def test_sample_highest_prob(self):
"""
Test :meth:`bet.postProcess.postTools.sample_highest_prob`.
"""
(num_samples,P_samples, samples, _ , data) = postTools.sample_highest_prob(1.0,
self.P_samples,
self.samples,
lam_vol=None, data=self.data, sort=True)
nptest.assert_almost_equal(np.sum(P_samples),1.0)
nptest.assert_equal(num_samples,1000)
(num_samples,P_samples, samples, _ , data) = postTools.sample_highest_prob(0.8,
self.P_samples,
self.samples,
lam_vol=None, data=self.data, sort=True)
nptest.assert_allclose(np.sum(P_samples),0.8,0.001)
def test_sample_highest_prob(self):
"""
Test :meth:`bet.postProcess.postTools.sample_highest_prob`.
"""
(num_samples, sample_set_out, _) = postTools.sample_highest_prob(1.0,
self.data,
sort=True)
nptest.assert_almost_equal(
np.sum(sample_set_out.get_probabilities()), 1.0)
nptest.assert_equal(num_samples, 1000)
(num_samples, sample_set_out, _) = postTools.sample_highest_prob(0.8,
self.data,
sort=True)
nptest.assert_allclose(
np.sum(sample_set_out.get_probabilities()), 0.8, 0.001)
Q_ref = Q[QoI_indices, :].dot(0.5 * np.ones(input_dim))
# bin_ratio defines the uncertainty in our data
bin_ratio = 0.25
# Create discretization object
my_discretization = sample.discretization(input_sample_set=input_samples,
output_sample_set=output_samples)
# Find the simple function approximation
simpleFunP.regular_partition_uniform_distribution_rectangle_scaled(
data_set=my_discretization, Q_ref=Q_ref, rect_scale=bin_ratio,
cells_per_dimension=1)
# Calculate probablities making the Monte Carlo assumption
calculateP.prob(my_discretization)
percentile = 1.0
# Sort samples by highest probability density and find how many samples lie in
# the support of the inverse solution. With the Monte Carlo assumption, this
# also tells us the approximate volume of this support.
(num_samples, _, indices_in_inverse) =\
postTools.sample_highest_prob(top_percentile=percentile,
sample_set=input_samples, sort=True)
# Print the number of samples that make up the highest percentile percent
# samples and ratio of the volume of the parameter domain they take up
if comm.rank == 0:
print (num_samples, np.sum(input_samples.get_volumes()[indices_in_inverse]))
# calculate 1d marginal probs
(bins, marginals1D) = plotP.calculate_1D_marginal_probs(P_samples=P, samples=samples, lam_domain=lam_domain, nbins=20)
# smooth 1d marginal probs (optional)
marginals1D = plotP.smooth_marginals_1D(marginals1D, bins, sigma=1.0)
# plot 1d marginal probs
plotP.plot_1D_marginal_probs(
marginals1D, bins, lam_domain, filename="contaminant_map", interactive=False, lam_ref=ref_lam, lambda_label=labels
)
percentile = 1.0
# Sort samples by highest probability density and sample highest percentile percent samples
(num_samples, P_high, samples_high, lam_vol_high, data_high) = postTools.sample_highest_prob(
top_percentile=percentile, P_samples=P, samples=samples, lam_vol=lam_vol, data=data, sort=True
)
# print the number of samples that make up the highest percentile percent samples and
# ratio of the volume of the parameter domain they take up
print(num_samples, np.sum(lam_vol_high))
# Propogate the probability measure through a different QoI map
(_, P_pred, _, _, data_pred) = postTools.sample_highest_prob(
top_percentile=percentile, P_samples=P, samples=samples, lam_vol=lam_vol, data=dataf[:, 7], sort=True
)
# Plot 1D pdf of predicted QoI
# calculate 1d marginal probs
(bins_pred, marginals1D_pred) = plotP.calculate_1D_marginal_probs(
P_samples=P_pred, samples=data_pred, lam_domain=np.array([[np.min(data_pred), np.max(data_pred)]]), nbins=20
#QoI_indices = [0, 3, 5, 8, 9]
#QoI_indices = [3, 4, 5, 8, 9]
#QoI_indices = [2, 3, 5, 6, 9]
# Restrict the data to have just QoI_indices
data = data[:, QoI_indices]
Q_ref = Q[QoI_indices, :].dot(0.5 * np.ones(Lambda_dim))
# bin_ratio defines the uncertainty in our data
bin_ratio = 0.25
# Find the simple function approximation
(d_distr_prob, d_distr_samples, d_Tree) = simpleFunP.uniform_hyperrectangle(\
data=data, Q_ref=Q_ref, bin_ratio=bin_ratio, center_pts_per_edge = 1)
# Calculate probablities making the Monte Carlo assumption
(P, lam_vol, io_ptr) = calculateP.prob(samples=samples, data=data,
rho_D_M=d_distr_prob, d_distr_samples=d_distr_samples)
percentile = 1.0
# Sort samples by highest probability density and find how many samples lie in
# the support of the inverse solution. With the Monte Carlo assumption, this
# also tells us the approximate volume of this support.
(num_samples, P_high, samples_high, lam_vol_high, data_high) =\
postTools.sample_highest_prob(top_percentile=percentile, P_samples=P,
samples=samples, lam_vol=lam_vol,data = data,sort=True)
# Print the number of samples that make up the highest percentile percent
# samples and ratio of the volume of the parameter domain they take up
if comm.rank == 0:
print (num_samples, np.sum(lam_vol_high))
# calculate 1d marginal probs
(bins, marginals1D) = plotP.calculate_1D_marginal_probs(my_discretization, nbins = 20)
# smooth 1d marginal probs (optional)
marginals1D = plotP.smooth_marginals_1D(marginals1D, bins, sigma=1.0)
# plot 1d marginal probs
plotP.plot_1D_marginal_probs(marginals1D, bins, my_discretization,
filename = "contaminant_map",
interactive=False,
lam_ref=param_ref,
lambda_label=labels)
percentile = 1.0
# Sort samples by highest probability density and sample highest percentile percent samples
(num_samples, my_discretization_highP, indices)= postTools.sample_highest_prob(
percentile, my_discretization, sort=True)
# print the number of samples that make up the highest percentile percent samples and
# ratio of the volume of the parameter domain they take up
print (num_samples, np.sum(my_discretization_highP._input_sample_set.get_volumes()))
# Choose unused QoI as prediction QoI and propagate measure onto predicted QoI data space
QoI_indices_predict = np.array([7])
output_samples_predict = samp.sample_set(QoI_indices_predict.size)
output_samples_predict.set_values(np.loadtxt("files/data.txt.gz")[:,QoI_indices_predict])
output_samples_predict.set_probabilities(input_samples.get_probabilities())
# Determine range of predictions and store as domain for plotting purposes
output_samples_predict.set_domain(output_samples_predict.get_bounding_box())
# Plot 1D pdf of predicted QoI
Q_ref = Q[QoI_indices, :].dot(0.5 * np.ones(input_dim))
# Define the level of uncertainty in the measured reference datum
rect_scale = 0.25
# Make the MC assumption and compute the volumes of each voronoi cell
input_samples.estimate_volume_mc()
# Create discretization object
my_discretization = sample.discretization(input_sample_set=input_samples,
output_sample_set=output_samples)
# Find the simple function approximation
simpleFunP.regular_partition_uniform_distribution_rectangle_scaled(
data_set=my_discretization, Q_ref=Q_ref, rect_scale=rect_scale,
cells_per_dimension=1)
# Compute the solution to the stochastic inverse problem
calculateP.prob(my_discretization)
(_, _, indices_in_inverse) = \
postTools.sample_highest_prob(top_percentile=1.0,
sample_set=input_samples, sort=True)
# Print the approximate percentage of the measure of the parameter space defined
# by the support of the inverse density
if comm.rank == 0:
print 'The approximate percentage of the measure of the parameter space defined'
print 'by the support of the inverse density associated with the choice of QoI map is'
print np.sum(input_samples.get_volumes()[indices_in_inverse])