Cet article a été publié dans le cadre du Blogathon sur la science des données.
Hé les gars,
J'espère que vous allez tous bien.
Dans cet article, nous apprendrons comment vous pouvez développer et déployer un classificateur d'images à l'aide de flask. Comme mes autres articles, cet article vous donnera une expérience pratique du code et à la fin de cet article, vous pourrez créer une API flask simple et efficace qui classifiera l'image. Cet article contiendra dans un premier temps la partie théorie puis la partie codage. Je donnerai un lien vers le code plus tard dans cet article, ce qui vous évitera de vous embêter. Alors concentrons-nous sur l'apprentissage. Encore une fois, cet article sera entièrement basé sur PYTHON.
Cet article est ouvert à toutes les catégories de spectateurs (Débutant, Intermédiaire, Avancé). Vous trouverez ci-dessous la table des matières de cet article, alors n'hésitez pas à ignorer les parties avec lesquelles vous êtes déjà à l'aise.
Cette partie se concentrera sur le classificateur d'images à l'aide de flask. Vous pouvez trouver la deuxième partie ici si vous êtes uniquement intéressé par la création d'une API de flacon.
Table des matières
- Qu'est-ce que la classification d'images?
1. 1. Réseau de neurones convolutionnels
1. 2. Apprentissage par transfert - Codage pour le classificateur d'images
- Conclusion
Classification d'image
La classification d'images est le processus de catégorisation et d'étiquetage de groupes de pixels ou de vecteurs dans une image en fonction de règles spécifiques. En termes simples, nous essayons de regrouper en quelque sorte des images liées ou des images similaires.
Les techniques de classification d'images sont principalement divisées en deux types : la classification d'images non supervisée et supervisée. Nous utiliserons ici les techniques de classification d'images supervisée. Je ne vais pas m'y plonger plus profondément.
L'état de l'art pour la classification d'images est basé sur le Deep Learning connu sous le nom de Convolutional Neural Networks (CNN).
Réseau neuronal convolutif
Avant de passer à CNN, jetons un coup d'œil à Neural Network.
Réseau neuronal: Il s'agit d'une série d'algorithmes qui reconnaissent les modèles/relations sous-jacents dans un ensemble de données grâce à un processus qui imite le fonctionnement du cerveau humain. Apprentissage en profondeur : un sous-ensemble d'algorithmes d'apprentissage automatique qui est très efficace pour reconnaître les modèles, mais qui nécessite généralement un grand nombre de données.
CNN également connu sous le nom de Convnet est un type spécial de réseau de neurones qui fonctionne de la même manière qu'un réseau de neurones normal, sauf qu'il a une couche de convolution au début.
Pourquoi utilisons-nous CNN ?
- Les réseaux de neurones à anticipation simples ne voient aucun ordre dans leurs entrées. Si vous mélangez toutes vos images de la même manière, le réseau de neurones aurait les mêmes performances qu'il avait lorsqu'il était entraîné sur des images non mélangées.
- profiter de la cohérence spatiale locale des images. Cela signifie qu'ils peuvent réduire considérablement le nombre d'opérations nécessaires pour traiter une image en utilisant la convolution sur des patchs de pixels adjacents, car les pixels adjacents ensemble sont significatifs.
- Ils utilisent ce qu'on appelle une couche de regroupement pour sous-échantillonner votre image.
L'image ci-dessous montre un exemple classique de CNN.
Termes VIP dans CNN
Convolution: Il contient un ensemble de filtres/noyaux (ensemble de pondérations) qui prend en entrée un sous-ensemble de l'image d'entrée. Des sous-ensembles d'images sont multipliés avec les filtres qui sont généralement de taille inférieure à l'image. L'image ci-dessous vous aidera à mieux comprendre la couche convolutive.
Mise en commun: Cette couche aide à sous-échantillonner nos images. Nous exécutons un filtre sur la matrice et lui appliquons une fonction pour générer la sortie. MAXPOOL est une fonction qui donne la sortie en tant que valeur maximale, comme indiqué ci-dessous.
L'image est tirée de https://cs231n.github.io/convolutional-networks/
RéLU
La fonction d'activation linéaire rectifiée ou ReLU en abrégé est une fonction linéaire par morceaux qui produira l'entrée directement si elle est positive, sinon, elle produira zéro. C'est devenu la fonction d'activation par défaut pour de nombreux types de réseaux de neurones, car un modèle qui l'utilise est plus facile à former et atteint souvent de meilleures performances.
marginal
Cette couche aide à éviter le surajustement de notre modèle en supprimant au hasard certains nœuds du réseau de neurones et en utilisant le repos pour la prédiction. Il s'agit d'une technique de régularisation qui oblige CNN à ne pas dépendre uniquement de certains nœuds mais à avoir une composante ou dit de tous les nœuds.
Couche entièrement connectée
Les neurones d'une couche entièrement connectée ont des connexions complètes à toutes les activations de la couche précédente. Leurs activations peuvent donc être calculées avec une multiplication matricielle suivie d'un décalage de biais.
Vous pouvez lire plus de détails ici.
Transfert d'apprentissage
L'apprentissage par transfert est la réutilisation d'un modèle précédemment appris sur un nouveau problème. Ce sont les techniques les plus utilisées en vision par ordinateur car elles permettent d'économiser beaucoup d'efforts lorsque vous utilisez ces techniques pour résoudre un nouveau problème similaire. Par exemple, nous avons créé un modèle pour classer le chat contre le singe, pouvons-nous l'utiliser pour classer le tigre contre le gorille ? Avec l'apprentissage par transfert, nous le pouvons.
Nous allons également utiliser l'apprentissage par transfert lors de la création de notre modèle. Des exemples de modèles d'apprentissage par transfert utilisés pour la classification d'images sont Resnet50, MobileNet, VGG16, VGG19, DenseNet.
En savoir plus sur l'apprentissage par transfert ici.
Assez de théorie MONTRE-MOI LE CODE !
Codage pour le classificateur d'images
Pour les classificateurs d'images, il existe de nombreux modules comme TensorFlow, PyTorch, fastai, etc. Pour ce blog, nous utiliserons TensorFlow.
Importer des bibliothèques :
# Bibliothèques d'assistance import os import numpy as np import matplotlib.pyplot as plt
# Tensorflow importe tensorflow en tant que tf
de tensorflow.keras.applications.imagenet_utils importer preprocess_input, decode_predictions
de tensorflow.keras.models importer load_model , model_from_json , Modèle
depuis tensorflow.keras.preprocessing importer l'image depuis tensorflow importer keras from keras.preprocessing.image import ImageDataGenerator
Créer votre ensemble de données
Vous devez déclarer et modifier les variables en fonction de votre utilisation.
# Déclaration de variables train_data_dir = 'v_data/train' validation_data_dir = 'v_data/test' nb_train_samples =400 nb_validation_samples = 100 epochs = 10 batch_size = 16img_width, img_height=224,224input_shape=(img_width, img_height,3)
époques : 1 L'époque correspond au moment où l'ensemble de données complet est transmis en avant et en arrière à travers le réseau de neurones une seule fois.
taille du lot: Étant donné que le passage de l'ensemble de données complet vers l'avant et vers l'arrière entraînera une augmentation des coûts de calcul, nous utilisons une taille de lot qui est définie comme le nombre d'échantillons qui seront propagés à travers le réseau.
train_datagen = ImageDataGenerator( rescale=1. / 255, shear_range=0.2, zoom_range=0.2, horizontal_flip=True) test_datagen = ImageDataGenerator(rescale=1. / 255) train_generator = train_datagen.flow_from_directory( train_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary') validation_generator = test_datagen.flow_from_directory( validation_data_dir, target_size=(img_width, img_height), batch_size=batch_size, class_mode='binary')
Création de modèle
model=Sequential()model.add(Conv2D(32, (2,2), input_shape=input_shape))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Conv2D(32, (2,2)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Conv2D(64, (2,2)))model.add(Activation('relu'))model.add(MaxPooling2D(pool_size=(2,2)))model.add(Flatten())model.add(Dense(64))model.add(Activation('relu'))model.add(Dropout(0.5))model.add(Dense(1))model.add(Activation('sigmoid'))
Nous avons créé la structure de notre modèle ici.
|
Le code ci-dessus créera une fonction de compilation qui contiendra la fonction de perte, l'optimiseur en tant qu'adam et l'évaluation du modèle.
Modèle d'apprentissage par transfert
de tensorflow.keras.applications.mobilenet_v2 importer le modèle MobileNetV2 = MobileNetV2(weights='imagenet')
Ce code créera un modèle avec la structure de MobileNetV2 chargé avec des poids imagenet.
Ajustement fin du modèle d'apprentissage par transfert
Pour ajuster les réseaux de neurones pré-formés à notre problème, nous devons les former sur notre ensemble de données. Nous pouvons également ajouter des couches supplémentaires à la fin du modèle de classification d'image.
de keras.applications importer Resnet50 base_model = ResNet50(weights='imagenet', include_top=False, input_shape=(IMG_SIZE, IMG_SIZE, 3))
output_categories = 2 # nombre de catégories dans la couche finale. add_model = Sequential() add_model.add(Flatten(input_shape=base_model.output_shape[1:])) add_model.add(Dropout(0.3)) add_model.add(Dense(128, activation='relu')) add_model.add( Dropout(0.3)) add_model.add(Dense(output_categories, activation='softmax')) model = Model(inputs=base_model.input, outputs=add_model(base_model.output))
Ici, nous avons utilisé Resnet50 comme modèle pré-formé, puis nous avons ajouté quelques couches à la fin de notre modèle afin de pouvoir l'affiner pour notre cas.
Modèle de formation
model.fit_generator( train_generator, steps_per_epoch=nb_train_samples // batch_size, epochs=epochs, validation_data=validation_generator, validation_steps=nb_validation_samples // batch_size)
Prédire à l'aide du modèle
def model_predict(img, modèle): img = img.resize((224, 224))
# Prétraitement de l'image x = image.img_to_array(img) # x = np.true_divide(x, 255) x = np.expand_dims(x, axis=0)
# Faites attention à la façon dont votre modèle formé traite l'entrée # sinon, il ne fera pas de prédiction correcte ! x = preprocess_input(x, mode='tf')
preds = model.predict(x) renvoie les preds
Enregistrement du modèle
model_json = model.to_json() avec open("ImageClassifier.json", "w") as json_file : json_file.write(model_json) # sérialise les poids en HDF5 model.save_weights("ImageClassifier.h5")
Les emplacements changeront en fonction de votre système.
Modèle de chargement
model_json = open(path_to_model_json, 'r') load_model_json = model_json.read() model_json.close() model = model_from_json(loaded_model_json) model.load_weights(path_to_model_wieght)
Au cas où vous seriez confus et voudriez voir ou copier le code. Référence pour le classificateur d'images ici.
Conclusion
C'est la fin du classificateur d'image utilisant flask. J'espère que vous avez une idée de la façon dont vous pouvez créer un classificateur d'images et comment pouvez-vous appliquer l'apprentissage par transfert et l'utiliser pour obtenir de meilleurs résultats pour vos problèmes de vision par ordinateur. Dans l'article de suivi, nous allons créer une API pour contenir notre classificateur d'images et le déployer. J'ai déjà mis le code complet de ce tutoriel dans le référentiel GitHub ci-dessous.
TROUVER LE CODE ici.
À PROPOS DE MOI
Je suis un étudiant de dernière année de l'IIIT poursuivant mon baccalauréat en informatique et ingénierie. J'aime explorer et essayer de plus en plus l'apprentissage profond et automatique. Si vous souhaitez collaborer, vous pouvez utiliser les liens ci-dessous :
Linkedin: Clique-moi
Github: Clique-moi
Kagglé : Clique-moi
Mail moi: [email protected]
J'espère que vous avez aimé mon article sur le classificateur d'images utilisant Flask. Merci pour la lecture!
Les médias présentés dans cet article n'appartiennent pas à Analytics Vidhya et sont utilisés à la discrétion de l'auteur.
