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]