def create_method_result(data, algo, zero_threshold=1e-6):
test_err = testerror_matrix_completion_groups(data, data.test_idx,
algo.best_model_params)
alphas_guess = algo.best_model_params["alphas"]
betas_guess = algo.best_model_params["betas"]
gamma_guess = algo.best_model_params["gamma"]
u, s, v = np.linalg.svd(gamma_guess)
return MethodResult(
{
"test_err":
test_err,
"validation_err":
algo.best_cost,
"alpha_err":
betaerror(np.vstack(data.real_betas), np.vstack(alphas_guess)),
"beta_err":
betaerror(np.vstack(data.real_betas), np.vstack(betas_guess)),
"gamma_err":
betaerror(data.real_gamma, gamma_guess),
"gamma_num_s":
np.sum(s > zero_threshold),
"runtime":
algo.runtime,
"num_solves":
algo.num_solves,
},
lambdas=algo.best_lambdas)
def create_method_result(data, algo, zero_threshold=1e-6):
test_err = testerror_grouped(
data.X_test,
data.y_test,
algo.best_model_params
)
beta_guess = np.concatenate(algo.best_model_params)
guessed_nonzero_elems = np.where(get_nonzero_indices(beta_guess, threshold=zero_threshold))
guessed_zero_elems = np.where(-get_nonzero_indices(beta_guess, threshold=zero_threshold))
true_nonzero_elems = np.where(get_nonzero_indices(data.beta_real, threshold=zero_threshold))
true_zero_elems = np.where(-get_nonzero_indices(data.beta_real, threshold=zero_threshold))
print "validation cost", algo.best_cost, "test_err", test_err
return MethodResult({
"test_err": test_err,
"validation_err": algo.best_cost,
"beta_err": betaerror(data.beta_real, beta_guess),
"runtime": algo.runtime,
"num_solves": algo.num_solves,
},
lambdas=algo.best_lambdas
)
def create_method_result(data, algo, num_funcs, num_zero_funcs):
test_err = testerror_sparse_add_smooth(
data.y_test,
data.test_idx,
algo.best_model_params
)
print "validation cost", algo.best_cost, "test_err", test_err
guessed_zero_funcs_mask = get_which_funcs_zero(algo.best_model_params)
guessed_zero_funcs = np.where(guessed_zero_funcs_mask)
guessed_nonzero_funcs = np.where(-guessed_zero_funcs_mask)
true_nonzero_funcs = np.array(range(num_funcs))
true_zero_funcs = np.array(range(num_funcs, num_zero_funcs + num_funcs))
assert(true_zero_funcs.size == num_zero_funcs)
return MethodResult({
"test_err":test_err,
"validation_err":algo.best_cost,
"runtime":algo.runtime,
"num_solves": algo.num_solves,
"perc_nonzero_true_f": get_intersection_percent(guessed_nonzero_funcs, true_nonzero_funcs), # among true nonzero f, what percent correct
"perc_zero_true_f": get_intersection_percent(guessed_zero_funcs, true_zero_funcs), # among true zero f, what percent correct
"perc_nonzero_f": get_intersection_percent(true_nonzero_funcs, guessed_nonzero_funcs), # among guessed nonzero f, what percent correct
"perc_zero_f": get_intersection_percent(true_zero_funcs, guessed_zero_funcs), # among true zero f, what percent correct
},
lambdas=algo.current_lambdas
)
def create_method_result(data, fmodel):
test_err = testerror_sparse_add_smooth(data.y_test, data.test_idx,
fmodel.best_model_params)
print "test_err", test_err
return MethodResult(
{
"test_err": test_err,
"validation_err": fmodel.best_cost,
},
lambdas=fmodel.best_lambdas,
)
def create_method_result(data, algo, num_funcs, num_zero_funcs):
test_err = testerror_sparse_add_smooth(data.y_test, data.test_idx,
algo.best_model_params)
return MethodResult(
{
"test_err": test_err,
"validation_err": algo.best_cost,
"runtime": algo.runtime,
"num_solves": algo.num_solves,
},
lambdas=algo.current_lambdas)
def create_method_result(data, algo):
test_err = testerror_elastic_net(data.X_test, data.y_test,
algo.best_model_params)
print "validation cost", algo.best_cost, "test_err", test_err
return MethodResult(
{
"test_err": test_err,
"validation_err": algo.best_cost,
"beta_err": betaerror(algo.current_model_params, data.beta_real),
"runtime": algo.runtime,
"num_solves": algo.num_solves
},
lambdas=algo.current_lambdas)
def create_method_result(data,
grouped_betas,
validate_cost,
runtime,
threshold=1e-6):
log_likelihood, test_rate, false_positive_rate, false_negative_rate = testerror_logistic_grouped(
data.X_test, data.y_test, grouped_betas)
nonzeros_genes, nonzero_genesets = get_num_nonzero_betas(
grouped_betas, data.genesets, threshold=threshold)
return MethodResult({
"log_likelihood": log_likelihood,
"nonzeros_genes": nonzeros_genes,
"nonzero_genesets": nonzero_genesets,
"validation_err": validate_cost,
"test_rate": test_rate,
"false_positive_rate": false_positive_rate,
"false_negative_rate": false_negative_rate,
"runtime": runtime
})
def create_method_result(data, algo, zero_threshold=1e-6):
test_err = testerror_matrix_completion(data, data.test_idx,
algo.best_model_params)
alpha_guess = algo.best_model_params["alpha"]
beta_guess = algo.best_model_params["beta"]
gamma_guess = algo.best_model_params["gamma"]
u, s, v = np.linalg.svd(gamma_guess)
row_guessed_nonzero_elems = np.where(
get_nonzero_indices(alpha_guess, threshold=zero_threshold))
row_guessed_zero_elems = np.where(
-get_nonzero_indices(alpha_guess, threshold=zero_threshold))
row_true_nonzero_elems = np.where(
get_nonzero_indices(data.real_alpha, threshold=zero_threshold))
row_true_zero_elems = np.where(
-get_nonzero_indices(data.real_alpha, threshold=zero_threshold))
col_guessed_nonzero_elems = np.where(
get_nonzero_indices(beta_guess, threshold=zero_threshold))
col_guessed_zero_elems = np.where(
-get_nonzero_indices(beta_guess, threshold=zero_threshold))
col_true_nonzero_elems = np.where(
get_nonzero_indices(data.real_beta, threshold=zero_threshold))
col_true_zero_elems = np.where(
-get_nonzero_indices(data.real_beta, threshold=zero_threshold))
return MethodResult(
{
"test_err":
test_err,
"validation_err":
algo.best_cost,
"alpha_err":
betaerror(data.real_alpha, alpha_guess),
"alpha_cn":
get_intersection_percent(row_guessed_nonzero_elems,
row_true_nonzero_elems),
"alpha_cz":
get_intersection_percent(row_guessed_zero_elems,
row_true_zero_elems),
"alpha_correct_nonzero":
get_intersection_percent(row_true_nonzero_elems,
row_guessed_nonzero_elems),
"alpha_correct_zero":
get_intersection_percent(row_true_zero_elems,
row_guessed_zero_elems),
"beta_err":
betaerror(data.real_beta, beta_guess),
"beta_cn":
get_intersection_percent(col_guessed_nonzero_elems,
col_true_nonzero_elems),
"beta_cz":
get_intersection_percent(col_guessed_zero_elems,
col_true_zero_elems),
"beta_correct_nonzero":
get_intersection_percent(col_true_nonzero_elems,
col_guessed_nonzero_elems),
"beta_correct_zero":
get_intersection_percent(col_true_zero_elems,
col_guessed_zero_elems),
"gamma_err":
betaerror(data.real_gamma, gamma_guess),
"gamma_num_s":
np.sum(s > zero_threshold),
"runtime":
algo.runtime,
"num_solves":
algo.num_solves,
},
lambdas=algo.best_lambdas)