Shared Encoder API¶

The text fields the shared encoder reads, and their markers (Req 14; spec R13).

A code has four channels: title, description, excluded and examples. A query is a fifth field. A present text is marked with its field's name, '<field>: <text>', so one backbone can tell the fields apart. An absent text (null or blank) is the empty string with present False and no marker, so fusion can mask it (Req 9).

Fusion of a code's channel vectors into one vector (Req 14; Req 9; spec 4.1).

Every option reads only the present channels: an absent channel's slot is masked whatever it holds, and a row with no present channel fuses to a finite vector with a finite gradient.

• masked_mean, the default: the sum over present channels, divided by max(1, number present).
• attention: a learned vector scores each present channel by its dot product, and a softmax over the present channels weights them.
• moe, an ablation only (R12): the masked mean, then the mixture of experts on that vector. Only this option emits gate probabilities and expert indices.

The geometry heads of Req 12's three arms: Euclidean, spherical and hyperbolic.

Every head takes the projection's output v (B, d) and returns HeadPoints:

• tangent: the coordinates the export writes, Req 2's form of the arm. The hyperbolic head writes its bounded tangent r · û, the Euclidean head v and the spherical head û;
• embedding: the point the arm's decoding distance reads. It is the Lorentz point (B, d + 1) under hyperbolic and tangent itself otherwise;
• radius and direction: the polar parts that the code cache keeps and the training distance reads.

Each head also names its geometry and its decoding distance (a panels.decoding DISTANCES name). radial says whether the radial term applies, which it does only in the hyperbolic arm (Req 12). pair_distance is its training distance over polar parts, (A, B) in the inputs' dtype. read_points maps exported coordinates to the float64 CPU points its distance reads. The hyperbolic head is hyperbolic.HyperbolicHead; this module adds the two flat heads and builds a head by name.

‖v_a − v_b‖ = √((r_a − r_b)² + r_a · r_b · ‖û_a − û_b‖²)

The shared encoder (Req 14; spec 4.1): one backbone with one LoRA adapter, for every field.

Per code the path is:

1. field-marked channel texts;
2. one backbone with one LoRA adapter;
3. an attention-masked mean over each text's tokens;
4. fusion over the present channels;
5. one Linear(hidden → d);
6. the geometry head, which gives the point.

A query is a one-field batch, {'query': …}, and takes the same path.

Each field's present texts go to the backbone in chunks of at most max_texts_per_call, each trimmed to its own longest text. So no absent text, and no padding column beyond a chunk's longest text, enters the backbone. Presence comes from each field's present flag, never from the attention mask (Req 9).

Under autocast only the backbone runs in reduced precision. The pooled vectors are cast to float32, and fusion, the projection and the head run with autocast off (spec 4.2).