pypu-learn 0.0.1__py3-none-any.whl

pypu/__init__.py

@@ -0,0 +1,24 @@
+"""PyPU: positive-unlabeled (PU) learning in Python.
+
+PU learning trains a binary classifier from positive examples and unlabeled examples
+(a mix of positives and negatives), without any example labeled negative. PyPU collects
+PU learning methods behind one scikit-learn style interface: every model is fitted with
+``fit(X, s)``, where ``s[i] == 1`` marks a labeled positive and ``s[i] == 0`` an unlabeled
+sample.
+
+Subpackages
+-----------
+models
+    The PU classifiers, e.g. ``from pypu.models import NaivePU``.
+utils
+    Input validation and helpers shared by the models.
+"""
+
+from pypu.utils import show_versions
+
+try:
+    from pypu._version import __version__
+except ImportError:  # pragma: no cover - only when running from a source tree without installing
+    __version__ = "0.0.0+unknown"
+
+__all__ = ["__version__", "show_versions"]

pypu/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1'
+__version_tuple__ = version_tuple = (0, 0, 1)
+
+__commit_id__ = commit_id = None

pypu/base.py

@@ -0,0 +1,184 @@
+"""Base class shared by every PU classifier in PyPU."""
+
+from __future__ import annotations
+
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+from scipy.special import logit
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.utils.validation import check_consistent_length, check_is_fitted, validate_data
+
+from pypu.utils.validation import check_pu_labels
+
+# Probabilities are clipped to [_EPS, 1 - _EPS] before taking log-odds.
+_EPS = 1e-12
+
+
+class BasePUClassifier(ClassifierMixin, BaseEstimator, metaclass=ABCMeta):
+    """Base class for positive-unlabeled (PU) classifiers.
+
+    Every PU classifier in PyPU follows the scikit-learn estimator API, so it works with
+    :func:`~sklearn.base.clone`, :class:`~sklearn.pipeline.Pipeline` and the model selection
+    tools:
+
+    - ``fit(X, s)`` learns from features ``X`` and PU labels ``s``, where ``s[i] == 1``
+      marks a labeled positive and ``s[i] == 0`` an unlabeled sample (positive or negative).
+    - ``predict_proba(X)`` returns an array of shape ``(n_samples, 2)`` whose second column
+      is the estimated probability of the positive class.
+    - ``decision_function(X)`` returns one score per sample: higher means more likely
+      positive. By default it is the log-odds of the positive-class probability, so ``0``
+      corresponds to a probability of ``0.5``.
+    - ``predict(X)`` returns hard labels in ``{0, 1}``: a sample is predicted positive when
+      its positive-class probability is at least :attr:`threshold_`.
+
+    ``score(X, y)`` (from :class:`~sklearn.base.ClassifierMixin`) computes the accuracy
+    against *true* labels ``y``, not against PU labels.
+
+    Subclasses implement :meth:`_fit` and :meth:`_predict_proba`, and may override
+    :meth:`_decision_function` (to return raw scores) and :meth:`_compute_threshold` (to
+    change the decision threshold). Input validation and the fitted attributes listed below
+    are handled by this class.
+
+    Attributes
+    ----------
+    classes_ : ndarray of shape (2,)
+        The class labels, always ``[0, 1]``.
+    n_features_in_ : int
+        Number of features seen during :meth:`fit`.
+    feature_names_in_ : ndarray of shape (n_features_in_,)
+        Names of features seen during :meth:`fit`. Defined only when ``X`` has feature
+        names that are all strings, e.g. a pandas DataFrame.
+    threshold_ : float
+        Positive-class probability threshold used by :meth:`predict`.
+    """
+
+    def fit(self, X, s):
+        """Fit the model to PU data.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training samples.
+        s : array-like of shape (n_samples,)
+            PU labels: ``1`` for a labeled positive, ``0`` for an unlabeled sample.
+
+        Returns
+        -------
+        self : object
+            The fitted estimator.
+        """
+        X = self._validate_X(X, reset=True)
+        s = check_pu_labels(s)
+        check_consistent_length(X, s)
+        self._fit(X, s)
+        self.classes_ = np.array([0, 1])
+        self.threshold_ = float(self._compute_threshold(X, s))
+        return self
+
+    def predict_proba(self, X):
+        """Estimate class probabilities.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        proba : ndarray of shape (n_samples, 2)
+            Probability of the negative class (column 0) and of the positive class (column 1).
+        """
+        check_is_fitted(self)
+        X = self._validate_X(X, reset=False)
+        proba = np.asarray(self._predict_proba(X), dtype=np.float64).reshape(-1)
+        return np.column_stack([1.0 - proba, proba])
+
+    def decision_function(self, X):
+        """Score samples; higher means more likely positive.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        scores : ndarray of shape (n_samples,)
+            One score per sample.
+        """
+        check_is_fitted(self)
+        X = self._validate_X(X, reset=False)
+        return np.asarray(self._decision_function(X), dtype=np.float64).reshape(-1)
+
+    def predict(self, X):
+        """Predict class labels.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Samples.
+
+        Returns
+        -------
+        y_pred : ndarray of shape (n_samples,)
+            ``1`` for samples whose positive-class probability is at least
+            :attr:`threshold_`, ``0`` otherwise.
+        """
+        proba = self.predict_proba(X)[:, 1]
+        return self.classes_[(proba >= self.threshold_).astype(np.int64)]
+
+    # ------------------------------------------------------------------ hooks for subclasses
+
+    @abstractmethod
+    def _fit(self, X, s):
+        """Fit the model.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Validated training samples (float64 or float32).
+        s : ndarray of shape (n_samples,)
+            Validated PU labels (int64, 1 = labeled positive, 0 = unlabeled).
+        """
+
+    @abstractmethod
+    def _predict_proba(self, X):
+        """Return the positive-class probability of each sample.
+
+        Parameters
+        ----------
+        X : ndarray of shape (n_samples, n_features)
+            Validated samples.
+
+        Returns
+        -------
+        proba : ndarray of shape (n_samples,)
+            Positive-class probabilities, in ``[0, 1]``.
+        """
+
+    def _decision_function(self, X):
+        """Return a score per sample; by default the log-odds of the positive class."""
+        proba = np.clip(self._predict_proba(X), _EPS, 1.0 - _EPS)
+        return logit(proba)
+
+    def _compute_threshold(self, X, s):
+        """Return the probability threshold used by :meth:`predict`; ``0.5`` by default.
+
+        Called at the end of :meth:`fit`, after :meth:`_fit`, with the validated training data.
+        """
+        return 0.5
+
+    def _validate_X(self, X, *, reset):
+        """Validate ``X``; ``reset=True`` in ``fit``, ``False`` when predicting."""
+        return validate_data(self, X, reset=reset, dtype=[np.float64, np.float32])
+
+    # ------------------------------------------------------------------ scikit-learn protocol
+
+    def __sklearn_is_fitted__(self):
+        return hasattr(self, "threshold_")
+
+    def __sklearn_tags__(self):
+        tags = super().__sklearn_tags__()
+        tags.classifier_tags.multi_class = False
+        return tags

pypu/models/__init__.py

@@ -0,0 +1,42 @@
+"""PU learning models.
+
+Every model follows the interface of :class:`pypu.base.BasePUClassifier`::
+
+    from pypu.models import NaivePU
+
+    clf = NaivePU().fit(X_train, s_train)  # s: 1 = labeled positive, 0 = unlabeled
+    proba = clf.predict_proba(X_test)[:, 1]
+
+Models are imported lazily: importing :mod:`pypu.models` does not import the optional
+dependencies (such as PyTorch) of models that are not used.
+"""
+
+from __future__ import annotations
+
+from importlib import import_module
+from typing import TYPE_CHECKING
+
+# Public model name -> module that defines it. Register every new model here, in __all__ and
+# in the TYPE_CHECKING block below (tests check that the three agree).
+_MODELS: dict[str, str] = {
+    "NaivePU": "pypu.models.naive",
+}
+
+__all__ = ["NaivePU"]
+
+if TYPE_CHECKING:
+    from pypu.models.naive import NaivePU
+
+
+def __getattr__(name: str):
+    try:
+        module_name = _MODELS[name]
+    except KeyError:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+    model = getattr(import_module(module_name), name)
+    globals()[name] = model  # later lookups skip __getattr__
+    return model
+
+
+def __dir__():
+    return sorted(set(globals()) | set(_MODELS))

pypu/models/naive.py

@@ -0,0 +1,89 @@
+"""Naive baseline that treats every unlabeled sample as negative."""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.base import clone
+from sklearn.linear_model import LogisticRegression
+
+from pypu.base import BasePUClassifier
+from pypu.utils.validation import check_prior, threshold_from_prior
+
+
+class NaivePU(BasePUClassifier):
+    r"""Naive PU baseline: a classifier trained with unlabeled samples as negatives.
+
+    The wrapped classifier learns to separate labeled positives (``s == 1``) from unlabeled
+    samples (``s == 0``), so it estimates :math:`P(s = 1 \mid x)` rather than
+    :math:`P(y = 1 \mid x)`. Under the SCAR assumption (labeled positives are selected
+    completely at random) the two differ by the constant factor
+    :math:`c = P(s = 1 \mid y = 1)` [1]_: the ranking of samples, and therefore ROC AUC, is
+    preserved, but the probabilities are too low and a ``0.5`` threshold under-predicts
+    positives. Passing the class ``prior`` sets the threshold so that a ``prior`` fraction of
+    the training samples is predicted positive.
+
+    It is the usual lower bound when comparing PU learning methods.
+
+    Parameters
+    ----------
+    estimator : classifier, default=None
+        A scikit-learn classifier implementing ``predict_proba``. It is cloned before
+        fitting. ``None`` uses :class:`~sklearn.linear_model.LogisticRegression`.
+    prior : float, default=None
+        Class prior :math:`\pi = P(y = 1)`. If given, :attr:`threshold_` is set so that a
+        ``prior`` fraction of the training samples is predicted positive. Otherwise the
+        threshold is ``0.5``.
+
+    Attributes
+    ----------
+    estimator_ : classifier
+        The fitted classifier.
+    classes_ : ndarray of shape (2,)
+        The class labels, always ``[0, 1]``.
+    n_features_in_ : int
+        Number of features seen during ``fit``.
+    feature_names_in_ : ndarray of shape (n_features_in_,)
+        Names of features seen during ``fit``, when ``X`` has string feature names.
+    threshold_ : float
+        Positive-class probability threshold used by ``predict``.
+
+    References
+    ----------
+    .. [1] C. Elkan and K. Noto. "Learning classifiers from only positive and unlabeled
+       data." KDD 2008.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearn.datasets import make_classification
+    >>> from pypu.models import NaivePU
+    >>> X, y = make_classification(n_samples=500, weights=[0.7], random_state=0)
+    >>> rng = np.random.default_rng(0)
+    >>> s = ((y == 1) & (rng.random(len(y)) < 0.5)).astype(int)  # label half the positives
+    >>> clf = NaivePU(prior=y.mean()).fit(X, s)
+    >>> clf.predict_proba(X).shape
+    (500, 2)
+    """
+
+    def __init__(self, estimator=None, prior=None):
+        self.estimator = estimator
+        self.prior = prior
+
+    def _fit(self, X, s):
+        if self.prior is not None:
+            check_prior(self.prior, s)
+        estimator = LogisticRegression() if self.estimator is None else clone(self.estimator)
+        if not hasattr(estimator, "predict_proba"):
+            raise TypeError(
+                f"estimator must implement predict_proba; {type(estimator).__name__} does not."
+            )
+        self.estimator_ = estimator.fit(X, s)
+
+    def _predict_proba(self, X):
+        positive_column = np.flatnonzero(self.estimator_.classes_ == 1)[0]
+        return self.estimator_.predict_proba(X)[:, positive_column]
+
+    def _compute_threshold(self, X, s):
+        if self.prior is None:
+            return 0.5
+        return threshold_from_prior(self._predict_proba(X), self.prior)

pypu/utils/__init__.py

@@ -0,0 +1,6 @@
+"""Utilities shared by the PyPU models."""
+
+from pypu.utils._show_versions import show_versions
+from pypu.utils.validation import check_prior, check_pu_labels, threshold_from_prior
+
+__all__ = ["check_prior", "check_pu_labels", "show_versions", "threshold_from_prior"]

pypu/utils/_show_versions.py

@@ -0,0 +1,27 @@
+"""Print the versions of PyPU and its dependencies, for bug reports."""
+
+from __future__ import annotations
+
+import platform
+import sys
+from importlib.metadata import PackageNotFoundError, version
+
+# Distributions reported by show_versions: core dependencies first, then optional ones.
+_DEPENDENCIES = ("numpy", "scipy", "scikit-learn", "lightgbm", "xgboost", "torch", "pyod")
+
+
+def show_versions() -> None:
+    """Print the versions of PyPU, Python and the main dependencies.
+
+    Include this output when reporting a bug.
+    """
+    import pypu
+
+    print(f"pypu: {pypu.__version__}")
+    print(f"python: {sys.version.split()[0]} ({platform.platform()})")
+    for dist in _DEPENDENCIES:
+        try:
+            dist_version = version(dist)
+        except PackageNotFoundError:
+            dist_version = "not installed"
+        print(f"{dist}: {dist_version}")

pypu/utils/validation.py

@@ -0,0 +1,120 @@
+"""Validation of PU labels and class priors."""
+
+from __future__ import annotations
+
+import numbers
+import warnings
+
+import numpy as np
+from sklearn.utils.multiclass import type_of_target
+from sklearn.utils.validation import column_or_1d
+
+_PU_LABELS_HINT = "PU labels must be 1 (labeled positive) or 0 (unlabeled)"
+
+
+def check_pu_labels(s) -> np.ndarray:
+    """Validate PU labels.
+
+    Parameters
+    ----------
+    s : array-like of shape (n_samples,)
+        PU labels: ``1`` for a labeled positive, ``0`` for an unlabeled sample.
+        Booleans are accepted (``True`` means labeled positive).
+
+    Returns
+    -------
+    s : ndarray of shape (n_samples,), dtype int64
+        The validated labels.
+
+    Raises
+    ------
+    ValueError
+        If the labels are not 0/1, or if there is no labeled positive or no unlabeled sample.
+    """
+    s = column_or_1d(s, warn=True)
+    if s.size == 0:
+        raise ValueError("PU labels are empty.")
+    # Same error wording as scikit-learn for non-binary targets.
+    target_type = type_of_target(s, input_name="s", raise_unknown=True)
+    if target_type == "continuous":
+        raise ValueError(f"Unknown label type: continuous. {_PU_LABELS_HINT}.")
+
+    values = np.unique(s)
+    if target_type == "multiclass":
+        raise ValueError(
+            f"Only binary classification is supported. {_PU_LABELS_HINT}, got values "
+            f"{values[:10].tolist()}."
+        )
+    if s.dtype.kind not in "biuf" or not np.isin(values, (0, 1)).all():
+        raise ValueError(
+            f"{_PU_LABELS_HINT}, got values {values[:10].tolist()}. If unlabeled samples are "
+            "encoded as -1, map them to 0."
+        )
+    if values.size < 2:
+        missing = "labeled positive (s == 1)" if values[0] == 0 else "unlabeled sample (s == 0)"
+        raise ValueError(f"PU labels contain only one class: there is no {missing}.")
+    return s.astype(np.int64)
+
+
+def check_prior(prior, s=None) -> float:
+    r"""Validate a class prior :math:`\pi = P(y = 1)`.
+
+    Parameters
+    ----------
+    prior : float
+        The class prior, in the open interval ``(0, 1)``.
+    s : array-like of shape (n_samples,), default=None
+        Validated PU labels. When given, a warning is raised if ``prior`` is lower than the
+        fraction of labeled positives, which is impossible when the labeled positives are
+        drawn from the same sample as the unlabeled data.
+
+    Returns
+    -------
+    prior : float
+        The validated prior.
+
+    Raises
+    ------
+    TypeError
+        If ``prior`` is not a real number.
+    ValueError
+        If ``prior`` is not in ``(0, 1)``.
+    """
+    if isinstance(prior, bool) or not isinstance(prior, numbers.Real):
+        raise TypeError(f"prior must be a float in (0, 1), got {prior!r}.")
+    prior = float(prior)
+    if not 0.0 < prior < 1.0:
+        raise ValueError(f"prior must be in the open interval (0, 1), got {prior}.")
+    if s is not None:
+        labeled_fraction = float(np.mean(s))
+        if prior < labeled_fraction:
+            warnings.warn(
+                f"prior={prior} is lower than the fraction of labeled positives "
+                f"({labeled_fraction:.4f}). When the labeled positives come from the same sample "
+                "as the unlabeled data the prior cannot be lower than that fraction: check that "
+                "you passed the class prior P(y=1) and not the label frequency P(s=1 | y=1).",
+                UserWarning,
+                stacklevel=2,
+            )
+    return prior
+
+
+def threshold_from_prior(scores, prior: float) -> float:
+    """Return the threshold that labels the top ``prior`` fraction of ``scores`` positive.
+
+    Parameters
+    ----------
+    scores : array-like of shape (n_samples,)
+        Scores where higher means more likely positive (e.g. positive-class probabilities).
+    prior : float
+        Fraction of samples to label positive, in ``(0, 1)``.
+
+    Returns
+    -------
+    threshold : float
+        The ``1 - prior`` quantile of ``scores``; samples with ``score >= threshold``
+        are labeled positive.
+    """
+    prior = check_prior(prior)
+    scores = np.asarray(scores, dtype=np.float64).reshape(-1)
+    return float(np.quantile(scores, 1.0 - prior))

pypu_learn-0.0.1.dist-info/METADATA

@@ -0,0 +1,137 @@
+Metadata-Version: 2.5
+Name: pypu-learn
+Version: 0.0.1
+Summary: Positive-unlabeled (PU) learning in Python, with a scikit-learn style API.
+Project-URL: Homepage, https://github.com/izavits/PyPU
+Project-URL: Repository, https://github.com/izavits/PyPU
+Project-URL: Issues, https://github.com/izavits/PyPU/issues
+Project-URL: Changelog, https://github.com/izavits/PyPU/blob/main/CHANGELOG.md
+Author: Ilias Zavitsanos
+License-Expression: BSD-3-Clause
+License-File: LICENSE
+Keywords: machine-learning,positive-unlabeled,pu-learning,scikit-learn,semi-supervised,weak-supervision
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: scikit-learn>=1.6
+Requires-Dist: scipy>=1.11
+Description-Content-Type: text/markdown
+
+# PyPU
+
+**Positive-unlabeled (PU) learning in Python, with a scikit-learn style API.**
+
+[![CI](https://github.com/izavits/PyPU/actions/workflows/ci.yml/badge.svg)](https://github.com/izavits/PyPU/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/pypu-learn.svg)](https://pypi.org/project/pypu-learn/)
+[![Python versions](https://img.shields.io/pypi/pyversions/pypu-learn.svg)](https://pypi.org/project/pypu-learn/)
+[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://github.com/izavits/PyPU/blob/main/LICENSE)
+
+> **Status: pre-alpha.** The common interface is in place and the methods are being ported.
+> See the [roadmap](https://github.com/izavits/PyPU/blob/main/ROADMAP.md).
+
+In PU learning the training data hold some examples labeled positive and many unlabeled
+examples, which are a mix of positives and negatives. No example is labeled negative. This
+happens whenever only one class gets recorded: confirmed frauds, known disease genes, reported
+misstatements, clicked items.
+
+PyPU collects PU learning methods behind one interface, in the spirit of
+[PyOD](https://github.com/yzhao062/pyod) for outlier detection: import a model, `fit` it on
+PU data, and predict on new data.
+
+## Installation
+
+```bash
+pip install pypu-learn
+```
+
+The package is imported as `pypu` and needs Python 3.11 or newer. (The PyPI name `pypu`
+belongs to an unrelated project, hence `pypu-learn`.)
+
+Until the first release is on PyPI, install from GitHub:
+
+```bash
+pip install git+https://github.com/izavits/PyPU.git
+```
+
+## Quick start
+
+```python
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.metrics import roc_auc_score
+from sklearn.model_selection import train_test_split
+
+from pypu.models import NaivePU
+
+# A fully labeled dataset...
+X, y = make_classification(n_samples=2000, weights=[0.8], random_state=0)
+X_train, X_test, y_train, y_test = train_test_split(X, y, stratify=y, random_state=0)
+
+# ...turned into PU data: label half of the training positives, leave the rest unlabeled.
+rng = np.random.default_rng(0)
+s_train = ((y_train == 1) & (rng.random(len(y_train)) < 0.5)).astype(int)
+
+clf = NaivePU(prior=y_train.mean())
+clf.fit(X_train, s_train)  # s = 1: labeled positive, s = 0: unlabeled
+
+scores = clf.predict_proba(X_test)[:, 1]
+print("ROC AUC:", roc_auc_score(y_test, scores))
+```
+
+Data utilities that turn labeled datasets into PU data in one call are coming in 0.1.0.
+
+## The interface
+
+Every model derives from `pypu.base.BasePUClassifier` and is a scikit-learn estimator, so it
+works with `clone`, `Pipeline` and `GridSearchCV`.
+
+| Method | Returns |
+| --- | --- |
+| `fit(X, s)` | The fitted model. `s[i] = 1` marks a labeled positive, `s[i] = 0` an unlabeled sample. |
+| `predict_proba(X)` | An `(n_samples, 2)` array; column 1 is the positive-class probability. |
+| `decision_function(X)` | One score per sample; higher means more likely positive. |
+| `predict(X)` | Labels in `{0, 1}`, thresholding the positive-class probability at `threshold_`. |
+
+Models that need the class prior π = P(y = 1) take it as a `prior` parameter.
+
+## Methods
+
+| Model | Description | Status |
+| --- | --- | --- |
+| `NaivePU` | Treats unlabeled samples as negatives; the usual lower bound | available |
+| `IFPU` | Focal-loss PU risk with gradient boosting | planned (0.1.0) |
+| `IFPNU` | Anomaly detector picks reliable negatives, then a focal PNU risk with gradient boosting | planned (0.1.0) |
+| `SAREM` | EM for labels selected at random (SAR) | planned (0.1.0) |
+| `ElkanNoto`, `PUBagging` | Classic PU baselines | planned (0.1.0) |
+| `PUHellingerTree`, `PUHellingerForest` | Hellinger-distance decision trees and forests for PU data | planned (0.2.0) |
+| `NNPU`, `LBE`, `PUe`, `ALMPU` | Neural PU methods (optional PyTorch dependency) | planned (0.3.0) |
+
+Also planned: creating PU data from labeled datasets (uniform SCAR selection, KNN-biased and
+other SAR selection mechanisms), class-prior estimation, and PU-specific metrics.
+
+## Contributing
+
+Contributions are welcome. See
+[CONTRIBUTING.md](https://github.com/izavits/PyPU/blob/main/CONTRIBUTING.md) for the
+development setup, how to add a model, and the release process. Changes are listed in
+[CHANGELOG.md](https://github.com/izavits/PyPU/blob/main/CHANGELOG.md).
+
+## Citing
+
+If you use PyPU in your research, please cite it; GitHub's "Cite this repository" button uses
+[CITATION.cff](https://github.com/izavits/PyPU/blob/main/CITATION.cff).
+
+## License
+
+PyPU is distributed under the
+[BSD 3-Clause License](https://github.com/izavits/PyPU/blob/main/LICENSE).

pypu_learn-0.0.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+pypu/__init__.py,sha256=jQpD4zxbfx6oNWpMpQwf_WBPLBkBLb9kMke1X33xGUA,839
+pypu/_version.py,sha256=8OsTLsIVB9D0HdPTmt5rVwyVUBe9xTVGkRslXicxzkM,520
+pypu/base.py,sha256=7m-uVcrY1MybqpmF_B55h64b-iZOiCZKHN_nS-mm8nk,6581
+pypu/models/__init__.py,sha256=5BIn2dKwYsEXtaqfCJAjMCustsN29-iShQSZZyAnNsA,1221
+pypu/models/naive.py,sha256=pckviwY6gzcGq_9vd5Yav68I63jhBX6_sVPr83aEvVQ,3607
+pypu/utils/__init__.py,sha256=k89kme_ki-1m_74aef-xGNeEDBVWY-l7VSIG1WIVOmQ,268
+pypu/utils/_show_versions.py,sha256=F2lLrp9oDNFw_ys7_yXy8S1TirSLc_Wc_gvY9Kx7mdk,865
+pypu/utils/validation.py,sha256=k6Fb31s4Sqez2dJNg8Csy1cEowrGNkxNssekPr9cOL8,4225
+pypu_learn-0.0.1.dist-info/METADATA,sha256=K4wm80yqIKkqz79FEQ9ZY8mZnGgjUKvOBdeNLkS8l6c,5897
+pypu_learn-0.0.1.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+pypu_learn-0.0.1.dist-info/licenses/LICENSE,sha256=5QchMJ0UqJ3ORojl0D3c_skp3PlswPioxsTF3pEjV6g,1524
+pypu_learn-0.0.1.dist-info/RECORD,,

pypu_learn-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pypu_learn-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2026, Ilias Zavitsanos
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.