modelstudio 0.1.1__tar.gz → 0.3.0__tar.gz

{modelstudio-0.1.1 → modelstudio-0.3.0}/MANIFEST.in

@@ -1,6 +1,8 @@
 include CMakeLists.txt
 include python/modelstudio/py.typed
 recursive-include csrc *
+recursive-include docs *.md
 recursive-include examples *.py
 recursive-include benchmarks *.py
+recursive-include scripts *.py
 recursive-include tests *.py

modelstudio-0.3.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: modelstudio
+Version: 0.3.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.3.0` provides a
+CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
+basic data loading, 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` with axis and keepdims; `max` is value-only |
+| Activations | ReLU, GELU, exp, log, tanh, sigmoid, SiLU, softmax, log-softmax |
+| Losses | MSE and cross entropy with `none`, `mean`, and `sum` reductions |
+| 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 |
+| Data | Dataset, TensorDataset, DataLoader with deterministic seeded shuffle |
+| Randomness | `manual_seed`, RNG-backed `randn`, dropout, and init helpers |
+| Compiler | Placeholder IR and passes |
+
+## Backend Status
+
+| Backend | Status |
+| --- | --- |
+| CPU | working MVP |
+| CUDA | scaffold only |
+| ROCm | scaffold only |
+| oneAPI | scaffold only |
+
+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)
+```
+
+## MLP Example
+
+```python
+import modelstudio as ms
+from modelstudio import nn
+
+
+class MLP(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(784, 256)
+        self.fc2 = nn.Linear(256, 10)
+
+    def forward(self, x):
+        return self.fc2(ms.gelu(self.fc1(x)))
+
+
+model = MLP()
+optimizer = ms.optim.AdamW(model.parameters(), lr=3e-4)
+x = ms.randn((16, 784))
+target = ms.randn((16, 10))
+loss = ms.mse_loss(model(x), target)
+optimizer.zero_grad()
+loss.backward()
+optimizer.step()
+```
+
+## State Dict and Save/Load
+
+```python
+model = nn.Linear(4, 2)
+ms.save(model.state_dict(), "model.ms")
+state = ms.load("model.ms")
+model.load_state_dict(state)
+```
+
+## DataLoader
+
+```python
+from modelstudio import data
+
+dataset = data.TensorDataset(ms.randn((8, 4)), ms.arange(8))
+loader = data.DataLoader(dataset, batch_size=2, shuffle=False)
+for xb, yb in loader:
+    print(xb.shape, yb.shape)
+```
+
+## Embedding
+
+```python
+emb = nn.Embedding(num_embeddings=100, embedding_dim=32)
+tokens = ms.tensor([[1, 2, 3]], dtype=ms.int64)
+print(emb(tokens).shape)
+```
+
+## Cross Entropy
+
+```python
+logits = ms.randn((4, 10), requires_grad=True)
+targets = ms.tensor([1, 2, 3, 4], dtype=ms.int64)
+loss = ms.cross_entropy(logits, targets)
+loss.backward()
+```
+
+## TransformerBlock
+
+```python
+block = nn.TransformerBlock(embed_dim=16, num_heads=4)
+x = ms.randn((2, 8, 16), requires_grad=True)
+y = block(x)
+print(y.shape)
+```
+
+## 0.3.0 Training Utilities
+
+```python
+ms.manual_seed(123)
+model = nn.Linear(4, 2)
+optimizer = ms.optim.AdamW(model.parameters(), lr=1e-3)
+state = {"model": model.state_dict(), "optimizer": optimizer.state_dict()}
+ms.save(state, "checkpoint.ms")
+```
+
+New CPU-only helpers include `ms.concat`, `ms.stack`, `Tensor.flatten`,
+`Tensor.squeeze`, `Tensor.unsqueeze`, `nn.init`, `nn.Dropout`,
+`nn.BatchNorm1d`, `nn.Conv1d`, `nn.Conv2d`, `nn.AvgPool2d`, `nn.MaxPool2d`,
+and `nn.utils` gradient clipping.
+
+## 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 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
+```
+
+## Documentation
+
+- [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)
+- [Randomness](docs/randomness.md)
+- [Native backend roadmap](docs/native-backend-roadmap.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 native CPU kernels into Python bindings.
+- Add tested CUDA, ROCm, and oneAPI packages when hardware-backed CI exists.
+- Improve compiler graph capture and lowering.

modelstudio-0.3.0/README.md

@@ -0,0 +1,192 @@
+# ModelStudio
+
+ModelStudio is an early-stage AI tensor framework. Version `0.3.0` provides a
+CPU tensor/autograd MVP with neural-network modules, optimizers, serialization,
+basic data loading, 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` with axis and keepdims; `max` is value-only |
+| Activations | ReLU, GELU, exp, log, tanh, sigmoid, SiLU, softmax, log-softmax |
+| Losses | MSE and cross entropy with `none`, `mean`, and `sum` reductions |
+| 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 |
+| Data | Dataset, TensorDataset, DataLoader with deterministic seeded shuffle |
+| Randomness | `manual_seed`, RNG-backed `randn`, dropout, and init helpers |
+| Compiler | Placeholder IR and passes |
+
+## Backend Status
+
+| Backend | Status |
+| --- | --- |
+| CPU | working MVP |
+| CUDA | scaffold only |
+| ROCm | scaffold only |
+| oneAPI | scaffold only |
+
+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)
+```
+
+## MLP Example
+
+```python
+import modelstudio as ms
+from modelstudio import nn
+
+
+class MLP(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.fc1 = nn.Linear(784, 256)
+        self.fc2 = nn.Linear(256, 10)
+
+    def forward(self, x):
+        return self.fc2(ms.gelu(self.fc1(x)))
+
+
+model = MLP()
+optimizer = ms.optim.AdamW(model.parameters(), lr=3e-4)
+x = ms.randn((16, 784))
+target = ms.randn((16, 10))
+loss = ms.mse_loss(model(x), target)
+optimizer.zero_grad()
+loss.backward()
+optimizer.step()
+```
+
+## State Dict and Save/Load
+
+```python
+model = nn.Linear(4, 2)
+ms.save(model.state_dict(), "model.ms")
+state = ms.load("model.ms")
+model.load_state_dict(state)
+```
+
+## DataLoader
+
+```python
+from modelstudio import data
+
+dataset = data.TensorDataset(ms.randn((8, 4)), ms.arange(8))
+loader = data.DataLoader(dataset, batch_size=2, shuffle=False)
+for xb, yb in loader:
+    print(xb.shape, yb.shape)
+```
+
+## Embedding
+
+```python
+emb = nn.Embedding(num_embeddings=100, embedding_dim=32)
+tokens = ms.tensor([[1, 2, 3]], dtype=ms.int64)
+print(emb(tokens).shape)
+```
+
+## Cross Entropy
+
+```python
+logits = ms.randn((4, 10), requires_grad=True)
+targets = ms.tensor([1, 2, 3, 4], dtype=ms.int64)
+loss = ms.cross_entropy(logits, targets)
+loss.backward()
+```
+
+## TransformerBlock
+
+```python
+block = nn.TransformerBlock(embed_dim=16, num_heads=4)
+x = ms.randn((2, 8, 16), requires_grad=True)
+y = block(x)
+print(y.shape)
+```
+
+## 0.3.0 Training Utilities
+
+```python
+ms.manual_seed(123)
+model = nn.Linear(4, 2)
+optimizer = ms.optim.AdamW(model.parameters(), lr=1e-3)
+state = {"model": model.state_dict(), "optimizer": optimizer.state_dict()}
+ms.save(state, "checkpoint.ms")
+```
+
+New CPU-only helpers include `ms.concat`, `ms.stack`, `Tensor.flatten`,
+`Tensor.squeeze`, `Tensor.unsqueeze`, `nn.init`, `nn.Dropout`,
+`nn.BatchNorm1d`, `nn.Conv1d`, `nn.Conv2d`, `nn.AvgPool2d`, `nn.MaxPool2d`,
+and `nn.utils` gradient clipping.
+
+## 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 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
+```
+
+## Documentation
+
+- [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)
+- [Randomness](docs/randomness.md)
+- [Native backend roadmap](docs/native-backend-roadmap.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 native CPU kernels into Python bindings.
+- Add tested CUDA, ROCm, and oneAPI packages when hardware-backed CI exists.
+- Improve compiler graph capture and lowering.

modelstudio-0.3.0/benchmarks/bench_attention.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+import numpy as np
+
+
+def timeit(fn, iterations: int = 20, warmup: int = 5) -> float:
+    for _ in range(warmup):
+        fn()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        fn()
+    return (time.perf_counter() - start) / iterations
+
+
+def main() -> None:
+    shape = (2, 4, 16, 8)
+    iterations = 20
+    warmup = 5
+    q = ms.randn(shape)
+    k = ms.randn(shape)
+    v = ms.randn(shape)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Shape:       {shape}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU MVP")
+    elapsed = timeit(lambda: ms.scaled_dot_product_attention(q, k, v, causal=True), iterations, warmup)
+    print(f"Attention avg: {elapsed * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()

modelstudio-0.3.0/benchmarks/bench_conv.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+import numpy as np
+from modelstudio import nn
+
+
+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 = 3
+    iterations = 10
+    shape = (8, 3, 16, 16)
+    ms.manual_seed(1)
+    x = ms.randn(shape)
+    conv = nn.Conv2d(3, 8, kernel_size=3, padding=1)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Operation:   Conv2d input={shape} out_channels=8 kernel=3 padding=1")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU only")
+    print(f"Conv2d avg:  {timeit(lambda: conv(x), iterations, warmup) * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()
+

modelstudio-0.3.0/benchmarks/bench_dataloader.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import platform
+import time
+
+import modelstudio as ms
+import numpy as np
+from modelstudio import data
+
+
+def main() -> None:
+    samples = 1024
+    features = 32
+    batch_size = 64
+    iterations = 20
+    warmup = 5
+    dataset = data.TensorDataset(ms.randn((samples, features)), ms.arange(samples))
+    loader = data.DataLoader(dataset, batch_size=batch_size, shuffle=False)
+
+    def consume() -> int:
+        count = 0
+        for xb, _ in loader:
+            count += xb.shape[0]
+        return count
+
+    for _ in range(warmup):
+        consume()
+    start = time.perf_counter()
+    for _ in range(iterations):
+        consume()
+    elapsed = (time.perf_counter() - start) / iterations
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Samples:     {samples}")
+    print(f"Features:    {features}")
+    print(f"Batch size:  {batch_size}")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU MVP")
+    print(f"DataLoader avg: {elapsed * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()

modelstudio-0.3.0/benchmarks/bench_dropout.py

@@ -0,0 +1,37 @@
+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)
+    x = ms.randn(shape)
+
+    print(f"Python:      {platform.python_version()}")
+    print(f"NumPy:       {np.__version__}")
+    print(f"ModelStudio: {ms.__version__}")
+    print(f"Operation:   dropout shape={shape} p=0.5")
+    print(f"Warmup:      {warmup}")
+    print(f"Iterations:  {iterations}")
+    print("Backend:     CPU only")
+    print(f"Dropout avg: {timeit(lambda: ms.dropout(x, p=0.5), iterations, warmup) * 1_000:.3f} ms")
+
+
+if __name__ == "__main__":
+    main()
+

{modelstudio-0.1.1 → modelstudio-0.3.0}/csrc/CMakeLists.txt

@@ -2,6 +2,8 @@ add_library(modelstudio_native STATIC
   backends/cpu/cpu_backend.cpp
   backends/cpu/kernels/add.cpp
   backends/cpu/kernels/matmul.cpp
+  backends/cpu/kernels/mul.cpp
+  backends/cpu/kernels/relu.cpp
 )
 
 target_include_directories(modelstudio_native PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

{modelstudio-0.1.1 → modelstudio-0.3.0}/csrc/backends/cpu/cpu_backend.cpp

@@ -10,8 +10,16 @@ Tensor CPUBackend::add(const Tensor& lhs, const Tensor& rhs) {
   return add_kernel(lhs, rhs);
 }
 
+Tensor CPUBackend::mul(const Tensor& lhs, const Tensor& rhs) {
+  return mul_kernel(lhs, rhs);
+}
+
 Tensor CPUBackend::matmul(const Tensor& lhs, const Tensor& rhs) {
   return matmul_kernel(lhs, rhs);
 }
 
+Tensor CPUBackend::relu(const Tensor& input) {
+  return relu_kernel(input);
+}
+
 }  // namespace modelstudio::cpu

{modelstudio-0.1.1 → modelstudio-0.3.0}/csrc/backends/cpu/cpu_backend.hpp

@@ -5,14 +5,18 @@
 namespace modelstudio::cpu {
 
 Tensor add_kernel(const Tensor& lhs, const Tensor& rhs);
+Tensor mul_kernel(const Tensor& lhs, const Tensor& rhs);
 Tensor matmul_kernel(const Tensor& lhs, const Tensor& rhs);
+Tensor relu_kernel(const Tensor& input);
 
 class CPUBackend final : public Backend {
  public:
   std::string_view name() const override { return "cpu"; }
   Tensor empty(const Shape& shape, DType dtype) override;
   Tensor add(const Tensor& lhs, const Tensor& rhs) override;
+  Tensor mul(const Tensor& lhs, const Tensor& rhs) override;
   Tensor matmul(const Tensor& lhs, const Tensor& rhs) override;
+  Tensor relu(const Tensor& input) override;
 };
 
 }  // namespace modelstudio::cpu

modelstudio-0.3.0/csrc/backends/cpu/kernels/mul.cpp

@@ -0,0 +1,43 @@
+#include "backends/cpu/cpu_backend.hpp"
+
+namespace modelstudio::cpu {
+namespace {
+
+template <typename T>
+void mul_typed(const Tensor& lhs, const Tensor& rhs, Tensor& out) {
+  const auto* lhs_ptr = static_cast<const T*>(lhs.data());
+  const auto* rhs_ptr = static_cast<const T*>(rhs.data());
+  auto* out_ptr = static_cast<T*>(out.data());
+  for (std::int64_t i = 0; i < lhs.numel(); ++i) {
+    out_ptr[i] = lhs_ptr[i] * rhs_ptr[i];
+  }
+}
+
+}  // namespace
+
+Tensor mul_kernel(const Tensor& lhs, const Tensor& rhs) {
+  if (lhs.shape() != rhs.shape() || lhs.dtype() != rhs.dtype()) {
+    throw Error("native CPU mul currently requires identical shape and dtype");
+  }
+  Tensor out(lhs.shape(), lhs.dtype(), lhs.device());
+  switch (lhs.dtype()) {
+    case DType::Float32:
+      mul_typed<float>(lhs, rhs, out);
+      break;
+    case DType::Float64:
+      mul_typed<double>(lhs, rhs, out);
+      break;
+    case DType::Int32:
+      mul_typed<std::int32_t>(lhs, rhs, out);
+      break;
+    case DType::Int64:
+      mul_typed<std::int64_t>(lhs, rhs, out);
+      break;
+    case DType::Bool:
+      mul_typed<bool>(lhs, rhs, out);
+      break;
+  }
+  return out;
+}
+
+}  // namespace modelstudio::cpu