creyone-layer 1.0.0__py3-none-any.whl

creyone_layer/__init__.py

@@ -0,0 +1,7 @@
+from .utils.factory import create_layer
+from . import act, conv, norm, pool  # trigger layer registration
+
+__all__ = [
+    'create_layer',
+    'act', 'conv', 'norm', 'pool',
+]

creyone_layer/act.py

@@ -0,0 +1,93 @@
+from functools import partial
+from typing import Optional
+
+import torch
+from torch import nn
+
+from .utils.registry import register_layer
+
+# A memory-efficient implementation of Swish function
+class SwishImplementation(torch.autograd.Function):
+
+    @staticmethod
+    def forward(ctx, i):
+        result = i * torch.sigmoid(i)
+        ctx.save_for_backward(i)
+        return result
+
+    @staticmethod
+    def backward(ctx, grad_output):
+        i = ctx.saved_tensors[0]
+        sigmoid_i = torch.sigmoid(i)
+        return grad_output * (sigmoid_i * (1 + i * (1 - sigmoid_i)))
+
+
+class MemoryEfficientSwish(nn.Module):
+    
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return SwishImplementation.apply(x)
+    
+
+class QuickGELU(nn.Module):
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return x * torch.sigmoid(1.702 * x)
+
+class HardSigmoid(nn.Module):
+
+    def __init__(self, inplace=True):
+        super().__init__()
+        self.relu = nn.ReLU6(inplace=inplace)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return self.relu(x + 3) / 6
+    
+class HardSwish(nn.Module):
+
+    def __init__(self, inplace=True):
+        super().__init__()
+        self.sigmoid = HardSigmoid(inplace=inplace)
+
+    def forward(self, x):
+        return x * self.sigmoid(x)
+    
+
+@register_layer('act')
+def gelu(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return nn.GELU
+
+@register_layer('act')
+def relu(overwrite: Optional[nn.Module] = None, inplace: bool = False, **kwargs):
+    if overwrite is not None: return overwrite
+    return partial(nn.ReLU, inplace=inplace)
+
+@register_layer('act')
+def relu6(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return nn.ReLU6
+
+@register_layer('act')
+def sigmoid(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return nn.Sigmoid
+
+@register_layer('act')
+def hardsig(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return HardSigmoid
+
+@register_layer('act')
+def hardswish(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return HardSwish
+
+@register_layer('act')
+def quickgelu(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return QuickGELU
+
+@register_layer('act')
+def swisheff(overwrite: Optional[nn.Module] = None, **kwargs):
+    if overwrite is not None: return overwrite
+    return MemoryEfficientSwish

creyone_layer/conv.py

@@ -0,0 +1,23 @@
+from torch import nn
+
+from .utils.registry import register_layer
+from .wrap import wrap_conv
+
+
+def _base(dim: int, opt: set | None = None):
+    if opt is None: opt = set()
+    if dim == 1: return wrap_conv(nn.Conv1d, opt=opt)
+    if dim == 2: return wrap_conv(nn.Conv2d, opt=opt)
+    if dim == 3: return wrap_conv(nn.Conv3d, opt=opt)
+    raise ValueError(f'Unsupported dim: {dim}')
+
+
+@register_layer('conv')
+def base(dim: int = 2, optional: str = '') -> type[nn.Module]:
+    return _base(dim, opt=set(optional.split('+')))
+
+
+@register_layer('conv')
+def depthwise(dim: int = 2, optional: str = '') -> type[nn.Module]:
+    seq = set(optional.split('+')); seq.add('dw')
+    return _base(dim, opt=seq)

creyone_layer/norm.py

@@ -0,0 +1,23 @@
+import torch.nn as nn
+
+from .utils.registry import register_layer
+
+
+def _wrapper(cls, eps: float = 1e-5, **extra_kwargs):
+
+    def _norm_func(*args, **kwargs):
+        _eps = kwargs.pop('eps', eps)
+        return cls(*args, eps=_eps, **extra_kwargs, **kwargs)
+
+    return _norm_func
+
+
+@register_layer('norm')
+def layer(eps: float = 1e-5, **_):
+    return _wrapper(nn.LayerNorm, eps=eps)
+
+@register_layer('norm')
+def batch(eps: float = 1e-5, dim: int = 2, mom: float = 0.1):
+    if dim == 1: return _wrapper(nn.BatchNorm1d, eps=eps, momentum=mom)
+    if dim == 2: return _wrapper(nn.BatchNorm2d, eps=eps, momentum=mom)
+    raise ValueError(f"Unsupported dim={dim} for BatchNorm. Expected 1 or 2.")

creyone_layer/pool.py

@@ -0,0 +1,29 @@
+from torch import nn
+
+from .utils.registry import register_layer
+from .wrap import wrap_pool
+
+
+def _max(dim: int, opt: set | None = None):
+    if opt is None: opt = set()
+    return wrap_pool(getattr(nn, f"MaxPool{dim}d"), opt=opt)
+
+
+def _avg(dim: int, opt: set | None = None):
+    if opt is None: opt = set()
+    return wrap_pool(getattr(nn, f"AvgPool{dim}d"), opt=opt)
+
+
+@register_layer('pool')
+def max(dim: int = 2, optional: str = '') -> callable:
+    return _max(dim, opt=set(optional.split('+')))
+
+
+@register_layer('pool')
+def avg(dim: int = 2, optional: str = '') -> callable:
+    return _avg(dim, opt=set(optional.split('+')))
+
+
+@register_layer('pool')
+def aavg(dim: int = 2, optional: str = '') -> callable:
+    return getattr(nn, f"AdaptiveAvgPool{dim}d")

creyone_layer/utils/factory.py

@@ -0,0 +1,13 @@
+from typing import Callable, Optional, Union
+from torch import nn
+
+from .registry import layer_entrypoint
+
+def create_layer(
+        layer_name: Optional[Union[str, nn.Module]],
+        layer_family: str = 'any', 
+        otherwise: Callable = lambda *a, **b: nn.Identity()) -> Union[nn.Module, Callable]:
+    
+    if layer_name is None: return otherwise
+    if isinstance(layer_name, str): return layer_entrypoint(layer_name, layer_family=layer_family)
+    return layer_name

creyone_layer/utils/registry.py

@@ -0,0 +1,51 @@
+import sys, warnings
+from collections import defaultdict
+from typing import Any, Callable, Optional
+
+
+_module_to_layers: dict[str, set[str]] = defaultdict(set)  # dict of sets to check membership of model in module
+_layer_to_module: dict[str, dict[str, str]] = defaultdict(dict)  # mapping of model names to module names
+_layer_entrypoints: dict[str, dict[str, Callable[..., Any]]] = defaultdict(dict)  # mapping of model names to architecture entrypoint fns
+
+
+def register_layer(layer_family: str = 'any'):
+
+    def _register_layer(fn: Callable[..., Any]) -> Callable[..., Any]:
+
+        # lookup containing module
+        mod = sys.modules[fn.__module__]
+        module_name = fn.__module__.split('.')[-1]
+
+        # add model to __all__ in module
+        layer_name = fn.__name__
+        if not hasattr(mod, '__all__'): mod.__all__ = []
+        mod.__all__.append(layer_name)
+
+        # add entries to registry dict/sets
+        if layer_name in _layer_entrypoints[layer_family]:
+            warnings.warn(
+                f'Overwriting {layer_name} in registry with {fn.__module__}.{layer_name}. This is because the name being '
+                'registered conflicts with an existing name. Please check if this is not expected.',
+                stacklevel=2,
+            )
+        _layer_entrypoints[layer_family][layer_name] = fn
+        _layer_to_module[layer_family][layer_name] = module_name
+        _module_to_layers[module_name].add(layer_name)
+
+        return fn
+    
+    return _register_layer
+
+
+def layer_entrypoint(layer_name: str, 
+                     layer_family: Optional[str] = None, 
+                     module_filter: Optional[str] = None) -> Callable[..., Any]:
+    """Fetch a model entrypoint for specified model name
+    """
+    if module_filter and layer_name not in _module_to_layers.get(module_filter, set()):
+        raise RuntimeError(f'Model ({layer_name}) not found in module {module_filter}.')
+    if layer_family is not None and layer_name in _layer_entrypoints[layer_family]: 
+        return _layer_entrypoints[layer_family][layer_name]
+    if layer_name not in _layer_entrypoints['any']:
+        raise RuntimeError(f'Layer [{layer_name}] not found in {layer_family} and `any`.')
+    return _layer_entrypoints['any'][layer_name]

creyone_layer/wrap.py

@@ -0,0 +1,130 @@
+import inspect
+from typing import Optional, Union
+
+from torch import nn
+from creyone import cynn
+
+
+def _consume_args(args: tuple, kwargs: dict) -> tuple[list, dict]:
+    """Normalize positional args to (c1, c2, k), pulling missing values from kwargs.
+
+    Accepts args in (c1, c2, k) order. Any leading args that are omitted are
+    extracted from kwargs using the long-form keys ('in_channels', 'out_channels',
+    'kernel_size') or their short aliases ('c1', 'c2', 'k').
+    """
+    args = list(args)
+    if len(args) == 3: return args, kwargs
+    k = kwargs.pop('kernel_size', kwargs.pop('k', None))    
+    if len(args) == 2: return args + [k], kwargs
+    c2 = kwargs.pop('out_channels', kwargs.pop('c2', None))
+    if len(args) == 1: return args + [c2, k], kwargs
+    c1 = kwargs.pop('in_channels', kwargs.pop('c1', None))
+    return [c1, c2, k], kwargs
+
+
+def _consume_pool_args(args: tuple, kwargs: dict) -> tuple:
+    """Extract kernel size from positional args or kwargs for pool layers."""
+    if args:
+        return args[0], kwargs
+    k = kwargs.pop('kernel_size', kwargs.pop('k', None))
+    return k, kwargs
+
+
+def _compute_same_padding(k: int, d: int = 1) -> Union[int, list[int]]:  # kernel, padding, dilation
+    """Pad to 'same' shape outputs."""
+    if isinstance(k, int): k = [k] 
+    if d > 1: k = [d * (x - 1) + 1 for x in k]  # actual kernel-size
+    p = [x // 2 for x in k]  # auto-pad
+    return p[0] if len(p) == 1 else p
+
+
+def _wrapfn(**kwargs):
+    """Extract and return common convolution/pooling parameters from kwargs.
+
+    Pops 'stride'/'s', 'padding'/'p', 'dilation'/'d', and 'groups'/'g' from
+    kwargs, returning them as (s, p, d, g). The remaining kwargs are left for
+    the caller to pass through to the underlying layer.
+    """
+    s = kwargs.pop('stride', kwargs.pop('s', 1))
+    p = kwargs.pop('padding', kwargs.pop('p', 0))
+    d = kwargs.pop('dilation', kwargs.pop('d', 1))
+    g = kwargs.pop('groups', kwargs.pop('g', 1))
+    return s, p, d, g
+
+
+class AutoReshape(nn.Module):
+
+    def __init__(self, mid_layer: nn.Module):
+        super().__init__()
+        self._inner = mid_layer
+    
+    def forward(self, x: cynn.CreYonT) -> cynn.CreYonT:
+        x = x.rearrange('B (H W) C -> B C H W', H=x.H).contiguous()
+        return x(self._inner).rearrange('B C H W -> B (H W) C')
+
+
+def wrap_conv(cls: nn.Conv2d, opt: Union[set, str, None] = None):
+    """Wrap a Conv Nd class with flexible argument parsing and optional behaviors.
+
+    Args:
+        cls: A ConvNd-compatible class to wrap.
+        opt: A '+'-separated string of option flags:
+            - 'grid': use the kernel size arg as the stride (grid-like sampling).
+            - 'ap':   auto-pad so the output spatial size matches the input.
+            - 'dw':   set groups = in_channels (depthwise convolution).
+
+    Returns:
+        A factory function that accepts (c1, c2, k, ...) positionally or as kwargs
+        and forwards them to ``cls`` with stride, padding, dilation, and groups set.
+    """
+    if opt is None: opt = set()
+    elif isinstance(opt, str): opt = set(opt.split('+'))
+
+    def _fn(*args, **kwargs):
+        args, kwargs = _consume_args(args, kwargs)
+        s, p, d, g = _wrapfn(**kwargs)
+        if 'grid' in opt: s = args[-1]
+        if 'ap' in opt: p = _compute_same_padding(args[-1], d)
+        if 'dw' in opt: g = args[0]
+
+        ins = cls(*args, stride=s, padding=p, dilation=d, groups=g, **kwargs)
+        if 'ar' in opt: ins = AutoReshape(ins)
+        return ins
+    
+    return _fn
+
+
+def wrap_pool(cls, opt: Union[set, str, None] = None):
+    """Wrap a pooling class with flexible argument parsing and optional behaviors.
+
+    Args:
+        cls: A PoolNd-compatible class to wrap. Dilation is forwarded automatically
+             only when the class supports it (MaxPoolNd does, AvgPoolNd does not).
+        opt: A '+'-separated string of option flags:
+            - 'grid': use the kernel size arg as the stride (grid-like sampling).
+            - 'ap':   auto-pad so the output spatial size matches the input.
+            - 'ar':   wrap output in AutoReshape for (B HW C) tensors.
+
+    Returns:
+        A factory function that accepts (k, ...) positionally or as kwargs
+        and forwards them to ``cls`` with stride, padding, and dilation set.
+    """
+    if opt is None: opt = set()
+    elif isinstance(opt, str): opt = set(opt.split('+'))
+    _has_dilation = 'dilation' in inspect.signature(cls).parameters
+
+    def _fn(*args, **kwargs):
+        k, kwargs = _consume_pool_args(args, kwargs)
+        s, p, d, _ = _wrapfn(**kwargs)
+        if 'grid' in opt: s = k
+        if 'ap' in opt: p = _compute_same_padding(k, d if _has_dilation else 1)
+
+        extra = {'dilation': d} if _has_dilation else {}
+        ins = cls(k, stride=s, padding=p, **extra, **kwargs)
+        if 'ar' in opt: ins = AutoReshape(ins)
+        return ins
+
+    return _fn
+
+
+

creyone_layer-1.0.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: creyone_layer
+Version: 1.0.0
+Summary: PyTorch layer building tools for CREYONE
+Author-email: Linqa Kiriyama <kiriyamalq@gmail.com>
+License: MIT License
+        
+        Copyright (c) 2026 QNiLix
+        
+        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.
+        
+Project-URL: Homepage, https://example.com
+Project-URL: Documentation, https://readthedocs.org
+Project-URL: Repository, https://github.com/qnilix/creyone_layer.git
+Project-URL: Bug Tracker, https://github.com/qnilix/creyone_layer/issues
+Project-URL: Changelog, https://github.com/qnilix/creyone_layer/blob/master/CHANGELOG.md
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Dynamic: license-file
+
+# creyone_layer (Beta Package for CreYoNe)
+
+Create Your Network (a.k.a. CreYoNe) is a utility tools for making DNN module via torch. This repository provides Layer-sized building blocks for deep learning.
+
+## Installation
+
+```bash
+pip install creyone-layer
+```
+
+From source:
+
+```bash
+git clone https://github.com/qaiLN/creyone.git
+cd creyone_layer
+pip install -e .
+```
+
+## Quick Start
+
+### Layer registry — `create_layer`
+
+```python
+from creyone_layer import create_layer
+
+relu = create_layer('relu', 'act')(inplace=True)()
+bn   = create_layer('batch', 'norm')(dim=2, eps=1e-5, mom=0.1)(64)
+conv = create_layer('base',  'conv')(dim=2, optional='ap')(32, 64, 3)
+pool = create_layer('max',   'pool')(dim=2, optional='ap')(2)
+```
+
+## Registered Layers
+
+| Family | Names                                                                               |
+| ------ | ----------------------------------------------------------------------------------- |
+| `conv` | `base`, `depthwise`                                                                 |
+| `norm` | `batch`, `layer`                                                                    |
+| `act`  | `relu`, `relu6`, `gelu`, `quickgelu`, `sigmoid`, `hardsig`, `hardswish`, `swisheff` |
+| `pool` | `max`, `avg`                                                                        |
+
+### `conv` options (passed via `optional='...'`, `+`-separated)
+
+| Flag   | Effect                                              |
+| ------ | --------------------------------------------------- |
+| `ap`   | auto-pad — output spatial size matches input        |
+| `dw`   | depthwise — `groups = in_channels`                  |
+| `grid` | stride = kernel size (grid-like sampling)           |
+| `ar`   | AutoReshape — accepts `(B, H*W, C)` token sequences |

creyone_layer-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+creyone_layer/__init__.py,sha256=iylQnmzTdB2g7qiUjD06yUaRfiXX5YPcIHQiPtBtk0U,176
+creyone_layer/act.py,sha256=5rRCRIMQGftvdS-pj68ua5h8r8z5oQDKs7H2vFzMY9E,2596
+creyone_layer/conv.py,sha256=gvwN6dRUhxhwy1w_YKlcOvJTTLFjeBAl7OPqqZFmX08,697
+creyone_layer/norm.py,sha256=5S5xweVo6b7iTxM1vgQ1C20WPhzmKUxxi3tfBulavxU,696
+creyone_layer/pool.py,sha256=2oVyV8lIEoC85ohKbc1TGRdOodvastSriDnhzkgH_60,766
+creyone_layer/wrap.py,sha256=MgaGQhXR-h2o3M5K_2Vp-0WzDzWFwF_33vQn5Mv0hLA,4887
+creyone_layer/utils/factory.py,sha256=QniWN96qXSN_K983pCdjMO72b99NPLjug2iB-BtSYd4,475
+creyone_layer/utils/registry.py,sha256=-_Vy2_yJBJhQD5GMA35GefVF0UBlBAAKxfGH0vR8MqY,2265
+creyone_layer-1.0.0.dist-info/licenses/LICENSE,sha256=hclUFguzDZoeugY3tZSGMvKQnec1IV4x14q2WLiyV2k,1063
+creyone_layer-1.0.0.dist-info/METADATA,sha256=dZUkZrbI_xhMLzL_MWcN6lNgNI3moza0286tPX4sguk,3756
+creyone_layer-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+creyone_layer-1.0.0.dist-info/top_level.txt,sha256=k8aD6BdR6NCB7hFr7L_2C9Cw7TXOlhcPMpi_BDAkjvc,14
+creyone_layer-1.0.0.dist-info/RECORD,,

creyone_layer-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

creyone_layer-1.0.0.dist-info/licenses/LICENSE

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

creyone_layer-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+creyone_layer