AI Engineering Programmev2

How do I run Python code reliably — both as a reusable script and exploratorily in a notebook — and predict its behaviour from how I bind variables and shape control flow?

Starting from a fresh project, how do I bring it under Git and tell at a glance which files are tracked, modified, or staged?

How do I split my work into clean, reviewable commits, keep noise out of the repo, and read back the history I've created?

Which built-in Python container fits the access pattern I have — random lookup, ordered traversal, set membership, structured records — and why?

How do scope rules, file I/O, comprehensions, and first-class functions combine into a small, self-contained Python module I can run from disk?

How do I rewrite a system of linear equations as a single matrix-vector equation Ax = b, and what does each piece mean?

Given a system of linear equations, how do I tell from its structure whether it has a unique solution, no solutions, or infinitely many?

How do I represent vectors and matrices as NumPy arrays and operate on them at the array level rather than with explicit loops?

How do I use branches and remotes so I can experiment with two different implementations of the same idea and choose one cleanly?

Given a linear mapping, how do I read off its image, its kernel, and the basis and dimension of the spaces it operates on?

What is a random variable, exactly — and how do I generate reproducible samples from one in NumPy?

Given a joint distribution, how do I get marginal and conditional distributions, decide whether variables are independent, and reason about expected values?

How do I get a CSV from disk into a labelled, well-typed pandas DataFrame I can actually work with?

How do I take a messy dataset, decide what to do about missing values, summarise it by groups, and stitch it together with another table?

How do I summarise and visualise a tabular dataset — with sort and rank, string and categorical handling, charts, and simple sample statistics — to surface what's actually in it?

How do I measure how long a vector is, how far apart two vectors are, and the angle between them — and what's special about the Euclidean choice?

What does it mean for two vectors to be orthogonal, and why is an orthonormal basis the friendliest coordinate system to compute in?

Given a vector and a subspace, how do I drop the vector onto the subspace and decompose it into the part that lives in it and the part that's orthogonal?

Why do rotations preserve length and angle, and what makes a matrix orthogonal in the geometric sense?

How do the mean vector and covariance matrix summarise the geometry of a dataset, and what preprocessing does projecting onto principal directions actually require?

Given a multivariate function, how do I compute its gradient and Hessian, and why is the gradient of a quadratic form the recurring pattern in machine learning?

Why is minimising a squared-error loss the same thing as maximising a Gaussian likelihood, and how do Bayes' theorem and a prior reshape that estimate?

How do the normal equations fall out of MLE for a Gaussian linear model, and why does putting a Gaussian prior on the weights give you ridge regression for free?

Once I fit a regression on a real dataset, how do I judge whether the model is doing a reasonable job, and which assumptions are silently breaking?

How do I estimate how well a model will generalise to data it hasn't seen, and what's the bias-variance trade I am implicitly making?

How do ridge and lasso reshape the loss surface, and how does cross-validation choose the regularisation strength honestly?

What does the determinant of a matrix actually mean — algebraically, geometrically, and as a signal about invertibility?

Given a square matrix, how do I find its eigenvalues and eigenvectors, and what do they tell me about the map geometrically?

When can a matrix be diagonalised, and what extra structure do symmetric and positive-definite matrices give us?

How do I differentiate vector- and matrix-valued expressions, and apply the chain rule when the building blocks are themselves linear maps?

What is the singular value decomposition, and why do its three factors give us the optimal low-rank approximation of a matrix in the spectral and Frobenius norms?

How does gradient descent actually find a minimum, and what choices about step size, momentum, and stochastic batches change whether it converges?

What does convexity buy me, when do I reach for Lagrange multipliers, and how does minimising empirical risk frame almost every supervised model?

How do logistic and softmax regression fall out of the same cross-entropy objective, and what makes them a one-layer neural network in disguise?

Beyond accuracy: how do confusion matrices, ROC curves, and the bootstrap actually tell me whether a classifier is doing its job and how confident I should be about my evaluation?

Which NumPy primitives — aggregate statistics, sorting, linear-algebra routines, and streaming generators — does a hand-rolled classifier training loop actually need?

How does a multilayer perceptron actually compute its output, and what does it mean to view that computation as a graph for differentiation?

How does reverse-mode automatic differentiation compute every parameter's gradient in one backward pass, and how do I tell when the gradients are silently broken?

Why do SGD, momentum, and Adam behave so differently in practice, and how do learning-rate schedules and data loaders fit into the standard training loop?

Once the model trains, how do I diagnose overfitting, and which of weight decay, dropout, and early stopping is the right lever to reach for?

Why do principled initialisation and normalisation make deep networks trainable at all, and how do I compose, save, and reload models cleanly?

Given a binary or multi-class problem, how do the Bayes-optimal classifier and its practical approximations — LDA, QDA, naive Bayes, KNN — differ in what they assume and what they decide?

How does a decision tree partition the input space, and what do bagging, random forests, and boosting buy on top of a single tree?

What are the two complementary derivations of PCA — as max-variance directions and as best low-rank reconstruction — and how do they meet in the covariance matrix?

When there are no labels, how does K-means or a dendrogram surface structure, and how would I judge whether the resulting clusters are real?

When the model space is wide, how do pruning, best-subset and stepwise selection, and cross-validated criteria help me pick a defensible model?

How does test-driven development shape my code, and what changes when I deliberately keep pure business logic separate from side-effectful I/O?

How do ports, adapters, and dependency injection let me swap out the database, the queue, or the model at the edges of the system without rewriting the core?

How do domain entities, repositories, and a service layer organise an application so the database choice doesn't leak through every function?

How does the Unit of Work pattern make a multi-step business transaction atomic, and where do architectural layers and explicit validation live in the picture?

How do I make my Python project pip-installable, dockerise it for a clean build, and stand up a multi-container environment my CI can run against?

How do I expose the service layer behind a Flask API, separate validation from web concerns, and shape the test pyramid so coverage reaches the system end-to-end?

What makes ML systems different from ordinary software systems, and which decisions about data, architecture, and serving have the biggest impact on whether the project succeeds?

How do I move from a notebook prototype to a reproducible feature-and-training pipeline that another engineer can run cold and tracks every run that fed it?

How do I tune hyperparameters honestly at scale, write automated tests that protect a deployed model, and produce explanations a stakeholder can act on?

How do my team and I share an ML codebase without stepping on each other — syncing remotes, keeping history tidy, tagging releases, and reviewing changes through pull requests?

How do automated security scans, CI/CD pipelines, DAG orchestration, and managed training systems combine into an ML platform that runs without a human in the loop?

Why does a convolution — with its locality and weight-sharing — turn out to be the right inductive bias for images, and how do padding, stride, and pooling shape what it sees?

Once a CNN works for fixed images, how do residual connections scale it, and what new structure does a sequence model need that an image classifier doesn't?

What is attention computing, exactly — and why do queries, keys, values, scaled dot-products, and multiple heads give the Transformer its power?

How do positional encoding, an encoder block, and a Bahdanau-attention seq2seq baseline come together as the standard Transformer architecture?

How does a Transformer decoder become a foundation model through pretraining and fine-tuning, and what do the scaling laws say about why this works?

How do tokenisation, self-supervised pretraining, and the sampling controls — temperature, top-k, top-p — shape what a Transformer actually emits at inference time?

What is the difference between a prompt and a context window, and how do I move from a one-off prompt to a versioned, engineered prompt I can rerun and audit?

When do zero-shot, few-shot, chain-of-thought, task decomposition, and self-critique actually move accuracy, and when are they performative?

How do TF-IDF, embedding-based vector search, and hybrid reranking trade off in practice, and which combination is the right starting point for a new corpus?

How do chunking, retrieval, and context construction come together as a RAG architecture I can defend with diagrams and ablations?

How do structured outputs, post-training alignment, and the exact-versus-subjective evaluation split combine into a development loop where every prompt change is evaluated honestly?

How do function calling, ReAct, planning, and memory turn a chat model into an agent that can take useful, debuggable action?

How do I write evaluation criteria for an LLM application that are sharp enough to fail a regression and broad enough to cover what the system actually does?

When and how can I use a model as a judge of another model's output, and how do I build an eval pipeline that gates changes the way unit tests gate code?

How do I evaluate retrieval quality with precision-and-recall@k, MAP, and NDCG — and how do I detect, categorise, and reduce hallucinations downstream?

How do I curate training and evaluation datasets, supplement them with synthetic data, build instruction-tuning sets, and tie everything back to defensible AI product metrics?

Why are prefill and decode such different beasts under the hood, and what does managing the KV cache buy in latency and throughput?

When latency or cost is the bottleneck, which of quantisation, continuous batching, and speculative decoding do I reach for, and what does each give up?

How do I deploy a model as a real service, route requests through a gateway, decide between hosted-API and self-hosted, and cache results both exactly and semantically?

When do I reach for prompting, RAG, or finetuning — and within finetuning, what do SFT, LoRA, preference tuning, and distillation buy me at the layer of the wider AI stack?

Given a real product target, how do I architect the full system — model selection, retrieval, gateway, caching, FTI pipelines, and the first layer of guardrails — so it can meet quality, latency, and cost requirements?

Once an AI application is live, how do moderation and prompt-injection defences combine with data- and concept-drift detection and continuous monitoring to keep it safe and accurate?

Once a regression has fit, what do its coefficients actually claim about the world, and how do I test, compare, and interval those claims with discipline?

How does the choice of basis change the matrix of a linear map, and what do rank-nullity and injectivity tell me about which problems a map can solve and which it can't?

When my random variables are jointly Gaussian, how do I read off marginals and conditionals, sample from richer distributions via the probability integral transform, and reason cleanly about mixtures?

Beyond column access, how do boolean masks, loc and iloc, fancy indexing, map and apply, and groupwise summaries let me select and summarise exactly what the question asks for?

When the data isn't flat — hierarchical, long-vs-wide, time-indexed, in JSON, in a spreadsheet, or in a SQL database — which pandas idioms reshape it cleanly without losing structure?

What are the moves I will reach for under pressure — undoing a stage, discarding work, amending a commit, plucking a fix off a branch, parsing text with regex — and which domain-modelling moves (value objects, aggregates) keep my code from rotting at the edges?