Enel_directionPowerCurveTransformation
from utility import generate_samples_dynamic_set, get_current_data, get_common_indexes, \
extract_chosen_indexes_from_start, center_test
import sys
sys.argv[1:2] = [str(x) for x in sys.argv[1:2]]
output_folder = sys.argv[1]
threshold_dir = (int)(sys.argv[2])
num_blocks = (int)(sys.argv[3])
compute_mse_current = (int)(sys.argv[4])
cycles = (int)(sys.argv[5])
max_active_set = (int)(sys.argv[6])
####load data
file = "ENEL_2014/Enel_dataset.npz"
results = Result(file, "lasso")
XTrain, YTrain, XTest, YTest = results.extract_train_test()
enel_dict = results.extract_dict()
Coord, Coord_turb, power_curve = results.extract_coords()
angles_coord_turb, _ = compute_angle(Coord, Coord_turb)
##transformation of data
X = np.concatenate((XTrain, XTest), axis=0)
enel_transf = Enel_powerCurveTransformation()
X_angle, _, _ = enel_transf.compute_angle_matrix(X)
output_dict = dict.fromkeys(np.arange(0, 49), np.array([[]], dtype="int64"))
k_levels = np.arange(0, 12).reshape([12, 1])
from Enel_utils import find_nearest_turbine
from ExtractResult import Result
from Fit import Linear_fit
from Transformation import EnelWindSpeedTransformation
import numpy as np
file_coord = np.load("ENEL_2014/Coord.npz")
Coord = file_coord["Coord"]
Coord_turb = file_coord["Coord_turb"]
power_curve = file_coord["power_curve"]
file = "ENEL_2014/Enel_dataset.npz"
results = Result(file, "lasso")
XTrain, YTrain, XTest, YTest = results.extract_train_test()
enel_transf = EnelWindSpeedTransformation()
XTrain, dict_ = enel_transf.transform(XTrain)
XTest, dict_ = EnelWindSpeedTransformation().transform(XTest)
for k in range(5,10):
print(k, "vicini")
turbine_dict = find_nearest_turbine(Coord,Coord_turb,k)
XTrain_, output_dict = enel_transf.nearest_mean_turbine(turbine_dict,dict_,XTrain, power_curve)
print(XTrain_.shape)
XTest_, _ = enel_transf.nearest_mean_turbine(turbine_dict,dict_,XTest,power_curve)
print(XTest_.shape)
Linear_fit().fitting(XTrain_, YTrain, XTest_,YTest)
from sklearn.metrics import r2_score, mean_squared_error
from ExtractResult import Result
import numpy as np
from LASSOModel import Shooting, LASSOEstimator
from Lasso_utils import compute_weightedLASSO, compute_lasso
from utility import get_current_data, assign_weights, assign_weights_ordered, \
get_beta_div_zeros, print_features_active
import sys
sys.argv[1:] = [str(x) for x in sys.argv[1:]]
file_name = sys.argv[1]
ext = ".npz"
file = "ENEL_2014/"+file_name+ext
results = Result(file, "lasso")
dict_ = results.extract_dict()
XTrain, YTrain, XVal, YVal = results.extract_train_val()
score = "mean_squared_error"
if score=="r2_score":
score_f = r2_score
scoring = "r2"
else:
score_f = mean_squared_error
scoring = "mean_squared_error"
verbose = True
file_name = sys.argv[1]
compute_lasso_current = 1
score = "mean_squared_error"
if score=="r2_score":
score_f = r2_score
scoring = "r2"
else:
score_f = mean_squared_error
scoring = "mean_squared_error"
ext = ".npz"
file_cross_val = file_name+ext
fine_name_weights = file_name+"ranking"+ext
results_cross_val = Result(file_cross_val, "lasso")
results_weighted_lasso = Result(fine_name_weights, "lasso")
mses = results_weighted_lasso.extract_mses()
mses_int = list(map(int, mses))
iter = np.argmin(mses_int)
print ("iter chosen:",iter, "with mse:",mses_int[iter])
print("--------------")
indexes_beta = results_weighted_lasso.extract_beta_div_zeros()[iter]
##get transformed data
XTrain, XTest = results_cross_val.extract_data_transf()
_,YTrain,_, YTest = results_cross_val.extract_train_test()
### centratura dei dati
compute_lasso_current = False
score = "mean_squared_error"
if score=="r2_score":
score_f = r2_score
scoring = "r2"
else:
score_f = mean_squared_error
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()
print(sys.argv[1])
sys.argv[1:] = [int(x) for x in sys.argv[1:]]
n_samples = sys.argv[1]
print("n_samples", n_samples)
original_features = sys.argv[2]
print("original_features", original_features)
transformation = F2()
print("function", transformation)
end = sys.argv[3]
print("lambda_max", end)
verbose = True
file = "nonLinearDataset/"+transformation.__class__.__name__+"/test"+transformation.__class__.__name__+"num_blocks_modified1000num_samples"+str(n_samples)+"n_features"+str(original_features)+"dynamic_set.npz"
results = Result(file, "lasso")
XTrain, YTrain, XTest, YTest,mses = results.extract_data()
#dict_ = results.extract_dict()
weights_data = results.extract_weights()
informative_indexes = results.extract_informative()
print (informative_indexes)
n_features = XTrain.shape[1]
index_mse = len(weights_data)-1
weights_data = weights_data[index_mse]
final_weights = np.zeros(original_features)
#keys_ = np.array(dict_.keys()).astype("int64")
Enel_directionPowerCurveTransformation, Enel_turbineTransformation
from utility import generate_samples_dynamic_set, get_current_data,get_common_indexes, \
extract_chosen_indexes_from_start, center_test
import sys
sys.argv[1:2] = [str(x) for x in sys.argv[1:2]]
output_folder = sys.argv[1]
threshold_dir = (int)(sys.argv[2])
num_blocks = (int)(sys.argv[3])
compute_mse_current = (int)(sys.argv[4])
cycles = (int)(sys.argv[5])
max_active_set = (int)(sys.argv[6])
####load data
file = "ENEL_2014/Enel_dataset.npz"
results = Result(file, "lasso")
XTrain, YTrain, XTest, YTest = results.extract_train_test()
_, _, power_curve = results.extract_coords()
##transformation of data
X = np.concatenate((XTrain, XTest), axis = 0)
enel_transf = Enel_powerCurveTransformation()
X_speed,_, wind_direction = EnelWindSpeedTransformation().transform(X)
print("wind speed computed")
enel_transf = Enel_turbineTransformation()
X_transf, output_dict = enel_transf.transform(X_speed, power_curve)
print("transformation done")
file_name = sys.argv[1]
weights_all = 1
score = "mean_squared_error"
if score=="r2_score":
score_f = r2_score
scoring = "r2"
else:
score_f = mean_squared_error
scoring = "mean_squared_error"
ext = ".npz"
file_cross_val = file_name+ext
fine_name_weights = file_name+"_ranking_not_levels"+ext
results_weighted_lasso = Result(fine_name_weights, "lasso")
mses = results_weighted_lasso.extract_mses()
results_cross_val = Result(file_cross_val, "lasso")
##get transformed data
XTrain, YTrain, XTest, 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
weights_data = results_cross_val.extract_weights()
import numpy as np
import sys
from Enel_utils import find_nearest_turbine, compute_angle
from ExtractResult import Result
from Transformation import Enel_powerCurveTransformation, EnelWindSpeedTransformation, \
Enel_directionVersoPowerCurveTransformation, Enel_directionPowerCurveTransformation
sys.argv[1:3] = [str(x) for x in sys.argv[1:]]
folder_name = sys.argv[1]
filename = sys.argv[2]
compute_dict = (int)(sys.argv[3])
tot_filename = folder_name+"/"+filename
results = Result(tot_filename, "lasso")
weights_list = results.extract_weights()
mses = results.extract_mses()
XTrain_transf, _ = results.extract_data_transf()
XTrain_, YTrain_, XVal_, YVal_ = results.extract_train_val()
saved_indexes_list = results.get_saved_indexes()
XTrain_ValNoCenter, YTrainVal_noCenter, XVal_noCenter,YVal_noCenter = results.extract_train_val_no_centered()
output_dict = results.extract_dict()
file = "ENEL_2014/Enel_dataset.npz"
results = Result(file, "lasso")
XTrain, YTrain, XTest, YTest = results.extract_train_test()
X_speed,_ = EnelWindSpeedTransformation().transform(XTest)
Coord, Coord_turb, power_curve = results.extract_coords()
angles_coord_turb,verso_turb_point = compute_angle(Coord, Coord_turb)
enel_transf = Enel_powerCurveTransformation()
import numpy as np import sys from Enel_utils import find_nearest_turbine, compute_angle from ExtractResult import Result from Transformation import Enel_powerCurveTransformation, EnelWindSpeedTransformation sys.argv[1:] = [str(x) for x in sys.argv[1:]] filename = sys.argv[1] results = Result(filename, "lasso") XTrain, YTrain, XTest, YTest = results.extract_train_test() weights_list = results.extract_weights() mses = results.extract_mses() XTrain_transf, XTest_transf = results.extract_data_transf() XTrain_, YTrain_, XVal_, YVal_ = results.extract_train_val() saved_indexes_list = results.get_saved_indexes() XTrain_ValNoCenter, YTrainVal_noCenter, XVal_noCenter,YVal_noCenter = results.extract_train_val_no_centered() enel_dict = results.extract_dict() file = "ENEL_2014/Enel_dataset.npz" results = Result(file, "lasso") ##transformation of data X = np.concatenate((XTrain, XTest), axis = 0) enel_transf = Enel_powerCurveTransformation() output_dict = dict.fromkeys(np.arange(0,49),np.array([[]], dtype = "int64")) X_speed,_ = EnelWindSpeedTransformation().transform(X)
