├── results
├── README.md
├── 1.png
├── 2.png
├── 3.png
└── 4.png
├── README.md
├── accuracy_test.py
├── summaries.py
├── core.py
└── MAVAR.ipynb
/results/README.md:
--------------------------------------------------------------------------------
1 | this Directory display some results
2 |
--------------------------------------------------------------------------------
/results/1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yudai-il/Multivariate-Markov-Switching-Regressions/HEAD/results/1.png
--------------------------------------------------------------------------------
/results/2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yudai-il/Multivariate-Markov-Switching-Regressions/HEAD/results/2.png
--------------------------------------------------------------------------------
/results/3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yudai-il/Multivariate-Markov-Switching-Regressions/HEAD/results/3.png
--------------------------------------------------------------------------------
/results/4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/yudai-il/Multivariate-Markov-Switching-Regressions/HEAD/results/4.png
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | ### Multivariate Markov-Switching Models Regressions Framework
2 | This Directory contains Multivariate Markov-Switching Models Regressions Framework Written in Python
3 |
4 | Reference From "
5 | Bellone B. Classical Estimationof Multivariate Markov-Switching Models using MSVARlib[J]. Econometrics, 2005.
6 | "
7 |
8 | You can use This Package to build a Statistical arbitrage Strategy using MS-VECM (Markov-Switching Vector Error correction Models.)
9 |
10 | or Do some empirical Study of Asymmetric effects using MS-VAR( Markov-Switching Vector AutoRegression)
11 |
12 |
13 | Some Results Display Here:
14 |
15 | Time variant impact of M2 on Stocks Market:
16 |
17 | 
18 |
19 |
20 | impluse response :
21 |
22 | 
23 |
24 |
25 |
26 | Time variant impact of M2 on substantial economy:
27 |
28 | 
29 |
30 | impluse response :
31 |
32 | 
33 |
34 |
35 | For Detail Usage can Go To
36 | This Page
37 |
38 | An empirical Study based on China's macroeconomic and Financial Data.
39 |
40 | On the topic of 「Asymmetric effects of M2 on Stocks Market and substantial economy」.(Project during 2018)
41 |
42 |
43 |
44 | """ Notice：
45 | This Python Package are Based On the Gauss Language witten by Benoit BELLONE (2004)
46 |
47 | [The GAUSS programs available on the website http://bellone.ensae.net6 are written
48 | and copyrighted c 2004 by Benoit BELLONE, all rights reserved. They can be run on
49 | Gauss 3.2 or upper versions and should be OX-Gauss compliant, thanks to the routine
50 | M@ximize developped by Laurent and Urbain (2005)7. The code is licensed gratis to all
51 | third parties under the terms of this paragraph. Copying and distribution of the files
52 | in this archive is unrestricted if and only if the files are not modified. Modification of
53 | the files is encouraged, but the distribution of modifications of the code in this archive
54 | is unrestricted only if you meet the following conditions: modified files must carry a
55 | prominent notice stating
56 | (i) the original author and date,
57 | (ii) the new author and the date of release of the modification,
58 | (iii) that there is no warrantee for the code, and
59 | (iv) that the work is licensed at no charge to all parties.
60 | If you use the code extensively in your research, you are requested to provide appropriate
61 | attribution and thanks to the author of the code. No representation is made or implied
62 | as to the accuracy or completeness of the programs which may indeed contain bugs or
63 | errors unknown to the author. Benoit Bellone takes no responsibility for results produced
64 | by MSVARlib programs which are used entirely at the reader’s risk. This package is by
65 | no means finished yet, a enhancement “to do list” remains open. If you plan to extend
66 | the library, find any problems or have suggestions for improvement, contact the author.]"""
67 |
--------------------------------------------------------------------------------
/accuracy_test.py:
--------------------------------------------------------------------------------
1 | import pandas as pd
2 | import numpy as np
3 | # from.tools import *
4 | from Multivariate_Markov_Switching_Model.tools import *
5 | from Multivariate_Markov_Switching_Model.core import *
6 | from Multivariate_Markov_Switching_Model.tools import _2dim
7 | import numpy as np
8 | import os
9 | # os.chdir("Multivariate_Markov_Switching_Model")
10 |
11 |
12 | """
13 | test A
14 | """
15 |
16 |
17 | data = []
18 |
19 | with open("Multivariate_Markov_Switching_Model/test_data/MSVARUN.txt") as f:
20 | for _ in f.readlines():
21 | data.append(_.strip().split("\t"))
22 | data = pd.DataFrame(data)
23 |
24 | s = data.set_index([1,0]).replace(".",np.nan)[2].astype(float).rename_axis(['year','month'])
25 |
26 | apr = data.set_index([1,0]).replace(".",np.nan)[3].astype(float).rename_axis(['year','month'])
27 |
28 | apriori = apr[apr.index.get_loc(("1967","7")):apr.index.get_loc(("2004","3"))].values
29 |
30 | k_lag = 2
31 |
32 | _ = np.log(s).diff(k_lag)*100
33 |
34 | s = _[_.index.get_loc(("1967","2"))+k_lag:_.index.get_loc(("2004","2"))+1]
35 |
36 | s = ((s-s.mean())/s.std()).values[:,np.newaxis]
37 | y = s
38 |
39 | z = generate_lagged_regressors(s,3).values
40 | x = [1]*z.shape[0]
41 | x = _2dim(np.array(x))
42 |
43 | model = Markov_Multivarite_Regression(y[-z.shape[0]:],x,z,2,2,"full",apriori=None)
44 | # model = Multivariate_Markov_Switching_Model(y[-z.shape[0]:],x,None,2,2,"full",apriori=None)
45 |
46 | res = model.fit()
47 |
48 |
49 |
50 | """
51 | test B
52 | """
53 |
54 |
55 | data = []
56 |
57 | with open("Multivariate_Markov_Switching_Model/test_data/MSVARANAS.txt") as f:
58 | for _ in f.readlines():
59 | data.append(_.strip().split("\t"))
60 | data = pd.DataFrame(data)
61 |
62 |
63 | data = data.replace(".",np.nan).set_index([1,0]).rename_axis(['year','month']).astype(float)
64 |
65 | k_lag = 1
66 | _ = np.log(data).diff(k_lag)*100
67 |
68 | s = _[_.index.get_loc(("1984","1"))+k_lag:_.index.get_loc(("2003","1"))+1]
69 | s = s.iloc[:,:4]
70 |
71 | s = ((s-s.mean())/s.std()).values
72 |
73 | x = _2dim(np.array([1]*s.shape[0]))
74 |
75 | model = Markov_Multivarite_Regression(s,x,None,3,1,"full",apriori=None)
76 | res = model.fit()
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 | """
105 |
106 |
107 |
108 |
109 |
110 |
111 | # res = model.fit()
112 |
113 | self = model
114 |
115 | param = start_params(y=self.y, x=self.x, z=self.z, k_regimes=self.k_regimes, cov_type=self.cov_type,
116 | cov_switch=self.cov_switch, apriori=self.apriori, mean_variance=self.mean_variance,
117 | has_delta=self.has_delta)
118 |
119 | kwargs = {}
120 |
121 | kwargs["y"] = model.y
122 | kwargs["x"] = model.x
123 | kwargs["z"] = model.z
124 | kwargs["k_regimes"] = model.k_regimes
125 | kwargs['apriori'] = model.apriori
126 | kwargs['mean_variance'] = model.mean_variance
127 | kwargs['has_delta'] = model.has_delta
128 | kwargs["cov_switch"] = model.cov_switch
129 | kwargs['cov_type'] = model.cov_type
130 |
131 |
132 |
133 |
134 |
135 | _ = np.log(s).diff(-2)
136 |
137 | _ = _
138 |
139 | _ = s[:-10]
140 |
141 | y = data.iloc[:,2:3].astype(float)
142 |
143 |
144 | def generate_lagged_regressors(y, p):
145 | if not y.ndim == 2:
146 | y = format_data(y)
147 |
148 | _z = pd.DataFrame(np.hstack([y[i:-p + i] for i in np.arange(0, p, 1)]))
149 | y = pd.DataFrame(y)
150 | _z.columns = ["%s_%s" % (_c, p - i + 1) for i in np.arange(1, p + 1, 1) for _c in y.columns]
151 |
152 | if p > 0:
153 | warnings.warn("p>0 some Financial is dropout")
154 |
155 | return _z
156 |
157 |
158 | """
159 |
160 |
161 | # ---------------------------------------------------------------------
162 |
163 | """
164 | We plot the filtered and smoothed probabilities of a recession.
165 | Filtered refers to an estimate of the probability at time 𝑡
166 | based on data up to and including time 𝑡 (but excluding time 𝑡+1,...,𝑇).
167 | Smoothed refers to an estimate of the probability at time 𝑡 using all the data in the sample.
168 | """
169 |
170 |
171 | """
172 |
173 | # covmat_title = "Error covariance matrix"
174 | #
175 | # var = np.hsplit(var_mat, k_regimes)
176 | #
177 | #
178 | #
179 | # # error_covariance_mat = parameter_results.iloc[indices[2]:indices[3]]
180 | # #
181 | # # error_covariance_stubs = ["%s.%s"%(n,m) for i,n in enumerate(y_param_name) for j,m in enumerate(y_param_name) if j>=i]
182 | # #
183 | # # covariance_table = SimpleTable(data=error_covariance_mat.values,
184 | # # headers=["coef1", "std err", "t", "p>|t|"], stubs=error_covariance_stubs, title=covmat_title,
185 | # # txt_fmt=_fmt_params)
186 | # # summary.tables.append(covariance_table)
187 |
188 | """
189 | import statsmodels.api as sm
190 | import pandas as pd
191 | import numpy as np
192 | data = pd.read_pickle("Multivariate_Markov_Switching_Model/test_data.pkl")
193 | model = sm.tsa.VAR(data[['M2','股市']]).fit(maxlags=3)
194 |
195 | from statsmodels.tsa.vector_ar.irf import *
196 | self = model
197 |
198 | model.irf()
199 | """
200 |
201 | array([[[-0.22525379, 0.00593674],
202 | [-0.56635031, 0.04485926]],
203 | [[ 0.32894306, -0.00395223],
204 | [-0.44499289, 0.1234111 ]],
205 | [[ 0.30478203, 0.00154435],
206 | [ 0.59459188, 0.00716239]]])
207 |
208 | """
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
--------------------------------------------------------------------------------
/summaries.py:
--------------------------------------------------------------------------------
1 | import pandas as pd
2 | from statsmodels.tools.numdiff import approx_hess,approx_fprime
3 | from statsmodels.iolib.summary import *
4 | import numpy as np
5 | from statsmodels.iolib.table import SimpleTable
6 | from statsmodels.iolib.tableformatting import (gen_fmt, fmt_2,
7 | fmt_params, fmt_base, fmt_2cols)
8 |
9 |
10 | class MSVARResults:
11 | def __init__(self,model):
12 | self.model = model
13 |
14 | def summary(self):
15 |
16 | results = self.model.results
17 | parameters= self.model.parameters
18 |
19 | unconstrained = results['unconstrained']
20 | constrained = results['constrained']
21 |
22 | k_regimes = parameters.get("k_regimes")
23 | indices = parameters.get("indices")
24 |
25 | print("calculating gradian and hessian matrix..pls be patient")
26 |
27 | gradian = approx_fprime(unconstrained.squeeze(),self.model.transform_params)
28 |
29 | hess = approx_hess(unconstrained.squeeze(),self.model.llf)
30 |
31 | if np.linalg.det(hess)==0:
32 | inv_hess = np.linalg.pinv(hess)
33 | else:
34 | inv_hess = np.linalg.inv(hess)
35 |
36 | cov_beta = gradian.dot(inv_hess).dot(gradian.T)
37 | std_err = np.sqrt(np.diag(cov_beta))
38 | # cor_beta = cov_beta/std_err/std_err.T
39 | t_student = constrained.squeeze()/std_err
40 |
41 | ddf = parameters.get("nobs") - constrained.shape[0]
42 | import scipy.stats as stats
43 |
44 | p_value = 2*(1-stats.t.cdf(np.abs(t_student),ddf))
45 |
46 | parameter_results = pd.DataFrame(np.vstack([constrained.squeeze(),
47 | std_err,t_student,p_value])).T.round(4)
48 |
49 |
50 |
51 | splited_results = np.vsplit(parameter_results,indices)
52 |
53 | beta_sections = np.vsplit(splited_results[2],k_regimes)
54 |
55 | y_param_name = ["y%s"%i for i in np.arange(parameters.get("neqs_y"))]
56 |
57 | beta_sections_names = ["beta%s"%i for i in np.arange(parameters.get("neqs_x"))]
58 |
59 | d_ns = []
60 | # delta_sections = np.vsplit(splited_results[4], k_regimes)
61 |
62 | delta_sections = splited_results[4]
63 |
64 | if len(splited_results[4])>0:
65 |
66 | delta_sections_names = ["delta%s"%i for i in np.arange(parameters.get("neqs_z"))]
67 |
68 | d_ns = ["%s.%s"%(y_n,b_n) for y_n in y_param_name for b_n in delta_sections_names]
69 |
70 | b_ns = ["%s.%s"%(y_n,b_n) for b_n in beta_sections_names for y_n in y_param_name]
71 |
72 | parameters["y_param_names"] = y_param_name
73 |
74 | import time
75 | time_now = time.localtime()
76 | time_of_day = [time.strftime("%H:%M:%S", time_now)]
77 | date = time.strftime("%a, %d %b %Y", time_now)
78 |
79 | # sample=["1","2"]
80 |
81 | gen_left = [
82 | ('Dep. Variable:', [y_param_name]),
83 | ('Date:', [date]),
84 | ('Time:', [time_of_day]),
85 | # ('Sample:', [sample[0]]),
86 | # ('', [sample[1]]),
87 | ]
88 |
89 | gen_right = [
90 | ('No. Observations:', [parameters.get("nobs")]),
91 | ('Covariance Type', [parameters.get("covariance_type")]),
92 | ('Regimes',[parameters.get("k_regimes")]),
93 | ('Log Likelihood', ["%#5.3f" % results.get("likelihoods")]),
94 |
95 | ]
96 |
97 | gen_title = "Markov Switching Multivariate Model Results"
98 |
99 |
100 | if len(gen_right) < len(gen_left):
101 | # fill up with blank lines to same length
102 | gen_right += [(' ', ' ')] * (len(gen_left) - len(gen_right))
103 | elif len(gen_right) > len(gen_left):
104 | # fill up with blank lines to same length, just to keep it symmetric
105 | gen_left += [(' ', ' ')] * (len(gen_right) - len(gen_left))
106 |
107 | gen_right = [('%-21s' % (' ' + k), v) for k, v in gen_right]
108 |
109 | # gen_right = gen_left
110 |
111 | stubs = []
112 | vals = []
113 | for stub, val in gen_right:
114 | stubs.append(stub)
115 | vals.append(val)
116 | table_right = SimpleTable(vals, txt_fmt=fmt_2cols, stubs=stubs)
117 |
118 | stubs = []
119 | vals = []
120 | for stub, val in gen_left:
121 | stubs.append(stub)
122 | vals.append(val)
123 | table_left = SimpleTable(vals, txt_fmt=fmt_2cols,title=gen_title, stubs=stubs)
124 |
125 | table_left.extend_right(table_right)
126 |
127 | summary = Summary()
128 |
129 | summary.tables.append(table_left)
130 |
131 | fmt2 = dict(
132 | data_fmts=["%s", "%s", "%s", "%s", "%s", "%s"],
133 | colwidths=15,
134 | )
135 | from copy import deepcopy
136 | _fmt_params = deepcopy(fmt_params)
137 | _fmt_params.update(fmt2)
138 |
139 | for i in np.arange(k_regimes):
140 | title = "Regime %s Switching Parameters"%i
141 |
142 | tbl = SimpleTable(data=beta_sections[i].values,
143 | headers=["coef","std err","t","p>|t|"],stubs=b_ns,title=title,txt_fmt=_fmt_params)
144 |
145 | summary.tables.append(tbl)
146 |
147 | if self.model.has_delta:
148 | delta_tbl = SimpleTable(data=delta_sections.values,
149 | headers=["coef","std err","t","p>|t|"],stubs=d_ns,title="Non Switching Parameters",txt_fmt=_fmt_params)
150 |
151 | summary.tables.append(delta_tbl)
152 |
153 | # p_j, p_ij, b, d, var_mat, inv_var_mat,det_inv_var_mat =\
154 | # Markov_Multivarite_Regression.convert_param(self.model,constrained)
155 | p_j, p_ij, b, d, var_mat, inv_var_mat,det_inv_var_mat \
156 | = self.model.convert_param(constrained)
157 | # trans_df = pd.DataFrame(p_ij,index=np.arange(k_regimes),columns=np.arange(k_regimes))
158 |
159 | regime_parameter = parameter_results.iloc[0:indices[1]]
160 |
161 | # trans_information = pd.Series({"%s-%s"%(i,j): "%.4f"%c for i,r in enumerate(p_ij)for j,c in enumerate(r)})
162 | trans_stubs = ["p[%s-%s]"%(i,j) for i,r in enumerate(p_ij)for j,c in enumerate(r)][:indices[1]]
163 |
164 | regime_title = "Regime transition parameters"
165 |
166 | regime_tables = SimpleTable(data=regime_parameter.values,
167 | headers=["coef1", "std err", "t", "p>|t|"], stubs=trans_stubs, title=regime_title,
168 | txt_fmt=_fmt_params)
169 |
170 | summary.tables.append(regime_tables)
171 |
172 | parameter_results.columns = ["Estimates","Standard-errors","T","P-values"]
173 |
174 | return summary,parameter_results,p_ij,var_mat
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
--------------------------------------------------------------------------------
/core.py:
--------------------------------------------------------------------------------
1 | from Multivariate_Markov_Switching_Model.tools import *
2 | from Multivariate_Markov_Switching_Model.tools import _2dim
3 | import statsmodels.api as sm
4 | from Multivariate_Markov_Switching_Model.summaries import *
5 |
6 |
7 | class Markov_Multivarite_Regression(object):
8 | def __init__(self,y,x,z,k_regimes,variance_regimes,covariance_type,apriori,**kwargs):
9 | self.original_y = y
10 | self.original_x = x
11 | self.original_z = z
12 |
13 | self.mean_variance = False
14 |
15 | if z is None and (len(np.unique(x)) == 1 and x.flatten()[0] == 1):
16 | self.mean_variance = True
17 |
18 | self.covariance_type = covariance_type
19 | self.variance_regimes = variance_regimes
20 | self.apriori = apriori
21 | self.k_regimes = k_regimes
22 | self.has_delta = True
23 |
24 | self.x,self.y,self.z = Data(self.original_y,self.original_x,self.original_z,self.mean_variance)()
25 |
26 | if len(np.unique(self.z)) == 1 and self.z.flatten()[0] == 0:
27 | self.has_delta = False
28 |
29 | self.nobs,self.neqs_y = self.y.shape
30 | self.neqs_x = self.x.shape[1]
31 | self.neqs_z = self.z.shape[1]
32 | self.indices,self.cov_obs = slicing_parameter(self.k_regimes,self.neqs_y,self.neqs_z,
33 | self.neqs_x,self.covariance_type,self.variance_regimes)
34 | self.start_params = None
35 | if not isinstance(self.apriori,(pd.Series,np.ndarray)):
36 | self.apriori = clustering(self.y,self.k_regimes)
37 |
38 | self.kwargs = kwargs
39 | self.results = {'status': -1}
40 | self.parameters = {"nobs":self.nobs,"neqs_y":self.neqs_y,"neqs_x":self.neqs_x,
41 | "neqs_z":self.neqs_z,"k_regimes":self.k_regimes,
42 | "mean_variance":self.mean_variance,"covariance_type":covariance_type,"variance_regimes":variance_regimes,
43 | "indices":self.indices}
44 | self.current_params = None
45 |
46 |
47 | def fit(self):
48 | param = start_params(y=self.y,x=self.x,z=self.z,k_regimes=self.k_regimes,covariance_type=self.covariance_type,
49 | variance_regimes=self.variance_regimes,apriori=self.apriori,mean_variance=self.mean_variance,has_delta=self.has_delta)
50 |
51 | self.start_params = param
52 | import scipy.optimize as opt
53 |
54 | init_param = param.squeeze()
55 |
56 | maxiters = self.kwargs.setdefault("maxiters",1e+3)
57 | epsilon=self.kwargs.setdefault("eps",np.sqrt(np.finfo(float).eps))
58 | # epsilon = self.kwargs.setdefault('epsilon', np.sqrt(np.finfo(float).eps))
59 |
60 | gtol = self.kwargs.setdefault("gtol",1.0000000000000001e-05)
61 | norm = self.kwargs.setdefault('norm', np.Inf)
62 |
63 | proper_input = isinstance(maxiters,float) == isinstance(epsilon,float) == isinstance(gtol,float)
64 | if not proper_input:
65 | raise Exception("pls enter the correct input")
66 |
67 | options = {"maxiter":maxiters,"eps":epsilon,"gtol":gtol,"norm":norm}
68 | # options = {"maxiter":maxiters,"gtol":gtol}
69 |
70 | # gtol = self.kwargs.setdefault('gtol', 1.0000000000000001e-05)
71 | # norm = self.kwargs.setdefault('norm', np.Inf)
72 | # epsilon = self.kwargs.setdefault('epsilon', 1.4901161193847656e-08)
73 |
74 | rounds = 0
75 |
76 | while True:
77 | rounds += 1
78 | # print(rounds)
79 | # ,callback=progress_bar(maxiters)
80 | res = opt.minimize(self.llf,init_param,method="BFGS",options=options)
81 | self.results["unconstrained"] = res.x[:,None]
82 | self.results['likelihoods'] = res.fun
83 |
84 | if res.status == 0:
85 | final_parameters = res.x
86 |
87 | if final_parameters.ndim <2:
88 | final_parameters = final_parameters[:,None]
89 | parameter = self.transform_params(final_parameters)
90 | self.results['constrained'] = parameter
91 | self.results['jac'] = res.jac
92 | self.results['status'] = 0
93 | return parameter
94 |
95 | elif res.status == 2:
96 | init_param = res.x
97 | options['eps'] *= (options['gtol'])
98 | else:
99 | print(res)
100 | raise Exception("something wrong pls check ")
101 |
102 | if rounds>=10:
103 | print("out of space")
104 | return res
105 |
106 | def llf(self,param):
107 |
108 | param = _2dim(param)
109 |
110 | parameter = self.transform_params(param)
111 |
112 | results = self._filter(parameter)
113 | return results
114 |
115 | def convert_param(self,param):
116 | """transforms a vector of parameters in transition probability and ergodic matrices
117 | beta coefficient and var-cov matrices
118 | """
119 |
120 | cut_off = self.indices
121 | from Multivariate_Markov_Switching_Model.tools import _p_transition,_cov_mat,_p_ergodic
122 |
123 | p_trans = _p_transition(param[cut_off[0]:cut_off[1]], self.k_regimes)
124 | p_ergodic = _p_ergodic(p_trans, self.k_regimes)
125 |
126 | b = param[cut_off[1]:cut_off[2]].reshape(self.neqs_x, self.neqs_y * self.k_regimes)
127 | sig_mat, inv_sig_mat, det_inv_sig_mat \
128 | = _cov_mat(param[cut_off[2]:cut_off[3]].reshape(self.cov_obs, self.variance_regimes), self.neqs_y, self.covariance_type, self.variance_regimes)
129 |
130 | d = np.kron(np.ones((1, self.k_regimes)), param[cut_off[3]:cut_off[4]].reshape(self.neqs_z, self.neqs_y)) if self.has_delta else 0
131 |
132 | return p_ergodic, p_trans, b, d, sig_mat, inv_sig_mat, det_inv_sig_mat
133 |
134 | def _filter(self,parameter):
135 | """apply hamilton filter"""
136 |
137 | p_j, p_ij, b, d, var_mat, inv_var_mat,det_inv_var_mat = self.convert_param(parameter)
138 | self.current_params = parameter
139 | if np.sometrue(np.greater_equal(p_ij,1)):
140 | return np.inf
141 |
142 | nobs = self.nobs
143 | y_hat = np.zeros((nobs,self.neqs_y))
144 |
145 | p_predicted_joint = np.zeros((nobs,self.k_regimes))
146 |
147 | joint_likelihoods = np.zeros((nobs,1))
148 | filtered_probabilities = np.zeros((nobs+1,self.k_regimes))
149 | filtered_probabilities[0,...] = p_j.T
150 |
151 | mu = self.x.dot(b)+self.z.dot(d)
152 |
153 | _y = np.kron(np.ones((1,self.k_regimes)),self.y)
154 |
155 | residual = _y-mu
156 |
157 | if np.sometrue(np.less(det_inv_var_mat,0)):
158 | return np.inf
159 |
160 | # filtered joint probabilities
161 | for i in np.arange(nobs):
162 |
163 | cond_likelihoods = self._cond_densities(residual[i,:].T,inv_var_mat,det_inv_var_mat).T
164 | # P(S(t)=i,Y(t)|I(t-1))
165 | p_predicted_joint[i,...] = p_ij.dot(filtered_probabilities[i,...])
166 |
167 | tmp = cond_likelihoods*p_predicted_joint[i,...]
168 | joint_likelihoods[i] = tmp.sum()
169 |
170 | if np.isnan(joint_likelihoods[i]):
171 | return np.inf
172 |
173 | filtered_probabilities[i+1,...] = tmp/joint_likelihoods[i]
174 |
175 | y_hat[i,:] = filtered_probabilities[i+1,...].dot(mu[i,:].reshape(self.k_regimes,self.neqs_y))
176 |
177 | resid = self.y-y_hat
178 | likelihoods = -(np.log(joint_likelihoods).sum())
179 |
180 | if np.isnan(likelihoods):
181 | raise Exception("Please Check the Calculation ")
182 |
183 | self.results["resid"] = resid
184 | self.results["joint_likelihoods"] = joint_likelihoods
185 | self.results['filtered_probabilities'] = filtered_probabilities
186 | self.results['p_predicted_joint'] = p_predicted_joint
187 |
188 | # ,y_hat,resid,joint_likelihoods,filtered_probabilities,p_predicted_joint
189 | return likelihoods
190 |
191 | def _cond_densities(self,res,inv_var_mat, det_inv_var_mat):
192 | """compute the conditional densities """
193 | k_regimes = self.k_regimes
194 | neqs_y = self.neqs_y
195 | _resid = res.reshape(neqs_y,k_regimes).T
196 |
197 | if self.variance_regimes == 1:
198 | sig = np.kron(np.ones((1,k_regimes)),inv_var_mat)
199 | det_sig = np.kron(np.ones((1,k_regimes)),det_inv_var_mat).T
200 | else:
201 | sig = inv_var_mat
202 | det_sig = det_inv_var_mat[:,np.newaxis]
203 |
204 | _resid = _resid.flatten(order="F")[:,np.newaxis]
205 | aux = _resid*np.kron(np.eye(k_regimes),np.ones((neqs_y,1)))
206 | sigma = np.kron(np.eye(k_regimes),np.ones((neqs_y,neqs_y)))*(np.kron(np.ones((k_regimes,1)),sig))
207 |
208 | w = aux.T.dot(sigma).dot(aux)
209 | v = np.diag(w)[:,np.newaxis]
210 |
211 | eta = (1/np.sqrt(2*np.pi))**neqs_y*np.sqrt(det_sig)*np.exp(-0.5*v)
212 |
213 | return eta
214 |
215 | def transform_params(self,unconstrained):
216 | """create a constrained parameter g=g(theta) to enter the likelihood function"""
217 |
218 | unconstrained = _2dim(unconstrained)
219 |
220 | k_regimes = self.k_regimes
221 | neqs_y = self.neqs_y
222 | slices = self.indices
223 | aux_p = unconstrained[:(k_regimes-1)*k_regimes].reshape((k_regimes-1),k_regimes)
224 | # FIXME over flow ignore
225 | _ = np.seterr(over='ignore')
226 | B = np.exp(aux_p)
227 |
228 | masks = np.isinf(B)
229 |
230 | sumx = B.sum(axis=0)+np.ones((1,k_regimes))[0]
231 | aux_p = B/sumx
232 |
233 | aux_p = np.where(masks,1,aux_p)
234 |
235 | from copy import deepcopy
236 | c = deepcopy(unconstrained)
237 |
238 | # FIXME
239 | prob = np.hstack([aux_p.flatten()[:,np.newaxis],0.001*np.ones(((k_regimes-1)*k_regimes,1))])
240 | # c.extend(prob.max(axis=1))
241 |
242 | c[:(k_regimes-1)*k_regimes] = prob.max(axis=1)[:,np.newaxis]
243 |
244 | v = c[slices[2]:slices[3],:]
245 | aux_v = v.reshape(self.cov_obs,self.variance_regimes)
246 | for i in np.arange(self.variance_regimes):
247 | if self.covariance_type == 'full':
248 | _value = aux_v[:,i]
249 |
250 | m_aux = xpnd(_value)
251 |
252 | diag_mat = np.abs(np.diag(m_aux))*(np.eye(neqs_y))
253 |
254 | rho_mat = m_aux-diag_mat
255 | rho_mat = rho_constraints(rho_mat)+np.eye(neqs_y)
256 |
257 | m_aux = diag_mat.dot(rho_mat).dot(diag_mat)
258 | aux_v[:,i] = vech(m_aux)
259 | else:
260 | aux_v[:,i] = aux_v[:,i]**2
261 | c[slices[2]:slices[3]] = vecr(aux_v)[:,np.newaxis]
262 | return c
263 |
264 | def summary(self):
265 | s = MSVARResults(self)
266 | return s.summary()
267 |
268 | def smooth_probabilities(self):
269 | results = self.results
270 | p_filtered_joint = results['filtered_probabilities'][1:]
271 | p_predicted_joint = results['p_predicted_joint']
272 | parameter = results['constrained']
273 | p_j, p_ij, b, d, var_mat, inv_var_mat,det_inv_var_mat = self.convert_param(parameter)
274 |
275 | _ = convert_smooth(p_filtered_joint, p_predicted_joint, p_ij)
276 |
277 | return _
278 |
279 |
280 | i=0
281 | import time
282 | import sys
283 |
284 |
285 | class progress_bar(object):
286 | def __init__(self,iter):
287 | # self.max_sec = max_sec
288 | self.start = time.time()
289 | self.iter = iter
290 |
291 | def __call__(self, xk=None):
292 | global i
293 | i+=1
294 |
295 | elapsed = time.time()-self.start
296 | rate = i/self.iter
297 | percentage = rate*100
298 |
299 | l_bar = '{0:3.0f}%|'.format(percentage)
300 |
301 | bar_length,frac_bar = divmod(int(percentage), 10)
302 | bar = chr(0x2588) * bar_length
303 | frac_bar = chr(0x2590-frac_bar)
304 |
305 | remaining_time = elapsed/rate - elapsed
306 |
307 | speed = elapsed/i
308 |
309 | full_bar = bar + frac_bar +' ' * max(10 - bar_length, 0)
310 | r_bar = '| {0}/{1} [{2}<{3}, {4}s/iter]'.format(
311 | i, self.iter, np.round(elapsed,4),np.round(remaining_time,4),np.round(speed,4))
312 |
313 | bar = l_bar+full_bar+r_bar
314 |
315 | sys.stdout.write(bar)
316 | sys.stdout.write('\n')
317 |
318 |
319 |
320 | # def filter_probabilities(parameter):
321 | # llf, y_hat, resid,joint_likelihoods, filtered_probabilities, p_predicted_joint = filter(parameter,K,M,covariance_type,variance_regimes,n_x,n_z)
322 | # ptrans_res = convert_param(param,K,M,n_x,n_z,covariance_type,variance_regimes)
323 | # param, K, M, n_x, n_z, covariance_type, variance_regimes
324 | # PR_SMO = MSVAR_smooth(filtered_probabilities, p_predicted_joint,ptrans_res)
325 | #
326 |
327 |
328 |
329 |
330 |
331 |
332 |
333 |
334 |
335 |
336 |
337 |
338 |
339 |
340 |
341 |
342 |
343 |
344 |
345 |
346 |
347 |
348 |
349 |
350 |
--------------------------------------------------------------------------------
/MAVAR.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": null,
6 | "metadata": {},
7 | "outputs": [],
8 | "source": [
9 | "import pandas as pd\n",
10 | "import numpy as np\n",
11 | "# from.tools import *\n",
12 | "from Multivariate_Markov_Switching_Model.tools import *\n",
13 | "from Multivariate_Markov_Switching_Model.MSVAR import *\n",
14 | "from Multivariate_Markov_Switching_Model.tools import _2dim\n",
15 | "import numpy as np\n",
16 | "import os\n",
17 | "# os.chdir(\"MSVAR\")\n",
18 | "import pandas as pd\n",
19 | "import numpy as np\n",
20 | "from statsmodels.tsa.seasonal import seasonal_decompose\n",
21 | "from scipy.interpolate import interp1d\n",
22 | "from Multivariate_Markov_Switching_Model.MSVAR import *\n",
23 | "%matplotlib inline"
24 | ]
25 | },
26 | {
27 | "cell_type": "code",
28 | "execution_count": null,
29 | "metadata": {},
30 | "outputs": [],
31 | "source": [
32 | "import matplotlib.pyplot as plt\n",
33 | "plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签\n",
34 | "plt.rcParams['axes.unicode_minus']=False #用来正常显示负号\n"
35 | ]
36 | },
37 | {
38 | "cell_type": "code",
39 | "execution_count": null,
40 | "metadata": {},
41 | "outputs": [],
42 | "source": [
43 | "\n",
44 | "\n",
45 | "def fill(series):\n",
46 | " # print(series.name)\n",
47 | " if any(series.isna()):\n",
48 | "\n",
49 | " nan_loc = pd.Index(series.values).get_loc(np.nan)\n",
50 | " if isinstance(nan_loc, np.ndarray):\n",
51 | " all_loc = np.arange(len(series))\n",
52 | "\n",
53 | " x = np.setdiff1d(all_loc, nan_loc)\n",
54 | " y = series.dropna().values\n",
55 | "\n",
56 | " f = interp1d(x, y, 'slinear')\n",
57 | " new_x = nan_loc[(nan_loc >= x[0]) & (nan_loc <= x[-1])]\n",
58 | " new_y = f(new_x)\n",
59 | "\n",
60 | " interpolate = pd.Series(new_y, index=new_x)\n",
61 | " ori = pd.Series(y, index=x)\n",
62 | "\n",
63 | " _ = pd.concat([interpolate, ori]).reindex(all_loc)\n",
64 | " _.index = series.index\n",
65 | " return _\n",
66 | " else:\n",
67 | " return series\n",
68 | " else:\n",
69 | " return series\n",
70 | "\n",
71 | "\n",
72 | "\n",
73 | "price = pd.read_pickle(\"Data/Financial/Index/daily/000001_daily_price.pkl\")['close']\n",
74 | "\n",
75 | "p = price.resample(\"M\").last()\n",
76 | "\n",
77 | "\n",
78 | "industry = pd.read_excel(\"Data/Financial/Macro/工业增加值-月.xls\",index_col=0,header=2,nrows=2).T\n",
79 | "\n",
80 | "industry.index = pd.DatetimeIndex(industry.index.str[:4]+\"-\"+industry.index.str[5:-1].str.zfill(2)+\"-01\")\n",
81 | "\n",
82 | "industry = industry.resample(\"M\").last()\n",
83 | "\n",
84 | "industry_increase = industry['工业增加值同比增长(%)']\n",
85 | "industry_increase = fill(industry_increase).dropna()\n",
86 | "\n",
87 | "\n",
88 | "# industry_increase.reindex(smooth_probabilities.index).plot()"
89 | ]
90 | },
91 | {
92 | "cell_type": "code",
93 | "execution_count": null,
94 | "metadata": {},
95 | "outputs": [],
96 | "source": []
97 | },
98 | {
99 | "cell_type": "code",
100 | "execution_count": null,
101 | "metadata": {},
102 | "outputs": [],
103 | "source": [
104 | "data = pd.read_pickle(\"Multivariate_Markov_Switching_Model/test_data.pkl\")\n",
105 | "data = data[['M2',\"股市\",'实体经济']]\n",
106 | "model = pd.read_pickle(\"Multivariate_Markov_Switching_Model/m2-股市-L3-K3.pkl\").loc[0]\n",
107 | "smooth_probabilities = pd.DataFrame(model.smooth_probabilities(),index=data.index[-model.x.shape[0]:])\n",
108 | "filtered_probabilities = pd.DataFrame(model.results['filtered_probabilities'][1:],index = data.index[-model.x.shape[0]:])\n",
109 | "p_predicted_joint = pd.DataFrame(model.results['p_predicted_joint'],index=data.index[-model.x.shape[0]:])\n",
110 | "price = pd.read_pickle(\"Data/Financial/Index/daily/000001_daily_price.pkl\")['close']\n",
111 | "\n",
112 | "# p = price.resample(\"M\").last().reindex(smooth_probabilities.index)\n",
113 | "p = (industry_increase).reindex(smooth_probabilities.index)\n",
114 | "\n",
115 | "import matplotlib.pyplot as plt\n",
116 | "import seaborn as sns\n",
117 | "fig,ax = plt.subplots(smooth_probabilities.shape[1],1,sharex=True,figsize=(10,6))\n",
118 | "for i in smooth_probabilities:\n",
119 | " smooth_probabilities[i].plot(ax=ax[i],color='#984B4B')\n",
120 | " filtered_probabilities[i].plot(ax=ax[i],color=\"#4F9D9D\",ls='-.')\n",
121 | " p_predicted_joint[i].plot(ax=ax[i],color='#FF8F59',ls='--')\n",
122 | "# ax[i].set(title=\"Regime %s\"%i)\n",
123 | " ax[0].legend(['Smoothed','Filtered','Predicted'],loc='upper right') \n",
124 | " ax[i] = ax[i].twinx()\n",
125 | " p.plot(ax=ax[i],color='k',alpha=0.3)\n",
126 | " ax[0].legend(['工业同比增加'],loc='lower left') \n",
127 | "ax[0].set_title(\"紧缩\")\n",
128 | "ax[1].set_title(\"平稳\")\n",
129 | "ax[2].set_title(\"通胀\")\n",
130 | "\n",
131 | "fig.tight_layout()\n"
132 | ]
133 | },
134 | {
135 | "cell_type": "code",
136 | "execution_count": null,
137 | "metadata": {},
138 | "outputs": [],
139 | "source": [
140 | "np.corrcoef(filtered_probabilities[2],p)"
141 | ]
142 | },
143 | {
144 | "cell_type": "code",
145 | "execution_count": null,
146 | "metadata": {},
147 | "outputs": [],
148 | "source": [
149 | "p_j, p_ij, b, d, var_mat, inv_var_mat,det_inv_var_mat = model.convert_param(model.results['constrained'])"
150 | ]
151 | },
152 | {
153 | "cell_type": "code",
154 | "execution_count": null,
155 | "metadata": {},
156 | "outputs": [],
157 | "source": [
158 | "p_ij"
159 | ]
160 | },
161 | {
162 | "cell_type": "code",
163 | "execution_count": null,
164 | "metadata": {},
165 | "outputs": [],
166 | "source": [
167 | "_ = model.summary()"
168 | ]
169 | },
170 | {
171 | "cell_type": "code",
172 | "execution_count": null,
173 | "metadata": {},
174 | "outputs": [],
175 | "source": [
176 | "pd.Series(_).to_pickle(\"Multivariate_Markov_Switching_Model//model1_summary.pkl\")"
177 | ]
178 | },
179 | {
180 | "cell_type": "code",
181 | "execution_count": null,
182 | "metadata": {},
183 | "outputs": [],
184 | "source": []
185 | },
186 | {
187 | "cell_type": "code",
188 | "execution_count": 1,
189 | "metadata": {},
190 | "outputs": [],
191 | "source": [
192 | "import warnings \n",
193 | "warnings.filterwarnings('ignore') \n",
194 | "from Multivariate_Markov_Switching_Model.MSVAR import *\n",
195 | "%matplotlib inline\n",
196 | "from Multivariate_Markov_Switching_Model.tools import _2dim\n",
197 | "\n",
198 | "\n",
199 | "data = []\n",
200 | "\n",
201 | "with open(\"Multivariate_Markov_Switching_Model/test_data/MSVARUN.txt\") as f:\n",
202 | " for _ in f.readlines():\n",
203 | " data.append(_.strip().split(\"\\t\"))\n",
204 | "data = pd.DataFrame(data)\n",
205 | "\n",
206 | "s = data.set_index([1,0]).replace(\".\",np.nan)[2].astype(float).rename_axis(['year','month'])\n",
207 | "\n",
208 | "apr = data.set_index([1,0]).replace(\".\",np.nan)[3].astype(float).rename_axis(['year','month'])\n",
209 | "\n",
210 | "apriori = apr[apr.index.get_loc((\"1967\",\"7\")):apr.index.get_loc((\"2004\",\"3\"))].values\n",
211 | "\n",
212 | "k_lag = 2\n",
213 | "\n",
214 | "_ = np.log(s).diff(k_lag)*100\n",
215 | "\n",
216 | "s = _[_.index.get_loc((\"1967\",\"2\"))+k_lag:_.index.get_loc((\"2004\",\"2\"))+1]\n",
217 | "\n",
218 | "s = ((s-s.mean())/s.std()).values[:,np.newaxis]\n",
219 | "y = s\n",
220 | "\n",
221 | "z = generate_lagged_regressors(s,3).values\n",
222 | "x = [1]*z.shape[0]\n",
223 | "x = _2dim(np.array(x))\n",
224 | "\n",
225 | "model = Markov_Multivarite_Regression(y[-z.shape[0]:],x,z,2,2,\"full\",apriori=None)\n",
226 | "# model = Multivariate_Markov_Switching_Model(y[-z.shape[0]:],x,None,2,2,\"full\",apriori=None)\n",
227 | "\n",
228 | "res = model.fit()\n",
229 | "\n"
230 | ]
231 | },
232 | {
233 | "cell_type": "code",
234 | "execution_count": 2,
235 | "metadata": {},
236 | "outputs": [
237 | {
238 | "data": {
239 | "text/plain": [
240 | "array([[ 0.85089924],\n",
241 | " [ 0.97339873],\n",
242 | " [-0.80059507],\n",
243 | " [ 0.14887296],\n",
244 | " [ 0.70574205],\n",
245 | " [ 0.34950403],\n",
246 | " [ 0.6414498 ],\n",
247 | " [-0.45878331],\n",
248 | " [ 0.34911898]])"
249 | ]
250 | },
251 | "execution_count": 2,
252 | "metadata": {},
253 | "output_type": "execute_result"
254 | }
255 | ],
256 | "source": [
257 | "res"
258 | ]
259 | },
260 | {
261 | "cell_type": "code",
262 | "execution_count": 3,
263 | "metadata": {},
264 | "outputs": [
265 | {
266 | "name": "stdout",
267 | "output_type": "stream",
268 | "text": [
269 | "calculating gradian and hessian matrix..pls be patient\n"
270 | ]
271 | }
272 | ],
273 | "source": [
274 | "summary = model.summary()"
275 | ]
276 | },
277 | {
278 | "cell_type": "code",
279 | "execution_count": 4,
280 | "metadata": {},
281 | "outputs": [
282 | {
283 | "data": {
284 | "text/html": [
285 | "\n",
286 | "Markov Switching Multivariate Model Results\n",
287 | "\n",
288 | " | Dep. Variable: | ['y0'] | No. Observations: | 440 | \n",
289 | "
\n",
290 | "\n",
291 | " | Date: | Fri, 17 Apr 2020 | Covariance Type | full | \n",
292 | "
\n",
293 | "\n",
294 | " | Time: | ['21:34:54'] | Regimes | 2 | \n",
295 | "
\n",
296 | "\n",
297 | " | | | Log Likelihood | 449.278 | \n",
298 | "
\n",
299 | "
\n",
300 | "\n",
301 | "Regime 0 Switching Parameters\n",
302 | "\n",
303 | " | coef | std err | t | p>|t| | \n",
304 | "
\n",
305 | "\n",
306 | " | y0.beta0 | -0.8006 | 0.2243 | -3.5699 | 0.0004 | \n",
307 | "
\n",
308 | "
\n",
309 | "\n",
310 | "Regime 1 Switching Parameters\n",
311 | "\n",
312 | " | coef | std err | t | p>|t| | \n",
313 | "
\n",
314 | "\n",
315 | " | y0.beta0 | 0.1489 | 0.0519 | 2.8709 | 0.0043 | \n",
316 | "
\n",
317 | "
\n",
318 | "\n",
319 | "Non Switching Parameters\n",
320 | "\n",
321 | " | coef | std err | t | p>|t| | \n",
322 | "
\n",
323 | "\n",
324 | " | y0.delta0 | 0.6414 | 0.0578 | 11.1001 | 0.0 | \n",
325 | "
\n",
326 | "\n",
327 | " | y0.delta1 | -0.4588 | 0.0512 | -8.9583 | 0.0 | \n",
328 | "
\n",
329 | "\n",
330 | " | y0.delta2 | 0.3491 | 0.051 | 6.8521 | 0.0 | \n",
331 | "
\n",
332 | "
\n",
333 | "\n",
334 | "Regime transition parameters\n",
335 | "\n",
336 | " | coef1 | std err | t | p>|t| | \n",
337 | "
\n",
338 | "\n",
339 | " | p[0-0] | 0.8509 | 0.0797 | 10.6763 | 0.0 | \n",
340 | "
\n",
341 | "\n",
342 | " | p[0-1] | 0.9734 | 0.0129 | 75.6457 | 0.0 | \n",
343 | "
\n",
344 | "
"
345 | ],
346 | "text/plain": [
347 | "\n",
348 | "\"\"\"\n",
349 | " Markov Switching Multivariate Model Results \n",
350 | "==============================================================================\n",
351 | "Dep. Variable: ['y0'] No. Observations: 440\n",
352 | "Date: Fri, 17 Apr 2020 Covariance Type full\n",
353 | "Time: ['21:34:54'] Regimes 2\n",
354 | " Log Likelihood 449.278\n",
355 | " Regime 0 Switching Parameters \n",
356 | "===============================================================================\n",
357 | " coef std err t p>|t|\n",
358 | "-------------------------------------------------------------------------------\n",
359 | "y0.beta0 -0.8006 0.2243 -3.5699 0.0004\n",
360 | " Regime 1 Switching Parameters \n",
361 | "===============================================================================\n",
362 | " coef std err t p>|t|\n",
363 | "-------------------------------------------------------------------------------\n",
364 | "y0.beta0 0.1489 0.0519 2.8709 0.0043\n",
365 | " Non Switching Parameters \n",
366 | "===============================================================================\n",
367 | " coef std err t p>|t|\n",
368 | "-------------------------------------------------------------------------------\n",
369 | "y0.delta0 0.6414 0.0578 11.1001 0.0\n",
370 | "y0.delta1 -0.4588 0.0512 -8.9583 0.0\n",
371 | "y0.delta2 0.3491 0.051 6.8521 0.0\n",
372 | " Regime transition parameters \n",
373 | "===============================================================================\n",
374 | " coef1 std err t p>|t|\n",
375 | "-------------------------------------------------------------------------------\n",
376 | "p[0-0] 0.8509 0.0797 10.6763 0.0\n",
377 | "p[0-1] 0.9734 0.0129 75.6457 0.0\n",
378 | "===============================================================================\n",
379 | "\"\"\""
380 | ]
381 | },
382 | "execution_count": 4,
383 | "metadata": {},
384 | "output_type": "execute_result"
385 | }
386 | ],
387 | "source": [
388 | "summary[0]"
389 | ]
390 | },
391 | {
392 | "cell_type": "code",
393 | "execution_count": 5,
394 | "metadata": {},
395 | "outputs": [
396 | {
397 | "data": {
398 | "text/html": [
399 | "\n",
400 | "\n",
413 | "
\n",
414 | " \n",
415 | " \n",
416 | " | \n",
417 | " Estimates | \n",
418 | " Standard-errors | \n",
419 | " T | \n",
420 | " P-values | \n",
421 | "
\n",
422 | " \n",
423 | " \n",
424 | " \n",
425 | " | 0 | \n",
426 | " 0.8509 | \n",
427 | " 0.0797 | \n",
428 | " 10.6763 | \n",
429 | " 0.0000 | \n",
430 | "
\n",
431 | " \n",
432 | " | 1 | \n",
433 | " 0.9734 | \n",
434 | " 0.0129 | \n",
435 | " 75.6457 | \n",
436 | " 0.0000 | \n",
437 | "
\n",
438 | " \n",
439 | " | 2 | \n",
440 | " -0.8006 | \n",
441 | " 0.2243 | \n",
442 | " -3.5699 | \n",
443 | " 0.0004 | \n",
444 | "
\n",
445 | " \n",
446 | " | 3 | \n",
447 | " 0.1489 | \n",
448 | " 0.0519 | \n",
449 | " 2.8709 | \n",
450 | " 0.0043 | \n",
451 | "
\n",
452 | " \n",
453 | " | 4 | \n",
454 | " 0.7057 | \n",
455 | " 0.2004 | \n",
456 | " 3.5216 | \n",
457 | " 0.0005 | \n",
458 | "
\n",
459 | " \n",
460 | " | 5 | \n",
461 | " 0.3495 | \n",
462 | " 0.0314 | \n",
463 | " 11.1178 | \n",
464 | " 0.0000 | \n",
465 | "
\n",
466 | " \n",
467 | " | 6 | \n",
468 | " 0.6414 | \n",
469 | " 0.0578 | \n",
470 | " 11.1001 | \n",
471 | " 0.0000 | \n",
472 | "
\n",
473 | " \n",
474 | " | 7 | \n",
475 | " -0.4588 | \n",
476 | " 0.0512 | \n",
477 | " -8.9583 | \n",
478 | " 0.0000 | \n",
479 | "
\n",
480 | " \n",
481 | " | 8 | \n",
482 | " 0.3491 | \n",
483 | " 0.0510 | \n",
484 | " 6.8521 | \n",
485 | " 0.0000 | \n",
486 | "
\n",
487 | " \n",
488 | "
\n",
489 | "