Spaces:
Sleeping
Sleeping
File size: 3,448 Bytes
526a74f |
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 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import classification_report, accuracy_score, confusion_matrix
import seaborn as sns
import matplotlib.pyplot as plt
import joblib
# Carregar o dataset unificado
csv_path = "./unified_dataset.csv" # Caminho relativo a partir da pasta src
try:
df = pd.read_csv(csv_path)
print("Dataset carregado com sucesso!")
except Exception as e:
print(f"Erro ao carregar o dataset: {e}")
exit()
# Verificar o dataset
print(df.head())
print(f"Tamanho do dataset: {df.shape}")
# Separar features (X) e labels (y)
X = df.drop(columns=["label"]) # Todas as colunas exceto 'label'
y = df["label"] # Coluna 'label'
# Codificar as labels (transformar strings em números)
label_encoder = LabelEncoder()
y = label_encoder.fit_transform(y)
# Dividir o dataset em treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Normalizar as features (importante para MLP)
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# Criar e treinar a MLP
mlp = MLPClassifier(
hidden_layer_sizes=(128, 64), # Duas camadas ocultas com 128 e 64 neurônios
activation="relu", # Função de ativação ReLU
solver="adam", # Otimizador Adam
max_iter=500, # Número máximo de iterações
random_state=42,
verbose=True # Mostrar progresso durante o treinamento
)
print("Treinando a MLP...")
mlp.fit(X_train, y_train)
# Fazer previsões no conjunto de teste
y_pred = mlp.predict(X_test)
# Avaliar o modelo
print("\nRelatório de classificação:")
print(classification_report(y_test, y_pred, target_names=label_encoder.classes_))
print(f"Acurácia: {accuracy_score(y_test, y_pred):.4f}")
# Gerar a matriz de confusão
conf_matrix = confusion_matrix(y_test, y_pred)
# Plotar a matriz de confusão
plt.figure(figsize=(10, 7))
sns.heatmap(conf_matrix, annot=True, fmt="d", cmap="Blues",
xticklabels=label_encoder.classes_,
yticklabels=label_encoder.classes_)
plt.xlabel("Predito")
plt.ylabel("Verdadeiro")
plt.title("Matriz de Confusão")
plt.show()
# Extrair valores relevantes da matriz de confusão
print("\nValores relevantes da matriz de confusão:")
# Acurácia por classe
class_accuracy = conf_matrix.diagonal() / conf_matrix.sum(axis=1)
for i, accuracy in enumerate(class_accuracy):
print(f"Acurácia da classe {label_encoder.classes_[i]}: {accuracy:.4f}")
# Erros mais comuns (maiores valores fora da diagonal)
conf_matrix_df = pd.DataFrame(conf_matrix, index=label_encoder.classes_, columns=label_encoder.classes_)
conf_matrix_df.values[np.diag_indices_from(conf_matrix_df)] = 0 # Zerar a diagonal para focar nos erros
most_common_errors = conf_matrix_df.stack().sort_values(ascending=False).head(5)
print("\nErros mais comuns:")
print(most_common_errors)
# Salvar o modelo
model_filename = "mlp_classifier.joblib"
joblib.dump(mlp, model_filename)
print(f"Modelo salvo como {model_filename}")
# Salvar o LabelEncoder (para decodificar as previsões)
label_encoder_filename = "label_encoder.joblib"
joblib.dump(label_encoder, label_encoder_filename)
print(f"LabelEncoder salvo como {label_encoder_filename}") |