미세조정

pip install unsloth

import unsloth

print('Unsloth', unsloth.__version__)

Unsloth 2026.5.4

from unsloth import FastLanguageModel

model_name = 'unsloth/Qwen3-4B-unsloth-bnb-4bit'
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name, max_seq_length=2048, dtype=None, load_in_4bit=True)

==((====))==  Unsloth 2026.5.4: Fast Qwen3 patching. Transformers: 5.5.0.
   \\   /|    NVIDIA GeForce RTX 3090. Num GPUs = 1. Max memory: 23.999 GB. Platform: Linux.
O^O/ \_/ \    Torch: 2.10.0+cu128. CUDA: 8.6. CUDA Toolkit: 12.8. Triton: 3.6.0
\        /    Bfloat16 = TRUE. FA [Xformers = 0.0.35. FA2 = False]
 "-____-"     Free license: http://github.com/unslothai/unsloth
unsloth/Qwen3-4B-unsloth-bnb-4bit does not have a padding token! Will use pad_token = <|PAD_TOKEN|>.

model = FastLanguageModel.get_peft_model(
    model,
    r = 8, # 클수록 성능이 증가하지만, 메모리 사용량도 증가합니다.
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                  "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 8, # rank와 동일하거나 두 배 값을 권장합니다.
    lora_dropout = 0, # 대체로 0 권장
    bias = "none",    # 임의 값 가능하지만, "none" 권장
    use_gradient_checkpointing = "unsloth", # "unsloth" 권장. True/False도 가능
    random_state = 2025, # 재현성을 위해 난수 초기값 (0 이상 정수)
)

Unsloth 2026.5.4 patched 36 layers with 36 QKV layers, 36 O layers and 36 MLP layers.

from datasets import load_dataset

dataset = load_dataset('mlabonne/FineTome-100k', split='train')

sample = dataset[0]
for key, value in sample.items():
    print(f'{key}: {value}\n')

conversations: [{'from': 'human', 'value': 'Explain what boolean operators are, ... across different programming languages.'}, {'from': 'gpt', 'value': 'Boolean operators are logical operators used in programming ... regardless of the language's truthiness and falsiness rules.'}]

source: infini-instruct-top-500k

score: 5.212620735168457

from unsloth.chat_templates import standardize_data_formats

dataset = standardize_data_formats(dataset)

sample = dataset[0]
for turn in sample['conversations']:
    print(f"{turn['role']}: {turn['content']}\n")

user: Explain what boolean operators are, what they do, and provide examples of how they can be used in programming. ... write code that handles cases where truthiness and falsiness are implemented differently across different programming languages.

assistant: Boolean operators are logical operators used in programming to manipulate boolean values. ... This ensures that the result is always a boolean value, regardless of the language's truthiness and falsiness rules.

from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(tokenizer, chat_template='qwen-3')

def formatting_prompts_func(examples):
    texts = [
        tokenizer.apply_chat_template(
            conversation, tokenize=False, add_generation_prompt=False)
        for conversation in examples['conversations']
    ]
    return {'text': texts}

train_dataset = dataset.map(formatting_prompts_func, batched=True)

print(train_dataset[0]['text'])

<|im_start|>user
Explain what boolean operators are, what they do, and provide examples of how they can be used in programming. ... implemented differently across different programming languages.<|im_end|>
<|im_start|>assistant
<think>

</think>

Boolean operators are logical operators used in programming to manipulate boolean values. ... regardless of the language's truthiness and falsiness rules.<|im_end|>

from trl import SFTConfig, SFTTrainer

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = train_dataset,
    args = SFTConfig(
        dataset_text_field = "text",
        max_seq_length = 2048,
        packing = False, # 짧은 시퀀스에서 학습을 최대 5배 빠르게 합니다.
        per_device_train_batch_size = 2,
        gradient_accumulation_steps = 4,
        warmup_steps = 5,
        max_steps = 60,
        num_train_epochs = 1,
        learning_rate = 2e-4,
        logging_steps = 1,
        optim = "adamw_8bit",
        weight_decay = 0.01,
        lr_scheduler_type = "linear",
        seed = 3407,
        output_dir = "qwen3-finetuned",
        report_to = "none", # WandB 등으로 보내려면 변경합니다.
    ),
)

from unsloth.chat_templates import train_on_responses_only

trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|im_start|>user\n",
    response_part = "<|im_start|>assistant\n",
)

Unsloth: Removed 11 out of 100000 samples from train_dataset where all labels were -100 (no response found after truncation). This prevents NaN loss during training.

sudo apt update
sudo apt install -y build-essential

import torch

gpu_stats = torch.cuda.get_device_properties(0)
start_gpu_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
max_memory = round(gpu_stats.total_memory / 1024 / 1024 / 1024, 3)
print(f"GPU = {gpu_stats.name}. Max memory = {max_memory} GB.")
print(f"{start_gpu_memory} GB of memory reserved.")

GPU = NVIDIA GeForce RTX 3090. Max memory = 23.999 GB.
3.449 GB of memory reserved.

trainer_stats = trainer.train()

==((====))==  Unsloth - 2x faster free finetuning | Num GPUs used = 1
   \\   /|    Num examples = 99,989 | Num Epochs = 1 | Total steps = 60
O^O/ \_/ \    Batch size per device = 2 | Gradient accumulation steps = 4
\        /    Data Parallel GPUs = 1 | Total batch size (2 x 4 x 1) = 8
 "-____-"     Trainable parameters = 16,515,072 of 4,038,983,168 (0.41% trained)
{'loss': 1.1, 'grad_norm': 0.5406, 'learning_rate': 0.0, 'epoch': 0.0001}
{'loss': 0.9904, 'grad_norm': 0.4712, 'learning_rate': 4e-05, 'epoch': 0.0002}
{'loss': 1.117, 'grad_norm': 0.5819, 'learning_rate': 8e-05, 'epoch': 0.0002}
...
{'loss': 0.6233, 'grad_norm': 0.1532, 'learning_rate': 7.273e-06, 'epoch': 0.0047}
{'loss': 0.5512, 'grad_norm': 0.131, 'learning_rate': 3.636e-06, 'epoch': 0.0048}
{'train_runtime': 466.8, 'train_loss': 0.7907, 'epoch': 0.0048}

import torch

used_memory = round(torch.cuda.max_memory_reserved() / 1024 / 1024 / 1024, 3)
used_memory_for_lora = round(used_memory - start_gpu_memory, 3)
used_percentage = round(used_memory / max_memory * 100, 3)
lora_percentage = round(used_memory_for_lora / max_memory * 100, 3)
print(f"{trainer_stats.metrics['train_runtime']} seconds used for training.")
print(
    f"{round(trainer_stats.metrics['train_runtime']/60, 2)} minutes used for training."
)
print(f"Peak reserved memory = {used_memory} GB.")
print(f"Peak reserved memory for training = {used_memory_for_lora} GB.")
print(f"Peak reserved memory % of max memory = {used_percentage} %.")
print(f"Peak reserved memory for training % of max memory = {lora_percentage} %.")

466.8338 seconds used for training.
7.78 minutes used for training.
Peak reserved memory = 6.068 GB.
Peak reserved memory for training = 2.619 GB.
Peak reserved memory % of max memory = 25.284 %.
Peak reserved memory for training % of max memory = 10.913 %.

model_path = "qwen3-lora-finetuned"
model.save_pretrained(model_path)
tokenizer.save_pretrained(model_path)

from pathlib import Path
from unsloth import FastLanguageModel

model_path = Path("qwen3-lora-finetuned")
if model_path.exists():
    model_path = str(model_path)
    print(f"모델 불러오기: {model_path}")
    model, tokenizer = FastLanguageModel.from_pretrained(
        model_path, max_seq_length=2048, dtype=None, load_in_4bit=True)
    FastLanguageModel.for_inference(model) # 2배 빠른 추론 속도

FastLanguageModel.for_inference(model)
messages = [
    {
        "role": "user",
        "content": "Continue the fibonacci sequence: 1, 1, 2, 3, 5, 8,"
    },
]
input_ids = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt = True,
    return_tensors = "pt",
).to("cuda")

from transformers import TextStreamer

text_streamer = TextStreamer(tokenizer, skip_prompt=True)
_ = model.generate(
    input_ids, streamer=text_streamer, max_new_tokens=128, pad_token_id=tokenizer.eos_token_id)

<think>

</think>

The next numbers in the Fibonacci sequence are 13, 21, 34, 55, 89, 144, 233, and so on. The Fibonacci sequence is a series of numbers where each number is the sum of the two preceding numbers. The sequence starts with 1 and 1, and each subsequent number is the sum of the two previous numbers.<|im_end|>

FastLanguageModel.for_inference(model) # Enable native 2x faster inference
messages = [
    {"role": "user",      "content": "Continue the fibonacci sequence: 1, 1, 2, 3, 5, 8"},
    {"role": "assistant", "content": "The fibonacci sequence continues as 13, 21, 34, 55 and 89."},
    {"role": "user",      "content": "What is France's tallest tower called?"},
]
input_ids = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt = True,
    return_tensors = "pt",
).to("cuda")

from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer, skip_prompt = True)
_ = model.generate(input_ids, streamer=text_streamer, max_new_tokens=128, pad_token_id=tokenizer.eos_token_id)