Poradnik 14: Dostrój swój pierwszy model LLM w godzinę

Autor: Jakub Rusinowski · Ostatnia aktualizacja: 12 lipca 2026

W tym przewodniku

Krok 0 — Czy w ogóle powinieneś robić fine-tuning? (5 min)
Krok 1 — Wybierz swoją ścieżkę (2 min)
Krok 2 — Wybierz startowy zbiór danych (5 min)
Krok 3A — Trening na NVIDIA z Unsloth (25 min)
Krok 3B — Trening na Macu z MLX (25 min)
Krok 4 — Testowanie i eksport do Ollama (10 min)
Krok 5 — Co poszło nie tak? (5 min)
Co dalej

Pod koniec tej godziny będziesz mieć mały model językowy, który odpowiada w TWOIM formacie, działający lokalnie w Ollama — koszt całkowity: 0 USD. Doktorat niepotrzebny. Potrzebujesz dokładnie jednego z: karty NVIDIA z 6GB+ VRAM lub Maca z Apple Silicon i 16GB+ RAM. Wybierzemy startowy zbiór danych, wytrenujemy adapter QLoRA z zachowawczymi ustawieniami, które nie wysadzą treningu w powietrze, wyeksportujemy do GGUF i porozmawiamy z własnym modelem. To jest przepis w pigułce; Poradnik 13: Fine-tuning modeli LLM lokalnie to pełna „książka kucharska” — zajrzyj tam, gdy zechcesz poznać teorię danego kroku.

Krok 0 — Czy w ogóle powinieneś robić fine-tuning? (5 min)

Uczciwa bramka, zanim poświęcisz godzinę: fine-tuning to *trzecie* narzędzie, po które warto sięgnąć, a nie pierwsze.

Najpierw prompt. Dobry prompt systemowy plus dwa–trzy przykładowe wyniki rozwiązują większość problemów typu „spraw, by odpowiadał jak X” w pięć minut. Po drugie RAG. Jeśli problemem jest *wiedza* — Twoje dokumenty, Twój produkt, aktualne fakty — wygrywa wyszukiwanie, bo fine-tuning nie dodaje faktów w sposób niezawodny. Rób fine-tuning, gdy potrzebujesz spójnego stylu lub formatu w każdej odpowiedzi, specyficznego dla domeny słownictwa, uporządkowanego wyniku, który zawsze musi się parsować, albo krótkiego promptu ze względu na opóźnienia. To wersja na jeden akapit — pełną listę decyzyjną z przykładami znajdziesz w sekcji „Kiedy robić fine-tuning?” Poradnika 13.

Nadal tu jesteś? Dobrze — styl, format i ton to dokładnie to, co godzinny fine-tuning robi dobrze.

Krok 1 — Wybierz swoją ścieżkę (2 min)

	Ścieżka A: NVIDIA	Ścieżka B: Apple Silicon
Sprzęt	GPU GeForce z 6GB+ VRAM (RTX 3060/4060 lub lepsza)	Mac M1–M4 z 16GB+ pamięci zunifikowanej
Narzędzie	Unsloth (QLoRA na bazie 4-bit)	MLX-LM (LoRA na modelu 4-bit)
Model bazowy	unsloth/Llama-3.2-3B-Instruct	mlx-community/Mistral-7B-Instruct-v0.3-4bit
Czas dla ~1k próbek	~20–60 min	~20–40 min

QLoRA to sztuczka, która czyni to możliwym na sprzęcie konsumenckim: model bazowy jest ładowany w 4-bit, a Ty trenujesz tylko małe macierze adaptera, więc fine-tuning 7B mieści się w około 6GB VRAM — a fine-tuning 4-bitowego 7B na Macu zużywa mniej więcej 8GB pamięci roboczej, zostawiając zapas na maszynie 16GB. Na ścieżce B zauważ, że trenowanie adaptera LoRA na już-4-bitowym modelu *to jest* QLoRA — MLX obsługuje to bez dodatkowej konfiguracji.

Nie masz pewności, czy Twoja karta się kwalifikuje? Sprawdź swoją kartę GPU w analizatorze sprzętu. W ogóle nie masz zgodnego sprzętu? Wynajmij RTX 4090 za ~0,35 USD/godz — zobacz Przewodnik wynajmu chmurowego GPU; wszystko poniżej działa identycznie na wynajętej maszynie.

Jeśli szukasz pierwszej karty do fine-tuningu, 16GB RTX 4060 Ti to złoty środek — dość VRAM na treningi QLoRA modeli 13B:

Krok 2 — Wybierz startowy zbiór danych (5 min)

Trzy dobre opcje, w kolejności:

1. No Robots — 10 tys. przykładów napisanych w całości przez ludzkich anotatorów. Mały, czysty, różnorodny. Najlepszy pierwszy zbiór do *nauki* przepływu pracy — i to jego używają poniższe skrypty. 2. Databricks Dolly 15k — 15 tys. par napisanych przez ludzi na licencji CC BY-SA 3.0. Wybierz ten, jeśli Twój fine-tune mógłby kiedykolwiek trafić do produktu. 3. Twoje własne 200–500 przykładów — w chwili, gdy chcesz, by model brzmiał jak *Ty*, nic nie przebije Twoich własnych danych. Użyj formatu Alpaca JSONL (tego samego co w Poradniku 13):

{"instruction": "Summarize this support ticket in two sentences.", "input": "Customer reports login fails after password reset...", "output": "Customer cannot log in following a password reset. Issue traced to a stale session cookie; cleared and resolved."}

> ⚠️ Sprawdź licencję przed treningiem. Alpaca i ShareGPT są na CC BY-NC (niekomercyjne) — podobnie No Robots, więc traktuj go jako zbiór do nauki. Do czegokolwiek komercyjnego użyj Dolly 15k (CC BY-SA) lub innego zbioru na liberalnej licencji — przefiltruj centrum zbiorów danych według „Permissive”, aby zobaczyć wszystkie.

Krok 3A — Trening na NVIDIA z Unsloth (25 min)

Jeden skrypt, od góry do dołu. Najpierw instalacja (świeże środowisko venv oszczędza bólu z zależnościami CUDA):

pip install unsloth

from unsloth import FastLanguageModel
from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

# 1. Load a small 4-bit base — 3B keeps this comfortable even on 6GB cards
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-3B-Instruct",
    max_seq_length=2048,
    load_in_4bit=True,
)

# 2. Add LoRA adapters (r=16 is the standard starting point)
model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=16,
    lora_dropout=0,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
)

# 3. Load No Robots and render each conversation with the chat template.
#    Columns on the HF card: prompt, prompt_id, messages, category —
#    "messages" is the list of {role, content} turns we train on.
dataset = load_dataset("HuggingFaceH4/no_robots", split="train[:1000]")

def to_text(row):
    return {"text": tokenizer.apply_chat_template(row["messages"], tokenize=False)}

dataset = dataset.map(to_text)

# 4. Train — conservative defaults, same as Guide 13
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=2,
        learning_rate=2e-4,
        logging_steps=10,
        optim="adamw_8bit",
        output_dir="./outputs",
        save_strategy="epoch",
    ),
)
trainer.train()

# 5. Save the adapter
model.save_pretrained("my-first-lora")
tokenizer.save_pretrained("my-first-lora")

Na GPU klasy RTX 3060/4060 dla podzbioru 1000 przykładów (2 epoki) spodziewaj się mniej więcej 20–60 minut — rozrzut zależy od długości przykładów; starsze karty 6GB lądują u górnej granicy. Strata (loss) powinna zaczynać się od około 2 i systematycznie spadać; jeśli tak się nie dzieje, przejdź do Kroku 5.

Krok 3B — Trening na Macu z MLX (25 min)

pip install mlx-lm

MLX oczekuje folderu data/ z plikami train.jsonl i valid.jsonl w swoim formacie czatu — każda linia to {"messages": [...]}, a ostatnia wiadomość to to, czego model uczy się generować. Przekonwertuj No Robots w kilku linijkach:

import json
from datasets import load_dataset

ds = load_dataset("HuggingFaceH4/no_robots")
def dump(rows, path):
    with open(path, "w") as f:
        for row in rows:
            f.write(json.dumps({"messages": row["messages"]}) + "\n")

dump(ds["train"].select(range(1000)), "data/train.jsonl")
dump(ds["test"].select(range(100)), "data/valid.jsonl")

Następnie trenuj — jedno polecenie:

mlx_lm.lora \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --data ./data \
  --train \
  --batch-size 2 \
  --iters 600

Ponieważ model bazowy jest już 4-bitowy, ten trening LoRA to QLoRA — bez żadnych flag. Spodziewaj się 20–40 minut na M2/M3/M4 z 16GB; strata walidacyjna wypisuje się na bieżąco. Przetestuj adapter od razu:

mlx_lm.generate \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --adapter-path adapters \
  --prompt "Summarize what QLoRA does in one sentence."

Krok 4 — Testowanie i eksport do Ollama (10 min)

Ścieżka A (Unsloth): eksportuj prosto do GGUF — jedna linia dodana do skryptu:

model.save_pretrained_gguf("my-first-model", tokenizer, quantization_method="q4_k_m")

Ścieżka B (MLX): wtop adapter w wagi i wyeksportuj. Eksport GGUF wymaga wag fp16, więc dekwantyzuj podczas wtapiania:

mlx_lm.fuse \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --adapter-path adapters \
  --de-quantize \
  --export-gguf

Teraz podłącz go do Ollama dwulinijkowym Modelfile (wskaż FROM na plik .gguf, który właśnie utworzyłeś):

FROM ./my-first-model/unsloth.Q4_K_M.gguf
SYSTEM You are a concise assistant that answers in two sentences maximum.

ollama create my-first-model -f Modelfile
ollama run my-first-model

Porównanie „przed/po” to Twoja nagroda. Ten sam prompt — „Wyjaśnij, co robi VPN”:

Przed (model bazowy): *„Świetne pytanie! VPN, czyli wirtualna sieć prywatna, to technologia tworząca bezpieczne, szyfrowane połączenie w mniej bezpiecznej sieci… [jeszcze trzy akapity]”*

Po (Twój fine-tune): *„VPN szyfruje Twój ruch i przekierowuje go przez zdalny serwer, ukrywając Twoją aktywność przed sieciami lokalnymi i maskując adres IP. Chroni prywatność w publicznym Wi-Fi, ale nie czyni Cię anonimowym.”*

Tak wygląda każdy udany fine-tuning stylu: ta sama wiedza, Twój format.

Krok 5 — Co poszło nie tak? (5 min)

Cztery porażki, które trafiają się każdemu, w kolejności częstotliwości:

1. Brak pamięci CUDA (out of memory) — obniż per_device_train_batch_size do 1, zetnij max_seq_length do 1024 lub (MLX) dodaj --grad-checkpoint. QLoRA na bazie 3B mieści się w ~4GB; jeśli tam dostajesz OOM, coś innego zajmuje VRAM — zamknij to. 2. Model papuguje przykłady treningowe słowo w słowo — przetrenowanie. Zejdź do 1 epoki lub dodaj więcej zróżnicowanych danych. 3. Model zgłupiał we wszystkim innym — zbyt wysoki learning rate lub zbyt wiele epok wymazało ogólne umiejętności. Wróć do 2e-4 i 2 epok; dlatego to są wartości domyślne. 4. Strata nigdy nie spada — prawie zawsze problem z formatem danych: pole tekstowe nie przechodzi przez szablon czatu albo klucze JSONL się nie zgadzają. Wypisz jedną sformatowaną próbkę i przeczytaj ją.

Zamiast tego dziwne błędy sterowników lub instalacji? Sekcja rozwiązywania problemów omawia CUDA OOM i pokrewne błąd po błędzie.

Co dalej

Wyostrz odpowiedzi z DPO — po SFT przebieg preferencyjny sprawia, że model *wybiera* lepsze odpowiedzi, a nie tylko je formatuje. Poradnik 13 zawiera działający skrypt DPO.
Podnieś poziom danych — przejrzyj wszystkie 47 zbiorów danych w centrum, filtrując po licencji i kategorii.
Pochwal się — wytrenowałeś coś fajnego? Prezentujemy fine-tune'y czytelników w Local AI Digest; odpowiedz na dowolne wydanie ze swoim „przed/po”.

Najczęściej zadawane pytania

Jaka jest minimalna karta GPU do fine-tuningu LLM?

Karta NVIDIA 6GB (klasy RTX 3060/4060) wygodnie dostraja model 7B z QLoRA, a model 3B mieści się w około 4GB. Pełny fine-tuning bez QLoRA potrzebuje 10–20× więcej pamięci — dlatego każdy krok w tym przewodniku używa baz 4-bit z adapterami LoRA.

Czy mogę dostroić LLM na Macu?

Tak. Framework MLX firmy Apple trenuje adaptery LoRA na modelach 4-bit, używając pamięci zunifikowanej — Mac M-serii z 16GB obsłuży fine-tuning 7B QLoRA w mniej więcej 8GB pamięci roboczej. Jest wolniejszy niż desktopowa karta NVIDIA, ale w pełni lokalny i cichy.

Ile przykładów potrzebuję do fine-tuningu?

Dla stylu, tonu i formatu: 200–1000 dobrych przykładów. LIMA pokazała, że 1000 starannie dobranych próbek potrafi dostroić model 65B. Dla nowych umiejętności domenowych celuj w 10 tys.+. Jakość zawsze bije ilość — jeden zły przykład uczy złego nawyku.

Ile trwa fine-tuning?

Przy ustawieniach z tego przewodnika mniej więcej 20–60 minut dla 1000 przykładów na GPU klasy RTX 3060/4060 i 20–40 minut na Macu Apple Silicon 16GB. Większe zbiory skalują się liniowo: 10 tys. przykładów to trening na noc, a nie na weekend.

Czy fine-tuning dodaje modelowi nową wiedzę?

Nie w sposób niezawodny — fine-tuning zmienia to, *jak* model odpowiada, a nie to, *co wie*. Aby model odpowiadał na podstawie Twoich dokumentów lub aktualnych faktów, użyj zamiast tego RAG (retrieval-augmented generation) albo połącz oba: RAG dla faktów, fine-tune dla stylu wypowiedzi.

Powiązane przewodniki

← Wszystkie przewodniki | Sprawdź zgodność GPU