modelstudio 0.3.0__tar.gz → 0.5.0__tar.gz

modelstudio-0.5.0/PKG-INFO

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: modelstudio
+Version: 0.5.0
+Summary: An early-stage AI tensor framework with CPU tensors, autograd, and backend extension scaffolding.
+Author: ModelStudio Contributors
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/imattas/modelstudio
+Project-URL: Repository, https://github.com/imattas/modelstudio
+Project-URL: Issues, https://github.com/imattas/modelstudio/issues
+Keywords: ai,autograd,deep-learning,neural-networks,tensor
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+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: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.26
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+Dynamic: license-file
+
+# ModelStudio
+
+ModelStudio is an early-stage AI tensor framework. Version `0.5.0` provides a
+CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
+data loading, graph tracing metadata, backend status inspection, and small
+LLM-oriented building blocks.
+
+It is not a PyTorch or TensorFlow replacement. CPU is the only working backend.
+CUDA, ROCm, and oneAPI remain explicit scaffolds until real kernels are built
+and tested.
+
+## Installation
+
+From PyPI:
+
+```bash
+python -m pip install modelstudio
+```
+
+For development:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+## Feature Table
+
+| Area | Status |
+| --- | --- |
+| CPU tensors | Working MVP |
+| Autograd | Reverse-mode for core CPU ops |
+| Reductions | `sum`, `mean`, `max`, `all`, and `any`; `max` is value-only |
+| Comparisons | Elementwise comparisons, `equal`, `isclose`, and `allclose` |
+| Activations | ReLU, GELU, LeakyReLU, ELU, Softplus, exp, log, tanh, sigmoid, SiLU, softmax, log-softmax |
+| Losses | MSE and cross entropy with `none`, `mean`, and `sum` reductions |
+| Functional API | `modelstudio.nn.functional` wrappers for common NN operations |
+| Modules | Parameters, buffers, child traversal, state dicts, save/load |
+| Layers | Linear, Embedding, LayerNorm, RMSNorm, BatchNorm1d, Dropout, Conv1d, Conv2d, pooling, TransformerBlock |
+| Optimizers | SGD and AdamW with state serialization, parameter groups, and LR schedulers |
+| Data | Dataset, TensorDataset, random_split, DataLoader with deterministic seeded shuffle |
+| Randomness | `manual_seed`, `ms.random`, RNG-backed creation, dropout, and init helpers |
+| Linalg | `ms.linalg.matmul`, `norm`, `vector_norm`, and `transpose` |
+| Interop | `asarray`, `from_numpy`, `to_numpy`, and `ms.numpy` |
+| Metrics | accuracy and top-k accuracy |
+| Compiler | Metadata-only tracing plus placeholder IR and passes |
+
+## Backend Status
+
+```python
+import modelstudio as ms
+
+print(ms.backends.status())
+print(ms.backends.native_cpu_available())
+```
+
+Expected shape:
+
+```python
+{
+    "cpu": {"available": True, "native": False},
+    "cuda": {"available": False, "reason": "..."},
+    "rocm": {"available": False, "reason": "..."},
+    "oneapi": {"available": False, "reason": "..."},
+}
+```
+
+The production CPU path is the NumPy backend. `ms.backends.use_native_cpu(True)`
+raises `ModelStudioBackendUnavailable` unless a future optional native extension
+is actually installed. Unsupported accelerator devices fail with
+`ModelStudioBackendUnavailable`.
+
+## Tensor Example
+
+```python
+import modelstudio as ms
+
+x = ms.randn((32, 784), requires_grad=True)
+w = ms.randn((784, 10), requires_grad=True)
+loss = (x @ w).mean()
+loss.backward()
+print(w.grad)
+```
+
+## Functional API
+
+```python
+import modelstudio as ms
+from modelstudio import nn
+from modelstudio.nn import functional as F
+
+model = nn.Linear(4, 2)
+x = ms.random.randn((8, 4))
+target = ms.random.randn((8, 2))
+loss = F.mse_loss(F.relu(F.linear(x, model.weight, model.bias)), target)
+```
+
+## Tracing
+
+```python
+import modelstudio as ms
+from modelstudio.nn import functional as F
+
+x = ms.random.randn((4, 3))
+w = ms.random.randn((3, 2))
+graph = ms.trace(lambda a, b: F.relu(a @ b), x, w)
+print(graph)
+```
+
+Tracing captures operation names and tensor metadata. It does not optimize or
+execute graphs yet. `ms.compile(fn)` remains a documented no-op that returns the
+original callable.
+
+## Random And Linalg
+
+```python
+ms.random.seed(123)
+x = ms.random.normal((4, 3), mean=0.0, std=1.0)
+w = ms.random.uniform((3, 2), low=-0.1, high=0.1)
+y = ms.linalg.matmul(x, w)
+print(ms.linalg.norm(y).item())
+```
+
+## Comparisons
+
+```python
+x = ms.tensor([1.0, 2.0, 3.0])
+y = ms.tensor([1.0, 2.1, 3.0])
+print(ms.isclose(x, y, atol=0.05))
+print(ms.allclose(x, y, atol=0.05))
+print((x > 1.5).any().item())
+```
+
+Comparison and logical outputs are bool tensors and do not track gradients.
+
+## Checkpointing
+
+```python
+model = nn.Linear(4, 2)
+optimizer = ms.optim.AdamW(model.parameters(), lr=1e-3)
+ms.save_checkpoint("checkpoint.ms", model=model, optimizer=optimizer, extra={"epoch": 1})
+checkpoint = ms.load_checkpoint("checkpoint.ms", model=model, optimizer=optimizer, map_location="cpu")
+```
+
+Checkpoint loading validates structure and model state. CPU is the only accepted
+`map_location` in the current release.
+
+## Commands
+
+```bash
+python -m pytest
+python scripts/smoke_test.py
+python examples/train_mlp.py
+python examples/train_classifier.py
+python examples/tiny_transformer.py
+python examples/save_load.py
+python examples/train_cnn_toy.py
+python examples/dropout_batchnorm.py
+python examples/checkpoint_training.py
+python examples/numpy_interop.py
+python examples/scheduler_training.py
+python examples/checkpoint_resume.py
+python examples/metrics_demo.py
+python examples/backend_status.py
+python examples/tracing_demo.py
+python examples/functional_training.py
+python examples/random_linalg_demo.py
+python benchmarks/bench_matmul.py
+python benchmarks/bench_mlp.py
+python benchmarks/bench_attention.py
+python benchmarks/bench_dataloader.py
+python benchmarks/bench_conv.py
+python benchmarks/bench_dropout.py
+python benchmarks/bench_creation.py
+python benchmarks/bench_manipulation.py
+python benchmarks/bench_elementwise.py
+python benchmarks/bench_trace.py
+```
+
+## Documentation
+
+- [Backend status](docs/backend-status.md)
+- [Tracing](docs/tracing.md)
+- [Functional API](docs/functional-api.md)
+- [Random namespace](docs/random.md)
+- [Linalg namespace](docs/linalg.md)
+- [Comparison ops](docs/comparison-ops.md)
+- [Tensor API](docs/tensor-api.md)
+- [Neural network API](docs/nn.md)
+- [Data utilities](docs/data.md)
+- [Training](docs/training.md)
+- [Modules](docs/modules.md)
+- [Serialization](docs/serialization.md)
+- [Native backend roadmap](docs/native-backend-roadmap.md)
+- [NumPy interop](docs/numpy-interop.md)
+- [Tensor creation](docs/tensor-creation.md)
+- [Tensor manipulation](docs/tensor-manipulation.md)
+- [Optimizers](docs/optimizers.md)
+- [Checkpointing](docs/checkpointing.md)
+- [Metrics](docs/metrics.md)
+- [Backend architecture](docs/backend-architecture.md)
+- [Autograd design](docs/autograd.md)
+- [Releasing](docs/releasing.md)
+- [Contributing](CONTRIBUTING.md)
+
+## Roadmap
+
+- Expand tensor and autograd coverage.
+- Wire optional native CPU kernels only after a safe Python extension exists.
+- Add tested CUDA, ROCm, and oneAPI packages when hardware-backed CI exists.
+- Improve compiler graph capture, analysis passes, and lowering.

modelstudio-0.5.0/README.md

@@ -0,0 +1,210 @@
+# ModelStudio
+
+ModelStudio is an early-stage AI tensor framework. Version `0.5.0` provides a
+CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
+data loading, graph tracing metadata, backend status inspection, and small
+LLM-oriented building blocks.
+
+It is not a PyTorch or TensorFlow replacement. CPU is the only working backend.
+CUDA, ROCm, and oneAPI remain explicit scaffolds until real kernels are built
+and tested.
+
+## Installation
+
+From PyPI:
+
+```bash
+python -m pip install modelstudio
+```
+
+For development:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+## Feature Table
+
+| Area | Status |
+| --- | --- |
+| CPU tensors | Working MVP |
+| Autograd | Reverse-mode for core CPU ops |
+| Reductions | `sum`, `mean`, `max`, `all`, and `any`; `max` is value-only |
+| Comparisons | Elementwise comparisons, `equal`, `isclose`, and `allclose` |
+| Activations | ReLU, GELU, LeakyReLU, ELU, Softplus, exp, log, tanh, sigmoid, SiLU, softmax, log-softmax |
+| Losses | MSE and cross entropy with `none`, `mean`, and `sum` reductions |
+| Functional API | `modelstudio.nn.functional` wrappers for common NN operations |
+| Modules | Parameters, buffers, child traversal, state dicts, save/load |
+| Layers | Linear, Embedding, LayerNorm, RMSNorm, BatchNorm1d, Dropout, Conv1d, Conv2d, pooling, TransformerBlock |
+| Optimizers | SGD and AdamW with state serialization, parameter groups, and LR schedulers |
+| Data | Dataset, TensorDataset, random_split, DataLoader with deterministic seeded shuffle |
+| Randomness | `manual_seed`, `ms.random`, RNG-backed creation, dropout, and init helpers |
+| Linalg | `ms.linalg.matmul`, `norm`, `vector_norm`, and `transpose` |
+| Interop | `asarray`, `from_numpy`, `to_numpy`, and `ms.numpy` |
+| Metrics | accuracy and top-k accuracy |
+| Compiler | Metadata-only tracing plus placeholder IR and passes |
+
+## Backend Status
+
+```python
+import modelstudio as ms
+
+print(ms.backends.status())
+print(ms.backends.native_cpu_available())
+```
+
+Expected shape:
+
+```python
+{
+    "cpu": {"available": True, "native": False},
+    "cuda": {"available": False, "reason": "..."},
+    "rocm": {"available": False, "reason": "..."},
+    "oneapi": {"available": False, "reason": "..."},
+}
+```
+
+The production CPU path is the NumPy backend. `ms.backends.use_native_cpu(True)`
+raises `ModelStudioBackendUnavailable` unless a future optional native extension
+is actually installed. Unsupported accelerator devices fail with
+`ModelStudioBackendUnavailable`.
+
+## Tensor Example
+
+```python
+import modelstudio as ms
+
+x = ms.randn((32, 784), requires_grad=True)
+w = ms.randn((784, 10), requires_grad=True)
+loss = (x @ w).mean()
+loss.backward()
+print(w.grad)
+```
+
+## Functional API
+
+```python
+import modelstudio as ms
+from modelstudio import nn
+from modelstudio.nn import functional as F
+
+model = nn.Linear(4, 2)
+x = ms.random.randn((8, 4))
+target = ms.random.randn((8, 2))
+loss = F.mse_loss(F.relu(F.linear(x, model.weight, model.bias)), target)
+```
+
+## Tracing
+
+```python
+import modelstudio as ms
+from modelstudio.nn import functional as F
+
+x = ms.random.randn((4, 3))
+w = ms.random.randn((3, 2))
+graph = ms.trace(lambda a, b: F.relu(a @ b), x, w)
+print(graph)
+```
+
+Tracing captures operation names and tensor metadata. It does not optimize or
+execute graphs yet. `ms.compile(fn)` remains a documented no-op that returns the
+original callable.
+
+## Random And Linalg
+
+```python
+ms.random.seed(123)
+x = ms.random.normal((4, 3), mean=0.0, std=1.0)
+w = ms.random.uniform((3, 2), low=-0.1, high=0.1)
+y = ms.linalg.matmul(x, w)
+print(ms.linalg.norm(y).item())
+```
+
+## Comparisons
+
+```python
+x = ms.tensor([1.0, 2.0, 3.0])
+y = ms.tensor([1.0, 2.1, 3.0])
+print(ms.isclose(x, y, atol=0.05))
+print(ms.allclose(x, y, atol=0.05))
+print((x > 1.5).any().item())
+```
+
+Comparison and logical outputs are bool tensors and do not track gradients.
+
+## Checkpointing
+
+```python
+model = nn.Linear(4, 2)
+optimizer = ms.optim.AdamW(model.parameters(), lr=1e-3)
+ms.save_checkpoint("checkpoint.ms", model=model, optimizer=optimizer, extra={"epoch": 1})
+checkpoint = ms.load_checkpoint("checkpoint.ms", model=model, optimizer=optimizer, map_location="cpu")
+```
+
+Checkpoint loading validates structure and model state. CPU is the only accepted
+`map_location` in the current release.
+
+## Commands
+
+```bash
+python -m pytest
+python scripts/smoke_test.py
+python examples/train_mlp.py
+python examples/train_classifier.py
+python examples/tiny_transformer.py
+python examples/save_load.py
+python examples/train_cnn_toy.py
+python examples/dropout_batchnorm.py
+python examples/checkpoint_training.py
+python examples/numpy_interop.py
+python examples/scheduler_training.py
+python examples/checkpoint_resume.py
+python examples/metrics_demo.py
+python examples/backend_status.py
+python examples/tracing_demo.py
+python examples/functional_training.py
+python examples/random_linalg_demo.py
+python benchmarks/bench_matmul.py
+python benchmarks/bench_mlp.py
+python benchmarks/bench_attention.py
+python benchmarks/bench_dataloader.py
+python benchmarks/bench_conv.py
+python benchmarks/bench_dropout.py
+python benchmarks/bench_creation.py
+python benchmarks/bench_manipulation.py
+python benchmarks/bench_elementwise.py
+python benchmarks/bench_trace.py
+```
+
+## Documentation
+
+- [Backend status](docs/backend-status.md)
+- [Tracing](docs/tracing.md)
+- [Functional API](docs/functional-api.md)
+- [Random namespace](docs/random.md)
+- [Linalg namespace](docs/linalg.md)
+- [Comparison ops](docs/comparison-ops.md)
+- [Tensor API](docs/tensor-api.md)
+- [Neural network API](docs/nn.md)
+- [Data utilities](docs/data.md)
+- [Training](docs/training.md)
+- [Modules](docs/modules.md)
+- [Serialization](docs/serialization.md)
+- [Native backend roadmap](docs/native-backend-roadmap.md)
+- [NumPy interop](docs/numpy-interop.md)
+- [Tensor creation](docs/tensor-creation.md)
+- [Tensor manipulation](docs/tensor-manipulation.md)
+- [Optimizers](docs/optimizers.md)
+- [Checkpointing](docs/checkpointing.md)
+- [Metrics](docs/metrics.md)
+- [Backend architecture](docs/backend-architecture.md)
+- [Autograd design](docs/autograd.md)
+- [Releasing](docs/releasing.md)
+- [Contributing](CONTRIBUTING.md)
+
+## Roadmap
+
+- Expand tensor and autograd coverage.
+- Wire optional native CPU kernels only after a safe Python extension exists.
+- Add tested CUDA, ROCm, and oneAPI packages when hardware-backed CI exists.
+- Improve compiler graph capture, analysis passes, and lowering.

modelstudio-0.5.0/benchmarks/bench_creation.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+import numpy as np
+
+
+def timeit(fn, iterations: int, warmup: int) -> float:
+    for _ in range(warmup):
+        fn()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    return (time.perf_counter() - start) / iterations
+
+
+def main() -> None:
+    warmup = 5
+    iterations = 50
+    shape = (512, 512)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Operation:   rand/full/eye shape={shape}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU only")
+    print(f"rand avg:    {timeit(lambda: ms.rand(shape), iterations, warmup) * 1_000:.3f} ms")
+    print(f"full avg:    {timeit(lambda: ms.full(shape, 1.25), iterations, warmup) * 1_000:.3f} ms")
+    print(f"eye avg:     {timeit(lambda: ms.eye(512), iterations, warmup) * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()
+

modelstudio-0.5.0/benchmarks/bench_elementwise.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+
+
+def _time_ms(fn, warmup: int, iterations: int) -> float:
+    for _ in range(warmup):
+        fn()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    return (time.perf_counter() - start) * 1000.0 / iterations
+
+
+def main() -> None:
+    shape = (1024, 1024)
+    warmup = 5
+    iterations = 50
+    ms.random.seed(123)
+    x = ms.random.randn(shape)
+    y = ms.random.randn(shape)
+
+    add_ms = _time_ms(lambda: x + y, warmup, iterations)
+    relu_ms = _time_ms(lambda: ms.relu(x), warmup, iterations)
+    cmp_ms = _time_ms(lambda: x > y, warmup, iterations)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {ms.numpy.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Shape:       {shape}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print(f"Backend:     {ms.backends.status()}")
+    print(f"add avg:     {add_ms:.3f} ms")
+    print(f"relu avg:    {relu_ms:.3f} ms")
+    print(f"compare avg: {cmp_ms:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()
+

modelstudio-0.5.0/benchmarks/bench_manipulation.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+import numpy as np
+
+
+def timeit(fn, iterations: int, warmup: int) -> float:
+    for _ in range(warmup):
+        fn()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    return (time.perf_counter() - start) / iterations
+
+
+def main() -> None:
+    warmup = 5
+    iterations = 50
+    x = ms.randn((64, 64, 8))
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print("Operation:   permute/repeat/tile")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU only")
+    print(f"permute avg: {timeit(lambda: ms.permute(x, (2, 0, 1)), iterations, warmup) * 1_000:.3f} ms")
+    print(f"repeat avg:  {timeit(lambda: ms.repeat(x, 2, axis=0), iterations, warmup) * 1_000:.3f} ms")
+    print(f"tile avg:    {timeit(lambda: ms.tile(x, (2, 1, 1)), iterations, warmup) * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()
+

modelstudio-0.5.0/benchmarks/bench_trace.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+from modelstudio.nn import functional as F
+
+
+def _time_ms(fn, warmup: int, iterations: int) -> float:
+    for _ in range(warmup):
+        fn()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    return (time.perf_counter() - start) * 1000.0 / iterations
+
+
+def main() -> None:
+    shape = (64, 128)
+    weight_shape = (128, 32)
+    warmup = 5
+    iterations = 100
+    x = ms.random.randn(shape)
+    w = ms.random.randn(weight_shape)
+
+    def forward(a: ms.Tensor, b: ms.Tensor) -> ms.Tensor:
+        return F.relu(a @ b)
+
+    trace_ms = _time_ms(lambda: ms.trace(forward, x, w), warmup, iterations)
+    graph = ms.trace(forward, x, w)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {ms.numpy.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Input:       {shape}")
+    print(f"Weight:      {weight_shape}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print(f"Backend:     {ms.backends.status()}")
+    print(f"Trace avg:   {trace_ms:.3f} ms")
+    print(f"Nodes:       {[node.op for node in graph.nodes]}")
+
+
+if __name__ == "__main__":
+    main()
+

modelstudio-0.5.0/docs/backend-status.md

@@ -0,0 +1,21 @@
+# Backend Status
+
+ModelStudio 0.5.0 keeps CPU as the only available runtime backend.
+
+```python
+import modelstudio as ms
+
+status = ms.backends.status()
+print(status["cpu"])
+```
+
+`ms.backends.status()` returns a mapping for `cpu`, `cuda`, `rocm`, and
+`oneapi`. CPU is always available through the NumPy backend. Accelerator
+backends remain explicit unavailable scaffolds and include a human-readable
+reason.
+
+`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
+CPU backend remains the production path.
+

modelstudio-0.5.0/docs/checkpointing.md

@@ -0,0 +1,30 @@
+# Checkpointing
+
+High-level checkpoint helpers wrap `ms.save` and `ms.load`.
+
+```python
+ms.save_checkpoint(
+    "checkpoint.ms",
+    model=model,
+    optimizer=optimizer,
+    scheduler=scheduler,
+    extra={"epoch": 3},
+)
+
+checkpoint = ms.load_checkpoint(
+    "checkpoint.ms",
+    model=model,
+    optimizer=optimizer,
+    scheduler=scheduler,
+)
+```
+
+The checkpoint dictionary contains:
+
+- `model`
+- optional `optimizer`
+- optional `scheduler`
+- `extra`
+
+The file format is currently ModelStudio's internal pickle-backed format.
+

modelstudio-0.5.0/docs/comparison-ops.md

@@ -0,0 +1,23 @@
+# Comparison Ops
+
+ModelStudio 0.5.0 adds elementwise tensor comparisons:
+
+```python
+x = ms.tensor([1.0, 2.0, 3.0])
+y = ms.tensor([1.0, 2.1, 3.0])
+
+print(x == y)
+print(x > 1.5)
+print(ms.isclose(x, y, atol=0.05))
+```
+
+Available helpers:
+
+- `ms.equal(x, y)` for exact shape and value equality
+- `ms.allclose(x, y, rtol=1e-5, atol=1e-8)`
+- `ms.isclose(x, y, rtol=1e-5, atol=1e-8)`
+- `x.all(axis=None, keepdims=False)` and `x.any(...)`
+- `ms.all(x, axis=None, keepdims=False)` and `ms.any(...)`
+
+Comparison and logical outputs are bool tensors and do not track gradients.
+