def test_backprop(input_units, hidden_units, rgen):
nn = FcClassifier(input_units, hidden_units)
nn.init_random()
parameters = nn.get_weights()
weights = list(w for w, _ in parameters)
biases = list(b for _, b in parameters)
x_in = rgen.randn(input_units, 1)
cost, grads = nn.back_propagate(x_in, 1.0)
grad_w = [w for w, _ in grads]
grad_b = [b for _, b in grads]
y_hat = lambda weights: fcnn_predict(x_in, weights, biases,
it.repeat(sigmoid))
costf = lambda weights: cross_entropy(1.0, y_hat(weights))
grad_costf_ref = grad(costf)(weights)
for w, w_ref in zip(grad_w, grad_costf_ref):
assert_array_almost_equal(w, w_ref)
y_hat = lambda biases: fcnn_predict(x_in, weights, biases,
it.repeat(sigmoid))
costf = lambda biases: cross_entropy(1, y_hat(biases))
grad_costf_ref = grad(costf)(biases)
for b, b_ref in zip(grad_b, grad_costf_ref):
assert_array_almost_equal(b, b_ref)
assert_almost_equal(cost, costf(biases))
def test_random_initialization(input_units, hidden_units):
nn = FcClassifier(input_units, hidden_units)
weights = nn.get_weights()
for w, b in weights:
assert_almost_equal(np.linalg.norm(w), 0)
assert_almost_equal(np.linalg.norm(b), 0)
nn.init_random()
weights = nn.get_weights()
for w, b in weights:
assert np.linalg.norm(w) > .5
def test_predict(input_units, hidden_units, nr_samples, rgen):
nn = FcClassifier(input_units, hidden_units)
nn.init_random()
parameters = nn.get_weights()
weights = list(rgen.randn(*w.shape) for w, _ in parameters)
biases = list(np.zeros(b.shape) for _, b in parameters)
for n, (w, b) in enumerate(zip(weights, biases)):
nn.set_weights(n, w, b)
x_in = rgen.randn(input_units, nr_samples)
y_ref = fcnn_predict(x_in, weights, biases, it.repeat(sigmoid))[0, :]
y_hat = nn.predict(x_in)
assert_almost_equal(y_hat, y_ref)
def test_train(input_units, hidden_units, batch_size, nr_samples, rgen):
nn = FcClassifier(input_units, hidden_units)
nn.init_random()
x_in = rgen.randn(nr_samples, input_units)
y_in = rgen.randint(2, size=nr_samples)
cost_old = nn.evaluate(x_in.T, y_in)
nn.train(x_in,
y_in,
learning_rate=0.0005,
nr_epochs=1,
batch_size=batch_size)
cost_new = nn.evaluate(x_in.T, y_in)
assert cost_old > cost_new
def test_evaluate(input_units, hidden_units, nr_samples, rgen):
nn = FcClassifier(input_units, hidden_units)
nn.init_random()
parameters = nn.get_weights()
weights = list(w for w, _ in parameters)
biases = list(b for _, b in parameters)
x_in = rgen.randn(input_units, nr_samples)
y_in = rgen.randint(2, size=nr_samples)
cost = nn.evaluate(x_in, y_in)
y_ref = fcnn_predict(x_in, weights, biases, it.repeat(sigmoid))
cost_ref = cross_entropy(y_in, y_ref)
assert_almost_equal(cost, cost_ref)