Update src/streamlit_app.py

src/streamlit_app.py

@@ -10,8 +10,7 @@ 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
@@ -19,13 +18,12 @@ 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
@@ -38,7 +36,6 @@ def load_data():
         st.stop()
     return df
 
-
 @st.cache_data
 def preprocess_data(df):
     df_processed = df.copy()
@@ -47,41 +44,34 @@ 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' ---
-    # Inclui colunas como Kidhome, Teenhome, AcceptedCmpX, Response que devem ser numéricas
+    # Coerção explícita para numérico para colunas que podem vir como 'object'
     cols_to_coerce_numeric = [
         'Kidhome', 'Teenhome', 'Recency', 'MntWines', 'MntFruits', 'MntMeatProducts',
         'MntFishProducts', 'MntSweetProducts', 'MntGoldProds', 'NumDealsPurchases',
         'NumWebPurchases', 'NumCatalogPurchases', 'NumStorePurchases',
         'NumWebVisitsMonth', 'AcceptedCmp1', 'AcceptedCmp2', 'AcceptedCmp3',
         'AcceptedCmp4', 'AcceptedCmp5', 'Response', 'Days_Since_Customer', 'Income'
-        # Adicionado Income aqui para garantir
     ]
     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
-
-    # Lidar com valores ausentes: preencher 'Income' com a média (se ainda houver, após coerção)
-    # df_processed['Income'] = df_processed['Income'].fillna(df_processed['Income'].mean()) # Removido, já tratado acima
+            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):
@@ -98,36 +88,33 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
 
     results = {}
 
-    # Check if y_train has at least two classes before attempting to train
+    # --- NOVO: Se for uma chamada inicial, apenas retorna as chaves sem tentar treinar ---
+    if st.session_state.get('is_initial_call', False):
+        return {name: {} for name in models.keys()}
+    # --- FIM NOVO ---
+
+    # Check if y_train has at least two classes before attempting to train (real training calls)
     if len(np.unique(y_train)) < 2:
-        if st.session_state.get('is_initial_call', False):
-            return {name: {} for name in models.keys()}
-        else:
-            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 {}
+        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
+    # Check if X_train_raw has enough samples (real training calls)
     if X_train_raw.shape[0] == 0:
-        if st.session_state.get('is_initial_call', False):
-            return {name: {} for name in models.keys()}
-        else:
-            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
+        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
@@ -136,15 +123,15 @@ 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 ===
+            
+            # Correção para IndexError no predict_proba
             if hasattr(model, 'predict_proba'):
                 probas = model.predict_proba(X_test_processed)
                 if probas.shape[1] > 1:
@@ -152,7 +139,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:
@@ -176,20 +163,16 @@ def train_and_evaluate_models(X_train_raw, X_test_raw, y_train, y_test, _scaler,
                 "TPR": tpr,
                 "y_prob": y_prob
             }
-        except ValueError as e:
-            if not st.session_state.get('is_initial_call', False):
-                st.warning(
-                    f"Não foi possível treinar o modelo {name} devido a um erro: {e}. Provavelmente dados de teste/treino insuficientes ou de apenas uma classe.")
-            # Se for chamada inicial (dummy), não mostra nada no front
+        except Exception as e:
+            # Captura erros de treinamento, mas não os exibe para o usuário final durante a seleção inicial
+            # 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))
+                "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)
@@ -203,21 +186,17 @@ 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:
-    # Garante que X tem colunas suficientes para o slider
     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)
@@ -229,20 +208,20 @@ 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
 st.sidebar.subheader("Seleção de Modelo para Treinamento")
 
-# === CORREÇÃO: Passar dados dummy robustos para a chamada inicial do selectbox ===
+# === 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_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
+# 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
 
 model_choice = st.sidebar.selectbox(
     "Escolha o Modelo Principal para Análise Detalhada:",
@@ -254,11 +233,11 @@ st.sidebar.markdown("Desenvolvido por seu AI Assistant")
 
 # --- Abas do Dashboard ---
 tab1, tab2, tab3, tab4, tab5 = st.tabs([
-    "1. Visão Geral dos Dados",
-    "2. Balanceamento de Dados",
-    "3. Comparação de Modelos",
-    "4. Análise do Melhor Modelo",
-    "5. Aplicação Gerencial"
+    "Visão Geral dos Dados",
+    "Balanceamento de Dados",
+    "Comparação de Modelos",
+    "Análise do Melhor Modelo",
+    "Aplicação Gerencial"
 ])
 
 with tab1:
@@ -287,8 +266,7 @@ 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()
@@ -312,8 +290,7 @@ 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.")
@@ -326,23 +303,21 @@ 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)
 
-    # --- Mensagens de depuração movidas para cá, se necessário ---
-    st.write("Shape X_train:", X_train.shape)
-    st.write("Shape X_test:", X_test.shape)
-    st.write("Shape y_train:", y_train.shape)
-    st.write("Shape y_test:", y_test.shape)
-    st.write("Shape do DataFrame (após pré-processamento):", df_processed.shape)
-    st.write("Tipos das colunas (após pré-processamento):", df_processed.dtypes)
-    st.write("Primeiras 5 linhas (após pré-processamento):", df_processed.head())
-    st.write("Classes em y_train:", np.unique(y_train))
-    # --- FIM NOVO ---
+    st.write(f"**Shape dos dados de treino:** {X_train.shape}")
+    st.write(f"**Shape dos dados de teste:** {X_test.shape}")
+    st.write(f"**Shape y_train:** {y_train.shape}")
+    st.write(f"**Shape y_test:** {y_test.shape}")
+    st.write(f"**Shape do DataFrame (após pré-processamento):** {df_processed.shape}")
+    st.write(f"**Tipos das colunas (após pré-processamento):**")
+    st.dataframe(df_processed.dtypes.astype(str).reset_index().rename(columns={'index': 'Coluna', 0: 'Tipo de Dado'}))
+    st.write(f"**Primeiras 5 linhas (após pré-processamento):**")
+    st.dataframe(df_processed.head())
+    st.write(f"**Classes em y_train:** {np.unique(y_train)}")
 
     if X_train.empty or y_train.empty:
         st.error("Os dados de treino estão vazios! Verifique o carregamento ou pré-processamento dos dados.")
@@ -352,8 +327,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")
@@ -395,8 +370,7 @@ 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")
@@ -404,11 +378,10 @@ 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.")
+                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]
 
@@ -421,8 +394,7 @@ 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)
@@ -437,8 +409,7 @@ 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)')
@@ -446,8 +417,7 @@ 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":
@@ -467,8 +437,7 @@ 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")
@@ -476,12 +445,10 @@ 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.")
+                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"]
 
@@ -490,8 +457,7 @@ 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'))
 
@@ -503,8 +469,7 @@ 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")