Instructions to use Maggio33/GoLLeM-110M-PL with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Maggio33/GoLLeM-110M-PL with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="Maggio33/GoLLeM-110M-PL")

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("Maggio33/GoLLeM-110M-PL")
model = AutoModelForCausalLM.from_pretrained("Maggio33/GoLLeM-110M-PL", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Maggio33/GoLLeM-110M-PL with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Maggio33/GoLLeM-110M-PL"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Maggio33/GoLLeM-110M-PL",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

docker model run hf.co/Maggio33/GoLLeM-110M-PL

SGLang

How to use Maggio33/GoLLeM-110M-PL with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Maggio33/GoLLeM-110M-PL" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Maggio33/GoLLeM-110M-PL",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Maggio33/GoLLeM-110M-PL" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Maggio33/GoLLeM-110M-PL",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Docker Model Runner
How to use Maggio33/GoLLeM-110M-PL with Docker Model Runner:
```
docker model run hf.co/Maggio33/GoLLeM-110M-PL
```

GoLLeM-110M-PL / README.md

Maggio33

Add training recipe/script (README.md, train_125m.py)

e45bbca verified 20 days ago

preview code

Raw History Blame Contribute Delete

5.33 kB

	---
	license: apache-2.0
	language:
	- pl
	library_name: transformers
	pipeline_tag: text-generation
	tags:
	- gpt2
	- polish
	- base-model
	- from-scratch
	- amd-rocm
	---

	# GoLLeM-110M-PL (base)

	Bazowy model językowy (pretraining, model bazowy — NIE chatbot) dla języka polskiego.
	110M parametrów, architektura GPT-2, wytrenowany od zera na konsumenckiej karcie AMD Radeon RX 7900 XTX (ROCm/WSL2, Windows) — bez NVIDII, bez chmury.

	> To model completion: dostaje początek tekstu i kontynuuje najbardziej prawdopodobny ciąg.
	> Nie odpowiada na pytania jak asystent — do rozmowy/trzymania tematu wymaga osobnego fine-tuningu instrukcyjnego.

	## Specyfikacja
	\| \| \|
	\|---\|---\|
	\| Parametry \| 110,025,216 (110M), weight-tied embeddings \|
	\| Architektura \| GPT-2 (decoder-only): 12 warstw / 12 głów / d_model 768 \|
	\| Kontekst \| 512 tokenów \|
	\| Tokenizer \| polski BPE (dynaword-32k), słownik 32 000, `<\|endoftext\|>`=0 \|
	\| Dane \| polski korpus dynaword-expansion (HPLT v3.0 `pol_Latn`), ~1,35 mld tokenów, 1 epoka \|
	\| Trening \| od zera, bf16, AdamW, cosine LR + warmup, weight decay 0.1 \|
	\| Sprzęt \| 1× AMD Radeon RX 7900 XTX 24GB (RDNA3/gfx1100), ROCm/WSL2, Windows \|
	\| Loss (końcowy) \| ~3.53 (perplexity ~34) — średnia training-loss z ostatnich ~30 kroków (per-krok szum 3.3-3.8) \|

	## Przepis treningu

	Wszystko poniżej pochodzi ze skryptu treningu i logu biegu tego modelu; wartości, których log nie zapisał, są oznaczone jako niezapisane.

	Skrypt: `train_125m.py` w tym repozytorium (kopia pliku o sha256 `a7fc85ad5352a2e7…` z lokalnymi ścieżkami domyślnymi zamienionymi na `./…` i wczytywaniem checkpointów przy wznowieniu przez `torch.load(..., weights_only=True)`; bez innych zmian). Jeden proces na jednej karcie AMD Radeon RX 7900 XTX (24 GB), ROCm na WSL2.

	\| \| \|
	\|---\|---\|
	\| Architektura \| 12 warstw, d_model 768, 12 głów, kontekst 512, słownik 32 000; bloki pre-LayerNorm, atencja przyczynowa, MLP 4× z GELU, uczone embeddingi pozycji, wspólne wagi embeddingu wejścia i głowy wyjścia; 110 025 216 parametrów \|
	\| Inicjalizacja \| domyślna PyTorch (bez własnej) \|
	\| Optymalizator \| AdamW, beta (0.9, 0.95), eps 1e-8 (domyślne PyTorch), weight decay 0.1 na wszystkich parametrach (jedna grupa), przycinanie gradientu 1.0 \|
	\| Learning rate \| szczyt 3e-4, liniowa rozgrzewka przez 1 % zaplanowanych kroków, potem cosine do 3e-5 (0.1 × szczyt) \|
	\| Batch \| 64 sekwencje × 512 tokenów = 32 768 tokenów na krok \|
	\| Precyzja \| autocast bf16; wagi i stan optymalizatora w fp32 \|
	\| Próbkowanie danych \| losowe okna 512 tokenów z powtórzeniami z jednego pliku tokenów, więc „epoka” = budżet tokenów ÷ rozmiar korpusu, a nie kolejne przejście po danych \|
	\| Seed \| nieustawiony (biegi nie są odtwarzalne bit w bit) \|
	\| Checkpointy \| co 2 000 kroków; wznowienie wczytuje model, optymalizator i krok (bez stanu generatora losowego); wydanie = ostatni krok \|

	Ten model (v1):
	- Dane: dynaword-expansion (HPLT v3.0 `pol_Latn`), 1 354 902 613 tokenów; 1 epoka.
	- 41 348 kroków (rozgrzewka 413); wydany checkpoint = krok 41 348.
	- Gradient accumulation: niezapisane w logu. Dokładna komenda: niezapisana; domyślne argumenty skryptu z `--data <plik tokenów korpusu>` dają konfigurację z logu.
	- Bieg był kilka razy przerywany i wznawiany z checkpointu z kroku 34 000; przepustowość mocno różniła się między segmentami, więc łączny czas nie jest jedną liczbą.

	## Użycie
	```python
	import torch
	from transformers import AutoModelForCausalLM, PreTrainedTokenizerFast
	m = AutoModelForCausalLM.from_pretrained("Maggio33/GoLLeM-110M-PL").eval()
	tok = PreTrainedTokenizerFast(tokenizer_file="tokenizer.json")
	ids = tok("Polska to kraj położony w", return_tensors="pt").input_ids
	ids = torch.cat([torch.tensor([[0]]), ids], 1) # BOS = <\|endoftext\|>=0
	out = m.generate(ids, max_new_tokens=80, do_sample=True, temperature=0.8,
	top_k=40, repetition_penalty=1.3, pad_token_id=0)
	print(tok.decode(out[0].tolist()[1:], skip_special_tokens=True))
	```

	## Dane treningowe i licencja
	- Korpus: dynaword-expansion oparty na HPLT v3.0 (`pol_Latn`), zadeklarowany CC0-1.0 (byte-verified per-shard), PII-scrubbed.
	- Uczciwy caveat: HPLT to web-crawl — CC0 dotyczy pakowania/dedykacji maintainera + przeszedł web-review i mitygacje (length-cap usuwający książki, wykluczone domeny wiki/adult/boilerplate), ale nie jest gwarantowanie "release-clean" (tekst web może zawierać treści in-copyright). To standardowa podstawa dla modeli trenowanych na korpusach web.
	- Licencja modelu: Apache-2.0.

	## Ograniczenia
	- Mały model bazowy (110M) — generuje pewnie brzmiące nieprawdy i potrafi dryfować z tematu. To cecha modelu bazowego tej skali, nie błąd.
	- Brak fine-tuningu instrukcyjnego → nie jest chatbotem.
	- Kontekst 512 tokenów. Brak filtrów bezpieczeństwa na wyjściu.
	- Dane osobowe / PII: może generować prawdopodobnie brzmiące imiona/nazwiska/adresy = KONFABULACJE (nie dane konkretnych, identyfikowalnych osób). Kontaktowe PII (telefon/e-mail/PESEL) było scrubowane w korpusie -> model zwraca tagi [Telefon]/[PII] zamiast realnych danych (zweryfikowane empirycznie). Brak filtra output-safety — weryfikacja wyjścia po stronie użytkownika.

	## Autor

	Arkadiusz Słota