Update app.py

app.py

@@ -1,357 +1,698 @@
+# 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
-from sklearn.model_selection import train_test_split, cross_val_score
-from sklearn.preprocessing import StandardScaler
+import joblib
+from sklearn.metrics import (accuracy_score, precision_score, recall_score, f1_score,
+                           roc_auc_score, roc_curve, confusion_matrix)
 from sklearn.linear_model import LogisticRegression
 from sklearn.neighbors import KNeighborsClassifier
 from sklearn.svm import SVC
-from sklearn.metrics import roc_curve, auc, classification_report, confusion_matrix, precision_recall_curve
-import os
+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
+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
 st.set_page_config(
-    page_title="Previsão de Cancelamentos Hoteleiros",
+    page_title="Dashboard - Cancelamento de Reservas",
     page_icon="🏨",
-    layout="wide"
+    layout="wide",
+    initial_sidebar_state="expanded"
 )
 
-# Título principal
-st.title("🏨 Dashboard de Previsão de Cancelamentos em Reservas Hoteleiras")
+# CSS customizado
 st.markdown("""
-**Objetivo**: Desenvolver e comparar modelos preditivos para identificar reservas com maior probabilidade de cancelamento,
-permitindo ações preventivas como overbooking controlado e ofertas promocionais direcionadas.
-""")
-
-# Carregar dados
-@st.cache_data
-def load_data():
-    """
-    Carrega dados sintéticos (evita problemas de compatibilidade)
-    """
-    np.random.seed(42)
-    n_samples = 4000
-    
-    # Criar dados mais realistas baseados no dataset real
-    data = {
-        'hotel': np.random.choice(['Resort Hotel', 'City Hotel'], n_samples, p=[0.6, 0.4]),
-        'is_canceled': np.random.choice([0, 1], n_samples, p=[0.65, 0.35]),
-        'lead_time': np.random.gamma(2, 50, n_samples).astype(int),
-        'arrival_date_year': np.random.choice([2015, 2016, 2017], n_samples, p=[0.3, 0.4, 0.3]),
-        'arrival_date_month': np.random.choice([
-            'January', 'February', 'March', 'April', 'May', 'June', 
-            'July', 'August', 'September', 'October', 'November', 'December'
-        ], n_samples),
-        'stays_in_weekend_nights': np.random.poisson(1, n_samples),
-        'stays_in_week_nights': np.random.poisson(3, n_samples),
-        'adults': np.random.choice([1, 2, 3, 4], n_samples, p=[0.1, 0.7, 0.15, 0.05]),
-        'children': np.random.choice([0, 1, 2], n_samples, p=[0.8, 0.15, 0.05]),
-        'babies': np.random.choice([0, 1], n_samples, p=[0.95, 0.05]),
-        'meal': np.random.choice(['BB', 'HB', 'FB', 'SC'], n_samples, p=[0.7, 0.2, 0.05, 0.05]),
-        'country': np.random.choice(['PRT', 'GBR', 'FRA', 'ESP', 'DEU', 'ITA', 'IRL', 'BEL'], n_samples),
-        'market_segment': np.random.choice([
-            'Direct', 'Corporate', 'Online TA', 'Offline TA/TO', 'Complementary', 'Groups'
-        ], n_samples, p=[0.2, 0.1, 0.5, 0.15, 0.02, 0.03]),
-        'distribution_channel': np.random.choice(['Direct', 'Corporate', 'TA/TO'], n_samples, p=[0.2, 0.1, 0.7]),
-        'is_repeated_guest': np.random.choice([0, 1], n_samples, p=[0.95, 0.05]),
-        'previous_cancellations': np.random.poisson(0.1, n_samples),
-        'previous_bookings_not_canceled': np.random.poisson(0.5, n_samples),
-        'reserved_room_type': np.random.choice(['A', 'B', 'C', 'D', 'E', 'F', 'G'], n_samples, p=[0.4, 0.2, 0.15, 0.1, 0.08, 0.05, 0.02]),
-        'assigned_room_type': np.random.choice(['A', 'B', 'C', 'D', 'E', 'F', 'G'], n_samples, p=[0.4, 0.2, 0.15, 0.1, 0.08, 0.05, 0.02]),
-        'booking_changes': np.random.poisson(0.3, n_samples),
-        'deposit_type': np.random.choice(['No Deposit', 'Non Refund', 'Refundable'], n_samples, p=[0.85, 0.1, 0.05]),
-        'customer_type': np.random.choice(['Transient', 'Contract', 'Transient-Party', 'Group'], n_samples, p=[0.7, 0.1, 0.15, 0.05]),
-        'adr': np.random.gamma(5, 20, n_samples) + 50,  # ADR entre 50-250
-        'required_car_parking_spaces': np.random.choice([0, 1], n_samples, p=[0.9, 0.1]),
-        'total_of_special_requests': np.random.poisson(0.5, n_samples),
+<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
     
-    df = pd.DataFrame(data)
+    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
     
-    # Ajustar lead_time para ser mais realista
-    df['lead_time'] = np.clip(df['lead_time'], 0, 400)
+    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
     
-    # Ajustar ADR para ter valores mais realistas
-    df['adr'] = np.clip(df['adr'], 50, 300)
+    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]
+        
+        return None
     
-    return df
-
-df = load_data()
-
-# Sidebar para configurações
-st.sidebar.header("⚙️ Configurações do Modelo")
-
-# Seleção do algoritmo
-algorithm = st.sidebar.selectbox(
-    "Selecione o algoritmo:",
-    ["Regressão Logística", "K-Nearest Neighbors", "Support Vector Machine"]
-)
-
-# Parâmetros específicos por algoritmo
-if algorithm == "Regressão Logística":
-    st.sidebar.subheader("Parâmetros da Regressão Logística")
-    penalty = st.sidebar.selectbox("Penalidade", ["l1", "l2", "none"])
-    C = st.sidebar.slider("Parâmetro C (Regularização)", 0.01, 10.0, 1.0, 0.1)
-    solver = st.sidebar.selectbox("Solver", ["liblinear", "lbfgs"])
+    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
     
-elif algorithm == "K-Nearest Neighbors":
-    st.sidebar.subheader("Parâmetros do KNN")
-    k = st.sidebar.slider("Número de vizinhos (k)", 1, 15, 5)
-    metric = st.sidebar.selectbox("Métrica de distância", ["euclidean", "manhattan"])
-    weights = st.sidebar.selectbox("Pesos", ["uniform", "distance"])
+    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
     
-elif algorithm == "Support Vector Machine":
-    st.sidebar.subheader("Parâmetros do SVM")
-    kernel = st.sidebar.selectbox("Kernel", ["linear", "rbf", "poly"])
-    C_svm = st.sidebar.slider("Parâmetro C (SVM)", 0.01, 10.0, 1.0, 0.1)
-    gamma = st.sidebar.selectbox("Gamma", ["scale", "auto"])
-
-# Configurações gerais
-st.sidebar.subheader("Configurações Gerais")
-test_size = st.sidebar.slider("Tamanho do conjunto de teste", 0.1, 0.5, 0.2, 0.05)
-cross_validation = st.sidebar.slider("Número de folds para validação cruzada", 2, 5, 3)
-
-# Análise exploratória
-st.header("📊 Análise Exploratória dos Dados")
-
-col1, col2 = st.columns(2)
-
-with col1:
-    st.subheader("Distribuição de Cancelamentos")
-    fig, ax = plt.subplots(figsize=(6, 4))
-    df['is_canceled'].value_counts().plot(kind='bar', ax=ax, color=['skyblue', 'salmon'])
-    ax.set_title('Distribuição de Cancelamentos')
-    ax.set_xlabel('Cancelado')
-    ax.set_ylabel('Contagem')
-    st.pyplot(fig)
-
-with col2:
-    st.subheader("Lead Time vs Cancelamentos")
-    fig, ax = plt.subplots(figsize=(6, 4))
-    sns.boxplot(data=df, x='is_canceled', y='lead_time', ax=ax)
-    ax.set_title('Lead Time por Status de Cancelamento')
-    ax.set_xlabel('Cancelado')
-    ax.set_ylabel('Lead Time (dias)')
-    st.pyplot(fig)
-
-# Informações do dataset
-st.sidebar.header("📊 Informações do Dataset")
-st.sidebar.write(f"**Registros**: {len(df):,}")
-st.sidebar.write(f"**Cancelamentos**: {df['is_canceled'].sum():,} ({df['is_canceled'].mean():.1%})")
-st.sidebar.write(f"**Variáveis**: {len(df.columns)}")
-
-# Pré-processamento dos dados
-st.header("🔧 Pré-processamento dos Dados")
-
-# Preparar dados para modelagem
-X = df.drop('is_canceled', axis=1)
-y = df['is_canceled']
-
-# Codificar variáveis categóricas
-X_encoded = pd.get_dummies(X, drop_first=True)
-
-# Dividir dados
-X_train, X_test, y_train, y_test = train_test_split(
-    X_encoded, y, test_size=test_size, random_state=42, stratify=y
-)
-
-# Normalizar dados
-scaler = StandardScaler()
-X_train_scaled = scaler.fit_transform(X_train)
-X_test_scaled = scaler.transform(X_test)
-
-st.success(f"✅ Dados pré-processados: {X_train.shape[0]} amostras de treino, {X_test.shape[0]} amostras de teste")
-
-# Treinamento do modelo
-st.header("🤖 Treinamento do Modelo")
-
-def train_and_evaluate_model(algorithm, X_train, X_test, y_train, y_test, params):
-    if algorithm == "Regressão Logística":
-        model = LogisticRegression(
-            penalty=params.get('penalty', 'l2'),
-            C=params.get('C', 1.0),
-            solver=params.get('solver', 'liblinear'),
-            random_state=42,
-            max_iter=1000
-        )
-    elif algorithm == "K-Nearest Neighbors":
-        model = KNeighborsClassifier(
-            n_neighbors=params.get('k', 5),
-            metric=params.get('metric', 'euclidean'),
-            weights=params.get('weights', 'uniform')
-        )
-    elif algorithm == "Support Vector Machine":
-        model = SVC(
-            kernel=params.get('kernel', 'rbf'),
-            C=params.get('C_svm', 1.0),
-            gamma=params.get('gamma', 'scale'),
-            probability=True,
-            random_state=42
-        )
+    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
     
-    # Treinar modelo
-    model.fit(X_train, y_train)
+    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
     
-    # Previsões
-    y_pred = model.predict(X_test)
-    y_pred_proba = model.predict_proba(X_test)[:, 1]
+    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
     
-    return model, y_pred, y_pred_proba
-
-# Coletar parâmetros
-params = {}
-if algorithm == "Regressão Logística":
-    params = {'penalty': penalty, 'C': C, 'solver': solver}
-elif algorithm == "K-Nearest Neighbors":
-    params = {'k': k, 'metric': metric, 'weights': weights}
-elif algorithm == "Support Vector Machine":
-    params = {'kernel': kernel, 'C_svm': C_svm, 'gamma': gamma}
-
-# Treinar modelo
-with st.spinner(f"Treinando modelo {algorithm}..."):
-    try:
-        model, y_pred, y_pred_proba = train_and_evaluate_model(
-            algorithm, X_train_scaled, X_test_scaled, y_train, y_test, params
+    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
         )
         
-        # Validação cruzada
-        cv_scores = cross_val_score(model, X_train_scaled, y_train, cv=cross_validation, scoring='accuracy')
-        st.info(f"📊 Acurácia média na validação cruzada ({cross_validation} folds): {cv_scores.mean():.3f} (± {cv_scores.std():.3f})")
-
-        # Métricas de avaliação
-        st.header("📈 Avaliação do Modelo")
+        return fig
 
+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:
-            # Matriz de confusão
-            st.subheader("Matriz de Confusão")
-            cm = confusion_matrix(y_test, y_pred)
-            fig, ax = plt.subplots(figsize=(5, 4))
-            sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=ax)
-            ax.set_xlabel('Predito')
-            ax.set_ylabel('Real')
-            ax.set_title('Matriz de Confusão')
+            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
+    
+    # Sidebar - Configurações do Modelo
+    st.sidebar.header("⚙️ Configurações do Modelo")
+    
+    # Seleção do algoritmo
+    algorithm = st.sidebar.selectbox(
+        "Escolha o algoritmo:",
+        ["Regressão Logística", "KNN", "SVM"],
+        index=0
+    )
+    
+    # Parâmetros específicos
+    st.sidebar.subheader("📊 Parâmetros do Modelo")
+    
+    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)
+        
+    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]}")
+        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:
-            # Relatório de classificação
-            st.subheader("Métricas Principais")
-            report = classification_report(y_test, y_pred, output_dict=True)
-            metrics_df = pd.DataFrame({
-                'Métrica': ['Acurácia', 'Precisão', 'Recall', 'F1-Score'],
+            # 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': [
-                    report['accuracy'],
-                    report['1']['precision'],
-                    report['1']['recall'],
-                    report['1']['f1-score']
+                    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(metrics_df.style.format({"Valor": "{:.3f}"}))
-
-        # Curva ROC
-        st.subheader("Curva ROC")
-        fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)
-        roc_auc = auc(fpr, tpr)
-
-        fig, ax = plt.subplots(figsize=(8, 6))
-        ax.plot(fpr, tpr, color='darkorange', lw=2, label=f'Curva ROC (AUC = {roc_auc:.3f})')
-        ax.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--', label='Aleatório')
-        ax.set_xlim([0.0, 1.0])
-        ax.set_ylim([0.0, 1.05])
-        ax.set_xlabel('Taxa de Falsos Positivos')
-        ax.set_ylabel('Taxa de Verdadeiros Positivos')
-        ax.set_title('Curva ROC')
-        ax.legend(loc="lower right")
-        st.pyplot(fig)
-
-        # Comparação de modelos
-        st.header("🏆 Comparação de Modelos")
-
-        # Simular resultados para comparação
-        models_comparison = {
-            'Modelo': [algorithm, 'K-Nearest Neighbors', 'Support Vector Machine'],
-            'AUC': [roc_auc, 0.78, 0.82],
-            'Acurácia': [cv_scores.mean(), 0.75, 0.80],
-            'Precisão': [report['1']['precision'], 0.72, 0.78],
-            'Recall': [report['1']['recall'], 0.68, 0.75],
-            'F1-Score': [report['1']['f1-score'], 0.70, 0.76]
-        }
-
-        comparison_df = pd.DataFrame(models_comparison)
-        st.dataframe(comparison_df.style.format("{:.3f}").highlight_max(axis=0))
-
-        # Ranking do melhor modelo
-        best_model_idx = comparison_df['AUC'].idxmax()
-        best_model = comparison_df.loc[best_model_idx, 'Modelo']
-        best_auc = comparison_df.loc[best_model_idx, 'AUC']
-
-        st.success(f"🎯 **Melhor modelo**: {best_model} (AUC: {best_auc:.3f})")
-
-        # Recomendações práticas
-        st.header("💡 Recomendações Práticas")
-
-        st.markdown("""
-        **Com base na análise realizada, recomenda-se:**
-
-        1. **Segmentação de Clientes**: Focar em reservas com lead time > 100 dias
-        2. **Política de Overbooking**: Aplicar overbooking de 3-5% para reservas de alto risco
-        3. **Ações Preventivas**: Oferecer upgrades para reservas identificadas como risco médio-alto
-        4. **Comunicação Proativa**: Contato com clientes de alto risco 48h antes do check-in
-
-        **Fatores de risco identificados:**
-        - Lead time elevado (> 100 dias)
-        - Histórico de cancelamentos anteriores
-        - Tipo de depósito não reembolsável
-        - Canal de distribuição Online TA
-        """)
-
-        # Seção de previsão individual
-        st.header("🎯 Previsão Individual")
-
+            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
+            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}"
+                
+            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}"
+                
+            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:
-            lead_time = st.slider("Lead Time (dias)", 0, 400, 30, key="lead_time")
-            adults = st.slider("Número de Adultos", 1, 4, 2, key="adults")
-            previous_cancellations = st.slider("Cancelamentos Anteriores", 0, 5, 0, key="prev_cancels")
-
+            # Curva ROC
+            roc_fig = dashboard.plot_roc_comparison(roc_data, model_name)
+            st.plotly_chart(roc_fig, use_container_width=True)
+        
         with col2:
-            deposit_type = st.selectbox("Tipo de Depósito", ["No Deposit", "Non Refund", "Refundable"], key="deposit")
-            market_segment = st.selectbox("Segmento de Mercado", ["Direct", "Corporate", "Online TA", "Offline TA/TO"], key="market")
-            customer_type = st.selectbox("Tipo de Cliente", ["Transient", "Contract", "Transient-Party", "Group"], key="customer")
-
-        if st.button("Prever Probabilidade de Cancelamento"):
-            # Simular predição baseada nas entradas
-            risk_factors = 0
-            if lead_time > 100:
-                risk_factors += 1
-            if previous_cancellations > 0:
-                risk_factors += 1
-            if deposit_type == "No Deposit":
-                risk_factors += 1
-            if market_segment == "Online TA":
-                risk_factors += 1
-            
-            probability = min(0.95, 0.2 + (risk_factors * 0.2))
-            
-            st.info(f"📊 Probabilidade estimada de cancelamento: {probability:.2f}")
-            
-            if probability > 0.6:
-                st.warning("⚠️ Reserva de ALTO RISCO - Recomenda-se ação preventiva imediata")
-            elif probability > 0.4:
-                st.warning("⚠️ Reserva de risco MODERADO - Monitorar e contatar proativamente")
+            # 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.success("✅ Reserva de BAIXO RISCO - Manter acompanhamento padrão")
-
-    except Exception as e:
-        st.error(f"❌ Erro no treinamento do modelo: {str(e)}")
-        st.info("💡 Tente ajustar os parâmetros do modelo ou reduzir a complexidade")
+                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']
+            
+            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.
+        """)
 
-# Rodapé
-st.markdown("---")
-st.markdown("**Dashboard desenvolvido para análise preditiva de cancelamentos hoteleiros | Hugging Face Spaces**")
+if __name__ == "__main__":
+    main()