eae-runtime 0.1.0__py3-none-any.whl

eae_runtime/schedulers/base.py

@@ -0,0 +1,87 @@
+"""
+Scheduler API. This is the heart of the runtime's reverse execution.
+
+Instead of a hardcoded `for block in reversed(blocks): ...` loop, the
+runtime delegates reverse execution to a swappable BaseScheduler. Every
+scheduler performs, per block, the same logical sequence:
+
+    reconstruct -> launch local VJP -> run adjoint pipeline -> free memory -> continue
+
+but *how* that sequence is scheduled (in order, with prefetching, in
+pipeline stages across microbatches, or across distributed workers) is
+entirely up to the scheduler implementation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+import torch
+import torch.nn as nn
+
+from ..adjoint import AdjointState
+from ..boundary_store import BoundaryStore
+from ..events import EventBus, EventType
+from ..memory import MemoryManager
+from ..pipeline import AdjointPipeline
+from ..profiler import Profiler
+from ..reconstruction import ReconstructionEngine
+
+
+@dataclass
+class ReverseContext:
+    """Everything a scheduler needs to run the reverse pass. Kept as a
+    plain dataclass so custom schedulers can be written without importing
+    half the runtime."""
+
+    blocks: List[nn.Module]
+    block_names: List[str]
+    boundary_store: BoundaryStore
+    reconstruction_engine: ReconstructionEngine
+    pipeline: AdjointPipeline
+    memory_manager: MemoryManager
+    event_bus: EventBus
+    profiler: Profiler
+    initial_adjoint: AdjointState
+
+
+class BaseScheduler:
+    """Subclass and implement `run(context)`.
+
+    Must return a dict mapping each `nn.Parameter` to its accumulated
+    gradient tensor for this step.
+    """
+
+    name: str = "BaseScheduler"
+
+    def run(self, context: ReverseContext) -> Dict[nn.Parameter, torch.Tensor]:
+        raise NotImplementedError
+
+    # -- shared helpers available to all schedulers --------------------- #
+    @staticmethod
+    def _accumulate(target: Dict[nn.Parameter, torch.Tensor], updates: Dict[nn.Parameter, torch.Tensor]) -> None:
+        for p, g in updates.items():
+            if p in target:
+                target[p] = target[p] + g
+            else:
+                target[p] = g.clone()
+
+    @staticmethod
+    def _reconstruct_one(context: ReverseContext, i: int, adjoint: AdjointState):
+        """Reconstruct block `i` (0-indexed) given the adjoint at its output
+        boundary (i+1). Returns (new_adjoint_at_input_boundary, param_grads)."""
+        block = context.blocks[i]
+        name = context.block_names[i]
+        input_activation = context.boundary_store.get(i)
+
+        with context.profiler.track(f"reconstruct:{name}"):
+            new_adjoint, param_grads = context.reconstruction_engine.reconstruct(
+                block, input_activation, adjoint, block_name=name
+            )
+
+        new_adjoint = context.pipeline.run(new_adjoint, context={"block_index": i, "block_name": name})
+
+        context.memory_manager.release(input_activation)
+        context.event_bus.emit(EventType.SCHEDULER_STEP, block_index=i, block_name=name)
+        return new_adjoint, param_grads

eae_runtime/schedulers/distributed.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import warnings
+from typing import Any, Dict, List, Optional
+
+import torch
+import torch.nn as nn
+
+from .base import BaseScheduler, ReverseContext
+from .sequential import SequentialScheduler
+
+dist: Optional[Any]
+try:
+    import torch.distributed as dist
+except ImportError:  # pragma: no cover
+    dist = None
+
+
+class DistributedScheduler(BaseScheduler):
+    """Assigns contiguous block ranges to ranks and pipelines the adjoint
+    across process boundaries via a Communication Pass (compress -> send ->
+    receive -> decompress) at each rank boundary.
+
+    Requires `torch.distributed` to be initialized (e.g. via
+    `torch.distributed.init_process_group`) with world_size > 1. When that
+    is not the case - e.g. running single-process, as in unit tests and
+    most local development - it transparently falls back to
+    SequentialScheduler so the same code path is exercised and produces
+    identical, verifiable gradients.
+    """
+
+    name = "DistributedScheduler"
+
+    def __init__(self, block_ranks: Optional[List[int]] = None):
+        """`block_ranks[i]` = rank that owns block i. If omitted, blocks are
+        striped evenly across the current world size."""
+        self.block_ranks = block_ranks
+        self._fallback = SequentialScheduler()
+
+    def _is_distributed_active(self) -> bool:
+        return dist is not None and dist.is_available() and dist.is_initialized() and dist.get_world_size() > 1
+
+    def run(self, context: ReverseContext) -> Dict[nn.Parameter, torch.Tensor]:
+        if not self._is_distributed_active():
+            warnings.warn(
+                "DistributedScheduler: torch.distributed is not initialized "
+                "with world_size > 1; falling back to SequentialScheduler "
+                "(numerically identical, single-process).",
+                RuntimeWarning,
+            )
+            return self._fallback.run(context)
+
+        # -- real multi-process path -------------------------------------
+        assert dist is not None  # guaranteed by _is_distributed_active()
+        rank = dist.get_rank()
+        world_size = dist.get_world_size()
+        num_blocks = len(context.blocks)
+        ranks = self.block_ranks or [i * world_size // num_blocks for i in range(num_blocks)]
+
+        adjoint = context.initial_adjoint
+        param_grads: Dict[nn.Parameter, torch.Tensor] = {}
+
+        for i in reversed(range(num_blocks)):
+            owner = ranks[i]
+            if owner == rank:
+                adjoint, updates = self._reconstruct_one(context, i, adjoint)
+                self._accumulate(param_grads, updates)
+                # Communication pass: hand the adjoint to the neighboring
+                # rank that owns block i-1, if different.
+                if i > 0 and ranks[i - 1] != rank:
+                    dist.send(adjoint.tensor.contiguous(), dst=ranks[i - 1])
+            elif i > 0 and ranks[i - 1] == rank and owner != rank:
+                buf = torch.empty_like(adjoint.tensor)
+                dist.recv(buf, src=owner)
+                adjoint = adjoint.clone()
+                adjoint.tensor = buf
+
+        return param_grads

eae_runtime/schedulers/pipeline_scheduler.py

@@ -0,0 +1,67 @@
+from __future__ import annotations
+
+from typing import Dict
+
+import torch
+import torch.nn as nn
+
+from ..adjoint import AdjointState
+from ..events import EventType
+from .base import BaseScheduler, ReverseContext
+
+
+class PipelineScheduler(BaseScheduler):
+    """Splits the batch dimension into `num_microbatches` chunks and runs a
+    full reverse pass per chunk, accumulating parameter gradients across
+    chunks. This is a single-process emulation of pipeline-parallel
+    microbatching: for any block whose forward is applied independently
+    per-sample (the common case - Linear/activation/attention blocks
+    without cross-batch statistics), the accumulated result is numerically
+    identical to running the whole batch through SequentialScheduler.
+    """
+
+    name = "PipelineScheduler"
+
+    def __init__(self, num_microbatches: int = 1):
+        self.num_microbatches = max(1, num_microbatches)
+
+    @staticmethod
+    def _slice_adjoint(adjoint: AdjointState, start: int, end: int) -> AdjointState:
+        new = adjoint.clone()
+        new.tensor = adjoint.tensor[start:end]
+        return new
+
+    def run(self, context: ReverseContext) -> Dict[nn.Parameter, torch.Tensor]:
+        num_blocks = len(context.blocks)
+        param_grads: Dict[nn.Parameter, torch.Tensor] = {}
+
+        batch_size = context.initial_adjoint.tensor.shape[0]
+        num_mb = max(1, min(self.num_microbatches, batch_size))
+        chunk = (batch_size + num_mb - 1) // num_mb
+
+        for mb in range(num_mb):
+            start, end = mb * chunk, min(batch_size, (mb + 1) * chunk)
+            if start >= end:
+                continue
+            adjoint = self._slice_adjoint(context.initial_adjoint, start, end)
+
+            for i in reversed(range(num_blocks)):
+                block = context.blocks[i]
+                name = context.block_names[i]
+                full_input = context.boundary_store.get(i)
+                input_activation = full_input[start:end]
+
+                with context.profiler.track(f"reconstruct:{name}:mb{mb}"):
+                    new_adjoint, updates = context.reconstruction_engine.reconstruct(
+                        block, input_activation, adjoint, block_name=name
+                    )
+                new_adjoint = context.pipeline.run(
+                    new_adjoint, context={"block_index": i, "block_name": name, "microbatch": mb}
+                )
+                context.event_bus.emit(
+                    EventType.SCHEDULER_STEP, block_index=i, block_name=name, microbatch=mb
+                )
+                adjoint = new_adjoint
+                self._accumulate(param_grads, updates)
+
+        return param_grads

eae_runtime/schedulers/sequential.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from typing import Dict
+
+import torch
+import torch.nn as nn
+
+from .base import BaseScheduler, ReverseContext
+
+
+class SequentialScheduler(BaseScheduler):
+    """The reference scheduler: reconstruct -> VJP -> pipeline -> free,
+    strictly in order from the last block to the first. All other
+    schedulers must reproduce this scheduler's numerical result exactly."""
+
+    name = "SequentialScheduler"
+
+    def run(self, context: ReverseContext) -> Dict[nn.Parameter, torch.Tensor]:
+        num_blocks = len(context.blocks)
+        adjoint = context.initial_adjoint
+        param_grads: Dict[nn.Parameter, torch.Tensor] = {}
+
+        for i in reversed(range(num_blocks)):
+            adjoint, updates = self._reconstruct_one(context, i, adjoint)
+            self._accumulate(param_grads, updates)
+
+        return param_grads

eae_runtime-0.1.0.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: eae-runtime
+Version: 0.1.0
+Summary: A programmable, block-local reverse-mode execution engine that orchestrates PyTorch's local autograd (Explicit Adjoint Exposure runtime).
+Author: Vladimer Khasia
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/VladimerKhasia/eae_runtime
+Project-URL: Repository, https://github.com/VladimerKhasia/eae_runtime
+Project-URL: Issues, https://github.com/VladimerKhasia/eae_runtime/issues
+Project-URL: Changelog, https://github.com/VladimerKhasia/eae_runtime/blob/main/CHANGELOG.md
+Keywords: pytorch,autograd,backpropagation,transformer,deep-learning,training-runtime,gradient-compression,distributed-training
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: mypy>=1.10; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"
+Requires-Dist: twine>=5.0; extra == "dev"
+Dynamic: license-file
+
+# A programmable reverse-mode runtime for PyTorch
+
+A production-quality runtime that replaces PyTorch's monolithic
+`backward()` with a programmable, block-local reverse-mode execution engine
+implementing **Explicit Adjoint Exposure (EAE)**. It builds on the the top of [EAE](https://github.com/VladimerKhasia/eae) and turnes reverse-mode execution itself into schedulable runtime. 
+
+The runtime is **not** a new autodiff engine. It orchestrates many local
+autograd computations using PyTorch's existing local autograd:
+
+* **PyTorch owns:** local autograd, VJP computation, kernels.
+* **The runtime owns:** forward scheduling, reverse scheduling,
+  reconstruction, adjoint lifecycle, memory lifecycle, pass execution,
+  backend selection, communication scheduling.
+
+Users write ordinary `nn.Sequential` / `nn.Module` models. No custom tensor
+type, no compiler, no FX, no PyTorch internals modified.
+
+## Install
+
+```bash
+pip install -e .
+```
+
+## Quick start
+
+```python
+import torch
+import torch.nn as nn
+from eae_runtime import EAERuntime, RuntimeConfig
+from eae_runtime.passes import ClipPass, Int8QuantizationPass
+
+model = nn.Sequential(
+    nn.Linear(64, 64), nn.ReLU(),
+    nn.Linear(64, 64), nn.ReLU(),
+    nn.Linear(64, 10),
+)
+optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
+
+config = RuntimeConfig(
+    scheduler="sequential",          # "sequential" | "async" | "pipeline" | "distributed"
+    memory="pool",                   # "pool" | "none"
+    backend="auto",                  # "auto" | "cpu" | "cuda" | "triton" | "rocm"
+    passes=[Int8QuantizationPass(), ClipPass(max_norm=1.0)],
+    boundary_offload=False,          # move x0..xL to CPU between fwd/bwd
+    boundary_precision=None,         # e.g. torch.float16 to shrink boundary storage
+)
+
+runtime = EAERuntime(model, optimizer, config)
+
+x = torch.randn(32, 64)
+target = torch.randint(0, 10, (32,))
+loss = runtime.train_step(x, lambda out: nn.functional.cross_entropy(out, target))
+```
+
+## Architecture
+
+```
+User Model
+   |
+Block Decomposer            (blocks.py)
+   |
+Forward Executor            (forward_executor.py)   -> detached forward, no autograd graph
+   |
+Boundary State Store        (boundary_store.py)     -> stores only x0..xL
+   |
+Reverse Scheduler           (schedulers/)           -> pluggable: sequential/async/pipeline/distributed
+   |            \
+   |             \
+Reconstruction    Memory Manager                     (reconstruction.py / memory.py)
+Engine                 |            
+   |                   |             
+Adjoint Pipeline   Backend Manager                   (pipeline.py / backend.py)
+   |
+Local Autograd (PyTorch)
+   |
+CPU / CUDA
+```
+
+### The Adjoint Pipeline (the one addition beyond the base spec)
+
+Every reverse step exchanges an `AdjointState` — never a raw tensor —
+through a programmable pipeline:
+
+```
+AdjointState -> Pass1 -> Pass2 -> ... -> PassN -> next local VJP
+```
+
+A researcher working on gradient compression, synthetic gradients,
+error-feedback, distributed communication, or adaptive optimization only
+implements a new `EAEPass`. They never touch the reconstruction engine,
+scheduler, or memory manager.
+
+```python
+from eae_runtime.passes import EAEPass
+
+class MyPass(EAEPass):
+    name = "MyPass"
+    def process(self, adjoint, context=None):
+        new = adjoint.clone()
+        new.tensor = new.tensor * 0.9   # e.g. decay
+        return new
+```
+
+### Extension points
+
+| Want to add...          | Subclass                | Where                     |
+|--------------------------|--------------------------|----------------------------|
+| A gradient transform     | `EAEPass`                 | `eae_runtime/passes/`     |
+| A reverse scheduling policy | `BaseScheduler`        | `eae_runtime/schedulers/` |
+| A memory allocation strategy | `MemoryPolicy`        | `eae_runtime/memory.py`   |
+| A new backend             | extend `BackendManager`  | `eae_runtime/backend.py`  |
+
+None of these require modifying the runtime core.
+
+### Built-in passes
+
+`ClipPass`, `FP16Pass`, `Int8QuantizationPass` (aliased as `FP8Pass`),
+`SyntheticGradientPass`, `RegularizationPass`, `GaussianNoisePass`,
+`LoggingPass`.
+
+### Built-in schedulers
+
+* `SequentialScheduler` — the reference implementation; strict in-order
+  reconstruct → VJP → pipeline → free.
+* `AsyncScheduler` — overlaps boundary-activation prefetch (useful with
+  `boundary_offload=True`) with reconstruction compute; numerically
+  identical to `SequentialScheduler`.
+* `PipelineScheduler` — splits the batch into microbatches and runs a full
+  reverse pass per microbatch, accumulating gradients (single-process
+  emulation of pipeline-parallel microbatching).
+* `DistributedScheduler` — assigns block ranges to `torch.distributed`
+  ranks and communicates adjoints across rank boundaries; falls back to
+  `SequentialScheduler` (with a warning) when running single-process.
+
+### Events
+
+Every component emits structured events (`ForwardStarted`,
+`BlockReconstructed`, `AdjointCreated`, `MemoryAllocated`,
+`SchedulerStep`, `PassApplied`, ...) on an `EventBus`. Subscribe without
+touching runtime code:
+
+```python
+runtime.event_bus.subscribe("BlockReconstructed", lambda e: print(e.payload))
+```
+
+Set `RuntimeConfig(log_level="DEBUG")` to also pipe every event through
+Python's structured JSON logger.
+
+### Profiling
+
+```python
+loss = runtime.train_step(x, loss_fn)
+print(runtime.profiler.report())
+# {'forward': {...}, 'reconstruct:Linear_0': {...}, 'pass:ClipPass': {...}, ...}
+```
+
+## Testing
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+The suite (`tests/`) covers:
+
+* `AdjointState` API (norm, statistics, quantize/dequantize, compress, clone, detach)
+* Event bus pub/sub, wildcard subscribers, recording
+* Memory manager: pool reuse, null policy, allocator correctness, leak checks
+* Boundary store: precision downcast, CPU offload, ownership semantics
+* Reconstruction engine vs. manual VJP (`torch.autograd.grad`) reference
+* **Gradient equivalence**: every scheduler vs. plain `model.backward()`,
+  across float32, boundary-offloaded, and microbatched configurations
+* All built-in passes, including a full multi-pass pipeline
+* All built-in schedulers, plus a user-defined custom scheduler
+* Backend manager device/dtype resolution and graceful CUDA→CPU fallback
+* Profiler timing aggregation
+* Mixed precision (compute dtype + boundary storage dtype) numerical bounds
+* Memory-leak / allocator-stability checks over many training steps
+* A full Transformer-style block stack (`nn.MultiheadAttention` + FFN,
+  pre-norm, residual) trained end-to-end with a full pass pipeline
+* Real two-process `torch.distributed` (gloo) correctness check for
+  `DistributedScheduler` (skips gracefully if the sandbox blocks socket use)
+
+## Non-goals by design
+
+* Automatic partitioning of arbitrary `nn.Module` graphs — blocks are
+  specified manually or via `BlockDecomposer.from_sequential`/`from_list`.
+* Replacing or modifying PyTorch's autograd internals.
+* A new differentiation algorithm — local VJP is always PyTorch's own.
+* A new compiler or graph IR.
+* Day-one support for every architecture — the runtime targets
+  Transformer-style models with repeated block structure first.

eae_runtime-0.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+eae_runtime/__init__.py,sha256=dyoSq-IDEUuSojucACdao1ZTkXBuIEJ4Q02936UPUts,2266
+eae_runtime/_version.py,sha256=obMoDE79VgohpsGVxWupnx1D5WyFXxlX-YJV2Bv_O3s,528
+eae_runtime/adjoint.py,sha256=Sek-sxnTGb6AiVazStjy8-30Fxo55jRES_JuHXXdSLI,5002
+eae_runtime/backend.py,sha256=ycedtyXUeNAjNwv51DuYRWgePhOwHCiMQ-fyJ5d-Nl0,2015
+eae_runtime/blocks.py,sha256=2TuVvz2Gyusvx3XL-qbdRqwHxtukAmN17LhyN-EZBe8,2629
+eae_runtime/boundary_store.py,sha256=_CEZhxnaCBscUEEMDsUAs0QfUOfiBGdqNj12yn2mgqA,2183
+eae_runtime/config.py,sha256=6jCCzE2DSPU_txtA1qlMWj5Hjj1tfn5mkZE_0-xHvxk,1485
+eae_runtime/events.py,sha256=mGLHfSQpcTBKOJgyH7ITfH2o-qK-j60fL47zasUrqnM,2846
+eae_runtime/forward_executor.py,sha256=AIaVcdZpONf5-U-945qkYp4Ff6Lo3lnZRyu5BlgPDUI,1189
+eae_runtime/logging_utils.py,sha256=y-RcsKGuqUA55W-VNfdbPzzMiTM3CgaA_JmG4lMaNnY,1397
+eae_runtime/memory.py,sha256=9nBJ0nhtCfXWwEgZC3ZWLFCTxV8kTO7UHfBZ1z9LzEM,5788
+eae_runtime/pipeline.py,sha256=RJoSwRW6U3PjTISKWvNsnyRImKsIfvIVXSNMIbEInrQ,2144
+eae_runtime/profiler.py,sha256=dyDDjNKT2kbofrAC1TUP42dd84OPObXQwAQ9B1fXHA4,1391
+eae_runtime/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+eae_runtime/reconstruction.py,sha256=jzfql7QxP-YdIL6W5VnuPkeNMgH4S1HDwIekoIrFraY,3026
+eae_runtime/runtime.py,sha256=31k2S25drgLjnHe373ncHPAGZohDp-bzPfcAdEZtbkc,7148
+eae_runtime/contrib/__init__.py,sha256=x8_ozItvdqXl7cifLFlBkd9BY-tnkwcD6ErkoC8ph-E,653
+eae_runtime/contrib/transformer_blocks.py,sha256=MQPXwXiolhlU1llHP9yMiqZUdPeDaVThdAhQejqTpFw,10544
+eae_runtime/passes/__init__.py,sha256=m5Qz5mIxr5BPs5C__Z3qfvN9_dfPBK7YuVcEKrl7Pro,477
+eae_runtime/passes/base.py,sha256=Az8dUMbU4vYyTenhxib15Jv8x_WhxrHy1AFOKdU3bO8,972
+eae_runtime/passes/clip.py,sha256=wUjbMxdjxDFPpnnxsYztRQiUMd84wP-pQtWusCv-RGY,767
+eae_runtime/passes/logging_pass.py,sha256=4kjfF3e411C0SgbxSrtPtyzZsotD4r6bCpkl72-WMtI,888
+eae_runtime/passes/quantize.py,sha256=YTXesgAWNNr_UQD0_ENpqqOQqgujXEzay0yfPK0c2tk,1899
+eae_runtime/passes/regularization.py,sha256=fKUt8Vi1_eCsDwVZnsQBXSh0_-34VYLDYT4sAOEgxLU,1504
+eae_runtime/passes/synthetic_gradient.py,sha256=afaNlE_0aCUhyo9GkwCUhkjZwOegka31tYJnpiQCC24,2444
+eae_runtime/schedulers/__init__.py,sha256=cZcoRb4CZ-GDSRGLh-lzW9oO72YrqeHW9lmfhFX4LcE,1152
+eae_runtime/schedulers/async_scheduler.py,sha256=q_5pm-JuoZNN9Jr_bKPZJWogHtNDvaiuutkAdzw5_p0,2484
+eae_runtime/schedulers/base.py,sha256=s8nk_nNoDryQ_0cnWW0VluDXuQGwlbuNJ-pM7n2Dai8,3076
+eae_runtime/schedulers/distributed.py,sha256=o-iB7QEXVimegpPFigjUAY0kqA4KAWYCqNVj6xg5oXc,3147
+eae_runtime/schedulers/pipeline_scheduler.py,sha256=fPBAr0iS0LN-93kvAgXBstIulgVv61q-QMAeu7nYgxU,2654
+eae_runtime/schedulers/sequential.py,sha256=jwtzqsdGsSj-X4hn04GQWmKO5lvZ-DWOPAMn-IKJKWo,860
+eae_runtime-0.1.0.dist-info/licenses/LICENSE,sha256=ojKENiVsyN8E7oy0zMwPD3QxlcXSrTemue3f2whrp6o,555
+eae_runtime-0.1.0.dist-info/METADATA,sha256=XQ8OJ5KhV7uQ6FCqCuG3Ggev1t4dwoOQV2ZNIzieySw,8957
+eae_runtime-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+eae_runtime-0.1.0.dist-info/scm_file_list.json,sha256=OBrx3FNG3VnHpmm3wQLpYDedjzOkcpsAFCvfTI4a6HQ,1941
+eae_runtime-0.1.0.dist-info/scm_version.json,sha256=lmTMI8NbneyiyDTdQpOy0NUQkXa0gaeW-rJPiAib7sE,160
+eae_runtime-0.1.0.dist-info/top_level.txt,sha256=UQI-zlkwW3U0ukZvMmL3hb0F0v5F-VU2IP1CoitVorw,12
+eae_runtime-0.1.0.dist-info/RECORD,,

eae_runtime-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

eae_runtime-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2026 Vladimer Khasia
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

eae_runtime-0.1.0.dist-info/scm_file_list.json

@@ -0,0 +1,59 @@
+{
+  "files": [
+    ".gitignore",
+    "README.md",
+    "pyproject.toml",
+    "LICENSE",
+    ".github/workflows/publish.yml",
+    ".github/workflows/ci.yml",
+    "eae_runtime/adjoint.py",
+    "eae_runtime/memory.py",
+    "eae_runtime/profiler.py",
+    "eae_runtime/config.py",
+    "eae_runtime/reconstruction.py",
+    "eae_runtime/pipeline.py",
+    "eae_runtime/backend.py",
+    "eae_runtime/forward_executor.py",
+    "eae_runtime/boundary_store.py",
+    "eae_runtime/blocks.py",
+    "eae_runtime/runtime.py",
+    "eae_runtime/py.typed",
+    "eae_runtime/logging_utils.py",
+    "eae_runtime/__init__.py",
+    "eae_runtime/events.py",
+    "eae_runtime/contrib/transformer_blocks.py",
+    "eae_runtime/contrib/__init__.py",
+    "eae_runtime/schedulers/distributed.py",
+    "eae_runtime/schedulers/base.py",
+    "eae_runtime/schedulers/pipeline_scheduler.py",
+    "eae_runtime/schedulers/async_scheduler.py",
+    "eae_runtime/schedulers/sequential.py",
+    "eae_runtime/schedulers/__init__.py",
+    "eae_runtime/passes/base.py",
+    "eae_runtime/passes/quantize.py",
+    "eae_runtime/passes/regularization.py",
+    "eae_runtime/passes/clip.py",
+    "eae_runtime/passes/synthetic_gradient.py",
+    "eae_runtime/passes/logging_pass.py",
+    "eae_runtime/passes/__init__.py",
+    "examples/train_transformer_lm.py",
+    "tests/test_mixed_precision.py",
+    "tests/test_schedulers.py",
+    "tests/test_profiler.py",
+    "tests/conftest.py",
+    "tests/test_gradient_equivalence.py",
+    "tests/test_events.py",
+    "tests/test_distributed_multiprocess.py",
+    "tests/test_backend.py",
+    "tests/test_end_to_end_transformer.py",
+    "tests/test_runtime.py",
+    "tests/test_boundary_store.py",
+    "tests/test_memory_leaks.py",
+    "tests/test_memory_manager.py",
+    "tests/test_adjoint.py",
+    "tests/test_reconstruction.py",
+    "tests/test_contrib_transformer_blocks.py",
+    "tests/test_config_and_blocks.py",
+    "tests/test_passes.py"
+  ]
+}

eae_runtime-0.1.0.dist-info/scm_version.json

@@ -0,0 +1,8 @@
+{
+  "tag": "0.1.0",
+  "distance": 0,
+  "node": "g336fa5cb8099beaa6691bacf1e6475a7e668bb9a",
+  "dirty": false,
+  "branch": "HEAD",
+  "node_date": "2026-07-19"
+}

eae_runtime-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+eae_runtime