Name: LLM Configurator — GPU VRAM Checker
Author: LLM Configurator

Ujawnienie afiliacyjne: Niektóre odnośniki na tej stronie to linki afiliacyjne — jeśli dokonasz zakupu za ich pośrednictwem, LLM Configurator może otrzymać prowizję bez dodatkowych kosztów dla Ciebie. Jako uczestnik programu Amazon Associates, LLM Configurator zarabia na kwalifikujących się zakupach.

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:

NVIDIA GeForce RTX 4060 Ti 16GB

16 GB VRAM · 165 W board power

Ceny w 2026 są niestabilne — sprawdź aktualną ofertę.

Sprawdź cenę na Amazon

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

Trzy dobre opcje, w kolejności:

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.
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.
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):

json

{"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):

bash

pip install unsloth

python

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)

bash

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:

python

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:

bash

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:

bash

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:

python

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:

bash

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ś):

shell

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

bash

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:

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.
Model papuguje przykłady treningowe słowo w słowo — przetrenowanie. Zejdź do 1 epoki lub dodaj więcej zróżnicowanych danych.
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.
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

Następny →Fine-tuning czy dobry prompt?