pytinytensor 0.1.0__tar.gz

pytinytensor-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pytinytensor
+Version: 0.1.0
+Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.23
+Requires-Dist: pybind11>=2.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

pytinytensor-0.1.0/README.md

@@ -0,0 +1,203 @@
+# tinytensor
+
+Маленький самописный autograd на numpy. Тензоры, backprop, пара слоев,
+лоссы, оптимизаторы и даталоадер. По сути свой мини-pytorch, только без
+плюшек и без cuda (пока).
+
+Никакой производительности тут не ищите, тут просто видно как все
+устроено внутри, без магии.
+
+## Содержание
+
+- [Установка](#установка)
+- [Быстрый старт](#быстрый-старт)
+- [Как работает autograd](#как-работает-autograd)
+- [API](#api)
+- [Примеры](#примеры)
+- [Тесты](#тесты)
+- [Структура](#структура)
+- [Чего нет](#чего-нет)
+- [Ссылки](#ссылки)
+
+## Установка
+
+```bash
+git clone https://github.com/IbrokhimN/tinytensor
+cd tinytensor
+pip install -e .          # обычная установка
+pip install -e .[dev]     # плюс pytest, если хотите гонять тесты
+```
+
+Или руками:
+
+```bash
+pip install -r requirements.txt
+```
+
+Зависимость одна - numpy.
+
+## Быстрый старт
+
+```python
+from tinytensor.core.tensor import Tensor
+from tinytensor.nn.linear import Linear
+from tinytensor.nn.losses import MSELoss
+from tinytensor.optim import SGD
+
+model = Linear(in_features=1, out_features=1)
+loss_fn = MSELoss()
+optimizer = SGD(model.parameters(), lr=0.01)
+
+x = Tensor([[1.0], [2.0], [3.0]])
+y = Tensor([[3.0], [5.0], [7.0]])   # y = 2x + 1
+
+for epoch in range(100):
+    optimizer.zero_grad()
+    pred = model(x)
+    loss = loss_fn(pred, y)
+    loss.backward()
+    optimizer.step()
+
+print(model.weight.data, model.bias.data)  # ~2.0, ~1.0
+```
+
+Рабочие примеры целиком лежат в [`examples/`](examples/).
+
+## Как работает autograd
+
+У каждого `Tensor` есть:
+
+- `data` - сами значения (numpy-массив, всегда float32);
+- `grad` - градиент, пока не посчитан - None;
+- `_prev` - от каких тензоров он произошел (родители в графе);
+- `_backward` - функция которая знает как раскидать градиент на родителей.
+
+Когда считаете `z = f(x, y)`, по цепному правилу:
+
+```
+dL/dx = dL/dz * dz/dx
+dL/dy = dL/dz * dz/dy
+```
+
+`backward()` строит топологический порядок графа (`tinytensor/core/autograd.py`),
+ставит корню градиент = 1 и идет в обратном порядке, вызывая `_backward()`
+у каждого узла. Ровно так же устроен micrograd Карпатова, только у него
+даже покомпактнее:
+
+- [Karpathy - micrograd](https://github.com/karpathy/micrograd) - реализация того же самого на ~100 строк, must see
+- [CS231n: Backpropagation, Intuitions](https://cs231n.github.io/optimization-2/) - если нужно разложить backprop по полочкам
+- [colah - Calculus on Computational Graphs](https://colah.github.io/posts/2015-08-Backprop/)
+
+Если совсем в тему - есть видос Карпатова где он с нуля пишет micrograd и
+объясняет каждую строчку: ["The spelled-out intro to neural networks and backpropagation"](https://www.youtube.com/watch?v=VMj-3S1tku0).
+Собственно тут все то же самое, только на numpy и чуть пошире.
+
+### Формулы, которые реализованы в Tensor
+
+| операция | вперед | производная |
+|---|---|---|
+| `a + b` | `a + b` | `dL/da += dL/dz`, `dL/db += dL/dz` (плюс схлопывание по broadcast-осям) |
+| `a * b` | `a * b` | `dL/da += dL/dz * b`, `dL/db += dL/dz * a` |
+| `a @ b` | matmul | `dL/da += dL/dz @ bᵀ`, `dL/db += aᵀ @ dL/dz` |
+| `a ** p` | `aᵖ` | `dL/da += dL/dz * p * a^(p-1)` |
+| ReLU | `max(0, x)` | 1 при x>0, иначе 0 |
+| LeakyReLU | x или αx | 1 при x>0, иначе α |
+| sigmoid | `1/(1+e⁻ˣ)` | `σ(x)*(1-σ(x))` |
+| tanh | `tanh(x)` | `1 - tanh²(x)` |
+| GELU | `0.5x(1+tanh(√(2/π)(x+0.044715x³)))` | см. [статью по GELU](https://arxiv.org/abs/1606.08415), формула там не самая короткая |
+
+Про broadcasting и почему градиент иногда надо досуммировать обратно
+(`_unbroadcast`) норм объясняют [правила broadcasting в numpy](https://numpy.org/doc/stable/user/basics.broadcasting.html).
+
+## API
+
+### Tensor
+
+`tinytensor.core.tensor.Tensor` - главный класс. Есть `+ - * @ **`, `.sum()`,
+активации `relu / leaky_relu / sigmoid / tanh / gelu`, ну и `.backward()`.
+
+### nn
+
+- `Module` - от него наследуются все слои, `forward / parameters() / zero_grad()`, по духу как [`torch.nn.Module`](https://pytorch.org/docs/stable/generated/torch.nn.Module.html);
+- `Linear(in_features, out_features)` - обычный `y = xW + b`, веса инициализируются по [He/Kaiming init](https://arxiv.org/abs/1502.01852) (`std = sqrt(2/in_features)`);
+- `ReLU, LeReLU, Sigmod, Tanh, GELU` - тонкие обертки над методами Tensor;
+- `MSELoss` - `mean((pred - target)^2)`, банальщина.
+
+### optim
+
+- `SGD(params, lr, momentum=0.0)` - обычный градиентный спуск, можно с моментом;
+- `AdamW(params, lr, betas, eps, weight_decay)` - Adam с отдельным weight decay, см. [Loshchilov & Hutter](https://arxiv.org/abs/1711.05101) (в отличие от обычного [Adam](https://arxiv.org/abs/1412.6980), decay тут не лезет в градиент, а сразу режет веса).
+
+### data
+
+- `Dataset / TensorDataset` - обертка над (x, y);
+- `DataLoader` - бьет на батчи, можно с shuffle, мини-версия [`torch.utils.data.DataLoader`](https://pytorch.org/docs/stable/data.html).
+
+## Примеры
+
+- [`examples/01_linear_regression.py`](examples/01_linear_regression.py) - линейная регрессия, Linear + MSELoss + SGD на `y = 3x + 2 + шум`.
+- [`examples/02_mnist_mlp.py`](examples/02_mnist_mlp.py) - MLP (Linear -> ReLU -> Linear) с AdamW и DataLoader на синтетике в формате mnist (784 фичи, 10 классов). Настоящего mnist и загрузчиков датасетов тут нет, лень было тащить.
+
+Как выглядит запуск вживую:
+
+```
+$ python3 01_linear_regression.py
+epoch   0 | loss 30.8016
+epoch 180 | loss 0.2365
+выученные параметры: weight ~ 2.995, bias ~ 1.996
+
+$ python3 02_mnist_mlp.py
+epoch 1/5 | avg loss 2.0998
+epoch 5/5 | avg loss 0.0481
+```
+
+## Тесты
+
+```bash
+pip install -e .[dev]
+python3 -m pytest tests/ -v
+```
+
+47 штук, гоняют арифметику тензоров и broadcasting, autograd (накопление
+градиента, топология, повторный backward), лоссы, оптимизаторы и
+Dataset/DataLoader.
+
+> Важно: запускать через pytest из корня репы (или после `pip install -e .`),
+> а не `python3 test_x.py` из папки tests - иначе tinytensor просто не найдется.
+
+## Структура
+
+```
+tinytensor/
+├── tinytensor/
+│   ├── core/        # Tensor, autograd, ops
+│   ├── nn/          # Module, Linear, активации, MSELoss
+│   ├── optim/        # SGD, AdamW
+│   ├── data/         # Dataset, DataLoader
+│   ├── backends/     # заготовка под cuda, пока пусто
+│   └── config.py     # сид рандома
+├── examples/
+├── tests/
+├── setup.py
+└── requirements.txt
+```
+
+## Чего нет
+
+- Только numpy-backend, cuda_gpu.py пустой файл-заглушка.
+- Нет кросс-энтропии, сверток, рекуррентных слоев, сохранения модели (см. ToDo в исходном плане проекта).
+- backward не кэширует граф между вызовами, каждый раз строит топологию заново, как и в micrograd - никакой лени в духе pytorch тут нет.
+
+## Ссылки
+
+- [Andrej Karpathy - micrograd (GitHub)](https://github.com/karpathy/micrograd) - основной референс для всего autograd
+- [Andrej Karpathy - видео про backprop и micrograd](https://www.youtube.com/watch?v=VMj-3S1tku0)
+- [CS231n - Backpropagation, Intuitions](https://cs231n.github.io/optimization-2/)
+- [colah - Calculus on Computational Graphs](https://colah.github.io/posts/2015-08-Backprop/)
+- [NumPy broadcasting rules](https://numpy.org/doc/stable/user/basics.broadcasting.html)
+- [He et al. - инициализация весов](https://arxiv.org/abs/1502.01852)
+- [Kingma & Ba - Adam](https://arxiv.org/abs/1412.6980)
+- [Loshchilov & Hutter - AdamW](https://arxiv.org/abs/1711.05101)
+- [Hendrycks & Gimpel - GELU](https://arxiv.org/abs/1606.08415)
+- [PyTorch - torch.nn.Module](https://pytorch.org/docs/stable/generated/torch.nn.Module.html)
+- [PyTorch - torch.utils.data.DataLoader](https://pytorch.org/docs/stable/data.html)

pytinytensor-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=61", "wheel", "pybind11>=2.10"]
+build-backend = "setuptools.build_meta"

pytinytensor-0.1.0/pytinytensor.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.4
+Name: pytinytensor
+Version: 0.1.0
+Summary: мини ИИ фреймворк от IbrokimN ( github/IbrokhimN )
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.23
+Requires-Dist: pybind11>=2.10
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

pytinytensor-0.1.0/pytinytensor.egg-info/SOURCES.txt

@@ -0,0 +1,37 @@
+README.md
+pyproject.toml
+setup.py
+pytinytensor.egg-info/PKG-INFO
+pytinytensor.egg-info/SOURCES.txt
+pytinytensor.egg-info/dependency_links.txt
+pytinytensor.egg-info/requires.txt
+pytinytensor.egg-info/top_level.txt
+tests/test_autograd.py
+tests/test_data.py
+tests/test_losses.py
+tests/test_nn.py
+tests/test_optim.py
+tests/test_tensor_math.py
+tinytensor/__init__.py
+tinytensor/config.py
+tinytensor/backends/__init__.py
+tinytensor/backends/cpu_numpy.py
+tinytensor/backends/cuda_binding.cpp
+tinytensor/backends/cuda_gpu.cu
+tinytensor/core/__init__.py
+tinytensor/core/autograd.py
+tinytensor/core/ops.py
+tinytensor/core/tensor.py
+tinytensor/data/__init__.py
+tinytensor/data/dataloader.py
+tinytensor/data/dataset.py
+tinytensor/nn/__init__.py
+tinytensor/nn/activations.py
+tinytensor/nn/linear.py
+tinytensor/nn/losses.py
+tinytensor/nn/modules.py
+tinytensor/optim/__init__.py
+tinytensor/optim/optimizer.py
+tinytensor/utils/__init__.py
+tinytensor/utils/bar.py
+tinytensor/utils/early_stopping.py

pytinytensor-0.1.0/pytinytensor.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pytinytensor-0.1.0/pytinytensor.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=1.23
+pybind11>=2.10
+
+[dev]
+pytest>=7.0

pytinytensor-0.1.0/pytinytensor.egg-info/top_level.txt

@@ -0,0 +1 @@
+tinytensor

pytinytensor-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytinytensor-0.1.0/setup.py

@@ -0,0 +1,81 @@
+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):
+            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':
+                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:
+                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',
+            'tinytensor/backends/cuda_binding.cpp'
+        ],
+        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="pytinytensor",
+    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.0/tests/test_autograd.py

@@ -0,0 +1,59 @@
+import numpy as np
+
+from tinytensor.core.tensor import Tensor
+
+
+def test_backward_sets_grad_of_ones_on_root():
+    a = Tensor([1.0, 2.0], requires_grad=True)
+    out = a.sum()
+    out.backward()
+    assert out.grad == np.float32(1.0)
+
+
+def test_no_grad_when_requires_grad_false():
+    a = Tensor([1.0, 2.0], requires_grad=False)
+    b = Tensor([3.0, 4.0], requires_grad=False)
+    c = a + b
+    assert c.requires_grad is False
+    assert c.grad is None  # backward не должен считаться вообще
+
+
+def test_diamond_graph_accumulates_gradients():
+    x = Tensor([3.0], requires_grad=True)
+    y = x + x
+    y.backward()
+    assert np.allclose(x.grad, [2.0])
+
+
+def test_chain_of_relu_and_sum():
+    x = Tensor([-1.0, 2.0, -3.0, 4.0], requires_grad=True)
+    out = x.relu().sum()
+    out.backward()
+    # градиент 1 там где x>0, иначе 0
+    assert np.allclose(x.grad, [0.0, 1.0, 0.0, 1.0])
+
+
+def test_gradients_accumulate_across_multiple_backward_calls():
+    x = Tensor([2.0], requires_grad=True)
+    y = x.relu()
+    y.backward()
+    y2 = x.relu()
+    y2.backward()
+    assert np.allclose(x.grad, [2.0])
+
+
+def test_backward_only_computed_once_per_node():
+    calls = {"n": 0}
+    x = Tensor([1.0, 2.0], requires_grad=True)
+    mid = x.relu()
+
+    original = mid._backward
+
+    def counted():
+        calls["n"] += 1
+        original()
+
+    mid._backward = counted
+    out = mid.sum()
+    out.backward()
+    assert calls["n"] == 1

pytinytensor-0.1.0/tests/test_data.py

@@ -0,0 +1,48 @@
+import numpy as np
+
+from tinytensor.data import TensorDataset, DataLoader
+
+
+def make_dataset(n=10):
+    x = np.arange(n).reshape(n, 1).astype(np.float32)
+    y = (np.arange(n) * 2).astype(np.float32)
+    return TensorDataset(x, y)
+
+
+def test_tensor_dataset_len_and_getitem():
+    ds = make_dataset(5)
+    assert len(ds) == 5
+    x, y = ds[2]
+    assert x[0] == 2.0
+    assert y == 4.0
+
+
+def test_dataloader_batches_cover_full_dataset():
+    ds = make_dataset(10)
+    loader = DataLoader(ds, batch_size=3, shuffle=False)
+    seen = 0
+    for xb, yb in loader:
+        seen += xb.shape[0]
+    assert seen == 10
+
+
+def test_dataloader_len_is_ceil_division():
+    ds = make_dataset(10)
+    loader = DataLoader(ds, batch_size=3)
+    assert len(loader) == 4  # ceil(10/3)
+
+
+def test_dataloader_last_batch_smaller():
+    ds = make_dataset(10)
+    loader = DataLoader(ds, batch_size=3, shuffle=False)
+    batches = list(loader)
+    assert batches[-1][0].shape[0] == 1  # 10 = 3+3+3+1
+
+
+def test_dataloader_shuffle_changes_order_with_fixed_seed():
+    ds = make_dataset(20)
+    np.random.seed(0)
+    loader = DataLoader(ds, batch_size=20, shuffle=True)
+    xb, _ = next(iter(loader))
+    order = xb.data.flatten()
+    assert not np.array_equal(order, np.arange(20))  # почти наверняка перемешано

pytinytensor-0.1.0/tests/test_losses.py

@@ -0,0 +1,31 @@
+import numpy as np
+import pytest
+
+from tinytensor.core.tensor import Tensor
+from tinytensor.nn.losses import MSELoss
+
+
+def test_mse_forward_matches_manual_formula():
+    y_pred = Tensor([1.0, 2.0, 3.0])
+    y_true = Tensor([1.5, 2.5, 2.0])
+    loss = MSELoss()(y_pred, y_true)
+
+    expected = np.mean((y_pred.data - y_true.data) ** 2)
+    assert loss.data == pytest.approx(expected, abs=1e-5)
+
+
+def test_mse_zero_when_predictions_match():
+    y_pred = Tensor([1.0, 2.0, 3.0])
+    y_true = Tensor([1.0, 2.0, 3.0])
+    loss = MSELoss()(y_pred, y_true)
+    assert loss.data == pytest.approx(0.0, abs=1e-6)
+
+
+def test_mse_backward_gives_gradient_wrt_prediction():
+    y_pred = Tensor([2.0, 4.0], requires_grad=True)
+    y_true = Tensor([0.0, 0.0])
+    loss = MSELoss()(y_pred, y_true)
+    loss.backward()
+    # d(mean((p-t)^2))/dp = 2*(p-t)/n
+    expected_grad = 2 * (y_pred.data - y_true.data) / y_pred.data.size
+    assert np.allclose(y_pred.grad, expected_grad, atol=1e-5)

pytinytensor-0.1.0/tests/test_nn.py

@@ -0,0 +1,91 @@
+import numpy as np
+
+from tinytensor.core.tensor import Tensor
+from tinytensor.nn.modules import Module
+from tinytensor.nn.linear import Linear
+from tinytensor.nn.activations import ReLU, LeReLU, Sigmod, Tanh, GELU
+
+
+def test_module_parameters_collects_only_requires_grad_tensors():
+    class Dummy(Module):
+        def __init__(self):
+            super().__init__()
+            self.w = Tensor([1.0], requires_grad=True)
+            self.const = Tensor([2.0], requires_grad=False)
+
+    m = Dummy()
+    params = m.parameters()
+    assert len(params) == 1
+    assert params[0] is m.w
+
+
+def test_module_parameters_recurse_into_submodules():
+    class Inner(Module):
+        def __init__(self):
+            super().__init__()
+            self.w = Tensor([1.0], requires_grad=True)
+
+    class Outer(Module):
+        def __init__(self):
+            super().__init__()
+            self.inner = Inner()
+            self.b = Tensor([2.0], requires_grad=True)
+
+    m = Outer()
+    assert len(m.parameters()) == 2
+
+
+def test_module_zero_grad():
+    class Dummy(Module):
+        def __init__(self):
+            super().__init__()
+            self.w = Tensor([1.0], requires_grad=True)
+
+    m = Dummy()
+    m.w.grad = np.array([9.0], dtype=np.float32)
+    m.zero_grad()
+    assert m.w.grad is None
+
+
+def test_linear_forward_shape():
+    layer = Linear(in_features=4, out_features=3)
+    x = Tensor(np.random.randn(5, 4))
+    out = layer(x)
+    assert out.shape == (5, 3)
+
+
+def test_linear_has_weight_and_bias_as_params():
+    layer = Linear(3, 2)
+    params = layer.parameters()
+    assert len(params) == 2  # weight + bias
+    assert layer.weight.shape == (3, 2)
+    assert layer.bias.shape == (1, 2)
+
+
+def test_relu_module_matches_tensor_method():
+    x = Tensor([-1.0, 2.0])
+    assert np.allclose(ReLU()(x).data, x.relu().data)
+
+
+def test_leaky_relu_module():
+    x = Tensor([-2.0, 3.0])
+    out = LeReLU(alpha=0.2)(x)
+    assert np.allclose(out.data, [-0.4, 3.0])
+
+
+def test_sigmoid_module():
+    x = Tensor([0.0])
+    out = Sigmod()(x)
+    assert np.allclose(out.data, [0.5])
+
+
+def test_tanh_module():
+    x = Tensor([0.0])
+    out = Tanh()(x)
+    assert np.allclose(out.data, [0.0])
+
+
+def test_gelu_module():
+    x = Tensor([0.0])
+    out = GELU()(x)
+    assert np.allclose(out.data, [0.0], atol=1e-5)

pytinytensor-0.1.0/tests/test_optim.py

@@ -0,0 +1,63 @@
+import numpy as np
+
+from tinytensor.core.tensor import Tensor
+from tinytensor.optim import SGD, AdamW
+
+
+def test_sgd_step_moves_against_gradient():
+    p = Tensor([1.0, 1.0], requires_grad=True)
+    p.grad = np.array([1.0, 2.0], dtype=np.float32)
+    opt = SGD([p], lr=0.1)
+    opt.step()
+    assert np.allclose(p.data, [0.9, 0.8])
+
+
+def test_sgd_zero_grad_resets_to_none():
+    p = Tensor([1.0], requires_grad=True)
+    p.grad = np.array([5.0], dtype=np.float32)
+    opt = SGD([p], lr=0.1)
+    opt.zero_grad()
+    assert p.grad is None
+
+
+def test_sgd_momentum_accumulates_velocity():
+    p = Tensor([0.0], requires_grad=True)
+    opt = SGD([p], lr=1.0, momentum=0.9)
+
+    p.grad = np.array([1.0], dtype=np.float32)
+    opt.step()
+    first = p.data.copy()
+
+    p.grad = np.array([1.0], dtype=np.float32)
+    opt.step()
+    #второй шаг должен быть больше первого изза накопленной скорости
+    assert abs(p.data[0] - first[0]) > 1.0
+
+
+def test_sgd_skips_params_without_grad():
+    p1 = Tensor([1.0], requires_grad=True)
+    p2 = Tensor([1.0], requires_grad=True)
+    p1.grad = np.array([1.0], dtype=np.float32)
+    p2.grad = None  # градиент не считался
+    opt = SGD([p1, p2], lr=0.1)
+    opt.step()
+    assert p2.data[0] == 1.0  # не изменился
+
+
+def test_adamw_step_changes_parameters():
+    p = Tensor([1.0, -1.0], requires_grad=True)
+    p.grad = np.array([0.5, -0.5], dtype=np.float32)
+    opt = AdamW([p], lr=0.1)
+    before = p.data.copy()
+    opt.step()
+    assert not np.allclose(p.data, before)
+    assert opt.t == 1
+
+
+def test_adamw_multiple_steps_reduce_simple_quadratic():
+    p = Tensor([5.0], requires_grad=True)
+    opt = AdamW([p], lr=0.5)
+    for _ in range(50):
+        p.grad = 2.0 * p.data
+        opt.step()
+    assert abs(p.data[0]) < abs(5.0)