def test_chooseOptQoIs_large(self): """ Test :meth:`bet.sensitivity.chooseQoIs.chooseOptQoIs_large`. """ self.qoiIndices = range(0, self.num_qois) best_sets = cQoIs.chooseOptQoIs_large(self.G, qoiIndices=self.qoiIndices, inner_prod_tol=self.inner_prod_tol, cond_tol=self.cond_tol) # Test that the best_sets have conditiobn number less than the tolerance for Ldim in range(self.Lambda_dim - 1): nptest.assert_array_less(best_sets[Ldim][:, 0], self.cond_tol)
def test_chooseOptQoIs_large(self): """ Test :meth:`bet.sensitivity.chooseQoIs.chooseOptQoIs_large`. """ self.qoiIndices = range(0, self.output_dim) best_sets = cQoIs.chooseOptQoIs_large(self.input_set_centers, qoiIndices=self.qoiIndices, inner_prod_tol=self.inner_prod_tol, measskew_tol=self.measskew_tol) if self.measskew_tol == np.inf: self.measskew_tol = sys.float_info[0] # Test that the best_sets have condition number less than the tolerance for Ldim in range(self.input_dim - 1): inds = best_sets[Ldim][:, 0] != np.inf nptest.assert_array_less(best_sets[Ldim][inds, 0], self.measskew_tol)
def test_chooseOptQoIs_large(self): """ Test :meth:`bet.sensitivity.chooseQoIs.chooseOptQoIs_large`. """ self.qoiIndices = range(0, self.num_qois) best_sets = cQoIs.chooseOptQoIs_large( self.G, qoiIndices=self.qoiIndices, inner_prod_tol=self.inner_prod_tol, cond_tol=self.cond_tol) if self.cond_tol == np.inf: self.cond_tol = sys.float_info[0] # Test that the best_sets have condition number less than the tolerance for Ldim in range(self.Lambda_dim - 1): inds = best_sets[Ldim][:, 0] != np.inf nptest.assert_array_less(best_sets[Ldim][inds, 0], self.cond_tol)
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) ############################################################################### # 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 # different sets of these QoIs. We set Q_ref to correspond to the center of # the parameter space. We choose the set of QoIs to consider. QoI_indices = [3, 4] # choose up to input_dim #QoI_indices = [3, 6] #QoI_indices = [0, 3] #QoI_indices = [3, 5, 6, 8, 9] #QoI_indices = [0, 3, 5, 8, 9] #QoI_indices = [3, 4, 5, 8, 9] #QoI_indices = [2, 3, 5, 6, 9]
# 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 expected volume of the inverse image of a unit hypercube in the data space. With the bin_size definition of the uncertainty in the data, here we expect to see inverse solutions that have a smaller support (expected volume ratio < 1) than the original volume of the hypercube in the data space. This interpretation of the expected volume ratios is only valid for inverting from a data space that has the same dimensions as the paramter space. When inverting into a higher dimensional space, this expected volume ratio is the expected volume of the cross section of the inverse solution. ''' ###############################################################################
# *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 # problem. Now we compare the support of the inverse solution using # different sets of these QoIs. We set Q_ref to correspond to the center of # the parameter space. We choose the set of QoIs to consider. QoI_indices = [3, 6] # choose up to Lambda_dim #QoI_indices = [3, 4] #QoI_indices = [8, 9] #QoI_indices = [3, 5, 6, 8, 9] #QoI_indices = [3, 4, 5, 8, 9] #QoI_indices = [2, 3, 6, 8, 9] #QoI_indices = [3, 5, 6, 7, 8]
# 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) ############################################################################### # 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 # different sets of these QoIs. We set Q_ref to correspond to the center of # the parameter space. We choose the set of QoIs to consider. QoI_indices = [3, 4] # choose up to input_dim #QoI_indices = [3, 6] #QoI_indices = [0, 3] #QoI_indices = [3, 5, 6, 8, 9] #QoI_indices = [0, 3, 5, 8, 9] #QoI_indices = [3, 4, 5, 8, 9] #QoI_indices = [2, 3, 5, 6, 9]
G = grad.calculate_gradients_rbf(samples, data, centers=samples[: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 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, max_qois_return=5, num_optsets_return=2, inner_prod_tol=0.9, cond_tol=1E2, volume=True) ''' We see here the expected volume ratios are small. This number represents the expected volume of the inverse image of a unit hypercube in the data space. With the bin_size definition of the uncertainty in the data, here we expect to see inverse solutions that have a smaller support (expected volume ratio < 1) than the original volume of the hypercube in the data space. This interpretation of the expected volume ratios is only valid for inverting from a data space that has the same dimensions as the paramter space. When inverting into a higher dimensional space, this expected volume ratio is the expected volume of the cross section of the inverse solution. ''' ###############################################################################
# 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 # different sets of these QoIs. We set Q_ref to correspond to the center of # the parameter space. We choose the set of QoIs to consider. QoI_indices = [3, 4] # choose up to Lambda_dim #QoI_indices = [3, 6] #QoI_indices = [0, 3] #QoI_indices = [3, 5, 6, 8, 9] #QoI_indices = [0, 3, 5, 8, 9] #QoI_indices = [3, 4, 5, 8, 9] #QoI_indices = [2, 3, 5, 6, 9]
# 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 expected volume of the inverse image of a unit hypercube in the data space. With the bin_size definition of the uncertainty in the data, here we expect to see inverse solutions that have a smaller support (expected volume ratio < 1) than the original volume of the hypercube in the data space. This interpretation of the expected volume ratios is only valid for inverting from a data space that has the same dimensions as the parameter space. When inverting into a higher dimensional space, this expected volume ratio is the expected volume of the cross section of the inverse solution. ''' ###############################################################################
# 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 # problem. Now we compare the support of the inverse solution using # different sets of these QoIs. We set Q_ref to correspond to the center of # the parameter space. We choose the set of QoIs to consider. QoI_indices = [3, 6] # choose up to Lambda_dim #QoI_indices = [3, 4] #QoI_indices = [8, 9] #QoI_indices = [3, 5, 6, 8, 9] #QoI_indices = [3, 4, 5, 8, 9] #QoI_indices = [2, 3, 6, 8, 9] #QoI_indices = [3, 5, 6, 7, 8]
# 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. G = grad.calculate_gradients_rbf(samples, data, centers=samples[: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 Lambda_dim. This method returns a list of # matrices. Each matrix has 2 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, max_qois_return=5, num_optsets_return=2, inner_prod_tol=0.9, cond_tol=1E2, volume=True) ''' We see here the expected volume ratios are small. This number represents the expected volume of the inverse image of a unit hypercube in the data space. With the bin_size definition of the uncertainty in the data, here we expect to see inverse solutions that have a smaller support (expected volume ratio < 1) than the original volume of the hypercube in the data space. This interpretation of the expected volume ratios is only valid for inverting from a data space that has the same dimensions as the paramter space. When inverting into a higher dimensional space, this expected volume ratio is the expected volume of the cross section of the inverse solution. ''' ###############################################################################