INC new API tensorflow examples update

.azure-pipelines/scripts/codeScan/pyspelling/inc_dict.txt

@@ -2397,6 +2397,8 @@ grappler
 amsgrad
 qoperator
 apis
+PostTrainingQuantConfig
+dgpu
 CPz
 Nsh
 UmK

examples/.config/model_params_tensorflow.json

@@ -166,10 +166,8 @@
       "model_src_dir": "image_recognition/keras_models/inception_resnet_v2/quantization/ptq",
       "dataset_location": "/tf_dataset/dataset/imagenet",
       "input_model": "/tf_dataset2/models/tensorflow/inception_resnet_v2_keras/saved_model/",
-      "yaml": "inception_resnet_v2.yaml",
-      "strategy": "basic",
-      "batch_size": 1,
-      "new_benchmark": true
+      "main_script": "main.py",
+      "batch_size": 32
     },
     "vgg16": {
       "model_src_dir": "image_recognition/tensorflow_models/quantization/ptq",
@@ -292,10 +290,8 @@
       "model_src_dir": "image_recognition/keras_models/resnetv2_50/quantization/ptq",
       "dataset_location": "/tf_dataset/dataset/imagenet",
       "input_model": "/tf_dataset2/models/tensorflow/resnetv2_50_keras/saved_model",
-      "yaml": "resnetv2_50.yaml",
-      "strategy": "basic",
-      "batch_size": 1,
-      "new_benchmark": true
+      "main_script": "main.py",
+      "batch_size": 32
     },
     "resnetv2_101": {
       "model_src_dir": "image_recognition/tensorflow_models/quantization/ptq",
@@ -2494,10 +2490,8 @@
       "model_src_dir": "image_recognition/keras_models/xception/quantization/ptq",
       "dataset_location": "/tf_dataset/dataset/imagenet",
       "input_model": "/tf_dataset2/models/tensorflow/xception_keras/saved_model/",
-      "yaml": "xception.yaml",
-      "strategy": "basic",
-      "batch_size": 1,
-      "new_benchmark": true
+      "main_script": "main.py",
+      "batch_size": 32
     }
   }
 }

examples/tensorflow/image_recognition/keras_models/inception_resnet_v2/quantization/ptq/README.md

@@ -26,7 +26,8 @@ Intel Extension for Tensorflow is mandatory to be installed for quantizing the m
 ```shell
 pip install --upgrade intel-extension-for-tensorflow[gpu]
 ```
-For any more details, please follow the procedure in [install-gpu-drivers](https://github.com/intel-innersource/frameworks.ai.infrastructure.intel-extension-for-tensorflow.intel-extension-for-tensorflow/blob/master/docs/install/install_for_gpu.md#install-gpu-drivers)
+Please refer to the [Installation Guides](https://dgpu-docs.intel.com/installation-guides/ubuntu/ubuntu-focal-dc.html) for latest Intel GPU driver installation.
+For any more details, please follow the procedure in [install-gpu-drivers](https://github.com/intel-innersource/frameworks.ai.infrastructure.intel-extension-for-tensorflow.intel-extension-for-tensorflow/blob/master/docs/install/install_for_gpu.md#install-gpu-drivers).
 
 #### Quantizing the model on Intel CPU(Experimental)
 Intel Extension for Tensorflow for Intel CPUs is experimental currently. It's not mandatory for quantizing the model on Intel CPUs.
@@ -43,12 +44,20 @@ python prepare_model.py   --output_model=/path/to/model
  ```
 `--output_model ` the model should be saved as SavedModel format or H5 format.
 
-## Write Yaml config file
-In examples directory, there is a inception_resnet_v2.yaml for tuning the model on Intel CPUs. The 'framework' in the yaml is set to 'tensorflow'. If running this example on Intel GPUs, the 'framework' should be set to 'tensorflow_itex' and the device in yaml file should be set to 'gpu'. The inception_resnet_v2_itex.yaml is prepared for the GPU case. We could remove most of items and only keep mandatory item for tuning. We also implement a calibration dataloader and have evaluation field for creation of evaluation function at internal neural_compressor.
+## Quantization Config
+The Quantization Config class has default parameters setting for running on Intel CPUs. If running this example on Intel GPUs, the 'backend' parameter should be set to 'itex' and the 'device' parameter should be set to 'gpu'.
+
+```
+config = PostTrainingQuantConfig(
+    device="gpu",
+    backend="itex",
+    ...
+    )
+```
 
 ## Run Command
   ```shell
-  bash run_tuning.sh --config=inception_resnet_v2.yaml --input_model=./path/to/model --output_model=./result --eval_data=/path/to/evaluation/dataset --calib_data=/path/to/calibration/dataset
-  bash run_benchmark.sh --config=inception_resnet_v2.yaml --input_model=./path/to/model --mode=performance --eval_data=/path/to/evaluation/dataset
+  bash run_tuning.sh --input_model=./path/to/model --output_model=./result --dataset_location=/path/to/evaluation/dataset --batch_size=32
+  bash run_benchmark.sh --input_model=./path/to/model --mode=performance --dataset_location=/path/to/evaluation/dataset --batch_size=1
   ```
 

examples/tensorflow/image_recognition/keras_models/inception_resnet_v2/quantization/ptq/main.py

@@ -1,7 +1,7 @@
 #
 # -*- coding: utf-8 -*-
 #
-# Copyright (c) 2018 Intel Corporation
+# Copyright (c) 2022 Intel Corporation
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -16,11 +16,9 @@
 # limitations under the License.
 #
 import time
-import shutil
 import numpy as np
-from argparse import ArgumentParser
-from neural_compressor import data
 import tensorflow as tf
+from neural_compressor.utils import logger
 tf.compat.v1.logging.set_verbosity(tf.compat.v1.logging.ERROR)
 
 flags = tf.compat.v1.flags
@@ -42,87 +40,111 @@
 flags.DEFINE_bool(
     'benchmark', False, 'whether to benchmark the model')
 
-flags.DEFINE_string(
-    'config', 'bert.yaml', 'yaml configuration of the model')
-
 flags.DEFINE_string(
     'calib_data', None, 'location of calibration dataset')
 
 flags.DEFINE_string(
     'eval_data', None, 'location of evaluate dataset')
 
-from neural_compressor.experimental.metric.metric import TensorflowTopK
-from neural_compressor.experimental.data.transforms.transform import ComposeTransform
-from neural_compressor.experimental.data.datasets.dataset import TensorflowImageRecord
-from neural_compressor.experimental.data.transforms.imagenet_transform import LabelShift
-from neural_compressor.experimental.data.dataloaders.default_dataloader import DefaultDataLoader
+flags.DEFINE_integer('batch_size', 32, 'batch_size')
+
+flags.DEFINE_integer(
+    'iters', 100, 'maximum iteration when evaluating performance')
+
+from neural_compressor.metric.metric import TensorflowTopK
+from neural_compressor.data.transforms.transform import ComposeTransform
+from neural_compressor.data.datasets.dataset import TensorflowImageRecord
+from neural_compressor.data.transforms.imagenet_transform import LabelShift
+from neural_compressor.data.dataloaders.default_dataloader import DefaultDataLoader
 from neural_compressor.data.transforms.imagenet_transform import BilinearImagenetTransform
 
 eval_dataset = TensorflowImageRecord(root=FLAGS.eval_data, transform=ComposeTransform(transform_list= \
-  [BilinearImagenetTransform(height=299, width=299)]))
-if FLAGS.benchmark and FLAGS.mode == 'performance':
-  eval_dataloader = DefaultDataLoader(dataset=eval_dataset, batch_size=1)
-else:
-  eval_dataloader = DefaultDataLoader(dataset=eval_dataset, batch_size=32)
+                 [BilinearImagenetTransform(height=299, width=299)]))
+
+eval_dataloader = DefaultDataLoader(dataset=eval_dataset, batch_size=FLAGS.batch_size)
+
 if FLAGS.calib_data:
-  calib_dataset = TensorflowImageRecord(root=FLAGS.calib_data, transform=ComposeTransform(transform_list= \
-    [BilinearImagenetTransform(height=299, width=299)]))
-  calib_dataloader = DefaultDataLoader(dataset=calib_dataset, batch_size=10)
-
-def evaluate(model, measurer=None):
-  """
-  Custom evaluate function to inference the model for specified metric on validation dataset.
-
-  Args:
-      model (tf.saved_model.load): The input model will be the class of tf.saved_model.load(quantized_model_path).
-      measurer (object, optional): for benchmark measurement of duration.
-
-  Returns:
-      accuracy (float): evaluation result, the larger is better.
-  """
-  infer = model.signatures["serving_default"]
-  output_dict_keys = infer.structured_outputs.keys()
-  output_name = list(output_dict_keys )[0]
-  postprocess = LabelShift(label_shift=1)
-  metric = TensorflowTopK(k=1)
-
-  def eval_func(dataloader, metric):
-      results = []
-      for idx, (inputs, labels) in enumerate(dataloader):
-          inputs = np.array(inputs)
-          input_tensor = tf.constant(inputs)
-          if measurer:
-            measurer.start()
-          predictions = infer(input_tensor)[output_name]
-          if measurer:
-            measurer.end()
-          predictions = predictions.numpy()
-          predictions, labels = postprocess((predictions, labels))
-          metric.update(predictions, labels)
-      return results
-
-  results = eval_func(eval_dataloader, metric)
-  acc = metric.result()
-  return acc
+    calib_dataset = TensorflowImageRecord(root=FLAGS.calib_data, transform= \
+         ComposeTransform(transform_list= [BilinearImagenetTransform(height=299, width=299)]))
+    calib_dataloader = DefaultDataLoader(dataset=calib_dataset, batch_size=10)
+
+def evaluate(model):
+    """
+    Custom evaluate function to inference the model for specified metric on validation dataset.
+
+    Args:
+        model (tf.saved_model.load): The input model will be the class of tf.saved_model.load(quantized_model_path).
+        measurer (object, optional): for benchmark measurement of duration.
+
+    Returns:
+        accuracy (float): evaluation result, the larger is better.
+    """
+    infer = model.signatures["serving_default"]
+    output_dict_keys = infer.structured_outputs.keys()
+    output_name = list(output_dict_keys )[0]
+    postprocess = LabelShift(label_shift=1)
+    metric = TensorflowTopK(k=1)
+    latency_list = []
+
+    def eval_func(dataloader, metric):
+        warmup = 5
+        iteration = None
+
+        if FLAGS.benchmark and FLAGS.mode == 'performance':
+            iteration = FLAGS.iters
+        for idx, (inputs, labels) in enumerate(dataloader):
+            inputs = np.array(inputs)
+            input_tensor = tf.constant(inputs)
+            start = time.time()
+            predictions = infer(input_tensor)[output_name]
+            end = time.time()
+            latency_list.append(end - start)
+            predictions = predictions.numpy()
+            predictions, labels = postprocess((predictions, labels))
+            metric.update(predictions, labels)
+            if iteration and idx >= iteration:
+                break
+        latency = np.array(latency_list[warmup:]).mean() / eval_dataloader.batch_size
+        return latency
+
+    latency = eval_func(eval_dataloader, metric)
+    if FLAGS.benchmark:
+        logger.info("\n{} mode benchmark result:".format(FLAGS.mode))
+        for i, res in enumerate(latency_list):
+            logger.debug("Iteration {} result {}:".format(i, res))
+    if FLAGS.benchmark and FLAGS.mode == 'performance':
+        logger.info("Batch size = {}".format(eval_dataloader.batch_size))
+        logger.info("Latency: {:.3f} ms".format(latency * 1000))
+        logger.info("Throughput: {:.3f} images/sec".format(1. / latency))
+    acc = metric.result()
+    return acc
 
 def main(_):
-  if FLAGS.tune:
-    from neural_compressor.experimental import Quantization, common
-    quantizer = Quantization(FLAGS.config)
-    quantizer.model = common.Model(FLAGS.input_model)
-    quantizer.eval_func = evaluate
-    quantizer.calib_dataloader = calib_dataloader
-    q_model = quantizer.fit()
-    q_model.save(FLAGS.output_model)
-
-
-  if FLAGS.benchmark:
-    from neural_compressor.experimental import Benchmark, common
-    evaluator = Benchmark(FLAGS.config)
-    evaluator.model = common.Model(FLAGS.input_model)
-    evaluator.b_func = evaluate
-    evaluator.b_dataloader = eval_dataloader
-    evaluator(FLAGS.mode)
+    if FLAGS.tune:
+        from neural_compressor.quantization import fit
+        from neural_compressor.config import PostTrainingQuantConfig
+        from neural_compressor.utils.utility import set_random_seed
+        set_random_seed(9527)
+        config = PostTrainingQuantConfig(calibration_sampling_size=[50, 100])
+        q_model = fit(
+            model=FLAGS.input_model,
+            conf=config,
+            calib_dataloader=calib_dataloader,
+            eval_dataloader=eval_dataloader,
+            eval_func=evaluate)
+        q_model.save(FLAGS.output_model)
+
+    if FLAGS.benchmark:
+        from neural_compressor.benchmark import fit
+        from neural_compressor.config import BenchmarkConfig
+        if FLAGS.mode == 'performance':
+            conf = BenchmarkConfig(iteration=100, cores_per_instance=4, num_of_instance=7)
+            fit(FLAGS.input_model, conf, b_func=evaluate)
+        else:
+            from neural_compressor.model.model import Model
+            accuracy = evaluate(Model(FLAGS.input_model).model)
+            logger.info('Batch size = %d' % FLAGS.batch_size)
+            logger.info("Accuracy: %.5f" % accuracy)
 
 if __name__ == "__main__":
     tf.compat.v1.app.run()

examples/tensorflow/image_recognition/keras_models/inception_resnet_v2/quantization/ptq/prepare_model.py

@@ -1,3 +1,21 @@
+#
+# -*- coding: utf-8 -*-
+#
+# Copyright (c) 2022 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
 import argparse
 import tensorflow as tf
 def get_inception_resnet_v2_model(saved_path):