示例#1
0
    def test_grad_on_X(self):
        self.layer.forward(self.X)
        d_X = self.layer.backward(self.grad_top)

        assert_array_almost_equal(
            numerical_grad(self.layer.forward, self.X),
            d_X
        )
示例#2
0
    def test_backward(self):
        self.layer.forward(self.X, self.y)
        d_X = self.layer.backward()

        layer = self.layer

        def forward_as_func_of_X(X):
            return layer.forward(X, self.y)

        assert_array_almost_equal(numerical_grad(forward_as_func_of_X, self.X),
                                  d_X)
示例#3
0
    def test_grad_on_b(self):
        self.layer.forward(self.X)
        self.layer.backward(self.grad_top)
        d_b = self.layer.d_b

        layer = self.layer

        def forward_as_func_of_b(b_):
            layer.b = b_
            return layer.forward(self.X)

        assert_array_almost_equal(
            numerical_grad(forward_as_func_of_b, self.b),
            d_b
        )
示例#4
0
    def test_grad_on_W(self):
        self.layer.forward(self.X)
        self.layer.backward(self.grad_top)
        d_W = self.layer.d_W

        layer = self.layer

        def forward_as_func_of_W(W_):
            layer.W = W_
            return layer.forward(self.X)

        assert_array_almost_equal(
            numerical_grad(forward_as_func_of_W, self.W),
            d_W
        )
示例#5
0
    def test_numerical_grad_ndarray(self):
        X = np.array([
            [-5, 1, -1, 10, -2],
            [8, 10, -12, 3, 1],
            [0, 0, 2, -1, 5]], dtype=float)

        def dot_Y(X_):
            return np.dot(X_, self.Y)

        expected_grad_X = np.array([
            [6, -5, 8, 11, 11],
            [6, -5, 8, 11, 11],
            [6, -5, 8, 11, 11]], dtype=float)

        assert_array_almost_equal(
            numerical_grad(dot_Y, X),
            expected_grad_X
        )
示例#6
0
    def test_numerical_grad_scalar(self):

        def times_5(x_):
            return x_ * 5

        self.assertAlmostEqual(numerical_grad(times_5, 12), 5)