Databricks Machine Learning Associate study plan

Describe how the Databricks Machine Learning workspace organizes notebooks, clusters, repos, and experiments, and diagram that relationship from memory

Configure a single-node and a multi-node cluster, then explain which settings control runtime version, autoscaling, and library installation

Install a Python ML library at both the cluster and notebook scope, then identify which scope wins when versions conflict

Run a minimal training script on a Databricks cluster and read the driver logs to diagnose one intentionally introduced failure

Compare the Databricks Runtime ML variants and select the correct one for a GPU-based deep learning task

Register a trained model in the model registry and promote it through Staging to Production using registry stages and aliases

Create a feature table, then look up training features by primary key and timestamp to avoid label leakage

Explain how Unity Catalog governs models, features, and experiments across workspaces, and apply a grant to restrict access to one registered model

Trace a model from notebook run to registry version to serving endpoint by following its identifiers

Identify which Databricks ML governance controls are workspace-scoped versus account-scoped

Engineer numeric, categorical, and text features inside a Pandas or Spark DataFrame and handle nulls, skew, and high-cardinality columns deliberately

Split data into train, validation, and test sets without temporal or group leakage, and justify the splitting strategy in writing

Train baseline and tuned models for both classification and regression, and select evaluation metrics appropriate to class imbalance

Run a hyperparameter sweep with MLflow tracking and parallelize trials across a multi-node cluster

Detect and mitigate overfitting by comparing train versus validation learning curves

Implement a reproducible preprocessing pipeline that is fit only on training data and reused unchanged at inference time

Tune hyperparameters with an automated search and record the search space, sampler, and best trial in MLflow

Evaluate a model on a held-out test set and produce a confusion matrix plus per-class precision and recall

Diagnose a model with feature importance or permutation importance and remove at least one feature that adds no signal

Package the final model with its preprocessing steps into a single artifact that accepts raw input

Structure an MLflow experiment hierarchy with nested runs and consistent tag naming so results are comparable across team members

Log parameters, metrics, artifacts, and a model signature, then reload the logged model in a fresh notebook and confirm predictions match

Reproduce a prior run from its logged metadata alone, without reusing the original notebook state

Compare runs programmatically in a DataFrame and select the best configuration by a stated rule

Describe how Delta Lake tables support reproducible training data through versioning and time travel

Schedule a multi-task Databricks job that chains data preparation, training, and evaluation with explicit task dependencies

Parameterize a notebook so the same code runs for dev and prod by passing widget values from a job

Configure retries, timeouts, and failure notifications on a job and explain when each matters

Query the job run history to confirm a scheduled run succeeded and to retrieve its output metrics

Assemble a CI-style workflow that validates data quality before training begins

Deploy a registered model to a real-time serving endpoint and send a scored request to it

Perform batch inference with a Spark job and write predictions to a Delta table partitioned for downstream consumption

Choose between real-time serving, batch scoring, and streaming inference for three described scenarios and justify each choice

Explain how endpoint scaling, version promotion, and rollback work when a bad model version reaches production

Implement a basic drift or data-quality check on incoming requests and describe what should trigger a retrain

Re-derive from memory the full lifecycle from raw data to a governed, deployed model and identify weak links in your own understanding

Rework every item you flagged as uncertain during weeks 1 through 7 into a written, correct explanation

Complete a timed full-length practice set and analyze errors by domain rather than by question

Rehearse explaining model registry promotion, job orchestration, and serving trade-offs aloud in under two minutes each