def test_create_one_hot():
tensor = torch.from_numpy(np.array([1, 2, 3, 4, 0]))
size = 5
expected = torch.from_numpy(
np.array([[0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0],
[0, 0, 0, 0, 1], [1, 0, 0, 0, 0]]))
one_hot = create_one_hot(tensor, size)
assert_tensors_equal(one_hot, expected)
def test_drop_matrix_rows_3d():
matrix = torch.FloatTensor([[[1, 1, 1], [2, 2, 2], [3, 3, 3]],
[[4, 4, 4], [5, 5, 5], [6, 6, 6]]])
forget_vector = torch.FloatTensor([[0], [1]])
expected = torch.FloatTensor([[[0, 0, 0], [0, 0, 0], [0, 0, 0]],
[[4, 4, 4], [5, 5, 5], [6, 6, 6]]])
assert_tensors_equal(drop_matrix_rows_3d(matrix, forget_vector), expected)
def test_calc_attention_combination_should_work():
matrix = torch.FloatTensor([[[1, 10], [1, 1], [1, 8]],
[[1, 1], [4, 4], [9, 6]]])
attention_weights = torch.FloatTensor([[[1. / 2], [1.], [1. / 2]],
[[1.], [1. / 2], [1. / 3]]])
expected = torch.FloatTensor([[2., 10.], [6., 5.]])
attentioned = calc_attention_combination(attention_weights, matrix)
assert_tensors_equal(attentioned, expected)
def test_tensor_visualizer_metrics():
metrics = TensorVisualizerMetrics(file=None)
t1 = torch.from_numpy(np.array([[1, 2, 3], [4, 5, 6]]))
t2 = torch.from_numpy(np.array([[3, 4, 5], [6, 7, 8]]))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = (t1 + t2) / 2
assert_tensors_equal(metrics.get_current_value(), expected)
def test_tensor_visualizer2d_metrics_dim1():
metrics = TensorVisualizer2DMetrics(dim=1, file=None)
t1 = torch.from_numpy(np.array([[1, 2, 3], [4, 5, 6]]))
t2 = torch.from_numpy(np.array([[3, 4, 5], [6, 7, 8]]))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = torch.sum(t1 + t2, dim=1).float() / 6
assert_tensors_equal(metrics.get_current_value(), expected)
def test_tensor_visualizer2d_metrics_dim1_random():
torch.manual_seed(145)
metrics = TensorVisualizer2DMetrics(dim=1, file=None)
t1 = torch.randn((2, 3))
t2 = torch.randn((2, 3))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = torch.sum(t1 + t2, dim=1).float() / 6
assert_tensors_equal(metrics.get_current_value(), expected, eps=1e-6)
def test_tensor_visualizer_metrics_random():
torch.manual_seed(123)
metrics = TensorVisualizerMetrics(file=None)
t1 = torch.randn((2, 3))
t2 = torch.randn((2, 3))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = (t1 + t2) / 2
assert_tensors_equal(metrics.get_current_value(), expected, eps=1e-6)
def test_tensor_visualizer3d_metrics_random():
torch.manual_seed(2)
metrics = TensorVisualizer3DMetrics(file=None)
t1 = torch.randn((3, 4, 5))
t2 = torch.randn((3, 4, 5))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = (t1 + t2).sum(0).sum(0) / (12 * 2)
assert_tensors_equal(metrics.get_current_value(), expected, eps=1e-6)
def test_tensor_visualizer3d_metrics():
torch.manual_seed(2)
metrics = TensorVisualizer3DMetrics(file=None)
t1 = torch.from_numpy(
np.array([[
[1, 1, 1, 1, 1],
[2, 2, 2, 2, 2],
[3, 3, 3, 3, 3],
[4, 4, 4, 4, 4],
],
[
[1, 1, 1, 1, 8],
[2, 10, 2, 4, 2],
[3, 3, 3, 3, 3],
[9, 4, 4, 4, 4],
],
[
[1, 1, -10, 1, 9],
[2, -1, 2, 5, 2],
[0, 3, 7, 3, 3],
[4, 2, 4, 4, 4],
]]))
t2 = torch.from_numpy(
np.array([[
[10, 1, 10, 1, 1],
[2, 22, 28, 29, 2],
[3, 34, 33, 3, 31],
[4, 4, 4, 44, 4],
],
[
[1, 11, 1, 1, 8],
[2, 10, 2, 4, 2],
[3, 3, 33, 3, 3],
[9, 4, 4, 47, 40],
],
[
[1000, 1, -10, 1, 91],
[2, -111, 2, 5, 2],
[0, 32, 7, 3, 3],
[4, 24, 4, 4, 4],
]]))
metrics.drop_state()
metrics.report(t1)
metrics.report(t2)
expected = (t1 + t2).sum(0).sum(0) / (12 * 2)
assert_tensors_equal(metrics.get_current_value(), expected, eps=1e-6)
def test_move_right_should_move_dim0():
matrix = torch.LongTensor([[1, 1, 1], [2, 2, 2], [3, 3, 3]])
dimension = 0
shift_left(matrix, dimension)
assert_tensors_equal(matrix,
torch.LongTensor([[2, 2, 2], [3, 3, 3], [3, 3, 3]]))
def test_pad_tensor_2d():
tensor = torch.tensor([[3, 2, 1], [0, 10, 5]], dtype=torch.long)
assert_tensors_equal(
pad_tensor(tensor, seq_len=4),
torch.tensor([[3, 2, 1], [0, 10, 5], [0, 10, 5], [0, 10, 5]],
dtype=torch.float32))
def test_pad_tensor_float():
tensor = torch.tensor([0., 0.5, 1.2], dtype=torch.float32)
assert_tensors_equal(
pad_tensor(tensor, seq_len=6),
torch.tensor([0., 0.5, 1.2, 1.2, 1.2, 1.2], dtype=torch.float32))
def test_pad_tensor_long():
tensor = torch.tensor([1, 2, 3], dtype=torch.long)
assert_tensors_equal(pad_tensor(tensor, seq_len=5),
torch.tensor([1, 2, 3, 3, 3], dtype=torch.long))
