Avaliar um modelo de machine learning
Portanto, você treinou um modelo preditivo. Como você sabe se ele é bom?
Para avaliar um modelo, você precisa usar os dados de validação retidos. Para modelos de aprendizado de máquina supervisionados, essa abordagem permite comparar os rótulos previstos pelo modelo com os rótulos reais no conjunto de dados de validação. Comparando as previsões com os valores de rótulo verdadeiros, você pode calcular um intervalo de métricas de avaliação para quantificar o desempenho preditivo do modelo.
Como avaliar modelos de regressão
Os modelos de regressão preveem valores numéricos, portanto, qualquer avaliação do desempenho preditivo do modelo exige que você considere as diferenças entre os valores previstos e os valores de rótulo reais do conjunto de dados de validação. Como o conjunto de dados de validação inclui vários casos, alguns dos quais podem ter previsões mais exatas do que outros, é preciso de alguma forma para agregar as diferenças e determinar uma métrica geral de desempenho. As métricas típicas usadas para avaliar um modelo de regressão incluem:
- MSE (Erro Quadrático Médio): essa métrica é calculada elevando ao quadrado as diferenças entre cada previsão e valor real, somando essas diferenças elevadas ao quadrado e, por fim, calculando a média. Ao elevar ao quadrado os valores das diferenças tornam-se absolutos (ignorando se a diferença é negativa ou positiva) e confere-se mais peso às diferenças maiores.
- RMSE (Raiz do Erro Quadrático Médio): embora a métrica do MSE seja uma boa indicação do nível de erro nas previsões de modelos, ela não está relacionada à unidade real de medição do rótulo. Por exemplo, em um modelo que prevê vendas (em dólares americanos), o valor do MSE realmente representa os valores em dólar ao quadrado. Para avaliar a distância entre as previsões em termos de dólares, você precisa calcular a raiz quadrada do MSE.
- R2 (Coeficiente de Determinação): a métrica R2 mede a correlação entre o recurso ao quadrado e os valores previstos. Isso resulta em um valor entre 0 e 1 que mede a quantidade de variação que pode ser explicada pelo modelo. Quanto mais próximo esse valor for de 1, melhor será a previsão do modelo.
A maioria das estruturas de aprendizado de máquina fornece classes que calculam essas métricas para você. Por exemplo, a biblioteca MLlib do Spark fornece a classe RegressionEvaluator, que você pode usar conforme mostrado neste exemplo de código:
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))
Como avaliar modelos de classificação
Os modelos de classificação preveem rótulos categóricos (classes) calculando um valor de probabilidade para cada classe possível e selecionando o rótulo de classe com a maior probabilidade. As métricas usadas para avaliar um modelo de classificação refletem a frequência com que essas previsões de classe estavam corretas em comparação com os rótulos conhecidos reais no conjunto de dados de validação. As métricas típicas usadas para avaliar um modelo de classificação incluem:
- Precisão: uma métrica simples que indica a proporção de previsões de classe feitas pelo modelo que estavam corretas. Embora isso possa parecer a maneira óbvia de avaliar o desempenho de um modelo de classificação, considere um cenário em que um modelo é usado para prever se uma pessoa se deslocará para o trabalho de carro, ônibus ou bonde. Digamos que 95% dos casos do conjunto de validação usem carro, 3% usem ônibus e 2% usem bonde. Um modelo que simplesmente prevê que sempre será usado carro será 95% preciso – embora ele, de fato, não tenha capacidade preditiva de discriminar entre as três classes.
- Métricas por classe:
- Precisão: proporção de previsões da classe especificada que estavam corretas. Isso é medido como o número de verdadeiros positivos (previsões corretas dessa classe) divididos pelo número total de previsões dessa classe (incluindo falsos positivos).
- Recall: a proporção de instâncias reais dessa classe que foram previstas corretamente (verdadeiros positivos divididos pelo número total se instâncias dessa classe no conjunto de dados de validação, incluindo falsos negativos – casos em que o modelo previu incorretamente uma classe diferente).
- Medida f: uma métrica combinada de precisão e recall (calculada como a média harmônica de precisão e recall).
- Precisão combinada (ponderada), recall e métricas F1 para todas as classes.
Quanto à regressão, a maioria das estruturas de aprendizado de máquina inclui classes que podem calcular métricas de classificação. Por exemplo, o código a seguir usa o MulticlassClassificationEvaluator na biblioteca MLlib do 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)
Como avaliar modelos de clustering não supervisionados
Modelos de clustering não supervisionados não têm valores de rótulo verdadeiros conhecidos. O objetivo do modelo de clustering é agrupar casos semelhantes em clusters com base nos recursos deles. Para avaliar um cluster, você precisa de uma métrica que indique o nível de separação entre clusters. Você pode pensar nos casos clusterizados como pontos plotados no espaço multidimensional. Os pontos do mesmo cluster devem estar próximos uns dos outros e distantes dos pontos de outro cluster.
Uma dessas métricas é a medida Silhueta, que calcula a distância euclidiana quadrada e fornece uma indicação de consistência dentro dos clusters. Os valores de silhueta podem estar entre 1 e -1, sendo que valores próximos a 1 indicam que os pontos do cluster estão próximos de outros pontos do mesmo cluster e distantes dos pontos de outros clusters.
A biblioteca MLlib do Spark fornece a classe ClusteringEvaluator, que calcula a Silhueta das previsões feitas por um modelo de clustering, conforme mostrado aqui:
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)