if score=="r2_score":
score_f = r2_score
scoring = "r2"
else:
score_f = mean_squared_error
scoring = "mean_squared_error"
verbose = True
###compute ranking
weights_data = results.extract_weights()
index_mse = len(weights_data) - 1
weights_data = weights_data[index_mse]
weights = assign_weights(weights_data.copy())
keys_ = np.array(list(dict_.keys())).astype("int64")
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 = []
index_mse = len(weights_data)-1
weights_data = weights_data[index_mse]
ordered_final_weights = np.argsort(weights_data)[::-1]
if verbose:
print("-------------")
print("ranking of the featues:", ordered_final_weights)
print("-------------")
###compute LASSO
#resultsData = Result(file_data,"lasso")
ordered_indexes = ordered_final_weights
indexes = ordered_final_weights[:iter].astype("int64")
weights = assign_weights(weights_data[indexes].copy())
XTrain_current, XTest_current = get_current_data(XTrain, XTest,indexes)
###compute LASSO
if compute_lasso_current:
new_loss, beta = compute_lasso(XTrain_current, YTrain, XTest_current, YTest, score=score)
beta = np.abs(beta[:, 0])
beta_indexes,beta_ordered = get_beta_div_zeros(beta)
print("loss insieme ridotto", new_loss)
print(indexes[beta_indexes])
model = Shooting(weights)
lasso = LASSOEstimator(model)
values_TM = np.array([[24,281], [24,214]])
#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 = []
#if verbose:
# print("loss LASSO test", new_loss)
# print("------------------")
###recompute weights
if weights_all:
weights = assign_weights(weights_data.copy())
weights = weights[indexes_beta]
else:
weights = assign_weights(weights_data.copy()[indexes_beta])
XTrain_current, XTest_current = get_current_data(XTrain, XTest,indexes_beta)
###compute LASSO
print("-------------")
new_loss, beta = compute_lasso(XTrain_current, YTrain, XTest_current, YTest, score=score,values_TM = values_TM)
beta = np.abs(beta[:, 0])
beta_indexes,beta_ordered = get_beta_div_zeros(beta)
print("loss insieme ridotto", new_loss)
print(indexes_beta[beta_indexes])
print(weights_level[beta_indexes])
print("-------------")
print("ranking of the features:")
pprint(weights_level)
print("-------------")
losses = []
ordered_indexes = ordered_final_weights
losses = []
indexes_tot = []
n_features = len(ordered_final_weights)
values_TM = np.array([])
if weights_all:
weights = assign_weights(weights_data.copy())
beta_div_zeros = []
for i in range(n_features):
indexes = ordered_final_weights[:i+1].astype("int64")
indexes_tot.append(indexes)
XTrain_current, XTest_current = get_current_data(XTrain, XVal, indexes)
print("----------------------------")
print("iteration ", i)
if not weights_all:
weights_ = assign_weights(weights_data.copy()[indexes])
else:
beta_div_zeros = []
indexes_to_extract = []
ordered_indexes_div_zeros = []
current_informatives = []
alphas = np.linspace(0.0000001, end, 100)
parameters = {"alpha": alphas}
for active_set in active_sets:
ordered_values = np.sort(weights_data)[::-1][:active_set]
ordered_indexes = np.argsort(weights_data)[::-1][:active_set]
#active_indexes = extract_results(file)
weights = assign_weights(ordered_values.copy())
#weights[:70]= 0.0
#ordered_values = ordered_values[:len(weights)]
#ordered_indexes = ordered_indexes[:len(weights)]
#weights = assign_weights_ordered(ordered_values.copy())
#min_ = np.min(ordered_values)
#max_ = np.max(ordered_values)
#weights_std = (ordered_values - min_)/ (max_ - min_)
#weights = weights_std
#norm = Normalizer(norm = "max")
#weights_std = norm.fit_transform(ordered_values)[0]
#weights = 1-weights_std
