Learning Curve

Preview in your theme

status="ready" — 8 training sizes, 5 folds each. Training holds at 0.966 while validation plateaus at 0.797, and across the tail the 0.169 gap moved 0.015 inside ±0.032 of noise. Read: high variance.

Gradient boosting · learning curve

High variance

8 sizes · 400 to 3,200 samples · 5 folds · gap 0.169 at the largest size

training score
validation score
±1 SD across 5 folds
release target 0.860

High variance — the gap is not closinggap 0.169 at 3,200 samples

Training sits 0.169 above validation at the largest size, and across the upper half of the sweep the gap moved by 0.015 — inside its own ±0.032 noise, so it has not measurably closed. The model is fitting the training split; regularisation, fewer features or a smaller hypothesis space are the levers. Validation moved 0.011 across the same stretch against its ±0.028 noise, so more rows alone are not currently buying much.

Each line is the mean score across the folds at that training size and each band is ±1 sample standard deviation of those same fold scores, so a wide band means the folds disagreed, not that the score moved. The gap is measured fold by fold — training minus validation within one split — and the read only calls something a trend when it clears twice the standard error of that difference, measured over every size from 1,600 samples onward. A negative gap, validation above training, is what heavy regularisation looks like and is printed as it comes. Point at the plot, or tab in and use the arrow keys, to read any size.

Learning curve: R² against training-set size, 8 sizes from 400 to 3,200 training samples, 5 folds per size. Each band is the mean ± one sample standard deviation across the folds at that size. At the largest size training scores 0.966 and validation 0.797, a gap of 0.169. Read: high variance — the gap is not closing. The release target is 0.860. Exact values follow in the data table. Up to 16 sizes, evenly spaced by rank.
Training samples	Train R²	Validation R²	Gap	Folds
400	0.971 ± 0.018	0.691 ± 0.060	0.280 ± 0.071	5
800	0.974 ± 0.017	0.760 ± 0.025	0.214 ± 0.029	5
1,200	0.967 ± 0.006	0.764 ± 0.034	0.203 ± 0.031	5
1,600	0.970 ± 0.009	0.786 ± 0.027	0.185 ± 0.030	5
2,000	0.966 ± 0.005	0.808 ± 0.021	0.158 ± 0.023	5
2,400	0.966 ± 0.004	0.784 ± 0.010	0.182 ± 0.008	5
2,800	0.966 ± 0.003	0.802 ± 0.015	0.164 ± 0.014	5
3,200	0.966 ± 0.006	0.797 ± 0.016	0.169 ± 0.019	5

the same over-fitting shape caught earlier — the 0.065 gap is still real against ±0.009 of fold noise, but it narrowed 0.037 across the tail. Read: still converging, the verdict that keeps a live gap from ever being reported as met.

Random forest · learning curve

Still converging

8 sizes · 400 to 3,200 samples · 5 folds · gap 0.065 at the largest size

training score
validation score
±1 SD across 5 folds
release target 0.860

Still converging — the gap is real but closinggap 0.065 at 3,200 samples

Training still sits 0.065 above validation at the largest size — clear of the ±0.009 fold noise on that gap — but across the upper half of the sweep it narrowed by 0.037, past its own ±0.013. The curves have not met yet and are still moving toward each other, with validation itself up 0.039 across the same stretch, so the sweep is what to extend: take the bias/variance read again once the gap stops shrinking.

Learning curve: R² against training-set size, 8 sizes from 400 to 3,200 training samples, 5 folds per size. Each band is the mean ± one sample standard deviation across the folds at that size. At the largest size training scores 0.954 and validation 0.890, a gap of 0.065. Read: still converging — the gap is real but closing. The release target is 0.860. Exact values follow in the data table. Up to 16 sizes, evenly spaced by rank.
Training samples	Train R²	Validation R²	Gap	Folds
400	0.962 ± 0.009	0.698 ± 0.041	0.264 ± 0.048	5
800	0.949 ± 0.007	0.785 ± 0.021	0.164 ± 0.022	5
1,200	0.958 ± 0.010	0.807 ± 0.024	0.151 ± 0.018	5
1,600	0.953 ± 0.007	0.851 ± 0.013	0.101 ± 0.011	5
2,000	0.950 ± 0.008	0.867 ± 0.016	0.083 ± 0.020	5
2,400	0.951 ± 0.008	0.884 ± 0.012	0.067 ± 0.018	5
2,800	0.953 ± 0.006	0.878 ± 0.010	0.075 ± 0.010	5
3,200	0.954 ± 0.005	0.890 ± 0.009	0.065 ± 0.010	5

a well-regularised model the sweep stopped too early on — the curves sit on top of each other (0.003 apart, inside the fold noise) and validation is still up 0.065 across the tail. Read: still learning, so no bias/variance call is available yet.

Linear SVM · learning curve

Still learning

8 sizes · 400 to 3,200 samples · 5 folds · gap 0.0033 at the largest size

training score
validation score
±1 SD across 5 folds
release target 0.8600

Still learning — validation is still climbinggap 0.0033 at 3,200 samples

Validation gained 0.0648 across the upper half of the sweep, clearing its ±0.0177 noise, so the curve has not flattened yet. The sweep stopped before the model did — collect or label more data before drawing a bias/variance conclusion.

Learning curve: R² against training-set size, 8 sizes from 400 to 3,200 training samples, 5 folds per size. Each band is the mean ± one sample standard deviation across the folds at that size. At the largest size training scores 0.7981 and validation 0.7948, a gap of 0.0033. Read: still learning — validation is still climbing. The release target is 0.8600. Exact values follow in the data table. Up to 16 sizes, evenly spaced by rank.
Training samples	Train R²	Validation R²	Gap	Folds
400	0.6429 ± 0.0315	0.6528 ± 0.0273	-0.0098 ± 0.0437	5
800	0.6984 ± 0.0311	0.6869 ± 0.0180	0.0115 ± 0.0356	5
1,200	0.7052 ± 0.0247	0.7142 ± 0.0147	-0.0090 ± 0.0314	5
1,600	0.7374 ± 0.0177	0.7300 ± 0.0164	0.0074 ± 0.0262	5
2,000	0.7583 ± 0.0188	0.7513 ± 0.0183	0.0070 ± 0.0227	5
2,400	0.7682 ± 0.0174	0.7697 ± 0.0228	-0.0015 ± 0.0288	5
2,800	0.7896 ± 0.0129	0.7776 ± 0.0148	0.0120 ± 0.0115	5
3,200	0.7981 ± 0.0100	0.7948 ± 0.0111	0.0033 ± 0.0178	5

the finished sweep — the curves met at 0.890, nothing is moving and the release target is behind them. Read: converged, and extra rows buy nothing here.

Ridge regression · learning curve

Converged

8 sizes · 400 to 3,200 samples · 5 folds · gap 0.0031 at the largest size

training score
validation score
±1 SD across 5 folds
release target 0.8600

Converged — the curves have met and flattenedgap 0.0031 at 3,200 samples

The gap of 0.0031 is inside the fold noise and validation has stopped climbing, so the curves have met and flattened at or above the release target. Extra rows buy little here; a better score needs a different model or better features.

Learning curve: R² against training-set size, 8 sizes from 400 to 3,200 training samples, 5 folds per size. Each band is the mean ± one sample standard deviation across the folds at that size. At the largest size training scores 0.8933 and validation 0.8902, a gap of 0.0031. Read: converged — the curves have met and flattened. The release target is 0.8600. Exact values follow in the data table. Up to 16 sizes, evenly spaced by rank.
Training samples	Train R²	Validation R²	Gap	Folds
400	0.8389 ± 0.0118	0.8565 ± 0.0111	-0.0176 ± 0.0210	5
800	0.8910 ± 0.0160	0.8741 ± 0.0198	0.0169 ± 0.0124	5
1,200	0.8867 ± 0.0116	0.8850 ± 0.0161	0.0017 ± 0.0190	5
1,600	0.8954 ± 0.0120	0.8910 ± 0.0133	0.0045 ± 0.0188	5
2,000	0.8986 ± 0.0106	0.8834 ± 0.0048	0.0151 ± 0.0101	5
2,400	0.8970 ± 0.0046	0.8876 ± 0.0084	0.0094 ± 0.0076	5
2,800	0.8993 ± 0.0082	0.8936 ± 0.0061	0.0056 ± 0.0085	5
3,200	0.8933 ± 0.0063	0.8902 ± 0.0080	0.0031 ± 0.0117	5

met, flat and nowhere near good enough — validation settles at 0.736 against a 0.860 target. Read: high bias. The target is so far above the data that it is left off the y axis and marked with a caret at the edge it left by, rather than squashing both curves into a ribbon.

Logistic regression · learning curve

High bias

8 sizes · 400 to 3,200 samples · 5 folds · gap 0.0037 at the largest size

training score
validation score
±1 SD across 5 folds
release target 0.8600

High bias — converged below the targetgap 0.0037 at 3,200 samples

The two curves have met — the gap of 0.0037 is inside the fold noise — and validation has stopped climbing, but it settled at 0.7358, below the release target of 0.8600. More data will not close a gap to the target; the model, the features or the target has to change.

Learning curve: R² against training-set size, 8 sizes from 400 to 3,200 training samples, 5 folds per size. Each band is the mean ± one sample standard deviation across the folds at that size. At the largest size training scores 0.7395 and validation 0.7358, a gap of 0.0037. Read: high bias — converged below the target. The release target is 0.8600, outside the plotted range. Exact values follow in the data table. Up to 16 sizes, evenly spaced by rank.
Training samples	Train R²	Validation R²	Gap	Folds
400	0.7118 ± 0.0263	0.7066 ± 0.0129	0.0051 ± 0.0211	5
800	0.7440 ± 0.0071	0.7292 ± 0.0159	0.0148 ± 0.0180	5
1,200	0.7547 ± 0.0076	0.7423 ± 0.0114	0.0124 ± 0.0052	5
1,600	0.7406 ± 0.0104	0.7351 ± 0.0084	0.0055 ± 0.0176	5
2,000	0.7508 ± 0.0094	0.7454 ± 0.0138	0.0054 ± 0.0177	5
2,400	0.7426 ± 0.0110	0.7367 ± 0.0112	0.0059 ± 0.0136	5
2,800	0.7452 ± 0.0100	0.7459 ± 0.0072	-0.0006 ± 0.0142	5
3,200	0.7395 ± 0.0076	0.7358 ± 0.0096	0.0037 ± 0.0123	5

status="loading" — a flat top line, a rising lower one and a narrowing band, so the skeleton is the shape of the thing being loaded

Gradient boosting · learning curve

Training and validation R² against training-set size, each with a ±1 SD band across folds

status="empty" — no sweep yet, worded so it cannot be read as a failed fetch

Gradient boosting · learning curve

Training and validation R² against training-set size, each with a ±1 SD band across folds

No sweep to plot yet

A learning curve needs at least two training-set sizes, each scored on every fold — one size is a score, not a curve, and a single number cannot say whether the gap between training and validation is closing.

status="error" — Try again is wired to a real onRetry and flips the card to ready

Gradient boosting · learning curve

Training and validation R² against training-set size, each with a ±1 SD band across folds

Couldn't load this learning curve

The data source didn't respond.

Loading preview…

"use client"

import * as React from "react"

import { cn } from "@/lib/utils"
import type {
  ChartLearningCurveData,
  ChartLearningCurvePoint,
  ChartLearningCurveTarget,
} from "./chart-learning-curve.contract"

export interface ChartLearningCurveProps
  extends Omit<React.HTMLAttributes<HTMLDivElement>, "title">,
    ChartLearningCurveData {

Installation

npx shadcn@latest add https://ui.zyeon.ai/r/chart-learning-curve.json

Prompt

Build a React + TypeScript + Tailwind "ChartLearningCurve" model-diagnostics card
in plain SVG with zod. Not recharts: the bands are computed from raw per-fold
scores rather than sent as bounds, the gap has to be measured fold-wise against
its own standard error, and the annotation at the converged end is a bracket
between two curves — none of which is an annotation API.

Contract
- One zod schema is the source of truth:
  { status: "loading" | "empty" | "error" | "ready"; title: string;
    metric: string;
    points: { trainSize: number > 0;
              trainScores: number[];    // one per CV fold
              valScores: number[] }[];  // same folds, aligned by index
    target?: { value: number; label?: string } }.
- trainScores[j] and valScores[j] are THE SAME fold j — one model, scored on the
  split it was fitted on and on the part held out from it. State it in the
  schema doc and refine that the two arrays have equal length: the pairing is
  what makes SD(gap) computable rather than guessed.
- Nothing assumes 0..1 and nothing is clamped: a negative R² on a tiny training
  set is a real reading, and validation above training is what heavy
  regularisation looks like.
- superRefine: ready needs >= 2 points ("one size is a score, not a curve");
  each point needs >= 1 fold on both sides when ready; trainSize unique (two
  fold sets at one size are a contradiction, and their mean is a number nobody
  measured). Guard every access so a ragged payload yields an issue, not a
  TypeError.
- Props = z.infer plus height (default 250, clamped 160..480), onRetry,
  className and the div's native props; forwardRef to the card.
- Export the maths next to the component so a test can print the numbers the
  picture is made of: mean(), sampleSd(), summariseStop(),
  buildLearningCurveModel(), readLearningCurve(), axisStep(), nearestStop().

Maths (state the formulas in comments; they are the component, not decoration)
- Per size, per side: mean = Σx / K, and the band half-height is the SAMPLE
  standard deviation SD = sqrt( Σ(xᵢ − x̄)² / (K − 1) ). K − 1 because the folds
  are a sample of the splits that could have been drawn. K = 1 gives SD 0 and
  the card names the fold count, so a zero-width band is never read as
  certainty. (numpy's std is ddof=0; × sqrt((K−1)/K) reproduces it.)
- Standard error of a mean: SE = SD / sqrt(K).
- Gap, FOLD-WISE where the arrays line up: gapⱼ = trainⱼ − valⱼ, gap = mean(gapⱼ),
  SD(gap) = sampleSd(gapⱼ). Its mean equals meanTrain − meanVal exactly, but its
  SD does not: an easy split flatters both sides at once, and pairing keeps that
  correlation instead of inflating the spread with it. Ragged arrays fall back
  to Var(a − b) = Var(a) + Var(b) — conservative — and the card says so.
- Non-finite folds: drop fold j from BOTH sides or neither, or fold 3's train
  score silently re-pairs with fold 4's validation score.
- THE READ, taken over the TAIL — every size from half the largest size onward,
  never fewer than two stops (the left end of any learning curve is steep and
  separated; a verdict taken there calls every model high-variance). Three
  measurements, one rule: a difference counts only when it clears 2 × the
  standard error OF THAT DIFFERENCE (SE of a difference = hypot(SE₁, SE₂)).
    gapSignificant = gap(last) > 2·SE(gap,last)
    gapClosing     = gap(tailStart) − gap(last) > 2·hypot(SE,SE)
    valStillRising = val(last) − val(tailStart) > 2·hypot(SE,SE)
    belowTarget    = val(last) + 2·SE(val,last) < target
  Verdict — a TREE, not a list, because every verdict under the first branch
  claims the curves have MET. While the gap is real the only open question is
  whether it is still narrowing, and neither answer may fall through to a
  reading that says they met:
    gapSignificant && !gapClosing → high variance     the gap is not closing
    gapSignificant && gapClosing  → still converging  real gap, still narrowing
    else valStillRising           → still learning    the sweep stopped early
    else belowTarget              → high bias         met, flat, short of target
    else                          → converged
  Print the measurements next to the verdict; the headline is a summary, not
  the evidence — and every clause in the read box has to be one the branch
  actually tested. "The flat validation tail says more rows are not buying
  much" belongs behind !valStillRising, or better, prints valGain against its
  own 2 × SE and lets the reader draw it.

Behavior
- Four first-class branches of one card: loading (skeleton with a flat top
  line, a rising lower one and a narrowing band, aria-hidden, plus an sr-only
  role=status line), empty (worded so it cannot be mistaken for a failed fetch),
  error (Try again only when onRetry was passed), ready. status "ready" with
  fewer than two usable sizes renders the empty branch.
- CLEAN, THEN DRAW: sort a copy by ascending trainSize, drop unplottable points
  and repeats of a size already placed, count both and disclose them under the
  chart. Count the sizes whose folds could not be paired separately, and name
  the assumption their gap SD then rests on.
- ANNOTATE THE CONVERGED END: a bracket at the largest size spanning the two
  means, with the signed gap beside it. Draw it toward the inside of the plot
  (right-anchored text) so it can never clip the frame, and step it away from
  the target line when the two would collide instead of trusting the halo.
- TARGET: a dashed rule with its label at the LEFT edge (the gap bracket owns
  the right). It joins the y window only when it is within one data span of the
  data; a target further out is left off the axis and marked with a caret at the
  edge it left by, because chasing it would squash every curve into a ribbon.
- SCAN: one tab stop, role="slider", snapping to measured sizes — pointer move,
  arrows, PageUp/PageDown, Home/End — reading train mean ± SD, validation
  mean ± SD and the gap at that size. It rests at the largest size, where the
  read is taken. Keyboard moves speak through an sr-only role=status line;
  pointer moves do not (a live region updated on every pointer sample is a queue
  nobody can listen through).
- CLEANUP: one ResizeObserver measuring the plot column so SVG user units are
  CSS pixels, disconnected on unmount and whenever the node changes. No timers,
  no rAF, no window listeners.

Rendering & styling
- Semantic tokens only: bg-card / text-card-foreground panel, border gridlines
  and the read box, muted skeleton, muted-foreground axis text, foreground/45
  for the target rule, foreground for the gap bracket, destructive (border /10
  fill, dark:/20) only for the high-variance chip, stroke-ring for the focus
  frame, var(--chart-1) for training and var(--chart-2) for validation. Never a
  hex, never a chart token as body text colour.
- Bands are filled AND outlined (fill ~0.22, stroke ~0.5 of the same ink):
  a fill this light survives on a light card but nearly vanishes on a dark one,
  so the ribbon's edge carries it there. Stroking the closed band path outlines
  the whole ribbon, end caps included, for one attribute.
- COLOUR IS NEVER THE ONLY CHANNEL: the training curve is dashed in the plot, in
  the legend swatch and in the skeleton; the target has its own dash pattern.
- Straight segments between measured sizes — the sweep is sampled, and a spline
  would invent a bend nobody measured — with a dot at every measured size.
- Axes: y from the BAND extremes (a band cut off at the frame understates
  exactly the uncertainty it exists to show) padded 8%; x always labels both
  domain ends and drops an interior tick that would sit within ~30px of an end
  label, so "3,000" never collides with "3,200".
- PRECISION FOLLOWS THE SCALE: tick digits come from the chosen y step, readouts
  two digits finer (clamped 2..4). An accuracy sweep lands on a 0.1 step and a
  negative-RMSE sweep on a step of 5; three fixed decimals would print noise on
  one and six gridlines all reading "0" on the other.
- ACCESSIBILITY: role="group" on the svg (never role="img" — it is
  children-presentational and would silence the slider), aria-labelledby the
  heading and aria-describedby the summary line. An sr-only WRAPPER DIV (never
  sr-only on the table itself: CSS width is only a lower bound for a table box)
  holds up to 16 rank-spaced sizes with train, validation, gap and fold count.
- Motion: the only animation is the skeleton pulse, and it carries
  motion-reduce:animate-none.

Customization levers
- The bar for a trend: SIGMA (default 2) drives all three tests at once. Raise
  it to 3 for a report that only calls out what nobody can argue with; drop it
  toward 1 for an exploratory sweep with few folds.
- Statistical size vs practical size: the read asks whether a gap is REAL, not
  whether it is BIG — folds that agree closely can make a 0.003 gap significant.
  That is deliberate (a floor in score units would have to be re-tuned for every
  metric) and the gap is printed beside the verdict, but if your audience needs
  one, add `&& gap > minGap` to gapSignificant with minGap supplied by the
  caller in the metric's own units.
- Where the read is taken: the tail starts at half the largest training size.
  Move it to the last three stops for a dense sweep, or to the whole range when
  you only ran four sizes.
- Verdict vocabulary: VERDICT_LABEL feeds the chip, VERDICT_HEADLINE the read
  box — retitle them for your audience ("needs regularisation" / "needs data")
  without touching the classifier.
- Density: height is the plot box; drop the caption paragraph, the read box or
  the legend for a dashboard tile, or raise LABELS_AT to keep the in-plot labels
  on narrower cards.
- Bands: swap ±1 SD for ±1 SE by dividing by sqrt(K) in one place — say which in
  the legend, since the two look identical and differ by a factor of sqrt(K).
- Palette: re-point TRAIN_INK / VAL_INK at the host palette, but keep the dash
  ladder — it is the channel that survives a greyscale print.
- Axis: for a sweep spanning decades (100 → 1,000,000 rows), map trainSize
  through log10 in toX and label the ticks in the same units; the bands, the
  bracket and the read are all in score units and are unaffected.
- Interaction: for a static report card drop the slider group and keep the
  bracket; for a shared cursor across a page of charts lift scanIndex into a
  controlled prop and emit onSizeChange.

Concepts

The x axis is data, not time — a learning curve re-fits the model at growing training-set sizes, so a point is "how good would this model be with n rows". That is what makes the question it answers should we buy more data, and it is why a per-epoch loss curve, which never changes n, cannot be read the same way.
The band comes from the folds, not from the payload — the component is handed raw per-fold scores and computes the mean and the Bessel-corrected sample SD itself. A wide band means the folds disagreed at that size, which is a different fact from the score moving, and it cannot be smuggled in pre-summarised.
Pairing is what makes the gap measurable — fold j's training and validation scores come from one split, so gapⱼ = trainⱼ − valⱼ has its own distribution. Its mean is exactly meanTrain − meanVal, but its SD keeps the correlation an easy split induces in both sides; treating the two curves as independent inflates the spread and quietly makes every gap look uncertain.
One rule decides every trend — a difference is only called a trend when it clears twice the standard error of that difference. The same test asks "is there a gap", "is it closing" and "is validation still climbing", so nothing on the card rests on a threshold in score units that would need re-tuning for R² versus RMSE.
The read is taken at the tail, never at the left end — every learning curve starts steep and separated. Judging there would label every model high-variance, so the verdict looks only at sizes past half the largest one, and the card says which size that is.
The verdict is a headline over printed evidence — the chip says "high variance", and next to it sit the gap, how much it moved and the noise it moved inside. A reader who disagrees with the classifier can still see the three numbers it was made from, which is the difference between a diagnosis and a decoration. That is also why the verdicts form a tree rather than a list: "converged" is only reachable once the gap is inside the fold noise, so the headline can never claim the curves met while the bracket printed beside it says they are 0.2 apart.

Gradient boosting · learning curve

Random forest · learning curve

Linear SVM · learning curve

Ridge regression · learning curve

Logistic regression · learning curve

Gradient boosting · learning curve

Gradient boosting · learning curve

Gradient boosting · learning curve

Installation

Prompt

Concepts

On This Page

Gradient boosting · learning curve

Random forest · learning curve

Linear SVM · learning curve

Ridge regression · learning curve

Logistic regression · learning curve

Gradient boosting · learning curve

Gradient boosting · learning curve

Gradient boosting · learning curve