pysiglib 2.2.0__tar.gz → 2.3.0__tar.gz

{pysiglib-2.2.0 → pysiglib-2.3.0}/CMakeLists.txt

@@ -31,14 +31,32 @@ endif()
 # CUDA detection
 # ---------------------------------------------------------------------------
 set(_cuda_enabled FALSE)
+set(_cuda_version "")
 if(PYSIGLIB_CUDA)
     check_language(CUDA)
     if(CMAKE_CUDA_COMPILER)
         enable_language(CUDA)
         find_package(CUDAToolkit REQUIRED)
         set(_cuda_enabled TRUE)
+        set(_cuda_version "${CUDAToolkit_VERSION}")
     else()
         message(STATUS "CUDA compiler not found — building without CUDA")
+        message(STATUS "  CUDA_PATH env var  = '$ENV{CUDA_PATH}'")
+        find_program(_nvcc_probe nvcc
+            HINTS "$ENV{CUDA_PATH}/bin" "$ENV{CUDA_PATH}/Library/bin")
+        if(_nvcc_probe)
+            message(STATUS "  nvcc found at: ${_nvcc_probe}")
+            message(STATUS "  nvcc was found but failed to compile a test program.")
+            message(STATUS "  Common causes:")
+            message(STATUS "    - cl.exe (MSVC) is not on PATH — install Visual Studio Build Tools")
+            message(STATUS "    - CUDA Visual Studio integration files are missing — install the")
+            message(STATUS "      CUDA Toolkit from https://developer.nvidia.com/cuda-downloads")
+            message(STATUS "      (the conda cuda-toolkit package does not include VS integration)")
+        else()
+            message(STATUS "  nvcc was not found on PATH or in CUDA_PATH")
+            message(STATUS "  Install the CUDA Toolkit from https://developer.nvidia.com/cuda-downloads")
+        endif()
+        message(STATUS "  CMAKE_GENERATOR = ${CMAKE_GENERATOR}")
     endif()
 endif()
 
@@ -77,8 +95,39 @@ if(PYSIGLIB_AVX)
     endif()
 endif()
 
-message(STATUS "pysiglib — CUDA enabled : ${_cuda_enabled}")
-message(STATUS "pysiglib — Vectorization: ${_enable_vec}")
+message(STATUS "")
+message(STATUS "  ---- pysiglib build summary ----")
+message(STATUS "  System        : ${CMAKE_SYSTEM_NAME} ${CMAKE_SYSTEM_PROCESSOR}")
+message(STATUS "  Generator     : ${CMAKE_GENERATOR}")
+message(STATUS "  CXX compiler  : ${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}")
+if(CMAKE_CONFIGURATION_TYPES)
+    message(STATUS "  Build configs : ${CMAKE_CONFIGURATION_TYPES}")
+else()
+    message(STATUS "  Build type    : ${CMAKE_BUILD_TYPE}")
+endif()
+message(STATUS "  CUDA enabled  : ${_cuda_enabled}")
+if(_cuda_enabled)
+    message(STATUS "  CUDA compiler : ${CMAKE_CUDA_COMPILER}")
+    message(STATUS "  CUDA version  : ${_cuda_version}")
+    message(STATUS "  CUDA arch     : ${PYSIGLIB_CUDA_ARCH}")
+endif()
+message(STATUS "  AVX enabled   : ${_enable_vec}")
+if(_enable_vec AND NOT APPLE)
+    if(_has_avx2)
+        set(_avx2_str "yes")
+    else()
+        set(_avx2_str "no")
+    endif()
+    if(_has_avx512f)
+        set(_avx512_str "yes")
+    else()
+        set(_avx512_str "no")
+    endif()
+    message(STATUS "  AVX2          : ${_avx2_str}")
+    message(STATUS "  AVX-512F      : ${_avx512_str}")
+endif()
+message(STATUS "  --------------------------------")
+message(STATUS "")
 
 # ---------------------------------------------------------------------------
 # Generate _config.py  (consumed by pysiglib.load_siglib at runtime)
@@ -99,7 +148,10 @@ file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/_config.py"
 # It contains information about how the package was built.\n\
 SYSTEM = '${CMAKE_SYSTEM_NAME}'\n\
 BUILT_WITH_CUDA = ${_cuda_py}\n\
-BUILT_WITH_AVX = ${_vec_py}\n")
+BUILT_WITH_AVX = ${_vec_py}\n\
+CUDA_VERSION = '${_cuda_version}'\n\
+CXX_COMPILER = '${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}'\n\
+CMAKE_GENERATOR = '${CMAKE_GENERATOR}'\n")
 
 install(FILES "${CMAKE_CURRENT_BINARY_DIR}/_config.py" DESTINATION pysiglib)
 

{pysiglib-2.2.0 → pysiglib-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysiglib
-Version: 2.2.0
+Version: 2.3.0
 Summary: Fast Signature Computations on CPU and GPU
 Author-Email: Daniil Shmelev <daniil.shmelev23@imperial.ac.uk>
 License-Expression: Apache-2.0

{pysiglib-2.2.0 → pysiglib-2.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "scikit_build_core.build"
 
 [project]
 name = "pysiglib"
-version = "2.2.0"
+version = "2.3.0"
 description = "Fast Signature Computations on CPU and GPU"
 requires-python = ">=3.9"
 license = "Apache-2.0"

{pysiglib-2.2.0 → pysiglib-2.3.0}/pysiglib/__init__.py

@@ -28,10 +28,10 @@ from .sig_kernel_backprop import sig_kernel_backprop, sig_kernel_gram_backprop
 from .sig_metrics import sig_score, expected_sig_score, sig_mmd
 from .transform_path import transform_path
 from .transform_path_backprop import transform_path_backprop
-from .static_kernels import Context, StaticKernel, LinearKernel, ScaledLinearKernel, RBFKernel
+from .static_kernels import Context, StaticKernel, LinearKernel, ScaledLinearKernel, RBFKernel, PolynomialKernel, Matern12Kernel, Matern32Kernel, Matern52Kernel, RationalQuadraticKernel
 
 signature = sig
 
 import pysiglib.torch_api
 
-__version__ = "2.2.0"
+__version__ = "2.3.0"

{pysiglib-2.2.0 → pysiglib-2.3.0}/pysiglib/param_checks.py

@@ -87,6 +87,20 @@ def ensure_own_contiguous_storage(arr):
 
     raise TypeError("Unexpected error in ensure_own_contiguous_storage: arr must be of type torch.Tensor or numpy.ndarray")
 
+def parse_dyadic_order(dyadic_order):
+    if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
+        do1, do2 = dyadic_order
+    elif isinstance(dyadic_order, int):
+        do1 = do2 = dyadic_order
+    else:
+        raise TypeError("dyadic_order must be an integer or a tuple of length 2")
+    if do1 < 0 or do2 < 0:
+        raise ValueError("dyadic_order must be a non-negative integer or tuple of non-negative integers")
+    return do1, do2
+
+def dyadic_grid_length(path_length, dyadic_order):
+    return ((path_length - 1) << dyadic_order) + 1
+
 def check_log_sig_method(method):
     if method < 0 or method > 3:
         raise ValueError("method must be one of 0, 1, 2 or 3. Got " + str(method) + " instead.")

{pysiglib-2.2.0 → pysiglib-2.3.0}/pysiglib/sig_kernel.py

@@ -20,7 +20,7 @@ import numpy as np
 import torch
 
 from .transform_path import transform_path
-from .param_checks import check_type
+from .param_checks import check_type, parse_dyadic_order, dyadic_grid_length
 from .error_codes import err_msg
 from .dtypes import CPSIG_BATCH_SIG_KERNEL, DTYPES, CUSIG_BATCH_SIG_KERNEL_CUDA
 from .data_handlers import MultiplePathInputHandler, ScalarOutputHandler, GridOutputHandler
@@ -67,7 +67,8 @@ def sig_kernel(
         lead_lag : bool = False,
         end_time : float = 1.,
         n_jobs : int = 1,
-        return_grid: bool = False
+        return_grid: bool = False,
+        normalize : bool = False
 ) -> Union[np.ndarray, torch.tensor]:
     """
     Computes a single signature kernel or a batch of signature kernels.
@@ -121,6 +122,9 @@ def sig_kernel(
     :type n_jobs: int
     :param return_grid: If ``True``, returns the entire PDE grid.
     :type return_grid: bool
+    :param normalize: If ``True``, normalizes the signature kernel so that :math:`k(x, x) = 1`
+        by dividing by :math:`\\sqrt{k(x, x) \\cdot k(y, y)}`. Cannot be used with ``return_grid=True``.
+    :type normalize: bool
     :return: Single signature kernel or batch of signature kernels
     :rtype: numpy.ndarray | torch.tensor
 
@@ -175,18 +179,10 @@ def sig_kernel(
     check_type(n_jobs, "n_jobs", int)
     if n_jobs == 0:
         raise ValueError("n_jobs cannot be 0")
+    if normalize and return_grid:
+        raise ValueError("normalize=True cannot be used with return_grid=True")
 
-    if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
-        dyadic_order_1 = dyadic_order[0]
-        dyadic_order_2 = dyadic_order[1]
-    elif isinstance(dyadic_order, int):
-        dyadic_order_1 = dyadic_order
-        dyadic_order_2 = dyadic_order
-    else:
-        raise TypeError("dyadic_order must be an integer or a tuple of length 2")
-
-    if dyadic_order_1 < 0 or dyadic_order_2 < 0:
-        raise ValueError("dyadic_order must be a non-negative integer or tuple of non-negative integers")
+    dyadic_order_1, dyadic_order_2 = parse_dyadic_order(dyadic_order)
 
     if time_aug or lead_lag:
         path1 = transform_path(path1, time_aug, lead_lag, end_time, n_jobs)
@@ -198,8 +194,8 @@ def sig_kernel(
     if not return_grid:
         result = ScalarOutputHandler(data)
     else:
-        dyadic_len_1 = ((data.length[0] - 1) << dyadic_order_1) + 1
-        dyadic_len_2 = ((data.length[1] - 1) << dyadic_order_2) + 1
+        dyadic_len_1 = dyadic_grid_length(data.length[0], dyadic_order_1)
+        dyadic_len_2 = dyadic_grid_length(data.length[1], dyadic_order_2)
         result = GridOutputHandler(dyadic_len_1, dyadic_len_2, data)
 
     torch_path1 = torch.as_tensor(data.path[0])  # Avoids data copy
@@ -238,6 +234,15 @@ def sig_kernel(
             stacklevel=2
         )
 
+    if normalize:
+        # Paths are already transformed at this point, so pass time_aug=False, lead_lag=False
+        k1 = sig_kernel(path1, path1, dyadic_order, static_kernel, n_jobs=n_jobs)
+        k2 = sig_kernel(path2, path2, dyadic_order, static_kernel, n_jobs=n_jobs)
+        if isinstance(result.data, np.ndarray):
+            result.data = result.data / np.sqrt(np.maximum(k1 * k2, 1e-30))
+        else:
+            result.data = result.data / torch.sqrt(torch.clamp(k1 * k2, min=1e-30))
+
     return result.data
 
 
@@ -251,7 +256,8 @@ def sig_kernel_gram(
         end_time : float = 1.,
         n_jobs : int = 1,
         max_batch : int = -1,
-        return_grid : bool = False
+        return_grid : bool = False,
+        normalize : bool = False
 ) -> Union[np.ndarray, torch.tensor]:
     """
     Given batches of paths :math:`\\{x_i\\}_{i=1}^B` and :math:`\\{y_i\\}_{i=1}^B`, computes the gram matrix of signature kernels
@@ -314,6 +320,9 @@ def sig_kernel_gram(
     :type max_batch: int
     :param return_grid: If ``True``, returns the entire PDE grid.
     :type return_grid: bool
+    :param normalize: If ``True``, normalizes the gram matrix so that :math:`K(x, x) = 1` by
+        dividing each entry by :math:`\\sqrt{K(x_i, x_i) \\cdot K(y_j, y_j)}`. Cannot be used with ``return_grid=True``.
+    :type normalize: bool
     :return: Gram matrix of signature kernels
     :rtype: numpy.ndarray | torch.tensor
 
@@ -368,6 +377,8 @@ def sig_kernel_gram(
     check_type(max_batch, "max_batch", int)
     if max_batch == 0 or max_batch < -1:
         raise ValueError("max_batch must be a positive integer or -1")
+    if normalize and return_grid:
+        raise ValueError("normalize=True cannot be used with return_grid=True")
 
     data = MultiplePathInputHandler([path1, path2], time_aug, lead_lag, end_time, ["path1", "path2"], False)
 
@@ -388,44 +399,41 @@ def sig_kernel_gram(
     # Now run computation in batches
     ####################################
 
+    do1, do2 = parse_dyadic_order(dyadic_order)
+
+    if return_grid:
+        gl1 = dyadic_grid_length(data.length[0], do1)
+        gl2 = dyadic_grid_length(data.length[1], do2)
+
     if symmetric:
         # Symmetric case: only compute upper triangle pairs, mirror to lower.
-        # This guarantees exact symmetry and halves the number of kernel evaluations.
         # Cannot mirror grids when dyadic orders differ (gl1 != gl2), so fall through.
-        if return_grid:
-            if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
-                do1, do2 = dyadic_order
-            else:
-                do1 = do2 = dyadic_order
-            gl1 = ((data.length[0] - 1) << do1) + 1
-            gl2 = ((data.length[1] - 1) << do2) + 1
-            if gl1 != gl2:
-                symmetric = False
+        if return_grid and gl1 != gl2:
+            symmetric = False
 
     if symmetric:
         idx_i, idx_j = torch.triu_indices(batch1, batch1, device=path1.device)
-        n_pairs = idx_i.shape[0]
-        chunk_size = max_batch * max_batch
-
-        if return_grid:
-            res = torch.empty(batch1, batch1, gl1, gl2, dtype=path1.dtype, device=path1.device)
-        else:
-            res = torch.empty(batch1, batch1, dtype=path1.dtype, device=path1.device)
-
-        for start in range(0, n_pairs, chunk_size):
-            end = min(start + chunk_size, n_pairs)
-            ci = idx_i[start:end]
-            cj = idx_j[start:end]
+        src1, src2 = path1, path1
+    else:
+        idx_i = torch.arange(batch1, device=path1.device).repeat_interleave(batch2)
+        idx_j = torch.arange(batch2, device=path2.device).repeat(batch1)
+        src1, src2 = path1, path2
 
-            path1_ = path1[ci]
-            path2_ = path1[cj]
+    if return_grid:
+        res = torch.empty(batch1, batch2, gl1, gl2, dtype=path1.dtype, device=path1.device)
+    else:
+        res = torch.empty(batch1, batch2, dtype=path1.dtype, device=path1.device)
 
-            k = sig_kernel(path1_, path2_, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, return_grid)
+    chunk_size = max_batch * max_batch
+    for start in range(0, idx_i.shape[0], chunk_size):
+        end = min(start + chunk_size, idx_i.shape[0])
+        ci = idx_i[start:end]
+        cj = idx_j[start:end]
 
-            # Place in upper triangle
-            res[ci, cj] = k
+        k = sig_kernel(src1[ci], src2[cj], dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, return_grid)
+        res[ci, cj] = k
 
-            # Mirror off-diagonal to lower triangle
+        if symmetric:
             off = ci != cj
             if off.any():
                 k_mirror = k[off]
@@ -433,31 +441,11 @@ def sig_kernel_gram(
                     k_mirror = k_mirror.transpose(-2, -1)
                 res[cj[off], ci[off]] = k_mirror
 
-        return res
-
-    # Asymmetric case: pair-based indexing
-    idx_i = torch.arange(batch1, device=path1.device).repeat_interleave(batch2)
-    idx_j = torch.arange(batch2, device=path2.device).repeat(batch1)
-    n_pairs = idx_i.shape[0]
-    chunk_size = max_batch * max_batch
-
-    if return_grid:
-        if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
-            do1, do2 = dyadic_order
-        else:
-            do1 = do2 = dyadic_order
-        gl1 = ((data.length[0] - 1) << do1) + 1
-        gl2 = ((data.length[1] - 1) << do2) + 1
-        res = torch.empty(batch1, batch2, gl1, gl2, dtype=path1.dtype, device=path1.device)
-    else:
-        res = torch.empty(batch1, batch2, dtype=path1.dtype, device=path1.device)
-
-    for start in range(0, n_pairs, chunk_size):
-        end = min(start + chunk_size, n_pairs)
-        ci = idx_i[start:end]
-        cj = idx_j[start:end]
-
-        k = sig_kernel(path1[ci], path2[cj], dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, return_grid)
-        res[ci, cj] = k
+    if normalize:
+        d1 = sig_kernel(path1, path1, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs)
+        d2 = sig_kernel(path2, path2, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs) if not symmetric else d1
+        res = res / torch.sqrt(torch.clamp(d1.unsqueeze(1) * d2.unsqueeze(0), min=1e-30))
 
+    if data.type_ == "numpy":
+        return res.numpy()
     return res

{pysiglib-2.2.0 → pysiglib-2.3.0}/pysiglib/sig_kernel_backprop.py

@@ -22,7 +22,7 @@ import torch
 from .transform_path import transform_path
 from .transform_path_backprop import transform_path_backprop
 from .sig_kernel import sig_kernel
-from .param_checks import check_type
+from .param_checks import check_type, parse_dyadic_order
 from .error_codes import err_msg
 from .dtypes import CPSIG_BATCH_SIG_KERNEL_BACKPROP, DTYPES, CUSIG_BATCH_SIG_KERNEL_BACKPROP_CUDA
 from .data_handlers import MultiplePathInputHandler, ScalarInputHandler, GridOutputHandler, PathInputHandler
@@ -203,17 +203,7 @@ def sig_kernel_backprop(
     if not (left_deriv or right_deriv):
         return None, None
 
-    if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
-        dyadic_order_1 = dyadic_order[0]
-        dyadic_order_2 = dyadic_order[1]
-    elif isinstance(dyadic_order, int):
-        dyadic_order_1 = dyadic_order
-        dyadic_order_2 = dyadic_order
-    else:
-        raise TypeError("dyadic_order must be an integer or a tuple of length 2")
-
-    if dyadic_order_1 < 0 or dyadic_order_2 < 0:
-        raise ValueError("dyadic_order must be a non-negative integer or tuple of non-negative integers")
+    dyadic_order_1, dyadic_order_2 = parse_dyadic_order(dyadic_order)
 
     if time_aug or lead_lag:
         path1 = transform_path(path1, time_aug, lead_lag, end_time, n_jobs)
@@ -444,10 +434,7 @@ def sig_kernel_gram_backprop(
     chunk_size = max_batch * max_batch
 
     # Check if k_grid can be transposed for symmetric off-diagonal pairs
-    if isinstance(dyadic_order, tuple) and len(dyadic_order) == 2:
-        do1, do2 = dyadic_order
-    else:
-        do1 = do2 = dyadic_order
+    do1, do2 = parse_dyadic_order(dyadic_order)
     can_transpose_k = (do1 == do2)
 
     for start in range(0, n_pairs, chunk_size):

{pysiglib-2.2.0 → pysiglib-2.3.0}/pysiglib/sig_metrics.py

@@ -3,8 +3,6 @@ import numpy as np
 import torch
 
 from .param_checks import check_type_multiple
-from .data_handlers import MultiplePathInputHandler
-
 from .static_kernels import StaticKernel
 from .sig_kernel import sig_kernel_gram
 
@@ -112,25 +110,25 @@ def sig_score(
     check_type_multiple(sample, "sample", (np.ndarray, torch.Tensor))
     check_type_multiple(y, "y", (np.ndarray, torch.Tensor))
 
-    # Use torch for simplicity
+    is_numpy = isinstance(sample, np.ndarray)
     sample = torch.as_tensor(sample)
     y = torch.as_tensor(y)
     if len(y.shape) == 2:
         y = y.unsqueeze(0).contiguous().clone()
 
-    data = MultiplePathInputHandler([sample, y], time_aug, lead_lag, end_time, ["sample_paths", "y"], False)
-
     B = sample.shape[0]
+    if B < 2:
+        raise ValueError("sig_score requires at least 2 sample paths (got {}).".format(B))
 
     xx = sig_kernel_gram(sample, sample, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, max_batch, False)
     xy = sig_kernel_gram(sample, y, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, max_batch, False)
 
-    xx_sum = (torch.sum(xx) - torch.sum(torch.diag(xx))) / (B * (B - 1.))
-    xy_sum = torch.sum(xy, dim = 0) * (2. / B)
+    xx_sum = (torch.sum(xx) - torch.trace(xx)) / (B * (B - 1.))
+    xy_sum = torch.sum(xy, dim=0) * (2. / B)
 
     res = lam * xx_sum - xy_sum
 
-    if data.type_ == "numpy":
+    if is_numpy:
         return res.numpy()
     return res
 
@@ -341,25 +339,27 @@ def sig_mmd(
         print(mmd)
 
     """
-    data = MultiplePathInputHandler([sample1, sample2], time_aug, lead_lag, end_time, ["sample1", "sample2"], False)
-
-    # Use torch for simplicity
-    sample1 = torch.as_tensor(data.path[0])
-    sample2 = torch.as_tensor(data.path[1])
+    is_numpy = isinstance(sample1, np.ndarray)
+    sample1 = torch.as_tensor(sample1)
+    sample2 = torch.as_tensor(sample2)
 
     m = sample1.shape[0]
     n = sample2.shape[0]
+    if m < 2:
+        raise ValueError("sig_mmd requires at least 2 paths in sample1 (got {}).".format(m))
+    if n < 2:
+        raise ValueError("sig_mmd requires at least 2 paths in sample2 (got {}).".format(n))
 
     xx = sig_kernel_gram(sample1, sample1, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, max_batch, False)
     xy = sig_kernel_gram(sample1, sample2, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, max_batch, False)
     yy = sig_kernel_gram(sample2, sample2, dyadic_order, static_kernel, time_aug, lead_lag, end_time, n_jobs, max_batch, False)
 
-    xx_sum = (torch.sum(xx) - torch.sum(torch.diag(xx))) / (m * (m - 1))
+    xx_sum = (torch.sum(xx) - torch.trace(xx)) / (m * (m - 1))
     xy_sum = 2. * torch.mean(xy)
-    yy_sum = (torch.sum(yy) - torch.sum(torch.diag(yy))) / (n * (n - 1))
+    yy_sum = (torch.sum(yy) - torch.trace(yy)) / (n * (n - 1))
 
     res = xx_sum - xy_sum + yy_sum
 
-    if data.type_ == "numpy":
+    if is_numpy:
         return res.numpy()
     return res