S27L02 – Modelo mestre de classificação

html
Dominando Modelos de Classificação: Um Guia Abrangente com Técnicas de Avaliação e Manipulação de Conjuntos de Dados

Introdução

No reino do aprendizado de máquina, os modelos de classificação desempenham um papel fundamental na previsão de resultados categóricos. Seja distinguindo entre e-mails de spam e não spam, diagnosticando doenças ou determinando a satisfação do cliente, os algoritmos de classificação fornecem a espinha dorsal para a tomada de decisões informadas. Neste artigo, aprofundaremos na construção de modelos de classificação robustos usando o poderoso ecossistema do Python, com foco em pré-processamento de dados, treinamento de modelos, avaliação e manipulação de conjuntos de dados diversos. Nós o guiaremos através de um Notebook Jupyter abrangente que serve como um modelo mestre para tarefas de classificação, equipado com métricas de avaliação e adaptabilidade para diferentes conjuntos de dados.



Índice


    Entendendo o Conjunto de Dados
    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 Modelos de Classificação
        
            Classificador K-Vizinhos Mais Próximos (KNN)
            Regressão Logística
            Naive Bayes Gaussiano (GaussianNB)
            Máquina de Vetores de Suporte (SVM)
            Classificador de Árvore de Decisão
            Classificador de Floresta Aleatória
            Classificador AdaBoost
            Classificador XGBoost
        
    
    Conclusão




Entendendo o Conjunto de Dados

Antes de mergulhar na construção do modelo, é crucial entender o conjunto de dados em questão. Para este guia, utilizaremos o conjunto de dados Satisfação dos Passageiros da Companhia Aérea do Kaggle. Este conjunto de dados abrange vários fatores que influenciam a satisfação dos passageiros, tornando-o ideal para tarefas de classificação.

Carregando os Dados

Começaremos importando as bibliotecas necessárias e carregando o conjunto de dados em um DataFrame do pandas.





		
		
			
			
Java
			
			import pandas as pd
import seaborn as sns

# Carregar conjuntos de dados
data1 = pd.read_csv('Airline1.csv')
data2 = pd.read_csv('Airline2.csv')

# Concatenar conjuntos de dados
data = pd.concat([data1, data2])
print(data.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import pandas as pd
import seaborn as sns
 
# Carregar conjuntos de dados
data1 = pd.read_csv('Airline1.csv')
data2 = pd.read_csv('Airline2.csv')
 
# Concatenar conjuntos de dados
data = pd.concat([data1, data2])
print(data.shape)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(129880, 25)
			
				
					
				
					1
				
						(129880, 25)
					
				
			
		



Isso indica que temos 129.880 registros com 25 características cada.



Pré-processamento de Dados

O pré-processamento de dados é a pedra angular para um desempenho eficaz do modelo. Envolve a limpeza dos dados, tratamento de valores faltantes, codificação de variáveis categóricas, seleção de características relevantes e escalonamento dos dados para garantir consistência.

Tratamento de Dados Faltantes

Dados Numéricos:

Para colunas numéricas, empregaremos a imputação da média para preencher valores faltantes.





		
		
			
			
Java
			
			import numpy as np
from sklearn.impute import SimpleImputer

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

# Inicializar imputador
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')

# Ajustar e transformar
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
 
# Identificar colunas numéricas
numerical_cols = list(np.where((X.dtypes == np.int64) | (X.dtypes == np.float64))[0])
 
# Inicializar imputador
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
 
# Ajustar e transformar
imp_mean.fit(X.iloc[:, numerical_cols])
X.iloc[:, numerical_cols] = imp_mean.transform(X.iloc[:, numerical_cols])
					
				
			
		



Dados Categóricos:

Para colunas categóricas, usaremos a estratégia da frequência mais alta para imputar valores faltantes.





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

# Inicializar imputador
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')

# Ajustar e transformar
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
				
						# Identificar colunas string/object
string_cols = list(np.where((X.dtypes == np.object))[0])
 
# Inicializar imputador
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
 
# Ajustar e transformar
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

Modelos de aprendizado de máquina requerem entradas numéricas. Portanto, variáveis categóricas devem ser codificadas adequadamente.

Codificação de Rótulos:

Para variáveis categóricas binárias ou aquelas com um grande número de categorias, a codificação de rótulos é eficiente.





		
		
			
			
Java
			
			from sklearn import preprocessing

def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)

# Codificar variável alvo
y = LabelEncoderMethod(y)
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						from sklearn import preprocessing
 
def LabelEncoderMethod(series):
    le = preprocessing.LabelEncoder()
    le.fit(series)
    return le.transform(series)
 
# Codificar variável alvo
y = LabelEncoderMethod(y)
					
				
			
		



Codificação One-Hot:

Para variáveis categóricas com um número limitado de categorias, a codificação one-hot evita que o modelo interprete relações numéricas onde não existem.





		
		
			
			
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
				
						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)
					
				
			
		



Seleção de Codificação:

Para otimizar estratégias de codificação com base no número de categorias, implementamos um mecanismo de seleção.





		
		
			
			
Java
			
			def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == np.object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 ou length > 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)
print(X.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
				
						def EncodingSelection(X, threshold=10):
    string_cols = list(np.where((X.dtypes == np.object))[0])
    one_hot_encoding_indices = []
    
    for col in string_cols:
        length = len(pd.unique(X[X.columns[col]]))
        if length == 2 ou length > 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)
print(X.shape)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(129880, 26)
			
				
					
				
					1
				
						(129880, 26)
					
				
			
		



Seleção de Características

Selecionar as características mais relevantes melhora o desempenho do modelo e reduz a complexidade computacional. Usaremos o teste Qui-Quadrado para seleção de características.





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

# Inicializar
kbest = SelectKBest(score_func=chi2, k='all')
MMS = preprocessing.MinMaxScaler()
K_features = 10

# Aplicar transformações
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)

# Selecionar as top K características
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = np.argsort(x_temp.scores_)[:-K_features]
X = np.delete(X, features_to_delete, axis=1)
print(X.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn import preprocessing
 
# Inicializar
kbest = SelectKBest(score_func=chi2, k='all')
MMS = preprocessing.MinMaxScaler()
K_features = 10
 
# Aplicar transformações
x_temp = MMS.fit_transform(X)
x_temp = kbest.fit(x_temp, y)
 
# Selecionar as top K características
best_features = np.argsort(x_temp.scores_)[-K_features:]
features_to_delete = np.argsort(x_temp.scores_)[:-K_features]
X = np.delete(X, features_to_delete, axis=1)
print(X.shape)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(129880, 10)
			
				
					
				
					1
				
						(129880, 10)
					
				
			
		



Escalonamento de Características

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





		
		
			
			
Java
			
			from sklearn import preprocessing

# Inicializar escalador
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)

# Transformar características
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)

print(X_train.shape)
print(X_test.shape)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						from sklearn import preprocessing
 
# Inicializar escalador
sc = preprocessing.StandardScaler(with_mean=False)
sc.fit(X_train)
 
# Transformar características
X_train = sc.transform(X_train)
X_test = sc.transform(X_test)
 
print(X_train.shape)
print(X_test.shape)
					
				
			
		



Saída:




		
		
			
			
Java
			
			(103904, 10)
(25976, 10)
			
				
					
				
					1
2
				
						(103904, 10)
(25976, 10)
					
				
			
		





Construindo e Avaliando Modelos de Classificação

Com os dados pré-processados, agora podemos construir e avaliar vários modelos de classificação. Exploraremos múltiplos algoritmos para comparar seu desempenho.

Classificador K-Vizinhos Mais Próximos (KNN)

KNN é um algoritmo simples, porém eficaz, que classifica pontos de dados com base no rótulo majoritário de seus vizinhos mais próximos.





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

# Inicializar e treinar
knnClassifier = KNeighborsClassifier(n_neighbors=10)
knnClassifier.fit(X_train, y_train)

# Prever e avaliar
y_pred = knnClassifier.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test, target_names=['Não', 'Sim']))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report
 
# Inicializar e treinar
knnClassifier = KNeighborsClassifier(n_neighbors=10)
knnClassifier.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = knnClassifier.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test, target_names=['Não', 'Sim']))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.932668617185094
              precision    recall  f1-score   support

           Não       0.96      0.92      0.94     15395
          Sim       0.90      0.94      0.92     10581

    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.932668617185094
              precision    recall  f1-score   support
 
           Não       0.96      0.92      0.94     15395
          Sim       0.90      0.94      0.92     10581
 
    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretação:
O classificador KNN alcança uma alta acurácia de 93,27%, indicando um excelente desempenho na previsão da satisfação dos passageiros.

Regressão Logística

Regressão Logística modela a probabilidade de um resultado binário, tornando-a ideal para tarefas de classificação.





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

# Inicializar e treinar
LRM = LogisticRegression()
LRM.fit(X_train, y_train)

# Prever e avaliar
y_pred = LRM.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.linear_model import LogisticRegression
 
# Inicializar e treinar
LRM = LogisticRegression()
LRM.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = LRM.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.8557129658145981
              precision    recall  f1-score   support

           Não       0.88      0.87      0.87     15068
          Sim       0.82      0.84      0.83     10908

    accuracy                           0.86     25976
   macro avg       0.85      0.85      0.85     25976
weighted avg       0.86      0.86      0.86     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.8557129658145981
              precision    recall  f1-score   support
 
           Não       0.88      0.87      0.87     15068
          Sim       0.82      0.84      0.83     10908
 
    accuracy                           0.86     25976
   macro avg       0.85      0.85      0.85     25976
weighted avg       0.86      0.86      0.86     25976
					
				
			
		



Interpretação:
A Regressão Logística produz uma acurácia de 85,57%, ligeiramente inferior à do KNN, mas ainda respeitável para comparações de linha de base.

Naive Bayes Gaussiano (GaussianNB)

GaussianNB é um classificador probabilístico baseado no Teorema de Bayes, assumindo independência das características.





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

# Inicializar e treinar
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_GNB.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.naive_bayes import GaussianNB
 
# Inicializar e treinar
model_GNB = GaussianNB()
model_GNB.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_GNB.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.828688019710502
              precision    recall  f1-score   support

           Não       0.84      0.85      0.85     14662
          Sim       0.81      0.80      0.80     11314

    accuracy                           0.83     25976
   macro avg       0.83      0.82      0.83     25976
weighted avg       0.83      0.83      0.83     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.828688019710502
              precision    recall  f1-score   support
 
           Não       0.84      0.85      0.85     14662
          Sim       0.81      0.80      0.80     11314
 
    accuracy                           0.83     25976
   macro avg       0.83      0.82      0.83     25976
weighted avg       0.83      0.83      0.83     25976
					
				
			
		



Interpretação:
GaussianNB alcança uma acurácia de 82,87%, demonstrando sua eficácia apesar de suas suposições subjacentes simples.

Máquina de Vetores de Suporte (SVM)

SVM cria hiperplanos para separar classes, otimizando a margem entre elas.





		
		
			
			
Java
			
			from sklearn.svm import SVC

# Inicializar e treinar
model_SVC = SVC()
model_SVC.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_SVC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.svm import SVC
 
# Inicializar e treinar
model_SVC = SVC()
model_SVC.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_SVC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.9325916230366492
              precision    recall  f1-score   support

           Não       0.95      0.93      0.94     15033
          Sim       0.91      0.93      0.92     10943

    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9325916230366492
              precision    recall  f1-score   support
 
           Não       0.95      0.93      0.94     15033
          Sim       0.91      0.93      0.92     10943
 
    accuracy                           0.93     25976
   macro avg       0.93      0.93      0.93     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretação:
SVM espelha o desempenho do KNN com uma acurácia de 93,26%, destacando sua robustez em tarefas de classificação.

Classificador de Árvore de Decisão

Árvores de Decisão dividem os dados com base nos valores das características, formando um modelo em forma de árvore de decisões.





		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

# Inicializar e treinar
model_DTC = DecisionTreeClassifier(max_leaf_nodes=25, min_samples_split=4, random_state=42)
model_DTC.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_DTC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.tree import DecisionTreeClassifier
 
# Inicializar e treinar
model_DTC = DecisionTreeClassifier(max_leaf_nodes=25, min_samples_split=4, random_state=42)
model_DTC.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_DTC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.9256621496766245
              precision    recall  f1-score   support

           Não       0.95      0.92      0.94     15213
          Sim       0.90      0.93      0.91     10763

    accuracy                           0.93     25976
   macro avg       0.92      0.93      0.92     25976
weighted avg       0.93      0.93      0.93     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9256621496766245
              precision    recall  f1-score   support
 
           Não       0.95      0.92      0.94     15213
          Sim       0.90      0.93      0.91     10763
 
    accuracy                           0.93     25976
   macro avg       0.92      0.93      0.92     25976
weighted avg       0.93      0.93      0.93     25976
					
				
			
		



Interpretação:
O Classificador de Árvore de Decisão registra uma acurácia de 92,57%, demonstrando sua capacidade de capturar padrões complexos nos dados.

Classificador de Floresta Aleatória

Random Forest constrói múltiplas árvores de decisão e agrega suas previsões para melhorar a acurácia e a robustez.





		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

# Inicializar e treinar
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_RFC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.ensemble import RandomForestClassifier
 
# Inicializar e treinar
model_RFC = RandomForestClassifier(n_estimators=500, max_depth=5)
model_RFC.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_RFC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.9181937172774869
              precision    recall  f1-score   support

           Não       0.93      0.93      0.93     14837
          Sim       0.90      0.91      0.90     11139

    accuracy                           0.92     25976
   macro avg       0.92      0.92      0.92     25976
weighted avg       0.92      0.92      0.92     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9181937172774869
              precision    recall  f1-score   support
 
           Não       0.93      0.93      0.93     14837
          Sim       0.90      0.91      0.90     11139
 
    accuracy                           0.92     25976
   macro avg       0.92      0.92      0.92     25976
weighted avg       0.92      0.92      0.92     25976
					
				
			
		



Interpretação:
Random Forest alcança uma acurácia de 91,82%, equilibrando viés e variância de forma eficaz através do aprendizado em conjunto.

Classificador AdaBoost

AdaBoost combina múltiplos classificadores fracos para formar um classificador forte, focando em instâncias previamente mal classificadas.





		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

# Inicializar e treinar
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_ABC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.ensemble import AdaBoostClassifier
 
# Inicializar e treinar
model_ABC = AdaBoostClassifier()
model_ABC.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_ABC.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.9101863258392362
              precision    recall  f1-score   support

           Não       0.93      0.92      0.92     14977
          Sim       0.89      0.90      0.89     10999

    accuracy                           0.91     25976
   macro avg       0.91      0.91      0.91     25976
weighted avg       0.91      0.91      0.91     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9101863258392362
              precision    recall  f1-score   support
 
           Não       0.93      0.92      0.92     14977
          Sim       0.89      0.90      0.89     10999
 
    accuracy                           0.91     25976
   macro avg       0.91      0.91      0.91     25976
weighted avg       0.91      0.91      0.91     25976
					
				
			
		



Interpretação:
AdaBoost atinge uma acurácia de 91,02%, demonstrando sua eficácia na melhoria do desempenho do modelo através de técnicas de boosting.

Classificador XGBoost

XGBoost é uma estrutura de gradient boosting altamente otimizada conhecida por seu desempenho e velocidade.





		
		
			
			
Java
			
			import xgboost as xgb

# Inicializar e treinar
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)

# Prever e avaliar
y_pred = model_xgb.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						import xgboost as xgb
 
# Inicializar e treinar
model_xgb = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss')
model_xgb.fit(X_train, y_train)
 
# Prever e avaliar
y_pred = model_xgb.predict(X_test)
print(accuracy_score(y_pred, y_test))
print(classification_report(y_pred, y_test))
					
				
			
		



Saída:




		
		
			
			
Java
			
			0.9410994764397905
              precision    recall  f1-score   support

           Não       0.96      0.94      0.95     15122
          Sim       0.92      0.94      0.93     10854

    accuracy                           0.94     25976
   macro avg       0.94      0.94      0.94     25976
weighted avg       0.94      0.94      0.94     25976
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						0.9410994764397905
              precision    recall  f1-score   support
 
           Não       0.96      0.94      0.95     15122
          Sim       0.92      0.94      0.93     10854
 
    accuracy                           0.94     25976
   macro avg       0.94      0.94      0.94     25976
weighted avg       0.94      0.94      0.94     25976
					
				
			
		



Interpretação:
XGBoost lidera a concorrência com uma impressionante acurácia de 94,11%, ressaltando sua superioridade no tratamento de conjuntos de dados complexos com alto poder preditivo.



Conclusão

Construir modelos de classificação eficazes depende de um pré-processamento de dados meticuloso, seleção informada de características e escolha do algoritmo certo para a tarefa. Através de nosso modelo mestre abrangente em Notebook Jupyter, exploramos diversos algoritmos de classificação, cada um com suas forças únicas. Desde K-Vizinhos Mais Próximos e Regressão Logística até técnicas avançadas de ensemble como Random Forest e XGBoost, o conjunto de ferramentas é vasto e adaptável a diversos conjuntos de dados.

Seguindo este guia, cientistas de dados e entusiastas podem otimizar seus fluxos de trabalho de aprendizado de máquina, garantindo um desempenho robusto do modelo e avaliações perspicazes. Lembre-se, a pedra angular de qualquer modelo bem-sucedido reside em entender e preparar os dados antes de mergulhar nas complexidades algorítmicas.

Principais Pontos:


    A Qualidade dos Dados Importa: O tratamento eficaz de dados faltantes e a codificação adequada de variáveis categóricas são cruciais para a precisão do modelo.
    A Seleção de Características Melhora o Desempenho: Identificar e selecionar as características mais relevantes pode aumentar significativamente o desempenho do modelo e reduzir a sobrecarga computacional.
    Algoritmos Diversos Oferecem Vantagens Únicas: Explorar múltiplos algoritmos de classificação permite uma tomada de decisão informada baseada nas forças do modelo e nas características do conjunto de dados.
    A Avaliação Contínua é Essencial: Avaliar regularmente os modelos usando métricas como acurácia, precisão, revocação e F1-score garante alinhamento com os objetivos do projeto.


Aproveite o poder dessas técnicas para construir modelos preditivos que não apenas desempenham excepcionalmente, mas também fornecem insights significativos sobre seus dados.



Recursos:


    Kaggle: Satisfação dos Passageiros da Companhia Aérea
    Documentação do Scikit-Learn
    Documentação do XGBoost


Mantenha-se Conectado:

Para mais tutoriais e insights sobre aprendizado de máquina e ciência de dados, inscreva-se em nossa newsletter e siga-nos no LinkedIn.