{ "schemaVersion": 1, "roles": [ { "id": "training-engineer", "title": "ML & training engineer", "headline": "Build models that train reliably.", "description": "Turn a dataset and model idea into a reproducible experiment. You define the objective, diagnose learning, keep held-out evaluation isolated and prove a saved run can continue correctly.", "defaultPathwayId": "models", "pathwayIds": [ "models", "tpu" ], "responsibilities": [ "Build and evaluate neural networks", "Design data pipelines and resumable training", "Debug losses, state, and model quality", "Track comparable training runs, data lineage and artifacts with MLflow." ], "skills": [ "Flax NNX and explicit state", "Optax and train/eval steps", "Grain, Orbax, and XProf", "MLflow experiment provenance", "Masked and contrastive pretraining; response-only SFT, LoRA and preference optimization; numerical architecture parity" ], "portfolio": "A run dossier: data split, configuration, learning curves, error examples and a restart comparison.", "readiness": "Demonstrate that your model trains, evaluates, resumes correctly, and produces reproducible results.", "background": "Use foundations to become comfortable with shapes, scalar losses, gradients and explicit state. Then practice train/evaluation separation in the classifier before adding recovery and sequence models.", "milestones": [ { "title": "Build the shared CPU foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Train and evaluate a small model", "phaseIds": [ "networks" ], "deliverable": "A reproducible classifier", "criteria": [ "Keep train and evaluation behavior separate and reproduce metrics from a saved configuration." ] }, { "title": "Prove full-state recovery", "phaseIds": [ "recovery" ], "deliverable": "An interrupted run restored with its full state", "criteria": [ "Compare resumed and uninterrupted runs under a stated determinism tolerance." ] }, { "title": "Diagnose and improve training speed", "phaseIds": [ "performance" ], "deliverable": "A trace-backed before-and-after performance report", "criteria": [ "Separate compilation, execution, input stalls, and synchronization before claiming a speedup." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can implement and explain JAX transformations." }, { "phaseId": "state", "question": "I can implement and explain State, randomness & control flow." }, { "phaseId": "optimization", "question": "I can implement and explain Math & optimization." } ], "workExample": "Compare two training runs whose validation losses disagree. Trace the difference through data IDs, initialization, optimizer state and precision.", "modalityTrackIds": [ "image", "text", "audio" ], "reviewQuestions": [ "How did you keep validation data and evaluation state out of training?", "Which saved values are required to reproduce the next update after interruption?", "Which error examples explain the learning curve, and does the result hold under a new seed?", "How would you recover the exact code, data and metric definition behind the selected MLflow run?", "How would you detect target leakage, an incorrect preference denominator or the first PyTorch/Flax layer mismatch?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "Flax NNX and explicit state", "lessonIds": [ "networks-02" ], "projectId": "mlp-classifier", "evidence": "Inspect graph/state and check a known-parameter forward pass.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1" ] }, { "skill": "Optax and train/eval steps", "lessonIds": [ "networks-03" ], "projectId": "mlp-classifier", "evidence": "Verify an update independently and show evaluation does not mutate training state.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "2", "3" ] }, { "skill": "Grain, Orbax, and XProf", "lessonIds": [ "recovery-04" ], "projectId": "sharded-training", "evidence": "Compare resumed and uninterrupted state and inspect a real CPU trace.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 4 project preparation lessons lie outside the required route", "stageIds": [ "3", "4" ] }, { "skill": "MLflow experiment provenance", "lessonIds": [ "recovery-06" ], "projectId": "reproducible-experiments", "evidence": "Reload tracked metrics and identities and reproduce a paired comparison.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3", "4" ] }, { "skill": "Masked and contrastive pretraining; response-only SFT, LoRA and preference optimization; numerical architecture parity", "lessonIds": [ "pretraining-01" ], "projectId": "training-methods", "evidence": "Defend masks, objective reductions and held-out checks; these optional objective labs do not certify a complete adapted model.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 8 project preparation lessons lie outside the required route", "stageIds": [ "1", "2", "3", "4", "5", "6", "7", "8" ] } ] }, { "id": "research-engineer", "title": "Research engineer", "headline": "Turn mathematical ideas into experiments.", "description": "Turn a proposed method into an experiment that can support or refute a claim. Your work connects mathematical assumptions, a simple baseline, independent checks and carefully bounded conclusions.", "defaultPathwayId": "internals", "pathwayIds": [ "internals", "probability" ], "responsibilities": [ "Prototype differentiable algorithms", "Investigate uncertainty and inference", "Run controlled experiments and numerical checks", "Keep experiment provenance and independent evaluation definitions." ], "skills": [ "JVPs, VJPs, and custom derivatives", "jaxpr and program inspection", "Hand-built HMC/VI diagnostics; optional NumPyro extension", "MLflow experiment provenance" ], "portfolio": "A reproducibility report with a baseline, ablation, numerical checks and unresolved limitations.", "readiness": "Explain the assumptions of your method and support a conclusion with correctness checks and an appropriate baseline.", "background": "Python, array reasoning and calculus help. Complete gradient checking and controlled experiments before comparing architectures or extending derivative rules.", "milestones": [ { "title": "Build the shared foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Inspect and verify a differentiable method", "phaseIds": [ "internals" ], "deliverable": "A custom derivative with an explained jaxpr", "criteria": [ "Explain tracing and verify the derivative rule numerically." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "Reproduce a baseline, change one mechanism, and explain whether the result survives a new seed and a fixed evaluation set.", "modalityTrackIds": [ "text", "image", "cross-modal" ], "reviewQuestions": [ "Which independent calculation checks the mechanism you changed?", "What did you hold fixed in the baseline and ablation, and which seeds changed?", "What alternative explanation remains consistent with your results?", "What information besides a Git commit is needed to reproduce an experiment with changed data?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "JVPs, VJPs, and custom derivatives", "lessonIds": [ "internals-03" ], "projectId": "derivative-audit", "evidence": "Check derivative linearity, finite differences and higher-order behavior.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2" ] }, { "skill": "jaxpr and program inspection", "lessonIds": [ "internals-04" ], "projectId": "derivative-audit", "evidence": "Explain supported primitives and reject unsupported programs.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3" ] }, { "skill": "Hand-built HMC/VI diagnostics; optional NumPyro extension", "lessonIds": [ "probability-03" ], "projectId": "bayesian-regression", "evidence": "Compare posterior moments and sampler diagnostics against the exact target; NumPyro remains an optional library extension.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 4 project preparation lessons lie outside the required route", "stageIds": [ "2", "3" ] }, { "skill": "MLflow experiment provenance", "lessonIds": [ "recovery-06" ], "projectId": "reproducible-experiments", "evidence": "Freeze the question, retain failed attempts and interpret complete paired results.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 3 project preparation lessons lie outside the required route", "stageIds": [ "1", "2", "3", "4" ] } ] }, { "id": "scientific-ml", "title": "Scientific ML engineer", "headline": "Simulate systems. Learn their hidden parameters.", "description": "Connect observations to a numerical or physical model. You check derivatives and solver behavior, fit parameters and explain how noise, conditioning and model assumptions affect the answer.", "defaultPathwayId": "science", "pathwayIds": [ "science" ], "responsibilities": [ "Build and batch numerical simulations", "Differentiate through dynamics and solvers", "Recover parameters from observed trajectories", "Version simulation inputs, solver settings and inferred-parameter artifacts." ], "skills": [ "scan and batched simulation", "Solver sensitivities; optional Diffrax extension", "Numerical accuracy and inverse problems", "MLflow experiment provenance" ], "portfolio": "An inverse-problem report with reference solutions, sensitivity checks and a held-out observation test.", "readiness": "Verify parameter recovery, gradient accuracy, and simulation stability on a stated test problem.", "background": "Bring a physical or numerical question and basic calculus. The shared foundations introduce JAX; the science sequence develops discretization, sensitivity and inverse-problem checks on small CPU examples.", "milestones": [ { "title": "Build the shared foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Recover a hidden physical parameter", "phaseIds": [ "science" ], "deliverable": "A differentiable inverse problem", "criteria": [ "Recover a known physical parameter and report error, stability, and gradient checks." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "A parameter fit looks accurate but changes sharply when observations move slightly. Separate numerical error from weak identifiability.", "modalityTrackIds": [], "reviewQuestions": [ "Does the inferred parameter converge when you refine the time grid?", "Do solver sensitivities agree with independent finite differences?", "Can different parameters explain the same observations, and what extra measurement would distinguish them?", "Which model and solver configuration does the recorded experiment actually validate?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "scan and batched simulation", "lessonIds": [ "science-02" ], "projectId": "scientific-inverse", "evidence": "Verify batch/time axis contracts and a known trajectory.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1" ] }, { "skill": "Solver sensitivities; optional Diffrax extension", "lessonIds": [ "science-03" ], "projectId": "scientific-inverse", "evidence": "Compare the discrete derivative and a refined-grid continuous reference; Diffrax is optional extension work.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "2" ] }, { "skill": "Numerical accuracy and inverse problems", "lessonIds": [ "science-04" ], "projectId": "scientific-inverse", "evidence": "Separate parameter error, prediction error and solver bias.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3" ] }, { "skill": "MLflow experiment provenance", "lessonIds": [ "recovery-06" ], "projectId": "reproducible-experiments", "evidence": "Attach configuration, source/data identities and a justified comparison to a research notebook.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 3 project preparation lessons lie outside the required route", "stageIds": [ "1", "2", "3", "4" ] } ] }, { "id": "rl-engineer", "title": "RL engineer", "headline": "Build agents that learn by interacting.", "description": "Build experiments in which actions change later observations. You keep environment state, random sampling and policy updates reproducible, and evaluate improvement across seeds and conditions.", "defaultPathwayId": "rl", "pathwayIds": [ "rl" ], "responsibilities": [ "Build reproducible environments and rollouts", "Implement and diagnose policy updates", "Evaluate agents across independent seeds", "Track environment, policy and seed identities across evaluations." ], "skills": [ "Vectorized environments and PRNG", "scan-based rollouts", "Policy gradients and PPO", "MLflow experiment provenance" ], "portfolio": "A policy-learning report with fixed evaluation conditions, seed variation and trajectory-level failure analysis.", "readiness": "Show that the evaluation measures policy improvement rather than a lucky seed or a changed environment.", "background": "Be comfortable with a scalar objective, gradients, random keys and a training update. The route teaches functional environments and sampled objectives using a small finite environment.", "milestones": [ { "title": "Build the shared foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Build a policy model", "phaseIds": [ "networks" ], "deliverable": "A reproducible classifier", "criteria": [ "Keep train and evaluation behavior separate and reproduce metrics from a saved configuration." ] }, { "title": "Evaluate a learning agent", "phaseIds": [ "rl" ], "deliverable": "An evaluated policy in a functional environment", "criteria": [ "Compare a trained policy to a baseline across several seeds and report variability." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "Training reward rises while evaluation reward falls. Check leakage, environment termination, sampling and the evaluation policy.", "modalityTrackIds": [], "reviewQuestions": [ "Are terminal transitions and padded steps handled correctly in return targets?", "How do results vary across trained seeds under the same held-out evaluation protocol?", "Does the policy-gradient estimate agree with the enumerated small-state reference?", "How do you compare logged policy runs without mixing training return and held-out evaluation?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "Vectorized environments and PRNG", "lessonIds": [ "rl-01" ], "projectId": "policy-evaluation", "evidence": "Check transitions, termination and owned random streams.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1" ] }, { "skill": "scan-based rollouts", "lessonIds": [ "rl-02" ], "projectId": "policy-evaluation", "evidence": "Preserve active masks and return bookkeeping across time and environments.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "2" ] }, { "skill": "Policy gradients and PPO", "lessonIds": [ "rl-03" ], "projectId": "policy-evaluation", "evidence": "Check signed clipping cases and compare held-out returns with the exact evaluator.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3", "4" ] }, { "skill": "MLflow experiment provenance", "lessonIds": [ "recovery-06" ], "projectId": "reproducible-experiments", "evidence": "Keep training and evaluation seeds separate and retain complete run inventories.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 1 project preparation lessons lie outside the required route", "stageIds": [ "1", "2", "3", "4" ] } ] }, { "id": "performance-engineer", "title": "Accelerator & performance engineer", "headline": "Find bottlenecks. Scale the right computation.", "description": "Measure where a workload spends time and memory, then improve the limiting operation while preserving its numerical contract. Explain when an optimization helps and when it does not.", "defaultPathwayId": "scale", "pathwayIds": [ "scale" ], "responsibilities": [ "Diagnose compute, input, and communication bottlenecks", "Partition workloads across devices", "Optimize custom kernels when justified", "Preserve runtime/image identity and workload contracts in benchmark evidence." ], "skills": [ "XProf, HLO, and roofline reasoning", "Meshes, sharding, and distributed recovery", "Pallas and reference correctness checks", "MLflow experiment provenance" ], "portfolio": "A correctness-backed benchmark with synchronized latency, throughput, memory and scaling limits.", "readiness": "Preserve correctness, separate compile time from execution, and justify the improvement using workload measurements.", "background": "Start with a correct training loop and understand its data and state. Profiling requires a reproducible workload; distributed execution adds placement and communication contracts.", "milestones": [ { "title": "Build the shared CPU foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Build a reference workload", "phaseIds": [ "networks" ], "deliverable": "A reproducible classifier", "criteria": [ "Keep train and evaluation behavior separate and reproduce metrics from a saved configuration." ] }, { "title": "Make it recoverable", "phaseIds": [ "recovery" ], "deliverable": "An interrupted run restored with its full state", "criteria": [ "Compare resumed and uninterrupted runs under a stated determinism tolerance." ] }, { "title": "Find its measured bottleneck", "phaseIds": [ "performance" ], "deliverable": "A trace-backed before-and-after performance report", "criteria": [ "Separate compilation, execution, input stalls, and synchronization before claiming a speedup." ] }, { "title": "Partition it across devices", "phaseIds": [ "distributed" ], "deliverable": "A resilient sharded training experiment", "criteria": [ "Explain partitioning, communication costs, and recovery behavior with measured evidence." ] }, { "title": "Optimize a checked kernel", "phaseIds": [ "kernels" ], "deliverable": "A measured custom kernel with correctness checks", "criteria": [ "Compare against a reference across shapes and justify each optimization with evidence." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "A faster-looking run excluded compilation or returned before device work completed. Rebuild the benchmark and compare identical workloads.", "modalityTrackIds": [ "image", "text" ], "reviewQuestions": [ "Did every timing wait for completion and separate compilation from steady execution?", "Which trace event or memory-traffic estimate supports the claimed bottleneck?", "Does the optimization preserve results across changed shapes, and where does it stop helping?", "How would you distinguish an image/runtime change from a model optimization in your benchmark?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "XProf, HLO, and roofline reasoning", "lessonIds": [ "performance-03" ], "projectId": "sharded-training", "evidence": "Read an actual CPU trace and separate compilation from steady work; target measurements are separate.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "4" ] }, { "skill": "Meshes, sharding, and distributed recovery", "lessonIds": [ "distributed-02" ], "projectId": "sharded-training", "evidence": "Check count-weighted global updates and fresh-process recovery.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3" ] }, { "skill": "Pallas and reference correctness checks", "lessonIds": [ "kernels-04" ], "projectId": "kernel-audit", "evidence": "Compare independent numerical references and declare interpreted versus target execution.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3" ] }, { "skill": "MLflow experiment provenance", "lessonIds": [ "recovery-06" ], "projectId": "reproducible-experiments", "evidence": "Keep comparable configurations and observed measurements, including failed runs.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3", "4" ] } ] }, { "id": "inference-engineer", "title": "Inference & deployment engineer", "headline": "Make a trained model usable.", "description": "Package a trained model so another process or device can use it reliably. Own preprocessing, exported predictions, precision choices and measurements under a defined request workload.", "defaultPathwayId": "ship", "pathwayIds": [ "ship" ], "responsibilities": [ "Adapt and export trained computations", "Measure serving latency and throughput", "Plan batching, capacity, and rollout behavior", "Validate precision tradeoffs and execution on target edge devices", "Package non-root containers, verify readiness and preserve preprocessing/model/image identity." ], "skills": [ "JAX, Keras, TensorFlow and PyTorch interoperability", "JAX export and artifact verification", "Weight, activation and accumulation precision", "Edge deployment and capacity analysis", "Containerized delivery and release evidence" ], "portfolio": "A deployment dossier with parity tests, precision tradeoffs, target-runtime measurements and rollback criteria.", "readiness": "Reproduce exported predictions and defend the serving plan under a clearly stated workload.", "background": "Begin with a trained model and a reproducible prediction. You will need array shapes, saved state and a baseline measurement before reasoning about conversion, quantization or capacity.", "milestones": [ { "title": "Build the shared CPU foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Produce a trained artifact", "phaseIds": [ "networks" ], "deliverable": "A reproducible classifier", "criteria": [ "Keep train and evaluation behavior separate and reproduce metrics from a saved configuration." ] }, { "title": "Reproduce its saved state", "phaseIds": [ "recovery" ], "deliverable": "An interrupted run restored with its full state", "criteria": [ "Compare resumed and uninterrupted runs under a stated determinism tolerance." ] }, { "title": "Measure a reference workload", "phaseIds": [ "performance" ], "deliverable": "A trace-backed before-and-after performance report", "criteria": [ "Separate compilation, execution, input stalls, and synchronization before claiming a speedup." ] }, { "title": "Verify serving and capacity", "phaseIds": [ "deployment" ], "deliverable": "An inference artifact and capacity plan", "criteria": [ "Measure latency and throughput under a stated workload and test the exported artifact.", "Compare precision policies and distinguish CPU proxy results from measured edge-device behavior." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "A converted model passes one example but fails on a changed shape or rare class. Locate the mismatch before comparing speed.", "modalityTrackIds": [ "image", "text", "audio", "cross-modal" ], "reviewQuestions": [ "Do preprocessing, weight layout and output meanings agree across the source and exported runtimes?", "What changed when you reduced weight, activation or accumulation precision?", "Which latency and throughput measurements support the capacity plan, and which device claims remain unmeasured?", "What checks would reject a container that starts successfully but loads the wrong model version?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "JAX, Keras, TensorFlow and PyTorch interoperability", "lessonIds": [ "deployment-08" ], "projectId": "weight-conversion", "evidence": "Locate the first numerical disagreement and reload the mapped artifact.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3" ] }, { "skill": "JAX export and artifact verification", "lessonIds": [ "deployment-03" ], "projectId": "deployment-audit", "evidence": "Reload exported bytes and reject incompatible input signatures.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "2" ] }, { "skill": "Weight, activation and accumulation precision", "lessonIds": [ "deployment-05" ], "projectId": "deployment-audit", "evidence": "Account for weights, activations, accumulator and scales separately.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "2" ] }, { "skill": "Edge deployment and capacity analysis", "lessonIds": [ "deployment-06" ], "projectId": "deployment-audit", "evidence": "Separate observed CPU timing, queue simulation and unqualified edge-device measurements.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3" ] }, { "skill": "Containerized delivery and release evidence", "lessonIds": [ "deployment-07" ], "projectId": "engineering-release", "evidence": "Verify model identity, readiness and release/rollback gates; real container/runtime qualification is separate.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Optional project extension; 3 project preparation lessons lie outside the required route", "stageIds": [ "4" ] } ] }, { "id": "operations-engineer", "title": "JAX / accelerator operations engineer", "headline": "Keep real workloads observable and recoverable.", "description": "Make model workloads observable and recoverable. Track progress and resource use, diagnose failed or stalled runs and rehearse recovery before relying on it.", "defaultPathwayId": "ops", "pathwayIds": [ "ops", "scale" ], "responsibilities": [ "Manage accelerator jobs and runtime lifecycle", "Monitor throughput, stalls, and checkpoint health", "Test failure recovery and plan capacity", "Own MLOps release gates, LLMOps trace/evaluation versions and ModelOps approvals, rollback and retirement." ], "skills": [ "Distributed JAX and workload configuration", "Grain, Orbax, and recovery protocols", "Profiling, observability, and operational runbooks", "Containerized delivery and release evidence" ], "portfolio": "An incident runbook with a deliberate interruption, recovery evidence and a measured resource budget.", "readiness": "Detect and diagnose a controlled failure, restore full workload state, and explain operational tradeoffs.", "background": "Understand the values that make a training update reproducible. Basic process lifecycle and filesystem knowledge help when rehearsing worker failure, checkpoint acceptance and rollback.", "milestones": [ { "title": "Build the shared CPU foundation", "phaseIds": [ "welcome", "arrays", "transforms", "state", "optimization" ], "deliverable": "A reproducible regression fit with checked gradients and explicit random state.", "criteria": [ "Explain array shapes and pure functions", "Compose grad, vmap, and jit", "Verify a loss and parameter update" ] }, { "title": "Run a reference job", "phaseIds": [ "networks" ], "deliverable": "A reproducible classifier", "criteria": [ "Keep train and evaluation behavior separate and reproduce metrics from a saved configuration." ] }, { "title": "Verify a recovery point", "phaseIds": [ "recovery" ], "deliverable": "An interrupted run restored with its full state", "criteria": [ "Compare resumed and uninterrupted runs under a stated determinism tolerance." ] }, { "title": "Observe and diagnose workload behavior", "phaseIds": [ "performance" ], "deliverable": "A trace-backed before-and-after performance report", "criteria": [ "Separate compilation, execution, input stalls, and synchronization before claiming a speedup." ] }, { "title": "Operate a sharded job", "phaseIds": [ "distributed" ], "deliverable": "A resilient sharded training experiment", "criteria": [ "Explain partitioning, communication costs, and recovery behavior with measured evidence." ] }, { "title": "Rehearse failure and recovery", "phaseIds": [ "operations" ], "deliverable": "An observable local job, a deliberate worker failure and a tested restore/rollback runbook; accelerator transfer needs a separate target run.", "criteria": [ "Diagnose a failed or stalled child from recorded events and terminate/reap it safely.", "Compare resumed sample state and losses with an uninterrupted reference.", "Reject a degraded artifact using actual held-out predictions; document rollback and a capacity hypothesis." ] } ], "startingPointChecks": [ { "phaseId": "welcome", "question": "I can set up JAX and identify the device running my code." }, { "phaseId": "arrays", "question": "I can predict array shapes and write a pure function." }, { "phaseId": "transforms", "question": "I can compose grad, vmap, and jit and explain recompilation." }, { "phaseId": "state", "question": "I can pass random keys and state through a compiled loop." }, { "phaseId": "optimization", "question": "I can check a gradient and implement a loss and optimizer update." } ], "workExample": "A job restarts with the right weights but a different data position. Compare subsequent sample IDs and optimizer steps before accepting recovery.", "modalityTrackIds": [ "image", "text", "audio", "cross-modal" ], "reviewQuestions": [ "Which signal distinguishes slow progress from a failed or stalled worker?", "How do you know the restored job uses the accepted checkpoint and correct next data batch?", "Which artifact would you roll back to, and what evidence triggers that decision?", "When does a changed artifact invalidate approval, and how do you prove a failed rollout left the previous release active?" ], "scopeNote": "This is a learning route for practicing the work, not a claim of job readiness. Use the milestone coverage and a reviewer’s feedback to identify what remains to demonstrate. The capability map below separates required route practice from optional extensions. Public checks and self-reported completion are not independent review or hardware qualification.", "skillEvidence": [ { "skill": "Distributed JAX and workload configuration", "lessonIds": [ "distributed-04" ], "projectId": "sharded-training", "evidence": "Explain ownership and replay boundaries; multi-host TPU qualification is separate.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3" ] }, { "skill": "Grain, Orbax, and recovery protocols", "lessonIds": [ "recovery-05" ], "projectId": "workload-operations", "evidence": "Distinguish checkpoint requested, completed and accepted before recovery.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3" ] }, { "skill": "Profiling, observability, and operational runbooks", "lessonIds": [ "operations-03" ], "projectId": "workload-operations", "evidence": "Retain a failed process, diagnose the symptom and verify continuation.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "1", "2", "3" ] }, { "skill": "Containerized delivery and release evidence", "lessonIds": [ "operations-08" ], "projectId": "engineering-release", "evidence": "Bind approval and rollback to immutable model and evaluation identities.", "reviewCriterion": "Explain the independent check, repeat it under a changed condition and retain the observed result.", "scope": "Required route practice", "stageIds": [ "3" ] } ] } ], "domains": [ { "id": "training", "title": "Training & model development", "headline": "Build a model that learns.", "description": "Move from a loss and a handwritten update to neural networks, Transformers, reproducible data, and recoverable training.", "skills": [ "Design models and optimization loops", "Evaluate quality and debug training", "Checkpoint and reproduce complete runs" ], "pathwayIds": [ "models", "tpu", "rl" ], "defaultPathwayId": "tpu", "roleIds": [ "training-engineer", "rl-engineer" ], "artifact": "A trained, evaluated model with reproducible state recovery." }, { "id": "inference", "title": "Inference & deployment", "headline": "Make trained models useful.", "description": "Verify model exports across frameworks, compare weight and activation precision, and measure serving and edge workloads.", "skills": [ "Framework interoperability and verified exports", "Weight and activation precision policies", "Edge runtime contracts and serving measurements" ], "pathwayIds": [ "ship" ], "defaultPathwayId": "ship", "roleIds": [ "inference-engineer" ], "artifact": "A verified inference artifact and a measured serving plan." }, { "id": "ops", "title": "Operations & accelerator systems", "headline": "Keep workloads fast and dependable.", "description": "Operate jobs, trace bottlenecks, recover from failures, shard across devices, and optimize kernels when the evidence calls for it.", "skills": [ "Monitor jobs and test recovery", "Profile and plan accelerator capacity", "Scale workloads and optimize bottlenecks" ], "pathwayIds": [ "ops", "scale" ], "defaultPathwayId": "ops", "roleIds": [ "operations-engineer", "performance-engineer" ], "artifact": "An observable workload, a recovery runbook, and a performance report." }, { "id": "research", "title": "Research & scientific computing", "headline": "Turn ideas into tested experiments.", "description": "Differentiate simulations, model uncertainty, inspect transformed programs, and validate methods with numerical evidence.", "skills": [ "Build differentiable simulations", "Fit parameters and model uncertainty", "Check derivatives and compare methods" ], "pathwayIds": [ "science", "probability", "internals" ], "defaultPathwayId": "science", "roleIds": [ "scientific-ml", "research-engineer" ], "artifact": "A validated simulation, inverse problem, or research experiment." } ] }