AI Infrastructure

Write a Python script using variables, collections, loops, and conditionals.

Organize reusable Python logic into functions and imported modules.

Read, transform, and write CSV and JSON data with Python.

Create a virtual environment and install reproducible, pinned Python dependencies.

Handle expected failures with exceptions and meaningful process exit codes.

Build a command-line Python program that accepts arguments and environment-based configuration.

Write and run unit tests for Python functions with pytest.

Track a project with Git by staging changes, creating commits, and inspecting history.

Develop a change on a Git branch and merge it back into the main branch.

Trace how DNS, IP addresses, ports, and TCP connect a client to a network service.

Diagnose a basic connectivity failure using dig, curl, ping, and ss.

Interpret the method, headers, status code, and body of an HTTP exchange.

Call a JSON REST API from Python and handle unsuccessful responses.

Expose a health-check endpoint with FastAPI and test it locally.

Identify the features, target, training phase, and inference phase in a supervised-learning workflow.

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

Fit a preprocessing transformation on training data and apply it consistently to unseen data.

Train a baseline classification or regression model with scikit-learn.

Select and compute an evaluation metric appropriate to a model task.

Diagnose underfitting and overfitting from training and validation results.

Serialize a trained model and reload it to reproduce predictions.

Compare the compute and memory demands of classical models, neural-network training, and neural-network inference.

Create PyTorch tensors and reason about their shapes, data types, and device placement.

Define a small neural network and execute its forward pass.

Compute gradients for model parameters with PyTorch automatic differentiation.

Implement a training loop with batches, a loss function, and an optimizer.

Save and resume model and optimizer state from a checkpoint.

Run the same PyTorch workload on a CPU or CUDA device through device-aware code.

Explain the roles of container images, containers, layers, and registries.

Write a Dockerfile for a Python application with pinned dependencies.

Build an image and run its application in an isolated container.

Configure a container through port mappings, environment variables, and mounted volumes.

Inspect a running container through its logs, process list, and interactive shell.

Reduce image size and run the container as a non-root user.

Tag an image and push it to a container registry.

Trace the lineage from a source dataset through code, parameters, metrics, and a model artifact.

Implement deterministic preprocessing that produces the same output from the same input.

Validate a dataset against expected columns, data types, and value ranges.

Record training parameters, metrics, and artifacts in an MLflow experiment.

Register a model version and move it through explicit lifecycle stages or aliases.

Assemble preprocessing, training, evaluation, and packaging into a repeatable pipeline.

Run a parameterized pipeline with a workflow orchestrator and inspect task states and failures.

Choose among batch, synchronous online, and asynchronous inference for a stated workload.

Implement a FastAPI prediction endpoint around a previously trained model.

Enforce request and response schemas and return appropriate API errors.

Measure inference latency percentiles and throughput under a controlled load.

Configure concurrent serving workers and measure their effect on latency and throughput.

Apply request batching and determine when it improves serving efficiency.

Quantize a model and compare its accuracy, size, and inference latency with the original.

Explain how Kubernetes control-plane components manage pods and desired state.

Create a local Kubernetes cluster and inspect its resources with kubectl.

Deploy a containerized inference service from a declarative Kubernetes manifest.

Expose an inference deployment through a Kubernetes Service.

Inject non-secret and secret configuration with ConfigMaps and Secrets.

Set resource requests, resource limits, liveness probes, and readiness probes for an inference workload.

Scale, update, roll back, and inspect the rollout history of an inference deployment.

Explain why GPU cores, accelerator memory, and host-to-device transfers affect AI workload performance.

Measure GPU utilization, accelerator memory usage, and active processes with standard monitoring tools.

Estimate memory required for model parameters, gradients, optimizer state, and activations.

Describe how all-reduce enables gradient synchronization in data-parallel training.

Launch a small multi-process PyTorch Distributed Data Parallel job on available CPU or GPU devices.

Choose among data, tensor, pipeline, and model parallelism for a stated scaling constraint.

Configure a Kubernetes workload to request an advertised GPU resource and verify its allocation.

Map compute, object storage, networking, identity, registry, and orchestration needs to vendor-neutral cloud service categories.

Configure cloud budget alerts and remove unused resources after a lab.

Store and retrieve a model artifact in cloud object storage using a least-privilege identity.

Provision a low-cost cloud resource from a version-controlled Terraform configuration.

Deploy a containerized inference API to a managed cloud container service.

Create a continuous-integration workflow that tests code and builds and scans a container image.

Create a controlled delivery workflow that deploys a versioned image and supports rollback.

Emit structured application logs with request identifiers while excluding sensitive values.

Instrument an inference API with request-rate, error-rate, and latency metrics.

Build a dashboard that reveals the health and resource usage of an inference service.

Define a measurable service-level indicator and objective for an inference workload.

Configure an alert and investigate a simulated latency or availability incident.

Detect a shift in production input data relative to a stored reference dataset.

Write an operational runbook covering diagnosis, rollback, recovery verification, and cloud-resource cleanup.