M/PhxdZddlZddlZddlZddlmZddlmZddl m Z dZ dZ e e zZ d dZGd d eZGd d ZdS)z{ State Space Representation, Kalman Filter, Smoother, and Simulation Smoother Author: Chad Fulton License: Simplified-BSD N)KalmanSmoother)CFASimulationSmoother)toolsc|&t|tjtjfrtj|St|tjjtjjfr|St|d)agTurn `seed` into a `numpy.random.Generator` instance. Parameters ---------- seed : {None, int, Generator, RandomState}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``numpy.random.RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``numpy.random.Generator`` or ``numpy.random.RandomState`` instance then that instance is used. Returns ------- seed : {`numpy.random.Generator`, `numpy.random.RandomState`} Random number generator. Nz9 cannot be used to seed a numpy.random.Generator instance) isinstancenumbersIntegralnpintegerrandom default_rng RandomState Generator ValueError)seeds n/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/statsmodels/tsa/statespace/simulation_smoother.pycheck_random_staters  |z$)92:(FGG|y$$T*** D290")2EF G G= D<<<== =cbeZdZdZgdZ d fd Z d dZ ddZddZ dd Z xZ S)SimulationSmoothera State space representation of a time series process, with Kalman filter and smoother, and with simulation smoother. Parameters ---------- k_endog : {array_like, int} The observed time-series process :math:`y` if array like or the number of variables in the process if an integer. k_states : int The dimension of the unobserved state process. k_posdef : int, optional The dimension of a guaranteed positive definite covariance matrix describing the shocks in the measurement equation. Must be less than or equal to `k_states`. Default is `k_states`. simulation_smooth_results_class : class, optional Default results class to use to save output of simulation smoothing. Default is `SimulationSmoothResults`. If specified, class must extend from `SimulationSmoothResults`. simulation_smoother_classes : dict, optional Dictionary with BLAS prefixes as keys and classes as values. **kwargs Keyword arguments may be used to provide default values for state space matrices, for Kalman filtering options, for Kalman smoothing options, or for Simulation smoothing options. See `Representation`, `KalmanFilter`, and `KalmanSmoother` for more details. )simulate_statesimulate_disturbance simulate_allNc tj|||fi||t}||_||ntj|_i|_dSN)super__init__SimulationSmoothResultssimulation_smooth_results_classrprefix_simulation_smoother_mapcopy _simulators)selfk_endogk_statesk_posdefr!simulation_smoother_classeskwargs __class__s rrzSimulationSmoother.__init__Rs  Xx  +1    + 2.E +/N,+6 ( '5::<< +rc |]d}|r |tz}|r |tz}|r |tz}|dkr1t|du|du|dug }|rt d|j}|S)a Get simulation output bitmask Helper method to get final simulation output bitmask from a set of optional arguments including the bitmask itself and possibly boolean flags. Parameters ---------- simulation_output : int, optional Simulation output bitmask. If this is specified, it is simply returned and the other arguments are ignored. simulate_state : bool, optional Whether or not to include the state in the simulation output. simulate_disturbance : bool, optional Whether or not to include the state and observation disturbances in the simulation output. simulate_all : bool, optional Whether or not to include all simulation output. \*\*kwargs Additional keyword arguments. Present so that calls to this method can use \*\*kwargs without clearing out additional arguments. NrzKInvalid simulation output options: given options would result in no output.)SIMULATION_STATESIMULATION_DISTURBANCESIMULATION_ALLallrsmoother_output)r%simulation_outputrrrr* argument_sets rget_simulation_outputz(SimulationSmoother.get_simulation_outputfs8  $ !  6!%55!# <!%;;! 4!^3!!A%%$'"d*,@D,H D(($$   1$&0111 %)$8!  rFc ||||}|jdi|tj|jd}tj|jd}|jd||jd|f}|r||fz}|S)N random_stateTr#) simulatorsimulater array generated_obsgenerated_stateT) r% nsimulationsr:r7return_simulatorr* simulated_obssimulated_stateouts r _simulatezSimulationSmoother._simulates  |,OOI  $$V$$$!8tDDD (9#<4HHH} }- ,/1  % $C rc4|dd||S)Nrkfs)r2methodnobsr7)simulation_smoother)r%r@r7s rr:zSimulationSmoother.simulators,''!E-95A(CC CrrGc t|}|dkr"|dvrtdt|S|dkrtd|z||j}t |t std|\}}} } } |j|fi|}|d|} |d |j } |d |j }|d |j }|d |j }|d |j }|d|j}|d|j}|j|}||j|| ||||||| || }||||}|S)a Retrieve a simulation smoother for the statespace model. Parameters ---------- simulation_output : int, optional Determines which simulation smoother output is calculated. Default is all (including state and disturbances). method : {'kfs', 'cfa'}, optional Method for simulation smoothing. If `method='kfs'`, then the simulation smoother is based on Kalman filtering and smoothing recursions. If `method='cfa'`, then the simulation smoother is based on the Cholesky Factor Algorithm (CFA) approach. The CFA approach is not applicable to all state space models, but can be faster for the cases in which it is supported. results_class : class, optional Default results class to use to save output of simulation smoothing. Default is `SimulationSmoothResults`. If specified, class must extend from `SimulationSmoothResults`. prefix : str The prefix of the datatype. Usually only used internally. nobs : int The number of observations to simulate. If set to anything other than -1, only simulation will be performed (i.e. simulation smoothing will not be performed), so that only the `generated_obs` and `generated_state` attributes will be available. random_state : {None, int, Generator, RandomState}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``numpy.random.RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``numpy.random.Generator`` or ``numpy.random.RandomState`` instance then that instance is used. **kwargs Additional keyword arguments, used to set the simulation output. See `set_simulation_output` for more details. Returns ------- SimulationSmoothResults cfa)NrrKzTCan only retrieve simulations of the state vector using the CFA simulation smoother.rGzJInvalid simulation smoother method "%s". Valid methods are "kfs" or "cfa".NzInvalid results class provided.r1 filter_methodinversion_methodstability_methodconserve_memory filter_timingloglikelihood_burn tolerancer6)lowerrrr! issubclassr _initialize_smootherr4getrNrOrPrQrRrSrTr" _statespaces)r%r2rH results_classprefixrIr7r*dtypecreate_smoother create_filtercreate_statespacer1rNrOrPrQrRrSrTclsrJresultss rrJz&SimulationSmoother.simulation_smoothers@X U?? 55 "NOOO(.. . u__<>DEFF F   @M-)@AA @>?? ?  % % ' ' I 7H7D67HAA9?AA!**%68IJJ ?D4FGG !::&8&*&;==!::&8&*&;== **%6%)%9;; ?#'#577 #ZZ(<(,(?AAJJ{DN;; 1&9!c  f % +-= 9&8/ t    -&9-9;;;r)NNN)NNNN)NNFr)NrGNNrKN) __name__ __module__ __qualname____doc__simulation_outputsrr4rEr:rJ __classcell__)r+s@rrr0s:4815-1(7;HL+/8!8!8!8!tDH#(&CCCC BGBD)-ffffffffrrceZdZdZddZedZejdZedZejdZedZ e jd Z ed Z e jd Z ed Z ed Z edZ edZedZedZedZ ddZdS)r a" Results from applying the Kalman smoother and/or filter to a state space model. Parameters ---------- model : Representation A Statespace representation simulation_smoother : {{prefix}}SimulationSmoother object The Cython simulation smoother object with which to simulation smooth. random_state : {None, int, Generator, RandomState}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``numpy.random.RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``numpy.random.Generator`` or ``numpy.random.RandomState`` instance then that instance is used. Attributes ---------- model : Representation A Statespace representation dtype : dtype Datatype of representation matrices prefix : str BLAS prefix of representation matrices simulation_output : int Bitmask controlling simulation output. simulate_state : bool Flag for if the state is included in simulation output. simulate_disturbance : bool Flag for if the state and observation disturbances are included in simulation output. simulate_all : bool Flag for if simulation output should include everything. generated_measurement_disturbance : ndarray Measurement disturbance variates used to genereate the observation vector. generated_state_disturbance : ndarray State disturbance variates used to genereate the state and observation vectors. generated_obs : ndarray Generated observation vector produced as a byproduct of simulation smoothing. generated_state : ndarray Generated state vector produced as a byproduct of simulation smoothing. simulated_state : ndarray Simulated state. simulated_measurement_disturbance : ndarray Simulated measurement disturbance. simulated_state_disturbance : ndarray Simulated state disturbance. Nc||_|j|_|j|_||_t ||_d|_d|_d|_d|_ d|_ d|_ d|_ dSr) modelr[r\_simulation_smootherrr7"_generated_measurement_disturbance_generated_state_disturbance_generated_obs_generated_state_simulated_state"_simulated_measurement_disturbance_simulated_state_disturbance)r%rjrJr7s rrz SimulationSmoothResults.__init__Xss l [ $7!.|<<37/,0)" $ $26/,0)))rc|jjSrrkr2r%s rr2z)SimulationSmoothResults.simulation_outpuths(::rc||j_dSrrtr%values rr2z)SimulationSmoothResults.simulation_outputls6;!333rc:t|jtzSrboolr2r-rus rrz&SimulationSmoothResults.simulate_statepsD*-==>>>rczt|r|jtz|_dS|jtz|_dSrrzrws rrz&SimulationSmoothResults.simulate_statetsB ;; P%)%;>N%ND " " "%)%;?O>O%OD " " "rc:t|jtzSrr{r2r.rus rrz,SimulationSmoothResults.simulate_disturbance{sD*-CCDDDrczt|r|jtz|_dS|jtz|_dSrr~rws rrz,SimulationSmoothResults.simulate_disturbancesJ ;; B&)??  " " "&*@)@@  " " "rc:t|jtzSrr{r2r/rus rrz$SimulationSmoothResults.simulate_allsD*^;<<rus rr>z'SimulationSmoothResults.generated_states<  ($&H)9%%%D !$$rch|j%tj|jjd|_|jS)z Random draw of the state vector from its conditional distribution. Notes ----- .. math:: \alpha ~ p(\alpha \mid Y_n) NTr8)rpr r<rkrCrus rrCz'SimulationSmoothResults.simulated_states<  ($&H)9%%%D !$$rch|j%tj|jjd|_|jS)z Random draw of the measurement disturbance vector from its conditional distribution. Notes ----- .. math:: \varepsilon ~ N(\hat \varepsilon, Var(\hat \varepsilon \mid Y_n)) NTr8)rqr r<rk!simulated_measurement_disturbancerus rrz9SimulationSmoothResults.simulated_measurement_disturbances=  2 :68h)K777D 366rch|j%tj|jjd|_|jS)z Random draw of the state disturbanc e vector from its conditional distribution. Notes ----- .. math:: \eta ~ N(\hat \eta, Var(\hat \eta \mid Y_n)) NTr8)rrr r<rksimulated_state_disturbancerus rrz3SimulationSmoothResults.simulated_state_disturbances=  , 402)E111D -00rrKFc x|rd} tj| t||td|A|}|jj|jjz} |d| }|| d}|5d} tj| t||td||}|}|d}|d}d|_d|_ d|_ d|_ d|_ d|_ d|_ d|_| |j} nt!| } |j\} }}}}|rtd|j| |H|jt+j||j | n|j| |H|jt+j||j | n|j| |l| r4|jt+j||j nP|jt+j||j d n|j| |j|dS) ac Perform simulation smoothing Does not return anything, but populates the object's `simulated_*` attributes, as specified by simulation output. Parameters ---------- simulation_output : int, optional Bitmask controlling simulation output. Default is to use the simulation output defined in object initialization. measurement_disturbance_variates : array_like, optional If specified, these are the shocks to the measurement equation, :math:`\varepsilon_t`. If unspecified, these are automatically generated using a pseudo-random number generator. If specified, must be shaped `nsimulations` x `k_endog`, where `k_endog` is the same as in the state space model. state_disturbance_variates : array_like, optional If specified, these are the shocks to the state equation, :math:`\eta_t`. If unspecified, these are automatically generated using a pseudo-random number generator. If specified, must be shaped `nsimulations` x `k_posdef` where `k_posdef` is the same as in the state space model. initial_state_variates : array_like, optional If specified, this is the state vector at time zero, which should be shaped (`k_states` x 1), where `k_states` is the same as in the state space model. If unspecified, but the model has been initialized, then that initialization is used. initial_state_variates : array_likes, optional Random values to use as initial state variates. Usually only specified if results are to be replicated (e.g. to enforce a seed) or for testing. If not specified, random variates are drawn. pretransformed_measurement_disturbance_variates : bool, optional If `measurement_disturbance_variates` is provided, this flag indicates whether it should be directly used as the shocks. If False, then it is assumed to contain draws from the standard Normal distribution that must be transformed using the `obs_cov` covariance matrix. Default is False. pretransformed_state_disturbance_variates : bool, optional If `state_disturbance_variates` is provided, this flag indicates whether it should be directly used as the shocks. If False, then it is assumed to contain draws from the standard Normal distribution that must be transformed using the `state_cov` covariance matrix. Default is False. pretransformed_initial_state_variates : bool, optional If `initial_state_variates` is provided, this flag indicates whether it should be directly used as the initial_state. If False, then it is assumed to contain draws from the standard Normal distribution that must be transformed using the `initial_state_cov` covariance matrix. Default is False. random_state : {None, int, Generator, RandomState}, optional If `seed` is None (or `np.random`), the `numpy.random.RandomState` singleton is used. If `seed` is an int, a new ``numpy.random.RandomState`` instance is used, seeded with `seed`. If `seed` is already a ``numpy.random.Generator`` or ``numpy.random.RandomState`` instance then that instance is used. disturbance_variates : bool, optional Deprecated, please use pretransformed_measurement_shocks and pretransformed_state_shocks instead. .. deprecated:: 0.14.0 Use ``measurement_disturbance_variates`` and ``state_disturbance_variates`` as replacements. pretransformed : bool, optional Deprecated, please use pretransformed_measurement_shocks and pretransformed_state_shocks instead. .. deprecated:: 0.14.0 Use ``pretransformed_measurement_disturbance_variates`` and ``pretransformed_state_disturbance_variates`` as replacements. Nz~`disturbance_variates` keyword is deprecated, use `measurement_disturbance_variates` and `state_disturbance_variates` instead.zzCannot use `disturbance_variates` in combination with `measurement_disturbance_variates` or `state_disturbance_variates`.z`pretransformed` keyword is deprecated, use `pretransformed_measurement_disturbance_variates` and `pretransformed_state_disturbance_variates` instead.zCannot use `pretransformed` in combination with `pretransformed_measurement_disturbance_variates` or `pretransformed_state_disturbance_variates`.FzThe simulation smoother currently cannot replace the underlying _{{prefix}}Representation model object if it changes (which happens e.g. if the dimensions of some system matrices change.)r[)r\)pretransformed)warningswarn FutureWarningrravelrjrIr&rlrmrornrprqrrr7rrW_initialize_staterk$set_measurement_disturbance_variatesr r<r\%draw_measurement_disturbance_variatesset_state_disturbance_variatesdraw_state_disturbance_variatesset_initial_stateset_initial_state_variatesdraw_initial_state_variatesr;)r%r2disturbance_variatesrrinitial_state_variatesr/pretransformed_measurement_disturbance_variates)pretransformed_state_disturbance_variates%pretransformed_initial_state_variatesr7msgn_mdsr[r\r]r^r_s rr;z SimulationSmoothResults.simulate#sl +C ; 4 <8= 537/,0) $" $ $26/,0)  ,LL-l;;L J + + - - I 7H  LKLL L $$F$333 , 7  % J J9#z++++0577N K      % K K    & 1  % D D34:FFFLLNNH E      % E E    " -4 );;H34:FFF)DDH34:FFF#(E  % A A    !**+<=====rr) rKNNNNNNNFN)rbrcrdrerpropertyr2setterrrrrrr=r>rCrrr;r9rrr r !s44l1111 ;;X;<<<??X?PPP EEXE BB! B==X=NNN 77X7.11X1,##X#&%%X%$%%X%"77X7&11X1&*,&*26,0(, $AE;?7<"D>D>D>D>D>D>rr r)rer rnumpyr kalman_smootherrcfa_simulation_smootherrrr-r.r/rrr r9rrrs++++++::::::-- ====2nnnnnnnnbF>F>F>F>F>F>F>F>F>F>r