Python: pratique du Deep Learning

Présentation de l'apprentissage en profondeur

Le code est écrit en utilisant un «cadre» qui peut rationaliser la programmation. Pour les frameworks d'apprentissage en profondeur "Tensor Flow" développé par Google américain Il existe différents types tels que "PyTorch" développé par Facebook aux États-Unis.

Ici, TensorFlow et TensorFlow sont plus faciles à utiliser. Utilisez le framework "Keras".

Exemple d'apprentissage profond

Nombre d'époques (représente le nombre de fois qu'une donnée d'entraînement est entraînée à plusieurs reprises) Au fur et à mesure qu'il monte

Taux de réponse correct selon les données d'entraînement Taux de réponse correct val_acc pour les données de test Voyons comment ça monte.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense, Dropout
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

sgd = optimizers.SGD(lr=0.1)
model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

#Spécifiez 5 pour le nombre d'époques
history = model.fit(X_train, y_train, batch_size=500, epochs=5, verbose=1, validation_data=(X_test, y_test))

#acc, val_tracé acc
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.plot(history.history["val_acc"], label="val_acc", ls="-", marker="x")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

Qu'est-ce que le Deep Learning? (1)

L'apprentissage en profondeur, également appelé apprentissage en profondeur, est un type d'apprentissage automatique qui va encore plus loin. Référencement des réseaux de neurones biologiques pour la classification et la régression des données Nous utilisons un modèle appelé Deep Neural Network.

Cependant, le but de l'apprentissage profond n'est pas de reproduire le réseau neuronal du cerveau. Des recherches sont menées dans le but d'améliorer la précision de reconnaissance des images et des sons.

Réalisé par la technologie de conduite automatique utilisant la reconnaissance d'image et l'analyse vidéo, et l'analyse vocale Haut-parleurs intelligents tels que «Google Home» et «Siri» Cette technologie est utilisée dans de nombreux aspects de notre vie quotidienne.

L'une des raisons pour lesquelles l'apprentissage en profondeur attire l'attention est d'automatiser le travail que les gens accomplissent traditionnellement. Cela économise du temps et des efforts et améliore la précision.

Par exemple, lors de la création d'un programme qui détecte une «voiture» à partir d'une image Dans l'apprentissage automatique, des informations détaillées telles que les caractéristiques de divers types de pneus de voiture et de pare-brise sont préparées à l'avance. J'ai dû créer un modèle qui l'a entraîné.

Cependant, l'apprentissage en profondeur peut trouver automatiquement les caractéristiques des pièces automobiles sans un tel modèle.

Qu'est-ce que l'apprentissage profond? (2)

La figure ci-dessous montre les neurones qui composent le réseau neuronal. x1 et x2 sont des valeurs d'entrée et w1 et w2 sont des paramètres de poids.

Dans ce modèle, si la valeur de x1w1 + x2w2 est supérieure au seuil θ, le neurone se déclenchera. Sorties 1 et 0 sinon.

Lorsque l'entrée dépasse le seuil, le neurone communique avec le neurone suivant.

C'est ce qu'on appelle le déclenchement neuronal.

Le réseau neuronal reçoit des valeurs d'entrée telles que des vecteurs et des matrices Il génère enfin des valeurs telles que des scalaires et des vecteurs via une chaîne de tir.

Si vous comparez cela avec la reconnaissance d'image, en entrant les données de pixels de l'image animale C'est une image qui fournit des informations sur la catégorie (chat, chien, oiseau, etc.) qui appartient probablement.

Ensuite, comme le montre la figure ci-dessous, les couches de neurones ont été empilées afin que des problèmes plus complexes puissent être traités. C'est un réseau neuronal profond. En particulier, il se réfère souvent à une structure à trois couches ou plus. Il a été nommé "Deep" en raison de la profondeur de sa structure.

En fait, le modèle mathématique appelé réseau de neurones Il existe déjà depuis les années 50.

Et ces dernières années, un environnement informatique pouvant utiliser des réseaux de neurones profonds a été mis en place. Au fur et à mesure que la recherche sur les méthodes d'apprentissage progressait, elle a reçu beaucoup d'attention.

En apprentissage profond, le paramètre de poids de chaque neurone est ajusté mécaniquement. Créez un modèle de classification ou un modèle de régression.

Flux de classification utilisant l'apprentissage en profondeur

Regardons le flux de classification à l'aide de l'apprentissage en profondeur.

① Créer un modèle de réseau

En empilant des couches qui regroupent plusieurs neurones comme indiqué sur la figure Créez un modèle de réseau profond.

Au départ, les neurones répondent de manière aléatoire à l'entrée, produisant des valeurs sans signification.

② Donnez au modèle les données d'entraînement et effectuez l'apprentissage

Le modèle prend la valeur d'entrée X et sort la valeur de sortie y.

À ce moment, assurez-vous que ΔE, qui est la différence entre y et les données de réponse correctes (étiquette de l'enseignant) T, devient petit. Le poids du neurone est automatiquement ajusté par une méthode appelée propagation de retour d'erreur.

Ensuite, en donnant des données brutes X telles qu'une image et des données de réponse correctes T, le poids est ajusté à plusieurs reprises. Peu à peu, vous pourrez obtenir la valeur de sortie souhaitée.

Si la formation se déroule bien, vous aurez un modèle qui renvoie les prédictions appropriées.

③ Transmettez les données de classification au modèle

Les données peuvent être classées par apprentissage en profondeur selon le flux illustré dans la figure. En d'autres termes, l'apprentissage en profondeur vous permet de créer des modèles de classification et de régression sans avoir à comprendre les détails de la procédure.

Classification des nombres manuscrits

Flux vers la classification

Implémentons le modèle de réseau neuronal suivant à l'aide d'une bibliothèque appelée Keras. Premièrement, la procédure suivante est utilisée pour classer les nombres manuscrits, ce qui peut être considéré comme une norme en apprentissage profond.

1, préparer les données 2, construire un modèle de réseau neuronal 3, donnez des données au modèle et entraînez-le 4, évaluer la précision de classification du modèle Enfin, donnez une image de nombres manuscrits pour voir les valeurs prédites.

Réseau neuronal profond

Un réseau de neurones d'une certaine profondeur

Appelé un réseau neuronal profond

Couche d'entrée: couche d'entrée Couche de sortie: couche de sortie Couche cachée: entre la couche d'entrée et la couche de sortie C'est appelé.

Cette fois, tous les neurones étaient connectés aux neurones de la couche précédente

Couche entièrement connectée

Créez un réseau de neurones avec une structure simple à deux.

Lorsque les données d'image manuscrites d'entrée sont "7" L'étiquette de réponse correcte des données de l'enseignant est 1 pour l'élément correspondant à 7 et 0 pour les autres éléments.

Données avec toutes les valeurs nulles sauf un élément

one-C'est ce qu'on appelle un vecteur chaud.

Puisque cette fois nous reconnaissons les nombres, les 0e à 9e éléments représentent respectivement les caractères «0» à «9».

S'il s'agit d'une reconnaissance d'image telle que "quel type d'animal est sur l'image" Les éléments 0e à Nième correspondent à chaque animal qui est une option de reconnaissance. Ces classifications (classes) sont attribuées dans l'ordre et exprimées numériquement, ce qui est appelé une «étiquette de classe».

Unité de nœud

Les données à saisir sont une image monochrome de 28 pixels de hauteur et de largeur. Même une image est appelée un vecteur car elle ressemble à une collection de 28 x 28 nombres sur un ordinateur.

L'élément représenté par "○" qui reçoit le vecteur et effectue le calcul

C'est ce qu'on appelle un «nœud» ou une «unité».

En comptant du côté de l'entrée, les unités disposées verticalement dans la figure ci-dessus

C'est ce qu'on appelle un "calque" ou "calque".

C'est ainsi qu'il est appelé lorsqu'il est organisé de manière à ce qu'il soit facile à voir pour les humains. L'endroit où se trouvent les unités dans la même couche changera de temps en temps.

Cette fois

model.add(Dense(256, input_dim=784))
#J'ai créé une couche d'entrée. 256 est le nombre d'unités.
# input_Dans dim, le nombre d'éléments du vecteur d'entrée est spécifié.
# input_dim peut être traité comme le nombre de colonnes.

Puisque 28 × 28 = 784, nous spécifions qu'un vecteur avec 784 éléments sera entré.

J'ai décidé d'exprimer le caractère de la sortie avec une probabilité. La probabilité est sortie pour chacun des 10 types de 0 à 9. Préparez 10 unités qui acceptent toutes les valeurs générées par les unités de couche masquées et produisent la probabilité.

Introduction de Keras

Enquête menée par le site d'information d'exploration de données KD Nuggets Dans le cadre d'apprentissage profond Power Scores 2018 Les résultats montrent que Keras est le deuxième plus populaire après TensorFlow.

TensorFlow est une bibliothèque de logiciels open source pour l'apprentissage automatique fournie par Google. Keras est une bibliothèque d'encapsulation TensorFlow qui vous permet d'écrire du code de manière plus intuitive et concise.

Pour le dire clairement, Keras se situe quelque part entre TensorFlow et le code, plutôt que d'écrire directement TensorFlow. Vous pouvez réduire le code à une fraction.

L'emballage dans ce cas signifie que le système est inclus pour le rendre plus facile à utiliser.

Préparation des données

Pour l'apprentissage des nombres manuscrits, il est publié sur le site Internet de Yann LeCun.

MNIST(Emnist)Utilisez l'ensemble de données.

MNIST peut également être téléchargé en exécutant le code ci-dessous dans Keras.

from keras.datasets import mnist
(X_train, y_train), (X_test, y_test) = mnist.load_data()

Dans le code, X est les données d'image et y est les données d'étiquette d'enseignant. train correspond aux données d'entraînement et test aux données utilisées pour évaluer les performances du modèle.

Cependant, il n'y a pas de différence essentielle entre les données de train et les données de test. Vous pouvez également lire les données en exécutant MNIST à l'état téléchargé.

Sortons la taille de chacun des X_train, y_train, X_test et y_test.

from keras.datasets import mnist

(X_train, y_train), (X_test, y_test) = mnist.load_data()

print(X_train.shape, y_train.shape, X_test.shape, y_test.shape)

#Résultat de sortie

(60000, 28, 28) (60000,) (10000, 28, 28) (10000,)

Génération de modèle

Chez Keras, créez d'abord une instance pour gérer le modèle

Définissez-le couche par couche avec la méthode d'ajout.

Créez une instance.

from keras.models import Sequential
from keras.layers import Dense, Activation

model = Sequential()

Cette fois, nous définirons une couche entièrement connectée de 128 unités. Définissez le modèle couche par couche en utilisant la méthode d'ajout comme indiqué ci-dessous.

model.add(Dense(128))

Une fonction appelée fonction d'activation est appliquée à la sortie de la couche entièrement connectée.

model.add(Activation("sigmoid"))

C'est un mécanisme équivalent à la mise à feu des nerfs de l'animal.

Réglez la fonction sigmoïde sigmoïde et la fonction ReLU relu.

et enfin

Compile méthode compile()Définissez le processus de formation avec et la génération du modèle est terminée.

model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])
#Ces fonctions et paramètres seront discutés plus tard.

Si vous donnez un exemple

Tout d'abord, saisissez l'image de construction du modèle de réseau. Dans le code ci-dessous, après avoir généré un modèle de réseau avec une couche masquée. Générez un modèle avec deux couches masquées, comme illustré ci-dessous. Utilisez la fonction ReLU relu comme fonction d'activation.

from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.utils.vis_utils import plot_model
from keras.utils.np_utils import to_categorical
import matplotlib.pyplot as plt

(X_train, y_train), (X_test, y_test) = mnist.load_data()

# (◯, 28, 28)Les données(◯, 784)Réduction de dimension à.(Réduisez le nombre de données pour plus de simplicité)
shapes = X_train.shape[1] * X_train.shape[2]
X_train = X_train.reshape(X_train.shape[0], shapes)[:6000]
X_test = X_test.reshape(X_test.shape[0], shapes)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
#Le nombre d'unités d'entrée est 784,Le nombre d'unités de sortie dans la première couche entièrement connectée est de 256
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))

#Le nombre d'unités de sortie dans la deuxième couche entièrement connectée est de 128. La fonction d'activation est relu.
#　---------------------------
#Il crée deux couches cachées.
model.add(Dense(128))
model.add(Activation("relu"))

#　---------------------------

#Le nombre d'unités de sortie dans la troisième couche entièrement connectée (couche de sortie) est de 10.
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

#Sortie de la structure du modèle
plot_model(model, "model125.png ", show_layer_names=False)
#Visualisation de la structure du modèle
image = plt.imread("model125.png ")
plt.figure(dpi=150)
plt.imshow(image)
plt.axis('off')
plt.show()

Apprentissage de modèle

#L'entraînement est effectué en utilisant la méthode d'ajustement et en transmettant les données d'entraînement au modèle.
model.fit(X_train, y_train, verbose=1, epochs=3)

Dans la méthode d'ajustement, les données d'entraînement sont entrées dans le modèle dans l'ordre. Mettez à jour le poids de chaque neurone afin que la différence entre la sortie et les données de l'enseignant soit faible Nous améliorerons la précision de prédiction du modèle.

(1) En tant que valeur de retour, un objet History qui contient un enregistrement d'apprentissage est renvoyé.
② Argument X_train est des données de formation, y_train, ce sont les données des enseignants.
③ 1 pour verbeux(Ou vrai)Si est spécifié, la progression de l'apprentissage est sortie, et si elle est 0, elle n'est pas sortie.
④ epochs spécifie le nombre de formations à effectuer sur le même jeu de données.

Voici un exemple.

from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential
from keras import optimizers
from keras.utils.np_utils import to_categorical
import matplotlib.pyplot as plt

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])
#---------------------------
history = model.fit(X_train, y_train, verbose=True, epochs=3)
#---------------------------
#acc, val_tracé acc
plt.plot(history.history["acc"], label="acc", ls="-", marker="o")
plt.ylabel("accuracy")
plt.xlabel("epoch")
plt.legend(loc="best")
plt.show()

Évaluation du modèle

Même si le réglage par apprentissage est terminé et que la précision du modèle est améliorée Il est possible que ses performances ne puissent être démontrées qu'avec des données d'entraînement. Par conséquent, les données entraînées ne peuvent pas être utilisées pour évaluer correctement les performances du modèle.

Par conséquent, nous évaluerons le modèle en utilisant des données de test qui n'ont pas été utilisées pour la formation. La précision à ce moment

Précision de généralisation(Précision pour les nouvelles données)C'est appelé.

Pour calculer la précision de généralisation

Utilisez la méthode d'évaluation.

score = model.evaluate(X_test, y_test, verbose=1)

X_test est les données d'entrée pour l'évaluation (test), et y_test est les données de l'enseignant. La valeur de la fonction de perte et le taux de précision obtenus par la méthode d'évaluation sont stockés dans score.

Les données de test servent à calculer la précision de généralisation et ne sont pas utilisées pour la formation.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential, load_model
from keras import optimizers
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train)

# ---------------------------
score = model.evaluate(X_test, y_test, verbose=True)
# ---------------------------
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

Classification par modèle

Utilisez la méthode prédire pour obtenir la valeur prévue des données d'entrée.

predict(self, x, batch_size=None, verbose=0, steps=None)

argument

①　x:Des données d'entrée. Format de tableau Numpy.
②　batch_size:entier. La valeur par défaut est 32.
③　verbose:Mode de sortie du message de progression. 0 ou 1.
④　steps:Nombre total d'étapes (lot d'échantillons) avant de déclarer la fin du cycle d'évaluation. Si Aucun (valeur par défaut), il sera ignoré.

Valeur de retour

Tableau Numpy contenant des valeurs prédites

Par exemple, lors de la prédiction du nombre de deux images de X_test, ce sera comme suit.

import numpy as np
#Préparez un modèle entraîné.
model = ...

#Prédire
pred = np.argmax(model.predict(X_test[0:2]))
print("Valeur prédite:" + str(pred))

Notez que prédire suppose plusieurs images. Il est nécessaire de faire attention à la dimension lors de la prédiction d'une seule feuille. Si vous voulez n'en prédire qu'un Il est nécessaire de concevoir pour décrire l'argument comme X_test [0] .reshape (1, -1).

Dans MNIST, la sortie de la méthode de prédiction est de 10 dimensions Utilisez la fonction argmax pour renvoyer l'index de la valeur maximale du tableau Obtient l'emplacement du neurone qui renvoie la valeur la plus élevée.

import numpy as np
x = np.array([[0, 1, 2], [-1, 1000, 1]])
print(np.argmax(x)) #Renvoie 4.
print(np.argmax(x, axis=0)) # [0, 1, 0]Retour.
print(np.argmax(x, axis=1)) # [2, 1]Retour.

La fonction argmax est

(1) Spécifiez l'axe avec l'argument optionnel axis et donnez-le avec le premier argument
Vérifiez l'index de la valeur maximale du tableau.

(2) Si axis n'est pas spécifié, le tableau sera unidimensionnel.
Renvoie l'index de la valeur maximale lors du remodelage.

Après l'apprentissage, affichez la valeur prédite de X_test [0:10] et visualisez-la.

import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
from keras.layers import Activation, Dense
from keras.models import Sequential, load_model
from keras.utils.np_utils import to_categorical

(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(X_train.shape[0], 784)[:6000]
X_test = X_test.reshape(X_test.shape[0], 784)[:1000]
y_train = to_categorical(y_train)[:6000]
y_test = to_categorical(y_test)[:1000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
model.add(Dense(10))
model.add(Activation("softmax"))

model.compile(optimizer="sgd", loss="categorical_crossentropy", metrics=["accuracy"])

model.fit(X_train, y_train, verbose=True)

score = model.evaluate(X_test, y_test, verbose=False)
print("evaluate loss: {0[0]}\nevaluate acc: {0[1]}".format(score))

#Afficher les 10 premières feuilles de données de test
for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(X_test[i].reshape((28,28)), "gray")
plt.show()

# X_Affiche les 10 premières étiquettes prédites du test
#---------------------------
pred = np.argmax(model.predict(X_test[0:10]), axis=1)
print(pred)
#---------------------------