Évaluer un modèle Machine Learning

  • 10 minutes

Vous avez donc entraîné un modèle prédictif. Comment savez-vous s’il est bon ?

Pour évaluer un modèle, vous devez utiliser les données de validation que vous avez mises de côté. Pour les modèles Machine Learning 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 vraies valeurs d’étiquette, vous pouvez calculer un ensemble de métriques d’évaluation pour quantifier les performances prédictives du modèle.

Évaluation les modèles de régression

Les modèles de régression prédisent des valeurs numériques. Par conséquent, 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 métriques classiques 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 la valeur réelle, en ajoutant les différences au carré ensemble et en calculant la moyenne. Le calcul du carré des valeurs rend les différences absolues (sans tenir compte du fait que la différence est négative ou positive) et donne plus de poids aux différences plus grandes.
  • Racine de l’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 ne correspond pas à 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 dollar mises au carré. Pour évaluer la distance entre les prédictions en termes de dollars, vous devez calculer la racine carrée de l’erreur quadratique moyenne.
  • Coefficient de détermination (R2) : la métrique R2 mesure la corrélation entre la caractéristique au carré et les valeurs prédites. Cela produit une valeur comprise entre 0 et 1 qui mesure la quantité de variance pouvant être expliquée par le modèle. Plus cette valeur est proche de 1, meilleure sera la prédiction du modèle.

La plupart des frameworks Machine Learning fournissent des classes qui calculent ces métriques pour vous. Par exemple, la bibliothèque Spark MLlib 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 métriques classiques utilisées pour évaluer un modèle de classification sont les suivantes :

  • Précision : métrique simple qui indique la proportion de prédictions de classe effectuées par le modèle qui étaient correctes. Bien que cela puisse sembler la façon évidente d’évaluer les performances d’un modèle de classification, envisagez 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 tram. Supposons que 95 % des cas dans le jeu de validation utilisent une voiture, 3 % prennent le bus et 2 % un tram. Un modèle qui prédit simplement toujours l’utilisation d’une voiture sera exact à 95 %, même s’il n’a en fait aucune capacité prédictive à distinguer entre les trois classes.
  • Métriques par classe :
    • Précision : proportion des prédictions de la classe spécifiée qui étaient correctes. Elle est mesurée par le nombre de vrais positifs (prédictions correctes de cette classe) divisé 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 le jeu de données de validation, y compris les faux négatifs ; les cas où le modèle a prédit incorrectement une classe différente).
    • Score F1 : métrique combinée de précision et de rappel (calculée comme la moyenne harmonique de la précision et du rappel).
  • Métriques combinées (pondérées) de précision, rappel et F1 pour toutes les classes.

Comme pour la régression, la plupart des frameworks Machine Learning incluent des classes qui peuvent calculer des métriques de classification. Par exemple, le code suivant utilise l’élément MulticlassClassificationEvaluator dans la bibliothèque Spark MLlib.

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és

Les modèles de clustering non supervisés n’ont pas de vraies valeurs d’étiquette 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 en cluster comme des points tracés dans un espace multidimensionnel. Les points du même cluster doivent être proches les uns des autres et éloignés des points d’un autre cluster.

L’une de ces métriques est la Silhouette, qui calcule la distance euclidienne carrée et fournit une indication de cohérence au sein des clusters. Les valeurs de silhouette peuvent être comprises entre 1 et -1, avec 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 Spark MLlib 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)