S24L01 – Árvore de Decisão e Floresta Aleatória

Translation:
html
Implementando Árvores de Decisão, Florestas Aleatórias, XGBoost e AdaBoost para Previsão do Tempo em Python

Tabela de Conteúdos

    Introdução
    Visão Geral do Conjunto de Dados
    Pré-processamento de Dados
        
            Tratamento de Valores Ausentes
            Codificação de Variáveis Categóricas
            Seleção de Características
            Divisão de Treino e Teste e Escalonamento de Características
        
    
    Implementação e Avaliação do Modelo
        
            K-Vizinhos Mais Próximos (KNN)
            Regressão Logística
            Naive Bayes Gaussiano
            Máquina de Vetores de Suporte (SVM)
            Árvore de Decisão
            Floresta Aleatória
            XGBoost e AdaBoost
        
    
    Visualizando Regiões de Decisão
    Conclusão
    Referências


Introdução
Prever as condições meteorológicas é um problema clássico em aprendizado de máquina, oferecendo insights valiosos para diversas indústrias, como agricultura, aviação e planejamento de eventos. Neste guia abrangente, vamos nos aprofundar na implementação de vários modelos de aprendizado de máquina—incluindo Árvores de Decisão, Florestas Aleatórias, XGBoost e AdaBoost—para prever se vai chover amanhã usando o conjunto de dados Weather Australia. Abordaremos o pré-processamento de dados, treinamento de modelos, avaliação e até a implantação desses modelos em aplicações web reais.

Visão Geral do Conjunto de Dados
O conjunto de dados Weather Australia, obtido de Kaggle, contém 24 características relacionadas às condições meteorológicas registradas em várias localidades na Austrália. O objetivo principal é prever o atributo RainTomorrow, indicando se vai chover no dia seguinte.

Características do Conjunto de Dados

    Date: Data da observação.
    Location: Localização geográfica da estação meteorológica.
    MinTemp: Temperatura mínima em °C.
    MaxTemp: Temperatura máxima em °C.
    Rainfall: Quantidade de chuva em mm.
    Evaporation: Evaporação em mm.
    Sunshine: Número de horas de sol.
    WindGustDir: Direção do vento mais forte.
    WindGustSpeed: Velocidade do vento mais forte em km/h.
    WindDir9am: Direção do vento às 9 AM.
    WindDir3pm: Direção do vento às 3 PM.
    ...e mais.


Pré-processamento de Dados
O pré-processamento eficaz de dados é crucial para construir modelos de aprendizado de máquina precisos e confiáveis. Abordaremos o tratamento de valores ausentes, codificação de variáveis categóricas, seleção de características e escalonamento.

Tratamento de Valores Ausentes
Dados ausentes podem impactar significativamente o desempenho do modelo. Vamos tratar os valores ausentes separadamente para dados numéricos e categóricos.

Dados Numéricos
Para colunas numéricas, usaremos Imputação pela Média para preencher os valores ausentes.





		
		
			
			
Java
			
			import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer

# Load data
data = pd.read_csv('weatherAUS.csv')

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

# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
				
						import numpy as np
import pandas as pd
from sklearn.impute import SimpleImputer
 
# Load data
data = pd.read_csv('weatherAUS.csv')
 
# Identify numerical columns
numerical_cols = data.select_dtypes(include=['int64', 'float64']).columns
 
# Impute missing values with mean
imp_mean = SimpleImputer(missing_values=np.nan, strategy='mean')
data[numerical_cols] = imp_mean.fit_transform(data[numerical_cols])
					
				
			
		



Dados Categóricos
Para colunas categóricas, usaremos Imputação pelo Valor Mais Frequente.





		
		
			
			
Java
			
			# Identify categorical columns
categorical_cols = data.select_dtypes(include=['object']).columns

# Impute missing values with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
data[categorical_cols] = imp_freq.fit_transform(data[categorical_cols])
			
				
					
				
					1
2
3
4
5
6
				
						# Identify categorical columns
categorical_cols = data.select_dtypes(include=['object']).columns
 
# Impute missing values with the most frequent value
imp_freq = SimpleImputer(missing_values=np.nan, strategy='most_frequent')
data[categorical_cols] = imp_freq.fit_transform(data[categorical_cols])
					
				
			
		



Codificação de Variáveis Categóricas
Algoritmos de aprendizado de máquina exigem entradas numéricas. Utilizaremos tanto Codificação de Rótulos (Label Encoding) quanto Codificação One-Hot (One-Hot Encoding) com base no número de categorias únicas em cada característica.





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

def encode_features(df, threshold=10):
    label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() &lt;= threshold]
    onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() &gt; threshold]
    
    # Label Encoding
    le = LabelEncoder()
    for col in label_enc_cols:
        df[col] = le.fit_transform(df[col])
    
    # One-Hot Encoding
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), onehot_enc_cols)], remainder='passthrough')
    df = ct.fit_transform(df)
    
    return df

X = data.drop('RainTomorrow', axis=1)
y = data['RainTomorrow']

X = encode_features(X)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
				
						from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.compose import ColumnTransformer
 
def encode_features(df, threshold=10):
    label_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() &lt;= threshold]
    onehot_enc_cols = [col for col in df.columns if df[col].dtype == 'object' and df[col].nunique() &gt; threshold]
    
    # Label Encoding
    le = LabelEncoder()
    for col in label_enc_cols:
        df[col] = le.fit_transform(df[col])
    
    # One-Hot Encoding
    ct = ColumnTransformer(transformers=[('encoder', OneHotEncoder(), onehot_enc_cols)], remainder='passthrough')
    df = ct.fit_transform(df)
    
    return df
 
X = data.drop('RainTomorrow', axis=1)
y = data['RainTomorrow']
 
X = encode_features(X)
					
				
			
		



Seleção de Características
Para melhorar o desempenho do modelo e reduzir a complexidade computacional, selecionaremos as principais características usando o método SelectKBest com a estatística Qui-Quadrado (Chi-Squared).





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

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

# Select top 10 features
selector = SelectKBest(score_func=chi2, k=10)
X_selected = selector.fit_transform(X_scaled, y)

# Further reduce to top 2 features for visualization
best_features = selector.get_support(indices=True)
X_final = X_selected[:, :2]
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
				
						from sklearn.feature_selection import SelectKBest, chi2
from sklearn.preprocessing import MinMaxScaler
 
# Scale features
scaler = MinMaxScaler()
X_scaled = scaler.fit_transform(X)
 
# Select top 10 features
selector = SelectKBest(score_func=chi2, k=10)
X_selected = selector.fit_transform(X_scaled, y)
 
# Further reduce to top 2 features for visualization
best_features = selector.get_support(indices=True)
X_final = X_selected[:, :2]
					
				
			
		



Divisão de Treino e Teste e Escalonamento de Características
Dividir os dados em conjuntos de treino e teste garante que o desempenho do nosso modelo seja avaliado em dados não vistos anteriormente.





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

# Split the data
X_train, X_test, y_train, y_test = train_test_split(X_final, y, test_size=0.20, random_state=1)

# Feature Scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
 
# Split the data
X_train, X_test, y_train, y_test = train_test_split(X_final, y, test_size=0.20, random_state=1)
 
# Feature Scaling
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
					
				
			
		



Implementação e Avaliação do Modelo
Implementaremos diversos modelos de aprendizado de máquina e avaliaremos seu desempenho usando a Precisão (Accuracy Score).

K-Vizinhos Mais Próximos (KNN)





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

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {knn_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
8
				
						from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score
 
knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
y_pred_knn = knn.predict(X_test)
knn_accuracy = accuracy_score(y_pred_knn, y_test)
print(f'KNN Accuracy: {knn_accuracy:.2f}')
					
				
			
		


Precisão do KNN: 0.80

Regressão Logística





		
		
			
			
Java
			
			from sklearn.linear_model import LogisticRegression

log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {lr_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.linear_model import LogisticRegression
 
log_reg = LogisticRegression(random_state=0, max_iter=200)
log_reg.fit(X_train, y_train)
y_pred_lr = log_reg.predict(X_test)
lr_accuracy = accuracy_score(y_pred_lr, y_test)
print(f'Logistic Regression Accuracy: {lr_accuracy:.2f}')
					
				
			
		


Precisão da Regressão Logística: 0.83

Naive Bayes Gaussiano





		
		
			
			
Java
			
			from sklearn.naive_bayes import GaussianNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.naive_bayes import GaussianNB
 
gnb = GaussianNB()
gnb.fit(X_train, y_train)
y_pred_gnb = gnb.predict(X_test)
gnb_accuracy = accuracy_score(y_pred_gnb, y_test)
print(f'Gaussian Naive Bayes Accuracy: {gnb_accuracy:.2f}')
					
				
			
		


Precisão do Naive Bayes Gaussiano: 0.80

Máquina de Vetores de Suporte (SVM)





		
		
			
			
Java
			
			from sklearn.svm import SVC

svm = SVC()
svm.fit(X_train, y_train)
y_pred_svm = svm.predict(X_test)
svm_accuracy = accuracy_score(y_pred_svm, y_test)
print(f'SVM Accuracy: {svm_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.svm import SVC
 
svm = SVC()
svm.fit(X_train, y_train)
y_pred_svm = svm.predict(X_test)
svm_accuracy = accuracy_score(y_pred_svm, y_test)
print(f'SVM Accuracy: {svm_accuracy:.2f}')
					
				
			
		


Precisão da SVM: 0.83

Árvore de Decisão





		
		
			
			
Java
			
			from sklearn.tree import DecisionTreeClassifier

dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.tree import DecisionTreeClassifier
 
dtc = DecisionTreeClassifier()
dtc.fit(X_train, y_train)
y_pred_dtc = dtc.predict(X_test)
dtc_accuracy = accuracy_score(y_pred_dtc, y_test)
print(f'Decision Tree Accuracy: {dtc_accuracy:.2f}')
					
				
			
		


Precisão da Árvore de Decisão: 0.83

Floresta Aleatória





		
		
			
			
Java
			
			from sklearn.ensemble import RandomForestClassifier

rf = RandomForestClassifier(n_estimators=500, max_depth=5)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
rf_accuracy = accuracy_score(y_pred_rf, y_test)
print(f'Random Forest Accuracy: {rf_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.ensemble import RandomForestClassifier
 
rf = RandomForestClassifier(n_estimators=500, max_depth=5)
rf.fit(X_train, y_train)
y_pred_rf = rf.predict(X_test)
rf_accuracy = accuracy_score(y_pred_rf, y_test)
print(f'Random Forest Accuracy: {rf_accuracy:.2f}')
					
				
			
		


Precisão da Floresta Aleatória: 0.83

XGBoost e AdaBoost
Embora a implementação inicial não aborde XGBoost e AdaBoost, esses métodos de ensemble podem melhorar ainda mais o desempenho do modelo. Aqui está um breve exemplo de como implementá-los:

XGBoost





		
		
			
			
Java
			
			from xgboost import XGBClassifier

xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
xgb.fit(X_train, y_train)
y_pred_xgb = xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from xgboost import XGBClassifier
 
xgb = XGBClassifier(use_label_encoder=False, eval_metric='logloss')
xgb.fit(X_train, y_train)
y_pred_xgb = xgb.predict(X_test)
xgb_accuracy = accuracy_score(y_pred_xgb, y_test)
print(f'XGBoost Accuracy: {xgb_accuracy:.2f}')
					
				
			
		



AdaBoost





		
		
			
			
Java
			
			from sklearn.ensemble import AdaBoostClassifier

ada = AdaBoostClassifier(n_estimators=100, random_state=0)
ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)
ada_accuracy = accuracy_score(y_pred_ada, y_test)
print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')
			
				
					
				
					1
2
3
4
5
6
7
				
						from sklearn.ensemble import AdaBoostClassifier
 
ada = AdaBoostClassifier(n_estimators=100, random_state=0)
ada.fit(X_train, y_train)
y_pred_ada = ada.predict(X_test)
ada_accuracy = accuracy_score(y_pred_ada, y_test)
print(f'AdaBoost Accuracy: {ada_accuracy:.2f}')
					
				
			
		



Nota: Certifique-se de ter a biblioteca xgboost instalada usando pip install xgboost.

Visualizando Regiões de Decisão
Visualizar fronteiras de decisão ajuda a entender como diferentes modelos classificam os dados. Abaixo está um exemplo usando o conjunto de dados Iris:





		
		
			
			
Java
			
			from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets

# Load Iris dataset
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target

# Train KNN
knn_vis = KNeighborsClassifier(n_neighbors=3)
knn_vis.fit(X_vis, y_vis)

# Plot decision regions
plot_decision_regions(X_vis, y_vis, clf=knn_vis)

plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.legend()
plt.show()
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						from mlxtend.plotting import plot_decision_regions
import matplotlib.pyplot as plt
from sklearn import datasets
 
# Load Iris dataset
iris = datasets.load_iris()
X_vis = iris.data[:, :2]
y_vis = iris.target
 
# Train KNN
knn_vis = KNeighborsClassifier(n_neighbors=3)
knn_vis.fit(X_vis, y_vis)
 
# Plot decision regions
plot_decision_regions(X_vis, y_vis, clf=knn_vis)
 
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title('KNN Decision Regions')
plt.legend()
plt.show()
					
				
			
		


Saída da Visualização: Um gráfico mostrando as fronteiras de decisão criadas pelo classificador KNN.

Conclusão
Neste guia, exploramos a implementação de vários modelos de aprendizado de máquina—Árvores de Decisão, Florestas Aleatórias, Regressão Logística, KNN, Naive Bayes Gaussiano e SVM—para prever condições meteorológicas usando o conjunto de dados Weather Australia. Cada modelo apresentou pontuações de precisão competitivas, com Regressão Logística, SVM, Árvores de Decisão e Florestas Aleatórias alcançando aproximadamente 83% de precisão.
Para um desempenho aprimorado, métodos de ensemble como XGBoost e AdaBoost podem ser integrados. Além disso, implantar esses modelos em aplicações web pode fornecer previsões meteorológicas em tempo real, tornando os insights acionáveis para os usuários finais.

Referências

    Conjunto de Dados Weather Australia no Kaggle
    Documentação do Scikit-Learn
    Documentação do XGBoost
    MLxtend: Extensões de Aprendizado de Máquina
    Documentação do Pandas