def mapFeatures(X):
'''
MAPFEATURE Feature mapping function to polynomial features
MAPFEATURE(X1, X2) maps the two input features
to quadratic features used in the regularization exercise.
Returns a new feature array with more features, comprising of
X1, X2, X1.^2, X2.^2, X1*X2, X1*X2.^2, etc..
Inputs X1, X2 must be the same size
:param X:
:return: XTransform
'''
degree = 4
poly = PolynomialFeatures(degree)
XTransform = poly.fit_transform(X)
return XTransform
python类PolynomialFeatures()的实例源码
def fit(self, x, y=None):
if y is not None:
xdot = y
else:
xdot = self.derivative.transform(x)
if self.operators is not None:
feature_transformer = SymbolicFeatures(exponents=np.linspace(1, self.degree, self.degree), operators=self.operators)
else:
feature_transformer = PolynomialFeatures(degree=self.degree, include_bias=False)
steps = [("features", feature_transformer),
("model", STRidge(alpha=self.alpha, threshold=self.threshold, **self.kw))]
self.model = MultiOutputRegressor(Pipeline(steps), n_jobs=self.n_jobs)
self.model.fit(x, xdot)
self.n_input_features_ = self.model.estimators_[0].steps[0][1].n_input_features_
self.n_output_features_ = self.model.estimators_[0].steps[0][1].n_output_features_
return self
basics.model.complexity.py 文件源码
项目：microbiome-summer-school-2017
作者: aldro61
项目源码
文件源码
阅读 24
收藏 0
点赞 0
评论 0
def fit_linear_regression(X, y, degree):
return Pipeline([("polynomial_features", PolynomialFeatures(degree=degree,
include_bias=False)),
("linear_regression", LinearRegression())]
).fit(X, y)
def send_data(self):
if self.data is not None:
attributes = self.x_var_model[self.x_var_index]
class_var = self.y_var_model[self.y_var_index]
data_table = Table(
Domain([attributes], class_vars=[class_var]), self.data)
polyfeatures = skl_preprocessing.PolynomialFeatures(
int(self.polynomialexpansion))
valid_mask = ~np.isnan(data_table.X).any(axis=1)
x = data_table.X[valid_mask]
x = polyfeatures.fit_transform(x)
x_label = data_table.domain.attributes[0].name
out_array = np.concatenate((x, data_table.Y[np.newaxis].T[valid_mask]), axis=1)
out_domain = Domain(
[ContinuousVariable("1")] + ([data_table.domain.attributes[0]]
if self.polynomialexpansion > 0
else []) +
[ContinuousVariable("{}^{}".format(x_label, i))
for i in range(2, int(self.polynomialexpansion) + 1)], class_vars=[class_var])
self.Outputs.data.send(Table(out_domain, out_array))
return
self.Outputs.data.send(None)
def get_polynomials(features, poly_degree):
r"""Generate interactions that are products of distinct features.
Parameters
----------
features : pandas.DataFrame
Dataframe containing the features for generating interactions.
poly_degree : int
The degree of the polynomial features.
Returns
-------
poly_features : numpy array
The interaction features only.
References
----------
You can find more information on polynomial interactions here [POLY]_.
.. [POLY] http://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.PolynomialFeatures.html
"""
polyf = PolynomialFeatures(interaction_only=True,
degree=poly_degree,
include_bias=False)
poly_features = polyf.fit_transform(features)
return poly_features
#
# Function get_text_features
#
def scaled_pipelines():
# Model parameters
# RANSAC parameters
# 500 max trials takes 90s
ransac_kwargs = {
'max_trials': 1000,
'min_samples': 5000,
'loss': 'absolute_loss',
'residual_threshold': 2.0,
'random_state': _RANDOM_STATE,
}
# Ridge CV parameters
alphas = [.01, .1, 1, 10]
# Model instances
model_steps = [
LinearRegression(),
# [PolynomialFeatures(degree=2), LinearRegression()],
# [PolynomialFeatures(degree=3), LinearRegression()],
# RANSACRegressor(base_estimator=LinearRegression(), **ransac_kwargs),
# RANSACRegressor with polynomial regression?
# RidgeCV(alphas=alphas),
# LassoCV(), # Alphas set automatically by default
# ElasticNetCV(l1_ratio=0.5), # Same as default
# [PolynomialFeatures(degree=2), ElasticNetCV(l1_ratio=0.5)],
# SGDRegressor(),
]
# Pipelines
pipelines = []
for m in model_steps:
# Steps
common_steps = [
StandardScaler(),
PCA(**_PCA_KWARGS)
]
model_steps = m if isinstance(m, list) else [m]
steps = common_steps + model_steps
pipelines.append(make_pipeline(*steps))
return pipelines
def get_models4ensamble(conf):
models = []
#models = [RFRModel(conf), DLModel(conf), LRModel(conf)]
#models = [LRModel(conf)]
# see http://scikit-learn.org/stable/modules/linear_model.html
#0 was too big to run with depth set to 1, and 1 was overfitting a bit
if conf.command == 1:
xgb_params = {"objective": "reg:linear", "booster":"gbtree", "max_depth":3, "eta":0.1, "min_child_weight":5,
"subsample":0.5, "nthread":4, "colsample_bytree":0.5, "num_parallel_tree":1, 'gamma':0}
else:
xgb_params = {"objective": "reg:linear", "booster":"gbtree", "max_depth":10, "eta":0.1, "min_child_weight":8,
"subsample":0.5, "nthread":4, "colsample_bytree":0.5, "num_parallel_tree":1, 'gamma':0}
#xgb_params = {"objective": "reg:linear", "booster":"gbtree", "max_depth":10, "eta":0.1, "min_child_weight":8,
# "subsample":0.5, "nthread":4, "colsample_bytree":0.5, "num_parallel_tree":1, 'gamma':0}
models = [
#DLModel(conf),
#LRModel(conf, model=linear_model.BayesianRidge()),
#LRModel(conf, model=linear_model.LassoLars(alpha=.1)),
#LRModel(conf, model=linear_model.Lasso(alpha = 0.1)),
#LRModel(conf, model=Pipeline([('poly', PolynomialFeatures(degree=3)),
#LRModel(conf, model=linear_model.Ridge (alpha = .5))
# ('linear', LinearRegression(fit_intercept=False))])),
XGBoostModel(conf, xgb_params, use_cv=True),
LRModel(conf, model=linear_model.Lasso(alpha = 0.3)),
RFRModel(conf, RandomForestRegressor(oob_score=True, n_jobs=4)),
#LRModel(conf, model=linear_model.Lasso(alpha = 0.2)),
ETRModel(conf, model=ExtraTreesRegressor(n_jobs=4)),
#AdaBoostRModel(conf, model=AdaBoostRegressor(loss='square'))
]
return models
#return [XGBoostModel(conf, xgb_params, use_cv=True)]
def polynomial(self, X, deg=1):
return PolynomialFeatures(deg).fit_transform(X)
def Identified_Model(y, t, library, estimator) :
'''
Simulates the model from Sparse identification.
Inputs
------
library: library object used in the sparse identification
(e.g. poly_lib = PolynomialFeatures(degree=3) )
estimator: estimator object obtained from the sparse identification
Output
------
dy : numpy array object containing the derivatives evaluated using the
model identified from sparse regression.
'''
dy = np.zeros_like(y)
lib = library.fit_transform(y.reshape(1,-1))
Theta = block_diag(lib, lib, lib)
dy = Theta.dot(estimator.coef_)
return dy
def feature_transform(X, mode='polynomial', degree=1):
poly = PolynomialFeatures(degree)
process_X = poly.fit_transform(X)
if mode == 'legendre':
lege = legendre(degree)
process_X = lege(process_X)
return process_X
def fit_twosls(x, z, t, y):
'''
Two stage least squares with polynomial basis function.
'''
params = dict(poly__degree=range(1,4),
ridge__alpha=np.logspace(-5, 5, 11))
pipe = Pipeline([('poly', PolynomialFeatures()),
('ridge', Ridge())])
stage_1 = GridSearchCV(pipe, param_grid=params, cv=5)
if z.shape[1] > 0:
X = np.concatenate([x,z], axis=1)
else:
X = z
stage_1.fit(X,t)
t_hat = stage_1.predict(X)
print("First stage paramers: " + str(stage_1.best_params_ ))
pipe2 = Pipeline([('poly', PolynomialFeatures()),
('ridge', Ridge())])
stage_2 = GridSearchCV(pipe2, param_grid=params, cv=5)
X2 = np.concatenate([x,t_hat], axis=1)
stage_2.fit(X2, y)
print("Best in sample score: %f" % stage_2.score(X2, y))
print("Second stage paramers: " + str(stage_2.best_params_ ))
def g_hat(x,z,t):
X_new = np.concatenate([x, t], axis=1)
return stage_2.predict(X_new)
return g_hat
def measure(y):
x=np.linspace(1,183,183)
y_ex=[]
y_ex=np.array(y_ex)
pred=Pipeline([('poly',PolynomialFeatures(10)),
('linear',LinearRegression(fit_intercept=False))])
pred.fit(x[:,np.newaxis],y)
y_ex=pred.predict(x[:,np.newaxis])
t=comp(y_ex,y)
return t
def fit(self, X, y):
sdim, fdim = X.shape
for i in range(self.n_estimators):
ridge = Ridge(alpha=self.alpha, normalize=self.normalize, random_state=self.random_state)
fidx = self._random_feature_idx(fdim, self.random_state+i*100)
sidx = self._random_sample_idx(sdim, self.random_state+i*10)
X_tmp = X[sidx][:,fidx]
if self.poly:
X_tmp = PolynomialFeatures(degree=2).fit_transform(X_tmp)[:,1:]
ridge.fit(X_tmp, y[sidx])
self.ridge_list[i] = ridge
self.feature_idx_list[i] = fidx
return self
def predict(self, X):
y_pred = np.zeros((X.shape[0], self.n_estimators))
for i in range(self.n_estimators):
fidx = self.feature_idx_list[i]
ridge = self.ridge_list[i]
X_tmp = X[:,fidx]
if self.poly:
X_tmp = PolynomialFeatures(degree=2).fit_transform(X_tmp)[:,1:]
y_pred[:,i] = ridge.predict(X_tmp)
y_pred = np.mean(y_pred, axis=1)
return y_pred
def gen_features(train, y, test):
ntrain = len(train)
df_all = pd.concat([train, test])
poly = preprocessing.PolynomialFeatures(degree=3)
dpoly = poly.fit_transform(df_all)
df_all['ap_diff'] = df_all.ap_hi - df_all.ap_lo
h = df_all['height'] / 100
df_all['BWI'] = df_all['weight'] / (h * h)
df_all['bad_bwi'] = (df_all.BWI > 60).values * 1 + (df_all.BWI < 10).values * 1
df_all['bad_height'] = (df_all.height < 130).values * 1
df_all['bad_weight'] = (df_all.weight + 120 < df_all.height).values * 1
df_all['bad_ap_hi'] = 0
df_all.ix[(df_all.ap_hi < 80).values + (df_all.ap_hi > 220).values, 'bad_ap_hi'] = 1
df_all['bad_ap_lo'] = 0
df_all.ix[(df_all.ap_lo < 40).values + (df_all.ap_lo > 200).values, 'bad_ap_lo'] = 1
df_all['has_bad_data'] = (df_all.bad_bwi + df_all.bad_height + df_all.bad_weight + df_all.bad_ap_hi + df_all.bad_ap_lo) > 0
return df_all[:ntrain].reindex(), y, df_all[ntrain:].reindex()
def multireg(self,Xtrain,ytrain, Xtest, ytest):
self.normalize(Xtrain)
'''
# polynomial try
poly = PolynomialFeatures(degree=2)
Xtrain = poly.fit_transform(Xtrain)
Xtest = poly.fit_transform(Xtest)
'''
# normal clf fit
clf = linear_model.LinearRegression()
clf.fit (Xtrain, ytrain)
coeffients = clf.coef_
print "coefficients:", coeffients
print "intercept:", clf.intercept_
print "train score", clf.score(Xtrain,ytrain)
print "test score", clf.score(Xtest,ytest)
# manual calculate train accuracy
train_results = clf.predict(Xtrain)
print "first x:", Xtrain[0]
print "first result:", train_results[0]
correct = 0
for i in range(len(train_results)):
if round(train_results[i], 1) == round(ytrain[i], 1):
correct += 1
accuracy = correct * 1.0 / len(ytrain)
print "train accuracy: ", accuracy * 100, "%"
# cross validation
score = cross_validation.cross_val_score(clf, Xtrain, ytrain, scoring='mean_squared_error', cv = 5)
print "cross validation score: ", score
predict = cross_val_predict(clf, Xtrain, ytrain, cv = 5)
correct = 0
for i in range(len(predict)):
if round(predict[i], 1) == round(ytrain[i], 1):
correct += 1
accuracy = correct * 1.0 / len(ytrain)
print "cross validation accuracy: ", accuracy * 100, "%"
# manual calculate test accuracy
self.normalize(Xtest)
results = clf.predict(Xtest)
correct = 0
for i in range(len(results)):
if round(results[i], 1) == round(ytest[i], 1):
correct += 1
accuracy = correct * 1.0 / len(ytest)
print "test accuracy: ", accuracy * 100, "%"
return coeffients
Qfunction_approx.py 文件源码
项目：reinforcement-learning-market-microstructure
作者: jacobkahn
项目源码
文件源码
阅读 29
收藏 0
点赞 0
评论 0
def __init__(self, T, L, backup):
self.backup = backup
self.T = T
self.L = L
self.pre_process = PolynomialFeatures(degree=2, include_bias=False)
if self.backup['name'] == 'sampling':
self.Q = linear_model.SGDRegressor(loss='huber', penalty='l2', learning_rate='invscaling', eta0=0.1, power_t=0.25, warm_start=False)
elif self.backup['name'] == 'doubleQ':
self.Q_1 = linear_model.SGDRegressor(loss='huber', penalty='l2', learning_rate='invscaling', eta0=0.1, power_t=0.25, warm_start=False)
self.Q_2 = linear_model.SGDRegressor(loss='huber', penalty='l2', learning_rate='invscaling', eta0=0.1, power_t=0.25, warm_start=False)
elif self.backup['name'] == 'replay buffer':
self.Q = linear_model.SGDRegressor(loss='huber', penalty='l2', learning_rate='invscaling', eta0=0.1, power_t=0.25, warm_start=False)
self.buff = []
else:
print "Illegal Backup Type"
def transform_pf(data, degree=2):
PF = PolynomialFeatures(degree=degree)
pf = PF.fit_transform(data)
# print pf.shape
return pf
# ???????? max min sum std mean median
def fitJA(j, start_date_rank):
pltf.clf()
p = artists_play_inday[j]
p = p[start_date_rank:]
print p
apcount = [0] * (183 - start_date_rank)
apdate = range(start_date_rank, 183)
for i in p:
apcount[i[1] - start_date_rank] = i[0]
print apcount
d_train = np.asarray(apdate)
c_train = np.asarray(apcount)
# create matrix versions of these arrays
D_train = d_train[:, np.newaxis]
d_test_plot = np.asarray(range(start_date_rank, 244))
D_test_plot = d_test_plot[:, np.newaxis]
pltf.scatter(d_train, c_train, label="training points")
for degree in [1,2,3]:
model = make_pipeline(PolynomialFeatures(degree), Ridge())
model.fit(D_train, c_train)
c_test_plot = model.predict(D_test_plot)
pltf.plot(d_test_plot, c_test_plot, label="degree %d" % degree)
pltf.legend(bbox_to_anchor=(0., 1.02, 1., .102), loc=3, ncol=5, mode="expand", borderaxespad=0.)
pltf.show()
def pred(degree):
predict_file_path = "./data/mars_tianchi_artist_plays_predict.csv"
fp = open(predict_file_path, 'wb')
fpwriter = csv.writer(fp, delimiter=',', quotechar='"', quoting=csv.QUOTE_NONE)
for j in range(0, 50):
p = artists_play_inday[j]
apcount = [0] * 184
apdate = range(0, 184)
for i in p:
apcount[i[1]] = i[0]
x = np.asarray(apdate)
X = x[:, np.newaxis]
y = np.asarray(apcount)
x_future = np.asarray(range(184, 245))
X_future = x_future[:, np.newaxis]
model = make_pipeline(PolynomialFeatures(degree), Ridge())
model.fit(X, y)
y_future = model.predict(X_future)
artist_id = artists_rank_to_id[j]
for idx in range(0, 61):
date = rank_to_date[x_future[idx]]
play_num = int(math.ceil(y_future[idx]))
if play_num < 0:
play_num = 0
row = [artist_id, play_num, date]
print row
fpwriter.writerow(row)
fp.close()
def pred(degree):
predict_file_path = "./data/mars_tianchi_artist_plays_predict.csv"
fp = open(predict_file_path, 'wb')
fpwriter = csv.writer(fp, delimiter=',', quotechar='"', quoting=csv.QUOTE_NONE)
for j in range(0, 50):
p = artists_play_inday[j]
apcount = [0] * 184
apdate = range(0, 184)
for i in p:
apcount[i[1]] = i[0]
x = np.asarray(apdate)
X = x[:, np.newaxis]
y = np.asarray(apcount)
x_future = np.asarray(range(184, 245))
X_future = x_future[:, np.newaxis]
model = make_pipeline(PolynomialFeatures(degree), Ridge())
model.fit(X, y)
y_future = model.predict(X_future)
artist_id = artists_rank_to_id[j]
for idx in range(0, 61):
date = rank_to_date[x_future[idx]]
play_num = int(math.ceil(y_future[idx]))
if play_num < 0:
play_num = 0
row = [artist_id, play_num, date]
print row
fpwriter.writerow(row)
fp.close()
def predDegs(degree, start_date_rank_list):
predict_file_path = "./data/mars_tianchi_artist_plays_predict.csv"
fp = open(predict_file_path, 'wb')
fpwriter = csv.writer(fp, delimiter=',', quotechar='"', quoting=csv.QUOTE_NONE)
for j in range(0, 50):
start_date_rank = start_date_rank_list[j]
p = artists_play_inday[j]
p = p[start_date_rank:]
apcount = [0] * (183 - start_date_rank)
apdate = range(start_date_rank, 183)
for i in p:
apcount[i[1] - start_date_rank] = i[0]
d_train = np.asarray(apdate)
c_train = np.asarray(apcount)
# create matrix versions of these arrays
D_train = d_train[:, np.newaxis]
d_future = np.asarray(range(184, 244))
D_future = d_future[:, np.newaxis]
model = make_pipeline(PolynomialFeatures(degree[j]), Ridge())
model.fit(D_train, c_train)
c_future = model.predict(D_future)
artist_id = artists_rank_to_id[j]
for idx in range(0, 60):
date = rank_to_date[d_future[idx]]
play_num = int(math.ceil(c_future[idx]))
if play_num < 0:
play_num = 0
row = [artist_id, play_num, date]
print row
fpwriter.writerow(row)
fp.close()
def BasicFactorRegress(inputs, window_length, mask, n_fwd_days, algo_mode=None, cross=True):
class BasicFactorRegress(CustomFactor):
# params = {'trigger_date': None, }
init = False
def __shift_mask_data(self, X, Y, n_fwd_days=1):
# Shift X to match factors at t to returns at t+n_fwd_days (we want to predict future returns after all)
shifted_X = np.roll(X, n_fwd_days, axis=0)
# Slice off rolled elements
X = shifted_X[n_fwd_days:]
Y = Y[n_fwd_days:]
n_time, n_stocks, n_factors = X.shape
# Flatten X
X = X.reshape((n_time * n_stocks, n_factors))
Y = Y.reshape((n_time * n_stocks))
return X, Y
def __get_last_values(self, input_data):
last_values = []
for dataset in input_data:
last_values.append(dataset[-1])
return np.vstack(last_values).T
def compute(self, today, assets, out, returns, *inputs):
if (not self.init):
self.clf = algo_mode
X = np.dstack(inputs) # (time, stocks, factors) ??????
Y = returns # (time, stocks)
X, Y = self.__shift_mask_data(X, Y, n_fwd_days) # n????????1???- ??factor ????
X = np.nan_to_num(X)
Y = np.nan_to_num(Y)
if cross == True:
quadratic_featurizer = PolynomialFeatures(interaction_only=True)
X = quadratic_featurizer.fit_transform(X)
self.clf.fit(X, Y)
# self.init = True
last_factor_values = self.__get_last_values(inputs)
last_factor_values = np.nan_to_num(last_factor_values)
out[:] = self.clf.predict(last_factor_values)
return BasicFactorRegress(inputs=inputs, window_length=window_length, mask=mask)
def BasicFactorRegress(inputs, window_length, mask, n_fwd_days, algo_mode=None, cross=True):
class BasicFactorRegress(CustomFactor):
# params = {'trigger_date': None, }
init = False
def __shift_mask_data(self, X, Y, n_fwd_days=1):
# Shift X to match factors at t to returns at t+n_fwd_days (we want to predict future returns after all)
shifted_X = np.roll(X, n_fwd_days, axis=0)
# Slice off rolled elements
X = shifted_X[n_fwd_days:]
Y = Y[n_fwd_days:]
n_time, n_stocks, n_factors = X.shape
# Flatten X
X = X.reshape((n_time * n_stocks, n_factors))
Y = Y.reshape((n_time * n_stocks))
return X, Y
def __get_last_values(self, input_data):
last_values = []
for dataset in input_data:
last_values.append(dataset[-1])
return np.vstack(last_values).T
def compute(self, today, assets, out, returns, *inputs):
if (not self.init):
self.clf = algo_mode
X = np.dstack(inputs) # (time, stocks, factors) ??????
Y = returns # (time, stocks)
X, Y = self.__shift_mask_data(X, Y, n_fwd_days) # n????????1???- ??factor ????
X = np.nan_to_num(X)
Y = np.nan_to_num(Y)
if cross == True:
quadratic_featurizer = PolynomialFeatures(interaction_only=True)
X = quadratic_featurizer.fit_transform(X)
self.clf.fit(X, Y)
# self.init = True
last_factor_values = self.__get_last_values(inputs)
last_factor_values = np.nan_to_num(last_factor_values)
out[:] = self.clf.predict(last_factor_values)
return BasicFactorRegress(inputs=inputs, window_length=window_length, mask=mask)
def ridge_multireg(self,Xtrain,ytrain, Xtest, ytest):
self.normalize(Xtrain)
'''
# polynomial try
poly = PolynomialFeatures(degree=2)
Xtrain = poly.fit_transform(Xtrain)
Xtest = poly.fit_transform(Xtest)
'''
# normal clf try
clf = linear_model.Ridge(alpha = 10000)
clf.fit (Xtrain, ytrain)
coeffients = clf.coef_
print "train score", clf.score(Xtrain,ytrain)
print "test score", clf.score(Xtest,ytest)
# manual calculate train accuracy
train_results = clf.predict(Xtrain)
correct = 0
for i in range(len(train_results)):
if round(train_results[i], 1) == round(ytrain[i], 1):
correct += 1
accuracy = correct * 1.0 / len(ytrain)
print "train accuracy: ", accuracy * 100, "%"
# cross validation
score = cross_validation.cross_val_score(clf, Xtrain, ytrain, scoring='mean_squared_error', cv = 5)
print "cross validation score: ", score
'''
predict = cross_val_predict(clf, Xtrain, ytrain, cv = 5)
correct = 0
for i in range(len(predict)):
if round(predict[i]) == round(ytrain[i]):
correct += 1
accuracy = correct * 1.0 / len(ytrain)
print "cross validation accuracy: ", accuracy * 100, "%"
'''
# manual calculate test accuracy
self.normalize(Xtest)
results = clf.predict(Xtest)
correct = 0
for i in range(len(results)):
if round(results[i], 1) == round(ytest[i], 1):
correct += 1
accuracy = correct * 1.0 / len(ytest)
print "test accuracy: ", accuracy * 100, "%"
return coeffients
def test(degree):
error_rate_of_artist = []
weight_of_artist = []
f_of_artist = []
F = 0.0
for j in range(0, 50):
p = artists_play_inday[j]
apcount = [0] * 184
apdate = range(0, 184)
for i in p:
apcount[i[1]] = i[0]
x = np.asarray(apdate[:122])
x_test = np.asarray(apdate[122:])
X = x[:, np.newaxis]
y = np.asarray(apcount[:122])
y_test_true = np.asarray(apcount[122:])
X_test = x_test[:, np.newaxis]
model = make_pipeline(PolynomialFeatures(degree), Ridge())
model.fit(X, y)
y_test_pred = model.predict(X_test)
error_rate_pow2_sum = 0.0
weight = 0.0
for idx in range(0, len(x_test)):
y_true = y_test_true[idx]
if y_true == 0:
y_true = 1 # deal with divide by zero
error_rate_pow2_sum += (float((int(math.ceil(y_test_pred[idx])) - y_true)) / float(y_true) )**2
weight += y_test_true[idx]
error_rate_j = math.sqrt(error_rate_pow2_sum / float(len(x_test)))
error_rate_of_artist.append(error_rate_j)
weight_j = math.sqrt(weight)
weight_of_artist.append(weight_j)
f_j = (1 - error_rate_j) * weight_j
f_of_artist.append(f_j)
F += f_j
print 'degree', degree
print 'error_rate_of_artist', error_rate_of_artist
print 'weight_of_artist', weight_of_artist
print 'f_of_artist', f_of_artist
print 'F', F
