影像分類

影像分類為影像分配標籤或類別。與文字或音訊分類不同，輸入是構成影像的畫素值。影像分類有許多應用，例如在自然災害後檢測損壞、監測作物健康或幫助篩選醫學影像以尋找疾病跡象。

本指南將演示如何

在 Food-101 資料集上微調 ViT 以對影像中的食物項進行分類。
使用您的微調模型進行推理。

要檢視與此任務相容的所有架構和檢查點，我們建議檢視任務頁面

在開始之前，請確保您已安裝所有必要的庫

pip install transformers datasets evaluate accelerate pillow torchvision scikit-learn

我們鼓勵您登入到您的 Hugging Face 帳戶，以便與社群上傳和共享您的模型。當出現提示時，輸入您的令牌以登入

>>> from huggingface_hub import notebook_login

>>> notebook_login()

載入 Food-101 資料集

首先從 🤗 Datasets 庫載入 Food-101 資料集的一個較小子集。這將使您有機會進行實驗並確保一切正常，然後再花費更多時間在完整資料集上進行訓練。

>>> from datasets import load_dataset

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

使用 train_test_split 方法將資料集的 `train` 拆分為訓練集和測試集

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

然後檢視一個示例

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

資料集中的每個示例都有兩個欄位

image：食物項的 PIL 影像
label：食物項的標籤類別

為了讓模型更容易從標籤 ID 獲取標籤名稱，建立一個將標籤名稱對映到整數的字典，反之亦然

>>> 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 轉換為標籤名稱

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

預處理

下一步是載入 ViT 影像處理器以將影像處理為張量

>>> from transformers import AutoImageProcessor

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

Pytorch

隱藏 Pytorch 內容

對影像應用一些影像轉換，以使模型更穩健地抵抗過擬合。這裡您將使用 torchvision 的 transforms 模組，但您也可以使用任何您喜歡的影像庫。

裁剪影像的隨機部分，調整其大小，並使用影像均值和標準差對其進行標準化

>>> 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 - 模型的輸入

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

要將預處理函式應用於整個資料集，請使用 🤗 Datasets 的 with_transform 方法。當您載入資料集的元素時，轉換會即時應用

>>> food = food.with_transform(transforms)

現在使用 DefaultDataCollator 建立一批示例。與 🤗 Transformers 中的其他資料整理器不同，DefaultDataCollator 不會應用額外的預處理，例如填充。

>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator()

TensorFlow

隱藏 TensorFlow 內容

為了避免過擬合併使模型更穩健，向資料集的訓練部分新增一些資料增強。這裡我們使用 Keras 預處理層來定義訓練資料（包括資料增強）的轉換，以及驗證資料（僅中心裁剪、調整大小和歸一化）的轉換。您可以使用 tf.image 或任何其他您喜歡的庫。

>>> from tensorflow import keras
>>> from tensorflow.keras import layers

>>> size = (image_processor.size["height"], image_processor.size["width"])

>>> train_data_augmentation = keras.Sequential(
...     [
...         layers.RandomCrop(size[0], size[1]),
...         layers.Rescaling(scale=1.0 / 127.5, offset=-1),
...         layers.RandomFlip("horizontal"),
...         layers.RandomRotation(factor=0.02),
...         layers.RandomZoom(height_factor=0.2, width_factor=0.2),
...     ],
...     name="train_data_augmentation",
... )

>>> val_data_augmentation = keras.Sequential(
...     [
...         layers.CenterCrop(size[0], size[1]),
...         layers.Rescaling(scale=1.0 / 127.5, offset=-1),
...     ],
...     name="val_data_augmentation",
... )

接下來，建立函式以將適當的轉換應用於一批影像，而不是一次一張影像。

>>> import numpy as np
>>> import tensorflow as tf
>>> from PIL import Image


>>> def convert_to_tf_tensor(image: Image):
...     np_image = np.array(image)
...     tf_image = tf.convert_to_tensor(np_image)
...     # `expand_dims()` is used to add a batch dimension since
...     # the TF augmentation layers operates on batched inputs.
...     return tf.expand_dims(tf_image, 0)


>>> def preprocess_train(example_batch):
...     """Apply train_transforms across a batch."""
...     images = [
...         train_data_augmentation(convert_to_tf_tensor(image.convert("RGB"))) for image in example_batch["image"]
...     ]
...     example_batch["pixel_values"] = [tf.transpose(tf.squeeze(image)) for image in images]
...     return example_batch


... def preprocess_val(example_batch):
...     """Apply val_transforms across a batch."""
...     images = [
...         val_data_augmentation(convert_to_tf_tensor(image.convert("RGB"))) for image in example_batch["image"]
...     ]
...     example_batch["pixel_values"] = [tf.transpose(tf.squeeze(image)) for image in images]
...     return example_batch

使用 🤗 Datasets set_transform 即時應用轉換

food["train"].set_transform(preprocess_train)
food["test"].set_transform(preprocess_val)

作為最後的預處理步驟，使用 DefaultDataCollator 建立一批示例。與 🤗 Transformers 中的其他資料整理器不同，DefaultDataCollator 不會應用額外的預處理，例如填充。

>>> from transformers import DefaultDataCollator

>>> data_collator = DefaultDataCollator(return_tensors="tf")

評估

在訓練期間包含一個指標通常有助於評估模型的效能。您可以使用 🤗 Evaluate 庫快速載入評估方法。對於此任務，載入準確度指標（請參閱 🤗 Evaluate 快速入門以瞭解有關如何載入和計算指標的更多資訊）

>>> import evaluate

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

然後建立一個函式，將您的預測和標籤傳遞給 compute 以計算準確度。

>>> 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 函式現在已準備就緒，您將在設定訓練時再次使用它。

訓練

Pytorch

隱藏 Pytorch 內容

如果您不熟悉如何使用 Trainer 對模型進行微調，請參閱此處的基本教程！

您現在可以開始訓練您的模型了！使用 AutoModelForImageClassification 載入 ViT。指定標籤數量以及預期標籤數量和標籤對映

>>> from transformers import AutoModelForImageClassification, TrainingArguments, Trainer

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

此時，只剩下三個步驟

在 TrainingArguments 中定義您的訓練超引數。重要的是不要刪除未使用的列，因為這會丟棄 image 列。沒有 image 列，您無法建立 pixel_values。設定 remove_unused_columns=False 以防止此行為！唯一其他必需的引數是 output_dir，它指定儲存模型的位置。您將透過設定 push_to_hub=True 將此模型推送到 Hub（您需要登入 Hugging Face 才能上傳您的模型）。在每個 epoch 結束時，Trainer 將評估準確性並儲存訓練檢查點。
將訓練引數與模型、資料集、分詞器、資料整理器和 compute_metrics 函式一起傳遞給 Trainer。
呼叫 train() 來微調您的模型。

>>> 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_ratio=0.1,
...     logging_steps=10,
...     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() 方法將您的模型分享到 Hub，以便所有人都可以使用您的模型。

>>> trainer.push_to_hub()

TensorFlow

隱藏 TensorFlow 內容

如果您不熟悉使用 Keras 微調模型，請先檢視基本教程！

要在 TensorFlow 中微調模型，請遵循以下步驟

定義訓練超引數，並設定最佳化器和學習率排程器。
例項化預訓練模型。
將 🤗 Dataset 轉換為 tf.data.Dataset。
編譯您的模型。
添加回調並使用 fit() 方法執行訓練。
將您的模型上傳到 🤗 Hub 以與社群共享。

首先定義超引數、最佳化器和學習率排程器

>>> from transformers import create_optimizer

>>> batch_size = 16
>>> num_epochs = 5
>>> num_train_steps = len(food["train"]) * num_epochs
>>> learning_rate = 3e-5
>>> weight_decay_rate = 0.01

>>> optimizer, lr_schedule = create_optimizer(
...     init_lr=learning_rate,
...     num_train_steps=num_train_steps,
...     weight_decay_rate=weight_decay_rate,
...     num_warmup_steps=0,
... )

然後，使用 TFAutoModelForImageClassification 以及標籤對映載入 ViT

>>> from transformers import TFAutoModelForImageClassification

>>> model = TFAutoModelForImageClassification.from_pretrained(
...     checkpoint,
...     id2label=id2label,
...     label2id=label2id,
... )

使用 to_tf_dataset 和您的 data_collator 將您的資料集轉換為 tf.data.Dataset 格式

>>> # converting our train dataset to tf.data.Dataset
>>> tf_train_dataset = food["train"].to_tf_dataset(
...     columns="pixel_values", label_cols="label", shuffle=True, batch_size=batch_size, collate_fn=data_collator
... )

>>> # converting our test dataset to tf.data.Dataset
>>> tf_eval_dataset = food["test"].to_tf_dataset(
...     columns="pixel_values", label_cols="label", shuffle=True, batch_size=batch_size, collate_fn=data_collator
... )

使用 compile() 配置模型進行訓練

>>> from tensorflow.keras.losses import SparseCategoricalCrossentropy

>>> loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
>>> model.compile(optimizer=optimizer, loss=loss)

要從預測中計算準確性並將模型推送到 🤗 Hub，請使用 Keras 回撥。將您的 compute_metrics 函式傳遞給 KerasMetricCallback，並使用 PushToHubCallback 上傳模型

>>> from transformers.keras_callbacks import KerasMetricCallback, PushToHubCallback

>>> metric_callback = KerasMetricCallback(metric_fn=compute_metrics, eval_dataset=tf_eval_dataset)
>>> push_to_hub_callback = PushToHubCallback(
...     output_dir="food_classifier",
...     tokenizer=image_processor,
...     save_strategy="no",
... )
>>> callbacks = [metric_callback, push_to_hub_callback]

最後，您已準備好訓練您的模型！呼叫 fit()，傳入您的訓練和驗證資料集、epoch 數量和您的回撥，以微調模型

>>> model.fit(tf_train_dataset, validation_data=tf_eval_dataset, epochs=num_epochs, callbacks=callbacks)
Epoch 1/5
250/250 [==============================] - 313s 1s/step - loss: 2.5623 - val_loss: 1.4161 - accuracy: 0.9290
Epoch 2/5
250/250 [==============================] - 265s 1s/step - loss: 0.9181 - val_loss: 0.6808 - accuracy: 0.9690
Epoch 3/5
250/250 [==============================] - 252s 1s/step - loss: 0.3910 - val_loss: 0.4303 - accuracy: 0.9820
Epoch 4/5
250/250 [==============================] - 251s 1s/step - loss: 0.2028 - val_loss: 0.3191 - accuracy: 0.9900
Epoch 5/5
250/250 [==============================] - 238s 949ms/step - loss: 0.1232 - val_loss: 0.3259 - accuracy: 0.9890

恭喜！您已經微調了您的模型並將其分享到 🤗 Hub。您現在可以將其用於推理！

有關如何微調影像分類模型的更深入示例，請參閱相應的 PyTorch 筆記本。

推理

太棒了，現在您已經微調了一個模型，您可以將其用於推理了！

載入您想要執行推理的影像

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

嘗試對您的微調模型進行推理的最簡單方法是將其用於 pipeline()。例項化一個用於影像分類的 pipeline，並將您的模型和影像傳遞給它

>>> 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 的結果

Pytorch

隱藏 Pytorch 內容

載入一個影像處理器來預處理影像並以 PyTorch 張量返回 input

>>> from transformers import AutoImageProcessor
>>> import torch

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

將您的輸入傳遞給模型並返回 logits

>>> from transformers import AutoModelForImageClassification

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

獲取機率最高的預測標籤，並使用模型的 id2label 對映將其轉換為標籤

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

TensorFlow

隱藏 TensorFlow 內容

載入一個影像處理器來預處理影像並以 TensorFlow 張量返回 input

>>> from transformers import AutoImageProcessor

>>> image_processor = AutoImageProcessor.from_pretrained("MariaK/food_classifier")
>>> inputs = image_processor(image, return_tensors="tf")

將您的輸入傳遞給模型並返回 logits

>>> from transformers import TFAutoModelForImageClassification

>>> model = TFAutoModelForImageClassification.from_pretrained("MariaK/food_classifier")
>>> logits = model(**inputs).logits

獲取機率最高的預測標籤，並使用模型的 id2label 對映將其轉換為標籤

>>> predicted_class_id = int(tf.math.argmax(logits, axis=-1)[0])
>>> model.config.id2label[predicted_class_id]
'beignets'

< > 在 GitHub 上更新