M/Ph3xdZddlmZddlmZddlZddlZddlm Z m Z m Z ddl m Z mZddlmZerejZn ejjZgdZd Z d$d Zd%d Zd&dZd&dZd'dZd(dZd(dZd(dZd)dZejejdZdZdZ d*dZ!d*dZ"dZ#d+dZ$e ejZ%e%ddge%&d ge%&d!gGd"d#Z'dS),aARMA process and estimation with scipy.signal.lfilter Notes ----- * written without textbook, works but not sure about everything briefly checked and it looks to be standard least squares, see below * theoretical autocorrelation function of general ARMA Done, relatively easy to guess solution, time consuming to get theoretical test cases, example file contains explicit formulas for acovf of MA(1), MA(2) and ARMA(1,1) Properties: Judge, ... (1985): The Theory and Practise of Econometrics Author: josefpktd License: BSD )NP_LT_2)AppenderN)linalgoptimizesignal) Docstringremove_parameters) array_like) arma_acf arma_acovfarma_generate_samplearma_impulse_responsearma2ararma2ma deconvolve lpol2index index2lpolzThe model's autoregressive parameters (ar) indicate that the process is non-stationary. arma_acovf can only be used with stationary processes. c&|tjjn|}tj|dkr|g}|rrt |}||xx|z cc<t |}t dgt|z}t |dd||<t |}nAt |}t t dgtj|z}|||z} tj ||| ||S)a Simulate data from an ARMA. Parameters ---------- ar : array_like The coefficient for autoregressive lag polynomial, including zero lag. ma : array_like The coefficient for moving-average lag polynomial, including zero lag. nsample : int or tuple of ints If nsample is an integer, then this creates a 1d timeseries of length size. If nsample is a tuple, creates a len(nsample) dimensional time series where time is indexed along the input variable ``axis``. All series are unless ``distrvs`` generates dependent data. scale : float The standard deviation of noise. distrvs : function, random number generator A function that generates the random numbers, and takes ``size`` as argument. The default is np.random.standard_normal. axis : int See nsample for details. burnin : int Number of observation at the beginning of the sample to drop. Used to reduce dependence on initial values. Returns ------- ndarray Random sample(s) from an ARMA process. Notes ----- As mentioned above, both the AR and MA components should include the coefficient on the zero-lag. This is typically 1. Further, due to the conventions used in signal processing used in signal.lfilter vs. conventions in statistics for ARMA processes, the AR parameters should have the opposite sign of what you might expect. See the examples below. Examples -------- >>> import numpy as np >>> np.random.seed(12345) >>> arparams = np.array([.75, -.25]) >>> maparams = np.array([.65, .35]) >>> ar = np.r_[1, -arparams] # add zero-lag and negate >>> ma = np.r_[1, maparams] # add zero-lag >>> y = sm.tsa.arma_generate_sample(ar, ma, 250) >>> model = sm.tsa.ARIMA(y, (2, 0, 2), trend='n').fit(disp=0) >>> model.params array([ 0.79044189, -0.23140636, 0.70072904, 0.40608028]) Nr)size)axis) nprandomstandard_normalndimlisttupleslicelenrlfilter) armansamplescaledistrvsrburninnewsizefsliceetas ]/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/statsmodels/tsa/arima_process.pyr r 6sn,3?bi''G ww1) 9w--  ..++W-VT400t v..d }rww'7'7788 ''w''' 'C >"b#D 1 1 1& 99 c |Ltjtj|tj|tj|}t|dz }t|dz }t ||dz}|jdkrt d||cxkrdkr nntj||}||d<|S|dkrPtjtjtj |dkrt tt|||} tj||f|} tj|df|} tj||} || d|dz<t|D]} | d| dzddd| | d| dzf<| | d|| z fxx| | dz|z cc<|tj || |dz| dt |dz| z dz| | <tjt |||} tj| | dddf|d|<n,#tjj$rt twxYw||krct#jdg||d|ddd}t#jdg|tj||z ||d||d<|d|S) a[ Theoretical autocovariances of stationary ARMA processes Parameters ---------- ar : array_like, 1d The coefficients for autoregressive lag polynomial, including zero lag. ma : array_like, 1d The coefficients for moving-average lag polynomial, including zero lag. nobs : int The number of terms (lags plus zero lag) to include in returned acovf. sigma2 : float Variance of the innovation term. Returns ------- ndarray The autocovariance of ARMA process given by ar, ma. See Also -------- arma_acf : Autocorrelation function for ARMA processes. acovf : Sample autocovariance estimation. References ---------- .. [*] Brockwell, Peter J., and Richard A. Davis. 2009. Time Series: Theory and Methods. 2nd ed. 1991. New York, NY: Springer. Nrrz'Must have positive innovation variance.)dtypelags)zi)r common_typearrayrmaxreal ValueErrorzerosabsrootsNONSTATIONARY_ERRORrrangedotrsolve LinAlgErrorrlfilticr )r!r"nobssigma2r.pqmout ma_coeffsAbtmp_arkacovfr2s r*r r s"< }rx||RXb\\28F;K;KLL B! A B! A Aq A A {QBCCC A{{{{{{{{{ht5)))A Q26"&"..//144,---BQ'''I !Qu%%%A !Qu%%%A Xau % % %FF7QU7O 1XXPP AE+DDbD1!YAY, !QQY,61q5A+..r!a!e)}i8M#q1uqy1:M:M8M.NOOO! HSq\\ / / /E.IOOAq))!!!Q$/bqb 9 ...,---. axx ^QCU3A3Z"%5 6 6N CRXdQhe444    abb  $<s /I00)Jc:t|||}||dz S)a Theoretical autocorrelation function of an ARMA process. Parameters ---------- ar : array_like Coefficients for autoregressive lag polynomial, including zero lag. ma : array_like Coefficients for moving-average lag polynomial, including zero lag. lags : int The number of terms (lags plus zero lag) to include in returned acf. Returns ------- ndarray The autocorrelations of ARMA process given by ar and ma. See Also -------- arma_acovf : Autocovariances from ARMA processes. acf : Sample autocorrelation function estimation. acovf : Sample autocovariance function estimation. r)r )r!r"r0rLs r*r r s$0 r2t $ $E 58 r+c(tj|}t|||dz}d|d<td|dzD]O}|d|}t jt j|dd|ddd||dz <P|S)ay Theoretical partial autocorrelation function of an ARMA process. Parameters ---------- ar : array_like, 1d The coefficients for autoregressive lag polynomial, including zero lag. ma : array_like, 1d The coefficients for moving-average lag polynomial, including zero lag. lags : int The number of terms (lags plus zero lag) to include in returned pacf. Returns ------- ndarrray The partial autocorrelation of ARMA process given by ar and ma. Notes ----- Solves yule-walker equation for each lag order up to nobs lags. not tested/checked yet rr/?rNr1)rr8r r<rr>toeplitz)r!r"r0apacfacovrKrs r* arma_pacfrUs2 HTNNE B * * *DE!H 1dQh  HH !H|FOAcrcF$;$;QqrrUCCBGa!e Lr+c6tj||||\}}tj|dztjdtjzz }tjtj|rddl}|j dtd||fS)a0 Periodogram for ARMA process given by lag-polynomials ar and ma. Parameters ---------- ar : array_like The autoregressive lag-polynomial with leading 1 and lhs sign. ma : array_like The moving average lag-polynomial with leading 1. worN : {None, int}, optional An option for scipy.signal.freqz (read "w or N"). If None, then compute at 512 frequencies around the unit circle. If a single integer, the compute at that many frequencies. Otherwise, compute the response at frequencies given in worN. whole : {0,1}, optional An options for scipy.signal.freqz/ Normally, frequencies are computed from 0 to pi (upper-half of unit-circle. If whole is non-zero compute frequencies from 0 to 2*pi. Returns ------- w : ndarray The frequencies. sd : ndarray The periodogram, also known as the spectral density. Notes ----- Normalization ? This uses signal.freqz, which does not use fft. There is a fft version somewhere. )worNwholerPrNz7Warning: nan in frequency response h, maybe a unit root) stacklevel) rfreqzrr9sqrtpianyisnanwarningswarnRuntimeWarning)r!r"rWrXwhsdr_s r*arma_periodogramre sD <BT 7 7 7DAq a"'!be),, ,B vbhqkk  H     b5Lr+dc`tj|}d|d<tj|||S)al Compute the impulse response function (MA representation) for ARMA process. Parameters ---------- ar : array_like, 1d The auto regressive lag polynomial. ma : array_like, 1d The moving average lag polynomial. leads : int The number of observations to calculate. Returns ------- ndarray The impulse response function with nobs elements. Notes ----- This is the same as finding the MA representation of an ARMA(p,q). By reversing the role of ar and ma in the function arguments, the returned result is the AR representation of an ARMA(p,q), i.e ma_representation = arma_impulse_response(ar, ma, leads=100) ar_representation = arma_impulse_response(ma, ar, leads=100) Fully tested against matlab Examples -------- AR(1) >>> arma_impulse_response([1.0, -0.8], [1.], leads=10) array([ 1. , 0.8 , 0.64 , 0.512 , 0.4096 , 0.32768 , 0.262144 , 0.2097152 , 0.16777216, 0.13421773]) this is the same as >>> 0.8**np.arange(10) array([ 1. , 0.8 , 0.64 , 0.512 , 0.4096 , 0.32768 , 0.262144 , 0.2097152 , 0.16777216, 0.13421773]) MA(2) >>> arma_impulse_response([1.0], [1., 0.5, 0.2], leads=10) array([ 1. , 0.5, 0.2, 0. , 0. , 0. , 0. , 0. , 0. , 0. ]) ARMA(1,2) >>> arma_impulse_response([1.0, -0.8], [1., 0.5, 0.2], leads=10) array([ 1. , 1.3 , 1.24 , 0.992 , 0.7936 , 0.63488 , 0.507904 , 0.4063232 , 0.32505856, 0.26004685]) rOr)rr8rr )r!r"leadsimpulses r*rr=s/lhuooGGAJ >"b' * **r+c&t|||S)a A finite-lag approximate MA representation of an ARMA process. Parameters ---------- ar : ndarray The auto regressive lag polynomial. ma : ndarray The moving average lag polynomial. lags : int The number of coefficients to calculate. Returns ------- ndarray The coefficients of AR lag polynomial with nobs elements. Notes ----- Equivalent to ``arma_impulse_response(ma, ar, leads=100)`` rhrr!r"r0s r*rrx, !Rt 4 4 44r+c&t|||S)a A finite-lag AR approximation of an ARMA process. Parameters ---------- ar : array_like The auto regressive lag polynomial. ma : array_like The moving average lag polynomial. lags : int The number of coefficients to calculate. Returns ------- ndarray The coefficients of AR lag polynomial with nobs elements. Notes ----- Equivalent to ``arma_impulse_response(ma, ar, leads=100)`` rkrlrms r*rrrnr+r!cfd}|Btjdtjdz ztj|dz f}n|}t j|||d}tj|d} tjd| ddz ff} tjd| dz df} | | |fS)a Find arma approximation to ar process. This finds the ARMA(p,q) coefficients that minimize the integrated squared difference between the impulse_response functions (MA representation) of the AR and the ARMA process. This does not check whether the MA lag polynomial of the ARMA process is invertible, neither does it check the roots of the AR lag polynomial. Parameters ---------- ar_des : array_like The coefficients of original AR lag polynomial, including lag zero. p : int The length of desired AR lag polynomials. q : int The length of desired MA lag polynomials. n : int The number of terms of the impulse_response function to include in the objective function for the approximation. mse : str, 'ar' Not used. start : ndarray Initial values to use when finding the approximation. Returns ------- ar_app : ndarray The coefficients of the AR lag polynomials of the approximation. ma_app : ndarray The coefficients of the MA lag polynomials of the approximation. res : tuple The result of optimize.leastsq. Notes ----- Extension is possible if we want to match autocovariance instead of impulse response function. ctjd|ddz ftjd|dz df}}t||}||z S)Nr)rr_r)armaar_desr!r" ar_approxnrCs r* msear_errzar2arma..msear_errsXq$wQw-'("%4A=0@*AB)"b!44  !!r+Ngri)maxfevr)rrsonesr8rleastsq atleast_1d) rurCrDrwmsestartrxarma0resarma_appar_appma_apps ` ` r*ar2armars\""""""  }dRWQU^^+RXa!e__<=  9eVD A A AC}SV$$HeAx!a%(() +F U1hq1uww'' (F 63 r+)r!r"ctj5tjdtt |d}dddn #1swxYwYt j|d}||}||fS)a4 Remove zeros from lag polynomial Parameters ---------- ar : array_like coefficients of lag polynomial Returns ------- coeffs : ndarray non-zero coefficients of lag polynomial index : ndarray index (lags) of lag polynomial with non-zero elements ignorer!Nr)r_catch_warnings simplefilterComplexWarningr rnonzero)r!indexcoeffss r*rrs  " """h777 D ! !""""""""""""""" JrNN1 E YF 5=s+A  AAc\t|}tj|dz}|||<|S)a3 Expand coefficients to lag poly Parameters ---------- coeffs : ndarray non-zero coefficients of lag polynomial index : ndarray index (lags) of lag polynomial with non-zero elements Returns ------- ar : array_like coefficients of lag polynomial r)r5rr8)rrrwr!s r*rrs. E A !a%BBuI Ir+cddlm}tj|}tj|||z||dzz ||z S)a@MA representation of fractional integration .. math:: (1-L)^{-d} for |d|<0.5 or |d|<1 (?) Parameters ---------- d : float fractional power n : int number of terms to calculate, including lag zero Returns ------- ma : ndarray coefficients of lag polynomial rgammalnr scipy.specialrrarangeexp)drwrjs r* lpol_fimars]$&%%%%% ! A 6''!a%..771q5>>1GGAJJ> ? ??r+cddlm}tj|}tj|| |z||dzz || z  }d|d<|S)aAR representation of fractional integration .. math:: (1-L)^{d} for |d|<0.5 or |d|<1 (?) Parameters ---------- d : float fractional power n : int number of terms to calculate, including lag zero Returns ------- ar : ndarray coefficients of lag polynomial Notes: first coefficient is 1, negative signs except for first term, ar(L)*x_t rrrr)rrwrrr!s r* lpol_fiarr3sq,&%%%%% ! A &!a771q5>>1GGQBKK? @ @ @B BqE Ir+c$dgdg|dz zzdgzS)zreturn coefficients for seasonal difference (1-L^s) just a trivial convenience function Parameters ---------- s : int number of periods in season Returns ------- sdiff : list, length s+1 rrr1)ss r* lpol_sdiffrRs" 3!A " %%r+c 0tj|}tj|}t|}t|}||kr|g}|}n|||z dz}tj|t}d|d<t j|||}t j||d}t|t|krEtj|tjt|t|z f}||z }||fS)aDeconvolves divisor out of signal, division of polynomials for n terms calculates den^{-1} * num Parameters ---------- num : array_like signal or lag polynomial denom : array_like coefficients of lag polynomial (linear filter) n : None or int number of terms of quotient Returns ------- quot : ndarray quotient or filtered series rem : ndarray remainder Notes ----- If num is a time series, then this applies the linear filter den^{-1}. If both num and den are both lag polynomials, then this calculates the quotient polynomial for n terms and also returns the remainder. This is copied from scipy.signal.signaltools and added n as optional parameter. Nrrfull)mode) rr|rr8floatrr convolve concatenate) numdenrwNDquotreminput num_approxs r*rrcs< -  C -  C CA CA1uu 9A AE""a~c3.._S$V<<< s88c*oo % %.#rxJ#c((0J'K'K!LMMCJ 9r+r"NotesExamplesc&eZdZdZddZeddZeddZed dZdZ d Z d Z e e ejgd d d Ze e ejd dgd dZe e ejd dgd dZe e ejgdd dZe e ejd dgd dZe e ejd dgd dZe e ejd dgd dZedZedZedZedZd!dZe e e! d"dZ"dS)# ArmaProcessaF Theoretical properties of an ARMA process for specified lag-polynomials. Parameters ---------- ar : array_like Coefficient for autoregressive lag polynomial, including zero lag. Must be entered using the signs from the lag polynomial representation. See the notes for more information about the sign. ma : array_like Coefficient for moving-average lag polynomial, including zero lag. nobs : int, optional Length of simulated time series. Used, for example, if a sample is generated. See example. Notes ----- Both the AR and MA components must include the coefficient on the zero-lag. In almost all cases these values should be 1. Further, due to using the lag-polynomial representation, the AR parameters should have the opposite sign of what one would write in the ARMA representation. See the examples below. The ARMA(p,q) process is described by .. math:: y_{t}=\phi_{1}y_{t-1}+\ldots+\phi_{p}y_{t-p}+\theta_{1}\epsilon_{t-1} +\ldots+\theta_{q}\epsilon_{t-q}+\epsilon_{t} and the parameterization used in this function uses the lag-polynomial representation, .. math:: \left(1-\phi_{1}L-\ldots-\phi_{p}L^{p}\right)y_{t} = \left(1+\theta_{1}L+\ldots+\theta_{q}L^{q}\right)\epsilon_{t} Examples -------- ARMA(2,2) with AR coefficients 0.75 and -0.25, and MA coefficients 0.65 and 0.35 >>> import statsmodels.api as sm >>> import numpy as np >>> np.random.seed(12345) >>> arparams = np.array([.75, -.25]) >>> maparams = np.array([.65, .35]) >>> ar = np.r_[1, -arparams] # add zero-lag and negate >>> ma = np.r_[1, maparams] # add zero-lag >>> arma_process = sm.tsa.ArmaProcess(ar, ma) >>> arma_process.isstationary True >>> arma_process.isinvertible True >>> arma_process.arroots array([1.5-1.32287566j, 1.5+1.32287566j]) >>> y = arma_process.generate_sample(250) >>> model = sm.tsa.ARIMA(y, (2, 0, 2), trend='n').fit(disp=0) >>> model.params array([ 0.79044189, -0.23140636, 0.70072904, 0.40608028]) The same ARMA(2,2) Using the from_coeffs class method >>> arma_process = sm.tsa.ArmaProcess.from_coeffs(arparams, maparams) >>> arma_process.arroots array([1.5-1.32287566j, 1.5+1.32287566j]) NrfcD|tjdg}|tjdg}tj5tjdt t |d|_t |d|_dddn #1swxYwY|jdd |_ |jdd|_ tj |j|_ tj |j|_||_dS)NrOrr!r"r)rr4r_rrrr r!r"arcoefsmacoefs polynomial PolynomialarpolymapolyrA)selfr!r"rAs r*__init__zArmaProcess.__init__s& :3%B :3%B  $ & & + +  !(N ; ; ; T**DG T**DG + + + + + + + + + + + + + + + | wqrr{ m..tw77 m..tw77  sABBBc|Vt|rGtjjj|}|jdd|jdz }ng}|Vt|rGtjjj|}|jdd|jdz }ng}|tjd|ftjd|f|S)a Create ArmaProcess from AR and MA polynomial roots. Parameters ---------- maroots : array_like, optional Roots for the MA polynomial 1 + theta_1*z + theta_2*z^2 + ..... + theta_n*z^n arroots : array_like, optional Roots for the AR polynomial 1 - phi_1*z - phi_2*z^2 - ..... - phi_n*z^n nobs : int, optional Length of simulated time series. Used, for example, if a sample is generated. Returns ------- ArmaProcess Class instance initialized with arcoefs and macoefs. Examples -------- >>> arroots = [.75, -.25] >>> maroots = [.65, .35] >>> arma_process = sm.tsa.ArmaProcess.from_roots(arroots, maroots) >>> arma_process.isstationary True >>> arma_process.isinvertible True NrrrA)rrrr fromrootscoefrs)clsmarootsarrootsrArrrrs r* from_rootszArmaProcess.from_rootss@  3w<< ]-8BB7KKFk!""o A6GGG  3w<< ]-8BB7KKFk!""o A6GGGs25G$beAwJ&7dCCCCr+c|gn|}|gn|}|tjdtj| ftjdtj|f|S)a  Create ArmaProcess from an ARMA representation. Parameters ---------- arcoefs : array_like Coefficient for autoregressive lag polynomial, not including zero lag. The sign is inverted to conform to the usual time series representation of an ARMA process in statistics. See the class docstring for more information. macoefs : array_like Coefficient for moving-average lag polynomial, excluding zero lag. nobs : int, optional Length of simulated time series. Used, for example, if a sample is generated. Returns ------- ArmaProcess Class instance initialized with arcoefs and macoefs. Examples -------- >>> arparams = [.75, -.25] >>> maparams = [.65, .35] >>> arma_process = sm.tsa.ArmaProcess.from_coeffs(ar, ma) >>> arma_process.isstationary True >>> arma_process.isinvertible True Nrr)rrsasarray)rrrrAs r* from_coeffszArmaProcess.from_coeffs spB ""W""Ws E!bj)))) * E!RZ((( )    r+cD|p|j}||j|j|S)a  Create an ArmaProcess from the results of an ARIMA estimation. Parameters ---------- model_results : ARIMAResults instance A fitted model. nobs : int, optional If None, nobs is taken from the results. Returns ------- ArmaProcess Class instance initialized from model_results. See Also -------- statsmodels.tsa.arima.model.ARIMA The models class used to create the ArmaProcess r)rApolynomial_reduced_arpolynomial_reduced_ma)r model_resultsrAs r*from_estimationzArmaProcess.from_estimationIs9,)})s  /  /    r+ct||jr)|j|jzj}|j|jzj}nw |\}}t j|}t j|}|j|zj}|j|zj}n#tdxYw||||j S)NzOther type is not a valid typer) isinstance __class__rrrrrr TypeErrorrA)rothr!r"arothmaoth arpolyoth mapolyoths r*__mul__zArmaProcess.__mul__fs c4> * * B+ *0B+ *0BB B" uM44U;; M44U;; kI-3kI-3 B @AAA~~b"49~555s A!B""B3c d}||j|j|jt t |S)Nz&ArmaProcess({0}, {1}, nobs={2}) at {3})formatr!tolistr"rAhexid)rmsgs r*__repr__zArmaProcess.__repr__usL6zz GNN  dgnn.. 3r$xx==   r+cd|j|jS)NzArmaProcess AR: {} MA: {})rr!rr"rs r*__str__zArmaProcess.__str__{s7,33 GNN  dgnn..   r+)r!r"rBcL|p|j}t|j|j|S)Nr)rAr r!r"rrAs r*rLzArmaProcess.acovfs' ty$'476666r+r!r"cL|p|j}t|j|j|SNr/)rAr r!r"rr0s r*acfzArmaProcess.acfs' tyt4444r+cL|p|j}t|j|j|Sr)rArUr!r"rs r*pacfzArmaProcess.pacfs' ty$'5555r+)r!r"rWrXcL|p|j}t|j|j|S)N)rW)rArer!r"rs r* periodogramzArmaProcess.periodograms)  tyt<<<>$'5ty>AA A*$ $r+rOrc Bt|j|j|||||S)N)rr&)r r!r")rr#r$r%rr&s r*generate_samplezArmaProcess.generate_samples.$ GTWgugD    r+)NNrfN)F)rfrONrr)#__name__ __module__ __qualname____doc__r classmethodrrrrrrrr r rLr rrUrrerrrrrpropertyrrrrrstr_generate_sample_docrrr+r*rrs\BBJ    -D-D-D[-D^& & & [& P   [ 8 6 6 6      X 24J4J4JKKLL777ML7X 04,??@@555A@5X 1D$<@@AA666BA6X  $&C&C&C   ===  =X 5 =d|LLMMDDDNMDX$>>??444@?4X$>>??444@?4##X###X#  X   X !%!%!%!%FXcc&''((CD   )(   r+r)rNrr)r,rN)r,)Nr)rf)rpr!N)rpr)(rstatsmodels.compat.numpyrstatsmodels.compat.pandasrr_numpyrscipyrrrstatsmodels.tools.docstringrr statsmodels.tools.validationr r exceptions__all__r;r r r rUrerrrr _arma_docsrrrrrrr replace_blockrrr+r*rs$-,,,,,......**********DDDDDDDD333333 2&NN]1N   <=G:G:G:G:TKKKK\8    F----`8+8+8+8+v5555255554;;;;|O7? ; ; 0,@@@@2>&&&"////d!y!5!=>>&&d|444""7B///"":r222] ] ] ] ] ] ] ] ] ] r+