Dung Minh Dao

Quick note on the definition of AI

Wed, 25 May 2022 20:13:33 +0700

As a final-year student who has some experience about artificial intelligence(AI) and machine learning (ML), it’s great for me to have a chance to revisit the definition of AI through the introductory course to AI at Stanford University - CS221 - which content is available online. This is also a chance for me to look back at the Introduction to AI course that I studied in my second year at Hanoi University of Science and Technology (HUST).

What is AI/ML for me, before this course?

After many days of reading online content about the definition of AI in my early years at the university, I finally came up and satisfied with a definition of AI that seem to be general enough. In my own expression: “Artificial Intelligence is any kind of simulation that exhibit a feature of intelligence”. This definition, to me, is acceptable for a number of reasons:

Some definitions equalize intelligence to human intelligence, which I believe is a limit to themselves. Animals exhibit some kinds of intelligence, and there can be types of intelligence that human don’t have.
Simulations are created by human in general, but the “simulation” here is meant to be equivalent to “artificial” - not occuring in the nature.
There are many type of intelligence and abilities associate with intelligence - as from Wikipedia, abstraction, logic, understanding, learning, emotional knowledge, etc. - and there is also no single definition for intelligence. So exhibition of one those traits is acceptable.

The definition of machine learning by Tom M. Mitchell in his book Machine Learning is commonly accepted by everyone:

“A computer program is said to learn from experience E with respect to some class of tasks T and performance measure P if its performance at tasks in T, as measured by P, improves with experience E.”

ML is often regarded as a subset of AI. The difference here is, ML has an element called “learning” - improvement of performance with more data/experience

My unanswered questions

You might ask “So what is the problem for you definition?”. Actually, I know that I can have a good definition for my own. The next step is what make me interested in: “How to categorize AI/ML in such a way that aligns well with some aspects of natural intelligence?”. In fact, there are already some common ways of categorizing AI or ML:

Grouping by learning methods: supervised learning, unsupervised learning, reinforcement learning,…
Grouping by type of tasks: computer vision, natural language processing, speech processing,…

While these groupings are useful, I’m still not contented, since they are unnatural:

The groupings just “split” problems in AI/ML into group according to human-defined concepts (e.g: supervised) or functionalities of human (e.g: see - computer vision, or speak - speech processing) - which ignores general aspects of intelligence (e.g: logic, abstraction) mentioned above
There is not much thing to compare between groups. There isn’t seem to exist a scale from “low” to “high” to measure any aspect of each category in comparison with other categories

Introduction to AI course at my university, and my doubt

These are topics that were mentioned in my AI class:

Searching problems: tree methods (BFS, DFS), heuristic methods, constraint satisfaction problem (CSP)
Logic: Propositional logic, First-order logic
Machine learning: Some common methods (kNN, naive bayes, decision tree, neural network)

Studying this course made me feel that there wass some kind of ordered categorization here. Maybe the difficulty of the problems is the scale that I’m looking for? Or, the scale is based on how abstract the problems are?

At the beginnning of the course, there was an introduction and overview of AI history. However, we students were not told why the course was structured in that way - we only knew the topics.

What I learned and deduced from Stanford’s AI course

First, from the view of this course’s lecturer, there are 3 pillars to AI: Modeling (create a mathematical/logical representation of the real world), Inference (answer questions about models, e.g: shortest path, winning strategy), and Learning (transform an abstract model into a concrete one, with the help from additional data).

The below image pretty much sums up the categorization of AI/ML problem/model types used in this course. They are sorted by the “low-high” level of intelligence:

Reflex-based model is a fixed sequence of computations to get the output. This is equivalent to daily reflexive task that we can do very quickly, such as recognizing an object in the house
State-based model considers available states and actions at each state, as well as plan the step-by-step actions that will followed. This is the model of some of our favorite games such as chess and go, or some riddles for children like the prisoners’ dilemma
Variable-based model deals with assignment of variable with respect to some factors/conditions, regardless of order. Sudoku is a game that can be well-modelled in this category.
Logic-based model can digest heterogeneous information into some syntax and semantic representations, and reason deeply using inference rules. The common logical analysis we often do in daily life can be represented by this type of model.

So there is an ordered categorization here!!!. A great news for me. However, to make the ordering clearer, I read through the course and try to make some scales to organize the problems/models according to the 3 pillars mentioned above. Here is my own summary of analysis, based on what I learned from the course:

Pillar	Reflex	States	Variables	Logic	Conclusion
Modeling	abstract model, “massive lookup table of best actions”	local interactions between states (like in graph)	solutions are assigned to variables (lots of possibilities)	syntax and semantics, highly expressive	Models get simpler and more expressive. Moving from abstract → concrete (less learning)
Inference	follow a fixed sequence of steps to get the output	combine local interactions to get optimization solutions	find assignments to variables, or probabilistic inference	draw (deep) logical reasoning from knowledge, but rules can be deterministic	Inference gets more complex, and handles less uncertainty
Learning	have to learn from (lots of) data	get data through exploration action	need few data, incorporate prior domain knowledge	rule-based, don’t allow fine-tuning through data	Learning gets easier - but lower ability to fine-tune through additional data

Conclusion

In the end, I have found what I need: an ordered grouping that “aligns well with some aspects of natural intelligence”. This categorization also fill in the hole of my understanding about how my university’s Introduction to AI course was structured.

Needless to say, there are many topics covered in this course. I think this is a very good course for anyone who want to get an overview of what AI is, and it can also be a starting point to find out more on specific topics of AI/ML.

Reference

Background image: https://upload.wikimedia.org/wikipedia/commons/thumb/4/42/Artificial-Intelligence.jpg/1024px-Artificial-Intelligence.jpg
CS221 - Spring 2022 lecture slides (and image references): https://stanford-cs221.github.io/spring2022/modules/
Intelligence - Wikipedia: https://en.wikipedia.org/wiki/Intelligence

Chiến tranh Chechnya

Thu, 19 May 2022 10:01:59 +0700

Machine Learning Operation (MLOps) Courses Review

Wed, 18 May 2022 08:59:52 +0700

Hi. This is the first course review I’ve ever done on my blog, and today I will review the 2 series of courses on the same topic: Machine Learning Operations, or MLOps for short.

What to expect in this review:

An overview of what these programs do and don’t provide
The topics that are focused in each series and technological stacks used
Methods of teaching, reviewing, and testing
My experience studying each of these programs: what I find interesting (and what need to be improved)

What NOT to expect in my review:

Details on each of the topics (though I do provide some insights)
How to complete each projects and tests

Why should you care about MLOps?

For most of beginners in Machine Learning or AI, it is a common practice to use notebooks and simple files to do experiments with readily available datasets, run and fine-tune a number of models. While this could be a good starting point for developing practical models, things are quite different in the production scenarios.

I will not list all of the cumbersome theoretical and practical issues here, as the readers can easily search for posts on the topic of MLOps, as well as find some insights on the problems that MLOps solves through the rest of my course review. However, here is a simple summary of some of the problems that MLOps can provide solutions:

The real-world data are constantly changing, which needs investigation to take action
ML models need to be easy to run, fine-tune, and track to ensure good performances
The ML project code should be organized in a pipeline with tracked dependencies for reproducibility and fault tolerance
When put into production, model performance should be constantly monitored and retraining should be trigger when there is a significant performance downgrade
Model fairness, information securities,… are also problems for MLOps to deal with

ML system in production

Figure 1: This is how production ML system looks like

You can see that in the end of the day, ML engineers have to work with many other stakeholders - software engineers, data engineers, DevOps, customers, and managers - to implement a successful MLOps project.

A quick summary of courses and their providers

This topic is pretty new, and there are multiple approaches to deal with it. I have experience studying 2 series of courses on the topic of MLOps. The providers of these 2 courses have great reputation in organizing online courses in the topic of Machine Learning. Although these 2 programs are designed for a 3 to 4 months period of studying, it is personally beneficial for me to study each of these program in 1 month (as I can fully focus on MLOps topics). Links for these programs can be found at the reference part. Let’s have an overview:

Coursera Machine Learning Engineering for Production (MLOps) Specialization: Well, another specialization provided by DeepLearning.AI; and from the past experience with their famous ML courses, I had a great expectation that this would be an another wonderful journey. Coursera’s courses can be audited for free, or you can get a financial aid to study these courses at a reasonable price - and sometimes for free!
Udacity Nanodegree in Machine Learning DevOps Engineer: the first Nanodegree program I have ever taken, and I study this course as a part of training in my company. For the regular students, you can take the courses with the price of as low (or high?) as $120. The price goes with benefit, of course: in return, you will get personalized assessment and suggestion for your project submissions

Coursera MLOps Specialization

This is a series of 4 courses, the first course is an introduction, and each of the other 3 courses focus on a specific topic: Data Lifecycle, Modeling Pipelines, and Deploying in Production. TensorFlow Extended (TFX) platform is used for for creating production ML pipelines; the pipelines’ components are introduced throughout the last 3 courses. Besides, other libraries (ml_metdata, sklearn) and technological platform related to Tensorflow (such as Google Cloud Platform) are also frequently used. A basic familiarity with the Tensorflow library can help you in some scenarios.

TensorFlow Extended (TFX)

Figure 2: TensorFlow Extended Pipeline for production ML

In every course, there is a series of videos introducing new concepts. After a few videos, small quizzes are provided to test how well you understand these concepts, and there are also hand-on labs for practical experiences. Each course final score is determined by a combination of some specific quizzes and hand-on labs score.

Benefit of taking this program

This specialization introduce a lot of recent concept in Machine Learning and AI such as Semi-supervised learning, Neural Architecture Search (NAS), and Knowledge Distillation. I also find interesting recent techniques in handling data (feature transformation, feature selection) and working with models (quantization and pruning).

Using a common platform (TFX) for creating pipeline make the courses in this specialization well-connected and coherent. A wide range of tools revolves around Tensorflow, especially from Google Cloud Platform, also help me to explore the new tools to train and deploy models automatically.

Side notes: There are some guides provided by Qwiklabs that help learners gain familiarity with deploying ML models on Google Cloud Platform in this courses. I recommend checking out other courses from Qwiklabs for basic understanding of the whole platform. Signing up for a Qwiklabs account through Google and get into the first guide, you will receive 30-days of studying any courses for free. Check out the link: https://www.qwiklabs.com/

Figure 3: Vertex AI on GCP for end-to-end ML workflow (Course 4)

Drawback, or things that this program needs to improve

Unfortunately, this program requires basic knowledge in Deep Learning (e.g. completion of the Deep Learning Specialization) for comprehension of the recent concepts mentioned above, so it’s quite difficult for learners with knowledge in just traditional Machine Learning algorithms to understand many parts in these courses.

Since the topic of the specialization is about MLOps, too much advanced or in-depth discussion on a specific state-of-the-art Machine Learning techniques can distract the learners from the main purpose.

The hand-on labs provided are great in the knowledge provided; however, there aren’t much room for creativity and most of the time, learners just have to follow the instruction provided in the description in the notebooks or the guidelines in external labs to complete the graded exercises. This has 2 main disadvantages:

It is difficult to remember the knowledge provided if you just follow the instructions and not doing something for yourself. The course can be quite tedious sometimes.
There are no project to complete for your own goods. Personally, I think that pushing projects you have done in the course to GitHub can help showing your ability and skill to recruiters a lot.

Udacity ML DevOps Nanodegree

This Nanodegree is also divided into 4 courses.

The first course helps developing skills that are necessary for production models, includes clean code, version control, testing and logging.
The second course focuses on building a organized and reproducible end-to-end machine learning pipeline from scratch using MLFlow. Besides, experiments, codes and results are tracked using Github and Wandb (Weights and Biases)
The third course teaches students about model deployment. Data Version Control (DVC) is used for data and models, and CI/CD workflow is built with Github Actions and Heroku.
The final course is about automating all the stuffs mentioned above with DevOps process, including diagnose operational issues, as well as retraining and redeployment of models

Videos are used for introducing new concepts to the learners in each course. After each concepts, there are questions and programming exercises (not counted toward the final course accomplishment) for students to reinforce their knowledge on the topic. Finally, after completing all the lessons, there is a final project for each course, which students have to complete and satisfy all the requirements in the rubric to get pass the project.

Figure 4: Experiments and model tracking using Wandb (second project, my implementation)

Benefit of taking this program

First of all, this Nanodegree doesn’t require you to have knowledge in Deep Learning; in fact, all the model used in the courses are simple traditional Machine Learning models. This is a great way to introduce MLOps concepts without going too much into other sophisticated methods specific to handling data or models.

There are also multiple technologies introduced in this program. However, compared to the Coursera’s technological stacks, the tools in this course are easier to learn and apply in practice. The deployment part using CI/CD is one of the most challenging but rewarding part that I have learned in doing the projects.

I find this Nanodegree’s projects very exciting to complete. There are many requirements in the rubrics, but it still create many rooms for my own creativity and improvements. Since not everything is provided readily like in the Coursera MLOps’ hand-on labs, I have the experience of implementing from scratch for some parts of the project, which strengthen my ability to use the tools and reinforce my understanding of the concepts and the whole system.

Last but not least, the personalized assessment and suggestion for project submissions gives me lots of insight on how to improve my implementation and best practices in MLOps.

Figure 5: ML system that allows scheduled re-train, re-deploy, monitor, and report on the model (final project)

Drawback, or things that this program needs to improve

Compared to the DeepLearningAI’s specialization, this Nanodegree doesn’t have implementation of MLOps for Deep Learning models. This is a drawback, since the MLOps process benefit the most for that type of model - which require frequent training, fine-tuning, and deployment compared to traditional one.

There are trade-off in introducing a number of different libraries and focusing on a specific tools. From my point of view, the concepts are presented in an organized manner, but it can still be a challenge for other learners to keep track of all the technologies used.

Summary and final words

I found the 2 courses to be very comprehensive and contain interesting materials. These knowledge from the 2 courses can supplement each other very well, and I recommend taking both of these courses if possible. But for further recommendation:

If you do not have experience with Deep Learning beforehand, or you want to study the concept of MLOps without focusing too much on advanced details, the Udacity Nanodegree program is definitely the better choice.
If you want to know the state-of-the-art techniques in AI - especially for Deep Learning models - and get used to the TensorFlow-related libraries and Google Cloud Platform, then the Coursera Specialization is the way to go.

A special thanks to my mentor at FPT Software AI Center, Dr. Khuong Nguyen, for recommending me these courses. Studying these courses helps me a lot to become a better Data Scientest and AI Engineer/Researcher.

There are some images in the post, some are mine, some are from the Internet, and it’s free to use as in the LICENSE below. But I always leave credit here to support authors, and so do you if you want to use content in my article.

References

Image sources:
Reference courses:
- Coursera Machine Learning Engineering for Production (MLOps) Specialization
- Udacity Nanodegree in Machine Learning DevOps Engineer

Getting Used to GitHub, Eps. 3

Wed, 04 May 2022 21:55:37 +0700

Hi again. This is Dung Dao Minh, vice president of SoICT Innovation Club, and in this third post of series “Github 101”, I will talk about some kind of scenarios that can happen when you work on multiple branches in your work repositories, or work in collaboration with a team on a project.

First words

In many cases, you (and your collaborators) create multiple branches for different purpose: creating features, bug fixing, code versioning,… Most of the issues happen when you try to combine the code between those branches: you may realize that you still commit to the main branch while fixing bugs/adding features, another developer may add a little documentation on your code (which is great), or your evil coworker might mess up with your code and make it full of bugs. In short, there may be some modification on the branch you are trying to merge into, that you need to resolve to (happily) combine the two different commits.

I will create (with additional references from other sources) some different scenarios here that represent the problem you might face when working on different branches, and make it easy to introduce some new definition, as well as some good practices when working with Git and Github

Scenario #1: Working on new feature (no file conflict yet)

Suppose that you are working on a project about real estate recommendation system, and you want to try using location information for your system. In the middle of your work, your boss want you to focus 100% of your time on improving system based on demographic information.

Step 1: assume that you are on the develop branch. You should create a new branch location for developing the new feature:

# Create and switch to new branch
git checkout -b location
# Commit as you go 
git commit -m "add recommendation based on city'

Step 2: however, you boss want you to focus on demographic features. You have not completed the location feature yet

# Switch back to the develop branch
git checkout develop
# Create and switch to `demographic` branch
git checkout -b demographic
# Working on that branch and commit changes
git commit -m "finalized demographic-based recommendation"

Step 3: after you finish your work on demographic feature, you can merge it to the develop branch and push this to the remote origin/develop branch (assuming that both develop and origin/develop have no additional commit in the mean time)

# Switch back to the develop branch
git checkout develop
# Merge the `demographic` branch into the `develop` branch
git merge --no-ff demographic
# Push to the remote repository
git push origin develop

Quick note on `merge`: fast-forward vs. no fast-forward

You might see the --no-ff (no fast-forward) in the step 3 above. The new demographic code seems to only add new code, without any modification.

A picture is worth a thousand words:

Fast forward

--no-ff will create a new commit (with new id, but the file content is the same), while by default, git merge will fast-forward - moving your branch pointer (in this case, at develop) to point at the incoming commit (from demographic).

Note: when you merge with --no-ff, as a new commit is created, you might be asked to create message for that commit.

In many cases, you want to prevent fast-forward from happening, because you want to maintain a specific branch “shape”, and someone (your manager) can read the history of changes that you made from creating the demographic branch (instead of losing information when fast-forward)

You can change you command or do some setups to merge with or without feed-forward:

# Execute for once: add the `--ff-only`, or `--no-ff` flag
# Apply for both pull and merge (pull = fetch + merge)
git pull --ff-only
git pull --no-ff
# Using git config to do it by default 
# (git pull or git merge won't need specific flag)
git config --add merge.ff false
git config --add merge.ff only

Scenario #2: Same file names, different file contents on different branches (conflict)

You might wonder what’s the purpose of the location branch created above. Now I will use it to demonstrate merge conflict.

In a bad mood, you forgot that you create that location branch for experimenting with location data, and you do some commit directly on the develop branch to work with that data. Let review some of the recent commits you made (notice the HEAD->location (current branch) at commit f3b1b57 and the develop branch at commit 9a5187c)

git log --graph --decorate --oneline --all

* 9a5187c (develop) add recommendation based on city in develop
*   1fe34c7 Merge branch 'demographic' into develop
|\  
| * 0883fd7 (demographic) finalized demographic-based recommendation
|/  
| * f3b1b57 (HEAD -> location) add recommendation based on city
|/  
* b3a463a (origin/develop) Create develop branch

For simple demonstration purpose, here are the 2 versions of location.txt on that 2 branches:

# On `develop` branch
location file in develop

# On `location` branch
location file

Some ways you might consider to resolve the conflict

When you realize the mistake, there are some cases here:

Case 1: You recognize that there are part of the features you develop from both branches would be useful, and you want to combine them together.

Run the command git merge develop will create the following message:

Auto-merging location.txt
CONFLICT (add/add): Merge conflict in location.txt
Automatic merge failed; fix conflicts and then commit the result.

This is inevitable, since the 2 files have different contents inside. Inside the location.txt file, you can see that the content has been modified. The upper part is the line of the current commit pointed by HEAD and the lower part is the

<<<<<<< HEAD
location file
=======
location file in develop
>>>>>>> develop

Check git status for additional understanding:

On branch location
You have unmerged paths.
...
Unmerged paths:
  (use "git add <file>..." to mark resolution)
        both added:      location.txt

To resolve the problem, simply modify the location.txt file as you wish (obviously, you don’t want those “«<” or “===” characters anyway) and add it to the staging area, then create a new commit. Here I will modify the text into “location file after resolve conflict”:

git add location.txt
git status
# On branch location
# All conflicts fixed but you are still merging.
# ...

git commit -m "resolve conflict in location feature"
git log --graph --decorate --oneline --all

# Now we see that the `location` branch has new commit
*   1f79c56 (location) resolve conflict in location feature
|\  
| * 9a5187c (HEAD -> develop) add recommendation based on city in develop
| *   1fe34c7 Merge branch 'demographic' into develop

Case 2: You have done a far better work in the develop branch, and you don’t need the same code on location branch anymore. Or the other way around, you soon realize the mistake, and the location branch has more valuable code

The obvious solution is to use the code in develop instead of that code on location, or the other way around. You can use the approach in Case 1, observing that in some IDE, they support you with choosing the respective version you want. An example in VSCode (you can accept either change or both changes):

Conflict VSCode

A quicker way is to use additional flags, in favor of one of the branch (ours strategy refer to preference of the current branch, and theirs is the preference of the incoming branch):

git merge --strategy=ours develop
git merge -X theirs develop

Note: -s or --strategy completely ignore the other side, while -X or --strategy-option resolve any conflicts using the chosen side.

Additional note: `merge` vs `rebase`, and options for `git pull`

Perhaps some animation is great here (acknowledgement to Nicola Paolucci’s post with the animations). Click on animated images to see how it works:

Merge

Rebase

You should use git rebase when your changes do not “deserve” a separate branch for its own. All the commands with merge above can also be done with rebase; note that it has a different behaviour as in the animations

When working with remote directories, if you want to rebase instead of merge after fetching changes, you can add --rebase flag to the pull command:

git pull = git fetch + git merge against tracking upstream branch
git pull --rebase = git fetch + git rebase against tracking upstream branch

Final words

The conflict in reality can be more complex, but in this episode, I have list the common cases you might face when you need to merge 2 branches together.

A scenario from the Udacity’s Machine Learning DevOps Engineer helps me a lot in creating a bunch of scenarios above: https://www.udacity.com/course/machine-learning-dev-ops-engineer-nanodegree--nd0821
Answers on StackOverflow that help me with explanation (and images) in the process:
Amazing images and explanations from Nicola Paolucci’s blog post: https://blog.developer.atlassian.com/pull-request-merge-strategies-the-great-debate/

Dung Minh Dao

Quick note on the definition of AI

What is AI/ML for me, before this course?

My unanswered questions

Introduction to AI course at my university, and my doubt

What I learned and deduced from Stanford’s AI course

Conclusion

Reference

Chiến tranh Chechnya

Machine Learning Operation (MLOps) Courses Review

Why should you care about MLOps?

A quick summary of courses and their providers

Coursera MLOps Specialization

Benefit of taking this program

Drawback, or things that this program needs to improve

Udacity ML DevOps Nanodegree

Benefit of taking this program

Drawback, or things that this program needs to improve

Summary and final words

References

Getting Used to GitHub, Eps. 3

First words

Scenario #1: Working on new feature (no file conflict yet)

Quick note on merge: fast-forward vs. no fast-forward

Scenario #2: Same file names, different file contents on different branches (conflict)

Some ways you might consider to resolve the conflict

Additional note: merge vs rebase, and options for git pull

Final words

Quick note on `merge`: fast-forward vs. no fast-forward

Additional note: `merge` vs `rebase`, and options for `git pull`