S26L04 – Matriz de Confusão 3D

html
Dominando Matrizes de Confusão: Um Guia Abrangente para Profissionais de Machine Learning

Índice

    O que é uma Matriz de Confusão?
    Componentes de uma Matriz de Confusão
        
            True Positive (TP)
            True Negative (TN)
            False Positive (FP)
            False Negative (FN)
        
    
    Entendendo a Matriz de Confusão com Múltiplas Classes
    Construindo uma Matriz de Confusão Usando Scikit-Learn
    Visualizando a Matriz de Confusão
    Interpretando Métricas de Desempenho do Modelo
        
            Acurácia
            Precisão
            Recall
            F1 Score
            Especificidade
        
    
    Avançado: Tratando Matrizes de Confusão Multiclasse
    Implementação Prática com Dataset de Previsão do Tempo
    Conclusão


O que é uma Matriz de Confusão?
Uma matriz de confusão é uma representação tabular do desempenho de um modelo de classificação. Ela permite visualizar quão bem o seu modelo está se saindo ao comparar os valores reais do alvo com aqueles previstos pelo modelo. Cada linha da matriz representa as instâncias em uma classe real, enquanto cada coluna representa as instâncias em uma classe prevista, ou vice-versa. Essa estrutura facilita a identificação não apenas dos tipos de erros que seu modelo está cometendo, mas também sua frequência.



Figura 1: Estrutura básica de uma matriz de confusão.

Componentes de uma Matriz de Confusão
Entender os componentes individuais de uma matriz de confusão é crucial para interpretar os resultados de forma eficaz. A matriz consiste em quatro métricas principais:

True Positive (TP)

    Definição: O número de instâncias corretamente classificadas como positivas.
    Exemplo: Se o modelo prevê que vai chover amanhã e realmente chove, é um True Positive.


True Negative (TN)

    Definição: O número de instâncias corretamente classificadas como negativas.
    Exemplo: Se o modelo prevê que não vai chover amanhã e de fato não chove, é um True Negative.


False Positive (FP)

    Definição: O número de instâncias incorretamente classificadas como positivas.
    Exemplo: Se o modelo prevê que vai chover amanhã, mas não chove, é um False Positive. Isto também é conhecido como erro do Tipo I.


False Negative (FN)

    Definição: O número de instâncias incorretamente classificadas como negativas.
    Exemplo: Se o modelo prevê que não vai chover amanhã, mas na verdade chove, é um False Negative. Isto também é conhecido como erro do Tipo II.




Figura 2: Detalhamento de TP, TN, FP e FN dentro de uma matriz de confusão.

Entendendo a Matriz de Confusão com Múltiplas Classes
Enquanto a classificação binária envolve duas classes (positiva e negativa), a classificação multiclasse estende a matriz de confusão para acomodar mais classes. Por exemplo, em um dataset com três classes—setosa, versicolor e virginica—a matriz de confusão torna-se uma grade 3x3. Cada linha representa a classe real e cada coluna representa a classe prevista. Os elementos da diagonal ainda representam previsões corretas, enquanto os elementos fora da diagonal indicam vários tipos de erros de classificação.



Figura 3: Exemplo de uma matriz de confusão multiclasse.

Construindo uma Matriz de Confusão Usando Scikit-Learn
A biblioteca scikit-learn do Python oferece ferramentas robustas para gerar e analisar matrizes de confusão. Abaixo está um guia passo a passo para construir uma matriz de confusão usando scikit-learn, complementado por um exemplo prático.

Passo 1: Importar Bibliotecas Necessárias




		
		
			
			
Java
			
			import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
			
				
					
				
					1
2
3
4
5
6
				
						import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, OneHotEncoder, StandardScaler
from sklearn.metrics import confusion_matrix, plot_confusion_matrix, accuracy_score
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
					
				
			
		



Passo 2: Carregar e Preparar o Dataset
Para demonstração, usaremos o dataset Weather Australia.





		
		
			
			
Java
			
			# Carregar o dataset
data = pd.read_csv('weatherAUS.csv')

# Definir features e variável alvo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]

# Tratar dados ausentes
from sklearn.impute import SimpleImputer
import numpy as np

# Features numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])

# Features categóricas
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])

# Codificação de variáveis categóricas
X = pd.get_dummies(X, drop_first=True)

# Codificar variável alvo
le = LabelEncoder()
y = le.fit_transform(y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
				
						# Carregar o dataset
data = pd.read_csv('weatherAUS.csv')
 
# Definir features e variável alvo
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
 
# Tratar dados ausentes
from sklearn.impute import SimpleImputer
import numpy as np
 
# Features numéricas
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
 
# Features categóricas
string_cols = X.select_dtypes(include=['object']).columns
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
X[string_cols] = imp_mode.fit_transform(X[string_cols])
 
# Codificação de variáveis categóricas
X = pd.get_dummies(X, drop_first=True)
 
# Codificar variável alvo
le = LabelEncoder()
y = le.fit_transform(y)
					
				
			
		



Passo 3: Dividir o Dataset




		
		
			
			
Java
			
			# Dividir em conjuntos de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
			
				
					
				
					1
2
3
4
				
						# Dividir em conjuntos de treinamento e teste
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
					
				
			
		



Passo 4: Escalonamento de Features




		
		
			
			
Java
			
			# Padronizar as features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
				
						# Padronizar as features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



Passo 5: Treinar um Modelo de Classificação
Usaremos Regressão Logística para este exemplo.





		
		
			
			
Java
			
			# Inicializar e treinar o modelo
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)

# Fazer previsões
y_pred = model.predict(X_test)
			
				
					
				
					1
2
3
4
5
6
				
						# Inicializar e treinar o modelo
model = LogisticRegression(random_state=0, max_iter=200)
model.fit(X_train, y_train)
 
# Fazer previsões
y_pred = model.predict(X_test)
					
				
			
		



Passo 6: Gerar a Matriz de Confusão




		
		
			
			
Java
			
			# Calcular acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f'Acurácia: {accuracy:.4f}')

# Gerar matriz de confusão
cm = confusion_matrix(y_test, y_pred)
print('Matriz de Confusão:')
print(cm)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Calcular acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f'Acurácia: {accuracy:.4f}')
 
# Gerar matriz de confusão
cm = confusion_matrix(y_test, y_pred)
print('Matriz de Confusão:')
print(cm)
					
				
			
		



Saída:




		
		
			
			
Java
			
			Acurácia: 0.8297
Matriz de Confusão:
[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
3
4
				
						Acurácia: 0.8297
Matriz de Confusão:
[[21087  1058]
 [ 3786  2508]]
					
				
			
		



Visualizando a Matriz de Confusão
A visualização auxilia na compreensão intuitiva do desempenho do modelo. O scikit-learn fornece funções integradas para plotar matrizes de confusão sem esforço.





		
		
			
			
Java
			
			# Plotar matriz de confusão
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusão')
plt.show()
			
				
					
				
					1
2
3
4
				
						# Plotar matriz de confusão
plot_confusion_matrix(model, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusão')
plt.show()
					
				
			
		





Figura 4: Visualização da matriz de confusão usando scikit-learn.

Interpretando Métricas de Desempenho do Modelo
Além da acurácia, a matriz de confusão permite o cálculo de várias outras métricas de desempenho:

Acurácia

    Definição: A proporção de instâncias corretamente classificadas em relação ao total de instâncias.
    Fórmula: 
      \[
      \text{Acurácia} = \frac{TP + TN}{TP + TN + FP + FN}
      \]
    
    Interpretação: Embora seja útil, a acurácia pode ser enganosa, especialmente em datasets desbalanceados.


Precisão

    Definição: A razão de observações positivas corretamente previstas em relação ao total de positivas previstas.
    Fórmula: 
      \[
      \text{Precisão} = \frac{TP}{TP + FP}
      \]
    
    Interpretação: Alta precisão indica que o algoritmo retornou substancialmente mais resultados relevantes do que irrelevantes.


Recall (Sensibilidade)

    Definição: A razão de observações positivas corretamente previstas em relação ao total de observações na classe real.
    Fórmula: 
      \[
      \text{Recall} = \frac{TP}{TP + FN}
      \]
    
    Interpretação: Alto recall indica que o algoritmo retornou a maioria dos resultados relevantes.


F1 Score

    Definição: A média ponderada de Precisão e Recall.
    Fórmula: 
      \[
      F1 = 2 \times \frac{\text{Precisão} \times \text{Recall}}{\text{Precisão} + \text{Recall}}
      \]
    
    Interpretação: O F1 score transmite o equilíbrio entre Precisão e Recall.


Especificidade

    Definição: A razão de observações negativas corretamente previstas em relação ao total de negativas reais.
    Fórmula: 
      \[
      \text{Especificidade} = \frac{TN}{TN + FP}
      \]
    
    Interpretação: Alta especificidade indica que o modelo identifica efetivamente os casos negativos.


Avançado: Tratando Matrizes de Confusão Multiclasse
Em cenários com mais de duas classes, a matriz de confusão se expande para uma grade multidimensional. Cada elemento diagonal representa as instâncias corretamente classificadas para cada classe, enquanto os elementos fora da diagonal indicam várias misclassificações.

Exemplo:
Considere um problema de classificação com três classes A, B e C.





		
		
			
			
Java
			
			               Previsto
               A    B    C
    Real A      50     2     3
           B       5    45     5
           C       2     3    48
			
				
					
				
					1
2
3
4
5
				
						               Previsto
               A    B    C
    Real A      50     2     3
           B       5    45     5
           C       2     3    48
					
				
			
		




    True Positives para a Classe A: 50
    False Positives para a Classe A: 5 (de B) + 2 (de C) = 7
    False Negatives para a Classe A: 2 (para B) + 3 (para C) = 5
    True Negatives para a Classe A: Total - (TP + FP + FN) = 100 - (50 + 7 + 5) = 38


A função confusion_matrix do scikit-learn lida perfeitamente com cenários multiclasse, fornecendo uma matriz clara que facilita uma análise detalhada do desempenho.

Implementação Prática com Dataset de Previsão do Tempo
Para solidificar os conceitos, vamos percorrer um exemplo prático usando o dataset Weather Australia. Este dataset envolve prever se vai chover no dia seguinte com base em vários atributos climáticos.

Implementação Passo a Passo

    Pré-processamento de Dados:
        
            Tratar valores ausentes usando SimpleImputer.
            Codificar variáveis categóricas usando codificação one-hot.
            Codificar a variável alvo usando LabelEncoder.
        
    
    Escalonamento de Features:
        
            Padronizar as features para garantir que cada uma contribua igualmente para o desempenho do modelo.
        
    
    Treinamento do Modelo:
        
            Treinar múltiplos modelos de classificação como K-Nearest Neighbors, Regressão Logística, Gaussian Naive Bayes, Support Vector Machines, Decision Trees, Random Forests, AdaBoost e XGBoost.
        
    
    Avaliação:
        
            Calcular as pontuações de acurácia para cada modelo.
            Gerar e visualizar matrizes de confusão para entender a distribuição das previsões.
        
    


Trechos de Código de Exemplo

Treinando um Modelo de Regressão Logística:




		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Inicializar o modelo
LRM = LogisticRegression(random_state=0, max_iter=200)

# Treinar o modelo
LRM.fit(X_train, y_train)

# Prever nos dados de teste
y_pred = LRM.predict(X_test)

# Avaliar acurácia
print(accuracy_score(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.linear_model import LogisticRegression
 
# Inicializar o modelo
LRM = LogisticRegression(random_state=0, max_iter=200)
 
# Treinar o modelo
LRM.fit(X_train, y_train)
 
# Prever nos dados de teste
y_pred = LRM.predict(X_test)
 
# Avaliar acurácia
print(accuracy_score(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.8296705228735187
			
				
					
				
					1
				
						0.8296705228735187
					
				
			
		



Gerando Matriz de Confusão:




		
		
			
			
Java
			
			from sklearn.metrics import confusion_matrix, plot_confusion_matrix

# Calcular matriz de confusão
cm = confusion_matrix(y_test, y_pred)
print(cm)

# Plotar matriz de confusão
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusão da Regressão Logística')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.metrics import confusion_matrix, plot_confusion_matrix
 
# Calcular matriz de confusão
cm = confusion_matrix(y_test, y_pred)
print(cm)
 
# Plotar matriz de confusão
plot_confusion_matrix(LRM, X_test, y_test, display_labels=le.classes_)
plt.title('Matriz de Confusão da Regressão Logística')
plt.show()
					
				
			
		



Saída:




		
		
			
			
Java
			
			[[21087  1058]
 [ 3786  2508]]
			
				
					
				
					1
2
				
						[[21087  1058]
 [ 3786  2508]]
					
				
			
		





Figura 5: Matriz de confusão para o modelo de Regressão Logística.

Acurácia Comparativa de Múltiplos Modelos:




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb

# Inicializar modelos
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Regressão Logística': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}

# Treinar e avaliar modelos
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'Acurácia {name}: {accuracy:.4f}')
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier
import xgboost as xgb
 
# Inicializar modelos
models = {
    'KNN': KNeighborsClassifier(n_neighbors=3),
    'Regressão Logística': LogisticRegression(random_state=0, max_iter=200),
    'GaussianNB': GaussianNB(),
    'SVC': SVC(),
    'Decision Tree': DecisionTreeClassifier(),
    'Random Forest': RandomForestClassifier(n_estimators=500, max_depth=5),
    'AdaBoost': AdaBoostClassifier(),
    'XGBoost': xgb.XGBClassifier(use_label_encoder=False, eval_metric='mlogloss')
}
 
# Treinar e avaliar modelos
for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f'Acurácia {name}: {accuracy:.4f}')
					
				
			
		



Saída de Exemplo:




		
		
			
			
Java
			
			KNN Acurácia: 0.8003
Regressão Logística Acurácia: 0.8297
GaussianNB Acurácia: 0.7960
SVC Acurácia: 0.8282
Decision Tree Acurácia: 0.8302
Random Forest Acurácia: 0.8302
AdaBoost Acurácia: 0.8299
XGBoost Acurácia: 0.8302
			
				
					
				
					1
2
3
4
5
6
7
8
				
						KNN Acurácia: 0.8003
Regressão Logística Acurácia: 0.8297
GaussianNB Acurácia: 0.7960
SVC Acurácia: 0.8282
Decision Tree Acurácia: 0.8302
Random Forest Acurácia: 0.8302
AdaBoost Acurácia: 0.8299
XGBoost Acurácia: 0.8302
					
				
			
		



A partir da saída, é evidente que os modelos de Decision Tree, Random Forest e XGBoost exibem a maior acurácia, seguidos de perto pela Regressão Logística e AdaBoost.

Conclusão
Matrizes de confusão são indispensáveis para avaliar o desempenho de modelos de classificação. Elas proporcionam uma visão detalhada de como os modelos se comportam em diferentes classes, destacando tanto pontos fortes quanto áreas que precisam de melhoria. Ao dominar a construção e interpretação de matrizes de confusão, juntamente com métricas complementares como precisão, recall e F1 score, os profissionais de machine learning podem desenvolver modelos mais robustos e confiáveis. Utilizar ferramentas como o scikit-learn simplifica esse processo, permitindo uma avaliação eficiente do modelo e melhoria iterativa. Conforme você continua a explorar e implementar modelos de machine learning, integrar matrizes de confusão em seu pipeline de avaliação sem dúvida aprimorará suas capacidades analíticas e a eficácia dos modelos.



Para exemplos mais detalhados e técnicas avançadas, consulte a documentação do scikit-learn sobre Matrizes de Confusão.