ACCACC.CLIPPINGACC.METHODSACC.NORMALIZATIONSACC.SOLVERSACC.aggregate()ACC.aggregation_fit()HellingerDistance()TopsoeDistance()adjusted_quantification()argmin_prevalence()as_binary_prevalence()check_prevalence_vector()clip_prevalence()clip()condsoftmax()counts_from_labels()get_divergence()get_nprevpoints_approximation()l1_norm()linear_search()map_onto_probability_simplex()normalize_prevalence()num_prevalence_combinations()optim_minimize()prevalence_from_labels()prevalence_from_probabilities()prevalence_linspace()projection_simplex_sort()softmax()solve_adjustment()solve_adjustment_binary()strprev()ternary_search()uniform_prevalence_sampling()uniform_simplex_sampling()HellingerDistance()TopsoeDistance()adjusted_quantification()argmin_prevalence()as_binary_prevalence()check_prevalence_vector()clip_prevalence()clip()condsoftmax()counts_from_labels()get_divergence()get_nprevpoints_approximation()l1_norm()linear_search()map_onto_probability_simplex()normalize_prevalence()num_prevalence_combinations()optim_minimize()prevalence_from_labels()prevalence_from_probabilities()prevalence_linspace()projection_simplex_sort()softmax()solve_adjustment()solve_adjustment_binary()strprev()ternary_search()uniform_prevalence_sampling()uniform_simplex_sampling()HellingerDistance()TopsoeDistance()adjusted_quantification()argmin_prevalence()as_binary_prevalence()check_prevalence_vector()clip_prevalence()clip()condsoftmax()counts_from_labels()get_divergence()get_nprevpoints_approximation()l1_norm()linear_search()map_onto_probability_simplex()normalize_prevalence()num_prevalence_combinations()optim_minimize()prevalence_from_labels()prevalence_from_probabilities()prevalence_linspace()projection_simplex_sort()softmax()solve_adjustment()solve_adjustment_binary()strprev()ternary_search()uniform_prevalence_sampling()uniform_simplex_sampling()ACCACC.CLIPPINGACC.METHODSACC.NORMALIZATIONSACC.SOLVERSACC.aggregate()ACC.aggregation_fit()Implements the adjustment of ACC and PACC for the binary case. The adjustment for a prevalence estimate of the -positive class p comes down to computing:
-prevalence_estim – float, the estimated value for the positive class
tpr – float, the true positive rate of the classifier
fpr – float, the false positive rate of the classifier
clip – set to True (default) to clip values that might exceed the range [0,1]
float, the adjusted count
-Helper that, given a float representing the prevalence for the positive class, returns a np.ndarray of two values representing a binary distribution.
positive_prevalence – prevalence for the positive class
clip_if_necessary – if True, clips the value in [0,1] in order to guarantee the resulting distribution +
positive_prevalence – float or array-like of floats with the prevalence for the positive class
clip_if_necessary (bool) – if True, clips the value in [0,1] in order to guarantee the resulting distribution is valid. If False, it then checks that the value is in the valid range, and raises an error if not.
Checks that p is a valid prevalence vector, i.e., that it contains values in [0,1] and that the values sum up to 1.
-prevalences – the prevalence vector to check
-True if p is valid, False otherwise
-Clips the proportions vector prevalences so that it is a valid probability distribution, i.e., all values -are in [0,1] and sum up to 1.
+quapy.functional.check_prevalence_vector(prevalences: Union[_SupportsArray[dtype], _NestedSequence[_SupportsArray[dtype]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]], raise_exception: bool = False, tolerance: float = 1e-08, aggr=True)[source] +Checks that prevalences is a valid prevalence vector, i.e., it contains values in [0,1] and +the values sum up to 1. In other words, verifies that the prevalences vectors lies in the +probability simplex.
prevalences – array-like, the proportions vector to be clipped, shape (n_classes,)
method – indicates the method to be used for normalization. -If None or “none”, no normalization is performed. -If “clip”, the values are clipped to the range [0,1] and normalized, so they sum up to 1. -If “project”, the values are projected onto the probability simplex.
prevalences (ArrayLike) – the prevalence vector, or vectors, to check
raise_exception (bool) – whether to raise an exception if the vector (or any of the vectors) does +not lie in the simplex (default False)
tolerance (float) – error tolerance for the check sum(prevalences) - 1 = 0
aggr (bool) – if True (default) returns one single bool (True if all prevalence vectors are valid, +False otherwise), if False returns an array of bool, one for each prevalence vector
the normalized prevalence vector, shape (n_classes,)
+a single bool True if prevalences is a vector of prevalence values that lies on the simplex, +or False otherwise; alternatively, if prevalences is a matrix of shape (num_vectors, n_classes,) +then it returns one such bool for each prevalence vector
Clips the values in [0,1] and then applies the L1 normalization.
+prevalences – array-like of shape (n_classes,) or of shape (n_samples, n_classes,) with prevalence values
+np.ndarray representing a valid distribution
+Computes the count values from a vector of labels.
+quapy.functional.counts_from_labels(labels: Union[_SupportsArray[dtype], _NestedSequence[_SupportsArray[dtype]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]], classes: Union[_SupportsArray[dtype], _NestedSequence[_SupportsArray[dtype]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]]) ndarray[source] +Computes the raw count values from a vector of labels.
an ndarray of shape (len(classes),) with the occurrence counts of each class
+ndarray of shape (len(classes),) with the raw counts for each class, in the same order +as they appear in classes
Searches for the largest number of (equidistant) prevalence points to define for each of the n_classes classes so that the number of valid prevalence values generated as combinations of prevalence points (points in a n_classes-dimensional simplex) do not exceed combinations_budget.
combinations_budget – integer, maximum number of combinations allowed
n_classes – integer, number of classes
n_repeats – integer, number of repetitions for each prevalence combination
combinations_budget (int) – maximum number of combinations allowed
n_classes (int) – number of classes
n_repeats (int) – number of repetitions for each prevalence combination
Applies L1 normalization to the unnormalized_arr so that it becomes a valid prevalence +vector. Zero vectors are mapped onto the uniform distribution. Raises an exception if +the resulting vectors are not valid distributions. This may happen when the original +prevalence vectors contain negative values. Use the clip normalization function +instead to avoid this possibility.
+prevalences – array-like of shape (n_classes,) or of shape (n_samples, n_classes,) with prevalence values
+np.ndarray representing a valid distribution
+Projects a point onto the probability simplex.
-The code is adapted from Mathieu Blondel’s BSD-licensed -implementation -which is accompanying the paper
-Mathieu Blondel, Akinori Fujino, and Naonori Ueda. -Large-scale Multiclass Support Vector Machine Training via Euclidean Projection onto the Simplex, -ICPR 2014, URL
-unnormalized_arr – point in n-dimensional space, shape (n,)
-projection of v onto (n-1)-dimensional probability simplex, shape (n,)
-Normalize a vector or matrix of prevalence values. The normalization consists of applying a L1 normalization in +quapy.functional.normalize_prevalence(prevalences: Union[_SupportsArray[dtype], _NestedSequence[_SupportsArray[dtype]], bool, int, float, complex, str, bytes, _NestedSequence[Union[bool, int, float, complex, str, bytes]]], method='l1')[source] +
Normalizes a vector or matrix of prevalence values. The normalization consists of applying a L1 normalization in cases in which the prevalence values are not all-zeros, and to convert the prevalence values into 1/n_classes in cases in which all values are zero.
prevalences – array-like of shape (n_classes,) or of shape (n_samples, n_classes,) with prevalence values
+prevalences – array-like of shape (n_classes,) or of shape (n_samples, n_classes,) with prevalence values
method (str) –
indicates the normalization method to employ, options are:
+l1: applies L1 normalization (default); a 0 vector is mapped onto the uniform prevalence
clip: clip values in [0,1] and then rescales so that the L1 norm is 1
mapsimplex: projects vectors onto the probability simplex. This implementation relies on +Mathieu Blondel’s projection_simplex_sort
softmax: applies softmax to all vectors
condsoftmax: applies softmax only to invalid prevalence vectors
a normalized vector or matrix of prevalence values
@@ -1656,7 +1658,7 @@ cases in which all values are zero.Computes the number of valid prevalence combinations in the n_classes-dimensional simplex if n_prevpoints equally distant prevalence values are generated and n_repeats repetitions are requested. The computation comes down to calculating:
@@ -1668,14 +1670,15 @@ classes, and r is n_repeats. This solution comes fromn_classes – integer, number of classes
n_prevpoints – integer, number of prevalence points.
n_repeats – integer, number of repetitions for each prevalence combination
n_classes (int) – number of classes
n_prevpoints (int) – number of prevalence points.
n_repeats (int) – number of repetitions for each prevalence combination
The number of possible combinations. For example, if n_classes=2, n_prevpoints=5, n_repeats=1, then the -number of possible combinations are 5, i.e.: [0,1], [0.25,0.75], [0.50,0.50], [0.75,0.25], and [1.0,0.0]
+The number of possible combinations. For example, if `n_classes`=2, `n_prevpoints`=5, `n_repeats`=1, +then the number of possible combinations are 5, i.e.: [0,1], [0.25,0.75], [0.50,0.50], [0.75,0.25], +and [1.0,0.0]
an ndarray of shape (len(classes)) with the class prevalence values
+ndarray of shape (len(classes),) with the class proportions for each class, in the same order +as they appear in classes
Produces an array of uniformly separated values of prevalence. By default, produces an array of 21 prevalence values, with step 0.05 and with the limits smoothed, i.e.: @@ -1756,31 +1760,73 @@ step 0.05 and with the limits smoothed, i.e.:
Projects a point onto the probability simplex.
+The code is adapted from Mathieu Blondel’s BSD-licensed +implementation +(see function projection_simplex_sort in their repo) which is accompanying the paper
+Mathieu Blondel, Akinori Fujino, and Naonori Ueda. +Large-scale Multiclass Support Vector Machine Training via Euclidean Projection onto the Simplex, +ICPR 2014, URL
+unnormalized_arr – point in n-dimensional space, shape (n,)
+projection of unnormalized_arr onto the (n-1)-dimensional probability simplex, shape (n,)
+Applies the softmax function to all vectors even if the original vectors were valid distributions. +If you want to leave valid vectors untouched, use condsoftmax instead.
+prevalences – array-like of shape (n_classes,) or of shape (n_samples, n_classes,) with prevalence values
+np.ndarray representing a valid distribution
+Function that tries to solve for the equation \(P(C)=P(C|Y)P(Y)\), where \(P(C)\) is the vector of -prevalence values obtained by a classify and count, and \(P(C|Y)\) are the class-conditional misclassification -rates of the classifier.
+quapy.functional.solve_adjustment(class_conditional_rates: ndarray, unadjusted_counts: ndarray, method: Literal['inversion', 'invariant-ratio'], solver: Literal['exact', 'minimize', 'exact-raise', 'exact-cc']) ndarray[source] +Function that tries to solve for \(p\) the equation \(q = M p\), where \(q\) is the vector of +unadjusted counts (as estimated, e.g., via classify and count) with \(q_i\) an estimate of +\(P(\hat{Y}=y_i)\), and where \(M\) is the matrix of class-conditional rates with \(M_{ij}\) an +estimate of \(P(\hat{Y}=y_i|Y=y_j)\).
p_c_cond_y – array of shape (n_classes, n_classes,) with entry (c,y) being the estimate -of \(P(C=c|Y=y)\), that is, the probability that an instance that belongs to class \(y\) -ends up being classified as belonging to class \(c\)
p_c – array of shape (n_classes,) containing the prevalence values as estimated by classify and count
class_conditional_rates – array of shape (n_classes, n_classes,) with entry (i,j) being the estimate +of \(P(\hat{Y}=y_i|Y=y_j)\), that is, the probability that an instance that belongs to class \(y_j\) +ends up being classified as belonging to class \(y_i\)
unadjusted_counts – array of shape (n_classes,) containing the unadjusted prevalence values (e.g., as +estimated by CC or PCC)
method (str) –
indicates the adjustment method to be used. Valid options are:
’inversion’: tries to solve the equation \(P(C)=P(C|Y)P(Y)\) as \(P(Y) = P(C|Y)^{-1} P(C)\) where \(P(C|Y)^{-1}\) is the matrix inversion of \(P(C|Y)\). This inversion may not exist in degenerated cases
’invariant-ratio’: invariant ratio estimator of Vaz et al. 2018, which replaces the last equation with the normalization condition.
inversion: tries to solve the equation \(q = M p\) as \(p = M^{-1} q\) where +\(M^{-1}\) is the matrix inversion of \(M\). This inversion may not exist in +degenerated cases.
invariant-ratio: invariant ratio estimator of Vaz et al. 2018, +which replaces the last equation in \(M\) with the normalization condition (i.e., that the sum of +all prevalence values must equal 1).
solver (str) –
the method to use for solving the system of linear equations. Valid options are:
’exact-raise’: tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than n_classes.
’exact-cc’: if the matrix is not of full rank, returns p_c as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See quapy.method.aggregative.CC)
’exact’: deprecated, defaults to ‘exact-cc’
’minimize’: minimizes a loss, so the solution always exists
exact-raise: tries to solve the system using matrix inversion. Raises an error if the matrix has rank +strictly lower than n_classes.
exact-cc: if the matrix is not full rank, returns \(q\) (i.e., the unadjusted counts) as the estimates
exact: deprecated, defaults to ‘exact-cc’ (will be removed in future versions)
minimize: minimizes a loss, so the solution always exists
Implements the adjustment of ACC and PACC for the binary case. The adjustment for a prevalence estimate of the +positive class p comes down to computing:
+prevalence_estim (float) – the estimated value for the positive class (p in the formula)
tpr (float) – the true positive rate of the classifier
fpr (float) – the false positive rate of the classifier
clip (bool) – set to True (default) to clip values that might exceed the range [0,1]
float, the adjusted count
+Returns a string representation for a prevalence vector. E.g.,
>>> strprev([1/3, 2/3], prec=2)
>>> '[0.33, 0.67]'
@@ -1799,8 +1867,8 @@ ends up being classified as belonging to class
- Parameters:
-prevalences – a vector of prevalence values
prec – float precision
prevalences – array-like of prevalence values
prec – int, indicates the float precision (number of decimal values to print)
- Returns:
@@ -1809,9 +1877,14 @@ ends up being classified as belonging to class
+-
+quapy.functional.ternary_search(loss: Callable, n_classes: int)[source]
+
+
-
-quapy.functional.uniform_prevalence_sampling(n_classes: int, size: int = 1)[source]
+quapy.functional.uniform_prevalence_sampling(n_classes: int, size: int = 1) ndarray[source]
Implements the Kraemer algorithm
for sampling uniformly at random from the unit simplex. This implementation is adapted from this
post <https://cs.stackexchange.com/questions/3227/uniform-sampling-from-a-simplex>_.
@@ -1830,7 +1903,7 @@ for sampling uniformly at random from the unit simplex. This implementation is a
-
-quapy.functional.uniform_simplex_sampling(n_classes: int, size: int = 1)
+quapy.functional.uniform_simplex_sampling(n_classes: int, size: int = 1) ndarray
Implements the Kraemer algorithm
for sampling uniformly at random from the unit simplex. This implementation is adapted from this
post <https://cs.stackexchange.com/questions/3227/uniform-sampling-from-a-simplex>_.
@@ -2811,7 +2884,7 @@ Seeds the child processes to ensure reproducibility when n_jobs>1.
seed – the numeric seed
asarray – set to True to return a np.ndarray instead of a list
backend – indicates the backend used for handling parallel works
open_args – if True, then the delayed function is called on *args_i, instead of on args_i
open_args – if True, then the delayed function is called on *args_i, instead of on args_i
diff --git a/docs/build/html/quapy.method.html b/docs/build/html/quapy.method.html
index 053fec3..c71d492 100644
--- a/docs/build/html/quapy.method.html
+++ b/docs/build/html/quapy.method.html
@@ -104,7 +104,7 @@
quapy.method.aggregative module
-
-class quapy.method.aggregative.ACC(classifier: BaseEstimator, val_split=5, solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize', method: Literal['inversion', 'invariant-ratio'] = 'inversion', clipping: Literal['clip', 'none', 'project'] = 'clip', n_jobs=None)[source]
+class quapy.method.aggregative.ACC(classifier: BaseEstimator, val_split=5, solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize', method: Literal['inversion', 'invariant-ratio'] = 'inversion', norm: Literal['clip', 'mapsimplex', 'condsoftmax'] = 'clip', n_jobs=None)[source]
Bases: AggregativeCrispQuantifier
Adjusted Classify & Count,
the “adjusted” variant of CC, that corrects the predictions of CC
@@ -122,23 +122,31 @@ Alternatively, this set can be specified at fit time by indicating the exact set
on which the predictions are to be generated.
method (str) –
adjustment method to be used:
-’inversion’: matrix inversion method based on the matrix equality \(P(C)=P(C|Y)P(Y)\), which tries to invert \(P(C|Y)\) matrix.
’invariant-ratio’: invariant ratio estimator of Vaz et al. 2018, which replaces the last equation with the normalization condition.
’inversion’: matrix inversion method based on the matrix equality \(P(C)=P(C|Y)P(Y)\),
+which tries to invert \(P(C|Y)\) matrix.
’invariant-ratio’: invariant ratio estimator of Vaz et al. 2018,
+which replaces the last equation with the normalization condition.
solver (str) –
indicates the method to use for solving the system of linear equations. Valid options are:
-’exact-raise’: tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than n_classes.
’exact-cc’: if the matrix is not of full rank, returns p_c as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See quapy.method.aggregative.CC)
’exact-raise’: tries to solve the system using matrix inversion. Raises an error if the matrix has rank
+strictly less than n_classes.
’exact-cc’: if the matrix is not of full rank, returns p_c as the estimates, which corresponds to
+no adjustment (i.e., the classify and count method. See quapy.method.aggregative.CC)
’exact’: deprecated, defaults to ‘exact-cc’
’minimize’: minimizes the L2 norm of \(|Ax-B|\). This one generally works better, and is the default parameter. More details about this can be consulted in Bunse, M. “On Multi-Class Extensions of Adjusted Classify and Count”, on proceedings of the 2nd International Workshop on Learning to Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France).
’minimize’: minimizes the L2 norm of \(|Ax-B|\). This one generally works better, and is the
+default parameter. More details about this can be consulted in Bunse, M. “On Multi-Class Extensions of
+Adjusted Classify and Count”, on proceedings of the 2nd International Workshop on Learning to Quantify:
+Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France).
clipping (str) –
the method to use for normalization.
+norm (str) –
the method to use for normalization.
-If None or “none”, no normalization is performed.
If “clip”, the values are clipped to the range [0,1] and normalized, so they sum up to 1.
If “project”, the values are projected onto the probability simplex.
clip, the values are clipped to the range [0,1] and then L1-normalized.
mapsimplex projects vectors onto the probability simplex. This implementation relies on
+Mathieu Blondel’s projection_simplex_sort
condsoftmax, applies a softmax normalization only to prevalence vectors that lie outside the simplex
n_jobs – number of parallel workers
--
-METHODS = ['inversion', 'invariant-ratio']
+-
+NORMALIZATIONS = ['clip', 'mapsimplex', 'condsoftmax', None]
@@ -212,7 +220,7 @@ document that belongs to yj ends up being classified as belonging to yi
-
classmethod newInvariantRatioEstimation(classifier: BaseEstimator, val_split=5, n_jobs=None)[source]
Constructs a quantifier that implements the Invariant Ratio Estimator of
-Vaz et al. 2018 <https://jmlr.org/papers/v20/18-456.html>_. This amounts
+Vaz et al. 2018. This amounts
to setting method to ‘invariant-ratio’ and clipping to ‘project’.
- Parameters:
@@ -1046,7 +1054,7 @@ probabilities are independent of each other, meaning that, in general, they do n
-
-class quapy.method.aggregative.PACC(classifier: BaseEstimator, val_split=5, solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize', method: Literal['inversion', 'invariant-ratio'] = 'inversion', clipping: Literal['clip', 'none', 'project'] = 'clip', n_jobs=None)[source]
+class quapy.method.aggregative.PACC(classifier: BaseEstimator, val_split=5, solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize', method: Literal['inversion', 'invariant-ratio'] = 'inversion', norm: Literal['clip', 'mapsimplex', 'condsoftmax'] = 'clip', n_jobs=None)[source]
Bases: AggregativeSoftQuantifier
Probabilistic Adjusted Classify & Count,
the probabilistic variant of ACC that relies on the posterior probabilities returned by a probabilistic classifier.
@@ -1062,23 +1070,31 @@ for k). Alternatively, this set can be specified at fit time by ind
on which the predictions are to be generated.
method (str) –
adjustment method to be used:
-’inversion’: matrix inversion method based on the matrix equality \(P(C)=P(C|Y)P(Y)\), which tries to invert P(C|Y) matrix.
’invariant-ratio’: invariant ratio estimator of Vaz et al., which replaces the last equation with the normalization condition.
’inversion’: matrix inversion method based on the matrix equality \(P(C)=P(C|Y)P(Y)\),
+which tries to invert P(C|Y) matrix.
’invariant-ratio’: invariant ratio estimator of Vaz et al.,
+which replaces the last equation with the normalization condition.
solver (str) –
the method to use for solving the system of linear equations. Valid options are:
-’exact-raise’: tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than n_classes.
’exact-cc’: if the matrix is not of full rank, returns p_c as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See quapy.method.aggregative.CC)
’exact-raise’: tries to solve the system using matrix inversion.
+Raises an error if the matrix has rank strictly less than n_classes.
’exact-cc’: if the matrix is not of full rank, returns p_c as the estimates, which
+corresponds to no adjustment (i.e., the classify and count method. See quapy.method.aggregative.CC)
’exact’: deprecated, defaults to ‘exact-cc’
’minimize’: minimizes the L2 norm of \(|Ax-B|\). This one generally works better, and is the default parameter. More details about this can be consulted in Bunse, M. “On Multi-Class Extensions of Adjusted Classify and Count”, on proceedings of the 2nd International Workshop on Learning to Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France).
’minimize’: minimizes the L2 norm of \(|Ax-B|\). This one generally works better, and is the
+default parameter. More details about this can be consulted in Bunse, M. “On Multi-Class Extensions
+of Adjusted Classify and Count”, on proceedings of the 2nd International Workshop on Learning to
+Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France).
clipping (str) –
the method to use for normalization.
+norm (str) –
the method to use for normalization.
-If None or “none”, no normalization is performed.
If “clip”, the values are clipped to the range [0,1] and normalized, so they sum up to 1.
If “project”, the values are projected onto the probability simplex.
clip, the values are clipped to the range [0,1] and then L1-normalized.
mapsimplex projects vectors onto the probability simplex. This implementation relies on
+Mathieu Blondel’s projection_simplex_sort
condsoftmax, applies a softmax normalization only to prevalence vectors that lie outside the simplex
n_jobs – number of parallel workers
`_
+ * `softmax`: applies softmax to all vectors
+ * `condsoftmax`: applies softmax only to invalid prevalence vectors
+
+ :return: a normalized vector or matrix of prevalence values
+ """
+ if method in ['none', None]:
+ return prevalences
+
+ prevalences = np.asarray(prevalences, dtype=float)
+
+ if method=='l1':
+ normalized = l1_norm(prevalences)
+ check_prevalence_vector(normalized, raise_exception=True)
+ elif method=='clip':
+ normalized = clip(prevalences) # no need to check afterwards
+ elif method=='mapsimplex':
+ normalized = projection_simplex_sort(prevalences)
+ elif method=='softmax':
+ normalized = softmax(prevalences)
+ elif method=='condsoftmax':
+ normalized = condsoftmax(prevalences)
+ else:
+ raise ValueError(f'unknown {method=}, valid ones are ["l1", "clip", "mapsimplex", "softmax"]')
+
+ return normalized
+
+
+def l1_norm(prevalences: ArrayLike) -> np.ndarray:
+ """
+ Applies L1 normalization to the `unnormalized_arr` so that it becomes a valid prevalence
+ vector. Zero vectors are mapped onto the uniform distribution. Raises an exception if
+ the resulting vectors are not valid distributions. This may happen when the original
+ prevalence vectors contain negative values. Use the `clip` normalization function
+ instead to avoid this possibility.
+
+ :param prevalences: array-like of shape `(n_classes,)` or of shape `(n_samples, n_classes,)` with prevalence values
+ :return: np.ndarray representing a valid distribution
+ """
+ n_classes = prevalences.shape[-1]
+ accum = prevalences.sum(axis=-1, keepdims=True)
+ prevalences = np.true_divide(prevalences, accum, where=accum > 0)
+ allzeros = accum.flatten() == 0
+ if any(allzeros):
+ if prevalences.ndim == 1:
+ prevalences = np.full(shape=n_classes, fill_value=1. / n_classes)
+ else:
+ prevalences[allzeros] = np.full(shape=n_classes, fill_value=1. / n_classes)
+ return prevalences
+
+
+def clip(prevalences: ArrayLike) -> np.ndarray:
+ """
+ Clips the values in [0,1] and then applies the L1 normalization.
+
+ :param prevalences: array-like of shape `(n_classes,)` or of shape `(n_samples, n_classes,)` with prevalence values
+ :return: np.ndarray representing a valid distribution
+ """
+ clipped = np.clip(prevalences, 0, 1)
+ normalized = l1_norm(clipped)
+ return normalized
+
+
+def projection_simplex_sort(unnormalized_arr: ArrayLike) -> np.ndarray:
+ """Projects a point onto the probability simplex.
+
+ The code is adapted from Mathieu Blondel's BSD-licensed
+ `implementation `_
+ (see function `projection_simplex_sort` in their repo) which is accompanying the paper
+
+ Mathieu Blondel, Akinori Fujino, and Naonori Ueda.
+ Large-scale Multiclass Support Vector Machine Training via Euclidean Projection onto the Simplex,
+ ICPR 2014, `URL `_
+
+ :param `unnormalized_arr`: point in n-dimensional space, shape `(n,)`
+ :return: projection of `unnormalized_arr` onto the (n-1)-dimensional probability simplex, shape `(n,)`
+ """
+ unnormalized_arr = np.asarray(unnormalized_arr)
+ n = len(unnormalized_arr)
+ u = np.sort(unnormalized_arr)[::-1]
+ cssv = np.cumsum(u) - 1.0
+ ind = np.arange(1, n + 1)
+ cond = u - cssv / ind > 0
+ rho = ind[cond][-1]
+ theta = cssv[cond][-1] / float(rho)
+ return np.maximum(unnormalized_arr - theta, 0)
+
+
+def softmax(prevalences: ArrayLike) -> np.ndarray:
+ """
+ Applies the softmax function to all vectors even if the original vectors were valid distributions.
+ If you want to leave valid vectors untouched, use condsoftmax instead.
+
+ :param prevalences: array-like of shape `(n_classes,)` or of shape `(n_samples, n_classes,)` with prevalence values
+ :return: np.ndarray representing a valid distribution
+ """
+ normalized = scipy.special.softmax(prevalences, axis=-1)
+ return normalized
+
+
+def condsoftmax(prevalences: ArrayLike) -> np.ndarray:
+ """
+ Applies the softmax function only to vectors that do not represent valid distributions.
+
+ :param prevalences: array-like of shape `(n_classes,)` or of shape `(n_samples, n_classes,)` with prevalence values
+ :return: np.ndarray representing a valid distribution
+ """
+ invalid_idx = ~ check_prevalence_vector(prevalences, aggr=False, raise_exception=False)
+ if isinstance(invalid_idx, np.bool_) and invalid_idx:
+ # only one vector
+ normalized = scipy.special.softmax(prevalences)
+ else:
+ prevalences = np.copy(prevalences)
+ prevalences[invalid_idx] = scipy.special.softmax(prevalences[invalid_idx], axis=-1)
+ normalized = prevalences
+ return normalized
+
+
+# ------------------------------------------------------------------------------------------
+# Divergences
+# ------------------------------------------------------------------------------------------
def HellingerDistance(P: np.ndarray, Q: np.ndarray) -> float:
"""
@@ -128,188 +352,6 @@ def TopsoeDistance(P: np.ndarray, Q: np.ndarray, epsilon: float=1e-20):
:return: float
"""
return np.sum(P*np.log((2*P+epsilon)/(P+Q+epsilon)) + Q*np.log((2*Q+epsilon)/(P+Q+epsilon)))
-
-
-def uniform_prevalence_sampling(n_classes: int, size: int=1):
- """
- Implements the `Kraemer algorithm `_
- for sampling uniformly at random from the unit simplex. This implementation is adapted from this
- `post _`.
-
- :param n_classes: integer, number of classes (dimensionality of the simplex)
- :param size: number of samples to return
- :return: `np.ndarray` of shape `(size, n_classes,)` if `size>1`, or of shape `(n_classes,)` otherwise
- """
- if n_classes == 2:
- u = np.random.rand(size)
- u = np.vstack([1-u, u]).T
- else:
- u = np.random.rand(size, n_classes-1)
- u.sort(axis=-1)
- _0s = np.zeros(shape=(size, 1))
- _1s = np.ones(shape=(size, 1))
- a = np.hstack([_0s, u])
- b = np.hstack([u, _1s])
- u = b-a
- if size == 1:
- u = u.flatten()
- return u
-
-
-uniform_simplex_sampling = uniform_prevalence_sampling
-
-
-def strprev(prevalences: ArrayLike, prec: int=3):
- """
- Returns a string representation for a prevalence vector. E.g.,
-
- >>> strprev([1/3, 2/3], prec=2)
- >>> '[0.33, 0.67]'
-
- :param prevalences: a vector of prevalence values
- :param prec: float precision
- :return: string
- """
- return '['+ ', '.join([f'{p:.{prec}f}' for p in prevalences]) + ']'
-
-
-def adjusted_quantification(prevalence_estim: ArrayLike, tpr: float, fpr: float, clip: bool=True):
- """
- Implements the adjustment of ACC and PACC for the binary case. The adjustment for a prevalence estimate of the
- positive class `p` comes down to computing:
-
- .. math::
- ACC(p) = \\frac{ p - fpr }{ tpr - fpr }
-
- :param prevalence_estim: float, the estimated value for the positive class
- :param tpr: float, the true positive rate of the classifier
- :param fpr: float, the false positive rate of the classifier
- :param clip: set to True (default) to clip values that might exceed the range [0,1]
- :return: float, the adjusted count
- """
-
- den = tpr - fpr
- if den == 0:
- den += 1e-8
- adjusted = (prevalence_estim - fpr) / den
- if clip:
- adjusted = np.clip(adjusted, 0., 1.)
- return adjusted
-
-
-def normalize_prevalence(prevalences: ArrayLike):
- """
- Normalize a vector or matrix of prevalence values. The normalization consists of applying a L1 normalization in
- cases in which the prevalence values are not all-zeros, and to convert the prevalence values into `1/n_classes` in
- cases in which all values are zero.
-
- :param prevalences: array-like of shape `(n_classes,)` or of shape `(n_samples, n_classes,)` with prevalence values
- :return: a normalized vector or matrix of prevalence values
- """
- prevalences = np.asarray(prevalences)
- n_classes = prevalences.shape[-1]
- accum = prevalences.sum(axis=-1, keepdims=True)
- prevalences = np.true_divide(prevalences, accum, where=accum>0)
- allzeros = accum.flatten()==0
- if any(allzeros):
- if prevalences.ndim == 1:
- prevalences = np.full(shape=n_classes, fill_value=1./n_classes)
- else:
- prevalences[accum.flatten()==0] = np.full(shape=n_classes, fill_value=1./n_classes)
- return prevalences
-
-
-def __num_prevalence_combinations_depr(n_prevpoints:int, n_classes:int, n_repeats:int=1):
- """
- Computes the number of prevalence combinations in the n_classes-dimensional simplex if `nprevpoints` equally distant
- prevalence values are generated and `n_repeats` repetitions are requested.
-
- :param n_classes: integer, number of classes
- :param n_prevpoints: integer, number of prevalence points.
- :param n_repeats: integer, number of repetitions for each prevalence combination
- :return: The number of possible combinations. For example, if n_classes=2, n_prevpoints=5, n_repeats=1, then the
- number of possible combinations are 5, i.e.: [0,1], [0.25,0.75], [0.50,0.50], [0.75,0.25], and [1.0,0.0]
- """
- __cache={}
- def __f(nc,np):
- if (nc,np) in __cache: # cached result
- return __cache[(nc,np)]
- if nc==1: # stop condition
- return 1
- else: # recursive call
- x = sum([__f(nc-1, np-i) for i in range(np)])
- __cache[(nc,np)] = x
- return x
- return __f(n_classes, n_prevpoints) * n_repeats
-
-
-def num_prevalence_combinations(n_prevpoints:int, n_classes:int, n_repeats:int=1):
- """
- Computes the number of valid prevalence combinations in the n_classes-dimensional simplex if `n_prevpoints` equally
- distant prevalence values are generated and `n_repeats` repetitions are requested.
- The computation comes down to calculating:
-
- .. math::
- \\binom{N+C-1}{C-1} \\times r
-
- where `N` is `n_prevpoints-1`, i.e., the number of probability mass blocks to allocate, `C` is the number of
- classes, and `r` is `n_repeats`. This solution comes from the
- `Stars and Bars `_
- which is accompanying the paper
- Mathieu Blondel, Akinori Fujino, and Naonori Ueda.
- Large-scale Multiclass Support Vector Machine Training via Euclidean Projection onto the Simplex,
- ICPR 2014, `URL `_
+# ------------------------------------------------------------------------------------------
+# Sampling utils
+# ------------------------------------------------------------------------------------------
- :param unnormalized_arr: point in n-dimensional space, shape `(n,)`
- :return: projection of `v` onto (n-1)-dimensional probability simplex, shape `(n,)`
+def prevalence_linspace(grid_points:int=21, repeats:int=1, smooth_limits_epsilon:float=0.01) -> np.ndarray:
"""
- unnormalized_arr = np.asarray(unnormalized_arr)
- n = len(unnormalized_arr)
+ Produces an array of uniformly separated values of prevalence.
+ By default, produces an array of 21 prevalence values, with
+ step 0.05 and with the limits smoothed, i.e.:
+ [0.01, 0.05, 0.10, 0.15, ..., 0.90, 0.95, 0.99]
- # Sort the values in the descending order
- u = np.sort(unnormalized_arr)[::-1]
-
- cssv = np.cumsum(u) - 1.0
- ind = np.arange(1, n + 1)
- cond = u - cssv / ind > 0
- rho = ind[cond][-1]
- theta = cssv[cond][-1] / float(rho)
- return np.maximum(unnormalized_arr - theta, 0)
-
-
-def clip_prevalence(prevalences: ArrayLike, method: Literal[None, "none", "clip", "project"]) -> np.ndarray:
+ :param grid_points: the number of prevalence values to sample from the [0,1] interval (default 21)
+ :param repeats: number of times each prevalence is to be repeated (defaults to 1)
+ :param smooth_limits_epsilon: the quantity to add and subtract to the limits 0 and 1
+ :return: an array of uniformly separated prevalence values
"""
- Clips the proportions vector `prevalences` so that it is a valid probability distribution, i.e., all values
- are in [0,1] and sum up to 1.
+ p = np.linspace(0., 1., num=grid_points, endpoint=True)
+ p[0] += smooth_limits_epsilon
+ p[-1] -= smooth_limits_epsilon
+ if p[0] > p[1]:
+ raise ValueError(f'the smoothing in the limits is greater than the prevalence step')
+ if repeats > 1:
+ p = np.repeat(p, repeats)
+ return p
- :param prevalences: array-like, the proportions vector to be clipped, shape `(n_classes,)`
- :param method: indicates the method to be used for normalization.
- If `None` or `"none"`, no normalization is performed.
- If `"clip"`, the values are clipped to the range [0,1] and normalized, so they sum up to 1.
- If `"project"`, the values are projected onto the probability simplex.
- :return: the normalized prevalence vector, shape `(n_classes,)`
+
+def uniform_prevalence_sampling(n_classes: int, size: int=1) -> np.ndarray:
"""
- prevalences = np.asarray(prevalences)
- if method in [None, "none"]:
- return prevalences
- elif method == "clip":
- clipped = np.clip(prevalences, 0, 1)
- adjusted = clipped / clipped.sum()
- return adjusted
- elif method == "project":
- return map_onto_probability_simplex(prevalences)
+ Implements the `Kraemer algorithm `_
+ for sampling uniformly at random from the unit simplex. This implementation is adapted from this
+ `post _`.
+
+ :param n_classes: integer, number of classes (dimensionality of the simplex)
+ :param size: number of samples to return
+ :return: `np.ndarray` of shape `(size, n_classes,)` if `size>1`, or of shape `(n_classes,)` otherwise
+ """
+ if n_classes == 2:
+ u = np.random.rand(size)
+ u = np.vstack([1-u, u]).T
else:
- raise ValueError(f'Unknown method {method}. Valid ones are "none", "clip", or "project"')
+ u = np.random.rand(size, n_classes-1)
+ u.sort(axis=-1)
+ _0s = np.zeros(shape=(size, 1))
+ _1s = np.ones(shape=(size, 1))
+ a = np.hstack([_0s, u])
+ b = np.hstack([u, _1s])
+ u = b-a
+ if size == 1:
+ u = u.flatten()
+ return u
+
+
+uniform_simplex_sampling = uniform_prevalence_sampling
+
+
+# ------------------------------------------------------------------------------------------
+# Adjustment
+# ------------------------------------------------------------------------------------------
+
+def solve_adjustment_binary(prevalence_estim: ArrayLike, tpr: float, fpr: float, clip: bool=True):
+ """
+ Implements the adjustment of ACC and PACC for the binary case. The adjustment for a prevalence estimate of the
+ positive class `p` comes down to computing:
+
+ .. math::
+ ACC(p) = \\frac{ p - fpr }{ tpr - fpr }
+
+ :param float prevalence_estim: the estimated value for the positive class (`p` in the formula)
+ :param float tpr: the true positive rate of the classifier
+ :param float fpr: the false positive rate of the classifier
+ :param bool clip: set to True (default) to clip values that might exceed the range [0,1]
+ :return: float, the adjusted count
+ """
+
+ den = tpr - fpr
+ if den == 0:
+ den += 1e-8
+ adjusted = (prevalence_estim - fpr) / den
+ if clip:
+ adjusted = np.clip(adjusted, 0., 1.)
+ return adjusted
def solve_adjustment(
- p_c_cond_y: np.ndarray,
- p_c: np.ndarray,
+ class_conditional_rates: np.ndarray,
+ unadjusted_counts: np.ndarray,
method: Literal["inversion", "invariant-ratio"],
solver: Literal["exact", "minimize", "exact-raise", "exact-cc"]) -> np.ndarray:
"""
- Function that tries to solve for the equation :math:`P(C)=P(C|Y)P(Y)`, where :math:`P(C)` is the vector of
- prevalence values obtained by a classify and count, and :math:`P(C|Y)` are the class-conditional misclassification
- rates of the classifier.
+ Function that tries to solve for :math:`p` the equation :math:`q = M p`, where :math:`q` is the vector of
+ `unadjusted counts` (as estimated, e.g., via classify and count) with :math:`q_i` an estimate of
+ :math:`P(\hat{Y}=y_i)`, and where :math:`M` is the matrix of `class-conditional rates` with :math:`M_{ij}` an
+ estimate of :math:`P(\hat{Y}=y_i|Y=y_j)`.
- :param p_c_cond_y: array of shape `(n_classes, n_classes,)` with entry `(c,y)` being the estimate
- of :math:`P(C=c|Y=y)`, that is, the probability that an instance that belongs to class :math:`y`
- ends up being classified as belonging to class :math:`c`
+ :param class_conditional_rates: array of shape `(n_classes, n_classes,)` with entry `(i,j)` being the estimate
+ of :math:`P(\hat{Y}=y_i|Y=y_j)`, that is, the probability that an instance that belongs to class :math:`y_j`
+ ends up being classified as belonging to class :math:`y_i`
- :param p_c: array of shape `(n_classes,)` containing the prevalence values as estimated by classify and count
+ :param unadjusted_counts: array of shape `(n_classes,)` containing the unadjusted prevalence values (e.g., as
+ estimated by CC or PCC)
:param str method: indicates the adjustment method to be used. Valid options are:
- * 'inversion': tries to solve the equation :math:`P(C)=P(C|Y)P(Y)` as :math:`P(Y) = P(C|Y)^{-1} P(C)` where :math:`P(C|Y)^{-1}` is the matrix inversion of :math:`P(C|Y)`. This inversion may not exist in degenerated cases
- * 'invariant-ratio': invariant ratio estimator of `Vaz et al. 2018 `_, which replaces the last equation with the normalization condition.
+ * `inversion`: tries to solve the equation :math:`q = M p` as :math:`p = M^{-1} q` where
+ :math:`M^{-1}` is the matrix inversion of :math:`M`. This inversion may not exist in
+ degenerated cases.
+ * `invariant-ratio`: invariant ratio estimator of `Vaz et al. 2018 `_,
+ which replaces the last equation in :math:`M` with the normalization condition (i.e., that the sum of
+ all prevalence values must equal 1).
:param str solver: the method to use for solving the system of linear equations. Valid options are:
- * 'exact-raise': tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than `n_classes`.
- * 'exact-cc': if the matrix is not of full rank, returns `p_c` as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See :class:`quapy.method.aggregative.CC`)
- * 'exact': deprecated, defaults to 'exact-cc'
- * 'minimize': minimizes a loss, so the solution always exists
+ * `exact-raise`: tries to solve the system using matrix inversion. Raises an error if the matrix has rank
+ strictly lower than `n_classes`.
+ * `exact-cc`: if the matrix is not full rank, returns :math:`q` (i.e., the unadjusted counts) as the estimates
+ * `exact`: deprecated, defaults to 'exact-cc' (will be removed in future versions)
+ * `minimize`: minimizes a loss, so the solution always exists
"""
if solver == "exact":
warnings.warn(
"The 'exact' solver is deprecated. Use 'exact-raise' or 'exact-cc'", DeprecationWarning, stacklevel=2)
solver = "exact-cc"
- A = np.asarray(p_c_cond_y, dtype=float)
- B = np.asarray(p_c, dtype=float)
+ A = np.asarray(class_conditional_rates, dtype=float)
+ B = np.asarray(unadjusted_counts, dtype=float)
if method == "inversion":
pass # We leave A and B unchanged
@@ -497,13 +584,13 @@ def solve_adjustment(
A[-1, :] = 1.0
B[-1] = 1.0
else:
- raise ValueError(f"Method {method} not known.")
+ raise ValueError(f"unknown {method=}")
if solver == "minimize":
def loss(prev):
return np.linalg.norm(A @ prev - B)
return optim_minimize(loss, n_classes=A.shape[0])
- else:
+ elif solver in ["exact-raise", "exact-cc"]:
# Solvers based on matrix inversion, so we use try/except block
try:
return np.linalg.solve(A, B)
@@ -514,6 +601,8 @@ def solve_adjustment(
if solver == "exact-raise":
raise
elif solver == "exact-cc":
- return p_c
+ return unadjusted_counts
else:
raise ValueError(f"Solver {solver} not known.")
+ else:
+ raise ValueError(f'unknown {solver=}')
diff --git a/quapy/method/aggregative.py b/quapy/method/aggregative.py
index bba0c15..46e56d7 100644
--- a/quapy/method/aggregative.py
+++ b/quapy/method/aggregative.py
@@ -394,21 +394,30 @@ class ACC(AggregativeCrispQuantifier):
:param str method: adjustment method to be used:
- * 'inversion': matrix inversion method based on the matrix equality :math:`P(C)=P(C|Y)P(Y)`, which tries to invert :math:`P(C|Y)` matrix.
- * 'invariant-ratio': invariant ratio estimator of `Vaz et al. 2018 `_, which replaces the last equation with the normalization condition.
+ * 'inversion': matrix inversion method based on the matrix equality :math:`P(C)=P(C|Y)P(Y)`,
+ which tries to invert :math:`P(C|Y)` matrix.
+ * 'invariant-ratio': invariant ratio estimator of `Vaz et al. 2018 `_,
+ which replaces the last equation with the normalization condition.
:param str solver: indicates the method to use for solving the system of linear equations. Valid options are:
- * 'exact-raise': tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than `n_classes`.
- * 'exact-cc': if the matrix is not of full rank, returns `p_c` as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See :class:`quapy.method.aggregative.CC`)
+ * 'exact-raise': tries to solve the system using matrix inversion. Raises an error if the matrix has rank
+ strictly less than `n_classes`.
+ * 'exact-cc': if the matrix is not of full rank, returns `p_c` as the estimates, which corresponds to
+ no adjustment (i.e., the classify and count method. See :class:`quapy.method.aggregative.CC`)
* 'exact': deprecated, defaults to 'exact-cc'
- * 'minimize': minimizes the L2 norm of :math:`|Ax-B|`. This one generally works better, and is the default parameter. More details about this can be consulted in `Bunse, M. "On Multi-Class Extensions of Adjusted Classify and Count", on proceedings of the 2nd International Workshop on Learning to Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France) `_.
+ * 'minimize': minimizes the L2 norm of :math:`|Ax-B|`. This one generally works better, and is the
+ default parameter. More details about this can be consulted in `Bunse, M. "On Multi-Class Extensions of
+ Adjusted Classify and Count", on proceedings of the 2nd International Workshop on Learning to Quantify:
+ Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France)
+ `_.
- :param str clipping: the method to use for normalization.
+ :param str norm: the method to use for normalization.
- * If `None` or `"none"`, no normalization is performed.
- * If `"clip"`, the values are clipped to the range [0,1] and normalized, so they sum up to 1.
- * If `"project"`, the values are projected onto the probability simplex.
+ * `clip`, the values are clipped to the range [0,1] and then L1-normalized.
+ * `mapsimplex` projects vectors onto the probability simplex. This implementation relies on
+ `Mathieu Blondel's projection_simplex_sort `_
+ * `condsoftmax`, applies a softmax normalization only to prevalence vectors that lie outside the simplex
:param n_jobs: number of parallel workers
"""
@@ -418,26 +427,25 @@ class ACC(AggregativeCrispQuantifier):
val_split=5,
solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize',
method: Literal['inversion', 'invariant-ratio'] = 'inversion',
- clipping: Literal['clip', 'none', 'project'] = 'clip',
+ norm: Literal['clip', 'mapsimplex', 'condsoftmax'] = 'clip',
n_jobs=None,
- ):
+ ):
self.classifier = classifier
self.val_split = val_split
self.n_jobs = qp._get_njobs(n_jobs)
self.solver = solver
self.method = method
- self.clipping = clipping
+ self.norm = norm
SOLVERS = ['exact', 'minimize', 'exact-raise', 'exact-cc']
METHODS = ['inversion', 'invariant-ratio']
- CLIPPING = ['clip', 'none', 'project', None]
-
+ NORMALIZATIONS = ['clip', 'mapsimplex', 'condsoftmax', None]
@classmethod
def newInvariantRatioEstimation(cls, classifier: BaseEstimator, val_split=5, n_jobs=None):
"""
Constructs a quantifier that implements the Invariant Ratio Estimator of
- `Vaz et al. 2018 _`. This amounts
+ `Vaz et al. 2018 `_. This amounts
to setting method to 'invariant-ratio' and clipping to 'project'.
:param classifier: a sklearn's Estimator that generates a classifier
@@ -451,15 +459,15 @@ class ACC(AggregativeCrispQuantifier):
:param n_jobs: number of parallel workers
:return: an instance of ACC configured so that it implements the Invariant Ratio Estimator
"""
- return ACC(classifier, val_split=val_split, method='invariant-ratio', clipping='project', n_jobs=n_jobs)
+ return ACC(classifier, val_split=val_split, method='invariant-ratio', norm='mapsimplex', n_jobs=n_jobs)
def _check_init_parameters(self):
if self.solver not in ACC.SOLVERS:
raise ValueError(f"unknown solver; valid ones are {ACC.SOLVERS}")
if self.method not in ACC.METHODS:
raise ValueError(f"unknown method; valid ones are {ACC.METHODS}")
- if self.clipping not in ACC.CLIPPING:
- raise ValueError(f"unknown clipping; valid ones are {ACC.CLIPPING}")
+ if self.norm not in ACC.NORMALIZATIONS:
+ raise ValueError(f"unknown clipping; valid ones are {ACC.NORMALIZATIONS}")
def aggregation_fit(self, classif_predictions: LabelledCollection, data: LabelledCollection):
"""
@@ -497,12 +505,12 @@ class ACC(AggregativeCrispQuantifier):
def aggregate(self, classif_predictions):
prevs_estim = self.cc.aggregate(classif_predictions)
estimate = F.solve_adjustment(
- p_c_cond_y=self.Pte_cond_estim_,
- p_c=prevs_estim,
+ class_conditional_rates=self.Pte_cond_estim_,
+ unadjusted_counts=prevs_estim,
solver=self.solver,
method=self.method,
)
- return F.clip_prevalence(estimate, method=self.clipping)
+ return F.normalize_prevalence(estimate, method=self.norm)
class PACC(AggregativeSoftQuantifier):
@@ -521,21 +529,30 @@ class PACC(AggregativeSoftQuantifier):
:param str method: adjustment method to be used:
- * 'inversion': matrix inversion method based on the matrix equality :math:`P(C)=P(C|Y)P(Y)`, which tries to invert `P(C|Y)` matrix.
- * 'invariant-ratio': invariant ratio estimator of `Vaz et al. `_, which replaces the last equation with the normalization condition.
+ * 'inversion': matrix inversion method based on the matrix equality :math:`P(C)=P(C|Y)P(Y)`,
+ which tries to invert `P(C|Y)` matrix.
+ * 'invariant-ratio': invariant ratio estimator of `Vaz et al. `_,
+ which replaces the last equation with the normalization condition.
:param str solver: the method to use for solving the system of linear equations. Valid options are:
- * 'exact-raise': tries to solve the system using matrix inversion. Raises an error if the matrix has rank strictly less than `n_classes`.
- * 'exact-cc': if the matrix is not of full rank, returns `p_c` as the estimates, which corresponds to no adjustment (i.e., the classify and count method. See :class:`quapy.method.aggregative.CC`)
+ * 'exact-raise': tries to solve the system using matrix inversion.
+ Raises an error if the matrix has rank strictly less than `n_classes`.
+ * 'exact-cc': if the matrix is not of full rank, returns `p_c` as the estimates, which
+ corresponds to no adjustment (i.e., the classify and count method. See :class:`quapy.method.aggregative.CC`)
* 'exact': deprecated, defaults to 'exact-cc'
- * 'minimize': minimizes the L2 norm of :math:`|Ax-B|`. This one generally works better, and is the default parameter. More details about this can be consulted in `Bunse, M. "On Multi-Class Extensions of Adjusted Classify and Count", on proceedings of the 2nd International Workshop on Learning to Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France) `_.
+ * 'minimize': minimizes the L2 norm of :math:`|Ax-B|`. This one generally works better, and is the
+ default parameter. More details about this can be consulted in `Bunse, M. "On Multi-Class Extensions
+ of Adjusted Classify and Count", on proceedings of the 2nd International Workshop on Learning to
+ Quantify: Methods and Applications (LQ 2022), ECML/PKDD 2022, Grenoble (France)
+ `_.
- :param str clipping: the method to use for normalization.
+ :param str norm: the method to use for normalization.
- * If `None` or `"none"`, no normalization is performed.
- * If `"clip"`, the values are clipped to the range [0,1] and normalized, so they sum up to 1.
- * If `"project"`, the values are projected onto the probability simplex.
+ * `clip`, the values are clipped to the range [0,1] and then L1-normalized.
+ * `mapsimplex` projects vectors onto the probability simplex. This implementation relies on
+ `Mathieu Blondel's projection_simplex_sort `_
+ * `condsoftmax`, applies a softmax normalization only to prevalence vectors that lie outside the simplex
:param n_jobs: number of parallel workers
"""
@@ -545,24 +562,23 @@ class PACC(AggregativeSoftQuantifier):
val_split=5,
solver: Literal['minimize', 'exact', 'exact-raise', 'exact-cc'] = 'minimize',
method: Literal['inversion', 'invariant-ratio'] = 'inversion',
- clipping: Literal['clip', 'none', 'project'] = 'clip',
- n_jobs=None,
- ):
+ norm: Literal['clip', 'mapsimplex', 'condsoftmax'] = 'clip',
+ n_jobs=None
+ ):
self.classifier = classifier
self.val_split = val_split
self.n_jobs = qp._get_njobs(n_jobs)
-
self.solver = solver
self.method = method
- self.clipping = clipping
+ self.norm = norm
def _check_init_parameters(self):
if self.solver not in ACC.SOLVERS:
raise ValueError(f"unknown solver; valid ones are {ACC.SOLVERS}")
if self.method not in ACC.METHODS:
raise ValueError(f"unknown method; valid ones are {ACC.METHODS}")
- if self.clipping not in ACC.CLIPPING:
- raise ValueError(f"unknown clipping; valid ones are {ACC.CLIPPING}")
+ if self.clipping not in ACC.NORMALIZATIONS:
+ raise ValueError(f"unknown clipping; valid ones are {ACC.NORMALIZATIONS}")
def aggregation_fit(self, classif_predictions: LabelledCollection, data: LabelledCollection):
"""
@@ -580,12 +596,12 @@ class PACC(AggregativeSoftQuantifier):
prevs_estim = self.pcc.aggregate(classif_posteriors)
estimate = F.solve_adjustment(
- p_c_cond_y=self.Pte_cond_estim_,
- p_c=prevs_estim,
+ class_conditional_rates=self.Pte_cond_estim_,
+ unadjusted_counts=prevs_estim,
solver=self.solver,
method=self.method,
)
- return F.clip_prevalence(estimate, method=self.clipping)
+ return F.normalize_prevalence(estimate, method=self.norm)
@classmethod
def getPteCondEstim(cls, classes, y, y_):
diff --git a/quapy/model_selection.py b/quapy/model_selection.py
index 12b3386..107f303 100644
--- a/quapy/model_selection.py
+++ b/quapy/model_selection.py
@@ -25,6 +25,7 @@ class Status(Enum):
class ConfigStatus:
+
def __init__(self, params, status, msg=''):
self.params = params
self.status = status