mlquantify 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

mlquantify/utils/_validation.py

@@ -0,0 +1,447 @@
+from __future__ import annotations
+from typing import Any
+import numpy as np
+import scipy.sparse as sp
+from sklearn.utils.validation import check_array, check_X_y, _check_y
+
+from mlquantify.utils._tags import TargetInputTags, get_tags
+from mlquantify.utils._exceptions import InputValidationError, InvalidParameterError, NotFittedError
+from mlquantify.utils._constraints import make_constraint
+
+
+# ---------------------------
+# y Validation
+# ---------------------------
+
+def _validate_is_numpy_array(array: Any) -> None:
+    """Ensure y are a numpy array."""
+    if not isinstance(array, np.ndarray):
+        raise InputValidationError(
+            f"y must be a numpy array, got {type(y).__name__}."
+        )
+
+
+def _validate_1d_predictions(quantifier: Any, y: np.ndarray, target_tags: TargetInputTags) -> None:
+    """Validate 1D predictions according to quantifier tags."""
+    if target_tags.continuous:
+        return  # continuous allows any numeric vector
+
+    n_class = len(np.unique(y))
+
+    if target_tags.one_d:
+        
+        if n_class > 2 and not target_tags.multi_class:
+            raise InputValidationError(
+                f"1D predictions for {quantifier.__class__.__name__} must be binary "
+                f"with 2 unique values, got {n_class} unique values."
+            )
+        if not np.issubdtype(y.dtype, np.number) and not target_tags.categorical:
+            raise InputValidationError(
+                f"1D predictions for {quantifier.__class__.__name__} must be numeric (int or float), "
+                f"got dtype {y.dtype}."
+            )
+        return
+
+    if not target_tags.one_d:
+        raise InputValidationError(
+            f"{quantifier.__class__.__name__} does not accept 1D input according to its tags."
+        )
+
+
+def _validate_2d_predictions(quantifier: Any, y: np.ndarray, target_tags: TargetInputTags) -> None:
+    """Validate 2D predictions according to quantifier tags."""
+    if not (target_tags.two_d or target_tags.multi_class):
+        raise InputValidationError(
+            f"{quantifier.__class__.__name__} does not accept multi-class or 2D input."
+        )
+
+    if not np.issubdtype(y.dtype, np.floating):
+        raise InputValidationError(
+            f"{quantifier.__class__.__name__} expects float probabilities for 2D predictions, "
+            f"got dtype {y.dtype}."
+        )
+
+    # Efficient normalization check for soft probabilities
+    if target_tags.two_d:
+        row_sums = y.sum(axis=1)
+        if np.abs(row_sums - 1).max() > 1e-3:
+            raise InputValidationError(
+                f"Soft predictions for multiclass quantifiers must sum to 1 across columns "
+                f"(max deviation={np.abs(row_sums - 1).max():.3g})."
+            )
+
+
+def validate_y(quantifier: Any, y: np.ndarray) -> None:
+    """
+    Validate predictions using the quantifier's declared input tags.
+    Raises InputValidationError if inconsistent with tags.
+    """
+    _validate_is_numpy_array(y)
+
+    try:
+        tags = get_tags(quantifier)
+        target_tags = tags.target_input_tags
+    except AttributeError as e:
+        raise InputValidationError(
+            f"Quantifier {quantifier.__class__.__name__} does not implement __mlquantify_tags__()."
+        ) from e
+    if y.ndim == 1:
+        _validate_1d_predictions(quantifier, y, target_tags)
+    elif y.ndim == 2:
+        _validate_2d_predictions(quantifier, y, target_tags)
+    else:
+        raise InputValidationError(
+            f"Predictions must be 1D or 2D array, got array with ndim={y.ndim} and shape={y.shape}."
+        )
+
+def _get_valid_crisp_predictions(predictions, threshold=0.5):
+    predictions = np.asarray(predictions)
+
+    dimensions = predictions.shape[1] if len(predictions.shape) > 1 else 1
+
+    if dimensions > 2:
+        predictions = np.argmax(predictions, axis=1)
+    elif dimensions == 2:
+        predictions = (predictions[:, 1] > threshold).astype(int)
+    elif dimensions == 1:
+        if np.issubdtype(predictions.dtype, np.floating):
+            predictions = (predictions > threshold).astype(int)
+    else:
+        raise ValueError(f"Predictions array has an invalid number of dimensions. Expected 1 or more dimensions, got {predictions.ndim}.")
+
+    return predictions
+
+
+def validate_predictions(quantifier: Any, predictions: np.ndarray) -> None:
+    """
+    Validate predictions using the quantifier's declared output tags.
+    Raises InputValidationError if inconsistent with tags.
+    """
+    _validate_is_numpy_array(predictions)
+
+    try:
+        tags = get_tags(quantifier)
+        estimator_type = tags.estimator_type
+    except AttributeError as e:
+        raise InputValidationError(
+            f"Quantifier {quantifier.__class__.__name__} does not implement __mlquantify_tags__()."
+        ) from e
+
+    if estimator_type == "soft" and np.issubdtype(predictions.dtype, np.integer):
+        raise InputValidationError(
+            f"Soft predictions for {quantifier.__class__.__name__} must be float, got dtype {predictions.dtype}."
+        )
+    elif estimator_type == "crisp" and np.issubdtype(predictions.dtype, np.floating):
+        predictions = _get_valid_crisp_predictions(predictions) 
+    return predictions   
+    
+    
+
+
+# ---------------------------
+# Parameter Validation
+# ---------------------------
+
+def validate_parameter_constraints(parameter_constraints: dict[str, Any], params: dict[str, Any], caller_name: str) -> None:
+    """Validate parameters against their declared constraints."""
+    for param_name, param_val in params.items():
+        if param_name not in parameter_constraints:
+            continue
+
+        constraints = parameter_constraints[param_name]
+        if constraints == "no_validation":
+            continue
+
+        constraint_objs = [make_constraint(c) for c in constraints]
+
+        if any(c.is_satisfied_by(param_val) for c in constraint_objs):
+            continue  # valid parameter
+
+        # Only visible constraints in error message
+        visible = [c for c in constraint_objs if not getattr(c, "hidden", False)] or constraint_objs
+        constraint_str = (
+            str(visible[0])
+            if len(visible) == 1
+            else ", ".join(map(str, visible[:-1])) + f" or {visible[-1]}"
+        )
+
+        raise InvalidParameterError(
+            f"The parameter '{param_name}' of {caller_name} must be {constraint_str}. "
+            f"Got {param_val!r} (type={type(param_val).__name__})."
+        )
+        
+        
+def validate_learner_contraints(quantifier, learner) -> None:
+    """Validate the learner parameter of a quantifier."""
+    try:
+        tags = get_tags(quantifier)
+    except AttributeError as e:
+        raise InvalidParameterError(
+            f"Quantifier {quantifier.__class__.__name__} does not implement __mlquantify_tags__()."
+        ) from e
+
+    if not tags.has_estimator:
+        if learner is not None:
+            raise InvalidParameterError(
+                f"The quantifier {quantifier.__class__.__name__} does not support using a learner."
+            )
+        return  # No learner needed
+
+
+    estimator_function = tags.estimator_function
+    
+    if estimator_function is None:
+        raise InvalidParameterError(f"The quantifier {quantifier.__class__.__name__} does not specify a valid estimator_function in its tags.")
+    elif estimator_function == "predict":
+        if not hasattr(quantifier.learner, "predict"):
+            raise InvalidParameterError(f"The provided learner does not have a 'predict' method, which is required by the quantifier {quantifier.__class__.__name__}.")
+    elif estimator_function == "predict_proba":
+        if not hasattr(quantifier.learner, "predict_proba"):
+            raise InvalidParameterError(f"The provided learner does not have a 'predict_proba' method, which is required by the quantifier {quantifier.__class__.__name__}.")
+
+
+def _is_fitted(quantifier, attributes=None, all_or_any=all):
+    """Check if the quantifier is fitted by verifying the presence of specified attributes."""
+    if attributes is None:
+        attributes = ["is_fitted_"]
+
+    checks = [hasattr(quantifier, attr) for attr in attributes]
+    return all(checks) if all_or_any == all else any(checks)
+
+
+def check_is_fitted(quantifier, attributes=None, *, msg=None, all_or_any=all):
+    """Raise NotFittedError if the quantifier is not fitted."""
+
+    if msg is None:
+        msg = f"This {quantifier.__class__.__name__} instance is not fitted yet. Call 'fit' first."
+
+    if not hasattr(quantifier, "fit"):
+        raise TypeError(f"Cannot check if {quantifier.__class__.__name__} is fitted: no 'fit' method found.")
+    
+    tags = get_tags(quantifier)
+    
+    if not tags.requires_fit and attributes is None:
+        return  # No fitting required for this quantifier
+    
+    if not _is_fitted(quantifier, attributes, all_or_any):
+        raise NotFittedError(msg % {"name": type(quantifier).__name__})
+
+
+def _is_arraylike_not_scalar(array):
+    """Return True if array is array-like and not a scalar"""
+    return _is_arraylike(array) and not np.isscalar(array)
+
+
+def _is_arraylike(x):
+    """Returns whether the input is array-like."""
+    if sp.issparse(x):
+        return False
+
+    return hasattr(x, "__len__") or hasattr(x, "shape") or hasattr(x, "__array__")
+
+
+def validate_data(quantifier, 
+                  X="no_validation",
+                  y="no_validation",
+                  reset=True,
+                  validate_separately=False,
+                  skip_check_array=False,
+                  **check_params):
+    """
+    Validate input data X and optionally y using sklearn's validate_data.
+    Raises InputValidationError if validation fails.
+    """
+    tags = get_tags(quantifier)
+    if y is None and tags.target_input_tags.required:
+        raise InputValidationError(
+            f"The target variable y is required for {quantifier.__class__.__name__}."
+        )
+    
+    no_val_X = isinstance(X, str) and X == "no_validation"
+    no_val_y = y is None or (isinstance(y, str) and y == "no_validation")
+    
+    if no_val_X and no_val_y:
+        raise ValueError("Validation should be done on X, y or both.")
+    
+    default_check_params = {"estimator": quantifier}
+    check_params = {**default_check_params, **check_params}
+    
+    if skip_check_array:
+        if not no_val_X and no_val_y:
+            out = X
+        elif no_val_X and not no_val_y:
+            out = y
+        else:
+            out = X, y
+    elif not no_val_X and no_val_y:
+        out = check_array(X, input_name="X", **check_params)
+    elif no_val_X and not no_val_y:
+        out = _check_y(y, **check_params)
+    else:
+        if validate_separately:
+            # We need this because some estimators validate X and y
+            # separately, and in general, separately calling check_array()
+            # on X and y isn't equivalent to just calling check_X_y()
+            # :(
+            check_X_params, check_y_params = validate_separately
+            if "estimator" not in check_X_params:
+                check_X_params = {**default_check_params, **check_X_params}
+            X = check_array(X, input_name="X", **check_X_params)
+            if "estimator" not in check_y_params:
+                check_y_params = {**default_check_params, **check_y_params}
+            y = check_array(y, input_name="y", **check_y_params)
+        else:
+            X, y = check_X_y(X, y, **check_params)
+        out = X, y
+        
+    return out
+
+
+def validate_prevalences(quantifier, prevalences: np.ndarray | list | dict, classes: np.ndarray, return_type: str = "dict", normalize: bool = True) -> dict | np.ndarray:
+    """
+    Validate class prevalences according to quantifier tags.
+    
+    Parameters
+    ----------
+    quantifier : estimator
+        The quantifier instance
+    prevalences : np.ndarray, list, or dict
+        Predicted prevalences for each class
+    classes : np.ndarray
+        Array of class labels
+    return_type : str, default="dict"
+        Return format: "dict" or "array"
+    normalize : bool, default=True
+        Whether to normalize prevalences to sum to 1
+        
+    Returns
+    -------
+    dict or np.ndarray
+        Validated prevalences in the requested format
+    """
+    if return_type not in ["dict", "array"]:
+        raise InvalidParameterError(
+            f"return_type must be 'dict' or 'array', got {return_type!r}."
+        )
+    
+    # Convert to dict if needed
+    if isinstance(prevalences, dict):
+        prev_dict = prevalences
+    elif isinstance(prevalences, (list, np.ndarray)):
+        prevalences = np.asarray(prevalences)
+        
+        if len(prevalences) > len(classes):
+            raise InputValidationError(
+                f"Number of prevalences ({len(prevalences)}) cannot exceed number of classes ({len(classes)})."
+            )
+        
+        # Create dict, padding with zeros if classes is larger
+        prev_dict = {}
+        for i, cls in enumerate(classes):
+            prev_dict[cls] = prevalences[i] if i < len(prevalences) else 0.0
+    else:
+        raise InputValidationError(
+            f"prevalences must be a numpy array, list, or dict, got {type(prevalences).__name__}."
+        )
+    
+    # Validate all classes are present
+    if set(prev_dict.keys()) != set(classes):
+        raise InputValidationError(
+            f"prevalences keys must match classes. Got keys {set(prev_dict.keys())}, expected {set(classes)}."
+        )
+    
+    # Normalize if requested
+    if normalize:
+        total = sum(prev_dict.values())
+        if total == 0:
+            raise InputValidationError("Cannot normalize prevalences: sum is zero.")
+        prev_dict = {cls: val / total for cls, val in prev_dict.items()}
+    
+    # Convert numpy types to native Python types for cleaner output
+    
+    prev_dict_converted = {}
+    # Convert numpy types to native Python types
+    for cls, val in prev_dict.items():
+        if isinstance(cls, np.integer):
+            cls = int(cls)
+        elif isinstance(cls, np.floating):
+            cls = float(cls)
+        elif isinstance(cls, np.str_):
+            cls = str(cls)
+        prev_dict_converted[cls] = float(val)
+    
+    # Return in requested format
+    if return_type == "dict":
+        return prev_dict_converted
+    else:
+        return np.array([prev_dict_converted[cls] for cls in classes])
+
+
+def normalize_prevalences(prevalences: np.ndarray | list | dict, classes: np.ndarray = None) -> np.ndarray | dict:
+    """
+    Normalize prevalences to sum to 1.
+    
+    Parameters
+    ----------
+    prevalences : np.ndarray, list, or dict
+        Class prevalences to normalize
+    classes : np.ndarray, optional
+        Array of class labels (required if prevalences is array/list)
+        
+    Returns
+    -------
+    np.ndarray or dict
+        Normalized prevalences in the same format as input
+    """
+    if isinstance(prevalences, dict):
+        total = sum(prevalences.values())
+        if total == 0:
+            raise InputValidationError("Cannot normalize prevalences: sum is zero.")
+        normalized = {cls: val / total for cls, val in prevalences.items()}
+        
+        normalized_dict = {}
+        # Convert numpy types to native Python types
+        for cls, val in normalized.items():
+            if isinstance(cls, np.integer):
+                cls = int(cls)
+            elif isinstance(cls, np.floating):
+                cls = float(cls)
+            elif isinstance(cls, np.str_):
+                cls = str(cls)
+            normalized_dict[cls] = float(val)
+        return normalized_dict
+    
+    elif isinstance(prevalences, (list, np.ndarray)):
+        prevalences = np.asarray(prevalences)
+        total = prevalences.sum()
+        if total == 0:
+            raise InputValidationError("Cannot normalize prevalences: sum is zero.")
+        return prevalences / total
+    
+    else:
+        raise InputValidationError(
+            f"prevalences must be a numpy array, list, or dict, got {type(prevalences).__name__}."
+        )
+        
+        
+def check_has_method(obj: Any, method_name: str) -> bool:
+    """Check if the object has a callable method with the given name."""
+    return callable(getattr(obj, method_name, None))
+
+def check_classes_attribute(quantifier: Any, classes) -> bool:
+    """Check if the quantifier has a 'classes_' attribute and if it matches the type of classes."""
+    
+    if not hasattr(quantifier, "classes_"):
+        return classes
+    
+    quantifier_classes = quantifier.classes_
+    
+    # Check if types match
+    if type(quantifier_classes) != type(classes):
+        return classes
+    
+    # Check if shapes match before comparing elements
+    if len(quantifier_classes) != len(classes) or not np.all(quantifier_classes == classes):
+        return classes
+    return quantifier_classes
+    

mlquantify/utils/prevalence.py

@@ -0,0 +1,61 @@
+import numpy as np
+import pandas as pd
+from collections import defaultdict
+
+
+def get_prev_from_labels(y) -> dict:
+    """
+    Get the real prevalence of each class in the target array.
+    
+    Parameters
+    ----------
+    y : np.ndarray or pd.Series
+        Array of class labels.
+        
+    Returns
+    -------
+    dict
+        Dictionary of class labels and their corresponding prevalence.
+    """
+    if isinstance(y, np.ndarray):
+        y = pd.Series(y)
+    real_prevs = y.value_counts(normalize=True).to_dict()
+    real_prevs = dict(sorted(real_prevs.items()))
+    return real_prevs
+
+
+
+
+
+def normalize_prevalence(prevalences: np.ndarray, classes:list):
+    """
+    Normalize the prevalence of each class to sum to 1.
+    
+    Parameters
+    ----------
+    prevalences : np.ndarray
+        Array of prevalences.
+    classes : list
+        List of unique classes.
+    
+    Returns
+    -------
+    dict
+        Dictionary of class labels and their corresponding prevalence.
+    """
+    if isinstance(prevalences, dict):
+        summ = sum(prevalences.values())
+        prevalences = {int(_class):float(value/summ) for _class, value in prevalences.items()}
+        return prevalences
+    
+    summ = np.sum(prevalences, axis=-1, keepdims=True)
+    prevalences = np.true_divide(prevalences, sum(prevalences), where=summ>0)
+    prevalences = {int(_class):float(prev) for _class, prev in zip(classes, prevalences)}
+    prevalences = defaultdict(lambda: 0, prevalences)
+    
+    # Ensure all classes are present in the result
+    for cls in classes:
+        prevalences[cls] = prevalences[cls]
+    
+    return dict(prevalences)
+

{mlquantify-0.1.7.dist-info → mlquantify-0.1.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mlquantify
-Version: 0.1.7
+Version: 0.1.9
 Summary: Quantification Library
 Home-page: https://github.com/luizfernandolj/QuantifyML/tree/master
 Maintainer: Luiz Fernando Luth Junior
@@ -20,6 +20,7 @@ Requires-Dist: tqdm
 Requires-Dist: pandas
 Requires-Dist: xlrd
 Requires-Dist: matplotlib
+Requires-Dist: abstention
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type

mlquantify-0.1.9.dist-info/RECORD

@@ -0,0 +1,53 @@
+mlquantify/__init__.py,sha256=P48iiVlcAeKeE6wr6yZGMTKwmtCOvQYO4ZUVCKAQMwM,52
+mlquantify/base.py,sha256=o7IaKODocyi4tEmCvGmHKQ8F4ZJsaEh4kymsNcLyHAg,5077
+mlquantify/base_aggregative.py,sha256=uqfhpUmgv5pNLLvqgROCWHfjs3sj_2jfwOTyzUySuGo,7545
+mlquantify/calibration.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+mlquantify/confidence.py,sha256=IUF6sLVmDi4XxX5NvbSFl4-cBbl1mdedtDMFqV-GA48,10918
+mlquantify/multiclass.py,sha256=Jux0fvL5IBZA3DXLCuqUEE77JYYBGAcW6GaEH9srmu4,11747
+mlquantify/adjust_counting/__init__.py,sha256=8qQtTzRAoRiIux_R8wCXopdi6dOg1ESd8oPWv-LvUC0,191
+mlquantify/adjust_counting/_adjustment.py,sha256=BdFwYTwWhwdSxBgu98yTsVyyxgPz_Xm53YEjMxXI8f8,12824
+mlquantify/adjust_counting/_base.py,sha256=abF0lo3fetR77JP87MS7Hy204jF7NYdxwyJWPE5hNyE,9344
+mlquantify/adjust_counting/_counting.py,sha256=n4pBdyntrrxZTu7dWMnCsgN5kz6npU7CNIgRPQLY-nA,5266
+mlquantify/adjust_counting/_utils.py,sha256=wlBrihWKPzzxXmIqowreZ_lN6buD6hFCH98qA3H6s5s,2636
+mlquantify/likelihood/__init__.py,sha256=3dC5uregNmquUKz0r0-3aPspfjZjKGn3TRBoZPO1uFs,53
+mlquantify/likelihood/_base.py,sha256=J6ze15i-TlMMEVl4KvE2_wdam-fq0ZqWl7pSkas35qs,6075
+mlquantify/likelihood/_classes.py,sha256=Xp0hU83mYmfs1AOlmGEYLLsBPZBjPoi2xTx-2H4ztuI,15111
+mlquantify/meta/__init__.py,sha256=GzdGw4ky_kmd5VNWiLBULy06IdN_MLCDAuJKbnMOx4s,62
+mlquantify/meta/_classes.py,sha256=msivgTXvPw6Duq2Uv_odoayX-spZPtuWtD0FQ_8UFdw,29824
+mlquantify/metrics/__init__.py,sha256=3bzzjSYTgrZIJsfAgJidQlB-bnjInwVYUvJ34bPhZxY,186
+mlquantify/metrics/_oq.py,sha256=qTLyKpQkdnyzNOmWjplnLnr7nMDNqlBtfnddo5XHJ48,3542
+mlquantify/metrics/_rq.py,sha256=v0FUepNF-Wj0f1MdB1-9TXSNDze-J0BXUqaTCo5gnUA,3032
+mlquantify/metrics/_slq.py,sha256=nigIpZtPhPYVe5GU3qf1TOxGIkmKOrrhLXAm_tDPaCQ,6808
+mlquantify/mixture/__init__.py,sha256=_KKhpFuvi3vYwxydm5nOy9MKwmIU4eyZDN9Pe00hqtk,70
+mlquantify/mixture/_base.py,sha256=VDAOY6vFM2OayQxN4APysZ-ZycfrUwUS5Zzjr5v2t04,6076
+mlquantify/mixture/_classes.py,sha256=BbBrMIFKWoaP5CjW35agecwl3TE6ZmmBh8kwUyp72Ig,14012
+mlquantify/mixture/_utils.py,sha256=3507D13aw6Xl5Ki5bcC1j8yZH4EqawmtRke9m4AouT4,3049
+mlquantify/model_selection/__init__.py,sha256=98I0uf8k6lbWAjazGyGjbOdPOvzU8aMRLqC3I7D3jzk,113
+mlquantify/model_selection/_protocol.py,sha256=J-96OPJCkwtwk96P962qeztENRwypO__SbDLxM-Myvo,12493
+mlquantify/model_selection/_search.py,sha256=YXeSSJXQVrKjwxfKOKJ9amkXZ1mOPJWKh2x2SQNO5rM,10694
+mlquantify/model_selection/_split.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+mlquantify/neighbors/__init__.py,sha256=rIOuSaUhjqEXsUN9HNZ62P53QG0N7lJ3j1pvf8kJzms,93
+mlquantify/neighbors/_base.py,sha256=tYgq_yjEuqv0dipo2hZW99GxlF09mwpTxlMLV2gYUHo,8258
+mlquantify/neighbors/_classes.py,sha256=zWPn9zhY_Xw3AgC1A112DUO3LrbuKOMvkZU2Cx0elYU,5577
+mlquantify/neighbors/_classification.py,sha256=wzqz6eZpE4AAyBmxv8cjheluoUB_RDYse_mfLCVXfzI,4310
+mlquantify/neighbors/_kde.py,sha256=URCq_o-bSb94_-1jX1Ag-1ZLkP0sBa-D3obAgqN6YYg,9930
+mlquantify/neighbors/_utils.py,sha256=rAu2VuW13rBj935z_m-u0MpfQbLQC0Iq_1WPSnAXZCk,4114
+mlquantify/neural/__init__.py,sha256=chG3GNX2BBDTWIuSVfZUJ_YF_ZVBSoel2d_AN0OChS0,6
+mlquantify/utils/__init__.py,sha256=fCozxFABSv5L7lbD16-J370dbc_xHien3w0crYKPLTc,1344
+mlquantify/utils/_artificial.py,sha256=6tqMoAuxUULFGHXtMez56re4DZ7d2Q6tK55LPGeEiO8,713
+mlquantify/utils/_constraints.py,sha256=r1WDJuqsO3OS2Q45IBKJGtB6iUjcAXMW8USaEakyvCI,5600
+mlquantify/utils/_context.py,sha256=25QmzmfSiuF_hwCjY_7db_XfCnj1dVe4mIbDycVTHf8,661
+mlquantify/utils/_decorators.py,sha256=yYtnPBh1sLSN6wTY-7ZVAV0j--qbpJxBsgncm794JPc,1205
+mlquantify/utils/_exceptions.py,sha256=C3BQSv3-7QDLaorKcV-ANxnBcSaxHQSlCc6YSZrPK6c,392
+mlquantify/utils/_get_scores.py,sha256=VlTvgg_t4D9MzcgsH7YvP_wIL5AZ8XmEtGpbFivdVJk,5280
+mlquantify/utils/_load.py,sha256=cMGXIs-8mUB4blAmagyDNNvAaV2hysRgeInQMl5fDHg,303
+mlquantify/utils/_parallel.py,sha256=XotpX9nsj6nW-tNCmZ-ahTcRztgnn9oQKP2cl1rLdYM,196
+mlquantify/utils/_random.py,sha256=7F3nyy7Pa_kN8xP8P1L6MOM4WFu4BirE7bOfGTZ1Spk,1275
+mlquantify/utils/_sampling.py,sha256=QQxE2WKLdiCFUfPF6fKgzyrsOUIWYf74w_w8fbYVc2c,8409
+mlquantify/utils/_tags.py,sha256=Rz78TLpxgVxBKS0mKTlC9Qo_kn6HaEwVKNXh8pxFT7M,1095
+mlquantify/utils/_validation.py,sha256=dE7NYLy6C5UWf8tXIhQeWLTz2-rej_gr8-aAIwgJTPk,16762
+mlquantify/utils/prevalence.py,sha256=9chdjfUyac7Omxv50Rb_HmfkQFrHfTjGiQPdbVH7FXc,1631
+mlquantify-0.1.9.dist-info/METADATA,sha256=QZUSlEfWxeFGjI8R1QzJx5Y4DeyCiWjFqxFHQzYEIz0,5192
+mlquantify-0.1.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mlquantify-0.1.9.dist-info/top_level.txt,sha256=tGEkYkbbFElwULvqENjam3u1uXtyC1J9dRmibsq8_n0,11
+mlquantify-0.1.9.dist-info/RECORD,,

mlquantify/classification/__init__.py

@@ -1 +0,0 @@
-from .methods import *

mlquantify/evaluation/__init__.py

@@ -1,14 +0,0 @@
-from . import measures
-
-
-MEASURES = {
-    "ae": measures.absolute_error,
-    "mae": measures.mean_absolute_error,
-    "nae": measures.normalized_absolute_error,
-    "kld": measures.kullback_leibler_divergence,
-    "nkld": measures.normalized_kullback_leibler_divergence,
-    "nrae": measures.normalized_relative_absolute_error,
-    "rae": measures.relative_absolute_error,
-    "se": measures.squared_error,
-    "mse": measures.mean_squared_error
-}