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 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 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 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 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 setUp(self): """ Set up problem. """ super(regular_partition_uniform_distribution_rectangle_scaled_list, self).setUp() if type(self.Q_ref) != np.array: Q_ref = np.array([self.Q_ref]) else: Q_ref = self.Q_ref if len(self.data_domain.shape) == 1: data_domain = np.expand_dims(self.data_domain, axis=0) else: data_domain = self.data_domain self.rect_domain = np.zeros((data_domain.shape[0], 2)) binratio = 0.1*np.ones((data_domain.shape[0],)) r_width = binratio*data_domain[:,1] self.rect_domain[:, 0] = Q_ref - .5*r_width self.rect_domain[:, 1] = Q_ref + .5*r_width self.data_prob = sFun.regular_partition_uniform_distribution_rectangle_scaled( self.data, self.Q_ref, binratio) self.rho_D_M = self.data_prob._probabilities self.d_distr_samples = self.data_prob._values
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): 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): """ 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 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], ))) num_l_emulate = 1e4 set_emulated = bsam.random_sample_set('r', lam_domain, num_l_emulate) my_disc = sample.discretization(input_sample_set, output_sample_set, output_probability_set, emulated_input_sample_set=set_emulated) print("Finished emulating lambda samples") # Calculate P on lambda emulate print("Calculating prob_on_emulated_samples") calcP.prob_on_emulated_samples(my_disc) sample.save_discretization(my_disc, filename, "prob_on_emulated_samples_solution") # 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") # Calculate P on the actual samples estimating voronoi cell volume with MC # integration calcP.prob_with_emulated_volumes(my_disc) print("Calculating prob_with_emulated_volumes") sample.save_discretization(my_disc, filename, "prob_with_emulated_volumes_solution")
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)
plotD.scatter_2D_multi(input_samples, ref_sample= param_ref, showdim = 'all', filename = 'linearMap_ParameterSamples', file_extension = '.eps') plotD.show_data_domain_2D(my_discretization, Q_ref = Q_ref, file_extension='.eps') ''' Suggested changes for user: Try different ways of discretizing the probability measure on D defined as a uniform probability measure on a rectangle (since D is 2-dimensional) centered at Q_ref whose size is determined by scaling the circumscribing box of D. ''' randomDataDiscretization = False if randomDataDiscretization is False: simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.25, cells_per_dimension = 3) else: simpleFunP.uniform_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.25, M=50, num_d_emulate=1E5) # calculate probablities calculateP.prob(my_discretization) ######################################## # Post-process the results ######################################## ''' Suggested changes for user:
if Q_ref.size == 2: plotD.show_data_domain_2D(my_discretization, Q_ref=Q_ref, file_extension=".eps") ''' Suggested changes for user: Try different ways of discretizing the probability measure on D defined as a uniform probability measure on a rectangle or interval depending on choice of QoI_num in myModel.py. ''' randomDataDiscretization = False if randomDataDiscretization is False: simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.25, cells_per_dimension=3) else: simpleFunP.uniform_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.25, M=50, num_d_emulate=1E5) # calculate probabilities calculateP.prob(my_discretization) ######################################## # Post-process the results
# create a discretization object my_discretization = samp.discretization(input_sample_set=input_samples, output_sample_set=output_samples) file_name_base = "KL_cor_var_inverse_rscale" disc_name_base = "disc_prob" for scale in range(1): scale = 5 fact = 2**scale fname = file_name_base + "_p05d" + str(fact) fname2 = disc_name_base + "_p05d" + str(fact) simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.05 / fact, center_pts_per_edge=1) # calculate the induced probability calculateP.prob(my_discretization) samp.save_discretization(my_discretization, fname) P = input_samples.get_probabilities() case = [] discrete_prob = np.zeros((np.size(var), np.size(eta))) ''' discrete_prob[i][j][k] = prob of i^th variance, j^th correlation length ''' i = 0 j = 0
input_samples = samp.sample_set(1) input_samples.set_domain(np.array([[1.5, 4.5]])) input_samples.set_values(samples) # associate volume input_samples.estimate_volume_mc() output_samples = samp.sample_set(2) output_samples.set_values(data) disc_name_base = "disc_prob_simpleFunc" # create a discretization object my_discretization = samp.discretization(input_sample_set=input_samples, output_sample_set=output_samples) fact = 4 simpleFunP.regular_partition_uniform_distribution_rectangle_scaled( data_set=my_discretization, Q_ref=Q_ref, rect_scale=0.2 / fact, center_pts_per_edge=1) # calculate the induced probability calculateP.prob(my_discretization) samp.save_discretization(my_discretization, fname) P = input_samples.get_probabilities() case = [] discrete_prob = np.zeros(3) print np.shape(P) print n_samples stride = 0 for meso in range(3): print stride, stride + n_samples