### Install sigkernel via pip

Source: https://github.com/crispitagorico/sigkernel/blob/master/README.md

Install the library directly from the GitHub repository.

```bash
pip install git+https://github.com/crispitagorico/sigkernel.git
```

--------------------------------

### Manage GPU Acceleration and Memory

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Example demonstrating automatic device selection, memory-efficient computation using max_batch, and GPU memory cleanup.

```python
import torch
import sigkernel

# Automatic device selection
if torch.cuda.is_available():
    device = torch.device('cuda')
    print("Using NVIDIA CUDA")
elif torch.backends.mps.is_available():
    device = torch.device('mps')
    print("Using Apple Silicon MPS")
else:
    device = torch.device('cpu')
    print("Using CPU (Cython backend)")

# Create data on selected device
batch, length, dim = 50, 100, 4
X = torch.rand(batch, length, dim, dtype=torch.float64, device=device)
Y = torch.rand(batch, length, dim, dtype=torch.float64, device=device)

# Setup kernel
static_kernel = sigkernel.RBFKernel(sigma=1.0)
sig_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=1)

# For large datasets, use max_batch to control memory
# Smaller max_batch = less memory but more iterations
G = sig_kernel.compute_Gram(X, Y, sym=False, max_batch=25)

# Move results back to CPU if needed
G_cpu = G.cpu().numpy()

# Clear GPU memory after computation
if device.type == 'cuda':
    torch.cuda.empty_cache()

print(f"Computed on {device}, result shape: {G_cpu.shape}")
```

--------------------------------

### Run UEA time series classification examples

Source: https://github.com/crispitagorico/sigkernel/blob/master/README.md

Commands to train, test, and print results for the UEA time series classification models.

```bash
python3 time_series_classification.py --train
```

```bash
python3 time_series_classification.py --test
```

```bash
python3 time_series_classification.py --print
```

--------------------------------

### Compute Signature Kernel Gram Matrix

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Basic example of converting data to torch tensors and computing the Gram matrix using an RBF static kernel.

```python
X = torch.tensor(batch_paths, dtype=torch.float64)
Y = torch.tensor(batch_paths, dtype=torch.float64)

static_kernel = sigkernel.RBFKernel(sigma=0.5)
sig_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=0)

G = sig_kernel.compute_Gram(X, Y, sym=True)
print(f"Gram matrix of Brownian paths: {G.shape}")
```

--------------------------------

### Prepare Features and Target for Sigkernel Model

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Extracts the 'Close' price, defines window sizes for feature engineering, generates the target variable 'y' (next mean price), and creates the feature matrix 'X_window' using `GetWindow` and `sigkernel.transform`. Splits data into training and testing sets.

```python
# use only close price
close_price = BTC_price.loc[:,'Close']
# close_price = TimeSeriesScalerMeanVariance().fit_transform(close_price.values[None,:])
close_price = pd.DataFrame(np.squeeze(close_price))

# use last h_window observations to predict mean over next f_window observations
h_window = 36
f_window = 2

# next mean price
y = GetNextMean(close_price, h_window=h_window , f_window=f_window)

# normal window features
X_window = GetWindow(close_price, h_window, f_window).values
X_window = torch.tensor(X_window, dtype=torch.float64)
X_window = sigkernel.transform(X_window, at=True, ll=True, scale=1e-5)

# train test split
x_train, x_test, y_train, y_test = train_test_split(X_window, y, test_size=0.2, shuffle=False)
x_train = torch.tensor(x_train, dtype=torch.float64, device='cpu')
x_test = torch.tensor(x_test, dtype=torch.float64, device='cpu')
```

--------------------------------

### Compute Signature Kernels and Gram Matrices

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Demonstrates initializing a SigKernel instance and computing batch-wise kernels or full Gram matrices for time series data.

```python
import torch
import sigkernel

# Detect available hardware acceleration
device = 'cuda' if torch.cuda.is_available() else ('mps' if torch.backends.mps.is_available() else 'cpu')

# Create synthetic time series data
batch_size, len_x, len_y, dim = 10, 50, 60, 3
X = torch.rand((batch_size, len_x, dim), dtype=torch.float64, device=device)
Y = torch.rand((batch_size, len_y, dim), dtype=torch.float64, device=device)

# Initialize static kernel (RBF or Linear)
static_kernel = sigkernel.RBFKernel(sigma=0.5)

# Create signature kernel with dyadic refinement order
# Higher dyadic_order = more accurate but slower (default=0)
signature_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=1)

# Compute batch-wise kernel: k(x_1,y_1), ..., k(x_batch, y_batch)
K = signature_kernel.compute_kernel(X, Y, max_batch=100)
print(f"Batch kernel shape: {K.shape}")  # Output: torch.Size([10])

# Compute full Gram matrix: k(x_i, y_j) for all i,j pairs
G = signature_kernel.compute_Gram(X, Y, sym=False, max_batch=100)
print(f"Gram matrix shape: {G.shape}")  # Output: torch.Size([10, 10])

# Symmetric Gram matrix (more efficient when X == Y)
G_sym = signature_kernel.compute_Gram(X, X, sym=True, max_batch=100)
```

--------------------------------

### Compute signature kernels and metrics

Source: https://github.com/crispitagorico/sigkernel/blob/master/README.md

Initialize the signature kernel and perform computations including Gram matrices, MMD distances, and scoring rules.

```python
import torch
import sigkernel

# Specify the static kernel (for linear kernel use sigkernel.LinearKernel())
static_kernel = sigkernel.RBFKernel(sigma=0.5)

# Specify dyadic order for PDE solver (int > 0, default 0, the higher the more accurate but slower)
dyadic_order = 1

# Specify maximum batch size of computation; if memory is a concern try reducing max_batch, default=100
max_batch = 100

# Initialize the corresponding signature kernel
signature_kernel = sigkernel.SigKernel(static_kernel, dyadic_order)

# Synthetic data
batch, len_x, len_y, dim = 5, 10, 20, 2
# Use 'cuda', 'mps', or 'cpu' depending on available hardware
device = 'cuda' if torch.cuda.is_available() else ('mps' if torch.backends.mps.is_available() else 'cpu')
X = torch.rand((batch,len_x,dim), dtype=torch.float64, device=device) # shape (batch,len_x,dim)
Y = torch.rand((batch,len_y,dim), dtype=torch.float64, device=device) # shape (batch,len_y,dim)
Z = torch.rand((batch,len_x,dim), dtype=torch.float64, device=device) # shape (batch,len_y,dim)

# Compute signature kernel "batch-wise" (i.e. k(x_1,y_1),...,k(x_batch, y_batch))
K = signature_kernel.compute_kernel(X,Y,max_batch)

# Compute signature kernel Gram matrix (i.e. k(x_i,y_j) for i,j=1,...,batch), also works for different batch_x != batch_y)
G = signature_kernel.compute_Gram(X,Y,sym=False,max_batch)

# Compute MMD distance between samples x ~ X and samples y ~ Y, where X,Y are two distributions on path space...
mmd = signature_kernel.compute_mmd(X,Y,max_batch)
# ... and to backpropagate through the MMD distance simply call .backward(), like any other PyTorch loss function
mmd.backward()

# Compute scoring rule between X and a sample path y, i.e. S_sig(X,y) = E[k(X,X)] - 2E[k(X,y] ...
y = Y[0]
sr = signature_kernel.compute_scoring_rule(X,y,max_batch)

# ... and expected scoring rule between X and Y, i.e. S(X,Y) = E_Y[S_sig(X,y)]
esr = signature_kernel.compute_expected_scoring_rule(X,Y,max_batch)

# Sig CHSIC: XY|Z
sigchsic = signature_kernel.SigCHSIC(X, Y, Z, static_kernel, dyadic_order=1, eps=0.1)
```

--------------------------------

### Apply Path Transformations with Sigkernel

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Utilize the sigkernel.transform function to preprocess time series paths by adding time coordinates and applying lead-lag transformations. Demonstrates individual and combined transformations with scaling.

```python
import numpy as np
import sigkernel

# Sample multivariate time series data
n_samples, length, dim = 50, 100, 3
paths = np.random.randn(n_samples, length, dim)

# Apply transformations using the convenience function
# at=True: Add time coordinate (dim -> dim+1)
# ll=True: Lead-lag transform (dim -> 2*dim)
# scale: Rescale paths

# Add time only
paths_with_time = sigkernel.transform(paths, at=True, ll=False, scale=1.0)
print(f"With time: {paths.shape} -> {paths_with_time.shape}")
```

```python
# Lead-lag only (doubles length and dimension)
paths_leadlag = sigkernel.transform(paths, at=False, ll=True, scale=1.0)
print(f"Lead-lag: {paths.shape} -> {paths_leadlag.shape}")
```

```python
# Both transformations with scaling
paths_full = sigkernel.transform(paths, at=True, ll=True, scale=0.1)
print(f"Full transform: {paths.shape} -> {paths_full.shape}")
```

```python
# Individual transformer classes for custom pipelines
add_time = sigkernel.AddTime(init_time=0., total_time=1.)
lead_lag = sigkernel.LeadLag()

# Apply sequentially
paths_t = add_time.fit_transform(list(paths))
paths_tll = lead_lag.fit_transform(paths_t)
```

--------------------------------

### Generate Brownian Motion Paths with Sigkernel Utilities

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Utilize helper functions from sigkernel to generate white noise increments and Brownian motion paths. Useful for creating synthetic data for testing and benchmarking signature kernel computations.

```python
import numpy as np
import torch
import sigkernel

# Generate white noise increments
steps, width, time = 100, 3, 1.0
increments = sigkernel.white(steps, width, time)
print(f"White noise shape: {increments.shape}")
```

```python
# Generate Brownian motion paths
paths = sigkernel.brownian(steps, width, time)
print(f"Brownian path shape: {paths.shape}")
print(f"Path starts at: {paths[0]}")
```

```python
# Generate batch of Brownian motions for kernel computation
n_paths = 20
batch_paths = np.array([sigkernel.brownian(steps, width) for _ in range(n_paths)])
print(f"Batch shape: {batch_paths.shape}")
```

--------------------------------

### Load and print results

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Loads the serialized results from a pickle file and prints the final dictionary.

```python
# print results
with open('../results/bitcoin_results.pkl', 'rb') as file:
    final = pickle.load(file)
    
print(final)
```

--------------------------------

### Load and Preprocess Bitcoin Price Data

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Loads Bitcoin price data from a CSV file, performs initial cleaning by dropping a column and reversing the order, sets the 'Date' column as the index, and filters data for a specific date range.

```python
# load data (source is https://www.cryptodatadownload.com)
BTC_price = pd.read_csv('../data/gemini_BTCUSD_day.csv',header=1)

# drop the first column and reverse order
BTC_price = BTC_price.iloc[1:,:]
BTC_price = BTC_price.iloc[::-1]
BTC_price['Date'] = pd.to_datetime(BTC_price['Date'])
BTC_price.set_index('Date', inplace=True)

# select duration
initial_date = '2017-06-01'
finish_date = '2018-08-01'
BTC_price = BTC_price.loc[BTC_price.index >= initial_date]
BTC_price = BTC_price.loc[BTC_price.index <= finish_date]
```

--------------------------------

### Tqdm Progress Output

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Console output indicating progress of the loops.

```text
  0%|          | 0/5 [00:00<?, ?it/s]
```

```text
  0%|          | 0/1 [00:00<?, ?it/s]
```

```text
  0%|          | 0/2 [00:00<?, ?it/s]
```

```text
  0%|          | 0/6 [00:00<?, ?it/s]
```

--------------------------------

### LinearKernel - Linear Static Kernel

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Compute inner products between path increments using the Linear kernel. Optionally scale kernel values. Can be used as a base for the signature kernel.

```python
import torch
import sigkernel

linear_kernel = sigkernel.LinearKernel(scale=1.0)

batch, len_x, len_y, dim = 5, 30, 35, 4
X = torch.rand(batch, len_x, dim, dtype=torch.float64)
Y = torch.rand(batch, len_y, dim, dtype=torch.float64)

K = linear_kernel.batch_kernel(X, Y)
print(f"Linear batch kernel shape: {K.shape}")
```

```python
import torch
import sigkernel

linear_kernel = sigkernel.LinearKernel(scale=1.0)

batch, len_x, len_y, dim = 5, 30, 35, 4
X = torch.rand(batch, len_x, dim, dtype=torch.float64)
Y = torch.rand(batch, len_y, dim, dtype=torch.float64)

sig_kernel = sigkernel.SigKernel(linear_kernel, dyadic_order=0)
result = sig_kernel.compute_kernel(X, Y)
print(f"Signature kernel with linear base: {result.shape}")
```

--------------------------------

### Define Hyperparameter Grid

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Sets up the parameter space for SVR grid search.

```python
svr_parameters = {'C': np.logspace(0, 4, 5), 'gamma': np.logspace(-4, 4, 9)}
```

--------------------------------

### Time Series Classification with SVM and Sigkernel

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Demonstrates a complete workflow for multivariate time series classification using Support Vector Machines. Includes data generation, path preprocessing, Gram matrix computation, and SVM training with a precomputed kernel.

```python
import torch
import numpy as np
from sklearn.svm import SVC
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
import sigkernel

# Generate synthetic classification data
n_class_0, n_class_1 = 30, 30
length, dim = 40, 2

# Class 0: Brownian motion with low drift
class_0 = 0.1 * torch.arange(length).unsqueeze(0).unsqueeze(-1).repeat(n_class_0, 1, dim).float()
class_0 += torch.cumsum(torch.randn(n_class_0, length, dim), dim=1)

# Class 1: Brownian motion with high drift
class_1 = 0.5 * torch.arange(length).unsqueeze(0).unsqueeze(-1).repeat(n_class_1, 1, dim).float()
class_1 += torch.cumsum(torch.randn(n_class_1, length, dim), dim=1)

# Combine data
X = torch.cat([class_0, class_1], dim=0)
y = np.array([0] * n_class_0 + [1] * n_class_1)

# Train/test split
indices = np.arange(len(y))
train_idx, test_idx = train_test_split(indices, test_size=0.3, stratify=y, random_state=42)

X_train, X_test = X[train_idx], X[test_idx]
y_train, y_test = y[train_idx], y[test_idx]

# Setup signature kernel
static_kernel = sigkernel.RBFKernel(sigma=1.0)
sig_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=0)

# Compute Gram matrices
G_train = sig_kernel.compute_Gram(X_train, X_train, sym=True).numpy()
G_test = sig_kernel.compute_Gram(X_test, X_train, sym=False).numpy()

# Train SVM with precomputed kernel
clf = SVC(kernel='precomputed', C=1.0)
clf.fit(G_train, y_train)

# Evaluate
train_acc = clf.score(G_train, y_train)
test_acc = clf.score(G_test, y_test)
print(f"Training accuracy: {train_acc:.2%}")
print(f"Testing accuracy: {test_acc:.2%}")
```

--------------------------------

### Perform Signature Kernel Grid Search

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Iterates over signature depths, scales, kernels, and normalization settings to find the best model.

```python
best_error_sig = 1e8

for depth in tqdm([2, 3, 4, 5, 6]):
    for scale in tqdm([1., 2., 3., 4., 5.], leave=False):
        for ker in tqdm(['linear', 'rbf'], leave=False):
            for normalize in tqdm([True, False], leave=False):
    
                # truncated signatures
                sig_train = iisignature.sig(scale*x_train.numpy(), depth)
            
                # normalization
                if normalize:
                    sig_train = sigkernel.normalize(sig_train, x_train.shape[-1], depth)

                # fit the model
                svr = SVR(kernel=ker)
                svr_sig = GridSearchCV(estimator=svr, param_grid=svr_parameters, cv=5, n_jobs=-1)
                svr_sig.fit(sig_train, np.squeeze(y_train))

                # select best model (criterion: R^2)
                if np.abs(1.-svr_sig.best_score_) < np.abs(1.-best_error_sig):
                    best_sig_model = svr_sig
                    best_error_sig = svr_sig.best_score_
                    best_depth_sig = depth
                    best_scale_sig = scale
                    best_ker_sig = ker
                    normalize_sig = normalize
```

--------------------------------

### Cite the signature kernel paper

Source: https://github.com/crispitagorico/sigkernel/blob/master/README.md

BibTeX citation for the signature kernel research paper.

```bibtex
@article{salvi2020computing,
  title={The Signature Kernel is the solution of a Goursat PDE},
  author={Salvi, Cristopher and Cass, Thomas and Foster, James and Lyons, Terry and Yang, Weixin},
  journal={arXiv preprint arXiv:2006.14794},
  year={2020}
}
```

--------------------------------

### Define Kernel List

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

List of kernel types to be evaluated.

```python
# kernels to test
kernels = ['rbf', 'gak', 'sig', 'sig_PDE']
```

--------------------------------

### hypothesis_test - Statistical Distribution Testing

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Perform a statistical hypothesis test using MMD to check if two sets of paths originate from the same distribution. Requires a static kernel and confidence level.

```python
import torch
import sigkernel

device = 'cuda' if torch.cuda.is_available() else 'cpu'

n_samples = 50
length, dim = 30, 2

paths_A = torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)
paths_B_same = torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)
paths_C_diff = 3.0 * torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)

static_kernel = sigkernel.RBFKernel(sigma=1.0)

print("Testing A vs B (same distribution):")
sigkernel.hypothesis_test(paths_A, paths_B_same, static_kernel, confidence_level=0.99, dyadic_order=0)

print("\nTesting A vs C (different distributions):")
sigkernel.hypothesis_test(paths_A, paths_C_diff, static_kernel, confidence_level=0.99, dyadic_order=0)
```

--------------------------------

### Evaluate kernels and store results

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Iterates through a list of kernels to compute Gram matrices or truncated signatures, performs predictions, and calculates mean absolute percentage error.

```python
final = {}
for ker in tqdm(kernels):

    if ker=='sig_PDE':
        
        # Specify the static kernel 
        static_kernel = sigkernel.RBFKernel(sigma=best_sigma)

        # Initialize the corresponding signature kernel
        signature_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=0)
    
        # Gram matrix test
        G_train = signature_kernel.compute_Gram(x_train, x_train, sym=True).numpy()
        G_test = signature_kernel.compute_Gram(x_test, x_train, sym=False).numpy()
        
        # predict
        y_train_predict = best_pde_model.predict(G_train)
        y_test_predict = best_pde_model.predict(G_test)  
        
        # calculate errors
        p_error_test = mean_absolute_percentage_error(np.array(y_test).reshape(-1,1), np.array(y_test_predict).reshape(-1,1))
        final[ker] = p_error_test
        
        # plot results
        PlotResult(y_train, y_test, y_train_predict, y_test_predict, ker)
        
    elif ker in ['rbf', 'gak']:
        
        # fit 
        svr = TimeSeriesSVR(kernel=ker)
        svr_model = GridSearchCV(estimator=svr, param_grid=svr_parameters, cv=TimeSeriesSplit(n_splits=5), n_jobs=-1)
        svr_model.fit(x_train.numpy(), np.squeeze(y_train))
        
        # predict
        y_train_predict = svr_model.predict(x_train.numpy())
        y_test_predict = svr_model.predict(x_test.numpy())
        
        # calculate errors
        p_error_test = mean_absolute_percentage_error(np.array(y_test).reshape(-1,1), np.array(y_test_predict).reshape(-1,1))
        final[ker] = p_error_test

    else:            
        # truncated signatures
        sig_train = iisignature.sig(best_scale_sig*x_train.numpy(), best_depth_sig)
        sig_test = iisignature.sig(best_scale_sig*x_test.numpy(), best_depth_sig)

        # normalization
        if normalize_sig:
            sig_train = sigkernel.normalize(sig_train, x_train.shape[-1], best_depth_sig)
            sig_test = sigkernel.normalize(sig_test, x_test.shape[-1], best_depth_sig)

        # predict
        y_train_predict = best_sig_model.predict(sig_train)
        y_test_predict = best_sig_model.predict(sig_test)
            
        # calculate errors
        p_error_test = mean_absolute_percentage_error(np.array(y_test).reshape(-1,1), 
                                                      np.array(y_test_predict).reshape(-1,1))
        final[ker + f'_best_depth_{best_depth_sig}', f'best_ker_{best_ker_sig}'] = p_error_test

# save results
with open('../results/bitcoin_results.pkl', 'wb') as file:
    pickle.dump(final, file)
```

--------------------------------

### Extract Rolling Windows and Future Means

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Helper functions to extract rolling windows of historical prices and calculate the mean of future prices. `GetWindow` creates sliding windows, and `GetNextMean` computes the rolling mean for prediction targets.

```python
#Helper function that extract rolling windows of historical prices of size h and means of the next future f prices.
def GetWindow(x, h_window=30, f_window=10):

    # First window
    X = np.array(x.iloc[:h_window,]).reshape(1,-1)
   
    # Append next window
    for i in range(1,len(x)-h_window+1):
        x_i = np.array(x.iloc[i:i+h_window,]).reshape(1,-1)
        X = np.append(X, x_i, axis=0)
        
    # Cut the end that we can't use to predict future price
    rolling_window = (pd.DataFrame(X)).iloc[:-f_window,]
    return rolling_window

def GetNextMean(x, h_window=30, f_window=10):
    return pd.DataFrame((x.rolling(f_window).mean().iloc[h_window+f_window-1:,]))
```

--------------------------------

### Move tensors to MPS device

Source: https://github.com/crispitagorico/sigkernel/blob/master/README.md

Explicitly move PyTorch tensors to the Apple Silicon GPU device.

```python
X = X.to('mps')
Y = Y.to('mps')
```

--------------------------------

### Import Libraries and Configure Plotting

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Imports necessary libraries for data manipulation, machine learning, and plotting. Configures matplotlib parameters for better visualization.

```python
import pandas as pd
import numpy as np
import torch
from tqdm.notebook import tqdm
import pickle
import iisignature

from sklearn.model_selection import train_test_split, GridSearchCV, TimeSeriesSplit
from tslearn.preprocessing import TimeSeriesScalerMinMax, TimeSeriesScalerMeanVariance
from sklearn.metrics import mean_absolute_error

from tslearn.svm import TimeSeriesSVR
from sklearn.svm import SVR

import sigkernel

import matplotlib.pyplot as plt
import matplotlib.pylab as pylab
params = {'legend.fontsize': 'large',
          'figure.figsize': (16, 5),
          'axes.labelsize': 'large',
          'axes.titlesize':'large',
          'xtick.labelsize':'large',
          'ytick.labelsize':'large'}
pylab.rcParams.update(params)
```

--------------------------------

### Perform PDE-based Signature Kernel Grid Search

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Iterates over sigma values to optimize the RBF static kernel within a signature kernel framework.

```python
best_error = 1e8

for sigma in tqdm([5e-2, 1e-1, 2.5e-1, 5e-1, 7.5e-1, 1.]):
    
    # Specify the static kernel 
    static_kernel = sigkernel.RBFKernel(sigma=sigma)

    # Initialize the corresponding signature kernel
    signature_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=0)
    
    # Gram matrix train
    G_train = signature_kernel.compute_Gram(x_train, x_train, sym=True).numpy()
    
    # fit the model
    svr = SVR(kernel='precomputed')
    svr_pde = GridSearchCV(estimator=svr, param_grid=svr_parameters, cv=5, n_jobs=-1)
    svr_pde.fit(G_train, np.squeeze(y_train))
            
    if np.abs(1.-svr_pde.best_score_) < np.abs(1.-best_error):
        best_pde_model = svr_pde
        best_error = svr_pde.best_score_
        best_sigma = sigma
```

--------------------------------

### RBFKernel - Radial Basis Function Static Kernel

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Use the RBF kernel for point-wise similarities between path increments. Control sensitivity to path differences with the sigma parameter.

```python
import torch
import sigkernel

rbf_kernel = sigkernel.RBFKernel(sigma=0.5)

batch, len_x, len_y, dim = 5, 20, 25, 3
X = torch.rand(batch, len_x, dim, dtype=torch.float64)
Y = torch.rand(batch, len_y, dim, dtype=torch.float64)

K_batch = rbf_kernel.batch_kernel(X, Y)
print(f"Batch kernel shape: {K_batch.shape}")
```

```python
import torch
import sigkernel

rbf_kernel = sigkernel.RBFKernel(sigma=0.5)

batch_x, batch_y = 8, 10
len_x, len_y, dim = 20, 25, 3
X = torch.rand(batch_x, len_x, dim, dtype=torch.float64)
Y = torch.rand(batch_y, len_y, dim, dtype=torch.float64)

G = rbf_kernel.Gram_matrix(X, Y)
print(f"Gram matrix shape: {G.shape}")
```

--------------------------------

### Compute Signature Kernel Scoring Rules

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Evaluates probabilistic forecasts by measuring how well a set of sample paths represents observed target paths.

```python
import torch
import sigkernel

device = 'cuda' if torch.cuda.is_available() else 'cpu'

# Ensemble of forecast paths (e.g., from Monte Carlo simulation)
n_forecasts = 30
forecast_length, dim = 50, 2
X_forecasts = torch.cumsum(torch.randn(n_forecasts, forecast_length, dim, device=device), dim=1)
X_forecasts.requires_grad = True

# Single observed path
y_observed = torch.cumsum(torch.randn(1, forecast_length, dim, device=device), dim=1)

# Multiple observed paths for expected scoring rule
Y_observed = torch.cumsum(torch.randn(10, forecast_length, dim, device=device), dim=1)

# Setup signature kernel
static_kernel = sigkernel.RBFKernel(sigma=0.5)
sig_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=1)
```

--------------------------------

### Compute Maximum Mean Discrepancy (MMD)

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Calculates the MMD distance between two sets of paths, supporting backpropagation for training generative models.

```python
import torch
import sigkernel

device = 'cuda' if torch.cuda.is_available() else 'cpu'

# Generate two sets of time series from different distributions
batch_X, batch_Y = 20, 25
length, dim = 40, 2

# Distribution 1: Random walk
X = torch.cumsum(torch.randn(batch_X, length, dim, device=device), dim=1)
X.requires_grad = True

# Distribution 2: Scaled random walk (different distribution)
Y = 2.0 * torch.cumsum(torch.randn(batch_Y, length, dim, device=device), dim=1)

# Setup signature kernel
static_kernel = sigkernel.RBFKernel(sigma=1.0)
sig_kernel = sigkernel.SigKernel(static_kernel, dyadic_order=0)

# Compute MMD distance
mmd_distance = sig_kernel.compute_mmd(X, Y, max_batch=50)
print(f"MMD distance: {mmd_distance.item():.6f}")

# Backpropagate through MMD (useful for generative model training)
mmd_distance.backward()
print(f"Gradient shape: {X.grad.shape}")  # Gradients flow back to X
```

--------------------------------

### Plot Prediction Results

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

Visualizes the training and testing results of a time series prediction model. It plots predicted and actual prices for both training and testing sets, highlighting the test set period.

```python
def PlotResult(y_train, y_test, y_train_predict, y_test_predict, name):
    
    train_len = len(y_train)
    test_len = len(y_test)
    
    #Visualise
    fig, ax = plt.subplots(1, figsize=(12, 5))
    ax.plot(y_train_predict,color='red')

    ax.plot(range(train_len, train_len+test_len),
            y_test_predict,
            label='Predicted average price',
            color='red',linestyle = '--')

    ax.plot(np.array((y_train).append(y_test)),
             label='Actual average price',
             color='green')

    ax.axvspan(len(y_train), len(y_train)+len(y_test),
                alpha=0.3, color='lightgrey')

    plt.grid(True)
    plt.axis('tight')
    plt.legend(loc="best")
    plt.xlabel('Days')
    plt.ylabel('Bitcoin prices')
    plt.savefig('../pictures/bitcoin_prices_prediction_{}'.format(name))
    plt.show()
```

--------------------------------

### SigCHSIC - Conditional Independence Testing

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Compute the Signature Conditional Hilbert-Schmidt Independence Criterion (CHSIC) to test conditional independence between time series X and Y given Z. Requires a static kernel.

```python
import torch
import sigkernel

device = 'cuda' if torch.cuda.is_available() else 'cpu'

n_samples = 30
length, dim = 25, 2

Z = torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)
X = Z + 0.5 * torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)
Y = Z + 0.5 * torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)

static_kernel = sigkernel.RBFKernel(sigma=0.5)

# Compute conditional independence statistic
```

--------------------------------

### Calculate Mean Absolute Percentage Error

Source: https://github.com/crispitagorico/sigkernel/blob/master/examples/bitcoin_predictions.ipynb

A helper function to compute the Mean Absolute Percentage Error (MAPE) between true and predicted values. Useful for evaluating forecasting models.

```python
def mean_absolute_percentage_error(y_true, y_pred):
    return 100.*np.mean(np.abs((y_true - y_pred) / y_true))
```

--------------------------------

### Compute Scoring Rule and Expected Scoring Rule

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Compute the scoring rule for a single observation or the expected scoring rule averaged over multiple observations. Gradients can be computed for training generative models.

```python
score = sig_kernel.compute_scoring_rule(X_forecasts, y_observed[0], max_batch=50)
print(f"Scoring rule: {score.item():.6f}")
```

```python
expected_score = sig_kernel.compute_expected_scoring_rule(X_forecasts, Y_observed, max_batch=50)
print(f"Expected scoring rule: {expected_score.item():.6f}")
```

```python
expected_score.backward()
```

--------------------------------

### Calculate SigCHSIC for Conditional Independence

Source: https://context7.com/crispitagorico/sigkernel/llms.txt

Compute the SigCHSIC value to assess conditional independence between X and Y given Z. Compares the result with a case using random Z.

```python
chsic_value = sigkernel.SigCHSIC(X, Y, Z, static_kernel, dyadic_order=1, eps=0.1)
print(f"SigCHSIC(X, Y | Z): {chsic_value.item():.6f}")
```

```python
Z_random = torch.cumsum(torch.randn(n_samples, length, dim, device=device), dim=1)
chsic_random = sigkernel.SigCHSIC(X, Y, Z_random, static_kernel, dyadic_order=1, eps=0.1)
print(f"SigCHSIC with random Z: {chsic_random.item():.6f}")
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.