Build Practical AI Systems

A true zero-to-advanced path: statistics and math intuition, the full classical ML toolbox, neural networks, CNNs/RNNs/Transformers, then tiny local LLMs, RAG, MLflow, DVC, agents, observability, security, and production serving - paired with offline CPU-conscious labs.

Modules

• AI, ML, and Deep Learning - Separate overloaded AI terms and understand what a trained model really is.
• Frame a Learnable Problem - Translate a vague AI idea into a target, decision, baseline, and measurable constraint.
• Datasets from First Principles - Understand observations, features, labels, schemas, and structured versus unstructured data.
• Why Real Data Is Messy - Profile types, ranges, duplicates, outliers, and provenance before modeling.
• Missing and Categorical Data - Treat absence and categories as meaningful modeling decisions instead of cleanup trivia.
• Train, Validation, and Test Splits - Create sealed evidence for learning, choosing, and finally judging a model.
• Data Leakage and False Confidence - Recognize target, temporal, preprocessing, and duplicate leakage through worked failures.
• Labels, Bias, and Responsible Data - Build trustworthy labels, inspect representation, and document lawful, accountable data use.
• Center and Spread - Interpret mean, median, variance, standard deviation, quantiles, and robust summaries.
• Distributions and Sampling - See data as shapes, understand sampling uncertainty, and avoid mistaking a sample for reality.
• Correlation Is Not Causation - Measure association while recognizing confounding, reverse causality, and selection effects.
• Conditional Probability and Bayes - Build conditional probability and Bayes' theorem from counts before formulas.
• Uncertainty and Statistical Significance - Interpret confidence intervals, hypothesis tests, significance, effect size, and multiple comparisons.
• Vectors, Matrices, and Similarity - Read vectors and matrices as real objects, then connect dot products to embeddings.
• Gradients and Learning Downhill - Build calculus intuition through slopes, loss surfaces, learning rates, and gradient descent.
• The End-to-End ML Workflow - Move from framed problem to reproducible baseline, evaluation, deployment, and monitoring.
• Linear Regression - Fit an interpretable numeric relationship, inspect residuals, and know when a line is inadequate.
• Logistic Regression - Turn weighted evidence into class probabilities and adjustable decisions.
• Decision Trees - Learn recursive yes/no splits, impurity reduction, pruning, and tree failure modes.
• Bagging and Random Forests - Reduce unstable tree variance by averaging diverse bootstrap learners.
• Boosting and Gradient-Boosted Trees - Build trees sequentially to correct residual errors and compare boosting with bagging.
• K-Nearest Neighbors - Predict from nearby examples while understanding distance, scaling, k, and dimensionality.
• Support Vector Machines - Understand maximum-margin boundaries, support vectors, kernels, and practical SVM selection.
• K-Means Clustering - Discover compact groups without labels and avoid turning clusters into invented truth.
• PCA and Dimensionality Reduction - Compress correlated numeric features into principal directions while tracking lost meaning.
• Preprocessing and Feature Pipelines - Compose column-specific transforms into one leakage-safe deployable artifact.
• Overfitting, Underfitting, and Bias-Variance - Diagnose learning curves and choose capacity that generalizes rather than memorizes.
• Regularization with L1 and L2 - Penalize unnecessary weight size and understand sparse versus smoothly shrunk models.
• Classification Metrics That Tell the Truth - Connect confusion matrices, precision, recall, F1, ROC, PR curves, thresholds, and calibration.
• Regression Metrics and Cross-Validation - Choose MAE, RMSE, and R² honestly, then validate models and hyperparameters without test-set tuning.
• Feature Engineering and Data Hygiene - Turn imperfect tables into trustworthy model inputs with Pandas and NumPy.
• Train and Evaluate Classical Models - Fit CPU-fast scikit-learn models and judge them with metrics that match the real cost of errors.
• Drift and Confusion Matrices - Use terminal reports to explain why yesterday's good model fails on today's data.
• The Perceptron: One Artificial Neuron - Build a neural unit from weighted inputs, bias, activation, and a learnable boundary.
• Layers and Nonlinearity - Stack neurons into representations and understand why activation functions make depth useful.
• Activation Functions - Compare sigmoid, tanh, ReLU, and softmax by their jobs and gradient behavior.
• Forward Passes and Loss Functions - Trace a prediction through layers and connect task-appropriate loss to learning.
• Backpropagation as Blame Assignment - Understand the chain rule as an efficient backward accounting of each parameter's responsibility.
• Gradient Descent Optimizers - Compare batch, stochastic, mini-batch, momentum, and Adam as update strategies.
• Convolutional Networks for Images - Understand kernels as sliding pattern detectors, feature maps, pooling, and spatial inductive bias.
• RNNs and LSTMs for Sequences - Process ordered inputs with recurrent state and understand why long memory is difficult.
• Attention from First Principles - Derive queries, keys, values, similarity scores, weighted context, and self-attention behavior.
• Transformers End to End - Combine token embeddings, position, attention, feed-forward layers, residuals, and decoder generation.
• How Local LLMs Work - Tokens, parameters, inference, context windows, and why small local models are useful.
• Ollama from the Terminal - Operate a local model inventory and make reproducible CLI and HTTP requests.
• GGUF and Quantization - Understand model files, quantized weights, memory budgets, and safe model selection.
• Embeddings and Similarity - Turn meaning into vectors and retrieve related text correctly.
• ChromaDB and Qdrant Local Mode - Persist vectors locally, attach metadata, query safely, and understand collection lifecycle.
• Build a RAG Pipeline - Chunk documents, retrieve evidence, construct grounded prompts, and cite sources.
• Track Experiments with MLflow - Record parameters, metrics, artifacts, and tracking locations so experiments remain reproducible.
• Version Data with DVC and Git - Track large data by checksum, keep metadata in Git, and detect drift between code and data.
• Serve Models with FastAPI - Design a bounded local inference API with validation, health checks, timeouts, and honest errors.
• Unified LLM Calls with LiteLLM - Use an OpenAI-shaped client across providers while keeping routing and secrets explicit.
• LLMs in Shell Pipelines - Safely connect files, pipes, JSON tools, and local inference in composable commands.
• Build Safe Terminal Agents - Design a bounded observe-plan-act loop with allowlisted tools, approvals, and secret-safe logs.
• Prompt Engineering as Interface Design - Design explicit instructions, examples, context boundaries, and validated output contracts.
• Evaluate Generative AI Systems - Create task rubrics, golden sets, pairwise tests, judge calibration, and release gates.
• Fine-Tuning and Parameter-Efficient Adaptation - Distinguish prompting, RAG, supervised fine-tuning, adapters, and preference optimization.
• LLM Cost, Latency, and Quality Trade-Offs - Budget tokens, context, routing, caching, and concurrency as one production design problem.
• Model Cards, Risk, and Governance - Document intended use, evidence, limitations, ownership, approvals, and retirement for AI systems.
• LLM Request Tracing and Token Accounting - Follow each request through an LLM application and turn token use into operational cost evidence.
• Automated RAG Evaluation - Turn grounded answers into testable evidence with faithfulness, citation, and support checks.
• Latency and Time to First Token - Benchmark real streamed Ollama responses and diagnose configuration that makes an assistant feel slow.
• Defend Against Prompt Injection - Separate trusted instructions from untrusted user and retrieved content, then test that policy under attack.
• Mask PII in Output Streams - Recognize personal data and credentials, redact streams before storage, and test both leaks and false positives.
• Build Config-Driven Guardrails - Express input and output policy as configuration, enforce it outside the model, and fail closed on bad shapes.
• Continuous Batching and KV Cache - Understand how vLLM-style schedulers interleave requests, reuse attention state, and trade throughput for latency.
• Proxy Routing and Model Fallback - Place a LiteLLM reverse proxy in front of local models and test explicit failure-aware fallback routing.
• Health, Readiness, and Crash Recovery - Expose truthful probes, remove unhealthy instances from traffic, and restart crashed model services safely.