# IteraGPU Lab v1

Originele bronbestanden, versie van 24 september 2026, om een reproduceerbaar GPU-experiment voor te bereiden. De geheugennotebook en zijn metgezel voeren een klein synthetisch netwerk `Linear → GELU → Linear` uit. Ze downloaden geen enkel model of dataset. Dit netwerk is geen LLM, geen training en geen representatieve benchmark voor de GPU's die te huur worden aangeboden.

## Inhoud

- `mesure-memoire.ipynb`: zelfstandige notebook, code inbegrepen, cellen zonder opgeslagen uitvoer.
- `mesure_memoire.py`: dezelfde rekenkunde en hetzelfde meetprotocol, bruikbaar vanaf de opdrachtregel.
- `protocole-qualite.md`: zakelijk protocol aan te vullen voordat je tijd en kosten vergelijkt.
- `resultats-bruts.csv`: leeg raster, één regel in te vullen per werkelijke run.
- `calcul_forfaits.py`: berekening van het volledige pakket, zonder externe afhankelijkheid.
- `tarifs-forfaits.csv`: 45 IteraGPU-tarieven, 15 modellen × 3 looptijden, momentopname van 24 september 2026.
- `LICENSE.txt`: MIT-licentie van de code, de notebook en de originele documenten.
- `MANIFEST.json`: volledige lijst van de negen archiefleden, groottes en SHA-256 van de acht inhoudsbestanden. Het manifest verklaart zichzelf zonder vingerafdruk om een zelfreferentiële vingerafdruk te vermijden.

Het archief `iteragpu-lab-v1.zip` bevat deze negen bestanden onder één map. Het bevat geen GPU-resultaat, geen Python-omgeving, geen stuurprogramma en geen inloggegevens. Pak de bestanden uit in een nieuwe map. De notebook kan ook apart worden gedownload: hij importeert het begeleidende script niet.

## Vereisten en beperkingen

De rekenkundige en pakketberekeningen gebruiken alleen Python 3.10 of hoger en de standaardbibliotheek. De notebook vereist een hulpmiddel dat een Python-notebook kan openen; er wordt geen Jupyter-server geleverd. De meting vereist daarnaast een bestaande PyTorch-installatie die compatibel is met de GPU, het stuurprogramma en de bijbehorende CUDA- of ROCm-runtime. Geen enkel commando in de map installeert deze componenten.

Kies een expliciet device, bijvoorbeeld `cuda:0`. De ROCm-backend van PyTorch gebruikt ook deze interfacenaam; dat bewijst niet de compatibiliteit van een bepaalde AMD-installatie. Zonder laadbare PyTorch of zonder toegankelijke GPU eindigt `measure` met code 2 en een duidelijke melding. Het schrijft geen valse meting en schakelt niet over op de CPU. `environment` is een diagnose: een geldige uitvoer kan een niet-beschikbare GPU melden.

## 1. Gewichten schatten, zonder GPU

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

Deze berekening neemt een aantal parameters en een opslagbreedte. Ze rondt de bits af naar het eerstvolgende gehele aantal bytes en zet dat vervolgens om in GiB (`2**30` bytes). Een decimale GB staat voor `10**9` bytes. De 4 GiB is een aanname die in dit voorbeeld is gekozen, geen gemeten reserve. Het resultaat bevat niet automatisch activaties, KV-cache, quantisatiemetadata, gradiënten, optimizer-toestanden of bibliotheken. Het voorspelt niet of een werkelijk model op een kaart past.

## 2. De bestaande omgeving controleren

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

Bewaar Python, PyTorch-versie, versie van de CUDA/HIP-build, de daadwerkelijk zichtbare GPU en het geheugen dat de runtime meldt. Het stuurprogramma moet apart worden vastgelegd met het hulpmiddel van de leverancier. Het script verzamelt geen omgevingsvariabelen en geen persoonlijke gegevens. De versie van de runtime die in PyTorch is ingebouwd, is niet de versie van het stuurprogramma.

## 3. Een expliciet begrensde meting uitvoeren

Begin klein, in een nieuw proces:

```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
```

Om daarna de dimensies van het MLP te verkennen, is een voorbeeld van een groter commando:

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

Verhoog één dimensie tegelijk en houd het beschikbare geheugen in de gaten. De tweede opdracht is een voorgestelde configuratie, geen gegarandeerde capaciteit en geen gepubliceerd resultaat. `context` verwijst hier naar het aantal posities van de invoer `[batch, context, width]`, zonder aandachtmechanisme of KV-cache. De gewichten en invoeren delen het gevraagde dtype; geen autocast, gradiënten, optimizer, kwantisering of verdeling over GPU's. `float16` en `bfloat16` hangen af van de daadwerkelijke installatie en worden niet gevalideerd door de float32-test alleen.

De JSON bevat `environment`, `configuration`, `synthetic_model` en `phases`. Het bestand moet een nieuwe naam hebben; het script weigert een bestaand resultaat te overschrijven.

| Fase | Bereik |
| --- | --- |
| `model_load` | Opbouw en initialisatie van het model op de CPU, overdracht naar de gekozen GPU. De tijd omvat deze CPU-voorbereiding; de geheugentellers hebben alleen betrekking op de GPU. |
| `inputs` | Aanmaken van de synthetische invoeren op deze GPU. |
| `cold_forward` | Eerste doorgang van het model na initialisatie van het device, de generator en de invoeren. Dit is geen koude start van de machine of het stuurprogramma. |
| `warmup` | Alle opwarmdoorgangen; deze tijd wordt niet vermengd met de volgende herhalingen. |
| `warm_forward` | Eén regel per herhaling na het opwarmen. |

Elke fase synchroniseert het device voor en na de bewerking, leest de baselines uit en reset daarna de pieken. De uitvoeren zijn nog aanwezig bij de eindmeting; ze worden vrijgegeven voor de volgende doorgang. De gewichten en invoeren blijven bestaan tussen doorgangen. De cache van de allocator blijft behouden. De tijden omvatten de Python-kosten en de synchronisatie: dit zijn geen geïsoleerde kerneltijden.

`allocated` maakt deel uit van `reserved`, dus je telt ze niet bij elkaar op. `peak_allocated_bytes` en `peak_reserved_bytes` zijn twee afzonderlijke maxima: je trekt ze niet van elkaar af om een cache te berekenen. Vergelijk de baselines, einden en absolute pieken afzonderlijk. De tellers dekken alleen de PyTorch-allocator van dit proces op de gekozen GPU, niet al het geheugen van de GPU, het stuurprogramma of andere processen. Een eventuele andere GPU wordt niet gemeten. De waarden hangen ook af van de allocator en de software: bewaar de omgeving bij de resultaten.

## 4. Kwaliteit en kosten met elkaar verbinden

Lees `protocole-qualite.md`, leg het nuttige werk en de drempel vast vóór de test en vul daarna `resultats-bruts.csv` met de werkelijke observaties. Deze map levert geen classificatiecorpus en geen kwaliteitsmeting.

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

De prijs van een B200-lot omvat al twee GPU's. Twee loten geven vier GPU's, maar de lotprijs wordt alleen met twee vermenigvuldigd. De tarieven zijn die van de IteraGPU-catalogus op de dag van deze momentopname: hele eenheden in USD-centen, looptijden van 3, 7 of 30 dagen, zonder conversie of uurtarief naar rato. De CSV bewijst noch de huidige beschikbaarheid noch een reservering. Controleer het getoonde aanbod voordat je een aankoopbeslissing neemt.

De optie `--accepted-results` heeft bewust geen standaardwaarde. Voeg hem alleen toe met het positieve gehele aantal daadwerkelijk geaccepteerde, afzonderlijke nuttige eenheden. De eenheidsprijs gebruikt de prijs van het hele forfait. Herhalingen van dezelfde benchmark zijn geen nieuwe nuttige corpora. Zonder ingevulde deler blijft de eenheidsprijs `null`; nul wordt geweigerd.

## Validatie van deze versie

De rekenkunde, de tarieven en het ontbreken van vooraf ingevulde uitvoeren zijn geverifieerd met Python 3.12.14 en de bijbehorende standaardbibliotheek. Deze omgeving bevat geen PyTorch: de afwezigheidscontrole wordt dus echt getest. Er is geen installatie uitgevoerd.

Op 24 september 2026 is ook een beperkte functionele test uitgevoerd op een **lokale GeForce RTX 5070**, stuurprogramma 610.62, Python 3.14.6, PyTorch 2.11.0+cu128, CUDA 12.8: batch 1, context 16, breedte 64, float32, één opwarming en twee herhalingen. Deze valideert de uitvoering van de zes faseregels van het script voor dit ene geval. Hij valideert niet de prestaties van de GPU's uit de catalogus, noch een gehuurde machine, noch een LLM, noch ROCm, noch de andere precisies. De metingen van deze test zijn niet vooraf ingevuld in de gedistribueerde bestanden. De notebook behoudt al zijn lege uitvoeren.

## Primaire technische bronnen

Documentatie geraadpleegd op 24 september 2026. Deze referenties leggen de API's uit; de daadwerkelijk uitgevoerde PyTorch-versie staat hierboven vermeld, los van die van de documentatiepagina's.

- [PyTorch: CUDA-geheugenbeheer](https://docs.pytorch.org/docs/2.14/notes/cuda.html#memory-management)
- [PyTorch: HIP/ROCm-semantiek](https://docs.pytorch.org/docs/2.14/notes/hip.html)
- [PyTorch: apparaatsynchronisatie](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.synchronize.html)
- [PyTorch: pieken resetten](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.reset_peak_memory_stats.html)
- [PyTorch: toegewezen geheugen](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_allocated.html) en [gereserveerd geheugen](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_reserved.html)
- [PyTorch: maximaal toegewezen](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_allocated.html) en [maximaal gereserveerd](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_reserved.html)
- [Python: decimale rekenkunde](https://docs.python.org/3/library/decimal.html) en [CSV-bestanden](https://docs.python.org/3/library/csv.html)

## Licentie

De originele creaties van de map worden verspreid onder de MIT-licentie, weergegeven in `LICENSE.txt`. Behoud de kennisgeving bij herdistributie. Python, PyTorch en de andere genoemde tools worden niet meegeleverd met het archief en behouden hun respectievelijke licenties.