gpuarray 0.1.0__tar.gz

gpuarray-0.1.0/PKG-INFO

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: gpuarray
+Version: 0.1.0
+Summary: NumPy-like GPU array library that works on every GPU — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required.
+Author: Arnav Kewalram
+License: MIT
+Project-URL: Homepage, https://github.com/arnavkewalram/gpuarray
+Project-URL: Repository, https://github.com/arnavkewalram/gpuarray
+Keywords: gpu,numpy,webgpu,array,compute,cuda-alternative
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: <3.14,>=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: wgpu>=0.19
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# gpuarray
+
+NumPy-like GPU array library that works on **every GPU** — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required.
+
+Powered by [WebGPU](https://www.w3.org/TR/webgpu/) via [wgpu-py](https://github.com/pygfx/wgpu-py). Uses Metal on macOS, Vulkan on Windows/Linux, and DirectX 12 on Windows.
+
+## Install
+
+```bash
+pip install gpuarray
+```
+
+## Usage
+
+```python
+import gpuarray as gp
+
+# Create arrays on GPU
+a = gp.array([1, 2, 3, 4, 5])
+b = gp.ones(5) * 3
+
+# Operations run on GPU
+c = a + b
+d = a * b
+e = gp.dot(a, b)
+
+# Read back to CPU
+print(c.to_numpy())  # [4. 5. 6. 7. 8.]
+
+# Matrix multiply
+A = gp.ones((512, 512))
+B = gp.ones((512, 512))
+C = gp.matmul(A, B)  # runs on GPU
+
+# Reductions
+total = gp.sum(a)
+avg = gp.mean(a)
+
+# Math functions
+x = gp.exp(a)
+y = gp.log(a)
+z = gp.sqrt(a)
+```
+
+## Why?
+
+**CuPy** only works on NVIDIA GPUs with CUDA. **gpuarray** works on every GPU:
+
+| GPU | CuPy | gpuarray |
+|-----|------|----------|
+| NVIDIA (CUDA) | ✓ | ✓ |
+| AMD (Vulkan) | ✗ | ✓ |
+| Intel (Vulkan) | ✗ | ✓ |
+| Apple Silicon (Metal) | ✗ | ✓ |
+
+## Supported Operations
+
+### Array Creation
+`array`, `zeros`, `ones`, `arange`, `linspace`
+
+### Elementwise Binary
+`+`, `-`, `*`, `/`, `**` (with arrays or scalars)
+
+### Elementwise Unary
+`exp`, `log`, `sqrt`, `abs`, `neg`, `relu`, `sigmoid`, `tanh`
+
+### Reductions
+`sum`, `mean`, `max`, `min`
+
+### Linear Algebra
+`dot`, `matmul`
+
+## Performance
+
+Benchmarks on Intel UHD 630 (integrated GPU) vs NumPy (CPU with SIMD):
+
+| Operation | NumPy | gpuarray | Speedup |
+|-----------|-------|----------|---------|
+| add 10M elements | 11.6ms | 19.9ms | 0.59x |
+| matmul 512x512 | 1.3ms | 1.0ms | **1.22x** |
+| sum 10M | 4.3ms | 12.5ms | 0.34x |
+
+The integrated GPU shows speedup on compute-heavy operations (matmul). Discrete GPUs (RTX 3080, RX 7900, etc.) will show much larger speedups across all operations.
+
+## Requirements
+
+- Python 3.10-3.13
+- Any GPU supported by WebGPU (most GPUs from 2015+)
+- No CUDA, no special drivers — just your system GPU
+
+## How It Works
+
+1. Arrays are stored as WebGPU GPU buffers
+2. Operations dispatch WGSL compute shaders to the GPU
+3. Pipelines are cached — repeated operations don't recompile
+4. Results stay on GPU until you call `.to_numpy()`
+
+## License
+
+MIT

gpuarray-0.1.0/README.md

@@ -0,0 +1,100 @@
+# gpuarray
+
+NumPy-like GPU array library that works on **every GPU** — NVIDIA, AMD, Intel, Apple Silicon. No CUDA required.
+
+Powered by [WebGPU](https://www.w3.org/TR/webgpu/) via [wgpu-py](https://github.com/pygfx/wgpu-py). Uses Metal on macOS, Vulkan on Windows/Linux, and DirectX 12 on Windows.
+
+## Install
+
+```bash
+pip install gpuarray
+```
+
+## Usage
+
+```python
+import gpuarray as gp
+
+# Create arrays on GPU
+a = gp.array([1, 2, 3, 4, 5])
+b = gp.ones(5) * 3
+
+# Operations run on GPU
+c = a + b
+d = a * b
+e = gp.dot(a, b)
+
+# Read back to CPU
+print(c.to_numpy())  # [4. 5. 6. 7. 8.]
+
+# Matrix multiply
+A = gp.ones((512, 512))
+B = gp.ones((512, 512))
+C = gp.matmul(A, B)  # runs on GPU
+
+# Reductions
+total = gp.sum(a)
+avg = gp.mean(a)
+
+# Math functions
+x = gp.exp(a)
+y = gp.log(a)
+z = gp.sqrt(a)
+```
+
+## Why?
+
+**CuPy** only works on NVIDIA GPUs with CUDA. **gpuarray** works on every GPU:
+
+| GPU | CuPy | gpuarray |
+|-----|------|----------|
+| NVIDIA (CUDA) | ✓ | ✓ |
+| AMD (Vulkan) | ✗ | ✓ |
+| Intel (Vulkan) | ✗ | ✓ |
+| Apple Silicon (Metal) | ✗ | ✓ |
+
+## Supported Operations
+
+### Array Creation
+`array`, `zeros`, `ones`, `arange`, `linspace`
+
+### Elementwise Binary
+`+`, `-`, `*`, `/`, `**` (with arrays or scalars)
+
+### Elementwise Unary
+`exp`, `log`, `sqrt`, `abs`, `neg`, `relu`, `sigmoid`, `tanh`
+
+### Reductions
+`sum`, `mean`, `max`, `min`
+
+### Linear Algebra
+`dot`, `matmul`
+
+## Performance
+
+Benchmarks on Intel UHD 630 (integrated GPU) vs NumPy (CPU with SIMD):
+
+| Operation | NumPy | gpuarray | Speedup |
+|-----------|-------|----------|---------|
+| add 10M elements | 11.6ms | 19.9ms | 0.59x |
+| matmul 512x512 | 1.3ms | 1.0ms | **1.22x** |
+| sum 10M | 4.3ms | 12.5ms | 0.34x |
+
+The integrated GPU shows speedup on compute-heavy operations (matmul). Discrete GPUs (RTX 3080, RX 7900, etc.) will show much larger speedups across all operations.
+
+## Requirements
+
+- Python 3.10-3.13
+- Any GPU supported by WebGPU (most GPUs from 2015+)
+- No CUDA, no special drivers — just your system GPU
+
+## How It Works
+
+1. Arrays are stored as WebGPU GPU buffers
+2. Operations dispatch WGSL compute shaders to the GPU
+3. Pipelines are cached — repeated operations don't recompile
+4. Results stay on GPU until you call `.to_numpy()`
+
+## License
+
+MIT

gpuarray-0.1.0/gpuarray/__init__.py

@@ -0,0 +1,47 @@
+"""gpuarray — WebGPU-accelerated NumPy replacement."""
+
+from .core import GPUArray
+from .api import (
+    array,
+    zeros,
+    ones,
+    arange,
+    linspace,
+    dot,
+    matmul,
+    sum,
+    mean,
+    exp,
+    log,
+    sqrt,
+    abs,
+    max,
+    min,
+    relu,
+    sigmoid,
+    tanh,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "GPUArray",
+    "array",
+    "zeros",
+    "ones",
+    "arange",
+    "linspace",
+    "dot",
+    "matmul",
+    "sum",
+    "mean",
+    "exp",
+    "log",
+    "sqrt",
+    "abs",
+    "max",
+    "min",
+    "relu",
+    "sigmoid",
+    "tanh",
+]

gpuarray-0.1.0/gpuarray/api.py

@@ -0,0 +1,99 @@
+"""NumPy-compatible module-level functions."""
+
+from __future__ import annotations
+
+from typing import Sequence
+
+import numpy as np
+
+from .core import GPUArray, _from_numpy, matmul as _matmul
+from . import shaders
+
+
+# ----- creation functions -----
+
+def array(data) -> GPUArray:
+    """Create a GPUArray from a list, nested list, or numpy array."""
+    if isinstance(data, GPUArray):
+        return data
+    arr = np.asarray(data, dtype=np.float32)
+    if arr.ndim == 0:
+        arr = arr.reshape((1,))
+    return _from_numpy(arr)
+
+
+def zeros(shape) -> GPUArray:
+    if isinstance(shape, int):
+        shape = (shape,)
+    return _from_numpy(np.zeros(shape, dtype=np.float32))
+
+
+def ones(shape) -> GPUArray:
+    if isinstance(shape, int):
+        shape = (shape,)
+    return _from_numpy(np.ones(shape, dtype=np.float32))
+
+
+def arange(start, stop=None, step=1) -> GPUArray:
+    if stop is None:
+        stop = start
+        start = 0
+    return _from_numpy(np.arange(start, stop, step, dtype=np.float32))
+
+
+def linspace(start, stop, num=50) -> GPUArray:
+    return _from_numpy(np.linspace(start, stop, num, dtype=np.float32))
+
+
+# ----- operations -----
+
+def dot(a: GPUArray, b: GPUArray):
+    return a.dot(b)
+
+
+def matmul(a: GPUArray, b: GPUArray) -> GPUArray:
+    return _matmul(a, b)
+
+
+def sum(a: GPUArray) -> float:
+    return a.sum()
+
+
+def mean(a: GPUArray) -> float:
+    return a.mean()
+
+
+def exp(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.EXP_SHADER)
+
+
+def log(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.LOG_SHADER)
+
+
+def sqrt(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.SQRT_SHADER)
+
+
+def abs(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.ABS_SHADER)
+
+
+def max(a: GPUArray) -> float:
+    return a.max()
+
+
+def min(a: GPUArray) -> float:
+    return a.min()
+
+
+def relu(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.RELU_SHADER)
+
+
+def sigmoid(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.SIGMOID_SHADER)
+
+
+def tanh(a: GPUArray) -> GPUArray:
+    return a._run_unary_op(shaders.TANH_SHADER)