本チュートリアルは Hugging Face Transformers / Datasets / PyTorch を用いた基本的なファインチューニングを、AWS EC2（GPU） 上で最後まで動かすことをゴールにしています。手順は上から順に実施すれば完走できます。
僕も実際に作業を実施したので大丈夫なはず！
目次
基礎知識編
実践編（基本フロー）- 必須
-
実践：感情分析モデルのファインチューニング（AWS EC2 編）
- Step 1-5: 基本的なファインチューニングフロー（環境構築 → 学習 → 評価 →API→ 成果物取得）
その他
ファインチューニングとは
ファインチューニング（Fine-tuning） とは、既に学習済みのモデルを特定タスク向けに追加学習することです。
具体例
一般日本語モデル（例: 東北大 BERT）を医療文書分類に最適化する、といった用途で使います。ゼロから学習するよりも、少ないデータ・短い時間 で高精度を目指せます。
料理に例えると
- 事前学習済みモデル：基礎力のあるシェフ
- ファインチューニング：寿司の専門技術を短期集中で習得
- 結果：寿司に強い一流シェフが効率よく誕生
なぜファインチューニングが必要なのか
-
計算コスト削減
ゼロからの事前学習は大規模 GPU や長期間が必要になる一方、ファインチューニングなら短時間・1 台 GPU でも実施可能。 -
データ効率が良い
数千〜数万のデータで実用精度に到達するケースが多い。 -
精度向上
事前学習で得た一般知識をベースに、対象ドメインへ適応できる。
ファインチューニングの種類
1. Full Fine-tuning（全層更新）
- 最高精度を狙える反面、メモリ/計算コストが大きい。
2. Parameter-Efficient Fine-tuning（PEFT）
- LoRA / Adapters など、小規模追加パラメータだけ学習して軽量・高速。
- 元モデルを共有しやすく、実運用で人気。
3. Prompt/Prefix Tuning
- さらに軽量。効果はタスク依存。
必要な環境・ツール
ハードウェア（目安）
- 最小：GPU 6GB/VRAM 以上、RAM 16GB、SSD 空き 50GB
- 推奨：GPU 12GB〜（例: NVIDIA T4/A10G クラス）、RAM 32GB、SSD 空き 100GB
クラウドでは AWS EC2 の G4dn（T4）、G5（A10G）、P3（V100） 等が選択肢。価格はリージョンで変動するため、最新のオンデマンド料金表 を必ず確認してください。(Amazon Web Services, Inc.)
ソフトウェア
- Python 3.9 以上（PyTorch 最新は 3.9+推奨）
- PyTorch（CUDA 11.8 / 12.x いずれか、環境に合わせて公式のインストールコマンドを使用）(PyTorch)
- Transformers / Datasets / Accelerate（Hugging Face）
（推奨）AMI で始める
AWS では Deep Learning AMI（DLAMI, Ubuntu 22.04） に PyTorch/CUDA/ドライバ等が同梱されたエディションが提供されています。PyTorch 2.6 版（CUDA 12.6） など最新の組み合わせが用意されており、導入が早いです。(AWS ドキュメント)
Hugging Face とは
モデル・データセット・学習ユーティリティを統合提供するプラットフォーム。
主なコンポーネント
Transformers
# Hugging Face Transformersライブラリから必要なクラスをインポート
from transformers import AutoModel, AutoTokenizer
# 東北大学のBERT日本語モデル（Whole Word Masking版）を読み込み
# AutoModelは適切なモデルクラスを自動選択してくれる便利なクラス
model = AutoModel.from_pretrained("tohoku-nlp/bert-base-japanese-whole-word-masking")
# 対応するトークナイザー（文章を単語・サブワードに分割するツール）も読み込み
# モデルとトークナイザーは必ずペアで使用する必要がある
tokenizer = AutoTokenizer.from_pretrained("tohoku-nlp/bert-base-japanese-whole-word-masking")
- 多数の事前学習モデルを数行で利用可。日本語 BERT（東北大 BERT）は語彙 32,000、WWS 対応などの特徴を持ちます。(Hugging Face)
Datasets
# Hugging Face Datasetsライブラリから データセット読み込み関数をインポート
from datasets import load_dataset
# WRIME（日本語感情分析データセット）のver1を読み込み
# このデータセットにはTwitter投稿やニュース記事と、それに対する感情ラベルが含まれる
dataset = load_dataset("shunk031/wrime", name="ver1") # 日本語感情データセット
- 大規模データの読み込み/前処理が高速。WRIME のフィールド構造は
sentence,writer,reader1-3,avg_readers（各 8 感情+polarity）など。(Hugging Face)
実践：感情分析モデルのファインチューニング（AWS EC2 編）
ここでは WRIME を 3 値（ネガ/中立/ポジ）にマッピングして、東北大 BERT を Transformers.Trainer で微調整します。最終的に Flask API で推論できるところまで行きます。
セキュリティ重要：学習用にポートを 0.0.0.0/0 に開放しないでください。外部アクセスは SSH ポートフォワード か AWS Systems Manager Session Manager を推奨します。(AWS ドキュメント)
📋 全体フロー
| Step | 目的 | 主な作業 | 分類 |
|---|---|---|---|
| 1 | EC2 GPU 準備 | インスタンス/AMI/SG 設定、SSH か SSM 準備 | 基本 |
| 2 | 環境構築 | venv / ライブラリ導入 / GPU 確認 | 基本 |
| 3 | 学習実行 | データ取得 → 学習 → ログ監視 | 基本 |
| 4 | 評価 | テストセット評価・レポート出力 | 基本 |
| 5 | API/成果物 | Flask API 起動 → テスト → 成果物取得 | 基本 |
成果物（保存フォルダ例）
fine_tuned_sentiment_model/
├── config.json
├── pytorch_model.bin # or model.safetensors（Transformersの設定による）
├── tokenizer.json
├── tokenizer_config.json
├── vocab.txt
├── special_tokens_map.json
└── training_args.bin # 学習時の引数（バージョンにより出力の有無/形式が異なる）
- 東北大 BERT ベースのため、学習済み重みは概ね数百 MB 規模（BERT-base）。
-
training_args.binやtrainer_state.jsonなどは Trainer のバージョンで出力が変わる 点に注意。(Hugging Face, GitHub)
推論コード（成果物の利用）
# 必要なライブラリのインポート
from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
# ファインチューニング済みモデルとトークナイザーを読み込み
# './fine_tuned_sentiment_model' は学習完了後に保存されたモデルのパス
model = AutoModelForSequenceClassification.from_pretrained('./fine_tuned_sentiment_model')
tokenizer = AutoTokenizer.from_pretrained('./fine_tuned_sentiment_model')
def analyze_sentiment(text: str) -> str:
"""
感情分析を実行する関数
Args:
text: 分析したい日本語テキスト
Returns:
感情ラベル（"ネガティブ", "中性", "ポジティブ"のいずれか）
"""
# 入力テキストをモデルが理解できる形式（テンソル）に変換
# padding=True: バッチ内で長さを揃える
# truncation=True: 最大長を超える場合は切り詰める
# return_tensors="pt": PyTorchテンソル形式で返す
inputs = tokenizer(text, return_tensors="pt", padding=True, truncation=True)
# 推論実行（勾配計算を無効にして高速化）
with torch.no_grad():
# モデルに入力を渡して予測スコア（logits）を取得
logits = model(**inputs).logits
# 最も高いスコアのクラスのインデックスを取得
idx = torch.argmax(logits, dim=-1).item()
# インデックスを人間が読める感情ラベルに変換
labels = ["ネガティブ", "中性", "ポジティブ"]
return labels[idx]
Step 1: AWS EC2 GPU インスタンスのセットアップ
インスタンスタイプ
- 学習用（コスパ）: G4dn（T4 16GB）
- 学習用（余裕）: G5（A10G 24GB）
- 互換性重視/旧世代: P3（V100 16GB）
料金は リージョン（例: ap-northeast-1, 東京） ごとに異なります。AWS 公式のオンデマンド料金表で確認してください。(Amazon Web Services, Inc.)
AMI
- Deep Learning AMI (Ubuntu 22.04, PyTorch) を推奨（CUDA/ドライバ同梱で素早く開始）。最新版は PyTorch 2.6 + CUDA 12.6 等の組み合わせが提供されています。(AWS ドキュメント)
推奨 AMI: Deep Learning OSS Nvidia Driver AMI GPU PyTorch 2.7 (Ubuntu 22.04)、アーキテクチャは x86_64
セキュリティグループ（SG）
原則として インバウンドは最小限。SSH(22)を 0.0.0.0/0 で開けない、外部公開ポートは不要（後述のポートフォワード/SSM でアクセス）。(AWS ドキュメント)
推奨設定: 自分の IP アドレスのみから 22 ポートへのアクセスを許可するセキュリティグループを作成
ファイル転送
後述の各Stepのスクリプトをローカルで作成し、以下コマンドでEC2 に転送:
# 事前に各スクリプトをローカルで用意して、EC2に転送
scp -i "~/your.pem" -r /prj/fine_tuning_project/scripts ubuntu@ec2-xxx-xxx-xxx-xxx.ap-northeast-1.compute.amazonaws.com:~/
接続と GPU 確認
# EC2インスタンスにSSH接続するためのキーファイルに適切な権限を設定
# 400 = 所有者のみ読み取り可能（セキュリティ要件）
chmod 400 your-key.pem
# SSH接続を実行
# -i: 秘密鍵ファイルを指定
# ubuntu: EC2のデフォルトユーザー名（AMIによって異なる場合がある）
ssh -i your-key.pem ubuntu@your-ec2-public-ip
# GPU情報を確認するコマンド
# 使用可能なGPU、メモリ使用量、動作温度などが表示される
nvidia-smi # GPU確認
nvidia-smi 出力例:
$ nvidia-smi
Sat Aug 30 10:30:44 2025
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 570.172.08 Driver Version: 570.172.08 CUDA Version: 12.8 |
|-----------------------------------------+------------------------+----------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
| | | MIG M. |
|=========================================+========================+======================|
| 0 Tesla T4 On | 00000000:00:1E.0 Off | 0 |
| N/A 24C P8 9W / 70W | 0MiB / 15360MiB | 0% Default |
| | | N/A |
+-----------------------------------------+------------------------+----------------------+
Step 2: 環境構築
venv 作成とライブラリ導入
# Python仮想環境を作成（プロジェクト専用の独立した環境）
# 他のプロジェクトとライブラリの競合を避けるため
########################################################################
# Deep Learning OSS Nvidia Driver AMI GPU PyTorch AMIからEC2を起動した場合は不要！
#既存の/opt/pytorch venvがあるので以下コマンドを実行
source /opt/pytorch/bin/activate
# その他であれば以下が必要
python3 -m venv ~/fine_tuning_env
# 作成した仮想環境を有効化
# これ以降のpipインストールは仮想環境内に限定される
source ~/fine_tuning_env/bin/activate
########################################################################
# pipパッケージマネージャーを最新版にアップグレード
# Deep Learning OSS Nvidia Driver AMI GPU PyTorch AMIからEC2を起動した場合は基本的には不要
# 新しいバージョンがある警告が出た場合は、必要に応じて実行する
pip install --upgrade pip
# PyTorch: 公式ページのセレクタで自環境に合うコマンドを使用
# CUDA 11.8対応版PyTorchをインストール（GPU計算に必要）
# (例) CUDA 11.8:
########################################################################
# Deep Learning OSS Nvidia Driver AMI GPU PyTorch AMIからEC2を起動した場合は不要！
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
########################################################################
# (例) CUDA 12.6 の場合は PyTorch セレクタで提示されるコマンドを使用
# 公式: https://pytorch.org/get-started/locally/
# Hugging Face の核となるライブラリ群をインストール
# transformers: 事前学習済みモデルとトークナイザー
# datasets: 大規模データセットの効率的な処理
# accelerate: 分散学習とGPU最適化
pip install "transformers>=4.41" "datasets>=2.19" "accelerate>=0.33"
# 機械学習の評価・可視化ライブラリ
# scikit-learn: 評価指標計算
# pandas/numpy: データ処理
# matplotlib/seaborn: グラフ作成
# tensorboard: 学習過程の可視化
pip install scikit-learn pandas numpy matplotlib seaborn tensorboard
# WebAPI作成用ライブラリ
# flask: 軽量Webフレームワーク
# gunicorn: 本番環境用WSGIサーバー
pip install flask gunicorn
# TODO: ここに説明を追加
pip install requests
# 日本語BERTトークナイザーに必要なライブラリをインストール
pip install fugashi ipadic
# Unidic軽量版辞書もインストール（東北大BERTで必要）
pip install unidic-lite
メモ: PyTorch のサポート Python は 3.9 以上。インストールコマンドは 公式のセレクタに従ってください。(PyTorch)
GPU 確認スクリプト（scripts/gpu_check.py）
# scripts/gpu_check.py
# GPU環境を確認するためのスクリプト
# 必要なライブラリのインポート
import torch, subprocess
def main():
"""GPU環境の詳細情報を表示する関数"""
# PyTorchからCUDAが利用可能かチェック
print("CUDA available:", torch.cuda.is_available())
# CUDAが利用可能な場合の詳細情報を表示
if torch.cuda.is_available():
# PyTorchがビルドされたCUDAバージョンを表示
print("torch CUDA:", torch.version.cuda)
# 利用可能なGPU数を表示
print("#GPUs:", torch.cuda.device_count())
# 各GPUの詳細情報をループで表示
for i in range(torch.cuda.device_count()):
# GPU iのプロパティを取得
p = torch.cuda.get_device_properties(i)
# GPU名とメモリ容量を表示
# total_memory はバイト単位なので GB に変換 (1024^3 で割る)
print(f"[GPU{i}] {torch.cuda.get_device_name(i)} / {p.total_memory/1024**3:.1f}GB")
try:
# nvidia-smi コマンドを実行してGPU詳細情報を取得
# subprocess.run: 外部コマンドを実行
# capture_output=True: 出力をキャプチャ
# text=True: 出力を文字列として扱う
# check=False: エラーでも例外を発生させない
out = subprocess.run(["nvidia-smi"], capture_output=True, text=True, check=False)
# nvidia-smi の出力結果を表示
print("\n==== nvidia-smi ====\n", out.stdout)
except FileNotFoundError:
# nvidia-smi が見つからない場合のエラーハンドリング
print("nvidia-smi not found")
# スクリプトが直接実行された場合のみmain関数を呼び出す
if __name__ == "__main__":
main()
Step 3: データ取得と学習実行
プロジェクト構成
fine_tuning_project/
├── scripts/
│ ├── gpu_check.py
│ ├── load_wrime_dataset.py
│ ├── fine_tuning.py
│ ├── run_training.sh
│ ├── evaluate_model.py
│ ├── sentiment_api.py
│ ├── test_api.py
│ ├── download_results.sh
│ └── auto_shutdown.sh
├── data/ # 生成
├── models/ # 生成
└── logs/ # 生成
WRIME データ取得・整形（scripts/load_wrime_dataset.py）
修正ポイント
- WRIME は
avg_readers等の入れ子辞書を持つスキーマ（ver1/2）なので、Hugging Face Datasets から読み込み後、各サンプルの辞書を参照して 3 値ラベルに変換します。 - 8 感情（喜/悲/期/驚/怒/恐/嫌/信）をポジ・ネガに集約し、差が弱い/拮抗時は中立に寄せる単純ルール。
スキーマの詳細はデータカード参照。(Hugging Face)
# scripts/load_wrime_dataset.py
# WRIMEデータセットを読み込み、3クラス感情分析用に変換するスクリプト
# 必要なライブラリのインポート
import os, pandas as pd
from datasets import load_dataset
def convert_to_3class(ex):
"""
WRIMEの8感情を3クラス（ネガ/中性/ポジ）に変換する関数
Args:
ex: WRIMEデータセットの1サンプル（辞書形式）
Returns:
int: 0=ネガティブ, 1=中性, 2=ポジティブ
"""
# avg_readers の 8感情スコアを取得（0-3 の強度値）
# avg_readers: 複数の読み手による感情評価の平均値
ar = ex["avg_readers"]
# ポジティブ感情の合計を計算
# joy: 喜び, anticipation: 期待, trust: 信頼
# or 0: 値がNoneの場合は0として扱う（安全な処理）
pos = (ar["joy"] or 0) + (ar["anticipation"] or 0) + (ar["trust"] or 0)
# ネガティブ感情の合計を計算
# sadness: 悲しみ, anger: 怒り, fear: 恐怖, disgust: 嫌悪
neg = (ar["sadness"] or 0) + (ar["anger"] or 0) + (ar["fear"] or 0) + (ar["disgust"] or 0)
# しきい値は経験的に >1.0 程度で有意とみなす
# 感情の強度が1.0以下の場合は中性として扱う
if pos > neg and pos > 1.0:
return 2 # ポジティブ
elif neg > pos and neg > 1.0:
return 0 # ネガティブ
else:
return 1 # 中性（ポジネガが拮抗、または両方とも弱い場合）
def main():
"""メイン処理：WRIMEデータセットの読み込みと変換"""
print("Loading WRIME...")
# Hugging Face DatasetsからWRIMEデータセット（ver1）を読み込み
# WRIMEは日本語の感情分析データセット（Twitter投稿+ニュース記事）
ds = load_dataset("shunk031/wrime", name="ver1")
# 訓練・検証・テストの各分割を処理
for split in ["train", "validation", "test"]:
# 各分割のテキスト（文章）を取得
texts = ds[split]["sentence"]
# 各サンプルを3クラス感情に変換
# リスト内包表記で全サンプルを一括変換
labels = [convert_to_3class(ex) for ex in ds[split]]
# pandas DataFrameに変換（CSV保存のため）
df = pd.DataFrame({"text": texts, "label": labels})
# 短すぎるテキスト（5文字以下）を除外
# 感情分析には最低限の文章長が必要
df = df[df["text"].str.len() > 5]
# data ディレクトリが存在しない場合は作成
os.makedirs("data", exist_ok=True)
# ファイル名を決定（validation -> val に短縮）
out = f"data/{'val' if split=='validation' else split}.csv"
# CSV形式で保存（index=False: 行番号は保存しない）
df.to_csv(out, index=False)
# 処理結果をコンソールに出力
print(split, "->", out, len(df), "rows")
# スクリプトが直接実行された場合のみmain関数を呼び出す
if __name__ == "__main__":
main()
学習スクリプト（scripts/fine_tuning.py）
- 東北大 BERT を 3 クラス分類に。
- GPU メモリに応じたバッチサイズ自動調整。
-
gradient_checkpointing=Trueでメモリ節約（Transformers 推奨の仕組み）。(Hugging Face)
# scripts/fine_tuning.py
# ファインチューニングのメイン実行スクリプト
# 必要なライブラリのインポート
import os, logging, numpy as np, pandas as pd, torch
from torch.utils.data import Dataset
from transformers import (AutoTokenizer, AutoModelForSequenceClassification,
TrainingArguments, Trainer, DataCollatorWithPadding)
from sklearn.metrics import accuracy_score, precision_recall_fscore_support
from datetime import datetime
# ログ設定（コンソールとファイルの両方に出力）
logging.basicConfig(level=logging.INFO,
format="%(asctime)s %(levelname)s %(message)s",
handlers=[logging.FileHandler("logs/training.log"),
logging.StreamHandler()])
class SentimentDataset(Dataset):
"""
感情分析用のカスタムデータセットクラス
PyTorchのDatasetを継承して独自のデータローダーを作成
"""
def __init__(self, texts, labels, tokenizer, max_length=128):
"""
データセットの初期化
Args:
texts: テキストのリスト
labels: ラベル（0,1,2）のリスト
tokenizer: 使用するトークナイザー
max_length: テキストの最大長（これを超える場合は切り詰め）
"""
self.texts, self.labels, self.tok = texts, labels, tokenizer
self.max_length = max_length
def __len__(self):
"""データセットのサイズを返す"""
return len(self.texts)
def __getitem__(self, idx):
"""
指定されたインデックスのデータを取得
Args:
idx: データのインデックス
Returns:
dict: モデルの入力形式に変換されたデータ
"""
# テキストをトークナイズ（単語・サブワードに分割）
enc = self.tok(str(self.texts[idx]),
truncation=True, # 最大長を超える場合は切り詰め
padding="max_length", # 最大長まで0埋め
max_length=self.max_length,
return_tensors="pt") # PyTorchテンソル形式で返す
# Trainerが期待する形式で辞書を返す
return {
"input_ids": enc["input_ids"].squeeze(0), # 単語IDシーケンス
"attention_mask": enc["attention_mask"].squeeze(0), # 注意マスク（パディング部分を無視）
"labels": torch.tensor(int(self.labels[idx]), dtype=torch.long) # 正解ラベル
}
def compute_metrics(eval_pred):
"""
評価指標を計算する関数（Trainerのコールバック用）
Args:
eval_pred: (predictions, labels) のタプル
Returns:
dict: 各種評価指標
"""
preds, labels = eval_pred
# 予測スコアから最大値のインデックス（予測クラス）を取得
preds = np.argmax(preds, axis=1)
# 精度（Accuracy）を計算
acc = accuracy_score(labels, preds)
# 精密度（Precision）、再現率（Recall）、F1スコアを計算
# average="weighted": クラス不均衡を考慮した重み付き平均
# zero_division=0: ゼロ除算の場合は0を返す
p, r, f1, _ = precision_recall_fscore_support(labels, preds, average="weighted", zero_division=0)
return {"accuracy": acc, "f1": f1, "precision": p, "recall": r}
def suggest_bs():
"""
GPU メモリに基づいて適切なバッチサイズを提案する関数
Returns:
tuple: (train_batch_size, eval_batch_size)
"""
# CUDAが利用できない場合は小さいバッチサイズ
if not torch.cuda.is_available():
return 4, 4
# GPU メモリ容量を取得（GB単位）
gb = torch.cuda.get_device_properties(0).total_memory/1024**3
# メモリ容量に応じてバッチサイズを決定
if gb >= 20: return 32, 32 # 20GB以上: 大きいバッチサイズ
if gb >= 12: return 16, 16 # 12GB以上: 中程度のバッチサイズ
return 8, 8 # それ以外: 小さいバッチサイズ
def main():
"""メイン処理：ファインチューニングの実行"""
# CSVファイルからデータを読み込み
train_df = pd.read_csv("data/train.csv")
val_df = pd.read_csv("data/val.csv")
# 使用するモデル名（東北大学のBERT日本語モデル）
model_name = "tohoku-nlp/bert-base-japanese-whole-word-masking" # 正式リポ名
# トークナイザーとモデルを読み込み
tok = AutoTokenizer.from_pretrained(model_name)
# 分類用モデルを読み込み（num_labels=3: 3クラス分類）
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=3)
# カスタムデータセットを作成
train_ds = SentimentDataset(train_df["text"], train_df["label"], tok)
val_ds = SentimentDataset(val_df["text"], val_df["label"], tok)
# GPU メモリに適したバッチサイズを取得
bs_tr, bs_ev = suggest_bs()
# 出力ディレクトリ名（タイムスタンプ付き）
outdir = f"models/sentiment_{datetime.now().strftime('%Y%m%d_%H%M%S')}"
# 学習パラメータの設定
args = TrainingArguments(
output_dir=outdir, # モデル保存先
num_train_epochs=3, # エポック数（データセット全体を3回学習）
per_device_train_batch_size=bs_tr, # 学習時のバッチサイズ
per_device_eval_batch_size=bs_ev, # 評価時のバッチサイズ
warmup_steps=500, # 学習率のウォームアップステップ数
weight_decay=0.01, # 重み減衰（過学習防止）
logging_dir="logs", # TensorBoardログ保存先
logging_steps=10, # ログ出力間隔
evaluation_strategy="epoch", # エポック毎に評価実行
save_strategy="epoch", # エポック毎にモデル保存
load_best_model_at_end=True, # 学習終了時に最良モデルを読み込み
metric_for_best_model="accuracy", # 最良モデル判定指標
report_to="tensorboard", # TensorBoardに結果を送信
fp16=torch.cuda.is_available(), # 半精度浮動小数点（GPU利用時のみ）
dataloader_num_workers=2, # データローダーのワーカー数
gradient_checkpointing=True, # 勾配チェックポイント（メモリ節約）
remove_unused_columns=False # 未使用カラムを削除しない
)
# Trainerオブジェクトの作成
trainer = Trainer(
model=model, # 学習対象モデル
args=args, # 学習パラメータ
train_dataset=train_ds, # 訓練データセット
eval_dataset=val_ds, # 検証データセット
tokenizer=tok, # トークナイザー（新APIではprocessor推奨だが互換のため保持）
data_collator=DataCollatorWithPadding(tok), # バッチ作成時のパディング処理
compute_metrics=compute_metrics # 評価指標計算関数
)
# ファインチューニング実行
trainer.train()
# 最終モデルを保存
final_dir = "models/fine_tuned_sentiment_model"
trainer.save_model(final_dir) # モデルの重みと設定を保存
tok.save_pretrained(final_dir) # トークナイザーも同じ場所に保存
# 結果を出力
print("Saved:", final_dir)
print("Eval:", trainer.evaluate()) # 最終的な評価結果を表示
# スクリプトが直接実行された場合のみmain関数を呼び出す
if __name__ == "__main__":
main()
学習実行シェル（scripts/run_training.sh）
-
GPU 監視 は
nvidia-smi dmonのログを推奨（1 秒間隔）。(NVIDIA Docs)
#!/usr/bin/env bash
# scripts/run_training.sh
# ファインチューニング実行のための統合シェルスクリプト
# エラー時にスクリプトを停止 + 未定義変数使用時にエラー
set -eu
# スクリプトのディレクトリから一つ上の階層（プロジェクトルート）に移動
cd "$(dirname "$0")"/..
# 仮想環境を有効化（事前に作成済みであることが前提）
source ~/fine_tuning_env/bin/activate
# 必要なディレクトリを作成（存在しない場合のみ）
# -p オプション: 親ディレクトリも含めて作成、既存の場合はエラーにしない
mkdir -p logs models data
# GPUモニタリングをバックグラウンドで開始
# nvidia-smi dmon: GPU使用状況をリアルタイム監視
# -s pucvmet: power, utilization, clock, video, memory, temperature を監視
# -d 1: 1秒間隔で更新
# -o TD: timestamp + device name を含めて出力
# > logs/gpu_dmon.log 2>&1: 標準出力・標準エラーをログファイルにリダイレクト
# & : バックグラウンドで実行
(nvidia-smi dmon -s pucvmet -d 1 -o TD > logs/gpu_dmon.log 2>&1 &)
# バックグラウンドプロセスのプロセスIDを保存（後で停止するため）
DMON_PID=$!
# 各ステップを順次実行
# 1. GPU環境確認
python scripts/gpu_check.py
# 2. WRIMEデータセット読み込み・前処理
python scripts/load_wrime_dataset.py
# 3. ファインチューニング実行
# ||演算子: 左のコマンドが失敗した場合に右のコマンドを実行
# { ... }: コマンドをグループ化
# kill $DMON_PID || true: GPUモニタを停止（失敗してもスクリプトは継続）
# exit 1: エラーコード1でスクリプト終了
python scripts/fine_tuning.py || { kill $DMON_PID || true; exit 1; }
# 学習が正常完了した場合、GPUモニタリングを停止
kill $DMON_PID || true
# TensorBoard接続方法をユーザーに案内
echo "TensorBoard -> ssh -L 6006:localhost:6006 ubuntu@your-ec2-ip"
echo "then: tensorboard --logdir=logs --port=6006 --host=127.0.0.1"
🎯 実際の実行
実際には、scripts/run_training.shを実行するだけで以下が順次実行されます：
- 環境準備: 仮想環境の有効化、必要なディレクトリ（logs、models、data）の作成、プロジェクトルートへの移動
- GPU 監視の開始: nvidia-smi dmon をバックグラウンドで起動、GPU 使用状況を logs/gpu_dmon.log にリアルタイム記録、電力・使用率・メモリ・温度を 1 秒間隔で監視
- 学習パイプラインの実行: gpu_check.py（GPU 環境の確認）→ load_wrime_dataset.py（WRIME データセットの取得・前処理）→ fine_tuning.py（ファインチューニングの実行）
- エラーハンドリング: 各ステップでエラーが発生した場合の適切な処理、GPU モニタリングプロセスの確実な停止
- 後処理: TensorBoard 接続方法の案内表示、ログファイルの整理
run_training.sh を実行すると、環境準備から GPU 監視、データ準備、学習実行まで全自動で行われ、最終的に API で使用可能な学習済みモデルが完成します。
📊 ファインチューニング実行時のログ解説
ファインチューニング実行中は、以下のようなログが出力されます：
初期化メッセージ
Some weights of BertForSequenceClassification were not initialized from the model checkpoint at tohoku-nlp/bert-base-japanese-whole-word-masking and are newly initialized: ['classifier.bias', 'classifier.weight']
You should probably TRAIN this model on a down-stream task to be able to use it for predictions and inference.
この警告は正常です。事前学習済み BERT モデルに新しい分類層（classifier）を追加するため、その重みは初期化されています。
学習中のログ（例）
{'loss': 0.885, 'grad_norm': 8.471055030822754, 'learning_rate': 9e-07, 'epoch': 0.31}
{'loss': 0.847, 'grad_norm': 5.233842372894287, 'learning_rate': 1.9e-06, 'epoch': 0.62}
{'loss': 0.7192, 'grad_norm': 3.917604923248291, 'learning_rate': 2.9e-06, 'epoch': 0.94}
各項目の意味:
- loss: 現在のバッチにおけるトレーニング損失（誤差）。小さいほど良く学習できています
- grad_norm: 勾配の大きさ（ノルム）。値が大きすぎると不安定になるため、必要に応じて勾配クリッピングに使われます
- learning_rate: その時点での学習率。スケジューラで動的に変化することがあり、小さいほど更新が穏やかになります
- epoch: 学習が何周目か。2.37 とは、全体の 2.37 回学習データを見終わったことを意味します
評価時のログ（例）
{'eval_loss': 0.5703369379043579, 'eval_accuracy': 0.7, 'eval_f1': 0.5764705882352941, 'eval_precision': 0.49, 'eval_recall': 0.7, 'eval_runtime': 0.267, 'eval_samples_per_second': 374.541, 'eval_steps_per_second': 26.218, 'epoch': 1.0}
各項目の意味:
- eval_loss: 検証データに対する損失。これが小さいほど、モデルが検証データに適合していることを示します
- eval_accuracy: 正解率（Accuracy）。全てのサンプルのうち、何％が正しく分類されたか
- eval_precision, eval_recall, eval_f1: 精密度・再現率・F1 スコア。どちらもバランスよく高いときに F1 スコアが向上
- eval_runtime: 評価にかかった実行時間（秒）
- eval_samples_per_second: 1 秒あたり評価できたサンプル数（スループットの目安）
- eval_steps_per_second: 1 秒あたり完了したバッチステップ数
⚠️ 評価結果の注意点
eval_accuracy = 1.0 や eval_f1 = 1.0 が連続で出る場合:
これは「すべてのサンプルを正しく分類できた」「完全に正しく分類できた」ことを示しますが、過学習やデータリークの疑いがあります。一般的な原因：
- データ漏洩、検証分割が極端に小さい、前処理のバグなどで過学習やリークが起きた
- テストデータと検証データが同じ、検証データが小規模すぎる、同じ内容が重複している
理想的な結果すぎる場合は、データセットの確認を推奨します。
正常な学習ログの例
{'eval_loss': 0.6967904567718506, 'eval_accuracy': 0.6816851960210649, 'eval_f1': 0.6748101346593145, 'eval_precision': 0.6948070170760761, 'eval_recall': 0.6816851960210649, 'eval_runtime': 5.6449, 'eval_samples_per_second': 605.502, 'eval_steps_per_second': 37.91, 'epoch': 1.0}
このような 68%程度の精度は、感情分析タスクとしては健全で実用的なレベルです。
Step 4: モデル評価（scripts/evaluate_model.py）
# scripts/evaluate_model.py
# ファインチューニング済みモデルの評価スクリプト
# 必要なライブラリのインポート
import torch, pandas as pd, numpy as np, logging
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns, matplotlib.pyplot as plt
# ログレベルを設定
logging.basicConfig(level=logging.INFO)
def eval_model(model_dir="models/fine_tuned_sentiment_model", test_csv="data/test.csv"):
"""
ファインチューニング済みモデルをテストデータで評価する関数
Args:
model_dir: 保存されたモデルのディレクトリパス
test_csv: テストデータのCSVファイルパス
"""
# 使用デバイスを決定（CUDA利用可能ならGPU、そうでなければCPU）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 保存済みモデルとトークナイザーを読み込み
tok = AutoTokenizer.from_pretrained(model_dir)
# モデルを読み込み、指定デバイスに配置、評価モードに設定
# .eval(): ドロップアウトやバッチ正規化を評価用に切り替え
model = AutoModelForSequenceClassification.from_pretrained(model_dir).to(device).eval()
# テストデータをCSVから読み込み
df = pd.read_csv(test_csv)
# 結果を格納するリストを初期化
preds, trues, confs = [], [], []
# 各テストサンプルについて予測を実行
for t, y in zip(df["text"], df["label"]):
# テキストをトークナイズしてテンソル形式に変換
enc = tok(t,
truncation=True, # 最大長を超える場合は切り詰め
padding="max_length", # 最大長まで0埋め
max_length=128, # 最大系列長
return_tensors="pt") # PyTorchテンソル形式
# テンソルを指定デバイス（GPU/CPU）に移動
enc = {k:v.to(device) for k,v in enc.items()}
# 推論実行（勾配計算を無効にしてメモリ節約・高速化）
with torch.no_grad():
# モデルの出力からソフトマックス確率を計算
# dim=-1: 最後の次元（クラス方向）でソフトマックス
p = torch.softmax(model(**enc).logits, dim=-1)
# 最高確率のクラスインデックスを予測結果として保存
preds.append(int(torch.argmax(p, dim=-1).item()))
# 予測の信頼度（最高確率値）を保存
confs.append(float(torch.max(p).item()))
# 正解ラベルを保存
trues.append(int(y))
# 分類レポートを出力（精密度、再現率、F1スコアなど）
# target_names: 各クラスの名前を指定
print(classification_report(trues, preds, target_names=["ネガ", "中性", "ポジ"]))
# 混同行列（Confusion Matrix）を作成・保存
# labels=[0,1,2]: クラスの順序を明示的に指定
cm = confusion_matrix(trues, preds, labels=[0,1,2])
# matplotlib/seabornで混同行列を可視化
plt.figure(figsize=(6,5)) # 図のサイズ設定
sns.heatmap(cm, annot=True, fmt="d", # ヒートマップ作成、数値表示、整数フォーマット
xticklabels=["ネガ","中性","ポジ"], # X軸ラベル（予測）
yticklabels=["ネガ","中性","ポジ"]) # Y軸ラベル（正解）
plt.title("Confusion Matrix") # タイトル設定
plt.tight_layout() # レイアウト自動調整
# 混同行列を画像ファイルとして保存
plt.savefig("logs/confusion_matrix.png", dpi=200)
# スクリプトが直接実行された場合のみeval_model関数を呼び出す
if __name__=="__main__":
eval_model()
📈 評価結果の実例
実行結果例（70%の精度は実用的なレベル）:
$ python scripts/evaluate_model.py
precision recall f1-score support
Negative 0.69 0.64 0.66 809
Neutral 0.70 0.72 0.71 1664
Positive 0.70 0.72 0.71 945
accuracy 0.70 3418
macro avg 0.70 0.69 0.69 3418
weighted avg 0.70 0.70 0.70 3418
📊 精度（accuracy）の詳細説明
accuracy = 0.70 の意味:
- 何に対する: テストデータセット全体（3,418 サンプル）に対する
- 何の精度: 感情分析（3 クラス分類：Negative/Neutral/Positive）の正解率
- 具体的な意味: テストデータ 3,418 件のうち、70%（約 2,393 件）を正しく分類できた
各指標の解釈:
- Precision（適合率）: モデルが予測したもののうち、実際に正しかった割合
- Recall（再現率）: 実際の正解のうち、モデルが正しく検出できた割合
- F1-score: Precision と Recall の調和平均（バランスの取れた指標）
- Support: 各クラスのテストデータ数
実用性の評価:
- 感情分析タスクとしては実用的なレベル（人間でも主観で判断が分かれる）
- 3 クラス分類でランダムなら 33%なので、70%は十分有意
- 商用サービスでも 70-80%程度が一般的
- Neutral（中性）が最も性能が良く、Negative（ネガティブ）の検出が最も困難という典型的な傾向
Step 5: API 作成とテスト
Flask API（scripts/sentiment_api.py）
修正点
-
/healthに GPU 情報を返却 -
POST /batch_predictを実装 - 外部公開はせず、ローカルで起動 + SSH ポートフォワード でアクセスする運用を推奨
# scripts/sentiment_api.py
# ファインチューニング済み感情分析モデルのFlask API
# 必要なライブラリのインポート
from flask import Flask, request, jsonify
import torch, time
from transformers import AutoTokenizer, AutoModelForSequenceClassification
# Flaskアプリケーションのインスタンスを作成
app = Flask(__name__)
# 使用デバイスを決定（CUDA利用可能ならGPU、そうでなければCPU）
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# ファインチューニング済みモデルとトークナイザーをグローバルに読み込み
# アプリ起動時に一度だけ読み込み、以降のリクエストで再利用
tok = AutoTokenizer.from_pretrained("models/fine_tuned_sentiment_model")
model = AutoModelForSequenceClassification.from_pretrained("models/fine_tuned_sentiment_model").to(device).eval()
# 感情ラベルの定義（モデルの出力インデックスに対応）
LABELS = ["ネガティブ", "中性", "ポジティブ"]
def predict_one(text: str):
"""
単一テキストの感情分析を実行する関数
Args:
text: 分析対象の日本語テキスト
Returns:
tuple: (感情ラベル, 信頼度)
"""
# テキストをトークナイズしてモデル入力形式に変換
enc = tok(text,
truncation=True, # 最大長を超える場合は切り詰め
padding="max_length", # 最大長まで0埋め
max_length=128, # 最大系列長
return_tensors="pt") # PyTorchテンソル形式
# テンソルを指定デバイス（GPU/CPU）に移動
enc = {k:v.to(device) for k,v in enc.items()}
# 推論実行（勾配計算を無効にしてメモリ節約・高速化）
with torch.no_grad():
# モデルの出力logitsからソフトマックス確率を計算
p = torch.softmax(model(**enc).logits, dim=-1)
# 最高確率のクラスインデックスを取得
idx = int(torch.argmax(p, dim=-1).item())
# 予測の信頼度（最高確率値）を取得
conf = float(torch.max(p).item())
# インデックスを感情ラベルに変換して返す
return LABELS[idx], conf
@app.get("/health")
def health():
"""
APIの健康状態をチェックするエンドポイント
Returns:
JSON: システム情報とGPU情報
"""
# 基本的なシステム情報
info = {
"status": "healthy",
"gpu_available": torch.cuda.is_available(),
"device": str(device),
"time": time.time() # 現在時刻（Unix timestamp）
}
# GPU利用可能な場合は詳細情報を追加
if torch.cuda.is_available():
info["gpu_name"] = torch.cuda.get_device_name(0)
info["gpu_mem_GB"] = round(torch.cuda.get_device_properties(0).total_memory/1024**3,1)
return jsonify(info)
@app.post("/predict")
def predict():
"""
単一テキストの感情分析エンドポイント
Request Body:
JSON: {"text": "分析したいテキスト"}
Returns:
JSON: {"text": "入力テキスト", "sentiment": "感情ラベル", "confidence": 信頼度}
"""
# リクエストからJSONを取得し、textフィールドを抽出（デフォルトは空文字）
text = request.get_json(force=True).get("text","")
# 感情分析を実行
s, c = predict_one(text)
# 結果をJSONで返す
return jsonify({"text": text, "sentiment": s, "confidence": c})
@app.post("/batch_predict")
def batch_predict():
"""
複数テキストの一括感情分析エンドポイント
Request Body:
JSON: {"texts": ["テキスト1", "テキスト2", ...]}
Returns:
JSON: {"results": [{"index": 0, "text": "テキスト1", "sentiment": "ラベル", "confidence": 信頼度}, ...]}
"""
# リクエストからJSONを取得し、textsフィールドを抽出（デフォルトは空配列）
texts = request.get_json(force=True).get("texts", [])
# 結果を格納するリスト
out = []
# 各テキストについて感情分析を実行
for i, t in enumerate(texts):
s, c = predict_one(t)
# インデックス、元テキスト、結果をまとめて保存
out.append({"index": i, "text": t, "sentiment": s, "confidence": c})
# 結果をJSONで返す
return jsonify({"results": out})
# メイン実行部分
if __name__ == "__main__":
# ローカルホストのみでバインド（外部公開しない）
# セキュリティ上、外部からの直接アクセスは禁止
# SSH ポートフォワードでアクセスすることを想定
app.run(host="127.0.0.1", port=5000)
API テスト（scripts/test_api.py）
# scripts/test_api.py
# Flask APIの動作テストスクリプト
# HTTPリクエストを送信するライブラリとJSON処理ライブラリをインポート
import requests, json
# APIのベースURL（ローカルホストの5000番ポート）
BASE = "http://127.0.0.1:5000"
# 1. ヘルスチェックエンドポイントのテスト
# APIが正常に動作しているか、GPU情報等をチェック
print("Health:", requests.get(f"{BASE}/health").json())
# 2. 単一予測エンドポイントのテスト
# 1つのテキストに対する感情分析結果をテスト
print("Predict:", requests.post(f"{BASE}/predict", json={"text":"この商品は素晴らしい！"}).json())
# 3. バッチ予測エンドポイントのテスト
# 複数のテキストを一括で感情分析（異なる感情を含むテストケース）
print("Batch:", requests.post(f"{BASE}/batch_predict", json={"texts":["最高！","普通","最悪"]}).json())
起動とアクセス
# サーバー側（EC2）でAPIを起動
# 仮想環境を有効化してからFlask APIを起動
source ~/fine_tuning_env/bin/activate
python scripts/sentiment_api.py
# ローカル端末（別ターミナル）
# SSH ポートフォワードでローカルからEC2のAPIにアクセス可能にする
# -L: ローカルポートフォワード設定
# 5000:127.0.0.1:5000 : ローカルの5000番ポートをEC2の127.0.0.1:5000に転送
ssh -i your-key.pem -L 5000:127.0.0.1:5000 ubuntu@your-ec2-public-ip
# → この設定により、ローカルブラウザから http://127.0.0.1:5000/health にアクセス可能
なぜ外部公開しないのか？ SG を広く開けるのは避けるのがベストプラクティス。必要に応じて Session Manager も検討してください。(AWS ドキュメント)
🚀 API テストの実行結果
実際のテスト実行結果：
$ python scripts/test_api.py
Health: {'device': 'cuda', 'gpu_available': True, 'gpu_mem_GB': 14.6, 'gpu_name': 'Tesla T4', 'status': 'healthy', 'time': 1756554627.5767715}
Predict: {'confidence': 0.9883559942245483, 'sentiment': 'ポジティブ', 'text': 'この商品は素晴らしい！'}
Batch: {'results': [{'confidence': 0.9920651316642761, 'index': 0, 'sentiment': 'ポジティブ', 'text': '最高！'}, {'confidence': 0.940481424331665, 'index': 1, 'sentiment': '中性', 'text': '普通'}, {'confidence': 0.9627910852432251, 'index': 2, 'sentiment': 'ネガティブ', 'text': '最悪'}]}
✅ 結果評価：非常に良好
システム状態（Health チェック）:
- GPU 正常動作: Tesla T4（14.6GB）が適切に認識・利用されている
- API ステータス: healthy で正常稼働
予測精度:
- 単一予測: 「この商品は素晴らしい！」→「ポジティブ」（98.8%信頼度）✅ 正解
-
バッチ予測: 全 3 件とも直感的に正しい分類を実現
- 「最高！」→ ポジティブ（99.2%）
- 「普通」→ 中性（94.0%）
- 「最悪」→ ネガティブ（96.3%）
技術的成果:
- 高い信頼度: 全て 94%以上の確信度で予測
- API 機能完全動作: 単一予測・バッチ予測両方が正常
- GPU 活用: Tesla T4 での高速推論が実現
🎉 結論: ファインチューニングが成功し、実用的な感情分析 API が完成！この品質であれば実際のアプリケーションに組み込んで使用可能なレベルです。
成果物ダウンロード（scripts/download_results.sh）
- データセット（WRIME）の再配布は禁止（研究目的のみ・再配布不可）。アーカイブから data/ を除外します(Hugging Face)
- EC2 のパブリック IP 取得は IMDSv2 を利用。(AWS ドキュメント)
#!/usr/bin/env bash
# scripts/download_results.sh
# 学習結果をローカルダウンロード用にアーカイブ化するスクリプト
# エラー時にスクリプトを停止 + 未定義変数使用時にエラー
set -eu
# スクリプトのディレクトリに移動
cd "$(dirname "$0")"
# タイムスタンプ付きのアーカイブファイル名を生成
# date コマンドで現在時刻をYYYYMMDD_HHMMSS形式で取得
TS=$(date +"%Y%m%d_%H%M%S")
ARCH="sentiment_model_results_${TS}.tar.gz"
echo "Creating ${ARCH}..."
# tar コマンドでアーカイブを作成
# -c: アーカイブ作成モード
# -z: gzip圧縮を有効
# -f: アーカイブファイル名を指定
# -C ..: 一つ上のディレクトリ（プロジェクトルート）を起点とする
# models/fine_tuned_sentiment_model: 学習済みモデルをアーカイブに含める
# logs: ログファイル（学習履歴、評価結果等）をアーカイブに含める
# 注意: data/ は含めない（WRIMEデータセットの再配布は禁止されているため）
tar -czf "${ARCH}" \
-C .. models/fine_tuned_sentiment_model \
-C .. logs
# アーカイブ作成完了メッセージとファイルサイズを表示
echo "OK: ${ARCH} ($(du -h ${ARCH} | cut -f1))"
# EC2インスタンスのメタデータサービス（IMDSv2）を使用してパブリックIPを取得
# セキュリティ向上のため、トークンベース認証を使用
# 1. アクセストークンを取得（60秒間有効）
TOKEN=$(curl -s -X PUT "http://169.254.169.254/latest/api/token" \
-H "X-aws-ec2-metadata-token-ttl-seconds: 60")
# 2. トークンを使ってパブリックIPアドレスを取得
PUBIP=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/public-ipv4)
# ローカルマシンでの実行手順をユーザーに表示
cat <<EOF
ローカルで実行:
scp -i your-key.pem ubuntu@${PUBIP}:~/fine_tuning_project/scripts/${ARCH} ./
EOF
📦 成果物ダウンロードの実行例
実際のダウンロードスクリプト実行結果：
$ ./scripts/download_results.sh
Creating sentiment_model_results_20250830_121004.tar.gz...
OK: sentiment_model_results_20250830_121004.tar.gz (392M)
ローカルで実行:
scp -i your-key.pem ubuntu@xxx.xxx.xxx.xxx:~/sentiment_model_results_20250830_121004.tar.gz ./
成果物に含まれる内容:
- 学習済みモデルファイル（約 392MB）
- ログファイル（学習履歴、評価結果、GPU 監視データ）
- 混同行列の可視化画像
- TensorBoard ログ
注意事項: WRIME データセットは研究目的のみの利用で再配布が禁止されているため、data ディレクトリは意図的にアーカイブから除外されています。
これで完了！
- 上から順に実行すれば 環境構築 → 学習 → 評価 → API → 成果物取得 まで到達できます。加えて、
- セキュリティ（ポート公開禁止/SSM 推奨） と 最新ツールの導入 を本文へ組み込んでいます。
- 必要に応じて、社内環境・予算・運用ポリシーに合わせてパラメータを調整してください。
よくあるトラブルと対処法
学習関連
-
学習が OOM（Out of Memory）
-
gradient_checkpointing=True継続、バッチサイズをさらに下げる - より小さいモデル（bert-base → distilbert）を検討
-
-
eval_accuracy = 1.0 が連続で出る
- データ漏洩や過学習の疑い
- 検証データセットの品質確認（重複、サイズ等）
環境・接続関連
-
API が外部から見えない
- 仕様通りローカルバインド（127.0.0.1）。SSH ポートフォワード でアクセス
- セキュリティグループの設定確認
-
PyTorch が GPU を認識しない
- ドライバ/CUDA/PyTorch のビルド整合性を PyTorch 公式の手順で再確認。(PyTorch)
-
nvidia-smiでGPUドライバの状態確認
データセット関連
-
「Dataset scripts are no longer supported」エラー
- Hugging Face Datasets 4.0+ での仕様変更
- 直接ダウンロードへの変更、またはバージョンダウングレード検討
-
学習データが少なすぎる警告
- フォールバック機能により自動でサンプルデータ生成
- 実データが利用可能になった時点で再実行
この記事の執筆にはGithub Copilot Agent（VSCode）を使用しています。
以下の流れで作成しています。
8で実際に作業することも重要です！
- テーマを決める
- 雛形・見出しをざっくり決める
- チュートリアルを書いてもらう
- 書かれたチュートリアルを読む
- 4で気づいた点の指摘 + Copilotによるセルフレビュー
- 5で得られた指摘事項を修正してもらう
- 4, 5, 6の繰り返し
- 実際に作業する
- 作業中に発生したエラーや、古い情報などを加筆修正
参考資料
- PyTorch インストール（Compute Platform/バージョンはここで選択）(PyTorch)
- 東北大 BERT（日本語・WWS） モデルカード（語彙 32k、訓練データ等）(Hugging Face)
- WRIME データカード（スキーマ/ライセンス）(Hugging Face)
- DLAMI（Ubuntu 22.04 / PyTorch 2.6） リリースノート (AWS ドキュメント)
- EC2 オンデマンド料金（最新の料金を必ず確認）(Amazon Web Services, Inc.)
- Security Group と最小権限（VPC SG の基本）(AWS ドキュメント)
- Systems Manager Session Manager（SSH/RDP の代替） (AWS ドキュメント)
- nvidia-smi dmon（GPU 監視向け）(NVIDIA Docs)