pytorch

1

2

3

4

5

6
from caffe2.python import workspace, core
7
import caffe2.python.hypothesis_test_util as hu
8
import caffe2.python.serialized_test.serialized_test_util as serial
9
from hypothesis import given, settings
10
import hypothesis.strategies as st
11
import numpy as np
12

13

14
class TestNegateGradient(serial.SerializedTestCase):
15

16
    @given(X=hu.tensor(), inplace=st.booleans(), **hu.gcs)
17
    @settings(deadline=10000)
18
    def test_forward(self, X, inplace, gc, dc):
19
        def neg_grad_ref(X):
20
            return (X,)
21

22
        op = core.CreateOperator("NegateGradient", ["X"], ["Y" if not inplace else "X"])
23
        self.assertReferenceChecks(gc, op, [X], neg_grad_ref)
24
        self.assertDeviceChecks(dc, op, [X], [0])
25

26
    @given(size=st.lists(st.integers(min_value=1, max_value=20),
27
                         min_size=1, max_size=5))
28
    def test_grad(self, size):
29
        X = np.random.random_sample(size)
30
        workspace.ResetWorkspace()
31
        workspace.FeedBlob("X", X.astype(np.float32))
32

33
        net = core.Net("negate_grad_test")
34
        Y = net.NegateGradient(["X"], ["Y"])
35

36
        grad_map = net.AddGradientOperators([Y])
37
        workspace.RunNetOnce(net)
38

39
        # check X_grad == negate of Y_grad
40
        x_val, y_val = workspace.FetchBlobs(['X', 'Y'])
41
        x_grad_val, y_grad_val = workspace.FetchBlobs([grad_map['X'],
42
                                                        grad_map['Y']])
43
        np.testing.assert_array_equal(x_val, y_val)
44
        np.testing.assert_array_equal(x_grad_val, y_grad_val * (-1))
45