def compute_uncert(x, y, load=False, save_name="test"):
params = prepare_data.x_to_params(x)
print("Starts to sample posteriors for calibration errors")
t = time.perf_counter()
predictions = model.fn_func(y_all.to(c.device)).detach().cpu().numpy()
x_pred = predictions[:, ::2]
uncert_x_pred = np.sqrt(np.exp(predictions[:, 1::2]))
params_pred = prepare_data.x_to_params(x_pred)
uncert_params_pred = prepare_data.x_to_params(uncert_x_pred, no_mu=True)
diff = params_pred - params
print("mean denorm", np.mean(diff, axis=0))
print("absmean denorm", np.mean(np.abs(diff), axis=0))
print(f"sample and x to params time: {time.perf_counter() - t:.2f}s")
print(
f"Total time to compute inlier matrix: {time.perf_counter() - t:.2f}s")
calibration = diff / uncert_params_pred
print("\n Predictions")
print(predictions[:, 1])
print(predictions[:, 1].max(), predictions[:, 1].min())
print("\n Exp Predictions")
print(np.exp(predictions[:, 1]))
print(np.exp(predictions[:, 1]).max(), np.exp(predictions[:, 1]).min())
return params, x_pred, uncert_x_pred, params_pred, uncert_params_pred, diff, calibration
def show_prediction_changes():
import help_train as ht
torch.manual_seed(71)
years = [2014, 2015, 2016, 2017, 2018]
param_gt_mean = []
output_param_mean = []
#batch_size = 512
#for _, year in enumerate(years):
for i, loadset in enumerate(dataloader.loader):
year = c.dc.viz_years[i]
#sets = dataloader.loadOCODataset(year = [year], analyze=True, noise=False)
#loadset = dataloader.DataLoader(sets,
# batch_size=batch_size, shuffle=True, drop_last=True, num_workers = 1)
x, y, _ = data_helpers.concatenate_set(loadset, 1000)
outputs = ht.sample_posterior(y, x)
output = torch.mean(torch.FloatTensor(outputs), dim=1)
#print(output.size())
#with torch.no_grad():
# output = feature_net.model.fn_func(y.to(c.device)).detach().cpu()
#errors = ht.show_error(f"{year} eval", visualize=False)
#errors.add_error(output,x)
#errors.print_error()
param_gt = prepare_data.x_to_params(x)
output_param = prepare_data.x_to_params(output)
param_gt_mean.append(np.mean(param_gt[:, 0]))
output_param_mean.append(np.mean(output_param[:, 0]))
plt.figure("Cmp_pred_true_INN")
plt.plot(years, param_gt_mean, label="gt")
plt.plot(years, output_param_mean, label="prediction_INN")
plt.legend()
plt.title("Comparison between predicted and true CO2 concentration")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.figure("Offset_per_year_INN")
plt.title("Offset per year")
plt.plot(years,
np.subtract(output_param_mean, param_gt_mean),
label="offset")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.legend()
plt.figure("Increases_per_year_fn")
plt.title("Increases per year")
plt.plot(years[1:],
np.diff(output_param_mean),
label="increase prediction")
plt.plot(years[1:],
[j - i for i, j in zip(param_gt_mean[:-1], param_gt_mean[1:])],
label="increase gt")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.legend()
plt.show(block=False)
def train_solver(epoch, N_epochs,model=model,viz=False):
model.train()
start_t = time.perf_counter()
#raw_index = c.ana_names.index("xco2_raw")
#errors = ht.show_error("train")#, mode = "train")
for batch_idx, (x, y, ana) in enumerate(train_loader):
y, x = y.to(c.device), x.to(c.device)
optim.zero_grad()
model.zero_grad()
output = model.fn_func(y)
#print(output.shape,x.shape)
if c.predict_uncert:
xi = output[:,0]
s = output[:,1]
loss_a = (xi-x[:,0])**2/(2*s**2)+0.5*torch.log(s**2)
loss = torch.mean(loss_a)
else:
loss_a = (output[:,:] - x[:,:])**2
loss = torch.mean(loss_a)
loss.backward()
loss_a = torch.mean(loss_a, dim = 0)
#print(loss_a)
#errors.add_error(output,x)
optim_step()
#print trainloss
if batch_idx % c.fn_pretrain_log_interval == 0:
print(f'\rTrain Epoch: {epoch}/{N_epochs-1} [{batch_idx * len(x)}/{len(train_loader.dataset)}'
f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f} Time: {time.perf_counter() - start_t:.1f}', end='')
##assert not torch.isnan(torch.sum(output)), (loss_a,x,y)
#print testloss
if (batch_idx) % int(len(train_loader.dataset)/len(x)/c.fn_pretrain_number_of_tests) == int(len(train_loader.dataset)/len(x)/c.fn_pretrain_number_of_tests)-1:
print(f"\nTrain_loss {loss_a.detach().cpu().numpy()}")
difference = prepare_data.x_to_params(output.detach().cpu().numpy()) - prepare_data.x_to_params(x.detach().cpu().numpy())
tot_difference = np.mean(np.abs(difference), axis = 0)
rel_difference = np.mean((difference), axis = 0)
print(f"Train errors {tot_difference} and with mean at {rel_difference}")
mean_er = torch.mean(torch.abs(output - x), dim = 0)
print("mean error train",mean_er.detach().cpu().numpy())
#errors.print_error()
break
return loss.item()
def plot():
#for i in range(len(params[0])):
# plot_quality_map(params[:,i],name = params_names[i])
show_co2_change()
params = prepare_data.x_to_params(x_all)
specs = prepare_data.y_to_spectra(y_all)
#plot_quality_map(params[:,co2_pos])
show_param_hists(x_all, name="whightened")
show_param_hists(params, name="orig")
last_specs = specs[:, -20:]
last_specs[:, 6] /= 12
show_param_hists(last_specs,
name="spec-20",
n_parameters=20,
elem_names=prepare_data.spectra_names[-20:])
show_param_hists(y_all[:, -20:],
name="y-20",
n_parameters=20,
elem_names=prepare_data.spectra_names[-20:])
#show_elementcorrelations()
#spectra_positions = [0,spec_length,2*spec_length]
#for i in range(params_in_spectrum):
# spectra_positions.append(3*spec_length+i)
#show_elementcorrelations(spectra[:,spectra_positions],len(prepare_data.spectra_names),"external params",params_names=prepare_data.spectra_names[:])
#show_one_input_data()
show_spectra()
def compute_calibration(x, y, load=False, save_name="test"):
params = prepare_data.x_to_params(x)
import time
n_steps = 100
q_values = []
confidences = np.linspace(0., 1., n_steps + 1, endpoint=True)[1:]
for conf in confidences:
q_low = 0.5 * (1 - conf)
q_high = 0.5 * (1 + conf)
q_values += [q_low, q_high]
print("Starts to sample posteriors for calibration errors")
t = time.perf_counter()
posterior = sample_posterior(y)
diff = torch.mean(torch.FloatTensor(posterior), dim=1) - x
print("meandiff direct", torch.mean(diff, dim=0))
print("absmeandiff direct", torch.mean(torch.abs(diff), dim=0))
posterior = prepare_data.x_to_params(posterior)
diff = np.mean(posterior, axis=1) - params
print("mean denorm", np.mean(diff, axis=0))
print("absmean denorm", np.mean(np.abs(diff), axis=0))
diff3 = np.median(posterior, axis=1) - params
print("meandiff denorm median", np.mean(diff3, axis=0))
print("absmeandiff denorm median", np.mean(np.abs(diff3), axis=0))
print(f"sample and x to params time: {time.perf_counter() - t:.2f}s")
quantile = (np.quantile(posterior[:, :, :], q_values, axis=1))
uncert_intervals = (quantile[1::2, :, :] - quantile[0::2, :, :])
print(
f"Total time to compute inlier matrix: {time.perf_counter() - t:.2f}s")
inliers = ((np.logical_and(np.less(params, quantile[1::2, :, :]),
np.greater(params, quantile[0::2, :, :]))))
uncert_error_co2 = uncert_intervals[68, :, c.co2_pos] / 2
uncert_error = uncert_intervals[68, :, :] / 2
#Calculate error of INN
#error_INN = (quantile[0,:,:]-gt_params)
error_INN = (posterior.mean(axis=1) - params)
return inliers, quantile, uncert_intervals, confidences, params, posterior, uncert_error_co2, uncert_error, error_INN
def show_error_correlations(x=x_all, y=y_all, load=False):
#plot error co2 against: xco2, "albedo_o2","albedo_sco2","albedo_wco2", "tcwv" 4
#and: "year","xco2_apriori","altitude","psurf","t700","longitude","latitude" 7
#"snr_wco2","snr_sco2","snr_o2a","aod_bc","aod_dust","aod_ice","aod_oc","aod_seasalt","aod_sulfate","aod_total","aod_water"
params = prepare_data.x_to_params(x)
spectra = prepare_data.y_to_spectra(y)
post = sample_posterior(y)
diff = torch.mean(torch.FloatTensor(post), dim=1) - x
#post_params =prepare_data.x_to_params(post)
_, _, uncert_intervals, _, post_params = compute_calibration(x,
y,
load=load)
uncert_error_co2 = uncert_intervals[68, :, c.co2_pos] / 2
diff = np.mean(post_params, axis=1) - params
diff_co2 = diff[:, 0]
error_name = ['error_correlations', 'estimated_error_correlations']
for l, spectra in enumerate([spectra, np.array(y)]):
if l == 1:
params = np.array(x)
for k, diff in enumerate([diff_co2, uncert_error_co2]):
plt.figure(error_name[k] + f'_{l}', figsize=(20, 15))
plt.title(error_name[k] + f'_{l}')
print(diff.shape)
horizontal_figures = 4
vertical_figures = 6
diff = np.clip(diff, -4, 4)
for i in range(horizontal_figures):
ax = plt.subplot(horizontal_figures, vertical_figures,
vertical_figures * i + 1)
bins = np.linspace(np.min(diff), np.max(diff), 100)
plt.hist(diff,
bins=bins,
histtype='step',
color="lightskyblue",
orientation="horizontal")
if i > 0:
#ax.axis('off')
ax.set_xticks([])
plt.ylabel(f"error of prediction in ppm")
"""
def train_solver(epoch, N_epochs, model=model, vizual=False):
model.train()
model2.train()
start_t = time.perf_counter()
#raw_index = c.ana_names.index("xco2_raw")
errors = ht.show_error("train") #,loss_fnc= loss_sub, mode = "train")
errors2 = ht.show_error(
"trainuncert", uncertainty=True) #,loss_fnc= loss_sub, mode = "train")
for batch_idx, (x, y, ana) in enumerate(train_loader):
y, x = y.to(c.device), x.to(c.device)
optim.zero_grad()
model.zero_grad()
#print(y.shape)
#print("y",y.shape)
output = model.fn_func(y)
#print(output.shape,x.shape)
loss, loss_a = create_loss(output, x, loss_a_use=True)
loss.backward()
#print(loss_a)
if c.train_uncert:
output = output[:, ::2]
####errors.add_error(output,x)
for i in range(output.shape[0]):
#print(test_output[i],x_test[i])
errors.add_error(output[i][None, :], x[i][None, :])
optim_step()
if two_nets:
optim2.zero_grad()
model2.zero_grad()
output2 = model2.fn_func(y)
#print(output2.shape,x.shape,y.shape)
loss2, loss_a2 = create_loss(output2,
x,
loss_a_use=True,
predict_uncert=True)
loss2.backward()
for i in range(output2.shape[0]):
#print(test_output[i],x_test[i])
#print(output2.shape)
errors2.add_error(output2[i][None, ::2], x[i][None, :],
output2[i][None, 1::2])
#assert 0
optim2.step()
#print trainloss
if batch_idx % c.fn_pretrain_log_interval == 0:
if two_nets:
print(
f'\rTrain Epoch: {epoch}/{N_epochs-1} [{batch_idx * len(x)}/{len(train_loader.dataset)}'
f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f},{loss2.item():.6f}, {torch.mean(loss_a2).item():.4f} Time: {time.perf_counter() - start_t:.1f}',
end='')
else:
print(
f'\rTrain Epoch: {epoch}/{N_epochs-1} [{batch_idx * len(x)}/{len(train_loader.dataset)}'
f'({100. * batch_idx / len(train_loader):.0f}%)]\tLoss: {loss.item():.6f}, Time: {time.perf_counter() - start_t:.1f}',
end='')
##assert not torch.isnan(torch.sum(output)), (loss_a,x,y) #torch.mean(loss_a2).detach().cpu().numpy()
#print testloss
if (batch_idx) % int(
len(train_loader.dataset) / len(x) /
c.fn_pretrain_number_of_tests) == int(
len(train_loader.dataset) / len(x) /
c.fn_pretrain_number_of_tests) - 1:
difference = prepare_data.x_to_params(
output.detach().cpu().numpy()) - prepare_data.x_to_params(
x.detach().cpu().numpy())
difference2 = prepare_data.x_to_params(
output.detach().cpu().numpy()) - prepare_data.x_to_params(
x.detach().cpu().numpy())
tot_difference = np.mean(np.abs(difference), axis=0)
rel_difference = np.mean((difference), axis=0)
print(
f"Train errors {tot_difference} and with mean at {rel_difference}"
)
mean_er = torch.mean(torch.abs(output - x), dim=0)
print("mean error train", mean_er.detach().cpu().numpy())
errors.print_error()
print("new")
#difference = prepare_data.x_to_params(output.detach().cpu().numpy()) - prepare_data.x_to_params(x.detach().cpu().numpy())
if two_nets:
errors2.print_error()
print(f"\nTrain_loss {loss_a.detach().cpu().numpy()}")
print(
f"\nTrain_loss new {loss2.item():.6f}, {torch.mean(loss_a2).detach().cpu().numpy():.6f}{loss_a2.detach().cpu().numpy()}"
)
viz.show_loss(loss2.item(), "trainuncert")
break
return loss.item()
def show_co2_change():
#def hist(x):
# results = []
# h, b = np.histogram(x[:, 0], bins=100, density=True)#range=(-2,2),
# h /= np.max(h)
# results = [b[:-1],h]
# return results
torch.manual_seed(153)
plt.figure(f"CO2 concentration", figsize=(10, 7), dpi=100)
ax = plt.gca()
means = []
for _, year in enumerate(dc.viz_years):
x, y = dataloader.year_sets[year]
#for _, year in enumerate([2014, 2015, 2016, 2017, 2018]):
#sets = dataloader.loadOCODataset(year = [year], analyze=True, noise=False)
#loadset = dataloader.DataLoader(sets,
# batch_size=batch_size, shuffle=True, drop_last=True, num_workers = 1)
#x,_,_ = data_helpers.concatenate_set(loadset,10000)
params = prepare_data.x_to_params(x)
#params_hist = hist(params)
#print(params.min(axis=0))
#print(params.max(axis=0))
#plt.subplot(5, 5/5+1, j +1)
#plt.step(*(params_hist), where='post', label = year)
color = next(ax._get_lines.prop_cycler)['color']
#print(np.shape(params_hist))
sns.set_style("whitegrid")
sns.kdeplot(params[:, 0], bw=0.2, label=year, color=color)
mean = np.mean(params[:, 0])
means.append(mean)
plt.plot([mean, mean], [0, 0.25], color=color)
title = "The means of the years were:"
for mean in means:
title += f" {mean:.2f},"
differences = ""
prev_mean = means[0]
for mean in means[1:]:
differences += f"{mean-prev_mean:.2f}, "
prev_mean = mean
plt.title(title[:-2])
plt.legend()
#plt.tight_layout()
plt.xlabel(f"CO2 in ppm, differences {differences[:-2]}")
plt.figure(f"Mean corrected CO2 distribution", figsize=(10, 7), dpi=100)
ax = plt.gca()
means = []
for _, year in enumerate(dc.viz_years):
x, y = dataloader.year_sets[year]
#for _, year in enumerate([2014, 2015, 2016, 2017, 2018]):
#sets = dataloader.loadOCODataset(year = [year], analyze=True, noise=False)
#loadset = dataloader.DataLoader(sets,
# batch_size=batch_size, shuffle=True, drop_last=True, num_workers = 1)
#x,_,_ = data_helpers.concatenate_set(loadset,10000)
params = prepare_data.x_to_params(x)
#params_hist = hist(params)
#print(params.min(axis=0))
#print(params.max(axis=0))
#plt.subplot(5, 5/5+1, j +1)
#plt.step(*(params_hist), where='post', label = year)
color = next(ax._get_lines.prop_cycler)['color']
#print(np.shape(params_hist))
sns.set_style("whitegrid")
mean = np.mean(params[:, 0])
sns.kdeplot(params[:, 0] - mean, bw=0.2, label=year, color=color)
means.append(mean)
#plt.plot([mean, mean], [0,0.25], color=color)
title = "Mean corrected distribution:"
for mean in means:
title += f" {mean:.2f},"
differences = ""
prev_mean = means[0]
for mean in means[1:]:
differences += f"{mean-prev_mean:.2f}, "
prev_mean = mean
plt.title(title[:-2])
plt.legend()
#plt.tight_layout()
plt.xlabel(f"Distribution shapes, 2014 and 2019 not complete years")
def show_prediction_changes(model, show_two=False):
N_post = c.N_post
z = torch.randn(N_post, c.x_dim).to(c.device)
model.eval()
def sample_posterior(y_it, z=z, N=N_post, model=model):
"""[summary]
Arguments:
y_it {[type]} -- [description]
Keyword Arguments:
z {[type]} -- [description] (default: {z})
N {[type]} -- [description] (default: {N_post})
Returns:
[outputs] -- [sampled]
"""
outputs = []
print("samples_posterior", y_it.shape, z.shape)
for i, y in enumerate(y_it):
y = y.expand(N, -1)
with torch.no_grad():
outputs.append(model.reverse_sample(z, y).data.cpu().numpy())
return outputs
import help_train as ht
three = True
#import nice_eval as ne
torch.manual_seed(71)
years = c.dc.viz_years #[2014, 2015, 2016, 2017, 2018]
param_gt_mean = []
param_gt_mean1 = []
param_gt_mean2 = []
param_gt_mean3 = []
other_gt_mean = []
output_param_mean = []
other_param_mean = []
#batch_size = 512
#for _, year in enumerate(years):
for i, year in enumerate(dataloader.dc.viz_years):
x, y = dataloader.year_sets[year]
x.to(c.device)
y.to(c.device)
print(f"Creates prediction for year {c.dc.viz_years[i]}\n\n\n\n")
#year = c.dc.viz_years[i]
#sets = dataloader.loadOCODataset(year = [year], analyze=True, noise=False)
#loadset = dataloader.DataLoader(sets,
# batch_size=batch_size, shuffle=True, drop_last=True, num_workers = 1)
#x,y,_ = data_helpers.concatenate_set(loadset,1000)'
#print(i,year_set)
#x,y = year_set
print(x.shape, y.shape)
outputs = sample_posterior(y)
output = torch.mean(torch.FloatTensor(outputs), dim=1)
#print(output.size())
#with torch.no_grad():
# output = feature_net.model.fn_func(y.to(c.device)).detach().cpu()
#errors = ht.show_error(f"{year} eval", visualize=False)
#errors.add_error(output,x)
#errors.print_error()
param_gt = prepare_data.x_to_params(x)
output_param = prepare_data.x_to_params(output)
param_gt_mean.append(np.mean(param_gt[:, 0]))
if three:
param_gt_mean1.append(np.mean(param_gt[:, 0]))
param_gt_mean2.append(np.mean(param_gt[:, 1]))
param_gt_mean3.append(np.mean(param_gt[:, 2]))
output_param_mean.append(np.mean(output_param[:, 0]))
if show_two:
other_gt_mean.append(np.mean(param_gt[:, 1]))
other_param_mean.append(np.mean(output_param[:, 1]))
param_gt_mean1 = np.array(param_gt_mean1)
param_gt_mean2 = np.array(param_gt_mean2)
param_gt_mean3 = np.array(param_gt_mean3)
plt.figure("Cmp_pred_true_INN")
plt.plot(years, param_gt_mean, label="gt")
plt.plot(years, output_param_mean, label="prediction_INN")
plt.legend()
plt.title("Comparison between predicted and true CO2 concentration")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.figure("Offset_per_year_INN")
plt.title("Offset per year")
plt.plot(years,
np.subtract(output_param_mean, param_gt_mean),
label="offset")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.legend()
plt.figure("Increases_per_year_fn")
plt.title("Increases per year")
plt.plot(years[1:],
np.diff(output_param_mean),
label="increase prediction")
plt.plot(years[1:],
[j - i for i, j in zip(param_gt_mean[:-1], param_gt_mean[1:])],
label="increase gt")
plt.xlabel("year")
plt.ylabel("CO2 in ppm")
plt.legend()
plt.figure("nice_yoy", figsize=(14, 5))
ax = plt.subplot(1, 2, 1)
plt.plot(years, param_gt_mean, label="True value apriori")
plt.plot(years, output_param_mean, label="Prediction apriori")
if show_two:
plt.plot(years, other_gt_mean, label="True value CO2")
#plt.plot(years, other_param_mean, label = "Prediction co2")
plt.legend(fontsize=18)
plt.title("Comparison between predicted and true mean CO2 concentrations")
plt.xlabel("year", fontsize=18)
plt.ylabel("mean CO2 concentration in ppm", fontsize=18)
ax = plt.subplot(1, 2, 2)
plt.title("Differences from true mean", fontsize=18)
plt.plot(years,
np.subtract(output_param_mean, param_gt_mean),
label="apriori")
if show_two:
plt.plot(years,
np.subtract(other_param_mean, other_gt_mean),
label="Measured")
plt.xlabel("year", fontsize=18)
plt.ylabel("difference of mean CO2 in ppm", fontsize=18)
if show_two:
plt.legend()
plt.tight_layout()
if three:
plt.figure("raw_aprioi_xco2", figsize=(14, 5))
ax = plt.subplot(1, 2, 1)
plt.title("Mean Concentrations", fontsize=18)
plt.plot(years, param_gt_mean1, label="A Priori CO2")
plt.plot(years, param_gt_mean2, label="Raw CO2")
plt.plot(years, param_gt_mean3, label="Correct CO2")
plt.xlabel("year", fontsize=18)
plt.ylabel("CO2 in ppm", fontsize=18)
plt.legend(fontsize=18)
ax = plt.subplot(1, 2, 2)
plt.title("Differences in Concentrations", fontsize=18)
plt.plot(years,
param_gt_mean1 - param_gt_mean2,
label="A Priori - Raw")
plt.plot(years, param_gt_mean3 - param_gt_mean2, label="Correct - Raw")
plt.plot(years,
param_gt_mean3 - param_gt_mean1,
label="Correct - A Priori")
plt.xlabel("year", fontsize=18)
plt.ylabel("CO2 in ppm", fontsize=18)
plt.legend(fontsize=18)
def uncert(model2=model, name="CO2", position=position):
x2 = model2.fn_func(y_all.to(c.device)).detach().cpu().numpy()
params2 = prepare_data.x_to_params(x2[:, ::2])[:, 0]
params_gt = prepare_data.x_to_params(x_all)[:, 0]
errors2 = params2 - params_gt
uncert2 = prepare_data.x_to_params(np.sqrt(np.exp(x2[:, 1::2])),
no_mu=True)[:, 0]
calib2 = errors2 / uncert2
plt.figure(f"Nice_uncerts_{name}", figsize=(15, 5))
#error_INN=np.clip(error_INN,-4,4)
plot_boarders = max(np.max(errors2), -np.min(errors2)) #4
bins = np.linspace(-plot_boarders, plot_boarders, 100)
#error_ret=np.clip(error_ret ,-3,3)
#Error distribution
ax = plt.subplot(1, 2, 1)
(mu_INN, sigma_INN) = norm.fit(errors2)
errors2_clip = np.clip(errors2, -plot_boarders, plot_boarders)
uncert2_clip = np.clip(uncert2, -plot_boarders, plot_boarders)
ax.set_title(
rf"Error distribution, $\mu$={mu_INN:.2f}, $\sigma$={sigma_INN:.2f}",
fontsize=20)
#plt.hist(error_ret, bins=bins, density=False, histtype='step',color="blue",label="retrival")
plt.hist(errors2_clip,
bins=bins,
density=False,
histtype='step',
color="blue",
label="cINN")
plt.hist(uncert2_clip,
bins=bins,
density=False,
histtype='step',
label="uncert")
plt.xlabel("Estimated difference to gt in ppm", fontsize=20)
plt.ylabel("Number of estimations", fontsize=20)
ax = plt.subplot(1, 2, 2)
bins = np.linspace(-4.5, 4.5, 100)
#rel_error_iNN=np.clip(rel_error_iNN,-4,4)
#plt.hist(error_ret/dataloader.ret_params[:c.evaluation_samples,1], density=True, bins=bins, histtype='step',color="blue",label="retrival")
iNN_bins, _, _ = plt.hist(calib2,
bins=bins,
histtype='step',
density=True,
color="blue",
label="cINN")
(mu_INN, sigma_iNN) = norm.fit(calib2)
y_best = scipy.stats.norm.pdf(bins, 0, 1)
xi2_iNN = 0 #np.sum(np.square(y_best-iNN_bins)/y_best)
print(xi2_iNN)
y_INN = scipy.stats.norm.pdf(bins, mu_INN, sigma_iNN)
l = plt.plot(bins,
y_best,
color="black",
linestyle="--",
linewidth=2,
label="optimal gaussian")
l = plt.plot(bins, y_INN, 'b--', linewidth=2, label="gaussian fit on INN")
#l = plt.plot(bins, y_ret, 'r--', linewidth=2)
ax.set_title(
f"mu_INN:{mu_INN:.2f}, sigma_iNN: {sigma_iNN:.2f}",
fontsize=20) #mu_ret: {mu_ret:.2f}, sigma_ret: {sigma_ret:.2f},
c.mu.append(sigma_iNN)
c.sigma.append(mu_INN)
plt.legend()
plt.xlabel("Difference to gt, depending on estimated error", fontsize=20)
plt.ylabel("Prob. density", fontsize=20)
plt.tight_layout()
def show_feature_net_solution():
print("show_feature_net_solution")
orig_prior_hists = hists(prepare_data.x_to_params(x_all))
x = model.fn_func(y_all.to(c.device)).detach().cpu().numpy()
#print("co2_results",x[:100,0])
#print("true_results",x_all[:100,0])
#y_test = y_all.numpy()+prepare_data.mu_y
#print(y_all[:10,:10], y_all[:10,-10:])
y_gt = y_all #[:n_plots]
x_gt = x_all
orig_x_gt = prepare_data.x_to_params(x_gt)
orig_y_gt = prepare_data.y_to_spectra(y_gt)
#print(x.shape)
orig_x = prepare_data.x_to_params(x)
#print(np.shape(orig_x), np.shape(orig_x_gt))
#print("\n")
#plot_world.plot_quality_map((np.abs(orig_x-orig_x_gt)[:,0]),(y_all.detach().cpu().numpy()+prepare_data.mu_y)[:,-2:], "Featurenet prediction")
plot_helpers.plot_quality_map((np.abs(orig_x - orig_x_gt)[:, 0]), position,
"Error of network prediction")
#print(x)
#print(x_gt)
print("shapes:", orig_x.shape, orig_x_gt.shape)
show_error_stats(orig_x[:, 0] - orig_x_gt[:, 0], show_nice=True)
print("show_predicted_error")
x_uncert = model.fn_func(y_all.to(c.device)).detach().cpu().numpy()[:, 1]
#compute s to sigma, following the paper
x_uncert = np.sqrt(np.exp(x_uncert))
uncert = x_uncert * np.linalg.inv(prepare_data.w_x)[0, 0]
plot_helpers.plot_quality_map(uncert, position, "Predicted Uncertainty")
#show_error_stats(uncert, "uncertainty")
#show_error_stats((orig_x[:,0]-orig_x_gt[:,0])/uncert, "normalized")
plot_helpers.plot_quality_map(
np.abs((orig_x[:, 0] - orig_x_gt[:, 0]) / uncert), position,
"Uncertainty quality")
#orig_x_gt = orig_x_gt[:n_plots]
#x_gt = x_gt[:n_plots]
for i in range(n_plots):
#print(x_gt[0])
#print("\n",prepare_datax_to_params(x_gt)[0])
#print(prepare_datax_to_params(x)[0])
#print(x[0])
plt.figure(f"orig_{i}", figsize=(20, 15))
for j in range(n_x):
plt.subplot(3, n_x / 4 + 1, j + 1)
if j == 0:
plt.step(*(orig_prior_hists[j]),
where='post',
color='grey',
label="prior")
plt.plot([orig_x_gt[i, j], orig_x_gt[i, j]], [0, 1],
color='red',
label="ground truth")
plt.plot([orig_x[i, j], orig_x[i, j]], [0, 1],
color='blue',
label="predicted value")
plt.legend()
else:
plt.step(*(orig_prior_hists[j]), where='post', color='grey')
#plt.step(*(hist_i[j+offset]), where='post', color='blue')
#x_low, x_high = np.percentile(orig_posteriors[i][:,j+offset], [q_low, q_high])
plt.plot([orig_x_gt[i, j], orig_x_gt[i, j]], [0, 1],
color='red')
plt.plot([orig_x[i, j], orig_x[i, j]], [0, 1], color='blue')
#plt.plot([orig_y_gt [i,j+offset-18], orig_y_gt[i,j+offset-18]], [0,1], color='orange',alpha=0.5) #is on top of red
#if j+offset == 14:
# x_low=dataloader.ret_params[i,0]-dataloader.ret_params[i,1]
# x_high=dataloader.ret_params[i,0]+dataloader.ret_params[i,1]
# plt.plot([x_low, x_low], [0,1], color='green')
# plt.plot([x_high, x_high], [0,1], color='green')
plt.xlabel(f"{c.param_names[j]}")
def show_posterior_histograms(params,
posteriors,
n_plots=n_plots,
orig_prior_hists=hists(
prepare_data.x_to_params(x_all))):
confidence = 0.68
q_low = 100. * 0.5 * (1 - confidence)
q_high = 100. * 0.5 * (1 + confidence)
for i in range(n_plots):
hist_i = hists(posteriors[i])
show_orig_number = n_plots - 10
if i < show_orig_number:
plt.figure(f"orig_{i}", figsize=(15, 7))
for j in range(n_x):
ax = plt.subplot((n_x + 2) / 3, 3, j + 1)
plt.step(*(orig_prior_hists[j]),
where='post',
color='grey',
label="gt dist. of other samples")
plt.step(*(hist_i[j]),
where='post',
color='blue',
label="sampled predictions")
x_low, x_high = np.percentile(posteriors[i][:, j],
[q_low, q_high])
if j == c.co2_pos:
raw_index = prepare_data.ana_names.index("xco2_raw")
unc_index = prepare_data.ana_names.index(
"xco2_uncertainty")
ap_index = prepare_data.ana_names.index("xco2_apriori")
if x_low < 100:
raw_xco2 = ana_all[i, raw_index] - ana_all[i, ap_index]
else:
raw_xco2 = ana_all[i, raw_index]
#x_low=params[i,j]-ana_all[i,unc_index]
#x_high=params[i,j]+ana_all[i,unc_index]
ret_uncert = ana_all[i, unc_index]
ret_bins = np.linspace(params[i, j] - 3 * ret_uncert,
params[i, j] + 3 * ret_uncert, 100)
y_best = scipy.stats.norm.pdf(ret_bins, params[i, j],
ret_uncert)
#scipy.stats.norm.pdf()
plt.plot(ret_bins,
y_best / y_best.max(),
color='brown',
label="uncertainty of gt")
plt.plot([x_low, x_low], [0, 1], color='green')
plt.plot([x_high, x_high], [0, 1],
color='green',
label="1 sigma range")
plt.plot([params[i, j], params[i, j]], [0, 1],
color='red',
linewidth=2,
label="ground truth")
plt.plot([], [], color='brown', label="uncertainty of gt")
unit = ""
if c.param_names[j] == "xco2":
unit = " in ppm"
if c.param_names[j] == "tcwv":
unit = r" in kg $m^{-2}$"
#plt.xlabel(rf"{c.param_names[j]}{unit}")
ax.set_title(rf"{c.param_names[j]}{unit}", fontsize=17)
plt.legend(fontsize=13)
plt.tight_layout()
