🧠 0からLLM — 目指せDeepSeek

ステップ1: SentencePieceで日本語トークナイザー作成

日本語コーパスを用意し、SentencePieceでBPEモデルを学習します。

pip install sentencepiece

# train_tokenizer.py
import sentencepiece as spm

spm.SentencePieceTrainer.train(
    input='japanese_corpus.txt',  # 学習テキスト（1行1文推奨）
    model_prefix='ja_tokenizer',   # 出力ファイル名
    vocab_size=32000,              # 語彙サイズ（32k〜64kが一般的）
    character_coverage=0.9999,     # 日本語は0.9999以上推奨
    model_type='bpe',              # BPEを使用
    pad_id=3,
    bos_id=1,
    eos_id=2,
    unk_id=0,
)

# 使用例
sp = spm.SentencePieceProcessor()
sp.load('ja_tokenizer.model')
tokens = sp.encode('東京でラーメンを食べた', out_type=str)
# ['▁東京', 'で', 'ラーメン', 'を', '食べた']  ← 自然な分割

ステップ2: HuggingFaceから日本語コーパスを取得

pip install datasets

from datasets import load_dataset

# 日本語Wikipediaを取得（最もクリーンなコーパス）
dataset = load_dataset('wikipedia', '20231101.ja', split='train')
# 約182万記事、約3GB

# より大規模なWebコーパス
dataset = load_dataset('mc4', 'ja', split='train', streaming=True)
# ストリーミングで大容量を扱える

# テキストを1ファイルに保存
with open('corpus.txt', 'w', encoding='utf-8') as f:
    for item in dataset:
        f.write(item['text'].replace('\n', ' ') + '\n')

ステップ3: PyTorchでTransformerを実装（核心部分）

import torch
import torch.nn as nn
import math

class CausalSelfAttention(nn.Module):
    def __init__(self, d_model, n_heads, max_len=2048):
        super().__init__()
        assert d_model % n_heads == 0
        self.n_heads = n_heads
        self.d_head = d_model // n_heads
        self.qkv = nn.Linear(d_model, 3 * d_model, bias=False)
        self.proj = nn.Linear(d_model, d_model, bias=False)
        # Causal mask（未来のトークンを見ない）
        mask = torch.tril(torch.ones(max_len, max_len))
        self.register_buffer('mask', mask)

    def forward(self, x):
        B, T, C = x.shape
        q, k, v = self.qkv(x).split(C, dim=2)
        q = q.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        k = k.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        v = v.view(B, T, self.n_heads, self.d_head).transpose(1, 2)
        scale = 1.0 / math.sqrt(self.d_head)
        att = (q @ k.transpose(-2, -1)) * scale
        att = att.masked_fill(self.mask[:T, :T] == 0, float('-inf'))
        att = att.softmax(dim=-1)
        return (att @ v).transpose(1, 2).contiguous().view(B, T, C)

class TransformerBlock(nn.Module):
    def __init__(self, d_model, n_heads, ffn_mult=4):
        super().__init__()
        self.ln1 = nn.LayerNorm(d_model)
        self.attn = CausalSelfAttention(d_model, n_heads)
        self.ln2 = nn.LayerNorm(d_model)
        self.ffn = nn.Sequential(
            nn.Linear(d_model, ffn_mult * d_model),
            nn.GELU(),
            nn.Linear(ffn_mult * d_model, d_model),
        )

    def forward(self, x):
        x = x + self.attn(self.ln1(x))   # Attention + 残差接続
        x = x + self.ffn(self.ln2(x))    # FFN + 残差接続
        return x

class GPT(nn.Module):
    def __init__(self, vocab_size, d_model=768, n_heads=12, n_layers=12, max_len=2048):
        super().__init__()
        self.tok_emb = nn.Embedding(vocab_size, d_model)
        self.pos_emb = nn.Embedding(max_len, d_model)
        self.blocks = nn.Sequential(*[TransformerBlock(d_model, n_heads) for _ in range(n_layers)])
        self.ln_f = nn.LayerNorm(d_model)
        self.head = nn.Linear(d_model, vocab_size, bias=False)

    def forward(self, idx):
        B, T = idx.shape
        pos = torch.arange(T, device=idx.device)
        x = self.tok_emb(idx) + self.pos_emb(pos)
        x = self.blocks(x)
        x = self.ln_f(x)
        return self.head(x)

# 125Mパラメータ構成: d_model=768, n_heads=12, n_layers=12
model = GPT(vocab_size=32000, d_model=768, n_heads=12, n_layers=12)

ステップ4: 学習ループ（AdamW + cosine schedule）

import torch
from torch.optim.lr_scheduler import CosineAnnealingLR

optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, weight_decay=0.1)
scheduler = CosineAnnealingLR(optimizer, T_max=10000, eta_min=3e-5)

model.train()
for step in range(max_steps):
    # Gradient Accumulation（メモリ節約）
    for micro_step in range(grad_accum_steps):
        x, y = get_batch()          # (B, T) のトークン列
        logits = model(x)           # (B, T, vocab_size)
        loss = F.cross_entropy(logits.view(-1, vocab_size), y.view(-1))
        loss = loss / grad_accum_steps
        loss.backward()

    # 勾配クリッピング（学習安定化）
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
    optimizer.step()
    scheduler.step()
    optimizer.zero_grad()

    if step % 100 == 0:
        ppl = torch.exp(loss * grad_accum_steps).item()
        print(f"step {step}: loss={loss.item()*grad_accum_steps:.4f}, ppl={ppl:.1f}")

ステップ1: 必要なパッケージのインストール

pip install transformers datasets accelerate peft trl bitsandbytes
pip install flash-attn --no-build-isolation  # 高速Attention（CUDA対応GPU必須）

ステップ2: 4bit量子化でモデルをロード

from transformers import AutoTokenizer, AutoModelForCausalLM, BitsAndBytesConfig
import torch

model_id = "meta-llama/Llama-3.1-8B"  # HuggingFaceのモデルID（要Meta申請）

# 4bit量子化の設定
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",         # NormalFloat4が精度と速度のバランス最良
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,    # さらにメモリ節約（推奨）
)

tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(
    model_id,
    quantization_config=bnb_config,
    device_map="auto",                 # 自動でGPU/CPUに配置
)

ステップ3: LoRAアダプタを設定

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training

# k-bit学習の準備（量子化モデルに必要）
model = prepare_model_for_kbit_training(model)

lora_config = LoraConfig(
    r=16,                              # LoRAのランク（高いほど高精度だがメモリ増加）
    lora_alpha=32,                     # スケールファクタ (通常 r*2)
    target_modules=["q_proj", "v_proj", "k_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()
# trainable params: 約40M || all params: 8B || trainable%: 0.5%

ステップ4: 日本語指示データの準備（Alpaca形式）

from datasets import load_dataset

# 日本語指示データセットをロード
dataset = load_dataset("kunishou/databricks-dolly-15k-ja", split="train")

# Alpaca形式のプロンプトテンプレート
def format_instruction(example):
    if example.get("input"):
        return f"""### 指示:
{example['instruction']}

### 入力:
{example['input']}

### 回答:
{example['output']}"""
    else:
        return f"""### 指示:
{example['instruction']}

### 回答:
{example['output']}"""

dataset = dataset.map(lambda x: {'"text": format_instruction(x)})

# ShareGPT形式（マルチターン会話）の場合
# {'conversations": [{'from": "human", "value": "質問"}, {'from": "gpt", "value": "回答"}]}

ステップ5: SFTTrainerで学習実行

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./llama3-ja-lora",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,    # 実効バッチサイズ = 2*8 = 16
    learning_rate=2e-4,
    lr_scheduler_type="cosine",
    warmup_ratio=0.05,
    fp16=True,                         # fp16混合精度学習
    logging_steps=10,
    save_strategy="epoch",
    max_seq_length=2048,
    report_to="wandb",                 # wandbでログ管理（オプション）
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset,
    dataset_text_field="text",
    tokenizer=tokenizer,
)

trainer.train()
trainer.save_model("./llama3-ja-lora-final")

（応用）ステップ6: DPOでアラインメント

SFT後にDPO（Direct Preference Optimization）を適用すると、より人間の好みに沿った回答を生成するようになります。

from trl import DPOTrainer, DPOConfig

# DPO用データ形式:
# {'prompt": "質問", "chosen": "良い回答", "rejected": "悪い回答"}
dpo_dataset = load_dataset("your-dpo-dataset")

dpo_config = DPOConfig(
    beta=0.1,                          # KLペナルティ係数
    output_dir="./llama3-ja-dpo",
    num_train_epochs=1,
    per_device_train_batch_size=2,
    learning_rate=5e-5,
)

dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,                    # peft使用時はNoneでOK
    args=dpo_config,
    train_dataset=dpo_dataset,
    tokenizer=tokenizer,
)
dpo_trainer.train()

ステップ1: モデルのダウンロード

# HuggingFace CLIでダウンロード（約30GB）
pip install huggingface_hub

huggingface-cli download deepseek-ai/DeepSeek-V2-Lite \
  --local-dir ./DeepSeek-V2-Lite \
  --local-dir-use-symlinks False

# Pythonで確認
from transformers import AutoTokenizer, AutoModelForCausalLM
tokenizer = AutoTokenizer.from_pretrained("./DeepSeek-V2-Lite")
model = AutoModelForCausalLM.from_pretrained(
    "./DeepSeek-V2-Lite",
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True           # DeepSeekはtrust_remote_code必須
)

ステップ2: MoE構造の確認

# モデル構造の確認
print(model.config)
# num_experts_per_tok: 6   ← Top-6 Expert選択
# n_routed_experts: 64     ← 計64個のExpert（うち共有Expert 2個）
# moe_intermediate_size: 1408

# Expert数の確認
for name, module in model.named_modules():
    if 'expert' in name.lower():
        print(f"{name}: {type(module).__name__}")

ステップ3: 日本語データでファインチューニング

MoEモデルのLoRAは通常モデルと同じ手順で可能です。ただしRouterはLoRA対象外にすること。

from peft import LoraConfig, get_peft_model

lora_config = LoraConfig(
    r=8,
    lora_alpha=16,
    # MoEのExpert内のLinear層を対象に（Routerは除外）
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
    lora_dropout=0.05,
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)

# DeepSpeed ZeRO-2で2GPU学習
# accelerate launch --num_processes=2 train.py

MoE特有の設定: 負荷分散ロス（Load Balancing Loss）

MoEの学習では特定のExpertに処理が偏る「Expertの崩壊」が起きやすい。 負荷分散ロスを追加することで全Expertが均等に使われるよう制御する。

# DeepSeek-V2の設定ファイル（config.json）
# "aux_loss_alpha": 0.001  ← 負荷分散ロスの係数
# この値が小さすぎると偏りが発生、大きすぎると性能低下

# 学習時のロス確認
# total_loss = ce_loss + aux_loss_alpha * load_balance_loss