tt-rl 0.1.0__tar.gz

tt_rl-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Antoni Bertel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tt_rl-0.1.0/PKG-INFO

@@ -0,0 +1,273 @@
+Metadata-Version: 2.4
+Name: tt-rl
+Version: 0.1.0
+Summary: Reinforcement learning on Tenstorrent, natively on TT-NN
+Author: Antoni Bertel
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/scaleresearch/tt-rl
+Project-URL: Repository, https://github.com/scaleresearch/tt-rl
+Project-URL: Issues, https://github.com/scaleresearch/tt-rl/issues
+Keywords: reinforcement-learning,tenstorrent,ttnn,blackhole,rl
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: <3.13,>=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: ttnn<0.81,>=0.80.0
+Requires-Dist: numpy<2,>=1.26
+Provides-Extra: atari
+Requires-Dist: gymnasium[atari]>=1.4; extra == "atari"
+Requires-Dist: ale-py>=0.12; extra == "atari"
+Requires-Dist: opencv-python-headless>=4.11; extra == "atari"
+Provides-Extra: mujoco
+Requires-Dist: gymnasium[mujoco]>=1.4; extra == "mujoco"
+Requires-Dist: mujoco<4,>=3.17; extra == "mujoco"
+Requires-Dist: opencv-python-headless>=4.11; extra == "mujoco"
+Provides-Extra: logging
+Requires-Dist: tensorboard>=2.21; extra == "logging"
+Provides-Extra: tracker
+Requires-Dist: wandb>=0.19; extra == "tracker"
+Provides-Extra: plots
+Requires-Dist: matplotlib>=3.9; extra == "plots"
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.21; extra == "onnx"
+Provides-Extra: dev
+Requires-Dist: pytest>=9; extra == "dev"
+Requires-Dist: torch>=2.14; extra == "dev"
+Requires-Dist: tensorboard>=2.21; extra == "dev"
+Requires-Dist: matplotlib>=3.9; extra == "dev"
+Requires-Dist: tt-rl[onnx]; extra == "dev"
+Requires-Dist: onnxruntime>=1.20; extra == "dev"
+Requires-Dist: tt-rl[atari]; extra == "dev"
+Requires-Dist: tt-rl[mujoco]; extra == "dev"
+Dynamic: license-file
+
+# tt-rl
+
+[![CI](https://github.com/scaleresearch/tt-rl/actions/workflows/ci.yml/badge.svg)](https://github.com/scaleresearch/tt-rl/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Reinforcement learning on Tenstorrent hardware, built directly on
+[TT-NN](https://github.com/tenstorrent/tt-metal). Networks, gradients, the Adam
+step and the device trace all run on the chip through `ttnn`. Environments
+and replay buffers stay on the host.
+
+<table>
+  <tr>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/pong.gif" height="260" alt="Pong"><br>Pong, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/breakout.gif" height="260" alt="Breakout"><br>Breakout, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/boxing.gif" height="260" alt="Boxing"><br>Boxing, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/hopper.gif" height="260" alt="Hopper"><br>Hopper, SAC</td>
+  </tr>
+</table>
+
+- **Algorithms:** DQN (double, n-step, prioritized replay), PPO (GAE, clipping,
+  optional GRU memory) and SAC (twin critics, learned temperature).
+- **Environments:** Atari pixels, MuJoCo state vectors, and any environment you
+  write against a small protocol.
+- **Single or multiple chips:** a run trains on one chip, or data-parallel
+  across several with one replica per chip.
+- **Deploy anywhere:** export a trained policy to numpy or ONNX and run it on
+  any CPU.
+
+## Results
+
+Measured on one Blackhole chip. Atari scores are the mean over 30 evaluation
+episodes with sticky actions (0.25), which is harder than the
+`NoFrameskip-v4` setting most published numbers use. A step is one agent
+action, four Atari frames. Each score is the best evaluation of its run.
+
+| Task | Algorithm | Steps | Score | Weights |
+|---|---|---|---|---|
+| Pong | DQN | 10M | 17.8 | [ttrl-dqn-pong](https://huggingface.co/scaleresearch/ttrl-dqn-pong) |
+| Breakout | DQN | 10M | 144.8 | [ttrl-dqn-breakout](https://huggingface.co/scaleresearch/ttrl-dqn-breakout) |
+| Boxing | DQN | 10M | 91.0 | [ttrl-dqn-boxing](https://huggingface.co/scaleresearch/ttrl-dqn-boxing) |
+| Hopper-v5 | SAC | 1M | 3604 | [ttrl-sac-hopper](https://huggingface.co/scaleresearch/ttrl-sac-hopper) |
+
+Each config in `configs/` records how it was measured in its docstring. The
+trained policies are on Hugging Face as ONNX and numpy weights, with a
+`play.py` that runs them on CPU.
+
+### Learning
+
+From an untrained agent to the final one, at fixed checkpoints of the same
+run (Atari clips play at 3x speed):
+
+![Pong learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/pong_learning.gif)
+
+![Hopper learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/hopper_learning.gif)
+
+<details>
+<summary>Breakout and Boxing</summary>
+
+![Breakout learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/breakout_learning.gif)
+
+![Boxing learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/boxing_learning.gif)
+
+</details>
+
+## Requirements
+
+- Linux and Python 3.12. `ttnn` 0.80 ships wheels for 3.10 and 3.12, and
+  3.10 is dropped because current Pillow and filelock no longer support it.
+- A Tenstorrent Blackhole chip with its driver and firmware installed.
+  Developed on a TT-QuietBox with four Blackhole chips.
+
+## Install
+
+ttrl installs from source for now. A PyPI release as `tt-rl` is on its way,
+after which `pip install tt-rl` will be enough.
+
+```bash
+git clone https://github.com/scaleresearch/tt-rl && cd tt-rl
+pip install -e '.[atari]'     # Atari
+pip install -e '.[mujoco]'    # MuJoCo
+pip install -e '.[dev]'       # both, plus the test suite's dependencies
+```
+
+`ttnn` installs from PyPI as a dependency. Then check the machine:
+
+```bash
+ttrl doctor
+```
+
+It reports versions, which chips exist and who holds each one, and opens a
+free chip to confirm a trace captures and replays.
+
+## Train
+
+A run is a Python config. Arguments after the path override any field by
+its dotted name:
+
+```bash
+ttrl train configs/pong_dqn.py device.chip=0
+ttrl train configs/pong_dqn.py total_frames=3000 algo_cfg.learning_starts=500 log_dir=runs/smoke
+```
+
+The same from Python:
+
+```python
+import ttrl
+
+config = ttrl.load_config("configs/pong_dqn.py", overrides=["device.chip=0"])
+result = ttrl.run(config)
+```
+
+A run writes metrics, checkpoints and `checkpoint-best.npz` to its
+`log_dir`. `ttrl train --resume best <config>` continues from the best one;
+DQN and SAC runs also need `checkpoint_replay=True` so the replay buffer is
+saved with them.
+`examples/atari-dqn` and `examples/mujoco-sac` are standalone projects that
+use ttrl as a library.
+
+A chip is exclusive to one process. `device.chip=N` names a physical chip,
+the `N` in `/dev/tenstorrent/N`; leave it unset to take the lowest free one.
+
+### Multiple chips
+
+`device.chips` trains one replica per chip. Each replica steps its own
+environments and runs its own updates, and every `device.sync_every` updates
+(50 by default) the replicas average their parameters, so they stay one model.
+
+```bash
+ttrl train configs/pong_ppo.py device.chips=4          # any 4 chips
+ttrl train configs/pong_ppo.py device.chips=all        # every chip on the machine
+ttrl train configs/pong_ppo.py 'device.chips=[0,1]'    # these physical chips
+```
+
+```python
+config = ttrl.load_config("configs/pong_ppo.py", overrides=["device.chips=4"])
+ttrl.run(config)
+```
+
+N replicas collect N times the experience per update round, so a multi-chip
+run is a different recipe from its single-chip config, and learning rates or
+batch sizes may need retuning. PPO, which already runs many environments at
+once, is the natural fit.
+
+## Deploy without a chip
+
+```python
+import ttrl
+
+artifact = ttrl.export_policy("runs/pong/checkpoint-best.npz", "pong.policy.npz")
+ttrl.export_onnx(artifact, "pong.onnx")      # needs the [onnx] extra
+
+policy = ttrl.load_policy(artifact)          # numpy only
+action = policy(obs)                         # obs: one raw observation
+```
+
+The ONNX graph has one input, `obs`, and two outputs, `action` and `head`
+(the Q-values or action distribution). It runs with `onnxruntime`, and the
+Atari DQN graph also compiles unchanged with Tenstorrent's TT-Forge-ONNX.
+
+## Your own environment
+
+An environment is any object with `obs_spec`, `action_spec`, `episode_bound`,
+`reset`, `step` and `close`. Nothing needs subclassing:
+
+```python
+import numpy as np
+import ttrl
+from ttrl.envs import check_env
+from ttrl.envs.registry import register
+from ttrl.envs.wrappers import RecordEpisodeStatistics
+
+
+class Slider:
+    """Move a point to the origin. Reward is the step's reduction in |x|."""
+
+    obs_spec = ttrl.ObsSpec.vector(2)
+    action_spec = ttrl.ActionSpec.discrete(3)
+    episode_bound = 64
+
+    def reset(self, *, seed=None):
+        self.rng = np.random.default_rng(seed)
+        self.x, self.t = float(self.rng.uniform(-1.0, 1.0)), 0
+        return self._obs(), {}
+
+    def _obs(self):
+        return np.array([self.x, self.t / self.episode_bound], dtype=np.float32)
+
+    def step(self, action):
+        before = abs(self.x)
+        self.x = float(np.clip(self.x + (int(action) - 1) * 0.05, -1.0, 1.0))
+        self.t += 1
+        return self._obs(), before - abs(self.x), False, self.t >= self.episode_bound, {}
+
+    def close(self):
+        pass
+
+
+register("slider", lambda **kw: RecordEpisodeStatistics(Slider(**kw)))
+check_env(RecordEpisodeStatistics(Slider()))
+
+config = ttrl.TrainConfig(
+    algo="dqn",
+    total_frames=4_000,
+    eval_interval=4_000,
+    log_dir="runs/slider",
+    env=ttrl.EnvConfig(name="slider", n_envs=1),
+    algo_cfg=ttrl.DQNConfig(batch_size=64, learning_starts=500, buffer_capacity=4_000),
+)
+ttrl.run(config)
+```
+
+`check_env` raises on the first contract violation with a message saying what
+was expected. `RecordEpisodeStatistics` is required: evaluation reads each
+episode's score from it.
+
+## Tests
+
+```bash
+pytest                 # host suite, no chip needed
+pytest -m tt           # hardware suite, needs a chip
+```
+
+## License
+
+MIT

tt_rl-0.1.0/README.md

@@ -0,0 +1,225 @@
+# tt-rl
+
+[![CI](https://github.com/scaleresearch/tt-rl/actions/workflows/ci.yml/badge.svg)](https://github.com/scaleresearch/tt-rl/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+Reinforcement learning on Tenstorrent hardware, built directly on
+[TT-NN](https://github.com/tenstorrent/tt-metal). Networks, gradients, the Adam
+step and the device trace all run on the chip through `ttnn`. Environments
+and replay buffers stay on the host.
+
+<table>
+  <tr>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/pong.gif" height="260" alt="Pong"><br>Pong, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/breakout.gif" height="260" alt="Breakout"><br>Breakout, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/boxing.gif" height="260" alt="Boxing"><br>Boxing, DQN</td>
+    <td align="center"><img src="https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/hopper.gif" height="260" alt="Hopper"><br>Hopper, SAC</td>
+  </tr>
+</table>
+
+- **Algorithms:** DQN (double, n-step, prioritized replay), PPO (GAE, clipping,
+  optional GRU memory) and SAC (twin critics, learned temperature).
+- **Environments:** Atari pixels, MuJoCo state vectors, and any environment you
+  write against a small protocol.
+- **Single or multiple chips:** a run trains on one chip, or data-parallel
+  across several with one replica per chip.
+- **Deploy anywhere:** export a trained policy to numpy or ONNX and run it on
+  any CPU.
+
+## Results
+
+Measured on one Blackhole chip. Atari scores are the mean over 30 evaluation
+episodes with sticky actions (0.25), which is harder than the
+`NoFrameskip-v4` setting most published numbers use. A step is one agent
+action, four Atari frames. Each score is the best evaluation of its run.
+
+| Task | Algorithm | Steps | Score | Weights |
+|---|---|---|---|---|
+| Pong | DQN | 10M | 17.8 | [ttrl-dqn-pong](https://huggingface.co/scaleresearch/ttrl-dqn-pong) |
+| Breakout | DQN | 10M | 144.8 | [ttrl-dqn-breakout](https://huggingface.co/scaleresearch/ttrl-dqn-breakout) |
+| Boxing | DQN | 10M | 91.0 | [ttrl-dqn-boxing](https://huggingface.co/scaleresearch/ttrl-dqn-boxing) |
+| Hopper-v5 | SAC | 1M | 3604 | [ttrl-sac-hopper](https://huggingface.co/scaleresearch/ttrl-sac-hopper) |
+
+Each config in `configs/` records how it was measured in its docstring. The
+trained policies are on Hugging Face as ONNX and numpy weights, with a
+`play.py` that runs them on CPU.
+
+### Learning
+
+From an untrained agent to the final one, at fixed checkpoints of the same
+run (Atari clips play at 3x speed):
+
+![Pong learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/pong_learning.gif)
+
+![Hopper learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/hopper_learning.gif)
+
+<details>
+<summary>Breakout and Boxing</summary>
+
+![Breakout learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/breakout_learning.gif)
+
+![Boxing learning](https://raw.githubusercontent.com/scaleresearch/tt-rl/master/assets/boxing_learning.gif)
+
+</details>
+
+## Requirements
+
+- Linux and Python 3.12. `ttnn` 0.80 ships wheels for 3.10 and 3.12, and
+  3.10 is dropped because current Pillow and filelock no longer support it.
+- A Tenstorrent Blackhole chip with its driver and firmware installed.
+  Developed on a TT-QuietBox with four Blackhole chips.
+
+## Install
+
+ttrl installs from source for now. A PyPI release as `tt-rl` is on its way,
+after which `pip install tt-rl` will be enough.
+
+```bash
+git clone https://github.com/scaleresearch/tt-rl && cd tt-rl
+pip install -e '.[atari]'     # Atari
+pip install -e '.[mujoco]'    # MuJoCo
+pip install -e '.[dev]'       # both, plus the test suite's dependencies
+```
+
+`ttnn` installs from PyPI as a dependency. Then check the machine:
+
+```bash
+ttrl doctor
+```
+
+It reports versions, which chips exist and who holds each one, and opens a
+free chip to confirm a trace captures and replays.
+
+## Train
+
+A run is a Python config. Arguments after the path override any field by
+its dotted name:
+
+```bash
+ttrl train configs/pong_dqn.py device.chip=0
+ttrl train configs/pong_dqn.py total_frames=3000 algo_cfg.learning_starts=500 log_dir=runs/smoke
+```
+
+The same from Python:
+
+```python
+import ttrl
+
+config = ttrl.load_config("configs/pong_dqn.py", overrides=["device.chip=0"])
+result = ttrl.run(config)
+```
+
+A run writes metrics, checkpoints and `checkpoint-best.npz` to its
+`log_dir`. `ttrl train --resume best <config>` continues from the best one;
+DQN and SAC runs also need `checkpoint_replay=True` so the replay buffer is
+saved with them.
+`examples/atari-dqn` and `examples/mujoco-sac` are standalone projects that
+use ttrl as a library.
+
+A chip is exclusive to one process. `device.chip=N` names a physical chip,
+the `N` in `/dev/tenstorrent/N`; leave it unset to take the lowest free one.
+
+### Multiple chips
+
+`device.chips` trains one replica per chip. Each replica steps its own
+environments and runs its own updates, and every `device.sync_every` updates
+(50 by default) the replicas average their parameters, so they stay one model.
+
+```bash
+ttrl train configs/pong_ppo.py device.chips=4          # any 4 chips
+ttrl train configs/pong_ppo.py device.chips=all        # every chip on the machine
+ttrl train configs/pong_ppo.py 'device.chips=[0,1]'    # these physical chips
+```
+
+```python
+config = ttrl.load_config("configs/pong_ppo.py", overrides=["device.chips=4"])
+ttrl.run(config)
+```
+
+N replicas collect N times the experience per update round, so a multi-chip
+run is a different recipe from its single-chip config, and learning rates or
+batch sizes may need retuning. PPO, which already runs many environments at
+once, is the natural fit.
+
+## Deploy without a chip
+
+```python
+import ttrl
+
+artifact = ttrl.export_policy("runs/pong/checkpoint-best.npz", "pong.policy.npz")
+ttrl.export_onnx(artifact, "pong.onnx")      # needs the [onnx] extra
+
+policy = ttrl.load_policy(artifact)          # numpy only
+action = policy(obs)                         # obs: one raw observation
+```
+
+The ONNX graph has one input, `obs`, and two outputs, `action` and `head`
+(the Q-values or action distribution). It runs with `onnxruntime`, and the
+Atari DQN graph also compiles unchanged with Tenstorrent's TT-Forge-ONNX.
+
+## Your own environment
+
+An environment is any object with `obs_spec`, `action_spec`, `episode_bound`,
+`reset`, `step` and `close`. Nothing needs subclassing:
+
+```python
+import numpy as np
+import ttrl
+from ttrl.envs import check_env
+from ttrl.envs.registry import register
+from ttrl.envs.wrappers import RecordEpisodeStatistics
+
+
+class Slider:
+    """Move a point to the origin. Reward is the step's reduction in |x|."""
+
+    obs_spec = ttrl.ObsSpec.vector(2)
+    action_spec = ttrl.ActionSpec.discrete(3)
+    episode_bound = 64
+
+    def reset(self, *, seed=None):
+        self.rng = np.random.default_rng(seed)
+        self.x, self.t = float(self.rng.uniform(-1.0, 1.0)), 0
+        return self._obs(), {}
+
+    def _obs(self):
+        return np.array([self.x, self.t / self.episode_bound], dtype=np.float32)
+
+    def step(self, action):
+        before = abs(self.x)
+        self.x = float(np.clip(self.x + (int(action) - 1) * 0.05, -1.0, 1.0))
+        self.t += 1
+        return self._obs(), before - abs(self.x), False, self.t >= self.episode_bound, {}
+
+    def close(self):
+        pass
+
+
+register("slider", lambda **kw: RecordEpisodeStatistics(Slider(**kw)))
+check_env(RecordEpisodeStatistics(Slider()))
+
+config = ttrl.TrainConfig(
+    algo="dqn",
+    total_frames=4_000,
+    eval_interval=4_000,
+    log_dir="runs/slider",
+    env=ttrl.EnvConfig(name="slider", n_envs=1),
+    algo_cfg=ttrl.DQNConfig(batch_size=64, learning_starts=500, buffer_capacity=4_000),
+)
+ttrl.run(config)
+```
+
+`check_env` raises on the first contract violation with a message saying what
+was expected. `RecordEpisodeStatistics` is required: evaluation reads each
+episode's score from it.
+
+## Tests
+
+```bash
+pytest                 # host suite, no chip needed
+pytest -m tt           # hardware suite, needs a chip
+```
+
+## License
+
+MIT

tt_rl-0.1.0/pyproject.toml

@@ -0,0 +1,138 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tt-rl"
+# Single source of truth: `ttrl.__version__`. setuptools reads this statically
+# (AST), so declaring it here does not import the package at build time.
+dynamic = ["version"]
+description = "Reinforcement learning on Tenstorrent, natively on TT-NN"
+requires-python = ">=3.12,<3.13"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "Antoni Bertel" }]
+keywords = ["reinforcement-learning", "tenstorrent", "ttnn", "blackhole", "rl"]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: POSIX :: Linux",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+# Version policy for the two pins below.
+#
+# ttnn is pinned to a single minor, `>=0.80.0,<0.81`. ttnn publishes one
+# release per minor (0.65 through 0.80 on PyPI, with 0.67.4, 0.70.1, 0.71.2
+# and 0.73.1 the only patches), so its minor is its release channel and it
+# carries breaking C++ and Python API changes inside it. ttrl builds on the
+# parts of ttnn that move most: the autograd-free op surface, device trace
+# capture, the mesh and cluster descriptors, and the conv kernel configs. A
+# ttnn minor bump is therefore a porting job for us, and it ships as a ttrl
+# minor bump: raise both bounds together, run the hardware gate, and record
+# the ttnn version the numbers came from.
+# A range spanning minors would let pip pick a ttnn that ttrl has never been
+# run against on a chip, which on this stack surfaces as a TT_FATAL inside a
+# kernel rather than an ImportError.
+#
+# `numpy<2` comes from upstream. ttnn 0.80.0's own metadata declares
+# `numpy<2,>=1.24.4`, so 1.26.4, the last of the 1.x line, is the ceiling the
+# whole tree is held to. Stating it here makes the resolution failure legible
+# at install time instead of mid-backtrack. It also caps
+# `opencv-python-headless` at 4.11.x, the last release that still accepts
+# numpy 1.x. This bound lifts when ttnn's does and not before.
+#
+# The env plumbing (gymnasium / ale-py / cv2 / mujoco) is resolved at call
+# time by `ttrl.envs`, so a bare install imports and runs without any
+# environment suite and each suite is an extra.
+dependencies = [
+  "ttnn>=0.80.0,<0.81",
+  "numpy>=1.26,<2",
+]
+
+[project.optional-dependencies]
+atari = [
+  "gymnasium[atari]>=1.4",
+  "ale-py>=0.12",
+  "opencv-python-headless>=4.11",
+]
+mujoco = [
+  "gymnasium[mujoco]>=1.4",
+  "mujoco>=3.17,<4",
+  # `ttrl.record_video` writes its mp4 through cv2, and watching a gait is
+  # a first-class use of this extra. Without it here, recording a
+  # locomotion policy needed the unrelated `atari` extra installed.
+  "opencv-python-headless>=4.11",
+]
+logging = ["tensorboard>=2.21"]
+# The tracker sink, `ttrl.train.logging.WandbLogger`. An extra rather than a
+# dependency: nothing on the training path imports wandb, and a run logs to
+# JSONL without it.
+tracker = ["wandb>=0.19"]
+# What `python -m tools.curves` draws with. An extra rather than a
+# dependency: the wheel trains, and nothing on the training path imports
+# matplotlib.
+plots = ["matplotlib>=3.9"]
+# What `ttrl.export_onnx` writes the policy graph with. An extra rather than a
+# dependency: `ttrl.export_policy` and `ttrl.load_policy` need numpy alone, and
+# `onnx` is a protobuf library that no training path imports. It brings no
+# torch and no runtime: running the graph is the consumer's business, and the
+# parity gate in the dev extra below is the only place this repository does it.
+onnx = ["onnx>=1.21"]
+# Everything needed to run the non-hardware test suite: pytest, the torch
+# reference implementations the parity tests compare against, TensorBoard,
+# which `tests/train/test_logging.py` exercises, matplotlib, which
+# `tests/tools/test_curves.py` exercises, and both environment suites, which
+# the env-layer tests build real environments from.
+#
+# wandb is deliberately absent. `tests/train/test_trackers.py` drives that
+# sink against a stand-in module and asserts the refusal when the real one is
+# missing, so the suite holds it to its contract on a machine with no tracker
+# client and without reaching a network.
+#
+# onnxruntime is here and not in the `onnx` extra: writing a graph needs the
+# protobuf library, and only the parity gate
+# (`tests/deploy/test_onnx_parity.py`) needs to run one. A policy whose ONNX
+# file merely loads is not a validated export, so the suite executes the graph
+# and compares actions against the numpy artifact.
+dev = [
+  "pytest>=9",
+  "torch>=2.14",
+  "tensorboard>=2.21",
+  "matplotlib>=3.9",
+  "tt-rl[onnx]",
+  "onnxruntime>=1.20",
+  "tt-rl[atari]",
+  "tt-rl[mujoco]",
+]
+
+[project.urls]
+Homepage = "https://github.com/scaleresearch/tt-rl"
+Repository = "https://github.com/scaleresearch/tt-rl"
+Issues = "https://github.com/scaleresearch/tt-rl/issues"
+
+[project.scripts]
+# The CLI is a thin argparse shell over the same public API an external
+# script calls, so anything it can do, `import ttrl` can do too.
+ttrl = "ttrl.cli:main"
+
+[tool.setuptools.dynamic]
+version = { attr = "ttrl.__version__" }
+
+[tool.setuptools.packages.find]
+include = ["ttrl*"]
+
+[tool.pytest.ini_options]
+# Only `tests/` holds tests, so a bare `pytest` at the repo root never reaches
+# into `tools/`, which is developer tooling rather than a test suite.
+testpaths = ["tests"]
+# A bare `pytest` must not open a chip. The `tt` marker is what says a test
+# needs one, and `tt`-marked tests live all over `tests/`, not only in
+# `tests/hardware`, so deselecting the directory is not enough and a
+# command-line `-m` still overrides this to reach them.
+addopts = '-m "not tt"'
+markers = [
+  "tt: requires real Tenstorrent hardware (/dev/tenstorrent/*)",
+]

tt_rl-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+