modelstudio 0.6.0__tar.gz → 0.7.0__tar.gz

{modelstudio-0.6.0/python/modelstudio.egg-info → modelstudio-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelstudio
-Version: 0.6.0
+Version: 0.7.0
 Summary: An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding.
 Author: ModelStudio Contributors
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.0` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -74,7 +74,7 @@ python -m pip install -e ".[dev]"
 | Interop | `asarray`, `from_numpy`, `to_numpy`, and `ms.numpy` |
 | Metrics | accuracy and top-k accuracy |
 | Compiler | Metadata-only tracing plus placeholder IR and passes |
-| CUDA API | Availability, device-count, sync, and memory-status facade; tensor execution is not implemented in the CPU wheel |
+| CUDA API | Availability, device-count/name, sync, memory-status facade, and release-machine validation scripts; tensor execution is not implemented in the CPU wheel |
 
 ## Architecture
 
@@ -123,6 +123,7 @@ CUDA availability can also be checked through the public namespace:
 ```python
 print(ms.cuda.is_available())
 print(ms.cuda.device_count())
+print(ms.cuda.device_name())
 print(ms.cuda.memory_summary())
 ```
 
@@ -226,6 +227,7 @@ python examples/functional_training.py
 python examples/random_linalg_demo.py
 python examples/cuda_tensor_demo.py
 python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
 python benchmarks/bench_matmul.py
 python benchmarks/bench_mlp.py
 python benchmarks/bench_attention.py
@@ -238,6 +240,9 @@ python benchmarks/bench_elementwise.py
 python benchmarks/bench_trace.py
 python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

{modelstudio-0.6.0 → modelstudio-0.7.0}/README.md

@@ -1,6 +1,6 @@
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.0` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -43,7 +43,7 @@ python -m pip install -e ".[dev]"
 | Interop | `asarray`, `from_numpy`, `to_numpy`, and `ms.numpy` |
 | Metrics | accuracy and top-k accuracy |
 | Compiler | Metadata-only tracing plus placeholder IR and passes |
-| CUDA API | Availability, device-count, sync, and memory-status facade; tensor execution is not implemented in the CPU wheel |
+| CUDA API | Availability, device-count/name, sync, memory-status facade, and release-machine validation scripts; tensor execution is not implemented in the CPU wheel |
 
 ## Architecture
 
@@ -92,6 +92,7 @@ CUDA availability can also be checked through the public namespace:
 ```python
 print(ms.cuda.is_available())
 print(ms.cuda.device_count())
+print(ms.cuda.device_name())
 print(ms.cuda.memory_summary())
 ```
 
@@ -195,6 +196,7 @@ python examples/functional_training.py
 python examples/random_linalg_demo.py
 python examples/cuda_tensor_demo.py
 python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
 python benchmarks/bench_matmul.py
 python benchmarks/bench_mlp.py
 python benchmarks/bench_attention.py
@@ -207,6 +209,9 @@ python benchmarks/bench_elementwise.py
 python benchmarks/bench_trace.py
 python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

modelstudio-0.7.0/benchmarks/bench_cuda_autograd.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import platform
+import time
+from collections.abc import Callable
+
+import modelstudio as ms
+from modelstudio import nn
+
+
+def _time_ms(fn: Callable[[], object], warmup: int, iterations: int, *, synchronize: bool) -> float:
+    for _ in range(warmup):
+        fn()
+    if synchronize:
+        ms.cuda.synchronize()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    if synchronize:
+        ms.cuda.synchronize()
+    return (time.perf_counter() - start) * 1000.0 / iterations
+
+
+def main() -> None:
+    batch = 32
+    in_features = 128
+    out_features = 64
+    warmup = 3
+    iterations = 20
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {ms.numpy.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"CUDA:        available={ms.cuda.is_available()} device_count={ms.cuda.device_count()}")
+    print(f"GPU:         {ms.cuda.device_name() or 'unavailable'}")
+    print(f"Shape:       batch={batch} in={in_features} out={out_features}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+
+    if not ms.cuda.is_available():
+        print(ms.cuda.memory_summary())
+        print("Skipping CUDA autograd benchmark because CUDA tensor execution is not available.")
+        return
+
+    ms.manual_seed(123)
+    model = nn.Linear(in_features, out_features).to("cuda")
+    optimizer = ms.optim.SGD(model.parameters(), lr=1e-3)
+    x = ms.randn((batch, in_features), device="cuda")
+    target = ms.randn((batch, out_features), device="cuda")
+
+    def step() -> ms.Tensor:
+        pred = model(x)
+        loss = ms.mse_loss(pred, target)
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+        return loss
+
+    autograd_ms = _time_ms(step, warmup, iterations, synchronize=True)
+
+    print(f"CUDA forward/backward/update avg: {autograd_ms:.3f} ms")
+    print(ms.cuda.memory_summary())
+
+
+if __name__ == "__main__":
+    main()

{modelstudio-0.6.0 → modelstudio-0.7.0}/benchmarks/bench_cuda_elementwise.py

@@ -29,6 +29,7 @@ def main() -> None:
     print(f"NumPy:       {ms.numpy.__version__}")
     print(f"ModelStudio: {ms.__version__}")
     print(f"CUDA:        available={ms.cuda.is_available()} device_count={ms.cuda.device_count()}")
+    print(f"GPU:         {ms.cuda.device_name() or 'unavailable'}")
     print(f"Shape:       {shape}")
     print(f"Warmup:      {warmup}")
     print(f"Iterations:  {iterations}")

{modelstudio-0.6.0 → modelstudio-0.7.0}/benchmarks/bench_cuda_matmul.py

@@ -29,6 +29,7 @@ def main() -> None:
     print(f"NumPy:       {ms.numpy.__version__}")
     print(f"ModelStudio: {ms.__version__}")
     print(f"CUDA:        available={ms.cuda.is_available()} device_count={ms.cuda.device_count()}")
+    print(f"GPU:         {ms.cuda.device_name() or 'unavailable'}")
     print(f"Shape:       {shape} x {shape}")
     print(f"Warmup:      {warmup}")
     print(f"Iterations:  {iterations}")

{modelstudio-0.6.0 → modelstudio-0.7.0}/csrc/backends/cuda/cuda_context.cu

@@ -30,6 +30,12 @@ int current_device() {
   return device;
 }
 
+std::string device_name(int index) {
+  cudaDeviceProp properties{};
+  check_cuda(cudaGetDeviceProperties(&properties, index), "cudaGetDeviceProperties");
+  return std::string(properties.name);
+}
+
 void set_device(int index) {
   check_cuda(cudaSetDevice(index), "cudaSetDevice");
 }

{modelstudio-0.6.0 → modelstudio-0.7.0}/csrc/backends/cuda/cuda_context.hpp

@@ -1,9 +1,12 @@
 #pragma once
 
+#include <string>
+
 namespace modelstudio::cuda {
 
 int device_count();
 int current_device();
+std::string device_name(int index);
 void set_device(int index);
 void check_cuda(int status, const char* operation);
 

{modelstudio-0.6.0 → modelstudio-0.7.0}/docs/backend-status.md

@@ -1,6 +1,6 @@
 # Backend Status
 
-ModelStudio 0.6.0 keeps CPU as the only available runtime backend in the
+ModelStudio 0.7.0 keeps CPU as the only available runtime backend in the
 default PyPI package. It also exposes a public CUDA status namespace so users
 can check accelerator availability without importing optional native artifacts.
 
@@ -31,6 +31,19 @@ The CUDA entry includes these fields:
 device. `built` only reports whether the optional CUDA extension can be
 imported. In the CPU-only package both are false.
 
+The `ms.cuda` namespace provides safe availability probes:
+
+```python
+ms.cuda.is_available()
+ms.cuda.device_count()
+ms.cuda.device_name()
+ms.cuda.memory_allocated()
+ms.cuda.memory_summary()
+```
+
+`device_name()` returns `None` when CUDA is unavailable or when an optional
+backend does not expose a device-name binding.
+
 `ms.backends.native_cpu_available()` checks for the optional future native CPU
 extension. `ms.backends.use_native_cpu(True)` raises
 `ModelStudioBackendUnavailable` unless that extension is installed. The NumPy

modelstudio-0.7.0/docs/cuda.md

@@ -0,0 +1,127 @@
+# CUDA Status
+
+ModelStudio 0.7.0 includes a public CUDA availability namespace and native scaffold,
+but the default `modelstudio` PyPI package remains CPU-only.
+
+```python
+import modelstudio as ms
+
+print(ms.cuda.is_available())
+print(ms.cuda.device_count())
+print(ms.cuda.device_name())
+print(ms.cuda.current_device())
+print(ms.cuda.memory_summary())
+```
+
+In the CPU-only package:
+
+- `ms.cuda.is_available()` returns `False`.
+- `ms.cuda.device_count()` returns `0`.
+- `ms.cuda.device_name()` returns `None`.
+- `ms.cuda.memory_allocated()` returns `0`.
+- `ms.cuda.memory_summary()` explains why CUDA is unavailable.
+- `ms.cuda.set_device(...)` and `ms.cuda.synchronize()` raise
+  `ModelStudioBackendUnavailable`.
+- Creating tensors with `device="cuda"` raises `ModelStudioBackendUnavailable`.
+
+The error is intentional:
+
+```text
+CUDA backend is not built. Install modelstudio-cuda or build with MODELSTUDIO_ENABLE_CUDA=ON.
+```
+
+## Native Scaffold
+
+The `csrc/backends/cuda` tree includes conditional CMake wiring, CUDA context
+helpers, memory and stream placeholders, and initial kernel entry points for:
+
+- elementwise arithmetic
+- reductions
+- matrix multiplication
+
+Those files are extension points, not a CUDA execution claim. A future CUDA
+package must add device tensor storage, real kernels, Python bindings, packaging,
+and hardware-backed tests before CUDA tensor execution can be advertised.
+
+## Build Option
+
+The top-level CMake option is:
+
+```bash
+cmake -S . -B build-cuda -DMODELSTUDIO_ENABLE_CUDA=ON
+```
+
+If the CUDA compiler or toolkit is missing, configuration fails clearly instead
+of silently producing a CPU-only build that looks CUDA-capable.
+
+On Windows source checkouts, the helper below bootstraps missing Python-side
+build tools such as the CMake wheel, runs CMake, and treats skipped CUDA tests
+as a failure:
+
+```powershell
+python scripts/cuda_source_build_check.py
+```
+
+If this fails with a C++ compiler or generator error, install Visual Studio
+Build Tools with the C++ workload and rerun it from a shell where `nvcc --version`
+works.
+
+## Phase 7 Release Gate
+
+The next CUDA execution release must be prepared on a machine where all of
+these commands work:
+
+```bash
+nvidia-smi
+nvcc --version
+cmake -S . -B build-cuda -DMODELSTUDIO_ENABLE_CUDA=ON
+cmake --build build-cuda --config Release
+```
+
+Do not bump the package to `0.7.0`, create `v0.7.0`, or publish PyPI artifacts
+unless the CUDA tests run instead of skipping:
+
+```bash
+python -m pytest \
+  tests/test_cuda_availability.py \
+  tests/test_cuda_tensor.py \
+  tests/test_cuda_ops.py \
+  tests/test_cuda_reductions.py \
+  tests/test_cuda_matmul.py \
+  tests/test_cuda_autograd.py \
+  tests/test_cuda_optim.py \
+  tests/test_cuda_nn.py \
+  tests/test_cuda_memory.py
+```
+
+CPU-only machines may still run the same tests, but CUDA execution tests should
+skip with `CUDA unavailable`. That is useful development feedback, not release
+evidence for CUDA execution.
+
+For the same gate in one command from a source checkout:
+
+```bash
+python scripts/cuda_source_build_check.py
+```
+
+## CUDA Examples And Benchmarks
+
+The CUDA scripts are safe to run on CPU-only installs:
+
+```bash
+python examples/cuda_tensor_demo.py
+python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
+python benchmarks/bench_cuda_elementwise.py
+python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+python scripts/cuda_release_check.py
+```
+
+On CPU-only installs they print the unavailable reason and exit with status 0.
+On a CUDA build they should perform real CUDA tensor computation and synchronize
+around timed benchmark regions.
+
+`scripts/cuda_release_check.py` is stricter than the demos and benchmarks. It is
+intended for a CUDA release machine and exits non-zero when CUDA is unavailable
+or CUDA tensor execution fails.

{modelstudio-0.6.0 → modelstudio-0.7.0}/docs/native-backend-roadmap.md

@@ -1,6 +1,6 @@
 # Native Backend Roadmap
 
-The Python runtime still uses NumPy CPU kernels in 0.6.0. The native C++ tree is
+The Python runtime still uses NumPy CPU kernels in 0.7.0. The native C++ tree is
 scaffolding for future backend work and is intentionally not wired into Python
 dispatch yet.
 

{modelstudio-0.6.0 → modelstudio-0.7.0}/docs/releasing.md

@@ -17,10 +17,49 @@ Run the full local gate:
 ```bash
 python -m ruff check .
 python -m pytest
-python examples/train_mlp.py
 python scripts/smoke_test.py
+python examples/backend_status.py
+python examples/train_mlp.py
+python examples/cuda_tensor_demo.py
+python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
 python benchmarks/bench_matmul.py
 python benchmarks/bench_mlp.py
+python benchmarks/bench_cuda_elementwise.py
+python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+cmake -S . -B build-native
+cmake --build build-native --config Release
+```
+
+## CUDA Execution Release Gate
+
+Do not publish a CUDA execution release from a CPU-only machine. Before bumping
+to a release that claims CUDA execution, verify:
+
+```bash
+nvidia-smi
+nvcc --version
+cmake -S . -B build-cuda -DMODELSTUDIO_ENABLE_CUDA=ON
+cmake --build build-cuda --config Release
+python -m pytest tests/test_cuda_availability.py tests/test_cuda_tensor.py tests/test_cuda_ops.py tests/test_cuda_reductions.py tests/test_cuda_matmul.py tests/test_cuda_autograd.py tests/test_cuda_optim.py tests/test_cuda_nn.py tests/test_cuda_memory.py
+python examples/cuda_tensor_demo.py
+python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
+python benchmarks/bench_cuda_elementwise.py
+python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+python scripts/cuda_release_check.py
+```
+
+On the CUDA release machine those tests must run and pass. If they skip because
+CUDA is unavailable, do not tag or publish the CUDA release.
+
+From a source checkout, this one-command gate also bootstraps missing
+Python-side build tools such as the CMake wheel and fails if CUDA tests skip:
+
+```bash
+python scripts/cuda_source_build_check.py
 ```
 
 ## Build Distributions

{modelstudio-0.6.0 → modelstudio-0.7.0}/docs/training.md

@@ -1,6 +1,6 @@
 # Training
 
-ModelStudio 0.6.0 supports CPU training loops with modules, optimizers,
+ModelStudio 0.7.0 supports CPU training loops with modules, optimizers,
 loss functions, DataLoader batching, dropout, BatchNorm1d, and checkpointing.
 
 ```python

modelstudio-0.7.0/examples/cuda_autograd_demo.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import modelstudio as ms
+from modelstudio import nn
+
+
+def main() -> None:
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"CUDA available: {ms.cuda.is_available()}")
+    print(f"CUDA device count: {ms.cuda.device_count()}")
+
+    if not ms.cuda.is_available():
+        print(ms.cuda.memory_summary())
+        print("Skipping CUDA autograd demo because CUDA tensor execution is not available.")
+        return
+
+    ms.manual_seed(123)
+    x_cpu = ms.randn((4, 3), requires_grad=True)
+    w_cpu = ms.randn((3, 2), requires_grad=True)
+    x = x_cpu.to("cuda")
+    w = w_cpu.to("cuda")
+
+    loss = ms.gelu(x @ w).mean()
+    loss.backward()
+    ms.cuda.synchronize()
+
+    print(f"loss={loss.item():.6f}")
+    print(f"x.grad.device={x.grad.device if x.grad is not None else None}")
+    print(f"w.grad.device={w.grad.device if w.grad is not None else None}")
+
+    model = nn.Linear(3, 2).to("cuda")
+    optimizer = ms.optim.SGD(model.parameters(), lr=1e-2)
+    target = ms.randn((4, 2), device="cuda")
+    train_loss = ms.mse_loss(model(x.detach()), target)
+    optimizer.zero_grad()
+    train_loss.backward()
+    optimizer.step()
+    ms.cuda.synchronize()
+
+    print(f"train_loss={train_loss.item():.6f}")
+    print(ms.cuda.memory_summary())
+
+
+if __name__ == "__main__":
+    main()

{modelstudio-0.6.0 → modelstudio-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modelstudio"
-version = "0.6.0"
+version = "0.7.0"
 description = "An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding."
 readme = "README.md"
 requires-python = ">=3.10"

modelstudio-0.7.0/python/modelstudio/_version.py

@@ -0,0 +1 @@
+__version__ = "0.7.0"

{modelstudio-0.6.0 → modelstudio-0.7.0}/python/modelstudio/cuda/__init__.py

@@ -1,10 +1,11 @@
-from modelstudio.cuda.device import current_device, device_count, is_available, set_device
+from modelstudio.cuda.device import current_device, device_count, device_name, is_available, set_device
 from modelstudio.cuda.memory import memory_allocated, memory_summary
 from modelstudio.cuda.streams import synchronize
 
 __all__ = [
     "current_device",
     "device_count",
+    "device_name",
     "is_available",
     "memory_allocated",
     "memory_summary",

{modelstudio-0.6.0 → modelstudio-0.7.0}/python/modelstudio/cuda/device.py

@@ -17,6 +17,20 @@ def device_count() -> int:
     return cuda_backend.device_count()
 
 
+def device_name(index: int = 0) -> str | None:
+    """Return the CUDA device name when the optional backend exposes it."""
+
+    if not is_available():
+        return None
+    normalized = int(index)
+    if normalized < 0 or normalized >= device_count():
+        from modelstudio.errors import ModelStudioDeviceError
+
+        raise ModelStudioDeviceError(f"CUDA device index {normalized} is out of range")
+    name = cuda_backend.call_optional("device_name", None, normalized)
+    return None if name is None else str(name)
+
+
 def current_device() -> int:
     """Return the selected CUDA device index.
 

{modelstudio-0.6.0 → modelstudio-0.7.0/python/modelstudio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelstudio
-Version: 0.6.0
+Version: 0.7.0
 Summary: An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding.
 Author: ModelStudio Contributors
 License-Expression: MIT
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.6.0` provides a
+ModelStudio is an early-stage AI tensor framework. Version `0.7.0` provides a
 CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
 data loading, graph tracing metadata, backend status inspection, a public CUDA
 availability namespace, and small LLM-oriented building blocks.
@@ -74,7 +74,7 @@ python -m pip install -e ".[dev]"
 | Interop | `asarray`, `from_numpy`, `to_numpy`, and `ms.numpy` |
 | Metrics | accuracy and top-k accuracy |
 | Compiler | Metadata-only tracing plus placeholder IR and passes |
-| CUDA API | Availability, device-count, sync, and memory-status facade; tensor execution is not implemented in the CPU wheel |
+| CUDA API | Availability, device-count/name, sync, memory-status facade, and release-machine validation scripts; tensor execution is not implemented in the CPU wheel |
 
 ## Architecture
 
@@ -123,6 +123,7 @@ CUDA availability can also be checked through the public namespace:
 ```python
 print(ms.cuda.is_available())
 print(ms.cuda.device_count())
+print(ms.cuda.device_name())
 print(ms.cuda.memory_summary())
 ```
 
@@ -226,6 +227,7 @@ python examples/functional_training.py
 python examples/random_linalg_demo.py
 python examples/cuda_tensor_demo.py
 python examples/cuda_mlp_demo.py
+python examples/cuda_autograd_demo.py
 python benchmarks/bench_matmul.py
 python benchmarks/bench_mlp.py
 python benchmarks/bench_attention.py
@@ -238,6 +240,9 @@ python benchmarks/bench_elementwise.py
 python benchmarks/bench_trace.py
 python benchmarks/bench_cuda_elementwise.py
 python benchmarks/bench_cuda_matmul.py
+python benchmarks/bench_cuda_autograd.py
+python scripts/cuda_release_check.py
+python scripts/cuda_source_build_check.py
 ```
 
 ## Documentation

{modelstudio-0.6.0 → modelstudio-0.7.0}/python/modelstudio.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ pyproject.toml
 benchmarks/bench_attention.py
 benchmarks/bench_conv.py
 benchmarks/bench_creation.py
+benchmarks/bench_cuda_autograd.py
 benchmarks/bench_cuda_elementwise.py
 benchmarks/bench_cuda_matmul.py
 benchmarks/bench_dataloader.py
@@ -81,6 +82,7 @@ docs/training.md
 examples/backend_status.py
 examples/checkpoint_resume.py
 examples/checkpoint_training.py
+examples/cuda_autograd_demo.py
 examples/cuda_mlp_demo.py
 examples/cuda_tensor_demo.py
 examples/dropout_batchnorm.py
@@ -163,6 +165,8 @@ python/modelstudio/runtime/backend.py
 python/modelstudio/runtime/dispatcher.py
 python/modelstudio/testing/__init__.py
 python/modelstudio/testing/gradcheck.py
+scripts/cuda_release_check.py
+scripts/cuda_source_build_check.py
 scripts/smoke_test.py
 tests/test_activations_more.py
 tests/test_attention.py
@@ -178,9 +182,12 @@ tests/test_conv.py
 tests/test_creation_more.py
 tests/test_cuda_autograd.py
 tests/test_cuda_availability.py
+tests/test_cuda_matmul.py
 tests/test_cuda_memory.py
 tests/test_cuda_nn.py
 tests/test_cuda_ops.py
+tests/test_cuda_optim.py
+tests/test_cuda_reductions.py
 tests/test_cuda_tensor.py
 tests/test_data.py
 tests/test_data_split.py