newton-vision 1.0.0__tar.gz

newton_vision-1.0.0/.gitignore

@@ -0,0 +1,27 @@
+# Build & Compiled artifacts
+build/
+dist/
+*.egg-info/
+.wheel_tag/
+_core*.pyd
+_core*.so
+
+# Python bytecode & cache
+__pycache__/
+*.py[cod]
+*$py.class
+.pytest_cache/
+
+# Dataset & Temporary Model Checkpoints
+tutorials/data/
+*.nv
+*.onnx
+*.png
+*.log
+
+# IDE & OS
+.vs/
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db

newton_vision-1.0.0/CMakeLists.txt

@@ -0,0 +1,37 @@
+cmake_minimum_required(VERSION 3.17)
+project(newton_vision LANGUAGES CXX)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(pybind11 CONFIG REQUIRED)
+find_package(OpenMP REQUIRED)
+
+include(CheckLanguage)
+check_language(CUDA)
+
+if(CMAKE_CUDA_COMPILER)
+    enable_language(CUDA)
+    set(CMAKE_CUDA_STANDARD 17)
+    add_definitions(-DHAS_CUDA)
+    pybind11_add_module(_core
+        cpp/binding.cpp
+        cpp/layers.cpp
+        cpp/cuda_layers.cu
+    )
+    set_property(TARGET _core PROPERTY CUDA_SEPARABLE_COMPILATION ON)
+else()
+    pybind11_add_module(_core
+        cpp/binding.cpp
+        cpp/layers.cpp
+    )
+endif()
+
+target_include_directories(_core PRIVATE cpp)
+target_link_libraries(_core PRIVATE OpenMP::OpenMP_CXX)
+
+if(WIN32 AND MINGW)
+    target_link_options(_core PRIVATE -static-libgcc -static-libstdc++)
+endif()
+
+install(TARGETS _core DESTINATION newton_vision)

newton_vision-1.0.0/MANIFEST.in

@@ -0,0 +1,21 @@
+include README.md
+include PROGRESS.md
+include CMakeLists.txt
+include pyproject.toml
+recursive-include cpp *.h *.cpp *.cu
+recursive-include src/newton_vision *.py
+recursive-include docs *.md
+recursive-include benchmarks *.py
+recursive-include examples *.py
+recursive-include tests *.py
+recursive-include tutorials *.py
+
+global-exclude __pycache__
+global-exclude *.py[cod]
+global-exclude *.nv
+global-exclude *.onnx
+global-exclude *.png
+global-exclude *.log
+prune tutorials/data
+prune build
+prune dist

newton_vision-1.0.0/PKG-INFO

@@ -0,0 +1,74 @@
+Metadata-Version: 2.2
+Name: newton-vision
+Version: 1.0.0
+Summary: High-Performance Computer Vision & Deep Learning Framework in C++ & CUDA with PyTorch Parity
+Keywords: deep-learning,computer-vision,cuda,autograd,cnn,resnet,mobilenet,cpp
+Author-Email: newton-vision Core Team <info@newton-vision.org>
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Project-URL: Homepage, https://github.com/onur/newton-vision
+Project-URL: Documentation, https://github.com/onur/newton-vision/tree/master/docs
+Project-URL: Repository, https://github.com/onur/newton-vision.git
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.20.0
+Description-Content-Type: text/markdown
+
+# newton-vision — İlerleme & Devam Noktası
+
+> Bu dosya oturumlarda kaldığımız yerden devam edebilmek için **tek doğruluk kaynağıdır**. Her oturumda güncelle.
+> Özet: sıfırdan, sürdürülebilir, pybind11'li bir görüntü/CNN çekirdeği yazıyoruz.
+
+> **⭐ DEVAM NOKTASI:** **v1.0.0 RESMİ SÜRÜM & PYPI DAĞITIM PAKETLERİ TAMAMLANDI!**
+> 1. Gerçek MNIST verisi üzerinde LeNet evrişimsel sinir ağı eğitildi (%91.6 Eğitim, %86.6 Test Doğruluğu) ve model `tutorials/lenet_mnist_v1.nv` checkpoint dosyası olarak kaydedildi.
+> 2. PyPI ikili tekerlek (`dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl`) ve kaynak dağıtım paketi (`dist/newton_vision-1.0.0.tar.gz`) derlendi.
+
+Yol: `C:\Users\onur_\Desktop\newton-vision` (Windows 11, git repo, branch `master`)
+
+---
+
+## 🎯 Proje Dizin Yapısı (Open Source Production Release)
+
+```
+newton-vision/
+├── dist/                    # PyPI Dağıtım Paketleri (.whl & .tar.gz)
+├── cpp/                     # C++ & CUDA Katman Çekirdeği (im2col, GEMM, OpenMP, NVCC)
+├── docs/                    # Mimari ve Akademik Matematik Dokümantasyonu (docs/autograd_math.md)
+├── benchmarks/              # PyTorch vs newton-vision Yan Yana Karşılaştırma Testleri
+├── examples/                # Canlı Görsel, Sobel Filtreleme ve Master Showcase Demosu
+├── tests/                   # Otomatik Birim ve Parite Testleri (100% PASS)
+├── tutorials/               # Uçtan Uca Model Eğitimi & Checkpoint (train_and_eval_lenet.py, lenet_mnist_v1.nv)
+└── src/newton_vision/       # Ana Python Paketi (v1.0.0 - optics, fluxion, gravity, principia, models, weights, jit)
+```
+
+---
+
+## 📦 1. PyPI Dağıtım Paketleri (`dist/`)
+
+- `dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl` (Binary Wheel Package)
+- `dist/newton_vision-1.0.0.tar.gz` (Source Package)
+
+Paketi yüklemek için:
+```bash
+pip install dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl
+```
+
+---
+
+## 🧪 2. Model Eğitimi & Değerlendirme Sonuçları (`tutorials/train_and_eval_lenet.py`)
+
+- **Eğitim Verisi:** 60,000 Örnek | **Test Verisi:** 10,000 Örnek
+- **Model:** LeNet Classifier (`Conv2d` ➜ `ReLU` ➜ `MaxPool2d` ➜ `Conv2d` ➜ `Linear` 120 ➜ `Linear` 84 ➜ `Linear` 10)
+- **Loss:** `CrossEntropyLoss` | **Optimizer:** `Adam`
+- **Eğitim Başarımı:** %91.6 Accuracy (Loss: 0.2590)
+- **🏆 TEST KÜMESİ DOĞRULUĞU:** **%86.6 Accuracy**
+- **Kaydedilen Model Checkpoint:** `tutorials/lenet_mnist_v1.nv`

newton_vision-1.0.0/PROGRESS.md

@@ -0,0 +1,49 @@
+# newton-vision — İlerleme & Devam Noktası
+
+> Bu dosya oturumlarda kaldığımız yerden devam edebilmek için **tek doğruluk kaynağıdır**. Her oturumda güncelle.
+> Özet: sıfırdan, sürdürülebilir, pybind11'li bir görüntü/CNN çekirdeği yazıyoruz.
+
+> **⭐ DEVAM NOKTASI:** **v1.0.0 RESMİ SÜRÜM & PYPI DAĞITIM PAKETLERİ TAMAMLANDI!**
+> 1. Gerçek MNIST verisi üzerinde LeNet evrişimsel sinir ağı eğitildi (%91.6 Eğitim, %86.6 Test Doğruluğu) ve model `tutorials/lenet_mnist_v1.nv` checkpoint dosyası olarak kaydedildi.
+> 2. PyPI ikili tekerlek (`dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl`) ve kaynak dağıtım paketi (`dist/newton_vision-1.0.0.tar.gz`) derlendi.
+
+Yol: `C:\Users\onur_\Desktop\newton-vision` (Windows 11, git repo, branch `master`)
+
+---
+
+## 🎯 Proje Dizin Yapısı (Open Source Production Release)
+
+```
+newton-vision/
+├── dist/                    # PyPI Dağıtım Paketleri (.whl & .tar.gz)
+├── cpp/                     # C++ & CUDA Katman Çekirdeği (im2col, GEMM, OpenMP, NVCC)
+├── docs/                    # Mimari ve Akademik Matematik Dokümantasyonu (docs/autograd_math.md)
+├── benchmarks/              # PyTorch vs newton-vision Yan Yana Karşılaştırma Testleri
+├── examples/                # Canlı Görsel, Sobel Filtreleme ve Master Showcase Demosu
+├── tests/                   # Otomatik Birim ve Parite Testleri (100% PASS)
+├── tutorials/               # Uçtan Uca Model Eğitimi & Checkpoint (train_and_eval_lenet.py, lenet_mnist_v1.nv)
+└── src/newton_vision/       # Ana Python Paketi (v1.0.0 - optics, fluxion, gravity, principia, models, weights, jit)
+```
+
+---
+
+## 📦 1. PyPI Dağıtım Paketleri (`dist/`)
+
+- `dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl` (Binary Wheel Package)
+- `dist/newton_vision-1.0.0.tar.gz` (Source Package)
+
+Paketi yüklemek için:
+```bash
+pip install dist/newton_vision-1.0.0-cp313-cp313-win_amd64.whl
+```
+
+---
+
+## 🧪 2. Model Eğitimi & Değerlendirme Sonuçları (`tutorials/train_and_eval_lenet.py`)
+
+- **Eğitim Verisi:** 60,000 Örnek | **Test Verisi:** 10,000 Örnek
+- **Model:** LeNet Classifier (`Conv2d` ➜ `ReLU` ➜ `MaxPool2d` ➜ `Conv2d` ➜ `Linear` 120 ➜ `Linear` 84 ➜ `Linear` 10)
+- **Loss:** `CrossEntropyLoss` | **Optimizer:** `Adam`
+- **Eğitim Başarımı:** %91.6 Accuracy (Loss: 0.2590)
+- **🏆 TEST KÜMESİ DOĞRULUĞU:** **%86.6 Accuracy**
+- **Kaydedilen Model Checkpoint:** `tutorials/lenet_mnist_v1.nv`

newton_vision-1.0.0/README.md

@@ -0,0 +1,26 @@
+# newton-vision
+
+Sıfırdan, sürdürülebilir bir görüntü/CNN işleme çekirdeği. Saf Python → C++:
+
+- **C++ çekirdek** (`cpp/`): conv2d, ReLU, maxpool2d — GCC 15 ile derlenir.
+- **pybind11 binding**: `import newton_vision` diye çağrılır.
+- **Saf Python referans** (`python_ref/`): doğruluk için altın standart.
+- **Test + benchmark**: C++ çıktısı saf Python ile eşit mi? Hız kazancı ne kadar?
+
+## Hedef Yol Haritası
+- `v0.1` — C++ conv2d + relu + maxpool, pybind11, standart build & doğruluk testi (✅ Tamamlandı)
+- `v0.2` — `im2col + GEMM` C++ hız katmanı & ek katmanlar (AvgPool2d, BatchNorm2d vb.)
+- `v0.3` — autograd / backward pass (`fluxion` türev motoru)
+
+## Kurulum ve Kullanım
+
+```bash
+# Standart paket kurulumu (scikit-build-core + pybind11)
+pip install .
+
+# Test
+python -c "from newton_vision import Conv2d, ReLU, MaxPool2d; print('newton-vision hazir!')"
+```
+
+---
+Birlikte yazılmıştır. 🤝

newton_vision-1.0.0/benchmarks/bench_layers.py

@@ -0,0 +1,119 @@
+"""Benchmark: C++ pybind11 Çekirdeği vs Saf Python Referansı.
+
+Performans ve hız karşılaştırmasını (Speedup factor) ölçer.
+"""
+
+from __future__ import annotations
+import sys
+import os
+import time
+import numpy as np
+
+PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.join(PROJECT_ROOT, "python_ref"))
+
+import layers as ref
+import newton_vision._core as _core
+
+
+def benchmark_conv2d():
+    print("\n[BENCHMARK] Conv2D (N=4, C_in=16, H=64, W=64 -> C_out=32, 3x3)")
+    np.random.seed(42)
+
+    x = np.random.randn(4, 16, 64, 64).astype(np.float32)
+    w = np.random.randn(32, 16, 3, 3).astype(np.float32)
+    bias = np.random.randn(32).astype(np.float32)
+
+    warmup = 3
+    iters = 15
+
+    # Warmup
+    for _ in range(warmup):
+        _ = ref.conv2d(x, w, bias=bias, stride=1, padding=1)
+        _ = _core.conv2d(x, w, bias=bias, stride=1, padding=1)
+
+    # Benchmark Ref
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = ref.conv2d(x, w, bias=bias, stride=1, padding=1)
+    t_ref = (time.perf_counter() - t0) / iters
+
+    # Benchmark C++
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = _core.conv2d(x, w, bias=bias, stride=1, padding=1)
+    t_cpp = (time.perf_counter() - t0) / iters
+
+    speedup = t_ref / t_cpp if t_cpp > 0 else 0
+    print(f"  Python Ref : {t_ref * 1000:.2f} ms / iter")
+    print(f"  C++ Naive  : {t_cpp * 1000:.2f} ms / iter")
+    print(f"  🚀 Speedup : {speedup:.2f}x daha hızlı!")
+
+
+def benchmark_relu():
+    print("\n[BENCHMARK] ReLU (16 x 64 x 128 x 128)")
+    np.random.seed(42)
+
+    x = np.random.randn(16, 64, 128, 128).astype(np.float32)
+    warmup = 5
+    iters = 30
+
+    for _ in range(warmup):
+        _ = ref.relu(x)
+        _ = _core.relu(x)
+
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = ref.relu(x)
+    t_ref = (time.perf_counter() - t0) / iters
+
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = _core.relu(x)
+    t_cpp = (time.perf_counter() - t0) / iters
+
+    speedup = t_ref / t_cpp if t_cpp > 0 else 0
+    print(f"  Python Ref : {t_ref * 1000:.2f} ms / iter")
+    print(f"  C++ Core   : {t_cpp * 1000:.2f} ms / iter")
+    print(f"  🚀 Speedup : {speedup:.2f}x daha hızlı!")
+
+
+def benchmark_maxpool2d():
+    print("\n[BENCHMARK] MaxPool2D (N=8, C=32, H=64, W=64, k=2, s=2)")
+    np.random.seed(42)
+
+    x = np.random.randn(8, 32, 64, 64).astype(np.float32)
+    warmup = 3
+    iters = 20
+
+    for _ in range(warmup):
+        _ = ref.maxpool2d(x, kernel_size=2, stride=2)
+        _ = _core.maxpool2d(x, kernel_size=2, stride=2)
+
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = ref.maxpool2d(x, kernel_size=2, stride=2)
+    t_ref = (time.perf_counter() - t0) / iters
+
+    t0 = time.perf_counter()
+    for _ in range(iters):
+        _ = _core.maxpool2d(x, kernel_size=2, stride=2)
+    t_cpp = (time.perf_counter() - t0) / iters
+
+    speedup = t_ref / t_cpp if t_cpp > 0 else 0
+    print(f"  Python Ref : {t_ref * 1000:.2f} ms / iter")
+    print(f"  C++ Naive  : {t_cpp * 1000:.2f} ms / iter")
+    print(f"  🚀 Speedup : {speedup:.2f}x daha hızlı!")
+
+
+def main():
+    print("==========================================")
+    print("newton-vision: Performans Benchmark")
+    print("==========================================")
+    benchmark_conv2d()
+    benchmark_relu()
+    benchmark_maxpool2d()
+
+
+if __name__ == "__main__":
+    main()

newton_vision-1.0.0/benchmarks/bench_vs_pytorch.py

@@ -0,0 +1,90 @@
+"""newton-vision vs PyTorch 2.6.0 Yan Yana Performans Benchmark Testi (benchmarks/bench_vs_pytorch.py).
+
+newton-vision C++ OpenMP çekirdeği ile PyTorch CPU motorunun evrişim (Conv2d)
+gecikmesini (latency ms) ve saniye başı kare işleme hızını (FPS) doğrudan karşılaştırır.
+"""
+
+from __future__ import annotations
+import time
+import numpy as np
+import torch
+import torch.nn as nn
+import newton_vision as nv
+
+
+def benchmark_conv2d(batch_size=4, in_channels=16, out_channels=32, H=64, W=64, kernel_size=3, padding=1, num_runs=50):
+    print(f"\n--- Conv2D Benchmark: input=({batch_size}, {in_channels}, {H}, {W}), kernel={kernel_size}x{kernel_size}, runs={num_runs} ---")
+
+    # Input & Weight data
+    x_np = np.random.randn(batch_size, in_channels, H, W).astype(np.float32)
+
+    # 1. newton-vision C++ OpenMP Engine
+    nv_conv = nv.Conv2d(in_channels, out_channels, kernel_size, padding=padding)
+
+    # Warmup
+    _ = nv_conv(x_np)
+
+    start = time.perf_counter()
+    for _ in range(num_runs):
+        _ = nv_conv(x_np)
+    end = time.perf_counter()
+    nv_total_time = end - start
+    nv_avg_ms = (nv_total_time / num_runs) * 1000.0
+    nv_fps = (batch_size * num_runs) / nv_total_time
+
+    # 2. PyTorch 2.6 CPU Engine
+    torch_x = torch.from_numpy(x_np)
+    torch_conv = nn.Conv2d(in_channels, out_channels, kernel_size, padding=padding)
+    torch_conv.weight.data = torch.from_numpy(nv_conv.w.data)
+    if nv_conv.bias is not None:
+        torch_conv.bias.data = torch.from_numpy(nv_conv.bias.data)
+
+    # Warmup
+    with torch.no_grad():
+        _ = torch_conv(torch_x)
+
+    start = time.perf_counter()
+    with torch.no_grad():
+        for _ in range(num_runs):
+            _ = torch_conv(torch_x)
+    end = time.perf_counter()
+    torch_total_time = end - start
+    torch_avg_ms = (torch_total_time / num_runs) * 1000.0
+    torch_fps = (batch_size * num_runs) / torch_total_time
+
+    print(f"  • newton-vision C++ Engine : {nv_avg_ms:6.2f} ms / batch | Hız: {nv_fps:7.1f} FPS")
+    print(f"  • PyTorch 2.6 CPU Engine   : {torch_avg_ms:6.2f} ms / batch | Hız: {torch_fps:7.1f} FPS")
+
+    speedup = torch_avg_ms / nv_avg_ms
+    if speedup >= 1.0:
+        print(f"  🚀 newton-vision PyTorch'a kıyasla {speedup:.2f}x daha hızlı!")
+    else:
+        print(f"  📊 PyTorch newton-vision'a kıyasla {1.0/speedup:.2f}x daha hızlı.")
+
+    return nv_avg_ms, torch_avg_ms
+
+
+def main():
+    print("===============================================================")
+    print("      newton-vision vs PyTorch 2.6.0 BENCHMARK RAPORU          ")
+    print("===============================================================")
+    print(f"PyTorch Sürümü : {torch.__version__}")
+    print(f"newton-vision   : v0.6.0 (C++ im2col + GEMM + OpenMP)")
+
+    b1_nv, b1_torch = benchmark_conv2d(batch_size=1, in_channels=3, out_channels=16, H=128, W=128)
+    b2_nv, b2_torch = benchmark_conv2d(batch_size=8, in_channels=16, out_channels=32, H=64, W=64)
+    b3_nv, b3_torch = benchmark_conv2d(batch_size=16, in_channels=32, out_channels=64, H=32, W=32)
+
+    print("\n===============================================================")
+    print("                      ÖZET TABLO                                ")
+    print("===============================================================")
+    print("| Test Senaryosu              | newton-vision | PyTorch 2.6 CPU |")
+    print("|-----------------------------|---------------|-----------------|")
+    print(f"| Batch=1 (128x128 3->16 ch)  | {b1_nv:6.2f} ms   | {b1_torch:6.2f} ms     |")
+    print(f"| Batch=8 (64x64 16->32 ch)   | {b2_nv:6.2f} ms   | {b2_torch:6.2f} ms     |")
+    print(f"| Batch=16 (32x32 32->64 ch)  | {b3_nv:6.2f} ms   | {b3_torch:6.2f} ms     |")
+    print("===============================================================")
+
+
+if __name__ == "__main__":
+    main()