Comprehensive Artificial Intelligence

Create an isolated Python environment and register it as a Jupyter kernel.

Create and clone Git repositories and exclude local data, environments, and secrets with .gitignore.

Inspect and record code changes using git status, git diff, staging, and commits.

Use branches and pull requests to integrate a code change into a GitHub project.

Resolve a basic merge conflict and synchronize a repository with GitHub.

Refactor notebook code into reusable Python functions and modules with type hints and docstrings.

Load configuration values and secrets from environment variables and handle missing or invalid settings.

Apply vectorized NumPy operations to transform numerical arrays.

Load data into pandas and inspect its schema, data types, ranges, and distributions.

Translate SQL-style filtering, grouping, joining, and reshaping operations into pandas.

Retrieve query results from Azure SQL Database into a pandas DataFrame without embedding credentials in code.

Select and justify a treatment for missing values in a dataset.

Detect and resolve duplicate records, invalid values, and inconsistent categories.

Detect outliers and choose whether to retain, transform, cap, or remove them.

Construct numerical, categorical, and datetime features from raw business data.

Create visualizations that reveal distributions, relationships, and subgroup differences.

Represent observations and model parameters as vectors and matrices.

Calculate and interpret dot products, matrix products, transposes, and vector norms in model computations.

Calculate derivatives of basic single-variable functions used in machine learning.

Calculate partial derivatives and gradients for simple multivariable functions.

Use gradient descent to minimize a simple loss function.

Calculate and interpret mean, median, variance, standard deviation, and quantiles.

Calculate joint and conditional probabilities and apply Bayes' rule to a simple inference problem.

Model simple outcomes with Bernoulli, binomial, and normal distributions and calculate their expected values and variances.

Distinguish populations, samples, parameters, estimators, and estimates in a data problem.

Identify selection bias, measurement bias, and data leakage in a proposed analysis.

Use repeated-sampling simulations to explain sampling distributions, standard errors, and the central limit theorem.

Construct and interpret a confidence interval for a population mean or proportion.

Formulate null and alternative hypotheses for a business question.

Perform and interpret a hypothesis test without treating statistical significance as practical importance.

Calculate and interpret covariance and correlation while avoiding causal claims.

Design and analyze a basic randomized A/B test using an appropriate success metric.

Frame a business problem as a supervised learning task by defining the prediction unit, features, target, and success metric.

Create training, validation, and test sets while preventing target and temporal leakage.

Build a fitted preprocessing pipeline for numerical and categorical features.

Establish a simple baseline model against which trained models can be compared.

Fit and interpret a multiple linear regression model.

Evaluate a regression model using residual plots, MAE, RMSE, and R-squared.

Fit and interpret a logistic regression classifier.

Evaluate a classifier and select a decision threshold using confusion-matrix metrics, ROC-AUC, and precision-recall analysis.

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

Fit a random forest and interpret the effect of feature and sample randomness.

Fit a gradient-boosted tree model for tabular prediction.

Use cross-validation to estimate out-of-sample performance.

Tune hyperparameters using a bounded search and a validation metric.

Compare class weighting and resampling within leakage-safe training pipelines for imbalanced classification.

Compare candidate pipelines under the same validation scheme and select a final model using predictive and operational criteria.

Explain individual and global predictions using permutation importance and SHAP values.

Standardize numerical features and explain why scale affects distance-based methods.

Fit a k-means clustering model and select a defensible number of clusters.

Evaluate whether discovered clusters are stable and useful for a business decision.

Reduce feature dimensionality with principal component analysis and interpret explained variance.

Detect unusual observations using an isolation-based anomaly detector.

Create lag and rolling-window features without using future information.

Evaluate a forecast with rolling-origin backtesting.

Compare seasonal-naive, linear, and tree-based forecasting baselines.

Represent inputs, parameters, and outputs as tensors in PyTorch.

Use automatic differentiation to calculate gradients of a loss with respect to model parameters.

Define a multilayer perceptron for a regression or classification task.

Select output activations and loss functions appropriate to a prediction task.

Train a neural network with mini-batches and the Adam optimizer.

Diagnose underfitting and overfitting from training and validation curves.

Apply early stopping, weight decay, and dropout to reduce overfitting.

Fine-tune a small pretrained text or vision network in Google Colab while controlling which parameters are updated.

Refactor a trained model and its preprocessing into a testable Python package.

Write unit tests for data transformations and prediction behavior.

Track model experiments with reproducible parameters, metrics, and versioned artifacts.

Expose a validated prediction endpoint with FastAPI.

Package an inference service in a Docker container.

Run automated tests and container builds with GitHub Actions.

Deploy a containerized inference service to Azure App Service or Azure Container Apps and verify its health endpoint.

Configure structured logging and telemetry for endpoint latency, errors, and basic input-distribution checks.

Explain next-token prediction and distinguish language-model fluency from factual reliability.

Tokenize text and estimate whether a request fits within a model's context window.

Calculate scaled dot-product attention for a small set of query, key, and value vectors.

Call OpenAI and Claude APIs securely with retries, rate-limit handling, and usage tracking.

Construct prompts with clear instructions, context, examples, and output constraints.

Generate schema-validated structured output from a language model.

Use text embeddings to measure semantic similarity between passages.

Evaluate model responses against a fixed test set and an explicit scoring rubric.

Parse and chunk enterprise documents while preserving useful metadata.

Create a vector index from document-chunk embeddings.

Retrieve relevant chunks for a user query and inspect retrieval failures.

Apply metadata filtering and hybrid keyword-vector search to improve candidate recall.

Re-rank retrieved passage candidates with a cross-encoder model.

Generate grounded answers that cite the retrieved source passages.

Measure retrieval quality and answer quality on a representative evaluation set.

Expose a completed RAG pipeline through a tested service endpoint.

Specify an enterprise capstone use case, evaluation criteria, and whether it requires a deterministic workflow or a bounded agent loop.

Define a tool schema and execute a validated language-model tool call.

Implement explicit session state and distinguish it from durable, validated memory.

Add input controls, output validation, and human approval to a high-impact action.

Mitigate prompt injection, unauthorized retrieval, and accidental disclosure in a RAG system.

Trace an AI workflow and calculate its latency, token usage, and per-request cost.

Implement a bounded orchestrator that invokes an existing prediction API and document-retrieval tool.

Present the capstone with reproducible setup instructions, an architecture diagram, evaluation evidence, and known limitations.