|
| | 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 |
| |
| | 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.
|
| |