def setUp(self): # Define the parameter space (Lambda) self.input_dim = 15 self.input_set = sample.sample_set(self.input_dim) self.input_set_centers = sample.sample_set(self.input_dim) self.lam_domain = np.zeros((self.input_dim, 2)) np.random.seed(0) self.lam_domain[:,0] = -1*np.random.random(self.input_dim) - 2 self.lam_domain[:,1] = -1*np.random.random(self.input_dim) self.input_set.set_domain(self.lam_domain) self.input_set_centers.set_domain(self.lam_domain) # Choose random centers to cluster points around self.num_centers = 143 self.centers = (self.lam_domain[:,1] - self.lam_domain[:,0]) * \ np.random.random((self.num_centers,self.input_dim)) + \ self.lam_domain[:,0] self.input_set_centers.set_values(self.centers) self.num_close = self.input_dim + 1 self.rvec = 0.1 # Choose array shapes for RBF methods np.random.seed(0) self.radii_rbf = np.random.random([self.num_close, self.num_close]) self.radii_rbfdxi = np.random.random([self.input_dim, self.num_close]) self.dxi = np.random.random([self.input_dim, self.num_close]) # Define example linear functions (QoIs) for gradient approximation # methods self.output_dim = 37 coeffs = np.random.random((self.input_dim, self.output_dim-self.input_dim)) self.coeffs = np.append(coeffs, np.eye(self.input_dim), axis=1)
def setUp(self): self.input_dim = 2 self.input_set = sample.sample_set(self.input_dim) self.input_set_centers = sample.sample_set(self.input_dim) self.output_dim_return = 2 self.num_optsets_return = 5 self.radius = 0.01 np.random.seed(0) self.num_centers = 10 self.centers = np.random.random((self.num_centers, self.input_dim)) self.input_set_centers.set_values(self.centers) self.input_set = grad.sample_l1_ball(self.input_set_centers, self.input_dim + 1, self.radius) self.output_dim = 28 self.output_set = sample.sample_set(self.output_dim) coeffs = np.zeros((self.input_dim, 2*self.input_dim)) coeffs = np.append(coeffs, np.random.random((self.input_dim, self.output_dim - 3 * self.input_dim)), axis=1) self.coeffs = np.append(coeffs, np.eye(self.input_dim), axis=1) self.output_set.set_values(self.input_set._values.dot(self.coeffs)) self.my_disc = sample.discretization(self.input_set, self.output_set) self.center_disc = grad.calculate_gradients_rbf(\ self.my_disc, self.num_centers) self.input_set_centers = self.center_disc.get_input_sample_set() self.inner_prod_tol = 0.9 self.measskew_tol = np.inf
def setUp(self): # Define the input domain (Lambda) self.input_dim = 1 self.input_set = sample.sample_set(self.input_dim) self.input_set_centers = sample.sample_set(self.input_dim) self.lam_domain = np.zeros((self.input_set.get_dim(), 2)) self.lam_domain[:,0] = np.zeros(self.input_set.get_dim()) self.lam_domain[:,1] = np.ones(self.input_set.get_dim()) self.input_set.set_domain(self.lam_domain) self.input_set_centers.set_domain(self.lam_domain) # Choose random centers in input_domian to cluster points around self.num_centers = 1 self.num_close = self.input_set.get_dim() + 1 self.rvec = 0.1 np.random.seed(0) self.centers = np.random.uniform(self.lam_domain[:, 0], self.lam_domain[:, 1] - self.lam_domain[:, 0], [self.num_centers, self.input_set.get_dim()]) self.input_set_centers.set_values(self.centers) # Choose array shapes for RBF methods np.random.seed(0) self.radii_rbf = np.random.random([self.num_close, self.num_close]) self.radii_rbfdxi = np.random.random([self.input_dim, self.num_close]) self.dxi = np.random.random([self.input_dim, self.num_close]) # Define example linear functions (QoIs) for gradient approximation # methods self.output_dim = 20 coeffs = np.random.random((self.input_dim, self.output_dim-self.input_dim)) self.coeffs = np.append(coeffs, np.eye(self.input_dim), axis=1)
def check_show_data(self, data, sample_nos, q_ref, save, qnums, showdim): """ Check to see that the :meth:`bet.postTools.plotDomains.scatter_rhoD` ran without generating an error. """ try: if data.shape[1] == 4: data_obj_temp = sample.sample_set(4) data_obj_temp.set_values(data) plotDomains.scatter_rhoD(data_obj_temp, q_ref, sample_nos, 'output', self.rho_D, qnums, None, showdim, save, False) else: data_obj_temp = sample.sample_set(data.shape[1]) data_obj_temp.set_values(data) plotDomains.scatter_rhoD(data_obj_temp, q_ref, sample_nos, None, None, qnums, None, showdim, save, False) go = True except (RuntimeError, TypeError, NameError): print("ERROR") print("data shape:", data.shape) print("data ref:", q_ref) print("samples nums:", sample_nos) print("save:", save) print("qnums:", qnums) print("showdim:", showdim) go = False nptest.assert_equal(go, True)
def setUp(self): """ Set up problem. """ import numpy.random as rnd rnd.seed(1) self.inputs = samp.sample_set(1) self.outputs = samp.sample_set(1) self.lam_domain = np.zeros((1, 2)) self.lam_domain[:, 0] = 0.0 self.lam_domain[:, 1] = 1.0 self.inputs.set_domain(self.lam_domain) self.inputs.set_values(rnd.rand(100,)) self.num_l_emulate = 1001 self.inputs = bsam.random_sample_set('r', self.inputs.get_domain(), num_samples=1001, globalize=True) self.outputs.set_values(2.0*self.inputs._values) Q_ref = np.mean(self.outputs._values, axis=0) self.inputs_emulated = bsam.random_sample_set('r', self.inputs.get_domain(), num_samples=self.num_l_emulate, globalize=True) self.output_prob = simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( self.outputs, Q_ref=Q_ref, rect_scale=0.2, cells_per_dimension=1) self.disc = samp.discretization(input_sample_set=self.inputs, output_sample_set=self.outputs, output_probability_set=self.output_prob, emulated_input_sample_set=self.inputs_emulated)
def test_calculate_gradients_cfd(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_cfd`. """ self.output_set = sample.sample_set(self.output_dim) self.cluster_set = grad.pick_cfd_points(self.input_set_centers, self.rvec) num_centers = self.input_set_centers.check_num() self.output_set.set_values(self.cluster_set._values.dot(self.coeffs)) self.cluster_disc = sample.discretization(self.cluster_set, self.output_set) self.center_disc = grad.calculate_gradients_cfd(self.cluster_disc) self.jacobians = self.center_disc._input_sample_set._jacobians # Test the method returns the correct size tensor self.assertEqual(self.jacobians.shape, (self.num_centers, self.output_dim, self.input_dim)) # Test that each vector is normalized or a zero vector normG = np.linalg.norm(self.jacobians, ord=1, axis=2) # If its a zero vectors, make it the unit vector in input_dim self.jacobians[normG==0] = 1.0/self.input_dim nptest.assert_array_almost_equal(np.linalg.norm(self.jacobians, ord=1, axis=2), np.ones((self.jacobians.shape[0], self.jacobians.shape[1])))
def check_show_param(self, samples, sample_nos, p_ref, save, lnums, showdim): """ Check to see that the :meth:`bet.postTools.plotDomains.scatter_rhoD` ran without generating an error. """ try: input_sample_set_temp = sample.sample_set(samples.shape[1]) input_sample_set_temp.set_values(samples) disc_obj_temp = sample.discretization(input_sample_set_temp, self.disc._output_sample_set) plotDomains.scatter_rhoD(disc_obj_temp, p_ref, sample_nos, 'input', self.rho_D, lnums, None, showdim, save, False) go = True except (RuntimeError, TypeError, NameError) as error: print("ERROR:", error) print("samples shape:", samples.shape) print("param ref:", p_ref) print("samples nums:", sample_nos) print("save:", save) print("lnums:", lnums) print("showdim:", showdim) go = False nptest.assert_equal(go, True)
def check_show_data_domain_2D(self, ref_markers, ref_colors, triangles, save, filenames): """ Check to see that the :meth:`bet.postTools.plotDomains.show_data_domain_2D` ran without generating an error. """ Q_ref = self.disc._output_sample_set.get_values()[:, [0, 1]] Q_ref = Q_ref[[1, 4], :] data_obj_temp = sample.sample_set(2) data_obj_temp.set_values( self.disc._output_sample_set.get_values()[:, [0, 1]]) disc_obj_temp = sample.discretization( self.disc._input_sample_set, data_obj_temp) try: plotDomains.show_data_domain_2D( disc_obj_temp, Q_ref, ref_markers, ref_colors, triangles=triangles, save=save, filenames=filenames) go = True except (RuntimeError, TypeError, NameError): go = False nptest.assert_equal(go, True)
def postprocess(station_nums, ref_num): filename = 'P_q'+str(station_nums[0]+1)+'_q'+str(station_nums[1]+1) if len(station_nums) == 3: filename += '_q'+str(station_nums[2]+1) filename += '_ref_'+str(ref_num+1) data = Q[:, station_nums] output_sample_set = sample.sample_set(data.shape[1]) output_sample_set.set_values(data) q_ref = Q_ref[ref_num, station_nums] # Create Simple function approximation # Save points used to parition D for simple function approximation and the # approximation itself (this can be used to make close comparisions...) output_probability_set = sfun.regular_partition_uniform_distribution_rectangle_scaled(\ output_sample_set, q_ref, rect_scale=0.15, cells_per_dimension=np.ones((data.shape[1],))) my_disc = sample.discretization(input_sample_set, output_sample_set, output_probability_set) # Calclate P on the actual samples with assumption that voronoi cells have # equal size input_sample_set.estimate_volume_mc() print "Calculating prob" calcP.prob(my_disc) sample.save_discretization(my_disc, filename, "prob_solution")
def test_loadmat(): """ Tests :meth:`bet.sampling.basicSampling.loadmat` """ np.random.seed(1) mdat1 = {'num_samples':5} mdat2 = {'num_samples':6} model = "this is not a model" my_input1 = sample_set(1) my_input1.set_values(np.random.random((5,1))) my_output = sample_set(1) my_output.set_values(np.random.random((5,1))) my_input2 = sample_set(1) my_input2.set_values(np.random.random((6,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_output), (os.path.join(local_path, 'testfile1')), globalize=True) bet.sample.save_discretization(disc(my_input2, None), os.path.join(local_path, 'testfile2'), "NAME", globalize=True) (loaded_sampler1, discretization1) = bsam.loadmat(os.path.join(local_path, 'testfile1')) 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_output.get_values()) assert loaded_sampler1.num_samples == 5 assert loaded_sampler1.lb_model is None (loaded_sampler2, discretization2) = bsam.loadmat(os.path.join(local_path, 'testfile2'), disc_name="NAME", model=model) nptest.assert_array_equal(discretization2._input_sample_set.get_values(), my_input2.get_values()) assert discretization2._output_sample_set is None assert loaded_sampler2.num_samples == 6 assert loaded_sampler2.lb_model == model 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 setUp(self): # Define the parameter space (Lambda) self.input_dim = 2 self.input_set_rbf = sample.sample_set(self.input_dim) self.input_set_ffd = sample.sample_set(self.input_dim) self.input_set_cfd = sample.sample_set(self.input_dim) self.input_set_centers = sample.sample_set(self.input_dim) self.output_dim = 2 self.output_set_rbf = sample.sample_set(self.output_dim) self.output_set_ffd = sample.sample_set(self.output_dim) self.output_set_cfd = sample.sample_set(self.output_dim) self.lam_domain = np.zeros((self.input_dim, 2)) self.lam_domain[:, 0] = np.zeros(self.input_dim) self.lam_domain[:, 1] = np.ones(self.input_dim) self.input_set_rbf.set_domain(self.lam_domain) self.input_set_ffd.set_domain(self.lam_domain) self.input_set_cfd.set_domain(self.lam_domain) # Choose random centers to cluster points around self.num_centers = 100 np.random.seed(0) self.centers = (self.lam_domain[:, 1] - self.lam_domain[:, 0]) * \ np.random.random((self.num_centers, self.input_dim)) + \ self.lam_domain[:, 0] self.input_set_centers.set_values(self.centers) self.num_close = self.input_dim + 1 self.rvec = 0.01 * np.ones(self.input_dim) self.input_set_rbf = grad.sample_l1_ball(self.input_set_centers, self.num_close, self.rvec) self.input_set_ffd = grad.pick_ffd_points(self.input_set_centers, self.rvec) self.input_set_cfd = grad.pick_cfd_points(self.input_set_centers, self.rvec) # Define a vector valued function f : [0,1]x[0,1] -> [x^2, y^2] def f(x): f = np.zeros(x.shape) f[:, 0] = x[:, 0]**2 f[:, 1] = x[:, 1]**2 return f self.output_set_rbf.set_values(f(self.input_set_rbf.get_values())) self.output_set_ffd.set_values(f(self.input_set_ffd.get_values())) self.output_set_cfd.set_values(f(self.input_set_cfd.get_values())) self.cluster_disc_rbf = sample.discretization( self.input_set_rbf, self.output_set_rbf) self.cluster_disc_ffd = sample.discretization( self.input_set_ffd, self.output_set_ffd) self.cluster_disc_cfd = sample.discretization( self.input_set_cfd, self.output_set_cfd) self.G_exact = np.zeros([self.num_centers, self.output_dim, self.input_dim]) self.G_exact[:, 0, 0] = 2 * self.centers[:, 0] self.G_exact[:, 1, 1] = 2 * self.centers[:, 1]
def createData(self): """ Set up data. """ self.data = samp.sample_set(1) self.data.set_values(np.random.random((100,1))*10.0) self.Q_ref = np.array([5.0]) self.data_domain = np.expand_dims(np.array([0.0, 10.0]), axis=0) self.mdim = 1
def createData(self): """ Set up data. """ self.data = samp.sample_set(2) self.data.set_values(np.random.random((100,2))*10.0) self.Q_ref = np.array([5.0, 5.0]) self.data_domain = np.array([[0.0, 10.0], [0.0, 10.0]]) self.mdim = 2
def verify_compute_QoI_and_create_discretization(model, sampler, input_sample_set, savefile): """ Verify that the user samples are correct. """ # 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) discretization = disc(input_sample_set, output_sample_set) # evaluate the model at the sample print savefile, input_sample_set.get_dim() my_discretization = sampler.compute_QoI_and_create_discretization(\ input_sample_set, savefile, globalize=True) #comm.barrier() my_num = my_discretization.check_nums() # compare the samples nptest.assert_array_equal(my_discretization._input_sample_set.get_values(), discretization._input_sample_set.get_values()) # compare the data nptest.assert_array_equal(my_discretization._output_sample_set.get_values(), discretization._output_sample_set.get_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) mdat = sio.loadmat(savefile) print "HERE HERE", mdat, my_num #comm.barrier() # 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())
def setUp(self): self.inputs = samp.sample_set(3) self.outputs = samp.sample_set(2) self.inputs.set_values(np.loadtxt(data_path + "/3to2_samples.txt.gz")) self.outputs.set_values(np.loadtxt(data_path + "/3to2_data.txt.gz")) Q_ref = np.array([0.422, 0.9385]) self.output_prob = simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( self.outputs, Q_ref=Q_ref, rect_scale=0.2, cells_per_dimension=1) self.inputs.set_domain(np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0]])) import numpy.random as rnd rnd.seed(1) self.inputs_emulated = bsam.random_sample_set('r', self.inputs.get_domain(), num_samples=1001, globalize=True) self.disc = samp.discretization(input_sample_set=self.inputs, output_sample_set=self.outputs, output_probability_set=self.output_prob, emulated_input_sample_set=self.inputs_emulated)
def verify_regular_sample_set_dimension(sampler, input_dim, num_samples_per_dim): input_domain = np.repeat([[0, 1]], input_dim, axis=0) input_sample_set = sample_set(input_dim) input_sample_set.set_domain(input_domain) test_sample_set = input_sample_set dim = input_dim # recreate the samples if num_samples_per_dim is None: num_samples_per_dim = 5 if not isinstance(num_samples_per_dim, collections.Iterable): num_samples_per_dim = num_samples_per_dim * np.ones((dim,), dtype='int') sampler.num_samples = np.product(num_samples_per_dim) test_domain = test_sample_set.get_domain() if test_domain is None: test_domain = np.repeat([[0, 1]], test_sample_set.get_dim(), axis=0) test_values = np.zeros((sampler.num_samples, test_sample_set.get_dim())) vec_samples_dimension = np.empty((dim), dtype=object) for i in np.arange(0, dim): bin_width = (test_domain[i, 1] - test_domain[i, 0]) / \ np.float(num_samples_per_dim[i]) vec_samples_dimension[i] = list(np.linspace( test_domain[i, 0] - 0.5 * bin_width, test_domain[i, 1] + 0.5 * bin_width, num_samples_per_dim[i] + 2))[1:num_samples_per_dim[i] + 1] if np.equal(dim, 1): arrays_samples_dimension = np.array([vec_samples_dimension]) else: arrays_samples_dimension = np.meshgrid( *[vec_samples_dimension[i] for i in np.arange(0, dim)], indexing='ij') if np.equal(dim, 1): test_values = arrays_samples_dimension.transpose() else: for i in np.arange(0, dim): test_values[:, i:i + 1] = np.vstack(arrays_samples_dimension[i].flat[:]) test_sample_set.set_values(test_values) # create the sample set from sampler my_sample_set = sampler.regular_sample_set(input_dim, num_samples_per_dim=num_samples_per_dim) # compare the samples nptest.assert_array_equal(test_sample_set._values, my_sample_set._values)
def setUp(self): """ Set Up """ self.t_set = asam.transition_set(.5, .5**5, 1.0) self.output_set = sample_set(self.mdim) self.output_set.set_values(self.output) self.output_set.global_to_local() # Update _right_local, _left_local, _width_local self.output_set.set_domain(self.output_domain) self.output_set.update_bounds() self.output_set.update_bounds_local()
def test_scatter_2D_multi(self): """ Test :meth:`bet.postTools.plotDomins.scatter_2D_multi` """ if not os.path.exists('figs/'): os.mkdir('figs/') try: input_sample_set_temp = sample.sample_set(3) input_sample_set_temp.set_values(self.disc._input_sample_set.get_values()[:, [0,1,2]]) plotDomains.scatter_2D_multi(input_sample_set_temp) go = True except (RuntimeError, TypeError, NameError): go = False nptest.assert_equal(go, True)
def check_scatter_3D(self, sample_nos, p_ref, save): """ Check to see that the :meth:`bet.postTools.plotDomains.scatter_3D` ran without generating an error. """ try: input_sample_set_temp = sample.sample_set(3) input_sample_set_temp.set_values(self.disc._input_sample_set.get_values()[:, [0, 1, 2]]) plotDomains.scatter_3D( input_sample_set_temp, sample_nos, self.disc._input_sample_set.get_probabilities(), p_ref, save, False, 'XLABEL', 'YLABEL', 'ZLABEL', self.filename) go = True except (RuntimeError, TypeError, NameError): go = False nptest.assert_equal(go, True)
def setUp(self): """ Set up problem. """ emulated_input_samples = sample.sample_set(2) emulated_input_samples.set_domain(np.array([[0.0,1.0],[0.0,1.0]])) emulated_input_samples.set_values_local(util.meshgrid_ndim((np.linspace(emulated_input_samples.get_domain()[0][0], emulated_input_samples.get_domain()[0][1], 10), np.linspace(emulated_input_samples.get_domain()[1][0], emulated_input_samples.get_domain()[1][1], 10)))) emulated_input_samples.set_probabilities_local(1.0/float(comm.size)*\ (1.0/float(emulated_input_samples.get_values_local().shape[0]))*\ np.ones((emulated_input_samples.get_values_local().shape[0],))) emulated_input_samples.check_num() self.samples = emulated_input_samples
def uniform_partition_uniform_distribution_data_samples(data_set): r""" Creates a simple function approximation of :math:`\rho_{\mathcal{D},M}` where :math:`\rho_{\mathcal{D},M}` is a uniform probability density over the entire ``data_domain``. Here the ``data_domain`` is the union of voronoi cells defined by ``data``. In other words we assign each sample the same probability, so ``M = len(data)`` or rather ``len(d_distr_samples) == len(data)``. The purpose of this method is to approximate uniform distributions over irregularly shaped domains. :param data_set: Sample set that the probability measure is defined for. :type data_set: :class:`~bet.sample.discretization` or :class:`~bet.sample.sample_set` or :class:`~numpy.ndarray` :rtype: :class:`~bet.sample.voronoi_sample_set` :returns: sample_set object defininng simple function approximation """ if isinstance(data_set, samp.sample_set_base): num = data_set.check_num() dim = data_set._dim values = data_set._values s_set = data_set.copy() elif isinstance(data_set, samp.discretization): num = data_set.check_nums() dim = data_set._output_sample_set._dim values = data_set._output_sample_set._values s_set = data_set._output_sample_set.copy() elif isinstance(data_set, np.ndarray): num = data_set.shape[0] dim = data_set.shape[1] values = data_set s_set = samp.sample_set(dim=dim) s_set.set_values(values) else: msg = "The first argument must be of type bet.sample.sample_set, " msg += "bet.sample.discretization or np.ndarray" raise wrong_argument_type(msg) s_set.set_probabilities(np.ones((num,), dtype=np.float)/num) if isinstance(data_set, samp.discretization): data_set._output_probability_set = s_set data_set.set_io_ptr(globalize=False) return s_set
def pick_cfd_points(input_set, radii_vec): r""" Pick 2*input_dim points, for each center, for centered finite difference gradient approximation. The center are not needed for the CFD gradient approximation, they are returned for consistency with the other methods and because of the common need to have not just the gradient but also the QoI value at the centers in adaptive sampling algorithms.The points are returned in the order: centers, followed by the cluster around the first center, then the cluster around the second center and so on. :param input_set: The input sample set. Make sure the attribute _values is not None :type input_set: :class:`~bet.sample.sample_set` :param radii_vec: The radius of the stencil, along each axis :type radii_vec: :class:`numpy.ndarray` of shape (input_dim,) :rtype: :class:`~bet.sample.sample_set` :returns: Centers and clusters of samples near each center (values are :class:`numpy.ndarray` of shape ((``num_close+1``)*``num_centers``, ``input_dim``)) """ if input_set._values is None: raise ValueError("You must have values to use this method.") input_dim = input_set.get_dim() centers = input_set.get_values() num_centers = centers.shape[0] samples = np.repeat(centers, 2 * input_dim, axis=0) radii_vec = util.fix_dimensions_vector(radii_vec) # Contstruct a [num_centers*2*input_dim, input_dim] array that # translates the centers to the CFD points ident = np.eye(input_dim) * radii_vec translate = np.tile(np.append(ident, -ident, axis=0), (num_centers, 1)) samples = samples + translate cluster_set = sample.sample_set(input_dim) if input_set.get_domain() is not None: cluster_set.set_domain(input_set.get_domain()) cluster_set.set_values(centers) cluster_set.append_values(samples) return cluster_set
def setUp(self): """ Set up problem. """ emulated_input_samples = sample.sample_set(1) emulated_input_samples.set_domain(np.array([[0.0, 1.0]])) num_samples=1000 emulated_input_samples.set_values_local(np.linspace(emulated_input_samples.get_domain()[0][0], emulated_input_samples.get_domain()[0][1], num_samples+1)) emulated_input_samples.set_probabilities_local(1.0/float(comm.size)*(1.0/float(\ emulated_input_samples.get_values_local().shape[0]))\ *np.ones((emulated_input_samples.get_values_local().shape[0],))) emulated_input_samples.check_num() self.samples = emulated_input_samples
def setUp(self): param_ref = np.array([0.5]) Q_ref = linear_model3(param_ref) sampler = bsam.sampler(linear_model3) input_samples = sample.sample_set(1) input_samples.set_domain(np.repeat([[0.0, 1.0]], 1, axis=0)) input_samples = sampler.random_sample_set( 'random', input_samples, num_samples=1E2) disc = sampler.compute_QoI_and_create_discretization(input_samples, globalize=True) simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=disc, Q_ref=Q_ref, rect_scale=0.5) num = disc.check_nums() disc._output_sample_set.set_error_estimates(0.01 * np.ones((num, 1))) jac = np.zeros((num, 1, 1)) jac[:, :, :] = np.array([[0.506]]).transpose() disc._input_sample_set.set_jacobians(jac) self.disc = disc
def setUp(self): # create 1-1 map self.input_domain1 = np.column_stack((np.zeros((1,)), np.ones((1,)))) def map_1t1(x): return np.sin(x) # create 3-1 map self.input_domain3 = np.column_stack((np.zeros((3,)), np.ones((3,)))) def map_3t1(x): return np.sum(x, 1) # create 3-2 map def map_3t2(x): return np.vstack(([x[:, 0]+x[:, 1], x[:, 2]])).transpose() # create 10-4 map self.input_domain10 = np.column_stack( (np.zeros((10,)), np.ones((10,)))) def map_10t4(x): x1 = x[:, 0] + x[:, 1] x2 = x[:, 2] + x[:, 3] x3 = x[:, 4] + x[:, 5] x4 = np.sum(x[:, [6, 7, 8, 9]], 1) return np.vstack([x1, x2, x3, x4]).transpose() num_samples = 100 self.savefiles = ["11t11", "1t1", "3to1", "3to2", "10to4"] self.models = [map_1t1, map_1t1, map_3t1, map_3t2, map_10t4] self.samplers = [] for model in self.models: self.samplers.append(bsam.sampler(model, num_samples)) self.input_dim1 = 1 self.input_dim2 = 2 self.input_dim3 = 10 self.input_sample_set1 = sample_set(self.input_dim1) self.input_sample_set2 = sample_set(self.input_dim2) self.input_sample_set3 = sample_set(self.input_dim3) self.input_sample_set4 = sample_set(self.input_domain1.shape[0]) self.input_sample_set4.set_domain(self.input_domain1) self.input_sample_set5 = sample_set(self.input_domain3.shape[0]) self.input_sample_set5.set_domain(self.input_domain3) self.input_sample_set6 = sample_set(self.input_domain10.shape[0]) self.input_sample_set6.set_domain(self.input_domain10)
def setUp(self): """ Set up problem. """ input_samples = sample.sample_set(1) input_samples.set_domain(np.array([[0.0, 1.0]])) # self.lam_domain=np.array([[0.0,1.0]]) num_samples = 1000 input_samples.set_values(np.linspace(input_samples.get_domain()[0, 0], input_samples.get_domain()[0, 1], num_samples+1)) #self.samples = np.linspace(self.lam_domain[0][0], self.lam_domain[0][1], num_samples+1) input_samples.set_probabilities((1.0/float(input_samples.get_values().shape[0])) * np.ones((input_samples.get_values().shape[0],))) #self.P_samples = (1.0/float(self.samples.shape[0]))*np.ones((self.samples.shape[0],)) input_samples._probabilities[0] = 0.0 input_samples._probabilities[-1] *= 2.0 #self.P_samples[0] = 0.0 #self.P_samples[-1] *= 2.0 self.data = input_samples
def verify_random_sample_set_dimension(sampler, sample_type, input_dim, num_samples): np.random.seed(1) # recreate the samples if num_samples is None: num_samples = sampler.num_samples input_domain = np.repeat([[0, 1]], input_dim, axis=0) input_sample_set = sample_set(input_dim) 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) # reset the random seed np.random.seed(1) # create the sample set from the domain my_sample_set = sampler.random_sample_set(sample_type, input_dim, num_samples=num_samples) # make sure that the samples are within the boundaries assert np.all(my_sample_set._values <= input_right) assert np.all(my_sample_set._values >= input_left) # compare the samples if comm.size == 0: nptest.assert_array_equal(input_sample_set._values, my_sample_set._values)
def test_compute_QoI_and_create_discretization(self): """ Test :meth:`bet.sampling.basicSampling.sampler.user_samples` for three different QoI maps (1 to 1, 3 to 1, 3 to 2, 10 to 4). """ # create a list of different sets of samples list_of_samples = [np.ones((4, )), np.ones((4, 1)), np.ones((4, 3)), np.ones((4, 3)), np.ones((4, 10))] list_of_dims = [1, 1, 3, 3, 10] list_of_sample_sets = [None]*len(list_of_samples) for i, array in enumerate(list_of_samples): list_of_sample_sets[i] = sample_set(list_of_dims[i]) list_of_sample_sets[i].set_values(array) test_list = zip(self.models, self.samplers, list_of_sample_sets, self.savefiles) for model, sampler, input_sample_set, savefile in test_list: verify_compute_QoI_and_create_discretization(model, sampler, input_sample_set, savefile)
def setUp(self): """ Setup map. """ param_ref = np.array([0.5, 0.5, 0.5]) Q_ref = linear_model1(param_ref) sampler = bsam.sampler(linear_model1) input_samples = sample.sample_set(3) input_samples.set_domain(np.repeat([[0.0, 1.0]], 3, axis=0)) input_samples = sampler.random_sample_set('random', input_samples, num_samples=1E2) disc = sampler.compute_QoI_and_create_discretization(input_samples, globalize=True) simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=disc, Q_ref=Q_ref, rect_scale=0.5) num = disc.check_nums() disc._output_sample_set.set_error_estimates(0.01 * np.ones((num, 2))) jac = np.zeros((num,2,3)) jac[:,:,:] = np.array([[0.506, 0.463],[0.253, 0.918], [0.085, 0.496]]).transpose() disc._input_sample_set.set_jacobians(jac) self.sur = surrogates.piecewise_polynomial_surrogate(disc)
def pick_ffd_points(input_set, radii_vec): r""" Pick input_dim points, for each centers, for a forward finite difference gradient approximation. The points are returned in the order: centers, followed by the cluster around the first center, then the cluster around the second center and so on. :param input_set: The input sample set. Make sure the attribute _values is not None :type input_set: :class:`~bet.sample.sample_set` :param radii_vec: The radius of the stencil, along each axis :type radii_vec: :class:`numpy.ndarray` of shape (input_dim,) :rtype: :class:`~bet.sample.sample_set` :returns: Centers and clusters of samples near each center (values are :class:`numpy.ndarray` of shape ((``num_close+1``)*``num_centers``, ``input_dim``)) """ if input_set._values is None: raise ValueError("You must have values to use this method.") input_dim = input_set.get_dim() centers = input_set.get_values() num_centers = centers.shape[0] samples = np.repeat(centers, input_dim, axis=0) radii_vec = util.fix_dimensions_vector(radii_vec) # Construct a [num_centers*(input_dim+1), input_dim] matrix that # translates the centers to the FFD points. translate = np.tile(np.eye(input_dim) * radii_vec, (num_centers, 1)) samples = samples + translate cluster_set = sample.sample_set(input_dim) if input_set.get_domain() is not None: cluster_set.set_domain(input_set.get_domain()) cluster_set.set_values(centers) cluster_set.append_values(samples) return cluster_set
def setUp(self): """ Setup maps """ param_ref = np.array([0.5]) Q_ref = linear_model3(param_ref) sampler = bsam.sampler(linear_model3) input_samples = sample.sample_set(1) input_samples.set_domain(np.repeat([[0.0, 1.0]], 1, axis=0)) input_samples = sampler.random_sample_set('random', input_samples, num_samples=1E3) disc = sampler.compute_QoI_and_create_discretization(input_samples, globalize=True) simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=disc, Q_ref=Q_ref, rect_scale=0.5) num = disc.check_nums() disc._output_sample_set.set_error_estimates(0.01 * np.ones((num, 1))) jac = np.zeros((num, 1, 1)) jac[:, :, :] = np.array([[0.506]]).transpose() disc._input_sample_set.set_jacobians(jac) self.sur = surrogates.piecewise_polynomial_surrogate(disc)
import bet.calculateP.simpleFunP as sfun import numpy as np import scipy.io as sio import bet.sample as sample # Import "Truth" mdat = sio.loadmat('../matfiles/Q_2D') Q = mdat['Q'] Q_ref = mdat['Q_true'] # Import Data points = mdat['points'] lam_domain = np.array([[0.07, .15], [0.1, 0.2]]) # Create input, output, and discretization from data read from file input_sample_set = sample.sample_set(points.shape[0]) input_sample_set.set_values(points.transpose()) input_sample_set.set_domain(lam_domain) print "Finished loading data" def postprocess(station_nums, ref_num): filename = 'P_q' + str(station_nums[0] + 1) + '_q' + str(station_nums[1] + 1) if len(station_nums) == 3: filename += '_q' + str(station_nums[2] + 1) filename += '_ref_' + str(ref_num + 1) data = Q[:, station_nums] output_sample_set = sample.sample_set(data.shape[1])
def slice(self, dims=None): r""" Slices the left and right of the comparison. :param list dims: list of indices (dimensions) of sample set to include :rtype: :class:`~bet.sample.comparison` :returns: sliced comparison """ slice_list = ['_values', '_values_local', '_error_estimates', '_error_estimates_local', ] slice_list2 = ['_jacobians', '_jacobians_local'] comp_ss = samp.sample_set(len(dims)) left_ss = samp.sample_set(len(dims)) right_ss = samp.sample_set(len(dims)) if self._comparison_sample_set._domain is not None: comp_ss.set_domain(self._comparison_sample_set._domain[dims, :]) if self._left_sample_set._domain is not None: left_ss.set_domain(self._left_sample_set._domain[dims, :]) if self._left_sample_set._reference_value is not None: left_ss.set_reference_value( self._left_sample_set._reference_value[dims]) if self._right_sample_set._domain is not None: right_ss.set_domain(self._right_sample_set._domain[dims, :]) if self._right_sample_set._reference_value is not None: right_ss.set_reference_value( self._right_sample_set._reference_value[dims]) for obj in slice_list: val = getattr(self._left_sample_set, obj) if val is not None: setattr(left_ss, obj, val[:, dims]) val = getattr(self._right_sample_set, obj) if val is not None: setattr(right_ss, obj, val[:, dims]) val = getattr(self._comparison_sample_set, obj) if val is not None: setattr(comp_ss, obj, val[:, dims]) for obj in slice_list2: val = getattr(self._left_sample_set, obj) if val is not None: nval = np.copy(val) nval = nval.take(dims, axis=1) nval = nval.take(dims, axis=2) setattr(left_ss, obj, nval) val = getattr(self._right_sample_set, obj) if val is not None: nval = np.copy(val) nval = nval.take(dims, axis=1) nval = nval.take(dims, axis=2) setattr(right_ss, obj, nval) comp = comparison(sample_set_left=left_ss, sample_set_right=right_ss, comparison_sample_set=comp_ss) # additional attributes to copy over here. TODO: maybe slice through return comp
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_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 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 sample_prob(percentile, sample_set, sort=True, descending=False): """ This calculates the highest/lowest probability samples whose probability sum to a given value. A new sample_set with the samples corresponding to these highest/lowest probability samples is returned along with the number of samples and the indices. This uses :meth:`~bet.postProcess.sort_by_rho`. The ``descending`` flag determines whether or not to calcuate the highest/lowest. :param percentile: ratio of highest probability samples to select :type percentile: float :param sample_set: Object containing samples and probabilities :type sample_set: :class:`~bet.sample.sample_set_base` or :class:`~bet.sample.discretization` :type indices: :class:`numpy.ndarray` of shape (num_samples,) :param indices: sorting indices :param bool sort: Flag whether or not to sort :param bool descending: Flag order of sorting :param sample_set_out: Object containing sorted samples and probabilities :type sample_set_out: :class:`~bet.sample.sample_set` or :class:`~bet.sample.discretization` :rtype: tuple :returns: ( num_samples, sample_set_out, data) """ if isinstance(sample_set, sample.discretization): samples = sample_set._input_sample_set.get_values() P_samples = sample_set._input_sample_set.get_probabilities() lam_vol = sample_set._input_sample_set.get_volumes() data = sample_set._output_sample_set.get_values() elif isinstance(sample_set, sample.sample_set_base): samples = sample_set.get_values() P_samples = sample_set.get_probabilities() lam_vol = sample_set.get_volumes() data = None else: raise bad_object("Improper sample object") if sort: (sample_set, indices) = sort_by_rho(sample_set) if isinstance(sample_set, sample.discretization): samples = sample_set._input_sample_set.get_values() P_samples = sample_set._input_sample_set.get_probabilities() lam_vol = sample_set._input_sample_set.get_volumes() data = sample_set._output_sample_set.get_values() elif isinstance(sample_set, sample.sample_set_base): samples = sample_set.get_values() P_samples = sample_set.get_probabilities() lam_vol = sample_set.get_volumes() data = None if descending: P_samples = P_samples[::-1] samples = samples[::-1] if lam_vol is not None: lam_vol = lam_vol[::-1] if data is not None: data = data[::-1] indices = indices[::-1] P_sum = np.cumsum(P_samples) num_samples = np.sum(np.logical_and(0.0 < P_sum, P_sum <= percentile)) P_samples = P_samples[0:num_samples] samples = samples[0:num_samples, :] if lam_vol is not None: lam_vol = lam_vol[0:num_samples] if data is not None: if len(data.shape) == 1: data = np.expand_dims(data, axis=1) data = data[0:num_samples, :] if isinstance(sample_set, sample.discretization): samples_out = sample.sample_set(sample_set._input_sample_set.get_dim()) data_out = sample.sample_set(sample_set._output_sample_set.get_dim()) sample_set_out = sample.discretization(samples_out, data_out) sample_set_out._input_sample_set.set_values(samples) sample_set_out._input_sample_set.set_probabilities(P_samples) sample_set_out._input_sample_set.set_volumes(lam_vol) sample_set_out._output_sample_set.set_values(data) else: sample_set_out = sample.sample_set(sample_set.get_dim()) sample_set_out.set_values(samples) sample_set_out.set_probabilities(P_samples) sample_set_out.set_volumes(lam_vol) return (num_samples, sample_set_out, indices[0:num_samples])
def sort_by_rho(sample_set): """ This sorts the samples within the sample_set by probability density. If a discretization object is given, then the QoI data is also sorted to maintain the correspondence. Any volumes present in the input space (or just the sample object) are also sorted. :param sample_set: Object containing samples and probabilities :type sample_set: :class:`~bet.sample.sample_set_base` or :class:`~bet.sample.discretization` :param indices: sorting indices :type indices: :class:`numpy.ndarray` of shape (num_samples,) :param sample_set_out: Object containing sorted samples and probabilities :type sample_set_out: :class:`~bet.sample.sample_set` or :class:`~bet.sample.discretization` :rtype: tuple :returns: (sample_set_out, indicices) """ if isinstance(sample_set, sample.discretization): samples = sample_set._input_sample_set.get_values() P_samples = sample_set._input_sample_set.get_probabilities() lam_vol = sample_set._input_sample_set.get_volumes() data = sample_set._output_sample_set.get_values() elif isinstance(sample_set, sample.sample_set_base): samples = sample_set.get_values() P_samples = sample_set.get_probabilities() lam_vol = sample_set.get_volumes() data = None else: raise bad_object("Improper sample object") nnz = np.sum(P_samples > 0) if lam_vol is None: indices = np.argsort(P_samples)[::-1][0:nnz] else: indices = np.argsort(P_samples / lam_vol)[::-1][0:nnz] P_samples = P_samples[indices] samples = samples[indices, :] if lam_vol is not None: lam_vol = lam_vol[indices] if data is not None: data = data[indices, :] if isinstance(sample_set, sample.discretization): samples_out = sample.sample_set(sample_set._input_sample_set.get_dim()) data_out = sample.sample_set(sample_set._output_sample_set.get_dim()) sample_set_out = sample.discretization(samples_out, data_out) sample_set_out._input_sample_set.set_values(samples) sample_set_out._input_sample_set.set_probabilities(P_samples) sample_set_out._input_sample_set.set_volumes(lam_vol) sample_set_out._output_sample_set.set_values(data) else: sample_set_out = sample.sample_set(sample_set.get_dim()) sample_set_out.set_values(samples) sample_set_out.set_probabilities(P_samples) sample_set_out.set_volumes(lam_vol) return (sample_set_out, indices)
def generalized_chains(self, input_obj, t_set, kern, savefile, initial_sample_type="random", criterion='center', hot_start=0): """ Basic adaptive sampling algorithm using generalized chains. .. todo:: Test HOTSTART from parallel files using different num proc :param string initial_sample_type: type of initial sample random (or r), latin hypercube(lhs), or space-filling curve(TBD) :param input_obj: Either a :class:`bet.sample.sample_set` object for an input space, an array of min and max bounds for the input values with ``min = input_domain[:, 0]`` and ``max = input_domain[:, 1]``, or the dimension of an input space :type input_obj: :class:`~bet.sample.sample_set`, :class:`numpy.ndarray` of shape (ndim, 2), or :class: `int` :param t_set: method for creating new parameter steps using given a step size based on the paramter domain size :type t_set: :class:`bet.sampling.adaptiveSampling.transition_set` :param kern: functional that acts on the data used to determine the proposed change to the ``step_size`` :type kernel: :class:~`bet.sampling.adaptiveSampling.kernel` object. :param string savefile: filename to save samples and data :param int hot_start: Flag whether or not hot start the sampling chains from a previous set of chains. Note that ``num_chains`` must be the same, but ``num_chains_pproc`` need not be the same. 0 - cold start, 1 - hot start from uncompleted run, 2 - hot start from finished run :param string criterion: latin hypercube criterion see `PyDOE <http://pythonhosted.org/pyDOE/randomized.html>`_ :rtype: tuple :returns: (``discretization``, ``all_step_ratios``) where ``discretization`` is a :class:`~bet.sample.discretization` object containing ``num_samples`` and ``all_step_ratios`` is np.ndarray of shape ``(num_chains, chain_length)`` """ # Calculate step_size max_ratio = t_set.max_ratio min_ratio = t_set.min_ratio if not hot_start: logging.info("COLD START") step_ratio = t_set.init_ratio * np.ones(self.num_chains_pproc) # Initiative first batch of N samples (maybe taken from latin # hypercube/space-filling curve to fully explore parameter space - # not necessarily random). Call these Samples_old. disc_old = super(sampler, self).create_random_discretization( initial_sample_type, input_obj, savefile, self.num_chains, criterion, globalize=False) self.num_samples = self.chain_length * self.num_chains comm.Barrier() # populate local values #disc_old._input_sample_set.global_to_local() #disc_old._output_sample_set.global_to_local() input_old = disc_old._input_sample_set.copy() disc = disc_old.copy() all_step_ratios = step_ratio (kern_old, proposal) = kern.delta_step(disc_old.\ _output_sample_set.get_values_local(), None) start_ind = 1 if hot_start: # LOAD FILES _, disc, all_step_ratios, kern_old = loadmat( savefile, lb_model=None, hot_start=hot_start, num_chains=self.num_chains) # MAKE SURE ARRAYS ARE LOCALIZED FROM HERE ON OUT WILL ONLY # OPERATE ON _local_values # Set mdat, step_ratio, input_old, start_ind appropriately step_ratio = all_step_ratios[-self.num_chains_pproc:] input_old = sample.sample_set(disc._input_sample_set.get_dim()) input_old.set_domain(disc._input_sample_set.get_domain()) input_old.set_values_local(disc._input_sample_set.\ get_values_local()[-self.num_chains_pproc:, :]) # Determine how many batches have been run start_ind = disc._input_sample_set.get_values_local().\ shape[0]/self.num_chains_pproc mdat = dict() self.update_mdict(mdat) input_old.update_bounds_local() for batch in xrange(start_ind, self.chain_length): # For each of N samples_old, create N new parameter samples using # transition set and step_ratio. Call these samples input_new. input_new = t_set.step(step_ratio, input_old) # Solve the model for the input_new. output_new_values = self.lb_model(input_new.get_values_local()) # Make some decision about changing step_size(k). There are # multiple ways to do this. # Determine step size (kern_old, proposal) = kern.delta_step(output_new_values, kern_old) step_ratio = proposal * step_ratio # Is the ratio greater than max? step_ratio[step_ratio > max_ratio] = max_ratio # Is the ratio less than min? step_ratio[step_ratio < min_ratio] = min_ratio # Save and export concatentated arrays if self.chain_length < 4: pass elif comm.rank == 0 and (batch + 1) % (self.chain_length / 4) == 0: logging.info("Current chain length: "+\ str(batch+1)+"/"+str(self.chain_length)) disc._input_sample_set.append_values_local(input_new.\ get_values_local()) disc._output_sample_set.append_values_local(output_new_values) all_step_ratios = np.concatenate((all_step_ratios, step_ratio)) mdat['step_ratios'] = all_step_ratios mdat['kern_old'] = kern_old super(sampler, self).save(mdat, savefile, disc, globalize=False) input_old = input_new # collect everything disc._input_sample_set.update_bounds_local() #disc._input_sample_set.local_to_global() #disc._output_sample_set.local_to_global() MYall_step_ratios = np.copy(all_step_ratios) # ``all_step_ratios`` is np.ndarray of shape (num_chains, # chain_length) all_step_ratios = util.get_global_values(MYall_step_ratios, shape=(self.num_samples, )) all_step_ratios = np.reshape(all_step_ratios, (self.num_chains, self.chain_length), 'F') # save everything mdat['step_ratios'] = all_step_ratios mdat['kern_old'] = util.get_global_values(kern_old, shape=(self.num_chains, )) super(sampler, self).save(mdat, savefile, disc, globalize=True) return (disc, all_step_ratios)
def rho_D(outputs): rho_left = np.repeat([Q_ref - .5 * bin_size], outputs.shape[0], 0) rho_right = np.repeat([Q_ref + .5 * bin_size], outputs.shape[0], 0) rho_left = np.all(np.greater_equal(outputs, rho_left), axis=1) rho_right = np.all(np.less_equal(outputs, rho_right), axis=1) inside = np.logical_and(rho_left, rho_right) max_values = np.repeat(maximum, outputs.shape[0], 0) return inside.astype('float64') * max_values # Read in points_ref and plot results ref_sample = mdat['points_true'] ref_sample = ref_sample[:, 14] # Create input, output, and discretization from data read from file input_sample_set = sample.sample_set(points.shape[0]) input_sample_set.set_values(points.transpose()) input_sample_set.set_domain(param_domain) output_sample_set = sample.sample_set(Q.shape[1]) output_sample_set.set_values(Q) my_disc = sample.discretization(input_sample_set, output_sample_set) # Show the samples in the parameter space pDom.scatter_rhoD(my_disc, rho_D=rho_D, ref_sample=ref_sample, io_flag='input') # Show the corresponding samples in the data space pDom.scatter_rhoD(output_sample_set, rho_D=rho_D, ref_sample=Q_ref, io_flag='output') # Show multiple data domains that correspond with the convex hull of samples in
def generate_for_input_set(self, input_sample_set, order=0): """ Generates a surrogate discretization based on the input discretization, for a user-defined input sample set. The output sample set values and error estimates are piecewise polynomially defined over input sample set cells from the input discretization. For order 0, both are piecewise constant. For order 1, values are piecewise linear (assuming Jacobians exist), and error estimates are piecewise constant. :param input_sample_set: input sample set for surrogate discretization :type set_old: :class:`~bet.sample.sample_set_base` :param order: Polynomial order :type order: int :rtype: :class:`~bet.sample.discretization` :returns: discretization defining the surrogate model """ # Check inputs if order not in [0, 1]: msg = "Order must be 0 or 1." raise calculateError.wrong_argument_type(msg) input_sample_set.check_num() if input_sample_set._dim != self.input_disc._input_sample_set._dim: msg = "Dimensions of input sets are not equal." raise sample.dim_not_matching(msg) # Give properties from input discretization. if input_sample_set._domain is None: if self.input_disc._input_sample_set._domain is not None: input_sample_set.set_domain(self.input_disc.\ _input_sample_set._domain) if input_sample_set._p_norm is None: if self.input_disc._input_sample_set._p_norm is not None: input_sample_set.set_p_norm(self.input_disc.\ _input_sample_set._p_norm) # Setup dummy discretizion to get pointers # Assumes Voronoi sample set for now output_sample_set = sample.sample_set(self.input_disc.\ _output_sample_set._dim) self.dummy_disc = self.input_disc.copy() self.dummy_disc.set_emulated_input_sample_set(input_sample_set) self.dummy_disc.set_emulated_ii_ptr(globalize=False) if order == 0: # define new values based on piecewise constants new_values_local = self.input_disc._output_sample_set.\ _values[self.dummy_disc._emulated_ii_ptr_local] output_sample_set.set_values_local(new_values_local) elif order == 1: # define new values based on piecewise linears using Jacobians if self.input_disc._input_sample_set._jacobians is None: if self.input_disc._input_sample_set._jacobians_local is None: msg = "The input discretization must" msg += " have jacobians defined." raise calculateError.wrong_argument_type(msg) else: self.input_disc._input_sample_set.local_to_global() jac_local = self.input_disc._input_sample_set._jacobians[\ self.dummy_disc._emulated_ii_ptr_local] diff_local = self.input_disc._input_sample_set._values[\ self.dummy_disc._emulated_ii_ptr_local] - \ input_sample_set._values_local new_values_local = self.input_disc._output_sample_set._values[\ self.dummy_disc._emulated_ii_ptr_local] new_values_local += np.einsum('ijk,ik->ij', jac_local, diff_local) output_sample_set.set_values_local(new_values_local) # if they exist, define error estimates with piecewise constants if self.input_disc._output_sample_set._error_estimates is not None: new_ee = self.input_disc._output_sample_set._error_estimates[\ self.dummy_disc._emulated_ii_ptr_local] output_sample_set.set_error_estimates_local(new_ee) # create discretization object for the surrogate self.surrogate_discretization = sample.discretization(input_sample_set\ =input_sample_set, output_sample_set=output_sample_set, output_probability_set=self.input_disc._output_probability_set) return self.surrogate_discretization
def calculate_gradients_cfd(cluster_discretization, normalize=True): """ Approximate gradient vectors at ``num_centers, centers.shape[0]`` points in the parameter space for each QoI map. THIS METHOD IS DEPENDENT ON USING :meth:~bet.sensitivity.pick_cfd_points TO CHOOSE SAMPLES FOR THE CFD STENCIL AROUND EACH CENTER. THE ORDERING MATTERS. :param cluster_discretization: Must contain input and output values for the sample clusters. :type cluster_discretization: :class:`~bet.sample.discretization` :param boolean normalize: If normalize is True, normalize each gradient vector :rtype: :class:`~bet.sample.discretization` :returns: A new :class:`~bet.sample.discretization` that contains only the centers of the clusters and their associated ``_jacobians`` which are tensor representation of the gradient vectors of each QoI map at each point in centers :class:`numpy.ndarray` of shape (num_samples, output_dim, input_dim) """ if cluster_discretization._input_sample_set.get_values() is None \ or cluster_discretization._output_sample_set.get_values() is None: raise ValueError("You must have values to use this method.") samples = cluster_discretization._input_sample_set.get_values() data = cluster_discretization._output_sample_set.get_values() input_dim = cluster_discretization._input_sample_set.get_dim() num_model_samples = cluster_discretization.check_nums() output_dim = cluster_discretization._output_sample_set.get_dim() num_model_samples = cluster_discretization.check_nums() input_dim = cluster_discretization._input_sample_set.get_dim() num_centers = num_model_samples / (2 * input_dim + 1) # Find radii_vec from the first cluster of samples radii_vec = samples[num_centers:num_centers + input_dim, :] - samples[0, :] radii_vec = util.fix_dimensions_vector_2darray(radii_vec.diagonal()) # Clean the data data = util.clean_data(data[num_centers:]) gradient_tensor = np.zeros([num_centers, output_dim, input_dim]) radii_vec = np.tile(np.repeat(radii_vec, output_dim, axis=1), [num_centers, 1]) # Construct indices for CFD gradient approxiation inds = np.repeat(range(0, 2 * input_dim * num_centers, 2 * input_dim), input_dim) + np.tile(range(0, input_dim), num_centers) inds = np.array([inds, inds + input_dim]).transpose() gradient_mat = (data[inds[:, 0]] - data[inds[:, 1]]) * (0.5 / radii_vec) # Reshape and organize gradient_tensor = np.reshape(gradient_mat.transpose(), [output_dim, input_dim, num_centers], order='F').transpose(2, 0, 1) if normalize: # Compute the norm of each vector norm_gradient_tensor = np.linalg.norm(gradient_tensor, ord=1, axis=2) # If it is a zero vector (has 0 norm), set norm=1, avoid divide by zero norm_gradient_tensor[norm_gradient_tensor == 0] = 1.0 # Normalize each gradient vector gradient_tensor = gradient_tensor / np.tile( norm_gradient_tensor, (input_dim, 1, 1)).transpose(1, 2, 0) center_input_sample_set = sample.sample_set(input_dim) center_input_sample_set.set_values(samples[:num_centers, :]) if cluster_discretization._input_sample_set.get_domain() is not None: center_input_sample_set.set_domain(cluster_discretization.\ _input_sample_set.get_domain()) center_input_sample_set.set_jacobians(gradient_tensor) center_output_sample_set = sample.sample_set(output_dim) center_output_sample_set.set_values(data[:num_centers, :]) if cluster_discretization._output_sample_set.get_domain() is not None: center_output_sample_set.set_domain(cluster_discretization.\ _output_sample_set.get_domain()) #center_output_sample_set.set_jacobians(gradient_tensor.transpose()) center_discretization = sample.discretization(center_input_sample_set, center_output_sample_set) return center_discretization
def calculate_gradients_rbf(cluster_discretization, num_centers=None, num_neighbors=None, RBF=None, ep=None, normalize=True): r""" Approximate gradient vectors at ``num_centers, centers.shape[0]`` points in the parameter space for each QoI map using a radial basis function interpolation method. :param cluster_discretization: Must contain input and output values for the sample clusters. :type cluster_discretization: :class:`~bet.sample.discretization` :param int num_centers: The number of cluster centers. :param int num_neighbors: Number of nearest neighbors to use in gradient approximation. Default value is ``input_dim + 2`` :param string RBF: Choice of radial basis function. Default is Gaussian :param float ep: Choice of shape parameter for radial basis function. Default value is 1.0 :param boolean normalize: If normalize is True, normalize each gradient vector :rtype: :class:`~bet.sample.discretization` :returns: A new :class:`~bet.sample.discretization` that contains only the centers of the clusters and their associated ``_jacobians`` which are tensor representation of the gradient vectors of each QoI map at each point in centers :class:`numpy.ndarray` of shape (num_samples, output_dim, input_dim) """ if cluster_discretization._input_sample_set.get_values() is None \ or cluster_discretization._output_sample_set.get_values() is None: raise ValueError("You must have values to use this method.") samples = cluster_discretization._input_sample_set.get_values() data = cluster_discretization._output_sample_set.get_values() input_dim = cluster_discretization._input_sample_set.get_dim() num_model_samples = cluster_discretization.check_nums() output_dim = cluster_discretization._output_sample_set.get_dim() if num_neighbors is None: num_neighbors = input_dim + 2 if ep is None: ep = 1.0 if RBF is None: RBF = 'Gaussian' # If centers is None we assume the user chose clusters of size # input_dim + 2 if num_centers is None: num_centers = num_model_samples / (input_dim + 2) centers = samples[:num_centers, :] rbf_tensor = np.zeros([num_centers, num_model_samples, input_dim]) gradient_tensor = np.zeros([num_centers, output_dim, input_dim]) # For each center, interpolate the data using the rbf chosen and # then evaluate the partial derivative of that interpolant at the desired # point. for c in range(num_centers): # Find the k nearest neighbors and their distances to centers[c,:] [r, nearest] = cluster_discretization._input_sample_set.query(\ centers[c, :], k=num_neighbors) r = np.tile(r, (input_dim, 1)) # Compute the linf distances to each of the nearest neighbors diffVec = (centers[c, :] - samples[nearest, :]).transpose() # Compute the l2 distances between pairs of nearest neighbors distMat = spatial.distance_matrix(samples[nearest, :], samples[nearest, :]) # Solve for the rbf weights using interpolation conditions and # evaluate the partial derivatives rbf_mat_values = \ np.linalg.solve(radial_basis_function(distMat, RBF), radial_basis_function_dxi(r, diffVec, RBF, ep) \ .transpose()).transpose() # Construct the finite difference matrices rbf_tensor[c, nearest, :] = rbf_mat_values.transpose() gradient_tensor = rbf_tensor.transpose(2, 0, 1).dot(data).transpose(1, 2, 0) if normalize: # Compute the norm of each vector norm_gradient_tensor = np.linalg.norm(gradient_tensor, ord=1, axis=2) # If it is a zero vector (has 0 norm), set norm=1, avoid divide by zero norm_gradient_tensor[norm_gradient_tensor == 0] = 1.0 # Normalize each gradient vector gradient_tensor = gradient_tensor / np.tile( norm_gradient_tensor, (input_dim, 1, 1)).transpose(1, 2, 0) center_input_sample_set = sample.sample_set(input_dim) center_input_sample_set.set_values(samples[:num_centers, :]) if cluster_discretization._input_sample_set.get_domain() is not None: center_input_sample_set.set_domain(cluster_discretization.\ _input_sample_set.get_domain()) center_input_sample_set.set_jacobians(gradient_tensor) center_output_sample_set = sample.sample_set(output_dim) center_output_sample_set.set_values(data[:num_centers, :]) if cluster_discretization._output_sample_set.get_domain() is not None: center_output_sample_set.set_domain(cluster_discretization.\ _output_sample_set.get_domain()) #center_output_sample_set.set_jacobians(gradient_tensor.transpose()) center_discretization = sample.discretization(center_input_sample_set, center_output_sample_set) return center_discretization
import bet.postProcess.plotDomains as plotD import bet.postProcess.postTools as postTools import bet.sample as samp # Labels and descriptions of the uncertain parameters labels = [ 'Source $y$ coordinate [L]', 'Source $x$ coordinate [L]', 'Dispersivity x [L]', 'Flow Angle [degrees]', 'Contaminant flux [M/T]' ] # Load data from files # First obtain info on the parameter domain parameter_domain = np.loadtxt("files/lam_domain.txt.gz") # parameter domain parameter_dim = parameter_domain.shape[0] # Create input sample set input_samples = samp.sample_set(parameter_dim) input_samples.set_domain(parameter_domain) input_samples.set_values(np.loadtxt("files/samples.txt.gz")) input_samples.estimate_volume_mc() # Use standard MC estimate of volumes # Choose which QoI to use and create output sample set QoI_indices_observe = np.array([0, 1, 2, 3]) output_samples = samp.sample_set(QoI_indices_observe.size) output_samples.set_values( np.loadtxt("files/data.txt.gz")[:, QoI_indices_observe]) # Create discretization object my_discretization = samp.discretization(input_sample_set=input_samples, output_sample_set=output_samples) # Load the reference parameter and QoI values param_ref = np.loadtxt("files/lam_ref.txt.gz") # reference parameter set
def sample_lp_ball(input_set, num_close, radius, p_num=2): r""" Pick num_close points in a the Lp ball of length 2*``radii_vec`` around a point in the input space, do this for each point in centers. If this box extends outside of the domain of the input space, we sample the intersection. :param input_set: The input sample set. Make sure the attribute ``_values`` is not ``None`` :type input_set: :class:`~bet.sample.sample_set` :param int num_close: Number of points in each cluster :param radii_vec: Each side of the box will have length ``2*radii_vec[i]`` :type radii_vec: :class:`numpy.ndarray` of shape (``input_dim``,) :param float p_num: :math:`0 < p \leq \infty`, p for the lp norm where infinity is ``numpy.inf`` :rtype: :class:`~bet.sample.sample_set` :returns: Centers and clusters of samples near each center (values are :class:`numpy.ndarray` of shape ((``num_close+1``)*``num_centers``, ``input_dim``)) """ if input_set.get_values() is None: raise ValueError("You must have values to use this method.") input_dim = input_set.get_dim() centers = input_set.get_values() num_centers = input_set.check_num() input_domain = input_set.get_domain() cluster_set = sample.sample_set(input_dim) if input_domain is not None: cluster_set.set_domain(input_domain) cluster_set.set_values(centers) for i in xrange(num_centers): in_bounds = 0 inflate = 1.0 while in_bounds < num_close: # sample uniformly new_cluster = lpsam.Lp_generalized_uniform(input_dim, num_close * inflate, p_num, radius, centers[i, :]) # check bounds if input_domain is not None: cluster_set.update_bounds(num_close * inflate) left = np.all(np.greater_equal(new_cluster, cluster_set._left), axis=1) right = np.all(np.less_equal(new_cluster, cluster_set._right), axis=1) inside = np.logical_and(left, right) in_bounds = np.sum(inside) new_cluster = new_cluster[inside, :] # increase inflate inflate *= 10.0 else: in_bounds = num_close if in_bounds > num_close: new_cluster = new_cluster[:num_close, :] cluster_set.append_values(new_cluster) # reset bounds cluster_set._left = None cluster_set._right = None cluster_set._width = None return cluster_set
import bet.postProcess.postTools as postTools import bet.Comm as comm import bet.sample as sample # Set up the info for the spaces input_dim = 5 output_dim = 10 num_samples = 1E5 num_centers = 10 # Let the map Q be a random matrix of size (output_dim, input_dim) np.random.seed(0) Q = np.random.random([output_dim, input_dim]) # Initialize some sample objects we will need input_samples = sample.sample_set(input_dim) output_samples = sample.sample_set(output_dim) # Choose random samples in parameter space to solve the model input_samples.set_values( np.random.uniform(0, 1, [np.int(num_samples), input_dim])) # Make the MC assumption and compute the volumes of each voronoi cell input_samples.estimate_volume_mc() # Compute the output values with the map Q output_samples.set_values( Q.dot(input_samples.get_values().transpose()).transpose()) # Calculate the gradient vectors at some subset of the samples. Here the # *normalize* argument is set to *True* because we are using bin_ratio to
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 setUp(self): """ Set up problem. """ # Create sample_set object for input_samples input_samples = sample.sample_set(4) input_samples.set_domain(np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0], [0.0, 1.0]])) input_samples.set_values(util.meshgrid_ndim( (np.linspace(input_samples.get_domain()[0, 0], input_samples.get_domain()[0, 1], 3), np.linspace(input_samples.get_domain()[1, 0], input_samples.get_domain()[1, 1], 3), np.linspace(input_samples.get_domain()[2, 0], input_samples.get_domain()[2, 1], 3), np.linspace(input_samples.get_domain()[3, 0], input_samples.get_domain()[3, 1], 3)))) input_samples.set_probabilities( (1.0/float(input_samples.get_values().shape[0])) * np.ones((input_samples.get_values().shape[0],))) # Check that probabilities and values arrays have same number of entries input_samples.check_num() # Create sample_set object for output_samples output_samples = sample.sample_set(4) output_samples.set_values(input_samples.get_values()*3.0) output_samples.set_domain(3.0*input_samples.get_domain()) self.disc = sample.discretization(input_samples, output_samples) self.filename = "testfigure" output_ref_datum = np.mean(output_samples.get_domain(), axis=1) bin_size = 0.15*(np.max(output_samples.get_domain(), axis=1) - np.min(output_samples.get_domain(), axis=1)) maximum = 1/np.product(bin_size) def ifun(outputs): """ Indicator function. :param outputs: outputs :type outputs: :class:`numpy.ndarray` of shape (N, ndim) :rtype: :class:`numpy.ndarray` of shape (N,) :returns: 0 if outside of set or positive number if inside set """ left = np.repeat([output_ref_datum-.5*bin_size], outputs.shape[0], 0) right = np.repeat([output_ref_datum+.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 self.rho_D = ifun self.lnums = [1, 2, 3] self.markers = [] for m in Line2D.markers: try: if len(m) == 1 and m != ' ': self.markers.append(m) except TypeError: pass self.colors = ('b', 'g', 'r', 'c', 'm', 'y', 'k')
def regular_sample_set(input_obj, num_samples_per_dim=1): """ Sampling algorithm for generating a regular grid of samples taken on the domain present with ``input_obj`` (a default unit hypercube is used if no domain has been specified) :param input_obj: :class:`~bet.sample.sample_set` object containing the dimension or domain to sample from, the 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 num_samples_per_dim: number of samples per dimension :type num_samples_per_dim: :class:`~numpy.ndarray` of dimension ``(input_sample_set._dim,)`` :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 not isinstance(num_samples_per_dim, collections.Iterable): num_samples_per_dim = num_samples_per_dim * np.ones((dim, )) if np.any(np.less_equal(num_samples_per_dim, 0)): warnings.warn('Warning: num_samples_per_dim must be greater than 0') num_samples = int(np.product(num_samples_per_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) else: input_domain = input_sample_set.get_domain() # update the bounds based on the number of samples input_values = np.zeros((num_samples, dim)) vec_samples_dimension = np.empty((dim), dtype=object) for i in range(dim): bin_width = (input_domain[i, 1] - input_domain[i, 0]) / \ np.float(num_samples_per_dim[i]) vec_samples_dimension[i] = list( np.linspace(input_domain[i, 0] - 0.5 * bin_width, input_domain[i, 1] + 0.5 * bin_width, num_samples_per_dim[i] + 2))[1:int(num_samples_per_dim[i] + 1)] arrays_samples_dimension = np.meshgrid( *[vec_samples_dimension[i] for i in np.arange(0, dim)], indexing='ij') for i in range(dim): input_values[:, i:i + 1] = np.vstack(arrays_samples_dimension[i].flat[:]) input_sample_set.set_values(input_values) input_sample_set.global_to_local() return input_sample_set
of all space-time locations (``indexstart = 0``, ``indexstop = 1000``), or, we can check the QoI at a particular time (e.g., setting ``indexstart=0`` and ``indexstop = 20`` considers all the spatial QoI only at the first time step). In general, ``indexstart`` can be any integer between 0 and 998 and ``indexstop`` must be at least 2 greater than ``indexstart`` (so between 2 and 1000 subject to the additional constraint that ``indexstop`` :math: `\geq` ``indexstart + 2`` to ensure that we check at least a single pair of QoI.) ''' indexstart = 0 indexstop = 20 qoiIndices = range(indexstart, indexstop) # Initialize the necessary sample objects input_samples = sample.sample_set(2) output_samples = sample.sample_set(1000) # Set the input sample values from the imported file input_samples.set_values(matfile['samples']) # Set the data fromthe imported file output_samples.set_values(matfile['data']) # Create the cluster discretization cluster_discretization = sample.discretization(input_samples, output_samples) # Calculate the gradient vectors at each of the 16 centers for each of the # QoI maps if fd_scheme.upper() in ['RBF']: center_discretization = grad.calculate_gradients_rbf(
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 user_partition_user_distribution(data_set, data_partition_set, data_distribution_set): r""" Creates a user defined simple function approximation of a user defined distribution. The simple function discretization is specified in the ``data_partition_set``, and the set of i.i.d. samples from the distribution is specified in the ``data_distribution_set``. :param data_set: Sample set that the probability measure is defined for. :type data_set: :class:`~bet.sample.discretization` or :class:`~bet.sample.sample_set` or :class:`~numpy.ndarray` :param data_partition_set: Sample set defining the discretization of the data space into Voronoi cells for which a simple function is defined upon. :type data_partition_set: :class:`~bet.sample.discretization` or :class:`~bet.sample.sample_set` or :class:`~numpy.ndarray` :param data_distribution_set: Sample set containing the i.i.d. samples from the distribution on the data space that are binned within the Voronoi cells implicitly defined by the data_discretization_set. :type data_distribution_set: :class:`~bet.sample.discretization` or :class:`~bet.sample.sample_set` or :class:`~numpy.ndarray` :rtype: :class:`~bet.sample.voronoi_sample_set` :returns: sample_set object defininng simple function approximation """ if isinstance(data_set, samp.sample_set_base): s_set = data_set.copy() dim = s_set._dim elif isinstance(data_set, samp.discretization): s_set = data_set._output_sample_set.copy() dim = s_set._dim elif isinstance(data_set, np.ndarray): dim = data_set.shape[1] values = data_set s_set = samp.sample_set(dim=dim) s_set.set_values(values) else: msg = "The first argument must be of type bet.sample.sample_set, " msg += "bet.sample.discretization or np.ndarray" raise wrong_argument_type(msg) if isinstance(data_partition_set, samp.sample_set_base): M = data_partition_set.check_num() d_distr_samples = data_partition_set._values dim_simpleFun = d_distr_samples.shape[1] elif isinstance(data_partition_set, samp.discretization): M = data_partition_set.check_nums() d_distr_samples = data_partition_set._output_sample_set._values dim_simpleFun = d_distr_samples.shape[1] elif isinstance(data_partition_set, np.ndarray): M = data_partition_set.shape[0] dim_simpleFun = data_partition_set.shape[1] d_distr_samples = data_partition_set else: msg = "The second argument must be of type bet.sample.sample_set, " msg += "bet.sample.discretization or np.ndarray" raise wrong_argument_type(msg) if isinstance(data_distribution_set, samp.sample_set_base): d_distr_emulate = data_distribution_set._values dim_MonteCarlo = d_distr_emulate.shape[1] num_d_emulate = data_distribution_set.check_num() elif isinstance(data_distribution_set, samp.discretization): d_distr_emulate = data_distribution_set._output_sample_set._values dim_MonteCarlo = d_distr_emulate.shape[1] num_d_emulate = data_distribution_set.check_nums() elif isinstance(data_distribution_set, np.ndarray): num_d_emulate = data_distribution_set.shape[0] dim_MonteCarlo = data_distribution_set.shape[1] d_distr_emulate = data_distribution_set else: msg = "The second argument must be of type bet.sample.sample_set, " msg += "bet.sample.discretization or np.ndarray" raise wrong_argument_type(msg) if np.not_equal(dim_MonteCarlo, dim) or np.not_equal(dim_simpleFun, dim): msg = "The argument types have conflicting dimensions" raise wrong_argument_type(msg) # Initialize sample set object s_set = samp.sample_set(dim) s_set.set_values(d_distr_samples) s_set.set_kdtree() (_, k) = s_set.query(d_distr_emulate) count_neighbors = np.zeros((M,), dtype=np.int) for i in xrange(M): count_neighbors[i] = np.sum(np.equal(k, i)) # Use the binning to define :math:`\rho_{\mathcal{D},M}` ccount_neighbors = np.copy(count_neighbors) comm.Allreduce([count_neighbors, MPI.INT], [ccount_neighbors, MPI.INT], op=MPI.SUM) count_neighbors = ccount_neighbors rho_D_M = count_neighbors.astype(np.float64) / \ float(num_d_emulate * comm.size) s_set.set_probabilities(rho_D_M) if isinstance(data_set, samp.discretization): data_set._output_probability_set = s_set return s_set
import bet.postProcess.plotDomains as plotD import bet.sample as samp import bet.sampling.basicSampling as bsam from myModel import my_model from Compute_Save_KL import computeSaveKL # Interface BET to the model. sampler = bsam.sampler(my_model) # Define the number of KL terms to use to represent permeability field num_KL_terms = 2 # Compute and save the KL expansion -- can comment out after running once computeSaveKL(num_KL_terms) # Initialize input parameter sample set object input_samples = samp.sample_set(num_KL_terms) # Set parameter domain KL_term_min = -3.0 KL_term_max = 3.0 input_samples.set_domain( np.repeat([[KL_term_min, KL_term_max]], num_KL_terms, axis=0)) ''' Suggested changes for user: Try with and without random sampling. If using regular sampling, try different numbers of samples per dimension (be careful if the dimension is not 2). ''' # Generate samples on the parameter space
figurepath = "figures_linearode/decay-"+str(decaynum) if not os.path.isdir(figurepath): os.makedirs(figurepath) # Whether to create new output data createNewOutputData = sys.argv[2].lower() == 'true' # Generate true parameters an, bn = mm.true_param() coef_true= np.zeros((1,10)) coef_true[0,0::2] = an coef_true[0,1::2] = bn # Initialize 2*trunc_term input parameter sample set object # trunc_term is defined in myModel input_samples = samp.sample_set(2*mm.param_len) # Set parameter domain parameter_domain = mm.my_model_domain(pow = -decaynum, halfwidth0 = 0.5) input_samples.set_domain(parameter_domain) # Define the sampler that will be used to create the discretization # object, which is the fundamental object used by BET to compute # solutions to the stochastic inverse problem sampler = bsam.sampler(mm.my_model) # Generate samples on the parameter space randomSampling = True if randomSampling is True: input_samples = sampler.random_sample_set('random', input_samples, num_samples =200000) else:
def scatter_rhoD(sample_obj, ref_sample=None, sample_nos=None, io_flag='input', rho_D=None, dim_nums=None, label_char=None, showdim=None, save=True, interactive=False, file_extension=".png", markersize=75): r""" Create scatter plots of samples within the sample object colored by ``color`` (usually an array of pointwise probability density values). A reference sample (``ref_sample``) can be chosen by the user. This reference sample will be plotted as a mauve circle twice the size of the other markers. .. note:: Do not specify the file extension in BOTH ``filename`` and ``file_extension``. :param sample_obj: Object containing the samples to plot :type sample_obj: :class:`~bet.sample.discretization` or :class:`~bet.sample.sample_set_base` :param ref_sample: reference parameter value :type ref_sample: :class:`numpy.ndarray` of shape (ndim,) :param list sample_nos: sample numbers to plot :param string io_flag: Either `input` or `output`. If ``sample_obj`` is a :class:`~bet.sample.discretization` object flag whether or not put plot input or output. :param rho_D: probability density function on D :type rho_D: callable function that takes a :class:`np.array` and returns a :class:`numpy.ndarray` :param list dim_nums: integers representing domain coordinate numbers to plot (e.g. i, where :math:`\x_i` is a coordinate in the input/output space). :param string label_char: character to use to label coordinate axes :param int showdim: 2 or 3, flag to determine whether or not to show pairwise or tripletwise parameter sample scatter plots in 2 or 3 dimensions :param bool save: flag whether or not to save the figure :param bool interactive: flag whether or not to show the figure :param string file_extension: file extension """ # If there is density function given determine the pointwise probability # values of each sample based on the value in the data space. Otherwise, # color the samples in numerical order. rD = None if isinstance(sample_obj, sample.discretization): if rho_D is not None: rD = rho_D(sample_obj._output_sample_set.get_values()) if io_flag == 'input': sample_obj = sample_obj._input_sample_set else: sample_obj = sample_obj._output_sample_set elif isinstance(sample_obj, sample.sample_set_base): if io_flag == 'output': rD = rho_D(sample_obj.get_values()) else: raise bad_object("Improper sample object") if ref_sample is None: ref_sample = sample_obj._reference_value if rD is None: rD = np.ones(sample_obj.get_values().shape[0]) if label_char is None: if io_flag == 'input': label_char = r'$\lambda_' prefix = 'input_' elif io_flag == 'output': label_char = r'$q_' prefix = 'output_' else: # no io_flag label_char = r'$x_' prefix = 'rhoD_' else: label_char = r'$x_' prefix = 'rhoD_' # If no specific coordinate numbers are given for the parameter coordinates # (e.g. i, where \lambda_i is a coordinate in the parameter space), then # set them to be the the counting numbers. if dim_nums is None: dim_nums = 1 + np.array(np.arange(sample_obj.get_values().shape[1])) # Create the labels based on the user selected parameter coordinates xlabel = label_char + r'{' + str(dim_nums[0]) + '}$' ylabel = label_char + r'{' + str(dim_nums[1]) + '}$' savename = prefix + 'samples_cs' # Plot 2 or 3 dimensional scatter plots of the samples colored by rD. if sample_obj.get_dim() == 2: scatter_2D(sample_obj, sample_nos, rD, ref_sample, save, interactive, xlabel, ylabel, None, savename, markersize=markersize) elif sample_obj.get_dim() > 2 and showdim == 2: temp_obj = sample.sample_set(2) for x, y in combinations(dim_nums, 2): xlabel = label_char + r'{' + str(x) + '}$' ylabel = label_char + r'{' + str(y) + '}$' savename = prefix + 'samples_x' + str(x) + 'x' + str(y) + '_cs' temp_obj.set_values(sample_obj.get_values()[:, [x - 1, y - 1]]) if ref_sample is not None: scatter_2D(temp_obj, sample_nos, rD, ref_sample[[x - 1, y - 1]], save, interactive, xlabel, ylabel, None, savename, markersize=markersize) else: scatter_2D(temp_obj, sample_nos, rD, ref_sample, save, interactive, xlabel, ylabel, None, savename, markersize=markersize) elif sample_obj.get_dim() == 3: zlabel = label_char + r'{' + str(dim_nums[2]) + '}$' scatter_3D(sample_obj, sample_nos, rD, ref_sample, save, interactive, xlabel, ylabel, zlabel, None, savename, markersize=markersize) elif sample_obj.get_dim() > 3 and showdim == 3: temp_obj = sample.sample_set(3) for x, y, z in combinations(dim_nums, 3): xlabel = label_char + r'{' + str(x) + '}$' ylabel = label_char + r'{' + str(y) + '}$' zlabel = label_char + r'{' + str(z) + '}$' savename = prefix + 'samples_x' + str(x) + 'x' + str(y) + 'x' +\ str(z) + '_cs' temp_obj.set_values(sample_obj.get_values()[:, [x - 1, y - 1, z - 1]]) if ref_sample is not None: scatter_3D(temp_obj, sample_nos, rD, ref_sample[[x - 1, y - 1, z - 1]], save, interactive, xlabel, ylabel, zlabel, None, savename, file_extension, markersize=markersize) else: scatter_3D(temp_obj, sample_nos, rD, ref_sample, save, interactive, xlabel, ylabel, zlabel, None, savename, file_extension, markersize=markersize)
import bet.postProcess.postTools as postTools import bet.Comm as comm import bet.sample as sample # Set up the info for the spaces input_dim = 5 QoI_scalar_map_num = 10 num_samples = 1E5 num_centers = 10 # Let the map Q be a random matrix of size (QoI_scalar_map_num, input_dim) np.random.seed(0) Q = np.random.random([QoI_scalar_map_num, input_dim]) # Initialize some sample objects we will need input_samples = sample.sample_set(input_dim) output_samples = sample.sample_set(QoI_scalar_map_num) # Choose random samples in parameter space to solve the model input_samples.set_values( np.random.uniform(0, 1, [np.int(num_samples), input_dim])) # Compute the output values with the map Q output_samples.set_values( Q.dot(input_samples.get_values().transpose()).transpose()) # Calculate the gradient vectors at some subset of the samples. Here the # *normalize* argument is set to *True* because we are using *bin_ratio* to # determine the uncertainty in our data. cluster_discretization = sample.discretization(input_samples, output_samples) # We will approximate the jacobian at each of the centers
import bet.postProcess.plotP as plotP import bet.postProcess.plotDomains as plotD import bet.sample as samp import bet.sampling.basicSampling as bsam from myModel import my_model # Define the sampler that will be used to create the discretization # object, which is the fundamental object used by BET to compute # solutions to the stochastic inverse problem. # The sampler and my_model is the interface of BET to the model, # and it allows BET to create input/output samples of the model. sampler = bsam.sampler(my_model) # Initialize 2-dimensional input parameter sample set object input_samples = samp.sample_set(2) # Set parameter domain input_samples.set_domain(np.array([[3.0, 6.0], [1.0, 5.0]])) ''' Suggested changes for user: Try with and without random sampling. If using random sampling, try num_samples = 1E3 and 1E4. What happens when num_samples = 1E2? Try using 'lhs' instead of 'random' in the random_sample_set. If using regular sampling, try different numbers of samples per dimension. '''
def show_data_domain_multi(sample_disc, Q_ref=None, Q_nums=None, img_folder='figs/', ref_markers=None, ref_colors=None, showdim=None, file_extension=".png", markersize=75): r""" Plots 2-D projections of the data domain D using a triangulation based on the first two coordinates (parameters) of the generating samples where :math:`Q={q_1, q_i}` for ``i=Q_nums``, with a marker for various :math:`Q_{ref}`. :param sample_disc: Object containing the samples to plot :type sample_disc: :class:`~bet.sample.discretization` :param Q_ref: reference data value :type Q_ref: :class:`numpy.ndarray` of shape (M, mdim) :param list Q_nums: dimensions of the QoI to plot :param string img_folder: folder to save the plots to :param list ref_markers: list of marker types for :math:`Q_{ref}` :param list ref_colors: list of colors for :math:`Q_{ref}` :param showdim: default 1. If int then flag to show all combinations with a given dimension (:math:`q_i`) or if ``all`` show all combinations. :type showdim: int or string :param string file_extension: file extension """ if not isinstance(sample_disc, sample.discretization): raise bad_object("Improper sample object") # Set the default marker and colors if ref_markers is None: ref_markers = markers if ref_colors is None: ref_colors = colors data_obj = sample_disc._output_sample_set sample_obj = sample_disc._input_sample_set if Q_ref is None: Q_ref = data_obj._reference_value # If no specific coordinate numbers are given for the data coordinates # (e.g. i, where \q_i is a coordinate in the data space), then # set them to be the the counting numbers. if Q_nums is None: Q_nums = list(range(data_obj.get_dim())) # If no specific coordinate number of choice is given set to be the first # coordinate direction. if showdim is None: showdim = 0 # Create a folder for these figures if it doesn't already exist if not os.path.isdir(img_folder): os.mkdir(img_folder) # Make sure the shape of Q_ref is correct if Q_ref is not None: Q_ref = util.fix_dimensions_data(Q_ref, data_obj.get_dim()) # Create the triangulization to use to define the topology of the samples # in the data space from the first two parameters in the parameter space triangulation = tri.Triangulation(sample_obj.get_values()[:, 0], sample_obj.get_values()[:, 1]) triangles = triangulation.triangles # Create plots of the showdim^th QoI (q_{showdim}) with all other QoI (q_i) if isinstance(showdim, int): for i in Q_nums: if i != showdim: xlabel = r'$q_{' + str(showdim + 1) + r'}$' ylabel = r'$q_{' + str(i + 1) + r'}$' filenames = [ img_folder + 'domain_q' + str(showdim + 1) + '_q' + str(i + 1), img_folder + 'q' + str(showdim + 1) + '_q' + str(i + 1) + '_domain_Q_cs' ] data_obj_temp = sample.sample_set(2) data_obj_temp.set_values(data_obj.get_values()[:, [showdim, i]]) sample_disc_temp = sample.discretization( sample_obj, data_obj_temp) if Q_ref is not None: show_data_domain_2D(sample_disc_temp, Q_ref[:, [showdim, i]], ref_markers, ref_colors, xlabel=xlabel, ylabel=ylabel, triangles=triangles, save=True, interactive=False, filenames=filenames, file_extension=file_extension, markersize=markersize) else: show_data_domain_2D(sample_disc_temp, None, ref_markers, ref_colors, xlabel=xlabel, ylabel=ylabel, triangles=triangles, save=True, interactive=False, filenames=filenames, file_extension=file_extension, markersize=markersize) # Create plots of all combinations of QoI in 2D elif showdim == 'all' or showdim == 'ALL': for x, y in combinations(Q_nums, 2): xlabel = r'$q_{' + str(x + 1) + r'}$' ylabel = r'$q_{' + str(y + 1) + r'}$' filenames = [ img_folder + 'domain_q' + str(x + 1) + '_q' + str(y + 1), img_folder + 'q' + str(x + 1) + '_q' + str(y + 1) + '_domain_Q_cs' ] data_obj_temp = sample.sample_set(2) data_obj_temp.set_values(data_obj.get_values()[:, [x, y]]) sample_disc_temp = sample.discretization(sample_obj, data_obj_temp) if Q_ref is not None: show_data_domain_2D(sample_disc_temp, Q_ref[:, [x, y]], ref_markers, ref_colors, xlabel=xlabel, ylabel=ylabel, triangles=triangles, save=True, interactive=False, filenames=filenames, file_extension=file_extension, markersize=markersize) else: show_data_domain_2D(sample_disc_temp, None, ref_markers, ref_colors, xlabel=xlabel, ylabel=ylabel, triangles=triangles, save=True, interactive=False, filenames=filenames, file_extension=file_extension, markersize=markersize)
import bet.calculateP.calculateP as calculateP import bet.postProcess.plotP as plotP import bet.postProcess.plotDomains as plotD import bet.sample as samp import bet.sampling.basicSampling as bsam from myModel import my_model # Define the sampler that will be used to create the discretization # object, which is the fundamental object used by BET to compute # solutions to the stochastic inverse problem. # The sampler and my_model is the interface of BET to the model, # and it allows BET to create input/output samples of the model. sampler = bsam.sampler(my_model) # Initialize 3-dimensional input parameter sample set object input_samples = samp.sample_set(2) # Set parameter domain input_samples.set_domain(np.repeat([[0.0, 1.0]], 2, axis=0)) ''' Suggested changes for user: Try with and without random sampling. If using random sampling, try num_samples = 1E3 and 1E4. What happens when num_samples = 1E2? Try using 'lhs' instead of 'random' in the random_sample_set. If using regular sampling, try different numbers of samples per dimension.
def scatter_2D_multi(sample_obj, color=None, ref_sample=None, img_folder='figs/', filename="scatter2Dm", label_char=r'$\lambda', showdim=None, file_extension=".png", cbar_label=None, markersize=75): r""" Creates two-dimensional projections of scatter plots of samples colored by ``color`` (usually an array of pointwise probability density values). A reference sample (``ref_sample``) can be chosen by the user. This reference sample will be plotted as a mauve circle twice the size of the other markers. .. note:: Do not specify the file extension in BOTH ``filename`` and ``file_extension``. :param sample_obj: Object containing the samples to plot :type sample_obj: :class:`~bet.sample.sample_set_base` :param color: values to color the ``samples`` by :type color: :class:`numpy.ndarray` :param string filename: filename to save the figure as :param string label_char: character to use to label coordinate axes :param bool save: flag whether or not to save the figure :param bool interactive: flag whether or not to show the figure :param string img_folder: folder to save the plots to :param showdim: default 1. If int then flag to show all combinations with a given dimension (:math:`\lambda_i`) or if ``all`` show all combinations. :type showdim: int or string :param string filename: filename to save the figure as :param string cbar_label: color bar label """ if not isinstance(sample_obj, sample.sample_set_base): raise bad_object("Improper sample object") # If no specific coordinate number of choice is given set to be the first # coordinate direction. if showdim is None: showdim = 0 # Create a folder for these figures if it doesn't already exist if not os.path.isdir(img_folder): os.mkdir(img_folder) # Create list of all the parameter coordinates p_nums = np.arange(sample_obj.get_dim()) # Create plots of the showdim^th parameter (\lambda_{showdim}) with all the # other parameters if isinstance(showdim, int): for i in p_nums: xlabel = label_char + r'_{' + str(showdim + 1) + r'}$' ylabel = label_char + r'_{' + str(i + 1) + r'}$' postfix = '_d' + str(showdim + 1) + '_d' + str(i + 1) myfilename = os.path.join(img_folder, filename + postfix) sample_obj_temp = sample.sample_set(2) sample_obj_temp.set_values(sample_obj.get_values()[:, [showdim, i]]) if ref_sample is not None: scatter_2D(sample_obj_temp, sample_nos=None, color=color, ref_sample=ref_sample[[showdim, i]], save=True, interactive=False, xlabel=xlabel, ylabel=ylabel, cbar_label=cbar_label, filename=myfilename, file_extension=file_extension, markersize=markersize) else: scatter_2D(sample_obj_temp, sample_nos=None, color=color, ref_sample=None, save=True, interactive=False, xlabel=xlabel, ylabel=ylabel, cbar_label=cbar_label, filename=myfilename, file_extension=file_extension, markersize=markersize) # Create plots of all of the possible pairwise combinations of parameters elif showdim == 'all' or showdim == 'ALL': for x, y in combinations(p_nums, 2): xlabel = label_char + r'_{' + str(x + 1) + r'}$' ylabel = label_char + r'_{' + str(y + 1) + r'}$' postfix = '_d' + str(x + 1) + '_d' + str(y + 1) myfilename = os.path.join(img_folder, filename + postfix) sample_obj_temp = sample.sample_set(2) sample_obj_temp.set_values(sample_obj.get_values()[:, [x, y]]) if ref_sample is not None: scatter_2D(sample_obj_temp, sample_nos=None, color=color, ref_sample=ref_sample[[x, y]], save=True, interactive=False, xlabel=xlabel, ylabel=ylabel, cbar_label=cbar_label, filename=myfilename, markersize=markersize, file_extension=file_extension) else: scatter_2D(sample_obj_temp, sample_nos=None, color=color, ref_sample=None, save=True, interactive=False, xlabel=xlabel, ylabel=ylabel, cbar_label=cbar_label, markersize=markersize, filename=myfilename, file_extension=file_extension)