dongik 0.1.0__tar.gz

dongik-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,32 @@
+name: Publish to PyPI
+
+on:
+    push:
+        tags:
+          - 'v*'
+
+jobs:
+    deploy:
+        runs-on: ubuntu-latest
+
+        steps:
+            -   name: Checkout code
+                uses: actions/checkout@v4
+
+            -   name: Set up uv
+                uses: astral-sh/setup-uv@v5
+                with:
+                    enable-cache: true
+
+            -   name: Set up Python
+                uses: actions/setup-python@v5
+                with:
+                    python-version: '3.11'
+
+            -   name: Build package distributions
+                run: uv build
+
+            -   name: Publish package to PyPI
+                uses: pypa/gh-action-pypi-publish@release/v1
+                with:
+                    password: ${{ secrets.PYPI_API_TOKEN }}

dongik-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+# Python
+.venv/
+.ruff_cache/
+__pycache__
+dist/
+
+# Editor
+.vscode/
+.zed/

dongik-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,34 @@
+fail_fast: false
+
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+
+  - repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+      - id: isort
+        name: isort (python)
+        args:
+          - --profile
+          - black
+          - --filter-files
+
+  - repo: https://github.com/psf/black
+    rev: 24.10.0
+    hooks:
+      - id: black
+        args:
+          - --line-length=88
+
+  - repo: https://github.com/charliermarsh/ruff-pre-commit
+    rev: v0.7.3
+    hooks:
+      - id: ruff
+        args:
+          - --fix

dongik-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

dongik-0.1.0/LICENSE

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

dongik-0.1.0/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.5
+Name: dongik
+Version: 0.1.0
+Summary: A short description of my package
+Project-URL: Homepage, https://github.com/don-gik/pypi-dongik
+Author-email: don-gik <224256443+don-gik@users.noreply.github.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Requires-Dist: torch>=2.5.1
+Requires-Dist: torchvision>=0.20.1

dongik-0.1.0/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "dongik"
+version = "0.1.0"
+authors = [
+    { name = "don-gik", email = "224256443+don-gik@users.noreply.github.com" }
+]
+description = "A short description of my package"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+    "torch>=2.5.1",
+    "torchvision>=0.20.1",
+]
+
+[project.urls]
+Homepage = "https://github.com/don-gik/pypi-dongik"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dongik"]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[tool.uv.sources]
+torch = { index = "pytorch-cpu" }
+torchvision = { index = "pytorch-cpu" }
+
+[dependency-groups]
+dev = [
+    "pre-commit>=3.5.0",
+    "ruff>=0.16.5",
+]

dongik-0.1.0/src/dongik/__init__.py

@@ -0,0 +1,5 @@
+# src/dongik/__init__.py
+
+from src.dongik import data, nn, ops, optim
+
+__all__ = ["data", "nn", "ops", "optim"]

dongik-0.1.0/src/dongik/data.py

@@ -0,0 +1,81 @@
+# src/dongik/data.py
+
+from __future__ import annotations
+
+import random
+from typing import Iterator, overload
+
+import torch
+from torchvision import datasets, transforms
+
+
+class MNISTData:
+    def __init__(
+        self, samples: int = 5000, augment: bool = True, root: str = "./data"
+    ) -> None:
+        transform_list = []
+        if augment:
+            transform_list.extend(
+                [
+                    transforms.RandomRotation(degrees=15),
+                    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),
+                ]
+            )
+
+        transform_list.append(transforms.ToTensor())
+
+        raw_ds = datasets.MNIST(
+            root=root,
+            train=True,
+            download=True,
+            transform=transforms.Compose(transform_list),
+        )
+
+        self._images: list[torch.Tensor] = []
+        self._labels: list[list[float]] = []
+
+        max_len = min(samples, len(raw_ds))
+        for i in range(max_len):
+            img_tensor, label_idx = raw_ds[i]
+            self._images.append(img_tensor.view(-1))
+
+            one_hot = [0.0] * 10
+            one_hot[int(label_idx)] = 1.0
+            self._labels.append(one_hot)
+
+    def __len__(self) -> int:
+        return len(self._labels)
+
+    @overload
+    def __getitem__(self, idx: int) -> tuple[list[float], list[float]]: ...
+    @overload
+    def __getitem__(self, idx: slice) -> list[tuple[list[float], list[float]]]: ...
+
+    def __getitem__(
+        self, idx: int | slice
+    ) -> tuple[list[float], list[float]] | list[tuple[list[float], list[float]]]:
+        # dataset[:10] Slicing support
+        if isinstance(idx, slice):
+            return [self[i] for i in range(*idx.indices(len(self)))]
+
+        x_list = self._images[idx].tolist()
+        y_list = self._labels[idx]
+        return x_list, y_list
+
+    def __iter__(self) -> Iterator[tuple[list[float], list[float]]]:
+        # for x, y in dataset
+        for i in range(len(self)):
+            yield self[i]
+
+    def shuffle(self) -> None:
+        combined = list(zip(self._images, self._labels))
+        random.shuffle(combined)
+        images_tuple, labels_tuple = zip(*combined)
+        self._images = list(images_tuple)
+        self._labels = list(labels_tuple)
+
+
+def get_mnist(
+    samples: int = 5000, augment: bool = True, root: str = "./data"
+) -> MNISTData:
+    return MNISTData(samples=samples, augment=augment, root=root)

dongik-0.1.0/src/dongik/nn.py

@@ -0,0 +1,129 @@
+# src/dongik/nn.py
+
+from __future__ import annotations
+
+import abc
+import math
+import random
+from typing import Any, Callable, overload
+
+import torch
+
+
+class Base(abc.ABC):
+    input_cnt: int
+    weight: list[float]
+    bias: float
+    d_weight: list[float]
+    d_bias: float
+    inputs: list[float]
+
+    _compiled_forward: Callable[..., Any]
+    _compiled_backward: Callable[..., Any]
+
+    def __init_subclass__(cls, **kwargs) -> None:
+        super().__init_subclass__(**kwargs)
+        orig_init = cls.__init__
+
+        def wrapped_init(self, *args, **kwargs):
+            self.input_cnt = kwargs.get(
+                "input_cnt", args[0] if args and isinstance(args[0], int) else 0
+            )
+            self.weight = []
+            self.bias = 0.0
+            self.d_weight = []
+            self.d_bias = 0.0
+            self.inputs = []
+
+            orig_init(self, *args, **kwargs)
+
+            # He Initialization
+            if self.input_cnt > 0 and not self.weight:
+                std = math.sqrt(2.0 / self.input_cnt)
+                self.weight = [random.gauss(0, std) for _ in range(self.input_cnt)]
+                self.bias = 0.0
+                self.d_weight = [0.0] * self.input_cnt
+                self.d_bias = 0.0
+
+            self._compiled_forward = torch.compile(self.forward, mode="default")
+            self._compiled_backward = torch.compile(self.backward, mode="default")
+
+        cls.__init__ = wrapped_init  # type: ignore[method-assign]
+
+    def __init__(self, input_cnt: int = 0) -> None:
+        pass
+
+    @abc.abstractmethod
+    def forward(self, inputs: list[float]) -> float | list[float]:
+        pass
+
+    @abc.abstractmethod
+    def backward(self, loss: float | list[float]) -> list[float]:
+        pass
+
+    @overload
+    def __call__(self, inputs: float) -> float: ...
+    @overload
+    def __call__(self, inputs: list[float]) -> list[float]: ...
+    @overload
+    def __call__(self, inputs: Any) -> Any: ...
+
+    def __call__(self, inputs: Any) -> Any:
+        is_root = not isinstance(inputs, torch.Tensor)
+        t_inputs = torch.as_tensor(inputs, dtype=torch.float32) if is_root else inputs
+
+        res = self._compiled_forward(t_inputs)
+
+        if is_root and isinstance(res, torch.Tensor):
+            return res.tolist() if res.ndim > 0 else res.item()
+        return res
+
+    @overload
+    def step_backward(self, loss: float) -> float: ...
+    @overload
+    def step_backward(self, loss: list[float]) -> list[float]: ...
+    @overload
+    def step_backward(self, loss: Any) -> Any: ...
+
+    def step_backward(self, loss: Any) -> Any:
+        is_root = not isinstance(loss, torch.Tensor)
+        t_loss = torch.as_tensor(loss, dtype=torch.float32) if is_root else loss
+
+        grad = self._compiled_backward(t_loss)
+
+        if is_root and isinstance(grad, torch.Tensor):
+            return grad.tolist() if grad.ndim > 0 else grad.item()
+        return grad
+
+    def get_leaf_nodes(self, visited: set[int] | None = None) -> list[Base]:
+        if visited is None:
+            visited = set()
+
+        if id(self) in visited:
+            return []
+        visited.add(id(self))
+
+        child_nodes: list[Base] = []
+        for attr_value in self.__dict__.values():
+            child_nodes.extend(self._find_base_nodes(attr_value, visited))
+
+        if not child_nodes:
+            if self.weight and self.d_weight:
+                return [self]
+            return []
+
+        return child_nodes
+
+    def _find_base_nodes(self, obj: Any, visited: set[int]) -> list[Base]:
+        found: list[Base] = []
+
+        if isinstance(obj, Base):
+            found.extend(obj.get_leaf_nodes(visited))
+        elif isinstance(obj, (list, tuple)):
+            for item in obj:
+                found.extend(self._find_base_nodes(item, visited))
+        elif isinstance(obj, dict):
+            for item in obj.values():
+                found.extend(self._find_base_nodes(item, visited))
+
+        return found

dongik-0.1.0/src/dongik/ops.py

@@ -0,0 +1,127 @@
+# src/dongik/ops.py
+
+from __future__ import annotations
+
+from typing import Any, overload
+
+import torch
+
+Number = int | float
+
+# ==========================================
+# Torch Kernel
+# ==========================================
+
+
+@torch.compile(mode="default")
+def _fast_multiply(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    return a * b
+
+
+@torch.compile(mode="default")
+def _fast_add(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    return a + b
+
+
+@torch.compile(mode="default")
+def _fast_sum(a: torch.Tensor) -> torch.Tensor:
+    return torch.sum(a)
+
+
+# ==========================================
+# APIs
+# ==========================================
+
+
+@overload
+def multiply(a: Number, b: Number) -> float: ...
+@overload
+def multiply(a: list[float], b: Number) -> list[float]: ...
+@overload
+def multiply(a: Number, b: list[float]) -> list[float]: ...
+@overload
+def multiply(a: list[float], b: list[float]) -> list[float]: ...
+@overload
+def multiply(a: Any, b: Any) -> Any: ...
+
+
+def multiply(a: Any, b: Any) -> Any:
+    if isinstance(a, torch.Tensor) or isinstance(b, torch.Tensor):
+        t_a = (
+            a
+            if isinstance(a, torch.Tensor)
+            else torch.as_tensor(a, dtype=torch.float32)
+        )
+        t_b = (
+            b
+            if isinstance(b, torch.Tensor)
+            else torch.as_tensor(b, dtype=torch.float32)
+        )
+        return _fast_multiply(t_a, t_b)
+
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return float(a * b)
+
+    t_a = torch.as_tensor(a, dtype=torch.float32)
+    t_b = torch.as_tensor(b, dtype=torch.float32)
+    res = _fast_multiply(t_a, t_b)
+    return res.tolist() if res.ndim > 0 else res.item()
+
+
+@overload
+def add(a: Number, b: Number) -> float: ...
+@overload
+def add(a: list[float], b: Number) -> list[float]: ...
+@overload
+def add(a: Number, b: list[float]) -> list[float]: ...
+@overload
+def add(a: list[float], b: list[float]) -> list[float]: ...
+@overload
+def add(a: Any, b: Any) -> Any: ...
+
+
+def add(a: Any, b: Any) -> Any:
+    if isinstance(a, torch.Tensor) or isinstance(b, torch.Tensor):
+        t_a = (
+            a
+            if isinstance(a, torch.Tensor)
+            else torch.as_tensor(a, dtype=torch.float32)
+        )
+        t_b = (
+            b
+            if isinstance(b, torch.Tensor)
+            else torch.as_tensor(b, dtype=torch.float32)
+        )
+        return _fast_add(t_a, t_b)
+
+    if isinstance(a, (int, float)) and isinstance(b, (int, float)):
+        return float(a + b)
+
+    t_a = torch.as_tensor(a, dtype=torch.float32)
+    t_b = torch.as_tensor(b, dtype=torch.float32)
+    res = _fast_add(t_a, t_b)
+    return res.tolist() if res.ndim > 0 else res.item()
+
+
+@overload
+def sum_all(a: Number) -> float: ...
+@overload
+def sum_all(a: list[float]) -> float: ...
+@overload
+def sum_all(a: Any) -> Any: ...
+
+
+def sum_all(a: Any) -> Any:
+    if isinstance(a, torch.Tensor):
+        t_a = (
+            a
+            if isinstance(a, torch.Tensor)
+            else torch.as_tensor(a, dtype=torch.float32)
+        )
+        return _fast_sum(t_a)
+
+    if isinstance(a, (int, float)):
+        return float(a)
+
+    t_a = torch.as_tensor(a, dtype=torch.float32)
+    return _fast_sum(t_a).item()

dongik-0.1.0/src/dongik/optim.py

@@ -0,0 +1,21 @@
+# src/dongik/optim.py
+
+from __future__ import annotations
+
+import abc
+
+from dongik.nn import Base
+
+
+class BaseUpdater(abc.ABC):
+    def __init__(self, model: Base, lr: float = 0.01) -> None:
+        self.model = model
+        self.lr = lr
+
+    @abc.abstractmethod
+    def update_node(self, node: Base) -> None:
+        pass
+
+    def update(self) -> None:
+        for node in self.model.get_leaf_nodes():
+            self.update_node(node)