Avaliar um modelo de aprendizagem automática
Então você treinou um modelo preditivo. Como saber se é bom?
Para avaliar um modelo, você precisa usar os dados de validação retidos. Para modelos supervisionados de aprendizado de máquina, essa abordagem permite comparar os rótulos previstos pelo modelo com os rótulos reais no conjunto de dados de validação. Ao comparar as previsões com os valores verdadeiros do rótulo, você pode calcular um intervalo de métricas de avaliação para quantificar o desempenho preditivo do modelo.
Avaliação de modelos de regressão
Os modelos de regressão predizem valores numéricos, portanto, qualquer avaliação do desempenho preditivo do modelo requer que você considere as diferenças entre os valores previstos e os valores reais do rótulo no 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 precisas do que outros, você precisa de alguma maneira de 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:
- Erro quadrático médio (MPE): Esta métrica é calculada pela quadratura das diferenças entre cada previsão e o valor real, adicionando as diferenças ao quadrado e calculando a média (média). A quadratura dos valores torna as diferenças absolutas (ignorando se a diferença é negativa ou positiva) e dá mais peso a diferenças maiores.
- Erro quadrático médio raiz (RMSE): Embora a métrica MSE seja uma boa indicação do nível de erro nas previsões dos modelos, ela não está relacionada à unidade de medida real do rótulo. Por exemplo, em um modelo que prevê vendas (em dólares americanos), o valor MPE na verdade representa os valores em dólar ao quadrado. Para avaliar o quão longe estão as previsões em termos de dólares, você precisa calcular a raiz quadrada do MSE.
- Coeficiente de Determinação (R 2): A métrica R2 mede a correlação entre a característica quadrada e os valores previstos. Isso resulta em um valor entre 0 e 1 que mede a quantidade de variância que pode ser explicada pelo modelo. Quanto mais próximo este valor estiver de 1, melhor o modelo prevê.
A maioria das estruturas de aprendizado de máquina fornece classes que calculam essas métricas para você. Por exemplo, a biblioteca Spark MLlib 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))
Avaliação de modelos de classificação
Os modelos de classificação predizem 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 quando comparadas 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 no conjunto de validação usam carro, 3% pegam ônibus e 2% pegam bonde. Um modelo que simplesmente sempre prevê um carro será 95% preciso - mesmo que na verdade não tenha capacidade preditiva para discriminar entre as três classes.
- Métricas por classe:
- Precisão: A proporção de previsões da classe especificada que estavam corretas. Isto é medido como o número de verdadeiros positivos (previsões corretas desta classe) dividido pelo número total de previsões desta classe (incluindo falsos positivos).
- Recall: A proporção de instâncias reais desta classe que foram corretamente previstas (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).
- Pontuação F1: Uma métrica combinada para precisão e recordação (calculada como a média harmônica de precisão e recordação).
- Precisão (ponderada) combinada, 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 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)
Avaliação de modelos de agrupamento não supervisionados
Os modelos de clustering não supervisionados não têm valores de rótulo verdadeiros conhecidos. O objetivo do modelo de agrupamento é agrupar casos semelhantes em clusters com base em suas características. 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 agrupados como pontos plotados no espaço multidimensional. Os pontos no mesmo aglomerado devem estar próximos uns dos outros e longe dos pontos de um aglomerado diferente.
Uma dessas métricas é a medida Silhouette, que calcula a distância euclidiana quadrada e fornece uma indicação de consistência dentro de clusters. Os valores de silhueta podem estar entre 1 e -1, com um valor próximo a 1 indicando que os pontos em um cluster estão próximos aos outros pontos do mesmo cluster e longe dos pontos dos outros clusters.
A biblioteca Spark MLlib fornece a classe ClusteringEvaluator, que calcula a Silhouette para as 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)