Valutare un modello di Machine Learning

  • 10 minuti

Quindi è stato eseguito il training di un modello predittivo. Come si fa a sapere se funziona bene?

Per valutare un modello, è necessario usare i dati di convalida conservati. Per i modelli di Machine Learning supervisionati, questo approccio consente di confrontare le etichette stimate dal modello con le etichette effettive nel set di dati di convalida. Confrontando le stime con i valori di etichetta reali, è possibile calcolare un intervallo di metriche di valutazione per quantificare le prestazioni predittive del modello.

Valutazione dei modelli di regressione

I modelli di regressione stimano valori numerici, pertanto qualsiasi valutazione delle prestazioni predittive del modello richiede di considerare le differenze tra i valori stimati e i valori effettivi delle etichette nel set di dati di convalida. Dal momento che il set di dati di convalida include più casi, alcuni dei quali possono avere stime più accurate di altre, è necessario un modo per aggregare le differenze e determinare una metrica complessiva per le prestazioni. Le metriche tipiche usate per valutare un modello di regressione includono:

  • Errore quadratico medio (MSE): questa metrica viene calcolata elevando al quadrato le differenze tra ogni stima e valore effettivo e sommando le differenze elevate al quadrato e calcolando la media. Elevare al quadrato i valori rende le differenze assolute, ignorando se la differenza è negativa o positiva, e dando più peso alle differenze maggiori.
  • Radice dell’errore quadratico medio (RMSE): mentre la metrica MSE è un'indicazione valida del livello di errore nelle stime dei modelli, non è correlata all'unità di misura effettiva dell'etichetta. Ad esempio, in un modello che stima le vendite (in dollari USA), il valore MSE rappresenta effettivamente i valori in dollari elevati al quadrato. Per valutare quanto lontano sono le stime in termini di dollari, è necessario calcolare la radice quadrata dell’errore quadratico medio (MSE).
  • Coefficiente di determinazione (R2): la metrica R2 misura la correlazione tra la funzionalità elevata al quadrato e i valori stimati. Ciò risulta in un valore compreso tra 0 e 1 che misura la quantità di varianza che può essere spiegata dal modello. Più il valore è vicino a 1, migliori saranno le previsioni del modello.

La maggior parte dei framework di Machine Learning offre classi che calcolano automaticamente queste metriche. Ad esempio, la libreria Spark MLlib fornisce la classe RegressionEvaluator, che è possibile usare come illustrato in questo esempio di codice:

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

Valutazione dei modelli di classificazione

I modelli di classificazione stimano le etichette categoriche (classi) calcolando un valore di probabilità per ogni classe possibile e selezionando l'etichetta di classe con la probabilità più alta. Le metriche usate per valutare un modello di classificazione riflettono la frequenza con cui queste stime di classe erano corrette rispetto alle etichette note effettive nel set di dati di convalida. Le metriche tipiche usate per valutare un modello di classificazione includono:

  • Accuratezza: metrica semplice che indica la percentuale di stime della classe effettuate dal modello che erano corrette. Anche se questo può sembrare il modo ovvio per valutare le prestazioni di un modello di classificazione, considerare uno scenario in cui viene usato un modello per stimare se una persona andrà al lavoro in auto, in autobus o con il tram. Ipotizzare che il 95% dei casi nel set di convalida usi un'auto, il 3% prenda l'autobus e il 2% prenda un tram. Un modello che prevede sempre semplicemente un'auto sarà accurato al 95%, anche se in realtà non ha capacità predittiva per discriminare tra le tre classi.
  • Metriche per classe:
    • Precisione: percentuale delle stime della classe specificata che erano corrette. Questo valore viene misurato come numero di veri positivi, stime corrette di questa classe, diviso per il numero totale di stime di questa classe, inclusi falsi positivi.
    • Richiamo: percentuale delle istanze effettive di questa classe stimate correttamente, il numero di veri positivi diviso per il numero totale di istanze di questa classe nel set di dati di convalida, inclusi falsi negativi, cioè casi in cui il modello ha stimato erroneamente una classe diversa.
    • Punteggio F1: metrica combinata per precisione e richiamo, calcolata come media armonica di precisione e richiamo.
  • Le metriche combinate (ponderate) Precisione, Richiamoe F1 per tutte le classi.

Per quanto riguarda la regressione, la maggior parte dei framework di Machine Learning include classi in grado di calcolare le metriche di classificazione. Ad esempio, il codice seguente usa MulticlassClassificationEvaluator nella libreria MLlib di 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)

Valutazione di modelli di clustering non supervisionati

I modelli di clustering non supervisionati non hanno valori di etichetta reali noti. L'obiettivo del modello di clustering è raggruppare casi simili in cluster in base alle relative funzionalità. Per valutare un cluster, è necessaria una metrica che indica il livello di separazione tra cluster. È possibile considerare i casi in cluster come punti tracciati nello spazio multidimensionale. I punti nello stesso cluster devono essere vicini l'uno all'altro e lontano da punti in un cluster diverso.

Una di queste metriche è la misura Silhouette, che calcola la distanza euclidea elevata al quadrato e fornisce un'indicazione della coerenza all'interno dei cluster. I valori Silhouette possono essere compresi tra 1 e -1, con un valore vicino a 1 che indica che i punti in un cluster sono vicini agli altri punti dello stesso cluster e lontani dai punti degli altri cluster.

La libreria MLlib di Spark fornisce la classe ClusteringEvaluator, che calcola la Silhouette per le stime effettuate da un modello di clustering, come illustrato qui:

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)