wszystkie wpisy 2026 BitNet
BitNet · 2026-11-17 · 17 min

BitNet od zera – Rozbieramy cudzy model: czy zmieści się w mojej pamięci?

Odcinek pomostowy między kwantyzacją a autogradem: budżet pamięci prawdziwego modelu.

Model ma 5,95 GB, Ty masz 16 GB RAM. Zmieści się? Zwykle odpowiedź brzmi „spróbuj i zobacz”, czyli trzydzieści minut pobierania, żeby dostać out of memory. A wystarczy przeczytać pierwsze kilkadziesiąt bajtów pliku, żeby wiedzieć przed pobraniem: ile zajmą wagi, ile dołoży pamięć podręczna kontekstu, co zrobi silnik przy ładowaniu i czy w ogóle zna ten format.

Objaśnienie. Plik z modelem to nie worek liczb, tylko coś ze spisem treści. Na jego początku siedzi nagłówek, w którym jest wprost napisane, ile jest tablic z wagami, jakiego są typu, ile bitów przypada na jedną wagę, ile model ma warstw i głów. Z tych kilku liczb policzysz zużycie pamięci z dokładnością do kilku procent, zanim cokolwiek uruchomisz. W tym odcinku uczę czytać ten spis treści i przeliczać go na „zmieści się / nie zmieści się”. Przydaje się to przy każdym modelu, a nie tylko przy ternarnym.

Co ten odcinek dodaje do serii: 7 pakowanie pokaże, jak wygląda bajt wag od środka, a 16 bitnet cpp w którym zaglądam, co konkretnie jest zapisane w oficjalnym pliku BitNeta i w jakim stanie jest ekosystem, przyjdzie dalej. Tutaj chodzi o trzecią rzecz, czysto praktyczną: przewidzieć zużycie pamięci z nagłówka i zrozumieć, co się dzieje między plikiem na dysku a obliczeniami. Bez treningu i bez GPU.

Strona projektu: Budżet pamięci: czy ten model się zmieści?

1. Nagłówek GGUF: spis treści pliku

Plik GGUF zaczyna się od stałej struktury, którą da się odczytać w ok. 150 wierszach kodu:

magic "GGUF" (4 B) · wersja (u32) · liczba tensorów (u64) · liczba par metadanych (u64)
  → pary klucz-wartość (architektura, liczba warstw, głowy, kontekst, tokenizer, …)
  → indeks tensorów (nazwa, kształt, typ ggml, offset)
  → wyrównanie → blob z danymi

Najważniejsze: indeks tensorów podaje typ każdego z nich osobno. Model nie ma „jednej kwantyzacji”. Zwykle ma ich kilka naraz i to jest główne źródło pomyłek przy szacowaniu rozmiaru.

Przykład odczytu (zmierzone: ggml-model-i2_s.gguf z microsoft/bitnet-b1.58-2B-4T-gguf, 1 187 801 280 B – ten sam odczyt robi inspektor na stronie 12 z odcinka 16):

co wartość
format GGUF v3, 332 tensory, 24 pary metadanych
architektura bitnet-b1.58, warstw 30, d_model 2560
głowy 20 Q / 5 KV (GQA), kontekst 4096
tensory ternarne 210 × typ 36 (I2_S), razem 2 084 044 800 wag
normalizacje 121 × F32
embedding 1 × F16, 2560 × 128 256
głowa brak output.weight → współdzieli wagi z embeddingiem

2. Ile bitów naprawdę zajmuje jedna waga

Tabela, którą dobrze mieć pod ręką. Te same {−1, 0, +1} pakowane na pięć sposobów:

format bity/wagę gdzie
.bitpack (nasz, odc. 07) 2,0 ten projekt – czytelność ważniejsza niż gęstość
I2_S (typ 36) 2,0 + jedna skala f32 na tensor (zapisana na końcu, 32 B) fork bitnet.cpp, nie ma go w głównej gałęzi llama.cpp
TQ2_0 (typ 35) 2,0625 llama.cpp, główna gałąź
TQ1_0 (typ 34) 1,6875 llama.cpp, główna gałąź
PTQ1_0 1,75 w formacie wdrożeniowym Ternary Bonsai 2 (PrismML)
granica teoretyczna log₂3 = 1,585 trzy stany na wagę

(źródło: llama.cpp PR #8151 dla TQ1_0/TQ2_0; karty modeli PrismML dla PTQ1_0)

Dwa wnioski. Po pierwsze: moje 2 bity to o 26% więcej niż granica informacyjna, a przy modelu z 27 mld parametrów to mniej więcej gigabajt różnicy. Płacę tę cenę świadomie, w zamian za dekodowanie jednym przesunięciem bitowym. Po drugie: 2 bity na wagę to nie 2 bity na parametr modelu, bo embedding zwykle nie jest ternarny. Na tym polega pułapka z następnej sekcji.

3. Budżet pamięci z nagłówka

Trzy składniki, od najważniejszego:

wagi ternarne  = liczba_wag_ternarnych × bity/wagę / 8
+ embedding    = vocab × d_model × bajty_typu_embeddingu      ← najczęściej pomijany
+ cache KV     = 2 × warstwy × głowy_KV × d_head × bajty × kontekst

Rachunek dla 2B4T (wszystkie liczby z nagłówka pokazanego wyżej):

składnik rachunek wynik
wagi ternarne 2 084 044 800 × 2 / 8 521 MB
embedding F16 2560 × 128 256 × 2 B 657 MB
normalizacje F32 121 tensorów ok. 1 MB
cache KV przy 4096 tokenach, f16 2 × 30 × 5 × 128 × 2 B × 4096 315 MB
razem ≈ 1,49 GB

Same wagi to 1178 MB przy pliku o rozmiarze 1188 MB. Resztę zajmują metadane, głównie słownik 128 256 tokenów.

Pułapka, którą dobrze zobaczyć raz a porządnie. Zdanie „model 2B w 1,58 bita zajmuje pół giga” jest prawdziwe tylko w odniesieniu do warstw ternarnych. Same wagi to 1,18 GB (cały plik z metadanymi: 1,19 GB), a w pamięci razem z kontekstem ok. 1,49 GB, czyli trzy razy więcej, niż obiecuje slogan. Winny jest embedding: 328 mln parametrów w F16, czyli więcej bajtów niż wszystkie 2,08 mld wag ternarnych razem wzięte. Stąd bierze się większość zaskoczeń typu „miało się zmieścić”.

Dla porównania Ternary Bonsai 2 27B: 27,2 mld parametrów × 1,75 bita / 8 ≈ 5,95 GB. Tyle daje kalkulator na stronie 01 (gotowe ustawienie 2,72·10¹⁰ parametrów, „9,14× mniej” niż bf16) (obliczone) i to jest już cały model, bo tu ternarne są także embedding i głowa (źródło: karta modelu). 5,91 GB w starszych tekstach to wynik dla ustawienia 27,0 mld. Cache KV dolicz według wzoru wyżej, z liczbami z nagłówka.

4. Co się dzieje między plikiem a obliczeniami

Nagłówek mówi, ile jest bajtów. Nie mówi, jak trafią do obliczeń, a od tego może zależeć zużycie pamięci i czas startu. Silnik llama-server ma do tego jedną opcję (cytaty z --help pliku wykonywalnego z pakietu Ollamy 0.34.0, zmierzone):

--load-mode co robi
auto (domyślne) mmap, chyba że urządzenie go nie obsługuje
none bez mmap – cały plik kopiowany do pamięci
mmap plik „udaje” pamięć, system wczytuje potrzebne fragmenty
mlock, mmap+mlock wymuszenie trzymania danych w RAM
dio DirectIO, jeśli dostępne

Jest też --lazy-mode, czyli „czytanie wierszy wybranych tensorów z dysku na żądanie”. Dwie rzeczy zmieniają oczekiwania. To nie jest strumieniowe wczytywanie całego modelu z SSD (w trybie auto dotyczy tylko tensorów powyżej 4 GiB). I wymaga mmap: wyłączenie mapowania wyłącza też tryb leniwy.

A teraz część, która mnie zaskoczyła: Ollama uruchamia dokładnie ten program jako proces potomny i sama ustala jego flagi. W poleceniu zapisanym w logu na tym komputerze nie ma ani jednej z powyższych opcji (zmierzone: ~/.ollama/logs/server.log). Co więcej, gdy model nie mieści się w pamięci GPU, Ollama sama dopisuje --load-mode none (reason=metal_partial_offload), a flaga z wiersza poleceń ma pierwszeństwo przed zmienną środowiskową. Silnik pisze to wprost w ostrzeżeniu. Czyli dokładnie wtedy, gdy mapowanie pliku by się przydało, nie włączysz go zmienną.

Jedyne ustawienie, na które masz faktyczny wpływ, to use_mmap w opcjach API i w Modelfile: false → Ollama dopisuje --load-mode none, true → nie dopisuje nic (zmierzone). Nie ma go w ollama serve --help, ale działa.

4.1 Czy to ustawienie wystarczy? Trzy części, trzy różne odpowiedzi

Naturalne pytanie: skoro Ollama sama wyłącza mapowanie, gdy tylko część warstw trafia na GPU (częściowy offload), to czy use_mmap: true odbierze jej tę decyzję? Odpowiedź trzeba sprawdzić osobno i właśnie tego uczy ta sekcja.

Część 1 – scheduler Ollamy: ustawienie działa. (zmierzone; częściowy offload wymuszony opcją num_gpu)

num_gpu use_mmap co robi Ollama
10 (częściowy) – dopisuje --load-mode none
10 (częściowy) true nie dopisuje nic
99 (pełny) false dopisuje --load-mode none

Pierwsze i drugie polecenie różnią się wyłącznie numerem portu i tą jedną flagą. Scheduler nie zapisuje w logu nawet swojej decyzji.

Część 2 – silnik: zależy od architektury modelu. Silnik z pakietu Ollamy ma własną łatę, która dla niektórych modeli i tak wyłącza mmap:

compat patch disabled mmap for transformed text tensors

(zmierzone, żądanie przez Ollamę z use_mmap: true):

model architektura łata co raportuje silnik
qwen2.5-coder:1.5b-base qwen2 nie load_mode = mmap
gemma4 gemma4 nie load_mode = mmap
gpt-oss:20b gptoss nie load_mode = mmap
qwen3.5:4b, qwen3.5:9b qwen35 tak load_mode = none
qwen3.6:35b qwen35moe tak load_mode = none

Tekst tego komunikatu siedzi w pliku wykonywalnym llama-server z pakietu Ollamy, a nie ma go w libllama-server-impl.dylib. Czyli to łata nałożona przez Ollamę na llama.cpp, a nie zachowanie głównej gałęzi.

Jak się pomyliłem i czego to uczy. Dzień wcześniej zmierzyłem to samo na trzech modelach Qwen 3.5/3.6, zobaczyłem load_mode = none w każdym przebiegu i napisałem tu: „mmap pod Ollamą i tak się nie włączy”. To było zbyt daleko idące uogólnienie z próby złożonej z samych Qwenów. Wystarczyło dołożyć gemma4 i gpt-oss, żeby zobaczyć mmap. Jeżeli wszystkie Twoje przypadki testowe pochodzą z jednej rodziny, nie mierzysz zachowania narzędzia, tylko zachowanie tej rodziny.

Część 3 – tryb leniwy: działa, i to niezależnie od mmap. Tu z kolei zmyliła mnie dokumentacja. --help mówi, że --lazy-mode on „requires mmap”, więc wyciągnąłem wniosek, że skoro Ollama wyłącza mmap, to tryb leniwy jest nieosiągalny. Pomiar pokazuje co innego (zmierzone na gemma4, który ma tensor per_layer_token_embd.weight o rozmiarze 5376 MiB – powyżej progu 4 GiB):

--load-mode --lazy-mode szczytowe zużycie pamięci przez proces
mmap off 9,81 GB
mmap on 3,84 GB
none on 4,34 GB
none off 9,98 GB

Oszczędność to około 6 GB, dokładnie tyle, ile zajmuje tensor zostawiony na dysku. Czas startu się przy tym nie zmienia (1,6 s w obu wariantach). W pierwszej serii wyszło 5,7 s dla trybu leniwego i 1,6 s dla zwykłego, ale winna była zimna pamięć podręczna stron (page cache), co widać po odwróceniu kolejności pomiarów. Gdybym zmierzył tylko raz, opisałbym tu nieistniejące spowolnienie 3,5×.

Wniosek praktyczny. use_mmap działa w Ollamie dla większości modeli, a w rodzinie qwen35 blokuje je łata. Tryb leniwy, który (jak właśnie widać) naprawdę oszczędza pamięć, jest w Ollamie nieosiągalny, ale nie dlatego, że brakuje mmap. Ollama po prostu nigdy nie przekazuje tej flagi (w jej pliku wykonywalnym tekst lazy-mode nie występuje ani razu). Jak chcesz go użyć, odpal llama-server samodzielnie.

Dwie lekcje, obie ważne nie tylko w tym przypadku.

  1. Sprawdzaj warstwę, na której coś się dzieje. Polecenie uruchamiające proces potomny mówiło „mmap włączony”, a przy Qwenach mapowania nie było. Miarodajny jest wiersz load_mode = … z logu silnika, bo to silnik czyta plik.
  2. Zdanie z dokumentacji to nie pomiar. „requires mmap” brzmiało jak fakt i zbudowałem na nim cały łańcuch wniosków. Trzydzieści sekund pracy programu pokazało, że tryb leniwy działa także bez mmap.

Zastrzeżenia: jedna platforma, jedna wersja (Ollama 0.34.0). Nie zmierzyłem, ile tryb leniwy kosztuje w tokenach na sekundę. Tensor czytany z dysku w trakcie obliczeń musi coś kosztować.

5. Czego nagłówek Ci nie powie

  1. Czy Twój silnik w ogóle zna ten typ. I2_S (typ 36) nie istnieje w głównej gałęzi llama.cpp, to typ z forka Microsoftu. Ollama i LM Studio go nie wczytają (zgłoszenia ollama #10337 i #8970 są otwarte). TQ2_0 działa, w tym na Metalu (PR #26980), a dla CUDA dalej brak obsługi TQ.
  2. Że ten sam model to inny plik na x86 i na ARM. I2_S układa wagi w bloki po 128 na x86 i po 64 na ARM, a oficjalny konwerter zawsze pakuje w układzie dla x86 (odc. 07). To jedna z czterech hipotez wyjaśniających bezsensowny tekst na wyjściu na Apple Silicon. Pozostałe to gałąź submodułu, SiLU zamiast ReLU² w grafie forka (z dowodem w kodzie źródłowym) i błędna ścieżka zapasowa bez instrukcji wektorowych (scalar fallback, #600).
  3. Buforów obliczeniowych i narzutu środowiska. Rachunek z §3 to dolna granica, a prawdziwe zużycie zmierzysz dopiero po starcie (RSS, log silnika). Dlatego „przewidziane a zmierzone” to osobny krok tego odcinka. Cel to zgodność ±10%, a rozjazdy się opisuje, zamiast naginać wzór.

5.1 Przewidziane a zmierzone – pomiar na trzech własnych plikach

Objaśnienie. W końcu sprawdziłem, jak rachunek z §3 ma się do rzeczywistości: trzy modele z dysku uruchomione bezpośrednio w silniku (bez Ollamy), w trzech trybach ładowania, z odczytem pamięci procesu. Wniosek w jednym zdaniu: rachunek zgadza się z dokładnością do kilku procent, kiedy plik jest kopiowany do pamięci, a architektura jest „zwykła”. Myli się o jedną piątą, gdy model ma nietypowy mechanizm uwagi (attention), i wtedy wiadomo, który składnik wzoru poprawić.

Zmierzone skryptem pomiarowym; silnik llama-server z pakietu Ollamy uruchamiany bezpośrednio, kontekst 2048, cache f16, narzut 0,5 GB [szacunek]:

model (plik) razem przewidziane RSS load_mode = none rozjazd RSS mmap tok/s (none / mmap)
qwen2.5-coder 1,5b (0,99 GB) 1,54 GB 1,57 GB +1,8% 1,17 GB 153 / 152
qwen3.5 4b (3,39 GB) 4,96 GB 4,02 GB −19,1% 4,02 GB (łata wyłącza mmap) 60 / 62
ornith 9b (5,63 GB) 6,40 GB 6,82 GB +6,6% 5,84 GB 38,5 / 39,4
  • Cel ±10% z punktu 3 wyżej spełniają 2 z 3 pomiarów. Rozjazd w trzecim przypadku wynika ze składnika KV. Wzór liczy cache dla każdej warstwy, a qwen3.5 ma warstwy hybrydowe bez klasycznego cache’u K/V [hipoteza – do sprawdzenia tensor po tensorze]. Dla tej rodziny silnik z pakietu Ollamy wyłącza mmap niezależnie od flagi (compat patch disabled mmap for transformed text tensors w logu przy --load-mode mmap).
  • Tryb ładowania nie zmienia szybkości pracy (tok/s i TTFT równe w granicach ±3%), zmienia tylko to, co pokazuje RSS. Przy mmap widać strony pliku, które zostały faktycznie odczytane (o 4-18% więcej niż rozmiar pliku), przy none kopię wag i bufory. Właśnie dlatego trzy piętra z §4.1 (cmd=, load_mode, RSS) czyta się osobno.
  • --lazy-mode on nie włączył się dla żadnego z trzech plików (brak tensora ≥ 4 GiB), więc koszt trybu leniwego w tok/s dalej nie jest zmierzony.

Ćwiczenie na stronie

Dwie strony: 02b-budzet-pamieci.html, czyli kalkulator „czy się zmieści” z listą przykładowych modeli i wyborem rodzaju uwagi, oraz 12-hub.html, czyli inspektor nagłówka, który czyta Twój plik lokalnie w przeglądarce (nic nie wysyła).

  1. Wskaż w inspektorze (strona 12, odc. 16) dowolny plik .gguf, który masz na dysku, choćby zwykły Q4_K_M. Odczytaj liczbę tensorów, rozkład typów i architekturę.
  2. W polu „Tensory po nazwie” wpisz token_embd, a dostaniesz typ i kształt embeddingu. Policz sam, ile miejsca zajmuje (elementy × bajty typu) i jaki to procent całego pliku. (Przykład z prawdziwego pliku: qwen35, embedding Q6_K 2560 × 248 320 = 636 mln parametrów w modelu o rozmiarze 3,39 GB.)
  3. Liczby odczytane w inspektorze (warstwy, głowy KV, wymiar głowy) przepisz do kalkulatora (strona 02b, odc. 03) albo wybierz z listy podobny model. Ustaw pamięć swojego komputera i przesuwaj suwak długości kontekstu. Znajdź punkt, w którym cache KV zaczyna zajmować więcej miejsca w pamięci niż model. Dla 2B4T to ≈ 15 000 tokenów (76 800 B na token × 15 334 = 1,18 GB wag) (poprawione: poprzednia wersja podawała 32 768 – błąd 2×), a dla modelu z dużą liczbą głów KV dużo wcześniej.
  4. Na tej samej stronie przełącz format cache’u na q4_0. Dla 2B4T przy 131 072 tokenach cache maleje z 10,07 GB do 2,83 GB. To efekt tej jednej flagi -ctk q4_0, o której nie wspomina żaden poradnik o „modelach na słabym sprzęcie”.
  5. W sekcji 5 kalkulatora zobacz, ile ten sam model zająłby z innym rodzajem uwagi. Przy wymiarach Llama 3.1 8B i 4096 tokenach MLA (jak w DeepSeek-V3) trzyma w cache’u 14 razy mniej niż pełne MHA, a okno przesuwne w połowie warstw (jak w gpt-oss) prawie 8 razy mniej (obliczenie na stronie).
  6. Odpal model naprawdę i porównaj przewidywanie z faktycznym zużyciem pamięci. Rozjazd większy niż 10%? Zapisz, jak duży, bo to jest właśnie ta liczba, której nie ma w żadnym poradniku.
  7. Sprawdź §4.1 u siebie: odpal model w Ollamie i znajdź w ~/.ollama/logs/server.log dwa wiersze: cmd= (co Ollama zleciła) i load_tensors: … (load_mode = …) (co silnik zrobił). Jeżeli różnią się mimo use_mmap: true, masz tę samą łatę co ja. Jeżeli nie, napisz, na jakiej platformie i w jakiej wersji, bo to rozstrzyga pytanie oznaczone u mnie jako niezweryfikowane.

Sprawdź się

Bez zaglądania w tekst i bez strony. Zapisz odpowiedź, dopiero potem rozwiń. To, czym Twoja odpowiedź różni się od tej pod spodem, to najcenniejsza rzecz z tego odcinka – zapisz to w dzienniku.

  1. Policz, ile bajtów zajmuje cache KV na jeden token dla 2B4T (30 warstw, 5 głów KV, wymiar głowy 128, f16), i podaj kontekst, przy którym cache dorównuje wagom (1,18 GB).
odpowiedź2·30·5·128·2 B = **76 800 B/token**; 1177,7 MB / 76 800 ≈ **15 300 tokenów**.
  1. Dlaczego embedding liczy się w budżecie osobno?
odpowiedźMa inny typ (F16/Q6_K) niż warstwy i często zajmuje więcej miejsca niż wszystkie warstwy razem: w 2B4T 657 MB wobec 521 MB. Pominięcie go to najczęstsze źródło błędu „2B = 0,5 GB”.
  1. Dlaczego jeden plik GGUF nie ma „jednej kwantyzacji”?
odpowiedźNagłówek podaje typ **każdego** tensora z osobna: embedding może być w Q6_K, warstwy w Q4_K, normalizacje w F32. Rozmiar liczy się dla każdego typu osobno: bajty typu × liczba elementów.
  1. Trzy piętra przy uruchamianiu modelu: co mierzy wiersz cmd=, co load_mode = …, a co RSS?
odpowiedź`cmd=` to to, co Ollama *zleciła*; `load_mode` w logu silnika to to, co llama-server *zrobił* (łata compat może to zmienić); RSS/footprint to to, co system *faktycznie* trzyma w pamięci. Miarodajne jest piętro najniższe.

Czego się nauczyłeś

  • Nagłówek GGUF to spis treści: typ każdego tensora z osobna, architektura, głowy, kontekst. Wszystko, czego trzeba do policzenia budżetu pamięci.
  • Budżet = wagi + embedding osobno + cache KV. Pominięcie embeddingu to najczęstszy błąd: w 2B4T zajmuje on więcej miejsca niż 2,08 mld wag ternarnych razem.
  • Cache KV rośnie liniowo z długością kontekstu, a wagi wcale. Dla 2B4T przy 4096 tokenach cache to 21% sumy wag i cache’u (9%, jeśli doliczyć 2 GB narzutu [szacunek] ze strony), przy 131 072 to już 90% (76% z narzutem). Przy długim kontekście o tym, czy model się zmieści, decyduje cache, a nie model. Dlatego kwantyzacja cache’u (q8_0, q4_0) daje czasem większą oszczędność niż kwantyzacja wag.
  • Formaty ternarne różnią się gęstością: 1,6875 (TQ1_0), 1,75 (PTQ1_0), 2,0 (.bitpack, I2_S), 2,0625 (TQ2_0), przy granicy log₂3 = 1,585.
  • Między plikiem a obliczeniami stoi tryb ładowania (--load-mode, mmap, --lazy-mode), a w Ollamie większość tych decyzji podejmuje za Ciebie scheduler.
  • use_mmap: true naprawdę odbiera Ollamie jej automatyczną decyzję i dla większości architektur mmap się wtedy włącza. Rodzinę qwen35 blokuje osobna łata w silniku. Miarodajny jest wiersz load_mode = … z logu silnika, a nie polecenie uruchamiające proces.
  • Tryb leniwy (--lazy-mode on) zmniejsza zużycie pamięci dokładnie o tyle, ile zajmuje tensor zostawiony na dysku (na gemma4 9,81 GB → 3,84 GB), i nie wymaga mmap, wbrew własnej dokumentacji. W Ollamie i tak go nie użyjesz, bo nigdy nie przekazuje ona tej flagi.
  • Rozmiar to nie wszystko: silnik musi znać typ, a I2_S zna tylko fork.

W następnym odcinku zaczynam budować od zera: własny mikroautograd, czyli backward() bez magii, i pierwsza sieć ucząca się na spirali i MNIST. CDN…

Źródła

  • Formaty ternarne: llama.cpp PR #8151 (TQ1_0 1,6875 bpw, TQ2_0 2,0625 bpw), PR #26980 (Metal TQ2_0); karty modeli PrismML (PTQ1_0, Ternary Bonsai 2 27B).
  • I2_S: microsoft/BitNet commit 0b341e5 (quantize_to_i2_s, ggml-cpu-i2s.c), zgłoszenia #600, #610, #618; szczegóły układu bajtów.

← Poprzedni wpis

BitNet od zera – Liczby w sieci: fp32, bf16, int8 i błąd kwantyzacji

0 komentarzy

Zostaw komentarz

Twój adres email nie zostanie opublikowany. Wymagane pola są oznaczone *