rafalohaki/javamc

MC-Java SFT Dataset — Qwen3-4B-Thinking Fine-Tune

Pipeline budowy datasetu SFT do douczenia Qwen3-4B-Thinking-2507 na całym stacku Java MC developera: pluginy Folia / Paper / Velocity / packetevents (server-side, MC 1.21.11 i 26.1.2) oraz mody Fabric 26.1 (client/modding-side) z prawdziwym, zdekompilowanym źródłem Minecraft / Fabric API / Fabric Loader / SpongePowered Mixin / MixinExtras + dokumentacją Fabric, plus idiomy Java 21/25 (LTS). Cel: model, który zna realne klasy, metody i powiązania (nie halucynuje API) i potrafi pisać mixiny.

~18.7k zwalidowanych par (z 1.8k). Pięć domen: mc, fabric, mixin, folia/velocity, java.

Strategia w dwóch zdaniach

SFT na czystej masie REALNEGO kodu (zdekompilowany MC 26.1 + open-source Fabric/Mixin + parametryczne pary server-side), później (opcjonalnie) GRPO z verifiable rewards. SFT uczy API z prawdziwych sygnatur, GRPO odsiewa resztki halucynacji. Model jest „Thinking" — część kategorii decyzyjnych ma zwięzłe uzasadnienia. Najpierw fundament (realne klasy), potem szlif.

⚠️ Licencja: pary z domeny mc (zdekompilowany net.minecraft.*) podlegają EULA Mojang — tylko do lokalnego/własnego treningu, NIE redystrybuować. Reszta (Fabric Apache-2.0, Mixin MIT, parametryczne własne) jest wolna. Szczegóły i filtr publikacyjny: docs/SOURCES.md.

Co siedzi w tym repo

Ścieżka	Rola
api_index/folia_api_index.json	Zweryfikowany indeks publicznych klas/metod Folia+Paper+Velocity z jd.papermc.io. Używany do walidacji importów — kluczowa broń przeciw halucynacjom.
src/parse_javadoc.py	Buduje indeks API z Javadoc HTML. Idempotentne, można odpalać per wersja.
src/scrape_github.py	Klonuje płytko repozytoria z prawdziwymi pluginami Folia (filtr: io.papermc.paper.threadedregions w kodzie + ≥3 stars + commit w 2025+).
src/extract_pairs.py	Tworzy pary instruction → output z plików .java + Javadoc + diff'ów Bukkit→Folia. Używa Anthropic API z prompt caching.
src/validate.py	Twarda walidacja: kompilacja w sandboxie, sprawdzenie importów przeciw folia_api_index.json, heurystyki anti-Bukkit-w-Folii.
sandbox/Dockerfile	JDK 21 + Maven + deps Folia/Paper/Velocity. Endpoint /compile zwraca {ok, errors}.
src/dedup.py	MinHash dedup (próg 0.85) — kluczowe, bo Folia repos masowo kopiują kod od siebie.
src/split.py	Stratyfikowany podział 95/3/2 train/val/test + konwersja na chat-format i Alpaca.
src/generate_extra.py	NOWE. Generatory parametryczne: Java 21/25 (LTS), setup modów Fabric 26.1 (build.gradle, fabric.mod.json, mixins.json, migracja Yarn→Mojang), Folia 26.1.2 (deps, manifest, wersjonowanie).
src/javasrc.py	NOWE. Pragmatyczny parser strukturalny Java (świadomy komentarzy/stringów): pakiet, importy, typy, metody, pola, hierarchia, ciała metod. Obsługuje Java 25.
src/extract_source_pairs.py	NOWE. Zdekompilowane drzewa .java (MC/Fabric/Mixin) → zwięzłe pary: api.class_card, api.hierarchy, api.method_src, mixin.inject (na realnych sygnaturach).
src/extract_docs.py	NOWE. Fabric docs (Markdown) → pary konceptualne fabric.docs (mixiny, rejestry, rendering, networking…).
src/balance_merge.py	NOWE. Scala shardy i balansuje po (domena, kategoria) — przycina nadmiar MC, zachowuje wszystkie karty i mixiny.
scripts/build_full.sh	NOWE. End-to-end build wszystkich pillarów → data/export/. Używa .venv (deps z requirements.txt).
work/	NOWE (lokalne, nie commitować). Toolchain dekompilacji: fabric-261/ (template+Loom), mc-decomp/ (zdekompilowany MC 26.1), sources/ (Fabric/Mixin/docs).
seed/seed_pairs.jsonl	Hand-crafted, gold-standard pary (∼60). Każda walidowana, każda z prawdziwymi importami. Baza, której pipeline NIE generuje.
prompts/synth_prompts.txt	Banki promptów do generacji syntetycznej.
docs/DATASET_SCHEMA.md	Format JSONL.
docs/SOURCES.md	Źródła + licencje + provenance.
docs/ANTIPATTERNS.md	Lista konkretnych antywzorców Bukkit/Paper, których model ma NIE pisać w kontekście Folii.

Target

• build_full.sh (wszystkie pillary): ~18.7k par zwalidowanych po dedupie. One command (po jednorazowym genSources).
• Rozkład domen: mc ~11k (zdekompilowane API), fabric ~3.5k, mixin ~2.2k, folia/velocity ~1.8k, java ~130.
• Stary szybki wariant (server-only, bez moddingu): make quickstart → ~1.8k par.

Status pipeline'u: scripts/build_full.sh produkuje 18 711 par (train 17 776 / val 557 / test 378) po dedupie (0.95). Walidacja domeno-świadoma (validate.py --no-compile): reguły anty-Bukkit tylko dla folia/paper; pary źródłowe są realnym kodem (import-check). p99 sekwencji ≈ 548 tok, max ≈ 1193 → trening na --max-seq-len 1024.

Pillary (skąd wiedza)

Pillar	Domena	~Pary	Źródło
Zdekompilowane MC 26.1	mc	11000	com.mojang:minecraft:26.1.2 → Loom genSources + Vineflower (Mojang mappings, nieobfuskowane)
Fabric API/Loader + setup	fabric	3500	github FabricMC + autorytatywny build 26.1 + Fabric docs
Mixin + MixinExtras	mixin	2250	github SpongePowered/Mixin, LlamaLad7/MixinExtras + @Inject na realnych metodach MC
Folia/Paper/Velocity/packetevents	folia/velocity	1800	parametryczny generator (1.21.11 + 26.1.2) + seed
Java 21/25 (LTS)	java	130	idiomy (records, sealed, pattern matching, virtual threads, scoped values, instance main…)

Skąd dane

1. Javadoc Folia/Paper/Velocity — jd.papermc.io/{folia,paper,velocity}/{1.21.11,3.5.0}/. Ground truth dla sygnatur API. Generuje ∼300–500 par "API → użycie" przy systematycznym przejściu.
2. Javadoc bibliotek integracyjnych — PacketEvents 2.12.1 (javadocs.packetevents.com), ProtocolLib 5.4.0 (dmulloy2.net/ProtocolLib/javadoc/, 1.21.11 supported od 2026-02-02), VaultAPI 1.7 (milkbowl.github.io/VaultAPI/). Trzy biblioteki, które realnie są używane w >50% pluginów Paper.
3. GitHub — repozytoria pluginów Folia (filtr na io.papermc.paper.threadedregions + ≥3 stars + 2025+).
4. Migration pairs — commity migrujące stare pluginy z Bukkit na Folię (git log --grep folia w popularnych pluginach).
5. Antywzorce → poprawki — para Bukkit.getScheduler().runTask(...) → poprawny equivalent z EntityScheduler / RegionScheduler.
6. Distylacja z Opus 4.7 — generujesz ∼2000 promptów, Opus pisze rozwiązania, TY filtrujesz przez sandbox (mvn compile + walidacja importów). Tylko czyste przechodzą. To distylacja Z FILTREM — odsiewa halucynacje samego Opusa.

Hard rules (anti-halucination)

Każda para musi przejść:

1. output kompiluje się (mvnd compile w sandboxie z prawdziwymi deps Folia 1.21.11).
2. Każdy import w output istnieje w folia_api_index.json (lub jest z JDK / Adventure / Brigadier).
3. Brak Bukkit.getScheduler(), BukkitRunnable, runTask(, runTaskLater(, runTaskTimer(, runTaskAsynchronously(, runTaskLaterAsynchronously(, runTaskTimerAsynchronously( jeśli plugin deklaruje Folia support. (BukkitScheduler jest @Deprecated w folia-api.)
4. Dedup MinHash 0.85 (Folia repos masowo kopiują od siebie — bez tego model nauczy się jednego stylu).

Full build (modding + server) — NOWE

Wymaga JDK 25 (np. GraalVM), git, ~3 GB miejsca. Jednorazowo: dekompilacja MC 26.1 + klon źródeł.

# 0) venv z zależnościami (datasketch, pandas, pyarrow) — bez dotykania systemowego Pythona
python3 -m venv .venv && ./.venv/bin/pip install -r requirements.txt

# 1) dekompilacja MC 26.1.2 do .java (Loom genSources + Vineflower) + klon Fabric/Mixin/docs
bash scripts/fetch_sources.sh        # jednorazowo; artefakty w work/ (mc-decomp/, sources/)

# 2) end-to-end build wszystkich pillarów
bash scripts/build_full.sh
# -> data/export/dataset.{parquet,jsonl}  (~18.7k par)
# -> data/chat/{train,val,test}.jsonl

Trening: scripts/run_training.sh (już ustawiony na --max-seq-len 1024).

Quick start (server-only, legacy)

make api-index     # buduje folia_api_index.json z Javadoc
make scrape        # klonuje repo Folia z GitHub (wymaga GH_TOKEN)
make sandbox       # buduje Docker image walidacyjny
make seed          # waliduje seed/seed_pairs.jsonl
make synth         # generuje syntetyczne pary z indeksu API
make validate      # waliduje wszystko przez sandbox
make dedup         # MinHash
make split         # train/val/test + konwersja formatu
make stats         # statystyki datasetu

Albo jedna komenda (deterministyczny generator + seed, bez Dockera i API key):

make quickstart    # ~1810 par → data/export/{train,val,test}.{jsonl,parquet}

Training pipeline (Apple Silicon, pmetal)

Pełen flow od czystego repo do ollama run folia:v1. Krok po kroku — każda komenda idempotentna, można restartować w razie czego.

0. Prereki (jednorazowo)

# (a) pmetal — Rust LoRA/QLoRA trainer dla Apple Silicon
git clone https://github.com/Epistates/pmetal
(cd pmetal && cargo build --release)        # ~5 min, daje ./pmetal/target/release/pmetal

# (b) model bazowy (Qwen3 4B Thinking, text-only, ~8 GB)
git lfs install
git clone https://huggingface.co/Qwen/Qwen3-4B-Thinking-2507

# (c) Ollama (do deploymentu w OpenCode / Cursor / lokalnym CLI)
brew install ollama
ollama serve &     # uruchom daemon w tle

1. Zbuduj dataset

make quickstart
# sprawdź:
ls -lh data/export/{train,val,test}.jsonl
# train: ~1710 par, val: ~56, test: ~45

2. Odpal trening (one-shot, w tle)

# blokada sleepu — KRYTYCZNE na MacBooku, M5 GPU stanie przy uśpieniu:
caffeinate -dimsu -t 86400 &

# start: pmetal QLoRA + auto-watcher (eval/fuse/GGUF/Ollama po treningu)
bash scripts/run_training.sh

Skrypt:

• waliduje prereki (binary, model, dataset, brak konfliktu z innym treningiem),
• startuje pmetal train w tle (nohup + disown),
• startuje auto_post_train.sh — odpali post-train pipeline jak tylko pmetal padnie z sukcesem,
• printuje PID-y i przykładowe komendy do monitorowania.

Konfiguracja low-RAM (default w run_training.sh):

• --batch-size 1 --gradient-accumulation-steps 4 (efektywny batch 4)
• --max-seq-len 512 (dataset p99=361 tokenów, mamy 40% zapasu)
• --quantization nf4 (4-bit base + bf16 LoRA)
• --cut-cross-entropy (memory-efficient loss przy vocab 151k)
• --lora-r 16 --lora-alpha 32 (33 M trainable params)

Peak RAM: ~10-12 GB z 24 GB unified memory (M5). ETA na M5 24 GB: ~10-14 h dla 1710 par × 2 epochs, FlashAttention enabled. Loss curve startuje ~2.2 i schodzi <1.0 w pierwszych ~5 krokach.

3. Monitoruj postęp

# live tail z filtrem na ważne linie:
tail -f folia-v1-adapter/training.log \
  | grep --line-buffered -E 'Step [0-9]+:|Epoch [0-9]|Eval|complete|error|panic|OOM'

# status procesów:
pgrep -fl 'pmetal train|auto_post_train'

# metryki w JSONL (loss/lr/throughput per step):
tail -f folia-v1-adapter/metrics.jsonl | jq -c '{step, loss, lr, tokens_per_s}'

4. Po treningu — auto pipeline (nic nie robisz)

auto_post_train.sh wykryje że pmetal train padło z sukcesem i odpali scripts/post_train.sh, który:

1. Eval — scripts/eval_test.sh 30 → 30 promptów z test.jsonl przez pmetal infer --lora folia-v1-adapter, score przez validate.py (imports_real + anti_bukkit). Wynik: eval/v1/predictions.validated.jsonl.
2. Fuse — pmetal fuse → folia-v1-fused/ (pełen model, adapter wmergowany).
3. GGUF — pmetal quantize --method q4_k_m → folia-v1.q4_k_m.gguf (~2.5 GB).
4. Modelfile — pmetal ollama modelfile z system promptem + temp 0.2 + ctx 8192.
5. Ollama — ollama create folia:v1 -f Modelfile.

Status sprawdzasz w folia-v1-adapter/auto_post_train.log.

5. Użycie w OpenCode / CLI

# test lokalny:
ollama run folia:v1 'Napisz listener tworzący Moba przez EntityScheduler'

# w OpenCode / Cursor / Claude Code: provider = ollama, model = folia:v1
# domyślny endpoint: http://localhost:11434

Aborty i recovery

# zabij trening i watcher:
pkill -f 'pmetal train'
pkill -f 'auto_post_train'

# wyczyść artefakty i zacznij od nowa:
rm -rf folia-v1-adapter folia-v1-fused folia-v1.q4_k_m.gguf Modelfile

# wznów z checkpointa (jeśli pmetal zapisał — zwykle robi to na koniec epoch):
./pmetal/target/release/pmetal train --resume --output folia-v1-adapter ...

Tuning parametrów (jeśli pierwszy run nie wyszedł)

Symptom	Lek
Loss nie spada poniżej 1.0	więcej epoch (--epochs 3), wyższy LR (--learning-rate 3e-4), wyższy LoRA rank (--lora-r 32 --lora-alpha 64)
Loss skacze / NaN	niższy LR (1e-4), włącz warmup (--warmup-steps 50), zostaw adaptive_lr (default ON)
Masz wolne RAM, chcesz szybciej	--batch-size 2 --gradient-accumulation-steps 2, ewentualnie --max-seq-len 1024 (jeśli p99 zaczyna się o to ocierać)
OOM przy starcie	--lora-r 8 --lora-alpha 16, sprawdź czy --cut-cross-entropy ON, --max-seq-len 384
Wolno (>60s/step)	zmniejsz --max-seq-len do realnego p99 (sprawdź w log: lengths: mean=X, p95=Y)
Model halucynuje API po treningu	rozszerz seed/seed_pairs.jsonl, regeneruj make quickstart, retrain

Format docelowy

Chat-format dla Gemma 4 Instruct (najbliższe deploymentowi):

{"messages": [
  {"role": "system", "content": "Jesteś ekspertem od Folia/Paper API 1.21.11. Piszesz nowoczesny kod Java 21, używasz wyłącznie realnych klas z Folia API."},
  {"role": "user", "content": "..."},
  {"role": "assistant", "content": "..."}
]}

Alpaca dla wariantu bazowego (nie-Instruct) w data/alpaca/.

Limity i rzetelność

• Wersje API się rozjeżdżają. Trzymamy się Folia 1.21.11, Paper 1.21.11, Velocity 3.5.0-SNAPSHOT. Bez mieszania. (-SNAPSHOT w Velocity to stała konwencja — gałąź 3.x żyje jako SNAPSHOT przez lata, to wersja produkcyjna, nie testowa.)
• paper-plugin.yml + flaga folia-supported: true — wymagana w każdym wygenerowanym przykładzie pluginu pod Folię.
• Java 21 jest LTS przy MC 1.21.11. Java 25 jest opcjonalna (records, pattern matching, sealed). Nie używamy preview features.