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])
for key in np.arange(0,49):
current_values = np.arange(key*12,key*12+12).reshape([12,1])
output_dict[key] = np.concatenate((current_values,k_levels), axis = 1)
X_speed,_, wind_direction = EnelWindSpeedTransformation().transform(X)
print("wind speed computed")
enel_transf = Enel_directionPowerCurveTransformation()
X_transf,_ = enel_transf.transform(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb,threshold_dir = threshold_dir)
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])
for key in np.arange(0, 49):
current_values = np.arange(key * 12, key * 12 + 12).reshape([12, 1])
output_dict[key] = np.concatenate((current_values, k_levels), axis=1)
X_speed, _, _ = EnelWindSpeedTransformation().transform(X)
print("wind speed computed")
enel_transf = Enel_directionPowerCurveTransformation()
X_transf, dict_sample_turb = enel_transf.transform(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb,
threshold_dir=threshold_dir)
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()
sys.argv[1:] = [int(x) for x in sys.argv[1:]]
sum_until_k = sys.argv[1]
##transformation of data
k = 2
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k = k)
enel_transf = Enel_powerCurveTransformation()
XTrain_transf, output_dict = enel_transf.transform(turbine_dict, enel_dict, XTrain, power_curve,l = k, sum_until_k=sum_until_k)
XTest_transf, _ = enel_transf.transform(turbine_dict,enel_dict,XTest,power_curve, l = k, sum_until_k=sum_until_k)
##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)
new_loss, _ = compute_lasso(XTrain_, YTrain_, XVal_, YVal_,score = "mean_squared_error",values_TM = [])
print("loss", new_loss)
n_features_transf = XTrain_.shape[1]
####generation blocks
# Coord, Coord_turb = enel_dataset.extract_coordinates(folder="ENEL_2014/PSC/")
# power_curve = enel_dataset.extract_power_curve(file_name_power_curve)
# XTrain, YTrain, XTest, YTest = enel_dataset.get_data()
#np.savez("Enel_dataset.npz", XTrain = XTrain, YTrain = YTrain,XTest = XTest,YTest = YTest, Coord = Coord,Coord_turb = Coord_turb, power_curve=power_curve, dict_ = dict_)
for k in range(2,20):
print(k, "vicini")
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k)
#neight_ = nearest_mean_turbine(turbine_dict)
#XTrain, YTrain, XTest, YTest = enel_dataset.get_data()
#np.savez("Enel_dataset.npz", XTrain = XTrain, XTest = XTest, YTrain = YTrain, YTest = YTest)
enel_transf = Enel_powerCurveTransformation()
XTrain_, output_dict = enel_transf.transform(turbine_dict, enel_dict, XTrain, power_curve,k,1)
print(XTrain_.shape)
#XTest_, _ = enel_transf.transform(turbine_dict,enel_dict,XTest,power_curve,k)
XTrain_, XVal_, YTrain_, YVal_ = train_test_split(XTrain_, YTrain, test_size=0.33,random_state=0)
#YTrain = (YTrain/39)**(1./3)
#YTest = (YTest/39)**(1./3)
#XTrain = XTrain**3
#XTest = XTest**3
Linear_fit().fitting(XTrain_, YTrain_, XVal_,YVal_)
#Power_fit().fitting(XTrain, YTrain, XTest,YTest)
#Polynomial_fit().fitting(XTrain, YTrain, XTest,YTest)
from Lasso_utils import compute_mse
from Transformation import Enel_powerCurveTransformation
from utility import generate_samples_dynamic_set, get_current_data,get_common_indexes, \
extract_chosen_indexes_from_start, center_test
####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()
##transformation of data
enel_transf = Enel_powerCurveTransformation()
output_dict_ = dict.fromkeys(np.arange(0,49),np.array([[]], dtype = "int64"))
angular_coeffs = compute_angle(Coord, Coord_turb)
X = np.concatenate((XTrain, XTest), axis = 0)
enel_transf = Enel_powerCurveTransformation()
X_angle,dict_ = enel_transf.compute_angle_matrix(X)
XTrain_angle = X_angle[:XTrain.shape[0],:]
XTest_angle = X[XTrain.shape[0]:,:]
turbine_dict = create_dict_direction(X_angle,angular_coeffs)
X_transf = np.array([[]])
X_transf, output_dict_ = enel_transf.transform1(turbine_dict, enel_dict, X, power_curve, 0, X_transf,
sys.argv[1:] = [str(x) for x in sys.argv[1:]]
output_folder = sys.argv[1]
####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,verso_turb_point = compute_angle(Coord, Coord_turb)
##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_angle,x_verso,dict_ = enel_transf.compute_angle_matrix(X)
X_speed,_,_ = EnelWindSpeedTransformation().transform(X)
current_dim =0
k_levels = np.arange(0,12).reshape([12,1])
for current_dim in range(4):
for key in np.arange(0,49):
current_values = np.arange(current_dim*X_speed.shape[1]+key*12,current_dim*X_speed.shape[1]+key*12+12).reshape([12,1])
values_plus_key = np.concatenate((current_values,k_levels), axis = 1)
if output_dict[key].shape[1]==0:
output_dict[key] = values_plus_key
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")
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)
cycles = (int)(sys.argv[5])
####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, verso_turb_point = compute_angle(Coord, Coord_turb)
##transformation of data
X = np.concatenate((XTrain, XTest), axis = 0)
enel_transf = Enel_powerCurveTransformation()
X_angle,x_verso,_ = 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])
for key in np.arange(0,49):
current_values = np.arange(key*12,key*12+12).reshape([12,1])
output_dict[key] = np.concatenate((current_values,k_levels), axis = 1)
X_speed,_, wind_direction = EnelWindSpeedTransformation().transform(X)
print("wind speed computed")
enel_transf = Enel_directionPowerCurveTransformation()
X_transf,_ = enel_transf.transform_versus(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb,x_verso, verso_turb_point, threshold_dir)
print("transformation done")
XTrain, YTrain, XTest, YTest = results.extract_train_test()
dir = [180,90,45]
##transformation of data
X = np.concatenate((XTrain, XTest), axis = 0)
X_speed,_,_ = EnelWindSpeedTransformation().transform(X)
print("wind speed computed")
for directions in dir:
print("-------")
print(directions)
angles_coord_turb, verso_turb_point = compute_angle(Coord, Coord_turb, directions)
enel_transf = Enel_powerCurveTransformation()
X_angle,x_verso,dict_ = enel_transf.compute_angle_matrix(X, directions)
#np.savez("angles.npz",X_angle = X_angle, angles_coord_turb = angles_coord_turb)
print("saved angles")
output_dict = dict.fromkeys(np.arange(0,49),np.array([[]], dtype = "int64"))
k_levels = np.arange(0,12).reshape([12,1])
for key in np.arange(0,49):
current_values = np.arange(key*12,key*12+12).reshape([12,1])
output_dict[key] = np.concatenate((current_values,k_levels), axis = 1)
enel_transf = Enel_directionPowerCurveTransformation()
X_transf, matrix_turbs = enel_transf.transform(X_angle, angles_coord_turb, X_speed, power_curve, Coord, Coord_turb,threshold_dir=threshold_dir)
print("single transformation done")
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()
### save the dataset
# enel_dataset = Enel_dataset(folder_train, folder_test, label_file,centerdata=False)
# dict_ = enel_dataset.dict_
# Coord, Coord_turb = enel_dataset.extract_coordinates(folder="ENEL_2014/PSC/")
# power_curve = enel_dataset.extract_power_curve(file_name_power_curve)
# XTrain, YTrain, XTest, YTest = enel_dataset.get_data()
# np.savez("Enel_dataset.npz", XTrain = XTrain, YTrain = YTrain,XTest = XTest,YTest = YTest, Coord = Coord,Coord_turb = Coord_turb, power_curve=power_curve, dict_ = dict_)
enel_transf = Enel_powerCurveTransformation()
output_dict_ = dict.fromkeys(np.arange(0,49),np.array([[]], dtype = "int64"))
XTrain_tmp = np.array([[]])
XTest_tmp = np.array([[]])
k_1 = 1
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k_1)
XTrain_tmp, output_dict_ = enel_transf.transform(turbine_dict, enel_dict, XTrain, power_curve,0, XTrain_tmp, output_dict_)
#XTest_tmp, _ = enel_transf.transform_nearest_1(turbine_dict, enel_dict, XTest, power_curve,k_1, XTest_tmp, output_dict_.copy())
#Linear_fit().fitting(XTrain_tmp, YTrain, XTest_tmp,YTest)
#print(XTrain_tmp.shape[1])
for k in range(1,50):
print(k, "vicini")
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k)
import sys
##sys parameter
sys.argv[1:] = [int(x) for x in sys.argv[1:]]
k = sys.argv[1]
####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()
##transformation of data
enel_transf = Enel_powerCurveTransformation()
output_dict_ = dict.fromkeys(np.arange(0,49),np.array([[]], dtype = "int64"))
XTrain_transf = np.array([[]])
XTest_transf = np.array([[]])
k_1 = 1
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k_1)
XTrain_transf, output_dict_ = enel_transf.transform(turbine_dict, enel_dict, XTrain, power_curve,0, XTrain_transf, output_dict_)
XTest_transf, _ = enel_transf.transform(turbine_dict, enel_dict, XTest, power_curve,0, XTest_transf, output_dict_.copy())
for k_1 in range(1,k+1):
print(k_1, "vicini")
turbine_dict = find_turbines_nearest_points(Coord,Coord_turb,k_1)
XTrain_transf, output_dict_ = enel_transf.transform(turbine_dict, enel_dict, XTrain, power_curve,1, XTrain_transf, output_dict_)
XTest_transf, _ = enel_transf.transform(turbine_dict, enel_dict, XTest, power_curve,1, XTest_transf, output_dict_.copy())
