Python: réglage du Deep Learning

Hyper paramètres

Pour le modèle de réseau neuronal Il existe des soi-disant hyperparamètres qui doivent être ajustés lors de la configuration du réseau.

Il existe de nombreux hyper paramètres et s'ils ne sont pas définis correctement, ils ne seront pas correctement entraînés. Par conséquent, lors de la création d'un nouveau modèle, il est nécessaire de concevoir les hyper paramètres optimaux.

Regardons les hyper paramètres dans le code réel.

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))
#Hyperparamètre: fonction d'activation
model.add(Activation("sigmoid"))
#Hyper paramètres: nombre de couches cachées, nombre d'unités de couches cachées
model.add(Dense(128))
model.add(Activation("sigmoid"))
#Hyper paramètre: taux d'abandon (taux)
model.add(Dropout(rate=0.5))
model.add(Dense(10))
model.add(Activation("softmax"))

#Hyper paramètre: taux d'apprentissage (lr)
sgd = optimizers.SGD(lr=0.01)

#Hyperparamètres: optimiseur
#Hyperparamètre: fonction d'erreur (perte)
model.compile(optimizer=sgd, loss="categorical_crossentropy", metrics=["accuracy"])

#Hyper paramètres: taille du lot_size）
#Hyper paramètres: époques
model.fit(X_train, y_train, batch_size=32, epochs=10, verbose=1)

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

Paramètres de la structure du réseau

Le nombre de couches masquées et le nombre d'unités entre la couche d'entrée et la couche de sortie peuvent être librement spécifiés. En augmentant le nombre, il devient possible d'exprimer diverses fonctions.

Cependant, si le nombre de couches cachées est important, la difficulté d'ajustement du poids augmentera et la progression de l'apprentissage ralentira. Lorsque le nombre d'unités est important, le surapprentissage (un état avec des performances de généralisation faibles) est effectué en extrayant des entités de faible importance. Il sera plus facile de se réveiller. Par conséquent, il est nécessaire de définir un nombre approprié pour l'apprentissage, plutôt que de simplement augmenter aveuglément le nombre.

Considérez la structure du réseau basée sur le précédent, par exemple en vous référant à un exemple d'implémentation similaire.

Par exemple

Confirmer l'effet de la structure de couche masquée sur l'entraînement du modèle Prédisons le modèle le plus précis parmi les trois suivants.

R: Une couche cachée entièrement connectée avec 256 unités et une couche cachée entièrement connectée avec 128 unités B: 1 couche cachée entièrement connectée avec 256 unités, 3 couches cachées entièrement connectées avec 128 unités C: 1 couche cachée entièrement connectée avec 256 unités, 1 couche cachée entièrement connectée avec 1568 unités

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"))

def funcA():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcB():
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))
    model.add(Dense(128))
    model.add(Activation("sigmoid"))

def funcC():
    model.add(Dense(1568))
    model.add(Activation("sigmoid"))

#Choisissez l'un des modèles A, B et C et commentez les deux autres.
#---------------------------
funcA()
funcB()
funcC()
#---------------------------

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"])

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

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




#La bonne réponse est funcA()est.

Abandonner

L'abandon empêche le surentraînement des données d'entraînement C'est l'une des méthodes pour améliorer la précision du modèle.

Dans le décrochage, supprimez au hasard les neurones (remplacez-les par 0) Répétez l'apprentissage. Ainsi, le réseau neuronal devient un neurone spécifique. Vous apprendrez des fonctionnalités plus générales sans dépendance.

La description de l'abandon est la suivante.

model.add(Dropout(rate=0.5))
#taux est le pourcentage d'unités à supprimer.

Les positions et les taux d'abandon sont tous deux des hyperparamètres.

Mettez en œuvre un abandon pour vous rapprocher du taux de réponse correct pour les données d'entraînement et les données de test.

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"))

# ---------------------------
#Voici le code du décrochage
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"])

history = model.fit(X_train, y_train, batch_size=32, 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()

Fonction d'activation

Fonction d'activation

La fonction d'activation est une fonction qui est appliquée après la couche entièrement connectée, etc.
Cela équivaut à déclencher un neurone.

Dans la couche entièrement connectée, l'entrée est transformée et sortie de manière linéaire. La non-linéarité peut être ajoutée en utilisant la fonction d'activation.

Si la fonction d'activation n'est pas utilisée, elle ne peut pas être séparée par une seule ligne droite comme le montre la figure ci-dessous (la séparation linéaire n'est pas possible). Les données ne peuvent pas être classées.

En donnant la non-linéarité par la fonction d'activation Même les modèles qui ne peuvent pas être séparés linéairement pourront toujours être classés s'ils sont correctement formés.

Il existe plusieurs types de fonctions d'activation, il est donc important de choisir celle qui convient.

Fonction Sigmaid

La fonction sigmoïde est l'une des fonctions d'activation La valeur d'entrée est définie sur une valeur comprise entre 0 et 1 et la sortie. La formule est la suivante.

La fonction sigmoïde est essentiellement 1/2 à X = 0 0 ou plus et moins de 1/2 lorsque X <0 1/2 ou plus et moins de 1 lorsque x> 0 Il est devenu.

Le graphique bleu est la fonction sigmoïde Le graphique orange est le dérivé de la fonction sigmoïde.

ReLU

En tant que fonction d'activation souvent utilisée

Il y a ReLU (fonction de rampe).

Cette fonction prend 0 si la valeur d'entrée est inférieure à 0 et prend la valeur d'entrée comme valeur de sortie si elle est égale ou supérieure à 0.

La formule de définition de ReLU (Rectified Linear Unit) est affichée.

ReLU (fonction de rampe) est essentiellement

0 lorsque x <0 x => 0 et y = x Ce sera.

Le graphique bleu représente ReLU et le graphique orange représente le dérivé de ReLU.

Fonction de perte

Fonction de perte

Une fonction qui évalue la différence entre les données de sortie et les données de l'enseignant pendant la formation

C'est ce qu'on appelle une fonction de perte (fonction d'erreur).

Il est possible d'évaluer en utilisant le taux de réponse correct comme indice, mais cela seul ne suffit pas pour les données de sortie individuelles. Je ne connais pas les résultats détaillés tels que les réponses correctes et incorrectes. En d'autres termes, la fonction de perte est utilisée pour voir la différence entre chaque donnée de sortie et les données de l'enseignant.

Il existe de nombreux types de fonctions de perte Couramment utilisé pour l'apprentissage automatique

Les exemples incluent l'erreur quadratique et l'erreur d'entropie croisée.

Nous en reparlerons plus tard.

De plus, une technique appelée rétropropagation d'erreur est utilisée pour rendre efficace le calcul du différentiel de la fonction de perte. Cette technique met à jour les pondérations de chaque couche pour minimiser la différence entre les données de sortie et les données de l'enseignant.

Erreur quadratique moyenne

L'erreur quadratique moyenne est à côté de la méthode du carré minimum
Il s'agit d'une fonction d'erreur souvent utilisée dans des domaines tels que les statistiques.

Décrivez avec la formule suivante.

yi est l'étiquette de prédiction et ti est l'étiquette de réponse correcte. Étant donné que l'erreur quadratique moyenne est bonne pour évaluer les valeurs continues, elle est principalement utilisée comme fonction d'erreur des modèles de régression.

Puisque 1 / N est une constante déterminée par le nombre de données, nous pouvons l'omettre et utiliser simplement la fonction d'erreur qui est la somme des valeurs au carré des erreurs.

Erreur d'entropie croisée

L'erreur d'entropie croisée est spécialisée pour l'évaluation de la classification Il est principalement utilisé comme une fonction d'erreur du modèle de classification. La formule est la suivante.

De plus, la formule suivante est souvent utilisée en général.

Ce faisant, tous les termes avec des étiquettes autres que 1 seront 0. En effet, seule l'erreur de l'étiquette de réponse correcte est calculée.

Par exemple, supposons que vous ayez une sortie comme celle ci-dessus. Le calcul de cette erreur d'entropie croisée est le suivant.

En d'autres termes, plus yi est proche de 1, plus le logyi est proche de 0, donc l'erreur devient plus petite. Nous pouvons voir que le principe est que lorsque y approche 0, logyi s'approche de -∞ et l'erreur augmente.

Fonction d'optimisation

Sur la base de la valeur différenciée par la fonction d'erreur, la direction et le degré sont déterminés et le poids est mis à jour. À ce moment-là, comment vérifier le taux d'apprentissage, le nombre d'époques, la quantité de mises à jour de poids passées, etc. La fonction d'optimisation est utilisée pour déterminer si le poids est reflété dans la mise à jour.

Les fonctions d'optimisation sont des hyperparamètres qui doivent être ajustés par l'homme. Comme vous pouvez le voir, il existe plusieurs types de fonctions d'optimisation qui doivent être correctement sélectionnées. Soyez prudent car cela peut nuire à l'apprentissage.

Taux d'apprentissage

Le taux d'apprentissage détermine dans quelle mesure le poids de chaque couche est modifié à la fois. Hyper paramètres.

La figure ci-dessous illustre le modèle de minimisation et l'impact du taux d'apprentissage. Le point supérieur droit est la valeur initiale.

1, le taux d'apprentissage est trop faible et la mise à jour progresse à peine. 2, avec un taux d'apprentissage approprié, les valeurs convergent en un petit nombre de fois. 3, il converge, mais il y a un gaspillage dans la mise à jour car la valeur est grande. 4, le taux d'apprentissage est trop élevé et les valeurs divergent. (Mis à jour vers le haut et la valeur devient de plus en plus grande)

En d'autres termes, pour entraîner correctement le modèle, il est nécessaire de définir un taux d'apprentissage approprié pour la fonction de perte.

#Réglage du taux d'apprentissage
global lr
    lr = #Paramètres

J'ai montré un exemple ci-dessous, veuillez donc l'ajuster et le vérifier.

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"))


def funcA():
    global lr
    lr = 0.01

def funcB():
    global lr
    lr = 0.1

def funcC():
    global lr
    lr = 1.0

#Choisissez l'une des trois et commentez les deux autres lignes pour comparer les modifications.
#---------------------------
#funcA()
funcB()
#funcC()
#---------------------------

sgd = optimizers.SGD(lr=lr)

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

model.fit(X_train, y_train, batch_size=32, epochs=3, verbose=1)

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

Mini apprentissage par lots

Le nombre de données à saisir dans le modèle à la fois

Appelé la taille du lot, c'est également l'un des hyper paramètres.

Si vous transmettez plusieurs données à la fois, le modèle calcule le gradient de fonction de perte et de perte pour chaque donnée. Le poids n'est mis à jour qu'une seule fois en fonction de la valeur moyenne du gradient de chaque donnée.

De cette manière, en mettant à jour le poids avec des données multiples, l'influence des données biaisées est réduite. Vous pouvez également raccourcir le temps de calcul en effectuant un calcul parallèle.

Cependant, d'un autre côté, il devient difficile pour des mises à jour de poids importantes de se produire, et il est optimisé pour certaines données.

Il est également possible que vous soyez bloqué dans un état où l'optimisation de l'ensemble des données n'est pas effectuée (solution locale).

Pour éviter cela, quand il y a beaucoup de données irrégulières Augmentez la taille du lot, diminuez la taille du lot lorsqu'il est petit, etc. Ajustez la taille du lot.

Apprentissage en ligne(Méthode de descente de gradient probabiliste):Méthode d'apprentissage pour définir la taille du lot sur 1
Apprentissage par lots(La méthode de descente la plus raide):Méthode d'apprentissage pour définir le nombre total de données
Mini apprentissage par lots:Méthode d'apprentissage pour définir un petit nombre au milieu
Est appelé.

#Ajustement de la taille des lots
global batch_size
    batch_size = #Paramètres

Voici un exemple de code.

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"])

def funcA():
    global batch_size
    batch_size = 16

def funcB():
    global batch_size
    batch_size = 32

def funcC():
    global batch_size
    batch_size = 64

#Choisissez l'une des trois, commentez les deux autres lignes et par lots_Veuillez comparer la taille.
#---------------------------
#funcA()
#funcB()
funcC()
#---------------------------

model.fit(X_train, y_train, batch_size=batch_size, epochs=3, verbose=1)

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

Apprentissage itératif

En règle générale, lors de l'exécution en profondeur, l'apprentissage itératif est effectué et l'apprentissage est répété avec les mêmes données d'entraînement. Le nombre de formations est appelé le numéro d'époque, qui est également un hyper paramètre.

Définir un grand nombre d'époques ne signifie pas que la précision du modèle continuera à s'améliorer.

Si vous ne définissez pas un nombre d'époques approprié, la précision n'augmentera pas au milieu. Non seulement cela, mais en essayant de minimiser la fonction de perte en répétant l'apprentissage Cela peut provoquer un surapprentissage.

Par conséquent, il est également important de définir un nombre approprié d'époques et d'arrêter l'apprentissage en temps opportun.

#Nombre d'époques
global epochs
    epochs = #Paramètres

Voici un exemple de code.

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)[:1500]
X_test = X_test.reshape(X_test.shape[0], 784)[:6000]
y_train = to_categorical(y_train)[:1500]
y_test = to_categorical(y_test)[:6000]

model = Sequential()
model.add(Dense(256, input_dim=784))
model.add(Activation("sigmoid"))
model.add(Dense(128))
model.add(Activation("sigmoid"))
#Je n'utiliserai pas Dropout cette fois.
#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"])

def funcA():
    global epochs
    epochs = 5

def funcB():
    global epochs
    epochs = 10

def funcC():
    global epochs
    epochs = 60

#Choisissez l'une des trois et commentez les deux autres lignes pour déterminer le nombre d'époques.
#---------------------------
#funcA()
funcB()
#funcC()
#---------------------------

history = model.fit(X_train, y_train, batch_size=32, epochs=epochs, 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()

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