S29L04 – ROC, AUC – Calculando o limiar ideal (melhor método de acurácia)

Translation:
html
Otimização de Modelos de Classificação Binária com ROC, AUC e Análise de Limite: Um Guia Abrangente
Desbloqueie todo o potencial dos seus modelos de aprendizado de máquina dominando curvas ROC, métricas AUC e seleção de limite ótima. Este guia aprofunda-se no pré-processamento, modelagem de regressão logística e otimização de desempenho utilizando um conjunto de dados meteorológicos do mundo real.

Introdução
No domínio do aprendizado de máquina, particularmente em tarefas de classificação binária, avaliar e otimizar o desempenho do modelo é fundamental. Métricas como Curvas Características de Operação do Receptor (ROC) e Área Sob a Curva (AUC) fornecem insights inestimáveis sobre a capacidade de um modelo em discriminar entre classes. Além disso, ajustar o limiar de classificação pode melhorar significativamente a precisão do modelo, a pontuação F1 e o desempenho geral. Este artigo explora esses conceitos em detalhe, utilizando um conjunto de dados meteorológicos do mundo real para demonstrar a aplicação prática através de um exemplo em Jupyter Notebook.

Entendendo as Curvas ROC e AUC
O que é uma Curva ROC?
Uma curva ROC é uma representação gráfica que ilustra a capacidade diagnóstica de um sistema de classificador binário à medida que seu limiar de discriminação varia. Ela plota a Taxa de Verdadeiros Positivos (TPR) contra a Taxa de Falsos Positivos (FPR) em várias configurações de limiar.

  Taxa de Verdadeiros Positivos (TPR): Também conhecida como Recall ou Sensibilidade, mede a proporção de positivos reais corretamente identificados pelo modelo.
  
    \[
    \text{TPR} = \frac{\text{Verdadeiros Positivos}}{\text{Verdadeiros Positivos} + \text{Falsos Negativos}}
    \]
  
  Taxa de Falsos Positivos (FPR): Mede a proporção de negativos reais incorretamente identificados como positivos pelo modelo.
  
    \[
    \text{FPR} = \frac{\text{Falsos Positivos}}{\text{Falsos Positivos} + \text{Verdadeiros Negativos}}
    \]
  

O que é AUC?
A Área Sob a Curva (AUC) quantifica a capacidade geral do modelo em discriminar entre as classes positivas e negativas. Uma AUC mais alta indica um modelo com melhor desempenho. Uma AUC de 0,5 sugere nenhuma capacidade discriminativa, equivalente a um palpite aleatório, enquanto uma AUC de 1,0 significa discriminação perfeita.

Visão Geral do Conjunto de Dados: Weather Australia
Para este guia, utilizaremos um conjunto de dados Weather Australia, que contém diversas características meteorológicas. O conjunto de dados foi pré-processado para incluir 10.000 registros, garantindo manejabilidade e eficácia na ilustração dos conceitos.
Fonte dos Dados: Conjunto de Dados Weather Australia no Kaggle

Pré-processamento de Dados
Um pré-processamento eficaz é crucial para construir modelos de aprendizado de máquina robustos. Os seguintes passos delineiam a pipeline de pré-processamento aplicada ao conjunto de dados Weather Australia.
1. Importando Bibliotecas e Dados




		
		
			
			
Java
			
			import pandas as pd 
import seaborn as sns
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, MinMaxScaler, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc, classification_report
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import pandas as pd 
import seaborn as sns
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, MinMaxScaler, StandardScaler
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, roc_curve, auc, classification_report
					
				
			
		






		
		
			
			
Java
			
			data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
			
				
					
				
					1
2
				
						data = pd.read_csv('weatherAUS - tiny.csv')
data.tail()
					
				
			
		


Exemplo de Saída:

  
    Data
    Localização
    MinTemp
    MaxTemp
    Precipitação
    Evaporação
    Sunshine
    ...
    ChoveuHoje
    RISCO_MM
    ChoveuAmanhã
  
  
    05/01/2012
    CoffsHarbour
    21.3
    26.5
    0.6
    7.6
    6.4
    ...
    Não
    0.0
    Não
  

2. Seleção de Características
Separe o conjunto de dados em características (X) e alvo (y).




		
		
			
			
Java
			
			X = data.iloc[:,:-1]
X.drop('RISK_MM', axis=1, inplace=True)
y = data.iloc[:,-1]
			
				
					
				
					1
2
3
				
						X = data.iloc[:,:-1]
X.drop('RISK_MM', axis=1, inplace=True)
y = data.iloc[:,-1]
					
				
			
		


3. Tratamento de Dados Faltantes
a. Características Numéricas
Impute valores faltantes em colunas numéricas usando a estratégia da média.




		
		
			
			
Java
			
			numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
				
						numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		


b. Características Categóricas
Impute valores faltantes em colunas categóricas usando a estratégia de mais frequente.




		
		
			
			
Java
			
			string_cols = list(np.where((X.dtypes == object))[0])
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
				
						string_cols = list(np.where((X.dtypes == object))[0])
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		


4. Codificação de Variáveis Categóricas
a. Codificação de Rótulos
Converta rótulos categóricos em valores numéricos para a variável alvo.




		
		
			
			
Java
			
			def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series) 

y = LabelEncoderMethod(y)
			
				
					
				
					1
2
3
4
5
				
						def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series) 
 
y = LabelEncoderMethod(y)
					
				
			
		


b. Codificação One-Hot
Aplique a Codificação One-Hot a características categóricas com mais de dois valores únicos.




		
		
			
			
Java
			
			def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices )], remainder='passthrough')
    return columnTransformer.fit_transform(data)

def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_values = len(pd.unique(X[X.columns[col]]))
        if unique_values == 2 or unique_values > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X

X = EncodingSelection(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices )], remainder='passthrough')
    return columnTransformer.fit_transform(data)
 
def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_values = len(pd.unique(X[X.columns[col]]))
        if unique_values == 2 or unique_values > threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		


5. Escalonamento e Seleção de Características
a. Escalonamento de Características
Padronize o conjunto de características para garantir uniformidade entre as variáveis.




		
		
			
			
Java
			
			sc = StandardScaler(with_mean=False)
X = sc.fit_transform(X)
			
				
					
				
					1
2
				
						sc = StandardScaler(with_mean=False)
X = sc.fit_transform(X)
					
				
			
		


b. Seleção de Características
Selecione as 10 melhores características com base no teste estatístico Qui-Quadrado (chi2).




		
		
			
			
Java
			
			kbest = SelectKBest(score_func=chi2, k=10)
X = kbest.fit_transform(X, y)
			
				
					
				
					1
2
				
						kbest = SelectKBest(score_func=chi2, k=10)
X = kbest.fit_transform(X, y)
					
				
			
		


6. Divisão em Conjuntos de Treino e Teste
Divida o conjunto de dados em conjuntos de treino e teste para avaliar o desempenho do modelo.




		
		
			
			
Java
			
			X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
			
				
					
				
					1
				
						X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
					
				
			
		



Construindo e Avaliando o Modelo de Regressão Logística
Com os dados pré-processados, procedemos para construir um modelo de Regressão Logística, avaliar seu desempenho e otimizá-lo usando métricas ROC e AUC.
1. Treinando o Modelo




		
		
			
			
Java
			
			LRM = LogisticRegression(random_state=0, max_iter=500)
LRM.fit(X_train, y_train)
y_pred = LRM.predict(X_test)
print(f"Precisão: {accuracy_score(y_pred, y_test):.3f}")
			
				
					
				
					1
2
3
4
				
						LRM = LogisticRegression(random_state=0, max_iter=500)
LRM.fit(X_train, y_train)
y_pred = LRM.predict(X_test)
print(f"Precisão: {accuracy_score(y_pred, y_test):.3f}")
					
				
			
		


Saída:




		
		
			
			
Java
			
			Precisão: 0.872
			
				
					
				
					1
				
						Precisão: 0.872
					
				
			
		


2. Cálculo da Curva ROC e AUC
Plotar a curva ROC e calcular a AUC fornece uma compreensão abrangente do desempenho do modelo.




		
		
			
			
Java
			
			predicted_probabilities = LRM.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, predicted_probabilities[:,1])
roc_auc = auc(fpr, tpr)
print(f"AUC: {roc_auc:.3f}")
			
				
					
				
					1
2
3
4
				
						predicted_probabilities = LRM.predict_proba(X_test)
fpr, tpr, thresholds = roc_curve(y_test, predicted_probabilities[:,1])
roc_auc = auc(fpr, tpr)
print(f"AUC: {roc_auc:.3f}")
					
				
			
		


Saída:




		
		
			
			
Java
			
			AUC: 0.884
			
				
					
				
					1
				
						AUC: 0.884
					
				
			
		


3. Otimizando o Limite de Classificação
O limiar padrão de 0,5 pode não sempre oferecer o melhor desempenho. Ajustar esse limiar pode melhorar a precisão e outras métricas.
a. Calculando a Precisão em Diversos Limites




		
		
			
			
Java
			
			accuracies = []
for thresh in thresholds:
    _predictions = [1 if i >= thresh else 0 for i in predicted_probabilities[:, -1]]
    accuracies.append(accuracy_score(y_test, _predictions, normalize=True))

accuracies = pd.concat([pd.Series(thresholds), pd.Series(accuracies)], axis=1)
accuracies.columns = ['threshold', 'accuracy']
accuracies.sort_values(by='accuracy', ascending=False, inplace=True)
print(accuracies.head())
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						accuracies = []
for thresh in thresholds:
    _predictions = [1 if i >= thresh else 0 for i in predicted_probabilities[:, -1]]
    accuracies.append(accuracy_score(y_test, _predictions, normalize=True))
 
accuracies = pd.concat([pd.Series(thresholds), pd.Series(accuracies)], axis=1)
accuracies.columns = ['threshold', 'accuracy']
accuracies.sort_values(by='accuracy', ascending=False, inplace=True)
print(accuracies.head())
					
				
			
		


Exemplo de Saída:




		
		
			
			
Java
			
			   threshold  accuracy
78    0.547545    0.8760
76    0.560424    0.8755
114   0.428764    0.8755
112   0.432886    0.8755
110   0.433176    0.8755
			
				
					
				
					1
2
3
4
5
6
				
						   threshold  accuracy
78    0.547545    0.8760
76    0.560424    0.8755
114   0.428764    0.8755
112   0.432886    0.8755
110   0.433176    0.8755
					
				
			
		


b. Selecionando o Limite Ótimo




		
		
			
			
Java
			
			optimal_proba_cutoff = accuracies['threshold'].iloc[0]
roc_predictions = [1 if i >= optimal_proba_cutoff else 0 for i in predicted_probabilities[:, -1]]
			
				
					
				
					1
2
				
						optimal_proba_cutoff = accuracies['threshold'].iloc[0]
roc_predictions = [1 if i >= optimal_proba_cutoff else 0 for i in predicted_probabilities[:, -1]]
					
				
			
		


c. Avaliando com o Limite Ótimo




		
		
			
			
Java
			
			print("Relatório de Classificação com Limite Ótimo:")
print(classification_report(roc_predictions, y_test))
			
				
					
				
					1
2
				
						print("Relatório de Classificação com Limite Ótimo:")
print(classification_report(roc_predictions, y_test))
					
				
			
		


Saída:




		
		
			
			
Java
			
			              precision    recall  f1-score   support

           0       0.97      0.89      0.93      1770
           1       0.48      0.77      0.59       230

    accuracy                           0.88      2000
   macro avg       0.72      0.83      0.76      2000
weighted avg       0.91      0.88      0.89      2000
			
				
					
				
					1
2
3
4
5
6
7
8
				
						              precision    recall  f1-score   support
 
           0       0.97      0.89      0.93      1770
           1       0.48      0.77      0.59       230
 
    accuracy                           0.88      2000
   macro avg       0.72      0.83      0.76      2000
weighted avg       0.91      0.88      0.89      2000
					
				
			
		


Comparação com o Limite Padrão:




		
		
			
			
Java
			
			print("Relatório de Classificação com Limite Padrão (0.5):")
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
				
						print("Relatório de Classificação com Limite Padrão (0.5):")
print(classification_report(y_pred, y_test))
					
				
			
		


Saída:




		
		
			
			
Java
			
			              precision    recall  f1-score   support

           0       0.96      0.89      0.92      1740
           1       0.51      0.73      0.60       260

    accuracy                           0.87      2000
   macro avg       0.73      0.81      0.76      2000
weighted avg       0.90      0.87      0.88      2000
			
				
					
				
					1
2
3
4
5
6
7
8
				
						              precision    recall  f1-score   support
 
           0       0.96      0.89      0.92      1740
           1       0.51      0.73      0.60       260
 
    accuracy                           0.87      2000
   macro avg       0.73      0.81      0.76      2000
weighted avg       0.90      0.87      0.88      2000
					
				
			
		


Insights:

  Melhoria na Precisão: O limiar ótimo aumenta ligeiramente a precisão de 87,2% para 88%.
  Melhoria na Pontuação F1: A pontuação F1 melhora de 0,60 para 0,59 (uma melhoria marginal dado o equilíbrio entre precisão e recall).
  Precisão e Recall Balanceados: O limiar ótimo mantém uma precisão e recall balanceados, garantindo que nenhum deles seja desproporcionalmente favorecido.


Melhores Práticas para Otimização de Limiar

  Entenda as Compensações: Ajustar o limiar afeta a sensibilidade e a especificidade. É essencial alinhar a seleção do limiar com os objetivos específicos da sua aplicação.
  Use Métricas Relevantes: Dependendo do problema, priorize métricas como pontuação F1, precisão ou recall em vez de apenas a precisão.
  Automatize a Seleção de Limiar: Embora a inspeção manual seja benéfica, aproveitar métodos automatizados ou validação cruzada pode aumentar a robustez.


Conclusão
Otimizar modelos de classificação binária vai além de alcançar alta precisão. Ao utilizar curvas ROC, métricas AUC e ajustes estratégicos de limiar, os profissionais podem afinar os modelos para atender a critérios específicos de desempenho. Essa abordagem abrangente garante que os modelos não sejam apenas precisos, mas também confiáveis e eficazes em diversos cenários.
Principais Aprendizados:

  ROC e AUC fornecem uma visão holística do desempenho do modelo em diferentes limiares.
  Otimização de Limiar pode melhorar as métricas do modelo, ajustando o desempenho às necessidades específicas da aplicação.
  Pré-processamento Abrangente é fundamental para construir modelos de aprendizado de máquina robustos e eficazes.

Inicie o refinamento dos seus modelos com essas estratégias para alcançar desempenho superior e insights acionáveis.

Recursos Adicionais

  Documentação do Scikit-learn
  Conjuntos de Dados Kaggle
  Entendendo Curvas ROC


Autor: [Seu Nome]

Redator Técnico & Entusiasta de Ciência de Dados