Classification d'image de visage étreint: un guide complet avec des exemples

Adapter le visage étreint pour la classification des images: un guide complet

Classification d'image, une pierre angulaire de l'IA et de l'apprentissage automatique, trouve des applications dans divers domaines, de la reconnaissance faciale à l'imagerie médicale. Le visage étreint apparaît comme une plate-forme puissante pour cette tâche, en particulier pour ceux qui connaissent le traitement du langage naturel (NLP) et de plus en plus, la vision par ordinateur. Ce guide détaille en utilisant le visage étreint pour la classification d'images, en s'adressant à la fois aux débutants et aux praticiens expérimentés.

Comprendre la classification des images et les avantages du visage étreint

La classification d'images implique la catégorisation d'images en classes prédéfinies à l'aide d'algorithmes qui analysent le contenu visuel et prédisent les catégories basées sur des modèles apprises. Les réseaux de neurones convolutionnels (CNN) sont l'approche standard en raison de leurs capacités de reconnaissance des modèles. Pour une plongée plus profonde dans CNNS, reportez-vous à notre article «Une introduction aux réseaux de neurones convolutionnels (CNNS)». Notre article "Classification in Machine Learning: An Introduction" fournit une compréhension plus large des algorithmes de classification.

Le visage étreint offre plusieurs avantages:

Avantages clés de l'utilisation du visage étreint pour la classification d'image

• Accessibilité: Les API intuitives et la documentation complète s'adressent à tous les niveaux de compétence.
• Modèles pré-formés: Un vaste référentiel de modèles pré-formés permet un réglage fin efficace sur les ensembles de données personnalisés, la minimisation du temps de formation et des ressources de calcul. Les utilisateurs peuvent former et déployer leurs propres modèles.
• Communauté et soutien: Une communauté dynamique fournit un soutien inestimable et une assistance de dépannage.

Le visage étreint simplifie également le déploiement du modèle sur les principales plates-formes cloud (AWS, Azure, Google Cloud Platform) avec diverses options d'inférence.

Options de déploiement du modèle sur les plates-formes cloud

Préparation des données et prétraitement

Ce guide utilise l'ensemble de données «Beans» pour la démonstration. Après le chargement, nous visualiserons les données avant le prétraitement. Le cahier Google Colab qui l'accompagne fournit le code. Le code est inspiré par la documentation officielle de l'étreinte.

Exigences de la bibliothèque:

Installez les bibliothèques nécessaires à l'aide de pip:

pip -q install datasets
pip -q install transformers=='4.29.0'
pip -q install tensorflow=='2.15' 
pip -q install evaluate
pip -q install --upgrade accelerate

redémarrer le noyau après l'installation. Importer des bibliothèques requises:

import torch
import torchvision
import numpy as np
import evaluate
from datasets import load_dataset
from huggingface_hub import notebook_login
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from transformers import DefaultDataCollator
from transformers import AutoImageProcessor
from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
from transformers import AutoModelForImageClassification, TrainingArguments, Trainer
import matplotlib.pyplot as plt

Chargement des données et organisation:

Chargez l'ensemble de données:

pip -q install datasets
pip -q install transformers=='4.29.0'
pip -q install tensorflow=='2.15' 
pip -q install evaluate
pip -q install --upgrade accelerate

L'ensemble de données contient 1034 images, chacune avec 'Image_File_Path', 'Image' (objet PIL) et 'Labels' (0: Angular_leaf_Spot, 1: Bean_rust, 2: Sain

Une fonction d'assistance visualise les images aléatoires:

import torch
import torchvision
import numpy as np
import evaluate
from datasets import load_dataset
from huggingface_hub import notebook_login
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
from transformers import DefaultDataCollator
from transformers import AutoImageProcessor
from torchvision.transforms import RandomResizedCrop, Compose, Normalize, ToTensor
from transformers import AutoModelForImageClassification, TrainingArguments, Trainer
import matplotlib.pyplot as plt

Visualisez six images aléatoires:

beans_train = load_dataset("beans", split="train")

Exemples d'images de l'ensemble de données Beans

Prétraitement des données:

diviser l'ensemble de données (Train à 80%, validation de 20%):

labels_names = {0: "angular_leaf_spot", 1: "bean_rust", 2: "healthy"}

def display_random_images(dataset, num_images=4):
   # ... (function code as in original input) ...

Créer des mappages d'étiquettes:

display_random_images(beans_train, num_images=6)

Modèle de chargement et de réglage fin

Chargez le modèle VIT pré-formé:

beans_train = beans_train.train_test_split(test_size=0.2)

Le code charge le modèle pré-formé, définit les transformations (redimensionnement, normalisation) et prépare l'ensemble de données pour la formation. La métrique de précision est définie pour l'évaluation.

Connectez-vous au visage étreint:

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

(Suivez les instructions à l'écran)

Configurer et lancer la formation:

checkpoint = "google/vit-base-patch16-224-in21k"
image_processor = AutoImageProcessor.from_pretrained(checkpoint)
# ... (rest of the preprocessing code as in original input) ...

(résultats de formation comme indiqué dans l'entrée d'origine)

Déploiement et intégration du modèle

Poussez le modèle formé au centre de visage étreint:

notebook_login()

Le modèle est alors accessible et utilisé via:

1. Portail de visage étreint: Téléchargez directement des images pour la prédiction.
2. Bibliothèque Transformers: Utilisez le modèle dans votre code Python.
3. API REST: Utilisez le point de terminaison de l'API fourni pour les prédictions. Exemple utilisant l'API:

training_args = TrainingArguments(
    # ... (training arguments as in original input) ...
)

trainer = Trainer(
    # ... (trainer configuration as in original input) ...
)

trainer.train()

Conclusion et ressources supplémentaires

Ce guide fournit une procédure pas à pas complète de la classification des images en utilisant le visage de câlin. D'autres ressources d'apprentissage incluent:

"Une introduction à l'utilisation des transformateurs et des étreintes de visage"
"Traitement d'image avec Python" Skill Track
"Qu'est-ce que la reconnaissance d'image?" Article

Ce guide permet aux utilisateurs de tous les niveaux de tirer parti des étreintes pour leurs projets de classification d'image.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!