cuknn 0.1.0__tar.gz

cuknn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Salvatore Calderaro
+
+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.

cuknn-0.1.0/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: cuknn
+Version: 0.1.0
+Summary: GPU accelerated K-Nearest Neighbors using CuPy
+Author: Salvatore Calderaro
+Project-URL: Homepage, https://github.com/salvatorecalderaro/cuKNN
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# CuPy-KNN ⚡
+<p align="center">
+  <img src="logo.png" alt="CuPy-KNN logo" width="600">
+</p>
+<p align="center">
+GPU-Accelerated K-Nearest Neighbors using NVIDIA CUDA and CuPy
+</p>
+
+<p align="center">
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![CUDA](https://img.shields.io/badge/CUDA-GPU-green)
+![License](https://img.shields.io/badge/license-MIT-orange)
+
+</p>
+
+## 🚀 Overview
+
+**CuPy-KNN** is a GPU accelerated implementation of the
+K-Nearest Neighbors algorithm powered by
+[CuPy](https://cupy.dev/).
+
+It provides a scikit-learn compatible API while exploiting NVIDIA GPUs
+for large-scale nearest neighbor search.
+
+Designed for:
+
+- Machine Learning
+- Deep Learning embeddings
+- Computer Vision features
+- Bioinformatics embeddings
+- Large-scale similarity search
+
+## ✨ Features
+
+✅ GPU acceleration with CUDA  
+✅ Batch-based distance computation  
+✅ Multiple distance metrics:
+
+- Euclidean
+- Cosine
+- Manhattan
+
+✅ sklearn-like API
+
+- `fit()`
+- `predict()`
+- `predict_proba()`
+- `kneighbors()`
+
+✅ Supports large datasets  
+✅ Fully implemented with CuPy tensors
+
+## 📦 Installation
+
+Install from PyPI:
+
+```bash
+pip install cuknn
+```
+
+For CUDA-enabled systems install CuPy first:
+
+```bash
+pip install cupy-cuda12x
+```
+
+or select the version matching your CUDA installation.
+
+## ⚡ Quick Start
+
+```python
+from cuknn import KNN
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+
+X, y = make_classification(
+    n_samples=100000,
+    n_features=512,
+    n_classes=5
+)
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y
+)
+
+
+model = KNN(
+    k=5,
+    distance="euclidean",
+    batch_size=1024
+)
+
+
+model.fit(
+    X_train,
+    y_train
+)
+
+
+prediction = model.predict(
+    X_test
+)
+
+```
+
+## 📚 Citation
+
+If you use cuKNN in your research:
+
+```
+@software{cupy_knn,
+ author = {Calderaro, Salvatore},
+ title = {cuKNN: GPU Accelerated K-Nearest Neighbors},
+ year = {2026}
+}
+```

cuknn-0.1.0/README.md

@@ -0,0 +1,121 @@
+# CuPy-KNN ⚡
+<p align="center">
+  <img src="logo.png" alt="CuPy-KNN logo" width="600">
+</p>
+<p align="center">
+GPU-Accelerated K-Nearest Neighbors using NVIDIA CUDA and CuPy
+</p>
+
+<p align="center">
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![CUDA](https://img.shields.io/badge/CUDA-GPU-green)
+![License](https://img.shields.io/badge/license-MIT-orange)
+
+</p>
+
+## 🚀 Overview
+
+**CuPy-KNN** is a GPU accelerated implementation of the
+K-Nearest Neighbors algorithm powered by
+[CuPy](https://cupy.dev/).
+
+It provides a scikit-learn compatible API while exploiting NVIDIA GPUs
+for large-scale nearest neighbor search.
+
+Designed for:
+
+- Machine Learning
+- Deep Learning embeddings
+- Computer Vision features
+- Bioinformatics embeddings
+- Large-scale similarity search
+
+## ✨ Features
+
+✅ GPU acceleration with CUDA  
+✅ Batch-based distance computation  
+✅ Multiple distance metrics:
+
+- Euclidean
+- Cosine
+- Manhattan
+
+✅ sklearn-like API
+
+- `fit()`
+- `predict()`
+- `predict_proba()`
+- `kneighbors()`
+
+✅ Supports large datasets  
+✅ Fully implemented with CuPy tensors
+
+## 📦 Installation
+
+Install from PyPI:
+
+```bash
+pip install cuknn
+```
+
+For CUDA-enabled systems install CuPy first:
+
+```bash
+pip install cupy-cuda12x
+```
+
+or select the version matching your CUDA installation.
+
+## ⚡ Quick Start
+
+```python
+from cuknn import KNN
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+
+X, y = make_classification(
+    n_samples=100000,
+    n_features=512,
+    n_classes=5
+)
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y
+)
+
+
+model = KNN(
+    k=5,
+    distance="euclidean",
+    batch_size=1024
+)
+
+
+model.fit(
+    X_train,
+    y_train
+)
+
+
+prediction = model.predict(
+    X_test
+)
+
+```
+
+## 📚 Citation
+
+If you use cuKNN in your research:
+
+```
+@software{cupy_knn,
+ author = {Calderaro, Salvatore},
+ title = {cuKNN: GPU Accelerated K-Nearest Neighbors},
+ year = {2026}
+}
+```

cuknn-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = [
+    "setuptools>=61",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "cuknn"
+version = "0.1.0"
+
+description = "GPU accelerated K-Nearest Neighbors using CuPy"
+
+authors = [
+    {name="Salvatore Calderaro"}
+]
+
+readme = "README.md"
+
+requires-python = ">=3.9"
+
+dependencies = [
+    "numpy",
+    "tqdm"
+]
+
+
+[project.urls]
+Homepage = "https://github.com/salvatorecalderaro/cuKNN"

cuknn-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

cuknn-0.1.0/src/cuknn/__init__.py

@@ -0,0 +1,7 @@
+from .cuknn import KNN
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "KNN"
+]

cuknn-0.1.0/src/cuknn/cuknn.py

@@ -0,0 +1,127 @@
+import cupy as cp
+from .distances import euclidean_distance, cosine_distance,manhattan_distance
+from tqdm import tqdm
+
+class KNN:
+    """
+    A simple K-Nearest Neighbors (KNN) classifier using CuPy for GPU acceleration.
+    Attributes:
+        k (int): The number of nearest neighbors to consider for classification.
+        distance (str): The distance metric to use ('euclidean', 'cosine', or 'manhattan').
+        batch_size (int): The number of samples to process in each batch during prediction.
+        X_train (cp.ndarray): The training data features.
+        y_train (cp.ndarray): The training data labels.
+    Methods:
+        fit(X, y): Fit the KNN model using the training data.
+        predict(X): Predict the labels for the given test data.
+    """
+    def __init__(self, k=5, distance='euclidean',batch_size=128):
+        self.k = k
+        self.batch_size = batch_size
+        
+        metrics = {
+            "euclidean": euclidean_distance,
+            "cosine": cosine_distance,
+            "manhattan": manhattan_distance,
+        }
+        
+        if distance not in metrics:
+            raise ValueError(f"Unknown distance metric: {distance}")
+        
+        self.distance = metrics[distance]
+        self.X_train = None
+        self.y_train = None
+        
+        self.neighbor_indices_ = None
+        self.neighbor_distances_ = None
+        self._last_X = None
+        
+    def fit(self, X, y):
+        self.X_train = cp.asarray(X)
+        self.y_train = cp.asarray(y)
+        
+    
+    def kneighbors(self, X):
+        """
+        Find the k-nearest neighbors for each sample in X.
+        Args:
+            X: A 2D array of shape (n_samples, n_features).
+        Returns:
+            A tuple containing:
+                - distances: A 2D array of shape (n_samples, k) containing the distances to the k-nearest neighbors.
+                - indices: A 2D array of shape (n_samples, k) containing the indices of the k-nearest neighbors in the training data.
+        """
+        X = cp.asarray(X)
+        n_samples = X.shape[0]
+        
+        all_distances = []
+        all_indices = []
+        
+        for i in tqdm(range(0, n_samples, self.batch_size), desc="Finding Neighbors", unit="batch"):
+            X_batch = X[i:i+self.batch_size]
+            distances = self.distance(X_batch, self.X_train)
+            nearest_indices = cp.argpartition(distances, self.k, axis=1)[:, :self.k]
+            nearest_distances = cp.take_along_axis(distances, nearest_indices, axis=1)
+            all_distances.append(nearest_distances)
+            all_indices.append(nearest_indices)
+        
+        all_distances = cp.concatenate(all_distances, axis=0)
+        all_indices = cp.concatenate(all_indices, axis=0)
+        self.neighbor_indices_ = all_indices
+        self.neighbor_distances_ = all_distances
+        self._last_X = X.copy()    
+        return self.neighbor_distances_, self.neighbor_indices_
+    
+    def _check_kneighbors(self, X):
+        """
+        Check if kneighbors has been called for the given input X.
+        If not, call kneighbors to compute the neighbors.
+        Args:
+            X: A 2D array of shape (n_samples, n_features).
+        """
+        X = cp.asarray(X)
+        if self.neighbor_indices_ is None or self.neighbor_distances_ is None or not cp.array_equal(self._last_X, X):
+            self.kneighbors(X)
+    
+    def predict(self, X):
+        """
+        Predict the labels for the given test data.
+        Args:
+            X: A 2D array of shape (n_samples, n_features).
+        Returns:
+            A 1D array of shape (n_samples,) containing the predicted labels.
+        """
+        self._check_kneighbors(X)
+        indices = self.neighbor_indices_
+
+        predictions = []
+
+
+        for row in tqdm(indices,desc="Predicting",unit="batch"):
+            labels = self.y_train[row]
+            values, counts = cp.unique(labels,return_counts=True)
+            predictions.append(values[cp.argmax(counts)])
+        return cp.asarray(predictions)
+    
+    
+    def predict_proba(self,X):
+        self._check_kneighbors(X)
+        
+        classes = cp.unique(self.y_train)
+        probas = []
+        
+        indices = self.neighbor_indices_
+        
+        for row in tqdm(indices,desc="Predicting Probabilities",unit="batch"):
+            labels = self.y_train[row]
+            for cls in classes:
+                probas.append(cp.sum(labels == cls) / self.k)
+        return cp.asarray(probas).reshape(X.shape[0], len(classes))
+    
+    
+    
+
+    
+    
+    
+

cuknn-0.1.0/src/cuknn/distances.py

@@ -0,0 +1,78 @@
+import cupy as cp
+
+def euclidean_distance(x,y):
+    """
+    Compute the Euclidean distance between two sets of points.
+    Args:
+        x: A 2D array of shape (n_samples_x, n_features).
+        y: A 2D array of shape (n_samples_y, n_features).
+    Returns:
+        A 2D array of shape (n_samples_x, n_samples_y) containing the
+        pairwise Euclidean distances between the points in x and y.
+    """
+    x = cp.asarray(x)
+    y = cp.asarray(y)
+    x_norm = cp.sum(x**2, axis=1, keepdims=True)
+    y_norm  = cp.sum(y**2, axis=1)
+    
+    dist = (x_norm + y_norm - 2 * cp.dot(x, y.T))
+    
+    dist = cp.sqrt(cp.maximum(dist, 0))
+    return dist
+
+
+def manhattan_distance(x,y):
+    """
+    Compute the Manhattan distance between two sets of points.
+    Args:
+        x: A 2D array of shape (n_samples_x, n_features).
+        y: A 2D array of shape (n_samples_y, n_features).
+    Returns:
+        A 2D array of shape (n_samples_x, n_samples_y) containing the
+        pairwise Manhattan distances between the points in x and y.
+    """
+    x = cp.asarray(x)
+    y = cp.asarray(y)
+    dist = cp.sum(cp.abs(x[:, None] - y[None, :]), axis=-1)
+    return dist
+
+
+def cosine_distance(x,y):
+    """
+    Compute the Cosine distance between two sets of points.
+    Args:
+        x: A 2D array of shape (n_samples_x, n_features).
+        y: A 2D array of shape (n_samples_y, n_features).
+    Returns:
+        A 2D array of shape (n_samples_x, n_samples_y) containing the
+        pairwise Cosine distances between the points in x and y.
+    """
+    x = cp.asarray(x)
+    y = cp.asarray(y)
+    x_norm = cp.linalg.norm(x, axis=1, keepdims=True)
+    y_norm = cp.linalg.norm(y, axis=1, keepdims=True)
+    
+    dist = 1 - (cp.dot(x, y.T) / (x_norm * y_norm.T))
+    
+    return dist
+
+def precomputed_distance(D):
+    """
+    Return a function that computes the precomputed distance between two sets of points.
+    Args:
+        D: A 2D array of shape (n_samples_x, n_samples_y) containing the precomputed distances.
+    Returns:
+        A function that takes two 2D arrays x and y and returns the precomputed distances between the points in x and y.
+    """
+    def distance(x, y):
+        """
+        Return the precomputed distances between the points in x and y.
+        Args:
+            x: A 2D array of shape (n_samples_x, n_features).
+            y: A 2D array of shape (n_samples_y, n_features).
+        Returns:
+            A 2D array of shape (n_samples_x, n_samples_y) containing the
+            precomputed distances between the points in x and y."""
+        return D
+
+    return distance

cuknn-0.1.0/src/cuknn.egg-info/PKG-INFO

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: cuknn
+Version: 0.1.0
+Summary: GPU accelerated K-Nearest Neighbors using CuPy
+Author: Salvatore Calderaro
+Project-URL: Homepage, https://github.com/salvatorecalderaro/cuKNN
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: tqdm
+Dynamic: license-file
+
+# CuPy-KNN ⚡
+<p align="center">
+  <img src="logo.png" alt="CuPy-KNN logo" width="600">
+</p>
+<p align="center">
+GPU-Accelerated K-Nearest Neighbors using NVIDIA CUDA and CuPy
+</p>
+
+<p align="center">
+
+![Python](https://img.shields.io/badge/python-3.9+-blue)
+![CUDA](https://img.shields.io/badge/CUDA-GPU-green)
+![License](https://img.shields.io/badge/license-MIT-orange)
+
+</p>
+
+## 🚀 Overview
+
+**CuPy-KNN** is a GPU accelerated implementation of the
+K-Nearest Neighbors algorithm powered by
+[CuPy](https://cupy.dev/).
+
+It provides a scikit-learn compatible API while exploiting NVIDIA GPUs
+for large-scale nearest neighbor search.
+
+Designed for:
+
+- Machine Learning
+- Deep Learning embeddings
+- Computer Vision features
+- Bioinformatics embeddings
+- Large-scale similarity search
+
+## ✨ Features
+
+✅ GPU acceleration with CUDA  
+✅ Batch-based distance computation  
+✅ Multiple distance metrics:
+
+- Euclidean
+- Cosine
+- Manhattan
+
+✅ sklearn-like API
+
+- `fit()`
+- `predict()`
+- `predict_proba()`
+- `kneighbors()`
+
+✅ Supports large datasets  
+✅ Fully implemented with CuPy tensors
+
+## 📦 Installation
+
+Install from PyPI:
+
+```bash
+pip install cuknn
+```
+
+For CUDA-enabled systems install CuPy first:
+
+```bash
+pip install cupy-cuda12x
+```
+
+or select the version matching your CUDA installation.
+
+## ⚡ Quick Start
+
+```python
+from cuknn import KNN
+
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+
+X, y = make_classification(
+    n_samples=100000,
+    n_features=512,
+    n_classes=5
+)
+
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X,
+    y
+)
+
+
+model = KNN(
+    k=5,
+    distance="euclidean",
+    batch_size=1024
+)
+
+
+model.fit(
+    X_train,
+    y_train
+)
+
+
+prediction = model.predict(
+    X_test
+)
+
+```
+
+## 📚 Citation
+
+If you use cuKNN in your research:
+
+```
+@software{cupy_knn,
+ author = {Calderaro, Salvatore},
+ title = {cuKNN: GPU Accelerated K-Nearest Neighbors},
+ year = {2026}
+}
+```

cuknn-0.1.0/src/cuknn.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/cuknn/__init__.py
+src/cuknn/cuknn.py
+src/cuknn/distances.py
+src/cuknn.egg-info/PKG-INFO
+src/cuknn.egg-info/SOURCES.txt
+src/cuknn.egg-info/dependency_links.txt
+src/cuknn.egg-info/requires.txt
+src/cuknn.egg-info/top_level.txt

cuknn-0.1.0/src/cuknn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cuknn-0.1.0/src/cuknn.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy
+tqdm

cuknn-0.1.0/src/cuknn.egg-info/top_level.txt

@@ -0,0 +1 @@
+cuknn