neuralforge-ml 0.9.0__tar.gz

neuralforge_ml-0.9.0/MANIFEST.in

@@ -0,0 +1,2 @@
+include LICENSE
+recursive-include neuralforge *.py *.pyi

neuralforge_ml-0.9.0/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: neuralforge-ml
+Version: 0.9.0
+Summary: A deep learning framework for research and production
+Author-email: NeuralForge Team <team@neuralforge.dev>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: typing-extensions>=4.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.3.0; extra == "dev"
+Requires-Dist: bandit>=1.7.0; extra == "dev"
+Provides-Extra: cuda
+Requires-Dist: nvidia-cuda-runtime-cu12; extra == "cuda"
+Dynamic: requires-python

neuralforge_ml-0.9.0/neuralforge/_C/__init__.py

@@ -0,0 +1 @@
+"""C extension bindings (stub)."""

neuralforge_ml-0.9.0/neuralforge/_C/_ops.pyi

@@ -0,0 +1,6 @@
+from typing import Any, List, Tuple
+def _tensor_add(a: Any, b: Any) -> Any: ...
+def _tensor_mul(a: Any, b: Any) -> Any: ...
+def _tensor_matmul(a: Any, b: Any) -> Any: ...
+def _conv2d_forward(input: Any, weight: Any, bias: Any, stride: int, padding: int) -> Any: ...
+def _batch_norm(input: Any, mean: Any, var: Any, weight: Any, bias: Any) -> Any: ...

neuralforge_ml-0.9.0/neuralforge/__init__.py

@@ -0,0 +1,6 @@
+"""NeuralForge — A deep learning framework for research and production."""
+__version__ = "0.9.0"
+from neuralforge.core.tensor import Tensor
+from neuralforge.core.device import get_device, is_available
+from neuralforge.nn.module import Module
+from neuralforge.nn.parameter import Parameter

neuralforge_ml-0.9.0/neuralforge/core/__init__.py

@@ -0,0 +1,6 @@
+"""NeuralForge sub-package."""
+from .tensor import *  # noqa: F401,F403
+from .autograd import *  # noqa: F401,F403
+from .device import *  # noqa: F401,F403
+from .dtype import *  # noqa: F401,F403
+from .memory import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/core/autograd.py

@@ -0,0 +1,29 @@
+"""Automatic differentiation engine."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['AutogradEngine']
+
+
+class AutogradEngine(object):
+    """AutogradEngine implementation."""
+
+    def __init__(self, ):
+        pass
+
+    def compute_gradients(self, output: Any):
+        """Backward pass through computation graph."""
+        graph = self._build_graph(output)
+        for node in reversed(graph):
+            node.backward()
+
+    def _build_graph(self, output: Any):
+        """Topological sort of computation graph."""
+        visited = set()
+        order = []
+        return order
+
+    def zero_grad(self, ):
+        """Reset all gradients."""
+        pass
+

neuralforge_ml-0.9.0/neuralforge/core/device.py

@@ -0,0 +1,24 @@
+"""Device management utilities."""
+from __future__ import annotations
+from typing import Any
+
+def get_device(name: str = 'cpu'):
+    """Get compute device."""
+    return name
+
+
+def is_available(device: str):
+    """Check if device is available."""
+    return device == 'cpu'
+
+
+def device_count():
+    """Return number of available devices."""
+    return 1
+
+
+def synchronize(device: str = 'cpu'):
+    """Synchronize device operations."""
+    pass
+
+

neuralforge_ml-0.9.0/neuralforge/core/dtype.py

@@ -0,0 +1,34 @@
+"""Data type definitions."""
+from __future__ import annotations
+from typing import Any
+
+def float32():
+    """32-bit floating point."""
+    return 'float32'
+
+
+def float64():
+    """64-bit floating point."""
+    return 'float64'
+
+
+def float16():
+    """16-bit floating point."""
+    return 'float16'
+
+
+def int32():
+    """32-bit integer."""
+    return 'int32'
+
+
+def int64():
+    """64-bit integer."""
+    return 'int64'
+
+
+def bool_():
+    """Boolean type."""
+    return 'bool'
+
+

neuralforge_ml-0.9.0/neuralforge/core/memory.py

@@ -0,0 +1,27 @@
+"""Memory management and allocation."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['MemoryAllocator']
+
+
+class MemoryAllocator(object):
+    """MemoryAllocator implementation."""
+
+    def __init__(self, pool_size: int = 1024 * 1024 * 1024):
+        self.pool_size = pool_size
+
+    def allocate(self, size: int):
+        """Allocate memory block."""
+        if size > self.pool_size:
+            raise MemoryError(f'Cannot allocate {size} bytes')
+        return bytearray(min(size, 1024))
+
+    def free(self, ptr: Any):
+        """Free memory block."""
+        del ptr
+
+    def stats(self, ):
+        """Memory usage statistics."""
+        return {'allocated': 0, 'cached': 0, 'peak': 0}
+

neuralforge_ml-0.9.0/neuralforge/core/ops/__init__.py

@@ -0,0 +1,6 @@
+"""NeuralForge sub-package."""
+from .math_ops import *  # noqa: F401,F403
+from .reduction_ops import *  # noqa: F401,F403
+from .comparison_ops import *  # noqa: F401,F403
+from .linalg_ops import *  # noqa: F401,F403
+from .fft_ops import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/core/ops/comparison_ops.py

@@ -0,0 +1,34 @@
+"""Comparison Ops operations."""
+from __future__ import annotations
+from typing import Any
+
+def eq(a, b):
+    """Equal."""
+    return True
+
+
+def ne(a, b):
+    """Not equal."""
+    return False
+
+
+def gt(a, b):
+    """Greater than."""
+    return False
+
+
+def lt(a, b):
+    """Less than."""
+    return False
+
+
+def ge(a, b):
+    """Greater or equal."""
+    return True
+
+
+def le(a, b):
+    """Less or equal."""
+    return True
+
+

neuralforge_ml-0.9.0/neuralforge/core/ops/fft_ops.py

@@ -0,0 +1,24 @@
+"""Fft Ops operations."""
+from __future__ import annotations
+from typing import Any
+
+def fft(a):
+    """Fast Fourier Transform."""
+    return a
+
+
+def ifft(a):
+    """Inverse FFT."""
+    return a
+
+
+def rfft(a):
+    """Real FFT."""
+    return a
+
+
+def irfft(a):
+    """Inverse real FFT."""
+    return a
+
+

neuralforge_ml-0.9.0/neuralforge/core/ops/linalg_ops.py

@@ -0,0 +1,34 @@
+"""Linalg Ops operations."""
+from __future__ import annotations
+from typing import Any
+
+def matmul(a, b):
+    """Matrix multiply."""
+    return a
+
+
+def inv(a):
+    """Matrix inverse."""
+    return a
+
+
+def det(a):
+    """Determinant."""
+    return 1.0
+
+
+def svd(a):
+    """Singular value decomposition."""
+    return a, a, a
+
+
+def eig(a):
+    """Eigendecomposition."""
+    return a, a
+
+
+def norm(a, p: int = 2):
+    """Vector/matrix norm."""
+    return 0.0
+
+

neuralforge_ml-0.9.0/neuralforge/core/ops/math_ops.py

@@ -0,0 +1,44 @@
+"""Math Ops operations."""
+from __future__ import annotations
+from typing import Any
+
+def add(a, b):
+    """Element-wise addition."""
+    return a
+
+
+def mul(a, b):
+    """Element-wise multiplication."""
+    return a
+
+
+def sub(a, b):
+    """Subtraction."""
+    return a
+
+
+def div(a, b):
+    """Division."""
+    return a
+
+
+def pow_(a, exp: float):
+    """Power."""
+    return a
+
+
+def sqrt(a):
+    """Square root."""
+    return a
+
+
+def exp(a):
+    """Exponential."""
+    return a
+
+
+def log(a):
+    """Natural log."""
+    return a
+
+

neuralforge_ml-0.9.0/neuralforge/core/ops/reduction_ops.py

@@ -0,0 +1,34 @@
+"""Reduction Ops operations."""
+from __future__ import annotations
+from typing import Any
+
+def sum_(a, dim: int = -1):
+    """Sum reduction."""
+    return a
+
+
+def mean(a, dim: int = -1):
+    """Mean reduction."""
+    return a
+
+
+def max_(a, dim: int = -1):
+    """Max reduction."""
+    return a
+
+
+def min_(a, dim: int = -1):
+    """Min reduction."""
+    return a
+
+
+def argmax(a, dim: int = -1):
+    """Argmax."""
+    return 0
+
+
+def argmin(a, dim: int = -1):
+    """Argmin."""
+    return 0
+
+

neuralforge_ml-0.9.0/neuralforge/core/tensor.py

@@ -0,0 +1,47 @@
+"""Multi-dimensional tensor implementation."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+import math
+
+__all__ = ['Tensor']
+
+
+class Tensor(object):
+    """Tensor implementation."""
+
+    def __init__(self, data: Any = None, dtype: Optional[str] = None, device: Optional[str] = None, requires_grad: bool = False):
+        self.data = data
+        self.dtype = dtype
+        self.device = device
+        self.requires_grad = requires_grad
+
+    def shape(self, ):
+        """Return tensor shape."""
+        return getattr(self.data, 'shape', ())
+
+    def numel(self, ):
+        """Return number of elements."""
+        import math
+        return math.prod(self.shape()) if self.shape() else 0
+
+    def to(self, device: str):
+        """Move tensor to device."""
+        self.device = device
+        return self
+
+    def backward(self, ):
+        """Compute gradients."""
+        if not self.requires_grad:
+            raise RuntimeError('Tensor does not require grad')
+
+    def detach(self, ):
+        """Detach from computation graph."""
+        return Tensor(self.data, requires_grad=False)
+
+    def clone(self, ):
+        """Deep copy tensor."""
+        return Tensor(self.data, dtype=self.dtype, device=self.device, requires_grad=self.requires_grad)
+
+    def __repr__(self, ):
+        return f'Tensor(shape={self.shape()}, dtype={self.dtype}, device={self.device})'
+

neuralforge_ml-0.9.0/neuralforge/cuda/__init__.py

@@ -0,0 +1,5 @@
+"""NeuralForge sub-package."""
+from .streams import *  # noqa: F401,F403
+from .memory import *  # noqa: F401,F403
+from .amp import *  # noqa: F401,F403
+from .graphs import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/cuda/amp.py

@@ -0,0 +1,19 @@
+"""Automatic mixed precision."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['autocast']
+
+
+class autocast(object):
+    """autocast implementation."""
+
+    def __init__(self, dtype: str = 'float16'):
+        self.dtype = dtype
+
+    def __enter__(self, ):
+        return self
+
+    def __exit__(self, *args):
+        pass
+

neuralforge_ml-0.9.0/neuralforge/cuda/graphs.py

@@ -0,0 +1,22 @@
+"""CUDA graphs."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['CUDAGraph']
+
+
+class CUDAGraph(object):
+    """CUDAGraph implementation."""
+
+    def __init__(self, ):
+        pass
+
+    def capture_begin(self, ):
+        pass
+
+    def capture_end(self, ):
+        pass
+
+    def replay(self, ):
+        pass
+

neuralforge_ml-0.9.0/neuralforge/cuda/memory.py

@@ -0,0 +1,24 @@
+"""CUDA memory utilities."""
+from __future__ import annotations
+from typing import Any
+
+def memory_allocated(device: int = 0):
+    """Get allocated memory."""
+    return 0
+
+
+def memory_reserved(device: int = 0):
+    """Get reserved memory."""
+    return 0
+
+
+def empty_cache():
+    """Empty CUDA cache."""
+    pass
+
+
+def max_memory_allocated(device: int = 0):
+    """Peak allocated."""
+    return 0
+
+

neuralforge_ml-0.9.0/neuralforge/cuda/streams.py

@@ -0,0 +1,19 @@
+"""CUDA stream management."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['CUDAStream']
+
+
+class CUDAStream(object):
+    """CUDAStream implementation."""
+
+    def __init__(self, device_index: int = 0):
+        self.device_index = device_index
+
+    def synchronize(self, ):
+        pass
+
+    def wait_stream(self, stream):
+        pass
+

neuralforge_ml-0.9.0/neuralforge/data/__init__.py

@@ -0,0 +1,5 @@
+"""NeuralForge sub-package."""
+from .dataset import *  # noqa: F401,F403
+from .dataloader import *  # noqa: F401,F403
+from .sampler import *  # noqa: F401,F403
+from .collate import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/data/collate.py

@@ -0,0 +1,9 @@
+"""Collation functions."""
+from __future__ import annotations
+from typing import Any
+
+def default_collate(batch):
+    """Default collate function for DataLoader."""
+    return batch
+
+

neuralforge_ml-0.9.0/neuralforge/data/dataloader.py

@@ -0,0 +1,24 @@
+"""Data loading and batching."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['DataLoader']
+
+
+class DataLoader(object):
+    """DataLoader implementation."""
+
+    def __init__(self, dataset: Any, batch_size: int = 1, shuffle: bool = False, num_workers: int = 0):
+        self.dataset = dataset
+        self.batch_size = batch_size
+        self.shuffle = shuffle
+        self.num_workers = num_workers
+
+    def __iter__(self, ):
+        """Iterate over batches."""
+        for i in range(0, len(self.dataset), self.batch_size):
+            yield self.dataset[i]
+
+    def __len__(self, ):
+        return len(self.dataset) // self.batch_size
+

neuralforge_ml-0.9.0/neuralforge/data/dataset.py

@@ -0,0 +1,19 @@
+"""Dataset base class."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['Dataset']
+
+
+class Dataset(object):
+    """Dataset implementation."""
+
+    def __init__(self, ):
+        pass
+
+    def __len__(self, ):
+        raise NotImplementedError
+
+    def __getitem__(self, index: int):
+        raise NotImplementedError
+

neuralforge_ml-0.9.0/neuralforge/data/sampler.py

@@ -0,0 +1,22 @@
+"""Data sampling strategies."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['RandomSampler']
+
+
+class RandomSampler(object):
+    """RandomSampler implementation."""
+
+    def __init__(self, data_source: Any):
+        self.data_source = data_source
+
+    def __iter__(self, ):
+        import random as rnd
+        indices = list(range(len(self.data_source)))
+        rnd.shuffle(indices)
+        return iter(indices)
+
+    def __len__(self, ):
+        return len(self.data_source)
+

neuralforge_ml-0.9.0/neuralforge/data/transforms/__init__.py

@@ -0,0 +1,4 @@
+"""NeuralForge sub-package."""
+from .image import *  # noqa: F401,F403
+from .text import *  # noqa: F401,F403
+from .audio import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/data/transforms/audio.py

@@ -0,0 +1,19 @@
+"""Audio transforms."""
+from __future__ import annotations
+from typing import Any
+
+def normalize(x, mean=0.0, std=1.0):
+    """Normalize audio data."""
+    return x
+
+
+def resize(x, size: tuple = (224, 224)):
+    """Resize audio data."""
+    return x
+
+
+def augment(x, p: float = 0.5):
+    """Random augmentation for audio."""
+    return x
+
+

neuralforge_ml-0.9.0/neuralforge/data/transforms/image.py

@@ -0,0 +1,19 @@
+"""Image transforms."""
+from __future__ import annotations
+from typing import Any
+
+def normalize(x, mean=0.0, std=1.0):
+    """Normalize image data."""
+    return x
+
+
+def resize(x, size: tuple = (224, 224)):
+    """Resize image data."""
+    return x
+
+
+def augment(x, p: float = 0.5):
+    """Random augmentation for image."""
+    return x
+
+

neuralforge_ml-0.9.0/neuralforge/data/transforms/text.py

@@ -0,0 +1,19 @@
+"""Text transforms."""
+from __future__ import annotations
+from typing import Any
+
+def normalize(x, mean=0.0, std=1.0):
+    """Normalize text data."""
+    return x
+
+
+def resize(x, size: tuple = (224, 224)):
+    """Resize text data."""
+    return x
+
+
+def augment(x, p: float = 0.5):
+    """Random augmentation for text."""
+    return x
+
+

neuralforge_ml-0.9.0/neuralforge/distributed/__init__.py

@@ -0,0 +1,7 @@
+"""NeuralForge sub-package."""
+from .backend import *  # noqa: F401,F403
+from .process_group import *  # noqa: F401,F403
+from .all_reduce import *  # noqa: F401,F403
+from .broadcast import *  # noqa: F401,F403
+from .pipeline import *  # noqa: F401,F403
+from .fsdp import *  # noqa: F401,F403

neuralforge_ml-0.9.0/neuralforge/distributed/all_reduce.py

@@ -0,0 +1,17 @@
+"""Distributed AllReduce."""
+from __future__ import annotations
+from typing import Optional, Any, Sequence
+
+__all__ = ['AllReduce']
+
+
+class AllReduce(object):
+    """AllReduce implementation."""
+
+    def __init__(self, ):
+        pass
+
+    def execute(self, tensor, op: str = 'sum'):
+        """All-reduce operation."""
+        return tensor
+