Scikit-learn

confusion_matrix returns a square array where rows are true classes and columns are predicted classes, so C[i, j] counts samples of true class i predicted as class j. Classes appear in sorted order unless you pass labels= to fix the order.

stratify=y tells train_test_split to preserve each class's proportion in both halves instead of splitting purely at random. Without it a rare class can land unevenly in the test set, or be missing from it entirely.

fit runs fit_transform on every step except the last, feeding each output into the next, then fit on the final estimator. predict runs transform only on those same intermediate steps — never fit again — and calls predict on the final estimator.

OrdinalEncoder maps each category to an integer in one column, which implies an ordering. That is safe for genuinely ordered features and for tree-based models that split on thresholds, but misleading for linear models, SVMs and distance-based estimators.

In scikit-learn, get_params reads the init signature and returns the same-named attributes, and clone() feeds those values straight back into the constructor. Any renaming, conversion or validation inside init breaks that round-trip and makes clone raise RuntimeError.

Inherit both, mixin first: class MyTransformer(TransformerMixin, BaseEstimator). BaseEstimator supplies get_params, set_params, the repr and the default tags; TransformerMixin supplies fit_transform and set_output. You then implement only init, fit returning self, and transform.

The average parameter decides how per-class precision values are reduced to one number. It defaults to 'binary', which scores only one class and rejects multiclass targets; multiclass data needs 'macro', 'micro', 'weighted', or None for the per-class array.

ROC-AUC measures how well a continuous score ranks positives above negatives, so it needs predict_proba(X)[:, 1] or decision_function(X). Hard 0/1 labels from predict() collapse the curve to one threshold and silently return a lower, meaningless number instead of raising.

An integer cv is expanded for you: StratifiedKFold when the estimator is a classifier and the target is binary or multiclass, plain KFold otherwise. Neither shuffles — folds are contiguous blocks of the data in its current row order.

GridSearchCV fits every combination in param_grid, so its cost multiplies with each added parameter. RandomizedSearchCV draws a fixed n_iter samples from param_distributions, letting you cap the budget and sample continuous ranges instead of a hand-picked ladder.

Use the step name, a double underscore, then the parameter name: "clf__C": [0.1, 1.0]. Nesting repeats the pattern for nested estimators, and using a step's bare name as the key replaces the whole step with another estimator or with "passthrough".

cross_val_score refits whatever estimator you hand it on each training fold. A scaler fitted outside it has already seen every fold's held-out rows, so its means and variances encode validation data and the reported score comes out optimistically biased.

ColumnTransformer fits each listed transformer on its own column subset and concatenates the results side by side in the order the transformers are declared. Columns you did not list are dropped, because remainder defaults to 'drop'.

By default OneHotEncoder raises a ValueError at transform time for any category it did not see in fit(). Setting handle_unknown='ignore' encodes the unknown value as an all-zero row instead, so scoring continues.

StandardScaler.fit() computes and stores each column's mean (mean_) and standard deviation (scale_). Test data must only go through transform(), because refitting replaces those statistics with test-set numbers the model would never have at serving time.

Prefer HistGradientBoostingClassifier on anything beyond a few thousand rows. It bins each feature into at most 255 integer bins so split-finding stops scaling with the number of distinct values, handles missing values natively, and accepts categorical columns directly.

Scikit-learn's LogisticRegression is regularized by default: penalty='l2' with C=1.0. C is the inverse of regularization strength, so a smaller C shrinks coefficients harder and a larger C fits closer to unpenalized. Pass penalty=None to switch it off.

A random forest is randomized twice: each tree trains on a bootstrap resample of the rows, and each split considers a random subset of features. With random_state left at None those draws differ per fit. Pass an integer random_state for reproducible results.

clone() returns a new, unfitted estimator of the same class built from get_params(deep=False): hyperparameters only. All fitted attributes are dropped. Plain parameter values are deep-copied, and any parameter that is itself an estimator is cloned recursively, so it comes back unfitted too.

Usually not at all: TransformerMixin's default fit_transform is literally fit(X, y).transform(X). Transformers override it when fitting and transforming together is cheaper, or when the embedding is defined only for the fitted samples — sklearn.manifold.TSNE offers fit_transform and no transform.

silhouette_score(X, labels) is internal: it scores cluster shape from the feature matrix alone, so it works without ground truth. adjusted_rand_score(labels_true, labels_pred) is external: it compares two labelings and requires true labels you usually do not have.

make_scorer wraps a metric function into a callable of the form scorer(estimator, X, y). greater_is_better=False negates the value so larger always means better, and response_method decides whether the scorer calls predict, predict_proba, or decision_function.

TimeSeriesSplit never puts later rows in a training fold: each split trains on a prefix of the rows and tests on the block immediately after, with the training window growing each split. gap drops a fixed number of rows between the train end and the test start.

FeatureUnion fits several transformers on the same input in parallel and horizontally concatenates their outputs into one feature matrix. It is the wrong tool when each transformer should see a different subset of columns — that is ColumnTransformer's job.

SimpleImputer learns one constant per column (mean, median, most frequent or a fixed value) and stores it in statistics_. KNNImputer fills from similar training rows, and IterativeImputer models each column from the others — both far more expensive.

An SVM produces a signed distance to the hyperplane, not a probability. Setting probability=True makes fit run Platt scaling — a sigmoid fitted by internal 5-fold cross-validation — which sharply increases fit time and can yield probabilities whose argmax disagrees with predict.

Score the ranking with average_precision_score, then call precision_recall_curve to choose an operating threshold: it returns precision and recall arrays one element longer than thresholds. Rebuild confusion_matrix at that threshold instead of trusting predict()'s default 0.5.

GroupKFold, given a groups array of patient IDs, guarantees no group's rows appear in both the training and test side of a split. The groups array is passed at fit time — GroupKFold(n_splits=5).split(X, y, groups) or search.fit(X, y, groups=ids).

Pass the unfitted search as the estimator to an outer cross-validation: cross_val_score(GridSearchCV(est, grid, cv=inner), X, y, cv=outer). Each outer fold tunes on its own training portion and is scored on data no tuning decision ever saw.