Comment évaluer les compétences des modèles d'apprentissage profond
Je vois souvent des praticiens exprimer leur confusion sur la manière d’évaluer un modèle d’apprentissage profond.
Cela ressort souvent clairement de questions telles que :
- Quelle graine aléatoire dois-je utiliser ?
- Ai-je besoin d’une graine aléatoire ?
- Pourquoi n’obtiens-je pas les mêmes résultats lors des exécutions suivantes ?
Dans cet article, vous découvrirez la procédure que vous pouvez utiliser pour évaluer les modèles d'apprentissage profond et la justification de leur utilisation.
Vous découvrirez également des statistiques connexes utiles que vous pouvez calculer pour présenter les compétences de votre modèle, telles que l'écart type, l'erreur type et les intervalles de confiance.
Démarrez votre projet avec mon nouveau livre Deep Learning With Python, comprenant des tutoriels étape par étape et les fichiers code source Python pour tous exemples.
Commençons.
L'erreur du débutant
Vous adaptez le modèle à vos données d'entraînement et l'évaluez sur l'ensemble de données de test, puis signalez la compétence.
Peut-être utilisez-vous la validation croisée k-fold pour évaluer le modèle, puis signalez les compétences du modèle.
C'est une erreur commise par les débutants.
Il semble que vous fassiez la bonne chose, mais il y a un problème clé que vous n’avez pas pris en compte :
Les modèles d'apprentissage profond sont stochastiques.
Les réseaux de neurones artificiels utilisent le caractère aléatoire tout en étant adaptés à un ensemble de données, comme des poids initiaux aléatoires et un brassage aléatoire des données au cours de chaque époque d'entraînement lors de la descente de gradient stochastique.
Cela signifie que chaque fois que le même modèle est adapté aux mêmes données, il peut donner des prédictions différentes et, par conséquent, avoir des compétences globales différentes.
Estimation des compétences du modèle
(Contrôle de la variance du modèle)
Nous n’avons pas toutes les données possibles ; si nous le faisions, nous n’aurions pas besoin de faire de prédictions.
Nous disposons d’un échantillon limité de données et, à partir de celui-ci, nous devons découvrir le meilleur modèle possible.
Utiliser une répartition Train-Test
Nous faisons cela en divisant les données en deux parties, en ajustant un modèle ou une configuration de modèle spécifique sur la première partie des données et en utilisant le modèle d'ajustement pour faire des prédictions sur le reste, puis en évaluant la compétence de ces prédictions. C'est ce qu'on appelle une répartition train-test et nous utilisons la compétence comme une estimation de la façon dont nous pensons que le modèle fonctionnera dans la pratique lorsqu'il fera des prédictions sur de nouvelles données.
Par exemple, voici un pseudocode pour évaluer un modèle à l’aide d’une répartition train-test :
train, test = split(data)
model = fit(train.X, train.y)
predictions = model.predict(test.X)
skill = compare(test.y, predictions)
Une répartition des tests d'entraînement est une bonne approche à utiliser si vous avez beaucoup de données ou un modèle très lent à entraîner, mais le score de compétence résultant pour le modèle sera bruyant en raison du caractère aléatoire des données (variance du modèle). .
Cela signifie que le même modèle adapté à différentes données donnera des scores de compétence de modèle différents.
Utiliser la validation croisée k-Fold
Nous pouvons souvent resserrer cela et obtenir des estimations plus précises de la compétence du modèle en utilisant des techniques telles que la validation croisée k-fold. Il s'agit d'une technique qui divise systématiquement les données disponibles en k plis, ajuste le modèle sur k-1 plis, l'évalue sur le pli retenu et répète ce processus pour chaque pli.
Il en résulte k modèles différents comportant k ensembles de prédictions différents et, par conséquent, k scores de compétences différents.
Par exemple, voici un pseudocode pour évaluer un modèle à l’aide d’une validation croisée k-fold :
scores = list()
for i in k:
train, test = split_old(data, i)
model = fit(train.X, train.y)
predictions = model.predict(test.X)
skill = compare(test.y, predictions)
scores.append(skill)
Une population de scores de compétences est plus utile car nous pouvons prendre la moyenne et rapporter la performance moyenne attendue du modèle, qui est probablement plus proche de la performance réelle du modèle dans la pratique. Par exemple:
mean_skill = sum(scores) / count(scores)
Nous pouvons également calculer un écart type en utilisant la moyenne_skill pour avoir une idée de l'écart moyen des scores autour de la moyenne_skill :
standard_deviation = sqrt(1/count(scores) * sum( (score - mean_skill)^2 ))
Estimation des compétences d'un modèle stochastique
(Contrôle de la stabilité du modèle)
Les modèles stochastiques, comme les réseaux de neurones profonds, ajoutent une source supplémentaire de hasard.
Ce caractère aléatoire supplémentaire donne au modèle plus de flexibilité lors de l'apprentissage, mais peut rendre le modèle moins stable (par exemple, des résultats différents lorsque le même modèle est entraîné sur les mêmes données).
Ceci est différent de la variance du modèle qui donne des résultats différents lorsque le même modèle est formé sur des données différentes.
Pour obtenir une estimation robuste de la compétence d’un modèle stochastique, nous devons prendre en compte cette source supplémentaire de variance ; nous devons le contrôler.
Réparer la graine aléatoire
Une solution consiste à utiliser le même caractère aléatoire à chaque fois que le modèle est ajusté. Nous pouvons le faire en corrigeant la graine de nombres aléatoires utilisée par le système, puis en évaluant ou en ajustant le modèle. Par exemple:
seed(1)
scores = list()
for i in k:
train, test = split_old(data, i)
model = fit(train.X, train.y)
predictions = model.predict(test.X)
skill = compare(test.y, predictions)
scores.append(skill)
C'est idéal pour les didacticiels et les démonstrations lorsque le même résultat est nécessaire à chaque fois que votre code est exécuté.
Ceci est fragile et n’est pas recommandé pour évaluer les modèles.
Voir le message :
- Adoptez le caractère aléatoire dans l’apprentissage automatique
- Comment obtenir des résultats reproductibles avec Keras
Répéter les expériences d'évaluation
Une approche plus robuste consiste à répéter plusieurs fois l’expérience d’évaluation d’un modèle non stochastique.
Par exemple:
scores = list()
for i in repeats:
run_scores = list()
for j in k:
train, test = split_old(data, j)
model = fit(train.X, train.y)
predictions = model.predict(test.X)
skill = compare(test.y, predictions)
run_scores.append(skill)
scores.append(mean(run_scores))
Notez que nous calculons la moyenne de la compétence moyenne estimée du modèle, ce qu'on appelle la moyenne générale.
C'est ma procédure recommandée pour estimer les compétences d'un modèle d'apprentissage profond.
Étant donné que les répétitions sont souvent >=30, nous pouvons facilement calculer l'erreur standard de la compétence moyenne du modèle, qui correspond à la mesure dans laquelle la moyenne estimée du score de compétence du modèle diffère de la compétence moyenne réelle inconnue du modèle (par exemple, à quel point la moyenne_skill peut être erronée)
standard_error = standard_deviation / sqrt(count(scores))
De plus, nous pouvons utiliser standard_error pour calculer un intervalle de confiance pour Mean_skill. Cela suppose que la distribution des résultats est gaussienne, ce que vous pouvez vérifier en regardant un histogramme, un tracé Q-Q ou en utilisant des tests statistiques sur les scores collectés.
Par exemple, l'intervalle de 95 % est de (1,96 * standard_error) autour de la compétence moyenne.
interval = standard_error * 1.96
lower_interval = mean_skill - interval
upper_interval = mean_skill + interval
Il existe d'autres méthodes, peut-être statistiquement plus robustes, pour calculer les intervalles de confiance que l'utilisation de l'erreur type de la moyenne générale, telles que :
- Calcul de l'intervalle de confiance de la proportion binomiale.
- Utiliser le bootstrap pour estimer un intervalle de confiance empirique.
Dans quelle mesure les réseaux de neurones sont-ils instables ?
Cela dépend de votre problème, du réseau et de sa configuration.
Je recommanderais d’effectuer une analyse de sensibilité pour le savoir.
Évaluez le même modèle sur les mêmes données plusieurs fois (30, 100 ou des milliers) et ne faites varier que la valeur de départ du générateur de nombres aléatoires.
Examinez ensuite la moyenne et l’écart type des scores de compétences produits. L'écart type (distance moyenne des scores par rapport au score moyen) vous donnera une idée de l'instabilité de votre modèle.
Combien de répétitions ?
Je recommanderais au moins 30, peut-être 100, voire des milliers, limités uniquement par votre temps et vos ressources informatiques, et par des rendements décroissants (par exemple, erreur standard sur la moyenne_skill).
De manière plus rigoureuse, je recommanderais une expérience qui examine l'impact sur les compétences estimées du modèle par rapport au nombre de répétitions et au calcul de l'erreur type (dans quelle mesure la performance moyenne estimée diffère de la véritable moyenne sous-jacente de la population).
Lectures complémentaires
- Adoptez le caractère aléatoire dans l’apprentissage automatique
- Comment former un modèle final d'apprentissage automatique
- Comparaison de différentes espèces de validation croisée
- Méthodes empiriques pour l'intelligence artificielle, Cohen, 1995.
- Erreur standard sur Wikipédia
Résumé
Dans cet article, vous avez découvert comment évaluer les compétences des modèles de deep learning.
Concrètement, vous avez appris :
- L'erreur courante commise par les débutants lors de l'évaluation des modèles d'apprentissage profond.
- La justification de l’utilisation d’une validation croisée répétée k-fold pour évaluer les modèles d’apprentissage profond.
- Comment calculer les statistiques de compétences de modèle associées, telles que l'écart type, l'erreur type et les intervalles de confiance.
Avez-vous des questions sur l'estimation de la compétence des modèles d'apprentissage profond ?
Postez vos questions dans les commentaires et je ferai de mon mieux pour y répondre.