pathsig 0.1.1__tar.gz

pathsig-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Tobias Nygaard
+
+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.

pathsig-0.1.1/MANIFEST.in

@@ -0,0 +1,7 @@
+# Include license/readme/pyproject
+include LICENSE
+include README*
+include pyproject.toml
+
+# Include all package sources under src/
+recursive-include src *.cu *.cpp *.h *.cuh *.py

pathsig-0.1.1/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: pathsig
+Version: 0.1.1
+Summary: GPU-accelerated library for scalable and efficient differentiable signature computations.
+Author-email: Tobias Nygaard <tobiasknygard@gmail.com>
+Project-URL: Homepage, https://github.com/tobiasny12/pathsig
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pathsig
+A high-performance, GPU-accelerated library for differentiable signature computations, with PyTorch integration. Built on a decomposition approach that enables efficient, scalable signature computations with minimal memory usage.
+
+## Installation
+```bash
+pip install pathsig
+```
+
+**Requirements:**
+- PyTorch >= 2.0
+- CUDA-capable GPU (compute capability >= 7.0)
+- Python >= 3.8
+
+## Quick Start
+`pathsig` provides both a functional API and a PyTorch module for computing path signatures. The library allows for straightforward usage of the signature as part of machine learning models, acting as a differentiable feature extractor for time series or path data.
+
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import pathsig
+
+# Compute signature of a path
+path = torch.randn(1, 100, 3, device='cuda') # (batch_size, sequence_length, path_dim)
+sig = pathsig.signature(path, truncation_level=4)
+print(sig.shape) # (1, 120)
+
+# Use as a PyTorch module
+signature_layer = pathsig.Signature(truncation_level=4).to('cuda')
+sig = signature_layer(path)
+
+# As part of a neural network 
+class SignatureNet(nn.Module):
+    def __init__(self, input_channels, sig_level, num_classes):
+        super().__init__()
+        self.signature = pathsig.Signature(truncation_level=sig_level)
+        sig_dim = pathsig.sig_size(input_channels, sig_level)
+        self.classifier = nn.Linear(sig_dim, num_classes)
+ 
+    def forward(self, x):
+        sig = self.signature(x)
+        return self.classifier(sig)
+```
+
+
+## Limitations
+- GPU-only (no CPU support currently).
+- Maximum truncation level: 12.
+- Maximum path dimension: 1000.
+
+## License
+MIT License, see [LICENSE](LICENSE) file for details.

pathsig-0.1.1/README.md

@@ -0,0 +1,53 @@
+# pathsig
+A high-performance, GPU-accelerated library for differentiable signature computations, with PyTorch integration. Built on a decomposition approach that enables efficient, scalable signature computations with minimal memory usage.
+
+## Installation
+```bash
+pip install pathsig
+```
+
+**Requirements:**
+- PyTorch >= 2.0
+- CUDA-capable GPU (compute capability >= 7.0)
+- Python >= 3.8
+
+## Quick Start
+`pathsig` provides both a functional API and a PyTorch module for computing path signatures. The library allows for straightforward usage of the signature as part of machine learning models, acting as a differentiable feature extractor for time series or path data.
+
+
+```python
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import pathsig
+
+# Compute signature of a path
+path = torch.randn(1, 100, 3, device='cuda') # (batch_size, sequence_length, path_dim)
+sig = pathsig.signature(path, truncation_level=4)
+print(sig.shape) # (1, 120)
+
+# Use as a PyTorch module
+signature_layer = pathsig.Signature(truncation_level=4).to('cuda')
+sig = signature_layer(path)
+
+# As part of a neural network 
+class SignatureNet(nn.Module):
+    def __init__(self, input_channels, sig_level, num_classes):
+        super().__init__()
+        self.signature = pathsig.Signature(truncation_level=sig_level)
+        sig_dim = pathsig.sig_size(input_channels, sig_level)
+        self.classifier = nn.Linear(sig_dim, num_classes)
+ 
+    def forward(self, x):
+        sig = self.signature(x)
+        return self.classifier(sig)
+```
+
+
+## Limitations
+- GPU-only (no CPU support currently).
+- Maximum truncation level: 12.
+- Maximum path dimension: 1000.
+
+## License
+MIT License, see [LICENSE](LICENSE) file for details.

pathsig-0.1.1/pyproject.toml

@@ -0,0 +1,24 @@
+# pyproject.toml
+[build-system]
+requires = ["setuptools", "wheel", "torch"]
+build-backend = "setuptools.build_meta"
+
+
+[project]
+name = "pathsig"
+version = "0.1.1"
+description = "GPU-accelerated library for scalable and efficient differentiable signature computations."
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [{name = "Tobias Nygaard", email = "tobiasknygard@gmail.com"}]
+
+[project.urls]
+Homepage = "https://github.com/tobiasny12/pathsig"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["pathsig"]
+include-package-data = false
+
+[tool.setuptools.exclude-package-data]
+pathsig = ["signature_forward/*", "signature_backward/*", "utils/*", "*.cu", "*.cuh", "*.cpp", "*.h", "*.hpp"]

pathsig-0.1.1/setup.cfg

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

pathsig-0.1.1/setup.py

@@ -0,0 +1,41 @@
+# setup.py for CUDA Torch extension with correct ABI passing to NVCC host compiler
+import os
+import torch
+from setuptools import setup, find_packages
+from torch.utils.cpp_extension import BuildExtension, CUDAExtension
+
+current_dir = os.path.dirname(os.path.abspath(__file__))
+abi_flag = '-D_GLIBCXX_USE_CXX11_ABI=' + ('1' if torch._C._GLIBCXX_USE_CXX11_ABI else '0')
+
+setup(
+    name='pathsig',
+    version='0.1.1',
+    package_dir={'': 'src'},
+    packages=['pathsig'],
+    ext_modules=[
+        CUDAExtension(
+            name='pathsig._impl',
+            sources=[
+                'src/pathsig/pybindings.cpp',
+                'src/pathsig/utils/SigDecomposition.cpp',
+                'src/pathsig/signature_backward/sig_backprop.cu',
+                'src/pathsig/signature_backward/sig_backprop_launch.cu',
+                'src/pathsig/signature_forward/compute_sig.cu',
+                'src/pathsig/signature_forward/compute_sig_launch.cu',
+                'src/pathsig/utils/sig_setup.cu',
+            ],
+            include_dirs=[
+                os.path.join(current_dir, 'src/pathsig'),
+                os.path.join(current_dir, 'src/pathsig/utils'),
+                os.path.join(current_dir, 'src/pathsig/signature_backward'),
+                os.path.join(current_dir, 'src/pathsig/signature_forward'),
+            ],
+            extra_compile_args={
+                'cxx': ['-O2', abi_flag, '-fvisibility=hidden'],
+                'nvcc': ['-O2', abi_flag, '-diag-suppress=20281'],
+            },
+        )
+    ],
+    cmdclass={'build_ext': BuildExtension},
+    zip_safe=False,
+)

pathsig-0.1.1/src/pathsig/Signature.py

@@ -0,0 +1,45 @@
+import torch
+import torch.nn as nn
+from ._impl import SigDecomposition
+from ._autograd import SignatureFunction
+
+class Signature(nn.Module):
+    def __init__(self, truncation_level: int, extended_precision: bool = False):
+        """
+        Args:
+            truncation_level: Maximum degree of signature terms
+            extended_precision: If True and dtype is double, use higher precision during computation
+        """
+        super(Signature, self).__init__()
+        self.truncation_level = truncation_level
+        self.extended_precision = extended_precision
+        self.sig_decomp = None
+        self._cached_path_dim = None
+
+    def forward(self, path: torch.Tensor) -> torch.Tensor:
+        """
+        Computes the signatures of the input paths.
+        Args:
+            path: Input tensor of shape (batch_size, sequence_length, path_dim)
+        Returns:
+            Tensor containing signatures of shape (batch_size, signature_size)
+        """
+        batch_size, sequence_length, path_dim = path.shape
+        if (self.sig_decomp is None or
+                self._cached_path_dim != path_dim):
+            self.sig_decomp = SigDecomposition(path_dim, self.truncation_level)
+            self._cached_path_dim = path_dim
+        return SignatureFunction.apply(path, self.truncation_level, self.extended_precision, self.sig_decomp)
+
+def signature(path: torch.Tensor, truncation_level: int, extended_precision: bool = False, sig_decomp=None) -> torch.Tensor:
+    """
+    Computes the signature/signatures of a path/paths up to a given truncation level.
+
+    Args:
+        path: Input tensor of shape (batch_size, num_time_steps, path_dim)
+        truncation_level: Maximum degree of signature terms
+        extended_precision: If True and path is of dtype FP64, use higher precision in signature computations
+    Returns:
+        Tensor containing the truncated signature of the input path
+    """
+    return SignatureFunction.apply(path, truncation_level, extended_precision, sig_decomp)

pathsig-0.1.1/src/pathsig/__init__.py

@@ -0,0 +1,6 @@
+# pathsig/__init__.py
+import torch
+from .Signature import Signature, signature
+from ._impl import sig_size
+
+__all__ = ["Signature", "signature", "sig_size"]

pathsig-0.1.1/src/pathsig/_autograd.py

@@ -0,0 +1,54 @@
+import torch
+from ._impl import compute_sig, compute_sig_gradients, SigDecomposition
+from torch.autograd.function import once_differentiable
+from typing import Optional, Tuple, Union
+
+class SignatureFunction(torch.autograd.Function):
+    """
+    Custom autograd function for signature computation and differentiation.
+    """
+    @staticmethod
+    def forward(path: torch.Tensor, truncation_level: int,
+                extended_precision: bool = False, sig_decomp: Optional[SigDecomposition] = None) -> torch.Tensor:
+        """
+        Args:
+            path: Input tensor of shape (batch_size, num_time_steps, path_dim)
+            truncation_level: Maximum degree of signature terms
+            extended_precision: If True and path is of dtype FP64, use higher precision in signature computation
+        Returns:
+            Signatures torch tensor of shape (batch_size, signature_size)
+        """
+
+        # Compute signatures
+        sig = compute_sig(path, truncation_level, extended_precision, sig_decomp)
+        return sig
+
+    @staticmethod
+    def setup_context(ctx, inputs, output):
+        """
+        Args:
+            ctx: Context object
+            inputs: Tuple of inputs to forward
+            output: Output of forward
+        """
+        path, truncation_level, extended_precision, sig_decomp = inputs
+        sig = output
+        if path.requires_grad:
+            ctx.save_for_backward(path, sig)
+            ctx.truncation_level = truncation_level
+            ctx.sig_decomp = sig_decomp
+
+    @staticmethod
+    def backward(ctx, incoming_gradients: torch.Tensor) -> Tuple[torch.Tensor, None, None, None]:
+        """
+        Args:
+            ctx: Context object with saved tensors
+            incoming_gradients: Gradient of loss w.r.t. signature
+        Returns:
+            gradient of signature w.r.t. input path, and None for other inputs
+        """
+        path, sig = ctx.saved_tensors
+        path_grad = compute_sig_gradients(
+            path, sig, incoming_gradients, ctx.truncation_level, ctx.sig_decomp
+        )
+        return path_grad, None, None, None

pathsig-0.1.1/src/pathsig/pybindings.cpp

@@ -0,0 +1,33 @@
+// pybindings.cpp
+#include <torch/extension.h>
+#include "compute_sig_launch.cuh"
+#include "sig_backprop_launch.cuh"
+#include "SigDecomposition.h"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
+    py::class_<pathsig::SigDecomposition>(m, "SigDecomposition")
+        .def(py::init<int,int>(),
+             py::arg("path_dim"), py::arg("trunc_level"));
+
+    m.def("compute_sig", &pathsig::computeSignature,
+          py::arg("path"),
+          py::arg("truncation_level"),
+          py::arg("extended_precision") = false,
+          py::arg("sig_decomp") = py::none(), // None maps to nullptr
+          py::call_guard<py::gil_scoped_release>());
+
+    m.def("compute_sig_gradients", &pathsig::computeSigGradients,
+          py::arg("path"),
+          py::arg("signature"),
+          py::arg("incoming_grads"),
+          py::arg("truncation_level"),
+          py::arg("sig_decomp") = py::none(),
+          py::call_guard<py::gil_scoped_release>());
+
+    m.def("sig_size",
+          &pathsig::computeSigSize,
+          py::arg("path_dim"), py::arg("truncation_level"),
+          "Total number of signature terms excluding the level 0 identity term.");
+}