def test_non_integer_embeddings_rejected():
"""Tests whether an error is raised if user tries to provide non-integer data to be embedded"""
with pytest.raises(AssertionError):
nn_instance = NN(input_dim=5,
layers=[5],
columns_of_data_to_be_embedded=[2, 4],
embedding_dimensions=[[50, 3], [55, 4]])
out = nn_instance.forward(X)
def test_output_activation():
"""Tests whether network outputs data that has gone through correct activation function"""
RANDOM_ITERATIONS = 20
for _ in range(RANDOM_ITERATIONS):
data = torch.randn((1, 100))
nn_instance = NN(input_dim=100,
layers=[5, 5, 5],
hidden_activations="relu",
output_activation="relu",
initialiser="xavier")
out = nn_instance.forward(data)
assert all(out.squeeze() >= 0)
nn_instance = NN(input_dim=100,
layers=[5, 5, 5],
hidden_activations="relu",
output_activation="sigmoid",
initialiser="xavier")
out = nn_instance.forward(data)
assert all(out.squeeze() >= 0)
assert all(out.squeeze() <= 1)
nn_instance = NN(input_dim=100,
layers=[5, 5, 5],
hidden_activations="relu",
output_activation="softmax",
initialiser="xavier")
out = nn_instance.forward(data)
assert all(out.squeeze() >= 0)
assert all(out.squeeze() <= 1)
assert round(torch.sum(out.squeeze()).item(), 3) == 1.0
nn_instance = NN(
input_dim=100,
layers=[5, 5, 5],
hidden_activations="relu",
)
out = nn_instance.forward(data)
assert not all(out.squeeze() >= 0)
assert not round(torch.sum(out.squeeze()).item(), 3) == 1.0
def test_output_head_activations_work():
"""Tests that output head activations work properly"""
nn_instance = NN(input_dim=2,
layers_info=[4, 7, 9, [5, 10, 3]],
hidden_activations="relu",
output_activation=["softmax", None, "relu"])
x = torch.randn((20, 2)) * -20.0
out = nn_instance.forward(x)
assert torch.allclose(torch.sum(out[:, :5], dim=1), torch.Tensor([1.0]))
assert not torch.allclose(torch.sum(out[:, 5:], dim=1), torch.Tensor([1.0
]))
for row in range(out.shape[0]):
assert all(out[row, -3:] >= 0)
def test_output_shape_correct():
"""Tests whether network returns output of the right shape"""
input_dims = [x for x in range(1, 3)]
output_dims = [x for x in range(4, 6)]
linear_hidden_units_options = [[2, 3, 4], [2, 9, 1], [55, 55, 55, 234, 15]]
for input_dim, output_dim, linear_hidden_units in zip(
input_dims, output_dims, linear_hidden_units_options):
linear_hidden_units.append(output_dim)
nn_instance = NN(input_dim=input_dim,
layers=linear_hidden_units,
hidden_activations="relu",
output_activation="relu",
initialiser="xavier")
data = torch.randn((25, input_dim))
output = nn_instance.forward(data)
assert output.shape == (25, output_dim)
def test_y_range():
"""Tests whether setting a y range works correctly"""
for _ in range(100):
val1 = random.random() - 3.0 * random.random()
val2 = random.random() + 2.0 * random.random()
lower_bound = min(val1, val2)
upper_bound = max(val1, val2)
nn_instance = NN(input_dim=5,
layers=[10, 10, 3],
y_range=(lower_bound, upper_bound))
random_data = torch.randn(15, 5)
out = nn_instance.forward(random_data)
assert torch.sum(
out > lower_bound).item() == 3 * 15, "lower {} vs. {} ".format(
lower_bound, out)
assert torch.sum(
out < upper_bound).item() == 3 * 15, "upper {} vs. {} ".format(
upper_bound, out)
def test_check_input_data_into_forward_once():
"""Tests that check_input_data_into_forward_once method only runs once"""
data_to_throw_error = torch.randn(N, 2)
X = torch.randn(N, 2) * 5.0 + 20.0
y = (X[:, 0] >= 20) * (X[:, 1] <= 20)
X = X.long()
nn_instance = NN(input_dim=2,
layers=[5, 1],
columns_of_data_to_be_embedded=[0, 1],
embedding_dimensions=[[50, 3], [55, 3]])
with pytest.raises(AssertionError):
nn_instance.forward(data_to_throw_error)
with pytest.raises(RuntimeError):
nn_instance.forward(X)
nn_instance.forward(data_to_throw_error)
