def setUp(self): self.Lambda_dim = 2 self.num_qois_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.Lambda_dim)) self.samples = grad.sample_l1_ball(self.centers, self.Lambda_dim + 1, self.radius) self.num_qois = 28 coeffs = np.zeros((self.Lambda_dim, 2 * self.Lambda_dim)) coeffs = np.append(coeffs, np.random.random( (self.Lambda_dim, self.num_qois - 3 * self.Lambda_dim)), axis=1) self.coeffs = np.append(coeffs, np.eye(self.Lambda_dim), axis=1) self.data = self.samples.dot(self.coeffs) self.G = grad.calculate_gradients_rbf(self.samples, self.data, self.centers) self.inner_prod_tol = 0.9 self.cond_tol = np.inf
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 test_calculate_gradients_rbf(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.output_set = sample.sample_set(self.output_dim) self.cluster_set = grad.sample_l1_ball(self.input_set_centers, self.num_close, 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_rbf(self.cluster_disc, num_centers) # Test the method returns the correct size tensor self.jacobians = self.center_disc._input_sample_set._jacobians 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 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 test_calculate_gradients_rbf_accuracy(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.G_nonlin = grad.calculate_gradients_rbf(self.samples_rbf, self.data_nonlin_rbf, normalize=False) nptest.assert_array_almost_equal(self.G_nonlin - self.G_exact, 0, decimal = 2)
def test_calculate_gradients_rbf_accuracy(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.center_disc = grad.calculate_gradients_rbf(self.cluster_disc_rbf, normalize=False) self.jacobians = self.center_disc._input_sample_set._jacobians nptest.assert_allclose(self.jacobians - self.G_exact, 0, atol=2)
def test_calculate_gradients_rbf_accuracy(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.center_disc = grad.calculate_gradients_rbf(\ self.cluster_disc_rbf, normalize=False) self.jacobians = self.center_disc._input_sample_set._jacobians nptest.assert_allclose(self.jacobians - self.G_exact, 0, atol=2)
def test_calculate_gradients_rbf_accuracy(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.G_nonlin = grad.calculate_gradients_rbf(self.samples_rbf, self.data_nonlin_rbf, normalize=False) nptest.assert_array_almost_equal(self.G_nonlin - self.G_exact, 0, decimal=2)
def setUp(self): self.Lambda_dim = 4 self.num_qois_return = 4 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.Lambda_dim)) self.samples = grad.sample_l1_ball(self.centers, self.Lambda_dim + 1, self.radius) self.num_qois = 20 coeffs = np.random.random((self.Lambda_dim, self.num_qois - self.Lambda_dim)) self.coeffs = np.append(coeffs, np.eye(self.Lambda_dim), axis=1) self.data = self.samples.dot(self.coeffs) self.G = grad.calculate_gradients_rbf(self.samples, self.data, self.centers)
def test_calculate_gradients_rbf(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.samples = grad.sample_l1_ball(self.centers, self.num_close, self.rvec) self.data = self.samples.dot(self.coeffs) self.G = grad.calculate_gradients_rbf(self.samples, self.data, self.centers) # Test the method returns the correct size tensor self.assertEqual(self.G.shape, (self.num_centers, self.num_qois, self.Lambda_dim)) # Test that each vector is normalized or a zero vector normG = np.linalg.norm(self.G, axis=2) # If its a zero vectors, make it the unit vector in Lambda_dim self.G[normG==0] = 1.0/np.sqrt(self.Lambda_dim) nptest.assert_array_almost_equal(np.linalg.norm(self.G, axis=2), np.ones((self.G.shape[0], self.G.shape[1])))
def test_calculate_gradients_rbf(self): """ Test :meth:`bet.sensitivity.gradients.calculate_gradients_rbf`. """ self.samples = grad.sample_l1_ball(self.centers, self.num_close, self.rvec) self.data = self.samples.dot(self.coeffs) self.G = grad.calculate_gradients_rbf(self.samples, self.data, self.centers) # Test the method returns the correct size tensor self.assertEqual(self.G.shape, (self.num_centers, self.num_qois, self.Lambda_dim)) # Test that each vector is normalized or a zero vector normG = np.linalg.norm(self.G, ord=1, axis=2) # If its a zero vectors, make it the unit vector in Lambda_dim self.G[normG == 0] = 1.0 / self.Lambda_dim nptest.assert_array_almost_equal( np.linalg.norm(self.G, ord=1, axis=2), np.ones((self.G.shape[0], self.G.shape[1])))
def setUp(self): self.Lambda_dim = 2 self.num_qois_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.Lambda_dim)) self.samples = grad.sample_l1_ball(self.centers, self.Lambda_dim + 1, self.radius) self.num_qois = 28 coeffs = np.zeros((self.Lambda_dim, 2*self.Lambda_dim)) coeffs = np.append(coeffs, np.random.random((self.Lambda_dim, self.num_qois - 3 * self.Lambda_dim)), axis=1) self.coeffs = np.append(coeffs, np.eye(self.Lambda_dim), axis=1) self.data = self.samples.dot(self.coeffs) self.G = grad.calculate_gradients_rbf(self.samples, self.data, self.centers) self.inner_prod_tol = 0.9 self.cond_tol = sys.float_info[0]
import bet.Comm as comm import scipy.io as sio import numpy as np # Import the data from the FEniCS simulation (RBF or FFD or CFD clusters) matfile = sio.loadmat('heatplate_2d_16clustersRBF_1000qoi.mat') #matfile = sio.loadmat('heatplate_2d_16clustersFFD_1000qoi.mat') #matfile = sio.loadmat('heatplate_2d_16clustersCFD_1000qoi.mat') samples = matfile['samples'] data = matfile['data'] Lambda_dim = samples.shape[1] # Calculate the gradient vectors at each of the 16 centers for each of the # QoI maps G = grad.calculate_gradients_rbf(samples, data) #G = grad.calculate_gradients_ffd(samples, data) #G = grad.calculate_gradients_cfd(samples, data) # With a set of QoIs to consider, we check all possible combinations # of the QoIs and choose the best sets. indexstart = 0 indexstop = 20 qoiIndices = range(indexstart, indexstop) condnum_indices_mat = cQoIs.chooseOptQoIs(G, qoiIndices) qoi1 = condnum_indices_mat[0, 1] qoi2 = condnum_indices_mat[0, 2] if comm.rank == 0: print 'The 10 smallest condition numbers are in the first column, the \ corresponding sets of QoIs are in the following columns.'
Data_dim = 10 num_samples = 1E5 num_centers = 10 # Let the map Q be a random matrix of size (Data_dim, Lambda_dim) np.random.seed(0) Q = np.random.random([Data_dim, Lambda_dim]) # Choose random samples in parameter space to solve the model samples = np.random.random([num_samples, Lambda_dim]) data = Q.dot(samples.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. G = grad.calculate_gradients_rbf(samples, data, centers=samples[:num_centers, :], normalize=True) # With these gradient vectors, we are now ready to choose an optimal set of # QoIs to use in the inverse problem, based on optimal skewness properites of # QoI vectors. The most robust method for this is # :meth:~bet.sensitivity.chooseQoIs.chooseOptQoIs_large which returns the # best set of 2, 3, 4 ... until Lambda_dim. This method returns a list of # matrices. Each matrix has 10 rows, the first column representing the # average condition number of the Jacobian of Q, and the rest of the columns # the corresponding QoI indices. best_sets = cQoI.chooseOptQoIs_large(G, volume=False) ############################################################################### # At this point we have determined the optimal set of QoIs to use in the inverse # problem. Now we compare the support of the inverse solution using
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( cluster_discretization, normalize=False) elif fd_scheme.upper() in ['FFD']: center_discretization = grad.calculate_gradients_ffd( cluster_discretization) else: center_discretization = grad.calculate_gradients_cfd( cluster_discretization) input_samples_centers = center_discretization.get_input_sample_set() # Choose a specific set of QoIs to check the average skewness of index1 = 0 index2 = 4 (specific_skewness, _) = cqoi.calculate_avg_skewness(input_samples_centers, qoi_set=[index1, index2]) if comm.rank == 0:
num_samples = 1E5 num_centers = 10 # Let the map Q be a random matrix of size (Data_dim, Lambda_dim) np.random.seed(0) Q = np.random.random([Data_dim, Lambda_dim]) # Choose random samples in parameter space to solve the model samples = np.random.random([num_samples, Lambda_dim]) data = Q.dot(samples.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. G = grad.calculate_gradients_rbf(samples, data, centers=samples[:num_centers, :], normalize=True) # With these gradient vectors, we are now ready to choose an optimal set of # QoIs to use in the inverse problem, based on minimizing the support of the # inverse solution (volume). The most robust method for this is # :meth:~bet.sensitivity.chooseQoIs.chooseOptQoIs_large which returns the # best set of 2, 3, 4 ... until Lambda_dim. This method returns a list of # matrices. Each matrix has 10 rows, the first column representing the # expected inverse volume ratio, and the rest of the columns the corresponding # QoI indices. best_sets = cQoI.chooseOptQoIs_large(G, volume=True) ############################################################################### # At this point we have determined the optimal set of QoIs to use in the inverse
import bet.Comm as comm import scipy.io as sio import numpy as np # Import the data from the FEniCS simulation (RBF or FFD or CFD clusters) matfile = sio.loadmat('heatplate_2d_16clustersRBF_1000qoi.mat') #matfile = sio.loadmat('heatplate_2d_16clustersFFD_1000qoi.mat') #matfile = sio.loadmat('heatplate_2d_16clustersCFD_1000qoi.mat') samples = matfile['samples'] data = matfile['data'] Lambda_dim = samples.shape[1] # Calculate the gradient vectors at each of the 16 centers for each of the # QoI maps G = grad.calculate_gradients_rbf(samples, data) #G = grad.calculate_gradients_ffd(samples, data) #G = grad.calculate_gradients_cfd(samples, data) # With a set of QoIs to consider, we check all possible combinations # of the QoIs and choose the best sets. indexstart = 0 indexstop = 20 qoiIndices = range(indexstart, indexstop) condnum_indices_mat = cQoIs.chooseOptQoIs(G, qoiIndices) qoi1 = condnum_indices_mat[0, 1] qoi2 = condnum_indices_mat[0, 2] if comm.rank==0: print 'The 10 smallest condition numbers are in the first column, the \ corresponding sets of QoIs are in the following columns.'
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 *False* because we are using bin_size 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 center_discretization = grad.calculate_gradients_rbf(cluster_discretization, num_centers, normalize=False) # With these gradient vectors, we are now ready to choose an optimal set of # QoIs to use in the inverse problem, based on minimizing the support of the # inverse solution (volume). The most robust method for this is # :meth:~bet.sensitivity.chooseQoIs.chooseOptQoIs_large which returns the # best set of 2, 3, 4 ... until input_dim. This method returns a list of # matrices. Each matrix has 10 rows, the first column representing the # expected inverse volume ratio, and the rest of the columns the corresponding # QoI indices. input_samples_center = center_discretization.get_input_sample_set() best_sets = cqoi.chooseOptQoIs_large(input_samples_center, max_qois_return=5, num_optsets_return=2, inner_prod_tol=0.9, measskew_tol=1E2, measure=True) ''' We see here the expected volume ratios are small. This number represents the
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 # determine the uncertainty in our data. cluster_discretization = sample.discretization(input_samples, output_samples) # We will approximate the jacobian at each of the centers center_discretization = grad.calculate_gradients_rbf(cluster_discretization, num_centers, normalize=True) # With these gradient vectors, we are now ready to choose an optimal set of # QoIs to use in the inverse problem, based on optimal skewness properites of # QoI vectors. The most robust method for this is # :meth:~bet.sensitivity.chooseQoIs.chooseOptQoIs_large which returns the # best set of 2, 3, 4 ... until input_dim. This method returns a list of # matrices. Each matrix has 10 rows, the first column representing the # average skewness of the Jacobian of Q, and the rest of the columns # the corresponding QoI indices. input_samples_center = center_discretization.get_input_sample_set() best_sets = cqoi.chooseOptQoIs_large(input_samples_center, measure=False) ###############################################################################