Construire un réseau de neurones convolutifs

Contenu

Cet article a été publié dans le cadre du Blogathon sur la science des données

Cet article a pour but d’expliquer le convolucional neuronal rouge et comment compiler CNN avec la bibliothèque TensorFlow Keras. Cet article traitera des sujets suivants.

Analysons d’abord le neuronal rouge convolutif.

Convolucional neuronal rouge (CNN)

Le l'apprentissage en profondeur Il s’agit d’un sous-ensemble très important de l’apprentissage automatique en raison de ses hautes performances dans plusieurs domaines. La convolucional neuronal rouge (CNN) est un type puissant d'apprentissage en profondeur de traitement d'images qui est souvent utilisé dans la vision par ordinateur et comprend la reconnaissance d'images et de vidéos ainsi qu'un système de recommandation et un traitement du langage naturel (PNL).

CNN utilise un système multicouche composé de la couche d'entrée, la Couche de sortie et une couche cachée comprenant plusieurs couches convolutives, calques groupés, couches entièrement connectées. Nous discuterons de toutes les couches dans la section suivante de l'article pendant que nous expliquons la construction de CNN..

Discutons de la construction de CNN à l'aide de la bibliothèque Keras avec une explication du fonctionnement de CNN.

Immeuble CNN

Nous utiliserons le Ensemble de données d'imagerie cellulaire du paludisme. Cet ensemble de données se compose de 27,558 images d'échantillons de sang microscopiques. L'ensemble de données se compose de 2 Dossiers: Dossiers: parasité et non infecté. Exemples d'images

une) échantillon de sang parasité

b) Échantillon de sang non infecté

Nous discuterons de la construction de CNN avec CNN en travaillant sur les points suivants 6 Pas:

Paso 1: importer les bibliothèques requises

Paso 2: initialiser CNN et ajouter un couverture convolutive

Paso 3: opération de regroupement

Paso 4: ajouter deux couches convolutives

Paso 5 – Opération d'aplatissement

Paso 6: couche et couche de sortie entièrement connectées

Ces 6 étapes expliqueront comment CNN fonctionne, montré dans l'image suivante:

55796cnn-9342100

À présent, analysons chaque étape:

1. Importer les bibliothèques requises

S'il vous plait, voir le lien ci-dessous pour des explications détaillées sur les modules Keras.

https://keras.io/getting_started/

Code Python:

From tensorflow.keras.layers import Entrée, Lambda, Dense, Aplatir,Conv2D
depuis tensorflow.keras.models importer le modèle
de tensorflow.keras.applications.vgg19 importer VGG19
depuis tensorflow.keras.applications.resnet50 importer preprocess_input
à partir de l'image d'importation tensorflow.keras.preprocessing
de tensorflow.keras.preprocessing.image importer ImageDataGenerator,load_img
de tensorflow.keras.models import séquentiel
importer numpy en tant que np
de glob importer glob
importer matplotlib.pyplot en tant que plt
de tensorflow.keras.layers importer MaxPooling2D

2. Initialiser CNN et ajouter une couche convolutive

Code Python:

modèle=Séquentiel()

model.ajouter(Conv2D(filtres=16,kernel_size=2,padding="même",activation="reprendre",input_shape=(224,224,3)))

Nous devons d'abord démarrer la classe séquentielle car il y a plusieurs couches pour construire CNN et toutes doivent être en séquence. Ensuite, nous ajoutons la première couche convolutive où nous devons spécifier 5 arguments. Ensuite, Analysons chaque argument et son objectif.

· Filtres

Le but principal de la convolution est de trouver des caractéristiques dans l'image à l'aide d'un détecteur de caractéristiques. Alors, placez-les sur une carte des caractéristiques, qui préserve les caractéristiques distinctives des images.

Le détecteur de caractéristiques, qui est connu comme un filtre, également initialisé de manière aléatoire, puis, après plusieurs itérations, le paramètre de matrice de filtre qui sera le mieux pour séparer les images est sélectionné. Par exemple, l'oeil, le nez, etc. des animaux sera considérée comme une caractéristique utilisée pour classer les images à l'aide de filtres ou de détecteurs de caractéristiques. Ici, nous utilisons 16 les fonctions.

· Kernel_size

Kernel_size fait référence à la taille du tableau de filtres. Ici, nous utilisons une taille de filtre de 2 * 2.

· Remplissage

67425tampon-3670102

Discutons du problème avec CNN et de la façon dont l'opération de remplissage résoudra le problème.

ongle. Pour une image en niveaux de gris (nxn) et un filtre / coeur (fxf), les dimensions de l'image résultant d'une opération de convolution sont (m – F + 1) X (m – F + 1).

Ensuite, par exemple, une photo de 5 * 7 et une taille de noyau de filtre de 3 * 3, le résultat de sortie après l'opération de convolution serait une taille de 3 * 5. Donc, l'image rétrécit à chaque fois que l'opération convolutive est effectuée.

B. Pixels, situé dans les coins, ont une très faible contribution par rapport aux pixels du milieu.

Ensuite, pour atténuer ces problèmes, l'opération de remplissage est effectuée. Le remplissage est un processus simple d'ajout de couches avec 0 O -1 aux images d'entrée pour éviter les problèmes mentionnés ci-dessus.

Ici, nous utilisons Padding = Mêmes arguments, qui décrit que les images de sortie ont les mêmes dimensions que les images d'entrée.

· Fonction de déclenchementreprendre

94297reluuu-8785187

Puisque les images ne sont pas linéaires, fournir la non-linéarité, la Fonction d’activation Relu appliqué après un fonctionnement convolutif.

Relu signifie fonction d'activation linéaire rectifiée. La fonction Relu va générer l'entrée directement si elle est positive; au contraire, générera zéro.

· Formulaire de saisie

Cet argument montre la taille de l'image: 224 * 224 * 3. Puisque les images au format RVB sont comme ceci, le troisième dimension de l’image est 3.

3. Fonctionnement de la piscine

Code Python:

model.ajouter(MaxPooling2D(pool_size=2))

Nous devons appliquer l'opération de regroupement après avoir initialisé CNN. Le clustering est une opération de sous-échantillonnage de l'image. La couche de regroupement est utilisée pour réduire les dimensions des cartes de caractéristiques. Donc, la couche Pooling réduit la quantité de paramètres pour apprendre et réduire le calcul dans le réseau de neurones.

68836ppppppppppp-9351255

Les opérations futures sont effectuées sur les entités récapitulatives créées par la couche de regroupement. au lieu d'entités localisées avec précision générées par la couche de convolution. Cela conduit au modèle plus robuste aux variations de l'orientation de la caractéristique dans l'image..

Il y a principalement 3 types de regroupement: –

1. Regroupement maximal

2. Regroupement moyen

3. Regroupement global

4. Ajouter deux couches convolutives

Pour ajouter deux autres couches convolutives, nous devons répéter les étapes 2 Oui 3 avec une légère modification du nombre de filtres.

Code Python:

model.ajouter(Conv2D(filtres=32,kernel_size=2,padding="même",activation ="reprendre"))
model.ajouter(MaxPooling2D(pool_size=2))
model.ajouter(Conv2D(filtres=64,kernel_size=2,padding="même",activation="reprendre"))
model.ajouter(MaxPooling2D(pool_size=2))

Nous modifions le 2Dakota du nord Oui 3rd couches convolutives avec numéro de filtre 32 Oui 64 respectivement.

5. Opération d'aplatissement

Code Python:

model.ajouter(Aplatir())

L'opération d'aplatissement consiste à convertir l'ensemble de données en une matrice 1D pour entrer dans la couche suivante, qui est la couche entièrement connectée.

36841tttttt-6506254

Après avoir terminé le 3 Pas, maintenant nous avons regroupé la carte des caractéristiques. Maintenant, nous aplatissons notre sortie après deux pas dans une colonne. Parce que nous devons insérer ces données 1D dans une couche de réseau de neurones artificiels.

6. Couche et couche de sortie entièrement connectées

La sortie de l'opération d'aplatissement fonctionne comme entrée du réseau neuronal. L'objectif du réseau de neurones artificiels rend le réseau de neurones convolutif plus avancé et suffisamment capable pour classer les images.

45580ssssss-7571933

Ici, nous utilisons une classe dense de la bibliothèque Keras pour créer une couche entièrement connectée et une couche de sortie.

Code Python:

model.ajouter(Dense(500,activation="reprendre"))

model.ajouter(Dense(2,activation="softmax"))

La fonction softMax enable est utilisée pour construire la couche de sortie. Analysons la fonction d'activation de softmax.

Fonction d'activation Softmax

59812sssssssssss-1488041

Il est utilisé comme dernière fonction d'activation d'un réseau de neurones pour amener la sortie du réseau de neurones à une distribution de probabilité sur les classes de prédiction. La sortie de Softmax est en probabilités de chaque résultat possible pour prédire la classe. La somme des probabilités doit être une pour toutes les classes de prédiction possibles.

À présent, Analysons le entraînement et l’évaluation du réseau de neurones convolutif. Nous discuterons de cette section dans 3 Pas; –

Paso 1: compiler le modèle CNN

Paso 2: adapter le modèle à l'ensemble d'entraînement

Paso 3: évaluer le résultat

Paso 1: compiler le modèle CNN

Ligne de code

modèle.compile (loss = ‘catégorique_crossentropie’, optimizer = ‘Adam’, métriques =['précision'])

Ici, nous utilisons 3 arguments: –

· Fonction de perte

Nous utilisons le catégorique_crossentropie fonction de perte utilisée dans la tâche de classification. Cette perte est une très bonne mesure de la distinction entre deux distributions de probabilité discrètes..

S'il vous plait, Veuillez vous référer au lien ci-dessous pour une description détaillée des différents types de fonction de perte:

https://machinelearningmastery.com/how-to-choose-loss-functions-when-training-deep-learning-neural-networks/

· Optimiseur

Nous utilisons Adam Optimiserr utilisé pour mettre à jour les poids du réseau de neurones et le taux d'apprentissage. Les optimiseurs sont utilisés pour résoudre les problèmes d'optimisation en minimisant la fonction.

S'il vous plait, voir le lien ci-dessous pour une explication détaillée des différents types d'optimiseur:

https://medium.datadriveninvestor.com/overview-of-different-optimizers-for-neural-networks-e0ed119440c3

· Arguments de métrique

Ici, nous utilisons la précision comme métrique pour évaluer les performances de l'algorithme de réseau neuronal convolutif.

Paso 2: adapter le modèle à l'ensemble d'entraînement

Ligne de code:

model.fit_generator(ensemble d'entraînement,validation_data=test_set,époques=50, step_per_epoch = seulement(ensemble d'entraînement), validation_steps=len(ensemble d'essai) )

Nous ajustons le modèle CNN sur l'ensemble de données d'entraînement avec 50 itérations et chaque itération a différentes étapes pour entraîner et évaluer les étapes en fonction de la durée du test et de l'ensemble d'entraînement.

Paso 3: – Évaluer le résultat

Nous comparons la fonction de précision et de perte pour l'ensemble de données d'entraînement et de test.

Code: Graphique des pertes

plt.plot(r.histoire['perte'], étiquette="perte de train")
plt.plot(r.histoire['val_loss'], étiquette="perte de valeur")
plt.légende()
plt.show()
plt.savefig('LossVal_loss')

Production

84637llllllll-3357681

La perte est la punition pour une mauvaise prédiction. L'objectif est de réduire au maximum la perte de validation. Un peu de surapprentissage est presque toujours une bonne chose. Tout ce qui compte, à la fin, il est: est la perte de validation la plus faible possible.

Code: Tracer un graphique de précision

plt.plot(r.histoire['précision'], étiquette="train acc")
plt.plot(r.histoire['val_accuracy'], étiquette="val acc")
plt.légende()
plt.show()
plt.savefig('AccVal_acc')

Production

28356aaaaaaa-7616326

La précision est une métrique pour évaluer les modèles de classification. Informellement, la précision est la fraction des prédictions que notre modèle a obtenues. Ici, on voit que la précision est proche de 90% dans le test de validation montrant qu'un modèle CNN fonctionne bien sur les métriques de précision.

Merci pour la lecture! Bon apprentissage en profondeur!

Les références:

1. https://www.superdatascience.com/

2. https://www.youtube.com/watch?v=H-bcnHE6Mes

Sur moi :

Soja Jitendra Sharma, Stagiaire data science chez Nabler, y me dedico a PGDM-Big Data Analytics del Goa Institute of Management. Vous pouvez me contacter via LinkedIn Oui Github.

Les médias présentés dans cet article ne sont pas la propriété de DataPeaker et sont utilisés à la discrétion de l'auteur.

Abonnez-vous à notre newsletter

Nous ne vous enverrons pas de courrier SPAM. Nous le détestons autant que vous.

Haut-parleur de données