def fitting(self,XTrain, YTrain, XTest,YTest):
YTrain_ = np.log(YTrain)
if np.isnan(YTrain_).any():
print("log y nan")
return
YTest_ = np.log(YTest)
if np.isnan(YTest_).any():
print("log y nan")
return
XTrain_transf = np.log(XTrain)
if np.isnan(XTrain_transf):
print("log x nan")
return
XTest_transf = np.log(XTest)
if np.isnan(XTest_transf):
print("log x nan")
return
##centratura dei dati
XTrain_transf, YTrain_, X_mean, y_mean, X_std = center_data(XTrain_transf, YTrain_, fit_intercept=True, normalize = True)
XTest_transf, YTest_ = center_test(XTest_transf,YTest_,X_mean,y_mean,X_std)
new_loss,_ = compute_lasso(XTrain_transf, YTrain_, XTest_transf, YTest_, score = "r2_score")
print("loss log(y) e log(x) :", new_loss )
def fitting(self, XTrain, YTrain, XTest,YTest,values_TM ):
##center data
XTrain_, YTrain_, X_mean, y_mean, X_std = center_data(XTrain, YTrain, fit_intercept=True, normalize = True)
XTest_, YTest_ = center_test(XTest,YTest,X_mean,y_mean,X_std, normalize=True)
##compute linear lasso
new_loss, beta = compute_lasso(XTrain_, YTrain_, XTest_, YTest_,score = "r2_score", values_TM = values_TM)
print("loss lineare", new_loss)
def fitting(self,XTrain, YTrain, XTest,YTest ):
###trasformazione non lineare
for degree in range(2,3):
poly = PolynomialFeatures(degree=degree,include_bias=False)
XTrain_transf = poly.fit_transform(XTrain)
XTest_transf = poly.fit_transform(XTest)
##centratura dei dati
XTrain_transf, YTrain_, X_mean, y_mean, X_std = center_data(XTrain_transf, YTrain, fit_intercept=True, normalize = True)
XTest_transf, YTest_ = center_test(XTest_transf,YTest,X_mean,y_mean,X_std)
new_loss, _ =compute_lasso(XTrain_transf, YTrain_, XTest_transf, YTest_,score = "r2_score")
print("loss polinomio grado", str(degree),":", new_loss )
def fitting(self,XTrain, YTrain, XTest,YTest):
YTrain_ = np.sqrt(YTrain)
if np.isnan(YTrain_).any():
print("sqrt nan")
return
YTest_ = np.sqrt(YTest)
if np.isnan(YTest_).any():
print("sqrt nan")
return
XTrain_, YTrain_, X_mean, y_mean, X_std = center_data(XTrain, YTrain_, fit_intercept=True, normalize = True)
XTest_, YTest_ = center_test(XTest,YTest_,X_mean,y_mean,X_std)
new_loss, _ = compute_lasso(XTrain_, YTrain_, XTest_, YTest_,score = "r2_score")
print("loss sqrt(y) :", new_loss )
def fitting(self,XTrain, YTrain, XTest,YTest):
XTrain_transf = 1./XTrain
if np.isnan(XTrain_transf).any():
print("inverse x nan")
return
XTest_transf = 1./np.array(XTest)
if np.isnan(XTest_transf).any():
print("inverse x nan")
return
XTrain_, YTrain_, X_mean, y_mean, X_std = center_data(XTrain_transf, YTrain, fit_intercept=True, normalize = True)
XTest_, YTest_ = center_test(XTest_transf,YTest,X_mean,y_mean,X_std)
new_loss, _ =compute_lasso(XTrain_, YTrain_, XTest_, YTest_,score = "r2_score")
print("loss inverse x:", new_loss )
def fitting(self,XTrain, YTrain, XTest,YTest):
XTrain_transf = XTrain
XTest_transf = XTest
YTest_transf = Scalar_kernel().transform_y(XTest_transf,YTest)
YTrain_transf = Scalar_kernel().transform_y(XTrain_transf,YTrain)
XTrain_transf, dict_ = Scalar_kernel().transform(XTrain_transf)
XTest_transf, dict_ = Scalar_kernel().transform(XTest_transf)
##centratura dei dati
XTrain_transf, YTrain_, X_mean, y_mean, X_std = center_data(XTrain_transf, YTrain_transf, fit_intercept=True, normalize = True)
XTest_transf, YTest_ = center_test(XTest_transf,YTest_transf,X_mean,y_mean,X_std)
new_loss, _ = compute_lasso(XTrain_transf, YTrain_, XTest_transf, YTest_, score ="r2_score")
print("loss enel velocita :", new_loss )
return XTrain_transf, XTest_transf, dict_
X_transf, dict_sample_turb = enel_transf.transform(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb,
threshold_dir=threshold_dir)
print("single transformation done")
X_transf, output_dict = enel_transf.transformPerTurbineLevel(dict_sample_turb, enel_dict, X, power_curve, X_transf,
output_dict)
print("transformation per turbine done")
XTrain_transf = X_transf[:XTrain.shape[0], :]
XTest_transf = X_transf[XTrain.shape[0]:, :]
##center data
values_TM = []
start_loss, _ = compute_lasso(XTrain_, YTrain_, XVal_, YVal_, score="mean_squared_error", values_TM=values_TM)
print("loss", start_loss)
n_features_transf = XTrain_.shape[1]
####generation blocks
r = np.random.RandomState(11)
r1 = np.random.RandomState(12)
r2 = np.random.RandomState(13)
r4 = np.random.RandomState(15)
n_samples_val = XVal_.shape[0]
active_set_samples = (int)(8. / 9. * n_samples_val)
saved_indexes = []
original_features = len(keys_)
final_weights = np.zeros(original_features)
for key in keys_:
final_weights[key] += np.sum(weights_data[dict_.get(key).astype("int64")])
ordered_final_weights = np.argsort(final_weights)[::-1]
if verbose:
print("-------------")
print("ranking of the featues:", ordered_final_weights)
print("-------------")
ordered_indexes = np.argsort(weights_data)[::-1]
losses = []
new_loss, _ = compute_lasso(XTrain, YTrain, XVal, YVal, score, [])
print("new_loss", new_loss)
losses = []
indexes_tot = []
n_features = len(ordered_final_weights)
extracted_indexes = []
for i in range(n_features):
indexes = []
for k in ordered_final_weights[:i + 1]:
indexes = np.union1d(indexes, dict_.get(k))
indexes_tot.append(indexes)
indexes = np.array(indexes).astype("int64")
X_transf, dict_sample_turb = enel_transf.transform(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb, threshold_dir=threshold_dir)
print("single transformation done")
X_transf, output_dict = enel_transf.transformPerTurbine(dict_sample_turb, enel_dict, X, power_curve, X_transf,output_dict)
print("transformation per turbine done")
XTrain_transf = X_transf[:XTrain.shape[0],:]
XTest_transf = X_transf[XTrain.shape[0]:,:]
##center data
XTrain_noCenter, XVal_noCenter, YTrain_noCenter, YVal_noCenter = train_test_split(XTrain_transf, YTrain, test_size=0.33,random_state=0)
XTrain_, YTrain_, X_mean, y_mean, X_std = center_data(XTrain_noCenter, YTrain_noCenter, fit_intercept=True, normalize = True)
XVal_, YVal_ = center_test(XVal_noCenter,YVal_noCenter,X_mean,y_mean,X_std)
values_TM = []
new_loss, _ = compute_lasso(XTrain_, YTrain_, XVal_, YVal_,score = "mean_squared_error", values_TM = np.array([[24,281], [24,214]]))
print("loss", new_loss)
n_features_transf = XTrain_.shape[1]
####generation blocks
r = np.random.RandomState(11)
r1 = np.random.RandomState(12)
r2 = np.random.RandomState(13)
r4 = np.random.RandomState(15)
n_samples_val = XVal_.shape[0]
active_set_samples = (int)(8./9.*n_samples_val)
final_weights = np.zeros(len(dict_.keys()))
keys_ = np.array((list)(dict_.keys())).astype("int64")
for key in keys_:
final_weights[key] += np.sum(weights_data[dict_.get(key).astype("int64")])
ordered_final_weights = np.argsort(final_weights)[::-1]
if verbose:
print("-------------")
print("ranking of the featues:", ordered_final_weights)
print("-------------")
###compute LASSO
#resultsData = Result(file_data,"lasso")
new_loss, beta = compute_lasso(XTrain, YTrain, XTest, YTest, score = score,values_TM = values_TM)
beta = np.abs(beta[:, 0])
beta_indexes,beta_ordered = get_beta_div_zeros(beta)
real_indexes = []
ordered_indexes = np.argsort(weights_data)[::-1]
print_features_active(keys_, beta_indexes, dict_)
if verbose:
print("loss LASSO test", new_loss)
print("------------------")
keys_sel = ordered_final_weights[:iter+1]
