Aidemy 2020/9/30
Bonjour, c'est Yope! Bien que je sois une école littéraire, j'étudie à l'école spécialisée en IA "Aidemy" parce que je me suis intéressé aux possibilités de l'IA. 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. Je vous remercie! Ceci est le premier article de Deep Learning. Ravi de vous rencontrer.
Quoi apprendre cette fois ・ À propos de l'apprentissage profond ・ Créez un modèle pour classer les nombres manuscrits
-Le Deep Learning est un type d'apprentissage automatique qui utilise un modèle appelé Deep Neural Network pour classer et régresser les données. Il porte un tel nom car il est fait en référence au réseau neuronal des organismes vivants. ・ L'apprentissage en profondeur est largement utilisé dans les domaines de la reconnaissance d'image et de la reconnaissance vocale. Le but de l'apprentissage profond est "d'améliorer la précision de reconnaissance des images et des sons".
-Le réseau de neurones (profond) est composé de couches d'éléments qui reçoivent et produisent des informations appelées neuron. Ceux qui ont trois couches ou plus à ce stade sont traités comme un modèle appelé réseau neuronal profond. À ce stade, la couche d'entrée est appelée input layer, la couche de sortie est appelée output layer et la couche entre les deux est appelée hidden layer. La couche dans laquelle le neurone précédent et le neurone suivant sont connectés pour chaque couche est appelée __ couche entièrement connectée __.
• Le neurone reçoit les __ valeurs d'entrée (x) __ et __ paramètres de poids (w) __. Si la valeur de l'expression représentée par x et w est supérieure au __seuil (θ) __ de chaque neurone, la valeur de 1 est transmise au neurone suivant, sinon 0 est passé. Cette transmission d'informations est appelée __neuron tir __. ・ En deep learning, un modèle de classification et un modèle de régression sont créés en ajustant mécaniquement la valeur du paramètre de poids (w).
・ Créer un modèle de réseau → Donner les données d'entraînement du modèle à former → (apprentissage terminé) → mettre en œuvre
・ Premièrement, comme confirmé dans la section précédente, un modèle de réseau est construit en formant une structure hiérarchique de certains neurones. Ensuite, les données d'apprentissage (valeur d'entrée x) sont fournies au modèle créé et la valeur de sortie y est sortie. Au début, la valeur de ce y est différente de celle de l'examen, mais la valeur du paramètre de poids (w) est ajustée de sorte que l'écart ΔE par rapport aux données de réponse correctes (étiquette de l'enseignant) devienne petit, et finalement la valeur appropriée est définie. Le modèle à retourner est terminé.
・ Préparation des données → Construire un modèle de réseau neuronal → Donner des données et former → Évaluation de la précision du modèle
-Cette fois, lorsque les données manuscrites d'entrée sont "7", la valeur correspondant à "7" parmi les étiquettes de réponse correctes des données d'enseignant est 1 (activé), et les autres valeurs sont 0 (désactivé). Les données avec une réponse correcte et 0 sortie autre que celle-ci sont appelées __one-hot vector __. De plus, l'affectation (étiquette) lors de la classification de données telles que "7" est appelée __class label __.
-Dans le cas d'une image de caractère manuscrite, les données d'entrée sont composées d'un ensemble de 28 * 28 nombres (vecteur). L'élément qui reçoit et calcule ce vecteur est appelé __node (unité) __, et le groupe d'unité vertical est appelé __layer (couche) __.
-TensorFlow est une bibliothèque d'apprentissage automatique fournie par Google. ・ Keras peut rendre le code TensorFlow intuitif et concis. Une bibliothèque wrapper qui facilite l'utilisation d'autres bibliothèques (TensorFlow dans ce cas), telles que Keras.
-Les données numériques manuscrites peuvent être utilisées immédiatement en important un jeu de données appelé MNIST depuis Keras. ・ (Revue) X correspond aux données d'image, y correspond aux données d'étiquette de l'enseignant. train est des données d'entraînement et test est des données de test pour l'évaluation du modèle.
from keras.datasets import mnist
(X_train,y_train),(X_test,y_test)=mnist.load_data()
-La méthode de construction (création) d'un modèle consiste à créer d'abord une instance __Sequential () __ qui gère le modèle, puis à la créer. __add (Dense (nombre d'unités de sortie dans la première couche entièrement connectée, input_dim = nombre d'unités d'entrée)) __ La couche d'entrée et la première couche entièrement connectée sont créées à l'aide de. De plus, il est nécessaire de spécifier la fonction __activation __ pour la sortie de la couche entièrement connectée. La méthode est __add (Activation ("nom de la fonction")) __. Si vous souhaitez créer la deuxième couche d'entrée et les suivantes, vous pouvez spécifier la valeur Dense avec la méthode add () à chaque fois (input_dim ne peut être spécifié qu'une seule fois). Enfin, définissez le processus d'apprentissage avec la méthode __compile () __ et terminez.
#Importation de module
from keras.model import Sequential
from keras.layers import Dense,Activation
#Création d'instance séquentielle (gestion des modèles)
model=Sequential()
#Nombre d'unités d'entrée 28*28=784, 256 unités de sortie de la première couche entièrement connectée, fonction d'activation sigmoïde
model.add(Dense(256,input_dim=784))
model.add(Activation("sigmoid"))
#256 unités de sortie pour la deuxième couche entièrement connectée, fonction d'activation relu
model.add(Dense(128))
model.add(Activation("relu"))
#Le nombre d'unités de sortie de la troisième couche entièrement connectée est de 10, fonction d'activation softmax
model.add(Dense(10))
model.add(Activation("softmax"))
#Paramètres du processus d'apprentissage (je ne connais pas les arguments maintenant)
model.compile(optimizer="sgd",loss="categorical_crossentropy",metrics=["accuracy"])
・ Apprenez avec __model.fit (X_train, y_train, verbose = 0or1, epochs = number of learning) __. ・ Si epochs est 1, la progression de l'apprentissage est sortie, et si elle est 0, elle n'est pas sortie. ・ (Révision) L'apprentissage est effectué en modifiant le poids de sorte que la différence entre la sortie et les données de l'enseignant devienne petite.
-Évaluer si le modèle peut produire une précision élevée autre que des données d'entraînement en utilisant des données de test. La précision des données de test à ce moment est appelée __ précision de la généralisation __. -Calculer la précision de généralisation avec __model.evaluate (X_test, y_test, verbose = 0or1) __.
・ Effectuer un problème de classification en utilisant le modèle entraîné (+ évalué). ・ __Model.predict (self, données d'entrée, batch_size = integer, verbose = 0 or1, steps = nombre d'étapes) __ ・ À propos de chaque argument
En ce qui concerne la valeur de retour, la méthode prédire () renvoie un tableau NumPy qui stocke la valeur prédite, mais comme la classe de caractères manuscrits est à 10 dimensions, la plus grande valeur est extraite. La méthode utilise __np.argmax (données utilisant Predict (), axis = 1) __ pour obtenir le numéro d'index de la valeur maximale. Étant donné que l'indice de chaque ligne peut être obtenu en définissant axis = 1, seul le résultat de la prédiction est affiché.
-L'apprentissage en profondeur fait référence à la classification et au retrait des données à l'aide d'un modèle appelé __Deep Neural Network __. ・ En deep learning, un modèle de classification et un modèle de régression sont créés en ajustant mécaniquement la valeur du paramètre de poids (w). ・ Le flux d'apprentissage en profondeur est la préparation des données, la création de modèles, l'apprentissage des modèles, l'évaluation des modèles et la classification par modèle. -Les données numériques manuscrites peuvent être utilisées immédiatement en important un ensemble de données appelé MNIST depuis Keras. -Créer un modèle, apprendre un modèle et évaluer un modèle avec __add (), fit () et evaluer () __, respectivement. -La classification par modèle se fait avec __predict () __, mais lors de la sortie, utilisez __np.argmax () __.
Cette fois, c'est fini. Merci d'avoir lu jusqu'au bout.
Recommended Posts