def fit(self, time_coefficients, y):
p = 1 #VAR model order
K = 3 #Number of states
wlen = 50 #Window length
shift = 1 #Window shift
min_r_len = 5 #Minimum length for each regime
N, T = y.shape
C, St_km = self._vns_clustering(time_coefficients.T, K)
# Pooling samples for regimes
St = np.zeros((N, T, K))
tj = np.zeros(K, dtype="i")
for j in range(K):
t = 0
for i in range(T):
if St_km[i] == j:
St[:, t, j] = y[:, i]
t = t + 1
tj[j] = t - 1
# Estimate state-specific VAR
A_km = np.zeros((N, N * p, K))
for j in range(K):
A_km[:, :,
j] = var_model.VAR(St[:, :tj[j],
j].T).fit(maxlags=p,
method="ols",
ic=None,
trend="nc").params #Fit a VAR
self.cluster_centres = C
self.clustered_coefficients = St_km
self.expanded_time_series = St
self.length_by_cluster = tj
self.time_varying_states_var_coefficients = A_km
def transform(self, seriess, debug):
lhs, rhs = seriess[0], seriess[1]
NodeTransformer.validate_input_steps_spans(lhs, rhs)
if(lhs.span() != rhs.span()):
raise ValueError("Inputs must have same span")
endog = np.transpose([s.pdseries.tolist() for s in seriess])
p, output = self.get_params()
calc_p = timedelta_to_period(p, seriess[0].step())
model = var_model.VAR(endog)
model_fit = model.fit(calc_p)
result = None
if output == 'predicted':
result = model_fit.fittedvalues
elif output == 'resid':
result = model_fit.resid
else:
raise ValueError('Invalid output: ' + output)
# Drop offset_start elements
offset_start = len(seriess[0].pdseries.index) - len(result)
# Debug info
if debug:
debug_info = {
"summary": str(model_fit.summary()),
"offset_start": offset_start,
}
else:
debug_info = {}
result = pd.Series([np.sum(np.abs(r)) for r in result], index=seriess[0].pdseries.index[offset_start:])
return (result, debug_info)
def fit(self, y):
p = 1 #VAR model order
K = 3 #Number of states
wlen = 50 #Window length
shift = 1 #Window shift
min_r_len = 5 #Minimum length for each regime
N, T = y.shape
tvvar_vec = np.zeros((p * N**2, T)) #TV-VAR coeffs
win = np.ones(wlen) #form a window
# initialize the indexes
indx = 0
t = 0
Yw = np.zeros((N, wlen))
# Short-Time VAR Analysis
while indx + wlen <= T:
for i in range(N):
Yw[i, :] = y[i, indx:indx + wlen] * win.T
At = var_model.VAR(Yw.T).fit(maxlags=p,
method="ols",
ic=None,
trend="nc").params #Fit a VAR
tvvar_vec[:, t] = At[:].ravel() #update time-varying matrix
indx = indx + shift
t = t + 1 #update the indexes
self.coefficients = tvvar_vec
def ar_stability(data, order, n_eigs):
'''
Builds an vector autoregressive (VAR) model of iEEG data,
constructs a state matrix, and returns first n_eigs eigenvalues
of this matrix.
:param data:
:param order:
:param n_eigs:
:return:
'''
n, N = data.shape # N : number of channels, n: number of observations
model = var_model.VAR(data)
mvar_fit = model.fit(order)
A = mvar_fit.coefs
# build the state matrix
top = np.concatenate(A,axis=1)
bottom = np.eye(N*(order-1), N*order)
state_mat = np.concatenate(np.array([top,bottom]), axis=0)
# compute the top n_eigs largest eigenvalues
eigs = linalg.eig(state_mat,right=False, overwrite_a=True)
abs_eigs = np.abs(eigs)
abs_eigs =np.sort(abs_eigs)
return abs_eigs[-n_eigs:]
def __init__(self, nid, connection=None, freq='T', maxlags=_maxlags):
super().__init__(nid, connection, freq)
endog = self.readings.dropna()
if endog.empty:
raise AttributeError('Empty endogenous variable')
try:
model = vm.VAR(endog=endog)
fit = model.fit(maxlags=maxlags)
self.irf = fit.irf(maxlags)
except (LinAlgError, ValueError) as err:
raise AttributeError(err)
def var(df, lags = -1, **kwargs):
model = var_model.VAR(df, dates=df.index, freq="Q")
if lags > 0:
print(f"Using given lag order ({lags})...")
results = model.fit(lags, verbose=True, **kwargs)
else:
print("Finding optimum lag order...")
results = model.fit(verbose=True, **kwargs)
return results
def var_(*args):
(_, nid, cargs) = args
node = nd.Cluster(nid)
log.info('var: {0}'.format(str(node)))
endog = node.readings.dropna()
if not endog.empty and cargs.lags:
maxlags = max(cargs.lags)
try:
res = vm.VAR(endog=endog).fit(maxlags=maxlags)
mkplot(node, 'var', res, cargs.output, maxlags)
except (LinAlgError, ValueError) as err:
log.error(err)
def fit(self, training_df=None):
"""This function fits the loaded model
Returns:
model_fit (model): The trained model
"""
# First load the training data
if training_df is None:
train = self.training_data[:int(0.8 * (len(self.training_data)))]
else:
train = training_df[:int(0.8 * (len(training_df)))]
self.training_data = training_df
# Now fit the model
model = var_model.VAR(endog=train)
self.ml_model = model.fit()
return self.ml_model
def select_lr(df, maxlags = 15, **kwargs):
lag_list = make_lag_iter(maxlags)
model = var_model.VAR(df, dates=df.index, freq="Q")
for more_l, less_l in lag_list:
big_model = model.fit(more_l, **kwargs)
small_model = model.fit(less_l, **kwargs)
reject = lr_test(big_model.llf, small_model.llf, big_model.df_resid)
if reject:
return more_l
else:
raise ValueError("Never rejected, increase maxlags")
def forecast_stock_price_var(stock_prices, time_horizon, max_order=5):
# transpose this sucker
stock_prices_t = np.transpose(stock_prices)
# select optimal order
var_mod = var_model.VAR(stock_prices_t)
order = var_mod.select_order(max_order)
opt_order = order['aic']
# fit data with optimal order
results = var_mod.fit(maxlags=opt_order)
# predict price to time horizon
forecasted_price_t = results.forecast(stock_prices_t, time_horizon)
forecasted_price = np.transpose(forecasted_price_t)
return forecasted_price
def mvar_pred_err(data, pred_window_size=1000, order=30):
'''
Fits a multivatiate autoregressive model to data
:param data:
:param pred_window_size:
:param order:
:return:
'''
model_var = var_model.VAR(data[:-pred_window_size, :])
model_results = model_var.fit(maxlags=order)
pred_data = np.asarray(
model_results.forecast(
data[-pred_window_size - order:-pred_window_size],
pred_window_size))
fun_energy = function_energy(data[-pred_window_size:, :])
err_energy = function_energy(data[-pred_window_size:, :] - pred_data)
return np.append(fun_energy, err_energy)
def rolling_estimate(args):
data, idx, larger_constraints, less_constraints = args
fit_lag = 100
result_lst = []
for i in xrange(len(data)):
if i < fit_lag:
continue
print i
this_data = data.iloc[i - fit_lag:i, :]
var = sm.VAR(endog=this_data.values)
result = var.fit(1, trend="nc")
a_matrix = irf(result,
idx,
larger_constraints,
less_constraints,
2,
200,
2,
plot=False)
result_lst.append(a_matrix.mean(1))
result_ar = np.array(result_lst)
fig = plt.figure(figsize=(20, 10))
plt.plot(result_ar[:, 0], label="0")
plt.plot(result_ar[:, 1], label="1")
plt.plot(result_ar[:, 2], label="2")
plt.plot(result_ar[:, 3], label="3")
plt.plot(result_ar[:, 4], label="4")
plt.plot(result_ar[:, 5], label="5")
plt.legend()
plt.savefig("{}_100.png".format(idx))
with open(str(idx) + "_100", "wb") as fp:
cp.dump(result_ar, fp)
# try pdc_dtf.py code
A_bar, sigma_bar = mv.mvar_fit(X, p)
est_total = sum(np.array([np.linalg.norm(A_bar[i],ord='fro') for i in range(p)]))
true_total = sum(np.array([np.linalg.norm(A[i],ord='fro') for i in range(p)]))
for i in range(p):
est_power = np.linalg.norm(A_bar[i],ord='fro') / est_total
true_power = np.linalg.norm(A[i],ord='fro') / true_total
print "For i=" + str(i) +", the estimated regression coefficients (with norm " + str(est_power) + " | " + str(true_power) + ") : "
print str(A_bar[i])
print "Noise variances: "
print str(sigma_bar)
# # create known VAR process with parameters A and sigma -- useful later?
# known = var_model.VARProcess(coefs=A, intercept=np.zeros(N), sigma_u=sigma)
# known.plotsim()
# print "Simulation successful"
# create the VAR with data X
model = var_model.VAR(X.T)
print "Model Successfully created"
# fit the model -- trying a method
results = model.fit(ic='aic', maxlags=10, trend="nc", verbose=True)
results.summary()
# for i in range(p):
# print "For i=" + str(i) +", the difference of estimated and true regression coefficients: "
# print str(A[i]-A_bar[i])
# print "Noise variances: "
# print str(sigma_bar)
def varfit(self, p, S):
return var_model.VAR(S).fit(maxlags=p,
method="ols",
ic=None,
trend="nc").params # Fit a VAR
def var(self, input, output):
model = var_model.VAR()
model.fi
model.fit(input, output)
return model
def start_params(self):
params = np.zeros(self.k_params, dtype=np.float64)
# A. Run a multivariate regression to get beta estimates
endog = self.endog.copy()
exog = self.exog.copy() if self.k_exog > 0 else None
# Although the Kalman filter can deal with missing values in endog,
# conditional sum of squares cannot
if np.any(np.isnan(endog)):
endog = endog[~np.isnan(endog)]
if exog is not None:
exog = exog[~np.isnan(endog)]
# Regression effects via OLS
exog_params = np.zeros(0)
if self.k_exog > 0:
exog_params = np.linalg.pinv(exog).dot(endog).T
endog -= np.dot(exog, exog_params.T)
# B. Run a VAR model on endog to get trend, AR parameters
ar_params = []
k_ar = self.k_ar if self.k_ar > 0 else 1
mod_ar = var_model.VAR(endog)
res_ar = mod_ar.fit(maxlags=k_ar, ic=None, trend=self.trend)
ar_params = np.array(res_ar.params.T)
if self.trend == 'c':
trend_params = ar_params[:, 0]
if self.k_ar > 0:
ar_params = ar_params[:, 1:].ravel()
else:
ar_params = []
elif self.k_ar > 0:
ar_params = ar_params.ravel()
else:
ar_params = []
endog = res_ar.resid
# Test for stationarity
if self.k_ar > 0 and self.enforce_stationarity:
coefficient_matrices = (ar_params.reshape(self.k_endog * self.k_ar,
self.k_endog).T).reshape(
self.k_endog,
self.k_endog,
self.k_ar).T
stationary = is_invertible([1] + list(-coefficient_matrices))
if not stationary:
raise ValueError(
'Non-stationary starting autoregressive'
' parameters found with `enforce_stationarity`'
' set to True.')
# C. Run a VAR model on the residuals to get MA parameters
ma_params = []
if self.k_ma > 0:
mod_ma = var_model.VAR(endog)
res_ma = mod_ma.fit(maxlags=self.k_ma, ic=None, trend='nc')
ma_params = np.array(res_ma.params.T).ravel()
# Test for invertibility
if self.enforce_invertibility:
coefficient_matrices = (ma_params.reshape(
self.k_endog * self.k_ma,
self.k_endog).T).reshape(self.k_endog, self.k_endog,
self.k_ma).T
invertible = is_invertible([1] + list(-coefficient_matrices))
if not invertible:
raise ValueError(
'Non-invertible starting moving-average'
' parameters found with `enforce_stationarity`'
' set to True.')
# 1. Intercept terms
if self.trend == 'c':
params[self._params_trend] = trend_params
# 2. AR terms
params[self._params_ar] = ar_params
# 3. MA terms
params[self._params_ma] = ma_params
# 4. Regression terms
if self.mle_regression:
params[self._params_regression] = exog_params.ravel()
# 5. State covariance terms
if self.error_cov_type == 'diagonal':
params[self._params_state_cov] = res_ar.sigma_u.diagonal()
elif self.error_cov_type == 'unstructured':
cov_factor = np.linalg.cholesky(res_ar.sigma_u)
params[self._params_state_cov] = (
cov_factor[self._idx_lower_state_cov].ravel())
# 5. Measurement error variance terms
if self.measurement_error:
if self.k_ma > 0:
params[self._params_obs_cov] = res_ma.sigma_u.diagonal()
else:
params[self._params_obs_cov] = res_ar.sigma_u.diagonal()
return params
def var_network(data, connections, weightType, order, n_fft=None):
"""
Builds a networkx graph using connectivity measurements
derived from vector autoregressive models (VAR)
Parameters
----------
data : ndarray, shape (n, N)
iEEG data with N channels and n samples
connections : list
list of either (i) integers
the integers are the channels that will become nodes
and the graph will be complete
or (ii) length 2 lists of integers
the integers correspond to directed edges
weightType: str
string to indicate the connectivity measurement used
see build_network for more details
order: int
VAR model order
n_fft: int
length of FFT in PDC, DTF computations
Returns
-------
G : a weighted networkx graph
"""
# Notes:
# 1) Data is centered and scaled --> other transformations?
# 2) Do we want to pass parameters for these transformations?
# check that n_fft is supplied when required
if weightType == "directed_transfer_function" or weightType == "partial_directed_coherence":
if n_fft is None:
raise AttributeError("n_fft is not supplied")
# get parameters
n, N = data.shape # N : number of channels, n: number of observations
# normalize the channels
d_mean = np.reshape(np.mean(data, axis=0), (1, N))
d_std = np.reshape(np.std(data, axis=0), (1, N))
data = (data - d_mean) / d_std
# fit MVAR and obtain coefficients
model = var_model.VAR(data)
mvar_fit = model.fit(order)
A = mvar_fit.coefs
sigma = np.diagonal(mvar_fit.sigma_u_mle)
# compute connectivity measurement
if weightType == "directed_transfer_function":
W, freqs = DTF(A=A, sigma=sigma, n_fft=n_fft)
keyword = "dtf"
elif weightType == "partial_directed_coherence":
W, freqs = PDC(A=A, n_fft=n_fft)
keyword = "pdc"
elif weightType == "granger_causality":
# granger causality code from statsmodels
keyword = "gc"
# create directed graph
G = nx.DiGraph()
# create an edge list from connections
if type(connections[0]) is list:
edges = connections
elif type(connections[0]) is int:
edges = []
for node1 in connections:
for node2 in connections:
if node1 != node2:
edges.append([node1, node2])
# build the graph with edge weights
G = nx.DiGraph()
for edge in edges:
attr = {keyword: W[edge[0], edge[1]]}
G.add_edge(edge[0], edge[1], attr)
return G
def df_granger(df, maxlags=10, test='F-test'):
ts = df.values
VAR_model = var_model.VAR(ts)
results = VAR_model.fit(ic='aic', maxlags=maxlags)
return results
def multi_dim_granger(X_ts, Y_ts, maxlags=5, test='F-test'):
ts = np.hstack((X, Y))
VAR_model = var_model.VAR(ts)
results = VAR_model.fit(ic='aic', maxlags=maxlags)
#return var_results.coefs
return results
from statsmodels.tsa.tsatools import detrend
#%%
sub_id = 'DiAs'
proc = 'preproc'
stage = '_BP_montage_HFB_raw.fif'
picks = ['LTo1-LTo2', 'LTo5-LTo6']
sfreq = 250
tmin_crop = 0
tmax_crop = 1.75
#%%
subject = cf.Subject(sub_id)
datadir = subject.processing_stage_path(proc=proc)
visual_populations = subject.pick_visual_chan()
ts, time = hf.chan_specific_category_ts(picks,
sub_id=sub_id,
proc=proc,
sfreq=sfreq,
stage=stage,
tmin_crop=tmin_crop,
tmax_crop=tmax_crop)
(nchan, nobs, ntrials, ncat) = ts.shape
#%%
X = ts[:, :, 2, 1]
VAR = tsa.VAR(X)
#%%
lag_results = VAR.select_order(trend='n')
# https://www.statsmodels.org/dev/generated/statsmodels.tsa.stattools.periodogram.html
from statsmodels.tsa.stattools import periodogram
plt.plot(periodogram(bprice))
plt.show()
plt.plot(periodogram(bprice_1d))
# ### There is no seasonality
# #### Q13
# In[27]:
final_1d = final_date_2017.diff().dropna()
final_1d
from statsmodels.tsa.vector_ar import var_model
var = var_model.VAR(final_1d)
np.argmin(var.select_order().ics['aic'])
var_results = var.fit(maxlags=1)
var_results.summary()
# In[28]:
resid.columns
resid = pd.DataFrame(var_results.resid)
for i in resid.columns:
print(i)
resid[i].plot()
plt.show()
resid[i].plot(kind='kde')
plt.show()
def var_order_sel(data, maxorder=5000):
model = var_model.VAR(data)
order = model.select_order(maxorder)
return order['aic']
def start_params(self):
params = np.zeros(self.k_params, dtype=np.float64)
# A. Run a multivariate regression to get beta estimates
endog = pd.DataFrame(self.endog.copy())
endog = endog.interpolate()
endog = endog.fillna(method='backfill').values
exog = None
if self.k_trend > 0 and self.k_exog > 0:
exog = np.c_[self._trend_data, self.exog]
elif self.k_trend > 0:
exog = self._trend_data
elif self.k_exog > 0:
exog = self.exog
# Although the Kalman filter can deal with missing values in endog,
# conditional sum of squares cannot
if np.any(np.isnan(endog)):
mask = ~np.any(np.isnan(endog), axis=1)
endog = endog[mask]
if exog is not None:
exog = exog[mask]
# Regression and trend effects via OLS
trend_params = np.zeros(0)
exog_params = np.zeros(0)
if self.k_trend > 0 or self.k_exog > 0:
trendexog_params = np.linalg.pinv(exog).dot(endog)
endog -= np.dot(exog, trendexog_params)
if self.k_trend > 0:
trend_params = trendexog_params[:self.k_trend].T
if self.k_endog > 0:
exog_params = trendexog_params[self.k_trend:].T
# B. Run a VAR model on endog to get trend, AR parameters
ar_params = []
k_ar = self.k_ar if self.k_ar > 0 else 1
mod_ar = var_model.VAR(endog)
res_ar = mod_ar.fit(maxlags=k_ar, ic=None, trend='nc')
if self.k_ar > 0:
ar_params = np.array(res_ar.params).T.ravel()
endog = res_ar.resid
# Test for stationarity
if self.k_ar > 0 and self.enforce_stationarity:
coefficient_matrices = (ar_params.reshape(self.k_endog * self.k_ar,
self.k_endog).T).reshape(
self.k_endog,
self.k_endog,
self.k_ar).T
stationary = is_invertible([1] + list(-coefficient_matrices))
if not stationary:
warn('Non-stationary starting autoregressive parameters'
' found. Using zeros as starting parameters.')
ar_params *= 0
# C. Run a VAR model on the residuals to get MA parameters
ma_params = []
if self.k_ma > 0:
mod_ma = var_model.VAR(endog)
res_ma = mod_ma.fit(maxlags=self.k_ma, ic=None, trend='nc')
ma_params = np.array(res_ma.params.T).ravel()
# Test for invertibility
if self.enforce_invertibility:
coefficient_matrices = (ma_params.reshape(
self.k_endog * self.k_ma,
self.k_endog).T).reshape(self.k_endog, self.k_endog,
self.k_ma).T
invertible = is_invertible([1] + list(-coefficient_matrices))
if not invertible:
warn('Non-stationary starting moving-average parameters'
' found. Using zeros as starting parameters.')
ma_params *= 0
# Transform trend / exog params from mean form to intercept form
if self.k_ar > 0 and self.k_trend > 0 or self.mle_regression:
coefficient_matrices = (ar_params.reshape(self.k_endog * self.k_ar,
self.k_endog).T).reshape(
self.k_endog,
self.k_endog,
self.k_ar).T
tmp = np.eye(self.k_endog) - np.sum(coefficient_matrices, axis=0)
if self.k_trend > 0:
trend_params = np.dot(tmp, trend_params)
if self.mle_regression > 0:
exog_params = np.dot(tmp, exog_params)
# 1. Intercept terms
if self.k_trend > 0:
params[self._params_trend] = trend_params.ravel()
# 2. AR terms
if self.k_ar > 0:
params[self._params_ar] = ar_params
# 3. MA terms
if self.k_ma > 0:
params[self._params_ma] = ma_params
# 4. Regression terms
if self.mle_regression:
params[self._params_regression] = exog_params.ravel()
# 5. State covariance terms
if self.error_cov_type == 'diagonal':
params[self._params_state_cov] = res_ar.sigma_u.diagonal()
elif self.error_cov_type == 'unstructured':
cov_factor = np.linalg.cholesky(res_ar.sigma_u)
params[self._params_state_cov] = (
cov_factor[self._idx_lower_state_cov].ravel())
# 5. Measurement error variance terms
if self.measurement_error:
if self.k_ma > 0:
params[self._params_obs_cov] = res_ma.sigma_u.diagonal()
else:
params[self._params_obs_cov] = res_ar.sigma_u.diagonal()
return params
def model_selection(method, data=None, n_HN=None, CV_name=None, CV_value=None):
"""Select model instance from scikit-learn library.
Parameters
----------
method : str
model type, options: NB' (Naive-Bayes),'SVM','NN' (neural net), 'Tree','Forest','kNN','Logit','OLS','VAR'
suffix: 'rgr' : regression problem, 'clf' : classification problem
NB only takes clf, No suffix for Logit, OLS and 'VAR'
data : numpy.array, optional (Default value = None)
needs to be given if method=='VAR' (from 'statsmodels', not 'scikit-learn').
n_HN : int, optional (Default value = None)
number of neurons in hidden layer (only needed for neural networks)
CV_name : str, optional (Default value = None, no cross-validation)
name of cross-validation parameter.
Note: default and cross-validated model require to modify the source code below.
CV_value : value, optional (Default value = None)
value of CV_name, if not None.
Returns
-------
model : scikit-learn model instance (VAR from statsmodels)
"""
# check if model choice is valid
valid_methods = ['NN-rgr', 'NN-clf', 'Tree-rgr', 'Tree-clf', 'Forest-rgr', 'Forest-clf', \
'SVM-rgr', 'SVM-clf', 'kNN-rgr', 'kNN-clf', 'NB-clf', 'OLS', 'Logit', 'VAR']
if not method in valid_methods:
raise ValueError("Invalid method: '{0}' not supported.".format(method))
# select model
else:
if method == 'NN-rgr': # ONLY WORKING with scikit-learn >= 0.18
# create and train network
if CV_name == None:
model = skl_nn.MLPRegressor(hidden_layer_sizes=(n_HN, n_HN),
alpha=.001,
activation='relu',
solver='lbfgs')
else:
exec('model = skl_nn.MLPRegressor(' + CV_name + '=' + str(CV_value) + \
',hidden_layer_sizes=((n_col-1),(n_col-1)),activation="relu",solver="lbfgs")')
elif method == 'NN-clf': # ONLY WORKING with scikit-learn >= 0.18
# create and train network
if CV_name == None:
model = skl_nn.MLPClassifier(hidden_layer_sizes=n_HN,
alpha=2.,
activation='logistic',
solver='lbfgs')
else:
exec('model = skl_nn.MLPClassifier(' + CV_name + '=' + str(CV_value) + \
',hidden_layer_sizes=(n_col-1),activation="logistic",solver="lbfgs")')
elif method == 'Tree-rgr':
if CV_name == None:
model = skl_tree.DecisionTreeRegressor(max_features='sqrt',
max_depth=5)
else:
exec('model = skl_tree.DecisionTreeRegressor(' + CV_name +
'=' + str(CV_value) + ',max_features="sqrt")')
elif method == 'Tree-clf':
if CV_name == None:
model = skl_tree.DecisionTreeClassifier(max_depth=8)
else:
exec('model = skl_tree.DecisionTreeClassifier(' + CV_name +
'=' + str(CV_value) + ')') # e.g. 'max_depth'
elif method == 'Forest-rgr':
if CV_name == None:
model = skl_ens.RandomForestRegressor(
200, max_features='sqrt', max_depth=11) # 7 best for CPI
else:
exec('model = skl_ens.RandomForestRegressor(200,' + CV_name +
'=' + str(CV_value) + ',max_depth=11)')
elif method == 'Forest-clf':
if CV_name == None:
model = skl_ens.RandomForestClassifier(200, max_depth=9, \
criterion='entropy', max_features='sqrt')
else:
exec('model = skl_ens.RandomForestClassifier(200,' + CV_name +
'=' + str(CV_value) + ',criterion="entropy")')
elif method == 'SVM-rgr':
if CV_name == None:
model = skl_svm.SVR(C=50, gamma=0.001, epsilon=0.2)
else:
exec(
'model = skl_svm.SVR(' + CV_name + '=' + str(CV_value) +
',epsilon=0.2,gamma=0.001)') # change for gamma/epsilon CV
elif method == 'SVM-clf':
if CV_name == None:
model = skl_svm.SVC(C=1e3, gamma=1)
else:
exec('model = skl_svm.SVC(C=1e3,' + CV_name + '=' +
str(CV_value) + ')')
elif method == 'kNN-rgr':
if CV_name == None:
model = skl_neigh.KNeighborsRegressor(n_neighbors=2, p=1)
else:
exec('model = skl_neigh.KNeighborsRegressor(' + CV_name + '=' +
str(CV_value) + ',p=1)') # e.g. 'n_neighbors'
elif method == 'kNN-clf':
if CV_name == None:
model = skl_neigh.KNeighborsClassifier(n_neighbors=5, p=1)
else:
exec('model = skl_neigh.KNeighborsClassifier(n_neighbors=3,' +
CV_name + '=' + str(CV_value) + ')') # e.g. 'n_neighbors'
elif method == 'NB-clf':
if CV_name == None:
model = skl_NB.GaussianNB()
else:
exec(
'model = skl_NB.MultinomialNB(' + CV_name + '=' +
str(CV_value) + ')'
) # e.g. 'alpha' smoothing parameter (0 for no smoothing).
elif method == 'OLS':
if CV_name == None:
model = skl_lin.Ridge(alpha=10)
else:
exec('model = skl_lin.Ridge(' + CV_name + '=' + str(CV_value) +
')')
elif method == 'Logit':
if CV_name == None:
model = skl_lin.logistic.LogisticRegression(C=0.01)
else:
exec("model = skl_lin.logistic.LogisticRegression(" + CV_name +
"=" + str(CV_value) + ",solver='liblinear')")
elif method == 'VAR':
model = sm_vars.VAR(data)
return model
