k_fold

Builtin index · Statistics & ML

result = k_fold(X, y, folds)

Input: X, y, folds · Output: result

What it is

Splits an N-row feature matrix X and a length-N target vector y into an integer number of folds cross-validation folds.

Overloads

One call shape — this function is not overloaded.

Code	Input	Output	Description
`result = k_fold(X, y, folds)`	`X` matrix, vector, or numbernot documented yet `y` matrix, vector, or numbernot documented yet `folds` matrix, vector, or numbernot documented yet	`result` Record	Returns a length-`folds` list, each entry a Record with `X_train`/`X_test`/`y_train`/`y_test` for that fold; the loop over them (fitting a model per fold and averaging the score) is yours to write.

Examples

From the documentation, and run by the build -- the output and the figure below are what the engine actually produced. Simplest first.

print("corrcoef matrix:\n{round(corrcoef(X), 3)}")

m = ols_model(X, y)
yhat = m.predict(X)
print("mae: {round(mae(y, yhat), 4)}, mse: {round(mse(y, yhat), 4)}")

cm = knn_model(Xc, yc, 5, kind = "classification")
predc = cm.predict(Xc)
print("precision: {round(precision(yc, predc), 3)}")
print("recall:    {round(recall(yc, predc), 3)}")
print("f1:        {round(f1(yc, predc), 3)}")

folds = k_fold(X, y, 4)
print("k_fold: {len(folds)} folds, first fold trains on {rows(folds[0].X_train)} rows")

stab = cv_stability(Xc, yc, n_repeats = 5, cv_folds = 3)
print("cv_stability: {round(mean(stab), 3)} +/- {round(std(stab), 3)}")

ab = ablation_study(Xc, yc, cv_folds = 3)
print("ablation_study scores: {round(ab, 4)}")
print("rfe keeps:             {rfe(Xc, yc, 1)}")
print("mutual_info_classif:   {round(mutual_info_classif(Xc, yc, k = 3), 4)}")
print("astar_mrmr keeps:      {astar_mrmr(Xc, yc, 1)}")
print("permutation_importance: {round(permutation_importance(m, X, y, n_repeats = 5), 4)}")

output

corrcoef matrix:
[1, -0.119, 0.007; -0.119, 1, -0.036; 0.007, -0.036, 1]
mae: 0.0847, mse: 0.011
precision: 0.995
recall:    0.995
f1:        0.995
k_fold: 4 folds, first fold trains on 90 rows
cv_stability: 0.908 +/- 0.012
ablation_study scores: [0.2401, 0.1301]
rfe keeps:             [0]
mutual_info_classif:   [0.2398, 0.1939]
astar_mrmr keeps:      [0]
permutation_importance: [1.5394, 0.3327, 0.0947]

from statistics-ml

How it works

k_fold(X, y, k, [seed=], [shuffle=true]) — sklearn's KFold: partitions rows into k roughly-equal contiguous groups (sizes differ by at most 1 — the extra n % k rows go to the first folds, matching sklearn's own convention) after an optional shuffle, and returns a Value::List of k "split"-kind model handles — the exact same .X_train/ .X_test/.y_train/.y_test field convention train_test_ split already established, so any existing _model + .score script pattern works unchanged inside a for fold in k_fold(...) loop. Deliberately returns *data*, not a score: unlike sklearn's cross_val_score, Qu has no way to pass an unfitted estimator as a first-class value, so the fit/score call is left to the calling script (or, later, to grad's §38 successors) rather than baked in here.

From the note above this builtin in the interpreter, where the reasoning was written down as it was built.