initium-deeplearning 0.1.0__py3-none-any.whl

initium/setup_wheels.py

@@ -0,0 +1,175 @@
+"""Install the CUDA-matched binary wheels that PyPI metadata cannot express.
+
+Run once after installing initium:
+
+    initium-setup                # or: python -m initium.setup_wheels
+    initium-setup --dry-run      # print the commands only
+
+What it does (stdlib only, no torch reinstall):
+  1. pytorch-dnc from git (PyPI's `dnc` is stale; direct URLs are forbidden in PyPI metadata).
+  2. mamba-ssm + causal-conv1d prebuilt wheels matching the ACTIVE torch/CUDA build, from
+     the wheel index, so nothing is compiled locally.
+Steps that are already satisfied are skipped, so re-running is cheap.
+"""
+
+from __future__ import annotations
+
+import argparse
+import importlib.util
+import json
+import shlex
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from importlib import metadata
+
+WHEEL_INDEX_TEMPLATE = "https://wheels.astral.sh/simple/{cuda_tag}/"
+MAMBA_SSM_VERSION = "2.3.2.post1"
+CAUSAL_CONV1D_VERSION = "1.6.2.post1"
+DNC_SOURCE = "git+https://github.com/ixaxaar/pytorch-dnc.git"  # pin "@<sha>" for reproducibility
+SKIPPABLE = ("dnc", "gpu-wheels")
+
+
+@dataclass(frozen=True)
+class TorchEnv:
+    version: str  # "2.10.0"
+    major_minor: str  # "2.10"
+    cuda: str | None  # "12.8", or None for CPU-only torch
+
+    @property
+    def cuda_tag(self) -> str | None:
+        return None if self.cuda is None else "cu" + self.cuda.replace(".", "")
+
+
+def detect_torch() -> TorchEnv:
+    try:
+        import torch
+    except ImportError as exc:
+        raise SystemExit(
+            "PyTorch is required to install GPU wheels. Install a compatible PyTorch build first."
+        ) from exc
+    version = torch.__version__.split("+", 1)[0]
+    return TorchEnv(version, ".".join(version.split(".")[:2]), torch.version.cuda)
+
+
+def gpu_requirements(env: TorchEnv) -> list[str]:
+    local = f"+cu.{env.cuda}.torch.{env.major_minor}"
+    return [
+        f"mamba-ssm=={MAMBA_SSM_VERSION}{local}",
+        f"causal-conv1d=={CAUSAL_CONV1D_VERSION}{local}",
+    ]
+
+
+def resolve_installer(choice: str) -> str:
+    if choice != "auto":
+        return choice
+    if importlib.util.find_spec("pip") is not None:
+        return "pip"
+    if shutil.which("uv") is not None:
+        return "uv"
+    raise SystemExit("Neither pip nor uv is available in this environment.")
+
+
+def _base_cmd(installer: str) -> list[str]:
+    if installer == "pip":
+        return [sys.executable, "-m", "pip", "install"]
+    return ["uv", "pip", "install", "--python", sys.executable]
+
+
+def dnc_command(installer: str) -> list[str]:
+    force = ["--force-reinstall"] if installer == "pip" else ["--reinstall-package", "dnc"]
+    return [*_base_cmd(installer), *force, "--no-deps", DNC_SOURCE]
+
+
+def gpu_command(installer: str, requirements: list[str], index_url: str) -> list[str]:
+    cmd = _base_cmd(installer)
+    if installer == "uv":
+        # uv's default "first-index" strategy would stop at PyPI (which lacks the +cu local
+        # versions) and never look at the extra index.
+        cmd += ["--index-strategy", "unsafe-best-match"]
+    return [*cmd, *requirements, "--extra-index-url", index_url]
+
+
+def _installed_version(dist: str) -> str | None:
+    try:
+        return metadata.version(dist)
+    except metadata.PackageNotFoundError:
+        return None
+
+
+def _dnc_from_git() -> bool:
+    try:
+        raw = metadata.distribution("dnc").read_text("direct_url.json")
+    except metadata.PackageNotFoundError:
+        return False
+    return raw is not None and "vcs_info" in json.loads(raw)
+
+
+def _gpu_satisfied(requirements: list[str]) -> bool:
+    for req in requirements:
+        name, version = req.split("==", 1)
+        if _installed_version(name) != version:
+            return False
+    return True
+
+
+def _parse_args(argv: list[str] | None) -> argparse.Namespace:
+    p = argparse.ArgumentParser(
+        prog="initium-setup",
+        description="Install CUDA-matched mamba-ssm / causal-conv1d wheels and pytorch-dnc (git).",
+    )
+    p.add_argument("--installer", choices=("auto", "pip", "uv"), default="auto")
+    p.add_argument(
+        "--skip",
+        nargs="+",
+        choices=SKIPPABLE,
+        default=[],
+        metavar="STEP",
+        help=f"steps to skip: {', '.join(SKIPPABLE)}",
+    )
+    p.add_argument(
+        "--wheel-index",
+        default=WHEEL_INDEX_TEMPLATE,
+        help="wheel index URL; may contain the {cuda_tag} placeholder (e.g. cu128)",
+    )
+    p.add_argument("--force", action="store_true", help="reinstall even if already satisfied")
+    p.add_argument("--dry-run", action="store_true", help="print commands without running them")
+    return p.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv)
+    installer = resolve_installer(args.installer)
+
+    plan: list[tuple[str, list[str]]] = []
+    if "dnc" not in args.skip and (args.force or not _dnc_from_git()):
+        plan.append(("pytorch-dnc (git)", dnc_command(installer)))
+    if "gpu-wheels" not in args.skip:
+        env = detect_torch()
+        print(f"[initium-setup] torch={env.version} cuda={env.cuda or 'none (CPU build)'}")
+        if env.cuda_tag is None:
+            print("[initium-setup] CPU-only torch: skipping mamba-ssm/causal-conv1d (need CUDA).")
+        else:
+            reqs = gpu_requirements(env)
+            if args.force or not _gpu_satisfied(reqs):
+                index = args.wheel_index.format(cuda_tag=env.cuda_tag)
+                plan.append(("GPU wheels", gpu_command(installer, reqs, index)))
+
+    if not plan:
+        print("[initium-setup] nothing to do - everything is already installed.")
+        return 0
+    for label, cmd in plan:
+        print(f"[initium-setup] {label}: {shlex.join(cmd)}")
+        if args.dry_run:
+            continue
+        try:
+            subprocess.run(cmd, check=True)
+        except subprocess.CalledProcessError as exc:
+            print(f"[initium-setup] FAILED ({label}), exit code {exc.returncode}", file=sys.stderr)
+            return exc.returncode
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

initium_deeplearning-0.1.0.dist-info/METADATA

@@ -0,0 +1,253 @@
+Metadata-Version: 2.5
+Name: initium-deeplearning
+Version: 0.1.0
+Summary: Differentiable Neural Computer research framework with pluggable LSTM/Mamba/CfC controllers, MoE, split-graph and stochastic write heads.
+Project-URL: Homepage, https://github.com/samueleternity/initium
+Project-URL: Issues, https://github.com/samueleternity/initium/issues
+Author: samueleternity
+License-Expression: GPL-3.0
+License-File: LICENSE
+Keywords: differentiable-neural-computer,dnc,liquid-neural-networks,mamba,pytorch
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: dnc>=1.1.0
+Requires-Dist: ncps>=0.0.7
+Requires-Dist: numpy>=1.26
+Requires-Dist: torch>=2.4
+Provides-Extra: real-data
+Requires-Dist: opencv-python>=4.8; extra == 'real-data'
+Requires-Dist: tokenizers>=0.19; extra == 'real-data'
+Provides-Extra: text
+Requires-Dist: tokenizers>=0.19; extra == 'text'
+Provides-Extra: video
+Requires-Dist: opencv-python>=4.8; extra == 'video'
+Description-Content-Type: text/markdown
+
+# Initium
+
+Initium is an experimental research framework for combining a Differentiable Neural Computer (DNC)/augmented memory with interchangeable sequence controllers and task/data pipelines. Its central idea is to keep an explicit, addressable external memory while exploring controllers such as LSTM, Mamba-family state-space models, and closed-form continuous-time (CfC) networks. The code also includes stochastic memory-write regularization, sparse expert layers, split-graph models, memory-structure experiments, and checkpoint-driven inference.
+
+> **Research status:** Alpha and actively changing. Results below are experiment-specific observations, not guarantees that a configuration will reproduce on another machine, code revision, or dataset. This README is deliberately maintained as a working guide: update it when the code, default configuration, or evidence changes.
+
+## What the project is investigating
+
+The project studies how a neural controller can interact with a differentiable external memory on sequential tasks, especially graph traversal. It asks questions at several levels:
+
+1. **Memory and controller:** Can a controller process a sequence and use DNC read/write operations to store and retrieve information needed later?
+2. **Generalization:** How does performance change between the training curriculum and a held-out or out-of-distribution (OOD) evaluation distribution?
+3. **Write regularization:** Does placing a probabilistic prior on each memory write improve generalization, and what are the costs or seed-to-seed variations?
+4. **Compute structure:** Can the controller's sequence computation be parallelized or sparsified while preserving the sequential memory interface?
+5. **Task breadth and deployment:** Can trained checkpoints be evaluated through a common inference interface across graph, text, audio, video, and multimodal tasks?
+
+These are research questions, not all established project claims. In particular, supported dataset interfaces do not imply that every modality has been trained and validated to the same standard as graph traversal.
+
+## High-level flow
+
+```text
+Configuration and random seed
+        │
+        ▼
+Dataset registry ──► task episodes / curriculum ──► batch and sequence tensors
+                                                          │
+                                                          ▼
+                                            Controller + DNC external memory
+                                            ├─ controller processes sequence
+                                            ├─ write head updates memory
+                                            └─ read heads return memory content
+                                                          │
+                                                          ▼
+                                   task loss + optional KL / MoE auxiliary losses
+                                                          │
+                                                          ▼
+                           optimizer, evaluation, logs, checkpoints, curriculum
+                                                          │
+                                                          ▼
+                      checkpoint loader ──► task inference ──► metrics and run logs
+```
+
+The training core delegates task construction and task-specific behavior to a dataset interface. The model combines a selected controller with DNC memory operations. During training, the loop computes task and optional auxiliary objectives, updates model parameters, periodically evaluates ID and OOD performance, advances the curriculum when its criteria are met, writes diagnostics, and saves resumable checkpoints. Inference reconstructs a model from a checkpoint, checks that the requested task and dimensions are supported, creates the task runner, and reports episode metrics. Optional inference caches can reuse eligible results or shared prefixes.
+
+## Architecture and major components
+
+### Differentiable external memory
+
+The DNC supplies a memory matrix and differentiable read/write interface. The memory can retain information beyond a controller's immediate hidden state. Content-based addressing, read heads, and temporal-link structures are part of the underlying DNC implementation. The temporal link matrix has quadratic cost in the number of memory cells, which motivates the project's link-matrix ablations and memory-size investigations.
+
+### Controllers
+
+The training core exposes controller choices through its command-line interface and configuration:
+
+- **LSTM:** baseline recurrent controller.
+- **Mamba:** selective state-space controller.
+- **Mamba-2 and Mamba-3:** additional state-space variants; current experiment notes report that these configurations underperformed in earlier tests and need further investigation.
+- **CfC:** closed-form continuous-time controller.
+- **Hybrid chains:** compositions of supported controller stages, such as a Mamba/CfC sequence.
+- **Split-graph:** a parallel sequence backbone plus a separate combiner for the sequential memory-addressing work. It is an experimental way to expose more of the controller computation to parallel execution while retaining the memory interface and currently performs the best out of all options.
+
+Some options require optional or hardware-sensitive dependencies, particularly `mamba-ssm` and `causal-conv1d`. A controller being selectable in code should not be read as evidence that it is equally mature or portable on every platform.
+
+### Stochastic writes and KL regularization
+
+The write-head extension models a write vector as a diagonal Gaussian. It can sample a write using the reparameterization trick and add a KL penalty to a prior distribution. The implementation supports a fixed standard-normal prior and a learned prior updated from recent write statistics on a periodic, detached snapshot schedule. The loss can include KL annealing and free bits; the learned-prior path logs its snapshot state separately.
+
+The intended locality distinction is important: the per-write KL is computed from the current write distribution and a prior snapshot. In the learned-prior variant, the prior itself is fitted from recent writes periodically, outside the per-step gradient path. That makes the overall mechanism periodically data-conditioned even though the per-write calculation uses the current write and frozen prior snapshot.
+
+Also KL regularization has specific, uninvestigated behaviour: it tends to stabilize grad_norms allowing the model to not collapse (detected once and needs further investigations) - it was mildly visible in graph-traversal experiments but its full strength occured in multimodal tasks where a model managed to collapse in lesson 14 with beta=0.0, meanwhile with beta=0.001(KL term active) the same model kept going with no issues.
+
+### Other experimental mechanisms
+
+- **Mixture of Experts (MoE):** sparse expert feed-forward capacity with routing and load-balancing diagnostics. The current project notes caution that this overhead may be unnecessary or harmful at smaller model sizes; its motivation is future scaling, not a demonstrated benefit for the current compact experiments.
+- **Dynamic memory size (Dynamic-N):** usage-triggered growth of the memory cell array within configured bounds.
+- **Link-matrix options:** ablations or sparsification of temporal-link computation.
+- **Dynamic beta:** an optional bounded controller for the KL weight, distinct from a fixed-beta sweep.
+- **Multimodal and real-data loaders:** interfaces for synthetic and selected real text, audio, video, graph, and multimodal inputs. Their practical coverage and validation are still evolving.
+
+## Repository map
+
+| Path | Role |
+| --- | --- |
+| `src/initium/core_training.py` | Dataset-agnostic training loop, CLI, evaluation, logging, checkpointing, and orchestration of model options. |
+| `src/initium/config/` | Training, regularization, controller, and architecture defaults. |
+| `src/initium/data/` | Dataset registry, task episodes, curriculum/data handling, codecs, and real-data utilities. |
+| `src/initium/mamba_controller/` | DNC controller integration, Mamba variants, hybrid controllers, and split-graph implementation. |
+| `src/initium/LNN_controller/` | CfC and hybrid continuous-time controller implementations. |
+| `src/initium/memory_manipulation/` | Stochastic write heads, prior snapshots, memory resizing, link-matrix ablations, and compatibility helpers. |
+| `src/initium/MoE/` | Sparse expert layer and its local usage notes. |
+| `src/initium/inference/` | Checkpoint loading, task registry, inference engine, metrics, logging, and cache support. |
+| `setup_wheels.py` | Environment/dependency setup entry point for specialized wheels. |
+| `pyproject.toml` | Package metadata, base and optional dependencies, and development tooling groups. |
+
+## Setup
+
+The PyPI distribution is named `initium-deeplearning`; its Python import package is `initium`. The project targets Python 3.10 or later. Core dependencies are declared in `pyproject.toml`; accelerated state-space controllers may need platform-specific PyTorch/CUDA wheels and additional packages. Install the project and optional task dependencies in an environment appropriate to your hardware. For specialized dependency setup, inspect the repository's `setup_wheels.py` and its help output before running it; GPU package compatibility depends on the installed PyTorch, CUDA, and Python versions.
+
+Typical editable installation for development:
+
+```bash
+python -m pip install -e .
+```
+
+Optional dependencies are grouped by modality, for example `text`, `video`, and `real-data` in the project metadata. Audio/video processing may also rely on system tools such as FFmpeg. Mamba-family components can require packages beyond the base install. The default training path is intended to be usable without those optional controller dependencies.
+
+The source tree is packaged as `initium`; internal modules use the `initium.*` namespace.
+
+## Training
+
+The main entry point is `src/initium/core_training.py`. From the repository root, inspect the available arguments with:
+
+```bash
+python -m initium.core_training --help
+```
+
+The script accepts a positional KL weight (`beta`); omitting it runs the configured beta sweep. It also accepts a random seed and controller/task/architecture options. A representative graph-task run with the Mamba controller and the dynamic-memory/split-graph experiments enabled is:
+
+```bash
+python -m initium.core_training 0.0 --seed 0 --controller mamba --dynamic-n-mode --split-graph
+```
+
+This is an example of the CLI shape, not a universal best configuration. Check `src/initium/config/train_config.py` and `src/initium/config/controller_config.py` for the defaults in the checkout you're running. In particular, training duration, model size, beta sweep, dataset, evaluation cadence, and memory options may have changed since older experiment records were produced.
+
+Training runs typically produce:
+
+- periodic and final checkpoints, including model, optimizer, random-generator, curriculum, and architecture/prior state needed to resume or evaluate;
+- step-level or periodic logs for task loss, KL, accuracy, OOD evaluation, and training health;
+- additional CSV diagnostics for learned-prior snapshots and optional architecture features;
+- a run identifier that encodes relevant settings to reduce accidental collisions.
+
+Keep seeds, source revision, full command, configuration, device/dependency versions, and evaluation protocol with any result you intend to compare. A single final metric is not enough to characterize these experiments: curriculum position, checkpoint step, sampled versus deterministic writes, and evaluation sample count can change the interpretation.
+
+## Evaluation and inference
+
+The checkpoint-based inference CLI lives at `src/initium/inference/run_inference.py`. Its help output is the current reference for arguments:
+
+```bash
+python -m initium.inference.run_inference --help
+```
+
+The command accepts a checkpoint, task type, optional data link, episode count, seed, device, and task-specific settings. It can inspect checkpoint capabilities, compare reset and persistent experience modes, report memory-ablation behavior, and optionally configure inference caches. A basic invocation has this form:
+
+```bash
+python -m initium.inference.run_inference path/to/checkpoint.pt --dataset-type graph
+```
+
+The loader checks checkpoint/task compatibility and refuses unsupported task types or dimensions. Graph, text, audio, and video task runners are registered; multimodal execution is also represented in the code but its input dimensions depend on the selected modality combination. Verify the checkpoint's recorded dataset configuration before comparing results across task types.
+
+## Experiments and current evidence
+
+The supplied experiment records describe a staged investigation of a KL penalty on DNC memory writes. They are summarized here as results rather than by the names of the individual working files, so this overview can remain useful if those files are renamed or reorganized. -> If anyone wishes to see the original files, you can create an issue and will be contacted afterwards.
+
+### Fixed-prior multi-seed study
+
+The first study compared a no-KL anchor with a small fixed-prior KL weight over multiple random seeds with --controller lstm. It found meaningful heterogeneity: several seeds showed non-collapsed OOD gains, some showed little benefit, and two seeds showed genuine reversals. The strongest observed seed improved OOD triple accuracy by roughly 11–12 percentage points over its own anchor. The study therefore supports a **conditional** positive result for the tested configuration, not a claim that the effect is universal or statistically settled. The measured OOD perfect-traversal fraction also did not track triple accuracy uniformly, so the metric definition matters.
+
+### Learned-prior study
+
+The follow-up replaced the fixed prior with a prior periodically estimated from recent write statistics. Four deliberately selected seeds were tested: two previous reversal cases and two stronger fixed-prior cases. Outcomes were mixed: the two former reversals improved, one strong case was nearly flat, and the strongest fixed-prior result regressed by about five to six OOD points. Across the four seeds, the mean OOD change was small and not statistically distinguishable from zero; ID accuracy was lower by about 1.1–2.7 points in all four comparisons. Diagnostics did not indicate KL collapse. A regression-to-the-mean explanation is plausible (the reported correlation was large at n=4), but the sample is too small to distinguish that from a true repair of the earlier reversal cases. The structural audit found the learned prior's snapshot update was detached and periodic, with no second online posterior; that is a design characterization, not proof of a generalization benefit.
+
+### Alternate Mamba-controller study
+
+A separate study compared beta 0 and beta 0.001 in a Mamba, dynamic-memory, split-graph configuration across five seeds. The logs showed no statistically clear OOD or ID-to-OOD offset improvement from the KL term; beta 0 had a small nominal OOD edge in four of five seeds. The beta 0.001 runs consistently left the first curriculum lesson later. The comparison is provisional: only one seed reached the final curriculum lesson, four runs were unfinished, and there was no wide-evaluation sweep for that batch. This configuration should not be described as a completed replication of the earlier study because its controller, memory size, training budget, and evaluation coverage differ.
+
+### Evidence boundaries and open work
+
+- Results above apply to the exact runs and evaluation procedures recorded; they do not establish broad performance across modalities, hardware, or model scales.
+- Phase 1's seed variation and Phase 2's four-seed selection limit aggregate claims. Report per-seed values and uncertainty alongside averages.
+- The learned prior's apparent variance-dampening/mean-reversion effect needs more seeds and controls to separate it from failure-mode-specific repair.
+- The alternate Mamba batch needs completion of unfinished seeds and late-curriculum evaluation before a gate-level conclusion.
+- Mamba-2/Mamba-3 performance, MoE's useful scaling regime, memory-link trade-offs, dynamic memory growth, and real-data/multimodal behavior remain active investigation areas.
+- Experiment status can change. Update this section when new runs are verified; retain the method, sample size, seed set, incompleteness, and uncertainty so summaries do not outrun evidence.
+
+## Research foundations
+
+The project draws on several complementary lines of work. These references motivate components and questions; their inclusion does not imply that Initium reproduces each paper's results.
+
+### Differentiable memory and neural sequence models
+
+- Graves et al., **“Hybrid computing using a neural network with dynamic external memory.”** DNC memory, differentiable addressing, and the graph-traversal motivation.
+- Hasani et al., **“Closed-form Continuous-time Neural Networks.”** Continuous-time controller design.
+- Gu and Dao, **“Mamba-3: Improved Sequence Modeling using State Space Principles.”** State-space sequence-modeling direction explored by controller variants.
+- Dao and Gu, **“Transformers are SSMs: Generalized Models and Efficient Algorithms Through Structured State Space Duality.”** Structured state-space/sequence computation background.
+
+### Delta-rule and state-space improvements
+
+- **“Gated Delta Networks: Improving Mamba 2 with Delta Rule.”** Gated delta-rule sequence processing.
+- **“Parallelizing Linear Transformers with the Delta Rule over Sequence Length.”** Parallelization ideas related to sequence-length computation.
+
+### Sparse expert models
+
+- Shazeer et al., **“Outrageously Large Neural Networks: The Sparsely-Gated Mixture-of-Experts Layer.”** Sparse expert routing foundations.
+- Fedus et al., **“Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity.”** Simplified sparse expert scaling.
+- **“Multi-Rate Mixture of Experts for Accelerating Liquid Neural Network Training.”** Motivation for combining expert computation with liquid-network training.
+- **“MoE-Mamba: Efficient Selective State Space Models with Mixture of Experts.”** MoE and selective state-space combination.
+
+### Stochastic regularization and the DNC baseline
+
+- Higgins et al., **“beta-VAE: Learning Basic Visual Concepts with a Constrained Variational Framework.”** Gaussian KL regularization and reparameterized latent sampling adapted here to memory writes.
+- Graves et al., **“Hybrid computing using a neural network with dynamic external memory.”** Baseline memory architecture and task family used by the Q21 study.
+- Additional work on local credit assignment, priors, and continual-learning regularization informed the experiment design and interpretation. Consult the experiment notes for the specific comparisons and caveats.
+
+## Development principles
+
+Because the repository is new and research directions are still changing:
+
+- Prefer describing mechanisms and measured outcomes over calling a configuration “best” without a scoped comparison.
+- Distinguish implemented, exercised, and validated features. A registry entry is implementation coverage, not empirical validation.
+- Preserve negative and mixed results; record the seed, comparison anchor, metric, evaluation window, and incomplete runs.
+- Keep CLI help, configuration defaults, this README, and experiment records aligned as the project evolves.
+- Treat research papers as motivation and technical background, not as evidence that this implementation matches their methods or results unless a reproduction has been explicitly checked.
+
+## License
+
+Initium is distributed under the GNU General Public License v3.0. See [`LICENSE`](LICENSE).
+
+## Publishing to PyPI
+
+Package versions come from `__version__` in `src/__init__.py`. After merging a version update into `main`, create a GitHub Release whose tag matches that version (for example, `v0.1.0`). The `Publish to PyPI` workflow builds and validates the wheel and source distribution, then publishes them automatically. It refuses releases whose tag points to a commit outside `main` or whose tag does not match the package version.
+
+The PyPI distribution name is `initium-deeplearning`; the source directory and import namespace remain `initium`. The configured PyPI Trusted Publisher should target project `initium-deeplearning` with owner `samueleternity`, repository `initium`, workflow `publish-pypi.yml`, and GitHub environment `pypi`. Publishing uses short-lived OIDC credentials, so no PyPI API token is stored in GitHub.

initium_deeplearning-0.1.0.dist-info/RECORD

@@ -0,0 +1,71 @@
+initium/__init__.py,sha256=J-Uw6FY1qiYlb6ykNEfZppHeP82CCoSvWQtJDIKjR_o,65
+initium/core_training.py,sha256=Zjmr1FqbGAlQ4ZI8q9jZD4TYctCZU6bCiIw1KaysPfg,98701
+initium/setup_wheels.py,sha256=B_gThJYtSJSNdsEiQtmt-ZBeCebP0OGogWUxxNToSEk,6037
+initium/LNN_controller/cfc_backbone_parallel.py,sha256=ARTOBZLaUoJzZ2pHBYRRyAbh4lsv8RvuNDSmi2t1ax0,9346
+initium/LNN_controller/cfc_controller.py,sha256=lEUX0S4hU7o1Q45O6HTmk3VlFBym72ZIZ7Q9ClrNhWk,13480
+initium/LNN_controller/chained_controller.py,sha256=Eh07-TxdzPgX-NDa19i5sBK5TMhw7CUf-P6t2QYAJg0,3621
+initium/LNN_controller/hybrid_controller.py,sha256=48p1wIOykG7Wdh9Jh4zdFoG9IQREZcI6SaSVeP6Uz_Q,3668
+initium/MoE/README.md,sha256=JCoF0kWBUraxvSF-JORleBsbp27EYHOsf09ELtid5Ss,306
+initium/MoE/moe_layer.py,sha256=jJP8NDc0WDq9pwMpXFd48Q4ac9zJyjlgvOvTK-a1U3Q,25757
+initium/config/controller_config.py,sha256=Q8z-mWqSaBGbm3MyioskX95T77B4AcBEL0hRRwtc9J4,3669
+initium/config/train_config.py,sha256=h8U3P8jE95hxwksmJLr-EkXv0M5sUwpIBc5Dp8XNBoc,2870
+initium/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/base_dataset.py,sha256=LqPQPRSM_ZbyssEvGjlld4TW46HldGqA048SKJxi_SM,3278
+initium/data/dataset_registry.py,sha256=5bA48eNm5TC6RoK51vdYE7kMVm3TH5rX6fuhCOVhZlk,2687
+initium/data/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/audio/audio_dataset.py,sha256=4wnGuFc3bkN49_WAcQiZxE_nGGQdY2jis4PFVFbHvGg,4141
+initium/data/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/common/chain_task.py,sha256=__YtaJFY65_Y2HYqyDQI-AZxtWwb3fQrhctFrCkB07E,23532
+initium/data/common/digit_codec.py,sha256=jFRkP7DUVOEz9USGh4hgodkjATW85Hcnizf6OVo8uv0,3067
+initium/data/common/graph_io.py,sha256=63KbNyOF26LWs049ZdAUwoTwo-lU7ym5OKZ1D786Ysk,4972
+initium/data/common/real_data.py,sha256=9Kld9kPfsVYhQTNP4ZTpMGFCHYs_UM2TI4oXdG-QGsU,33065
+initium/data/graph_traversal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/graph_traversal/graph_traversal.py,sha256=Z_njRDPeuuT_QtNvmMuSasSJWXAJ9OXdhs7AUtbbajo,29897
+initium/data/multimodal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/multimodal/multimodal_dataset.py,sha256=UVwpKHeZUGDGEJ8IDK4qKW4COYIRX041rqnr96n6tSI,16829
+initium/data/text/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/text/text_dataset.py,sha256=a-w1234N1eOGm9efNOxF65ZTi-THJMoXlIa9k4xsAvM,3372
+initium/data/video/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+initium/data/video/video_dataset.py,sha256=EprUntYkJuY9URTsNf3gSXMNO9hqO7IY3R5OgFjXWVM,3523
+initium/inference/__init__.py,sha256=J0YX8Uaq2ktnD3whEE85lS4QSl1IINHGjhmn3wDSke8,84
+initium/inference/capabilities.py,sha256=3oCXNvGiBMDqyt8z4CqHr1osV0dl7ximi2323QQZXV8,3227
+initium/inference/checkpoint_io.py,sha256=tbEV9SydQkmRSV5ZVYASGVpqj4avXhYEe13yrDanrD0,2605
+initium/inference/engine.py,sha256=1rARwAW1YN0OmhQaXitEMgcddKpCI95A-IS1EZ59WLA,3365
+initium/inference/inference_config.py,sha256=R81LGaynjA7byHoN7is3_ShLisKGIkRGt92Ja1irXOE,869
+initium/inference/metrics.py,sha256=-VlilD57Vt0t9SRVKIT4hNRVotb4dEeiLk-ihE5Ym7s,3474
+initium/inference/model_loader.py,sha256=_C3_B0U-GLvgy4drpDjJVwq-3EmfhSrul2jxUjSYq88,10058
+initium/inference/run_inference.py,sha256=udXlHuK-ipseqdwRunYvewFbGgdaPQpbHMavWvHudok,20816
+initium/inference/run_logging.py,sha256=MtuaGRjnOZmgNllPbU0VyQTUZ3qHn6Y7KiUcQnVdeVA,5889
+initium/inference/cache/__init__.py,sha256=VNu0sYjmWR2q2zw2eJJwjuBW5Nxyyg0ln5uYZXl7j34,89
+initium/inference/cache/base_cache.py,sha256=f0UO1noaBbkW_E1X-psXnwf99u_vV8kAupH7bJKBvuA,3633
+initium/inference/cache/cache_config.py,sha256=6Wfppk4Mg2uoIPnPcoQILbSgtIN1LaPCP4y7d0F8jlE,834
+initium/inference/cache/cache_registry.py,sha256=sv7kE3ZKET0ccdqSFSAO_6I-q2fLkZUMSk1lcDMizu8,3328
+initium/inference/cache/cached_engine.py,sha256=8ye9U966xbfxhyI86Dn9MRHfhn2uxL-PJPniNUmpnwg,11342
+initium/inference/cache/keys.py,sha256=Hb5kFyNDn-4OyJVANNTHjnR2yT-O2gY16-GV-hN2e2k,2444
+initium/inference/cache/prefix_cache.py,sha256=xzBHVwFII-stz4DDfYOKQeNDERtlyt_wiZfJWjZSBTE,2526
+initium/inference/cache/result_cache.py,sha256=Qdh9j5biz0trsRzzHvdIBeDuIY9fdMvJMgsQz9Ff0jc,2152
+initium/inference/cache/state_utils.py,sha256=dbtU5xQ9B28JiVRJsQUSwv7mZxfyTBck-EtUExDdZes,2661
+initium/inference/cache/stores.py,sha256=N9khCDJfdRe4Cv5bFcaYkKxwN2n3YXQhG3dpy0eU21g,4954
+initium/inference/tasks/__init__.py,sha256=lTnmjF9a_sAl6OPwQc_eEzmP4J0nvWArndRaXIQpym8,63
+initium/inference/tasks/audio_task.py,sha256=MKhlk_n4hnWeHPRvjxztCdKZ0SbHC_po7a2cYZbbVAA,4759
+initium/inference/tasks/base_task.py,sha256=mVDgDfbsfW7zRzbGW37dypE7TD9pv8UD1a4kt3J2bqs,2274
+initium/inference/tasks/graph_traversal_task.py,sha256=tZYFNhls03AxlAPLZ5XAjMXMZvUKgD2FSSXBrNBK8BI,9706
+initium/inference/tasks/multimodal_task.py,sha256=DIl4dHvOwKU_ezMf4Yp6Y_vxujqIWSXTjODJIhfRkQk,3107
+initium/inference/tasks/task_registry.py,sha256=SRn870HCMBv0NbBYipDQ4hjgrzXmhA8pjybIkRkkqbc,2251
+initium/inference/tasks/text_task.py,sha256=ZdwOnMjl_IhnjHDme0nxdtFNOG0b5hRaK9qF-tY0Ntg,4745
+initium/inference/tasks/video_task.py,sha256=uBbHpH8qEOkKb5_V_rzqg_m3d0XLhB3bl4ma04fa8Yw,4759
+initium/mamba_controller/mamba2_controller.py,sha256=7oFL7oj3eatGV5Mowt8BOREBXwnQy7kVB02UdD8fnjE,19401
+initium/mamba_controller/mamba3_controller.py,sha256=h76BUncvH0iquoct5ssgEY8DRL5UjdtD52VGQg7LuxE,8597
+initium/mamba_controller/mamba_backbone_parallel.py,sha256=KaWWhLF-wAMXJxdk_OgMJwyWnVztccbJ05CmKCUkzZ4,12733
+initium/mamba_controller/mamba_controller.py,sha256=XS5vM77UAM6NoJdA7-Oovnc6GYywePt5pmREBiwiMJ0,47063
+initium/mamba_controller/split_graph_dnc.py,sha256=x9lJeu2MX34aSKfLbi-q_Hp0CgjbLhwwTnL2QQ9yPcg,31352
+initium/memory_manipulation/dynamic_memory_resize.py,sha256=aJ96yQbGhCu8dKPpOjVYu5zdtJWFsgqoDweimXwqy5c,8445
+initium/memory_manipulation/dynamic_n_controller.py,sha256=AmcaGBWR77prrsq_xjDiqI272JTFbaf-DCsvYB4oXuo,7510
+initium/memory_manipulation/link_matrix_ablation.py,sha256=ot2T9JKYCaBBTirJRJHQa8H1-PHZKCeAgeayl4XxmBk,6884
+initium/memory_manipulation/nvrtc_compat.py,sha256=VQ6Gpf1PgRMeOW2QHj7cl1ojFsLlFb_sy-CwG7xwqZc,6732
+initium/memory_manipulation/stochastic_write_head_v2.py,sha256=wjMXNkhn3xrrMmPF-M_ivZb8a0mcU3yz7H2xm27M1Mo,26185
+initium_deeplearning-0.1.0.dist-info/METADATA,sha256=1K1Kyu_cvEfxNcJlLtdIYFp48WUHbJNdO2S8K_o6lvE,22247
+initium_deeplearning-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+initium_deeplearning-0.1.0.dist-info/entry_points.txt,sha256=upd8fKkrTScCaqfJSrFKgCwdDHUOSEO7EKUuB-RTC1k,113
+initium_deeplearning-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+initium_deeplearning-0.1.0.dist-info/RECORD,,

initium_deeplearning-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

initium_deeplearning-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+initium-infer = initium.inference.run_inference:main
+initium-setup = initium.setup_wheels:main