Databricks Machine Learning Associate Practice Test

A machine learning engineer already has a Unity Catalog Delta table with the correct columns, but it was created without a primary key. She wants to use it as a feature table rather than recreating it. What should she do?

1. AClone the table into the workspace Feature Store, because only tables created there can later be upgraded into feature tables recognized by the Feature Engineering UI and API
2. BAlter the existing Unity Catalog Delta table to make the key columns NOT NULL and add a primary key constraint, after which the table can be used as a feature table
3. CConvert the Delta table into a notebook-scoped temporary table and then call create_training_set, because feature table recognition happens dynamically only at model training time and not in catalog metadata
4. DRegister the table as a model artifact in MLflow first, because feature table discovery in Catalog Explorer depends on the table being linked to at least one active experiment run
5. EPublish the table to an online store immediately, because the publish_table operation backfills the missing primary key metadata and makes the source table eligible for offline feature engineering workflows

A scikit-learn GridSearchCV job is running on one large machine with many CPU cores. The model itself is single node, but the engineer wants different parameter-fold evaluations to run concurrently on that machine. Which configuration is the standard approach?

1. ASet n_jobs on GridSearchCV so candidate evaluations can run in parallel across the available local workers
2. BSet random_state on the estimator so all folds execute at the same time with identical pseudorandom seeds
3. CUse train_test_split instead of cross-validation so the model automatically parallelizes over the remaining samples
4. DExport the training set to CSV so each core can read a different file shard during a separate notebook run
5. EConvert the model to SQL because parameter search objects only parallelize queries, not Python model evaluations

A data engineer is building a Spark MLlib Pipeline to prepare a categorical string column city for a logistic regression model. The city column contains string values like 'Seattle', 'Austin', 'Chicago'. Which sequence of preprocessing steps correctly implements one-hot encoding for this column so that it is suitable for a linear model?

1. AApply OneHotEncoder directly to the string city column with handleInvalid='keep', producing a sparse binary vector for each city value — PySpark's OneHotEncoder accepts string-type columns directly and handles the string-to-index conversion internally before constructing the binary vectors
2. BApply OneHotEncoder to the city column and then normalize the resulting binary vector using StandardScaler before passing it to logistic regression — the normalization step is required to rescale the binary indicator values so that the logistic regression model can learn stable coefficients from encoded categorical inputs
3. CApply StringIndexer to convert city strings to numeric indices and then pass those indices directly to the logistic regression model — Spark MLlib's LogisticRegression transformer automatically applies one-hot encoding internally to any IntegerType or DoubleType input features that were produced by StringIndexer, so an explicit OneHotEncoder step is unnecessary
4. DApply StringIndexer to convert city strings to numeric indices, then apply OneHotEncoder to convert those indices to sparse binary vectors, then use VectorAssembler to combine the encoded city vector with any other numeric features into a single features vector — this three-step sequence (StringIndexer → OneHotEncoder → VectorAssembler) is the standard PySpark MLlib pattern for preparing categorical features for linear models
5. EApply HashingTF to hash each city string value into a fixed-length sparse frequency vector — HashingTF is PySpark MLlib's recommended preprocessing step for nominal categorical string columns in classification pipelines because it avoids the two-step StringIndexer + OneHotEncoder overhead and directly produces numeric vectors compatible with logistic regression

A team has written custom Python inference logic that is not covered by a built-in MLflow flavor. They want to deploy it with Databricks Model Serving. Which preparation path is correct?

1. AZip the notebook source and upload it directly to a serving endpoint without using MLflow model packaging
2. BSave only the fitted weights to DBFS, because endpoints infer the rest of the Python environment automatically
3. CLog the model in MLflow format, typically with pyfunc for custom code, register it, and then create a serving endpoint
4. DRegister a Delta table as a model version, because serving endpoints can execute SQL tables as Python models
5. EExport the model to CSV and point the endpoint at the file path so Databricks can discover the predict function