AI Engineering with Python

Manipulate NumPy arrays by shape, axis, indexing, and broadcasting.

Compute dot products, vector norms, and cosine similarity and interpret their geometric meaning.

Use summary statistics and conditional frequencies to identify patterns and anomalies in a dataset.

Calculate the gradient of a simple loss and use it in a basic gradient-descent update.

Load, clean, join, and inspect a small tabular dataset with pandas.

Visualize feature distributions and model errors with a compact plotting workflow.

Create train, validation, and test splits without leaking information between them.

Build a scikit-learn preprocessing pipeline for missing values, categorical encoding, and numerical scaling.

Translate an application requirement into a supervised, unsupervised, representation-learning, or generative-learning problem.

Train linear and logistic regression baselines and interpret their predictions.

Train a tree-based model and compare its behavior with a linear baseline.

Select and compute appropriate classification or regression metrics for a stated product objective.

Use cross-validation to compare model configurations without tuning on the test set.

Address class imbalance with weighting, sampling, threshold selection, and calibrated probabilities.

Perform slice-based error analysis to find systematic model failures.

Serialize a fitted preprocessing-and-model pipeline and reproduce its predictions in a separate process.

Create PyTorch tensors, move them between supported devices, and inspect their shapes and data types.

Use automatic differentiation to compute gradients for a small neural-network loss.

Implement and train a multilayer perceptron with an explicit PyTorch training loop.

Diagnose overfitting from learning curves and apply an appropriate regularization response.

Tokenize text and inspect how tokenization and chat templates affect context length.

Implement scaled dot-product self-attention on a small set of vectors.

Trace data through the attention, residual, normalization, and feed-forward parts of a transformer block.

Distinguish pretraining, instruction tuning, fine-tuning, preference alignment, and inference by their inputs and objectives.

Run a quantized open-source language model locally and measure its memory use, startup time, and generation speed.

Control generation behavior with temperature, top-p sampling, stop conditions, and output-length limits.

Construct prompts with explicit roles, constraints, examples, and failure behavior for a defined task.

Generate schema-constrained output and validate it before application code consumes it.

Define a tool schema, execute a model-requested tool safely, and return the result to the model.

Implement a provider-neutral model interface that can switch between local and hosted-compatible backends.

Estimate token usage and apply a context-truncation strategy without removing critical instructions.

Create prompt regression tests that cover normal, ambiguous, malformed, and adversarial inputs.

Generate text embeddings locally and rank candidates by vector similarity.

Compare fixed-size, recursive, and structure-aware chunking on a sample document collection.

Build and query a persistent local vector index with document identifiers and metadata.

Apply metadata filters without breaking the relationship between retrieved text and its source.

Build a lexical BM25 retrieval baseline for the same document collection.

Combine lexical and vector result lists with a rank-fusion method.

Rerank retrieved candidates with a local cross-encoder and measure the quality-latency trade-off.

Create a labeled query-document test set and calculate recall at k and mean reciprocal rank.

Implement an idempotent ingestion pipeline that parses documents, normalizes text, chunks content, and records provenance.

Format retrieved passages into a bounded context while preserving source identifiers.

Generate answers with source citations and explicit abstention when the available evidence is insufficient.

Apply query rewriting to improve retrieval for conversational or underspecified questions.

Remove redundant passages and compress context without dropping answer-bearing evidence.

Compare naive vector retrieval, hybrid retrieval, and reranking on the same evaluation set.

Implement document update and deletion so stale chunks cannot appear in later answers.

Integrate ingestion, retrieval, grounded generation, and citations into a runnable document-intelligence vertical slice.

Define task-specific acceptance criteria and construct a versioned evaluation dataset from representative cases.

Measure retrieval quality, answer relevance, citation correctness, and groundedness with repeatable checks.

Create a rubric-based model evaluation and calibrate it against a small set of human judgments.

Trace an AI request across retrieval, model calls, tools, latency, tokens, and failures.

Classify a failed RAG response as an ingestion, retrieval, context-construction, or generation problem.

Test a document-based application against prompt injection and attempted data exfiltration.

Enforce trust boundaries, tool permissions, and output validation to limit injection impact.

Define handling rules for secrets, personal data, logs, retention, and deletion in an AI application.

Choose between a deterministic workflow, a router, and an autonomous agent for a stated task.

Specify typed tool contracts with narrow permissions, explicit errors, and test doubles.

Implement a state graph with conditional transitions and a bounded termination rule.

Persist workflow state and resume an interrupted execution from a checkpoint.

Apply timeouts, retries, idempotency, and fallbacks without repeating unsafe side effects.

Insert human approval before sensitive or irreversible tool actions.

Evaluate a tool-using workflow by task success, tool errors, trajectory length, and recovery behavior.

Integrate state, tools, safeguards, and evaluation into a runnable workflow-agent vertical slice.

Preprocess images for a vision model and verify tensor shape, normalization, and batching.

Explain how contrastive image-text training creates a shared embedding space.

Use a local image-text embedding model for zero-shot classification and cross-modal retrieval.

Build an index that retrieves images from text queries while preserving image metadata.

Run a local vision-language model for image description and visual question answering.

Combine OCR text, generated descriptions, and image embeddings in a multimodal retrieval pipeline.

Create a small multimodal evaluation set and measure retrieval and answer quality.

Integrate multimodal ingestion, retrieval, and grounded responses into a runnable vertical slice.

Expose an AI pipeline through a typed asynchronous API with streaming and cancellation behavior.

Apply concurrency limits, queues, timeouts, and backpressure to protect constrained model resources.

Cache embeddings and model results with explicit invalidation, privacy, and correctness rules.

Persist corpus versions and workflow state with schema migrations and reproducible identifiers.

Correlate user feedback with traces, model versions, prompts, retrieved context, and outputs.

Add evaluation thresholds to continuous integration so quality regressions block a release.

Threat-model authentication, rate limiting, tenant isolation, and model-tool access for an AI service.

Package and benchmark a resource-aware local deployment that can later migrate to cloud infrastructure.

Audit the three project vertical slices against representative applied AI engineer job requirements and identify evidence gaps.

Turn the document-intelligence project into a case study covering architecture, evaluation results, failure analysis, and trade-offs.

Turn the workflow-agent project into a case study covering tool safety, recovery behavior, and measured task success.

Turn the multimodal project into a case study covering model selection, retrieval quality, and local-compute constraints.

Create reproducible project demos and setup instructions that a hiring reviewer can verify.

Write quantified résumé bullets that connect engineering decisions to project outcomes.

Solve timed Python exercises involving data transformation, validation, asynchronous I/O, and testing.

Present and defend an LLM system design covering retrieval, evaluation, safety, scaling, and observability.