Google Colaboratoryで始めるLLMファインチューニング(5)：ファインチューニング実行

前回の記事の続きで、今回は自社の製品の情報を使用しデータセットを作成し、ファインチューニングをしていきたいと思います。使うモデルは、「Llama-3.1-8B-Instruct」を使います。

Google Colabの使い方やモデルをダウンロードする方法、動かす方法などについての記事も書いているので、これからやってみたい方はぜひ見てみてください。

Google Colabの使い方：

Hugging Faceモデルダウンロード：

Llama 3.1をColabで動かす方法：

ファインチューニング用のデータセット準備：

はじめに

これからファインチューニングをするにあたり、「Unsloth」というのを使ってLlamaをファインチューニングしてみたいと思います。通常、ファインチューニングするときはかなりの時間やメモリ不足、処理速度が遅いといった課題が出てきます。

この記事では、「Unsloth」を使用したLlama3.1のファインチューニングをする方法について解説します。

Unslothとは？

Unslothは、大規模言語モデル（LLM）のファインチューニングを高速かつメモリ効率良く行うためのPythonライブラリです。Hugging Faceの標準実装と比較して、学習速度が2～5倍速く、メモリ使用量も大幅に削減される（最大90%削減）という大きな特徴があります。

主な特徴とメリット

圧倒的な高速化：
内部実装を最適化したGPUカーネル （Tritonで実装）を使用することで、Hugging Faceの標準的なファインチューニングと比べて、学習速度を大幅に向上させています。事例によっては最大30倍の高速化が可能です。

メモリ効率の向上：
QLoRAやLoRAといった技術を使うと、GPUメモリ（VRAM）の使用量を最大90%も減らせます。そのため、これまで高性能GPUが必要だった大規模モデル （70Bモデルなど）でも、比較的安価なGPU（VRAM 30～40GB）でファインチューニングできるようになります。

精度の維持：
Unslothは、パフォーマンス向上のために数学的な最適化と効率的な実装を採用しており、モデルの訓練後の最終的な性能（精度）に悪影響を及ぼさないことを目的として設計されています。

使いやすさ：
Hugging Faceと互換性があるため、既存のHugging Faceユーザーは少しコードを変更するだけでUnslothを利用できます。Google Colabでの実行例も多く、簡単に試せます。

多様なモデルサポート：
Llama、Mixtral、Qwen、Gemmaなど、主要なオープンソースLLMをサポートしています。

このような特徴から、大きなモデルを手軽に素早く学習させたいというときに「Unsloth」は使えます。実際に「Unsloth」を使用してGoogle Colab上で使うための環境構築をしていきます。

Google Colabでの環境構築

最初に、Google Colab上でファインチューニングするための環境を整えます。

1. GPUランタイムの有効化

Google Colab を開いたら、「ランタイム」→「ランタイムのタイプを変更」をクリック。

「A100 GPU」を選択し、「ハイメモリ」をオンにして保存をクリック。次に、Unslothとファインチューニングに必要なライブラリをインストールします。

2. 必要ライブラリのインストール

unsloth, transformers, datasets, accelerate, peft, trl などのライブラリをインストールします。これは、大規模言語モデルのロード、ファインチューニング、データセット処理に必要なツールです。

!pip install unsloth transformers datasets accelerate trl bitsandbytes

上記コマンド実行：

• Unsloth
  大規模言語モデルのファインチューニングを高速化・効率化するためのライブラリ
• Transformers
  Hugging Face が提供する、様々な事前学習済みモデル（BERT, GPT-2, T5 など）や、それらを扱うためのツール（トークナイザー、モデルアーキテクチャなど）を提供するライブラリ
• Datasets
  これも Hugging Face が提供するライブラリで、多様なデータセットを簡単にダウンロード、ロード、処理するための機能を提供します。
• Accelerate
  Hugging Face のライブラリで、PyTorch などのディープラーニングフレームワークを使用した学習プロセスを、異なるハードウェア（CPU、GPU、TPU など）や分散環境で簡単に高速化するための機能。
• trl
  主に大規模言語モデル（LLM）の強化学習を用いたファインチューニングに使われるライブラリ。
• bitsandbytes
  モデルの量子化と最適化を行うためのライブラリです。

これらのライブラリをインストールすることで、大規模言語モデルのファインチューニングを行うための環境が整います。

3. Google Driveのマウント

Google Driveのマウントは、Google Colab上でGoogle Driveにアクセスするために行います。

from google.colab import drive
drive.mount('/content/drive')

これを実行すると認証が来るので許可してください。

4. 必要なライブラリのインポート

必要なライブラリのインポートは、Pythonでファインチューニングに必要な機能を使えるようにするために行います。

import json
import os
import glob
import random
import torch
from datasets import Dataset, DatasetDict
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments

print("✓ ライブラリのインポート完了")
print(f"✓ PyTorchバージョン: {torch.__version__}")
print(f"✓ CUDA利用可能: {torch.cuda.is_available()}")
if torch.cuda.is_available():
    print(f"✓ GPU名: {torch.cuda.get_device_name(0)}")
    print(f"✓ GPU VRAM: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")

5. 設定の定義

設定の定義は、ファインチューニングのパラメータを一箇所にまとめて、後で変更しやすくするために行います。

# モデル設定
BASE_MODEL = "unsloth/Meta-Llama-3.1-8B-Instruct"
MAX_SEQ_LENGTH = 2048
LOAD_IN_4BIT = False  # フルファインチューニング用にFalseに変更

# データ設定
DATASET_DIR = "ここにDatasetのPathを入力"
TRAIN_SPLIT = 0.9

# 訓練設定
OUTPUT_DIR = "./output_full_finetuning"
NUM_EPOCHS = 3
BATCH_SIZE = 1  # フルファインチューニングはメモリを多く使うため1に削減
GRADIENT_ACCUMULATION_STEPS = 8  # 実効バッチサイズを維持
LEARNING_RATE = 2e-5  # フルファインチューニングでは小さめの学習率
WARMUP_STEPS = 10

# ログ・保存設定
LOGGING_STEPS = 10
SAVE_STEPS = 100

print("✓ 設定完了（フルファインチューニングモード）")
print(f"  ベースモデル: {BASE_MODEL}")
print(f"  データセット: {DATASET_DIR}")
print(f"  出力先: {OUTPUT_DIR}")
print(f"  ⚠️ フルファインチューニング: すべてのパラメータを訓練します")

6. データセットの確認

データセットの確認は、ファインチューニングを開始する前に、データが正しく準備できているかを確認するために行います。

# データセットパスの存在確認
if os.path.exists(DATASET_DIR):
    print(f"✓ パスが見つかりました: {DATASET_DIR}")

    # JSONファイル数を確認
    json_files = glob.glob(os.path.join(DATASET_DIR, "*.json"))
    print(f"✓ JSONファイル数: {len(json_files)}")

    # サンプルデータを表示
    if len(json_files) > 0:
        with open(json_files[0], 'r', encoding='utf-8') as f:
            sample = json.load(f)[0]
            print(f"\n✓ サンプルデータ:")
            print(f"  interaction: {sample['interaction'][:50]}...")
            print(f"  input: {sample['input'][:50]}...")
            print(f"  output: {sample['output'][:50]}...")
else:
    print(f"❌ エラー: パスが見つかりません: {DATASET_DIR}")

7. データセットの読み込み

データセットの読み込みは、JSONファイルに保存されているQ&Aデータをプログラムで使えるようにメモリに展開するために行います。

all_data = []
json_files = glob.glob(os.path.join(DATASET_DIR, "*.json"))

print(f"データセットを読み込み中...")

for json_file in sorted(json_files):
    filename = os.path.basename(json_file)
    with open(json_file, 'r', encoding='utf-8') as f:
        data = json.load(f)
        all_data.extend(data)
        print(f"  ✓ {filename}: {len(data)}件")

print(f"\n✓ 総データ数: {len(all_data)}件")

8. データの分割（訓練用/評価用）

データの分割（訓練用/評価用）は、モデルの性能を正しく評価し、過学習を防ぐために行います。

# シャッフル
random.seed(42)
random.shuffle(all_data)

# 分割
split_idx = int(len(all_data) * TRAIN_SPLIT)
train_data = all_data[:split_idx]
eval_data = all_data[split_idx:]

print(f"✓ データ分割完了")
print(f"  訓練データ: {len(train_data)}件")
print(f"  評価データ: {len(eval_data)}件")

9. プロンプトのフォーマット（Llama 3.1形式）

プロンプトのフォーマット（Llama 3.1形式）は、Llama 3.1モデルが期待する特殊な会話形式に変換するために行います。

def format_llama31_prompt(example):
    """Llama 3.1のチャット形式に変換"""
    system_message = "あなたはNextorageの製品に関する質問に答えるアシスタントです。"

    prompt = f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>

{system_message}<|eot_id|><|start_header_id|>user<|end_header_id|>

{example['input']}<|eot_id|><|start_header_id|>assistant<|end_header_id|>

{example['output']}<|eot_id|>"""

    return {"text": prompt}

print("✓ プロンプトフォーマット関数を定義")

10. データセットをHugging Face形式に変換

データセットをHugging Face形式に変換するのは、SFTTrainer（訓練ツール）がHugging FaceのDataset形式しか受け付けないためです。

# 訓練データ
train_dataset = Dataset.from_list(train_data)
train_dataset = train_dataset.map(format_llama31_prompt)

# 評価データ
eval_dataset = Dataset.from_list(eval_data)
eval_dataset = eval_dataset.map(format_llama31_prompt)

# DatasetDictに統合
dataset = DatasetDict({
    "train": train_dataset,
    "test": eval_dataset
})

print("✓ Dataset形式への変換完了")
print(f"  訓練: {len(dataset['train'])}件")
print(f"  評価: {len(dataset['test'])}件")

# サンプル表示
print("\n✓ フォーマット済みサンプル:")
print(dataset['train'][0]['text'][:200] + "...")

11. モデルとトークナイザーの読み込み

モデルとトークナイザーの読み込みは、ファインチューニングに必要な2つの重要なコンポーネントをメモリに展開するために行います。

print("モデルをロード中...")
print("⏰ 初回は5-10分かかります（モデルをダウンロード中）")

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = BASE_MODEL,
    max_seq_length = MAX_SEQ_LENGTH,
    dtype = None,
    load_in_4bit = LOAD_IN_4BIT,
)

print(f"\n✓ モデルロード完了！")
print(f"  モデル: {model.__class__.__name__}")
print(f"  トークナイザー語彙サイズ: {tokenizer.vocab_size}")

max_seq_length：
これはモデルが一度に処理できる最大のトークン（単語や文字の一部など、モデルが認識する最小単位）の数を指定します。

dtype：
これはモデルのパラメータ（重み）のデータ型を指定します。ディープラーニングモデルでは、通常、パラメータは浮動小数点数（float）で表現されます。一般的なデータ型には float32, float16, bfloat16 などがあります。

dtype = None と指定した場合、unsloth は使用可能なハードウェア（GPU など）に基づいて最適なデータ型を自動的に選択します。多くの最新の GPU では bfloat16 がサポートされており、これによりメモリ使用量を削減しつつ計算速度を向上させることができます。

load_in_4bit：
AIモデルを圧縮して、メモリを節約する技術。

Tokenizerとは、テキストをモデルが理解できる数字に変換すること（逆も可能）

12. モデルの訓練準備

モデルの訓練準備は、フルファインチューニングのためにモデルの全パラメータを訓練可能な状態にし、メモリを最適化するために行います。

# フルファインチューニングの準備
# すべてのパラメータを訓練可能に設定
for param in model.parameters():
    param.requires_grad = True

# Gradient checkpointingを有効化（メモリ節約）
model.gradient_checkpointing_enable()

print("✓ フルファインチューニングの準備完了")
print(f"  訓練可能パラメータ: すべて")
print(f"  Gradient checkpointing: 有効")

13. 訓練引数の設定

訓練引数の設定は、ファインチューニングの「やり方」を細かく指定するために行います。学習率、エポック数、保存タイミングなど、訓練の挙動を制御する重要なパラメータを設定します。

training_args = TrainingArguments(
    output_dir = OUTPUT_DIR,
    per_device_train_batch_size = BATCH_SIZE,
    per_device_eval_batch_size = BATCH_SIZE,
    gradient_accumulation_steps = GRADIENT_ACCUMULATION_STEPS,
    warmup_steps = WARMUP_STEPS,
    num_train_epochs = NUM_EPOCHS,
    learning_rate = LEARNING_RATE,
    fp16 = not torch.cuda.is_bf16_supported(),
    bf16 = torch.cuda.is_bf16_supported(),
    logging_steps = LOGGING_STEPS,
    optim = "adamw_8bit",
    weight_decay = 0.01,
    lr_scheduler_type = "linear",
    seed = 42,
    save_steps = SAVE_STEPS,
    save_total_limit = 2,
    eval_strategy = "steps",  # 修正: evaluation_strategy → eval_strategy
    eval_steps = SAVE_STEPS,
    load_best_model_at_end = True,
)

print("✓ 訓練引数設定完了")
print(f"  エポック数: {NUM_EPOCHS}")
print(f"  バッチサイズ: {BATCH_SIZE}")
print(f"  実効バッチサイズ: {BATCH_SIZE * GRADIENT_ACCUMULATION_STEPS}")
print(f"  学習率: {LEARNING_RATE}")

14. SFTTrainerの初期化

SFTTrainerの初期化は、モデル、データセット、訓練設定をすべて1つにまとめて、ファインチューニングを実行できる状態にするために行います。

trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    train_dataset = dataset["train"],
    eval_dataset = dataset["test"],
    dataset_text_field = "text",
    max_seq_length = MAX_SEQ_LENGTH,
    args = training_args,
)

print("✓ SFTTrainer初期化完了")
print("  準備完了！次のセルでファインチューニングを開始します")

15. フルファインチューニング実行

フルファインチューニング実行は、準備したモデルを実際にNextorageのQ&Aデータで学習させて、製品に関する質問に答えられるようにするために行います。

print("=" * 80)
print("フルファインチューニング開始")
print("=" * 80)
print("⏰ 約45-60分かかります。完了するまでお待ちください...")
print("⚠️ すべてのパラメータを訓練するため、LoRAより時間がかかります")
print("ブラウザを閉じないでください！")
print("=" * 80)

trainer_stats = trainer.train()

print("\n" + "=" * 80)
print("✓ フルファインチューニング完了！")
print("=" * 80)
print(f"訓練損失: {trainer_stats.training_loss:.4f}")
print(f"訓練時間: {trainer_stats.metrics['train_runtime']:.2f}秒")

ここでトレーニングを開始します。

実行すると、「wandb」のAPIキーを入力と出てくるのでこちらを取得し入力してください。

Weights & Biases（wandb.ai）の料金プラン

Weights & Biasesは、機械学習の実験を追跡、可視化、比較するためのプラットフォームです。ファインチューニングのような学習プロセスでは、以下の情報を記録し、分析することができます。

• 学習の進捗: Loss (損失) の変化、学習率など。
• モデルの性能: 検証データでの評価指標など（このノートブックの現在の設定では評価は行っていませんが、追加することは可能です）。
• ハイパーパラメータ: 学習率、バッチサイズ、LoRA の設定など。
• システム情報: GPU 使用率、メモリ使用量など。

これにより、学習がうまくいっているかを確認したり、異なる設定で学習した結果を比較したりすることが容易になります。

16. フルモデルの保存（16bit）

フルモデルの保存（16bit）は、ファインチューニングで学習した成果を失わないために、訓練済みモデル全体をディスクに永続的に保存する処理です。

full_model_path = os.path.join(OUTPUT_DIR, "full_model")

# フルファインチューニングされたモデルを保存
model.save_pretrained(full_model_path)
tokenizer.save_pretrained(full_model_path)

print(f"✓ フルモデル保存完了（16bit）")
print(f"  保存先: {full_model_path}")
print(f"  💾 サイズ: 約16GB")

17. 完了確認

完了確認は、モデルが正しく保存されたかを検証し、次のステップ（推論テスト）に安全に進めるかを判断するために行います。

print("=" * 80)
print("モデル保存確認")
print("=" * 80)

# 保存されたファイルを確認
import os

if os.path.exists(full_model_path):
    # モデルファイルのサイズを計算
    total_size = 0
    for dirpath, dirnames, filenames in os.walk(full_model_path):
        for f in filenames:
            fp = os.path.join(dirpath, f)
            total_size += os.path.getsize(fp)

    print(f"✓ フルモデル保存確認")
    print(f"  パス: {full_model_path}")
    print(f"  サイズ: {total_size / (1024**3):.2f} GB")
    print(f"  ファイル数: {len(os.listdir(full_model_path))}")
else:
    print(f"❌ エラー: モデルが見つかりません: {full_model_path}")

print("\n次のセルで推論テストを実行します")

18. ファインチューニング前後の比較

ファインチューニング前後の比較は、訓練によってモデルがどれだけ改善されたかを実際に確認し、ファインチューニングの効果を検証するために行います。

import time

# テスト質問
test_question = "PS5にM.2 SSDを取り付ける方法を教えてください。"

# プロンプト作成関数
def create_prompt(question):
    system_message = "あなたはNextorageの製品に関する質問に答えるアシスタントです。"
    return f"""<|begin_of_text|><|start_header_id|>system<|end_header_id|>

{system_message}<|eot_id|><|start_header_id|>user<|end_header_id|>

{question}<|eot_id|><|start_header_id|>assistant<|end_header_id|>

"""

「“””」がある理由は、Llama 3.1モデルの特殊なチャット形式（プロンプトテンプレート）を正確に再現するためです。

# 推論実行関数
def generate_response(model, tokenizer, question):
    prompt = create_prompt(question)
    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

    start_time = time.time()
    outputs = model.generate(
        **inputs,
        max_new_tokens=512,
        temperature=0.7,
        top_p=0.9,
        do_sample=True,
    )
    end_time = time.time()

    response = tokenizer.batch_decode(outputs)[0]

    # アシスタントの応答部分のみを抽出
    if "<|start_header_id|>assistant<|end_header_id|>" in response:
        response = response.split("<|start_header_id|>assistant<|end_header_id|>")[-1]
        response = response.split("<|eot_id|>")[0].strip()

    return response, end_time - start_time

print("=" * 80)
print("ファインチューニング前後の比較テスト")
print("=" * 80)
print(f"【質問】\n{test_question}\n")

ファインチューニング済みのモデルで推論

print("\n" + "=" * 80)
print("【ファインチューニング後のモデル】")
print("=" * 80)

# 推論モードに切り替え
FastLanguageModel.for_inference(model)

finetuned_response, finetuned_time = generate_response(model, tokenizer, test_question)

print(finetuned_response)
print(f"\n⏰ 生成時間: {finetuned_time:.2f}秒")

# メモリ解放
del model
del tokenizer
import gc
gc.collect()
torch.cuda.empty_cache()

ファインチューニング後の出力結果

================================================================================
【ファインチューニング後のモデル】
================================================================================
以下の手順で取り付けてください: 1)PS5の電源を完全に切る、2)電源コードを抜く、3)十分に冷却するまで待つ(30分以上推奨)、4)静電気対策として非塗装の金属表面に触れる、5)カバーを外す、6)M.2 SSDカバーのネジを外す、7)M.2 2280のPCIe SSDを約30度の角度でスロットに挿入、8)カバーを戻し、ネジで固定、9)電源を入れ、設定からストレージをフォーマット。注意: この作業は静電気や誤った挿入で故障の原因となる可能性があるため、慎重に実行してください。

⏰ 生成時間: 8.15秒

ベースモデル（ファインチューニング前）で推論

ベースモデル（ファインチューニング前）で推論は、ファインチューニングによる改善効果を客観的に測定するための比較対象（ベースライン）を得るために行います。

print("\n" + "=" * 80)
print("【ファインチューニング前のベースモデル】")
print("⏰ ベースモデルをロード中...")
print("=" * 80)

# ベースモデルをロード
base_model, base_tokenizer = FastLanguageModel.from_pretrained(
    model_name = BASE_MODEL,
    max_seq_length = MAX_SEQ_LENGTH,
    dtype = None,
    load_in_4bit = False,
)

# 推論モードに切り替え
FastLanguageModel.for_inference(base_model)

base_response, base_time = generate_response(base_model, base_tokenizer, test_question)

print(base_response)
print(f"\n⏰ 生成時間: {base_time:.2f}秒")

ファインチューニング前の出力結果

================================================================================
【ファインチューニング前のベースモデル】
⏰ ベースモデルをロード中...
================================================================================
==((====))==  Unsloth 2025.11.2: Fast Llama patching. Transformers: 4.57.1.
   \\   /|    NVIDIA A100-SXM4-80GB. Num GPUs = 1. Max memory: 79.318 GB. Platform: Linux.
O^O/ \_/ \    Torch: 2.9.0+cu128. CUDA: 8.0. CUDA Toolkit: 12.8. Triton: 3.5.0
\        /    Bfloat16 = TRUE. FA [Xformers = 0.0.33.post1. FA2 = False]
 "-____-"     Free license: http://github.com/unslothai/unsloth
Unsloth: Fast downloading is enabled - ignore downloading bars which are red colored!
Loading checkpoint shards: 100%
 4/4 [01:02<00:00, 13.31s/it]
PS5のM.2 SSDの取り付けについては以下の手順に従ってください。

1.  PS5を起動して、設定を選択します。
2.  設定から「ストレージ」を選択し、「M.2 NVMe SSD」を選択します。
3.  次に、M.2 SSDを取り付け場所に取り付けます。
4.  PS5の電源を切り、M.2 SSDを取り付けます。
5.  PS5を再起動し、M.2 SSDが認識されることを確認します。

以上の手順に従ってM.2 SSDを取り付けることで、PS5のストレージ容量が増加し、ゲームの読み込み速度が向上します。

⏰ 生成時間: 6.13秒

比較結果のサマリー

比較結果のサマリーは、ファインチューニング前後の2つの回答を一覧で並べて表示し、改善効果を視覚的・定量的に分かりやすく示すために行います。

print("\n" + "=" * 80)
print("📊 比較サマリー")
print("=" * 80)

print(f"\n【質問】")
print(f"{test_question}")

print(f"\n【ファインチューニング前】")
print(f"{base_response[:200]}..." if len(base_response) > 200 else base_response)

print(f"\n【ファインチューニング後】")
print(f"{finetuned_response[:200]}..." if len(finetuned_response) > 200 else finetuned_response)

print(f"\n【生成時間】")
print(f"  ファインチューニング前: {base_time:.2f}秒")
print(f"  ファインチューニング後: {finetuned_time:.2f}秒")

print(f"\n【文字数】")
print(f"  ファインチューニング前: {len(base_response)}文字")
print(f"  ファインチューニング後: {len(finetuned_response)}文字")

print("\n" + "=" * 80)
print("✓ 比較テスト完了")
print("=" * 80)

# メモリ解放
del base_model
del base_tokenizer
gc.collect()
torch.cuda.empty_cache()

出力結果

================================================================================
📊 比較サマリー
================================================================================

【質問】
PS5にM.2 SSDを取り付ける方法を教えてください。

【ファインチューニング前】
PS5のM.2 SSDの取り付けについては以下の手順に従ってください。

1.  PS5を起動して、設定を選択します。
2.  設定から「ストレージ」を選択し、「M.2 NVMe SSD」を選択します。
3.  次に、M.2 SSDを取り付け場所に取り付けます。
4.  PS5の電源を切り、M.2 SSDを取り付けます。
5.  PS5を再起動し、M.2 SSDが認識されることを確認します。

以...

【ファインチューニング後】
以下の手順で取り付けてください: 1)PS5の電源を完全に切る、2)電源コードを抜く、3)十分に冷却するまで待つ(30分以上推奨)、4)静電気対策として非塗装の金属表面に触れる、5)カバーを外す、6)M.2 SSDカバーのネジを外す、7)M.2 2280のPCIe SSDを約30度の角度でスロットに挿入、8)カバーを戻し、ネジで固定、9)電源を入れ、設定からストレージをフォーマット。注意: この作...

【生成時間】
  ファインチューニング前: 6.13秒
  ファインチューニング後: 8.15秒

【文字数】
  ファインチューニング前: 258文字
  ファインチューニング後: 241文字

================================================================================
✓ 比較テスト完了
================================================================================

19. 完了サマリー

完了サマリーは、すべての処理が正常に完了したことを確認し、次に取るべきアクション（モデルのダウンロードや保存）を明確に示すために行います。

print("=" * 80)
print("🎉 すべての処理が完了しました！")
print("=" * 80)

print("\n【保存されたモデル】")
print(f"1. フルモデル（16bit）: {full_model_path}")

print("\n【次のステップ】")
print("1. モデルをダウンロード:")
print("   !zip -r full_model.zip ./output_full_finetuning/full_model/")
print("   from google.colab import files")
print("   files.download('full_model.zip')")
print("")
print("2. Google Driveに保存:")
print("   !cp -r ./output_full_finetuning /content/drive/MyDrive/")

print("\n✨ Unslothによる高速フルファインチューニング完了！")
print("=" * 80)

まとめ

Google Colab で、Llama3.1 を自社の製品情報のデータセットを作成しファインチューニングしていきました。環境構築から一連の流れを解説しているので試してみてください。

クラウドに出せないデータで、自社専用AIをつくる。
Nextorageでは、機密情報や社内ナレッジなど、クラウドサービスに出せないデータを活用して、自社専用AIを構築するためのオンプレミスAIソリューション 「aiDAPTIV+（アイダプティブ・プラス）」 を展開しています。

生成AIを業務で活用したい一方で、
「社外サービスに機密情報を入力できない」
「GPUコストが高く、導入・運用のハードルが高い」
「日本語業務で十分な精度を出したい」
といった課題を感じている企業・組織の方は、ぜひ以下からお問い合わせください。