raglu 0.1.0__py3-none-any.whl

raglu/__init__.py

@@ -0,0 +1,31 @@
+"""RaGLU: Pure Rational GLU ve RaLU aktivasyonları.
+
+PyTorch (CPU/CUDA/MPS), isteğe bağlı Triton CUDA çekirdekleri ve Apple MLX
+desteği sunar.
+"""
+
+from .core import (
+    HAS_MLX,
+    HAS_TRITON,
+    fused_pure_rational,
+    fused_pure_rational_glu,
+)
+from .torch_module import RaGLU, RaLU
+
+if HAS_MLX:
+    from .core import mlx_pure_rational, mlx_pure_rational_glu
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "fused_pure_rational_glu",
+    "fused_pure_rational",
+    "RaGLU",
+    "RaLU",
+    "HAS_TRITON",
+    "HAS_MLX",
+    "__version__",
+]
+
+if HAS_MLX:
+    __all__ += ["mlx_pure_rational_glu", "mlx_pure_rational"]

raglu/core.py

@@ -0,0 +1,116 @@
+import torch
+
+# Triton ve CUDA kontrolü
+HAS_TRITON = False
+if torch.cuda.is_available():
+    try:
+        import triton
+        import triton.language as tl
+        HAS_TRITON = True
+    except ImportError:
+        HAS_TRITON = False
+
+# MLX kontrolü (Apple Silicon / Mac desteği için)
+HAS_MLX = False
+try:
+    import mlx.core as mx
+    import mlx.nn as mx_nn
+    HAS_MLX = True
+except ImportError:
+    HAS_MLX = False
+
+
+# ==============================================================================
+# 1. TRITON KERNELS (NVIDIA CUDA OPTİMİZE)
+# ==============================================================================
+if HAS_TRITON:
+    @triton.jit
+    def _pure_rational_glu_fwd_kernel(gate_ptr, val_ptr, out_ptr, n_elements, BLOCK_SIZE: tl.constexpr):
+        pid = tl.program_id(axis=0)
+        offsets = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+        mask = offsets < n_elements
+
+        g = tl.load(gate_ptr + offsets, mask=mask)
+        v = tl.load(val_ptr + offsets, mask=mask)
+
+        g = tl.clamp(g, -50.0, 50.0)
+        g_sq = g * g
+        fg = (g * g_sq + g) / (g_sq + 3.0)
+        tl.store(out_ptr + offsets, fg * v, mask=mask)
+
+    @triton.jit
+    def _pure_rational_glu_bwd_kernel(dy_ptr, gate_ptr, val_ptr, dg_ptr, dv_ptr, n_elements, BLOCK_SIZE: tl.constexpr):
+        pid = tl.program_id(axis=0)
+        offsets = pid * BLOCK_SIZE + tl.arange(0, BLOCK_SIZE)
+        mask = offsets < n_elements
+
+        dy = tl.load(dy_ptr + offsets, mask=mask)
+        g = tl.load(gate_ptr + offsets, mask=mask)
+        v = tl.load(val_ptr + offsets, mask=mask)
+
+        g = tl.clamp(g, -50.0, 50.0)
+        g_sq = g * g
+        denom = g_sq + 3.0
+
+        fg = (g * g_sq + g) / denom
+        dv = dy * fg
+        dfg = (g_sq * g_sq + 8.0 * g_sq + 3.0) / (denom * denom)
+        dg = dy * v * dfg
+
+        tl.store(dv_ptr + offsets, dv, mask=mask)
+        tl.store(dg_ptr + offsets, dg, mask=mask)
+
+    class FusedPureRationalGLUFunction(torch.autograd.Function):
+        @staticmethod
+        def forward(ctx, gate, val):
+            gate_c, val_c = gate.contiguous(), val.contiguous()
+            n_elements = gate_c.numel()
+            out = torch.empty_like(gate_c)
+            GRID = lambda meta: (triton.cdiv(n_elements, meta['BLOCK_SIZE']),)
+            _pure_rational_glu_fwd_kernel[GRID](gate_c, val_c, out, n_elements, BLOCK_SIZE=1024)
+            ctx.save_for_backward(gate_c, val_c)
+            return out
+
+        @staticmethod
+        def backward(ctx, dy):
+            gate, val = ctx.saved_tensors
+            dy_c = dy.contiguous()
+            n_elements = gate.numel()
+            dgate, dval = torch.empty_like(gate), torch.empty_like(val)
+            GRID = lambda meta: (triton.cdiv(n_elements, meta['BLOCK_SIZE']),)
+            _pure_rational_glu_bwd_kernel[GRID](dy_c, gate, val, dgate, dval, n_elements, BLOCK_SIZE=1024)
+            return dgate, dval
+
+
+# ==============================================================================
+# 2. PYTORCH API (CUDA + MPS/Mac + CPU FALLBACK)
+# ==============================================================================
+def fused_pure_rational_glu(gate: torch.Tensor, val: torch.Tensor) -> torch.Tensor:
+    """Pure Rational GLU Function: f(g) = (g^3 + g) / (g^2 + 3) * v"""
+    if HAS_TRITON and gate.is_cuda:
+        return FusedPureRationalGLUFunction.apply(gate, val)
+    else:
+        # PyTorch Native Fallback (MPS, CPU veya Triton bulunmayan ortamlar)
+        g_sq = gate * gate
+        fg = (gate * g_sq + gate) / (g_sq + 3.0)
+        return fg * val
+
+
+def fused_pure_rational(x: torch.Tensor) -> torch.Tensor:
+    """RaLU (Non-GLU Pure Rational): f(x) = (x^3 + x) / (x^2 + 3)"""
+    x_sq = x * x
+    return (x * x_sq + x) / (x_sq + 3.0)
+
+
+# ==============================================================================
+# 3. APPLE MLX NATIVE DESTEĞİ
+# ==============================================================================
+if HAS_MLX:
+    def mlx_pure_rational_glu(gate: mx.array, val: mx.array) -> mx.array:
+        g_sq = mx.square(gate)
+        fg = (gate * g_sq + gate) / (g_sq + 3.0)
+        return fg * val
+
+    def mlx_pure_rational(x: mx.array) -> mx.array:
+        x_sq = mx.square(x)
+        return (x * x_sq + x) / (x_sq + 3.0)

raglu/torch_module.py

@@ -0,0 +1,121 @@
+"""PyTorch ``nn.Module`` katman sarmalayıcıları.
+
+``RaGLU`` gated (kapılı) doğrusal katmanı, ``RaLU`` ise kapısız
+element-wise aktivasyonu sağlar.
+"""
+
+from __future__ import annotations
+
+from torch import Tensor, nn
+
+from .core import fused_pure_rational, fused_pure_rational_glu
+
+__all__ = ["RaGLU", "RaLU"]
+
+
+class RaGLU(nn.Module):
+    """Pure Rational GLU katmanı.
+
+    İki kullanım biçimi vardır:
+
+    1. Yerleşik doğrusal katman (önerilen)::
+
+           layer = RaGLU(in_features=768, out_features=768)
+           y = layer(x)  # x: (..., 768) -> y: (..., 768)
+
+       Girdi, tek bir doğrusal katmanla ``2 * out_features`` boyutuna
+       genişletilir ve ikiye bölünür. İlk yarı kapı (``gate``), ikinci yarı
+       değer (``val``) olarak kullanılır.
+
+    2. Hazır ``gate`` ve ``val`` modülleri ile::
+
+           layer = RaGLU(gate=nn.Linear(768, 1024), val=nn.Linear(768, 1024))
+           y = layer(x)
+
+    Args:
+        in_features: Girdi özellik sayısı (yerleşik modda zorunludur).
+        out_features: Çıktı özellik sayısı. Varsayılan olarak ``in_features``.
+        bias: Yerleşik doğrusal katmanda bias kullanılıp kullanılmayacağı.
+        gate: Hazır kapı modülü. Verilirse ``val`` da verilmelidir.
+        val: Hazır değer modülü. Verilirse ``gate`` de verilmelidir.
+
+    Girdi ve çıktı şekilleri aynı son boyuta sahip olmalıdır: ``gate`` ve
+    ``val`` çıktıları eşleşmezse hata verilir.
+    """
+
+    def __init__(
+        self,
+        in_features: int | None = None,
+        out_features: int | None = None,
+        bias: bool = True,
+        gate: nn.Module | None = None,
+        val: nn.Module | None = None,
+    ) -> None:
+        super().__init__()
+
+        self.in_features: int | None = in_features
+        self.out_features: int | None = out_features
+
+        if gate is not None or val is not None:
+            if gate is None or val is None:
+                raise ValueError("'gate' ve 'val' birlikte verilmelidir.")
+            if in_features is not None or out_features is not None:
+                raise ValueError(
+                    "Hazır 'gate'/'val' modülleriyle 'in_features'/'out_features' birlikte kullanılamaz."
+                )
+            self.linear = None
+            self.gate = gate
+            self.val = val
+        else:
+            if in_features is None:
+                raise ValueError("'in_features' veya hem 'gate' hem 'val' verilmelidir.")
+            if out_features is None:
+                out_features = in_features
+            self.in_features = in_features
+            self.out_features = out_features
+
+            # Tek matmul ile gate ve val üretimi (GLU standardı).
+            self.linear: nn.Linear | None = nn.Linear(
+                in_features, 2 * out_features, bias=bias
+            )
+            self.gate = None
+            self.val = None
+
+    def forward(self, x: Tensor) -> Tensor:
+        """``x`` üzerinde Pure Rational GLU uygular."""
+        if self.linear is not None:
+            gate, val = self.linear(x).chunk(2, dim=-1)
+        else:
+            gate = self.gate(x)
+            val = self.val(x)
+            if gate.shape != val.shape:
+                raise ValueError(
+                    f"'gate' ve 'val' çıktı şekilleri eşleşmiyor: "
+                    f"{tuple(gate.shape)} != {tuple(val.shape)}"
+                )
+
+        return fused_pure_rational_glu(gate, val)
+
+    def extra_repr(self) -> str:
+        if self.linear is not None:
+            return (
+                f"in_features={self.in_features}, out_features={self.out_features}, "
+                f"bias={self.linear.bias is not None}"
+            )
+        return "gate=<custom>, val=<custom>"
+
+
+class RaLU(nn.Module):
+    """Kapısız Pure Rational aktivasyonu.
+
+    ``f(x) = (x^3 + x) / (x^2 + 3)``
+
+    Şekil değiştirmez; tüm tensörlerde (``float16``/``bfloat16``/``float32``)
+    ve cihazlarda (CPU/CUDA/MPS) çalışır.
+    """
+
+    def forward(self, x: Tensor) -> Tensor:
+        return fused_pure_rational(x)
+
+    def extra_repr(self) -> str:
+        return "inplace=False"

raglu-0.1.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.4
+Name: raglu
+Version: 0.1.0
+Summary: Pure Rational GLU (RaGLU) and RaLU activations for PyTorch, Triton CUDA and Apple MLX.
+Author: Ömer Faruk Solmaz
+License-Expression: MIT
+Keywords: activation,glu,ralu,rational,pytorch,triton,mlx,deep-learning
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0.0
+Provides-Extra: triton
+Requires-Dist: triton>=2.0.0; extra == "triton"
+Provides-Extra: mlx
+Requires-Dist: mlx>=0.1.0; extra == "mlx"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: build>=1.0.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# RaGLU
+
+**Pure Rational GLU (RaGLU)** ve **RaLU** aktivasyon fonksiyonları için platform
+bağımsız PyTorch kütüphanesi. NVIDIA CUDA'da isteğe bağlı **Triton** çekirdekleri,
+Apple Silicon'da ise yerel **MLX** desteği sunar.
+
+Paket iki `nn.Module` sınıfı sunar:
+
+| Sınıf | Görevi |
+| --- | --- |
+| `RaGLU()` | Kapılı (GLU) katman: `Linear` çıktısını gate/val olarak ikiye böler, `f(g) * v` uygular. |
+| `RaLU()` | Kapısız, element-wise aktivasyon: `f(x)` uygular, şekli değiştirmez. |
+
+## Fonksiyonlar
+
+Kapılı (gated) varyant:
+
+$$
+\operatorname{RaGLU}(g, v) = \frac{g^3 + g}{g^2 + 3} \cdot v
+$$
+
+Kapısız varyant:
+
+$$
+\operatorname{RaLU}(x) = \frac{x^3 + x}{x^2 + 3}
+$$
+
+Türev (her iki varyantın çekirdeği):
+
+$$
+\frac{d}{dx}\left(\frac{x^3 + x}{x^2 + 3}\right)
+= \frac{x^4 + 8x^2 + 3}{(x^2 + 3)^2}
+$$
+
+Fonksiyon tek (odd) bir fonksiyondur: `f(-x) = -f(x)`. Payda her zaman
+`>= 3` olduğundan sayısal olarak kararlıdır.
+
+## Kurulum
+
+```bash
+pip install raglu
+```
+
+İsteğe bağlı hızlandırıcılar:
+
+```bash
+pip install "raglu[triton]"   # NVIDIA CUDA için Triton çekirdekleri
+pip install "raglu[mlx]"      # Apple Silicon için MLX
+pip install "raglu[dev]"      # test + derleme araçları
+```
+
+## Kullanım
+
+### Fonksiyonel PyTorch API
+
+```python
+import torch
+from raglu import fused_pure_rational_glu, fused_pure_rational
+
+gate = torch.randn(32, 128)
+val = torch.randn(32, 128)
+
+y = fused_pure_rational_glu(gate, val)  # (32, 128)
+z = fused_pure_rational(gate)           # (32, 128)
+```
+
+`fused_pure_rational_glu`, CUDA + Triton mevcutsa füzyonlu çekirdeği kullanır.
+Aksi halde otomatik olarak CPU/MPS uyumlu PyTorch fallback'ine döner.
+Her iki yol da autograd desteklidir.
+
+### Katmanlar
+
+```python
+import torch
+from raglu import RaGLU, RaLU
+
+# Girdiyi 2 * out_features boyutuna genişletip gate/val olarak böler.
+layer = RaGLU(in_features=768, out_features=768)
+x = torch.randn(8, 128, 768)
+y = layer(x)  # (8, 128, 768)
+
+# Kapısız aktivasyon
+act = RaLU()
+z = act(x)    # (8, 128, 768)
+```
+
+Hazır `gate` ve `val` modülleri de kullanılabilir:
+
+```python
+from torch import nn
+from raglu import RaGLU
+
+layer = RaGLU(
+    gate=nn.Linear(768, 1024),
+    val=nn.Linear(768, 1024),
+)
+```
+
+### Apple MLX
+
+```python
+import mlx.core as mx
+from raglu import mlx_pure_rational_glu, mlx_pure_rational
+
+gate = mx.random.normal((32, 128))
+val = mx.random.normal((32, 128))
+
+y = mlx_pure_rational_glu(gate, val)
+z = mlx_pure_rational(gate)
+```
+
+MLX kurulu değilse bu semboller dışa aktarılmaz; `raglu.HAS_MLX` ile kontrol
+edebilirsiniz.
+
+## API
+
+| Sembol | Açıklama |
+| --- | --- |
+| `raglu.fused_pure_rational_glu(gate, val)` | Kapılı Pure Rational GLU (Triton/CUDA veya PyTorch fallback) |
+| `raglu.fused_pure_rational(x)` | Kapısız RaLU aktivasyonu |
+| `raglu.RaGLU` | Doğrusal katman + Pure Rational GLU `nn.Module`'ü |
+| `raglu.RaLU` | Element-wise RaLU `nn.Module`'ü |
+| `raglu.mlx_pure_rational_glu` | MLX kapılı varyant (MLX varsa) |
+| `raglu.mlx_pure_rational` | MLX kapısız varyant (MLX varsa) |
+| `raglu.HAS_TRITON` | Triton çekirdeklerinin kullanılabilirliği |
+| `raglu.HAS_MLX` | MLX'in kullanılabilirliği |
+
+### Not: CUDA clamp
+
+Triton çekirdekleri sayısal kararlılık için kapı değerini `[-50, 50]` aralığına
+kırpar. Bu aralığın dışındaki değerlerde Triton ve fallback çıktıları
+farklılaşabilir; pratik aktivasyon girdilerinde fark yoktur.
+
+## Geliştirme
+
+```bash
+git clone <repo-url>
+cd RaGLU
+python -m venv .venv
+source .venv/bin/activate
+pip install -e ".[dev]"
+pytest -v
+```
+
+Triton testleri yalnızca CUDA + Triton mevcut olduğunda, MLX testleri ise
+yalnızca MLX kurulu olduğunda çalışır; diğer ortamlarda otomatik atlanır.
+
+### Paket derleme
+
+```bash
+python -m build
+python -m twine check dist/*
+```
+
+## Lisans
+
+MIT — bkz. [LICENSE](LICENSE).
+
+Copyright (c) 2026 Ömer Faruk Solmaz

raglu-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+raglu/__init__.py,sha256=FcWZq1XN-i9cKo4Qz9d-64b1pf3ttEYFgCkzI5Vl1p4,621
+raglu/core.py,sha256=sFj_zzAnjKsKOjPaJjaJN9wB8IiD4LrhLkFFIS_dkx4,4248
+raglu/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raglu/torch_module.py,sha256=nr4SIS86Biccogm3V449romNv4fZtvJ__B2L5rVXsTc,4129
+raglu-0.1.0.dist-info/licenses/LICENSE,sha256=k1JAVRiTnpXhVIXp5swyTlFdBYUEQ2yDVMF4_9ew8zY,1075
+raglu-0.1.0.dist-info/METADATA,sha256=qEozdnyk3KZ0M-d9PoPyfg97PgenrNnOtEAkdRBExNk,5187
+raglu-0.1.0.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+raglu-0.1.0.dist-info/top_level.txt,sha256=f2EdUXjqFV1EtaIUCQ8lQgZ4d9ewf5QJKy_jB7UzlTI,6
+raglu-0.1.0.dist-info/RECORD,,

raglu-0.1.0.dist-info/WHEEL

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

raglu-0.1.0.dist-info/licenses/LICENSE

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

raglu-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+raglu