AI Engineer "Post-Basics" To-Do List

Phase 1: Deepening Your PyTorch Mastery

(Goal: Move beyond boilerplate. Understand the internals and write modular,
reusable code.)

[ ] Refactor the Training Loop:

Take your standard training loop and encapsulate it within a Python
class (e.g., class Trainer: ). The class should handle the model,
optimizer, data loaders, and training logic.
Implement simple "callbacks." For example, create a callback
function/class that saves the model with the best validation
accuracy after each epoch. This mimics the functionality of high-
level libraries and shows good design patterns.
[ ] Master Data Handling with Dataset and DataLoader :
Write a custom Dataset class from scratch for a non-trivial dataset
(e.g., one with images and corresponding JSON metadata). You must
implement __len__ and __getitem__ .
Create a complex data augmentation pipeline using
[Link] . Go beyond simple resizing and flipping;
experiment with color jitter, random erasing, etc. Understand their
impact on overfitting.
[ ] Deconstruct a Famous Architecture:
Pick a block from a well-known CNN, like a ResNet "residual block"
or an Inception module.
Implement it yourself from scratch in a [Link] . Do not just copy-
paste. Understand the path of the tensors, the channel dimensions at
each step, and why the skip connection in ResNet is important.
[ ] Investigate the Autograd Engine:
During a backward pass ( [Link]() ), stop your code with a
debugger ( pdb or your IDE's debugger).
Inspect the .grad attribute of your model's weight tensors
( [Link] ). Get a feel for how gradients are populated
and what they represent.
Manually call optimizer.zero_grad() and see the .grad attributes
become None . Internalize this critical step.

Phase 2: Implementing Advanced & State-of-the-Art Models

(Goal: Go beyond standard CNNs/LSTMs and tackle the architectures used in
today's most powerful models.)

[ ] Build and Fine-Tune a Transformer:

The Practical Skill: Use the Hugging Face transformers library to
fine-tune a pre-trained model (like DistilBERT or DeBERTa ) on a
custom text classification or question-answering task. This is a
core industry skill.
The Deep-Dive Skill: Implement a single multi-head self-attention
block from scratch. Write a Python function that takes Query, Key,
and Value tensors and performs the scaled dot-product attention.
This is the heart of the Transformer, and understanding it is a
major differentiator.
[ ] Implement a Generative Model:
Build a simple Deep Convolutional GAN (DCGAN) to generate images for
a basic dataset like MNIST or Fashion-MNIST.
You must write the Generator and Discriminator networks and manage
the adversarial training loop, alternating between training each
network. This teaches you about model stability and different loss
functions.
[ ] Explore Model Optimization:
Take a model you've already trained and apply Post-Training Static
Quantization using PyTorch's built-in tools ( [Link] ).
Measure the model size reduction and the performance (speed and
accuracy) before and after. Understand the trade-offs.

Phase 3: MLOps & Production-Ready Engineering

(Goal: Think like an engineer at a big company. Focus on reproducibility,

scalability, and deployment.)

[ ] Implement Robust Experiment Tracking:

Choose an experiment tracking tool like Weights & Biases or MLflow.
Integrate it into your training script. Log hyperparameters,
training/validation metrics (loss, accuracy), and save model
artifacts (checkpoints) automatically. Your days of printing loss to
the console are over.
[ ] Containerize Your Project with Docker:
Write a Dockerfile for one of your projects. It should define the
base image (e.g., pytorch/pytorch ), copy your source code, install
dependencies from a [Link] file, and define a command to
run training or inference.
 Successfully build the image and run the container. This proves your
project is reproducible.
[ ] Deploy a Model as an API:
Take a trained model checkpoint ( .pth file).
Use a web framework like FastAPI to build a simple REST API around
it. Create an endpoint (e.g., /predict ) that accepts input data
(like an image or text), runs inference with your model, and returns
the prediction.
Combine this with the previous step: run your FastAPI application
inside a Docker container.
[ ] Write Unit Tests for Your ML Code:
Using a framework like pytest , write tests for the "non-ML" parts of
your code.
A great place to start: write a test for your custom Dataset class
to ensure it returns tensors of the correct shape and type.
Write a simple test to check that a dummy batch of data can pass
through your model's forward method without crashing. This is a
"smoke test" and is incredibly valuable.

Of course. This is an ambitious but achievable goal for a motivated

individual with existing foundational knowledge. The key will be
disciplined, project-focused learning.

Here is a 10-month intensive plan designed to advance your skills in LLMs,

Computer Vision, Machine Learning, Software Engineering, and advanced
C++/Python. This plan assumes you have a solid understanding of basic data
structures, algorithms, calculus, linear algebra, probability, and
introductory machine learning concepts.

Guiding Principles for this Plan

Theory and Practice: Each month combines theoretical learning with

hands-on coding and projects. You cannot master these topics through
reading alone.
Integration: Skills are not learned in isolation. Software engineering
practices are integrated throughout, and C++ is introduced for
performance-critical applications of Python-based ML systems.
Project-Based: The goal is a strong portfolio. Each month culminates in
a tangible output that you can add to your GitHub.
Discipline: This schedule requires significant daily commitment.
The 10-Month Advanced AI Engineer Plan

Month 1: Advanced ML & Deep Learning Foundations

Objective: Solidify the bedrock of modern ML and deep learning. Move

from knowing what they are to how and why they work mathematically and
practically.
Machine Learning Topics:
In-depth review of ensemble methods (Random Forests, Gradient
Boosting Machines like XGBoost/LightGBM), focusing on their
hyperparameters and optimization.
Probabilistic models: Bayesian inference, Gaussian Mixture Models
(GMMs), and Hidden Markov Models (HMMs).
Deep Learning Topics:
Deep dive into backpropagation, vanishing/exploding gradients.
Normalization layers: In-depth study of Batch Norm vs. Layer Norm
vs. Group Norm. Understand their use cases, especially Layer Norm's
importance in Transformers.
Advanced optimizers: Adam vs. AdamW, SGD with momentum. Understand
their update rules.
Activation functions: A deep look at ReLU, GELU, SiLU/Swish and
their properties.
Coding & Software Engineering Focus:
Python: Implement a simple neural network from scratch using only
NumPy to understand the mechanics of forward and backward passes.
Then, replicate it in PyTorch or TensorFlow 2.x to master the
framework's core APIs.
SE: Enforce a professional Git workflow for all your projects
(feature branches, pull requests). Use venv or conda for
environment management. Start writing unit tests for your model
components.

Month 2: The Transformer Architecture - The Universal Tool

Objective: Master the "Attention Is All You Need" paper and its
components. This is the foundation for most of the LLM topics and modern
CV models.
Topics:
 Tokenization: Go beyond basics. Study Byte-Pair Encoding (BPE),
WordPiece, and SentencePiece.
Embeddings: Review Word2Vec/GloVe, then focus on contextual
embeddings.
Positional Embeddings: Absolute (learned and sinusoidal), and an
introduction to Relative embeddings.
Self-Attention: The math behind Query, Key, Value (QKV). Scaled Dot-
Product Attention.
Multi-Head Attention: Understand its motivation (attending to
different representation subspaces).
Full Architecture: Encoder-only (BERT-style), Decoder-only (GPT-
style), and Encoder-Decoder (T5/BART-style). The role of residual
connections and Layer Normalization (Pre-LN vs. Post-LN).
Coding & Software Engineering Focus:
Python: The single most important project for this month is to
implement a Transformer block from scratch in PyTorch/TensorFlow.
You don't need to train it on a large corpus, but you must be able
to construct the model, pass data through it, and verify the tensor
shapes at each step.

Month 3: Advanced Computer Vision

Objective: Apply deep learning expertise to the vision domain, moving

from classic CNNs to Transformer-based approaches.
Topics:
Advanced CNN architectures: ResNets, DenseNets, Inception Networks.
Focus on the architectural innovations (residual connections, 1x1
convolutions).
Object Detection: R-CNN family (Faster R-CNN) vs. single-shot
detectors (YOLO, SSD). Understand the concepts of anchor boxes and
non-maximum suppression.
Image Segmentation: U-Net architecture for semantic segmentation.
Vision Transformers (ViT): Understand how an image is patched,
flattened, and fed into a standard Transformer. Compare its
performance and inductive bias against CNNs.
Coding & Software Engineering Focus:
Python: Fine-tune a pre-trained ViT model on a classification task.
Separately, build a project using a pre-trained YOLO model for real-
time object detection from a webcam feed.
Month 4: LLM Pre-training and Scaling

Objective: Understand how large-scale models are built from scratch.

Topics:
Pre-training Objectives:
Causal Language Modeling (e.g., GPT): Predicting the next token.
Masked Language Modeling (e.g., BERT): Filling in masked tokens.
Sequence-to-Sequence (e.g., T5): Denoising objectives.
Scaling Laws: Study the key papers (e.g., Chinchilla). Understand
the relationship between model size, dataset size, and compute for
optimal performance. Analyze model capacity curves.
Data Curation: The importance of high-quality, large-scale datasets.
Data cleaning, deduplication, and the role of synthetic data
generation.
Coding & Software Engineering Focus:
Python: You will not pre-train a large model, but you can simulate
it. Use Hugging Face libraries ( transformers , datasets ) to run a
from-scratch pre-training of a small model (e.g., GPT-2 small) on a
small, clean dataset (like TinyStories). This will teach you the
mechanics of the training loop, data collation, and saving
checkpoints.
SE: Learn the basics of distributed training concepts (Data
Parallelism vs. Model Parallelism). Read about frameworks like
DeepSpeed.

Month 5: LLM Fine-tuning and Alignment

Objective: Master the techniques for adapting pre-trained LLMs to

specific downstream tasks and making them helpful and harmless.
Topics:
Finetuning vs. Instruction Tuning (SFT): Understand the difference
in data format and objective.
Parameter-Efficient Fine-Tuning (PEFT): Study LoRA (Low-Rank
Adaptation) and QLoRA. Understand how they drastically reduce memory
requirements.
Reinforcement Learning from Human Feedback (RLHF): Learn the three-
stage process: 1) SFT, 2) Reward Model Training, 3) RL Optimization
(PPO).
Direct Preference Optimization (DPO): A more recent, simpler
alternative to RLHF.
 Coding & Software Engineering Focus:
Python: Take a pre-trained open-source model (e.g., Llama, Mistral)
and perform instruction fine-tuning using LoRA on a public dataset
(e.g., the Alpaca dataset). This is a critical portfolio project.

Month 6: Advanced LLM Architectures

Objective: Go deep on the specific architectural innovations mentioned

in your list that enable modern model performance.
Topics:
Mixture of Experts (MoE): How routing layers work, the concept of
experts, and how it enables scaling model size while keeping
inference cost constant (e.g., Mixtral-8x7B).
Attention Variants: Grouped-Query Attention (GQA) and Multi-Query
Attention (MQA). Understand how they reduce the size of the KV
cache.
Advanced Positional Embeddings: Rotary Positional Embedding (RoPE)
and ALiBi. Understand how they improve long-context performance.
Long Context Tricks: Sliding Window Attention (used in Mistral), and
concepts like Infini-Attention.
Coding & Software Engineering Focus:
Python: This month is more theoretical, but you should dive into the
source code of models that implement these features. Use the Hugging
Face transformers library to load a model like Mistral-7B and explore
its configuration and layer definitions to see GQA and sliding
window attention in practice.

Month 7: LLM Inference and Quantization

Objective: Understand how to run LLMs efficiently after they are

trained.
Topics:
Autoregressive Sampling: The mechanics of generating text token-by-
token.
Sampling Parameters: Temperature, Top-k, Top-p.
KV Cache: A deep dive into why this is the single most important
optimization for fast inference.
Quantization: Post-Training Quantization (PTQ) vs. Quantization-
Aware Training (QAT). Study popular formats and methods like GGUF
 (for CPU), AWQ, and GPTQ.
Inference Stacks: Learn what problems are solved by tools like vLLM
(PagedAttention), TensorRT-LLM, and Text Generation Inference (TGI).
Coding & Software Engineering Focus:
Python: Use the transformers library's generate function and
experiment heavily with different sampling parameters to develop an
intuition for their effects.
C++: Download and compile [Link] . This is your entry into high-
performance C++ for AI. Run a quantized GGUF model on your CPU.
Begin to read and understand the [Link] source code. It is a
masterclass in C++ optimization for LLMs.

Month 8: C++ for High-Performance AI

Objective: Develop advanced C++ skills specifically for accelerating ML

workloads.
Topics:
Modern C++ (17/20): Focus on performance features like move
semantics, smart pointers, and concurrency ( std::thread , std::async ).
Interfacing C++ and Python: Learn Pybind11 to expose C++ functions
and classes to Python.
High-Performance Libraries: Use a C++ linear algebra library like
Eigen.
Inference Engines: Study the high-level architecture of ONNX
Runtime. Understand how a graph is received and executed by
optimized C++ kernels.
Coding & Software Engineering Focus:
C++ / Python: Identify a performance bottleneck in one of your
previous Python projects (e.g., a specific data preprocessing step
or a custom model layer). Re-implement that component in C++ with
Eigen, create Python bindings using Pybind11, and benchmark the
speedup.

Month 9: MLOps and Production Systems

Objective: Learn to deploy, serve, and maintain your models as robust

software.
Topics:
 Containerization: Docker. Create Dockerfiles for your ML
applications.
Model Serving: Build REST APIs for your models using FastAPI
(Python).
CI/CD (Continuous Integration/Continuous Deployment): Use GitHub
Actions to automate testing and even model deployment.
Vector Databases & RAG: Understand what vector databases (e.g.,
Chroma, Pinecone) are and their role in Retrieval-Augmented
Generation (RAG) systems.
Coding & Software Engineering Focus:
Full Stack Project: Build a complete RAG application. This will
involve:
1. A script to embed documents (using a sentence-transformer) and
store them in a local ChromaDB instance.
2. A FastAPI backend that takes a user query, retrieves relevant
documents from ChromaDB, and passes them as context to an LLM
(via an API like [Link] or a locally run model) to generate
an answer.
3. Containerize the entire application with Docker.

Month 10: Capstone Project & Portfolio Polish

Objective: Synthesize all your knowledge into a single, impressive

project and prepare for job applications.
Project Options (Choose one and go deep):
LLM Systems: Implement a recent research paper (e.g., a new PEFT
method or a novel sampling strategy). A good project would be to
implement DPO from scratch and use it to align a fine-tuned model.
CV/Multi-modal: Build a visual question-answering (VQA) system by
combining a ViT-based image encoder with an LLM decoder.
Performance/C++: Contribute to an open-source inference project like
[Link] or a similar engine. Even a small, well-documented
optimization or bug fix is a significant achievement.
Final Steps:
Refine the GitHub repositories for all your projects. Write
excellent [Link] files with demonstrations, setup instructions,
and explanations of the concepts.
Write 2-3 blog posts on a platform like Medium or your own website,
explaining the theory and implementation of your most complex
projects (e.g., "Implementing a Transformer from Scratch," "A Deep
 Dive into RLHF vs. DPO," "Optimizing Inference with C++ and
Pybind11").
Build your resume around these projects, linking directly to your
GitHub and blog posts.

Excellent. Prioritizing C++ for ICPC preparation while building advanced

software engineering and AI skills is a powerful combination. This revised
10-month plan front-loads C++ and core software engineering principles,
then integrates them into the advanced AI/ML curriculum.

This schedule is extremely demanding and assumes you will dedicate yourself
to it full-time.

The 10-Month ICPC-Focused AI Engineer Plan

Phase 1: C++ and Systems Foundations (Months 1-3)

This phase builds an elite foundation in C++ for competitive programming

and the core software engineering skills needed to build robust systems.

Month 1: C++ Mastery for Competitive Programming

Objective: Achieve fluency in C++ and the algorithmic thinking required

for competitions like ICPC.
C++ Topics:
Modern C++ (17/20): Move semantics, smart pointers ( unique_ptr ,
shared_ptr ), lvalue/rvalue references, and constexpr .
STL Mastery: Deep dive into all containers ( vector , map , set ,
unordered_map , priority_queue ), iterators, and the <algorithm> header.
Performance: I/O optimization ( ios_base::sync_with_stdio(false) ,
[Link](NULL) ), memory layout, and cache-friendliness.
Algorithms & Data Structures:
Graph Algorithms: DFS, BFS, Dijkstra, Floyd-Warshall, Bellman-Ford,
Minimum Spanning Trees (Kruskal's, Prim's).
Dynamic Programming: Master common patterns (e.g., Knapsack, LCS,
Matrix Chain Multiplication).
Advanced Data Structures: Segment Trees, Fenwick Trees (Binary
Indexed Trees).
Coding & Software Engineering Focus:
Practice: The core of this month is solving problems. Dedicate
several hours daily to platforms like Codeforces, TopCoder, and
LeetCode (focus on Hard problems). Participate in online contests.
 Python: Use Python as a scripting tool to generate complex test
cases for your C++ solutions and to quickly prototype algorithmic
ideas.

Month 2: High-Performance C++ & Python Integration

Objective: Bridge your C++ skills to real-world systems by making them

available in Python.
C++ Topics:
Concurrency: std::thread , std::mutex , std::atomic , std::future , and
std::async . Understand data races and synchronization.
Template Metaprogramming: Basic understanding of how templates can
be used for compile-time computation.
High-Performance Libraries: Get familiar with a C++ linear algebra
library like Eigen. Understand its API for matrix and vector
operations.
Python Integration:
Pybind11: This is the key technology for this month. Learn how to
expose C++ functions and classes to Python, including handling
complex data types like Eigen matrices and std::vector .
Coding & Software Engineering Focus:
Project: Implement a computationally intensive algorithm in C++
(e.g., a K-D Tree for nearest neighbor search, or N-body
simulation). Then, create Python bindings using Pybind11. Write a
Python script that benchmarks your C++ module against a pure
Python/NumPy implementation to quantify the speedup. This is a
powerful portfolio piece.

Month 3: Advanced Software Engineering & System Design

Objective: Learn to design and build scalable, maintainable software

systems.
Databases:
SQL: Go beyond basic queries. Learn about window functions, common
table expressions (CTEs), advanced indexing (e.g., B-Tree vs. Hash),
and transaction isolation levels. Use PostgreSQL.
NoSQL: Understand the use cases for different models. Use Redis for
caching (key-value) and MongoDB for flexible documents (document
store).
 System Design & DevOps:
APIs: Design clean REST APIs. Understand HTTP methods, status codes,
and API versioning.
Architecture: Learn the patterns of microservices vs. monoliths,
message queues (RabbitMQ or Kafka), and load balancing.
Containerization: Docker is essential. Learn to write Dockerfiles
and use Docker Compose to orchestrate multi-container applications.
CI/CD: Set up a basic continuous integration pipeline using GitHub
Actions that automatically runs tests on every push.
Coding & Software Engineering Focus:
Project: Design and build a complete microservice application. For
example, a user analytics service.
1. A Python FastAPI service to receive events.
2. A Kafka or RabbitMQ queue to buffer incoming events.
3. A C++ worker process that consumes from the queue, performs some
fast aggregation, and writes results to PostgreSQL.
4. Containerize all three components with Docker Compose.

Phase 2: Advanced AI Specialization (Months 4-10)

Now, apply your elite C++ and systems skills to the AI domain.

Month 4: The Transformer & Deep Learning Core

Objective: Master the foundational architecture of modern AI.

Topics: Deep dive into the "Attention Is All You Need" paper: QKV, Self-
Attention, Multi-Head Attention, Positional Embeddings (Absolute, RoPE),
and the full Encoder/Decoder architecture. Review backpropagation and
normalization layers (especially LayerNorm).
Coding & Software Engineering Focus:
Python: Implement a complete Transformer block from scratch in
PyTorch. Ensure you understand the tensor shapes at every step.
C++: Read the C++ implementation of a self-attention layer in the
[Link] source code. Compare this low-level, optimized code to
your high-level Python prototype.

Month 5: Advanced Computer Vision

 Objective: Apply Transformer and CNN knowledge to the vision domain.
Topics: Advanced CNNs (ResNet), Object Detection (YOLO), Semantic
Segmentation (U-Net), and Vision Transformers (ViT).
Coding & Software Engineering Focus:
Project 1 (Python): Use PyTorch to fine-tune a pre-trained ViT model
on an image classification dataset.
Project 2 (Python/Systems): Build a real-time object detection
application. Use a pre-trained YOLO model, wrap it in a FastAPI
service, and create a simple client that can send video frames and
receive bounding box data.

Month 6: LLM Adaptation: Fine-tuning & Alignment

Objective: Learn to customize pre-trained LLMs for specific tasks.

Topics: Instruction Tuning (SFT), Parameter-Efficient Fine-Tuning (LoRA,
QLoRA), Reinforcement Learning from Human Feedback (RLHF), and Direct
Preference Optimization (DPO).
Coding & Software Engineering Focus:
Project (Python): This is a critical portfolio project. Use the
Hugging Face ecosystem ( transformers , peft ) to perform a LoRA fine-
tuning of an open-source model like Mistral-7B on an instruction
dataset (e.g., Alpaca).

Month 7: Advanced LLM Architectures

Objective: Understand the architectural innovations that enable cutting-

edge models.
Topics: Mixture of Experts (MoE), Grouped-Query Attention (GQA), and
Long Context strategies (Sliding Window Attention).
Coding & Software Engineering Focus:
This is a code-reading month. Dive into the source code of models
like Mixtral (MoE, GQA) and Mistral (Sliding Window) in the
transformers library to see how these theoretical concepts are
implemented in practice.

Month 8: High-Performance LLM Inference

 Objective: Master the art of running LLMs efficiently, with a heavy C++
focus.
Topics: The KV Cache, sampling methods (Temperature, Top-k, Top-p),
Quantization (GGUF, AWQ), and inference engines (vLLM, TensorRT-LLM).
Coding & Software Engineering Focus:
Project (C++): This is your main C++ AI project.
1. Become an expert user of [Link] . Compile it, run various GGUF-
quantized models, and benchmark their performance.
2. Modify the [Link] source code. A great task is to implement a
novel or custom sampling method (e.g., Mirostat). This requires
you to understand the C++ generation loop, token management, and
state handling. Document your changes and benchmark their effect.

Month 9: Production AI Systems (RAG)

Objective: Build a complete, production-grade AI application.

Topics: Vector Databases (ChromaDB, Pinecone) and Retrieval-Augmented
Generation (RAG) architecture.
Coding & Software Engineering Focus:
Project (Full Stack): Build a robust RAG system.
1. Ingestion: A Python script to process documents, generate
embeddings (with a sentence-transformer), and store them in a
vector DB.
2. Backend: A FastAPI service that takes a query, retrieves context
from the DB, and calls an LLM (using your efficient [Link]
server or an API) to generate a response.
3. Deployment: Containerize the entire application (API, DB) with
Docker Compose and write a GitHub Actions workflow to automate
testing.

Month 10: Capstone Project & Portfolio

Objective: Synthesize all skills into a single, flagship project.

Project Ideas:
C++/Systems Focus: Contribute a significant, well-documented feature
or optimization to an open-source inference engine. This could be
adding support for a new model architecture or implementing a
technique from a recent paper.
 Full-Stack AI Focus: Build a multi-modal agent. The system should
take an image (CV model) and a text prompt (LLM) to perform a
complex task, like creating a detailed recipe from a picture of
ingredients. This integrates all your skills.
Final Steps:
Thoroughly document all projects in your GitHub with professional
[Link] files.
Write detailed blog posts explaining the "how" and "why" of your
capstone project and your C++ inference modifications.
Build your resume to showcase these advanced, multi-faceted
projects.