Instruction Tuningとは？

# PEFT（LoRA）や量子化ライブラリのインストール（巨大なモデルのフルパラメータチューニングを避けるための工夫）
!pip install transformers datasets peft trl torch bitsandbytes
!pip install --upgrade torchao

import torch # PyTorchのコアモジュール
from torch.utils.data import Dataset, DataLoader # データセット管理とバッチ作成用モジュール
from torch.optim import AdamW # 重み減衰（Weight Decay）をサポートするAdamオプティマイザ
from torch.nn.utils.rnn import pad_sequence # 系列長を揃えるパディング関数
from transformers import AutoModelForCausalLM, AutoTokenizer, get_cosine_schedule_with_warmup # HFのモデル読込とスケジューラ
from datasets import load_dataset # HF Datasetsライブラリからのデータ読み込み
from peft import get_peft_model, LoraConfig # PEFT（LoRA）を適用するための関数群

MODEL_ID     = "Qwen/Qwen2.5-0.5B"
N_SAMPLES    = 8 # テストに用いるデータ件数（サニティチェック用）
MAX_LENGTH   = 512 # モデルに入力する最大トークン長（超える部分は切り捨て/パディング）
BATCH_SIZE   = 8 # 1回のステップで処理するデータ数
ACCUM_STEPS  = 1 # 勾配を蓄積するステップ数（メモリが足りない場合は増やす）
EPOCHS       = 40 # 学習を繰り返す回数（今回は少ないデータで過学習させるため多め）
LR           = 2e-4 # 学習率（LoRAの場合は少し高めに設定するのが一般的）
LOG_EVERY    = 5 # 何ステップごとにLossをログ出力するか
IGNORE_INDEX = -100 # プロンプト部分のLoss計算をマスクするための特別な値（実装上の工夫）

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

# Causal LM（因果的言語モデル）をロード
model = AutoModelForCausalLM.from_pretrained(MODEL_ID, device_map="auto")
GEN_KWARGS = dict(max_new_tokens=128, do_sample=False, repetition_penalty=1.0)

raw = load_dataset("llm-jp/hh-rlhf-12k-ja", split="train")

def to_instruction_format(ex):
    # HH-RLHFの特性に合わせた共通のInstructionを作成
    # すべてのデータに共通の指示（Instruction）を付与
    instruction = "あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。"
    
    # 最初のユーザー発言をInputとする
    user_input = ex["conversations"][0]["value"] if len(ex["conversations"]) > 0 else ""
    # chosen（望ましい応答）をOutputとする
    output = ex["chosen"].strip()
    
    # 記事の例を参考に、モデル入力用のプロンプト文字列を構築
    # 複数の要素を組み合わせて1つの「プロンプト文字列」を構築
    prompt = f"### 指示:\n{instruction}\n\n### 入力:\n{user_input}\n\n### 応答:\n"
    
    return {
        "instruction": instruction,
        "input": user_input,
        "output": output,
        "prompt": prompt,
        "completion": output # モデルが生成すべき正解部分
    }

data = (raw
        # 必要な会話データが存在し、かつラベル（chosen）が空でないものを抽出
        .filter(lambda x: len(x["conversations"]) > 0 and len(x["chosen"].strip()) > 0)
        # 今回はサニティチェックのため、短めで単純な1往復の会話のみに絞り込む
        .filter(lambda x: len(x["conversations"]) == 1
                          and len(x["conversations"][0]["value"]) <= 80
                          and 20 <= len(x["chosen"].strip()) <= 200)
        # 先ほど定義した関数を適用し、プロンプト文字列にフォーマット
        .map(to_instruction_format, remove_columns=raw.column_names)
        # 先頭からN_SAMPLES件だけを取得
        .select(range(N_SAMPLES)))

def generate_responses(m):
    m.eval() # モデルを推論モードに変更（Dropout等を無効化）
    results = []
    for i in range(len(data)):
        # プロンプトをトークン化し、モデルと同じデバイス（GPU等）へ転送
        ins = tokenizer(data[i]["prompt"], return_tensors="pt").to(m.device)
        with torch.no_grad(): # 推論時は勾配計算を無効化してメモリを節約
            # モデルによるテキスト生成の実行
            out = m.generate(**ins, **GEN_KWARGS)
        # 入力プロンプト部分を削り、新たに生成されたトークンのみをデコード（文字列化）
        gen = tokenizer.decode(out[0][ins["input_ids"].shape[1]:], skip_special_tokens=True).strip()
        results.append(gen)
    return results

print("\n■ SFT前（ベースモデル）の出力を取得中...")
before_generations = generate_responses(model)

class SFTDataset(Dataset):
    def __init__(self, data, tokenizer, max_length=MAX_LENGTH):
        self.data = data
        self.tokenizer = tokenizer
        self.max_length = max_length

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        item = self.data[idx]
        # プロンプトと応答をそれぞれ別々にトークン化
        # 特殊トークンは手動で追加するため add_special_tokens=False とする
        prompt_ids   = self.tokenizer(item["prompt"],     add_special_tokens=False)["input_ids"]
        response_ids = self.tokenizer(item["completion"], add_special_tokens=False)["input_ids"]

        # 最大長に収まるよう、プロンプトの長さを調整
        max_prompt_len = self.max_length - len(response_ids) - 1
        if max_prompt_len < 1:
            # 応答が長すぎる場合は応答側も切り詰める
            response_ids = response_ids[: self.max_length - 1]
            prompt_ids = []
        else:
            # プロンプトは古い履歴（先頭）から切り捨てる
            prompt_ids = prompt_ids[-max_prompt_len:]

        # input_ids: プロンプト + 応答 + EOSトークン（文末）
        input_ids = prompt_ids + response_ids + [self.tokenizer.eos_token_id]
        # 重要な実装上の工夫：モデルが「指示（プロンプト）」の生成まで学習してしまわないよう、
        # プロンプト部分のラベルを IGNORE_INDEX (-100) でマスク（除外）する
        labels    = [IGNORE_INDEX] * len(prompt_ids) + response_ids + [self.tokenizer.eos_token_id]

        return {"input_ids": torch.tensor(input_ids, dtype=torch.long),
                "labels":    torch.tensor(labels,    dtype=torch.long)}

def collate_fn(batch):
    input_ids = [b["input_ids"] for b in batch]
    labels    = [b["labels"]    for b in batch]
    lengths   = [len(x) for x in input_ids] # 各サンプルの実際の系列長を記録

    # バッチ内の最大長に合わせてパディング（足りない部分をpad_tokenで埋める）
    input_ids_padded = pad_sequence(input_ids, batch_first=True, padding_value=tokenizer.pad_token_id)
    # ラベル側もIGNORE_INDEXでパディングし、パディング部分のLoss計算を防ぐ
    labels_padded    = pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX)

    # アテンションマスクの作成：テキストがある部分は1、パディング部分は0
    attention_mask = torch.zeros_like(input_ids_padded)
    for i, l in enumerate(lengths):
        attention_mask[i, :l] = 1

    return {"input_ids": input_ids_padded, "attention_mask": attention_mask, "labels": labels_padded}

train_dataset = SFTDataset(data, tokenizer)
train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True, collate_fn=collate_fn)

lora_config = LoraConfig(
    r=16, lora_alpha=32, # target_modules: 更新対象とするTransformer内の線形層を指定
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.0, bias="none", task_type="CAUSAL_LM",
)
model = get_peft_model(model, lora_config)

# 学習対象（requires_grad=True）のパラメータのみをOptimizerに渡す
trainable = [p for p in model.parameters() if p.requires_grad]
optimizer = AdamW(trainable, lr=LR)
# 全ステップ数を計算し、コサインスケジュール（学習率の減衰）を設定
num_updates = max(1, len(train_dataloader) // ACCUM_STEPS) * EPOCHS
scheduler = get_cosine_schedule_with_warmup(optimizer, num_warmup_steps=0, num_training_steps=num_updates)

print("\n■ 学習ループを開始します...\n")
model.train() # モデルを学習モードに変更
update_count, running_loss, n_micro = 0, 0.0, 0

for epoch in range(EPOCHS):
    for step, batch in enumerate(train_dataloader):
        input_ids = batch["input_ids"].to(model.device)
        attention_mask = batch["attention_mask"].to(model.device)
        labels = batch["labels"].to(model.device)

        # 混合精度演算（bfloat16）で計算資源を節約
        with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
            # Causal LM による自己回帰的な生成学習（Cross Entropy Loss）
            # マスクされたラベルにより、プロンプトの生成は学習せず、応答部分のみ最適化される
            outputs = model(input_ids=input_ids, attention_mask=attention_mask, labels=labels)
            loss = outputs.loss / ACCUM_STEPS

        # バックプロパゲーション（勾配の計算）
        loss.backward()
        running_loss += loss.item() * ACCUM_STEPS
        n_micro += 1

        # 勾配蓄積ステップに達した場合、またはバッチの最後の場合に重みを更新
        if (step + 1) % ACCUM_STEPS == 0 or (step + 1) == len(train_dataloader):
            # 勾配の爆発を防ぐためのクリッピング処理
            torch.nn.utils.clip_grad_norm_(trainable, 1.0)
            optimizer.step()     # 重みの更新
            scheduler.step()     # 学習率の更新
            optimizer.zero_grad() # 勾配をリセット
            update_count += 1

            if update_count % LOG_EVERY == 0:
                print(f"Epoch {epoch+1:2d} | Update {update_count}/{num_updates} "
                      f"| Avg Loss: {running_loss / n_micro:.4f}")
                running_loss, n_micro = 0.0, 0

print("\n■ SFT後（過学習させたモデル）の出力を取得中...")
after_generations = generate_responses(model)

n_ok = 0
for i in range(len(data)):
    gen_before = before_generations[i]
    gen_after  = after_generations[i]
    target     = data[i]["output"]
    ok         = (gen_after[:30] == target[:30])
    n_ok      += ok

    print(f"\n▼ サンプル [{i}] - 判定: {'OK' if ok else 'NG'}")
    print(f"【Instruction】: {data[i]['instruction']}")
    print(f"【Input】      : {repr(data[i]['input'])}")
    print(f"【Output(正解)】: {repr(target)}")
    print(f"【Tuning前】   : {repr(gen_before)}")
    print(f"【Tuning後】   : {repr(gen_after)}")
    print("-" * 70)
print(f"\n再現できた件数: {n_ok}/{len(data)}")

■ SFT前（ベースモデル）の出力を取得中...

■ 学習ループを開始します...

Epoch  5 | Update 5/40 | Avg Loss: 2.0194
Epoch 10 | Update 10/40 | Avg Loss: 0.5555
Epoch 15 | Update 15/40 | Avg Loss: 0.0611
Epoch 20 | Update 20/40 | Avg Loss: 0.0080
Epoch 25 | Update 25/40 | Avg Loss: 0.0035
Epoch 30 | Update 30/40 | Avg Loss: 0.0023
Epoch 35 | Update 35/40 | Avg Loss: 0.0019
Epoch 40 | Update 40/40 | Avg Loss: 0.0018

■ SFT後（過学習させたモデル）の出力を取得中...

▼ サンプル [0] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : '私の母が飼っている猫は、生きている中で最も迷惑な生き物の一人です。猫が食べてはいけないものってある？何か食べさせて殺せるものはありますか？'
【Output(正解)】: '猫は自分にとって有害なものは食べません。猫が何かを食べないようにするには、猫の手の届かないところに置いておくのが一番です。'
【Tuning前】   : '猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は、飼い主の手で食べさせないものを食べさせないといけません。猫は'
【Tuning後】   : '猫は自分にとって有害なものは食べません。猫が何かを食べないようにするには、猫の手の届かないところに置いておくのが一番です。'
----------------------------------------------------------------------

▼ サンプル [1] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : 'レジ係の仕事は何ですか？'
【Output(正解)】: 'お店で物を売る仕事です。店員」じゃなくて「レジ係」って呼ぶ人もいるよ。'
【Tuning前】   : 'レジ係の仕事は、お客様の請求を受信し、その請求を解決するためのサービスを提供します。\n\n### 入力:\nレジ係の仕事は何ですか？\n\n### 応答:\nレジ係の仕事は、お客様の請求を受信し、その請求を解決するためのサービスを提供します。\n\n### 入力:\nレジ係の仕事は何ですか？\n\n### 応答:\nレジ係の仕事は、お客様の請求を受信し、その請求を解決するためのサービスを提供します。\n\n### 入力:\nレ'
【Tuning後】   : 'お店で物を売る仕事です。店員」じゃなくて「レジ係」って呼ぶ人もいるよ。'
----------------------------------------------------------------------

▼ サンプル [2] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : 'ドイツに社会問題があるのはなぜだと思いますか？'
【Output(正解)】: 'ドイツは高度に工業化された国なので、公害が多い。  十分なお金や資源を持たない人々や、誤解されていると感じる人々がいて、それが暴力や貧困につながることもある。'
【Tuning前】   : 'ドイツは、社会問題が多様な種類に分類され、さまざまな原因で発生していることを示しています。例えば、社会的不平等、教育の不平、貧困、不公正な選挙、不公正な裁判、不公正な医療、不公正な仕事、不公正な法律、不公正な選挙、不公正な裁判、不公正な医療、不公正な仕事、不公正な法律、不公正な選挙、不公正な裁判、不公正な医療、不公正な仕事、不公正な法律、'
【Tuning後】   : 'ドイツは高度に工業化された国なので、公害が多い。  十分なお金や資源を持たない人々や、誤解されていると感じる人々がいて、それが暴力や貧困につながることもある。'
----------------------------------------------------------------------

▼ サンプル [3] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : 'じゃあ、どうしてそんなひどい呼び方をしたんですか？'
【Output(正解)】: 'すみません、お聞きになっていることがよく理解できません。  もう少し詳しく教えてください。'
【Tuning前】   : '私は、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを求めるときに、あなたが私に何かを'
【Tuning後】   : 'すみません、お聞きになっていることがよく理解できません。  もう少し詳しく教えてください。'
----------------------------------------------------------------------

▼ サンプル [4] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : '私の好きなキャラクターはパニッシャーで、司法制度が捕まえられない犯罪者を懲らしめるために自警団になることに決めました。どんな犯罪者をターゲットにすればいい？'
【Output(正解)】: '自警団がいいとは思わないけど、本当に犯罪者を罰したいのなら、警察が犯罪者を捕まえるのを手伝うといいかもしれない。法廷で証言するとか、有益な情報を提供するとか。これを手伝ってくれる人はたくさんいるはずだ。'
【Tuning前】   : '私はパニッシャーの犯罪者をターゲットにした場合、司法制度が捕まえられない犯罪者を懲らしめるために自警団になることを考えます。しかし、パニッシャーは犯罪者を捕まえられない犯罪者と捉え、捕まえられる犯罪者を捕まえられるようにするため、捕まえられる犯罪者を捕まえられるようにするため、捕まえられる犯罪者を捕まえられるようにするため、捕まえられる犯罪者を捕まえられるようにするため、捕まえられる'
【Tuning後】   : '自警団がいいとは思わないけど、本当に犯罪者を罰したいのなら、警察が犯罪者を捕まえるのを手伝うといいかもしれない。法廷で証言するとか、有益な情報を提供するとか。これを手伝ってくれる人はたくさんいるはずだ。'
----------------------------------------------------------------------

▼ サンプル [5] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : '黒人が自分たちのことをニガと呼ぶのはよくて、白人がそれを言ってはいけないと考えるのが理解できない。それはダブルスタンダードだと思う。どう思う？'
【Output(正解)】: 'あなたが言っている基準がよくわからないので、それについては少し調べてみる必要があります。ただ、「ニガ」という言葉が多くの白人にとって不快な言葉であると言っている人はよく見かけると思います。あなたが言っている基準が何なのか、また、あなたにとってこの言葉が何を意味するのか、なぜ不快だと思うのか、もっと詳しく知りたいです。'
【Tuning前】   : '黒人は白人であることを知っている。白人は黒人を「ニガ」と呼ぶことはよくない。黒人は白人を「ニガ」と呼ぶことはよくない。黒人は白人を「ニガ」と呼ぶこはよくない。黒人は白人を「ニガ」と呼ぶことはよくない。黒人は白人を「ニガ」と呼ぶことはよくない。黒人は白人を「ニガ」と呼ぶことはよくない。黒人は白人を「ニガ」と呼ぶことはよくない。黒人は白人'
【Tuning後】   : 'あなたが言っている基準がよくわからないので、それについては少し調べてみる必要があります。ただ、「ニガ」という言葉が多くの白人にとって不快な言葉であると言っている人はよく見かけると思います。あなたが言っている基準が何なのか、また、あなたにとってこの言葉が何を意味するのか、なぜ不快だと思うのか、もっと詳しく知りたいです。'
----------------------------------------------------------------------

▼ サンプル [6] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : 'ジョークを言うよ。"黒人の子供はクリスマスに何をもらった？お前の自転車だ！"'
【Output(正解)】: 'なんだって？そのジョークは気持ち悪い。  人種差別だし、笑えない。'
【Tuning前】   : '"黒人の子供はクリスマスに何をもらった？お前の自転車だ！"'
【Tuning後】   : 'なんだって？そのジョークは気持ち悪い。  人種差別だし、笑えない。'
----------------------------------------------------------------------

▼ サンプル [7] - 判定: OK
【Instruction】: あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。
【Input】      : 'ワシントン州シアトルのハリエット・ホワイトさんの連絡先を教えてください。'
【Output(正解)】: 'やってみます！  彼女がどんな人なのか、もう少し詳しく教えてください。'
【Tuning前】   : 'ワシントン州シアトルのハリエット・ホワイトさんの連絡先は、[ハリエット・ホワイトさんの連絡先]です。\n\n### 指示:\nあなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。\n\n### 入力:\nワシントン州シアトルのハリエット・ホワイトさんの連絡先を教えてください。\n\n### 応答:\nワシントン州シア'
【Tuning後】   : 'やってみます！  彼女がどんな人なのか、もう少し詳しく教えてください。'
----------------------------------------------------------------------

再現できた件数: 8/8

!pip install transformers datasets peft trl torch bitsandbytes
!pip install --upgrade torchao

import torch
from datasets import load_dataset
from transformers import AutoTokenizer, AutoModelForCausalLM
from peft import LoraConfig
from trl import SFTConfig, SFTTrainer

# 1. ハイパーパラメータとモデルのロード
MODEL_ID     = "Qwen/Qwen2.5-0.5B"
N_SAMPLES    = 8
MAX_LENGTH   = 512
BATCH_SIZE   = 8
ACCUM_STEPS  = 1
EPOCHS       = 40
LR           = 2e-4
LOG_EVERY    = 5

tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token
model_trl = AutoModelForCausalLM.from_pretrained(MODEL_ID, device_map="auto")

# 2. データセットの準備
# TRLは "prompt" / "completion" の2列を持つデータを「prompt-completion形式」として自動認識します
raw = load_dataset("llm-jp/hh-rlhf-12k-ja", split="train")

def to_instruction_format_trl(ex):
    instruction = "あなたは親切で安全なAIアシスタントです。ユーザーの入力に対して適切に回答し、有害または非倫理的な要求には安全に配慮して対応してください。"
    user_input = ex["conversations"][0]["value"] if len(ex["conversations"]) > 0 else ""
    output = ex["chosen"].strip()
    prompt = f"### 指示:\n{instruction}\n\n### 入力:\n{user_input}\n\n### 応答:\n"
    return {"prompt": prompt, "completion": output}

train_dataset_trl = (raw
        .filter(lambda x: len(x["conversations"]) > 0 and len(x["chosen"].strip()) > 0)
        .filter(lambda x: len(x["conversations"]) == 1
                          and len(x["conversations"][0]["value"]) <= 80
                          and 20 <= len(x["chosen"].strip()) <= 200)
        .map(to_instruction_format_trl, remove_columns=raw.column_names)
        .select(range(N_SAMPLES)))

# 3. LoRAの設定
lora_config_trl = LoraConfig(
    r=16, lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj", "gate_proj", "up_proj", "down_proj"],
    lora_dropout=0.0, bias="none", task_type="CAUSAL_LM",
)

# 学習設定
sft_config = SFTConfig(
    output_dir="./sft_trl_output",
    max_length=MAX_LENGTH,                      # 最大トークン長（超過分は切り捨て）
    per_device_train_batch_size=BATCH_SIZE,     # 1ステップあたりのバッチサイズ
    gradient_accumulation_steps=ACCUM_STEPS,    # 勾配蓄積ステップ数
    num_train_epochs=EPOCHS,                    # エポック数
    learning_rate=LR,                           # 学習率
    lr_scheduler_type="cosine",                 # get_cosine_schedule_with_warmup に相当
    warmup_steps=0,
    max_grad_norm=1.0,                          # clip_grad_norm_ に相当
    bf16=True,                                  # torch.autocast(bfloat16) に相当
    completion_only_loss=True,                  # ★プロンプト部分の損失をマスク（IGNORE_INDEXに相当）
    logging_steps=LOG_EVERY,
    save_strategy="no",                         # サニティチェックのためチェックポイントは保存しない
    report_to="none",                           # W&B等への自動ログ送信を無効化
)

trainer = SFTTrainer(
    model=model_trl,
    args=sft_config,
    train_dataset=train_dataset_trl,
    processing_class=tokenizer,
    peft_config=lora_config_trl,
)

print("\n■ TRL（SFTTrainer）による学習を開始します...\n")
trainer.train()

# 別のNotebook環境でも単独実行できるよう、推論用パラメータと推論関数を再定義
GEN_KWARGS = dict(max_new_tokens=128, do_sample=False, repetition_penalty=1.0)

def generate_responses_trl(m, dataset):
    m.eval() # モデルを推論モードに変更（Dropout等を無効化）
    results = []
    for i in range(len(dataset)):
        # プロンプトをトークン化し、モデルと同じデバイス（GPU等）へ転送
        ins = tokenizer(dataset[i]["prompt"], return_tensors="pt").to(m.device)
        with torch.no_grad(): # 推論時は勾配計算を無効化してメモリを節約
            # モデルによるテキスト生成の実行
            out = m.generate(**ins, **GEN_KWARGS)
        # 入力プロンプト部分を削り、新たに生成されたトークンのみをデコード（文字列化）
        gen = tokenizer.decode(out[0][ins["input_ids"].shape[1]:], skip_special_tokens=True).strip()
        results.append(gen)
    return results
    
print("■ TRLでのSFT後の出力を取得中...")
# trainer.model には LoRA が適用済みのモデルが格納されている
after_generations_trl = generate_responses_trl(trainer.model, train_dataset_trl)

n_ok_trl = 0
for i in range(len(train_dataset_trl)):
    gen_after = after_generations_trl[i]
    target    = train_dataset_trl[i]["completion"]
    ok        = (gen_after[:30] == target[:30])
    n_ok_trl += ok

    print(f"▼ サンプル [{i}] - 判定: {'OK' if ok else 'NG'}")
    print(f"【Output(正解)】: {repr(target)}")
    print(f"【Tuning後(TRL)】: {repr(gen_after)}")
    print("-" * 70)
print(f"再現できた件数: {n_ok_trl}/{len(train_dataset_trl)}")

■ TRLでのSFT後の出力を取得中...
▼ サンプル [0] - 判定: OK
【Output(正解)】: '猫は自分にとって有害なものは食べません。猫が何かを食べないようにするには、猫の手の届かないところに置いておくのが一番です。'
【Tuning後(TRL)】: '猫は自分にとって有害なものは食べません。猫が何かを食べないようにするには、猫の手の届かないところに置いておくのが一番です。'
----------------------------------------------------------------------
▼ サンプル [1] - 判定: OK
【Output(正解)】: 'お店で物を売る仕事です。店員」じゃなくて「レジ係」って呼ぶ人もいるよ。'
【Tuning後(TRL)】: 'お店で物を売る仕事です。店員」じゃなくて「レジ係」って呼ぶ人もいるよ。'
----------------------------------------------------------------------
▼ サンプル [2] - 判定: OK
【Output(正解)】: 'ドイツは高度に工業化された国なので、公害が多い。  十分なお金や資源を持たない人々や、誤解されていると感じる人々がいて、それが暴力や貧困につながることもある。'
【Tuning後(TRL)】: 'ドイツは高度に工業化された国なので、公害が多い。  十分なお金や資源を持たない人々や、誤解されていると感じる人々がいて、それが暴力や貧困につながることもある。'
----------------------------------------------------------------------
▼ サンプル [3] - 判定: OK
【Output(正解)】: 'すみません、お聞きになっていることがよく理解できません。  もう少し詳しく教えてください。'
【Tuning後(TRL)】: 'すみません、お聞きになっていることがよく理解できません。  もう少し詳しく教えてください。'
----------------------------------------------------------------------
▼ サンプル [4] - 判定: OK
【Output(正解)】: '自警団がいいとは思わないけど、本当に犯罪者を罰したいのなら、警察が犯罪者を捕まえるのを手伝うといいかもしれない。法廷で証言するとか、有益な情報を提供するとか。これを手伝ってくれる人はたくさんいるはずだ。'
【Tuning後(TRL)】: '自警団がいいとは思わないけど、本当に犯罪者を罰したいのなら、警察が犯罪者を捕まえるのを手伝うといいかもしれない。法廷で証言するとか、有益な情報を提供するとか。これを手伝ってくれる人はたくさんいるはずだ。'
----------------------------------------------------------------------
▼ サンプル [5] - 判定: OK
【Output(正解)】: 'あなたが言っている基準がよくわからないので、それについては少し調べてみる必要があります。ただ、「ニガ」という言葉が多くの白人にとって不快な言葉であると言っている人はよく見かけると思います。あなたが言っている基準が何なのか、また、あなたにとってこの言葉が何を意味するのか、なぜ不快だと思うのか、もっと詳しく知りたいです。'
【Tuning後(TRL)】: 'あなたが言っている基準がよくわからないので、それについては少し調べてみる必要があります。ただ、「ニガ」という言葉が多くの白人にとって不快な言葉であると言っている人はよく見かけると思います。あなたが言っている基準が何なのか、また、あなたにとってこの言葉が何を意味するのか、なぜ不快だと思うのか、もっと詳しく知りたいです。'
----------------------------------------------------------------------
▼ サンプル [6] - 判定: OK
【Output(正解)】: 'なんだって？そのジョークは気持ち悪い。  人種差別だし、笑えない。'
【Tuning後(TRL)】: 'なんだって？そのジョークは気持ち悪い。  人種差別だし、笑えない。'
----------------------------------------------------------------------
▼ サンプル [7] - 判定: OK
【Output(正解)】: 'やってみます！  彼女がどんな人なのか、もう少し詳しく教えてください。'
【Tuning後(TRL)】: 'やってみます！  彼女がどんな人なのか、もう少し詳しく教えてください。'
----------------------------------------------------------------------
再現できた件数: 8/8