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],)))
mdict = dict()
mdict['rho_D_M'] = rho_D_M
mdict['d_distr_samples'] = d_distr_samples
# 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
# Export P and compare to MATLAB solution visually
sio.savemat(filename, mdict, do_compression=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]
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):
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):
"""
Set up problem.
"""
import numpy.random as rnd
rnd.seed(1)
self.lam_domain=np.zeros((1,2))
self.lam_domain[0,0]=0.0
self.lam_domain[0,1]=1.0
self.num_l_emulate = 1001
self.lambda_emulate = calcP.emulate_iid_lebesgue(self.lam_domain, self.num_l_emulate)
self.samples = rnd.rand(100,)
self.data = 2.0*self.samples
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):
"""
Set up problem.
"""
import numpy.random as rnd
rnd.seed(1)
self.lam_domain = np.zeros((1, 2))
self.lam_domain[0, 0] = 0.0
self.lam_domain[0, 1] = 1.0
self.num_l_emulate = 1001
self.lambda_emulate = calcP.emulate_iid_lebesgue(
self.lam_domain, self.num_l_emulate)
self.samples = rnd.rand(100, )
self.data = 2.0 * self.samples
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 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)
def setUp(self):
"""
Set up problem.
"""
super(uniform_hyperrectangle_ratio_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.rho_D_M, self.d_distr_samples, self.d_Tree = sFun.uniform_hyperrectangle(self.data,
self.Q_ref, binratio, self.center_pts_per_edge)
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], )))
mdict = dict()
mdict['rho_D_M'] = rho_D_M
mdict['d_distr_samples'] = d_distr_samples
# 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
# Export P and compare to MATLAB solution visually
sio.savemat(filename, mdict, do_compression=True)
dmin = data.min(axis=0)
dscale = bin_ratio*(dmax-dmin)
Qmax = Q_ref + 0.5*dscale
Qmin = Q_ref -0.5*dscale
def rho_D(x):
return np.all(np.logical_and(np.greater(x,Qmin), np.less(x,Qmax)),axis=1)
# Plot the data domain
plotD.show_data(data, Q_ref = Q_ref, rho_D=rho_D, showdim=2)
# Whether or not to use deterministic description of simple function approximation of
# ouput probability
deterministic_discretize_D = True
if deterministic_discretize_D == True:
(d_distr_prob, d_distr_samples, d_Tree) = simpleFunP.uniform_hyperrectangle(data=data,
Q_ref=Q_ref,
bin_ratio=bin_ratio,
center_pts_per_edge = 1)
else:
(d_distr_prob, d_distr_samples, d_Tree) = simpleFunP.unif_unif(data=data,
Q_ref=Q_ref,
M=50,
bin_ratio=bin_ratio,
num_d_emulate=1E5)
# calculate probablities making Monte Carlo assumption
(P, lam_vol, io_ptr) = calculateP.prob(samples=samples,
data=data,
rho_D_M=d_distr_prob,
d_distr_samples=d_distr_samples)
# calculate 2D marginal probabilities
defeats the purpose of "localizing" the probability within a subset of D.
uniform_hyperrectangle uses the same measure defined in the same way as
unif_unif, but the difference is in the discretization which is on a
regular grid defined by center_pts_per_edge. If center_pts_per_edge = 1,
then the contour event corresponding to the entire support of rho_D is
approximated as a single event. This is done by carefully placing a
regular 3x3 grid (for the D=2 case) of points in D with the center
point of the grid in the center of the support of the measure and the
other points placed outside of the rectangle defining the support to
define a total of 9 contour events with 8 of them with zero probability.
'''
deterministic_discretize_D = True
if deterministic_discretize_D == True:
(d_distr_prob, d_distr_samples, d_Tree) = simpleFunP.uniform_hyperrectangle(data=data,
Q_ref=Q_ref, bin_ratio=0.2, center_pts_per_edge = 1)
else:
(d_distr_prob, d_distr_samples, d_Tree) = simpleFunP.unif_unif(data=data,
Q_ref=Q_ref, M=50, bin_ratio=0.2, num_d_emulate=1E5)
# create emulated points
'''
Suggested changes for user:
If using a regular grid of sampling (if random_sample = False), we set
lambda_emulate = samples
Otherwise, play around with num_l_emulate. A value of 1E2 will probably
give poor results while results become fairly consistent with values
uniform_hyperrectangle uses the same measure defined in the same way as
unif_unif, but the difference is in the discretization which is on a
regular grid defined by center_pts_per_edge. If center_pts_per_edge = 1,
then the contour event corresponding to the entire support of rho_D is
approximated as a single event. This is done by carefully placing a
regular 3x3 grid (for the D=2 case) of points in D with the center
point of the grid in the center of the support of the measure and the
other points placed outside of the rectangle defining the support to
define a total of 9 contour events with 8 of them with zero probability.
'''
deterministic_discretize_D = True
if deterministic_discretize_D == True:
(d_distr_prob, d_distr_samples,
d_Tree) = simpleFunP.uniform_hyperrectangle(data=data,
Q_ref=Q_ref,
bin_ratio=0.2,
center_pts_per_edge=1)
else:
(d_distr_prob, d_distr_samples,
d_Tree) = simpleFunP.unif_unif(data=data,
Q_ref=Q_ref,
M=50,
bin_ratio=0.2,
num_d_emulate=1E5)
# create emulated points
'''
Suggested changes for user:
If using a regular grid of sampling (if random_sample = False), we set
