Update model_utils.py

atualizada a base com modelo da tarefa

model_utils.py

@@ -1,4 +1,5 @@
-# model_utils.py
+# model_utils.py - ATUALIZADO
+
 import pandas as pd
 import numpy as np
 from sklearn.model_selection import train_test_split
@@ -10,10 +11,12 @@ from sklearn.linear_model import LogisticRegression
 from imblearn.over_sampling import SMOTE
 from typing import Dict, Any, List, Tuple, Union
 
-# Definir as colunas que seu modelo espera
-ALL_FEATURES = ['Idade', 'Saldo_Conta', 'Numero_Produtos', 'Tempo_Cliente_Meses',
-                'Genero', 'Cidade', 'Renda_Anual_USD', 'Membro_Ativo', 'Tem_Cartao_Credito']
-TARGET_COLUMN = 'Churn'
+# --- DEFINIÇÃO DAS FEATURES E COLUNA ALVO PARA SEU data.csv ---
+ALL_FEATURES = [
+    'creditscore', 'geography', 'gender', 'age', 'tenure',
+    'balance', 'numofproducts', 'hascrcard', 'isactivemember', 'estimatedsalary'
+]
+TARGET_COLUMN = 'exited' # Sua coluna alvo agora é 'exited'
 
 class ChurnModelPipeline:
     def __init__(self):
@@ -23,8 +26,9 @@ class ChurnModelPipeline:
 
     def _build_preprocessor(self, X: pd.DataFrame) -> ColumnTransformer:
         # Identificar features numéricas e categóricas com base no dataframe X
-        numeric_features = X.select_dtypes(include=np.number).columns.tolist()
-        categorical_features = X.select_dtypes(include='object').columns.tolist()
+        # A seleção é feita a partir das ALL_FEATURES definidas
+        numeric_features = X[ALL_FEATURES].select_dtypes(include=np.number).columns.tolist()
+        categorical_features = X[ALL_FEATURES].select_dtypes(include='object').columns.tolist()
 
         numeric_transformer = Pipeline(steps=[
             ('imputer', SimpleImputer(strategy='median')),
@@ -41,36 +45,49 @@ class ChurnModelPipeline:
                 ('num', numeric_transformer, numeric_features),
                 ('cat', categorical_transformer, categorical_features)
             ],
-            remainder='passthrough'
+            remainder='passthrough' # Manter colunas não usadas se houver (e.g., customerid, surname)
         )
         return preprocessor
 
     def train(self, df: pd.DataFrame) -> None:
+        print(f"Iniciando treinamento com {len(df)} linhas e features: {ALL_FEATURES}")
+        print(f"Coluna alvo: {TARGET_COLUMN}")
+        
+        # Validar se todas as ALL_FEATURES e TARGET_COLUMN existem no DataFrame
+        missing_cols = [col for col in ALL_FEATURES + [TARGET_COLUMN] if col not in df.columns]
+        if missing_cols:
+            raise ValueError(f"Colunas ausentes no DataFrame: {missing_cols}. Verifique seu 'data.csv'.")
+
         X = df[ALL_FEATURES]
         y = df[TARGET_COLUMN]
 
-        # 1. Dividir em treino e teste (estratificado para Churn)
+        # 1. Dividir em treino e teste (estratificado para a coluna 'exited')
+        # Para datasets pequenos como o seu exemplo, test_size=0.2 é um bom balanceamento
         X_train, _, y_train, _ = train_test_split(
             X, y, test_size=0.2, random_state=42, stratify=y
         )
+        print(f"X_train shape antes do pre-processamento: {X_train.shape}")
+        print(f"y_train value counts antes do SMOTE: {y_train.value_counts()}")
 
         # 2. Construir e ajustar o pré-processador
         self.preprocessor = self._build_preprocessor(X_train)
         X_train_processed = self.preprocessor.fit_transform(X_train)
         
-        # Obter nomes das features após o pré-processamento
-        numeric_f = X_train.select_dtypes(include=np.number).columns.tolist()
-        categorical_f = X_train.select_dtypes(include='object').columns.tolist()
+        # Obter nomes das features após one-hot encoding
+        numeric_f = X_train[ALL_FEATURES].select_dtypes(include=np.number).columns.tolist()
+        categorical_f = X_train[ALL_FEATURES].select_dtypes(include='object').columns.tolist()
         
+        # get_feature_names_out é mais robusto para ColumnTransformer
         self.feature_names_out = numeric_f + list(self.preprocessor.named_transformers_['cat']['onehot'].get_feature_names_out(categorical_f))
+        print(f"X_train_processed shape após pre-processamento: {X_train_processed.shape}")
 
 
         # 3. Balanceamento de Classes com SMOTE
         smote = SMOTE(random_state=42)
         X_train_resampled, y_train_resampled = smote.fit_resample(X_train_processed, y_train)
+        print(f"y_train_resampled value counts após SMOTE: {y_train_resampled.value_counts()}")
 
-        # 4. Treinar o modelo
-        # Usamos LogisticRegression, similar ao seu relatório
+        # 4. Treinar o modelo (Logistic Regression)
         self.model = LogisticRegression(random_state=42, solver='liblinear', C=0.1, max_iter=500)
         self.model.fit(X_train_resampled, y_train_resampled)
         print("Modelo de Churn treinado com sucesso!")
@@ -84,7 +101,7 @@ class ChurnModelPipeline:
             missing_cols = [col for col in ALL_FEATURES if col not in input_data.columns]
             raise ValueError(f"Dados de entrada brutos não contêm todas as features esperadas: {missing_cols}. Features esperadas: {ALL_FEATURES}")
 
-        # Garantir a ordem das colunas e que todas as features estejam presentes, mesmo que preenchidas com NaN
+        # Garantir a ordem das colunas e que todas as features estejam presentes
         input_data_ordered = input_data[ALL_FEATURES]
 
         # Aplicar o mesmo pré-processamento usado no treino
@@ -92,12 +109,12 @@ class ChurnModelPipeline:
         
         # Fazer a previsão
         prediction = self.model.predict(X_processed)[0]
-        # Obter a probabilidade da classe positiva (Churn=1)
+        # Obter a probabilidade da classe positiva (exited=1)
         probability_churn = self.model.predict_proba(X_processed)[0][1]
         
         return int(prediction), float(probability_churn)
 
-# Funções auxiliares para Gradio
+# Funções auxiliares para Gradio (ainda não usadas na UI, mas úteis)
 def get_model_coefficients(model_pipeline: ChurnModelPipeline) -> pd.DataFrame:
     if model_pipeline.model and hasattr(model_pipeline.model, 'coef_') and model_pipeline.feature_names_out:
         coefs = model_pipeline.model.coef_[0] if model_pipeline.model.coef_.ndim > 1 else model_pipeline.model.coef_