From b77a6e7188aab1cb5e698b5611ddcc19ac1e5fd4 Mon Sep 17 00:00:00 2001 From: Jesse Grabowski <48652735+jessegrabowski@users.noreply.github.com> Date: Thu, 1 Aug 2024 15:06:34 +0800 Subject: [PATCH] Add docs and examples (#18) * Add v0 docs * Add v0 docs * Add scripts to generate notebook html * Working towards passing tests * All tests pass * Reformat docs * Never divide by zero when computing iterations per second --- .github/workflows/release.yml | 47 + .github/workflows/rtd-link-preview.yml | 16 + .gitignore | 4 + .readthedocs.yaml | 17 + REQUIREMENTS.txt | 3 +- cge_modeling/__init__.py | 4 + cge_modeling/base/cge.py | 27 +- cge_modeling/plotting.py | 37 +- cge_modeling/pytensorf/compile.py | 91 +- cge_modeling/pytensorf/optimize.py | 16 +- cge_modeling/pytensorf/rewrites.py | 1 + cge_modeling/tools/pytensor_tools.py | 2 + conda_envs/cge_test.yml | 2 +- conda_envs/environment_docs.yml | 41 + docs/source/_templates/autosummary/class.rst | 30 + docs/source/api.rst | 9 + docs/source/api/base.rst | 10 + docs/source/api/base/cge.rst | 22 + docs/source/api/base/utilities.rst | 27 + docs/source/conf.py | 201 ++ docs/source/dev/index.rst | 4 + docs/source/examples/data/simple_rbc_data.csv | 7 + .../source/examples/getting_started/rbc.ipynb | 1906 +++++++++++++++++ docs/source/get_started/about.rst | 4 + docs/source/get_started/get_started.rst | 4 + docs/source/get_started/install.rst | 36 + docs/source/index.rst | 31 + docs/source/release/index.rst | 8 + docs/source/user_guide/api_structure.rst | 4 + docs/source/user_guide/cge_intro.rst | 4 + docs/source/user_guide/coords_dims.rst | 4 + docs/source/user_guide/example_model.rst | 4 + docs/source/user_guide/index.rst | 10 + sphinxext/generate_gallery.py | 179 ++ tests/data/unbalanced_sam.csv | 17 + tests/pytensorf/test_compile.py | 16 +- tests/pytensorf/test_optimize.py | 25 +- tests/test_production_functions.py | 5 +- tests/test_pytensorf.py | 3 +- tests/test_rebalance.py | 2 +- 40 files changed, 2754 insertions(+), 126 deletions(-) create mode 100644 .github/workflows/release.yml create mode 100644 .github/workflows/rtd-link-preview.yml create mode 100644 .readthedocs.yaml create mode 100644 conda_envs/environment_docs.yml create mode 100644 docs/source/_templates/autosummary/class.rst create mode 100644 docs/source/api.rst create mode 100644 docs/source/api/base.rst create mode 100644 docs/source/api/base/cge.rst create mode 100644 docs/source/api/base/utilities.rst create mode 100644 docs/source/conf.py create mode 100644 docs/source/dev/index.rst create mode 100644 docs/source/examples/data/simple_rbc_data.csv create mode 100644 docs/source/examples/getting_started/rbc.ipynb create mode 100644 docs/source/get_started/about.rst create mode 100644 docs/source/get_started/get_started.rst create mode 100644 docs/source/get_started/install.rst create mode 100644 docs/source/index.rst create mode 100644 docs/source/release/index.rst create mode 100644 docs/source/user_guide/api_structure.rst create mode 100644 docs/source/user_guide/cge_intro.rst create mode 100644 docs/source/user_guide/coords_dims.rst create mode 100644 docs/source/user_guide/example_model.rst create mode 100644 docs/source/user_guide/index.rst create mode 100644 sphinxext/generate_gallery.py create mode 100644 tests/data/unbalanced_sam.csv diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..ed50777 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,47 @@ +name: release-pipeline + +on: + release: + types: + - created + +jobs: + release-job: + runs-on: ubuntu-latest + env: + PYPI_TOKEN: ${{ secrets.PYPI_TOKEN }} + steps: + - uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332 + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: 3.11 + - name: Install release tooling + run: | + pip install twine wheel + - name: Build package + run: | + python setup.py sdist bdist_wheel + - name: Check version number match + run: | + echo "GITHUB_REF: ${GITHUB_REF}" + # The GITHUB_REF should be something like "refs/tags/v1.2.3" + # Make sure the package version is the same as the tag + grep -Rq "^Version: ${GITHUB_REF:11}$" cge_modeling.egg-info/PKG-INFO + - name: Publish to PyPI + run: | + twine check dist/* + twine upload --repository pypi --username __token__ --password ${PYPI_TOKEN} dist/* + test-install-job: + needs: release-job + runs-on: ubuntu-latest + steps: + - name: Set up Python + uses: actions/setup-python@v5 + with: + python-version: 3.7 + - name: Give PyPI a chance to update the index + run: sleep 240 + - name: Install from PyPI + run: | + pip install cge_modeling==${GITHUB_REF:11} diff --git a/.github/workflows/rtd-link-preview.yml b/.github/workflows/rtd-link-preview.yml new file mode 100644 index 0000000..e9a838d --- /dev/null +++ b/.github/workflows/rtd-link-preview.yml @@ -0,0 +1,16 @@ +name: Read the Docs Pull Request Preview +on: + pull_request_target: + types: + - opened + +permissions: + pull-requests: write + +jobs: + documentation-links: + runs-on: ubuntu-latest + steps: + - uses: readthedocs/actions/preview@v1 + with: + project-slug: "cge_modeling" diff --git a/.gitignore b/.gitignore index e92acd3..98a827a 100644 --- a/.gitignore +++ b/.gitignore @@ -170,3 +170,7 @@ cge_modeling/base/__pycache__/ cge_modeling/pytensorf/__pycache__/ cge_modeling/tools/__pycache__/ tests/utilities/__pycache__/ + +# Locally built docs +docs/build/ +docs/jupyter_execute/ diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..21cacc2 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,17 @@ +version: 2 + +sphinx: + configuration: docs/source/conf.py + +python: + install: + - method: pip + path: . + +conda: + environment: "conda_envs/environment_docs.yml" + +build: + os: "ubuntu-22.04" + tools: + python: "mambaforge-4.10" diff --git a/REQUIREMENTS.txt b/REQUIREMENTS.txt index 9b2bcd6..9b96083 100644 --- a/REQUIREMENTS.txt +++ b/REQUIREMENTS.txt @@ -2,10 +2,9 @@ pytest setuptools numba numpy -sympy +sympy<1.13 scipy pandas -ipython joblib pytensor latextable diff --git a/cge_modeling/__init__.py b/cge_modeling/__init__.py index 7694e04..9557190 100644 --- a/cge_modeling/__init__.py +++ b/cge_modeling/__init__.py @@ -2,6 +2,10 @@ from cge_modeling.base.primitives import Equation, Parameter, Variable from cge_modeling.plotting import plot_kateplot, plot_lines from cge_modeling.tools.output_tools import display_info_as_table, latex_print_equations +from cge_modeling.pytensorf.rewrites import prod_to_no_zero_prod # noqa: F401 + + +__version__ = "0.0.1" __all__ = [ "CGEModel", diff --git a/cge_modeling/base/cge.py b/cge_modeling/base/cge.py index faf24e3..9277a13 100644 --- a/cge_modeling/base/cge.py +++ b/cge_modeling/base/cge.py @@ -267,7 +267,6 @@ def __init__( self._compile( backend=backend, mode=mode, - inverse_method=inverse_method, functions_to_compile=compile, use_scan_euler=use_scan_euler, ) @@ -738,15 +737,12 @@ def _compile_pytensor( self, mode, functions_to_compile: list[CompiledFunctions], - inverse_method: Literal["solve", "pinv", "svd"] = "solve", sparse: bool = False, use_scan_euler: bool = True, ): _log.info("Compiling model equations into pytensor graph") - (variables, parameters), (system, jac, jac_inv, B) = ( - compile_cge_model_to_pytensor( - self, inverse_method=inverse_method, sparse=sparse - ) + (variables, parameters), (system, jac, B) = compile_cge_model_to_pytensor( + self, sparse=sparse ) inputs = variables + parameters text_mode = "C" if mode is None else mode @@ -807,6 +803,7 @@ def f_jac(*args, **kwargs): pt.concatenate([pt.atleast_1d(eq).ravel() for eq in grad]), self.n_variables, ) + # View grad as the function, compute jvp instead (hessp) # _log.info("Computing SSE Jacobian") # hessp, p = make_jacobian(grad, variables, return_jvp=True) @@ -863,7 +860,7 @@ def __pytensor_euler_helper(*args, n_steps=100, **kwargs): ) self.__last_n_steps = n_steps self.__compiled_f_euler = compile_euler_approximation_function( - jac_inv, + jac, B, variables, parameters, @@ -881,10 +878,9 @@ def __pytensor_euler_helper(*args, n_steps=100, **kwargs): f_step = jax_euler_step(system, variables, parameters) else: inputs, outputs = pytensor_euler_step( - system, jac_inv, B, variables, parameters + system, jac, B, variables, parameters ) # inputs = get_required_inputs(outputs) - print(inputs, outputs) f_step = pytensor.function(inputs, outputs, mode=mode) f_step.trust_inputs = True self.f_step = f_step @@ -928,7 +924,10 @@ def f_euler( n_steps=n_steps, ) - current_variable_vals, current_parameter_vals = current_step + current_variable_vals = current_step[: len(self.variable_names)] + current_parameter_vals = current_step[ + len(self.variable_names) : + ] # current_variable_vals = flat_current_step[ # : len(self.variable_names) @@ -953,7 +952,8 @@ def f_euler( elapsed = end - start unit = "s/it" if elapsed < 1: - elapsed = 1 / elapsed + # if elapsed is exactly zero just put a big number + elapsed = 1 / elapsed if elapsed != 0 else 1000000 unit = "it/s" progress.comment = desc.format(elapsed, unit, rmse) @@ -980,7 +980,6 @@ def _compile( self, backend: Literal["pytensor", "numba"] | None = "pytensor", mode=None, - inverse_method: Literal["solve", "pinv", "svd"] = "solve", functions_to_compile: list[CompiledFunctions] = "all", use_scan_euler: bool = True, ): @@ -993,9 +992,6 @@ def _compile( The backend to compile to. One of 'pytensor' or 'numba'. mode: str Pytensor compile mode. Ignored if mode is not 'pytensor'. - inverse_method: str - The method to use to compute the inverse of the Jacobian. One of "solve", "pinv", or "svd". - Defaults to "solve". Ignored if mode is not 'pytensor' functions_to_compile: list of str A list of functions to compile. Valid choices are 'root', 'minimum', 'euler', or 'all'. Defaults to 'all'. use_scan_euler: bool @@ -1035,7 +1031,6 @@ def _compile( elif backend == "pytensor": self._compile_pytensor( mode=mode, - inverse_method=inverse_method, functions_to_compile=functions_to_compile, use_scan_euler=use_scan_euler, sparse=self.sparse, diff --git a/cge_modeling/plotting.py b/cge_modeling/plotting.py index 5050278..c3554ef 100644 --- a/cge_modeling/plotting.py +++ b/cge_modeling/plotting.py @@ -3,7 +3,6 @@ import arviz as az import matplotlib.pyplot as plt import numpy as np -import pandas as pd from matplotlib.colors import Colormap from matplotlib.gridspec import GridSpec from matplotlib.ticker import PercentFormatter @@ -80,7 +79,7 @@ def plot_lines( The number of columns in the grid of plots. var_names: list of str, optional Name of the variables to plot. If None, all variables will be plotted. - initial_values: dict[str, np.ndarray], optional + initial_values: dict[str, np.array], optional The initial values of the variables in the model; those passed to the simulate method. If None, the initial values will be taken from the InferenceData object. plot_euler: bool, default True @@ -169,12 +168,13 @@ def f_cmap(*args): t0 = np.zeros_like(initial_value) T = np.ones_like(final_value) + if plot_euler: T = T * idata["euler"].variables.step.max().item() axis.scatter( t0, - final_value, + initial_value, marker="*", color="tab:green", zorder=10, @@ -198,7 +198,7 @@ def f_cmap(*args): def plot_kateplot( idata: az.InferenceData, - initial_values: dict[str, np.ndarray], + initial_values: dict[str, np.array], mod: CGEModel, var_names: str | list[str], shock_name: str | None = None, @@ -213,7 +213,7 @@ def plot_kateplot( ---------- idata: az.InferenceData The InferenceData object returned by the model's simulate method. - initial_values: dict[str, np.ndarray] + initial_values: dict[str, np.array] The initial values of the variables in the model; those passed to the simulate method. mod: CGEModel The model object. @@ -347,17 +347,21 @@ def _plot_one_bar( ] = "pct_change", legend=True, threshhold=1e-6, + labelsize=12, + xlabel_rotation=0, ): try: data = data.to_dataframe().droplevel(level=drop_vars, axis=0) initial_data = initial_data.to_dataframe().droplevel(level=drop_vars, axis=0) except ValueError: - data = pd.DataFrame([data.to_dict()]).loc[:, ["data", "name"]].set_index("name") + data = data.to_dataarray().to_dataframe(name="data") + data.index.name = "name" initial_data = ( - pd.DataFrame([initial_data.to_dict()]) - .loc[:, ["data", "name"]] - .set_index("name") + initial_data.to_dataarray() + .to_dataframe(name="data") + .droplevel(level=drop_vars, axis=0) ) + if "step" in data.columns: data = data.drop(columns=["step"]) if "step" in initial_data.columns: @@ -374,11 +378,9 @@ def _plot_one_bar( to_plot = _compute_bar_data(data, initial_data, metric, threshhold) if orientation == "v": - # to_plot.plot.bar(ax=ax, legend='', facecolor='none', edgecolor="black") to_plot.plot.bar(ax=ax, legend=legend) ax.axhline(0, color="black", lw=2.0) else: - # to_plot.plot.barh(ax=ax, legend='', facecolor='none', edgecolor="black") to_plot.plot.barh(ax=ax, legend=legend) ax.axvline(0, color="black", lw=2.0) @@ -388,7 +390,8 @@ def _plot_one_bar( ax.yaxis.set_major_formatter(ticker) elif orientation == "h": ax.xaxis.set_major_formatter(ticker) - ax.tick_params(which="both", labelsize=6) + ax.tick_params(which="both", labelsize=labelsize) + ax.tick_params(which="major", axis="x", rotation=xlabel_rotation) return ax @@ -406,6 +409,9 @@ def plot_bar( "pct_change", "change", "abs_change", "final", "initial", "both" ] = "pct_change", threshhold=1e-6, + labelsize=12, + xlabel_rotation=0, + legend=True, **figure_kwargs, ): data = None @@ -471,7 +477,10 @@ def plot_bar( drop_vars=drop_vars, orientation=orientation, metric=metric, + legend=legend, threshhold=threshhold, + labelsize=labelsize, + xlabel_rotation=xlabel_rotation, ) axis.set(title=var) if metric == "final_initial": @@ -497,7 +506,6 @@ def plot_bar( raise ValueError(msg) fig, ax = plt.subplots(dpi=dpi, figsize=figsize, **figure_kwargs) - # labels = [label for label in [make_labels(var_name, mod) for var_name in var_names]] _ = _plot_one_bar( data, initial_values, @@ -506,6 +514,9 @@ def plot_bar( drop_vars=drop_vars, orientation=orientation, metric=metric, + legend=legend, + labelsize=labelsize, + xlabel_rotation=xlabel_rotation, ) return fig diff --git a/cge_modeling/pytensorf/compile.py b/cge_modeling/pytensorf/compile.py index 3f098e6..fd33f41 100644 --- a/cge_modeling/pytensorf/compile.py +++ b/cge_modeling/pytensorf/compile.py @@ -1,5 +1,5 @@ import logging -from typing import Literal, cast +from typing import cast import numpy as np import pytensor @@ -75,11 +75,8 @@ def pytensor_objects_from_CGEModel(cge_model): def compile_cge_model_to_pytensor( cge_model, - inverse_method: Literal["solve", "pinv", "svd"] = "solve", sparse=False, -) -> tuple[ - tuple[list, list], tuple[pt.TensorLike, pt.TensorLike, pt.TensorLike, pt.TensorLike] -]: +) -> tuple[tuple[list, list], tuple[pt.TensorLike, pt.TensorLike, pt.TensorLike]]: """ Compile a CGE model to a PyTensor function. @@ -87,9 +84,7 @@ def compile_cge_model_to_pytensor( ---------- cge_model: CGEModel The CGE model object to compile - inverse_method: str, optional - The method to use to compute the inverse of the Jacobian. One of "solve", "pinv", or "svd". Defaults to "solve". - Note that if svd is chosen, gradients for autodiff will not be available. + sparse: bool, optional Whether to use sparse matrices for the Jacobian and its inverse. Defaults to False. @@ -113,9 +108,6 @@ def compile_cge_model_to_pytensor( A pytensor matrix representing the Jacobian of the system of equations. The shape of the matrix is (n_eq, n_eq), where n_eq is the number of *unrolled* equations in the system of equations. - jac_inv: pytensor.tensor.TensorVariable - A pytensor matrix representing the inverse of the Jacobian of the system of equations. - B: pytensor.tensor.TensorVariable A pytensor matrix representing the Jacobian of the system of equations with respect to the parameters. The shape of the matrix is (n_eq, n_params), where n_eq is the number of *unrolled* equations in the system @@ -129,7 +121,7 @@ def compile_cge_model_to_pytensor( ) = pytensor_objects_from_CGEModel(cge_model) cache, unpacked_cache = sympy_to_pytensor_caches - n_eq = flat_equations.type.shape[0] + # n_eq = flat_equations.type.shape[0] inputs = (variables, parameters) if not all([x in cache.values() for x in inputs[0] + inputs[1]]): @@ -183,32 +175,29 @@ def compile_cge_model_to_pytensor( jac.name = "jacobian" B.name = "B" - _log.info("Inverting jacobian") - if inverse_method == "pinv": - jac_inv = pt.linalg.pinv(jac) - elif inverse_method == "solve": - jac_inv = pt.linalg.solve(jac, pt.eye(jac.shape[0]), check_finite=False) - elif inverse_method == "svd": - U, S, V = pt.linalg.svd(jac) - S_inv = pt.where(pt.gt(S, 1e-8), 1 / S, 0) - jac_inv = V @ pt.diag(S_inv) @ U.T - else: - raise ValueError( - f'Invalid inverse method {inverse_method}, expected one of "pinv", "solve", "svd"' - ) - - jac_inv = pt.specify_shape(jac_inv, (n_eq, n_eq)) - jac_inv.name = "inverse_jacobian" - - outputs = (flat_equations, jac, jac_inv, B) + # _log.info("Inverting jacobian") + # if inverse_method == "pinv": + # jac_inv = pt.linalg.pinv(jac) + # elif inverse_method == "solve": + # jac_inv = pt.linalg.solve(jac, pt.eye(jac.shape[0]), check_finite=False) + # elif inverse_method == "svd": + # U, S, V = pt.linalg.svd(jac) + # S_inv = pt.where(pt.gt(S, 1e-8), 1 / S, 0) + # jac_inv = V @ pt.diag(S_inv) @ U.T + # else: + # raise ValueError( + # f'Invalid inverse method {inverse_method}, expected one of "pinv", "solve", "svd"' + # ) + + # jac_inv = pt.specify_shape(jac_inv, (n_eq, n_eq)) + # jac_inv.name = "inverse_jacobian" + + outputs = (flat_equations, jac, B) return inputs, outputs -def compile_cge_model_to_pytensor_Op( - cge_model, - inverse_method: Literal["solve", "pinv", "svd"] = "solve", -) -> tuple[pt.Op, pt.Op, pt.Op]: +def compile_cge_model_to_pytensor_Op(cge_model) -> tuple[pt.Op, pt.Op]: """ Compile a CGE model to a PyTensor Ops. @@ -216,9 +205,6 @@ def compile_cge_model_to_pytensor_Op( ---------- cge_model: CGEModel The CGE model object to compile - inverse_method: str, optional - The method to use to compute the inverse of the Jacobian. One of "solve", "pinv", or "svd". Defaults to "solve". - Note that if svd is chosen, gradients for autodiff will not be available. Returns ------- @@ -230,11 +216,6 @@ def compile_cge_model_to_pytensor_Op( A PyTensor Op representing computation of the Jacobian of model equations given model variables and parameters as inputs - f_jac_inv: pt.Op - A PyTensor Op representing computation of the inverse of the Jacobian of model equations given model - variables and parameters as inputs - - Notes ----- In general, it shouldn't be necessary to use this function. Most downstream computation can directly use the graph @@ -242,18 +223,15 @@ def compile_cge_model_to_pytensor_Op( need to be "anonymous". This function exists to facilitate that use case. """ - (variables, parameters), outputs = compile_cge_model_to_pytensor( - cge_model, inverse_method=inverse_method - ) + (variables, parameters), outputs = compile_cge_model_to_pytensor(cge_model) - flat_equations, jac, jac_inv, _ = outputs + flat_equations, jac, B = outputs inputs = list(variables) + list(parameters) f_model = OpFromGraph(inputs, outputs=[flat_equations], inline=True) f_jac = OpFromGraph(inputs, outputs=[jac], inline=True) - f_jac_inv = OpFromGraph(inputs, outputs=[jac_inv], inline=True) - return f_model, f_jac, f_jac_inv + return f_model, f_jac def flat_tensor_to_ragged_list(tensor, shapes): @@ -270,7 +248,7 @@ def flat_tensor_to_ragged_list(tensor, shapes): def euler_approximation( - A_inv: pt.TensorVariable, + A: pt.TensorVariable, B: pt.TensorVariable, variables: list[pt.Variable], parameters: list[pt.Variable], @@ -287,7 +265,7 @@ def euler_approximation( Parameters ---------- - A_inv: pytensor.tensor.TensorVariable + A: pytensor.tensor.TensorVariable Inverse of the Jacobian of the system of equations with respect to the variables B: pytensor.tensor.TensorVariable Jacobian of the system of equations with respect to the parameters @@ -323,7 +301,7 @@ def euler_approximation( Bv = B @ pt.atleast_1d(step_size) Bv.name = "Bv" - step = -A_inv @ Bv + step = -pt.linalg.solve(A, Bv, assume_a="gen", check_finite=False) f_step = OpFromGraph(x_list + theta_list + [step_size], [step], inline=True) @@ -363,7 +341,7 @@ def step_func(*args): return theta_final, final_result -def pytensor_euler_step(system, A_inv, B, variables, parameters): +def pytensor_euler_step(system, A, B, variables, parameters): x_list = at_least_list(variables) x_shapes = [x.type.shape for x in x_list] @@ -386,7 +364,7 @@ def pytensor_euler_step(system, A_inv, B, variables, parameters): v = flatten_equations(step_size) Bv = B @ v - step = -A_inv @ Bv + step = pt.linalg.solve(-A, Bv) step.name = "euler_step" delta_x = flat_tensor_to_ragged_list(step, x_shapes) @@ -395,7 +373,8 @@ def pytensor_euler_step(system, A_inv, B, variables, parameters): theta_next = [theta + dtheta for theta, dtheta in zip(theta_list, step_size)] inputs = x_list + theta_list + theta0 + theta_final + [n_steps] - outputs = [pt.stack(x_next, axis=-1), pt.stack(theta_next, axis=-1)] + outputs = x_next + theta_next + return inputs, outputs @@ -507,10 +486,10 @@ def step(**kwargs): def compile_euler_approximation_function( - A_inv, B, variables, parameters, n_steps=100, mode=None + A, B, variables, parameters, n_steps=100, mode=None ): theta_final, result = euler_approximation( - A_inv, B, variables, parameters, n_steps=n_steps + A, B, variables, parameters, n_steps=n_steps ) theta_final.name = "theta_final" inputs = variables + parameters + [theta_final] diff --git a/cge_modeling/pytensorf/optimize.py b/cge_modeling/pytensorf/optimize.py index c0240b5..6cb5cd6 100644 --- a/cge_modeling/pytensorf/optimize.py +++ b/cge_modeling/pytensorf/optimize.py @@ -18,13 +18,13 @@ def eval_func_maybe_exog(X, exog, f, has_exog): return out -def _newton_step(flat_X, exog, F, J_inv, step_size, has_exog, shapes): +def _newton_step(flat_X, exog, F, J, step_size, has_exog, shapes): X = flat_tensor_to_ragged_list(flat_X, shapes) F_X = eval_func_maybe_exog(X, exog, F, has_exog) - J_inv_X = eval_func_maybe_exog(X, exog, J_inv, has_exog) + J_X = eval_func_maybe_exog(X, exog, J, has_exog) flat_F_X = flatten_equations(F_X) - flat_new_X = flat_X - step_size * J_inv_X @ flat_F_X + flat_new_X = flat_X - step_size * pt.linalg.solve(J_X, flat_F_X) new_X = flat_tensor_to_ragged_list(flat_new_X, [x.type.shape for x in X]) flat_F_new_X = eval_func_maybe_exog(new_X, exog, F, has_exog) @@ -72,7 +72,7 @@ def backtrack_if_not_decreasing(is_decreasing, X, new_X): return pytensor.ifelse(is_decreasing, new_X, X) -def scan_body(*args, F, J_inv, initial_step_size, tol, has_exog, n_endog, n_exog): +def scan_body(*args, F, J, initial_step_size, tol, has_exog, n_endog, n_exog): X = args[:n_endog] converged, step_size, n_steps = args[n_endog : n_endog + 3] exog = args[-n_exog:] @@ -83,7 +83,7 @@ def scan_body(*args, F, J_inv, initial_step_size, tol, has_exog, n_endog, n_exog out = pytensor.ifelse( converged, no_op(flat_X), - _newton_step(flat_X, exog, F, J_inv, step_size, has_exog, shapes), + _newton_step(flat_X, exog, F, J, step_size, has_exog, shapes), ) flat_X, flat_new_X, flat_F_X, flat_F_new_X = (out[i] for i in range(4)) @@ -116,7 +116,7 @@ def _process_root_data(data: dict[str, np.ndarray] | None) -> list[pt.TensorLike def root( f: pt.Op, - f_jac_inv: pt.Op, + f_jac: pt.Op, initial_data: dict[str, np.ndarray | float], parameters: dict[str, np.ndarray | float] | None = None, step_size: int = 1, @@ -133,7 +133,7 @@ def root( f: pytensor Op A pytensor Op, typically created by CGEModel.compile_equations_to_pytensor, that takes a ragged list of variables and parameters as input and returns a vector of residuls as output. - f_jac_inv: pytensor Op + f_jac: pytensor Op A pytensor Op, typically created by CGEModel.compile_equations_to_pytensor, that takes a ragged list of variables and parameters as input and returns the inverse of the Jacobian of the system of equations as output. initial_data: dict[str, np.ndarray] @@ -179,7 +179,7 @@ def root( root_func = ft.partial( scan_body, F=f, - J_inv=f_jac_inv, + J=f_jac, initial_step_size=init_step_size, tol=tol, has_exog=has_exog, diff --git a/cge_modeling/pytensorf/rewrites.py b/cge_modeling/pytensorf/rewrites.py index 3df14dd..2a13cc7 100644 --- a/cge_modeling/pytensorf/rewrites.py +++ b/cge_modeling/pytensorf/rewrites.py @@ -13,6 +13,7 @@ def prod_to_no_zero_prod(fgraph, node): Note that this only affects product reduction Ops, it's not the same as a multiplication. """ if isinstance(node.op, Prod) and not node.op.no_zeros_in_input: + print("hi :)") (x,) = node.inputs new_op = Prod( dtype=node.op.dtype, acc_dtype=node.op.dtype, no_zeros_in_input=True diff --git a/cge_modeling/tools/pytensor_tools.py b/cge_modeling/tools/pytensor_tools.py index 573019c..ee71032 100644 --- a/cge_modeling/tools/pytensor_tools.py +++ b/cge_modeling/tools/pytensor_tools.py @@ -232,6 +232,7 @@ def make_jacobian( n_vars = int(np.sum([np.prod(var.type.shape) for var in x])) rewrite_pregrad(system) + if return_jvp: if p is None: p = [var.clone(name=f"{var.name}_point") for var in x] @@ -239,6 +240,7 @@ def make_jacobian( return jvp, p column_list = pytensor.gradient.jacobian(system, x) + jac = pt.concatenate( [pt.atleast_2d(x).reshape((n_eq, -1)) for x in column_list], axis=-1 ) diff --git a/conda_envs/cge_test.yml b/conda_envs/cge_test.yml index d008931..9b203a6 100644 --- a/conda_envs/cge_test.yml +++ b/conda_envs/cge_test.yml @@ -6,7 +6,7 @@ dependencies: - pip - numpy - scipy - - sympy + - sympy<1.13 - pandas - numba - IPython diff --git a/conda_envs/environment_docs.yml b/conda_envs/environment_docs.yml new file mode 100644 index 0000000..868ed43 --- /dev/null +++ b/conda_envs/environment_docs.yml @@ -0,0 +1,41 @@ +name: geconpy-docs +channels: + - conda-forge +dependencies: + # Base dependencies + - pip + - numpy + - scipy + - sympy<1.13 + - pandas + - numba + - IPython + - pymc + - pytensor + - tqdm + - numba-progress + - fastprogress + - matplotlib + - joblib + + - pip: + - latextable + - texttable + - sympytensor + - squarify + + # Extra dependencies for docs build + - ipython + - jupyter-sphinx + - myst-nb + - numpydoc + - pre-commit + - sphinx>=5 + - sphinx-copybutton + - sphinx-design + - sphinx-notfound-page + - sphinx-sitemap + - sphinx-codeautolink + - sphinxcontrib-bibtex + - pydata-sphinx-theme + - watermark diff --git a/docs/source/_templates/autosummary/class.rst b/docs/source/_templates/autosummary/class.rst new file mode 100644 index 0000000..ad5436f --- /dev/null +++ b/docs/source/_templates/autosummary/class.rst @@ -0,0 +1,30 @@ +{{ fullname | escape | underline}} + +.. currentmodule:: {{ module }} + +.. autoclass:: {{ objname }} + + {% block methods %} + {% if methods %} + + .. rubric:: Methods + + .. autosummary:: + :toctree: classmethods + + {% for item in methods %} + {{ objname }}.{{ item }} + {%- endfor %} + {% endif %} + {% endblock %} + + {% block attributes %} + {% if attributes %} + .. rubric:: Attributes + + .. autosummary:: + {% for item in attributes %} + ~{{ name }}.{{ item }} + {%- endfor %} + {% endif %} + {% endblock %} diff --git a/docs/source/api.rst b/docs/source/api.rst new file mode 100644 index 0000000..6d2ac86 --- /dev/null +++ b/docs/source/api.rst @@ -0,0 +1,9 @@ +.. _api: + +API +=== + +.. toctree:: + :maxdepth: 1 + + api/base diff --git a/docs/source/api/base.rst b/docs/source/api/base.rst new file mode 100644 index 0000000..6423739 --- /dev/null +++ b/docs/source/api/base.rst @@ -0,0 +1,10 @@ +CGE Modeling +************ + +.. automodule:: cge_modeling.base + +.. toctree:: + :maxdepth: 1 + + base/cge + base/utilities diff --git a/docs/source/api/base/cge.rst b/docs/source/api/base/cge.rst new file mode 100644 index 0000000..104e0af --- /dev/null +++ b/docs/source/api/base/cge.rst @@ -0,0 +1,22 @@ +CGE +--- + +.. currentmodule:: cge_modeling.base.cge + +.. autosummary:: + :toctree: generated/ + + CGEModel + + +Model Components +---------------- + +.. currentmodule:: cge_modeling.base.primitives + +.. autosummary:: + :toctree: generated/ + + Parameter + Variable + Equation diff --git a/docs/source/api/base/utilities.rst b/docs/source/api/base/utilities.rst new file mode 100644 index 0000000..fbcdac3 --- /dev/null +++ b/docs/source/api/base/utilities.rst @@ -0,0 +1,27 @@ +Utility Functions for CGE Models +******************************** + +.. currentmodule:: cge_modeling.base.utilities + +.. autosummary:: + :toctree: generated/ + + unpack_equation_strings + ensure_input_is_sequence + infer_object_shape_from_coords + make_flat_array_return_mask + flat_array_to_variable_dict + variable_dict_to_flat_array + wrap_fixed_values + wrap_pytensor_func_for_scipy + flat_mask_from_param_names + +Optimization Wrapper +******************** + +.. currentmodule:: cge_modeling.base.utilities + +.. autosummary:: + :toctree: generated/ + + CostFuncWrapper diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..2441a82 --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,201 @@ +import os +import sys + +sys.path.insert(0, os.path.abspath(os.path.join("..", ".."))) +sys.path.insert(0, os.path.abspath(os.path.join("..", "..", "sphinxext"))) + +import cge_modeling + +# -- Project information ----------------------------------------------------- +project = "cge_modeling" +copyright = "2023-2024, Jesse Grabowski" +language = "en" +html_baseurl = "github.com/jessegrabowski/cge_modeling" + +docnames = [] + +version = cge_modeling.__version__ +on_readthedocs = os.environ.get("READTHEDOCS", False) +rtd_version = os.environ.get("READTHEDOCS_VERSION", "") +if on_readthedocs: + if rtd_version.lower() == "stable": + version = cge_modeling.__version__.split("+")[0] + elif rtd_version.lower() == "latest": + version = "dev" + else: + version = rtd_version +else: + rtd_version = "local" +# The full version, including alpha/beta/rc tags. +release = version + +# -- General configuration --------------------------------------------------- +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones. +extensions = [ + "pydata_sphinx_theme", + "sphinx.ext.intersphinx", + "sphinx.ext.mathjax", + "myst_nb", + "sphinx_design", + "sphinx_copybutton", + "sphinxcontrib.bibtex", + "sphinx_codeautolink", + "generate_gallery", + "sphinx.ext.autodoc", + "numpydoc", + "sphinx.ext.doctest", + "sphinx.ext.extlinks", + "sphinx.ext.todo", + "sphinx.ext.autosectionlabel", + "sphinx.ext.autosummary", + "matplotlib.sphinxext.plot_directive", + "IPython.sphinxext.ipython_console_highlighting", + "IPython.sphinxext.ipython_directive", +] + + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = [ + "_build", + "**.ipynb_checkpoints", + "*/autosummary/*.rst", + "Thumbs.db", + ".DS_Store", +] + +# -- Options for HTML output ------------------------------------------------- +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. + +html_theme = "pydata_sphinx_theme" +html_title = project +html_short_title = project +html_last_updated_fmt = "" + +rtd_version = os.environ.get("READTHEDOCS_VERSION", "") +sitemap_url_scheme = f"{{lang}}{rtd_version}/{{link}}" +html_theme_options = { + "secondary_sidebar_items": ["page-toc", "edit-this-page", "sourcelink"], + "navbar_start": ["navbar-logo"], + # "article_header_end": ["nb-badges"], + "show_prev_next": True, + # "article_footer_items": ["rendered_citation.html"], +} +version = version if "." in rtd_version else "main" +# doi_code = os.environ.get("DOI_READTHEDOCS", "10.5281/zenodo.5654871") +html_context = { + "github_url": "https://github.com", + "github_user": "jessegrabowski", + "github_repo": "cge_modeling", + "github_version": version, + "doc_path": "docs/", + # "sandbox_repo": f"pymc-devs/pymc-sandbox/{version}", + # "doi_url": f"https://doi.org/{doi_code}", + # "doi_code": doi_code, + "default_mode": "dark", +} + + +# html_favicon = "../_static/PyMC.ico" +# html_logo = "../_static/PyMC.png" +html_title = "cge_modeling: CGE Modeling in Python" +html_sidebars = {"**": ["sidebar-nav-bs.html", "searchbox.html"]} + +# ----Miscellaneous Config------------------------------ +# Add any paths that contain templates here, relative to this directory. +templates_path = ["_templates"] + +# The suffix of source filenames. +source_suffix = { + ".rst": "restructuredtext", + ".ipynb": "myst-nb", + ".myst": "myst-nb", +} + +# The master toctree document. +master_doc = "index" + +# Don't auto-generate summary for class members. +autosummary_generate = True +autodoc_typehints = "none" +autoclass_content = "class" +remove_from_toctrees = ["**/classmethods/*"] + +numpydoc_show_class_members = False +numpydoc_xref_param_type = True +numpydoc_xref_ignore = { + "of", + "or", + "optional", + "default", + "numeric", + "type", + "scalar", + "1D", + "2D", + "3D", + "nD", + "array", + "instance", + "M", + "N", +} + +# -- MyST config ------------------------------------------------- +myst_enable_extensions = [ + "colon_fence", + "deflist", + "dollarmath", + "amsmath", + "substitution", +] +myst_dmath_double_inline = True + +myst_substitutions = { + "pip_dependencies": "{{ extra_dependencies }}", + "conda_dependencies": "{{ extra_dependencies }}", + "extra_install_notes": "", +} + +nb_execution_mode = "off" +nbsphinx_execute = "never" +nbsphinx_allow_errors = True + + +# -- Bibtex config ------------------------------------------------- +bibtex_bibfiles = ["references.bib"] +bibtex_default_style = "unsrt" +bibtex_reference_style = "author_year" + +# -- ABlog config ------------------------------------------------- +# blog_baseurl = "https://docs.pymc.io/projects/examples/en/latest/" +# blog_title = "PyMC Examples" +# blog_path = "blog" +# blog_authors = { +# "contributors": ("PyMC Contributors", "https://docs.pymc.io"), +# } +# blog_default_author = "contributors" +# post_show_prev_next = False +# fontawesome_included = True + + +# -- Intersphinx Mapping ------------------------------------------------- +intersphinx_mapping = { + "arviz": ("https://python.arviz.org/en/latest/", None), + "pytensor": ("https://pytensor.readthedocs.io/en/latest/", None), + "pmx": ("https://www.pymc.io/projects/experimental/en/latest", None), + "numpy": ("https://numpy.org/doc/stable/", None), + "myst": ("https://myst-parser.readthedocs.io/en/latest", None), + "myst-nb": ("https://myst-nb.readthedocs.io/en/latest/", None), + "python": ("https://docs.python.org/3/", None), + "scipy": ("https://docs.scipy.org/doc/scipy/", None), + "xarray": ("https://docs.xarray.dev/en/stable/", None), +} + +# OpenGraph config +# use default readthedocs integration aka no config here + +# codeautolink_autodoc_inject = False +# codeautolink_concat_default = True diff --git a/docs/source/dev/index.rst b/docs/source/dev/index.rst new file mode 100644 index 0000000..2ba9a43 --- /dev/null +++ b/docs/source/dev/index.rst @@ -0,0 +1,4 @@ +Contributing to CGE Modeling +============================ + +WRITEME diff --git a/docs/source/examples/data/simple_rbc_data.csv b/docs/source/examples/data/simple_rbc_data.csv new file mode 100644 index 0000000..c556cae --- /dev/null +++ b/docs/source/examples/data/simple_rbc_data.csv @@ -0,0 +1,7 @@ +,,Factor,Factor,Institution,Production,Activities +,,Labor,Capital,Household,Firm,Firm +Factor,Labor,,,,,7000 +Factor,Capital,,,,,3000 +Institution,Household,7000,3000,,, +Production,Firm,,,10000,, +Activities,Firm,,,,10000, diff --git a/docs/source/examples/getting_started/rbc.ipynb b/docs/source/examples/getting_started/rbc.ipynb new file mode 100644 index 0000000..1813875 --- /dev/null +++ b/docs/source/examples/getting_started/rbc.ipynb @@ -0,0 +1,1906 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "836ca90d", + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "\n", + "sys.path.append(\"../..\")\n", + "from cge_modeling import Variable, Parameter, Equation, CGEModel\n", + "from cge_modeling import plotting as cgp\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "a3e1e660", + "metadata": {}, + "source": [ + "# Modeling with `cge_modeling`\n", + "\n", + "A CGE model is comprised of three components:\n", + "\n", + "1. Variables: symbolic objects that represent model quantities that will vary endogenously in your model.\n", + "2. Parameters: symbolic objects that represent model quantities that will vary exogenously in your model (or not at all!)\n", + "3. Equations: A mathematical description of your model economy.\n", + "\n", + "To create a model, one first must write down all the variables and parameters that will go into the model." + ] + }, + { + "cell_type": "markdown", + "id": "a8b26908", + "metadata": {}, + "source": [ + "## Model Setup\n", + "\n", + "In this first simple model, we consider an economy with a single household and a single firm. The household has fixed endowments of labor and capital, which it sells to the firm for wages and rents, respectively. The firm uses these to produce a single consumption good, which it then sells back to the household. There is no government and no investment. The structure of the economy is shown in the following graph:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "b6781767", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Household\n", + "\n", + "Household\n", + "\n", + "\n", + "\n", + "K_s\n", + "\n", + "K_s\n", + "\n", + "\n", + "\n", + "Household->K_s\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L_s\n", + "\n", + "L_s\n", + "\n", + "\n", + "\n", + "Household->L_s\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "C\n", + "\n", + "C\n", + "\n", + "\n", + "\n", + "Household->C\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Capital Market\n", + "\n", + "Capital Market\n", + "\n", + "\n", + "\n", + "K_s->Capital Market\n", + "\n", + "\n", + "r\n", + "\n", + "\n", + "\n", + "Labor Market\n", + "\n", + "Labor Market\n", + "\n", + "\n", + "\n", + "L_s->Labor Market\n", + "\n", + "\n", + "w\n", + "\n", + "\n", + "\n", + "Goods Market\n", + "\n", + "Goods Market\n", + "\n", + "\n", + "\n", + "C->Goods Market\n", + "\n", + "\n", + "P\n", + "\n", + "\n", + "\n", + "Firm\n", + "\n", + "Firm\n", + "\n", + "\n", + "\n", + "Y\n", + "\n", + "Y\n", + "\n", + "\n", + "\n", + "Firm->Y\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "K_d\n", + "\n", + "K_d\n", + "\n", + "\n", + "\n", + "Firm->K_d\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "L_d\n", + "\n", + "L_d\n", + "\n", + "\n", + "\n", + "Firm->L_d\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "Y->Goods Market\n", + "\n", + "\n", + "P\n", + "\n", + "\n", + "\n", + "K_d->Capital Market\n", + "\n", + "\n", + "r\n", + "\n", + "\n", + "\n", + "L_d->Labor Market\n", + "\n", + "\n", + "w\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import graphviz as gr\n", + "\n", + "\n", + "def draw_graph(edge_list, node_props=None, edge_props=None, graph_direction=\"UD\"):\n", + " \"\"\"Utility to draw a causal (directed) graph\"\"\"\n", + " g = gr.Digraph(\n", + " graph_attr={\"rankdir\": graph_direction, \"ratio\": \"0.25\"},\n", + " engine=\"neato\",\n", + " )\n", + "\n", + " edge_props = {} if edge_props is None else edge_props\n", + " for e in edge_list:\n", + " props = edge_props[e] if e in edge_props else {}\n", + " g.edge(e[0], e[1], **props)\n", + "\n", + " if node_props is not None:\n", + " for name, props in node_props.items():\n", + " g.node(name=name, **props)\n", + " return g\n", + "\n", + "\n", + "nodes = [\"K\", \"L\", \"Y\", \"C\", \"Household\", \"Firm\"]\n", + "edges = [\n", + " (\"Household\", \"K_s\"),\n", + " (\"Household\", \"L_s\"),\n", + " (\"Household\", \"C\"),\n", + " (\"Firm\", \"Y\"),\n", + " (\"Firm\", \"K_d\"),\n", + " (\"Firm\", \"L_d\"),\n", + " (\"K_d\", \"Capital Market\"),\n", + " (\"L_d\", \"Labor Market\"),\n", + " (\"K_s\", \"Capital Market\"),\n", + " (\"L_s\", \"Labor Market\"),\n", + " (\"C\", \"Goods Market\"),\n", + " (\"Y\", \"Goods Market\"),\n", + "]\n", + "edge_props = {\n", + " (\"K_d\", \"Capital Market\"): {\"label\": \"r\"},\n", + " (\"K_s\", \"Capital Market\"): {\"label\": \"r\"},\n", + " (\"L_d\", \"Labor Market\"): {\"label\": \"w\"},\n", + " (\"L_s\", \"Labor Market\"): {\"label\": \"w\"},\n", + " (\"C\", \"Goods Market\"): {\"label\": \"P\"},\n", + " (\"Y\", \"Goods Market\"): {\"label\": \"P\"},\n", + "}\n", + "draw_graph(edges, edge_props=edge_props, graph_direction=\"LR\")" + ] + }, + { + "cell_type": "markdown", + "id": "93d4100b", + "metadata": {}, + "source": [ + "Given this structure, the economy will be comprised of the following equations:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " Y &= C & \\text{Goods market clearing} \\\\\n", + " K_d &= K_s & \\text{Capital market clearing} \\\\\n", + " L_d &= L_s & \\text{Labor market clearing} \\\\\n", + " Y &= f(K_d, L_d) & \\text{Production function} \\\\\n", + " \\frac{r}{P} &= \\frac{\\partial f \\left (K_d, L_d \\right )}{\\partial K_d} & \\text{Firm demand for capital} \\\\\n", + " \\frac{w}{P} &= \\frac{\\partial f \\left (K_d, L_d \\right )}{\\partial L_d} & \\text{Firm demand for labor} \\\\\n", + " PC &= rK_s + wL_s + \\Pi & \\text{Household budget constraint}\n", + "\\end{align}\n", + "$$\n", + "\n", + "Since we are an endowment economy, we take $K_s$ and $L_s$ as given -- they are thus parameters. The variables are $Y$, $C$, $K_d$, $L_d$, $w$, $r$, and $P$. $\\Pi$, the profits of the firm, we set to zero to eliminate. So we have 7 variables and 7 unknowns." + ] + }, + { + "cell_type": "markdown", + "id": "e1d711fc", + "metadata": {}, + "source": [ + "### Underdetermination\n", + "\n", + "The system above looks square, but actually it's not! The household budget constraint is equivalent to the goods market clearning condition. To see this, you have to know that the equations for the firm's factor demand are based on the zero profit condtion. Suppose we don't eliminate $\\Pi$, and instead use the identity:\n", + "\n", + "$$\\Pi = P Y - r K_d - w L_d$$\n", + "\n", + "Substituting this into the household budget constraint, we obtain:\n", + "\n", + "$$PC = r K_s + w L_s + P Y - r K_d - w L_d $$\n", + "\n", + "From the factor clearing conditions we have $K_d = K_s$ and $L_d = L_s$, so we can make these substitutions:\n", + "\n", + "$$\\begin{align}\n", + "PC &= r K_s - r K_s + w L_s - w L_s + PY \\\\\n", + "PC &= PY \\\\\n", + "C &= Y\n", + "\\end{align}\n", + "$$\n", + "\n", + "We recovered the market clearing condition from the other equations! This shows that although we wrote down 7 equations, we actually only have 6 equations worth of information." + ] + }, + { + "cell_type": "markdown", + "id": "f5a0caf1", + "metadata": {}, + "source": [ + "### Walras' Law and Choice of Numeraire\n", + "\n", + "It's surprising that we only have 6 independent equations, given that we have 7 variables. But actually we only have 6 variables. This is because of Walras' law. The law says that, given perfect competiton and flexible prices in all markets (which we've assumed), the sum of the values of excess demands (or supplies) must be zero. This is an additional constraint on the economy, which has the effect of pinning down the price of the last good, assuming we know the prices of all other goods. In our case, if we know values of $r$ and $w$, we are *not* free to choose a value for $P$. \n", + "\n", + "As a result, one of our prices is not actually a variable at all. We are required to choose a numeraire -- a price that all other prices are measured by. The choice of numeraire is the modeler's. I will choose $w$, the wage level, to be the numeraire. As a result, all prices will be expressed in hourly wages.\n", + "\n", + "Conceptually, we think of $w$ as a parameter now (which we will fix to be 1 -- since any numeraire value implies a valid price vector, we might as well choose the easiest possible value). Now we have 6 variables are 7 equations, 6 of which are independent. " + ] + }, + { + "cell_type": "markdown", + "id": "9ab5df37", + "metadata": {}, + "source": [ + "### Squaring up the system\n", + "\n", + "Now we just need to make the system square. We have two choices. First, we could remove one of the redundant equations (either the household budget constraint or the goods market clearing conditions). Alternatively, we can add a dummy \"residual\" variable, which we set to zero. This second choice is popular because it adds a consistency check to model simulations. This residual should always be zero, at all valid equlibria. \n", + "\n", + "We will add a residual term, $\\varepsilon$, to the market clearing condition. So our system now becomes:" + ] + }, + { + "cell_type": "markdown", + "id": "edc0a944", + "metadata": {}, + "source": [ + "### The Final System" + ] + }, + { + "cell_type": "markdown", + "id": "8b6f956b", + "metadata": {}, + "source": [ + "Finally, we need to specify a production function. We can use Cobb-Douglas, so $Y = f(K_d, L_d) = AK_d^\\alpha L_d^{1-\\alpha}$.\n", + "\n", + "The system then becomes:\n", + "\n", + "$$\n", + "\\begin{align}\n", + " Y &= C + \\varepsilon & \\text{Goods market clearing} \\\\\n", + " K_d &= K_s & \\text{Capital market clearing} \\\\\n", + " L_d &= L_s & \\text{Labor market clearing} \\\\\n", + " Y &= AK_d^\\alpha L_d^{1-\\alpha} & \\text{Production function} \\\\\n", + " K_d &= \\alpha Y \\frac{P}{r} & \\text{Firm demand for capital} \\\\\n", + " L_d &= (1 - \\alpha) Y \\frac{P}{w} & \\text{Firm demand for labor} \\\\\n", + " PC &= rK_s + wL_s + \\Pi & \\text{Household budget constraint}\n", + "\\end{align}\n", + "$$\n", + "\n", + "Where $Y$, $C$, $K_d$, $L_d$, $r$, $P$, and $\\varepsilon$ are variables. $A$, $\\alpha$, $L_s$, $K_s$, and $w$ are parameters.\n", + "\n", + "We have 7 variables and 7 independent equations (since the market clearing and budget constraint now vary by $\\varepsilon$!), and we are ready to proceed. " + ] + }, + { + "cell_type": "markdown", + "id": "88e472ea", + "metadata": {}, + "source": [ + "## Declare Variables\n", + "\n", + "First, we make a list of variables using the `Variable` class. In their simplest form, variables have a `name` and a `description`. We can optionally also specify a `latex_name` for pretty printing." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cb03f51b", + "metadata": {}, + "outputs": [], + "source": [ + "variables = [\n", + " Variable(\"Y\", description=\"Total output\"),\n", + " Variable(\"C\", description=\"Household constumption\"),\n", + " Variable(\"K_d\", description=\"Firm demand for capital\"),\n", + " Variable(\"L_d\", description=\"Firm demand for labor\"),\n", + " Variable(\"r\", description=\"Rental rate of capital\"),\n", + " Variable(\"P\", description=\"Price of consumption goods\"),\n", + " Variable(\"resid\", latex_name=\"\\\\varepsilon\", description=\"Walrasian residual\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "3123d41f", + "metadata": {}, + "source": [ + "## Declare Parameters\n", + "\n", + "`Parameter`s are exactly the same as `Variable`s, except that they are treated differently inside the model." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a316d325", + "metadata": {}, + "outputs": [], + "source": [ + "parameters = [\n", + " Parameter(\"A\", description=\"Total factor productivity\"),\n", + " Parameter(\"alpha\", description=\"Share of capital in production\"),\n", + " Parameter(\"L_s\", description=\"Household endowment of labor\"),\n", + " Parameter(\"K_s\", description=\"Household endowment of capital\"),\n", + " Parameter(\"w\", description=\"Wage level\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "44d9df30", + "metadata": {}, + "source": [ + "## Declare equations\n", + "\n", + "`Equation`s also have a name, but instead of a description, you need to provide a string form of the equation. " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4bf6d331", + "metadata": {}, + "outputs": [], + "source": [ + "equations = [\n", + " Equation(\"Production function\", \"Y = A * K_d ** alpha * L_d ** (1 - alpha)\"),\n", + " Equation(\"Firm capital demand function\", \"K_d = alpha * Y * P / r\"),\n", + " Equation(\"Firm labor demand function\", \"L_d = (1 - alpha) * Y * P / w\"),\n", + " Equation(\"Household budget constraint\", \"P * C = r * K_s + w * L_s\"),\n", + " Equation(\"Labor market clearing\", \"L_s = L_d\"),\n", + " Equation(\"Capital market clearing\", \"K_s = K_d\"),\n", + " Equation(\"Goods market clearing\", \"Y = C + resid\"),\n", + "]" + ] + }, + { + "cell_type": "markdown", + "id": "0b5d6a17", + "metadata": {}, + "source": [ + "# Create a model\n", + "\n", + "With these these lists, we are ready to create a CGEModel" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "dab3cada", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Initializing variables\n", + "Initializing parameters\n", + "Initializing equations\n", + "Expanding reduction Ops (Sum, Prod)\n", + "Post-processing sympy equations\n", + "Post-processing sympy variables\n", + "Post-processing sympy parameters\n", + "Initial pre-processing complete, found 7 equations, 7 variables, 5 parameters\n", + "Beginning compilation using pytensor backend using C (FAST_RUN) mode\n", + "Compiling model with ['root', 'minimize', 'euler'] functions\n", + "Compiling model equations into pytensor graph\n", + "Compiling CGE equations into C function\n", + "Compiling Jacobian equations into C function\n", + "Computing sum of squared errors\n", + "Computing SSE gradient\n", + "Compiling SSE functions (sse, gradient, jacobian) into C function\n", + "Compiling euler approximation function\n" + ] + } + ], + "source": [ + "mod = CGEModel(\n", + " variables=variables, parameters=parameters, equations=equations, backend=\"pytensor\"\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "54772097", + "metadata": {}, + "source": [ + "Once the model is built, we can look at the equations" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c355dc90", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/latex": [ + "\n", + "\t\n", + "\t\t\\begin{array}{|c|c|c|}\n", + "\t\t\t\\hline\n", + "\t\t\t\\textbf{} & \\textbf{Name} & \\textbf{Equation} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t1 & \\text{Production function} & Y = A K_{d}^{\\alpha} L_{d}^{1 - \\alpha} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t2 & \\text{Firm capital demand function} & K_{d} = \\frac{P Y \\alpha}{r} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t3 & \\text{Firm labor demand function} & L_{d} = \\frac{P Y \\left(1 - \\alpha\\right)}{w} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t4 & \\text{Household budget constraint} & C P = K_{s} r + L_{s} w \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t5 & \\text{Labor market clearing} & L_{s} = L_{d} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t6 & \\text{Capital market clearing} & K_{s} = K_{d} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t7 & \\text{Goods market clearing} & Y = C + \\varepsilon \\\\\n", + "\t\t\t\\hline\n", + "\t\t\\end{array}\n", + "\t\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod.equation_table()" + ] + }, + { + "cell_type": "markdown", + "id": "2983539a", + "metadata": {}, + "source": [ + "As well as the parameters and variables" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ea5c4cf4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "\n", + "\t\n", + "\t\t\\begin{array}{|c|c|}\n", + "\t\t\t\\hline\n", + "\t\t\t\\textbf{Symbol} & \\textbf{Description} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tY & \\text{Total output} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tC & \\text{Household constumption} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tK_d & \\text{Firm demand for capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tL_d & \\text{Firm demand for labor} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tr & \\text{Rental rate of capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tP & \\text{Price of consumption goods} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t\\varepsilon & \\text{Walrasian residual} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\\end{array}\n", + "\t\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod.summary(\"variables\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b797b7fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "\n", + "\t\n", + "\t\t\\begin{array}{|c|c|}\n", + "\t\t\t\\hline\n", + "\t\t\t\\textbf{Symbol} & \\textbf{Description} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tA & \\text{Total factor productivity} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t\\alpha & \\text{Share of capital in production} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tL_s & \\text{Household endowment of labor} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tK_s & \\text{Household endowment of capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tw & \\text{Wage level} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\\end{array}\n", + "\t\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod.summary(\"parameters\")" + ] + }, + { + "cell_type": "markdown", + "id": "acbf9b92", + "metadata": {}, + "source": [ + "Or, if you prefer, everything together" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "ec1cf066", + "metadata": {}, + "outputs": [ + { + "data": { + "text/latex": [ + "\n", + "\t\n", + "\t\t\\begin{array}{|c|c|}\n", + "\t\t\t\\hline\n", + "\t\t\t\\textbf{Symbol} & \\textbf{Description} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tY & \\text{Total output} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tC & \\text{Household constumption} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tK_d & \\text{Firm demand for capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tL_d & \\text{Firm demand for labor} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tr & \\text{Rental rate of capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tP & \\text{Price of consumption goods} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t\\varepsilon & \\text{Walrasian residual} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tA & \\text{Total factor productivity} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\t\\alpha & \\text{Share of capital in production} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tL_s & \\text{Household endowment of labor} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tK_s & \\text{Household endowment of capital} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\tw & \\text{Wage level} \\\\\n", + "\t\t\t\\hline\n", + "\t\t\\end{array}\n", + "\t\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "mod.summary()" + ] + }, + { + "cell_type": "markdown", + "id": "2736135f", + "metadata": {}, + "source": [ + "# Data and Calibration\n", + "\n", + "To actually run policy experiments, you have to first find a non-trivial model equlibrium. To check for an equlibrium, you can use the `model.check_for_equlibrium` method. It expects a dictionary containing all model variables and parameters, and checks whether all provided model equations are equal to zero" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "73290c01", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Equilibrium not found. Total squared error: 9.293908\n", + "\n", + "\n", + "Equation Residual\n", + "====================================================================================================\n", + "Production function -1.431595\n", + "Firm capital demand function 1.911287\n", + "Firm labor demand function 0.424706\n", + "Household budget constraint -0.354216\n", + "Labor market clearing -0.292049\n", + "Capital market clearing -1.764859\n", + "Goods market clearing -0.292508\n" + ] + } + ], + "source": [ + "all_objects = mod.variable_names + mod.parameter_names\n", + "random_initial_point = dict(\n", + " zip(all_objects, np.random.normal(size=len(all_objects)) ** 2)\n", + ")\n", + "mod.check_for_equilibrium(random_initial_point)" + ] + }, + { + "cell_type": "markdown", + "id": "fc0ce160", + "metadata": {}, + "source": [ + "For data, we will use a (fake!) balanced SAM. We exploit the fact that the SAM is balanced to \"calibrate\" the model, choosing parameter values that lead to the data observed in the SAM. Calibration is unique to each model, so `cge_modeling` currently can't do that for you. What it can do is help you with some consistency checks. We need to:\n", + "\n", + "1. Write a python function that takes the model, plus all required initial data from the SAM\n", + "2. Inside the function, make sure every parameter and variable is given a value\n", + "3. return `model.check_calibration()`\n", + "\n", + "`model.check_calibration()` specifically looks at the local namespace, so it's important that it is called from within a function." + ] + }, + { + "cell_type": "markdown", + "id": "f8fecd84", + "metadata": {}, + "source": [ + "## Load Data" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "fc3681af", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FactorInstitutionProductionActivities
LaborCapitalHouseholdFirmFirm
FactorLabor0.00.00.00.07000.0
Capital0.00.00.00.03000.0
InstitutionHousehold7000.03000.00.00.00.0
ProductionFirm0.00.010000.00.00.0
ActivitiesFirm0.00.00.010000.00.0
\n", + "
" + ], + "text/plain": [ + " Factor Institution Production Activities\n", + " Labor Capital Household Firm Firm\n", + "Factor Labor 0.0 0.0 0.0 0.0 7000.0\n", + " Capital 0.0 0.0 0.0 0.0 3000.0\n", + "Institution Household 7000.0 3000.0 0.0 0.0 0.0\n", + "Production Firm 0.0 0.0 10000.0 0.0 0.0\n", + "Activities Firm 0.0 0.0 0.0 10000.0 0.0" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "sam = pd.read_csv(\n", + " \"../data/simple_rbc_data.csv\", index_col=[0, 1], header=[0, 1]\n", + ").fillna(0)\n", + "sam" + ] + }, + { + "cell_type": "markdown", + "id": "e3838c7c", + "metadata": {}, + "source": [ + "First we can double check that this is a properly balanced SAM by checking that the sum of the rows is equal to the sum of the columns" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "3a736c35", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Factor Labor True\n", + " Capital True\n", + "Institution Household True\n", + "Production Firm True\n", + "Activities Firm True\n", + "dtype: bool" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sam.sum(axis=1) == sam.sum(axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "3f4a8456", + "metadata": {}, + "source": [ + "For bigger SAMs its not realistic to look row by row, so we can use `.all()`" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "d16237d5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(sam.sum(axis=1) == sam.sum(axis=0)).all()" + ] + }, + { + "cell_type": "markdown", + "id": "602ab636", + "metadata": {}, + "source": [ + "Next, we extract the required initial values. In this case we actually know basically everything, but let's try to work with the minimum set: $Y$, $K_d$, $L_d$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "551e64e4", + "metadata": {}, + "outputs": [], + "source": [ + "initial_values = {\n", + " \"Y\": sam.loc[(\"Activities\", \"Firm\"), (\"Production\", \"Firm\")],\n", + " \"K_d\": sam.loc[(\"Factor\", \"Capital\"), (\"Activities\", \"Firm\")],\n", + " \"L_d\": sam.loc[(\"Factor\", \"Labor\"), (\"Activities\", \"Firm\")],\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "89edfef3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'Y': 10000.0, 'K_d': 3000.0, 'L_d': 7000.0}" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "initial_values" + ] + }, + { + "cell_type": "markdown", + "id": "9762c374", + "metadata": {}, + "source": [ + "## Calibration\n", + "\n", + "Now that we have data, we need to \"calibrate\" the CGE model to the data. Calibration is process in which we use observed values in the same to calculate parameter values. All widely used production and utility functions have off-the-sheft calibration equations for all or most of the parameters. In the case of the Cobb-Douglas production function, the calibrating equations are:\n", + "\n", + "$$\\begin{align} \n", + "\\alpha &= \\frac{r K_d}{r K_d + w L_d} \\\\\n", + "A &= \\frac{Y}{K_d ^\\alpha L_d ^ {1 - \\alpha}}\n", + "\\end{align}$$\n", + "\n", + "It is easy to see that the second equation is just a re-arrangement of the production function, conditional on knowing the value of $\\alpha$. The equation for $\\alpha$ itself comes from \"inverting\" the factor demand functions:\n", + "\n", + "$$\\begin{align}\n", + "K_d &= \\alpha Y \\frac{P}{r} & \\to Y P &= \\frac{K_d r}{\\alpha} \\\\\n", + "L_d &= (1 - \\alpha) Y \\frac{P}{w} & \\to Y P &= \\frac{L_d w}{1 - \\alpha} \\\\ \n", + "\\frac{K_d r}{\\alpha} &= \\frac{L_d w}{1 - \\alpha} \\\\\n", + "\\frac{1 - \\alpha}{\\alpha} &= \\frac{L_d w}{K_d r} \\\\\n", + "\\frac{1}{\\alpha} - 1 &= \\frac{L_d w}{K_d r} \\\\\n", + "\\frac{1}{\\alpha} &= \\frac{L_d w}{K_d r} + \\frac{K_d r}{K_d r} \\\\\n", + "\\alpha &= \\frac{K_d r}{K_d r + L_d w}\n", + "\\end{align}$$" + ] + }, + { + "cell_type": "markdown", + "id": "757308a8", + "metadata": {}, + "source": [ + "### A sidenote on prices\n", + "\n", + "To perform this calibration, we need to know $K_d$, $L_d$ , and $Y$. It is tempting to read these values off from the SAM. After all, it records transfers from the activity account (the firms' purchases of inputs) to the factor accounts (e.g. $K_d$ and $L_d$) as well as flows from the production account to the activity account (the firm's output). Recall though that the SAM records the *value* of these flows -- that is, $\\text{Price} \\times \\text{Quantity}$. \n", + "\n", + "When computing $\\alpha$ the situation isn't so bad, because all terms enter as values. That is, we have $rK_d$ and $wL_d$, and never $K_d$ or $L_d$ (the quantity variables) alone. But for computing $A$, we do need to pick apart the price and quantity. Since we're unlikely to have access to detailed price data, trickery will be employed.\n", + "\n", + "The trick in this case is called \"normalization\". To understand the trick, first realize that \"quantity\" is a value with units. We might not know what these units are without digging into statistical documentation, but the SAM might record, for example, purchases of wheat by households from wheat farmers in bushels. So the value $V = PQ$ in this case would be $\\text{Currency} \\times \\text{Bushel}$. \n", + "\n", + "Note that this choice of unit is entirely arbitrary. If we knew the price of a kilogram of wheat instead, we could just as easily have reported $V = P^\\prime Q^\\prime$, with $P^\\prime Q^\\prime$ measured in $\\text{Currency} \\times \\text{Kilograms}$. Importantly, though, the total value would be the same -- note that I did not write $V^\\prime$ in the 2nd equation; this was delibrate!\n", + "\n", + "Given this, there is a sense in which we are free to choose whatever units we wish, as long as we are consistent. Let us choose the most convenient unit possible -- the \"Unit Currency Unit\". That is, we choose whatever unit of every good, such that the price of that good is exactly 1 unit of currency. Labor is measured in whatever fraction of time such that the wage for that time is one dollar. Cars are measured in fractional cars, such that the price of the fraction is one dollar, and so on. \n", + "\n", + "This might strike you as a bit silly, but you have to admit it's very convenient! We are now free to set $P=1$, and $r=1$ (recall that we already set $w=1$, since it was chosen to be the numeraire). What changes is our interprertation. We cannot report \"natural\" units on the outputs of our simulations, since everything will be measured in \"Unit Currency Units\". But not all hope is lost, because percentages are unitless! So we can calibrate to this odd unit, then report the results of a policy experiment in percentages. " + ] + }, + { + "cell_type": "markdown", + "id": "24c272f2", + "metadata": {}, + "source": [ + "## Implementing the calibration\n", + "\n", + "Now we know how to actually do the calibration. We will:\n", + "\n", + "1. Read in the necessary values from the SAM, in this case $Y$, $K_d$, and $L_d$.\n", + "2. Normalize all prices to 1.\n", + "3. Calibrate $\\alpha$ and $A$ using the formulas derived above\n", + "4. Compute all variables using model equations\n", + "\n", + "`cge_modeling` provides a few tools to help you accomplish this. First, when setting constant values, you can use `model.initialize_parameter`. This will take care of shapes automatically for models with many dimensions. Second, you can use `model.finalize_calibration`. This will automatically collect the variables in a function context, check shapes, and return a dictionary of results. If anything was not declared, it will give a reminder.\n", + "\n", + "The following cell shows how to use this features to calibrate our model. `resid` has been purposely omitted, to show how `finalize_calibration` will alert us to missing variables or parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "08ebb64f", + "metadata": {}, + "outputs": [], + "source": [ + "def calibrate_model(mod, *, Y, K_d, L_d):\n", + " # Normalize prices\n", + " r = mod.initialize_parameter(\"r\", 1.0)\n", + " w = mod.initialize_parameter(\"w\", 1.0)\n", + " P = mod.initialize_parameter(\"P\", 1.0)\n", + "\n", + " # Calibrate parameters\n", + " alpha = r * K_d / (r * K_d + w * L_d)\n", + " A = Y / K_d**alpha / L_d ** (1 - alpha)\n", + "\n", + " # Market clearing conditions\n", + " K_s = K_d\n", + " L_s = L_d\n", + " C = Y\n", + "\n", + " return mod.finalize_calibration()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "697da516", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "resid not found in model variables\n" + ] + } + ], + "source": [ + "calibrated_values = calibrate_model(mod, **initial_values)" + ] + }, + { + "cell_type": "markdown", + "id": "56f59a08", + "metadata": {}, + "source": [ + "Oops, we forgot `resid`. Let's go back and fix it:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "d212759e", + "metadata": {}, + "outputs": [], + "source": [ + "def calibrate_model(mod, *, Y, K_d, L_d):\n", + " # Normalize prices\n", + " r = mod.initialize_parameter(\"r\", 1.0)\n", + " w = mod.initialize_parameter(\"w\", 1.0)\n", + " P = mod.initialize_parameter(\"P\", 1.0)\n", + "\n", + " # Calibrate parameters\n", + " alpha = r * K_d / (r * K_d + w * L_d)\n", + " A = Y / K_d**alpha / L_d ** (1 - alpha)\n", + "\n", + " # Market clearing conditions\n", + " K_s = K_d\n", + " L_s = L_d\n", + " C = Y\n", + " resid = Y - C\n", + "\n", + " return mod.finalize_calibration()" + ] + }, + { + "cell_type": "markdown", + "id": "ebed3b47", + "metadata": {}, + "source": [ + "In Python, no news is good news! " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "be24d013", + "metadata": {}, + "outputs": [], + "source": [ + "calibrated_values = calibrate_model(mod, **initial_values)" + ] + }, + { + "cell_type": "markdown", + "id": "9db2a555", + "metadata": {}, + "source": [ + "We can check that the calibrated values have zero residual when plugged into the model equations " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "7ffd31ed", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Equilibrium found! Total squared error: 0.000000\n" + ] + } + ], + "source": [ + "mod.check_for_equilibrium(calibrated_values)" + ] + }, + { + "cell_type": "markdown", + "id": "20664bc5", + "metadata": {}, + "source": [ + "We have an equlibrium. We can now proceed to policy simulation" + ] + }, + { + "cell_type": "markdown", + "id": "468eb9a9", + "metadata": {}, + "source": [ + "# Policy Simulation\n", + "\n", + "To perform a policy simulation, use the `simulate` method. This method has a number of options, but the most important are the following:\n", + "\n", + "- `initial_state` is the initial equilibrium from which to begin. In most cases this will be the calibrated equlibrium, but it could also be a previous simulation (if you're doing recursive modeling through time, for example)\n", + "\n", + "- `final_delta`, `final_delta_pct`, or `final_values` are how you specify the policy simulation. Ultimately, what you need to provide is a vector of final parameter values -- the policy to be simulated. Each of these options are available to help you better reason about that. Values passed to `final_delta` are added to the inital parameter values; values passed to `final_delt_pct` are multiplied by the initial values; and `final_values` completely override the initial values.\n", + "\n", + " Suppose the initial value of labor supply was 1000, and we want to simulate a cut in labor supply to 500. The following specifications are all equivalent:\n", + " \n", + " 1. `final_values={'L_s':500}`\n", + " 2. `final_delta={'L_s':-500}`\n", + " 3. `final_delta_pct = {'L_s':0.5}`\n", + " \n", + "- `use_euler_approximation` and `use_optimizer`. By default, `cge_modeling` solves for the policy solution in two ways:\n", + "\n", + " 1. Linearize the model, and convert the policy shock into an implicit ODE. This is \"euler approximation\". Given infinite compute, it always gives the right answer, but involves some expensive matrix inversion. As a bonus, it gives you all equlibria on the way from the initial state to the final state, so you can see a small slice of the function space.\n", + " \n", + " 2. Solve for the new equlibrium using a numerical routine. This can be more direct, but sometimes struggles on complex problems.\n", + " \n", + " The strategy of `cge_modeling` is to use the euler approximation with a conservative number of steps to move the model into the neighborhood of the solution, then use a numerical optimizer to finish the job. You acn disable one or the other, though, if you don't want to use both.\n", + " \n", + "- `optimizer_mode`, one of `root` or `minimize`. `root` solves for a vector of zeros directly, using multivariate root finding algorithms. `minimize` tries to minimize the sum of squared residuals using some flavor of Newton's Method. Usually `root` works fine, but on really stubbon problems `minimize` is nice to try.\n", + "\n", + "\n", + "Other options are related to saving and loading model results. Any other keyword arguments are passed to the `scipy` optimizer being used, so check the scipy documentation to learn what you can do there. " + ] + }, + { + "cell_type": "markdown", + "id": "cfdf81dd", + "metadata": {}, + "source": [ + "## 50% Labor Supply Reduction\n", + "\n", + "We now (finally) run a policy simulation, to study what happens if households work 50% less. I use the `final_delta_pct` argument to directly specify the cut in percentage terms." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "83721f93", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [10000/10000 00:01<00:00 10,131.17 it/s, f = 0.01052]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [3/3 00:00<00:00 f = 1.9171e-24, ||grad|| = 10,729]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "labor_cut = mod.simulate(initial_state=calibrated_values, final_delta_pct={\"L_s\": 0.5})" + ] + }, + { + "cell_type": "markdown", + "id": "920e0827", + "metadata": {}, + "source": [ + "We get back a dictionary with three entries. `euler` and `optimizer` hold `xarray` objects with the results of their respective optimization steps. `optim_res` holds the raw optimizer result returned by `scipy.` We can see from the `optim_res` that optimization was successful. We can also see that during Euler approximation, the errors in the approximation stayed around 0.01, which is good." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "318560e6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + " message: The solution converged.\n", + " success: True\n", + " status: 1\n", + " fun: [ 0.000e+00 4.547e-13 -9.095e-13 9.095e-13 0.000e+00\n", + " 0.000e+00 2.365e-13]\n", + " x: [ 6.156e+03 6.156e+03 3.000e+03 3.500e+03 5.000e-01\n", + " 8.123e-01 -1.146e-12]\n", + " method: hybr\n", + " nfev: 3\n", + " njev: 1\n", + " fjac: [[-6.249e-01 3.045e-01 ... -4.114e-18 -6.249e-01]\n", + " [ 3.466e-01 -1.689e-01 ... 6.771e-18 -5.410e-01]\n", + " ...\n", + " [ 5.124e-01 -1.219e-01 ... -4.372e-01 -1.980e-01]\n", + " [ 1.091e-06 2.452e-01 ... 2.451e-01 3.983e-01]]\n", + " r: [-1.600e+00 6.249e-01 ... 1.980e-01 -3.983e-01]\n", + " qtf: [-7.427e-08 2.653e-07 9.276e-08 -6.169e-08 -5.178e-08\n", + " -1.929e-07 5.513e-08]\n", + " args: [ 1.842e+00 3.000e-01 3.500e+03 3.000e+03 1.000e+00]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labor_cut[\"optim_res\"]" + ] + }, + { + "cell_type": "markdown", + "id": "ba8487a5", + "metadata": {}, + "source": [ + "It's also good to check the final value of the `resid` variable, since we know it should always be zero. If it isn't, we have a problem in our model closure. " + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "84087493", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.DataArray 'resid' (step: 2)> Size: 16B\n",
+       "array([ 0.00000000e+00, -1.14597047e-12])\n",
+       "Coordinates:\n",
+       "  * step     (step) int64 16B 0 1
" + ], + "text/plain": [ + " Size: 16B\n", + "array([ 0.00000000e+00, -1.14597047e-12])\n", + "Coordinates:\n", + " * step (step) int64 16B 0 1" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "labor_cut[\"optimizer\"].variables[\"resid\"]" + ] + }, + { + "cell_type": "markdown", + "id": "448944ba", + "metadata": {}, + "source": [ + "### Plotting\n", + "\n", + "`cge_model.plotting` offers some plotting functions to examine outputs. The two most important are `plot_bar` and `plot_line`. See the example gallery for how to use these.\n", + "\n", + "First, we can look at the total change from the initial to the final state using `gcp.plot_bar`. Since all of the variables have the same dimensions (in this case, no dimensions!) we set `plot_together = True` to see all the plots on a single axis.\n", + "\n", + "The default is to plot each variable in its own axis, which makes sense when the variables have different dimensions (for example, one is defined over the set of firms, and other over the set of households).\n", + "\n", + "In this case, real demand for capital $K_d$ did not change. This is because it was the *price* of capital $r$ that shifted in response to the reduced labor supply. Capital becomes relatively cheaper as wages go up (remember that implicity $r = \\frac{r^N}{w}$, since wages are the numeraire!), and the net effect is no change to capital demand.\n", + "\n", + "On the other hand, the budget line for the household shifts inward (because their endowment of labor has been reduced), which decreases consumpton (and output, which is the same thing in this economy)." + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "2d636f01", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cgp.plot_bar(\n", + " labor_cut,\n", + " mod,\n", + " var_names=[\"Y\", \"C\", \"K_d\", \"L_d\", \"r\"],\n", + " plot_together=True,\n", + " figsize=(14, 4),\n", + " legend=True,\n", + " metric=\"pct_change\",\n", + ");" + ] + }, + { + "cell_type": "markdown", + "id": "792bd034", + "metadata": {}, + "source": [ + "Thanks for the Euler Approximation approach, we can also trace out the effect of each \"step\" in the labor supply reduction on all the other variables. We can see this with `plot_lines`.\n", + "\n", + "In this case, we see that the reduction in all variables is essentially linear in the labor supply. This makes sense, since the driving effect is the shifting inward of the household budget constraint." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "3d0aaaf8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cgp.plot_lines(\n", + " labor_cut, mod, var_names=[\"Y\", \"C\", \"K_d\", \"L_d\", \"r\"], figsize=(14, 4)\n", + ");" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": {}, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/source/get_started/about.rst b/docs/source/get_started/about.rst new file mode 100644 index 0000000..8f70fde --- /dev/null +++ b/docs/source/get_started/about.rst @@ -0,0 +1,4 @@ +About CGE Modeling +================== + +WRITEME diff --git a/docs/source/get_started/get_started.rst b/docs/source/get_started/get_started.rst new file mode 100644 index 0000000..ef186b0 --- /dev/null +++ b/docs/source/get_started/get_started.rst @@ -0,0 +1,4 @@ +Getting Started +=============== + +WRITEME diff --git a/docs/source/get_started/install.rst b/docs/source/get_started/install.rst new file mode 100644 index 0000000..6b7baae --- /dev/null +++ b/docs/source/get_started/install.rst @@ -0,0 +1,36 @@ +Installation +============ + + +Recommended Installation Method +******************************* +You can use the ``environment.yaml`` file provided in the repository to create a new conda environment with all the +dependencies installed: + +.. code-block:: bash + + conda env create -f environment.yaml + conda activate cge-modeling + + +Other Methods +************* +``cge_modeling`` is available on PyPI and can be installed using pip: + +.. code-block:: bash + + pip install cge_modeling + +This command will install the package and all its dependencies. Is is **strongly** recommended that you create a +virtual environment before installing the package. ``cge_modeling`` depends on `pytensor `_, +a package that requires a C compiler to be installed on your system. Therefore, it is recommended that you first create a virtual environment with +pytensor, then install ``cge_modeling`` in that environment: + +.. code-block:: bash + + conda create -n cge-modeling python=3.12 pip pytensor + conda activate cge-modeling + pip install cge_modeling + + +This will ensure that all dependencies are correctly installed and that the package will work as expected. diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000..eb76c3f --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,31 @@ +Introduction +============ + + +Quick Setup +=========== + + +Citation +======== + +If you use gEconpy in your research, please cite the package using the following BibTeX entry: + +.. code-block:: bibtex + + @software{gEconpy, + author = {Jesse Grabowski}, + title = {cge_modeling: Computable General Equlibirum Models in Python}, + url = {https://github.com/jessegrabowski/cge_modeling}, + version = {0.0.1}} + +.. toctree:: + :maxdepth: 1 + :hidden: + + get_started/index + user_guide/index + examples/gallery + api + dev/index + release/index diff --git a/docs/source/release/index.rst b/docs/source/release/index.rst new file mode 100644 index 0000000..2f6dc23 --- /dev/null +++ b/docs/source/release/index.rst @@ -0,0 +1,8 @@ +.. _release_index: + +============= +Release Notes +============= + +.. toctree:: + :maxdepth: 1 diff --git a/docs/source/user_guide/api_structure.rst b/docs/source/user_guide/api_structure.rst new file mode 100644 index 0000000..6dc6aba --- /dev/null +++ b/docs/source/user_guide/api_structure.rst @@ -0,0 +1,4 @@ +API Structure +============= + +WRITEME diff --git a/docs/source/user_guide/cge_intro.rst b/docs/source/user_guide/cge_intro.rst new file mode 100644 index 0000000..0229c8f --- /dev/null +++ b/docs/source/user_guide/cge_intro.rst @@ -0,0 +1,4 @@ +Introduction to CGE Modeling +============================ + +WRITEME diff --git a/docs/source/user_guide/coords_dims.rst b/docs/source/user_guide/coords_dims.rst new file mode 100644 index 0000000..8821c3c --- /dev/null +++ b/docs/source/user_guide/coords_dims.rst @@ -0,0 +1,4 @@ +Coordinates and Dimensions +========================== + +WRITEME diff --git a/docs/source/user_guide/example_model.rst b/docs/source/user_guide/example_model.rst new file mode 100644 index 0000000..43b2dec --- /dev/null +++ b/docs/source/user_guide/example_model.rst @@ -0,0 +1,4 @@ +A Simple Modeling Workflow +========================== + +WRITEME diff --git a/docs/source/user_guide/index.rst b/docs/source/user_guide/index.rst new file mode 100644 index 0000000..35c0f32 --- /dev/null +++ b/docs/source/user_guide/index.rst @@ -0,0 +1,10 @@ +User Guide +========== + +.. toctree:: + :maxdepth: 1 + + cge_intro + api_structure + coords_dims + example_model diff --git a/sphinxext/generate_gallery.py b/sphinxext/generate_gallery.py new file mode 100644 index 0000000..4e7520d --- /dev/null +++ b/sphinxext/generate_gallery.py @@ -0,0 +1,179 @@ +""" +Sphinx plugin to run generate a gallery for notebooks + +Modified from the pymc project, whihch modified the seaborn project, which modified the mpld3 project. +""" + +import base64 +import json +import os +import shutil + +from glob import glob + +import matplotlib + +matplotlib.use("Agg") +import matplotlib.pyplot as plt +import sphinx + +from matplotlib import image + +logger = sphinx.util.logging.getLogger(__name__) + +DOC_SRC = os.path.dirname(os.path.abspath(__file__)) + +DEFAULT_IMG_LOC = None +external_nbs = {} + +HEAD = """ +Example Gallery +=============== + +.. toctree:: + :hidden: + +""" + +SECTION_TEMPLATE = """ +.. _{section_id}: + +{section_title} +{underlines} + +.. grid:: 1 2 3 3 + :gutter: 4 + +""" + +ITEM_TEMPLATE = """ + .. grid-item-card:: :doc:`{doc_name}` + :img-top: {image} + :link: {doc_reference} + :link-type: {link_type} + :shadow: none +""" + +folder_title_map = {"getting_started": "Getting Started"} + + +def create_thumbnail(infile, width=275, height=275, cx=0.5, cy=0.5, border=4): + """Overwrites `infile` with a new file of the given size""" + im = image.imread(infile) + rows, cols = im.shape[:2] + size = min(rows, cols) + if size == cols: + xslice = slice(0, size) + ymin = min(max(0, int(cx * rows - size // 2)), rows - size) + yslice = slice(ymin, ymin + size) + else: + yslice = slice(0, size) + xmin = min(max(0, int(cx * cols - size // 2)), cols - size) + xslice = slice(xmin, xmin + size) + thumb = im[yslice, xslice] + thumb[:border, :, :3] = thumb[-border:, :, :3] = 0 + thumb[:, :border, :3] = thumb[:, -border:, :3] = 0 + + dpi = 100 + fig = plt.figure(figsize=(width / dpi, height / dpi), dpi=dpi) + + ax = fig.add_axes([0, 0, 1, 1], aspect="auto", frameon=False, xticks=[], yticks=[]) + ax.imshow(thumb, aspect="auto", resample=True, interpolation="bilinear") + fig.savefig(infile, dpi=dpi) + plt.close(fig) + return fig + + +class NotebookGenerator: + """Tools for generating an example page from a file""" + + def __init__(self, filename, root_dir, folder): + self.folder = folder + self.basename = os.path.basename(filename) + self.stripped_name = os.path.splitext(self.basename)[0] + self.image_dir = os.path.join(root_dir, "_thumbnails", folder) + self.png_path = os.path.join(self.image_dir, f"{self.stripped_name}.png") + with open(filename, encoding="utf-8") as fid: + self.json_source = json.load(fid) + self.default_image_loc = DEFAULT_IMG_LOC + + def extract_preview_pic(self): + """By default, just uses the last image in the notebook.""" + pic = None + for cell in self.json_source["cells"]: + for output in cell.get("outputs", []): + if "image/png" in output.get("data", []): + pic = output["data"]["image/png"] + if pic is not None: + return base64.b64decode(pic) + return None + + def gen_previews(self): + preview = self.extract_preview_pic() + if preview is not None: + print(self.png_path) + with open(self.png_path, "wb") as buff: + buff.write(preview) + else: + logger.warning( + f"Didn't find any pictures in {self.basename}", + type="thumbnail_extractor", + ) + shutil.copy(self.default_image_loc, self.png_path) + create_thumbnail(self.png_path) + + +def main(app): + logger.info("Starting thumbnail extractor.") + + working_dir = os.getcwd() + os.chdir(app.builder.srcdir) + + file = [HEAD] + + for folder, title in folder_title_map.items(): + file.append( + SECTION_TEMPLATE.format( + section_title=title, section_id=folder, underlines="-" * len(title) + ) + ) + + thumbnail_dir = os.path.join("..", "..", "_thumbnails", folder) + if not os.path.exists(thumbnail_dir): + os.makedirs(thumbnail_dir) + + if folder in external_nbs.keys(): + for descr in external_nbs[folder]: + file.append( + ITEM_TEMPLATE.format( + doc_name=descr["doc_name"], + image=descr["image"], + doc_reference=descr["doc_reference"], + link_type=descr["link_type"], + ) + ) + + nb_paths = glob(f"examples/{folder}/*.ipynb") + for nb_path in nb_paths: + nbg = NotebookGenerator( + filename=nb_path, root_dir=os.path.join("..", ".."), folder=folder + ) + nbg.gen_previews() + + file.append( + ITEM_TEMPLATE.format( + doc_name=os.path.join(folder, nbg.stripped_name), + image="/" + nbg.png_path, + doc_reference=os.path.join(folder, nbg.stripped_name), + link_type="doc", + ) + ) + + with open(os.path.join("examples", "gallery.rst"), "w", encoding="utf-8") as f: + f.write("\n".join(file)) + + os.chdir(working_dir) + + +def setup(app): + app.connect("builder-inited", main) diff --git a/tests/data/unbalanced_sam.csv b/tests/data/unbalanced_sam.csv new file mode 100644 index 0000000..8359d52 --- /dev/null +++ b/tests/data/unbalanced_sam.csv @@ -0,0 +1,17 @@ +,,Factor,Factor,Factor,Factor,Institution,Institution,Institution,Commodity,Commodity,Commodity,Activity,Activity,Activity,Other,Other +,,Labor,Unskilled Labor,Skilled Labor,Capital,Household,Firm,Government,Agriculture,Industry,Service,Agriculture,Industry,Service,Capital,Rest of World +Factor,Labor,,,,,,,,,,,690,0,0,, +Factor,Unskilled Labor,,,,,,,,,,,480,1530,4060,, +Factor,Skilled Labor,,,,,,,,,,,200,870,280,, +Factor,Capital,,,,,,,,,,,50,900,250,, +Institution,Household,600,6070,1400,1200,,,100,,,,,,,,523 +Institution,Firm,,,,,,,,,,,,,,, +Institution,Government,,,,,1400,,,165,1365,280,50,140,90,,58 +Commodity,Agriculture,,,,,1750,,500,,,,1120,930,1150,200,331 +Commodity,Industry,,,,,1200,,1030,,,,2200,3120,3398,745,37 +Commodity,Service,,,,,3400,,2785,,,,870,2250,1100,100,1900 +Activity,Agriculture,,,,,,,,5500,,,,,,, +Activity,Industry,,,,,,,,,9800,,,,,, +Activity,Service,,,,,,,,,,10200,,,,, +Other,Capital,,,,,2180,,-800,,,,,,,,-325 +Other,Rest of World,,,,,,,,150,440,95,,,,, diff --git a/tests/pytensorf/test_compile.py b/tests/pytensorf/test_compile.py index 3d92689..73d6184 100644 --- a/tests/pytensorf/test_compile.py +++ b/tests/pytensorf/test_compile.py @@ -58,13 +58,10 @@ def test_compile_to_pytensor(model_func, kwargs): n_variables = n_eq = len(cge_model.unpacked_variable_names) n_params = len(cge_model.unpacked_parameter_names) - (variables, parameters), (model, jac, jac_inv, B) = compile_cge_model_to_pytensor( - cge_model - ) + (variables, parameters), (model, jac, B) = compile_cge_model_to_pytensor(cge_model) assert model.type.shape == (n_eq,) assert jac.type.shape == (n_eq, n_variables) - assert jac_inv.type.shape == (n_eq, n_variables) assert B.type.shape == (n_eq, n_params) @@ -81,10 +78,11 @@ def f_analytic(v3): return np.array([v1, v2]) mode = "FAST_COMPILE" - A_inv = pt.linalg.inv(make_jacobian(equations, variables)) + + A = make_jacobian(equations, variables) B = make_jacobian(equations, [parameters]) f_1 = compile_euler_approximation_function( - A_inv=A_inv, + A=A, B=B, variables=variables, parameters=[parameters], @@ -92,7 +90,7 @@ def f_analytic(v3): mode=mode, ) f_10 = compile_euler_approximation_function( - A_inv=A_inv, + A=A, B=B, variables=variables, parameters=[parameters], @@ -100,7 +98,7 @@ def f_analytic(v3): mode=mode, ) f_100 = compile_euler_approximation_function( - A_inv=A_inv, + A=A, B=B, variables=variables, parameters=[parameters], @@ -108,7 +106,7 @@ def f_analytic(v3): mode=mode, ) f_10k = compile_euler_approximation_function( - A_inv=A_inv, + A=A, B=B, variables=variables, parameters=[parameters], diff --git a/tests/pytensorf/test_optimize.py b/tests/pytensorf/test_optimize.py index 7ecc829..9e57636 100644 --- a/tests/pytensorf/test_optimize.py +++ b/tests/pytensorf/test_optimize.py @@ -33,16 +33,15 @@ def test_simple_root(): eq2 = x - y**2 + 1 system = pt.stack([eq1, eq2]) jac = pt.stack(pytensor.gradient.jacobian(system, [x, y])) - jac_inv = pt.linalg.solve(jac, pt.identity_like(jac)) f = pytensor.compile.builders.OpFromGraph([x, y], [system]) - f_jac_inv = pytensor.compile.builders.OpFromGraph([x, y], [jac_inv]) + f_jac = pytensor.compile.builders.OpFromGraph([x, y], [jac]) x_val = 1.0 y_val = 1.0 root_histories, converged, step_size, n_steps = root( - f, f_jac_inv, {"x": x_val, "y": y_val} + f, f_jac, {"x": x_val, "y": y_val} ) final_root = _postprocess_root_return(root_histories) @@ -69,16 +68,15 @@ def f_model(Y, C, L_d, K_d, P, r, resid, K_s, L_s, A, alpha, w): equations = f_model(*variables, *params) jac = pt.stack(pytensor.gradient.jacobian(equations, variables)).T - jac_inv = pt.linalg.solve(jac, pt.identity_like(jac), check_finite=False) - f_jac_inv = pytensor.compile.builders.OpFromGraph( - variables + params, outputs=[jac_inv], inline=True + f_jac = pytensor.compile.builders.OpFromGraph( + variables + params, outputs=[jac], inline=True ) x0 = {"Y": 11000, "C": 11000, "L_d": 7000, "K_d": 4000, "r": 1, "P": 1, "resid": 0} param_vals = {"K_s": 4000, "L_s": 7000, "A": 2, "alpha": 0.33, "w": 1} root_histories, converged, step_size, n_steps = root( - f_model, f_jac_inv, initial_data=x0, parameters=param_vals + f_model, f_jac, initial_data=x0, parameters=param_vals ) root_eval = _postprocess_root_return(root_histories) @@ -106,9 +104,7 @@ def test_small_model_from_compile(): mod = load_model_1( parse_equations_to_sympy=False, backend="pytensor", compile=False ) - (f_model, f_jac, f_jac_inv) = compile_cge_model_to_pytensor_Op( - mod, inverse_method="solve" - ) + f_model, f_jac = compile_cge_model_to_pytensor_Op(mod) data = { "Y": 11000.0, "C": 11000.0, @@ -136,7 +132,7 @@ def test_small_model_from_compile(): root_histories, converged, step_size, n_steps = root( f_model, - f_jac_inv, + f_jac, initial_data=sorted_data, parameters=sorted_params, tol=1e-8, @@ -174,12 +170,9 @@ def test_sector_model_from_compile(): x0 = {var.name: calib_dict[var.name] for var in mod.variables} params = {param.name: calib_dict[param.name] for param in mod.parameters} - f_model, f_jac, f_jac_inv = compile_cge_model_to_pytensor_Op( - mod, inverse_method="solve" - ) - + f_model, f_jac = compile_cge_model_to_pytensor_Op(mod) root_history, converged, step_size, n_steps = root( - f_model, f_jac_inv, initial_data=x0, parameters=params, tol=1e-8, max_iter=500 + f_model, f_jac, initial_data=x0, parameters=params, tol=1e-8, max_iter=500 ) root_eval = _postprocess_root_return(root_history) diff --git a/tests/test_production_functions.py b/tests/test_production_functions.py index ed6b315..0d6525b 100644 --- a/tests/test_production_functions.py +++ b/tests/test_production_functions.py @@ -350,7 +350,8 @@ def dx_X(Y, A, alpha, P_Y, P_X, epsilon): if backend == "numba": eq = sp.parse_expr(eq_production, transformations="all", local_dict=local_dict) - f_eq = sp.lambdify(inputs, eq.rhs) + + f_eq = sp.lambdify(inputs, eq.rhs.doit()) k = len(coords["f"]) sympy_out = f_eq( @@ -604,7 +605,7 @@ def leontief_VC(Y, phi_VC, *args, **kwargs): if backend == "numba": eq = sp.parse_expr(zero_profit, transformations="all", local_dict=local_dict) - f_eq = sp.lambdify(inputs, eq.rhs) + f_eq = sp.lambdify(inputs, eq.rhs.doit()) k = len(coords["i"]) sympy_out = f_eq( diff --git a/tests/test_pytensorf.py b/tests/test_pytensorf.py index bc508ef..d98319f 100644 --- a/tests/test_pytensorf.py +++ b/tests/test_pytensorf.py @@ -33,11 +33,10 @@ def test_euler_approximation_2d(): equations = pt.stack([v1**2 * v3 - 1, v1 + v2 - 2]) A = make_jacobian(equations, variables) - A_inv = pt.linalg.solve(A, pt.identity_like(A)) B = make_jacobian(equations, [parameters]) theta_final, result = euler_approximation( - A_inv, B, variables=variables, parameters=[parameters], n_steps=n_steps + A, B, variables=variables, parameters=[parameters], n_steps=n_steps ) f = pytensor.function(inputs + [theta_final, n_steps], result) diff --git a/tests/test_rebalance.py b/tests/test_rebalance.py index f3c8198..814cde3 100644 --- a/tests/test_rebalance.py +++ b/tests/test_rebalance.py @@ -26,7 +26,7 @@ def test_SAM_transformer(): def test_cross_entropy_rebalance(): - df = pd.read_csv("data/unbalanced_sam.csv", index_col=[0, 1], header=[0, 1]) + df = pd.read_csv("tests/data/unbalanced_sam.csv", index_col=[0, 1], header=[0, 1]) df2, optim_res = balance_SAM(df) assert optim_res.success assert np.allclose(df2.sum(axis=0), df2.sum(axis=1))