pytinytensor 0.1.1__tar.gz → 0.1.2__tar.gz

pytinytensor-0.1.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 IbrokhimN
+
+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.

{pytinytensor-0.1.1 → pytinytensor-0.1.2}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: pytinytensor
-Version: 0.1.1
+Version: 0.1.2
 Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
 Home-page: https://github.com/IbrokhimN/tinytensor
 Author: IbrokhimN
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy>=1.23
 Requires-Dist: pybind11>=2.10
 Provides-Extra: dev
@@ -14,6 +15,7 @@ Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{pytinytensor-0.1.1 → pytinytensor-0.1.2}/pytinytensor.egg-info/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: pytinytensor
-Version: 0.1.1
+Version: 0.1.2
 Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
 Home-page: https://github.com/IbrokhimN/tinytensor
 Author: IbrokhimN
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: numpy>=1.23
 Requires-Dist: pybind11>=2.10
 Provides-Extra: dev
@@ -14,6 +15,7 @@ Dynamic: author
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: provides-extra
 Dynamic: requires-dist
 Dynamic: requires-python

{pytinytensor-0.1.1 → pytinytensor-0.1.2}/pytinytensor.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 setup.py
@@ -14,10 +15,12 @@ tests/test_optim.py
 tests/test_tensor_math.py
 tinytensor/__init__.py
 tinytensor/config.py
+tinytensor/setup.py
 tinytensor/backends/__init__.py
 tinytensor/backends/cpu_numpy.py
 tinytensor/backends/cuda_binding.cpp
 tinytensor/backends/cuda_gpu.cu
+tinytensor/backends/cuda_gpu.py
 tinytensor/core/__init__.py
 tinytensor/core/autograd.py
 tinytensor/core/ops.py
@@ -32,6 +35,27 @@ tinytensor/nn/losses.py
 tinytensor/nn/modules.py
 tinytensor/optim/__init__.py
 tinytensor/optim/optimizer.py
+tinytensor/tinytensor/__init__.py
+tinytensor/tinytensor/config.py
+tinytensor/tinytensor/backends/__init__.py
+tinytensor/tinytensor/backends/cpu_numpy.py
+tinytensor/tinytensor/core/__init__.py
+tinytensor/tinytensor/core/autograd.py
+tinytensor/tinytensor/core/ops.py
+tinytensor/tinytensor/core/tensor.py
+tinytensor/tinytensor/data/__init__.py
+tinytensor/tinytensor/data/dataloader.py
+tinytensor/tinytensor/data/dataset.py
+tinytensor/tinytensor/nn/__init__.py
+tinytensor/tinytensor/nn/activations.py
+tinytensor/tinytensor/nn/linear.py
+tinytensor/tinytensor/nn/losses.py
+tinytensor/tinytensor/nn/modules.py
+tinytensor/tinytensor/optim/__init__.py
+tinytensor/tinytensor/optim/optimizer.py
+tinytensor/tinytensor/utils/__init__.py
+tinytensor/tinytensor/utils/bar.py
+tinytensor/tinytensor/utils/early_stopping.py
 tinytensor/utils/__init__.py
 tinytensor/utils/bar.py
 tinytensor/utils/early_stopping.py

pytinytensor-0.1.2/setup.py

@@ -0,0 +1,133 @@
+import os
+import subprocess
+import pybind11
+from pathlib import Path
+from setuptools import setup, find_packages, Extension
+from setuptools.command.build_ext import build_ext
+
+long_description = Path(__file__).parent / "README.md"
+long_description = long_description.read_text(encoding="utf-8") if long_description.exists() else ""
+
+def find_cuda_lib_dirs():
+    candidates = [
+        os.environ.get("CUDA_HOME"),
+        os.environ.get("CUDA_PATH"),
+        "/usr/local/cuda",
+    ]
+    conda_prefix = os.environ.get("CONDA_PREFIX")
+    if conda_prefix:
+        candidates.append(conda_prefix)
+
+    found = []
+    for base in candidates:
+        if not base:
+            continue
+        lib_dir = os.path.join(base, "lib64")
+        if not os.path.isdir(lib_dir):
+            lib_dir = os.path.join(base, "lib")
+        has_cudart = any(
+            f.startswith("libcudart.so") for f in os.listdir(lib_dir)
+        ) if os.path.isdir(lib_dir) else False
+        has_cublas = any(
+            f.startswith("libcublas.so") for f in os.listdir(lib_dir)
+        ) if os.path.isdir(lib_dir) else False
+        if has_cudart and has_cublas:
+            found.append(lib_dir)
+    return found
+
+
+def check_cuda():
+    try:
+        subprocess.check_output(["nvcc", "--version"])
+    except (FileNotFoundError, subprocess.CalledProcessError):
+        return False, []
+
+    lib_dirs = find_cuda_lib_dirs()
+    if not lib_dirs:
+        print("nvcc есть но libcudart/libcublas не найдены рядом. Сборка пойдет на CPU.")
+        return False, []
+    return True, lib_dirs
+
+
+class CUDABuildExt(build_ext):
+    # если cuda-сборка все равно упадет (например линковка) - не роняем весь pip install,
+    # а просто откатываемся на чистый cpu-пакет
+    def build_extensions(self):
+        self.compiler.src_extensions.append('.cu')
+        original_compile = self.compiler._compile
+
+        def custom_compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
+            # extra_postargs может приходить как список или словарь — обрабатываем оба случая
+            if isinstance(extra_postargs, dict):
+                gcc_postargs = extra_postargs.get('gcc', [])
+                nvcc_postargs = extra_postargs.get('nvcc', [])
+            else:
+                gcc_postargs = extra_postargs or []
+                nvcc_postargs = []
+
+            if os.path.splitext(src)[1] == '.cu':
+                # nvcc собирает .cu файл
+                inc_flags = [f"-I{inc}" for inc in self.compiler.include_dirs]
+                cmd = ['nvcc', '-c', src, '-o', obj] + inc_flags + nvcc_postargs
+                self.spawn(cmd)
+            else:
+                # g++ собирает .cpp файл (с pybind11)
+                original_compile(obj, src, ext, cc_args, gcc_postargs, pp_opts)
+
+        self.compiler._compile = custom_compile
+
+        try:
+            super().build_extensions()
+        except Exception as e:
+            print(f"сборка cuda-расширения не удалась ({e}), продолжаем без него (cpu-only).")
+            self.extensions = []
+
+ext_modules = []
+
+cuda_ok, cuda_lib_dirs = check_cuda()
+
+if cuda_ok:
+    cuda_module = Extension(
+        'tinytensor.cuda_ops',
+        sources=[
+            'tinytensor/backends/cuda_gpu.cu',       # nvcc
+            'tinytensor/backends/cuda_binding.cpp'   # g++
+        ],
+        include_dirs=[
+            pybind11.get_include(),
+            '/usr/local/cuda/include',
+            os.path.expanduser('~/.local/include')
+        ],
+        library_dirs=cuda_lib_dirs,
+        libraries=['cudart', 'cublas'],
+        extra_compile_args={
+            'gcc': ['-O3', '-fPIC', '-std=c++17'],
+            'nvcc': ['-O3', '-Xcompiler', '-fPIC']
+        },
+        optional=True,
+    )
+    ext_modules.append(cuda_module)
+    print("cublas")
+else:
+    print("cpu")
+
+setup(
+    name="pytinytensor",
+    version="0.1.2",
+    description="мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="IbrokhimN",
+    url="https://github.com/IbrokhimN/tinytensor",
+    packages=find_packages(include=["tinytensor", "tinytensor.*"]),
+    ext_modules=ext_modules,
+    cmdclass={'build_ext': CUDABuildExt},
+    install_requires=[
+        "numpy>=1.23",
+        "pybind11>=2.10",
+    ],
+    extras_require={
+        "dev": ["pytest>=7.0"],
+    },
+    python_requires=">=3.9",
+)

{pytinytensor-0.1.1 → pytinytensor-0.1.2/tinytensor}/setup.py

@@ -1,13 +1,9 @@
 import os
 import subprocess
 import pybind11
-from pathlib import Path
 from setuptools import setup, find_packages, Extension
 from setuptools.command.build_ext import build_ext
 
-long_description = Path(__file__).parent / "README.md"
-long_description = long_description.read_text(encoding="utf-8") if long_description.exists() else ""
-
 def check_cuda():
     try:
         subprocess.check_output(["nvcc", "--version"])
@@ -21,6 +17,7 @@ class CUDABuildExt(build_ext):
         original_compile = self.compiler._compile
 
         def custom_compile(obj, src, ext, cc_args, extra_postargs, pp_opts):
+            # extra_postargs может приходить как список или словарь — обрабатываем оба случая
             if isinstance(extra_postargs, dict):
                 gcc_postargs = extra_postargs.get('gcc', [])
                 nvcc_postargs = extra_postargs.get('nvcc', [])
@@ -29,10 +26,12 @@ class CUDABuildExt(build_ext):
                 nvcc_postargs = []
 
             if os.path.splitext(src)[1] == '.cu':
+                # nvcc собирает .cu файл
                 inc_flags = [f"-I{inc}" for inc in self.compiler.include_dirs]
                 cmd = ['nvcc', '-c', src, '-o', obj] + inc_flags + nvcc_postargs
                 self.spawn(cmd)
             else:
+                # g++ собирает .cpp файл (с pybind11)
                 original_compile(obj, src, ext, cc_args, gcc_postargs, pp_opts)
 
         self.compiler._compile = custom_compile
@@ -44,8 +43,8 @@ if check_cuda():
     cuda_module = Extension(
         'tinytensor.cuda_ops',
         sources=[
-            'tinytensor/backends/cuda_gpu.cu',       
-            'tinytensor/backends/cuda_binding.cpp'   
+            'tinytensor/backends/cuda_gpu.cu',       # Компилируется nvcc
+            'tinytensor/backends/cuda_binding.cpp'    # Компилируется g++
         ],
         include_dirs=[
             pybind11.get_include(),
@@ -60,18 +59,14 @@ if check_cuda():
         }
     )
     ext_modules.append(cuda_module)
-    print("CUDA найдена! Собираем cuBLAS бэкенд...")
+    print("🔥 CUDA найдена! Собираем cuBLAS бэкенд...")
 else:
-    print("CUDA не найдена. Сборка продолжится на CPU (NumPy).")
+    print("⚠️ CUDA не найдена. Сборка продолжится на CPU (NumPy).")
 
 setup(
-    name="pytinytensor",
-    version="0.1.1",
+    name="tinytensor",
+    version="0.1.0",
     description="мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    author="IbrokhimN",
-    url="https://github.com/IbrokhimN/tinytensor",
     packages=find_packages(include=["tinytensor", "tinytensor.*"]),
     ext_modules=ext_modules,
     cmdclass={'build_ext': CUDABuildExt},
@@ -83,4 +78,4 @@ setup(
         "dev": ["pytest>=7.0"],
     },
     python_requires=">=3.9",
-)
+)

pytinytensor-0.1.2/tinytensor/tinytensor/config.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+import numpy as np
+
+
+@dataclass
+class Config:
+    # базовый сид будет 67
+    seed: int = 67
+
+
+config = Config()
+
+
+def set_seed(seed: int):
+    # автоматически устанавливаем сид для воспроизведения и тд
+    config.seed = seed
+    np.random.seed(seed)
+
+# ну все при импорте будет устанавливаться
+np.random.seed(config.seed)

pytinytensor-0.1.2/tinytensor/tinytensor/core/autograd.py

@@ -0,0 +1,22 @@
+import numpy as np
+
+
+def backward(target_tensor):
+    # эт я вообще сделал чтоб файл не пустовал, но это архитектура micrograd как у Андрея Карпатова,
+    # если кто то шарит за нормальный движок autograd, то PRните
+    topo = []
+    visited = set()
+
+    def build_topo(v):
+        if v not in visited:
+            visited.add(v)
+            for child in v._prev:
+                build_topo(child)
+            topo.append(v)
+
+    build_topo(target_tensor)
+
+    target_tensor.grad = np.ones_like(target_tensor.data, dtype=np.float32)
+
+    for v in reversed(topo):
+        v._backward()

pytinytensor-0.1.2/tinytensor/tinytensor/core/ops.py

@@ -0,0 +1 @@
+# пока что побудет пустым 

pytinytensor-0.1.2/tinytensor/tinytensor/core/tensor.py

@@ -0,0 +1,288 @@
+import numpy as np
+
+from tinytensor.core.autograd import backward as run_backward
+
+#чекаем ес можно на cuda матричные умножения сделать
+try:
+    from tinytensor import cuda_ops
+    HAS_CUDA = True
+except ImportError:
+    HAS_CUDA = False
+
+
+def _unbroadcast(grad, target):
+    while grad.ndim > len(target):
+        grad = grad.sum(axis=0)
+
+    for i, dim in enumerate(target):
+        if dim == 1:
+            grad = grad.sum(axis=i, keepdims=True)
+    return grad
+
+
+# этот мир жесток
+class Tensor:
+    def __init__(self, data, requires_grad=False, device="cpu"):
+        # кароч проверка если нампай массив то оставляем а если нет то делаем нампаем
+        if isinstance(data, np.ndarray):
+            self.data = data.astype(np.float32)
+        else:
+            self.data = np.array(data, dtype=np.float32)
+
+        self.grad = None
+        self._backward = lambda: None
+        self._prev = set()
+        self.requires_grad = requires_grad
+        self.device = device
+
+    def to(self, device):
+        # перекидываем тензор на cuda или cpu
+        self.device = device
+        return self
+
+    def __repr__(self):
+        return f"tensor({self.data}, device='{self.device}', requires_grad={self.requires_grad})"
+
+    @property
+    def shape(self):
+        return self.data.shape
+
+    # сложение
+    def __add__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other, device=self.device)
+        out = Tensor(
+            self.data + other.data,
+            requires_grad=self.requires_grad or other.requires_grad,
+            device=self.device,
+        )
+
+        if out.requires_grad:
+            out._prev = {self, other}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+
+                    grad_self = out.grad * 1.0
+                    self.grad += _unbroadcast(grad_self, self.data.shape)
+
+                # градиент для 2 параметра
+                if other.requires_grad:
+                    if other.grad is None:
+                        other.grad = np.zeros_like(other.data, dtype=np.float32)
+
+                    grad_other = out.grad * 1.0
+                    other.grad += _unbroadcast(grad_other, other.data.shape)
+
+            out._backward = _backward
+
+        return out
+
+    def __radd__(self, other):
+        # эт если пользователь решит написать не Tensor + 5 а 5 + Tensor
+        return self + other
+
+    # умножение
+    def __mul__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other, device=self.device)
+        out = Tensor(
+            self.data * other.data,
+            requires_grad=self.requires_grad or other.requires_grad,
+            device=self.device,
+        )
+
+        if out.requires_grad:
+            out._prev = {self, other}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    grad_self = out.grad * other.data
+                    self.grad += _unbroadcast(grad_self, self.data.shape)
+
+                if other.requires_grad:
+                    if other.grad is None:
+                        other.grad = np.zeros_like(other.data, dtype=np.float32)
+                    grad_other = out.grad * self.data
+                    other.grad += _unbroadcast(grad_other, other.data.shape)
+
+            out._backward = _backward
+
+        return out
+
+    def __rmul__(self, other):
+        return self * other
+
+    # матричное умножение
+    def __matmul__(self, other):
+        other = other if isinstance(other, Tensor) else Tensor(other, device=self.device)
+
+        # если девайс куда и бэкенд собрался то гоним через кублас а если нет то обычный нампай
+        if (self.device == "cuda" or other.device == "cuda") and HAS_CUDA:
+            res_data = cuda_ops.matmul(self.data, other.data)
+        else:
+            res_data = np.matmul(self.data, other.data)
+
+        out = Tensor(
+            res_data,
+            requires_grad=self.requires_grad or other.requires_grad,
+            device=self.device,
+        )
+
+        if out.requires_grad:
+            out._prev = {self, other}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += np.matmul(out.grad, other.data.T)
+
+                if other.requires_grad:
+                    if other.grad is None:
+                        other.grad = np.zeros_like(other.data, dtype=np.float32)
+                    other.grad += np.matmul(self.data.T, out.grad)
+
+            out._backward = _backward
+
+        return out
+
+    # вычитание
+    def __sub__(self, other):
+        return self + (other * -1)
+
+    def __rsub__(self, other):
+        return (self * -1) + other
+
+    def __pow__(self, power):
+        out = Tensor(self.data ** power, requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += out.grad * (power * (self.data ** (power - 1)))
+
+            out._backward = _backward
+        return out
+
+    def sum(self):
+        out = Tensor(self.data.sum(), requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += out.grad * np.ones_like(self.data)
+
+            out._backward = _backward
+        return out
+
+    def relu(self):
+        out = Tensor(
+            np.maximum(0, self.data),
+            requires_grad=self.requires_grad,
+            device=self.device,
+        )
+
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += out.grad * (self.data > 0)
+
+            out._backward = _backward
+
+        return out
+
+    def leaky_relu(self, alpha=0.01):
+        out_data = np.where(self.data > 0, self.data, self.data * alpha)
+        out = Tensor(out_data, requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    dx = np.where(self.data > 0, 1.0, alpha)
+                    self.grad += out.grad * dx
+
+            out._backward = _backward
+        return out
+
+    def sigmoid(self):
+        sig = 1.0 / (1.0 + np.exp(-np.clip(self.data, -50, 50)))
+        out = Tensor(sig, requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += out.grad * (sig * (1.0 - sig))
+
+            out._backward = _backward
+        return out
+
+    def tanh(self):
+        t = np.tanh(self.data)
+        out = Tensor(t, requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    self.grad += out.grad * (1.0 - t ** 2)
+
+            out._backward = _backward
+        return out
+
+    def gelu(self):
+        x = self.data
+        cdf = 0.5 * (1.0 + np.tanh(np.sqrt(2.0 / np.pi) * (x + 0.044715 * (x ** 3))))
+        out = Tensor(x * cdf, requires_grad=self.requires_grad, device=self.device)
+        if out.requires_grad:
+            out._prev = {self}
+
+            def _backward():
+                if self.requires_grad:
+                    if self.grad is None:
+                        self.grad = np.zeros_like(self.data, dtype=np.float32)
+                    pdf = np.exp(-0.5 * (x ** 2)) / np.sqrt(2.0 * np.pi)
+                    d_gelu = cdf + x * pdf
+                    self.grad += out.grad * d_gelu
+
+            out._backward = _backward
+        return out
+
+    def backward(self):
+        run_backward(self)
+
+
+# ⣇⣿⠘⣿⣿⣿⡿⡿⣟⣟⢟⢟⢝⠵⡝⣿⡿⢂⣼⣿⣷⣌⠩⡫⡻⣝⠹⢿⣿⣷
+# ⡆⣿⣆⠱⣝⡵⣝⢅⠙⣿⢕⢕⢕⢕⢝⣥⢒⠅⣿⣿⣿⡿⣳⣌⠪⡪⣡⢑⢝⣇
+# ⡆⣿⣿⣦⠹⣳⣳⣕⢅⠈⢗⢕⢕⢕⢕⢕⢈⢆⠟⠋⠉⠁⠉⠉⠁⠈⠼⢐⢕⢽
+# ⡗⢰⣶⣶⣦⣝⢝⢕⢕⠅⡆⢕⢕⢕⢕⢕⣴⠏⣠⡶⠛⡉⡉⡛⢶⣦⡀⠐⣕⢕
+# ⡝⡄⢻⢟⣿⣿⣷⣕⣕⣅⣿⣔⣕⣵⣵⣿⣿⢠⣿⢠⣮⡈⣌⠨⠅⠹⣷⡀⢱⢕
+# ⡝⡵⠟⠈⢀⣀⣀⡀⠉⢿⣿⣿⣿⣿⣿⣿⣿⣼⣿⢈⡋⠴⢿⡟⣡⡇⣿⡇⡀⢕
+# ⡝⠁⣠⣾⠟⡉⡉⡉⠻⣦⣻⣿⣿⣿⣿⣿⣿⣿⣿⣧⠸⣿⣦⣥⣿⡇⡿⣰⢗⢄
+# ⠁⢰⣿⡏⣴⣌⠈⣌⠡⠈⢻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣬⣉⣉⣁⣄⢖⢕⢕⢕
+# ⡀⢻⣿⡇⢙⠁⠴⢿⡟⣡⡆⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣵⣵⣿
+# ⡻⣄⣻⣿⣌⠘⢿⣷⣥⣿⠇⣿⣿⣿⣿⣿⣿⠛⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿
+# ⣷⢄⠻⣿⣟⠿⠦⠍⠉⣡⣾⣿⣿⣿⣿⣿⣿⢸⣿⣦⠙⣿⣿⣿⣿⣿⣿⣿⣿⠟
+# ⡕⡑⣑⣈⣻⢗⢟⢞⢝⣻⣿⣿⣿⣿⣿⣿⣿⠸⣿⠿⠃⣿⣿⣿⣿⣿⣿⡿⠁⣠
+# ⡝⡵⢟⢕⢕⢕⢕⣵⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣶⣿⣿⣿⣿⣿⠿⠋⣀⣈⠙
+# ⡝⡵⡕⡀⠑⠳⠿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⠿⠛⢉⡠⡲⡫⡪⡪⡣

pytinytensor-0.1.2/tinytensor/tinytensor/data/__init__.py

@@ -0,0 +1,5 @@
+from tinytensor.data.dataset import Dataset, TensorDataset
+from tinytensor.data.dataloader import DataLoader
+
+__all__ = ["Dataset", "TensorDataset", "DataLoader"]
+# для крастоы :3

pytinytensor-0.1.2/tinytensor/tinytensor/data/dataloader.py

@@ -0,0 +1,41 @@
+import numpy as np
+from tinytensor.core.tensor import Tensor
+
+class DataLoader:
+    def __init__(self, dataset, batch_size=32, shuffle=True):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+
+    def __len__(self):
+        #колво батчей за 1 эпоху
+        return (len(self.dataset) + self.batch_size - 1) // self.batch_size
+
+    def __iter__(self):
+        self.indices = np.arange(len(self.dataset))
+        
+        # перемешкиваем если шафл есть
+        if self.shuffle:
+            np.random.shuffle(self.indices)
+            
+        self.current_idx = 0
+        return self
+
+    def __next__(self):
+        # выдает след батч
+        # останавливаемся если дошли до конца датасета
+        if self.current_idx >= len(self.dataset):
+            raise StopIteration
+
+        batch_indices = self.indices[self.current_idx : self.current_idx + self.batch_size]
+        self.current_idx += self.batch_size
+
+        #cбор
+        batch_x, batch_y = [], []
+        for i in batch_indices:
+            x, y = self.dataset[i]
+            batch_x.append(x.data if isinstance(x, Tensor) else x)
+            batch_y.append(y.data if isinstance(y, Tensor) else y)
+
+        # батч в нампай и потом в тензо
+        return Tensor(np.array(batch_x)), Tensor(np.array(batch_y))

pytinytensor-0.1.2/tinytensor/tinytensor/data/dataset.py

@@ -0,0 +1,19 @@
+#влом коменты ставить тут и так все понятно
+class Dataset:
+    def __len__(self):
+        raise NotImplementedError
+    
+    def __getitem__(self, idx):
+        raise NotImplementedError
+
+class TensorDataset(Dataset):
+    def __init__(self, x, y):
+        assert len(x) == len(y)
+        self.x = x
+        self.y = y
+    
+    def __len__(self):
+        return len(self.x)
+
+    def __getitem__(self, idx):
+        return self.x[idx], self.y[idx]

pytinytensor-0.1.2/tinytensor/tinytensor/nn/activations.py

@@ -0,0 +1,36 @@
+from tinytensor.nn.modules import Module
+
+class ReLU(Module):
+    def forward(self, x):
+        return x.relu()
+
+class LeReLU(Module):
+    # у нас есть тут альфа
+    def __init__(self, alpha=0.01):
+        self.alpha = alpha
+    
+    def forward(self, x):
+        return x.leaky_relu(alpha=self.alpha)
+    
+class Sigmod(Module):
+    def forward(self, x):
+        return x.sigmoid()
+    
+class Tanh(Module):
+    def forward(self, x):
+        return x.tanh()
+    
+class GELU(Module):
+    def forward(self, x):
+        return x.gelu()
+
+
+
+
+# ToDo:
+# ReLU       [x]
+# LeReLU     [x]
+# Sigmoid    [x]
+# Tanh       [x]
+# GELU       [x]
+# kama soska

pytinytensor-0.1.2/tinytensor/tinytensor/nn/linear.py

@@ -0,0 +1,18 @@
+import numpy as np
+
+from tinytensor.core.tensor import Tensor
+from tinytensor.nn.modules import Module
+
+class Linear(Module):
+    def __init__(self,in_features, out_features):
+        super().__init__()
+        std = np.sqrt(2.0 / in_features)
+        weightd = np.random.randn(in_features, out_features).astype(np.float32) * std
+        self.weight = Tensor(weightd, requires_grad=True)
+
+        bias_d = np.zeros((1, out_features), dtype=np.float32)
+        self.bias = Tensor(bias_d, requires_grad=True)
+
+    def forward(self, x):
+        # кароч обычная формула y = x@w + b
+        return (x @ self.weight ) + self.bias

pytinytensor-0.1.2/tinytensor/tinytensor/nn/losses.py

@@ -0,0 +1,12 @@
+import numpy as np
+from tinytensor.nn.modules import Module
+# 1/n * sum((n, i = 1), yi - y`i)^2
+class MSELoss(Module):
+    def forward(self, y_pred, y_true):
+        diff = y_pred - y_true
+        sq_diff = diff ** 2
+        return sq_diff.sum() * (1.0/y_pred.data.size)
+
+
+
+# мб в будущем добавлю cross entropy loss  

pytinytensor-0.1.2/tinytensor/tinytensor/nn/modules.py

@@ -0,0 +1,64 @@
+from tinytensor.core.tensor import Tensor
+import pickle
+
+#кароч модуль от которого будут наследоваться все слои
+class Module:
+    def __init__(self):
+        self.training = True
+    
+    def __call__(self, *args, **kwargs):
+        return self.forward(*args, **kwargs)
+
+    #щас это просто заглушка для прямого вызова, а в реале у всех должны быть свои реализации forward, так что это роль не играет
+    def forward(self, *args, **kwargs):
+        raise NotImplementedError(...)
+
+    # сохраняет обучаемые веса, и если в модуле есть еще какие то модули то он их тоже открывает 
+    def parameters(self):
+        params = []
+        for atr in self.__dict__.values():
+            if isinstance(atr, Tensor) and atr.requires_grad == True:
+                params.append(atr)
+
+            elif isinstance(atr, Module):
+                params.extend(atr.parameters())
+        return params
+
+    #обнуляет градиенты
+    def zero_grad(self):
+        for atr in self.parameters():
+            atr.grad = None
+        
+    def state_dict(self):
+        #вытащим все веса параметров
+        sdict = {}
+        for name, param in self._get_named_params().items():
+            sdict[name] = param.data
+        return sdict
+        
+    def load_state_dict(self, sdict):
+        #запихиваем обратно
+        for name, param in self._get_named_params().items():
+            if name in sdict:
+                param.data = sdict[name] 
+
+    def _get_named_params(self, prefix=""):
+        named = {}
+        for attr_name, attr in self.__dict__.items():
+            key = f"{prefix}.{attr_name}" if prefix else attr_name
+            if isinstance(attr, Tensor):
+                named[key] = attr
+            elif isinstance(attr, Module):
+                named.update(attr._get_named_params(prefix=key))
+        return named 
+    
+    #сохранение модели
+    def save(self,filepath):
+        with open(filepath, "wb") as f:
+            pickle.dump(self.state_dict(), f)
+
+    # загрузка весов обратно
+    def load(self, filepath):
+        with open(filepath, "rb") as f:
+            sd = pickle.load(f)
+            self.load_state_dict(sd)

pytinytensor-0.1.2/tinytensor/tinytensor/optim/__init__.py

@@ -0,0 +1,11 @@
+from tinytensor.optim.optimizer import Optimizer, SGD, AdamW
+
+__all__ = ["Optimizer", "SGD", "AdamW"]
+
+#эт для удобства
+#чтоб можно было писать вот так:
+"""
+from tinytensor.optim import AdamW
+
+optimizer = AdamW(model.parameters(), lr=1e-3)
+"""

pytinytensor-0.1.2/tinytensor/tinytensor/optim/optimizer.py

@@ -0,0 +1,72 @@
+# я допил свой чай, теперь хочу еще но мне лень вставать
+import numpy as np
+
+class Optimizer:
+    def __init__ (self, parameters):
+        # в лист если через генератор model параметры выдано
+        self.parameters = list(parameters)
+
+    def step(self):
+        #у каждого свой
+        raise NotImplementedError
+
+    def zero_grad(self):
+        for p in self.parameters:
+            p.grad = None
+
+# SGD 
+# w = w - lr*dw
+class SGD(Optimizer):
+    def __init__(self, parameters, lr = 0.01, momentum = 0.0):
+        super().__init__(parameters)
+        self.lr = lr
+        self.momentum = momentum
+        # буфера
+        self.velocities = [np.zeros_like(p.data) for p in self.parameters] if momentum > 0 else None
+
+    def step(self):
+        for i,p in enumerate(self.parameters):
+            if p.grad is None:
+                continue
+            grad = p.grad
+
+            if self.momentum>0:
+                self.velocities[i] = self.momentum * self.velocities[i] + grad
+                grad = self.velocities[i]
+            # шаг
+            p.data -= self.lr * grad
+
+
+
+#Adamw
+# слишком много формул мне впадлу писать
+class AdamW(Optimizer):
+    def __init__(self, parameters, lr=0.001, betas=(0.9, 0.999), eps=1e-8, weight_decay=0.01):
+        super().__init__(parameters)
+        self.lr = lr
+        self.beta1, self.beta2 = betas
+        self.eps = eps
+        self.weight_decay = weight_decay
+        
+        self.t = 0
+
+        self.m = [np.zeros_like(p.data) for p in self.parameters]
+        self.v = [np.zeros_like(p.data) for p in self.parameters]
+    
+    def step(self):
+        self.t += 1
+
+        for i, p in enumerate(self.parameters):
+            if p.grad is None:
+                continue
+
+            grad = p.grad
+            # обновка m и v мометы
+            self.m[i] = self.beta1 * self.m[i] + (1.0 - self.beta1) * grad
+            self.v[i] = self.beta2 * self.v[i] + (1.0 - self.beta2) * (grad ** 2)
+            # корекция баяса
+            m_hat = self.m[i] / (1.0 - self.beta1 ** self.t)
+            v_hat = self.v[i] / (1.0 - self.beta2 ** self.t)
+            # адапт шаг и разделение затухания весов
+            denom = np.sqrt(v_hat) + self.eps
+            p.data -= self.lr * (m_hat / denom + self.weight_decay * p.data)

pytinytensor-0.1.2/tinytensor/utils/__init__.py

@@ -0,0 +1,4 @@
+from tinytensor.utils.bar import progress_bar, train_bar
+from tinytensor.utils.early_stopping import EarlyStopping
+__all__ = ["progress_bar", "train_bar",
+           "EarlyStopping"]

pytinytensor-0.1.2/tinytensor/utils/bar.py

@@ -0,0 +1,26 @@
+import time
+
+
+def progress_bar(iterable, prefix="", length=30):
+    total = len(iterable)
+    start_time = time.time()
+    for i, item in enumerate(iterable):
+        yield item  # ИСПРАВЛЕНО: возвращаем элемент, а не модуль time
+        percent = (i + 1) / total
+        filled = int(length * percent)
+        bar = "█" * filled + "-" * (length - filled)
+        elapsed = time.time() - start_time
+
+        print(f"\r{prefix} |{bar}| {percent*100:.1f}% [{elapsed:.1f}s]", end="")
+    print()
+
+
+#алиас для тех кто привык train_bar писать
+train_bar = progress_bar
+
+
+"""
+пользоваться надо крч вот так:
+for epoch in train_bar(range(100), prefix="обучение"):
+    ...
+"""

pytinytensor-0.1.2/tinytensor/utils/early_stopping.py

@@ -0,0 +1,64 @@
+import copy
+
+
+class EarlyStopping:
+    def __init__(self, model, patience=5, min_delta=0.0, restore_best_weights=True):
+        self.model = model
+        self.patience = patience
+        self.min_delta = min_delta
+        self.restore_best_weights = restore_best_weights
+
+        self.counter = 0
+        self.best_loss = None
+        self.early_stop = False
+        self.best_state_dict = None
+
+    def __call__(self, val_loss):
+        if hasattr(val_loss, "data"):
+            val_loss = float(val_loss.data)
+
+        #если это была первая эпоха
+        if self.best_loss is None:
+            self.best_loss = val_loss
+            self._save_checkpoint()
+
+        elif val_loss < self.best_loss - self.min_delta:
+            self.best_loss = val_loss
+            self.counter = 0
+            self._save_checkpoint()
+
+        else:
+            self.counter += 1
+            if self.counter >= self.patience:
+                self.early_stop = True
+                if self.restore_best_weights and self.best_state_dict is not None:
+                    # восстанавливаем лучшие веса
+                    self.model.load_state_dict(self.best_state_dict)
+
+        return self.early_stop
+
+    def _save_checkpoint(self): 
+        if self.restore_best_weights and hasattr(self.model, "state_dict"):
+            self.best_state_dict = copy.deepcopy(self.model.state_dict())
+
+
+'''пример кода
+
+from tinytensor.utils import EarlyStopping
+
+model = MLP()
+early_stopping = EarlyStopping(model, patience=7, min_delta=0.01)
+
+for epoch in range(100):
+    #обучение
+    train_loss = train_one_epoch(model)
+
+    #валидация
+    val_loss = evaluate(model)
+
+    #проверка остановки
+    if early_stopping(val_loss):
+        print(f"обучение прекратилось на эпохе {epoch+1}")
+        break
+
+'''