cosinefusion 0.1.0__tar.gz

cosinefusion-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Sam Chaudry
+
+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.

cosinefusion-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: cosinefusion
+Version: 0.1.0
+Summary: A high-performance C++ accelerated vector score fusion engine.
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Dynamic: license-file
+
+# Cosine Fusion
+
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/CookieMonsteriOS/CosineFusion)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/CookieMonsteriOS/CosineFusion/blob/main/LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)]()
+
+
+## Overview
+Cosine Fusion is a lightweight C++/Python cosine similarity engine using **pybind11**. It provides fast, vectorized similarity calculations between user and item feature matrices.
+
+## Features
+- C++ backend for high performance
+- Python interface via pybind11
+- Easy integration into Python projects
+- Simple example with user-item preference vectors
+
+## Use Cases / Applications
+- Recommender systems for e-commerce or media content
+- Personalization engines based on user preferences
+- Fast similarity search for AI/ML feature matching
+- Any project requiring high-performance cosine similarity computation
+
+## Installation
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/CookieMonsteriOS/CosineFusion.git
+cd CosineFusion
+pip install pybind11
+pip install .
+```
+
+## Usage Example
+```python
+import numpy as np
+import core_init
+
+
+# Example item features
+items = np.array([
+[0, 1, 0, 0, 1], # Tea
+[0, 1, 0, 0, 1], # Coffee
+[1, 0, 1, 1, 0], # Jaffa Cake
+[1, 0, 1, 0, 0], # Biscuit
+[1, 0, 1, 1, 1], # Chocolate Bar
+[0, 1, 0, 0, 1], # Espresso
+])
+
+
+item_names = ["Tea", "Coffee", "Jaffa Cake", "Biscuit", "Chocolate Bar", "Espresso"]
+
+
+user = np.array([[0, 0, 0, 1, 0]]) # User likes sweet + chocolate
+res = core_init.cosine_similarity(user, items)
+sim = res["similarity_matrix"]
+
+
+top_indices = np.argsort(sim[0])[::-1]
+print("Top recommendations for user:")
+for i in top_indices:
+print(f"{item_names[i]}: {sim[0][i]:.2f}") # Sample output showing relationships:
+
+# Top recommendations for user:
+# Chocolate Bar: 0.89
+# Jaffa Cake: 0.75 <- shows some similarity to Tea in sweetness
+# Biscuit: 0.65
+# Tea: 0.45
+# Coffee: 0.45
+# Espresso: 0.43
+```
+
+## Project Structure
+```
+CosineFusion/
+ ├── src/
+ │    ├── cpp/core_init.cpp
+ │    └── python/core_demo.py
+ ├── tests/test_bridge.py
+ ├── setup.py
+ ├── pyproject.toml
+ ├── README.md
+ ├── LICENSE
+ └── requirements.txt
+```
+
+## License
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
+
+---
+**Author:** Sam Chaudry  
+**GitHub:** [CookieMonsteriOS](https://github.com/CookieMonsteriOS)

cosinefusion-0.1.0/README.md

@@ -0,0 +1,92 @@
+# Cosine Fusion
+
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/CookieMonsteriOS/CosineFusion)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/CookieMonsteriOS/CosineFusion/blob/main/LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)]()
+
+
+## Overview
+Cosine Fusion is a lightweight C++/Python cosine similarity engine using **pybind11**. It provides fast, vectorized similarity calculations between user and item feature matrices.
+
+## Features
+- C++ backend for high performance
+- Python interface via pybind11
+- Easy integration into Python projects
+- Simple example with user-item preference vectors
+
+## Use Cases / Applications
+- Recommender systems for e-commerce or media content
+- Personalization engines based on user preferences
+- Fast similarity search for AI/ML feature matching
+- Any project requiring high-performance cosine similarity computation
+
+## Installation
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/CookieMonsteriOS/CosineFusion.git
+cd CosineFusion
+pip install pybind11
+pip install .
+```
+
+## Usage Example
+```python
+import numpy as np
+import core_init
+
+
+# Example item features
+items = np.array([
+[0, 1, 0, 0, 1], # Tea
+[0, 1, 0, 0, 1], # Coffee
+[1, 0, 1, 1, 0], # Jaffa Cake
+[1, 0, 1, 0, 0], # Biscuit
+[1, 0, 1, 1, 1], # Chocolate Bar
+[0, 1, 0, 0, 1], # Espresso
+])
+
+
+item_names = ["Tea", "Coffee", "Jaffa Cake", "Biscuit", "Chocolate Bar", "Espresso"]
+
+
+user = np.array([[0, 0, 0, 1, 0]]) # User likes sweet + chocolate
+res = core_init.cosine_similarity(user, items)
+sim = res["similarity_matrix"]
+
+
+top_indices = np.argsort(sim[0])[::-1]
+print("Top recommendations for user:")
+for i in top_indices:
+print(f"{item_names[i]}: {sim[0][i]:.2f}") # Sample output showing relationships:
+
+# Top recommendations for user:
+# Chocolate Bar: 0.89
+# Jaffa Cake: 0.75 <- shows some similarity to Tea in sweetness
+# Biscuit: 0.65
+# Tea: 0.45
+# Coffee: 0.45
+# Espresso: 0.43
+```
+
+## Project Structure
+```
+CosineFusion/
+ ├── src/
+ │    ├── cpp/core_init.cpp
+ │    └── python/core_demo.py
+ ├── tests/test_bridge.py
+ ├── setup.py
+ ├── pyproject.toml
+ ├── README.md
+ ├── LICENSE
+ └── requirements.txt
+```
+
+## License
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
+
+---
+**Author:** Sam Chaudry  
+**GitHub:** [CookieMonsteriOS](https://github.com/CookieMonsteriOS)

cosinefusion-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61.0.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "cosinefusion"
+version = "0.1.0"
+description = "A high-performance C++ accelerated vector score fusion engine."
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+	"Programming Language :: Python :: 3",
+	"Programming Language :: C++",
+	"License :: OSI Approved :: MIT License",
+	"Operating System :: OS Independent",
+]
+dependencies = [
+	"numpy>=1.24.0"
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]

cosinefusion-0.1.0/setup.cfg

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

cosinefusion-0.1.0/setup.py

@@ -0,0 +1,15 @@
+from setuptools import setup, Extension
+import os
+
+# Build the extension with the package namespace `cosinefusion.core_backend`.
+# The compiled binary will be placed in the package namespace so imports like
+# `from cosinefusion import core_backend` resolve directly to the extension.
+module = Extension(
+    'cosinefusion.core_backend',
+    sources=['src/cpp/core_init.cpp'],
+    extra_compile_args=['-O3', '-std=c++17']
+)
+
+setup(
+    ext_modules=[module]
+)

cosinefusion-0.1.0/src/cosinefusion/__init__.py

@@ -0,0 +1,20 @@
+"""cosinefusion package
+
+This package exposes the Python layer that interfaces with the compiled
+binary extension module `cosinefusion.core_backend`.
+
+Usage:
+    from cosinefusion import recommend
+
+The compiled extension is available as `cosinefusion.core_backend` and provides
+low-level routines such as `cosine_similarity(A, B)` which return a dict with
+keys `"similarity_matrix"` and optional `"meta"` information.
+
+The Python layer wraps and exposes higher-level helpers implemented in
+`core_demo.py`.
+"""
+
+from .core_demo import recommend, main  # re-export high-level helpers
+from . import core_backend  # compiled extension module
+
+__all__ = ["recommend", "main", "core_backend"]

cosinefusion-0.1.0/src/cosinefusion/core_demo.py

@@ -0,0 +1,53 @@
+import numpy as np
+from cosinefusion import core_backend as core_init
+
+
+def recommend(user, items, item_names=None, top_k=None):
+    """Compute similarity and return ranking info.
+
+    Parameters
+    - user: numpy array of shape (1, D)
+    - items: numpy array of shape (N, D)
+    - item_names: optional list of names for items
+    - top_k: optional int to limit returned results
+
+    Returns a dict containing:
+    - "similarity_matrix": numpy array of shape (1, N)
+    - "top_indices": numpy array of ranked indices (desc)
+    - "meta": optional metadata from the backend
+    """
+    res = core_init.cosine_similarity(user, items)
+    sim = res["similarity_matrix"]
+    top_indices = np.argsort(sim[0])[::-1]
+    if top_k is not None:
+        top_indices = top_indices[:top_k]
+    return {"similarity_matrix": sim, "top_indices": top_indices, "meta": res.get("meta", {})}
+
+
+def main():
+    items = np.array([
+        [0, 1, 0, 0, 1],  # Tea
+        [0, 1, 0, 0, 1],  # Coffee
+        [1, 0, 1, 1, 0],  # Jaffa Cake
+        [1, 0, 1, 0, 0],  # Biscuit
+        [1, 0, 1, 1, 1],  # Chocolate Bar
+        [0, 1, 0, 0, 1],  # Espresso
+    ])
+
+    item_names = ["Tea", "Coffee", "Jaffa Cake",
+                  "Biscuit", "Chocolate Bar", "Espresso"]
+
+    user = np.array([[0, 0, 0, 1, 0]])
+
+    out = recommend(user, items, item_names)
+    sim = out["similarity_matrix"]
+    top_indices = out["top_indices"]
+
+    print("Top recommendations for user:")
+    for i in top_indices:
+        name = item_names[i] if item_names is not None else str(i)
+        print(f"{name}: {sim[0][i]:.2f}")
+
+
+if __name__ == "__main__":
+    main()

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

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: cosinefusion
+Version: 0.1.0
+Summary: A high-performance C++ accelerated vector score fusion engine.
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C++
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24.0
+Dynamic: license-file
+
+# Cosine Fusion
+
+[![Build Status](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/CookieMonsteriOS/CosineFusion)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://github.com/CookieMonsteriOS/CosineFusion/blob/main/LICENSE)
+[![Python Version](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/)
+[![C++17](https://img.shields.io/badge/C%2B%2B-17-blue.svg)]()
+
+
+## Overview
+Cosine Fusion is a lightweight C++/Python cosine similarity engine using **pybind11**. It provides fast, vectorized similarity calculations between user and item feature matrices.
+
+## Features
+- C++ backend for high performance
+- Python interface via pybind11
+- Easy integration into Python projects
+- Simple example with user-item preference vectors
+
+## Use Cases / Applications
+- Recommender systems for e-commerce or media content
+- Personalization engines based on user preferences
+- Fast similarity search for AI/ML feature matching
+- Any project requiring high-performance cosine similarity computation
+
+## Installation
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/CookieMonsteriOS/CosineFusion.git
+cd CosineFusion
+pip install pybind11
+pip install .
+```
+
+## Usage Example
+```python
+import numpy as np
+import core_init
+
+
+# Example item features
+items = np.array([
+[0, 1, 0, 0, 1], # Tea
+[0, 1, 0, 0, 1], # Coffee
+[1, 0, 1, 1, 0], # Jaffa Cake
+[1, 0, 1, 0, 0], # Biscuit
+[1, 0, 1, 1, 1], # Chocolate Bar
+[0, 1, 0, 0, 1], # Espresso
+])
+
+
+item_names = ["Tea", "Coffee", "Jaffa Cake", "Biscuit", "Chocolate Bar", "Espresso"]
+
+
+user = np.array([[0, 0, 0, 1, 0]]) # User likes sweet + chocolate
+res = core_init.cosine_similarity(user, items)
+sim = res["similarity_matrix"]
+
+
+top_indices = np.argsort(sim[0])[::-1]
+print("Top recommendations for user:")
+for i in top_indices:
+print(f"{item_names[i]}: {sim[0][i]:.2f}") # Sample output showing relationships:
+
+# Top recommendations for user:
+# Chocolate Bar: 0.89
+# Jaffa Cake: 0.75 <- shows some similarity to Tea in sweetness
+# Biscuit: 0.65
+# Tea: 0.45
+# Coffee: 0.45
+# Espresso: 0.43
+```
+
+## Project Structure
+```
+CosineFusion/
+ ├── src/
+ │    ├── cpp/core_init.cpp
+ │    └── python/core_demo.py
+ ├── tests/test_bridge.py
+ ├── setup.py
+ ├── pyproject.toml
+ ├── README.md
+ ├── LICENSE
+ └── requirements.txt
+```
+
+## License
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
+
+---
+**Author:** Sam Chaudry  
+**GitHub:** [CookieMonsteriOS](https://github.com/CookieMonsteriOS)

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

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+src/cosinefusion/__init__.py
+src/cosinefusion/core_demo.py
+src/cosinefusion.egg-info/PKG-INFO
+src/cosinefusion.egg-info/SOURCES.txt
+src/cosinefusion.egg-info/dependency_links.txt
+src/cosinefusion.egg-info/requires.txt
+src/cosinefusion.egg-info/top_level.txt
+src/cpp/core_init.cpp
+tests/test_bridge.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,2 @@
+cosinefusion
+cpp

cosinefusion-0.1.0/src/cpp/core_init.cpp

@@ -0,0 +1,76 @@
+#include <pybind11/pybind11.h>
+#include <iostream>
+#include <pybind11/numpy.h>
+#include <cmath>
+#include <stdexcept>
+
+namespace py = pybind11;
+using namespace pybind11::literals;
+
+py::dict cosine_similarity(py::array_t<double> A, py::array_t<double> B) {
+    
+    auto a = A.unchecked<2>();
+    auto b = B.unchecked<2>();
+    
+    if (a.shape(1) != b.shape(1))
+        throw std::runtime_error("Matrix mismatch"); 
+    
+    ssize_t n_a = a.shape(0); // Count users/rows in A -> eg. Customer
+    ssize_t n_b = b.shape(0); // How many items in Row B -> eg. Items
+    ssize_t dim = a.shape(1); // Count Number of columns (e.g. 128 features) -> eg. Features data points in each row
+    
+     //Output matrix
+    py::array_t<double> result({n_a, n_b});
+    auto r = result.mutable_unchecked<2>();
+
+    // Store user lengths in norm_a and norm_b
+    std::vector<double> norm_a(n_a, 0.0), norm_b(n_b, 0.0); 
+    
+    // compute norms for rows of A
+    for (ssize_t i = 0; i < n_a; ++i) {
+        double s = 0.0;
+        for (ssize_t d = 0; d < dim; ++d) {
+            double v = a(i, d);
+            s += v * v;
+        }
+        norm_a[i] = std::sqrt(s);
+    }
+    // compute norms for rows of B
+    for (ssize_t j = 0; j < n_b; ++j) {
+        double s = 0.0;
+        for (ssize_t d = 0; d < dim; ++d) {
+            double v = b(j, d);
+            s += v * v;
+        }
+        norm_b[j] = std::sqrt(s);
+    }
+
+    // compute cosine similarity for each pair
+    for (ssize_t i = 0; i < n_a; ++i) {
+        for (ssize_t j = 0; j < n_b; ++j) {
+            double dot = 0.0;
+            for (ssize_t d = 0; d < dim; ++d)
+                dot += a(i, d) * b(j, d);
+            double denom = norm_a[i] * norm_b[j];
+            r(i, j) = (denom == 0.0) ? 0.0 : dot / denom;
+        }
+    }
+
+    py::dict output;
+    output["similarity_matrix"] = result;
+    output["meta"] = py::dict(
+        "n_a"_a = n_a,
+        "n_b"_a = n_b,
+        "dim"_a = dim,
+        "metric"_a = "cosine_similarity"
+    );
+
+    return output; 
+}
+
+
+PYBIND11_MODULE(core_backend, m) {
+    m.doc() = "C++ cosine similarity exposed to Python via pybind11 as core_backend";
+    m.def("cosine_similarity", &cosine_similarity, "Compute cosine similarity",
+          py::arg("A"), py::arg("B"));
+}

cosinefusion-0.1.0/tests/test_bridge.py

@@ -0,0 +1,65 @@
+from cosinefusion import core_backend as core_init
+import numpy as np
+import sys
+import os
+# Ensure local src/ is on path so tests import the package in-place
+sys.path.insert(0, os.path.abspath(
+    os.path.join(os.path.dirname(__file__), '../src')))
+
+
+def test_cosine_similarity_shape():
+    """Ensure the returned similarity matrix has the correct shape."""
+    A = np.random.rand(3, 4)
+    B = np.random.rand(5, 4)
+    res = core_init.cosine_similarity(A, B)
+    sim = res["similarity_matrix"]
+    meta = res["meta"]
+
+    # Assert matrix shape
+    assert sim.shape == (3, 5)
+    # Assert metadata matches
+    assert meta["n_a"] == 3
+    assert meta["n_b"] == 5
+    assert meta["dim"] == 4
+    assert meta["metric"] == "cosine_similarity"
+
+
+def test_cosine_similarity_values():
+    """Check that identical vectors return a similarity of 1."""
+    A = np.array([[1, 2, 3]])
+    B = np.array([[1, 2, 3], [3, 2, 1]])
+    res = core_init.cosine_similarity(A, B)
+    sim = res["similarity_matrix"]
+
+    # The first comparison (same vectors) should be 1.0
+    np.testing.assert_almost_equal(sim[0, 0], 1.0, decimal=6)
+    # The second should be less than 1.0
+    assert sim[0, 1] < 1.0
+
+
+def test_user_item_recommendations():
+    """Validate that top-ranked items match expected feature preferences."""
+    items = np.array([
+        [0, 1, 0, 0, 1],  # Tea
+        [0, 1, 0, 0, 1],  # Coffee
+        [1, 0, 1, 1, 0],  # Jaffa Cake
+        [1, 0, 1, 0, 0],  # Biscuit
+        [1, 0, 1, 1, 1],  # Chocolate Bar
+        [0, 1, 0, 0, 1],  # Espresso
+    ])
+    item_names = ["Tea", "Coffee", "Jaffa Cake",
+                  "Biscuit", "Chocolate Bar", "Espresso"]
+
+    # User likes sweet + chocolate
+    user = np.array([[0, 0, 0, 1, 0]])
+
+    res = core_init.cosine_similarity(user, items)
+    sim = res["similarity_matrix"]
+
+    top_indices = np.argsort(sim[0])[::-1]
+    top_item = item_names[top_indices[0]]
+
+    # Expect Jaffa Cake to be top match (matches cosine similarity scoring)
+    assert top_item == "Jaffa Cake"
+    # The similarity should be positive and within range
+    assert 0.0 <= sim[0][top_indices[0]] <= 1.0