# 画像分類

画像分類は、画像にラベルまたはクラスを割り当てます。テキストや音声の分類とは異なり、入力となるのは画像を構成するピクセル値です。画像分類には、自然災害後の被害の検出、作物の健全性の監視、疾患の兆候をスクリーニングするための医療画像の支援など、多くの応用があります。

このガイドでは、次の方法について説明します。

1. [Food-101](https://huggingface.co/datasets/ethz/food101) データセットで [ViT](../model_doc/vit) をファインチューニングして、画像内の食品を分類します。
2. ファインチューニングしたモデルを推論に使用します。

このタスクと互換性のあるすべてのアーキテクチャとチェックポイントを確認するには、[タスクページ](https://huggingface.co/tasks/image-classification)を参照することをお勧めします。

開始前に、必要なライブラリがすべてインストールされていることを確認してください。

```bash
pip install transformers datasets evaluate accelerate pillow torchvision scikit-learn trackio
```

Hugging Face アカウントにログインして、モデルをアップロードし、コミュニティと共有することをお勧めします。プロンプトが表示されたら、ログイン用のトークンを入力してください:

```py
>>> from huggingface_hub import notebook_login

>>> notebook_login()
```

## Food-101 データセットを読み込む

🤗 Datasets ライブラリから、Food-101 データセットのより小さなサブセットを読み込むことから始めます。これにより、フルデータセットでの学習により多くの時間を費やす前に、実験を行い、すべてが正常に動作することを確認する機会が得られます。

```py
>>> from datasets import load_dataset

>>> food = load_dataset("ethz/food101", split="train[:5000]")
```

[train_test_split](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.train_test_split) メソッドを使用して、データセットの`train` スプリットを学習セットとテストセットに分割します:

```py
>>> food = food.train_test_split(test_size=0.2)
```

次に、例を見てみましょう。

```py
>>> food["train"][0]
{'image': <PIL.JpegImagePlugin.JpegImageFile image mode=RGB size=512x512 at 0x7F52AFC8AC50>,
 'label': 79}
```

データセットの各サンプルには2つのフィールドがあります。

- `image`: 食品のPIL画像
- `label`: 食品項目のラベルクラス

モデルがラベルIDからラベル名を取得しやすくするために、ラベル名と整数を相互にマッピングする辞書を作成します：

```py
>>> labels = food["train"].features["label"].names
>>> label2id, id2label = dict(), dict()
>>> for i, label in enumerate(labels):
...     label2id[label] = str(i)
...     id2label[str(i)] = label
```

これで、ラベルIDをラベル名に変換できます。

```py
>>> id2label[str(79)]
'prime_rib'
```

## 前処理

次のステップは、ViTの画像プロセッサを読み込み、画像をテンソルに変換することです:

```py
>>> from transformers import AutoImageProcessor

>>> checkpoint = "google/vit-base-patch16-224-in21k"
>>> image_processor = AutoImageProcessor.from_pretrained(checkpoint)
```

モデルの過学習に対する頑健性を高めるために、画像にいくつかの画像変換を適用します。ここでは [`transforms`](https://pytorch.org/vision/stable/transforms.html) モジュールを使用しますが、お好みの画像ライブラリを使用することもできます。

画像のランダムな部分を切り出し、リサイズし、画像の平均と標準偏差で正規化します:

```py
>>> from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor

>>> normalize = Normalize(mean=image_processor.image_mean, std=image_processor.image_std)
>>> size = (
...     image_processor.size["shortest_edge"]
...     if "shortest_edge" in image_processor.size
...     else (image_processor.size["height"], image_processor.size["width"])
... )
>>> _transforms = Compose([RandomResizedCrop(size), ToTensor(), normalize])
```

次に、変換を適用して画像の`pixel_values`（モデルへの入力）を返す前処理関数を作成します:

```py
>>> def transforms(examples):
...     examples["pixel_values"] = [_transforms(img.convert("RGB")) for img in examples["image"]]
...     del examples["image"]
...     return examples
```

データセット全体に前処理関数を適用するには、🤗 Datasets の [with_transform](https://huggingface.co/docs/datasets/v5.2.0/en/package_reference/main_classes#datasets.Dataset.with_transform) メソッドを使用します。データセットの要素を読み込む際に、トランスフォームがオンザフライで適用されます:

```py
>>> food = food.with_transform(transforms)
```

次に、[DefaultDataCollator](/docs/transformers/v5.23.0/ja/main_classes/data_collator#transformers.DefaultDataCollator)を使用してバッチの例を作成します。🤗 Transformersの他のデータコラレーターとは異なり、`DefaultDataCollator`はパディングなどの追加の前処理を適用しません。

```py
>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator()
```

## 評価

学習中にメトリクスを含めることは、モデルの性能を評価する上でしばしば役立ちます。🤗 [Evaluate](https://huggingface.co/docs/evaluate/index) ライブラリを使用すると、評価メソッドをすばやく読み込むことができます。このタスクでは、[accuracy](https://huggingface.co/spaces/evaluate-metric/accuracy) メトリクスを読み込みます（メトリクスの読み込みと計算方法の詳細については、🤗 Evaluate の [quick tour](https://huggingface.co/docs/evaluate/a_quick_tour) を参照してください）：

```py
>>> import evaluate

>>> accuracy = evaluate.load("accuracy")
```

次に、予測値とラベルを[compute](https://huggingface.co/docs/evaluate/v0.4.6/en/package_reference/main_classes#evaluate.EvaluationModule.compute)に渡して正解率を計算する関数を作成します。

```py
>>> import numpy as np

>>> def compute_metrics(eval_pred):
...     predictions, labels = eval_pred
...     predictions = np.argmax(predictions, axis=1)
...     return accuracy.compute(predictions=predictions, references=labels)
```

`compute_metrics`関数はこれで準備が整いました。学習を設定する際に、この関数に戻ります。

## 学習

[Trainer](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.Trainer)によるモデルのファインチューニングに慣れていない場合は、[こちら](../training)の基本的なチュートリアルをご覧ください!

いよいよモデルの学習を開始できます![AutoModelForImageClassification](/docs/transformers/v5.23.0/ja/model_doc/auto#transformers.AutoModelForImageClassification)でViTを読み込みます。ラベルの数と、期待されるラベルの数、およびラベルのマッピングを指定します:

```py
>>> from transformers import AutoModelForImageClassification, TrainingArguments, Trainer

>>> model = AutoModelForImageClassification.from_pretrained(
...     checkpoint,
...     num_labels=len(labels),
...     id2label=id2label,
...     label2id=label2id,
... )
```

この時点で、残りのステップは3つだけです:

1. [TrainingArguments](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.TrainingArguments) で学習ハイパーパラメータを定義します。未使用の列を削除しないことが重要です。そうしないと、`image` 列が削除されてしまいます。`image` 列がなければ、`pixel_values` を作成できません。この動作を防ぐために、`remove_unused_columns=False` を設定してください。もう一つの必須パラメータは、モデルの保存先を指定する `output_dir` です。`push_to_hub=True` を設定することで、このモデルを Hub にプッシュできます（モデルをアップロードするには、Hugging Face にサインインしている必要があります）。各エポックの終了時、[Trainer](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.Trainer) は精度を評価し、学習チェックポイントを保存します。
2. モデル、データセット、トークナイザー、データコラテーター、`compute_metrics` 関数とともに、学習引数を [Trainer](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.Trainer) に渡します。
3. [train()](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.Trainer.train)を呼び出して、モデルをファインチューニングします。

```py
>>> training_args = TrainingArguments(
...     output_dir="my_awesome_food_model",
...     remove_unused_columns=False,
...     eval_strategy="epoch",
...     save_strategy="epoch",
...     learning_rate=5e-5,
...     per_device_train_batch_size=16,
...     gradient_accumulation_steps=4,
...     per_device_eval_batch_size=16,
...     num_train_epochs=3,
...     warmup_steps=0.1,
...     logging_steps=10,
...     report_to="trackio",
...     run_name="food101",
...     load_best_model_at_end=True,
...     metric_for_best_model="accuracy",
...     push_to_hub=True,
... )

>>> trainer = Trainer(
...     model=model,
...     args=training_args,
...     data_collator=data_collator,
...     train_dataset=food["train"],
...     eval_dataset=food["test"],
...     processing_class=image_processor,
...     compute_metrics=compute_metrics,
... )

>>> trainer.train()
```

トレーニングが完了したら、[push_to_hub()](/docs/transformers/v5.23.0/ja/main_classes/trainer#transformers.Trainer.push_to_hub) メソッドでモデルを Hub に共有し、誰でもそのモデルを利用できるようにしてください。

```py
>>> trainer.push_to_hub()
```

画像分類用のモデルをファインチューニングする方法について、より詳細な例を確認するには、対応する[PyTorchノートブック](https://colab.research.google.com/github/huggingface/notebooks/blob/main/examples/image_classification.ipynb)をご覧ください。

## 推論

素晴らしい、モデルのファインチューニングが完了したので、推論に使用できます！

推論を実行したい画像を読み込みます:

```py
>>> ds = load_dataset("ethz/food101", split="validation[:10]")
>>> image = ds["image"][0]
```

    

推論用にファインチューニングしたモデルを試す最も簡単な方法は、[pipeline()](/docs/transformers/v5.23.0/ja/main_classes/pipelines#transformers.pipeline)でそれを使用することです。モデルで画像分類用の`pipeline`をインスタンス化し、画像を渡します:

```py
>>> from transformers import pipeline

>>> classifier = pipeline("image-classification", model="my_awesome_food_model")
>>> classifier(image)
[{'score': 0.31856709718704224, 'label': 'beignets'},
 {'score': 0.015232225880026817, 'label': 'bruschetta'},
 {'score': 0.01519392803311348, 'label': 'chicken_wings'},
 {'score': 0.013022331520915031, 'label': 'pork_chop'},
 {'score': 0.012728818692266941, 'label': 'prime_rib'}]
```

必要に応じて、`pipeline`の結果を手動で再現することもできます:

画像の前処理を行い、`input`をPyTorchテンソルとして返すために、画像プロセッサを読み込みます:

```py
>>> from transformers import AutoImageProcessor
>>> import torch

>>> image_processor = AutoImageProcessor.from_pretrained("my_awesome_food_model")
>>> inputs = image_processor(image, return_tensors="pt")
```

入力データをモデルに渡し、logitsを返します:

```py
>>> from transformers import AutoModelForImageClassification

>>> model = AutoModelForImageClassification.from_pretrained("my_awesome_food_model")
>>> with torch.no_grad():
...     logits = model(**inputs).logits
```

最も高い確率を持つ予測ラベルを取得し、モデルの`id2label`マッピングを使用してラベルに変換します:

```py
>>> predicted_label = logits.argmax(-1).item()
>>> model.config.id2label[predicted_label]
'beignets'
```