Software Engineering

Use command-line commands to navigate directories, inspect files, and run Python programs.

Create an isolated Python environment and install dependencies from a pinned requirements file.

Initialize a Git repository, create commits, and inspect the repository history.

Create a Git branch, merge it, and resolve a simple merge conflict.

Organize reusable Python code as a package with a command-line entry point.

Add type hints to Python functions and check them with a static type checker.

Write and run unit tests for Python functions with pytest.

Add configurable structured logging to a Python application.

Use NumPy array operations and broadcasting to replace explicit Python loops.

Load a dataset into pandas and inspect its shape, data types, and summary statistics.

Handle missing values using explicit imputation or exclusion rules.

Transform and aggregate tabular data with pandas group-by operations.

Combine related tables with pandas joins while checking row-count assumptions.

Write SQL queries using SELECT, WHERE, GROUP BY, and aggregate functions.

Join relational tables in SQL using appropriate join keys and join types.

Create distribution and target-relationship plots with Matplotlib and Seaborn.

Evaluate and graph linear, exponential, and logarithmic functions used in machine-learning models and losses.

Represent data as vectors and matrices and compute matrix-vector products.

Calculate and interpret mean, variance, covariance, and correlation.

Distinguish Bernoulli and normal random variables and calculate simple probabilities from each distribution.

Calculate conditional probabilities and apply Bayes’ rule to a diagnostic example.

Estimate uncertainty in a sample mean using its standard error and a confidence interval.

Interpret a derivative as a rate of change and compute derivatives of simple functions.

Compute the gradient of a simple loss and use it to perform one gradient-descent update.

Frame a business or product question as a supervised-learning task with a defined target and prediction unit.

Choose an evaluation metric that reflects the costs of relevant prediction errors.

Split data into training, validation, and test sets while preserving an untouched final evaluation set.

Identify target leakage in features, preprocessing, or data splitting.

Build a scikit-learn preprocessing pipeline for numeric and categorical features.

Create a naive baseline against which trained models can be compared.

Estimate model performance with cross-validation.

Evaluate an imbalanced classifier with class-sensitive metrics and a tuned decision threshold.

Fit a linear regression model and interpret its coefficients and residual errors.

Apply L1 or L2 regularization and explain its effect on a linear model.

Fit a logistic regression classifier and interpret its predicted probabilities.

Fit a decision tree and control its complexity to reduce overfitting.

Train a random forest and compare its validation performance with a single tree.

Train a gradient-boosted tree model for tabular prediction.

Tune selected hyperparameters with randomized search without using the test set.

Compute and interpret permutation feature importance for a fitted model.

Segment prediction errors by a meaningful data cohort to identify systematic weaknesses.

Assess probability calibration and recalibrate an overconfident classifier.

Reduce feature dimensionality with principal component analysis while tracking explained variance.

Cluster unlabeled observations with k-means and evaluate whether the resulting clusters are useful.

Train and evaluate a forecasting model against a naive baseline using time-ordered backtesting.

Generate content-based recommendations from item features and similarity scores.

Build a user-item collaborative-filtering model from interaction data.

Evaluate collaborative-filtering recommendations with a ranking metric.

Create PyTorch tensors and perform shape-safe tensor operations.

Use automatic differentiation to compute gradients of a scalar loss.

Define a feed-forward neural network with PyTorch modules.

Implement a mini-batch training and validation loop.

Select an optimizer and learning rate using training and validation curves.

Apply early stopping to prevent overfitting in a neural-network training loop.

Save and load a trained model for inference using the correct evaluation mode.

Record model configuration, random seeds, and metrics for a reproducible experiment.

Convert labeled images into normalized tensors and apply training-time augmentation.

Train a small convolutional network for image classification.

Extract image features with a pretrained vision backbone.

Fine-tune selected layers of a pretrained vision model on a new dataset.

Tokenize text into model-ready IDs, masks, and padded batches.

Compute text embeddings and use cosine similarity to compare semantic relatedness.

Trace the self-attention calculation for a small set of token representations.

Fine-tune a pretrained transformer for text classification and report per-class performance.

Call a hosted language model from Python and record token usage, latency, and estimated cost.

Constrain language-model responses to a validated structured-output schema.

Create a small evaluation set and scoring rubric for a prompt-based task.

Chunk source documents and store their embeddings in a searchable vector index.

Retrieve and rerank relevant passages for a user query.

Generate a retrieval-grounded answer with citations to the supplied passages.

Implement a bounded tool-calling loop that executes function calls and updates conversation state up to a maximum iteration limit.

Evaluate a tool-calling language-model application for prompt-injection vulnerabilities and apply appropriate defenses.

Specify a versioned REST API contract for model or AI-pipeline inference.

Expose predictions from a saved model or AI pipeline through a FastAPI endpoint.

Validate inference requests and responses with typed schemas.

Write an integration test for an inference API.

Package an inference service as a Docker container.

Load environment-specific settings from environment variables and pass secrets securely into a container.

Configure continuous integration to run formatting, type, and test checks on each change.

Deploy a containerized inference service to a managed cloud platform and verify its health endpoint.

Create a reproducible pipeline that runs data preparation, training, and evaluation stages.

Track experiment parameters, metrics, and artifacts in an experiment-tracking system.

Version a dataset and reproduce the model built from a specified data version.

Register a model artifact with its evaluation metadata and lifecycle stage.

Define automated quality gates that block deployment when required metrics fail.

Detect feature-distribution drift between reference and production data.

Monitor delayed model performance after production labels become available.

Define retraining, staged-rollout, and rollback criteria for a production model.

Define a capstone problem, intended users, system constraints, acceptance criteria, and offline evaluation metrics.

Create a capstone repository with dependency management, configuration, tests, and automated quality checks.

Implement a reproducible command that validates and prepares the capstone data.

Implement a reproducible command that builds or trains, evaluates, and saves the selected model or AI pipeline.

Connect the saved model or AI pipeline to a validated inference API and verify it with an integration test.

Containerize and deploy the capstone inference service, then verify its health endpoint.

Instrument the deployed service and verify one model-quality or retrieval-quality monitoring check.

Publish a portfolio-ready README and model card containing an architecture diagram, decisions, limitations, reproduction steps, and results.