tensorstudio 1.0.1__tar.gz → 1.2.0__tar.gz

{tensorstudio-1.0.1 → tensorstudio-1.2.0}/.github/workflows/publish.yml

@@ -4,9 +4,6 @@ on:
   workflow_dispatch:
   release:
     types: [published]
-  push:
-    tags:
-      - "v*"
 
 permissions:
   contents: read
@@ -97,6 +94,8 @@ jobs:
     needs: [windows_wheels, linux_wheels, macos_wheels, build_sdist]
     runs-on: ubuntu-latest
     environment: pypi
+    env:
+      HAS_PYPI_TOKEN: ${{ secrets.PYPI_TOKEN != '' }}
     steps:
       - uses: actions/download-artifact@v4
         with:
@@ -107,7 +106,14 @@ jobs:
         run: |
           python -m pip install -U twine
           python -m twine check dist/*
-      - name: Publish to PyPI
+      - name: Publish to PyPI with configured API token
+        if: env.HAS_PYPI_TOKEN == 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          password: ${{ secrets.PYPI_TOKEN }}
+          skip-existing: true
+      - name: Publish to PyPI with Trusted Publishing
+        if: env.HAS_PYPI_TOKEN != 'true'
         uses: pypa/gh-action-pypi-publish@release/v1
         with:
           skip-existing: true

{tensorstudio-1.0.1 → tensorstudio-1.2.0}/CHANGELOG.md

@@ -1,5 +1,43 @@
 # Changelog
 
+## Unreleased
+
+## 1.2.0 - 2026-07-07
+
+- Added `save_npz` and `load_npz` for non-pickle tensor and flat
+  `state_dict` files using NumPy NPZ archives plus TensorStudio JSON metadata.
+- Added optional ONNX export through `tensorstudio.export_onnx` and
+  `tensorstudio.interchange.export_onnx` for supported Sequential module
+  stacks.
+- Added `tensorstudio.vision` with image-to-tensor conversion, normalization,
+  center crop, nearest-neighbor resize, and a small `TinyConvClassifier`.
+- Added tests for NPZ roundtrips, ONNX graph validation, and vision classifier
+  forward/backward behavior.
+- Updated README and MkDocs pages for file formats, ONNX limits, and vision
+  workflows.
+
+## 1.1.0 - 2026-07-07
+
+- Added native CPU NCHW `conv2d` with stride, padding, dilation, optional bias,
+  and reverse-mode gradients for input, weight, and bias.
+- Added `tensorstudio.conv2d`, `tensorstudio.ops.conv2d`,
+  `tensorstudio.nn.functional.conv2d`, and `tensorstudio.nn.Conv2d`.
+- Added convolution tests, finite-difference autograd coverage, and a
+  standalone convolution benchmark script.
+- Added convolution rows to the full benchmark report and updated docs to mark
+  convolution as partially implemented rather than missing.
+- Added native CPU NCHW `max_pool2d` and `avg_pool2d` operations with autograd,
+  Python top-level and functional APIs, `nn.MaxPool2d`, `nn.AvgPool2d`, tests,
+  docs, and benchmark coverage.
+- Added native single-axis `sum`, `mean`, `max`, and `min` reductions with
+  `keepdims` and reverse-mode gradients.
+- Added a typed contiguous 2D fast path for common axis `sum`/`mean`
+  reductions.
+- Added `nn.softmax`, `nn.log_softmax`, `nn.cross_entropy`, and
+  `nn.CrossEntropyLoss` for small multiclass classification workloads.
+- Added native `astype`, `concat`, and `stack` operations with Python wrappers,
+  Tensor methods for casting, and autograd support for floating tensors.
+
 ## 1.0.1
 
 - Added `test_all.py` for one-command local release checks covering lint,

{tensorstudio-1.0.1 → tensorstudio-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: tensorstudio
-Version: 1.0.1
+Version: 1.2.0
 Summary: TensorStudio is a compact C++ tensor and autograd engine with a Python API for learning, experimentation, and lightweight ML workloads.
 Keywords: tensor,autograd,machine-learning,cpp,pybind11
 Author: TensorStudio contributors
@@ -51,9 +51,15 @@ Requires-Dist: ruff>=0.6; extra == "dev"
 Requires-Dist: mypy>=1.10; extra == "dev"
 Requires-Dist: cibuildwheel>=2.19; extra == "dev"
 Requires-Dist: pre-commit>=3.7; extra == "dev"
+Requires-Dist: onnx>=1.16; extra == "dev"
+Requires-Dist: Pillow>=10; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: mkdocs>=1.6; extra == "docs"
 Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Provides-Extra: onnx
+Requires-Dist: onnx>=1.16; extra == "onnx"
+Provides-Extra: vision
+Requires-Dist: Pillow>=10; extra == "vision"
 Description-Content-Type: text/markdown
 
 # TensorStudio
@@ -65,7 +71,7 @@ Description-Content-Type: text/markdown
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.0.1` is a CPU-only stable API foundation. It is eager-only,
+TensorStudio `1.2.0` is a CPU-only stable API foundation. It is eager-only,
 intentionally small, and not a replacement for mature ML frameworks.
 
 ## Install
@@ -83,6 +89,12 @@ python -m pip install -U pip
 python -m pip install -e ".[dev]"
 ```
 
+Install optional extras for ONNX export and Pillow-backed image inputs:
+
+```bash
+python -m pip install "tensorstudio[onnx,vision]"
+```
+
 Build source and wheel distributions:
 
 ```bash
@@ -152,6 +164,8 @@ d = ts.linspace(0.0, 1.0, 5)
 
 print(a.shape, a.strides, a.device, a.is_contiguous)
 print((b.clamp(0.2, 0.8) + 1).mean().item())
+print(b.sum(axis=1).tolist())
+print(ts.concat([b, b], axis=0).shape, b.astype("float64").dtype)
 print(c.tolist(), d.tolist())
 print(ts.zeros_like(b).shape, ts.randn_like(b, seed=11).dtype)
 ```
@@ -204,6 +218,32 @@ print(model.state_dict().keys())
 print(model.parameter_count())
 ```
 
+## Vision
+
+TensorStudio includes a small vision namespace for image preprocessing and
+compact CNN classifiers. Image file decoding remains the job of Pillow or other
+image libraries; TensorStudio converts image-like arrays into channel-first
+tensors and runs the model with its native Conv2d and pooling kernels.
+
+```python
+import numpy as np
+import tensorstudio as ts
+from tensorstudio import nn, optim
+
+image = np.zeros((8, 8, 3), dtype=np.uint8)
+x = ts.vision.to_tensor(image).reshape((1, 3, 8, 8))
+x = ts.vision.normalize(x, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
+
+model = ts.vision.TinyConvClassifier((3, 8, 8), num_classes=2)
+target = ts.tensor([1], dtype="int64")
+optimizer = optim.SGD(model.parameters(), lr=0.01)
+
+optimizer.zero_grad()
+loss = nn.CrossEntropyLoss()(model(x), target)
+loss.backward()
+optimizer.step()
+```
+
 ## DataLoader
 
 ```python
@@ -235,12 +275,15 @@ python benchmarks/benchmark_report.py
 columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
 available locally.
 
-On one Windows CPython 3.10 run for `1.0.1`, TensorStudio beat NumPy on 13
-small activation/reduction benchmark cases and lost on 76 NumPy-comparable
-cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 71 local cases and
-lost 23. The strongest local wins were small eager operations where framework
-dispatch overhead dominates; larger matrix multiplication, larger transcendental
-activations, and larger autograd workloads remain faster in PyTorch and NumPy.
+On one Windows CPython 3.10 development run reporting `1.2.0`, TensorStudio
+beat NumPy on 26 small operation benchmark cases and lost on 77
+NumPy-comparable cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 75
+local cases and lost 33. The strongest local wins were small eager operations,
+small contiguous axis reductions, and the simple NumPy convolution/pooling
+references where framework dispatch or Python loops dominate; larger matrix
+multiplication, PyTorch convolution and pooling, larger axis reductions, larger
+transcendental activations, and larger autograd workloads remain faster in
+PyTorch and NumPy.
 See `benchmarks/results.md` for the full table, platform details, and exact
 timings.
 
@@ -248,11 +291,15 @@ Snapshot from that local run:
 
 | operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
 |---|---:|---:|---:|---:|---:|---:|
-| `sigmoid` | `(32,)` | 0.0018 ms | 0.0036 ms | 0.0575 ms | 2.0414x | 32.2110x |
-| `mean` | `(32,)` | 0.0016 ms | 0.0069 ms | 0.0112 ms | 4.4051x | 7.1262x |
-| `chain_relu` | `(128,)` | 0.0086 ms | 0.0039 ms | 0.0567 ms | 0.4488x | 6.5977x |
-| `matmul` | `(256, 256)` | 2.4215 ms | 0.4027 ms | 0.0832 ms | 0.1663x | 0.0343x |
-| `elementwise_backward` | `(1024,)` | 2.3527 ms | n/a | 0.1887 ms | n/a | 0.0802x |
+| `sigmoid` | `(32,)` | 0.0017 ms | 0.0038 ms | 0.0614 ms | 2.1691x | 35.3154x |
+| `mean` | `(32,)` | 0.0029 ms | 0.0131 ms | 0.0186 ms | 4.5638x | 6.4709x |
+| `sum_axis1` | `(16, 16)` | 0.0027 ms | 0.0029 ms | 0.0085 ms | 1.0894x | 3.1408x |
+| `chain_relu` | `(128,)` | 0.0112 ms | 0.0051 ms | 0.0726 ms | 0.4575x | 6.4533x |
+| `matmul` | `(256, 256)` | 4.4121 ms | 0.3779 ms | 0.1669 ms | 0.0856x | 0.0378x |
+| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.2374 ms | 1.7112 ms | 0.0186 ms | 7.2091x | 0.0784x |
+| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0237 ms | 0.2764 ms | 0.0082 ms | 11.6685x | 0.3462x |
+| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0198 ms | 0.7431 ms | 0.0073 ms | 37.4930x | 0.3662x |
+| `elementwise_backward` | `(1024,)` | 3.0196 ms | n/a | 0.2254 ms | n/a | 0.0746x |
 
 Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
 favor TensorStudio.
@@ -274,6 +321,39 @@ checkpoint = ts.load("checkpoint.tsmodel")
 Serialization uses pickle. Loading pickle files from untrusted sources is
 unsafe because pickle can execute arbitrary code.
 
+For safer tensor and `state_dict` interchange, use TensorStudio's non-pickle
+NPZ helpers:
+
+```python
+state = model.state_dict()
+ts.save_npz(state, "weights.tsnpz")
+model.load_state_dict(ts.load_npz("weights.tsnpz"))
+```
+
+## ONNX Export
+
+TensorStudio can export a supported `nn.Sequential` graph to ONNX when the
+optional `onnx` extra is installed:
+
+```python
+import tensorstudio as ts
+from tensorstudio import nn
+
+model = nn.Sequential(
+    nn.Conv2d(1, 2, kernel_size=3, padding=1),
+    nn.ReLU(),
+    nn.MaxPool2d(2),
+    nn.Flatten(),
+    nn.Linear(2 * 2 * 2, 3),
+)
+
+ts.export_onnx(model, "classifier.onnx", input_shape=(1, 1, 4, 4))
+```
+
+The v1.2 exporter supports `Linear`, `Conv2d`, `Flatten`, `ReLU`, `Sigmoid`,
+`Tanh`, `MaxPool2d`, and `AvgPool2d`. It is an exporter, not an ONNX runtime or
+importer.
+
 ## Development
 
 ```bash
@@ -318,9 +398,15 @@ tokens or print secrets.
 - No CUDA or Metal backend yet.
 - No BLAS-backed matrix multiplication yet.
 - No graph compiler or distributed runtime.
-- No convolution layers yet.
+- Convolution and pooling support are currently limited to CPU NCHW
+  `conv2d`, `max_pool2d`, and `avg_pool2d` style workloads.
+- Vision utilities are preprocessing and small CNN helpers, not a full computer
+  vision library.
+- ONNX support is export-only for a limited set of TensorStudio modules.
+- Reductions support all-element or single-axis reductions, not tuple-axis
+  reductions yet.
 - No sparse tensors or advanced indexing.
-- Limited dtype casting.
+- Dtype casting is basic and does not include a full promotion/casting policy.
 - Experimental performance; benchmarks are local references only.
 - Pickle serialization is for trusted TensorStudio objects only.
 
@@ -328,10 +414,10 @@ tokens or print secrets.
 
 - CUDA backend
 - Graph/JIT mode
-- Convolution ops
-- Dataset utilities
+- Broader convolution ops, adaptive/global pooling, and image-model examples
+- Richer dataset utilities
 - Model zoo examples
-- ONNX import/export
+- ONNX import and broader export coverage
 - Improved memory allocator
 - SIMD kernels
 - Multithreaded ops

{tensorstudio-1.0.1 → tensorstudio-1.2.0}/README.md

@@ -7,7 +7,7 @@
 TensorStudio is a compact C++ tensor and autograd engine with a Python API for
 learning, experimentation, and lightweight ML workloads.
 
-TensorStudio `1.0.1` is a CPU-only stable API foundation. It is eager-only,
+TensorStudio `1.2.0` is a CPU-only stable API foundation. It is eager-only,
 intentionally small, and not a replacement for mature ML frameworks.
 
 ## Install
@@ -25,6 +25,12 @@ python -m pip install -U pip
 python -m pip install -e ".[dev]"
 ```
 
+Install optional extras for ONNX export and Pillow-backed image inputs:
+
+```bash
+python -m pip install "tensorstudio[onnx,vision]"
+```
+
 Build source and wheel distributions:
 
 ```bash
@@ -94,6 +100,8 @@ d = ts.linspace(0.0, 1.0, 5)
 
 print(a.shape, a.strides, a.device, a.is_contiguous)
 print((b.clamp(0.2, 0.8) + 1).mean().item())
+print(b.sum(axis=1).tolist())
+print(ts.concat([b, b], axis=0).shape, b.astype("float64").dtype)
 print(c.tolist(), d.tolist())
 print(ts.zeros_like(b).shape, ts.randn_like(b, seed=11).dtype)
 ```
@@ -146,6 +154,32 @@ print(model.state_dict().keys())
 print(model.parameter_count())
 ```
 
+## Vision
+
+TensorStudio includes a small vision namespace for image preprocessing and
+compact CNN classifiers. Image file decoding remains the job of Pillow or other
+image libraries; TensorStudio converts image-like arrays into channel-first
+tensors and runs the model with its native Conv2d and pooling kernels.
+
+```python
+import numpy as np
+import tensorstudio as ts
+from tensorstudio import nn, optim
+
+image = np.zeros((8, 8, 3), dtype=np.uint8)
+x = ts.vision.to_tensor(image).reshape((1, 3, 8, 8))
+x = ts.vision.normalize(x, mean=(0.5, 0.5, 0.5), std=(0.5, 0.5, 0.5))
+
+model = ts.vision.TinyConvClassifier((3, 8, 8), num_classes=2)
+target = ts.tensor([1], dtype="int64")
+optimizer = optim.SGD(model.parameters(), lr=0.01)
+
+optimizer.zero_grad()
+loss = nn.CrossEntropyLoss()(model(x), target)
+loss.backward()
+optimizer.step()
+```
+
 ## DataLoader
 
 ```python
@@ -177,12 +211,15 @@ python benchmarks/benchmark_report.py
 columns for NumPy, TensorFlow, PyTorch, and JAX when those libraries are
 available locally.
 
-On one Windows CPython 3.10 run for `1.0.1`, TensorStudio beat NumPy on 13
-small activation/reduction benchmark cases and lost on 76 NumPy-comparable
-cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 71 local cases and
-lost 23. The strongest local wins were small eager operations where framework
-dispatch overhead dominates; larger matrix multiplication, larger transcendental
-activations, and larger autograd workloads remain faster in PyTorch and NumPy.
+On one Windows CPython 3.10 development run reporting `1.2.0`, TensorStudio
+beat NumPy on 26 small operation benchmark cases and lost on 77
+NumPy-comparable cases. Against PyTorch CPU `2.12.1+cpu`, TensorStudio won 75
+local cases and lost 33. The strongest local wins were small eager operations,
+small contiguous axis reductions, and the simple NumPy convolution/pooling
+references where framework dispatch or Python loops dominate; larger matrix
+multiplication, PyTorch convolution and pooling, larger axis reductions, larger
+transcendental activations, and larger autograd workloads remain faster in
+PyTorch and NumPy.
 See `benchmarks/results.md` for the full table, platform details, and exact
 timings.
 
@@ -190,11 +227,15 @@ Snapshot from that local run:
 
 | operation | shape | TensorStudio | NumPy | PyTorch CPU | TS vs NumPy | TS vs PyTorch |
 |---|---:|---:|---:|---:|---:|---:|
-| `sigmoid` | `(32,)` | 0.0018 ms | 0.0036 ms | 0.0575 ms | 2.0414x | 32.2110x |
-| `mean` | `(32,)` | 0.0016 ms | 0.0069 ms | 0.0112 ms | 4.4051x | 7.1262x |
-| `chain_relu` | `(128,)` | 0.0086 ms | 0.0039 ms | 0.0567 ms | 0.4488x | 6.5977x |
-| `matmul` | `(256, 256)` | 2.4215 ms | 0.4027 ms | 0.0832 ms | 0.1663x | 0.0343x |
-| `elementwise_backward` | `(1024,)` | 2.3527 ms | n/a | 0.1887 ms | n/a | 0.0802x |
+| `sigmoid` | `(32,)` | 0.0017 ms | 0.0038 ms | 0.0614 ms | 2.1691x | 35.3154x |
+| `mean` | `(32,)` | 0.0029 ms | 0.0131 ms | 0.0186 ms | 4.5638x | 6.4709x |
+| `sum_axis1` | `(16, 16)` | 0.0027 ms | 0.0029 ms | 0.0085 ms | 1.0894x | 3.1408x |
+| `chain_relu` | `(128,)` | 0.0112 ms | 0.0051 ms | 0.0726 ms | 0.4575x | 6.4533x |
+| `matmul` | `(256, 256)` | 4.4121 ms | 0.3779 ms | 0.1669 ms | 0.0856x | 0.0378x |
+| `conv2d_3x3_padding1` | `(1, 1, 8, 8)` | 0.2374 ms | 1.7112 ms | 0.0186 ms | 7.2091x | 0.0784x |
+| `max_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0237 ms | 0.2764 ms | 0.0082 ms | 11.6685x | 0.3462x |
+| `avg_pool2d_2x2` | `(1, 1, 16, 16)` | 0.0198 ms | 0.7431 ms | 0.0073 ms | 37.4930x | 0.3662x |
+| `elementwise_backward` | `(1024,)` | 3.0196 ms | n/a | 0.2254 ms | n/a | 0.0746x |
 
 Speedup is `competitor median / TensorStudio median`, so values above `1.0x`
 favor TensorStudio.
@@ -216,6 +257,39 @@ checkpoint = ts.load("checkpoint.tsmodel")
 Serialization uses pickle. Loading pickle files from untrusted sources is
 unsafe because pickle can execute arbitrary code.
 
+For safer tensor and `state_dict` interchange, use TensorStudio's non-pickle
+NPZ helpers:
+
+```python
+state = model.state_dict()
+ts.save_npz(state, "weights.tsnpz")
+model.load_state_dict(ts.load_npz("weights.tsnpz"))
+```
+
+## ONNX Export
+
+TensorStudio can export a supported `nn.Sequential` graph to ONNX when the
+optional `onnx` extra is installed:
+
+```python
+import tensorstudio as ts
+from tensorstudio import nn
+
+model = nn.Sequential(
+    nn.Conv2d(1, 2, kernel_size=3, padding=1),
+    nn.ReLU(),
+    nn.MaxPool2d(2),
+    nn.Flatten(),
+    nn.Linear(2 * 2 * 2, 3),
+)
+
+ts.export_onnx(model, "classifier.onnx", input_shape=(1, 1, 4, 4))
+```
+
+The v1.2 exporter supports `Linear`, `Conv2d`, `Flatten`, `ReLU`, `Sigmoid`,
+`Tanh`, `MaxPool2d`, and `AvgPool2d`. It is an exporter, not an ONNX runtime or
+importer.
+
 ## Development
 
 ```bash
@@ -260,9 +334,15 @@ tokens or print secrets.
 - No CUDA or Metal backend yet.
 - No BLAS-backed matrix multiplication yet.
 - No graph compiler or distributed runtime.
-- No convolution layers yet.
+- Convolution and pooling support are currently limited to CPU NCHW
+  `conv2d`, `max_pool2d`, and `avg_pool2d` style workloads.
+- Vision utilities are preprocessing and small CNN helpers, not a full computer
+  vision library.
+- ONNX support is export-only for a limited set of TensorStudio modules.
+- Reductions support all-element or single-axis reductions, not tuple-axis
+  reductions yet.
 - No sparse tensors or advanced indexing.
-- Limited dtype casting.
+- Dtype casting is basic and does not include a full promotion/casting policy.
 - Experimental performance; benchmarks are local references only.
 - Pickle serialization is for trusted TensorStudio objects only.
 
@@ -270,10 +350,10 @@ tokens or print secrets.
 
 - CUDA backend
 - Graph/JIT mode
-- Convolution ops
-- Dataset utilities
+- Broader convolution ops, adaptive/global pooling, and image-model examples
+- Richer dataset utilities
 - Model zoo examples
-- ONNX import/export
+- ONNX import and broader export coverage
 - Improved memory allocator
 - SIMD kernels
 - Multithreaded ops

{tensorstudio-1.0.1 → tensorstudio-1.2.0}/benchmark_all.py

@@ -8,6 +8,8 @@ from benchmarks.benchmark_report import run_benchmarks
 ALL_SECTIONS = {
     "elementwise",
     "matmul",
+    "conv2d",
+    "pooling",
     "reductions",
     "activations",
     "autograd",

tensorstudio-1.2.0/benchmarks/bench_conv2d.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from benchmark_report import run_benchmarks
+
+if __name__ == "__main__":
+    print(run_benchmarks({"conv2d"}, Path(__file__).with_name("results_conv2d.md")))

tensorstudio-1.2.0/benchmarks/bench_pooling.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from benchmark_report import run_benchmarks
+
+if __name__ == "__main__":
+    print(run_benchmarks({"pooling"}, Path(__file__).with_name("results_pooling.md")))