Free Databricks Databricks-Machine-Learning-Associate Practice Exam with Questions & Answers | Set: 2

To organize MLflow runs with one parent run for the tuning process and a child run for each unique combination of hyperparameter values, the data scientist can specifynested=Truewhen starting the child run. This approach ensures that each child run is properly nested under the parent run, maintaining a clear hierarchical structure for the experiment. This nesting helps in tracking and comparing different hyperparameter combinations within the same tuning process.References:

• MLflow Documentation (Managing Nested Runs).

Thesummary()function in PySpark's DataFrame API provides descriptive statistics which include count, mean, standard deviation, min, max, and quantiles for numeric columns. Here are the steps on how it can be used:

• Import PySpark:Ensure PySpark is installed and correctly configured in the Databricks environment.
• Load Data:Load the data into a Spark DataFrame.
• Apply Summary:Usespark_df.summary()to generate summary statistics.
• View Results:The output from thesummary()function includes the statistics specified in the query (count, mean, standard deviation, min, max, and potentially quartiles which approximate the interquartile range).

References

• PySpark Documentation:https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.sql.DataFrame.summary.html

To ensure reproducible training and test sets, writing the split data sets to persistent storage is a reliable approach. This allows you to consistently load the same training and test data for each model run, regardless of cluster reconfiguration or other changes in the environment.

Correct approach:

• Split the data.
• Write the split data to persistent storage (e.g., HDFS, S3).
• Load the data from storage for each model training session.

train_df, test_df = spark_df.randomSplit([0.8,0.2], seed=42) train_df.write.parquet("path/to/train_df.parquet") test_df.write.parquet("path/to/test_df.parquet")# Later, load the datatrain_df = spark.read.parquet("path/to/train_df.parquet") test_df = spark.read.parquet("path/to/test_df.parquet")

References:

• Spark DataFrameWriter Documentation

When evaluating the RMSE for a model that predicts log-transformed prices, the predictions need to be transformed back to the original scale to obtain an RMSE that is comparable with the actual price values. This is done by exponentiating the predictions before computing the RMSE. The RMSE should be computed on the same scale as the original data to provide a meaningful measure of error.

References:

• Databricks documentation on regression evaluation: Regression Evaluation

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

To improve the likelihood of a more accurate model, the data scientist can increasenum_evalsto 100. Increasing the number of evaluations allows the hyperparameter tuning process to explore a larger search space and evaluate more combinations of hyperparameters, which increases the chance of finding a more optimal set of hyperparameters for the model.

References:

• Databricks documentation on hyperparameter tuning: Hyperparameter Tuning

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

The functionmapInPandasin the PySpark DataFrame API allows for applying a function to each partition of the DataFrame. When working with grouped data,groupbyfollowed byapplyInPandasis the correct approach to apply a function to each group as a separate Pandas DataFrame. However, if the function should apply across each partition of the grouped data rather than on each individual group,mapInPandaswould be utilized. Since the code snippet indicates the use ofgroupby, the intent seems to be to applytrain_modelon each group specifically, which aligns withapplyInPandas. Thus,applyInPandasis a better fit to ensure that each group generated bygroupbyis processed through thetrain_modelfunction, preserving the partitioning and grouping integrity.

References

• PySpark Documentation on applying functions to grouped data:https://spark.apache.org/docs/latest/api/python/reference/api/pyspark.sql.GroupedData.applyInPandas.html

By creating a binary feature variable for each feature with missing values to indicate whether a value has been imputed, the data scientist can preserve information about the original state of the data. This approach maintains the integrity of the dataset by marking which values are original and which are synthetic (imputed). Here are the steps to implement this approach:

• Identify Missing Values:Determine which features contain missing values.
• Impute Missing Values:Continue with median imputation or choose another method (mean, mode, regression, etc.) to fill missing values.
• Create Indicator Variables:For each feature that had missing values, add a new binary feature. This feature should be '1' if the original value was missing and imputed, and '0' otherwise.
• Data Integration:Integrate these new binary features into the existing dataset. This maintains a record of where data imputation occurred, allowing models to potentially weight these observations differently.
• Model Adjustment:Adjust machine learning models to account for these new features, which might involve considering interactions between these binary indicators and other features.

References

• "Feature Engineering for Machine Learning" by Alice Zheng and Amanda Casari (O'Reilly Media, 2018), especially the sections on handling missing data.
• Scikit-learn documentation on imputing missing values: https://scikit-learn.org/stable/modules/impute.html

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_dfinto 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