Create app.py

app.py

@@ -0,0 +1,533 @@
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+from collections import OrderedDict
+import datetime
+from alphacast import Alphacast
+import gradio as gr
+import plotly.graph_objects as go
+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 = {})
+data = df[["country","Date","Real Consumption at constant 2017 national prices (In mil. 2017US$)",
+           "Average annual hours worked by persons engaged",
+           "Capital Stock at constant 2017 national prices (In mil. 2017US$)",
+           "Population (In millions)"]]
+data = data.rename(columns={
+    "Real Consumption at constant 2017 national prices (In mil. 2017US$)": "C",
+    "Average annual hours worked by persons engaged": "L",
+    "Capital Stock at constant 2017 national prices (In mil. 2017US$)": "I",
+    "Population (In millions)": "N"
+})
+paises = ["Argentina", "Brazil", "Chile", "Uruguay", "Colombia"]
+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)
+    
+    # Calcular el ingreso (output) como la suma de Consumo e Inversión
+    Y = C + I  # Ingreso per cápita
+    
+    # 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"
+    rbc_data[pais] = pd.concat((y, n, c), axis=1)
+    rbc_data[pais].columns = ['output', 'labor', 'consumption']
+
+data_2 = df[["country","Date","Real GDP at constant 2017 national prices (In mil. 2017US$)","Real Consumption at constant 2017 national prices (In mil. 2017US$)",
+           "Average annual hours worked by persons engaged",
+           "Capital Stock at constant 2017 national prices (In mil. 2017US$)",
+           "Population (In millions)"]]
+data_2= data_2.rename(columns={"Real GDP at constant 2017 national prices (In mil. 2017US$)":"Y",
+    "Real Consumption at constant 2017 national prices (In mil. 2017US$)": "C",
+    "Average annual hours worked by persons engaged": "L",
+    "Capital Stock at constant 2017 national prices (In mil. 2017US$)": "I",
+    "Population (In millions)": "N"
+})
+
+
+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
+    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"
+    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'], 
+                             mode='lines+markers', name='Output (y)', marker=dict(symbol='circle')))
+    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'], 
+                             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()
+
+
+class SimpleRBC(sm.tsa.statespace.MLEModel):
+
+    parameters = OrderedDict([
+        ('discount_rate', 0.95),
+        ('disutility_labor', 3.),
+        ('depreciation_rate', 0.025),
+        ('capital_share', 0.36),
+        ('technology_shock_persistence', 0.85),
+        ('technology_shock_var', 0.04**2)
+    ])
+
+    def __init__(self, endog, calibrated=None):
+        super(SimpleRBC, self).__init__(
+            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([
+            (param, calibrated[param]) for param in parameters
+            if param in calibrated
+        ])
+        self.idx_calibrated = np.array([
+            param in self.calibrated for param in parameters])
+        self.idx_estimated = ~self.idx_calibrated
+
+        self.k_params = len(self.parameters)
+        self.k_calibrated = len(self.calibrated)
+        self.k_estimated = self.k_params - self.k_calibrated
+
+        self.idx_cap_share = parameters.index('capital_share')
+        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
+    def start_params(self):
+        structural_params = np.array(list(self.parameters.values()))[self.idx_estimated]
+        measurement_variances = [0.1] * 3
+        return np.r_[structural_params, measurement_variances]
+
+    @property
+    def param_names(self):
+        structural_params = np.array(list(self.parameters.keys()))[self.idx_estimated]
+        measurement_variances = ['%s.var' % name for name in self.endog_names]
+        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))
+        B12 = (-depreciation_rate *
+               (1 - capital_share + gamma * capital_share) /
+               (capital_share * (1 - gamma)))
+        B21 = 0
+        B22 = capital_share / (zeta + capital_share*(1 - zeta))
+        B = np.array([[B11, B12], [B21, B22]])
+
+        C1 = depreciation_rate / (capital_share * (1 - gamma))
+        C2 = (zeta * technology_shock_persistence /
+              (zeta + capital_share*(1 - zeta)))
+        C = np.array([[C1], [C2]])
+
+        return A, B, C
+
+    def solve(self, params):
+        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
+        if not k_stable == self.k_predetermined:
+            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:]
+
+        p11 = np.s_[:k, :k]
+        p12 = np.s_[:k, k:]
+        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(
+                    np.eye(k_nonpredetermined) -
+                    technology_shock_persistence / eigvals[p22]
+                )
+            ).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]]))
+
+        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
+        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
+        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):
+        constrained = np.zeros(unconstrained.shape, unconstrained.dtype)
+
+        i = 0
+        for param in self.parameters.keys():
+            if param not in self.calibrated:
+                method = getattr(self, 'transform_%s' % param)
+                constrained[i] = method(unconstrained[i])
+                i += 1
+
+        # Measurement error variances must be positive
+        constrained[self.k_estimated:] = unconstrained[self.k_estimated:]**2
+
+        return constrained
+
+    def untransform_params(self, constrained):
+        unconstrained = np.zeros(constrained.shape, constrained.dtype)
+
+        i = 0
+        for param in self.parameters.keys():
+            if param not in self.calibrated:
+                method = getattr(self, 'transform_%s' % param)
+                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
+
+    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]
+        self['obs_cov', 2, 2] = measurement_variances[2]
+        self['transition'] = transition
+        self['state_cov', 0, 0] = structural_params[self.idx_tech_var]
+
+calibrated = {
+    'discount_rate': 0.95,
+    'disutility_labor': 3.0,
+    'capital_share': 0.36,
+    'depreciation_rate': 0.025,
+    'technology_shock_persistence': 0.85,
+    'technology_shock_var': 0.012**2
+}
+
+
+
+def plot_irfs_plotly(irfs):
+    fig = go.Figure()
+
+    fig.add_trace(go.Scatter(x=list(range(len(irfs['output']))), y=irfs['output'], mode='lines+markers', name='Output'))
+    fig.add_trace(go.Scatter(x=list(range(len(irfs['labor']))), y=irfs['labor'], mode='lines+markers', name='Labor'))
+    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 (%)",
+        legend_title="Variables",
+        template = "plotly_dark"
+    )
+
+    return fig
+
+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, :]
+
+    fig.add_trace(go.Scatter(x=rbc_data.index, y=capital, mode='lines', name='Capital'))
+    fig.add_trace(go.Scatter(x=rbc_data.index, y=shock, mode='lines', name='Technology process'))
+
+    fig.update_layout(
+        title="State Variables over Time",
+        xaxis_title="Time",
+        yaxis_title="Value",
+        legend_title="Variables",
+        template = "plotly_dark"
+    )
+
+
+    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
+    }
+
+    # 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
+
+    # 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
+
+    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]] 
+
+
+
+    var_output = np.var(rbc_data_2[pais]["output"])
+    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")
+
+    with gr.Tab("Ecuaciones del Modelo"):
+        gr.Markdown(r"""
+        ### Ecuaciones del Modelo RBC
+
+        - **FOC estática**:
+        $$ \psi c_t = (1 - \alpha) z_t \left( \frac{k_t}{n_t} \right)^{\alpha} $$
+
+        - **Ecuación de Euler**:
+        $$ \frac{1}{c_t} = \beta E_t \left\{ \frac{1}{c_{t+1}} \left[ \alpha z_{t+1} \left( \frac{k_{t+1}}{n_{t+1}} \right)^{\alpha-1} + (1 - \delta) \right] \right\} $$
+
+        - **Función de producción**:
+        $$ y_t = z_t k_t^{\alpha} n_t^{1 - \alpha} $$
+
+        - **Restricción de recursos agregados**:
+        $$ y_t = c_t + i_t $$
+
+        - **Acumulación de capital**:
+        $$ k_{t+1} = (1 - \delta)k_t + i_t $$
+
+        - **Comercio entre trabajo y ocio**:
+        $$ 1 = l_t + n_t $$
+
+        - **Transición del choque tecnológico**:
+        $$ \log z_t = \rho \log z_{t-1} + \varepsilon_t $$
+        """)
+
+    with gr.Tab("Gráfico del País"):
+        pais_selec_grafico = 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
+    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)
+        shock_variance = gr.Slider(label="Desviación estándar del choque tecnológico", minimum=0.01, maximum=0.05, value=0.012)
+        discount_rate = gr.Number(label="Tasa de descuento (β)", value=0.95)
+        disutility_labor = gr.Number(label="Desutilidad del trabajo", value=3.0)
+        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")
+
+    with gr.Tab("Estadísticas del Modelo"):
+        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()