pulsatrix 1.1.0
Loading...
Searching...
No Matches
pulsatrix Directory Reference
Directory dependency graph for pulsatrix:
include/pulsatrix

Directories

 orch
 
 tda
 
 viz
 

Files

 acquisition_functions.hpp
 Bayesian-Optimization acquisition functions over a GP posterior: Expected Improvement, Probability of Improvement, GP-Upper-Confidence-Bound (Snoek, Larochelle, Adams, "Practical Bayesian Optimization of Machine Learning Algorithms," NeurIPS 2012).
 
 activation_module.hpp
 A pointwise activation chosen at construction: ReLU, tanh, sigmoid, SiLU, exact GELU or GELU's tanh approximation (PLM-1).
 
 activation_snapshot.hpp
 Self-contained, enumerable copy of one forward pass's cached activations.
 
 adam_optimizer.hpp
 Adam optimizer – operates uniformly across any Module's parameters().
 
 adaptive_avg_pool2d_module.hpp
 Average pooling to a fixed output size, as PyTorch's AdaptiveAvgPool2d (KS-9).
 
 adversarial.hpp
 Adversarial attacks on a classifier (KS-4): the fast gradient sign method (Goodfellow, Shlens and Szegedy, ICLR 2015) and projected gradient descent (Madry et al., ICLR 2018), under the L∞ or L2 norm, untargeted or targeted, and the robust accuracy they leave.
 
 agent.hpp
 Abstract RL agent interface – the inference-time policy contract, act() only.
 
 aggregator_module.hpp
 Differentiable p-mean quantifier aggregator – Phase 1 Mission 1 of campaign_exai_dl_library_neuro_symbolic (Logic Tensor Networks' Real Logic: agg_p(x) = (mean(x^p))^(1/p), standing in for a fuzzy universal/existential quantifier over a batch of groundings).
 
 anchors.hpp
 Anchors (Ribeiro, Singh and Guestrin, "Anchors: High-Precision Model-Agnostic Explanations", AAAI 2018): an if-then rule around one input that keeps the model's prediction with high probability, whatever the other features do (XAI-4).
 
 asha.hpp
 ASHA (Asynchronous Successive Halving Algorithm; Li, Jamieson, Rostamizadeh, Gonina, Hardt, Recht, Talwalkar, "A System for Massively Parallel Hyperparameter Tuning," MLSys 2020): unlike synchronous Successive Halving/Hyperband (which process one full rung across every candidate before any candidate advances to the next), ASHA promotes a candidate to the next rung as soon as it qualifies (its metric is in the top 1/eta fraction of every candidate that has ever completed that rung so far), never waiting on the rest of the current rung's population.
 
 assert.hpp
 PULSATRIX_ASSERT – debug-only invariant check for programmer errors, distinct from throw (used for caller-facing contract violations). See cpp_style_guide/context_style_project_conventions.md's assert-vs-throw table.
 
 attnlrp_parity.hpp
 AttnLRP parity with LXT on a real language model (LLM-7): pulsatrix's relevance against LXT's own AttnLRP on the same Hugging Face model and tokens.
 
 attribution.hpp
 First-class explanation result type – values, method, and metadata together.
 
 audio_collate.hpp
 AudioPadCollate – zero-pads variable-length waveforms into one batch Tensor.
 
 audio_folder_dataset.hpp
 Directory-of-class-subfolders audio Dataset, mirroring ImageFolderDataset.
 
 audio_transforms.hpp
 Sample-level audio Transforms – linear-interpolation resampling.
 
 autograd.hpp
 Reverse-mode autodiff – walks a ComputationGraph backward, accumulating gradients via per-node backward functions supplied by the caller.
 
 avg_pool2d_module.hpp
 2D average pooling, non-overlapping windows (stride == kernel), no padding.
 
 batch_norm_fold.hpp
 Folds an eval-mode BatchNorm into the Conv2D before it for the duration of an LRP explanation – Zennit's BatchNorm canonizer (roadmap FND-5, lrp_issues #8).
 
 batch_norm_module.hpp
 Batch normalization (Ioffe & Szegedy, 2015) – per-channel statistics computed across the batch and spatial dimensions jointly, unlike GroupNormModule's per-(batch-row, group) statistics.
 
 bce_with_logits_loss.hpp
 Binary cross-entropy on raw logits – combined sigmoid + BCE, numerically stable.
 
 benchmark.hpp
 Timing, benchmark reports (pulsatrix.benchmark.v1) and regression comparison.
 
 block_sparse_featurizer.hpp
 Block-sparse featurizers (FEAT-6; Fel et al., "Structuring Sparsity: Block-Sparse Featurizers Capture Visual Concept Manifolds", arXiv 2606.25234): features are small subspaces (blocks of directions) instead of single directions, so a concept that lives on a low-dimensional manifold, such as an angle or a lighting direction, is one feature.
 
 born_again.hpp
 Born-again networks (Furlanello et al., ICML 2018; roadmap KD-4): a student the size of its teacher, trained on the teacher's outputs, then a teacher for the next generation.
 
 bounded_queue.hpp
 Fixed-capacity thread-safe blocking queue – the staged-pipeline backbone.
 
 byte_level_bpe.hpp
 The components byte-level BPE tokenizers are built from (TOK-2): NFC, regex and digit splitting, byte-level mapping, BPE, template post-processing and byte-level decoding, each following Hugging Face tokenizers.
 
 caching_allocator.hpp
 A caching device-memory allocator (roadmap HIP-3): freed blocks are kept and reused for later requests of the same size class instead of going back to the driver.
 
 calibration.hpp
 Calibrating a model's probabilities (KS-13): temperature scaling fitted on held-out data, and the error in log-odds against reference probabilities, by probability band.
 
 calibration_loss.hpp
 Brier score – a proper-scoring-rule calibration loss (Brier, 1950).
 
 cartpole_env.hpp
 CartPole-v1 environment – classic cart-pole balancing physics, discrete actions.
 
 categorical_policy_agent.hpp
 Stochastic categorical (discrete-action) policy over a logit-producing Module.
 
 causal_lm.hpp
 A Llama-family decoder-only language model built from a Hugging Face config, and loading its Hugging Face weights by name (IO-4).
 
 checkpoint.hpp
 Saving and resuming models (roadmap IO-2): parameters and buffers in one safetensors file, optimizer state in a sibling file, and a format version with a migration table.
 
 circuit_graph.hpp
 Self-contained circuit-graph artifact – scored nodes and weighted edges.
 
 circuit_tracing.hpp
 Attribution graphs with cross-layer transcoders (FEAT-10), after Ameisen, Lindsey et al., "Circuit Tracing: Revealing Computational Graphs in Language Models" (Transformer Circuits, 2025) and its open implementation, circuit-tracer (github.com/decoderesearch/circuit-tracer). Each MLP is replaced by a transcoder's features plus an error term, attention patterns and normalization scales are frozen, and what is left is linear: the graph's edges are exact attributions between features, errors, token embeddings and output logits.
 
 cma_es.hpp
 A CMA-ES-*style* ask-tell evolutionary strategy (Hansen & Ostermeier's Covariance Matrix Adaptation Evolution Strategy) for continuous hyperparameter search: an adaptive mean, a per-dimension adaptive scale (separable/diagonal covariance, Ros & Hansen, "A Simple Modification in CMA-ES Achieving Linear Time and Space Complexity," PPSN 2008), and an adaptive global step size.
 
 collate.hpp
 Batch assembly – Batch, CollateFn, DefaultCollate.
 
 computation_graph.hpp
 Owns and exposes graph structure – the interpretability substrate every explainer (Phase 2+) walks.
 
 concept_relevance.hpp
 Concept Relevance Propagation (INT-6): which of a layer's channels an LRP explanation passes through, where each one looks in the input, and which inputs show it at work.
 
 conformal.hpp
 Split conformal prediction (KS-3): prediction sets for a classifier and intervals for a regressor that contain the truth with a chosen probability, whatever the model (Vovk, Gammerman and Shafer, 2005; Angelopoulos and Bates, arXiv 2107.07511).
 
 conjunction_module.hpp
 Differentiable fuzzy conjunction (t-norm) – Phase 1 Mission 0 of campaign_exai_dl_library_neuro_symbolic (differentiable fuzzy-logic core, Logic Tensor Networks-shaped).
 
 continuous_cartpole_env.hpp
 Continuous-action variant of CartPoleEnv – identical physics, force is a fraction.
 
 contrastive.hpp
 The contrastive explanation method (CEM; Dhurandhar et al., "Explanations based on the Missing", NeurIPS 2018): pertinent negatives, what is absent from an input and would change its class if present, and pertinent positives, the least of the input that keeps its class on its own (XAI-4).
 
 conv2d_module.hpp
 2D convolution – implemented via im2col + DeviceBackend::gemm (no new backend primitive).
 
 counterfactual.hpp
 Counterfactual explanations: gradient-based (Wachter et al. 2017, CFS-5) and model-agnostic (growing spheres, Laugel et al. 2018, CFS-6), and diverse sets with a plausibility score (DiCE, Mothilal et al. 2020, CFS-7).
 
 cpu_backend.hpp
 CPU implementation of DeviceBackend – the first, reference DeviceBackend implementation.
 
 cross_entropy_loss.hpp
 Softmax + negative log-likelihood classification loss.
 
 crosscoder.hpp
 Crosscoders (FEAT-8): one sparse dictionary read from and written to several sources at once, such as the residual stream at several layers, or the same layer in a base model and its fine-tune (Lindsey et al., "Sparse Crosscoders for Cross-Layer Features and Model Diffing", Transformer Circuits, 2024). Model diffing reads which latents' decoders live in one model only, with Minder et al.'s BatchTopK crosscoder and Latent Scaling ("Overcoming Sparsity Artifacts in Crosscoders to Interpret Chat-Tuning", arXiv 2504.02922), and Kassem et al.'s Delta-Crosscoder for narrow fine-tunes ("Delta- Crosscoder: Robust Crosscoder Model Diffing in Narrow Fine-Tuning Regimes", arXiv 2603.04426).
 
 crossover.hpp
 Genetic-algorithm crossover operators: one-point, two-point, uniform (generic sequence genotypes), and blend/BLX-alpha, simulated binary (SBX) (real-valued genotypes).
 
 csv_dataset.hpp
 Dataset over a CSV file's numeric feature/label columns – Phase 1's tabular reference case.
 
 csv_reader.hpp
 Minimal hand-rolled CSV parser – RFC-4180-ish, whole-file-at-once.
 
 cublas_check.hpp
 PULSATRIX_CUBLAS_CHECK – converts a cuBLAS call failure into a thrown C++ exception, parallel to PULSATRIX_CUDA_CHECK (cuda_check.hpp). Only compiled when PULSATRIX_ENABLE_CUDA is set.
 
 cuda_backend.hpp
 CUDA implementation of DeviceBackend. Only compiled when PULSATRIX_ENABLE_CUDA is set.
 
 cuda_check.hpp
 PULSATRIX_CUDA_CHECK – converts a CUDA runtime failure into a thrown C++ exception at the DeviceBackend boundary, per gpu_backend_programming/context_gpu_cuda_kernel_mechanics.md's Error Checking pattern. Only compiled when PULSATRIX_ENABLE_CUDA is set.
 
 data_loader.hpp
 Orchestrates sampling, fetch, and collation into batches.
 
 data_thread_pool.hpp
 Minimal generic thread pool for CPU-side data pipeline work.
 
 datalog_atom.hpp
 A Datalog atom: a predicate name plus a tuple of terms, no function symbols. Phase 3 Mission 0 of campaign_exai_dl_library_neuro_symbolic (Datalog core).
 
 datalog_dual_semiring.hpp
 Forward-mode-automatic-differentiation semiring (DualNumber<T>/DualSemiring<T>) – a second, differentiable real-valued instantiation of Mission 1's generic Semiring trait shape, carrying a value and its derivative w.r.t. one seeded scalar through every ⊕/⊗ the weighted engine performs. Phase 3 Mission 2 of campaign_exai_dl_library_neuro_symbolic (Neural-Predicate Integration).
 
 datalog_engine.hpp
 Bottom-up fixpoint evaluation (naive and semi-naive), boolean semiring only. Phase 3 Mission 0 of campaign_exai_dl_library_neuro_symbolic (Datalog core).
 
 datalog_fact_database.hpp
 A set of ground (fully-constant) Datalog atoms. Phase 3 Mission 0 of campaign_exai_dl_library_neuro_symbolic (Datalog core).
 
 datalog_lrp.hpp
 LRP-style relevance propagation for the real-valued (+, x) provenance-semiring Datalog circuit built in Mission 1/2 – Phase 3 Mission 3 of campaign_exai_dl_library_neuro_symbolic (LRP for the Datalog/Provenance-Semiring Circuit), extending Phase 1-2's fuzzy-logic LRP methodology (the weighted-sum/ epsilon-rule split for +, the bilinear split for x) to derived-fact weights instead of Module output tensors.
 
 datalog_rule.hpp
 A Datalog rule: head :- body1, body2, ..., range-restricted (safe) by construction. Phase 3 Mission 0 of campaign_exai_dl_library_neuro_symbolic (Datalog core).
 
 datalog_semiring.hpp
 Generic provenance-semiring abstraction (zero/one/add=(+)/mul=(x)) plus the boolean (trivial) and real-valued (+, x) concrete instantiations. Phase 3 Mission 1 of campaign_exai_dl_library_neuro_symbolic (Generic Provenance-Semiring Abstraction).
 
 datalog_term.hpp
 Function-symbol-free Datalog term – a constant or a variable, never a compound term. Phase 3 Mission 0 of campaign_exai_dl_library_neuro_symbolic (Datalog core).
 
 datalog_weighted_engine.hpp
 Semiring-parameterized bottom-up fixpoint evaluation – the weighted counterparts of Mission 0's naive_evaluate/semi_naive_evaluate. Phase 3 Mission 1 of campaign_exai_dl_library_neuro_symbolic (Generic Provenance-Semiring Abstraction).
 
 datalog_weighted_fact_database.hpp
 A map from ground Datalog atom to a semiring-typed weight. Phase 3 Mission 1 of campaign_exai_dl_library_neuro_symbolic (Generic Provenance-Semiring Abstraction).
 
 dataset.hpp
 Random-access dataset abstraction – Sample, Dataset (size()/get()).
 
 dataset_validator.hpp
 Generic per-field descriptive statistics + missingness/outlier detection over any Dataset.
 
 detailed_balance_loss.hpp
 GFlowNet Detailed Balance loss (Bengio et al., "GFlowNet Foundations", arXiv:2111.09266).
 
 determinism.hpp
 One global seed for everything that isn't given its own, and a deterministic mode that forbids nondeterministic computation (roadmap FND-7).
 
 device_backend.hpp
 Abstract interface isolating vendor-specific memory/compute operations from Tensor/ComputationGraph.
 
 disjunction_module.hpp
 Differentiable fuzzy disjunction (t-conorm) – Phase 1 Mission 0 of campaign_exai_dl_library_neuro_symbolic (differentiable fuzzy-logic core, Logic Tensor Networks-shaped).
 
 distillation_loss.hpp
 Knowledge distillation (roadmap KD-1): a student learns from a teacher's softened outputs (Hinton, Vinyals and Dean, 2015), optionally mixed with the hard labels.
 
 dqn_agent.hpp
 Epsilon-greedy DQN policy over an arbitrary Q-network Module.
 
 dqn_loss.hpp
 DQN's masked-MSE Bellman loss – squared error on the taken action only.
 
 dqn_target.hpp
 DQN Bellman target computation (vanilla + Double DQN) and target-network hard sync.
 
 dropout_module.hpp
 Inverted dropout – the first module whose forward behavior genuinely differs between training and inference (Module::is_training()).
 
 egan_mutation.hpp
 E-GAN's own three named "mutation" objectives (Wang et al. 2019, "Evolutionary Generative Adversarial Networks") plus its sample-quality/diversity fitness metric. In E-GAN, "mutation" means training a copy of a generator against a different loss function, not perturbing its weights directly – a structurally different kind of mutation than this campaign's own Phase 3 NEAT/ES operators, which do perturb weights.
 
 egan_training.hpp
 E-GAN's own full generational training loop (Wang et al. 2019): each generation, every population member independently attempts every given mutation objective (Phase 5 Mission 1) via a fresh weight-copy offspring, keeps whichever mutation scored the best combined fitness, then the shared discriminator trains on a real batch plus the (now-mutated) population's own pooled fake output (Phase 5 Mission 0).
 
 embedding_export.hpp
 Hand embeddings or activations to UMAP and t-SNE tools, and bring their coordinates back as a projection document.
 
 embedding_module.hpp
 Lookup-table (row-select) layer – y = W[index], batched (N, L) -> (N, L, embedding_dim).
 
 encoder_block.hpp
 A configurable transformer encoder layer (PLM-1): LayerNorm or RMSNorm, before or after each sublayer, and a plain or gated MLP. ESM-2's layer, BERT's layer and the Llama-style pre-norm layer are all settings of it.
 
 encoder_lm.hpp
 Masked-language-model encoders: ESM-2 protein language models (PLM-2), Hugging Face EsmForMaskedLM checkpoints loaded, run, trained and explained natively, and MDLM masked diffusion language models (DIFF-2).
 
 environment.hpp
 Abstract RL environment interface (gymnasium-shaped reset/step) + StepResult.
 
 evolution_strategies.hpp
 Evolution Strategies (Salimans et al. 2017, "Evolution Strategies as a Scalable Alternative to Reinforcement Learning"): a black-box, gradient-free optimizer over an arbitrary flat parameter vector, driven entirely by a scalar fitness function – zero inherent RL dependency, applicable to any fixed-topology network's flattened weight vector or any other real-valued parameterization.
 
 evolutionary_loop.hpp
 The shared six-step evolutionary-loop skeleton (evaluate -> select parents -> vary via crossover/mutation -> evaluate offspring -> survivor-select -> loop), generic over which survivor-selection policy (survivor_selection.hpp) and which offspring-production recipe (selection + crossover + mutation, composed by the caller) is used.
 
 explainer_capabilities.hpp
 What each explainer answers: the nine question categories (Liao, Gruen and Miller, CHI 2020), the four reasons to explain (Adadi and Berrada, 2018), and a machine-readable declaration of every explainer's question, scope, model access and inputs (XAI-1).
 
 explainer_context.hpp
 Stable interface every explainer gets, regardless of type (charter Part 2 SS2).
 
 explainer_stability.hpp
 Production API for an explainer's repeated-run stability audit metric (charter Phase 4).
 
 explanation_agreement.hpp
 Whether two models explain the same inputs with the same evidence (roadmap KD-2): a distilled student against its teacher, a fine-tuned model against its base, or any two models that take the same input.
 
 explanation_metrics.hpp
 Explanation-quality metrics in the Quantus families (roadmap XAI-5): faithfulness (deletion and insertion curves, with ROAD's imputation), randomization (the model-parameter randomization test) and complexity (sparseness and complexity).
 
 explanation_planner.hpp
 Turns a question and a reason into a plan: which explainers can answer the question for this model, ranked, and which checks must run before the answer is trusted (XAI-2).
 
 explanation_report.hpp
 An explanation that says what it supports (XAI-3): the attribution together with the question and reason it was made for, the method and its settings, the results of the checks the plan asks for, and caveats derived from those results and from the method's known failure modes.
 
 explanation_robustness.hpp
 How much an explanation changes when its input barely does (KS-4): the max- and average-sensitivity of Yeh et al. (NeurIPS 2019), the local Lipschitz estimate of Alvarez-Melis and Jaakkola (2018), and the sensitivity at the perturbation an attacker would try first, FGSM's.
 
 feature_distillation.hpp
 Distilling a teacher's intermediate features, not only its outputs (roadmap KD-3): FitNets' hint loss (Romero et al., ICLR 2015) and attention transfer (Zagoruyko and Komodakis, ICLR 2017).
 
 featurizer.hpp
 The featurizer family's common interface (FEAT-1): models that rewrite activations as sparse codes over learned directions and back, such as sparse autoencoders, with a shared training step and metrics (L0, dead and dense latents).
 
 featurizer_metrics.hpp
 How good a featurizer is (FEAT-3), after SAEBench (Karvonen et al., arXiv 2503.09532): reconstruction (explained variance, cosine, norm ratio, L0, dead and dense latents), loss recovered when the reconstruction is spliced back into the model, and feature absorption (Chanin et al., arXiv 2409.14507) with a linear probe as its baseline.
 
 feed_forward_module.hpp
 The plain transformer MLP, Linear -> activation -> Linear, of BERT, ESM and the original Transformer (PLM-1). The gated variant is SwiGLUModule.
 
 fine_tune_diff.hpp
 What did a fine-tune change? The fine-tuned model's relevance minus the base model's for the same prediction, input by input and token by token across a dataset, and intruder dimensions: new top singular directions in the fine-tuned weights (TRN-11).
 
 fitness_metrics.hpp
 ProteinGym's metrics for how well predicted variant scores track measured fitness (PLM-3), computed exactly as ProteinGym's performance_DMS_benchmarks.py does.
 
 fixed_topology_xor_network.hpp
 A small, fixed-topology (2 input -> 2 hidden -> 1 output, both layers sigmoid) MLP whose weights are a flat parameter vector, plus a plain analytic fitness function scoring it against the four XOR patterns – the "fixed-topology network" and "plain analytic fitness function" this campaign's Evolution Strategies mission needs, deliberately using the same XOR benchmark and the same fitness convention (4.0 minus sum of squared error) as Mission 2's NEAT proof, for a direct same-problem cross-check between the two techniques.
 
 flatten_module.hpp
 Reshape-only Module – flattens every non-batch dim of a (N, ...) input to (N, flattened_features), for chaining Conv2DModule's batched (N,C,H,W) output into a LinearModule's batched (N, in_features) input.
 
 gae.hpp
 Generalized Advantage Estimation (Schulman et al. 2016) over a stored rollout.
 
 gaussian_process.hpp
 Gaussian-Process regression surrogate for Bayesian Optimization – the "gaussian bands" technique named at this campaign's own drafting (Snoek, Larochelle, Adams, "Practical Bayesian Optimization of Machine Learning Algorithms," NeurIPS 2012).
 
 generation.hpp
 Text generation from a language model: greedy decoding and seeded sampling with temperature, top-k, top-p and min-p, repetition penalty, and EOS handling (LLM-4).
 
 generator_population.hpp
 E-GAN's own population-of-generators infrastructure (Wang et al. 2019, "Evolutionary Generative Adversarial Networks"): N independently-parameterized generator Modules, and the concrete mechanism for training one shared discriminator against fake samples pooled from the whole population – in E-GAN, the discriminator's own training distribution is the union of every population member's output, not one generator's alone, which is what gives the discriminator (and, in turn, each generator's own training signal) a harder, more diverse target than a single- generator GAN ever sees.
 
 gflownet_forward_policy.hpp
 Masked stochastic categorical policy over a logit-producing Module – P_F for GFlowNet training objectives.
 
 gflownet_trajectory.hpp
 Rolls out one full HyperGrid episode under a GFlowNetForwardPolicy.
 
 global_sensitivity.hpp
 Global sensitivity analysis: Morris elementary effects and Sobol indices (CFS-4).
 
 golden_logits.hpp
 The golden-logit harness: a loaded model's logits against Hugging Face's on real text (LLM-6).
 
 gp_bo.hpp
 The GP-BO trial loop: random-initialize, then repeatedly fit a GP to every trial observed so far and propose the next point by maximizing an acquisition function over random candidates in the unit hypercube.
 
 grad_cam.hpp
 Grad-CAM – gradient-weighted class activation mapping over the last conv layer (charter Part 1, Phase 2; theory: xai_context.aDNA's vision_gradcam.md).
 
 grad_clipping.hpp
 Global gradient-norm clipping (roadmap TRN-3).
 
 group_norm_module.hpp
 Group normalization (Wu & He, 2018) – rank-3 (C, H, W), matching Conv2DModule's convention, unlike RMSNormModule/LayerNormModule's rank-1 feature-vector scope.
 
 gru_module.hpp
 Single-layer GRU – gated recurrence with a reset-gated candidate.
 
 hf_model.hpp
 Hugging Face checkpoints: config.json and single or sharded safetensors (IO-5).
 
 hip_backend.hpp
 HIP/ROCm implementation of DeviceBackend. Only compiled when PULSATRIX_ENABLE_HIP is set.
 
 hip_check.hpp
 PULSATRIX_HIP_CHECK – converts a HIP runtime failure into a thrown C++ exception at the DeviceBackend boundary, per gpu_backend_programming/context_gpu_cuda_kernel_mechanics.md's Error Checking pattern. Only compiled when PULSATRIX_ENABLE_HIP is set.
 
 hipblas_check.hpp
 PULSATRIX_HIPBLAS_CHECK – converts a hipBLAS call failure into a thrown C++ exception, parallel to PULSATRIX_HIP_CHECK (hip_check.hpp). Only compiled when PULSATRIX_ENABLE_HIP is set.
 
 host_guard.hpp
 PULSATRIX_REQUIRE_HOST – always-on guard for code paths that dereference Tensor::data() on the host.
 
 hpo_genotype.hpp
 Decodes a real-valued genotype (a unit-hypercube point, one gene per parameter, each in [0, 1]) into a full hyperparameter Configuration – the encoding this campaign's GA operators (crossover.hpp/mutation.hpp, all defined over std::vector<double>) evolve directly, decoded only when a genotype needs to be evaluated.
 
 hpo_sampling.hpp
 Grid search and random search over a SearchSpace: the two simplest, baseline hyperparameter-optimization algorithms, proving the SearchSpace/Trial abstraction's instantiate/train/read-back-metric loop end-to-end before Phase 2's GP-BO/TPE.
 
 hyperband.hpp
 Hyperband (Li, Jamieson, DeSalvo, Rostamizadeh, Talwalkar, JMLR 2018): runs several Successive Halving "brackets" with different (num_configs, initial_budget) trade-offs – covering the tension between "few configs trained long" and "many configs trained short, halved down" that a single Successive Halving run commits to in advance – and returns the best result across every bracket.
 
 hypergrid_env.hpp
 HyperGrid – the standard minimal GFlowNet correctness-check environment.
 
 ia3.hpp
 IA³ (Liu et al., 2022): fine-tune a frozen model by learning one rescaling vector per adapted Linear layer, on its output (keys, values) or its input (the MLP's down projection), and save and load it as a PEFT adapter.
 
 ice.hpp
 Individual conditional expectation (ICE), its centered and derivative forms, two-feature partial dependence (CFS-1) and accumulated local effects (CFS-2).
 
 image_decoder.hpp
 Decodes image files (PNG/JPEG/BMP/etc.) into Tensors via stb_image.
 
 image_folder_dataset.hpp
 Directory-of-class-subfolders image Dataset, mirroring torchvision's ImageFolder.
 
 image_transforms.hpp
 Sample-level image Transforms – resize, center-crop, normalize, horizontal flip.
 
 individual.hpp
 A genetic-algorithm candidate solution: a genotype paired with its fitness.
 
 integrated_gradients.hpp
 Integrated Gradients – baseline-interpolated gradient integral (charter Part 1, Phase 2; theory: xai_context.aDNA's vision_integrated_gradients.md).
 
 iterable_dataset.hpp
 Streaming dataset abstraction – reset()/next() for sources with no random access.
 
 json.hpp
 A small strict JSON value, parser and deterministic writer (RFC 8259).
 
 jumprelu_sparse_autoencoder.hpp
 The JumpReLU sparse autoencoder (FEAT-4; Rajamanoharan et al., "Jumping Ahead: Improving Reconstruction Fidelity with JumpReLU Sparse Autoencoders", arXiv 2407.14435): a learned threshold per latent, trained against an L0 penalty through straight-through estimators.
 
 kernel_shap.hpp
 KernelSHAP – model-agnostic Shapley value approximation via weighted linear regression (charter Part 1, Phase 3; theory: xai_context.aDNA's technique_shap.md).
 
 kl_divergence_loss.hpp
 VAE KL-divergence-to-standard-normal loss term.
 
 kv_cache.hpp
 Preallocated key/value cache for incremental attention (LLM-5).
 
 layer_norm_module.hpp
 Layer normalization (Ba et al., 2016) – mean-centered/scaled RMSNormModule sibling.
 
 layer_student.hpp
 DistilBERT's recipe for a smaller language model (Sanh et al., 2019; roadmap KD-4): a student with some of the teacher's layers, started from those layers' weights, and a cosine loss that aligns the two models' hidden states.
 
 learnable_scalar.hpp
 A single trainable float, updated by plain SGD – not a Tensor/Module parameter.
 
 lime.hpp
 LIME – local interpretable model-agnostic explanations (charter Part 1, Phase 3; theory: xai_context.aDNA's technique_lime.md).
 
 linear_algebra.hpp
 Small, dense linear-system solve – shared by weighted_linear_regression.hpp (Phase 3's LIME/KernelSHAP) and gaussian_process.hpp (this campaign's GP-BO surrogate).
 
 linear_module.hpp
 Dense/fully-connected layer – the reference Module implementation.
 
 linear_probe.hpp
 Linear probe – trains one linear classifier to decode a binary concept from a layer's activations, answering "is this concept linearly represented here?".
 
 lm_scoring.hpp
 Prompt/completion data for a causal language model (LLM-10): read it from JSONL, batch it with the prompt masked out of the loss, and score it, as log P(completion | prompt) or as the probabilities of a few single-token choices ("P(True)").
 
 lora.hpp
 LoRA (Hu et al., 2021): fine-tune a frozen model through a low-rank update on each of its Linear layers, merge it into the weights or take it out again, and save and load it as a PEFT adapter.
 
 loreft.hpp
 LoReFT (Wu et al., 2024): fine-tune a frozen language model by editing its hidden states in a learned low-rank subspace, at a few positions after chosen layers, and explain the edit with LRP.
 
 lr_scheduler.hpp
 Learning-rate schedules (warmup, constant, linear, cosine) and a scheduler that applies one to an optimizer and its parameter groups (roadmap TRN-4).
 
 lrp.hpp
 LRP – whole-model Layer-wise Relevance Propagation explainer.
 
 lrp_conservation.hpp
 Production API for LRP's conservation-delta audit metric (charter Phase 4).
 
 lrp_rule_config.hpp
 Selects which LRP rule variant a Module::propagate_relevance() call uses.
 
 lstm_module.hpp
 Single-layer LSTM – this codebase's first gated recurrent module.
 
 mamba_module.hpp
 Mamba/S6 selective-state-space recurrence with the MambaLRP relevance rule.
 
 masked_diffusion.hpp
 Sampling from a masked diffusion language model (DIFF-2): start from a sequence with masked positions and fill them over a number of steps, recording the whole trajectory so it can be explained afterwards (DIFF-3). DPLM's remasking sampler (DIFF-4) also takes positions back.
 
 masked_diffusion_lrp.hpp
 Explaining a masked diffusion LM's generation (DIFF-3): commitment-graph LRP, which explains tokens written at any step back to the prompt by chaining AttnLRP through the tokens committed in between, and the checks that test it by replaying the trajectory.
 
 matrix_decompositions.hpp
 Small dense decompositions on the host: symmetric eigensolver, power iteration, QR and SVD (roadmap FND-4).
 
 max_pool2d_module.hpp
 2D max pooling with a stride and padding (non-overlapping windows by default).
 
 metrics_sink.hpp
 Keeps monitoring/visualization tools out of the training core – same OCP/DIP pattern as DeviceBackend/ExplainerContext.
 
 mlp_hook.hpp
 Reads or replaces a transformer block's MLP output during forward() (FEAT-5), for collecting a transcoder's training pairs and splicing it in.
 
 mnist_classifier_example.hpp
 Real MNIST classifier: Conv2DModule -> ReluModule -> FlattenModule -> LinearModule -> CrossEntropyLoss, mirroring XorNetwork's training-loop pattern and grad_cam_mnist_demo.cpp's network shape exactly.
 
 mnist_dataset_adapter.hpp
 Adapts a pre-loaded MnistDataset onto the generic Dataset interface.
 
 mnist_loader.hpp
 Parses real MNIST IDX/ubyte files (fetched by tools/fetch_mnist.py) into Tensor images and integer labels.
 
 module.hpp
 Abstract base every layer subclasses – NVI forward(), pure-virtual LRP contract.
 
 mse_loss.hpp
 Mean squared error loss.
 
 multihead_attention_module.hpp
 Multi-head scaled dot-product attention – this codebase's first Module composed out of other real Modules, plus AttnLRP's Eq. 15 bilinear relevance rule.
 
 mutation.hpp
 Genetic-algorithm mutation operators: bit-flip (generic boolean genotypes) and Gaussian, polynomial (real-valued genotypes).
 
 nearest_neighbors.hpp
 Nearest neighbors over embeddings or activations, mutual nearest neighbors, and mutual-kNN alignment between two representations.
 
 neat_evolution.hpp
 NEAT's own generational evolutionary loop: fitness evaluation, speciation, fitness sharing, proportional offspring allocation, and mutation-only reproduction.
 
 neat_genome.hpp
 NEAT genome (Stanley & Miikkulainen, "Evolving Neural Networks through Augmenting Topologies," Evolutionary Computation 10(2), 2002): a connection-gene list with global historical markings (innovation numbers) plus the two structural mutations (add-connection, add-node) that grow topology from a minimal starting point.
 
 neat_phenotype.hpp
 Decodes a NEATGenome into an evaluable phenotype: a forward pass over the genome's own irregular connection graph.
 
 neat_speciation.hpp
 NEAT speciation (Stanley & Miikkulainen 2002): a compatibility-distance metric over two genomes' gene lists, population grouping by that metric, and fitness sharing – the mechanism that protects a structurally novel but not-yet-optimized genome from being immediately out-competed before its innovation has a chance to be refined.
 
 neat_xor_fitness.hpp
 XOR fitness function for NEAT – Stanley & Miikkulainen 2002's own validation task, chosen here for the same reason it was chosen there: XOR is the canonical not-linearly-separable problem, so a genome that solves it starting from a fully connected (no-hidden-node) minimal topology has genuinely grown new structure to do so, not merely tuned weights on an already-sufficient network shape.
 
 negation_module.hpp
 Standard fuzzy negation y = 1 - x – Phase 1 Mission 0 of campaign_exai_dl_library_neuro_symbolic (differentiable fuzzy-logic core).
 
 neuro_symbolic_datalog_bridge.hpp
 Wires a real neural predicate (LinearModule + sigmoid, reusing Phase 1 Mission 2's ToyKnowledgeBase pattern) into the weighted Datalog engine as one base fact's weight, on a small diamond-graph transitive-closure toy program (Mission 0/1's own ancestor shape). Computes the gradient of a derived query fact's weight w.r.t. the neural predicate's output (via forward-mode AD over the provenance semiring, see datalog_dual_semiring.hpp) and, transitively, the predicate's LinearModule parameters (via that module's own real backward(), mirroring ToyKnowledgeBase's hand-chained-Module::backward() precedent). Phase 3 Mission 2 of campaign_exai_dl_library_neuro_symbolic (Neural-Predicate Integration).
 
 neuro_symbolic_toy_kb.hpp
 Toy knowledge-base training demo – Phase 1 Mission 2 of campaign_exai_dl_library_neuro_symbolic (differentiable fuzzy-logic core's own correctness oracle: proves Missions 0-1's operators compose into a real, trainable Logic Tensor Network).
 
 node.hpp
 Computation graph node – op type, shape, optional label, parent/child edges.
 
 noise_schedule.hpp
 DDPM noise schedules (linear and cosine): precomputed beta/alpha/alpha_bar, forward noising, and DDPM and DDIM reverse steps.
 
 nsga2.hpp
 NSGA-II multi-objective survivor selection (Deb, Pratap, Agarwal, Meyarivan, "A Fast and Elitist Multiobjective Genetic Algorithm: NSGA-II," IEEE TEVC 6(2), 2002): fast non-dominated sorting, crowding distance, and truncation selection.
 
 null_model_baseline.hpp
 The baseline rule as one call (roadmap XAI-6): run any explainer, probe or featurizer on the trained model and on a re-initialized ("null") model, and compare.
 
 op_type.hpp
 Closed set of operation categories every graph Node is tagged with.
 
 param_groups.hpp
 Optimizer parameter groups: a learning rate and weight decay per set of parameters, chosen by name (roadmap TRN-1).
 
 parameter_decomposition.hpp
 Parameter decomposition (FEAT-9): explaining a network in weight space. Each weight matrix is split into rank-one subcomponents, and training asks that, for every input, few of them be needed to compute the output. SPD (Bushnaq, Braun and Sharkey, "Stochastic Parameter Decomposition", arXiv 2506.20790) and VPD (Bushnaq et al., "Interpreting Language Model Parameters", Goodfire, 2026: adversarial parameter decomposition) are both here, after their reference code (github.com/goodfire-ai/ param-decomp: tag v1 for SPD, nano_param_decomp for VPD).
 
 pbt.hpp
 Population Based Training (Jaderberg et al. 2017, "Population Based Training of Neural Networks"): a population of live, incrementally-trained trials periodically truncation-selected – the bottom fraction exploits (copies weights and hyperparameters from a uniformly-randomly-chosen top performer) then explores (perturbs the copied hyperparameters) – producing a hyperparameter schedule (different effective hyperparameters at different points in training) rather than a single fixed configuration.
 
 pbt_trial.hpp
 Extends the sibling HPO campaign's own ResumableTrial (successive_halving.hpp) with the weight/hyperparameter read-write capability Population Based Training's own exploit/explore step needs.
 
 pca.hpp
 Principal component analysis of a layer's representations (INT-5): 2D and 3D views, directions to steer along, and fewer dimensions for what comes after.
 
 pdp.hpp
 Partial Dependence Plot – a global marginal-effect technique, sweeping one feature's value while averaging the model's response over a background set (charter addition 2026-09-19, see charter Decisions Log).
 
 performance.hpp
 How well a model does (KS-3): a classifier's accuracy, log loss, Brier score, calibration and per-class scores; a regressor's errors; and the error on each slice of the data, with a test of whether a slice is worse than the rest.
 
 policy_gradient_loss.hpp
 REINFORCE's return-weighted negative log-likelihood loss over a batched rollout.
 
 polyak_update.hpp
 Soft (Polyak / exponential-moving-average) target-network update, as used by SAC.
 
 ppo_clipped_loss.hpp
 PPO's clipped surrogate objective (Schulman et al. 2017) over a batched rollout.
 
 probe_controls.hpp
 Linear probes with controls (INT-3): a multi-class probe trainer, Hewitt and Liang's control task and selectivity, and a comparison against a baseline representation.
 
 protein_concepts.hpp
 What a protein language model's representations encode (PLM-8): per-residue concepts from Swiss-Prot annotations, per-layer linear probes with control tasks, and sparse autoencoder features matched to the concepts, as InterPLM does.
 
 protein_contacts.hpp
 Residue contacts from a protein language model's attention (PLM-4): ESM's contact head, the top-K head average, and precision at L, L/2 and L/5 against a structure's contacts.
 
 protein_explanations.hpp
 Explaining a protein language model residue by residue (PLM-6): AttnLRP from a masked residue's prediction, a mutation's log-odds or a head on the representations back to the input residues, and the checks that keep such explanations honest.
 
 protein_sequences.hpp
 Protein sequence input (PLM-2): ESM's tokenizer from its vocab.txt, and FASTA files.
 
 protein_structure.hpp
 Protein structures (PLM-4): PDB and mmCIF coordinates, residue distances and true contacts, to check a protein language model's predicted contacts against.
 
 protein_training.hpp
 Training protein language models (PLM-7): ESM-2's masked-LM data pipeline (masking, cropping, cluster-weighted sampling), its initialization, a training step and evaluation, and heads for fine-tuning on per-protein and per-residue labels.
 
 proteingym.hpp
 Running ProteinGym's deep-mutational-scanning substitution benchmarks (PLM-3): read an assay, score every variant with a protein language model, and compute ProteinGym's metrics.
 
 prototypes.hpp
 Explaining by example (XAI-4): the background inputs nearest one input that the model treats the same way and differently, and ProtoDash's weighted prototypes that summarize a dataset (Gurumoorthy, Dhurandhar, Cecchi and Aggarwal, ICDM 2019).
 
 relevance_graph.hpp
 A language model's attribution graph from AttnLRP (VIZ-4): how relevance for one predicted token flows from the input tokens through every layer's residual stream, ready for Neuronpedia's and circuit-tracer's graph viewers.
 
 relu_module.hpp
 ReLU activation – the second Module subclass, following LinearModule's pattern.
 
 reparameterize.hpp
 VAE reparameterization trick: z = mu + exp(log_sigma) * epsilon.
 
 replay_buffer.hpp
 Off-policy experience replay: fixed-capacity circular transition store + sampling.
 
 representation_geometry.hpp
 One number per layer for the shape of its representations: anisotropy, effective rank and TwoNN intrinsic dimension.
 
 representation_similarity.hpp
 How similar two layers' representations of the same inputs are: linear CKA, RSA and SVCCA.
 
 residual_module.hpp
 Generic skip-connection wrapper – Phase 4's only mission, the ResNet-style residual block generalized past a fixed Conv-BN-ReLU stack to any Module.
 
 retnet_module.hpp
 RetNet retention mechanism (recurrent mode), with an original derived LRP rule (no published rule exists for RetNet – see the class-level note).
 
 rms_norm_module.hpp
 RMS normalization layer (Zhang & Sennrich, 2019) – this codebase's first normalization Module, establishing the Tier 1 pattern for GroupNorm/LayerNorm.
 
 rnn_module.hpp
 Vanilla (Elman) recurrent layer – this codebase's first recurrent module.
 
 rollout_buffer.hpp
 On-policy trajectory storage: fill-once fixed-length rollout + discounted returns.
 
 rope_module.hpp
 Rotary Position Embedding – fixed per-position pair rotation, epsilon-rule LRP.
 
 rule_extraction.hpp
 Rules from trees, run by the Datalog engine (roadmap KD-3): a surrogate or distilled tree becomes a Datalog program that classifies the same way.
 
 rwkv_module.hpp
 RWKV-4 time-mixing (WKV linear-attention) recurrence, with an original derived LRP rule adapting MambaLRP's detach-the-gate technique to the WKV quotient (see the class-level note).
 
 safetensors.hpp
 Native safetensors reader and writer (roadmap IO-1): the one file format pulsatrix reads and writes for weights.
 
 saliency.hpp
 Saliency maps – raw gradient of a target output w.r.t. the input (charter Part 1, Phase 2).
 
 sampler.hpp
 Index-order abstraction for DataLoader – SequentialSampler, ShuffleSampler.
 
 satisfaction_loss.hpp
 Real-Logic-style knowledge-base satisfaction loss – Phase 1 Mission 1 of campaign_exai_dl_library_neuro_symbolic.
 
 search_space.hpp
 Typed hyperparameter search-space description: named parameters, each continuous, log-uniform, integer, or categorical.
 
 selection.hpp
 Genetic-algorithm selection operators (tournament, roulette/fitness-proportionate, linear-rank) over a population of Individual<Genotype, FitnessT>.
 
 sensitivity.hpp
 Local sensitivity: one-at-a-time input changes and occlusion (CFS-3).
 
 sentencepiece_bpe.hpp
 The components SentencePiece-style BPE tokenizers are built from (TOK-3): spaces as ▁ (Replace, Prepend or Metaspace), byte fallback in BpeModel (BpeOptions::byte_fallback), and the decoder chain that undoes them, each following Hugging Face tokenizers. Gemma 3, Llama 2, Mistral and TinyLlama tokenize this way.
 
 sequential_module.hpp
 Model container – chains a sequence of existing Modules.
 
 sgd_optimizer.hpp
 Stochastic gradient descent – operates uniformly across any Module's parameters().
 
 shape.hpp
 Tensor dimension arithmetic – rank, element count, per-dimension access.
 
 sinusoidal_timestep_embedding.hpp
 Fixed sinusoidal encoding of a diffusion timestep, for conditioning a denoiser.
 
 soft_decision_tree.hpp
 A soft decision tree (Frosst and Hinton, "Distilling a Neural Network Into a Soft Decision Tree", 2017): an interpretable student for a network teacher (roadmap KD-3).
 
 softmax_module.hpp
 Rank-agnostic softmax over the last axis, with AttnLRP's Eq. 13 DTD relevance rule.
 
 sparse_autoencoder.hpp
 Sparse autoencoder – reconstructs an activation through an overcomplete, L1-penalized hidden layer, decomposing it into a larger, sparser basis.
 
 steering.hpp
 Steering a model by adding a direction to its residual stream (FEAT-7), with difference-of-means as the default direction, a featurizer's decoder direction as an option, and a report on how reliably steering works.
 
 subtb_loss.hpp
 GFlowNet SubTB(lambda) loss (Madan et al., "Learning GFlowNets from partial episodes for improved convergence and stability", arXiv:2209.12782).
 
 successive_halving.hpp
 Successive Halving (the rung-based promotion mechanism underlying Hyperband and ASHA, Li, Jamieson, DeSalvo, Rostamizadeh, Talwalkar, "Hyperband: A Novel Bandit-Based Approach to Hyperparameter Optimization," JMLR 2018): train a population of configurations for a small budget, keep the best fraction, repeat with a larger budget, until one survives.
 
 surrogate_tree.hpp
 A global surrogate: a shallow decision tree fitted to a model's predictions, with its fidelity to the model on held-out inputs (XAI-4; TREPAN, Craven and Shavlik 1996).
 
 survivor_selection.hpp
 Survivor-selection policies for the evolutionary-loop skeleton (evolutionary_loop.hpp): generational replacement, (mu+lambda), (mu,lambda).
 
 swiglu_module.hpp
 SwiGLU gated feedforward block – second module composed from real LinearModule sub-objects, plus a diagonal specialization of AttnLRP's Eq. 15 bilinear rule.
 
 system_monitor.hpp
 Live CPU/GPU utilization, memory and temperature monitoring with a streaming log.
 
 system_monitor_detail.hpp
 SystemMonitor internals exposed for unit tests: the platform-source interface, the filesystem-rooted Linux parsers, and the log record encoders.
 
 tagger_finetune_example.hpp
 A full fine-tuning recipe (roadmap TRN-6): pretrain a tiny transformer tagger on one rule, save it, reload it and fine-tune every parameter on a related rule.
 
 tanh_gaussian_policy.hpp
 SAC's reparameterized, tanh-squashed Gaussian policy sampling (action + log-prob).
 
 tcav.hpp
 Testing with Concept Activation Vectors (INT-6): how much a concept, given only by examples, pushes a model towards a class, and whether that's more than chance.
 
 tensor.hpp
 N-dimensional tensor – owns a buffer via DeviceBackend*, RAII (Rule of Five).
 
 text_collate.hpp
 PadCollate – right-pads variable-length token sequences into one batch Tensor.
 
 text_dataset.hpp
 Line-delimited corpus Dataset – tokenizes and indexes each line into a Tensor.
 
 text_tokenizer.hpp
 The tokenizer interface (TOK-1): a pipeline of normalizer, pre-tokenizer, model, post-processor and decoder, as in Hugging Face tokenizers, with added tokens split out first. encode() returns ids, token strings, offsets into the input and a special- token mask; decode() returns text.
 
 tied_lm_head_module.hpp
 Language-model head that reuses an EmbeddingModule's table as its weight (LLM-2).
 
 token_cross_entropy_loss.hpp
 Cross-entropy over a batch of tokens, with padding ignored and a caller-chosen normalizer for exact gradient accumulation (roadmap TRN-5).
 
 tokenizer.hpp
 Minimal deterministic whitespace/punctuation word-level tokenizer.
 
 tokenizer_components.hpp
 Pipeline components for TextTokenizer (TOK-1), and the word-level, byte and character tokenizers built from them.
 
 tokenizer_json.hpp
 Loads a Hugging Face tokenizer.json into a TextTokenizer (TOK-2).
 
 tokenizer_parity.hpp
 Compares a TextTokenizer with Hugging Face tokenizers on a reference corpus (TOK-2), as written by tools/tokenizers/make_tokenizer_reference.py.
 
 top_k.hpp
 Top-k selection along a tensor's last dimension, on any device (roadmap FND-3).
 
 topk_sparse_autoencoder.hpp
 The TopK sparse autoencoder (FEAT-2; Gao et al., "Scaling and evaluating sparse autoencoders", arXiv 2406.04093): sparsity set directly by keeping each input's k largest latents, with an auxiliary loss that revives dead latents. Two variants (FEAT-4): BatchTopK (Bussmann et al., arXiv 2412.06410) and Matryoshka (Bussmann et al., arXiv 2503.17547).
 
 tpe.hpp
 Tree-structured Parzen Estimator (Bergstra, Bardenet, Bengio, Kegl, "Algorithms for Hyper-Parameter Optimization," NeurIPS 2011) – a structurally distinct second surrogate family from GP-BO (gp_bo.hpp), handling mixed/categorical search spaces GP-BO's own vanilla kernel cannot (gp_bo.hpp restricts to Continuous/LogUniform; this file supports every ParameterKind).
 
 trajectory_balance_loss.hpp
 GFlowNet Trajectory Balance loss (Malkin et al. 2022, arXiv:2201.13259).
 
 trajectory_lrp.hpp
 Explaining a continuous diffusion sampler end to end (DIFF-5): trajectory LRP (design D1), which seeds a scalar of the final sample x_0 once and carries its relevance back through every reverse step to the starting noise x_T, the conditioning, and named sinks.
 
 transcoder.hpp
 Transcoders and skip transcoders (FEAT-5): sparse, wide replacements for an MLP that predict its output from its input (Dunefsky et al., "Transcoders Find Interpretable LLM Feature Circuits", arXiv 2406.11944), optionally beside a linear skip connection (Paulo et al., "Transcoders Beat Sparse Autoencoders for Interpretability", arXiv 2501.18823).
 
 transform.hpp
 Sample-level preprocessing abstraction – Transform, Compose, TransformDataset.
 
 transformer_block.hpp
 Pre-LN transformer block – Phase 3's literal exit-gate deliverable, third and last composition mission (RMSNorm x2, MultiHeadAttentionModule, SwiGLUModule, plus the resolved residual-split LRP rule).
 
 trial.hpp
 A single hyperparameter-optimization trial: the configuration tried, plus every metric value recorded against it.
 
 uncertainty.hpp
 How sure a model is of each prediction (KS-3): Monte Carlo dropout (Gal and Ghahramani, ICML 2016), deep ensembles (Lakshminarayanan, Pritzel and Blundell, NeurIPS 2017), and the split of a prediction's uncertainty into the part more data would remove and the part it wouldn't.
 
 unicode_regex.hpp
 A small backtracking regex engine over Unicode code points, for the pre-tokenizer patterns in tokenizer.json files (TOK-2). std::regex can't match Unicode categories.
 
 variant_scoring.hpp
 Zero-shot variant effects from a protein language model (PLM-3): how much the model prefers a mutant residue over the wild type, with no training on the protein.
 
 video_frame_directory_dataset.hpp
 Directory-of-pre-extracted-frames video Dataset (reduced-scope stub, no codec decode).
 
 video_transforms.hpp
 Frame-sampling Transform – selects a fixed number of evenly-spaced frames.
 
 vision_models.hpp
 torchvision's ResNet and VGG, built from pulsatrix layers with torchvision's parameter names, so their published ImageNet weights load once converted to safetensors (KS-9).
 
 vocabulary.hpp
 Token<->index lookup with a reserved <unk> fallback, plus a frequency-ranked builder.
 
 wav_reader.hpp
 Hand-rolled 16-bit PCM WAV decoder.
 
 weighted_linear_regression.hpp
 Weighted least squares via normal equations – the shared fitting primitive Phase 3's LIME and KernelSHAP explainers both reduce to.
 
 word_scores.hpp
 Per-word scores from per-token scores (TOK-4): explanations are made per token but read per word, so relevance, attributions or probe outputs are merged into the words of the input using the tokenizer's offsets.
 
 xor_training_example.hpp
 Phase 1's training-loop proof: Linear(2,4)->ReLU->Linear(4,1) learning XOR.