| title | Errors Index | |||||||
|---|---|---|---|---|---|---|---|---|
| one_liner | Refusals keyed by their message, each with its cause and the page that fixes it; and the route to the symptom index when nothing was refused. | |||||||
| tags |
|
|||||||
| related |
|
|||||||
| sources |
|
Up: docs/index.md — all sections.
Find the message you saw. If the run finished, nothing was refused and the numbers look wrong, use symptom-index.md instead.
A refusal prints as nnspec: <where>: <what>; find <what>'s first clause below, and see plan-lifecycle.md for which stage each <where> comes from.
Each row quotes a message's first clause without its <where>:. <x> stands for a name or value from your document, and … for the rest of the message.
| Message | Cause | Page |
|---|---|---|
unknown field '<f>' |
a misspelled key, or one on the wrong record | FORMAT.md |
Field required |
a required key is missing (model, steps) |
FORMAT.md |
Input should be … |
a value of none of the field's forms; a field of several forms prints one line naming every form (input: 5 should be a valid string, or a valid list) |
FORMAT.md |
unknown step kind '<k>' |
kind names no step kind |
FORMAT.md |
'<f>' is a derived field, which compile writes |
a field compile fills, set in a document: a step's at or schedule, batch_size on a forward or a generate, an entry's positions, gathered, dims, width or space, an op's space |
FORMAT.md |
a compiled plan holds no sweep |
a document that sets compiled, a field the plan derives, beside a sweep; leave compiled out |
FORMAT.md |
'reads': a step's reads and writes are one 'interventions' value |
entries go in one interventions dict; an entry with an edit writes |
interventions.md |
an entry named '<k>': a step's reads and writes are one 'interventions' value, … |
a bundle's entry named reads or writes; a bundle is one dict of entries, and an entry with an edit writes |
interventions.md |
a name has no dots |
a step named with a dot | writing-a-document.md |
'<n>' is also a dataset or a featurizer |
a step named like a dataset or a featurizer | writing-a-document.md |
unknown op '<op>' |
op names no op |
FORMAT.md |
'<x>' takes no '<arg>' |
an argument the op or the featurizer kind does not take; the message lists the ones it does | FORMAT.md |
'<op>' needs '<arg>' |
a required argument left out | FORMAT.md |
<arg>: <v> is not <type> |
an argument of another type (p: 'inf' is not float) |
FORMAT.md |
<arg>: <v> is not a named value or a number |
a value argument of another form | FORMAT.md |
'<arg>' is no argument a document gives: the run supplies it |
an op argument under a name the run supplies the op (dims, layers, rows, positions, eos, engine, original: nnspec/ops/__init__.py SUPPLIED), on an op step or an entry's op |
FORMAT.md |
'clamp' needs 'min' or 'max', or both; 'clamp' min <a> is greater than its max <b> |
clamp's bounds |
FORMAT.md |
against <v> is not a name |
kl's or js's against is not a named value |
ops.md |
'norm' p <p> is not finite |
an infinite p; the largest absolute value is a max of abs |
ops.md |
'norm' p <p> is not greater than 0 |
p of 0 or below |
ops.md |
there is no 'featurizer' op |
a featurizer written as an op: encode gives its coordinates, apply its version of the value |
featurizers.md |
'<op>' takes no 'featurizer' |
an op on a featurizer's coordinates goes between its encode and its decode |
featurizers.md |
'<op>' takes no 'select'; select <v>: an encode selects among a featurizer's coordinates |
only encode selects features, {"features": <selector>} |
featurizers.md |
unknown featurizer kind '<k>' |
kind names no featurizer kind |
FORMAT.md |
'k' is how many latents activation 'topk' keeps; activation 'topk' needs 'k', how many latents it keeps |
k without "activation": "topk", or topk without k |
featurizers.md |
'topk' keeps k = <k> of <n> latents |
k outside 1 to latents |
featurizers.md |
a 'jumprelu' sae's threshold is a published file's |
a drawn jumprelu sae; load one with file_path |
featurizers.md |
epochs <n>: a fit runs 0 or more epochs |
negative epochs |
fit.md |
batch_size <n>: a minibatch holds at least one row |
a fit's batch_size below 1 |
fit.md |
a sweep cannot stand on a name, and the optimizer's name is one |
a swept optimizer name; write one fit per optimizer |
fit.md |
<option> <v>; it stays <w> |
a generate option nnspec holds at one value (num_beams 2; it stays 1); the message names the option and says why |
generate.md |
| Message | Cause | Page |
|---|---|---|
unknown component '<c>' |
component names nothing nnspec addresses; nnspec describe components lists them |
sites.md |
<c> is a block's value and needs 'layers' |
a block's component without layers |
sites.md |
<c> is the model's own value and takes no layers |
layers on the model's own value (logits, lm_head_output) |
sites.md |
<c> has no axis '<a>' to select |
select names an axis the component's value lacks |
sites.md |
select key <s>: the key axis is as long as each row |
a key selector counted from the end |
sites.md |
keys relative to the query are a read's |
a key offset on a write; a write selects keys counted from the start |
sites.md |
select <a> {'offset': <k>}: an offset is relative to the query position, on an attention pattern's key axis alone |
an offset on an axis other than key |
sites.md |
offsets <o> name at least one, each once |
an empty or repeated offset list |
sites.md |
'<x>' holds <keys>, and … holds <keys>; a key relative to the query pairs with the same offsets alone |
an operand and the value it meets at different keys, one of them at offsets from the query | sites.md |
'<s>' is not a selector |
a selector outside the grammar: an int, a slice string, a list of distinct ints | FORMAT.md |
picks <p> name <i> twice |
a list of picks that repeats an index | FORMAT.md |
'<s>' picks nothing, however many things there are |
a slice empty at every size ("3:1") |
FORMAT.md |
'<s>' is a string, which is not read as a number |
a pos written as a string ("-1", "-2:"): an index is an int, and a slice goes inside an object, {"index": "-2:"} |
positions.md |
a scope is one of {'column': …}, {'text': …}, {'turn': …} |
a scope with none of the three, or two of them | positions.md |
a scope's list of columns or texts names at least one |
an empty list in a scope | positions.md |
a column's <flag> goes on its reference |
strip or lower beside a column scope; write {"column": {"column": …, "strip": true}} |
positions.md |
<v> is an object; a text is a literal, and its strip and lower go on the scope beside it |
a scope's text written as a literal object |
positions.md |
a turn's messages are located as the chat template rendered them; it takes no <flag> |
strip or lower on a turn scope |
positions.md |
turn '<r>' is a role; its messages are its occurrences |
a turn that is not a role's name; pick a message with occurrence |
positions.md |
scope turn '<r>' is a chat turn of the prompt; it takes frame 0 |
a turn scope on a decode frame |
positions.md |
index '<i>' picks none of the <n> tokens of frame '<f>''s decode calls, one each |
a frame and an index that can never meet | generate.md |
index '<i>' is <w> tokens wide and picks <k> of the <n> tokens of frame '<f>''s decode calls |
a frame and an index that can never meet | generate.md |
a sweep's values are numbers, strings, booleans or lists of them, each point keyed by its value |
a sweep over objects or lists of lists. Sweep a scalar inside: a pos's frame, index or scope occurrence; a select axis's selector. A scope's text takes no sweep: write one entry per text |
sweeps.md |
a sweep's values hold no sweep |
a sweep nested inside a sweep's values | sweeps.md |
label '<l>' sweeps <v> twice |
a sweep that lists one value twice, whose points would collapse into one key; in a fit's body, a trained featurizer's bare name beside <fit>.<name>, which there are one featurizer |
sweeps.md, featurizers.md |
a sweep cannot stand for '<field>' |
a sweep at a field that takes none; under model it ends a run loads one model: write one document per <field> |
sweeps.md |
'<x>' is not a column reference, …; a scope's column takes no sweep (its occurrence does) |
a sweep at a scope's column; write one entry per column, or sweep occurrence |
sweeps.md |
'<label>': a sweep's label is letters, digits and underscores |
a label with other characters |
sweeps.md |
label '<l>' is also the sweep at <path>, over […]; one label is one axis |
two sweeps share a label (a field's name is the default label) but not their values | sweeps.md |
| Message | Cause | Page |
|---|---|---|
'<key>': the dtype is spelled `dtype` , '<key>': where the model runs is a run option: --device, '<key>': tensor parallelism is a run option: -o tp=N, … |
a model-block key that respells key, revision or dtype, or names a run option (nnspec/plan.py OWNED lists each with its fix), refused at compile |
engines.md |
a dataset's rows come from one of 'path', inline 'rows' and a hub dataset 'hf' |
a dataset with none of the three, or several | data.md |
hf '<x>': a hub dataset is named '<owner>/<name>' |
an hf that is not <owner>/<name> |
data.md |
'hf' needs 'revision' |
a hub dataset without the commit to load | data.md |
'revision' pins a hub dataset ('hf'); 'config' is the subset of a hub dataset ('hf') |
revision or config on a file or inline rows |
data.md |
'split' is which split of a file or a hub dataset |
split on inline rows |
data.md |
take <n>: a dataset keeps at least one row; skip <n>: a dataset drops 0 rows or more from the start |
take below 1, or a negative skip |
data.md |
template: a chat renders to text, which nnspec tokenizes; it takes no 'tokenize' |
tokenize in a template |
data.md |
no file data/<path>.json under the corpus root |
data paths resolve under the nearest directory holding data/, from the document's own directory up |
running.md |
the dataset has no rows |
an empty file, or an empty split of it |
data.md |
skip <n>, and the dataset has <m> rows |
a skip that leaves no row |
data.md |
take <n>, and the dataset has <m> rows |
a take past the rows left |
data.md |
'<c>' is not a column of row <i> |
columns names a column a row lacks |
data.md |
'<c>' is a column the rows keep, which this <rename> would overwrite |
a renamed or derived column given a name the rows hold | data.md |
row <i>: '<text>' is not in its '<c>' |
a derived column's after or before absent on a row |
data.md |
row <i>: '<c>' is <type>, …; a derived column is cut from text |
a derived column whose source is not text | data.md |
'<s>' is a string; text written as it is is {'text': '<s>'} |
a derived column's after or before written as a bare string |
data.md |
<hf> (…) has splits <s>; 'split' names the one to read |
a hub dataset of several splits, none named | data.md |
<hf> (…) has no such split; its splits: … |
a split the hub dataset lacks |
data.md |
<hf> (…) at revision <r> is not in the cache, which holds it at <commit> |
offline, a revision the cache lacks |
data.md |
<hf> (…) at revision <r>: <the datasets library's message> |
the datasets library refused the load (offline, a config the cache lacks); its text can run to a second line |
data.md |
<hf>: column '<c>' holds values that are not JSON (images, audio, bytes) |
a hub dataset with an image, audio or bytes column | data.md |
data/<path>.json is not what the run read; <hf> gives other rows here than compile read |
the rows changed between compile and the run | data.md |
no dataset '<d>' |
a reference to a dataset data does not declare |
data.md |
dataset '<d>' has no column '<c>' on every row |
a column some rows lack | data.md |
column '<c>' has no entry <i> on every row |
an input index past some row's list |
data.md |
'<ref>' is not on row <i> of '<d>' |
a column reference that is not on every row | data.md |
'<x>' is not <dataset>.<column> or <dataset>.<column>[i] |
an input that names no column |
data.md |
a list input names at least one column, whose dataset its rows are |
a list input of texts alone, or an empty one |
data.md |
'<part>' is not text on row <r> of '<d>'; a list input joins text |
a list input's column that is not text on a row | data.md |
'<x>' is a column of '<d>', and the value it goes with has a row per example of '<e>' |
a list input's column, or a scope's column, from another dataset than the step's input |
data.md |
'<x>' is not <dataset>.<column> over a dataset |
a column reference (an answer, a probe's classes) whose dataset is not declared; an answer the same on every row is {"text": …} |
data.md |
'<x>' is not a column reference, '<dataset>.<column>' |
a dataset named without its column, as an answer or a scope's column |
data.md |
<v> is not a column |
a column field holding a number or another type | data.md |
<v> is not a literal's text |
a literal whose text is not a string or a list of strings |
data.md |
a literal takes no '<k>' |
a literal with a key other than text, strip and lower |
data.md |
<v> is not a boolean |
a strip or lower that is not true or false |
data.md |
'<col>' is <type> on row <i> of '<d>' |
a column read as text holds something else on a row | data.md |
no step reads a chat column of '<d>' |
template on a dataset no step reads as a chat |
data.md |
message <i> (<role>) '<content>' is not where the chat template put the messages before it |
a chat template that changes a message's text, or renders the messages out of order | data.md |
'<x>' names no value produced before this step |
a misspelled name, or its producer comes later in the document | writing-a-document.md |
'<n>' is saved twice |
a name listed twice in saves |
writing-a-document.md |
'<n>' names no step's value; a save is a step or a step's member |
saves names something no step makes |
writing-a-document.md |
'<n>' is the name of a run directory's own <n>.json |
a step saved whole named manifest or tokens |
writing-a-document.md |
no site '<s>' |
a site name sites does not declare; from featurizers.<f>.site, see featurizers.md |
interventions.md |
no intervention bundle '<b>' |
a bundle name interventions does not declare |
interventions.md |
two entries named '<k>'; a step binds each name once |
an entry name used twice across the bundles and dicts of one step's interventions |
interventions.md |
'<step>.<e>' names step '<step>''s entry '<e>', which is also this bundle's own entry |
inside a bundle, its own entries are named bare | interventions.md |
'<x>' has a row per example of '<a>' and '<y>' of '<b>'; an op takes one dataset's rows |
an op mixes values or columns of two datasets; two datasets that read the same file are two | operand-does-not-fit.md |
| Message | Cause | Page |
|---|---|---|
no run at <out> under the corpus root (no manifest.json) |
the load's from holds no run |
cached-harvest.md |
<out> ran another model than this document's |
the run's model block differs from this document's, a loader key included |
cached-harvest.md |
<out> saved no '<n>' |
a value the run did not save |
cached-harvest.md |
<out>/<file> is missing, which its manifest says holds '<n>' |
a saved file gone from the run directory | cached-harvest.md |
<out>/manifest.json is not a run this nnspec reads |
a manifest that does not parse as a run | cached-harvest.md |
<out>/manifest.json: a saved value's record holds no 'axes'; <out>/manifest.json: fit '<f>' has an 'eval' and no 'evals' |
the manifest's records lack a field a load reads; rerun the document that wrote it | cached-harvest.md |
'<n>' was made over the rows of dataset '<d>', which this document does not declare |
the loading document gives the dataset another name, or none; declare it under the run's name | cached-harvest.md |
'<n>' was made over the rows of dataset '<d>', and this document's '<d>' is not the rows <out> read, in their order |
other rows: it ends <m> rows where it read <n> after another take or skip, or as many rows, whose digest differs |
cached-harvest.md |
'<n>' was made over the rows of dataset '<d>', whose chats <out> rendered with template <t> |
the dataset's template differs from the run's |
cached-harvest.md |
'<n>' is swept over '<l>', […] in <out>, and this document sweeps '<l>' over […] |
this document sweeps a label the value depends on over other values | cached-harvest.md |
'<n>' is a bundle, which a featurizer of its kind loads, with 'file_path' |
a pca's value or a trained featurizer named in a load |
cached-harvest.md |
'<n>' is in the coordinates of '<f>' |
a value inside a featurizer's encode; load the value it encodes, and encode it here | cached-harvest.md |
'<n>' is a tensor of <out>'s featurizer '<f>', as drawn or loaded there; '<n>' is a tensor of '<f>', which <out>'s fit trained |
a featurizer's tensor named in a load; declare the featurizer here, or load the trained one's bundle with file_path, and name its tensor |
featurizers.md |
'<n>' is a generation's value or holds its positions |
a generation's ids, or a read at its decode calls | cached-harvest.md |
'<l>' loads '<x>.tokens', a top_k's tokens |
an op over a loaded top_k member that is text; save <x>.ids in the run that made it and load that |
ops.md |
'<l>' loads '<x>.ids', a top_k's ids over a list of axes |
an op over a loaded ids of a top_k over a list of axes, one tensor per axis; save the axis's (<x>.ids.rows) and load that |
ops.md |
a fit's body holds no load |
a load inside a fit; load before the fit |
cached-harvest.md |
| Message | Cause | Page |
|---|---|---|
frame <f>: a forward makes one call, the prefill |
a decode frame on a forward step |
generate.md |
the input <i> is text, not a chat: a turn scope names a chat's messages |
turn on a text input |
positions.md |
<c>'s key axis grows with every decode call; read it in the prefill |
an attention pattern or scores beyond frame 0 | generate.md |
a write beyond the prefill lands as its call runs, before the token it would predict is chosen |
before on a write in decode calls |
generate.md |
a write's positions beyond the prefill are decided call by call |
until on a write in decode calls |
positions.md |
frame '<f>' holds the prompt, and until with before starts before the frame's first token |
until with before over a frame that holds the prompt |
positions.md |
frame '<f>': a scoped write beyond the prefill is found call by call in the generated inputs |
a scoped write whose frame holds the prompt or counts from the row's last call; give decode calls ("1:") |
generate.md |
index '<i>': a scoped write lands at the call fed its text's last token |
a scoped write in decode calls at an index other than -1 | generate.md |
occurrence <o> counts from the last occurrence, which is known only when the row ends |
a scoped write in decode calls at an occurrence counted from the end | generate.md |
frame '<f>' with index <i> counts back from the row's last position |
a write over the prompt and every decode call at an index counted from the end; write two entries | generate.md |
frame '<f>' with index <i>: over a frame that holds the prompt a write's index is ':' |
a write over a frame holding the prompt at an index other than ":" |
generate.md |
frame '<f>' with index <i> names calls up to the row's last |
a write over every decode call in a step without max_new_tokens |
generate.md |
frame '<f>' with index <i> names calls that depend on how far each row gets |
a write whose frame counts from the row's last call, or whose index counts from the end over several decode calls | generate.md |
row <i>: text '<t>' is not in its input |
a text scope a row does not hold, on word boundaries |
position-not-in-row.md |
row <i>: column '<c>' ('<v>') is not in its input |
a column scope whose value a row does not hold |
position-not-in-row.md |
row <i>: … occurs <n> times in the row's input; it has no occurrence <o> |
an occurrence past the row's count |
position-not-in-row.md |
row <i>: index <idx> does not fit the row's <n> positions at this frame; row <i>: index <idx> does not fit the row's <n> scope tokens |
a static index wider than a row, or than its scope | position-not-in-row.md |
row <i>: the write's positions hold no token of this row |
a write at an open-ended index past a short row | position-not-in-row.md |
row <i>: … begins the row, at position 0, which no position comes before |
before on a scope at a row's first token |
position-not-in-row.md |
row <i>: the row has no '<role>' message |
a turn scope a row's chat does not hold |
position-not-in-row.md |
this tokenizer has no offset mapping, which a scope in the prompt needs |
a prompt scope on a tokenizer without offsets (a slow tokenizer) | positions.md |
| Message | Cause | Page |
|---|---|---|
layer <n>; the model has <m> layers |
a layer outside the model | sites.md |
layers '<s>' pick none of the model's <m> layers |
a layers selector that keeps no layer |
sites.md |
select <axis> <s> outside the model's <n> |
a select past the model's size |
sites.md |
select <axis> '<s>' keeps none of the model's <n> |
a select that keeps nothing at the model's size |
sites.md |
select key <k> outside the <n> tokens of the input's shortest row |
a key past the shortest row |
sites.md |
select <axis>: picks <p> count one of these <n> twice |
two picks that name one index once counted (-1 and 3 of 4) |
sites.md |
the nnterp engine does not serve <c>: read inside the eager attention forward, but this model runs 'sdpa' |
the attention interior needs eager attention | sites.md |
the hooks engine does not serve <c>: nnterp reads it inside a module's forward |
hooks reaches module boundaries only | engines.md |
the hooks engine does not serve <c>: nnterp reads it among a module's call arguments |
hooks reaches a module's first input and its output only | engines.md |
<c> layer <l>: the hooks engine's two-token forward at load did not reach its module |
a module the hooks engine's load-time forward never runs | engines.md |
the <engine> engine does not serve <c>: block <i>'s MLP is a mixture of experts |
a dense MLP's value (mlp_activation, mlp_neurons) on a mixture-of-experts block; the message lists what that block serves |
sites.md |
the <engine> engine does not serve <c>: no block of this model has a mixture of experts |
a mixture's value on a dense model | sites.md |
the <engine> engine does not serve <c>: no <c> value on this block's mlp |
a mixture's value at a dense block of a model with mixtures elsewhere | sites.md |
the <engine> engine does not serve shared_expert_output: this mixture has no shared expert |
shared_expert_output on a mixture without one |
sites.md |
the <engine> engine does not serve <c>: nnterp has no family for this architecture |
a mixture on a checkpoint nnterp reads under its default family, which names none of a mixture's values | sites.md |
'<edit>' would compute on expert_indices, the ids the model indexes its num_experts with, as numbers |
an edit other than swap at expert_indices (at compile) |
expert-ablation.md |
swap with <v>: expert_indices holds ids |
a constant that is no expert's id | expert-ablation.md |
writes <v> into expert_indices at row <r>, token <t> |
a named value's entry that is no id, as the write lands; a hole (writes a hole, -1) is a -1 in the operand: a step's value that holds one, or a position past a row's own. A generation's read on a row that stopped before its call is refused before the forward instead (operand '<x>' holds no value on row <r>) |
expert-ablation.md |
the <engine> engine does not serve <c>: no self_attn module on this block |
a block without the component's module (the linear-attention blocks of a hybrid), refused layer by layer | sites.md |
the nnterp engine does not serve <c>: under tp <n> … |
a value the ranks hold in pieces under tensor parallelism: it is computed inside <module>, or <module> is a vocab-parallel embedding |
engines.md |
grad's of '<x>' is read at <c> layer <l>, which the <engine> engine's forward reaches no later than this entry's |
of is made before, or at, the gradient's own site; name a later entry, such as one at the head |
interventions.md |
the nnterp engine takes no gradient under tp <n> |
grad under tensor parallelism; run it at tp 1 |
engines.md |
the checkpoint's chat template calls strftime_now, which writes today's date into the prompt |
a chat template that reads the clock; pin the date in data.<d>.template, {"date_string": …} |
data.md |
nnterp's support() does not name <name>, so nothing says whether it serves <component> |
a component added to address.COMPONENTS under a name nnterp's support() does not list; every document is refused |
extending.md |
| Message | Cause | Page |
|---|---|---|
'<edit>' is an edit, which writes back, and it follows '<op>' |
an edit after a transform, metric or reduction in one entry | interventions.md |
an entry that writes selects on one axis |
a write's site narrows two axes | interventions.md |
'<x>' is this entry or one this forward makes after it |
an operand from the write's own forward that comes later | operand-does-not-fit.md |
'<x>' is an entry of this generation |
an operand from an entry of the write's own generate step |
operand-does-not-fit.md |
'<x>' runs '<op>' once it is off the model, after this forward |
a same-forward operand with an op after its last edit | operand-does-not-fit.md |
'<x>' is an entry of this forward, and '<op>' here runs once the value is off the model |
a same-forward operand given to an op that runs after the forward; take both in an op step | operand-does-not-fit.md |
operand '<x>' is read at <c> layer <l>, which the <engine> engine's forward reaches no earlier than this write's |
a same-forward operand at a site the forward reaches later | operand-does-not-fit.md |
operand '<x>' holds no position on row <r> |
a same-forward operand at an index a short row does not reach | operand-does-not-fit.md |
operand '<x>' holds <n> position(s) on row <r> and this write <m> |
a same-forward operand whose width differs from the write's on a row | operand-does-not-fit.md |
'<x>' is laid out […]; '<op>' acts on a value laid out […] |
an operand with an axis the value lacks; a featurizer's tensor, or a value made of one, on the last axis of the site the featurizer is first used at, which the message names (… lies on <a>, the last axis of <c>, where a step first uses '<f>') |
operand-does-not-fit.md |
'<x>' has no width compile can fix (…), and two values of different reads pair only at a fixed width |
at compile: a side whose pos leaves its width open where no row settles it (an until scope, several occurrences, an open index beyond the prefill: which forms), or a permute of one, against a value of another read, of the same forward in an op step or of another forward |
operand-does-not-fit.md |
operand '<x>' holds <n> positions on rows … and <m> positions on row <r>; two values of different reads pair only at a fixed width, whether one forward or two made them, which an open index has where every row holds as many positions |
in preflight: an open index in the prefill ({"index": ":"}) on prompts of different lengths, of one forward or two, or a permute of one (operand '<x>' reorders the rows of '<read>', which holds …; a load's by its step); at compile, without operand, for a loaded one; read a static span every row holds |
operand-does-not-fit.md |
operand '<x>' holds <n> position(s) on rows … and <m> positions on row <r>; two values of different reads pair only at a fixed width, whether one forward or two made them, which a scoped read has where every row's scope holds the same number of tokens |
a scope's rows hold different numbers of tokens, or a permute of such a scope (operand '<x>' reorders the rows of '<read>', which holds …); at compile, without operand, for a loaded read's scope |
operand-does-not-fit.md |
operand '<x>' meets the value '<op>' acts on, which holds … |
the write's own scope or open index holds different numbers of tokens by row | operand-does-not-fit.md |
'<x>' holds <n> position(s) per row and the value '<op>' … holds <m> |
two static widths that differ | operand-does-not-fit.md |
'<x>' has a pos axis, and this write lands beyond the prefill |
a per-position operand for a write over decode calls | operand-does-not-fit.md |
'<x>' is read at decode call <k>, and '<g>' makes calls 0 to <m-1> (max_new_tokens <m>) |
at compile: a write's operand read at a fixed decode call at or past its generation's max_new_tokens, which no row makes |
alignment-missing.md |
operand '<x>' holds no value on row <r> (alignment_missing); operand '<y>', which descends from '<x>', holds no value on row <r> |
in the run: a write whose operand is an earlier generation's read, or an op step's value made from one, on a row whose generation never made the call the read names | alignment-missing.md |
'<x>' is in the site's own layout; this bracket is in the coordinates of '<f>' |
an operand inside an encode bracket, not encoded |
operand-does-not-fit.md |
'<x>' holds num_heads […], and this write's selection holds […] |
an operand's selected indices against the write's; along an axis no site selects (classes, features), indices two select steps kept, which a reduction over the axis lets meet (… or reduce each over <a> first) |
operand-does-not-fit.md |
'<x>' holds layers […], and this op acts at layers […] |
an operand without a slice for every layer the op acts at | operand-does-not-fit.md |
'<x>' has a layers axis, and this op acts at no layer |
an operand with layers for a value at no layer |
operand-does-not-fit.md |
operand '<x>' was read on <input>, row <r> of which is <n> tokens |
an unscoped operand on another input of another length | operand-does-not-fit.md |
grad is taken in a forward, not a generate |
grad in a generate step |
interventions.md |
grad inside a fit's body is not served |
grad in a fit's body |
interventions.md |
grad is no step |
grad written as an op step |
interventions.md |
grad is ops[<i>] here, and it is the first op of its entry |
grad after another op |
interventions.md |
grad follows '<edit>', an edit, and an entry that takes a gradient writes nothing |
an edit before grad; write in an entry of its own listed before it at the site |
interventions.md |
'renormalize' restores the value the site had before its writes, and after grad |
renormalize after grad |
interventions.md |
decode closes an encode whose edits write back, and after grad nothing writes back |
an encode bracket after grad |
interventions.md |
'<x>' names no entry of this forward; grad's of is an entry of its own forward, by its bare name |
of names an entry elsewhere, or with its step's name ("metric", not "patched.metric") |
interventions.md |
'<x>' is a grad entry, whose value is a gradient the forward never computes |
of names another grad entry |
interventions.md |
'<x>' runs '<op>', which gives <what>, and no gradient passes through it |
of names an entry whose ops end in an op no gradient passes through; the message names it |
interventions.md |
readout projects a residual-stream value; <c> is not one |
readout on a component that is not a stream |
ops.md |
readout projects the whole residual stream through the model's final norm and head, and <x> keeps … |
readout after a select on hidden_size |
ops.md |
'<op>' over 'layers': inside an entry an op acts at each layer |
a reduction over layers in an entry; make it a step |
ops.md |
'<op>' aggregates over rows, and inside an entry it sees one batch |
a reduction over rows in an entry; make it a step | ops.md |
'<op>' restores the value a site had before its writes; it runs only inside an entry |
renormalize as a step |
ops.md |
a top_k over a list of axes gives an index per axis of each pick, which an entry's batches do not join |
a top_k over several axes in an entry; make it a step |
ops.md |
a reduction cannot remove '<a>' |
over names an axis the value lacks |
ops.md |
a reduction of a value laid out […] removes no axis of it |
over names none of the value's axes |
ops.md |
'<op>' needs a value with a '<a>' axis |
an op whose axis the value lacks | ops.md |
it reduces over hidden_size unless 'over' names the axes |
norm or dot on a value without hidden_size |
ops.md |
it takes the softmax over vocab_size or num_experts unless 'over' names the axes |
entropy on a value with neither axis |
ops.md |
count counts along 'pos' unless 'over' names the axes it counts along |
count on a value without pos |
ops.md |
it ranks the value's '<a>' axis, and the value is laid out […] |
top_k or argmax on a value without its default axis |
ops.md |
over […]: a list of axes names each axis it ranks once |
top_k or argmax over an axis twice |
ops.md |
'<x>' is a top_k's value, several tensors |
an op over a whole top_k value (an op step's, a load's, an entry's whose last op is top_k), or an operand naming one; name a member (<x>.ids, <x>.probs), or make an entry's top_k a step after the forward |
ops.md |
'<op>' follows top_k, whose value is several tensors |
an op after a top_k in its entry; make the top_k a step after the forward and the op a step over its member |
ops.md |
'<x>.ids' is a top_k's ids over a list of axes, one tensor per axis it ranks |
an op over the ids of a top_k over a list of axes; name the axis's, <x>.ids.rows |
ops.md |
'<x>.tokens' is a top_k's tokens, its picks' token strings, which are text |
an op over a top_k's tokens; name its ids, <x>.ids |
ops.md |
k <k>: a top_k picks at least one entry |
a top_k whose k is 0 or below |
ops.md |
select <v>: {<axis>: <selector>}, one or more axes of the value |
select's select is not a dict of axes and selectors |
ops.md |
select '<a>': a select step narrows a value's other axes; select 'layers': … (compile) |
select of rows, pos or key, which the dataset and the read narrow, or of a read's layers, which its site picks (a featurizer's tensor over layers selects them) |
ops.md |
select narrows the value's '<a>' axis, and the value is laid out […] |
select of an axis the value does not have |
ops.md |
select <a> <s> outside the <n> along <a> (…); select <a> <s> keeps none of the <n> along <a> (…) |
a select step's pick past an axis, or a slice that keeps none of it: at compile where the document fixes the number (the probe's, the sae's, the fit's epochs; at most, a bound: max_new_tokens, the epochs of a fit with early_stop), in preflight for the model's sizes (the model's), at the run for a history early_stop ended sooner or a generation whose rows stopped early (the value's, naming the step) |
ops.md |
inside an entry the value is its site's selection, which the site's own select narrows |
select in an entry's ops; narrow the site, or select in a step after the forward |
ops.md |
k <k> is more than the <n> entries it ranks |
a k past the entries of an axis whose size is known: at compile where the document fixes it (a select, a static width, the dataset's rows, a probe's classes, a featurizer's coordinates, an earlier top_k's k), in preflight where the model's sizes or the rows do |
ops.md |
contains reads text, a detokenize's value (without tokens) |
contains on something other than detokenized text |
generation-experiments.md |
after keeps each row's text after an occurrence, and with tokens a row is its token strings |
detokenize with both tokens and after |
generation-experiments.md |
permute is no op of an entry |
permute in an entry; it is an op step over a read |
ablation.md |
'<x>' is a top_k's value, which permute does not reorder |
permute of a top_k's or a detokenize's value; permute the value it is over |
ablation.md |
'<x>' holds other rows' values (a permute's), so no one read's site says what it is |
a pca of a permuted value; take the read before it is permuted |
ablation.md |
'permute' with seed null is the identity, which moves no row |
derangement with seed: null |
ablation.md |
a derangement moves every row to another, and … |
a derangement over one row: a one-row dataset, or a fit's minibatch of one row | ablation.md |
seed <s> draws the identity over a minibatch of <n> row(s), which moves no row |
a permute without derangement in a fit's body whose seed draws the identity over a training minibatch's rows: seed 0 over two, any seed over one |
ablation.md |
the value '<op>' scores keeps <n> of its vocab_size (select) |
a metric over a head narrowed on vocab_size; score the whole head, or rank within the selection with argmax or top_k |
ops.md |
<column> row <r>: '<v>' is <k> tokens; the read has <n> position(s) on that row |
an answer of several tokens against a read of other positions. At pos: -1, teacher-force it: append it to the input and read before its scope with "occurrence": -1 (teacher forcing). At a generated word, the model said one id that the column retokenizes into more (its own text) |
answer-does-not-line-up.md |
<column> row <r>: '<v>' is <k> tokens, a position each, and the value has no pos axis; an answer of several tokens scores a position each, and the value has no pos axis |
an answer of several tokens against a value reduced over pos |
answer-does-not-line-up.md |
<column> row <r>: <v> stands for <n> ids (a set, or a class under strip or lower) |
a set or a class where the metric reads one id's logit | answer-does-not-line-up.md |
<column> row <r>: its members are … tokens; a set's members are one width |
a set whose members tokenize to different lengths | answer-does-not-line-up.md |
<column> row <r>: '<v>' is no tokens once strip drops the whitespace-only tokens at its end |
an answer of whitespace alone under strip |
answer-does-not-line-up.md |
<column> row <r>: position <p> predicts '<t>' in the input, which is not token <i> of '<v>' |
a teacher-forced input that says the answer with other tokens | answer-does-not-line-up.md |
| Message | Cause | Page |
|---|---|---|
'<x>' is a featurizer, not a value |
a featurizer named where a value goes; reach it with an op (encode, apply) |
featurizers.md |
'<x>' names no tensor of '<f>', a <kind>, whose tensors are … |
<featurizer>.<tensor> or <fit>.<featurizer>.<tensor> with a name the kind does not hold |
featurizers.md |
'<x>' is a tensor of '<f>', laid out on the last axis of the site it is used at, and no step before this one encodes or applies '<f>' at a site |
a featurizer's tensor named before any step uses the featurizer (in a save or an init: no step at all) |
featurizers.md |
'<x>' is laid out […], two of its axes under one name, which no op tells apart |
an affine's W, or a basis inside another's coordinates; save the fit's featurizer whole |
featurizers.md |
'<x>' is a tensor of '<f>', which this fit trains |
the fit's body names a tensor of what it trains; name it in a step after the fit | fit.md |
'<x>' is a tensor of '<f>', which is itself drawn from a value |
a constant's init naming a tensor of a featurizer drawn from a value |
featurizers.md |
'<x>' names no featurizer here |
a featurizer name featurizers does not declare |
featurizers.md |
'<f>' is a '<kind>' featurizer, which has no <op> |
an op the featurizer's kind does not serve, a point of a sweep over featurizers included (the path names it); the message lists the ones it does | featurizers.md |
a <kind>'s apply takes no 'with' |
with on an apply of a kind that is not an adapter or a gate |
featurizers.md |
<v> is not a name; 'with' names a value read at the positions the op acts on |
an adapter's with that is not a value's name |
lora.md |
decode of '<f>' closes no encode |
a decode with no open encode of it |
featurizers.md |
decode of '<f>', and the open encode is of '<g>' |
brackets closed out of order, or a decode that does not carry its swept encode's sweep (one name, or another label), at the point the path names |
featurizers.md |
the entry writes back here with the encode of '<f>' (ops[<j>]) still open |
an entry that ends inside a bracket | featurizers.md |
'<op>' of '<f>' at ops[<i>] is inside the encode of '<f>' |
the featurizer's own op inside its bracket | featurizers.md |
decode closes an encode of its own entry, so it runs inside the entry that encodes |
decode as a step |
featurizers.md |
a '<kind>' featurizer drawn without a bundle needs '<f>' |
a drawn featurizer missing a field; or load one with file_path |
featurizers.md |
a <kind> loaded from file_path is its bundle's, and <field> draws one |
a loaded featurizer with a field that draws (a constant's init) |
featurizers.md |
site '<s>' is {…}; the site a featurizer was trained at is a component at one layer |
a featurizer's site with several layers or none |
featurizers.md |
<c>'s last axis is <axis>, which grows with the input; featurizer '<f>' needs a feature axis |
a featurizer at an attention pattern or its scores | featurizers.md |
'<x>' is laid out […], …, and a constant's init is one vector of its width |
an init with a rows or layers axis, or more than the site's last axis; at a site of several heads, one vector serves every head; along an axis no site selects (probe.W's classes), take one, a select summed over it |
ablation.md |
'<x>' is in another coordinate space than <entry>'s value |
an init in another featurizer's coordinates |
ablation.md |
'<x>' depends on the sweep axes […] |
an init that varies over a sweep |
ablation.md |
'<x>' is made by step '<s>', …, and '<f>' is drawn from it |
an init made after the featurizer's first use |
ablation.md |
'<x>' names no value a step makes |
an init no step makes |
ablation.md |
featurizer '<f>' is drawn from '<x>' (init), which keeps … |
before any forward: init's selection against the use's |
ablation.md |
<file> is a published sae, which says neither how it encodes nor where it was trained |
a published SAE without its stated fields | featurizers.md |
<file> has no nnspec header and holds …; a published sae holds … |
a file without an SAE's tensors | featurizers.md |
<file>: W_enc is […]; it is [width, latents]; <file>: W_dec is […]; with W_enc […] it is […] |
a published SAE's tensor shapes | featurizers.md |
<file> has <n> latents; this document says <m>; <file> has <n> latents; 'topk' keeps k = <k> of them |
latents or k against the file |
featurizers.md |
<file> holds no threshold; a 'jumprelu' sae needs one; <file> holds a JumpReLU threshold; its activation is 'jumprelu', not '<a>' |
activation against the file's threshold |
featurizers.md |
<file> does not exist under the corpus root |
a file_path with no file; a bundle beside a document with no data/ above it, whose root is the directory above; from nnspec show or nnspec table, a relative path read from outside the run's corpus root |
bundles.md |
<file> is not a safetensors file |
a file_path in another format; convert it first |
bundles.md |
<file> holds one bundle per point of a sweep (…) |
a swept training run's file | bundles.md |
<file> carries nnspec header keys (…) but its format is … |
a file with some of nnspec's header keys and another format | bundles.md |
<file> holds …; a <kind> bundle holds … |
a bundle of another kind's tensors | bundles.md |
<file> has no nnspec header; a <kind> bundle is one nnspec wrote |
a kind that loads only nnspec's bundles, given another file | bundles.md |
<file>: header '<key>' is '<v>'; this document expects '<w>' |
the bundle's header against the document | bundles.md |
<file>: header 'layer' is '<l>'; this document uses '<f>' at <c> layer <m> |
a bundle used at another layer | bundles.md |
<file>: header 'select' is '{…}'; this document uses '<f>' at <c> layer <m>, whose selection keeps … |
a bundle used at another selection | bundles.md |
<file>: header has no 'select' |
a bundle made at the whole component, used at a selection | bundles.md |
<file>: header 'width' is '<w>'; this document uses '<f>' at <c>, whose width is <v> |
a bundle used at another width | bundles.md |
<file>: header records no '<field>', which a <kind> bundle records |
a hand-made nnspec header without its width or a field its kind's draw needs (a subspace's or a pca's k, an sae's latents, a lora's rank and alpha, a probe's classes) |
bundles.md |
<file>: '<t>' is […], and its header lays a <kind> out at width <w> |
a bundle tensor whose shape is not a draw's from its header (a subspace's basis [width, k], a lora's B [rank, width], a gate's theta [width]) |
bundles.md |
featurizer '<f>' is used at width <a> here and <b> elsewhere |
one featurizer used at two widths; at a point of a sweep over featurizers, that point's featurizer, which the path names | featurizers.md |
featurizer '<f>' has <field> <n>, and it is used at width <w> |
a rank or k larger than the width allows |
featurizers.md |
<file> has no nnspec header and is <w> wide |
a headerless file of another width | featurizers.md |
featurizer '<f>' was trained at <c> layer <l> (its site); this use is … |
a featurizer used at another site than its site |
featurizers.md |
select features '<s>' keeps none of the <n> features of '<f>' |
a features selector past the featurizer's coordinates |
featurizers.md |
over: […] names no axis |
a gate's over that is empty or repeats an axis |
featurizers.md |
over: […] names <a>, an example's |
a gate over rows or pos |
featurizers.md |
<use> encodes '<f>', and a gate over axes serves apply alone |
an encode of a gate over axes |
featurizers.md |
<use> applies '<f>' inside the encode of '<g>' |
a gate over axes applied inside another featurizer's bracket | featurizers.md |
'<f>' is at <c> layer <l>, one layer, whose selection […] has no layers axis |
a gate over layers at a one-layer site |
featurizers.md |
<use>'s selection at <c> is laid out […], which has no '<a>' |
a gate over an axis its site lacks |
featurizers.md |
a gate's units are laid out on its axes in the selection's order, and <use>'s is […] |
over in another order than the site's layout |
featurizers.md |
<c>'s <a> axis grows with the input; gate '<f>' lays its units on axes of a fixed size |
a gate over key |
featurizers.md |
gate '<f>' is over <axes> here and … elsewhere (an affine's: affine '<f>' is over …) |
one gate or affine used at two selections of its axes | featurizers.md |
<file>: header 'kept.<a>' is '[…]'; this document uses '<f>' at <c>, whose selection keeps … |
a gate's bundle used at another selection of its axes | head-masking.md |
<file>: 'theta' is […], and its header lays a gate over […] out on … (an affine's: 'W' is […], …) |
a bundle's tensor against its header's axes | head-masking.md |
over: […]: an 'affine' is over ['layers'] or nothing |
an affine over another axis; a map is a matrix over the last axis |
featurizers.md |
<file> was trained reading its input at <c> layer <l> (with), and this use gives no 'with' |
a cross-site adapter used without with |
lora.md |
<file> was trained reading its input at <c> layer <l> (with), and this use's with '<x>' is <c> layer <m> |
with read at another site than the training run's |
lora.md |
<file>'s header records no input site (with.component) |
with on an adapter trained on its own site's value |
lora.md |
operand '<x>' is read at positions … of row <r> and this write lands at … |
a same-forward with read at other positions than the write |
lora.md |
operand '<x>' is <n> wide per position, its axes after the positions flattened; this write's value is <m> |
with read at a site of another width per position |
lora.md |
pca of <n> vectors has no rank-<k> basis |
pca's k against its data |
trained-subspaces.md |
pca k <k> counts directions of a value <w> wide |
pca's k past the value's width |
trained-subspaces.md |
classes column '<c>' holds str (…), int (…) |
a probe's classes of several types | probing.md |
<arg> names a class of probe '<p>', which is compared exactly |
strip or lower on a probe's class column |
probing.md |
<arg> is '<c>' of '<d>', whose row <i> is '<v>', not one of the classes of probe '<p>'; <arg> is the literal '<v>', not one of the classes of probe '<p>' |
an answer that is no class of the probe | probing.md |
no featurizer '<f>' |
a fit trains a featurizer featurizers does not declare |
fit.md |
'<f>' is a <kind>, which a bundle fixes |
a fit trains a kind with nothing to train | fit.md |
'<f>' is loaded from a bundle, which fixes it |
a fit trains a loaded featurizer | fit.md |
a fit's body holds no fit |
a fit inside a fit | fit.md |
'<n>' is also a dataset or a featurizer, or has a dot |
a body step's name | fit.md |
not a body op or a trained featurizer's scalar |
an objective term that is neither |
fit.md |
'<m>' is not a body op |
an early_stop metric that names no body op |
fit.md |
'<label>' names the fit's history or a featurizer it trains, or has a dot |
an eval name taken |
fit.md |
none of its terms (<t>) depends on what the fit trains (<f>) |
an objective over values no trained featurizer reaches | fit.md |
'<s>' is over the coordinates the body reads of '<f>', an encode no decode closes |
an SAE's scalar in the objective of a body with no open encode of it |
fit.md |
an sae's scalars are over what the body's encodes of it saw; this body has none |
an SAE's scalar with no encode to measure |
fit.md |
'<f>' is trained but used at no site, so its width is unknown |
a trained featurizer the body never reaches | fit.md |
'<f>' is trained but used at no site at this point |
a sweep in the body over the featurizers the fit trains: each point trains every one and uses one | featurizers.md |
dataset '<a>' is read as '<b>', and their templates differ |
an eval replaces a dataset with one of another template |
fit.md |
the body uses '<x>', made before the fit with a row per example of '<d>', which no forward of the body reads |
a harvest whose dataset no body forward reads | fit.md |
the body's datasets have {…} rows |
body datasets of different lengths; a body pairs them row by row | fit.md |
the body uses '<x>', made before the fit with a row per example of '<d>', and this eval reads '<d>' as '<e>' |
an eval that reads a harvest's dataset as another; score that split after the fit, through <fit>.<featurizer> |
fit.md |
'<x>' is an op's value, which no one site made, and a featurizer's <op> acts on a value at its site |
an encode or apply step over an op step's value; encode a read, or inside the entry that reads |
featurizers.md |
| Message | Cause | Page |
|---|---|---|
no document at '<path>' |
the document path given to nnspec run does not exist |
cli.md |
batch_size <n>: a batch holds one row or more |
a --batch-size below 1 |
running.md |
padding '<p>': one of 'dataset', 'batch', 'sorted' |
a --padding nnspec does not have |
running.md |
readout '<r>': one of 'full', 'at-reads' |
a --readout nnspec does not have |
running.md |
-o '<x>': an option is KEY=VALUE |
an -o without = |
cli.md |
-o <key>: it is given as --<flag> |
device, batch_size, padding or readout given with -o |
cli.md |
device '<d>': not a torch device ('cpu', 'cuda:0') or a device map transformers computes |
a --device torch does not know |
engines.md |
device '<d>': no CUDA device is visible |
a GPU device where none is visible, under nnterp or hooks | engines.md |
device '<d>': <n> CUDA devices visible, cuda:0 to cuda:<m> |
a GPU index past the visible ones | engines.md |
model.key '<k>' at revision '<r>': the <engine> engine cannot load it |
the loader could not load the checkpoint; offline, the revision is not in the cache |
engines.md |
model.<key>: the <engine> engine cannot honor it |
a key of OWNED in a model block given an engine directly, which no compile judged |
engines.md |
model.<key>: the <engine> engine's loader rejects it |
a model-block value the loader refuses (a bad attn_implementation) |
engines.md |
<v> is not a value generate takes |
a generate option of a type the generation config refuses | generate.md |
'<opt>' is a parameter of generate itself |
one of generate's own parameters given as an option |
generate.md |
generate rejected '<opt>' |
the model's generate refused an option the step passed |
generate.md |
generate rejected its options {…}: <message> |
an option whose value is of a type the generation config takes at compile and generate does not (min_length: "3"); the message is generate's |
generate.md |
unknown engine '<e>' |
--engine names no engine |
engines.md |
the <engine> engine takes no '<opt>' |
an -o option the engine does not take; the message lists its options |
engines.md |
remote: '<v>' is not one of True, 'local' |
an ndif remote option of another value |
engines.md |
tp 0: tensor parallelism shards the model over at least one rank |
-o tp=0 |
engines.md |
tp <n> shards the model over <n> processes, one per rank, that torchrun starts |
-o tp outside torchrun |
engines.md |
tp <n>: torchrun started <w> processes (WORLD_SIZE), each of which runs the whole plan |
torchrun's process count differs from tp; give both the one number |
engines.md |
WORLD_SIZE <n>: torchrun started <n> processes, and the <engine> engine takes no 'tp' |
torchrun around an engine without tp |
engines.md |
tp <n>: <key> cannot be sharded <n> ways |
a checkpoint that does not split that many ways | engines.md |
device '<d>': under tp <n> transformers puts each rank's shard … |
a --device under tp other than cuda (or cpu where no GPU is visible) |
engines.md |
tp <n>: each rank holds its shard on its own GPU, and torchrun started <k> ranks on this node, which shows <m> |
fewer visible GPUs than ranks on a node | engines.md |
model.dtype 'fp8' needs a GPU of compute capability 8.9 or later |
fp8 on an older GPU, or on none |
engines.md |
model.dtype '<q>' holds the weights in bitsandbytes, which is not installed |
a quantized dtype without bitsandbytes |
engines.md |
model.dtype '<q>': bitsandbytes' packed weights do not shard across ranks |
a quantized dtype under tp |
engines.md |
model.dtype '<q>': the ndif engine cannot honor it |
a quantized dtype under ndif |
engines.md |
device: the ndif engine cannot honor '<d>': the server places the model; device: the ndif engine places a local model on one torch device |
--device under ndif |
engines.md |
device: the vllm engine cannot honor '<d>' |
--device under vllm |
engines.md |
model.dtype '<q>': the vllm engine cannot honor it |
a bitsandbytes dtype under vllm |
engines.md |
tp <n>: vLLM shards the model over one GPU or more |
a vllm tp below 1 |
engines.md |
memory <m>: the fraction of each GPU's memory vLLM reserves is above 0 and at most 1 |
a vllm memory outside (0, 1] |
engines.md |
max_len <n>: the longest sequence the engine serves is one token or more |
a vllm max_len below 1 |
engines.md |
the vllm engine does not write <c> |
on vllm, a write at the recomputed attention pattern or scores | engines.md |
the <engine> engine serves <c> at the prompt's last position alone |
on vllm, the head at a prefill position but the last | engines.md |
a fit trains through the model's gradient, which vLLM's kernels do not take; a grad entry takes the model's gradient, … |
a fit or a grad entry under vllm |
engines.md |
generate rejected '<opt>': the vllm engine's generate maps … onto vLLM's sampling, and has nothing to map '<opt>' to |
an option vLLM's sampling has no name for | engines.md |
generate rejected 'max_new_tokens': the vllm engine needs the step to give it |
a vllm generate step without max_new_tokens |
engines.md |
generate rejected '<field>': the checkpoint's generation config sets <field> … |
a generation config with a logits processor vLLM lacks | engines.md |
<input>'s longest row has <n> tokens …, past the <m> the vllm engine serves |
rows past the engine's max_len |
engines.md |
plan is not compiled; call plan.compile() |
execute on a plan not compiled |
python-api.md |
the plan's model is not the one this engine loaded |
a loaded engine reused with another model block; the message names each field that differs | python-api.md |
the loaded <e> engine runs on <d> with {…}; device and options are given when an engine loads |
nnspec.run with a loaded engine and another device or options |
python-api.md |
the plan has not run, so it has no results; execute it first |
the run record asked for before the run | python-api.md |
describe '<what>': nothing is described under that name |
nnspec.describe given a name that is none of its tables; the message lists them. On the command line argparse refuses it (invalid choice) |
python-api.md |
out of CUDA memory at batch size <n> |
a step ran out of CUDA memory; the run stops there and saves the steps that finished | running.md |
row <r> of dataset '<d>' is not among the <n> rows this value holds |
in the run: a value made over some of its dataset's rows (a fit body's minibatch) read at a row it does not hold; no document reaches it, so reaching it is a defect in nnspec | fit.md |
the values this document loads hold <n> MiB of tensors (…), and a request carries at most 512 MiB inside its plan |
loads too large to send in a request, to an NDIF server or under -o remote=local |
cached-harvest.md |
'<n>' was not saved; add it to saves |
nnspec table or nnspec show of an unsaved name, or of a run whose --out a later run reused, replacing its manifest |
output.md, bundles.md |
'<n>' has no result: the run stopped before its step |
a name whose step a stopped run never reached | output.md |
no run at '<out>' (no manifest.json) |
nnspec show or nnspec table of a directory without a run |
output.md |
<out>/tokens.json is missing, and the manifest holds no tokens |
a run directory without its tokens.json |
output.md |
'<a>' has a row per example of '<d>' and '<b>' of '<e>'; a table joins the values of one dataset |
names of different datasets in one table | output.md |
'<a>' has a pos column counting positions of <i>, and '<b>' one counting positions of <j> |
names read on different inputs in one table; table them one at a time | output.md |
'<n>' is a top_k over rows, whose rows are its picks, and a top_k over rows tables alone |
a top_k over rows beside another name |
output.md |
'<a>' and '<b>' share no row and pos together (or … layer, row and pos together) |
reads of one input at positions no row holds for both, so the join has no row; table them one at a time, or read at a pos both hold |
output.md |
'<a>' and '<b>' share no layer |
values at layers neither holds (a layers axis, or a value without rows reduced from one) |
output.md |
'<n>' reached no row (each is alignment_missing) |
a read that reached no row, beside one that did; alone it tables each row flagged | alignment-missing.md |
'<n>' is a trained featurizer's bundle, which has no rows to table |
a bundle in nnspec table; read it from plan.results |
output.md |
'<n>' has no rows to table: it is … |
a value with no rows axis | output.md |
the plan holds none of its rows |
preflight or a step called from Python on a plan whose rows are not loaded; nnspec.run and an engine's execute load them first |
compile-and-run.md |
A malformed command line (an unknown flag, a missing argument, a value outside a flag's choices) gets argparse's usage message and exit status 2, not an nnspec: line: nnspec describe: error: argument what: invalid choice: 'bogus' (choose from …). An engine no one registered is an nnspec: line, nnspec: unknown engine 'bogus'; valid: nnterp, hooks, ndif, vllm (cli.md).
Under --engine ndif, preflight and the run happen on the server. With -o remote=local, nnsight's local simulation of that trip, nnspec run prints the same nnspec: line as under nnterp; engines.md covers a real server.
- symptom-index — Something ran and the numbers are wrong: the silent cases, from indices counted within a select list to a published SAE stated at the wrong layer, each with what it is and where it is explained.
- alignment-missing — Why a row is alignment_missing or a value is NaN, how missingness propagates through ops and tables, how to count it, and how to move the question into the prefill, where a miss is refused.
- operand-does-not-fit — Why a swap, add, kl or cosine refuses its operand: layout, width, positions, selected heads, layers, coordinates, dataset, a same-forward entry, or two inputs of different lengths, with the fix for each message.
- position-not-in-row — Why a run refuses with 'row i: … is not in its input' or 'index … does not fit the row's …': a prefill position that names nothing on one row, how to see that row's tokens, and the fix for each message.
- answer-does-not-line-up — Why a metric refuses its answer column ('is 3 tokens; the read has 1 position', 'no one logit for logit_diff', 'predicts … in the input'): how answers are tokenized and lined up with the read, and the fix for each message.