The record as it runs: the {{ turnLabel }} and batch bars, the checkpoint monitor across the sets, the loss every optimizer minimizes, the batch loss per step, the latest evaluation values and the tail of stdout, refreshed as the record changes or on the footer's schedule; a finished record shows its last state. The stop button in the header asks the record to end after its current turn.

nothing recorded yet, the first {{ turnLabel }} is running

{{ logs.lines.slice(-14).join('\n') }}

The last {{ turnLabel }} of history.jsonl per series with its kind and the lego behind it (from resolved.yaml), the loss every optimizer minimized with the weights of its terms as the rules left them, the switches and the other effects of the rules over the {{ turnLabel }}s, the learning rates, the best {{ turnLabel }} by the checkpoint monitor, the checkpoints and the calibrations of the record.

The predictions of the test set, or of another set when the run wrote one: a target per chip, the prediction against the truth with the y = x line on a sample of 2,000 rows or on every row, the residual histogram, the distributions of the prediction and the truth over the same bins with their ratio below, and the largest errors over every row, in the original units; the calibration flags are counted on the rows drawn. The filter is a pandas query over the columns of the file, the targets, the pred_ and raw_ wires, the flags and the data.spectators columns; R², rmse, mae, the histogram and the largest errors are all computed over the rows it keeps. Expand opens a chart large with its settings: scales, line width, points, the bins of the histogram.

the query did not run: {{ predictionsData.error }}

no predictions file in the record yet

reading the predictions

the predictions have no target and prediction pair to draw

The fitted plan under fitted/preprocessors: every field with its chain and the columns it produces, and what each preprocessor learned on the train set (a scaler's mean and scale per column, an encoder's categories, an imputer's statistic), read from the pickles.

reading the fitted preprocessors

no fitted preprocessors in the record

Every file of the record with its size and time. A name opens the file here: text (the first 400 KB), images and PDFs; a weights file or a table says it is not shown. Save downloads any file as it is.

files · {{ filesData.files.length }} files, {{ fmtBytes(filesData.total) }}

name	size	modified
{{ item.name }}	{{ fmtBytes(item.size) }}	{{ ago(item.modified) }}	save

reading the files

{{ fileView.name }} first {{ fmtBytes(400000) }} of {{ fmtBytes(fileView.size) }} save close

{{ fileView.text }}

{{ fileView.text }}

The event stream of tezgah (events.jsonl): every node from its start to its end on one time axis, indented by block; a node still running is orange, a failed one red.

reading the events

no node event yet

One chart per metric, one line per set, drawn from history.jsonl once per turn; the axis says epoch when a turn is one pass over the train loader and turn when the run trains by steps. Drag to zoom, click a legend entry to hide a line, the toolbar downloads; expand opens a large view. Dashed lines mark the {{ turnLabel }}s a rule fired.

nothing to draw yet

One line of steps.jsonl per optimizer update: loss/<optimizer> is the batch loss that update stepped on (not the running mean of the turn), lr/<optimizer> its learning rate at that step, grad_norm/<optimizer> the gradient norm before clipping under grad_clip. Dashed lines mark the {{ turnLabel }}s, labelled along the top, and the tooltip names the {{ turnLabel }} of a step; a long run is drawn with at most 2000 points per line, the extremes of every bucket kept, so spikes stay visible.

no step written yet

Every report model from architecture.json, written at the end of the run, drawn as a schematic: one block per node of the config with its input pins on the left and its output pins on the right, every wire with its width, the losses and the optimizers beside the outputs. A block clicked opens in place: the layers of a node chained left to right with the tensor shapes on the wires between them, the nodes of another model with their wires, the features of the input one per line; an inner block opens the same way, a second click closes it; hover lists what a block holds. Drag a block to move it, drag the upright part of a wire to bend it elsewhere, the wheel zooms, the background pans; the arrangement is kept in this browser per record, fit and reset undo it, save writes the png as arranged, expand opens it large. The module text is the torch repr.

no architecture.json in the record; runs write it since this version

{{ moduleText === undefined ? 'reading' : moduleText }}

The data block from data.json: the source, every transform with its call and the columns it added or removed, the split, the fit on train (dashed wires from valid and test: applied, never fitted), the feeds and the loaders. A block clicked opens in place with everything it holds, the columns named one per line; a second click closes it; hover lists a few. The tables below list the calls and the columns of every stage.

no data.json in the record

The files under plots/, written when training ended or by kalfa plots: click an image for the large view, a text plot opens in a viewer, save downloads the file as it is.

The per {{ turnLabel }} sample images under samples/ written by sample_writer; play walks through the {{ turnLabel }}s, the gallery lists them all.

{{ playing ? 'pause' : 'play' }} {{ record.samples[frame] }}

{{ texts[textKey(name)] === undefined ? 'reading' : texts[textKey(name)] }}

nothing written yet

resolved.yaml, the config as the run read it: includes expanded, aliases resolved to URIs, the command line overrides annotated.

{{ record.resolved || 'no resolved.yaml' }}

The identity of the record (manifest.json, host.json, device.json, git.json), every node of the run with its time from run.json and the seconds of every {{ turnLabel }} from history.jsonl.

The last 60 events of events.jsonl, what tezgah started and finished and how long each node took; the timeline tab draws them all.

The tail of stdout.txt and stderr.txt as the run wrote them (tezgah tees both into the record): the last 300 lines, refreshed while the record runs.

{{ logs.lines.join('\n') }}

{{ record.logs.length ? 'empty so far' : 'no log file in the record' }}

kalfa describe over the record: the same analysis the command prints, read from resolved.yaml under the contract the run was compiled by, computed when the tab opens.

{{ describeText }}