Instructions to use SlayerLab/goLLeM-110M-PL-SFT-merged with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use SlayerLab/goLLeM-110M-PL-SFT-merged with Transformers:

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

pipe = pipeline("text-generation", model="SlayerLab/goLLeM-110M-PL-SFT-merged")

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("SlayerLab/goLLeM-110M-PL-SFT-merged")
model = AutoModelForCausalLM.from_pretrained("SlayerLab/goLLeM-110M-PL-SFT-merged", device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use SlayerLab/goLLeM-110M-PL-SFT-merged with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/SlayerLab/goLLeM-110M-PL-SFT-merged

SGLang

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

Docker Model Runner
How to use SlayerLab/goLLeM-110M-PL-SFT-merged with Docker Model Runner:
```
docker model run hf.co/SlayerLab/goLLeM-110M-PL-SFT-merged
```

GoLLeM-110M-PL-SFT-merged

Wydanie eksperymentalne / Experimental release. Model nie jest przeznaczony do zastosowań produkcyjnych ani wysokiego ryzyka.

Instruction-tuned (SFT) wersja GoLLeM-110M-PL — małego, polskojęzycznego modelu bazowego typu decoder-only, wytrenowanego od zera na konsumenckiej karcie AMD Radeon RX 7900 XTX (ROCm/WSL2, Windows), bez NVIDII i bez chmury. Implementacja GPT-2 (nanoGPT-style) + własny polski tokenizer BPE. Wersja merged = wagi SFT scalone do formatu GPT2LMHeadModel (ładowalne standardowym transformers).

Architektura i tokenizer

Właściwość	Wartość
Typ	GPT-2-style decoder-only Transformer
Warstwy / głowy / d_model	12 / 12 / 768
Maksymalny kontekst	512 tokenów
Słownik	32 000 (polski byte-level BPE, dynaword-32k)
Parametry	~110M (weight-tied embeddings)
Token specjalny	`<
Format	`GPT2LMHeadModel`, safetensors

Baza, dane i trening

Model bazowy: SlayerLab/goLLeM-110M-PL (ckpt_00060733), pretrenowany od zera na korpusie dynaword-expansion (HPLT v3.0 pol_Latn, ~1,35 mld tokenów, 1 epoka), PII-scrubbed. Język treningu: 100% polski.
SFT: grounded-QA, 26 194 par (4 autorów, CC-BY-SA-inherit); 3 epoki, lr 2e-5, weight decay 0.1, batch 16 × accum 4 (efektywny 64), ~3 min 40 s na RX 7900 XTX (ROCm).
Gate treningowy: PII 0, regurgitacja 0 (model składa ze wzorców, nie recytuje danych); forma odpowiedzi 15/15 (0 kontynuacji, 0 boilerplate).

Ewaluacja

Zero-shot, pełne splity. Ewaluacja pokrywa dwa języki: polski (3 benchmarki) — realna kompetencja modelu — oraz angielski (7 benchmarków) — transfer międzyjęzykowy (model jest jednojęzyczny polski, więc EN mierzy transfer, nie zdolność). Bateria EN: lm-evaluation-harness 0.4.12 (te same taski i wersja co karta Pollock). Bateria PL: port protokołu dmpod (eval_pl_bench, mean-loglikelihood-per-token, length-normalized, accuracy + macro-F1). Pomiar: SlayerLab (Latarnik/Hart), 2026-08-27, RX 7900 XTX.

🇵🇱 Bateria POLSKA — kompetencja (random: 8Tags .125, PolEmo2 .25)

Benchmark	Język	Accuracy	Macro-F1	Próbki
8Tags	🇵🇱 PL	0.1102	0.0348	4 372
PolEmo2-IN	🇵🇱 PL	0.4238	0.2426	722
PolEmo2-OUT	🇵🇱 PL	0.3563	0.1699	494

🇬🇧 Bateria ANGIELSKA — transfer międzyjęzykowy (random: BLiMP/PIQA .5, reszta ~.25)

Benchmark	Język	Metryka	Wynik
BLiMP	🇬🇧 EN	acc	0.5404
LAMBADA OpenAI	🇬🇧 EN	acc	0.0223 (ppl 55056)
HellaSwag	🇬🇧 EN	acc_norm	0.2817
PIQA	🇬🇧 EN	acc_norm	0.5065
SciQ	🇬🇧 EN	acc_norm	0.6000
ARC-Easy	🇬🇧 EN	acc_norm	0.2597
ARC-Challenge	🇬🇧 EN	acc_norm	0.2270

Interpretacja (uczciwie): to model polski (trenowany 100% PL). Bateria 🇵🇱 mierzy realną kompetencję, bateria 🇬🇧 — transfer międzyjęzykowy. Na EN wypada ~losowo (LAMBADA ppl 55056 = nie przewiduje angielskiego następnego słowa) — to oczekiwane dla modelu monolingwalnego, nie wada. Sygnał jest tam, gdzie powinien: PolEmo2-IN 0.424 (nad losowym 0.25). Uwaga porównawcza: względem bazy GoLLeM-110M-PL SFT nie podniósł zdolności zero-shot klasyfikacji (8Tags pozostaje ~losowo; wzrost accuracy PolEmo2 idzie w parze ze spadkiem macro-F1 = przesunięcie ku klasie większościowej). Model najlepiej traktować jako completion/instruction-following bazowej skali, nie jako klasyfikator. Confound porównań z modelami innej klasy: różny słownik i długość kontekstu.

Użycie

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_id = "SlayerLab/goLLeM-110M-PL-SFT-merged"
tok = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id).eval()

ids = tok("Polska to kraj położony w", return_tensors="pt").input_ids
out = model.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], skip_special_tokens=True))

Ograniczenia i odpowiedzialne użycie

Mały model (110M) — generuje pewnie brzmiące nieprawdy i potrafi dryfować z tematu; wiedza faktograficzna jest ograniczona skalą.
Trenowany i oceniany głównie po polsku; po angielsku ~losowo (transfer).
Kontekst 512 tokenów, brak filtrów bezpieczeństwa na wyjściu.
PII: może generować prawdopodobnie brzmiące imiona/adresy = konfabulacje, nie dane realnych osób; kontaktowe PII (telefon/e-mail/PESEL) było scrubowane w korpusie (model zwraca tagi [Telefon]/[PII]). Weryfikacja wyjścia po stronie użytkownika.

Licencja i pochodzenie

Licencja: CC-BY-SA-4.0 (dziedziczona po danych SFT grounded-QA, CC-BY-SA-inherit).
Model i trening: Arkadiusz Słota / SlayerLab. Architektura oparta na GPT-2 / nanoGPT.

Downloads last month: 5

Safetensors

Model size

0.1B params

Tensor type

F32

Evaluation results

Accuracy (PL) on 8Tags (Polish)
test set self-reported

0.110
Macro-F1 (PL) on 8Tags (Polish)
test set self-reported

0.035
Accuracy (PL) on PolEmo2-IN (Polish)
test set self-reported

0.424
Macro-F1 (PL) on PolEmo2-IN (Polish)
test set self-reported

0.243
Accuracy (PL) on PolEmo2-OUT (Polish)
test set self-reported

0.356
Macro-F1 (PL) on PolEmo2-OUT (Polish)
test set self-reported

0.170
acc (EN) on BLiMP (English)
self-reported

0.540
acc (EN) on LAMBADA OpenAI (English)
test set self-reported

0.022