neuropress 0.1.0__tar.gz

neuropress-0.1.0/.editorconfig

@@ -0,0 +1,30 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.py]
+indent_style = space
+indent_size = 4
+max_line_length = 88
+
+[*.{toml,cfg,ini}]
+indent_style = space
+indent_size = 4
+
+[*.{yml,yaml}]
+indent_style = space
+indent_size = 2
+
+[*.{json,jsonc}]
+indent_style = space
+indent_size = 2
+
+[*.md]
+trim_trailing_whitespace = false
+
+[Makefile]
+indent_style = tab

neuropress-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,67 @@
+name: ci
+
+# Lint and test on every push to main and every pull request.
+#
+# The release workflow (publish.yml) verifies that the *artifact* installs and
+# imports; this one verifies that the *code* is correct. Both gate a release:
+# publish.yml runs on a tag, by which point these checks have already run on the
+# commit being tagged.
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: ci-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: ruff
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.13"
+
+      # Mirrors the blocking half of `./run check`. Pinned so a new ruff release
+      # cannot fail CI on a commit that did not change; bump it deliberately.
+      - name: Lint
+        run: uvx ruff@0.15.2 check .
+
+      - name: Format
+        run: uvx ruff@0.15.2 format --check .
+
+  test:
+    name: pytest
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.13"
+
+      - name: Install
+        run: |
+          set -euo pipefail
+          uv venv --python 3.13
+          # CPU torch first: the default PyPI wheel bundles CUDA (~2.5 GB) and
+          # fills the runner disk. Installing it up front leaves the project
+          # install below with the requirement already satisfied.
+          uv pip install --python .venv torch --index-url https://download.pytorch.org/whl/cpu
+          # `cloud` is needed for collection, not just for coverage:
+          # tests/test_cloud_runner.py imports neuropress.cloud.vast_runner,
+          # which imports rich at module scope.
+          uv pip install --python .venv -e ".[dev,cloud]"
+
+      - name: Test
+        # Integration tests need HuggingFace downloads and several minutes; they
+        # are additionally gated behind RUN_INTEGRATION inside the module.
+        run: .venv/bin/python -m pytest --ignore=tests/integration -q

neuropress-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,183 @@
+name: publish
+
+# Build neuropress and upload it to PyPI.
+#
+#   release (published)  ->  PyPI      (the tag must match the package version)
+#   workflow_dispatch    ->  TestPyPI  (rehearsal; no tag check)
+#
+# Authentication is PyPI Trusted Publishing (OIDC). No API token is stored in
+# this repository, so there is nothing to rotate or leak. One-time setup, on
+# both pypi.org and test.pypi.org, before the first upload:
+#
+#   Your projects -> Publishing -> Add a pending publisher
+#     PyPI project name : neuropress
+#     Owner             : DreamerMind
+#     Repository        : neuropress
+#     Workflow name     : publish.yml
+#     Environment       : pypi        (use "testpypi" on test.pypi.org)
+#
+# Cutting a release:
+#   1. bump `version` in pyproject.toml and commit it
+#   2. gh release create v<version> --generate-notes
+#
+# PyPI is append-only: a version number can never be reused, not even after the
+# file is deleted. Rehearse with "Run workflow" against TestPyPI first.
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: publish-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  build:
+    name: build and verify artifacts
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.13"
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - name: Validate package metadata
+        run: uvx twine check --strict dist/*
+
+      - name: Tag must match the built version
+        if: github.event_name == 'release'
+        run: |
+          # Compare as versions, not as strings: a wheel filename is always
+          # PEP 440-normalized, so `version = "1.0.0-rc1"` builds as 1.0.0rc1
+          # and would never string-match the natural tag v1.0.0-rc1.
+          set -euo pipefail
+          built=$(basename "$(ls dist/*.whl)" | cut -d- -f2)
+          uv run --no-project --with packaging python - "$built" "${GITHUB_REF_NAME#v}" <<'PY'
+          import sys
+
+          from packaging.version import InvalidVersion, Version
+
+          built, tag = sys.argv[1], sys.argv[2]
+          try:
+              match = Version(built) == Version(tag)
+          except InvalidVersion:
+              match = False
+          if not match:
+              print(
+                  f"::error::release tag {tag!r} and the built version {built!r} disagree — "
+                  "correct whichever is wrong (the tag, or `version` in pyproject.toml)"
+              )
+              raise SystemExit(1)
+          print(f"publishing neuropress {built}")
+          PY
+
+      - name: Artifacts must carry no research-only material
+        run: |
+          # Defence in depth. pyproject.toml already excludes these from both
+          # build targets, so a hit means an exclude pattern regressed. Uploads
+          # are permanent, so fail closed rather than warn.
+          #
+          # Build the listing before grepping it: `unzip -l ... | grep` inside an
+          # `if` swallows a failing unzip, and a check that cannot read the
+          # artifact must not report it clean.
+          #
+          # `unzip -Z1` lists bare paths. `unzip -l` pads each name into a
+          # right-hand column, which leaves a top-level `reports/` preceded by
+          # spaces rather than by start-of-line, so the anchor below could never
+          # match it and the wheel half of this check would be dead code.
+          set -euo pipefail
+          wheel=$(ls dist/*.whl)
+          sdist=$(ls dist/*.tar.gz)
+          listing=$(unzip -Z1 "$wheel"; tar -tzf "$sdist")
+          # Scoped to scripts/: a bare `_diag\.py` also matches shipped modules
+          # such as neuropress/calibration/probe/hessian_diag.py.
+          pattern='research_registry|research_jobs|sync_public|public-manifest'
+          pattern="$pattern"'|(^|/)scripts/(qwen35|gemma4)_'
+          pattern="$pattern"'|(^|/)(reports|plans|docs|papers|sweeps)/'
+          if grep -Ei "$pattern" <<<"$listing"; then
+            echo "::error::research-only paths found in the distribution artifacts"
+            exit 1
+          fi
+          echo "artifacts clean: $wheel $sdist"
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  smoke:
+    name: built wheel installs and imports
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.13"
+
+      - name: Install the wheel with base dependencies only
+        run: |
+          uv venv --python 3.13 .venv
+          # torch's default PyPI wheel bundles CUDA (~2.5 GB) and fills the
+          # runner disk. The CPU build is all an import check needs.
+          uv pip install --python .venv torch --index-url https://download.pytorch.org/whl/cpu
+          uv pip install --python .venv dist/*.whl
+
+      - name: Import from outside the workspace
+        run: |
+          # Never run this from a directory containing neuropress/: python puts
+          # the working directory on sys.path, so the import would resolve to
+          # the source tree and prove nothing about the wheel.
+          mkdir -p "$RUNNER_TEMP/smoke"
+          cd "$RUNNER_TEMP/smoke"
+          "$GITHUB_WORKSPACE/.venv/bin/python" - <<'PY'
+          from importlib.metadata import version
+
+          import importlib.util
+
+          import neuropress
+          from neuropress.t2n import NEUROPRESS_COMPRESSION as registry
+
+          print(f"neuropress {version('neuropress')} from {neuropress.__file__}")
+          assert registry, "compression registry is empty"
+
+          # The invariant is that the research module is absent, not that its
+          # entries happen to share a key prefix — a prefix nothing enforces.
+          spec = importlib.util.find_spec("neuropress.t2n.research_registry")
+          assert spec is None, f"research module reached the wheel: {spec.origin}"
+          print(f"{len(registry)} compression entries, research module absent")
+          PY
+
+  publish:
+    name: upload to ${{ github.event_name == 'release' && 'PyPI' || 'TestPyPI' }}
+    needs: [build, smoke]
+    runs-on: ubuntu-latest
+    environment:
+      name: ${{ github.event_name == 'release' && 'pypi' || 'testpypi' }}
+      url: ${{ github.event_name == 'release' && 'https://pypi.org/p/neuropress' || 'https://test.pypi.org/p/neuropress' }}
+    permissions:
+      id-token: write # mints the OIDC token trusted publishing exchanges for an upload token
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist
+
+      - uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          repository-url: ${{ github.event_name == 'release' && 'https://upload.pypi.org/legacy/' || 'https://test.pypi.org/legacy/' }}
+          # Rehearsals re-upload the same version repeatedly; a real release
+          # must still fail loudly if that version is already on PyPI.
+          skip-existing: ${{ github.event_name != 'release' }}

neuropress-0.1.0/.gitignore

@@ -0,0 +1,100 @@
+# === Python ===
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+wheels/
+MANIFEST
+pip-wheel-metadata/
+share/python-wheels/
+
+# === Virtual environments ===
+.venv/
+venv/
+env/
+.env/
+
+# === uv / pip ===
+uv.lock
+pip-selfcheck.json
+
+# === Testing & coverage ===
+.pytest_cache/
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+.tox/
+.nox/
+
+# === Type checkers ===
+.mypy_cache/
+.pyright/
+.dmypy.json
+pyrightconfig.json
+
+# === PyTorch artefacts ===
+*.pt
+*.pth
+*.ckpt
+*.bin
+*.safetensors
+
+# === ONNX / NNEF artefacts ===
+*.onnx
+*.nnef
+*.nnef.tar
+*.rgg
+
+# === Jupyter ===
+.ipynb_checkpoints/
+*.ipynb
+
+# === IDEs ===
+.idea/
+.vscode/
+*.sublime-project
+*.sublime-workspace
+*.code-workspace
+*.iml
+.metals/
+.bloop/
+
+# === macOS ===
+.DS_Store
+.AppleDouble
+.LSOverride
+._*
+.Spotlight-V100
+.Trashes
+
+# === Linux ===
+*~
+.fuse_hidden*
+.Trash-*
+
+# === Windows ===
+Thumbs.db
+ehthumbs.db
+Desktop.ini
+
+# === Logs & temp ===
+*.log
+*.tmp
+*.bak
+*.swp
+*.swo
+
+# === neuropress output ===
+/data/
+vast_output/
+.ruff_cache/
+.ty_cache/
+papers/
+.cachesize
+.tmp_inst.json

neuropress-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,16 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.11.5
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: ty
+        name: ty
+        entry: uv run ty check
+        language: system
+        types: [python]
+        pass_filenames: false

neuropress-0.1.0/.prospector.yaml

@@ -0,0 +1,43 @@
+strictness: medium
+doc-warnings: false
+test-warnings: false
+
+# ruff already handles pycodestyle and pyflakes
+without-tools:
+  - pycodestyle
+  - pyflakes
+
+ignore-patterns:
+  - .venv
+
+mccabe:
+  options:
+    # GPTQ and hessian methods are inherently complex multi-branch algorithms.
+    max-complexity: 20
+
+pylint:
+  options:
+    # Scientific / ML code naturally has many parameters and local variables.
+    max-args: 10
+    max-locals: 28
+    max-branches: 20
+    # Allow extension-pkg access (torch._C, torch.cuda, etc.)
+    extension-pkg-allow-list:
+      - torch
+
+  disable:
+    # Lazy / conditional imports are intentional in this codebase
+    # (OffloadedTensor, datasets, GranularityType, os, …).
+    - import-outside-toplevel
+    # Hook callbacks must match PyTorch signatures; unused args are structural.
+    - unused-argument
+    # Accessing _clone_weights / _LinAlgError on peer classes is intentional.
+    - protected-access
+    # torch.linalg.cholesky is callable; pylint static analysis is wrong.
+    - not-callable
+    # torch._C members are C-extension; unavailable at static analysis time.
+    - c-extension-no-member
+    # Project does not use Django.
+    - django-not-available
+    # Scientific APIs naturally have more than 5 positional parameters.
+    - too-many-positional-arguments

neuropress-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

neuropress-0.1.0/ARCHITECTURE.md

@@ -0,0 +1,110 @@
+# neuropress architecture
+
+## Commands
+
+```bash
+# Install dependencies (Python 3.13, managed with uv)
+uv sync
+
+# Install with optional LLM data loader (HuggingFace datasets)
+uv sync --extra llm
+
+# Run all unit tests
+uv run pytest
+
+# Run a single test file
+uv run pytest tests/test_pipeline.py -v
+
+# Run a single test by name
+uv run pytest tests/test_pipeline.py::TestQuantizationPipeline::test_pipeline_runs -v
+
+# Run integration tests (downloads ~500 MB model, requires RUN_INTEGRATION=1)
+RUN_INTEGRATION=1 uv run pytest tests/integration/ -v
+```
+
+## Architecture
+
+`neuropress` is a graph-aware neural network quantization framework targeting NNEF export via `torch_to_nnef`. The full pipeline proceeds in six steps (see `pipeline.py`):
+
+1. **QGraph** – `RuntimeModuleGraphProvider` traces a single forward pass using PyTorch module hooks to build a `QGraph` (`nodes: Dict[str, QNode]`, `values: Dict[str, QValue]`). No symbolic tracing (FX/Dynamo) is used.
+
+2. **Targets** – `WeightTarget` (`module_id/param_name`) and `ActivationTarget` (`value_id`) identify what to quantize.
+
+3. **StatisticsRegistry** – `QuantizationParamEstimator.declare_statistics()` returns `StatisticRequest` objects. The registry deduplicates them (key = `target_key::stat_type`), installs hooks, runs a forward pass over calibration data, and stores results. Supported stat types: `"min_max"` and `"hessian"`.
+
+4. **QuantizationRecipe** – ties together `allowed_weight_qschemes`, `allowed_activation_qschemes`, a `QuantizationParamEstimator`, and a `ModuleQuantizationAdapter`.
+
+5. **QuantizationPlan** – the output of estimation: dicts mapping target keys to `ZpScaleScheme` or `QSchemeGroup` instances.
+
+6. **ModuleQuantizationAdapter** – applies the plan to the model (abstract; user-supplied).
+
+### Key abstractions
+
+| Class | Role |
+|---|---|
+| `QSchemeDescriptor` | Static backend constraint (nbits, symmetric, granularity) |
+| `ZpScaleScheme` | Concrete affine scheme (zero_point, scale, nbits); extends `torch_to_nnef.QScheme` |
+| `QSchemeGroup` / `PanelSpec` / `TensorSlice` | Mixed-precision grouping of weight regions |
+| `CalibrationMethod` | ABC for algorithms; subclasses implement `update_statistics` + `compute_qscheme` |
+| `CalibrationMethodOnActivation` | Subclass of above for Hessian-based methods (GPTQ) |
+| `GPTQCalibration` | Full GPTQ implementation (Frantar et al. ICLR 2023) |
+| `GPTQMixedPrecisionCalibration` | GPTQ with per-column-group bit-width allocation via `MixedAllocationStrategy` |
+| `MixedPrecisionLinear` | Drop-in replacement for `nn.Linear` produced by `split_mixed_precision_linear` |
+
+### Calibration data shapes (4-D convention)
+
+Weights are reshaped to `[rows, 1, n_groups, group_size]` before quantization. Odd dims (1, group_size) are "reduction" dims; even dims (rows, n_groups) are "kept". `qscheme_data_shape` is the same rank with reduction dims set to 1.
+
+### `StatField` annotation pattern
+
+`CalibrationMethod` subclasses declare statistic dependencies via `Annotated` type hints. The registry auto-discovers and injects them — no manual wiring needed.
+
+```python
+hessian: Annotated[Optional[torch.Tensor], StatField("hessian", "hessian")] = None
+```
+
+`StatField(stat_type, field_key)`:
+- `stat_type` — matches the string key in `StatisticRequest` (`"hessian"`, `"hessian_diag"`, `"min_max"`).
+- `field_key` — the attribute name to populate on the method instance.
+
+Flow: `StatisticsRegistry.register_method(method, target_key)` scans `Annotated` hints to build `StatisticRequest` objects. After collection, `registry.inject(method, target_key)` sets the annotated fields from stored results. The pattern lives across three files: `calibration/probe/collectors.py` (StatField), `calibration/probe/registry.py` (discover + inject), and each `CalibrationMethod` subclass.
+
+### Estimator config / implementation split
+
+`VptqGroupEstimatorConfig` (`estimator_configs.py`) is the user-facing Pydantic model; `VPTQGroupEstimator` (`estimators.py`) is the runtime dataclass. The config's `build()` passes every field explicitly, so **`VPTQGroupEstimator` is the single source of truth for defaults** — `VptqGroupEstimatorConfig` derives its defaults from the dataclass fields via `_vd()` at class definition time. If you add a field to `VPTQGroupEstimator`, add a corresponding `_vd("field_name")` default in the config.
+
+### Pipeline wiring: `_cache` and `_spans`
+
+`QuantizationParamEstimator` declares `_cache: CacheManager` and `_spans: SpanCollector` as class attributes with no-op defaults. The pipeline calls `set_cache()` and `set_span_collector()` before `prepare()`. Subclasses use `self._cache` / `self._spans` directly — no `getattr` fallback needed.
+
+### Compression registry (`neuropress/t2n/registry.py`)
+
+Follows the `torch_to_nnef` registry pattern: a dict (`NEUROPRESS_COMPRESSION`) maps string keys to callables with signature `fn(model, tokenizer=..., **kwargs) -> model`. Pass it to `LLMExporter.prepare`:
+
+```python
+exporter.prepare(
+    compression_method="open_text_c4_gptq_q4_0",
+    compression_registry="neuropress.t2n.registry.NEUROPRESS_COMPRESSION",
+)
+```
+
+Every entry is built by `_make_entry(config)`, which binds a `QuantizationRecipeConfig` into a `functools.partial` of `run_quantization_pipeline` and stashes the config JSON on the partial as `__config__` so the manifest can record it. Calling an entry:
+
+1. Reads `QuantizationRecipe.calibration` and loads batches from `calibration.DATASET_REGISTRY`
+2. Transfers batches to the model device one at a time (no OOM on large calibration sets)
+3. Delegates to `QuantizationPipeline`, which runs the six steps above
+4. Applies kernel lowering when the recipe configures one
+
+Recipes can also be built from JSON via `QuantizationRecipeConfig.from_json(...).build()`, which resolves component types from the registries at deserialization time.
+
+Layers whose `in_features` is not a multiple of the group size are skipped (Q4_0 group size = 32).
+
+Registry entries: `"open_text_c4_gptq_q4_0"` (128 samples), `"open_text_c4_gptq_q4_0_32samples"`, `"open_text_c4_gptq_q4_0_256samples"`.
+
+### LLM calibration data
+
+`neuropress.calibration.data.llm.load_c4_calibration(tokenizer, ...)` loads C4 samples as `{"input_ids": Tensor[batch_size, seq_len]}` dicts. Requires the `llm` optional dependency (`datasets`).
+
+### Integration test pattern
+
+The integration test (`tests/integration/test_gptq_nnef_export.py`) demonstrates the end-to-end workflow: HuggingFace model load → C4 calibration → layer-by-layer GPTQ → `torch_to_nnef` NNEF export. It is gated behind `RUN_INTEGRATION=1` and also requires `transformers` and `datasets`.

neuropress-0.1.0/Dockerfile.vast

@@ -0,0 +1,82 @@
+# Dockerfile.vast — pre-baked base image for neuropress vast.ai GPU jobs.
+#
+# Cuts cold-start time from ~15 min to ~3 min by pre-warming the uv package
+# cache inside the image layer.  On a fresh instance, uv sync only needs to
+# install the neuropress source itself (a few seconds), not re-download torch
+# or any other dependency.
+#
+# Build and push once:
+#
+#   DOCKER_BUILDKIT=1 docker build -f Dockerfile.vast -t <user>/neuropress-base:latest .
+#   docker push <user>/neuropress-base:latest
+#
+# Subsequent rebuilds after a pyproject.toml change are fast (~30 s) because
+# BuildKit caches the downloaded packages on the build host.  The first build
+# still downloads everything (~9 min).
+#
+# Then tell neuropress-vast to use it:
+#
+#   export NEUROPRESS_DOCKER_IMAGE=<user>/neuropress-base:latest
+#   neuropress-vast --job neuropress-eval-compare ...
+#
+# The image must be public (vast.ai pulls without auth by default).
+# Re-build any time pyproject.toml dependencies change.
+
+# Slim CUDA 12.4 runtime — ~800 MB compressed vs ~5 GB for pytorch/pytorch.
+# PyTorch is installed via uv from PyPI below, so we don't need it in the base.
+FROM nvidia/cuda:13.0.2-cudnn-runtime-ubuntu24.04
+
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# System tools needed by setup commands:
+#   tmux     — disconnect-resilient job executor
+#   build-essential — g++/make for torch-to-nnef C++ extension
+#   ninja-build — required by torch.utils.cpp_extension for CUDA JIT kernels
+#   cuda-nvcc — nvcc compiler for CUDA JIT (runtime images lack it)
+#   curl     — uv installer
+#   git      — some HuggingFace libs call git
+#
+# Cache mounts keep downloaded .deb files on the build host so subsequent
+# builds skip re-downloading them.  The mounts are not part of the image
+# layer, so no rm -rf /var/lib/apt/lists/* is needed.
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt,sharing=locked \
+    apt-get update -qq && \
+    apt-get install -y --no-install-recommends \
+        tmux build-essential ninja-build cuda-nvcc curl ca-certificates git
+
+# Install uv
+RUN curl -LsSf https://astral.sh/uv/install.sh | sh
+ENV PATH="/root/.local/bin:$PATH"
+ENV UV_CACHE_DIR=/root/.cache/uv
+
+# Pre-install Python 3.13.
+# Cache mount keeps the CPython tarball on the build host; the installed
+# binary goes to ~/.local/share/uv/python (baked into the image layer).
+RUN --mount=type=cache,target=/root/.cache/uv \
+    uv python install 3.13
+
+# ── Pre-warm the uv package cache ────────────────────────────────────────────
+# Copy only the dependency manifest (not the source) so this layer is rebuilt
+# only when dependencies change, not on every code change.
+WORKDIR /tmp/neuropress-seed
+COPY pyproject.toml ./
+# hatchling needs a minimal package layout to resolve the project
+RUN mkdir -p neuropress && \
+    printf '"""neuropress."""\n' > neuropress/__init__.py && \
+    touch README.md
+
+# Download packages to the BuildKit cache (/tmp/uv-cache, preserved on the
+# build host between runs).  On first build this takes ~9 min; on subsequent
+# rebuilds after a dependency change uv resolves from cache in ~30 s.
+# After sync, cp bakes the populated cache into UV_CACHE_DIR (image layer) so
+# that `uv sync` on a fresh vast.ai instance needs no network downloads.
+RUN --mount=type=cache,target=/tmp/uv-cache,sharing=locked \
+    UV_CACHE_DIR=/tmp/uv-cache \
+    uv sync --extra llm --extra eval --extra dev && \
+    rm -rf .venv && \
+    mkdir -p "$UV_CACHE_DIR" && \
+    cp -a /tmp/uv-cache/. "$UV_CACHE_DIR/"
+
+WORKDIR /workspace