Évaluer un modèle Machine Learning

  • 10 minutes

Vous avez donc formé un modèle prédictif. Comment savoir si c’est bon ?

Pour évaluer un modèle, vous devez utiliser les données de validation que vous avez conservées. Pour les modèles d’apprentissage automatique supervisés, cette approche vous permet de comparer les étiquettes prédites par le modèle aux étiquettes réelles dans le jeu de données de validation. En comparant les prédictions aux valeurs réelles des étiquettes, vous pouvez calculer une plage de métriques d’évaluation pour quantifier les performances prédictives du modèle.

Évaluation des modèles de régression

Les modèles de régression prédisent des valeurs numériques, de sorte que toute évaluation des performances prédictives du modèle vous oblige à prendre en compte les différences entre les valeurs prédites et les valeurs d’étiquette réelles dans le jeu de données de validation. Étant donné que le jeu de données de validation comprend plusieurs cas, dont certains peuvent avoir des prédictions plus précises que d’autres, vous avez besoin d’un moyen d’agréger les différences et de déterminer une métrique globale pour les performances. Les mesures typiques utilisées pour évaluer un modèle de régression sont les suivantes :

  • Erreur quadratique moyenne (MSE) : cette métrique est calculée en mettant au carré les différences entre chaque prédiction et valeur réelle, en additionnant les différences carrées et en calculant la moyenne (moyenne). La mise au carré des valeurs rend les différences absolues (en ignorant si la différence est négative ou positive) et donne plus de poids aux différences plus grandes.
  • Erreur quadratique moyenne (RMSE) : bien que la métrique MSE soit une bonne indication du niveau d’erreur dans les prédictions des modèles, elle n’est pas liée à l’unité de mesure réelle de l’étiquette. Par exemple, dans un modèle qui prédit les ventes (en dollars américains), la valeur MSE représente en fait les valeurs en dollars au carré. Pour évaluer à quel point les prédictions sont éloignées en termes de dollars, vous devez calculer la racine carrée du MSE.
  • Coefficient de détermination (R2) : La métrique R2 mesure la corrélation entre l’élément carré et les valeurs prédites. Il en résulte une valeur comprise entre 0 et 1 qui mesure la quantité de variance qui peut être expliquée par le modèle. Plus cette valeur est proche de 1, mieux le modèle prédit.

La plupart des frameworks de machine learning proposent des classes qui calculent ces métriques pour vous. Par exemple, la bibliothèque MLlib Spark fournit la classe RegressionEvaluator , que vous pouvez utiliser comme indiqué dans cet exemple de code :

from pyspark.ml.evaluation import RegressionEvaluator

# Inference predicted labels from validation data
predictions_df = model.transform(validation_df)

# Assume predictions_df includes a 'prediction' column with the predicted labels
# and a 'label' column with the actual known label values

# Use an evaluator to get metrics
evaluator = RegressionEvaluator()
evaluator.setPredictionCol("prediction")
mse = evaluator.evaluate(predictions_df, {evaluator.metricName: "mse"})
rmse = evaluator.evaluate(predictions_df, {evaluator.metricName: "rmse"})
r2 = evaluator.evaluate(predictions_df, {evaluator.metricName: "r2"})
print("MSE:", str(mse))
print("RMSE:", str(rmse))
print("R2", str(r2))

Évaluation des modèles de classification

Les modèles de classification prédisent les étiquettes catégorielles (classes) en calculant une valeur de probabilité pour chaque classe possible et en sélectionnant l’étiquette de classe avec la probabilité la plus élevée. Les métriques utilisées pour évaluer un modèle de classification reflètent la fréquence à laquelle ces prédictions de classe étaient correctes par rapport aux étiquettes connues réelles dans le jeu de données de validation. Les mesures typiques utilisées pour évaluer un modèle de classification sont les suivantes :

  • Précision : mesure simple qui indique la proportion de prédictions de classe effectuées par le modèle qui étaient correctes. Bien que cela puisse sembler être la façon évidente d’évaluer les performances d’un modèle de classification, considérons un scénario où un modèle est utilisé pour prédire si une personne se rendra au travail en voiture, en bus ou en tramway. Supposons que 95% des cas de l’ensemble de validation utilisent une voiture, 3% prennent le bus et 2% prennent un tramway. Un modèle qui prédit simplement toujours une voiture sera précis à 95% - même s’il n’a en fait aucune capacité prédictive pour faire la distinction entre les trois classes.
  • Métriques par classe :
    • Précision : proportion de prédictions correctes de la classe spécifiée. Il est mesuré en divisant le nombre de vrais positifs (prédictions correctes de cette classe) par le nombre total de prédictions de cette classe (y compris les faux positifs).
    • Rappel : proportion d’instances réelles de cette classe qui ont été correctement prédites (vrais positifs divisés par le nombre total d’instances de cette classe dans l’ensemble de données de validation, y compris les faux négatifs - cas où le modèle a mal prédit une classe différente).
    • Score F1 : Une mesure combinée de la précision et de la mémorisation (calculée comme la moyenne harmonique de la précision et du rappel).
  • Précision combinée (pondérée), rappel et mesures F1 pour toutes les classes.

En ce qui concerne la régression, la plupart des frameworks d’apprentissage automatique incluent des classes qui peuvent calculer des métriques de classification. Par exemple, le code suivant utilise MulticlassClassificationEvaluator dans la bibliothèque MLlib Spark.

from pyspark.ml.evaluation import MulticlassClassificationEvaluator

# Inference predicted labels from validation data
predictions_df = model.transform(validation_df)

# Assume predictions_df includes a 'prediction' column with the predicted labels
# and a 'label' column with the actual known label values

# Use an evaluator to get metrics
accuracy = evaluator.evaluate(predictions_df, {evaluator.metricName:"accuracy"})
print("Accuracy:", accuracy)

labels = [0,1,2]
print("\nIndividual class metrics:")
for label in sorted(labels):
    print ("Class %s" % (label))
    precision = evaluator.evaluate(predictions_df, {evaluator.metricLabel:label,
                                                    evaluator.metricName:"precisionByLabel"})
    print("\tPrecision:", precision)
    recall = evaluator.evaluate(predictions_df, {evaluator.metricLabel:label,
                                                 evaluator.metricName:"recallByLabel"})
    print("\tRecall:", recall)
    f1 = evaluator.evaluate(predictions_df, {evaluator.metricLabel:label,
                                             evaluator.metricName:"fMeasureByLabel"})
    print("\tF1 Score:", f1)
    
overallPrecision = evaluator.evaluate(predictions_df, {evaluator.metricName:"weightedPrecision"})
print("Overall Precision:", overallPrecision)
overallRecall = evaluator.evaluate(predictions_df, {evaluator.metricName:"weightedRecall"})
print("Overall Recall:", overallRecall)
overallF1 = evaluator.evaluate(predictions_df, {evaluator.metricName:"weightedFMeasure"})
print("Overall F1 Score:", overallF1)

Évaluation des modèles de clustering non supervisé

Les modèles de clustering non supervisé n’ont pas de valeurs d’étiquette réelles connues. L’objectif du modèle de clustering est de regrouper les cas similaires en clusters en fonction de leurs caractéristiques. Pour évaluer un cluster, vous avez besoin d’une métrique qui indique le niveau de séparation entre les clusters. Vous pouvez considérer les cas groupés comme des points tracés dans un espace multidimensionnel. Les points d’un même cluster doivent être proches les uns des autres et éloignés des points d’un autre cluster.

L’une de ces mesures est la mesure Silhouette , qui calcule la distance euclidienne au carré et fournit une indication de cohérence au sein des grappes. Les valeurs de silhouette peuvent être comprises entre 1 et -1, une valeur proche de 1 indiquant que les points d’un cluster sont proches des autres points du même cluster et éloignés des points des autres clusters.

La bibliothèque MLlib Spark fournit la classe ClusteringEvaluator , qui calcule la silhouette pour les prédictions effectuées par un modèle de clustering, comme illustré ici :

from pyspark.ml.evaluation import ClusteringEvaluator
from pyspark.ml.linalg import Vectors

# Inference predicted labels from validation data
predictions_df = model.transform(validation_df)

# Assume predictions_df includes a 'prediction' column with the predicted cluster

# Use an evaluator to get metrics
evaluator = ClusteringEvaluator(predictionCol="prediction")
silhouetteVal  = evaluator.evaluate(predictions_df)
print(silhouetteVal)