DeepSeekモデルファインチューニングチュートリアル
DeepSeekモデルをあなた専用のAIアシスタントにカスタマイズ。データ準備からモデルデプロイまで、完全なファインチューニングの流れを、すぐ実行可能なコードと設定付きで紹介します。
学習を始める第1節
ファインチューニング概要
ファインチューニングを始める前に、ファインチューニングとは何か、いつ必要か、そしてファインチューニングの種類を理解しましょう。
モデルファインチューニングとは？
モデルファインチューニングとは、事前学習済みの大規模言語モデルを、特定のドメインのデータを使って追加学習し、特定のタスクでのパフォーマンスを向上させることを指します。DeepSeekモデルはすでに強力な汎用能力を備えていますが、医療診断、法律相談、金融分析、コードレビューなどの垂直領域でより専門的に動作させる必要がある場合、ファインチューニングが最も効果的な方法です。
ファインチューニングとプロンプトエンジニアリングの使い分け
これは多くの開発者が最初に抱く疑問です。判断基準は以下の通りです：
ファインチューニング推奨のシナリオ
- モデルに特定のドメイン知識（医学、法律、金融など）を習得させる必要がある
- 特定の出力形式（JSON構造、特定のテンプレート）が必要
- 特定の文体やトーンを模倣する必要がある
- プロンプトが長すぎて、コンテキストで要件を完全に記述できない
- 推論コストを削減する必要がある（ファインチューニング後の小規模モデルで大規模モデルを代替可能）
- レイテンシを削減する必要がある（ファインチューニング後は複雑なプロンプトが不要）
プロンプトエンジニアリング推奨のシナリオ
- タスクが比較的単純で、数文で明確に記述できる
- データ量が不足している（高品質なサンプルが100件未満）
- 要件が頻繁に変わり、繰り返しトレーニングしたくない
- 一時的な使用のみで、長期的なメンテナンスが不要
- ファインチューニングによる他の能力の低下を懸念している
ファインチューニングの主な種類
最も推奨
LoRAファインチューニング
低ランク適応（Low-Rank Adaptation）は、元のモデルに小さなパラメータ行列を追加し、これらの新しいパラメータのみをトレーニングします。VRAM要件が低く、トレーニング速度が速く、単一GPUで7Bモデルのファインチューニングが可能です。現在最も主流で推奨されるファインチューニング方法です。
- VRAM要件：7Bモデルで約16GB
- トレーニング速度：速い（数時間）
- モデル品質：フルファインチューニングに近い
- 元のモデルにマージ可能
VRAMフレンドリー
QLoRAファインチューニング
LoRAに4ビット量子化を追加し、モデルパラメータを4ビット精度に圧縮します。VRAM要件がさらに低減され、コンシューマー向けGPU（例：RTX 3090 24GB）で7Bモデルのファインチューニングが可能です。LoRAよりわずかに遅いですが、結果は同等です。
- VRAM要件：7Bモデルで約8-10GB
- トレーニング速度：中程度（数時間）
- モデル品質：LoRAと同等
- コンシューマー向けGPUに適しています
最高品質
フルファインチューニング
モデルの全パラメータを更新し、理論上最も良い結果が得られますが、大量のGPUメモリが必要です。7Bモデルには約60-80GBのVRAMが必要で、通常は複数GPUトレーニングまたはDeepSpeed ZeRO最適化が必要です。十分な計算リソースを持つチームに適しています。
- VRAM要件：7Bモデルで約60-80GB
- トレーニング速度：遅い（数日）
- モデル品質：最適
- 複数GPU/A100が必要
DeepSeekモデルファインチューニングの特別な利点
DeepSeekモデルはMoE（混合エキスパート）アーキテクチャを採用しており、ファインチューニングにおいて以下の利点があります：
- Denseモデル（例：DeepSeek-Coder-6.7B）：標準アーキテクチャで、LoRA/QLoRAのサポートが充実し、コミュニティリソースが豊富
- MoEモデル（例：DeepSeek-V2-Lite）：推論ごとに一部のエキスパートのみをアクティブ化し、推論効率が高く、ファインチューニング時に特定のエキスパートを対象に最適化可能
- 公式コードサポート：DeepSeek公式GitHubリポジトリに完全なファインチューニングコードが用意されており、すぐに使用可能
- MITオープンソースライセンス：ファインチューニング後のモデルは制限なく商用利用可能
DeepSeekモデルアーキテクチャの詳細については、DeepSeekモデルアーキテクチャ詳細 および DeepSeekオープンソースモデル一覧 をご覧ください。
セクション2
環境準備
ファインチューニングを開始する前に、必要なPython依存ライブラリのインストールとGPU環境の設定が必要です。
ハードウェア要件
| ファインチューニング方法 | 1.5Bモデル | 7Bモデル | 16Bモデル | 推奨GPU |
|---|---|---|---|---|
| QLoRA (4-bit) | ~4GB | ~8-10GB | ~16-20GB | RTX 3060 12GB以上 |
| LoRA (FP16/BF16) | ~8GB | ~16-20GB | ~32-40GB | RTX 3090/4090 24GB |
| 全パラメータファインチューニング | ~20GB | ~60-80GB | ~120-160GB | A100 80GB / マルチGPU |
依存ライブラリのインストール
新しいPython仮想環境を作成し、以下の依存関係をインストールします：
# 仮想環境の作成
python -m venv deepseek-finetune
# Windowsでのアクティベート
deepseek-finetune\Scripts\activate
# Linux/Macでのアクティベート
# source deepseek-finetune/bin/activate
# PyTorchのインストール（CUDAバージョンに応じて選択）
# CUDA 12.1
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
# CUDA 11.8
# pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
# ファインチューニング用コアライブラリのインストール
pip install transformers datasets accelerate peft bitsandbytes
pip install trl # Transformer Reinforcement Learning、SFTTrainerを提供
pip install wandb tensorboard # トレーニング監視
pip install deepspeed # 全パラメータ微調整に必要（オプション）
環境の検証
インストール後、以下のPythonスクリプトを実行して環境が正常かどうかを検証します：
import torch
import transformers
import peft
import datasets
print(f"PyTorch バージョン: {torch.__version__}")
print(f"CUDA 利用可能: {torch.cuda.is_available()}")
print(f"GPU 数: {torch.cuda.device_count()}")
print(f"Transformers バージョン: {transformers.__version__}")
print(f"PEFT バージョン: {peft.__version__}")
print(f"Datasets バージョン: {datasets.__version__}")
if torch.cuda.is_available():
print(f"現在のGPU: {torch.cuda.get_device_name(0)}")
print(f"総VRAM: {torch.cuda.get_device_properties(0).total_mem / 1024**3:.1f} GB")
else:
print("警告: GPUが検出されませんでした。トレーニングはCPUを使用します（非常に遅い）")
環境に関する注意事項
- bitsandbytes のインストール：Windowsユーザーはソースからコンパイルする必要がある場合があります。WSL2またはLinux環境を推奨します
- CUDAバージョンの一致：PyTorchのCUDAバージョンは、システムにインストールされているCUDAドライババージョンと互換性がある必要があります
- クラウドGPUの推奨：ローカルGPUがない場合は、AutoDL、恒源云などの国内GPUクラウドプラットフォームを推奨します
第3節
データセット準備
高品質なデータは微調整成功の鍵です。この節では、データ形式、データ品質要件、データ準備のベストプラクティスを紹介します。
データ形式
微調整データは通常、JSONまたはJSONL形式を使用します。各データは命令（instruction）と対応する出力（output）を含み、オプションで入力（input）フィールドを含むことができます。
# data.jsonl — 各行に1つのJSONオブジェクト
{"instruction": "以下の中国語を英語に翻訳してください", "input": "人工智能正在改变世界", "output": "Artificial intelligence is changing the world."}
{"instruction": "以下のPythonコードの機能を説明してください", "input": "def foo(x): return x**2", "output": "この関数は引数xを受け取り、xの2乗を返します。"}
{"instruction": "春についての五言絶句を書いてください", "input": "", "output": "春风拂柳绿，\n细雨润花红。\n燕子归巢急，\n人间四月同。"}
Alpaca形式（推奨）
Alpaca形式は微調整コミュニティで最も一般的に使用されるデータ形式であり、DeepSeekモデルとの互換性が最も高いです：
[
{
"instruction": "あなたはプロのPythonプログラミングアシスタントです。以下の質問に答えてください。",
"input": "Pythonでシングルトンパターンを実装するにはどうすればよいですか？",
"output": "Pythonでシングルトンパターンを実装するにはいくつかの一般的な方法があります：\n\n1. __new__メソッドを使用する：\n```python\nclass Singleton:\n _instance = None\n def __new__(cls, *args, **kwargs):\n if cls._instance is None:\n cls._instance = super().__new__(cls)\n return cls._instance\n```\n\n2. デコレータを使用する：\n```python\ndef singleton(cls):\n instances = {}\n def wrapper(*args, **kwargs):\n if cls not in instances:\n instances[cls] = cls(*args, **kwargs)\n return instances[cls]\n return wrapper\n```\n\n最初の方法がよりPythonicであるため推奨されます。"
}
]
チャット形式（会話データ）
会話データがある場合は、ShareGPT形式またはconversations形式を使用できます：
{
"conversations": [
{"role": "system", "content": "あなたはプロの医療相談アシスタントです。"},
{"role": "user", "content": "最近頭痛が続いていますが、どうすればよいですか？"},
{"role": "assistant", "content": "頭痛の原因は多くあります。...（具体的な内容は省略）"}
]
}
データ品質の推奨事項
量
- 最低100〜200件の高品質サンプル
- 推奨500〜2000件
- 簡単なタスクは500件で十分
- 複雑なタスクは2000件以上を推奨
多様性
- 異なる難易度とシナリオをカバー
- 重複または類似性の高いサンプルを避ける
- 長文と短文を混在させる
- エッジケースを含める
正確性
- 出力は正確でなければならない
- コード例は実行可能であること
- 専門分野の知識は検証が必要
- フォーマットを一貫させる
一貫性
- 統一された出力形式
- 一貫したトーンとスタイル
- 同じ用語の使用
- 統一された句読点規則
データの品質は量よりも重要
高品質なデータ500件は、低品質なデータ5000件よりもはるかに効果的です。各サンプルは手動でレビューし、出力が正確で形式が整っていることを確認する必要があります。データ品質が悪いと、ファインチューニングはモデルの元の能力を損なう可能性があります。
DeepSeekを使用したトレーニングデータの生成
DeepSeek自体を利用して高品質なトレーニングデータを生成できます。以下は実用的なデータ生成戦略です：
# DeepSeek APIを使用してトレーニングデータを生成
from openai import OpenAI
import json
client = OpenAI(
api_key="sk-your-api-key",
base_url="https://api.deepseek.com",
)
# DeepSeek V3にトレーニングデータを生成させる
prompt = """PythonプログラミングのQ&Aペアを50件、JSON配列形式で生成してください。
各要素はinstruction（質問）とoutput（詳細な回答）を含みます。
トピック：デコレータ、非同期プログラミング、型ヒント、コンテキストマネージャ、ジェネレータ。
{"instruction": "...", "output": "..."}"""
response = client.chat.completions.create(
model="deepseek-chat",
messages=[{"role": "user", "content": prompt}],
temperature=0.8,
)
# 解析して保存
data = json.loads(response.choices[0].message.content)
with open('training_data.json', 'w', encoding='utf-8') as f:
json.dump(data, f, ensure_ascii=False, indent=2)
DeepSeek APIの詳細な使用方法は、DeepSeek使用チュートリアルを参照してください。
第4節
LoRA ファインチューニング（推奨）
LoRA は現在最も推奨され、実用的なファインチューニング方法です。このセクションでは、QLoRA ファインチューニングの完全なコードと詳細なパラメータ説明を提供します。
LoRA ファインチューニングの原理
LoRA（Low-Rank Adaptation）の核となる考え方は、事前学習モデルの重みに低ランク行列を追加し、これらの新しい行列パラメータのみを訓練し、元のモデルの重みは変更しないことです。これにより、訓練するパラメータ数とメモリ要件が大幅に削減されます。
具体的には、元の重み行列 W（d x k）に対して、LoRA はその更新を2つの小さな行列の積に分解します：W + delta_W = W + B * A。ここで、A は r x k 行列、B は d x r 行列、r はランクで、通常 8〜64 です。r が d や k よりはるかに小さいため、訓練パラメータ数が大幅に削減されます。
QLoRA ファインチューニングの完全なコード
以下は、QLoRA（4ビット量子化 + LoRA）を使用して DeepSeek モデルをファインチューニングするための完全な Python スクリプトです：
# train_lora.py — DeepSeek モデルの QLoRA ファインチューニング
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
BitsAndBytesConfig,
)
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer
# ========== 1. 設定 ==========
model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
dataset_path = "./data/training_data.json"
output_dir = "./output/deepseek-lora"
# ========== 2. 4ビット量子化設定 ==========
bnb_config = BitsAndBytesConfig(
load_in_4bit=True,
bnb_4bit_quant_type="nf4",
bnb_4bit_compute_dtype=torch.bfloat16,
bnb_4bit_use_double_quant=True,
)
# ========== 3. モデルとトークナイザーの読み込み ==========
model = AutoModelForCausalLM.from_pretrained(
model_name,
quantization_config=bnb_config,
device_map="auto",
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(
model_name,
trust_remote_code=True,
)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
# ========== 4. kビットトレーニング用にモデルを準備 ==========
model = prepare_model_for_kbit_training(model)
# ========== 5. LoRA 設定 ==========
lora_config = LoraConfig(
r=16, # LoRA ランク、大きいほど表現力が高いがパラメータが増える
lora_alpha=32, # LoRA スケーリング係数、通常 r の2倍に設定
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.print_trainable_parameters()
# ========== 6. データセットの読み込み ==========
dataset = load_dataset("json", data_files=dataset_path, split="train")
def format_instruction(sample):
"""データをトレーニング用テキストにフォーマット"""
if sample.get("input"):
text = f"""Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
### Instruction:
{sample['instruction']}
### Input:
{sample['input']}
### Response:
{sample['output']}"""
else:
text = f"""Below is an instruction that describes a task. Write a response that appropriately completes the request.
### Instruction:
{sample['instruction']}
### Response:
{sample['output']}"""
return {"text": text}
dataset = dataset.map(format_instruction)
# ========== 7. トレーニング引数 ==========
training_args = TrainingArguments(
output_dir=output_dir,
num_train_epochs=3,
per_device_train_batch_size=4,
gradient_accumulation_steps=4,
warmup_steps=100,
learning_rate=2e-4,
fp16=True,
logging_steps=10,
save_steps=200,
save_total_limit=3,
optim="paged_adamw_8bit",
lr_scheduler_type="cosine",
report_to="tensorboard",
)
# ========== 8. Trainer を作成してトレーニング開始 ==========
trainer = SFTTrainer(
model=model,
args=training_args,
train_dataset=dataset,
tokenizer=tokenizer,
max_seq_length=2048,
dataset_text_field="text",
)
trainer.train()
# ========== 9. モデルの保存 ==========
trainer.model.save_pretrained(output_dir)
tokenizer.save_pretrained(output_dir)
主要パラメータの説明
| パラメータ | 推奨値 | 説明 |
|---|---|---|
| r (rank) | 8-64 | ランクが大きいほど表現力が高まりますが、学習パラメータとGPUメモリも増加します。単純なタスクではr=8で十分ですが、複雑なタスクではr=32-64を使用できます。 |
| lora_alpha | rの2倍 | スケーリング係数。LoRAの重みが元のモデルに与える影響を制御します。通常はrの2倍に設定します。 |
| learning_rate | 1e-4 ~ 5e-4 | 学習率。LoRAは通常、全パラメータ微調整よりも高い学習率を使用します。推奨は2e-4です。 |
| num_train_epochs | 2-5 | エポック数。データ量が少ない場合はエポック数を増やし、多い場合は2-3エポックで十分です。過学習を防ぐため、損失曲線に注意してください。 |
| max_seq_length | 2048-4096 | 最大シーケンス長。長いテキストの学習にはより多くのGPUメモリが必要です。DeepSeek-Coderは16Kコンテキストをサポートしています。 |
トレーニングの実行
上記のコードを train_lora.py として保存し、実行します：
python train_lora.py
トレーニング高速化のヒント
- gradient_checkpointingを使用：計算とメモリをトレードオフします。TrainingArgumentsで
gradient_checkpointing=Trueを設定します。 - batch_sizeを調整：GPUメモリが不足している場合は、per_device_train_batch_sizeを減らし、gradient_accumulation_stepsを増やします。
- Flash Attention 2を使用：flash-attnライブラリをインストールし、モデル読み込み時に
use_flash_attention_2=Trueを設定すると、2〜3倍高速化できます。
モデルのダウンロードとデプロイの詳細は、DeepSeekモデルダウンロード と DeepSeekデプロイチュートリアル を参照してください。
第5節
全パラメータ微調整
全パラメータ微調整は理論上最も良い結果が得られますが、大量のGPUメモリが必要です。このセクションでは、DeepSpeed ZeROを使用した全パラメータ微調整の方法を紹介します。
全パラメータ微調整の要件
全パラメータ微調整ではモデルのすべてのパラメータを更新するため、モデル全体をGPUメモリにロードする必要があります。7Bモデルの場合、モデルの重みだけで約14GB（FP16）が必要で、オプティマイザの状態と勾配を加えると、合計で約60〜80GBのGPUメモリが必要です。そのため、通常は複数GPUでのトレーニングや、A100/H100などの大容量メモリを備えたGPUが必要です。
DeepSpeed ZeROの設定
DeepSpeed ZeROは、オプティマイザの状態、勾配、モデルパラメータを複数のGPUに分散することで、GPUあたりのメモリ要件を大幅に削減します。以下は、DeepSeekモデルの全パラメータ微調整のためのDeepSpeed設定です：
# ds_config_zero3.json — DeepSpeed ZeRO Stage 3設定
{
"bf16": {
"enabled": true
},
"zero_optimization": {
"stage": 3,
"offload_optimizer": {
"device": "cpu",
"pin_memory": true
},
"offload_param": {
"device": "cpu",
"pin_memory": true
},
"overlap_comm": true,
"contiguous_gradients": true,
"sub_group_size": 1e9,
"reduce_bucket_size": "auto",
"stage3_prefetch_bucket_size": "auto",
"stage3_param_persistence_threshold": "auto",
"stage3_max_live_parameters": 1e9,
"stage3_max_reuse_distance": 1e9,
"stage3_gather_16bit_weights_on_model_save": true
},
"gradient_accumulation_steps": "auto",
"gradient_clipping": "auto",
"train_batch_size": "auto",
"train_micro_batch_size_per_gpu": "auto",
"wall_clock_breakdown": false
}
全パラメータ微調整のトレーニングスクリプト
# train_full.py — DeepSeek全パラメータ微調整
import torch
from datasets import load_dataset
from transformers import (
AutoModelForCausalLM,
AutoTokenizer,
TrainingArguments,
Trainer,
DataCollatorForLanguageModeling,
)
model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
dataset_path = "./data/training_data.json"
output_dir = "./output/deepseek-full"
# モデルをロード（量子化なし）
model = AutoModelForCausalLM.from_pretrained(
model_name,
torch_dtype=torch.bfloat16,
trust_remote_code=True,
use_flash_attention_2=True, # flash-attnのインストールが必要
)
tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"
# データセットのロードと処理
dataset = load_dataset("json", data_files=dataset_path, split="train")
def tokenize_function(examples):
texts = [f"### Instruction:\n{inst}\n\n### Response:\n{out}"
for inst, out in zip(examples["instruction"], examples["output"])]
return tokenizer(texts, truncation=True, max_length=2048)
tokenized_dataset = dataset.map(tokenize_function, batched=True, remove_columns=dataset.column_names)
data_collator = DataCollatorForLanguageModeling(
tokenizer=tokenizer,
mlm=False,
)
training_args = TrainingArguments(
output_dir=output_dir,
overwrite_output_dir=True,
num_train_epochs=2,
per_device_train_batch_size=2,
gradient_accumulation_steps=8,
warmup_ratio=0.03,
learning_rate=5e-5,
bf16=True,
logging_steps=10,
save_steps=200,
save_total_limit=2,
deepspeed="./ds_config_zero3.json",
lr_scheduler_type="cosine",
report_to="tensorboard",
)
trainer = Trainer(
model=model,
args=training_args,
train_dataset=tokenized_dataset,
tokenizer=tokenizer,
data_collator=data_collator,
)
trainer.train()
trainer.save_model(output_dir)
tokenizer.save_pretrained(output_dir)
マルチGPUトレーニングの開始
# DeepSpeedを使用して4つのGPUでトレーニング
deepspeed --num_gpus=4 train_full.py
全パラメータ微調整 vs LoRA 選択の推奨事項
- LoRAを優先: ほとんどのシナリオで、LoRAの効果は全パラメータ微調整と差がほとんどありません（通常 < 2%）が、コストははるかに低いです
- 全パラメータ微調整が適している場面: 新しい分野でモデルの動作を大幅に変更する必要がある場合、十分な計算リソースがある場合、究極のパフォーマンスを追求する場合
- ハイブリッド戦略: まずLoRAで迅速に実験し、最適なデータとハイパーパラメータを見つけてから、最終版には全パラメータ微調整を使用します
第6節
DeepSeek公式ファインチューニングコードの使用
DeepSeekはGitHubで完全なファインチューニングコードを提供しており、ゼロからトレーニングスクリプトを書くことなく直接使用できます。
公式ファインチューニングコードの取得
DeepSeek公式GitHubリポジトリには、トレーニングとファインチューニングに必要なすべてのコードが含まれています。例としてDeepSeek-Coderを取り上げます：
# DeepSeek-Coderリポジトリをクローン
git clone https://github.com/deepseek-ai/DeepSeek-Coder.git
cd DeepSeek-Coder
# ファインチューニングコードは finetune/ ディレクトリにあります
ls finetune/
# 出力: deepseek_coder_finetune.py data/ README.md
# 公式依存関係をインストール
pip install -r finetune/requirements.txt
公式ファインチューニングコマンド
DeepSeekは、LoRAと全パラメータファインチューニングをサポートする簡潔なコマンドラインインターフェースを提供しています：
# DeepSeek-Coder-6.7BのLoRAファインチューニング
python finetune/deepseek_coder_finetune.py \
--model_name_or_path deepseek-ai/deepseek-coder-6.7b-instruct \
--data_path ./data/training_data.jsonl \
--output_dir ./output/deepseek-coder-lora \
--num_train_epochs 3 \
--per_device_train_batch_size 4 \
--gradient_accumulation_steps 4 \
--learning_rate 2e-4 \
--lora_r 16 \
--lora_alpha 32 \
--use_lora True \
--bf16 True
公式データ形式の要件
DeepSeek公式ファインチューニングコードが期待するデータ形式はJSONLで、各行にinstructionフィールドとoutputフィールドが含まれます：
# training_data.jsonl
{"instruction": "2つの数値の最大公約数を計算するPython関数を書いてください", "output": "def gcd(a, b):\n while b:\n a, b = b, a % b\n return a\n\n# math.gcdを使用してもよい\n# from math import gcd"}
{"instruction": "再帰とは何か説明してください", "output": "再帰は、関数が自分自身を呼び出すことで問題を解決するプログラミング手法です。再帰には2つの重要な部分があります：\n\n1. ベースケース（基本ケース）：再帰を停止する条件\n2. 再帰ケース：関数が自分自身を呼び出す条件\n\n例えば、階乗 n! = n * (n-1)! を計算する場合、n=1で停止します。"}
公式コードの利点
- DeepSeekモデルアーキテクチャに最適化され、トレーニング効率が高い
- DeepSeek固有のトークナイザーとモデル設定を自動処理
- データ処理と評価ロジックが組み込まれている
- 継続的に更新され、最新のモデルバージョンと互換性がある
その他のDeepSeekエコシステムツールについては、DeepSeekエコシステムツールをご覧ください。
第7節
トレーニング監視
トレーニング中にloss曲線、学習率の変化、GPU使用状況をリアルタイムで監視し、異常を早期に発見してパラメータを調整するのに役立ちます。
TensorBoard 監視
TensorBoard は PyTorch に組み込まれたトレーニング可視化ツールです。トレーニングコードで report_to="tensorboard" を設定した後、TensorBoard を起動します：
# TensorBoard を起動
tensorboard --logdir ./output --port 6006
# ブラウザで http://localhost:6006 を開く
Wandb 監視
Wandb（Weights & Biases）は、よりリッチなクラウドベースのトレーニング監視機能を提供し、チームコラボレーションをサポートします：
# wandb をインストール
pip install wandb
# ログイン（初回はAPIキーが必要）
wandb login
# トレーニングコードで設定（または環境変数で）
# TrainingArguments で report_to="wandb" を設定
# または環境変数を設定：
# export WANDB_PROJECT="deepseek-finetune"
主要な監視指標
Loss 曲線
- トレーニング loss は継続的に減少する必要があります
- loss が減少しない場合は、学習率を確認してください
- loss が激しく振動する場合は、学習率を下げてください
- loss が急速に減少した後にプラトーになるのは正常です
GPU 使用率
- GPU 使用率は 90-100% に近い必要があります
- 使用率が低い = データロードのボトルネック
- num_workers を増やしてデータロードを高速化
- nvidia-smi でリアルタイムに確認
学習率
- cosine スケジューラで自動減衰
- warmup フェーズで学習率を段階的に上げる
- loss が減少しない場合は学習率を上げてみる
- loss が振動する場合は学習率を下げてみる
Checkpoint
- 定期的に checkpoint を保存
- save_total_limit で保存数を制御
- トレーニング中断時は checkpoint から再開可能
- loss が最も低い checkpoint を保持
Checkpoint からトレーニングを再開
トレーニングが予期せず中断された場合、最新の checkpoint から再開できます：
# TrainingArguments に追加
resume_from_checkpoint=True
# または具体的な checkpoint パスを指定
resume_from_checkpoint="./output/deepseek-lora/checkpoint-600"
過学習の警告サイン
トレーニング loss が継続的に減少しているが検証 loss が上昇し始めた場合、モデルは過学習しています。この場合は、トレーニングエポック数を減らす、データ量を増やす、lora_dropout を増やす、またはより小さい learning_rate を使用してください。
第8節
モデル評価
ファインチューニング後、ターゲットタスクでのモデルの性能を評価し、ファインチューニングが期待どおりの効果を達成したことを確認する必要があります。
評価方法
モデル評価は、自動評価と手動評価の2つの方法に分けられます。
自動評価
定量的指標
- Perplexity（困惑度）
- ROUGE / BLEU スコア
- 正確率 / F1 スコア
- HumanEval（コードタスク）
- MMLU（知識Q&A）
手動評価
定性的評価
- 出力品質のスコアリング
- 指示への従順性
- 回答の正確性
- スタイルの一貫性
- A/B 比較テスト
テストセット評価スクリプト
# evaluate.py — ファインチューニング後のモデルを評価
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
# ベースモデルとLoRAウェイトを読み込む
base_model = AutoModelForCausalLM.from_pretrained(
"deepseek-ai/deepseek-coder-6.7b-instruct",
torch_dtype=torch.float16,
device_map="auto",
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(
"deepseek-ai/deepseek-coder-6.7b-instruct",
trust_remote_code=True,
)
# LoRAアダプターを読み込む
model = PeftModel.from_pretrained(base_model, "./output/deepseek-lora")
# テスト推論
test_questions = [
"二分探索アルゴリズムを実装するPython関数を書いてください",
"PythonのGILとは何か説明してください",
"asyncioを使って並行リクエストを実装する方法",
]
for question in test_questions:
prompt = f"### Instruction:\n{question}\n\n### Response:\n"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
outputs = model.generate(
**inputs,
max_new_tokens=512,
temperature=0.7,
do_sample=True,
top_p=0.9,
)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(f"質問: {question}\n回答: {response}\n{'='*60}")
ベンチマーク比較
同じテストセットでファインチューニング前後のモデルの出力を比較し、ファインチューニングによる改善を評価することをお勧めします：
- 横方向の比較：ファインチューニング後のモデル vs 元のモデル vs 他の同種モデル
- 縦方向の比較：異なるチェックポイント間の効果の違い
- アブレーション実験：異なるハイパーパラメータ組み合わせの効果比較
- 境界テスト：極端な入力でのモデルの性能をテスト
評価の推奨事項
自動評価指標だけを見ないでください。実際のシナリオでモデルをテストし、特にエッジケースやエラーが発生しやすい状況を確認してください。ファインチューニング後のモデルが一般的な能力で大幅に低下している場合は、元のデータとファインチューニングデータを混ぜて再トレーニングすることを検討してください。
第9節
モデルのマージとエクスポート
ファインチューニング後、LoRAウェイトを元のモデルにマージし、デプロイ用にさまざまな形式でエクスポートする必要があります。
LoRAウェイトのマージ
LoRAトレーニングではアダプターウェイトが生成されるため、スタンドアロンモデルとして使用するには元のモデルにマージする必要があります：
# merge_lora.py — LoRAウェイトを元のモデルにマージ
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel
base_model_name = "deepseek-ai/deepseek-coder-6.7b-instruct"
lora_path = "./output/deepseek-lora"
merged_path = "./output/deepseek-coder-merged"
# ベースモデルの読み込み
base_model = AutoModelForCausalLM.from_pretrained(
base_model_name,
torch_dtype=torch.float16,
trust_remote_code=True,
)
# LoRAウェイトの読み込みとマージ
model = PeftModel.from_pretrained(base_model, lora_path)
model = model.merge_and_unload()
# マージ後のモデルを保存
model.save_pretrained(merged_path)
tokenizer = AutoTokenizer.from_pretrained(base_model_name, trust_remote_code=True)
tokenizer.save_pretrained(merged_path)
print(f"モデルはマージされ、保存されました: {merged_path}")
GGUF形式へのエクスポート（Ollama / llama.cpp）
GGUFはllama.cppとOllamaで使用されるモデル形式で、エクスポート後はローカルで効率的に実行できます：
# llama.cppのconvert_hf_to_gguf.pyを使用して変換
# llama.cppをクローン
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
# 依存関係のインストール
pip install -r requirements.txt
# モデルをGGUF形式に変換
python convert_hf_to_gguf.py ../output/deepseek-coder-merged \
--outfile ../output/deepseek-coder-finetuned.gguf \
--outtype f16
# モデルの量子化（オプション、サイズ削減用）
# ./build/bin/llama-quantize ../output/deepseek-coder-finetuned.gguf Q4_K_M
Ollama Modelfileの作成
GGUFをエクスポートした後、Modelfileを作成するとOllamaで使用できます：
# Modelfile
FROM ./deepseek-coder-finetuned.gguf
PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 16384
SYSTEM """あなたはプロのPythonプログラミングアシスタントであり、ファインチューニングによって最適化されています。"""
# Ollamaモデルの作成
# ollama create deepseek-coder-custom -f Modelfile
# 実行
# ollama run deepseek-coder-custom
Hugging Faceへのプッシュ
ファインチューニングしたモデルをHugging Faceコミュニティと共有します：
# push_to_hub.py
from transformers import AutoModelForCausalLM, AutoTokenizer
from huggingface_hub import login
# Hugging Faceにログイン（Access Tokenが必要）
login(token="hf_your_access_token")
model = AutoModelForCausalLM.from_pretrained(
"./output/deepseek-coder-merged",
trust_remote_code=True,
)
tokenizer = AutoTokenizer.from_pretrained(
"./output/deepseek-coder-merged",
trust_remote_code=True,
)
repo_id = "your-username/deepseek-coder-finetuned"
model.push_to_hub(repo_id, private=True)
tokenizer.push_to_hub(repo_id, private=True)
print(f"モデルがプッシュされました: https://huggingface.co/{repo_id}")
その他のデプロイ方法については、DeepSeekデプロイチュートリアルを参照してください。
第10節
デプロイ
ファインチューニング後の最後のステップ：モデルを本番環境にデプロイし、APIサービスを提供します。
デプロイ方法の比較
最も簡単
Ollama ローカルデプロイ
個人利用や小規模チームに適しており、ワンクリックでファインチューニング済みモデルをデプロイできます。GGUF形式にエクスポート後、Ollamaで実行し、API呼び出しをサポートします。
- 1コマンドで起動
- OpenAI API形式と互換性あり
- リソース消費が少ない
- 単一マシンでのデプロイに適している
高性能
vLLM デプロイ
本番環境に適した高性能推論エンジン。PagedAttention、連続バッチ処理、マルチGPU並列推論をサポートし、スループットはOllamaをはるかに上回ります。
- 高スループット
- OpenAI APIと互換性あり
- マルチGPU対応
- 本番レベルの安定性
クラウド
Hugging Face Inference
モデルをHugging Faceにプッシュ後、Inference Endpointsを使用してデプロイでき、サーバー管理は不要です。
- 運用不要
- 自動スケーリング
- 従量課金
- グローバルノード
vLLM デプロイコマンド
vLLMは現在、本番環境で最も推奨される高性能推論エンジンです：
# vLLMのインストール
pip install vllm
# vLLM APIサービスの起動
python -m vllm.entrypoints.openai.api_server \
--model ./output/deepseek-coder-merged \
--served-model-name deepseek-coder-custom \
--host 0.0.0.0 \
--port 8000 \
--max-model-len 16384 \
--gpu-memory-utilization 0.95 \
--trust-remote-code
# API呼び出し（OpenAIと完全互換）
# curl http://localhost:8000/v1/chat/completions \
# -H "Content-Type: application/json" \
# -d '{"model":"deepseek-coder-custom","messages":[{"role":"user","content":"こんにちは"}]}'
Docker デプロイ
Dockerデプロイを使用すると、環境の一貫性が確保され、移行や拡張が容易になります：
# Dockerfile
FROM vllm/vllm-openai:latest
COPY ./output/deepseek-coder-merged /models/deepseek-coder-custom
ENV VLLM_MODEL=/models/deepseek-coder-custom
ENV VLLM_SERVED_MODEL_NAME=deepseek-coder-custom
ENV VLLM_MAX_MODEL_LEN=16384
EXPOSE 8000
# ビルドと実行
# docker build -t deepseek-coder-custom .
# docker run --gpus all -p 8000:8000 deepseek-coder-custom
API呼び出し例（Python）
from openai import OpenAI
client = OpenAI(
base_url="http://localhost:8000/v1",
api_key="not-needed",
)
response = client.chat.completions.create(
model="deepseek-coder-custom",
messages=[
{"role": "system", "content": "あなたはプロのPythonプログラミングアシスタントです。"},
{"role": "user", "content": "クイックソートの実装を書いてください"},
],
temperature=0.7,
max_tokens=512,
)
print(response.choices[0].message.content)
本番環境での注意点
- ヘルスチェック：/healthエンドポイントを設定し、サービス可用性の監視を確保
- レート制限：NginxやAPIゲートウェイでリクエスト頻度制限を設定
- 同時実行制御：vLLMはmax_num_seqsパラメータで同時リクエスト数を制御可能
- ログ記録：すべてのAPIリクエストとレスポンスを記録し、問題のトラブルシューティングを容易にする
- モデルのホットアップデート：ブルーグリーンデプロイ戦略を使用し、ダウンタイムなしでモデルを更新
デプロイの詳細は、DeepSeekデプロイチュートリアル と DeepSeek使用チュートリアル を参照してください。
よくある質問
DeepSeekモデル微調整のよくある質問
DeepSeekモデルの微調整にはどのくらいのデータが必要ですか？
最低でも100〜200件の高品質なサンプルが必要で、500〜2000件を推奨します。データの質は量よりも重要です。単純なタスク（形式変換など）には、500件の高品質データで顕著な効果が得られます。複雑なタスク（専門分野のQ&Aなど）には2000件以上を推奨します。データが不足している場合は、まずDeepSeekで初期データを生成し、その後人間がレビューして修正することができます。
LoRAと全パラメータ微調整のどちらが良いですか？
ほとんどのシナリオでは、LoRAを推奨します。LoRAの効果は全パラメータ微調整とほとんど差がなく（通常2%未満）、コストははるかに低くなります（GPUメモリ要件が60〜80%削減）。全パラメータ微調整は、新しい領域でモデルの動作を大幅に変更する必要があるシナリオに適しており、十分な計算リソースが必要です。まずLoRAで迅速に実験し、最適なデータとハイパーパラメータを見つけてから、全パラメータ微調整が必要かどうかを決定することをお勧めします。
通常のPCでDeepSeekモデルを微調整できますか？
はい。QLoRA（4ビット量子化+LoRA）を使用すると、8GB以上のVRAMを搭載したコンシューマー向けGPU（RTX 3060 12GBなど）で7Bモデルを微調整できます。CPUのみまたは低スペックの場合は、AutoDLなどのクラウドGPUサービスを利用し、A100などのGPUを時間単位でレンタルすることをお勧めします。コストは低く抑えられます。また、より小さいモデルバージョン（1.5Bなど）を微調整することもでき、VRAM要件はわずか4GBです。
微調整後、モデルは元の能力を失いますか？
可能性があります。これは「破壊的忘却」と呼ばれます。防止策：1）過学習を避ける（エポック数を増やしすぎない）；2）元の汎用データと微調整データを混ぜてトレーニングする；3）学習率を小さくする；4）トレーニング中に定期的に汎用能力を評価する。劣化が見られた場合は、トレーニングエポック数を減らすか、汎用データの割合を増やしてください。
DeepSeek MoEモデルは微調整できますか？
はい。DeepSeek V2/V3などのMoEモデルもLoRA微調整をサポートしています。MoEアーキテクチャの利点は、各推論で一部のエキスパートのみがアクティブになるため、微調整時に特定のエキスパートをターゲットに最適化できることです。ただし、MoEモデルはパラメータ数が多いため、全パラメータ微調整のハードルは非常に高いです。LoRAを使用し、target_modulesにMoE固有のゲート層を含めることをお勧めします。DeepSeek公式GitHubリポジトリにはMoEモデルの微調整例が提供されています。
微調整したモデルは商用利用できますか？
はい。DeepSeekモデルはMITオープンソースライセンスで公開されているため、微調整したモデルは追加の許可なしで商用利用できます。ただし、以下の点に注意してください：1）トレーニングデータ自体に権利侵害の内容が含まれていないこと；2）他者がアノテーションしたデータセットを使用する場合は、そのデータセットのライセンスに従うこと；3）リリース時にDeepSeekモデルに基づいて微調整されたことを明記することをお勧めします。
その他のリソース
DeepSeek完全チュートリアルインデックス
以下は、初心者から上級者まで、ワンストップで学べるDeepSeek関連チュートリアルのすべてです。