def test_path():
"""Tests that Path behaves correctly."""
# Test small edge cases thoroughly
for device in h.get_devices():
for batch_size in (1, 2):
for input_stream, basepoints in zip(
(1, 2), ((True, h.without_grad, h.with_grad),
(False, True, h.without_grad, h.with_grad))):
for input_channels in (1, 2):
for depth in (1, 2):
path_grad = random.choice([False, True])
basepoint = random.choice(basepoints)
update_lengths, update_grads = _update_lengths_update_grads(
3)
_test_path(device,
path_grad,
batch_size,
input_stream,
input_channels,
depth,
basepoint,
update_lengths,
update_grads,
extrarandom=False)
# Randomly test larger cases
for _ in range(50):
device = random.choice(h.get_devices())
batch_size = random.choice((1, 2, 5))
input_stream = random.choice([3, 6, 10])
input_channels = random.choice([1, 2, 6])
depth = random.choice([1, 2, 4, 6])
basepoint = random.choice([False, True, h.without_grad, h.with_grad])
path_grad = random.choice([False, True])
update_lengths, update_grads = _update_lengths_update_grads(10)
_test_path(device,
path_grad,
batch_size,
input_stream,
input_channels,
depth,
basepoint,
update_lengths,
update_grads,
extrarandom=True)
# Do at least one large test
for device in h.get_devices():
_test_path(device,
path_grad=True,
batch_size=5,
input_stream=10,
input_channels=6,
depth=6,
basepoint=True,
update_lengths=[5, 6],
update_grads=[False, True],
extrarandom=False)
def test_forward():
"""Tests that the forward calculations of the signature behave correctly."""
for class_ in (False, True):
for device in h.get_devices():
# sometimes we do different calculations depending on whether we expect to take a gradient later, so we need
# to check both of these cases
for path_grad in (False, True):
for batch_size in (0, 1, 2, 5):
for input_stream in (0, 1, 2, 3, 10):
for input_channels in (0, 1, 2, 6):
for depth in (1, 2, 4, 6):
for stream in (False, True):
for basepoint in (False, True,
h.without_grad,
h.with_grad):
for inverse in (False, True):
for initial in (None,
h.without_grad,
h.with_grad):
_test_forward(
class_, device, path_grad,
batch_size, input_stream,
input_channels, depth,
stream, basepoint, inverse,
initial)
def test_backward_expand_words():
"""Tests that the backward calculations produce the correct values."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels in h.random_sizes():
for depth in (1, 2, 4, 6):
for stream in (False, True):
for mode in (h.expand_mode, h.words_mode):
_test_backward(class_, device, batch_size,
input_stream, input_channels, depth,
stream, mode)
def test_backward():
"""Tests that the backwards calculation for combing signatures produces the correct values."""
for signature_combine, amount in ((True, 2), (False, 1), (False, 2),
(False, 3), (False, 10)):
for device in h.get_devices():
for batch_size, input_stream, input_channels in h.random_sizes():
for depth in (1, 2, 4, 6):
inverse = random.choice([False, True])
_test_backward(signature_combine, amount, device,
batch_size, input_stream, input_channels,
depth, inverse)
def test_backward_brackets():
"""Tests that the backwards operation through the logsignature gives the correct values."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels, basepoint in h.random_sizes_and_basepoint():
for depth in (1, 2, 4, 6):
for mode in (h.brackets_mode,):
stream = random.choice([False, True])
inverse = random.choice([False, True])
_test_backward(class_, device, batch_size, input_stream, input_channels, depth, stream,
basepoint, inverse, mode)
def test_backward():
"""Tests that the backwards operation through the signature gives the correct values."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels, basepoint in h.random_sizes_and_basepoint():
for depth in (1, 2, 4, 6):
for stream in (False, True):
for inverse in (False, True):
for initial in (None, h.without_grad, h.with_grad):
for scalar_term in (False, True):
_test_backward(class_, device, batch_size, input_stream, input_channels, depth,
stream, basepoint, inverse, initial, scalar_term)
def test_no_adjustments():
"""Tests that the logsignature computations don't modify any memory that they're not supposed to."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels, basepoint in h.random_sizes_and_basepoint():
for depth in (1, 2, 5):
for mode in h.all_modes:
path_grad = random.choice([False, True])
stream = random.choice([False, True])
inverse = random.choice([False, True])
_test_no_adjustments(class_, device, batch_size, input_stream, input_channels, depth, stream,
basepoint, inverse, mode, path_grad)
def test_forward():
"""Tests that the forward calculations produce the correct values."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels in h.random_sizes():
for depth in (1, 2, 4, 6):
for stream in (False, True):
for mode in h.all_modes:
for signature_grad in (False, True):
_test_forward(class_, device, batch_size,
input_stream, input_channels,
depth, stream, mode,
signature_grad)
def test_no_adjustments():
"""Tests that no memory is modified that shouldn't be modified."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels in h.random_sizes():
for depth in (1, 2, 5):
for stream in (False, True):
for mode in h.all_modes:
for signature_grad in (False, True):
_test_no_adjustments(class_, device,
batch_size, input_stream,
input_channels, depth,
stream, mode,
signature_grad)
def test_no_adjustments():
"""Tests that the signature computations don't modify any memory that they're not supposed to."""
for class_ in (False, True):
for path_grad in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels, basepoint in h.random_sizes_and_basepoint():
for depth in (1, 2, 5):
for stream in (False, True):
for inverse in (False, True):
for initial in (None, h.without_grad, h.with_grad):
for scalar_term in (False, True):
_test_no_adjustments(class_, device, batch_size, input_stream, input_channels,
depth, stream, basepoint, inverse, initial, path_grad,
scalar_term)
def test_forward():
"""Tests that the forward calculation for combing signatures produces the correct values."""
for signature_combine, amount in ((True, 2), (False, 1), (False, 2),
(False, 3), (False, 10)):
for signature_grad in (False, True):
for device in h.get_devices():
for batch_size in (1, 2, 5):
input_stream = 2
for input_channels in (1, 2, 6):
for depth in (1, 2, 4, 6):
for inverse in (False, True):
_test_forward(signature_combine,
signature_grad, amount, device,
batch_size, input_stream,
input_channels, depth, inverse)
def test_no_adjustments():
"""Tests that the calculations for combining signatures don't modify memory they're not supposed to."""
for signature_combine, amount in ((True, 2), (False, 1), (False, 2),
(False, 3), (False, 10)):
for signature_grad in (False, True):
for device in h.get_devices():
for batch_size, input_stream, input_channels in h.random_sizes(
):
for depth in (1, 2, 5):
for inverse in (False, True):
_test_no_adjustments(signature_combine, amount,
device, batch_size,
input_stream, input_channels,
depth, inverse,
signature_grad)
def test_forward():
"""Tests that the forward calculations of the logsignature behave correctly."""
for class_ in (False, True):
for device in h.get_devices():
for batch_size in (0, 1, 2, 3):
for input_stream in (0, 1, 2, 3, 10):
for input_channels in (0, 1, 2, 6):
for depth in (1, 2, 4, 6):
for mode in h.all_modes:
# Cuts down on the amount of iterations dramatically!
# We're randomising over the arguments which we happen to know aren't really important
# to the operation of logsignatures (as compared to signatures), so we're not missing
# much by doing this.
stream = random.choice([False, True])
path_grad = random.choice([False, True])
basepoint = random.choice([False, True, h.without_grad, h.with_grad])
inverse = random.choice([False, True])
_test_forward(class_, device, path_grad, batch_size, input_stream, input_channels,
depth, stream, basepoint, inverse, mode)
