AI Basics Learning Roadmap: AI, Machine Learning, and Deep Learning

Artificial intelligence is often introduced as if it were a single mysterious subject. If you already know how to program, a better starting point is to build a clear map: which ideas belong together, which tools are just implementation details, and which fundamentals you should practice repeatedly.

This article separates artificial intelligence, machine learning, and deep learning, then gives a practical learning path for programmers. The next posts in this series cover the machine learning workflow, model training and evaluation, neural networks, and a small Python classification project.

After reading it, you should be able to answer three questions: whether AI and machine learning are the same thing, why machine learning needs data and labels, and which foundations to learn next.

1. Start With Three Terms

The first source of confusion is usually this group of terms:

• Artificial intelligence: the broad goal of making software behave intelligently
• Machine learning: systems that learn patterns from data instead of relying only on hand-written rules
• Deep learning: a subset of machine learning that uses multi-layer neural networks

They are not separate boxes. The relationship is nested:

Artificial intelligence
└── Machine learning
    └── Deep learning

That means learning AI does not have to begin with training large models. A more stable path is to understand how data becomes a model, then move into neural networks and large-model applications.

2. Traditional Programming vs. Machine Learning

Traditional programming usually looks like this:

Rules + input data -> output

For example, if you write a leap-year function, the rule is explicitly written by the programmer. The input is a year, and the output is true or false.

Machine learning often looks more like this:

Input data + known answers -> learned rule
New input data + learned rule -> prediction

For spam classification, you probably cannot hand-write every useful rule. A common approach is to collect many emails with labels, then let a model learn which patterns are associated with spam.

This is the most important mindset shift for programmers: your code no longer describes every rule directly. It describes how the program should learn rules from data.

3. The Parts of a Basic AI Project

From an engineering perspective, a small machine learning project usually contains these steps:

1. Define the problem: classification, regression, clustering, ranking, or something else
2. Prepare the data: where it comes from, whether labels are reliable, and what each field means
3. Build features: convert raw records into numbers the model can use
4. Train the model: let the algorithm adjust parameters from training data
5. Evaluate results: test the model on data it has not seen during training
6. Use the model: place predictions inside a script, service, or product workflow

Beginners often focus too much on switching to a stronger model. In real projects, data quality, feature handling, and evaluation design are often more important.

4. What to Learn First

If you already know basic programming, start with these areas:

• Python basics: functions, lists, dictionaries, modules, virtual environments, and packages
• Data handling: CSV files, tabular data, missing values, and simple statistics
• Linear algebra intuition: vectors, matrices, and dot products without heavy proof work at the beginning
• Probability and statistics intuition: mean, variance, distributions, sampling, and correlation
• Model evaluation: train/test splits, accuracy, validation, and overfitting

You do not need to finish all of this before practicing. The better approach is to run small examples and fill the gaps as each concept appears.

5. A Practical Learning Order

A useful order for programmers is:

1. Understand the relationship between AI, machine learning, and deep learning
2. Learn supervised classification and regression
3. Understand training, validation, and test data
4. Learn loss functions, parameters, training epochs, and overfitting
5. Run a complete classification task with scikit-learn
6. Then move into neural networks, deep learning frameworks, and large-model applications

This order helps you understand why a model can learn from data before you deal with larger frameworks and more complex model architectures.

6. What Not to Rush

These can wait until the foundations are clearer:

• Training a large deep learning model as the first project
• Comparing models before understanding evaluation metrics
• Copying notebooks without explaining each input and output
• Confusing API usage with understanding AI fundamentals

Using existing models is valuable, but during foundation learning, the main goal is to understand how data enters a model, how predictions are produced, and how predictions are evaluated.

7. A Simple Self-Check

At this stage, you do not need to derive advanced formulas. You should, however, be able to explain these ideas in your own words:

• Why the same problem can sometimes be solved with hand-written rules or with machine learning
• What features and labels are, and what role they play during training
• Why training data and test data should not be mixed casually
• Why one run of one model is not enough to prove that a model is reliable

8. Learning Path Evidence Table

A learning roadmap should help readers decide what to practice and what evidence proves that the practice worked. The following table maps each foundation topic to a concrete output.

How much mathematics do you actually need

“AI requires strong mathematics” discourages a lot of people, and it is too vague to act on. A more useful framing separates being able to read it from being able to derive it — the overwhelming majority of applied work needs only the former.

What you must be able to read (about ninety percent of actual usage):

• The shape rule for matrix multiplication. (m×n) × (n×k) = (m×k). You do not need to compute a 4×4 product by hand, but you must be able to see at a glance whether two tensors can multiply and what shape results. Shape mismatch is the single most frequent error in deep learning, and this one rule resolves most of them.
• That a derivative means “rate of change.” Not computing derivatives of complicated functions, but understanding that “the gradient tells you which direction to move a parameter to reduce the loss.”
• Basic probability distributions and expectation. Model outputs are probabilities and loss functions are frequently expectations; reading the formulas requires this.

What you can defer: deriving backpropagation’s chain rule by hand, the full matrix-calculus identities, measure-theoretic probability, convergence proofs from optimisation theory. All are useful for reading papers and doing research, and none are needed at the stage of “get a model running and judge whether it is trustworthy.”

A self-test: looking at the line y = softmax(Wx + b), can you say what determines W’s shape, why b is one-dimensional, and what range the values take after softmax? If yes, you have enough to start. If not, fill in that specific gap rather than restarting linear algebra from the beginning.

On sequencing, learn the mathematics you need when you need it. Looking something up with a concrete problem in hand is far more efficient than studying systematically then trying to apply it — the latter typically ends with linear algebra completed and no idea how it connects to model code.

You do not need to “finish” Python first

Another common stall is “my Python is not strong enough yet; I will start once it is.” That ordering keeps people in the preparation phase indefinitely.

The subset of Python that machine learning code actually uses is narrow — roughly this:

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])   # create an array
a.shape                                 # (2, 3) -- the single most-used line
a[:, 1]                                 # slicing: take the second column
a[a > 3]                                # boolean indexing
a.reshape(3, 2)                         # change shape
a.mean(axis=0)                          # aggregate along an axis

xs = [f(x) for x in data if ok(x)]      # list comprehension
for i, x in enumerate(data): ...        # iterate with index
for a, b in zip(xs, ys): ...            # iterate in parallel

Getting fluent with the above, plus being able to read error messages, is enough to start running models. Decorators, metaclasses, async and context managers are essentially unused at this stage — learn them when a real need appears, and they will actually stick.

The item most worth investing in early is shape and the concept of axes. A large fraction of deep learning debugging is tracking tensor shapes, and building the habit of printing the shape at every step is worth considerably more than several additional language features.

9. How to Read This Series

This first article gives the map. The next articles expand the workflow in order:

• Machine Learning Workflow: from data and features to predictions
• Model Training and Evaluation: loss, overfitting, and metrics
• Neural Network Basics: from perceptrons to multi-layer networks
• Python AI Mini Practice: a classification task with scikit-learn

The goal is not to memorize as many AI terms as possible. The goal is to take a small problem and clearly explain what the data is, what the target is, what the model learns, and how to verify whether it learned something useful.