tensorstudio 0.1.1__cp313-cp313-win_amd64.whl

tensorstudio/_C.pyi

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+class Tensor:
+    requires_grad: bool
+    grad: Tensor | None
+    shape: tuple[int, ...]
+    dtype: str
+    ndim: int
+    size: int
+    T: Tensor
+    def numpy(self) -> np.ndarray: ...
+    def tolist(self) -> Any: ...
+    def item(self) -> Any: ...
+    def reshape(self, *shape: Any) -> Tensor: ...
+    def flatten(self) -> Tensor: ...
+    def transpose(self) -> Tensor: ...
+    def sum(self) -> Tensor: ...
+    def mean(self) -> Tensor: ...
+    def relu(self) -> Tensor: ...
+    def sigmoid(self) -> Tensor: ...
+    def tanh(self) -> Tensor: ...
+    def exp(self) -> Tensor: ...
+    def log(self) -> Tensor: ...
+    def backward(self, gradient: Tensor | None = None) -> None: ...
+    def zero_grad(self) -> None: ...
+    def _assign(self, other: Tensor) -> None: ...
+    def _add_scaled_(self, other: Tensor, scale: float) -> None: ...
+    def __add__(self, other: Any) -> Tensor: ...
+    def __radd__(self, other: Any) -> Tensor: ...
+    def __sub__(self, other: Any) -> Tensor: ...
+    def __rsub__(self, other: Any) -> Tensor: ...
+    def __mul__(self, other: Any) -> Tensor: ...
+    def __rmul__(self, other: Any) -> Tensor: ...
+    def __truediv__(self, other: Any) -> Tensor: ...
+    def __rtruediv__(self, other: Any) -> Tensor: ...
+    def __neg__(self) -> Tensor: ...
+    def __pow__(self, exponent: float) -> Tensor: ...
+    def __matmul__(self, other: Any) -> Tensor: ...
+    def __rmatmul__(self, other: Any) -> Tensor: ...
+
+
+class TensorStudioError(RuntimeError): ...
+class ShapeError(TensorStudioError): ...
+class DTypeError(TensorStudioError): ...
+class DeviceError(TensorStudioError): ...
+class AutogradError(TensorStudioError): ...
+
+def tensor(data: Any, dtype: str | None = None, requires_grad: bool = False) -> Tensor: ...
+def from_numpy(array: np.ndarray, requires_grad: bool = False) -> Tensor: ...
+def zeros(shape: Any, dtype: str = "float32") -> Tensor: ...
+def ones(shape: Any, dtype: str = "float32") -> Tensor: ...
+def full(shape: Any, fill_value: float, dtype: str = "float32") -> Tensor: ...
+def randn(shape: Any, dtype: str = "float32", seed: int | None = None) -> Tensor: ...
+def arange(
+    start: float,
+    stop: float | None = None,
+    step: float = 1,
+    dtype: str = "float32",
+) -> Tensor: ...
+def add(left: Tensor, right: Any) -> Tensor: ...
+def sub(left: Tensor, right: Any) -> Tensor: ...
+def mul(left: Tensor, right: Any) -> Tensor: ...
+def div(left: Tensor, right: Any) -> Tensor: ...
+def neg(input: Tensor) -> Tensor: ...
+def pow(input: Tensor, exponent: float) -> Tensor: ...
+def matmul(left: Tensor, right: Any) -> Tensor: ...
+def sum(input: Tensor) -> Tensor: ...
+def mean(input: Tensor) -> Tensor: ...
+def relu(input: Tensor) -> Tensor: ...
+def sigmoid(input: Tensor) -> Tensor: ...
+def tanh(input: Tensor) -> Tensor: ...
+def exp(input: Tensor) -> Tensor: ...
+def log(input: Tensor) -> Tensor: ...
+def reshape(input: Tensor, shape: Any) -> Tensor: ...
+def flatten(input: Tensor) -> Tensor: ...
+def transpose(input: Tensor) -> Tensor: ...
+def backward(output: Tensor, gradient: Tensor | None = None) -> None: ...

tensorstudio/__init__.py

@@ -0,0 +1,24 @@
+"""TensorStudio public Python API."""
+
+from __future__ import annotations
+
+from . import nn, optim
+from ._version import __version__
+from .serialization import load, save
+from .tensor import Tensor, arange, from_numpy, full, ones, randn, tensor, zeros
+
+__all__ = [
+    "Tensor",
+    "__version__",
+    "arange",
+    "from_numpy",
+    "full",
+    "load",
+    "nn",
+    "ones",
+    "optim",
+    "randn",
+    "save",
+    "tensor",
+    "zeros",
+]

tensorstudio/_version.py

@@ -0,0 +1,5 @@
+"""Package version."""
+
+__version__ = "0.1.1"
+
+__all__ = ["__version__"]

tensorstudio/autograd.py

@@ -0,0 +1,15 @@
+"""Autograd helpers."""
+
+from __future__ import annotations
+
+from . import _C
+from .tensor import Tensor
+
+
+def backward(output: Tensor, gradient: Tensor | None = None) -> None:
+    """Run reverse-mode automatic differentiation from an output tensor."""
+
+    _C.backward(output, gradient)
+
+
+__all__ = ["backward"]

tensorstudio/data/__init__.py

@@ -0,0 +1,8 @@
+"""Small data utilities."""
+
+from __future__ import annotations
+
+from .dataloader import DataLoader
+from .dataset import Dataset, TensorDataset
+
+__all__ = ["DataLoader", "Dataset", "TensorDataset"]

tensorstudio/data/dataloader.py

@@ -0,0 +1,38 @@
+"""Minimal deterministic dataloader."""
+
+from __future__ import annotations
+
+import random
+from collections.abc import Iterator
+from typing import Any
+
+from .dataset import Dataset
+
+
+class DataLoader:
+    """Iterate over a dataset in Python batches."""
+
+    def __init__(
+        self,
+        dataset: Dataset,
+        batch_size: int = 1,
+        shuffle: bool = False,
+        seed: int | None = None,
+    ) -> None:
+        if batch_size <= 0:
+            raise ValueError("batch_size must be positive")
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.seed = seed
+
+    def __iter__(self) -> Iterator[list[Any]]:
+        indices = list(range(len(self.dataset)))
+        if self.shuffle:
+            rng = random.Random(self.seed)
+            rng.shuffle(indices)
+        for start in range(0, len(indices), self.batch_size):
+            yield [self.dataset[index] for index in indices[start : start + self.batch_size]]
+
+
+__all__ = ["DataLoader"]

tensorstudio/data/dataset.py

@@ -0,0 +1,34 @@
+"""Dataset abstractions."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+from tensorstudio.tensor import Tensor
+
+
+class Dataset(Protocol):
+    def __len__(self) -> int: ...
+
+    def __getitem__(self, index: int) -> object: ...
+
+
+class TensorDataset:
+    """Dataset wrapping tensors with matching leading dimension."""
+
+    def __init__(self, *tensors: Tensor) -> None:
+        if not tensors:
+            raise ValueError("TensorDataset requires at least one tensor")
+        leading = tensors[0].shape[0]
+        if any(tensor.shape[0] != leading for tensor in tensors):
+            raise ValueError("all tensors must have the same leading dimension")
+        self.tensors = tensors
+
+    def __len__(self) -> int:
+        return self.tensors[0].shape[0]
+
+    def __getitem__(self, index: int) -> tuple[object, ...]:
+        return tuple(tensor.tolist()[index] for tensor in self.tensors)
+
+
+__all__ = ["Dataset", "TensorDataset"]

tensorstudio/errors.py

@@ -0,0 +1,19 @@
+"""TensorStudio exception aliases."""
+
+from __future__ import annotations
+
+from . import _C
+
+TensorStudioError = _C.TensorStudioError
+ShapeError = _C.ShapeError
+DTypeError = _C.DTypeError
+DeviceError = _C.DeviceError
+AutogradError = _C.AutogradError
+
+__all__ = [
+    "AutogradError",
+    "DTypeError",
+    "DeviceError",
+    "ShapeError",
+    "TensorStudioError",
+]

tensorstudio/nn/__init__.py

@@ -0,0 +1,22 @@
+"""Neural network modules."""
+
+from __future__ import annotations
+
+from .functional import mse_loss, relu, sigmoid, tanh
+from .losses import MSELoss
+from .modules import Linear, Module, Parameter, ReLU, Sequential, Sigmoid, Tanh
+
+__all__ = [
+    "Linear",
+    "MSELoss",
+    "Module",
+    "Parameter",
+    "ReLU",
+    "Sequential",
+    "Sigmoid",
+    "Tanh",
+    "mse_loss",
+    "relu",
+    "sigmoid",
+    "tanh",
+]

tensorstudio/nn/functional.py

@@ -0,0 +1,25 @@
+"""Functional neural network operations."""
+
+from __future__ import annotations
+
+from tensorstudio.tensor import Tensor
+
+
+def relu(input: Tensor) -> Tensor:
+    return input.relu()
+
+
+def sigmoid(input: Tensor) -> Tensor:
+    return input.sigmoid()
+
+
+def tanh(input: Tensor) -> Tensor:
+    return input.tanh()
+
+
+def mse_loss(input: Tensor, target: Tensor) -> Tensor:
+    diff = input - target
+    return (diff * diff).mean()
+
+
+__all__ = ["mse_loss", "relu", "sigmoid", "tanh"]

tensorstudio/nn/losses.py

@@ -0,0 +1,18 @@
+"""Loss modules."""
+
+from __future__ import annotations
+
+from tensorstudio.tensor import Tensor
+
+from . import functional as F
+from .modules import Module
+
+
+class MSELoss(Module):
+    """Mean squared error loss."""
+
+    def forward(self, input: Tensor, target: Tensor) -> Tensor:
+        return F.mse_loss(input, target)
+
+
+__all__ = ["MSELoss"]

tensorstudio/nn/modules.py

@@ -0,0 +1,150 @@
+"""Small neural network module system built on TensorStudio tensors."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Iterator
+from typing import Any, cast
+
+from tensorstudio.tensor import Tensor, randn, tensor, zeros
+
+
+class Parameter:
+    """Factory class that creates tensors with ``requires_grad=True``."""
+
+    def __new__(cls, data: Any, dtype: str | None = None) -> Tensor:  # type: ignore[misc]
+        if isinstance(data, Tensor):
+            data.requires_grad = True
+            return data
+        return tensor(data, dtype=dtype, requires_grad=True)
+
+
+class Module:
+    """Base class for Python-level neural network modules."""
+
+    training: bool
+
+    def __init__(self) -> None:
+        self.training = True
+
+    def forward(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return self.forward(*args, **kwargs)
+
+    def parameters(self) -> list[Tensor]:
+        seen: set[int] = set()
+        return list(self._iter_parameters(seen))
+
+    def zero_grad(self) -> None:
+        for parameter in self.parameters():
+            parameter.zero_grad()
+
+    def train(self) -> Module:
+        self.training = True
+        for module in self._children():
+            module.train()
+        return self
+
+    def eval(self) -> Module:
+        self.training = False
+        for module in self._children():
+            module.eval()
+        return self
+
+    def _children(self) -> Iterator[Module]:
+        for value in self.__dict__.values():
+            yield from self._modules_from_value(value)
+
+    def _iter_parameters(self, seen: set[int]) -> Iterator[Tensor]:
+        for value in self.__dict__.values():
+            yield from self._parameters_from_value(value, seen)
+
+    @classmethod
+    def _parameters_from_value(cls, value: Any, seen: set[int]) -> Iterator[Tensor]:
+        if isinstance(value, Tensor):
+            marker = id(value)
+            if value.requires_grad and marker not in seen:
+                seen.add(marker)
+                yield value
+        elif isinstance(value, Module):
+            yield from value._iter_parameters(seen)
+        elif isinstance(value, dict):
+            for item in value.values():
+                yield from cls._parameters_from_value(item, seen)
+        elif isinstance(value, (list, tuple)):
+            for item in value:
+                yield from cls._parameters_from_value(item, seen)
+
+    @classmethod
+    def _modules_from_value(cls, value: Any) -> Iterator[Module]:
+        if isinstance(value, Module):
+            yield value
+        elif isinstance(value, dict):
+            for item in value.values():
+                yield from cls._modules_from_value(item)
+        elif isinstance(value, (list, tuple)):
+            for item in value:
+                yield from cls._modules_from_value(item)
+
+
+class Linear(Module):
+    """Fully connected layer with shape ``input @ weight.T + bias``."""
+
+    def __init__(self, in_features: int, out_features: int, bias: bool = True) -> None:
+        super().__init__()
+        if in_features <= 0 or out_features <= 0:
+            raise ValueError("in_features and out_features must be positive")
+        scale = 1.0 / math.sqrt(in_features)
+        self.in_features = in_features
+        self.out_features = out_features
+        self.weight = cast(Tensor, Parameter(randn((out_features, in_features), seed=42) * scale))
+        self.bias = cast(Tensor, Parameter(zeros((out_features,)))) if bias else None
+
+    def forward(self, input: Tensor) -> Tensor:
+        output = input @ self.weight.T
+        if self.bias is not None:
+            output = output + self.bias
+        return output
+
+
+class Sequential(Module):
+    """A simple ordered container of modules."""
+
+    def __init__(self, *modules: Module) -> None:
+        super().__init__()
+        self.modules = list(modules)
+
+    def forward(self, input: Tensor) -> Tensor:
+        output = input
+        for module in self.modules:
+            output = module(output)
+        return output
+
+    def __iter__(self) -> Iterator[Module]:
+        return iter(self.modules)
+
+    def __len__(self) -> int:
+        return len(self.modules)
+
+    def __getitem__(self, index: int) -> Module:
+        return self.modules[index]
+
+
+class ReLU(Module):
+    def forward(self, input: Tensor) -> Tensor:
+        return input.relu()
+
+
+class Sigmoid(Module):
+    def forward(self, input: Tensor) -> Tensor:
+        return input.sigmoid()
+
+
+class Tanh(Module):
+    def forward(self, input: Tensor) -> Tensor:
+        return input.tanh()
+
+
+__all__ = ["Linear", "Module", "Parameter", "ReLU", "Sequential", "Sigmoid", "Tanh"]

tensorstudio/ops.py

@@ -0,0 +1,97 @@
+"""Functional tensor operations."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from . import _C
+from .tensor import Tensor
+
+
+def add(left: Tensor, right: Any) -> Tensor:
+    return _C.add(left, right)
+
+
+def sub(left: Tensor, right: Any) -> Tensor:
+    return _C.sub(left, right)
+
+
+def mul(left: Tensor, right: Any) -> Tensor:
+    return _C.mul(left, right)
+
+
+def div(left: Tensor, right: Any) -> Tensor:
+    return _C.div(left, right)
+
+
+def neg(input: Tensor) -> Tensor:
+    return _C.neg(input)
+
+
+def pow(input: Tensor, exponent: float) -> Tensor:
+    return _C.pow(input, exponent)
+
+
+def matmul(left: Tensor, right: Any) -> Tensor:
+    return _C.matmul(left, right)
+
+
+def sum(input: Tensor) -> Tensor:  # noqa: A001
+    return _C.sum(input)
+
+
+def mean(input: Tensor) -> Tensor:
+    return _C.mean(input)
+
+
+def relu(input: Tensor) -> Tensor:
+    return _C.relu(input)
+
+
+def sigmoid(input: Tensor) -> Tensor:
+    return _C.sigmoid(input)
+
+
+def tanh(input: Tensor) -> Tensor:
+    return _C.tanh(input)
+
+
+def exp(input: Tensor) -> Tensor:
+    return _C.exp(input)
+
+
+def log(input: Tensor) -> Tensor:
+    return _C.log(input)
+
+
+def reshape(input: Tensor, shape: int | tuple[int, ...] | list[int]) -> Tensor:
+    return _C.reshape(input, shape)
+
+
+def flatten(input: Tensor) -> Tensor:
+    return _C.flatten(input)
+
+
+def transpose(input: Tensor) -> Tensor:
+    return _C.transpose(input)
+
+
+__all__ = [
+    "add",
+    "div",
+    "exp",
+    "flatten",
+    "log",
+    "matmul",
+    "mean",
+    "mul",
+    "neg",
+    "pow",
+    "relu",
+    "reshape",
+    "sigmoid",
+    "sub",
+    "sum",
+    "tanh",
+    "transpose",
+]

tensorstudio/optim/__init__.py

@@ -0,0 +1,8 @@
+"""Optimizers."""
+
+from __future__ import annotations
+
+from .adam import Adam
+from .sgd import SGD
+
+__all__ = ["Adam", "SGD"]

tensorstudio/optim/adam.py

@@ -0,0 +1,53 @@
+"""Adam optimizer."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from tensorstudio.tensor import Tensor, zeros
+
+
+class Adam:
+    """Adam optimizer with bias correction."""
+
+    def __init__(
+        self,
+        params: Iterable[Tensor],
+        lr: float = 0.001,
+        betas: tuple[float, float] = (0.9, 0.999),
+        eps: float = 1e-8,
+    ) -> None:
+        if lr <= 0:
+            raise ValueError("lr must be positive")
+        beta1, beta2 = betas
+        if not 0 <= beta1 < 1 or not 0 <= beta2 < 1:
+            raise ValueError("betas must be in [0, 1)")
+        if eps <= 0:
+            raise ValueError("eps must be positive")
+        self.params = list(params)
+        self.lr = lr
+        self.beta1 = beta1
+        self.beta2 = beta2
+        self.eps = eps
+        self.t = 0
+        self._m = [zeros(parameter.shape, dtype=parameter.dtype) for parameter in self.params]
+        self._v = [zeros(parameter.shape, dtype=parameter.dtype) for parameter in self.params]
+
+    def zero_grad(self) -> None:
+        for parameter in self.params:
+            parameter.zero_grad()
+
+    def step(self) -> None:
+        self.t += 1
+        for index, parameter in enumerate(self.params):
+            grad = parameter.grad
+            if grad is None:
+                continue
+            self._m[index] = self._m[index] * self.beta1 + grad * (1.0 - self.beta1)
+            self._v[index] = self._v[index] * self.beta2 + (grad * grad) * (1.0 - self.beta2)
+            m_hat = self._m[index] / (1.0 - self.beta1**self.t)
+            v_hat = self._v[index] / (1.0 - self.beta2**self.t)
+            parameter._assign(parameter - self.lr * m_hat / ((v_hat**0.5) + self.eps))
+
+
+__all__ = ["Adam"]

tensorstudio/optim/sgd.py

@@ -0,0 +1,31 @@
+"""Stochastic gradient descent optimizer."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable
+
+from tensorstudio.tensor import Tensor
+
+
+class SGD:
+    """Basic SGD optimizer."""
+
+    def __init__(self, params: Iterable[Tensor], lr: float = 0.01) -> None:
+        if lr <= 0:
+            raise ValueError("lr must be positive")
+        self.params = list(params)
+        self.lr = lr
+
+    def zero_grad(self) -> None:
+        for parameter in self.params:
+            parameter.zero_grad()
+
+    def step(self) -> None:
+        for parameter in self.params:
+            grad = parameter.grad
+            if grad is None:
+                continue
+            parameter._assign(parameter - grad * self.lr)
+
+
+__all__ = ["SGD"]

tensorstudio/py.typed

@@ -0,0 +1 @@
+

tensorstudio/serialization.py

@@ -0,0 +1,34 @@
+"""Serialization helpers.
+
+TensorStudio v0.1.x uses pickle for internal object roundtrips. Loading pickle
+data from untrusted sources is unsafe because pickle can execute arbitrary code
+during deserialization.
+"""
+
+from __future__ import annotations
+
+import pickle
+from pathlib import Path
+from typing import Any
+
+from .typing import PathLikeStr
+
+
+def save(obj: Any, path: PathLikeStr) -> None:
+    """Serialize a TensorStudio object to a file with pickle."""
+
+    with Path(path).open("wb") as file:
+        pickle.dump(obj, file, protocol=pickle.HIGHEST_PROTOCOL)
+
+
+def load(path: PathLikeStr) -> Any:
+    """Load a TensorStudio object from a pickle file.
+
+    Only load files you created or otherwise trust.
+    """
+
+    with Path(path).open("rb") as file:
+        return pickle.load(file)  # noqa: S301
+
+
+__all__ = ["load", "save"]

tensorstudio/tensor.py

@@ -0,0 +1,69 @@
+"""Tensor creation helpers and the public Tensor class."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+
+from . import _C
+
+Tensor = _C.Tensor
+
+
+def tensor(data: Any, dtype: str | None = None, requires_grad: bool = False) -> Tensor:
+    """Create a Tensor from Python numeric data or a NumPy array."""
+
+    return _C.tensor(data, dtype, requires_grad)
+
+
+def from_numpy(array: np.ndarray, requires_grad: bool = False) -> Tensor:
+    """Create a Tensor copy from a NumPy array."""
+
+    return _C.from_numpy(np.asarray(array), requires_grad)
+
+
+def zeros(shape: int | tuple[int, ...] | list[int], dtype: str = "float32") -> Tensor:
+    """Create a tensor filled with zeros."""
+
+    return _C.zeros(shape, dtype)
+
+
+def ones(shape: int | tuple[int, ...] | list[int], dtype: str = "float32") -> Tensor:
+    """Create a tensor filled with ones."""
+
+    return _C.ones(shape, dtype)
+
+
+def full(
+    shape: int | tuple[int, ...] | list[int],
+    fill_value: float,
+    dtype: str = "float32",
+) -> Tensor:
+    """Create a tensor filled with a scalar value."""
+
+    return _C.full(shape, fill_value, dtype)
+
+
+def randn(
+    shape: int | tuple[int, ...] | list[int],
+    dtype: str = "float32",
+    seed: int | None = None,
+) -> Tensor:
+    """Create a tensor with normally distributed pseudo-random values."""
+
+    return _C.randn(shape, dtype, seed)
+
+
+def arange(
+    start: float,
+    stop: float | None = None,
+    step: float = 1,
+    dtype: str = "float32",
+) -> Tensor:
+    """Create a 1D tensor with evenly spaced values."""
+
+    return _C.arange(start, stop, step, dtype)
+
+
+__all__ = ["Tensor", "arange", "from_numpy", "full", "ones", "randn", "tensor", "zeros"]

tensorstudio/typing.py

@@ -0,0 +1,12 @@
+"""Typing helpers for TensorStudio."""
+
+from __future__ import annotations
+
+from os import PathLike
+from typing import TypeAlias
+
+ShapeLike: TypeAlias = int | tuple[int, ...] | list[int]
+PathLikeStr: TypeAlias = str | PathLike[str]
+DTypeLike: TypeAlias = str | None
+
+__all__ = ["DTypeLike", "PathLikeStr", "ShapeLike"]

tensorstudio-0.1.1.dist-info/METADATA

@@ -0,0 +1,188 @@
+Metadata-Version: 2.2
+Name: tensorstudio
+Version: 0.1.1
+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
+License: MIT License
+         
+         Copyright (c) 2026 TensorStudio contributors
+         
+         Permission is hereby granted, free of charge, to any person obtaining a copy
+         of this software and associated documentation files (the "Software"), to deal
+         in the Software without restriction, including without limitation the rights
+         to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+         copies of the Software, and to permit persons to whom the Software is
+         furnished to do so, subject to the following conditions:
+         
+         The above copyright notice and this permission notice shall be included in all
+         copies or substantial portions of the Software.
+         
+         THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+         IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+         FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+         AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+         SOFTWARE.
+         
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: C++
+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
+Project-URL: Homepage, https://github.com/tensorstudio/tensorstudio
+Project-URL: Repository, https://github.com/tensorstudio/tensorstudio
+Project-URL: Issues, https://github.com/tensorstudio/tensorstudio/issues
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: pytest-cov>=5; extra == "dev"
+Requires-Dist: build>=1.2; extra == "dev"
+Requires-Dist: twine>=5; extra == "dev"
+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"
+Provides-Extra: docs
+Requires-Dist: mkdocs>=1.6; extra == "docs"
+Requires-Dist: mkdocs-material>=9.5; extra == "docs"
+Description-Content-Type: text/markdown
+
+# TensorStudio
+
+[![CI](https://github.com/tensorstudio/tensorstudio/actions/workflows/ci.yml/badge.svg)](https://github.com/tensorstudio/tensorstudio/actions/workflows/ci.yml)
+[![Wheels](https://github.com/tensorstudio/tensorstudio/actions/workflows/wheels.yml/badge.svg)](https://github.com/tensorstudio/tensorstudio/actions/workflows/wheels.yml)
+[![PyPI](https://img.shields.io/pypi/v/tensorstudio.svg)](https://pypi.org/project/tensorstudio/)
+
+TensorStudio is a compact C++ tensor and autograd engine with a Python API for
+learning, experimentation, and lightweight ML workloads.
+
+TensorStudio is experimental v0.1.1 software. It is CPU-only, eager-only, and
+intentionally small enough to read and modify.
+
+## Install
+
+From a source checkout:
+
+```bash
+python -m pip install -U pip
+python -m pip install -e ".[dev]"
+```
+
+Build source and wheel distributions:
+
+```bash
+python -m build
+```
+
+## Quickstart
+
+```python
+import tensorstudio as ts
+
+x = ts.tensor([[1.0, 2.0], [3.0, 4.0]])
+y = ts.ones((2, 2))
+
+print((x + y).tolist())
+print((x @ y).numpy())
+```
+
+## Autograd
+
+```python
+import tensorstudio as ts
+
+x = ts.tensor([1.0, 2.0, 3.0], requires_grad=True)
+loss = ((x * x).sum())
+loss.backward()
+
+print(x.grad.tolist())  # [2.0, 4.0, 6.0]
+```
+
+## Neural Networks
+
+```python
+import tensorstudio as ts
+from tensorstudio import nn, optim
+
+model = nn.Sequential(nn.Linear(1, 8), nn.Tanh(), nn.Linear(8, 1))
+optimizer = optim.SGD(model.parameters(), lr=0.05)
+criterion = nn.MSELoss()
+
+x = ts.tensor([[0.0], [1.0], [2.0], [3.0]])
+y = ts.tensor([[1.0], [3.0], [5.0], [7.0]])
+
+for _ in range(50):
+    optimizer.zero_grad()
+    loss = criterion(model(x), y)
+    loss.backward()
+    optimizer.step()
+
+print(loss.item())
+```
+
+## Development
+
+```bash
+python -m pip install -e ".[dev]"
+pytest
+ruff check .
+mypy python/tensorstudio
+python -m build
+```
+
+The native extension is built with CMake, pybind11, scikit-build-core, and C++20.
+
+## Documentation
+
+The documentation lives in `docs/` and is configured with MkDocs:
+
+```bash
+python -m pip install -e ".[docs]"
+mkdocs serve
+mkdocs build
+```
+
+The docs cover tensor semantics, broadcasting, NumPy interop, autograd, neural
+network modules, training loops, CPU backend details, benchmarks, development,
+publishing, and the project roadmap.
+
+## Publishing
+
+Releases are intended to be built by GitHub Actions. The publish workflow uses
+PyPI trusted publishing through `pypa/gh-action-pypi-publish`; do not commit PyPI
+API tokens.
+
+## Current Limitations
+
+- CPU backend only
+- Eager execution only
+- No CUDA kernels or mixed precision
+- No graph compiler or distributed training
+- Limited dtype casting and no advanced indexing
+- No sparse tensors
+- Pickle serialization is for trusted TensorStudio objects only
+
+## Roadmap
+
+- CUDA backend
+- Graph/JIT mode
+- Convolution ops
+- Dataset utilities
+- Model zoo examples
+- ONNX import/export
+- Improved memory allocator
+- SIMD kernels
+- Multithreaded ops
+
+## License
+
+TensorStudio is licensed under the MIT License.

tensorstudio-0.1.1.dist-info/RECORD

@@ -0,0 +1,25 @@
+tensorstudio/__init__.py,sha256=Y9DQ2Qf9VTvYJV9ppc_ZLudUgBkWBlNUtLAX4k6Ve5I,467
+tensorstudio/_C.cp313-win_amd64.pyd,sha256=GRjcAGsvbx9sKCCQYWxrsu-lLQUPUx7Mtln1wLt3fSk,408576
+tensorstudio/_C.pyi,sha256=rLsHKXD7tP9yxyUS5n3YQmZADbjaZT3t_fjV7IBFhws,3223
+tensorstudio/_version.py,sha256=J-qSORFK7QMCuBXuRQYvSNcMYGsG28v_KPc392hVSiQ,78
+tensorstudio/autograd.py,sha256=OzmQjn1A3sY8Z_DhJkEu-ujSXsZsPU2PE1B1r6XQdw0,328
+tensorstudio/data/__init__.py,sha256=srpO6wZIkx0r0PJ0PA9w1cyFZJbIs1BshAUYhaK2Cxg,206
+tensorstudio/data/dataloader.py,sha256=GzDwT-1mx1r2EFNpKa7wR30T6dEXBo7U1cx45HbYDck,1051
+tensorstudio/data/dataset.py,sha256=w6eINnpqhgoZb5rlHCQUH5F5oSOmS1RLl0FMaJA6qh4,985
+tensorstudio/errors.py,sha256=v_jnvS8_F2nwHQLkHMcVQKs-FE6DbSnY0yIGopYwpeA,385
+tensorstudio/nn/__init__.py,sha256=Ks_XjkOjFXQyaHh3Vppwpa5y9jzM7BU77Viz_Fwyx3g,438
+tensorstudio/nn/functional.py,sha256=3NYsG5QSfdUGLM5FKBy_TOqhCgkpunrHc3n3dQ0FJN0,501
+tensorstudio/nn/losses.py,sha256=AcBPesUamqvnKyMc7aeTKUEbnr8raYYo3zaal7pci0o,363
+tensorstudio/nn/modules.py,sha256=DK8Ch6-HCHC0oeYrx8W0e_1-qxPw0jpqbANmcCMTmTw,4849
+tensorstudio/ops.py,sha256=REw0fFmex9Dpw4aPRBUa75Vz_9t-qRo9mT5bL5EAu5s,1725
+tensorstudio/optim/__init__.py,sha256=U_Yg_xESI0UAf_VlzgJtnZK-l5ek4pWy_susR49zK5E,134
+tensorstudio/optim/adam.py,sha256=MjwghneGTXLQfJjM2Ic4_beGMNX3OVRfLRpuw7qIfxU,1784
+tensorstudio/optim/sgd.py,sha256=vAAxZM4nheGi7QVymtuoj_p3C8VexDW63_bFK3Oafxs,778
+tensorstudio/py.typed,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
+tensorstudio/serialization.py,sha256=g3sPMgEXLQh-foHxLqPhVHXV2KRn9Sk5AZB1vwtND9s,870
+tensorstudio/tensor.py,sha256=7_6Zd1vOT_Qs8nUmmDRATwlbDk7ljE-tJ7ppOORB82I,1763
+tensorstudio/typing.py,sha256=G6jA3AjaV8PSJG-N-88wSJG0YI7toUG7i3yWM_3XL5k,331
+tensorstudio-0.1.1.dist-info/METADATA,sha256=neuxU2yIu4SgJytDepjYqSUxNPif5WtR7eMdFaYYyoU,5901
+tensorstudio-0.1.1.dist-info/WHEEL,sha256=wCnCdPo_X0QGrRMO_ctMhdhFetNHQp7_-JalWW02tjE,105
+tensorstudio-0.1.1.dist-info/licenses/LICENSE,sha256=4IIKD3q9NiDUwBZ1k1ly4lDgV7z8U-698jfW0_kHRG4,1103
+tensorstudio-0.1.1.dist-info/RECORD,,

tensorstudio-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.0.0
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

tensorstudio-0.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TensorStudio contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.