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 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 / RegNet | model.fc |
| VGG / AlexNet | model.classifier[-1] |
| DenseNet | model.classifier |
| EfficientNet | model.classifier[-1] |
| MobileNetV2/V3 | model.classifier[-1] |
| ViT (Vision Transformer) | model.heads.head |
| ConvNeXt | model.classifier[-1] |
| Inception V3 | model.fc |
| Swin Transformer | model.head |
3. 3つの転移戦略
3.1 戦略1:特徴抽出(全部凍結)
事前学習モデルの全パラメータを凍結し、新しく置き換えた分類ヘッドのみを学習します。
データ量が極めて少ない(数百枚)場合や、タスクがソースタスクと非常に似ている場合に適しています。
例
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.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.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 画像分類モデル
例
# 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-18 | 69.8% | 11.7M | 非常に高速 | リソース制約、迅速なプロトタイピング |
| ResNet-50 | 80.9% | 25.6M | 快 | 汎用の第一選択 |
| EfficientNet-B4 | 83.4% | 19.3M | 中 | 精度と効率のバランス |
| ConvNeXt-Base | 84.1% | 88.6M | 中 | 高精度CNN |
| ViT-B/16 | 81.1% | 86.6M | 中 | 大規模データのシーン |
| ViT-L/16 | 85.1% | 307M | 慢 | 最高精度 |
4.2 物体検出モデル
例
# 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ライブラリを使用します:
例
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の事前学習済み重みを使用する場合、事前学習と同じ正規化パラメータを使用する必要があります。そうしないと特徴分布が一致せず、効果が大幅に低下します。
例
# 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公式推奨の前処理を使う
例
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 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}")
推論と予測
例
# 最適モデルをロード
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)
例
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 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.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:バッチサイズを減らす
# 解決策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 の状態を保存