メインコンテンツへスキップ
見出し画像

自分の記事1000件250万文字データをなんとか活用しつつKaggleでLlama-3.1-Swallow-8B-Instruct をLoRAトレーニングする。

    ※中途半端に手順書のようですが、ほぼ、自分用のメモです。

    1.学習データの抽出。

    note記事のエクスポート分(記事一覧画面にそういう機能があります)を元に、とりあえず学習データを抽出します。

    画像

    スクレイピングだとペイウォールがあって面倒ですが、自分の記事エクスポートならペイウォールは関係ないので楽です。

    よく考えてみれば、1000件もある長文で構成された良質(?)なデータセットなのに、活用しないのはもったいなかったですね。

    参考までに、以下のようなPythonスクリプトでいい感じにチャンクしたjsonlを生成します。xmlファイルと同じディレクトリに置いて実行します。

    (少なくともUnslothなしではKaggleのT4*2環境では5000字だとどう頑張ってもOOMしてしまい、3000字ほどが限界でした。なので分割していますが、そもそもそんなに長文を書かない方には不要な工程です。URLなどは消すようにしていますが、定型文などが含まれていると学習のノイズになるため、私の記事用にカスタムしています。各々自分なりにカスタムしてください。エクスポートデータが複数ある場合は同じディレクトリに置いて実行。500文字未満の記事は短すぎて学習に不適切な気がしたので排除しています。)

    import xml.etree.ElementTree as ET
    import re
    import json
    from bs4 import BeautifulSoup
    import glob
    from datetime import datetime
    
    def clean_content(html_content):
        if not html_content: return ""
        cutoff_keywords = ["こんな記事もオススメ!", "オススメ記事", "関連記事"]
        for kw in cutoff_keywords:
            if kw in html_content:
                html_content = html_content.split(kw)[0]
    
        soup = BeautifulSoup(html_content, 'html.parser')
        
        # 文体維持(太字・改行)
        for tag in soup.find_all(['strong', 'b']):
            tag.replace_with(f"**{tag.get_text()}**")
        for br in soup.find_all('br'):
            br.replace_with('\n')
        for tag in soup.find_all(['p', 'div', 'h1', 'h2', 'h3', 'h4']):
            tag.append('\n')
        
        text = soup.get_text()
        text = re.sub(r'https?://[\w/:%#\$&\?\(\)~\.=\+\-]+', '', text)
        
        closing_patterns = [
            r"最後までお読みいただきありがとうございます.*",
            r"スキ/フォローお待ちしてます.*",
            r"あなたにいいことがありますように!.*"
        ]
        for pattern in closing_patterns:
            text = re.sub(pattern, "", text, flags=re.DOTALL | re.MULTILINE)
        
        text = re.sub(r'#\S+', '', text)
        text = re.sub(r'\n{3,}', '\n\n', text).strip()
        return text
    
    def split_text(text, limit=5000):
        """テキストを指定文字数付近の句点や改行で分割する"""
        chunks = []
        while len(text) > limit:
            # limit付近の直近の句点または改行を探す
            pos = -1
            for sep in ['\n\n', '\n', '。']:
                found = text.rfind(sep, 0, limit)
                if found > pos:
                    pos = found
            
            if pos == -1: # 区切りが見つからない場合は強制切断
                pos = limit
                
            chunks.append(text[:pos + len(sep)].strip())
            text = text[pos + len(sep):].strip()
        
        if text:
            chunks.append(text)
        return chunks
    
    def convert_to_sorted_jsonl(output_file):
        xml_files = glob.glob("*.xml")
        if not xml_files:
            print("エラー: XMLファイルが見つかりません。")
            return
    
        namespaces = {'content': 'http://purl.org/rss/1.0/modules/content/', 'wp': 'http://wordpress.org/export/1.2/'}
        all_posts = []
        
        for xml_file in xml_files:
            print(f"解析中: {xml_file}...")
            tree = ET.parse(xml_file)
            root = tree.getroot()
            
            for item in root.findall('.//item'):
                post_type = item.find('wp:post_type', namespaces).text
                status = item.find('wp:status', namespaces).text
                # 投稿日時を取得
                post_date = item.find('wp:post_date', namespaces).text 
                
                if post_type == 'post' and status == 'publish':
                    content_encoded = item.find('content:encoded', namespaces)
                    if content_encoded is not None and content_encoded.text:
                        content = clean_content(content_encoded.text)
                        if len(content) > 500: # 極端に短いものは除外
                            all_posts.append({
                                "date": post_date,
                                "text": content
                            })
    
        # 新しい順にソート
        all_posts.sort(key=lambda x: x['date'], reverse=True)
    
        with open(output_file, 'w', encoding='utf-8') as f:
            for post in all_posts:
                chunks = split_text(post['text'])
                for i, chunk in enumerate(chunks):
                    # 最後のチャンクかどうかを判定
                    is_end = (i == len(chunks) - 1)
                    data = {
                        "text": chunk,
                        "is_end": is_end
                    }
                    f.write(json.dumps(data, ensure_ascii=False) + '\n')
                
        print(f"--- 完了 ---")
        print(f"全 {len(all_posts)} 記事をチャンク分割して保存しました。")
        print(f"保存先: {output_file}")
    
    # --- 実行 ---
    convert_to_sorted_jsonl('my_note_style_data.jsonl')

    エクスポートされたxmlファイルと同じディレクトリでこれを実行します。

    以下のような出力になる筈です。

    処理中: note-yeku-1.xml...
    -> 247件 抽出完了
    処理中: note-yeku-2.xml...
    -> 790件 抽出完了
    --- すべての処理が完了しました ---
    総抽出記事数: 1037 件
    保存先: my_note_style_data.jsonl
    
    同じディレクトリにアウトプットされるこれが学習データになります。

    my_note_style_data.jsonl

    2.モデルの準備


    使用するモデルです。
    日本語強化型モデルのこれを使います。
    tokyotech-llm/Llama-3.1-Swallow-8B-Instruct-v0.5

    ライセンスはLlamaとGemmaに依存するモデルです。InstructにGemmaの回答を利用したらしく、素面だと何度聞いても「私はGemmaです」と名乗るのが玉に瑕です。

    Hugging Faceのトークンを確認

    Hugging Faceの Settings > Access Tokens を開き、Read 権限のトークンがまだ無ければ作成する。

    Kaggleに「鍵」を登録

    Kaggle Notebookのメニューにある Add-ons > Secrets をクリック。
    Label に HF_TOKEN、Value に 先ほどのトークン を貼り付けて保存。

    画像
    ここです。

    SettingsでGPU T4を使うように指定します(GPUによってコードを変える必要がある場合もある)。またモデルをダウンロードしたり依存関係ライブラリをダウンロードするのでインターネットも必須です。

    画像


    Kaggle Notebookというのは、色々便利な、だいたい無料でGPU環境を使えるGoogleのサービスです。Google Colabの類似システムです。Google Colabは長時間のGPU占有制限がKaggleよりも厳しいので学習の時はこっちを使っています。

    画像
    KaggleはGoogleに買収されていて、結局Googleのサービスであるような気がします。

    「データセット」というものを作り、先ほど抽出した学習データを登録してください。「my_note_style_data」という名前にしましょう。

    画像

    3.学習

    ノートを作り、右側のパネルから、先ほど登録した学習データを登録してください。こうすることで初めてマシン内で使えます。

    画像

    そして、セルにコードを打っていきます。

    適当にフェーズごとに分けて入れてください。

    (Kaggle自体は見ればわかると思うので細かい使い方までは解説しませんが Google Colabと同じ設計で、セルにコードが入力出来てノートに切り貼りするように仮想マシンでコードを実行できます。最初使った時はナンダコレと思っていましたが、「この仕組みによって実装の再現性が保てるのだ」とAIに言われて「理屈は分かるけど気持ち悪い」という気持ちになりました。)

    大体、こんな感じにしましょう。

    セル①環境構成

    # 標準の学習環境を構築します
    !pip install --no-cache-dir "torch==2.5.0" "torchvision==0.20.0" --index-url https://download.pytorch.org/whl/cu124 --quiet
    !pip install --no-cache-dir "transformers==4.46.1" "datasets" "trl" "accelerate" "peft" "bitsandbytes" --quiet
    
    print("--- INSTALL DONE ---")
    # 実行完了後、メニューの「Run」→「Restart & clear cell outputs」を行ってください。

    Kaggleの仕様で一度ライブラリ関係を更新した後にメニューから「Run -> Restart & clear cell outputs」を実行しないと環境に適用されないようです。面倒ですがインストールが終わったら一度「Run -> Restart & clear cell outputs」を押して最初からやり直す。

    最初はUnsloth(高速でメモリ消費削減)を使っていましたが、なんか動かないので諦めて戻しました。あのナマケモノのアスキーアート表示でエラーも無く固まってしまうと苛立ちがマックスになり、「ナマケモノがッ!」と吐き捨てたくなります。いいんです別に。KaggleでもLoRAだけなら数時間で終わりますしUnslothはいらない。

    セル②ログイン

    # ② Hugging Face ログイン
    from kaggle_secrets import UserSecretsClient
    from huggingface_hub import login
    import os
    
    user_secrets = UserSecretsClient()
    hf_token = user_secrets.get_secret("HF_TOKEN")
    login(token=hf_token)
    os.environ["HF_TOKEN"] = hf_token
    print("--- [セル2] ログイン完了 ---")

    なんだかこの環境だとライブラリのアレがアレでエラーが出るので無理やり上書きしました。

    import transformers.integrations.bitsandbytes
    
    # 中身を完全に空(常にTrueを返すだけ)にします
    def bypass_all(*args, **kwargs):
        return True
    
    ransformers.integrations.bitsandbytes.validate_bnb_backend_availability = bypass_all
    transformers.integrations.bitsandbytes._validate_bnb_multi_backend_availability = bypass_all

    セル③ ここでモデルのダウンロード 祈る

    # ③-1 モデルの読み込み
    import torch
    from transformers import AutoModelForCausalLM, BitsAndBytesConfig
    
    model_id = "tokyotech-llm/Llama-3.1-Swallow-8B-Instruct-v0.5"
    
    bnb_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_quant_type="nf4",
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_use_double_quant=True,
    )
    
    model = AutoModelForCausalLM.from_pretrained(
        model_id,
        quantization_config=bnb_config,
        device_map="auto",
        token=hf_token
    )
    print("--- [セル3-1] モデル本体のロード完了 ---")
    画像
    # ③-2 トークナイザーの設定
    from transformers import AutoTokenizer
    
    tokenizer = AutoTokenizer.from_pretrained(model_id, token=hf_token)
    tokenizer.pad_token = tokenizer.eos_token
    print("--- [セル3-2] トークナイザーの準備完了 ---")
    # ③-3 LoRAと学習効率化の設定
    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
    
    # 学習前の準備
    model = prepare_model_for_kbit_training(model)
    
    lora_config = LoraConfig(
        r=32,
        lora_alpha=32,
        target_modules=["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.gradient_checkpointing_enable() 
    print("--- [セル3-3] すべての準備が完了しました ---")

    セル④ LoRA設定

    from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
    
    # 学習前の準備
    model = prepare_model_for_kbit_training(model)
    
    lora_config = LoraConfig(
        r=32,
        lora_alpha=32,
        target_modules=["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.gradient_checkpointing_enable() # 以前のコードにあった設定
    print("--- [セル3-3] すべての準備が完了しました ---")

    セル⑤ トレーニングデータの設定

    # ④ データのロードとEOS処理
    import json
    from datasets import Dataset
    
    dataset_path = '/kaggle/input/my-note-style/my_note_all_data.jsonl' 
    
    all_chunks = []
    processedposts = 0
    max_posts = 200 # 最新200記事分を使用※データ量によって変えてください
    
    with open(dataset_path, 'r', encoding='utf-8') as f:
        for line in f:
            item = json.loads(line)
            text_content = item['text']
            
            # is_endフラグがTrue(記事の末尾)ならEOSを付与
            if item.get('is_end', False):
                text_content += tokenizer.eos_token
                processed_posts += 1
            
            full_text = text_content
            
            tokens = tokenizer(full_text, truncation=True, max_length=5000)
            input_ids = tokens["input_ids"]
                            
            labels = list(input_ids)
            
            all_chunks.append({
                "input_ids": input_ids,
                "attention_mask": tokens["attention_mask"],
                "labels": labels
            })
            
            if processed_posts >= max_posts:
                break
    
    tokenized_dataset = Dataset.from_list(all_chunks)
    print(f"--- [セル4] ロード完了: {processed_posts}記事 / {len(tokenized_dataset)}チャンク ---")

    ※ここではあえてInstractionなどのタグを外して記事データそのものを学習させています。こうするとベースモデルの重み自体を書き変えるような振舞になり、モデル自体の性格が自分の記事のようになりますが、逆にベースモデルの元の正確性を維持できない確率も高まります。なのでそういう用途ではなく、自分のような文体で記事だけ書かせたい時はInstractionを指定した上で、「Instraction:〇〇というタイトルで記事を執筆して」→「output:記事本体データ」という感じで学習させるのがオススメです。

    タグはベースモデルによって変わりますが、どうすればよいかというのは適当なフロンティアAIにこのメモとモデル名、ソースを読ませれば調節してくれると思います。

    また、あえて記事の順序をシャッフルせず古い→新しい順に並べていますが、これは新しいデータの方が結果に強く残りやすいことを考えて、人格的な変遷として学習させやすいかな? と思ったためです。私の記事はテーマがバラバラでもともと多様ですし。同じテーマで書き続けている方はシャッフルした方が良いかもしれません。用途とバランスによります。

    セル⑥ トレーニング

    # ⑤ 学習の実行(チェックポイント保存あり)
    from transformers import TrainingArguments, Trainer, DataCollatorForLanguageModeling
    
    # --- 設定値 ---
    target_epochs = 3.0              # 何周させたいか(今回はバランス重視の3周)
    grad_accum_steps = 4             # 1ステップあたりの累積(4ならログが出やすい)
    num_chunks = len(tokenized_dataset)        # チャンク数を取得
    
    # ステップ数の自動計算
    # 計算式: (チャンク数 / 1回で消費する数) * 希望周回数
    calculated_steps = int((num_chunks / grad_accum_steps) * target_epochs)
    
    print(f"--- 学習構成 ---")
    print(f"総チャンク数: {num_chunks}")
    print(f"累積ステップ: {grad_accum_steps}")
    print(f"目標周回数  : {target_epochs}周")
    print(f"算出ステップ: {calculated_steps} steps")
    
    training_args = TrainingArguments(
        output_dir="outputs",
        per_device_train_batch_size=1,
        gradient_accumulation_steps=grad_accum_steps,
        max_steps=calculated_steps,                 
        learning_rate=2e-5,
        lr_scheduler_type="cosine",
        warmup_steps=10,
        fp16=True,
        optim="paged_adamw_8bit",
        logging_steps=1,               # ログ表示
        save_steps=20,                 # 20歩(約15分)ごとに自動保存
        save_total_limit=2,            # 最新2つだけ保存(容量対策)
        report_to="none",
        remove_unused_columns=False,
    )
    
    trainer = Trainer(
        model=model,
        train_dataset=tokenized_dataset,
        args=training_args,
        data_collator=DataCollatorForLanguageModeling(tokenizer, mlm=False),
    )
    
    # チェックポイントがあれば再開
    checkpoint_dir = "outputs"
    resume = True if os.path.exists(checkpoint_dir) and os.listdir(checkpoint_dir) else False
    
    print(f"学習を開始します(再開: {resume})...")
    trainer.train(resume_from_checkpoint=resume)
    
    # 最後にアダプタを保存
    model.save_pretrained("final_adapter")
    import shutil
    shutil.make_archive("final_adapter", 'zip', "final_adapter")
    print("--- [セル5] すべての学習工程が完了しました ---")

    ※この設定のエポック3はちょっと高すぎたかもしれません。2~3くらいが過学習にならない無難な値だと思います。様子を見て結果に応じて変えていくのもオススメです。warmup_steps=10は大体総ステップ数の10%くらいで始めるのがオススメです。learning_rate=2e-5は結果が過学習気味になるならもう少し下げてください。

    ここでトレーニング開始。

    画像
    うまくいけばこうなる。これを見るために血の涙をのみながら朝日を迎える
    Training Lossは典型的に最初は高くてあとで低くなってくるなら良い兆候です。
    でも、1を切るほど低すぎるのも過学習の兆候で良くない。
    それにしても5.0は高いな

    1000件の記事データを読み込ませたケースでも、2~3時間で学習は終わります。Notebookのエディタ画面から実行すると放置でセッションが切れてしまうので、右上のSave Versionからバックグラウンド実行して寝るのがオススメです。

    終わればこのようにアダプタがダウンロードできるので、これをダウンロードしてくっつけるか別のKaggleNotebookでマージしてモデルをダウンロードしましょう。

    画像
    アウトプットディレクトリが20GBしかないのでモデルマージを一緒にやると、容量不足で落ちます…途中で落ちてもOutputに書き出すところまで終わっていれば救出は可能です。

    しかし…祈ってください。

    トレーニング開始できるまでが大変で、大体失敗します。依存関係エラーとかで。今この瞬間同じコードを貼り付ければ動くはずですが、時間が経ってKaggle自体の環境が変わったら、もう何も保障できません。毎回なんでこんなに大変なのかと思いながら調整しています。時間もかかるし、しんどいです。

    この苦しさは、まるで昔のLinuxの構築作業している時みたいです。何回やってもうまくコンパイルできなくて依存関係チェックして…。魔法の手順書が出来たと思ったらライブラリのアップデートで地獄を見る…。ネットを調べてもろくな情報もない。ライブラリ自体のソースコードを読む羽目に…あの地獄。

    でも、これを避けるために誰にでもできるようにとnotebookの共有機能があるんですよね。

    それなのに、なぜか一からやって地獄を見ている私。なんだか自分で試行錯誤するよりも、他人が作ったものの使い方の説明書を読む方がしんどいんですよね。人の試行錯誤の結果を読むのはなぜか最後の手段(どうしようもなくなった時)に限られます。

    効率は悪いのですが、人の成果物を読んでいる間に新奇性が失われ、やる気を失うのだと思います。やる気を保つのが一番大変なこと。


    苦労してトレーニングにこぎつけたモデルに関しても、結局8回ほど試行錯誤してようやくなんとなく思っていたようなアダプタに近いものが作れました。

    モデルの学習結果は学習データの質と設定、GPUに拠りますので、やってみなければ予測が難しいし、やってみても因果の推測が難しい上に試行錯誤に時間がかかる。

    これは本当にエンジニアリングなのでしょうか?
    錬金術師が鍋で薬を煮込むような作業です。みんなが自分独自の秘伝のタレを作っています。

    アダプタ層のトレーニングですら大変です。半年、1年とかけてモデルを作るAIプロバイダは、もう自分たちの秘伝のタレから逸脱したくないでしょうね。なんでうまく動いているのか、自分でもよく分からないでしょうし。開発フェーズが進めば進む程、スケールの難易度も上がっているはずです。それが少し感じられるような今回の試行錯誤でした。

     
     
    本アカ(YeKu)ではちょっと専門的すぎるメモやタイムラインに載せたくない説明記事などをこちらに投稿します。 ※倉庫的なアカウントなので、フォロー非推奨です。