From 802a33627d12dae4e8f0577d00a6d52ab495ed04 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Thu, 24 Feb 2022 18:32:13 +0100 Subject: [PATCH 01/15] controlled SMC code map --- particles/controlled_smc.py | 561 ++++++++++++++++++++++++++++++++++++ 1 file changed, 561 insertions(+) create mode 100644 particles/controlled_smc.py diff --git a/particles/controlled_smc.py b/particles/controlled_smc.py new file mode 100644 index 0000000..3504bcf --- /dev/null +++ b/particles/controlled_smc.py @@ -0,0 +1,561 @@ +# -*- coding: utf-8 -*- + +""" +Controlled Sequential Monte Carlo models as Python objects. + +The policy function is an attribute of StateSpaceModel class. + + +****************************************************************************** +Overview +======== +This module defines: + + 1. the `ControlledSMC` class, which lets you define a controlled sequential Monte Carlo model + as a Python object; + + 3. `TwistedSMC` class that define a kind of Bootstrap Feynman-Kac models + + 2. `FeynmanKac` classes based on the previous classes + +The recommended import is:: + + from particles import ControlledSMC module as CtSMC + +For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396 + +TODO: Defining a ControlledSMC model +============================== + +Consider the following (simplified) stochastic volatility model: + +.. math:: + + Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ + X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ + X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) + +To define this particular model, we sub-class `StateSpaceModel` as follows:: + + import numpy as np + from particles import distributions as dists + + class SimplifiedStochVol(ssms.StateSpaceModel): + default_parameters = {'sigma': 1., 'rho': 0.8} # optional + def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} + return dists.Normal(scale=np.exp(x)) + def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} + return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), + scale=self.sigma) + def PX0(self): # dist of X_0 + return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) + +Then we define a particular object (model) by instantiating this class:: + + my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9) + +Hopefully, the code above is fairly transparent, but here are some noteworthy +details: + + * probability distributions are defined through `ProbDist` objects, which + are defined in module `distributions`. Most basic probability + distributions are defined there; see module `distributions` for more details. + * The class above actually defines a **parametric** class of models; in + particular, ``self.sigma`` and ``self.rho`` are **attributes** of + this class that are set when we define object `my_stoch_vol_model`. + Default values for these parameters may be defined in a dictionary called + ``default_parameters``. When this dictionary is defined, any un-defined + parameter will be replaced by its default value:: + + default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8 + * There is no need to define a ``__init__()`` method, as it is already + defined by the parent class. (This parent ``__init__()`` simply takes + care of the default parameters, and may be overrided if needed.) + +Now that our state-space model is properly defined, what can we do with it? +First, we may simulate states and data from it:: + + x, y = my_stoch_vol_model.simulate(20) + +This generates two lists of length 20: a list of states, X_0, ..., X_{19} and +a list of observations (data-points), Y_0, ..., Y_{19}. + +TODO: Associated Feynman-Kac models +============================= + +Now that our state-space model is defined, we obtain the associated Bootstrap +Feynman-Kac model as follows: + + my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) + +That's it! You are now able to run a bootstrap filter for this model:: + + my_alg = particles.SMC(fk=my_fk_model, N=200) + my_alg.run() + +In case you are not clear about what are Feynman-Kac models, and how one may +associate a Feynman-Kac model to a given state-space model, see Chapter 5 of +the book. + +To generate a guided Feynman-Kac model, we must provide proposal kernels (that +is, Markov kernels that define how we simulate particles X_t at time t, given +an ancestor X_{t-1}):: + + class StochVol_with_prop(StochVol): + def proposal0(self, data): + return dists.Normal(scale = self.sigma) + def proposal(t, xp, data): # a silly proposal + return dists.Normal(loc=rho * xp + data[t], scale=self.sigma) + + my_second_ssm = StochVol_with_prop(sigma=0.3) + my_better_fk_model = ssms.Guided(ssm=my_second_ssm, data=y) + # then run a SMC as above + +Voilà! You have now implemented a guided filter. + +Of course, the proposal distribution above does not make much sense; we use it +to illustrate how proposals may be defined. Note in particular that it depends +on ``data``, an object that represents the complete dataset. Hence the proposal +kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other +datapoint. + +For auxiliary particle filters (APF), one must in addition specify auxiliary +functions, that is the (log of) functions :math:`\eta_t` that modify the +resampling probabilities (see Section 10.3.3 in the book):: + + class StochVol_with_prop_and_aux_func(StochVol_with_prop): + def logeta(self, t, x, data): + "Log of auxiliary function eta_t at time t" + return -(x-data[t])**2 + + my_third_ssm = StochVol_with_prop_and_aux_func() + apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y) + +Again, this particular choice does not make much sense, and is just given to +show how to define an auxiliary function. + +Already implemented the module +====================================== + +This module implements a few basic state-space models that are often used as +numerical examples: + +=================== ===================================================== +Class Comments +=================== ===================================================== +`NeuroScience` +`StochasticVol` + +=================== ===================================================== + +.. note:: + In C-SMC, proposal and weights are changed by the twisted functions. + The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. + The user also need to define the proposal function in this class as well. + This proposal shoub be overidden dynamically with ADP ! + +""" + +from __future__ import division, print_function +import state_space_models as modelssm +import numpy as np +from collectors import Moments +import utils +import kalman as kalman +import particles +from particles import distributions as dists + +err_msg_missing_cst = """ + State-space model %s is missing method upper_bound_log_pt, which provides + log of constant C_t, such that + p(x_t|x_{t-1}) <= C_t + This is required for smoothing algorithms based on rejection + """ +err_msg_missing_policy = """ + State-space model %s is missing method policy for controlled SMC, specify a policy + """ + +""" +TODO: +===== + - code is failing in resampling module in the function wmean_and_var() or 2D. + m = np.average(x, weights=W, axis=0) + m2 = np.average(x**2, weights=W, axis=0) # x**2 + v = m2 - m**2 + return {'mean': m, 'var': v} + + - Policy input shoud be refined + - Management of Policy function interaction. + - Reshape def run(self) in ControlledSMC class. + + QUESTIONS + --------- + -Observation space need to be updated ! + +""" + +# Define the ψ-twisted model || ψ-observation space, ψ-Proposal0, ψ-Proposal, G-ψ ? +class TwistedSMC(modelssm.Bootstrap): + """Twisted SMC for a given state-space model. + TODO: + matmul is not working for 1D. Adjust this. + define a template class to accomodate 1D and nD. + + Parameters + ---------- + ssm: StateSpaceModel object + the considered state-space model + data: list-like + the data + + Returns + ------- + FeynmanKac object + the Feynman-Kac representation of the bootstrap filter for the + considered state-space model + + Note + ---- + Argument ssm must implement methods `proposal0` and `proposal` and define a Policy function. + """ + + def M0(self, N): # TODO: t = 0 is not the right thing to do. + return self.M(0, self.ssm.proposal0(self.data).rvs(size=N)) + + def M(self, t, xp): + At, Bt, Ct = self.ssm.policy() + Mean = self.ssm.proposal(t, xp, self.data).loc + dimension = self.ssm.proposal(t, xp, self.data).dim + + if dimension == 1: + Var = self.ssm.proposal(t, xp, self.data).scale + VarInv = 1.00 / Var + V = np.dot(VarInv, Mean) - Bt + Alpha = VarInv + 2*At + AlphaInv = 1.00 / Alpha + else: + Var = self.ssm.proposal(t, xp, self.data).cov + VarInv = np.linalg.inv(Var) + V = np.dot(VarInv, Mean) - Bt + Alpha = VarInv + 2*At + AlphaInv = np.linalg.inv(Alpha) + + mbar = np.dot(V, np.dot(VarInv, Mean) - Bt) + + expo = 0.5 * self.Quadratic(self, AlphaInv, + np.zeros((dimension, 1)), - Ct, mbar) + if dimension == 1: + sqrtDet = np.sqrt(np.abs(Alpha)/np.abs(Var)) + else: + sqrtDet = np.sqrt(np.linalg.det(Alpha)/np.linalg.det(Var)) + + normalisation = self.Expectation(t, xp) + + if dimension == 1: + ProposalxPsi = dists.Normal( + mbar, (sqrtDet*expo/normalisation)**2*Alpha) + else: + ProposalxPsi = dists.MvNormal( + mbar, sqrtDet*expo/normalisation, Alpha) + # Proposal = self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0]) + # psiFactor = 0.5 * self.Quadratic(At, Bt, Ct, x) + # return Proposal*psiFactor/self.Expectation(t, xp) + # return ProposalxPsi / normalisation + return ProposalxPsi + + def logG(self, t, xp, x): + At, Bt, Ct = self.ssm.policy() + du = self.ssm.PX0().dim + + # Dimension adjustement + # Is breaking but something is happing in the code core. Weights are appended ! + if self.du == 1: + LogPolicy = self.Quadratic(self, At, Bt, Ct, x) # TODO: unsupported operand type(s) for ** or pow(): 'Normal' and 'int' + else: + LogPolicy = self.Quadratic(self, At, Bt.reshape( + self.du, 1), Ct.reshape(1, 1), x[-1]) # TODO: x[1] + + LogNormalisation = np.log(self.Expectation(t, x[-1])) + + # TODO: + if t == 0: + return (self.ssm.PX0().logpdf(x) + + self.ssm.proposal0(self.data).logpdf(x) + LogNormalisation - LogPolicy) + if t == self.T: + LogPotential = self.ssm.PY(t, xp, x).logpdf( + self.data[t]) + return LogPotential - LogPolicy + else: + LogPotential = self.ssm.PY(t, xp, x).logpdf( + self.data[t]) + return LogPotential + LogNormalisation - LogPolicy + + @staticmethod # TODO: unsupported operand type(s) for ** or pow(): 'Normal' and 'int' + def Quadratic(self, A, B, c, x): + if self.ssm.PX0().dim == 1: + return A*x**2 + B*x + c + else: + return np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c + + + def Expectation(self, t, xp): # \E[ψ(t, x, xp)| xp] = \E {\exp[(Ax,x)+ Bx + C] | xp} + """Conditional expectation with respect to the Markov kernel at time t + + Args: + t (_type_): _description_ + xp (_type_): _description_ + + Returns: + _type_: _description_ + """ + At, Bt, Ct = self.ssm.policy() # policy depends on (self, t, xp, x)) + dimension = self.du + + # TODO: + if t == 0: + return xp # This should be adjusted TODO: + if t == self.T: # G_T/Psi_T + Mean = self.ssm.proposal(t, xp, self.data[t]).loc + Var = self.ssm.proposal(t, xp, self.data[t]).cov + VarInverse = np.linalg.inv(Var) + V = np.dot(VarInverse, Mean) - Bt + Alpha = VarInverse + 2*At + Identity = np.identity(dim) + sqrtDet = np.sqrt(np.linalg.det(Identity + 2 * np.dot(Var, At))) + expo = self.Quadratic(Alpha, np.zeros((dimension, 1)), - Ct, V) + + return np.exp(expo) / np.sqrt(sqrtDet) + else: + Mean = self.ssm.proposal(t, xp, self.data).loc + if dimension == 1: + Var = self.ssm.proposal(t, xp, self.data).scale + else: + Var = self.ssm.proposal(t, xp, self.data).cov + + if dimension == 1: + VarInverse = 1.00/Var + V = VarInverse*Mean - Bt # ! Mean can be a random variable + Identity = dimension + sqrtDet = np.sqrt(np.abs(Identity + 2 * Var * At)) + Alpha = VarInverse + 2*At + expo = self.Quadratic(self, Alpha, np.zeros((dimension, 1)), - Ct, np.transpose(V)) + else: + VarInverse = np.linalg.inv(Var) + V = np.dot(VarInverse, np.transpose(Mean)) - \ + (np.transpose(Bt)).reshape(dimension, 1) + Identity = np.identity(dimension) + sqrtDet = np.sqrt(np.linalg.det( + Identity + 2 * np.dot(Var, At))) + Alpha = VarInverse + 2*At + + expo = self.Quadratic(self, Alpha, np.zeros( + (dimension, 1)), - Ct.reshape(1, 1), np.transpose(V)) + + return np.exp(expo) / sqrtDet + + +class ControlledSMC(TwistedSMC): + + """ Controlled SMC algorithm + Proposal distributions are determined by approximating the solution to an associated + optimal control problem using an iterative scheme = > You use APF where the proposal + is updated at every iteration. + Parameters + Inputs + ------------------- + ssm: StateSpaceModel object + the considered state-space model (-ssm with proposal and logEta(the psi)), + data: list-like + the data + + + Returns + ------- + [type]: [description] + FeynmanKac object + the Feynman-Kac representation of the filter for the + considered state-space model + + Note + ---- + In C-SMC, proposal and weights are changed by the twisted functions. + """ + + def __init__(self, ssm=None, data=None): + self.ssm = ssm # Argument ssm must implement methods `proposal0`, `proposal` + self.data = data + self.du = self.ssm.PX0().dim + self.policy = self.ssm.policy + + @property + def T(self): + return 0 if self.data is None else len(self.data) + + @property + def isPolicyMissing(self): + """Returns true if model parameter contains policy in the argument dictionary in ssm constructor""" + if (hasattr(self,self.ssm.policy) == False): + raise NotImplementedError(self._error_msg('missing policy')) + + + def run(self): # make this iterator() + # Policy Initialisation + AO, BO, CO = self.ssm.policy() + + # TODO: Dynamic SMC with update proposal via policy modulo coeffs A, B, C of Policy + for t in range(self.T): + # Run Twisted SMC for t different of T + fk_model = modelssm.TwistedSMC(self.ssm, self.data) + PsiSMC = particles.SMC(fk=fk_model, N=100, resampling='stratified', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # TODO: Look at the code and pick the right params + settings = {'N': 100, 'sample_trajectory': False, 'regularization': 1e-4} + + # run ADP to refine previous policy + # add feed the right staffs from PsiSMC.run() + adp = self.RefinePsiEstimation( + fk_model, self.data, self.ssm.policy, PsiSMC.summaries, settings, inverse_temperature=0.0) # add feed the right staffs from PsiSMC.run() + """ + model = ssm or any kind of model + observations = data + psi_smc = fk.run().results (derived from fk.run()) + settings = parameters of the model you define yourself + """ + # Construct refined policy (It is why we get/set policy), Use set function + refinedPolicy = self.ssm.policy() * adp['policy_refined'] # update A, B, C normally ! + self.ssm.set_policy(self, refinedPolicy) + + # Run ψ -twisted SMC method for t = T, + if t == self.T: + fk_model = modelssm.TwistedSMC(self.ssm, self.data) + PsiSMC = particles.SMC(fk=fk_model, N=100, resampling='stratified', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # return PsiSMC.result # Seems that PsiSMC is void :) as desire ! Smoothing, Filtering etc.. + pass + + # python compatibility + def next(self): + return self.__next__() #  Python 2 compatibility + + def __iter__(self): + return self + + # Compute the Backward Filter + def RefinePsiEstimation(model, observations, policy, psi_smc, settings, inverse_temperature=1.0): + """ + model = ssm or any kind of model + observations = data + psi_smc = fk.run().results (derived from fk.run()) + settings = parameters of the model you define yourself + + Approximate dynamic programming to refine a policy. + + In Python method overriding occurs by simply defining in the child class a method with the same name of a method + in the parent class. When you define a method in the object you make this latter able to satisfy that method call, + so the implementations of its ancestors do not come in play. + + Parameters + ---------- + model : controlledpsi_smc.models.LRR.ssm + A ssm class instance + + observations : numpy.array (T+1, dim_y) + Time series + + settings : dict + Particle filtering settings contain: + 'N' : int specifying number of particles + 'sample_trajectory' : bool specifying whether a trajectory is to be sampled + + policy : list of dicts of length T+1 + Coefficients specifying policy + + inverse_temperature : float + The inverse temperature controls the annealing of the observation densities + + Returns + + ------- + output : dict + Algorithm output contain: + 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy + 'r_squared' : numpy.array (T+1,) containing coefficient of determination values + """ + + # get model properties and algorithmic settings + dim_s = model.dim_s + T = observations.shape[0] - 1 + N = settings['N'] + + # pre-allocate + policy_refined = [{} for t in range(T+1)] + r_squared = np.ones([T+1]) + + # initialize + log_conditional_expectation = np.zeros([N]) + ancestors = psi_smc['ancestry'][:, T-1] + states_previous = psi_smc['states'][ancestors, :, T-1] + states_current = psi_smc['states'][:, :, T] + + # iterate over time periods backwards + for t in range(T, 0, -1): + # compute uncontrolled weights of reference proposal transition + log_weights_uncontrolled = model.log_weights_uncontrolled( + t, observations[t, :], states_previous, states_current, inverse_temperature) + + # evaluate log-policy function + log_policy = model.log_policy( + policy[t], states_previous, states_current) + + # target function values + target_values = log_weights_uncontrolled + \ + log_conditional_expectation - log_policy + + # perform regression to learn refinement + (refinement, r_squared[t]) = model.learn_refinement( + states_previous, states_current, target_values, settings) + + # refine current policy + policy_refined[t] = model.refine_policy(policy[t], refinement) + + # compute log-conditional expectation of refined policy + if t != 1: + ancestors = psi_smc['ancestry'][:, t-2] + states_previous = psi_smc['states'][ancestors, :, t-2] + states_current = psi_smc['states'][:, :, t-1] + (log_conditional_expectation, _) = model.log_conditional_expectation( + policy_refined[t], states_current) + + # also refine initial policy for random initial distributions + if model.initial_type == 'random': + # compute log-conditional expectation of refined policy + states_current = psi_smc['states'][:, :, 0] + (log_conditional_expectation, _) = model.log_conditional_expectation( + policy_refined[1], states_current) + + # compute uncontrolled weights of reference proposal distribution + log_weights_uncontrolled = model.log_weights_uncontrolled_initial( + observations[0, :], states_current, inverse_temperature) + + # evaluate log-policy function + log_policy = model.log_initial_policy(policy[0], states_current) + + # target function values + target_values = log_weights_uncontrolled + \ + log_conditional_expectation - log_policy + + # perform regression to learn refinement + (refinement, r_squared[0]) = model.learn_initial_refinement( + states_current, target_values, settings) + + # refine current policy + policy_refined[0] = model.refine_initial_policy( + policy[0], refinement) + + # algorithm output + output = {'policy_refined': policy_refined, 'r_squared': r_squared} + + return output \ No newline at end of file From 9fd3f61920bd4932fdde4d40ec1738beefcde505 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Thu, 24 Feb 2022 18:37:07 +0100 Subject: [PATCH 02/15] add policy functions for controlled SMC --- particles/state_space_models.py | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/particles/state_space_models.py b/particles/state_space_models.py index 0a44141..2df0cbb 100644 --- a/particles/state_space_models.py +++ b/particles/state_space_models.py @@ -171,6 +171,9 @@ def logeta(self, t, x, data): p(x_t|x_{t-1}) <= C_t This is required for smoothing algorithms based on rejection """ +err_msg_missing_policy = """ + State-space model %s is missing method policy for controlled SMC, specify a policy + """ class StateSpaceModel(object): """Base class for state-space models. @@ -260,7 +263,27 @@ def proposal(self, t, xp, data): data """ raise NotImplementedError(self._error_msg('proposal')) - + + @property # TODO: Policy should return a matrix ! Discuss how policy shoulb be incorporated + def policy(self): + """policy : + Coefficients specifying policy. + Policy should be exponential quadratic + log(policy(t, xp, x)) = -[(At x,x) + (Bt,x) + Ct] + F(x_p); where A is a matrix dxd, b a vector, c scalar + return the list [At, Bt, Ct] + At : a matrix + Bt : a vector + Ct : Normally for every t, we have a different coefficient + """ + raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) + + def get_policy(self): + return self.policy + + def set_policy(self, newPolicy): + self.policy = newPolicy + + def upper_bound_log_pt(self, t): """Upper bound for log of transition density. From f2a46712e3b772202d1292869a39818cc817c9ea Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:04:58 +0200 Subject: [PATCH 03/15] policy to ssm --- state_space_models.py | 683 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 683 insertions(+) create mode 100644 state_space_models.py diff --git a/state_space_models.py b/state_space_models.py new file mode 100644 index 0000000..4f78fe3 --- /dev/null +++ b/state_space_models.py @@ -0,0 +1,683 @@ +# -*- coding: utf-8 -*- + +r""" +State-space models as Python objects. + +Overview +======== +This module defines: + + 1. the `StateSpaceModel` class, which lets you define a state-space model + as a Python object; + + 2. `FeynmanKac` classes that automatically define the Bootstrap, guided or + auxiliary Feynman-Kac models associated to a given state-space model; + + 3. several standard state-space models (stochastic volatility, + bearings-only tracking, and so on). + +The recommended import is:: + + from particles import state_space_models as ssms + +For more details on state-space models and their properties, see Chapters 2 and +4 of the book. + +Defining a state-space model +============================ + +Consider the following (simplified) stochastic volatility model: + +.. math:: + + Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ + X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ + X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) + +To define this particular model, we sub-class `StateSpaceModel` as follows:: + + import numpy as np + from particles import distributions as dists + + class SimplifiedStochVol(ssms.StateSpaceModel): + default_params = {'sigma': 1., 'rho': 0.8} # optional + def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} + return dists.Normal(scale=np.exp(x)) + def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} + return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), + scale=self.sigma) + def PX0(self): # dist of X_0 + return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) + +Then we define a particular object (model) by instantiating this class:: + + my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9) + +Hopefully, the code above is fairly transparent, but here are some noteworthy +details: + + * probability distributions are defined through `ProbDist` objects, which + are defined in module `distributions`. Most basic probability + distributions are defined there; see module `distributions` for more details. + * The class above actually defines a **parametric** class of models; in + particular, ``self.sigma`` and ``self.rho`` are **attributes** of + this class that are set when we define object `my_stoch_vol_model`. + Default values for these parameters may be defined in a dictionary called + ``default_params``. When this dictionary is defined, any un-defined + parameter will be replaced by its default value:: + + default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8 + * There is no need to define a ``__init__()`` method, as it is already + defined by the parent class. (This parent ``__init__()`` simply takes + care of the default parameters, and may be overrided if needed.) + +Now that our state-space model is properly defined, what can we do with it? +First, we may simulate states and data from it:: + + x, y = my_stoch_vol_model.simulate(20) + +This generates two lists of length 20: a list of states, X_0, ..., X_{19} and +a list of observations (data-points), Y_0, ..., Y_{19}. + +Associated Feynman-Kac models +============================= + +Now that our state-space model is defined, we obtain the associated Bootstrap +Feynman-Kac model as follows:: + + my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) + +That's it! You are now able to run a bootstrap filter for this model:: + + my_alg = particles.SMC(fk=my_fk_model, N=200) + my_alg.run() + +In case you are not clear about what are Feynman-Kac models, and how one may +associate a Feynman-Kac model to a given state-space model, see Chapter 5 of +the book. + +To generate a guided Feynman-Kac model, we must provide proposal kernels (that +is, Markov kernels that define how we simulate particles X_t at time t, given +an ancestor X_{t-1}):: + + class StochVol_with_prop(StochVol): + def proposal0(self, data): + return dists.Normal(scale = self.sigma) + def proposal(t, xp, data): # a silly proposal + return dists.Normal(loc = rho * xp + data[t], scale=self.sigma) + + my_second_ssm = StochVol_with_prop(sigma=0.3) + my_better_fk_model = ssms.Guided(ssm = my_second_ssm, data=y) + # then run a SMC as above + +Voilà! You have now implemented a guided filter. + +Of course, the proposal distribution above does not make much sense; we use it +to illustrate how proposals may be defined. Note in particular that it depends +on ``data``, an object that represents the complete dataset. Hence the proposal +kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other +datapoint. + +For auxiliary particle filters (APF), one must in addition specify auxiliary +functions, that is the (log of) functions :math:`\eta_t` that modify the +resampling probabilities (see Section 10.3.3 in the book):: + + class StochVol_with_prop_and_aux_func(StochVol_with_prop): + def logeta(self, t, x, data): + "Log of auxiliary function eta_t at time t" + return -(x-data[t])**2 + + my_third_ssm = StochVol_with_prop_and_aux_func() + apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y) + +Again, this particular choice does not make much sense, and is just given to +show how to define an auxiliary function. + +Already implemented state-space models +====================================== + +This module implements a few basic state-space models that are often used as +numerical examples: + +=================== ===================================================== +Class Comments +=================== ===================================================== +`StochVol` Basic, univariate stochastic volatility model +`StochVolLeverage` Univariate stochastic volatility model with leverage +`MVStochVol` Multivariate stochastic volatility model +`BearingsOnly` Bearings-only tracking +`Gordon_etal` Popular toy model often used as a benchmark +`DiscreteCox` A discrete Cox model (Y_t|X_t is Poisson) +`ThetaLogistic` Theta-logistic model from Population Ecology +=================== ===================================================== + +.. note:: + Linear Gaussian state-space models are implemented in module `kalman`; + similarly hidden Markov models (state-space models with a finite state-space) + are implemented in module `hmm`. + +""" + +from __future__ import division, print_function +import numpy as np + +import particles +from particles import distributions as dists + +err_msg_missing_cst = """ + State-space model %s is missing method upper_bound_log_pt, which provides + log of constant C_t, such that + p(x_t|x_{t-1}) <= C_t + This is required for smoothing algorithms based on rejection + """ +err_msg_missing_policy = """ + State-space model %s is missing method policy (a dictionnary) for controlled SMC, specify a policy dictionnary + """ + +class StateSpaceModel(object): + """Base class for state-space models. + + To define a state-space model class, you must sub-class `StateSpaceModel`, + and at least define methods PX0, PX, and PY. Here is an example:: + + class LinearGauss(StateSpaceModel): + def PX0(self): # The law of X_0 + return dists.Normal(scale=self.sigmaX) + def PX(self, t, xp): # The law of X_t conditional on X_{t-1} + return dists.Normal(loc=self.rho * xp, scale=self.sigmaY) + def PY(self, t, xp, x): # the law of Y_t given X_t and X_{t-1} + return dists.Normal(loc=x, scale=self.sigmaY) + + These methods return ``ProbDist`` objects, which are defined in the module + `distributions`. The model above is a basic linear Gaussian SSM; it + depends on parameters rho, sigmaX, sigmaY (which are attributes of the + class). To define a particular instance of this class, we do:: + + a_certain_ssm = LinearGauss(rho=.8, sigmaX=1., sigmaY=.2) + + All the attributes that appear in ``PX0``, ``PX`` and ``PY`` must be + initialised in this way. Alternatively, it it possible to define default + values for these parameters, by defining class attribute + ``default_params`` to be a dictionary as follows:: + + class LinearGauss(StateSpaceModel): + default_params = {'rho': .9, 'sigmaX': 1., 'sigmaY': .1} + # rest as above + + Optionally, we may also define methods: + + * `proposal0(self, data)`: the (data-dependent) proposal dist at time 0 + * `proposal(self, t, xp, data)`: the (data-dependent) proposal distribution at + time t, for X_t, conditional on X_{t-1}=xp + * `logeta(self, t, x, data)`: the auxiliary weight function at time t + + You need these extra methods to run a guided or auxiliary particle filter. + + """ + + def __init__(self, **kwargs): + if hasattr(self, 'default_params'): + self.__dict__.update(self.default_params) + self.__dict__.update(kwargs) + + def _error_msg(self, method): + return ('method ' + method + ' not implemented in class%s' % + self.__class__.__name__) + + @classmethod + def state_container(cls, N, T): + law_X0 = cls().PX0() + dim = law_X0.dim + shape = [N, T] + if dim>1: + shape.append(dim) + return np.empty(shape, dtype=law_X0.dtype) + + def PX0(self): + "Law of X_0 at time 0" + raise NotImplementedError(self._error_msg('PX0')) + + def PX(self, t, xp): + " Law of X_t at time t, given X_{t-1} = xp" + raise NotImplementedError(self._error_msg('PX')) + + def PY(self, t, xp, x): + """Conditional distribution of Y_t, given the states. + """ + raise NotImplementedError(self._error_msg('PY')) + + def proposal0(self, data): + raise NotImplementedError(self._error_msg('proposal0')) + + def proposal(self, t, xp, data): + """Proposal kernel (to be used in a guided or auxiliary filter). + + Parameter + --------- + t: int + time + x: + particles + data: list-like + data + """ + raise NotImplementedError(self._error_msg('proposal')) + + @property + def policy(self): + """policy : + Coefficients specifying policy + policy should be exponential quadratic + log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A is a matrix dxd, b a vector, c scalar + return the list [At, Bt, Ct] + A_t is a matrix + Bt is a vector of dimension of the + Ct is !! + """ + raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) + + def get_policy(self): + return self.policy + + def set_policy(self, newPolicy): + self.policy = newPolicy + + + def upper_bound_log_pt(self, t): + """Upper bound for log of transition density. + + See `smoothing`. + """ + raise NotImplementedError(err_msg_missing_cst % self.__class__.__name__) + + def add_func(self, t, xp, x): + """Additive function.""" + raise NotImplementedError(self._error_msg('add_func')) + + def simulate_given_x(self, x): + lag_x = [None] + x[:-1] + return [self.PY(t, xp, x).rvs(size=1) + for t, (xp, x) in enumerate(zip(lag_x, x))] + + def simulate(self, T): + """Simulate state and observation processes. + + Parameters + ---------- + T: int + processes are simulated from time 0 to time T-1 + + Returns + ------- + x, y: lists + lists of length T + """ + x = [] + for t in range(T): + law_x = self.PX0() if t == 0 else self.PX(t, x[-1]) + x.append(law_x.rvs(size=1)) + y = self.simulate_given_x(x) + return x, y + + +class Bootstrap(particles.FeynmanKac): + """Bootstrap Feynman-Kac formalism of a given state-space model. + + Parameters + ---------- + + ssm: `StateSpaceModel` object + the considered state-space model + data: list-like + the data + + Returns + ------- + `FeynmanKac` object + the Feynman-Kac representation of the bootstrap filter for the + considered state-space model + """ + def __init__(self, ssm=None, data=None): + self.ssm = ssm + self.data = data + self.du = self.ssm.PX0().dim + + @property + def T(self): + return 0 if self.data is None else len(self.data) + + def M0(self, N): + return self.ssm.PX0().rvs(size=N) + + def M(self, t, xp): + return self.ssm.PX(t, xp).rvs(size=xp.shape[0]) + + def logG(self, t, xp, x): + return self.ssm.PY(t, xp, x).logpdf(self.data[t]) + + def Gamma0(self, u): + return self.ssm.PX0().ppf(u) + + def Gamma(self, t, xp, u): + return self.ssm.PX(t, xp).ppf(u) + + def logpt(self, t, xp, x): + """PDF of X_t|X_{t-1}=xp""" + return self.ssm.PX(t, xp).logpdf(x) + + def upper_bound_trans(self, t): + return self.ssm.upper_bound_log_pt(t) + + def add_func(self, t, xp, x): + return self.ssm.add_func(t, xp, x) + + +class GuidedPF(Bootstrap): + """Guided filter for a given state-space model. + + Parameters + ---------- + + ssm: StateSpaceModel object + the considered state-space model + data: list-like + the data + + Returns + ------- + FeynmanKac object + the Feynman-Kac representation of the bootstrap filter for the + considered state-space model + + Note + ---- + Argument ssm must implement methods `proposal0` and `proposal`. + """ + + def M0(self, N): + return self.ssm.proposal0(self.data).rvs(size=N) + + def M(self, t, xp): + return self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0]) + + def logG(self, t, xp, x): + if t == 0: + return (self.ssm.PX0().logpdf(x) + + self.ssm.PY(0, xp, x).logpdf(self.data[0]) + - self.ssm.proposal0(self.data).logpdf(x)) + else: + return (self.ssm.PX(t, xp).logpdf(x) + + self.ssm.PY(t, xp, x).logpdf(self.data[t]) + - self.ssm.proposal(t, xp, self.data).logpdf(x)) + + def Gamma0(self, u): + return self.ssm.proposal0(self.data).ppf(u) + + def Gamma(self, t, xp, u): + return self.ssm.proposal(t, xp, self.data).ppf(u) + +class APFMixin(): + def logeta(self, t, x): + return self.ssm.logeta(t, x, self.data) + +class AuxiliaryPF(GuidedPF, APFMixin): + """Auxiliary particle filter for a given state-space model. + + Parameters + ---------- + + ssm: StateSpaceModel object + the considered state-space model + data: list-like + the data + + Returns + ------- + `FeynmanKac` object + the Feynman-Kac representation of the APF (auxiliary particle filter) + for the considered state-space model + + Note + ---- + Argument ssm must implement methods `proposal0`, `proposal` and `logeta`. + """ + + pass + + +class AuxiliaryBootstrap(Bootstrap, APFMixin): + """Base class for auxiliary bootstrap particle filters + + This is an APF, such that the proposal kernel is set to the transition + kernel of the model + """ + + pass + + +################################ +# Specific state-space models +################################ + +class StochVol(StateSpaceModel): + r"""Univariate stochastic volatility model. + + .. math:: + + X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\ + X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t, \quad U_t\sim N(0,1) \\ + Y_t|X_t=x_t & \sim N(0, e^{x_t}) \\ + """ + default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178} + # values taken from Pitt & Shephard (1999) + + def sig0(self): + """std of X_0""" + return self.sigma / np.sqrt(1. - self.rho**2) + + def PX0(self): + return dists.Normal(loc=self.mu, scale=self.sig0()) + + def EXt(self, xp): + """compute E[x_t|x_{t-1}]""" + return (1. - self.rho) * self.mu + self.rho * xp + + def PX(self, t, xp): + return dists.Normal(loc=self.EXt(xp), scale=self.sigma) + + def PY(self, t, xp, x): + return dists.Normal(loc=0., scale=np.exp(0.5 * x)) + + def _xhat(self, xst, sig, yt): + return xst + 0.5 * sig**2 * (yt**2 * np.exp(-xst) - 1.) + + def proposal0(self, data): + # Pitt & Shephard + return dists.Normal(loc=self._xhat(0., self.sig0(), data[0]), + scale=self.sig0()) + + def proposal(self, t, xp, data): + # Pitt & Shephard + return dists.Normal(loc=self._xhat(self.EXt(xp), + self.sigma, data[t]), + scale=self.sigma) + + def logeta(self, t, x, data): + # Pitt & Shephard + xst = self.EXt(x) + xstmmu = xst - self.mu + xhat = self._xhat(xst, self.sigma, data[t + 1]) + xhatmmu = xhat - self.mu + return (0.5 / self.sigma**2 * (xhatmmu**2 - xstmmu**2) + - 0.5 * data[t + 1]**2 * np.exp(-xst) * (1. + xstmmu)) + + +class StochVolLeverage(StochVol): + r"""Univariate stochastic volatility model with leverage effect. + + .. math:: + + X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\ + X_t|X_{t-1}=x_{t-1} & \sim N(\mu + \rho (x-\mu), \sigma^2) \\ + Y_t|X_{t-1:t} =x_{t-1:t} & \sim N( s \phi z, s^2 (1-\phi^2) ) + + with :math:`s=\exp(x_t/2), z = [x_t-\mu-\rho*(x_{t-1}-\mu)]/\sigma` + + Note + ---- + + This is equivalent to assuming that the innovations of X_t and Y_t + are correlated, with correlation :math:`\phi`: + + .. math:: + + X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t \\ + Y_t & = \exp(X_t/2) * V_t + + and :math:`Cor(U_t, V_t) = \phi` + + Warning + ------- + This class inherits from StochVol, but methods proposal, proposal0 + and logeta were constructed for StochVol only, and should not work properly + for this class. + """ + + default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178, 'phi': 0.} + + def PY(self, t, xp, x): + # u is realisation of noise U_t, conditional on X_t, X_{t-1} + if t==0: + u = (x - self.mu) / self.sig0() + else: + u = (x - self.EXt(xp)) / self.sigma + std_x = np.exp(0.5 * x) + return dists.Normal(loc=std_x * self.phi * u, + scale=std_x * np.sqrt(1. - self.phi**2)) + + +class Gordon_etal(StateSpaceModel): + r"""Popular toy example that appeared initially in Gordon et al (1993). + + .. math:: + + X_0 & \sim N(0, 2^2) \\ + X_t & = b X_{t-1} + c X_{t-1}/(1+X_{t-1}^2) + d*\cos(e*(t-1)) + \sigma_X V_t, \quad V_t \sim N(0,1) \\ + Y_t|X_t=x_t & \sim N(a*x_t^2, 1) + """ + default_params = {'a': 0.05, 'b': .5, 'c': 25., 'd': 8., 'e': 1.2, + 'sigmaX': 3.162278} # = sqrt(10) + + def PX0(self): + return dists.Normal(scale=2.) + + def PX(self, t, xp): + return dists.Normal(loc=self.b * xp + self.c * xp / (1. + xp**2) + + self.d * np.cos(self.e * (t - 1)), + scale=self.sigmaX) + + def PY(self, t, xp, x): + return dists.Normal(loc=self.a * x**2) + + +class BearingsOnly(StateSpaceModel): + """ Bearings-only tracking SSM. + + """ + default_params = {'sigmaX': 2.e-4, 'sigmaY': 1e-3, + 'x0': np.array([3e-3, -3e-3, 1., 1.])} + + def PX0(self): + return dists.IndepProd(dists.Normal(loc=self.x0[0], scale=self.sigmaX), + dists.Normal(loc=self.x0[1], scale=self.sigmaX), + dists.Dirac(loc=self.x0[2]), + dists.Dirac(loc=self.x0[3]) + ) + + def PX(self, t, xp): + return dists.IndepProd(dists.Normal(loc=xp[:, 0], scale=self.sigmaX), + dists.Normal(loc=xp[:, 1], scale=self.sigmaX), + dists.Dirac(loc=xp[:, 0] + xp[:, 2]), + dists.Dirac(loc=xp[:, 1] + xp[:, 3]) + ) + + def PY(self, t, xp, x): + angle = np.arctan(x[:, 3] / x[:, 2]) + angle[x[:, 2] < 0.] += np.pi + return dists.Normal(loc=angle, scale=self.sigmaY) + + +class DiscreteCox(StateSpaceModel): + r"""A discrete Cox model. + + .. math:: + Y_t | X_t=x_t & \sim Poisson(e^{x_t}) \\ + X_t & = \mu + \phi(X_{t-1}-\mu) + U_t, U_t ~ N(0, sigma^2) \\ + X_0 & \sim N(\mu, \sigma^2/(1-\phi**2)) + """ + default_params = {'mu': 0., 'sigma': 1., 'phi': 0.95} + + def PX0(self): + return dists.Normal(loc=self.mu, + scale=self.sigma / np.sqrt(1. - self.phi**2)) + + def PX(self, t, xp): + return dists.Normal(loc=self.mu + self.phi * (xp - self.mu), + scale=self.sigma) + + def PY(self, t, xp, x): + return dists.Poisson(rate=np.exp(x)) + + +class MVStochVol(StateSpaceModel): + """Multivariate stochastic volatility model. + + X_0 ~ N(mu,covX) + X_t-mu = F*(X_{t-1}-mu)+U_t U_t~N(0,covX) + Y_t(k) = exp(X_t(k)/2)*V_t(k) for k=1,...,d + V_t ~ N(0,corY) + """ + default_params = {'mu': 0., 'covX': None, 'corY': None, 'F': None} # TODO + + def offset(self): + return self.mu - np.dot(self.F, self.mu) + + def PX0(self): + return dists.MvNormal(loc=self.mu, cov=self.covX) + + def PX(self, t, xp): + return dists.MvNormal(loc=np.dot(xp, self.F.T) + self.offset(), + cov=self.covX) + + def PY(self, t, xp, x): + return dists.MvNormal(scale=np.exp(0.5 * x), cov=self.corY) + + +class ThetaLogistic(StateSpaceModel): + r""" Theta-Logistic state-space model (used in Ecology). + + .. math:: + + X_0 & \sim N(0, 1) \\ + X_t & = X_{t-1} + \tau_0 - \tau_1 * \exp(\tau_2 * X_{t-1}) + U_t, \quad U_t \sim N(0, \sigma_X^2) \\ + Y_t & \sim X_t + V_t, \quad V_t \sim N(0, \sigma_Y^2) + """ + default_params = {'tau0':.15, 'tau1':.12, 'tau2':.1, 'sigmaX': 0.47, + 'sigmaY': 0.39} # values from Peters et al (2010) + + def PX0(self): + return dists.Normal(loc=0., scale=1.) + + def PX(self, t, xp): + return dists.Normal(loc=xp + self.tau0 - self.tau1 * + np.exp(self.tau2 * xp), scale=self.sigmaX) + + def PY(self, t, xp, x): + return dists.Normal(loc=x, scale=self.sigmaY) + + def proposal0(self, data): + return self.PX0().posterior(data[0], sigma=self.sigmaY) + + def proposal(self, t, xp, data): + return self.PX(t, xp).posterior(data[t], sigma=self.sigmaY) + \ No newline at end of file From 0988485fa26495bcf9eb1d4c045449abe17b12d9 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:07:10 +0200 Subject: [PATCH 04/15] Controlled SMC codes and test Note book - add controlled SMC class - add policy in ssm class - add Jupyter note book test for controlled SMC --- Test_ControlledSMC_StochasticVolatility.ipynb | 315 ++++++++ controlled_smc.py | 689 ++++++++++++++++++ 2 files changed, 1004 insertions(+) create mode 100644 Test_ControlledSMC_StochasticVolatility.ipynb create mode 100644 controlled_smc.py diff --git a/Test_ControlledSMC_StochasticVolatility.ipynb b/Test_ControlledSMC_StochasticVolatility.ipynb new file mode 100644 index 0000000..3843694 --- /dev/null +++ b/Test_ControlledSMC_StochasticVolatility.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test Controlled SMC\n", + "\n", + "Test Controlled SMC algorithm on Stochastic Volatiliy Model\n", + "\n", + "For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396\n", + "\n", + "Steps to define a ControlledSMC model: \n", + "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). \n", + " This model should be an ssm object. For example: ssm = stovolModel() \n", + " - Define your own policy functions. \n", + " \n", + "Step 2 : Create the ControlledSMC object as follow:\n", + " myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5)\n", + " ssm = your original defined model \n", + " data: is your data\n", + " iterations = fixed at your convenience. \n", + "\n", + " \n", + "## First steps: defining a state-space model and Policy functionss\n", + "\n", + "We start by importing some standard libraries, plus some modules from the package." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import warnings; warnings.simplefilter('ignore') # hide warnings \n", + "\n", + "# standard libraries\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sb\n", + "from particles import distributions as dists # where probability distributions are defined\n", + "from particles import state_space_models as ssm # where state-space models are defined\n", + "from particles.collectors import Moments \n", + "from collectors import Moments \n", + "from sklearn.linear_model import Ridge\n", + "import controlled_smc as cSMC\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define our first state-space model **class** and the policy function. We consider a basic stochastic volalitility model, that is: \n", + "\\begin{align*}\n", + "X_0 & \\sim N\\left(\\mu, \\frac{\\sigma^2}{1-\\rho^2}\\right), &\\\\\n", + "X_t|X_{t-1}=x_{t-1} & \\sim N\\left( \\mu + \\rho (x_{t-1}-\\mu), \\sigma^2\\right), &\\quad t\\geq 1, \\\\\n", + "Y_t|X_t=x_t & \\sim N\\left(0, e^{x_t}\\right),& \\quad t\\geq 0.\n", + "\\end{align*}\n", + " \n", + "Note that this model depends on fixed parameter $\\theta=(\\mu, \\rho, \\sigma)$. The policy function P is defined as:\n", + "\n", + "$$\n", + "\\log P_t(t, X_{t-1}, X_{t}) = -[(A_t X_{t},X_{t}) + (B_t,X_{t}) + c_t] \n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# DEFINE STOCHASTIC VOLATILITY MODEL\n", + "# ----------------------------------- \n", + "class StochVol(ssm.StateSpaceModel): \n", + " \"\"\" \"\"\"\n", + " mu = -1.0; sigma = 1.0; rho = 1.0/np.sqrt(2) #\n", + " def PX0(self): # Distribution of X_0\n", + " \"\"\" \"\"\"\n", + " return dists.Normal( loc = self.mu, scale=self.sigma / np.sqrt(1.0 - self.rho**2))\n", + " def PX(self, t, xp): # Distribution of X_t given X_{t-1}=xp (p=past)\n", + " \"\"\" \"\"\"\n", + " return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), scale=self.sigma)\n", + " def PY(self, t, xp, x): # Distribution of Y_t given X_t=x (and possibly X_{t-1}=xp)\n", + " \"\"\" \"\"\"\n", + " return dists.Normal(loc=0., scale=np.exp(0.5*x))\n", + " def policy(self,t): # a quadratic function policy(At, Bt, Ct)\n", + " \"\"\" return only coefs of the quadratic from of the policy function (A,B,c)\n", + " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t] - F(xp); where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", + " \"\"\"\n", + " return 0.002175129155947095, 0.021869510847052914, 0.53135057055622562" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N = 100\n", + "# define the model\n", + "stovolModel = StochVol() \n", + "true_states, data = stovolModel.simulate(N) # we simulate from the model 100 data points\n", + "\n", + "my_model = StochVol(mu=-1., rho=.9, sigma=.1) # actual model with params\n", + "true_states, data = my_model.simulate(100) # we simulate from the model 100 data points\n", + "\n", + "plt.style.use('ggplot')\n", + "plt.figure()\n", + "plt.plot(data, linewidth = 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Twisted feynman kac model and bootstraap - simulations comparison \n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "fk_StoVolTwisted = cSMC.TwistedFK(ssm=stovolModel, data=data) \n", + "fk_StoVolBootstrap= ssm.Bootstrap(ssm=stovolModel, data=data) \n", + "\n", + "# Bootstrap\n", + "pfBootstrap = particles.SMC(fk=fk_StoVolBootstrap, N=N, resampling='multinomial', collect=[Moments()], store_history=True) \n", + "pfBootstrap.run() # actual computation\n", + "\n", + "# Twisted FK\n", + "pfTwisted = particles.SMC(fk=fk_StoVolTwisted, N=N, resampling='multinomial', collect=[Moments()], store_history=True)\n", + "pfTwisted.run() # actual computation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Particle Smoothing\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "smooth_trajectories = pfTwisted.hist.backward_sampling(3) # 10 Trajectories\n", + "plt.figure()\n", + "plt.plot(smooth_trajectories)\n", + "plt.title(\" Twisted smooth_trajectories\")\n", + "plt.legend()\n", + "\n", + "# results = multiSMC(fk=fk_StoVolTwisted, N=100, nruns=30, qmc={'SMC':False, 'SQMC':True})\n", + "# plt.figure()\n", + "# sb.boxplot(x=[r['output'].logLt for r in results], y=[r['qmc'] for r in results]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Weights Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# A Serie of Weights # Make histogram\n", + "plt.figure()\n", + "plt.plot(np.arange(len(data)), pfTwisted.W, linewidth = 1, marker = 'o') # lineStyle = '.')\n", + "plt.plot(np.arange(len(data)), pfBootstrap.W ,linewidth = 1, marker = 'o') \n", + "plt.xlabel('period', fontsize = 15)\n", + "plt.ylabel('$Weights$', fontsize = 15)\n", + "plt.title(\" Some weights\")\n", + "plt.legend(['TwistedFK', 'Bootstrap'], fontsize = 15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Controlled smc - Feynman kac model results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "PsiSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) \n", + "\n", + "PsiSMCResults = PsiSMC.RunAll() \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TODO\n", + "\n", + " -\n", + " -\n", + " \n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/controlled_smc.py b/controlled_smc.py new file mode 100644 index 0000000..2d70df5 --- /dev/null +++ b/controlled_smc.py @@ -0,0 +1,689 @@ +# -*- coding: utf-8 -*- + +""" +Controlled Sequential Monte Carlo models as Python objects. + +The policy function is an attribute of StateSpaceModel class. + + +****************************************************************************** +Overview +======== +This module defines: + + 1. the `ControlledSMC` class, which lets you define a controlled sequential Monte Carlo model + as a Python object; + + 2. `TwistedFK` class that define a twisted Feynman-Kac models + + +The recommended import is:: + + from particles import ControlledSMC module as CtSMC + +For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396 + +Steps to define a ControlledSMC model +============================== +Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]) + This model should be an ssm object. For example ssm = stovolModel() + - Define your policy functions. + +Step 2 : Create the ControlledSMC object as follow: + + myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5) + ssm = your original defined model + data: is your data + iterations = fixed at your convenience. + +Example: +-------- +Consider the following (simplified) stochastic volatility model: +.. math:: + + Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ + X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ + X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) + +To define this particular model, we sub-class from `ControlledSMC` as follows:: + + import numpy as np + from particles import distributions as dists + + class SimplifiedStochVol(ssms.StateSpaceModel): + default_parameters = {'sigma': 1., 'rho': 0.8} # optional + def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} + return dists.Normal(scale=np.exp(x)) + def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} + return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), + scale=self.sigma) + def PX0(self): # dist of X_0 + return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) + +Then we define a particular object (model) by instantiating this class:: + + stovolModel = SimplifiedStochVol(sigma=0.3, rho=0.9) + + myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) + + +Hopefully, the code above is fairly transparent, but here are some noteworthy +details: + + +TODO: Associated Feynman-Kac models +============================= + +Now that our state-space model is defined, we obtain the associated Bootstrap +Feynman-Kac model as follows: + + my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) + +That's it! You are now able to run a bootstrap filter for this model:: + + my_alg = particles.SMC(fk=my_fk_model, N=200) + my_alg.run() + +In case you are not clear about what are Feynman-Kac models, and how one may +associate a Feynman-Kac model to a given state-space model, see Chapter 5 of +the book. + +To generate a guided Feynman-Kac model, we must provide proposal kernels (that +is, Markov kernels that define how we simulate particles X_t at time t, given +an ancestor X_{t-1}):: + + class StochVol_with_prop(StochVol): + def proposal0(self, data): + return dists.Normal(scale = self.sigma) + def proposal(t, xp, data): # a silly proposal + return dists.Normal(loc=rho * xp + data[t], scale=self.sigma) + + my_second_ssm = StochVol_with_prop(sigma=0.3) + my_better_fk_model = ssms.Guided(ssm=my_second_ssm, data=y) + # then run a SMC as above + +Voilà! You have now implemented a guided filter. + +.. note:: + The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. +""" +from __future__ import division, print_function + +from matplotlib.pyplot import hist +import state_space_models as ssm +import numpy as np +import core as core +import distributions as dists +from collectors import Moments +import utils +import kalman as kalman +from matplotlib import pyplot as plt +from sklearn.linear_model import Ridge + + +err_msg_missing_policy = """ + State-space model %s is missing method policy for controlled SMC, specify a policy + """ + +""" +TODO: +===== + + - Argument ssm must implement method: Policy function (Later on this will be taken out). + - + + QUESTIONS + --------- + - + + DISCUSION + --------- + - moove some functions to utils. + - reshape the classes and simplify it + - Make controlled SMC algo iterable + +""" + + +class TwistedFK(ssm.Bootstrap): + + """Twisted SMC for a given state-space model. + Parameters + ---------- + ssm: StateSpaceModel object + the considered state-space model + data: list-like + the data + + Returns + ------- + FeynmanKac object + the Feynman-Kac representation of the bootstrap filter for the + considered state-space model + + Note + ---- + Argument ssm must implement methods a Policy function (Later on this will be taken out). + """ + def M0(self, N): + ''' Initial-Distribution ''' + return self.M(0, self.ssm.PX0().rvs(size=N)) + + def M(self, t, xp): + ''' ψ-Distribution of X_t given X_{t-1}=xp ''' + it = t*np.ones(xp.shape[0]).astype(int) + if self.ssm.PX(t, xp).dim == 1: + loop = [self.PsiProposal (it[i], xp[i]) for i in range (0, len(it)) ] + transition = np.array(loop).reshape(xp.shape[0]) + else: + loop = [self.PsiProposal (int(it[i]), xp[i,:]) for i in range (0, len(it)) ] + transition = np.array(loop).reshape(xp.shape[0], xp.shape[1]) + + return transition + + + def PsiProposal(self, t, xp): # M-ψ-Proposal + + myPolicy = self.ssm.policy + At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) + + dim = self.ssm.PX(t, xp).dim + + if t == 0: + Mean = self.ssm.PX0().loc + Var = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 + else: + Mean = self.ssm.PX(t, xp).loc + Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 + + VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var + V = np.dot(VarInv, Mean) - Bt + Alpha = np.linalg.inv(VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) + mbar = np.dot(Alpha, V) + + if dim == 1: + ProposalxPsiLaw = dists.Normal(loc=mbar, scale = np.sqrt(Alpha)) + else: + ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale = 1, cov = Alpha) + + return ProposalxPsiLaw.rvs(size=1) + + def logG(self, t, xp, x): # Log Potentials + + # retrieve policy from ssm model + myPolicy = self.ssm.policy + + At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) + + # initialisation + LogPolicy = np.zeros(x.shape[0]) + LogExpect = np.zeros(x.shape[0]) + LogForwardExpt = np.zeros(x.shape[0]) + + for v in range(x.shape[0]): + if self.du == 1: + LogPolicy[v] = -self.Quadratic( At, Bt, Ct, x[v]) + if t != self.T: + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + if t == 0: + LogExpect[v] = self.logCondExp(t, x[v]) + else: + LogPolicy[v] = - self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + if t != self.T-1: + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + if t == 0: + LogExpect[v] = self.logCondExp(t, x[v]) + + if t == 0: + LogNuPsiOnPolicy = LogExpect - LogPolicy + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogForwardExp = LogForwardExpt + LogGPsi = LogPotential + LogForwardExp + LogNuPsiOnPolicy + return LogGPsi + + if t == self.T-1: + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogGPsi = LogPotential - LogPolicy + return LogPotential - LogPolicy + else: + LogForwardExp = LogForwardExpt + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogGPsi = LogPotential + LogForwardExpt - LogPolicy + return LogGPsi + + + def logPolicy(self, t, xp, x, policy_t): + LogPolicy = np.ones(x.shape[0]) + At = policy_t[0] + Bt = policy_t[1] + Ct = policy_t[2] + for v in range(x.shape[0]): + if self.du == 1: + LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) + else: + LogPolicy[v] = -self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + return LogPolicy + + + def logCondExp(self, t, xp): + # TODO: make the function depends on policy ! + + """ Log Conditional expectation with respect to the Markov kernel at time t + summary_ \E_M(ψ(Xp_t,X_t)) + + Args: + t (_type_): _description_ + xp (_type_): _description_ + + Returns: + \E_M(ψ(Xp_t,X_t)) + """ + dim = self.du + myPolicy = self.ssm.policy + + A , B , C = myPolicy[t-1] if type(myPolicy) is np.ndarray else self.ssm.policy(t-1) + + if t == 0: + Mean = self.ssm.PX0().loc + Cov = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 + else: + Mean = self.ssm.PX(t, xp).loc + Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 + + result = self.logCondFun(t, A, B, C, Mean, Cov) + + return result + + @property + def isADP(self): + """Returns true if we perform an ADP""" + return 'ADP' in dir(self) + + @staticmethod + def Quadratic(A, B, c, x): + if type(x) is np.ndarray: + result = np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c + else: + result = A*x**2 + B*x + c + return result + + + def logCondFun(self, t, A, B, C, Mean, Cov): + + """Log conditional expectation function""" + + dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 + Identity = np.identity(dim) + CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov + V = np.dot(CovInv, Mean) - B + Alpha = np.linalg.inv(CovInv + 2*A) if dim > 1 else 1.0 /(CovInv + 2*A) + quadraV = 0.5*self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) + quadraGamaMean = - 0.5*self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) + + Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A + return quadraV + quadraGamaMean -0.5 * np.log(Det) - C + + +class ControlledSMC(TwistedFK): + + """ Controlled SMC class algorithm + + Parameters + Inputs. + ------------------------------------------------------------- + It is the same as of TwistedFK + iterations (number of iterations) to use for the controlled SMC + + ssm: StateSpaceModel object + the considered state-space model (-ssm with proposal and logEta(the psi)), + data: list-like + the data + + Returns + ------- + [type]: [description] + FeynmanKac object + the Feynman-Kac representation of the filter for the + considered state-space model + + """ + + def __init__(self, ssm=None, data=None, iterations = None): + self.ssm = ssm + self.data = data + self.iterations = 1 + self.du = self.ssm.PX0().dim + self.policy = self.ssm.policy + self.iter = 0 + + @property + def T(self): + return 0 if self.data is None else len(self.data) + + @property + def isPolicyMissing(self): + """Returns true if model parameter contains policy in the argument dictionary in ssm constructor""" + if (hasattr(self, self.ssm.policy) == False): # if('policy' in dir(self) == False): + raise NotImplementedError(self._error_msg('missing policy')) + + def next(self): + return self.__next__() + + def __iter__(self): + return self + + @utils.timer + def run(self): # make this iterator() + for _ in self: + pass + + def generateIntialParticules(self): + N = len(self.data) + myPolicy = self.ssm.policy + policy_initial = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) + + # Construct and run the Psi Model for initialisation to compute ADP to refine the policy + fk_model = TwistedFK(self.ssm, self.data) + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # TODO: Add new field to the FK object. + self.hist = PsiSMC.hist + self.policy = policy_initial + + + def generateParticulesWithADP(self): + settings = {'N': len(self.data), 'sample_trajectory': False, + 'regularization': 1e-4} + # fk_model = self.hist + PsiSMC = self.hist + adp = self.ADP(self.data, self.policy, PsiSMC, settings) + refinedPolicy = adp['policy_refined'] + self.ssm.set_policy(refinedPolicy) + + # Run ψ -twisted SMC with refined policy + fk_model = TwistedFK(self.ssm, self.data) + fk_model.isADP == True + PsiSMC = core.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # TODO: Add new field to the FK object. + self.hist = PsiSMC.hist + self.policy = refinedPolicy + + + def RunAll(self): # def __next__(self): + # if self.done(self): + # raise StopIteration + # if self.iterations == 1: + # intialisation + N = len(self.data) + myPolicy = self.ssm.policy + policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + + policySSM = [policy for t in range(self.T+1)] + policySSM = [[0.0 , 0.0, 0.0] for t in range(self.T+1)] + + + # Construct and run the Psi Model for initialisation + fk_model = TwistedFK(self.ssm, self.data) + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + histDataPsiSMC = PsiSMC.hist + settings = {'N': N, 'sample_trajectory': False, + 'regularization': 1e-4} + # else: + for it in range(self.iterations): + # run ADP + adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) + # Construct refined policy + refinedPolicy = adp['policy_refined'] + self.ssm.set_policy(refinedPolicy) + TestRefinedPolicy = np.array(self.ssm.policy) + # Run ψ-twisted SMC with refined policy + fk_model = TwistedFK(self.ssm, self.data) + fk_model.isADP == True + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[Moments()], store_history=True) + PsiSMC.run() + return PsiSMC.hist + + def ADP(self, observations, policy, psi_smc, settings): + """ + model = ssm or any kind of model + observations = data + psi_smc = fk.run().results (derived from fk.run()) + settings = parameters of the model you define yourself + + Approximate dynamic programming to refine a policy. + + In Python method overriding occurs by simply defining in the child class a method with the same name of a method + in the parent class. When you define a method in the object you make this latter able to satisfy that method call, + so the implementations of its ancestors do not come in play. + + Parameters + ---------- + model : controlledpsi_smc.models.LRR.ssm + A ssm class instance + + observations : numpy.array (T+1, dim_y) + Time series + + settings : dict + Particle filtering settings contain: + 'N' : int specifying number of particles + 'sample_trajectory' : bool specifying whether a trajectory is to be sampled + + policy : list of dicts of length T+1 + Coefficients specifying policy + + inverse_temperature : float + The inverse temperature controls the annealing of the observation densities + + Returns + + ------- + output : dict + Algorithm output contain: + 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy + 'r_squared' : numpy.array (T+1,) containing coefficient of determination values + """ + + # get model properties and algorithmic settings + T = len(observations) - 1 # observations.shape[0] - 1 + N = settings['N'] + + HistoryData = psi_smc.hist + + # pre-allocate + policy_refined = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) + + r_squared = np.ones([T+1]) + + # initialize at T + states_previous = psi_smc.Xp + states_current = psi_smc.X + log_conditional_expectation = np.zeros([N]) + + + # iterate over time periods backwards + for t in range(T, 0, -1): + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + + # compute uncontrolled weights of reference proposal transition + log_weights_uncontrolled = self.log_weights_uncontrolled(t, states_previous, states_current) # (t, observations[t, :], states_previous, states_current) + + # evaluate log-policy function + log_policy = self.log_policy(t, policy[t], states_previous, states_current) + + # target function values + target_values = log_weights_uncontrolled.reshape(len(log_policy), 1) + \ + log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape(len(log_policy), 1) # TODO: log_conditional_expectation is not calculated here ! + + # perform regression to learn refinement (update this function for high dimensional case) + (refinement, r_squared[t]) = self.learn_refinement( + states_previous, states_current, target_values, settings) + + # refine current policy + policy_refined[t] = self.refine_policy(policy[t], refinement) + + # set Policy + self.ssm.set_policy(policy_refined) + + # compute log-conditional expectation of refined policy + if t != 1: + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + log_conditional_expectation = self.log_conditional_expectation(t, policy_refined[t], states_current) + + output = {'policy_refined': policy_refined } + + return output + + + """ + FONCTIONS USED FOR ADP FUNCTION ABOVE + """ + + def log_weights_uncontrolled(self, t, xp, x ): + """ """ + return self.ssm.PY(t, xp, x).logpdf(self.data[t]) + + def log_policy(self, t, policy, xp, x ): + """ """ + LogPolicy = self.logPolicy(t, xp, x, policy) + return LogPolicy + + def log_conditional_expectation(self, t, policy_refined, x): + """ """ + LogCondExpect = np.ones(x.shape[0]) + + it = t*np.ones(x.shape[0]).astype(int) + + if self.ssm.PX(t, x).dim == 1: + loop = [self.logCondExp(it[i], x[i]) for i in range (0, len(it))] + LogCondExpect = np.array(loop).reshape(x.shape[0]) + else: + loop = [self.logCondExp(it[i], x[i,:]) for i in range (0, len(it)) ] + + LogCondExpect = np.array(loop).reshape(x.shape[0], 1) + + return LogCondExpect + + + def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here + """ + Learn policy refinement using ridge regression. + + Parameters + ---------- + xp : numpy.array (N, dim_s) + Latent states at previous time period + x : numpy.array (N, dim_s) + Latent states at current time period + target_values : numpy.array (N,) + Target function values at latent states + settings : dict + Regression settings + + Returns + ------- + refinement : dict + Coefficients specifying the refinement at the current time period + r_squared : float + Coefficient of determination + """ + # construct design matrix + if self.du == 1: + x = x.reshape(x.shape[0],1) + xp = xp.reshape(xp.shape[0],1) + + design_matrix = self.design_matrix_Quadratic_univariate(x) + + # perform ridge regression + ridge_regressor = Ridge(alpha=settings['regularization'], fit_intercept=False) + ridge_regressor.fit(design_matrix, - target_values) + + # get refinement coefficients from regression coefficients + refinement = ridge_regressor.coef_ # self.get_coef_Quadratic_univariate(ridge_regressor.coef_) + + # compute R-squared + r_squared = np.corrcoef(ridge_regressor.predict(design_matrix), target_values)[0, 1]**2 + + return (refinement, r_squared) + + def get_coef_Quadratic_univariate(self, regression_coef): + """ + Get coefficients (a, b, c) of the Quadratic function of a univariate variable x + Q(x) = a * x^2 + b * x + c + given an array of regression coefficients. + + Parameters + ---------- + regression_coef : numpy.array (num_features,) where num_features = 3 + Array of regression coefficients + + Returns + ------- + output : dict + """ + # get coefficients + output = {} + + output['a'] = regression_coef[2] # output['a'] = regression_coef[2] + output[1] = regression_coef[2] # output['a'] = regression_coef[2] + + output['b'] = regression_coef[1] # output['b'] = regression_coef[1] + output['c'] = regression_coef[0] # output['c'] = regression_coef[0] + return output + + def design_matrix_Quadratic_univariate(self, x): + """ + Construct design matrix of features for Quadratic function of a univariate variable + Q(x) = a * x^2 + b * x + c. + + Parameters + ---------- + x : numpy.array (N, 1) + + Returns + ------- + design_matrix : numpy.array (N, num_features) where num_features = 3 + """ + + # get size + N = x.shape[0] + + # construct design matrix + num_features = 3 + design_matrix = np.ones([N, num_features]) # for intercept c + design_matrix[:, 1] = x[:, 0] # for coefficient b + design_matrix[:, 2] = x[:, 0]**2 # for coefficient a + + return design_matrix + + def refine_policy(self, policy_current, refinement): + """ + Perform policy refinement. + + Parameters + ---------- + policy_current : dict + Coefficients specifying the policy at the current time period + + refinement : dict + Coefficients specifying the refinement at the current time period + + Returns + ------- + output : dict + Coefficients specifying the refined policy at the current time period + """ + + if self.du == 1: + outPut = policy_current + np.exp(-refinement) + else: # should be updated + outPut = policy_current + refinement + return outPut \ No newline at end of file From 495ada6b02c729de93ba029898bb9d91c22088cb Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:14:26 +0200 Subject: [PATCH 05/15] Delete state_space_models.py --- state_space_models.py | 683 ------------------------------------------ 1 file changed, 683 deletions(-) delete mode 100644 state_space_models.py diff --git a/state_space_models.py b/state_space_models.py deleted file mode 100644 index 4f78fe3..0000000 --- a/state_space_models.py +++ /dev/null @@ -1,683 +0,0 @@ -# -*- coding: utf-8 -*- - -r""" -State-space models as Python objects. - -Overview -======== -This module defines: - - 1. the `StateSpaceModel` class, which lets you define a state-space model - as a Python object; - - 2. `FeynmanKac` classes that automatically define the Bootstrap, guided or - auxiliary Feynman-Kac models associated to a given state-space model; - - 3. several standard state-space models (stochastic volatility, - bearings-only tracking, and so on). - -The recommended import is:: - - from particles import state_space_models as ssms - -For more details on state-space models and their properties, see Chapters 2 and -4 of the book. - -Defining a state-space model -============================ - -Consider the following (simplified) stochastic volatility model: - -.. math:: - - Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ - X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ - X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) - -To define this particular model, we sub-class `StateSpaceModel` as follows:: - - import numpy as np - from particles import distributions as dists - - class SimplifiedStochVol(ssms.StateSpaceModel): - default_params = {'sigma': 1., 'rho': 0.8} # optional - def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} - return dists.Normal(scale=np.exp(x)) - def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} - return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), - scale=self.sigma) - def PX0(self): # dist of X_0 - return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) - -Then we define a particular object (model) by instantiating this class:: - - my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9) - -Hopefully, the code above is fairly transparent, but here are some noteworthy -details: - - * probability distributions are defined through `ProbDist` objects, which - are defined in module `distributions`. Most basic probability - distributions are defined there; see module `distributions` for more details. - * The class above actually defines a **parametric** class of models; in - particular, ``self.sigma`` and ``self.rho`` are **attributes** of - this class that are set when we define object `my_stoch_vol_model`. - Default values for these parameters may be defined in a dictionary called - ``default_params``. When this dictionary is defined, any un-defined - parameter will be replaced by its default value:: - - default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8 - * There is no need to define a ``__init__()`` method, as it is already - defined by the parent class. (This parent ``__init__()`` simply takes - care of the default parameters, and may be overrided if needed.) - -Now that our state-space model is properly defined, what can we do with it? -First, we may simulate states and data from it:: - - x, y = my_stoch_vol_model.simulate(20) - -This generates two lists of length 20: a list of states, X_0, ..., X_{19} and -a list of observations (data-points), Y_0, ..., Y_{19}. - -Associated Feynman-Kac models -============================= - -Now that our state-space model is defined, we obtain the associated Bootstrap -Feynman-Kac model as follows:: - - my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) - -That's it! You are now able to run a bootstrap filter for this model:: - - my_alg = particles.SMC(fk=my_fk_model, N=200) - my_alg.run() - -In case you are not clear about what are Feynman-Kac models, and how one may -associate a Feynman-Kac model to a given state-space model, see Chapter 5 of -the book. - -To generate a guided Feynman-Kac model, we must provide proposal kernels (that -is, Markov kernels that define how we simulate particles X_t at time t, given -an ancestor X_{t-1}):: - - class StochVol_with_prop(StochVol): - def proposal0(self, data): - return dists.Normal(scale = self.sigma) - def proposal(t, xp, data): # a silly proposal - return dists.Normal(loc = rho * xp + data[t], scale=self.sigma) - - my_second_ssm = StochVol_with_prop(sigma=0.3) - my_better_fk_model = ssms.Guided(ssm = my_second_ssm, data=y) - # then run a SMC as above - -Voilà! You have now implemented a guided filter. - -Of course, the proposal distribution above does not make much sense; we use it -to illustrate how proposals may be defined. Note in particular that it depends -on ``data``, an object that represents the complete dataset. Hence the proposal -kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other -datapoint. - -For auxiliary particle filters (APF), one must in addition specify auxiliary -functions, that is the (log of) functions :math:`\eta_t` that modify the -resampling probabilities (see Section 10.3.3 in the book):: - - class StochVol_with_prop_and_aux_func(StochVol_with_prop): - def logeta(self, t, x, data): - "Log of auxiliary function eta_t at time t" - return -(x-data[t])**2 - - my_third_ssm = StochVol_with_prop_and_aux_func() - apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y) - -Again, this particular choice does not make much sense, and is just given to -show how to define an auxiliary function. - -Already implemented state-space models -====================================== - -This module implements a few basic state-space models that are often used as -numerical examples: - -=================== ===================================================== -Class Comments -=================== ===================================================== -`StochVol` Basic, univariate stochastic volatility model -`StochVolLeverage` Univariate stochastic volatility model with leverage -`MVStochVol` Multivariate stochastic volatility model -`BearingsOnly` Bearings-only tracking -`Gordon_etal` Popular toy model often used as a benchmark -`DiscreteCox` A discrete Cox model (Y_t|X_t is Poisson) -`ThetaLogistic` Theta-logistic model from Population Ecology -=================== ===================================================== - -.. note:: - Linear Gaussian state-space models are implemented in module `kalman`; - similarly hidden Markov models (state-space models with a finite state-space) - are implemented in module `hmm`. - -""" - -from __future__ import division, print_function -import numpy as np - -import particles -from particles import distributions as dists - -err_msg_missing_cst = """ - State-space model %s is missing method upper_bound_log_pt, which provides - log of constant C_t, such that - p(x_t|x_{t-1}) <= C_t - This is required for smoothing algorithms based on rejection - """ -err_msg_missing_policy = """ - State-space model %s is missing method policy (a dictionnary) for controlled SMC, specify a policy dictionnary - """ - -class StateSpaceModel(object): - """Base class for state-space models. - - To define a state-space model class, you must sub-class `StateSpaceModel`, - and at least define methods PX0, PX, and PY. Here is an example:: - - class LinearGauss(StateSpaceModel): - def PX0(self): # The law of X_0 - return dists.Normal(scale=self.sigmaX) - def PX(self, t, xp): # The law of X_t conditional on X_{t-1} - return dists.Normal(loc=self.rho * xp, scale=self.sigmaY) - def PY(self, t, xp, x): # the law of Y_t given X_t and X_{t-1} - return dists.Normal(loc=x, scale=self.sigmaY) - - These methods return ``ProbDist`` objects, which are defined in the module - `distributions`. The model above is a basic linear Gaussian SSM; it - depends on parameters rho, sigmaX, sigmaY (which are attributes of the - class). To define a particular instance of this class, we do:: - - a_certain_ssm = LinearGauss(rho=.8, sigmaX=1., sigmaY=.2) - - All the attributes that appear in ``PX0``, ``PX`` and ``PY`` must be - initialised in this way. Alternatively, it it possible to define default - values for these parameters, by defining class attribute - ``default_params`` to be a dictionary as follows:: - - class LinearGauss(StateSpaceModel): - default_params = {'rho': .9, 'sigmaX': 1., 'sigmaY': .1} - # rest as above - - Optionally, we may also define methods: - - * `proposal0(self, data)`: the (data-dependent) proposal dist at time 0 - * `proposal(self, t, xp, data)`: the (data-dependent) proposal distribution at - time t, for X_t, conditional on X_{t-1}=xp - * `logeta(self, t, x, data)`: the auxiliary weight function at time t - - You need these extra methods to run a guided or auxiliary particle filter. - - """ - - def __init__(self, **kwargs): - if hasattr(self, 'default_params'): - self.__dict__.update(self.default_params) - self.__dict__.update(kwargs) - - def _error_msg(self, method): - return ('method ' + method + ' not implemented in class%s' % - self.__class__.__name__) - - @classmethod - def state_container(cls, N, T): - law_X0 = cls().PX0() - dim = law_X0.dim - shape = [N, T] - if dim>1: - shape.append(dim) - return np.empty(shape, dtype=law_X0.dtype) - - def PX0(self): - "Law of X_0 at time 0" - raise NotImplementedError(self._error_msg('PX0')) - - def PX(self, t, xp): - " Law of X_t at time t, given X_{t-1} = xp" - raise NotImplementedError(self._error_msg('PX')) - - def PY(self, t, xp, x): - """Conditional distribution of Y_t, given the states. - """ - raise NotImplementedError(self._error_msg('PY')) - - def proposal0(self, data): - raise NotImplementedError(self._error_msg('proposal0')) - - def proposal(self, t, xp, data): - """Proposal kernel (to be used in a guided or auxiliary filter). - - Parameter - --------- - t: int - time - x: - particles - data: list-like - data - """ - raise NotImplementedError(self._error_msg('proposal')) - - @property - def policy(self): - """policy : - Coefficients specifying policy - policy should be exponential quadratic - log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A is a matrix dxd, b a vector, c scalar - return the list [At, Bt, Ct] - A_t is a matrix - Bt is a vector of dimension of the - Ct is !! - """ - raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) - - def get_policy(self): - return self.policy - - def set_policy(self, newPolicy): - self.policy = newPolicy - - - def upper_bound_log_pt(self, t): - """Upper bound for log of transition density. - - See `smoothing`. - """ - raise NotImplementedError(err_msg_missing_cst % self.__class__.__name__) - - def add_func(self, t, xp, x): - """Additive function.""" - raise NotImplementedError(self._error_msg('add_func')) - - def simulate_given_x(self, x): - lag_x = [None] + x[:-1] - return [self.PY(t, xp, x).rvs(size=1) - for t, (xp, x) in enumerate(zip(lag_x, x))] - - def simulate(self, T): - """Simulate state and observation processes. - - Parameters - ---------- - T: int - processes are simulated from time 0 to time T-1 - - Returns - ------- - x, y: lists - lists of length T - """ - x = [] - for t in range(T): - law_x = self.PX0() if t == 0 else self.PX(t, x[-1]) - x.append(law_x.rvs(size=1)) - y = self.simulate_given_x(x) - return x, y - - -class Bootstrap(particles.FeynmanKac): - """Bootstrap Feynman-Kac formalism of a given state-space model. - - Parameters - ---------- - - ssm: `StateSpaceModel` object - the considered state-space model - data: list-like - the data - - Returns - ------- - `FeynmanKac` object - the Feynman-Kac representation of the bootstrap filter for the - considered state-space model - """ - def __init__(self, ssm=None, data=None): - self.ssm = ssm - self.data = data - self.du = self.ssm.PX0().dim - - @property - def T(self): - return 0 if self.data is None else len(self.data) - - def M0(self, N): - return self.ssm.PX0().rvs(size=N) - - def M(self, t, xp): - return self.ssm.PX(t, xp).rvs(size=xp.shape[0]) - - def logG(self, t, xp, x): - return self.ssm.PY(t, xp, x).logpdf(self.data[t]) - - def Gamma0(self, u): - return self.ssm.PX0().ppf(u) - - def Gamma(self, t, xp, u): - return self.ssm.PX(t, xp).ppf(u) - - def logpt(self, t, xp, x): - """PDF of X_t|X_{t-1}=xp""" - return self.ssm.PX(t, xp).logpdf(x) - - def upper_bound_trans(self, t): - return self.ssm.upper_bound_log_pt(t) - - def add_func(self, t, xp, x): - return self.ssm.add_func(t, xp, x) - - -class GuidedPF(Bootstrap): - """Guided filter for a given state-space model. - - Parameters - ---------- - - ssm: StateSpaceModel object - the considered state-space model - data: list-like - the data - - Returns - ------- - FeynmanKac object - the Feynman-Kac representation of the bootstrap filter for the - considered state-space model - - Note - ---- - Argument ssm must implement methods `proposal0` and `proposal`. - """ - - def M0(self, N): - return self.ssm.proposal0(self.data).rvs(size=N) - - def M(self, t, xp): - return self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0]) - - def logG(self, t, xp, x): - if t == 0: - return (self.ssm.PX0().logpdf(x) - + self.ssm.PY(0, xp, x).logpdf(self.data[0]) - - self.ssm.proposal0(self.data).logpdf(x)) - else: - return (self.ssm.PX(t, xp).logpdf(x) - + self.ssm.PY(t, xp, x).logpdf(self.data[t]) - - self.ssm.proposal(t, xp, self.data).logpdf(x)) - - def Gamma0(self, u): - return self.ssm.proposal0(self.data).ppf(u) - - def Gamma(self, t, xp, u): - return self.ssm.proposal(t, xp, self.data).ppf(u) - -class APFMixin(): - def logeta(self, t, x): - return self.ssm.logeta(t, x, self.data) - -class AuxiliaryPF(GuidedPF, APFMixin): - """Auxiliary particle filter for a given state-space model. - - Parameters - ---------- - - ssm: StateSpaceModel object - the considered state-space model - data: list-like - the data - - Returns - ------- - `FeynmanKac` object - the Feynman-Kac representation of the APF (auxiliary particle filter) - for the considered state-space model - - Note - ---- - Argument ssm must implement methods `proposal0`, `proposal` and `logeta`. - """ - - pass - - -class AuxiliaryBootstrap(Bootstrap, APFMixin): - """Base class for auxiliary bootstrap particle filters - - This is an APF, such that the proposal kernel is set to the transition - kernel of the model - """ - - pass - - -################################ -# Specific state-space models -################################ - -class StochVol(StateSpaceModel): - r"""Univariate stochastic volatility model. - - .. math:: - - X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\ - X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t, \quad U_t\sim N(0,1) \\ - Y_t|X_t=x_t & \sim N(0, e^{x_t}) \\ - """ - default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178} - # values taken from Pitt & Shephard (1999) - - def sig0(self): - """std of X_0""" - return self.sigma / np.sqrt(1. - self.rho**2) - - def PX0(self): - return dists.Normal(loc=self.mu, scale=self.sig0()) - - def EXt(self, xp): - """compute E[x_t|x_{t-1}]""" - return (1. - self.rho) * self.mu + self.rho * xp - - def PX(self, t, xp): - return dists.Normal(loc=self.EXt(xp), scale=self.sigma) - - def PY(self, t, xp, x): - return dists.Normal(loc=0., scale=np.exp(0.5 * x)) - - def _xhat(self, xst, sig, yt): - return xst + 0.5 * sig**2 * (yt**2 * np.exp(-xst) - 1.) - - def proposal0(self, data): - # Pitt & Shephard - return dists.Normal(loc=self._xhat(0., self.sig0(), data[0]), - scale=self.sig0()) - - def proposal(self, t, xp, data): - # Pitt & Shephard - return dists.Normal(loc=self._xhat(self.EXt(xp), - self.sigma, data[t]), - scale=self.sigma) - - def logeta(self, t, x, data): - # Pitt & Shephard - xst = self.EXt(x) - xstmmu = xst - self.mu - xhat = self._xhat(xst, self.sigma, data[t + 1]) - xhatmmu = xhat - self.mu - return (0.5 / self.sigma**2 * (xhatmmu**2 - xstmmu**2) - - 0.5 * data[t + 1]**2 * np.exp(-xst) * (1. + xstmmu)) - - -class StochVolLeverage(StochVol): - r"""Univariate stochastic volatility model with leverage effect. - - .. math:: - - X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\ - X_t|X_{t-1}=x_{t-1} & \sim N(\mu + \rho (x-\mu), \sigma^2) \\ - Y_t|X_{t-1:t} =x_{t-1:t} & \sim N( s \phi z, s^2 (1-\phi^2) ) - - with :math:`s=\exp(x_t/2), z = [x_t-\mu-\rho*(x_{t-1}-\mu)]/\sigma` - - Note - ---- - - This is equivalent to assuming that the innovations of X_t and Y_t - are correlated, with correlation :math:`\phi`: - - .. math:: - - X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t \\ - Y_t & = \exp(X_t/2) * V_t - - and :math:`Cor(U_t, V_t) = \phi` - - Warning - ------- - This class inherits from StochVol, but methods proposal, proposal0 - and logeta were constructed for StochVol only, and should not work properly - for this class. - """ - - default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178, 'phi': 0.} - - def PY(self, t, xp, x): - # u is realisation of noise U_t, conditional on X_t, X_{t-1} - if t==0: - u = (x - self.mu) / self.sig0() - else: - u = (x - self.EXt(xp)) / self.sigma - std_x = np.exp(0.5 * x) - return dists.Normal(loc=std_x * self.phi * u, - scale=std_x * np.sqrt(1. - self.phi**2)) - - -class Gordon_etal(StateSpaceModel): - r"""Popular toy example that appeared initially in Gordon et al (1993). - - .. math:: - - X_0 & \sim N(0, 2^2) \\ - X_t & = b X_{t-1} + c X_{t-1}/(1+X_{t-1}^2) + d*\cos(e*(t-1)) + \sigma_X V_t, \quad V_t \sim N(0,1) \\ - Y_t|X_t=x_t & \sim N(a*x_t^2, 1) - """ - default_params = {'a': 0.05, 'b': .5, 'c': 25., 'd': 8., 'e': 1.2, - 'sigmaX': 3.162278} # = sqrt(10) - - def PX0(self): - return dists.Normal(scale=2.) - - def PX(self, t, xp): - return dists.Normal(loc=self.b * xp + self.c * xp / (1. + xp**2) - + self.d * np.cos(self.e * (t - 1)), - scale=self.sigmaX) - - def PY(self, t, xp, x): - return dists.Normal(loc=self.a * x**2) - - -class BearingsOnly(StateSpaceModel): - """ Bearings-only tracking SSM. - - """ - default_params = {'sigmaX': 2.e-4, 'sigmaY': 1e-3, - 'x0': np.array([3e-3, -3e-3, 1., 1.])} - - def PX0(self): - return dists.IndepProd(dists.Normal(loc=self.x0[0], scale=self.sigmaX), - dists.Normal(loc=self.x0[1], scale=self.sigmaX), - dists.Dirac(loc=self.x0[2]), - dists.Dirac(loc=self.x0[3]) - ) - - def PX(self, t, xp): - return dists.IndepProd(dists.Normal(loc=xp[:, 0], scale=self.sigmaX), - dists.Normal(loc=xp[:, 1], scale=self.sigmaX), - dists.Dirac(loc=xp[:, 0] + xp[:, 2]), - dists.Dirac(loc=xp[:, 1] + xp[:, 3]) - ) - - def PY(self, t, xp, x): - angle = np.arctan(x[:, 3] / x[:, 2]) - angle[x[:, 2] < 0.] += np.pi - return dists.Normal(loc=angle, scale=self.sigmaY) - - -class DiscreteCox(StateSpaceModel): - r"""A discrete Cox model. - - .. math:: - Y_t | X_t=x_t & \sim Poisson(e^{x_t}) \\ - X_t & = \mu + \phi(X_{t-1}-\mu) + U_t, U_t ~ N(0, sigma^2) \\ - X_0 & \sim N(\mu, \sigma^2/(1-\phi**2)) - """ - default_params = {'mu': 0., 'sigma': 1., 'phi': 0.95} - - def PX0(self): - return dists.Normal(loc=self.mu, - scale=self.sigma / np.sqrt(1. - self.phi**2)) - - def PX(self, t, xp): - return dists.Normal(loc=self.mu + self.phi * (xp - self.mu), - scale=self.sigma) - - def PY(self, t, xp, x): - return dists.Poisson(rate=np.exp(x)) - - -class MVStochVol(StateSpaceModel): - """Multivariate stochastic volatility model. - - X_0 ~ N(mu,covX) - X_t-mu = F*(X_{t-1}-mu)+U_t U_t~N(0,covX) - Y_t(k) = exp(X_t(k)/2)*V_t(k) for k=1,...,d - V_t ~ N(0,corY) - """ - default_params = {'mu': 0., 'covX': None, 'corY': None, 'F': None} # TODO - - def offset(self): - return self.mu - np.dot(self.F, self.mu) - - def PX0(self): - return dists.MvNormal(loc=self.mu, cov=self.covX) - - def PX(self, t, xp): - return dists.MvNormal(loc=np.dot(xp, self.F.T) + self.offset(), - cov=self.covX) - - def PY(self, t, xp, x): - return dists.MvNormal(scale=np.exp(0.5 * x), cov=self.corY) - - -class ThetaLogistic(StateSpaceModel): - r""" Theta-Logistic state-space model (used in Ecology). - - .. math:: - - X_0 & \sim N(0, 1) \\ - X_t & = X_{t-1} + \tau_0 - \tau_1 * \exp(\tau_2 * X_{t-1}) + U_t, \quad U_t \sim N(0, \sigma_X^2) \\ - Y_t & \sim X_t + V_t, \quad V_t \sim N(0, \sigma_Y^2) - """ - default_params = {'tau0':.15, 'tau1':.12, 'tau2':.1, 'sigmaX': 0.47, - 'sigmaY': 0.39} # values from Peters et al (2010) - - def PX0(self): - return dists.Normal(loc=0., scale=1.) - - def PX(self, t, xp): - return dists.Normal(loc=xp + self.tau0 - self.tau1 * - np.exp(self.tau2 * xp), scale=self.sigmaX) - - def PY(self, t, xp, x): - return dists.Normal(loc=x, scale=self.sigmaY) - - def proposal0(self, data): - return self.PX0().posterior(data[0], sigma=self.sigmaY) - - def proposal(self, t, xp, data): - return self.PX(t, xp).posterior(data[t], sigma=self.sigmaY) - \ No newline at end of file From 39fce7f7f5278d503091ff767991088c0fa6d5b3 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:16:02 +0200 Subject: [PATCH 06/15] Delete controlled_smc.py --- controlled_smc.py | 689 ---------------------------------------------- 1 file changed, 689 deletions(-) delete mode 100644 controlled_smc.py diff --git a/controlled_smc.py b/controlled_smc.py deleted file mode 100644 index 2d70df5..0000000 --- a/controlled_smc.py +++ /dev/null @@ -1,689 +0,0 @@ -# -*- coding: utf-8 -*- - -""" -Controlled Sequential Monte Carlo models as Python objects. - -The policy function is an attribute of StateSpaceModel class. - - -****************************************************************************** -Overview -======== -This module defines: - - 1. the `ControlledSMC` class, which lets you define a controlled sequential Monte Carlo model - as a Python object; - - 2. `TwistedFK` class that define a twisted Feynman-Kac models - - -The recommended import is:: - - from particles import ControlledSMC module as CtSMC - -For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396 - -Steps to define a ControlledSMC model -============================== -Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]) - This model should be an ssm object. For example ssm = stovolModel() - - Define your policy functions. - -Step 2 : Create the ControlledSMC object as follow: - - myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5) - ssm = your original defined model - data: is your data - iterations = fixed at your convenience. - -Example: --------- -Consider the following (simplified) stochastic volatility model: -.. math:: - - Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ - X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ - X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) - -To define this particular model, we sub-class from `ControlledSMC` as follows:: - - import numpy as np - from particles import distributions as dists - - class SimplifiedStochVol(ssms.StateSpaceModel): - default_parameters = {'sigma': 1., 'rho': 0.8} # optional - def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} - return dists.Normal(scale=np.exp(x)) - def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} - return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), - scale=self.sigma) - def PX0(self): # dist of X_0 - return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) - -Then we define a particular object (model) by instantiating this class:: - - stovolModel = SimplifiedStochVol(sigma=0.3, rho=0.9) - - myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) - - -Hopefully, the code above is fairly transparent, but here are some noteworthy -details: - - -TODO: Associated Feynman-Kac models -============================= - -Now that our state-space model is defined, we obtain the associated Bootstrap -Feynman-Kac model as follows: - - my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) - -That's it! You are now able to run a bootstrap filter for this model:: - - my_alg = particles.SMC(fk=my_fk_model, N=200) - my_alg.run() - -In case you are not clear about what are Feynman-Kac models, and how one may -associate a Feynman-Kac model to a given state-space model, see Chapter 5 of -the book. - -To generate a guided Feynman-Kac model, we must provide proposal kernels (that -is, Markov kernels that define how we simulate particles X_t at time t, given -an ancestor X_{t-1}):: - - class StochVol_with_prop(StochVol): - def proposal0(self, data): - return dists.Normal(scale = self.sigma) - def proposal(t, xp, data): # a silly proposal - return dists.Normal(loc=rho * xp + data[t], scale=self.sigma) - - my_second_ssm = StochVol_with_prop(sigma=0.3) - my_better_fk_model = ssms.Guided(ssm=my_second_ssm, data=y) - # then run a SMC as above - -Voilà! You have now implemented a guided filter. - -.. note:: - The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. -""" -from __future__ import division, print_function - -from matplotlib.pyplot import hist -import state_space_models as ssm -import numpy as np -import core as core -import distributions as dists -from collectors import Moments -import utils -import kalman as kalman -from matplotlib import pyplot as plt -from sklearn.linear_model import Ridge - - -err_msg_missing_policy = """ - State-space model %s is missing method policy for controlled SMC, specify a policy - """ - -""" -TODO: -===== - - - Argument ssm must implement method: Policy function (Later on this will be taken out). - - - - QUESTIONS - --------- - - - - DISCUSION - --------- - - moove some functions to utils. - - reshape the classes and simplify it - - Make controlled SMC algo iterable - -""" - - -class TwistedFK(ssm.Bootstrap): - - """Twisted SMC for a given state-space model. - Parameters - ---------- - ssm: StateSpaceModel object - the considered state-space model - data: list-like - the data - - Returns - ------- - FeynmanKac object - the Feynman-Kac representation of the bootstrap filter for the - considered state-space model - - Note - ---- - Argument ssm must implement methods a Policy function (Later on this will be taken out). - """ - def M0(self, N): - ''' Initial-Distribution ''' - return self.M(0, self.ssm.PX0().rvs(size=N)) - - def M(self, t, xp): - ''' ψ-Distribution of X_t given X_{t-1}=xp ''' - it = t*np.ones(xp.shape[0]).astype(int) - if self.ssm.PX(t, xp).dim == 1: - loop = [self.PsiProposal (it[i], xp[i]) for i in range (0, len(it)) ] - transition = np.array(loop).reshape(xp.shape[0]) - else: - loop = [self.PsiProposal (int(it[i]), xp[i,:]) for i in range (0, len(it)) ] - transition = np.array(loop).reshape(xp.shape[0], xp.shape[1]) - - return transition - - - def PsiProposal(self, t, xp): # M-ψ-Proposal - - myPolicy = self.ssm.policy - At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) - - dim = self.ssm.PX(t, xp).dim - - if t == 0: - Mean = self.ssm.PX0().loc - Var = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 - else: - Mean = self.ssm.PX(t, xp).loc - Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 - - VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var - V = np.dot(VarInv, Mean) - Bt - Alpha = np.linalg.inv(VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) - mbar = np.dot(Alpha, V) - - if dim == 1: - ProposalxPsiLaw = dists.Normal(loc=mbar, scale = np.sqrt(Alpha)) - else: - ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale = 1, cov = Alpha) - - return ProposalxPsiLaw.rvs(size=1) - - def logG(self, t, xp, x): # Log Potentials - - # retrieve policy from ssm model - myPolicy = self.ssm.policy - - At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) - - # initialisation - LogPolicy = np.zeros(x.shape[0]) - LogExpect = np.zeros(x.shape[0]) - LogForwardExpt = np.zeros(x.shape[0]) - - for v in range(x.shape[0]): - if self.du == 1: - LogPolicy[v] = -self.Quadratic( At, Bt, Ct, x[v]) - if t != self.T: - LogForwardExpt[v] = self.logCondExp(t+1, x[v]) - if t == 0: - LogExpect[v] = self.logCondExp(t, x[v]) - else: - LogPolicy[v] = - self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) - if t != self.T-1: - LogForwardExpt[v] = self.logCondExp(t+1, x[v]) - if t == 0: - LogExpect[v] = self.logCondExp(t, x[v]) - - if t == 0: - LogNuPsiOnPolicy = LogExpect - LogPolicy - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) - LogForwardExp = LogForwardExpt - LogGPsi = LogPotential + LogForwardExp + LogNuPsiOnPolicy - return LogGPsi - - if t == self.T-1: - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) - LogGPsi = LogPotential - LogPolicy - return LogPotential - LogPolicy - else: - LogForwardExp = LogForwardExpt - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) - LogGPsi = LogPotential + LogForwardExpt - LogPolicy - return LogGPsi - - - def logPolicy(self, t, xp, x, policy_t): - LogPolicy = np.ones(x.shape[0]) - At = policy_t[0] - Bt = policy_t[1] - Ct = policy_t[2] - for v in range(x.shape[0]): - if self.du == 1: - LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) - else: - LogPolicy[v] = -self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) - return LogPolicy - - - def logCondExp(self, t, xp): - # TODO: make the function depends on policy ! - - """ Log Conditional expectation with respect to the Markov kernel at time t - summary_ \E_M(ψ(Xp_t,X_t)) - - Args: - t (_type_): _description_ - xp (_type_): _description_ - - Returns: - \E_M(ψ(Xp_t,X_t)) - """ - dim = self.du - myPolicy = self.ssm.policy - - A , B , C = myPolicy[t-1] if type(myPolicy) is np.ndarray else self.ssm.policy(t-1) - - if t == 0: - Mean = self.ssm.PX0().loc - Cov = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 - else: - Mean = self.ssm.PX(t, xp).loc - Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 - - result = self.logCondFun(t, A, B, C, Mean, Cov) - - return result - - @property - def isADP(self): - """Returns true if we perform an ADP""" - return 'ADP' in dir(self) - - @staticmethod - def Quadratic(A, B, c, x): - if type(x) is np.ndarray: - result = np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c - else: - result = A*x**2 + B*x + c - return result - - - def logCondFun(self, t, A, B, C, Mean, Cov): - - """Log conditional expectation function""" - - dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 - Identity = np.identity(dim) - CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov - V = np.dot(CovInv, Mean) - B - Alpha = np.linalg.inv(CovInv + 2*A) if dim > 1 else 1.0 /(CovInv + 2*A) - quadraV = 0.5*self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) - quadraGamaMean = - 0.5*self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) - - Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A - return quadraV + quadraGamaMean -0.5 * np.log(Det) - C - - -class ControlledSMC(TwistedFK): - - """ Controlled SMC class algorithm - - Parameters + Inputs. - ------------------------------------------------------------- - It is the same as of TwistedFK + iterations (number of iterations) to use for the controlled SMC - - ssm: StateSpaceModel object - the considered state-space model (-ssm with proposal and logEta(the psi)), - data: list-like - the data - - Returns - ------- - [type]: [description] - FeynmanKac object - the Feynman-Kac representation of the filter for the - considered state-space model - - """ - - def __init__(self, ssm=None, data=None, iterations = None): - self.ssm = ssm - self.data = data - self.iterations = 1 - self.du = self.ssm.PX0().dim - self.policy = self.ssm.policy - self.iter = 0 - - @property - def T(self): - return 0 if self.data is None else len(self.data) - - @property - def isPolicyMissing(self): - """Returns true if model parameter contains policy in the argument dictionary in ssm constructor""" - if (hasattr(self, self.ssm.policy) == False): # if('policy' in dir(self) == False): - raise NotImplementedError(self._error_msg('missing policy')) - - def next(self): - return self.__next__() - - def __iter__(self): - return self - - @utils.timer - def run(self): # make this iterator() - for _ in self: - pass - - def generateIntialParticules(self): - N = len(self.data) - myPolicy = self.ssm.policy - policy_initial = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) - - # Construct and run the Psi Model for initialisation to compute ADP to refine the policy - fk_model = TwistedFK(self.ssm, self.data) - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', - collect=[Moments()], store_history=True) - PsiSMC.run() - - # TODO: Add new field to the FK object. - self.hist = PsiSMC.hist - self.policy = policy_initial - - - def generateParticulesWithADP(self): - settings = {'N': len(self.data), 'sample_trajectory': False, - 'regularization': 1e-4} - # fk_model = self.hist - PsiSMC = self.hist - adp = self.ADP(self.data, self.policy, PsiSMC, settings) - refinedPolicy = adp['policy_refined'] - self.ssm.set_policy(refinedPolicy) - - # Run ψ -twisted SMC with refined policy - fk_model = TwistedFK(self.ssm, self.data) - fk_model.isADP == True - PsiSMC = core.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', - collect=[Moments()], store_history=True) - PsiSMC.run() - - # TODO: Add new field to the FK object. - self.hist = PsiSMC.hist - self.policy = refinedPolicy - - - def RunAll(self): # def __next__(self): - # if self.done(self): - # raise StopIteration - # if self.iterations == 1: - # intialisation - N = len(self.data) - myPolicy = self.ssm.policy - policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. - policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. - - policySSM = [policy for t in range(self.T+1)] - policySSM = [[0.0 , 0.0, 0.0] for t in range(self.T+1)] - - - # Construct and run the Psi Model for initialisation - fk_model = TwistedFK(self.ssm, self.data) - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', - collect=[Moments()], store_history=True) - PsiSMC.run() - histDataPsiSMC = PsiSMC.hist - settings = {'N': N, 'sample_trajectory': False, - 'regularization': 1e-4} - # else: - for it in range(self.iterations): - # run ADP - adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) - # Construct refined policy - refinedPolicy = adp['policy_refined'] - self.ssm.set_policy(refinedPolicy) - TestRefinedPolicy = np.array(self.ssm.policy) - # Run ψ-twisted SMC with refined policy - fk_model = TwistedFK(self.ssm, self.data) - fk_model.isADP == True - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[Moments()], store_history=True) - PsiSMC.run() - return PsiSMC.hist - - def ADP(self, observations, policy, psi_smc, settings): - """ - model = ssm or any kind of model - observations = data - psi_smc = fk.run().results (derived from fk.run()) - settings = parameters of the model you define yourself - - Approximate dynamic programming to refine a policy. - - In Python method overriding occurs by simply defining in the child class a method with the same name of a method - in the parent class. When you define a method in the object you make this latter able to satisfy that method call, - so the implementations of its ancestors do not come in play. - - Parameters - ---------- - model : controlledpsi_smc.models.LRR.ssm - A ssm class instance - - observations : numpy.array (T+1, dim_y) - Time series - - settings : dict - Particle filtering settings contain: - 'N' : int specifying number of particles - 'sample_trajectory' : bool specifying whether a trajectory is to be sampled - - policy : list of dicts of length T+1 - Coefficients specifying policy - - inverse_temperature : float - The inverse temperature controls the annealing of the observation densities - - Returns - - ------- - output : dict - Algorithm output contain: - 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy - 'r_squared' : numpy.array (T+1,) containing coefficient of determination values - """ - - # get model properties and algorithmic settings - T = len(observations) - 1 # observations.shape[0] - 1 - N = settings['N'] - - HistoryData = psi_smc.hist - - # pre-allocate - policy_refined = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) - - r_squared = np.ones([T+1]) - - # initialize at T - states_previous = psi_smc.Xp - states_current = psi_smc.X - log_conditional_expectation = np.zeros([N]) - - - # iterate over time periods backwards - for t in range(T, 0, -1): - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] - - # compute uncontrolled weights of reference proposal transition - log_weights_uncontrolled = self.log_weights_uncontrolled(t, states_previous, states_current) # (t, observations[t, :], states_previous, states_current) - - # evaluate log-policy function - log_policy = self.log_policy(t, policy[t], states_previous, states_current) - - # target function values - target_values = log_weights_uncontrolled.reshape(len(log_policy), 1) + \ - log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape(len(log_policy), 1) # TODO: log_conditional_expectation is not calculated here ! - - # perform regression to learn refinement (update this function for high dimensional case) - (refinement, r_squared[t]) = self.learn_refinement( - states_previous, states_current, target_values, settings) - - # refine current policy - policy_refined[t] = self.refine_policy(policy[t], refinement) - - # set Policy - self.ssm.set_policy(policy_refined) - - # compute log-conditional expectation of refined policy - if t != 1: - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] - log_conditional_expectation = self.log_conditional_expectation(t, policy_refined[t], states_current) - - output = {'policy_refined': policy_refined } - - return output - - - """ - FONCTIONS USED FOR ADP FUNCTION ABOVE - """ - - def log_weights_uncontrolled(self, t, xp, x ): - """ """ - return self.ssm.PY(t, xp, x).logpdf(self.data[t]) - - def log_policy(self, t, policy, xp, x ): - """ """ - LogPolicy = self.logPolicy(t, xp, x, policy) - return LogPolicy - - def log_conditional_expectation(self, t, policy_refined, x): - """ """ - LogCondExpect = np.ones(x.shape[0]) - - it = t*np.ones(x.shape[0]).astype(int) - - if self.ssm.PX(t, x).dim == 1: - loop = [self.logCondExp(it[i], x[i]) for i in range (0, len(it))] - LogCondExpect = np.array(loop).reshape(x.shape[0]) - else: - loop = [self.logCondExp(it[i], x[i,:]) for i in range (0, len(it)) ] - - LogCondExpect = np.array(loop).reshape(x.shape[0], 1) - - return LogCondExpect - - - def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here - """ - Learn policy refinement using ridge regression. - - Parameters - ---------- - xp : numpy.array (N, dim_s) - Latent states at previous time period - x : numpy.array (N, dim_s) - Latent states at current time period - target_values : numpy.array (N,) - Target function values at latent states - settings : dict - Regression settings - - Returns - ------- - refinement : dict - Coefficients specifying the refinement at the current time period - r_squared : float - Coefficient of determination - """ - # construct design matrix - if self.du == 1: - x = x.reshape(x.shape[0],1) - xp = xp.reshape(xp.shape[0],1) - - design_matrix = self.design_matrix_Quadratic_univariate(x) - - # perform ridge regression - ridge_regressor = Ridge(alpha=settings['regularization'], fit_intercept=False) - ridge_regressor.fit(design_matrix, - target_values) - - # get refinement coefficients from regression coefficients - refinement = ridge_regressor.coef_ # self.get_coef_Quadratic_univariate(ridge_regressor.coef_) - - # compute R-squared - r_squared = np.corrcoef(ridge_regressor.predict(design_matrix), target_values)[0, 1]**2 - - return (refinement, r_squared) - - def get_coef_Quadratic_univariate(self, regression_coef): - """ - Get coefficients (a, b, c) of the Quadratic function of a univariate variable x - Q(x) = a * x^2 + b * x + c - given an array of regression coefficients. - - Parameters - ---------- - regression_coef : numpy.array (num_features,) where num_features = 3 - Array of regression coefficients - - Returns - ------- - output : dict - """ - # get coefficients - output = {} - - output['a'] = regression_coef[2] # output['a'] = regression_coef[2] - output[1] = regression_coef[2] # output['a'] = regression_coef[2] - - output['b'] = regression_coef[1] # output['b'] = regression_coef[1] - output['c'] = regression_coef[0] # output['c'] = regression_coef[0] - return output - - def design_matrix_Quadratic_univariate(self, x): - """ - Construct design matrix of features for Quadratic function of a univariate variable - Q(x) = a * x^2 + b * x + c. - - Parameters - ---------- - x : numpy.array (N, 1) - - Returns - ------- - design_matrix : numpy.array (N, num_features) where num_features = 3 - """ - - # get size - N = x.shape[0] - - # construct design matrix - num_features = 3 - design_matrix = np.ones([N, num_features]) # for intercept c - design_matrix[:, 1] = x[:, 0] # for coefficient b - design_matrix[:, 2] = x[:, 0]**2 # for coefficient a - - return design_matrix - - def refine_policy(self, policy_current, refinement): - """ - Perform policy refinement. - - Parameters - ---------- - policy_current : dict - Coefficients specifying the policy at the current time period - - refinement : dict - Coefficients specifying the refinement at the current time period - - Returns - ------- - output : dict - Coefficients specifying the refined policy at the current time period - """ - - if self.du == 1: - outPut = policy_current + np.exp(-refinement) - else: # should be updated - outPut = policy_current + refinement - return outPut \ No newline at end of file From 18c65fc37ff60501881fb3e7a210382e2612e8aa Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:17:34 +0200 Subject: [PATCH 07/15] Delete Test_ControlledSMC_StochasticVolatility.ipynb --- Test_ControlledSMC_StochasticVolatility.ipynb | 315 ------------------ 1 file changed, 315 deletions(-) delete mode 100644 Test_ControlledSMC_StochasticVolatility.ipynb diff --git a/Test_ControlledSMC_StochasticVolatility.ipynb b/Test_ControlledSMC_StochasticVolatility.ipynb deleted file mode 100644 index 3843694..0000000 --- a/Test_ControlledSMC_StochasticVolatility.ipynb +++ /dev/null @@ -1,315 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Test Controlled SMC\n", - "\n", - "Test Controlled SMC algorithm on Stochastic Volatiliy Model\n", - "\n", - "For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396\n", - "\n", - "Steps to define a ControlledSMC model: \n", - "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). \n", - " This model should be an ssm object. For example: ssm = stovolModel() \n", - " - Define your own policy functions. \n", - " \n", - "Step 2 : Create the ControlledSMC object as follow:\n", - " myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5)\n", - " ssm = your original defined model \n", - " data: is your data\n", - " iterations = fixed at your convenience. \n", - "\n", - " \n", - "## First steps: defining a state-space model and Policy functionss\n", - "\n", - "We start by importing some standard libraries, plus some modules from the package." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib inline\n", - "import warnings; warnings.simplefilter('ignore') # hide warnings \n", - "\n", - "# standard libraries\n", - "from matplotlib import pyplot as plt\n", - "import numpy as np\n", - "import seaborn as sb\n", - "from particles import distributions as dists # where probability distributions are defined\n", - "from particles import state_space_models as ssm # where state-space models are defined\n", - "from particles.collectors import Moments \n", - "from collectors import Moments \n", - "from sklearn.linear_model import Ridge\n", - "import controlled_smc as cSMC\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's define our first state-space model **class** and the policy function. We consider a basic stochastic volalitility model, that is: \n", - "\\begin{align*}\n", - "X_0 & \\sim N\\left(\\mu, \\frac{\\sigma^2}{1-\\rho^2}\\right), &\\\\\n", - "X_t|X_{t-1}=x_{t-1} & \\sim N\\left( \\mu + \\rho (x_{t-1}-\\mu), \\sigma^2\\right), &\\quad t\\geq 1, \\\\\n", - "Y_t|X_t=x_t & \\sim N\\left(0, e^{x_t}\\right),& \\quad t\\geq 0.\n", - "\\end{align*}\n", - " \n", - "Note that this model depends on fixed parameter $\\theta=(\\mu, \\rho, \\sigma)$. The policy function P is defined as:\n", - "\n", - "$$\n", - "\\log P_t(t, X_{t-1}, X_{t}) = -[(A_t X_{t},X_{t}) + (B_t,X_{t}) + c_t] \n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "# DEFINE STOCHASTIC VOLATILITY MODEL\n", - "# ----------------------------------- \n", - "class StochVol(ssm.StateSpaceModel): \n", - " \"\"\" \"\"\"\n", - " mu = -1.0; sigma = 1.0; rho = 1.0/np.sqrt(2) #\n", - " def PX0(self): # Distribution of X_0\n", - " \"\"\" \"\"\"\n", - " return dists.Normal( loc = self.mu, scale=self.sigma / np.sqrt(1.0 - self.rho**2))\n", - " def PX(self, t, xp): # Distribution of X_t given X_{t-1}=xp (p=past)\n", - " \"\"\" \"\"\"\n", - " return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), scale=self.sigma)\n", - " def PY(self, t, xp, x): # Distribution of Y_t given X_t=x (and possibly X_{t-1}=xp)\n", - " \"\"\" \"\"\"\n", - " return dists.Normal(loc=0., scale=np.exp(0.5*x))\n", - " def policy(self,t): # a quadratic function policy(At, Bt, Ct)\n", - " \"\"\" return only coefs of the quadratic from of the policy function (A,B,c)\n", - " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t] - F(xp); where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", - " \"\"\"\n", - " return 0.002175129155947095, 0.021869510847052914, 0.53135057055622562" - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "N = 100\n", - "# define the model\n", - "stovolModel = StochVol() \n", - "true_states, data = stovolModel.simulate(N) # we simulate from the model 100 data points\n", - "\n", - "my_model = StochVol(mu=-1., rho=.9, sigma=.1) # actual model with params\n", - "true_states, data = my_model.simulate(100) # we simulate from the model 100 data points\n", - "\n", - "plt.style.use('ggplot')\n", - "plt.figure()\n", - "plt.plot(data, linewidth = 2)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Twisted feynman kac model and bootstraap - simulations comparison \n", - "\n", - " \n" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [], - "source": [ - "fk_StoVolTwisted = cSMC.TwistedFK(ssm=stovolModel, data=data) \n", - "fk_StoVolBootstrap= ssm.Bootstrap(ssm=stovolModel, data=data) \n", - "\n", - "# Bootstrap\n", - "pfBootstrap = particles.SMC(fk=fk_StoVolBootstrap, N=N, resampling='multinomial', collect=[Moments()], store_history=True) \n", - "pfBootstrap.run() # actual computation\n", - "\n", - "# Twisted FK\n", - "pfTwisted = particles.SMC(fk=fk_StoVolTwisted, N=N, resampling='multinomial', collect=[Moments()], store_history=True)\n", - "pfTwisted.run() # actual computation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Particle Smoothing\n", - "\n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 37, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "smooth_trajectories = pfTwisted.hist.backward_sampling(3) # 10 Trajectories\n", - "plt.figure()\n", - "plt.plot(smooth_trajectories)\n", - "plt.title(\" Twisted smooth_trajectories\")\n", - "plt.legend()\n", - "\n", - "# results = multiSMC(fk=fk_StoVolTwisted, N=100, nruns=30, qmc={'SMC':False, 'SQMC':True})\n", - "# plt.figure()\n", - "# sb.boxplot(x=[r['output'].logLt for r in results], y=[r['qmc'] for r in results]);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Weights Distributions" - ] - }, - { - "cell_type": "code", - "execution_count": 38, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 38, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# A Serie of Weights # Make histogram\n", - "plt.figure()\n", - "plt.plot(np.arange(len(data)), pfTwisted.W, linewidth = 1, marker = 'o') # lineStyle = '.')\n", - "plt.plot(np.arange(len(data)), pfBootstrap.W ,linewidth = 1, marker = 'o') \n", - "plt.xlabel('period', fontsize = 15)\n", - "plt.ylabel('$Weights$', fontsize = 15)\n", - "plt.title(\" Some weights\")\n", - "plt.legend(['TwistedFK', 'Bootstrap'], fontsize = 15)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Controlled smc - Feynman kac model results\n" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "PsiSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) \n", - "\n", - "PsiSMCResults = PsiSMC.RunAll() \n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## TODO\n", - "\n", - " -\n", - " -\n", - " \n", - "\n" - ] - } - ], - "metadata": { - "celltoolbar": "Edit Metadata", - "kernelspec": { - "display_name": "Python 3", - "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.8.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} From 5685c77ddff0c95066ad746dfc909893a909ae26 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:19:32 +0200 Subject: [PATCH 08/15] Controlled SMC codes - add controlled SMC class - add policy in ssm class --- particles/controlled_smc.py | 822 ++++++++++++++++++-------------- particles/state_space_models.py | 30 +- 2 files changed, 490 insertions(+), 362 deletions(-) diff --git a/particles/controlled_smc.py b/particles/controlled_smc.py index 3504bcf..2d70df5 100644 --- a/particles/controlled_smc.py +++ b/particles/controlled_smc.py @@ -13,10 +13,9 @@ 1. the `ControlledSMC` class, which lets you define a controlled sequential Monte Carlo model as a Python object; + + 2. `TwistedFK` class that define a twisted Feynman-Kac models - 3. `TwistedSMC` class that define a kind of Bootstrap Feynman-Kac models - - 2. `FeynmanKac` classes based on the previous classes The recommended import is:: @@ -24,18 +23,29 @@ For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396 -TODO: Defining a ControlledSMC model +Steps to define a ControlledSMC model ============================== - +Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]) + This model should be an ssm object. For example ssm = stovolModel() + - Define your policy functions. + +Step 2 : Create the ControlledSMC object as follow: + + myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5) + ssm = your original defined model + data: is your data + iterations = fixed at your convenience. + +Example: +-------- Consider the following (simplified) stochastic volatility model: - .. math:: Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) -To define this particular model, we sub-class `StateSpaceModel` as follows:: +To define this particular model, we sub-class from `ControlledSMC` as follows:: import numpy as np from particles import distributions as dists @@ -52,34 +62,15 @@ def PX0(self): # dist of X_0 Then we define a particular object (model) by instantiating this class:: - my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9) - -Hopefully, the code above is fairly transparent, but here are some noteworthy -details: - - * probability distributions are defined through `ProbDist` objects, which - are defined in module `distributions`. Most basic probability - distributions are defined there; see module `distributions` for more details. - * The class above actually defines a **parametric** class of models; in - particular, ``self.sigma`` and ``self.rho`` are **attributes** of - this class that are set when we define object `my_stoch_vol_model`. - Default values for these parameters may be defined in a dictionary called - ``default_parameters``. When this dictionary is defined, any un-defined - parameter will be replaced by its default value:: + stovolModel = SimplifiedStochVol(sigma=0.3, rho=0.9) - default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8 - * There is no need to define a ``__init__()`` method, as it is already - defined by the parent class. (This parent ``__init__()`` simply takes - care of the default parameters, and may be overrided if needed.) + myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) -Now that our state-space model is properly defined, what can we do with it? -First, we may simulate states and data from it:: - - x, y = my_stoch_vol_model.simulate(20) - -This generates two lists of length 20: a list of states, X_0, ..., X_{19} and -a list of observations (data-points), Y_0, ..., Y_{19}. +Hopefully, the code above is fairly transparent, but here are some noteworthy +details: + + TODO: Associated Feynman-Kac models ============================= @@ -113,94 +104,50 @@ def proposal(t, xp, data): # a silly proposal Voilà! You have now implemented a guided filter. -Of course, the proposal distribution above does not make much sense; we use it -to illustrate how proposals may be defined. Note in particular that it depends -on ``data``, an object that represents the complete dataset. Hence the proposal -kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other -datapoint. - -For auxiliary particle filters (APF), one must in addition specify auxiliary -functions, that is the (log of) functions :math:`\eta_t` that modify the -resampling probabilities (see Section 10.3.3 in the book):: - - class StochVol_with_prop_and_aux_func(StochVol_with_prop): - def logeta(self, t, x, data): - "Log of auxiliary function eta_t at time t" - return -(x-data[t])**2 - - my_third_ssm = StochVol_with_prop_and_aux_func() - apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y) - -Again, this particular choice does not make much sense, and is just given to -show how to define an auxiliary function. - -Already implemented the module -====================================== - -This module implements a few basic state-space models that are often used as -numerical examples: - -=================== ===================================================== -Class Comments -=================== ===================================================== -`NeuroScience` -`StochasticVol` - -=================== ===================================================== - .. note:: - In C-SMC, proposal and weights are changed by the twisted functions. - The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. - The user also need to define the proposal function in this class as well. - This proposal shoub be overidden dynamically with ADP ! - + The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. """ - from __future__ import division, print_function -import state_space_models as modelssm + +from matplotlib.pyplot import hist +import state_space_models as ssm import numpy as np -from collectors import Moments +import core as core +import distributions as dists +from collectors import Moments import utils import kalman as kalman -import particles -from particles import distributions as dists - -err_msg_missing_cst = """ - State-space model %s is missing method upper_bound_log_pt, which provides - log of constant C_t, such that - p(x_t|x_{t-1}) <= C_t - This is required for smoothing algorithms based on rejection - """ +from matplotlib import pyplot as plt +from sklearn.linear_model import Ridge + + err_msg_missing_policy = """ State-space model %s is missing method policy for controlled SMC, specify a policy """ -""" +""" TODO: ===== - - code is failing in resampling module in the function wmean_and_var() or 2D. - m = np.average(x, weights=W, axis=0) - m2 = np.average(x**2, weights=W, axis=0) # x**2 - v = m2 - m**2 - return {'mean': m, 'var': v} - - - Policy input shoud be refined - - Management of Policy function interaction. - - Reshape def run(self) in ControlledSMC class. + - Argument ssm must implement method: Policy function (Later on this will be taken out). + - + QUESTIONS --------- - -Observation space need to be updated ! + - + DISCUSION + --------- + - moove some functions to utils. + - reshape the classes and simplify it + - Make controlled SMC algo iterable + """ -# Define the ψ-twisted model || ψ-observation space, ψ-Proposal0, ψ-Proposal, G-ψ ? -class TwistedSMC(modelssm.Bootstrap): - """Twisted SMC for a given state-space model. - TODO: - matmul is not working for 1D. Adjust this. - define a template class to accomodate 1D and nD. +class TwistedFK(ssm.Bootstrap): + + """Twisted SMC for a given state-space model. Parameters ---------- ssm: StateSpaceModel object @@ -216,158 +163,180 @@ class TwistedSMC(modelssm.Bootstrap): Note ---- - Argument ssm must implement methods `proposal0` and `proposal` and define a Policy function. + Argument ssm must implement methods a Policy function (Later on this will be taken out). """ + def M0(self, N): + ''' Initial-Distribution ''' + return self.M(0, self.ssm.PX0().rvs(size=N)) + + def M(self, t, xp): + ''' ψ-Distribution of X_t given X_{t-1}=xp ''' + it = t*np.ones(xp.shape[0]).astype(int) + if self.ssm.PX(t, xp).dim == 1: + loop = [self.PsiProposal (it[i], xp[i]) for i in range (0, len(it)) ] + transition = np.array(loop).reshape(xp.shape[0]) + else: + loop = [self.PsiProposal (int(it[i]), xp[i,:]) for i in range (0, len(it)) ] + transition = np.array(loop).reshape(xp.shape[0], xp.shape[1]) + + return transition + - def M0(self, N): # TODO: t = 0 is not the right thing to do. - return self.M(0, self.ssm.proposal0(self.data).rvs(size=N)) - - def M(self, t, xp): - At, Bt, Ct = self.ssm.policy() - Mean = self.ssm.proposal(t, xp, self.data).loc - dimension = self.ssm.proposal(t, xp, self.data).dim - - if dimension == 1: - Var = self.ssm.proposal(t, xp, self.data).scale - VarInv = 1.00 / Var - V = np.dot(VarInv, Mean) - Bt - Alpha = VarInv + 2*At - AlphaInv = 1.00 / Alpha - else: - Var = self.ssm.proposal(t, xp, self.data).cov - VarInv = np.linalg.inv(Var) - V = np.dot(VarInv, Mean) - Bt - Alpha = VarInv + 2*At - AlphaInv = np.linalg.inv(Alpha) - - mbar = np.dot(V, np.dot(VarInv, Mean) - Bt) - - expo = 0.5 * self.Quadratic(self, AlphaInv, - np.zeros((dimension, 1)), - Ct, mbar) - if dimension == 1: - sqrtDet = np.sqrt(np.abs(Alpha)/np.abs(Var)) - else: - sqrtDet = np.sqrt(np.linalg.det(Alpha)/np.linalg.det(Var)) - - normalisation = self.Expectation(t, xp) - - if dimension == 1: - ProposalxPsi = dists.Normal( - mbar, (sqrtDet*expo/normalisation)**2*Alpha) + def PsiProposal(self, t, xp): # M-ψ-Proposal + + myPolicy = self.ssm.policy + At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) + + dim = self.ssm.PX(t, xp).dim + + if t == 0: + Mean = self.ssm.PX0().loc + Var = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 else: - ProposalxPsi = dists.MvNormal( - mbar, sqrtDet*expo/normalisation, Alpha) - # Proposal = self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0]) - # psiFactor = 0.5 * self.Quadratic(At, Bt, Ct, x) - # return Proposal*psiFactor/self.Expectation(t, xp) - # return ProposalxPsi / normalisation - return ProposalxPsi - - def logG(self, t, xp, x): - At, Bt, Ct = self.ssm.policy() - du = self.ssm.PX0().dim - - # Dimension adjustement - # Is breaking but something is happing in the code core. Weights are appended ! - if self.du == 1: - LogPolicy = self.Quadratic(self, At, Bt, Ct, x) # TODO: unsupported operand type(s) for ** or pow(): 'Normal' and 'int' + Mean = self.ssm.PX(t, xp).loc + Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 + + VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var + V = np.dot(VarInv, Mean) - Bt + Alpha = np.linalg.inv(VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) + mbar = np.dot(Alpha, V) + + if dim == 1: + ProposalxPsiLaw = dists.Normal(loc=mbar, scale = np.sqrt(Alpha)) else: - LogPolicy = self.Quadratic(self, At, Bt.reshape( - self.du, 1), Ct.reshape(1, 1), x[-1]) # TODO: x[1] - - LogNormalisation = np.log(self.Expectation(t, x[-1])) - - # TODO: - if t == 0: - return (self.ssm.PX0().logpdf(x) - + self.ssm.proposal0(self.data).logpdf(x) + LogNormalisation - LogPolicy) - if t == self.T: - LogPotential = self.ssm.PY(t, xp, x).logpdf( - self.data[t]) + ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale = 1, cov = Alpha) + + return ProposalxPsiLaw.rvs(size=1) + + def logG(self, t, xp, x): # Log Potentials + + # retrieve policy from ssm model + myPolicy = self.ssm.policy + + At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) + + # initialisation + LogPolicy = np.zeros(x.shape[0]) + LogExpect = np.zeros(x.shape[0]) + LogForwardExpt = np.zeros(x.shape[0]) + + for v in range(x.shape[0]): + if self.du == 1: + LogPolicy[v] = -self.Quadratic( At, Bt, Ct, x[v]) + if t != self.T: + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + if t == 0: + LogExpect[v] = self.logCondExp(t, x[v]) + else: + LogPolicy[v] = - self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + if t != self.T-1: + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + if t == 0: + LogExpect[v] = self.logCondExp(t, x[v]) + + if t == 0: + LogNuPsiOnPolicy = LogExpect - LogPolicy + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogForwardExp = LogForwardExpt + LogGPsi = LogPotential + LogForwardExp + LogNuPsiOnPolicy + return LogGPsi + + if t == self.T-1: + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogGPsi = LogPotential - LogPolicy return LogPotential - LogPolicy else: - LogPotential = self.ssm.PY(t, xp, x).logpdf( - self.data[t]) - return LogPotential + LogNormalisation - LogPolicy - - @staticmethod # TODO: unsupported operand type(s) for ** or pow(): 'Normal' and 'int' - def Quadratic(self, A, B, c, x): - if self.ssm.PX0().dim == 1: - return A*x**2 + B*x + c - else: - return np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c - - - def Expectation(self, t, xp): # \E[ψ(t, x, xp)| xp] = \E {\exp[(Ax,x)+ Bx + C] | xp} - """Conditional expectation with respect to the Markov kernel at time t + LogForwardExp = LogForwardExpt + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogGPsi = LogPotential + LogForwardExpt - LogPolicy + return LogGPsi + + + def logPolicy(self, t, xp, x, policy_t): + LogPolicy = np.ones(x.shape[0]) + At = policy_t[0] + Bt = policy_t[1] + Ct = policy_t[2] + for v in range(x.shape[0]): + if self.du == 1: + LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) + else: + LogPolicy[v] = -self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + return LogPolicy + + + def logCondExp(self, t, xp): + # TODO: make the function depends on policy ! + + """ Log Conditional expectation with respect to the Markov kernel at time t + summary_ \E_M(ψ(Xp_t,X_t)) Args: t (_type_): _description_ xp (_type_): _description_ Returns: - _type_: _description_ + \E_M(ψ(Xp_t,X_t)) """ - At, Bt, Ct = self.ssm.policy() # policy depends on (self, t, xp, x)) - dimension = self.du - - # TODO: - if t == 0: - return xp # This should be adjusted TODO: - if t == self.T: # G_T/Psi_T - Mean = self.ssm.proposal(t, xp, self.data[t]).loc - Var = self.ssm.proposal(t, xp, self.data[t]).cov - VarInverse = np.linalg.inv(Var) - V = np.dot(VarInverse, Mean) - Bt - Alpha = VarInverse + 2*At - Identity = np.identity(dim) - sqrtDet = np.sqrt(np.linalg.det(Identity + 2 * np.dot(Var, At))) - expo = self.Quadratic(Alpha, np.zeros((dimension, 1)), - Ct, V) - - return np.exp(expo) / np.sqrt(sqrtDet) + dim = self.du + myPolicy = self.ssm.policy + + A , B , C = myPolicy[t-1] if type(myPolicy) is np.ndarray else self.ssm.policy(t-1) + + if t == 0: + Mean = self.ssm.PX0().loc + Cov = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 + else: + Mean = self.ssm.PX(t, xp).loc + Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 + + result = self.logCondFun(t, A, B, C, Mean, Cov) + + return result + + @property + def isADP(self): + """Returns true if we perform an ADP""" + return 'ADP' in dir(self) + + @staticmethod + def Quadratic(A, B, c, x): + if type(x) is np.ndarray: + result = np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c else: - Mean = self.ssm.proposal(t, xp, self.data).loc - if dimension == 1: - Var = self.ssm.proposal(t, xp, self.data).scale - else: - Var = self.ssm.proposal(t, xp, self.data).cov - - if dimension == 1: - VarInverse = 1.00/Var - V = VarInverse*Mean - Bt # ! Mean can be a random variable - Identity = dimension - sqrtDet = np.sqrt(np.abs(Identity + 2 * Var * At)) - Alpha = VarInverse + 2*At - expo = self.Quadratic(self, Alpha, np.zeros((dimension, 1)), - Ct, np.transpose(V)) - else: - VarInverse = np.linalg.inv(Var) - V = np.dot(VarInverse, np.transpose(Mean)) - \ - (np.transpose(Bt)).reshape(dimension, 1) - Identity = np.identity(dimension) - sqrtDet = np.sqrt(np.linalg.det( - Identity + 2 * np.dot(Var, At))) - Alpha = VarInverse + 2*At - - expo = self.Quadratic(self, Alpha, np.zeros( - (dimension, 1)), - Ct.reshape(1, 1), np.transpose(V)) - - return np.exp(expo) / sqrtDet - - -class ControlledSMC(TwistedSMC): - - """ Controlled SMC algorithm - Proposal distributions are determined by approximating the solution to an associated - optimal control problem using an iterative scheme = > You use APF where the proposal - is updated at every iteration. - Parameters + Inputs - ------------------- + result = A*x**2 + B*x + c + return result + + + def logCondFun(self, t, A, B, C, Mean, Cov): + + """Log conditional expectation function""" + + dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 + Identity = np.identity(dim) + CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov + V = np.dot(CovInv, Mean) - B + Alpha = np.linalg.inv(CovInv + 2*A) if dim > 1 else 1.0 /(CovInv + 2*A) + quadraV = 0.5*self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) + quadraGamaMean = - 0.5*self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) + + Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A + return quadraV + quadraGamaMean -0.5 * np.log(Det) - C + + +class ControlledSMC(TwistedFK): + + """ Controlled SMC class algorithm + + Parameters + Inputs. + ------------------------------------------------------------- + It is the same as of TwistedFK + iterations (number of iterations) to use for the controlled SMC + ssm: StateSpaceModel object - the considered state-space model (-ssm with proposal and logEta(the psi)), + the considered state-space model (-ssm with proposal and logEta(the psi)), data: list-like the data - Returns ------- [type]: [description] @@ -375,92 +344,128 @@ class ControlledSMC(TwistedSMC): the Feynman-Kac representation of the filter for the considered state-space model - Note - ---- - In C-SMC, proposal and weights are changed by the twisted functions. """ - def __init__(self, ssm=None, data=None): - self.ssm = ssm # Argument ssm must implement methods `proposal0`, `proposal` + def __init__(self, ssm=None, data=None, iterations = None): + self.ssm = ssm self.data = data - self.du = self.ssm.PX0().dim + self.iterations = 1 + self.du = self.ssm.PX0().dim self.policy = self.ssm.policy - - @property + self.iter = 0 + + @property def T(self): return 0 if self.data is None else len(self.data) @property def isPolicyMissing(self): """Returns true if model parameter contains policy in the argument dictionary in ssm constructor""" - if (hasattr(self,self.ssm.policy) == False): - raise NotImplementedError(self._error_msg('missing policy')) + if (hasattr(self, self.ssm.policy) == False): # if('policy' in dir(self) == False): + raise NotImplementedError(self._error_msg('missing policy')) + def next(self): + return self.__next__() + + def __iter__(self): + return self + @utils.timer def run(self): # make this iterator() - # Policy Initialisation - AO, BO, CO = self.ssm.policy() - - # TODO: Dynamic SMC with update proposal via policy modulo coeffs A, B, C of Policy - for t in range(self.T): - # Run Twisted SMC for t different of T - fk_model = modelssm.TwistedSMC(self.ssm, self.data) - PsiSMC = particles.SMC(fk=fk_model, N=100, resampling='stratified', - collect=[Moments()], store_history=True) - PsiSMC.run() + for _ in self: + pass + + def generateIntialParticules(self): + N = len(self.data) + myPolicy = self.ssm.policy + policy_initial = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) + + # Construct and run the Psi Model for initialisation to compute ADP to refine the policy + fk_model = TwistedFK(self.ssm, self.data) + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # TODO: Add new field to the FK object. + self.hist = PsiSMC.hist + self.policy = policy_initial + + + def generateParticulesWithADP(self): + settings = {'N': len(self.data), 'sample_trajectory': False, + 'regularization': 1e-4} + # fk_model = self.hist + PsiSMC = self.hist + adp = self.ADP(self.data, self.policy, PsiSMC, settings) + refinedPolicy = adp['policy_refined'] + self.ssm.set_policy(refinedPolicy) + + # Run ψ -twisted SMC with refined policy + fk_model = TwistedFK(self.ssm, self.data) + fk_model.isADP == True + PsiSMC = core.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + + # TODO: Add new field to the FK object. + self.hist = PsiSMC.hist + self.policy = refinedPolicy + + + def RunAll(self): # def __next__(self): + # if self.done(self): + # raise StopIteration + # if self.iterations == 1: + # intialisation + N = len(self.data) + myPolicy = self.ssm.policy + policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + + policySSM = [policy for t in range(self.T+1)] + policySSM = [[0.0 , 0.0, 0.0] for t in range(self.T+1)] - # TODO: Look at the code and pick the right params - settings = {'N': 100, 'sample_trajectory': False, 'regularization': 1e-4} - - # run ADP to refine previous policy - # add feed the right staffs from PsiSMC.run() - adp = self.RefinePsiEstimation( - fk_model, self.data, self.ssm.policy, PsiSMC.summaries, settings, inverse_temperature=0.0) # add feed the right staffs from PsiSMC.run() - """ - model = ssm or any kind of model - observations = data - psi_smc = fk.run().results (derived from fk.run()) - settings = parameters of the model you define yourself - """ - # Construct refined policy (It is why we get/set policy), Use set function - refinedPolicy = self.ssm.policy() * adp['policy_refined'] # update A, B, C normally ! - self.ssm.set_policy(self, refinedPolicy) - - # Run ψ -twisted SMC method for t = T, - if t == self.T: - fk_model = modelssm.TwistedSMC(self.ssm, self.data) - PsiSMC = particles.SMC(fk=fk_model, N=100, resampling='stratified', - collect=[Moments()], store_history=True) + + # Construct and run the Psi Model for initialisation + fk_model = TwistedFK(self.ssm, self.data) + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[Moments()], store_history=True) + PsiSMC.run() + histDataPsiSMC = PsiSMC.hist + settings = {'N': N, 'sample_trajectory': False, + 'regularization': 1e-4} + # else: + for it in range(self.iterations): + # run ADP + adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) + # Construct refined policy + refinedPolicy = adp['policy_refined'] + self.ssm.set_policy(refinedPolicy) + TestRefinedPolicy = np.array(self.ssm.policy) + # Run ψ-twisted SMC with refined policy + fk_model = TwistedFK(self.ssm, self.data) + fk_model.isADP == True + PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[Moments()], store_history=True) PsiSMC.run() - - # return PsiSMC.result # Seems that PsiSMC is void :) as desire ! Smoothing, Filtering etc.. - pass - - # python compatibility - def next(self): - return self.__next__() #  Python 2 compatibility - - def __iter__(self): - return self - - # Compute the Backward Filter - def RefinePsiEstimation(model, observations, policy, psi_smc, settings, inverse_temperature=1.0): + return PsiSMC.hist + + def ADP(self, observations, policy, psi_smc, settings): """ - model = ssm or any kind of model + model = ssm or any kind of model observations = data psi_smc = fk.run().results (derived from fk.run()) settings = parameters of the model you define yourself Approximate dynamic programming to refine a policy. - In Python method overriding occurs by simply defining in the child class a method with the same name of a method - in the parent class. When you define a method in the object you make this latter able to satisfy that method call, + In Python method overriding occurs by simply defining in the child class a method with the same name of a method + in the parent class. When you define a method in the object you make this latter able to satisfy that method call, so the implementations of its ancestors do not come in play. Parameters ---------- model : controlledpsi_smc.models.LRR.ssm - A ssm class instance + A ssm class instance observations : numpy.array (T+1, dim_y) Time series @@ -470,8 +475,8 @@ def RefinePsiEstimation(model, observations, policy, psi_smc, settings, inverse_ 'N' : int specifying number of particles 'sample_trajectory' : bool specifying whether a trajectory is to be sampled - policy : list of dicts of length T+1 - Coefficients specifying policy + policy : list of dicts of length T+1 + Coefficients specifying policy inverse_temperature : float The inverse temperature controls the annealing of the observation densities @@ -481,81 +486,204 @@ def RefinePsiEstimation(model, observations, policy, psi_smc, settings, inverse_ ------- output : dict Algorithm output contain: - 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy - 'r_squared' : numpy.array (T+1,) containing coefficient of determination values + 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy + 'r_squared' : numpy.array (T+1,) containing coefficient of determination values """ # get model properties and algorithmic settings - dim_s = model.dim_s - T = observations.shape[0] - 1 + T = len(observations) - 1 # observations.shape[0] - 1 N = settings['N'] + HistoryData = psi_smc.hist + # pre-allocate - policy_refined = [{} for t in range(T+1)] + policy_refined = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) + r_squared = np.ones([T+1]) - # initialize - log_conditional_expectation = np.zeros([N]) - ancestors = psi_smc['ancestry'][:, T-1] - states_previous = psi_smc['states'][ancestors, :, T-1] - states_current = psi_smc['states'][:, :, T] + # initialize at T + states_previous = psi_smc.Xp + states_current = psi_smc.X + log_conditional_expectation = np.zeros([N]) + # iterate over time periods backwards for t in range(T, 0, -1): + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + # compute uncontrolled weights of reference proposal transition - log_weights_uncontrolled = model.log_weights_uncontrolled( - t, observations[t, :], states_previous, states_current, inverse_temperature) - - # evaluate log-policy function - log_policy = model.log_policy( - policy[t], states_previous, states_current) + log_weights_uncontrolled = self.log_weights_uncontrolled(t, states_previous, states_current) # (t, observations[t, :], states_previous, states_current) + + # evaluate log-policy function + log_policy = self.log_policy(t, policy[t], states_previous, states_current) - # target function values - target_values = log_weights_uncontrolled + \ - log_conditional_expectation - log_policy + # target function values + target_values = log_weights_uncontrolled.reshape(len(log_policy), 1) + \ + log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape(len(log_policy), 1) # TODO: log_conditional_expectation is not calculated here ! - # perform regression to learn refinement - (refinement, r_squared[t]) = model.learn_refinement( + # perform regression to learn refinement (update this function for high dimensional case) + (refinement, r_squared[t]) = self.learn_refinement( states_previous, states_current, target_values, settings) # refine current policy - policy_refined[t] = model.refine_policy(policy[t], refinement) + policy_refined[t] = self.refine_policy(policy[t], refinement) + + # set Policy + self.ssm.set_policy(policy_refined) # compute log-conditional expectation of refined policy if t != 1: - ancestors = psi_smc['ancestry'][:, t-2] - states_previous = psi_smc['states'][ancestors, :, t-2] - states_current = psi_smc['states'][:, :, t-1] - (log_conditional_expectation, _) = model.log_conditional_expectation( - policy_refined[t], states_current) - - # also refine initial policy for random initial distributions - if model.initial_type == 'random': - # compute log-conditional expectation of refined policy - states_current = psi_smc['states'][:, :, 0] - (log_conditional_expectation, _) = model.log_conditional_expectation( - policy_refined[1], states_current) + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + log_conditional_expectation = self.log_conditional_expectation(t, policy_refined[t], states_current) + + output = {'policy_refined': policy_refined } - # compute uncontrolled weights of reference proposal distribution - log_weights_uncontrolled = model.log_weights_uncontrolled_initial( - observations[0, :], states_current, inverse_temperature) + return output - # evaluate log-policy function - log_policy = model.log_initial_policy(policy[0], states_current) - # target function values - target_values = log_weights_uncontrolled + \ - log_conditional_expectation - log_policy + """ + FONCTIONS USED FOR ADP FUNCTION ABOVE + """ + + def log_weights_uncontrolled(self, t, xp, x ): + """ """ + return self.ssm.PY(t, xp, x).logpdf(self.data[t]) + + def log_policy(self, t, policy, xp, x ): + """ """ + LogPolicy = self.logPolicy(t, xp, x, policy) + return LogPolicy + + def log_conditional_expectation(self, t, policy_refined, x): + """ """ + LogCondExpect = np.ones(x.shape[0]) + + it = t*np.ones(x.shape[0]).astype(int) + + if self.ssm.PX(t, x).dim == 1: + loop = [self.logCondExp(it[i], x[i]) for i in range (0, len(it))] + LogCondExpect = np.array(loop).reshape(x.shape[0]) + else: + loop = [self.logCondExp(it[i], x[i,:]) for i in range (0, len(it)) ] + + LogCondExpect = np.array(loop).reshape(x.shape[0], 1) - # perform regression to learn refinement - (refinement, r_squared[0]) = model.learn_initial_refinement( - states_current, target_values, settings) + return LogCondExpect - # refine current policy - policy_refined[0] = model.refine_initial_policy( - policy[0], refinement) - # algorithm output - output = {'policy_refined': policy_refined, 'r_squared': r_squared} + def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here + """ + Learn policy refinement using ridge regression. + + Parameters + ---------- + xp : numpy.array (N, dim_s) + Latent states at previous time period + x : numpy.array (N, dim_s) + Latent states at current time period + target_values : numpy.array (N,) + Target function values at latent states + settings : dict + Regression settings + + Returns + ------- + refinement : dict + Coefficients specifying the refinement at the current time period + r_squared : float + Coefficient of determination + """ + # construct design matrix + if self.du == 1: + x = x.reshape(x.shape[0],1) + xp = xp.reshape(xp.shape[0],1) + + design_matrix = self.design_matrix_Quadratic_univariate(x) - return output \ No newline at end of file + # perform ridge regression + ridge_regressor = Ridge(alpha=settings['regularization'], fit_intercept=False) + ridge_regressor.fit(design_matrix, - target_values) + + # get refinement coefficients from regression coefficients + refinement = ridge_regressor.coef_ # self.get_coef_Quadratic_univariate(ridge_regressor.coef_) + + # compute R-squared + r_squared = np.corrcoef(ridge_regressor.predict(design_matrix), target_values)[0, 1]**2 + + return (refinement, r_squared) + + def get_coef_Quadratic_univariate(self, regression_coef): + """ + Get coefficients (a, b, c) of the Quadratic function of a univariate variable x + Q(x) = a * x^2 + b * x + c + given an array of regression coefficients. + + Parameters + ---------- + regression_coef : numpy.array (num_features,) where num_features = 3 + Array of regression coefficients + + Returns + ------- + output : dict + """ + # get coefficients + output = {} + + output['a'] = regression_coef[2] # output['a'] = regression_coef[2] + output[1] = regression_coef[2] # output['a'] = regression_coef[2] + + output['b'] = regression_coef[1] # output['b'] = regression_coef[1] + output['c'] = regression_coef[0] # output['c'] = regression_coef[0] + return output + + def design_matrix_Quadratic_univariate(self, x): + """ + Construct design matrix of features for Quadratic function of a univariate variable + Q(x) = a * x^2 + b * x + c. + + Parameters + ---------- + x : numpy.array (N, 1) + + Returns + ------- + design_matrix : numpy.array (N, num_features) where num_features = 3 + """ + + # get size + N = x.shape[0] + + # construct design matrix + num_features = 3 + design_matrix = np.ones([N, num_features]) # for intercept c + design_matrix[:, 1] = x[:, 0] # for coefficient b + design_matrix[:, 2] = x[:, 0]**2 # for coefficient a + + return design_matrix + + def refine_policy(self, policy_current, refinement): + """ + Perform policy refinement. + + Parameters + ---------- + policy_current : dict + Coefficients specifying the policy at the current time period + + refinement : dict + Coefficients specifying the refinement at the current time period + + Returns + ------- + output : dict + Coefficients specifying the refined policy at the current time period + """ + + if self.du == 1: + outPut = policy_current + np.exp(-refinement) + else: # should be updated + outPut = policy_current + refinement + return outPut \ No newline at end of file diff --git a/particles/state_space_models.py b/particles/state_space_models.py index 2df0cbb..4f78fe3 100644 --- a/particles/state_space_models.py +++ b/particles/state_space_models.py @@ -104,10 +104,10 @@ class StochVol_with_prop(StochVol): def proposal0(self, data): return dists.Normal(scale = self.sigma) def proposal(t, xp, data): # a silly proposal - return dists.Normal(loc=rho * xp + data[t], scale=self.sigma) + return dists.Normal(loc = rho * xp + data[t], scale=self.sigma) my_second_ssm = StochVol_with_prop(sigma=0.3) - my_better_fk_model = ssms.GuidedPF(ssm=my_second_ssm, data=y) + my_better_fk_model = ssms.Guided(ssm = my_second_ssm, data=y) # then run a SMC as above Voilà! You have now implemented a guided filter. @@ -159,7 +159,6 @@ def logeta(self, t, x, data): """ from __future__ import division, print_function - import numpy as np import particles @@ -172,7 +171,7 @@ def logeta(self, t, x, data): This is required for smoothing algorithms based on rejection """ err_msg_missing_policy = """ - State-space model %s is missing method policy for controlled SMC, specify a policy + State-space model %s is missing method policy (a dictionnary) for controlled SMC, specify a policy dictionnary """ class StateSpaceModel(object): @@ -220,7 +219,7 @@ def __init__(self, **kwargs): if hasattr(self, 'default_params'): self.__dict__.update(self.default_params) self.__dict__.update(kwargs) - + def _error_msg(self, method): return ('method ' + method + ' not implemented in class%s' % self.__class__.__name__) @@ -263,17 +262,17 @@ def proposal(self, t, xp, data): data """ raise NotImplementedError(self._error_msg('proposal')) - - @property # TODO: Policy should return a matrix ! Discuss how policy shoulb be incorporated + + @property def policy(self): """policy : - Coefficients specifying policy. - Policy should be exponential quadratic - log(policy(t, xp, x)) = -[(At x,x) + (Bt,x) + Ct] + F(x_p); where A is a matrix dxd, b a vector, c scalar + Coefficients specifying policy + policy should be exponential quadratic + log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A is a matrix dxd, b a vector, c scalar return the list [At, Bt, Ct] - At : a matrix - Bt : a vector - Ct : Normally for every t, we have a different coefficient + A_t is a matrix + Bt is a vector of dimension of the + Ct is !! """ raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) @@ -282,8 +281,8 @@ def get_policy(self): def set_policy(self, newPolicy): self.policy = newPolicy + - def upper_bound_log_pt(self, t): """Upper bound for log of transition density. @@ -444,7 +443,7 @@ class AuxiliaryPF(GuidedPF, APFMixin): """ pass - + class AuxiliaryBootstrap(Bootstrap, APFMixin): """Base class for auxiliary bootstrap particle filters @@ -681,3 +680,4 @@ def proposal0(self, data): def proposal(self, t, xp, data): return self.PX(t, xp).posterior(data[t], sigma=self.sigmaY) + \ No newline at end of file From 74e42cfcc1796e45157055be5929be2c04178afb Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Mon, 11 Apr 2022 19:31:51 +0200 Subject: [PATCH 09/15] Add files via upload Add Controlled SMC codes based on the fact that the Log policy functions are quadratic. --- docs/source/notebooks/ControlledSMC.ipynb | 315 ++++++++++++++++++++++ 1 file changed, 315 insertions(+) create mode 100644 docs/source/notebooks/ControlledSMC.ipynb diff --git a/docs/source/notebooks/ControlledSMC.ipynb b/docs/source/notebooks/ControlledSMC.ipynb new file mode 100644 index 0000000..3843694 --- /dev/null +++ b/docs/source/notebooks/ControlledSMC.ipynb @@ -0,0 +1,315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test Controlled SMC\n", + "\n", + "Test Controlled SMC algorithm on Stochastic Volatiliy Model\n", + "\n", + "For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396\n", + "\n", + "Steps to define a ControlledSMC model: \n", + "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). \n", + " This model should be an ssm object. For example: ssm = stovolModel() \n", + " - Define your own policy functions. \n", + " \n", + "Step 2 : Create the ControlledSMC object as follow:\n", + " myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5)\n", + " ssm = your original defined model \n", + " data: is your data\n", + " iterations = fixed at your convenience. \n", + "\n", + " \n", + "## First steps: defining a state-space model and Policy functionss\n", + "\n", + "We start by importing some standard libraries, plus some modules from the package." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import warnings; warnings.simplefilter('ignore') # hide warnings \n", + "\n", + "# standard libraries\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sb\n", + "from particles import distributions as dists # where probability distributions are defined\n", + "from particles import state_space_models as ssm # where state-space models are defined\n", + "from particles.collectors import Moments \n", + "from collectors import Moments \n", + "from sklearn.linear_model import Ridge\n", + "import controlled_smc as cSMC\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's define our first state-space model **class** and the policy function. We consider a basic stochastic volalitility model, that is: \n", + "\\begin{align*}\n", + "X_0 & \\sim N\\left(\\mu, \\frac{\\sigma^2}{1-\\rho^2}\\right), &\\\\\n", + "X_t|X_{t-1}=x_{t-1} & \\sim N\\left( \\mu + \\rho (x_{t-1}-\\mu), \\sigma^2\\right), &\\quad t\\geq 1, \\\\\n", + "Y_t|X_t=x_t & \\sim N\\left(0, e^{x_t}\\right),& \\quad t\\geq 0.\n", + "\\end{align*}\n", + " \n", + "Note that this model depends on fixed parameter $\\theta=(\\mu, \\rho, \\sigma)$. The policy function P is defined as:\n", + "\n", + "$$\n", + "\\log P_t(t, X_{t-1}, X_{t}) = -[(A_t X_{t},X_{t}) + (B_t,X_{t}) + c_t] \n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "# DEFINE STOCHASTIC VOLATILITY MODEL\n", + "# ----------------------------------- \n", + "class StochVol(ssm.StateSpaceModel): \n", + " \"\"\" \"\"\"\n", + " mu = -1.0; sigma = 1.0; rho = 1.0/np.sqrt(2) #\n", + " def PX0(self): # Distribution of X_0\n", + " \"\"\" \"\"\"\n", + " return dists.Normal( loc = self.mu, scale=self.sigma / np.sqrt(1.0 - self.rho**2))\n", + " def PX(self, t, xp): # Distribution of X_t given X_{t-1}=xp (p=past)\n", + " \"\"\" \"\"\"\n", + " return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), scale=self.sigma)\n", + " def PY(self, t, xp, x): # Distribution of Y_t given X_t=x (and possibly X_{t-1}=xp)\n", + " \"\"\" \"\"\"\n", + " return dists.Normal(loc=0., scale=np.exp(0.5*x))\n", + " def policy(self,t): # a quadratic function policy(At, Bt, Ct)\n", + " \"\"\" return only coefs of the quadratic from of the policy function (A,B,c)\n", + " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t] - F(xp); where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", + " \"\"\"\n", + " return 0.002175129155947095, 0.021869510847052914, 0.53135057055622562" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "N = 100\n", + "# define the model\n", + "stovolModel = StochVol() \n", + "true_states, data = stovolModel.simulate(N) # we simulate from the model 100 data points\n", + "\n", + "my_model = StochVol(mu=-1., rho=.9, sigma=.1) # actual model with params\n", + "true_states, data = my_model.simulate(100) # we simulate from the model 100 data points\n", + "\n", + "plt.style.use('ggplot')\n", + "plt.figure()\n", + "plt.plot(data, linewidth = 2)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Twisted feynman kac model and bootstraap - simulations comparison \n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "fk_StoVolTwisted = cSMC.TwistedFK(ssm=stovolModel, data=data) \n", + "fk_StoVolBootstrap= ssm.Bootstrap(ssm=stovolModel, data=data) \n", + "\n", + "# Bootstrap\n", + "pfBootstrap = particles.SMC(fk=fk_StoVolBootstrap, N=N, resampling='multinomial', collect=[Moments()], store_history=True) \n", + "pfBootstrap.run() # actual computation\n", + "\n", + "# Twisted FK\n", + "pfTwisted = particles.SMC(fk=fk_StoVolTwisted, N=N, resampling='multinomial', collect=[Moments()], store_history=True)\n", + "pfTwisted.run() # actual computation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Particle Smoothing\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "smooth_trajectories = pfTwisted.hist.backward_sampling(3) # 10 Trajectories\n", + "plt.figure()\n", + "plt.plot(smooth_trajectories)\n", + "plt.title(\" Twisted smooth_trajectories\")\n", + "plt.legend()\n", + "\n", + "# results = multiSMC(fk=fk_StoVolTwisted, N=100, nruns=30, qmc={'SMC':False, 'SQMC':True})\n", + "# plt.figure()\n", + "# sb.boxplot(x=[r['output'].logLt for r in results], y=[r['qmc'] for r in results]);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Weights Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# A Serie of Weights # Make histogram\n", + "plt.figure()\n", + "plt.plot(np.arange(len(data)), pfTwisted.W, linewidth = 1, marker = 'o') # lineStyle = '.')\n", + "plt.plot(np.arange(len(data)), pfBootstrap.W ,linewidth = 1, marker = 'o') \n", + "plt.xlabel('period', fontsize = 15)\n", + "plt.ylabel('$Weights$', fontsize = 15)\n", + "plt.title(\" Some weights\")\n", + "plt.legend(['TwistedFK', 'Bootstrap'], fontsize = 15)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Controlled smc - Feynman kac model results\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "PsiSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) \n", + "\n", + "PsiSMCResults = PsiSMC.RunAll() \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## TODO\n", + "\n", + " -\n", + " -\n", + " \n", + "\n" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "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.8.3" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From e35ada81176fbea28b4a349ce2cb70e62d06a7a3 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Thu, 21 Apr 2022 21:35:27 +0200 Subject: [PATCH 10/15] Update packages Controlled SMC and SSM Controlled SMC and state_space_models updates --- particles/controlled_smc.py | 470 +++++++++++++++----------------- particles/state_space_models.py | 9 +- 2 files changed, 218 insertions(+), 261 deletions(-) diff --git a/particles/controlled_smc.py b/particles/controlled_smc.py index 2d70df5..312e642 100644 --- a/particles/controlled_smc.py +++ b/particles/controlled_smc.py @@ -19,14 +19,13 @@ The recommended import is:: - from particles import ControlledSMC module as CtSMC + from particles import ControlledSMC module as cSMC For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396 Steps to define a ControlledSMC model ============================== -Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]) - This model should be an ssm object. For example ssm = stovolModel() +Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). For example ssm = stovolModel() - Define your policy functions. Step 2 : Create the ControlledSMC object as follow: @@ -66,61 +65,26 @@ def PX0(self): # dist of X_0 myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) - -Hopefully, the code above is fairly transparent, but here are some noteworthy -details: - +TODO: Run the algorithm +======================= +To run the algorithm: + myCtrlSMC.run() + +Hopefully, the code above is fairly transparent. -TODO: Associated Feynman-Kac models -============================= - -Now that our state-space model is defined, we obtain the associated Bootstrap -Feynman-Kac model as follows: - - my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) - -That's it! You are now able to run a bootstrap filter for this model:: - - my_alg = particles.SMC(fk=my_fk_model, N=200) - my_alg.run() - -In case you are not clear about what are Feynman-Kac models, and how one may -associate a Feynman-Kac model to a given state-space model, see Chapter 5 of -the book. - -To generate a guided Feynman-Kac model, we must provide proposal kernels (that -is, Markov kernels that define how we simulate particles X_t at time t, given -an ancestor X_{t-1}):: - - class StochVol_with_prop(StochVol): - def proposal0(self, data): - return dists.Normal(scale = self.sigma) - def proposal(t, xp, data): # a silly proposal - return dists.Normal(loc=rho * xp + data[t], scale=self.sigma) - - my_second_ssm = StochVol_with_prop(sigma=0.3) - my_better_fk_model = ssms.Guided(ssm=my_second_ssm, data=y) - # then run a SMC as above -Voilà! You have now implemented a guided filter. .. note:: - The policy function Psi (in Twisted SMC) is an attribute of StateSpaceModel. """ from __future__ import division, print_function - -from matplotlib.pyplot import hist -import state_space_models as ssm +import particles +from particles import state_space_models as ssm import numpy as np -import core as core -import distributions as dists -from collectors import Moments -import utils -import kalman as kalman -from matplotlib import pyplot as plt +from particles import collectors +from particles import utils +from particles import distributions as dists from sklearn.linear_model import Ridge - err_msg_missing_policy = """ State-space model %s is missing method policy for controlled SMC, specify a policy """ @@ -140,7 +104,7 @@ def proposal(t, xp, data): # a silly proposal --------- - moove some functions to utils. - reshape the classes and simplify it - - Make controlled SMC algo iterable + - Make controlled SMC algo iterable """ @@ -165,109 +129,113 @@ class TwistedFK(ssm.Bootstrap): ---- Argument ssm must implement methods a Policy function (Later on this will be taken out). """ - def M0(self, N): + + def M0(self, N): ''' Initial-Distribution ''' return self.M(0, self.ssm.PX0().rvs(size=N)) - def M(self, t, xp): + def M(self, t, xp): ''' ψ-Distribution of X_t given X_{t-1}=xp ''' it = t*np.ones(xp.shape[0]).astype(int) if self.ssm.PX(t, xp).dim == 1: - loop = [self.PsiProposal (it[i], xp[i]) for i in range (0, len(it)) ] - transition = np.array(loop).reshape(xp.shape[0]) - else: - loop = [self.PsiProposal (int(it[i]), xp[i,:]) for i in range (0, len(it)) ] + loop = [self.PsiProposal(it[i], xp[i]) for i in range(0, len(it))] + transition = np.array(loop).reshape(xp.shape[0]) + else: + loop = [self.PsiProposal(int(it[i]), xp[i, :]) + for i in range(0, len(it))] transition = np.array(loop).reshape(xp.shape[0], xp.shape[1]) - + return transition - - def PsiProposal(self, t, xp): # M-ψ-Proposal - + def PsiProposal(self, t, xp): # M-ψ-Proposal + myPolicy = self.ssm.policy - At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) - - dim = self.ssm.PX(t, xp).dim - - if t == 0: - Mean = self.ssm.PX0().loc + At, Bt, Ct = myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) + + dim = self.ssm.PX(t, xp).dim + + if t == 0: + Mean = self.ssm.PX0().loc Var = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 else: - Mean = self.ssm.PX(t, xp).loc - Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 - - VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var - V = np.dot(VarInv, Mean) - Bt - Alpha = np.linalg.inv(VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) - mbar = np.dot(Alpha, V) + Mean = self.ssm.PX(t, xp).loc + Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX( + t, xp).scale**2 + + VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var + V = np.dot(VarInv, Mean) - Bt + Alpha = np.linalg.inv( + VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) + mbar = np.dot(Alpha, V) if dim == 1: - ProposalxPsiLaw = dists.Normal(loc=mbar, scale = np.sqrt(Alpha)) + ProposalxPsiLaw = dists.Normal(loc=mbar, scale=np.sqrt(Alpha)) else: - ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale = 1, cov = Alpha) - - return ProposalxPsiLaw.rvs(size=1) + ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale=1, cov=Alpha) + + return ProposalxPsiLaw.rvs(size=1) - def logG(self, t, xp, x): # Log Potentials + def logG(self, t, xp, x): # Log Potentials # retrieve policy from ssm model myPolicy = self.ssm.policy - At, Bt, Ct = myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) + At, Bt, Ct = myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) # initialisation LogPolicy = np.zeros(x.shape[0]) - LogExpect = np.zeros(x.shape[0]) - LogForwardExpt = np.zeros(x.shape[0]) - + LogExpect = np.zeros(x.shape[0]) + LogForwardExpt = np.zeros(x.shape[0]) + for v in range(x.shape[0]): if self.du == 1: - LogPolicy[v] = -self.Quadratic( At, Bt, Ct, x[v]) + LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) if t != self.T: - LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) if t == 0: - LogExpect[v] = self.logCondExp(t, x[v]) - else: - LogPolicy[v] = - self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + LogExpect[v] = self.logCondExp(t, x[v]) + else: + LogPolicy[v] = - \ + self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) if t != self.T-1: - LogForwardExpt[v] = self.logCondExp(t+1, x[v]) + LogForwardExpt[v] = self.logCondExp(t+1, x[v]) if t == 0: - LogExpect[v] = self.logCondExp(t, x[v]) - - if t == 0: - LogNuPsiOnPolicy = LogExpect - LogPolicy - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) - LogForwardExp = LogForwardExpt - LogGPsi = LogPotential + LogForwardExp + LogNuPsiOnPolicy + LogExpect[v] = self.logCondExp(t, x[v]) + + if t == 0: + LogNuPsiOnPolicy = LogExpect - LogPolicy + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogForwardExp = LogForwardExpt + LogGPsi = LogPotential + LogForwardExp + LogNuPsiOnPolicy return LogGPsi - + if t == self.T-1: - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) LogGPsi = LogPotential - LogPolicy return LogPotential - LogPolicy else: - LogForwardExp = LogForwardExpt - LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) + LogForwardExp = LogForwardExpt + LogPotential = self.ssm.PY(t, xp, x).logpdf(self.data[t]) LogGPsi = LogPotential + LogForwardExpt - LogPolicy return LogGPsi - def logPolicy(self, t, xp, x, policy_t): - LogPolicy = np.ones(x.shape[0]) + LogPolicy = np.ones(x.shape[0]) At = policy_t[0] Bt = policy_t[1] Ct = policy_t[2] for v in range(x.shape[0]): if self.du == 1: LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) - else: - LogPolicy[v] = -self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) + else: + LogPolicy[v] = - \ + self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) return LogPolicy - - def logCondExp(self, t, xp): + def logCondExp(self, t, xp): # TODO: make the function depends on policy ! - """ Log Conditional expectation with respect to the Markov kernel at time t summary_ \E_M(ψ(Xp_t,X_t)) @@ -280,48 +248,48 @@ def logCondExp(self, t, xp): """ dim = self.du myPolicy = self.ssm.policy - A , B , C = myPolicy[t-1] if type(myPolicy) is np.ndarray else self.ssm.policy(t-1) - - if t == 0: - Mean = self.ssm.PX0().loc + + if t == 0: + Mean = self.ssm.PX0().loc Cov = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 else: - Mean = self.ssm.PX(t, xp).loc - Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX(t, xp).scale**2 - - result = self.logCondFun(t, A, B, C, Mean, Cov) - + Mean = self.ssm.PX(t, xp).loc + Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX( + t, xp).scale**2 + + result = self.logCondFun(t, A, B, C, Mean, Cov) + return result - + @property def isADP(self): """Returns true if we perform an ADP""" return 'ADP' in dir(self) - + @staticmethod def Quadratic(A, B, c, x): - if type(x) is np.ndarray: - result = np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + c + if type(x) is np.ndarray: + result = np.sum(x * np.dot(A, np.transpose(x))) + \ + np.sum(B*np.transpose(x)) + c else: result = A*x**2 + B*x + c - return result - - - def logCondFun(self, t, A, B, C, Mean, Cov): + return result + def logCondFun(self, t, A, B, C, Mean, Cov): """Log conditional expectation function""" - dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 + dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 Identity = np.identity(dim) - CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov - V = np.dot(CovInv, Mean) - B - Alpha = np.linalg.inv(CovInv + 2*A) if dim > 1 else 1.0 /(CovInv + 2*A) - quadraV = 0.5*self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) - quadraGamaMean = - 0.5*self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) - - Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A - return quadraV + quadraGamaMean -0.5 * np.log(Det) - C + CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov + V = np.dot(CovInv, Mean) - B + Alpha = np.linalg.inv( + CovInv + 2*A) if dim > 1 else 1.0 / (CovInv + 2*A) + quadraV = 0.5 * self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) + quadraGamaMean = - 0.5 * self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) + + Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A + return quadraV + quadraGamaMean - 0.5 * np.log(Det) - C class ControlledSMC(TwistedFK): @@ -331,7 +299,7 @@ class ControlledSMC(TwistedFK): Parameters + Inputs. ------------------------------------------------------------- It is the same as of TwistedFK + iterations (number of iterations) to use for the controlled SMC - + ssm: StateSpaceModel object the considered state-space model (-ssm with proposal and logEta(the psi)), data: list-like @@ -346,15 +314,15 @@ class ControlledSMC(TwistedFK): """ - def __init__(self, ssm=None, data=None, iterations = None): - self.ssm = ssm + def __init__(self, ssm=None, data=None, iterations=None): + self.ssm = ssm self.data = data - self.iterations = 1 - self.du = self.ssm.PX0().dim + self.iterations = iterations + self.du = self.ssm.PX0().dim self.policy = self.ssm.policy self.iter = 0 - - @property + + @property def T(self): return 0 if self.data is None else len(self.data) @@ -365,91 +333,83 @@ def isPolicyMissing(self): raise NotImplementedError(self._error_msg('missing policy')) def next(self): - return self.__next__() - + return self.__next__() + def __iter__(self): - return self + return self @utils.timer def run(self): # make this iterator() for _ in self: - pass - + pass + def generateIntialParticules(self): N = len(self.data) - myPolicy = self.ssm.policy - policy_initial = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) + policy_initial = np.array([[0.0, 0.0, 0.0] for t in range(self.T)]) # Construct and run the Psi Model for initialisation to compute ADP to refine the policy fk_model = TwistedFK(self.ssm, self.data) - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', - collect=[Moments()], store_history=True) + PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[collectors.Moments()], store_history=True) PsiSMC.run() - - # TODO: Add new field to the FK object. - self.hist = PsiSMC.hist + + # TODO: remove new field to the FK object. + self.hist = PsiSMC.hist self.policy = policy_initial - - + def generateParticulesWithADP(self): settings = {'N': len(self.data), 'sample_trajectory': False, - 'regularization': 1e-4} + 'regularization': 1e-4} # fk_model = self.hist PsiSMC = self.hist - adp = self.ADP(self.data, self.policy, PsiSMC, settings) - refinedPolicy = adp['policy_refined'] + adp = self.ADP(self.data, self.policy, PsiSMC, settings) + refinedPolicy = adp['policy_refined'] self.ssm.set_policy(refinedPolicy) + self.policy = refinedPolicy # Run ψ -twisted SMC with refined policy fk_model = TwistedFK(self.ssm, self.data) fk_model.isADP == True - PsiSMC = core.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', - collect=[Moments()], store_history=True) + PsiSMC = particles.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', + collect=[collectors.Moments()], store_history=True) PsiSMC.run() - - # TODO: Add new field to the FK object. + self.hist = PsiSMC.hist - self.policy = refinedPolicy - - def RunAll(self): # def __next__(self): + def RunAll(self): # def __next__(self): # if self.done(self): # raise StopIteration # if self.iterations == 1: - # intialisation - N = len(self.data) - myPolicy = self.ssm.policy - policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. - policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. - - policySSM = [policy for t in range(self.T+1)] - policySSM = [[0.0 , 0.0, 0.0] for t in range(self.T+1)] - - - # Construct and run the Psi Model for initialisation + # intialisation + N = len(self.data) + myPolicy = self.ssm.policy + policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + + # Construct and run the Psi Model for initialisation + fk_model = TwistedFK(self.ssm, self.data) + PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', + collect=[collectors.Moments()], store_history=True) + PsiSMC.run() + settings = {'N': N, 'sample_trajectory': False, + 'regularization': 1e-4} + # else: + for it in range(self.iterations): + # run ADP + adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) + # Construct refined policy + refinedPolicy = adp['policy_refined'] + self.ssm.set_policy(refinedPolicy) + policy = refinedPolicy + TestRefinedPolicy = np.array(self.ssm.policy) + # Run ψ-twisted SMC with refined policy fk_model = TwistedFK(self.ssm, self.data) - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', - collect=[Moments()], store_history=True) + fk_model.isADP == True + PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[ + collectors.Moments()], store_history=True) PsiSMC.run() - histDataPsiSMC = PsiSMC.hist - settings = {'N': N, 'sample_trajectory': False, - 'regularization': 1e-4} - # else: - for it in range(self.iterations): - # run ADP - adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) - # Construct refined policy - refinedPolicy = adp['policy_refined'] - self.ssm.set_policy(refinedPolicy) - TestRefinedPolicy = np.array(self.ssm.policy) - # Run ψ-twisted SMC with refined policy - fk_model = TwistedFK(self.ssm, self.data) - fk_model.isADP == True - PsiSMC = core.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[Moments()], store_history=True) - PsiSMC.run() - return PsiSMC.hist - - def ADP(self, observations, policy, psi_smc, settings): + return PsiSMC.hist + + def ADP(self, model, observations, policy, psi_smc, settings, inverse_temperature=1.0): """ model = ssm or any kind of model observations = data @@ -458,10 +418,6 @@ def ADP(self, observations, policy, psi_smc, settings): Approximate dynamic programming to refine a policy. - In Python method overriding occurs by simply defining in the child class a method with the same name of a method - in the parent class. When you define a method in the object you make this latter able to satisfy that method call, - so the implementations of its ancestors do not come in play. - Parameters ---------- model : controlledpsi_smc.models.LRR.ssm @@ -497,30 +453,33 @@ def ADP(self, observations, policy, psi_smc, settings): HistoryData = psi_smc.hist # pre-allocate - policy_refined = np.array([[0.0 , 0.0, 0.0] for t in range(self.T)]) - + policy_refined = np.array([[0.0, 0.0, 0.0] for t in range(self.T)]) + r_squared = np.ones([T+1]) # initialize at T - states_previous = psi_smc.Xp - states_current = psi_smc.X - log_conditional_expectation = np.zeros([N]) + states_previous = psi_smc.Xp + states_current = psi_smc.X + log_conditional_expectation = np.zeros([N]) - # iterate over time periods backwards for t in range(T, 0, -1): - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] - + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + # compute uncontrolled weights of reference proposal transition - log_weights_uncontrolled = self.log_weights_uncontrolled(t, states_previous, states_current) # (t, observations[t, :], states_previous, states_current) - - # evaluate log-policy function - log_policy = self.log_policy(t, policy[t], states_previous, states_current) + # (t, observations[t, :], states_previous, states_current) + log_weights_uncontrolled = self.log_weights_uncontrolled( + t, states_previous, states_current) - # target function values + # evaluate log-policy function + log_policy = self.log_policy( + t, policy[t], states_previous, states_current) + + # target function values target_values = log_weights_uncontrolled.reshape(len(log_policy), 1) + \ - log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape(len(log_policy), 1) # TODO: log_conditional_expectation is not calculated here ! + log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape( + len(log_policy), 1) # perform regression to learn refinement (update this function for high dimensional case) (refinement, r_squared[t]) = self.learn_refinement( @@ -528,52 +487,51 @@ def ADP(self, observations, policy, psi_smc, settings): # refine current policy policy_refined[t] = self.refine_policy(policy[t], refinement) - + # set Policy - self.ssm.set_policy(policy_refined) + self.ssm.set_policy(policy_refined) # compute log-conditional expectation of refined policy if t != 1: - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] - log_conditional_expectation = self.log_conditional_expectation(t, policy_refined[t], states_current) - - output = {'policy_refined': policy_refined } + states_previous = HistoryData.X[t-1] + states_current = HistoryData.X[t] + log_conditional_expectation = self.log_conditional_expectation( + t, policy_refined[t], states_current) - return output + output = {'policy_refined': policy_refined} + return output """ FONCTIONS USED FOR ADP FUNCTION ABOVE """ - - def log_weights_uncontrolled(self, t, xp, x ): + + def log_weights_uncontrolled(self, t, xp, x): """ """ - return self.ssm.PY(t, xp, x).logpdf(self.data[t]) - - def log_policy(self, t, policy, xp, x ): + return self.ssm.PY(t, xp, x).logpdf(self.data[t]) + + def log_policy(self, t, policy, xp, x): """ """ LogPolicy = self.logPolicy(t, xp, x, policy) return LogPolicy def log_conditional_expectation(self, t, policy_refined, x): """ """ - LogCondExpect = np.ones(x.shape[0]) - + LogCondExpect = np.ones(x.shape[0]) + it = t*np.ones(x.shape[0]).astype(int) if self.ssm.PX(t, x).dim == 1: - loop = [self.logCondExp(it[i], x[i]) for i in range (0, len(it))] - LogCondExpect = np.array(loop).reshape(x.shape[0]) - else: - loop = [self.logCondExp(it[i], x[i,:]) for i in range (0, len(it)) ] - + loop = [self.logCondExp(it[i], x[i]) for i in range(0, len(it))] + LogCondExpect = np.array(loop).reshape(x.shape[0]) + else: + loop = [self.logCondExp(it[i], x[i, :]) for i in range(0, len(it))] + LogCondExpect = np.array(loop).reshape(x.shape[0], 1) return LogCondExpect - - def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here + def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here """ Learn policy refinement using ridge regression. @@ -597,23 +555,25 @@ def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor """ # construct design matrix if self.du == 1: - x = x.reshape(x.shape[0],1) - xp = xp.reshape(xp.shape[0],1) - + x = x.reshape(x.shape[0], 1) + xp = xp.reshape(xp.shape[0], 1) + design_matrix = self.design_matrix_Quadratic_univariate(x) # perform ridge regression - ridge_regressor = Ridge(alpha=settings['regularization'], fit_intercept=False) + ridge_regressor = Ridge( + alpha=settings['regularization'], fit_intercept=False) ridge_regressor.fit(design_matrix, - target_values) # get refinement coefficients from regression coefficients - refinement = ridge_regressor.coef_ # self.get_coef_Quadratic_univariate(ridge_regressor.coef_) + refinement = ridge_regressor.coef_ # compute R-squared - r_squared = np.corrcoef(ridge_regressor.predict(design_matrix), target_values)[0, 1]**2 + r_squared = np.corrcoef(ridge_regressor.predict( + design_matrix), target_values)[0, 1]**2 return (refinement, r_squared) - + def get_coef_Quadratic_univariate(self, regression_coef): """ Get coefficients (a, b, c) of the Quadratic function of a univariate variable x @@ -631,14 +591,12 @@ def get_coef_Quadratic_univariate(self, regression_coef): """ # get coefficients output = {} - - output['a'] = regression_coef[2] # output['a'] = regression_coef[2] - output[1] = regression_coef[2] # output['a'] = regression_coef[2] - - output['b'] = regression_coef[1] # output['b'] = regression_coef[1] - output['c'] = regression_coef[0] # output['c'] = regression_coef[0] + + output['a'] = regression_coef[2] + output['b'] = regression_coef[1] + output['c'] = regression_coef[0] return output - + def design_matrix_Quadratic_univariate(self, x): """ Construct design matrix of features for Quadratic function of a univariate variable @@ -681,9 +639,9 @@ def refine_policy(self, policy_current, refinement): output : dict Coefficients specifying the refined policy at the current time period """ - - if self.du == 1: - outPut = policy_current + np.exp(-refinement) - else: # should be updated - outPut = policy_current + refinement - return outPut \ No newline at end of file + + if self.du == 1: + outPut = policy_current + np.exp(-refinement) + else: # update this + outPut = policy_current + refinement + return outPut diff --git a/particles/state_space_models.py b/particles/state_space_models.py index 4f78fe3..fc303d7 100644 --- a/particles/state_space_models.py +++ b/particles/state_space_models.py @@ -268,11 +268,10 @@ def policy(self): """policy : Coefficients specifying policy policy should be exponential quadratic - log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A is a matrix dxd, b a vector, c scalar - return the list [At, Bt, Ct] - A_t is a matrix - Bt is a vector of dimension of the - Ct is !! + log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A_t is a symetric matrix, B_t a vector, C_t a scalar + + Returns: + A_t, B_t, C_t """ raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) From a59b5837590341343b514fbbab007baf933687f5 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Thu, 21 Apr 2022 21:42:15 +0200 Subject: [PATCH 11/15] Update Requirement and setup Add new package "sklearn.linear_model" requirement --- requirements.txt | 1 + setup.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/requirements.txt b/requirements.txt index 117817e..62da1b3 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ numpy scipy ipython nbsphinx +sklearn.linear_model diff --git a/setup.py b/setup.py index 6bc607f..ae8b5c4 100644 --- a/setup.py +++ b/setup.py @@ -22,8 +22,8 @@ install_requires=['numpy>=1.18', 'scipy>=1.7', 'numba', - 'joblib' - ], + 'joblib', + 'sklearn.linear_model'], author_email='nicolas.chopin@ensae.fr', description=DESCRIPTION, long_description = long_description, From ff56fd139aec375d0f3bf51f03c3e05e67b312c7 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Thu, 21 Apr 2022 21:45:04 +0200 Subject: [PATCH 12/15] Add Jupyter note book test for controlled SMC --- docs/source/notebooks/ControlledSMC.ipynb | 58 +++++++++-------------- 1 file changed, 23 insertions(+), 35 deletions(-) diff --git a/docs/source/notebooks/ControlledSMC.ipynb b/docs/source/notebooks/ControlledSMC.ipynb index 3843694..95975d7 100644 --- a/docs/source/notebooks/ControlledSMC.ipynb +++ b/docs/source/notebooks/ControlledSMC.ipynb @@ -8,62 +8,62 @@ "\n", "Test Controlled SMC algorithm on Stochastic Volatiliy Model\n", "\n", - "For more details on ControlledSMC models and their properties, see the article: https://arxiv.org/abs/1708.08396\n", + "For more details on ControlledSMC models, see the article: https://arxiv.org/abs/1708.08396\n", "\n", - "Steps to define a ControlledSMC model: \n", - "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). \n", - " This model should be an ssm object. For example: ssm = stovolModel() \n", - " - Define your own policy functions. \n", + "Steps to define a ControlledSMC model \n", + "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). For example ssm = stovolModel() \n", + " - Define your policy functions. \n", " \n", "Step 2 : Create the ControlledSMC object as follow:\n", + " \n", " myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 5)\n", " ssm = your original defined model \n", " data: is your data\n", - " iterations = fixed at your convenience. \n", + " iterations = fixed at your convenience. \n", "\n", " \n", - "## First steps: defining a state-space model and Policy functionss\n", + "## Defining a state-space model and Policy functions\n", "\n", "We start by importing some standard libraries, plus some modules from the package." ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "%matplotlib inline\n", "import warnings; warnings.simplefilter('ignore') # hide warnings \n", "\n", "# standard libraries\n", "from matplotlib import pyplot as plt\n", "import numpy as np\n", - "import seaborn as sb\n", + "\n", + "# modules from particles\n", + "import particles # core module\n", "from particles import distributions as dists # where probability distributions are defined\n", "from particles import state_space_models as ssm # where state-space models are defined\n", - "from particles.collectors import Moments \n", - "from collectors import Moments \n", - "from sklearn.linear_model import Ridge\n", - "import controlled_smc as cSMC\n" + "from particles.collectors import Moments \n", + "from particles import controlled_smc as cSMC " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Let's define our first state-space model **class** and the policy function. We consider a basic stochastic volalitility model, that is: \n", + "Let's define our first state-space model **class** and the policy functions. We consider a basic stochastic volalitility model, that is: \n", "\\begin{align*}\n", "X_0 & \\sim N\\left(\\mu, \\frac{\\sigma^2}{1-\\rho^2}\\right), &\\\\\n", "X_t|X_{t-1}=x_{t-1} & \\sim N\\left( \\mu + \\rho (x_{t-1}-\\mu), \\sigma^2\\right), &\\quad t\\geq 1, \\\\\n", "Y_t|X_t=x_t & \\sim N\\left(0, e^{x_t}\\right),& \\quad t\\geq 0.\n", "\\end{align*}\n", " \n", - "Note that this model depends on fixed parameter $\\theta=(\\mu, \\rho, \\sigma)$. The policy function P is defined as:\n", + "Note that this model depends on fixed parameter $\\theta=(\\mu, \\rho, \\sigma)$. The policy function $P_t$ is defined as:\n", "\n", "$$\n", "\\log P_t(t, X_{t-1}, X_{t}) = -[(A_t X_{t},X_{t}) + (B_t,X_{t}) + c_t] \n", - "$$" + "$$\n", + "$A_t$ is a matrix, $B_t$ a vector, $c_t$ a scalar " ] }, { @@ -72,11 +72,11 @@ "metadata": {}, "outputs": [], "source": [ - "# DEFINE STOCHASTIC VOLATILITY MODEL\n", - "# ----------------------------------- \n", + "# DEFINE STOCHASTIC VOLATILITY MODEL WITH TOY POLICY\n", + "# ---------------------------------------------------\n", "class StochVol(ssm.StateSpaceModel): \n", " \"\"\" \"\"\"\n", - " mu = -1.0; sigma = 1.0; rho = 1.0/np.sqrt(2) #\n", + " mu = -1.0; sigma = 1.0; rho = 1.0/np.sqrt(2) # for fixed parameters\n", " def PX0(self): # Distribution of X_0\n", " \"\"\" \"\"\"\n", " return dists.Normal( loc = self.mu, scale=self.sigma / np.sqrt(1.0 - self.rho**2))\n", @@ -88,7 +88,7 @@ " return dists.Normal(loc=0., scale=np.exp(0.5*x))\n", " def policy(self,t): # a quadratic function policy(At, Bt, Ct)\n", " \"\"\" return only coefs of the quadratic from of the policy function (A,B,c)\n", - " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t] - F(xp); where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", + " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t]; where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", " \"\"\"\n", " return 0.002175129155947095, 0.021869510847052914, 0.53135057055622562" ] @@ -137,7 +137,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Twisted feynman kac model and bootstraap - simulations comparison \n", + "# Twisted feynman kac model and Bootstrap - simulations comparison \n", "\n", " \n" ] @@ -276,18 +276,6 @@ "\n", "PsiSMCResults = PsiSMC.RunAll() \n" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## TODO\n", - "\n", - " -\n", - " -\n", - " \n", - "\n" - ] } ], "metadata": { @@ -307,7 +295,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.5.2" } }, "nbformat": 4, From e05c2e339796a3c744e9752c37dc189088c898b7 Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Fri, 30 Sep 2022 18:28:40 +0200 Subject: [PATCH 13/15] Add files via upload --- .../notebooks/ControlledSMCTutorial.ipynb | 641 ++++++++++++++++++ 1 file changed, 641 insertions(+) create mode 100644 docs/source/notebooks/ControlledSMCTutorial.ipynb diff --git a/docs/source/notebooks/ControlledSMCTutorial.ipynb b/docs/source/notebooks/ControlledSMCTutorial.ipynb new file mode 100644 index 0000000..0511b28 --- /dev/null +++ b/docs/source/notebooks/ControlledSMCTutorial.ipynb @@ -0,0 +1,641 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test Controlled SMC\n", + "\n", + "Test Controlled SMC algorithm on linear gaussian model. For more details on ControlledSMC models, see the article: https://arxiv.org/abs/1708.08396\n", + "\n", + "Steps to define a ControlledSMC model \n", + "Step 1 : - Define your own model (for example a state space model [See basic tutorial lesson]). For example ssm = myModel() \n", + " \n", + "Step 2 : Create the ControlledSMC object as follow:\n", + " \n", + " myCtrlSMC = cSMC.ControlledSMC(ssm=myModel, data = data, iterations = 5)\n", + " ssm: your original defined model \n", + " data: is your data\n", + " iterations: iteration to stop the algorithm\n", + "\n", + " \n", + "## Defining a state-space model and Policy functions\n", + "\n", + "We start by importing some standard libraries, plus some modules from the particles package and the controlled smc module." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings; warnings.simplefilter('ignore') # hide warnings \n", + "\n", + "# standard libraries\n", + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sb\n", + "\n", + "# modules from particles\n", + "import particles # core module\n", + "from particles import distributions as dists # where probability distributions are defined\n", + "from particles import state_space_models as ssm # where state-space models are defined\n", + "from particles.collectors import Moments \n", + "from particles import controlled_smc as cSMC # where controlled smc models are defined" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will test the controlled SMC algorithm on a linear gaussian state-space model. It is not required to define a policy function. \n", + "\n", + "\\begin{align*}\n", + "X_0 & \\sim N\\left(0, \\frac{\\sigma_X^2}{(1-\\rho^2)}\\right), &\\\\\n", + "X_t|X_{t-1}=x_{t-1} & \\sim N\\left( \\rho x_{t-1}, \\sigma_X^2\\right), &\\quad t\\geq 1, \\\\\n", + "Y_t|X_t=x_t & \\sim N\\left(x_{t}, \\sigma_Y^2\\right),& \\quad t\\geq 0.\n", + "\\end{align*}\n", + "\n", + "Note that this model depends on fixed parameter $\\theta = (\\sigma_X, \\rho, \\sigma_Y)$. \n", + "\n", + "If you want to define a policy function $P_t$, it should have the following structure:\n", + "\n", + "$$\n", + "\\log P_t(t, X_{t-1}, X_{t}) = -[(A_t X_{t},X_{t}) + (B_t,X_{t}) + c_t] \n", + "$$ \n", + "\n", + "where $A_t \\geq 0 $, $B_t$, $c_t$ are scalars. The policy function should return only the coefficients $A_t$, $B_t$, $c_t$." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "# DEFINE LINEAR GAUSSIAN MODEL\n", + "# -----------------------------\n", + "N = 150 # \n", + "class LinearGaussian(ssm.StateSpaceModel): \n", + " mu = -1.0; sigmaX = 1.0; sigmaY = 0.1; rho = 0.9 \n", + " def PX0(self): # Distribution of X_0\n", + " return dists.Normal( loc = 0, scale = self.sigmaX/np.sqrt((1- self.rho**2)))\n", + " # return dists.Normal( loc = 1.5, scale=2)\n", + " \n", + " def PX(self, t, xp): # Distribution of X_t given X_{t-1}=xp (p=past)\n", + " return dists.Normal(loc=self.rho * xp , scale=self.sigmaX)\n", + "\n", + " def PY(self, t, xp, x): # Distribution of Y_t given X_t=x (and possibly X_{t-1}=xp)\n", + " return dists.Normal(loc = x, scale = self.sigmaY)\n", + " \n", + " def policy(self, t): # this methode is optional to define.\n", + " \"\"\" return only coefs of the quadratic policy function\n", + " log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + c_t] - F(xp); where A_t is a matrix dxd, B_t a d-vector, c_t a scalar \n", + " The definition of this function is optional. \n", + " \"\"\"\n", + " return 0.0, 0.0, 0.0" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# define the model\n", + "linearModel = LinearGaussian() \n", + "true_states, data = linearModel.simulate(N) # we simulate from the model N data points\n", + "plt.style.use('ggplot')\n", + "plt.figure()\n", + "plt.plot(data, linewidth = 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Twisted feynman kac model and Bootstrap - simulations comparison \n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# define the corresponding Bootstrap model\n", + "fk_Bootstrap= ssm.Bootstrap(ssm=linearModel, data=data) \n", + "\n", + " # define the corresponding TwistedFK (feynman kac) model\n", + "fk_TwistedFK = cSMC.TwistedFK(ssm=linearModel, data=data)\n", + " \n", + "# Bootstrap \n", + "pfBootstrap = particles.SMC(fk=fk_Bootstrap, N=N, resampling='multinomial', collect=[Moments()], store_history=True) # the algorithm\n", + "pfBootstrap.run() # actual computation\n", + "\n", + "# Twisted SMC \n", + "pfTwisted = particles.SMC(fk=fk_TwistedFK, N=N, resampling='multinomial', collect=[Moments()], store_history=True) # the algorithm\n", + "pfTwisted.run() # actual computation\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Weighted histogram of the particles')" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Weighted histogram of the particles \n", + "plt.figure()\n", + "plt.hist(pfBootstrap.X, 100, weights=pfBootstrap.W)\n", + "plt.hist(pfTwisted.X, 100, weights=pfTwisted.W)\n", + "plt.legend(['Bootstrap', 'Twisted FK'], fontsize = 15)\n", + "plt.title('Weighted histogram of the particles')" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ESSs\n", + "plt.figure()\n", + "plt.plot(pfBootstrap.summaries.ESSs, linewidth = 1)\n", + "plt.plot(pfTwisted.summaries.ESSs, linewidth = 1.2)\n", + "plt.xlabel('t')\n", + "plt.ylabel('ESS')\n", + "plt.legend(['Bootstrap', 'Twisted FK'], fontsize = 15)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# log-likelihood\n", + "plt.figure()\n", + "plt.plot(pfBootstrap.summaries.logLts)\n", + "plt.plot(pfTwisted.summaries.logLts)\n", + "plt.xlabel('t')\n", + "plt.ylabel('log-likelihood')\n", + "plt.legend(['Bootstrap', 'Twisted FK'], fontsize = 15)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 1.0, 'Boxplot')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Boxplot\n", + "outf = lambda pf: pf.logLt\n", + "results = particles.multiSMC(fk={'boot':fk_Bootstrap, 'twistedFK':fk_TwistedFK}, \n", + " nruns=10, nprocs=1, out_func=outf)\n", + "plt.figure()\n", + "sb.boxplot(x=[r['fk'] for r in results], y=[r['output'] for r in results])\n", + "plt.title('Boxplot')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Controlled smc - Feynman kac model results " + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "maxTime = 150\n", + "myiter = 2\n", + "PsiSMC = cSMC.ControlledSMC(ssm=linearModel, data = data, maxTime = maxTime, iterations = myiter) \n", + "\n", + "# Run controlled SMC algorithm\n", + "cSMChist, cSMCsummaries = PsiSMC.RunAll()" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Weighted histogram of the particles\n", + "plt.figure()\n", + "plt.hist(cSMChist.X[maxTime-1], N, weights=cSMChist.wgts[maxTime-1].W)\n", + "plt.legend(['wgts histogram at iter ' + str(myiter)], fontsize = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ESSs\n", + "plt.figure()\n", + "plt.plot(pfBootstrap.summaries.ESSs) \n", + "plt.plot(cSMCsummaries.ESSs) \n", + "plt.xlabel('t')\n", + "plt.ylabel('ESS')\n", + "plt.legend(['Bootstrap', 'Twisted FK iter ' + str(myiter)], fontsize = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# log-likelihood\n", + "plt.figure()\n", + "plt.plot(np.array(pfBootstrap.summaries.logLts)[1:]/100)\n", + "plt.plot(np.array(cSMCsummaries.logLts)[1:]/100)\n", + "plt.xlabel('t')\n", + "plt.ylabel('log-likelihood')\n", + "plt.legend(['Bootstrap', 'Twisted FK iter '+str(myiter)], fontsize = 15)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [], + "source": [ + "maxTime = 100\n", + "myiter = 3\n", + "PsiSMC = cSMC.ControlledSMC(ssm=linearModel, data = data, maxTime = maxTime, iterations = myiter) \n", + "\n", + "# Run controlled SMC algorithm\n", + "cSMChist, cSMCsummaries = PsiSMC.RunAll()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Weighted histogram of the particles\n", + "plt.figure()\n", + "plt.hist(cSMChist.X[maxTime-1], N, weights=cSMChist.wgts[maxTime-1].W)\n", + "plt.legend(['wgts histogram at iter ' + str(myiter)], fontsize = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Weighted histogram of the particles\n", + "plt.figure()\n", + "plt.hist(cSMChist.X[maxTime-1], N, weights=cSMChist.wgts[maxTime-1].W)\n", + "plt.legend(['wgts histogram at iter ' + str(myiter)], fontsize = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ESSs\n", + "plt.figure()\n", + "plt.plot(pfBootstrap.summaries.ESSs) \n", + "\n", + "plt.plot(cSMCsummaries.ESSs) \n", + "plt.xlabel('t')\n", + "plt.ylabel('ESS')\n", + "plt.legend(['Bootstrap', 'Twisted FK iter ' + str(myiter)], fontsize = 15)" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# log-likelihood\n", + "plt.figure()\n", + "plt.plot(np.array(pfBootstrap.summaries.logLts)[1:]/100)\n", + "plt.plot(np.array(cSMCsummaries.logLts)[1:]/100)\n", + "plt.xlabel('t')\n", + "plt.ylabel('log-likelihood')\n", + "plt.legend(['Bootstrap', 'Twisted FK iter '+str(myiter)], fontsize = 15)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Particle Smoothing\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "smooth_trajectories = cSMChist.backward_sampling(3) # 10 Trajectories\n", + "plt.figure()\n", + "plt.plot(smooth_trajectories)\n", + "plt.title(\"Twisted smooth_trajectories iter\" +str(myiter))\n", + "plt.legend()" + ] + } + ], + "metadata": { + "celltoolbar": "Edit Metadata", + "kernelspec": { + "display_name": "Python 3", + "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.9.7" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From fd1e229bc76f84a080515f6252ccf638136818dc Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Fri, 30 Sep 2022 18:32:10 +0200 Subject: [PATCH 14/15] Add files via upload --- particles/controlled_smc.py | 371 +++++++++++++----------------------- 1 file changed, 130 insertions(+), 241 deletions(-) diff --git a/particles/controlled_smc.py b/particles/controlled_smc.py index 312e642..7fb95f1 100644 --- a/particles/controlled_smc.py +++ b/particles/controlled_smc.py @@ -65,16 +65,10 @@ def PX0(self): # dist of X_0 myCtrlSMC = cSMC.ControlledSMC(ssm=stovolModel, data = data, iterations = 10) -TODO: Run the algorithm +Run the algorithm ======================= To run the algorithm: - myCtrlSMC.run() - -Hopefully, the code above is fairly transparent. - - - -.. note:: + myCtrlSMC.runAll() """ from __future__ import division, print_function import particles @@ -85,32 +79,10 @@ def PX0(self): # dist of X_0 from particles import distributions as dists from sklearn.linear_model import Ridge -err_msg_missing_policy = """ - State-space model %s is missing method policy for controlled SMC, specify a policy - """ - -""" -TODO: -===== - - - Argument ssm must implement method: Policy function (Later on this will be taken out). - - - - QUESTIONS - --------- - - - - DISCUSION - --------- - - moove some functions to utils. - - reshape the classes and simplify it - - Make controlled SMC algo iterable - -""" +err_msg_missing_policy = " Model %s is missing method for policy ! Algorithm will use default policy " class TwistedFK(ssm.Bootstrap): - """Twisted SMC for a given state-space model. Parameters ---------- @@ -127,62 +99,45 @@ class TwistedFK(ssm.Bootstrap): Note ---- - Argument ssm must implement methods a Policy function (Later on this will be taken out). """ - def M0(self, N): + def M0(self, N): # ψ-Proposal0 ''' Initial-Distribution ''' return self.M(0, self.ssm.PX0().rvs(size=N)) - + def M(self, t, xp): ''' ψ-Distribution of X_t given X_{t-1}=xp ''' - it = t*np.ones(xp.shape[0]).astype(int) - if self.ssm.PX(t, xp).dim == 1: - loop = [self.PsiProposal(it[i], xp[i]) for i in range(0, len(it))] - transition = np.array(loop).reshape(xp.shape[0]) - else: - loop = [self.PsiProposal(int(it[i]), xp[i, :]) - for i in range(0, len(it))] - transition = np.array(loop).reshape(xp.shape[0], xp.shape[1]) - - return transition - - def PsiProposal(self, t, xp): # M-ψ-Proposal - - myPolicy = self.ssm.policy - At, Bt, Ct = myPolicy[t] if type( - myPolicy) is np.ndarray else self.ssm.policy(t) - dim = self.ssm.PX(t, xp).dim + if hasattr(self.ssm, 'policy'): + myPolicy = self.ssm.policy + At, Bt, Ct = myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) + else: + At, Bt, Ct = 0.0, 0.0, 0.0 if t == 0: Mean = self.ssm.PX0().loc - Var = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 + Var = self.ssm.PX0().scale**2 else: Mean = self.ssm.PX(t, xp).loc - Var = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX( - t, xp).scale**2 + Var = self.ssm.PX(t, xp).scale**2 - VarInv = np.linalg.inv(Var) if dim > 1 else 1.00 / Var - V = np.dot(VarInv, Mean) - Bt - Alpha = np.linalg.inv( - VarInv + 2*At) if dim > 1 else 1.0/(VarInv + 2*At) - mbar = np.dot(Alpha, V) + VarInv = 1.0 / Var + V = VarInv * Mean - Bt + Alpha = 1.0/(VarInv + 2*At) + mbar = Alpha * V - if dim == 1: - ProposalxPsiLaw = dists.Normal(loc=mbar, scale=np.sqrt(Alpha)) - else: - ProposalxPsiLaw = dists.MvNormal(loc=mbar, scale=1, cov=Alpha) + ProposalxPsi = dists.Normal(loc=mbar, scale=np.sqrt(Alpha)) - return ProposalxPsiLaw.rvs(size=1) + return ProposalxPsi.rvs(size = xp.shape[0]) def logG(self, t, xp, x): # Log Potentials - - # retrieve policy from ssm model - myPolicy = self.ssm.policy - - At, Bt, Ct = myPolicy[t] if type( - myPolicy) is np.ndarray else self.ssm.policy(t) + if hasattr(self.ssm, 'policy'): + myPolicy = self.ssm.policy # return my log policy coefs + At, Bt, Ct = myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) + else: + At, Bt, Ct = 0.0, 0.0, 0.0 # initialisation LogPolicy = np.zeros(x.shape[0]) @@ -192,7 +147,7 @@ def logG(self, t, xp, x): # Log Potentials for v in range(x.shape[0]): if self.du == 1: LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) - if t != self.T: + if t != self.T-1: LogForwardExpt[v] = self.logCondExp(t+1, x[v]) if t == 0: LogExpect[v] = self.logCondExp(t, x[v]) @@ -222,20 +177,13 @@ def logG(self, t, xp, x): # Log Potentials return LogGPsi def logPolicy(self, t, xp, x, policy_t): - LogPolicy = np.ones(x.shape[0]) At = policy_t[0] Bt = policy_t[1] Ct = policy_t[2] - for v in range(x.shape[0]): - if self.du == 1: - LogPolicy[v] = -self.Quadratic(At, Bt, Ct, x[v]) - else: - LogPolicy[v] = - \ - self.Quadratic(At, Bt.reshape(self.du, 1), Ct, x[v]) - return LogPolicy + output = np.squeeze(- At * x ** 2 - Bt * x - Ct) + return output def logCondExp(self, t, xp): - # TODO: make the function depends on policy ! """ Log Conditional expectation with respect to the Markov kernel at time t summary_ \E_M(ψ(Xp_t,X_t)) @@ -247,16 +195,20 @@ def logCondExp(self, t, xp): \E_M(ψ(Xp_t,X_t)) """ dim = self.du - myPolicy = self.ssm.policy - A , B , C = myPolicy[t-1] if type(myPolicy) is np.ndarray else self.ssm.policy(t-1) + if hasattr(self.ssm, 'policy'): + myPolicy = self.ssm.policy # return my log policy coefs + A, B, C = myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) + else: + A, B, C = 0.0, 0.0, 0.0 if t == 0: Mean = self.ssm.PX0().loc - Cov = self.ssm.PX0().cov if dim > 1 else self.ssm.PX0().scale**2 + Cov = self.ssm.PX0().scale**2 else: Mean = self.ssm.PX(t, xp).loc - Cov = self.ssm.PX(t, xp).cov if dim > 1 else self.ssm.PX( - t, xp).scale**2 + Cov = self.ssm.PX(t, xp).scale**2 + Mean = Mean.reshape(self.du, 1) result = self.logCondFun(t, A, B, C, Mean, Cov) @@ -268,37 +220,33 @@ def isADP(self): return 'ADP' in dir(self) @staticmethod - def Quadratic(A, B, c, x): + def Quadratic(A, B, C, x): if type(x) is np.ndarray: - result = np.sum(x * np.dot(A, np.transpose(x))) + \ - np.sum(B*np.transpose(x)) + c + return np.sum(x * np.dot(A, np.transpose(x))) + np.sum(B*np.transpose(x)) + C else: - result = A*x**2 + B*x + c - return result + result = A*x**2 + B*x + C + return result def logCondFun(self, t, A, B, C, Mean, Cov): """Log conditional expectation function""" + dim = 1 + CovInv = 1.0/Cov + V = CovInv * Mean - B + Alpha = 1.0 / (CovInv + 2*A) + quadraV = 0.5 * \ + self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) + quadraGamaMean = - 0.5 * \ + self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) - dim = Cov.shape[0] if type(Cov) is np.ndarray else 1 - Identity = np.identity(dim) - CovInv = np.linalg.inv(Cov) if dim > 1 else 1.0/Cov - V = np.dot(CovInv, Mean) - B - Alpha = np.linalg.inv( - CovInv + 2*A) if dim > 1 else 1.0 / (CovInv + 2*A) - quadraV = 0.5 * self.Quadratic(Alpha, np.zeros([dim, 1]), 0, np.transpose(V)) - quadraGamaMean = - 0.5 * self.Quadratic(CovInv, np.zeros([dim, 1]), 0, np.transpose(Mean)) - - Det = np.linalg.det(Identity + 2 * np.dot(Cov, A)) if dim > 1 else 1+2*Cov*A - return quadraV + quadraGamaMean - 0.5 * np.log(Det) - C + return quadraV + quadraGamaMean - 0.5 * np.log(1+2*Cov*A) - C class ControlledSMC(TwistedFK): - """ Controlled SMC class algorithm Parameters + Inputs. ------------------------------------------------------------- - It is the same as of TwistedFK + iterations (number of iterations) to use for the controlled SMC + It is the same as of the class TwistedFK + iterations (number of iterations) ssm: StateSpaceModel object the considered state-space model (-ssm with proposal and logEta(the psi)), @@ -311,26 +259,21 @@ class ControlledSMC(TwistedFK): FeynmanKac object the Feynman-Kac representation of the filter for the considered state-space model - """ - def __init__(self, ssm=None, data=None, iterations=None): + def __init__(self, ssm=None, data=None, maxTime=None, iterations=None): self.ssm = ssm self.data = data + self.maxTime = maxTime self.iterations = iterations self.du = self.ssm.PX0().dim - self.policy = self.ssm.policy + self.policy = self.ssm.policy if hasattr(self.ssm, 'policy') else print( + NotImplementedError(err_msg_missing_policy % self.__class__.__name__)) self.iter = 0 @property def T(self): - return 0 if self.data is None else len(self.data) - - @property - def isPolicyMissing(self): - """Returns true if model parameter contains policy in the argument dictionary in ssm constructor""" - if (hasattr(self, self.ssm.policy) == False): # if('policy' in dir(self) == False): - raise NotImplementedError(self._error_msg('missing policy')) + return len(self.data) if self.maxTime is None else self.maxTime def next(self): return self.__next__() @@ -339,84 +282,55 @@ def __iter__(self): return self @utils.timer - def run(self): # make this iterator() + def run(self): for _ in self: pass - def generateIntialParticules(self): + def RunAll(self): N = len(self.data) - policy_initial = np.array([[0.0, 0.0, 0.0] for t in range(self.T)]) - - # Construct and run the Psi Model for initialisation to compute ADP to refine the policy - fk_model = TwistedFK(self.ssm, self.data) - PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', - collect=[collectors.Moments()], store_history=True) - PsiSMC.run() - - # TODO: remove new field to the FK object. - self.hist = PsiSMC.hist - self.policy = policy_initial - - def generateParticulesWithADP(self): - settings = {'N': len(self.data), 'sample_trajectory': False, - 'regularization': 1e-4} - # fk_model = self.hist - PsiSMC = self.hist - adp = self.ADP(self.data, self.policy, PsiSMC, settings) - refinedPolicy = adp['policy_refined'] - self.ssm.set_policy(refinedPolicy) - self.policy = refinedPolicy - - # Run ψ -twisted SMC with refined policy - fk_model = TwistedFK(self.ssm, self.data) - fk_model.isADP == True - PsiSMC = particles.SMC(fk=fk_model, N=len(self.data), resampling='multinomial', - collect=[collectors.Moments()], store_history=True) - PsiSMC.run() - self.hist = PsiSMC.hist + if hasattr(self.ssm, 'policy'): + myPolicy = self.ssm.policy + policy = np.array([myPolicy[t] if type( + myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) + else: + myPolicy = np.array([0.0, 0.0, 0.0]) + policy = np.array([myPolicy for t in range(self.T)]) - def RunAll(self): # def __next__(self): - # if self.done(self): - # raise StopIteration - # if self.iterations == 1: - # intialisation - N = len(self.data) - myPolicy = self.ssm.policy - policy = np.array([myPolicy[t] if type(myPolicy) is np.ndarray else self.ssm.policy(t) for t in range(self.T)]) # this is the right one. + setattr(self.ssm, 'policy', policy) # Construct and run the Psi Model for initialisation fk_model = TwistedFK(self.ssm, self.data) + self.isADP == True + fk_model.isADP == True + PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[collectors.Moments()], store_history=True) PsiSMC.run() settings = {'N': N, 'sample_trajectory': False, - 'regularization': 1e-4} - # else: + 'regularization': 0.009} + + schedule = np.exp(np.linspace(-10, 0, self.iterations)) + for it in range(self.iterations): # run ADP - adp = self.ADP(fk_model, self.data, policy, PsiSMC, settings) - # Construct refined policy - refinedPolicy = adp['policy_refined'] - self.ssm.set_policy(refinedPolicy) - policy = refinedPolicy - TestRefinedPolicy = np.array(self.ssm.policy) + adp = self.ADP(fk_model, self.data, self.ssm.policy, + PsiSMC, settings, schedule[it]) # Run ψ-twisted SMC with refined policy - fk_model = TwistedFK(self.ssm, self.data) - fk_model.isADP == True - PsiSMC = particles.SMC(fk=fk_model, N=N, resampling='multinomial', collect=[ + tfk_model = TwistedFK(self.ssm, self.data) + PsiSMC = particles.SMC(fk=tfk_model, N=N, resampling='multinomial', collect=[ collectors.Moments()], store_history=True) PsiSMC.run() - return PsiSMC.hist + + return PsiSMC.hist, PsiSMC.summaries def ADP(self, model, observations, policy, psi_smc, settings, inverse_temperature=1.0): """ + Approximate dynamic programming to refine a policy. + model = ssm or any kind of model observations = data psi_smc = fk.run().results (derived from fk.run()) - settings = parameters of the model you define yourself - - Approximate dynamic programming to refine a policy. Parameters ---------- @@ -431,7 +345,7 @@ def ADP(self, model, observations, policy, psi_smc, settings, inverse_temperatur 'N' : int specifying number of particles 'sample_trajectory' : bool specifying whether a trajectory is to be sampled - policy : list of dicts of length T+1 + policy : list of dicts Coefficients specifying policy inverse_temperature : float @@ -442,63 +356,55 @@ def ADP(self, model, observations, policy, psi_smc, settings, inverse_temperatur ------- output : dict Algorithm output contain: - 'policy_refined' : list of dicts of length T+1 containing coefficients specifying refined policy - 'r_squared' : numpy.array (T+1,) containing coefficient of determination values + 'policy_refined' : list of dicts containing coefficients specifying refined policy + 'r_squared' : numpy.array containing coefficient of determination values """ - # get model properties and algorithmic settings - T = len(observations) - 1 # observations.shape[0] - 1 - N = settings['N'] - - HistoryData = psi_smc.hist - - # pre-allocate + T = model.T-1 + N = psi_smc.N + SMC = psi_smc.hist policy_refined = np.array([[0.0, 0.0, 0.0] for t in range(self.T)]) - r_squared = np.ones([T+1]) # initialize at T - states_previous = psi_smc.Xp - states_current = psi_smc.X log_conditional_expectation = np.zeros([N]) - - # iterate over time periods backwards - for t in range(T, 0, -1): - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] - + ancestors = SMC.A[T] + states_previous = np.take(SMC.X[T-1], ancestors) + states_current = SMC.X[T] + SMC.A[0] = np.asarray(list(range(0, N))) + + for t in range(T, -1, -1): + if t == 0: + states_current = SMC.X[0] + log_conditional_expectation = self.log_conditional_expectation( + t, policy_refined[1], states_current) # compute uncontrolled weights of reference proposal transition - # (t, observations[t, :], states_previous, states_current) log_weights_uncontrolled = self.log_weights_uncontrolled( - t, states_previous, states_current) - - # evaluate log-policy function - log_policy = self.log_policy( - t, policy[t], states_previous, states_current) + t, states_previous, states_current, inverse_temperature) + # evaluate log-policy function (self, t, policy, xp, x ): + log_policy = self.logPolicy( + t, states_previous, states_current, policy[t]) # target function values - target_values = log_weights_uncontrolled.reshape(len(log_policy), 1) + \ - log_conditional_expectation.reshape(len(log_policy), 1) - log_policy.reshape( - len(log_policy), 1) + target_values = log_weights_uncontrolled - \ + log_policy + log_conditional_expectation # perform regression to learn refinement (update this function for high dimensional case) (refinement, r_squared[t]) = self.learn_refinement( states_previous, states_current, target_values, settings) - - # refine current policy - policy_refined[t] = self.refine_policy(policy[t], refinement) - - # set Policy - self.ssm.set_policy(policy_refined) - - # compute log-conditional expectation of refined policy - if t != 1: - states_previous = HistoryData.X[t-1] - states_current = HistoryData.X[t] + refinement[0] = np.abs(refinement[0]) + # refine current policy # This change automatically the ssm.policy cause reference. + policy[t] = self.refine_policy(policy[t], refinement) + + if t > 1: + ancestors = SMC.A[t-1] + states_current = SMC.X[t-1] + states_previous = np.take( + SMC.X[t-2], ancestors) # SMC.X[T-1 ancestors] log_conditional_expectation = self.log_conditional_expectation( - t, policy_refined[t], states_current) + t, policy[t], states_current) - output = {'policy_refined': policy_refined} + output = {'policy_refined': policy, 'r_squared': r_squared} return output @@ -506,32 +412,18 @@ def ADP(self, model, observations, policy, psi_smc, settings, inverse_temperatur FONCTIONS USED FOR ADP FUNCTION ABOVE """ - def log_weights_uncontrolled(self, t, xp, x): - """ """ - return self.ssm.PY(t, xp, x).logpdf(self.data[t]) - def log_policy(self, t, policy, xp, x): - """ """ - LogPolicy = self.logPolicy(t, xp, x, policy) - return LogPolicy + return self.logPolicy(t, xp, x, policy) - def log_conditional_expectation(self, t, policy_refined, x): - """ """ - LogCondExpect = np.ones(x.shape[0]) - - it = t*np.ones(x.shape[0]).astype(int) - - if self.ssm.PX(t, x).dim == 1: - loop = [self.logCondExp(it[i], x[i]) for i in range(0, len(it))] - LogCondExpect = np.array(loop).reshape(x.shape[0]) - else: - loop = [self.logCondExp(it[i], x[i, :]) for i in range(0, len(it))] - - LogCondExpect = np.array(loop).reshape(x.shape[0], 1) + def log_weights_uncontrolled(self, t, xp, x, temp): + return temp * self.ssm.PY(t, xp, x).logpdf(self.data[t]) - return LogCondExpect + def log_conditional_expectation(self, t, policy_refined, x): + it = np.repeat(t, x.shape[0]) + result = np.squeeze(np.array(list(map(self.logCondExp, it, x)))) + return result - def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor here + def learn_refinement(self, xp, x, target_values, settings): """ Learn policy refinement using ridge regression. @@ -566,7 +458,7 @@ def learn_refinement(self, xp, x, target_values, settings): # ridge_regressor ridge_regressor.fit(design_matrix, - target_values) # get refinement coefficients from regression coefficients - refinement = ridge_regressor.coef_ + refinement = self.get_coef_Quadratic_univariate(ridge_regressor.coef_) # compute R-squared r_squared = np.corrcoef(ridge_regressor.predict( @@ -590,11 +482,12 @@ def get_coef_Quadratic_univariate(self, regression_coef): output : dict """ # get coefficients - output = {} + # output = {} + output = np.zeros(3) - output['a'] = regression_coef[2] - output['b'] = regression_coef[1] - output['c'] = regression_coef[0] + output[0] = regression_coef[2] + output[1] = regression_coef[1] + output[2] = regression_coef[0] return output def design_matrix_Quadratic_univariate(self, x): @@ -610,7 +503,6 @@ def design_matrix_Quadratic_univariate(self, x): ------- design_matrix : numpy.array (N, num_features) where num_features = 3 """ - # get size N = x.shape[0] @@ -640,8 +532,5 @@ def refine_policy(self, policy_current, refinement): Coefficients specifying the refined policy at the current time period """ - if self.du == 1: - outPut = policy_current + np.exp(-refinement) - else: # update this - outPut = policy_current + refinement - return outPut + outPut = refinement + policy_current + return outPut \ No newline at end of file From c01ca8fde5a415574260d0388fb5cc8eb661cd4a Mon Sep 17 00:00:00 2001 From: G-Kossi <97616269+G-Kossi@users.noreply.github.com> Date: Fri, 30 Sep 2022 18:37:26 +0200 Subject: [PATCH 15/15] Add files via upload Update package Controlled SMC and set state_space_models module to master --- particles/state_space_models.py | 6418 ++++++++++++++++++++++++++++--- 1 file changed, 5886 insertions(+), 532 deletions(-) diff --git a/particles/state_space_models.py b/particles/state_space_models.py index fc303d7..3f8f0bf 100644 --- a/particles/state_space_models.py +++ b/particles/state_space_models.py @@ -1,682 +1,6036 @@ -# -*- coding: utf-8 -*- -r""" -State-space models as Python objects. -Overview -======== -This module defines: - 1. the `StateSpaceModel` class, which lets you define a state-space model - as a Python object; - 2. `FeynmanKac` classes that automatically define the Bootstrap, guided or - auxiliary Feynman-Kac models associated to a given state-space model; - 3. several standard state-space models (stochastic volatility, - bearings-only tracking, and so on). -The recommended import is:: - from particles import state_space_models as ssms + + + + + + + + + + -For more details on state-space models and their properties, see Chapters 2 and -4 of the book. -Defining a state-space model -============================ -Consider the following (simplified) stochastic volatility model: + + + + + + -.. math:: + - Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\ - X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\ - X_0 &\sim N(0, \sigma^2 / (1 - \rho^2)) -To define this particular model, we sub-class `StateSpaceModel` as follows:: + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - import numpy as np - from particles import distributions as dists + particles/state_space_models.py at master · nchopin/particles - class SimplifiedStochVol(ssms.StateSpaceModel): - default_params = {'sigma': 1., 'rho': 0.8} # optional - def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1} - return dists.Normal(scale=np.exp(x)) - def PX(self, t, xp): # dist of X_t at time t, given X_{t-1} - return dists.Normal(loc=self.mu + self.rho * (xp - self.mu), - scale=self.sigma) - def PX0(self): # dist of X_0 - return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2)) -Then we define a particular object (model) by instantiating this class:: - my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9) + -Hopefully, the code above is fairly transparent, but here are some noteworthy -details: + - * probability distributions are defined through `ProbDist` objects, which - are defined in module `distributions`. Most basic probability - distributions are defined there; see module `distributions` for more details. - * The class above actually defines a **parametric** class of models; in - particular, ``self.sigma`` and ``self.rho`` are **attributes** of - this class that are set when we define object `my_stoch_vol_model`. - Default values for these parameters may be defined in a dictionary called - ``default_params``. When this dictionary is defined, any un-defined - parameter will be replaced by its default value:: + - default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8 - * There is no need to define a ``__init__()`` method, as it is already - defined by the parent class. (This parent ``__init__()`` simply takes - care of the default parameters, and may be overrided if needed.) -Now that our state-space model is properly defined, what can we do with it? -First, we may simulate states and data from it:: + + - x, y = my_stoch_vol_model.simulate(20) + -This generates two lists of length 20: a list of states, X_0, ..., X_{19} and -a list of observations (data-points), Y_0, ..., Y_{19}. + + + + + -Associated Feynman-Kac models -============================= + -Now that our state-space model is defined, we obtain the associated Bootstrap -Feynman-Kac model as follows:: + - my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y) + -That's it! You are now able to run a bootstrap filter for this model:: - my_alg = particles.SMC(fk=my_fk_model, N=200) - my_alg.run() -In case you are not clear about what are Feynman-Kac models, and how one may -associate a Feynman-Kac model to a given state-space model, see Chapter 5 of -the book. -To generate a guided Feynman-Kac model, we must provide proposal kernels (that -is, Markov kernels that define how we simulate particles X_t at time t, given -an ancestor X_{t-1}):: + - class StochVol_with_prop(StochVol): - def proposal0(self, data): - return dists.Normal(scale = self.sigma) - def proposal(t, xp, data): # a silly proposal - return dists.Normal(loc = rho * xp + data[t], scale=self.sigma) + - my_second_ssm = StochVol_with_prop(sigma=0.3) - my_better_fk_model = ssms.Guided(ssm = my_second_ssm, data=y) - # then run a SMC as above + -Voilà! You have now implemented a guided filter. + + + + + + + + + + + + + -Of course, the proposal distribution above does not make much sense; we use it -to illustrate how proposals may be defined. Note in particular that it depends -on ``data``, an object that represents the complete dataset. Hence the proposal -kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other -datapoint. -For auxiliary particle filters (APF), one must in addition specify auxiliary -functions, that is the (log of) functions :math:`\eta_t` that modify the -resampling probabilities (see Section 10.3.3 in the book):: + - class StochVol_with_prop_and_aux_func(StochVol_with_prop): - def logeta(self, t, x, data): - "Log of auxiliary function eta_t at time t" - return -(x-data[t])**2 - my_third_ssm = StochVol_with_prop_and_aux_func() - apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y) + + -Again, this particular choice does not make much sense, and is just given to -show how to define an auxiliary function. + -Already implemented state-space models -====================================== - -This module implements a few basic state-space models that are often used as -numerical examples: - -=================== ===================================================== -Class Comments -=================== ===================================================== -`StochVol` Basic, univariate stochastic volatility model -`StochVolLeverage` Univariate stochastic volatility model with leverage -`MVStochVol` Multivariate stochastic volatility model -`BearingsOnly` Bearings-only tracking -`Gordon_etal` Popular toy model often used as a benchmark -`DiscreteCox` A discrete Cox model (Y_t|X_t is Poisson) -`ThetaLogistic` Theta-logistic model from Population Ecology -=================== ===================================================== + -.. note:: - Linear Gaussian state-space models are implemented in module `kalman`; - similarly hidden Markov models (state-space models with a finite state-space) - are implemented in module `hmm`. - -""" - -from __future__ import division, print_function -import numpy as np -import particles -from particles import distributions as dists + + + + -err_msg_missing_cst = """ - State-space model %s is missing method upper_bound_log_pt, which provides - log of constant C_t, such that - p(x_t|x_{t-1}) <= C_t - This is required for smoothing algorithms based on rejection - """ -err_msg_missing_policy = """ - State-space model %s is missing method policy (a dictionnary) for controlled SMC, specify a policy dictionnary - """ + -class StateSpaceModel(object): - """Base class for state-space models. + + - To define a state-space model class, you must sub-class `StateSpaceModel`, - and at least define methods PX0, PX, and PY. Here is an example:: - - class LinearGauss(StateSpaceModel): - def PX0(self): # The law of X_0 - return dists.Normal(scale=self.sigmaX) - def PX(self, t, xp): # The law of X_t conditional on X_{t-1} - return dists.Normal(loc=self.rho * xp, scale=self.sigmaY) - def PY(self, t, xp, x): # the law of Y_t given X_t and X_{t-1} - return dists.Normal(loc=x, scale=self.sigmaY) - - These methods return ``ProbDist`` objects, which are defined in the module - `distributions`. The model above is a basic linear Gaussian SSM; it - depends on parameters rho, sigmaX, sigmaY (which are attributes of the - class). To define a particular instance of this class, we do:: - - a_certain_ssm = LinearGauss(rho=.8, sigmaX=1., sigmaY=.2) - - All the attributes that appear in ``PX0``, ``PX`` and ``PY`` must be - initialised in this way. Alternatively, it it possible to define default - values for these parameters, by defining class attribute - ``default_params`` to be a dictionary as follows:: - - class LinearGauss(StateSpaceModel): - default_params = {'rho': .9, 'sigmaX': 1., 'sigmaY': .1} - # rest as above - - Optionally, we may also define methods: - - * `proposal0(self, data)`: the (data-dependent) proposal dist at time 0 - * `proposal(self, t, xp, data)`: the (data-dependent) proposal distribution at - time t, for X_t, conditional on X_{t-1}=xp - * `logeta(self, t, x, data)`: the auxiliary weight function at time t - - You need these extra methods to run a guided or auxiliary particle filter. - - """ - - def __init__(self, **kwargs): - if hasattr(self, 'default_params'): - self.__dict__.update(self.default_params) - self.__dict__.update(kwargs) - - def _error_msg(self, method): - return ('method ' + method + ' not implemented in class%s' % - self.__class__.__name__) - - @classmethod - def state_container(cls, N, T): - law_X0 = cls().PX0() - dim = law_X0.dim - shape = [N, T] - if dim>1: - shape.append(dim) - return np.empty(shape, dtype=law_X0.dtype) - - def PX0(self): - "Law of X_0 at time 0" - raise NotImplementedError(self._error_msg('PX0')) - - def PX(self, t, xp): - " Law of X_t at time t, given X_{t-1} = xp" - raise NotImplementedError(self._error_msg('PX')) - - def PY(self, t, xp, x): - """Conditional distribution of Y_t, given the states. - """ - raise NotImplementedError(self._error_msg('PY')) - - def proposal0(self, data): - raise NotImplementedError(self._error_msg('proposal0')) - - def proposal(self, t, xp, data): - """Proposal kernel (to be used in a guided or auxiliary filter). - - Parameter - --------- - t: int - time - x: - particles - data: list-like - data - """ - raise NotImplementedError(self._error_msg('proposal')) - - @property - def policy(self): - """policy : - Coefficients specifying policy - policy should be exponential quadratic - log(policy(t, xp, x)) = -[(A_t x,x) + (B_t,x) + C_t]; where A_t is a symetric matrix, B_t a vector, C_t a scalar - - Returns: - A_t, B_t, C_t - """ - raise NotImplementedError(err_msg_missing_policy % self.__class__.__name__) + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ Skip to content + + + + + + + + + + + + - Returns - ------- - `FeynmanKac` object - the Feynman-Kac representation of the bootstrap filter for the - considered state-space model - """ - def __init__(self, ssm=None, data=None): - self.ssm = ssm - self.data = data - self.du = self.ssm.PX0().dim + +
- @property - def T(self): - return 0 if self.data is None else len(self.data) +
- def M0(self, N): - return self.ssm.PX0().rvs(size=N) - def M(self, t, xp): - return self.ssm.PX(t, xp).rvs(size=xp.shape[0]) - def logG(self, t, xp, x): - return self.ssm.PY(t, xp, x).logpdf(self.data[t]) - def Gamma0(self, u): - return self.ssm.PX0().ppf(u) - def Gamma(self, t, xp, u): - return self.ssm.PX(t, xp).ppf(u) - def logpt(self, t, xp, x): - """PDF of X_t|X_{t-1}=xp""" - return self.ssm.PX(t, xp).logpdf(x) - def upper_bound_trans(self, t): - return self.ssm.upper_bound_log_pt(t) +
- def add_func(self, t, xp, x): - return self.ssm.add_func(t, xp, x) -class GuidedPF(Bootstrap): - """Guided filter for a given state-space model. - Parameters - ---------- + +
- Returns - ------- - FeynmanKac object - the Feynman-Kac representation of the bootstrap filter for the - considered state-space model - Note - ---- - Argument ssm must implement methods `proposal0` and `proposal`. - """ + + - def M0(self, N): - return self.ssm.proposal0(self.data).rvs(size=N) - def M(self, t, xp): - return self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0]) + - def logG(self, t, xp, x): - if t == 0: - return (self.ssm.PX0().logpdf(x) - + self.ssm.PY(0, xp, x).logpdf(self.data[0]) - - self.ssm.proposal0(self.data).logpdf(x)) - else: - return (self.ssm.PX(t, xp).logpdf(x) - + self.ssm.PY(t, xp, x).logpdf(self.data[t]) - - self.ssm.proposal(t, xp, self.data).logpdf(x)) - - def Gamma0(self, u): - return self.ssm.proposal0(self.data).ppf(u) - def Gamma(self, t, xp, u): - return self.ssm.proposal(t, xp, self.data).ppf(u) -class APFMixin(): - def logeta(self, t, x): - return self.ssm.logeta(t, x, self.data) +
+ + + + + + + + + + + + + + + + + + +
+ +
+ + + + nchopin  /   + particles  /   + +
+
+ + + +
+ + +
+
+ Clear Command Palette +
+ + + + +
+
+ Tip: + Type # to search pull requests +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type # to search issues +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type # to search discussions +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type ! to search projects +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type @ to search teams +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type @ to search people and organizations +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type > to activate command mode +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Go to your accessibility settings to change your keyboard shortcuts +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type author:@me to search your content +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type is:pr to filter to pull requests +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type is:issue to filter to issues +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type is:project to filter to projects +
+
+ Type ? for help and tips +
+
+ + +
+
+ Tip: + Type is:open to filter to open content +
+
+ Type ? for help and tips +
+
+ + +
+ +
+
+ We’ve encountered an error and some results aren't available at this time. Type a new search or try again later. +
+ + + No results matched your search + + + + + + + + + + + + + + + + Search for issues and pull requests + + # + + + + Search for issues, pull requests, discussions, and projects + + # + + + + Search for organizations, repositories, and users + + @ + + + + Search for projects + + ! + + + + Search for files + + / + + + + Activate command mode + + > + + + + Search your issues, pull requests, and discussions + + # author:@me + + + + Search your issues, pull requests, and discussions + + # author:@me + + + + Filter to pull requests + + # is:pr + + + + Filter to issues + + # is:issue + + + + Filter to discussions + + # is:discussion + + + + Filter to projects + + # is:project + + + + Filter to open issues, pull requests, and discussions + + # is:open + + + + + + + + + + + + + + + + + + +
+ +
+ + + + + + + + + + +
+ + +
+
+
+ + -class AuxiliaryPF(GuidedPF, APFMixin): - """Auxiliary particle filter for a given state-space model. + - Parameters - ---------- - ssm: StateSpaceModel object - the considered state-space model - data: list-like - the data - Returns - ------- - `FeynmanKac` object - the Feynman-Kac representation of the APF (auxiliary particle filter) - for the considered state-space model - Note - ---- - Argument ssm must implement methods `proposal0`, `proposal` and `logeta`. - """ - pass - +
-class AuxiliaryBootstrap(Bootstrap, APFMixin): - """Base class for auxiliary bootstrap particle filters +
- This is an APF, such that the proposal kernel is set to the transition - kernel of the model - """ +
+ +
+ + + + / + + particles + + + Public +
+ + +
+ +
    + + + +
  • + +
    + + + + + + + Watch + + + 14 + + + +
    +
    +

    Notifications

    + +
    + +
    +
    + + + + + + + + +
    + + +
    + + + + + Get push notifications on iOS or Android. + +
    +
    +
    +     + + + + +
    +
    +     + + + +
    • + +
  • +
    + Fork + 55 + +
    + + + +
    + +
    +
    + + + + + + + +
    + +
    +
    +     +
    +
    • + +
  • + + +
    +
    + + +
    +
    + +
    + + + +
    + +
    +
    + + + + + + + +
    + +
    +
    +     +
    +
    +
    • - pass + +
-################################ -# Specific state-space models -################################ +
-class StochVol(StateSpaceModel): - r"""Univariate stochastic volatility model. +
+
- .. math:: - X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\ - X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t, \quad U_t\sim N(0,1) \\ - Y_t|X_t=x_t & \sim N(0, e^{x_t}) \\ - """ - default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178} - # values taken from Pitt & Shephard (1999) + + +
+ + + + + +
+ Open in github.dev + Open in a new github.dev tab - Note - ---- + - This is equivalent to assuming that the innovations of X_t and Y_t - are correlated, with correlation :math:`\phi`: - .. math:: + + +
+ + +
+ - X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t \\ - Y_t & = \exp(X_t/2) * V_t + - and :math:`Cor(U_t, V_t) = \phi` - Warning - ------- - This class inherits from StochVol, but methods proposal, proposal0 - and logeta were constructed for StochVol only, and should not work properly - for this class. - """ - default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178, 'phi': 0.} - def PY(self, t, xp, x): - # u is realisation of noise U_t, conditional on X_t, X_{t-1} - if t==0: - u = (x - self.mu) / self.sig0() - else: - u = (x - self.EXt(xp)) / self.sigma - std_x = np.exp(0.5 * x) - return dists.Normal(loc=std_x * self.phi * u, - scale=std_x * np.sqrt(1. - self.phi**2)) + +Permalink + +
+ +
+
+ + + master + + + +
+
+
+ Switch branches/tags + +
+ + + +
+ +
+ +
+ + +
+ +
+ + + + + + + + + + + + + + + +
+ + + + +
+
+ +
+ +
+ +

+ particles/particles/state_space_models.py + /
+ + Jump to + + +
+
+ Code definitions + +
+
+ +
+
+
+ + + StateSpaceModel + Class + + + __init__ + Function + + + _error_msg + Function + + + state_container + Function + + + PX0 + Function + + + PX + Function + + + PY + Function + + + proposal0 + Function + + + proposal + Function + + + upper_bound_log_pt + Function + + + add_func + Function + + + simulate_given_x + Function + + + simulate + Function + + + Bootstrap + Class + + + __init__ + Function + + + T + Function + + + M0 + Function + + + M + Function + + + logG + Function + + + Gamma0 + Function + + + Gamma + Function + + + logpt + Function + + + upper_bound_trans + Function + + + add_func + Function + + + GuidedPF + Class + + + M0 + Function + + + M + Function + + + logG + Function + + + Gamma0 + Function + + + Gamma + Function + + + APFMixin + Class + + + logeta + Function + + + AuxiliaryPF + Class + + + AuxiliaryBootstrap + Class + + + StochVol + Class + + + sig0 + Function + + + PX0 + Function + + + EXt + Function + + + PX + Function + + + PY + Function + + + _xhat + Function + + + proposal0 + Function + + + proposal + Function + + + logeta + Function + + + StochVolLeverage + Class + + + PY + Function + + + Gordon_etal + Class + + + PX0 + Function + + + PX + Function + + + PY + Function + + + BearingsOnly + Class + + + PX0 + Function + + + PX + Function + + + PY + Function + + + DiscreteCox + Class + + + PX0 + Function + + + PX + Function + + + PY + Function + + + MVStochVol + Class + + + offset + Function + + + PX0 + Function + + + PX + Function + + + PY + Function + + + ThetaLogistic + Class + + + PX0 + Function + + + PX + Function + + + PY + Function + + + proposal0 + Function + + + proposal + Function +
+
+
+
+ Code navigation index up-to-date + +
+
+
+ +
+ +

+ Go to file + +
+ + + + +
    +
  • + + Go to file + +
    • +
  • +
    • +
  • +
    • +
  • +
  • + + + Copy path -class Gordon_etal(StateSpaceModel): - r"""Popular toy example that appeared initially in Gordon et al (1993). +
    • +
  • + + + + Copy permalink + - .. math:: +
    • +
+
+
- X_0 & \sim N(0, 2^2) \\ - X_t & = b X_{t-1} + c X_{t-1}/(1+X_{t-1}^2) + d*\cos(e*(t-1)) + \sigma_X V_t, \quad V_t \sim N(0,1) \\ - Y_t|X_t=x_t & \sim N(a*x_t^2, 1) - """ - default_params = {'a': 0.05, 'b': .5, 'c': 25., 'd': 8., 'e': 1.2, - 'sigmaX': 3.162278} # = sqrt(10) - def PX0(self): - return dists.Normal(scale=2.) - def PX(self, t, xp): - return dists.Normal(loc=self.b * xp + self.c * xp / (1. + xp**2) - + self.d * np.cos(self.e * (t - 1)), - scale=self.sigmaX) - def PY(self, t, xp, x): - return dists.Normal(loc=self.a * x**2) + - def PX(self, t, xp): - return dists.IndepProd(dists.Normal(loc=xp[:, 0], scale=self.sigmaX), - dists.Normal(loc=xp[:, 1], scale=self.sigmaX), - dists.Dirac(loc=xp[:, 0] + xp[:, 2]), - dists.Dirac(loc=xp[:, 1] + xp[:, 3]) - ) + - def PY(self, t, xp, x): - angle = np.arctan(x[:, 3] / x[:, 2]) - angle[x[:, 2] < 0.] += np.pi - return dists.Normal(loc=angle, scale=self.sigmaY) +
+ +
+
+
 
+
+
+
 
+ Cannot retrieve contributors at this time +
+
-class DiscreteCox(StateSpaceModel): - r"""A discrete Cox model. - .. math:: - Y_t | X_t=x_t & \sim Poisson(e^{x_t}) \\ - X_t & = \mu + \phi(X_{t-1}-\mu) + U_t, U_t ~ N(0, sigma^2) \\ - X_0 & \sim N(\mu, \sigma^2/(1-\phi**2)) - """ - default_params = {'mu': 0., 'sigma': 1., 'phi': 0.95} - def PX0(self): - return dists.Normal(loc=self.mu, - scale=self.sigma / np.sqrt(1. - self.phi**2)) + - def PX(self, t, xp): - return dists.Normal(loc=self.mu + self.phi * (xp - self.mu), - scale=self.sigma) - def PY(self, t, xp, x): - return dists.Poisson(rate=np.exp(x)) -class MVStochVol(StateSpaceModel): - """Multivariate stochastic volatility model. - X_0 ~ N(mu,covX) - X_t-mu = F*(X_{t-1}-mu)+U_t U_t~N(0,covX) - Y_t(k) = exp(X_t(k)/2)*V_t(k) for k=1,...,d - V_t ~ N(0,corY) - """ - default_params = {'mu': 0., 'covX': None, 'corY': None, 'F': None} # TODO - def offset(self): - return self.mu - np.dot(self.F, self.mu) - def PX0(self): - return dists.MvNormal(loc=self.mu, cov=self.covX) - def PX(self, t, xp): - return dists.MvNormal(loc=np.dot(xp, self.F.T) + self.offset(), - cov=self.covX) + +
+ +
- def PY(self, t, xp, x): - return dists.MvNormal(scale=np.exp(0.5 * x), cov=self.corY) +
-class ThetaLogistic(StateSpaceModel): - r""" Theta-Logistic state-space model (used in Ecology). + 660 lines (488 sloc) + + 21.3 KB +
- .. math:: +
+ - X_0 & \sim N(0, 1) \\ - X_t & = X_{t-1} + \tau_0 - \tau_1 * \exp(\tau_2 * X_{t-1}) + U_t, \quad U_t \sim N(0, \sigma_X^2) \\ - Y_t & \sim X_t + V_t, \quad V_t \sim N(0, \sigma_Y^2) - """ - default_params = {'tau0':.15, 'tau1':.12, 'tau2':.1, 'sigmaX': 0.47, - 'sigmaY': 0.39} # values from Peters et al (2010) +
+ Raw + Blame +
- def PX0(self): - return dists.Normal(loc=0., scale=1.) +
+ +
+
+
+
+ +
+
+
+
+
+ +
Open in github.dev
+
.
+ + + Open in GitHub Desktop +
+
+
+
+
- def PX(self, t, xp): - return dists.Normal(loc=xp + self.tau0 - self.tau1 * - np.exp(self.tau2 * xp), scale=self.sigmaX) - def PY(self, t, xp, x): - return dists.Normal(loc=x, scale=self.sigmaY) + +
+ + + + + + + + + +
+ + +
+ +
+
+ +
+
+ + + + + +
+
+
+ + + +
- def proposal0(self, data): - return self.PX0().posterior(data[0], sigma=self.sigmaY) + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
# -*- coding: utf-8 -*-
+
r"""
State-space models as Python objects.
Overview
========
This module defines:
1. the `StateSpaceModel` class, which lets you define a state-space model
as a Python object;
2. `FeynmanKac` classes that automatically define the Bootstrap, guided or
auxiliary Feynman-Kac models associated to a given state-space model;
3. several standard state-space models (stochastic volatility,
bearings-only tracking, and so on).
The recommended import is::
from particles import state_space_models as ssms
For more details on state-space models and their properties, see Chapters 2 and
4 of the book.
Defining a state-space model
============================
Consider the following (simplified) stochastic volatility model:
.. math::
Y_t|X_t=x_t &\sim N(0, e^{x_t}) \\
X_t|X_{t-1}=x_{t-1} &\sim N(0, \rho x_{t-1}) \\
X_0 &\sim N(0, \sigma^2 / (1 - \rho^2))
To define this particular model, we sub-class `StateSpaceModel` as follows::
import numpy as np
from particles import distributions as dists
class SimplifiedStochVol(ssms.StateSpaceModel):
default_params = {'sigma': 1., 'rho': 0.8} # optional
def PY(self, t, xp, x): # dist of Y_t at time t, given X_t and X_{t-1}
return dists.Normal(scale=np.exp(x))
def PX(self, t, xp): # dist of X_t at time t, given X_{t-1}
return dists.Normal(loc=self.mu + self.rho * (xp - self.mu),
scale=self.sigma)
def PX0(self): # dist of X_0
return dists.Normal(scale=self.sigma / np.sqrt(1. - self.rho**2))
Then we define a particular object (model) by instantiating this class::
my_stoch_vol_model = SimplifiedStochVol(sigma=0.3, rho=0.9)
Hopefully, the code above is fairly transparent, but here are some noteworthy
details:
* probability distributions are defined through `ProbDist` objects, which
are defined in module `distributions`. Most basic probability
distributions are defined there; see module `distributions` for more details.
* The class above actually defines a **parametric** class of models; in
particular, ``self.sigma`` and ``self.rho`` are **attributes** of
this class that are set when we define object `my_stoch_vol_model`.
Default values for these parameters may be defined in a dictionary called
``default_params``. When this dictionary is defined, any un-defined
parameter will be replaced by its default value::
default_stoch_vol_model = SimplifiedStochVol() # sigma=1., rho=0.8
* There is no need to define a ``__init__()`` method, as it is already
defined by the parent class. (This parent ``__init__()`` simply takes
care of the default parameters, and may be overrided if needed.)
Now that our state-space model is properly defined, what can we do with it?
First, we may simulate states and data from it::
x, y = my_stoch_vol_model.simulate(20)
This generates two lists of length 20: a list of states, X_0, ..., X_{19} and
a list of observations (data-points), Y_0, ..., Y_{19}.
Associated Feynman-Kac models
=============================
Now that our state-space model is defined, we obtain the associated Bootstrap
Feynman-Kac model as follows::
my_fk_model = ssms.Bootstrap(ssm=my_stoch_vol_model, data=y)
That's it! You are now able to run a bootstrap filter for this model::
my_alg = particles.SMC(fk=my_fk_model, N=200)
my_alg.run()
In case you are not clear about what are Feynman-Kac models, and how one may
associate a Feynman-Kac model to a given state-space model, see Chapter 5 of
the book.
To generate a guided Feynman-Kac model, we must provide proposal kernels (that
is, Markov kernels that define how we simulate particles X_t at time t, given
an ancestor X_{t-1})::
class StochVol_with_prop(StochVol):
def proposal0(self, data):
return dists.Normal(scale = self.sigma)
def proposal(t, xp, data): # a silly proposal
return dists.Normal(loc=rho * xp + data[t], scale=self.sigma)
my_second_ssm = StochVol_with_prop(sigma=0.3)
my_better_fk_model = ssms.GuidedPF(ssm=my_second_ssm, data=y)
# then run a SMC as above
Voilà! You have now implemented a guided filter.
Of course, the proposal distribution above does not make much sense; we use it
to illustrate how proposals may be defined. Note in particular that it depends
on ``data``, an object that represents the complete dataset. Hence the proposal
kernel at time ``t`` may depend on y_t but also y_{t-1}, or any other
datapoint.
For auxiliary particle filters (APF), one must in addition specify auxiliary
functions, that is the (log of) functions :math:`\eta_t` that modify the
resampling probabilities (see Section 10.3.3 in the book)::
class StochVol_with_prop_and_aux_func(StochVol_with_prop):
def logeta(self, t, x, data):
"Log of auxiliary function eta_t at time t"
return -(x-data[t])**2
my_third_ssm = StochVol_with_prop_and_aux_func()
apf_fk_model = ssms.AuxiliaryPF(ssm=my_third_ssm, data=y)
Again, this particular choice does not make much sense, and is just given to
show how to define an auxiliary function.
Already implemented state-space models
======================================
This module implements a few basic state-space models that are often used as
numerical examples:
=================== =====================================================
Class Comments
=================== =====================================================
`StochVol` Basic, univariate stochastic volatility model
`StochVolLeverage` Univariate stochastic volatility model with leverage
`MVStochVol` Multivariate stochastic volatility model
`BearingsOnly` Bearings-only tracking
`Gordon_etal` Popular toy model often used as a benchmark
`DiscreteCox` A discrete Cox model (Y_t|X_t is Poisson)
`ThetaLogistic` Theta-logistic model from Population Ecology
=================== =====================================================
.. note::
Linear Gaussian state-space models are implemented in module `kalman`;
similarly hidden Markov models (state-space models with a finite state-space)
are implemented in module `hmm`.
"""
+
from __future__ import division, print_function
+
import numpy as np
+
import particles
from particles import distributions as dists
+
err_msg_missing_cst = """
State-space model %s is missing method upper_bound_log_pt, which provides
log of constant C_t, such that
p(x_t|x_{t-1}) <= C_t
This is required for smoothing algorithms based on rejection
"""
+
class StateSpaceModel(object):
"""Base class for state-space models.
To define a state-space model class, you must sub-class `StateSpaceModel`,
and at least define methods PX0, PX, and PY. Here is an example::
class LinearGauss(StateSpaceModel):
def PX0(self): # The law of X_0
return dists.Normal(scale=self.sigmaX)
def PX(self, t, xp): # The law of X_t conditional on X_{t-1}
return dists.Normal(loc=self.rho * xp, scale=self.sigmaY)
def PY(self, t, xp, x): # the law of Y_t given X_t and X_{t-1}
return dists.Normal(loc=x, scale=self.sigmaY)
These methods return ``ProbDist`` objects, which are defined in the module
`distributions`. The model above is a basic linear Gaussian SSM; it
depends on parameters rho, sigmaX, sigmaY (which are attributes of the
class). To define a particular instance of this class, we do::
a_certain_ssm = LinearGauss(rho=.8, sigmaX=1., sigmaY=.2)
All the attributes that appear in ``PX0``, ``PX`` and ``PY`` must be
initialised in this way. Alternatively, it it possible to define default
values for these parameters, by defining class attribute
``default_params`` to be a dictionary as follows::
class LinearGauss(StateSpaceModel):
default_params = {'rho': .9, 'sigmaX': 1., 'sigmaY': .1}
# rest as above
Optionally, we may also define methods:
* `proposal0(self, data)`: the (data-dependent) proposal dist at time 0
* `proposal(self, t, xp, data)`: the (data-dependent) proposal distribution at
time t, for X_t, conditional on X_{t-1}=xp
* `logeta(self, t, x, data)`: the auxiliary weight function at time t
You need these extra methods to run a guided or auxiliary particle filter.
"""
+
def __init__(self, **kwargs):
if hasattr(self, 'default_params'):
self.__dict__.update(self.default_params)
self.__dict__.update(kwargs)
+
def _error_msg(self, method):
return ('method ' + method + ' not implemented in class%s' %
self.__class__.__name__)
+
@classmethod
def state_container(cls, N, T):
law_X0 = cls().PX0()
dim = law_X0.dim
shape = [N, T]
if dim>1:
shape.append(dim)
return np.empty(shape, dtype=law_X0.dtype)
+
def PX0(self):
"Law of X_0 at time 0"
raise NotImplementedError(self._error_msg('PX0'))
+
def PX(self, t, xp):
" Law of X_t at time t, given X_{t-1} = xp"
raise NotImplementedError(self._error_msg('PX'))
+
def PY(self, t, xp, x):
"""Conditional distribution of Y_t, given the states.
"""
raise NotImplementedError(self._error_msg('PY'))
+
def proposal0(self, data):
raise NotImplementedError(self._error_msg('proposal0'))
+
def proposal(self, t, xp, data):
"""Proposal kernel (to be used in a guided or auxiliary filter).
Parameter
---------
t: int
time
x:
particles
data: list-like
data
"""
raise NotImplementedError(self._error_msg('proposal'))
+
def upper_bound_log_pt(self, t):
"""Upper bound for log of transition density.
See `smoothing`.
"""
raise NotImplementedError(err_msg_missing_cst % self.__class__.__name__)
+
def add_func(self, t, xp, x):
"""Additive function."""
raise NotImplementedError(self._error_msg('add_func'))
+
def simulate_given_x(self, x):
lag_x = [None] + x[:-1]
return [self.PY(t, xp, x).rvs(size=1)
for t, (xp, x) in enumerate(zip(lag_x, x))]
+
def simulate(self, T):
"""Simulate state and observation processes.
Parameters
----------
T: int
processes are simulated from time 0 to time T-1
Returns
-------
x, y: lists
lists of length T
"""
x = []
for t in range(T):
law_x = self.PX0() if t == 0 else self.PX(t, x[-1])
x.append(law_x.rvs(size=1))
y = self.simulate_given_x(x)
return x, y
+
+
class Bootstrap(particles.FeynmanKac):
"""Bootstrap Feynman-Kac formalism of a given state-space model.
Parameters
----------
ssm: `StateSpaceModel` object
the considered state-space model
data: list-like
the data
Returns
-------
`FeynmanKac` object
the Feynman-Kac representation of the bootstrap filter for the
considered state-space model
"""
def __init__(self, ssm=None, data=None):
self.ssm = ssm
self.data = data
self.du = self.ssm.PX0().dim
+
@property
def T(self):
return 0 if self.data is None else len(self.data)
+
def M0(self, N):
return self.ssm.PX0().rvs(size=N)
+
def M(self, t, xp):
return self.ssm.PX(t, xp).rvs(size=xp.shape[0])
+
def logG(self, t, xp, x):
return self.ssm.PY(t, xp, x).logpdf(self.data[t])
+
def Gamma0(self, u):
return self.ssm.PX0().ppf(u)
+
def Gamma(self, t, xp, u):
return self.ssm.PX(t, xp).ppf(u)
+
def logpt(self, t, xp, x):
"""PDF of X_t|X_{t-1}=xp"""
return self.ssm.PX(t, xp).logpdf(x)
+
def upper_bound_trans(self, t):
return self.ssm.upper_bound_log_pt(t)
+
def add_func(self, t, xp, x):
return self.ssm.add_func(t, xp, x)
+
+
class GuidedPF(Bootstrap):
"""Guided filter for a given state-space model.
Parameters
----------
ssm: StateSpaceModel object
the considered state-space model
data: list-like
the data
Returns
-------
FeynmanKac object
the Feynman-Kac representation of the bootstrap filter for the
considered state-space model
Note
----
Argument ssm must implement methods `proposal0` and `proposal`.
"""
+
def M0(self, N):
return self.ssm.proposal0(self.data).rvs(size=N)
+
def M(self, t, xp):
return self.ssm.proposal(t, xp, self.data).rvs(size=xp.shape[0])
+
def logG(self, t, xp, x):
if t == 0:
return (self.ssm.PX0().logpdf(x)
+ self.ssm.PY(0, xp, x).logpdf(self.data[0])
- self.ssm.proposal0(self.data).logpdf(x))
else:
return (self.ssm.PX(t, xp).logpdf(x)
+ self.ssm.PY(t, xp, x).logpdf(self.data[t])
- self.ssm.proposal(t, xp, self.data).logpdf(x))
+
def Gamma0(self, u):
return self.ssm.proposal0(self.data).ppf(u)
+
def Gamma(self, t, xp, u):
return self.ssm.proposal(t, xp, self.data).ppf(u)
+
class APFMixin():
def logeta(self, t, x):
return self.ssm.logeta(t, x, self.data)
+
class AuxiliaryPF(GuidedPF, APFMixin):
"""Auxiliary particle filter for a given state-space model.
Parameters
----------
ssm: StateSpaceModel object
the considered state-space model
data: list-like
the data
Returns
-------
`FeynmanKac` object
the Feynman-Kac representation of the APF (auxiliary particle filter)
for the considered state-space model
Note
----
Argument ssm must implement methods `proposal0`, `proposal` and `logeta`.
"""
+
pass
+
+
class AuxiliaryBootstrap(Bootstrap, APFMixin):
"""Base class for auxiliary bootstrap particle filters
This is an APF, such that the proposal kernel is set to the transition
kernel of the model
"""
+
pass
+
+
################################
# Specific state-space models
################################
+
class StochVol(StateSpaceModel):
r"""Univariate stochastic volatility model.
.. math::
X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\
X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t, \quad U_t\sim N(0,1) \\
Y_t|X_t=x_t & \sim N(0, e^{x_t}) \\
"""
default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178}
# values taken from Pitt & Shephard (1999)
+
def sig0(self):
"""std of X_0"""
return self.sigma / np.sqrt(1. - self.rho**2)
+
def PX0(self):
return dists.Normal(loc=self.mu, scale=self.sig0())
+
def EXt(self, xp):
"""compute E[x_t|x_{t-1}]"""
return (1. - self.rho) * self.mu + self.rho * xp
+
def PX(self, t, xp):
return dists.Normal(loc=self.EXt(xp), scale=self.sigma)
+
def PY(self, t, xp, x):
return dists.Normal(loc=0., scale=np.exp(0.5 * x))
+
def _xhat(self, xst, sig, yt):
return xst + 0.5 * sig**2 * (yt**2 * np.exp(-xst) - 1.)
+
def proposal0(self, data):
# Pitt & Shephard
return dists.Normal(loc=self._xhat(0., self.sig0(), data[0]),
scale=self.sig0())
+
def proposal(self, t, xp, data):
# Pitt & Shephard
return dists.Normal(loc=self._xhat(self.EXt(xp),
self.sigma, data[t]),
scale=self.sigma)
+
def logeta(self, t, x, data):
# Pitt & Shephard
xst = self.EXt(x)
xstmmu = xst - self.mu
xhat = self._xhat(xst, self.sigma, data[t + 1])
xhatmmu = xhat - self.mu
return (0.5 / self.sigma**2 * (xhatmmu**2 - xstmmu**2)
- 0.5 * data[t + 1]**2 * np.exp(-xst) * (1. + xstmmu))
+
+
class StochVolLeverage(StochVol):
r"""Univariate stochastic volatility model with leverage effect.
.. math::
X_0 & \sim N(\mu, \sigma^2/(1-\rho^2)) \\
X_t|X_{t-1}=x_{t-1} & \sim N(\mu + \rho (x-\mu), \sigma^2) \\
Y_t|X_{t-1:t} =x_{t-1:t} & \sim N( s \phi z, s^2 (1-\phi^2) )
with :math:`s=\exp(x_t/2), z = [x_t-\mu-\rho*(x_{t-1}-\mu)]/\sigma`
Note
----
This is equivalent to assuming that the innovations of X_t and Y_t
are correlated, with correlation :math:`\phi`:
.. math::
X_t & = \mu + \rho(X_{t-1}-\mu) + \sigma U_t \\
Y_t & = \exp(X_t/2) * V_t
and :math:`Cor(U_t, V_t) = \phi`
Warning
-------
This class inherits from StochVol, but methods proposal, proposal0
and logeta were constructed for StochVol only, and should not work properly
for this class.
"""
+
default_params = {'mu': -1.02, 'rho': 0.9702, 'sigma': .178, 'phi': 0.}
+
def PY(self, t, xp, x):
# u is realisation of noise U_t, conditional on X_t, X_{t-1}
if t==0:
u = (x - self.mu) / self.sig0()
else:
u = (x - self.EXt(xp)) / self.sigma
std_x = np.exp(0.5 * x)
return dists.Normal(loc=std_x * self.phi * u,
scale=std_x * np.sqrt(1. - self.phi**2))
+
+
class Gordon_etal(StateSpaceModel):
r"""Popular toy example that appeared initially in Gordon et al (1993).
.. math::
X_0 & \sim N(0, 2^2) \\
X_t & = b X_{t-1} + c X_{t-1}/(1+X_{t-1}^2) + d*\cos(e*(t-1)) + \sigma_X V_t, \quad V_t \sim N(0,1) \\
Y_t|X_t=x_t & \sim N(a*x_t^2, 1)
"""
default_params = {'a': 0.05, 'b': .5, 'c': 25., 'd': 8., 'e': 1.2,
'sigmaX': 3.162278} # = sqrt(10)
+
def PX0(self):
return dists.Normal(scale=2.)
+
def PX(self, t, xp):
return dists.Normal(loc=self.b * xp + self.c * xp / (1. + xp**2)
+ self.d * np.cos(self.e * (t - 1)),
scale=self.sigmaX)
+
def PY(self, t, xp, x):
return dists.Normal(loc=self.a * x**2)
+
+
class BearingsOnly(StateSpaceModel):
""" Bearings-only tracking SSM.
"""
default_params = {'sigmaX': 2.e-4, 'sigmaY': 1e-3,
'x0': np.array([3e-3, -3e-3, 1., 1.])}
+
def PX0(self):
return dists.IndepProd(dists.Normal(loc=self.x0[0], scale=self.sigmaX),
dists.Normal(loc=self.x0[1], scale=self.sigmaX),
dists.Dirac(loc=self.x0[2]),
dists.Dirac(loc=self.x0[3])
)
+
def PX(self, t, xp):
return dists.IndepProd(dists.Normal(loc=xp[:, 0], scale=self.sigmaX),
dists.Normal(loc=xp[:, 1], scale=self.sigmaX),
dists.Dirac(loc=xp[:, 0] + xp[:, 2]),
dists.Dirac(loc=xp[:, 1] + xp[:, 3])
)
+
def PY(self, t, xp, x):
angle = np.arctan(x[:, 3] / x[:, 2])
angle[x[:, 2] < 0.] += np.pi
return dists.Normal(loc=angle, scale=self.sigmaY)
+
+
class DiscreteCox(StateSpaceModel):
r"""A discrete Cox model.
.. math::
Y_t | X_t=x_t & \sim Poisson(e^{x_t}) \\
X_t & = \mu + \phi(X_{t-1}-\mu) + U_t, U_t ~ N(0, sigma^2) \\
X_0 & \sim N(\mu, \sigma^2/(1-\phi**2))
"""
default_params = {'mu': 0., 'sigma': 1., 'phi': 0.95}
+
def PX0(self):
return dists.Normal(loc=self.mu,
scale=self.sigma / np.sqrt(1. - self.phi**2))
+
def PX(self, t, xp):
return dists.Normal(loc=self.mu + self.phi * (xp - self.mu),
scale=self.sigma)
+
def PY(self, t, xp, x):
return dists.Poisson(rate=np.exp(x))
+
+
class MVStochVol(StateSpaceModel):
"""Multivariate stochastic volatility model.
X_0 ~ N(mu,covX)
X_t-mu = F*(X_{t-1}-mu)+U_t U_t~N(0,covX)
Y_t(k) = exp(X_t(k)/2)*V_t(k) for k=1,...,d
V_t ~ N(0,corY)
"""
default_params = {'mu': 0., 'covX': None, 'corY': None, 'F': None} # TODO
+
def offset(self):
return self.mu - np.dot(self.F, self.mu)
+
def PX0(self):
return dists.MvNormal(loc=self.mu, cov=self.covX)
+
def PX(self, t, xp):
return dists.MvNormal(loc=np.dot(xp, self.F.T) + self.offset(),
cov=self.covX)
+
def PY(self, t, xp, x):
return dists.MvNormal(scale=np.exp(0.5 * x), cov=self.corY)
+
+
class ThetaLogistic(StateSpaceModel):
r""" Theta-Logistic state-space model (used in Ecology).
.. math::
X_0 & \sim N(0, 1) \\
X_t & = X_{t-1} + \tau_0 - \tau_1 * \exp(\tau_2 * X_{t-1}) + U_t, \quad U_t \sim N(0, \sigma_X^2) \\
Y_t & \sim X_t + V_t, \quad V_t \sim N(0, \sigma_Y^2)
"""
default_params = {'tau0':.15, 'tau1':.12, 'tau2':.1, 'sigmaX': 0.47,
'sigmaY': 0.39} # values from Peters et al (2010)
+
def PX0(self):
return dists.Normal(loc=0., scale=1.)
+
def PX(self, t, xp):
return dists.Normal(loc=xp + self.tau0 - self.tau1 *
np.exp(self.tau2 * xp), scale=self.sigmaX)
+
def PY(self, t, xp, x):
return dists.Normal(loc=x, scale=self.sigmaY)
+
def proposal0(self, data):
return self.PX0().posterior(data[0], sigma=self.sigmaY)
+
def proposal(self, t, xp, data):
return self.PX(t, xp).posterior(data[t], sigma=self.sigmaY)
+
+ + + +
+ +
+ + + + +
+ + +
+ + +
 +
+ + + + +
+ +
+ + +
+ + + + +
+
+ +
+ + + + + + + + + + + + + + + + + + + + + - def proposal(self, t, xp, data): - return self.PX(t, xp).posterior(data[t], sigma=self.sigmaY) - \ No newline at end of file