Machine Learning and AI Foundations

Validate function inputs and raise targeted exceptions with informative messages.

Use Git to inspect, stage, commit, and push focused changes on a branch.

Write and run a pytest unit test for a deterministic Python function.

Evaluate AI-suggested code by tracing, checking documentation, testing, and modifying it before use.

Create NumPy arrays and inspect their dimensions, shapes, and data types.

Use array indexing and Boolean masks to select observations.

Replace element-wise Python loops with NumPy vectorized operations.

Inspect a pandas DataFrame and select rows and columns by label or condition.

Detect and handle missing, duplicated, invalid, and incorrectly typed tabular values.

Compute grouped summaries with pandas aggregation operations.

Combine tables by key using pandas merge operations.

Implement a reusable pandas function that cleans data and creates justified date, count, or ratio features.

Retrieve selected columns and filtered rows with SELECT, WHERE, and ORDER BY.

Summarize groups with SQL aggregate functions and GROUP BY.

Combine related tables with INNER and LEFT JOIN operations.

Structure a multi-step SQL analysis with a common table expression.

Load a SQL query result into a pandas DataFrame for further analysis.

Plot and interpret the distribution of one numeric or categorical variable.

Visualize and describe the relationship between two variables.

Produce a concise exploratory summary that distinguishes evidence-supported findings from hypotheses.

Compute and interpret descriptive summaries including center, spread, quantiles, and correlation.

Calculate probabilities using complements, intersections, and conditional probability.

Distinguish independence from mutually exclusive events in applied examples.

Match Bernoulli, binomial, and normal distributions to suitable data-generating situations.

Explain how sampling distributions and standard errors differ from raw-data distributions.

Construct and interpret a confidence interval for a population quantity.

Conduct a two-group hypothesis test and interpret its p-value without treating it as the probability that a hypothesis is true.

Use vectors, matrices, and dot products to express a linear prediction.

Generate predictions from a multiple linear regression equation.

Fit a linear regression model and interpret a coefficient while holding other included predictors fixed.

Encode categorical predictors and interpret their reference-category coefficients.

Diagnose nonlinearity, unequal residual variance, and influential observations using residual plots.

Quantify uncertainty in regression coefficients and distinguish statistical significance from practical importance.

Distinguish predictive association, confounding, and causal effect in a business question.

Design a randomized experiment by specifying its unit, treatment, outcome, estimand, and assignment procedure.

Estimate an experiment's treatment effect and report its uncertainty, effect size, and practical significance.

Translate a business objective into a supervised-learning target, prediction unit, prediction time, and success criterion.

Identify target leakage by checking whether each feature is available at prediction time.

Choose and create train, validation, and test splits that respect independent, grouped, or time-ordered observations.

Fit numeric and categorical preprocessing with a scikit-learn ColumnTransformer.

Generate naive predictions that establish a minimum-performance benchmark.

Combine preprocessing and an estimator in a scikit-learn Pipeline.

Fit a regularized linear regression pipeline as an interpretable predictive baseline.

Record random seeds, data versions, feature definitions, and library versions needed to reproduce a run.

Select and compute regression metrics aligned with the practical cost of prediction errors.

Fit a logistic regression classifier and interpret its outputs as estimated class probabilities.

Derive accuracy, precision, recall, specificity, and F1 score from a confusion matrix.

Select classification metrics that reflect class prevalence and false-positive and false-negative costs.

Use ROC and precision-recall curves to compare classification behavior across thresholds.

Choose a classification threshold from explicit operational costs or constraints.

Assess whether a classifier's predicted probabilities are calibrated.

Estimate generalization performance with a cross-validation scheme appropriate to the data structure.

Fit a decision tree and trace how its splits produce an individual prediction.

Control decision-tree overfitting with depth, leaf-size, and pruning-related hyperparameters.

Fit a random forest and explain how averaging decorrelated trees reduces prediction variance.

Fit a gradient-boosted tree model and explain its sequential error-correction process.

Tune a bounded hyperparameter search with cross-validation without using the test set.

Compare linear and tree-based candidates under one validation design and select one using performance, interpretability, latency, and data-size constraints.

Measure feature influence with permutation importance on held-out data without interpreting importance as causality.

Compare model errors across meaningful subgroups and document important failure patterns.

Organize source code, tests, configuration, notebooks, and model artifacts in a maintainable repository.

Move environment-specific settings and secrets out of source code into configuration or environment variables.

Implement a command-line training entry point that accepts configuration values.

Serialize and reload a fitted preprocessing-and-model pipeline.

Define and validate the input and output schemas of an inference function.

Add unit tests for preprocessing, prediction shape, and invalid inputs.

Emit structured logs for training events, model metadata, and inference failures.

Run formatting, linting, and tests locally before committing a change.

Implement a FastAPI prediction endpoint that calls a loaded inference pipeline.

Validate API requests and return informative HTTP errors for invalid inputs.

Write an automated test for a prediction API endpoint.

Build a Docker image that runs the prediction service with pinned dependencies.

Run the container locally and verify a prediction request against it.

Configure a continuous-integration workflow that runs linting and tests on each proposed change.

Configure a gated continuous-delivery job that builds a versioned container artifact after continuous-integration checks pass.

Map data preparation, inference, evaluation, and monitoring in predictive ML to analogous components in RAG and agent applications.

Write a capstone problem statement specifying users, target, prediction time, metric, and constraints.

Produce an exploratory analysis that motivates explicit data-quality, feature, and validation decisions.

Implement and evaluate a reproducible baseline training pipeline.

Select a capstone model by comparing justified candidates under one predefined validation design.

Write a model card that reports subgroup error-analysis results, intended use, and important limitations.

Create a single reproducible command that trains and serializes the selected capstone pipeline from a clean checkout.

Run and document an end-to-end acceptance test against the containerized capstone API, from validated request to prediction response.

Publish a portfolio-ready repository with setup and usage instructions, continuous-integration evidence, and a concise technical decision summary.