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 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()