Update src/streamlit_app.py

src/streamlit_app.py

@@ -10,7 +10,8 @@ from sklearn.tree import DecisionTreeClassifier
 from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier, GradientBoostingClassifier
 from xgboost import XGBClassifier
 from lightgbm import LGBMClassifier
-from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, ConfusionMatrixDisplay
+from sklearn.metrics import roc_auc_score, roc_curve, accuracy_score, precision_score, recall_score, f1_score, \
+    confusion_matrix, ConfusionMatrixDisplay
 import matplotlib.pyplot as plt
 import seaborn as sns
 import numpy as np
@@ -18,12 +19,13 @@ import io
 from sklearn.feature_selection import RFE
 from sklearn.linear_model import LogisticRegression
 
-
 # Configuração da página do Streamlit
 st.set_page_config(layout="wide", page_title="Previsão de Reclamações de Clientes")
 
 st.title("📊 Previsão de Reclamações de Clientes com Modelos Supervisionados")
-st.markdown("Este dashboard tem como objetivo identificar clientes com maior probabilidade de terem feito uma reclamação nos últimos 2 anos, utilizando modelos de Machine Learning.")
+st.markdown(
+    "Este dashboard tem como objetivo identificar clientes com maior probabilidade de terem feito uma reclamação nos últimos 2 anos, utilizando modelos de Machine Learning.")
+
 
 # --- Carregamento e Pré-processamento dos Dados ---
 @st.cache_data
@@ -36,6 +38,7 @@ def load_data():
         st.stop()
     return df
 
+
 @st.cache_data
 def preprocess_data(df):
     df_processed = df.copy()
@@ -44,7 +47,7 @@ def preprocess_data(df):
     df_processed['Dt_Customer'] = pd.to_datetime(df_processed['Dt_Customer'], format='%d-%m-%Y')
     reference_date = df_processed['Dt_Customer'].min()
     df_processed['Days_Since_Customer'] = (df_processed['Dt_Customer'] - reference_date).dt.days
-    df_processed = df_processed.drop('Dt_Customer', axis=1) # Remove coluna original de data
+    df_processed = df_processed.drop('Dt_Customer', axis=1)  # Remove coluna original de data
 
     # Coerção explícita para numérico para colunas que podem vir como 'object'
     cols_to_coerce_numeric = [
@@ -57,21 +60,23 @@ def preprocess_data(df):
     for col in cols_to_coerce_numeric:
         if col in df_processed.columns:
             df_processed[col] = pd.to_numeric(df_processed[col], errors='coerce')
-            df_processed[col] = df_processed[col].fillna(0) # Preenche NaN com 0 após coerção, se houver
+            df_processed[col] = df_processed[col].fillna(0)  # Preenche NaN com 0 após coerção, se houver
 
     # Convertendo variáveis categóricas em numéricas (one-hot encoding)
     df_processed = pd.get_dummies(df_processed, columns=['Education', 'Marital_Status'], drop_first=True)
 
     # Excluir colunas irrelevantes e com variância zero
     cols_to_drop = ['ID', 'Z_CostContact', 'Z_Revenue']
-    df_processed = df_processed.drop(columns=[col for col in cols_to_drop if col in df_processed.columns], axis=1, errors='ignore')
-    
+    df_processed = df_processed.drop(columns=[col for col in cols_to_drop if col in df_processed.columns], axis=1,
+                                     errors='ignore')
+
     # Remover colunas com variância zero (constantes) ou com muitos nulos após o pré-processamento
-    df_processed = df_processed.loc[:, df_processed.nunique() > 1] # Remove colunas com apenas 1 valor único
-    df_processed = df_processed.dropna(axis=1, how='all') # Remove colunas totalmente nulas
+    df_processed = df_processed.loc[:, df_processed.nunique() > 1]  # Remove colunas com apenas 1 valor único
+    df_processed = df_processed.dropna(axis=1, how='all')  # Remove colunas totalmente nulas
 
     return df_processed
 
+
 # Função para treinar e avaliar modelos
 @st.cache_data(show_spinner=False)
 def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler, model_selected=None):
@@ -95,26 +100,28 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
 
     # Check if y_train has at least two classes before attempting to train (real training calls)
     if len(np.unique(y_train)) < 2:
-        st.error("Erro: O conjunto de treino contém apenas uma classe na variável alvo. Verifique o balanceamento ou a divisão dos dados.")
+        st.error(
+            "Erro: O conjunto de treino contém apenas uma classe na variável alvo. Verifique o balanceamento ou a divisão dos dados.")
         return {}
 
     # Check if X_train_raw has enough samples (real training calls)
     if X_train_raw.shape[0] == 0:
         st.error("Erro: Dados de treino com 0 amostras. Não é possível treinar modelos.")
         return {}
-    
+
     # Verificar se os dtypes são numéricos antes de treinar (real training calls)
     for col in X_train_raw.columns:
         if not pd.api.types.is_numeric_dtype(X_train_raw[col]):
-            st.error(f"Erro: Coluna '{col}' no X_train_raw não é numérica. Tipo: {X_train_raw[col].dtype}. Verifique o pré-processamento.")
+            st.error(
+                f"Erro: Coluna '{col}' no X_train_raw não é numérica. Tipo: {X_train_raw[col].dtype}. Verifique o pré-processamento.")
             return {}
 
     for col in X_test_raw.columns:
         if not pd.api.types.is_numeric_dtype(X_test_raw[col]):
-            st.error(f"Erro: Coluna '{col}' no X_test_raw não é numérica. Tipo: {X_test_raw[col].dtype}. Verifique o pré-processamento.")
+            st.error(
+                f"Erro: Coluna '{col}' no X_test_raw não é numérica. Tipo: {X_test_raw[col].dtype}. Verifique o pré-processamento.")
             return {}
 
-
     for name, model in models.items():
         if model_selected and name != model_selected:
             continue
@@ -123,14 +130,14 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
         if name in ["K-Nearest Neighbors", "Support Vector Machine"]:
             X_train_processed = _scaler.fit_transform(X_train_raw)
             X_test_processed = _scaler.transform(X_test_raw)
-        else: # Para outros modelos, usamos os dados crus (não escalados)
+        else:  # Para outros modelos, usamos os dados crus (não escalados)
             X_train_processed = X_train_raw
             X_test_processed = X_test_raw
 
         try:
             model.fit(X_train_processed, y_train)
             y_pred = model.predict(X_test_processed)
-            
+
             # Correção para IndexError no predict_proba
             if hasattr(model, 'predict_proba'):
                 probas = model.predict_proba(X_test_processed)
@@ -139,7 +146,7 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
                 else:
                     y_prob = probas[:, 0]
             else:
-                y_prob = y_pred # fallback, não ideal para AUC
+                y_prob = y_pred  # fallback, não ideal para AUC
 
             # Calcular ROC AUC apenas se y_prob não for totalmente binário (0 ou 1)
             if len(np.unique(y_prob)) > 1:
@@ -168,11 +175,13 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
             # O warning será exibido APENAS se o treinamento real for solicitado (nos botões "Treinar" ou "Analisar")
             results[name] = {
                 "Model": None, "Accuracy": 0, "Precision": 0, "Recall": 0, "F1-score": 0,
-                "AUC": 0.5, "Confusion Matrix": np.array([[0,0],[0,0]]), "FPR": [0,1], "TPR": [0,1], "y_prob": np.zeros(len(y_test)), "Error": str(e)
+                "AUC": 0.5, "Confusion Matrix": np.array([[0, 0], [0, 0]]), "FPR": [0, 1], "TPR": [0, 1],
+                "y_prob": np.zeros(len(y_test)), "Error": str(e)
             }
             continue
     return results
 
+
 # --- Carregar e Pré-processar os dados ---
 df = load_data()
 df_processed = preprocess_data(df)
@@ -186,17 +195,20 @@ st.sidebar.header("⚙️ Configurações do Modelo")
 # Balanceamento da Base
 st.sidebar.subheader("Balanceamento de Dados (SMOTE)")
 balance_data = st.sidebar.checkbox("Aplicar SMOTE", value=True)
-st.sidebar.info("SMOTE cria amostras sintéticas da classe minoritária para balancear os dados, melhorando o desempenho em datasets desbalanceados.")
+st.sidebar.info(
+    "SMOTE cria amostras sintéticas da classe minoritária para balancear os dados, melhorando o desempenho em datasets desbalanceados.")
 
 # Seleção de Variáveis
 st.sidebar.subheader("Seleção de Variáveis")
 use_rfe = st.sidebar.checkbox("Usar Seleção de Variáveis (RFE)", value=False)
 if use_rfe:
     max_features_rfe = X.shape[1] if X.shape[1] > 5 else 5
-    n_features_rfe = st.sidebar.slider("Número de Variáveis a Selecionar (RFE)", 5, max_features_rfe, min(10, max_features_rfe))
-    st.sidebar.info(f"O RFE (Recursive Feature Elimination) seleciona as {n_features_rfe} melhores variáveis de forma iterativa.")
+    n_features_rfe = st.sidebar.slider("Número de Variáveis a Selecionar (RFE)", 5, max_features_rfe,
+                                       min(10, max_features_rfe))
+    st.sidebar.info(
+        f"O RFE (Recursive Feature Elimination) seleciona as {n_features_rfe} melhores variáveis de forma iterativa.")
     estimator_rfe = LogisticRegression(max_iter=1000, random_state=42)
-    
+
     if X.shape[0] > 0 and X.shape[1] >= n_features_rfe:
         try:
             selector_rfe = RFE(estimator_rfe, n_features_to_select=n_features_rfe, step=1)
@@ -208,7 +220,8 @@ if use_rfe:
             st.sidebar.error(f"Erro ao aplicar RFE: {e}. RFE desabilitado.")
             use_rfe = False
     else:
-        st.sidebar.warning(f"Não há dados suficientes ({X.shape[0]} amostras ou {X.shape[1]} colunas) para aplicar RFE com {n_features_rfe} features. RFE desabilitado.")
+        st.sidebar.warning(
+            f"Não há dados suficientes ({X.shape[0]} amostras ou {X.shape[1]} colunas) para aplicar RFE com {n_features_rfe} features. RFE desabilitado.")
         use_rfe = False
 
 # Escolha do Modelo
@@ -217,11 +230,12 @@ st.sidebar.subheader("Seleção de Modelo para Treinamento")
 # === CORREÇÃO: Usar st.session_state para sinalizar a chamada inicial ===
 st.session_state['is_initial_call'] = True
 # Criar dados dummy com 1 linha de zeros e todas as colunas de X para ter o shape correto
-dummy_X_for_keys = pd.DataFrame(np.zeros((1, X.shape[1])), columns=X.columns)
+dummy_X_for_keys = pd.DataFrame(np.zeros((2, X.shape[1])), columns=X.columns)
 # y_dummy deve ter pelo menos 2 classes para a função não reclamar
-dummy_y_for_keys = pd.Series([0, 1]) 
-model_keys = train_and_evaluate_models(dummy_X_for_keys, dummy_X_for_keys, dummy_y_for_keys, dummy_y_for_keys, StandardScaler()).keys()
-st.session_state['is_initial_call'] = False # Reseta a flag após a chamada inicial
+dummy_y_for_keys = pd.Series([0, 1])
+model_keys = train_and_evaluate_models(dummy_X_for_keys, dummy_X_for_keys, dummy_y_for_keys, dummy_y_for_keys,
+                                       StandardScaler()).keys()
+st.session_state['is_initial_call'] = False  # Reseta a flag após a chamada inicial
 
 model_choice = st.sidebar.selectbox(
     "Escolha o Modelo Principal para Análise Detalhada:",
@@ -266,7 +280,8 @@ with tab1:
 
 with tab2:
     st.header("2. Balanceamento de Dados com SMOTE")
-    st.write("A seguir, demonstramos o efeito do balanceamento da variável alvo 'Complain' utilizando a técnica **SMOTE**.")
+    st.write(
+        "A seguir, demonstramos o efeito do balanceamento da variável alvo 'Complain' utilizando a técnica **SMOTE**.")
 
     X_display = X.copy()
     y_display = y.copy()
@@ -290,7 +305,8 @@ with tab2:
                 ax.set_ylabel("Contagem")
                 st.pyplot(fig)
         except Exception as e:
-            st.error(f"Erro ao aplicar SMOTE: {e}. Isso pode acontecer se houver poucas amostras na classe minoritária ou muitas features.")
+            st.error(
+                f"Erro ao aplicar SMOTE: {e}. Isso pode acontecer se houver poucas amostras na classe minoritária ou muitas features.")
             X_res, y_res = X_display, y_display
     else:
         st.info("SMOTE desabilitado. O balanceamento não será aplicado.")
@@ -303,9 +319,11 @@ with tab2:
         st.subheader("Divisão dos Dados (Treino/Teste)")
         test_size = st.slider("Tamanho do Conjunto de Teste", 0.1, 0.5, 0.3, 0.05)
         if len(np.unique(y_res)) > 1:
-            X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42, stratify=y_res)
+            X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42,
+                                                                stratify=y_res)
         else:
-            st.warning("Não foi possível usar `stratify` no `train_test_split` pois o alvo tem apenas uma classe após o processamento. Dividindo sem estratificação.")
+            st.warning(
+                "Não foi possível usar `stratify` no `train_test_split` pois o alvo tem apenas uma classe após o processamento. Dividindo sem estratificação.")
             X_train, X_test, y_train, y_test = train_test_split(X_res, y_res, test_size=test_size, random_state=42)
 
     st.write(f"**Shape dos dados de treino:** {X_train.shape}")
@@ -327,8 +345,8 @@ with tab2:
         st.stop()
 
     st.subheader("Escalonamento de Dados")
-    st.write("Para modelos sensíveis à escala (como KNN e SVM), os dados serão automaticamente escalonados (`StandardScaler`) antes do treinamento e da previsão.")
-
+    st.write(
+        "Para modelos sensíveis à escala (como KNN e SVM), os dados serão automaticamente escalonados (`StandardScaler`) antes do treinamento e da previsão.")
 
 with tab3:
     st.header("3. Comparação de Modelos Supervisionados")
@@ -370,7 +388,8 @@ with tab3:
                 st.markdown("""
                 Para problemas de previsão de reclamações, o **Recall** é frequentemente crucial, pois minimiza Falsos Negativos (clientes que reclamam mas não são previstos). No entanto, um bom **AUC** (Área sob a Curva ROC) indica a capacidade geral do modelo de distinguir entre as classes, e o **F1-score** oferece um equilíbrio entre Precisão e Recall.
                 """)
-                st.success(f"**Recomendação:** O modelo com o maior **AUC** é geralmente um bom ponto de partida, pois indica a melhor capacidade discriminatória geral. Para este exemplo, o modelo principal para análise detalhada será o selecionado na sidebar: **{model_choice}**.")
+                st.success(
+                    f"**Recomendação:** O modelo com o maior **AUC** é geralmente um bom ponto de partida, pois indica a melhor capacidade discriminatória geral. Para este exemplo, o modelo principal para análise detalhada será o selecionado na sidebar: **{model_choice}**.")
 
 with tab4:
     st.header("4. Análise Detalhada do Modelo Selecionado")
@@ -378,10 +397,12 @@ with tab4:
 
     if st.button(f"Analisar {model_choice}"):
         with st.spinner(f"Analisando {model_choice}..."):
-            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(), model_selected=model_choice)
-            
+            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(),
+                                                               model_selected=model_choice)
+
             if model_choice not in selected_model_results or selected_model_results[model_choice]['Model'] is None:
-                st.error(f"Não foi possível analisar o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
+                st.error(
+                    f"Não foi possível analisar o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
             else:
                 metrics = selected_model_results[model_choice]
 
@@ -394,7 +415,8 @@ with tab4:
 
                 st.subheader(f"Matriz de Confusão para {model_choice}")
                 fig_cm, ax_cm = plt.subplots(figsize=(7, 6))
-                disp = ConfusionMatrixDisplay(confusion_matrix=metrics['Confusion Matrix'], display_labels=['Não Reclamou (0)', 'Reclamou (1)'])
+                disp = ConfusionMatrixDisplay(confusion_matrix=metrics['Confusion Matrix'],
+                                              display_labels=['Não Reclamou (0)', 'Reclamou (1)'])
                 disp.plot(cmap=plt.cm.Blues, ax=ax_cm)
                 ax_cm.set_title(f'Matriz de Confusão para {model_choice}')
                 st.pyplot(fig_cm)
@@ -409,7 +431,8 @@ with tab4:
 
                 st.subheader(f"Curva ROC para {model_choice}")
                 fig_roc_single, ax_roc_single = plt.subplots(figsize=(8, 6))
-                ax_roc_single.plot(metrics['FPR'], metrics['TPR'], color='darkorange', lw=2, label=f'Curva ROC (AUC = {metrics["AUC"]:.2f})')
+                ax_roc_single.plot(metrics['FPR'], metrics['TPR'], color='darkorange', lw=2,
+                                   label=f'Curva ROC (AUC = {metrics["AUC"]:.2f})')
                 ax_roc_single.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='Classificador Aleatório')
                 ax_roc_single.set_xlabel('Taxa de Falsos Positivos (FPR)')
                 ax_roc_single.set_ylabel('Taxa de Verdadeiros Positivos (TPR)')
@@ -417,7 +440,8 @@ with tab4:
                 ax_roc_single.legend(loc='lower right')
                 ax_roc_single.grid(True)
                 st.pyplot(fig_roc_single)
-                st.write(f"O **AUC** de {metrics['AUC']:.2f} indica a capacidade discriminatória do modelo: quanto mais próximo de 1, melhor o modelo distingue entre as classes.")
+                st.write(
+                    f"O **AUC** de {metrics['AUC']:.2f} indica a capacidade discriminatória do modelo: quanto mais próximo de 1, melhor o modelo distingue entre as classes.")
 
                 st.subheader("Sensibilidade aos Hiperparâmetros")
                 if model_choice == "K-Nearest Neighbors":
@@ -437,7 +461,8 @@ with tab4:
                     Modelos de Boosting como XGBoost e LightGBM são influenciados por `n_estimators` (número de estimadores), `learning_rate` (taxa de aprendizado) e `max_depth`. Uma `learning_rate` menor com mais estimadores pode melhorar o desempenho, mas requer mais tempo de treinamento. `Max_depth` controla a complexidade de cada árvore.
                     """)
                 else:
-                    st.markdown("Este modelo também possui hiperparâmetros que podem ser ajustados para otimizar o desempenho (ex: `max_depth` para Decision Tree, `n_estimators` para AdaBoosting/Gradient Boosting).")
+                    st.markdown(
+                        "Este modelo também possui hiperparâmetros que podem ser ajustados para otimizar o desempenho (ex: `max_depth` para Decision Tree, `n_estimators` para AdaBoosting/Gradient Boosting).")
 
 with tab5:
     st.header("5. Tomada de Decisão e Aplicação Gerencial")
@@ -445,10 +470,12 @@ with tab5:
 
     if st.button("Gerar Análise Gerencial"):
         with st.spinner("Gerando insights gerenciais..."):
-            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(), model_selected=model_choice)
-            
+            selected_model_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler(),
+                                                               model_selected=model_choice)
+
             if model_choice not in selected_model_results or selected_model_results[model_choice]['Model'] is None:
-                st.error(f"Não foi possível gerar a análise gerencial para o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
+                st.error(
+                    f"Não foi possível gerar a análise gerencial para o modelo {model_choice}. Ele pode ter falhado no treinamento. Erro: {selected_model_results.get(model_choice, {}).get('Error', 'Desconhecido')}")
             else:
                 model_instance = selected_model_results[model_choice]["Model"]
 
@@ -457,7 +484,8 @@ with tab5:
                 if hasattr(model_instance, 'feature_importances_'):
                     feature_importances = model_instance.feature_importances_
                     feature_names = X.columns.tolist()
-                    importance_df = pd.DataFrame({'Variável': feature_names, 'Importância Relativa': feature_importances})
+                    importance_df = pd.DataFrame(
+                        {'Variável': feature_names, 'Importância Relativa': feature_importances})
                     importance_df = importance_df.sort_values(by='Importância Relativa', ascending=False)
                     st.dataframe(importance_df.head(10).set_index('Variável'))
 
@@ -469,7 +497,8 @@ with tab5:
                 elif hasattr(model_instance, 'coef_'):
                     st.info("Para modelos lineares, os coeficientes podem ser interpretados como importância.")
                 else:
-                    st.info("Não foi possível extrair a importância das variáveis para este tipo de modelo de forma direta.")
+                    st.info(
+                        "Não foi possível extrair a importância das variáveis para este tipo de modelo de forma direta.")
 
                 st.subheader("Análise e Recomendações Gerenciais")