tech-rkj 0.1.0__tar.gz

tech_rkj-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 Jaydeep Prajapati
+
+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.
+

tech_rkj-0.1.0/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: tech-rkj
+Version: 0.1.0
+Summary: Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust
+Author: Jaydeep Prajapati
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Dynamic: license-file
+
+# tech-rkj
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/tech-rkj/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Platform](https://img.shields.io/badge/platform-linux__x86__64-brightgreen.svg)]()
+[![Hardware Acceleration](https://img.shields.io/badge/AVX2%20%2B%20FMA-Vectorized-blueviolet.svg)]()
+
+**Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust.**
+
+`tech-rkj` delivers instant, single-pass closed-form training with zero backprop loops, alongside sub-30µs streaming continual learning without catastrophic forgetting.
+
+---
+
+## Key Features
+
+- **Single-Pass Closed-Form Solve**: Direct Gauss-Jordan orthogonal subspace solver $(Z^T Z + \alpha I)^{-1} Z^T Y$ eliminates iterative backpropagation loops entirely.
+- **Hardware-Vectorized AVX2 + FMA**: Rank-1 updates ($P^{-1} \leftarrow P^{-1} - \gamma k k^T$ and $W \leftarrow W + \gamma k e^T$) unrolled with 256-bit SIMD intrinsics.
+- **Continual Streaming Learning (< 30µs)**: Real-time sample-by-sample recursive least squares (RLS) updates with zero heap allocation per stream step.
+- **Zero-Day & Few-Shot Detection**: Novelty-aware learning gain floor avoids $P^{-1}$ saturation on rare classes after large batch fits.
+- **Supervised Fisher / ANOVA Feature Weighting**: Automatic between-class to within-class variance ratio scaling for tabular datasets to surpass gradient boosted trees (e.g. XGBoost).
+- **Scikit-Learn Compatible API**: Drop-in `.fit(X, y)`, `.predict(X)`, `.score(X, y)`, `.update_online(x, label, sample_weight)`, and `.memory_mb()`.
+
+---
+
+## Installation
+
+```bash
+pip install tech-rkj
+```
+
+*Requirements*: Linux (x86_64 with AVX2 support), Python >= 3.9, NumPy >= 1.21.
+
+---
+
+## Quickstart
+
+### Batch Fitting & Evaluation
+```python
+import numpy as np
+from sklearn.datasets import load_digits
+from tech_rkj import SubspaceClassifier
+
+# Load dataset
+X, y = load_digits(return_X_y=True)
+X = (X / 16.0).astype(np.float32)
+y = y.astype(np.int64)
+
+# Split 80/20
+X_train, X_test = X[:1400], X[1400:]
+y_train, y_test = y[:1400], y[1400:]
+
+# Initialize classifier
+clf = SubspaceClassifier(
+    input_dim=64,
+    num_classes=10,
+    num_heads=4,
+    head_circuits=256,
+    alpha=1.0,
+    low_freq_scale=0.18,
+    high_freq_scale=0.38,
+)
+
+# Single-pass fit (no backpropagation)
+clf.fit(X_train, y_train)
+
+# Evaluate
+acc = clf.score(X_test, y_test)
+print(f"Test Accuracy: {acc * 100:.2f}%")
+print(f"Memory Footprint: {clf.memory_mb():.2f} MB")
+```
+
+### Continual Online Streaming (< 30µs / sample)
+```python
+# Stream new incoming sample dynamically without retraining
+clf.update_online(X_test[0], int(y_test[0]), sample_weight=1.0)
+
+# High-priority / zero-day novelty sample (e.g. few-shot rare event)
+clf.update_online(X_test[1], int(y_test[1]), sample_weight=5.0)
+```
+
+### Tabular Datasets with Fisher / ANOVA Feature Weighting
+```python
+# For tabular datasets with noisy or uninformative features
+clf_tab = SubspaceClassifier(
+    input_dim=32,
+    num_classes=4,
+    num_heads=4,
+    head_circuits=384,
+    alpha=0.5,
+    low_freq_scale=0.15,
+    high_freq_scale=0.35,
+    frontend_mode="zscore",  # Enables ANOVA F-statistic feature weighting
+)
+clf_tab.fit(X_tabular_train, y_tabular_train)
+```
+
+---
+
+## API Reference
+
+### `SubspaceClassifier`
+
+```python
+SubspaceClassifier(
+    input_dim: int,
+    num_classes: int,
+    num_heads: int = 4,
+    head_circuits: int = 384,
+    alpha: float = 8.0,
+    forgetting_factor: float = 1.0,
+    low_freq_scale: float = 0.055,
+    high_freq_scale: float = 0.115,
+    frontend_mode: str = "identity",  # "identity" | "zscore" | "vision_gabor"
+    lib_path: Optional[str] = None,
+)
+```
+
+- `fit(X, y)`: Fits the subspace model using single-pass closed-form Gauss-Jordan elimination.
+- `predict(X)`: Predicts class labels for sample array `X`.
+- `score(X, y)`: Computes mean classification accuracy on `(X, y)`.
+- `update_online(x, label, sample_weight=1.0)`: Performs sub-30µs streaming RLS rank-1 update.
+- `memory_mb()`: Returns the total internal memory footprint of the engine in megabytes.
+
+*(Note: `AICoreClassifier` is retained as an alias for backward compatibility.)*
+
+---
+
+## Benchmark Highlights
+
+- **Full MNIST 28x28 (784-D)**: Trained single-pass in ~2.1 seconds (**2.9x faster** than 10-epoch MLP backpropagation).
+- **Continual Learning Retention**: **95.25%** base class retention after streaming completely new unseen classes.
+- **Zero-Day Few-Shot Detection**: **82.14%** accuracy on 40 few-shot zero-day samples injected after 6,000 normal samples (with 99.00% normal class retention).
+- **Tabular 32D Benchmark**: **84.90%** accuracy (exceeds XGBoost baseline of 83.83%).
+
+---
+
+## License
+
+MIT License. Copyright (c) 2026 Jaydeep Prajapati.
+

tech_rkj-0.1.0/README.md

@@ -0,0 +1,140 @@
+# tech-rkj
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/tech-rkj/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Platform](https://img.shields.io/badge/platform-linux__x86__64-brightgreen.svg)]()
+[![Hardware Acceleration](https://img.shields.io/badge/AVX2%20%2B%20FMA-Vectorized-blueviolet.svg)]()
+
+**Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust.**
+
+`tech-rkj` delivers instant, single-pass closed-form training with zero backprop loops, alongside sub-30µs streaming continual learning without catastrophic forgetting.
+
+---
+
+## Key Features
+
+- **Single-Pass Closed-Form Solve**: Direct Gauss-Jordan orthogonal subspace solver $(Z^T Z + \alpha I)^{-1} Z^T Y$ eliminates iterative backpropagation loops entirely.
+- **Hardware-Vectorized AVX2 + FMA**: Rank-1 updates ($P^{-1} \leftarrow P^{-1} - \gamma k k^T$ and $W \leftarrow W + \gamma k e^T$) unrolled with 256-bit SIMD intrinsics.
+- **Continual Streaming Learning (< 30µs)**: Real-time sample-by-sample recursive least squares (RLS) updates with zero heap allocation per stream step.
+- **Zero-Day & Few-Shot Detection**: Novelty-aware learning gain floor avoids $P^{-1}$ saturation on rare classes after large batch fits.
+- **Supervised Fisher / ANOVA Feature Weighting**: Automatic between-class to within-class variance ratio scaling for tabular datasets to surpass gradient boosted trees (e.g. XGBoost).
+- **Scikit-Learn Compatible API**: Drop-in `.fit(X, y)`, `.predict(X)`, `.score(X, y)`, `.update_online(x, label, sample_weight)`, and `.memory_mb()`.
+
+---
+
+## Installation
+
+```bash
+pip install tech-rkj
+```
+
+*Requirements*: Linux (x86_64 with AVX2 support), Python >= 3.9, NumPy >= 1.21.
+
+---
+
+## Quickstart
+
+### Batch Fitting & Evaluation
+```python
+import numpy as np
+from sklearn.datasets import load_digits
+from tech_rkj import SubspaceClassifier
+
+# Load dataset
+X, y = load_digits(return_X_y=True)
+X = (X / 16.0).astype(np.float32)
+y = y.astype(np.int64)
+
+# Split 80/20
+X_train, X_test = X[:1400], X[1400:]
+y_train, y_test = y[:1400], y[1400:]
+
+# Initialize classifier
+clf = SubspaceClassifier(
+    input_dim=64,
+    num_classes=10,
+    num_heads=4,
+    head_circuits=256,
+    alpha=1.0,
+    low_freq_scale=0.18,
+    high_freq_scale=0.38,
+)
+
+# Single-pass fit (no backpropagation)
+clf.fit(X_train, y_train)
+
+# Evaluate
+acc = clf.score(X_test, y_test)
+print(f"Test Accuracy: {acc * 100:.2f}%")
+print(f"Memory Footprint: {clf.memory_mb():.2f} MB")
+```
+
+### Continual Online Streaming (< 30µs / sample)
+```python
+# Stream new incoming sample dynamically without retraining
+clf.update_online(X_test[0], int(y_test[0]), sample_weight=1.0)
+
+# High-priority / zero-day novelty sample (e.g. few-shot rare event)
+clf.update_online(X_test[1], int(y_test[1]), sample_weight=5.0)
+```
+
+### Tabular Datasets with Fisher / ANOVA Feature Weighting
+```python
+# For tabular datasets with noisy or uninformative features
+clf_tab = SubspaceClassifier(
+    input_dim=32,
+    num_classes=4,
+    num_heads=4,
+    head_circuits=384,
+    alpha=0.5,
+    low_freq_scale=0.15,
+    high_freq_scale=0.35,
+    frontend_mode="zscore",  # Enables ANOVA F-statistic feature weighting
+)
+clf_tab.fit(X_tabular_train, y_tabular_train)
+```
+
+---
+
+## API Reference
+
+### `SubspaceClassifier`
+
+```python
+SubspaceClassifier(
+    input_dim: int,
+    num_classes: int,
+    num_heads: int = 4,
+    head_circuits: int = 384,
+    alpha: float = 8.0,
+    forgetting_factor: float = 1.0,
+    low_freq_scale: float = 0.055,
+    high_freq_scale: float = 0.115,
+    frontend_mode: str = "identity",  # "identity" | "zscore" | "vision_gabor"
+    lib_path: Optional[str] = None,
+)
+```
+
+- `fit(X, y)`: Fits the subspace model using single-pass closed-form Gauss-Jordan elimination.
+- `predict(X)`: Predicts class labels for sample array `X`.
+- `score(X, y)`: Computes mean classification accuracy on `(X, y)`.
+- `update_online(x, label, sample_weight=1.0)`: Performs sub-30µs streaming RLS rank-1 update.
+- `memory_mb()`: Returns the total internal memory footprint of the engine in megabytes.
+
+*(Note: `AICoreClassifier` is retained as an alias for backward compatibility.)*
+
+---
+
+## Benchmark Highlights
+
+- **Full MNIST 28x28 (784-D)**: Trained single-pass in ~2.1 seconds (**2.9x faster** than 10-epoch MLP backpropagation).
+- **Continual Learning Retention**: **95.25%** base class retention after streaming completely new unseen classes.
+- **Zero-Day Few-Shot Detection**: **82.14%** accuracy on 40 few-shot zero-day samples injected after 6,000 normal samples (with 99.00% normal class retention).
+- **Tabular 32D Benchmark**: **84.90%** accuracy (exceeds XGBoost baseline of 83.83%).
+
+---
+
+## License
+
+MIT License. Copyright (c) 2026 Jaydeep Prajapati.
+

tech_rkj-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tech-rkj"
+version = "0.1.0"
+description = "Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+authors = [
+    { name = "Jaydeep Prajapati" }
+]
+dependencies = [
+    "numpy>=1.21",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["tech_rkj*"]
+
+[tool.setuptools.package-data]
+tech_rkj = ["bin/*.so"]

tech_rkj-0.1.0/setup.cfg

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

tech_rkj-0.1.0/setup.py

@@ -0,0 +1,21 @@
+from setuptools import setup, find_packages
+from wheel.bdist_wheel import bdist_wheel as _bdist_wheel
+
+
+class universal_bdist_wheel(_bdist_wheel):
+    def finalize_options(self):
+        super().finalize_options()
+        self.root_is_pure = False
+
+    def get_tag(self):
+        _, _, plat = super().get_tag()
+        return ("py3", "none", plat)
+
+
+setup(
+    packages=find_packages(),
+    package_data={"tech_rkj": ["bin/*.so"]},
+    include_package_data=True,
+    cmdclass={"bdist_wheel": universal_bdist_wheel},
+    has_ext_modules=lambda: True,
+)

tech_rkj-0.1.0/tech_rkj/__init__.py

@@ -0,0 +1,9 @@
+"""
+tech-rkj: High-Performance AVX2 Closed-Form & Continual Learning Subspace Engine in Rust.
+"""
+
+from .classifier import SubspaceClassifier, AICoreClassifier
+
+__version__ = "0.1.0"
+__all__ = ["SubspaceClassifier", "AICoreClassifier", "__version__"]
+

tech_rkj-0.1.0/tech_rkj/classifier.py

@@ -0,0 +1,161 @@
+import ctypes
+import os
+from typing import Optional
+import numpy as np
+
+_MODE_MAP = {"identity": 0, "zscore": 1, "vision_gabor": 2}
+
+
+class SubspaceClassifier:
+    """
+    SubspaceClassifier: High-performance AVX2 closed-form and continual learning classifier in Rust.
+    """
+
+    def __init__(
+        self,
+        input_dim: int,
+        num_classes: int,
+        num_heads: int = 4,
+        head_circuits: int = 384,
+        alpha: float = 8.0,
+        forgetting_factor: float = 1.0,
+        low_freq_scale: float = 0.055,
+        high_freq_scale: float = 0.115,
+        frontend_mode: str = "identity",
+        lib_path: Optional[str] = None,
+    ):
+        if lib_path is None:
+            here = os.path.dirname(os.path.abspath(__file__))
+            default_so = os.path.join(here, "bin", "libaicore_fw.so")
+            fallback_so = os.path.join(here, "libaicore_fw.so")
+            if os.path.exists(default_so):
+                lib_path = default_so
+            elif os.path.exists(fallback_so):
+                lib_path = fallback_so
+            else:
+                lib_path = default_so
+
+        if not os.path.exists(lib_path):
+            raise FileNotFoundError(
+                f"Native binary '{lib_path}' not found. Please verify package installation."
+            )
+
+        self._lib = ctypes.CDLL(lib_path)
+        self._bind_signatures()
+        self.input_dim = input_dim
+        self.num_classes = num_classes
+
+        mode_id = _MODE_MAP.get(frontend_mode, 0)
+        self._handle = self._lib.aicore_create(
+            input_dim,
+            num_classes,
+            num_heads,
+            head_circuits,
+            alpha,
+            forgetting_factor,
+            low_freq_scale,
+            high_freq_scale,
+            mode_id,
+        )
+        if not self._handle:
+            raise RuntimeError("Failed to initialize Rust AICoreEngine")
+        self.handle = self._handle
+
+    def _bind_signatures(self):
+        c_f32_p = ctypes.POINTER(ctypes.c_float)
+        c_i64_p = ctypes.POINTER(ctypes.c_int64)
+
+        self._lib.aicore_create.argtypes = [
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_size_t,
+            ctypes.c_double,
+            ctypes.c_double,
+            ctypes.c_float,
+            ctypes.c_float,
+            ctypes.c_int,
+        ]
+        self._lib.aicore_create.restype = ctypes.c_void_p
+        self._lib.aicore_free.argtypes = [ctypes.c_void_p]
+        self._lib.aicore_fit.argtypes = [
+            ctypes.c_void_p,
+            c_f32_p,
+            c_i64_p,
+            ctypes.c_size_t,
+        ]
+        self._lib.aicore_fit.restype = ctypes.c_int
+        self._lib.aicore_update_online.argtypes = [
+            ctypes.c_void_p,
+            c_f32_p,
+            ctypes.c_size_t,
+            ctypes.c_double,
+        ]
+        self._lib.aicore_predict_batch.argtypes = [
+            ctypes.c_void_p,
+            c_f32_p,
+            c_i64_p,
+            ctypes.c_size_t,
+        ]
+        self._lib.aicore_memory_mb.argtypes = [ctypes.c_void_p]
+        self._lib.aicore_memory_mb.restype = ctypes.c_double
+
+    def fit(self, X: np.ndarray, y: np.ndarray):
+        X_c = np.ascontiguousarray(X, dtype=np.float32)
+        y_c = np.ascontiguousarray(y, dtype=np.int64)
+        if len(X_c) != len(y_c):
+            raise ValueError(
+                f"Length mismatch: X has {len(X_c)} samples, y has {len(y_c)} samples"
+            )
+        rc = self._lib.aicore_fit(
+            self._handle,
+            X_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            y_c.ctypes.data_as(ctypes.POINTER(ctypes.c_int64)),
+            len(y_c),
+        )
+        if rc != 0:
+            raise RuntimeError(f"aicore_fit failed with code {rc}")
+        return self
+
+    def update_online(
+        self, x: np.ndarray, label: int, sample_weight: float = 1.0
+    ):
+        x_c = np.ascontiguousarray(x, dtype=np.float32)
+        self._lib.aicore_update_online(
+            self._handle,
+            x_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            int(label),
+            float(sample_weight),
+        )
+
+    def predict(self, X: np.ndarray) -> np.ndarray:
+        X_c = np.ascontiguousarray(X, dtype=np.float32)
+        preds = np.empty(len(X_c), dtype=np.int64)
+        self._lib.aicore_predict_batch(
+            self._handle,
+            X_c.ctypes.data_as(ctypes.POINTER(ctypes.c_float)),
+            preds.ctypes.data_as(ctypes.POINTER(ctypes.c_int64)),
+            len(X_c),
+        )
+        return preds
+
+    def score(self, X: np.ndarray, y: np.ndarray) -> float:
+        preds = self.predict(X)
+        y_arr = np.asarray(y)
+        return float(np.mean(preds == y_arr))
+
+    def memory_mb(self) -> float:
+        if self._handle:
+            return float(self._lib.aicore_memory_mb(self._handle))
+        return 0.0
+
+    def __del__(self):
+        if getattr(self, "_handle", None) and getattr(self, "_lib", None):
+            self._lib.aicore_free(self._handle)
+            self._handle = None
+            self.handle = None
+
+
+# Backward compatibility alias
+AICoreClassifier = SubspaceClassifier
+

tech_rkj-0.1.0/tech_rkj.egg-info/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: tech-rkj
+Version: 0.1.0
+Summary: Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust
+Author: Jaydeep Prajapati
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21
+Dynamic: license-file
+
+# tech-rkj
+
+[![PyPI version](https://img.shields.io/badge/pypi-v0.1.0-blue.svg)](https://pypi.org/project/tech-rkj/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Platform](https://img.shields.io/badge/platform-linux__x86__64-brightgreen.svg)]()
+[![Hardware Acceleration](https://img.shields.io/badge/AVX2%20%2B%20FMA-Vectorized-blueviolet.svg)]()
+
+**Deterministic AVX2 Closed-Form & Online Continual Learning Subspace Engine in Rust.**
+
+`tech-rkj` delivers instant, single-pass closed-form training with zero backprop loops, alongside sub-30µs streaming continual learning without catastrophic forgetting.
+
+---
+
+## Key Features
+
+- **Single-Pass Closed-Form Solve**: Direct Gauss-Jordan orthogonal subspace solver $(Z^T Z + \alpha I)^{-1} Z^T Y$ eliminates iterative backpropagation loops entirely.
+- **Hardware-Vectorized AVX2 + FMA**: Rank-1 updates ($P^{-1} \leftarrow P^{-1} - \gamma k k^T$ and $W \leftarrow W + \gamma k e^T$) unrolled with 256-bit SIMD intrinsics.
+- **Continual Streaming Learning (< 30µs)**: Real-time sample-by-sample recursive least squares (RLS) updates with zero heap allocation per stream step.
+- **Zero-Day & Few-Shot Detection**: Novelty-aware learning gain floor avoids $P^{-1}$ saturation on rare classes after large batch fits.
+- **Supervised Fisher / ANOVA Feature Weighting**: Automatic between-class to within-class variance ratio scaling for tabular datasets to surpass gradient boosted trees (e.g. XGBoost).
+- **Scikit-Learn Compatible API**: Drop-in `.fit(X, y)`, `.predict(X)`, `.score(X, y)`, `.update_online(x, label, sample_weight)`, and `.memory_mb()`.
+
+---
+
+## Installation
+
+```bash
+pip install tech-rkj
+```
+
+*Requirements*: Linux (x86_64 with AVX2 support), Python >= 3.9, NumPy >= 1.21.
+
+---
+
+## Quickstart
+
+### Batch Fitting & Evaluation
+```python
+import numpy as np
+from sklearn.datasets import load_digits
+from tech_rkj import SubspaceClassifier
+
+# Load dataset
+X, y = load_digits(return_X_y=True)
+X = (X / 16.0).astype(np.float32)
+y = y.astype(np.int64)
+
+# Split 80/20
+X_train, X_test = X[:1400], X[1400:]
+y_train, y_test = y[:1400], y[1400:]
+
+# Initialize classifier
+clf = SubspaceClassifier(
+    input_dim=64,
+    num_classes=10,
+    num_heads=4,
+    head_circuits=256,
+    alpha=1.0,
+    low_freq_scale=0.18,
+    high_freq_scale=0.38,
+)
+
+# Single-pass fit (no backpropagation)
+clf.fit(X_train, y_train)
+
+# Evaluate
+acc = clf.score(X_test, y_test)
+print(f"Test Accuracy: {acc * 100:.2f}%")
+print(f"Memory Footprint: {clf.memory_mb():.2f} MB")
+```
+
+### Continual Online Streaming (< 30µs / sample)
+```python
+# Stream new incoming sample dynamically without retraining
+clf.update_online(X_test[0], int(y_test[0]), sample_weight=1.0)
+
+# High-priority / zero-day novelty sample (e.g. few-shot rare event)
+clf.update_online(X_test[1], int(y_test[1]), sample_weight=5.0)
+```
+
+### Tabular Datasets with Fisher / ANOVA Feature Weighting
+```python
+# For tabular datasets with noisy or uninformative features
+clf_tab = SubspaceClassifier(
+    input_dim=32,
+    num_classes=4,
+    num_heads=4,
+    head_circuits=384,
+    alpha=0.5,
+    low_freq_scale=0.15,
+    high_freq_scale=0.35,
+    frontend_mode="zscore",  # Enables ANOVA F-statistic feature weighting
+)
+clf_tab.fit(X_tabular_train, y_tabular_train)
+```
+
+---
+
+## API Reference
+
+### `SubspaceClassifier`
+
+```python
+SubspaceClassifier(
+    input_dim: int,
+    num_classes: int,
+    num_heads: int = 4,
+    head_circuits: int = 384,
+    alpha: float = 8.0,
+    forgetting_factor: float = 1.0,
+    low_freq_scale: float = 0.055,
+    high_freq_scale: float = 0.115,
+    frontend_mode: str = "identity",  # "identity" | "zscore" | "vision_gabor"
+    lib_path: Optional[str] = None,
+)
+```
+
+- `fit(X, y)`: Fits the subspace model using single-pass closed-form Gauss-Jordan elimination.
+- `predict(X)`: Predicts class labels for sample array `X`.
+- `score(X, y)`: Computes mean classification accuracy on `(X, y)`.
+- `update_online(x, label, sample_weight=1.0)`: Performs sub-30µs streaming RLS rank-1 update.
+- `memory_mb()`: Returns the total internal memory footprint of the engine in megabytes.
+
+*(Note: `AICoreClassifier` is retained as an alias for backward compatibility.)*
+
+---
+
+## Benchmark Highlights
+
+- **Full MNIST 28x28 (784-D)**: Trained single-pass in ~2.1 seconds (**2.9x faster** than 10-epoch MLP backpropagation).
+- **Continual Learning Retention**: **95.25%** base class retention after streaming completely new unseen classes.
+- **Zero-Day Few-Shot Detection**: **82.14%** accuracy on 40 few-shot zero-day samples injected after 6,000 normal samples (with 99.00% normal class retention).
+- **Tabular 32D Benchmark**: **84.90%** accuracy (exceeds XGBoost baseline of 83.83%).
+
+---
+
+## License
+
+MIT License. Copyright (c) 2026 Jaydeep Prajapati.
+

tech_rkj-0.1.0/tech_rkj.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+tech_rkj/__init__.py
+tech_rkj/classifier.py
+tech_rkj.egg-info/PKG-INFO
+tech_rkj.egg-info/SOURCES.txt
+tech_rkj.egg-info/dependency_links.txt
+tech_rkj.egg-info/requires.txt
+tech_rkj.egg-info/top_level.txt
+tech_rkj/bin/libaicore_fw.so

tech_rkj-0.1.0/tech_rkj.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tech_rkj-0.1.0/tech_rkj.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.21

tech_rkj-0.1.0/tech_rkj.egg-info/top_level.txt

@@ -0,0 +1 @@
+tech_rkj