pytinytensor 0.1.2__tar.gz → 0.1.3__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytinytensor
-Version: 0.1.2
+Version: 0.1.3
 Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
 Home-page: https://github.com/IbrokhimN/tinytensor
 Author: IbrokhimN

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytinytensor
-Version: 0.1.2
+Version: 0.1.3
 Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
 Home-page: https://github.com/IbrokhimN/tinytensor
 Author: IbrokhimN

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

@@ -15,7 +15,6 @@ 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
@@ -30,32 +29,12 @@ tinytensor/data/dataloader.py
 tinytensor/data/dataset.py
 tinytensor/nn/__init__.py
 tinytensor/nn/activations.py
+tinytensor/nn/dropout.py
 tinytensor/nn/linear.py
 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 → pytinytensor-0.1.3}/setup.py

@@ -113,7 +113,7 @@ else:
 
 setup(
     name="pytinytensor",
-    version="0.1.2",
+    version="0.1.3",
     description="мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )",
     long_description=long_description,
     long_description_content_type="text/markdown",

{pytinytensor-0.1.2/tinytensor → pytinytensor-0.1.3}/tinytensor/nn/activations.py

@@ -7,6 +7,7 @@ class ReLU(Module):
 class LeReLU(Module):
     # у нас есть тут альфа
     def __init__(self, alpha=0.01):
+        super().__init__()
         self.alpha = alpha
     
     def forward(self, x):

pytinytensor-0.1.3/tinytensor/nn/dropout.py

@@ -0,0 +1,23 @@
+#функция дропаута это короче нужно чтоб вырубать нейроны во время обучения чтоб остальные нейроны обучились хорошо тоже
+
+import numpy as np
+from tinytensor.nn.modules import Module
+from tinytensor.core.tensor import Tensor
+
+class Dropout(Module):
+    def __init__(self, p=0.5):
+        super().__init__()
+        # p это вероятност типа 0.5 это половина нейронов вырубается
+        self.p = p
+
+    def forward(self, x):
+        # если не обучаемся то скип
+        if not self.training or self.p == 0:
+            return x
+        mask_data = (np.random.rand(*x.data.shape) > self.p) / (1.0 - self.p)
+        
+        #маску в тензор превращаем
+        mask = Tensor(mask_data, requires_grad=False)
+
+        #тк маска состоит из 0 и 1 умножение как раз некоторые нейроны вырубит
+        return x * mask

{pytinytensor-0.1.2/tinytensor → pytinytensor-0.1.3}/tinytensor/nn/modules.py

@@ -1,6 +1,5 @@
 from tinytensor.core.tensor import Tensor
 import pickle
-
 #кароч модуль от которого будут наследоваться все слои
 class Module:
     def __init__(self):
@@ -8,27 +7,31 @@ class Module:
     
     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 train(self, mode=True):
+        self.training = mode
+        for atr in self.__dict__.values():
+            if isinstance(atr, Module):
+                atr.train(mode)
+        return self
+    def eval(self):
+        return self.train(False)
     def state_dict(self):
         #вытащим все веса параметров
         sdict = {}
@@ -41,7 +44,6 @@ class Module:
         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():
@@ -56,7 +58,6 @@ class Module:
     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:

{pytinytensor-0.1.2/tinytensor → pytinytensor-0.1.3}/tinytensor/optim/optimizer.py

@@ -17,27 +17,30 @@ class Optimizer:
 # SGD 
 # w = w - lr*dw
 class SGD(Optimizer):
-    def __init__(self, parameters, lr = 0.01, momentum = 0.0):
+    def __init__(self, parameters, lr = 0.01, momentum = 0.0, weight_decay = 0.0):
         super().__init__(parameters)
         self.lr = lr
         self.momentum = momentum
+        self.weight_decay = weight_decay
         # буфера
         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):
+        for i, p in enumerate(self.parameters):
             if p.grad is None:
                 continue
-            grad = p.grad
+            grad = p.grad  
+            if self.weight_decay != 0:
+                grad = grad + self.weight_decay * p.data
 
-            if self.momentum>0:
+            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):
@@ -69,4 +72,8 @@ class AdamW(Optimizer):
             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)
+            
+            if self.weight_decay != 0:
+                p.data -= self.lr * self.weight_decay * p.data
+
+            p.data -= self.lr * (m_hat / denom)

pytinytensor-0.1.2/tinytensor/nn/activations.py

@@ -1,36 +0,0 @@
-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/nn/modules.py

@@ -1,63 +0,0 @@
-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
-        
-    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, "wb") as f:
-            sd = pickle.load(f)
-            self.load_state_dict(sd)

pytinytensor-0.1.2/tinytensor/optim/optimizer.py

@@ -1,72 +0,0 @@
-# я допил свой чай, теперь хочу еще но мне лень вставать
-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/setup.py

@@ -1,81 +0,0 @@
-import os
-import subprocess
-import pybind11
-from setuptools import setup, find_packages, Extension
-from setuptools.command.build_ext import build_ext
-
-def check_cuda():
-    try:
-        subprocess.check_output(["nvcc", "--version"])
-        return True
-    except (FileNotFoundError, subprocess.CalledProcessError):
-        return False
-
-class CUDABuildExt(build_ext):
-    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
-        super().build_extensions()
-
-ext_modules = []
-
-if check_cuda():
-    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=['/usr/local/cuda/lib64'],
-        libraries=['cudart', 'cublas'],
-        extra_compile_args={
-            'gcc': ['-O3', '-fPIC', '-std=c++17'],
-            'nvcc': ['-O3', '-Xcompiler', '-fPIC']
-        }
-    )
-    ext_modules.append(cuda_module)
-    print("🔥 CUDA найдена! Собираем cuBLAS бэкенд...")
-else:
-    print("⚠️ CUDA не найдена. Сборка продолжится на CPU (NumPy).")
-
-setup(
-    name="tinytensor",
-    version="0.1.0",
-    description="мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )",
-    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.2/tinytensor/tinytensor/config.py

@@ -1,20 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

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

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

@@ -1,288 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,19 +0,0 @@
-#влом коменты ставить тут и так все понятно
-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/linear.py

@@ -1,18 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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/optim/__init__.py

@@ -1,11 +0,0 @@
-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/utils/__init__.py

@@ -1,4 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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
-
-'''