quarterbit 0.1.0__tar.gz

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

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

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

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "quarterbit"
+version = "0.1.0"
+description = "Precision optimizer for PyTorch - 1,000,000x more accurate than FP32"
+readme = "README.md"
+license = {text = "Proprietary - Free tier available, commercial use requires license"}
+authors = [
+    {name = "Kyle Clouthier", email = "info@quarterbit.dev"}
+]
+keywords = ["pytorch", "optimizer", "precision", "training", "gpu", "cuda", "adam"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: Other/Proprietary License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.8"
+dependencies = [
+    "torch>=2.0",
+    "numpy>=1.20",
+]
+
+[project.urls]
+Homepage = "https://quarterbit.dev"
+Repository = "https://github.com/DigitalMax321/quarterbit"
+Documentation = "https://quarterbit.dev/docs"
+
+[project.optional-dependencies]
+dev = ["pytest", "build", "twine"]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["quarterbit*"]

quarterbit-0.1.0/quarterbit/__init__.py

@@ -0,0 +1,94 @@
+"""
+QuarterBit
+==========
+
+Precision computing library.
+
+Usage:
+    from quarterbit.torch import Adam
+
+Copyright (c) 2026 Clouthier Simulation Labs. All rights reserved.
+"""
+
+__version__ = "1.0.0"
+__author__ = "Kyle Clouthier"
+__license__ = "Proprietary"
+
+import os as _os
+import hashlib as _hashlib
+import platform as _platform
+
+# ============================================================================
+# License Validation (stub - implement full validation later)
+# ============================================================================
+
+_LICENSE_KEY = _os.environ.get("QUARTERBIT_LICENSE_KEY", "")
+_VALIDATED = False
+
+def _validate_license():
+    """Validate license key. Returns tier or raises."""
+    global _VALIDATED
+
+    if _VALIDATED:
+        return True
+
+    # Free tier: limited functionality
+    if not _LICENSE_KEY:
+        _VALIDATED = True
+        return "free"
+
+    # TODO: Implement full license validation against server
+    # For now, any key = pro tier
+    _VALIDATED = True
+    return "pro"
+
+def _check_environment():
+    """Check for debugging/reverse engineering attempts."""
+    # Basic anti-debug checks
+    suspicious = []
+
+    # Check for common debuggers
+    if _os.environ.get("PYTHONDEBUG"):
+        suspicious.append("debug_mode")
+
+    # Check for trace
+    import sys
+    if sys.gettrace() is not None:
+        suspicious.append("trace_active")
+
+    return suspicious
+
+# Run checks on import
+_tier = _validate_license()
+_suspicious = _check_environment()
+
+if _suspicious and _tier == "free":
+    import warnings
+    warnings.warn("QuarterBit: Debug mode detected. Some features disabled.")
+
+# ============================================================================
+# Public API
+# ============================================================================
+
+def get_version():
+    """Get QuarterBit version."""
+    return __version__
+
+def get_license_tier():
+    """Get current license tier."""
+    return _tier
+
+def is_available():
+    """Check if QuarterBit GPU backend is available."""
+    try:
+        from .torch.utils import is_available as _gpu_available
+        return _gpu_available()
+    except ImportError:
+        return False
+
+# Lazy imports for submodules
+def __getattr__(name):
+    if name == "torch":
+        from . import torch
+        return torch
+    raise AttributeError(f"module 'quarterbit' has no attribute '{name}'")

quarterbit-0.1.0/quarterbit/torch/__init__.py

@@ -0,0 +1,22 @@
+"""
+QuarterBit PyTorch Backend
+==========================
+
+Precision optimizers for PyTorch.
+
+Usage:
+    from quarterbit.torch import Adam
+    optimizer = Adam(model.parameters(), lr=1e-3)
+
+Copyright (c) 2026 Clouthier Simulation Labs. All rights reserved.
+"""
+
+from .optim import SGD, Adam, AdamW, CompactAdam, CompactEFTAdam
+from .functional import eft_matmul, eft_sum, eft_accumulate
+from .utils import get_backend_info, is_available
+
+__all__ = [
+    'SGD', 'Adam', 'AdamW', 'CompactAdam', 'CompactEFTAdam',
+    'eft_matmul', 'eft_sum', 'eft_accumulate',
+    'get_backend_info', 'is_available'
+]

quarterbit-0.1.0/quarterbit/torch/functional.py

@@ -0,0 +1,229 @@
+"""
+QuarterBit Functional Operations
+================================
+
+Copyright (c) 2026 Clouthier Simulation Labs. All rights reserved.
+"""
+
+import torch
+import ctypes
+from .utils import get_lib, is_available
+
+def _ptr(tensor):
+    """Get ctypes pointer to tensor data."""
+    if tensor is None:
+        return None
+    return ctypes.cast(tensor.data_ptr(), ctypes.POINTER(ctypes.c_float))
+
+
+def eft_accumulate(dst: torch.Tensor, src: torch.Tensor, comp: torch.Tensor = None):
+    """
+    Accumulate src into dst with EFT precision: dst += src
+
+    If comp (compensation buffer) is not provided, creates one.
+    Returns the compensation buffer for continued accumulation.
+
+    Args:
+        dst: Destination tensor (modified in-place)
+        src: Source tensor to add
+        comp: Compensation buffer (same shape as dst)
+
+    Returns:
+        comp: Compensation buffer
+
+    Example:
+        >>> dst = torch.zeros(1000).cuda()
+        >>> comp = None
+        >>> for batch in data:
+        ...     comp = eft_accumulate(dst, batch, comp)
+    """
+    if not is_available():
+        # Fallback: standard addition
+        dst.add_(src)
+        return torch.zeros_like(dst) if comp is None else comp
+
+    if comp is None:
+        comp = torch.zeros_like(dst)
+
+    if not (dst.is_cuda and src.is_cuda and dst.dtype == torch.float32):
+        # Fallback for non-CUDA or non-float32
+        dst.add_(src)
+        return comp
+
+    lib = get_lib()
+    n = dst.numel()
+
+    lib.eft_accumulate(
+        _ptr(dst), _ptr(comp), _ptr(src),
+        ctypes.c_int(n)
+    )
+
+    return comp
+
+
+def eft_accumulate_scaled(dst: torch.Tensor, src: torch.Tensor,
+                          scale: float, comp: torch.Tensor = None):
+    """
+    Scaled accumulation with EFT: dst += scale * src
+
+    Args:
+        dst: Destination tensor
+        src: Source tensor
+        scale: Scaling factor
+        comp: Compensation buffer
+
+    Returns:
+        comp: Compensation buffer
+    """
+    if not is_available():
+        dst.add_(src, alpha=scale)
+        return torch.zeros_like(dst) if comp is None else comp
+
+    if comp is None:
+        comp = torch.zeros_like(dst)
+
+    if not (dst.is_cuda and src.is_cuda and dst.dtype == torch.float32):
+        dst.add_(src, alpha=scale)
+        return comp
+
+    lib = get_lib()
+    n = dst.numel()
+
+    lib.eft_accumulate_scaled(
+        _ptr(dst), _ptr(comp), _ptr(src),
+        ctypes.c_float(scale),
+        ctypes.c_int(n)
+    )
+
+    return comp
+
+
+def eft_sum(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Sum all elements with EFT precision.
+
+    More accurate than tensor.sum() for large tensors.
+
+    Args:
+        tensor: Input tensor
+
+    Returns:
+        Scalar tensor with sum
+
+    Example:
+        >>> x = torch.randn(1000000).cuda()
+        >>> standard_sum = x.sum()
+        >>> eft_precise_sum = eft_sum(x)
+    """
+    if not is_available() or not tensor.is_cuda or tensor.dtype != torch.float32:
+        return tensor.sum()
+
+    lib = get_lib()
+    n = tensor.numel()
+
+    output = torch.zeros(1, device=tensor.device, dtype=torch.float32)
+    output_comp = torch.zeros(1, device=tensor.device, dtype=torch.float32)
+
+    # Flatten for contiguous access
+    flat = tensor.contiguous().view(-1)
+
+    lib.eft_reduce_sum(
+        _ptr(flat), _ptr(output), _ptr(output_comp),
+        ctypes.c_int(n)
+    )
+
+    # Final compensation
+    return output + output_comp
+
+
+def eft_matmul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Matrix multiplication with EFT precision: C = A @ B
+
+    More accurate than torch.mm for ill-conditioned matrices.
+
+    Args:
+        a: First matrix [M, K]
+        b: Second matrix [K, N]
+
+    Returns:
+        Result matrix [M, N]
+
+    Example:
+        >>> A = torch.randn(1000, 500).cuda()
+        >>> B = torch.randn(500, 1000).cuda()
+        >>> C = eft_matmul(A, B)  # More precise than A @ B
+    """
+    if not is_available():
+        return torch.mm(a, b)
+
+    if not (a.is_cuda and b.is_cuda and a.dtype == torch.float32 and b.dtype == torch.float32):
+        return torch.mm(a, b)
+
+    if a.dim() != 2 or b.dim() != 2:
+        raise ValueError("eft_matmul requires 2D tensors")
+
+    M, K = a.shape
+    K2, N = b.shape
+    if K != K2:
+        raise ValueError(f"Matrix dimensions don't match: {a.shape} @ {b.shape}")
+
+    lib = get_lib()
+
+    c = torch.empty(M, N, device=a.device, dtype=torch.float32)
+
+    # Ensure contiguous
+    a_contig = a.contiguous()
+    b_contig = b.contiguous()
+
+    lib.eft_matmul(
+        _ptr(a_contig), _ptr(b_contig), _ptr(c),
+        ctypes.c_int(M), ctypes.c_int(K), ctypes.c_int(N)
+    )
+
+    return c
+
+
+def eft_dot(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Dot product with EFT precision.
+
+    Args:
+        a: First vector
+        b: Second vector
+
+    Returns:
+        Scalar tensor with dot product
+    """
+    return eft_sum(a * b)
+
+
+def eft_mean(tensor: torch.Tensor) -> torch.Tensor:
+    """
+    Mean with EFT precision.
+
+    Args:
+        tensor: Input tensor
+
+    Returns:
+        Scalar tensor with mean
+    """
+    return eft_sum(tensor) / tensor.numel()
+
+
+def eft_var(tensor: torch.Tensor, unbiased: bool = True) -> torch.Tensor:
+    """
+    Variance with EFT precision.
+
+    Args:
+        tensor: Input tensor
+        unbiased: Use Bessel's correction (N-1 denominator)
+
+    Returns:
+        Scalar tensor with variance
+    """
+    mean = eft_mean(tensor)
+    diff = tensor - mean
+    ss = eft_sum(diff * diff)
+    n = tensor.numel()
+    return ss / (n - 1 if unbiased else n)