def clutter_button_callback(attr):
if cluttered_button.active:
cluttered_button.button_type = 'success'
scatter_data.data = {'x': x[indexes], 'y': y[indexes]}
new_x = x[indexes]
new_y = y[indexes]
new_y_line = set_m.value * new_x
new_line_x = [[i, i] for i in new_x]
new_line_y = [[j, new_y_line[i]] for i, j in enumerate(new_y)]
error_points.data = dict(x=new_line_x, y=new_line_y)
error_param = error_land_data.data['x']
error_val = [utils.compute_error(new_x, new_y, i) for i in error_param]
error_land_data.data = dict(x=error_param, y=error_val)
error_plot.y_range.update(start=0, end=400)
else:
cluttered_button.button_type = 'primary'
scatter_data.data = {'x': x, 'y': y}
error_param = error_land_data.data['x']
error_val = [utils.compute_error(x, y, i) for i in error_param]
error_land_data.data = dict(x=error_param, y=error_val)
error_plot.y_range.update(start=0, end=2000)
def change_m(attr, old, new):
new_m = set_m.value
x_line = np.arange(-1, 5.1, 0.1)
y_line = new_m * x_line
line_data.data = dict(x=x_line, y=y_line)
if cluttered_button.active:
new_x = x[indexes]
new_y = y[indexes]
else:
new_x = x
new_y = y
new_y_line = set_m.value * new_x
new_line_x = [[i, i] for i in new_x]
new_line_y = [[j, new_y_line[i]] for i, j in enumerate(new_y)]
error_points.data = dict(x=new_line_x, y=new_line_y)
error_param = np.append(error_land_data.data['x'], new_m)
error_val = np.append(
error_land_data.data['y'],
utils.compute_error(new_x, new_y, new_m),
)
sort_index = np.argsort(error_param)
error_param = error_param[sort_index]
error_val = error_val[sort_index]
error_land_data.data = dict(x=error_param, y=error_val)
def run_experiment(args):
# build directory name
commit = git.Repo(search_parent_directories=True).head.object.hexsha[:10]
results_dirname = os.path.join(args["output_dir"], commit + "/")
os.makedirs(results_dirname, exist_ok=True)
# build file name
md5_fname = hashlib.md5(str(args).encode('utf-8')).hexdigest()
results_fname = os.path.join(results_dirname, md5_fname + ".jsonl")
results_file = open(results_fname, "w")
utils.set_seed(args["data_seed"])
dataset = datasets.DATASETS[args["dataset"]](dim_inv=args["dim_inv"],
dim_spu=args["dim_spu"],
n_envs=args["n_envs"])
# Oracle trained on test mode (scrambled)
train_split = "train" if args["model"] != "Oracle" else "test"
# sample the envs
envs = {}
for key_split, split in zip(("train", "validation", "test"),
(train_split, train_split, "test")):
envs[key_split] = {"keys": [], "envs": []}
for env in dataset.envs:
envs[key_split]["envs"].append(
dataset.sample(n=args["num_samples"], env=env, split=split))
envs[key_split]["keys"].append(env)
# offsetting model seed to avoid overlap with data_seed
utils.set_seed(args["model_seed"] + 1000)
# selecting model
args["num_dim"] = args["dim_inv"] + args["dim_spu"]
model = models.MODELS[args["model"]](in_features=args["num_dim"],
out_features=1,
task=dataset.task,
hparams=args["hparams"])
# update this field for printing purposes
args["hparams"] = model.hparams
# fit the dataset
model.fit(envs=envs,
num_iterations=args["num_iterations"],
callback=args["callback"])
# compute the train, validation and test errors
for split in ("train", "validation", "test"):
key = "error_" + split
for k_env, env in zip(envs[split]["keys"], envs[split]["envs"]):
args[key + "_" + k_env] = utils.compute_error(model, *env)
# write results
results_file.write(json.dumps(args))
results_file.close()
return args
def test_model(model, X, y, test_type='Test'):
logging.info('Testing model...')
predictions = model.predict(X)
err = utils.compute_error(y, predictions)
acc = 1 - err
num_total = len(y)
num_correct = int(round(acc * num_total))
num_incorrect = num_total - num_correct
logging.info('%s accuracy: %g (%d/%d)' % (test_type, acc, num_correct, num_total))
logging.info('%s error: %g (%d/%d)' % (test_type, err, num_incorrect, num_total))
return acc, err
def load_and_test(self, test_data, path=None):
pred = self.load_and_predict(test_data, path)
c_pred = pred["c"]
u_pred = pred["u"]
V_high = test_data["V_high"]
u_high = test_data["u_high"]
c_high = test_data["c_high"]
coeff_errors = []
approx_errors = []
for i in range(self.Lmax):
coeff_errors.append(
compute_error(c_high[:, :(i + 1)], c_pred[i], scale=u_high))
approx_errors.append(compute_error(u_high, u_pred[i],
scale=u_high))
return {
"c": c_pred,
"u": u_pred,
"coeff_errors": coeff_errors,
"approx_errors": approx_errors
}
def holdout_train(feats, labels, parameters):
logging.info("Start holdout training ...")
x_train,x_test,y_train,y_test = train_test_split(feats, labels, \
test_size=parameters['test_size'])
logging.debug("Dimension of training set: {}".format(x_train.shape))
clf = svm.SVR(kernel=parameters['kernel'], C=parameters['c'], \
epsilon=parameters['epsilon'], gamma=parameters['gamma'])
clf.fit(x_train, y_train)
logging.info("Holdout training is complete.")
y_pred = clf.predict(x_test)
rmse = utl.compute_error(y_pred, y_test)
logging.info("Saving the trained model on disk ...")
utl.save_model(clf, parameters['name'] + '-holdout')
return y_pred, y_test, rmse
def Newtons_method_log_barrier_feasible_init_point(f, A, constraint_inequalities,
t_path, x_0, tol,
tol_backtracking, x_ast=None, p_ast=None, maxiter=30,
gf_symbolic = None,
Hf_symbolic = None):
'''
Newton's method to numerically approximate solution of min f subject to Ax = b.
IMPORTANT: this implementation requires that initial point x_0, satisfies: Ax_0 = b
Args:
f (fun): definition of function f as lambda expression or function definition.
A (numpy ndarray): 2d numpy array of shape (m,n) defines system of constraints Ax=b.
constraints_ineq
t_path
x_0 (numpy ndarray): initial point for Newton's method. Must satisfy: Ax_0 = b
tol (float): tolerance that will halt method. Controls stopping criteria.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations
gf_symbolic (fun): definition of gradient of f. If given, no approximation is
performed via finite differences.
Hf_symbolic (fun): definition of Hessian of f. If given, no approximation is
performed via finite differences.
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
feval = f(x)
if gf_symbolic and Hf_symbolic:
gfeval = gf_symbolic(x)
Hfeval = Hf_symbolic(x)
else:
grad_Hess_log_barrier_dict = numerical_differentiation_of_logarithmic_barrier(f,x,t_path,
constraint_inequalities)
gfeval = grad_Hess_log_barrier_dict['gradient']
Hfeval = grad_Hess_log_barrier_dict['Hessian']
normgf = np.linalg.norm(gfeval)
condHf= np.linalg.cond(Hfeval)
Err_plot_aux = np.zeros(maxiter)
Err_plot_aux[iteration]=compute_error(p_ast,feval)
Err = compute_error(x_ast,x)
if (np.all(A < np.nextafter(0,1))): #A is zero matrix
system_matrix = Hfeval
rhs = -gfeval
n = x.size
p = 0
else:
if(A.ndim == 1):
p = 1
n = x.size
zero_matrix = np.zeros(p)
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack((A.reshape(1,n).T,zero_matrix)).reshape(1,n+1)[0]
else:
p,n = A.shape
zero_matrix = np.zeros((p,p))
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.column_stack((A,zero_matrix))
system_matrix = np.row_stack((first_stack,second_stack))
zero_vector = np.zeros(p)
rhs = -np.row_stack((gfeval.reshape(n,1), zero_vector.reshape(p,1))).T[0]
x_plot = np.zeros((n,maxiter))
x_plot[:,iteration] = x
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton)
w_dual_variable_estimation = dir_desc[n:(n+p)]
print('I\tNorm gfLogBarrier \tNewton Decrement\tError x_ast\tError p_ast\tline search\tCondHf')
print('{}\t\t{:0.2e}\t\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{}\t\t{:0.2e}'.format(iteration,normgf,
dec_Newton,Err,
Err_plot_aux[iteration],"---",
condHf))
stopping_criteria = dec_Newton/2
iteration+=1
while(stopping_criteria>tol and iteration < maxiter):
der_direct = -dec_Newton
t = line_search_for_log_barrier_by_backtracking(f,dir_Newton,x,t_path,
constraint_inequalities,
der_direct)
x = x + t*dir_Newton
feval = f(x)
if gf_symbolic and Hf_symbolic:
gfeval = gf_symbolic(x)
Hfeval = Hf_symbolic(x)
else:
grad_Hess_log_barrier_dict = numerical_differentiation_of_logarithmic_barrier(f,x,t_path,
constraint_inequalities)
gfeval = grad_Hess_log_barrier_dict['gradient']
Hfeval = grad_Hess_log_barrier_dict['Hessian']
if (np.all(A < np.nextafter(0,1))): #A is zero matrix
system_matrix = Hfeval
rhs = -gfeval
n = x.size
p = 0
else:
if(A.ndim == 1):
first_stack = np.column_stack((Hfeval, A.T))
else:
first_stack = np.column_stack((Hfeval, A.T))
system_matrix = np.row_stack((first_stack,second_stack))
rhs = -np.row_stack((gfeval.reshape(n,1), zero_vector.reshape(p,1))).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton)
w_dual_variable_estimation = dir_desc[n:(n+p)]
Err_plot_aux[iteration]=compute_error(p_ast,feval)
x_plot[:,iteration] = x
Err = compute_error(x_ast,x)
print('{}\t\t{:0.2e}\t\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}'.format(iteration,normgf,
dec_Newton,Err,
Err_plot_aux[iteration],t,
condHf))
stopping_criteria = dec_Newton/2
if t<tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iter_salida=iteration
iteration = maxiter - 1
iteration+=1
print('{} {:0.2e}'.format("Error of x with respect to x_ast:",Err))
print('{} {}'.format("Approximate solution:", x))
cond = Err_plot_aux > np.finfo(float).eps*10**(-2)
Err_plot = Err_plot_aux[cond]
if iteration == maxiter and t < tol_backtracking:
print("Backtracking value less than tol_backtracking, check approximation")
iteration=iter_salida
else:
if iteration == maxiter:
print("Reached maximum of iterations, check approximation")
x_plot = x_plot[:,:iteration]
return [x,iteration,Err_plot,x_plot]
def Newtons_method_log_barrier_infeasible_init_point(f, A, b,
constraint_inequalities, t_path,
x_0, nu_0, tol,
tol_backtracking, x_ast=None, p_ast=None, maxiter=30,
gf_symbolic = None,
Hf_symbolic = None):
'''
Newton's method for infeasible initial point to numerically approximate solution of min f subject to Ax = b.
Calls Newton's method for feasible initial point when reach primal feasibility given by tol.
Args:
f (fun): definition of function f as lambda expression or function definition.
A (numpy ndarray): 2d numpy array of shape (m,n) defines system of constraints Ax=b.
b (numpy ndarray or float): array that defines system of constraints Ax=b (can be a single number
if just one restriction is defined)
constraints_ineq
t_path
x_0 (numpy ndarray): initial point for Newton's method.
nu_0 (numpy ndarray or float): initial point for Newton's method.
tol (float): tolerance that will halt method. Controls stopping criteria.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations
gf_symbolic (fun): definition of gradient of f. If given, no approximation is
performed via finite differences.
Hf_symbolic (fun): definition of Hessian of f. If given, no approximation is
performed via finite differences.
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
nu = nu_0
feval = f(x)
if gf_symbolic and Hf_symbolic:
gfeval = gf_symbolic(x)
Hfeval = Hf_symbolic(x)
else:
grad_Hess_log_barrier_dict = numerical_differentiation_of_logarithmic_barrier(f,x,t_path,
constraint_inequalities)
gfeval = grad_Hess_log_barrier_dict['gradient']
Hfeval = grad_Hess_log_barrier_dict['Hessian']
normgf = np.linalg.norm(gfeval)
condHf= np.linalg.cond(Hfeval)
Err_x_ast = compute_error(x_ast,x)
Err_p_ast = compute_error(p_ast,feval)
def residual_dual(nu_fun):
if(A.ndim==1):
return gfeval + A.T*nu_fun
else:
return gfeval + A.T@nu_fun
feasibility_dual = residual_dual(nu)
if (np.all(A < np.nextafter(0,1))): #A is zero matrix
system_matrix = Hfeval
rhs = -gfeval
n = x.size
p = 0
feasibility_primal = 0
else:
if(A.ndim == 1):
p = 1
n = x.size
zero_matrix = np.zeros(p)
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack((A.reshape(1,n).T,zero_matrix)).reshape(1,n+1)[0]
else:
p,n = A.shape
zero_matrix = np.zeros((p,p))
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.column_stack((A,zero_matrix))
system_matrix = np.row_stack((first_stack,second_stack))
residual_primal = lambda x_fun: A@x_fun-b
feasibility_primal = residual_primal(x)
rhs = -np.row_stack((feasibility_dual.reshape(n,1), feasibility_primal.reshape(p,1))).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton_primal = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton_primal)
dir_Newton_dual = dir_desc[n:(n+p)]
norm_residual_eval = norm_residual(feasibility_primal,
feasibility_dual)
norm_residual_primal = np.linalg.norm(feasibility_primal)
norm_residual_dual = np.linalg.norm(feasibility_dual)
print('I\t||res_primal||\t||res_dual|| \tNewton Decrement\tError x_ast\tError p_ast\tline search\tCondHf')
print('{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{}\t\t{:0.2e}'.format(iteration,norm_residual_primal,
norm_residual_dual,
dec_Newton,Err_x_ast,
Err_p_ast,"---",
condHf))
stopping_criteria = norm_residual_primal > tol
iteration+=1
while(stopping_criteria>tol and iteration < maxiter):
der_direct = -dec_Newton
t = line_search_for_residual_by_backtracking(residual_primal, residual_dual,
dir_Newton_primal, dir_Newton_dual,
x, nu,
norm_residual_eval
)
x = x + t*dir_Newton_primal
nu = nu + t*dir_Newton_dual
feval = f(x)
if gf_symbolic:
gfeval = gf_symbolic(x)
else:
gfeval = gradient_approximation(f,x)
if Hf_symbolic:
Hfeval = Hf_symbolic(x)
else:
Hfeval = Hessian_approximation(f,x)
if(A.ndim == 1):
first_stack = np.column_stack((Hfeval, A.T))
else:
first_stack = np.column_stack((Hfeval, A.T))
system_matrix = np.row_stack((first_stack,second_stack))
feasibility_primal = residual_primal(x)
feasibility_dual = residual_dual(nu)
rhs = -np.row_stack((feasibility_dual.reshape(n,1), feasibility_primal.reshape(p,1))).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton_primal = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton_primal)
dir_Newton_dual = dir_desc[n:(n+p)]
Err_x_ast = compute_error(x_ast,x)
Err_p_ast = compute_error(p_ast,feval)
norm_residual_eval = norm_residual(feasibility_primal,
feasibility_dual)
norm_residual_primal = np.linalg.norm(feasibility_primal)
norm_residual_dual = np.linalg.norm(feasibility_dual)
print('{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}'.format(iteration,norm_residual_primal,
norm_residual_dual,
dec_Newton,Err_x_ast,
Err_p_ast,t,
condHf))
stopping_criteria = norm_residual_primal > tol
if t<tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iteration = maxiter - 1
iteration+=1
if iteration == maxiter and t < tol_backtracking:
print("Backtracking value less than tol_backtracking, try other initial point")
return [None,None,None,None]
else:
if iteration == maxiter:
print("------------------------------------------------------------")
print("------------------------------------------------------------")
print("------------------------------------------------------------")
print("Reached maximum of iterations, check primal feasibility")
print("Continuing with Newtons method for feasible initial point")
return Newtons_method_log_barrier_feasible_init_point(f,A, constraint_inequalities,
t_path, x,tol,
tol_backtracking, x_ast, p_ast,
maxiter,gf_symbolic,Hf_symbolic)
else:
print("------------------------------------------------------------")
print("------------------------------------------------------------")
print("------------------------------------------------------------")
print("Beginning Newtons method for feasible initial point")
return Newtons_method_log_barrier_feasible_init_point(f,A, constraint_inequalities,
t_path, x,tol,
tol_backtracking, x_ast, p_ast,
maxiter,gf_symbolic,Hf_symbolic)
def weather_prediction(feats, labels, parameters, masks):
''' weather prediction wrapper for solar forecast '''
# create results dictionary under each weather
sunny_results = {}
cloudy_results = {}
partly_cloudy_results = {}
# get parameters of SVR model under each weather types
if parameters['SUNNY']['para_path'] is not None:
logging.info('Loading given model on disk ...')
sunny_model = utl.restore_model(\
parameters['SUNNY']['para_path'])
else:
logging.info('Restore model on disk ...')
sunny_model = utl.restore_model(\
parameters['SUNNY']['name'] + '-grid-search')
logging.info("Sunny model loaded is {}".format(sunny_model))
if parameters['CLOUDY']['para_path'] is not None:
logging.info('Loading given model on disk ...')
cloudy_model = utl.restore_model(\
parameters['CLOUDY']['para_path'])
else:
logging.info('Restore model on disk ...')
cloudy_model = utl.restore_model(\
parameters['CLOUDY']['name'] + '-grid-search')
logging.info("Cloudy model loaded is {}".format(cloudy_model))
if parameters['PARTLY CLOUDY']['para_path'] is not None:
logging.info('Loading given model on disk ...')
partly_cloudy_model = utl.restore_model(\
parameters['PARTLY CLOUDY']['para_path'])
else:
logging.info('Restore model on disk ...')
partly_cloudy_model = utl.restore_model(\
parameters['PARTLY CLOUDY']['name'] + '-grid-search')
logging.info("Partly cloudy model loaded is {}"\
.format(partly_cloudy_model))
# perform prediction based on weather types
# sunny day
logging.info("Start performing predictions on sunny days ...")
sunny_pred = predict(feats['sunny'], sunny_model)
sunny_results['prediction'] = sunny_pred
logging.info("Weather prediction on sunny days is complete.")
# cloudy day
logging.info("Start performing predictions on cloudy days ...")
cloudy_pred = predict(feats['cloudy'], cloudy_model)
cloudy_results['prediction'] = cloudy_pred
logging.info("Weather prediction on cloudy days is complete.")
# partly cloudy day
logging.info("Start performing predictions on partly cloudy days ...")
partly_cloudy_pred = predict(feats['partly_cloudy'], partly_cloudy_model)
partly_cloudy_results['prediction'] = partly_cloudy_pred
logging.info("Weather prediction on partly cloudy days is complete.")
if labels is not None:
# computing errors
sunny_errors = utl.compute_error(sunny_pred, labels['sunny'])
sunny_results['rmse_errors'] = sunny_errors
logging.info("RMSE errors of sunny days: {}".format(sunny_errors))
cloudy_errors = utl.compute_error(cloudy_pred, labels['cloudy'])
cloudy_results['rmse_errors'] = cloudy_errors
logging.info("RMSE errors of cloudy days: {}".format(cloudy_errors))
partly_cloudy_errors = utl.compute_error(partly_cloudy_pred,\
labels['partly_cloudy'])
partly_cloudy_results['rmse_errors'] = partly_cloudy_errors
logging.info("RMSE errors of partly cloudy days: {}"\
.format(partly_cloudy_errors))
# comparison between prediction and true labels
sunny_fig = utl.compare_pred_results(sunny_pred, labels['sunny'],\
'sunny', style='k.')
cloudy_fig = utl.compare_pred_results(cloudy_pred, labels['cloudy'],\
'cloudy', style='k.')
partly_cloudy_fig = utl.compare_pred_results(partly_cloudy_pred,\
labels['partly_cloudy'], 'partly cloudy', style='k.')
preds = {'sunny': sunny_pred, 'cloudy': cloudy_pred,\
'partly_cloudy': partly_cloudy_pred}
# plot predictions and measurements
fig_pred_meas, preds_total = utl.compare_preds_labels(
preds,
labels,
masks,
)
# save fig
fig_path = parameters['SUNNY']['fig_path'] + '.png'
sunny_fig.savefig(fig_path)
fig_path = parameters['CLOUDY']['fig_path'] + '.png'
cloudy_fig.savefig(fig_path)
fig_path = parameters['PARTLY CLOUDY']['fig_path'] + '.png'
partly_cloudy_fig.savefig(fig_path)
fig_path = parameters['fig_folder'] + 'pred_vs_meas' + '.png'
partly_cloudy_fig.savefig(fig_path)
if parameters['FLAG']['show_figs']:
plt.show()
return preds_total
)
pair_plot.add_glyph(error_points, error_glyph)
# Plot error landscape
error_plot = figure(
plot_height=400,
plot_width=400,
title="Error Plots",
tools="crosshair,pan,reset,save,wheel_zoom",
x_range=[start_m - 0.5, end_m + 0.5],
y_range=[0, 50],
)
error_land_data = ColumnDataSource(data=dict(
x=[m],
y=[utils.compute_error(x, y, m)],
))
error_plot.line('x', 'y', source=error_land_data, color='red')
# Set up widgets
set_m = Slider(title='m', value=m, start=start_m, step=0.1, end=end_m)
animate_button = Button(label='► Play', button_type='primary')
cluttered_button = Toggle(label='Filter points',
button_type='primary',
width=200)
button_draw_error = Toggle(label='Draw Errors',
button_type='primary',
width=200)
reset_button = Button(label='Reset errors')
def matrix_factorization_als(train,
test,
num_features=20,
lambda_user=0.014,
lambda_item=0.575,
stop_criterion=1e-5,
max_iter=100,
min_iter=25,
verbose=False,
robust=False):
"""
Computes the matrix factorization on train data using alternating least squares
and returns RMSE computed on train and test data.
:param train: training data, sparse matrix of shape (num_items, num_users)
:param test: testing data, sparse matrix of shape (num_items, num_users)
if None, only the training part is done and the matrix factorization is returned
:param num_features: number of latent features in the factorization
:param lambda_user: size of penalization coefficient for the optimization of user features
:param lambda_item: size of penalization coefficient for the optimization of item features
:param stop_criterion: computation continues until an optimization step does not improve the error by more than
this value
:param max_iter: maximum number of iterations
:param min_iter: minimum number of iterations
:param verbose: True if user wants to print details of the computation
:param robust: True to enable robustsness against singular matrices
:return: training RMSE, testing RMSE, user_features and item_features
or user_features and item_features only if test is None
"""
change = 1
error_list = [0, 0]
num_item = train.shape[0]
num_user = train.shape[1]
# set seed
np.random.seed(988)
# init ALS
user_features, item_features = init_mf(train, num_features)
nz_items, nz_users = train.nonzero()
nz_users_indices = [nz_users[nz_items == i] for i in range(num_item)]
nz_items_indices = [nz_items[nz_users == u] for u in range(num_user)]
nz_train = list(zip(nz_items, nz_users))
# run ALS
if verbose:
print('Learning the matrix factorization using ALS...')
n_iter = 0
while change > stop_criterion and n_iter < max_iter or n_iter < min_iter:
n_iter += 1
user_features = update_user_feature(train, num_user, item_features,
lambda_user, nz_items_indices,
robust)
item_features = update_item_feature(train, num_item, user_features,
lambda_item, nz_users_indices,
robust)
error = compute_error(train, user_features, item_features, nz_train)
if False:
print("Iteration {} : RMSE on training set: {}.".format(
n_iter, error))
error_list.append(error)
change = np.fabs(error_list[-1] - error_list[-2])
if test is not None:
# evaluate the test error
nnz_row, nnz_col = test.nonzero()
nnz_test = list(zip(nnz_row, nnz_col))
test_rmse = compute_error(test, user_features, item_features, nnz_test)
if verbose:
print('Final RMSE on train data: {}'.format(error_list[-1]))
print('Final RMSE on test data: {}.'.format(test_rmse))
return error_list[-1], test_rmse, user_features, item_features
if test is None:
return error_list[-1], user_features, item_features
def matrix_factorization_sgd(train,
test,
gamma=0.01,
num_features=25,
lambda_user=0.011,
lambda_item=0.25,
num_epochs=50,
verbose=False):
"""
Computes the matrix factorization on train data using stochastic gradient descent
and returns RMSE computed on train and test data.
:param train: training data, sparse matrix of shape (num_items, num_users)
:param test: testing data, sparse matrix of shape (num_items, num_users)
if None, only the training is performed and the factorization is returned
:param gamma: size of each step of the gradient descent
:param num_features: number of latent features in the factorization
:param lambda_user: size of penalization coefficient for the optimization of user features
:param lambda_item: size of penalization coefficient for the optimization of item features
:param num_epochs: number of epochs for the optimization
:param verbose: True if user wants to print details of the computation
:return: training RMSE, testing RMSE, user_features and item_features
or user_features and item_features only if test is None
"""
errors = [0]
# set seed
np.random.seed(988)
# init matrix
user_features, item_features = init_mf(train, num_features)
# find the non-zero ratings indices
nz_row, nz_col = train.nonzero()
nz_train = list(zip(nz_row, nz_col))
if verbose:
print('Learning the matrix factorization using SGD...')
for epoch in range(num_epochs):
# shuffle the training rating indices
np.random.shuffle(nz_train)
# decrease step size
gamma /= 1.1
for d, n in nz_train:
current_item = item_features[:, d]
current_user = user_features[:, n]
error = train[d, n] - current_user.T.dot(current_item)
# gradient
item_features[:, d] += gamma * (error * current_user -
lambda_item * current_item)
user_features[:, n] += gamma * (error * current_item -
lambda_user * current_user)
rmse = compute_error(train, user_features, item_features, nz_train)
if False:
print("epoch: {}, RMSE on training set: {}.".format(
epoch + 1, rmse))
errors.append(rmse)
if test is not None:
nz_row, nz_col = test.nonzero()
nz_test = list(zip(nz_row, nz_col))
rmse = compute_error(test, user_features, item_features, nz_test)
if verbose:
print('Final RMSE on train data: {}'.format(errors[-1]))
print('Final RMSE on test data: {}.'.format(rmse))
return errors[-1], rmse, user_features, item_features
if test is None:
return errors[-1], user_features, item_features
def Newtons_method(f,
A,
x_0,
tol,
tol_backtracking,
x_ast=None,
p_ast=None,
maxiter=30):
'''
Newton's method to numerically approximate solution of min f.
Args:
f (lambda expression): definition of function f.
A (numpy ndarray): 2d numpy array of shape (m,n) defines system of constraints Ax=b.
x_0 (numpy ndarray): initial point for Newton's method.
tol (float): tolerance that will halt method. Controls stopping criteria.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
feval = f(x)
gfeval = gradient_approximation(f, x)
Hfeval = Hessian_approximation(f, x)
normgf = np.linalg.norm(gfeval)
condHf = np.linalg.cond(Hfeval)
Err_plot_aux = np.zeros(maxiter)
Err_plot_aux[iteration] = math.fabs(feval - p_ast)
Err = compute_error(x_ast, x)
if (A.ndim == 1):
m = 1
n = x.size
zero_matrix = np.zeros(1)
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack(
(A.reshape(1, n).T, zero_matrix)).reshape(1, n + 1)[0]
else:
m, n = A.shape
zero_matrix = np.zeros((m, n))
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack((A, zero_matrix))
x_plot = np.zeros((n, maxiter))
x_plot[:, iteration] = x
system_matrix = np.row_stack((first_stack, second_stack))
zero_vector = np.zeros(m)
rhs = np.row_stack((gfeval.reshape(n, 1), zero_vector)).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton = dir_desc[0:n]
dec_Newton = dir_Newton.dot(Hfeval @ dir_Newton)
w_dual_variable_estimation = -dir_desc[n:(n + m)]
dir_Newton = -dir_desc[0:n]
print(
'I Normgf Newton Decrement Error x_ast Error p_ast line search Condition of Hessian'
)
print(
'{} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {} {:0.2e}'
.format(iteration, normgf, dec_Newton, Err, Err_plot_aux[iteration],
"---", condHf))
stopping_criteria = dec_Newton / 2
iteration += 1
while (stopping_criteria > tol and iteration < maxiter):
der_direct = -dec_Newton
t = line_search_by_backtracking(f, dir_Newton, x, der_direct)
x = x + t * dir_Newton
feval = f(x)
gfeval = gradient_approximation(f, x)
Hfeval = Hessian_approximation(f, x)
normgf = np.linalg.norm(gfeval)
condHf = np.linalg.cond(Hfeval)
if (A.ndim == 1):
m = 1
n = x.size
zero_matrix = np.zeros(1)
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack(
(A.reshape(1, n).T, zero_matrix)).reshape(1, n + 1)[0]
else:
m, n = A.shape
zero_matrix = np.zeros((m, n))
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack((A, zero_matrix))
system_matrix = np.row_stack((first_stack, second_stack))
rhs = np.row_stack((gfeval.reshape(n, 1), zero_vector)).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, rhs)
dir_Newton = dir_desc[0:n]
dec_Newton = dir_Newton.dot(Hfeval @ dir_Newton)
w_dual_variable_estimation = -dir_desc[n:(n + m)]
dir_Newton = -dir_desc[0:n]
Err_plot_aux[iteration] = math.fabs(feval - p_ast)
x_plot[:, iteration] = x
Err = compute_error(x_ast, x)
print(
'{} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {:0.2e}'
.format(iteration, normgf, dec_Newton, Err,
Err_plot_aux[iteration], t, condHf))
stopping_criteria = dec_Newton / 2
if t < tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iter_salida = iteration
iteration = maxiter - 1
iteration += 1
print('{} {:0.2e}'.format("Error of x with respect to x_ast:", Err))
print('{} {}'.format("Approximate solution:", x))
cond = Err_plot_aux > np.finfo(float).eps * 10**(-2)
Err_plot = Err_plot_aux[cond]
if iteration == maxiter and t < tol_backtracking:
print(
"Backtracking value less than tol_backtracking, check approximation"
)
iteration = iter_salida
x_plot = x_plot[:, :iteration]
else:
x_plot = x_plot[:, :iteration]
return [x, iteration, Err_plot, x_plot]
def Newtons_method(f, x_0, tol,
tol_backtracking, x_ast=None, p_ast=None, maxiter=30):
'''
Newton's method to numerically approximate solution of min f.
Args:
f (lambda expression): definition of function f.
x_0 (numpy ndarray): initial point for Newton's method.
tol (float): tolerance that will halt method. Controls stopping criteria.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
feval = f(x)
gfeval = gradient_approximation(f,x)
Hfeval = Hessian_approximation(f,x)
normgf = np.linalg.norm(gfeval)
condHf= np.linalg.cond(Hfeval)
Err_plot_aux = np.zeros(maxiter)
Err_plot_aux[iteration]=compute_error(p_ast,feval)
Err = compute_error(x_ast,x)
n = x.size
x_plot = np.zeros((n,maxiter))
x_plot[:,iteration] = x
#Newton's direction and Newton's decrement
dir_Newton = np.linalg.solve(Hfeval, -gfeval)
dec_Newton = -gfeval.dot(dir_Newton)
print('I Normgf Newton Decrement Error x_ast Error p_ast line search Condition of Hessian')
print('{} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {} {:0.2e}'.format(iteration,normgf,
dec_Newton,Err,
Err_plot_aux[iteration],"---",
condHf))
stopping_criteria = dec_Newton/2
iteration+=1
while(stopping_criteria>tol and iteration < maxiter):
der_direct = -dec_Newton
t = line_search_by_backtracking(f,dir_Newton,x,der_direct)
x = x + t*dir_Newton
feval = f(x)
gfeval = gradient_approximation(f,x)
Hfeval = Hessian_approximation(f,x)
normgf = np.linalg.norm(gfeval)
condHf= np.linalg.cond(Hfeval)
#Newton's direction and Newton's decrement
dir_Newton = np.linalg.solve(Hfeval, -gfeval)
dec_Newton = -gfeval.dot(dir_Newton)
Err_plot_aux[iteration]=compute_error(p_ast,feval)
x_plot[:,iteration] = x
Err = compute_error(x_ast,x)
print('{} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {:0.2e} {:0.2e}'.format(iteration,normgf,
dec_Newton,Err,
Err_plot_aux[iteration],t,
condHf))
stopping_criteria = dec_Newton/2
if t<tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iter_salida=iteration
iteration = maxiter - 1
iteration+=1
print('{} {:0.2e}'.format("Error of x with respect to x_ast:",Err))
print('{} {}'.format("Approximate solution:", x))
cond = Err_plot_aux > np.finfo(float).eps*10**(-2)
Err_plot = Err_plot_aux[cond]
if iteration == maxiter and t < tol_backtracking:
print("Backtracking value less than tol_backtracking, check approximation")
iteration=iter_salida
x_plot = x_plot[:,:iteration]
else:
x_plot = x_plot[:,:iteration]
return [x,iteration,Err_plot,x_plot]
args = parser.parse_args(sys.argv[1:] if len(sys.argv) > 1 else ['-h'])
data_dir = args.d
model_fp = args.m
logging_level = logging.DEBUG if args.v else logging.INFO
logging.basicConfig(stream=sys.stdout, level=logging_level)
logging.info('Loading model from file...')
with open(model_fp, 'rb') as model_file:
model = pickle.load(model_file)
if type(model) != model:
logging.error('\'%s\' contains object of type \'%s\', not Model. Exiting...' % (model_fp, type(model).__name__))
logging.info('Loading data...')
im_fps = glob2.glob(os.path.join(data_dir, '**/snippets/**/*.png'))
ims = utils.import_images(im_fps)
im_labels = utils.get_labels_from_fps(im_fps)
logging.info('Testing model...')
predictions = model.predict(ims)
accuracy = 1 - utils.compute_error(im_labels, predictions)
num_total = len(im_labels)
num_correct = int(round(accuracy * num_total))
logging.info('Accuracy: %g (%d/%d)' % (accuracy, num_correct, num_total))
if accuracy != 1:
logging.info('Incorrectly labeled images:')
for i, (label, prediction) in enumerate(zip(im_labels, predictions)):
if label != prediction:
logging.info('img_fp=%s, label=%s, prediction=%s' % (im_fps[i], label, prediction))
def Newtons_method_infeasible_init_point_2nd_version(f,
A,
b,
x_0,
nu_0,
tol,
tol_backtracking,
x_ast=None,
p_ast=None,
maxiter=30,
gf_symbolic=None,
Hf_symbolic=None):
'''
Newton's method to numerically approximate solution of min f subject to Ax = b.
Args:
f (fun): definition of function f as lambda expression or function definition.
A (numpy ndarray): 2d numpy array of shape (m,n) defines system of constraints Ax=b.
b (numpy ndarray or float): array that defines system of constraints Ax=b (can be a single number
if just one restriction is defined)
x_0 (numpy ndarray): initial point for Newton's method.
nu_0 (numpy ndarray): initial point for Newton's method.
tol (float): tolerance that will halt method. Controls stopping criteria.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations
gf_symbolic (fun): definition of gradient of f. If given, no approximation is
performed via finite differences.
Hf_symbolic (fun): definition of Hessian of f. If given, no approximation is
performed via finite differences.
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
nu = nu_0
feval = f(x)
if gf_symbolic:
gfeval = gf_symbolic(x)
else:
gfeval = gradient_approximation(f, x)
if Hf_symbolic:
Hfeval = Hf_symbolic(x)
else:
Hfeval = Hessian_approximation(f, x)
normgf = np.linalg.norm(gfeval)
condHf = np.linalg.cond(Hfeval)
Err_plot_aux = np.zeros(maxiter)
Err_plot_aux[iteration] = compute_error(p_ast, feval)
Err = compute_error(x_ast, x)
if (A.ndim == 1):
p = 1
n = x.size
zero_matrix = np.zeros(p)
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.row_stack(
(A.reshape(1, n).T, zero_matrix)).reshape(1, n + 1)[0]
else:
p, n = A.shape
zero_matrix = np.zeros((p, p))
first_stack = np.column_stack((Hfeval, A.T))
second_stack = np.column_stack((A, zero_matrix))
x_plot = np.zeros((n, maxiter))
x_plot[:, iteration] = x
system_matrix = np.row_stack((first_stack, second_stack))
residual_primal = lambda x_fun: A @ x_fun - b
def residual_dual(nu_fun):
if (A.ndim == 1):
return gfeval + A.T * nu_fun
else:
return gfeval + A.T @ nu_fun
feasibility_primal = residual_primal(x)
feasibility_dual = residual_dual(nu)
rhs = np.row_stack(
(feasibility_dual.reshape(n, 1), feasibility_primal.reshape(p,
1))).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, -rhs)
dir_Newton_primal = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton_primal)
dir_Newton_dual = dir_desc[n:(n + p)]
norm_residual_eval = norm_residual(feasibility_primal, feasibility_dual)
norm_residual_primal = np.linalg.norm(feasibility_primal)
norm_residual_dual = np.linalg.norm(feasibility_dual)
print(
'I\t||res_primal||\t||res_dual|| \tNewton Decrement\tError x_ast\tError p_ast\tline search\tCondHf'
)
print('{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{}\t\t{:0.2e}'.
format(iteration, norm_residual_primal, norm_residual_dual,
dec_Newton, Err, Err_plot_aux[iteration], "---", condHf))
stopping_criteria = norm_residual_eval > tol
iteration += 1
while (stopping_criteria > tol and iteration < maxiter):
der_direct = -dec_Newton
t = line_search_for_residual_by_backtracking(residual_primal,
residual_dual,
dir_Newton_primal,
dir_Newton_dual, x, nu,
norm_residual_eval)
x = x + t * dir_Newton_primal
nu = nu + t * dir_Newton_dual
feval = f(x)
if gf_symbolic:
gfeval = gf_symbolic(x)
else:
gfeval = gradient_approximation(f, x)
if Hf_symbolic:
Hfeval = Hf_symbolic(x)
else:
Hfeval = Hessian_approximation(f, x)
if (A.ndim == 1):
first_stack = np.column_stack((Hfeval, A.T))
else:
first_stack = np.column_stack((Hfeval, A.T))
system_matrix = np.row_stack((first_stack, second_stack))
feasibility_primal = residual_primal(x)
feasibility_dual = residual_dual(nu)
rhs = np.row_stack((feasibility_dual.reshape(n, 1),
feasibility_primal.reshape(p, 1))).T[0]
#Newton's direction and Newton's decrement
dir_desc = np.linalg.solve(system_matrix, -rhs)
dir_Newton_primal = dir_desc[0:n]
dec_Newton = -gfeval.dot(dir_Newton_primal)
dir_Newton_dual = dir_desc[n:(n + p)]
Err_plot_aux[iteration] = compute_error(p_ast, feval)
x_plot[:, iteration] = x
Err = compute_error(x_ast, x)
norm_residual_eval = norm_residual(feasibility_primal,
feasibility_dual)
norm_residual_primal = np.linalg.norm(feasibility_primal)
norm_residual_dual = np.linalg.norm(feasibility_dual)
print(
'{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}'
.format(iteration, norm_residual_primal, norm_residual_dual,
dec_Newton, Err, Err_plot_aux[iteration], t, condHf))
stopping_criteria = norm_residual_eval > tol
if t < tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iter_salida = iteration
iteration = maxiter - 1
iteration += 1
print('{} {:0.2e}'.format("Error of x with respect to x_ast:", Err))
print('{} {}'.format("Approximate solution:", x))
cond = Err_plot_aux > np.finfo(float).eps * 10**(-2)
Err_plot = Err_plot_aux[cond]
if iteration == maxiter and t < tol_backtracking:
print(
"Backtracking value less than tol_backtracking, check approximation"
)
iteration = iter_salida
else:
if iteration == maxiter:
print("Reached maximum of iterations, check approximation")
x_plot = x_plot[:, :iteration]
return [x, iteration, Err_plot, x_plot]
def gradient_descent(f, x_0, tol,
tol_backtracking, x_ast=None, p_ast=None, maxiter=30,
gf_symbolic=None):
'''
Method of gradient descent to numerically approximate solution of min f.
Args:
f (fun): definition of function f as lambda expression or function definition.
x_0 (numpy ndarray): initial point for gradient descent method.
tol (float): tolerance that will halt method. Controls norm of gradient of f.
tol_backtracking (float): tolerance that will halt method. Controls value of line search by backtracking.
x_ast (numpy ndarray): solution of min f, now it's required that user knows the solution...
p_ast (float): value of f(x_ast), now it's required that user knows the solution...
maxiter (int): maximum number of iterations.
gf_symbolic (fun): definition of gradient of f. If given, no approximation is
performed via finite differences.
Returns:
x (numpy ndarray): numpy array, approximation of x_ast.
iteration (int): number of iterations.
Err_plot (numpy ndarray): numpy array of absolute error between p_ast and f(x) with x approximation
of x_ast. Useful for plotting.
x_plot (numpy ndarray): numpy array that containts in columns vector of approximations. Last column
contains x, approximation of solution. Useful for plotting.
'''
iteration = 0
x = x_0
feval = f(x)
if gf_symbolic:
gfeval = gf_symbolic(x)
else:
gfeval = gradient_approximation(f,x)
normgf = np.linalg.norm(gfeval)
Err_plot_aux = np.zeros(maxiter)
Err_plot_aux[iteration]=compute_error(p_ast,feval)
Err = compute_error(x_ast,x)
n = x.size
x_plot = np.zeros((n,maxiter))
x_plot[:,iteration] = x
print('I\tNormagf\t\tError x_ast\tError p_ast\tline search')
print('{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{}'.format(iteration,normgf,Err,Err_plot_aux[iteration],"---"))
iteration+=1
while(normgf>tol and iteration < maxiter):
dir_desc = -gfeval
der_direct = gfeval.dot(dir_desc)
t = line_search_by_backtracking(f,dir_desc,x,der_direct)
x = x + t*dir_desc
feval = f(x)
if gf_symbolic:
gfeval = gf_symbolic(x)
else:
gfeval = gradient_approximation(f,x)
normgf = np.linalg.norm(gfeval)
Err_plot_aux[iteration]=compute_error(p_ast,feval)
x_plot[:,iteration] = x
Err = compute_error(x_ast,x)
print('{}\t{:0.2e}\t{:0.2e}\t{:0.2e}\t{:0.2e}'.format(iteration,normgf,Err,
Err_plot_aux[iteration],t))
if t<tol_backtracking: #if t is less than tol_backtracking then we need to check the reason
iter_salida=iteration
iteration = maxiter - 1
iteration+=1
print('{} {:0.2e}'.format("Error of x with respect to x_ast:",Err))
print('{} {}'.format("Approximate solution:", x))
cond = Err_plot_aux > np.finfo(float).eps*10**(-2)
Err_plot = Err_plot_aux[cond]
if iteration == maxiter and t < tol_backtracking:
print("Backtracking value less than tol_backtracking, check approximation")
iteration=iter_salida
else:
if iteration == maxiter:
print("Reached maximum of iterations, check approximation")
x_plot = x_plot[:,:iteration]
return [x,iteration,Err_plot,x_plot]
def evaluate_one_file(filename):
# evaluate on one file pair
data = dataLoader(filename)
imgL = data.imgL
pc = data.pc
print("Processing data " + filename + "...\n")
print("Upsampling(accelerated) begins...")
start_acc = time.time()
disp_lidar = bf_vanilla_accelerated(imgL, pc)
end_acc = time.time()
elapse_acc = end_acc - start_acc
print("Upsampling(accelerated) on raw points takes " + str(elapse_acc) +
" seconds...\n")
print("Refinement begins...")
start_refine = time.time()
edge_map, disp_bf = measure_dispersion(imgL, pc)
end_refine = time.time()
elapse_refine = end_refine - start_refine
print("Refinement takes " + str(elapse_refine) + " seconds...\n")
disp_psmnet = cv2.imread("../data/prediction/" + filename + ".png",
-1) / 256.0
disp_gt = cv2.imread("../data/gt/disp_occ_0/" + filename + ".png",
-1) / 256.0
obj_map = cv2.imread("../data/gt/obj_map/" + filename + ".png", -1) / 256.0
disp_refined = replace_boundary(disp_psmnet, disp_bf)
rtn = []
error1, error1_fg, error1_bg, error_map1, count1_above_15 = compute_error(
disp_gt, disp_refined, obj_map)
rtn.append((error1, error1_fg, error1_bg, error_map1, count1_above_15))
error2, error2_fg, error2_bg, error_map2, count2_above_15 = compute_error(
disp_gt, disp_psmnet, obj_map)
rtn.append((error2, error2_fg, error2_bg, error_map2, count2_above_15))
error3, error3_fg, error3_bg, error_map3, count3_above_15 = compute_error(
disp_gt, disp_lidar, obj_map)
rtn.append((error3, error3_fg, error3_bg, error_map3, count3_above_15))
print("All: LiDAR points upsampling... " + str(error3))
print("All: before refinement... " + str(error2))
print("All: after refinement... " + str(error1))
print("FG: LiDAR points upsampling... " + str(error3_fg))
print("FG: before refinement... " + str(error2_fg))
print("FG: after refinement... " + str(error1_fg))
print("BG: LiDAR points upsampling... " + str(error3_bg))
print("BG: before refinement... " + str(error2_bg))
print("BG: after refinement... " + str(error1_bg))
print("BIG ERROR COUNT: LiDAR points upsampling... " +
str(count3_above_15))
print("BIG ERROR COUNT: before refinement... " + str(count2_above_15))
print("BIG ERROR COUNT: after refinement... " + str(count1_above_15))
f = plt.figure()
ax1 = f.add_subplot(4, 2, 1)
plt.imshow(error_map2, 'rainbow', vmin=-5, vmax=20)
plt.axis('off')
ax1.set_title("Error predicted: " + str(100 * error2)[:4] + "%",
fontsize=8)
ax2 = f.add_subplot(4, 2, 2)
plt.imshow(disp_psmnet, 'rainbow', vmin=10, vmax=80)
plt.axis('off')
ax2.set_title("Disparity predicted", fontsize=8)
ax3 = f.add_subplot(4, 2, 3)
plt.imshow(error_map1, 'rainbow', vmin=-5, vmax=20)
plt.axis('off')
ax3.set_title("Error refined: " + str(100 * error1)[:4] + "%",
fontsize=8)
ax4 = f.add_subplot(4, 2, 4)
plt.imshow(disp_refined, 'rainbow', vmin=10, vmax=80)
plt.axis('off')
ax4.set_title("Disparity refined", fontsize=8)
ax5 = f.add_subplot(4, 2, 5)
plt.imshow(error_map3, 'rainbow', vmin=-5, vmax=20)
plt.axis('off')
ax5.set_title("Error upsampled: " + str(100 * error3)[:4] + "%",
fontsize=8)
ax6 = f.add_subplot(4, 2, 6)
plt.imshow(disp_lidar, 'rainbow', vmin=10, vmax=80)
plt.axis('off')
ax6.set_title("Disparity upsampled", fontsize=8)
ax7 = f.add_subplot(4, 2, 7)
plt.imshow(edge_map)
plt.axis('off')
ax7.set_title("Edges", fontsize=10)
ax8 = f.add_subplot(4, 2, 8)
plt.imshow(cv2.cvtColor(imgL, cv2.COLOR_BGR2RGB))
plt.axis('off')
ax8.set_title("Image", fontsize=10)
plt.tight_layout()
plt.savefig("../output/" + "compare_" + filename + ".png", dpi=600)
plt.close()
points, colors = reproject_to_3D(disp_lidar, imgL)
save_ply("../output/" + filename + "_upsampled.ply", points, colors)
points, colors = reproject_to_3D(disp_psmnet, imgL)
save_ply("../output/" + filename + "_predicted.ply", points, colors)
points, colors = reproject_to_3D(disp_refined, imgL)
save_ply("../output/" + filename + "_refined.ply", points, colors)
points, colors = reproject_to_3D(disp_gt, imgL)
save_ply("../output/" + filename + "_gt.ply", points, colors)
return rtn
yplaceholder: batch_y
})
epoch_loss += c / train_iters
print('Epoch', epoch + 1, 'completed out of', epochs, 'loss:',
epoch_loss)
print("Optimization Finished!")
print("Testing..")
test_batch = test_inputs.reshape((-1, input_length, number_of_sequences))
predictions = sess.run([logit], feed_dict={xplaceholder: test_batch})
print('Total Mae for Test set is: ',
utils.compute_error(test_labels,
np.array(predictions)[0]))
preds = np.array(predictions)[0]
close_labels = []
close_preds = []
index_list = []
for i in range(0, len(preds)):
close_labels.append(test_labels[i])
close_preds.append(preds[i])
index_list.append(i)
utils.print_preds(close_labels, close_preds, index_list)
