[PYTHON] Implémentation du modèle de reconnaissance d'images d'apprentissage en profondeur 2

Aidemy　2020/11/10

introduction

Bonjour, c'est Yope! Je suis une école littéraire croustillante, mais j'étais intéressé par les possibilités de l'IA, alors je suis allé à l'école spécialisée en IA "Aidemy" pour étudier. Je voudrais partager les connaissances acquises ici avec vous, et je les ai résumées dans Qiita. Je suis très heureux que de nombreuses personnes aient lu l'article de synthèse précédent. Merci! Ceci est le deuxième article sur l'apprentissage en profondeur et la reconnaissance d'image. Ravi de vous rencontrer.

• Cet article est un résumé de ce que vous avez appris dans "Aidemy" "dans vos propres mots". Il peut contenir des erreurs et des malentendus. Notez s'il vous plaît.

Quoi apprendre cette fois ・ À propos du réseau neuronal convolutif ・ À propos de la mise en œuvre du modèle

(Review) Réseau de neurones convolutifs

Aperçu

-__ Convolutional Neural Network (CNN) __ est une méthode d'apprentissage en profondeur principalement utilisée dans le __ traitement d'images__. -Le Perceptron multicouche (MLP) utilisé dans le chapitre 1 en a reçu d'autres par une entrée unidimensionnelle, mais CNN peut recevoir des données car elles sont __ bidimensionnelles, donc des données bidimensionnelles telles que des images peuvent être utilisées comme informations. Vous pouvez apprendre sans perdre.

-Le réseau de neurones convolutifs se compose de __ "couche de convolution" __ et __ "couche de pooling" __. La couche de convolution est une couche qui se concentre sur une partie des données d'entrée et examine les caractéristiques de l'image. -Le __ pooling layer __ est une couche qui réduit la quantité de données en réduisant les __ données de sortie de la couche de convolution. Comme méthode de réduction, il y a __ "Max pooling" __ qui prend la valeur maximale de chaque fonctionnalité et __ "Average pooling" __ qui prend la valeur moyenne.

・ Diagramme de relation du calque de pliage

・ Diagramme de relation de la couche de pooling (pooling max)

Implémentation de couche

-Cette fois, nous allons implémenter la couche avec le modèle __Sequential __. -L'un des types de couches est __ "Dense" __. C'est une couche où toutes les entrées et sorties sont connectées. Le modèle ci-dessous utilise la couche entièrement connectée deux fois.

-La "couche de pliage" dans la section précédente peut être implémentée avec __ "Conv2D ()" __. __ "filters" __ est le nombre de filtres, __ "kernel_size" __ est la taille du filtre, __ "strides" __ est la distance pour déplacer les filtres à la fois, __ "padding" __ est __ 'same' Si __, la taille d'entrée et la taille de sortie sont alignées, et si __ «valide» __, ne le faites pas.

-La couche de pooling peut être implémentée avec __ "MaxPooling2D ()" __ pour Max pooling. __ "pool_size" __ spécifie la taille de la plage à regrouper, __ "strides" __ spécifie la distance pour déplacer le filtre en une seule fois (les enjambées ne doivent pas être spécifiées).

-Pour ces couches d'entrée, spécifiez la taille des données d'entrée avec __ "input_dim (unidimensionnel)" et "input_shape (multi-dimensionnel)" __. Par exemple, dans le cas de données d'image RVB (28 × 28), «input_shape = (28,28,3)».

-Lors de la combinaison d'une couche __ qui produit __2 dimensions telles que Conv2D et MaxPooling2D et une couche __ qui reçoit ___ une entrée dimensionnelle telle que Dense __, il est nécessaire d'ajouter __ "couche d'aplatissement" __ Il y a. -La couche d'aplatissement peut être ajoutée avec __ "Flatten ()" __, et aucun argument __ n'est requis __.

-Le code suivant est un exemple d'ajout de couches jusqu'à présent. model.add(Conv2D(input_shape=(28, 28, 3), filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same")) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(filters=32, kernel_size=(2, 2), strides=(1, 1), padding="same")) model.add(MaxPooling2D(pool_size=(2, 2)))

Apprentissage de modèle

Spécification de la fonction d'activation

-Spécifiez la fonction d'activation avec __ "model_add (Activation ('function name'))" __. Il y a __ "sigmoïde" __ pour les fonctions sigmoïdes, __ "relu" __ pour les fonctions ReLU et __ "softmax" __ utilisé dans la couche de sortie.

Compilez, apprenez

-Après avoir ajouté une couche au modèle, exécutez compile. Lors de la compilation, __comment modifier le taux d'apprentissage __, __ spécification de la fonction de perte __, __ spécification d'indice de précision __, etc. Plus précisément, compiler c'est __ "analyser du code écrit dans un langage de programmation de haut niveau et le pré-convertir en un langage machine qui peut être directement exécuté par un ordinateur" __. -La compilation peut être effectuée avec __ "model.compile ()" __. __ "optimizer" __ spécifie le taux d'apprentissage, __ "loss" __ spécifie la fonction de perte, __ "metrics" __ spécifie l'indice de précision. ・ Il y a __ [SGD, RMSprop, Adagrad, Adadelta, Adam] __ etc. pour le taux d'apprentissage, mais celui à utiliser est décidé par __exploratory __. -Les fonctions de perte incluent __mean squared_error (mean_squared_error) __, crossentropy (category_crossentropy, binary_crossentropy) , etc. - Metrics est souvent spécifié comme __ "['precision']" __.

-L'apprentissage se fait avec __ "model.fit ()" __. En plus de saisir les données de formation et de leur attribuer une étiquette, __ "batch_size" __ spécifie le nombre de données à transmettre en même temps, et __ "epochs" __ spécifie le nombre de formations. Le batch_size est spécifié pour effectuer le __ "mini-batch learning" __ appris à la fin du chapitre 1.

・ Exemple de code

Évaluation des performances du modèle

-Évaluer la précision du modèle formé avec __test data __. Ceci est fait avec __ "model.evaluate ()" __. En plus de transmettre les données d'entrée et l'étiquette des données de test, si verbose = 1, le processus de calcul est affiché.

Enregistrer et charger des modèles

-Lors de l'enregistrement du modèle créé, procédez comme __ "model.save ('model.h5')" __. -Lors du chargement de ce modèle, utilisez __ "model.load_model ('model.h5')" __.

-De plus, pour que __ permette à __ personnes de visualiser et de modifier ce modèle, il est nécessaire de le convertir une fois au format __ "json" __. Ceci est fait avec __ "model.to_json ()" __. -Pour charger ceci, utilisez __ "model_from_json (modèle converti)" __.

Sommaire

-Dans le traitement d'image, un "réseau neuronal convolutif" qui peut gérer des données d'image bidimensionnelles est utilisé. -En tant qu'implémentation de modèle, une méthode est utilisée dans laquelle la couche de convolution et la couche entièrement connectée sont connectées par une couche d'aplatissement, et après compilation et apprentissage, le modèle est évalué.

Cette fois, c'est fini. Merci d'avoir lu jusqu'à la fin.