trainproof 0.1.0__tar.gz → 0.2.0__tar.gz

trainproof-0.2.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: trainproof
+Version: 0.2.0
+Summary: A deterministic linter for ML training runs: dataset, tokenizer, and epoch logs.
+Author-email: "Panagiotis (Panos) Gkilis" <bedvibe@bedvibe.studio>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: soundfile
+Requires-Dist: ttsproof
+
+# trainproof
+
+[![PyPI](https://img.shields.io/pypi/v/trainproof)](https://pypi.org/project/trainproof/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**A deterministic linter for ML training runs.** Point it at your dataset, your
+tokenizer, or your first-epoch logs — it returns a PASS / WARN / FAIL verdict
+with named findings and cited evidence, before you burn days of GPU time on a
+run that was doomed at step 50.
+
+No ML judging ML. No invented "confidence 97%". Every rule is a deterministic
+threshold in [one auditable module](src/trainproof/rules.py), and every finding
+cites the numbers that triggered it.
+
+```bash
+pip install trainproof
+```
+
+## See a verdict in 60 seconds
+
+This repo ships the real logs of five QLoRA fine-tuning runs (Qwen2.5-3B,
+RTX 5080 — see the gallery below). Judge one right now:
+
+```bash
+trainproof epoch examples/gallery/lr_hot/trainer_state.json --format hf
+```
+
+```text
+[FAIL] Critical checks failed:
+  [FAIL] Loss curve is diverging.
+         Evidence: End loss 7.492 vs Min loss 1.398
+  [FAIL] Loss never improved over the run (dead run).
+  [WARN] Gradient norm spikes detected.
+         Evidence: Max gn 2649.75 > 10.0x median (0.55)
+```
+
+## Why this exists
+
+The author lost a real 11-hour fine-tune to a failure nothing warned about.
+Pointed retroactively at that run's 1MB Coqui Trainer log (2,501 logged steps),
+trainproof's verdict: **FAIL — diverging**. The loss reached its minimum at 82%
+of the run and ended 1.9x above it. Translation: the final two hours of GPU
+time made the model measurably worse, and the checkpoint worth keeping had
+already existed for hours. No tool in the stack said a word.
+
+## The fault-injection gallery
+
+To validate the rules, the same QLoRA fine-tune (Qwen2.5-3B-Instruct, 4-bit,
+LoRA r=16, 300 steps on Alpaca-cleaned) was run five times — once healthy, four
+times with exactly one knob deliberately broken. Real runs, real logs, all
+shipped in [`examples/gallery/`](examples/gallery/):
+
+| Run | Sabotage | Verdict | Key evidence |
+|---|---|---|---|
+| `healthy` | none | **PASS** | loss 1.52 → 0.94, stable gradients |
+| `lr_hot` | LR x100 (2e-2) | **FAIL** | diverging: end 7.49 vs min 1.40; grad spike 2650 vs median 0.55 |
+| `lr_zero` | LR = 0 | **FAIL** | dead run: first-5 median 1.52 vs last-5 1.49 (<5% improvement); lr=0 on 100% of steps |
+| `fp16_nan` | fp16 + hot LR, no clipping | **FAIL** | diverging: end 7.21 vs min 1.09 (grad scaling absorbed the intended NaN — the run diverged instead; reported as observed) |
+| `bad_labels` | labels shuffled per-sequence | **WARN only** — see below | grad spike 23.3 vs median 1.09 |
+
+### The honest finding: loss curves cannot see corrupted data
+
+The `bad_labels` run — whose shuffled labels make real learning impossible —
+*reduced its loss by 62%* (18.9 → 5.75). The model was genuinely learning: not
+the task, but the marginal token statistics of the garbage. From its own loss
+curve, that is indistinguishable from healthy training (neural networks
+famously fit random labels). **No single-run, loss-only rule can catch this
+class of failure** — its real signature is *relative*: a loss floor ~6x higher
+than a known-good run of the same task (5.59 vs 0.94).
+
+That finding sets the roadmap: v0.3 is `trainproof compare <run> <baseline>` —
+deterministic ratio rules against the healthy baseline you already have.
+See [ROADMAP.md](ROADMAP.md). (The gallery also improved v0.2 itself: the
+dead-run rule exists because `lr_zero` initially escaped with only a WARN.)
+
+## The three commands
+
+```bash
+# 1. Dataset preflight (speech/TTS pack): audio integrity, transcript quality,
+#    duplicates, text-vs-audio duration mismatches
+trainproof data /path/to/dataset_or_manifest.jsonl
+
+# 2. Tokenizer preflight: vocabulary coverage, OOV rate, sequence blowouts,
+#    suspicious splits on numbers/dates
+trainproof tokenizer my_tokenizer.model transcripts.txt
+
+# 3. Training-run verdict: NaN/divergence/dead-run detection, gradient spikes,
+#    LR sanity, throughput — from log files, any framework
+trainproof epoch logs/run.jsonl            # exit code 1 on FAIL: CI-ready
+```
+
+Each command prints the verdict, writes a self-contained HTML report, and sets
+the process exit code — so it works as a CI gate out of the box.
+
+## Supported log formats
+
+- HuggingFace Trainer (`trainer_state.json`)
+- Coqui Trainer text logs (ANSI-colored `trainer_0_log.txt`)
+- Generic JSONL / CSV (columns: step, loss, lr, grad_norm, time — all optional)
+
+Auto-detected; override with `--format hf|coqui|jsonl|csv`. TensorBoard event
+files are planned (Lightning console captures are TTY dumps, not logs, and
+will not be supported).
+
+## Philosophy
+
+1. **Deterministic.** A rule fires or it doesn't. Thresholds live in one
+   module, commented, tunable.
+2. **Evidence-cited.** Every finding names the steps and values that triggered
+   it.
+3. **Honest about limits.** What the tool cannot detect is documented in the
+   README, not discovered by the user in production.
+
+## Family
+
+trainproof judges training runs. Its sibling [ttsproof](https://github.com/Mormolykos/ttsproof)
+judges TTS model *outputs* (structural audio checks, equivalence-aware WER/CER,
+published method with DOI) — and trainproof builds on it for the speech
+dataset checks.
+
+## Author
+
+Panagiotis (Panos) Gkilis — [portfolio](https://tts.bedvibe.studio/portfolio/) ·
+[bedvibe.studio](https://bedvibe.studio/)
+
+MIT license.

trainproof-0.2.0/README.md

@@ -0,0 +1,126 @@
+# trainproof
+
+[![PyPI](https://img.shields.io/pypi/v/trainproof)](https://pypi.org/project/trainproof/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**A deterministic linter for ML training runs.** Point it at your dataset, your
+tokenizer, or your first-epoch logs — it returns a PASS / WARN / FAIL verdict
+with named findings and cited evidence, before you burn days of GPU time on a
+run that was doomed at step 50.
+
+No ML judging ML. No invented "confidence 97%". Every rule is a deterministic
+threshold in [one auditable module](src/trainproof/rules.py), and every finding
+cites the numbers that triggered it.
+
+```bash
+pip install trainproof
+```
+
+## See a verdict in 60 seconds
+
+This repo ships the real logs of five QLoRA fine-tuning runs (Qwen2.5-3B,
+RTX 5080 — see the gallery below). Judge one right now:
+
+```bash
+trainproof epoch examples/gallery/lr_hot/trainer_state.json --format hf
+```
+
+```text
+[FAIL] Critical checks failed:
+  [FAIL] Loss curve is diverging.
+         Evidence: End loss 7.492 vs Min loss 1.398
+  [FAIL] Loss never improved over the run (dead run).
+  [WARN] Gradient norm spikes detected.
+         Evidence: Max gn 2649.75 > 10.0x median (0.55)
+```
+
+## Why this exists
+
+The author lost a real 11-hour fine-tune to a failure nothing warned about.
+Pointed retroactively at that run's 1MB Coqui Trainer log (2,501 logged steps),
+trainproof's verdict: **FAIL — diverging**. The loss reached its minimum at 82%
+of the run and ended 1.9x above it. Translation: the final two hours of GPU
+time made the model measurably worse, and the checkpoint worth keeping had
+already existed for hours. No tool in the stack said a word.
+
+## The fault-injection gallery
+
+To validate the rules, the same QLoRA fine-tune (Qwen2.5-3B-Instruct, 4-bit,
+LoRA r=16, 300 steps on Alpaca-cleaned) was run five times — once healthy, four
+times with exactly one knob deliberately broken. Real runs, real logs, all
+shipped in [`examples/gallery/`](examples/gallery/):
+
+| Run | Sabotage | Verdict | Key evidence |
+|---|---|---|---|
+| `healthy` | none | **PASS** | loss 1.52 → 0.94, stable gradients |
+| `lr_hot` | LR x100 (2e-2) | **FAIL** | diverging: end 7.49 vs min 1.40; grad spike 2650 vs median 0.55 |
+| `lr_zero` | LR = 0 | **FAIL** | dead run: first-5 median 1.52 vs last-5 1.49 (<5% improvement); lr=0 on 100% of steps |
+| `fp16_nan` | fp16 + hot LR, no clipping | **FAIL** | diverging: end 7.21 vs min 1.09 (grad scaling absorbed the intended NaN — the run diverged instead; reported as observed) |
+| `bad_labels` | labels shuffled per-sequence | **WARN only** — see below | grad spike 23.3 vs median 1.09 |
+
+### The honest finding: loss curves cannot see corrupted data
+
+The `bad_labels` run — whose shuffled labels make real learning impossible —
+*reduced its loss by 62%* (18.9 → 5.75). The model was genuinely learning: not
+the task, but the marginal token statistics of the garbage. From its own loss
+curve, that is indistinguishable from healthy training (neural networks
+famously fit random labels). **No single-run, loss-only rule can catch this
+class of failure** — its real signature is *relative*: a loss floor ~6x higher
+than a known-good run of the same task (5.59 vs 0.94).
+
+That finding sets the roadmap: v0.3 is `trainproof compare <run> <baseline>` —
+deterministic ratio rules against the healthy baseline you already have.
+See [ROADMAP.md](ROADMAP.md). (The gallery also improved v0.2 itself: the
+dead-run rule exists because `lr_zero` initially escaped with only a WARN.)
+
+## The three commands
+
+```bash
+# 1. Dataset preflight (speech/TTS pack): audio integrity, transcript quality,
+#    duplicates, text-vs-audio duration mismatches
+trainproof data /path/to/dataset_or_manifest.jsonl
+
+# 2. Tokenizer preflight: vocabulary coverage, OOV rate, sequence blowouts,
+#    suspicious splits on numbers/dates
+trainproof tokenizer my_tokenizer.model transcripts.txt
+
+# 3. Training-run verdict: NaN/divergence/dead-run detection, gradient spikes,
+#    LR sanity, throughput — from log files, any framework
+trainproof epoch logs/run.jsonl            # exit code 1 on FAIL: CI-ready
+```
+
+Each command prints the verdict, writes a self-contained HTML report, and sets
+the process exit code — so it works as a CI gate out of the box.
+
+## Supported log formats
+
+- HuggingFace Trainer (`trainer_state.json`)
+- Coqui Trainer text logs (ANSI-colored `trainer_0_log.txt`)
+- Generic JSONL / CSV (columns: step, loss, lr, grad_norm, time — all optional)
+
+Auto-detected; override with `--format hf|coqui|jsonl|csv`. TensorBoard event
+files are planned (Lightning console captures are TTY dumps, not logs, and
+will not be supported).
+
+## Philosophy
+
+1. **Deterministic.** A rule fires or it doesn't. Thresholds live in one
+   module, commented, tunable.
+2. **Evidence-cited.** Every finding names the steps and values that triggered
+   it.
+3. **Honest about limits.** What the tool cannot detect is documented in the
+   README, not discovered by the user in production.
+
+## Family
+
+trainproof judges training runs. Its sibling [ttsproof](https://github.com/Mormolykos/ttsproof)
+judges TTS model *outputs* (structural audio checks, equivalence-aware WER/CER,
+published method with DOI) — and trainproof builds on it for the speech
+dataset checks.
+
+## Author
+
+Panagiotis (Panos) Gkilis — [portfolio](https://tts.bedvibe.studio/portfolio/) ·
+[bedvibe.studio](https://bedvibe.studio/)
+
+MIT license.

{trainproof-0.1.0 → trainproof-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "trainproof"
-version = "0.1.0"
+version = "0.2.0"
 description = "A deterministic linter for ML training runs: dataset, tokenizer, and epoch logs."
 authors = [{name = "Panagiotis (Panos) Gkilis", email = "bedvibe@bedvibe.studio"}]
 readme = "README.md"

{trainproof-0.1.0 → trainproof-0.2.0}/src/trainproof/epoch.py

@@ -67,6 +67,16 @@ def check_epoch(log_path: str | Path, fmt: str = "auto") -> dict[str, Any]:
             findings.append({"level": "FAIL", "message": "Loss curve is diverging.", "evidence": f"End loss {valid_losses[-1]:.3f} vs Min loss {min_loss:.3f}"})
             verdict = "FAIL"
 
+        # Check no-improvement (dead run): robust start-vs-end median comparison
+        if len(valid_losses) >= rules.MIN_POINTS_FOR_IMPROVEMENT_CHECK:
+            w = rules.LOSS_IMPROVEMENT_WINDOW
+            start_med = sorted(valid_losses[:w])[w // 2]
+            end_med = sorted(valid_losses[-w:])[w // 2]
+            if start_med > 0 and end_med >= start_med * (1 - rules.MIN_LOSS_IMPROVEMENT):
+                findings.append({"level": "FAIL", "message": "Loss never improved over the run (dead run).",
+                                 "evidence": f"median of first {w} losses {start_med:.3f} vs last {w} {end_med:.3f} (needs >={rules.MIN_LOSS_IMPROVEMENT*100:.0f}% improvement)"})
+                verdict = "FAIL"
+
     # Check Grad Norm
     valid_gns = [g for g in grad_norms if not math.isnan(g) and not math.isinf(g)]
     if valid_gns and len(valid_gns) > 5:

{trainproof-0.1.0 → trainproof-0.2.0}/src/trainproof/rules.py

@@ -51,3 +51,13 @@ MAX_GRAD_NORM_SPIKE_RATIO = 10.0
 
 # If the learning rate is strictly zero for more than this fraction of the epoch, it's a warning.
 MAX_ZERO_LR_FRACTION = 0.1
+
+# Dead-run detection (added in v0.2 after fault-injection testing showed that
+# zero-LR and garbage-label runs — which can never learn — only earned WARNs):
+# the median of the last LOSS_IMPROVEMENT_WINDOW losses must be at least
+# MIN_LOSS_IMPROVEMENT (relative) below the median of the first window, else
+# the run never learned. Note: this targets FIRST-EPOCH linting; a model
+# resumed at its convergence floor would also trip it.
+MIN_LOSS_IMPROVEMENT = 0.05
+LOSS_IMPROVEMENT_WINDOW = 5
+MIN_POINTS_FOR_IMPROVEMENT_CHECK = 10

trainproof-0.2.0/src/trainproof.egg-info/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: trainproof
+Version: 0.2.0
+Summary: A deterministic linter for ML training runs: dataset, tokenizer, and epoch logs.
+Author-email: "Panagiotis (Panos) Gkilis" <bedvibe@bedvibe.studio>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: soundfile
+Requires-Dist: ttsproof
+
+# trainproof
+
+[![PyPI](https://img.shields.io/pypi/v/trainproof)](https://pypi.org/project/trainproof/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
+
+**A deterministic linter for ML training runs.** Point it at your dataset, your
+tokenizer, or your first-epoch logs — it returns a PASS / WARN / FAIL verdict
+with named findings and cited evidence, before you burn days of GPU time on a
+run that was doomed at step 50.
+
+No ML judging ML. No invented "confidence 97%". Every rule is a deterministic
+threshold in [one auditable module](src/trainproof/rules.py), and every finding
+cites the numbers that triggered it.
+
+```bash
+pip install trainproof
+```
+
+## See a verdict in 60 seconds
+
+This repo ships the real logs of five QLoRA fine-tuning runs (Qwen2.5-3B,
+RTX 5080 — see the gallery below). Judge one right now:
+
+```bash
+trainproof epoch examples/gallery/lr_hot/trainer_state.json --format hf
+```
+
+```text
+[FAIL] Critical checks failed:
+  [FAIL] Loss curve is diverging.
+         Evidence: End loss 7.492 vs Min loss 1.398
+  [FAIL] Loss never improved over the run (dead run).
+  [WARN] Gradient norm spikes detected.
+         Evidence: Max gn 2649.75 > 10.0x median (0.55)
+```
+
+## Why this exists
+
+The author lost a real 11-hour fine-tune to a failure nothing warned about.
+Pointed retroactively at that run's 1MB Coqui Trainer log (2,501 logged steps),
+trainproof's verdict: **FAIL — diverging**. The loss reached its minimum at 82%
+of the run and ended 1.9x above it. Translation: the final two hours of GPU
+time made the model measurably worse, and the checkpoint worth keeping had
+already existed for hours. No tool in the stack said a word.
+
+## The fault-injection gallery
+
+To validate the rules, the same QLoRA fine-tune (Qwen2.5-3B-Instruct, 4-bit,
+LoRA r=16, 300 steps on Alpaca-cleaned) was run five times — once healthy, four
+times with exactly one knob deliberately broken. Real runs, real logs, all
+shipped in [`examples/gallery/`](examples/gallery/):
+
+| Run | Sabotage | Verdict | Key evidence |
+|---|---|---|---|
+| `healthy` | none | **PASS** | loss 1.52 → 0.94, stable gradients |
+| `lr_hot` | LR x100 (2e-2) | **FAIL** | diverging: end 7.49 vs min 1.40; grad spike 2650 vs median 0.55 |
+| `lr_zero` | LR = 0 | **FAIL** | dead run: first-5 median 1.52 vs last-5 1.49 (<5% improvement); lr=0 on 100% of steps |
+| `fp16_nan` | fp16 + hot LR, no clipping | **FAIL** | diverging: end 7.21 vs min 1.09 (grad scaling absorbed the intended NaN — the run diverged instead; reported as observed) |
+| `bad_labels` | labels shuffled per-sequence | **WARN only** — see below | grad spike 23.3 vs median 1.09 |
+
+### The honest finding: loss curves cannot see corrupted data
+
+The `bad_labels` run — whose shuffled labels make real learning impossible —
+*reduced its loss by 62%* (18.9 → 5.75). The model was genuinely learning: not
+the task, but the marginal token statistics of the garbage. From its own loss
+curve, that is indistinguishable from healthy training (neural networks
+famously fit random labels). **No single-run, loss-only rule can catch this
+class of failure** — its real signature is *relative*: a loss floor ~6x higher
+than a known-good run of the same task (5.59 vs 0.94).
+
+That finding sets the roadmap: v0.3 is `trainproof compare <run> <baseline>` —
+deterministic ratio rules against the healthy baseline you already have.
+See [ROADMAP.md](ROADMAP.md). (The gallery also improved v0.2 itself: the
+dead-run rule exists because `lr_zero` initially escaped with only a WARN.)
+
+## The three commands
+
+```bash
+# 1. Dataset preflight (speech/TTS pack): audio integrity, transcript quality,
+#    duplicates, text-vs-audio duration mismatches
+trainproof data /path/to/dataset_or_manifest.jsonl
+
+# 2. Tokenizer preflight: vocabulary coverage, OOV rate, sequence blowouts,
+#    suspicious splits on numbers/dates
+trainproof tokenizer my_tokenizer.model transcripts.txt
+
+# 3. Training-run verdict: NaN/divergence/dead-run detection, gradient spikes,
+#    LR sanity, throughput — from log files, any framework
+trainproof epoch logs/run.jsonl            # exit code 1 on FAIL: CI-ready
+```
+
+Each command prints the verdict, writes a self-contained HTML report, and sets
+the process exit code — so it works as a CI gate out of the box.
+
+## Supported log formats
+
+- HuggingFace Trainer (`trainer_state.json`)
+- Coqui Trainer text logs (ANSI-colored `trainer_0_log.txt`)
+- Generic JSONL / CSV (columns: step, loss, lr, grad_norm, time — all optional)
+
+Auto-detected; override with `--format hf|coqui|jsonl|csv`. TensorBoard event
+files are planned (Lightning console captures are TTY dumps, not logs, and
+will not be supported).
+
+## Philosophy
+
+1. **Deterministic.** A rule fires or it doesn't. Thresholds live in one
+   module, commented, tunable.
+2. **Evidence-cited.** Every finding names the steps and values that triggered
+   it.
+3. **Honest about limits.** What the tool cannot detect is documented in the
+   README, not discovered by the user in production.
+
+## Family
+
+trainproof judges training runs. Its sibling [ttsproof](https://github.com/Mormolykos/ttsproof)
+judges TTS model *outputs* (structural audio checks, equivalence-aware WER/CER,
+published method with DOI) — and trainproof builds on it for the speech
+dataset checks.
+
+## Author
+
+Panagiotis (Panos) Gkilis — [portfolio](https://tts.bedvibe.studio/portfolio/) ·
+[bedvibe.studio](https://bedvibe.studio/)
+
+MIT license.

{trainproof-0.1.0 → trainproof-0.2.0}/tests/test_epoch.py

@@ -34,3 +34,10 @@ def test_epoch_flat():
     report = check_epoch(FIXTURES_DIR / "flat.jsonl")
     assert report["verdict"] == "FAIL"
     assert any("completely flat" in str(f) for f in report["findings"])
+
+def test_epoch_dead_noisy():
+    # noisy-but-never-improving loss with healthy lr: only the no-improvement
+    # rule (v0.2) can catch this dead run
+    report = check_epoch(FIXTURES_DIR / "dead_noisy.jsonl")
+    assert report["verdict"] == "FAIL"
+    assert any("never improved" in str(f) for f in report["findings"])

trainproof-0.1.0/PKG-INFO

@@ -1,62 +0,0 @@
-Metadata-Version: 2.4
-Name: trainproof
-Version: 0.1.0
-Summary: A deterministic linter for ML training runs: dataset, tokenizer, and epoch logs.
-Author-email: "Panagiotis (Panos) Gkilis" <bedvibe@bedvibe.studio>
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: soundfile
-Requires-Dist: ttsproof
-
-# Trainproof
-
-A deterministic linter for ML training runs. Run it on your dataset, tokenizer, and first-epoch logs — it gives a deterministic PASS/WARN/FAIL verdict with named findings and suggested fixes, BEFORE you burn weeks of GPU time.
-
-## Installation
-```bash
-pip install .
-```
-
-## Usage
-
-Exactly three subcommands:
-
-### 1. Dataset Preflight
-```bash
-trainproof data /path/to/dataset
-```
-Checks audio integrity (clipping, silence, duration distribution) and transcript quality (unnormalized text, charset audit, duration correlation).
-
-### 2. Tokenizer Preflight
-```bash
-trainproof tokenizer my_model.model transcripts.txt
-```
-Checks vocabulary coverage, tokens-per-second, and suspicious splits on numbers/dates.
-
-### 3. First-Epoch Verification
-```bash
-trainproof epoch logs/epoch1.jsonl
-```
-Analyzes loss curves (divergence, flatlines, NaN), grad norms, learning rate response, and throughput.
-
-## Supported log formats
-- **Generic JSONL / CSV**
-- **HuggingFace** (`trainer_state.json`)
-- **Coqui TTS Trainer** (plain text `trainer_0_log.txt`)
-
-*Roadmap: TensorBoard event files planned (v0.2) — Lightning console captures are TTY dumps, not logs, and will not be supported.*
-
-## Verdict Rules
-All verdict rules are deterministic thresholds defined centrally in `src/trainproof/rules.py`. Examples include:
-- `MAX_CLIPPING_PEAK = 0.99`
-- `MAX_LOSS_DIVERGENCE_RATIO = 1.5`
-- `MIN_VOCAB_COVERAGE = 0.999`
-
-## Explicit Non-Goals
-- No live learning-rate auto-adjustment.
-- No PyTorch/Lightning callbacks or framework hooks (log files only).
-- No MCP server, no LLM integration.
-- No dashboards/wandb-style UI.
-- No extra features beyond this spec.

trainproof-0.1.0/README.md

@@ -1,50 +0,0 @@
-# Trainproof
-
-A deterministic linter for ML training runs. Run it on your dataset, tokenizer, and first-epoch logs — it gives a deterministic PASS/WARN/FAIL verdict with named findings and suggested fixes, BEFORE you burn weeks of GPU time.
-
-## Installation
-```bash
-pip install .
-```
-
-## Usage
-
-Exactly three subcommands:
-
-### 1. Dataset Preflight
-```bash
-trainproof data /path/to/dataset
-```
-Checks audio integrity (clipping, silence, duration distribution) and transcript quality (unnormalized text, charset audit, duration correlation).
-
-### 2. Tokenizer Preflight
-```bash
-trainproof tokenizer my_model.model transcripts.txt
-```
-Checks vocabulary coverage, tokens-per-second, and suspicious splits on numbers/dates.
-
-### 3. First-Epoch Verification
-```bash
-trainproof epoch logs/epoch1.jsonl
-```
-Analyzes loss curves (divergence, flatlines, NaN), grad norms, learning rate response, and throughput.
-
-## Supported log formats
-- **Generic JSONL / CSV**
-- **HuggingFace** (`trainer_state.json`)
-- **Coqui TTS Trainer** (plain text `trainer_0_log.txt`)
-
-*Roadmap: TensorBoard event files planned (v0.2) — Lightning console captures are TTY dumps, not logs, and will not be supported.*
-
-## Verdict Rules
-All verdict rules are deterministic thresholds defined centrally in `src/trainproof/rules.py`. Examples include:
-- `MAX_CLIPPING_PEAK = 0.99`
-- `MAX_LOSS_DIVERGENCE_RATIO = 1.5`
-- `MIN_VOCAB_COVERAGE = 0.999`
-
-## Explicit Non-Goals
-- No live learning-rate auto-adjustment.
-- No PyTorch/Lightning callbacks or framework hooks (log files only).
-- No MCP server, no LLM integration.
-- No dashboards/wandb-style UI.
-- No extra features beyond this spec.

trainproof-0.1.0/src/trainproof.egg-info/PKG-INFO

@@ -1,62 +0,0 @@
-Metadata-Version: 2.4
-Name: trainproof
-Version: 0.1.0
-Summary: A deterministic linter for ML training runs: dataset, tokenizer, and epoch logs.
-Author-email: "Panagiotis (Panos) Gkilis" <bedvibe@bedvibe.studio>
-License: MIT
-Requires-Python: >=3.10
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: soundfile
-Requires-Dist: ttsproof
-
-# Trainproof
-
-A deterministic linter for ML training runs. Run it on your dataset, tokenizer, and first-epoch logs — it gives a deterministic PASS/WARN/FAIL verdict with named findings and suggested fixes, BEFORE you burn weeks of GPU time.
-
-## Installation
-```bash
-pip install .
-```
-
-## Usage
-
-Exactly three subcommands:
-
-### 1. Dataset Preflight
-```bash
-trainproof data /path/to/dataset
-```
-Checks audio integrity (clipping, silence, duration distribution) and transcript quality (unnormalized text, charset audit, duration correlation).
-
-### 2. Tokenizer Preflight
-```bash
-trainproof tokenizer my_model.model transcripts.txt
-```
-Checks vocabulary coverage, tokens-per-second, and suspicious splits on numbers/dates.
-
-### 3. First-Epoch Verification
-```bash
-trainproof epoch logs/epoch1.jsonl
-```
-Analyzes loss curves (divergence, flatlines, NaN), grad norms, learning rate response, and throughput.
-
-## Supported log formats
-- **Generic JSONL / CSV**
-- **HuggingFace** (`trainer_state.json`)
-- **Coqui TTS Trainer** (plain text `trainer_0_log.txt`)
-
-*Roadmap: TensorBoard event files planned (v0.2) — Lightning console captures are TTY dumps, not logs, and will not be supported.*
-
-## Verdict Rules
-All verdict rules are deterministic thresholds defined centrally in `src/trainproof/rules.py`. Examples include:
-- `MAX_CLIPPING_PEAK = 0.99`
-- `MAX_LOSS_DIVERGENCE_RATIO = 1.5`
-- `MIN_VOCAB_COVERAGE = 0.999`
-
-## Explicit Non-Goals
-- No live learning-rate auto-adjustment.
-- No PyTorch/Lightning callbacks or framework hooks (log files only).
-- No MCP server, no LLM integration.
-- No dashboards/wandb-style UI.
-- No extra features beyond this spec.