Update app.py

app.py

@@ -1,698 +1,404 @@
-# app.py - Dashboard Interativo com Dataset do Hugging Face
 import streamlit as st
 import pandas as pd
 import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-import joblib
-from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
-                           roc_auc_score, roc_curve, confusion_matrix)
+import plotly.express as px
+import plotly.graph_objects as go
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import (
+    classification_report,
+    confusion_matrix,
+    roc_curve,
+    roc_auc_score,
+    precision_recall_fscore_support,
+)
 from sklearn.linear_model import LogisticRegression
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.svm import SVC
-from sklearn.model_selection import train_test_split
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-import plotly.graph_objects as go
-import plotly.express as px
+from imblearn.over_sampling import SMOTE
 import time
 import warnings
-warnings.filterwarnings('ignore')
-
-# Tentar importar SMOTE, mas continuar funcionando mesmo se falhar
-try:
-    from imblearn.over_sampling import SMOTE
-    SMOTE_AVAILABLE = True
-except ImportError as e:
-    st.warning(f"⚠️ SMOTE não disponível: {e}. Continuando sem balanceamento automático.")
-    SMOTE_AVAILABLE = False
-
-# Tentar importar a biblioteca datasets do Hugging Face
-try:
-    from datasets import load_dataset
-    DATASETS_AVAILABLE = True
-except ImportError as e:
-    st.error(f"❌ Biblioteca 'datasets' não disponível: {e}")
-    DATASETS_AVAILABLE = False
-
-# Configuração da página
+
+warnings.filterwarnings("ignore")
+
+# --- Configuração da Página ---
 st.set_page_config(
-    page_title="Dashboard - Cancelamento de Reservas",
+    page_title="Dashboard de Previsão de Cancelamento",
     page_icon="🏨",
     layout="wide",
-    initial_sidebar_state="expanded"
 )
 
-# CSS customizado
-st.markdown("""
-<style>
-    .main-header {
-        font-size: 2.5rem;
-        color: #1f77b4;
-        text-align: center;
-        margin-bottom: 2rem;
-    }
-    .metric-card {
-        background-color: #f0f2f6;
-        padding: 1rem;
-        border-radius: 10px;
-        border-left: 4px solid #1f77b4;
-        margin: 0.5rem 0;
-    }
-    .best-model {
-        background-color: #d4edda;
-        border-left: 4px solid #28a745;
-        padding: 1rem;
-        border-radius: 10px;
-        margin: 1rem 0;
-    }
-    .parameter-section {
-        background-color: #e8f4f8;
-        padding: 1rem;
-        border-radius: 10px;
-        margin: 1rem 0;
-    }
-    .data-source-section {
-        background-color: #e7f3ff;
-        padding: 2rem;
-        border-radius: 10px;
-        border: 2px solid #2196F3;
-        text-align: center;
-        margin: 2rem 0;
-    }
-    .upload-section {
-        background-color: #fff3cd;
-        padding: 2rem;
-        border-radius: 10px;
-        border: 2px dashed #ffc107;
-        text-align: center;
-        margin: 2rem 0;
-    }
-</style>
-""", unsafe_allow_html=True)
-
-class HotelBookingDashboard:
-    def __init__(self):
-        self.models = {}
-        self.results = {}
-        self.X_train = None
-        self.X_test = None
-        self.y_train = None
-        self.y_test = None
-        self.scaler = StandardScaler()
-        self.is_data_loaded = False
-    
-    def load_huggingface_dataset(self):
-        """Carrega o dataset do Hugging Face"""
-        try:
-            with st.spinner("🌐 Carregando dataset do Hugging Face..."):
-                # Carregar o dataset
-                dataset = load_dataset("SIEP/hotel_bookings")
-                
-                # Converter para pandas DataFrame
-                if 'train' in dataset:
-                    df = dataset['train'].to_pandas()
-                else:
-                    # Se não tiver split 'train', pega o primeiro split disponível
-                    first_split = list(dataset.keys())[0]
-                    df = dataset[first_split].to_pandas()
-                
-                st.success(f"✅ Dataset carregado: {df.shape[0]} linhas × {df.shape[1]} colunas")
-                return df
-                
-        except Exception as e:
-            st.error(f"❌ Erro ao carregar dataset do Hugging Face: {str(e)}")
-            return None
-    
-    def load_and_preprocess_data(self, df):
-        """Carrega e pré-processa o dataset"""
-        try:
-            st.info("🔄 Iniciando pré-processamento dos dados...")
-            
-            # Fazer uma cópia do dataframe
-            df_clean = df.copy()
-            
-            # 1. Identificar a coluna target
-            target_col = self._identify_target_column(df_clean)
-            if not target_col:
-                st.error("❌ Não foi possível identificar a coluna target. Procure por colunas como 'is_canceled', 'canceled', etc.")
-                return False
-            
-            st.success(f"✅ Coluna target identificada: '{target_col}'")
-            
-            # 2. Tratamento de valores missing
-            df_clean = self._handle_missing_values(df_clean)
-            
-            # 3. Codificar variáveis categóricas
-            df_encoded = self._encode_categorical_variables(df_clean)
-            
-            # 4. Separar features e target
-            X = df_encoded.drop(columns=[target_col])
-            y = df_encoded[target_col]
-            
-            # 5. Dividir e balancear dados
-            success = self._split_and_balance_data(X, y)
-            
-            if success:
-                self.is_data_loaded = True
-                st.success("✅ Dados carregados e pré-processados com sucesso!")
-                return True
-            else:
-                return False
-                
-        except Exception as e:
-            st.error(f"❌ Erro no pré-processamento: {str(e)}")
-            return False
-    
-    def _identify_target_column(self, df):
-        """Identifica a coluna target automaticamente"""
-        target_candidates = ['is_canceled', 'canceled', 'cancelled', 'is_cancelled', 'booking_status']
-        
-        for candidate in target_candidates:
-            if candidate in df.columns:
-                # Se encontrou, renomear para padronizar
-                if candidate != 'is_canceled':
-                    df.rename(columns={candidate: 'is_canceled'}, inplace=True)
-                return 'is_canceled'
-        
-        # Se não encontrou, verificar colunas binárias
-        binary_cols = []
-        for col in df.columns:
-            if df[col].dtype in ['int64', 'float64'] and df[col].nunique() == 2:
-                binary_cols.append(col)
-        
-        if binary_cols:
-            st.warning(f"🔍 Colunas binárias encontradas: {binary_cols}")
-            return binary_cols[0]
-        
+# --- Título e Contexto ---
+st.title("🏨 Dashboard de Previsão de Cancelamento de Reservas")
+st.markdown(
+    """
+**Sua Missão como Analista de Dados:**
+Você é analista de dados em uma rede internacional de hotéis. Sua missão é desenvolver e comparar três modelos preditivos (Regressão Logística, KNN e SVM) capazes de identificar antecipadamente as reservas com maior probabilidade de cancelamento. Esta ferramenta permite simular esse processo de forma interativa.
+"""
+)
+
+
+# --- Funções de Processamento (Otimizadas com Cache) ---
+@st.cache_data
+def load_data(file_path):
+    """Carrega o dataset principal. O cache evita recarregar a cada interação."""
+    try:
+        df = pd.read_csv(file_path)
+        return df
+    except FileNotFoundError:
+        st.error(
+            f"Erro: Arquivo '{file_path}' não encontrado. Faça o upload do arquivo para o seu Hugging Face Space."
+        )
         return None
-    
-    def _handle_missing_values(self, df):
-        """Trata valores missing seguindo as boas práticas"""
-        df_clean = df.copy()
-        
-        # Remover coluna company se existir (muitos NAs)
-        if 'company' in df_clean.columns:
-            df_clean.drop('company', axis=1, inplace=True)
-        
-        # Preencher outros missing values
-        for col in df_clean.columns:
-            if df_clean[col].isnull().sum() > 0:
-                if df_clean[col].dtype == 'object':
-                    # Preencher com moda para categóricas
-                    df_clean[col].fillna(df_clean[col].mode()[0], inplace=True)
-                else:
-                    # Preencher com mediana para numéricas
-                    df_clean[col].fillna(df_clean[col].median(), inplace=True)
-        
-        return df_clean
-    
-    def _encode_categorical_variables(self, df):
-        """Codifica variáveis categóricas"""
-        df_encoded = df.copy()
-        
-        # Identificar colunas categóricas
-        categorical_cols = df_encoded.select_dtypes(include=['object']).columns.tolist()
-        
-        if categorical_cols:
-            st.info(f"📊 Codificando {len(categorical_cols)} variáveis categóricas...")
-            
-            # Label Encoding para alta cardinalidade (>20 categorias)
-            high_cardinality = [col for col in categorical_cols if df_encoded[col].nunique() > 20]
-            low_cardinality = [col for col in categorical_cols if df_encoded[col].nunique() <= 20]
-            
-            for col in high_cardinality:
-                le = LabelEncoder()
-                df_encoded[col] = le.fit_transform(df_encoded[col].astype(str))
-            
-            # One-Hot Encoding para baixa cardinalidade
-            if low_cardinality:
-                df_encoded = pd.get_dummies(df_encoded, columns=low_cardinality, drop_first=True)
-        
-        return df_encoded
-    
-    def _split_and_balance_data(self, X, y):
-        """Divide e balanceia os dados"""
-        try:
-            # Converter todas as colunas para numérico
-            X = X.apply(pd.to_numeric, errors='coerce').fillna(0)
-            
-            # Dividir dados
-            X_train, X_test, y_train, y_test = train_test_split(
-                X, y, test_size=0.3, random_state=42, stratify=y
-            )
-            
-            # Aplicar SMOTE se disponível e necessário
-            if (SMOTE_AVAILABLE and 
-                y_train.value_counts().min() / y_train.value_counts().max() < 0.3):
-                smote = SMOTE(random_state=42)
-                X_train, y_train = smote.fit_resample(X_train, y_train)
-                st.info("✅ SMOTE aplicado para balanceamento dos dados")
-            elif not SMOTE_AVAILABLE:
-                st.warning("⚠️ SMOTE não disponível. Usando dados originais (pode haver desbalanceamento).")
-            else:
-                st.info("ℹ️ Dados já balanceados, SMOTE não aplicado.")
-            
-            # Escalonar features
-            X_train_scaled = self.scaler.fit_transform(X_train)
-            X_test_scaled = self.scaler.transform(X_test)
-            
-            self.X_train = X_train_scaled
-            self.X_test = X_test_scaled
-            self.y_train = y_train
-            self.y_test = y_test
-            
-            st.success(f"✅ Dados divididos: Treino {X_train_scaled.shape}, Teste {X_test_scaled.shape}")
-            return True
-            
-        except Exception as e:
-            st.error(f"❌ Erro ao dividir dados: {str(e)}")
-            return False
-    
-    def train_logistic_regression(self, C=1.0, penalty='l2', solver='lbfgs'):
-        """Treina Regressão Logística"""
-        model = LogisticRegression(C=C, penalty=penalty, solver=solver, 
-                                 max_iter=1000, random_state=42)
-        start_time = time.time()
-        model.fit(self.X_train, self.y_train)
-        training_time = time.time() - start_time
-        return model, training_time
-    
-    def train_knn(self, n_neighbors=5, metric='euclidean', weights='uniform'):
-        """Treina KNN"""
-        model = KNeighborsClassifier(n_neighbors=n_neighbors, metric=metric, 
-                                   weights=weights)
-        start_time = time.time()
-        model.fit(self.X_train, self.y_train)
-        training_time = time.time() - start_time
-        return model, training_time
-    
-    def train_svm(self, C=1.0, kernel='rbf', gamma='scale'):
-        """Treina SVM"""
-        model = SVC(C=C, kernel=kernel, gamma=gamma, probability=True, 
-                  random_state=42)
-        start_time = time.time()
-        model.fit(self.X_train, self.y_train)
-        training_time = time.time() - start_time
-        return model, training_time
-    
-    def evaluate_model(self, model, model_name, training_time):
-        """Avalia modelo e retorna métricas"""
-        y_pred = model.predict(self.X_test)
-        y_proba = model.predict_proba(self.X_test)[:, 1]
-        
-        metrics = {
-            'Acurácia': accuracy_score(self.y_test, y_pred),
-            'Precisão': precision_score(self.y_test, y_pred, zero_division=0),
-            'Recall': recall_score(self.y_test, y_pred, zero_division=0),
-            'F1-Score': f1_score(self.y_test, y_pred, zero_division=0),
-            'AUC-ROC': roc_auc_score(self.y_test, y_proba),
-            'Tempo Treino (s)': training_time
-        }
-        
-        # Curva ROC
-        fpr, tpr, _ = roc_curve(self.y_test, y_proba)
-        roc_data = {'fpr': fpr, 'tpr': tpr, 'auc': metrics['AUC-ROC']}
-        
-        # Matriz de confusão
-        cm = confusion_matrix(self.y_test, y_pred)
-        
-        return metrics, roc_data, cm
-    
-    def plot_roc_comparison(self, current_roc, current_model_name):
-        """Plota comparação de curvas ROC"""
-        fig = go.Figure()
-        
-        # Curva do modelo atual
-        fig.add_trace(go.Scatter(
-            x=current_roc['fpr'], y=current_roc['tpr'],
-            mode='lines', name=f'{current_model_name} (AUC = {current_roc["auc"]:.3f})',
-            line=dict(width=3, color='red')
-        ))
-        
-        # Curvas dos outros modelos
-        colors = ['blue', 'green', 'orange', 'purple']
-        for i, (model_name, model) in enumerate(self.models.items()):
-            if model_name != current_model_name:
-                try:
-                    y_proba = model.predict_proba(self.X_test)[:, 1]
-                    fpr, tpr, _ = roc_curve(self.y_test, y_proba)
-                    auc = roc_auc_score(self.y_test, y_proba)
-                    
-                    fig.add_trace(go.Scatter(
-                        x=fpr, y=tpr, mode='lines',
-                        name=f'{model_name} (AUC = {auc:.3f})',
-                        line=dict(width=2, color=colors[i % len(colors)], dash='dash')
-                    ))
-                except:
-                    continue
-        
-        # Linha de referência
-        fig.add_trace(go.Scatter(
-            x=[0, 1], y=[0, 1], mode='lines',
-            name='Classificador Aleatório', line=dict(dash='dash', color='grey')
-        ))
-        
-        fig.update_layout(
-            title='Comparação das Curvas ROC',
-            xaxis_title='Taxa de Falsos Positivos',
-            yaxis_title='Taxa de Verdadeiros Positivos',
-            width=600, height=500
+
+
+@st.cache_data
+def preprocess_data(df):
+    """Aplica o pré-processamento seguindo as diretrizes da Tarefa 3."""
+    df_proc = df.copy()
+
+    # 1. Tratamento de valores faltantes
+    # Preenche 'country' com a moda (mais comum)
+    df_proc["country"].fillna(df_proc["country"].mode()[0], inplace=True)
+    # Para 'agent' e 'company', NaN significa "Não Aplicável" ou "Direto". Substituímos por 0.
+    df_proc["agent"].fillna(0, inplace=True)
+    df_proc["company"].fillna(0, inplace=True)
+    # Assume que NaN em 'children' significa 0 crianças.
+    df_proc["children"].fillna(0, inplace=True)
+
+    # 2. Tratamento de Outliers (simples, para performance)
+    # Remove 'adr' (Average Daily Rate) irrealista
+    df_proc = df_proc[(df_proc["adr"] >= 0) & (df_proc["adr"] < 5000)]
+
+    # 3. Engenharia de Features (simples)
+    # Cria 'total_stay' e 'total_guests'
+    df_proc["total_stay"] = (
+        df_proc["stays_in_weekend_nights"] + df_proc["stays_in_week_nights"]
+    )
+    df_proc["total_guests"] = (
+        df_proc["adults"] + df_proc["children"] + df_proc["babies"]
+    )
+
+    # Remove hóspedes com 0 pessoas (inválido)
+    df_proc = df_proc[df_proc["total_guests"] > 0]
+
+    # 4. Seleção de Variáveis (Baseado na Tarefa 3 - 8 a 15 features)
+    # Variável Alvo
+    y = df_proc["is_canceled"]
+
+    # Features Numéricas
+    numeric_features = [
+        "lead_time",
+        "total_stay",
+        "total_guests",
+        "adr",
+        "previous_cancellations",
+        "previous_bookings_not_canceled",
+        "booking_changes",
+        "days_in_waiting_list",
+        "total_of_special_requests",
+    ]
+
+    # Features Categóricas
+    categorical_features = [
+        "hotel",
+        "market_segment",
+        "distribution_channel",
+        "deposit_type",
+        "customer_type",
+        "is_repeated_guest",
+    ]
+
+    # Garante que todas as colunas existem
+    all_features = numeric_features + categorical_features
+    df_features = df_proc[all_features]
+
+    # 5. Codificação de Variáveis Categóricas (Dummies)
+    X = pd.get_dummies(df_features, columns=categorical_features, drop_first=True)
+
+    return X, y
+
+
+# --- Funções do Modelo ---
+def get_model(algorithm, params):
+    """Instancia o modelo com base nos parâmetros do usuário."""
+    if algorithm == "Regressão Logística":
+        model = LogisticRegression(
+            C=params["C_rl"],
+            solver="liblinear",  # Bom para datasets menores e binários
+            random_state=42,
+            max_iter=1000,
+        )
+    elif algorithm == "KNN":
+        model = KNeighborsClassifier(
+            n_neighbors=params["k"], metric=params["distance_metric"]
         )
-        
-        return fig
+    elif algorithm == "SVM":
+        model = SVC(
+            C=params["C_svm"],
+            kernel=params["kernel"],
+            gamma=params["gamma"] if params["kernel"] == "rbf" else "auto",
+            probability=True,  # Necessário para Curva ROC
+            random_state=42,
+        )
+    return model
 
-def main():
-    # Header principal
-    st.markdown('<h1 class="main-header">🏨 Dashboard - Cancelamento de Reservas</h1>', 
-                unsafe_allow_html=True)
-    
-    # Inicializar dashboard
-    dashboard = HotelBookingDashboard()
-    
-    # ===== SEÇÃO DE CARREGAMENTO DE DADOS =====
-    if not dashboard.is_data_loaded:
-        st.markdown("""
-        <div class="data-source-section">
-            <h2>📊 Escolha a Fonte dos Dados</h2>
-            <p style="font-size: 1.2rem; margin-bottom: 1.5rem;">
-                <strong>Carregue os dados do Hugging Face ou faça upload do seu próprio dataset</strong>
-            </p>
-        </div>
-        """, unsafe_allow_html=True)
-        
-        # Opções de carregamento
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.markdown("### 🌐 Dataset do Hugging Face")
-            st.markdown("""
-            **Vantagens:**
-            - Dataset pré-processado
-            - Estrutura consistente
-            - Sem necessidade de upload
-            """)
-            
-            if DATASETS_AVAILABLE:
-                if st.button("🚀 Carregar do Hugging Face", type="primary", use_container_width=True):
-                    with st.spinner("Carregando dataset SIEP/hotel_bookings..."):
-                        df = dashboard.load_huggingface_dataset()
-                        if df is not None:
-                            success = dashboard.load_and_preprocess_data(df)
-                            if success:
-                                st.session_state.data_processed = True
-                                st.session_state.dashboard = dashboard
-                                st.rerun()
-            else:
-                st.error("Biblioteca 'datasets' não disponível")
-                st.info("Adicione 'datasets' ao requirements.txt")
-        
-        with col2:
-            st.markdown("### 📁 Upload Manual")
-            st.markdown("""
-            **Use seu próprio dataset:**
-            - Formato CSV
-            - Coluna target: 'is_canceled'
-            - Estrutura personalizada
-            """)
-            
-            uploaded_file = st.file_uploader(
-                "Selecione o arquivo CSV",
-                type=['csv'],
-                help="Faça upload do dataset de reservas de hotel"
-            )
-            
-            if uploaded_file is not None:
-                try:
-                    with st.spinner("Carregando arquivo..."):
-                        df = pd.read_csv(uploaded_file)
-                        st.success(f"✅ Dataset carregado: {df.shape[0]} linhas × {df.shape[1]} colunas")
-                        
-                        # Preview
-                        with st.expander("👀 Visualizar Dataset"):
-                            st.dataframe(df.head(10))
-                        
-                        if st.button("🔄 Processar Dataset", type="primary", use_container_width=True):
-                            success = dashboard.load_and_preprocess_data(df)
-                            if success:
-                                st.session_state.data_processed = True
-                                st.session_state.dashboard = dashboard
-                                st.rerun()
-                            
-                except Exception as e:
-                    st.error(f"❌ Erro ao carregar arquivo: {str(e)}")
-        
-        # Informações sobre o dataset
-        with st.expander("📋 Sobre o Dataset", expanded=True):
-            st.markdown("""
-            **Dataset: Hotel Bookings (SIEP/hotel_bookings)**
-            
-            Este dataset contém informações de reservas de hotel incluindo:
-            
-            **Variáveis Principais:**
-            - `is_canceled`: Indicador de cancelamento (target)
-            - `lead_time`: Tempo entre reserva e chegada
-            - `adr`: Taxa diária média
-            - `adults`, `children`, `babies`: Número de hóspedes
-            - `country`, `market_segment`: Informações demográficas
-            - `previous_cancellations`: Histórico de cancelamentos
-            - `booking_changes`: Número de mudanças na reserva
-            
-            **Objetivo:** Prever se uma reserva será cancelada com base nas características da reserva.
-            """)
-        
-        return
-    
-    # ===== SEÇÃO PRINCIPAL (quando dados estão carregados) =====
-    
-    # Recuperar o dashboard do session_state se necessário
-    if 'dashboard' in st.session_state:
-        dashboard = st.session_state.dashboard
+
+# --- Funções de Plotagem ---
+def plot_roc_curve(y_test, y_proba, auc):
+    """Plota a curva ROC usando Plotly."""
+    fpr, tpr, _ = roc_curve(y_test, y_proba)
+    fig = px.area(
+        x=fpr,
+        y=tpr,
+        title=f"Curva ROC (AUC = {auc:.4f})",
+        labels=dict(x="Taxa de Falsos Positivos", y="Taxa de Verdadeiros Positivos"),
+        width=700,
+        height=500,
+    )
+    fig.add_shape(type="line", line=dict(dash="dash"), x0=0, x1=1, y0=0, y1=1)
+    fig.update_layout(
+        yaxis_title="Taxa de Verdadeiros Positivos (Sensibilidade)",
+        xaxis_title="Taxa de Falsos Positivos (1 - Especificidade)",
+    )
+    return fig
+
+
+def plot_confusion_matrix(y_test, y_pred):
+    """Plota a Matriz de Confusão usando Plotly."""
+    cm = confusion_matrix(y_test, y_pred)
+    cm_text = [[str(y) for y in x] for x in cm]
     
-    # Sidebar - Configurações do Modelo
-    st.sidebar.header("⚙️ Configurações do Modelo")
+    fig = px.imshow(
+        cm,
+        labels=dict(
+            x="Previsão do Modelo", y="Valor Real", color="Contagem"
+        ),
+        x=["Não Cancelou (0)", "Cancelou (1)"],
+        y=["Não Cancelou (0)", "Cancelou (1)"],
+        color_continuous_scale="Blues",
+        text_auto=True,
+    )
     
-    # Seleção do algoritmo
+    fig.update_layout(
+        title="Matriz de Confusão",
+        xaxis_title="Previsão do Modelo",
+        yaxis_title="Valor Real",
+        width=600,
+        height=500,
+    )
+    return fig
+
+
+# --- Configuração da Sidebar (Controles) ---
+st.sidebar.header("⚙️ Painel de Controle do Analista")
+
+df_original = load_data("hotel_bookings.csv")
+
+if df_original is not None:
+    # 1. Controles de Amostragem e Divisão
+    st.sidebar.subheader("1. Configuração dos Dados")
+    sample_size = st.sidebar.slider(
+        "Tamanho da Amostra para Treinamento",
+        min_value=1000,
+        max_value=20000,
+        value=3000,
+        step=500,
+        help="Use uma amostra menor para velocidade ou maior para precisão. O dataset completo tem >100k linhas.",
+    )
+    test_split_pct = st.sidebar.slider(
+        "Percentual de Dados para Teste",
+        min_value=0.1,
+        max_value=0.5,
+        value=0.3,
+        step=0.05,
+    )
+    use_smote = st.sidebar.checkbox(
+        "Aplicar SMOTE (Corrigir Desbalanceamento)",
+        value=False,
+        help="Pode melhorar o 'Recall', mas aumenta o tempo de treino.",
+    )
+
+    # 2. Seleção de Algoritmo
+    st.sidebar.subheader("2. Seleção do Algoritmo")
     algorithm = st.sidebar.selectbox(
-        "Escolha o algoritmo:",
-        ["Regressão Logística", "KNN", "SVM"],
-        index=0
+        "Escolha o Algoritmo",
+        ("Regressão Logística", "KNN", "SVM"),
     )
-    
-    # Parâmetros específicos
-    st.sidebar.subheader("📊 Parâmetros do Modelo")
-    
+
+    # 3. Ajuste de Hiperparâmetros (Dinâmico)
+    st.sidebar.subheader(f"3. Ajuste de Parâmetros ({algorithm})")
+    params = {}
+
     if algorithm == "Regressão Logística":
-        st.sidebar.markdown('<div class="parameter-section">', unsafe_allow_html=True)
-        C_lr = st.sidebar.slider("Parâmetro C (Regularização)", 0.01, 10.0, 1.0, 0.01)
-        penalty = st.sidebar.selectbox("Tipo de Penalidade", ["l2", "l1"])
-        solver = st.sidebar.selectbox("Algoritmo", ["lbfgs", "liblinear", "saga"])
-        st.sidebar.markdown('</div>', unsafe_allow_html=True)
-        
+        params["C_rl"] = st.sidebar.select_slider(
+            "C (Força da Regularização)",
+            options=[0.01, 0.1, 1.0, 10.0, 100.0],
+            value=1.0,
+            help="Valores menores = mais regularização (modelo mais simples).",
+        )
+
     elif algorithm == "KNN":
-        st.sidebar.markdown('<div class="parameter-section">', unsafe_allow_html=True)
-        n_neighbors = st.sidebar.slider("Número de Vizinhos (k)", 1, 50, 5)
-        metric = st.sidebar.selectbox("Métrica de Distância", 
-                                    ["euclidean", "manhattan", "minkowski"])
-        weights = st.sidebar.selectbox("Pesos", ["uniform", "distance"])
-        st.sidebar.markdown('</div>', unsafe_allow_html=True)
-        
-    else:  # SVM
-        st.sidebar.markdown('<div class="parameter-section">', unsafe_allow_html=True)
-        C_svm = st.sidebar.slider("Parâmetro C", 0.01, 10.0, 1.0, 0.01)
-        kernel = st.sidebar.selectbox("Kernel", ["rbf", "linear", "poly", "sigmoid"])
-        gamma = st.sidebar.selectbox("Gamma", ["scale", "auto"])
-        st.sidebar.markdown('</div>', unsafe_allow_html=True)
-    
-    # Botão de treinamento
-    train_button = st.sidebar.button("🚀 Treinar Modelo", type="primary", use_container_width=True)
-    
-    # Informações na sidebar
-    st.sidebar.markdown("---")
-    st.sidebar.info("""
-    **📊 Status do Dataset:**
-    - ✅ Dados carregados
-    - 📈 Pronto para treinamento
-    """)
-    
-    st.sidebar.markdown("---")
-    if st.sidebar.button("🔄 Carregar Novo Dataset", use_container_width=True):
-        st.session_state.clear()
-        st.rerun()
-    
-    # Conteúdo principal - Status dos dados
-    st.subheader("📈 Status dos Dados Carregados")
-    
-    col1, col2, col3, col4 = st.columns(4)
-    with col1:
-        st.metric("Amostras de Treino", f"{dashboard.X_train.shape[0]:,}")
-    with col2:
-        st.metric("Amostras de Teste", f"{dashboard.X_test.shape[0]:,}")
-    with col3:
-        st.metric("Features", f"{dashboard.X_train.shape[1]}")
-    with col4:
-        balance = pd.Series(dashboard.y_train).value_counts()
-        if len(balance) == 2:
-            st.metric("Balanceamento", f"{balance[0]}:{balance[1]}")
+        params["k"] = st.sidebar.slider(
+            "k (Número de Vizinhos)", min_value=3, max_value=21, value=5, step=2
+        )
+        params["distance_metric"] = st.sidebar.selectbox(
+            "Métrica de Distância", ("euclidean", "manhattan")
+        )
+
+    elif algorithm == "SVM":
+        params["kernel"] = st.sidebar.selectbox("Kernel", ("linear", "rbf"))
+        params["C_svm"] = st.sidebar.select_slider(
+            "C (Regularização)",
+            options=[0.1, 1.0, 10.0, 50.0],
+            value=1.0,
+            help="Controla o trade-off entre erro de treino e margem.",
+        )
+        if params["kernel"] == "rbf":
+            params["gamma"] = st.sidebar.select_slider(
+                "Gamma (Influência do Ponto)",
+                options=[0.001, 0.01, 0.1, 1.0],
+                value=0.1,
+            )
         else:
-            st.metric("Classes", len(balance))
-    
-    # Análise exploratória
-    with st.expander("🔍 Análise Exploratória dos Dados"):
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Distribuição do target
-            fig, ax = plt.subplots(figsize=(8, 6))
-            balance = pd.Series(dashboard.y_train).value_counts()
-            ax.pie(balance.values, labels=['Não Cancelado', 'Cancelado'], autopct='%1.1f%%', startangle=90)
-            ax.set_title('Distribuição de Cancelamentos')
-            st.pyplot(fig)
-        
-        with col2:
-            # Estatísticas básicas
-            st.write("**Estatísticas do Dataset:**")
-            stats_df = pd.DataFrame({
-                'Métrica': ['Total de Amostras', 'Features', 'Taxa de Cancelamento', 'Balanceamento'],
-                'Valor': [
-                    f"{dashboard.X_train.shape[0] + dashboard.X_test.shape[0]:,}",
-                    f"{dashboard.X_train.shape[1]}",
-                    f"{(dashboard.y_train.sum() + dashboard.y_test.sum()) / (len(dashboard.y_train) + len(dashboard.y_test)) * 100:.1f}%",
-                    f"{balance[0]}:{balance[1]}" if len(balance) == 2 else "Múltiplas classes"
-                ]
-            })
-            st.dataframe(stats_df, hide_index=True)
-    
-    # Conteúdo principal - Resultados do Modelo
-    if train_button:
-        with st.spinner(f"Treinando modelo {algorithm}..."):
-            # Treinar modelo
+            params["gamma"] = "auto"
+
+    # --- Botão de Execução ---
+    st.sidebar.markdown("---")
+    run_button = st.sidebar.button("Executar Análise", type="primary")
+
+    # --- Área Principal de Exibição ---
+    if run_button:
+        with st.spinner(
+            f"Executando pipeline para {algorithm} com {sample_size} amostras..."
+        ):
+            start_time = time.time()
+
+            # 1. Amostrar
+            df_sample = df_original.sample(n=sample_size, random_state=42)
+
+            # 2. Pré-processar
+            X, y = preprocess_data(df_sample)
+
+            # 3. Dividir (Train/Test)
+            X_train, X_test, y_train, y_test = train_test_split(
+                X, y, test_size=test_split_pct, random_state=42, stratify=y
+            )
+
+            # 4. Escalonar (MUITO importante para KNN e SVM)
+            scaler = StandardScaler()
+            X_train_scaled = scaler.fit_transform(X_train)
+            X_test_scaled = scaler.transform(X_test)
+
+            # 5. Aplicar SMOTE (Opcional)
+            if use_smote:
+                smote = SMOTE(random_state=42)
+                X_train_scaled, y_train = smote.fit_resample(X_train_scaled, y_train)
+
+            # 6. Treinar Modelo
+            model = get_model(algorithm, params)
+            model.fit(X_train_scaled, y_train)
+
+            # 7. Avaliar
+            y_pred = model.predict(X_test_scaled)
+            y_proba = model.predict_proba(X_test_scaled)[:, 1]
+            auc = roc_auc_score(y_test, y_proba)
+            report = classification_report(y_test, y_pred, output_dict=True)
+            report_df = pd.DataFrame(report).transpose()
+            
+            # Extrai métricas específicas para classe 1 (Cancelamento)
+            (
+                precision,
+                recall,
+                f1_score,
+                _,
+            ) = precision_recall_fscore_support(y_test, y_pred, average="binary")
+
+
+            end_time = time.time()
+            training_time = end_time - start_time
+
+            # --- Exibição dos Resultados ---
+            st.header(f"Resultados para: {algorithm}")
+            
+            # Métricas Chave
+            st.subheader("Visão Geral das Métricas (Classe 1: 'Cancelou')")
+            col1, col2, col3, col4 = st.columns(4)
+            col1.metric("AUC (Area Under Curve)", f"{auc:.3f}")
+            col2.metric("F1-Score", f"{f1_score:.3f}")
+            col3.metric("Precisão (Precision)", f"{precision:.3f}")
+            col4.metric("Recall (Sensibilidade)", f"{recall:.3f}")
+
+            st.markdown(f"**Tempo de Treinamento e Avaliação:** {training_time:.2f} segundos")
+
+            # Gráficos
+            st.subheader("Visualização das Métricas")
+            fig_roc = plot_roc_curve(y_test, y_proba, auc)
+            fig_cm = plot_confusion_matrix(y_test, y_pred)
+            
+            col_graph1, col_graph2 = st.columns(2)
+            with col_graph1:
+                st.plotly_chart(fig_roc, use_container_width=True)
+            with col_graph2:
+                st.plotly_chart(fig_cm, use_container_width=True)
+
+            st.subheader("Relatório de Classificação Detalhado")
+            st.dataframe(report_df.style.format("{:.3f}"))
+
+            # --- Interpretação Gerencial Automática ---
+            st.header("💡 Interpretação Gerencial e Recomendações")
+            
+            st.subheader(f"Análise Gerencial do Modelo: {algorithm}")
+            
             if algorithm == "Regressão Logística":
-                model, training_time = dashboard.train_logistic_regression(
-                    C=C_lr, penalty=penalty, solver=solver
-                )
-                model_name = f"RL_C={C_lr}"
-                
+                st.markdown("""
+                    **O que é?** Um modelo estatístico que calcula a *probabilidade* de cancelamento. É o modelo mais fácil de interpretar.
+                    **Ponto Forte (Interpretabilidade):** Podemos ver exatamente quais fatores (como `lead_time` ou `deposit_type`) mais aumentam ou diminuem as chances de cancelamento.
+                    **Ponto Fraco:** Pode não capturar relações complexas entre as variáveis.
+                """)
             elif algorithm == "KNN":
-                model, training_time = dashboard.train_knn(
-                    n_neighbors=n_neighbors, metric=metric, weights=weights
-                )
-                model_name = f"KNN_k={n_neighbors}_{metric}"
+                st.markdown("""
+                    **O que é?** Um modelo que classifica uma nova reserva com base nas reservas mais *parecidas* (vizinhas) que já temos no histórico.
+                    **Ponto Forte (Intuitivo):** Fácil de entender. "Diga-me quem são seus vizinhos e eu direi quem você é". Bom para capturar padrões locais.
+                    **Ponto Fraco (Performance):** Lento para prever em datasets muito grandes e muito sensível ao escalonamento dos dados e a features irrelevantes.
+                """)
+            elif algorithm == "SVM":
+                st.markdown("""
+                    **O que é?** Um modelo que tenta encontrar a *melhor fronteira* ou "linha" que separa os cancelamentos dos não-cancelamentos, maximizando a distância entre os dois grupos.
+                    **Ponto Forte (Poder Preditivo):** Especialmente com o kernel 'RBF', pode encontrar relações não-lineares complexas que outros modelos não veem. Geralmente tem alta acurácia.
+                    **Ponto Fraco (Caixa Preta):** É muito difícil de explicar *por que* o modelo tomou uma decisão específica.
+                """)
+
+            st.subheader("Tradução das Métricas para o Negócio Hoteleiro")
+            st.markdown(f"""
+                * **Precisão (Precision) = {precision:.2f}:** Das reservas que o modelo *disse* que iriam cancelar, **{precision*100:.1f}%** realmente cancelariam. 
+                    * *Impacto:* Uma Precisão alta evita que a equipe de retenção perca tempo com clientes que não iriam cancelar.
                 
-            else:  # SVM
-                model, training_time = dashboard.train_svm(
-                    C=C_svm, kernel=kernel, gamma=gamma
-                )
-                model_name = f"SVM_{kernel}_C={C_svm}"
-            
-            # Avaliar
-            metrics, roc_data, cm = dashboard.evaluate_model(model, model_name, training_time)
-            
-            # Salvar modelo
-            dashboard.models[model_name] = model
-            dashboard.results[model_name] = metrics
-            
-        # Resultados
-        st.success(f"✅ Modelo {algorithm} treinado com sucesso em {training_time:.2f} segundos!")
-        
-        # Métricas
-        st.subheader("📊 Métricas de Desempenho")
-        col1, col2, col3, col4, col5 = st.columns(5)
-        with col1: st.metric("Acurácia", f"{metrics['Acurácia']:.4f}")
-        with col2: st.metric("Precisão", f"{metrics['Precisão']:.4f}")
-        with col3: st.metric("Recall", f"{metrics['Recall']:.4f}")
-        with col4: st.metric("F1-Score", f"{metrics['F1-Score']:.4f}")
-        with col5: st.metric("AUC-ROC", f"{metrics['AUC-ROC']:.4f}")
-        
-        # Visualizações
-        st.subheader("📈 Visualizações")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            # Curva ROC
-            roc_fig = dashboard.plot_roc_comparison(roc_data, model_name)
-            st.plotly_chart(roc_fig, use_container_width=True)
-        
-        with col2:
-            # Matriz de confusão
-            fig_cm, ax = plt.subplots(figsize=(6, 4))
-            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax)
-            ax.set_xlabel('Predito')
-            ax.set_ylabel('Verdadeiro')
-            ax.set_title('Matriz de Confusão')
-            st.pyplot(fig_cm)
-        
-        # Análise
-        st.subheader("🔍 Análise e Interpretação")
-        col1, col2 = st.columns(2)
-        
-        with col1:
-            st.markdown("### 📋 Avaliação do Desempenho")
-            if metrics['F1-Score'] >= 0.7:
-                st.success("**🎯 Excelente desempenho!** Modelo bem balanceado entre precisão e recall.")
-            elif metrics['F1-Score'] >= 0.5:
-                st.info("**👍 Bom desempenho!** Resultados satisfatórios para aplicação prática.")
-            else:
-                st.warning("**⚠️ Desempenho moderado.** Considere ajustar parâmetros ou features.")
-            
-            if metrics['AUC-ROC'] >= 0.8:
-                st.success("**🔝 Ótima discriminação!** O modelo separa muito bem as classes.")
-            elif metrics['AUC-ROC'] >= 0.7:
-                st.info("**📈 Boa discriminação!** Separação adequada entre cancelamentos e não-cancelamentos.")
-            else:
-                st.warning("**📉 Discriminação moderada.** Há espaço para melhorias na separação das classes.")
-        
-        with col2:
-            st.markdown("### 💡 Recomendações Práticas")
-            recommendations = []
-            
-            if metrics['Precisão'] < 0.6:
-                recommendations.append("**Aumente o threshold** para reduzir falsos positivos")
-            if metrics['Recall'] < 0.6:
-                recommendations.append("**Diminua o threshold** para capturar mais cancelamentos reais")
-            if algorithm == "KNN" and n_neighbors < 5:
-                recommendations.append("**Aumente o valor de k** para reduzir overfitting")
-            if algorithm == "SVM" and training_time > 5:
-                recommendations.append("**Use kernel linear** para datasets grandes")
-            if metrics['AUC-ROC'] < 0.7:
-                recommendations.append("**Experimente diferentes algoritmos** ou faça feature engineering")
-            
-            for rec in recommendations:
-                st.write(f"• {rec}")
-            
-            if not recommendations:
-                st.success("**✅ Parâmetros bem ajustados!** Continue monitorando o desempenho.")
-        
-        # Ranking
-        st.subheader("🏆 Ranking dos Modelos")
-        if dashboard.results:
-            results_df = pd.DataFrame(dashboard.results).T
-            results_df = results_df.sort_values('F1-Score', ascending=False)
-            
-            # Mostrar tabela
-            st.dataframe(results_df.style.format("{:.4f}").background_gradient(cmap='Blues'), 
-                        use_container_width=True)
-            
-            # Melhor modelo
-            best_model = results_df.index[0]
-            best_f1 = results_df.loc[best_model, 'F1-Score']
-            best_auc = results_df.loc[best_model, 'AUC-ROC']
+                * **Recall (Sensibilidade) = {recall:.2f}:** Das reservas que *realmente* foram canceladas, o modelo conseguiu identificar **{recall*100:.1f}%** delas.
+                    * *Impacto:* Este é o custo de "deixar passar". Um Recall baixo significa que muitos cancelamentos estão ocorrendo sem aviso prévio.
+                
+                * **AUC = {auc:.2f}:** Mede a capacidade *geral* do modelo de distinguir entre um cancelamento e uma não-cancelamento. Um valor de 0.5 é um chute; 1.0 é a perfeição. **{auc*100:.1f}%** é um indicador de quão robusto é o modelo.
+            """)
             
-            st.markdown(f'''
-            <div class="best-model">
-                <h3>🎉 Melhor Modelo: {best_model}</h3>
-                <p><strong>F1-Score:</strong> {best_f1:.4f} | <strong>AUC-ROC:</strong> {best_auc:.4f}</p>
-                <p>Este modelo apresenta o melhor balanceamento entre precisão e recall.</p>
-            </div>
-            ''', unsafe_allow_html=True)
-    
-    else:
-        # Estado: dados carregados mas nenhum modelo treinado
-        st.info("""
-        **📊 Dataset carregado com sucesso!** 
-        
-        Configure o algoritmo e os parâmetros na barra lateral e clique em **'Treinar Modelo'** 
-        para iniciar a análise preditiva de cancelamentos.
-        """)
-
-if __name__ == "__main__":
-    main()
+            st.subheader("Ranking e Recomendações (Visão Geral)")
+            st.markdown("""
+                A "melhor" escolha depende da estratégia da rede hoteleira:
+
+                1.  **Para Interpretabilidade (Entender o *Porquê*):**
+                    * **Vencedor:** **Regressão Logística**.
+                    * **Ação:** Use este modelo para entender os *drivers* do cancelamento. Se `lead_time` alto é um fator de risco, a equipe de marketing pode criar ações de engajamento para reservas feitas com muita antecedência.
+                
+                2.  **Para Ação Preventiva (Maximizar o *Recall*):**
+                    * **Vencedor:** Geralmente **SVM** ou **KNN** (com SMOTE) podem ser ajustados para um Recall mais alto.
+                    * **Ação:** Se a estratégia é "não deixar nenhum cancelamento passar despercebido" (mesmo que isso gere alguns falsos positivos), priorizamos o **Recall**. Podemos enviar um e-mail de confirmação ou uma pequena oferta para *todas* as reservas de alto risco sinalizadas pelo modelo.
+
+                3.  **Para Eficiência Operacional (Maximizar a *Precisão*):**
+                    * **Vencedor:** Geralmente **Regressão Logística** ou **SVM (linear)**.
+                    * **Ação:** Se temos uma equipe de retenção pequena e cara (ex: ligações telefônicas), queremos ter certeza de que cada reserva sinalizada é *realmente* de alto risco. Priorizamos a **Precisão**.
+
+                **Recomendação Prática (Exemplo):**
+                "O modelo de Regressão Logística (AUC de ~0.85) mostrou que reservas do tipo 'Transient' (não-grupo) com `deposit_type` = 'Non Refund' e `lead_time` > 120 dias têm 70% mais chance de cancelar. Recomenda-se uma política de overbooking de 3% para esse segmento específico ou um contato proativo 60 dias antes do check-in."
+            """)
+
+else:
+    st.warning("O arquivo 'hotel_bookings.csv' não foi carregado. O dashboard não pode continuar.")