Free Cloudera Machine Learning Engineer (CDP-6001) Sample Questions

Correct answer: A — Build a custom runtime with all necessary packages pre-installed in the Docker image.

• A. Correct. Building a custom runtime with all necessary packages pre-installed in the Docker image ensures that the environment is consistent, reproducible, and ready for use without additional setup time during session startup. This is the recommended practice in Cloudera Machine Learning to avoid interruptions from package installation.
• B. Incorrect. Developing a background script to pip-install dependencies during notebook load can lead to delays, inconsistencies, and potential failures if the installation process encounters issues. This is not a recommended practice for production environments and does not prevent restarts from interrupting installation.
• C. Incorrect. Adjusting the project settings to extend the session timeout does not address the root issue of missing packages. It only delays the inevitable restart and does not ensure the required packages are available.
• D. Incorrect. Attaching a persistent volume with a virtual environment may work but is less efficient and scalable compared to a custom runtime. It also introduces complexity in managing dependencies across different sessions or users. Runtime images are the intended place to define dependencies.

Correct answer: A — Insufficient memory and CPU in the session for running both frameworks concurrently.

• A. Correct. Running both Spark and TensorFlow in the same session significantly increases memory and CPU consumption. If the session's allocated resources are insufficient, the combined workload can cause the notebook process to fail, even though each framework works individually. This is the most common cause of such failures in Cloudera Machine Learning.
• B. Incorrect. Docker image size limits typically affect container deployment or startup, not runtime execution. Since each framework works separately, the container has started successfully, ruling out image size issues.
• C. Incorrect. While Java library conflicts can occur, they are not the most likely cause here. The fact that both libraries work individually suggests no fundamental incompatibility. Resource exhaustion is a more common and general explanation.
• D. Incorrect. A custom runtime incompatibility with the Jupyter kernel would prevent any notebook from running, not just those using both frameworks. Since each framework works separately, the runtime is compatible.

Correct answer: B — Use the ENV instruction in the runtime’s Dockerfile to define them.

• A. Incorrect. The runtime.yaml file is used for runtime metadata and configuration, but not for defining environment variables. Environment variables for a custom runtime should be set in the Dockerfile.
• B. Correct. Using the ENV instruction in the runtime’s Dockerfile embeds environment variables into the container image, making them available to all sessions and jobs that use the runtime. This is the standard and recommended method.
• C. Incorrect. The project-level Environment tab configures environment variables for the project as a whole, not for a specific runtime. Runtime-specific variables must be defined in the runtime Dockerfile.
• D. Incorrect. Specifying environment variables at session launch is a per-session action and does not persist for all sessions or jobs using the runtime. It is not the recommended approach for custom runtime definitions.

Correct answers: B, E — Metrics are streamed to the CML UI as they are logged during a run.; You can add custom tags to an experiment run after it has finished.

• A. Incorrect. Experiment runs can be initiated from a Workbench session, but also via the CML API, CLI, or scheduled jobs. The statement is too restrictive.
• B. Correct. Metrics logged during an experiment run are streamed in real-time to the CML UI, allowing users to monitor progress dynamically.
• C. Incorrect. CML allows comparing experiment runs from different experiments side-by-side in the UI, enabling cross-experiment analysis.
• D. Incorrect. Artifacts logged during a run are not automatically stored in the project's data directory; they are tracked as experiment outputs and must be explicitly persisted.
• E. Correct. Custom tags can be added to an experiment run after it has finished via the CML UI or API, helping organize and filter runs.

Correct answer: B — The object store bucket configured for artifacts lacks write permissions for the service account.

• A. Incorrect. In CML, log_artifact will raise an explicit error if the local file path does not exist, so this would not result in a silent failure.
• B. Correct. If the service account lacks write permissions to the object store bucket, the artifact upload may fail silently, as the error is not always surfaced to the user's code in CML.
• C. Incorrect. Cloudera Machine Learning does not enforce a hard limit on artifact count that would cause silent failures; such limits typically raise an error immediately.
• D. Incorrect. If artifact logging is called after the run completes, CML will typically raise an error or warning, not fail silently.

Correct answer: C — No automatic deletion

• A. Incorrect. Experiment runs in Cloudera Machine Learning are not automatically deleted after 30 days. The default retention is indefinite unless manually deleted.
• B. Incorrect. There is no standard 90-day automatic deletion policy for experiment runs. They are retained indefinitely by default.
• C. Correct. By default, Cloudera Machine Learning does not automatically delete experiment runs. They are retained indefinitely unless a user or admin manually deletes them.
• D. Incorrect. There is no default 1-year automatic deletion period for experiment runs. Retention is indefinite unless manually managed.

Correct answer: A — The Workspace Usage Dashboard, which aggregates resource consumption metrics.

• A. Correct. The Workspace Usage Dashboard in CML aggregates resource consumption metrics (e.g., CPU, memory, GPU) across all projects, providing a centralized view for administrators. It is the standard UI feature to inspect overall workspace usage.
• B. Incorrect. Project-level charts are specific to individual projects and do not provide a consolidated view of resource usage across all projects. They are useful for per-project details, not cross-project aggregation.
• C. Incorrect. The Resource Quota management page shows allocations or limits per project, not actual usage metrics. It is for governance and setting boundaries, not for viewing consumption.
• D. Incorrect. While the CML API metrics endpoint can provide per-project usage data for automation or integration, it does not offer a centralized, user-friendly dashboard for all projects in the product interface.

Correct answer: C — They are defined in Project Settings > Environment Variables and are available to all sessions, jobs, and applications in the project.

• A. Incorrect. Environment variables in Cloudera Machine Learning are not configured globally in workspace settings. They are managed at the project level and are not inherited by all projects by default. Workspace-level settings may provide shared defaults in some areas, but project environment variables are project-specific.
• B. Incorrect. While startup scripts can be used for initialization tasks, they are not the standard mechanism for defining project environment variables in CML. Environment variables intended for sessions, jobs, and applications are configured through the project's settings, not hardcoded in a startup script.
• C. Correct. In Cloudera Machine Learning, project environment variables are defined in the Project Settings under the Environment Variables tab. Once set there, they are automatically available to all sessions, jobs, and applications associated with that project. This is the recommended and supported method for managing environment variables at the project level.
• D. Incorrect. Although a .env file may be used in some development workflows, CML does not rely on a .env file in the project's home directory for environment variable configuration. Instead, environment variables are managed through the Project Settings UI, ensuring consistent and secure access across project resources.

Correct answers: A, E — Set the MLflow tracking URI to a shared tracking server in the project environment variables.; Use a project runtime that includes the MLflow library and set the tracking URI variable.

• A. Correct. Setting the MLflow tracking URI to a shared tracking server in the project environment variables ensures all experiments log to the same backend, enabling centralized tracking. This is a standard method in CML.
• B. Incorrect. CML does not have a dedicated 'experiment tracking toggle' in the project's general settings. MLflow tracking is enabled via environment variables or runtime configurations, not a simple toggle.
• C. Incorrect. Configuring the project's output directory is useful for artifact storage but does not enable MLflow experiment tracking. MLflow requires explicit tracking URI configuration.
• D. Incorrect. A post-run hook can copy metrics to a database, but it is a custom workaround and does not enable MLflow's native experiment tracking. The tracking must be configured in the runtime or environment.
• E. Correct. Using a project runtime that includes the MLflow library and setting the tracking URI variable (e.g., MLFLOW_TRACKING_URI) is a valid way to enable MLflow experiment tracking in CML.

Correct answer: D — Both B and C above are correct.

• A. Incorrect. This code plots $val\_loss$ against $train\_loss$ rather than plotting both loss curves against epochs. The legend labels are not attached to the plotted curves, and the x-axis would show training loss values, not epoch numbers.
• B. Correct. This code explicitly plots both `train_loss` and `val_loss` against `epochs` on the same axes. The `plt.legend()` call with a list of labels provides a legend for the two curves.
• C. Correct. This code also correctly plots both loss curves against epochs. By using the `label` parameter in each `plt.plot()` call, `plt.legend()` automatically generates the legend from these labels.
• D. Correct. Both options B and C are valid ways to plot the training and validation loss curves with a legend. Option B uses explicit legend labels, while option C uses the `label` parameter and an automatic legend. Therefore, D is the correct choice.

Correct answer: B — MLflow

• A. Incorrect. TensorBoard is a visualization toolkit for TensorFlow, but it is not the library used by CML's Experiments feature for logging and tracking metrics.
• B. Correct. MLflow is the primary library used by CML Experiments to log parameters, metrics, and artifacts, and to visualize experiment runs. It is the standard tracking library integrated with Cloudera Machine Learning.
• C. Incorrect. Matplotlib is a general-purpose plotting library for creating static charts, not the experiment tracking backend used by CML Experiments.
• D. Incorrect. Plotly is used for interactive visualizations, but it is not the library CML Experiments uses to log and visualize experiment metrics.

Correct answer: B — Multi-Instance GPU (MIG) support

• A. Incorrect. While the A100 supports CUDA 11.0 or higher, this is not unique because both the T4 and V100 also support modern CUDA versions (depending on driver and software stack).
• B. Correct. Multi-Instance GPU (MIG) is a distinctive capability of the NVIDIA A100 that allows a single physical GPU to be partitioned into multiple isolated instances, each with dedicated resources. This feature is not available on the T4 or V100.
• C. Incorrect. Hardware-accelerated video encoding is supported by the T4 (via NVENC) and also by the V100, so it is not unique to the A100.
• D. Incorrect. NVLink for GPU-to-GPU communication is supported by both the V100 and A100, so it is not unique to the A100. The T4 does not support NVLink.

Correct answer: B — Tensor Cores with FP16 support

• A. Incorrect. Ray Tracing Cores are specialized hardware for graphics rendering, such as real-time ray tracing, and do not accelerate FP16 or FP32 computations in machine learning inference. They are not relevant to the performance difference observed.
• B. Correct. The NVIDIA T4 GPU includes Tensor Cores designed to accelerate mixed-precision matrix operations, including FP16. These cores provide significantly higher throughput for deep learning inference compared to standard FP32 execution, explaining the performance boost observed.
• C. Incorrect. While a larger L2 cache can improve memory access efficiency in some workloads, it does not specifically enable or optimize FP16 operations. The speedup in FP16 inference is attributable to dedicated tensor acceleration hardware, not cache enhancements.
• D. Incorrect. Higher memory clock speed increases memory bandwidth, which can benefit data transfer, but it does not selectively boost FP16 arithmetic over FP32. The superior FP16 performance on a T4 is due to Tensor Cores, not memory clock differences.

Correct answer: B — The session is automatically suspended after the idle timeout, and the GPU is released to the pool.

• A. Incorrect. CML does not retain GPU-attached sessions indefinitely. Idle sessions are automatically managed to free resources, not kept active until manual termination.
• B. Correct. CML automatically suspends a GPU-attached session after a configurable idle timeout. The GPU is released back to the pool, making it available for other workloads.
• C. Incorrect. CML does not dynamically switch to a shared GPU mode upon idleness. GPUs are either fully allocated or released; no on-demand sharing is implemented.
• D. Incorrect. CML does not downgrade GPU tiers for idle sessions. The session is suspended entirely, not throttled to a lower tier.

Correct answer: C — dense_rank() — assigns same rank to ties without gaps, so filtering ≤ 3 includes all top three distinct salary values and their tied rows

• A. Incorrect. row_number() assigns a unique sequential number to each row, arbitrarily breaking ties. Filtering row_number ≤ 3 would select exactly three rows per department, not all employees tied for the top three salaries.
• B. Incorrect. rank() assigns the same rank to tied rows but leaves gaps. Filtering rank ≤ 3 may not include all employees with the top three distinct salary values if there are ties that cause ranks to skip (e.g., many ties at rank 1 would skip rank 2 and 3). It does not guarantee inclusion of all top three salaries.
• C. Correct. dense_rank() assigns consecutive ranks to distinct values without gaps. Filtering dense_rank ≤ 3 includes all employees whose salaries are among the top three distinct salary values, including all tied rows, which matches the requirement of selecting more than three if ties exist.
• D. Incorrect. ntile(3) divides rows into three roughly equal buckets and does not rank by salary value, so it cannot reliably select the top three salaries with ties.

Correct answer: A — The function returns the specified default value, or NULL if no default is given.

• A. Correct. When the offset goes beyond the partition boundary, LAG returns the specified default value. If no default is provided, it returns NULL instead of failing.
• B. Incorrect. LAG does not throw an error when the offset exceeds the partition bounds; it handles the missing row gracefully by returning the default value or NULL.
• C. Incorrect. LAG is not a non-null search function; it looks back by the given offset and does not search for the first non-null value. That behavior is typical of functions like FIRST_VALUE with filtering.
• D. Incorrect. LAG does not substitute the current row's value; it returns the provided default or NULL when the target row is outside the partition.

Correct answers: A, B — Use the percentile_approx() aggregate function with GROUP BY on department to compute an approximate median.; Use row_number() and count() with a window partition to assign row numbers, then filter for the middle position(s).

• A. Correct. `percentile_approx(0.5)` with GROUP BY department computes the approximate median per department. It is an aggregate function, not a window function, but effectively solves the per-group median problem.
• B. Correct. Using `row_number()` and `count()` over a window partitioned by department and ordered by salary allows identifying the middle row(s) based on row count. This is a standard exact method for computing the median.
• C. Incorrect. `cume_dist()` gives the cumulative distribution, but filtering at 0.5 does not reliably isolate the median value, especially with even-sized groups or ties. It may include multiple rows or miss the exact median.
• D. Incorrect. `ntile(2)` splits data into two buckets; the first tile represents the lower half only, not the median value. This does not compute the middle value(s) needed for a median.

Correct answer: A — col('event_date') == current_date()

• A. Correct. `current_date()` is a built-in Spark function that returns the current date as a DateType without time, which is appropriate for comparing with a date column like 'event_date'.
• B. Incorrect. `now()` returns the current timestamp (TimestampType), including time. Directly comparing a DateType column with a TimestampType may cause type mismatch or unexpected results.
• C. Incorrect. `today()` is not a standard Spark SQL or PySpark function. Spark uses `current_date()` to obtain the current date.
• D. Incorrect. `sysdate()` is not a standard Spark function. It exists in some databases (e.g., Oracle) but is not available in Spark for DataFrame operations.

Correct answers: A, B, C — map; filter; flatMap

• A. Correct. map is a narrow transformation because each input partition contributes to exactly one output partition, meaning Spark can process it without shuffling data across the cluster. The one-to-one partition dependency avoids redistribution.
• B. Correct. filter is a narrow transformation because it evaluates each row independently within the same partition. No data needs to be shuffled or exchanged between partitions, as the filter condition is applied locally.
• C. Correct. flatMap is a narrow transformation because it preserves the one-to-one partition dependency pattern from input to output. Even though one input record can produce multiple output records, all output stays within the same partition, so no shuffle occurs.
• D. Incorrect. groupByKey is a wide transformation because Spark must shuffle all values for the same key to the same reducer/partition to group them. This crosses partition boundaries and requires data redistribution.
• E. Incorrect. reduceByKey is a wide transformation because it requires shuffling data to combine values with the same key across partitions. Although it can perform a map-side combine, it still involves a full shuffle to repartition by key.
• F. Incorrect. join is generally a wide transformation because matching keys from different datasets usually requires shuffling data across partitions to co-locate records with the same key. It is not considered narrow.

Correct answer: A — It generates all combinations of specified hyperparameter values for tuning.

• A. ParamGridBuilder is used to define a grid of hyperparameter values and generate all combinations for tuning models. This parameter grid is then passed to tools like CrossValidator or TrainValidationSplit.
• B. Incorrect. Creating a pipeline of transformers and estimators is the role of the Pipeline class, not ParamGridBuilder. ParamGridBuilder only defines hyperparameter search space.
• C. Incorrect. Model evaluation with cross-validation is handled by CrossValidator. ParamGridBuilder may supply the parameter combinations used during that process, but it does not perform the evaluation itself.
• D. Incorrect. Splitting a dataset into training and test subsets is typically done with functions like randomSplit. ParamGridBuilder has nothing to do with dataset splitting.

Correct answer: A — metricName

• A. Correct. The BinaryClassificationEvaluator in Spark MLlib uses the 'metricName' parameter to specify the evaluation metric, such as 'areaUnderROC' or 'areaUnderPR'.
• B. Incorrect. The 'labelCol' parameter specifies the column name for the true labels, not the metric to be used.
• C. Incorrect. The 'scoreCol' parameter specifies the column name for the predicted scores, not the metric to be used.
• D. Incorrect. There is no 'evaluationMetric' parameter in BinaryClassificationEvaluator; the correct parameter is 'metricName'.

Correct answer: A — 200,000

• A. Correct. TrainValidationSplit uses the trainRatio to split the dataset. With trainRatio=0.8, 80% (800,000 records) are used for training, leaving 20% (200,000 records) for validation.
• B. Incorrect. 800,000 records represent the training set, not the validation set. The validation set is the remaining 20%, which is 200,000 records.
• C. Incorrect. 100,000 records would correspond to a trainRatio of 0.9 (90% training, 10% validation). For trainRatio=0.8, the validation set should be 20% of the total.
• D. Incorrect. 500,000 records would imply a 50-50 split (trainRatio=0.5), which does not match the given trainRatio of 0.8.

Correct answer: A — Reserve 20% as holdout test set before tuning; use cross-validation on the remaining 80% for hyperparameter tuning; evaluate final model on the holdout set.

• A. Correct. This approach ensures the holdout test set is never used during hyperparameter tuning (cross-validation is only on the training set), providing an unbiased estimate of model performance on unseen data. The 80/20 split is standard and efficient for a dataset of 100,000 rows.
• B. Incorrect. Using the entire dataset only within cross-validation for both tuning and evaluation leads to data leakage, as the test folds are reused for evaluation. The average cross-validation metric is typically optimistic and not an unbiased estimate of future performance; it is useful for model selection but not final assessment.
• C. Incorrect. A 50/50 split wastes a large portion of data for training, which can reduce model quality. More importantly, the approach still uses a holdout test set for final evaluation, but the split is inefficient. An 80/20 split is preferred to maximize training data while retaining a sufficient test set.
• D. Incorrect. Repeating cross-validation with different random seeds may reduce variance in the estimate, but it still does not provide an unbiased final performance estimate because the entire dataset is used for tuning and evaluation. A separate, untouched test set is required for unbiased estimation.

Correct answer: A — 72% of test samples were correctly classified.

• A. Correct. Accuracy in multiclass classification is the proportion of correctly classified samples out of the total test samples. An accuracy of 0.72 on 1000 samples means 72% (720 samples) were correctly predicted.
• B. Incorrect. Precision is a per-class metric measuring true positives divided by predicted positives. Averaging precision across classes gives macro-precision, not accuracy. With `metricName='accuracy'`, the evaluator does not return precision.
• C. Incorrect. The F1 score is the harmonic mean of precision and recall, calculated per class. Accuracy does not imply any specific F1 value; they are distinct evaluation metrics.
• D. Incorrect. Log loss measures the cross-entropy between predicted probabilities and true labels, not the percentage of correct classifications. An accuracy of 0.72 means 72% samples correctly classified, not a log-loss agreement.

Correct answer: A — The accuracy computed on the training data using the indexed label column.

• A. Correct. The `model.summary.accuracy` in Spark MLLib's LogisticRegressionSummary reports the accuracy computed on the training data using the indexed label column. This is the default behavior; no validation set is held out unless explicitly configured.
• B. Incorrect. Spark MLLib does not automatically hold out a validation set during training for logistic regression. Any validation split must be done explicitly using tools like `CrossValidator` or `TrainValidationSplit`.
• C. Incorrect. The accuracy is computed using the indexed label column ('label'), not the original string 'outcome' column. The StringIndexer transforms the labels, and the model operates on the numeric values.
• D. Incorrect. The `model.summary.accuracy` does not perform internal cross-validation. Cross-validation requires explicit use of `CrossValidator` or similar utilities.

Correct answer: C — Large transformer-based models with many parameters.

• A. Incorrect. Linear regression with small feature sets is computationally lightweight and runs efficiently on CPUs. GPU overhead often outweighs the minimal parallel computation benefits, so no significant latency reduction is observed.
• B. Incorrect. Decision tree-based models rely on branching logic and irregular control flow, which do not map well to GPU parallelism. Their inference is dominated by sequential decisions rather than large matrix operations, limiting GPU acceleration benefits.
• C. Correct. Large transformer-based models involve massive tensor and matrix computations that are highly parallelizable. GPUs are optimized for such operations, dramatically reducing inference latency for these models.
• D. Incorrect. Rule-based models execute sequential conditional logic and simple comparisons, which do not benefit from GPU parallelism. Latency depends on rule complexity rather than raw compute throughput, making GPU acceleration ineffective.

Correct answer: A — Externalize session state to a distributed cache like Redis.

• A. Correct. Externalizing session state to a distributed cache such as Redis decouples state from individual replicas, allowing replicas to be stateless and safely scale up or down without losing user session data. This is the standard pattern for enabling autoscaling on stateful workloads.
• B. Incorrect. Sticky sessions route requests from the same user to the same replica, but they do not prevent state loss when that replica is terminated or rescheduled during autoscaling. They also reduce load-balancing effectiveness and provide no durable session storage.
• C. Incorrect. Keeping state only in memory and synchronizing replicas is fragile, complex, and not scalable. It does not guarantee consistency during autoscaling events and can still result in data loss.
• D. Incorrect. Disabling autoscaling avoids state-loss issues but contradicts the requirement to enable autoscaling. The recommended approach is to externalize state, not to prevent scaling.

Correct answer: A — Set the minimum replicas to 0 to allow scaling down to zero during low-traffic periods.

• A. Correct. Setting minimum replicas to 0 allows the endpoint to scale down to zero when there is no traffic, minimizing costs during low-demand periods like nighttime. This is a cost-effective autoscaling configuration for cyclic traffic patterns.
• B. Incorrect. Manually scaling every day introduces operational overhead and is error-prone compared to automated scaling. It is not efficient or scalable for predictable cyclic patterns.
• C. Incorrect. Setting a very high target CPU utilization may reduce the number of replicas but does not allow scaling down to zero during low traffic. It can also hurt performance by overloading the remaining replicas.
• D. Incorrect. Using a smaller instance type lowers per-replica cost, but never scaling down keeps resources running all night, wasting money. This does not take advantage of the cyclic traffic pattern to minimize costs.

Correct answer: C — Bagging primarily reduces variance, while boosting primarily reduces bias.

• A. Incorrect. This statement reverses the training order. Bagging trains models in parallel on different bootstrap samples, while boosting trains models sequentially, with each new model focusing on correcting errors of previous ones.
• B. Incorrect. Bagging typically combines predictions using majority voting (classification) or averaging (regression), while boosting uses weighted voting, but this is not the primary difference; the core distinction lies in variance vs. bias reduction.
• C. Correct. Bagging (e.g., Random Forest) primarily reduces variance by averaging multiple models trained on different data subsets, making predictions more stable. Boosting (e.g., AdaBoost) primarily reduces bias by sequentially building models that correct prior mistakes.
• D. Incorrect. Both bagging and boosting can be applied to both regression and classification tasks. The difference is not about task type but about how the ensemble is trained and how predictions are combined.

Correct answer: B — It is the tradeoff between bias (underfitting) and variance (overfitting) as model complexity changes.

• A. Incorrect. This describes a tradeoff between predictive accuracy and training time, which does not address the overfitting issue. The near-zero training error and high validation error with increasing depth is a classic sign of the bias-variance tradeoff, not computational efficiency.
• B. Correct. As tree depth increases, model complexity increases, reducing bias (underfitting) but increasing variance (overfitting). The observed pattern—low training error and high validation error—is the classic bias-variance tradeoff, indicating overfitting.
• C. Incorrect. The tradeoff between number of input features and interpretability does not explain the behavior. The phenomenon is about model complexity and generalization, not feature count or interpretability.
• D. Incorrect. False positive and false negative rates relate to classification thresholds and error types, not to why deeper trees overfit. The behavior is best explained by bias and variance, not class-specific error tradeoffs.

Correct answer: B — It penalizes the sum of squared coefficient values.

• A. Incorrect. This statement is ambiguous but more closely describes L1 regularization, where the penalty is constant, leading to some coefficients being zero. L2 regularization shrinks coefficients proportionally, not by the same amount.
• B. Correct. L2 regularization adds a penalty equal to the sum of the squared coefficient values (Ridge regression). This discourages large coefficients but does not force them to zero.
• C. Incorrect. This is a property of L1 regularization (Lasso), which can set some coefficients exactly to zero, performing feature selection. L2 regularization shrinks coefficients smoothly but rarely eliminates them.
• D. Incorrect. While L2 regularization does reduce variance and increase bias, this statement is true of regularization in general and does not specifically identify L2.

Correct answers: B, C — Increase the maximum allowed depth of each individual tree.; Decrease the minimum samples required to split an internal node.

• A. Incorrect. Increasing the number of trees generally reduces variance and improves stability, but does not increase the complexity of individual trees, so it is not effective for reducing underfitting.
• B. Correct. Increasing the maximum depth allows trees to grow deeper, capturing more complex patterns and reducing underfitting. However, it also increases the risk of overfitting.
• C. Correct. Decreasing the minimum samples required to split an internal node allows more frequent splits, making trees more complex and better fitting the training data, which can reduce underfitting.
• D. Incorrect. Increasing the minimum samples at a leaf node forces larger leaves, simplifying the model and increasing underfitting, not reducing it.

Correct answer: B — Raise the classification threshold to increase precision, sacrificing recall.

• A. Lowering the classification threshold increases recall but typically decreases precision due to more false positives. This option prioritizes recall, not precision.
• B. Raising the classification threshold makes the model more conservative, reducing false positives and increasing precision, while recall decreases. This is the standard trade-off to increase precision.
• C. Acquiring more labeled data can improve model performance overall but does not directly or reliably increase precision while sacrificing recall. The outcome depends on data quality and model behavior.
• D. A more complex ensemble may improve both metrics or increase overfitting, but it does not guarantee a controlled increase in precision with reduced recall, and it is not the standard approach for this trade-off.

Correct answer: B — To tune hyperparameters and detect overfitting during training.

• A. Incorrect. Evaluating the model on unseen data after training is complete is the purpose of the test set, not the validation set. The validation set is used during training to guide model development and tuning.
• B. Correct. The validation set is used to tune hyperparameters and monitor performance on data not used for training. It also helps detect overfitting by showing when validation performance stops improving while training performance continues, ensuring the model generalizes well.
• C. Incorrect. A validation set does not reduce computational time; it adds some extra evaluation overhead during training. Its purpose is model evaluation and tuning, not optimization of training speed.
• D. Incorrect. A validation set does not increase model complexity. Model complexity is determined by architecture and hyperparameters; the validation set provides feedback to select a better configuration and prevent overfitting.

Correct answer: A — Increasing model complexity reduces bias and increases variance.

• A. Correct. As model complexity increases, the model fits the training data more closely, reducing bias. However, the model becomes more sensitive to noise, increasing variance (risk of overfitting).
• B. Incorrect. Increasing model complexity typically reduces bias, not increases it, because the model can capture more patterns. Variance increases, not decreases, with higher complexity.
• C. Incorrect. Decreasing model complexity usually increases bias (underfitting) and reduces variance. The statement reverses the actual effect.
• D. Incorrect. Decreasing model complexity increases bias and reduces variance. The statement incorrectly claims that variance increases when it actually decreases.