【初心者向け】かんたんなファインチューニングをする方法！学習データの作り方からgoogle colabやローカル環境でする方法まで

pip install transformers datasets torch accelerate peft bitsandbytes evaluate

{
    "prompt": "",
    "response": ""
}

 ]
  {
    "prompt": "元気がないけどどうしたの？",
    "response": "お腹空いたよ〜"
  },
  {
    "prompt": "お腹空いたよ",
    "response": "それなら早くご飯にしようよ！"
  },
  {
    "prompt": "授業まだまだ続くからめんどくさいよ",
    "response": "頑張って！終わったら遊ぼう！"
  },
〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜〜
  {
    "prompt": "1+1は何？",
    "response": "２だね！"
  },
  {
    "prompt": "NATってなに？",
    "response": "えーっとね、NATは、パブリックIPアドレスとプライベートIPアドレスを変換する技術のことだよ！"
  },
  {
    "prompt": "しりとりしようよ！",
    "response": "いいよ！しりとりのりからね！"
  }
]

import os
import json
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer, Trainer, TrainingArguments, get_linear_schedule_with_warmup
from datasets import Dataset
from peft import LoraConfig, get_peft_model
from torch.optim import AdamW
import evaluate
import numpy as np

# デバイスの確認
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using device: {device}")

# モデルとトークナイザーのロード (bitsandbytesで量子化、オフロード有効化)
model_name = "rinna/japanese-gpt-neox-3.6b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_8bit=True,
    device_map="auto",
    llm_int8_enable_fp32_cpu_offload=True
)

# LoRAの設定
lora_config = LoraConfig(
    r=8,
    lora_alpha=32,
    target_modules=["query_key_value"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# 学習データのロード
data_file = "data.json"
if not os.path.exists(data_file):
    raise FileNotFoundError(f"{data_file} が見つかりません。同じディレクトリに配置してください。")

try:
    with open(data_file, "r", encoding="utf-8") as f:
        raw_data = json.load(f)
        for entry in raw_data:
            if not ("prompt" in entry and "response" in entry):
                raise ValueError("Invalid data format: 'prompt' and 'response' keys are required.")
except json.JSONDecodeError:
    raise ValueError("Invalid JSON format.")

# データセットの整形
def format_data(entry):
    return {"text": f"{entry['prompt']}\n{entry['response']}"}

formatted_data = [format_data(entry) for entry in raw_data]

# データセットを作成 (labelsの追加と修正)
def preprocess_function(examples):
    inputs = tokenizer(examples["text"], truncation=True, padding="max_length", max_length=512)
    inputs["labels"] = inputs["input_ids"].copy()

    new_labels = []
    for label in inputs["labels"]:
        if isinstance(label, int):
            label = [label]
        new_label = [(l if l != tokenizer.pad_token_id else -100) for l in label]
        new_labels.append(new_label)
    inputs["labels"] = new_labels
    return inputs

dataset = Dataset.from_list(formatted_data)
dataset = dataset.map(preprocess_function, batch_size=32, num_proc=os.cpu_count())
dataset = dataset.train_test_split(test_size=0.1)

# 評価指標の設定
metric = evaluate.load("rouge")

def compute_metrics(eval_pred):
    predictions, labels = eval_pred
    decoded_preds = tokenizer.batch_decode(predictions, skip_special_tokens=True)
    decoded_labels = tokenizer.batch_decode(labels, skip_special_tokens=True)
    result = metric.compute(predictions=decoded_preds, references=decoded_labels, use_stemmer=True)
    result = {key: value.mid.fmeasure * 100 for key, value in result.items()}
    prediction_lens = [np.count_nonzero(pred != tokenizer.pad_token_id) for pred in predictions]
    result["gen_len"] = np.mean(prediction_lens)
    return {k: v for k, v in result.items()}

# 学習パラメータの設定
output_dir = "./output"
os.makedirs(output_dir, exist_ok=True)

training_args = TrainingArguments(
    output_dir=output_dir,
    overwrite_output_dir=True,
    num_train_epochs=3,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=8,
    save_steps=500,
    evaluation_strategy="steps",
    eval_steps=500,
    logging_steps=100,
    learning_rate=3e-4,
    fp16=True,
    save_total_limit=2,
    load_best_model_at_end=True,
    metric_for_best_model="rougeL",
    report_to="tensorboard"
)

# オプティマイザーとスケジューラーの設定
optimizer = AdamW(model.parameters(), lr=training_args.learning_rate)
num_training_steps = len(dataset["train"]) * training_args.num_train_epochs // (
    training_args.per_device_train_batch_size * training_args.gradient_accumulation_steps)
warmup_steps = int(num_training_steps * 0.1)
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps=warmup_steps, num_training_steps=num_training_steps)

# Trainerの作成
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    eval_dataset=dataset["test"],
    tokenizer=tokenizer,
    optimizers=(optimizer, scheduler),
    compute_metrics=compute_metrics
)

# ファインチューニングの実行
trainer.train()

# モデルの保存
model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)

print(f"Fine-tuning complete! Model saved to {output_dir}")

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import os
import tempfile

model_name = "./model" #colabで作成した場合は　model_name = "./LLM"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name).to("cuda")

text = "「今日のご飯、何食べたい？」という会話文へのの返信は："
inputs = tokenizer(text, return_tensors="pt").to("cuda")

outputs = model.generate(**inputs, max_new_tokens=100)  # max_new_tokensで生成するトークン数を制御
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)