modelstudio 0.2.0__tar.gz → 0.3.0__tar.gz

{modelstudio-0.2.0/python/modelstudio.egg-info → modelstudio-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modelstudio
-Version: 0.2.0
+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
@@ -31,7 +31,7 @@ Dynamic: license-file
 
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.2.0` provides a
+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.
 
@@ -61,10 +61,12 @@ python -m pip install -e ".[dev]"
 | 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 |
-| Modules | Parameters, buffers, state dicts, save/load |
-| Layers | Linear, Embedding, LayerNorm, RMSNorm, TransformerBlock |
-| Data | Dataset, TensorDataset, DataLoader |
+| 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
@@ -163,6 +165,21 @@ 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
@@ -172,10 +189,15 @@ 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
@@ -183,6 +205,11 @@ python benchmarks/bench_dataloader.py
 - [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)

{modelstudio-0.2.0 → modelstudio-0.3.0}/README.md

@@ -1,6 +1,6 @@
 # ModelStudio
 
-ModelStudio is an early-stage AI tensor framework. Version `0.2.0` provides a
+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.
 
@@ -30,10 +30,12 @@ python -m pip install -e ".[dev]"
 | 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 |
-| Modules | Parameters, buffers, state dicts, save/load |
-| Layers | Linear, Embedding, LayerNorm, RMSNorm, TransformerBlock |
-| Data | Dataset, TensorDataset, DataLoader |
+| 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
@@ -132,6 +134,21 @@ 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
@@ -141,10 +158,15 @@ 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
@@ -152,6 +174,11 @@ python benchmarks/bench_dataloader.py
 - [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)

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_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.2.0 → 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.2.0 → 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.2.0 → 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

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

@@ -0,0 +1,40 @@
+#include "backends/cpu/cpu_backend.hpp"
+
+#include <algorithm>
+
+namespace modelstudio::cpu {
+namespace {
+
+template <typename T>
+void relu_typed(const Tensor& input, Tensor& out) {
+  const auto* input_ptr = static_cast<const T*>(input.data());
+  auto* out_ptr = static_cast<T*>(out.data());
+  for (std::int64_t i = 0; i < input.numel(); ++i) {
+    out_ptr[i] = std::max<T>(input_ptr[i], T{});
+  }
+}
+
+}  // namespace
+
+Tensor relu_kernel(const Tensor& input) {
+  Tensor out(input.shape(), input.dtype(), input.device());
+  switch (input.dtype()) {
+    case DType::Float32:
+      relu_typed<float>(input, out);
+      break;
+    case DType::Float64:
+      relu_typed<double>(input, out);
+      break;
+    case DType::Int32:
+      relu_typed<std::int32_t>(input, out);
+      break;
+    case DType::Int64:
+      relu_typed<std::int64_t>(input, out);
+      break;
+    case DType::Bool:
+      throw Error("native CPU bool relu is not implemented");
+  }
+  return out;
+}
+
+}  // namespace modelstudio::cpu

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/cuda/cuda_backend.cu

@@ -14,9 +14,19 @@ Tensor CUDABackend::add(const Tensor&, const Tensor&) {
   throw Error("CUDA add kernel is not implemented");
 }
 
+Tensor CUDABackend::mul(const Tensor&, const Tensor&) {
+  // TODO: Add a tested CUDA elementwise multiply kernel.
+  throw Error("CUDA mul kernel is not implemented");
+}
+
 Tensor CUDABackend::matmul(const Tensor&, const Tensor&) {
   // TODO: Add a tested CUDA matmul kernel or cuBLAS integration.
   throw Error("CUDA matmul kernel is not implemented");
 }
 
+Tensor CUDABackend::relu(const Tensor&) {
+  // TODO: Add a tested CUDA ReLU kernel.
+  throw Error("CUDA relu kernel is not implemented");
+}
+
 }  // namespace modelstudio::cuda

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/cuda/cuda_backend.hpp

@@ -9,7 +9,9 @@ class CUDABackend final : public Backend {
   std::string_view name() const override { return "cuda"; }
   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::cuda

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/oneapi/oneapi_backend.cpp

@@ -14,9 +14,19 @@ Tensor OneAPIBackend::add(const Tensor&, const Tensor&) {
   throw Error("oneAPI add kernel is not implemented");
 }
 
+Tensor OneAPIBackend::mul(const Tensor&, const Tensor&) {
+  // TODO: Add a tested SYCL elementwise multiply kernel.
+  throw Error("oneAPI mul kernel is not implemented");
+}
+
 Tensor OneAPIBackend::matmul(const Tensor&, const Tensor&) {
   // TODO: Add a tested SYCL matmul kernel or oneMKL integration.
   throw Error("oneAPI matmul kernel is not implemented");
 }
 
+Tensor OneAPIBackend::relu(const Tensor&) {
+  // TODO: Add a tested SYCL ReLU kernel.
+  throw Error("oneAPI relu kernel is not implemented");
+}
+
 }  // namespace modelstudio::oneapi

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/oneapi/oneapi_backend.hpp

@@ -9,7 +9,9 @@ class OneAPIBackend final : public Backend {
   std::string_view name() const override { return "oneapi"; }
   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::oneapi

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/rocm/rocm_backend.cpp

@@ -14,9 +14,19 @@ Tensor ROCmBackend::add(const Tensor&, const Tensor&) {
   throw Error("ROCm add kernel is not implemented");
 }
 
+Tensor ROCmBackend::mul(const Tensor&, const Tensor&) {
+  // TODO: Add a tested HIP elementwise multiply kernel.
+  throw Error("ROCm mul kernel is not implemented");
+}
+
 Tensor ROCmBackend::matmul(const Tensor&, const Tensor&) {
   // TODO: Add a tested HIP matmul kernel or rocBLAS integration.
   throw Error("ROCm matmul kernel is not implemented");
 }
 
+Tensor ROCmBackend::relu(const Tensor&) {
+  // TODO: Add a tested HIP ReLU kernel.
+  throw Error("ROCm relu kernel is not implemented");
+}
+
 }  // namespace modelstudio::rocm

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/backends/rocm/rocm_backend.hpp

@@ -9,7 +9,9 @@ class ROCmBackend final : public Backend {
   std::string_view name() const override { return "rocm"; }
   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::rocm

{modelstudio-0.2.0 → modelstudio-0.3.0}/csrc/dispatcher/backend.hpp

@@ -12,7 +12,9 @@ class Backend {
   virtual std::string_view name() const = 0;
   virtual Tensor empty(const Shape& shape, DType dtype) = 0;
   virtual Tensor add(const Tensor& lhs, const Tensor& rhs) = 0;
+  virtual Tensor mul(const Tensor& lhs, const Tensor& rhs) = 0;
   virtual Tensor matmul(const Tensor& lhs, const Tensor& rhs) = 0;
+  virtual Tensor relu(const Tensor& input) = 0;
 };
 
 }  // namespace modelstudio

{modelstudio-0.2.0 → modelstudio-0.3.0}/docs/data.md

@@ -20,7 +20,7 @@ All tensors must have the same first dimension. Items are returned as tuples.
 ## DataLoader
 
 ```python
-loader = data.DataLoader(dataset, batch_size=32, shuffle=True, drop_last=False)
+loader = data.DataLoader(dataset, batch_size=32, shuffle=True, drop_last=False, seed=123)
 ```
 
 The current `DataLoader` is intentionally simple:
@@ -28,5 +28,6 @@ The current `DataLoader` is intentionally simple:
 - CPU only
 - no multiprocessing
 - no workers
-- supports tensors and tuples of tensors
+- deterministic shuffle when `seed` is provided
+- supports tensors, tuples/lists, and simple Python numeric values
 - batches along axis 0

modelstudio-0.3.0/docs/modules.md

@@ -0,0 +1,24 @@
+# Modules
+
+`nn.Module` is the base class for layers and models.
+
+Important APIs:
+
+- `parameters()` and `named_parameters()`
+- `register_buffer(name, tensor)`
+- `named_buffers()`
+- `children()`, `modules()`, and `named_modules()`
+- `train(mode=True)` and `eval()`
+- `state_dict()` and `load_state_dict(state)`
+
+Assigning a `Parameter` registers it as trainable. Assigning another `Module`
+registers it as a child module. Assigning a plain `Tensor` does not make it a
+parameter; persistent non-trainable tensors should use `register_buffer`.
+
+Deleting a parameter, child module, or buffer attribute removes it from the
+corresponding registry.
+
+Available CPU layers include Linear, Embedding, LayerNorm, RMSNorm,
+BatchNorm1d, Dropout, Conv1d, Conv2d, AvgPool2d, MaxPool2d, and
+TransformerBlock.
+

modelstudio-0.3.0/docs/native-backend-roadmap.md

@@ -0,0 +1,26 @@
+# Native Backend Roadmap
+
+The Python runtime still uses NumPy CPU kernels in 0.3.0. The native C++ tree is
+scaffolding for future backend work and is intentionally not wired into Python
+dispatch yet.
+
+Current native CPU preparation includes interfaces for:
+
+- `add`
+- `mul`
+- `matmul`
+- `relu`
+
+The intended path is:
+
+1. Expand native tensor storage and shape/stride metadata.
+2. Add tested C++ CPU kernels with broadcasting and dtype coverage.
+3. Bind native CPU kernels through the Python extension.
+4. Switch the Python CPU backend behind the dispatcher without changing public
+   tensor APIs.
+5. Add real CUDA, ROCm, and oneAPI packages only when kernels compile and run
+   under hardware-backed CI.
+
+CUDA, ROCm, and oneAPI remain unavailable placeholders. Requesting those device
+types raises `ModelStudioBackendUnavailable`.
+

{modelstudio-0.2.0 → modelstudio-0.3.0}/docs/nn.md

@@ -17,6 +17,9 @@ model = nn.Linear(4, 2)
 - `named_parameters()`
 - `register_buffer()`
 - `named_buffers()`
+- `children()`
+- `modules()`
+- `named_modules()`
 - `state_dict()`
 - `load_state_dict()`
 - `train()` / `eval()`
@@ -33,14 +36,28 @@ Current CPU layers include:
 - `Embedding`
 - `LayerNorm`
 - `RMSNorm`
+- `BatchNorm1d`
+- `Dropout`
+- `Conv1d`
+- `Conv2d`
+- `AvgPool2d`
+- `MaxPool2d`
 - `TransformerBlock`
 - `ReLU`
 - `GELU`
 - `MSELoss`
 - `CrossEntropyLoss`
 
-`TransformerBlock` is intentionally minimal and CPU-only. Nonzero dropout raises
-a clear error because dropout is not implemented yet.
+`TransformerBlock` is intentionally minimal and CPU-only. Dropout is supported
+through `nn.Dropout` and respects `train()` / `eval()` mode.
+
+## Initialization and Gradient Clipping
+
+`nn.init` provides in-place seeded initialization helpers such as
+`xavier_uniform_` and `kaiming_uniform_`.
+
+`nn.utils.clip_grad_norm_` and `nn.utils.clip_grad_value_` mutate gradients
+in-place and ignore parameters whose gradients are absent.
 
 ## Save and Load
 

modelstudio-0.3.0/docs/randomness.md

@@ -0,0 +1,23 @@
+# Randomness
+
+ModelStudio uses a process-local NumPy `Generator` for framework randomness.
+
+```python
+import modelstudio as ms
+
+ms.manual_seed(123)
+x = ms.randn((2, 3))
+y = ms.dropout(ms.ones((2, 3)), p=0.5)
+```
+
+`manual_seed(seed)` resets the ModelStudio RNG and returns the normalized seed.
+It controls:
+
+- `ms.randn`
+- dropout masks
+- seeded initialization helpers in `nn.init`
+- DataLoader shuffling when no explicit DataLoader seed is provided
+
+`DataLoader(..., seed=123)` uses its own deterministic shuffle sequence for
+each iteration over that loader.
+

modelstudio-0.3.0/docs/serialization.md

@@ -0,0 +1,25 @@
+# Serialization
+
+`ms.save(obj, path)` and `ms.load(path)` serialize nested Python containers that
+contain ModelStudio tensors. This is suitable for model and optimizer
+checkpoints in the CPU MVP.
+
+```python
+checkpoint = {
+    "model": model.state_dict(),
+    "optimizer": optimizer.state_dict(),
+}
+ms.save(checkpoint, "checkpoint.ms")
+
+loaded = ms.load("checkpoint.ms")
+model.load_state_dict(loaded["model"])
+optimizer.load_state_dict(loaded["optimizer"])
+```
+
+Optimizer state dictionaries include hyperparameters and parameter-count
+metadata. AdamW also stores step counts and first/second moment buffers.
+Loading validates parameter count and moment shapes.
+
+The format is currently a Python pickle-based internal format, not a stable
+cross-language exchange format.
+

{modelstudio-0.2.0 → modelstudio-0.3.0}/docs/tensor-api.md

@@ -30,11 +30,14 @@ ms.arange(10)
 ## Operations
 
 ModelStudio supports CPU arithmetic, matrix multiplication, reductions, reshape,
-transpose, indexing, and common neural-network activations.
+transpose, indexing, concat/stack, flatten/squeeze/unsqueeze, and common
+neural-network activations.
 
 ```python
 y = x.sum(axis=-1, keepdims=True)
 z = x.softmax(axis=-1)
+flat = x.flatten(start_dim=1)
+joined = ms.concat([flat, flat], axis=-1)
 ```
 
 Autograd is implemented for the core CPU ops used by the neural-network API.