Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,528 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+from collections import Counter
+from imblearn.over_sampling import SMOTE
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.svm import SVC
+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
+import matplotlib.pyplot as plt
+import seaborn as sns
+import numpy as np
+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.")
+
+
+# --- Carregamento e Pré-processamento dos Dados ---
+@st.cache_data
+def load_data():
+    github_url = "https://raw.githubusercontent.com/Abdulraqib20/Customer-Personality-Analysis/refs/heads/main/marketing_campaign.csv"
+    try:
+        df = pd.read_csv(github_url, sep='\t')
+    except Exception as e:
+        st.error(f"Erro ao carregar o arquivo do GitHub: {e}")
+        st.stop()
+    return df
+
+
+@st.cache_data
+def preprocess_data(df):
+    df_processed = df.copy()
+
+    # Handle 'Dt_Customer' column
+    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
+
+    # --- 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
+    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
+
+    # 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')
+
+    # 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
+
+    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):
+    models = {
+        "K-Nearest Neighbors": KNeighborsClassifier(),
+        "Support Vector Machine": SVC(probability=True, random_state=42),
+        "Decision Tree": DecisionTreeClassifier(random_state=42),
+        "Random Forest": RandomForestClassifier(random_state=42),
+        "AdaBoosting": AdaBoostClassifier(random_state=42),
+        "Gradient Boosting": GradientBoostingClassifier(random_state=42),
+        "XGBoosting": XGBClassifier(use_label_encoder=False, eval_metric='logloss', random_state=42),
+        "LightGBM": LGBMClassifier(random_state=42)
+    }
+
+    results = {}
+
+    # Check if y_train has at least two classes before attempting to train
+    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 {}
+
+    # Check if X_train_raw has enough samples
+    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
+    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.")
+            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.")
+            return {}
+
+    for name, model in models.items():
+        if model_selected and name != model_selected:
+            continue
+
+        # Aplicar escalonamento apenas para os dados de treino e teste
+        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)
+            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)
+                if probas.shape[1] > 1:
+                    y_prob = probas[:, 1]
+                else:
+                    y_prob = probas[:, 0]
+            else:
+                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:
+                roc_auc = roc_auc_score(y_test, y_prob)
+                fpr, tpr, _ = roc_curve(y_test, y_prob)
+            else:
+                roc_auc = 0.5
+                fpr, tpr = [0, 1], [0, 1]
+
+            conf_matrix = confusion_matrix(y_test, y_pred)
+
+            results[name] = {
+                "Model": model,
+                "Accuracy": accuracy_score(y_test, y_pred),
+                "Precision": precision_score(y_test, y_pred, zero_division=0),
+                "Recall": recall_score(y_test, y_pred, zero_division=0),
+                "F1-score": f1_score(y_test, y_pred, zero_division=0),
+                "AUC": roc_auc,
+                "Confusion Matrix": conf_matrix,
+                "FPR": fpr,
+                "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
+            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))
+            }
+            continue
+    return results
+
+
+# --- Carregar e Pré-processar os dados ---
+df = load_data()
+df_processed = preprocess_data(df)
+
+X = df_processed.drop('Complain', axis=1)
+y = df_processed['Complain']
+
+# --- Sidebar para controle ---
+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.")
+
+# 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.")
+    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)
+            selector_rfe = selector_rfe.fit(X, y)
+            rfe_selected_features_indices = selector_rfe.support_
+            X = X.loc[:, rfe_selected_features_indices]
+            st.sidebar.success(f"RFE aplicado. Selecionadas {X.shape[1]} features.")
+        except Exception as e:
+            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.")
+        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 ===
+st.session_state['is_initial_call'] = True
+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
+
+model_choice = st.sidebar.selectbox(
+    "Escolha o Modelo Principal para Análise Detalhada:",
+    list(model_keys)
+)
+
+st.sidebar.markdown("---")
+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"
+])
+
+with tab1:
+    st.header("1. Visão Geral dos Dados")
+    st.subheader("Primeiras 5 Linhas do Dataset")
+    st.dataframe(df.head())
+
+    st.subheader("Estatísticas Descritivas")
+    st.dataframe(df.describe())
+
+    st.subheader("Informações sobre as Colunas")
+    buffer = io.StringIO()
+    df.info(buf=buffer)
+    s = buffer.getvalue()
+    st.text(s)
+
+    st.subheader("Distribuição da Variável Alvo ('Complain') Original")
+    fig, ax = plt.subplots(figsize=(6, 4))
+    sns.countplot(x=y, ax=ax)
+    ax.set_title("Distribuição Original da Variável 'Complain'")
+    ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
+    ax.set_ylabel("Contagem")
+    st.pyplot(fig)
+    st.write(f"Distribuição da variável 'Complain' original: {Counter(y)}")
+    st.warning("Observe o desbalanceamento da classe 'Complain' (poucas reclamações).")
+
+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**.")
+
+    X_display = X.copy()
+    y_display = y.copy()
+
+    if balance_data:
+        st.subheader("Resultados do SMOTE")
+        smote = SMOTE(random_state=42)
+        try:
+            if len(np.unique(y_display)) < 2:
+                st.error("SMOTE não pode ser aplicado: A variável alvo contém apenas uma classe.")
+                X_res, y_res = X_display, y_display
+            else:
+                X_res, y_res = smote.fit_resample(X_display, y_display)
+                st.success("Dados balanceados com sucesso!")
+                st.write(f"'Complain' variable distribution after SMOTE balancing: {Counter(y_res)}")
+
+                fig, ax = plt.subplots(figsize=(6, 4))
+                sns.countplot(x=y_res, ax=ax)
+                ax.set_title("Distribuição da Variável 'Complain' Após SMOTE")
+                ax.set_xlabel("Reclamou (0: Não, 1: Sim)")
+                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.")
+            X_res, y_res = X_display, y_display
+    else:
+        st.info("SMOTE desabilitado. O balanceamento não será aplicado.")
+        X_res, y_res = X_display, y_display
+
+    if X_res.empty or y_res.empty:
+        st.error("Erro: Os dados pós-balanceamento estão vazios. Verifique o dataset original e o pré-processamento.")
+        X_train, X_test, y_train, y_test = pd.DataFrame(), pd.DataFrame(), pd.Series(), pd.Series()
+    else:
+        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)
+        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.")
+            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 ---
+
+    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.")
+        st.stop()
+    if X_test.empty or y_test.empty:
+        st.error("Os dados de teste estão vazios! Verifique o carregamento ou pré-processamento dos dados.")
+        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.")
+
+with tab3:
+    st.header("3. Comparação de Modelos Supervisionados")
+    st.write("Avalie o desempenho de diferentes grupos de modelos supervisionados utilizando métricas chave.")
+
+    if st.button("Treinar e Comparar Todos os Modelos"):
+        with st.spinner("Treinando e avaliando modelos..."):
+            all_results = train_and_evaluate_models(X_train, X_test, y_train, y_test, StandardScaler())
+
+            valid_results = {k: v for k, v in all_results.items() if v['Model'] is not None}
+
+            if not valid_results:
+                st.warning("Nenhum modelo pôde ser treinado com sucesso. Verifique seus dados e configurações.")
+            else:
+                st.subheader("Métricas de Desempenho dos Modelos")
+                metrics_df = pd.DataFrame({
+                    "Modelo": list(valid_results.keys()),
+                    "Accuracy": [res["Accuracy"] for res in valid_results.values()],
+                    "Precision": [res["Precision"] for res in valid_results.values()],
+                    "Recall": [res["Recall"] for res in valid_results.values()],
+                    "F1-score": [res["F1-score"] for res in valid_results.values()],
+                    "AUC": [res["AUC"] for res in valid_results.values()]
+                })
+                st.dataframe(metrics_df.set_index("Modelo").sort_values(by="AUC", ascending=False))
+
+                st.subheader("Curvas ROC de Todos os Modelos")
+                fig_roc_all, ax_roc_all = plt.subplots(figsize=(10, 8))
+                for name, metrics in valid_results.items():
+                    ax_roc_all.plot(metrics['FPR'], metrics['TPR'], label=f'{name} (AUC = {metrics["AUC"]:.2f})')
+                ax_roc_all.plot([0, 1], [0, 1], 'k--', label='Aleatório (AUC = 0.50)')
+                ax_roc_all.set_xlabel('Taxa de Falsos Positivos (FPR)')
+                ax_roc_all.set_ylabel('Taxa de Verdadeiros Positivos (TPR)')
+                ax_roc_all.set_title('Curva ROC para Diferentes Modelos')
+                ax_roc_all.legend()
+                ax_roc_all.grid(True)
+                st.pyplot(fig_roc_all)
+
+                st.subheader("Discussão sobre a Escolha do Melhor Modelo")
+                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}**.")
+
+with tab4:
+    st.header("4. Análise Detalhada do Modelo Selecionado")
+    st.write(f"Foco na análise detalhada do modelo: **{model_choice}**.")
+
+    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)
+
+            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.")
+            else:
+                metrics = selected_model_results[model_choice]
+
+                st.subheader(f"Métricas de Desempenho para {model_choice}")
+                st.write(f"**Accuracy:** {metrics['Accuracy']:.4f}")
+                st.write(f"**Precision:** {metrics['Precision']:.4f}")
+                st.write(f"**Recall:** {metrics['Recall']:.4f}")
+                st.write(f"**F1-score:** {metrics['F1-score']:.4f}")
+                st.write(f"**AUC:** {metrics['AUC']:.4f}")
+
+                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.plot(cmap=plt.cm.Blues, ax=ax_cm)
+                ax_cm.set_title(f'Matriz de Confusão para {model_choice}')
+                st.pyplot(fig_cm)
+
+                st.markdown("""
+                **Interpretação da Matriz de Confusão:**
+                - **Verdadeiros Negativos (TN):** Clientes que não reclamaram e foram previstos corretamente.
+                - **Falsos Positivos (FP):** Clientes que não reclamaram, mas foram erroneamente previstos como reclamantes (custo de intervenção desnecessária).
+                - **Falsos Negativos (FN):** Clientes que reclamaram, mas foram erroneamente previstos como não reclamantes (custo de perda de oportunidade de intervenção, insatisfação).
+                - **Verdadeiros Positivos (TP):** Clientes que reclamaram e foram previstos corretamente.
+                """)
+
+                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([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)')
+                ax_roc_single.set_title(f'Curva ROC para {model_choice}')
+                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.subheader("Sensibilidade aos Hiperparâmetros")
+                if model_choice == "K-Nearest Neighbors":
+                    st.markdown("""
+                    O KNN é altamente sensível ao `n_neighbors` (número de vizinhos). Pequenos valores podem causar overfitting, enquanto valores grandes podem levar a underfitting. A métrica de distância e a escala dos dados também são cruciais.
+                    """)
+                elif model_choice == "Random Forest":
+                    st.markdown("""
+                    O Random Forest é impactado por `n_estimators` (número de árvores), `max_depth` (profundidade máxima) e `min_samples_leaf`. Mais árvores geralmente melhoram o desempenho, mas `max_depth` e `min_samples_leaf` controlam a complexidade e evitam o overfitting das árvores individuais.
+                    """)
+                elif model_choice == "Support Vector Machine":
+                    st.markdown("""
+                    O SVM é sensível ao `C` (parâmetro de regularização) e `kernel` (função de kernel). `C` controla a penalidade por erros de classificação, e o `kernel` define a forma do limite de decisão (linear, RBF, etc.). A escala dos dados é fundamental para o SVM.
+                    """)
+                elif model_choice == "XGBoosting" or model_choice == "LightGBM":
+                    st.markdown("""
+                    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).")
+
+with tab5:
+    st.header("5. Tomada de Decisão e Aplicação Gerencial")
+    st.write("Análise dos fatores que mais influenciam a ocorrência de reclamações e recomendações práticas.")
+
+    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)
+
+            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.")
+            else:
+                model_instance = selected_model_results[model_choice]["Model"]
+
+                st.subheader("Importância das Variáveis")
+
+                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 = importance_df.sort_values(by='Importância Relativa', ascending=False)
+                    st.dataframe(importance_df.head(10).set_index('Variável'))
+
+                    fig_imp, ax_imp = plt.subplots(figsize=(10, 6))
+                    sns.barplot(x='Importância Relativa', y='Variável', data=importance_df.head(10), ax=ax_imp)
+                    ax_imp.set_title('Top 10 Variáveis Mais Importantes')
+                    st.pyplot(fig_imp)
+
+                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.subheader("Análise e Recomendações Gerenciais")
+
+                st.markdown("""
+                Com base nas variáveis mais importantes, podemos formular estratégias proativas:
+
+                **Exemplo de Cenário e Recomendação (Ajuste com base nos resultados reais das suas variáveis importantes):**
+
+                Se, por exemplo, 'MntWines' (gasto com vinho), 'NumWebVisitsMonth' (visitas ao site) e 'Dt_Customer' (dias desde a última compra) forem as variáveis mais importantes:
+
+                * **Clientes com alto gasto em vinho (`MntWines`)** que apresentam **alta frequência de visitas ao site (`NumWebVisitsMonth`) mas baixo engajamento recente (`Dt_Customer` elevado)** podem estar enfrentando dificuldades para encontrar produtos, informações ou ter problemas não resolvidos.
+
+                **Recomendação Gerencial:**
+
+                Priorize esses clientes com **ações proativas de atendimento e retenção**. Por exemplo:
+                1.  **Suporte Proativo:** Monitore clientes com alto `NumWebVisitsMonth` que não resultam em compra ou que têm histórico de altos gastos e ofereça ajuda via chat ou contato telefônico personalizado.
+                2.  **Campanhas de Reengajamento:** Crie campanhas segmentadas para clientes com `Dt_Customer` elevado, oferecendo descontos em seus produtos preferidos (ex: vinhos) ou convidando-os a fornecer feedback sobre a experiência recente.
+                3.  **Melhoria na Experiência Online:** Analise as páginas mais visitadas por esses clientes com `NumWebVisitsMonth` alto para identificar gargalos ou informações ausentes que possam estar gerando frustração.
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+                Ao antecipar e resolver proativamente as insatisfações, a empresa pode **melhorar a experiência do consumidor, reduzir as taxas de reclamação e aumentar a lealdade do cliente.**
+                """)