Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py - Dashboard Interativo de Cancelamento de Reservas
+# app.py - Dashboard Interativo com Dataset do Hugging Face
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -26,6 +26,14 @@ 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",
@@ -93,6 +101,28 @@ 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:
@@ -343,104 +373,91 @@ def main():
     if not dashboard.is_data_loaded:
         st.markdown("""
         <div class="data-source-section">
-            <h2>📊 Upload do Dataset</h2>
+            <h2>📊 Escolha a Fonte dos Dados</h2>
             <p style="font-size: 1.2rem; margin-bottom: 1.5rem;">
-                <strong>Faça upload do dataset de reservas de hotel para começar a análise</strong>
+                <strong>Carregue os dados do Hugging Face ou faça upload do seu próprio dataset</strong>
             </p>
         </div>
         """, unsafe_allow_html=True)
         
-        # Upload centralizado
-        col1, col2, col3 = st.columns([1, 2, 1])
-        with col2:
-            uploaded_file = st.file_uploader(
-                "**Selecione o arquivo CSV do dataset**",
-                type=['csv'],
-                help="Faça upload do dataset de reservas de hotel (ex: hotel_bookings.csv)",
-                key="main_uploader"
-            )
+        # Opções de carregamento
+        col1, col2 = st.columns(2)
         
-        # Instruções
-        with st.expander("📋 Instruções de Uso", expanded=True):
+        with col1:
+            st.markdown("### 🌐 Dataset do Hugging Face")
             st.markdown("""
-            **Como usar este dashboard:**
-            
-            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
+            **Vantagens:**
+            - Dataset pré-processado
+            - Estrutura consistente
+            - Sem necessidade de upload
+            """)
             
-            **Requisitos do dataset:**
+            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
-            - Deve conter uma coluna target (cancelamento)
-            - Colunas típicas: `lead_time`, `adr`, `adults`, `is_canceled`, etc.
-            - Suporta o dataset "Hotel Booking Demand" do Kaggle
+            - Coluna target: 'is_canceled'
+            - Estrutura personalizada
             """)
-        
-        # 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"):
+            
+            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()
-                            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.")
+                            
+                except Exception as e:
+                    st.error(f"❌ Erro ao carregar arquivo: {str(e)}")
         
-        # Exemplo de estrutura esperada
-        with st.expander("🎯 Exemplo de Dataset Compatível"):
+        # Informações sobre o dataset
+        with st.expander("📋 Sobre o Dataset", expanded=True):
             st.markdown("""
-            **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)
+            **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
@@ -462,7 +479,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)
@@ -527,23 +544,19 @@ def main():
             # Distribuição do target
             fig, ax = plt.subplots(figsize=(8, 6))
             balance = pd.Series(dashboard.y_train).value_counts()
-            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')
+            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:**")
-            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"{total_samples:,}",
+                    f"{dashboard.X_train.shape[0] + dashboard.X_test.shape[0]:,}",
                     f"{dashboard.X_train.shape[1]}",
-                    f"{cancel_rate:.1f}%",
+                    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"
                 ]
             })