Databricks DATABRICKS-MACHINE-LEARNING-ASSOCIATE Online Practice Questions and Exam Preparation

Databricks DATABRICKS-MACHINE-LEARNING-ASSOCIATE Online Questions & Answers

• Question 41:

  A data scientist wants to tune a set of hyperparameters for a machine learning model. They have wrapped a Spark ML model in the objective functionobjective_functionand they have defined the search spacesearch_space.

  As a result, they have the following code block: Which of the following changes do they need to make to the above code block in order to accomplish the task?

  

  A. Change SparkTrials() to Trials()
  B. Reduce num_evals to be less than 10
  C. Change fmin() to fmax()
  D. Remove the trials=trials argument
  E. Remove the algo=tpe.suggest argument
  A. Change SparkTrials() to Trials()

  ---

  Explanation/Reference:

  TheSparkTrials()is used to distribute trials of hyperparameter tuning across a Spark cluster. If the environment does not support Spark or if the user prefers not to usedistributed computing for this purpose, switching toTrials()would be

  appropriate.Trials() is the standard class for managing search trials in Hyperopt but does not distribute the computation. If the user is encountering issues withSparkTrials()possibly due to an unsupported configuration or an error in the cluster

  setup, usingTrials()can be a suitable change for running the optimization locally or in a non-distributed manner.

  References:

  Hyperopt documentation: http://hyperopt.github.io/hyperopt/

• Question 42:

  Which of the following tools can be used to parallelize the hyperparameter tuning process for single-node machine learning models using a Spark cluster?

  A. MLflow Experiment Tracking
  B. Spark ML
  C. Autoscaling clusters
  D. Autoscaling clusters
  E. Delta Lake
  B. Spark ML

  ---

  Explanation/Reference:

  Spark ML (part of Apache Spark's MLlib) is designed to handle machine learning tasks across multiple nodes in a cluster, effectively parallelizing tasks like hyperparameter tuning. It supports various machine learning algorithms that can be

  optimized over a Spark cluster, making it suitable for parallelizing hyperparameter tuning for single-node machine learning models when they are adapted to run on Spark.

  References:

  Apache Spark MLlib Guide:https://spark.apache.org/docs/latest/ml-guide.html

  Spark ML is a library within Apache Spark designed for scalable machine learning. It provides tools to handle large-scale machine learning tasks, including parallelizing the hyperparameter tuning process for single-node machine learning

  models using a Spark cluster. Here's a detailed explanation of how Spark ML can be used:

  Hyperparameter Tuning with CrossValidator: Spark ML includes theCrossValidatorandTrainValidationSplitclasses, which are used for hyperparameter tuning. These classes can evaluate multiple sets of hyperparameters in parallel using a

  Spark cluster. from pyspark.ml.tuning import CrossValidator, ParamGridBuilder from pyspark.ml.evaluation import BinaryClassificationEvaluator

  # Define the model

  model = ...

  # Create a parameter grid

  paramGrid = ParamGridBuilder() \

  addGrid(model.hyperparam1, [value1, value2]) \

  addGrid(model.hyperparam2, [value3, value4]) \

  build()

  # Define the evaluator

  evaluator = BinaryClassificationEvaluator()

  # Define the CrossValidator

  crossval = CrossValidator(estimator=model,

  estimatorParamMaps=paramGrid,

  evaluator=evaluator,

  numFolds=3)

  Parallel Execution: Spark distributes the tasks of training models with different hyperparameters across the cluster's nodes. Each node processes a subset of the parameter grid, which allows multiple models to be trained simultaneously.

  Scalability: Spark ML leverages the distributed computing capabilities of Spark. This allows for efficient processing of large datasets and training of models across many nodes, which speeds up the hyperparameter tuning process significantly

  compared to single-node computations.

  References:

  Apache Spark MLlib Documentation

  Hyperparameter Tuning in Spark ML

• Question 43:

  A data scientist wants to efficiently tune the hyperparameters of a scikit-learn model. They elect to use the Hyperopt library'sfminoperation to facilitate this process. Unfortunately, the final model is not very accurate. The data scientist suspects that there is an issue with theobjective_functionbeing passed as an argument tofmin.

  They use the following code block to create theobjective_function:

  

  Which of the following changes does the data scientist need to make to theirobjective_functionin order to produce a more accurate model?

  A. Add test set validation process
  B. Add a random_state argument to the RandomForestRegressor operation
  C. Remove the mean operation that is wrapping the cross_val_score operation
  D. Replace the r2 return value with-r2
  E. Replace the fmin operation with the fmax operation
  D. Replace the r2 return value with-r2

  ---

  Explanation/Reference:

  When using theHyperoptlibrary withfmin, the goal is to find the minimum of the objective function. Since you are usingcross_val_scoreto calculate the R2 score which is a measure of the proportion of the variance for a dependent variable

  that's explained by an independent variable(s) in a regression model, higher values are better. However,fmin seeks to minimize the objective function, so to align withfmin's goal, you should return the negative of the R2 score (-r2). This way,

  by minimizing the negative R2,fminis effectively maximizing the R2 score, which can lead to a more accurate model.

  References:

  Hyperopt Documentation: http://hyperopt.github.io/hyperopt/ Scikit-Learn documentation on model evaluation: https://scikit-learn.org/stable/modules/model_evaluation.html

• Question 44:

  What is the name of the method that transforms categorical features into a series of binary indicator feature variables?

  A. Leave-one-out encoding
  B. Target encoding
  C. One-hot encoding
  D. Categorical
  E. String indexing
  C. One-hot encoding

  ---

  Explanation/Reference:

  The method that transforms categorical features into a series of binary indicator variables is known as one-hot encoding. This technique converts each categorical value into a new binary column, which is essential for models that require

  numerical input. One-hot encoding is widely used because it helps to handle categorical data without introducing a false ordinal relationship among categories.References:

  Feature Engineering Techniques (One-Hot Encoding).

• Question 45:

  A machine learning engineer is trying to scale a machine learning pipeline by distributing its feature engineering process.

  Which of the following feature engineering tasks will be the least efficient to distribute?

  A. One-hot encoding categorical features
  B. Target encoding categorical features
  C. Imputing missing feature values with the mean
  D. Imputing missing feature values with the true median
  E. Creating binary indicator features for missing values
  D. Imputing missing feature values with the true median

  ---

  Explanation/Reference:

  Among the options listed, calculating the true median for imputing missing feature values is the least efficient to distribute. This is because the true median requires knowledge of the entire data distribution, which can be computationally

  expensive in a distributed environment. Unlike mean or mode, finding the median requires sorting the data or maintaining a full distribution, which is more intensive and often requires shuffling the data across partitions.

  References:

  Challenges in parallel processing and distributed computing for data aggregation like median calculation:https://www.apache.org

• Question 46:

  An organization is developing a feature repository and is electing to one-hot encode all categorical feature variables. A data scientist suggests that the categorical feature variables should not be one-hot encoded within the feature repository.

  Which of the following explanations justifies this suggestion?

  A. One-hot encoding is not supported by most machine learning libraries.
  B. One-hot encoding is dependent on the target variable's values which differ for each application.
  C. One-hot encoding is computationally intensive and should only be performed on small samples of training sets for individual machine learning problems.
  D. One-hot encoding is not a common strategy for representing categorical feature variables numerically.
  E. One-hot encoding is a potentially problematic categorical variable strategy for some machine learning algorithms.
  E. One-hot encoding is a potentially problematic categorical variable strategy for some machine learning algorithms.

  ---

  Explanation/Reference:

  One-hot encoding transforms categorical variables into a format that can be provided to machine learning algorithms to better predict the output. However, when done prematurely or universally within a feature repository, it can be

  problematic:

  Dimensionality Increase:One-hot encoding significantly increases the feature space, especially with high cardinality features, which can lead to high memory consumption and slower computation.

  Model Specificity:Some models handle categorical variables natively (like decision trees and boosting algorithms), and premature one-hot encoding can lead to inefficiency and loss of information (e.g., ordinal relationships). Sparse Matrix

  Issue:It often results in a sparse matrix where most values are zero, which can be inefficient in both storage and computation for some algorithms. Generalization vs. Specificity:Encoding should ideally be tailored to specific models and use

  cases rather than applied generally in a feature repository.

  References:

  "Feature Engineering and Selection: A Practical Approach for Predictive Models" by Max Kuhn and Kjell Johnson (CRC Press, 2019).

• Question 47:

  A machine learning engineer has been notified that a new Staging version of a model registered to the MLflow Model Registry has passed all tests. As a result, the machine learning engineer wants to put this model into production by transitioning it to the Production stage in the Model Registry.

  From which of the following pages in Databricks Machine Learning can the machine learning engineer accomplish this task?

  A. The home page of the MLflow Model Registry
  B. The experiment page in the Experiments observatory
  C. The model version page in the MLflow ModelRegistry
  D. The model page in the MLflow Model Registry
  C. The model version page in the MLflow ModelRegistry

  ---

  Explanation/Reference:

  The machine learning engineer can transition a model version to the Production stage in the Model Registry from the model version page. This page provides detailed information about a specific version of a model, including its metrics,

  parameters, and current stage. From here, the engineer can perform stage transitions, moving the model from Staging to Production after it has passed all necessary tests.

  References:

  Databricks documentation on MLflow Model Registry:

  https://docs.databricks.com/applications/mlflow/model-registry.html#model-version

• Question 48:

  A data scientist has developed a linear regression model using Spark ML and computed the predictions in a Spark DataFrame preds_df with the following schema:

  prediction DOUBLE actual DOUBLE Which of the following code blocks can be used to compute the root mean-squared-error of the model according to the data in preds_df and assign it to the rmse variable?

  

  A. Option A
  B. Option B
  C. Option C
  D. Option D
  E. Option E
  C. Option C

  ---

  Explanation/Reference:

  The code block to compute the root mean-squared error (RMSE) for a linear regression model in Spark ML should use theRegressionEvaluatorclass withmetricNameset to "rmse". Given the schema ofpreds_dfwith

  columnspredictionandactual, the correct evaluator setup will specifypredictionCol="prediction"andlabelCol="actual". Thus, the appropriate code block (Option C in your list) that usesRegressionEvaluatorto compute the RMSE is the correct

  choice. This setup correctly measures the performance of the regression model using the predictions and actual outcomes from the DataFrame.

  References:

  Spark ML documentation (Using RegressionEvaluator to Compute RMSE).

• Question 49:

  A machine learning engineer is trying to scale a machine learning pipelinepipelinethat contains multiple feature engineering stages and a modeling stage. As part of the cross-validation process, they are using the following code block:

  

  A colleague suggests that the code block can be changed to speed up the tuning process by passing the model object to theestimatorparameter and then placing the updated cv object as the final stage of thepipelinein place of the original model.

  Which of the following is a negative consequence of the approach suggested by the colleague?

  A. The model will take longerto train for each unique combination of hvperparameter values
  B. The feature engineering stages will be computed using validation data
  C. The cross-validation process will no longer be
  D. The cross-validation process will no longer be reproducible
  E. The model will be refit one more per cross-validation fold
  B. The feature engineering stages will be computed using validation data

  ---

  Explanation/Reference:

  If the model object is passed to the estimator parameter ofCrossValidator and the cross-validation object itself is placed as a stage in the pipeline, the feature engineering stages within the pipeline would be applied separately to each training

  and validation fold during cross-validation. This leads to a significant issue: the feature engineering stages would be computed using validation data, thereby leaking information from the validation set into the training process. This would

  potentially invalidate the cross-validation results by giving an overly optimistic performance estimate.References:

  Cross-validation and Pipeline Integration in MLlib (Avoiding Data Leakage in Pipelines).

• Question 50:

  A data scientist has been given an incomplete notebook from the data engineering team. The notebook uses a Spark DataFrame spark_df on which the data scientist needs to perform further feature engineering. Unfortunately, the data scientist has not yet learned the PySpark DataFrame API.

  Which of the following blocks of code can the data scientist run to be able to use the pandas API on Spark?

  A. import pyspark.pandas as ps df = ps.DataFrame(spark_df)
  B. import pyspark.pandas as ps df = ps.to_pandas(spark_df)
  C. spark_df.to_pandas()
  D. import pandas as pd df = pd.DataFrame(spark_df)
  A. import pyspark.pandas as ps df = ps.DataFrame(spark_df)

  ---

  Explanation/Reference:

  To use the pandas API on Spark, the data scientist can run the following code block:

  importpyspark.pandasasps df = ps.DataFrame(spark_df) This code imports the pandas API on Spark and converts the Spark DataFramespark_df into a pandas-on-Spark DataFrame, allowing the data scientist to use familiar pandas functions

  for further feature engineering.

  References:

  Databricks documentation on pandas API on Spark: pandas API on Spark