pytorch

1
import numpy as np
2
import unittest
3

4
import caffe2.python.fakelowp.init_shared_libs  # noqa
5
from hypothesis import given, settings
6
from hypothesis import strategies as st
7
from caffe2.proto import caffe2_pb2
8
from caffe2.python import core
9
from caffe2.python import workspace
10
from caffe2.python.onnx.onnxifi import onnxifi_caffe2_net
11
from caffe2.python.fakelowp.test_utils import print_test_debug_info
12
import datetime
13
import caffe2.python.serialized_test.serialized_test_util as serial
14

15
core.GlobalInit(["caffe2", "--caffe2_log_level=-3", "--glow_global_fp16=1"])
16

17
GLOW_MATMUL_RTOL = 0
18

19

20
class FCTest(serial.SerializedTestCase):
21
    @given(seed=st.integers(0, 65534))
22
    @settings(deadline=datetime.timedelta(seconds=10))
23
    def test_clip(self, seed):
24
        np.random.seed(seed)
25
        m, n, k = 8, 8, 8
26
        dtype = np.float32
27
        pred_net = caffe2_pb2.NetDef()
28
        pred_net.name = "pred"
29
        pred_net.external_input.extend(["X", "W0", "b0", "W1", "b1"])
30
        pred_net.external_output.append("Y")
31
        pred_net.op.add().CopyFrom(
32
            core.CreateOperator(
33
                "FC",
34
                ["X", "W0", "b0"],
35
                ["X1"],
36
            )
37
        )
38
        pred_net.op.add().CopyFrom(
39
            core.CreateOperator(
40
                "FC",
41
                ["X1", "W1", "b1"],
42
                ["Y"],
43
            )
44
        )
45
        workspace.GlobalInit(
46
            ['caffe2', '--caffe2_log_level=0', '--glow_global_fp16=1',
47
             '--glow_clip_fp16', '--glow_global_fp16_constants=1'])
48
        workspace.SwitchWorkspace("glow_test_ws", True)
49
        workspace.ResetWorkspace()
50
        W0 = np.full((n, k), 65536.0, dtype)
51
        b0 = np.random.randint(low=1, high=3, size=(n)).astype(dtype)
52
        W1 = np.random.randint(low=1, high=3, size=(n, k)).astype(dtype)
53
        b1 = np.random.randint(low=1, high=3, size=(n)).astype(dtype)
54
        workspace.FeedBlob("W0", W0)
55
        workspace.FeedBlob("b0", b0)
56
        workspace.FeedBlob("W1", W1)
57
        workspace.FeedBlob("b1", b1)
58

59
        pred_net_onnxified = onnxifi_caffe2_net(
60
            pred_net,
61
            {"X": (m, k)},
62
            debug=True,
63
            adjust_batch=False,
64
            use_onnx=False
65
        )
66

67
        X = np.random.randint(low=1, high=3, size=(m, k)).astype(dtype)
68
        workspace.FeedBlob("X", X)
69
        workspace.CreateNet(pred_net_onnxified)
70

71
        workspace.RunNet(pred_net_onnxified.name)
72
        Y_glow = workspace.FetchBlob("Y")
73
        np.testing.assert_allclose(Y_glow, np.full((m, n), 65504.0, dtype))
74

75
    @given(
76
        m=st.integers(4, 50),
77
        k=st.integers(4, 50),
78
        n=st.integers(4, 50),
79
        seed=st.integers(0, 65534)
80
    )
81
    @settings(deadline=datetime.timedelta(seconds=10))
82
    def test_fc_exercise(self, m, k, n, seed):
83
        """ Test that the matmul engine is working, this doesn't test
84
            precision
85
        """
86
        np.random.seed(seed)
87
        dtype = np.float32
88
        pred_net = caffe2_pb2.NetDef()
89
        pred_net.name = "pred"
90
        pred_net.external_input.extend(["X", "W0", "b0"])
91
        pred_net.external_output.append("Y")
92
        pred_net.op.add().CopyFrom(
93
            core.CreateOperator(
94
                "FC",
95
                ["X", "W0", "b0"],
96
                ["Y"],
97
            )
98
        )
99

100
        workspace.SwitchWorkspace("glow_test_ws", True)
101
        workspace.ResetWorkspace()
102
        W0 = np.random.randint(low=1, high=3, size=(n, k)).astype(dtype)
103
        b0 = np.random.randint(low=1, high=3, size=(n)).astype(dtype)
104
        workspace.FeedBlob("W0", W0)
105
        workspace.FeedBlob("b0", b0)
106

107
        pred_net_onnxified = onnxifi_caffe2_net(pred_net,
108
                                                {"X": (m, k)},
109
                                                debug=True,
110
                                                adjust_batch=False,
111
                                                use_onnx=False)
112
        num_onnxified_ops = sum(
113
            1 if o.type == "Onnxifi" else 0 for o in pred_net_onnxified.op)
114
        np.testing.assert_equal(num_onnxified_ops, 1)
115

116
        X0 = np.random.randint(low=1, high=3, size=(m, k)).astype(dtype)
117
        workspace.FeedBlob("X", X0)
118
        workspace.CreateNet(pred_net_onnxified)
119
        workspace.CreateNet(pred_net)
120

121
        num_iterations = 2
122
        for _ in range(num_iterations):
123
            X0 = np.random.randint(low=1, high=3, size=(m, k)).astype(dtype)
124
            workspace.FeedBlob("X", X0)
125
            # Run Glow net
126
            workspace.RunNet(pred_net_onnxified.name)
127
            Y_glow = workspace.FetchBlob('Y')
128
            # Run caffe2 net
129
            workspace.RunNet(pred_net.name)
130
            Y_c2 = workspace.FetchBlob('Y')
131
            if not np.allclose(Y_c2, Y_glow):
132
                print_test_debug_info("fc", {
133
                    "seed": seed,
134
                    "m": m,
135
                    "k": k,
136
                    "n": n,
137
                    "X": X0,
138
                    "W0": W0,
139
                    "b0": b0,
140
                    "Y_glow": Y_glow,
141
                    "Y_c2": Y_c2,
142
                    "diff": np.abs((Y_c2 - Y_glow) / Y_c2)})
143
                assert(0)
144

145
    @given(seed=st.integers(0, 65534))
146
    @settings(deadline=datetime.timedelta(seconds=10))
147
    def test_fc_numeric_cases(self, seed):
148
        """ Test numerics, use examples found from the unit test.
149
            Use Fp16FCAcc16NNPI as a reference.
150
        """
151
        np.random.seed(seed)
152
        m = 1
153
        k = 20
154
        n = 1
155
        dtype = np.float32
156
        pred_net = caffe2_pb2.NetDef()
157
        pred_net.name = "pred"
158
        pred_net.external_input.extend(["X", "W0", "b0"])
159
        pred_net.external_output.append("Y")
160
        pred_net.op.add().CopyFrom(
161
            core.CreateOperator(
162
                "FC",
163
                ["X", "W0", "b0"],
164
                ["Y"],
165
            )
166
        )
167
        pred_net_ref = caffe2_pb2.NetDef()
168
        pred_net_ref.name = "pred"
169
        pred_net_ref.external_input.extend(["X", "W0", "b0"])
170
        pred_net_ref.external_output.append("Y")
171
        pred_net_ref.op.add().CopyFrom(
172
            core.CreateOperator(
173
                "Fp16FCAcc32NNPI",
174
                ["X", "W0", "b0"],
175
                ["Y"],
176
            )
177
        )
178

179
        workspace.SwitchWorkspace("glow_test_ws", True)
180
        workspace.ResetWorkspace()
181

182
        W0 = np.array([[0.04882812, 0.21520996, 0.1027832, 0.04489136,
183
                        -0.07635498, 0.14587402,
184
                        -0.06240845, 0.3918457, 0.46362305, -0.11657715,
185
                        0.29174805, 0.02890015,
186
                        0.0680542, 0.4255371, -0.42895508, -0.4128418,
187
                        -0.47973633, 0.33251953,
188
                        0.27807617, 0.3701172]], dtype=np.float32)
189
        b0 = np.array([0.47851562], dtype=np.float32)
190

191
        workspace.FeedBlob("W0", W0)
192
        workspace.FeedBlob("b0", b0)
193

194
        pred_net_onnxified = onnxifi_caffe2_net(pred_net,
195
                                                {"X": (m, k)},
196
                                                debug=True,
197
                                                adjust_batch=False,
198
                                                use_onnx=False)
199
        num_onnxified_ops = sum(
200
            1 if o.type == "Onnxifi" else 0 for o in pred_net_onnxified.op)
201
        np.testing.assert_equal(num_onnxified_ops, 1)
202

203
        X_inputs = [
204
            np.array([[
205
                -2.94921875e-01, -3.58642578e-01, -1.92871094e-01,
206
                2.81250000e-01, -1.30126953e-01, 2.32696533e-02,
207
                -4.55566406e-01, -2.31811523e-01, -1.95190430e-01,
208
                -7.76977539e-02, -1.29394531e-01, 2.94677734e-01,
209
                8.96453857e-04, 4.97314453e-01, -6.07604980e-02,
210
                2.55371094e-01, 3.49853516e-01, -1.37695312e-01,
211
                2.95410156e-01, -3.67187500e-01]], dtype=np.float32),
212
            np.array([[
213
                -0.4494629, -0.22192383, -0.1640625, 0.11480713,
214
                -0.09851074, -0.02084351,
215
                0.19091797, -0.17468262, -0.47485352, 0.07489014,
216
                0.03897095, 0.00197601,
217
                0.02835083, -0.27294922, 0.26757812, -0.20996094,
218
                -0.31103516, -0.41601562,
219
                0.09918213, -0.07696533]], dtype=np.float32),
220
            np.array([[
221
                0.01150513, -0.20507812, 0.46704102, 0.00906372,
222
                0.19848633, 0.3720703,
223
                0.46557617, -0.47436523, -0.35107422, -0.0362854,
224
                -0.20812988, 0.41918945,
225
                0.09716797, 0.19897461, 0.3876953, -0.0165863,
226
                0.23535156, 0.29956055,
227
                0.24389648, -0.23486328]], dtype=np.float32)
228
        ]
229

230
        # keep onnxifi happy by feeding something with a shape
231
        workspace.FeedBlob("X", X_inputs[0])
232
        workspace.CreateNet(pred_net_onnxified)
233
        workspace.CreateNet(pred_net_ref)
234

235
        for i in range(len(X_inputs)):
236
            workspace.FeedBlob("X", X_inputs[i])
237
            # Run Glow net
238
            workspace.RunNet(pred_net_onnxified.name)
239
            Y_glow = workspace.FetchBlob('Y')
240
            workspace.RunNet(pred_net_ref.name)
241
            Y_c2 = workspace.FetchBlob('Y')
242

243
            diff = np.abs((Y_c2 - Y_glow) / (Y_c2 + 1e-8))
244
            rowdiff = np.max(diff, axis=1)
245

246
            n_offenders = np.count_nonzero(rowdiff[rowdiff > GLOW_MATMUL_RTOL])
247
            if n_offenders > 0:
248
                print_test_debug_info("fc", {
249
                    "seed": seed,
250
                    "iter": i,
251
                    "m": m,
252
                    "k": k,
253
                    "n": n,
254
                    "W0": W0,
255
                    "b0": b0,
256
                    "Y_glow": Y_glow,
257
                    "Y_c2": Y_c2,
258
                    "diff": diff,
259
                    "rowdiff": rowdiff})
260
                assert(0)
261

262
    @given(
263
        m=st.integers(1, 50),
264
        k=st.integers(1, 1000),
265
        n=st.integers(1, 50),
266
        seed=st.integers(0, 65534),
267
        use_packed=st.integers(0, 2)
268
    )
269
    @settings(deadline=datetime.timedelta(seconds=10))
270
    def test_fc_num0(self, seed, m, k, n, use_packed):
271
        """ Test numerics, fix a dimension and determine the ranges of error.
272
            Use Fp16FCAcc16 as a reference.
273
        """
274
        W = "W_packed" if use_packed else "W0"
275
        dtype = np.float32
276
        pred_net = caffe2_pb2.NetDef()
277
        pred_net.name = "pred"
278
        pred_net.external_input.extend(["X", W, "b0"])
279
        pred_net.external_output.append("Y")
280
        pred_net.op.add().CopyFrom(
281
            core.CreateOperator(
282
                "FbFCPacked" if use_packed else "FC",
283
                ["X", W, "b0"],
284
                ["Y"],
285
            )
286
        )
287
        pred_net_ref = caffe2_pb2.NetDef()
288
        pred_net_ref.name = "pred"
289
        pred_net_ref.external_input.extend(["X", W, "b0"])
290
        pred_net_ref.external_output.append("Y")
291
        pred_net_ref.op.add().CopyFrom(
292
            core.CreateOperator(
293
                "Fp16FCAcc32NNPI",
294
                ["X", W, "b0"],
295
                ["Y"],
296
            )
297
        )
298

299
        workspace.SwitchWorkspace("glow_test_ws", True)
300
        workspace.ResetWorkspace()
301
        W0 = 10 * (np.random.rand(n, k) - 0.5).astype(np.float16).astype(np.float32)
302
        b0 = 1 * (np.random.rand(n) - 0.5).astype(np.float16).astype(np.float32)
303

304
        workspace.FeedBlob("W0", W0)
305
        workspace.FeedBlob("b0", b0)
306
        workspace.RunOperatorOnce(
307
            core.CreateOperator(
308
                "FbGemmPack",
309
                ['W0'],
310
                ['W_packed'],
311
                no_packing=True,
312
            )
313
        )
314

315
        pred_net_onnxified = onnxifi_caffe2_net(pred_net,
316
                                                {"X": (m, k)},
317
                                                debug=True,
318
                                                adjust_batch=False,
319
                                                use_onnx=False)
320
        num_onnxified_ops = sum(
321
            1 if o.type == "Onnxifi" else 0 for o in pred_net_onnxified.op)
322
        np.testing.assert_equal(num_onnxified_ops, 1)
323

324
        X0 = np.random.rand(m, k).astype(dtype) - 0.5
325
        workspace.FeedBlob("X", X0)
326
        workspace.CreateNet(pred_net_onnxified)
327
        workspace.CreateNet(pred_net_ref)
328

329
        workspace.RunNet(pred_net_onnxified.name)
330
        Y_glow = workspace.FetchBlob('Y')
331

332
        # Run caffe2 net
333
        workspace.RunNet(pred_net_ref.name)
334
        Y_c2 = workspace.FetchBlob('Y')
335

336
        diff = np.abs((Y_c2 - Y_glow) / (Y_c2 + 1e-8))
337
        rowdiff = np.max(diff, axis=1)
338

339
        n_offenders = np.count_nonzero(rowdiff[rowdiff > GLOW_MATMUL_RTOL])
340
        if n_offenders > 0:
341
            print_test_debug_info("fc", {
342
                "seed": seed,
343
                "use_packed": use_packed,
344
                "m": m,
345
                "k": k,
346
                "n": n,
347
                "X": X0.shape,
348
                "W0": W0.shape,
349
                "b0": b0.shape,
350
                "Y_glow": Y_glow,
351
                "Y_c2": Y_c2,
352
                "diff": diff,
353
                "rowdiff": rowdiff})
354
            assert(0)
355

356
if __name__ == '__main__':
357
    unittest.main()
358