nn-engine-core 0.1.0__tar.gz

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

@@ -0,0 +1,62 @@
+name: Build and Publish to PyPI
+
+on:
+  release:
+    types:
+      - published
+  workflow_dispatch:
+
+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
+        env:
+          CIBW_BEFORE_ALL_MACOS: brew install libomp
+
+      - 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/nn-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

nn_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/

nn_engine_core-0.1.0/CMakeLists.txt

@@ -0,0 +1,63 @@
+cmake_minimum_required(VERSION 3.18)
+
+if(POLICY CMP0135)
+    cmake_policy(SET CMP0135 NEW)
+endif()
+
+project(NN_ENGINE LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+if(NOT MSVC)
+    if(APPLE)
+        add_compile_options(-O3)
+    else()
+        add_compile_options(-O3 -march=native)
+    endif()
+endif()
+
+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)
+
+find_package(OpenMP)
+
+pybind11_add_module(nn_core NO_EXTRAS
+    src/binding.cpp 
+    src/core/Model.cpp
+    src/parametric/LogisticNeuron.cpp
+    src/parametric/DenseLayer.cpp
+    src/parametric/ReLULayer.cpp
+)
+
+target_include_directories(nn_core SYSTEM PRIVATE 
+    include 
+    ${eigen_SOURCE_DIR}
+)
+
+target_link_libraries(nn_core PRIVATE pybind11::module)
+
+if(OpenMP_CXX_FOUND)
+    target_link_libraries(nn_core PRIVATE OpenMP::OpenMP_CXX)
+    message(STATUS "OpenMP found: Multi-threading enabled in NNEngine.")
+else()
+    message(WARNING "OpenMP NOT found: Falling back to single-threaded NNEngine.")
+endif()
+
+target_compile_definitions(nn_core PRIVATE EIGEN_USE_THREADS)
+
+install(TARGETS nn_core DESTINATION .)

nn_engine_core-0.1.0/LICENSE

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

nn_engine_core-0.1.0/PKG-INFO

@@ -0,0 +1,158 @@
+Metadata-Version: 2.2
+Name: nn-engine-core
+Version: 0.1.0
+Summary: A high-performance C++ parametric optimization backend for NNEngine
+License: MIT
+Requires-Python: >=3.8
+Requires-Dist: numpy
+Description-Content-Type: text/markdown
+
+# NN Engine Core
+
+[![PyPI version](https://img.shields.io/pypi/v/nn-engine-core?logo=pypi&logoColor=white)](https://pypi.org/project/nn-engine-core/)
+[![Python](https://img.shields.io/pypi/pyversions/nn-engine-core?logo=python&logoColor=white)](https://pypi.org/project/nn-engine-core/)
+[![Build system](https://img.shields.io/badge/build-scikit--build--core-blue?logo=cmake&logoColor=white)](https://scikit-build-core.readthedocs.io/)
+[![Bindings](https://img.shields.io/badge/bindings-pybind11-4C72B0?logo=python&logoColor=white)](https://pybind11.readthedocs.io/)
+
+A high-performance, fully native C++ Neural Network engine exposed to Python via pybind11. 
+
+Designed for rapid experimentation without the Python Global Interpreter Lock (GIL) overhead, `nn-engine-core` executes the entire deep learning training loop (forward pass, loss calculation, backpropagation, and weight updates) strictly in native C++ using Eigen, achieving significant speedups over standard Python-loop ML libraries.
+
+## Highlights
+
+- **Native Loop Hoisting**: The `Model::fit` loop executes entirely in C++, eliminating the Python GIL overhead across epochs.
+- **Memory-Optimized Backpropagation**: Utilizes Eigen's `.noalias()` to perform in-place matrix calculus without allocating temporary memory buffers.
+- **Mathematically Stable**: Built-in Xavier (Glorot) initialization and batch-normalized gradients to prevent exploding gradients.
+- **Cross-Platform Threading**: Graceful degradation OpenMP support. Uses multi-threading where available, gracefully falling back to single-threaded standard C++ on restricted environments (e.g., Apple Clang without `libomp`).
+- **Clean Python API**: A familiar Keras/scikit-learn style interface.
+
+## Repository Structure
+
+```text
+.
+├── CMakeLists.txt
+├── pyproject.toml
+├── include/
+│   ├── core/
+│   │   ├── Layer.hpp
+│   │   ├── Loss.hpp
+│   │   └── Model.hpp
+│   └── parametric/
+│       ├── DenseLayer.hpp
+│       ├── LogisticNeuron.hpp
+│       ├── ReLULayer.hpp
+│       └── Sequential.hpp
+├── src/
+│   ├── binding.cpp
+│   ├── core/
+│   │   └── Model.cpp
+│   └── parametric/
+│       ├── DenseLayer.cpp
+│       ├── LogisticNeuron.cpp
+│       └── ReLULayer.cpp
+└── examples/
+    └── script.py
+```
+
+## Requirements
+
+- Python 3.8+
+- CMake 3.18+
+- C++17 compiler
+- Ninja (recommended generator)
+
+Python dependencies are declared in `pyproject.toml`:
+- `numpy`
+
+## Installation
+
+### Option 1: Install from PyPI (recommended)
+
+```bash
+pip install nn-engine-core
+```
+
+### Option 2: Install from source (editable)
+
+From the project root:
+
+```bash
+python -m pip install -U pip
+python -m pip install -e .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import nn_core
+
+# Example Data (Scaled)
+X_train = np.random.rand(100, 20).astype(np.float64)
+y_train = np.random.rand(100, 1).astype(np.float64)
+
+# 1. Initialize the Model
+model = nn_core.Model()
+
+# 2. Build Architecture
+model.add(nn_core.DenseLayer(20, 64))
+model.add(nn_core.ReLULayer())
+model.add(nn_core.DenseLayer(64, 1))
+
+# 3. Compile with Loss Function
+model.compile(nn_core.MSELoss())
+
+# 4. Train (Executes entirely in C++)
+model.fit(X_train, y_train, epochs=200, learning_rate=0.01, verbose=True)
+
+# 5. Predict
+sample = np.random.rand(1, 20).astype(np.float64)
+predictions = model.predict(sample)
+print("Prediction:", predictions)
+```
+
+## Python API
+
+### `Model()`
+The orchestrator for the neural network.
+- `add(layer)`: Appends a layer to the network sequence.
+- `compile(loss_fn)`: Attaches a loss function to the model.
+- `fit(X, y, epochs=100, learning_rate=0.01, verbose=True)`: Executes full-batch gradient descent. *Note: `X` and `y` must be 2D `float64` NumPy arrays.*
+- `predict(X)`: Runs a forward pass on new data.
+
+### Layers (`nn_core.*`)
+- `DenseLayer(input_dim: int, output_dim: int)`: A fully connected parametric layer using Xavier initialization.
+- `ReLULayer()`: A non-parametric Rectified Linear Unit activation layer.
+- `Sequential()`: The underlying layer container (automatically managed by `Model`).
+
+### Loss Functions (`nn_core.*`)
+- `MSELoss()`: Mean Squared Error loss. Automatically normalizes gradients by batch size.
+
+## Benchmark Results
+
+The following results were produced using a non-linear regression dataset (`sklearn.datasets.make_regression`, 5000 samples, 20 features, noise=0.1) trained over 200 epochs via Full-Batch Gradient Descent. 
+
+Comparing `NNEngine` against `sklearn.neural_network.MLPRegressor` natively highlights the extreme performance advantage of C++ loop hoisting and `noalias()` matrix optimization.
+
+| Engine | MSE | Time | Speedup |
+|---|---:|---:|---:|
+| **NNEngine (C++)** | **0.067268** | **0.5593s** | **2.59×** |
+| Scikit-Learn | 0.145411 | 1.4470s | 1.00× |
+
+Console output:
+```text
+--- Testing NNEngine: Non-Linear Regression ---
+Training NNEngine...
+NNEngine   | MSE: 0.067268 | Time: 0.5593s
+
+Training Scikit-Learn...
+Scikit-Learn | MSE: 0.145411 | Time: 1.4470s
+
+Speedup: 2.59x faster than Sklearn!
+```
+
+## Notes and Limitations
+
+- Targets (`y`) passed to `model.fit()` must be strictly 2D arrays (e.g., shape `(N, 1)` for regression), unlike scikit-learn which often accepts 1D arrays.
+- The optimizer is currently integrated as Vanilla Full-Batch Gradient Descent. 
+- Input and Target data should be standardized (e.g., mean `0`, variance `1`) before passing to `fit()` to maintain gradient stability.

nn_engine_core-0.1.0/README.md

@@ -0,0 +1,149 @@
+# NN Engine Core
+
+[![PyPI version](https://img.shields.io/pypi/v/nn-engine-core?logo=pypi&logoColor=white)](https://pypi.org/project/nn-engine-core/)
+[![Python](https://img.shields.io/pypi/pyversions/nn-engine-core?logo=python&logoColor=white)](https://pypi.org/project/nn-engine-core/)
+[![Build system](https://img.shields.io/badge/build-scikit--build--core-blue?logo=cmake&logoColor=white)](https://scikit-build-core.readthedocs.io/)
+[![Bindings](https://img.shields.io/badge/bindings-pybind11-4C72B0?logo=python&logoColor=white)](https://pybind11.readthedocs.io/)
+
+A high-performance, fully native C++ Neural Network engine exposed to Python via pybind11. 
+
+Designed for rapid experimentation without the Python Global Interpreter Lock (GIL) overhead, `nn-engine-core` executes the entire deep learning training loop (forward pass, loss calculation, backpropagation, and weight updates) strictly in native C++ using Eigen, achieving significant speedups over standard Python-loop ML libraries.
+
+## Highlights
+
+- **Native Loop Hoisting**: The `Model::fit` loop executes entirely in C++, eliminating the Python GIL overhead across epochs.
+- **Memory-Optimized Backpropagation**: Utilizes Eigen's `.noalias()` to perform in-place matrix calculus without allocating temporary memory buffers.
+- **Mathematically Stable**: Built-in Xavier (Glorot) initialization and batch-normalized gradients to prevent exploding gradients.
+- **Cross-Platform Threading**: Graceful degradation OpenMP support. Uses multi-threading where available, gracefully falling back to single-threaded standard C++ on restricted environments (e.g., Apple Clang without `libomp`).
+- **Clean Python API**: A familiar Keras/scikit-learn style interface.
+
+## Repository Structure
+
+```text
+.
+├── CMakeLists.txt
+├── pyproject.toml
+├── include/
+│   ├── core/
+│   │   ├── Layer.hpp
+│   │   ├── Loss.hpp
+│   │   └── Model.hpp
+│   └── parametric/
+│       ├── DenseLayer.hpp
+│       ├── LogisticNeuron.hpp
+│       ├── ReLULayer.hpp
+│       └── Sequential.hpp
+├── src/
+│   ├── binding.cpp
+│   ├── core/
+│   │   └── Model.cpp
+│   └── parametric/
+│       ├── DenseLayer.cpp
+│       ├── LogisticNeuron.cpp
+│       └── ReLULayer.cpp
+└── examples/
+    └── script.py
+```
+
+## Requirements
+
+- Python 3.8+
+- CMake 3.18+
+- C++17 compiler
+- Ninja (recommended generator)
+
+Python dependencies are declared in `pyproject.toml`:
+- `numpy`
+
+## Installation
+
+### Option 1: Install from PyPI (recommended)
+
+```bash
+pip install nn-engine-core
+```
+
+### Option 2: Install from source (editable)
+
+From the project root:
+
+```bash
+python -m pip install -U pip
+python -m pip install -e .
+```
+
+## Quick Start
+
+```python
+import numpy as np
+import nn_core
+
+# Example Data (Scaled)
+X_train = np.random.rand(100, 20).astype(np.float64)
+y_train = np.random.rand(100, 1).astype(np.float64)
+
+# 1. Initialize the Model
+model = nn_core.Model()
+
+# 2. Build Architecture
+model.add(nn_core.DenseLayer(20, 64))
+model.add(nn_core.ReLULayer())
+model.add(nn_core.DenseLayer(64, 1))
+
+# 3. Compile with Loss Function
+model.compile(nn_core.MSELoss())
+
+# 4. Train (Executes entirely in C++)
+model.fit(X_train, y_train, epochs=200, learning_rate=0.01, verbose=True)
+
+# 5. Predict
+sample = np.random.rand(1, 20).astype(np.float64)
+predictions = model.predict(sample)
+print("Prediction:", predictions)
+```
+
+## Python API
+
+### `Model()`
+The orchestrator for the neural network.
+- `add(layer)`: Appends a layer to the network sequence.
+- `compile(loss_fn)`: Attaches a loss function to the model.
+- `fit(X, y, epochs=100, learning_rate=0.01, verbose=True)`: Executes full-batch gradient descent. *Note: `X` and `y` must be 2D `float64` NumPy arrays.*
+- `predict(X)`: Runs a forward pass on new data.
+
+### Layers (`nn_core.*`)
+- `DenseLayer(input_dim: int, output_dim: int)`: A fully connected parametric layer using Xavier initialization.
+- `ReLULayer()`: A non-parametric Rectified Linear Unit activation layer.
+- `Sequential()`: The underlying layer container (automatically managed by `Model`).
+
+### Loss Functions (`nn_core.*`)
+- `MSELoss()`: Mean Squared Error loss. Automatically normalizes gradients by batch size.
+
+## Benchmark Results
+
+The following results were produced using a non-linear regression dataset (`sklearn.datasets.make_regression`, 5000 samples, 20 features, noise=0.1) trained over 200 epochs via Full-Batch Gradient Descent. 
+
+Comparing `NNEngine` against `sklearn.neural_network.MLPRegressor` natively highlights the extreme performance advantage of C++ loop hoisting and `noalias()` matrix optimization.
+
+| Engine | MSE | Time | Speedup |
+|---|---:|---:|---:|
+| **NNEngine (C++)** | **0.067268** | **0.5593s** | **2.59×** |
+| Scikit-Learn | 0.145411 | 1.4470s | 1.00× |
+
+Console output:
+```text
+--- Testing NNEngine: Non-Linear Regression ---
+Training NNEngine...
+NNEngine   | MSE: 0.067268 | Time: 0.5593s
+
+Training Scikit-Learn...
+Scikit-Learn | MSE: 0.145411 | Time: 1.4470s
+
+Speedup: 2.59x faster than Sklearn!
+```
+
+## Notes and Limitations
+
+- Targets (`y`) passed to `model.fit()` must be strictly 2D arrays (e.g., shape `(N, 1)` for regression), unlike scikit-learn which often accepts 1D arrays.
+- The optimizer is currently integrated as Vanilla Full-Batch Gradient Descent. 
+- Input and Target data should be standardized (e.g., mean `0`, variance `1`) before passing to `fit()` to maintain gradient stability.

nn_engine_core-0.1.0/examples/script.py

@@ -0,0 +1,94 @@
+import nn_core
+import numpy as np
+import time
+from sklearn.datasets import make_regression
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.neural_network import MLPRegressor
+from sklearn.metrics import mean_squared_error
+
+def test_regression_performance():
+    print("\n--- Testing NNEngine: Non-Linear Regression ---")
+    
+    # 1. Generate Data
+    # 5000 samples, 20 features, making it slightly non-linear
+    X, y = make_regression(n_samples=5000, n_features=20, noise=0.1, random_state=42)
+    
+    # NNEngine strictly expects 2D matrices (MatrixRM) for both X and y.
+    # Scikit-learn generates y as (N,), so we must reshape it to (N, 1).
+    y = y.reshape(-1, 1)
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X.astype(np.float64), y.astype(np.float64), test_size=0.2, random_state=42
+    )
+
+    # Neural Networks require scaled data to prevent exploding gradients
+    scaler_X = StandardScaler()
+    scaler_y = StandardScaler()
+    
+    X_train_scaled = scaler_X.fit_transform(X_train)
+    X_test_scaled = scaler_X.transform(X_test)
+    y_train_scaled = scaler_y.fit_transform(y_train)
+    y_test_scaled = scaler_y.transform(y_test)
+
+    # Architecture Config
+    epochs = 200
+    lr = 0.01
+
+    # ==========================================
+    # Custom NNEngine (C++ Native)
+    # ==========================================
+    model = nn_core.Model()
+    model.add(nn_core.DenseLayer(20, 64))
+    model.add(nn_core.ReLULayer())
+    model.add(nn_core.DenseLayer(64, 1))
+    model.compile(nn_core.MSELoss())
+
+    print("Training NNEngine...")
+    t0 = time.perf_counter()
+    # Verbose=False to avoid cluttering the benchmark output
+    model.fit(X_train_scaled, y_train_scaled, epochs=epochs, learning_rate=lr, verbose=False)
+    t1 = time.perf_counter()
+
+    nn_preds = model.predict(X_test_scaled)
+    nn_mse = mean_squared_error(y_test_scaled, nn_preds)
+    nn_time = t1 - t0
+
+    print(f"NNEngine   | MSE: {nn_mse:.6f} | Time: {nn_time:.4f}s")
+
+    # ==========================================
+    # Scikit-Learn (MLPRegressor)
+    # ==========================================
+    print("Training Scikit-Learn...")
+    # Configure sklearn to mirror our C++ Engine:
+    # solver='sgd' with momentum=0 mirrors our basic Vanilla Gradient Descent.
+    # batch_size=X_train.shape[0] forces Full-Batch GD instead of mini-batches.
+    sk_model = MLPRegressor(
+        hidden_layer_sizes=(64,), 
+        activation='relu', 
+        solver='sgd',
+        batch_size=X_train.shape[0], 
+        learning_rate_init=lr,
+        max_iter=epochs,
+        momentum=0.0,
+        random_state=42
+    )
+
+    t0 = time.perf_counter()
+    # sklearn expects y as (N,)
+    sk_model.fit(X_train_scaled, y_train_scaled.ravel())
+    t1 = time.perf_counter()
+
+    sk_preds = sk_model.predict(X_test_scaled)
+    sk_mse = mean_squared_error(y_test_scaled.ravel(), sk_preds)
+    sk_time = t1 - t0
+
+    print(f"Scikit-Learn | MSE: {sk_mse:.6f} | Time: {sk_time:.4f}s")
+    
+    if nn_time < sk_time:
+        print(f"Speedup: {sk_time / nn_time:.2f}x faster than Sklearn!")
+    else:
+        print(f"Speedup: Sklearn is {nn_time / sk_time:.2f}x faster.")
+
+if __name__ == "__main__":
+    test_regression_performance()

nn_engine_core-0.1.0/include/core/Layer.hpp

@@ -0,0 +1,21 @@
+#pragma once
+#include <Eigen/Core>
+#include <iostream>
+
+namespace mlengine::core {
+
+using MatrixRM =
+    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+
+class Layer {
+ public:
+  virtual ~Layer() = default;
+
+  virtual void forward(const MatrixRM& input, MatrixRM& output) = 0;
+
+  virtual MatrixRM backward(const MatrixRM& output_gradient) = 0;
+
+  virtual void update_weights(double learning_rate) {}
+};
+
+}

nn_engine_core-0.1.0/include/core/Loss.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <Eigen/Core>
+
+namespace mlengine::core {
+
+class Loss {
+ public:
+  virtual ~Loss() = default;
+  virtual double calculate(const MatrixRM& predictions,
+                           const MatrixRM& targets) = 0;
+  virtual MatrixRM backward(const MatrixRM& predictions,
+                            const MatrixRM& targets) = 0;
+};
+
+class MSELoss : public Loss {
+ public:
+  double calculate(const MatrixRM& predictions,
+                   const MatrixRM& targets) override {
+    return (predictions - targets).squaredNorm() / predictions.rows();
+  }
+
+  MatrixRM backward(const MatrixRM& predictions,
+                    const MatrixRM& targets) override {
+    return 2.0 * (predictions - targets) / predictions.rows();
+  }
+};
+
+}

nn_engine_core-0.1.0/include/core/Model.hpp

@@ -0,0 +1,28 @@
+#pragma once
+#include <Eigen/Core>
+#include <memory>
+
+#include "core/Layer.hpp"
+#include "core/Loss.hpp"
+#include "parametric/Sequential.hpp"
+
+namespace mlengine::core {
+
+class Model {
+ public:
+  Model();
+
+  void add(std::shared_ptr<Layer> layer);
+  void compile(std::shared_ptr<Loss> loss_fn);
+
+  void fit(const MatrixRM& X, const MatrixRM& y, int epochs,
+           double learning_rate, bool verbose = true);
+
+  MatrixRM predict(const MatrixRM& X);
+
+ private:
+  std::shared_ptr<parametric::Sequential> network_;
+  std::shared_ptr<Loss> loss_fn_;
+};
+
+}

nn_engine_core-0.1.0/include/parametric/DenseLayer.hpp

@@ -0,0 +1,25 @@
+#pragma once
+#include "core/Layer.hpp"
+
+namespace mlengine::parametric {
+
+class DenseLayer : public core::Layer {
+ public:
+  DenseLayer(int input_dim, int output_dim);
+
+  void forward(const core::MatrixRM& input, core::MatrixRM& output) override;
+  core::MatrixRM backward(const core::MatrixRM& output_gradient) override;
+  void update_weights(double learning_rate) override;
+
+  core::MatrixRM get_weights() const { return weights_; }
+  core::MatrixRM get_bias() const { return bias_; }
+
+ private:
+  core::MatrixRM weights_;
+  core::MatrixRM bias_;
+  core::MatrixRM last_input_;
+  core::MatrixRM dW_;
+  core::MatrixRM db_;
+};
+
+}

nn_engine_core-0.1.0/include/parametric/LogisticNeuron.hpp

@@ -0,0 +1,29 @@
+#pragma once
+#include <Eigen/Core>
+
+namespace mlengine::parametric {
+
+using MatrixRM =
+    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+using VectorRM = Eigen::Matrix<double, Eigen::Dynamic, 1>;
+
+class LogisticNeuron {
+ public:
+  LogisticNeuron() = default;
+
+  void fit(const MatrixRM& X, const VectorRM& y, int epochs,
+           double learning_rate);
+
+  VectorRM predict_proba(const MatrixRM& X) const;
+
+  VectorRM predict(const MatrixRM& X) const;
+
+  VectorRM get_weights() const { return weights_; }
+  double get_bias() const { return bias_; }
+
+ private:
+  VectorRM weights_;
+  double bias_ = 0.0;
+};
+
+}

nn_engine_core-0.1.0/include/parametric/ReLULayer.hpp

@@ -0,0 +1,15 @@
+#pragma once
+#include "core/Layer.hpp"
+
+namespace mlengine::parametric {
+
+class ReLULayer : public core::Layer {
+ public:
+  void forward(const core::MatrixRM& input, core::MatrixRM& output) override;
+  core::MatrixRM backward(const core::MatrixRM& output_gradient) override;
+
+ private:
+  core::MatrixRM last_input_;
+};
+
+}

nn_engine_core-0.1.0/include/parametric/Sequential.hpp

@@ -0,0 +1,43 @@
+#pragma once
+#include <iostream>
+#include <memory>
+#include <vector>
+
+#include "core/Layer.hpp"
+
+namespace mlengine::parametric {
+
+class Sequential : public core::Layer {
+ public:
+  void add(std::shared_ptr<core::Layer> layer) { layers_.push_back(layer); }
+
+  void forward(const core::MatrixRM& input, core::MatrixRM& output) override {
+    core::MatrixRM current_input = input;
+    core::MatrixRM current_output;
+
+    for (auto& layer : layers_) {
+      layer->forward(current_input, current_output);
+      current_input = current_output;
+    }
+    output = current_input;
+  }
+
+  core::MatrixRM backward(const core::MatrixRM& output_gradient) override {
+    core::MatrixRM gradient = output_gradient;
+    for (auto it = layers_.rbegin(); it != layers_.rend(); ++it) {
+      gradient = (*it)->backward(gradient);
+    }
+    return gradient;
+  }
+
+  void update_weights(double learning_rate) override {
+    for (auto& layer : layers_) {
+      layer->update_weights(learning_rate);
+    }
+  }
+
+ private:
+  std::vector<std::shared_ptr<core::Layer>> layers_;
+};
+
+}  // namespace mlengine::parametric

nn_engine_core-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["scikit-build-core", "pybind11"]
+build-backend = "scikit_build_core.build"
+
+[project]
+name = "nn-engine-core"
+version = "0.1.0"
+description = "A high-performance C++ parametric optimization backend for NNEngine"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.8"
+dependencies = [
+    "numpy"
+]
+
+[tool.scikit-build]
+cmake.version = ">=3.18"
+wheel.install-dir = "."
+
+[tool.cibuildwheel]
+skip = "*-musllinux_*"

nn_engine_core-0.1.0/src/binding.cpp

@@ -0,0 +1,85 @@
+#include <pybind11/eigen.h>
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+
+#include <memory>
+
+#include "core/Layer.hpp"
+#include "core/Loss.hpp"
+#include "core/Model.hpp"
+#include "parametric/DenseLayer.hpp"
+#include "parametric/LogisticNeuron.hpp"
+#include "parametric/ReLULayer.hpp"
+#include "parametric/Sequential.hpp"
+
+namespace py = pybind11;
+using namespace mlengine::core;
+using namespace mlengine::parametric;
+
+PYBIND11_MODULE(nn_core, m) {
+  m.doc() = "C++ Parametric Optimization Layer Engine for NNEngine";
+
+  py::class_<Layer, std::shared_ptr<Layer>>(m, "Layer")
+      .def("update_weights", &Layer::update_weights);
+
+  py::class_<Loss, std::shared_ptr<Loss>>(m, "Loss");
+
+  py::class_<MSELoss, Loss, std::shared_ptr<MSELoss>>(m, "MSELoss")
+      .def(py::init<>())
+      .def("calculate", &MSELoss::calculate)
+      .def("backward", &MSELoss::backward);
+
+  py::class_<LogisticNeuron>(m, "LogisticNeuron")
+      .def(py::init<>())
+      .def("fit", &LogisticNeuron::fit, py::arg("X"), py::arg("y"),
+           py::arg("epochs"), py::arg("learning_rate"))
+      .def("predict_proba", &LogisticNeuron::predict_proba)
+      .def("predict", &LogisticNeuron::predict)
+      .def("get_weights", &LogisticNeuron::get_weights)
+      .def("get_bias", &LogisticNeuron::get_bias);
+
+  py::class_<DenseLayer, Layer, std::shared_ptr<DenseLayer>>(m, "DenseLayer")
+      .def(py::init<int, int>())
+      .def("forward",
+           [](DenseLayer& self, const MatrixRM& input) {
+             MatrixRM output;
+             self.forward(input, output);
+             return output;
+           })
+      .def("backward", &DenseLayer::backward)
+      .def("update_weights", &DenseLayer::update_weights)
+      .def("get_weights", &DenseLayer::get_weights)
+      .def("get_bias", &DenseLayer::get_bias);
+
+  py::class_<ReLULayer, Layer, std::shared_ptr<ReLULayer>>(m, "ReLULayer")
+      .def(py::init<>())
+      .def("forward",
+           [](ReLULayer& self, const MatrixRM& input) {
+             MatrixRM output;
+             self.forward(input, output);
+             return output;
+           })
+      .def("backward", &ReLULayer::backward)
+      .def("update_weights", &ReLULayer::update_weights);
+
+  py::class_<Sequential, Layer, std::shared_ptr<Sequential>>(m, "Sequential")
+      .def(py::init<>())
+      .def("add", &Sequential::add, py::arg("layer"))
+      .def("forward",
+           [](Sequential& self, const MatrixRM& input) {
+             MatrixRM output;
+             self.forward(input, output);
+             return output;
+           })
+      .def("backward", &Sequential::backward)
+      .def("update_weights", &Sequential::update_weights);
+
+  py::class_<Model, std::shared_ptr<Model>>(m, "Model")
+      .def(py::init<>())
+      .def("add", &Model::add, py::arg("layer"))
+      .def("compile", &Model::compile, py::arg("loss_fn"))
+      .def("fit", &Model::fit, py::arg("X"), py::arg("y"),
+           py::arg("epochs") = 100, py::arg("learning_rate") = 0.01,
+           py::arg("verbose") = true)
+      .def("predict", &Model::predict, py::arg("X"));
+}

nn_engine_core-0.1.0/src/core/Model.cpp

@@ -0,0 +1,46 @@
+#include "core/Model.hpp"
+
+#include <algorithm>
+#include <iostream>
+#include <stdexcept>
+
+namespace mlengine::core {
+
+Model::Model() { network_ = std::make_shared<parametric::Sequential>(); }
+
+void Model::add(std::shared_ptr<Layer> layer) { network_->add(layer); }
+
+void Model::compile(std::shared_ptr<Loss> loss_fn) { loss_fn_ = loss_fn; }
+
+void Model::fit(const MatrixRM& X, const MatrixRM& y, int epochs,
+                double learning_rate, bool verbose) {
+  if (!loss_fn_) {
+    throw std::runtime_error(
+        "Model must be compiled with a loss function before fitting.");
+  }
+
+  for (int epoch = 0; epoch < epochs; ++epoch) {
+    MatrixRM predictions;
+    network_->forward(X, predictions);
+
+    double loss_val = loss_fn_->calculate(predictions, y);
+
+    MatrixRM loss_gradient = loss_fn_->backward(predictions, y);
+    network_->backward(loss_gradient);
+
+    network_->update_weights(learning_rate);
+
+    if (verbose &&
+        (epoch % std::max(1, epochs / 10) == 0 || epoch == epochs - 1)) {
+      std::cout << "Epoch " << epoch << " | Loss: " << loss_val << std::endl;
+    }
+  }
+}
+
+MatrixRM Model::predict(const MatrixRM& X) {
+  MatrixRM predictions;
+  network_->forward(X, predictions);
+  return predictions;
+}
+
+}

nn_engine_core-0.1.0/src/parametric/DenseLayer.cpp

@@ -0,0 +1,30 @@
+#include "parametric/DenseLayer.hpp"
+
+#include <cmath>
+
+namespace mlengine::parametric {
+
+DenseLayer::DenseLayer(int input_dim, int output_dim) {
+  double limit = std::sqrt(6.0 / (input_dim + output_dim));
+  weights_ = core::MatrixRM::Random(input_dim, output_dim) * limit;
+  bias_ = core::MatrixRM::Zero(1, output_dim);
+}
+
+void DenseLayer::forward(const core::MatrixRM& input, core::MatrixRM& output) {
+  last_input_ = input;
+  output.noalias() = (input * weights_).rowwise() + bias_.row(0);
+}
+
+core::MatrixRM DenseLayer::backward(const core::MatrixRM& output_gradient) {
+  dW_.noalias() = last_input_.transpose() * output_gradient;
+  db_ = output_gradient.colwise().sum();
+
+  return output_gradient * weights_.transpose();
+}
+
+void DenseLayer::update_weights(double learning_rate) {
+  weights_ -= learning_rate * dW_;
+  bias_ -= learning_rate * db_;
+}
+
+}  // namespace mlengine::parametric

nn_engine_core-0.1.0/src/parametric/LogisticNeuron.cpp

@@ -0,0 +1,41 @@
+#include "parametric/LogisticNeuron.hpp"
+
+#include <cmath>
+
+namespace mlengine::parametric {
+
+void LogisticNeuron::fit(const MatrixRM& X, const VectorRM& y, int epochs,
+                         double learning_rate) {
+  int m = X.rows();
+  int n = X.cols();
+
+  weights_ = VectorRM::Zero(n);
+  bias_ = 0.0;
+
+  for (int epoch = 0; epoch < epochs; ++epoch) {
+    VectorRM Z = (X * weights_).array() + bias_;
+
+    VectorRM A =
+        Z.unaryExpr([](double z) { return 1.0 / (1.0 + std::exp(-z)); });
+
+    VectorRM error = A - y;
+
+    // dW = (X^T * error) / m
+    VectorRM dW = (X.transpose() * error) / m;
+    double db = error.sum() / m;
+    weights_ -= learning_rate * dW;
+    bias_ -= learning_rate * db;
+  }
+}
+
+VectorRM LogisticNeuron::predict_proba(const MatrixRM& X) const {
+  VectorRM Z = (X * weights_).array() + bias_;
+  return Z.unaryExpr([](double z) { return 1.0 / (1.0 + std::exp(-z)); });
+}
+
+VectorRM LogisticNeuron::predict(const MatrixRM& X) const {
+  VectorRM proba = predict_proba(X);
+  return proba.unaryExpr([](double p) { return p >= 0.5 ? 1.0 : 0.0; });
+}
+
+}  // namespace mlengine::parametric

nn_engine_core-0.1.0/src/parametric/ReLULayer.cpp

@@ -0,0 +1,16 @@
+#include "parametric/ReLULayer.hpp"
+
+namespace mlengine::parametric {
+
+void ReLULayer::forward(const core::MatrixRM& input, core::MatrixRM& output) {
+  last_input_ = input;
+  output = input.cwiseMax(0.0);
+}
+
+core::MatrixRM ReLULayer::backward(const core::MatrixRM& output_gradient) {
+  core::MatrixRM dX = output_gradient;
+  dX = (last_input_.array() > 0.0).select(dX, 0.0);
+  return dX;
+}
+
+}