gpuicalcc 0.1.3__tar.gz

gpuicalcc-0.1.3/LICENSE

@@ -0,0 +1,19 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright (c) 2026 Kleinverse AI, Inc.
+
+You are free to:
+  Share — copy and redistribute the material in any medium or format
+  Adapt — remix, transform, and build upon the material for any purpose,
+           even commercially.
+
+Under the following terms:
+  Attribution — You must give appropriate credit, provide a link to the
+                license, and indicate if changes were made. You may do so
+                in any reasonable manner, but not in any way that suggests
+                the licensor endorses you or your use.
+
+No additional restrictions — You may not apply legal terms or technological
+measures that legally restrict others from doing anything the license permits.
+
+Full license text: https://creativecommons.org/licenses/by/4.0/legalcode

gpuicalcc-0.1.3/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: gpuicalcc
+Version: 0.1.3
+Summary: GPU-accelerated locally centered contrast functions for FastICA
+Author-email: Tetsuya Saito <ted@kleinverse.io>
+License: CC BY 4.0
+Project-URL: Repository, https://github.com/Kleinverse/gpuicalcc
+Project-URL: CPU Package, https://github.com/Kleinverse/icalcc
+Project-URL: Research, https://github.com/Kleinverse/research
+Keywords: ICA,independent component analysis,blind source separation,locally centered contrast,cumulants,higher-order statistics,Renyi entropy,FastICA,scikit-learn,GPU,PyTorch,CUDA
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+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: License :: Other/Proprietary License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: icalcc>=0.1.3
+Requires-Dist: torch>=2.0
+Dynamic: license-file
+
+# gpuicalcc
+GPU-accelerated locally centered contrast functions for FastICA.
+PyTorch extension of [icalcc](https://github.com/Kleinverse/icalcc).
+Same API, drop-in replacement with CUDA acceleration for bounded
+and polynomial LCC contrasts.
+```python
+from gpuicalcc import GPUICALCC
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+```
+
+## Installation
+```bash
+pip install gpuicalcc
+```
+Requires PyTorch with CUDA. See [pytorch.org](https://pytorch.org)
+for installation instructions.
+
+## Supported K Values
+| K | Description |
+|---|---|
+| `'ltanh'` | Bounded LCC-tanh — 40–48× GPU speedup |
+| `'lexp'` | Bounded LCC-exp — 40–48× GPU speedup |
+| `4` | Polynomial LCC order 4 |
+| `6` | Polynomial LCC order 6, couples m₃, m₄, m₆ |
+| `8` | Polynomial LCC order 8, up to 2.4× GPU speedup at N≥500k |
+| `'tanh'` | Classical logcosh contrast (CPU fallback) |
+| `'exp'` | Classical Gaussian contrast (CPU fallback) |
+| `'skew'` | Classical cube contrast (CPU fallback) |
+
+Bounded contrasts (`'ltanh'`, `'lexp'`) achieve 40–48× speedup
+across all dataset sizes due to the O(NB) pairwise computation
+being embarrassingly parallel. Polynomial contrasts benefit from
+GPU acceleration at N ≥ 500,000. Classical contrasts fall back
+to the CPU implementation in `icalcc`.
+
+## Usage
+```python
+from gpuicalcc import GPUICALCC
+
+# Bounded LCC-tanh (recommended for heavy-tailed or skewed sources)
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Bounded LCC-tanh with memory limit
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda',
+                batch_size=500, gpu_mem_limit=8, random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Polynomial LCC order 8 (near-Gaussian sources)
+ica = GPUICALCC(n_components=4, K=8, device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Falls back to CPU automatically if CUDA unavailable
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+```
+
+## Parameters
+| Parameter | Default | Description |
+|---|---|---|
+| `device` | `'cuda'` | PyTorch device. Falls back to `'cpu'` if CUDA unavailable |
+| `batch_size` | `500` | Subsample size B for bounded pairwise computation |
+| `gpu_mem_limit` | `None` | GPU memory limit in GB. Auto-detected if None |
+| `clear_gpu` | `True` | Clear GPU cache after fit |
+
+## Benchmark
+![GPU Benchmark](https://github.com/Kleinverse/research/blob/main/icalcc/img/benchmark.png)
+
+Bounded contrasts (`ltanh`, `lexp`) achieve 40–48× speedup across
+all dataset sizes. Polynomial contrasts (K=4,6,8) benefit from GPU
+acceleration at N ≥ 500,000, reaching up to 2.4× at K=8. All runs
+use batch_size=500. Full benchmark table:
+[Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc).
+
+## Requirements
+- Python ≥ 3.9
+- numpy ≥ 1.24
+- scikit-learn ≥ 1.3
+- icalcc ≥ 0.1.0
+- torch ≥ 2.0
+
+## See Also
+- [icalcc](https://github.com/Kleinverse/icalcc) — CPU version
+- [Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc)
+
+## Citation
+
+If you use this package, please cite both the software paper and
+the underlying LCC kernel paper:
+```bibtex
+@article{saito2026icalcc,
+  author  = {Saito, Tetsuya},
+  title   = {{ICALCC}: Locally Centered Contrast Functions for
+             {FastICA} with {GPU} Acceleration},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+
+@article{saito2026lcc,
+  author  = {Saito, Tetsuya},
+  title   = {Locally Centered Cyclic Kernels for Higher-Order
+             Independent Component Analysis},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+```
+
+## License
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)

gpuicalcc-0.1.3/README.md

@@ -0,0 +1,109 @@
+# gpuicalcc
+GPU-accelerated locally centered contrast functions for FastICA.
+PyTorch extension of [icalcc](https://github.com/Kleinverse/icalcc).
+Same API, drop-in replacement with CUDA acceleration for bounded
+and polynomial LCC contrasts.
+```python
+from gpuicalcc import GPUICALCC
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+```
+
+## Installation
+```bash
+pip install gpuicalcc
+```
+Requires PyTorch with CUDA. See [pytorch.org](https://pytorch.org)
+for installation instructions.
+
+## Supported K Values
+| K | Description |
+|---|---|
+| `'ltanh'` | Bounded LCC-tanh — 40–48× GPU speedup |
+| `'lexp'` | Bounded LCC-exp — 40–48× GPU speedup |
+| `4` | Polynomial LCC order 4 |
+| `6` | Polynomial LCC order 6, couples m₃, m₄, m₆ |
+| `8` | Polynomial LCC order 8, up to 2.4× GPU speedup at N≥500k |
+| `'tanh'` | Classical logcosh contrast (CPU fallback) |
+| `'exp'` | Classical Gaussian contrast (CPU fallback) |
+| `'skew'` | Classical cube contrast (CPU fallback) |
+
+Bounded contrasts (`'ltanh'`, `'lexp'`) achieve 40–48× speedup
+across all dataset sizes due to the O(NB) pairwise computation
+being embarrassingly parallel. Polynomial contrasts benefit from
+GPU acceleration at N ≥ 500,000. Classical contrasts fall back
+to the CPU implementation in `icalcc`.
+
+## Usage
+```python
+from gpuicalcc import GPUICALCC
+
+# Bounded LCC-tanh (recommended for heavy-tailed or skewed sources)
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Bounded LCC-tanh with memory limit
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda',
+                batch_size=500, gpu_mem_limit=8, random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Polynomial LCC order 8 (near-Gaussian sources)
+ica = GPUICALCC(n_components=4, K=8, device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Falls back to CPU automatically if CUDA unavailable
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+```
+
+## Parameters
+| Parameter | Default | Description |
+|---|---|---|
+| `device` | `'cuda'` | PyTorch device. Falls back to `'cpu'` if CUDA unavailable |
+| `batch_size` | `500` | Subsample size B for bounded pairwise computation |
+| `gpu_mem_limit` | `None` | GPU memory limit in GB. Auto-detected if None |
+| `clear_gpu` | `True` | Clear GPU cache after fit |
+
+## Benchmark
+![GPU Benchmark](https://github.com/Kleinverse/research/blob/main/icalcc/img/benchmark.png)
+
+Bounded contrasts (`ltanh`, `lexp`) achieve 40–48× speedup across
+all dataset sizes. Polynomial contrasts (K=4,6,8) benefit from GPU
+acceleration at N ≥ 500,000, reaching up to 2.4× at K=8. All runs
+use batch_size=500. Full benchmark table:
+[Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc).
+
+## Requirements
+- Python ≥ 3.9
+- numpy ≥ 1.24
+- scikit-learn ≥ 1.3
+- icalcc ≥ 0.1.0
+- torch ≥ 2.0
+
+## See Also
+- [icalcc](https://github.com/Kleinverse/icalcc) — CPU version
+- [Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc)
+
+## Citation
+
+If you use this package, please cite both the software paper and
+the underlying LCC kernel paper:
+```bibtex
+@article{saito2026icalcc,
+  author  = {Saito, Tetsuya},
+  title   = {{ICALCC}: Locally Centered Contrast Functions for
+             {FastICA} with {GPU} Acceleration},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+
+@article{saito2026lcc,
+  author  = {Saito, Tetsuya},
+  title   = {Locally Centered Cyclic Kernels for Higher-Order
+             Independent Component Analysis},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+```
+
+## License
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)

gpuicalcc-0.1.3/gpuicalcc.egg-info/PKG-INFO

@@ -0,0 +1,137 @@
+Metadata-Version: 2.4
+Name: gpuicalcc
+Version: 0.1.3
+Summary: GPU-accelerated locally centered contrast functions for FastICA
+Author-email: Tetsuya Saito <ted@kleinverse.io>
+License: CC BY 4.0
+Project-URL: Repository, https://github.com/Kleinverse/gpuicalcc
+Project-URL: CPU Package, https://github.com/Kleinverse/icalcc
+Project-URL: Research, https://github.com/Kleinverse/research
+Keywords: ICA,independent component analysis,blind source separation,locally centered contrast,cumulants,higher-order statistics,Renyi entropy,FastICA,scikit-learn,GPU,PyTorch,CUDA
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Programming Language :: Python :: 3
+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: License :: Other/Proprietary License
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: icalcc>=0.1.3
+Requires-Dist: torch>=2.0
+Dynamic: license-file
+
+# gpuicalcc
+GPU-accelerated locally centered contrast functions for FastICA.
+PyTorch extension of [icalcc](https://github.com/Kleinverse/icalcc).
+Same API, drop-in replacement with CUDA acceleration for bounded
+and polynomial LCC contrasts.
+```python
+from gpuicalcc import GPUICALCC
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+```
+
+## Installation
+```bash
+pip install gpuicalcc
+```
+Requires PyTorch with CUDA. See [pytorch.org](https://pytorch.org)
+for installation instructions.
+
+## Supported K Values
+| K | Description |
+|---|---|
+| `'ltanh'` | Bounded LCC-tanh — 40–48× GPU speedup |
+| `'lexp'` | Bounded LCC-exp — 40–48× GPU speedup |
+| `4` | Polynomial LCC order 4 |
+| `6` | Polynomial LCC order 6, couples m₃, m₄, m₆ |
+| `8` | Polynomial LCC order 8, up to 2.4× GPU speedup at N≥500k |
+| `'tanh'` | Classical logcosh contrast (CPU fallback) |
+| `'exp'` | Classical Gaussian contrast (CPU fallback) |
+| `'skew'` | Classical cube contrast (CPU fallback) |
+
+Bounded contrasts (`'ltanh'`, `'lexp'`) achieve 40–48× speedup
+across all dataset sizes due to the O(NB) pairwise computation
+being embarrassingly parallel. Polynomial contrasts benefit from
+GPU acceleration at N ≥ 500,000. Classical contrasts fall back
+to the CPU implementation in `icalcc`.
+
+## Usage
+```python
+from gpuicalcc import GPUICALCC
+
+# Bounded LCC-tanh (recommended for heavy-tailed or skewed sources)
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Bounded LCC-tanh with memory limit
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda',
+                batch_size=500, gpu_mem_limit=8, random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Polynomial LCC order 8 (near-Gaussian sources)
+ica = GPUICALCC(n_components=4, K=8, device='cuda', random_state=0)
+S_hat = ica.fit_transform(X)
+
+# Falls back to CPU automatically if CUDA unavailable
+ica = GPUICALCC(n_components=4, K='ltanh', device='cuda', random_state=0)
+```
+
+## Parameters
+| Parameter | Default | Description |
+|---|---|---|
+| `device` | `'cuda'` | PyTorch device. Falls back to `'cpu'` if CUDA unavailable |
+| `batch_size` | `500` | Subsample size B for bounded pairwise computation |
+| `gpu_mem_limit` | `None` | GPU memory limit in GB. Auto-detected if None |
+| `clear_gpu` | `True` | Clear GPU cache after fit |
+
+## Benchmark
+![GPU Benchmark](https://github.com/Kleinverse/research/blob/main/icalcc/img/benchmark.png)
+
+Bounded contrasts (`ltanh`, `lexp`) achieve 40–48× speedup across
+all dataset sizes. Polynomial contrasts (K=4,6,8) benefit from GPU
+acceleration at N ≥ 500,000, reaching up to 2.4× at K=8. All runs
+use batch_size=500. Full benchmark table:
+[Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc).
+
+## Requirements
+- Python ≥ 3.9
+- numpy ≥ 1.24
+- scikit-learn ≥ 1.3
+- icalcc ≥ 0.1.0
+- torch ≥ 2.0
+
+## See Also
+- [icalcc](https://github.com/Kleinverse/icalcc) — CPU version
+- [Experiment code](https://github.com/Kleinverse/research/tree/main/icalcc)
+
+## Citation
+
+If you use this package, please cite both the software paper and
+the underlying LCC kernel paper:
+```bibtex
+@article{saito2026icalcc,
+  author  = {Saito, Tetsuya},
+  title   = {{ICALCC}: Locally Centered Contrast Functions for
+             {FastICA} with {GPU} Acceleration},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+
+@article{saito2026lcc,
+  author  = {Saito, Tetsuya},
+  title   = {Locally Centered Cyclic Kernels for Higher-Order
+             Independent Component Analysis},
+  journal = {TechRxiv},
+  year    = {2026}
+}
+```
+
+## License
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)

gpuicalcc-0.1.3/gpuicalcc.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+gpuicalcc.py
+pyproject.toml
+gpuicalcc.egg-info/PKG-INFO
+gpuicalcc.egg-info/SOURCES.txt
+gpuicalcc.egg-info/dependency_links.txt
+gpuicalcc.egg-info/requires.txt
+gpuicalcc.egg-info/top_level.txt

gpuicalcc-0.1.3/gpuicalcc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gpuicalcc-0.1.3/gpuicalcc.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.24
+scikit-learn>=1.3
+icalcc>=0.1.3
+torch>=2.0

gpuicalcc-0.1.3/gpuicalcc.egg-info/top_level.txt

@@ -0,0 +1 @@
+gpuicalcc

gpuicalcc-0.1.3/gpuicalcc.py

@@ -0,0 +1,300 @@
+"""gpuicalcc: PyTorch-accelerated locally centered cyclic contrasts.
+
+GPU extension for ICALCC. Same API as sklearn FastICA:
+just replace the import and set K.
+
+    from gpuicalcc import GPUICALCC
+    est = GPUICALCC(K='ltanh', device='cuda')
+    est.fit(X)
+
+Supported K values: 4, 6, 8, 'ltanh', 'lexp', 'tanh', 'exp', 'skew'.
+
+Requirements: icalcc, torch
+
+Reference: T. Saito, "Locally Centered Cyclic Kernels for Higher-Order
+Independent Component Analysis," TechRxiv, 2026.
+https://doi.org/10.36227/techrxiv.XXXXXXX
+"""
+
+import numpy as np
+import warnings
+import torch
+from sklearn.exceptions import ConvergenceWarning
+from icalcc import ICALCC
+
+
+# -------------------------------------------------------------------
+#  Polynomial LCC on GPU  (K = 4, 6, 8)
+# -------------------------------------------------------------------
+
+def _gpu_lcc_h_gprime(y_np, k, device="cuda"):
+    """Polynomial LCC nonlinearity on GPU."""
+    y = torch.as_tensor(y_np, dtype=torch.float64, device=device)
+    y2 = y * y
+    y3 = y2 * y
+
+    if k == 4:
+        gy = (-3.0 / 16) * y3
+        gpy = (-9.0 / 16) * y2
+        return gy.cpu().numpy(), gpy.cpu().numpy()
+
+    m3 = y3.mean().item()
+    m4 = (y2 * y2).mean().item()
+
+    if k == 6:
+        dJ3 = 145 * m3 / 1944.0
+        dJ4 = 115.0 / 2592
+        dJ6 = -5.0 / 7776
+        y4 = y2 * y2
+        gy = dJ3 * 3 * y2 + dJ4 * 4 * y3 + dJ6 * 6 * (y4 * y)
+        gpy = dJ3 * 6 * y + dJ4 * 12 * y2 + dJ6 * 30 * y4
+        return gy.cpu().numpy(), gpy.cpu().numpy()
+
+    # k == 8
+    m5 = (y2 * y3).mean().item()
+    m6 = (y3 * y3).mean().item()
+    dJ3 = -7665 * m3 / 65536.0 + 497 * m5 / 262144.0
+    dJ4 = 2765 * m4 / 1048576.0 - 18795.0 / 524288
+    dJ5 = 497 * m3 / 262144.0
+    dJ6 = 329.0 / 524288
+    dJ8 = -7.0 / 2097152
+    y4 = y2 * y2
+    gy = (dJ3 * 3 * y2 + dJ4 * 4 * y3
+          + dJ5 * 5 * y4 + dJ6 * 6 * (y4 * y)
+          + dJ8 * 8 * (y4 * y3))
+    gpy = (dJ3 * 6 * y + dJ4 * 12 * y2
+           + dJ5 * 20 * y3 + dJ6 * 30 * y4
+           + dJ8 * 56 * (y3 * y3))
+    return gy.cpu().numpy(), gpy.cpu().numpy()
+
+
+def _gpu_lcc_contrast(x, K=6, device="cuda"):
+    """Polynomial LCC contrast for sklearn fun parameter."""
+    if x.ndim == 1:
+        return _gpu_lcc_h_gprime(x, K, device=device)
+    p, N = x.shape
+    gY = np.empty_like(x)
+    gpy = np.empty(p, dtype=x.dtype)
+    for i in range(p):
+        gi, gpi = _gpu_lcc_h_gprime(x[i], K, device=device)
+        gY[i] = gi
+        gpy[i] = gpi.mean()
+    return gY, gpy
+
+
+# -------------------------------------------------------------------
+#  Bounded LCC on GPU  (K = 'ltanh', 'lexp')
+# -------------------------------------------------------------------
+
+def _get_gpu_mem_bytes(device, gpu_mem_limit):
+    """Resolve effective GPU memory limit in bytes.
+
+    Auto-detects free memory.  If gpu_mem_limit is set and exceeds
+    97% of total, warns and caps at 97%.
+    """
+    if not device.startswith("cuda"):
+        return 4 * 1024**3  # 4GB fallback for CPU
+    free, total = torch.cuda.mem_get_info(device)
+    safe = int(total * 0.97)
+    if gpu_mem_limit is None:
+        return min(free, safe)
+    requested = int(gpu_mem_limit * 1024**3)
+    if requested > safe:
+        warnings.warn(
+            f"gpu_mem_limit={gpu_mem_limit}GB exceeds 97% of "
+            f"GPU memory ({total/1024**3:.1f}GB). "
+            f"Capping at {safe/1024**3:.1f}GB.",
+            RuntimeWarning)
+        return safe
+    return requested
+
+
+def _gpu_bounded_contrast(x, G="tanh", batch_size=500,
+                          device="cuda", gpu_mem_limit=None):
+    """Pairwise bounded LCC contrast on GPU.
+
+    Handles both deflation (1-D) and parallel (2-D).
+    Auto-detects GPU memory; user can override via gpu_mem_limit (GB).
+    Halves chunk size on OOM.
+    """
+    if x.ndim == 1:
+        return _gpu_bounded_1d(x, G, batch_size, device)
+
+    p, N = x.shape
+    B = min(batch_size, N)
+    step = max(1, N // B)
+    idx = np.arange(0, N, step)[:B]
+
+    mem = _get_gpu_mem_bytes(device, gpu_mem_limit)
+    max_chunk = max(1, mem // (p * B * 8 * 6))
+
+    X_batch = torch.as_tensor(x[:, idx], dtype=torch.float64,
+                              device=device)
+    gY = np.empty_like(x)
+    gpY = np.empty_like(x)
+
+    start = 0
+    while start < N:
+        end = min(start + max_chunk, N)
+        try:
+            X_chunk = torch.as_tensor(
+                x[:, start:end], dtype=torch.float64, device=device)
+            diff = X_chunk.unsqueeze(2) - X_batch.unsqueeze(1)
+
+            if G == "tanh":
+                t = torch.tanh(diff)
+                gY[:, start:end] = t.mean(dim=2).cpu().numpy()
+                gpY[:, start:end] = (1.0 - t * t).mean(
+                    dim=2).cpu().numpy()
+            else:  # exp
+                e = torch.exp(-0.5 * diff * diff)
+                gY[:, start:end] = (diff * e).mean(
+                    dim=2).cpu().numpy()
+                gpY[:, start:end] = ((1.0 - diff * diff) * e).mean(
+                    dim=2).cpu().numpy()
+
+            del diff, X_chunk
+            torch.cuda.empty_cache()
+            start = end
+
+        except torch.cuda.OutOfMemoryError:
+            del X_chunk
+            torch.cuda.empty_cache()
+            max_chunk = max(1, max_chunk // 2)
+
+    del X_batch
+    return gY, gpY.mean(axis=1)
+
+
+def _gpu_bounded_1d(y_np, G, batch_size, device):
+    """1-D bounded LCC for deflation algorithm."""
+    N = len(y_np)
+    B = min(batch_size, N)
+    step = max(1, N // B)
+    idx = np.arange(0, N, step)[:B]
+
+    y = torch.as_tensor(y_np, dtype=torch.float64, device=device)
+    y_batch = y[idx]
+    diff = y.unsqueeze(1) - y_batch.unsqueeze(0)
+
+    if G == "tanh":
+        t = torch.tanh(diff)
+        gy = t.mean(dim=1)
+        gpy = (1.0 - t * t).mean(dim=1)
+    else:
+        e = torch.exp(-0.5 * diff * diff)
+        gy = (diff * e).mean(dim=1)
+        gpy = ((1.0 - diff * diff) * e).mean(dim=1)
+
+    return gy.cpu().numpy(), gpy.cpu().numpy()
+
+
+# -------------------------------------------------------------------
+#  Main class
+# -------------------------------------------------------------------
+
+class GPUICALCC(ICALCC):
+    """GPU-accelerated ICALCC.
+
+    Accelerates all LCC contrasts (polynomial and bounded) via
+    PyTorch.  Classical contrasts ('tanh', 'exp', 'skew') and
+    FastICA(k) contrasts fall back to the parent class.
+
+    Parameters
+    ----------
+    K : contrast selector (same as ICALCC)
+    device : str, default='cuda'
+        PyTorch device.  Falls back to 'cpu' if CUDA unavailable.
+    batch_size : int, default=500
+        Subsample size for bounded pairwise computation.
+    **kwargs : passed to ICALCC
+
+    Examples
+    --------
+    >>> from gpuicalcc import GPUICALCC
+    >>> est = GPUICALCC(n_components=4, K='ltanh', device='cuda')
+    >>> S_hat = est.fit_transform(X)
+    >>> est6 = GPUICALCC(n_components=4, K=6, device='cuda')
+    >>> S6 = est6.fit_transform(X)
+    """
+
+    def __init__(self, n_components=None, *, K=6, device="cuda",
+                 batch_size=500, gpu_mem_limit=None,
+                 algorithm="parallel",
+                 whiten="unit-variance", max_iter=200, tol=1e-4,
+                 w_init=None, whiten_solver="svd",
+                 random_state=None, clear_gpu=True):
+
+        if device.startswith("cuda") and not torch.cuda.is_available():
+            warnings.warn(
+                "CUDA not available, falling back to device='cpu'.",
+                RuntimeWarning)
+            device = "cpu"
+        self.device = device
+        self.batch_size = batch_size
+        self.gpu_mem_limit = gpu_mem_limit
+        self.clear_gpu = clear_gpu
+
+        super().__init__(
+            n_components=n_components, K=K,
+            algorithm=algorithm, whiten=whiten,
+            max_iter=max_iter, tol=tol, w_init=w_init,
+            whiten_solver=whiten_solver, random_state=random_state)
+
+        # override with GPU versions
+        if K in self._LCC_BOUNDED_MAP:
+            G = self._LCC_BOUNDED_MAP[K]
+            self.fun = _gpu_bounded_contrast
+            self.fun_args = dict(G=G, batch_size=batch_size,
+                                 device=self.device,
+                                 gpu_mem_limit=gpu_mem_limit)
+        elif isinstance(K, int) and K in (4, 6, 8):
+            self.fun = _gpu_lcc_contrast
+            self.fun_args = dict(K=K, device=self.device)
+
+    def get_params(self, deep=True):
+        params = super().get_params(deep=deep)
+        params["device"] = self.device
+        params["batch_size"] = self.batch_size
+        params["gpu_mem_limit"] = self.gpu_mem_limit
+        params["clear_gpu"] = self.clear_gpu
+        return params
+
+    def set_params(self, **params):
+        device = params.pop("device", None)
+        batch_size = params.pop("batch_size", None)
+        gpu_mem_limit = params.pop("gpu_mem_limit", None)
+        if device is not None:
+            self.device = device
+        if batch_size is not None:
+            self.batch_size = batch_size
+        if gpu_mem_limit is not None:
+            self.gpu_mem_limit = gpu_mem_limit
+        super().set_params(**params)
+        K = self.K
+        if K in self._LCC_BOUNDED_MAP:
+            G = self._LCC_BOUNDED_MAP[K]
+            self.fun = _gpu_bounded_contrast
+            self.fun_args = dict(G=G, batch_size=self.batch_size,
+                                 device=self.device,
+                                 gpu_mem_limit=self.gpu_mem_limit)
+        elif isinstance(K, int) and K in (4, 6, 8):
+            self.fun = _gpu_lcc_contrast
+            self.fun_args = dict(K=K, device=self.device)
+        return self
+
+    def _clear(self):
+        if self.clear_gpu and self.device.startswith("cuda"):
+            import gc
+            gc.collect()
+            torch.cuda.empty_cache()
+
+    def fit(self, X, y=None):
+        result = super().fit(X, y)
+        self._clear()
+        return result
+
+    def fit_transform(self, X, y=None):
+        result = super().fit_transform(X, y)
+        self._clear()
+        return result

gpuicalcc-0.1.3/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "gpuicalcc"
+version = "0.1.3"
+description = "GPU-accelerated locally centered contrast functions for FastICA"
+readme = "README.md"
+license = { text = "CC BY 4.0" }
+authors = [
+    { name = "Tetsuya Saito", email = "ted@kleinverse.io" }
+]
+keywords = [
+    "ICA", "independent component analysis", "blind source separation",
+    "locally centered contrast", "cumulants", "higher-order statistics",
+    "Renyi entropy", "FastICA", "scikit-learn", "GPU", "PyTorch", "CUDA"
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "License :: Other/Proprietary License",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.24",
+    "scikit-learn>=1.3",
+    "icalcc>=0.1.3",
+    "torch>=2.0",
+]
+
+[project.urls]
+Repository = "https://github.com/Kleinverse/gpuicalcc"
+"CPU Package" = "https://github.com/Kleinverse/icalcc"
+Research = "https://github.com/Kleinverse/research"
+
+[tool.setuptools]
+py-modules = ["gpuicalcc"]

gpuicalcc-0.1.3/setup.cfg

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