Model dimensions from constructor arguments stay wildcarded on layer inputs and logits

[khatchad]

Three wildcard axes in the gpt-2 subject are pinnable but left open, all the same shape: a model dimension that reaches a layer through a constructor argument.

• OutputLayer.call's x is inferred float32 (None, None, None). Its final axis is the embedding width, which arrives as the constructor argument at Gpt2 and is read back in the body with tf.shape(x)[-1] rather than as a static dimension.
• Gpt2.get_loss's pred and Gpt2.get_padded_accuracy's logits are inferred float32 (None, None, None). Their final axis is the output width of the same layer, constructed as OutputLayer(self.vocab_size), whose body reshapes to [batch, sequence, self.output_dim].

In both cases the value is a literal default on a command-line option in the entry script, threaded through the model constructor to the layer. It is a fixed integer at runtime, never None, so these are precision gaps rather than deliberate wildcards, and the derivation is static: fold the default through the constructor to the stored attribute, then to the layer's declared output dimension.

The batch and sequence axes on the same parameters are genuinely variable and correctly wildcarded, so only the final axis is at issue.

Scope note: a run overriding the option changes the constant, so any recovered value is the default-configuration one. That is the same status as other config-derived sizes the analysis reports as fixed-but-uncomputable.

The call sites and line numbers behind each axis are recorded alongside the analysis notes.

[khatchad]

One of These Three Axes Is a Correctness Requirement

Applied the static-versus-dynamic test to the three axes in this issue. They do not behave alike, and the difference is visible in the source.

OutputLayer reads the dimension twice, once each way. Its call does d_model = tf.shape(x)[-1], which is dynamic and safe. Its build does input_dim = tensor_shape.dimension_value(input_shape[-1]) and passes that to add_weight(shape=[input_dim, self.output_dim]), which needs a Python integer. The build read is the one that decides, since build runs during tracing:

OutputLayer.call  emitted (None, None, None)  -> TypeError
                  last axis pinned (None, None, 8)  -> traces OK

So that axis is a soundness requirement: the signature currently inferred for OutputLayer.call cannot be written without breaking the layer.

The two logits axes, on get_loss and get_padded_accuracy, are different. Neither body reads the dimension statically; they use tf.argmax(..., axis=-1) and the loss object, both of which work with the axis open. Those remain precision-only, and leaving them wildcarded costs nothing at run time.

The practical effect is to split this issue: recovering the constant fixes one signature that would otherwise be wrong, and tightens two that are merely loose. If the work is ever scoped down, OutputLayer is the part that has to happen.

The general form of the failure is in ponder-lab/Hybridize-Functions-Refactoring#811.