quarterbit 0.1.0__py3-none-any.whl

quarterbit/torch/utils.py

@@ -0,0 +1,239 @@
+"""
+QuarterBit PyTorch Backend — Utilities
+Copyright (c) 2026 Clouthier Simulation Labs. All rights reserved.
+"""
+
+import ctypes
+from pathlib import Path
+import warnings
+import sys
+
+_lib = None
+_available = None
+
+def _load_backend():
+    """Load the QuarterBit CUDA backend."""
+    global _lib, _available
+
+    if _available is not None:
+        return _available
+
+    # DLL search paths (compiled binaries only - source is confidential)
+    candidates = [
+        Path(__file__).parent.parent / "bin" / "quarterbit_core.dll",
+        Path(__file__).parent.parent.parent / "build" / "quarterbit_core.dll",
+        Path(r"C:\QuarterBit\build\quarterbit_core.dll"),
+    ]
+
+    # Linux paths
+    if sys.platform != "win32":
+        candidates = [
+            Path(__file__).parent.parent / "bin" / "libquarterbit_core.so",
+            Path(__file__).parent.parent.parent / "build" / "libquarterbit_core.so",
+        ]
+
+    for path in candidates:
+        if path.exists():
+            try:
+                _lib = ctypes.CDLL(str(path))
+                _configure_functions()
+                _available = True
+                return True
+            except Exception as e:
+                warnings.warn(f"Failed to load QuarterBit backend: {e}")
+
+    _available = False
+    return False
+
+def _configure_functions():
+    """Configure ctypes function signatures."""
+    global _lib
+
+    P_F = ctypes.POINTER(ctypes.c_float)
+
+    # eft_accumulate
+    _lib.eft_accumulate.argtypes = [P_F, P_F, P_F, ctypes.c_int]
+    _lib.eft_accumulate.restype = ctypes.c_int
+
+    # eft_accumulate_scaled
+    _lib.eft_accumulate_scaled.argtypes = [P_F, P_F, P_F, ctypes.c_float, ctypes.c_int]
+    _lib.eft_accumulate_scaled.restype = ctypes.c_int
+
+    # eft_sgd_step
+    _lib.eft_sgd_step.argtypes = [
+        P_F, P_F, P_F,  # weight, comp, grad
+        ctypes.c_float, ctypes.c_float,  # lr, weight_decay
+        ctypes.c_int  # n
+    ]
+    _lib.eft_sgd_step.restype = ctypes.c_int
+
+    # eft_adam_step
+    _lib.eft_adam_step.argtypes = [
+        P_F, P_F, P_F,  # weight, weight_comp, grad
+        P_F, P_F,  # exp_avg, exp_avg_sq
+        P_F, P_F,  # exp_avg_comp, exp_avg_sq_comp
+        ctypes.c_float, ctypes.c_float, ctypes.c_float,  # lr, beta1, beta2
+        ctypes.c_float, ctypes.c_float,  # eps, weight_decay
+        ctypes.c_int, ctypes.c_int  # step, n
+    ]
+    _lib.eft_adam_step.restype = ctypes.c_int
+
+    # eft_matmul
+    _lib.eft_matmul.argtypes = [P_F, P_F, P_F, ctypes.c_int, ctypes.c_int, ctypes.c_int]
+    _lib.eft_matmul.restype = ctypes.c_int
+
+    # eft_reduce_sum
+    _lib.eft_reduce_sum.argtypes = [P_F, P_F, P_F, ctypes.c_int]
+    _lib.eft_reduce_sum.restype = ctypes.c_int
+
+    # eft_zero_compensation
+    _lib.eft_zero_compensation.argtypes = [P_F, ctypes.c_int]
+    _lib.eft_zero_compensation.restype = ctypes.c_int
+
+    # Try to configure compact functions (may not be present in core library)
+    _try_configure_compact_functions()
+
+
+def _try_configure_compact_functions():
+    """Try to configure compact adam functions. These may be in a separate library."""
+    global _lib
+
+    P_F = ctypes.POINTER(ctypes.c_float)
+    P_V = ctypes.c_void_p
+
+    # Check if compact functions already exist in core lib
+    if hasattr(_lib, 'compact_adam_create'):
+        _configure_compact_signatures()
+        return
+
+    # Try to load compact library separately
+    compact_candidates = [
+        Path(__file__).parent.parent / "bin" / "quarterbit_compact.dll",
+        Path(__file__).parent.parent.parent / "build" / "quarterbit_compact.dll",
+        Path(r"C:\QuarterBit\build\quarterbit_compact.dll"),
+    ]
+    if sys.platform != "win32":
+        compact_candidates = [
+            Path(__file__).parent.parent / "bin" / "libquarterbit_compact.so",
+            Path(__file__).parent.parent.parent / "build" / "libquarterbit_compact.so",
+        ]
+
+    for path in compact_candidates:
+        if path.exists():
+            try:
+                compact_lib = ctypes.CDLL(str(path))
+                # Add compact functions to main lib object for unified access
+                _lib.compact_adam_create = compact_lib.compact_adam_create
+                _lib.compact_adam_step = compact_lib.compact_adam_step
+                _lib.compact_adam_destroy = compact_lib.compact_adam_destroy
+                _lib.compact_adam_memory_info = compact_lib.compact_adam_memory_info
+                _configure_compact_signatures()
+                return
+            except Exception:
+                pass
+
+
+def _configure_compact_signatures():
+    """Configure ctypes signatures for compact functions."""
+    global _lib
+
+    P_F = ctypes.POINTER(ctypes.c_float)
+    P_V = ctypes.c_void_p
+    P_D = ctypes.POINTER(ctypes.c_double)
+
+    # compact_adam_create(n, use_ef) -> handle
+    _lib.compact_adam_create.argtypes = [ctypes.c_int, ctypes.c_int]
+    _lib.compact_adam_create.restype = P_V
+
+    # compact_adam_step(handle, params, grads, lr, beta1, beta2, eps, step) -> int
+    _lib.compact_adam_step.argtypes = [
+        P_V, P_F, P_F,  # handle, params, grads
+        ctypes.c_float, ctypes.c_float, ctypes.c_float, ctypes.c_float,  # lr, beta1, beta2, eps
+        ctypes.c_int  # step
+    ]
+    _lib.compact_adam_step.restype = ctypes.c_int
+
+    # compact_adam_destroy(handle)
+    _lib.compact_adam_destroy.argtypes = [P_V]
+    _lib.compact_adam_destroy.restype = None
+
+    # compact_adam_memory_info(n, use_ef, fp32_bytes, compact_bytes, savings_pct)
+    _lib.compact_adam_memory_info.argtypes = [
+        ctypes.c_longlong, ctypes.c_int, P_D, P_D, P_D
+    ]
+    _lib.compact_adam_memory_info.restype = None
+
+
+# CompactEFT library (separate from compact)
+_compact_eft_lib = None
+
+def _load_compact_eft_lib():
+    """Load the CompactEFT library (production optimizer with EFT precision)."""
+    global _compact_eft_lib
+
+    if _compact_eft_lib is not None:
+        return _compact_eft_lib
+
+    P_F = ctypes.POINTER(ctypes.c_float)
+    P_V = ctypes.c_void_p
+
+    candidates = [
+        Path(__file__).parent.parent / "bin" / "quarterbit_compact_eft.dll",
+        Path(__file__).parent.parent.parent / "build" / "quarterbit_compact_eft.dll",
+        Path(r"C:\QuarterBit\build\quarterbit_compact_eft.dll"),
+    ]
+    if sys.platform != "win32":
+        candidates = [
+            Path(__file__).parent.parent / "bin" / "libquarterbit_compact_eft.so",
+            Path(__file__).parent.parent.parent / "build" / "libquarterbit_compact_eft.so",
+        ]
+
+    for path in candidates:
+        if path.exists():
+            try:
+                lib = ctypes.CDLL(str(path))
+
+                # Configure signatures
+                lib.compact_eft_adam_create.argtypes = [ctypes.c_int]
+                lib.compact_eft_adam_create.restype = P_V
+
+                lib.compact_eft_adam_step.argtypes = [
+                    P_V, P_F, P_F,
+                    ctypes.c_float, ctypes.c_float, ctypes.c_float, ctypes.c_float,
+                    ctypes.c_int
+                ]
+                lib.compact_eft_adam_step.restype = ctypes.c_int
+
+                lib.compact_eft_adam_destroy.argtypes = [P_V]
+                lib.compact_eft_adam_destroy.restype = None
+
+                _compact_eft_lib = lib
+                return lib
+            except Exception as e:
+                warnings.warn(f"Failed to load CompactEFT library: {e}")
+
+    return None
+
+
+def get_lib():
+    """Get the loaded library, loading if necessary."""
+    if not _load_backend():
+        raise RuntimeError(
+            "QuarterBit backend not available. "
+            "Ensure CUDA is installed and you have a valid license."
+        )
+    return _lib
+
+def is_available() -> bool:
+    """Check if QuarterBit backend is available."""
+    return _load_backend()
+
+def get_backend_info() -> dict:
+    """Get backend information."""
+    if not _load_backend():
+        return {"available": False}
+
+    return {
+        "available": True,
+        "version": "1.0.0",
+    }

quarterbit-0.1.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.4
+Name: quarterbit
+Version: 0.1.0
+Summary: Precision optimizer for PyTorch - 1,000,000x more accurate than FP32
+Author-email: Kyle Clouthier <info@quarterbit.dev>
+License: Proprietary - Free tier available, commercial use requires license
+Project-URL: Homepage, https://quarterbit.dev
+Project-URL: Repository, https://github.com/DigitalMax321/quarterbit
+Project-URL: Documentation, https://quarterbit.dev/docs
+Keywords: pytorch,optimizer,precision,training,gpu,cuda,adam
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: torch>=2.0
+Requires-Dist: numpy>=1.20
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# QuarterBit
+
+**The Pareto-Optimal Optimizer for PyTorch**
+
+Better precision. Less memory. Faster training. No tradeoffs.
+
+## The Problem
+
+Standard FP32 training loses precision over long runs. Tiny gradient updates get rounded away, causing:
+- Stalled convergence in late training
+- Wasted GPU hours
+- Suboptimal final models
+
+## The Solution
+
+QuarterBit's `CompactEFTAdam` combines **compressed storage** with **EFT (Error-Free Transformation) arithmetic** to achieve:
+
+| Metric | PyTorch Adam | CompactEFTAdam | Improvement |
+|--------|--------------|----------------|-------------|
+| Precision | Loses 100% of tiny updates | Loses 0% | **1,000,000x** |
+| Memory | 16 B/param | 9.25-13.25 B/param | **17-42% savings** |
+| Convergence | 41 steps to target | 27 steps | **34% faster** |
+
+## Installation
+
+```bash
+pip install quarterbit
+```
+
+## Quick Start
+
+```python
+from quarterbit.torch import CompactEFTAdam
+
+# Drop-in replacement for torch.optim.Adam
+optimizer = CompactEFTAdam(model.parameters(), lr=1e-3)
+
+# Train as usual
+for batch in dataloader:
+    loss = model(batch)
+    loss.backward()
+    optimizer.step()
+    optimizer.zero_grad()
+```
+
+## Why QuarterBit?
+
+### 1. Precision That Matters
+After 500K training steps, standard FP32 loses **100%** of tiny gradient updates. QuarterBit's EFT arithmetic preserves every bit.
+
+### 2. Memory Efficiency
+Train larger models on the same GPU. CompactEFTAdam uses compressed FP16+FP4 storage, saving 17-42% memory.
+
+### 3. Faster Convergence
+Better precision = faster convergence. Reach your target loss in 34% fewer steps.
+
+### 4. Drop-In Replacement
+No code changes needed. Just swap your optimizer.
+
+## Benchmarks
+
+See our [Kaggle notebook](https://www.kaggle.com/code/kyleclouthier/quarterbit-benchmark-v2) for full benchmarks on GPT-2.
+
+## Requirements
+
+- Python 3.8+
+- PyTorch 2.0+
+- NVIDIA GPU with CUDA support
+
+## Pricing
+
+| Tier | Price | Use Case |
+|------|-------|----------|
+| **Free** | $0 | Personal, research, evaluation (<10 GPU-hrs/mo) |
+| **Pro** | $299/mo | Commercial use, up to 10 GPUs |
+| **Team** | $2,499/mo | Up to 100 GPUs, priority support |
+| **Enterprise** | Custom | Unlimited GPUs, custom SLA |
+
+See [quarterbit.dev/pricing](https://quarterbit.dev/pricing) for details.
+
+## License
+
+Proprietary - see [LICENSE](LICENSE) for details. Free tier available for non-commercial use.
+
+## Links
+
+- Website: [quarterbit.dev](https://quarterbit.dev)
+- GitHub: [github.com/DigitalMax321/quarterbit](https://github.com/DigitalMax321/quarterbit)
+- Email: info@quarterbit.dev

quarterbit-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+quarterbit/__init__.py,sha256=XkZDkB0_pdGIi0JEj6yVccqRo48B5-SCEEi7Y1vevN4,2483
+quarterbit/torch/__init__.py,sha256=e41S-OgXlbXh5vkbpGwVB0g3Eqv0z594UmMiGrHBo-8,621
+quarterbit/torch/functional.py,sha256=VaNMvOzqvo2AgCRI3OQNpk-bIVOc-3usKAKyhYyI84g,5760
+quarterbit/torch/optim.py,sha256=NbYJjKt4v1dAf2kswPiSg10n7kEgta1aivJ8_Dy2tDU,26883
+quarterbit/torch/utils.py,sha256=4mnCwgygwDueJbkM7BaFbjEmmD6VQIV0tAK7ffasY1o,8162
+quarterbit-0.1.0.dist-info/licenses/LICENSE,sha256=sIMy1D4ij6YMTJf8ohG5TRIZJRpeb7zS4VGjA9pY5qk,2007
+quarterbit-0.1.0.dist-info/METADATA,sha256=twvl-oxLPsPxNVFQFOpfblR8oB4XDWim4NsxkTc2pSc,4082
+quarterbit-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quarterbit-0.1.0.dist-info/top_level.txt,sha256=QVr0PzQsD71veFxGScXUdhVVxcrQtxDY3UCvRbGkWxA,11
+quarterbit-0.1.0.dist-info/RECORD,,

quarterbit-0.1.0.dist-info/WHEEL

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

quarterbit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,53 @@
+QuarterBit Software License Agreement
+Copyright (c) 2026 Clouthier Simulation Labs. All rights reserved.
+
+================================================================================
+TERMS OF USE
+================================================================================
+
+This software is proprietary and offered under a tiered licensing model.
+
+FREE TIER
+---------
+You may use QuarterBit free of charge for:
+- Personal projects
+- Academic research (non-commercial)
+- Evaluation purposes
+- Projects with less than 10 GPU-hours per month
+
+FREE TIER RESTRICTIONS:
+- No commercial use without a paid license
+- No redistribution of source code
+- No removal of license notices
+- Attribution required in publications
+
+PAID TIERS
+----------
+Commercial use requires a paid license:
+
+  Pro ($299/month)      - Up to 10 GPUs, commercial use permitted
+  Team ($2,499/month)   - Up to 100 GPUs, priority support
+  Enterprise (Custom)   - Unlimited GPUs, custom SLA, on-premise deployment
+
+Contact: info@quarterbit.dev
+Website: https://quarterbit.dev/pricing
+
+================================================================================
+WARRANTY DISCLAIMER
+================================================================================
+
+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.
+
+================================================================================
+CONTACT
+================================================================================
+
+Clouthier Simulation Labs
+Email: info@quarterbit.dev
+Web: https://quarterbit.dev

quarterbit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+quarterbit