def run_instance(instance, sparsity, trade_off, learning_rate, max_iter=30000, epsilon=1e-3): opt_x = optimize(instance, sparsity, trade_off, learning_rate, max_iter, epsilon) pred_subgraph = np.nonzero(opt_x)[0] prec, rec, fm, iou = evaluate_block(instance['subgraph'], pred_subgraph) logger.debug('-' * 5 + ' raw performance ' + '-' * 5) logger.debug('precision: {:.5f}'.format(prec)) logger.debug('recall : {:.5f}'.format(rec)) logger.debug('f-measure: {:.5f}'.format(fm)) logger.debug('iou : {:.5f}'.format(iou)) refined_pred_subgraph = post_process_block(instance['graph'], pred_subgraph) prec, rec, fm, iou = evaluate_block(instance['subgraph'], refined_pred_subgraph) logger.debug('-' * 5 + ' refined performance ' + '-' * 5) logger.debug('precision: {:.5f}'.format(prec)) logger.debug('recall : {:.5f}'.format(rec)) logger.debug('f-measure: {:.5f}'.format(fm)) logger.debug('iou : {:.5f}'.format(iou))
def density_projection(graph, weight, A, threshold, lmbd_sparsity_list, normalize=False, true_subgraph=None): if normalize: weight = (weight - np.min(weight)) / (np.max(weight) - np.min(weight)) else: pass print('start density projection') density_subgraph_list = [] print('density projection') # for lmbd in range(min_lmbd, max_lmbd, step_lmbd): for lmbd, sparsity in lmbd_sparsity_list: # for lmbd in lmbd_list: # for sparsity in range(min_sparsity, max_sparsity, step_sparsity): # for sparsity in sparsity_list: print('lambda, sparsity', lmbd, sparsity) x = proj_mp(graph, weight, A, sparsity, lmbd, max_iter=10, epsilon=1e-3) # max iteration print('performance', evaluate_block(true_subgraph, list(x))) density = nx.density(nx.subgraph(graph, x)) print('density', density) if density > threshold: print(density, len(x), sorted(list(x))) density_subgraph_list.append((density, x)) # find the best result print('candidate', len(density_subgraph_list)) max_weight = 0. best_density_subgraph = None for density_subgraph in density_subgraph_list: tmp_weight = np.linalg.norm(weight[list(density_subgraph[1])]) if tmp_weight > max_weight: best_density_subgraph = density_subgraph max_weight = tmp_weight print( 'end density projection: density {}, norm {}, size {}, set {}'.format( best_density_subgraph[0], max_weight, len(best_density_subgraph[1]), sorted(list(best_density_subgraph[1])))) return best_density_subgraph[1]
def run_dataset(paras): dataset, sparsity, trade_off, learning_rate, max_iter, epsilon, write_to_dir, tao = paras if not write_to_dir: logger = logging.getLogger('fei') else: log_fn = '{}_sparsity_{:d}_trade_{}_lr_{}_parallel.txt'.format( DATASET, sparsity, trade_off, learning_rate) if os.path.isfile(os.path.join(write_to_dir, log_fn)): print('file exist !!!') return logger = logging.getLogger(log_fn) formatter = logging.Formatter('') file_handler = logging.FileHandler(filename=os.path.join( write_to_dir, log_fn), mode='w') file_handler.setFormatter(formatter) logger.addHandler(file_handler) all_performance = [] logger.debug('-' * 5 + ' setting ' + '-' * 5) logger.debug('sparsity: {:d}'.format(sparsity)) logger.debug('learning rate: {:.5f}'.format(learning_rate)) logger.debug('trade off: {:.5f}'.format(trade_off)) logger.debug('tao: {:d}'.format(tao)) for i, instance in enumerate(dataset): logger.debug('instance: {:d}'.format(i)) normalize = True if normalize: print('normalize') instance['features'] = instance['features'] / np.max( instance['features']) # opt_x, run_time = optimize(instance, sparsity, trade_off, learning_rate, max_iter, epsilon, logger=None, tao=tao) opt_x, run_time = optimize(instance, sparsity, trade_off, learning_rate, max_iter, epsilon, logger=logger, tao=tao) logger.debug('run time: {:.5f}'.format(run_time)) raw_pred_subgraph = np.nonzero(opt_x)[0] prec, rec, fm, iou = evaluate_block(instance['true_subgraph'], raw_pred_subgraph) logger.debug('-' * 5 + ' performance of raw prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(prec)) logger.debug('recall : {:.5f}'.format(rec)) logger.debug('f-measure: {:.5f}'.format(fm)) logger.debug('iou : {:.5f}'.format(iou)) refined_pred_subgraph = post_process_block(instance['graph'], raw_pred_subgraph, dataset=DATASET) refined_prec, refined_rec, refined_fm, refined_iou = evaluate_block( instance['true_subgraph'], refined_pred_subgraph) logger.debug('-' * 5 + ' performance of refined prediction ' + '-' * 5) logger.debug('refined precision: {:.5f}'.format(refined_prec)) logger.debug('refined recall : {:.5f}'.format(refined_rec)) logger.debug('refined f-measure: {:.5f}'.format(refined_fm)) logger.debug('refined iou : {:.5f}'.format(refined_iou)) all_performance.append((prec, rec, fm, iou, refined_prec, refined_rec, refined_fm, refined_iou, run_time)) all_performance = np.array(all_performance) avg_performance = np.mean(all_performance, axis=0) logger.debug('-' * 5 + ' average performance ' + '-' * 5) logger.debug('average presision: {:.5f}'.format(avg_performance[0])) logger.debug('average recall : {:.5f}'.format(avg_performance[1])) logger.debug('average f-measure: {:.5f}'.format(avg_performance[2])) logger.debug('average iou : {:.5f}'.format(avg_performance[3])) logger.debug('avg refined prec : {:.5f}'.format(avg_performance[4])) logger.debug('avg refined rec : {:.5f}'.format(avg_performance[5])) logger.debug('avg refined fm : {:.5f}'.format(avg_performance[6])) logger.debug('avg refined iou : {:.5f}'.format(avg_performance[7])) logger.debug('average run time : {:.5f}'.format(avg_performance[8]))
def run_dataset(paras): dataset, sparsity, threshold, trade_off, learning_rate, max_iter, epsilon, write_to_dir = paras if not write_to_dir: logger = logging.getLogger('fei') else: log_fn = '{}_sparsity_{:d}_threshold_{}_trade_{}_lr_{}.txt'.format( DATASET, sparsity, threshold, trade_off, learning_rate) if os.path.isfile(os.path.join(write_to_dir, log_fn)): print('file exists !!!') return logger = logging.getLogger(log_fn) formatter = logging.Formatter('') file_handler = logging.FileHandler(filename=os.path.join( write_to_dir, log_fn), mode='w') file_handler.setFormatter(formatter) logger.addHandler(file_handler) all_performance = [] logger.debug('-' * 5 + ' setting ' + '-' * 5) logger.debug('sparsity: {:d}'.format(sparsity)) logger.debug('learning rate: {:.5f}'.format(learning_rate)) logger.debug('trade off: {:.5f}'.format(trade_off)) for i, instance in enumerate(dataset): logger.debug('instance: {:d}'.format(i)) # if normalize: # logger.debug('feature normalized') # instance['features'] = instance['features'] / np.max(instance['features']) opt_x, opt_y, run_time = optimize(instance, sparsity, threshold, trade_off, learning_rate, max_iter, epsilon, logger=logger) logger.debug('run time: {:.5f}'.format(run_time)) second_graph = instance['second_graph'] raw_pred_subgraph_x = np.nonzero(opt_x)[0] # ndarray prec, rec, fm, iou = evaluate_block(instance['true_subgraph'], raw_pred_subgraph_x) logger.debug('-' * 5 + ' performance of x prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(prec)) logger.debug('recall : {:.5f}'.format(rec)) logger.debug('f-measure: {:.5f}'.format(fm)) logger.debug('iou : {:.5f}'.format(iou)) logger.debug('raw density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, list(raw_pred_subgraph_x))))) raw_pred_subgraph_y = np.nonzero(opt_y)[0] prec, rec, fm, iou = evaluate_block(instance['true_subgraph'], raw_pred_subgraph_y) logger.debug('-' * 5 + ' performance of y prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(prec)) logger.debug('recall : {:.5f}'.format(rec)) logger.debug('f-measure: {:.5f}'.format(fm)) logger.debug('iou : {:.5f}'.format(iou)) logger.debug('raw density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, list(raw_pred_subgraph_y))))) # connected in first graph refined_pred_subgraph_x = post_process_block(instance['first_graph'], raw_pred_subgraph_x, dataset=DATASET) refined_prec, refined_rec, refined_fm, refined_iou = evaluate_block( instance['true_subgraph'], refined_pred_subgraph_x) logger.debug('-' * 5 + ' performance of refined x prediction ' + '-' * 5) logger.debug('refined precision: {:.5f}'.format(refined_prec)) logger.debug('refined recall : {:.5f}'.format(refined_rec)) logger.debug('refined f-measure: {:.5f}'.format(refined_fm)) logger.debug('refined iou : {:.5f}'.format(refined_iou)) logger.debug('refined x density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, refined_pred_subgraph_x)))) refined_pred_subgraph_y = post_process_block(instance['first_graph'], raw_pred_subgraph_y, dataset=DATASET) refined_prec, refined_rec, refined_fm, refined_iou = evaluate_block( instance['true_subgraph'], refined_pred_subgraph_y) logger.debug('-' * 5 + ' performance of refined y prediction ' + '-' * 5) logger.debug('refined precision: {:.5f}'.format(refined_prec)) logger.debug('refined recall : {:.5f}'.format(refined_rec)) logger.debug('refined f-measure: {:.5f}'.format(refined_fm)) logger.debug('refined iou : {:.5f}'.format(refined_iou)) logger.debug('refined y density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, refined_pred_subgraph_y)))) # print(type(raw_pred_subgraph_x)) # print(type(raw_pred_subgraph_y)) combine_pred_subgraph = set(list(raw_pred_subgraph_x)) & set( list(raw_pred_subgraph_y)) combine_prec, combine_rec, combine_fm, combine_iou = evaluate_block( instance['true_subgraph'], combine_pred_subgraph) logger.debug('-' * 5 + ' combine performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(combine_prec)) logger.debug('recall : {:.5f}'.format(combine_rec)) logger.debug('f-measure: {:.5f}'.format(combine_fm)) logger.debug('iou : {:.5f}'.format(combine_iou)) logger.debug('combined density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, combine_pred_subgraph)))) refined_combine_pred_subgraph = post_process_block( instance['first_graph'], combine_pred_subgraph, dataset=DATASET) refined_combine_prec, refined_combine_rec, refined_combine_fm, refined_combine_iou = evaluate_block( instance['true_subgraph'], refined_combine_pred_subgraph) logger.debug('-' * 5 + ' refined combine performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(refined_combine_prec)) logger.debug('recall : {:.5f}'.format(refined_combine_rec)) logger.debug('f-measure: {:.5f}'.format(refined_combine_fm)) logger.debug('iou : {:.5f}'.format(refined_combine_iou)) logger.debug('refined combined density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, refined_combine_pred_subgraph))))
def run_dataset(paras): dataset, sparsity, threshold, trade_off, learning_rate, max_iter, epsilon, write_to_dir = paras # print log setting if not write_to_dir: logger = logging.getLogger('fei') else: log_fn = '{}_sparsity_{:d}_threshold_{}_trade_off_{}_lr_{}.txt'.format( DATASET, sparsity, threshold, trade_off, learning_rate) if os.path.isfile(os.path.join(write_to_dir, log_fn)): print('file exists !!!') return logger = logging.getLogger(log_fn) formatter = logging.Formatter('') file_handler = logging.FileHandler(filename=os.path.join( write_to_dir, log_fn), mode='w') file_handler.setFormatter(formatter) logger.addHandler(file_handler) all_performance = [] logger.debug('-' * 5 + ' setting ' + '-' * 5) logger.debug('sparsity: {:d}'.format(sparsity)) logger.debug('learning rate: {:.5f}'.format(learning_rate)) logger.debug('trade off: {:.5f}'.format(trade_off)) for i, instance in enumerate(dataset): logger.debug('instance: {:d}'.format(i)) opt_x, opt_y, run_time = optimize(instance, sparsity, threshold, trade_off, learning_rate, max_iter, epsilon, logger=logger) logger.debug('run time: {:.5f}'.format(run_time)) second_graph = instance['second_graph'] raw_pred_subgraph_x = np.nonzero(opt_x)[0] x_prec, x_rec, x_fm, x_iou = evaluate_block(instance['true_subgraph'], raw_pred_subgraph_x) logger.debug('-' * 5 + ' performance of x prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(x_prec)) logger.debug('recall : {:.5f}'.format(x_rec)) logger.debug('f-measure: {:.5f}'.format(x_fm)) logger.debug('iou : {:.5f}'.format(x_iou)) logger.debug('raw density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, list(raw_pred_subgraph_x))))) raw_pred_subgraph_y = np.nonzero(opt_y)[0] print('length y', len(raw_pred_subgraph_y)) y_prec, y_rec, y_fm, y_iou = evaluate_block(instance['true_subgraph'], raw_pred_subgraph_y) logger.debug('-' * 5 + ' performance of y prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(y_prec)) logger.debug('recall : {:.5f}'.format(y_rec)) logger.debug('f-measure: {:.5f}'.format(y_fm)) logger.debug('iou : {:.5f}'.format(y_iou)) logger.debug('raw density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, list(raw_pred_subgraph_y))))) # connected in first graph connected_pred_subgraph_x = post_process_block(instance['first_graph'], raw_pred_subgraph_x, dataset=DATASET) connected_x_prec, connected_x_rec, connected_x_fm, connected_x_iou = evaluate_block( instance['true_subgraph'], connected_pred_subgraph_x) logger.debug('-' * 5 + ' performance of connected x prediction ' + '-' * 5) logger.debug('refined precision: {:.5f}'.format(connected_x_prec)) logger.debug('refined recall : {:.5f}'.format(connected_x_rec)) logger.debug('refined f-measure: {:.5f}'.format(connected_x_fm)) logger.debug('refined iou : {:.5f}'.format(connected_x_iou)) logger.debug('connected x density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, connected_pred_subgraph_x)))) connected_pred_subgraph_y = post_process_block(instance['first_graph'], raw_pred_subgraph_y, dataset=DATASET) connected_y_prec, connected_y_rec, connected_y_fm, connected_y_iou = evaluate_block( instance['true_subgraph'], connected_pred_subgraph_y) logger.debug('-' * 5 + ' performance of connected y prediction ' + '-' * 5) logger.debug('refined precision: {:.5f}'.format(connected_y_prec)) logger.debug('refined recall : {:.5f}'.format(connected_y_rec)) logger.debug('refined f-measure: {:.5f}'.format(connected_y_fm)) logger.debug('refined iou : {:.5f}'.format(connected_y_iou)) logger.debug('refined y density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, connected_pred_subgraph_y)))) # print(type(raw_pred_subgraph_x)) # print(type(raw_pred_subgraph_y)) intersect_pred_subgraph = set(list(raw_pred_subgraph_x)) & set( list(raw_pred_subgraph_y)) intersect_prec, intersect_rec, intersect_fm, intersect_iou = evaluate_block( instance['true_subgraph'], intersect_pred_subgraph) logger.debug('-' * 5 + ' intersect performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(intersect_prec)) logger.debug('recall : {:.5f}'.format(intersect_rec)) logger.debug('f-measure: {:.5f}'.format(intersect_fm)) logger.debug('iou : {:.5f}'.format(intersect_iou)) logger.debug('intersect density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, intersect_pred_subgraph)))) connected_intersect_pred_subgraph = post_process_block( instance['first_graph'], intersect_pred_subgraph, dataset=DATASET) connected_intersect_prec, connected_intersect_rec, connected_intersect_fm, connected_intersect_iou = evaluate_block( instance['true_subgraph'], connected_intersect_pred_subgraph) logger.debug('-' * 5 + ' connected intersect performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(connected_intersect_prec)) logger.debug('recall : {:.5f}'.format(connected_intersect_rec)) logger.debug('f-measure: {:.5f}'.format(connected_intersect_fm)) logger.debug('iou : {:.5f}'.format(connected_intersect_iou)) logger.debug('connected intersect density second graph: {:.5f}'.format( nx.density( nx.subgraph(second_graph, connected_intersect_pred_subgraph)))) union_pred_subgraph = set(list(raw_pred_subgraph_x)) | set( list(raw_pred_subgraph_y)) union_prec, union_rec, union_fm, union_iou = evaluate_block( instance['true_subgraph'], union_pred_subgraph) logger.debug('-' * 5 + ' union performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(union_prec)) logger.debug('recall : {:.5f}'.format(union_rec)) logger.debug('f-measure: {:.5f}'.format(union_fm)) logger.debug('iou : {:.5f}'.format(union_iou)) logger.debug('union density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, union_pred_subgraph)))) connected_union_pred_subgraph = post_process_block( instance['first_graph'], union_pred_subgraph, dataset=DATASET) connected_union_prec, connected_union_rec, connected_union_fm, connected_union_iou = evaluate_block( instance['true_subgraph'], connected_union_pred_subgraph) logger.debug('-' * 5 + ' connected union performance of prediction ' + '-' * 5) logger.debug('precision: {:.5f}'.format(connected_union_prec)) logger.debug('recall : {:.5f}'.format(connected_union_rec)) logger.debug('f-measure: {:.5f}'.format(connected_union_fm)) logger.debug('iou : {:.5f}'.format(connected_union_iou)) logger.debug('connected union density second graph: {:.5f}'.format( nx.density(nx.subgraph(second_graph, connected_union_pred_subgraph))))
def optimize(instance, sparsity, trade_off, learning_rate, max_iter, epsilon): graph = instance['graph'] true_subgraph = instance['subgraph'] features = instance['features'] block_node_sets = instance['block_node_sets'] block_boundary_edges_dict = instance['block_boundary_edges_dict'] num_nodes = graph.number_of_nodes() num_edges = graph.number_of_edges() num_blocks = len(block_boundary_edges_dict) logger.debug('-' * 5 + ' related info ' + '-' * 5) logger.debug('algorithm: graph block-structured IHT') logger.debug('sparsity: {:d}'.format(sparsity)) logger.debug('max iteration: {:d}'.format(max_iter)) logger.debug('number of nodes: {:d}'.format(num_nodes)) logger.debug('number of edges: {:d}'.format(num_edges)) logger.debug('number of blocks: {:d}'.format(num_blocks)) node_id_dict = relabel_nodes(block_node_sets) relabeled_edge_sets = relabel_edges(graph, block_node_sets, node_id_dict) logger.debug('-' * 5 + ' start iterating ' + '-' * 5) start_time = time.time() acc_proj_time = 0. func = BlockSumEMS(features=features, nodes_set=block_node_sets, boundary_edges_dict=block_boundary_edges_dict, nodes_id_dict=node_id_dict, trade_off=trade_off) true_x = np.zeros(num_nodes) true_x[true_subgraph] = 1. true_x = np.array(true_x) true_obj_val, true_sum_ems_val, true_penalty = func.get_obj_val(true_x) logger.debug( 'ground truth, obj value: {:.5f}, sum ems value: {:.5f}, penalty: {:.5f}' .format(true_obj_val, true_sum_ems_val, true_penalty)) current_x = func.get_init_x_zeros() + 1e-6 for iter in range(max_iter): # cyclic block coordinate version for b in range(num_blocks): logger.debug('iteration: {:d}'.format(iter)) prev_x = np.copy(current_x) iter_time = time.time() iter_proj_time = 0. sorted_node_set = sorted(block_node_sets[b]) block_x = current_x[sorted_node_set] block_boundary_edge_x_dict = get_boundary_xs( current_x, block_boundary_edges_dict[b], node_id_dict) block_features = features[sorted_node_set] block_grad = func.get_gradient(block_x, block_features, block_boundary_edge_x_dict) block_x = block_x if iter > 0 else np.zeros_like(block_x, dtype=np.float64) normalized_block_grad = normalize_gradient(block_x, block_grad) edges = np.array(relabeled_edge_sets[b]) edge_weights = np.ones(len(edges)) start_proj_time = time.time() re_head = head_proj(edges=edges, weights=edge_weights, x=normalized_block_grad, g=1, s=sparsity, budget=sparsity - 1., delta=1. / 169., max_iter=100, err_tol=1e-8, root=-1, pruning='strong', epsilon=1e-10, verbose=0) re_nodes, _, _ = re_head iter_proj_time += time.time() - start_proj_time block_omega_x = set( re_nodes ) # note, elements in block_omega_x are all local (block) node id # update one block block_x = current_x[sorted_node_set] block_features = features[sorted_node_set] block_indicator_x = np.zeros_like(current_x[sorted_node_set]) block_indicator_x[list(block_omega_x)] = 1. block_boundary_edge_x_dict = get_boundary_xs( current_x, block_boundary_edges_dict[b], node_id_dict) current_x[sorted_node_set] = current_x[ sorted_node_set] + learning_rate * func.get_gradient( block_x, block_features, block_boundary_edge_x_dict) * block_indicator_x block_bx = current_x[sorted_node_set] start_proj_time = time.time() re_tail = tail_proj(edges=edges, weights=edge_weights, x=block_bx, g=1, s=sparsity, budget=sparsity - 1., nu=2.5, max_iter=100, err_tol=1e-8, root=-1, pruning='strong', verbose=0) re_nodes, _, _ = re_tail iter_proj_time += time.time() - start_proj_time psi_x = set(re_nodes) block_x = np.zeros_like(current_x[sorted_node_set]) block_x[list(psi_x)] = block_bx[list(psi_x)] normalized_block_x = normalize(block_x) current_x[ sorted_node_set] = normalized_block_x # constrain current block x in [0, 1] acc_proj_time += iter_proj_time obj_val, sum_ems_val, penalty = func.get_obj_val(current_x) logger.debug( 'objective value: {:.5f}, sum ems value: {:.5f}, penalty: {:.5f}' .format(obj_val, sum_ems_val, penalty)) logger.debug('iteration time: {:.5f}'.format(time.time() - iter_time)) logger.debug('iter projection time: {:.5f}'.format(iter_proj_time)) logger.debug('acc projection time: {:.5f}'.format( acc_proj_time)) # accumulative projection time pred_subgraph = np.nonzero(current_x)[0] prec, rec, fm, iou = evaluate_block(instance['subgraph'], pred_subgraph) logger.debug( 'precision: {:.5f}, recall: {:.5f}, f-measure: {:.5f}'.format( prec, rec, fm)) logger.debug('-' * 10) diff_norm_x = np.linalg.norm(current_x - prev_x) if diff_norm_x < epsilon: print('difference {:.5f}'.format(diff_norm_x)) break run_time = time.time() - start_time obj_val, sum_ems_val, penalty = func.get_obj_val(current_x) logger.debug( 'objective value: {:.5f}, sum ems value: {:.5f}, penalty: {:.5f}'. format(obj_val, sum_ems_val, penalty)) logger.debug('run time of whole algorithm: {:.5f}'.format(run_time)) logger.debug('accumulative projection time: {:.5f}'.format(acc_proj_time)) return current_x