def test_batch_norm_layers():
"""Tests whether batch_norm_layers method works correctly"""
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4, 2],
["adaptivemaxpool", 3, 34], ["linear", 5]]
cnn = CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=False)
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4, 2],
["adaptivemaxpool", 3, 34], ["linear", 5]]
cnn = CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=True)
assert len(cnn.batch_norm_layers) == 1
assert cnn.batch_norm_layers[0].num_features == 2
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4,
2], ["conv", 12, 4, 3, 2],
["adaptivemaxpool", 3, 34], ["linear", 22], ["linear", 55]]
cnn = CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=True)
assert len(cnn.batch_norm_layers) == 3
assert cnn.batch_norm_layers[0].num_features == 2
assert cnn.batch_norm_layers[1].num_features == 12
assert cnn.batch_norm_layers[2].num_features == 22
def test_linear_layers_only_come_at_end():
"""Tests that it throws an error if user tries to provide list of hidden layers that include linear layers where they
don't only come at the end"""
layers = [["conv", 2, 4, 3, 2], ["linear", 55], ["maxpool", 3, 4, 2],
["adaptivemaxpool", 3, 34]]
with pytest.raises(AssertionError):
cnn = CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=True)
layers = [["conv", 2, 4, 3, 2], ["linear", 55]]
assert CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=True)
layers = [["conv", 2, 4, 3, 2], ["linear", 55], ["linear", 55],
["linear", 55]]
assert CNN(layers_info=layers,
hidden_activations="relu",
input_dim=(2, 10, 10),
output_activation="relu",
initialiser="xavier",
batch_norm=True)
def test_output_dim_user_input():
"""Tests whether network rejects an invalid output_dim input from user"""
inputs_that_should_fail = [-1, "aa", ["dd"], [2], 0, 2.5, {2}]
for input_value in inputs_that_should_fail:
with pytest.raises(AssertionError):
CNN(input_dim=(2, 10, 10), layers_info=[2, input_value], hidden_activations="relu", output_activation="relu")
with pytest.raises(AssertionError):
CNN(input_dim=(2, 10, 10), layers_info=input_value, hidden_activations="relu", output_activation="relu")
def test_activations_user_input():
"""Tests whether network rejects an invalid hidden_activations or output_activation from user"""
inputs_that_should_fail = [-1, "aa", ["dd"], [2], 0, 2.5, {2}, "Xavier_"]
for input_value in inputs_that_should_fail:
with pytest.raises(AssertionError):
CNN(input_dim=(2, 10, 10), layers_info=[["conv", 2, 2, 3331, 2]], hidden_activations=input_value,
output_activation="relu")
CNN(input_dim=(2, 10, 10), layers_info=[["conv", 2, 2, 3331, 2]], hidden_activations="relu",
output_activation=input_value)
def test_all_initialisers_work():
"""Tests that all initialisers get accepted"""
nn_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
dropout=0.0000001,
initialiser="xavier", input_dim=(1, 5, 5))
for key in nn_instance.str_to_initialiser_converter.keys():
model = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
dropout=0.0000001,
initialiser=key, input_dim=(1, 5, 5))
model(X)
def test_all_activations_work():
"""Tests that all activations get accepted"""
nn_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
dropout=0.0000001,
initialiser="xavier", input_dim=(1, 5, 5))
for key in nn_instance.str_to_activations_converter.keys():
if key == "none": hidden_key = "relu"
else: hidden_key = key
model = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
hidden_activations=hidden_key, output_activation=key, dropout=0.0000001,
initialiser="xavier", input_dim=(1, 5, 5))
model(X)
def test_dropout():
"""Tests whether dropout layer reads in probability correctly"""
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
hidden_activations="relu", output_activation="sigmoid", dropout=0.9999,
initialiser="xavier", input_dim=(1, 5, 5))
assert CNN_instance.dropout_layer.p == 0.9999
assert not solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
hidden_activations="relu", output_activation=None, dropout=0.0000001,
initialiser="xavier", input_dim=(1, 5, 5))
assert CNN_instance.dropout_layer.p == 0.0000001
assert solves_simple_problem(X, y, CNN_instance)
def test_model_trains_linear_layer():
"""Tests whether a small range of networks can solve a simple task"""
CNN_instance = CNN(layers_info=[["conv", 5, 3, 1, 0], ["linear", 5], ["linear", 5], ["linear", 1]],
input_dim=(1, 5, 5),
hidden_activations="relu", output_activation="sigmoid",
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["linear", 5], ["linear", 5], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation="sigmoid",
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
def test_linear_layers_acceptance():
"""Tests that only accepts linear layers of correct shape"""
layers_that_shouldnt_work = [[["linear", 2, 5]], [["linear", 2, 5, 5]], [["linear"]], [["linear", 2], ["linear", 5, 4]],
["linear", 0], ["linear", -5]]
for layers in layers_that_shouldnt_work:
with pytest.raises(AssertionError):
cnn = CNN(layers_info=layers, hidden_activations="relu", input_dim=(2, 10, 10),
output_activation="relu", initialiser="xavier", batch_norm=True)
layers_that_should_work = [[["linear", 44], ["linear", 2]], [["linear", 22]]]
for layer in layers_that_should_work:
assert CNN(layers_info=layer, hidden_activations="relu", input_dim=(2, 10, 10),
output_activation="relu", initialiser="xavier", batch_norm=True)
def test_output_layers_created_correctly():
"""Tests that create_output_layers works correctly"""
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4, 2],
["avgpool", 32, 42, 22], ["adaptivemaxpool", 3, 34],
["adaptiveavgpool", 23, 44], ["linear", 22], ["linear", 2222],
["linear", 2]]
cnn = CNN(input_dim=(3, 10, 10),
layers_info=layers,
hidden_activations="relu",
output_activation="relu")
assert cnn.output_layers[0].in_features == 2222
assert cnn.output_layers[0].out_features == 2
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4, 2],
["avgpool", 32, 42, 22], ["adaptivemaxpool", 3, 34],
["adaptiveavgpool", 23, 44], ["linear", 7]]
cnn = CNN(input_dim=(3, 10, 10),
layers_info=layers,
hidden_activations="relu",
output_activation="relu")
assert cnn.output_layers[0].in_features == 23 * 44 * 2
assert cnn.output_layers[0].out_features == 7
layers = [["conv", 5, 4, 3, 2], ["maxpool", 3, 4, 2],
["avgpool", 32, 42, 22], ["adaptivemaxpool", 3, 34],
["linear", 6]]
cnn = CNN(input_dim=(3, 10, 10),
layers_info=layers,
hidden_activations="relu",
output_activation="relu")
assert cnn.output_layers[0].in_features == 3 * 34 * 5
assert cnn.output_layers[0].out_features == 6
layers = [["conv", 5, 4, 3, 2], ["maxpool", 3, 4, 2],
["avgpool", 32, 42, 22], ["adaptivemaxpool", 3, 34],
[["linear", 6], ["linear", 22]]]
cnn = CNN(input_dim=(3, 1000, 1000),
layers_info=layers,
hidden_activations="relu",
output_activation=["softmax", None])
assert cnn.output_layers[0].in_features == 3 * 34 * 5
assert cnn.output_layers[0].out_features == 6
assert cnn.output_layers[1].in_features == 3 * 34 * 5
assert cnn.output_layers[1].out_features == 22
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)
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2], ["adaptivemaxpool", 2, 2], ["linear", 5]],
hidden_activations="relu", y_range=(lower_bound, upper_bound),
initialiser="xavier", input_dim=(1, 20, 20))
random_data = torch.randn((10, 1, 20, 20))
out = CNN_instance.forward(random_data)
assert torch.sum(out > lower_bound).item() == 10*5, "lower {} vs. {} ".format(lower_bound, out)
assert torch.sum(out < upper_bound).item() == 10*5, "upper {} vs. {} ".format(upper_bound, out)
def test_output_heads_error_catching():
"""Tests that having multiple output heads catches errors from user inputs"""
output_dims_that_should_break = [["linear", 2, 2, "SAME", "conv", 3, 4, "SAME"], [[["conv", 3, 2, "same"], ["linear", 4]]],
[[2, 8]], [-33, 33, 33, 33, 33]]
for output_dim in output_dims_that_should_break:
with pytest.raises(AssertionError):
CNN(input_dim=(12, 12, 3), layers_info=[["conv", 25, 5, 1, "valid"], ["conv", 25, 5, 1, "valid"], ["linear", 1], output_dim],
hidden_activations="relu", output_activation="relu")
output_activations_that_should_break = ["relu", ["relu"], ["relu", "softmax"]]
for output_activation in output_activations_that_should_break:
with pytest.raises(AssertionError):
CNN(input_dim=(12, 12, 3), layers_info=[["conv", 25, 5, 1, "valid"], ["conv", 25, 5, 1, "valid"], ["linear", 1],
[["linear", 4], ["linear", 10], ["linear", 4]]],
hidden_activations="relu", output_activation=output_activation)
def test_MNIST_progress():
"""Tests that network made using CNN module can make progress on MNIST"""
batch_size = 128
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
root="input/",
train=True,
download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ), (0.3081, ))
])),
batch_size=batch_size,
shuffle=True)
cnn = CNN(layers_info=[["conv", 20, 5, 1, 0], ["maxpool", 2, 2, 0],
["conv", 50, 5, 1, 0], ["maxpool", 2, 2, 0],
["linear", 500], ["linear", 10]],
hidden_activations="relu",
output_activation="softmax",
initialiser="xavier",
input_dim=(1, 28, 28))
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(cnn.parameters(), lr=0.001)
ix = 0
accuracies = []
for data, target in train_loader:
ix += 1
output = cnn(data)
loss = loss_fn(output, target)
optimizer.zero_grad()
loss.backward()
optimizer.step()
pred = output.argmax(
dim=1, keepdim=True) # get the index of the max log-probability
correct = pred.eq(target.view_as(pred)).sum().item()
print("Accuracy {}".format(correct / batch_size))
accuracies.append(correct / batch_size)
if ix > 200:
break
shutil.rmtree("input/", ignore_errors=False, onerror=None)
assert accuracies[-1] > 0.7, "Accuracy not good enough {}".format(
accuracies[-1])
def test_user_hidden_layers_input_acceptances():
"""Tests whether network rejects invalid hidden_layers inputted from user"""
inputs_that_should_work = [[["conv", 2, 2, 3331, 2]],
[["CONV", 2, 2, 3331, 22]],
[["ConV", 2, 2, 3331, 1]],
[["maxpool", 2, 2, 3331]],
[["MAXPOOL", 2, 2, 3331]],
[["MaXpOOL", 2, 2, 3331]],
[["avgpool", 2, 2, 3331]],
[["AVGPOOL", 2, 2, 3331]],
[["avGpOOL", 2, 2, 3331]],
[["adaptiveavgpool", 3, 22]],
[["ADAPTIVEAVGpOOL", 1, 33]],
[["ADAPTIVEaVGPOOL", 3, 6]],
[["adaptivemaxpool", 4, 66]],
[["ADAPTIVEMAXpOOL", 2, 2]],
[["ADAPTIVEmaXPOOL", 3, 3]],
[["adaptivemaxpool", 3, 3]],
[["ADAPTIVEMAXpOOL", 3, 1]], [["linear", 40]],
[["lineaR", 2]], [["LINEAR", 2]]]
for ix, input in enumerate(inputs_that_should_work):
input.append(["linear", 5])
CNN(input_dim=(1, 1, 1),
layers_info=input,
hidden_activations="relu",
output_activation="relu")
def test_user_hidden_layers_input_rejections():
"""Tests whether network rejects invalid hidden_layers inputted from user"""
inputs_that_should_fail = [['maxpool', 33, 22, 33], [['a']],
[[222, 222, 222, 222]], [["conv", 2, 2, -1]],
[["conv", 2, 2]], [["conv", 2, 2, 55, 999, 33]],
[["maxpool", 33, 33]], [["maxpool", -1, 33]],
[["maxpool", 33]], [["maxpoolX", 1, 33]],
[["cosnv", 2,
2]], [["avgpool", 33, 33, 333, 99]],
[["avgpool", -1, 33]], [["avgpool", 33]],
[["avgpoolX", 1, 33]],
[["adaptivemaxpool", 33, 33, 333, 33]],
[["adaptivemaxpool", 2]],
[["adaptivemaxpool",
33]], [["adaptivemaxpoolX"]],
[["adaptiveavgpool", 33, 33, 333, 11]],
[["adaptiveavgpool", 2]],
[["adaptiveavgpool", 33]],
[["adaptiveavgpoolX"]], [["linear", 40, -2]],
[["lineafr", 40, 2]]]
for input in inputs_that_should_fail:
print(input)
with pytest.raises(AssertionError):
CNN(input_dim=1,
layers_info=input,
hidden_activations="relu",
output_activation="relu")
def test_deals_with_None_activation():
"""Tests whether is able to handle user inputting None as output activation"""
assert CNN(layers_info=[["conv", 2, 2, 1, 2], ["adaptivemaxpool", 2, 2],
["linear", 5]],
hidden_activations="relu",
output_activation=None,
initialiser="xavier",
input_dim=(5, 5, 5))
def test_y_range_user_input():
"""Tests whether network rejects invalid y_range inputs"""
invalid_y_range_inputs = [ (4, 1), (2, 4, 8), [2, 4], (np.array(2.0), 6.9)]
for y_range_value in invalid_y_range_inputs:
with pytest.raises(AssertionError):
print(y_range_value)
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2], ["adaptivemaxpool", 2, 2]],
hidden_activations="relu", y_range=y_range_value, input_dim=(2, 2, 2),
initialiser="xavier")
def test_output_head_layers():
"""Tests whether the output head layers get created properly"""
for output_dim in [[["linear", 3],["linear", 9]], [["linear", 4], ["linear", 20]], [["linear", 1], ["linear", 1]]]:
nn_instance = CNN(input_dim=(12, 12, 3), layers_info=[["conv", 25, 5, 1, 2], ["conv", 25, 5, 1, 3], ["linear", 5], output_dim],
hidden_activations="relu", output_activation=["softmax", None])
assert nn_instance.output_layers[0].out_features == output_dim[0][1]
assert nn_instance.output_layers[0].in_features == 5
assert nn_instance.output_layers[1].out_features == output_dim[1][1]
assert nn_instance.output_layers[1].in_features == 5
def test_max_pool_working():
"""Tests whether max pool layers work properly"""
N = 250
X = torch.randn((N, 1, 8, 8))
X[0:125, 0, 3, 3] = 999.99
CNN_instance = CNN(layers_info=[["maxpool", 2, 2, 0], ["maxpool", 2, 2, 0], ["maxpool", 2, 2, 0], ["linear", 1]],
hidden_activations="relu", input_dim=(1, 8, 8),
initialiser="xavier")
assert CNN_instance(X).shape == (N, 1)
def test_output_head_shapes_correct():
"""Tests that the output shape of network is correct when using multiple outpout heads"""
N = 20
X = torch.randn((N, 25, 25, 2))
for _ in range(25):
nn_instance = CNN(input_dim=(25, 25, 2),
layers_info=[["conv", 25, 2, 1, 1], ["conv", 2, 5, 1, 1], ["linear", 1], ["linear", 12]],
hidden_activations="relu")
out = nn_instance(X)
assert out.shape[0] == N
assert out.shape[1] == 12
for output_dim in [[ ["linear", 10], ["linear", 4], ["linear", 6]], [["linear", 3], ["linear", 8], ["linear", 9]]]:
nn_instance = CNN(input_dim=(25, 25, 2),
layers_info=[["conv", 25, 1, 1, 2], ["conv", 25, 5, 1, 1], ["linear", 1], output_dim],
hidden_activations="relu", output_activation=["softmax", None, "relu"])
out = nn_instance(X)
assert out.shape[0] == N
assert out.shape[1] == 20
def test_check_input_data_into_forward_once():
"""Tests that check_input_data_into_forward_once method only runs once"""
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2], ["adaptivemaxpool", 2, 2], ["linear", 6]],
hidden_activations="relu", input_dim=(4, 2, 5),
output_activation="relu", initialiser="xavier")
data_not_to_throw_error = torch.randn((1, 4, 2, 5))
data_to_throw_error = torch.randn((1, 2, 20, 20))
with pytest.raises(AssertionError):
CNN_instance.forward(data_to_throw_error)
with pytest.raises(RuntimeError):
CNN_instance.forward(data_not_to_throw_error)
CNN_instance.forward(data_to_throw_error)
def test_model_trains():
"""Tests whether a small range of networks can solve a simple task"""
for output_activation in ["sigmoid", "None"]:
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=output_activation,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
z = X[:, 0:1, 3:4, 3:4] > 5.0
z = torch.cat([z ==1, z==0], dim=1).float()
z = z.squeeze(-1).squeeze(-1)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["linear", 2]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation="softmax", dropout=0.01,
initialiser="xavier")
assert solves_simple_problem(X, z, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier", batch_norm=True)
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["maxpool", 1, 1, 0], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["avgpool", 1, 1, 0], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 5, 3, 1, 0], ["adaptivemaxpool", 2, 2], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
CNN_instance = CNN(layers_info=[["conv", 5, 3, 1, 0], ["adaptiveavgpool", 2, 2], ["linear", 1]], input_dim=(1, 5, 5),
hidden_activations="relu", output_activation=None,
initialiser="xavier")
assert solves_simple_problem(X, y, CNN_instance)
def test_hidden_layers_created_correctly():
"""Tests that create_hidden_layers works correctly"""
layers = [["conv", 2, 4, 3, 2], ["maxpool", 3, 4, 2],
["avgpool", 32, 42, 22], ["adaptivemaxpool", 3, 34],
["adaptiveavgpool", 23, 44], ["linear", 22], ["linear", 2222],
["linear", 5]]
cnn = CNN(input_dim=(3, 10, 10),
layers_info=layers,
hidden_activations="relu",
output_activation="relu")
assert type(cnn.hidden_layers[0]) == nn.Conv2d
assert cnn.hidden_layers[0].in_channels == 3
assert cnn.hidden_layers[0].out_channels == 2
assert cnn.hidden_layers[0].kernel_size == (4, 4)
assert cnn.hidden_layers[0].stride == (3, 3)
assert cnn.hidden_layers[0].padding == (2, 2)
assert type(cnn.hidden_layers[1]) == nn.MaxPool2d
assert cnn.hidden_layers[1].kernel_size == 3
assert cnn.hidden_layers[1].stride == 4
assert cnn.hidden_layers[1].padding == 2
assert type(cnn.hidden_layers[2]) == nn.AvgPool2d
assert cnn.hidden_layers[2].kernel_size == 32
assert cnn.hidden_layers[2].stride == 42
assert cnn.hidden_layers[2].padding == 22
assert type(cnn.hidden_layers[3]) == nn.AdaptiveMaxPool2d
assert cnn.hidden_layers[3].output_size == (3, 34)
assert type(cnn.hidden_layers[4]) == nn.AdaptiveAvgPool2d
assert cnn.hidden_layers[4].output_size == (23, 44)
assert type(cnn.hidden_layers[5]) == nn.Linear
assert cnn.hidden_layers[5].in_features == 2024
assert cnn.hidden_layers[5].out_features == 22
assert type(cnn.hidden_layers[6]) == nn.Linear
assert cnn.hidden_layers[6].in_features == 22
assert cnn.hidden_layers[6].out_features == 2222
assert type(cnn.output_layers[0]) == nn.Linear
assert cnn.output_layers[0].in_features == 2222
assert cnn.output_layers[0].out_features == 5
def test_output_head_activations_work():
"""Tests that output head activations work properly"""
output_dim = [["linear", 5], ["linear", 10], ["linear", 3]]
nn_instance = CNN(input_dim=(12, 12, 3), layers_info=[["conv", 3, 2, 1, 1], ["conv", 3, 1, 1, 1], ["linear", 1], output_dim],
hidden_activations="relu", output_activation=["softmax", None, "relu"])
x = torch.randn((20, 12, 12, 3)) * -20.0
out = nn_instance(x)
assert out.shape == (20, 18)
sums = torch.sum(out[:, :5], dim=1).detach().numpy()
sums_others = torch.sum(out[:, 5:], dim=1).detach().numpy()
sums_others_2 = torch.sum(out[:, 5:15], dim=1).detach().numpy()
sums_others_3 = torch.sum(out[:, 15:18], dim=1).detach().numpy()
for row in range(out.shape[0]):
assert np.round(sums[row], 4) == 1.0, sums[row]
assert not np.round(sums_others[row], 4) == 1.0, sums_others[row]
assert not np.round(sums_others_2[row], 4) == 1.0, sums_others_2[row]
assert not np.round(sums_others_3[row], 4) == 1.0, sums_others_3[row]
for col in range(3):
assert out[row, 15 + col] >= 0.0, out[row, 15 + col]
def test_output_activation():
"""Tests whether network outputs data that has gone through correct activation function"""
RANDOM_ITERATIONS = 20
input_dim = (5, 100, 100)
for _ in range(RANDOM_ITERATIONS):
data = torch.randn((1, *input_dim))
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2],
["adaptivemaxpool", 2, 2],
["linear", 50]],
hidden_activations="relu",
input_dim=input_dim,
output_activation="relu",
initialiser="xavier")
out = CNN_instance.forward(data)
assert all(out.squeeze() >= 0)
CNN_instance = CNN(layers_info=[["conv", 2, 20, 1, 0], ["linear", 5]],
hidden_activations="relu",
input_dim=input_dim,
output_activation="relu",
initialiser="xavier")
out = CNN_instance.forward(data)
assert all(out.squeeze() >= 0)
CNN_instance = CNN(layers_info=[["conv", 5, 20, 1, 0], ["linear", 5]],
hidden_activations="relu",
input_dim=input_dim,
output_activation="relu",
initialiser="xavier")
out = CNN_instance.forward(data)
assert all(out.squeeze() >= 0)
CNN_instance = CNN(layers_info=[["conv", 5, 20, 1, 0], ["linear", 22]],
hidden_activations="relu",
input_dim=input_dim,
output_activation="sigmoid",
initialiser="xavier")
out = CNN_instance.forward(data)
assert all(out.squeeze() >= 0)
assert all(out.squeeze() <= 1)
assert round(torch.sum(out.squeeze()).item(), 3) != 1.0
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2],
["adaptivemaxpool", 2, 2],
["linear", 5]],
hidden_activations="relu",
input_dim=input_dim,
output_activation="softmax",
initialiser="xavier")
out = CNN_instance.forward(data)
assert all(out.squeeze() >= 0)
assert all(out.squeeze() <= 1)
assert round(torch.sum(out.squeeze()).item(), 3) == 1.0
CNN_instance = CNN(layers_info=[["conv", 2, 2, 1, 2],
["adaptivemaxpool", 2, 2],
["linear", 5]],
hidden_activations="relu",
input_dim=input_dim,
initialiser="xavier")
out = CNN_instance.forward(data)
assert not all(out.squeeze() >= 0)
assert not round(torch.sum(out.squeeze()).item(), 3) == 1.0
def test_print_model_summary():
nn_instance = CNN(layers_info=[["conv", 25, 5, 1, 0], ["adaptivemaxpool", 1, 1], ["linear", 1]],
dropout=0.0000001,
initialiser="xavier", input_dim=(1, 5, 5))
nn_instance.print_model_summary()
