Qwen 3.5 파인튜닝 실전 가이드 — LoRA로 나만의 모델 만들기

pip install torch transformers accelerate
pip install peft trl datasets
pip install bitsandbytes  # QLoRA 양자화용

pip install unsloth

[
  {
    "messages": [
      {"role": "system", "content": "You are a helpful medical assistant."},
      {"role": "user", "content": "두통이 3일째 계속됩니다. 어떻게 해야 하나요?"},
      {"role": "assistant", "content": "3일 이상 지속되는 두통은 여러 원인이 있을 수 있습니다..."}
    ]
  },
  {
    "messages": [
      {"role": "user", "content": "혈압약을 먹고 있는데 자몽을 먹어도 되나요?"},
      {"role": "assistant", "content": "자몽은 일부 혈압약과 상호작용할 수 있습니다..."}
    ]
  }
]

from datasets import load_dataset

# JSON 파일에서 로드
dataset = load_dataset("json", data_files="train_data.json", split="train")

# 또는 HuggingFace Hub에서 로드
# dataset = load_dataset("your-username/your-dataset", split="train")

# 학습/검증 분할
split = dataset.train_test_split(test_size=0.1, seed=42)
train_dataset = split["train"]
eval_dataset = split["test"]

print(f"Train: {len(train_dataset)}, Eval: {len(eval_dataset)}")

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig

model_name = "Qwen/Qwen3.5-9B"

# 4bit 양자화 설정 (QLoRA)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto",
    attn_implementation="flash_attention_2",  # 속도 향상
)

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=16,                      # LoRA rank (8~64, 높을수록 품질↑ VRAM↑)
    lora_alpha=32,             # 보통 rank의 2배
    target_modules=[           # Qwen 3.5 어텐션 모듈
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# 출력 예: trainable params: 26M || all params: 9.0B || trainable%: 0.29%

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./qwen35-finetuned",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,   # 실질 배치 사이즈 = 2 × 4 = 8
    learning_rate=2e-4,
    weight_decay=0.01,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine",
    logging_steps=10,
    save_strategy="epoch",
    eval_strategy="epoch",
    bf16=True,
    max_seq_length=2048,
    gradient_checkpointing=True,     # VRAM 절약
    report_to="none",
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    processing_class=tokenizer,
)

trainer.train()

# LoRA 어댑터만 저장 (수십 MB)
trainer.save_model("./qwen35-finetuned/final")
tokenizer.save_pretrained("./qwen35-finetuned/final")

# 전체 모델로 병합 저장 (선택)
from peft import PeftModel

merged_model = model.merge_and_unload()
merged_model.save_pretrained("./qwen35-finetuned/merged")
tokenizer.save_pretrained("./qwen35-finetuned/merged")

from unsloth import FastLanguageModel

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="Qwen/Qwen3.5-9B",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    lora_alpha=32,
    target_modules=[
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    lora_dropout=0.05,
)

from peft import PeftModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

# 베이스 모델 + LoRA 어댑터 로드
base_model = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen3.5-9B",
    torch_dtype=torch.bfloat16,
    device_map="auto",
)
model = PeftModel.from_pretrained(base_model, "./qwen35-finetuned/final")
tokenizer = AutoTokenizer.from_pretrained("./qwen35-finetuned/final")

# 테스트
messages = [
    {"role": "user", "content": "파인튜닝 데이터에 맞는 질문을 입력하세요"}
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

outputs = model.generate(**inputs, max_new_tokens=512, temperature=0.7, do_sample=True)
response = tokenizer.decode(outputs[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True)
print(response)

def compare_models(question, base_model, finetuned_model, tokenizer):
    messages = [{"role": "user", "content": question}]
    text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    inputs = tokenizer(text, return_tensors="pt").to(base_model.device)

    # 베이스 모델 답변
    base_out = base_model.generate(**inputs, max_new_tokens=256, temperature=0.7, do_sample=True)
    base_response = tokenizer.decode(base_out[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True)

    # 파인튜닝 모델 답변
    ft_out = finetuned_model.generate(**inputs, max_new_tokens=256, temperature=0.7, do_sample=True)
    ft_response = tokenizer.decode(ft_out[0][inputs.input_ids.shape[-1]:], skip_special_tokens=True)

    print("=== Base Model ===")
    print(base_response)
    print("\n=== Fine-tuned Model ===")
    print(ft_response)

# llama.cpp 설치 (이전 편 참조)
cd llama.cpp

# 모델 변환
python convert_hf_to_gguf.py ./qwen35-finetuned/merged \
  --outfile qwen35-finetuned-q4_k_m.gguf \
  --outtype q4_k_m

# Modelfile 작성
cat > Modelfile << 'EOF'
FROM ./qwen35-finetuned-q4_k_m.gguf

TEMPLATE """{{- if .System }}<|im_start|>system
{{ .System }}<|im_end|>
{{ end }}<|im_start|>user
{{ .Prompt }}<|im_end|>
<|im_start|>assistant
"""

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER stop "<|im_end|>"
EOF

# Ollama에 등록
ollama create my-qwen35 -f Modelfile

# 실행
ollama run my-qwen35