def plot_perfect_recall_rates_for_data(parsed_data, dps_per_exp_config_per_subset): perfect_recall_rates, spurious_patterns_data = Parser. \ get_perfect_recall_rates_and_spurious_patterns_from_data(parsed_data) # print "len perfect_recall_rates[0]:", len(perfect_recall_rates[0]) # print "perfect_recall_rates:", perfect_recall_rates # for all data: 4 buckets, containing 4x100 data points. # convergence_stats = Parser.get_convergence_avgs(convergence_data) ds = [] lf = dps_per_exp_config_per_subset for i in range(4): ds.append([perfect_recall_rates[0][i*lf:i*lf + lf], perfect_recall_rates[1][i*lf:i*lf + lf], perfect_recall_rates[2][i*lf:i*lf + lf], perfect_recall_rates[3][i*lf:i*lf + lf]]) perf_recall_stats_async_true_mode_0, stds_t_0 = Parser.get_average_recall_ratios(ds[0]) perf_recall_stats_async_true_mode_1, stds_t_1 = Parser.get_average_recall_ratios(ds[1]) perf_recall_stats_async_false_mode_0, stds_f_0 = Parser.get_average_recall_ratios(ds[2]) perf_recall_stats_async_false_mode_1, stds_f_1 = Parser.get_average_recall_ratios(ds[3]) for i in range(len(perf_recall_stats_async_true_mode_0)): perf_recall_stats_async_true_mode_0[i] = perf_recall_stats_async_true_mode_0[i] * 100 perf_recall_stats_async_true_mode_1[i] = perf_recall_stats_async_true_mode_1[i] * 100 perf_recall_stats_async_false_mode_0[i] = perf_recall_stats_async_false_mode_0[i] * 100 perf_recall_stats_async_false_mode_1[i] = perf_recall_stats_async_false_mode_1[i] * 100 stds_t_0[i] = stds_t_0[i] * 100 stds_t_1[i] = stds_t_1[i] * 100 stds_f_0[i] = stds_f_0[i] * 100 stds_f_1[i] = stds_f_1[i] * 100 # Plotting: x = np.asarray([2, 3, 4, 5]) plt.rcParams.update({'font.size': 25}) print "y:", perf_recall_stats_async_true_mode_0 # print "e:", e1.shape # print "e:", e1 p1 = plt.errorbar(x, perf_recall_stats_async_true_mode_0, stds_t_0, color='y', marker='o', linestyle='--') p2 = plt.errorbar(x, perf_recall_stats_async_true_mode_1, stds_t_1, color='g', marker='s', linestyle='--') p3 = plt.errorbar(x, perf_recall_stats_async_false_mode_0, stds_f_0, color='b', marker='^', linestyle='--') p4 = plt.errorbar(x, perf_recall_stats_async_false_mode_1, stds_f_1, color='c', marker='o', linestyle='--') plt.ylabel('Perfect recall rate (%)') plt.xlabel('Set size') plt.title('Average perfect recall rates by set size') plt.xticks(x, ('2x5', '3x5', '4x5', '5x5')) plt.margins(0.05) plt.legend((p1[0], p2[0], p3[0], p4[0]), ('Async. tm=0', 'Async. tm=1', 'Sync. tm=0', 'Sync. tm=1')) # bbox_to_anchor=(0.377, 0.23)) plt.grid(True) plt.show()
def plot_convergence_iterations_for_data(parsed_data, exp_num): convergence_data, _ = Parser.get_convergence_and_distinct_patterns_from_log_v1(parsed_data) # for all data: 4 buckets, containing 4x100 data points. # convergence_stats = Parser.get_convergence_avgs(convergence_data) ds = [] for i in range(4): ds.append([convergence_data[0][i*100:i*100 + 100], convergence_data[1][i*100:i*100 + 100], convergence_data[2][i*100:i*100 + 100], convergence_data[3][i*100:i*100 + 100]]) average_iters_convergence, sigmas = Parser.get_average_recall_ratios(ds[exp_num]) # Plotting: x = np.asarray([2, 3, 4, 5]) plt.rcParams.update({'font.size': 25}) p1 = plt.plot(x, average_iters_convergence, color='b', marker='o', linestyle='--', linewidth=3.0) p2 = plt.plot(x, sigmas, color='r', marker='^', linestyle='--', linewidth=3.0) # p1 = plt.plot(x, [2.78, 19.02, 15.85, 15.58], color='r', marker='o', linestyle='--') plt.ylabel('Average #iterations before convergence') plt.xlabel('Set size') plt.title('Average #iterations before convergence by set size') plt.xticks(x, ('2', '3', '4', '5')) plt.legend((p1[0], p2[0]), ('Sync., turnover for every learnt set', 'Standard deviation')) # bbox_to_anchor=(0.445, 1)) plt.grid(True) plt.show()
def plot_pattern_stats_from_parsed_data_v1(parsed_data, exp_num): _, distinct_patterns_data = Parser.get_convergence_and_distinct_patterns_from_log_v1(parsed_data) perfect_recall_rates, spurious_patterns_extracted = Parser. \ get_perfect_recall_rates_and_spurious_patterns_from_data(parsed_data) dist_patterns_data_experiments = [] pf_buckets = [] spurious_buckets = [] for i in range(4): dist_patterns_data_experiments.append([]) pf_buckets.append([]) spurious_buckets.append([]) for i in range(4): dist_patterns_data_experiments[i].append(distinct_patterns_data[0][i*100: i*100 + 100]) dist_patterns_data_experiments[i].append(distinct_patterns_data[1][i*100: i*100 + 100]) dist_patterns_data_experiments[i].append(distinct_patterns_data[2][i*100: i*100 + 100]) dist_patterns_data_experiments[i].append(distinct_patterns_data[3][i*100: i*100 + 100]) pf_buckets[i].append(perfect_recall_rates[0][i*20: i*20 + 20]) pf_buckets[i].append(perfect_recall_rates[1][i*20: i*20 + 20]) pf_buckets[i].append(perfect_recall_rates[2][i*20: i*20 + 20]) pf_buckets[i].append(perfect_recall_rates[3][i*20: i*20 + 20]) spurious_buckets[i].append(spurious_patterns_extracted[0][i*20: i*20 + 20]) spurious_buckets[i].append(spurious_patterns_extracted[1][i*20: i*20 + 20]) spurious_buckets[i].append(spurious_patterns_extracted[2][i*20: i*20 + 20]) spurious_buckets[i].append(spurious_patterns_extracted[3][i*20: i*20 + 20]) # convergence_data[0]: convergence data for the first set size. avg_recall, stds_avg_recall = Parser.get_average_recall_ratios(dist_patterns_data_experiments[exp_num]) for i in range(len(spurious_buckets[exp_num])): for j in range(len(spurious_buckets[exp_num][i])): spurious_buckets[exp_num][i][j] = spurious_buckets[exp_num][i][j] / 5. # print spurious_buckets[0][1] avg_spurious_ratios, stds_spurious = Parser.get_average_recall_ratios(spurious_buckets[exp_num]) # print avg_recall # print "stds_avg_recall:", stds_avg_recall # print # print avg_spurious_ratios # print "stds_spurious:", stds_spurious # graph 1: box plot width = .35 V = np.arange(4) p1 = plt.bar(V, avg_recall, width=width, color='y', yerr=stds_avg_recall) p2 = plt.bar(V + width, avg_spurious_ratios, width=width, color='r', yerr=stds_spurious) plt.rcParams.update({'font.size': 25}) plt.ylabel('Number of patterns') plt.xlabel('Set size') plt.title('Average number of patterns recalled for each sub-set') plt.xticks(V + width, ('2', '3', '4', '5')) plt.yticks(np.arange(0, 6, 1)) plt.legend((p1[0], p2[0]), ('avg. # patterns recalled per sub-set', 'avg. spurious recall per sub-set'), bbox_to_anchor=(0.42, 1)) plt.grid(True) plt.show()
def plot_avg_perfect_extraction_and_spurious_patterns(parsed_data, dps_per_exp_config_per_subset): perfect_recall_rates, spurious_patterns_data = Parser. \ get_perfect_recall_rates_and_spurious_patterns_from_data(parsed_data) print spurious_patterns_data print len(spurious_patterns_data[0]) ds = [] spds = [] lf = dps_per_exp_config_per_subset for i in range(4): ds.append([perfect_recall_rates[0][i*lf:i*lf + lf], perfect_recall_rates[1][i*lf:i*lf + lf], perfect_recall_rates[2][i*lf:i*lf + lf], perfect_recall_rates[3][i*lf:i*lf + lf]]) spds.append([spurious_patterns_data[0][i*lf:i*lf + lf], spurious_patterns_data[1][i*lf:i*lf + lf], spurious_patterns_data[2][i*lf:i*lf + lf], spurious_patterns_data[3][i*lf:i*lf + lf]]) perf_recall_stats_async_true_mode_0, stds_t_0 = Parser.get_average_recall_ratios(ds[0]) perf_recall_stats_async_true_mode_1, stds_t_1 = Parser.get_average_recall_ratios(ds[1]) perf_recall_stats_async_false_mode_0, stds_f_0 = Parser.get_average_recall_ratios(ds[2]) perf_recall_stats_async_false_mode_1, stds_f_1 = Parser.get_average_recall_ratios(ds[3]) spurpt0, stdspurpt0 = Parser.get_average_recall_ratios(spds[0]) spurpt1, stdspurpt1 = Parser.get_average_recall_ratios(spds[1]) spurpf0, stdspurpf0 = Parser.get_average_recall_ratios(spds[2]) spurpf1, stdspurpf1 = Parser.get_average_recall_ratios(spds[3]) for i in range(len(perf_recall_stats_async_true_mode_0)): perf_recall_stats_async_true_mode_0[i] = perf_recall_stats_async_true_mode_0[i] * float(2 + i) perf_recall_stats_async_true_mode_1[i] = perf_recall_stats_async_true_mode_1[i] * float(2 + i) perf_recall_stats_async_false_mode_0[i] = perf_recall_stats_async_false_mode_0[i] * float(2 + i) perf_recall_stats_async_false_mode_1[i] = perf_recall_stats_async_false_mode_1[i] * float(2 + i) stds_t_0[i] = stds_t_0[i] * float(2 + i) stds_t_1[i] = stds_t_1[i] * float(2 + i) stds_f_0[i] = stds_f_0[i] * float(2 + i) stds_f_1[i] = stds_f_1[i] * float(2 + i) spurpt0[i] = spurpt0[i] / float(2+i) spurpt1[i] = spurpt1[i] / float(2+i) spurpf0[i] = spurpf0[i] / float(2+i) spurpf1[i] = spurpf1[i] / float(2+i) # Plotting: width = .35 x = np.asarray([2, 3, 4, 5]) plt.rcParams.update({'font.size': 25}) p1 = plt.bar(x, perf_recall_stats_async_true_mode_0, color='y', width=width/2) p1_e = plt.bar(x, spurpt0, color='r', width=width/2, bottom=perf_recall_stats_async_true_mode_0) p2 = plt.bar(x+width/2, perf_recall_stats_async_true_mode_1, color='g', width=width/2) p2_2 = plt.bar(x+width/2, spurpt1, color='r', width=width/2, bottom=perf_recall_stats_async_true_mode_1) p3 = plt.bar(x+width, perf_recall_stats_async_false_mode_0, color='b', width=width/2) p3_e = plt.bar(x+width, spurpf0, color='r', width=width/2, bottom=perf_recall_stats_async_false_mode_0) p4 = plt.bar(x+3*width/2, perf_recall_stats_async_false_mode_1, color='c', width=width/2) p4_e = plt.bar(x+3*width/2, spurpf1, color='r', width=width/2, bottom=perf_recall_stats_async_false_mode_1) plt.ylabel('Average perfectly recalled patterns per subset') plt.xlabel('Subset size') plt.title('Average perfect recall per subset') plt.xticks(x + width, ('2', '3', '4', '5')) plt.yticks(np.arange(0, 6, 1)) plt.legend((p1[0], p2[0], p3[0], p4[0], p4_e[0]), ('Async., turnover for new sets', 'Async., turnover every iteration', 'Sync., turnover for new sets', 'Sync., turnover every iteration', 'Non-perfectly recalled patterns')) # bbox_to_anchor=(0.377, 1)) plt.grid(True) plt.show()