Update app.py

app.py

@@ -10,6 +10,8 @@ import matplotlib.pyplot as plt
 import seaborn as sns
 
 
+
+
 alphacast = Alphacast("ak_rjVLScLXFCHwimxt5Qew")
 dataset = alphacast.datasets.dataset(5664)
 df = dataset.download_data(format = "pandas", startDate=None, endDate=None, filterVariables = [], filterEntities = {})
@@ -28,31 +30,31 @@ subdatasets = {}
 rbc_data = {}
 
 for pais in paises:
-    # Filtrar los datos por país
+    
     df_pais = data[data['country'] == pais]
     df_pais = df_pais.rename(columns = {"Date":"DATE"})
+
     
-    # Establecer la columna "Date" como índice
     df_pais.set_index('DATE', inplace=True)
+
     
-    # Filtrar para que la data empiece desde 1991
     df_pais = df_pais[df_pais.index >= '1990-01-01']
+
     
-    # Cálculo en términos per cápita (C, L, I, N)
-    N = df_pais['N']  # Población
-    C = df_pais['C'] / N  # Consumo per cápita
-    I = df_pais['I'] / N  # Inversión per cápita
-    L = df_pais['L']  # Horas trabajadas (asumiendo que ya es per cápita o representa la fuerza laboral)
+    N = df_pais['N']  
+    C = df_pais['C'] / N
+    I = df_pais['I'] / N
+    L = df_pais['L']  
+
     
-    # Calcular el ingreso (output) como la suma de Consumo e Inversión
-    Y = C + I  # Ingreso per cápita
+    Y = C + I  
+
     
-    # Logaritmo natural y diferencia temporal (detrending)
-    y = np.log(Y).diff()[1:]  # Producto
-    c = np.log(C).diff()[1:]  # Consumo
-    n = np.log(L).diff()[1:]  # Horas trabajadas
+    y = np.log(Y).diff()[1:] 
+    c = np.log(C).diff()[1:] 
+    n = np.log(L).diff()[1:] 
+
     
-    # Concatenar los resultados en un DataFrame con el índice "Date"
     rbc_data[pais] = pd.concat((y, n, c), axis=1)
     rbc_data[pais].columns = ['output', 'labor', 'consumption']
 
@@ -72,58 +74,52 @@ subdatasets_2 = {}
 rbc_data_2 = {}
 
 for pais in paises:
-    # Filtrar los datos por país
+    
     df_pais = data_2[data_2['country'] == pais]
     df_pais = df_pais.rename(columns = {"Date":"DATE"})
+
     
-    # Establecer la columna "Date" como índice
     df_pais.set_index('DATE', inplace=True)
+
     
-    # Filtrar para que la data empiece desde 1991
     df_pais = df_pais[df_pais.index >= '1990-01-01']
+
     
-    # Cálculo en términos per cápita (C, L, I, N)
-    N = df_pais['N']  # Población
+    N = df_pais['N'] 
     Y = df_pais["Y"] / N
-    C = df_pais['C'] / N  # Consumo per cápita
-    I = df_pais['I'] / N  # Inversión per cápita
-    L = df_pais['L']  # Horas trabajadas (asumiendo que ya es per cápita o representa la fuerza laboral)
-    
-    
-    
-    # Logaritmo natural y diferencia temporal (detrending)
-    y = np.log(Y).diff()[1:]  # Producto
-    c = np.log(C).diff()[1:]  # Consumo
-    n = np.log(L).diff()[1:]  # Horas trabajadas
-    
-    # Concatenar los resultados en un DataFrame con el índice "Date"
+    C = df_pais['C'] / N  
+    I = df_pais['I'] / N  
+    L = df_pais['L']  
+
+
+
+    y = np.log(Y).diff()[1:]
+    c = np.log(C).diff()[1:]
+    n = np.log(L).diff()[1:]
+
     rbc_data_2[pais] = pd.concat((y, n, c), axis=1)
     rbc_data_2[pais].columns = ['output', 'labor', 'consumption']
 
 
 def generar_grafico_pais(pais):
-    # Filtrar los datos del país
+
     df_pais = rbc_data[pais]
 
-    # Crear el gráfico interactivo
     fig = go.Figure()
 
-    # Añadir las tres series: output (y), labor (n), consumption (c)
-    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['output'], 
+    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['output'],
                              mode='lines+markers', name='Output (y)', marker=dict(symbol='circle')))
-    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['labor'], 
+    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['labor'],
                              mode='lines+markers', name='Labor (n)', marker=dict(symbol='x')))
-    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['consumption'], 
+    fig.add_trace(go.Scatter(x=df_pais.index, y=df_pais['consumption'],
                              mode='lines+markers', name='Consumption (c)', marker=dict(symbol='square')))
 
-    # Personalizar el layout (título, etiquetas, etc.)
     fig.update_layout(title=f'Producción, Trabajo, y Consumo para {pais} (1991 - 2019)',
                       xaxis_title='Fecha',
                       yaxis_title='Log Differences',
                       legend_title='Variables',
                       template='plotly_dark')
 
-    # Mostrar el gráfico
     fig.show()
 
 
@@ -143,7 +139,6 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
             endog, k_states=2, k_posdef=1, initialization='stationary')
         self.k_predetermined = 1
 
-        # Save the calibrated vs. estimated parameters
         parameters = list(self.parameters.keys())
         calibrated = calibrated or {}
         self.calibrated = OrderedDict([
@@ -162,7 +157,6 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
         self.idx_tech_pers = parameters.index('technology_shock_persistence')
         self.idx_tech_var = parameters.index('technology_shock_var')
 
-        # Setup fixed elements of system matrices
         self['selection', 1, 0] = 1
 
     @property
@@ -178,17 +172,14 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
         return structural_params.tolist() + measurement_variances
 
     def log_linearize(self, params):
-        # Extract the parameters
         (discount_rate, disutility_labor, depreciation_rate, capital_share,
          technology_shock_persistence, technology_shock_var) = params
 
-        # Temporary values
         tmp = (1. / discount_rate - (1. - depreciation_rate))
         theta = (capital_share / tmp)**(1. / (1. - capital_share))
         gamma = 1. - depreciation_rate * theta**(1. - capital_share)
         zeta = capital_share * discount_rate * theta**(capital_share - 1)
 
-        # Coefficient matrices from linearization
         A = np.eye(2)
 
         B11 = 1 + depreciation_rate * (gamma / (1 - gamma))
@@ -210,19 +201,15 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
         capital_share = params[self.idx_cap_share]
         technology_shock_persistence = params[self.idx_tech_pers]
 
-        # Get the coefficient matrices from linearization
         A, B, C = self.log_linearize(params)
 
-        # Jordan decomposition of B
         eigvals, right_eigvecs = np.linalg.eig(np.transpose(B))
         left_eigvecs = np.transpose(right_eigvecs)
 
-        # Re-order, ascending
         idx = np.argsort(eigvals)
         eigvals = np.diag(eigvals[idx])
         left_eigvecs = left_eigvecs[idx, :]
 
-        # Blanchard-Kahn conditions
         k_nonpredetermined = self.k_states - self.k_predetermined
         k_stable = len(np.where(eigvals.diagonal() < 1)[0])
         k_unstable = self.k_states - k_stable
@@ -230,7 +217,6 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
             raise RuntimeError('Blanchard-Kahn condition not met.'
                                ' Unique solution does not exist.')
 
-        # Create partition indices
         k = self.k_predetermined
         p1 = np.s_[:k]
         p2 = np.s_[k:]
@@ -240,16 +226,11 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
         p21 = np.s_[k:, :k]
         p22 = np.s_[k:, k:]
 
-        # Decouple the system
         decoupled_C = np.dot(left_eigvecs, C)
 
-        # Solve the explosive component (controls) in terms of the
-        # non-explosive component (states) and shocks
         tmp = np.linalg.inv(left_eigvecs[p22])
 
-        # This is \phi_{ck}, above
         policy_state = - np.dot(tmp, left_eigvecs[p21]).squeeze()
-        # This is \phi_{cz}, above
         policy_shock = -(
             np.dot(tmp, 1. / eigvals[p22]).dot(
                 np.linalg.inv(
@@ -259,20 +240,15 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
             ).dot(decoupled_C[p2])
         ).squeeze()
 
-        # Solve for the non-explosive transition
-        # This is T_{kk}, above
         transition_state = np.squeeze(B[p11] + np.dot(B[p12], policy_state))
-        # This is T_{kz}, above
         transition_shock = np.squeeze(np.dot(B[p12], policy_shock) + C[p1])
 
-        # Create the full design matrix
         tmp = (1 - capital_share) / capital_share
         tmp1 = 1. / capital_share
         design = np.array([[1 - tmp * policy_state, tmp1 - tmp * policy_shock],
                            [1 - tmp1 * policy_state, tmp1 * (1-policy_shock)],
                            [policy_state,            policy_shock]])
 
-        # Create the transition matrix
         transition = (
             np.array([[transition_state, transition_shock],
                       [0,                technology_shock_persistence]]))
@@ -280,38 +256,32 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
         return design, transition
 
     def transform_discount_rate(self, param, untransform=False):
-        # Discount rate must be between 0 and 1
-        epsilon = 1e-4  # bound it slightly away from exactly 0 or 1
+        epsilon = 1e-4 
         if not untransform:
             return np.abs(1 / (1 + np.exp(param)) - epsilon)
         else:
             return np.log((1 - param + epsilon) / (param + epsilon))
 
     def transform_disutility_labor(self, param, untransform=False):
-        # Disutility of labor must be positive
         return param**2 if not untransform else param**0.5
 
     def transform_depreciation_rate(self, param, untransform=False):
-        # Depreciation rate must be positive
         return param**2 if not untransform else param**0.5
 
     def transform_capital_share(self, param, untransform=False):
-        # Capital share must be between 0 and 1
-        epsilon = 1e-4  # bound it slightly away from exactly 0 or 1
+        epsilon = 1e-4  
         if not untransform:
             return np.abs(1 / (1 + np.exp(param)) - epsilon)
         else:
             return np.log((1 - param + epsilon) / (param + epsilon))
 
     def transform_technology_shock_persistence(self, param, untransform=False):
-        # Persistence parameter must be between -1 and 1
         if not untransform:
             return param / (1 + np.abs(param))
         else:
             return param / (1 - param)
 
     def transform_technology_shock_var(self, unconstrained, untransform=False):
-        # Variances must be positive
         return unconstrained**2 if not untransform else unconstrained**0.5
 
     def transform_params(self, unconstrained):
@@ -324,7 +294,6 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
                 constrained[i] = method(unconstrained[i])
                 i += 1
 
-        # Measurement error variances must be positive
         constrained[self.k_estimated:] = unconstrained[self.k_estimated:]**2
 
         return constrained
@@ -339,7 +308,6 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
                 unconstrained[i] = method(constrained[i], untransform=True)
                 i += 1
 
-        # Measurement error variances must be positive
         unconstrained[self.k_estimated:] = constrained[self.k_estimated:]**0.5
 
         return unconstrained
@@ -347,17 +315,13 @@ class SimpleRBC(sm.tsa.statespace.MLEModel):
     def update(self, params, **kwargs):
         params = super(SimpleRBC, self).update(params, **kwargs)
 
-        # Reconstruct the full parameter vector from the
-        # estimated and calibrated parameters
         structural_params = np.zeros(self.k_params, dtype=params.dtype)
         structural_params[self.idx_calibrated] = list(self.calibrated.values())
         structural_params[self.idx_estimated] = params[:self.k_estimated]
         measurement_variances = params[self.k_estimated:]
 
-        # Solve the model
         design, transition = self.solve(structural_params)
 
-        # Update the statespace representation
         self['design'] = design
         self['obs_cov', 0, 0] = measurement_variances[0]
         self['obs_cov', 1, 1] = measurement_variances[1]
@@ -384,9 +348,9 @@ def plot_irfs_plotly(irfs):
     fig.add_trace(go.Scatter(x=list(range(len(irfs['consumption']))), y=irfs['consumption'], mode='lines+markers', name='Consumption'))
 
     fig.update_layout(
-        title="Impulse Responses (RBC Model)",
-        xaxis_title="Quarters after impulse",
-        yaxis_title="Impulse response (%)",
+        title="Función Impulso Respuesta",
+        xaxis_title="Años después del shcok",
+        yaxis_title="Impulso respuesta (%)",
         legend_title="Variables",
         template = "plotly_dark"
     )
@@ -396,7 +360,6 @@ def plot_irfs_plotly(irfs):
 def plot_states_plotly(res, rbc_data):
     fig = go.Figure()
 
-    # Capital plot with confidence interval
     capital = res.smoothed_state[0, :]
     shock = res.smoothed_state[1, :]
 
@@ -415,39 +378,32 @@ def plot_states_plotly(res, rbc_data):
     return fig
 
 def plot_rbc_model(pais, persistence, shock_variance, discount_rate, disutility_labor, capital_share, depreciation_rate):
-    # Crear el diccionario de parámetros calibrados con los valores ingresados
     calibrated = {
         'discount_rate': discount_rate,
         'disutility_labor': disutility_labor,
         'capital_share': capital_share,
         'depreciation_rate': depreciation_rate,
         'technology_shock_persistence': persistence,
-        'technology_shock_var': shock_variance ** 2  # El usuario ingresa la desviación estándar
+        'technology_shock_var': shock_variance ** 2  
     }
 
-    # Calibrar el modelo
     calibrated_mod = SimpleRBC(rbc_data[pais], calibrated=calibrated)
     calibrated_res = calibrated_mod.fit(method='nm', maxiter=1000, disp=0)
 
-    # Obtener las respuestas ante choques
     calibrated_irfs_pos = calibrated_res.impulse_responses(40, orthogonalized=True) * 100
-    calibrated_irfs_neg = -calibrated_irfs_pos  # Efecto negativo
+    calibrated_irfs_neg = -calibrated_irfs_pos  
 
-    # Graficar los IRF para el choque positivo
     fig_pos = plot_irfs_plotly(pd.DataFrame(calibrated_irfs_pos, columns=['output', 'labor', 'consumption']))
 
-    # Graficar los IRF para el choque negativo
     fig_neg = plot_irfs_plotly(pd.DataFrame(calibrated_irfs_neg, columns=['output', 'labor', 'consumption']))
 
-    # Output estadístico del modelo como un DataFrame
     summary_df = calibrated_res.summary().tables[1].data
-    summary_df = pd.DataFrame(summary_df[1:], columns=summary_df[0])  # Crear DataFrame de la tabla resumen
+    summary_df = pd.DataFrame(summary_df[1:], columns=summary_df[0])  
 
-    estimated_coefficients = summary_df['coef'].astype(float)  # Convertir a float
-    # Usar el índice en lugar de la columna 'Variable'
-    estimated_var_output = estimated_coefficients[summary_df.index[0]] 
-    estimated_var_labor = estimated_coefficients[summary_df.index[1]] 
-    estimated_var_consumption = estimated_coefficients[summary_df.index[2]] 
+    estimated_coefficients = summary_df['coef'].astype(float)  
+    estimated_var_output = estimated_coefficients[summary_df.index[0]]
+    estimated_var_labor = estimated_coefficients[summary_df.index[1]]
+    estimated_var_consumption = estimated_coefficients[summary_df.index[2]]
 
 
 
@@ -455,18 +411,16 @@ def plot_rbc_model(pais, persistence, shock_variance, discount_rate, disutility_
     var_consumption = np.var(rbc_data_2[pais]["consumption"])
     var_labor = np.var(rbc_data_2[pais]["labor"])
 
-    # Crear un DataFrame con los resultados de la varianza
     var_data = pd.DataFrame({
           'Variable': ['Output Real', 'Consumption', 'Labor'],
           'Varianza Real': [var_output, var_consumption, var_labor],
           'Varianza Estimada': [estimated_var_output, estimated_var_consumption, estimated_var_labor],
           'Diferencia': [abs(var_output - estimated_var_output), abs(var_consumption - estimated_var_consumption), abs(var_labor - estimated_var_labor)]
       })
-    
+
 
     return fig_pos, fig_neg, summary_df, var_data
 
-# Interfaz de Gradio
 with gr.Blocks() as demo:
     with gr.Row():
         gr.Markdown("### Real Business Cycle (RBC) Model Dashboard")
@@ -498,12 +452,10 @@ with gr.Blocks() as demo:
         """)
 
     with gr.Tab("Gráfico del País"):
-        pais_selec_grafico = gr.Dropdown(choices=["Argentina", "Brazil", "Chile", "Uruguay", "Colombia"], label="Selecciona un país")
+        pais = gr.Dropdown(choices=["Argentina", "Brazil", "Chile", "Uruguay", "Colombia"], label="Selecciona un país")
         grafico_pais = gr.Plot(label="Producción, Trabajo y Consumo")
-        
-        # Generar gráfico al cambiar la selección
-        pais_selec_grafico.change(fn=generar_grafico_pais, inputs=pais_selec_grafico, outputs=grafico_pais)
-    # Parámetros calibrados: casillas para ingresar valores
+    
+        pais.change(generar_grafico_pais,pais,grafico_pais)
     with gr.Tab("Calibración del Modelo"):
         pais_selec = gr.Dropdown(choices=["Argentina", "Brazil", "Chile", "Uruguay", "Colombia"], label="Selecciona un país")
         persistence = gr.Slider(label="Persistencia del choque tecnológico", minimum=0.5, maximum=1.0, value=0.85)
@@ -513,10 +465,8 @@ with gr.Blocks() as demo:
         capital_share = gr.Number(label="Participación del capital (α)", value=0.36)
         depreciation_rate = gr.Number(label="Tasa de depreciación", value=0.025)
 
-        # Botón para actualizar los gráficos
         btn = gr.Button("Actualizar Modelo")
 
-        # Gráficos de las respuestas ante choques
         output_pos = gr.Plot(label="Respuesta ante un Choque Tecnológico Positivo")
         output_neg = gr.Plot(label="Respuesta ante un Choque Tecnológico Negativo")
 
@@ -524,10 +474,8 @@ with gr.Blocks() as demo:
         output_stats = gr.DataFrame(label="Output estadístico del modelo", type="pandas")
         output_var = gr.DataFrame(label="Varianzas reales", type = "pandas")
 
-    # Funcionalidad del botón
     btn.click(fn=plot_rbc_model,
               inputs=[pais_selec,persistence, shock_variance, discount_rate, disutility_labor, capital_share, depreciation_rate],
               outputs=[output_pos, output_neg, output_stats,output_var])
 
-# Ejecutar la aplicación
 demo.launch()