def plot_vergence_trajectory_all(fig, anchors, data): # generate sub lists of param anchors data = filter_data(data, **anchors) list_of_subdata = [filter_data(data, object_distances=[d]) for d in anchors["object_distances"]] n_subplots = len(anchors["object_distances"]) # for each sublist, plot in an ax for subplot_index, subdata in enumerate(list_of_subdata): ax = get_new_ax(fig, n_subplots, subplot_index, method="square") plot_vergence_trajectory_sub(ax, subdata)
def plot_abs_vergence_trajectory_ax(ax, anchors, data, set_title=True, set_ylabel=True, ylim=[-0.2, 4.5]): data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data], dtype=data[0][1].dtype) at = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 19]) bp = ax.boxplot(np.abs(data["vergence_error"][:, at]) / 90 * 320, showfliers=False) ax.axhline(1, color="grey", linestyle="--") for i, line in enumerate(bp["medians"]): x_left, x_right = line.get_xdata() y_left, y_right = line.get_ydata() if i != 0: ax.plot([xprev_right, x_left], [yprev_right, y_left], color=line.get_color(), linewidth=line.get_linewidth()) xprev_left, xprev_right = x_left, x_right yprev_left, yprev_right = y_left, y_right if set_title: ax.set_title("Absolute speed error within one episode") ax.set_xlabel("Iteration (vergence)") ax.set_ylim(ylim) if set_ylabel: ax.set_ylabel("absolute error in px (vergence) or px.it (pan, tilt)") else: ax.set_yticks([]) xticks = np.arange(1, 1 + len(at)) xticklabels = at + 1 ax.set_xticks(xticks[1::2]) ax.set_xticklabels(xticklabels[1::2])
def plot_speed_trajectory(fig, anchors, data, pan_or_tilt="pan"): joint_index = 1 if pan_or_tilt == "pan" else 0 data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data], dtype=data[0][1].dtype) n_speeds = len(anchors["speed_errors"]) at = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 14, 19]) for i, speed in enumerate(anchors["speed_errors"]): ax = get_new_ax(fig, n_speeds, i, method="square") where = np.where(test_cases["speed_error"][:, joint_index] == speed[joint_index]) subdata = data[where] # print(subdata["speed_error"][:6, :10, joint_index]) # print("\n\n\n\n\n\n\n") # ax.plot(subdata["speed_error"][:, :10, joint_index].T / 90 * 320, "b-", alpha=0.2) bp = ax.boxplot(subdata["speed_error"][:, at, joint_index] / 90 * 320, showfliers=False) for i, line in enumerate(bp["medians"]): x_left, x_right = line.get_xdata() y_left, y_right = line.get_ydata() if i != 0: ax.plot([xprev_right, x_left], [yprev_right, y_left], color=line.get_color(), linewidth=line.get_linewidth()) xprev_left, xprev_right = x_left, x_right yprev_left, yprev_right = y_left, y_right ax.set_title("{:.1f} pix/it".format(speed[joint_index] / 90 * 320)) geo = ax.get_geometry() if (geo[-1] - 1) // geo[1] == geo[0] - 1: ax.set_xlabel("Iteration within episode") if geo[-1] % geo[1] == 1: ax.set_ylabel("speed error in pixel/it") xticks = np.arange(1, 1 + len(at)) xticklabels = at + 1 ax.set_xticks(xticks[1::2]) ax.set_xticklabels(xticklabels[1::2]) fig.tight_layout()
def plot_policy_vergence_ax(ax, anchors, data, title_supplement="", set_ylabel=True, set_title=True, cmap_name="Greys"): joint_index = 2 data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data]) vergence_errors = np.sort(anchors["vergence_errors"]) actions_in_semi_pixels = np.array([-8, -4, -2, -1, 0, 1, 2, 4, 8]) n_actions = len(actions_in_semi_pixels) result_matrix = np.zeros((actions_in_semi_pixels.shape[0], vergence_errors.shape[0]), dtype=np.float32) for vergence_error_index, vergence_error in enumerate(vergence_errors): where = np.where(np.abs(data["vergence_error"][:, 0] - vergence_error) < 1e-5) greedy_actions = data["action_index"][where] for action_index in greedy_actions[:, 0, joint_index]: result_matrix[action_index, vergence_error_index] += 1 result_matrix[:, vergence_error_index] /= len(greedy_actions) one_pixel = 90 / 320 im = ax.imshow(result_matrix, aspect="auto", extent=[vergence_errors[0] / one_pixel, vergence_errors[-1] / one_pixel, -n_actions / 2, n_actions / 2], cmap=plt.get_cmap(cmap_name)) ax.axvline(0, color="k", linestyle="--", alpha=0.8) ax.set_xlabel("vergence error (px)") if set_ylabel: ax.set_ylabel("action in px.it-1 (vergence) or px.it-2 (pan, tilt)") ax.set_yticks(np.linspace(-(n_actions - 1) / 2, (n_actions - 1) / 2, n_actions)) ax.set_yticklabels(actions_in_semi_pixels / 2) else: ax.set_yticks([]) if set_title: ax.set_title("Action probabilities" + title_supplement) return im
def plot_critic_accuracy_speed_ax(ax, anchors, data, pan_or_tilt="pan", set_title=True, set_ylabel=True, reward_scaling_factor=200, stimulus=0, at_error=0): joint_index = 2 data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data]) actions_in_pixels = np.array([-8, -4, -2, -1, 0, 1, 2, 4, 8]) / 2 one_pixel = 90 / 320 n_actions = len(actions_in_pixels) # x axis: action # y axis: recerr and critic val # text indicating which stimulus, which error # vertical line showing the error on the x axis where = np.where(test_cases["stimulus"] == stimulus) data = data[where][:, 0] rewards = [] critic_values = [] pan_tilt_index = 0 if pan_or_tilt == "tilt" else 1 where = np.where(np.abs(data["speed_error"][:, pan_tilt_index] / one_pixel - at_error) < 1e-2) baseline_reconstructiuon_error = data["total_recerrs_4_frames"][where] critic_values = data["critic_value_{}".format(pan_or_tilt)][where][0] for action in actions_in_pixels: where = np.where(np.abs(data["speed_error"][:, pan_tilt_index] / one_pixel + action - at_error) < 1e-2) reconstruction_error = data["total_recerrs_4_frames"][where] rewards.append((baseline_reconstructiuon_error - reconstruction_error) * reward_scaling_factor) ax.plot(actions_in_pixels, rewards, label="reward") ax.plot(actions_in_pixels, critic_values, label="critic") ax.set_xlabel("Action (in pixel)") ax.set_ylabel("Reward / Return") ax.set_ylim([-2, 0.2]) ax.legend()
def plot_vergence_path(fig, anchors, data): data = filter_data(data, **anchors) test_data = np.array([b for a, b in data]) n_subplots = 1 ax = get_new_ax(fig, n_subplots, 0) result = test_data["eye_position"][np.random.randint(test_data["eye_position"].shape[0], size=40), :] print(result) print(np.shape(result)) print(result[0][2]) for elem in result: ax.plot(range(len(elem)), elem[:, 2], )
def plot_stimulus_path(fig, anchors, data): path = "/home/aecgroup/aecdata/Textures/mcgillManMade_600x600_bmp_selection/" #path = "../local_copies_of_aecgroup/mcgillManMade_600x600_bmp_selection/" textures_names = os.listdir(path) textures_list = [np.array(Image.open(path + name), dtype=np.uint8) for name in textures_names] lim_stimulus = min(10, len(anchors["stimulus"])) data = filter_data(data, **anchors) list_of_subdata = [filter_data(data, stimulus=[s]) for s in anchors["stimulus"][:lim_stimulus]] n_subplots = lim_stimulus * 2 for subplot_index, elem in enumerate(list_of_subdata): ax = get_new_ax(fig, n_subplots, subplot_index * 2) test_data = np.array([b for a, b in elem]) ax.boxplot(test_data["vergence_error"], notch=True, showfliers=False) ax.axhline(0, color="k") ax.axhline(90 / 320, color="k", linestyle="--") ax.axhline(-90 / 320, color="k", linestyle="--") ax.set_xlabel("Iteration") ax.set_ylabel("Vergence error (deg)") #ax.set_ylim([np.min(test_cases["vergence_error"]) - 1, np.max(test_cases["vergence_error"]) + 1]) ax.set_title("Stimulus {:.1f}".format(elem[0][0]["stimulus"])) ax2 = get_new_ax(fig, n_subplots, (subplot_index * 2) + 1) ax2.imshow(textures_list[elem[0][0]["stimulus"]])
def plot_recerr_wrt_vergence_error_ax(ax, anchors, data, turn_2_frames_vergence_on=True, ylim=[0, 0.04], set_title=True, set_ylabel=True, inset=True, legend=False): total_recerrs = "total_recerrs_2_frames" if turn_2_frames_vergence_on else "total_recerrs_4_frames" joint_index = 2 data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data]) mean = None n = 0 one_pixel = 90 / 320 for stimulus in anchors["stimulus"]: where = np.where(test_cases["stimulus"] == stimulus) subdata = data[where][:, 0] vergence_error = subdata["vergence_error"] recerr = subdata[total_recerrs] args = np.argsort(vergence_error) ax.plot(vergence_error[args] / one_pixel, recerr[args], 'b-', linewidth=1, alpha=0.6) if mean is None: mean = recerr[args] else: mean += recerr[args] n += 1 ax.plot(vergence_error[args] / one_pixel, mean / n, 'r-', linewidth=3, label="mean") if inset: axins = inset_axes(ax, width="20%", height="20%", borderpad=2) # , loc=4 axins.plot(vergence_error[args] / one_pixel, mean / n, 'r-') axins.axvline(0, color="k", linestyle="--", alpha=0.5) axins.set_xticks([]) axins.set_yticks([]) axins.set_title("Mean only") ax.set_xlabel("vergence error (px)") if set_ylabel: ax.set_ylabel("Reconstruction error") else: ax.set_yticks([]) if legend: ax.legend() if set_title: ax.set_title("Reconstruction error wrt vergence error") ax.axvline(0, color="k", linestyle="--") ax.set_ylim(ylim)
def plot_recerr_wrt_vergence_error_per_scale_ax(ax, anchors, data, ylim=[0, 0.03], set_title=True, set_ylabel=True, legend=True, turn_2_frames_vergence_on=True): scale_recerrs = "scale_recerrs_2_frames" if turn_2_frames_vergence_on else "scale_recerrs_4_frames" data = np.array([b for a, b in filter_data(data, **anchors)]) one_pixel = 90 / 320 vergence_errors = np.array(anchors["vergence_errors"]) args = np.argsort(data["vergence_error"][:, 0]) data = data[args].reshape((len(vergence_errors), -1)) for recerrs, scale_name in zip(data[scale_recerrs].T, ["fine", "coarse", "very coarse", "very very coarse"]): ax.plot(vergence_errors / one_pixel, np.mean(recerrs, axis=0), linewidth=3, label=scale_name) ax.set_xlabel("vergence error (px)") if set_ylabel: ax.set_ylabel("Reconstruction error") else: ax.set_yticks([]) if legend: ax.legend() if set_title: ax.set_title("Reconstruction error wrt speed error") ax.axvline(0, color="k", linestyle="--") ax.set_ylim(ylim)
def plot_reward_wrt_action_speed_error_pair(fig, anchors, data, reward_scaling_factor=200, pan_or_tilt="pan", title_supplement=""): joint_index = 1 if pan_or_tilt == "pan" else 0 data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data]) ax = fig.add_subplot(111) speed_errors = np.sort(np.unique(test_cases["speed_error"][:, joint_index])) actions_in_semi_pixels = np.array([-8, -4, -2, -1, 0, 1, 2, 4, 8]) count_matrix = np.zeros((actions_in_semi_pixels.shape[0], speed_errors.shape[0]), dtype=np.int32) reward_matrix = np.zeros((actions_in_semi_pixels.shape[0], speed_errors.shape[0]), dtype=np.float32) n_speed_errors = len(speed_errors) n_actions = len(actions_in_semi_pixels) for action_index, action in enumerate(actions_in_semi_pixels): for index_start_error in range(n_speed_errors): index_end_error = index_start_error + action if 0 < index_end_error < n_speed_errors: where_start = np.where(data["speed_error"][:, 0, joint_index] == speed_errors[index_start_error]) where_end = np.where(data["speed_error"][:, 0, joint_index] == speed_errors[index_end_error]) rewards = data["total_recerrs_4_frames"][where_start] - data["total_recerrs_4_frames"][where_end] reward_matrix[action_index][index_start_error] += np.sum(rewards) count_matrix[action_index][index_start_error] += rewards.shape[0] where = np.where(count_matrix == 0) count_matrix[where] = 1 reward_matrix /= count_matrix reward_matrix[where] = np.nan one_pixel = 90 / 320 xmin = speed_errors[0] / one_pixel xmax = speed_errors[-1] / one_pixel ymin = -n_actions / 2 ymax = n_actions / 2 im = ax.imshow(reward_matrix * reward_scaling_factor, aspect="auto", extent=[xmin, xmax, ymin, ymax], cmap="seismic") # im = ax.imshow(reward_matrix * reward_scaling_factor, aspect="auto", extent=[xmin, xmax, ymin, ymax], cmap=rbg_cmap) cbar = fig.colorbar(im) cbar.ax.set_ylabel('reward', rotation=270) ax.axvline(0, color="k", linestyle="--", alpha=0.8) ax.set_xlabel("{} speed error in pixel/it".format(pan_or_tilt)) ax.set_ylabel("action in px.it-1 (vergence) or px.it-2 (pan, tilt)") ax.set_yticks(np.linspace(-(n_actions - 1) / 2, (n_actions - 1) / 2, n_actions)) ax.set_yticklabels(actions_in_semi_pixels / 2) ax.set_title("Reward wrt action / speed error pair" + title_supplement)
def plot_abs_vergence_trajectory_mean_std_ax(ax, anchors, data, set_title=True, set_ylabel=True, ylim=[-0.2, 4.5]): data = filter_data(data, **anchors) test_cases = np.array([a for a, b in data]) data = np.array([b for a, b in data], dtype=data[0][1].dtype) values = np.abs(data["vergence_error"]) / 90 * 320 mean = np.mean(values, axis=0) std = np.std(values, axis=0) X = np.arange(len(mean)) ax.fill_between(X, mean - std, mean + std, alpha=0.5) ax.plot(X, mean) ax.axhline(1, color="grey", linestyle="--") if set_title: ax.set_title("Mean absolute vergence error within one episode") ax.set_xlabel("Iteration (vergence)") ax.set_ylim(ylim) if set_ylabel: ax.set_ylabel("Mean absolute error in px (vergence) or px.it-1 (pan, tilt)") else: ax.set_yticks([]) xticks = [0, len(X) - 1] xticklabels = [1, len(X)] ax.set_xticks(xticks) ax.set_xticklabels(xticklabels)
def plot_recerr_wrt_speed_error_per_scale_ax(ax, anchors, data, pan_or_tilt="pan", ylim=[0, 0.03], set_title=True, set_ylabel=True, legend=True): joint_index = 1 if pan_or_tilt == "pan" else 0 data = np.array([b for a, b in filter_data(data, **anchors)]) one_pixel = 90 / 320 speed_errors = np.array([s[joint_index] for s in anchors["speed_errors"]]) args = np.argsort(data["speed_error"][:, 0, joint_index]) data = data[args].reshape((len(speed_errors), -1)) # labels = ["fine", "middle", "coarse", "very coarse", "very very coarse"] labels = ["fine", "coarse", "very coarse", "very very coarse"] for recerrs, scale_name in zip(data["scale_recerrs_4_frames"].T, labels): ax.plot(speed_errors / one_pixel, np.mean(recerrs, axis=0), linewidth=3, label=scale_name) ax.set_xlabel("{} error (px/it)".format(pan_or_tilt)) if set_ylabel: ax.set_ylabel("Reconstruction error") else: ax.set_yticks([]) if legend: ax.legend() if set_title: ax.set_title("Reconstruction error wrt speed error") ax.axvline(0, color="k", linestyle="--") ax.set_ylim(ylim)