Comment choisir les fonctions de perte lors de la formation des réseaux de neurones d'apprentissage profond

Les réseaux neuronaux d'apprentissage profond sont entraînés à l'aide de l'algorithme d'optimisation de descente de gradient stochastique.

Dans le cadre de l'algorithme d'optimisation, l'erreur relative à l'état actuel du modèle doit être estimée à plusieurs reprises. Cela nécessite le choix d'une fonction d'erreur, classiquement appelée fonction de perte, qui peut être utilisée pour estimer la perte du modèle afin que les poids puissent être mis à jour pour réduire la perte lors de la prochaine évaluation.

Les modèles de réseaux neuronaux apprennent une cartographie des entrées aux sorties à partir d'exemples et le choix de la fonction de perte doit correspondre au cadrage du problème de modélisation prédictive spécifique, tel que la classification ou la régression. De plus, la configuration de la couche de sortie doit également être adaptée à la fonction de perte choisie.

Dans ce tutoriel, vous découvrirez comment choisir une fonction de perte pour votre réseau neuronal d'apprentissage profond pour un problème de modélisation prédictive donné.

Après avoir terminé ce tutoriel, vous saurez :

Comment configurer un modèle pour l'erreur quadratique moyenne et des variantes pour les problèmes de régression.
Comment configurer un modèle pour les fonctions d'entropie croisée et de perte de charnière pour la classification binaire.
Comment configurer un modèle pour les fonctions d'entropie croisée et de perte de divergence KL pour la classification multi-classe.

Démarrez votre projet avec mon nouveau livre Better Deep Learning, comprenant des tutoriels étape par étape et les fichiers code source Python pour tous les exemples .

Commençons.

Mise à jour d'octobre 2019 : mise à jour pour Keras 2.3 et TensorFlow 2.0.
Mise à jour de janvier 2020 : mise à jour pour les modifications apportées à l'API scikit-learn v0.22

Présentation du didacticiel

Ce didacticiel est divisé en trois parties : ils sont:

Fonctions de perte de régression
1. Perte d'erreur quadratique moyenne
2. Perte d'erreur logarithmique quadratique moyenne
3. Perte d'erreur absolue moyenne
Fonctions de perte de classification binaire
1. Entropie croisée binaire
2. Perte de charnière
3. Perte de charnière carrée
Fonctions de perte de classification multiclasse
1. Perte d'entropie croisée multiclasse
2. Perte d'entropie croisée multiclasse clairsemée
3. Perte de divergence Kullback Leibler

Nous nous concentrerons sur la manière de choisir et de mettre en œuvre différentes fonctions de perte.

Pour plus de théorie sur les fonctions de perte, voir l'article :

Fonctions de perte et de perte pour la formation des réseaux de neurones d'apprentissage profond

Fonctions de perte de régression

Un problème de modélisation prédictive de régression consiste à prédire une quantité à valeur réelle.

Dans cette section, nous étudierons les fonctions de perte appropriées aux problèmes de modélisation prédictive de régression.

Comme contexte pour cette enquête, nous utiliserons un générateur de problèmes de régression standard fourni par la bibliothèque scikit-learn dans la fonction make_regression(). Cette fonction générera des exemples à partir d'un simple problème de régression avec un nombre donné de variables d'entrée, de bruit statistique et d'autres propriétés.

Nous utiliserons cette fonction pour définir un problème comportant 20 fonctionnalités d’entrée ; 10 des fonctionnalités seront significatives et 10 ne seront pas pertinentes. Au total, 1 000 exemples seront générés aléatoirement. Le générateur de nombres pseudo-aléatoires sera corrigé pour garantir que nous obtenons les mêmes 1 000 exemples à chaque fois que le code est exécuté.

# generate regression dataset
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=1)

Les réseaux de neurones fonctionnent généralement mieux lorsque les variables d'entrée et de sortie à valeur réelle doivent être mises à l'échelle dans une plage raisonnable. Pour ce problème, chacune des variables d'entrée et la variable cible ont une distribution gaussienne ; par conséquent, la normalisation des données dans ce cas est souhaitable.

Nous pouvons y parvenir en utilisant la classe de transformateur StandardScaler également de la bibliothèque scikit-learn. Sur un problème réel, nous préparerions le scaler sur l'ensemble de données d'entraînement et l'appliquerions aux ensembles d'entraînement et de test, mais pour plus de simplicité, nous mettrons à l'échelle toutes les données ensemble avant de les diviser en ensembles d'entraînement et de test.

# standardize dataset
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(y.reshape(len(y),1))[:,0]

Une fois mises à l'échelle, les données seront réparties uniformément en ensembles d'entraînement et de test.

# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]

Un petit modèle de Perceptron Multicouche (MLP) sera défini pour résoudre ce problème et fournir la base pour explorer différentes fonctions de perte.

Le modèle attendra 20 fonctionnalités en entrée telles que définies par le problème. Le modèle aura une couche cachée avec 25 nœuds et utilisera la fonction d'activation linéaire rectifiée (ReLU). La couche de sortie aura 1 nœud, étant donné la valeur réelle à prédire, et utilisera la fonction d'activation linéaire.

# define model
model = Sequential()
model.add(Dense(25, input_dim=20, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='linear'))

Le modèle sera équipé d'une descente de gradient stochastique avec un taux d'apprentissage de 0,01 et un élan de 0,9, deux valeurs par défaut raisonnables.

La formation sera effectuée pendant 100 époques et l'ensemble de tests sera évalué à la fin de chaque époque afin que nous puissions tracer des courbes d'apprentissage à la fin de l'exécution.

opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='...', optimizer=opt)
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)

Maintenant que nous avons la base d'un problème et d'un modèle, nous pouvons examiner trois fonctions de perte courantes appropriées pour un problème de modélisation prédictive de régression.

Bien qu'un MLP soit utilisé dans ces exemples, les mêmes fonctions de perte peuvent être utilisées lors de la formation des modèles CNN et RNN pour la régression.

Perte d'erreur quadratique moyenne

La perte d'erreur quadratique moyenne, ou MSE, est la perte par défaut à utiliser pour les problèmes de régression.

Mathématiquement, il s'agit de la fonction de perte préférée dans le cadre d'inférence du maximum de vraisemblance si la distribution de la variable cible est gaussienne. C'est la fonction de perte qui doit être évaluée en premier et modifiée uniquement si vous avez une bonne raison.

L’erreur quadratique moyenne est calculée comme la moyenne des différences quadratiques entre les valeurs prédites et réelles. Le résultat est toujours positif quel que soit le signe des valeurs prédites et réelles et une valeur parfaite est 0,0. La mise au carré signifie que les erreurs plus importantes entraînent plus d'erreurs que les erreurs plus petites, ce qui signifie que le modèle est puni pour avoir commis des erreurs plus importantes.

La fonction de perte d'erreur quadratique moyenne peut être utilisée dans Keras en spécifiant « mse » ou « mean_squared_error » comme fonction de perte lors de la compilation du modèle.

model.compile(loss='mean_squared_error')

Il est recommandé que la couche de sortie ait un nœud pour la variable cible et que la fonction d'activation linéaire soit utilisée.

model.add(Dense(1, activation='linear'))

Un exemple complet de démonstration d'un MLP sur le problème de régression décrit est répertorié ci-dessous.

# mlp for regression with mse loss function
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
# generate regression dataset
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=1)
# standardize dataset
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(y.reshape(len(y),1))[:,0]
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(25, input_dim=20, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='linear'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='mean_squared_error', optimizer=opt)
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
train_mse = model.evaluate(trainX, trainy, verbose=0)
test_mse = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_mse, test_mse))
# plot loss during training
pyplot.title('Loss / Mean Squared Error')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord l’erreur quadratique moyenne du modèle sur les ensembles de données d’entraînement et de test.

Remarque : Vos résultats peuvent varier en raison de la nature stochastique de l'algorithme ou de la procédure d'évaluation, ou des différences de précision numérique. Pensez à exécuter l’exemple plusieurs fois et comparez le résultat moyen.

Dans ce cas, nous pouvons voir que le modèle a appris le problème en atteignant zéro erreur, au moins à trois décimales près.

Train: 0.000, Test: 0.001

Un tracé linéaire est également créé montrant la perte d'erreur quadratique moyenne au cours des époques d'entraînement pour les ensembles de train (bleu) et de test (orange).

Nous pouvons voir que le modèle a convergé assez rapidement et que les performances d’entraînement et de test sont restées équivalentes. Les performances et le comportement de convergence du modèle suggèrent que l'erreur quadratique moyenne convient bien à un réseau neuronal apprenant ce problème.

Perte d'erreur logarithmique quadratique moyenne

Il peut y avoir des problèmes de régression dans lesquels la valeur cible présente un écart de valeurs et, lorsque vous prédisez une valeur élevée, vous ne souhaiterez peut-être pas punir un modèle aussi lourdement que l'erreur quadratique moyenne.

Au lieu de cela, vous pouvez d’abord calculer le logarithme népérien de chacune des valeurs prédites, puis calculer l’erreur quadratique moyenne. C’est ce qu’on appelle la perte d’erreur logarithmique quadratique moyenne, ou MSLE en abrégé.

Cela a pour effet d’atténuer l’effet punitif des grandes différences dans les grandes valeurs prédites.

En tant que mesure de perte, elle peut être plus appropriée lorsque le modèle prédit directement des quantités non mises à l'échelle. Néanmoins, nous pouvons démontrer cette fonction de perte en utilisant notre simple problème de régression.

Le modèle peut être mis à jour pour utiliser la fonction de perte « mean_squared_logarithmic_error » et conserver la même configuration pour la couche de sortie. Nous suivrons également l'erreur quadratique moyenne en tant que métrique lors de l'ajustement du modèle afin de pouvoir l'utiliser comme mesure de performance et tracer la courbe d'apprentissage.

model.compile(loss='mean_squared_logarithmic_error', optimizer=opt, metrics=['mse'])

L'exemple complet d'utilisation de la fonction de perte MSLE est répertorié ci-dessous.

# mlp for regression with msle loss function
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
# generate regression dataset
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=1)
# standardize dataset
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(y.reshape(len(y),1))[:,0]
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(25, input_dim=20, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='linear'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='mean_squared_logarithmic_error', optimizer=opt, metrics=['mse'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
_, train_mse = model.evaluate(trainX, trainy, verbose=0)
_, test_mse = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_mse, test_mse))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot mse during training
pyplot.subplot(212)
pyplot.title('Mean Squared Error')
pyplot.plot(history.history['mean_squared_error'], label='train')
pyplot.plot(history.history['val_mean_squared_error'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord l’erreur quadratique moyenne du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons voir que le modèle a abouti à un MSE légèrement pire sur l'ensemble de données de formation et de test. Cela n'est peut-être pas adapté à ce problème car la distribution de la variable cible est une gaussienne standard.

Train: 0.165, Test: 0.184

Un tracé linéaire est également créé montrant la perte d'erreur logarithmique quadratique moyenne au cours des époques d'entraînement pour les ensembles d'entraînement (bleu) et de test (orange) (en haut), ainsi qu'un tracé similaire pour l'erreur quadratique moyenne (en bas).

Nous pouvons voir que le MSLE a bien convergé sur l’algorithme des 100 époques ; il semble que le MSE montre des signes de surajustement du problème, diminuant rapidement et commençant à augmenter à partir de l'époque 20.

Perte d'erreur absolue moyenne

Sur certains problèmes de régression, la distribution de la variable cible peut être principalement gaussienne, mais peut comporter des valeurs aberrantes, par ex. valeurs grandes ou petites éloignées de la valeur moyenne.

La perte d’erreur moyenne absolue, ou MAE, est une fonction de perte appropriée dans ce cas car elle est plus robuste aux valeurs aberrantes. Elle est calculée comme la moyenne de la différence absolue entre les valeurs réelles et prédites.

Le modèle peut être mis à jour pour utiliser la fonction de perte « mean_absolute_error » et conserver la même configuration pour la couche de sortie.

model.compile(loss='mean_absolute_error', optimizer=opt, metrics=['mse'])

L'exemple complet utilisant l'erreur absolue moyenne comme fonction de perte sur le problème du test de régression est répertorié ci-dessous.

# mlp for regression with mae loss function
from sklearn.datasets import make_regression
from sklearn.preprocessing import StandardScaler
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
# generate regression dataset
X, y = make_regression(n_samples=1000, n_features=20, noise=0.1, random_state=1)
# standardize dataset
X = StandardScaler().fit_transform(X)
y = StandardScaler().fit_transform(y.reshape(len(y),1))[:,0]
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(25, input_dim=20, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='linear'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='mean_absolute_error', optimizer=opt, metrics=['mse'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
_, train_mse = model.evaluate(trainX, trainy, verbose=0)
_, test_mse = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_mse, test_mse))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot mse during training
pyplot.subplot(212)
pyplot.title('Mean Squared Error')
pyplot.plot(history.history['mean_squared_error'], label='train')
pyplot.plot(history.history['val_mean_squared_error'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord l’erreur quadratique moyenne du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons voir que le modèle a appris le problème, atteignant une erreur proche de zéro, au moins à trois décimales.

Train: 0.002, Test: 0.002

Un tracé linéaire est également créé montrant la perte d'erreur absolue moyenne au cours des époques d'entraînement pour les ensembles d'entraînement (bleu) et de test (orange) (en haut), ainsi qu'un tracé similaire pour l'erreur quadratique moyenne (en bas).

Dans ce cas, nous pouvons voir que le MAE converge mais montre un parcours cahoteux, bien que la dynamique du MSE ne semble pas grandement affectée. Nous savons que la variable cible est une gaussienne standard sans valeurs aberrantes importantes, donc MAE ne conviendrait pas dans ce cas.

Cela pourrait être plus approprié pour ce problème si nous ne mettions pas d'abord à l'échelle la variable cible.

Fonctions de perte de classification binaire

La classification binaire concerne les problèmes de modélisation prédictive dans lesquels les exemples se voient attribuer l'une des deux étiquettes suivantes.

Le problème est souvent formulé comme prédisant une valeur de 0 ou 1 pour la première ou la deuxième classe et est souvent mis en œuvre comme prédisant la probabilité que l'exemple appartienne à la valeur de classe 1.

Dans cette section, nous étudierons les fonctions de perte appropriées aux problèmes de modélisation prédictive de classification binaire.

Nous générerons des exemples du problème du test des cercles dans scikit-learn comme base de cette enquête. Le problème des cercles implique des échantillons tirés de deux cercles concentriques sur un plan bidimensionnel, où les points du cercle extérieur appartiennent à la classe 0 et les points du cercle intérieur appartiennent à la classe 1. Du bruit statistique est ajouté aux échantillons pour ajouter de l'ambiguïté et rendre le problème est plus difficile à apprendre.

Nous générerons 1 000 exemples et ajouterons 10 % de bruit statistique. Le générateur de nombres pseudo-aléatoires sera doté de la même valeur pour garantir que nous obtenons toujours les mêmes 1 000 exemples.

# generate circles
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1)

Nous pouvons créer un nuage de points de l'ensemble de données pour avoir une idée du problème que nous modélisons. L’exemple complet est répertorié ci-dessous.

# scatter plot of the circles dataset with points colored by class
from sklearn.datasets import make_circles
from numpy import where
from matplotlib import pyplot
# generate circles
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1)
# select indices of points with each class label
for i in range(2):
	samples_ix = where(y == i)
	pyplot.scatter(X[samples_ix, 0], X[samples_ix, 1], label=str(i))
pyplot.legend()
pyplot.show()

L'exécution de l'exemple crée un nuage de points des exemples, où les variables d'entrée définissent l'emplacement du point et la valeur de classe définit la couleur, avec la classe 0 bleue et la classe 1 orange.

Les points sont déjà raisonnablement échelonnés autour de 0, presque en [-1,1]. Nous ne les redimensionnerons pas dans ce cas.

L'ensemble de données est réparti uniformément pour les ensembles d'entraînement et de test.

# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]

Un modèle MLP simple peut être défini pour résoudre ce problème qui attend deux entrées pour les deux entités de l'ensemble de données, une couche cachée avec 50 nœuds, une fonction d'activation linéaire rectifiée et une couche de sortie qui devra être configurée pour le choix de la perte. fonction.

# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='...'))

Le modèle sera ajusté en utilisant une descente de gradient stochastique avec un taux d'apprentissage par défaut raisonnable de 0,01 et une dynamique de 0,9.

opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='...', optimizer=opt, metrics=['accuracy'])

Nous ajusterons le modèle pour 200 époques de formation et évaluerons les performances du modèle par rapport à la perte et à la précision à la fin de chaque époque afin de pouvoir tracer des courbes d'apprentissage.

# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)

Maintenant que nous avons la base d'un problème et d'un modèle, nous pouvons examiner trois fonctions de perte courantes appropriées pour un problème de modélisation prédictive de classification binaire.

Bien qu'un MLP soit utilisé dans ces exemples, les mêmes fonctions de perte peuvent être utilisées lors de la formation des modèles CNN et RNN pour la classification binaire.

Perte d'entropie croisée binaire

L'entropie croisée est la fonction de perte par défaut à utiliser pour les problèmes de classification binaire.

Il est destiné à être utilisé avec une classification binaire où les valeurs cibles se trouvent dans l'ensemble {0, 1}.

Mathématiquement, il s'agit de la fonction de perte préférée dans le cadre d'inférence du maximum de vraisemblance. C'est la fonction de perte qui doit être évaluée en premier et modifiée uniquement si vous avez une bonne raison.

L'entropie croisée calculera un score qui résume la différence moyenne entre les distributions de probabilité réelle et prédite pour prédire la classe 1. Le score est minimisé et une valeur d'entropie croisée parfaite est de 0.

L'entropie croisée peut être spécifiée comme fonction de perte dans Keras en spécifiant « binary_crossentropy » lors de la compilation du modèle.

model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])

La fonction nécessite que la couche de sortie soit configurée avec un seul nœud et une activation « sigmoïde » afin de prédire la probabilité pour la classe 1.

model.add(Dense(1, activation='sigmoid'))

L'exemple complet d'un MLP avec perte d'entropie croisée pour le problème de classification binaire à deux cercles est répertorié ci-dessous.

# mlp for the circles problem with cross entropy loss
from sklearn.datasets import make_circles
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
# generate 2d classification dataset
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='sigmoid'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons voir que le modèle a assez bien appris le problème, atteignant une précision d'environ 83 % sur l'ensemble de données d'entraînement et d'environ 85 % sur l'ensemble de données de test. Les scores sont raisonnablement proches, ce qui suggère que le modèle n’est probablement ni sur- ni sous-adapté.

Train: 0.836, Test: 0.852

Une figure est également créée montrant deux tracés linéaires, le tracé du haut avec la perte d'entropie croisée au fil des époques pour l'ensemble de données de train (bleu) et de test (orange), et le tracé du bas montrant la précision de la classification au fil des époques.

L’intrigue montre que le processus de formation a bien convergé. Le tracé de la perte est fluide, étant donné la nature continue de l'erreur entre les distributions de probabilité, tandis que le tracé linéaire de la précision montre des irrégularités. Les exemples donnés dans le train et l'ensemble de test ne peuvent finalement être prédits que comme étant corrects ou incorrects, fournissant ainsi un retour d'information moins granulaire. sur les performances.

Perte de charnière

Une alternative à l'entropie croisée pour les problèmes de classification binaire est la fonction de perte de charnière, principalement développée pour être utilisée avec les modèles SVM (Support Vector Machine).

Il est destiné à être utilisé avec une classification binaire où les valeurs cibles se trouvent dans l'ensemble {-1, 1}.

La fonction de perte de charnière encourage les exemples à avoir le signe correct, attribuant plus d'erreurs lorsqu'il existe une différence de signe entre les valeurs de classe réelles et prédites.

Les rapports de performances avec la perte de charnière sont mitigés, entraînant parfois de meilleures performances que l'entropie croisée sur les problèmes de classification binaire.

Tout d'abord, la variable cible doit être modifiée pour avoir des valeurs dans l'ensemble {-1, 1}.

# change y from {0,1} to {-1,1}
y[where(y == 0)] = -1

La fonction de perte de charnière peut alors être spécifiée comme « hinge » dans la fonction de compilation.

model.compile(loss='hinge', optimizer=opt, metrics=['accuracy'])

Enfin, la couche de sortie du réseau doit être configurée pour avoir un seul nœud avec une fonction d'activation tangente hyperbolique capable de produire une valeur unique dans la plage [-1, 1].

model.add(Dense(1, activation='tanh'))

L'exemple complet d'un MLP avec une fonction de perte de charnière pour le problème de classification binaire à deux cercles est répertorié ci-dessous.

# mlp for the circles problem with hinge loss
from sklearn.datasets import make_circles
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
from numpy import where
# generate 2d classification dataset
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1)
# change y from {0,1} to {-1,1}
y[where(y == 0)] = -1
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='tanh'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='hinge', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons constater des performances légèrement moins bonnes que l'utilisation de l'entropie croisée, avec la configuration du modèle choisie avec une précision inférieure à 80 % sur le train et les ensembles de test.

Train: 0.792, Test: 0.740

Une figure est également créée montrant deux tracés linéaires, le tracé du haut avec la perte de charnière au fil des époques pour l'ensemble de données de train (bleu) et de test (orange), et le tracé du bas montrant la précision de la classification au fil des époques.

Le graphique de la perte de charnière montre que le modèle a convergé et présente une perte raisonnable sur les deux ensembles de données. Le graphique de l’exactitude de la classification montre également des signes de convergence, quoique à un niveau de compétence inférieur à celui qui pourrait être souhaitable pour ce problème.

Perte de charnière carrée

La fonction de perte charnière a de nombreuses extensions, faisant souvent l'objet d'investigations avec les modèles SVM.

Une extension populaire est appelée perte de charnière carrée qui calcule simplement le carré de la perte de charnière de score. Cela a pour effet de lisser la surface de la fonction d’erreur et de la rendre numériquement plus facile à utiliser.

Si l’utilisation d’une perte de charnière entraîne de meilleures performances sur un problème de classification binaire donné, il est probable qu’une perte de charnière carrée soit appropriée.

Comme pour l'utilisation de la fonction de perte de charnière, la variable cible doit être modifiée pour avoir des valeurs dans l'ensemble {-1, 1}.

# change y from {0,1} to {-1,1}
y[where(y == 0)] = -1

La perte de charnière carrée peut être spécifiée comme « squared_hinge » dans la fonction compile() lors de la définition du modèle.

model.compile(loss='squared_hinge', optimizer=opt, metrics=['accuracy'])

Et enfin, la couche de sortie doit utiliser un seul nœud avec une fonction d'activation tangente hyperbolique capable de générer des valeurs continues dans la plage [-1, 1].

model.add(Dense(1, activation='tanh'))

L'exemple complet d'un MLP avec la fonction de perte de charnière carrée sur le problème de classification binaire à deux cercles est répertorié ci-dessous.

# mlp for the circles problem with squared hinge loss
from sklearn.datasets import make_circles
from keras.models import Sequential
from keras.layers import Dense
from keras.optimizers import SGD
from matplotlib import pyplot
from numpy import where
# generate 2d classification dataset
X, y = make_circles(n_samples=1000, noise=0.1, random_state=1)
# change y from {0,1} to {-1,1}
y[where(y == 0)] = -1
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(1, activation='tanh'))
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='squared_hinge', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=200, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur les ensembles de données d’entraînement et de test.

Dans ce cas, nous pouvons voir que pour ce problème et la configuration du modèle choisi, la perte quadratique charnière peut ne pas être appropriée, ce qui entraîne une précision de classification inférieure à 70 % sur le train et les ensembles de test.

Train: 0.682, Test: 0.646

Une figure est également créée montrant deux tracés linéaires, le tracé du haut avec la perte de charnière carrée au fil des époques pour l'ensemble de données de train (bleu) et de test (orange), et le tracé du bas montrant la précision de la classification au fil des époques.

Le graphique des pertes montre qu'en effet, le modèle a convergé, mais la forme de la surface d'erreur n'est pas aussi lisse que celle d'autres fonctions de perte où de petites modifications des poids entraînent de grandes modifications de la perte.

Fonctions de perte de classification multiclasse

La classification multi-classes concerne les problèmes de modélisation prédictive dans lesquels les exemples se voient attribuer une classe parmi plus de deux.

Le problème est souvent formulé comme la prédiction d'une valeur entière, où chaque classe se voit attribuer une valeur entière unique comprise entre 0 et (num_classes – 1). Le problème est souvent implémenté en prédisant la probabilité que l'exemple appartienne à chaque classe connue.

Dans cette section, nous étudierons les fonctions de perte appropriées aux problèmes de modélisation prédictive de classification multiclasse.

Nous utiliserons le problème des blobs comme base d’enquête. La fonction make_blobs() fournie par scikit-learn fournit un moyen de générer des exemples étant donné un nombre spécifié de classes et de fonctionnalités d'entrée. Nous utiliserons cette fonction pour générer 1 000 exemples pour un problème de classification à 3 classes avec 2 variables d'entrée. Le générateur de nombres pseudo-aléatoires sera généré de manière cohérente afin que les mêmes 1 000 exemples soient générés à chaque exécution du code.

# generate dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)

Les deux variables d'entrée peuvent être considérées comme des coordonnées x et y pour des points sur un plan bidimensionnel.

L'exemple ci-dessous crée un nuage de points de l'ensemble des points de coloration de l'ensemble de données en fonction de leur appartenance à une classe.

# scatter plot of blobs dataset
from sklearn.datasets import make_blobs
from numpy import where
from matplotlib import pyplot
# generate dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# select indices of points with each class label
for i in range(3):
	samples_ix = where(y == i)
	pyplot.scatter(X[samples_ix, 0], X[samples_ix, 1])
pyplot.show()

L'exécution de l'exemple crée un nuage de points montrant les 1 000 exemples de l'ensemble de données avec des exemples appartenant aux classes 0, 1 et 2, respectivement bleu, orange et vert.

Les caractéristiques d'entrée sont gaussiennes et pourraient bénéficier d'une standardisation ; néanmoins, nous conserverons les valeurs non mises à l'échelle dans cet exemple par souci de concision.

L'ensemble de données sera réparti uniformément entre les ensembles d'entraînement et de test.

# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]

Un petit modèle MLP sera utilisé comme base pour explorer les fonctions de perte.

Le modèle attend deux variables d'entrée, comporte 50 nœuds dans la couche cachée et la fonction d'activation linéaire rectifiée, et une couche de sortie qui doit être personnalisée en fonction de la sélection de la fonction de perte.

# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(..., activation='...'))

Le modèle est ajusté en utilisant une descente de gradient stochastique avec un taux d'apprentissage par défaut raisonnable de 0,01 et une dynamique de 0,9.

# compile model
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='...', optimizer=opt, metrics=['accuracy'])

Le modèle sera adapté pendant 100 époques sur l'ensemble de données d'entraînement et l'ensemble de données de test sera utilisé comme ensemble de données de validation, nous permettant d'évaluer à la fois la perte et la précision de la classification sur les ensembles de train et de test à la fin de chaque époque d'entraînement et de tracer des courbes d'apprentissage. .

# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)

Maintenant que nous avons la base d'un problème et d'un modèle, nous pouvons examiner l'évaluation de trois fonctions de perte courantes qui sont appropriées pour un problème de modélisation prédictive de classification multiclasse.

Bien qu'un MLP soit utilisé dans ces exemples, les mêmes fonctions de perte peuvent être utilisées lors de la formation des modèles CNN et RNN pour la classification multi-classe.

Perte d'entropie croisée multiclasse

L'entropie croisée est la fonction de perte par défaut à utiliser pour les problèmes de classification multi-classes.

Dans ce cas, il est destiné à être utilisé avec une classification multi-classes où les valeurs cibles se trouvent dans l'ensemble {0, 1, 3,…, n}, où chaque classe se voit attribuer une valeur entière unique.

L'entropie croisée calculera un score qui résume la différence moyenne entre les distributions de probabilité réelle et prédite pour toutes les classes du problème. Le score est minimisé et une valeur d'entropie croisée parfaite est de 0.

L'entropie croisée peut être spécifiée comme fonction de perte dans Keras en spécifiant « categorical_crossentropy » lors de la compilation du modèle.

model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])

La fonction nécessite que la couche de sortie soit configurée avec n nœuds (un pour chaque classe), dans ce cas trois nœuds, et une activation 'softmax' afin de prédire la probabilité pour chaque classe.

model.add(Dense(3, activation='softmax'))

À son tour, cela signifie que la variable cible doit être une variable codée à chaud.

Cela permet de garantir que chaque exemple a une probabilité attendue de 1,0 pour la valeur réelle de la classe et une probabilité attendue de 0,0 pour toutes les autres valeurs de classe. Ceci peut être réalisé en utilisant la fonction Keras to_categorical().

# one hot encode output variable
y = to_categorical(y)

L'exemple complet d'un MLP avec perte d'entropie croisée pour le problème de classification des blobs multi-classes est répertorié ci-dessous.

# mlp for the blobs multi-class classification problem with cross-entropy loss
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
from matplotlib import pyplot
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# one hot encode output variable
y = to_categorical(y)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons constater que le modèle fonctionne bien, atteignant une précision de classification d'environ 84 % sur l'ensemble de données d'entraînement et d'environ 82 % sur l'ensemble de données de test.

Train: 0.840, Test: 0.822

Dans ce cas, le graphique montre que le modèle semble avoir convergé. Les tracés linéaires pour l’entropie croisée et la précision montrent tous deux un bon comportement de convergence, bien que quelque peu irrégulier. Le modèle peut être bien configuré étant donné aucun signe de sur-ajustement ou de sous-ajustement. Le taux d'apprentissage ou la taille du lot peuvent être ajustés pour égaliser la fluidité de la convergence dans ce cas.

Perte d'entropie croisée multiclasse clairsemée

Une cause possible de frustration lors de l'utilisation de l'entropie croisée avec des problèmes de classification avec un grand nombre d'étiquettes est le processus de codage à chaud.

Par exemple, la prédiction de mots dans un vocabulaire peut comporter des dizaines ou des centaines de milliers de catégories, une pour chaque étiquette. Cela peut signifier que l'élément cible de chaque exemple d'entraînement peut nécessiter un vecteur codé à chaud avec des dizaines ou des centaines de milliers de valeurs nulles, nécessitant une mémoire importante.

L'entropie croisée clairsemée résout ce problème en effectuant le même calcul d'erreur d'entropie croisée, sans exiger que la variable cible soit codée à chaud avant l'entraînement.

L'entropie croisée clairsemée peut être utilisée dans les keras pour la classification multi-classes en utilisant 'sparse_categorical_crossentropy' lors de l'appel de la fonction compile().

model.compile(loss='sparse_categorical_crossentropy', optimizer=opt, metrics=['accuracy'])

model.add(Dense(3, activation='softmax'))

Aucun codage à chaud de la variable cible n'est requis, un avantage de cette fonction de perte.

L'exemple complet de formation d'un MLP avec une entropie croisée clairsemée sur le problème de classification multi-classes des blobs est répertorié ci-dessous.

# mlp for the blobs multi-class classification problem with sparse cross-entropy loss
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from matplotlib import pyplot
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='sparse_categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous pouvons voir que le modèle atteint de bonnes performances sur le problème. En fait, si vous répétez l'expérience plusieurs fois, les performances moyennes de l'entropie croisée clairsemée et non clairsemée devraient être comparables.

Train: 0.832, Test: 0.818

Une figure est également créée montrant deux tracés linéaires, le tracé du haut avec la perte d'entropie croisée clairsemée au fil des époques pour l'ensemble de données de train (bleu) et de test (orange), et le tracé du bas montrant la précision de la classification au fil des époques.

Dans ce cas, le graphique montre une bonne convergence du modèle au cours de la formation en ce qui concerne la perte et la précision de la classification.

Perte de divergence Kullback Leibler

La divergence Kullback Leibler, ou divergence KL en abrégé, est une mesure de la façon dont une distribution de probabilité diffère d'une distribution de base.

Une perte de divergence KL de 0 suggère que les distributions sont identiques. En pratique, le comportement de KL Divergence est très similaire à l’entropie croisée. Il calcule la quantité d'informations perdues (en termes de bits) si la distribution de probabilité prédite est utilisée pour se rapprocher de la distribution de probabilité cible souhaitée.

En tant que telle, la fonction de perte de divergence KL est plus couramment utilisée lors de l'utilisation de modèles qui apprennent à se rapprocher d'une fonction plus complexe qu'une simple classification multi-classe, comme dans le cas d'un auto-encodeur utilisé pour apprendre une représentation de caractéristiques denses sous un modèle qui doit reconstruire l'entrée originale. Dans ce cas, la perte de divergence KL serait préférée. Néanmoins, il peut être utilisé pour la classification multi-classes, auquel cas il est fonctionnellement équivalent à l'entropie croisée multi-classes.

La perte de divergence KL peut être utilisée dans Keras en spécifiant « kullback_leibler_divergence » dans la fonction compile().

model.compile(loss='kullback_leibler_divergence', optimizer=opt, metrics=['accuracy'])

Comme pour l'entropie croisée, la couche de sortie est configurée avec n nœuds (un pour chaque classe), dans ce cas trois nœuds, et une activation 'softmax' afin pour prédire la probabilité pour chaque classe.

De plus, comme pour l'entropie croisée catégorielle, nous devons coder à chaud la variable cible pour avoir une probabilité attendue de 1,0 pour la valeur de classe et de 0,0 pour toutes les autres valeurs de classe.

# one hot encode output variable
y = to_categorical(y)

L'exemple complet de formation d'un MLP avec perte de divergence KL pour le problème de classification multi-classes de blobs est répertorié ci-dessous.

# mlp for the blobs multi-class classification problem with kl divergence loss
from sklearn.datasets import make_blobs
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import SGD
from keras.utils import to_categorical
from matplotlib import pyplot
# generate 2d classification dataset
X, y = make_blobs(n_samples=1000, centers=3, n_features=2, cluster_std=2, random_state=2)
# one hot encode output variable
y = to_categorical(y)
# split into train and test
n_train = 500
trainX, testX = X[:n_train, :], X[n_train:, :]
trainy, testy = y[:n_train], y[n_train:]
# define model
model = Sequential()
model.add(Dense(50, input_dim=2, activation='relu', kernel_initializer='he_uniform'))
model.add(Dense(3, activation='softmax'))
# compile model
opt = SGD(lr=0.01, momentum=0.9)
model.compile(loss='kullback_leibler_divergence', optimizer=opt, metrics=['accuracy'])
# fit model
history = model.fit(trainX, trainy, validation_data=(testX, testy), epochs=100, verbose=0)
# evaluate the model
_, train_acc = model.evaluate(trainX, trainy, verbose=0)
_, test_acc = model.evaluate(testX, testy, verbose=0)
print('Train: %.3f, Test: %.3f' % (train_acc, test_acc))
# plot loss during training
pyplot.subplot(211)
pyplot.title('Loss')
pyplot.plot(history.history['loss'], label='train')
pyplot.plot(history.history['val_loss'], label='test')
pyplot.legend()
# plot accuracy during training
pyplot.subplot(212)
pyplot.title('Accuracy')
pyplot.plot(history.history['accuracy'], label='train')
pyplot.plot(history.history['val_accuracy'], label='test')
pyplot.legend()
pyplot.show()

L’exécution de l’exemple imprime d’abord la précision de la classification du modèle sur l’ensemble de données d’entraînement et de test.

Dans ce cas, nous constatons des performances similaires à celles observées avec la perte d'entropie croisée, dans ce cas, une précision d'environ 82 % sur l'ensemble de données d'entraînement et de test.

Train: 0.822, Test: 0.822

Une figure est également créée montrant deux tracés linéaires, le tracé du haut avec la perte de divergence KL au fil des époques pour l'ensemble de données de train (bleu) et de test (orange), et le tracé du bas montrant la précision de la classification au fil des époques.

Dans ce cas, le graphique montre un bon comportement de convergence à la fois en termes de perte et de précision de classification. Il est très probable qu'une évaluation de l'entropie croisée aboutirait à un comportement presque identique étant donné les similitudes de la mesure.

Lectures complémentaires

Cette section fournit plus de ressources sur le sujet si vous souhaitez approfondir.

Messages

Fonctions de perte et de perte pour la formation des réseaux de neurones d'apprentissage profond

Papiers

Sur les fonctions de perte pour les réseaux de neurones profonds en classification, 2017.

API

API des fonctions de perte Keras
API des fonctions d'activation Keras
API sklearn.preprocessing.StandardScaler
API sklearn.datasets.make_regression
API sklearn.datasets.make_circles
API sklearn.datasets.make_blobs

Articles

Erreur quadratique moyenne, Wikipédia.
Erreur absolue moyenne, Wikipédia.
Entropie croisée, Wikipédia.
Perte de charnière, Wikipédia.
Divergence Kullback-Leibler, Wikipédia.
Fonctions de perte dans les réseaux de neurones, 2017.

Résumé

Dans ce didacticiel, vous avez découvert comment choisir une fonction de perte pour votre réseau neuronal d'apprentissage profond pour un problème de modélisation prédictive donné.

Concrètement, vous avez appris :

Comment configurer un modèle pour l'erreur quadratique moyenne et des variantes pour les problèmes de régression.
Comment configurer un modèle pour les fonctions d'entropie croisée et de perte de charnière pour la classification binaire.
Comment configurer un modèle pour les fonctions d'entropie croisée et de perte de divergence KL pour la classification multi-classe.

Avez-vous des questions ?
Posez vos questions dans les commentaires ci-dessous et je ferai de mon mieux pour y répondre.

Comment choisir les fonctions de perte lors de la formation des réseaux de neurones d'apprentissage profond

Présentation du didacticiel

Fonctions de perte de régression

Perte d'erreur quadratique moyenne

Perte d'erreur logarithmique quadratique moyenne

Perte d'erreur absolue moyenne

Fonctions de perte de classification binaire

Perte d'entropie croisée binaire

Perte de charnière

Perte de charnière carrée

Fonctions de perte de classification multiclasse

Perte d'entropie croisée multiclasse

Perte d'entropie croisée multiclasse clairsemée

Perte de divergence Kullback Leibler

Lectures complémentaires

Messages

Papiers

API

Articles

Résumé

Articles connexes