Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - Dashboard Interativo com Dataset do Hugging Face
+# app.py - Dashboard Interativo de Cancelamento de Reservas
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -26,14 +26,6 @@ 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="Dashboard - Cancelamento de Reservas",
@@ -101,28 +93,6 @@ class HotelBookingDashboard:
         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:
@@ -373,91 +343,104 @@ def main():
     if not dashboard.is_data_loaded:
         st.markdown("""
         <div class="data-source-section">
-            <h2>📊 Escolha a Fonte dos Dados</h2>
+            <h2>📊 Upload do Dataset</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>
+                <strong>Faça upload do dataset de reservas de hotel para começar a análise</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")
-        
+        # Upload centralizado
+        col1, col2, col3 = st.columns([1, 2, 1])
         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",
+                "**Selecione o arquivo CSV do dataset**",
                 type=['csv'],
-                help="Faça upload do dataset de reservas de hotel"
+                help="Faça upload do dataset de reservas de hotel (ex: hotel_bookings.csv)",
+                key="main_uploader"
             )
+        
+        # Instruções
+        with st.expander("📋 Instruções de Uso", expanded=True):
+            st.markdown("""
+            **Como usar este dashboard:**
             
-            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):
+            1. **📁 Faça upload** do dataset de reservas de hotel (formato CSV)
+            2. **🔄 Aguarde o processamento** automático dos dados
+            3. **⚙️ Configure** o algoritmo e parâmetros desejados
+            4. **🚀 Treine o modelo** e analise os resultados
+            5. **📊 Compare** o desempenho entre diferentes modelos
+            
+            **Requisitos do dataset:**
+            - Formato CSV
+            - Deve conter uma coluna target (cancelamento)
+            - Colunas típicas: `lead_time`, `adr`, `adults`, `is_canceled`, etc.
+            - Suporta o dataset "Hotel Booking Demand" do Kaggle
+            """)
+        
+        # Processar o arquivo assim que for carregado
+        if uploaded_file is not None:
+            try:
+                with st.spinner("📊 Carregando e analisando o dataset..."):
+                    # Ler o arquivo
+                    df = pd.read_csv(uploaded_file)
+                    
+                    # Mostrar informações básicas
+                    st.success(f"✅ Dataset carregado: {df.shape[0]} linhas × {df.shape[1]} colunas")
+                    
+                    # Preview do dataset
+                    with st.expander("👀 Visualização do Dataset (primeiras 10 linhas)"):
+                        st.dataframe(df.head(10), use_container_width=True)
+                    
+                    # Informações das colunas
+                    with st.expander("📋 Informações das Colunas"):
+                        col1, col2 = st.columns(2)
+                        with col1:
+                            st.write("**Colunas Numéricas:**")
+                            numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+                            for col in numeric_cols[:10]:  # Mostrar apenas as primeiras 10
+                                st.write(f"- {col}")
+                            if len(numeric_cols) > 10:
+                                st.write(f"- ... e mais {len(numeric_cols) - 10} colunas")
+                        with col2:
+                            st.write("**Colunas Categóricas:**")
+                            categorical_cols = df.select_dtypes(include=['object']).columns.tolist()
+                            for col in categorical_cols[:10]:  # Mostrar apenas as primeiras 10
+                                st.write(f"- {col}")
+                            if len(categorical_cols) > 10:
+                                st.write(f"- ... e mais {len(categorical_cols) - 10} colunas")
+                    
+                    # Processar automaticamente
+                    if st.button("🔄 Processar Dataset e Continuar", type="primary", use_container_width=True):
+                        with st.spinner("Processando dataset... Isso pode levar alguns segundos"):
                             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)}")
+                            else:
+                                st.error("Falha no processamento do dataset. Verifique os dados e tente novamente.")
+            
+            except Exception as e:
+                st.error(f"❌ Erro ao carregar arquivo: {str(e)}")
+                st.info("💡 **Dica:** Verifique se o arquivo é um CSV válido e tente novamente.")
         
-        # Informações sobre o dataset
-        with st.expander("📋 Sobre o Dataset", expanded=True):
+        # Exemplo de estrutura esperada
+        with st.expander("🎯 Exemplo de Dataset Compatível"):
             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.
+            **Estrutura típica do dataset Hotel Booking Demand:**
+            ```csv
+            hotel,lead_time,arrival_date_year,arrival_date_month,arrival_date_week_number,
+            arrival_date_day_of_month,stays_in_weekend_nights,stays_in_week_nights,adults,
+            children,babies,meal,country,market_segment,distribution_channel,
+            is_repeated_guest,previous_cancellations,previous_bookings_not_canceled,
+            reserved_room_type,assigned_room_type,booking_changes,deposit_type,agent,
+            company,days_in_waiting_list,customer_type,adr,required_car_parking_spaces,
+            total_of_special_requests,reservation_status,is_canceled
+            ```
+            
+            **Coluna target:** `is_canceled` (1 = cancelado, 0 = não cancelado)
             """)
         
         return
@@ -479,7 +462,7 @@ def main():
     )
     
     # Parâmetros específicos
-    st.sidebar.subheader("📊 Parâmetros do Modelo")
+    st.sidebar.subheader("📊 Parámetros do Modelo")
     
     if algorithm == "Regressão Logística":
         st.sidebar.markdown('<div class="parameter-section">', unsafe_allow_html=True)
@@ -544,19 +527,23 @@ def main():
             # 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')
+            labels = ['Não Cancelado', 'Cancelado'] if len(balance) == 2 else [f'Classe {i}' for i in balance.index]
+            ax.pie(balance.values, labels=labels, autopct='%1.1f%%', startangle=90)
+            ax.set_title('Distribuição do Target')
             st.pyplot(fig)
         
         with col2:
             # Estatísticas básicas
             st.write("**Estatísticas do Dataset:**")
+            total_samples = dashboard.X_train.shape[0] + dashboard.X_test.shape[0]
+            cancel_rate = (dashboard.y_train.sum() + dashboard.y_test.sum()) / total_samples * 100
+            
             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"{total_samples:,}",
                     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"{cancel_rate:.1f}%",
                     f"{balance[0]}:{balance[1]}" if len(balance) == 2 else "Múltiplas classes"
                 ]
             })