Hugging Faceの使い方｜Transformersライブラリで最新AIモデルを動かす【完全ガイド】

はじめに：AI開発の革命、Hugging Faceへようこそ

現代のAI、特に自然言語処理（NLP）の世界は、大規模言語モデル（LLM）の登場によって劇的な変化を遂げています。GoogleのBERT、OpenAIのGPTシリーズ、MetaのLlamaなど、最先端のモデルが次々と発表され、その性能は日進月歩で向上しています。しかし、これらの巨大で複雑なモデルをゼロから学習させ、自分のプロジェクトで活用するのは、膨大な計算資源と専門知識を必要とし、一部の研究機関や大企業に限られた特権でした。

その壁を打ち破り、AI技術の民主化を推し進めているのが、今回特集する Hugging Face です。

Hugging Faceは、AI開発者や研究者のためのプラットフォームであり、コミュニティです。彼らが提供するエコシステムを使えば、世界中の開発者が共有した何十万もの学習済みモデルやデータセットに、まるでオープンソースのソフトウェアライブラリを使うかのように手軽にアクセスできます。

その中核をなすのが、Pythonライブラリである Transformers です。このライブラリは、複雑なモデルアーキテクチャの違いを吸収し、統一されたシンプルなインターフェースを提供します。これにより、私たちはわずか数行のコードで、最先端のAIモデルをダウンロードし、推論を実行し、さらには自分のデータでファインチューニング（追加学習）まですることが可能になります。

この記事では、AI開発のゲームチェンジャーであるHugging FaceとTransformersライブラリについて、以下の内容を網羅的に、そして初心者にも分かりやすく解説していきます。

Hugging Faceエコシステムの全体像: Transformersだけでなく、Hub, Datasets, Tokenizersなど、全体像を掴みます。
環境構築: 開発を始めるための準備をステップ・バイ・ステップで進めます。
pipelineによる簡単な使い方: まずは最も手軽な方法で、AIモデルのパワーを体感します。
モデルとトークナイザの直接操作: pipelineの裏側を理解し、より柔軟な制御を目指します。
ファインチューニングの実践: 既存のモデルを自分のタスクに特化させる、本格的な活用法を学びます。
発展的なトピック: 大規模モデルを効率的に扱うPEFTや、Webデモを作成するSpacesなど、さらに一歩進んだ使い方を紹介します。

この記事を読み終える頃には、あなたはHugging Faceを自在に操り、最新のAIモデルを自らの手で動かすための知識とスキルを身につけているはずです。さあ、AI開発の未来を共に探求しましょう。

1. Hugging Faceエコシステムの全体像

Hugging Faceは単なるライブラリではなく、AI開発を包括的にサポートする「エコシステム」です。主要な構成要素を理解することが、効果的な活用の第一歩となります。

(画像はHugging Faceのロゴ)

Hugging Face Hub

「AIモデルのGitHub」 とも呼ばれる、エコシステムの中心的なプラットフォームです。
* Models: 何十万もの事前学習済みモデルが登録されています。テキスト、画像、音声、マルチモーダルなど、あらゆる分野のモデルが見つかります。各モデルページには、モデルカード（説明書）、使用例、オンラインで試せる推論ウィジェットが用意されています。
* Datasets: モデルの学習や評価に使われる10万以上のデータセットがホストされています。これもModels同様、簡単に検索・ダウンロードできます。
* Spaces: GradioやStreamlitといったツールを使い、学習させたモデルのインタラクティブなWebデモを簡単に作成・ホストできるサービスです。自分の成果を世界中に公開し、フィードバックを得るのに最適です。
* Docs: 各ライブラリやコンセプトに関する詳細なドキュメントとチュートリアルが揃っています。

HubはGitベースで構築されており、モデルやデータセットのバージョン管理も容易です。

Transformers

本記事の主役となるライブラリです。PyTorch, TensorFlow, JAXといった主要な機械学習フレームワーク上で動作し、様々なモデルアーキテクチャ（BERT, GPT, T5, Llamaなど）を統一されたAPIで扱えるようにします。主な機能は以下の通りです。
* モデルのロードと推論: Hubからモデルを一行でダウンロードし、推論を実行。
* ファインチューニング: Trainerという高レベルAPIを使い、少ないコードで効率的なファインチ-ニングを実現。
* pipeline: 特定のタスク（感情分析、質問応答など）を非常に簡単に実行できる抽象化された機能。

Datasets

大規模なデータセット（数GB〜数TB）を効率的に扱うためのライブラリです。
* 高速なデータアクセス: Apache Arrowをバックエンドに採用し、メモリに収まらない巨大なデータも高速に処理します。
* ストリーミング: データセット全体をダウンロードせずに、必要な分だけをストリームして処理できます。
* 豊富な前処理機能: map, filter, shuffleなど、データセットを効率的に前処理するためのメソッドが豊富に用意されています。

Tokenizers

自然言語処理モデルは、テキストを直接理解できません。テキストを「トークン」と呼ばれる数値のIDに分割・変換するプロセス（トークナイゼーション）が必要であり、この処理を専門に行うのがTokenizersライブラリです。
* 高速処理: Rustで実装されており、非常に高速に動作します。
* 主要なアルゴリズムをサポート: BPE, WordPiece, Unigramなど、主要なトークナイゼーションアルゴリズムをサポートしています。
* Transformersライブラリとの密な連携: Transformersで使われるモデルのトークナイザは、このライブラリをベースにしています。

その他の重要なライブラリ

Accelerate: 複数GPUやTPUを使った分散学習、混合精度学習といった高度な学習設定を、コードをほとんど変更することなく実現します。
PEFT (Parameter-Efficient Fine-Tuning): LoRAに代表される、大規模モデルの全パラメータを更新するのではなく、ごく一部のパラメータを追加・更新するだけで効率的にファインチューニングする手法を簡単に実装できるライブラリです。

これらの要素が有機的に連携することで、Hugging FaceはAI開発のあらゆるフェーズを強力にサポートするプラットフォームとなっているのです。

2. 環境構築

それでは、実際に手を動かすための準備を始めましょう。ここではPythonの仮想環境を使い、必要なライブラリをインストールしていきます。

ステップ1：Python仮想環境の作成

プロジェクトごとに環境を分離するため、仮想環境を作成することを強く推奨します。

venvの場合:
“`bash

“hf-env”という名前の仮想環境を作成

python -m venv hf-env

仮想環境を有効化 (Windowsの場合は hf-env\Scripts\activate)

source hf-env/bin/activate
“`

condaの場合:
“`bash

“hf-env”という名前でPython 3.9の環境を作成

conda create -n hf-env python=3.9

仮想環境を有効化

conda activate hf-env
“`

ステップ2：必要なライブラリのインストール

Hugging Faceのエコシステムをフル活用するために、主要なライブラリをインストールします。

“`bash

PyTorchをベースにインストールします

pip install torch torchvision torchaudio

Hugging Faceの主要ライブラリをインストール

pip install transformers datasets accelerate sentencepiece
`` *torch: 機械学習フレームワーク本体。 *transformers: メインとなるライブラリ。 *datasets: データセットを扱うためのライブラリ。 *accelerate: 分散学習などを簡単にするライブラリ。 *sentencepiece`: T5やXLNetなど、多くのモデルで使われるトークナイザの実装。

ステップ3：Hugging Face Hubへのログイン

学習したモデルをHubにアップロードしたり、アクセス制限のあるモデルを利用したりするには、アカウント認証が必要です。

Hugging Faceのウェブサイトでアカウントを作成します。
アカウント設定ページの Access Tokens に移動し、新しいトークン（Roleはwriteを推奨）を作成してコピーします。
ターミナルで以下のコマンドを実行し、コピーしたトークンを貼り付けます。

bash huggingface-cli login

Jupyter NotebookやGoogle Colabを使っている場合は、以下のコードセルを実行すると便利です。

“`python
from huggingface_hub import notebook_login

notebook_login()
“`
入力欄が表示されるので、そこにトークンをペーストしてください。

これで開発環境の準備は完了です。いよいよTransformersライブラリの核心に触れていきましょう。

3. Transformersライブラリの核心：`pipeline`関数

Hugging Face Transformersの最も簡単で直感的な使い方が pipeline 関数です。これは、特定のタスク（例：文章の感情分析）に必要な「トークナイズ → モデル推論 → 後処理」という一連の流れをすべてカプセル化し、数行のコードで実行できるようにしたものです。

まずはpipelineの威力を見てみましょう。

例1：感情分析 (Text Classification)

文章がポジティブかネガティブかを判定します。

“`python
from transformers import pipeline

感情分析パイプラインをロード

初回実行時にはモデルのダウンロードが自動的に行われます

classifier = pipeline(“sentiment-analysis”)

分析したいテキストを渡す

result = classifier(“I’ve been waiting for a Hugging Face course my whole life.”)
print(result)

出力例: [{‘label’: ‘POSITIVE’, ‘score’: 0.9998634457588196}]

result = classifier(“I hate this so much!”)
print(result)

出力例: [{‘label’: ‘NEGATIVE’, ‘score’: 0.9994558691978455}]

“`

たったこれだけです。pipeline("sentiment-analysis") の一行で、Hugging Face Hubから感情分析タスクに適したデフォルトのモデル（例えば distilbert-base-uncased-finetuned-sst-2-english）が自動的に選ばれ、ダウンロード・セットアップされます。あとはテキストを渡すだけで、ラベル（POSITIVE/NEGATIVE）とその確信度（score）が返ってきます。

`pipeline`がサポートする多様なタスク

pipelineは感情分析以外にも、非常に多くのタスクをサポートしています。いくつか代表的なものを紹介します。

ゼロショット分類 (Zero-Shot Classification)
事前に学習されていないラベルに対しても分類ができる、非常に強力な機能です。

“`python
from transformers import pipeline

classifier = pipeline(“zero-shot-classification”)

sequence_to_classify = “This is a course about the Transformers library”
candidate_labels = [“education”, “politics”, “business”]

result = classifier(sequence_to_classify, candidate_labels)
print(result)

出力例:

{‘sequence’: ‘This is a course about the Transformers library’,

‘labels’: [‘education’, ‘business’, ‘politics’],

‘scores’: [0.9845, 0.0094, 0.0059]}

“`
「教育」「政治」「ビジネス」というラベルで学習していないにも関わらず、文脈から「education」が最も関連性が高いと判断しています。

テキスト生成 (Text Generation)
与えられたテキストの続きを生成します。

“`python
from transformers import pipeline

generator = pipeline(“text-generation”, model=”gpt2″)

result = generator(
“In a world where AI is becoming increasingly powerful,”,
max_length=50,
num_return_sequences=2,
)
print(result)

出力例:

[{‘generated_text’: ‘In a world where AI is becoming increasingly powerful, the question of whether or not to regulate its use has become a major topic of debate. The issue has been raised by a number of prominent figures in the field, including Stephen Hawking’},

{‘generated_text’: ‘In a world where AI is becoming increasingly powerful, a new generation of AI-powered tools is emerging to help us make sense of the world around us. The latest is a new AI-powered tool called the “AI-pow’}]

``model引数で、特定のモデル（ここではgpt2`）を指定することもできます。

質問応答 (Question Answering)
文脈（context）と質問（question）を渡すと、文脈の中から答えを探し出します。

“`python
from transformers import pipeline

qa_pipeline = pipeline(“question-answering”)

context = “Hugging Face is a company based in New York City. Its headquarters are in Dumbo, Brooklyn.”
question = “Where is Hugging Face’s headquarters?”

result = qa_pipeline(question=question, context=context)
print(result)

出力例:

{‘score’: 0.932, ‘start’: 65, ‘end’: 81, ‘answer’: ‘Dumbo, Brooklyn’}

“`

要約 (Summarization)
長い文章を短い要約文にまとめます。

“`python
from transformers import pipeline

summarizer = pipeline(“summarization”)

long_text = “””
(ここに長いニュース記事などを挿入)
“””

summary = summarizer(long_text, max_length=130, min_length=30, do_sample=False)
print(summary)
“`

`pipeline`の裏側

pipelineは魔法のように見えますが、内部では以下の3つのステップが整然と実行されています。

前処理 (Preprocessing): 入力された生のテキストを、モデルが理解できる形式（数値のID配列、いわゆるテンソル）に変換します。この処理は Tokenizer が担当します。
モデル推論 (Model Inference): 前処理されたテンソルを、ロードされた事前学習済みモデルに入力し、予測結果（ロジットと呼ばれる生の数値スコア）を得ます。
後処理 (Postprocessing): モデルが出力したロジットを、人間が理解しやすい形式（例：ラベル名、確率スコア、生成されたテキスト）に変換します。

pipelineはこれらの複雑な処理を隠蔽してくれる便利なツールですが、より高度なカスタマイズや、処理の内部を深く理解するためには、これらのステップを個別に実行する方法を知ることが重要になります。次のセクションでは、その方法を詳しく見ていきましょう。

4. モデルとトークナイザを直接操作する

pipelineの便利さを超えて、より柔軟にモデルを制御したい場合、前処理、モデル推論、後処理の各ステップを自分でコーディングする必要があります。Hugging Faceはこれを実現するために AutoClass という便利な機能を提供しています。

AutoClass は、Hubにあるモデル名を指定するだけで、そのモデルに最適なアーキテクチャ、設定、そしてトークナイザを自動的に判別してインスタンス化してくれるクラス群です。

AutoTokenizer: モデルに対応するトークナイザをロードします。
AutoModel: モデルの本体（特徴量抽出部分）をロードします。
AutoModelFor[Task]: 特定のタスク（例：SequenceClassification, QuestionAnswering）に適したヘッド（出力層）が追加されたモデルをロードします。

ここでは、感情分析タスクを例に、pipelineの裏側を手動で再現してみましょう。

ステップ・バイ・ステップ：手動での感情分析

使用するモデルはpipelineでデフォルトで使われていた distilbert-base-uncased-finetuned-sst-2-english です。

ステップ1：モデルとトークナイザのロード

まず、AutoTokenizerと、今回は分類タスクなのでAutoModelForSequenceClassificationを使って、必要なコンポーネントをHubからロードします。

“`python
from transformers import AutoTokenizer, AutoModelForSequenceClassification

モデル名を指定

checkpoint = “distilbert-base-uncased-finetuned-sst-2-english”

モデル名からトークナイザをロード

tokenizer = AutoTokenizer.from_pretrained(checkpoint)

モデル名からタスク用のモデルをロード

model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
“`
初回実行時には、モデルの重みファイルなどがダウンロードされます。一度ダウンロードされれば、次回以降はキャッシュから高速に読み込まれます。

ステップ2：前処理（トークナイゼーション）

次に、入力テキストをトークナイザで処理します。

“`python
raw_inputs = [
“I’ve been waiting for a Hugging Face course my whole life.”,
“I hate this so much!”,
]

トークナイザに入力テキストを渡す

padding=True: バッチ内のシーケンス長を最長のものに合わせる

truncation=True: モデルの最大長を超えるシーケンスを切り詰める

return_tensors=”pt”: PyTorchのテンソル形式で結果を返す

inputs = tokenizer(
raw_inputs, padding=True, truncation=True, return_tensors=”pt”
)

inputsの中身を確認

print(inputs)
“`

出力は以下のようになります。
{ 'input_ids': tensor([ [ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102], [ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0] ]), 'attention_mask': tensor([ [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0] ]) }
* input_ids: テキストがトークンIDのシーケンスに変換されています。[CLS](101)や[SEP](102)といった特殊トークンが付与され、2番目の文は長さが短いため、パディングトークン(0)で埋められています。
* attention_mask: モデルが注意（attention）を払うべきトークンを示します。パディング部分は0になっており、計算から除外されます。

ステップ3：モデル推論

前処理されたinputsをモデルに渡します。**inputsという記法は、辞書のキーを引数名、値を引数値として関数に渡すPythonのテクニックです。

“`python
import torch

モデルにinputsを渡して推論を実行

with torch.no_grad(): # 勾配計算を無効にし、メモリ効率を上げる
outputs = model(**inputs)

モデルの出力を確認

print(outputs)
“`

出力は以下のようになります。
SequenceClassifierOutput( loss=None, logits=tensor([ [-4.2678, 4.6293], [ 3.1931, -2.6788] ]), hidden_states=None, attentions=None )
重要なのは logits です。これはモデルが出力した生のスコアで、各クラス（このモデルの場合は「NEGATIVE」と「POSITIVE」）に対応します。このままでは解釈が難しいので、後処理が必要です。

ステップ4：後処理

logitsを人間が理解しやすい確率に変換し、ラベルと紐付けます。

“`python

logitsを取得

logits = outputs.logits
print(logits)

tensor([[-4.2678, 4.6293], [ 3.1931, -2.6788]])

Softmax関数を適用して確率に変換

predictions = torch.nn.functional.softmax(logits, dim=-1)
print(predictions)

tensor([[1.3684e-04, 9.9986e-01], [9.9746e-01, 5.4418e-04]])

``softmaxを適用すると、各行の合計が1になる確率分布が得られます。 * 1行目:[0.00013, 0.99986]-> 2番目のクラスの確率が非常に高い * 2行目:[0.99746, 0.00054]` -> 1番目のクラスの確率が非常に高い

最後に、これらのインデックスがどのラベルに対応するかを確認します。これはモデルの設定情報（config）に含まれています。

“`python

モデルのラベルマッピングを確認

print(model.config.id2label)

{0: ‘NEGATIVE’, 1: ‘POSITIVE’}

各入力に対する予測ラベルを取得

predicted_labels = torch.argmax(predictions, dim=1)
print(predicted_labels)

tensor([1, 0])

ラベル名に変換して表示

for i, label_id in enumerate(predicted_labels):
print(f”Input: ‘{raw_inputs[i]}'”)
print(f”Predicted label: {model.config.id2label[label_id.item()]}”)

Input: ‘I’ve been waiting for a Hugging Face course my whole life.’

Predicted label: POSITIVE

Input: ‘I hate this so much!’

Predicted label: NEGATIVE

“`

これで、pipelineが内部で行っている処理を完全に再現できました。この知識があれば、例えばlogitsを直接使って特殊な損失関数を計算したり、モデルの中間層の出力（hidden_states）を取り出して別のタスクに利用したりと、応用範囲が格段に広がります。

5. ファインチューニングの実践

事前学習済みモデルは強力ですが、その真価は特定のタスクやドメインのデータに適応させるファインチューニングによって最大限に引き出されます。ファインチューニングとは、大規模なデータで事前学習されたモデルの重みを初期値として、自分の持っている（比較的小規模な）データセットで追加学習を行うプロセスです。

ここでは、Hugging Faceの Trainer API を使って、テキスト分類モデルをファインチューニングする一連の流れを解説します。Trainerは、学習ループ、評価、チェックポイント保存などの面倒な処理を抽象化し、研究者や開発者が本質的な部分に集中できるように設計されています。

ファインチューニングの全体像

データセットの準備: Datasetsライブラリでデータセットをロードし、前処理を行う。
モデルのロード: ファインチューニングのベースとなる事前学習済みモデルをロードする。
学習の設定: TrainingArgumentsで学習率やエポック数などのハイパーパラメータを定義する。
評価指標の定義: 学習中にモデルの性能を測るための関数を準備する。
Trainerの初期化: モデル、設定、データセット、評価指標などをTrainerに渡す。
学習の実行: trainer.train()を呼び出してファインチューニングを開始する。
結果の共有: 学習済みモデルをHubにアップロードする。

例：IMDb映画レビューデータセットでの感情分析モデルのファインチューニング

ステップ1：データセットの準備

Datasetsライブラリを使って、IMDbデータセット（映画レビューのポジティブ/ネガティブ分類）をロードします。

“`python
from datasets import load_dataset
from transformers import AutoTokenizer

IMDbデータセットをロード

imdb = load_dataset(“imdb”)

ファインチューニングのベースとなるモデルと、そのトークナイザをロード

BERTの軽量版であるDistilBERTを使用

tokenizer = AutoTokenizer.from_pretrained(“distilbert-base-uncased”)

トークナイゼーションをデータセット全体に適用する関数

def preprocess_function(examples):
# ‘text’カラムのテキストをトークナイズ
return tokenizer(examples[“text”], truncation=True)

データセットの各分割（train, test）に前処理を適用

batched=Trueで複数サンプルを一度に処理し高速化

tokenized_imdb = imdb.map(preprocess_function, batched=True)

学習に必要なカラムだけを残し、PyTorchテンソル形式に変換

tokenized_imdb = tokenized_imdb.remove_columns([“text”])
tokenized_imdb = tokenized_imdb.rename_column(“label”, “labels”)
tokenized_imdb.set_format(“torch”)

データセットを小さくして、デモを高速化（実際の学習では全データを使う）

small_train_dataset = tokenized_imdb[“train”].shuffle(seed=42).select(range(1000))
small_eval_dataset = tokenized_imdb[“test”].shuffle(seed=42).select(range(1000))
“`

ステップ2：モデルのロード

今回は分類タスクなので AutoModelForSequenceClassification を使います。num_labels引数で、このタスクのラベル数（IMDbはポジティブ/ネガティブの2つ）を指定することが重要です。

“`python
from transformers import AutoModelForSequenceClassification

model = AutoModelForSequenceClassification.from_pretrained(
“distilbert-base-uncased”, num_labels=2
)
“`

ステップ3：学習の設定

TrainingArgumentsクラスに、学習に関するあらゆる設定を渡します。出力ディレクトリ、評価のタイミング、学習率、バッチサイズなどを指定します。

“`python
from transformers import TrainingArguments

学習設定を定義

output_dirはモデルのチェックポイントが保存される場所

push_to_hub=Trueにすると、学習後に自動でHubにアップロードされる

training_args = TrainingArguments(
output_dir=”my_awesome_imdb_model”,
evaluation_strategy=”epoch”, # 1エポックごとに評価
learning_rate=2e-5,
per_device_train_batch_size=16,
per_device_eval_batch_size=16,
num_train_epochs=3,
weight_decay=0.01,
push_to_hub=True, # HubにアップロードするためにTrueに設定
)
``push_to_hub=Trueとするには、事前にhuggingface-cli loginが必要です。output_dir`で指定した名前が、Hub上のリポジトリ名になります。

ステップ4：評価指標の定義

学習中にモデルの性能を客観的に評価するため、正解率（accuracy）などを計算する関数を定義します。

“`python
import numpy as np
import evaluate # Hugging Faceの評価ライブラリ

評価指標としてaccuracyをロード

metric = evaluate.load(“accuracy”)

評価時に呼び出される関数

def compute_metrics(eval_pred):
logits, labels = eval_pred
predictions = np.argmax(logits, axis=-1)
return metric.compute(predictions=predictions, references=labels)
“`

ステップ5＆6：`Trainer`の初期化と学習実行

すべての準備が整いました。これらをTrainerクラスに渡して、train()メソッドを呼び出すだけです。

“`python
from transformers import Trainer

Trainerを初期化

trainer = Trainer(
model=model,
args=training_args,
train_dataset=small_train_dataset,
eval_dataset=small_eval_dataset,
compute_metrics=compute_metrics,
tokenizer=tokenizer, # トークナイザも渡すと、モデルと一緒に保存・アップロードされて便利
)

ファインチューニングを開始

trainer.train()
“`
学習が始まると、プログレスバーと共にlossやvalidation accuracyが表示されます。GPUが利用可能な環境では、自動的にGPUが使われます。

ステップ7：結果の共有

TrainingArgumentsでpush_to_hub=Trueと設定したので、学習が完了すると自動的にモデルがHubにアップロードされます。もし手動でアップロードしたい場合は、trainer.push_to_hub()を呼び出します。

“`python

手動でアップロードする場合

trainer.push_to_hub(commit_message=”Training complete!”)

`` アップロードが完了すると、https://huggingface.co/<あなたのユーザー名>/my_awesome_imdb_modelのようなURLに自分だけのモデルページが作成されます。このページから、誰でもあなたのモデルをpipelineやfrom_pretrained`で利用できるようになります。

“`python

他の人があなたのモデルを使う例

from transformers import pipeline

Hub上のあなたのリポジトリ名を指定

trained_classifier = pipeline(“sentiment-analysis”, model=”<あなたのユーザー名>/my_awesome_imdb_model”)

試してみる

result = trained_classifier(“This movie was absolutely fantastic!”)
print(result)
“`

以上が、Trainer APIを使ったファインチューニングの基本的な流れです。この強力なAPIを使いこなすことで、最先端モデルを自分の課題に合わせてカスタマイズする道が大きく開かれます。

6. 発展的なトピック

Hugging Faceエコシステムは、基本的な使い方にとどまらず、より高度で実践的なシナリオにも対応しています。ここでは、近年のトレンドとなっている大規模モデルの効率的な扱い方や、成果を共有するためのデモ作成について紹介します。

a. PEFTとLoRAによるパラメータ効率の良いファインチューニング

GPT-3やLlama 2のような数十億〜数百億パラメータを持つ巨大なモデルは、ファインチューニングするだけでも高性能なGPUメモリ（VRAM）を大量に消費し、個人や中小企業には手が出しにくいものでした。

この問題を解決するのが PEFT (Parameter-Efficient Fine-Tuning) というアプローチです。PEFTは、モデルの全パラメータ（数十億個）を更新するのではなく、ごく一部（数百万個）の追加パラメータだけを学習します。これにより、必要な計算資源とメモリを劇的に削減できます。

その代表的な手法が LoRA (Low-Rank Adaptation) です。LoRAは、Transformerモデル内の特定の層（主にAttention層）に、低ランクの小さな行列を2つ追加し、学習時にはこの追加した行列だけを更新します。

Hugging Faceの peft ライブラリを使えば、LoRAを驚くほど簡単に導入できます。

“`python
from peft import get_peft_model, LoraConfig, TaskType

LoRAの設定を定義

lora_config = LoraConfig(
task_type=TaskType.SEQ_CLS, # タスクタイプ（今回は系列分類）
r=8, # LoRAのランク（小さいほどパラメータが少ない）
lora_alpha=32, # LoRAのスケーリング係数
lora_dropout=0.1,
target_modules=[“query”, “value”], # LoRAを適用する層の名前
)

ベースモデルを取得

base_model = AutoModelForSequenceClassification.from_pretrained(
“distilbert-base-uncased”, num_labels=2
)

ベースモデルにLoRAを適用

peft_model = get_peft_model(base_model, lora_config)

学習可能なパラメータ数を確認

peft_model.print_trainable_parameters()

出力例: trainable params: 294,914 || all params: 67,255,298 || trainable%: 0.4385

`` 全パラメータの0.5%弱しか学習しないにもかかわらず、多くの場合、フルファインチューニングに近い性能を達成できます。あとは、このpeft_modelをTrainer` に渡すだけで、通常通り学習を進められます。

b. Accelerateによる分散学習の簡素化

モデルが大きくなったり、データセットが巨大になったりすると、1つのGPUでは学習に時間がかかりすぎることがあります。複数のGPUやTPUを使って学習を高速化する「分散学習」が必要になりますが、通常その実装は複雑です。

accelerate ライブラリは、この分散学習のコードを劇的に簡潔にします。

通常のPyTorchコード:
“`python

model, optimizer, train_dataloaderなどを定義

…

device = “cuda”
model.to(device)

for epoch in range(num_epochs):
for batch in train_dataloader:
batch = {k: v.to(device) for k, v in batch.items()}
outputs = model(**batch)
loss = outputs.loss
loss.backward()
optimizer.step()
optimizer.zero_grad()
“`

accelerateを使ったコード:
“`python
from accelerate import Accelerator

accelerator = Accelerator()

model, optimizer, train_dataloaderなどを定義

…

準備

model, optimizer, train_dataloader = accelerator.prepare(
model, optimizer, train_dataloader
)

for epoch in range(num_epochs):
for batch in train_dataloader:
# batchは自動で適切なデバイスに送られる
outputs = model(**batch)
loss = outputs.loss
accelerator.backward(loss) # loss.backward()の代わりにこれを使う
optimizer.step()
optimizer.zero_grad()
``accelerator.prepare()でオブジェクトをラップし、loss.backward()をaccelerator.backward(loss)に変えるだけで、あとはaccelerate launch` コマンドでスクリプトを実行すれば、自動的に環境（単一GPU、複数GPU、TPUなど）を検知して最適な分散学習を行ってくれます。

c. GradioとSpacesによるインタラクティブなデモ作成

学習したモデルは、自分だけでなく他の人にも使ってもらってこそ価値が高まります。Hugging Face Spacesは、GradioやStreamlitといったライブラリを使って、インタラクティブなWebデモを簡単に作成・ホストできる無料のプラットフォームです。

特にGradioは、数行のコードで機械学習モデルのUIを構築できます。

“`python

app.pyというファイルに保存

import gradio as gr
from transformers import pipeline

ファインチューニングした自分のモデルをロード

pipe = pipeline(“sentiment-analysis”, model=”<あなたのユーザー名>/my_awesome_imdb_model”)

def predict_sentiment(text):
# pipelineの出力をGradioが扱いやすい形式に整形
result = pipe(text)[0]
return {result[‘label’]: result[‘score’]}

Gradioインターフェースを作成

iface = gr.Interface(
fn=predict_sentiment,
inputs=gr.Textbox(lines=2, placeholder=”Enter a movie review…”),
outputs=”label”,
title=”IMDb Sentiment Analyzer”,
description=”A simple demo of a sentiment analysis model fine-tuned on the IMDb dataset.”,
)

デモを起動

iface.launch()
`` このapp.pyと、依存関係を記述したrequirements.txt` をHub上の新しいSpaceリポジトリにプッシュするだけで、Webデモが自動的にビルドされ、公開されます。

7. まとめ

本記事では、AI開発のプラットフォームであるHugging Face、特にその中核をなすTransformersライブラリの使い方について、網羅的に解説しました。

pipeline: 数行のコードで最新AIモデルの驚異的な性能を手軽に体験できる、最も簡単な入り口。
モデルとトークナイザの直接操作: pipelineの裏側を理解し、AutoClassを通じて処理を細かく制御することで、応用の幅を広げるステップ。
Trainerによるファインチューニング: 事前学習済みモデルを自分のデータセットで追加学習させ、特定のタスクに特化した高性能なモデルを自ら作り出す、本格的な活用法。
PEFT, Accelerate, Spaces: 大規模モデルを効率的に扱い、学習をスケールさせ、成果を世界に共有するための発展的なツール群。

Hugging Faceエコシステムは、単にツールを提供するだけでなく、オープンなコミュニティを通じてモデルやデータセット、知識を共有し、誰もが最先端のAI技術にアクセスできる環境を構築しています。かつては専門家だけのものだった高度なAIモデルが、今やあなたの手の中にあります。

この記事が、あなたのAI開発の旅における羅針盤となれば幸いです。Hugging Faceの公式ドキュメント、コース、ブログなどを参考にしながら、ぜひ様々なモデルやタスクに挑戦してみてください。AIで何ができるのか、その可能性は無限大です。さあ、創造の翼を広げましょう。

Hugging Faceの使い方｜Transformersライブラリで最新AIモデルを動かす【完全ガイド】

はじめに：AI開発の革命、Hugging Faceへようこそ

1. Hugging Faceエコシステムの全体像

Hugging Face Hub

Transformers

Datasets

Tokenizers

その他の重要なライブラリ

2. 環境構築

ステップ1：Python仮想環境の作成

“hf-env”という名前の仮想環境を作成

仮想環境を有効化 (Windowsの場合は hf-env\Scripts\activate)

“hf-env”という名前でPython 3.9の環境を作成

仮想環境を有効化

ステップ2：必要なライブラリのインストール

PyTorchをベースにインストールします

Hugging Faceの主要ライブラリをインストール

ステップ3：Hugging Face Hubへのログイン

3. Transformersライブラリの核心：pipeline関数

例1：感情分析 (Text Classification)

感情分析パイプラインをロード

初回実行時にはモデルのダウンロードが自動的に行われます

分析したいテキストを渡す

出力例: [{‘label’: ‘POSITIVE’, ‘score’: 0.9998634457588196}]

出力例: [{‘label’: ‘NEGATIVE’, ‘score’: 0.9994558691978455}]

pipelineがサポートする多様なタスク

出力例:

{‘sequence’: ‘This is a course about the Transformers library’,

‘labels’: [‘education’, ‘business’, ‘politics’],

‘scores’: [0.9845, 0.0094, 0.0059]}

出力例:

[{‘generated_text’: ‘In a world where AI is becoming increasingly powerful, the question of whether or not to regulate its use has become a major topic of debate. The issue has been raised by a number of prominent figures in the field, including Stephen Hawking’},

{‘generated_text’: ‘In a world where AI is becoming increasingly powerful, a new generation of AI-powered tools is emerging to help us make sense of the world around us. The latest is a new AI-powered tool called the “AI-pow’}]

出力例:

{‘score’: 0.932, ‘start’: 65, ‘end’: 81, ‘answer’: ‘Dumbo, Brooklyn’}

pipelineの裏側

4. モデルとトークナイザを直接操作する

ステップ・バイ・ステップ：手動での感情分析

ステップ1：モデルとトークナイザのロード

モデル名を指定

モデル名からトークナイザをロード

モデル名からタスク用のモデルをロード

ステップ2：前処理（トークナイゼーション）

トークナイザに入力テキストを渡す

padding=True: バッチ内のシーケンス長を最長のものに合わせる

truncation=True: モデルの最大長を超えるシーケンスを切り詰める

return_tensors=”pt”: PyTorchのテンソル形式で結果を返す

inputsの中身を確認

ステップ3：モデル推論

モデルにinputsを渡して推論を実行

モデルの出力を確認

ステップ4：後処理

logitsを取得

tensor([[-4.2678, 4.6293], [ 3.1931, -2.6788]])

Softmax関数を適用して確率に変換

tensor([[1.3684e-04, 9.9986e-01], [9.9746e-01, 5.4418e-04]])

モデルのラベルマッピングを確認

{0: ‘NEGATIVE’, 1: ‘POSITIVE’}

各入力に対する予測ラベルを取得

tensor([1, 0])

ラベル名に変換して表示

Input: ‘I’ve been waiting for a Hugging Face course my whole life.’

Predicted label: POSITIVE

Input: ‘I hate this so much!’

Predicted label: NEGATIVE

5. ファインチューニングの実践

ファインチューニングの全体像

例：IMDb映画レビューデータセットでの感情分析モデルのファインチューニング

ステップ1：データセットの準備

IMDbデータセットをロード

ファインチューニングのベースとなるモデルと、そのトークナイザをロード

BERTの軽量版であるDistilBERTを使用

トークナイゼーションをデータセット全体に適用する関数

データセットの各分割（train, test）に前処理を適用

batched=Trueで複数サンプルを一度に処理し高速化

学習に必要なカラムだけを残し、PyTorchテンソル形式に変換

データセットを小さくして、デモを高速化（実際の学習では全データを使う）

ステップ2：モデルのロード

ステップ3：学習の設定

学習設定を定義

3. Transformersライブラリの核心：`pipeline`関数

`pipeline`がサポートする多様なタスク

`pipeline`の裏側

ステップ5＆6：`Trainer`の初期化と学習実行

コメントする返信をキャンセル