def main(args: List[str]) -> None: if len(args) != 2: print(f"usage: {os.path.basename(args[0])} IMAGE") exit(1) if not os.path.isfile(args[1]): print(f"{os.path.basename(args[0])}: '{args[1]}' isn't a file") exit(1) tfjs.api.enable_cuda() image = tf.keras.preprocessing.image.load_img(args[1]) image = tf.keras.preprocessing.image.img_to_array(image) # normalise image data to [-1, 1] image /= 127.5 image -= 1. # ensure image size matches model input shape if image.shape != (32, 32, 3): print(f"{os.path.basename(args[0])}: WARNING - image size " f"should be 32x32, not {image.shape[0]}x{image.shape[1]}") image = Resizing(height=32, width=32)(image) # reshape to fit model input (and convert to tensor if necessary) image = tf.reshape(image, [1, 32, 32, 3]) # grab the model file and convert graph to function graph = util.get_sample_graph(util.get_path_to(util.DEPTHWISE_RELU_FILE)) model = tfjs.api.graph_to_function_v2(graph) # run the model on the input image result = model(image) # show result label, confidence = _evaluate(result) print(f"Result: {label}, confidence={confidence}")
def test_graph_to_function_v2_given_graph(self): """graph_def_to_function_v2 should accept tf.Graph""" graph = testutils.get_sample_graph(testutils.SIMPLE_MODEL_FILE_NAME) estimate = api.graph_to_function_v2(graph) x_ = 12 x = tf.constant([[x_]], dtype=tf.float32) y = as_scalar(estimate(x)) self.assertAlmostEqual(y, x_ * 5, places=1)
def test_optimize_graph(self): """optimize_graph should replace nodes if possible""" # generate optimisable test model input_graph = testutils.get_sample_graph() input_ops = [node.op for node in _op_nodes(input_graph)] # optimise the graph model output_graph = optimization.optimize_graph(input_graph) output_ops = [node.op for node in _op_nodes(output_graph)] # output should differ from input and be more efficient (smaller) self.assertNotEqual(input_ops, output_ops) self.assertLess(len(output_ops), len(input_ops))
def test_get_input_nodes(self): """Should return node info for inputs""" def _shape_of(node): shape = [d.size for d in node.attr['shape'].shape.dim] return [n if n > 0 else None for n in shape] graph = testutils.get_sample_graph() actual = util.get_input_nodes(graph) expected = testutils.get_inputs(graph.as_graph_def()) self.assertEqual(len(actual), len(expected)) for i, result in enumerate(actual): self.assertEqual(result.name, expected[i].name) self.assertEqual(result.shape, _shape_of(expected[i])) self.assertEqual(result.tensor, expected[i].name + ':0')
def test_build_signatures(self): """_build_signatures should apply given key and include inputs""" graph = testutils.get_sample_graph( testutils.get_path_to(testutils.MULTI_HEAD_FILE)) default_key = tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY debug_key = 'debug_model' signature_map = { '': {api.SIGNATURE_OUTPUTS: ['Identity']}, debug_key: {api.SIGNATURE_OUTPUTS: ['Identity', 'Identity_1']}} signature_def_map = api._build_signatures(graph, signature_map) self.assertIn(default_key, signature_def_map) self.assertIn(debug_key, signature_def_map) for signature_def in signature_def_map.values(): self.assertTrue(is_valid_signature(signature_def))
def test_build_signatures_applies_defaults(self): """_build_signatures should return defaults given None or empty""" graph = testutils.get_sample_graph() signature_map = {None: {api.SIGNATURE_OUTPUTS: ['Identity']}} signature_def_map = api._build_signatures(graph, signature_map) default_key = tf.saved_model.DEFAULT_SERVING_SIGNATURE_DEF_KEY self.assertIn(default_key, signature_def_map) default_name = tf.saved_model.PREDICT_METHOD_NAME self.assertEqual(signature_def_map[default_key].method_name, default_name) # empty method names map to default, too signature_map = {None: {api.SIGNATURE_OUTPUTS: ['Identity'], api.SIGNATURE_METHOD: ''}} signature_def_map = api._build_signatures(graph, signature_map) self.assertEqual(signature_def_map[default_key].method_name, default_name)
def test_infer_signature(self): """Should return valid SignatureDef from TF Graph""" graph = testutils.get_sample_graph() signature_def = util.infer_signature(graph) self.assertIsInstance(signature_def, util.SignatureDef) self.assertTrue(tf.compat.v1.saved_model.is_valid_signature( signature_def)) # verify inputs self.assertEqual(len(signature_def.inputs), 1) key, value = list(signature_def.inputs.items())[0] self.assertEqual(key, 'x') self.assertEqual(value.name, 'x:0') self.assertEqual(value.dtype, tf.dtypes.float32) self.assertEqual(_shape_of(value), (-1, 128, 128, 3)) # verify outputs self.assertEqual(len(signature_def.outputs), 1) key, value = list(signature_def.outputs.items())[0] self.assertEqual(key, 'Identity') self.assertEqual(value.name, 'Identity:0') self.assertEqual(value.dtype, tf.dtypes.float32) self.assertEqual(_shape_of(value), (-1, 10))
def test_build_signatures_verifies_outputs(self): """_build_signatures should not accept invalid output names""" graph = testutils.get_sample_graph() signature_map = {'': {api.SIGNATURE_OUTPUTS: ['Not_A_Tensor']}} self.assertRaises(ValueError, lambda: api._build_signatures(graph, signature_map))