Character recognition: build your own library

Upload one or more .zips of individual character images plus a manifest.json that labels each image and gives its baseline. Most samples train; the last few per character measure accuracy. Height is meaningful — measured from the baseline up (descenders below the baseline don't add to it). Select several zips at once, or add more later — they combine into one training set (a same-named zip replaces its earlier version). This builds a photo-input character library. See the format doc.

manifest.json: { "version":1, "xHeight":52, "characters":[ {"file":"a1.png","char":"a","baselineY":140}, … ] } — xHeight optional (auto-derived from x-height letters if omitted); add "split":"test" to force a sample into the test set.

A second recognizer that scores the white space, not the ink: for every background pixel it measures the distance to the nearest dark pixel and, casting rays, how far each travels before hitting ink (an angular arm signature that separates * / x / +), binned into a per-cell spatial-grid histogram and matched by chi-square. Its per-class probabilities are then blended with the main dark-pixel matcher in log-probability space — (1−blend)·log Pdark + blend·log Pwhite. Loads the same character zips above; run once, then slide blend d↔w to remix the two instantly and find the best mix. A standalone experiment (not part of the downloaded library).

Runs many training passes over the same character zips above: each time a different drawn variant of a character is held out of the bank and recognized against the rest, repeated until every variant has been the held-out one exactly once. Reports the overall accuracy and, for each variant, its result — the confidence when the correct character ranks #1, otherwise the top-3 guesses with each one's confidence. Uses the matcher's built-in self-exclusion, so one recognizer is built and reused across all hold-outs.

Which parts of a character carry the evidence that separates it from one specific confusable rival (O vs Q, P vs R)? Pick a good letter and a bad (rival) letter. For every variant of the good letter, its most similar other good variant and most similar bad variant are found (production matcher score, baseline-anchored frame: height above the baseline + distance from the left edge). Then each point is colored by comparing its best point-match into each: dark blue = matches the good template well and the bad one poorly (evidence for the good letter); dark red = the reverse (evidence for the rival); white = matches both or neither (uninformative). Continuous in between. A consistent blue region across variants = exploitable signal for a pair-specific discriminator.

Defaults are the swept optima — change only if you know why. Applies to stroke matching; photo matching uses its own tuned set.

The sentence product orders words with a word-level trigram language model (the ~1 MB sentlm.bin). By default it ships a built-in literary model. Generate your own from a corpus — one sentence per line (or split on . ! ?). The model's vocabulary becomes the default word list when yours is empty. Edit the sentences and regenerate to change the trigrams.

Experimental. Photo recognition of whole words is materially rougher than drawn input — a photo has no pen strokes, so ink is skeletonized into pseudo-strokes. Upload one or more .zips of word photos + a manifest.json giving each image's correct word. Each word is auto-added to your list. Most samples measure accuracy; a held-out slice validates the auto-tuned parameters. Baseline is optional.

manifest.json: { "version":1, "words":[ {"file":"w1.png","word":"cat","baselineY":140}, … ] } — add "split":"test" to force a sample into the held-out set.

Upload a .zip of word photos (the same manifest.json of {file, word, baselineY}). For each image the recognizer skeletonizes the ink and splits it into characters using the known correct word from the manifest — the same known-word segmentation the library uses to draw letter boxes. Each attempt is shown with its strokes colored per letter, so you can see where the current bank puts the letter boundaries in your handwriting.

per-pixel refine (EM) — instead of assigning whole strokes, assign every dark pixel of the original image to a letter from its shape-context posterior + a left-to-right position prior (the charlab lineage). Each letter's assigned pixels are then recognized in isolation to score the split — reported as a per-letter accuracy alongside the stroke-DP split on the same yardstick.

A cheap first pass before the harder splitters: cut each word photo into its connected ink blobs and recognize each blob with the character (wasm) recognizer — the strong, calibrated one, not the word bank. Every blob that a trained character matches at or above your threshold is a free, reliable letter; the rest go to the splitters. Needs character training (the glyph set you trained on) for the templates + calibrated confidence.

Saved sets and zips accumulate — combine several to cover the full alphabet. Only photo-trained (image-input) character sets can be used.