def save(self, mdict, save_file, discretization=None, globalize=False):
"""
Save matrices to a ``*.mat`` file for use by ``MATLAB BET`` code and
:meth:`~bet.basicSampling.loadmat`
:param dict mdict: dictonary of sampler parameters
:param string save_file: file name
:param discretization: input and output from sampling
:type discretization: :class:`bet.sample.discretization`
:param bool globalize: Makes local variables global.
"""
if comm.size > 1 and not globalize:
local_save_file = os.path.join(
os.path.dirname(save_file),
"proc{}_{}".format(comm.rank, os.path.basename(save_file)))
else:
local_save_file = save_file
if (globalize and comm.rank == 0) or not globalize:
sio.savemat(local_save_file, mdict)
comm.barrier()
if discretization is not None:
sample.save_discretization(discretization,
save_file,
globalize=globalize)
def save(self, mdict, save_file, discretization=None, globalize=False):
"""
Save matrices to a ``*.mat`` file for use by ``MATLAB BET`` code and
:meth:`~bet.basicSampling.loadmat`
:param dict mdict: dictonary of sampler parameters
:param string save_file: file name
:param discretization: input and output from sampling
:type discretization: :class:`bet.sample.discretization`
:param bool globalize: Makes local variables global.
"""
if comm.size > 1 and not globalize:
local_save_file = os.path.join(os.path.dirname(save_file),
"proc{}_{}".format(comm.rank, os.path.basename(save_file)))
else:
local_save_file = save_file
if (globalize and comm.rank == 0) or not globalize:
sio.savemat(local_save_file, mdict)
comm.barrier()
if discretization is not None:
sample.save_discretization(discretization, save_file,
globalize=globalize)
def tearDown(self):
comm.barrier()
for f in self.savefiles:
if comm.rank == 0 and os.path.exists(f+".mat"):
os.remove(f+".mat")
proc_savefiles = glob.glob("p{}*.mat".format(comm.rank))
proc_savefiles.extend(glob.glob("proc{}*.mat".format(comm.rank)))
for pf in proc_savefiles:
if os.path.exists(pf):
os.remove(pf)
def tearDown(self):
"""
Clean up extra files
"""
comm.barrier()
if comm.rank == 0:
for f in self.savefiles:
if os.path.exists(f+".mat"):
os.remove(f+".mat")
comm.barrier()
def tearDown(self):
comm.barrier()
for f in self.savefiles:
if comm.rank == 0 and os.path.exists(f + ".mat"):
os.remove(f + ".mat")
proc_savefiles = glob.glob("p{}*.mat".format(comm.rank))
proc_savefiles.extend(glob.glob("proc{}*.mat".format(comm.rank)))
for pf in proc_savefiles:
if os.path.exists(pf):
os.remove(pf)
def tearDown(self):
"""
Clean up extra files
"""
comm.barrier()
if comm.rank == 0:
for f in self.savefiles:
if os.path.exists(f + ".mat"):
os.remove(f + ".mat")
comm.barrier()
def my_model(io_file_name):
# read in input from file
io_mdat = sio.loadmat(io_file_name)
input = io_mdat['input']
# localize input
input_local = np.array_split(input, comm.size)[comm.rank]
# model is y = x[:, 0:dim/2 ] + x[:, dim/2:]
output_local = sum(np.split(input_local, 2, 1))
# save output to file
io_mdat['output'] = util.get_global_values(output_local)
comm.barrier()
if comm.rank == 0:
sio.savemat(io_file_name, io_mdat)
def my_model(io_file_name):
# read in input from file
io_mdat = sio.loadmat(io_file_name)
input = io_mdat['input']
# localize input
input_local = np.array_split(input, comm.size)[comm.rank]
# model is y = x[:, 0:dim/2 ] + x[:, dim/2:]
output_local = sum(np.split(input_local, 2, 1))
# save output to file
io_mdat['output'] = util.get_global_values(output_local)
comm.barrier()
if comm.rank == 0:
sio.savemat(io_file_name, io_mdat)
def verify_create_random_discretization(model, sampler, sample_type, input_domain,
num_samples, savefile):
np.random.seed(1)
# recreate the samples
if num_samples is None:
num_samples = sampler.num_samples
input_sample_set = sample_set(input_domain.shape[0])
input_sample_set.set_domain(input_domain)
input_left = np.repeat([input_domain[:, 0]], num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], num_samples, 0)
input_values = (input_right-input_left)
if sample_type == "lhs":
input_values = input_values * pyDOE.lhs(input_sample_set.get_dim(),
num_samples, 'center')
elif sample_type == "random" or "r":
input_values = input_values * np.random.random(input_left.shape)
input_values = input_values + input_left
input_sample_set.set_values(input_values)
# evalulate the model at the samples directly
output_values = (model(input_sample_set._values))
if len(output_values.shape) == 1:
output_sample_set = sample_set(1)
else:
output_sample_set = sample_set(output_values.shape[1])
output_sample_set.set_values(output_values)
# reset the random seed
np.random.seed(1)
comm.barrier()
# create the random discretization using a specified input domain
my_discretization = sampler.create_random_discretization(sample_type,
input_domain, savefile, num_samples=num_samples, globalize=True)
#comm.barrier()
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
# did num_samples get updated?
assert my_num == sampler.num_samples
# did the file get correctly saved?
saved_disc = bet.sample.load_discretization(savefile)
# compare the samples
nptest.assert_array_equal(my_discretization._input_sample_set.get_values(),
saved_disc._input_sample_set.get_values())
# compare the data
nptest.assert_array_equal(my_discretization._output_sample_set.get_values(),
saved_disc._output_sample_set.get_values())
# reset the random seed
np.random.seed(1)
my_sample_set = sample_set(input_domain.shape[0])
my_sample_set.set_domain(input_domain)
#comm.barrier()
# create the random discretization using an initialized sample_set
my_discretization = sampler.create_random_discretization(sample_type,
my_sample_set, savefile, num_samples=num_samples,
globalize=True)
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
# reset the random seed
np.random.seed(1)
# recreate the samples to test default choices with unit hypercube domain
if num_samples is None:
num_samples = sampler.num_samples
my_dim = input_domain.shape[0]
input_sample_set = sample_set(my_dim)
input_sample_set.set_domain(np.repeat([[0.0, 1.0]], my_dim, axis=0))
input_left = np.repeat([input_domain[:, 0]], num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], num_samples, 0)
input_values = (input_right - input_left)
if sample_type == "lhs":
input_values = input_values * pyDOE.lhs(input_sample_set.get_dim(),
num_samples, 'center')
elif sample_type == "random" or "r":
input_values = input_values * np.random.random(input_left.shape)
input_values = input_values + input_left
input_sample_set.set_values(input_values)
# reset random seed
np.random.seed(1)
comm.barrier()
# create the random discretization using a specified input_dim
my_discretization = sampler.create_random_discretization(sample_type,
my_dim, savefile, num_samples=num_samples, globalize=True)
#comm.barrier()
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
def plot_1D_marginal_probs(marginals, bins, sample_set,
filename="file", lam_ref=None, interactive=False,
lambda_label=None, file_extension=".png"):
"""
This makes plots of every single marginal probability of
input probability measure on a 1D grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 1D marginal probabilities
:type marginals: dictionary with int as keys and :class:`~numpy.ndarray` of
shape (nbins+1,) as values :param bins: Endpoints of bins used in
calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
if comm.rank == 0:
index = copy.deepcopy(marginals.keys())
index.sort()
for i in index:
x_range = np.linspace(lam_domain[i, 0], lam_domain[i, 1],
len(bins[i])-1)
fig = plt.figure(i)
ax = fig.add_subplot(111)
ax.plot(x_range, marginals[i]/(bins[i][1]-bins[i][0]))
ax.set_ylim([0, 1.05*np.max(marginals[i]/(bins[i][1]-bins[i][0]))])
if lam_ref is not None:
ax.plot(lam_ref[i], 0.0, 'ko', markersize=10)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i+1) + '}$'
else:
label1 = lambda_label[i]
ax.set_xlabel(label1)
ax.set_ylabel(r'$\rho$')
plt.tight_layout()
fig.savefig(filename + "_1D_" + str(i) + file_extension,
transparent=True)
if interactive:
plt.show()
else:
plt.close()
plt.clf()
comm.barrier()
def test_loadmat_init():
"""
Tests :meth:`bet.sampling.adaptiveSampling.loadmat` and
:meth:`bet.sampling.adaptiveSampling.sampler.init`.
"""
np.random.seed(1)
chain_length = 5
mdat1 = {'num_samples': 50, 'chain_length': chain_length}
mdat2 = {'num_samples': 60, 'chain_length': chain_length}
model = "this is not a model"
my_input1 = sample_set(1)
my_input1.set_values(np.random.random((50, 1)))
my_output1 = sample_set(1)
my_output1.set_values(np.random.random((50, 1)))
my_input2 = sample_set(1)
my_input2.set_values(np.random.random((60, 1)))
my_output2 = sample_set(1)
my_output2.set_values(np.random.random((60, 1)))
num_samples = np.array([50, 60])
num_chains_pproc1, num_chains_pproc2 = np.ceil(num_samples/float(
chain_length*comm.size)).astype('int')
num_chains1, num_chains2 = comm.size * np.array([num_chains_pproc1,
num_chains_pproc2])
num_samples1, num_samples2 = chain_length * np.array([num_chains1,
num_chains2])
mdat1['num_chains'] = num_chains1
mdat1['kern_old'] = np.random.random((num_chains1,))
mdat1['step_ratios'] = np.random.random((num_samples[0],))
mdat2['num_chains'] = num_chains2
mdat2['kern_old'] = np.random.random((num_chains2,))
mdat2['step_ratios'] = np.random.random((num_samples[1],))
sio.savemat(os.path.join(local_path, 'testfile1'), mdat1)
sio.savemat(os.path.join(local_path, 'testfile2'), mdat2)
bet.sample.save_discretization(disc(my_input1, my_output1),
os.path.join(local_path, 'testfile1'), globalize=True)
bet.sample.save_discretization(disc(my_input2, my_output2),
os.path.join(local_path, 'testfile2'), globalize=True)
loaded_sampler1, discretization1, _, _ = asam.loadmat(os.path.join(local_path,
'testfile1'), hot_start=2)
nptest.assert_array_equal(discretization1._input_sample_set.get_values(),
my_input1.get_values())
nptest.assert_array_equal(discretization1._output_sample_set.get_values(),
my_output1.get_values())
assert loaded_sampler1.num_samples == num_samples1
assert loaded_sampler1.chain_length == chain_length
assert loaded_sampler1.num_chains_pproc == num_chains_pproc1
assert loaded_sampler1.num_chains == num_chains1
nptest.assert_array_equal(np.repeat(np.arange(num_chains1), chain_length, 0),
loaded_sampler1.sample_batch_no)
assert loaded_sampler1.lb_model == None
loaded_sampler2, discretization2, _, _ = asam.loadmat(os.path.join(local_path,
'testfile2'), lb_model=model, hot_start=2)
nptest.assert_array_equal(discretization2._input_sample_set.get_values(),
my_input2.get_values())
assert loaded_sampler2.num_samples == num_samples2
assert loaded_sampler2.chain_length == chain_length
assert loaded_sampler2.num_chains_pproc == num_chains_pproc2
assert loaded_sampler2.num_chains == num_chains2
nptest.assert_array_equal(np.repeat(np.arange(num_chains2), chain_length, 0),
loaded_sampler2.sample_batch_no)
nptest.assert_array_equal(discretization2._output_sample_set.get_values(),
my_output2.get_values())
comm.barrier()
if comm.rank == 0:
if os.path.exists(os.path.join(local_path, 'testfile1.mat')):
os.remove(os.path.join(local_path, 'testfile1.mat'))
if os.path.exists(os.path.join(local_path, 'testfile2.mat')):
os.remove(os.path.join(local_path, 'testfile2.mat'))
def random_sample_set(sample_type,
input_obj,
num_samples,
criterion='center',
globalize=True):
"""
Sampling algorithm with three basic options
* ``random`` (or ``r``) generates ``num_samples`` samples in
``lam_domain`` assuming a Lebesgue measure.
* ``lhs`` generates a latin hyper cube of samples.
Note: This function is designed only for generalized rectangles and
assumes a Lebesgue measure on the parameter space.
:param string sample_type: type sampling random (or r),
latin hypercube(lhs), regular grid (rg), or space-filling
curve(TBD)
:param input_obj: :class:`~bet.sample.sample_set` object containing
the dimension/domain to sample from, domain to sample from, or the
dimension
:type input_obj: :class:`~bet.sample.sample_set` or
:class:`numpy.ndarray` of shape (dim, 2) or ``int``
:param string savefile: filename to save discretization
:param int num_samples: N, number of samples
:param string criterion: latin hypercube criterion see
`PyDOE <http://pythonhosted.org/pyDOE/randomized.html>`_
:param bool globalize: Makes local variables global. Only applies if
``parallel==True``.
:rtype: :class:`~bet.sample.sample_set`
:returns: :class:`~bet.sample.sample_set` object which contains
input ``num_samples``
"""
# check to see what the input object is
if isinstance(input_obj, sample.sample_set):
input_sample_set = input_obj.copy()
elif isinstance(input_obj, int):
input_sample_set = sample.sample_set(input_obj)
elif isinstance(input_obj, np.ndarray):
input_sample_set = sample.sample_set(input_obj.shape[0])
input_sample_set.set_domain(input_obj)
else:
raise bad_object("Improper sample object")
# Create N samples
dim = input_sample_set.get_dim()
if input_sample_set.get_domain() is None:
# create the domain
input_domain = np.array([[0., 1.]] * dim)
input_sample_set.set_domain(input_domain)
if sample_type == "lhs":
# update the bounds based on the number of samples
input_sample_set.update_bounds(num_samples)
input_values = np.copy(input_sample_set._width)
input_values = input_values * lhs(dim, num_samples, criterion)
input_values = input_values + input_sample_set._left
input_sample_set.set_values_local(
np.array_split(input_values, comm.size)[comm.rank])
elif sample_type == "random" or "r":
# define local number of samples
num_samples_local = int((num_samples / comm.size) +
(comm.rank < num_samples % comm.size))
# update the bounds based on the number of samples
input_sample_set.update_bounds_local(num_samples_local)
input_values_local = np.copy(input_sample_set._width_local)
input_values_local = input_values_local * \
np.random.random(input_values_local.shape)
input_values_local = input_values_local + input_sample_set._left_local
input_sample_set.set_values_local(input_values_local)
comm.barrier()
if globalize:
input_sample_set.local_to_global()
else:
input_sample_set._values = None
return input_sample_set
def random_sample_set(sample_type, input_obj, num_samples,
criterion='center', globalize=True):
"""
Sampling algorithm with three basic options
* ``random`` (or ``r``) generates ``num_samples`` samples in
``lam_domain`` assuming a Lebesgue measure.
* ``lhs`` generates a latin hyper cube of samples.
Note: This function is designed only for generalized rectangles and
assumes a Lebesgue measure on the parameter space.
:param string sample_type: type sampling random (or r),
latin hypercube(lhs), regular grid (rg), or space-filling
curve(TBD)
:param input_obj: :class:`~bet.sample.sample_set` object containing
the dimension/domain to sample from, domain to sample from, or the
dimension
:type input_obj: :class:`~bet.sample.sample_set` or
:class:`numpy.ndarray` of shape (dim, 2) or ``int``
:param string savefile: filename to save discretization
:param int num_samples: N, number of samples
:param string criterion: latin hypercube criterion see
`PyDOE <http://pythonhosted.org/pyDOE/randomized.html>`_
:param bool globalize: Makes local variables global. Only applies if
``parallel==True``.
:rtype: :class:`~bet.sample.sample_set`
:returns: :class:`~bet.sample.sample_set` object which contains
input ``num_samples``
"""
# check to see what the input object is
if isinstance(input_obj, sample.sample_set):
input_sample_set = input_obj.copy()
elif isinstance(input_obj, int):
input_sample_set = sample.sample_set(input_obj)
elif isinstance(input_obj, np.ndarray):
input_sample_set = sample.sample_set(input_obj.shape[0])
input_sample_set.set_domain(input_obj)
else:
raise bad_object("Improper sample object")
# Create N samples
dim = input_sample_set.get_dim()
if input_sample_set.get_domain() is None:
# create the domain
input_domain = np.array([[0., 1.]]*dim)
input_sample_set.set_domain(input_domain)
if sample_type == "lhs":
# update the bounds based on the number of samples
input_sample_set.update_bounds(num_samples)
input_values = np.copy(input_sample_set._width)
input_values = input_values * lhs(dim,
num_samples, criterion)
input_values = input_values + input_sample_set._left
input_sample_set.set_values_local(np.array_split(input_values,
comm.size)[comm.rank])
elif sample_type == "random" or "r":
# define local number of samples
num_samples_local = int((num_samples/comm.size) +
(comm.rank < num_samples % comm.size))
# update the bounds based on the number of samples
input_sample_set.update_bounds_local(num_samples_local)
input_values_local = np.copy(input_sample_set._width_local)
input_values_local = input_values_local * \
np.random.random(input_values_local.shape)
input_values_local = input_values_local + input_sample_set._left_local
input_sample_set.set_values_local(input_values_local)
comm.barrier()
if globalize:
input_sample_set.local_to_global()
else:
input_sample_set._values = None
return input_sample_set
def verify_create_random_discretization(model, sampler, sample_type,
input_domain, num_samples, savefile):
np.random.seed(1)
# recreate the samples
if num_samples is None:
num_samples = sampler.num_samples
input_sample_set = sample_set(input_domain.shape[0])
input_sample_set.set_domain(input_domain)
input_left = np.repeat([input_domain[:, 0]], num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], num_samples, 0)
input_values = (input_right - input_left)
if sample_type == "lhs":
input_values = input_values * pyDOE.lhs(input_sample_set.get_dim(),
num_samples, 'center')
elif sample_type == "random" or "r":
input_values = input_values * np.random.random(input_left.shape)
input_values = input_values + input_left
input_sample_set.set_values(input_values)
# evalulate the model at the samples directly
output_values = (model(input_sample_set._values))
if len(output_values.shape) == 1:
output_sample_set = sample_set(1)
else:
output_sample_set = sample_set(output_values.shape[1])
output_sample_set.set_values(output_values)
# reset the random seed
np.random.seed(1)
comm.barrier()
# create the random discretization using a specified input domain
my_discretization = sampler.create_random_discretization(
sample_type,
input_domain,
savefile,
num_samples=num_samples,
globalize=True)
#comm.barrier()
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
# did num_samples get updated?
assert my_num == sampler.num_samples
# did the file get correctly saved?
saved_disc = bet.sample.load_discretization(savefile)
# compare the samples
nptest.assert_array_equal(my_discretization._input_sample_set.get_values(),
saved_disc._input_sample_set.get_values())
# compare the data
nptest.assert_array_equal(
my_discretization._output_sample_set.get_values(),
saved_disc._output_sample_set.get_values())
# reset the random seed
np.random.seed(1)
my_sample_set = sample_set(input_domain.shape[0])
my_sample_set.set_domain(input_domain)
#comm.barrier()
# create the random discretization using an initialized sample_set
my_discretization = sampler.create_random_discretization(
sample_type,
my_sample_set,
savefile,
num_samples=num_samples,
globalize=True)
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
# reset the random seed
np.random.seed(1)
# recreate the samples to test default choices with unit hypercube domain
if num_samples is None:
num_samples = sampler.num_samples
my_dim = input_domain.shape[0]
input_sample_set = sample_set(my_dim)
input_sample_set.set_domain(np.repeat([[0.0, 1.0]], my_dim, axis=0))
input_left = np.repeat([input_domain[:, 0]], num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], num_samples, 0)
input_values = (input_right - input_left)
if sample_type == "lhs":
input_values = input_values * pyDOE.lhs(input_sample_set.get_dim(),
num_samples, 'center')
elif sample_type == "random" or "r":
input_values = input_values * np.random.random(input_left.shape)
input_values = input_values + input_left
input_sample_set.set_values(input_values)
# reset random seed
np.random.seed(1)
comm.barrier()
# create the random discretization using a specified input_dim
my_discretization = sampler.create_random_discretization(
sample_type, my_dim, savefile, num_samples=num_samples, globalize=True)
#comm.barrier()
my_num = my_discretization.check_nums()
# make sure that the samples are within the boundaries
assert np.all(my_discretization._input_sample_set._values <= input_right)
assert np.all(my_discretization._input_sample_set._values >= input_left)
if comm.size == 0:
# compare the samples
nptest.assert_array_equal(input_sample_set._values,
my_discretization._input_sample_set._values)
# compare the data
nptest.assert_array_equal(output_sample_set._values,
my_discretization._output_sample_set._values)
def plot_2D_marginal_contours(marginals,
bins,
sample_set,
contour_num=8,
lam_ref=None,
lam_refs=None,
plot_domain=None,
interactive=False,
lambda_label=None,
contour_font_size=20,
filename="file",
file_extension=".png"):
"""
This makes contour plots of every pair of marginals (or joint in 2d case)
of input probability measure on a rectangular grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 2D marginal probabilities
:type marginals: dictionary with tuples of 2 integers as keys and
:class:`~numpy.ndarray` of shape (nbins+1,) as values
:param bins: Endpoints of bins used in calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,2)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
matplotlib.rcParams['xtick.direction'] = 'out'
matplotlib.rcParams['ytick.direction'] = 'out'
matplotlib.rcParams.update({'figure.autolayout': True})
if comm.rank == 0:
pairs = copy.deepcopy(marginals.keys())
pairs.sort()
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.add_subplot(111)
boxSize = (bins[i][1] - bins[i][0]) * (bins[j][1] - bins[j][0])
nx = len(bins[i]) - 1
ny = len(bins[j]) - 1
dx = bins[i][1] - bins[i][0]
dy = bins[j][1] - bins[j][0]
x_kernel = np.linspace(-nx * dx / 2, nx * dx / 2, nx)
y_kernel = np.linspace(-ny * dy / 2, ny * dy / 2, ny)
X, Y = np.meshgrid(x_kernel, y_kernel, indexing='ij')
quadmesh = ax.contour(marginals[(i, j)].transpose() / boxSize,
contour_num,
colors='k',
extent=[
lam_domain[i][0], lam_domain[i][1],
lam_domain[j][0], lam_domain[j][1]
],
origin='lower',
vmax=marginals[(i, j)].max() / boxSize,
vmin=0,
aspect='auto')
if lam_refs is not None:
ax.plot(lam_refs[:, i], lam_refs[:, j], 'wo', markersize=20)
if lam_ref is not None:
ax.plot(lam_ref[i], lam_ref[j], 'ko', markersize=20)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i + 1) + '}$'
label2 = r'$\lambda_{' + str(j + 1) + '}$'
else:
label1 = lambda_label[i]
label2 = lambda_label[j]
ax.set_xlabel(label1, fontsize=30)
ax.set_ylabel(label2, fontsize=30)
ax.tick_params(axis='both', which='major', labelsize=20)
plt.clabel(quadmesh,
fontsize=contour_font_size,
inline=1,
style='sci')
if plot_domain is None:
plt.axis([
lam_domain[i][0], lam_domain[i][1], lam_domain[j][0],
lam_domain[j][1]
])
else:
plt.axis([
plot_domain[i][0], plot_domain[i][1], plot_domain[j][0],
plot_domain[j][1]
])
fig.savefig(filename + "_2D_contours_" + str(i) + "_" + str(j) +\
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
comm.barrier()
def plot_2D_marginal_probs(marginals,
bins,
sample_set,
filename="file",
lam_ref=None,
plot_surface=False,
interactive=False,
lambda_label=None,
file_extension=".png"):
"""
This makes plots of every pair of marginals (or joint in 2d case) of
input probability measure on a rectangular grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 2D marginal probabilities
:type marginals: dictionary with tuples of 2 integers as keys and
:class:`~numpy.ndarray` of shape (nbins+1,) as values
:param bins: Endpoints of bins used in calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,2)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
from matplotlib import cm
if plot_surface:
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator, FormatStrFormatter
if comm.rank == 0:
pairs = copy.deepcopy(marginals.keys())
pairs.sort()
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.add_subplot(111)
boxSize = (bins[i][1] - bins[i][0]) * (bins[j][1] - bins[j][0])
quadmesh = ax.imshow(marginals[(i, j)].transpose() / boxSize,
interpolation='bicubic',
cmap=cm.CMRmap_r,
extent=[
lam_domain[i][0], lam_domain[i][1],
lam_domain[j][0], lam_domain[j][1]
],
origin='lower',
vmax=marginals[(i, j)].max() / boxSize,
vmin=0,
aspect='auto')
if lam_ref is not None:
ax.plot(lam_ref[i], lam_ref[j], 'wo', markersize=10)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i + 1) + '}$'
label2 = r'$\lambda_{' + str(j + 1) + '}$'
else:
label1 = lambda_label[i]
label2 = lambda_label[j]
ax.set_xlabel(label1, fontsize=20)
ax.set_ylabel(label2, fontsize=20)
ax.tick_params(axis='both', which='major', labelsize=14)
label_cbar = r'$\rho_{\lambda_{' + str(i + 1) + '}, '
label_cbar += r'\lambda_{' + str(j + 1) + '}' + '}$ (Lebesgue)'
cb = fig.colorbar(quadmesh, ax=ax, label=label_cbar)
cb.ax.tick_params(labelsize=14)
cb.set_label(label_cbar, size=20)
plt.axis([
lam_domain[i][0], lam_domain[i][1], lam_domain[j][0],
lam_domain[j][1]
])
fig.savefig(filename + "_2D_" + str(i) + "_" + str(j) +\
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
if plot_surface:
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.gca(projection='3d')
X = bins[i][:-1] + np.diff(bins[i]) / 2
Y = bins[j][:-1] + np.diff(bins[j]) / 2
X, Y = np.meshgrid(X, Y, indexing='ij')
surf = ax.plot_surface(X,
Y,
marginals[(i, j)],
rstride=1,
cstride=1,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
ax.set_xlabel(r'$\lambda_{' + str(i + 1) + '}$')
ax.set_ylabel(r'$\lambda_{' + str(j + 1) + '}$')
ax.set_zlabel(r'$P$')
plt.backgroundcolor = 'w'
fig.colorbar(surf, shrink=0.5, aspect=5, label=r'$P$')
fig.savefig(filename + "_surf_" + str(i) + "_" + str(j) + \
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
plt.clf()
comm.barrier()
def plot_1D_marginal_probs(marginals,
bins,
sample_set,
filename="file",
lam_ref=None,
interactive=False,
lambda_label=None,
file_extension=".png"):
"""
This makes plots of every single marginal probability of
input probability measure on a 1D grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 1D marginal probabilities
:type marginals: dictionary with int as keys and :class:`~numpy.ndarray` of
shape (nbins+1,) as values :param bins: Endpoints of bins used in
calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
if comm.rank == 0:
index = copy.deepcopy(marginals.keys())
index.sort()
for i in index:
x_range = np.linspace(lam_domain[i, 0], lam_domain[i, 1],
len(bins[i]) - 1)
fig = plt.figure(i)
ax = fig.add_subplot(111)
ax.plot(x_range, marginals[i] / (bins[i][1] - bins[i][0]))
ax.set_ylim(
[0, 1.05 * np.max(marginals[i] / (bins[i][1] - bins[i][0]))])
if lam_ref is not None:
ax.plot(lam_ref[i],
0.02 * 1.05 * np.max(marginals[i] /
(bins[i][1] - bins[i][0])),
'ko',
markersize=15)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i + 1) + '}$'
else:
label1 = lambda_label[i]
ax.set_xlabel(label1, fontsize=30)
ax.set_ylabel(r'PDF', fontsize=30)
ax.tick_params(axis='both', which='major', labelsize=20)
fig.savefig(filename + "_1D_" + str(i) + file_extension,
transparent=True)
if interactive:
plt.show()
else:
plt.close()
plt.clf()
comm.barrier()
def plot_2D_marginal_probs(marginals, bins, sample_set,
filename="file", lam_ref=None, plot_surface=False, interactive=False,
lambda_label=None, file_extension=".png"):
"""
This makes plots of every pair of marginals (or joint in 2d case) of
input probability measure on a rectangular grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 2D marginal probabilities
:type marginals: dictionary with tuples of 2 integers as keys and
:class:`~numpy.ndarray` of shape (nbins+1,) as values
:param bins: Endpoints of bins used in calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,2)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
from matplotlib import cm
if plot_surface:
from mpl_toolkits.mplot3d import Axes3D
from matplotlib.ticker import LinearLocator, FormatStrFormatter
if comm.rank == 0:
pairs = copy.deepcopy(marginals.keys())
pairs.sort()
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.add_subplot(111)
boxSize = (bins[i][1]-bins[i][0])*(bins[j][1]-bins[j][0])
quadmesh = ax.imshow(marginals[(i, j)].transpose()/boxSize,
interpolation='bicubic', cmap=cm.CMRmap_r,
extent=[lam_domain[i][0], lam_domain[i][1],
lam_domain[j][0], lam_domain[j][1]], origin='lower',
vmax=marginals[(i, j)].max()/boxSize, vmin=0, aspect='auto')
if lam_ref is not None:
ax.plot(lam_ref[i], lam_ref[j], 'wo', markersize=10)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i+1) + '}$'
label2 = r'$\lambda_{' + str(j+1) + '}$'
else:
label1 = lambda_label[i]
label2 = lambda_label[j]
ax.set_xlabel(label1, fontsize=20)
ax.set_ylabel(label2, fontsize=20)
ax.tick_params(axis='both', which='major', labelsize=14)
label_cbar = r'$\rho_{\lambda_{' + str(i+1) + '}, '
label_cbar += r'\lambda_{' + str(j+1) + '}' + '}$ (Lebesgue)'
cb = fig.colorbar(quadmesh, ax=ax, label=label_cbar)
cb.ax.tick_params(labelsize=14)
cb.set_label(label_cbar, size=20)
plt.axis([lam_domain[i][0], lam_domain[i][1], lam_domain[j][0],
lam_domain[j][1]])
plt.tight_layout()
fig.savefig(filename + "_2D_" + str(i) + "_" + str(j) +\
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
if plot_surface:
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.gca(projection='3d')
X = bins[i][:-1] + np.diff(bins[i])/2
Y = bins[j][:-1] + np.diff(bins[j])/2
X, Y = np.meshgrid(X, Y, indexing='ij')
surf = ax.plot_surface(X, Y, marginals[(i, j)], rstride=1,
cstride=1, cmap=cm.coolwarm, linewidth=0,
antialiased=False)
ax.zaxis.set_major_locator(LinearLocator(10))
ax.zaxis.set_major_formatter(FormatStrFormatter('%.02f'))
ax.set_xlabel(r'$\lambda_{' + str(i+1) + '}$')
ax.set_ylabel(r'$\lambda_{' + str(j+1) + '}$')
ax.set_zlabel(r'$P$')
plt.backgroundcolor = 'w'
fig.colorbar(surf, shrink=0.5, aspect=5, label=r'$P$')
fig.savefig(filename + "_surf_" + str(i) + "_" + str(j) + \
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
plt.clf()
comm.barrier()
def test_loadmat_parallel():
"""
Tests :class:`bet.sampling.basicSampling.sampler.loadmat`.
"""
np.random.seed(1)
mdat1 = {'num_samples':10}
mdat2 = {'num_samples':20}
model = "this is not a model"
my_input1 = sample_set(1)
my_input1.set_values_local(np.array_split(np.random.random((10,1)),
comm.size)[comm.rank])
my_output1 = sample_set(1)
my_output1.set_values_local(np.array_split(np.random.random((10,1)),
comm.size)[comm.rank])
my_input2 = sample_set(1)
my_input2.set_values_local(np.array_split(np.random.random((20,1)),
comm.size)[comm.rank])
my_output2 = sample_set(1)
my_output2.set_values_local(np.array_split(np.random.random((20,1)),
comm.size)[comm.rank])
file_name1 = 'testfile1.mat'
file_name2 = 'testfile2.mat'
if comm.size > 1:
local_file_name1 = os.path.os.path.join(os.path.dirname(file_name1),
"proc{}_{}".format(comm.rank, os.path.basename(file_name1)))
local_file_name2 = os.path.os.path.join(os.path.dirname(file_name2),
"proc{}_{}".format(comm.rank, os.path.basename(file_name2)))
else:
local_file_name1 = file_name1
local_file_name2 = file_name2
sio.savemat(local_file_name1, mdat1)
sio.savemat(local_file_name2, mdat2)
comm.barrier()
bet.sample.save_discretization(disc(my_input1, my_output1),
file_name1, globalize=False)
bet.sample.save_discretization(disc(my_input2, my_output2),
file_name2, "NAME", globalize=False)
(loaded_sampler1, discretization1) = bsam.loadmat(file_name1)
nptest.assert_array_equal(discretization1._input_sample_set.get_values(),
my_input1.get_values())
nptest.assert_array_equal(discretization1._output_sample_set.get_values(),
my_output1.get_values())
assert loaded_sampler1.num_samples == 10
assert loaded_sampler1.lb_model is None
(loaded_sampler2, discretization2) = bsam.loadmat(file_name2,
disc_name="NAME", model=model)
nptest.assert_array_equal(discretization2._input_sample_set.get_values(),
my_input2.get_values())
nptest.assert_array_equal(discretization2._output_sample_set.get_values(),
my_output2.get_values())
assert loaded_sampler2.num_samples == 20
assert loaded_sampler2.lb_model == model
if comm.size == 1:
os.remove(file_name1)
os.remove(file_name2)
else:
os.remove(local_file_name1)
os.remove(local_file_name2)
def test_loadmat_parallel():
"""
Tests :class:`bet.sampling.basicSampling.sampler.loadmat`.
"""
np.random.seed(1)
mdat1 = {'num_samples': 10}
mdat2 = {'num_samples': 20}
model = "this is not a model"
my_input1 = sample_set(1)
my_input1.set_values_local(
np.array_split(np.random.random((10, 1)), comm.size)[comm.rank])
my_output1 = sample_set(1)
my_output1.set_values_local(
np.array_split(np.random.random((10, 1)), comm.size)[comm.rank])
my_input2 = sample_set(1)
my_input2.set_values_local(
np.array_split(np.random.random((20, 1)), comm.size)[comm.rank])
my_output2 = sample_set(1)
my_output2.set_values_local(
np.array_split(np.random.random((20, 1)), comm.size)[comm.rank])
file_name1 = 'testfile1.mat'
file_name2 = 'testfile2.mat'
if comm.size > 1:
local_file_name1 = os.path.os.path.join(
os.path.dirname(file_name1),
"proc{}_{}".format(comm.rank, os.path.basename(file_name1)))
local_file_name2 = os.path.os.path.join(
os.path.dirname(file_name2),
"proc{}_{}".format(comm.rank, os.path.basename(file_name2)))
else:
local_file_name1 = file_name1
local_file_name2 = file_name2
sio.savemat(local_file_name1, mdat1)
sio.savemat(local_file_name2, mdat2)
comm.barrier()
bet.sample.save_discretization(disc(my_input1, my_output1),
file_name1,
globalize=False)
bet.sample.save_discretization(disc(my_input2, my_output2),
file_name2,
"NAME",
globalize=False)
(loaded_sampler1, discretization1) = bsam.loadmat(file_name1)
nptest.assert_array_equal(discretization1._input_sample_set.get_values(),
my_input1.get_values())
nptest.assert_array_equal(discretization1._output_sample_set.get_values(),
my_output1.get_values())
assert loaded_sampler1.num_samples == 10
assert loaded_sampler1.lb_model is None
(loaded_sampler2, discretization2) = bsam.loadmat(file_name2,
disc_name="NAME",
model=model)
nptest.assert_array_equal(discretization2._input_sample_set.get_values(),
my_input2.get_values())
nptest.assert_array_equal(discretization2._output_sample_set.get_values(),
my_output2.get_values())
assert loaded_sampler2.num_samples == 20
assert loaded_sampler2.lb_model == model
if comm.size == 1:
os.remove(file_name1)
os.remove(file_name2)
else:
os.remove(local_file_name1)
os.remove(local_file_name2)
def compute_QoI_and_create_discretization(self,
input_sample_set,
savefile=None,
globalize=True):
"""
Samples the model at ``input_sample_set`` and saves the results.
Note: There are many ways to generate samples on a regular grid in
Numpy and other Python packages. Instead of reimplementing them here we
provide sampler that utilizes user specified samples.
:param input_sample_set: samples to evaluate the model at
:type input_sample_set: :class:`~bet.sample.sample_set` with
num_smaples
:param string savefile: filename to save samples and data
:param bool globalize: Makes local variables global.
:rtype: :class:`~bet.sample.discretization`
:returns: :class:`~bet.sample.discretization` object which contains
input and output of ``num_samples``
"""
# Update the number of samples
self.num_samples = input_sample_set.check_num()
# Solve the model at the samples
if input_sample_set._values_local is None:
input_sample_set.global_to_local()
local_output = self.lb_model(input_sample_set.get_values_local())
if isinstance(local_output, np.ndarray):
local_output_values = local_output
elif isinstance(local_output, tuple):
if len(local_output) == 1:
local_output_values = local_output[0]
elif len(local_output) == 2 and self.error_estimates:
(local_output_values, local_output_ee) = local_output
elif len(local_output) == 2 and self.jacobians:
(local_output_values, local_output_jac) = local_output
elif len(local_output) == 3:
(local_output_values, local_output_ee, local_output_jac) = \
local_output
else:
raise bad_object("lb_model is not returning the proper type")
# figure out the dimension of the output
if len(local_output_values.shape) <= 1:
output_dim = 1
else:
output_dim = local_output_values.shape[1]
output_sample_set = sample.sample_set(output_dim)
output_sample_set.set_values_local(local_output_values)
lam_ref = input_sample_set._reference_value
if lam_ref is not None:
try:
if not isinstance(lam_ref, collections.Iterable):
lam_ref = np.array([lam_ref])
Q_ref = self.lb_model(lam_ref)
output_sample_set.set_reference_value(Q_ref)
except ValueError:
try:
msg = "Model not mapping reference value as expected."
msg += "Attempting reshape..."
logging.log(20, msg)
Q_ref = self.lb_model(lam_ref.reshape(1, -1))
output_sample_set.set_reference_value(Q_ref)
except ValueError:
logging.log(20, 'Unable to map reference value.')
if self.error_estimates:
output_sample_set.set_error_estimates_local(local_output_ee)
if self.jacobians:
input_sample_set.set_jacobians_local(local_output_jac)
if globalize:
input_sample_set.local_to_global()
output_sample_set.local_to_global()
else:
input_sample_set._values = None
comm.barrier()
discretization = sample.discretization(input_sample_set,
output_sample_set)
comm.barrier()
mdat = dict()
self.update_mdict(mdat)
if savefile is not None:
self.save(mdat, savefile, discretization, globalize=globalize)
comm.barrier()
return discretization
def compute_QoI_and_create_discretization(self, input_sample_set,
savefile=None, globalize=True):
"""
Samples the model at ``input_sample_set`` and saves the results.
Note: There are many ways to generate samples on a regular grid in
Numpy and other Python packages. Instead of reimplementing them here we
provide sampler that utilizes user specified samples.
:param input_sample_set: samples to evaluate the model at
:type input_sample_set: :class:`~bet.sample.sample_set` with
num_smaples
:param string savefile: filename to save samples and data
:param bool globalize: Makes local variables global.
:rtype: :class:`~bet.sample.discretization`
:returns: :class:`~bet.sample.discretization` object which contains
input and output of ``num_samples``
"""
# Update the number of samples
self.num_samples = input_sample_set.check_num()
# Solve the model at the samples
if input_sample_set._values_local is None:
input_sample_set.global_to_local()
local_output = self.lb_model(
input_sample_set.get_values_local())
if isinstance(local_output, np.ndarray):
local_output_values = local_output
elif isinstance(local_output, tuple):
if len(local_output) == 1:
local_output_values = local_output[0]
elif len(local_output) == 2 and self.error_estimates:
(local_output_values, local_output_ee) = local_output
elif len(local_output) == 2 and self.jacobians:
(local_output_values, local_output_jac) = local_output
elif len(local_output) == 3:
(local_output_values, local_output_ee, local_output_jac) = \
local_output
else:
raise bad_object("lb_model is not returning the proper type")
# figure out the dimension of the output
if len(local_output_values.shape) <= 1:
output_dim = 1
else:
output_dim = local_output_values.shape[1]
output_sample_set = sample.sample_set(output_dim)
output_sample_set.set_values_local(local_output_values)
lam_ref = input_sample_set._reference_value
if lam_ref is not None:
try:
if not isinstance(lam_ref, collections.Iterable):
lam_ref = np.array([lam_ref])
Q_ref = self.lb_model(lam_ref)
output_sample_set.set_reference_value(Q_ref)
except ValueError:
try:
msg = "Model not mapping reference value as expected."
msg += "Attempting reshape..."
logging.log(20, msg)
Q_ref = self.lb_model(lam_ref.reshape(1, -1))
output_sample_set.set_reference_value(Q_ref)
except ValueError:
logging.log(20, 'Unable to map reference value.')
if self.error_estimates:
output_sample_set.set_error_estimates_local(local_output_ee)
if self.jacobians:
input_sample_set.set_jacobians_local(local_output_jac)
if globalize:
input_sample_set.local_to_global()
output_sample_set.local_to_global()
else:
input_sample_set._values = None
comm.barrier()
discretization = sample.discretization(input_sample_set,
output_sample_set)
comm.barrier()
mdat = dict()
self.update_mdict(mdat)
if savefile is not None:
self.save(mdat, savefile, discretization, globalize=globalize)
comm.barrier()
return discretization
def verify_samples(QoI_range, sampler, input_domain,
t_set, savefile, initial_sample_type, hot_start=0):
"""
Run :meth:`bet.sampling.adaptiveSampling.sampler.generalized_chains` and
verify that the samples have the correct dimensions and are containted in
the bounded parameter space.
"""
# create indicator function
Q_ref = QoI_range*0.5
bin_size = 0.15*QoI_range
maximum = 1/np.product(bin_size)
def ifun(outputs):
"""
Indicator function
"""
left = np.repeat([Q_ref-.5*bin_size], outputs.shape[0], 0)
right = np.repeat([Q_ref+.5*bin_size], outputs.shape[0], 0)
left = np.all(np.greater_equal(outputs, left), axis=1)
right = np.all(np.less_equal(outputs, right), axis=1)
inside = np.logical_and(left, right)
max_values = np.repeat(maximum, outputs.shape[0], 0)
return inside.astype('float64')*max_values
# create rhoD_kernel
kernel_rD = asam.rhoD_kernel(maximum, ifun)
if comm.rank == 0:
print("dim", input_domain.shape)
if not hot_start:
# run generalized chains
(my_discretization, all_step_ratios) = sampler.generalized_chains(
input_domain, t_set, kernel_rD, savefile, initial_sample_type)
print("COLD", comm.rank)
else:
# cold start
sampler1 = asam.sampler(sampler.num_samples // 2, sampler.chain_length // 2,
sampler.lb_model)
(my_discretization, all_step_ratios) = sampler1.generalized_chains(
input_domain, t_set, kernel_rD, savefile, initial_sample_type)
print("COLD then", comm.rank)
comm.barrier()
# hot start
(my_discretization, all_step_ratios) = sampler.generalized_chains(
input_domain, t_set, kernel_rD, savefile, initial_sample_type,
hot_start=hot_start)
print("HOT", comm.rank)
comm.barrier()
# check dimensions of input and output
assert my_discretization.check_nums()
# are the input in bounds?
input_left = np.repeat([input_domain[:, 0]], sampler.num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], sampler.num_samples, 0)
assert np.all(my_discretization._input_sample_set.get_values() <=
input_right)
assert np.all(my_discretization._input_sample_set.get_values() >=
input_left)
# check dimensions of output
assert my_discretization._output_sample_set.get_dim() == len(QoI_range)
# check dimensions of all_step_ratios
assert all_step_ratios.shape == (sampler.num_chains, sampler.chain_length)
# are all the step ratios of an appropriate size?
assert np.all(all_step_ratios >= t_set.min_ratio)
assert np.all(all_step_ratios <= t_set.max_ratio)
# did the savefiles get created? (proper number, contain proper keys)
comm.barrier()
mdat = dict()
# if comm.rank == 0:
mdat = sio.loadmat(savefile)
saved_disc = bet.sample.load_discretization(savefile)
# compare the input
nptest.assert_array_equal(my_discretization._input_sample_set.
get_values(), saved_disc._input_sample_set.get_values())
# compare the output
nptest.assert_array_equal(my_discretization._output_sample_set.
get_values(), saved_disc._output_sample_set.get_values())
nptest.assert_array_equal(all_step_ratios, mdat['step_ratios'])
assert sampler.chain_length == mdat['chain_length']
assert sampler.num_samples == mdat['num_samples']
assert sampler.num_chains == mdat['num_chains']
nptest.assert_array_equal(sampler.sample_batch_no,
np.squeeze(mdat['sample_batch_no']))
def test_loadmat_init():
"""
Tests :meth:`bet.sampling.adaptiveSampling.loadmat` and
:meth:`bet.sampling.adaptiveSampling.sampler.init`.
"""
np.random.seed(1)
chain_length = 5
mdat1 = {'num_samples': 50, 'chain_length': chain_length}
mdat2 = {'num_samples': 60, 'chain_length': chain_length}
model = "this is not a model"
num_samples = np.array([50, 60])
num_chains_pproc1, num_chains_pproc2 = np.ceil(
num_samples / float(chain_length * comm.size)).astype('int')
num_chains1, num_chains2 = comm.size * np.array(
[num_chains_pproc1, num_chains_pproc2])
num_samples1, num_samples2 = chain_length * np.array(
[num_chains1, num_chains2])
my_input1 = sample_set(1)
my_input1.set_values(np.random.random((num_samples1, 1)))
my_output1 = sample_set(1)
my_output1.set_values(np.random.random((num_samples1, 1)))
my_input2 = sample_set(1)
my_input2.set_values(np.random.random((num_samples2, 1)))
my_output2 = sample_set(1)
my_output2.set_values(np.random.random((num_samples2, 1)))
mdat1['num_chains'] = num_chains1
mdat1['kern_old'] = np.random.random((num_chains1, ))
mdat1['step_ratios'] = np.random.random((num_samples1, ))
mdat2['num_chains'] = num_chains2
mdat2['kern_old'] = np.random.random((num_chains2, ))
mdat2['step_ratios'] = np.random.random((num_samples2, ))
sio.savemat(os.path.join(local_path, 'testfile1'), mdat1)
sio.savemat(os.path.join(local_path, 'testfile2'), mdat2)
bet.sample.save_discretization(disc(my_input1, my_output1),
os.path.join(local_path, 'testfile1'),
globalize=True)
bet.sample.save_discretization(disc(my_input2, my_output2),
os.path.join(local_path, 'testfile2'),
globalize=True)
loaded_sampler1, discretization1, _, _ = asam.loadmat(os.path.join(
local_path, 'testfile1'),
hot_start=2)
nptest.assert_array_equal(discretization1._input_sample_set.get_values(),
my_input1.get_values())
nptest.assert_array_equal(discretization1._output_sample_set.get_values(),
my_output1.get_values())
assert loaded_sampler1.num_samples == num_samples1
assert loaded_sampler1.chain_length == chain_length
assert loaded_sampler1.num_chains_pproc == num_chains_pproc1
assert loaded_sampler1.num_chains == num_chains1
nptest.assert_array_equal(
np.repeat(np.arange(num_chains1), chain_length, 0),
loaded_sampler1.sample_batch_no)
assert loaded_sampler1.lb_model is None
loaded_sampler2, discretization2, _, _ = asam.loadmat(os.path.join(
local_path, 'testfile2'),
lb_model=model,
hot_start=2)
nptest.assert_array_equal(discretization2._input_sample_set.get_values(),
my_input2.get_values())
assert loaded_sampler2.num_samples == num_samples2
assert loaded_sampler2.chain_length == chain_length
assert loaded_sampler2.num_chains_pproc == num_chains_pproc2
assert loaded_sampler2.num_chains == num_chains2
nptest.assert_array_equal(
np.repeat(np.arange(num_chains2), chain_length, 0),
loaded_sampler2.sample_batch_no)
nptest.assert_array_equal(discretization2._output_sample_set.get_values(),
my_output2.get_values())
comm.barrier()
if comm.rank == 0:
if os.path.exists(os.path.join(local_path, 'testfile1.mat')):
os.remove(os.path.join(local_path, 'testfile1.mat'))
if os.path.exists(os.path.join(local_path, 'testfile2.mat')):
os.remove(os.path.join(local_path, 'testfile2.mat'))
def verify_samples(QoI_range,
sampler,
input_domain,
t_set,
savefile,
initial_sample_type,
hot_start=0):
"""
Run :meth:`bet.sampling.adaptiveSampling.sampler.generalized_chains` and
verify that the samples have the correct dimensions and are containted in
the bounded parameter space.
"""
# create indicator function
Q_ref = QoI_range * 0.5
bin_size = 0.15 * QoI_range
maximum = 1 / np.product(bin_size)
def ifun(outputs):
"""
Indicator function
"""
left = np.repeat([Q_ref - .5 * bin_size], outputs.shape[0], 0)
right = np.repeat([Q_ref + .5 * bin_size], outputs.shape[0], 0)
left = np.all(np.greater_equal(outputs, left), axis=1)
right = np.all(np.less_equal(outputs, right), axis=1)
inside = np.logical_and(left, right)
max_values = np.repeat(maximum, outputs.shape[0], 0)
return inside.astype('float64') * max_values
# create rhoD_kernel
kernel_rD = asam.rhoD_kernel(maximum, ifun)
if comm.rank == 0:
print("dim", input_domain.shape)
if not hot_start:
# run generalized chains
(my_discretization,
all_step_ratios) = sampler.generalized_chains(input_domain, t_set,
kernel_rD, savefile,
initial_sample_type)
print("COLD", comm.rank)
else:
# cold start
sampler1 = asam.sampler(sampler.num_samples // 2,
sampler.chain_length // 2, sampler.lb_model)
(my_discretization, all_step_ratios) = sampler1.generalized_chains(
input_domain, t_set, kernel_rD, savefile, initial_sample_type)
print("COLD then", comm.rank)
comm.barrier()
# hot start
(my_discretization,
all_step_ratios) = sampler.generalized_chains(input_domain,
t_set,
kernel_rD,
savefile,
initial_sample_type,
hot_start=hot_start)
print("HOT", comm.rank)
comm.barrier()
# check dimensions of input and output
assert my_discretization.check_nums()
# are the input in bounds?
input_left = np.repeat([input_domain[:, 0]], sampler.num_samples, 0)
input_right = np.repeat([input_domain[:, 1]], sampler.num_samples, 0)
assert np.all(
my_discretization._input_sample_set.get_values() <= input_right)
assert np.all(
my_discretization._input_sample_set.get_values() >= input_left)
# check dimensions of output
assert my_discretization._output_sample_set.get_dim() == len(QoI_range)
# check dimensions of all_step_ratios
assert all_step_ratios.shape == (sampler.num_chains, sampler.chain_length)
# are all the step ratios of an appropriate size?
assert np.all(all_step_ratios >= t_set.min_ratio)
assert np.all(all_step_ratios <= t_set.max_ratio)
# did the savefiles get created? (proper number, contain proper keys)
comm.barrier()
mdat = dict()
# if comm.rank == 0:
mdat = sio.loadmat(savefile)
saved_disc = bet.sample.load_discretization(savefile)
saved_disc.local_to_global()
# # compare the input
nptest.assert_array_equal(my_discretization._input_sample_set.get_values(),
saved_disc._input_sample_set.get_values())
# compare the output
nptest.assert_array_equal(
my_discretization._output_sample_set.get_values(),
saved_disc._output_sample_set.get_values())
nptest.assert_array_equal(all_step_ratios, mdat['step_ratios'])
assert sampler.chain_length == mdat['chain_length']
assert sampler.num_samples == mdat['num_samples']
assert sampler.num_chains == mdat['num_chains']
nptest.assert_array_equal(sampler.sample_batch_no,
np.squeeze(mdat['sample_batch_no']))
def plot_2D_marginal_contours(marginals, bins, sample_set,
contour_num=8,
lam_ref=None, lam_refs=None,
plot_domain=None,
interactive=False,
lambda_label=None,
contour_font_size=20,
filename="file",
file_extension=".png"):
"""
This makes contour plots of every pair of marginals (or joint in 2d case)
of input probability measure on a rectangular grid.
If the sample_set object is a discretization object, we assume
that the probabilities to be plotted are from the input space.
.. note::
Do not specify the file extension in the file name.
:param marginals: 2D marginal probabilities
:type marginals: dictionary with tuples of 2 integers as keys and
:class:`~numpy.ndarray` of shape (nbins+1,) as values
:param bins: Endpoints of bins used in calculating marginals
:type bins: :class:`~numpy.ndarray` of shape (nbins+1,2)
:param sample_set: Object containing samples and probabilities
:type sample_set: :class:`~bet.sample.sample_set_base`
or :class:`~bet.sample.discretization`
:param filename: Prefix for output files.
:type filename: str
:param lam_ref: True parameters.
:type lam_ref: :class:`~numpy.ndarray` of shape (ndim,) or None
:param interactive: Whether or not to display interactive plots.
:type interactive: bool
:param lambda_label: Label for each parameter for plots.
:type lambda_label: list of length nbins of strings or None
:param string file_extension: file extenstion
"""
if isinstance(sample_set, sample.discretization):
sample_obj = sample_set._input_sample_set
elif isinstance(sample_set, sample.sample_set_base):
sample_obj = sample_set
else:
raise bad_object("Improper sample object")
if lam_ref is None:
lam_ref = sample_obj._reference_value
lam_domain = sample_obj.get_domain()
matplotlib.rcParams['xtick.direction'] = 'out'
matplotlib.rcParams['ytick.direction'] = 'out'
matplotlib.rcParams.update({'figure.autolayout': True})
if comm.rank == 0:
pairs = copy.deepcopy(list(marginals.keys()))
pairs.sort()
for k, (i, j) in enumerate(pairs):
fig = plt.figure(k)
ax = fig.add_subplot(111)
boxSize = (bins[i][1]-bins[i][0])*(bins[j][1]-bins[j][0])
nx = len(bins[i])-1
ny = len(bins[j])-1
dx = bins[i][1] - bins[i][0]
dy = bins[j][1] - bins[j][0]
x_kernel = np.linspace(-nx*dx/2, nx*dx/2, nx)
y_kernel = np.linspace(-ny*dy/2, ny*dy/2, ny)
X, Y = np.meshgrid(x_kernel, y_kernel, indexing='ij')
quadmesh = ax.contour(marginals[(i, j)].transpose()/boxSize,
contour_num, colors='k',
extent=[lam_domain[i][0], lam_domain[i][1],
lam_domain[j][0], lam_domain[j][1]], origin='lower',
vmax=marginals[(i, j)].max()/boxSize, vmin=0,
aspect='auto')
if lam_refs is not None:
ax.plot(lam_refs[:, i], lam_refs[:, j], 'wo', markersize=20)
if lam_ref is not None:
ax.plot(lam_ref[i], lam_ref[j], 'ko', markersize=20)
if lambda_label is None:
label1 = r'$\lambda_{' + str(i+1) + '}$'
label2 = r'$\lambda_{' + str(j+1) + '}$'
else:
label1 = lambda_label[i]
label2 = lambda_label[j]
ax.set_xlabel(label1, fontsize=30)
ax.set_ylabel(label2, fontsize=30)
ax.tick_params(axis='both', which='major',
labelsize=20)
plt.clabel(quadmesh, fontsize=contour_font_size,
inline=1, style='sci')
if plot_domain is None:
plt.axis([lam_domain[i][0], lam_domain[i][1],
lam_domain[j][0], lam_domain[j][1]])
else:
plt.axis([plot_domain[i][0], plot_domain[i][1],
plot_domain[j][0], plot_domain[j][1]])
plt.tight_layout()
fig.savefig(filename + "_2D_contours_" + str(i) + "_" + str(j) +
file_extension, transparent=True)
if interactive:
plt.show()
else:
plt.close()
comm.barrier()
