Optymalizacja Llama 3.2 3B Instruct do generowania kodu w Pythonie – Kompletny przewodnik z Unsloth
Fine-tuning modelu Llama 3.2 3B Instruct – przewodnik krok po kroku
Sztuczna inteligencja i modele językowe zyskują na popularności, a ich dostosowywanie do konkretnych zastosowań, takich jak analiza kodu, staje się coraz bardziej powszechne. W tym przewodniku przeprowadzimy Cię przez proces konfiguracji i fine-tuningu modelu Llama 3.2 3B Instruct przy użyciu specjalnie przygotowanego zbioru danych w języku Python. Dzięki temu zrozumiesz, jak personalizować duże modele językowe pod kątem zadań związanych z programowaniem oraz jakie narzędzia i konfiguracje są niezbędne do wykorzystania biblioteki Unsloth w procesie fine-tuningu.
—
Instalacja wymaganych zależności
Zanim rozpoczniemy fine-tuning, musimy zainstalować wszystkie niezbędne biblioteki. W tym celu uruchamiamy następujące polecenia:
python
!pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
!pip install "git+https://github.com/huggingface/transformers.git"
!pip install -U trl
!pip install --no-deps trl peft accelerate bitsandbytes
!pip install torch torchvision torchaudio triton
!pip install xformers
!python -m xformers.info
!python -m bitsandbytes
Powyższe komendy instalują oraz aktualizują kluczowe biblioteki, takie jak Unsloth, Transformers, xFormers i BitsAndBytes, które są wymagane do przeprowadzenia fine-tuningu modelu Llama 3.2 3B Instruct. Ostatnie dwie linie kodu służą do uruchomienia komend diagnostycznych, które sprawdzają poprawność instalacji.
—
Importowanie niezbędnych bibliotek
Po zainstalowaniu zależności możemy zaimportować kluczowe klasy i funkcje:
python
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
import torch
from datasets import load_dataset
Zaimportowane moduły pozwalają na trenowanie i dostosowywanie modelu, a także na wczytanie zbioru danych z platformy Hugging Face.
—
Wczytywanie zbioru danych w języku Python
Aby rozpocząć proces trenowania, musimy wczytać odpowiedni zbiór danych:
python
max_seq_length = 2048
dataset = load_dataset("user/Llama-3.2-Python-Alpaca-143k", split="train")
W powyższym kodzie ustawiliśmy maksymalną długość sekwencji na 2048 tokenów oraz pobraliśmy zbiór danych zapisany na profilu użytkownika w serwisie Hugging Face. Własne zbiory danych można przechowywać na swoim koncie, aby ułatwić dostęp w przyszłości.
—
Inicjalizacja modelu Llama 3.2 3B Instruct
Teraz możemy załadować model Llama 3.2 3B Instruct w wersji 4-bitowej, co pozwala na oszczędność pamięci:
python
model, tokenizer = FastLanguageModel.from_pretrained(
model_name = "unsloth/Llama-3.2-3B-Instruct-bnb-4bit",
max_seq_length = max_seq_length,
dtype = None,
load_in_4bit = True
)
Dzięki zastosowaniu 4-bitowej kwantyzacji, model zużywa mniej pamięci VRAM, co pozwala na jego trenowanie nawet na sprzęcie o ograniczonych zasobach.
—
Konfiguracja LoRA z Unsloth
Aby zoptymalizować proces fine-tuningu, użyjemy techniki LoRA (Low-Rank Adaptation):
python
model = FastLanguageModel.get_peft_model(
model,
r = 16,
target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
"gate_proj", "up_proj", "down_proj"],
lora_alpha = 16,
lora_dropout = 0,
bias = "none",
use_gradient_checkpointing = "unsloth",
random_state = 3407,
use_rslora = False,
loftq_config = None,
max_seq_length = max_seq_length
)
Technika LoRA pozwala na efektywne dostrajanie modelu poprzez modyfikowanie tylko wybranych warstw, co znacząco zmniejsza wymagania sprzętowe i przyspiesza proces trenowania.
—
Montowanie Google Drive (opcjonalnie)
Jeśli korzystasz z Google Colab, warto zamontować dysk Google Drive, aby zapisywać tam wyniki trenowania:
python
from google.colab import drive
drive.mount("/content/drive")
Dzięki temu model i jego parametry zostaną zapisane na Twoim koncie Google Drive, co ułatwi ich późniejsze wykorzystanie.
—
Konfiguracja pętli trenowania
Następnie konfigurujemy proces trenowania modelu:
python
trainer = SFTTrainer(
model = model,
train_dataset = dataset,
dataset_text_field = "text",
max_seq_length = max_seq_length,
tokenizer = tokenizer,
args = TrainingArguments(
per_device_train_batch_size = 2,
gradient_accumulation_steps = 4,
warmup_steps = 10,
max_steps = 60,
learning_rate = 2e-4,
fp16 = not torch.cuda.is_bf16_supported(),
bf16 = torch.cuda.is_bf16_supported(),
logging_steps = 1,
optim = "adamw_8bit",
weight_decay = 0.01,
lr_scheduler_type = "linear",
seed = 3407,
output_dir = "/content/drive/My Drive/Llama-3.2-3B-Instruct-bnb-4bit"
),
)
trainer.train()
W konfiguracji TrainingArguments określiliśmy m.in.:
– Batch size wynoszący 2 na jedno urządzenie,
– Liczbę kroków akumulacji gradientów ustawioną na 4, co pozwala efektywnie wykorzystać pamięć GPU,
– Maksymalną liczbę kroków treningowych ustawioną na 60,
– Współczynnik uczenia (learning rate) na poziomie 0.0002,
– Typ optymalizatora: AdamW w wersji 8-bitowej, co zmniejsza zużycie pamięci.
Po skonfigurowaniu wartości hiperparametrów uruchamiamy proces trenowania poprzez wywołanie trainer.train().
—
Zapisywanie wytrenowanego modelu
Po zakończeniu procesu trenowania warto zapisać dostrojony model, aby można było go później wykorzystać:
python
model.save_pretrained("lora_model")
tokenizer.save_pretrained("lora_model")
Model oraz tokenizer zostaną zapisane w lokalnym katalogu lora_model, skąd można je później załadować bez konieczności ponownego trenowania.
—
Podsumowanie
W tym przewodniku krok po kroku omówiliśmy proces fine-tuningu modelu Llama 3.2 3B Instruct do zadań związanych z analizą kodu w języku Python. Korzystając z biblioteki Unsloth, zastosowaliśmy technikę LoRA oraz 4-bitową kwantyzację, co pozwoliło na znaczną redukcję zużycia pamięci oraz optymalizację procesu trenowania. Wykorzystaliśmy również narzędzia Hugging Face do zarządzania zbiorami danych i konfiguracji trenowania.
Dzięki temu przewodnikowi możesz dostosować duże modele językowe do własnych potrzeb, tworząc efektywne rozwiązania w zakresie generowania i analizy kodu.
