PyTorch 転移学習

転移学習(Transfer Learning)とは、大規模データセットで事前学習されたモデルを、データ量が少ない新しいタスクに移して学習させる技術のことです。

これは今日のディープラーニング実践で最も広く使われている技術の1つです。ほとんどの場合、転移学習はゼロから学習するよりも効果が高く、速度が速く、必要なデータも少なくなります。


1. 転移学習の核となる考え方

深層ニューラルネットワークがImageNetで学習した特徴には汎用性があります:

  • 浅い層のネットワーク:汎用的な低レベル特徴を学習(エッジ、テクスチャ、色勾配)
  • 中間の層のネットワーク:汎用的な中レベル特徴を学習(形状、部品、テクスチャの組み合わせ)
  • 深い層のネットワーク:タスクに関連する高レベル特徴を学習(顔、車輪、文字)

これらの低・中レベル特徴はほとんどの視覚タスクに有効であり、再学習する必要はありません。

いつ転移学習を使うのか?

データ量ソースタスクとの類似度推奨される戦略
少ない(< 1000)高最後の分類ヘッドだけを置き換え、バックボーン全体を凍結する
少ない(< 1000)低浅い層をファインチューニングし、深い層は凍結する
中程度(1000〜10000)高ネットワーク全体を小さな学習率でファインチューニングする
中程度(1000〜10000)低深い層をファインチューニングし、浅い層は凍結する
多い(> 10000)任意すべてファインチューニングするか、ゼロから学習を検討する

3つの核となる戦略の比較

事前学習モデル(例:ResNet50)の階層構造は次の通りです:

  • Conv Layer 1~3(低レベル特徴:エッジ/テクスチャ):通常は凍結
  • Conv Layer 4~6(中レベル特徴:形状/部品):凍結は任意
  • Conv Layer 7~N(高レベル特徴:セマンティック情報):ファインチューニング
  • Classifier Head(分類ヘッド):置き換えて学習
┌─────────────────────────────────────────────────┐
│              预训练模型(如 ResNet50)             │
│  ┌──────────────────────────────────────────┐   │
│  │  Conv Layer 1~3(低级特征:边缘/纹理)      │  ← 通常冻结
│  ├──────────────────────────────────────────┤   │
│  │  Conv Layer 4~6(中级特征:形状/部件)      │  ← 可选冻结
│  ├──────────────────────────────────────────┤   │
│  │  Conv Layer 7~N(高级特征:语义信息)       │  ← 微调
│  ├──────────────────────────────────────────┤   │
│  │  Classifier Head(分类头)                 │  ← 替换 & 训练
│  └──────────────────────────────────────────┘   │
└─────────────────────────────────────────────────┘

2. 事前学習モデルの読み込み

PyTorchはtorchvision.modelsを通じて多数の公式事前学習モデルを提供しており、読み込みは非常に簡単です。

例

import torch
import torchvision.models as models

# 加载预训练模型(自动下载权重)
# PyTorch >= 0.13 推荐新写法:使用 weights 参数
from torchvision.models import ResNet50_Weights

model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)

# 旧写法(仍然有效,但会收到 deprecation 警告)
model = models.resnet50(pretrained=True)

# 不加载预训练权重(仅使用网络结构)
model = models.resnet50(weights=None)

モデル構造の確認

例

# 打印完整结构
print(model)

# 只查看最后几层(分类头)
print(model.fc)
# Linear(in_features=2048, out_features=1000, bias=True)

# 统计参数量
total_params    = sum(p.numel() for p in model.parameters())
trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
print(f"总参数量:   {total_params:,}")
print(f"可训练参数: {trainable_params:,}")

各モデルの分類ヘッドの名前

モデルによって分類ヘッドの属性名が異なるため、転移するときは対応する層を置き換える必要があります:

モデル分類ヘッド属性
ResNet / RegNetmodel.fc
VGG / AlexNetmodel.classifier[-1]
DenseNetmodel.classifier
EfficientNetmodel.classifier[-1]
MobileNetV2/V3model.classifier[-1]
ViT (Vision Transformer)model.heads.head
ConvNeXtmodel.classifier[-1]
Inception V3model.fc
Swin Transformermodel.head

3. 3つの転移戦略

3.1 戦略1:特徴抽出(全部凍結)

事前学習モデルの全パラメータを凍結し、新しく置き換えた分類ヘッドのみを学習します。

データ量が極めて少ない(数百枚)場合や、タスクがソースタスクと非常に似ている場合に適しています。

例

import torch
import torch.nn as nn
import torchvision.models as models
from torchvision.models import ResNet18_Weights

NUM_CLASSES = 5   # 対象タスクのクラス数

# Step 1:加载预训练模型
model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)

# Step 2:冻结所有参数
for param in model.parameters():
    param.requires_grad = False

# Step 3:分類ヘッドを置き換える(この部分のパラメータはデフォルトで requires_grad=True)
in_features = model.fc.in_features    # 512
model.fc = nn.Linear(in_features, NUM_CLASSES)

# 検証:分類ヘッドのみが訓練可能である
trainable = [(n, p.shape) for n, p in model.named_parameters() if p.requires_grad]
print(f"可训练层数: {len(trainable)}")
for name, shape in trainable:
    print(f"  {name}: {shape}")
# 输出:
#   fc.weight: torch.Size([5, 512])
#   fc.bias:   torch.Size([5])

# Step 4:优化器只传可训练参数(更高效)
optimizer = torch.optim.Adam(
    filter(lambda p: p.requires_grad, model.parameters()),
    lr=1e-3
)
# または同等の、より明確な書き方:
optimizer = torch.optim.Adam(model.fc.parameters(), lr=1e-3)

特徴抽出は最も簡単で最もよく使われる転移学習戦略であり、データ量が少ないシナリオに特に適しています。

3.2 戦略2: ファインチューニング

事前学習済みの層の全部または一部の凍結を解除し、小さめの学習率で全体を学習します。

データ量が中程度の場合や、タスクがソースタスクと異なる場合に適しています。

例

import torch
import torch.nn as nn
import torchvision.models as models

NUM_CLASSES = 10
model = models.resnet50(weights='IMAGENET1K_V2')

# 方式 A:全量微调(解冻所有层)
# 先冻结
for param in model.parameters():
    param.requires_grad = False

# 再解冻(等价于全量微调,此写法常用于逐步解冻场景)
for param in model.parameters():
    param.requires_grad = True

# 替换分类头
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

# 全量微调:主干用小学习率,头部用大学习率(见策略三)
optimizer = torch.optim.SGD(model.parameters(), lr=1e-4, momentum=0.9)


# 方式 B:解冻最后 N 层(部分微调)
model = models.resnet50(weights='IMAGENET1K_V2')

# 先全部冻结
for param in model.parameters():
    param.requires_grad = False

# layer4 と fc(ResNet の最後のブロックと分類ヘッド)のみを凍結解除する
for param in model.layer4.parameters():
    param.requires_grad = True

model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)  # fc 默认可训练

print("可训练参数:")
for name, param in model.named_parameters():
    if param.requires_grad:
        print(f"  {name}")

3.3 戦略3: 層ごとに異なる学習率

バックボーン(backbone)は小さな学習率(事前学習の知識を保持)、分類ヘッドは大きな学習率(新しいタスクに素早く適応)を使用します。

これは業界で最も一般的に使われるファインチューニング戦略で、総合的な効果が最も高いです。

例

import torch
import torch.nn as nn
import torchvision.models as models

NUM_CLASSES = 8
model = models.resnet50(weights='IMAGENET1K_V2')
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

# 方案一:两组学习率(主干 vs 头部)
optimizer = torch.optim.Adam([
    {'params': model.fc.parameters(),  'lr': 1e-3},     # 分类头:大学习率
    {'params': [p for n, p in model.named_parameters()  # 主干:小学习率
                if not n.startswith('fc')],
     'lr': 1e-5},
])


# 方案二:逐层递减学习率(最精细)
# 出力に近い層ほど、学習率が大きい
layer_groups = [
    (model.layer1, 1e-5),    # 最浅层,最小学习率
    (model.layer2, 3e-5),
    (model.layer3, 1e-4),
    (model.layer4, 3e-4),    # 最深主干层
    (model.fc,     1e-3),    # 分类头,最大学习率
]

param_groups = [
    {'params': layer.parameters(), 'lr': lr}
    for layer, lr in layer_groups
]
optimizer = torch.optim.Adam(param_groups)


# 方案三:逐步解冻(Gradual Unfreezing)
# 训练初期只训练头部,逐步解冻更多层(fastai 推荐)
model = models.resnet50(weights='IMAGENET1K_V2')
for param in model.parameters():
    param.requires_grad = False
model.fc = nn.Linear(model.fc.in_features, NUM_CLASSES)

def unfreeze_layers(model, num_layers):
    """解冻 ResNet 最后 num_layers 个 layer block"""
    layers = [model.layer4, model.layer3, model.layer2, model.layer1]
    for i in range(min(num_layers, len(layers))):
        for param in layers[i].parameters():
            param.requires_grad = True

# Epoch 1-5:只训练分类头
# Epoch 6-10:解冻 layer4
unfreeze_layers(model, num_layers=1)
# Epoch 11+:解冻更多层
unfreeze_layers(model, num_layers=3)

4. よく使われる事前学習モデル

4.1 画像分類モデル

例

import torchvision.models as models

# ResNet 系列(最经典,适合大多数任务)
resnet18  = models.resnet18(weights='IMAGENET1K_V1')   # 轻量,适合边缘设备
resnet50  = models.resnet50(weights='IMAGENET1K_V2')   # 均衡之选
resnet101 = models.resnet101(weights='IMAGENET1K_V2')  # 更强,更慢

# EfficientNet 系列(精度效率比极高)
effnet_b0 = models.efficientnet_b0(weights='IMAGENET1K_V1')  # 最轻量
effnet_b4 = models.efficientnet_b4(weights='IMAGENET1K_V1')  # 均衡
effnet_b7 = models.efficientnet_b7(weights='IMAGENET1K_V1')  # 最强

# Vision Transformer(大規模データ向けタスクの第一選択)
vit_b16 = models.vit_b_16(weights='IMAGENET1K_V1')    # ViT-Base/16
vit_l16 = models.vit_l_16(weights='IMAGENET1K_V1')    # ViT-Large/16

# MobileNet(モバイル/組み込み向けデプロイ)
mobilenet_v3 = models.mobilenet_v3_small(weights='IMAGENET1K_V1')

# ConvNeXt(CNNの現代的バージョン、性能はViTに近い)
convnext_t = models.convnext_tiny(weights='IMAGENET1K_V1')
convnext_b = models.convnext_base(weights='IMAGENET1K_V1')

主流モデルの性能比較(ImageNet Top-1 Acc):

モデルTop-1 Accパラメータ数推論速度適用シーン
ResNet-1869.8%11.7M非常に高速リソース制約、迅速なプロトタイピング
ResNet-5080.9%25.6M快汎用の第一選択
EfficientNet-B483.4%19.3M中精度と効率のバランス
ConvNeXt-Base84.1%88.6M中高精度CNN
ViT-B/1681.1%86.6M中大規模データのシーン
ViT-L/1685.1%307M慢最高精度

4.2 物体検出モデル

例

import torchvision.models.detection as detection

# Faster R-CNN(古典的な二段階検出器)
faster_rcnn = detection.fasterrcnn_resnet50_fpn(weights='DEFAULT')

# SSD(単一段階検出器、高速)
ssd = detection.ssd300_vgg16(weights='DEFAULT')

# RetinaNet
retinanet = detection.retinanet_resnet50_fpn(weights='DEFAULT')

# FCOS
fcos = detection.fcos_resnet50_fpn(weights='DEFAULT')

# Faster R-CNNの分類ヘッドを置き換える(新しいクラス数に適合)
from torchvision.models.detection.faster_rcnn import FastRCNNPredictor

NUM_CLASSES = 5 + 1   # 5つの目標クラス + 1つの背景クラス

faster_rcnn = detection.fasterrcnn_resnet50_fpn(weights='DEFAULT')
in_features = faster_rcnn.roi_heads.box_predictor.cls_score.in_features
faster_rcnn.roi_heads.box_predictor = FastRCNNPredictor(in_features, NUM_CLASSES)

4.3 テキストモデル(HuggingFace)

NLPタスクの転移学習は通常HuggingFace transformersライブラリを使用します:

例

# pip install transformers
from transformers import (
    BertForSequenceClassification,
    RobertaForSequenceClassification,
    AutoModelForSequenceClassification,
    AutoTokenizer,
)

NUM_CLASSES = 3

# BERT(テキスト分類の第一選択)
model = BertForSequenceClassification.from_pretrained(
    'bert-base-chinese',     # 中国語BERT
    num_labels=NUM_CLASSES
)
tokenizer = AutoTokenizer.from_pretrained('bert-base-chinese')

# RoBERTa(BERTの改良版、より高性能)
model = RobertaForSequenceClassification.from_pretrained(
    'roberta-base',
    num_labels=NUM_CLASSES
)

# 汎用ロード方法(モデルタイプを自動認識)
model = AutoModelForSequenceClassification.from_pretrained(
    'hfl/chinese-roberta-wwm-ext',    # 中国語RoBERTa
    num_labels=NUM_CLASSES
)

5. データ前処理と拡張

転移学習でImageNetの事前学習済み重みを使用する場合、事前学習と同じ正規化パラメータを使用する必要があります。そうしないと特徴分布が一致せず、効果が大幅に低下します。

例

from torchvision import transforms

# ImageNet標準の正規化パラメータ(すべてのtorchvision事前学習済みモデルに共通)
IMAGENET_MEAN = [0.485, 0.456, 0.406]
IMAGENET_STD  = [0.229, 0.224, 0.225]

# 訓練セット:データ拡張を含む
train_transforms = transforms.Compose([
    transforms.RandomResizedCrop(224),          # ランダムクロップしてリサイズ
    transforms.RandomHorizontalFlip(p=0.5),    # ランダムな水平反転
    transforms.ColorJitter(                    # 色のジッター
        brightness=0.2, contrast=0.2,
        saturation=0.2, hue=0.1
    ),
    transforms.RandomRotation(degrees=15),     # ランダム回転
    transforms.ToTensor(),
    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
])

# 検証/テストセット:ランダム拡張を行わない
val_transforms = transforms.Compose([
    transforms.Resize(256),                    # まず256にリサイズ
    transforms.CenterCrop(224),                # 次に224にセンタークロップ
    transforms.ToTensor(),
    transforms.Normalize(IMAGENET_MEAN, IMAGENET_STD),
])

# データセットのロード(ディレクトリ構造:root/class_name/img.jpg)
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader

train_dataset = ImageFolder(root='data/train', transform=train_transforms)
val_dataset   = ImageFolder(root='data/val',   transform=val_transforms)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True,
                          num_workers=4, pin_memory=True)
val_loader   = DataLoader(val_dataset,   batch_size=32, shuffle=False,
                          num_workers=4, pin_memory=True)

print(f"訓練サンプル数: {len(train_dataset)}")
print(f"クラスリスト: {train_dataset.classes}")
print(f"クラスマッピング: {train_dataset.class_to_idx}")

torchvision公式推奨の前処理を使う

例

# PyTorch >= 0.13:weightsオブジェクトから標準の前処理を直接取得でき、手動でパラメータを指定する必要はありません
from torchvision.models import ResNet50_Weights

weights   = ResNet50_Weights.IMAGENET1K_V2
model     = models.resnet50(weights=weights)
preprocess = weights.transforms()   # 対応する前処理パイプラインを自動的に返す

# preprocessにはResize(232)、CenterCrop(224)、Normalizeなどのステップが含まれています
# 訓練時はこれにデータ拡張を追加するだけでよい

ImageNetの正規化パラメータ [0.485, 0.456, 0.406] と [0.229, 0.224, 0.225] を使用する必要があります。そうしないと、事前学習済みの特徴が正しく一致しません。


6. 完全実践:画像二値分類

猫犬分類を例に、データ準備から訓練評価までの完全な転移学習フローを示します:

例

import os
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim.lr_scheduler import CosineAnnealingLR
from torchvision import models, transforms, datasets
from torch.utils.data import DataLoader, random_split
from torchvision.models import EfficientNet_B0_Weights

# 設定
DEVICE      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
NUM_CLASSES = 2
BATCH_SIZE  = 32
EPOCHS      = 20
BASE_LR     = 1e-3
DATA_DIR    = 'data/cats_and_dogs'

# データ準備
train_tfm = transforms.Compose([
    transforms.RandomResizedCrop(224),
    transforms.RandomHorizontalFlip(),
    transforms.ColorJitter(brightness=0.3, contrast=0.3),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],
                         [0.229, 0.224, 0.225]),
])
val_tfm = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize([0.485, 0.456, 0.406],
                         [0.229, 0.224, 0.225]),
])

full_dataset = datasets.ImageFolder(DATA_DIR, transform=train_tfm)

n_val   = int(len(full_dataset) * 0.2)
n_train = len(full_dataset) - n_val
train_set, val_set = random_split(full_dataset, [n_train, n_val])
val_set.dataset = datasets.ImageFolder(DATA_DIR, transform=val_tfm)  # valのtransformを置き換える

train_loader = DataLoader(train_set, BATCH_SIZE, shuffle=True,
                          num_workers=4, pin_memory=True)
val_loader   = DataLoader(val_set,   BATCH_SIZE, shuffle=False,
                          num_workers=4, pin_memory=True)

# 転移モデルを構築
weights = EfficientNet_B0_Weights.IMAGENET1K_V1
model   = models.efficientnet_b0(weights=weights)

# バックボーンを凍結
for param in model.parameters():
    param.requires_grad = False

# 分類ヘッドを置き換える(EfficientNet-B0のヘッド構造)
in_features = model.classifier[1].in_features  # 1280
model.classifier = nn.Sequential(
    nn.Dropout(p=0.2, inplace=True),
    nn.Linear(in_features, NUM_CLASSES),
)

model = model.to(DEVICE)

# オプティマイザ:層別学習率
optimizer = optim.Adam([
    {'params': model.classifier.parameters(), 'lr': BASE_LR},
    {'params': model.features.parameters(),   'lr': BASE_LR * 0.1},
])
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
scheduler = CosineAnnealingLR(optimizer, T_max=EPOCHS, eta_min=1e-6)

# 訓練と検証関数
def train_epoch(model, loader, optimizer, criterion):
    model.train()
    total_loss, correct = 0.0, 0
    for imgs, labels in loader:
        imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
        optimizer.zero_grad()
        outputs = model(imgs)
        loss    = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        total_loss += loss.item() * imgs.size(0)
        correct    += (outputs.argmax(1) == labels).sum().item()
    n = len(loader.dataset)
    return total_loss / n, correct / n

def eval_epoch(model, loader, criterion):
    model.eval()
    total_loss, correct = 0.0, 0
    with torch.no_grad():
        for imgs, labels in loader:
            imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
            outputs = model(imgs)
            loss    = criterion(outputs, labels)
            total_loss += loss.item() * imgs.size(0)
            correct    += (outputs.argmax(1) == labels).sum().item()
    n = len(loader.dataset)
    return total_loss / n, correct / n

# 段階的訓練
print("=== 段階1:分類ヘッドのみ訓練(Epoch 1-5)===")
best_acc = 0.0

for epoch in range(1, EPOCHS + 1):
    # 5エポック目でバックボーンを凍結解除し、全量ファインチューニング段階に入る
    if epoch == 6:
        print("\n=== 段階2:バックボーンを凍結解除して全量ファインチューニング(Epoch 6-20)===")
        for param in model.features.parameters():
            param.requires_grad = True

    train_loss, train_acc = train_epoch(model, train_loader, optimizer, criterion)
    val_loss,   val_acc   = eval_epoch(model,  val_loader,   criterion)
    scheduler.step()

    print(f"Epoch {epoch:2d}/{EPOCHS} | "
          f"Train Loss: {train_loss:.4f}, Acc: {train_acc:.4f} | "
          f"Val Loss: {val_loss:.4f}, Acc: {val_acc:.4f} | "
          f"LR: {scheduler.get_last_lr()[0]:.2e}")

    if val_acc > best_acc:
        best_acc = val_acc
        torch.save(model.state_dict(), 'best_model.pth')
        print(f" ✓ 最適モデルを保存 Acc={best_acc:.4f}")

print(f"\n訓練完了、最適な検証精度: {best_acc:.4f}")

推論と予測

例

from PIL import Image

# 最適モデルをロード
model.load_state_dict(torch.load('best_model.pth', map_location=DEVICE))
model.eval()

# 単一画像を予測
def predict(image_path, model, class_names):
    img = Image.open(image_path).convert('RGB')
    tensor = val_tfm(img).unsqueeze(0).to(DEVICE)  # (1, 3, 224, 224)

    with torch.inference_mode():
        logits = model(tensor)
        probs  = torch.softmax(logits, dim=1)[0]
        pred   = probs.argmax().item()

    for cls, prob in zip(class_names, probs.tolist()):
        print(f"  {cls}: {prob:.4f}")
    print(f"予測結果: {class_names[pred]}")
    return class_names[pred]

class_names = train_set.dataset.classes  # ['cat', 'dog']
predict('test_cat.jpg', model, class_names)

7. 完全実践:テキスト分類(BERT)

例

# pip install transformers datasets
import torch
import torch.nn as nn
from torch.utils.data import Dataset, DataLoader
from transformers import (
    BertTokenizer,
    BertForSequenceClassification,
    AdamW,
    get_linear_schedule_with_warmup,
)

DEVICE      = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
MODEL_NAME  = 'bert-base-chinese'
NUM_CLASSES = 3       # 感情分類:ポジティブ/ニュートラル/ネガティブ
MAX_LEN     = 128
BATCH_SIZE  = 16
EPOCHS      = 5
LR          = 2e-5    # BERTファインチューニングの推奨学習率範囲:1e-5 ~ 5e-5

# カスタムDataset
class SentimentDataset(Dataset):
    def __init__(self, texts, labels, tokenizer, max_len):
        self.texts     = texts
        self.labels    = labels
        self.tokenizer = tokenizer
        self.max_len   = max_len

    def __len__(self):
        return len(self.texts)

    def __getitem__(self, idx):
        encoding = self.tokenizer(
            self.texts[idx],
            max_length=self.max_len,
            padding='max_length',
            truncation=True,
            return_tensors='pt',
        )
        return {
            'input_ids':      encoding['input_ids'].squeeze(0),
            'attention_mask': encoding['attention_mask'].squeeze(0),
            'label':          torch.tensor(self.labels[idx], dtype=torch.long),
        }

# BERTの事前学習済みモデルをロード
tokenizer = BertTokenizer.from_pretrained(MODEL_NAME)
model     = BertForSequenceClassification.from_pretrained(
    MODEL_NAME,
    num_labels=NUM_CLASSES,
    hidden_dropout_prob=0.1,
)
model = model.to(DEVICE)

# 下部N層を凍結(オプション)
# BERT-baseは12層のTransformerを持ち、計算を節約するために最初の数層を凍結できる
FREEZE_LAYERS = 6   # 最初の6層を凍結

for i, layer in enumerate(model.bert.encoder.layer):
    if i < FREEZE_LAYERS:
        for param in layer.parameters():
            param.requires_grad = False

print(f"前{FREEZE_LAYERS}層を凍結し、パラメータ更新を約{FREEZE_LAYERS/12*100:.0f}%削減")

# データロード
# サンプルデータ(実際には実際のデータセットに置き換える)
train_texts  = ["この映画は素晴らしい!", "サービスがひどく、失望した", "まあまあ、特に何もない"]
train_labels = [2, 0, 1]  # 0:ネガティブ 1:ニュートラル 2:ポジティブ

train_dataset = SentimentDataset(train_texts, train_labels, tokenizer, MAX_LEN)
train_loader  = DataLoader(train_dataset, BATCH_SIZE, shuffle=True)

# オプティマイザとスケジューラ
# BERT標準:AdamW + 線形warmup
no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped = [
    {'params': [p for n, p in model.named_parameters()
                if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
    {'params': [p for n, p in model.named_parameters()
                if     any(nd in n for nd in no_decay)], 'weight_decay': 0.0},
]
optimizer = AdamW(optimizer_grouped, lr=LR)

total_steps   = len(train_loader) * EPOCHS
warmup_steps  = int(total_steps * 0.1)   # 10%のステップをウォームアップに使用
scheduler = get_linear_schedule_with_warmup(
    optimizer,
    num_warmup_steps=warmup_steps,
    num_training_steps=total_steps,
)

# 訓練ループ
for epoch in range(1, EPOCHS + 1):
    model.train()
    total_loss, correct = 0.0, 0

    for batch in train_loader:
        input_ids      = batch['input_ids'].to(DEVICE)
        attention_mask = batch['attention_mask'].to(DEVICE)
        labels         = batch['label'].to(DEVICE)

        optimizer.zero_grad()
        outputs = model(input_ids=input_ids,
                        attention_mask=attention_mask,
                        labels=labels)

        loss   = outputs.loss           # BERT内部でCE Lossを計算済み
        logits = outputs.logits

        loss.backward()
        # BERTファインチューニング標準:勾配クリッピング、勾配爆発を防止
        nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
        optimizer.step()
        scheduler.step()

        total_loss += loss.item()
        correct    += (logits.argmax(1) == labels).sum().item()

    avg_loss = total_loss / len(train_loader)
    acc      = correct / len(train_dataset)
    print(f"Epoch {epoch}/{EPOCHS} | Loss: {avg_loss:.4f} | Acc: {acc:.4f}")

# 推論
def predict_sentiment(text, model, tokenizer, id2label):
    model.eval()
    encoding = tokenizer(text, max_length=MAX_LEN, padding='max_length',
                         truncation=True, return_tensors='pt')
    with torch.inference_mode():
        outputs = model(
            input_ids      = encoding['input_ids'].to(DEVICE),
            attention_mask = encoding['attention_mask'].to(DEVICE),
        )
    pred = outputs.logits.argmax(1).item()
    return id2label[pred]

id2label = {0: 'ネガティブ', 1: 'ニュートラル', 2: 'ポジティブ'}
print(predict_sentiment("この製品の品質は本当に良い!", model, tokenizer, id2label))

8. モデル構造の修正テクニック

分類ヘッドを置き換える一般的な方法

例

import torch.nn as nn
import torchvision.models as models

def build_transfer_model(arch, num_classes, pretrained=True, dropout=0.5):
    """
汎用転移モデル構築関数。分類ヘッドを自動認識して置き換える
対応: resnet, efficientnet, densenet, mobilenet, vit, convnext
    """

    weights = 'IMAGENET1K_V1' if pretrained else None
    model   = getattr(models, arch)(weights=weights)
    name    = arch.lower()

    if 'resnet' in name or 'resnext' in name or 'inception' in name:
        in_f = model.fc.in_features
        model.fc = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(in_f, num_classes)
        )

    elif 'efficientnet' in name or 'mobilenet' in name or 'convnext' in name:
        in_f = model.classifier[-1].in_features
        model.classifier[-1] = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(in_f, num_classes)
        )

    elif 'densenet' in name:
        in_f = model.classifier.in_features
        model.classifier = nn.Linear(in_f, num_classes)

    elif 'vit' in name or 'swin' in name:
        in_f = model.heads.head.in_features
        model.heads.head = nn.Linear(in_f, num_classes)

    else:
        raise ValueError(f"サポートされていないアーキテクチャ: {arch}")

    return model


# 使用例
model_resnet  = build_transfer_model('resnet50',        num_classes=10)
model_effnet  = build_transfer_model('efficientnet_b3', num_classes=10)
model_vit     = build_transfer_model('vit_b_16',        num_classes=10)

中間特徴抽出層の追加

例

import torch
import torch.nn as nn
import torchvision.models as models

class TransferWithAttention(nn.Module):
    """事前学習済みバックボーンの後にカスタムアテンションモジュールと分類ヘッドを接続する"""
    def __init__(self, num_classes, dropout=0.5):
        super().__init__()
        backbone = models.resnet50(weights='IMAGENET1K_V2')

        # 元の分類ヘッドを除去し、feature extractorを保持
        self.backbone  = nn.Sequential(*list(backbone.children())[:-1])
        self.feat_dim  = 2048   # ResNet50の特徴次元

        # カスタムアテンションゲート
        self.attention = nn.Sequential(
            nn.Linear(self.feat_dim, 512),
            nn.Tanh(),
            nn.Linear(512, 1),
            nn.Sigmoid()
        )

        # 分類ヘッド
        self.classifier = nn.Sequential(
            nn.Dropout(dropout),
            nn.Linear(self.feat_dim, 256),
            nn.ReLU(),
            nn.Linear(256, num_classes),
        )

    def forward(self, x):
        feat   = self.backbone(x).flatten(1)          # (N, 2048)
        weight = self.attention(feat)                  # (N, 1)
        feat   = feat * weight                         # 重み付き特徴
        return self.classifier(feat)

9. 転移学習のベストプラクティス

学習率の選択

例

# バックボーン(事前学習層)の学習率
# 通常ヘッド学習率の1/10 ~ 1/100に設定
backbone_lr = 1e-5   # 保守的戦略、データ量が少ない場合に推奨
head_lr     = 1e-3   # 新しい層はランダム初期化から始まるため、より大きな学習率が必要

# BERT / ViTなどのTransformerの学習率
# このような大規模モデルは学習率に非常に敏感で、範囲を超えると事前学習済みの知識を壊す可能性がある
bert_lr = 2e-5        # 推奨範囲:1e-5 ~ 5e-5

よくある問題と解決策

例

# 問題1:GPUメモリ不足
# 解決策1:バッチサイズを減らす
# 解決策2:勾配チェックポイントを使用(時間と空間のトレードオフ)
from torch.utils.checkpoint import checkpoint_sequential
model.features = lambda x: checkpoint_sequential(model.features, 4, x)

# 解決策3:より多くの層を凍結(逆伝播の計算量を削減)

# 問題2:訓練セットの精度が高く、検証セットは低い(過学習)
# 解決策1:データ拡張を強化
# 解決策2:Dropoutを増加
model.classifier = nn.Sequential(nn.Dropout(0.5), nn.Linear(in_f, num_classes))
# 解決策3:ラベルスムージングを使用
criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
# 解決策4:より多くのバックボーン層を凍結し、学習可能なパラメータを減らす

# 問題3:訓練が不安定、Lossが振動
# 解決策1:学習率を下げる(半分にして再試行)
# 解決策2:warmup(ウォームアップ)を追加
# 解決策3:勾配クリッピング
nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
# 解決策4:オプティマイザを変更(Adam → AdamW)

# 問題4:正規化パラメータが不一致
# エラー:カスタム正規化を使用しており、事前学習と一致しない
transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
# 正解:ImageNet の平均と標準偏差を必ず使用する
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

全体戦略の早見表

問題推奨される方法
データ量 < 500すべての層を凍結し、分類ヘッドのみ訓練
データ量 500〜2000前 2/3 を凍結し、後 1/3 をファインチューニング
データ量 2000〜10000全層ファインチューニング、バックボーンは 1e-5、ヘッドは 1e-3
データ量 > 10000全層ファインチューニング、より大きな学習率またはスクラッチからの訓練を検討
訓練速度が遅い最初に数エポック凍結して訓練してから解凍;AMP混合精度を使用
性能が頭打ちより大きく/より新しいバックボーンに変更;ConvNeXt / ViT を試す
モデルを本番展開する場合EfficientNet-B0 / MobileNetV3 などの軽量モデルを優先的に選択
中国語NLPタスクBERT-base-chinese または chinese-roberta-wwm-ext

推奨される完全な学習戦略

第1フェーズ(エポック 1〜N/4):

  • バックボーンを凍結し、分類ヘッドのみ訓練
  • 大きめの学習率(1e-3)を使用し、ヘッドパラメータを素早く収束させる

第2フェーズ(エポック N/4〜N):

  • バックボーンを解凍し、全層ファインチューニング
  • バックボーンは小さな学習率(1e-5)、ヘッドはそのまま(1e-3)
  • コサインアニーリングまたは ReduceLROnPlateau と組み合わせる

保存戦略:

  • 検証セットの指標が最良のチェックポイントのみ保存
  • 同時に model / optimizer / scheduler の状態を保存
その他の拡張