100 AI Concepts for College Students and Interviews: The Definitive Technical Compendium

Table of Contents

1. Foundations of Artificial Intelligence

2. Machine Learning Fundamentals

3. Deep Learning & Neural Architectures

4. Natural Language Processing & Transformers

5. Computer Vision & Image Understanding

6. Reinforcement Learning & Decision Making

7. Generative AI & Large Language Models

8. Advanced Topics: MLOps, Ethics, & Emerging Frontiers

9. Interview Preparation & Strategic Frameworks

10. The AI Learning Roadmap

1. Foundations of Artificial Intelligence

1.1 What is Artificial Intelligence?

Artificial Intelligence (AI) is the simulation of human intelligence processes by computer systems. These processes include learning (the acquisition of information and rules for using the information), reasoning (using rules to reach approximate or definite conclusions), and self-correction. For a college student, think of AI as the discipline that enables machines to perceive, reason, learn, and act intelligently in the world.

1.2 The Three Schools of AI

• Symbolic AI (Good Old-Fashioned AI): Based on explicit rules and logic. Expert systems, theorem provers. Strengths: explainability, formal guarantees. Weaknesses: brittle, cannot handle ambiguity.

• Connectionist AI (Neural Networks): Inspired by the brain. Learns patterns from data. Strengths: handles noisy data, excels at perception. Weaknesses: black-box, data-hungry.

• Hybrid AI: Combines symbolic reasoning with neural learning. Emerging paradigm for robust, explainable systems.

1.3 Strong AI vs. Weak AI

• Weak AI (Narrow AI): Designed to perform a specific task (e.g., spam filter, chess engine, recommendation system). All current AI is weak AI.

• Strong AI (Artificial General Intelligence - AGI): A machine with consciousness and the ability to perform any intellectual task that a human can. This remains theoretical.

1.4 The Turing Test

Proposed by Alan Turing in 1950. A machine passes if a human interrogator cannot reliably distinguish it from a human in a text-based conversation. While historically significant, it is now considered a weak benchmark for intelligence.

1.5 The Chinese Room Argument

John Searle's thought experiment arguing that a program cannot give a computer a "mind" or "consciousness," regardless of how intelligently it behaves. It challenges the validity of the Turing Test and highlights the difference between syntax (symbol manipulation) and semantics (understanding).

1.6 Agents and Environments

An agent is anything that can perceive its environment through sensors and act upon that environment through actuators. A rational agent acts to maximize its performance measure. Environments can be fully/partially observable, deterministic/stochastic, episodic/sequential, static/dynamic, discrete/continuous, and single/multi-agent.

1.7 Search Algorithms

• Uninformed Search: BFS, DFS, Depth-Limited, Iterative Deepening, Uniform-Cost.

• Informed Search: Greedy Best-First, A* (uses heuristic function h(n) + path cost g(n)).

• Adversarial Search: Minimax, Alpha-Beta Pruning (for game playing).

• Constraint Satisfaction Problems (CSPs): Backtracking, Forward Checking, Arc Consistency (AC-3).

1.8 Knowledge Representation

How to encode knowledge about the world in a form that a computer system can utilize. Key paradigms: propositional logic, first-order logic, semantic networks, frames, ontologies, and description logics. The challenge is the frame problem representing the effects of actions without specifying everything that does not change.

1.9 Reasoning Under Uncertainty

Real-world AI must handle uncertainty. Key formalisms:

• Probability Theory: Bayes' theorem, conditional independence.

• Bayesian Networks: Directed acyclic graphs representing probabilistic relationships.

• Markov Models: For sequential data (Hidden Markov Models, Markov Decision Processes).

• Dempster-Shafer Theory: Belief functions for handling evidence.

• Fuzzy Logic: Degrees of truth (0 to 1) rather than binary true/false.

1.10 The History of AI (Timeline)

2. Machine Learning Fundamentals

2.1 Supervised Learning

The model learns from labeled training data to map inputs to outputs. Key algorithms: Linear/Logistic Regression, Decision Trees, Random Forests, Support Vector Machines (SVMs), k-Nearest Neighbors (k-NN), Neural Networks.

2.2 Unsupervised Learning

The model finds patterns in unlabeled data. Key algorithms: k-Means Clustering, Hierarchical Clustering, DBSCAN, Principal Component Analysis (PCA), t-SNE, Autoencoders, Gaussian Mixture Models (GMMs).

2.3 Reinforcement Learning

An agent learns to make decisions by interacting with an environment, receiving rewards or penalties. Core components: policy, reward function, value function, model of the environment. Algorithms: Q-Learning, Deep Q-Networks (DQN), Policy Gradients, Actor-Critic (A2C/A3C), Proximal Policy Optimization (PPO).

2.4 Semi-Supervised & Self-Supervised Learning

• Semi-Supervised: Combines a small amount of labeled data with a large amount of unlabeled data. Useful when labeling is expensive.

• Self-Supervised: The model generates its own labels from the data itself (e.g., predicting masked words in a sentence, predicting the next frame in a video). Foundation of modern LLMs.

2.5 The Bias-Variance Tradeoff

The fundamental tension in ML:

• Bias: Error from overly simplistic assumptions (underfitting). High bias = model misses relevant patterns.

• Variance: Error from sensitivity to small fluctuations in the training set (overfitting). High variance = model learns noise.

• Goal: Find the sweet spot that minimizes total error (Bias² + Variance + Irreducible Error).

2.6 Overfitting & Underfitting

• Overfitting: Model performs well on training data but poorly on unseen data. Solutions: more data, regularization (L1/L2), dropout, early stopping, cross-validation.

• Underfitting: Model performs poorly on both training and test data. Solutions: more complex model, better features, reduce regularization.

2.7 Cross-Validation

Technique for assessing model generalization. k-Fold Cross-Validation splits data into k subsets, trains on k-1 folds, validates on the held-out fold, and repeats k times. Common choices: k=5 or k=10. Stratified k-fold preserves class proportions.

2.8 Evaluation Metrics

2.9 Feature Engineering & Selection

The process of transforming raw data into features that better represent the underlying problem. Techniques include one-hot encoding, normalization/standardization, binning, polynomial features, and domain-specific transforms. Feature selection (filter, wrapper, embedded methods like LASSO) reduces dimensionality and combats overfitting.

2.10 Ensemble Methods

Combining multiple models to improve performance beyond any single model:

• Bagging (Bootstrap Aggregating): Trains models in parallel on random subsets (e.g., Random Forest).

• Boosting: Trains models sequentially, each correcting the previous one's errors (e.g., AdaBoost, Gradient Boosting, XGBoost, LightGBM).

• Stacking: Combines predictions from diverse models using a meta-learner.

3. Deep Learning & Neural Architectures

3.1 Perceptrons and Multi-Layer Perceptrons (MLPs)

The perceptron is the simplest neural unit: a weighted sum of inputs passed through an activation function. Stacking layers of perceptrons with non-linear activations produces an MLP, capable of approximating any continuous function given enough width (the Universal Approximation Theorem).

3.2 Activation Functions

Non-linearities that let networks learn complex mappings:

• Sigmoid: Squashes to (0,1), suffers from vanishing gradients.

• Tanh: Squashes to (-1,1), zero-centered but still saturates.

• ReLU: max(0,x), fast and avoids saturation for positive inputs, but can "die."

• Leaky ReLU / GELU / SiLU (Swish): Smoother variants used in modern transformers.

3.3 Backpropagation & Gradient Descent

Backpropagation computes gradients of the loss with respect to every weight using the chain rule, propagating error signals backward through the network. Gradient descent then updates weights in the direction that reduces loss. Variants include batch, stochastic (SGD), and mini-batch gradient descent.

3.4 Optimizers

• SGD with Momentum: Accumulates velocity to smooth updates and escape shallow local minima.

• RMSProp: Adapts learning rate per parameter using a moving average of squared gradients.

• Adam: Combines momentum and adaptive learning rates; the default choice for most deep learning tasks.

• AdamW: Decouples weight decay from the gradient update, widely used for training transformers.

3.5 Convolutional Neural Networks (CNNs)

Use convolutional filters that slide across input data to detect local patterns (edges, textures, shapes), with pooling layers for spatial downsampling. The hierarchical structure lets early layers detect simple features and deeper layers detect complex, composite ones. Foundational for computer vision.

3.6 Recurrent Neural Networks (RNNs, LSTM, GRU)

Designed for sequential data by maintaining a hidden state that carries information across time steps. Plain RNNs suffer from vanishing/exploding gradients over long sequences. LSTMs (Long Short-Term Memory) and GRUs (Gated Recurrent Units) use gating mechanisms to control what information is retained or forgotten, enabling longer-range dependencies.

3.7 Batch Normalization & Layer Normalization

• Batch Normalization: Normalizes activations across a mini-batch, stabilizing and accelerating training in CNNs.

• Layer Normalization: Normalizes across features for a single example, independent of batch size the standard choice in transformers, since it works well with variable sequence lengths and small batches.

3.8 Regularization Techniques

• Dropout: Randomly zeroes a fraction of neurons during training, preventing co-adaptation.

• Weight Decay (L2 Regularization): Penalizes large weights to encourage simpler models.

• Early Stopping: Halts training once validation performance stops improving.

• Data Augmentation: Artificially expands the training set (flips, crops, noise) to improve generalization.

3.9 Residual Networks (ResNets) & Skip Connections

Skip (residual) connections allow gradients to flow directly across layers by adding a layer's input to its output, mitigating vanishing gradients and enabling networks hundreds of layers deep. This idea underlies not just ResNets but also the residual structure inside every transformer block.

3.10 Vanishing & Exploding Gradients

In deep networks, gradients can shrink toward zero (vanishing) or grow uncontrollably (exploding) as they propagate backward through many layers, especially with saturating activations or poor initialization. Mitigations: careful weight initialization (Xavier/He), normalization layers, gradient clipping, and residual connections.

4. Natural Language Processing & Transformers

4.1 Tokenization

The process of splitting text into units a model can process. Modern subword tokenizers Byte-Pair Encoding (BPE), WordPiece, SentencePiece split rare words into common subword units, balancing vocabulary size with the ability to represent any input, including out-of-vocabulary words and morphologically rich or code-switched languages.

4.2 Word Embeddings

Dense vector representations of words that capture semantic relationships (e.g., king - man + woman ≈ queen). Word2Vec (Skip-gram/CBOW) and GloVe were foundational static embedding methods; modern models instead use contextual embeddings that change depending on surrounding words.

4.3 The Attention Mechanism

Attention lets a model weigh how relevant every other token is when representing a given token, rather than compressing a whole sequence into one fixed vector. Computed via Query, Key, and Value projections: attention scores are the scaled dot product of queries and keys, used to weight the values.

4.4 The Transformer Architecture

Introduced in "Attention Is All You Need" (2017), the transformer replaced recurrence entirely with self-attention and feed-forward layers, enabling full parallelization during training. It consists of stacked blocks, each with multi-head self-attention, layer normalization, and a position-wise feed-forward network, connected via residual connections.

4.5 Self-Attention vs. Cross-Attention

• Self-Attention: Tokens attend to other tokens within the same sequence (used in both encoders and decoders).

• Cross-Attention: Tokens in one sequence (e.g., a decoder) attend to tokens in a different sequence (e.g., an encoder's output) central to translation and encoder-decoder architectures.

4.6 Positional Encoding

Since self-attention has no inherent notion of token order, positional information must be injected explicitly via sinusoidal functions, learned embeddings, or more modern relative schemes like Rotary Positional Embeddings (RoPE), which encode relative position directly into attention computation.

4.7 Encoder-Decoder vs. Decoder-Only Architectures

• Encoder-only (e.g., BERT): Processes the full input bidirectionally; suited to understanding tasks (classification, embeddings).

• Encoder-Decoder (e.g., T5, original Transformer): Encodes input, then generates output conditioned on it; suited to translation and summarization.

• Decoder-only (e.g., GPT family): Generates text autoregressively, attending only to previous tokens; the dominant architecture for modern LLMs.

4.8 BERT and Masked Language Modeling

BERT (Bidirectional Encoder Representations from Transformers) is pretrained by masking random tokens in a sentence and predicting them from both left and right context, plus a next-sentence prediction objective. This bidirectionality makes BERT strong at understanding tasks but unsuitable for free-form text generation.

4.9 GPT and Autoregressive Language Modeling

GPT-style models are trained to predict the next token given all previous tokens, using causal (masked) self-attention so a position cannot see future tokens. This simple objective, scaled to enormous datasets and parameter counts, underlies essentially all modern generative LLMs.

4.10 Core NLP Tasks

• Named Entity Recognition (NER): Identifying people, places, organizations in text.

• Part-of-Speech (POS) Tagging: Labeling each word's grammatical role.

• Sentiment Analysis: Classifying text as positive, negative, or neutral in tone.

• Machine Translation: Converting text between languages, historically a key transformer benchmark.

5. Computer Vision & Image Understanding

5.1 Image Classification

Assigning a single label to an entire image, historically the benchmark task for CNNs (e.g., ImageNet, AlexNet, ResNet). Modern approaches increasingly use vision transformers or hybrid CNN-transformer backbones.

5.2 Object Detection

Locating and classifying multiple objects within an image using bounding boxes.

• Two-stage detectors (R-CNN family): Propose regions, then classify each accurate but slower.

• One-stage detectors (YOLO, SSD): Predict boxes and classes in a single pass faster, suited to real-time use.

5.3 Semantic & Instance Segmentation

• Semantic Segmentation: Labels every pixel with a class, without distinguishing individual object instances.

• Instance Segmentation: Labels every pixel and distinguishes separate instances of the same class (e.g., Mask R-CNN).

5.4 Image Generation

• GANs (Generative Adversarial Networks): A generator and discriminator trained adversarially, the generator trying to fool the discriminator into accepting synthetic images as real.

• Diffusion Models in Vision: Learn to reverse a gradual noising process, iteratively denoising random noise into a coherent image; the basis of modern image generators like Stable Diffusion and DALL·E.

5.5 Vision Transformers (ViT)

Applies the transformer architecture to images by splitting an image into fixed-size patches, treating each patch as a "token." With sufficient training data, ViTs match or exceed CNNs, though they typically need more data or careful regularization since they lack the built-in inductive biases (locality, translation invariance) of convolutions.

5.6 Transfer Learning & Pretrained Backbones

Rather than training from scratch, models are initialized from weights pretrained on large datasets (e.g., ImageNet) and fine-tuned on a smaller, task-specific dataset. Dramatically reduces the data and compute needed for strong performance on a new task.

5.7 Data Augmentation

Synthetically expanding a training set through transformations rotation, flipping, cropping, color jitter, mixup, cutout to improve robustness and reduce overfitting, especially valuable when labeled data is scarce.

5.8 Optical Character Recognition (OCR)

Extracting machine-readable text from images or scanned documents. Modern OCR pipelines combine text detection (locating text regions) with text recognition (reading characters), increasingly unified in single end-to-end transformer-based models.

5.9 Multimodal Vision-Language Models

Models like CLIP jointly embed images and text into a shared representation space by training on image-caption pairs with a contrastive objective, enabling zero-shot image classification, retrieval, and forming the visual backbone for many multimodal LLMs.

6. Reinforcement Learning & Decision Making

6.1 Markov Decision Processes (MDPs)

The formal framework for RL: a set of states, actions, transition probabilities, and rewards, satisfying the Markov property (the future depends only on the current state, not the full history). Solving an MDP means finding a policy that maximizes expected cumulative reward.

6.2 Value Functions & the Bellman Equation

• State-Value Function V(s): Expected return starting from state s under a given policy.

• Action-Value Function Q(s,a): Expected return from taking action a in state s.

• Bellman Equation: Expresses these values recursively in terms of immediate reward plus the discounted value of the next state, forming the basis of most RL algorithms.

6.3 Exploration vs. Exploitation

The core dilemma in RL: exploit known high-reward actions, or explore uncertain ones that might be better. Common strategies: epsilon-greedy, softmax/Boltzmann exploration, Upper Confidence Bound (UCB), and intrinsic-motivation/curiosity-driven exploration.

6.4 Q-Learning & Deep Q-Networks (DQN)

Q-Learning is a model-free, off-policy algorithm that learns the optimal action-value function via temporal-difference updates. DQN scales this to high-dimensional inputs (e.g., raw pixels) by approximating Q with a neural network, stabilized with techniques like experience replay and target networks.

6.5 Policy Gradient Methods

Rather than learning a value function and deriving a policy, policy gradient methods directly parameterize and optimize the policy by ascending the gradient of expected reward. REINFORCE is the foundational algorithm; variance-reduction techniques (baselines, advantage estimation) make training more stable.

6.6 Actor-Critic Methods

Combine both approaches: an "actor" learns the policy, while a "critic" learns a value function to reduce variance in the actor's gradient estimates. Modern variants include A2C, A3C, and Proximal Policy Optimization (PPO), which clips policy updates to prevent destructively large steps.

6.7 Multi-Agent Reinforcement Learning

Extends RL to settings with multiple interacting agents, which may cooperate, compete, or both. Introduces challenges absent in single-agent RL, such as non-stationarity (the environment changes as other agents learn) and the need for coordination or communication protocols.

6.8 RLHF (Reinforcement Learning from Human Feedback)

The technique used to align large language models with human preferences: human raters rank model outputs, a reward model is trained to predict these preferences, and the language model is then fine-tuned (typically with PPO) to maximize the learned reward a key step in turning a raw pretrained LLM into an assistant like ChatGPT or Claude.

7. Generative AI & Large Language Models

7.1 What Makes a Model "Generative"

Generative models learn the underlying distribution of data well enough to produce new, plausible samples text, images, audio, or code rather than only classifying or predicting a single output. This contrasts with discriminative models, which learn decision boundaries between classes.

7.2 Large Language Models: Scale and Emergence

LLMs are transformer-based models trained on massive text corpora with billions of parameters. As scale (data, parameters, compute) increases, models exhibit emergent capabilities abilities like multi-step reasoning or in-context learning that appear abruptly rather than improving smoothly, and are largely absent at smaller scale.

7.3 Prompt Engineering

The practice of crafting inputs to elicit better outputs from an LLM without changing its weights. Techniques include few-shot examples, explicit step-by-step instructions, role/persona framing, and structured output formatting (e.g., requesting JSON or specific tags).

7.4 In-Context Learning & Few-Shot Learning

LLMs can perform a new task by seeing a handful of examples in the prompt itself, without any gradient updates a strikingly different learning paradigm from traditional ML, where "learning" always meant updating weights.

7.5 Fine-Tuning vs. Parameter-Efficient Fine-Tuning

• Full Fine-Tuning: Updates all of a pretrained model's weights on a new task or dataset effective but computationally expensive at LLM scale.

• LoRA (Low-Rank Adaptation): Freezes the original weights and injects small trainable low-rank matrices into each layer, drastically reducing trainable parameters.

• QLoRA: Combines LoRA with 4-bit quantization of the base model, making fine-tuning of large models feasible on a single consumer GPU.

7.6 Retrieval-Augmented Generation (RAG)

Combines an LLM with an external retrieval system: relevant documents are fetched from a knowledge base (often via vector similarity search) and inserted into the prompt as context, letting the model answer with up-to-date or domain-specific information it wasn't trained on, while reducing hallucination.

7.7 Hallucination in LLMs

The tendency of language models to generate fluent, confident-sounding text that is factually incorrect or unsupported by any source. Arises because models are trained to produce plausible continuations, not to verify truth. Mitigations include RAG, better training data curation, and calibration/uncertainty techniques.

7.8 Diffusion Models

A class of generative models that learn to reverse a gradual noise-adding process. Training involves progressively corrupting data with noise and teaching a network to predict and remove that noise step by step; sampling then starts from pure noise and iteratively denoises it into a realistic sample. Dominant in modern image and increasingly audio/video generation.

7.9 Multimodal Foundation Models

Models trained to jointly understand and/or generate across multiple modalities text, images, audio, video typically by projecting different modalities into a shared embedding space that a transformer backbone can reason over jointly.

7.10 AI Agents & Tool Use

Systems where an LLM doesn't just generate text but plans, calls external tools or APIs, observes results, and iterates enabling tasks like web browsing, code execution, or multi-step workflows. Common patterns include ReAct (reasoning + acting) and explicit function/tool-calling interfaces.

8. Advanced Topics: MLOps, Ethics, & Emerging Frontiers

8.1 MLOps & the ML Lifecycle

The discipline of taking ML from experimentation to reliable production: versioning data and models, reproducible training pipelines, automated testing, CI/CD for models, and monitoring analogous to DevOps but for the additional complexity of data and model drift.

8.2 Model Deployment & Serving

Turning a trained model into a usable service via REST/gRPC APIs, batch inference pipelines, or edge deployment. Considerations include latency, throughput, hardware (CPU/GPU/TPU), and serving frameworks (e.g., TorchServe, Triton, vLLM for LLM inference).

8.3 Model Monitoring & Drift Detection

Once deployed, models can degrade as real-world data distributions shift away from training data (data drift) or as the relationship between inputs and outputs changes (concept drift). Monitoring tracks input distributions, prediction distributions, and downstream performance to catch this early.

8.4 AI Ethics & Fairness

Concerns how AI systems can encode or amplify societal biases present in training data, leading to unfair outcomes across groups. Fairness metrics (demographic parity, equalized odds) and bias-auditing tools help detect and mitigate this, though tradeoffs between different fairness definitions are often unavoidable.

8.5 Explainable AI (XAI)

Techniques for making model decisions interpretable to humans, especially important for high-stakes domains (healthcare, finance, criminal justice). Methods include SHAP and LIME (local, model-agnostic explanations), attention visualization, and inherently interpretable models.

8.6 AI Safety & Alignment

The broader research area concerned with ensuring AI systems reliably do what humans intend, especially as capabilities scale covering robustness, avoiding harmful or deceptive behavior, and techniques like RLHF, red-teaming, and interpretability research.

8.7 Low-Resource Language AI

Most large models are trained overwhelmingly on high-resource languages like English, leaving thousands of languages including many African languages severely underrepresented in training data. Building capable models for these languages requires deliberate data collection, synthetic data generation, and architectures or tokenizers adapted to code-switching and unique morphology, an active and important research frontier.

8.8 Federated Learning & Privacy

Federated learning trains a shared model across many decentralized devices or servers holding local data, without that raw data ever leaving its source only model updates are aggregated centrally. Combined with techniques like differential privacy, this enables training on sensitive data while limiting privacy exposure.

8.9 Quantization & Model Compression

Techniques to shrink models for efficient deployment, especially on edge devices:

• Quantization: Reduces numerical precision of weights/activations (e.g., 32-bit to 8-bit or 4-bit).

• Pruning: Removes redundant weights or neurons.

• Knowledge Distillation: Trains a smaller "student" model to mimic a larger "teacher" model's outputs.

9. Interview Preparation & Strategic Frameworks

9.1 How to Approach an ML System Design Interview

Structure your answer around: (1) clarify the problem and constraints, (2) propose data and features, (3) choose a model and justify tradeoffs, (4) define evaluation metrics tied to business goals, (5) discuss deployment, monitoring, and how you'd iterate. Interviewers care more about structured reasoning than a single "correct" architecture.

9.2 Common Coding Interview Topics for AI/ML Roles

Expect a mix of general software engineering (data structures, algorithms, complexity analysis) and ML-specific coding implementing gradient descent, a k-NN classifier, matrix operations from scratch, or debugging a broken training loop.

9.3 Explaining Projects Using the STAR Method

When describing past projects (Situation, Task, Action, Result), be specific about your individual contribution, the technical decisions you made and why, and quantifiable outcomes vague summaries are far less convincing than a concrete story about a hard tradeoff you navigated.

9.4 Key Papers Every AI Candidate Should Know

At minimum, be able to summarize: "Attention Is All You Need" (Transformers), "BERT," the GPT series, "Deep Residual Learning" (ResNet), "Generative Adversarial Networks," "Denoising Diffusion Probabilistic Models," and "LoRA." You don't need to memorize equations, but should grasp the core idea and why it mattered.

9.5 Behavioral Questions for AI/ML Roles

Common themes: handling ambiguous or underspecified problems, disagreeing with a teammate's technical approach, a project that failed and what you learned, and how you stay current given how fast the field moves. Prepare specific, honest stories rather than generic answers.

9.6 Questions to Ask Your Interviewer

Strong candidates ask questions too: What does the model lifecycle look like on this team? How is model performance measured post-deployment? What's the split between research and production engineering? These signal genuine engagement with how the role actually works day to day.

10. The AI Learning Roadmap

10.1 Months 1-2: Math & Programming Foundations

Linear algebra (vectors, matrices, eigenvalues), calculus (derivatives, gradients, chain rule), probability & statistics, and solid Python fundamentals including NumPy and Pandas. This foundation makes everything downstream easier to understand rather than memorize.

10.2 Months 3-4: Classical Machine Learning

Work through supervised and unsupervised learning algorithms, implement a few from scratch (linear regression, k-means, decision trees), and get comfortable with scikit-learn, cross-validation, and evaluation metrics on real datasets.

10.3 Months 5-6: Deep Learning

Learn PyTorch or TensorFlow, build MLPs and CNNs from scratch, understand backpropagation deeply enough to derive it, and train models on standard benchmarks (MNIST, CIFAR-10) before moving to more complex architectures.

10.4 Months 7-8: Specialization (NLP, CV, or RL)

Pick one track based on interest: NLP (tokenizers, transformers, fine-tuning small models), Computer Vision (object detection, segmentation, ViTs), or Reinforcement Learning (Q-learning through PPO on OpenAI Gym environments). Depth in one area beats shallow breadth across all three.

10.5 Months 9+: Projects, Portfolio, and Real-World Application

Build 2-3 substantial, original projects that solve a real problem you care about not tutorial clones. Document them well, publish the code, write about the technical decisions and tradeoffs, and use them as the backbone of both your portfolio and your interview stories. This is where a genuinely distinctive candidate emerges from the crowd of people who only completed courses.

This compendium is meant as a living reference revisit sections as you build projects and prepare for interviews, since these concepts are best internalized through application rather than memorization alone.

Shadrackovsky. Founder, Antera.