-
Notifications
You must be signed in to change notification settings - Fork 14
/
Copy pathplotting.py
118 lines (87 loc) · 6.05 KB
/
plotting.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
import numpy as np
def jointplot(logger, data, loss_type="mse_loss"):
data = np.stack((data[f"train_{loss_type}"], data[f"val_{loss_type}"]), axis=1)
logger.plot(data, loss_type, opts={"legend": [f"train_{loss_type}", f"val_{loss_type}"]})
def get_running_means_w_std_bounds_and_legend_on_diff_prev_time_step(list_of_list_values):
running_mean_and_std_bounds = []
legend = ["Mean-STD", "Mean Difference", "Mean+STD"]
for ii, losses_in_batch_ii in enumerate(list_of_list_values):
if ii == 0: # there's no previous time step to compare to
running_mean_and_std_bounds.append([0, 0, 0])
else:
loss_diffs = [loss_val - list_of_list_values[ii - 1][jj]
for jj, loss_val in enumerate(losses_in_batch_ii)]
mean = np.mean(loss_diffs)
std = np.std(loss_diffs)
running_mean_and_std_bounds.append([mean - std, mean, mean + std])
return running_mean_and_std_bounds, legend
def get_running_means_w_std_bounds_and_legend(list_of_list_values):
running_mean_and_std_bounds = []
legend = ["Mean-STD", "Mean", "Mean+STD"]
for ii in range(len(list_of_list_values)):
mean = np.mean(list_of_list_values[ii])
std = np.std(list_of_list_values[ii])
running_mean_and_std_bounds.append([mean - std, mean, mean + std])
return running_mean_and_std_bounds, legend
def get_running_std(list_of_list_values):
return [np.std(list_of_list_values[ii]) for ii in range(len(list_of_list_values))]
def get_running_p_coeffs(list_of_list_values_1, list_of_list_values_2):
assert len(list_of_list_values_1) == len(list_of_list_values_2)
pearson_coefficients = []
for ii in range(len(list_of_list_values_1)):
cov = np.cov(np.stack((list_of_list_values_1[ii],
list_of_list_values_2[ii]), axis=0))[0, 1]
std1 = np.std(list_of_list_values_1[ii])
std2 = np.std(list_of_list_values_2[ii])
correlation_coefficient = cov / (std1 * std2)
pearson_coefficients.append(correlation_coefficient)
return pearson_coefficients
def mseplots(data, logger):
data = np.stack((logger.data["train_mse_loss"], logger.data["val_mse_loss"]), axis=1)
logger.plot(data, "mse_loss", opts={"legend": ["train_mse", "val_mse"]})
running_mean_and_std_bounds, legend = get_running_means_w_std_bounds_and_legend(logger.data["val_mse_losses"])
logger.plot(running_mean_and_std_bounds, "val_mse_loss_running_mean", opts={"legend": legend})
logger.plot(get_running_std(logger.data["val_mse_losses"]), "val_mse_losses_running_stds",
opts={"legend": ['STD']})
running_mean_and_std_bounds_diff_prev_time_step, legend = \
get_running_means_w_std_bounds_and_legend_on_diff_prev_time_step(logger.data["val_mse_losses"])
logger.plot(running_mean_and_std_bounds_diff_prev_time_step, "val_mse_loss_diff_prev_step_running_mean",
opts={"legend": legend})
def curvatureplots(data, logger):
data = np.stack((logger.data["train_curvature_loss"], logger.data["val_curvature_loss"]), axis=1)
logger.plot(data, "curvature_loss", opts={"legend": ["train_curvature", "val_curvature"]})
running_mean_and_std_bounds, legend = get_running_means_w_std_bounds_and_legend(
logger.data["val_curvature_losses"])
logger.plot(running_mean_and_std_bounds, "val_curvature_loss_running_mean", opts={"legend": legend})
logger.plot(get_running_std(logger.data["val_curvature_losses"]), "val_curvature_losses_running_stds",
opts={"legend": ['STD']})
running_mean_and_std_bounds_diff_prev_time_step, legend = \
get_running_means_w_std_bounds_and_legend_on_diff_prev_time_step(logger.data["val_curvature_losses"])
logger.plot(running_mean_and_std_bounds_diff_prev_time_step, "val_curvature_loss_diff_prev_step_running_mean",
opts={"legend": legend})
def depthplots(data, logger):
data = np.stack((logger.data["train_depth_loss"], logger.data["val_depth_loss"]), axis=1)
logger.plot(data, "depth_loss", opts={"legend": ["train_depth", "val_depth"]})
running_mean_and_std_bounds, legend = get_running_means_w_std_bounds_and_legend(logger.data["val_depth_losses"])
logger.plot(running_mean_and_std_bounds, "val_depth_loss_running_mean", opts={"legend": legend})
logger.plot(get_running_std(logger.data["val_depth_losses"]), "val_depth_losses_running_stds",
opts={"legend": ['STD']})
running_mean_and_std_bounds_diff_prev_time_step, legend = \
get_running_means_w_std_bounds_and_legend_on_diff_prev_time_step(logger.data["val_depth_losses"])
logger.plot(running_mean_and_std_bounds_diff_prev_time_step, "val_depth_loss_diff_prev_step_running_mean",
opts={"legend": legend})
def covarianceplot(data, logger):
covs = get_running_p_coeffs(logger.data["val_mse_losses"], logger.data["val_curvature_losses"])
logger.plot(covs, "val_mse_curvature_running_pearson_coeffs", opts={"legend": ['Pearson Coefficient']})
covs = get_running_p_coeffs(logger.data["val_mse_losses"], logger.data["val_depth_losses"])
logger.plot(covs, "val_mse_depth_running_pearson_coeffs", opts={"legend": ['Pearson Coefficient']})
covs = get_running_p_coeffs(logger.data["val_curvature_losses"], logger.data["val_depth_losses"])
logger.plot(covs, "train_curvature_depth_running_pearson_coeffs", opts={"legend": ['Pearson Coefficient']})
ratio_mse_curv_stds = [mse_std / curv_std for mse_std, curv_std in
zip(get_running_std(logger.data["val_mse_losses"]),
get_running_std(logger.data["val_curvature_losses"]))]
logger.plot(ratio_mse_curv_stds, "val_mse_over_curvature_stds", opts={"legend": ['MSE / Curvature STD']})
ratio_mse_depth_stds = [mse_std / depth_std for mse_std, depth_std in
zip(get_running_std(logger.data["val_mse_losses"]),
get_running_std(logger.data["val_depth_losses"]))]
logger.plot(ratio_mse_depth_stds, "val_mse_over_depth_stds", opts={"legend": ['MSE / Depth STD']})