S19L04 – Classes de Codificação de Rótulos

html
Dominando a Codificação de Rótulos em Aprendizado de Máquina: Um Guia Abrangente

Índice

    Introdução à Codificação de Rótulos
    Entendendo o Dataset
    Tratamento de Dados Faltantes
        
            Dados Numéricos
            Dados Categóricos
        
    
    Codificação de Variáveis Categóricas
        
            One-Hot Encoding
            Label Encoding
            Selecionando a Técnica de Codificação Correta
        
    
    Seleção de Características
    Construindo e Avaliando um Modelo KNN
        
            Divisão Treinamento-Teste
            Escala de Características
            Treinamento e Avaliação do Modelo
        
    
    Visualizando Regiões de Decisão
    Conclusão




Introdução à Codificação de Rótulos

Em aprendizado de máquina, a Codificação de Rótulos é uma técnica utilizada para converter dados categóricos em formato numérico. Como muitos algoritmos não conseguem trabalhar diretamente com dados categóricos, codificar essas categorias em números torna-se uma necessidade. A codificação de rótulos atribui um inteiro único para cada categoria, facilitando a capacidade do modelo de interpretar e processar os dados de maneira eficiente.

Conceitos Chave:

    Dados Categóricos: Variáveis que representam categorias, como "Sim/Não", "Vermelho/Azul/Verde", etc.
    Codificação Numérica: O processo de converter dados categóricos em valores numéricos.




Entendendo o Dataset

Para este guia, usaremos o dataset Weather AUS obtido do Kaggle. Este dataset abrange vários atributos relacionados ao clima em diferentes localidades e datas da Austrália.

Visão Geral do Dataset:

    URL: Dataset Weather AUS
    Características: Data, Localização, métricas de Temperatura, Precipitação, detalhes de Vento, Umidade, Pressão, Cobertura de Nuvens e mais.
    Variável Alvo: RainTomorrow indicando se choveu no dia seguinte.




Tratamento de Dados Faltantes

Datasets do mundo real frequentemente contêm valores faltantes, o que pode prejudicar o desempenho dos modelos de aprendizado de máquina. Tratar adequadamente esses valores faltantes é crucial para construir modelos robustos.

Dados Numéricos

Estratégia: Imputar valores faltantes usando a média da coluna.

Implementação:





		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

# Inicializa o imputador com a estratégia de média
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Identifica colunas numéricas
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])

# Ajusta e transforma os dados
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						import numpy as np
from sklearn.impute import SimpleImputer
 
# Inicializa o imputador com a estratégia de média
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Identifica colunas numéricas
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Ajusta e transforma os dados
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



Dados Categóricos

Estratégia: Imputar valores faltantes usando a categoria mais frequente.

Implementação:





		
		
			
			
Java
			
			# Identifica colunas de string
string_cols = list(np.where((X.dtypes == object))[0])

# Inicializa o imputador com a estratégia da categoria mais frequente
imp_mean = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Ajusta e transforma os dados
imp_mean.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mean.transform(X.iloc[:, string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						# Identifica colunas de string
string_cols = list(np.where((X.dtypes == object))[0])
 
# Inicializa o imputador com a estratégia da categoria mais frequente
imp_mean = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Ajusta e transforma os dados
imp_mean.fit(X.iloc[:, string_cols])
X.iloc[:, string_cols] = imp_mean.transform(X.iloc[:, string_cols])
					
				
			
		





Codificação de Variáveis Categóricas

Após tratar os dados faltantes, o próximo passo envolve codificar variáveis categóricas para prepará-las para os algoritmos de aprendizado de máquina.

One-Hot Encoding

One-Hot Encoding transforma variáveis categóricas em um formato que pode ser fornecido a algoritmos de ML para melhorar o desempenho na predição.

Implementação:





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

def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], 
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import OneHotEncoder
 
def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        [('encoder', OneHotEncoder(), indices)], 
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
					
				
			
		



Label Encoding

Label Encoding converte cada valor de uma coluna categórica em um inteiro único. É particularmente útil para variáveis categóricas binárias.

Implementação:





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
			
				
					
				
					1
2
3
4
5
6
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
					
				
			
		



Selecionando a Técnica de Codificação Correta

Escolher entre One-Hot Encoding e Label Encoding depende da natureza dos dados categóricos.

Diretrizes:

    Categorias Binárias: Label Encoding é suficiente.
    Múltiplas Categorias: One-Hot Encoding é preferível para evitar a introdução de relações ordinais.


Implementação:





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    # Seleciona colunas de string
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Decide o método de codificação baseado em valores únicos
    for col in string_cols:
        unique_length = len(pd.unique(X[X.columns[col]]))
        if unique_length == 2 or unique_length &gt; threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    # Aplica One-Hot Encoding
    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
				
						def EncodingSelection(X, threshold=10):
    # Seleciona colunas de string
    string_cols = list(np.where((X.dtypes == object))[0])
    one_hot_encoding_indices = []
    
    # Decide o método de codificação baseado em valores únicos
    for col in string_cols:
        unique_length = len(pd.unique(X[X.columns[col]]))
        if unique_length == 2 or unique_length &gt; threshold:
            X[X.columns[col]] = LabelEncoderMethod(X[X.columns[col]])
        else:
            one_hot_encoding_indices.append(col)
            
    # Aplica One-Hot Encoding
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		





Seleção de Características

Selecionar as características mais relevantes melhora o desempenho do modelo e reduz a complexidade computacional.

Técnica: SelectKBest com Chi-Quadrado (chi2) como função de pontuação.

Implementação:





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

# Inicializa SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)

# Inicializa o Min-Max Scaler
MMS = preprocessing.MinMaxScaler()

# Escala as características
x_temp = MMS.fit_transform(X)

# Ajusta o SelectKBest
x_temp = kbest.fit(x_temp, y)

# Identifica as melhores características
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = best_features = np.argsort(x_temp.scores_)[:-K_features]

# Reduz o dataset
X = np.delete(X, features_to_delete, axis=1)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
# Inicializa SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
 
# Inicializa o Min-Max Scaler
MMS = preprocessing.MinMaxScaler()
 
# Escala as características
x_temp = MMS.fit_transform(X)
 
# Ajusta o SelectKBest
x_temp = kbest.fit(x_temp, y)
 
# Identifica as melhores características
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = best_features = np.argsort(x_temp.scores_)[:-K_features]
 
# Reduz o dataset
X = np.delete(X, features_to_delete, axis=1)
					
				
			
		





Construindo e Avaliando um Modelo KNN

Com o dataset pré-processado e as características selecionadas, prosseguimos para construir e avaliar um classificador K-Nearest Neighbors (KNN).

Divisão Treinamento-Teste

Dividir o dataset garante que o modelo seja avaliado com dados não vistos, fornecendo uma medida de sua capacidade de generalização.

Implementação:





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

# Divide os dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)

print(X_train.shape)  # Output: (113754, 12)
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.model_selection import train_test_split
 
# Divide os dados
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
 
print(X_train.shape)  # Output: (113754, 12)
					
				
			
		



Escala de Características

A escala de características padroniza o intervalo das características, o que é essencial para algoritmos como KNN que são sensíveis à escala dos dados.

Implementação:





		
		
			
			
Java
			
			from sklearn import preprocessing

# Inicializa o StandardScaler
sc = preprocessing.StandardScaler(with_mean=False)

# Ajusta e transforma os dados de treinamento
sc.fit(X_train)
X_train = sc.transform(X_train)

# Transforma os dados de teste
X_test = sc.transform(X_test)

print(X_train.shape)  # Output: (113754, 12)
print(X_test.shape)   # Output: (28439, 12)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn import preprocessing
 
# Inicializa o StandardScaler
sc = preprocessing.StandardScaler(with_mean=False)
 
# Ajusta e transforma os dados de treinamento
sc.fit(X_train)
X_train = sc.transform(X_train)
 
# Transforma os dados de teste
X_test = sc.transform(X_test)
 
print(X_train.shape)  # Output: (113754, 12)
print(X_test.shape)   # Output: (28439, 12)
					
				
			
		



Treinamento e Avaliação do Modelo

Implementação:





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

# Inicializa o classificador KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)

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

# Prediz nos dados de teste
y_pred = knnClassifier.predict(X_test)

# Avalia a acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f"Accuracy: {accuracy}")
			
				
					
				
					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
 
# Inicializa o classificador KNN
knnClassifier = KNeighborsClassifier(n_neighbors=3)
 
# Treina o modelo
knnClassifier.fit(X_train, y_train)
 
# Prediz nos dados de teste
y_pred = knnClassifier.predict(X_test)
 
# Avalia a acurácia
accuracy = accuracy_score(y_pred, y_test)
print(f"Accuracy: {accuracy}")
					
				
			
		



Output:




		
		
			
			
Java
			
			Accuracy: 0.8258
			
				
					
				
					1
				
						Accuracy: 0.8258
					
				
			
		



Uma acurácia de aproximadamente 82,58% indica que o modelo apresenta um desempenho razoável na predição de se vai chover no dia seguinte com base nas características fornecidas.



Visualizando Regiões de Decisão

Visualizar regiões de decisão pode fornecer insights sobre como o modelo KNN está fazendo previsões. Embora seja mais ilustrativo com menos características, aqui está um trecho de código de exemplo para visualização.

Implementação:





		
		
			
			
Java
			
			# Instale o mlxtend se ainda não estiver instalado
# pip install mlxtend

from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt

# Plotando regiões de decisão (Exemplo com as duas primeiras características)
plot_decision_regions(X_train[:, :2], y_train, clf=knnClassifier, legend=2)

# Adicionando rótulos aos eixos
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.title('Regiões de Decisão KNN')
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						# Instale o mlxtend se ainda não estiver instalado
# pip install mlxtend
 
from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
 
# Plotando regiões de decisão (Exemplo com as duas primeiras características)
plot_decision_regions(X_train[:, :2], y_train, clf=knnClassifier, legend=2)
 
# Adicionando rótulos aos eixos
plt.xlabel('Característica 1')
plt.ylabel('Característica 2')
plt.title('Regiões de Decisão KNN')
plt.show()
					
				
			
		



Nota: A visualização é mais eficaz com duas características. Para datasets com mais características, considere técnicas de redução de dimensionalidade como PCA antes da visualização.



Conclusão

A Codificação de Rótulos é uma técnica fundamental no arsenal de pré-processamento de dados, permitindo que modelos de aprendizado de máquina interpretem dados categóricos de maneira eficaz. Ao tratar sistematicamente dados faltantes, selecionar características relevantes e codificar adequadamente variáveis categóricas, você estabelece uma base sólida para construir modelos preditivos robustos. Incorporar essas práticas em seu fluxo de trabalho não apenas melhora o desempenho do modelo, mas também garante escalabilidade e eficiência em seus projetos de aprendizado de máquina.

Principais Pontos:

    Codificação de Rótulos transforma dados categóricos em formato numérico, essencial para algoritmos de ML.
    Tratamento de Dados Faltantes adequado pode prevenir resultados enviesados do modelo.
    Técnicas de Codificação devem ser escolhidas com base na natureza e quantidade das categorias.
    Seleção de Características melhora o desempenho do modelo eliminando características irrelevantes ou redundantes.
    Modelo KNN é influenciado pela pré-processamento adequado e escala de características.


Inicie sua jornada em aprendizado de máquina dominando essas técnicas de pré-processamento e desbloqueie o potencial para construir modelos que são tanto precisos quanto confiáveis.



Aprimore Seu Aprendizado:

    Explore mais técnicas de pré-processamento em nosso Guia Avançado de Pré-Processamento de Dados.
    Aprofunde-se em algoritmos de aprendizado de máquina com nosso Tutorial Abrangente de Modelos de ML.


Feliz Codificação!