# IteraGPU Lab v1

Oryginalne zasoby, wersja z 24 września 2026, do przygotowania powtarzalnego eksperymentu GPU. Notebook pamięci i jego towarzysz uruchamiają małą syntetyczną sieć `Linear → GELU → Linear`. Nie pobierają żadnego modelu ani zbioru danych. Ta sieć nie jest ani LLM, ani treningiem, ani reprezentatywnym benchmarkiem oferowanych do wynajmu GPU.

## Zawartość

- `mesure-memoire.ipynb`: samodzielny notebook, kod w środku, komórki bez zapisanych wyników.
- `mesure_memoire.py`: ta sama arytmetyka i ten sam protokół pomiaru, możliwe do użycia z wiersza poleceń.
- `protocole-qualite.md`: protokół biznesowy do uzupełnienia przed porównaniem czasu i kosztu.
- `resultats-bruts.csv`: pusta siatka, jeden wiersz do wypełnienia na każde rzeczywiste przejście.
- `calcul_forfaits.py`: obliczenie pełnego forfait, bez zależności zewnętrznych.
- `tarifs-forfaits.csv`: 45 cenników IteraGPU, 15 modeli × 3 czasy trwania, stan na 24 września 2026.
- `LICENSE.txt`: licencja MIT kodu, notebooka i oryginalnych dokumentów.
- `MANIFEST.json`: wyczerpująca lista dziewięciu elementów archiwum, rozmiary i SHA-256 ośmiu plików z zawartością. Manifest sam siebie deklaruje bez skrótu, aby uniknąć skrótu autoreferencyjnego.

Archiwum `iteragpu-lab-v1.zip` zawiera te dziewięć plików w jednym folderze. Nie zawiera ani wyniku GPU, ani środowiska Python, ani sterownika, ani identyfikatora. Rozpakuj pliki do nowego katalogu. Notebook można też pobrać osobno: nie importuje on skryptu towarzyszącego.

## Wymagania wstępne i ograniczenia

Obliczenia arytmetyczne i forfaitowe używają wyłącznie Python 3.10 lub nowszego i jego biblioteki standardowej. Notebook wymaga narzędzia potrafiącego otworzyć notebook Python; żaden serwer Jupyter nie jest dostarczany. Pomiar wymaga dodatkowo istniejącej instalacji PyTorch zgodnej z GPU, sterownikiem i jego środowiskiem uruchomieniowym CUDA lub ROCm. Żadna komenda z folderu nie instaluje tych komponentów.

Wybierz jawny device, na przykład `cuda:0`. Backend ROCm PyTorch również używa tej nazwy interfejsu; nie dowodzi to zgodności konkretnej instalacji AMD. Bez możliwego do załadowania PyTorch lub bez dostępnego GPU `measure` kończy się kodem 2 i jasnym komunikatem. Nie zapisuje żadnego fałszywego pomiaru i nie przełącza się na CPU. `environment` to diagnostyka: prawidłowe wyjście może ogłosić niedostępny GPU.

## 1. Oszacuj wagi, bez GPU

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

To obliczenie przyjmuje liczbę parametrów i szerokość przechowywania. Zaokrągla bity w górę do całkowitej liczby bajtów, a następnie konwertuje na GiB (`2**30` bajtów). Jeden GB dziesiętny to `10**9` bajtów. Te 4 GiB to założenie wybrane w tym przykładzie, a nie zmierzony zapas. Wynik nie obejmuje automatycznie aktywacji, cache KV, metadanych kwantyzacji, gradientów, stanów optymalizatora ani bibliotek. Nie przewiduje, czy rzeczywisty model zmieści się na karcie.

## 2. Sprawdź istniejące środowisko

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

Zachowaj Python, wersję PyTorch, wersję builda CUDA/HIP, faktycznie widoczny GPU i pamięć ogłoszoną przez runtime. Sterownik należy odnotować osobno za pomocą narzędzia dostawcy. Skrypt nie zbiera ani zmiennych środowiskowych, ani danych osobowych. Wersja runtime wbudowanego w PyTorch to nie wersja sterownika.

## 3. Wykonaj jawnie ograniczony pomiar

Zacznij od małego, w świeżym procesie:

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

Aby następnie zbadać wymiary MLP, przykładem większej komendy jest:

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

Zwiększaj jedną dimensję naraz i obserwuj dostępną pamięć. Drugie polecenie to proponowana konfiguracja, a nie gwarantowana pojemność ani opublikowany wynik. `context` oznacza tutaj liczbę pozycji wejścia `[batch, context, width]`, bez mechanizmu uwagi ani cache KV. Wagi i wejścia współdzielą żądany dtype; brak autocast, gradientów, optymalizatora, kwantyzacji czy rozkładu między GPU. `float16` i `bfloat16` zależą od faktycznej instalacji i nie są potwierdzane samym testem float32.

JSON zawiera `environment`, `configuration`, `synthetic_model` i `phases`. Plik musi mieć nową nazwę; skrypt odmawia nadpisania istniejącego wyniku.

| Faza | Zakres |
| --- | --- |
| `model_load` | Budowa i inicjalizacja modelu na CPU, transfer do wybranego GPU. Czas obejmuje to przygotowanie na CPU; liczniki pamięci dotyczą wyłącznie GPU. |
| `inputs` | Utworzenie syntetycznych wejść na tym GPU. |
| `cold_forward` | Pierwsze przejście modelu po inicjalizacji device, generatora i wejść. To nie jest zimny start maszyny ani sterownika. |
| `warmup` | Zbiór przejść rozgrzewających; ten czas nie jest mieszany z kolejnymi powtórzeniami. |
| `warm_forward` | Jeden wiersz na powtórzenie po rozgrzewce. |

Każda faza synchronizuje device przed operacją i po niej, odczytuje baseline'y, a następnie resetuje piki. Wyjścia są jeszcze obecne przy odczycie końcowym; są zwalniane przed kolejnym przejściem. Wagi i wejścia pozostają między przejściami. Cache alokatora jest zachowywany. Czasy obejmują koszt Pythona i synchronizację: to nie są izolowane czasy jądra.

`allocated` jest częścią `reserved`, więc się ich nie sumuje. `peak_allocated_bytes` i `peak_reserved_bytes` to dwa odrębne maksima: nie odejmuje się ich, aby obliczyć cache. Porównuj osobno baseline'y, końce i piki absolutne. Liczniki obejmują wyłącznie alokator PyTorch tego procesu na wybranym GPU, a nie całą pamięć GPU, sterownika czy innych procesów. Ewentualny inny GPU nie jest mierzony. Wartości zależą też od alokatora i oprogramowania: zachowaj środowisko wraz z wynikami.

## 4. Łączenie jakości i kosztu

Przeczytaj `protocole-qualite.md`, ustal pracę użyteczną i próg przed testem, następnie wypełnij `resultats-bruts.csv` rzeczywistymi obserwacjami. Ten zestaw nie dostarcza żadnego korpusu klasyfikacji ani pomiaru jakości.

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

Cena jednego lotu B200 obejmuje już dwa GPU. Dwa loty dają cztery GPU, ale cena lotu jest mnożona wyłącznie przez dwa. Taryfy pochodzą z katalogu IteraGPU w dniu tego zrzutu: jednostki całkowite w centach USD, czasy trwania 3, 7 lub 30 dni, bez konwersji ani proporcjonalnego rozliczenia godzinowego. CSV nie dowodzi ani aktualnej dostępności, ani rezerwacji. Sprawdź wyświetlaną ofertę przed podjęciem decyzji o zakupie.

Opcja `--accepted-results` celowo nie ma wartości domyślnej. Dodaj ją tylko z dodatnią liczbą całkowitą odrębnych jednostek użytecznych faktycznie zaakceptowanych. Koszt jednostkowy wykorzystuje cenę całego forfait. Powtórzenia tego samego benchmarku nie są nowymi użytecznymi korpusami. Bez podanego mianownika koszt jednostkowy pozostaje `null`; zero jest odrzucane.

## Walidacja tej wersji

Arytmetyka, taryfy i brak wstępnie wypełnionych wyników są sprawdzane za pomocą Python 3.12.14 i jego biblioteki standardowej. To środowisko nie zawiera PyTorch: strażnik braku jest więc testowany naprawdę. Nie wykonano żadnej instalacji.

Wykonano także ograniczony test funkcjonalny 24 września 2026 na **lokalnej GeForce RTX 5070**, sterownik 610.62, Python 3.14.6, PyTorch 2.11.0+cu128, CUDA 12.8: batch 1, kontekst 16, szerokość 64, float32, jedna rozgrzewka i dwa powtórzenia. Potwierdza on wykonanie sześciu wierszy faz skryptu w tym jednym przypadku. Nie potwierdza ani wydajności GPU z katalogu, ani wynajętej maszyny, ani LLM, ani ROCm, ani innych precyzji. Pomiary z tego testu nie są wstępnie wypełnione w dystrybuowanych plikach. Notebook zachowuje wszystkie swoje puste wyniki.

## Podstawowe źródła techniczne

Dokumentacja sprawdzona 24 września 2026. Te odwołania wyjaśniają API; faktycznie uruchomiona wersja PyTorch jest podana powyżej, odrębnie od tej ze stron dokumentacji.

- [PyTorch: zarządzanie pamięcią CUDA](https://docs.pytorch.org/docs/2.14/notes/cuda.html#memory-management)
- [PyTorch: semantyka HIP/ROCm](https://docs.pytorch.org/docs/2.14/notes/hip.html)
- [PyTorch: synchronizacja urządzenia](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.synchronize.html)
- [PyTorch: resetowanie szczytów](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.reset_peak_memory_stats.html)
- [PyTorch: pamięć przydzielona](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_allocated.html) i [pamięć zarezerwowana](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.memory_reserved.html)
- [PyTorch: maksimum przydzielone](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_allocated.html) i [maksimum zarezerwowane](https://docs.pytorch.org/docs/2.14/generated/torch.cuda.memory.max_memory_reserved.html)
- [Python: arytmetyka dziesiętna](https://docs.python.org/3/library/decimal.html) i [pliki CSV](https://docs.python.org/3/library/csv.html)

## Licencja

Oryginalne utwory zawarte w tym zbiorze są rozpowszechniane na licencji MIT, której treść znajduje się w `LICENSE.txt`. Zachowaj tę informację przy redystrybucji. Python, PyTorch i inne wymienione narzędzia nie są rozpowszechniane wraz z archiwum i zachowują swoje własne licencje.