|
| | CausalLM (const HfModelConfig &config, DeviceBackend *backend, bool allow_unsupported=false) |
| |
| Tensor | backward (const Tensor &grad_output) override |
| | Computes the gradient w.r.t. this module's input, given the gradient w.r.t. its output. Must be called after forward() – uses state cached from that call.
|
| |
| Tensor | propagate_relevance (const Tensor &relevance_out, const LRPRuleConfig &config) override |
| | Computes this module's contribution to LRP relevance propagation.
|
| |
| std::vector< Tensor > | propagate_relevance_by_layer (const Tensor &relevance_out, const LRPRuleConfig &config) |
| | propagate_relevance, stopping at every block boundary: the relevance of the residual stream entering block 0 (the scaled embeddings), then leaving each block, each shaped like the hidden states (N, L, hidden_size). Summing the first over hidden_size gives propagate_relevance's per-token relevance.
|
| |
| OpType | op_type () const override |
| | A chain of other modules, as SequentialModule.
|
| |
| std::vector< NamedParamRef > | named_parameters () override |
| | This module's trainable parameters, each with its hierarchical name – the one place a module declares its parameters (roadmap FND-1).
|
| |
| std::vector< NamedModuleRef > | named_children () override |
| | This module's direct sub-modules, each under the prefix its parameters carry in named_parameters(), in the same order (TRN-7: how ApplyLora() finds a model's Linear layers). Default: none. NamedModules() walks the whole tree.
|
| |
| std::vector< NamedBufferRef > | named_buffers () override |
| | This module's buffers: state a checkpoint must save that no optimizer updates.
|
| |
| void | set_training (bool training) override |
| | Sets this module's training/eval mode. Defaults to training (matches every mainstream framework's Module default).
|
| |
| std::optional< DeviceType > | compute_device () const override |
| | The device this module computes on, so forward() can reject an input on another device before any kernel sees it (roadmap FND-8).
|
| |
| NextTokenLogitsFn | next_token_logits (int64_t max_length) |
| | A cached next-token function for Generate (LLM-5): one pass over the prompt, then one position per new token.
|
| |
| void | set_intervention (int64_t layer, std::unique_ptr< ResidualIntervention > intervention) |
| | Runs intervention on block layer's output, in forward(), backward(), the relevance passes and cached generation (TRN-9). Its parameters join named_parameters() as interventions.<layer>.*. nullptr removes it.
|
| |
| void | set_interventions_enabled (bool enabled) |
| | false runs the model as if it had no interventions, everywhere they would run; true (the default) runs them again (TRN-11: the base model's relevance).
|
| |
| bool | interventions_enabled () const |
| |
| ResidualIntervention * | intervention (int64_t layer) |
| | Block layer's intervention, or nullptr.
|
| |
| void | set_hidden_state_hook (HiddenStateHook hook) |
| | Calls hook at every position during forward() (not during next_token_logits()'s cached passes). An empty function removes it.
|
| |
| const HfModelConfig & | config () const |
| |
| EmbeddingModule & | embed_tokens () |
| |
| TransformerBlock & | layer (int64_t i) |
| |
| int64_t | num_layers () const |
| |
| RMSNormModule & | norm () |
| |
| LinearModule * | lm_head () |
| | The untied language-model head, (hidden_size -> vocab); nullptr when tied to the embedding.
|
| |
| virtual | ~Module ()=default |
| |
| Tensor | forward (const Tensor &input) |
| | Runs this module's forward computation.
|
| |
| std::pair< Tensor, NodeId > | forward_traced (const Tensor &input, NodeId input_node, ComputationGraph &graph, Autograd &autograd) |
| | Runs forward() while also registering a ComputationGraph node (tagged with this module's op_type(), parented to input_node) and wiring an Autograd backward function that reuses this module's own backward() – the opt-in traced/explainable path, per Phase 2 Mission 0.
|
| |
| virtual bool | supports_lrp_rule (LRPRule rule) const |
| | Whether propagate_relevance() implements rule (no silent fallback: callers such as ExplainerContext::relevance_pass() throw rather than run a module on a rule it does not implement).
|
| |
| virtual std::vector< ParamRef > | parameters () |
| | This module's trainable parameters and their gradients, for an optimizer to update uniformly across module types.
|
| |
| void | set_requires_grad (bool requires_grad, const std::string &prefix="") |
| | Freezes (false) or unfreezes (true) parameters by name (roadmap FND-2).
|
| |
| bool | is_training () const |
| | Whether this module is currently in training mode.
|
| |
| virtual void | release_activations () |
| | Frees the tensors forward() kept for backward() and the relevance passes; containers release their children too. Inference that only needs the output calls it after each forward, so a deep model holds one layer's activations at a time (a 1024-token ESM-2 650M pass otherwise keeps over 10 GB of them).
|
| |
Token embedding, num_hidden_layers pre-norm transformer blocks, a final RMSNorm and a language-model head (tied to the embedding or its own bias-free Linear): the architecture of Llama, SmolLM2, Qwen2/2.5 and Qwen3. Maps (N, L) token ids to (N, L, vocab) logits.
Parameter names follow Hugging Face's with pulsatrix's module names inside a layer: embed_tokens.weight, layers.<i>.norm1.weight, layers.<i>.mha.q_proj.weight, ..., layers.<i>.swiglu.down_proj.weight, norm.weight, and lm_head.weight when untied. HuggingFaceMapping() lists how each Hugging Face tensor maps onto them.
- Note
- backward() and propagate_relevance() run through every layer, so the model trains and explains like any other module.