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

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

• Question 11:

  A data scientist has produced two models for a single machine learning problem. One of the models performs well when one of the features has a value of less than 5, and the other model performs well when the value of that feature is greater than or equal to 5. The data scientist decides to combine the two models into a single machine learning solution.

  Which of the following terms is used to describe this combination of models?

  A. Bootstrap aggregation
  B. Support vector machines
  C. Bucketing
  D. Ensemble learning
  E. Stacking
  D. Ensemble learning

  ---

  Explanation/Reference:

  Ensemble learning is a machine learning technique that involves combining several models to solve a particular problem. The scenario described fits the concept of ensemble learning, where two models, each performing well under different

  conditions, are combined to create a more robust model. This approach often leads to better performance as it combines the strengths of multiple models.

  References:

  Introduction to Ensemble Learning:

  https://machinelearningmastery.com/ensemble-machine-learning-algorithms-python-scikit-learn/

• Question 12:

  A data scientist is working with a feature set with the following schema:

  

  Thecustomer_idcolumn is the primary key in the feature set. Each of the columns in the feature set has missing values. They want to replace the missing values by imputing a common value for each feature.

  Which of the following lists all of the columns in the feature set that need to be imputed using the most common value of the column?

  A. customer_id, loyalty_tier
  B. loyalty_tier
  C. units
  D. spend
  E. customer_id
  B. loyalty_tier

  ---

  Explanation/Reference:

  For the feature set schema provided, the columns that need to be imputed using the most common value (mode) are typically the categorical columns. In this case, loyalty_tieris the only categorical column that should be imputed using the

  most common value.customer_idis a unique identifier and should not be imputed, whilespendandunits are numerical columns that should typically be imputed using the mean or median values, not the mode.

  References:

  Databricks documentation on missing value imputation: Handling Missing Data If you need any further clarification or additional questions answered, please let me know!

• Question 13:

  A team is developing guidelines on when to use various evaluation metrics for classification problems. The team needs to provide input on when to use the F1 score over accuracy.

  

  Which of the following suggestions should the team include in their guidelines?

  A. The F1 score should be utilized over accuracy when the number of actual positive cases is identical to the number of actual negative cases.
  B. The F1 score should be utilized over accuracy when there are greater than two classes in the target variable.
  C. The F1 score should be utilized over accuracy when there is significant imbalance between positive and negative classes and avoiding false negatives is a priority.
  D. The F1 score should be utilized over accuracy when identifying true positives and true negatives are equally important to the business problem.
  C. The F1 score should be utilized over accuracy when there is significant imbalance between positive and negative classes and avoiding false negatives is a priority.

  ---

  Explanation/Reference:

  The F1 score is the harmonic mean of precision and recall and is particularly useful in situations where there is a significant imbalance between positive and negative classes. When there is a class imbalance, accuracy can be misleading

  because a model can achieve high accuracy by simply predicting the majority class. The F1 score, however, provides a better measure of the test's accuracy in terms of both false positives and false negatives.

  Specifically, the F1 score should be used over accuracy when:

  There is a significant imbalance between positive and negative classes. Avoiding false negatives is a priority, meaning recall (the ability to detect all positive instances) is crucial.

  In this scenario, the F1 score balances both precision (the ability to avoid false positives) and recall, providing a more meaningful measure of a model's performance under these conditions.

  References:

  Databricks documentation on classification metrics: Classification Metrics

• Question 14:

  A data scientist has created two linear regression models. The first model uses price as a label variable and the second model uses log(price) as a label variable. When evaluating the RMSE of each model bycomparing the label predictions to the actual price values, the data scientist notices that the RMSE for the second model is much larger than the RMSE of the first model.

  Which of the following possible explanations for this difference is invalid?

  A. The second model is much more accurate than the first model
  B. The data scientist failed to exponentiate the predictions in the second model prior tocomputingthe RMSE
  C. The datascientist failed to take the logof the predictions in the first model prior to computingthe RMSE
  D. The first model is much more accurate than the second model
  E. The RMSE is an invalid evaluation metric for regression problems
  E. The RMSE is an invalid evaluation metric for regression problems

  ---

  Explanation/Reference:

  The Root Mean Squared Error (RMSE) is a standard and widely used metric for evaluating the accuracy of regression models. The statement that it is invalid is incorrect. Here's a breakdown of why the other statements are or are not valid:

  Transformations and RMSE Calculation:If the model predictions were transformed (e.g., using log), they should be converted back to their original scale before calculating RMSE to ensure accuracy in the evaluation. Missteps in this

  conversion process can lead to misleading RMSE values. Accuracy of Models:Without additional information, we can't definitively say which model is more accurate without considering their RMSE values properly scaled back to the original

  price scale.

  Appropriateness of RMSE:RMSE is entirely valid for regression problems as it provides a measure of how accurately a model predicts the outcome, expressed in the same units as the dependent variable.

  References:

  "Applied Predictive Modeling" by Max Kuhn and Kjell Johnson (Springer, 2013), particularly the chapters discussing model evaluation metrics.

• Question 15:

  A data scientist has a Spark DataFrame spark_df. They want to create a new Spark DataFrame that contains only the rows from spark_df where the value in column discount is less than or equal 0.

  Which of the following code blocks will accomplish this task?

  A. spark_df.loc[:,spark_df["discount"]
  B. spark_df[spark_df["discount"]
  C. spark_df.filter (col("discount")
  D. spark_df.loc(spark_df["discount"]
  C. spark_df.filter (col("discount")

  ---

  Explanation/Reference:

  To filter rows in a Spark DataFrame based on a condition, thefiltermethod is used. In this case, the condition is that the value in the "discount" column should be less than or equal to 0. The correct syntax uses thefiltermethod along with

  thecolfunction from pyspark.sql.functions.

  Correct code:

  frompyspark.sql.functionsimportcol filtered_df = spark_df.filter(col("discount") <=0) Option A and D use Pandas syntax, which is not applicable in PySpark. Option B is closer but misses the use of thecolfunction.

  References:

  PySpark SQL Documentation

• Question 16:

  The implementation of linear regression in Spark ML first attempts to solve the linear regression problem using matrix decomposition, but this method does not scale well to large datasets with a large number of variables.

  Which of the following approaches does Spark ML use to distribute the training of a linear regression model for large data?

  A. Logistic regression
  B. Singular value decomposition
  C. Iterative optimization
  D. Least-squares method
  C. Iterative optimization

  ---

  Explanation/Reference:

  For large datasets, Spark ML uses iterative optimization methods to distribute the training of a linear regression model. Specifically, Spark MLlib employs techniques like Stochastic Gradient Descent (SGD) and Limited-memory Broyden

• Question 17:

  Which of the following machine learning algorithms typically uses bagging?

  A. IGradient boosted trees
  B. K-means
  C. Random forest
  D. Decision tree
  C. Random forest

  ---

  Explanation/Reference:

  Random Forest is a machine learning algorithm that typically uses bagging (Bootstrap Aggregating). Bagging is a technique that involves training multiple base models (such as decision trees) on different subsets of the data and then combining their predictions to improve overall model performance. Each subset is created by randomly sampling with replacement from the original dataset. The Random Forest algorithm builds multiple decision trees and merges them to get a more accurate and stable prediction. References: Databricks documentation on Random Forest: Random Forest in Spark ML

• Question 18:

  A data scientist is utilizing MLflow Autologging to automatically track their machine learning experiments. After completing a series of runs for the experiment experiment_id, the data scientist wants to identify the run_id of the run with the best root-mean-square error (RMSE).

  Which of the following lines of code can be used to identify the run_id of the run with the best RMSE in experiment_id?

  

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

  ---

  Explanation/Reference:

  To find the run_id of the run with the best root-mean-square error (RMSE) in an MLflow experiment, the correct line of code to use is:

  mlflow.search_runs( experiment_id, order_by=["metrics.rmse"] )["run_id"][0] This line of code searches the runs in the specified experiment, orders them by the RMSE metric in ascending order (the lower the RMSE, the better), and retrieves

  the run_id of the best-performing run. Option C correctly represents this logic.

  References:

  MLflow documentation on tracking experiments:

  https://www.mlflow.org/docs/latest/python_api/mlflow.html#mlflow.search_runs

• Question 19:

  A data scientist is attempting to tune a logistic regression model logistic using scikit-learn. They want to specify a search space for two hyperparameters and let the tuning process randomly select values for each evaluation.

  They attempt to run the following code block, but it does not accomplish the desired task:

  

  Which of the following changes can the data scientist make to accomplish the task?

  A. Replace the GridSearchCV operation with RandomizedSearchCV
  B. Replace the GridSearchCV operation with cross_validate
  C. Replace the GridSearchCV operation with ParameterGrid
  D. Replace the random_state=0 argument with random_state=1
  E. Replace the penalty= ['12', '11'] argument with penalty=uniform ('12', '11')
  A. Replace the GridSearchCV operation with RandomizedSearchCV

  ---

  Explanation/Reference:

  The user wants to specify a search space for hyperparameters and let the tuning process randomly select values.GridSearchCVsystematically tries every combination of the provided hyperparameter values, which can be computationally expensive and time-consuming.RandomizedSearchCV, on the other hand, samples hyperparameters from a distribution for a fixed number of iterations. This approach is usually faster and still can find very good parameters, especially when the search space is large or includes distributions. References: Scikit-Learn documentation on hyperparameter tuning: https://scikit-learn.org/stable/modules/grid_search.html#randomized-parameter-optimization

• Question 20:

  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_sql()
  D. import pandas as pd df = pd.DataFrame(spark_df)
  E. spark_df.to_pandas()
  A. import pyspark.pandas as ps df = ps.DataFrame(spark_df)

  ---

  Explanation/Reference:

  To use the pandas API on Spark, which is designed to bridge the gap between the simplicity of pandas and the scalability of Spark, the correct approach involves importing the pyspark.pandas (recently renamed topandas_api_on_spark)

  module and converting a Spark DataFrame to a pandas-on-Spark DataFrame using this API. The provided syntax correctly initializes a pandas-on-Spark DataFrame, allowing the data scientist to work with the familiar pandas-like API on large

  datasets managed by Spark.

  References:

  Pandas API on Spark

  Documentation:https://spark.apache.org/docs/latest/api/python/user_guide/pandas _on_spark/index.html