def set_comparison_sample_set(self, comparison_sample_set): r""" Sets the comparison sample set for this comparison. :param comparison_sample_set: comparison sample set :type comparison_sample_set: :class:`~bet.sample.sample_set_base` """ if isinstance(comparison_sample_set, samp.sample_set_base): output_dims = [] output_dims.append(comparison_sample_set.get_dim()) if self._right_sample_set is not None: output_dims.append(self._right_sample_set.get_dim()) if self._left_sample_set is not None: output_dims.append(self._left_sample_set.get_dim()) if len(output_dims) == 1: self._comparison_sample_set = comparison_sample_set elif np.all(np.array(output_dims) == output_dims[0]): self._comparison_sample_set = comparison_sample_set else: raise samp.dim_not_matching("dimension of values incorrect") else: raise AttributeError( "Wrong Type: Should be samp.sample_set_base type") # if a new emulation set is provided, forget the comparison evaluation. if self._left_sample_set is not None: self._left_sample_set._comparison_densities = None if self._right_sample_set is not None: self._right_sample_set._comparison_densities = None
def check_dim(self): r""" Checks that dimensions of left and right sample sets match the dimension of the comparison sample set. :rtype: int :returns: dimension """ left_set = self.get_left() right_set = self.get_right() if left_set.get_dim() != right_set.get_dim(): msg = "These sample sets must have the same dimension." raise samp.dim_not_matching(msg) else: dim = left_set.get_dim() il, ir = self.get_ptr_left(), self.get_ptr_right() if (il is not None) and (ir is not None): if len(il) != len(ir): msg = "The pointers have inconsistent sizes." msg += "\nTry running set_ptr_left() [or _right()]" raise samp.dim_not_matching(msg) return dim
def prob_from_discretization_input(disc, set_new): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` where :math:`\lambda_{samples_old}` come from an input discretization. :param disc: Discretiztion on which probabilities have already been calculated :type disc: :class:`~bet.sample.discretization` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` """ if disc._emulated_input_sample_set is None: logging.warning("Using MC assumption because no emulated points given") em_set = disc._input_sample_set else: em_set = disc._emulated_input_sample_set if em_set._values_local is None: em_set.global_to_local() if em_set._probabilities_local is None: raise AttributeError("Probabilities must be pre-calculated.") # Check dimensions disc.check_nums() num_new = set_new.check_num() if (disc._input_sample_set._dim != set_new._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") (_, ptr) = set_new.query(em_set._values_local) ptr = ptr.flat[:] # Set up probability vectors prob_new = np.zeros((num_new, )) prob_em = em_set._probabilities_local for i in range(num_new): Itemp = np.equal(ptr, i) Itemp_sum = np.sum(prob_em[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new
def prob_from_discretization_input(disc, set_new): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` where :math:`\lambda_{samples_old}` come from an input discretization. :param disc: Discretiztion on which probabilities have already been calculated :type disc: :class:`~bet.sample.discretization` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` """ if disc._emulated_input_sample_set is None: logging.warning("Using MC assumption because no emulated points given") em_set = disc._input_sample_set else: em_set = disc._emulated_input_sample_set if em_set._values_local is None: em_set.global_to_local() if em_set._probabilities_local is None: raise AttributeError("Probabilities must be pre-calculated.") # Check dimensions disc.check_nums() num_new = set_new.check_num() if (disc._input_sample_set._dim != set_new._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") (_, ptr) = set_new.query(em_set._values_local) ptr = ptr.flat[:] # Set up probability vectors prob_new = np.zeros((num_new,)) prob_em = em_set._probabilities_local for i in range(num_new): Itemp = np.equal(ptr, i) Itemp_sum = np.sum(prob_em[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new
def prob_from_sample_set(set_old, set_new): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` using the MC assumption with respect to set_old. :param set_old: Sample set on which probabilities have already been calculated :type set_old: :class:`~bet.sample.sample_set_base` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` """ # Check dimensions set_old.check_num() num_new = set_new.check_num() if (set_old._dim != set_new._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") # Map old points new sets if set_old._values_local is None: set_old.global_to_local() (_, ptr) = set_new.query(set_old._values_local) ptr = ptr.flat[:] # Set up probability vector prob_new = np.zeros((num_new, )) # Loop over new cells and distribute probability from old for i in range(num_new): Itemp = np.equal(ptr, i) Itemp_sum = np.sum(set_old._probabilities_local[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new
def prob_from_sample_set(set_old, set_new): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` using the MC assumption with respect to set_old. :param set_old: Sample set on which probabilities have already been calculated :type set_old: :class:`~bet.sample.sample_set_base` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` """ # Check dimensions set_old.check_num() num_new = set_new.check_num() if (set_old._dim != set_new._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") # Map old points new sets if set_old._values_local is None: set_old.global_to_local() (_, ptr) = set_new.query(set_old._values_local) ptr = ptr.flat[:] # Set up probability vector prob_new = np.zeros((num_new,)) # Loop over new cells and distribute probability from old for i in range(num_new): Itemp = np.equal(ptr, i) Itemp_sum = np.sum(set_old._probabilities_local[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new
def check_type(val, data_set=None): """ Add support for different data types that can be passed as keyword arguments. Attempt to infer dimension and set it correctly. """ if isinstance(data_set, samp.discretization): dim = data_set._output_sample_set.get_dim() elif isinstance(data_set, samp.sample_set_base): dim = data_set.get_dim() else: dim = 1 if isinstance(val, float) or isinstance(val, int): val = np.array([val]*dim) elif isinstance(val, list) or isinstance(val, tuple): if len(val) != dim: raise samp.dim_not_matching("Dimension mismatch.") else: val = np.array(val) elif not isinstance(val, collections.Iterable): val = np.array([val]) else: pass return val
def check_type(val, data_set=None): """ Add support for different data types that can be passed as keyword arguments. Attempt to infer dimension and set it correctly. """ if isinstance(data_set, samp.discretization): dim = data_set._output_sample_set.get_dim() elif isinstance(data_set, samp.sample_set_base): dim = data_set.get_dim() else: dim = 1 if isinstance(val, float) or isinstance(val, int): val = np.array([val] * dim) elif isinstance(val, list) or isinstance(val, tuple): if len(val) != dim: raise samp.dim_not_matching("Dimension mismatch.") else: val = np.array(val) elif not isinstance(val, collections.Iterable): val = np.array([val]) else: pass return val
def generate_for_input_set(self, input_sample_set, order=0): """ Generates a surrogate discretization based on the input discretization, for a user-defined input sample set. The output sample set values and error estimates are piecewise polynomially defined over input sample set cells from the input discretization. For order 0, both are piecewise constant. For order 1, values are piecewise linear (assuming Jacobians exist), and error estimates are piecewise constant. :param input_sample_set: input sample set for surrogate discretization :type set_old: :class:`~bet.sample.sample_set_base` :param order: Polynomial order :type order: int :rtype: :class:`~bet.sample.discretization` :returns: discretization defining the surrogate model """ # Check inputs if order not in [0, 1]: msg = "Order must be 0 or 1." raise calculateError.wrong_argument_type(msg) input_sample_set.check_num() if input_sample_set._dim != self.input_disc._input_sample_set._dim: msg = "Dimensions of input sets are not equal." raise sample.dim_not_matching(msg) # Give properties from input discretization. if input_sample_set._domain is None: if self.input_disc._input_sample_set._domain is not None: input_sample_set.set_domain(self.input_disc.\ _input_sample_set._domain) if input_sample_set._p_norm is None: if self.input_disc._input_sample_set._p_norm is not None: input_sample_set.set_p_norm(self.input_disc.\ _input_sample_set._p_norm) # Setup dummy discretizion to get pointers # Assumes Voronoi sample set for now output_sample_set = sample.sample_set(self.input_disc.\ _output_sample_set._dim) self.dummy_disc = self.input_disc.copy() self.dummy_disc.set_emulated_input_sample_set(input_sample_set) self.dummy_disc.set_emulated_ii_ptr(globalize=False) if order == 0: # define new values based on piecewise constants new_values_local = self.input_disc._output_sample_set.\ _values[self.dummy_disc._emulated_ii_ptr_local] output_sample_set.set_values_local(new_values_local) elif order == 1: # define new values based on piecewise linears using Jacobians if self.input_disc._input_sample_set._jacobians is None: if self.input_disc._input_sample_set._jacobians_local is None: msg = "The input discretization must" msg += " have jacobians defined." raise calculateError.wrong_argument_type(msg) else: self.input_disc._input_sample_set.local_to_global() jac_local = self.input_disc._input_sample_set._jacobians[\ self.dummy_disc._emulated_ii_ptr_local] diff_local = self.input_disc._input_sample_set._values[\ self.dummy_disc._emulated_ii_ptr_local] - \ input_sample_set._values_local new_values_local = self.input_disc._output_sample_set._values[\ self.dummy_disc._emulated_ii_ptr_local] new_values_local += np.einsum('ijk,ik->ij', jac_local, diff_local) output_sample_set.set_values_local(new_values_local) # if they exist, define error estimates with piecewise constants if self.input_disc._output_sample_set._error_estimates is not None: new_ee = self.input_disc._output_sample_set._error_estimates[\ self.dummy_disc._emulated_ii_ptr_local] output_sample_set.set_error_estimates_local(new_ee) # create discretization object for the surrogate self.surrogate_discretization = sample.discretization(input_sample_set\ =input_sample_set, output_sample_set=output_sample_set, output_probability_set=self.input_disc._output_probability_set) return self.surrogate_discretization
def prob_from_sample_set_with_emulated_volumes(set_old, set_new, set_emulate=None): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` using a set of emulated points are distributed with respect to the volume measure. :param set_old: Sample set on which probabilities have already been calculated :type set_old: :class:`~bet.sample.sample_set_base` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` :param set_emulate: Sample set for volume emulation :type set_emulate: :class:`~bet.sample.sample_set_base` """ if set_emulate is None: logging.warning("Using MC assumption because no emulated points given") return prob_from_sample_set(set_old, set_new) # Check dimensions num_old = set_old.check_num() num_new = set_new.check_num() set_emulate.check_num() if (set_old._dim != set_new._dim) or (set_old._dim != set_emulate._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") # Localize emulated points if set_emulate._values_local is None: set_emulate.global_to_local() # Map emulated points to old and new sets (_, ptr1) = set_old.query(set_emulate._values_local) (_, ptr2) = set_new.query(set_emulate._values_local) ptr1 = ptr1.flat[:] ptr2 = ptr2.flat[:] # Set up probability vectors prob_new = np.zeros((num_new, )) prob_em = np.zeros((len(ptr1), )) # Loop over old cells and divide probability over emulated cells warn = False for i in range(num_old): if set_old._probabilities[i] > 0.0: Itemp = np.equal(ptr1, i) Itemp_sum = np.sum(Itemp) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) if Itemp_sum > 0: prob_em[Itemp] += set_old._probabilities[i] / float(Itemp_sum) else: warn = True # Warn that some cells have no emulated points in them if warn: msg = "Some old cells have no emulated points in them. " msg += "Renormalizing probability." logging.warning(msg) total_prob = np.sum(prob_em) total_prob = comm.allreduce(total_prob, op=MPI.SUM) prob_em = prob_em / total_prob # Loop over new cells and distribute probability from emulated cells for i in range(num_new): Itemp = np.equal(ptr2, i) Itemp_sum = np.sum(prob_em[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new
def __init__(self, comparison_sample_set, sample_set_left=None, sample_set_right=None, ptr_left=None, ptr_right=None): #: Left sample set self._left_sample_set = None #: Right sample set self._right_sample_set = None #: Integration/Emulation set :class:`~bet.sample.sample_set_base` self._comparison_sample_set = comparison_sample_set #: Pointer from ``self._comparison_sample_set`` to #: ``self._left_sample_set`` self._ptr_left = ptr_left #: Pointer from ``self._comparison_sample_set`` to #: ``self._right_sample_set`` self._ptr_right = ptr_right #: local integration left ptr for parallelsim self._ptr_left_local = None #: local integration right ptr for parallelism self._ptr_right_local = None #: Domain self._domain = None #: Left sample set density evaluated on emulation set. self._den_left = None #: Right sample set density evaluated on emulation set. self._den_right = None # extract sample set if isinstance(sample_set_left, samp.sample_set_base): # left sample set self._left_sample_set = sample_set_left self._domain = sample_set_left.get_domain() if isinstance(sample_set_right, samp.sample_set_base): # right sample set self._right_sample_set = sample_set_right if self._domain is not None: if not np.allclose(self._domain, sample_set_right._domain): raise samp.domain_not_matching( "Left and Right domains do not match") else: self._domain = sample_set_right.get_domain() # check dimension consistency if isinstance(comparison_sample_set, samp.sample_set_base): self._num_samples = comparison_sample_set.check_num() output_dims = [] output_dims.append(comparison_sample_set.get_dim()) if self._right_sample_set is not None: output_dims.append(self._right_sample_set.get_dim()) if self._left_sample_set is not None: output_dims.append(self._left_sample_set.get_dim()) if len(output_dims) == 1: self._comparison_sample_set = comparison_sample_set elif np.all(np.array(output_dims) == output_dims[0]): self._comparison_sample_set = comparison_sample_set else: raise samp.dim_not_matching("Dimension of values incorrect") if not isinstance(comparison_sample_set.get_domain(), np.ndarray): # domain can be missing if left/right sample sets present if self._left_sample_set is not None: comparison_sample_set.set_domain(self._domain) else: if self._right_sample_set is not None: comparison_sample_set.set_domain(self._domain) else: # no sample sets provided msg = "Must provide at least one set from\n" msg += "\twhich a domain can be inferred." raise AttributeError(msg) else: if (self._left_sample_set is not None) or \ (self._right_sample_set is not None): pass else: raise AttributeError( "Wrong Type: Should be samp.sample_set_base type") if (ptr_left is not None): if len(ptr_left) != self._num_samples: raise AttributeError( "Left pointer length must match comparison set.") if (ptr_right is not None): if not np.allclose(ptr_left.shape, ptr_right.shape): raise AttributeError("Pointers must be of same length.") if (ptr_right is not None): if len(ptr_right) != self._num_samples: raise AttributeError( "Right pointer length must match comparison set.")
def prob_from_sample_set_with_emulated_volumes(set_old, set_new, set_emulate=None): r""" Calculates :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_new}})` from :math:`P_{\Lambda}(\mathcal{V}_{\lambda_{samples_old}})` using a set of emulated points are distributed with respect to the volume measure. :param set_old: Sample set on which probabilities have already been calculated :type set_old: :class:`~bet.sample.sample_set_base` :param set_new: Sample set for which probabilities will be calculated. :type set_new: :class:`~bet.sample.sample_set_base` :param set_emulate: Sample set for volume emulation :type set_emulate: :class:`~bet.sample.sample_set_base` """ if set_emulate is None: logging.warning("Using MC assumption because no emulated points given") return prob_from_sample_set(set_old, set_new) # Check dimensions num_old = set_old.check_num() num_new = set_new.check_num() set_emulate.check_num() if (set_old._dim != set_new._dim) or (set_old._dim != set_emulate._dim): raise samp.dim_not_matching("Dimensions of sets are not equal.") # Localize emulated points if set_emulate._values_local is None: set_emulate.global_to_local() # Map emulated points to old and new sets (_, ptr1) = set_old.query(set_emulate._values_local) (_, ptr2) = set_new.query(set_emulate._values_local) ptr1 = ptr1.flat[:] ptr2 = ptr2.flat[:] # Set up probability vectors prob_new = np.zeros((num_new,)) prob_em = np.zeros((len(ptr1), )) # Loop over old cells and divide probability over emulated cells warn = False for i in range(num_old): if set_old._probabilities[i] > 0.0: Itemp = np.equal(ptr1, i) Itemp_sum = np.sum(Itemp) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) if Itemp_sum > 0: prob_em[Itemp] += set_old._probabilities[i]/float(Itemp_sum) else: warn = True # Warn that some cells have no emulated points in them if warn: msg = "Some old cells have no emulated points in them. " msg += "Renormalizing probability." logging.warning(msg) total_prob = np.sum(prob_em) total_prob = comm.allreduce(total_prob, op=MPI.SUM) prob_em = prob_em/total_prob # Loop over new cells and distribute probability from emulated cells for i in range(num_new): Itemp = np.equal(ptr2, i) Itemp_sum = np.sum(prob_em[Itemp]) Itemp_sum = comm.allreduce(Itemp_sum, op=MPI.SUM) prob_new[i] = Itemp_sum # Set probabilities set_new.set_probabilities(prob_new) return prob_new