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

Libraries

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

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

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

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

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

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Maggio33/GoLLeM-110M-PL-v3 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-v3"
# 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-v3",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

Use Docker

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

SGLang

How to use Maggio33/GoLLeM-110M-PL-v3 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-v3" \
    --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-v3",
		"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-v3" \
        --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-v3",
		"prompt": "Once upon a time,",
		"max_tokens": 512,
		"temperature": 0.5
	}'

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

GoLLeM-110M-PL-v3 / README.md

Maggio33

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

f43524c verified 11 days ago

preview code

Raw History Blame Contribute Delete

9.59 kB

metadata

license: cc-by-sa-4.0
language:
  - pl
library_name: transformers
pipeline_tag: text-generation
datasets:
  - SlayerLab/gollem-corpus-2b-pl
  - SlayerLab/polish-dynaword
tags:
  - gpt2
  - polish
  - base-model
  - from-scratch
  - amd-rocm
  - continued-pretraining
model-index:
  - name: GoLLeM-110M-PL-v3
    results:
      - task:
          type: text-classification
          name: PolEmo2-IN sentiment
        dataset:
          type: allegro/klej-polemo2-in
          name: PolEmo2-IN
        metrics:
          - type: accuracy
            value: 18
            name: accuracy (0-shot; domain-PMI board-repro)
      - task:
          type: text-classification
          name: 8TAGS topic
        dataset:
          type: sdadas/8tags
          name: 8TAGS
        metrics:
          - type: accuracy
            value: 41.2
            name: accuracy (0-shot; domain-PMI board-repro)
      - task:
          type: multiple-choice
          name: Belebele PL reading
        dataset:
          type: facebook/belebele
          name: Belebele pol_Latn
        metrics:
          - type: accuracy
            value: 24
            name: accuracy (0-shot)
      - task:
          type: text-classification
          name: CBD cyberbullying
        dataset:
          type: ptaszynski/PolishCyberbullyingDataset
          name: CBD
        metrics:
          - type: f1
            value: 12.6
            name: macro-F1 (0-shot; domain-PMI board-repro)
      - task:
          type: text-classification
          name: DYK question-answer
        dataset:
          type: allegro/klej-dyk
          name: DYK
        metrics:
          - type: f1
            value: 28.3
            name: positive-F1 (0-shot; domain-PMI board-repro)
      - task:
          type: token-classification
          name: KLEJ NER
        dataset:
          type: allegro/klej-nkjp-ner
          name: KLEJ-NER
        metrics:
          - type: accuracy
            value: 18.2
            name: accuracy (0-shot; domain-PMI board-repro)
      - task:
          type: text-classification
          name: PSC summary
        dataset:
          type: allegro/klej-psc
          name: PSC
        metrics:
          - type: f1
            value: 44.2
            name: positive-F1 (0-shot; domain-PMI board-repro)

GoLLeM-110M-PL-v3

Polski model językowy 110M (GPT-2-class), trenowany od zera na AMD Radeon RX 7900 XTX (ROCm/WSL2). Model bazowy (completion) — kontynuuje tekst, nie jest chatbotem (nie odpowiada na pytania; daj mu początek zdania).

Trzecia iteracja serii GoLLeM. Główna zmiana vs v2: druga epoka na tym samym czystym korpusie ~2,0 mld (podwojona ekspozycja, ~18 → ~36 tokenów/parametr) — korekta niedotrenowania v2.

Model completion. Dobrze: "Stolica Polski to" · Źle: "Jaka jest stolica Polski?"

Co nowego vs v2

Korekta niedotrenowania. v2 widział korpus 1 raz (~18 tok/param). v3 to kontynuacja pretreningu przez 2. epokę (łącznie ~4 mld tokenów widzianych z tego samego 2,0 mld korpusu).
Zmierzony efekt: wzrost na 7/9 zadań benchmarku (patrz Ewaluacja); największy na sentymencie, streszczeniach i NER.
Uczciwie: to podwojona ekspozycja na te same dane, nie nowe dane.

Trening


Parametry	110 025 216 (110M), weight-tied
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	korpus v2 ~~2,0 mld (58% curated: Wikipedia/Wikisource/Wolne Lektury/1000 Novels/Wiki/eltec + 42% HPLT v3 web clean; zero legalese), 2 epoki* (~~4 mld tok widzianych)
Trening	kontynuacja z ckpt v2 (krok 60 733 → 121 466), bf16, AdamW, cosine LR (bez ponownej rozgrzewki, patrz „Przepis treningu”), wd 0.1, batch 64 (grad-accum 4)
Sprzęt	1× AMD Radeon RX 7900 XTX 24GB (gfx1100), ROCm/WSL2, ~9 h

Ewaluacja

Protokół: OpenPL (polish4, 0-shot) + własna reprodukcja domain-PMI OrisTeam (metoda KateMajzel: ll(label|pełny) − ll(label|pusty-szablon)). Nasza reprodukcja odtwarza tablicę OrisTeam Polish-SLM-Benchmark na 7/9 zadaniach w granicach ~1-2 pp (belebele idealnie, tags8/cbd/dyk/klej_ner/polemo_in blisko). Ten sam scorer dla v2 i v3 → delta jest wiarygodna.

zadanie	v2	v3	Δ
PolEmo2-in	16,2	18,0	+1,8
PolEmo2-out	1,8*	10,7*	+8,9
8tags	41,3	41,2	−0,1
Belebele	23,0	24,0	+1,0
CBD (hate)	14,6	12,6	−2,0
DYK	23,4	28,3	+4,9
KLEJ-NER	17,5	18,2	+0,7
PPC	20,0*	25,7*	+5,7
PSC	38,1	44,2	+6,0
Sygnał-6	21,6	24,1	+2,55
kompozyt-9	21,8	24,8	+2,99

* polemo_out i ppc: nasza reprodukcja domain-PMI odbiega od tablicy OrisTeam (polemo_out schodzi poniżej losowego — znany quirk scoringu, wg KateMajzel sygnał błędu bazy PMI); delty na tych zadaniach traktować ostrożnie.

Wniosek: v3 przewyższa v2 pod spójnym scoringiem (Sygnał-6 +2,55, kompozyt +2,99), rośnie na 7/9. Regresja: CBD (mowa nienawiści) −2,0. Pozycja na oficjalnej tablicy OrisTeam — do potwierdzenia przez zgłoszenie modelu do nich (autorytatywny scoring po ich stronie).

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 (v3):

Kontynuacja v2: model i stan AdamW wczytane z checkpointu v2 (krok 60 733), druga epoka na tym samym korpusie (SlayerLab/gollem-corpus-2b-pl); łącznie ~4,0 mld widzianych tokenów.
Harmonogram przeliczono na 2 epoki (121 466 kroków, rozgrzewka 1 214). Ponieważ trening wznowiono od kroku 60 733, rozgrzewka się nie powtórzyła: learning rate skoczył z 3e-5 (koniec v2) do 1,67e-4 i dalej szedł cosine do 3e-5.
Gradient accumulation 4 (16 sekwencji w mikro-batchu), według tej karty i jej komendy; log biegu go nie zapisuje. Wydany checkpoint = krok 121 466; ~9,2 h.
Komenda (z sekcji Reprodukcja; ścieżki jako placeholdery):

python train_125m.py --run-id gollem_v3_e2b --data <gollem_v2_train_32k.bin> \
  --epochs 2 --batch 64 --accum-steps 4 --lr 3e-4
# z checkpointem v2 (krok 60 733) w katalogu checkpointów biegu

Użycie

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
m = AutoModelForCausalLM.from_pretrained("Maggio33/GoLLeM-110M-PL-v3").eval()
t = AutoTokenizer.from_pretrained("Maggio33/GoLLeM-110M-PL-v3")
ids = t("Stolica Polski to", 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.7,
                 top_k=40, repetition_penalty=1.3, pad_token_id=0)
print(t.decode(out[0].tolist()[1:], skip_special_tokens=True))

Ograniczenia

110M = mały → konfabuluje konkretne fakty; uczy się głównie płynności i formy polskiego.
Base/completion, nie chat — do rozmowy potrzebny SFT/instruct-tuning.
Kontekst 512 tokenów. Brak filtrów bezpieczeństwa na wyjściu.
PII scrubowane w treningu (telefon/e-mail/PESEL/NIP → tagi); generowane imiona/adresy to konfabulacje.
CBD (mowa nienawiści) regresja vs v2 — do zastosowań wrażliwych na detekcję hate rozważ v2.

Licencja i atrybucja

Korpus = CC-BY-SA-4.0 (dominująca, share-alike): Wikipedia/Wikisource/Wiki* — CC-BY-SA-3.0 (Wikimedia Foundation); Wolne Lektury — CC-BY-SA-4.0 / Wolna Sztuka 1.3; 1000 Novels, eltec_pol — CC-BY-4.0; HPLT v3 (web) — CC0-1.0. Użycie wymaga ATTRIBUTION (Wikimedia Foundation, Wolne Lektury, autorzy 1000 Novels, HPLT/CLARIN-PL) oraz SHARE-ALIKE. Model: CC-BY-SA-4.0.

Podziękowania

Benchmark i protokół ewaluacyjny: OrisTeam (Polish-SLM-Benchmark); metoda kalibracji domain-PMI: KateMajzel (gollem-pl).

Reprodukcja

Trening: train_125m.py --run-id gollem_v3_e2b --data gollem_v2_train_32k.bin --epochs 2 --batch 64 --accum-steps 4 --lr 3e-4 (resume z ckpt v2). Dane treningowe jawnie: SlayerLab/gollem-corpus-2b-pl (dokładny korpus v2/v3). Ewaluacja: board_eval.py (domain-PMI). Skrypt treningu: train_125m.py w tym repozytorium.

Autor: Arkadiusz Słota.