parzen_window 0.0.2__py3-none-any.whl

parzen_window/__init__.py

@@ -0,0 +1,7 @@
+from .core import ParzenWindowClassifier
+
+__author__ = "Andrey Ferubko"
+__version__ = "0.0.2"
+__email__ = "ferubko1999@yandex.ru"
+
+__all__ = ["ParzenWindowClassifier"]

parzen_window/compaction.py

@@ -0,0 +1,83 @@
+"""Dataset compaction via convex-neighborhood analysis.
+
+A training point contributes almost nothing to the decision boundary when
+it is (a) surrounded entirely by same-class neighbors -- i.e. it sits deep
+inside a convex, single-class neighborhood -- and (b) far from the nearest
+point of any other class. Such points are safe to drop to free up memory,
+since the kernel weight they contribute is dominated by points closer to
+the actual boundary.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from sklearn.neighbors import NearestNeighbors
+
+
+def compute_removal_scores(X: np.ndarray, y: np.ndarray, n_neighbors: int) -> np.ndarray:
+    """Score each point by how safe it is to remove (higher = safer).
+
+    A point scores 0 (never removed) unless all of its ``n_neighbors``
+    nearest neighbors share its label; otherwise its score is the distance
+    to the nearest point of a *different* class -- a proxy for how far it
+    sits from the decision boundary.
+    """
+    n_samples = len(X)
+    k = min(n_neighbors, n_samples - 1)
+    if k < 1:
+        return np.zeros(n_samples)
+
+    neighbors = NearestNeighbors(n_neighbors=k + 1).fit(X)
+    _, indices = neighbors.kneighbors(X)
+    indices = indices[:, 1:]  # drop the point itself (distance 0)
+    homogeneous = (y[indices] == y[:, None]).all(axis=1)
+
+    margin = np.zeros(n_samples)
+    for label in np.unique(y):
+        own, other = y == label, y != label
+        if not other.any() or not own.any():
+            continue
+        boundary = NearestNeighbors(n_neighbors=1).fit(X[other])
+        boundary_distance, _ = boundary.kneighbors(X[own])
+        margin[own] = boundary_distance[:, 0]
+
+    return np.where(homogeneous, margin, 0.0)
+
+
+def select_points_to_remove(
+    X: np.ndarray,
+    y: np.ndarray,
+    reduction_fraction: float,
+    n_neighbors: int = 5,
+    min_per_class: int = 2,
+) -> np.ndarray:
+    """Pick indices that can be dropped without touching the decision boundary.
+
+    Points are removed greedily, safest (highest score) first, until either
+    ``reduction_fraction`` of the dataset has been removed, points with a
+    zero score are reached (mixed neighborhood or near the boundary), or a
+    class would drop below ``min_per_class`` remaining points.
+    """
+    if not 0.0 < reduction_fraction < 1.0:
+        raise ValueError("reduction_fraction must be in (0, 1)")
+
+    n_samples = len(X)
+    target_removals = int(n_samples * reduction_fraction)
+    if target_removals <= 0:
+        return np.array([], dtype=int)
+
+    scores = compute_removal_scores(X, y, n_neighbors)
+    order = np.argsort(scores)[::-1]
+    remaining_per_class = {label: int(np.sum(y == label)) for label in np.unique(y)}
+
+    to_remove = []
+    for idx in order:
+        if len(to_remove) >= target_removals or scores[idx] <= 0:
+            break
+        label = y[idx]
+        if remaining_per_class[label] - 1 < min_per_class:
+            continue
+        remaining_per_class[label] -= 1
+        to_remove.append(idx)
+
+    return np.array(sorted(to_remove), dtype=int)

parzen_window/core.py

@@ -0,0 +1,219 @@
+"""Parzen window classifier with incremental updates, compaction and persistence."""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.spatial.distance import cdist
+from sklearn.base import BaseEstimator, ClassifierMixin
+from sklearn.neighbors import NearestNeighbors
+from sklearn.utils.validation import check_array, check_is_fitted
+
+from . import io as _io
+from .compaction import select_points_to_remove
+from .kernels import resolve_kernel
+from .scheduler import CompactionScheduler
+
+_NOT_FITTED_MSG = "This ParzenWindowClassifier instance is not fitted yet. Call fit() first."
+
+
+class ParzenWindowClassifier(BaseEstimator, ClassifierMixin):
+    """Non-parametric classifier based on the Parzen window method.
+
+    Parameters
+    ----------
+    h : float, default=0.5
+        Kernel bandwidth. Used as-is when ``adaptive_bandwidth=False``; used
+        as a scale factor on the per-point bandwidth when it is ``True``.
+    kernel : {"gaussian", "epanechnikov", "quartic", "triangular", "rectangular"}
+        Kernel function shape.
+    adaptive_bandwidth : bool, default=False
+        When ``True``, each training point gets its own bandwidth equal to
+        ``h`` times its distance to its ``bandwidth_neighbors``-th nearest
+        neighbor, instead of a single global ``h``. This lets the kernel
+        widen in sparse regions and narrow in dense ones (a variable-kernel
+        / "balloon" estimator), which the fixed-bandwidth Parzen window
+        cannot do.
+    bandwidth_neighbors : int, default=5
+        Number of neighbors used to derive the adaptive bandwidth. Ignored
+        when ``adaptive_bandwidth=False``.
+    """
+
+    def __init__(
+        self,
+        h: float = 0.5,
+        kernel: str = "gaussian",
+        adaptive_bandwidth: bool = False,
+        bandwidth_neighbors: int = 5,
+    ):
+        self.h = h
+        self.kernel = kernel
+        self.adaptive_bandwidth = adaptive_bandwidth
+        self.bandwidth_neighbors = bandwidth_neighbors
+        self._scheduler = CompactionScheduler()
+        self._bandwidth_cache = None
+
+    # -- persistence-related plumbing --------------------------------
+
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop("_scheduler", None)
+        return state
+
+    def __setstate__(self, state):
+        self.__dict__.update(state)
+        self._scheduler = CompactionScheduler()
+
+    @property
+    def is_compacting(self) -> bool:
+        return self._scheduler.is_compacting
+
+    # -- fitting --------------------------------------------------------
+
+    def fit(self, X, y):
+        """(Re)fit the model from scratch, discarding any previous data."""
+        X = check_array(X)
+        y = np.asarray(y)
+        return self._scheduler.call(self._fit_impl, X, y)
+
+    def _fit_impl(self, X, y):
+        self.X_train_ = X
+        self.y_train_ = y
+        self.classes_ = np.unique(y)
+        self._bandwidth_cache = None
+        return self
+
+    def partial_fit(self, X, y):
+        """Incrementally fit the model on a new batch, keeping prior data.
+
+        While a :meth:`compact` call is in progress on another thread, this
+        call does not fail -- it is queued and applied automatically right
+        after compaction finishes.
+        """
+        check_is_fitted(self, "X_train_", msg=_NOT_FITTED_MSG)
+        X = check_array(X)
+        y = np.asarray(y)
+        return self._scheduler.call(self._partial_fit_impl, X, y)
+
+    def _partial_fit_impl(self, X, y):
+        self.X_train_ = np.vstack([self.X_train_, X])
+        self.y_train_ = np.concatenate([self.y_train_, y])
+        self.classes_ = np.unique(self.y_train_)
+        self._bandwidth_cache = None
+        return self
+
+    # -- inference --------------------------------------------------------
+
+    def predict(self, X):
+        """Predict class labels. Queued automatically if compaction is running."""
+        check_is_fitted(self, "X_train_", msg=_NOT_FITTED_MSG)
+        X = check_array(X)
+        return self._scheduler.call(self._predict_impl, X)
+
+    def _predict_impl(self, X):
+        scores = self._class_scores(X)
+        return self.classes_[np.argmax(scores, axis=1)]
+
+    def predict_proba(self, X):
+        """Predict per-class weights normalized to sum to 1 for each sample."""
+        check_is_fitted(self, "X_train_", msg=_NOT_FITTED_MSG)
+        X = check_array(X)
+        return self._scheduler.call(self._predict_proba_impl, X)
+
+    def _predict_proba_impl(self, X):
+        scores = self._class_scores(X)
+        totals = scores.sum(axis=1, keepdims=True)
+        totals[totals == 0] = 1.0  # query point has ~zero kernel weight everywhere
+        return scores / totals
+
+    def _class_scores(self, X):
+        kernel_fn = resolve_kernel(self.kernel)
+        distances = cdist(X, self.X_train_)
+        kernel_values = kernel_fn(distances / self._bandwidth())
+        scores = np.zeros((len(X), len(self.classes_)))
+        for i, label in enumerate(self.classes_):
+            scores[:, i] = kernel_values[:, self.y_train_ == label].sum(axis=1)
+        return scores
+
+    def _bandwidth(self):
+        if not self.adaptive_bandwidth:
+            return self.h
+        if self._bandwidth_cache is None:
+            self._bandwidth_cache = self._compute_adaptive_bandwidth()
+        return self._bandwidth_cache
+
+    def _compute_adaptive_bandwidth(self):
+        n_samples = len(self.X_train_)
+        k = min(self.bandwidth_neighbors, n_samples - 1)
+        if k < 1:
+            return np.full(n_samples, self.h)
+        neighbors = NearestNeighbors(n_neighbors=k + 1).fit(self.X_train_)
+        distances, _ = neighbors.kneighbors(self.X_train_)
+        bandwidth = self.h * distances[:, -1]
+        bandwidth[bandwidth == 0] = self.h
+        return bandwidth
+
+    # -- memory management --------------------------------------------------------
+
+    def compact(
+        self, reduction_fraction: float, n_neighbors: int = 5, min_per_class: int = 2
+    ) -> int:
+        """Drop training points that lie deep inside their own class's territory.
+
+        Uses convex-neighborhood analysis (see :mod:`parzen_window.compaction`)
+        to find points that are both surrounded entirely by same-class
+        neighbors and far from the decision boundary, then removes up to
+        ``reduction_fraction`` of the dataset. While this runs, other threads'
+        ``predict``/``partial_fit`` calls are queued and executed automatically
+        as soon as compaction completes, instead of failing.
+
+        Returns the number of points actually removed.
+        """
+        check_is_fitted(self, "X_train_", msg=_NOT_FITTED_MSG)
+        return self._scheduler.run_exclusively(
+            self._compact_impl, reduction_fraction, n_neighbors, min_per_class
+        )
+
+    def _compact_impl(self, reduction_fraction, n_neighbors, min_per_class):
+        to_remove = select_points_to_remove(
+            self.X_train_, self.y_train_, reduction_fraction, n_neighbors, min_per_class
+        )
+        if len(to_remove) == 0:
+            return 0
+        mask = np.ones(len(self.X_train_), dtype=bool)
+        mask[to_remove] = False
+        self.X_train_ = self.X_train_[mask]
+        self.y_train_ = self.y_train_[mask]
+        self._bandwidth_cache = None
+        return len(to_remove)
+
+    # -- persistence --------------------------------------------------------
+
+    def save(self, path) -> None:
+        """Save model weights to a ``.npz`` file for backup or transfer."""
+        check_is_fitted(self, "X_train_", msg=_NOT_FITTED_MSG)
+        self._scheduler.call(
+            _io.save_npz,
+            path,
+            h=self.h,
+            kernel=self.kernel,
+            adaptive_bandwidth=self.adaptive_bandwidth,
+            bandwidth_neighbors=self.bandwidth_neighbors,
+            X_train=self.X_train_,
+            y_train=self.y_train_,
+            classes=self.classes_,
+        )
+
+    @classmethod
+    def load(cls, path) -> ParzenWindowClassifier:
+        """Load a model previously saved with :meth:`save`."""
+        data = _io.load_npz(path)
+        model = cls(
+            h=data["h"],
+            kernel=data["kernel"],
+            adaptive_bandwidth=data["adaptive_bandwidth"],
+            bandwidth_neighbors=data["bandwidth_neighbors"],
+        )
+        model.X_train_ = data["X_train"]
+        model.y_train_ = data["y_train"]
+        model.classes_ = data["classes"]
+        return model

parzen_window/io.py

@@ -0,0 +1,33 @@
+"""Persisting model weights to/from ``.npz`` files for backups and transfer."""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def save_npz(
+    path, *, h, kernel, adaptive_bandwidth, bandwidth_neighbors, X_train, y_train, classes
+) -> None:
+    np.savez(
+        path,
+        h=np.asarray(h),
+        kernel=np.asarray(kernel),
+        adaptive_bandwidth=np.asarray(adaptive_bandwidth),
+        bandwidth_neighbors=np.asarray(bandwidth_neighbors),
+        X_train=X_train,
+        y_train=y_train,
+        classes=classes,
+    )
+
+
+def load_npz(path) -> dict:
+    with np.load(path, allow_pickle=False) as data:
+        return {
+            "h": float(data["h"]),
+            "kernel": str(data["kernel"]),
+            "adaptive_bandwidth": bool(data["adaptive_bandwidth"]),
+            "bandwidth_neighbors": int(data["bandwidth_neighbors"]),
+            "X_train": data["X_train"],
+            "y_train": data["y_train"],
+            "classes": data["classes"],
+        }

parzen_window/kernels.py

@@ -0,0 +1,45 @@
+"""Kernel functions used by :class:`parzen_window.core.ParzenWindowClassifier`.
+
+Every kernel accepts a numpy array of normalized distances ``u = distance / h``
+and returns the corresponding weight, vectorized over arrays of any shape.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+
+def gaussian(u: np.ndarray) -> np.ndarray:
+    return np.exp(-0.5 * u**2) / np.sqrt(2 * np.pi)
+
+
+def epanechnikov(u: np.ndarray) -> np.ndarray:
+    return np.where(np.abs(u) <= 1, 0.75 * (1 - u**2), 0.0)
+
+
+def quartic(u: np.ndarray) -> np.ndarray:
+    return np.where(np.abs(u) <= 1, (15.0 / 16.0) * (1 - u**2) ** 2, 0.0)
+
+
+def triangular(u: np.ndarray) -> np.ndarray:
+    return np.where(np.abs(u) <= 1, 1 - np.abs(u), 0.0)
+
+
+def rectangular(u: np.ndarray) -> np.ndarray:
+    return np.where(np.abs(u) <= 1, 0.5, 0.0)
+
+
+KERNELS = {
+    "gaussian": gaussian,
+    "epanechnikov": epanechnikov,
+    "quartic": quartic,
+    "triangular": triangular,
+    "rectangular": rectangular,
+}
+
+
+def resolve_kernel(name: str):
+    try:
+        return KERNELS[name]
+    except KeyError as exc:
+        raise ValueError(f"Unknown kernel {name!r}. Supported kernels: {sorted(KERNELS)}") from exc

parzen_window/scheduler.py

@@ -0,0 +1,82 @@
+"""Thread-safety around dataset compaction.
+
+While :meth:`~parzen_window.core.ParzenWindowClassifier.compact` runs, the
+training set is being rewritten in place, so calls to ``predict`` or
+``partial_fit`` made from other threads cannot run concurrently with it.
+Rather than failing, such calls are queued and executed automatically, in
+arrival order, right after compaction finishes -- acting as a small
+scheduler for deferred work.
+"""
+
+from __future__ import annotations
+
+import threading
+from collections import deque
+from collections.abc import Callable
+
+
+class _PendingCall:
+    __slots__ = ("_func", "_args", "_kwargs", "_done", "_result", "_error")
+
+    def __init__(self, func: Callable, args: tuple, kwargs: dict):
+        self._func = func
+        self._args = args
+        self._kwargs = kwargs
+        self._done = threading.Event()
+        self._result = None
+        self._error = None
+
+    def run(self) -> None:
+        try:
+            self._result = self._func(*self._args, **self._kwargs)
+        except Exception as error:  # re-raised in the waiting thread
+            self._error = error
+        finally:
+            self._done.set()
+
+    def wait(self):
+        self._done.wait()
+        if self._error is not None:
+            raise self._error
+        return self._result
+
+
+class CompactionScheduler:
+    """Serializes access to model data and defers calls during compaction."""
+
+    def __init__(self) -> None:
+        self._lock = threading.RLock()
+        self._compacting = threading.Event()
+        self._queue: deque[_PendingCall] = deque()
+        self._queue_lock = threading.Lock()
+
+    @property
+    def is_compacting(self) -> bool:
+        return self._compacting.is_set()
+
+    def call(self, func: Callable, *args, **kwargs):
+        """Run ``func`` now, or queue it while compaction is in progress."""
+        if self._compacting.is_set():
+            pending = _PendingCall(func, args, kwargs)
+            with self._queue_lock:
+                self._queue.append(pending)
+            return pending.wait()
+        with self._lock:
+            return func(*args, **kwargs)
+
+    def run_exclusively(self, func: Callable, *args, **kwargs):
+        """Run ``func`` (compaction) with exclusive access to the data."""
+        with self._lock:
+            self._compacting.set()
+            try:
+                return func(*args, **kwargs)
+            finally:
+                self._compacting.clear()
+                self._drain_queue()
+
+    def _drain_queue(self) -> None:
+        with self._queue_lock:
+            pending_calls = list(self._queue)
+            self._queue.clear()
+        for pending in pending_calls:
+            pending.run()

parzen_window-0.0.2.dist-info/METADATA

@@ -0,0 +1,224 @@
+Metadata-Version: 2.5
+Name: parzen_window
+Version: 0.0.2
+Summary: Parzen window classification with incremental learning, memory-efficient compaction and adaptive bandwidth.
+Project-URL: Homepage, https://github.com/89605502155/parzen_window
+Project-URL: Download, https://github.com/89605502155/parzen_window/archive/main.zip
+Author-email: Andrey Ferubko <ferubko1999@yandex.ru>
+License: MIT
+License-File: LICENSE
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Requires-Python: >=3.10
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Description-Content-Type: text/markdown
+
+# parzen_window
+
+[Русский](#русский) | [English](#english)
+
+---
+
+## English
+
+`parzen_window` is a Python library implementing the Parzen window method for
+classification, built on top of `numpy` and `scikit-learn` (`BaseEstimator`,
+`ClassifierMixin`).
+
+### Features
+
+- Five kernel shapes: `gaussian`, `epanechnikov`, `quartic`, `triangular`, `rectangular`.
+- **Adaptive bandwidth** — each training point can get its own kernel width,
+  derived from the distance to its `k`-th nearest neighbor, instead of a
+  single fixed `h` for the whole dataset (a variable-kernel / "balloon"
+  estimator). This is the library's scientific contribution over plain
+  fixed-bandwidth Parzen window implementations: it widens the kernel in
+  sparse regions and narrows it in dense ones automatically.
+- **Incremental learning** — `partial_fit()` extends the model with a new
+  batch of data without discarding what it already learned.
+- **Dataset compaction** — `compact()` reduces memory usage by removing
+  training points that are deep inside their own class's territory (found
+  via convex-neighborhood analysis: a point is dropped only if all its
+  nearest neighbors share its label *and* it is far from the nearest point
+  of a different class). This shrinks the stored dataset with minimal
+  impact on the decision boundary.
+- **Thread-safe compaction with a call scheduler** — while `compact()` is
+  running, the training data is locked for writes. `predict()` and
+  `partial_fit()` calls from other threads do not fail during this time:
+  they are queued and executed automatically as soon as compaction
+  finishes.
+- **`.npz` persistence** — `save()`/`load()` for backups and moving a model
+  between machines.
+- Fully compatible with `pickle`/`joblib`.
+
+### Installation
+
+```bash
+pip install parzen_window
+```
+
+### Quick start
+
+```python
+from parzen_window import ParzenWindowClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+model = ParzenWindowClassifier(h=1.0, kernel="quartic")
+model.fit(X_train, y_train)
+predictions = model.predict(X_test)
+probabilities = model.predict_proba(X_test)
+```
+
+Incremental learning:
+
+```python
+model = ParzenWindowClassifier(h=0.5, kernel="gaussian")
+model.fit(X_batch_1, y_batch_1)
+model.partial_fit(X_batch_2, y_batch_2)  # extends, does not discard X_batch_1
+```
+
+Adaptive bandwidth:
+
+```python
+model = ParzenWindowClassifier(
+    h=1.0, kernel="gaussian", adaptive_bandwidth=True, bandwidth_neighbors=5
+)
+model.fit(X_train, y_train)
+```
+
+Compacting a large dataset to cut memory usage by ~25%:
+
+```python
+removed = model.compact(0.25)  # returns the number of points actually removed
+```
+
+Backups:
+
+```python
+model.save("model.npz")
+restored = ParzenWindowClassifier.load("model.npz")
+```
+
+### Development
+
+The project uses [uv](https://docs.astral.sh/uv/) for dependency management.
+
+```bash
+uv sync --dev        # install dependencies
+uv run ruff check .  # lint
+uv run ruff format .  # format
+uv build              # build sdist + wheel
+```
+
+---
+
+## Русский
+
+`parzen_window` — библиотека на Python, реализующая метод Парзеновского окна
+для классификации, построенная поверх `numpy` и `scikit-learn`
+(`BaseEstimator`, `ClassifierMixin`).
+
+### Возможности
+
+- Пять видов ядер: `gaussian`, `epanechnikov`, `quartic`, `triangular`, `rectangular`.
+- **Адаптивная ширина окна** — каждая точка обучающей выборки может получить
+  собственную ширину ядра, вычисленную по расстоянию до её `k`-го ближайшего
+  соседа, вместо единого фиксированного `h` на весь датасет (вариант
+  variable-kernel / "balloon"-оценки). Это научная новизна библиотеки по
+  сравнению с обычными реализациями Парзеновского окна с фиксированной
+  шириной: окно автоматически расширяется в разреженных областях и
+  сужается в плотных.
+- **Дообучение** — `partial_fit()` расширяет модель новым батчем данных, не
+  теряя уже накопленное.
+- **Разрядка датасета** — `compact()` уменьшает потребление памяти, удаляя
+  точки обучающей выборки, которые лежат глубоко на территории своего
+  класса (метод анализа выпуклых окрестностей: точка удаляется, только
+  если все её ближайшие соседи имеют ту же метку класса *и* она далека от
+  ближайшей точки другого класса). Это сокращает хранимый датасет с
+  минимальным влиянием на границу между классами.
+- **Потокобезопасная разрядка с планировщиком вызовов** — пока выполняется
+  `compact()`, обучающие данные заблокированы для записи. Вызовы
+  `predict()` и `partial_fit()` из других потоков в это время не падают:
+  они встают в очередь и выполняются автоматически сразу после завершения
+  разрядки.
+- **Сохранение в `.npz`** — `save()`/`load()` для бэкапов и переноса модели
+  между устройствами.
+- Полная совместимость с `pickle`/`joblib`.
+
+### Установка
+
+```bash
+pip install parzen_window
+```
+
+### Быстрый старт
+
+```python
+from parzen_window import ParzenWindowClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+
+X, y = load_iris(return_X_y=True)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+model = ParzenWindowClassifier(h=1.0, kernel="quartic")
+model.fit(X_train, y_train)
+predictions = model.predict(X_test)
+probabilities = model.predict_proba(X_test)
+```
+
+Дообучение:
+
+```python
+model = ParzenWindowClassifier(h=0.5, kernel="gaussian")
+model.fit(X_batch_1, y_batch_1)
+model.partial_fit(X_batch_2, y_batch_2)  # расширяет, не теряя X_batch_1
+```
+
+Адаптивная ширина окна:
+
+```python
+model = ParzenWindowClassifier(
+    h=1.0, kernel="gaussian", adaptive_bandwidth=True, bandwidth_neighbors=5
+)
+model.fit(X_train, y_train)
+```
+
+Разрядка большого датасета, чтобы сократить потребление памяти примерно на 25%:
+
+```python
+removed = model.compact(0.25)  # возвращает число реально удалённых точек
+```
+
+Бэкапы:
+
+```python
+model.save("model.npz")
+restored = ParzenWindowClassifier.load("model.npz")
+```
+
+### Разработка
+
+Проект использует [uv](https://docs.astral.sh/uv/) для управления зависимостями.
+
+```bash
+uv sync --dev         # установить зависимости
+uv run ruff check .   # линтер
+uv run ruff format .  # форматирование
+uv build               # сборка sdist + wheel
+```

parzen_window-0.0.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+parzen_window/__init__.py,sha256=OspRBpbnhkD3XEzMp2BKf5MkmPx6ftrDr2krqo4CAWk,175
+parzen_window/compaction.py,sha256=YPjxSig0rFZpsLr-vsND9QCisXLS4UVmoijiHt3pU3o,3130
+parzen_window/core.py,sha256=yX3etp6I_eh0oDg9C_4qHeLcZ-fwlnP48eX0AVcUsXw,8636
+parzen_window/io.py,sha256=VI4BisLjByXaHPvae39pmljwXqe9hU-v-TlFdTLIpJs,1020
+parzen_window/kernels.py,sha256=M9GPPY93h-taYfkp05MAjWUdGJ8HSzj122bZYdg3Sko,1223
+parzen_window/scheduler.py,sha256=5sRrw2mh320cRrQx9AUBwvC4HYBTyurcvyhvzit-Bx8,2764
+parzen_window-0.0.2.dist-info/METADATA,sha256=_NRimgct2knqm5MnRE4OaqOO4pFn5cDF9mKELCmymOE,8822
+parzen_window-0.0.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+parzen_window-0.0.2.dist-info/licenses/LICENSE,sha256=VnRHTC1ELnJKvHM4h2fDqX_VVD-O4p3FJNFmOK6MUJo,1092
+parzen_window-0.0.2.dist-info/RECORD,,

parzen_window-0.0.2.dist-info/WHEEL

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

parzen_window-0.0.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Andery Ferubko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.