def iisignature_signature(path,
depth,
stream=False,
basepoint=False,
inverse=False):
"""Duplicates signatory.signature's functionality using iisignature, for testing purposes."""
return r.iisignature_signature_or_logsignature(
_IisignatureSignatureFunction.apply, path, depth, stream, basepoint,
inverse)
def iisignature_signature(path, depth, stream, basepoint, inverse, initial):
"""Duplicates signatory.signature's functionality using iisignature, for testing purposes."""
if isinstance(initial, torch.Tensor):
def fn(path, depth):
return signatory.signature_combine(
initial, _IisignatureSignatureFunction.apply(path, depth),
path.size(-1), depth, inverse)
else:
fn = _IisignatureSignatureFunction.apply
return r.iisignature_signature_or_logsignature(fn, path, depth, stream,
basepoint, inverse)
def iisignature_signature(path, depth, stream, basepoint, inverse, initial, scalar_term):
"""Duplicates signatory.signature's functionality using iisignature, for testing purposes."""
def fn(path, depth):
signature = _IisignatureSignatureFunction.apply(path, depth)
if scalar_term:
out = torch.ones(signature.size(0), 1 + signature.size(1), dtype=signature.dtype,
device=signature.device)
out[:, 1:] = signature
signature = out
if isinstance(initial, torch.Tensor):
signature = signatory.signature_combine(initial, signature, path.size(-1), depth, inverse, scalar_term)
return signature
return r.iisignature_signature_or_logsignature(fn, path, depth, stream, basepoint, inverse)
def iisignature_logsignature(path, depth, stream, basepoint, inverse, mode):
"""Duplicates signatory.logsignature's functionality using iisignature, for testing purposes."""
batch_size, input_stream, input_channels = path.shape
device = path.device
dtype = path.dtype
if input_channels > 1:
fn = lambda path, depth: _iisignature_logsignature(path, depth, mode)
result = r.iisignature_signature_or_logsignature(fn, path, depth, stream, basepoint, inverse)
else:
# iisignature doesn't actually support channels == 1, but the logsignature is just the increment in this
# case.
# Add on the basepoint if necessary
if basepoint is True:
iisignature_path = torch.cat([torch.zeros(batch_size, 1, input_channels,
dtype=dtype, device=device), path], dim=1)
elif isinstance(basepoint, torch.Tensor):
iisignature_path = torch.cat([basepoint.unsqueeze(1), path], dim=1)
else:
iisignature_path = path
# Calculate increments
result = iisignature_path[:, 1:] - iisignature_path[:, 0].unsqueeze(1)
# Extract final piece if necessary
if not stream:
result = result[:, -1]
# Invert if necessary
# (The simple code below works in this special case! Inverting is usually a bit trickier.)
if inverse:
result = -result
if mode == h.expand_mode:
result_ = result
if stream:
if basepoint is False:
stream_length = input_stream - 1
else:
stream_length = input_stream
result = torch.zeros(batch_size, stream_length, depth, dtype=dtype, device=device)
else:
result = torch.zeros(batch_size, depth, dtype=dtype, device=device)
result[..., 0].unsqueeze(-1).copy_(result_)
return result
def iisignature_signature(path,
depth,
stream=False,
basepoint=False,
inverse=False,
scalar_term=False):
"""Duplicates signatory.signature's functionality using iisignature, for testing purposes."""
def fn(path, depth):
signature = _IisignatureSignatureFunction.apply(path, depth)
if scalar_term:
out = torch.ones(signature.size(0),
1 + signature.size(1),
dtype=signature.dtype,
device=signature.device)
out[:, 1:] = signature
signature = out
return signature
return r.iisignature_signature_or_logsignature(fn, path, depth, stream,
basepoint, inverse)