AI Engineer Roadmap

Python is the lingua franca of AI. Every framework, every library, every deployment tool speaks Python. You don't need to be a Python expert on day one, but you need to be fluent enough to express any idea without fighting the language.

Core topics:

• Data types and structures — ints, floats, strings, lists, tuples, dicts, sets. Know when to use each. List comprehensions and dict unpacking are daily tools.
• Control flow — loops (for, while), conditionals, try/except/finally, context managers (with statements). Exception handling is how real code survives.
• Functions — def, arguments, keyword args, *args / **kwargs, lambda functions, type hints. Type hints aren't optional in professional code — they're documentation that the IDE reads.
• Object-oriented programming — classes, inheritance, dunder methods (__init__, __repr__, __str__), properties, and composition over inheritance.
• Decorators and generators — decorators wrap functions (used heavily by FastAPI and Flask). Generators yield values lazily — essential for processing datasets that don't fit in memory.

You don't need a maths degree to be an AI engineer. But you do need intuition for the three mathematical pillars of machine learning. Focus on understanding why things work, not on memorising formulas.

• Linear algebra — vectors (addition, dot product, magnitude), matrices (multiplication, transpose, inverse), eigenvalues and eigenvectors. The dot product is the single most important operation in ML (it's how attention works, how embeddings compare, how neural networks compute).
• Calculus — derivatives (what a derivative tells you about a function's slope), partial derivatives, the chain rule, gradients. Gradient descent is just "follow the slope downhill" extended to high dimensions.
• Probability — probability distributions (normal, binomial, uniform), conditional probability, Bayes' theorem, expected value. Bayesian thinking is the foundation of uncertainty estimation in ML.

Three essential resources for building intuition:

• 3Blue1Brown's "Essence of Linear Algebra" — best visual explanations on YouTube
• StatQuest for probability and statistics — clear, simple, no fluff
• Khan Academy's calculus course — work through derivatives and gradient sections

If Python is your hammer, the terminal is your workbench. Git is how you save your progress and collaborate. These aren't optional — they're the tools you'll use every minute of every workday.

Git essentials:

• init, add, commit, push, pull — the basic rhythm
• branch, checkout, merge — feature branches prevent chaos
• rebase, stash, log, diff — debugging your history
• Resolving merge conflicts — they happen daily, learn to handle them calmly

CLI essentials:

• Navigating: ls, cd, pwd, find, tree
• File ops: cp, mv, rm, cat, head, tail, grep
• Processes: ps, top, kill, nohup
• Permissions: chmod, chown

Your Month 1 project is a command-line data analysis tool. It reads CSV files, computes statistics (mean, median, std dev), generates simple reports, and outputs formatted tables. This project ties together Python, CLI, and Git.

What you'll build:

• Python script with argparse for CLI arguments
• Read CSV with Python's csv module (no Pandas yet)
• Compute summary statistics per column
• Generate a Markdown report file
• Version-controlled with Git (multiple branches)

Extensions: add filtering, grouping, JSON/Excel output, and basic plotting with matplotlib.

NumPy gives you fast numerical operations on arrays and matrices. Pandas adds labelled data structures (DataFrames and Series) on top. Together they handle 95% of data manipulation in the ML workflow.

NumPy essentials:

• Arrays vs Python lists — memory efficiency and vectorised operations
• Indexing, slicing, reshaping (reshape, flatten, transpose)
• Universal functions (ufuncs) — element-wise operations without loops
• Broadcasting — operating on arrays of different shapes
• Linear algebra: np.dot, np.linalg.inv, np.linalg.eig

Pandas essentials:

• Creating DataFrames from CSV, JSON, dicts
• Selecting rows/columns with loc, iloc, boolean indexing
• Handling missing data: isna(), fillna(), dropna()
• Group operations: groupby(), agg(), apply()
• Merging and joining DataFrames

Visualisation is the fastest way to spot patterns, outliers, and data quality issues. matplotlib and seaborn are the standard tools.

• matplotlib — the foundation. Figure and axes objects, line plots, scatter plots, histograms, subplots. Learn to customise: titles, labels, legends, colours.
• seaborn — higher-level API built on matplotlib. Beautiful defaults. Key plots: pairplot() (scatter matrix), heatmap() (correlation matrix), boxplot(), violinplot(), countplot().
• What to look for: missing values patterns, skewed distributions, outliers, correlations, class imbalances. Every insight you gain from visualisation is one less assumption that breaks in production.

Before you touch any algorithm, understand the principles that govern them all. These concepts are the foundation you'll refer back to for your entire career.

• Supervised vs unsupervised vs reinforcement learning — labelled data vs patterns without labels vs learning through interaction. Most of your early work will be supervised.
• Train/test split — you never evaluate on data the model has seen. The split is sacred. Typical splits: 80/20 or 70/30.
• Overfitting and underfitting — a model that memorises the training data (high variance) vs one that's too simple to capture the pattern (high bias). The bias-variance tradeoff is the central tension in ML.
• Cross-validation — splitting data into K folds, training on K-1 and evaluating on the held-out fold. K=5 or K=10 are standard. CV gives a more reliable performance estimate than a single split.
• Feature engineering and scaling — the quality of your features determines the ceiling of your model's performance. Normalise or standardise numeric features for most algorithms.

These algorithms are the foundation of classical ML. Some (random forests) still win Kaggle competitions. Others (linear/logistic regression) are essential baselines for any problem.

• Linear regression — predicts a continuous value. Assumes linear relationship between features and target. Simple, interpretable, fast. The first thing you try on any regression problem.
• Logistic regression — despite the name, it's for classification. Applies sigmoid function to linear output to produce probabilities between 0 and 1. Great baseline for binary classification.
• Decision trees — hierarchical if/else rules learned from data. Interpretable but prone to overfitting. The building block for ensemble methods.
• Random forests — hundreds of decision trees trained on random subsets of data and features. Averages their predictions. Robust, handles non-linear relationships, no feature scaling needed.
• Support vector machines (SVMs) — find the hyperplane that maximises the margin between classes. Works well with kernel tricks for non-linear boundaries. Good for medium-sized datasets.

scikit-learn is the standard library for classical ML in Python. Its consistent API — fit(), predict(), transform() — means once you learn one model, you know them all. The standard workflow:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

model = RandomForestClassifier(n_estimators=100)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

Pipeline essentials: Pipeline chains preprocessing and modelling into one object. GridSearchCV automates hyperparameter tuning with cross-validation. ColumnTransformer applies different transformations to different columns.

These three tools — Pipeline, GridSearchCV, ColumnTransformer — are what separate beginner scikit-learn code from professional code.

Choosing the right metric is as important as choosing the right algorithm. The wrong metric can make a bad model look good.

• Accuracy — correct predictions / total predictions. Misleading on imbalanced datasets (99% accuracy on data with 99% one class).
• Precision — true positives / (true positives + false positives). "When we predict positive, how often are we right?"
• Recall — true positives / (true positives + false negatives). "Of all actual positives, how many did we find?"
• F1 score — harmonic mean of precision and recall. Balances both. Good default for classification.
• ROC-AUC — area under the receiver operating characteristic curve. Measures the model's ability to distinguish between classes at all thresholds. 0.5 = random, 1.0 = perfect.

A neural network is a stack of matrix multiplications with non-linear activation functions in between. Every neuron computes a weighted sum of its inputs, passes it through an activation function, and sends the result forward. Stack enough of these layers and you can approximate any function — this is the Universal Approximation Theorem.

• The perceptron — a single neuron with a step activation. Linearly separable problems only. The foundation everything builds on.
• Activation functions — ReLU (most common), sigmoid (for binary classification output), tanh, softmax (for multi-class). Each has a specific purpose.
• Forward propagation — input → hidden layers → output. Each layer is W·x + b, then activation.
• Backpropagation — the chain rule applied to compute gradients through all layers. The "learning" in deep learning. You don't implement it by hand (PyTorch does it for you), but you must understand what it does: it tells each weight how much it contributed to the error.

PyTorch is the most popular deep learning framework for research and production. Its key features are tensors (like NumPy arrays but GPU-accelerated) and autograd (automatic differentiation).

• Tensors — create from lists or NumPy arrays. Move to GPU with .cuda() or .to('cuda').
• Tensor operations — .view() (reshape), .permute(), indexing, broadcasting. All familiar from NumPy but GPU-accelerated.
• Autograd — set requires_grad=True. Every tensor operation builds a computation graph. Call .backward() to compute all gradients. This is the magic that makes training possible.
• Gradients — after loss.backward(), each tensor has .grad populated with the gradient of the loss with respect to that tensor.

import torch

x = torch.tensor([1., 2., 3.], requires_grad=True)
y = (x ** 2).sum()
y.backward()
print(x.grad)  # tensor([2., 4., 6.])

PyTorch provides abstractions for data loading and model building that make training repeatable and scalable. These patterns are used in every PyTorch project.

• Dataset and DataLoader — subclass torch.utils.data.Dataset to define your data. Wrap in DataLoader for batching, shuffling, and parallel loading with multiple workers.
• nn.Module — subclass to define your model. Define layers in __init__, implement forward pass in forward(). Compose layers with nn.Sequential for simple networks.
• Loss functions and optimisers — nn.CrossEntropyLoss for classification, nn.MSELoss for regression. optim.Adam is the default optimiser (adaptive learning rate, works well out of the box).

model = nn.Sequential(
    nn.Linear(784, 256),
    nn.ReLU(),
    nn.Linear(256, 10)
)
optimizer = optim.Adam(model.parameters(), lr=0.001)
for epoch in range(10):
    for xb, yb in dataloader:
        pred = model(xb)
        loss = loss_fn(pred, yb)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

CNNs are designed for grid-structured data — images above all. Instead of dense connections (every neuron to every other), CNNs use sliding filters (kernels) that learn local patterns.

• Convolution — a filter slides over the input, computing dot products at each position. Produces a feature map showing where patterns were detected. Multiple filters → multiple feature maps.
• Pooling — downsampling operation (usually max pooling) that reduces spatial dimensions and adds translation invariance. Common: 2×2 max pool with stride 2 halves the size.
• LeNet-5 — the original CNN (1998). Conv → Pool → Conv → Pool → FC. Still a valid pattern for simple problems.
• ResNet — introduced skip connections (residual connections) that allow training very deep networks (50+ layers) by letting gradients flow directly through the identity path. The breakthrough that made deep networks practical.

Start with a simple ConvNet on MNIST or CIFAR-10, then graduate to using a pretrained ResNet.

When data has a temporal or sequential structure (text, speech, stock prices), you need models that process one element at a time while maintaining state.

• RNNs — the simplest sequence model. Pass a hidden state from one timestep to the next. Suffers from vanishing gradients for long sequences. Good for short sequences only.
• LSTMs — Long Short-Term Memory. Adds forget, input, and output gates. Controls what to remember and forget. Handles long sequences (up to hundreds of tokens). Standard for sequence tasks before Transformers.
• Attention mechanism — "which part of the input should I focus on?" Attention computes weighted sums of input elements, where weights depend on the current context. The core idea behind Transformers.
• Transformers — "Attention is All You Need" (2017). No recurrence — process all tokens in parallel using self-attention. Positional encodings inject order information. The foundation of GPT, BERT, and every modern LLM.

For Month 3, focus on understanding the attention mechanism conceptually and using PyTorch's built-in transformer layers.

Training a deep network from scratch requires massive data and compute. Transfer learning lets you take a model pretrained on a huge dataset (like ImageNet with 14 million images) and adapt it to your specific task with minimal data.

• Feature extraction — freeze the pretrained model's weights (except the final classification layer). The pretrained model acts as a sophisticated feature extractor. Replace the last layer with one for your task. Train only that layer.
• Fine-tuning — unfreeze some or all of the pretrained layers and train everything with a low learning rate. Adapts the pretrained features to your specific domain. Requires more data but often gives better results.
• Common pretrained models — ResNet, EfficientNet, ViT (Vision Transformer) for images. BERT, RoBERTa for text. Available in torchvision.models and transformers library.

Knowing the architecture is half the battle. Knowing how to train it is the other half. These techniques separate working models from stuck models.

• Learning rate scheduling — start with a higher LR, then decrease over time. Common schedules: StepLR (reduce by factor every N epochs), CosineAnnealing, ReduceLROnPlateau (reduce when validation loss plateaus).
• Regularisation — dropout (randomly zero out neurons during training), weight decay (L2 penalty on weights), data augmentation (create synthetic variations of training data). Each reduces overfitting.
• Batch normalisation — normalise layer inputs to have zero mean and unit variance. Stabilises training, allows higher learning rates, and provides some regularisation.
• Early stopping — monitor validation loss. Stop training when it hasn't improved for N epochs (patience). Saves time and prevents overfitting.
• Gradient clipping — cap gradient values to prevent exploding gradients in RNNs and deep networks. Simple but critical.

The combo that works for most projects: Adam optimiser + ReduceLROnPlateau + early stopping + moderate dropout (0.3–0.5).