S19L05 – KNN em classificação multiclasse

html
Dominando a Classificação Multiclasse com K-Nearest Neighbors (KNN): Um Guia Abrangente

Índice

    Introdução à Classificação
    Classificação Binária vs. Multiclasse
    Entendendo K-Nearest Neighbors (KNN)
    Implementando KNN para Classificação Multiclasse
    
        Estudo de Caso: Classificando Gêneros de Música Bangla
        
            Visão Geral do Conjunto de Dados
            Etapas de Pré-processamento de Dados
                
                    Tratamento de Dados Faltantes
                    Codificação de Variáveis Categóricas
                    Seleção de Características
                    Escalonamento de Características
                
            
        
    
    Construindo e Avaliando o Modelo KNN
    Conclusão
    Perguntas Frequentes




Introdução à Classificação
A classificação é uma técnica de aprendizado supervisionado onde o objetivo é prever rótulos categóricos para dados de entrada fornecidos. É amplamente utilizada em várias aplicações, como detecção de spam em e-mails, reconhecimento de imagens, diagnóstico médico e muito mais. As tarefas de classificação podem ser amplamente categorizadas em dois tipos: classificação binária e classificação multiclasse.

Classificação Binária vs. Multiclasse

    Classificação Binária: Isso envolve categorizar dados em duas classes distintas. Por exemplo, determinar se um e-mail é spam ou não spam.
    Classificação Multiclasse: Isso estende a classificação binária para cenários onde há mais de duas classes. Por exemplo, classificar diferentes gêneros de música ou tipos de veículos.

Entender a diferença é crucial, pois influencia a escolha dos algoritmos e as métricas de avaliação.

Entendendo K-Nearest Neighbors (KNN)
K-Nearest Neighbors (KNN) é um algoritmo de aprendizado de máquina simples, mas potente, utilizado tanto para tarefas de classificação quanto de regressão. Aqui está uma análise de como o KNN funciona:

    Aprendizado Baseado em Instâncias: O KNN não constrói um modelo explícito. Em vez disso, ele memoriza o conjunto de dados de treinamento.
    Medição de Distância: Para fazer uma previsão, o KNN calcula a distância entre o novo ponto de dados e todos os pontos no conjunto de treinamento.
    Mecanismo de Votação: Para classificação, o KNN seleciona os 'k' vizinhos mais próximos e atribui a classe mais comum dentre eles ao novo ponto de dados.
    Escolha de 'k': O número de vizinhos, 'k', é um hiperparâmetro crucial. Um 'k' pequeno pode tornar o modelo sensível ao ruído, enquanto um 'k' grande pode suavizar os limites de decisão.

O KNN é particularmente eficaz para classificação multiclasse devido à sua habilidade inerente de lidar com múltiplas classes por meio da votação.

Implementando KNN para Classificação Multiclasse
Implementar o KNN para classificação multiclasse envolve várias etapas, incluindo pré-processamento de dados, seleção de características, escalonamento e avaliação do modelo. Vamos explorar essas etapas através de um estudo de caso prático.

Estudo de Caso: Classificando Gêneros de Música Bangla
Nesta seção, vamos percorrer uma implementação prática de classificação multiclasse usando KNN em um conjunto de dados de música Bangla. O objetivo é categorizar músicas em diferentes gêneros com base em várias características de áudio.

Visão Geral do Conjunto de Dados
O Conjunto de Dados de Música Bangla compreende dados de 1.742 músicas categorizadas em seis gêneros distintos. Cada música é descrita usando 31 características, incluindo atributos de áudio como taxa de cruzamento por zero, centróide espectral, frequência de cromas e MFCCs (Coeficientes Cepstrais de Frequência Mel).
Características Principais:

    Características Numéricas: Como taxa de cruzamento por zero, centróide espectral, rolloff espectral, etc.
    Características Categóricas: Nomes de arquivos e rótulos indicando o gênero.

Variável Alvo: O rótulo do gênero (label) indicando a categoria musical.

Etapas de Pré-processamento de Dados
O pré-processamento de dados é uma etapa crítica nos fluxos de trabalho de aprendizado de máquina. Um pré-processamento adequado garante que os dados estejam limpos, consistentes e adequados para o treinamento do modelo.

Tratamento de Dados Faltantes
Por que Isso Importa: Dados faltantes podem distorcer os resultados e reduzir a eficácia do modelo. É essencial tratar valores faltantes para manter a integridade dos dados.
Etapas:

    Dados Numéricos:
        
            Utilize a estratégia de Imputação pela Média para preencher valores faltantes.
            Implementado usando SimpleImputer com strategy='mean'.
        
    
    Dados Categóricos:
        
            Utilize a estratégia de Imputação pelo Valor Mais Frequente para preencher valores faltantes.
            Implementado usando SimpleImputer com strategy='most_frequent'.
        
    

Implementação em Python:




		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

# Tratando dados numéricos
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])

# Tratando dados categóricos
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
string_cols = list(np.where((X.dtypes == object))[0])
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Tratando dados numéricos
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
 
# Tratando dados categóricos
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
string_cols = list(np.where((X.dtypes == object))[0])
imp_freq.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_freq.transform(X.iloc[:, string_cols])
					
				
			
		



Codificação de Variáveis Categóricas
Por que Isso Importa: Modelos de aprendizado de máquina requerem entrada numérica. Variáveis categóricas precisam ser convertidas em formato numérico.
Dois Principais Métodos de Codificação:

    Codificação de Rótulo:
        
            Atribui um inteiro único para cada categoria.
            Adequado para variáveis categóricas binárias ou ordinais.
        
    
    Codificação One-Hot:
        
            Criam colunas binárias para cada categoria.
            Adequado para variáveis categóricas nominais com mais de duas categorias.
        
    

Estratégia de Codificação:

    Categorias com Duas Classes ou Mais do que um Limite: Aplicar codificação de rótulo.
    Outras Categorias: Aplicar codificação one-hot.

Implementação em Python:




		
		
			
			
Java
			
			from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Função de Codificação de Rótulo
def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)

# Função de Codificação One-Hot
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')
    return columnTransformer.fit_transform(data)

# Função de Seleção de Codificação
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 ou 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

# Aplicar Seleção de Codificação
X = EncodingSelection(X)
			
				
					
				
					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
28
29
30
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder
 
# Função de Codificação de Rótulo
def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
# Função de Codificação One-Hot
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer([('encoder', OneHotEncoder(), indices)], remainder='passthrough')
    return columnTransformer.fit_transform(data)
 
# Função de Seleção de Codificação
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 ou 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
 
# Aplicar Seleção de Codificação
X = EncodingSelection(X)
					
				
			
		



Seleção de Características
Por que Isso Importa: Selecionar as características certas melhora o desempenho do modelo eliminando dados irrelevantes ou redundantes, reduzindo o overfitting e melhorando a eficiência computacional.
Método de Seleção de Características Utilizado:

    SelectKBest com Teste Qui-Quadrado:
        
            Evalúa a relação entre cada característica e a variável alvo.
            Seleciona as 'k' principais características com os maiores pontuações.
        
    

Implementação em Python:




		
		
			
			
Java
			
			from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler

# Inicializar SelectKBest
kbest = SelectKBest(score_func=chi2, k=12)
scaler = MinMaxScaler()

# Fit e transformar os dados
X_scaled = scaler.fit_transform(X)
kbest.fit(X_scaled, y)

# Obter as melhores características
best_features = np.argsort(kbest.scores_)[-12:]
features_to_delete = np.argsort(kbest.scores_)[:-12]
X = np.delete(X, features_to_delete, axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Inicializar SelectKBest
kbest = SelectKBest(score_func=chi2, k=12)
scaler = MinMaxScaler()
 
# Fit e transformar os dados
X_scaled = scaler.fit_transform(X)
kbest.fit(X_scaled, y)
 
# Obter as melhores características
best_features = np.argsort(kbest.scores_)[-12:]
features_to_delete = np.argsort(kbest.scores_)[:-12]
X = np.delete(X, features_to_delete, axis=1)
					
				
			
		



Escalonamento de Características
Por que Isso Importa: Escalonar garante que todas as características contribuam igualmente para os cálculos de distância no KNN, evitando que características com escalas maiores dominem.
Método de Escalonamento Utilizado:

    Padronização:
        
            Transforma os dados para terem média zero e desvio padrão de um.
            Implementado usando StandardScaler.
        
    

Implementação em Python:




		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split

# Dividir o conjunto de dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)

# Inicializar e ajustar o escalonador
scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)

# Transformar os dados
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
 
# Dividir o conjunto de dados
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=1)
 
# Inicializar e ajustar o escalonador
scaler = StandardScaler(with_mean=False)
scaler.fit(X_train)
 
# Transformar os dados
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



Construindo e Avaliando o Modelo KNN
Com os dados pré-processados e preparados, o próximo passo é construir o modelo KNN e avaliar seu desempenho.

Treinamento do Modelo
Etapas:

    Inicializar o Classificador KNN:
        
            Defina o número de vizinhos (k=8 neste caso).
        
    
    Treinar o Modelo:
        
            Ajuste o classificador KNN nos dados de treinamento.
        
    
    Prever:
        
            Use o modelo treinado para fazer previsões no conjunto de teste.
        
    
    Avaliar:
        
            Calcule a métrica de acurácia para avaliar o desempenho do modelo.
        
    

Implementação em Python:




		
		
			
			
Java
			
			from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Inicializar KNN com k=8
knnClassifier = KNeighborsClassifier(n_neighbors=8)

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

# Fazer previsões
y_pred = knnClassifier.predict(X_test)

# Avaliar acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f"Model Accuracy: {accuracy:.2f}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
# Inicializar KNN com k=8
knnClassifier = KNeighborsClassifier(n_neighbors=8)
 
# Treinar o modelo
knnClassifier.fit(X_train, y_train)
 
# Fazer previsões
y_pred = knnClassifier.predict(X_test)
 
# Avaliar acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f"Model Accuracy: {accuracy:.2f}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			Model Accuracy: 0.68
			
				
					
				
					1
				
						Model Accuracy: 0.68
					
				
			
		



Interpretação: O modelo KNN alcançou uma acurácia de aproximadamente 68%, indicando que classificou corretamente 68% das músicas no conjunto de teste.

Ajuste de Hiperparâmetros
Ajustar o número de vizinhos ('k') pode impactar significativamente o desempenho do modelo. É aconselhável experimentar com diferentes valores de 'k' para encontrar o equilíbrio ótimo entre viés e variância.




		
		
			
			
Java
			
			# Experimente com diferentes valores de k
for k in range(3, 21, 2):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"k={k}, Accuracy={accuracy:.2f}")
			
				
					
				
					1
2
3
4
5
6
7
				
						# Experimente com diferentes valores de k
for k in range(3, 21, 2):
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    y_pred = knn.predict(X_test)
    accuracy = accuracy_score(y_pred, y_test)
    print(f"k={k}, Accuracy={accuracy:.2f}")
					
				
			
		



Exemplo de Saída:




		
		
			
			
Java
			
			k=3, Accuracy=0.65
k=5, Accuracy=0.66
k=7, Accuracy=0.67
k=9, Accuracy=0.68
...
k=19, Accuracy=0.65
			
				
					
				
					1
2
3
4
5
6
				
						k=3, Accuracy=0.65
k=5, Accuracy=0.66
k=7, Accuracy=0.67
k=9, Accuracy=0.68
...
k=19, Accuracy=0.65
					
				
			
		



Melhor Desempenho: Neste cenário, um valor de k=9 produziu a maior acurácia.

Conclusão
A classificação multiclasse é uma tarefa fundamental em aprendizado de máquina, permitindo a categorização de pontos de dados em múltiplas classes. O algoritmo K-Nearest Neighbors (KNN), conhecido por sua simplicidade e eficácia, revela-se um forte concorrente para tais tarefas. Através deste guia abrangente, exploramos as complexidades de implementar o KNN para classificação multiclasse, enfatizando a importância do pré-processamento de dados, seleção de características e avaliação do modelo.
Seguindo a abordagem sistemática delineada—from tratamento de dados faltantes e codificação de variáveis categóricas até a seleção de características relevantes e escalonamento—você pode aproveitar todo o potencial do KNN para seus problemas de classificação multiclasse. Lembre-se, a chave para um modelo bem-sucedido não está apenas no algoritmo, mas também na qualidade e preparação dos dados.

Perguntas Frequentes
1. Qual é a principal diferença entre classificação binária e multiclasse?
A classificação binária envolve categorizar dados em duas classes distintas, enquanto a classificação multiclasse estende isso para cenários com mais de duas classes.

2. Por que o escalonamento de características é importante para o KNN?
O KNN depende de cálculos de distância para determinar os vizinhos mais próximos. Sem o escalonamento, características com escalas maiores podem influenciar desproporcionalmente as métricas de distância, levando a previsões tendenciosas.

3. Como escolher o número ótimo de vizinhos (k) no KNN?
O k ótimo equilibra viés e variância. Normalmente, é determinado através de experimentação, como validação cruzada, para identificar o valor de 'k' que produz a maior acurácia.

4. O KNN pode lidar com dados tanto numéricos quanto categóricos?
O KNN funciona principalmente com dados numéricos. Variáveis categóricas precisam ser codificadas em formatos numéricos antes de aplicar o KNN.

5. Quais são algumas alternativas ao KNN para classificação multiclasse?
Alternativas incluem algoritmos como Support Vector Machines (SVM), Árvores de Decisão, Random Forests e Redes Neurais, cada uma com seus próprios pontos fortes e usos adequados.