S20L03 – Regressão Logística em Python

html
Implementando Regressão Logística em Python: Um Guia Abrangente

Desbloqueie o poder da Regressão Logística com a biblioteca Scikit-Learn do Python. Aprenda a pré-processar dados, lidar com valores faltantes, realizar seleção de características e construir modelos de classificação eficientes. Aprimore suas habilidades em aprendizado de máquina com este tutorial passo a passo.



Introdução à Regressão Logística

A Regressão Logística é um algoritmo fundamental em aprendizado de máquina, usado principalmente para tarefas de classificação binária. Ao contrário da regressão linear, que prevê resultados contínuos, a regressão logística estima a probabilidade de um resultado binário com base em uma ou mais variáveis preditoras.

Neste guia abrangente, percorreremos a implementação de um modelo de Regressão Logística em Python usando o Scikit-Learn. Abordaremos pré-processamento de dados, tratamento de valores faltantes, codificação de variáveis categóricas, seleção de características, escalonamento e avaliação de modelos. Além disso, compararemos o desempenho da Regressão Logística com o classificador K-Nearest Neighbors (KNN).

Sumário

    Entendendo a Regressão Logística
    Configurando o Ambiente
    Exploração de Dados e Pré-Processamento
    Tratamento de Dados Faltantes
    Codificação de Variáveis Categóricas
    Seleção de Características
    Escalonamento de Características
    Treinamento dos Modelos
    Avaliando o Desempenho do Modelo
    Ajuste de Hiperparâmetros
    Conclusão


Entendendo a Regressão Logística

A Regressão Logística é um modelo linear usado para tarefas de classificação. Ela prevê a probabilidade de que uma determinada entrada pertença a uma classe específica. A saída é transformada usando a função logística (sigmoid), que garante que os valores de saída estejam entre 0 e 1.

Características Principais:

    Classificação Binária: Ideal para cenários onde a variável alvo possui duas classes.
    Estimações de Probabilidade: Fornece probabilidades para o pertencimento a classes.
    Limite de Decisão Linear: Assume uma relação linear entre as características de entrada e o log-odds do resultado.


Configurando o Ambiente

Antes de mergulhar na codificação, certifique-se de ter as bibliotecas necessárias instaladas. Usaremos Pandas para manipulação de dados, NumPy para operações numéricas, Scikit-Learn para algoritmos de aprendizado de máquina e Seaborn para visualização de dados.





		
		
			
			
Java
			
			import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						import pandas as pd
import numpy as np
import seaborn as sns
from sklearn.model_selection import train_test_split
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder, LabelEncoder, StandardScaler
from sklearn.compose import ColumnTransformer
from sklearn.feature_selection import SelectKBest, chi2
from sklearn.metrics import accuracy_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
					
				
			
		



Exploração de Dados e Pré-Processamento

Para este tutorial, usaremos o Conjunto de Dados Weather Australia. Este conjunto contém registros de observações meteorológicas em várias cidades australianas.

Carregando os Dados





		
		
			
			
Java
			
			# Load the dataset
data = pd.read_csv('weatherAUS.csv')
			
				
					
				
					1
2
				
						# Load the dataset
data = pd.read_csv('weatherAUS.csv')
					
				
			
		



Dê uma olhada nas últimas linhas para entender a estrutura dos dados:





		
		
			
			
Java
			
			data.tail()
			
				
					
				
					1
				
						data.tail()
					
				
			
		



Exemplo de Saída:


    
        Data
        Localização
        MinTemp
        MaxTemp
        Rainfall
        Evaporation
        ...
        RainToday
        RISK_MM
        RainTomorrow
    
    
        2017-06-20
        Uluru
        3.5
        21.8
        0.0
        NaN
        ...
        Não
        0.0
        Não
    
    
        2017-06-21
        Uluru
        2.8
        23.4
        0.0
        NaN
        ...
        Não
        0.0
        Não
    
    
        2017-06-22
        Uluru
        3.6
        25.3
        0.0
        NaN
        ...
        Não
        0.0
        Não
    
    
        2017-06-23
        Uluru
        5.4
        26.9
        0.0
        NaN
        ...
        Não
        0.0
        Não
    
    
        2017-06-24
        Uluru
        7.8
        27.0
        0.0
        NaN
        ...
        Não
        0.0
        Não
    


Separando Características e Variável Alvo





		
		
			
			
Java
			
			# Features
X = data.iloc[:, :-1]

# Target variable
y = data.iloc[:, -1]
			
				
					
				
					1
2
3
4
5
				
						# Features
X = data.iloc[:, :-1]
 
# Target variable
y = data.iloc[:, -1]
					
				
			
		



Tratamento de uma Requisito Específico do Conjunto de Dados:

Se você estiver trabalhando exclusivamente com o conjunto de dados Weather Australia, pode ser necessário remover colunas específicas:





		
		
			
			
Java
			
			X.drop('RISK_MM', axis=1, inplace=True)
			
				
					
				
					1
				
						X.drop('RISK_MM', axis=1, inplace=True)
					
				
			
		



Tratamento de Dados Faltantes

Conjuntos de dados do mundo real frequentemente contêm valores faltantes. O tratamento adequado é crucial para garantir a precisão do modelo.

Tratamento de Dados Numéricos

Usaremos o SimpleImputer do Scikit-Learn para substituir valores numéricos faltantes pela média de cada coluna.





		
		
			
			
Java
			
			from sklearn.impute import SimpleImputer

# Identify numerical columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns

# Initialize the imputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Fit and transform the data
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.impute import SimpleImputer
 
# Identify numerical columns
numerical_cols = X.select_dtypes(include=['int64', 'float64']).columns
 
# Initialize the imputer
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Fit and transform the data
X[numerical_cols] = imp_mean.fit_transform(X[numerical_cols])
					
				
			
		



Tratamento de Dados Categóricos

Para variáveis categóricas, substituiremos os valores faltantes pela categoria mais frequente.





		
		
			
			
Java
			
			# Identify string columns
string_cols = X.select_dtypes(include=['object']).columns

# Initialize the imputer
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Fit and transform the data
X[string_cols] = imp_mode.fit_transform(X[string_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Identify string columns
string_cols = X.select_dtypes(include=['object']).columns
 
# Initialize the imputer
imp_mode = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Fit and transform the data
X[string_cols] = imp_mode.fit_transform(X[string_cols])
					
				
			
		



Codificação de Variáveis Categóricas

Modelos de aprendizado de máquina requerem entrada numérica. Transformaremos variáveis categóricas usando Codificação One-Hot e Codificação de Rótulos (Label Encoding) com base no número de categorias únicas.

Codificação One-Hot

Ideal para variáveis categóricas com um pequeno número de categorias únicas.





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

one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() <= 10]
X = OneHotEncoderMethod(one_hot_indices, X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						def OneHotEncoderMethod(indices, data):
    columnTransformer = ColumnTransformer(
        transformers=[('encoder', OneHotEncoder(), indices)],
        remainder='passthrough'
    )
    return columnTransformer.fit_transform(data)
 
one_hot_indices = [X.columns.get_loc(col) for col in string_cols if X[col].nunique() <= 10]
X = OneHotEncoderMethod(one_hot_indices, X)
					
				
			
		



Codificação de Rótulos (Label Encoding)

Adequado para variáveis categóricas binárias.





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

binary_cols = [col for col in string_cols if X[col].nunique() == 2]
for col in binary_cols:
    X[col] = LabelEncoderMethod(X[col])
			
				
					
				
					1
2
3
4
5
6
7
				
						def LabelEncoderMethod(series):
    le = LabelEncoder()
    return le.fit_transform(series)
 
binary_cols = [col for col in string_cols if X[col].nunique() == 2]
for col in binary_cols:
    X[col] = LabelEncoderMethod(X[col])
					
				
			
		



Seleção de Codificação para X

Para variáveis categóricas com mais de duas categorias (e acima de um determinado limite), usaremos Codificação de Rótulos (Label Encoding). Caso contrário, aplicaremos Codificação One-Hot.





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_count = X[col].nunique()
        if unique_count == 2 or unique_count &gt; threshold:
            X[col] = LabelEncoderMethod(X[col])
        else:
            one_hot_encoding_indices.append(X.columns.get_loc(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
				
						def EncodingSelection(X, threshold=10):
    string_cols = X.select_dtypes(include=['object']).columns
    one_hot_encoding_indices = []
    
    for col in string_cols:
        unique_count = X[col].nunique()
        if unique_count == 2 or unique_count &gt; threshold:
            X[col] = LabelEncoderMethod(X[col])
        else:
            one_hot_encoding_indices.append(X.columns.get_loc(col))
    
    X = OneHotEncoderMethod(one_hot_encoding_indices, X)
    return X
 
X = EncodingSelection(X)
					
				
			
		



Seleção de Características

Para melhorar o desempenho do modelo e reduzir o overfitting, selecionaremos as principais características usando o teste do Qui-Quadrado (Chi-Squared).





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

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

# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)

# Fit SelectKBest
kbest.fit(X_scaled, y)

# Get top features
best_features = np.argsort(kbest.scores_)[-2:]  # Selecting top 2 features
features_to_delete = np.argsort(kbest.scores_)[:-2]
X = np.delete(X, features_to_delete, axis=1)

print(f"Shape after feature selection: {X.shape}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Initialize SelectKBest
kbest = SelectKBest(score_func=chi2, k=10)
 
# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Fit SelectKBest
kbest.fit(X_scaled, y)
 
# Get top features
best_features = np.argsort(kbest.scores_)[-2:]  # Selecting top 2 features
features_to_delete = np.argsort(kbest.scores_)[:-2]
X = np.delete(X, features_to_delete, axis=1)
 
print(f"Shape after feature selection: {X.shape}")
					
				
			
		



Saída:





		
		
			
			
Java
			
			Shape after feature selection: (142193, 2)
			
				
					
				
					1
				
						Shape after feature selection: (142193, 2)
					
				
			
		



Escalonamento de Características

O escalonamento garante que todas as características contribuam igualmente para o desempenho do modelo.

Padronização

Transforma os dados para que tenham uma média de zero e um desvio padrão de um.





		
		
			
			
Java
			
			from sklearn.preprocessing import StandardScaler

sc = StandardScaler(with_mean=False)
sc.fit(X_train)

X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.preprocessing import StandardScaler
 
sc = StandardScaler(with_mean=False)
sc.fit(X_train)
 
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
					
				
			
		



Treinamento dos Modelos

Vamos comparar dois modelos de classificação: K-Nearest Neighbors (KNN) e Regressão Logística.

Divisão de Treinamento e Teste

Dividir os dados em conjuntos de treinamento e teste garante que possamos avaliar efetivamente o desempenho do modelo.





		
		
			
			
Java
			
			from sklearn.model_selection import train_test_split

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

print(f"Training set shape: {X_train.shape}")
print(f"Testing set shape: {X_test.shape}")
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.model_selection import train_test_split
 
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.20, random_state=1
)
 
print(f"Training set shape: {X_train.shape}")
print(f"Testing set shape: {X_test.shape}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			Training set shape: (113754, 2)
Testing set shape: (28439, 2)
			
				
					
				
					1
2
				
						Training set shape: (113754, 2)
Testing set shape: (28439, 2)
					
				
			
		



K-Nearest Neighbors (KNN)

O KNN é um algoritmo de aprendizado simples, baseado em instâncias, usado para classificação e regressão.





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

# Initialize KNN with 3 neighbors
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)

# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
# Initialize KNN with 3 neighbors
knnClassifier = KNeighborsClassifier(n_neighbors=3)
knnClassifier.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_knn = knnClassifier.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f"KNN Accuracy: {knn_accuracy:.2%}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			KNN Accuracy: 80.03%
			
				
					
				
					1
				
						KNN Accuracy: 80.03%
					
				
			
		



Regressão Logística

Um algoritmo poderoso para tarefas de classificação binária, a Regressão Logística estima a probabilidade de um resultado binário.





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Initialize Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)

# Predict and evaluate
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.linear_model import LogisticRegression
 
# Initialize Logistic Regression
LRM = LogisticRegression(random_state=0, max_iter=200)
LRM.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_lr = LRM.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f"Logistic Regression Accuracy: {lr_accuracy:.2%}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			Logistic Regression Accuracy: 82.97%
			
				
					
				
					1
				
						Logistic Regression Accuracy: 82.97%
					
				
			
		



Avaliando o Desempenho do Modelo

Tanto o KNN quanto a Regressão Logística oferecem uma precisão substancial no conjunto de dados, mas a Regressão Logística supera o KNN neste cenário.


    
        Modelo
        Precisão
    
    
        K-Nearest Neighbors
        80.03%
    
    
        Regressão Logística
        82.97%
    


Ajuste de Hiperparâmetros

Otimizar hiperparâmetros pode aprimorar ainda mais o desempenho do modelo. Para a Regressão Logística, parâmetros como C (inverso da força da regularização) e solver podem ser ajustados. Da mesma forma, o n_neighbors do KNN pode ser variado.

Exemplo: GridSearchCV para Regressão Logística





		
		
			
			
Java
			
			from sklearn.model_selection import GridSearchCV

# Define parameter grid
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear', 'lbfgs']
}

# Initialize GridSearchCV
grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)
grid.fit(X_train, y_train)

print(f"Best Parameters: {grid.best_params_}")
print(f"Best Cross-Validation Accuracy: {grid.best_score_:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.model_selection import GridSearchCV
 
# Define parameter grid
param_grid = {
    'C': [0.01, 0.1, 1, 10, 100],
    'solver': ['liblinear', 'lbfgs']
}
 
# Initialize GridSearchCV
grid = GridSearchCV(LogisticRegression(max_iter=200), param_grid, cv=5)
grid.fit(X_train, y_train)
 
print(f"Best Parameters: {grid.best_params_}")
print(f"Best Cross-Validation Accuracy: {grid.best_score_:.2%}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			Best Parameters: {'C': 1, 'solver': 'lbfgs'}
Best Cross-Validation Accuracy: 83.25%
			
				
					
				
					1
2
				
						Best Parameters: {'C': 1, 'solver': 'lbfgs'}
Best Cross-Validation Accuracy: 83.25%
					
				
			
		



Implementando os Melhores Parâmetros:





		
		
			
			
Java
			
			# Initialize Logistic Regression with best parameters
best_lr = grid.best_estimator_
best_lr.fit(X_train, y_train)

# Predict and evaluate
y_pred_best_lr = best_lr.predict(X_test)
best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)
print(f"Optimized Logistic Regression Accuracy: {best_lr_accuracy:.2%}")
			
				
					
				
					1
2
3
4
5
6
7
8
				
						# Initialize Logistic Regression with best parameters
best_lr = grid.best_estimator_
best_lr.fit(X_train, y_train)
 
# Predict and evaluate
y_pred_best_lr = best_lr.predict(X_test)
best_lr_accuracy = accuracy_score(y_pred_best_lr, y_test)
print(f"Optimized Logistic Regression Accuracy: {best_lr_accuracy:.2%}")
					
				
			
		



Saída:




		
		
			
			
Java
			
			Optimized Logistic Regression Accuracy: 83.00%
			
				
					
				
					1
				
						Optimized Logistic Regression Accuracy: 83.00%
					
				
			
		



Conclusão

Neste guia, implementamos com sucesso um modelo de Regressão Logística em Python, demonstrando todo o pipeline de aprendizado de máquina desde o pré-processamento de dados até a avaliação do modelo. Ao tratar dados faltantes, codificar variáveis categóricas, selecionar características relevantes e escalar, otimizamos o conjunto de dados para um desempenho superior do modelo. Além disso, comparando a Regressão Logística com o KNN, destacamos os pontos fortes de cada algoritmo, com a Regressão Logística superando ligeiramente neste contexto.

Principais Pontos:

    Pré-Processamento de Dados: Crucial para alcançar alta precisão do modelo.
    Seleção de Características: Ajuda a reduzir o overfitting e melhorar o desempenho.
    Comparação de Modelos: Sempre compare múltiplos modelos para identificar o melhor desempenho.
    Ajuste de Hiperparâmetros: Essencial para otimizar o desempenho do modelo.


Adote essas técnicas para construir modelos de classificação robustos e eficientes, adaptados aos seus conjuntos de dados e requisitos específicos.



Palavras-chave: Regressão Logística, Python, Scikit-Learn, Aprendizado de Máquina, Pré-Processamento de Dados, Modelos de Classificação, K-Nearest Neighbors, Seleção de Características, Ajuste de Hiperparâmetros, Tutorial de Ciência de Dados

Descrição Meta: Aprenda como implementar Regressão Logística em Python com Scikit-Learn. Este guia abrangente cobre pré-processamento de dados, tratamento de valores faltantes, seleção de características e avaliação de modelos, comparando Regressão Logística com KNN para desempenho ideal.
Data	Localização	MinTemp	MaxTemp	Evaporation	...	RainToday	RainTomorrow
2017-06-20	Uluru	3.5	21.8	NaN	...	Não	Não
2017-06-21	Uluru	2.8	23.4	NaN	...	Não	Não
2017-06-22	Uluru	3.6	25.3	NaN	...	Não	Não
2017-06-23	Uluru	5.4	26.9	NaN	...	Não	Não
2017-06-24	Uluru	7.8	27.0	NaN	...	Não	Não