Update app.py

app.py

@@ -4,21 +4,80 @@ import numpy as np
 import pandas as pd
 import datetime
 from scipy.stats import norm
-import matplotlib.pyplot as plt
 import plotly.graph_objects as go
 
 st.set_page_config(page_title="VaR & CVaR Calculator", layout="wide")
-
 st.title("📉 Portfolio VaR & CVaR Calculator")
 st.markdown("""
-Esta app permite calcular el **Valor en Riesgo (VaR)** y el **CVaR** para un portafolio de empresas, usando tres métodos: histórico, paramétrico y simulación Monte Carlo. 
-
-👉 Solo selecciona las empresas, rango de fechas y nivel de confianza.
+Esta app permite calcular el **Valor en Riesgo (VaR)** y el **CVaR** para un portafolio de empresas, usando tres métodos: histórico, paramétrico y simulación Monte Carlo.  
+👉 Solo selecciona las empresas, rango de fechas, nivel de confianza y el número de simulaciones para el método Monte Carlo.
 """)
 
-# -----------------------
-# Lista de empresas populares
-# -----------------------
+# -------------------------------------------------
+# Funciones Auxiliares
+# -------------------------------------------------
+@st.cache_data
+def fetch_data(tickers, start_date, end_date):
+    data = yf.download(tickers, start=start_date, end=end_date)["Close"]
+    return data.dropna()
+
+def compute_weights(returns):
+    # Pesos inversamente proporcionales a la volatilidad
+    volatilidad = returns.std()
+    inv_vol = 1 / volatilidad
+    weights = inv_vol / inv_vol.sum()
+    return weights
+
+def calculate_metrics(returns, confidence_level, n_simulations=10000):
+    tail_prob = 1 - confidence_level
+    portfolio_returns = returns.dot(compute_weights(returns))
+    mean_ret = portfolio_returns.mean()
+    std_ret = portfolio_returns.std()
+
+    # Cálculos para el portafolio
+    historical_VaR = np.percentile(portfolio_returns, tail_prob * 100)
+    z_score = norm.ppf(tail_prob)
+    parametric_VaR = mean_ret + z_score * std_ret
+    simulated_returns = np.random.normal(mean_ret, std_ret, n_simulations)
+    mc_VaR = np.percentile(simulated_returns, tail_prob * 100)
+    historical_CVaR = portfolio_returns[portfolio_returns <= historical_VaR].mean()
+
+    portfolio_metrics = {
+        "mean_return": mean_ret,
+        "std_return": std_ret,
+        "historical_VaR": historical_VaR,
+        "parametric_VaR": parametric_VaR,
+        "mc_VaR": mc_VaR,
+        "historical_CVaR": historical_CVaR,
+        "portfolio_returns": portfolio_returns
+    }
+    return portfolio_metrics
+
+def calculate_individual_metrics(returns, tail_prob, z_score, n_simulations=10000):
+    stats = []
+    for ticker in returns.columns:
+        r = returns[ticker]
+        m = r.mean()
+        s = r.std()
+        hvar = np.percentile(r, tail_prob * 100)
+        pvar = m + z_score * s
+        sim_r = np.random.normal(m, s, n_simulations)
+        mcvar = np.percentile(sim_r, tail_prob * 100)
+        hcvar = r[r <= hvar].mean()
+        stats.append({
+            "Ticker": ticker,
+            "Retorno Promedio": m,
+            "Volatilidad": s,
+            "VaR Histórico": hvar,
+            "VaR Paramétrico": pvar,
+            "VaR Monte Carlo": mcvar,
+            "CVaR Histórico": hcvar
+        })
+    return pd.DataFrame(stats)
+
+# -------------------------------------------------
+# Configuración de la App (Sidebar)
+# -------------------------------------------------
 company_options = {
     "Apple (AAPL)": "AAPL",
     "Tesla (TSLA)": "TSLA",
@@ -50,169 +109,239 @@ company_options = {
     "Walmart de México (WALMEX.MX)": "WALMEX.MX"
 }
 
-# -----------------------
-# Entradas del usuario
-# -----------------------
 with st.sidebar:
-    st.header("🔧 Configuración del análisis")
+    st.header("🔧 Configuración del Análisis")
     selected_companies = st.multiselect("Selecciona las empresas del portafolio", list(company_options.keys()))
     start_date = st.date_input("Fecha de inicio", datetime.date(2022, 1, 1))
     end_date = st.date_input("Fecha de fin", datetime.date.today())
     confidence_level = st.select_slider("Nivel de confianza", options=[0.90, 0.95, 0.99], value=0.95)
+    n_simulations = st.number_input("Número de simulaciones Monte Carlo", min_value=1000, max_value=100000, value=10000, step=1000)
 
-# Obtener tickers directamente
+# Obtener tickers a partir de la selección
 tickers = [company_options[c] for c in selected_companies]
 
+# -------------------------------------------------
+# Ejecución y Cálculos
+# -------------------------------------------------
 if st.button("📊 Calcular VaR y CVaR"):
     if not tickers:
         st.warning("⚠️ Debes seleccionar al menos una empresa.")
+    elif start_date >= end_date:
+        st.warning("⚠️ La fecha de inicio debe ser anterior a la fecha de fin.")
     else:
         with st.spinner("Obteniendo datos y calculando..."):
-            data = yf.download(tickers, start=start_date, end=end_date)["Close"].dropna()
-            returns = data.pct_change().dropna()
-
-            if returns.empty:
-                st.error("❌ No se encontraron datos válidos para el rango y empresas seleccionadas.")
-                st.stop()
-
-            # Pesos inversamente proporcionales a la volatilidad
-            volatilities = returns.std()
-            inv_vol = 1 / volatilities
-            weights = inv_vol / inv_vol.sum()
-
-            portfolio_returns = returns.dot(weights)
-
-            if portfolio_returns.empty:
-                st.error("❌ No se encontraron rendimientos válidos para el portafolio.")
-                st.stop()
-
-            tail_prob = 1 - confidence_level
-
-            historical_VaR = np.percentile(portfolio_returns, tail_prob * 100)
-            mean_ret = portfolio_returns.mean()
-            std_ret = portfolio_returns.std()
-            z_score = norm.ppf(tail_prob)
-            parametric_VaR = mean_ret + z_score * std_ret
-            simulated_returns = np.random.normal(mean_ret, std_ret, 10000)
-            mc_VaR = np.percentile(simulated_returns, tail_prob * 100)
-            historical_CVaR = portfolio_returns[portfolio_returns <= historical_VaR].mean()
-
-            st.subheader("📌 Resultados del Portafolio")
-            st.markdown(f"**Nivel de confianza:** {int(confidence_level * 100)}%")
-            st.markdown("**Pesos calculados automáticamente en base a la volatilidad:**")
-            st.dataframe(pd.DataFrame({"Ticker": tickers, "Peso": weights.values.round(4)}))
-
-            col1, col2 = st.columns(2)
-            with col1:
-                st.metric("Retorno promedio diario", f"{mean_ret:.5f}")
-                st.metric("Volatilidad diaria", f"{std_ret:.5f}")
-                st.metric("VaR Histórico", f"{historical_VaR:.2%}")
-            with col2:
-                st.metric("VaR Paramétrico", f"{parametric_VaR:.2%}")
-                st.metric("VaR Monte Carlo", f"{mc_VaR:.2%}")
-                st.metric("CVaR Histórico", f"{historical_CVaR:.2%}")
-
-            st.subheader("📊 Resultados Individuales por Empresa")
-            individual_stats = []
-            for ticker in tickers:
-                r = returns[ticker]
-                m = r.mean()
-                s = r.std()
-                hvar = np.percentile(r, tail_prob * 100)
-                pvar = m + z_score * s
-                sim_r = np.random.normal(m, s, 10000)
-                mcvar = np.percentile(sim_r, tail_prob * 100)
-                hcvar = r[r <= hvar].mean()
-                individual_stats.append([
-                    ticker, m, s, hvar, pvar, mcvar, hcvar
-                ])
-
-            df_stats = pd.DataFrame(individual_stats, columns=[
-                "Ticker", "Retorno Promedio", "Volatilidad", "VaR Histórico", 
-                "VaR Paramétrico", "VaR Monte Carlo", "CVaR Histórico"
-            ])
-            st.dataframe(df_stats.style.format({
-                "Retorno Promedio": "{:.5f}",
-                "Volatilidad": "{:.5f}",
-                "VaR Histórico": "{:.2%}",
-                "VaR Paramétrico": "{:.2%}",
-                "VaR Monte Carlo": "{:.2%}",
-                "CVaR Histórico": "{:.2%}"
-            }))
-
-            # 📊 Gráfica 1: Histograma de rendimientos del portafolio
-            st.subheader("📉 Distribución de Rendimientos del Portafolio")
-
-            hist_data = go.Histogram(
-                x=portfolio_returns,
-                nbinsx=50,
-                name="Rendimientos",
-                marker=dict(color='rgba(0, 123, 255, 0.6)'),
-                hovertemplate='Rendimiento: %{x:.2%}<br>Frecuencia: %{y}'
-            )
-
-            vlines = []
-            for value, label, color in zip(
-                [historical_VaR, parametric_VaR, mc_VaR],
-                ["VaR Histórico", "VaR Paramétrico", "VaR Monte Carlo"],
-                ["red", "blue", "green"]
-            ):
-                vlines.append(go.Scatter(
-                    x=[value, value],
-                    y=[0, portfolio_returns.count() * 0.1],
-                    mode="lines",
-                    name=f"{label}: {value:.2%}",
-                    line=dict(dash="dash", color=color, width=2),
-                    showlegend=True
-                ))
-
-            fig = go.Figure([hist_data] + vlines)
-            fig.update_layout(
-                title="Distribución de Rendimientos del Portafolio",
-                xaxis_title="Rendimiento Diario",
-                yaxis_title="Frecuencia",
-                template="plotly_white",
-                hovermode="x unified",
-                bargap=0.05,
-                height=450
-            )
-            st.plotly_chart(fig, use_container_width=True)
-
-            # 📈 Gráfica 2: Serie temporal
-            st.subheader("📈 Serie Temporal de Rendimientos del Portafolio")
-
-            fig2 = go.Figure()
-            fig2.add_trace(go.Scatter(
-                x=portfolio_returns.index,
-                y=portfolio_returns,
-                name="Rendimientos",
-                mode="lines",
-                line=dict(color="orange"),
-                hovertemplate="Fecha: %{x}<br>Retorno: %{y:.2%}"
-            ))
-
-            for value, label, color in zip(
-                [historical_VaR, parametric_VaR, mc_VaR],
-                ["VaR Histórico", "VaR Paramétrico", "VaR Monte Carlo"],
-                ["red", "blue", "green"]
-            ):
-                fig2.add_trace(go.Scatter(
-                    x=[portfolio_returns.index[0], portfolio_returns.index[-1]],
-                    y=[value, value],
-                    mode="lines",
-                    name=f"{label}: {value:.2%}",
-                    line=dict(dash="dash", color=color, width=2),
-                    showlegend=True
-                ))
-
-            fig2.update_layout(
-                title="Rendimientos del Portafolio en el Tiempo",
-                xaxis_title="Fecha",
-                yaxis_title="Rendimiento Diario",
-                template="plotly_white",
-                hovermode="x unified",
-                height=450
-            )
-            st.plotly_chart(fig2, use_container_width=True)
-
-            st.success("✅ Cálculos completados exitosamente")
+            try:
+                data = fetch_data(tickers, start_date, end_date)
+                returns = data.pct_change().dropna()
+                if returns.empty:
+                    st.error("❌ No se encontraron datos válidos para el rango y empresas seleccionadas.")
+                    st.stop()
+
+                # Cálculo de métricas del portafolio y de cada empresa
+                weights = compute_weights(returns)
+                portfolio_metrics = calculate_metrics(returns, confidence_level, n_simulations)
+                tail_prob = 1 - confidence_level
+                z_score = norm.ppf(tail_prob)
+                df_individual = calculate_individual_metrics(returns, tail_prob, z_score, n_simulations)
+
+                # -------------------------------------------------
+                # Resultados del Portafolio
+                # -------------------------------------------------
+                st.subheader("📌 Resultados del Portafolio")
+                st.markdown(f"**Nivel de confianza:** {int(confidence_level * 100)}%")
+                st.markdown("**Pesos calculados automáticamente (inversamente proporcionales a la volatilidad):**")
+                weights_df = pd.DataFrame({
+                    "Ticker": tickers,
+                    "Peso": weights.round(4).values
+                })
+                st.dataframe(weights_df)
+
+                col1, col2 = st.columns(2)
+                with col1:
+                    st.metric("Retorno promedio diario", f"{portfolio_metrics['mean_return']:.5f}")
+                    st.metric("Volatilidad diaria", f"{portfolio_metrics['std_return']:.5f}")
+                    st.metric("VaR Histórico", f"{portfolio_metrics['historical_VaR']:.2%}")
+                with col2:
+                    st.metric("VaR Paramétrico", f"{portfolio_metrics['parametric_VaR']:.2%}")
+                    st.metric("VaR Monte Carlo", f"{portfolio_metrics['mc_VaR']:.2%}")
+                    st.metric("CVaR Histórico", f"{portfolio_metrics['historical_CVaR']:.2%}")
+
+                # -------------------------------------------------
+                # Resultados Individuales por Empresa
+                # -------------------------------------------------
+                st.subheader("📊 Resultados Individuales por Empresa")
+                df_individual_display = df_individual.style.format({
+                    "Retorno Promedio": "{:.5f}",
+                    "Volatilidad": "{:.5f}",
+                    "VaR Histórico": "{:.2%}",
+                    "VaR Paramétrico": "{:.2%}",
+                    "VaR Monte Carlo": "{:.2%}",
+                    "CVaR Histórico": "{:.2%}"
+                })
+                st.dataframe(df_individual_display)
+
+                # Botones para descargar resultados
+                csv_weights = weights_df.to_csv(index=False).encode('utf-8')
+                st.download_button("Descargar Pesos", csv_weights, "pesos_portafolio.csv", "text/csv")
+                csv_individual = df_individual.to_csv(index=False).encode('utf-8')
+                st.download_button("Descargar Resultados Individuales", csv_individual, "resultados_individuales.csv", "text/csv")
+
+                # -------------------------------------------------
+                # Creación de pestañas: una para el portafolio y otras para cada empresa
+                # -------------------------------------------------
+                tab_names = ["Portfolio"] + selected_companies
+                tabs = st.tabs(tab_names)
+
+                # --- Colores para el portafolio ---
+                portfolio_vaR_colors = ("tomato", "seagreen", "dodgerblue")
+
+                # ----- Tab: Portafolio -----
+                with tabs[0]:
+                    st.markdown("## Gráficos del Portafolio")
+                    # Histograma de Rendimientos del Portafolio con líneas de VaR
+                    fig_port_hist = go.Figure()
+                    fig_port_hist.add_trace(go.Histogram(
+                        x=portfolio_metrics["portfolio_returns"],
+                        nbinsx=50,
+                        name="Rendimientos",
+                        marker=dict(color='rgba(70, 130, 180, 0.6)'),
+                        hovertemplate='Rendimiento: %{x:.2%}<br>Frecuencia: %{y}'
+                    ))
+                    for value, label, color in zip(
+                        [portfolio_metrics["historical_VaR"],
+                         portfolio_metrics["parametric_VaR"],
+                         portfolio_metrics["mc_VaR"]],
+                        ["VaR Histórico", "VaR Paramétrico", "VaR Monte Carlo"],
+                        portfolio_vaR_colors
+                    ):
+                        fig_port_hist.add_trace(go.Scatter(
+                            x=[value, value],
+                            y=[0, portfolio_metrics["portfolio_returns"].count() * 0.1],
+                            mode="lines",
+                            name=f"{label}: {value:.2%}",
+                            line=dict(dash="dash", color=color, width=2)
+                        ))
+                    fig_port_hist.update_layout(
+                        title="Distribución de Rendimientos del Portafolio",
+                        xaxis_title="Rendimiento Diario",
+                        yaxis_title="Frecuencia",
+                        template="plotly_white",
+                        hovermode="x unified",
+                        bargap=0.05,
+                        height=450
+                    )
+                    st.plotly_chart(fig_port_hist, use_container_width=True)
+
+                    # Serie Temporal de Rendimientos del Portafolio
+                    fig_port_line = go.Figure()
+                    fig_port_line.add_trace(go.Scatter(
+                        x=portfolio_metrics["portfolio_returns"].index,
+                        y=portfolio_metrics["portfolio_returns"],
+                        name="Rendimientos",
+                        mode="lines",
+                        line=dict(color="orange"),
+                        hovertemplate="Fecha: %{x}<br>Retorno: %{y:.2%}"
+                    ))
+                    for value, label, color in zip(
+                        [portfolio_metrics["historical_VaR"],
+                         portfolio_metrics["parametric_VaR"],
+                         portfolio_metrics["mc_VaR"]],
+                        ["VaR Histórico", "VaR Paramétrico", "VaR Monte Carlo"],
+                        portfolio_vaR_colors
+                    ):
+                        fig_port_line.add_trace(go.Scatter(
+                            x=[portfolio_metrics["portfolio_returns"].index[0],
+                               portfolio_metrics["portfolio_returns"].index[-1]],
+                            y=[value, value],
+                            mode="lines",
+                            name=f"{label}: {value:.2%}",
+                            line=dict(dash="dash", color=color, width=2)
+                        ))
+                    fig_port_line.update_layout(
+                        title="Serie Temporal de Rendimientos del Portafolio",
+                        xaxis_title="Fecha",
+                        yaxis_title="Rendimiento Diario",
+                        template="plotly_white",
+                        hovermode="x unified",
+                        height=450
+                    )
+                    st.plotly_chart(fig_port_line, use_container_width=True)
+
+                # --- Paleta de colores para empresas (d3 Category10) ---
+                category_colors = ["#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", 
+                                   "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", 
+                                   "#bcbd22", "#17becf"]
+
+                # ----- Tabs: Gráficos Individuales de cada Empresa -----
+                for i, company in enumerate(selected_companies):
+                    ticker = company_options[company]
+                    # Extraer los valores del VaR para la empresa desde df_individual
+                    company_metrics = df_individual[df_individual["Ticker"] == ticker].iloc[0]
+                    # Asignar colores distintos para la empresa usando la paleta
+                    comp_hist_color = category_colors[i % len(category_colors)]
+                    comp_param_color = category_colors[(i+1) % len(category_colors)]
+                    comp_mc_color = category_colors[(i+2) % len(category_colors)]
+                    
+                    with tabs[i+1]:
+                        st.markdown(f"### {company}")
+                        # Primero, el histograma de rendimientos (gráfica de barras)
+                        fig_hist = go.Figure()
+                        fig_hist.add_trace(go.Histogram(
+                            x=returns[ticker],
+                            nbinsx=50,
+                            name="Rendimientos",
+                            marker=dict(color=comp_hist_color, opacity=0.6),
+                            hovertemplate='Rendimiento: %{x:.2%}<br>Frecuencia: %{y}'
+                        ))
+                        for value, label, color in zip(
+                            [company_metrics["VaR Histórico"], company_metrics["VaR Paramétrico"], company_metrics["VaR Monte Carlo"]],
+                            ["VaR Histórico", "VaR Paramétrico", "VaR Monte Carlo"],
+                            [comp_hist_color, comp_param_color, comp_mc_color]
+                        ):
+                            fig_hist.add_trace(go.Scatter(
+                                x=[value, value],
+                                y=[0, returns[ticker].count() * 0.1],
+                                mode="lines",
+                                name=f"{label}: {value:.2%}",
+                                line=dict(dash="dash", color=color, width=2)
+                            ))
+                        fig_hist.update_layout(
+                            title=f"{company}: Distribución de Rendimientos",
+                            xaxis_title="Rendimiento",
+                            yaxis_title="Frecuencia",
+                            template="plotly_white",
+                            bargap=0.05
+                        )
+                        st.plotly_chart(fig_hist, use_container_width=True)
+
+                        # Luego, la serie de precios (gráfica de líneas)
+                        fig_price = go.Figure()
+                        fig_price.add_trace(go.Scatter(
+                            x=data.index,
+                            y=data[ticker],
+                            mode="lines",
+                            name="Precio de Cierre",
+                            hovertemplate="Fecha: %{x}<br>Precio: %{y:.2f}"
+                        ))
+                        fig_price.update_layout(
+                            title=f"{company}: Serie de Precios",
+                            xaxis_title="Fecha",
+                            yaxis_title="Precio (USD)",
+                            template="plotly_white"
+                        )
+                        st.plotly_chart(fig_price, use_container_width=True)
+                
+                st.success("✅ Cálculos completados exitosamente")
+
+                # -------------------------------------------------
+                # Explicación de los Métodos de Cálculo
+                # -------------------------------------------------
+                with st.expander("ℹ️ Más información sobre los métodos de cálculo"):
+                    st.markdown("""
+                    **VaR Histórico:** Calcula el percentil de los rendimientos históricos.  
+                    **VaR Paramétrico:** Utiliza la media, la desviación estándar y la distribución normal (z-score) para estimar el VaR.  
+                    **VaR Monte Carlo:** Simula rendimientos usando una distribución normal basada en la media y la desviación estándar del portafolio.  
+                    **CVaR Histórico:** Es el promedio de los rendimientos que están por debajo del VaR histórico.
+                    """)
+            except Exception as e:
+                st.error(f"❌ Ocurrió un error durante el cálculo: {e}")