knn-engine-core 0.1.0__tar.gz

knn_engine_core-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,59 @@
+name: Build and Publish to PyPI
+
+on:
+  release:
+    types:
+      - published
+
+jobs:
+  build_wheels:
+    name: Build wheels on ${{ matrix.os }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.17.0
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-wheels-${{ matrix.os }}-${{ strategy.job-index }}
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: Build source distribution
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build sdist
+        run: pipx run build --sdist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: cibw-sdist
+          path: dist/*.tar.gz
+
+  publish-to-pypi:
+    name: Publish Python distribution to PyPI
+    needs: [build_wheels, build_sdist]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/knn-engine-core
+    permissions:
+      id-token: write
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          pattern: cibw-*
+          path: dist
+          merge-multiple: true
+
+      - name: Publish distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

knn_engine_core-0.1.0/.gitignore

@@ -0,0 +1,36 @@
+# --- Build Artifacts ---
+build/
+out/
+bin/
+obj/
+*.so
+*.a
+*.la
+*.o
+*.obj
+
+# --- Python ---
+__pycache__/
+*.py[cod]
+*$py.class
+.venv/
+venv/
+ENV/
+.pytest_cache/
+
+# --- IDEs and Editors ---
+.vscode/
+.idea/
+*.swp
+*.swo
+.clangd/
+compile_commands.json
+
+# --- Data & Logs ---
+data/*.csv
+!data/README.md
+*.log
+
+# --- CMake ---
+CMakeUserPresets.json
+_deps/

knn_engine_core-0.1.0/CMakeLists.txt

@@ -0,0 +1,47 @@
+cmake_minimum_required(VERSION 3.18)
+
+if(POLICY CMP0135)
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
+if(POLICY CMP0169)
+    cmake_policy(SET CMP0169 OLD)
+endif()
+
+project(KNN_ENGINE LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(FetchContent)
+
+FetchContent_Declare(
+    eigen
+    URL https://gitlab.com/libeigen/eigen/-/archive/3.4.0/eigen-3.4.0.tar.gz
+)
+FetchContent_GetProperties(eigen)
+if(NOT eigen_POPULATED)
+    FetchContent_Populate(eigen)
+endif()
+
+FetchContent_Declare(
+    pybind11
+    URL https://github.com/pybind/pybind11/archive/refs/tags/v2.13.1.tar.gz
+)
+FetchContent_MakeAvailable(pybind11)
+
+pybind11_add_module(knn_core NO_EXTRAS
+    src/binding.cpp 
+    src/PCA.cpp 
+    src/KNN.cpp
+    src/KNNEngine.cpp
+)
+
+target_include_directories(knn_core SYSTEM PRIVATE 
+    include 
+    ${eigen_SOURCE_DIR}
+)
+
+target_link_libraries(knn_core PRIVATE pybind11::module)
+
+install(TARGETS knn_core DESTINATION .)

knn_engine_core-0.1.0/CMakePresets.json

@@ -0,0 +1,27 @@
+{
+    "version": 8,
+    "configurePresets": [
+        {
+            "name": "Debug",
+            "displayName": "Debug",
+            "description": "Debug",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Debug",
+                "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
+            }
+        },
+        {
+            "name": "Release",
+            "displayName": "Release",
+            "description": "Release",
+            "generator": "Ninja",
+            "binaryDir": "${sourceDir}/out/build/${presetName}",
+            "cacheVariables": {
+                "CMAKE_BUILD_TYPE": "Release",
+                "CMAKE_INSTALL_PREFIX": "${sourceDir}/out/install/${presetName}"
+            }
+        }
+    ]
+}

knn_engine_core-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.2
+Name: knn-engine-core
+Version: 0.1.0
+Summary: A high-performance C++ KNN Engine with Adaptive PCA
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+Description-Content-Type: text/markdown
+
+# KNN Core

knn_engine_core-0.1.0/README.md

@@ -0,0 +1 @@
+# KNN Core

knn_engine_core-0.1.0/include/KNN.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <Eigen/Dense>
+#include <map>
+#include <string>
+#include <vector>
+
+class KNN {
+ public:
+  explicit KNN(int k = 3);
+
+  void train(const Eigen::MatrixXd& training_data,
+             const std::vector<std::string>& training_labels);
+
+  std::string predict(const Eigen::VectorXd& query_point) const;
+
+ private:
+  int k_neighbors;
+  Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>
+      train_X;
+  std::vector<std::string> train_y;
+};

knn_engine_core-0.1.0/include/KNNEngine.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include <Eigen/Dense>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "KNN.hpp"
+#include "PCA.hpp"
+
+struct KNNConfig {
+  int k = 3;
+  double variance = 0.95;
+};
+
+class KNNEngine {
+ public:
+  explicit KNNEngine(KNNConfig config = KNNConfig());
+
+  void train(const Eigen::MatrixXd& X, const std::vector<std::string>& y,
+             bool scale = false);
+
+  std::string predict(const Eigen::VectorXd& raw_input) const;
+  std::vector<std::string> predict_batch(const Eigen::MatrixXd& inputs) const;
+
+ private:
+  KNNConfig cfg;
+  std::unique_ptr<PCA> pca;
+  std::unique_ptr<KNN> knn;
+};

knn_engine_core-0.1.0/include/PCA.hpp

@@ -0,0 +1,24 @@
+#pragma once
+#include <Eigen/Dense>
+
+class PCA {
+ public:
+  // components > 1: fixed count. components < 1: variance threshold (e.g. 0.95)
+  explicit PCA(double components = 0.95);
+
+  void fit(const Eigen::MatrixXd& X, bool scale = false);
+  Eigen::MatrixXd transform(const Eigen::MatrixXd& X) const;
+  Eigen::MatrixXd fit_transform(const Eigen::MatrixXd& X);
+
+  int getComponentCount() const { return num_components; }
+
+ private:
+  double threshold;
+  int num_components;
+  Eigen::RowVectorXd mean;
+  Eigen::RowVectorXd std_dev;
+  Eigen::MatrixXd projection_matrix;
+
+  void apply_threshold(const Eigen::VectorXd& evals,
+                       const Eigen::MatrixXd& evecs, bool is_thin_mode);
+};

knn_engine_core-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "knn-engine-core"
+version = "0.1.0"
+description = "A high-performance C++ KNN Engine with Adaptive PCA"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "scikit-learn"
+]
+
+[tool.scikit-build]
+cmake.version = ">=3.18"

knn_engine_core-0.1.0/script.py

@@ -0,0 +1,34 @@
+import knn_core
+import numpy as np
+from sklearn.datasets import fetch_olivetti_faces, load_iris, load_digits
+from sklearn.model_selection import train_test_split
+
+def test_dataset(name, X, y, k, variance, scale):
+    print(f"\n--- Testing {name} ---")
+    cfg = knn_core.KNNConfig()
+    cfg.k = k
+    cfg.variance = variance
+    engine = knn_core.KNNEngine(cfg)
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X.astype(np.float64), y.astype(str), test_size=0.2, stratify=y, random_state=42
+    )
+
+    engine.train(X_train, y_train.tolist(), scale)
+    
+    correct = 0
+    for i in range(len(X_test)):
+        if engine.predict(X_test[i]) == y_test[i]:
+            correct += 1
+    
+    print(f"Accuracy: {correct/len(X_test)*100:.2f}%")
+
+if __name__ == "__main__":
+    faces = fetch_olivetti_faces()
+    test_dataset("Olivetti Faces", faces.data, faces.target, k=1, variance=0.90, scale=False)
+
+    iris = load_iris()
+    test_dataset("Iris Flower", iris.data, iris.target, k=3, variance=0.99, scale=False)
+
+    digits = load_digits()
+    test_dataset("Handwritten Digits", digits.data, digits.target, k=3, variance=0.95, scale=False)

knn_engine_core-0.1.0/src/KNN.cpp

@@ -0,0 +1,40 @@
+#include "KNN.hpp"
+
+#include <algorithm>
+#include <numeric>
+
+KNN::KNN(int k) : k_neighbors(k) {}
+
+void KNN::train(const Eigen::MatrixXd& training_data,
+                const std::vector<std::string>& training_labels) {
+  train_X = training_data;
+  train_y = training_labels;
+}
+
+std::string KNN::predict(const Eigen::VectorXd& query_point) const {
+  if (train_X.rows() == 0 || k_neighbors <= 0) return "Unknown";
+
+  Eigen::VectorXd distances =
+      (train_X.rowwise() - query_point.transpose()).rowwise().squaredNorm();
+
+  std::vector<int> indices(train_X.rows());
+  std::iota(indices.begin(), indices.end(), 0);
+
+  int k_eff = std::min(k_neighbors, static_cast<int>(train_X.rows()));
+
+  if (k_eff < train_X.rows()) {
+    std::nth_element(
+        indices.begin(), indices.begin() + k_eff, indices.end(),
+        [&distances](int i, int j) { return distances(i) < distances(j); });
+  }
+
+  std::map<std::string, int> votes;
+  for (int i = 0; i < k_eff; ++i) {
+    votes[train_y[indices[i]]]++;
+  }
+
+  return std::max_element(
+             votes.begin(), votes.end(),
+             [](const auto& a, const auto& b) { return a.second < b.second; })
+      ->first;
+}

knn_engine_core-0.1.0/src/KNNEngine.cpp

@@ -0,0 +1,34 @@
+#include "KNNEngine.hpp"
+
+#include <iostream>
+
+KNNEngine::KNNEngine(KNNConfig config) : cfg(config) {
+  pca = std::make_unique<PCA>(cfg.variance);
+  knn = std::make_unique<KNN>(cfg.k);
+}
+
+void KNNEngine::train(const Eigen::MatrixXd& X,
+                      const std::vector<std::string>& y, bool scale) {
+  pca->fit(X, scale);
+  Eigen::MatrixXd x_reduced = pca->transform(X);
+
+  knn->train(x_reduced, y);
+
+  std::cout << "[Engine] Trained successfully. Reduced to "
+            << pca->getComponentCount() << " dimensions." << std::endl;
+}
+
+std::string KNNEngine::predict(const Eigen::VectorXd& raw_input) const {
+  Eigen::MatrixXd projected = pca->transform(raw_input.transpose());
+  return knn->predict(projected.transpose());
+}
+
+std::vector<std::string> KNNEngine::predict_batch(
+    const Eigen::MatrixXd& inputs) const {
+  Eigen::MatrixXd projected = pca->transform(inputs);
+  std::vector<std::string> predictions;
+  for (int i = 0; i < projected.rows(); ++i) {
+    predictions.push_back(knn->predict(projected.row(i).transpose()));
+  }
+  return predictions;
+}

knn_engine_core-0.1.0/src/PCA.cpp

@@ -0,0 +1,88 @@
+#include "PCA.hpp"
+
+#include <Eigen/Dense>
+#include <algorithm>
+#include <iostream>
+
+PCA::PCA(double components) : threshold(components), num_components(0) {}
+
+void PCA::fit(const Eigen::MatrixXd& X, bool scale) {
+  mean = X.colwise().mean();
+  Eigen::MatrixXd centered = X.rowwise() - mean;
+
+  if (scale) {
+    std_dev =
+        (centered.array().square().colwise().sum() / (X.rows() - 1)).sqrt();
+    std_dev = std_dev.unaryExpr([](double v) { return v < 1e-9 ? 1.0 : v; });
+    centered = centered.array().rowwise() / std_dev.array();
+  } else {
+    std_dev = Eigen::RowVectorXd::Ones(X.cols());
+  }
+
+  int N = X.rows();
+  int D = X.cols();
+
+  if (D > N) {
+    Eigen::MatrixXd L = (centered * centered.transpose());
+    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> solver(L);
+
+    Eigen::VectorXd evals = solver.eigenvalues().reverse();
+    Eigen::MatrixXd evecs_L = solver.eigenvectors().rowwise().reverse();
+
+    Eigen::MatrixXd evecs = centered.transpose() * evecs_L;
+
+    for (int i = 0; i < evecs.cols(); ++i) {
+      double norm = evecs.col(i).norm();
+      if (norm > 1e-9) {
+        evecs.col(i) /= norm;
+      } else {
+        evecs.col(i).setZero();
+      }
+    }
+    apply_threshold(evals, evecs, true);
+  } else {
+    Eigen::MatrixXd cov = (centered.transpose() * centered) / double(N - 1);
+    Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> solver(cov);
+
+    Eigen::VectorXd evals = solver.eigenvalues().reverse();
+    Eigen::MatrixXd evecs = solver.eigenvectors().rowwise().reverse();
+
+    apply_threshold(evals, evecs, false);
+  }
+}
+
+void PCA::apply_threshold(const Eigen::VectorXd& evals,
+                          const Eigen::MatrixXd& evecs, bool is_thin_mode) {
+  num_components = 0;
+
+  if (threshold >= 1.0) {
+    num_components =
+        std::min(static_cast<int>(threshold), static_cast<int>(evals.size()));
+  } else {
+    double total_variance = evals.sum();
+    double cumulative_variance = 0.0;
+    for (int i = 0; i < evals.size(); ++i) {
+      num_components++;
+      cumulative_variance += evals[i];
+      if ((cumulative_variance / total_variance) >= threshold) break;
+    }
+  }
+
+  projection_matrix = evecs.leftCols(num_components);
+  std::cout << "[PCA] Fit complete. Mode: "
+            << (is_thin_mode ? "Thin" : "Standard")
+            << " | Components: " << num_components << std::endl;
+}
+
+Eigen::MatrixXd PCA::transform(const Eigen::MatrixXd& X) const {
+  Eigen::MatrixXd centered = X.rowwise() - mean;
+
+  Eigen::MatrixXd standardized = centered.array().rowwise() / std_dev.array();
+
+  return standardized * projection_matrix;
+}
+
+Eigen::MatrixXd PCA::fit_transform(const Eigen::MatrixXd& X) {
+  fit(X);
+  return transform(X);
+}

knn_engine_core-0.1.0/src/binding.cpp

@@ -0,0 +1,23 @@
+#include <pybind11/eigen.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include "KNNEngine.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(knn_core, m) {
+  m.doc() = "C++ KNN Engine with Adaptive PCA support";
+
+  py::class_<KNNConfig>(m, "KNNConfig")
+      .def(py::init<>())
+      .def_readwrite("k", &KNNConfig::k)
+      .def_readwrite("variance", &KNNConfig::variance);
+
+  py::class_<KNNEngine>(m, "KNNEngine")
+      .def(py::init<KNNConfig>())
+      .def("train", &KNNEngine::train, py::arg("X"), py::arg("y"),
+           py::arg("scale") = false)
+      .def("predict", &KNNEngine::predict)
+      .def("predict_batch", &KNNEngine::predict_batch);
+}