def should_be_return_specific_array():
expected = np.asarray([[1., 2., 3.], [4., 5., 6.]])
initializer = ConstShapeInitializer(expected)
try:
equals(expected, initializer((2, 3)))
except ValueError:
ok()
def should_success_calculate_for_multiple_neurons():
network = MultipleLayersModel([
Layer(input_dimension=1,
output_dimension=3,
activation_function=LinearFunction(),
weights_initializer=ConstShapeInitializer(
np.asarray([[1., 2., 3.]])),
biases_initializer=ConstShapeInitializer(np.asarray([1., 2.,
3.]))),
Layer(input_dimension=3,
output_dimension=1,
activation_function=LinearFunction(2.),
weights_initializer=ConstShapeInitializer(
np.asarray([[1.], [2.], [3.]])),
biases_initializer=ConstShapeInitializer(np.asarray([1.])))
])
X = np.asarray([[0.], [1.]])
Y = np.asarray([[0.], [2.]])
gradient = ApproximateGradient()
square_error = SquareError()
network_gradient = gradient(network, X, Y, square_error)
expected = np.asarray([[
np.asarray([[224.00000444, 448.0000166, 672.00003605]]),
np.asarray([344.00000857, 688.0000326, 1032.00007197])
],
[
np.asarray([[568.00002073], [1136.00008012],
[1704.00017987]]),
np.asarray([344.00000834])
]])
equals(expected, network_gradient)
def should_raise_value_error_for_negative_derivative_count():
square_error = SquareError()
try:
equals(2., square_error(10., 20., -3))
fail(
'Should be raise value error because derivative count is negative')
except ValueError:
ok()
def success_get_all_values():
values = [
np.asarray([1., 2., 3.]),
np.asarray([4., 5., 6.]),
np.asarray([7., 8., 9.])
]
store = Store(values)
equals(values, store.values)
def success_get_batch_more_than_values_count():
values = [
np.asarray([1., 2., 3.]),
np.asarray([4., 5., 6.]),
np.asarray([7., 8., 9.])
]
store = Store(values, 2019)
next_values = store.next(4)
expected = np.asarray([values[1], values[2], values[0], values[2]])
equals(expected, next_values)
def success_get_next_two_values():
values = [
np.asarray([1., 2., 3.]),
np.asarray([4., 5., 6.]),
np.asarray([7., 8., 9.])
]
store = Store(values, 2019)
next_values = store.next(2)
equals(values[1:], next_values)
next_values = store.next(1)
equals(values[:1], next_values)
def should_be_success_calculate_output():
layer = Layer(
input_dimension=2,
output_dimension=3,
activation_function=LinearFunction(),
weights_initializer=ConstShapeInitializer(
np.asarray([
[1., 2., 3.],
[1., 2., 3.]
])
),
biases_initializer=ConstShapeInitializer(
np.asarray(
[1., 2., 3.]
)
)
)
expected = np.asarray(
[4., 8, 12.]
)
equals(expected, layer([1, 2]))
def should_success_calculate_for_multiple_examples():
network = MultipleLayersModel([
Layer(input_dimension=1,
output_dimension=1,
activation_function=LinearFunction(),
weights_initializer=ConstShapeInitializer(np.asarray([[1.]])),
biases_initializer=ConstShapeInitializer(np.asarray([2.]))),
Layer(input_dimension=1,
output_dimension=1,
activation_function=LinearFunction(2.),
weights_initializer=ConstShapeInitializer(np.asarray([[3.]])),
biases_initializer=ConstShapeInitializer(np.asarray([0.])))
])
X = np.asarray([[0.], [1.]])
Y = np.asarray([[0.], [2.]])
gradient = ApproximateGradient()
square_error = SquareError()
network_gradient = gradient(network, X, Y, square_error)
expected = np.asarray(
[[np.asarray([[192.0000359518781]]),
np.asarray([336.0000719681011])],
[np.asarray([[288.0000519667192]]),
np.asarray([112.00000793110121])]])
equals(expected, network_gradient)
def should_be_return_default_array():
initializer = ConstShapeInitializer()
expected = [0.]
equals(expected, initializer(1))
def should_success_calculate_third_derivative():
square_error = SquareError()
equals(0., square_error(10., 20., 3))
def test_const_initializer():
initializer = ConstInitializer(12.)
expected = [12., 12., 12.]
equals(expected, initializer(3))
def test_2d_range_initializer():
initializer = RangeInitializer(-3., 3.)
expected = [[-3.], [-2.], [-1.], [0.], [1.], [2.], [3.]]
equals(expected, initializer((7, 1)))
def should_success_calculate_error():
square_error = SquareError()
equals(100., square_error(10., 20.))
def should_calculate_single_input():
linear = LinearFunction()
equals(12., linear(12.))
def should_calculate_multiple_input():
linear = LinearFunction()
equals([12., 8.], linear(np.asarray([12., 8.])))
def overflow_sigmoid_test():
sigmoid = SigmoidFunction()
equals(1., sigmoid(1000.))
def sigmoid_test():
sigmoid = SigmoidFunction()
equals(0.5, sigmoid(0.))
def should_success_calculate_multiple_errors():
Y = np.asarray([0., 2.])
R = np.asarray([12., 18.])
E = np.asarray([144., 256.])
square_error = SquareError()
equals(E, square_error(Y, R))
def test_range_initializer():
initializer = RangeInitializer()
expected = [-1., 0., 1.]
equals(expected, initializer(3))
def should_success_calculate_first_derivative():
square_error = SquareError()
equals(20., square_error(10., 20., 1))
def test_uniform_initializer():
initializer = UniformInitializer(
seed=2019
)
expected = [0.80696443, -0.21383899, 0.24793992, 0.2757548]
equals(expected, initializer(4))
def should_success_calculate_second_derivative():
square_error = SquareError()
equals(2., square_error(10., 20., 2))
