[PYTHON] Apprentissage profond appris par l'implémentation 1 (édition de retour)

Premier apprentissage profond

introduction

Je suis entré en contact avec l'apprentissage profond pour la première fois lorsque j'étais en troisième année du premier cycle, et il semble qu'il y avait peu de conférences sur l'apprentissage profond dans les classes de premier cycle. Il y a beaucoup de choses que j'ai recherchées dans le deep learning par moi-même, mais j'ai repris les étapes que j'ai suivies pour comprendre et mettre en œuvre la structure interne du deep learning et je l'ai publiée sur mon blog. Mettez-le. De plus, c'est la première fois que j'écris un blog et c'est un article de pratique, il semble donc difficile à lire. Veuillez pardonner.

Qu'est-ce que le Deep Learning?

Tout d'abord, je vais expliquer ce que fait l'apprentissage profond avant la mise en œuvre. L'apprentissage profond est, en un mot, l'optimisation des fonctions. Si vous optimisez une fonction qui prend une image en entrée et donne la probabilité que l'image soit un chat, elle devient un classificateur qui classe l'image comme chat et autres, et une fonction qui prend $ x $ comme entrée et sort $ sin (x) $. Si vous optimisez, cela s'appelle un modèle de régression. Tout d'abord, nous mettrons en œuvre la régression pour réaliser que le deep learning est une optimisation des fonctions.

Arrangement environnemental

Si vous disposez d'un ordinateur personnel et d'un environnement Internet, vous disposez de tout ce dont vous avez besoin pour un apprentissage en profondeur. Si vous utilisez google colaboratory fourni par google, vous disposez de toutes les bibliothèques nécessaires, alors utilisez-la (c'est devenu un monde pratique). google cola boratory peut être sélectionné parmi d'autres en appuyant sur un nouveau bouton de google drive. Une fois ouvert, le jupiter-notebook est ouvert et un environnement interactif est configuré immédiatement.

Implémentation de la régression (prédiction de y = sin (x))

Je pense que c'est plus facile à comprendre si vous en discutez tout en regardant ce qu'il implémente et fonctionne, alors implémentez d'abord le modèle de régression. Tout d'abord, insérons le code suivant.

import numpy as np
import matplotlib.pyplot as plt
x = np.arange(0,20,0.1)
y = np.sin(x)
plt.plot(x,y)

Lorsque je fais cela, je pense que la courbe de péché est affichée sous forme de graphique. C'est la bibliothèque que matplotlib a utilisée pour dessiner des tables, et j'utiliserai cette bibliothèque fréquemment à partir de maintenant. Jusqu'à ce point, les données d'entraînement ont été générées. Les nombres réels de 0 à 20 par incréments de 0,1 et leurs péchés.

Ensuite, définissez le modèle.

from keras import layers
from keras import models
from keras import optimizers
model = models.Sequential()
model.add(layers.Dense(256,activation = "relu",input_shape=(1,)))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(256,activation = "relu"))
model.add(layers.Dense(1))
model.compile(loss = "mse",optimizer="adam")

Ici, j'ai importé ce dont j'avais besoin de la bibliothèque keras. Le modèle est de savoir comment créer une fonction cette fois-ci, et bien qu'il existe plusieurs façons de la décrire, Sequential () est utilisé d'une manière facile à comprendre. Vous pouvez voir ici que nous ajoutons beaucoup de couches au modèle. Cette fois, j'utilise beaucoup de couches. Sens, mais je vais vous expliquer ce que c'est.

Couche entièrement connectée

Comme vous pouvez le voir dans le sous-titre, layer.Dense reçoit le vecteur dans le calque entièrement connecté et renvoie le vecteur. Je pense qu'il y a beaucoup de choses qui prennent 256 comme argument, mais c'est combien de dimensions la sortie devrait être. Par exemple, l'entrée est x à n dimensions, la sortie est y à m dimensions et la couche entièrement connectée est exprimée par l'équation suivante.

y = Ax+b

Où A est une matrice n * m et b est un vecteur à m dimensions. D'où viennent cette matrice et ce vecteur? Nous les avons tous comme variables et les optimisons plus tard. En d'autres termes, cela permet de reproduire toute transformation linéaire.

Fonction d'activation

Il s'avère que le modèle ci-dessus essaie d'obtenir $ y $ en appliquant plusieurs fois des transformations linéaires, mais plusieurs transformations linéaires peuvent être reproduites avec une transformation linéaire. Dans ce cas, il est inutile d'empiler de nombreuses couches entièrement connectées. Ce qui en ressort est une fonction d'activation, qui est une cartographie non linéaire. Il effectue un mappage non linéaire sur toutes les valeurs du vecteur. En mordant ceci entre les couches entièrement connectées, la capacité expressive de l'ensemble du modèle augmente lorsque les couches sont empilées. Tout ce code utilise Relu. C'est $ max (0, x) $, qui est certainement non linéaire. Ce Relu est souvent utilisé dans le domaine du deep learning.

optimisation

Un grand nombre de variables internes ($ A et b $) sont utilisées pour représenter des transformations linéaires arbitraires dans la couche entièrement connectée, et comment les optimiser est décrite dans model.compile. La perte est un indice dont la valeur devient plus petite à mesure qu'il devient optimal, et cette fois nous utilisons mse (erreur quadratique moyenne). Autrement dit, c'est le carré de la différence entre la valeur prédite et la valeur correcte. Les paramètres ne peuvent pas être optimisés simplement en calculant la perte du modèle actuel. Vous devez calculer combien vous devez déplacer les paramètres dans quelle direction pour réduire la perte. Fondamentalement, il suffit de descendre le gradient des paramètres, mais du point de vue de la stabilisation et de l'accélération, adam qui utilise la différenciation quadratique et le gradient à l'étape précédente est le plus approprié pour l'apprentissage en profondeur. On dit que c'est bon pour la conversion.

Entraînement

Entraînons-nous réellement.

hist=model.fit(x,y,steps_per_epoch=10,epochs = 10)

En apprentissage, les données d'entraînement sont souvent énormes, il n'est donc souvent pas possible de descendre le gradient en utilisant toutes les données d'entraînement en un seul apprentissage (réglage des paramètres), donc un lot avec des données d'entraînement plus petites est utilisé. Cette fois, toutes les données d'entraînement sont divisées en 10 (setps_per_epoch = 10). En d'autres termes, 2 descendre le gradient à partir de ces données 10 fois correspond à une époque (correspondant au nombre de fois où toutes les données d'entraînement ont été léchées dans l'unité d'apprentissage), et cette fois s'entraîner à lécher l'ensemble des données d'entraînement 10 fois Je vous laisse.

Prévoir

Prédisons.

test_x = x + 0.05
acc_y = np.sin(test_x)
pre_y = model.predict(test_x)
plt.plot(test_x,acc_y)
plt.plot(test_x,pre_y)
plt.show()

Cela vous donnera une idée de la façon dont le modèle se comporte de la même manière que sin (x) pour les données qui s'écartent des données d'apprentissage de 0,05 dans la direction x. Si vous le déplacez tel quel, il ressemblera à ceci.

La valeur est loin à $ x> 10 $.

En améliorant le modèle lui-même et en faisant plus de formation, il peut être amélioré comme indiqué ci-dessous, alors essayons-le.

GPU Si vous avez besoin d'un modèle qui prend beaucoup de temps à apprendre, ou si vous avez besoin d'un long temps de formation, accédez à Modifier-> Paramètres du bloc-notes dans google colaboratory et changez l'accélérateur matériel de Aucun à GPU. La formation devrait se terminer tôt avec la puissance du GPU.

en conclusion

Cette fois, la courbe de péché était exprimée uniquement par transformation linéaire et relu. En plus de la courbe de péché, l'apprentissage en profondeur peut approcher des fonctions arbitraires de la reconnaissance d'image à la génération d'images, de sorte que les possibilités sont infinies. La prochaine fois, j'aimerais expliquer la couche de convolution en implémentant la reconnaissance d'image et la reconnaissance de caractères manuscrits solides mais mnist sur une ligne aussi courte que possible.