Saturated Coverage¶
Saturated coverage functions.
The general form of a sum redundancy function is
where \(f\) indicates the function, \(X\) is a subset, \(Y\) is the ground set, and \(\phi\) is the similarity measure between two examples. Like most graphbased functons, the facility location function requires access to the full ground set.
API Reference¶
This code implements saturated coverage functions.

class
apricot.functions.saturatedCoverage.
SaturatedCoverageSelection
(n_samples=10, metric='euclidean', alpha=0.1, initial_subset=None, optimizer='twostage', n_neighbors=None, n_jobs=1, random_state=None, optimizer_kwds={}, verbose=False)[source]¶ A saturated coverage submodular selection algorithm.
NOTE: All ~pairwise~ values in your data must be positive for this selection to work.
This function uses a saturated coverage based submodular selection algorithm to identify a representative subset of the data. This function works on pairwise measures between each of the samples. These measures can be the correlation, a dot product, or any other such function where a higher value corresponds to a higher similarity and a lower value corresponds to a lower similarity.
This implementation allows users to pass in either their own symmetric square matrix of similarity values, or a data matrix as normal and a function that calculates these pairwise values.
Parameters:  n_samples : int
The number of samples to return.
 metric : str, optional
The method for converting a data matrix into a square symmetric matrix of pairwise similarities. If a string, can be any of the metrics implemented in sklearn (see https://scikitlearn.org/stable/modules/ generated/sklearn.metrics.pairwise_distances.html), including “precomputed” if one has already generated a similarity matrix. Note that sklearn calculates distance matrices whereas apricot operates on similarity matrices, and so a distances.max()  distances transformation is performed on the resulting distances. For backcompatibility, ‘corr’ will be read as ‘correlation’. Default is ‘euclidean’.
 n_naive_samples : int, optional
The number of samples to perform the naive greedy algorithm on before switching to the lazy greedy algorithm. The lazy greedy algorithm is faster once features begin to saturate, but is slower in the initial few selections. This is, in part, because the naive greedy algorithm is parallelized whereas the lazy greedy algorithm currently is not. Default is 1.
 initial_subset : list, numpy.ndarray or None, optional
If provided, this should be a list of indices into the data matrix to use as the initial subset, or a group of examples that may not be in the provided data should beused as the initial subset. If indices, the provided array should be onedimensional. If a group of examples, the data should be 2 dimensional. Default is None.
 optimizer : string or optimizers.BaseOptimizer, optional
The optimization approach to use for the selection. Default is ‘twostage’, which makes selections using the naive greedy algorithm initially and then switches to the lazy greedy algorithm. Must be one of
‘naive’ : the naive greedy algorithm ‘lazy’ : the lazy (or accelerated) greedy algorithm ‘approximatelazy’ : the approximate lazy greedy algorithm ‘twostage’ : starts with naive and switches to lazy ‘stochastic’ : the stochastic greedy algorithm ‘greedi’ : the GreeDi distributed algorithm ‘bidirectional’ : the bidirectional greedy algorithm
Default is ‘naive’.
 random_state : int or RandomState or None, optional
The random seed to use for the random selection process. Only used for stochastic greedy.
 verbose : bool
Whether to print output during the selection process.
Attributes:  n_samples : int
The number of samples to select.
 pairwise_func : callable
A function that takes in a data matrix and converts it to a square symmetric matrix.
 ranking : numpy.array int
The selected samples in the order of their gain.
 gains : numpy.array float
The gain of each sample in the returned set when it was added to the growing subset. The first number corresponds to the gain of the first added sample, the second corresponds to the gain of the second added sample, and so forth.

fit
(self, X, y=None, sample_weight=None, sample_cost=None)[source]¶ Run submodular optimization to select the examples.
This method is a wrapper for the full submodular optimization process. It takes in some data set (and optionally labels that are ignored during this process) and selects n_samples from it in the greedy manner specified by the optimizer.
This method will return the selector object itself, not the transformed data set. The transform method will then transform a data set to the selected points, or alternatively one can use the ranking stored in the self.ranking attribute. The fit_transform method will perform both optimization and selection and return the selected items.
Parameters:  X : list or numpy.ndarray, shape=(n, d)
The data set to transform. Must be numeric.
 y : list or numpy.ndarray or None, shape=(n,), optional
The labels to transform. If passed in this function will return both the data and th corresponding labels for the rows that have been selected.
 sample_weight : list or numpy.ndarray or None, shape=(n,), optional
The weight of each example. Currently ignored in apricot but included to maintain compatibility with sklearn pipelines.
 sample_cost : list or numpy.ndarray or None, shape=(n,), optional
The cost of each item. If set, indicates that optimization should be performed with respect to a knapsack constraint.
Returns:  self : SaturatedCoverageSelection
The fit step returns this selector object.

fit_transform
(self, X, y=None, sample_weight=None, sample_cost=None)¶ Run optimization and select a subset of examples.
This method will first perform the fit step and then perform the transform step, returning a transformed data set.
Parameters:  X : list or numpy.ndarray, shape=(n, d)
The data set to transform. Must be numeric.
 y : list or numpy.ndarray or None, shape=(n,), optional
The labels to transform. If passed in this function will return both the data and the corresponding labels for the rows that have been selected. Default is None.
 sample_weight : list or numpy.ndarray or None, shape=(n,), optional
The sample weights to transform. If passed in this function will return the selected labels (y) and the selected samples, even if no labels were passed in. Default is None.
 sample_cost : list or numpy.ndarray or None, shape=(n,), optional
The cost of each item. If set, indicates that optimization should be performed with respect to a knapsack constraint.
Returns:  X_subset : numpy.ndarray, shape=(n_samples, d)
A subset of the data such that n_samples < n and n_samples is the integer provided at initialization.
 y_subset : numpy.ndarray, shape=(n_samples,), optional
The labels that match with the indices of the samples if y is passed in. Only returned if passed in.
 sample_weight_subset : numpy.ndarray, shape=(n_samples,), optional
The weight of each example.

transform
(self, X, y=None, sample_weight=None)¶ Transform a data set to include only the selected examples.
This method will return a selection of X and optionally selections of y and sample_weight. The default setting is to select items based on the ranking determined in the fit step with examples in the same order as that ranking. Optionally, the whole data set can be returned, with the weights corresponding to samples that were not selected set to 0. This setting can be controlled by setting pipeline=True.
Parameters:  X : list or numpy.ndarray, shape=(n, d)
The data set to transform. Must be numeric.
 y : list or numpy.ndarray or None, shape=(n,), optional
The labels to transform. If passed in this function will return both the data and the corresponding labels for the rows that have been selected. Default is None.
 sample_weight : list or numpy.ndarray or None, shape=(n,), optional
The sample weights to transform. If passed in this function will return the selected labels (y) and the selected samples, even if no labels were passed in. Default is None.
Returns:  X_subset : numpy.ndarray, shape=(n_samples, d)
A subset of the data such that n_samples < n and n_samples is the integer provided at initialization.
 y_subset : numpy.ndarray, shape=(n_samples,), optional
The labels that match with the indices of the samples if y is passed in. Only returned if passed in.
 sample_weight_subset : numpy.ndarray, shape=(n_samples,), optional
The weight of each example.