def setUp(self): """ Set up problem. """ import numpy.random as rnd rnd.seed(1) self.lam_domain=np.zeros((10,2)) self.lam_domain[:,0]=0.0 self.lam_domain[:,1]=1.0 self.num_l_emulate = 1001 self.lambda_emulate = calcP.emulate_iid_lebesgue(self.lam_domain, self.num_l_emulate) self.samples = calcP.emulate_iid_lebesgue(self.lam_domain, 100) self.data = np.dot(self.samples,rnd.rand(10,4)) Q_ref = np.mean(self.data, axis=0) (self.d_distr_prob, self.d_distr_samples, self.d_Tree) = simpleFunP.uniform_hyperrectangle(data=self.data,Q_ref=Q_ref, bin_ratio=0.2, center_pts_per_edge = 1)
def setUp(self): """ Test dimension, number of samples, and that all the samples are within lambda_domain. """ lam_left = np.array([0.0, .25, .4]) lam_right = np.array([1.0, 4.0, .5]) lam_width = lam_right-lam_left self.lam_domain = np.zeros((3, 3)) self.lam_domain[:, 0] = lam_left self.lam_domain[:, 1] = lam_right num_samples_dim = 2 start = lam_left+lam_width/(2*num_samples_dim) stop = lam_right-lam_width/(2*num_samples_dim) d1_arrays = [] for l, r in zip(start, stop): d1_arrays.append(np.linspace(l, r, num_samples_dim)) self.num_l_emulate = 1000001 self.lambda_emulate = calcP.emulate_iid_lebesgue(self.lam_domain, self.num_l_emulate) self.samples = util.meshgrid_ndim(d1_arrays) self.volume_exact = 1.0/self.samples.shape[0] self.lam_vol, self.lam_vol_local, self.local_index = calcP.\ estimate_volume(self.samples, self.lambda_emulate)
def runTest(self): """ Test dimension, number of samples, and that all the samples are within lambda_domain. """ lam_left = np.array([0.0, .25, .4]) lam_right = np.array([1.0, 4.0, .5]) lam_domain = np.zeros((3,3)) lam_domain[:,0] = lam_left lam_domain[:,1] = lam_right num_l_emulate = 1e6 lambda_emulate = calcP.emulate_iid_lebesgue(lam_domain, num_l_emulate) # check the dimension np.assert_array_equal(lambda_emulate.shape, (3, num_l_emulate)) # check that the samples are all within the correct bounds np.assertGreaterEqual(0.0, np.min(lambda_emulate[0, :])) np.assertGreaterEqual(.25, np.min(lambda_emulate[1, :])) np.assertGreaterEqual(.4, np.min(lambda_emulate[2, :])) np.assertLessEqual(1.0, np.max(lambda_emulate[0, :])) np.assertLessEqual(4.0, np.max(lambda_emulate[1, :])) np.assertLessEqual(.5, np.max(lambda_emulate[2, :]))
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] 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...) (rho_D_M, d_distr_samples, d_Tree) = sfun.uniform_hyperrectangle(data, q_ref, bin_ratio=0.15, center_pts_per_edge=np.ones((data.shape[1],))) num_l_emulate = 1e6 lambda_emulate = calcP.emulate_iid_lebesgue(lam_domain, num_l_emulate) if comm.rank == 0: print "Finished emulating lambda samples" mdict = dict() mdict['rho_D_M'] = rho_D_M mdict['d_distr_samples'] = d_distr_samples mdict['num_l_emulate'] = num_l_emulate # Calculate P on lambda emulate (P0, lem0, io_ptr0, emulate_ptr0) = calcP.prob_emulated(samples, data, rho_D_M, d_distr_samples, lambda_emulate, d_Tree) if comm.rank == 0: print "Calculating prob_emulated" mdict['P0'] = P0 mdict['lem0'] = lem0 mdict['io_ptr0'] = io_ptr0 mdict['emulate_ptr0'] = emulate_ptr0 # Calclate P on the actual samples with assumption that voronoi cells have # equal size (P1, lam_vol1, io_ptr1) = calcP.prob(samples, data, rho_D_M, d_distr_samples, d_Tree) if comm.rank == 0: print "Calculating prob" mdict['P1'] = P1 mdict['lam_vol1'] = lam_vol1 mdict['lem1'] = samples mdict['io_ptr1'] = io_ptr1 # Calculate P on the actual samples estimating voronoi cell volume with MC # integration (P3, lam_vol3, lambda_emulate3, io_ptr3, emulate_ptr3) = calcP.prob_mc(samples, data, rho_D_M, d_distr_samples, lambda_emulate, d_Tree) if comm.rank == 0: print "Calculating prob_mc" mdict['P3'] = P3 mdict['lam_vol3'] = lam_vol3 mdict['io_ptr3'] = io_ptr3 mdict['emulate_ptr3'] = emulate_ptr3 # Export P sio.savemat(filename, mdict, do_compression=True)
def postprocess(station_nums, ref_num): filename = 'P_q'+str(station_nums[0]+1)+'_q' if len(station_nums) == 3: filename += '_q'+str(station_nums[2]+1) filename += '_ref_'+str(ref_num+1) data = Q[:, station_nums] 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...) (rho_D_M, d_distr_samples, d_Tree) = sfun.uniform_hyperrectangle(data, q_ref, bin_ratio=0.15, center_pts_per_edge=np.ones((data.shape[1],))) num_l_emulate = 1e6 lambda_emulate = calcP.emulate_iid_lebesgue(lam_domain, num_l_emulate) print "Finished emulating lambda samples" mdict = dict() mdict['rho_D_M'] = rho_D_M mdict['d_distr_samples'] = d_distr_samples mdict['num_l_emulate'] = num_l_emulate mdict['lambda_emulate'] = lambda_emulate # Calculate P on lambda emulate (P0, lem0, io_ptr0, emulate_ptr0) = calcP.prob_emulated(samples, data, rho_D_M, d_distr_samples, lambda_emulate, d_Tree) print "Calculating prob_emulated" mdict['P0'] = P0 mdict['lem0'] = lem0 mdict['io_ptr0'] = io_ptr0 mdict['emulate_ptr0'] = emulate_ptr0 # Calclate P on the actual samples with assumption that voronoi cells have # equal size (P1, lam_vol1, io_ptr1) = calcP.prob(samples, data, rho_D_M, d_distr_samples, d_Tree) print "Calculating prob" mdict['P1'] = P1 mdict['lam_vol1'] = lam_vol1 mdict['lem1'] = samples mdict['io_ptr1'] = io_ptr1 # Calculate P on the actual samples estimating voronoi cell volume with MC # integration (P3, lam_vol3, lambda_emulate3, io_ptr3, emulate_ptr3) = calcP.prob_mc(samples, data, rho_D_M, d_distr_samples, lambda_emulate, d_Tree) print "Calculating prob_mc" mdict['P3'] = P3 mdict['lam_vol3'] = lam_vol3 mdict['io_ptr3'] = io_ptr3 mdict['emulate_ptr3'] = emulate_ptr3 # Export P sio.savemat(filename, mdict, do_compression=True)
def setUp(self): """ Set up problem. """ import numpy.random as rnd rnd.seed(1) self.lam_domain = np.zeros((10, 2)) self.lam_domain[:, 0] = 0.0 self.lam_domain[:, 1] = 1.0 self.num_l_emulate = 1001 self.lambda_emulate = calcP.emulate_iid_lebesgue( self.lam_domain, self.num_l_emulate) self.samples = calcP.emulate_iid_lebesgue(self.lam_domain, 100) self.data = np.dot(self.samples, rnd.rand(10, 4)) Q_ref = np.mean(self.data, axis=0) (self.d_distr_prob, self.d_distr_samples, self.d_Tree) = simpleFunP.uniform_hyperrectangle( data=self.data, Q_ref=Q_ref, bin_ratio=0.2, center_pts_per_edge=1)
def setUp(self): self.samples = np.loadtxt(data_path + "/3to2_samples.txt.gz") self.data = np.loadtxt(data_path + "/3to2_data.txt.gz") Q_ref = np.array([0.422, 0.9385]) (self.d_distr_prob, self.d_distr_samples, self.d_Tree) = simpleFunP.uniform_hyperrectangle(data=self.data,Q_ref=Q_ref, bin_ratio=0.2, center_pts_per_edge = 1) self.lam_domain= np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) import numpy.random as rnd rnd.seed(1) self.lambda_emulate = calcP.emulate_iid_lebesgue(lam_domain=self.lam_domain, num_l_emulate = 1001)
def setUp(self): self.samples = np.loadtxt(data_path + "/3to2_samples.txt.gz") self.data = np.loadtxt(data_path + "/3to2_data.txt.gz") Q_ref = np.array([0.422, 0.9385]) (self.d_distr_prob, self.d_distr_samples, self.d_Tree) = simpleFunP.uniform_hyperrectangle( data=self.data, Q_ref=Q_ref, bin_ratio=0.2, center_pts_per_edge=1) self.lam_domain = np.array([[0.0, 1.0], [0.0, 1.0], [0.0, 1.0]]) import numpy.random as rnd rnd.seed(1) self.lambda_emulate = calcP.emulate_iid_lebesgue( lam_domain=self.lam_domain, num_l_emulate=1001)
def setUp(self): """ Test dimension, number of samples, and that all the samples are within lambda_domain. """ lam_left = np.array([0.0, .25, .4]) lam_right = np.array([1.0, 4.0, .5]) self.lam_domain = np.zeros((3,3)) self.lam_domain[:,0] = lam_left self.lam_domain[:,1] = lam_right self.num_l_emulate = 1000001 self.lambda_emulate = calcP.emulate_iid_lebesgue(self.lam_domain, self.num_l_emulate)
def setUp(self): """ Test dimension, number of samples, and that all the samples are within lambda_domain. """ lam_left = np.array([0.0, .25, .4]) lam_right = np.array([1.0, 4.0, .5]) self.lam_domain = np.zeros((3, 3)) self.lam_domain[:, 0] = lam_left self.lam_domain[:, 1] = lam_right self.num_l_emulate = 1000001 self.lambda_emulate = calcP.emulate_iid_lebesgue( self.lam_domain, self.num_l_emulate)
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 += '_truth_'+str(ref_num+1) data = Q[:, station_nums] 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...) (rho_D_M, d_distr_samples, d_Tree) = sfun.uniform_hyperrectangle(data, q_ref, bin_ratio=0.15, center_pts_per_edge=np.ones((data.shape[1],))) num_l_emulate = 1e6 lambda_emulate = calcP.emulate_iid_lebesgue(lam_domain, num_l_emulate) print "Finished emulating lambda samples" # Calculate P on the actual samples estimating voronoi cell volume with MC # integration (P3, lam_vol3, lambda_emulate3, io_ptr3, emulate_ptr3) = calcP.prob_mc(samples, data, rho_D_M, d_distr_samples, lam_domain, lambda_emulate, d_Tree) print "Calculating prob_mc" mdict = dict() mdict['rho_D_M'] = rho_D_M mdict['d_distr_samples'] = d_distr_samples mdict['lambda_emulate'] = util.get_global_values(lambda_emulate) mdict['num_l_emulate'] = mdict['lambda_emulate'].shape[1] mdict['P3'] = util.get_global_values(P3) mdict['lam_vol3'] = util.get_global_values(lam_vol3) mdict['io_ptr3'] = util.get_global_values(io_ptr3) mdict['emulate_ptr3'] = emulate_ptr3 if rank == 0: # Export P and compare to MATLAB solution visually sio.savemat(filename, mdict, do_compression=True)
that are approximately 10x the number of samples. Note that you can always use lambda_emulate = samples and this simply will imply that a standard Monte Carlo assumption is being used, which in a measure-theoretic context implies that each Voronoi cell is assumed to have the same measure. This type of approximation is more reasonable for large n_samples due to the slow convergence rate of Monte Carlo (it converges like 1/sqrt(n_samples)). ''' if random_sample is False: lambda_emulate = samples else: lambda_emulate = calculateP.emulate_iid_lebesgue( lam_domain=lam_domain, num_l_emulate=1E5) # calculate probablities (P, lambda_emulate, io_ptr, emulate_ptr) = \ calculateP.prob_emulated(samples=samples, data=data, rho_D_M=d_distr_prob, d_distr_samples=d_distr_samples, lambda_emulate=lambda_emulate, d_Tree=d_Tree) # calculate 2d marginal probs ''' Suggested changes for user: