# HuggingFace Transformersのインストール # Google Colabでは最初から入っていることが多いが、 # 最新版にするためにインストールを実行 !pip install transformers torch torchvision # バージョン確認 import transformers print(f”transformers version: {transformers.__version__}”)

# =================================================== # 最も簡単な方法：pipeline # =================================================== from transformers import pipeline from PIL import Image # 1. 画像分類パイプラインを作成 # model: 使用するモデル名（Model Hubから） # 初回実行時にモデルが自動ダウンロードされる classifier = pipeline( “image-classification”, # タスクの種類 model=”google/vit-base-patch16-224″ # モデル名 ) # 2. サンプル画像をダウンロード（テスト用） import requests from io import BytesIO url = “https://upload.wikimedia.org/wikipedia/commons/thumb/3/3a/Cat03.jpg/1200px-Cat03.jpg” response = requests.get(url) image = Image.open(BytesIO(response.content)) # 3. 推論実行 # top_k: 上位何件の予測を返すか results = classifier(image, top_k=5) # 4. 結果を表示 print(“Top 5 Predictions:”) for result in results: print(f” {result[‘label’]}: {result[‘score’]*100:.2f}%”)

# =================================================== # 詳細な制御：processor + model # =================================================== from transformers import ViTImageProcessor, ViTForImageClassification from PIL import Image import torch # =================================================== # 1. モデルとプロセッサのロード # =================================================== # モデル名を指定 # google/vit-base-patch16-224: # – google: 提供元 # – vit-base: モデルサイズ（base = 86M パラメータ） # – patch16: パッチサイズ（16×16） # – 224: 入力画像サイズ（224×224） model_name = “google/vit-base-patch16-224″ # ViTImageProcessor: 画像の前処理を担当 # – リサイズ（224×224） # – 正規化（ImageNetの平均・標準偏差） # – テンソル変換 processor = ViTImageProcessor.from_pretrained(model_name) # ViTForImageClassification: 分類用ViTモデル # – Transformer Encoder + 分類ヘッド # – ImageNetの1000クラス分類用 model = ViTForImageClassification.from_pretrained(model_name) # 評価モードに設定（Dropout無効化、BatchNorm固定） model.eval() # GPUが使える場合はGPUに転送 device = torch.device(‘cuda’ if torch.cuda.is_available() else ‘cpu’) model = model.to(device) print(f”モデル: {model_name}”) print(f”クラス数: {model.config.num_labels}”) print(f”デバイス: {device}”)

# =================================================== # 2. 画像の読み込みと前処理 # =================================================== # 画像を読み込み（PILイメージとして） # convert(‘RGB’): 必ずRGB形式に変換（グレースケールやRGBAの場合があるため） image = Image.open(‘cat.jpg’).convert(‘RGB’) # 前処理を実行 # processor(): 画像をモデルの入力形式に変換 # – リサイズ: 224×224 # – 正規化: (pixel – mean) / std # – テンソル化: PILイメージ → PyTorchテンソル # return_tensors=”pt”: PyTorchテンソルで返す（”tf”ならTensorFlow） inputs = processor(images=image, return_tensors=”pt”) # GPUに転送（モデルと同じデバイスに） inputs = {k: v.to(device) for k, v in inputs.items()} print(f”入力テンソルのshape: {inputs[‘pixel_values’].shape}”) print(f”入力テンソルのデバイス: {inputs[‘pixel_values’].device}”)

# =================================================== # 3. 推論の実行 # =================================================== # torch.no_grad(): 勾配計算を無効化 # – 推論時は勾配不要（訓練時のみ必要） # – メモリ使用量削減、処理速度向上 with torch.no_grad(): # モデルに入力を渡して出力を取得 # **inputs: 辞書を展開して渡す（pixel_values=…） outputs = model(**inputs) # outputs.logits: 分類のロジット（softmax前の値） # shape: (batch_size, num_classes) = (1, 1000) logits = outputs.logits # softmaxで確率に変換 # dim=-1: 最後の次元（クラス次元）に対してsoftmax probs = torch.softmax(logits, dim=-1) print(f”ロジットのshape: {logits.shape}”) print(f”確率の合計: {probs.sum().item():.4f}”) # 1.0になるはず

# =================================================== # 4. 結果の取得と表示 # =================================================== # Top-5の確率とインデックスを取得 # torch.topk: 上位k個の値とインデックスを返す top5_prob, top5_idx = torch.topk(probs, 5, dim=-1) # クラスIDからクラス名への変換辞書を取得 # model.config.id2label: {0: “tench”, 1: “goldfish”, …} id2label = model.config.id2label # 結果を表示 print(“\nTop 5 Predictions:”) print(“-” * 40) for i in range(5): # .item(): テンソルから Python の数値を取り出す class_id = top5_idx[0][i].item() class_name = id2label[class_id] prob = top5_prob[0][i].item() print(f”{i+1}. {class_name}”) print(f” 確率: {prob*100:.2f}%”) print(f” クラスID: {class_id}”)

# =================================================== # ファインチューニングの実装 # =================================================== # 必要なライブラリのインポート from transformers import ViTImageProcessor, ViTForImageClassification from transformers import TrainingArguments, Trainer from torch.utils.data import Dataset import torch from PIL import Image import os from sklearn.metrics import accuracy_score, precision_recall_fscore_support # =================================================== # 1. カスタムデータセットクラスの定義 # =================================================== class CustomImageDataset(Dataset): “”” カスタム画像データセット PyTorchのDatasetクラスを継承 __len__と__getitem__を実装する必要がある “”” def __init__(self, image_paths, labels, processor): “”” Args: image_paths: 画像ファイルパスのリスト labels: 対応するラベルのリスト（0, 1, 2, …） processor: ViTImageProcessor（前処理用） “”” self.image_paths = image_paths self.labels = labels self.processor = processor def __len__(self): “””データセットのサイズを返す””” return len(self.image_paths) def __getitem__(self, idx): “”” idx番目のデータを返す Returns: dict: {‘pixel_values’: テンソル, ‘labels’: ラベル} “”” # 画像を読み込み image = Image.open(self.image_paths[idx]).convert(‘RGB’) # 前処理を適用 inputs = self.processor(images=image, return_tensors=”pt”) # バッチ次元を削除（Trainerが後で追加する） # (1, 3, 224, 224) → (3, 224, 224) pixel_values = inputs[‘pixel_values’].squeeze(0) return { ‘pixel_values’: pixel_values, ‘labels’: torch.tensor(self.labels[idx], dtype=torch.long) }

# =================================================== # 2. データの準備 # =================================================== # 実際のプロジェクトでは、以下のようにファイルパスとラベルを準備 # ここでは例として構造を示す # データディレクトリの構造: # data/ # train/ # dog/ # img1.jpg # img2.jpg # … # cat/ # img1.jpg # img2.jpg # … # val/ # dog/ # … # cat/ # … def load_dataset_paths(data_dir, class_names): “”” ディレクトリ構造からファイルパスとラベルを取得 Args: data_dir: データディレクトリのパス class_names: クラス名のリスト [‘dog’, ‘cat’] Returns: image_paths: 画像パスのリスト labels: ラベルのリスト “”” image_paths = [] labels = [] for label_idx, class_name in enumerate(class_names): class_dir = os.path.join(data_dir, class_name) if os.path.exists(class_dir): for filename in os.listdir(class_dir): if filename.lower().endswith((‘.jpg’, ‘.jpeg’, ‘.png’)): image_paths.append(os.path.join(class_dir, filename)) labels.append(label_idx) return image_paths, labels # クラス設定 class_names = [‘dog’, ‘cat’] # 0: dog, 1: cat num_classes = len(class_names) # ラベルマッピング id2label = {i: name for i, name in enumerate(class_names)} label2id = {name: i for i, name in enumerate(class_names)} print(f”クラス数: {num_classes}”) print(f”id2label: {id2label}”) print(f”label2id: {label2id}”)

# =================================================== # 3. モデルとプロセッサのロード # =================================================== model_name = “google/vit-base-patch16-224″ # プロセッサをロード processor = ViTImageProcessor.from_pretrained(model_name) # モデルをロード（分類ヘッドをカスタムクラス数に変更） # ignore_mismatched_sizes=True: # 事前学習済みモデルは1000クラス、今回は2クラス # サイズが異なるのでこのオプションで許可 model = ViTForImageClassification.from_pretrained( model_name, num_labels=num_classes, # クラス数を指定 id2label=id2label, # ID→ラベル名の辞書 label2id=label2id, # ラベル名→IDの辞書 ignore_mismatched_sizes=True # サイズ不一致を許可 ) print(f”モデルのクラス数: {model.config.num_labels}”) print(f”パラメータ数: {sum(p.numel() for p in model.parameters()):,}”)

# =================================================== # 4. 訓練設定 # =================================================== training_args = TrainingArguments( # 出力ディレクトリ（モデル保存先） output_dir=”./vit-finetuned”, # バッチサイズ # GPUメモリに応じて調整（8, 16, 32など） per_device_train_batch_size=16, per_device_eval_batch_size=16, # エポック数 # 過学習を防ぐため少なめに設定 num_train_epochs=5, # 評価と保存のタイミング # “epoch”: 各エポック終了時 # “steps”: 指定ステップごと evaluation_strategy=”epoch”, save_strategy=”epoch”, # 学習率 # ファインチューニングでは小さめに設定 learning_rate=2e-5, # 正則化（過学習防止） weight_decay=0.01, # ロギング設定 logging_dir=”./logs”, logging_steps=10, # ベストモデルの保存 load_best_model_at_end=True, metric_for_best_model=”accuracy”, # 保存するチェックポイント数の制限 save_total_limit=2, # Trainerの内部設定 remove_unused_columns=False, ) print(“訓練設定完了”)

# =================================================== # 5. 評価指標の定義 # =================================================== def compute_metrics(eval_pred): “”” 評価指標を計算する関数 Args: eval_pred: (logits, labels) のタプル logits: モデルの出力 (N, num_classes) labels: 正解ラベル (N,) Returns: dict: 評価指標の辞書 “”” logits, labels = eval_pred # ロジットから予測クラスを取得（argmax） predictions = logits.argmax(axis=-1) # 正解率 accuracy = accuracy_score(labels, predictions) # Precision, Recall, F1 # average=’weighted’: クラスの出現頻度で重み付け precision, recall, f1, _ = precision_recall_fscore_support( labels, predictions, average=’weighted’ ) return { ‘accuracy’: accuracy, ‘precision’: precision, ‘recall’: recall, ‘f1’: f1 } print(“評価指標の関数を定義完了”)

# =================================================== # 6. データセットの作成（実際のデータがある場合） # =================================================== # 実際のプロジェクトでは以下のようにデータセットを作成 # train_paths, train_labels = load_dataset_paths(‘data/train’, class_names) # val_paths, val_labels = load_dataset_paths(‘data/val’, class_names) # # train_dataset = CustomImageDataset(train_paths, train_labels, processor) # val_dataset = CustomImageDataset(val_paths, val_labels, processor) # =================================================== # 7. Trainerの作成と訓練 # =================================================== # trainer = Trainer( # model=model, # args=training_args, # train_dataset=train_dataset, # eval_dataset=val_dataset, # compute_metrics=compute_metrics, # ) # # # 訓練開始 # print(“訓練を開始します…”) # trainer.train() # # # 最終評価 # print(“\n最終評価:”) # results = trainer.evaluate() # for key, value in results.items(): # print(f” {key}: {value:.4f}”) # # # モデルを保存 # trainer.save_model(“./vit-finetuned-best”) # processor.save_pretrained(“./vit-finetuned-best”) # print(“\nモデルを保存しました: ./vit-finetuned-best”)

# =================================================== # 戦略別の実装例 # =================================================== # ————————————————— # 戦略1: 分類ヘッドのみ学習（Linear Probing） # ————————————————— def freeze_encoder(model): “”” Transformer Encoderを凍結し、分類ヘッドのみ学習可能にする 少量データ（100〜1000枚）で有効 “”” for name, param in model.named_parameters(): # “classifier” を含まないパラメータを凍結 if “classifier” not in name: param.requires_grad = False # 学習可能なパラメータ数を確認 trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) total = sum(p.numel() for p in model.parameters()) print(f”学習可能パラメータ: {trainable:,} / {total:,} ({trainable/total*100:.2f}%)”) # 使用例 # freeze_encoder(model)

# ————————————————— # 戦略2: 上位層 + 分類ヘッド # ————————————————— def freeze_lower_layers(model, num_layers_to_freeze=8): “”” 下位の層を凍結し、上位の層と分類ヘッドのみ学習可能にする Args: model: ViTモデル num_layers_to_freeze: 凍結する層数（0〜11） 中量データ（1000〜5000枚）で有効 “”” for name, param in model.named_parameters(): # 分類ヘッドは常に学習可能 if “classifier” in name: param.requires_grad = True continue # 凍結する層を判定 # ViTの層名は “encoder.layer.0”, “encoder.layer.1″, … の形式 should_freeze = False for i in range(num_layers_to_freeze): if f”encoder.layer.{i}.” in name: should_freeze = True break param.requires_grad = not should_freeze # 学習可能なパラメータ数を確認 trainable = sum(p.numel() for p in model.parameters() if p.requires_grad) total = sum(p.numel() for p in model.parameters()) print(f”凍結層数: {num_layers_to_freeze}”) print(f”学習可能パラメータ: {trainable:,} / {total:,} ({trainable/total*100:.2f}%)”) # 使用例: 下位8層を凍結、上位4層と分類ヘッドを学習 # freeze_lower_layers(model, num_layers_to_freeze=8)

# ————————————————— # 戦略3: 段階的学習（Gradual Unfreezing） # ————————————————— def gradual_unfreeze_training(model, train_dataset, val_dataset, processor): “”” 段階的に層を解凍しながら訓練 Phase 1: 分類ヘッドのみ（2 epochs） Phase 2: 上位4層 + 分類ヘッド（2 epochs） Phase 3: 全層（1 epoch） “”” # =================== # Phase 1: 分類ヘッドのみ # =================== print(“=” * 50) print(“Phase 1: 分類ヘッドのみ学習”) print(“=” * 50) # Encoderを凍結 for name, param in model.named_parameters(): if “classifier” not in name: param.requires_grad = False # 訓練（大きめの学習率） args_phase1 = TrainingArguments( output_dir=”./phase1″, num_train_epochs=2, learning_rate=1e-3, # 大きめ per_device_train_batch_size=16, evaluation_strategy=”epoch”, save_strategy=”no”, logging_steps=50, remove_unused_columns=False, ) trainer = Trainer( model=model, args=args_phase1, train_dataset=train_dataset, eval_dataset=val_dataset, compute_metrics=compute_metrics, ) trainer.train() # =================== # Phase 2: 上位4層 + 分類ヘッド # =================== print(“\n” + “=” * 50) print(“Phase 2: 上位4層 + 分類ヘッドを学習”) print(“=” * 50) # 上位4層を解凍 for name, param in model.named_parameters(): if “encoder.layer.8” in name or \ “encoder.layer.9” in name or \ “encoder.layer.10” in name or \ “encoder.layer.11” in name or \ “classifier” in name or \ “layernorm” in name.lower(): param.requires_grad = True # 訓練（中程度の学習率） args_phase2 = TrainingArguments( output_dir=”./phase2″, num_train_epochs=2, learning_rate=5e-5, # 中程度 per_device_train_batch_size=16, evaluation_strategy=”epoch”, save_strategy=”no”, logging_steps=50, remove_unused_columns=False, ) trainer = Trainer( model=model, args=args_phase2, train_dataset=train_dataset, eval_dataset=val_dataset, compute_metrics=compute_metrics, ) trainer.train() # =================== # Phase 3: 全層 # =================== print(“\n” + “=” * 50) print(“Phase 3: 全層を学習”) print(“=” * 50) # 全層を解凍 for param in model.parameters(): param.requires_grad = True # 訓練（小さめの学習率） args_phase3 = TrainingArguments( output_dir=”./phase3″, num_train_epochs=1, learning_rate=2e-5, # 小さめ per_device_train_batch_size=16, evaluation_strategy=”epoch”, save_strategy=”epoch”, load_best_model_at_end=True, metric_for_best_model=”accuracy”, logging_steps=50, remove_unused_columns=False, ) trainer = Trainer( model=model, args=args_phase3, train_dataset=train_dataset, eval_dataset=val_dataset, compute_metrics=compute_metrics, ) trainer.train() return model # 使用例 # model = gradual_unfreeze_training(model, train_dataset, val_dataset, processor)

# =================================================== # DeiTの使用（HuggingFace Transformers） # =================================================== from transformers import DeiTImageProcessor, DeiTForImageClassification from PIL import Image import torch # =================================================== # 1. モデルとプロセッサのロード # =================================================== # DeiT-Base（蒸留あり）モデル # “distilled” が名前に含まれる = 蒸留トークンを持つ model_name = “facebook/deit-base-distilled-patch16-224″ # プロセッサ（前処理） processor = DeiTImageProcessor.from_pretrained(model_name) # モデル model = DeiTForImageClassification.from_pretrained(model_name) model.eval() print(f”モデル: {model_name}”) print(f”クラス数: {model.config.num_labels}”)

# =================================================== # 2. 推論 # =================================================== # 画像を読み込み image = Image.open(‘cat.jpg’).convert(‘RGB’) # 前処理 inputs = processor(images=image, return_tensors=”pt”) # 推論 with torch.no_grad(): outputs = model(**inputs) logits = outputs.logits probs = torch.softmax(logits, dim=-1) # Top-5予測 top5_prob, top5_idx = torch.topk(probs, 5) print(“\nTop 5 Predictions (DeiT):”) print(“-” * 40) for i in range(5): class_id = top5_idx[0][i].item() class_name = model.config.id2label[class_id] prob = top5_prob[0][i].item() print(f”{i+1}. {class_name}: {prob*100:.2f}%”)

# =================================================== # Attention Mapの可視化 # =================================================== import torch import numpy as np import matplotlib.pyplot as plt from transformers import ViTModel, ViTImageProcessor from PIL import Image # =================================================== # 1. モデルの準備（Attention出力を有効化） # =================================================== model_name = “google/vit-base-patch16-224” # プロセッサ processor = ViTImageProcessor.from_pretrained(model_name) # ViTModel: 分類ヘッドなしのベースモデル # output_attentions=True: Attention行列を出力に含める model = ViTModel.from_pretrained( model_name, output_attentions=True # これが重要！ ) model.eval() print(“Attention出力を有効化したモデルをロードしました”)

# =================================================== # 2. 画像の前処理と推論 # =================================================== # 画像を読み込み image = Image.open(‘cat.jpg’).convert(‘RGB’) # 前処理 inputs = processor(images=image, return_tensors=”pt”) # 推論（Attentionも取得） with torch.no_grad(): outputs = model(**inputs) # Attentionを取得 # outputs.attentions: タプル（層数分） # 各要素: (batch_size, num_heads, num_tokens, num_tokens) # = (1, 12, 197, 197) attentions = outputs.attentions print(f”層数: {len(attentions)}”) print(f”各層のAttention shape: {attentions[0].shape}”)

# =================================================== # 3. Attention Map可視化関数 # =================================================== def visualize_attention_map(attentions, layer_idx=-1, head_idx=None): “”” Attention Mapを可視化 Args: attentions: モデルのAttention出力 layer_idx: 可視化する層（-1で最終層） head_idx: 可視化するヘッド（Noneで全ヘッド平均） Returns: attn_map: 14×14のAttention Map “”” # 指定層のAttentionを取得 # shape: (1, num_heads, 197, 197) attn = attentions[layer_idx][0] # バッチ次元を削除 if head_idx is not None: # 特定のヘッドのみ attn = attn[head_idx] # (197, 197) else: # 全ヘッドの平均 attn = attn.mean(dim=0) # (197, 197) # [CLS]トークンが各パッチに向けるAttentionを取得 # attn[0, 1:]: [CLS]（インデックス0）から # パッチ（インデックス1〜196）へのAttention attn_cls = attn[0, 1:] # (196,) # 14×14のグリッドに再構成 num_patches = int(np.sqrt(attn_cls.shape[0])) # 14 attn_map = attn_cls.reshape(num_patches, num_patches) # NumPyに変換 attn_map = attn_map.cpu().numpy() # 0-1に正規化 attn_map = (attn_map – attn_map.min()) / (attn_map.max() – attn_map.min()) return attn_map # Attention Mapを取得 attn_map = visualize_attention_map(attentions, layer_idx=-1) print(f”Attention Map shape: {attn_map.shape}”)

# =================================================== # 4. 可視化の実行 # =================================================== # 3つの画像を並べて表示 fig, axes = plt.subplots(1, 3, figsize=(15, 5)) # 元画像 axes[0].imshow(image) axes[0].set_title(“Original Image”, fontsize=14) axes[0].axis(‘off’) # Attention Map im = axes[1].imshow(attn_map, cmap=’viridis’) axes[1].set_title(“Attention Map (Last Layer)”, fontsize=14) axes[1].axis(‘off’) plt.colorbar(im, ax=axes[1], fraction=0.046) # 重ね合わせ # 元画像にAttention Mapをオーバーレイ axes[2].imshow(image) # リサイズしてオーバーレイ attn_resized = np.array(Image.fromarray((attn_map * 255).astype(np.uint8)).resize(image.size, Image.BILINEAR)) / 255 axes[2].imshow(attn_resized, cmap=’jet’, alpha=0.5) axes[2].set_title(“Overlay”, fontsize=14) axes[2].axis(‘off’) plt.tight_layout() plt.savefig(‘attention_visualization.png’, dpi=150, bbox_inches=’tight’) plt.show() print(“attention_visualization.png を保存しました”)

# =================================================== # 5. 層ごとのAttention比較 # =================================================== def visualize_attention_across_layers(attentions, image): “””複数の層のAttentionを比較””” # 可視化する層（第1, 4, 7, 10, 12層） layer_indices = [0, 3, 6, 9, 11] fig, axes = plt.subplots(1, len(layer_indices) + 1, figsize=(20, 4)) # 元画像 axes[0].imshow(image) axes[0].set_title(“Original”, fontsize=12) axes[0].axis(‘off’) # 各層のAttention for i, layer_idx in enumerate(layer_indices): attn_map = visualize_attention_map(attentions, layer_idx=layer_idx) im = axes[i + 1].imshow(attn_map, cmap=’viridis’) axes[i + 1].set_title(f”Layer {layer_idx + 1}”, fontsize=12) axes[i + 1].axis(‘off’) plt.tight_layout() plt.savefig(‘attention_layers.png’, dpi=150, bbox_inches=’tight’) plt.show() print(“attention_layers.png を保存しました”) # 実行 visualize_attention_across_layers(attentions, image)