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, 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
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 = []
start_loss, _ = compute_lasso(XTrain_, YTrain_, XVal_, YVal_, score="mean_squared_error", 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]
scoring = "mean_squared_error"
folder = "ENEL_2014/"
ext = ".npz"
file_cross_val = folder+file_name+ext
results_cross_val = Result(file_cross_val, "lasso")
##get transformed data
XTrain, XTest = results_cross_val.extract_data_transf()
_,YTrain,_, YTest = results_cross_val.extract_train_test()
### centratura dei dati
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)
##ranking
verbose = True
dict_ = results_cross_val.extract_dict()
weights_data = results_cross_val.extract_weights()
index_mse = len(weights_data)-1
weights_data = weights_data[index_mse]
final_weights = np.zeros(len(dict_.keys()))
keys_ = np.array((list)(dict_.keys())).astype("int64")
for key in keys_:
