kernel-craft 0.1.0__tar.gz

kernel_craft-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: kernel-craft
+Version: 0.1.0
+Summary: CUDA kernels for machine learning systems optimization
+Author-email: kernel-craft contributors <contact@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/anomalyco/kernel-craft
+Keywords: cuda,gpu,convolution,machine-learning,deep-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+
+# kernel-craft Python API
+
+CUDA convolution kernels exposed to Python with numpy and PyTorch support.
+
+## Installation
+
+Build from source with CMake:
+
+```bash
+cd /path/to/kernel-craft
+mkdir build && cd build
+cmake ..
+make kernel_craft_python
+```
+
+The module will be at `src/python/build/kernel_craft_python.cpython-*.so`.
+
+## Usage
+
+```python
+import sys
+sys.path.insert(0, 'src/python/build')
+
+import kernel_craft_python as kc
+import numpy as np
+
+# Input: 2D float32 numpy array
+input = np.random.randn(256, 256).astype(np.float32)
+kernel = np.random.randn(3, 3).astype(np.float32)
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> np.ndarray
+
+# Tiled convolution with configurable tile size
+out = kc.conv_tiled(input, kernel, tile_w=8, tile_h=8)  # -> np.ndarray
+```
+
+## Version
+
+```python
+import kernel_craft_python as kc
+print(kc.__version__)  # "0.1.0"
+```
+
+## PyTorch Tensors
+
+```python
+import torch
+import kernel_craft_python as kc
+
+# Input: 2D float32 PyTorch tensor on CUDA
+input = torch.rand(256, 256, dtype=torch.float32, device='cuda')
+kernel = torch.rand(3, 3, dtype=torch.float32, device='cuda')
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> torch.Tensor on GPU
+
+# Tiled convolution
+out = kc.conv_tiled(input, kernel, tile_w=16, tile_h=16)  # -> torch.Tensor on GPU
+```
+
+## API Reference
+
+| Function | Input Type | Output Type |
+|----------|-----------|--------------|
+| `conv_naive(input, kernel)` | np.ndarray or Tensor | np.ndarray or Tensor |
+| `conv_tiled(input, kernel, tile_w, tile_h)` | np.ndarray or Tensor | np.ndarray or Tensor |
+
+### Parameters
+
+- `input`: Input image (2D, float32)
+- `kernel`: Convolution kernel (2D, float32, odd dimension)
+- `tile_w`: Tile width for tiled convolution (default: 8)
+- `tile_h`: Tile height for tiled convolution (default: 8)
+
+### Supported Tile Sizes
+
+- 8x8 (default, best overall performance)
+- 16x16
+- 32x32
+
+### Error Handling
+
+All functions raise `RuntimeError` with descriptive messages for:
+- Invalid input dimensions (must be 2D)
+- Invalid kernel dimensions (must be 2D, square, odd-sized)
+- Invalid dtype (must be float32)

kernel_craft-0.1.0/README.md

@@ -0,0 +1,87 @@
+# kernel-craft Python API
+
+CUDA convolution kernels exposed to Python with numpy and PyTorch support.
+
+## Installation
+
+Build from source with CMake:
+
+```bash
+cd /path/to/kernel-craft
+mkdir build && cd build
+cmake ..
+make kernel_craft_python
+```
+
+The module will be at `src/python/build/kernel_craft_python.cpython-*.so`.
+
+## Usage
+
+```python
+import sys
+sys.path.insert(0, 'src/python/build')
+
+import kernel_craft_python as kc
+import numpy as np
+
+# Input: 2D float32 numpy array
+input = np.random.randn(256, 256).astype(np.float32)
+kernel = np.random.randn(3, 3).astype(np.float32)
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> np.ndarray
+
+# Tiled convolution with configurable tile size
+out = kc.conv_tiled(input, kernel, tile_w=8, tile_h=8)  # -> np.ndarray
+```
+
+## Version
+
+```python
+import kernel_craft_python as kc
+print(kc.__version__)  # "0.1.0"
+```
+
+## PyTorch Tensors
+
+```python
+import torch
+import kernel_craft_python as kc
+
+# Input: 2D float32 PyTorch tensor on CUDA
+input = torch.rand(256, 256, dtype=torch.float32, device='cuda')
+kernel = torch.rand(3, 3, dtype=torch.float32, device='cuda')
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> torch.Tensor on GPU
+
+# Tiled convolution
+out = kc.conv_tiled(input, kernel, tile_w=16, tile_h=16)  # -> torch.Tensor on GPU
+```
+
+## API Reference
+
+| Function | Input Type | Output Type |
+|----------|-----------|--------------|
+| `conv_naive(input, kernel)` | np.ndarray or Tensor | np.ndarray or Tensor |
+| `conv_tiled(input, kernel, tile_w, tile_h)` | np.ndarray or Tensor | np.ndarray or Tensor |
+
+### Parameters
+
+- `input`: Input image (2D, float32)
+- `kernel`: Convolution kernel (2D, float32, odd dimension)
+- `tile_w`: Tile width for tiled convolution (default: 8)
+- `tile_h`: Tile height for tiled convolution (default: 8)
+
+### Supported Tile Sizes
+
+- 8x8 (default, best overall performance)
+- 16x16
+- 32x32
+
+### Error Handling
+
+All functions raise `RuntimeError` with descriptive messages for:
+- Invalid input dimensions (must be 2D)
+- Invalid kernel dimensions (must be 2D, square, odd-sized)
+- Invalid dtype (must be float32)

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

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: kernel-craft
+Version: 0.1.0
+Summary: CUDA kernels for machine learning systems optimization
+Author-email: kernel-craft contributors <contact@example.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/anomalyco/kernel-craft
+Keywords: cuda,gpu,convolution,machine-learning,deep-learning
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Environment :: GPU :: NVIDIA CUDA
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: <3.13,>=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+
+# kernel-craft Python API
+
+CUDA convolution kernels exposed to Python with numpy and PyTorch support.
+
+## Installation
+
+Build from source with CMake:
+
+```bash
+cd /path/to/kernel-craft
+mkdir build && cd build
+cmake ..
+make kernel_craft_python
+```
+
+The module will be at `src/python/build/kernel_craft_python.cpython-*.so`.
+
+## Usage
+
+```python
+import sys
+sys.path.insert(0, 'src/python/build')
+
+import kernel_craft_python as kc
+import numpy as np
+
+# Input: 2D float32 numpy array
+input = np.random.randn(256, 256).astype(np.float32)
+kernel = np.random.randn(3, 3).astype(np.float32)
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> np.ndarray
+
+# Tiled convolution with configurable tile size
+out = kc.conv_tiled(input, kernel, tile_w=8, tile_h=8)  # -> np.ndarray
+```
+
+## Version
+
+```python
+import kernel_craft_python as kc
+print(kc.__version__)  # "0.1.0"
+```
+
+## PyTorch Tensors
+
+```python
+import torch
+import kernel_craft_python as kc
+
+# Input: 2D float32 PyTorch tensor on CUDA
+input = torch.rand(256, 256, dtype=torch.float32, device='cuda')
+kernel = torch.rand(3, 3, dtype=torch.float32, device='cuda')
+
+# Naive convolution
+out = kc.conv_naive(input, kernel)  # -> torch.Tensor on GPU
+
+# Tiled convolution
+out = kc.conv_tiled(input, kernel, tile_w=16, tile_h=16)  # -> torch.Tensor on GPU
+```
+
+## API Reference
+
+| Function | Input Type | Output Type |
+|----------|-----------|--------------|
+| `conv_naive(input, kernel)` | np.ndarray or Tensor | np.ndarray or Tensor |
+| `conv_tiled(input, kernel, tile_w, tile_h)` | np.ndarray or Tensor | np.ndarray or Tensor |
+
+### Parameters
+
+- `input`: Input image (2D, float32)
+- `kernel`: Convolution kernel (2D, float32, odd dimension)
+- `tile_w`: Tile width for tiled convolution (default: 8)
+- `tile_h`: Tile height for tiled convolution (default: 8)
+
+### Supported Tile Sizes
+
+- 8x8 (default, best overall performance)
+- 16x16
+- 32x32
+
+### Error Handling
+
+All functions raise `RuntimeError` with descriptive messages for:
+- Invalid input dimensions (must be 2D)
+- Invalid kernel dimensions (must be 2D, square, odd-sized)
+- Invalid dtype (must be float32)

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

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+kernel_craft.egg-info/PKG-INFO
+kernel_craft.egg-info/SOURCES.txt
+kernel_craft.egg-info/dependency_links.txt
+kernel_craft.egg-info/requires.txt
+kernel_craft.egg-info/top_level.txt
+kernel_craft_python/kernel_craft_python.cpython-312-x86_64-linux-gnu.so
+tests/conftest.py
+tests/test_bindings.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,6 @@
+numpy>=1.20
+
+[dev]
+pytest>=7.0
+twine>=4.0.0
+build>=1.0.0

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

@@ -0,0 +1 @@
+kernel_craft_python

kernel_craft-0.1.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "kernel-craft"
+version = "0.1.0"
+description = "CUDA kernels for machine learning systems optimization"
+readme = "README.md"
+requires-python = ">=3.11, <3.13"
+license = "MIT"
+authors = [
+    {name = "kernel-craft contributors", email = "contact@example.com"}
+]
+keywords = ["cuda", "gpu", "convolution", "machine-learning", "deep-learning"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Environment :: GPU :: NVIDIA CUDA",
+    "Operating System :: POSIX :: Linux",
+]
+
+dependencies = [
+    "numpy>=1.20",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=7.0", "twine>=4.0.0", "build>=1.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/anomalyco/kernel-craft"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["kernel_craft_python*"]
+
+[tool.setuptools.package-data]
+kernel_craft_python = ["*.so"]

kernel_craft-0.1.0/setup.cfg

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

kernel_craft-0.1.0/tests/conftest.py

@@ -0,0 +1,9 @@
+"""pytest configuration for kernel_craft Python tests."""
+
+import sys
+from pathlib import Path
+
+# Add build directory to path for module import
+build_dir = Path(__file__).parent.parent / "build"
+if build_dir.exists():
+    sys.path.insert(0, str(build_dir))

kernel_craft-0.1.0/tests/test_bindings.py

@@ -0,0 +1,187 @@
+"""Python tests for kernel_craft Python bindings."""
+
+import numpy as np
+import pytest
+
+
+def conv_cpu(input_arr, kernel):
+    """CPU reference implementation for convolution."""
+    height, width = input_arr.shape
+    ksize = kernel.shape[0]
+    kHalf = ksize // 2
+    output = np.zeros_like(input_arr)
+    for oy in range(height):
+        for ox in range(width):
+            sum_val = 0.0
+            for ky in range(ksize):
+                iy = oy + ky - kHalf
+                if iy < 0 or iy >= height:
+                    continue
+                for kx in range(ksize):
+                    ix = ox + kx - kHalf
+                    if ix < 0 or ix >= width:
+                        continue
+                    sum_val += input_arr[iy, ix] * kernel[ky, kx]
+            output[oy, ox] = sum_val
+    return output
+
+
+class TestConvNaiveNumpy:
+    """Tests for conv_naive with numpy arrays."""
+
+    def test_basic(self):
+        """Test basic convolution produces correct shape."""
+        import kernel_craft_python as kc
+        input_arr = np.random.rand(8, 8).astype(np.float32)
+        kernel = np.array([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32)
+        result = kc.conv_naive(input_arr, kernel)
+        assert result.shape == (8, 8)
+
+    def test_correctness(self):
+        """Test output matches CPU reference."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(16, 16).astype(np.float32)
+        kernel = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float32)
+        result_gpu = kc.conv_naive(input_arr, kernel)
+        result_cpu = conv_cpu(input_arr, kernel)
+        np.testing.assert_allclose(result_gpu, result_cpu, rtol=1e-5)
+
+    def test_large_kernel(self):
+        """Test with larger 5x5 kernel."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(32, 32).astype(np.float32)
+        kernel = np.random.rand(5, 5).astype(np.float32)
+        result_gpu = kc.conv_naive(input_arr, kernel)
+        result_cpu = conv_cpu(input_arr, kernel)
+        np.testing.assert_allclose(result_gpu, result_cpu, rtol=1e-4)
+
+    def test_invalid_input_dim(self):
+        """Test that 1D input raises error."""
+        import kernel_craft_python as kc
+        input_arr = np.random.rand(16).astype(np.float32)
+        kernel = np.array([[1, 0], [0, 1]], dtype=np.float32)
+        with pytest.raises(RuntimeError):
+            kc.conv_naive(input_arr, kernel)
+
+    def test_invalid_kernel_dim(self):
+        """Test that non-2D kernel raises error."""
+        import kernel_craft_python as kc
+        input_arr = np.random.rand(16, 16).astype(np.float32)
+        kernel = np.random.rand(4).astype(np.float32)
+        with pytest.raises(RuntimeError):
+            kc.conv_naive(input_arr, kernel)
+
+    def test_even_kernel_raises(self):
+        """Test that even-sized kernel raises error."""
+        import kernel_craft_python as kc
+        input_arr = np.random.rand(16, 16).astype(np.float32)
+        kernel = np.ones((4, 4), dtype=np.float32)
+        with pytest.raises(RuntimeError):
+            kc.conv_naive(input_arr, kernel)
+
+
+class TestConvTiledNumpy:
+    """Tests for conv_tiled with numpy arrays."""
+
+    def test_tile_8x8(self):
+        """Test tiled convolution with 8x8 tiles."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(16, 16).astype(np.float32)
+        kernel = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float32)
+        result = kc.conv_tiled(input_arr, kernel, 8, 8)
+        result_ref = kc.conv_naive(input_arr, kernel)
+        np.testing.assert_allclose(result, result_ref, rtol=1e-5)
+
+    def test_tile_16x16(self):
+        """Test tiled convolution with 16x16 tiles."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(32, 32).astype(np.float32)
+        kernel = np.random.rand(3, 3).astype(np.float32)
+        result = kc.conv_tiled(input_arr, kernel, 16, 16)
+        result_ref = kc.conv_naive(input_arr, kernel)
+        np.testing.assert_allclose(result, result_ref, rtol=1e-5)
+
+    def test_tile_32x32(self):
+        """Test tiled convolution with 32x32 tiles on larger image."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(64, 64).astype(np.float32)
+        kernel = np.random.rand(5, 5).astype(np.float32)
+        result = kc.conv_tiled(input_arr, kernel, 32, 32)
+        result_ref = kc.conv_naive(input_arr, kernel)
+        np.testing.assert_allclose(result, result_ref, rtol=1e-5)
+
+    def test_different_tile_w_h(self):
+        """Test different tile width and height."""
+        import kernel_craft_python as kc
+        np.random.seed(42)
+        input_arr = np.random.rand(24, 24).astype(np.float32)
+        kernel = np.random.rand(3, 3).astype(np.float32)
+        result = kc.conv_tiled(input_arr, kernel, 8, 16)
+        result_ref = kc.conv_naive(input_arr, kernel)
+        np.testing.assert_allclose(result, result_ref, rtol=1e-5)
+
+
+class TestConvNaiveTorch:
+    """Tests for conv_naive with PyTorch tensors."""
+
+    def test_basic(self):
+        """Test basic convolution with PyTorch tensor."""
+        try:
+            import torch
+            import kernel_craft_python as kc
+        except ImportError:
+            pytest.skip("PyTorch not installed")
+
+        input_tensor = torch.rand(8, 8, dtype=torch.float32, device='cuda')
+        kernel = torch.tensor([[1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=torch.float32, device='cuda')
+        result = kc.conv_naive(input_tensor, kernel)
+        assert result.shape == (8, 8)
+        assert result.device.type == 'cuda'
+
+    def test_correctness(self):
+        """Test output matches numpy reference."""
+        try:
+            import torch
+            import kernel_craft_python as kc
+        except ImportError:
+            pytest.skip("PyTorch not installed")
+
+        np.random.seed(42)
+        input_np = np.random.rand(16, 16).astype(np.float32)
+        kernel_np = np.array([[0, 1, 0], [1, -4, 1], [0, 1, 0]], dtype=np.float32)
+
+        result_gpu = kc.conv_naive(
+            torch.from_numpy(input_np).cuda(),
+            torch.from_numpy(kernel_np).cuda()
+        )
+        result_cpu = conv_cpu(input_np, kernel_np)
+        np.testing.assert_allclose(result_gpu.cpu().numpy(), result_cpu, rtol=1e-4)
+
+
+class TestConvTiledTorch:
+    """Tests for conv_tiled with PyTorch tensors."""
+
+    def test_tile_sizes(self):
+        """Test different tile sizes with PyTorch."""
+        try:
+            import torch
+            import kernel_craft_python as kc
+        except ImportError:
+            pytest.skip("PyTorch not installed")
+
+        input_tensor = torch.rand(32, 32, dtype=torch.float32, device='cuda')
+        kernel = torch.rand(3, 3, dtype=torch.float32, device='cuda')
+
+        for tw, th in [(8, 8), (16, 16), (32, 32)]:
+            result = kc.conv_tiled(input_tensor, kernel, tw, th)
+            assert result.shape == (32, 32)
+            assert result.device.type == 'cuda'
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v"])