# IteraGPU Lab v1

Originalressourcen, Version vom 24. September 2026, zur Vorbereitung eines reproduzierbaren GPU-Experiments. Das Speicher-Notebook und sein Begleiter führen ein kleines synthetisches Netz `Linear → GELU → Linear` aus. Sie laden weder ein Modell noch einen Datensatz herunter. Dieses Netz ist weder ein LLM noch ein Training noch ein repräsentativer Benchmark für die zur Miete angebotenen GPUs.

## Inhalt

- `mesure-memoire.ipynb`: eigenständiges Notebook, Code enthalten, Zellen ohne gespeicherte Ausgaben.
- `mesure_memoire.py`: dieselbe Arithmetik und dasselbe Messprotokoll, nutzbar über die Kommandozeile.
- `protocole-qualite.md`: fachliches Protokoll, das vor dem Vergleich von Zeit und Kosten auszufüllen ist.
- `resultats-bruts.csv`: leeres Raster, eine Zeile pro tatsächlichem Durchlauf auszufüllen.
- `calcul_forfaits.py`: Berechnung des Gesamtpakets, ohne externe Abhängigkeit.
- `tarifs-forfaits.csv`: 45 IteraGPU-Tarife, 15 Modelle × 3 Laufzeiten, Momentaufnahme vom 24. September 2026.
- `LICENSE.txt`: MIT-Lizenz des Codes, des Notebooks und der Originaldokumente.
- `MANIFEST.json`: vollständige Liste der neun Elemente des Archivs, Größen und SHA-256 der acht Inhaltsdateien. Das Manifest erklärt sich selbst als ohne Prüfsumme, um eine selbstreferenzielle Prüfsumme zu vermeiden.

Das Archiv `iteragpu-lab-v1.zip` enthält diese neun Dateien unter einem einzigen Ordner. Es enthält weder ein GPU-Ergebnis noch eine Python-Umgebung noch einen Treiber noch einen Identifikator. Extrahieren Sie die Dateien in ein neues Verzeichnis. Das Notebook kann auch allein heruntergeladen werden: Es importiert nicht das Begleitskript.

## Voraussetzungen und Grenzen

Die arithmetischen Berechnungen und die Paketberechnung verwenden nur Python 3.10 oder neuer und seine Standardbibliothek. Das Notebook benötigt ein Werkzeug, das ein Python-Notebook öffnen kann; es wird kein Jupyter-Server bereitgestellt. Die Messung erfordert zusätzlich eine bestehende PyTorch-Installation, die mit der GPU, dem Treiber und seiner CUDA- oder ROCm-Runtime kompatibel ist. Kein Befehl des Ordners installiert diese Komponenten.

Wählen Sie ein explizites Device, zum Beispiel `cuda:0`. Das ROCm-Backend von PyTorch verwendet ebenfalls diesen Interface-Namen; das beweist nicht die Kompatibilität einer bestimmten AMD-Installation. Ohne ladbares PyTorch oder ohne zugängliche GPU beendet `measure` mit Code 2 und einer klaren Meldung. Es schreibt keine falsche Messung und wechselt nicht auf die CPU. `environment` ist eine Diagnose: Eine gültige Ausgabe kann eine nicht verfügbare GPU melden.

## 1. Gewichte schätzen, ohne GPU

```console
python mesure_memoire.py estimate --parameters 7000000000 --bits 16 --reserve-gib 4
```

Diese Berechnung nimmt eine Anzahl von Parametern und eine Speicherbreite. Sie rundet die Bits auf die nächsthöhere ganze Anzahl von Bytes auf und rechnet dann in GiB um (`2**30` Bytes). Ein dezimales GB steht für `10**9` Bytes. Die 4 GiB sind eine in diesem Beispiel gewählte Annahme, keine gemessene Reserve. Das Ergebnis enthält nicht automatisch Aktivierungen, KV-Cache, Quantisierungs-Metadaten, Gradienten, Optimizer-Zustände oder Bibliotheken. Es sagt nicht voraus, ob ein reales Modell auf eine Karte passt.

## 2. Bestehende Umgebung prüfen

```console
python mesure_memoire.py environment --device cuda:0
```

Notieren Sie Python, PyTorch-Version, Version des CUDA/HIP-Builds, die tatsächlich sichtbare GPU und den vom Runtime gemeldeten Speicher. Der Treiber muss separat mit dem Werkzeug des Anbieters erfasst werden. Das Skript sammelt weder Umgebungsvariablen noch personenbezogene Daten. Die in PyTorch integrierte Runtime-Version ist nicht die Treiberversion.

## 3. Eine ausdrücklich begrenzte Messung durchführen

Fangen Sie klein an, in einem neuen Prozess:

```console
python mesure_memoire.py measure --device cuda:0 --batch 1 --context 16 --width 64 --dtype float32 --warmup 1 --repeats 2 --output mesures-petit-essai.json
```

Um anschließend die Dimensionen des MLP zu erkunden, ist ein größeres Beispielkommando:

```console
python mesure_memoire.py measure --device cuda:0 --batch 2 --context 128 --width 1024 --dtype float32 --warmup 3 --repeats 5 --output mesures.json
```

Erhöhen Sie jeweils nur eine Dimension und überwachen Sie den verfügbaren Speicher. Der zweite Befehl ist eine vorgeschlagene Konfiguration, keine garantierte Kapazität und kein veröffentlichtes Ergebnis. `context` bezeichnet hier die Anzahl der Positionen der Eingabe `[batch, context, width]`, ohne Attention-Mechanismus oder KV-Cache. Gewichte und Eingaben teilen sich den angeforderten dtype; kein Autocast, keine Gradienten, kein Optimierer, keine Quantisierung und keine Aufteilung zwischen GPUs. `float16` und `bfloat16` hängen von der tatsächlichen Installation ab und werden nicht allein durch den float32-Test validiert.

Die JSON enthält `environment`, `configuration`, `synthetic_model` und `phases`. Die Datei muss einen neuen Namen haben; das Skript weigert sich, ein vorhandenes Ergebnis zu überschreiben.

| Phase | Umfang |
| --- | --- |
| `model_load` | Aufbau und CPU-Initialisierung des Modells, Transfer auf die gewählte GPU. Die Zeit umfasst diese CPU-Vorbereitung; die Speicherzähler beziehen sich nur auf die GPU. |
| `inputs` | Erstellung der synthetischen Eingaben auf dieser GPU. |
| `cold_forward` | Erster Durchlauf des Modells nach Initialisierung des Geräts, des Generators und der Eingaben. Dies ist kein Kaltstart der Maschine oder des Treibers. |
| `warmup` | Gesamtheit der Aufwärmdurchläufe; diese Zeit wird nicht mit den folgenden Wiederholungen vermischt. |
| `warm_forward` | Eine Zeile pro Wiederholung nach dem Aufwärmen. |

Jede Phase synchronisiert das Gerät vor und nach der Operation, erfasst die Baselines und setzt dann die Spitzenwerte zurück. Die Ausgaben sind bei der Endmessung noch vorhanden; sie werden vor dem nächsten Durchlauf freigegeben. Gewichte und Eingaben bleiben zwischen den Durchläufen erhalten. Der Cache des Allokators bleibt erhalten. Die Zeiten umfassen die Python-Kosten und die Synchronisation: dies sind keine isolierten Kernel-Zeiten.

`allocated` ist Teil von `reserved`, daher addiert man sie nicht. `peak_allocated_bytes` und `peak_reserved_bytes` sind zwei verschiedene Maxima: man subtrahiert sie nicht, um einen Cache zu berechnen. Vergleichen Sie Baselines, Endwerte und absolute Spitzenwerte getrennt. Die Zähler decken nur den PyTorch-Allokator dieses Prozesses auf der gewählten GPU ab, nicht den gesamten Speicher der GPU, des Treibers oder anderer Prozesse. Eine eventuell vorhandene andere GPU wird nicht gemessen. Die Werte hängen auch vom Allokator und der Software ab: Bewahren Sie die Umgebung zusammen mit den Ergebnissen auf.

## 4. Qualität und Kosten verknüpfen

Lesen Sie `protocole-qualite.md`, legen Sie die nützliche Arbeit und den Schwellenwert vor dem Test fest und füllen Sie dann `resultats-bruts.csv` mit den tatsächlichen Beobachtungen. Dieser Ordner liefert weder ein Klassifikationskorpus noch eine Qualitätsmessung.

```console
python calcul_forfaits.py --gpu b200 --days 7 --lots 2
```

Der Preis eines B200-Lots umfasst bereits zwei GPUs. Zwei Lots ergeben vier GPUs, aber der Lot-Preis wird nur mit zwei multipliziert. Die Tarife sind die des IteraGPU-Katalogs zum Zeitpunkt dieses Snapshots: ganze Einheiten in US-Dollar-Cent, Laufzeiten von 3, 7 oder 30 Tagen, ohne Umrechnung oder stündliche Pro-rata-Berechnung. Die CSV belegt weder aktuelle Verfügbarkeit noch Reservation. Überprüfen Sie das angezeigte Angebot vor jeder Kaufentscheidung.

Die Option `--accepted-results` hat bewusst keinen Standardwert. Fügen Sie sie nur mit der positiven ganzen Zahl der tatsächlich akzeptierten, verschiedenen nützlichen Einheiten hinzu. Die Stückkosten verwenden den Preis des gesamten Pakets. Wiederholungen desselben Benchmarks sind keine neuen nützlichen Korpora. Ohne angegebenen Nenner bleiben die Stückkosten `null`; null wird abgelehnt.

## Validierung dieser Version

Die Arithmetik, die Tarife und das Fehlen vorausgefüllter Ausgaben werden mit Python 3.12.14 und seiner Standardbibliothek überprüft. Diese Umgebung enthält kein PyTorch: Die Absenzprüfung wird daher tatsächlich getestet. Es wurde keine Installation durchgeführt.

Ein begrenzter Funktionstest wurde außerdem am 24. September 2026 auf einer **lokalen GeForce RTX 5070** ausgeführt, Treiber 610.62, Python 3.14.6, PyTorch 2.11.0+cu128, CUDA 12.8: Batch 1, Kontext 16, Breite 64, float32, ein Aufwärmen und zwei Wiederholungen. Er validiert die Ausführung der sechs Phasenzeilen des Skripts in diesem einzigen Fall. Er validiert weder die Leistung der GPUs des Katalogs noch eine gemietete Maschine noch ein LLM noch ROCm noch die anderen Genauigkeiten. Die Messwerte dieses Tests sind nicht in den verteilten Dateien vorausgefüllt. Das Notebook behält alle seine Ausgaben leer.

## Primäre technische Quellen

Dokumentation eingesehen am 24. September 2026. Diese Referenzen erläutern die APIs; die tatsächlich ausgeführte PyTorch-Version ist oben angegeben und unterscheidet sich von der der Dokumentationsseiten.

- [PyTorch: CUDA-Speicherverwaltung](https://docs.pytorch.org/docs/2.14/notes/cuda.html#memory-management)
- [PyTorch: HIP/ROCm-Semantik](https://docs.pytorch.org/docs/2.14/notes/hip.html)
- [PyTorch: Gerätesynchronisation](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.synchronize.html)
- [PyTorch: Zurücksetzen der Spitzenwerte](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.reset_peak_memory_stats.html)
- [PyTorch: zugewiesener Speicher](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_allocated.html) und [reservierter Speicher](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_reserved.html)
- [PyTorch: maximal zugewiesen](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_allocated.html) und [maximal reserviert](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_reserved.html)
- [Python: Dezimalarithmetik](https://docs.python.org/3/library/decimal.html) und [CSV-Dateien](https://docs.python.org/3/library/csv.html)

## Lizenz

Die originären Inhalte des Ordners werden unter der MIT-Lizenz verbreitet, die in `LICENSE.txt` wiedergegeben ist. Der Hinweis ist bei einer Weitergabe zu erhalten. Python, PyTorch und die anderen genannten Werkzeuge werden nicht mit dem Archiv verbreitet und behalten ihre jeweiligen Lizenzen.