Free Scikit-learn Associate Practitioner Certification Sample Questions

Correct answer: B — The amount by which the model's prediction would change if it were estimated using a different training dataset.

• A. This option describes the bias term. Bias represents the error introduced by approximating a complex real-world relationship with a simplified model, which often leads to underfitting.
• B. This is the correct definition. Variance measures the model's sensitivity to the specific training set used. It captures how much the model's predictions would fluctuate if it were trained on different samples from the same data-generating process.
• C. This refers to the irreducible error (often denoted as sigma squared). This is the noise inherent in the data itself that cannot be eliminated regardless of the model chosen.
• D. This describes the mathematical definition of bias: the difference between the average prediction of our model (across many hypothetical training sets) and the true underlying value.

Correct answer: C — Decrease the max_depth parameter.

• A. Incorrect. Increasing the max_depth parameter allows the tree to grow deeper and model more complex patterns, which typically increases variance and worsens overfitting rather than reducing it.
• B. Incorrect. Decreasing the min_samples_split parameter allows the tree to perform splits on nodes with fewer samples, creating a more granular and complex tree. To reduce variance, you would generally increase this parameter to prevent the model from learning noise in small subsets of data.
• C. Correct. Decreasing the max_depth parameter constrains how deep the tree can grow, effectively limiting its complexity. This is a primary form of regularization for decision trees that helps reduce variance and mitigate overfitting.
• D. Incorrect. Setting max_features to None is the default behavior, which forces the tree to consider all features for each split. To reduce variance and overfitting, one would typically set this to a smaller subset of features (e.g., 'sqrt' or a float) to introduce randomness and limit the tree's capacity.

Correct answer: C — Supervised regression

• A. Incorrect. Unsupervised clustering is used to group data points without labeled responses. This problem involves predicting a numeric outcome (selling price) based on a labeled dataset where the target is already known for existing houses.
• B. Incorrect. Supervised classification is used when the target variable is categorical or discrete (e.g., 'spam' vs 'not spam'). In this case, the selling price is a continuous numeric value.
• C. Correct. This is a supervised regression problem because the goal is to predict a continuous numeric output variable (selling price) based on labeled input features such as square footage and number of bedrooms.
• D. Incorrect. Semi-supervised classification typically involves a dataset with a mix of many unlabeled examples and a few labeled examples for categorical prediction. This scenario provides a fully labeled dataset and seeks a continuous value prediction, not a discrete label.

Correct answers: A, C — The model is overfitting the training data.; You should decrease the complexity of the model (e.g., limit tree depth) to improve generalization.

• A. Correct. A very high training accuracy (99%) combined with a significantly lower test accuracy (62%) is a classic sign of overfitting. This means the model has learned noise and specific patterns within the training data that do not generalize to unseen data. Decision trees are particularly prone to this if they are allowed to grow deep without constraints.
• B. Incorrect. Underfitting occurs when a model is too simple to capture the underlying structure of the data, resulting in low accuracy on both the training and test sets. Since the training accuracy here is very high, underfitting is not the issue.
• C. Correct. Reducing model complexity is a standard technique to mitigate overfitting and improve generalization. For scikit-learn's DecisionTreeClassifier, this can be achieved by tuning hyperparameters such as max_depth, min_samples_leaf, or min_samples_split to constrain the tree growth.
• D. Incorrect. Increasing model complexity would likely worsen overfitting. More complexity allows the model to fit the training data even more tightly (memorizing more noise), which typically leads to an even wider gap between training and test performance.
• E. Incorrect. If the test set were identical to the training set, the performance on the test set would be nearly identical to the training performance (99%). The significant drop to 62% confirms that the test set is different and that the model's performance fails to generalize to it.

Correct answer: C — K-fold cross-validation (e.g., 5-fold or 10-fold).

• A. A 50/50 train/test split significantly reduces the amount of data available for training. For a small dataset of 150 records, this leaves only 75 samples for the model to learn from, likely resulting in poor performance and a performance estimate with high variance.
• B. A 99/1 train/test split uses almost all data for training but leaves an extremely small test set (e.g., 1 or 2 samples for a dataset of 150). This produces an unreliable and high-variance estimate of performance that cannot accurately reflect the model's ability to generalize to new data.
• C. K-fold cross-validation is the standard approach for small datasets. By partitioning the data into k folds and rotating which fold is used for testing, every data point is used for both training and testing across different iterations. This maximizes training data usage in each fold (e.g., 90% in 10-fold) while providing a stable, averaged performance estimate.
• D. Training and testing on the same dataset is a major methodological error. It leads to an overoptimistic bias because the model is evaluated on data it has already seen, making it impossible to detect overfitting or measure how the model will perform on unseen data.

Correct answer: B — It will always predict the majority class of the entire training dataset for any input.

• A. Incorrect. Setting n_neighbors equal to the number of training samples does not result in memorization; instead, every prediction is based on the vote of all training points. Unless the dataset consists of only one class, this will not result in 100% training accuracy, as it defaults to the majority label regardless of the local data structure.
• B. Correct. When k is equal to the total number of training samples (N), the set of nearest neighbors for any query point is the entire training dataset. Therefore, the classifier will always return the most frequent label (the majority class) in the training set, effectively acting as a constant classifier.
• C. Incorrect. A very large k (like k = N) increases bias and reduces variance, causing extreme underfitting. Overfitting is characterized by high variance and is associated with a very small k (e.g., k = 1), not a k equal to the total dataset size.
• D. Incorrect. K-Nearest Neighbors is a non-parametric model and does not transform into a parametric linear model. While a constant prediction technically has no complex boundary, the model does not change its underlying algorithm to a linear function.

Correct answer: B — The model is suffering from high bias (underfitting).

• A. Incorrect. High variance (overfitting) is characterized by a significant gap between the training score and the cross-validation score. In that scenario, the training score remains high, while the validation score is much lower.
• B. Correct. When both the training and cross-validation scores converge to a low value as the sample size increases, it indicates high bias (underfitting). This means the model is too simple or constrained to capture the underlying patterns in the data, regardless of how much data is provided.
• C. Incorrect. If the model primarily needed more data, the cross-validation score would typically still be trending upward as more data is added. Here, the scores have plateaued at a low level, suggesting that the model capacity, not the data volume, is the bottleneck.
• D. Incorrect. A well-tuned model that generalizes effectively would show both the training and validation scores converging to a high value. Converging to a low performance value (near chance) indicates poor predictive utility.

Correct answer: B — Use `PCA` (Principal Component Analysis) to reduce the dimensionality of the feature space before training.

• A. Incorrect. Applying `PolynomialFeatures` expands the feature space by creating interaction and higher-order terms. When the number of features (10,000) already far exceeds the number of samples (500), this would severely exacerbate the curse of dimensionality and increase overfitting.
• B. Correct. PCA (Principal Component Analysis) reduces dimensionality by projecting the data onto a smaller number of principal components that capture the maximum variance. In high-dimensional settings where p >> n, reducing the feature count via PCA helps mitigate overfitting and reduces noise while retaining the most significant underlying patterns.
• C. Incorrect. `MinMaxScaler` rescales features to a common range, which can help optimization algorithms (like gradient descent) converge and ensures regularization is applied fairly across features. However, it does not reduce the number of features or directly solve the overfitting problem caused by the curse of dimensionality.
• D. Incorrect. `SMOTE` is designed to address class imbalance by generating synthetic samples for the minority class. It does not reduce feature dimensionality and is not a technique intended to fix overfitting caused by having too many features relative to the number of samples.

Correct answers: A, B, C — Standard Python lists; pandas DataFrames; scipy sparse matrices

• A. Standard Python lists are valid inputs for train_test_split. These are treated as array-like structures that are indexable and have a defined length, allowing the function to compute consistent and repeatable splits.
• B. pandas DataFrames and Series objects are fully supported by train_test_split. The function preserves the array-like behavior and often maintains the original indices and column names in the returned subsets.
• C. SciPy sparse matrices (such as CSR or CSC formats) are valid inputs. The function can split sparse matrix inputs and will return the resulting splits in a compatible sparse format, which is essential for memory efficiency in large datasets.
• D. Python set objects are not valid inputs because they are unordered and do not support indexing. train_test_split requires sequence-like objects with a consistent order to ensure that features (X) and labels (y) remain aligned.
• E. Generator expressions are iterators that do not have a defined length and are consumed upon iteration. Because train_test_split needs to determine the size of the dataset and perform indexing to shuffle/split data, generators are not supported.

Correct answer: B — 5

• A. Incorrect. In the scikit-learn default confusion matrix layout, the value at index [0, 0] represents True Negatives (TN), which are instances correctly predicted as the negative class (0).
• B. Correct. In scikit-learn, the confusion matrix follows the layout [[TN, FP], [FN, TP]]. The value at position [0, 1] corresponds to False Positives (FP), which occurs when the true label is 0 (Negative) but the model predicted 1 (Positive).
• C. Incorrect. In the default layout, the value at position [1, 0] represents False Negatives (FN), which are positive instances incorrectly predicted as negative.
• D. Incorrect. In the default layout, the value at position [1, 1] represents True Positives (TP), which are instances correctly predicted as the positive class (1).

Correct answer: B — They are suffixed with an underscore (e.g., `coef_`).

• A. Incorrect. In scikit-learn, a leading underscore (e.g., `_coef`) is typically reserved for private or internal attributes and methods, following general Python conventions. It is not used for public attributes estimated during the fitting process.
• B. Correct. The scikit-learn API convention dictates that attributes estimated from the data during the `fit` method must be suffixed with a single trailing underscore (e.g., `coef_`, `intercept_`, `mean_`, `classes_`). This convention helps users distinguish between hyperparameters (set in the constructor) and learned parameters (calculated during fit).
• C. Incorrect. Capitalization is not part of scikit-learn's convention for designating estimated attributes. Scikit-learn adheres to PEP 8 standards where attribute names are lowercase with underscores.
• D. Incorrect. Scikit-learn does not store estimated parameters in a dedicated dictionary like `learned_params_`. Instead, learned attributes are assigned individually to the estimator instance with the trailing underscore suffix.

Correct answers: A, C — predict(X_test); predict_proba(X_test)

• A. The predict(X_test) method is the standard scikit-learn API for obtaining the definitive class labels (e.g., 'Fraud' or 'Not Fraud'). It returns the label of the class with the highest predicted probability for each sample.
• B. The decision_function(X_test) method is not implemented for RandomForestClassifier. While it is used in models like SVM or SGDClassifier to return signed distances to a decision boundary, it does not provide the probability scores required for this specific application.
• C. The predict_proba(X_test) method returns the class probability estimates for each sample. This provides the 'confidence scores' needed to rank alerts; for a RandomForestClassifier, these probabilities are calculated as the mean predicted class probabilities of the individual trees in the forest.
• D. The transform(X_test) method is used by transformers (like PCA or StandardScaler) or feature selectors to modify the input data. It is not used by classifiers to output predictions or confidence scores.
• E. The score(X_test, y_test) method returns the mean accuracy for the given test data. It requires the true labels (y_test) and returns a single aggregate scalar rather than the per-sample labels or probabilities needed for a final application.

Correct answers: B, C — Extract the probabilities for the positive class using `model.predict_proba(X_test)[:, 1]`, and manually apply the condition `>= 0.3`.; Scikit-learn's predict() method does not natively accept a threshold parameter for classification models.

• A. Incorrect. Scikit-learn's `predict()` method does not accept a `threshold` parameter. Attempting to pass one will result in a TypeError. Custom thresholding must be performed manually using the output of score-based methods.
• B. Correct. This is the standard procedure in scikit-learn to implement a custom threshold. `predict_proba(X_test)[:, 1]` retrieves the estimated probability of the positive class, which can then be compared against the desired threshold (0.3) to generate binary labels.
• C. Correct. In scikit-learn classifiers, the `predict()` method uses a hardcoded internal decision rule (typically a 0.5 probability threshold for binary classification). To use a different threshold, the user must manually compute it from probabilities or decision scores.
• D. Incorrect. The `class_weight` parameter is used during the training phase (the `fit()` method) to penalize misclassifications differently. Changing this parameter on a model that has already been fitted does not modify the existing decision boundary or the behavior of the `predict()` method.
• E. Incorrect. `decision_function` returns raw scores, such as the signed distance to the hyperplane (SVM) or log-odds (Logistic Regression). These are on a different scale than probabilities (0 to 1). A probability threshold of 0.3 does not equal a decision score of 0.3; for instance, in Logistic Regression, the probability 0.5 maps to a decision score of 0.

Correct answer: C — It will randomly predict A 50% of the time, B 30% of the time, and C 20% of the time.

• A. Incorrect. Always predicting the majority class (class A) is the behavior of the 'most_frequent' strategy. The 'stratified' strategy instead generates predictions by sampling based on the class priors.
• B. Incorrect. Predicting classes with equal probability (33.3% each) regardless of the training data distribution is the behavior of the 'uniform' strategy.
• C. Correct. The 'stratified' strategy in scikit-learn's DummyClassifier generates predictions by randomly sampling the class labels according to the empirical distribution (priors) found in the training data. Since the training data contains 50% A, 30% B, and 20% C, the model will produce predictions following those exact proportions.
• D. Incorrect. The DummyClassifier does not use test set distribution to make decisions, nor does it perform optimization for metrics like F1-score. It follows simple rules based on the training set distribution or constant values.

Correct answer: C — R-squared (R2) score

• A. Mean Absolute Error (MAE) measures the average absolute difference between predicted and actual values. While it can be calculated for a dummy model, the metric itself is an absolute value and does not inherently encode a comparison to a baseline model.
• B. Mean Squared Error (MSE) measures the average squared difference between predicted and actual values. Although the MSE of a mean-predicting model is equal to the variance of the target, MSE is an absolute metric and is not normalized against a dummy baseline by definition.
• C. R-squared (R2) is defined as 1 - (SS_res / SS_tot), where SS_tot is the sum of squared deviations from the mean. This denominator represents the error of a DummyRegressor using the 'mean' strategy. Therefore, R2 inherently measures how much better (or worse) the model is compared to a mean-only baseline. An R2 of 0 indicates performance equal to that dummy model.
• D. The Explained Variance Score is similar to R2 as it measures the proportion of variance explained by the model. However, it uses the variance of the residuals rather than the sum of squared errors and does not account for systematic offsets (bias) in the same way R2 does, making R2 the standard metric for direct dummy comparison.

Correct answers: A, B — cross_val_score provides an array of scores that can be used to calculate the standard deviation of the model's performance across folds.; sklearn.utils.resample can be used to generate bootstrap samples to estimate the confidence interval of a specific metric.

• A. Correct. cross_val_score returns a NumPy array containing the score for each cross-validation fold. This distribution of scores allows practitioners to calculate the mean and standard deviation, providing a measure of the variability and stability of the model performance.
• B. Correct. While scikit-learn does not have a dedicated 'Bootstrap' class in model_selection, sklearn.utils.resample is the standard tool for generating resampled datasets with replacement. This allows users to manually implement bootstrapping to derive empirical distributions and confidence intervals for any metric.
• C. Incorrect. cross_val_score returns an array of scores for each split. It does not perform statistical inference (like calculating 95% confidence intervals) automatically; the user must compute these statistics from the returned array.
• D. Incorrect. There is no BootstrapCV class in the official scikit-learn API. Bootstrapping is typically achieved using sklearn.utils.resample or by using ShuffleSplit for repeated random sub-sampling.
• E. Incorrect. The cross_validate function is specifically designed to support multiple scoring metrics simultaneously. This allows for a more comprehensive analysis of uncertainty across various performance dimensions compared to cross_val_score.

Correct answers: A, B — `roc_auc_score(y_test, y_proba, multi_class='ovr')`; `roc_auc_score(y_test, y_proba, multi_class='ovo')`

• A. Correct. `roc_auc_score` supports multiclass AUC when `multi_class='ovr'` (One-vs-Rest) is specified. This approach requires `y_proba` to contain class probability estimates for each class.
• B. Correct. `roc_auc_score` supports multiclass AUC when `multi_class='ovo'` (One-vs-One) is specified. This method computes the average of pairwise ROC AUCs for all possible combinations of classes.
• C. Incorrect. Without specifying the `multi_class` parameter, `roc_auc_score` will not successfully handle multiclass probability arrays and will typically raise an error because the default behavior is intended for binary classification.
• D. Incorrect. `np.argmax(y_proba, axis=1)` produces discrete class labels (hard predictions). ROC AUC score requires continuous probability scores or decision values for each class to evaluate different thresholds.
• E. Incorrect. `average='binary'` is only applicable to binary classification tasks. For multiclass scenarios, you must use a multiclass strategy ('ovr' or 'ovo') and an appropriate averaging method like 'macro' or 'weighted'.

Correct answers: A, B — `RocCurveDisplay.from_estimator(svc, X_test, y_test)`; `y_score = svc.decision_function(X_test)` followed by `RocCurveDisplay.from_predictions(y_test, y_score)`

• A. Correct. `RocCurveDisplay.from_estimator` is the standard scikit-learn API to create an ROC curve plot directly from a fitted estimator, feature matrix, and true labels. It automatically handles score computation internally.
• B. Correct. `RocCurveDisplay.from_predictions` accepts ground truth labels and score-like continuous values. Since `svc.decision_function(X_test)` provides these scores, this is a valid manual two-step approach.
• C. Incorrect. While `RocCurveDisplay` has a `.plot()` method, it is an instance method used to render an already-created display object. It cannot be called as a class method with these arguments.
• D. Incorrect. The `roc_curve` function computes the FPR and TPR and returns NumPy arrays. It does not return a display object and does not have a `.plot()` method.
• E. Incorrect. The signature for `from_estimator` requires the estimator first, then features (X), then labels (y). Furthermore, `svc.predict` returns discrete class labels, which are insufficient for a standard ROC curve that requires continuous scores or probabilities.

Correct answer: C — To provide a reference point showing how much value the complex model adds over a simple, naive guess.

• A. Incorrect. A baseline model (like a DummyClassifier) represents a naive level of performance, acting as a lower bound or starting point. It does not indicate the theoretical maximum or upper limit of accuracy for the dataset.
• B. Incorrect. While baseline models are often computationally inexpensive, their primary purpose in stakeholder communication is to provide context for performance metrics rather than to demonstrate the speed of the pipeline.
• C. Correct. A baseline model provides a crucial benchmark to show the 'lift' or incremental value added by a more sophisticated model. This helps stakeholders understand whether the complexity, cost, and risk associated with a complex model are justified compared to a simple, rule-based approach (like always predicting the most frequent class).
• D. Incorrect. A baseline model is used for performance comparison and does not serve as a tool for statistical hypothesis testing regarding the distribution of the underlying data.

Correct answers: A, C — Scikit-learn's Display classes (like `RocCurveDisplay`) return objects that contain a matplotlib `ax_` attribute, allowing further customization.; Scikit-learn's built-in plotting functions are built on top of matplotlib.

• A. Scikit-learn's Display classes (e.g., RocCurveDisplay, PrecisionRecallDisplay, ConfusionMatrixDisplay) return an object that stores the matplotlib Axes used in the `ax_` attribute. This allows users to apply additional matplotlib customizations, such as setting titles or adjusting axes, after the display has been created.
• B. Seaborn functions expect data structures like Pandas DataFrames, NumPy arrays, or lists. They do not accept scikit-learn estimator objects (the models themselves) as the data source; model outputs like predictions or residuals must be extracted into compatible arrays first.
• C. Scikit-learn's visualization API is designed as a high-level wrapper around matplotlib. Because it is built on top of matplotlib, the resulting plots are standard matplotlib figures and axes, making them fully compatible with the broader matplotlib ecosystem for fine-tuning.
• D. Matplotlib is a core dependency for scikit-learn's plotting and display utilities. Far from needing to be uninstalled, it must be installed for these functions to work, as they rely on matplotlib's rendering engine.

Correct answers: B, D — It centers the data by removing the mean and scales it to unit variance.; Its transformation is calculated independently for each feature.

• A. Incorrect. This describes MinMaxScaler, which scales features to a specific range (typically [0, 1]). StandardScaler centers features around mean 0 and scales to unit variance but does not enforce specific min/max bounds.
• B. Correct. The core function of StandardScaler is to standardize features by removing the mean and scaling to unit variance (z-score normalization). This results in features with approximately zero mean and unit variance.
• C. Incorrect. StandardScaler is sensitive to outliers because outliers significantly skew the calculation of the mean and standard deviation. RobustScaler (which uses the median and interquartile range) is preferred when outliers are present.
• D. Correct. StandardScaler computes its statistics (mean and variance) and applies the transformation independently for each feature (column), meaning each variable is standardized based on its own distribution.
• E. Incorrect. Scaling individual samples (rows) to have a unit norm is the behavior of the Normalizer transformer. StandardScaler standardizes features (columns) across all samples.

Correct answer: C — Call fit_transform on X_train, and transform on X_test.

• A. Incorrect. Calling fit_transform on both X_train and X_test is a mistake because it computes different scaling parameters (mean and standard deviation) for each set independently. The test set should never be used to fit the scaler, as it would influence the preprocessing step with information the model shouldn't have.
• B. Incorrect. Fitting the scaler on the entire dataset X (before the split or by combining sets) results in data leakage. The scaler would incorporate the mean and variance of the test data into the training process, providing the model with information about the distribution of unseen data.
• C. Correct. This is the standard procedure to prevent data leakage. fit_transform on X_train calculates the parameters (mean/std) based only on the training data and applies them. Then, transform on X_test uses those same training-derived parameters to scale the test data, ensuring the test set remains truly unseen during the fitting process.
• D. Incorrect. Calling transform on X_train without first fitting the scaler will result in an error (NotFittedError) because the scaler has no parameters yet. Additionally, using fit_transform on the test set would leak test-set information.

Correct answer: A — 'mean'

• A. Correct. The default strategy for `sklearn.impute.SimpleImputer` is 'mean'. This strategy calculates the mean (average) of the non-missing values in each column and replaces the missing values with that result. This strategy is only applicable to numerical data types.
• B. Incorrect. While 'median' is a valid strategy that can be more robust to outliers for numeric features, it is not the default behavior of `SimpleImputer`. It must be explicitly set using `strategy='median'`.
• C. Incorrect. The 'most_frequent' strategy replaces missing values with the most common value (mode) in each column. This is often used for categorical data, but it is not the default setting.
• D. Incorrect. The 'constant' strategy replaces missing values with a fixed value (defined by the `fill_value` parameter). While useful for filling specific constants or placeholders like 'missing_value', it is not the default strategy.

Correct answer: B — statistics_

• A. Incorrect. The `SimpleImputer` class does not have an attribute called `means_`. While other scikit-learn objects like `StandardScaler` use `mean_` (singular), `SimpleImputer` uses a consistent generic name for all imputation strategies.
• B. Correct. The `statistics_` attribute stores the values learned during the `fit` process. Whether the strategy is 'mean', 'median', or 'most_frequent', the resulting values used for imputation are always stored in this array.
• C. Incorrect. `imputed_values_` is not a valid attribute in the scikit-learn API. The imputer provides the per-feature learned values via `statistics_`, rather than exposing the results under this name.
• D. Incorrect. While `fill_value` is a parameter used when `strategy='constant'`, the resulting attribute after fitting is still `statistics_`. There is no attribute named `fill_values_` on the `SimpleImputer` object.

Correct answer: D — Scikit-learn does not have a built-in function for reading Parquet files; external libraries must be used.

• A. Incorrect. While pyarrow is a widely used engine for Parquet files, scikit-learn does not provide a native `sklearn.datasets.read_parquet` function that utilizes it.
• B. Incorrect. fastparquet is an alternative library for reading Parquet data, but scikit-learn does not include a built-in module or function to interface with it for file loading.
• C. Incorrect. Pandas is the industry standard for reading Parquet files into DataFrames using `pd.read_parquet()`, but scikit-learn does not wrap this functionality or ship its own equivalent function in the `sklearn.datasets` module.
• D. Correct. Scikit-learn does not have a built-in `read_parquet` function. It is designed to work with data that has already been loaded into memory (e.g., as NumPy arrays or Pandas DataFrames) using external libraries like pandas, pyarrow, or fastparquet.

Correct answer: B — The range containing the middle 50% of the data points.

• A. Incorrect. The distance between the minimum and maximum values (excluding outliers) is typically represented by the whiskers in a boxplot. The IQR specifically measures the distance between the first and third quartiles, not the full range of the data.
• B. Correct. The interquartile range (IQR) is defined as the distance between the first quartile (Q1) and the third quartile (Q3). In a boxplot, this is visually represented by the 'box' itself, which contains the middle 50% of the dataset's observations.
• C. Incorrect. IQR is a robust, quantile-based measure of spread, whereas standard deviation measures average deviation around the mean. Boxplots are built using medians and quartiles, making them less sensitive to outliers than mean-based metrics.
• D. Incorrect. The IQR describes the observed spread of the central distribution, not a statistical confidence interval. While some boxplot variations include 'notches' to represent a confidence interval for the median, the box itself always represents the IQR.

Correct answer: A — OneHotEncoder(handle_unknown='ignore')

• A. Correct. Setting handle_unknown='ignore' ensures that categories not seen during the fit method (like 'Yellow') will result in an all-zero row in the transformed output instead of raising a ValueError. This maintains the same number of output columns as learned during training.
• B. Incorrect. handle_unknown='error' is the default behavior of OneHotEncoder. It will raise a ValueError when it encounters an unknown category like 'Yellow' during transformation, which does not meet the requirement.
• C. Incorrect. OneHotEncoder does not have an unknown_value parameter. This parameter is used in OrdinalEncoder to specify the value assigned to unknown categories.
• D. Incorrect. The drop='first' parameter is used to remove the first category of each feature to avoid multicollinearity (the dummy variable trap). It does not handle unknown categories and will still result in an error if an unseen value is encountered unless handle_unknown='ignore' is also specified.

Correct answer: C — The univariate distribution of each feature (e.g., histograms or KDE plots).

• A. Plotting a feature against itself as a scatterplot would simply result in a straight line (the identity line), which provides no useful insight. Most plotting libraries replace this redundant visualization with univariate summaries.
• B. Pearson correlation coefficients are numerical summaries typically presented in a correlation matrix or heatmap. While they describe the relationship between features, they are not the standard graphical element placed on the diagonal of a scatterplot matrix.
• C. The diagonal axes are used to display the marginal (univariate) distribution of each variable. This allows the user to observe the frequency, range, skewness, and modality of individual features using histograms or Kernel Density Estimate (KDE) plots.
• D. While boxplots are useful for identifying outliers and understanding the spread of data, they are not the default choice for the diagonal of a scatterplot matrix. Histograms and KDE plots are the industry standard as they provide more detail about the density of the distribution.

Correct answer: B — It raises a ValueError because it cannot convert the strings to floats.

• A. StandardScaler is designed for numerical data scaling and does not operate on character codes or ASCII values. It requires numeric inputs to calculate the mean and standard deviation.
• B. Scikit-learn estimators perform data validation using `check_array`, which attempts to convert the input into a numeric NumPy array (usually float64). If the column has an 'object' dtype containing Python strings, this conversion fails and raises a ValueError. You must ensure data is numeric (e.g., using `pd.to_numeric` or `.astype(float)`) before fitting.
• C. StandardScaler does not automatically parse strings or perform implicit type coercion for the user. Ensuring that the data types are correct is a prerequisite step in the preprocessing pipeline.
• D. StandardScaler validates all provided input features. It will not silently ignore or drop non-numeric columns; instead, it will raise an error if any part of the input is incompatible with numeric processing.

Correct answer: B — ValueError: could not convert string to float

• A. This exception occurs when trying to use a mutable object like a numpy array as a hashable key in a dictionary or set; it is unrelated to data type conversion during the model fitting process.
• B. Correct. Scikit-learn estimators internally use validation functions like `check_array` to ensure inputs are numeric. If the input contains strings or is an object-type array that cannot be converted to the required floating-point type, a ValueError is raised with the message 'could not convert string to float'.
• C. A KeyError is typically raised when attempting to access a missing column in a pandas DataFrame or a missing key in a dictionary. It does not reflect issues with the data types contained within existing columns.
• D. The NotFittedError is a scikit-learn specific exception raised when calling methods that require a trained model (such as predict or transform) before fit has been executed. It is not triggered by data validation issues during the fitting phase itself.

Correct answer: B — named_transformers_

• A. Incorrect. The `transformers_` attribute is a list of (name, transformer, columns) tuples created after fitting. Because it is a list and not a name-keyed mapping, it is not the intended API for direct, efficient lookup by name.
• B. Correct. The `named_transformers_` attribute is a dictionary-like (Bunch) object that maps the user-provided transformer names to the fitted transformer instances. This allows for direct access using the syntax `ct.named_transformers_['name']`.
• C. Incorrect. `fitted_steps_` is not a valid attribute in scikit-learn. While the `Pipeline` class has a `named_steps` attribute, the `ColumnTransformer` class specifically uses `named_transformers_` for this purpose.
• D. Incorrect. The `get_params()` method returns the configuration and parameters of the estimator. While it lists sub-estimators, it is not the designated attribute for retrieving fitted transformer objects by name after the fitting process.

Correct answer: C — (10, 5)

• A. Incorrect. The shape (10,) would be a 1-dimensional array. However, `train_scores` is a 2D array because it must record the specific score for every cross-validation fold at each of the 10 training sizes.
• B. Incorrect. While this contains the correct factors, the dimensions are reversed. In scikit-learn's `learning_curve`, the first axis corresponds to the training set sizes (rows) and the second axis corresponds to the CV folds (columns).
• C. Correct. The `train_scores` array is returned with the shape `(n_ticks, n_cv_folds)`. Since there are 10 training sizes (n_ticks) and 5 cross-validation folds (cv=5), the resulting shape is (10, 5). This allows for calculating statistics like the mean score for each size using `np.mean(train_scores, axis=1)`.
• D. Incorrect. The shape (50,) would be a flattened 1D array. `learning_curve` returns a 2D array to keep the scores organized by training size and cross-validation split.

Correct answer: B — return_estimator=True

• A. Incorrect. The `return_train_score` parameter determines whether training scores are included in the output dictionary. While useful for detecting overfitting, it does not provide access to the fitted estimator objects or their internal attributes like `coef_`.
• B. Correct. By default, `cross_validate` discards the estimators after scoring. Setting `return_estimator=True` ensures that the fitted model for each fold is returned in a list under the 'estimator' key, allowing you to iterate through them and inspect coefficients, feature importances, or other model-specific attributes.
• C. Incorrect. Scikit-learn's `cross_validate` does not have a `return_coefs` parameter. Accessing coefficients is done indirectly by returning the full estimator objects using `return_estimator=True`.
• D. Incorrect. `extract_features` is not a valid parameter for the `cross_validate` function. Feature extraction is typically handled in a preprocessing step or within a Pipeline, not as a parameter of the cross-validation scoring utility.

Correct answer: C — GroupKFold

• A. StratifiedKFold preserves class proportions across folds but performs the split at the individual sample level. In this scenario, different images from the same patient would likely end up in both training and validation sets, causing data leakage and an overoptimistic estimate of generalization to new patients.
• B. TimeSeriesSplit is intended for temporally ordered data where the chronological sequence must be preserved. It does not group samples by patient and therefore cannot prevent images from the same patient from appearing in both the training and testing sets.
• C. GroupKFold ensures that all samples with the same group label (in this case, patient ID) are kept together in the same fold. This prevents patient-level data leakage, ensuring that no patient seen during training appears in the validation set, which accurately measures how the model generalizes to new individuals.
• D. RepeatedKFold repeats the K-Fold cross-validation process multiple times to reduce variance, but it still splits data at the sample level. Like standard K-Fold, it would allow images from the same patient to be split across folds, leading to leakage.

Correct answer: B — refit='roc_auc' (or 'accuracy')

• A. While `refit=True` is the default behavior and works for single-metric evaluation, it is insufficient when multiple metrics are provided to the `scoring` parameter. In a multi-metric setup, `refit=True` becomes ambiguous, leading to a ValueError because the search object does not know which metric to use for final model optimization.
• B. When using multiple scoring metrics, the `refit` parameter must be set to a specific string (the name of one of the scorers provided in the `scoring` dictionary). This ensures the GridSearchCV object refits the best found estimator on the entire dataset according to that specific metric, enabling the use of `predict()`, `predict_proba()`, and `best_estimator_` after the search.
• C. The `refit` parameter does not accept a list of strings. It must be a single boolean, a single string name of a scorer, or a callable function to determine the best parameters for the final refit.
• D. Setting `refit=False` prevents the estimator from being refitted on the full training set after the hyperparameter search is complete. Consequently, the GridSearchCV object will not have a `best_estimator_` attribute and will be unable to make predictions using `predict()` or `predict_proba()`.