raglu 0.1.0__tar.gz

raglu-0.1.0/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/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,159 @@
+# 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/pyproject.toml

@@ -0,0 +1,61 @@
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "raglu"
+version = "0.1.0"
+description = "Pure Rational GLU (RaGLU) and RaLU activations for PyTorch, Triton CUDA and Apple MLX."
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Ömer Faruk Solmaz" },
+]
+keywords = [
+    "activation",
+    "glu",
+    "ralu",
+    "rational",
+    "pytorch",
+    "triton",
+    "mlx",
+    "deep-learning",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Typing :: Typed",
+]
+dependencies = [
+    "torch>=2.0.0",
+]
+
+[project.optional-dependencies]
+triton = ["triton>=2.0.0"]
+mlx = ["mlx>=0.1.0"]
+dev = [
+    "pytest>=7.0.0",
+    "build>=1.0.0",
+    "twine>=4.0.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["raglu*"]
+
+[tool.setuptools.package-data]
+raglu = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "-ra"

raglu-0.1.0/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-0.1.0/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-0.1.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/raglu.egg-info/PKG-INFO

@@ -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/raglu.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+raglu/__init__.py
+raglu/core.py
+raglu/py.typed
+raglu/torch_module.py
+raglu.egg-info/PKG-INFO
+raglu.egg-info/SOURCES.txt
+raglu.egg-info/dependency_links.txt
+raglu.egg-info/requires.txt
+raglu.egg-info/top_level.txt
+tests/test_raglu.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,12 @@
+torch>=2.0.0
+
+[dev]
+pytest>=7.0.0
+build>=1.0.0
+twine>=4.0.0
+
+[mlx]
+mlx>=0.1.0
+
+[triton]
+triton>=2.0.0

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

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

raglu-0.1.0/setup.cfg

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

raglu-0.1.0/tests/test_raglu.py

@@ -0,0 +1,289 @@
+"""RaGLU testleri: PyTorch autograd, Triton ve MLX doğrulaması."""
+
+import math
+
+import pytest
+import torch
+
+import raglu
+from raglu import (
+    HAS_MLX,
+    HAS_TRITON,
+    RaGLU,
+    RaLU,
+    fused_pure_rational,
+    fused_pure_rational_glu,
+)
+
+
+def _reference_rational(x: torch.Tensor) -> torch.Tensor:
+    x_sq = x * x
+    return (x * x_sq + x) / (x_sq + 3.0)
+
+
+def _reference_glu(gate: torch.Tensor, val: torch.Tensor) -> torch.Tensor:
+    return _reference_rational(gate) * val
+
+
+# ==============================================================================
+# PyTorch fallback: ileri yön
+# ==============================================================================
+def test_ralu_matches_reference():
+    torch.manual_seed(0)
+    x = torch.randn(1024, dtype=torch.float64)
+    out = fused_pure_rational(x)
+    assert torch.allclose(out, _reference_rational(x), atol=1e-12, rtol=1e-12)
+
+
+def test_raglu_matches_reference():
+    torch.manual_seed(0)
+    gate = torch.randn(64, 128, dtype=torch.float64)
+    val = torch.randn(64, 128, dtype=torch.float64)
+    out = fused_pure_rational_glu(gate, val)
+    assert torch.allclose(out, _reference_glu(gate, val), atol=1e-12, rtol=1e-12)
+
+
+@pytest.mark.parametrize("dtype", [torch.float32, torch.float64])
+def test_shapes_and_dtypes_preserved(dtype):
+    gate = torch.randn(3, 5, 7, dtype=dtype)
+    val = torch.randn(3, 5, 7, dtype=dtype)
+    out = fused_pure_rational_glu(gate, val)
+    assert out.shape == gate.shape
+    assert out.dtype == dtype
+
+
+@pytest.mark.skipif(not torch.backends.mps.is_available(), reason="MPS yok")
+def test_mps_fallback_forward_backward():
+    gate = torch.randn(4, 8, device="mps", requires_grad=True)
+    val = torch.randn(4, 8, device="mps", requires_grad=True)
+    out = fused_pure_rational_glu(gate, val)
+    assert out.device.type == "mps"
+    out.sum().backward()
+    assert gate.grad is not None and torch.isfinite(gate.grad).all()
+    assert val.grad is not None and torch.isfinite(val.grad).all()
+
+
+def test_odd_and_empty_sizes():
+    # Triton çekirdeğinin maskeleme sınırları ve boş tensörler.
+    gate = torch.randn(1023, dtype=torch.float64)
+    val = torch.randn(1023, dtype=torch.float64)
+    assert torch.allclose(
+        fused_pure_rational_glu(gate, val), _reference_glu(gate, val), atol=1e-12
+    )
+
+    empty = torch.empty(0, dtype=torch.float64)
+    out = fused_pure_rational_glu(empty, empty)
+    assert out.shape == (0,)
+
+
+def test_function_is_odd():
+    # f(-x) = -f(x) olduğundan aktivasyon tek fonksiyondur.
+    x = torch.linspace(-5.0, 5.0, 101, dtype=torch.float64)
+    assert torch.allclose(fused_pure_rational(-x), -fused_pure_rational(x), atol=1e-12)
+
+
+# ==============================================================================
+# Gradyan doğrulaması (torch.autograd.gradcheck)
+# ==============================================================================
+def test_ralu_gradcheck():
+    x = torch.randn(16, 16, dtype=torch.float64, requires_grad=True)
+    assert torch.autograd.gradcheck(fused_pure_rational, (x,), eps=1e-6, atol=1e-5)
+
+
+def test_raglu_gradcheck():
+    gate = torch.randn(16, 16, dtype=torch.float64, requires_grad=True)
+    val = torch.randn(16, 16, dtype=torch.float64, requires_grad=True)
+    assert torch.autograd.gradcheck(
+        fused_pure_rational_glu, (gate, val), eps=1e-6, atol=1e-5
+    )
+
+
+def test_raglu_gradcheck_non_contiguous():
+    gate = torch.randn(32, 32, dtype=torch.float64, requires_grad=True).t()
+    val = torch.randn(32, 32, dtype=torch.float64, requires_grad=True).t()
+    assert torch.autograd.gradcheck(
+        fused_pure_rational_glu, (gate, val), eps=1e-6, atol=1e-5
+    )
+
+
+def test_raglu_backward_formula():
+    x = torch.linspace(-3.0, 3.0, 101, dtype=torch.float64, requires_grad=True)
+    fused_pure_rational(x).sum().backward()
+    # df/dx = (x^4 + 8x^2 + 3) / (x^2 + 3)^2
+    x_sq = x.detach() ** 2
+    expected = (x_sq**2 + 8.0 * x_sq + 3.0) / (x_sq + 3.0) ** 2
+    assert torch.allclose(x.grad, expected, atol=1e-12, rtol=1e-12)
+
+
+# ==============================================================================
+# nn.Module katmanları
+# ==============================================================================
+def test_ralu_module_shape_and_grad():
+    layer = RaLU()
+    x = torch.randn(4, 8, requires_grad=True)
+    out = layer(x)
+    assert out.shape == x.shape
+    out.sum().backward()
+    assert x.grad is not None
+    assert torch.isfinite(x.grad).all()
+
+
+def test_raglu_module_default_out_features():
+    layer = RaGLU(16)
+    x = torch.randn(2, 3, 16)
+    out = layer(x)
+    assert out.shape == (2, 3, 16)
+    assert layer.linear.weight.shape == (32, 16)
+    assert "in_features=16" in repr(layer)
+
+
+def test_raglu_module_projection():
+    layer = RaGLU(16, 32, bias=False)
+    x = torch.randn(5, 16)
+    out = layer(x)
+    assert out.shape == (5, 32)
+    assert layer.linear.bias is None
+    assert sum(p.numel() for p in layer.parameters()) == 2 * 32 * 16
+
+
+def test_raglu_module_matches_manual_computation():
+    torch.manual_seed(0)
+    layer = RaGLU(8, 4).double()
+    x = torch.randn(6, 8, dtype=torch.float64)
+    linear_out = layer.linear(x)
+    gate, val = linear_out.chunk(2, dim=-1)
+    expected = _reference_glu(gate, val)
+    assert torch.allclose(layer(x), expected, atol=1e-12)
+
+
+def test_raglu_module_custom_gate_val():
+    gate = torch.nn.Linear(8, 12, bias=False)
+    val = torch.nn.Linear(8, 12, bias=False)
+    layer = RaGLU(gate=gate, val=val)
+    x = torch.randn(3, 8)
+    assert layer(x).shape == (3, 12)
+    assert layer.linear is None
+
+
+def test_raglu_module_gradcheck():
+    torch.manual_seed(0)
+    layer = RaGLU(4, 3).double()
+    x = torch.randn(5, 4, dtype=torch.float64, requires_grad=True)
+    assert torch.autograd.gradcheck(lambda t: layer(t), (x,), eps=1e-6, atol=1e-5)
+
+
+def test_raglu_module_validation():
+    with pytest.raises(ValueError):
+        RaGLU()
+    with pytest.raises(ValueError):
+        RaGLU(gate=torch.nn.Linear(4, 4))
+    with pytest.raises(ValueError):
+        RaGLU(4, gate=torch.nn.Linear(4, 4), val=torch.nn.Linear(4, 4))
+
+
+def test_raglu_module_mismatched_custom_shapes():
+    layer = RaGLU(
+        gate=torch.nn.Linear(4, 8, bias=False),
+        val=torch.nn.Linear(4, 7, bias=False),
+    )
+    with pytest.raises(ValueError):
+        layer(torch.randn(2, 4))
+
+
+def test_package_exports():
+    assert raglu.__version__ == "0.1.0"
+    for name in (
+        "fused_pure_rational_glu",
+        "fused_pure_rational",
+        "RaGLU",
+        "RaLU",
+        "HAS_TRITON",
+        "HAS_MLX",
+    ):
+        assert hasattr(raglu, name)
+
+
+# ==============================================================================
+# Triton fused kernel doğrulaması (yalnızca CUDA + Triton varsa)
+# ==============================================================================
+@pytest.mark.skipif(not (HAS_TRITON and torch.cuda.is_available()), reason="CUDA/Triton yok")
+def test_triton_forward_matches_fallback():
+    torch.manual_seed(0)
+    device = torch.device("cuda")
+    # Clamp sınırı olan +/-50'nin oldukça altında değerler kullanılır.
+    gate = torch.randn(4096, device=device) * 3.0
+    val = torch.randn(4096, device=device)
+
+    fused = fused_pure_rational_glu(gate, val)
+    g_sq = gate * gate
+    fallback = ((gate * g_sq + gate) / (g_sq + 3.0)) * val
+
+    assert torch.allclose(fused, fallback, atol=1e-4, rtol=1e-4)
+
+
+@pytest.mark.skipif(not (HAS_TRITON and torch.cuda.is_available()), reason="CUDA/Triton yok")
+def test_triton_backward_matches_autograd():
+    torch.manual_seed(1)
+    device = torch.device("cuda")
+    gate_f = (torch.randn(4096, device=device) * 3.0).requires_grad_(True)
+    val_f = torch.randn(4096, device=device, requires_grad=True)
+    gate_r = gate_f.detach().clone().requires_grad_(True)
+    val_r = val_f.detach().clone().requires_grad_(True)
+    dy = torch.randn(4096, device=device)
+
+    # Fused yol
+    fused = raglu.core.FusedPureRationalGLUFunction.apply(gate_f, val_f)
+    dg_f, dv_f = torch.autograd.grad(fused, (gate_f, val_f), grad_outputs=dy)
+
+    # Referans yol
+    out_r = _reference_glu(gate_r, val_r)
+    dg_r, dv_r = torch.autograd.grad(out_r, (gate_r, val_r), grad_outputs=dy)
+
+    assert torch.allclose(fused.detach(), out_r.detach(), atol=1e-4, rtol=1e-4)
+    assert torch.allclose(dg_f, dg_r, atol=1e-4, rtol=1e-4)
+    assert torch.allclose(dv_f, dv_r, atol=1e-4, rtol=1e-4)
+
+
+@pytest.mark.skipif(not (HAS_TRITON and torch.cuda.is_available()), reason="CUDA/Triton yok")
+def test_triton_non_contiguous_inputs():
+    torch.manual_seed(2)
+    device = torch.device("cuda")
+    gate = (torch.randn(64, 64, device=device) * 2.0).t().requires_grad_(True)
+    val = torch.randn(64, 64, device=device).t().requires_grad_(True)
+    out = fused_pure_rational_glu(gate, val)
+    out.sum().backward()
+    assert torch.isfinite(gate.grad).all()
+    assert torch.isfinite(val.grad).all()
+
+
+# ==============================================================================
+# MLX doğrulaması (yalnızca MLX kuruluysa)
+# ==============================================================================
+@pytest.mark.skipif(not HAS_MLX, reason="MLX kurulu değil")
+def test_mlx_matches_pytorch():
+    import mlx.core as mx
+    import numpy as np
+
+    gate_np = np.random.default_rng(0).standard_normal((32, 32)).astype(np.float32)
+    val_np = np.random.default_rng(1).standard_normal((32, 32)).astype(np.float32)
+
+    mx_out = raglu.mlx_pure_rational_glu(mx.array(gate_np), mx.array(val_np))
+    mx_out = np.array(mx_out)
+
+    pt_out = fused_pure_rational_glu(
+        torch.from_numpy(gate_np), torch.from_numpy(val_np)
+    ).numpy()
+
+    assert np.allclose(mx_out, pt_out, atol=1e-5, rtol=1e-5)
+
+
+@pytest.mark.skipif(not HAS_MLX, reason="MLX kurulu değil")
+def test_mlx_ralu_values():
+    import mlx.core as mx
+    import numpy as np
+
+    x_np = np.linspace(-4.0, 4.0, 101, dtype=np.float32)
+    mx_out = np.array(raglu.mlx_pure_rational(mx.array(x_np)))
+    x_sq = x_np * x_np
+    expected = (x_np * x_sq + x_np) / (x_sq + 3.0)
+    assert np.allclose(mx_out, expected, atol=1e-6)