Esempio n. 1
0
 def setUp(self):  # type: () -> None
     self.img_arr = np.uint8(npr.rand(224, 224, 3) * 255)  # type: ignore
     self.img = Image.fromarray(np.uint8(self.img_arr))  # type: ignore
     self.img_arr = np.float32(self.img_arr)  # type: ignore
     self.onnx_model = _onnx_create_single_node_model(
         "Relu", [(3, 224, 224)], [(3, 224, 224)])
     self.input_names = [i.name for i in self.onnx_model.graph.input]
     self.output_names = [o.name for o in self.onnx_model.graph.output]
Esempio n. 2
0
 def test_create_node(self):  # type: () -> None
     model = _onnx_create_single_node_model("Elu", [(1, 3, 224, 224)],
                                            [(1, 3, 224, 224)],
                                            alpha=0.5)
     graph = model.graph
     node = graph.node[0]
     node_ = Node.from_onnx(node)
     self.assertTrue(len(node_.inputs) == 1)
     self.assertTrue(len(node_.outputs) == 1)
     self.assertTrue(len(node_.attrs) == 1)
     self.assertTrue(node_.attrs["alpha"] == 0.5)
Esempio n. 3
0
    def skip_test_lstm(self):  # type: () -> None
        x = 4
        h = 2
        seq_length = 3
        W = from_array(_random_array((4 * h, x)), name="gate_weights")
        R = from_array(_random_array((4 * h, h)), name="recursion_weights")
        B = from_array(_random_array((8 * h, )), name="biases")
        seq_lens_input = from_array(np.array([seq_length]).astype(np.int32),
                                    name='seq_lens_input')
        initial_h = from_array(np.zeros((1, 1, h)).astype(np.float32),
                               name='initial_h')
        initial_c = from_array(np.zeros((1, 1, h)).astype(np.float32),
                               name='initial_c')

        input_shape = (seq_length, 1, x)
        output_shape_all = (seq_length, 1, h)
        output_shape_last = (1, 1, h)

        onnx_model = _onnx_create_single_node_model(
            "LSTM", [input_shape], [output_shape_all, output_shape_last],
            initializer=[W, R, B, seq_lens_input, initial_h, initial_c],
            hidden_size=h)
        X = np.random.rand(*input_shape).astype("float32")  #type: ignore
        prepared_backend = caffe2.python.onnx.backend.prepare(onnx_model)
        out = prepared_backend.run({'input0': X})
        caffe2_out_all = out['output0']
        caffe2_out_last = out['output1']

        coreml_model = convert(onnx_model)
        inputdict = {}
        inputdict['input0'] = X
        inputdict['initial_h'] = np.zeros((h), dtype=np.float32)
        inputdict['initial_c'] = np.zeros((h), dtype=np.float32)
        coreml_out_dict = coreml_model.predict(inputdict, useCPUOnly=True)
        coreml_out_all = coreml_out_dict['output0']
        coreml_out_last = coreml_out_dict['output1']

        _assert_outputs(caffe2_out_all.flatten(),
                        coreml_out_all.flatten(),
                        decimal=5)
        _assert_outputs(caffe2_out_last.flatten(),
                        coreml_out_last.flatten(),
                        decimal=5)