llm-jp-3-13b-finetune

実行手順

以下の手順に従うことで、Hugging Face上のモデル(https://huggingface.co/ryuhki2003/llm-jp-3-13b-finetune)　を用いて入力データ(elyza-tasks-100-TV_0.jsonl)　を推論し、その結果を{adapter_id}-outputs.jsonlというファイルに出力できます。

実行に必要な条件

• Python環境があること（例: Google Colab　またはVSコード）

• Hugging Faceのアクセストークン (HF_TOKEN) が取得済みであること

• 性能の良いGPU（GoogleColabを使う場合、Colab Proを用いているとなおよい)

セットアップ

必要なライブラリのインストールを行う。ただし、バージョンによって仕組みが異なる場合があるためバージョンに気を付ける。今回はバージョン3.10.12を用いた。

python 3.10.12

!pip install -U pip
!pip install -U transformers
!pip install -U bitsandbytes
!pip install -U accelerate
!pip install -U datasets
!pip install peft==0.12.0
!pip install trl==0.12.0
!pip install -U wandb
!pip install ipywidgets --upgrade

1. トランスフォーム導入をした。

　　　from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    TrainingArguments,
    logging,
)
from peft import (
    LoraConfig,
    PeftModel,
    get_peft_model,
)
import os, torch, gc
from datasets import load_dataset
import bitsandbytes as bnb
from trl import SFTTrainer

4.Hugging Faceのトークンを取得していることを確認した。以下はGoogle Colabで例としてuserdataを用いた例である。ただし、HF_TOKENに用いたキーは実行環境に合わせて適宜変更してほしい。

from google.colab import userdata
HF_TOKEN = userdata.get('HF_TOKEN')
# Hugging Face Token
HF_TOKEN = "userdata.get('HF_TOKEN')"

モデルの準備

# モデルを読み込み。
# llm-jp-3 1.8B, 3.7B, 13Bのsnapshotをダウンロード済みでmodelsディレクトリに格納してあります。
# base_model_idの値はomnicampusの環境におけるモデルのパスを表しており、それ以外の環境で実行する場合は変更の必要があります。
# その他のモデルは取得に承諾が必要なため、各自でダウンロードお願いします。
base_model_id = "models/models--llm-jp--llm-jp-3-13b/snapshots/cd3823f4c1fcbb0ad2e2af46036ab1b0ca13192a" #Fine-Tuningするベースモデル
# omnicampus以外の環境をご利用の方は以下をご利用ください。
# base_model_id = "llm-jp/llm-jp-3-13b"

new_model_id = "llm-jp-3-13b-finetune" #Fine-Tuningしたモデルにつけたい名前

"""
bnb_config: 量子化の設定

  - load_in_4bit:
      - 4bit量子化形式でモデルをロード

  - bnb_4bit_quant_type:
      - 量子化の形式を指定

  - bnb_4bit_compute_dtype:
      - 量子化された重みを用いて計算する際のデータ型

"""

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4", # nf4は通常のINT4より精度が高く、ニューラルネットワークの分布に最適です
    bnb_4bit_compute_dtype=torch.bfloat16,
)

"""
model: モデル

  - base_model:
      - 読み込むベースモデル (事前に定義したもの)

  - quantization_config:
      - bnb_configで設定した量子化設定

  - device_map:
      - モデルを割り当てるデバイス (CPU/GPU) "auto"で自動に割り当てられます。

tokenizer: トークナイザー

  - base_model:
      - 読み込むベースモデル (事前に定義したもの)

  - trust_remote_code:
      - リモートコードの実行を許可 (カスタムモデルなど)
"""
base_model_id = "llm-jp/llm-jp-3-13b"  # 正しいリポジトリ形式に修正
model = AutoModelForCausalLM.from_pretrained(
    base_model_id,
    quantization_config=bnb_config,
    device_map="auto"
)


tokenizer = AutoTokenizer.from_pretrained(base_model_id, trust_remote_code=True)

from google.colab import output
output.enable_custom_widget_manager()

from google.colab import output
output.disable_custom_widget_manager()

"""
find_all_linear_names: モデル内の4bit量子化線形層を探します。
"""

def find_all_linear_names(model):
    cls = bnb.nn.Linear4bit # 4bit量子化線形層クラスを指定
    lora_module_names = set() # ここに取得した線形層を保持します。

    # モデル内の全てのモジュールを探索します
    for name, module in model.named_modules():
        if isinstance(module, cls): # モジュールが4bit量子化線形層の場合
            names = name.split('.') # モジュールの名前を分割 (ネストされてる際などに対処)
            lora_module_names.add(names[0] if len(names) == 1 else names[-1]) # 最下層の名前をlora_module_namesに追加

    # 'lm_head' は16ビット演算の際に除外する必要があるため、lora_module_namesから削除
    if 'lm_head' in lora_module_names:
        lora_module_names.remove('lm_head')

    return list(lora_module_names) # lora_module_namesをリストに変換して返します。

modules = find_all_linear_names(model)

"""
peft_config: PEFTの構成設定

  - r
      - LoRA のランク (4, 8, 16 ,32...)
      - 増やすほど学習が捗るが, 過学習のリスクも高まるので注意

  - lora_alpha
      - LoRAのスケーリング係数

  - lora_dropout
      - ドロップアウト率（過学習を防ぐための割合）

  - bias
      - バイアス項の扱い ("none"の場合、LoRAはバイアスを学習しない)

  - task_type
      - タスクタイプ

  - target_modules
      - LoRAを適用するターゲットモジュール (前のコードで特定した層)
"""

peft_config = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
    target_modules=modules,
)

model = get_peft_model(model, peft_config)

ここで、Distribution20241221_allはextracted_dataの下に置いた。

import zipfile
import os

# ZIPファイルのパス
zip_file_path = "/content/Distribution20241221_all.zip"

# 解凍先のディレクトリ
extract_path = "/content/extracted_data"

# ZIPファイルを解凍
with zipfile.ZipFile(zip_file_path, 'r') as zip_ref:
    zip_ref.extractall(extract_path)

# 解凍後のファイル一覧を表示
print("解凍されたファイル:")
for root, dirs, files in os.walk(extract_path):
    print(f"ディレクトリ: {root}")
    print(f"ファイル: {files}")

from datasets import load_dataset
import os

# 解凍されたJSONファイルのパスを確認
json_file_path = "/content/extracted_data/Distribution20241221_all/ichikara-instruction-003-001-1.json"

# ファイルが存在するか確認
if os.path.exists(json_file_path):
    print(f"ファイルが見つかりました: {json_file_path}")
else:
    raise FileNotFoundError(f"指定したファイルが存在しません: {json_file_path}")

# JSONデータをロード
dataset = load_dataset("json", data_files=json_file_path)

# データセットの内容を確認
print("データセット内容:")
print(dataset)

import os

# 現在の作業ディレクトリを確認
print("現在の作業ディレクトリ:", os.getcwd())

# 親ディレクトリの内容を表示
print("親ディレクトリの内容:", os.listdir(".."))

file_path = os.path.abspath("./extracted_data/Distribution20241221_all/ichikara-instruction-003-001-1.json")
print("ファイルパス:", file_path)
print("ファイル存在:", os.path.exists(file_path))

import os

# 現在の作業ディレクトリを確認
print("現在の作業ディレクトリ:", os.getcwd())

# 親ディレクトリの内容を確認
print("親ディレクトリの内容:", os.listdir("./extracted_data/Distribution20241221_all"))

file_path = "/content/extracted_data/Distribution20241221_all/ichikara-instruction-003-001-1.json"
print("ファイル存在:", os.path.exists(file_path))

import os

# 修正済みの相対パス


file_path = os.path.abspath("./extracted_data/Distribution20241221_all/ichikara-instruction-003-001-1.json")
print("ファイルパス:", file_path)
print("ファイル存在:", os.path.exists(file_path))

# データセットの読み込み (ファイルが見つかった場合)
if os.path.exists(file_path):
    from datasets import load_dataset
    dataset = load_dataset("json", data_files=file_path)
    print(dataset)
else:
    print("指定したファイルが見つかりません。パスを確認してください。")

# 学習時のプロンプトフォーマットの定義
prompt = """### 指示
{}
### 回答
{}"""


"""
formatting_prompts_func: 各データをプロンプトに合わせた形式に合わせる
"""
EOS_TOKEN = tokenizer.eos_token # トークナイザーのEOSトークン（文末トークン）
def formatting_prompts_func(examples):
    input = examples["text"] # 入力データ
    output = examples["output"] # 出力データ
    text = prompt.format(input, output) + EOS_TOKEN # プロンプトの作成
    return { "formatted_text" : text, } # 新しいフィールド "formatted_text" を返す
pass

# # 各データにフォーマットを適用
dataset = dataset.map(
    formatting_prompts_func,
    num_proc= 4, # 並列処理数を指定
)

dataset

# データを確認
print(dataset["train"]["formatted_text"][3])

# データをtrainデータとtestデータに分割 (test_sizeの比率に)
# dataset = dataset["train"].train_test_split(test_size=0.1)
# dataset

"""
training_arguments: 学習の設定

  - output_dir:
      -トレーニング後のモデルを保存するディレクトリ

  - per_device_train_batch_size:
      - デバイスごとのトレーニングバッチサイズ

  - per_device_
  _batch_size:
      - デバイスごとの評価バッチサイズ

  - gradient_accumulation_steps:
      - 勾配を更新する前にステップを積み重ねる回数

  - optim:
      - オプティマイザの設定

  - num_train_epochs:
      - エポック数

  - eval_strategy:
      - 評価の戦略 ("no"/"steps"/"epoch")

  - eval_steps:
      - eval_strategyが"steps"のとき、評価を行うstep間隔

  - logging_strategy:
      - ログ記録の戦略

  - logging_steps:
      - ログを出力するステップ間隔

  - warmup_steps:
      - 学習率のウォームアップステップ数

  - save_steps:
      - モデルを保存するステップ間隔

  - save_total_limit:
      - 保存しておくcheckpointの数

  - max_steps:
      - トレーニングの最大ステップ数

  - learning_rate:
      - 学習率

  - fp16:
      - 16bit浮動小数点の使用設定（第8回演習を参考にすると良いです）

  - bf16:
      - BFloat16の使用設定

  - group_by_length:
      -  入力シーケンスの長さによりバッチをグループ化 (トレーニングの効率化)

  - report_to:
      - ログの送信先 ("wandb"/"tensorboard"など)
"""

training_arguments = TrainingArguments(
    output_dir=new_model_id,
    per_device_train_batch_size=1,
    gradient_accumulation_steps=2,
    optim="paged_adamw_32bit",
    num_train_epochs=1,
    logging_strategy="steps",
    logging_steps=10,
    warmup_steps=10,
    save_steps=100,
    save_total_limit = 2,
    max_steps = -1,
    learning_rate=5e-5,
    fp16=False,
    bf16=False,
    seed = 3407,
    group_by_length=True,
    report_to="none"
)

"""
SFTTrainer: Supervised Fine-Tuningに関する設定

  - model:
      - 読み込んだベースのモデル

  - train_dataset:
      - トレーニングに使用するデータセット

  - eval_dataset:
      - 評価に使用するデータセット

  - peft_config:

 - PEFT（Parameter-Efficient Fine-Tuning）の設定（LoRAを利用する場合に指定）

  - max_seq_length:
      - モデルに入力されるシーケンスの最大トークン長

  - dataset_text_field:
      - データセット内の学習に使うテキストを含むフィールド名

  - tokenizer:
      - モデルに対応するトークナイザー

  - args:
      - トレーニングに使用するハイパーパラメータ（TrainingArgumentsの設定を指定）

  - packing:
      - 入力シーケンスのパッキングを行うかどうかの設定 (False に設定することで、各入力を独立して扱う)
"""
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    peft_config=peft_config,
    max_seq_length= 512,
    dataset_text_field="formatted_text",
    tokenizer=tokenizer,
    args=training_arguments,
    packing= False,
)

model.config.use_cache = False # キャッシュ機能を無効化
trainer.train() # トレーニングを実行

import os

# 指定ディレクトリの中身を確認
target_dir = "./extracted_data/Distribution20241221_all"
print("ディレクトリの中身:", os.listdir(target_dir))

import json

# 正しいファイルパスを指定（スペースを含める）
file_path = "./extracted_data/elyza-tasks-100-TV_0 .jsonl"

# ファイルの存在確認
print("ファイル存在:", os.path.exists(file_path))

# ファイルを読み込む
datasets = []
with open(file_path, "r") as f:
    item = ""
    for line in f:
        line = line.strip()
        item += line
        if item.endswith("}"):  # JSONオブジェクトの終了
            datasets.append(json.loads(item))
            item = ""

print("読み込んだデータ:", datasets)

# モデルによるタスクの推論。
from tqdm import tqdm

results = []
for data in tqdm(datasets):

  input = data["input"]

  prompt = f"""### 指示
  {input}
  ### 回答
  """

  tokenized_input = tokenizer.encode(prompt, add_special_tokens=False, return_tensors="pt").to(model.device)
  attention_mask = torch.ones_like(tokenized_input)

  with torch.no_grad():
      outputs = model.generate(
          tokenized_input,
          attention_mask=attention_mask,
          max_new_tokens=100,
          do_sample=False,
          repetition_penalty=1.2,
          pad_token_id=tokenizer.eos_token_id
      )[0]
  output = tokenizer.decode(outputs[tokenized_input.size(1):], skip_special_tokens=True)

  results.append({"task_id": data["task_id"], "input": input, "output": output})

出力の保存

最後に、JSONL形式の出力ファイルを保存する。

import re
jsonl_id = re.sub(".*/", "", new_model_id)
with open(f"./{jsonl_id}-outputs.jsonl", 'w', encoding='utf-8') as f:
    for result in results:
        json.dump(result, f, ensure_ascii=False)  # ensure_ascii=False for handling non-ASCII characters
        f.write('\n')

以上の手順で、{adapter_id}-outputs.jsonlというファイルに推論結果が書き出される。

モデルとトークナイザーをアップロードする

from transformers import AutoTokenizer, AutoModelForCausalLM
HF_TOKEN = userdata.get('HF_TOKEN')
new_model_id = "llm-jp-3-13b-finetune"

# モデルとトークナイザーをアップロード
model.push_to_hub(new_model_id, token=HF_TOKEN, private=True)
tokenizer.push_to_hub(new_model_id, token=HF_TOKEN, private=True)