k-Fold Cross-Validation

k-fold cross-validation estimates how a model will do on unseen data by averaging k small train-and-test runs. Instead of trusting one arbitrary train/test split, every slice of the data takes a turn as the test set.

Where you meet it

Reporting "5-fold CV accuracy" in an assignment or thesis, instead of one train/test number.
scikit-learn's cross_val_score and KFold.
Small datasets, where carving off a fixed 20% test set wastes data you can't spare.
Comparing two models, or picking a hyperparameter (k in kNN, tree depth, …).

What it does

It turns the vague question "how will this generalise?" into k honest little experiments and averages them, so the verdict rides on all of the data rather than one lucky slice.

Cross-validation buys you a test-set-sized verdict without ever permanently setting aside a test set.

How it works

Every fold is held out exactly once, so every point is scored by a model that never saw it; the CV score is simply the average of the k held-out errors. This tool fits a real least-squares line on each training set, so the per-fold error is honest — nothing is reused between training and testing.

data → k equal folds.   for each fold i = 1..k:
    train the model on the other k−1 folds
    error_i = its error on fold i        # fold i was never trained on
CV score = (error_1 + … + error_k) / k   # the average is the estimate

k = N  →  leave-one-out: N models, each tested on a single point

Why not just make k huge? Small k means each model trains on much less than the full data, so the estimate runs a little pessimistic (biased high). Push k up to N (leave-one-out) and each model trains on almost everything — bias nearly vanishes — but the N near-identical models give errors that move together, so their average gets noisier and slower. That trade-off is why k = 5 or 10 is the usual sweet spot.

Watch out

Fit nothing on the test fold — not even the scaler. Scaling, imputing, feature selection, PCA: all must be learned inside the loop, on the training folds only. Do it once on the whole dataset before splitting and information leaks, so the score comes out flatteringly good. scikit-learn Pipelines wire this correctly.
Shuffle unless order matters. Contiguous folds (like here) assume rows aren't sorted by label or date. Sorted by class → some folds miss whole classes: shuffle, or use stratified folds. Time series → don't shuffle; train on the past and test on the future, or tomorrow leaks into today.
Picking with CV ≠ scoring with CV. Try twenty settings and keep the best CV number, and that number is already optimistic — the winner got lucky on these folds. Report a fresh hold-out, or a nested loop, for the honest score.

One split gives you a number; k folds tell you whether to trust it.

Go deeper

k-fache Kreuzvalidierung schätzt, wie gut ein Modell auf ungesehenen Daten läuft, indem sie k kleine Trainings-und-Test-Durchläufe mittelt. Statt einem einzigen willkürlichen Train/Test-Split zu vertrauen, ist jede Scheibe der Daten einmal der Test-Satz.

Wo es vorkommt

„5-fache CV-Genauigkeit" in einer Aufgabe oder Thesis berichten, statt einer einzelnen Train/Test-Zahl.
scikit-learns cross_val_score und KFold.
Kleine Datensätze, wo ein fester 20%-Test-Satz Daten verschwendet, die du nicht entbehren kannst.
Zwei Modelle vergleichen oder einen Hyperparameter wählen (k bei kNN, Baumtiefe, …).

Was es tut

Es verwandelt die vage Frage „wie gut generalisiert das?" in k ehrliche kleine Experimente und mittelt sie — so hängt das Urteil an allen Daten statt an einer glücklichen Scheibe.

Kreuzvalidierung verschafft dir ein Urteil in Test-Satz-Größe, ohne je dauerhaft einen Test-Satz beiseitezulegen.

Wie es funktioniert

Jeder Fold wird genau einmal zurückgehalten, also wird jeder Punkt von einem Modell bewertet, das ihn nie sah; der CV-Score ist einfach der Mittelwert der k zurückgehaltenen Fehler. Dieses Tool passt auf jedem Trainingssatz eine echte Least-Squares-Gerade neu an — der Fehler pro Fold ist ehrlich, zwischen Training und Test wird nichts wiederverwendet.

Daten → k gleiche Folds.   für jeden Fold i = 1..k:
    Modell auf den anderen k−1 Folds trainieren
    Fehler_i = sein Fehler auf Fold i    # Fold i war nie im Training
CV-Score = (Fehler_1 + … + Fehler_k) / k # der Mittelwert ist die Schätzung

k = N  →  Leave-One-Out: N Modelle, jedes an einem einzigen Punkt getestet

Warum nicht einfach k riesig machen? Kleines k heißt, jedes Modell trainiert auf viel weniger als den vollen Daten, also fällt die Schätzung etwas pessimistisch aus (nach oben verzerrt). Treibst du k auf N (Leave-One-Out), trainiert jedes Modell auf fast allem — die Verzerrung verschwindet fast — aber die N fast identischen Modelle liefern gleichlaufende Fehler, ihr Mittel wird verrauschter und langsamer. Wegen dieses Abwägens ist k = 5 oder 10 der übliche Sweet Spot.

Worauf achten

Auf dem Test-Fold nichts anpassen — nicht mal den Scaler. Skalieren, Imputieren, Feature-Selection, PCA: alles muss innerhalb der Schleife gelernt werden, nur auf den Trainings-Folds. Machst du es einmal auf dem ganzen Datensatz vor dem Splitten, leckt Information und der Score fällt schmeichelhaft aus. scikit-learn-Pipelines verdrahten das korrekt.
Mischen, außer die Reihenfolge zählt. Zusammenhängende Folds (wie hier) setzen voraus, dass die Zeilen nicht nach Label oder Datum sortiert sind. Nach Klasse sortiert → manchen Folds fehlen ganze Klassen: mischen oder stratifizierte Folds. Zeitreihe → nicht mischen; auf der Vergangenheit trainieren, auf der Zukunft testen, sonst leckt das Morgen ins Heute.
Wählen mit CV ≠ Bewerten mit CV. Probierst du zwanzig Einstellungen und behältst die beste CV-Zahl, ist diese Zahl schon optimistisch — der Gewinner hatte auf genau diesen Folds Glück. Berichte einen frischen Hold-out oder eine geschachtelte Schleife für den ehrlichen Score.

Ein Split gibt dir eine Zahl; k Folds sagen dir, ob du ihr trauen kannst.