update

main.py

@@ -0,0 +1,396 @@
+import streamlit as st
+import pandas as pd
+import numpy as np
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from prophet import Prophet
+from prophet.plot import plot_plotly, plot_components_plotly
+from datetime import datetime
+import statsmodels.api as sm
+from datetime import datetime
+import io
+# Configuración de la página
+st.set_page_config(page_title="Analytics Dashboard", layout="wide", page_icon="📈")
+
+
+if 'df' not in st.session_state:
+    st.session_state.df = pd.DataFrame()
+
+# Función para cargar datos
+@st.cache_data
+def load_data(uploaded_file):
+    try:
+        if uploaded_file.name.endswith('.csv'):
+            # Para CSV, detectar automáticamente el separador
+            content = uploaded_file.read().decode('utf-8')
+            dialect = io.StringIO(content[:1024]).read()
+            sniffer = pd.io.parsing.Sniffer()
+            delimiter = sniffer.sniff(dialect).delimiter
+            
+            uploaded_file.seek(0)  # Resetear el puntero del archivo
+            df = pd.read_csv(uploaded_file, delimiter=delimiter)
+        else:
+            # Para Excel
+            df = pd.read_excel(uploaded_file)
+        
+        # Convertir automáticamente columnas de fecha
+        df = df.apply(lambda col: pd.to_datetime(col, errors='ignore') 
+                      if col.dtypes == object else col)
+        return df
+    except Exception as e:
+        st.error(f"Error al cargar el archivo: {e}")
+        return None
+
+# Función para combinar columnas de fecha
+def create_date_column(df):
+    date_cols = st.columns(3)
+    with date_cols[0]:
+        year_col = st.selectbox("Selecciona columna de AÑO", df.columns)
+    with date_cols[1]:
+        month_col = st.selectbox("Selecciona columna de MES", df.columns[df.columns != year_col])
+    with date_cols[2]:
+        condition = [(column != year_col and column != month_col) for column in df.columns]
+        day_col = st.selectbox("Selecciona columna de DÍA", df.columns[condition])
+    
+    if st.button("Crear fecha combinada"):
+        try:
+            # Convertir a enteros primero para mayor seguridad
+            df['year'] = df[year_col].astype(int)
+            df['month'] = df[month_col].astype(int)
+            df['day'] = df[day_col].astype(int)
+            
+            # Crear la columna de fecha
+            df['ds'] = pd.to_datetime(df[['year', 'month', 'day']])
+            
+            # Mantener solo la columna resultante
+            df = df.drop(['year', 'month', 'day'], axis=1)
+            
+            st.session_state.df = df
+            st.success("Fecha creada exitosamente! Muestra de fechas:")
+            st.dataframe(st.session_state.df[['ds']].head())
+        except Exception as e:
+            st.error(f"Error al crear fecha: {str(e)}")
+    return df
+
+# Función para descomposición de series temporales
+def plot_decomposition(df, date_col, value_col):
+    st.header("📈 Descomposición de Series Temporales")
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        decomposition_model = st.selectbox("Modelo de descomposición", ["aditiva", "multiplicativa"])
+    with col2:
+        period = st.number_input("Periodo estacional", min_value=2, max_value=365, value=12)
+    
+    if st.button("Analizar componentes"):
+        try:
+            ts = df.set_index(date_col)[value_col].sort_index()
+            decomposition = sm.tsa.seasonal_decompose(ts.dropna(), 
+                                                     model=decomposition_model,
+                                                     period=period)
+
+            fig = make_subplots(rows=4, cols=1, shared_xaxes=True, vertical_spacing=0.1,
+                              subplot_titles=("Serie Original", "Tendencia", 
+                                            "Estacionalidad", "Residuales"))
+
+            # Serie Original
+            fig.add_trace(go.Scatter(x=ts.index, y=ts, mode='lines', name="Original", 
+                                   line=dict(color='#1f77b4')), row=1, col=1)
+
+            # Tendencia
+            fig.add_trace(go.Scatter(x=decomposition.trend.index, y=decomposition.trend, 
+                                   mode='lines', name="Tendencia", line=dict(color='#ff7f0e')), 
+                        row=2, col=1)
+
+            # Estacionalidad
+            fig.add_trace(go.Scatter(x=decomposition.seasonal.index, y=decomposition.seasonal,
+                                   mode='lines', name="Estacionalidad", line=dict(color='#2ca02c')), 
+                        row=3, col=1)
+
+            # Residuales
+            fig.add_trace(go.Scatter(x=decomposition.resid.index, y=decomposition.resid,
+                                   mode='lines', name="Residuales", line=dict(color='#d62728')), 
+                        row=4, col=1)
+
+            fig.update_layout(title_text=f"Descomposición de {value_col}", 
+                            height=800, showlegend=False,
+                            hovermode="x unified")
+            st.plotly_chart(fig, use_container_width=True)
+            
+        except Exception as e:
+            st.error(f"Error en descomposición: {str(e)}")
+
+# Análisis de datos
+def perform_analysis(df):
+    with st.expander("🔍 Análisis Rápido", expanded=True):
+        c1, c2, c3 = st.columns(3)
+        with c1:
+            st.metric("Registros", df.shape[0])
+        with c2:
+            st.metric("Variables", df.shape[1])
+        with c3:
+            missing = df.isna().sum().sum()
+            st.metric("Valores Faltantes", missing)
+    # Análisis estadístico
+    with st.expander("📊 Estadísticas Descriptivas"):
+        st.dataframe(df.describe().T.style.background_gradient(cmap='Blues'))
+    
+    with st.expander("📊 Vista General", expanded=True):
+        
+        date_col = 'ds'
+        values = [column for column in df.select_dtypes(include=np.number).columns if column not in ['ds', "Año", "Mes", "Día", "Dia"]]
+        value_col = st.selectbox("Seleccionar variable para análisis", 
+                            values)
+        plot_decomposition(df, date_col, value_col)
+    
+    # Análisis de correlación
+    with st.expander("🧮 Matriz de Correlación"):
+        numeric_df = df.select_dtypes(include=np.number)
+        if len(numeric_df.columns) > 1:
+            corr = numeric_df.corr()
+            fig = go.Figure(data=go.Heatmap(
+                z=corr.values,
+                x=corr.columns,
+                y=corr.index,
+                colorscale='RdBu',
+                zmin=-1,
+                zmax=1,
+                hoverongaps=True,
+                text=np.round(corr.values, 2)
+            ))
+            fig.update_layout(title='Matriz de Correlación',
+                            width=800,
+                            height=600)
+            st.plotly_chart(fig, use_container_width=True)
+        else:
+            st.warning("No hay suficientes columnas numéricas para calcular correlaciones")
+
+# Visualización temporal interactiva
+def time_analysis(df, date_col):
+    with st.expander("⏳ Análisis Temporal", expanded=True):
+        col1, col2 = st.columns([1, 3])
+        with col1:
+            values = [column for column in df.select_dtypes(include=np.number).columns if column not in ['ds', "Año", "Mes", "Día", "Dia"]]
+            value_col = st.selectbox("Seleccionar variable para análisis temporal",
+                                   values)
+            resample_freq = st.selectbox("Frecuencia de muestreo",
+                                       ['D', 'W', 'M', 'Q', 'Y'])
+        with col2:
+            try:
+                ts_df = df.set_index(date_col)[value_col]
+                resampled = ts_df.resample(resample_freq).mean()
+                
+                fig = px.line(resampled, 
+                            title=f"Evolución Temporal - {value_col}",
+                            labels={'value': value_col, 'index': 'Fecha'},
+                            markers=True)
+                fig.update_traces(line_width=2, 
+                                hovertemplate="Fecha: %{x}<br>Valor: %{y:.2f}")
+                fig.update_layout(hovermode="x unified")
+                st.plotly_chart(fig, use_container_width=True)
+            except Exception as e:
+                st.error(f"Error en análisis temporal: {e}")
+
+# Pronósticos con Prophet
+def forecast_section(df, date_col):
+    st.header("🔮 Modelo Predictivo")
+    
+    # Verificar y convertir a datetime si es necesario
+    if not np.issubdtype(df[date_col].dtype, np.datetime64):
+        df[date_col] = pd.to_datetime(df[date_col], errors='coerce')
+    
+    col1, col2 = st.columns(2)
+    with col1:
+        # Selección de agrupación temporal
+        freq_agrupacion = st.selectbox(
+            "Frecuencia de agrupación",
+            options=['Diaria', 'Semanal', 'Mensual'],
+            help="Agrupa los datos en intervalos temporales antes de modelar"
+        )
+        
+        # Mapeo de frecuencias de pandas
+        freq_map = {
+            'Diaria': 'D',
+            'Semanal': 'W-MON',
+            'Mensual': 'MS'
+        }
+        
+        # Selección de método de agregación
+        metodo_agregacion = st.selectbox(
+            "Método de agregación",
+            options=['Suma', 'Promedio', 'Maximo', 'Minimo'],
+            index=1
+        )
+        
+    with col2:
+        values = [column for column in df.select_dtypes(include=np.number).columns 
+                if column not in ['ds', "Año", "Mes", "Día", "Dia"]]
+        target_col = st.selectbox("Variable a predecir", values)
+        min_value = 1
+        max_value = 14
+        value = 7
+        if freq_agrupacion == "Mensual":
+            max_value = 2
+            value = 1
+        elif freq_agrupacion == "Semanal":
+            max_value = 4
+            value = 2
+        periods = st.number_input(
+            "Periodos a predecir", 
+            min_value=min_value, 
+            max_value=max_value, 
+            value=value,
+            help="Número de unidades temporales a pronosticar según la frecuencia seleccionada"
+        )
+    
+    # Agrupación temporal de los datos
+    try:
+        df_temp = df.set_index(date_col)[target_col]
+        
+        if metodo_agregacion == 'Suma':
+            df_grouped = df_temp.resample(freq_map[freq_agrupacion]).sum()
+        elif metodo_agregacion == 'Promedio':
+            df_grouped = df_temp.resample(freq_map[freq_agrupacion]).mean()
+        elif metodo_agregacion == 'Maximo':
+            df_grouped = df_temp.resample(freq_map[freq_agrupacion]).max()
+        elif metodo_agregacion == 'Minimo':
+            df_grouped = df_temp.resample(freq_map[freq_agrupacion]).min()
+            
+        df_grouped = df_grouped.reset_index()
+        df_grouped.columns = [date_col, target_col]
+        df = df_grouped.dropna()
+        
+        # Mostrar vista previa de los datos agrupados
+        with st.expander("📊 Vista de datos agrupados", expanded=False):
+            st.write(f"Formato actual: {freq_agrupacion} ({len(df)} registros)")
+            fig = px.line(df, x=date_col, y=target_col, title=f"Datos Agrupados - {target_col}")
+            fig.update_traces(mode='lines+markers')
+            st.plotly_chart(fig, use_container_width=True)
+            
+    except Exception as e:
+        st.error(f"Error al agrupar datos: {str(e)}")
+        return
+    
+        # Resto de la configuración del modelo
+    
+    if st.button("Ejecutar Pronóstico", type="primary"):
+        with st.spinner("Creando modelo..."):
+            try:
+                prophet_df = df[[date_col, target_col]].rename(columns={
+                    date_col: 'ds',
+                    target_col: 'y'
+                }).dropna()
+
+                model = Prophet()
+
+
+                model.fit(prophet_df)
+                
+                # Generar futuro considerando la frecuencia
+                future = model.make_future_dataframe(
+                    periods=periods,
+                    freq=freq_map[freq_agrupacion][0]  # Tomar primer carácter (D, W, M)
+                )
+                
+                forecast = model.predict(future)
+                
+                # Resultados
+                st.subheader("Predicción y Componentes")
+                fig1 = plot_plotly(model, forecast)
+                fig1.update_layout(
+                    height=600,
+                    hovermode="x unified",
+                    xaxis_title="Fecha",
+                    yaxis_title=target_col,
+                    annotations=[
+                        dict(
+                            text=f"Frecuencia: {freq_agrupacion} | Agregación: {metodo_agregacion}",
+                            xref="paper",
+                            yref="paper",
+                            x=0.5,
+                            y=-0.15,
+                            showarrow=False
+                        )
+                    ]
+                )
+                st.plotly_chart(fig1, use_container_width=True)
+                
+                st.subheader("Descomposición de Componentes")
+                fig2 = plot_components_plotly(model, forecast)
+                st.plotly_chart(fig2, use_container_width=True)
+                
+                # Mostrar métricas de rendimiento
+                with st.expander("📈 Métricas de Rendimiento", expanded=True):
+                    from sklearn.metrics import mean_absolute_error, mean_squared_error
+                    
+                    merged = forecast.set_index('ds')[['yhat']].join(
+                        prophet_df.set_index('ds')['y']
+                    ).dropna()
+                    
+                    mae = mean_absolute_error(merged['y'], merged['yhat'])
+                    rmse = np.sqrt(mean_squared_error(merged['y'], merged['yhat']))
+                    
+                    col_met1, col_met2 = st.columns(2)
+                    with col_met1:
+                        st.metric("MAE (Error Absoluto Medio)", f"{mae:.2f}")
+                    with col_met2:
+                        st.metric("RMSE (Raíz del Error Cuadrático Medio)", f"{rmse:.2f}")
+                
+            except Exception as e:
+                st.error(f"Error en el modelo: {str(e)}")
+
+def main():
+    st.title("📈 Dashboard Analítico Interactivo")
+    
+    # Crear pestañas
+    tab1, tab2, tab3 = st.tabs(["Carga de Datos", "Análisis Exploratorio", "Pronósticos"])
+    
+    with tab1:
+        st.header("📤 Carga de Datos")
+        uploaded_file = st.file_uploader("Sube tu archivo (Excel o CSV)", type=["xlsx", "xls", "csv"])
+        
+        if uploaded_file:
+            df = load_data(uploaded_file)
+            if df is not None:
+                st.success("Datos cargados exitosamente!")
+                
+                # Mostrar información básica del archivo
+                file_details = {
+                    "Nombre": uploaded_file.name,
+                    "Tipo": uploaded_file.type,
+                    "Tamaño": f"{uploaded_file.size / 1024:.2f} KB"
+                }
+                
+                st.json(file_details)
+                # Nueva sección de análisis de fecha
+                if 'ds' not in st.session_state.df.columns:
+                    st.warning("⚠️ No se detectó columna de fecha. Se creará una nueva columna 'ds'")
+                    create_date_column(df)
+
+                st.dataframe(df.head(), use_container_width=True)
+    
+    if 'df' in st.session_state:
+        
+        with tab2:
+            st.header("🔍 Análisis Exploratorio")
+            perform_analysis(st.session_state.df)
+            
+            # Selección de columna de fecha para análisis temporal
+            date_cols = st.session_state.df.select_dtypes(include=['datetime', 'datetimetz']).columns
+            if len(date_cols) > 0:
+                selected_date = st.selectbox("Seleccionar columna de fecha", date_cols)
+                time_analysis(st.session_state.df, selected_date)
+            else:
+                st.warning("No se detectaron columnas de fecha en los datos")
+        
+        with tab3:
+            st.header("🔮 Pronósticos con Prophet")
+            if len(date_cols) > 0:
+                selected_date = st.selectbox("Seleccionar fecha para pronóstico", date_cols)
+                forecast_section(st.session_state.df, selected_date)
+            else:
+                st.error("Se requiere al menos una columna de fecha para pronósticos")
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,11 @@
+# requirements.txt
+streamlit>=1.22.0
+pandas>=1.5.0
+numpy>=1.24.0
+plotly>=5.13.0
+prophet>=1.1.3
+xlrd>=2.0.1
+openpyxl>=3.0.10
+scikit-learn>=1.2.0
+matplotlib>=3.7.0
+tqdm>=4.65.0