Classification d'images Tensorflow 2.0 : installation, chargement de données, création et formation du modèle

La classification des images est une catégorie de reconnaissance de formes. Il classe les images en fonction de la relation entre les pixels voisins. En d'autres termes, il utilise des informations contextuelles pour organiser les images et est très populaire parmi les différentes technologies. C'est un sujet important dans Deep Learning, et si vous l'apprenez, vous apprécierez sûrement cet article.

Ici, nous allons effectuer la classification d'images TensorFlow. Nous allons construire un modèle, le former, puis améliorer sa précision pour classer les images de cactus. TensorFlow est une plate-forme d'apprentissage automatique open source et un produit de Google.

Commençons.

Installer TensorFlow 2.0

Tout d'abord, vous devez installer TensorFlow sur Google Colab. Vous pouvez l'installer via pip :

!pip install tensorflow-gpu==2.0.0-alpha0

Ensuite, nous vérifierons l'installation :

importer tensorflow en tant que tf

impression(tf.__version)

# Sortie : 2.0.0-alpha0

La source

Apprendre : les 5 projets TensorFlow les plus populaires pour les débutants

Charger les données

Après la vérification, nous pouvons charger les données en utilisant le tf.data.dataset. Nous allons construire un classificateur qui détermine si une image contient un cactus ou non. Le cactus doit être colonnaire. Nous pouvons utiliser le jeu de données Cactus Aerial Photos à cette fin. Maintenant, nous allons charger les chemins d'accès aux fichiers avec leurs étiquettes :

train_csv = pd.read_csv('données/train.csv')

# Ajouter les noms de fichiers d'image dans train/ avec un chemin relatif

filenames = ['train/' + fname pour fname dans train_csv['id'].tolist()]

labels = train_csv['has_cactus'].tolist()

train_filenames, val_filenames, train_labels, val_labels =

train_test_split(noms de fichiers,

Étiquettes,

train_size=0.9,

état_aléatoire=42)

Une fois que nous avons les étiquettes et les noms de fichiers, nous sommes prêts à créer les objets tf.data.Dataset :

train_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(train_filenames), tf.constant(train_labels))

)

val_data = tf.data.Dataset.from_tensor_slices(

(tf.constant(val_filenames), tf.constant(val_labels))

)

La source

Pour le moment, notre ensemble de données ne contient pas les images réelles. Il n'a que leurs noms de fichiers. Nous aurons besoin d'une fonction pour charger les images nécessaires et les traiter afin de pouvoir effectuer la reconnaissance d'image TensorFlow sur celles-ci.

IMAGE_SIZE = 96 # Taille d'image minimale à utiliser avec MobileNetV2

BATCH_SIZE = 32

# Fonction pour charger et prétraiter chaque image

def _parse_fn (nom de fichier, étiquette) :

img = tf.io.read_file(img)

img = tf.image.decode_jpeg(img)

img = (tf.cast(img, tf.float32)/127.5) – 1

img = tf.image.resize(img, (IMAGE_SIZE, IMAGE_SIZE))

retour img, étiquette

# Exécutez _parse_fn sur chaque exemple dans les ensembles de données train et val

# Mélangez et créez également des lots

train_data = (train_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

val_data = (val_data.map(_parse_fn)

.shuffle(buffer_size=10000)

.batch(BATCH_SIZE)

)

La source

Construire un modèle

Dans cet exemple de classification d'images TensorFlow, nous allons créer un modèle d'apprentissage par transfert. Ces modèles sont rapides car ils peuvent utiliser des modèles de classification d'images existants qui ont déjà subi une formation. Ils n'ont qu'à recycler la couche supérieure de leur réseau car cette couche spécifie la classe de l'image requise.

Nous utiliserons l'API Keras de TensorFlow 2.0 pour créer notre modèle de classification d'images. Et à des fins d'apprentissage par transfert, nous utiliserons le MobileNetV2 comme détecteur d'attributs. C'est la deuxième version de MobileNet et c'est un produit de Google. Il est plus léger que d'autres modèles tels que Inception et ResNet et peut fonctionner sur des appareils mobiles. Nous allons charger ce modèle sur ImageNet, geler les poids, ajouter une tête de classification et l'exécuter sans sa couche supérieure.

IMG_SHAPE = (IMAGE_SIZE, IMAGE_SIZE, 3)

# Modèle pré-formé avec MobileNetV2

base_model = tf.keras.applications.MobileNetV2(

input_shape=IMG_SHAPE,

include_top=Faux,

poids='imagenet'

)

# Geler les poids du modèle pré-formés

base_model.trainable=Faux

# Responsable classification formable

maxpool_layer = tf.keras.layers.GlobalMaxPooling2D()

prédiction_layer = tf.keras.layers.Dense(1, activation='sigmoïde')

# Tête de classification de couches avec détecteur de caractéristiques

modèle = tf.keras.Sequential([

modèle_de_base,

maxpool_layer,

prédiction_layer

])

taux_d'apprentissage = 0,0001

# Compiler le modèle

model.compile(optimizer=tf.keras.optimizers.Adam(lr=learning_rate),

loss='binary_crossentropy',

metrics=['précision']

)

La source

Vous devez utiliser les optimiseurs TensorFlow si vous comptez entraîner des modèles tf.keras. Les optimiseurs des API tf.keras.optimizers et tf.train sont regroupés dans les tf.keras.optimizers de TensorFlow 2.0. Dans TensorFlow 2.0, de nombreux optimiseurs d'origine de tf.keras ont été mis à niveau et remplacés pour de meilleures performances. Ils nous permettent d'appliquer des optimiseurs sans compromettre les performances et de gagner du temps.

Lire : Tutoriel de détection d'objets TensorFlow pour les débutants

Apprenez des cours de science des données dans les meilleures universités du monde. Gagnez des programmes Executive PG, des programmes de certificat avancés ou des programmes de maîtrise pour accélérer votre carrière.

Formation du modèle

Après avoir construit le modèle, nous pouvons l'enseigner. L'API tf.keras de TensorFlow 2.0 prend en charge l'API tf.data, vous devez donc utiliser les objets tf.data.Dataset à cette fin. Il peut effectuer l'entraînement efficacement et nous n'aurions pas à faire de compromis sur les performances.

num_epochs = 30

steps_per_epoch = round(num_train)//BATCH_SIZE

val_steps = 20

model.fit(train_data.repeat(),

époques=num_époques,

étapes_per_epoch = étapes_per_epoch,

validation_data=val_data.repeat(),

validation_steps=val_steps)

La source

Après 30 époques, la précision du modèle augmente considérablement, mais nous pouvons encore l'améliorer. Rappelez-vous, nous avons mentionné le gel des poids lors de l'apprentissage par transfert ? Eh bien, maintenant que nous avons formé le responsable de la classification, nous pouvons dégeler ces couches et affiner davantage notre ensemble de données :

# Dégelez toutes les couches de MobileNetV2

base_model.trainable=Vrai

# Regeler les calques jusqu'à ce que les calques que nous voulons affiner

pour le calque dans base_model.layers[:100] :

couche.trainable=Faux

# Utilisez un taux d'apprentissage inférieur

lr_finetune = taux_d'apprentissage / 10

# Recompiler le modèle

model.compile(loss='binary_crossentropy',

optimiseur = tf.keras.optimizers.Adam(lr=lr_finetune),

metrics=['précision'])

# Augmenter les époques d'entraînement pour un réglage fin

fine_tune_epochs = 30

total_epochs = num_epochs + fine_tune_epochs

# Affiner le modèle

# Remarque : Définissez initial_epoch pour commencer l'entraînement après l'époque 30 puisque nous

# précédemment formé pendant 30 époques.

model.fit(train_data.repeat(),

étapes_per_epoch = étapes_per_epoch,

époques=total_époques,

époque_initiale = num_époques,

validation_data=val_data.repeat(),

validation_steps=val_steps)

La source

30 époques plus tard, la précision du modèle s'améliore encore. Avec plus d'époques, nous avons constaté une plus grande amélioration de la précision du modèle. Maintenant, nous avons un modèle de reconnaissance d'image TensorFlow approprié qui peut reconnaître les cactus colonnaires dans les images avec une grande précision.

Lisez aussi: Idées de projets Tensorflow pour les débutants

En savoir plus sur la classification d'images TensorFlow

Les API hautement fonctionnelles de TensorFlow et ses capacités en font une technologie puissante que tout programmeur peut utiliser. Ses API de haut niveau suppriment également sa complexité générale, ce qui facilite son utilisation.

Souhaitez-vous en savoir plus sur TensorFlow, la classification d'images et les sujets connexes ? Ensuite, nous vous recommandons de consulter le diplôme PG IIIT-B & upGrad en apprentissage automatique et IA qui est conçu pour les professionnels en activité et offre plus de 450 heures de formation rigoureuse, plus de 30 études de cas et missions, le statut d'anciens élèves IIIT-B, 5+ pratique projets de synthèse pratiques et assistance à l'emploi avec les meilleures entreprises.