Beispiel #1
0
    def testGraphDefQuantizationInvalid(self):
        in_tensor_1 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                            dtype=dtypes.float32,
                                            name="inputA")
        in_tensor_2 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                            dtype=dtypes.float32,
                                            name="inputB")
        _ = array_ops.fake_quant_with_min_max_args(in_tensor_1 + in_tensor_2,
                                                   min=0.,
                                                   max=1.,
                                                   name="output")
        sess = session.Session()

        input_arrays_map = [("inputA", [1, 16, 16, 3]),
                            ("inputB", [1, 16, 16, 3])]
        output_arrays = ["output"]
        with self.assertRaises(ValueError) as error:
            convert.toco_convert_graph_def(
                sess.graph_def,
                input_arrays_map,
                output_arrays,
                inference_type=lite_constants.QUANTIZED_UINT8)
        self.assertEqual(
            "std_dev and mean must be defined when inference_input_type is "
            "QUANTIZED_UINT8.", str(error.exception))
Beispiel #2
0
    def testGraphDefQuantizationInvalid(self):
        with ops.Graph().as_default():
            in_tensor_1 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                                dtype=dtypes.float32,
                                                name="inputA")
            in_tensor_2 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                                dtype=dtypes.float32,
                                                name="inputB")
            _ = array_ops.fake_quant_with_min_max_args(in_tensor_1 +
                                                       in_tensor_2,
                                                       min=0.,
                                                       max=1.,
                                                       name="output")
            sess = session.Session()

        input_arrays_map = [("inputA", [1, 16, 16, 3]),
                            ("inputB", [1, 16, 16, 3])]
        output_arrays = ["output"]
        with self.assertRaises(ValueError) as error:
            convert.toco_convert_graph_def(sess.graph_def,
                                           input_arrays_map,
                                           output_arrays,
                                           enable_mlir_converter=False,
                                           inference_type=dtypes.uint8)
        self.assertEqual(
            "The `quantized_input_stats` flag must be defined when either "
            "`inference_type` flag or `inference_input_type` flag is set to "
            "tf.int8 or tf.uint8.", str(error.exception))
  def testGraphDefBasic(self):
    in_tensor = array_ops.placeholder(
        shape=[1, 16, 16, 3], dtype=dtypes.float32, name="input")
    _ = in_tensor + in_tensor
    sess = session.Session()

    tflite_model = convert.toco_convert_graph_def(
        sess.graph_def, [("input", [1, 16, 16, 3])], ["add"],
        inference_type=lite_constants.FLOAT)
    self.assertTrue(tflite_model)

    # Check values from converted model.
    interpreter = Interpreter(model_content=tflite_model)
    interpreter.allocate_tensors()

    input_details = interpreter.get_input_details()
    self.assertEqual(1, len(input_details))
    self.assertEqual("input", input_details[0]["name"])
    self.assertEqual(np.float32, input_details[0]["dtype"])
    self.assertTrue(([1, 16, 16, 3] == input_details[0]["shape"]).all())
    self.assertEqual((0., 0.), input_details[0]["quantization"])

    output_details = interpreter.get_output_details()
    self.assertEqual(1, len(output_details))
    self.assertEqual("add", output_details[0]["name"])
    self.assertEqual(np.float32, output_details[0]["dtype"])
    self.assertTrue(([1, 16, 16, 3] == output_details[0]["shape"]).all())
    self.assertEqual((0., 0.), output_details[0]["quantization"])
Beispiel #4
0
    def testGraphDefBasic(self):
        in_tensor = array_ops.placeholder(shape=[1, 16, 16, 3],
                                          dtype=dtypes.float32,
                                          name="input")
        _ = in_tensor + in_tensor
        sess = session.Session()

        tflite_model = convert.toco_convert_graph_def(
            sess.graph_def, [("input", [1, 16, 16, 3])], ["add"],
            inference_type=lite_constants.FLOAT)
        self.assertTrue(tflite_model)

        # Check values from converted model.
        interpreter = Interpreter(model_content=tflite_model)
        interpreter.allocate_tensors()

        input_details = interpreter.get_input_details()
        self.assertEqual(1, len(input_details))
        self.assertEqual("input", input_details[0]["name"])
        self.assertEqual(np.float32, input_details[0]["dtype"])
        self.assertTrue(([1, 16, 16, 3] == input_details[0]["shape"]).all())
        self.assertEqual((0., 0.), input_details[0]["quantization"])

        output_details = interpreter.get_output_details()
        self.assertEqual(1, len(output_details))
        self.assertEqual("add", output_details[0]["name"])
        self.assertEqual(np.float32, output_details[0]["dtype"])
        self.assertTrue(([1, 16, 16, 3] == output_details[0]["shape"]).all())
        self.assertEqual((0., 0.), output_details[0]["quantization"])
  def testGraphDefQuantizationInvalid(self):
    in_tensor_1 = array_ops.placeholder(
        shape=[1, 16, 16, 3], dtype=dtypes.float32, name="inputA")
    in_tensor_2 = array_ops.placeholder(
        shape=[1, 16, 16, 3], dtype=dtypes.float32, name="inputB")
    _ = array_ops.fake_quant_with_min_max_args(
        in_tensor_1 + in_tensor_2, min=0., max=1., name="output")
    sess = session.Session()

    input_arrays_map = [("inputA", [1, 16, 16, 3]), ("inputB", [1, 16, 16, 3])]
    output_arrays = ["output"]
    with self.assertRaises(ValueError) as error:
      convert.toco_convert_graph_def(
          sess.graph_def,
          input_arrays_map,
          output_arrays,
          inference_type=lite_constants.QUANTIZED_UINT8)
    self.assertEqual(
        "std_dev and mean must be defined when inference_input_type is "
        "QUANTIZED_UINT8.", str(error.exception))
Beispiel #6
0
    def testGraphDefQuantization(self):
        with ops.Graph().as_default():
            in_tensor_1 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                                dtype=dtypes.float32,
                                                name="inputA")
            in_tensor_2 = array_ops.placeholder(shape=[1, 16, 16, 3],
                                                dtype=dtypes.float32,
                                                name="inputB")
            _ = array_ops.fake_quant_with_min_max_args(in_tensor_1 +
                                                       in_tensor_2,
                                                       min=0.,
                                                       max=1.,
                                                       name="output")
            sess = session.Session()

        input_arrays_map = [("inputA", [1, 16, 16, 3]),
                            ("inputB", [1, 16, 16, 3])]
        output_arrays = ["output"]
        tflite_model = convert.toco_convert_graph_def(
            sess.graph_def,
            input_arrays_map,
            output_arrays,
            enable_mlir_converter=False,
            control_output_arrays=None,
            inference_type=dtypes.uint8,
            quantized_input_stats=[(0., 1.), (0., 1.)])
        self.assertTrue(tflite_model)

        # Check values from converted model.
        interpreter = Interpreter(model_content=tflite_model)
        interpreter.allocate_tensors()

        input_details = interpreter.get_input_details()
        self.assertEqual(2, len(input_details))
        self.assertEqual("inputA", input_details[0]["name"])
        self.assertEqual(np.uint8, input_details[0]["dtype"])
        self.assertTrue(([1, 16, 16, 3] == input_details[0]["shape"]).all())
        self.assertEqual((1., 0.),
                         input_details[0]["quantization"])  # scale, zero_point

        self.assertEqual("inputB", input_details[1]["name"])
        self.assertEqual(np.uint8, input_details[1]["dtype"])
        self.assertTrue(([1, 16, 16, 3] == input_details[1]["shape"]).all())
        self.assertEqual((1., 0.),
                         input_details[1]["quantization"])  # scale, zero_point

        output_details = interpreter.get_output_details()
        self.assertEqual(1, len(output_details))
        self.assertEqual("output", output_details[0]["name"])
        self.assertEqual(np.uint8, output_details[0]["dtype"])
        self.assertTrue(([1, 16, 16, 3] == output_details[0]["shape"]).all())
        self.assertGreater(output_details[0]["quantization"][0], 0)  # scale
  def testGraphDefQuantization(self):
    in_tensor_1 = array_ops.placeholder(
        shape=[1, 16, 16, 3], dtype=dtypes.float32, name="inputA")
    in_tensor_2 = array_ops.placeholder(
        shape=[1, 16, 16, 3], dtype=dtypes.float32, name="inputB")
    _ = array_ops.fake_quant_with_min_max_args(
        in_tensor_1 + in_tensor_2, min=0., max=1., name="output")
    sess = session.Session()

    input_arrays_map = [("inputA", [1, 16, 16, 3]), ("inputB", [1, 16, 16, 3])]
    output_arrays = ["output"]
    tflite_model = convert.toco_convert_graph_def(
        sess.graph_def,
        input_arrays_map,
        output_arrays,
        inference_type=lite_constants.QUANTIZED_UINT8,
        quantized_input_stats=[(0., 1.), (0., 1.)])
    self.assertTrue(tflite_model)

    # Check values from converted model.
    interpreter = Interpreter(model_content=tflite_model)
    interpreter.allocate_tensors()

    input_details = interpreter.get_input_details()
    self.assertEqual(2, len(input_details))
    self.assertEqual("inputA", input_details[0]["name"])
    self.assertEqual(np.uint8, input_details[0]["dtype"])
    self.assertTrue(([1, 16, 16, 3] == input_details[0]["shape"]).all())
    self.assertEqual((1., 0.),
                     input_details[0]["quantization"])  # scale, zero_point

    self.assertEqual("inputB", input_details[1]["name"])
    self.assertEqual(np.uint8, input_details[1]["dtype"])
    self.assertTrue(([1, 16, 16, 3] == input_details[1]["shape"]).all())
    self.assertEqual((1., 0.),
                     input_details[1]["quantization"])  # scale, zero_point

    output_details = interpreter.get_output_details()
    self.assertEqual(1, len(output_details))
    self.assertEqual("output", output_details[0]["name"])
    self.assertEqual(np.uint8, output_details[0]["dtype"])
    self.assertTrue(([1, 16, 16, 3] == output_details[0]["shape"]).all())
    self.assertTrue(output_details[0]["quantization"][0] > 0)  # scale