From 248ad7b4a9fe09d0e3ec382546e71de986ab2b12 Mon Sep 17 00:00:00 2001 From: Robert Gieseke Date: Tue, 10 Dec 2024 12:01:09 +0100 Subject: [PATCH] Add Scipy based solver As tests are comparing with original PyMC3 results, the tolerances are set to larger tolerances. Co-authored-by: Sven Willner Co-authored-by: Robert Gieseke --- attrici/commands/detrend.py | 2 +- attrici/detrend.py | 4 + attrici/estimation/model_pymc5.py | 5 + attrici/estimation/model_scipy.py | 314 +++++++++ notebooks/optimization-with-scipy.ipynb | 604 ++++++++++++++++++ notebooks/solver-comparison.ipynb | 313 +++++++++ ...{test_detrend.py => test_detrend_pymc5.py} | 5 +- tests/test_detrend_scipy.py | 110 ++++ 8 files changed, 1354 insertions(+), 3 deletions(-) create mode 100644 attrici/estimation/model_scipy.py create mode 100644 notebooks/optimization-with-scipy.ipynb create mode 100644 notebooks/solver-comparison.ipynb rename tests/{test_detrend.py => test_detrend_pymc5.py} (95%) create mode 100644 tests/test_detrend_scipy.py diff --git a/attrici/commands/detrend.py b/attrici/commands/detrend.py index 96a3641..267b629 100644 --- a/attrici/commands/detrend.py +++ b/attrici/commands/detrend.py @@ -106,7 +106,7 @@ def add_parser(subparsers): group.add_argument( "--solver", type=str, - choices=["pymc5"], + choices=["pymc5", "scipy"], default="pymc5", help="Solver library for statistical modelling", ) diff --git a/attrici/detrend.py b/attrici/detrend.py index bd6f1c3..b977333 100644 --- a/attrici/detrend.py +++ b/attrici/detrend.py @@ -383,6 +383,10 @@ def detrend(config: Config): from attrici.estimation.model_pymc5 import ModelPymc5 model_class = ModelPymc5 + elif config.solver == "scipy": + from attrici.estimation.model_scipy import ModelScipy + + model_class = ModelScipy else: raise ValueError(f"Unknown solver {config.solver}") diff --git a/attrici/estimation/model_pymc5.py b/attrici/estimation/model_pymc5.py index 4b88fe6..a2daa43 100644 --- a/attrici/estimation/model_pymc5.py +++ b/attrici/estimation/model_pymc5.py @@ -1,3 +1,5 @@ +# Suppress verbose PyMC logging output +import logging from dataclasses import dataclass import numpy as np @@ -7,6 +9,9 @@ from attrici import distributions from attrici.estimation.model import AttriciGLM, Model +logger = logging.getLogger("pymc") +logger.setLevel(logging.WARNING) + def setup_parameter_model(name, parameter): if isinstance(parameter, AttriciGLM.PredictorDependentParam): diff --git a/attrici/estimation/model_scipy.py b/attrici/estimation/model_scipy.py new file mode 100644 index 0000000..aceddaf --- /dev/null +++ b/attrici/estimation/model_scipy.py @@ -0,0 +1,314 @@ +from dataclasses import dataclass +from typing import Any, Callable + +import numpy as np +from scipy import stats +from scipy.optimize import minimize + +from attrici import distributions +from attrici.estimation.model import AttriciGLM, Model + + +def setup_parameter_model(name, parameter, params_first_index): + if isinstance(parameter, AttriciGLM.PredictorDependentParam): + return AttriciGLMScipy.PredictorDependentParam( + name=name, parameter=parameter, params_first_index=params_first_index + ) + if isinstance(parameter, AttriciGLM.PredictorIndependentParam): + return AttriciGLMScipy.PredictorIndependentParam( + name=name, parameter=parameter, params_first_index=params_first_index + ) + raise ValueError(f"Parameter type {type(parameter)} not supported") + + +def calc_oscillations(t, modes): + t_scaled = (t - t.min()) / (np.timedelta64(365, "D") + np.timedelta64(6, "h")) + x = (2 * np.pi * (np.arange(modes) + 1)) * t_scaled.values[:, None] + return np.concatenate((np.cos(x), np.sin(x)), axis=1) + + +class ParameterScipy: + pass + + +class AttriciGLMScipy: + PRIOR_INTERCEPT_MU = 0 + PRIOR_INTERCEPT_SIGMA = 1 + PRIOR_TREND_MU = 0 + PRIOR_TREND_SIGMA = 0.1 + + @dataclass + class PredictorDependentParam(ParameterScipy): + name: str + params_first_index: int + parameter: AttriciGLM.PredictorDependentParam + covariates: Any = None + + def get_initial_params(self): + return np.zeros(2 + 4 * self.parameter.modes) + + def estimate(self, params): + weights_longterm_intercept = params[self.params_first_index] + weights_longterm_trend = params[self.params_first_index + 1] + weights_fc_intercept = params[ + self.params_first_index + 2 : self.params_first_index + + 2 + + 2 * self.parameter.modes + ] + weights_fc_trend = params[ + self.params_first_index + + 2 + + 2 * self.parameter.modes : self.params_first_index + + 2 + + 4 * self.parameter.modes + ] + + logp_prior = stats.norm.logpdf( + weights_longterm_intercept, + loc=AttriciGLMScipy.PRIOR_INTERCEPT_MU, + scale=AttriciGLMScipy.PRIOR_INTERCEPT_SIGMA, + ) + logp_prior += stats.norm.logpdf( + weights_longterm_trend, + loc=AttriciGLMScipy.PRIOR_TREND_MU, + scale=AttriciGLMScipy.PRIOR_TREND_SIGMA, + ) + logp_prior += np.sum( + [ + stats.norm.logpdf( + weights_fc_intercept[i], + loc=AttriciGLMScipy.PRIOR_INTERCEPT_MU, + scale=1 / (2 * i + 1), + ) + for i in range(self.parameter.modes) + ] + ) + logp_prior += np.sum( + [ + stats.norm.logpdf( + weights_fc_trend[i], + loc=AttriciGLMScipy.PRIOR_TREND_MU, + scale=AttriciGLMScipy.PRIOR_TREND_SIGMA, + ) + for i in range(self.parameter.modes) + ] + ) + + weights_fc = np.concatenate([weights_fc_intercept, weights_fc_trend]) + return ( + np.dot(self.covariates, weights_fc) + + weights_longterm_intercept + + weights_longterm_trend * self.predictor + ), logp_prior + + def set_predictor_data(self, data): + oscillations = calc_oscillations(data.time, self.parameter.modes) + self.covariates = np.concatenate( + [ + oscillations, + np.tile(data.values[:, None], (1, 2 * self.parameter.modes)) + * oscillations, + ], + axis=1, + ) + self.predictor = data + + @dataclass + class PredictorIndependentParam(ParameterScipy): + name: str + params_first_index: int + parameter: AttriciGLM.PredictorIndependentParam + oscillations: Any = None + + def get_initial_params(self): + return np.zeros(1 + 2 * self.parameter.modes) + + def estimate(self, params): + weights_longterm_intercept = params[self.params_first_index] + weights_fc_intercept = params[ + self.params_first_index + 1 : self.params_first_index + + 1 + + 2 * self.parameter.modes + ] + logp_prior = stats.norm.logpdf( + weights_longterm_intercept, + loc=AttriciGLMScipy.PRIOR_INTERCEPT_MU, + scale=AttriciGLMScipy.PRIOR_INTERCEPT_SIGMA, + ) + logp_prior += np.sum( + [ + stats.norm.logpdf( + weights_fc_intercept[i], + loc=AttriciGLMScipy.PRIOR_INTERCEPT_MU, + scale=1 / (2 * i + 1), + ) + for i in range(self.parameter.modes) + ] + ) + + return ( + self.parameter.link( + np.dot(self.oscillations, weights_fc_intercept) + + weights_longterm_intercept + ), + logp_prior, + ) + + def set_predictor_data(self, data): + self.oscillations = calc_oscillations(data.time, self.parameter.modes) + + +@dataclass +class DistributionScipy: + logpdf: Callable + parameters: dict[str, ParameterScipy] + observed: Any + + def log_likelihood(self, params): + res = 0 + params_dict = {} + for name, parameter in self.parameters.items(): + p, logp = parameter.estimate(params) + res += logp + params_dict[name] = p + return res + np.sum(self.logpdf(self.observed, **params_dict)) + + +def distribution_beta(x, mu, phi): + return stats.beta.logpdf(x, mu * phi, (1 - mu) * phi) + + +def distributions_gamma(x, mu, nu): + return stats.gamma.logpdf(x, nu**2, scale=mu / nu**2) + + +class ModelScipy(Model): + def __init__( + self, + distribution, + parameters, + observed, + predictor, + ): + self._distribution_class = distribution + self._distributions = [] + self._initial_params = np.asarray([]) + self._parameter_models = {} + for name, parameter in parameters.items(): + p = setup_parameter_model(name, parameter, len(self._initial_params)) + self._initial_params = np.concatenate( + [self._initial_params, p.get_initial_params()] + ) + self._parameter_models[name] = p + + if distribution == distributions.BernoulliGamma: + observed_gamma = observed.sel(time=observed.notnull()) + + p = self._parameter_models["p"] + p.set_predictor_data(predictor) + mu = self._parameter_models["mu"] + mu.set_predictor_data(predictor.sel(time=observed_gamma.time)) + nu = self._parameter_models["nu"] + nu.set_predictor_data(predictor.sel(time=observed_gamma.time)) + + self._distributions.append( + DistributionScipy( + logpdf=distributions_gamma, + parameters={"mu": mu, "nu": nu}, + observed=observed_gamma, + ) + ) + self._distributions.append( + DistributionScipy( + logpdf=stats.bernoulli.logpmf, + parameters={"p": p}, + observed=np.isnan(observed.values).astype(int), + ) + ) + + elif distribution == distributions.Bernoulli: + p = self._parameter_models["p"] + p.set_predictor_data(predictor) + self._distributions.append( + DistributionScipy( + logpdf=stats.bernoulli.logpmf, + parameters={"p": p}, + observed=observed, + ) + ) + + elif distribution == distributions.Gamma: + mu = self._parameter_models["mu"] + mu.set_predictor_data(predictor) + nu = self._parameter_models["nu"] + nu.set_predictor_data(predictor) + self._distributions.append( + DistributionScipy( + logpdf=distributions_gamma, + parameters={"mu": mu, "nu": nu}, + observed=observed, + ) + ) + + elif distribution == distributions.Normal: + mu = self._parameter_models["mu"] + mu.set_predictor_data(predictor) + sigma = self._parameter_models["sigma"] + sigma.set_predictor_data(predictor) + self._distributions.append( + DistributionScipy( + logpdf=stats.norm.logpdf, + parameters={"loc": mu, "scale": sigma}, + observed=observed, + ) + ) + + elif distribution == distributions.Beta: + mu = self._parameter_models["mu"] + mu.set_predictor_data(predictor) + phi = self._parameter_models["phi"] + phi.set_predictor_data(predictor) + self._distributions.append( + DistributionScipy( + logpdf=distribution_beta, + parameters={"mu": mu, "phi": phi}, + observed=observed, + ) + ) + + elif distribution == distributions.Weibull: + alpha = self._parameter_models["alpha"] + alpha.set_predictor_data(predictor) + beta = self._parameter_models["beta"] + beta.set_predictor_data(predictor) + self._distributions.append( + DistributionScipy( + logpdf=stats.weibull_min.logpdf, + parameters={"c": alpha, "scale": beta}, + observed=observed, + ) + ) + + else: + raise ValueError(f"Distribution {distribution} not supported") + + def fit(self, **_): + result = minimize( + lambda params: -sum(d.log_likelihood(params) for d in self._distributions), + self._initial_params, + method="L-BFGS-B", + ) + self.logp = -result.fun + self.trace = result.x + return self.trace + + def estimate_logp(self, **_): + return self.logp + + def estimate_distribution(self, predictor, **_): + params = {} + for name, parameter_model in self._parameter_models.items(): + parameter_model.set_predictor_data(predictor) + params[name], _ = parameter_model.estimate(self.trace) + + return self._distribution_class(**params) diff --git a/notebooks/optimization-with-scipy.ipynb b/notebooks/optimization-with-scipy.ipynb new file mode 100644 index 0000000..06a9b34 --- /dev/null +++ b/notebooks/optimization-with-scipy.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1d07aa2-a4a1-4836-b89a-f00f1798f6a2", + "metadata": {}, + "source": [ + "# Optimization with Scipy\n", + "\n", + "The Attrici publication in GMD used the PyMC3 library to derive the results. This notebook shows how to estimate these counterfactuals using Scipy only, exemplarily for the `tas` variable in a single geographical cell." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fbaf89d5-9f81-4ae1-870f-96b5bce7e377", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from attrici.distributions import Normal\n", + "from attrici.variables import Tas\n", + "from scipy import stats\n", + "from scipy.optimize import minimize" + ] + }, + { + "cell_type": "markdown", + "id": "b1494c0d-68ea-4744-96c1-6cfeb5c1cee0", + "metadata": {}, + "source": [ + "## Functions for estimation using Scipy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d8c516bb-67b9-40f1-aa4c-21e57044850b", + "metadata": {}, + "outputs": [], + "source": [ + "# constants for prior distributions for mu and sigma:\n", + "PRIOR_INTERCEPT_MU = 0\n", + "PRIOR_INTERCEPT_SIGMA = 1\n", + "PRIOR_TREND_MU = 0\n", + "PRIOR_TREND_SIGMA = 0.1" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fafc1caf-870a-4730-87b5-89d4806ef82b", + "metadata": {}, + "outputs": [], + "source": [ + "def linear_model_independent_param(\n", + " oscillations, weights_fc_intercept, weights_longterm_intercept\n", + "):\n", + " return np.dot(oscillations, weights_fc_intercept) + weights_longterm_intercept" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "31308368-e740-4298-ac22-91275564aab7", + "metadata": {}, + "outputs": [], + "source": [ + "def linear_model_dependent_param(\n", + " covariates,\n", + " weights_fc_intercept,\n", + " weights_longterm_intercept,\n", + " weights_fc_trend,\n", + " weights_longterm_trend,\n", + " predictor,\n", + "):\n", + " weights_fc = np.concatenate([weights_fc_intercept, weights_fc_trend])\n", + " return (\n", + " np.dot(covariates, weights_fc)\n", + " + weights_longterm_intercept\n", + " + weights_longterm_trend * predictor\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "67b8fc88-7c83-4bb8-9cf1-c7bfc30e2739", + "metadata": {}, + "outputs": [], + "source": [ + "def get_mu(params, predictor, covariates, modes):\n", + " # get the respective weights (which are the control variables to the optimization) from params:\n", + " weights_mu_longterm_intercept = params[0]\n", + " weights_mu_longterm_trend = params[1]\n", + " weights_mu_fc_intercept = params[2 : 2 + 2 * modes]\n", + " weights_mu_fc_trend = params[2 + 2 * modes : 2 + 4 * modes]\n", + "\n", + " # also calculate the logp according to all prior distributions:\n", + " logp_prior = stats.norm.logpdf(\n", + " weights_mu_longterm_intercept,\n", + " loc=PRIOR_INTERCEPT_MU,\n", + " scale=PRIOR_INTERCEPT_SIGMA,\n", + " )\n", + " logp_prior += stats.norm.logpdf(\n", + " weights_mu_longterm_trend, loc=PRIOR_TREND_MU, scale=PRIOR_TREND_SIGMA\n", + " )\n", + " logp_prior += np.sum(\n", + " [\n", + " stats.norm.logpdf(\n", + " weights_mu_fc_intercept[i],\n", + " loc=PRIOR_INTERCEPT_MU,\n", + " scale=1 / (2 * i + 1),\n", + " )\n", + " for i in range(modes)\n", + " ]\n", + " )\n", + " logp_prior += np.sum(\n", + " [\n", + " stats.norm.logpdf(\n", + " weights_mu_fc_trend[i], loc=PRIOR_TREND_MU, scale=PRIOR_TREND_SIGMA\n", + " )\n", + " for i in range(modes)\n", + " ]\n", + " )\n", + "\n", + " return (\n", + " linear_model_dependent_param(\n", + " covariates,\n", + " weights_mu_fc_intercept,\n", + " weights_mu_longterm_intercept,\n", + " weights_mu_fc_trend,\n", + " weights_mu_longterm_trend,\n", + " predictor,\n", + " ),\n", + " logp_prior,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "8a026bb8-1d7a-46e0-8416-95781ba8e365", + "metadata": {}, + "outputs": [], + "source": [ + "def get_sigma(params, oscillations, modes):\n", + " # get the respective weights (which are the control variables to the optimization) from params:\n", + " weights_sigma_longterm_intercept = params[2 + 4 * modes]\n", + " weights_sigma_fc_intercept = params[3 + 4 * modes : 3 + 6 * modes]\n", + "\n", + " # also calculate the logp according to all prior distributions:\n", + " logp_prior = stats.norm.logpdf(\n", + " weights_sigma_longterm_intercept,\n", + " loc=PRIOR_INTERCEPT_MU,\n", + " scale=PRIOR_INTERCEPT_SIGMA,\n", + " )\n", + " logp_prior += np.sum(\n", + " [\n", + " stats.norm.logpdf(\n", + " weights_sigma_fc_intercept[i],\n", + " loc=PRIOR_INTERCEPT_MU,\n", + " scale=1 / (2 * i + 1),\n", + " )\n", + " for i in range(modes)\n", + " ]\n", + " )\n", + "\n", + " return (\n", + " np.exp(\n", + " linear_model_independent_param(\n", + " oscillations,\n", + " weights_sigma_fc_intercept,\n", + " weights_sigma_longterm_intercept,\n", + " )\n", + " ),\n", + " logp_prior,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "92a1a166-7b04-4002-82fb-6e95ac1b1e7d", + "metadata": {}, + "outputs": [], + "source": [ + "def calc_oscillations(t, modes):\n", + " t_scaled = (t - t.min()) / (np.timedelta64(365, \"D\") + np.timedelta64(6, \"h\"))\n", + " x = (2 * np.pi * (np.arange(modes) + 1)) * t_scaled.values[:, None]\n", + " return np.concatenate((np.cos(x), np.sin(x)), axis=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d7b0822f-ec5c-4649-a4a7-00e6bb0358dc", + "metadata": {}, + "outputs": [], + "source": [ + "def calc_covariates(oscillations, predictor, modes):\n", + " return np.concatenate(\n", + " [oscillations, np.tile(predictor[:, None], (1, 2 * modes)) * oscillations],\n", + " axis=1,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "c4baadcf-03b2-4e4c-80b3-1251bdcb360c", + "metadata": {}, + "source": [ + "`log_likelihood` is the cost function for the optimization:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "55191edb-a8f3-420b-a0c3-2bf7c7ef4a54", + "metadata": {}, + "outputs": [], + "source": [ + "def log_likelihood(params, oscillations, predictor, covariates, modes, y):\n", + " mu, logp_mu = get_mu(params, predictor, covariates, modes)\n", + " sigma, logp_sigma = get_sigma(params, oscillations, modes)\n", + " logp = np.sum(\n", + " stats.norm.logpdf(\n", + " y,\n", + " loc=mu,\n", + " scale=sigma,\n", + " )\n", + " )\n", + " # also add logp for the prior distributions:\n", + " logp += logp_mu\n", + " logp += logp_sigma\n", + "\n", + " return -logp" + ] + }, + { + "cell_type": "markdown", + "id": "a567b7b7-754c-492b-9d7d-118c95990428", + "metadata": {}, + "source": [ + "`estimate_parameters` does the actual optimization:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "7390766a-d20c-4b58-9706-75e8f26ef168", + "metadata": {}, + "outputs": [], + "source": [ + "def estimate_parameters(predictor, oscillations, y, modes):\n", + " # the weights are the control variables to be estimated by the optimization\n", + " # from the perspective of scipy these are just squashed into a params array\n", + " initial_params = np.concatenate(\n", + " [\n", + " np.zeros(1), # weights_mu_longterm_intercept\n", + " np.zeros(1), # weights_mu_longterm_trend\n", + " np.zeros(2 * modes), # weights_mu_fc_intercept\n", + " np.zeros(2 * modes), # weights_mu_fc_trend\n", + " np.zeros(1), # weights_sigma_longterm_intercept\n", + " np.zeros(2 * modes), # weights_sigma_fc_intercept\n", + " ]\n", + " )\n", + "\n", + " # do the actual optimization and return the optimal control parameter\n", + " # values, i.e. the weights:\n", + " result = minimize(\n", + " log_likelihood,\n", + " initial_params,\n", + " args=(\n", + " oscillations,\n", + " predictor,\n", + " calc_covariates(oscillations, predictor, modes),\n", + " modes,\n", + " y,\n", + " ),\n", + " method=\"L-BFGS-B\",\n", + " )\n", + "\n", + " return result.x" + ] + }, + { + "cell_type": "markdown", + "id": "4fa7b679-9c7e-4697-85ab-23118456893e", + "metadata": {}, + "source": [ + "`detrend` estimates the posterior distribution's parameters and maps the quantiles to yield the counterfactual time series:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "2e147d44-992b-4aa7-ac25-ef580586df8d", + "metadata": {}, + "outputs": [], + "source": [ + "def detrend(predictor, y, stopdate, modes=4):\n", + " # do the actual fit to the data until stopdate:\n", + " times = predictor.time[predictor.time <= np.datetime64(stopdate)]\n", + " assert not np.any(y.sel(time=times).isnull())\n", + " predictor_fit = predictor.sel(time=times)\n", + " optimized_params = estimate_parameters(\n", + " predictor_fit.values,\n", + " calc_oscillations(times, modes),\n", + " y.sel(time=times),\n", + " modes,\n", + " )\n", + "\n", + " # for estimating ('sampling') the posterior distribution's parameters (mu, sigma),\n", + " # we use the full time series ('ref') as well as the counterfactual with zero predictor\n", + " # (i.e. GMT=0; 'cfact'):\n", + " oscillations = calc_oscillations(predictor.time, modes)\n", + "\n", + " mu_ref, _ = get_mu(\n", + " optimized_params,\n", + " predictor.values,\n", + " calc_covariates(oscillations, predictor.values, modes),\n", + " modes,\n", + " )\n", + " sigma_ref, _ = get_sigma(optimized_params, oscillations, modes)\n", + "\n", + " # for the counterfactual we assume predictor (=GMT) = 0\n", + " predictor_cfact_values = np.zeros_like(predictor.values)\n", + " mu_cfact, _ = get_mu(\n", + " optimized_params,\n", + " predictor_cfact_values,\n", + " calc_covariates(oscillations, predictor_cfact_values, modes),\n", + " modes,\n", + " )\n", + " sigma_cfact, _ = get_sigma(optimized_params, oscillations, modes)\n", + "\n", + " distribution_ref = Normal(mu_ref, sigma_ref)\n", + " distribution_cfact = Normal(mu_cfact, sigma_cfact)\n", + "\n", + " cfact_scaled = distribution_cfact.invcdf(distribution_ref.cdf(y))\n", + "\n", + " return cfact_scaled" + ] + }, + { + "cell_type": "markdown", + "id": "4cbafc48-50b1-4587-b72e-8410cc20c192", + "metadata": {}, + "source": [ + "## Estimation and comparison to desired/target data" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "5c41cf2d-45b8-4701-87d0-caedb1a0ce82", + "metadata": {}, + "outputs": [], + "source": [ + "obs_data = xr.load_dataset(\"../tests/data/20CRv3-ERA5_germany_obs.nc\").tas\n", + "gmt = xr.load_dataset(\"../tests/data/20CRv3-ERA5_germany_ssa_gmt.nc\").tas" + ] + }, + { + "cell_type": "markdown", + "id": "761fab92-9b23-4a3e-ad3d-e63e3623b656", + "metadata": {}, + "source": [ + "First, we interpolate and scale the preditor, GMT:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a0384419-7638-4a33-aabf-ebe9c212ccac", + "metadata": {}, + "outputs": [], + "source": [ + "t_scaled = (obs_data.time - obs_data.time.min()) / (\n", + " obs_data.time.max() - obs_data.time.min()\n", + ")\n", + "\n", + "gmt_on_obs_times = np.interp(t_scaled, np.linspace(0, 1, len(gmt)), gmt)\n", + "gmt_scaled_values = (gmt_on_obs_times - gmt_on_obs_times.min()) / (\n", + " gmt_on_obs_times.max() - gmt_on_obs_times.min()\n", + ")\n", + "gmt_scaled = xr.DataArray(\n", + " gmt_scaled_values, coords={\"time\": obs_data.time}, dims=(\"time\",)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "77385201-d4bf-475d-aa93-529e743aa582", + "metadata": {}, + "source": [ + "Also, create a variable object of class `Tas`, which internally scales the data (to `var.y_scaled`):" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "a5f158df-5fe2-4f2e-9a78-48281723c5c8", + "metadata": {}, + "outputs": [], + "source": [ + "var = Tas(obs_data.sel(lon=9.25, lat=50.75))" + ] + }, + { + "cell_type": "markdown", + "id": "b842b6d9-51bd-4b42-b3ca-345d168c4ef5", + "metadata": {}, + "source": [ + "Now calculate the counterfactual using Scipy only:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "ab0cbfbd-d944-4b29-a187-7993a9434fcc", + "metadata": {}, + "outputs": [], + "source": [ + "cfact_scaled = detrend(gmt_scaled, var.y_scaled, \"2021-12-31\")" + ] + }, + { + "cell_type": "markdown", + "id": "723dfbdf-cbca-48c1-950b-28ac6d264727", + "metadata": {}, + "source": [ + "and rescale it according the the scaling done before:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "0cada712-4fc2-490e-b1fe-c13f72226299", + "metadata": {}, + "outputs": [], + "source": [ + "cfact = cfact_scaled * var.scale.item() + var.datamin.item()" + ] + }, + { + "cell_type": "markdown", + "id": "1216fe17-0312-4fa9-808e-3e111ce29043", + "metadata": {}, + "source": [ + "Now load the target ('desired') data and store both `desired` and `scipy` counterfactuals in the date frame:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "52abeebe-8c65-4c67-97ed-6a6ffa7aa2bf", + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_hdf(\"../tests/data/20CRv3-ERA5_germany_target_tas_lat50.75_lon9.25.h5\")\n", + "data[\"time\"] = data.ds\n", + "data.index = data.time\n", + "data[\"desired\"] = data.cfact\n", + "data[\"scipy\"] = cfact" + ] + }, + { + "cell_type": "markdown", + "id": "e92f6175-bde1-4622-9332-bee51a6f5577", + "metadata": {}, + "source": [ + "### Differences" + ] + }, + { + "cell_type": "markdown", + "id": "63bce432-56e6-4f1a-9ac9-ce3446114388", + "metadata": {}, + "source": [ + "Differences between both time series (actual and desired) are:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f0f10138-c491-4453-b791-1905c34cf084", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "(data.desired - data.scipy).plot();" + ] + }, + { + "cell_type": "markdown", + "id": "a10fff73-a7ef-466e-84af-23c70ec2b2d9", + "metadata": {}, + "source": [ + "On an absolute scale, these differences are minor (here, for a single year)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "18d2d711-263b-4779-8866-5efa34d38523", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "year = \"2015\"\n", + "data.desired.loc[year].plot(ax=ax, label=\"desired\")\n", + "data.scipy.loc[year].plot(ax=ax, label=\"scipy\")\n", + "ax.legend(frameon=False);" + ] + }, + { + "cell_type": "markdown", + "id": "3c362703-990d-4ffa-8922-ee37481b4294", + "metadata": {}, + "source": [ + "As can be seen from the histogram below, the overall distributions match fairly well:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "67318d09-f047-4aff-9c43-4ade42c8f920", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots()\n", + "data.desired.hist(ax=ax, bins=50, label=\"desired\", orientation=\"horizontal\", alpha=0.5)\n", + "data.scipy.hist(ax=ax, bins=50, label=\"scipy\", orientation=\"horizontal\", alpha=0.5)\n", + "ax.legend(frameon=False);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d2f524f-163f-4d52-b12e-64e084f5ad30", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/solver-comparison.ipynb b/notebooks/solver-comparison.ipynb new file mode 100644 index 0000000..5799e0d --- /dev/null +++ b/notebooks/solver-comparison.ipynb @@ -0,0 +1,313 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a1d07aa2-a4a1-4836-b89a-f00f1798f6a2", + "metadata": {}, + "source": [ + "# Comparison of solvers\n", + "\n", + "This notebook shows how to estimate the counterfactual with Scipy and PyMC5 and creates comparison plots" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "fbaf89d5-9f81-4ae1-870f-96b5bce7e377", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import xarray as xr\n", + "from attrici.detrend import Config, detrend\n", + "from pathlib import Path\n", + "\n", + "from loguru import logger\n", + "\n", + "logger.remove()" + ] + }, + { + "cell_type": "markdown", + "id": "4cbafc48-50b1-4587-b72e-8410cc20c192", + "metadata": {}, + "source": [ + "## Estimation and comparison to desired/target data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "8501659a-4dbf-43d8-b28d-941cd3fb523a", + "metadata": {}, + "outputs": [], + "source": [ + "variable_name = \"tas\"" + ] + }, + { + "cell_type": "markdown", + "id": "f9d42bcd-7e6c-40ff-83b4-19f9792a6f4f", + "metadata": {}, + "source": [ + "## PyMC5 run" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "606a6739-4904-4fba-8ff7-3fda9ac5aaef", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n", + "/home/robert/Projects/attrici/attrici-private/env/lib/python3.12/site-packages/tables/path.py:137: NaturalNameWarning: object name is not a valid Python identifier: 'lat_50.75_lon_9.25'; it does not match the pattern ``^[a-zA-Z_][a-zA-Z0-9_]*$``; you will not be able to use natural naming to access this object; using ``getattr()`` will still work, though\n", + " check_attribute_name(name)\n" + ] + } + ], + "source": [ + "config = Config(\n", + " gmt_file=Path(\"../tests/data/20CRv3-ERA5_germany_ssa_gmt.nc\"),\n", + " input_file=Path(\"../tests/data/20CRv3-ERA5_germany_obs.nc\"),\n", + " mask_file=Path(\"../tests/data/mask_lat50.75_lon9.25.nc\"),\n", + " variable=variable_name,\n", + " output_dir=Path(\"../tests/data/output/pymc5\"),\n", + " overwrite=True,\n", + " report_variables=[\"ds\", \"y\", \"cfact\"],\n", + " solver=\"pymc5\",\n", + " stop_date=\"2021-12-31\",\n", + ")\n", + "detrend(config)\n", + "\n", + "data_pymc5 = pd.read_hdf(\n", + " f\"../tests/data/output/pymc5/timeseries/{variable_name}/lat_50.75/ts_lat50.75_lon9.25.h5\"\n", + ")\n", + "data_pymc5[\"time\"] = data_pymc5.ds\n", + "data_pymc5.index = data_pymc5.time" + ] + }, + { + "cell_type": "markdown", + "id": "171646a6-721d-4f70-ad3a-83c4c922ad71", + "metadata": {}, + "source": [ + "## Scipy run" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "c51b7b4f-c5c3-49fe-a267-af7bc5ea7c0d", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/robert/Projects/attrici/attrici-private/env/lib/python3.12/site-packages/tables/path.py:137: NaturalNameWarning: object name is not a valid Python identifier: 'lat_50.75_lon_9.25'; it does not match the pattern ``^[a-zA-Z_][a-zA-Z0-9_]*$``; you will not be able to use natural naming to access this object; using ``getattr()`` will still work, though\n", + " check_attribute_name(name)\n" + ] + } + ], + "source": [ + "config = Config(\n", + " gmt_file=Path(\"../tests/data/20CRv3-ERA5_germany_ssa_gmt.nc\"),\n", + " input_file=Path(\"../tests/data/20CRv3-ERA5_germany_obs.nc\"),\n", + " mask_file=Path(\"../tests/data/mask_lat50.75_lon9.25.nc\"),\n", + " variable=variable_name,\n", + " output_dir=Path(\"../tests/data/output/scipy\"),\n", + " overwrite=True,\n", + " report_variables=[\"ds\", \"y\", \"cfact\"],\n", + " solver=\"scipy\",\n", + " stop_date=\"2021-12-31\",\n", + ")\n", + "detrend(config)\n", + "\n", + "data_scipy = pd.read_hdf(\n", + " f\"../tests/data/output/scipy/timeseries/{variable_name}/lat_50.75/ts_lat50.75_lon9.25.h5\"\n", + ")\n", + "data_scipy[\"time\"] = data_scipy.ds\n", + "data_scipy.index = data_scipy.time" + ] + }, + { + "cell_type": "markdown", + "id": "1216fe17-0312-4fa9-808e-3e111ce29043", + "metadata": {}, + "source": [ + "Now load the target ('desired') data and store both `desired` and `scipy` counterfactuals in the date frame:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "52abeebe-8c65-4c67-97ed-6a6ffa7aa2bf", + "metadata": {}, + "outputs": [], + "source": [ + "data = pd.read_hdf(\n", + " f\"../tests/data/20CRv3-ERA5_germany_target_{variable_name}_lat50.75_lon9.25.h5\"\n", + ")\n", + "data[\"time\"] = data.ds\n", + "data.index = data.time\n", + "data[\"desired\"] = data.cfact\n", + "data[\"pymc5\"] = data_pymc5.cfact.values\n", + "data[\"scipy\"] = data_scipy.cfact.values" + ] + }, + { + "cell_type": "markdown", + "id": "e92f6175-bde1-4622-9332-bee51a6f5577", + "metadata": {}, + "source": [ + "### Differences" + ] + }, + { + "cell_type": "markdown", + "id": "63bce432-56e6-4f1a-9ac9-ce3446114388", + "metadata": {}, + "source": [ + "Differences between both time series (actual and desired) are:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f0f10138-c491-4453-b791-1905c34cf084", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n", + "fig.suptitle(variable_name)\n", + "ax[0].set_title(\"PyMC5\")\n", + "ax[1].set_title(\"Scipy\")\n", + "(data.desired - data.pymc5).plot(ax=ax[0])\n", + "(data.desired - data.scipy).plot(ax=ax[1]);" + ] + }, + { + "cell_type": "markdown", + "id": "a10fff73-a7ef-466e-84af-23c70ec2b2d9", + "metadata": {}, + "source": [ + "A single year for comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "18d2d711-263b-4779-8866-5efa34d38523", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "year = \"2020\"\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(12, 4), sharey=True)\n", + "fig.suptitle(variable_name)\n", + "ax[0].set_title(\"PyMC5\")\n", + "ax[1].set_title(\"Scipy\")\n", + "\n", + "data.desired.loc[year].plot(ax=ax[0], label=\"desired\")\n", + "data.pymc5.loc[year].plot(ax=ax[0], label=\"pymc5\")\n", + "ax[0].legend(frameon=False)\n", + "data.desired.loc[year].plot(ax=ax[1], label=\"desired\")\n", + "data.scipy.loc[year].plot(ax=ax[1], label=\"scipy\")\n", + "ax[1].legend(frameon=False);" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "67318d09-f047-4aff-9c43-4ade42c8f920", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 2, figsize=(12, 4))\n", + "fig.suptitle(variable_name)\n", + "ax[0].set_title(\"PyMC5\")\n", + "ax[1].set_title(\"Scipy\")\n", + "\n", + "data.desired.hist(\n", + " ax=ax[0], bins=50, label=\"desired\", orientation=\"horizontal\", alpha=0.5\n", + ")\n", + "data.pymc5.hist(ax=ax[0], bins=50, label=\"pymc5\", orientation=\"horizontal\", alpha=0.5)\n", + "ax[0].legend(frameon=False)\n", + "data.desired.hist(\n", + " ax=ax[1], bins=50, label=\"desired\", orientation=\"horizontal\", alpha=0.5\n", + ")\n", + "data.scipy.hist(ax=ax[1], bins=50, label=\"scipy\", orientation=\"horizontal\", alpha=0.5)\n", + "ax[1].legend(frameon=False);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "423afd33-e65d-46aa-a452-7f3236f350ae", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/test_detrend.py b/tests/test_detrend_pymc5.py similarity index 95% rename from tests/test_detrend.py rename to tests/test_detrend_pymc5.py index 0dca436..066d761 100644 --- a/tests/test_detrend.py +++ b/tests/test_detrend_pymc5.py @@ -13,9 +13,10 @@ def detrend_run(variable_name): input_file=Path("./tests/data/20CRv3-ERA5_germany_obs.nc"), mask_file=Path("./tests/data/mask_lat50.75_lon9.25.nc"), variable=variable_name, - output_dir=Path("./tests/data/output"), + output_dir=Path("./tests/data/output/pymc5"), overwrite=True, report_variables=["ds", "y", "cfact", "logp"], + solver="pymc5", stop_date="2021-12-31", ) detrend(config) @@ -24,7 +25,7 @@ def detrend_run(variable_name): f"./tests/data/20CRv3-ERA5_germany_target_{variable_name}_lat50.75_lon9.25.h5" ) actual = pd.read_hdf( - f"./tests/data/output/timeseries/{variable_name}/lat_50.75/ts_lat50.75_lon9.25.h5" + f"./tests/data/output/pymc5/timeseries/{variable_name}/lat_50.75/ts_lat50.75_lon9.25.h5" ) return actual, desired diff --git a/tests/test_detrend_scipy.py b/tests/test_detrend_scipy.py new file mode 100644 index 0000000..e9b2aa9 --- /dev/null +++ b/tests/test_detrend_scipy.py @@ -0,0 +1,110 @@ +from pathlib import Path + +import numpy as np +import pandas as pd +import pytest + +from attrici.detrend import Config, detrend + + +def detrend_run(variable_name): + config = Config( + gmt_file=Path("./tests/data/20CRv3-ERA5_germany_ssa_gmt.nc"), + input_file=Path("./tests/data/20CRv3-ERA5_germany_obs.nc"), + mask_file=Path("./tests/data/mask_lat50.75_lon9.25.nc"), + variable=variable_name, + output_dir=Path("./tests/data/output/scipy"), + overwrite=True, + report_variables=["ds", "y", "cfact"], + solver="scipy", + stop_date="2021-12-31", + ) + detrend(config) + + desired = pd.read_hdf( + f"./tests/data/20CRv3-ERA5_germany_target_{variable_name}_lat50.75_lon9.25.h5" + ) + actual = pd.read_hdf( + f"./tests/data/output/scipy/timeseries/{variable_name}/lat_50.75/ts_lat50.75_lon9.25.h5" + ) + + return actual, desired + + +rtol = 1e-02 + + +@pytest.mark.slow +def test_detrend_run_tas(): + actual, desired = detrend_run("tas") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=rtol, atol=1e-05) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_tasskew(): + actual, desired = detrend_run("tasskew") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=rtol, atol=1e-05) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_tasrange(): + actual, desired = detrend_run("tasrange") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=0.19, atol=0.1) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_pr(): + actual, desired = detrend_run("pr") + + # Days with rain in both + data = pd.DataFrame({"actual": actual.cfact, "desired": desired.cfact}) + test_data = data[(data.actual > 0) & (data.desired > 0)] + np.testing.assert_allclose( + test_data.actual, test_data.desired, rtol=rtol, atol=5e-05 + ) + + # Days with rain in one dataset should have no or little rain in the other + test_data = data[(data.actual <= 0) | (data.desired <= 0)] + np.testing.assert_allclose( + test_data.actual, test_data.desired, rtol=rtol, atol=1e-05 + ) + + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_ps(): + actual, desired = detrend_run("ps") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=rtol, atol=1e-05) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_hurs(): + actual, desired = detrend_run("hurs") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=0.11, atol=0.1) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_rsds(): + actual, desired = detrend_run("rsds") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=rtol, atol=1e-05) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_rlds(): + actual, desired = detrend_run("rlds") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=rtol, atol=1e-05) + np.testing.assert_allclose(actual.y, desired.y) + + +@pytest.mark.slow +def test_detrend_run_sfc_wind(): + actual, desired = detrend_run("sfcWind") + np.testing.assert_allclose(actual.cfact, desired.cfact, rtol=0.16, atol=1e-01) + np.testing.assert_allclose(actual.y, desired.y)