Formating

Author: daniil-lyakhov

backends/openvino/quantizer/quantizer.py

@@ -1,13 +1,8 @@
-# Copyright (c) 2025 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.
+# Copyright (c) Intel Corporation
+#
+# Licensed under the BSD License (the "License"); you may not use this file
+# except in compliance with the License. See the license file in the root
+# directory of this source tree for more details.
 
 from collections import defaultdict
 from typing import Dict, List, Optional, Tuple

examples/openvino/aot/aot_openvino_compiler.py

@@ -4,33 +4,31 @@
 # except in compliance with the License. See the license file in the root
 # directory of this source tree for more details.
 
-import nncf.experimental
-import nncf.experimental.torch
+import argparse
+
 import executorch
-import nncf
 import timm
 import torch
 import torchvision.datasets as datasets
 import torchvision.models as torchvision_models
-import torchvision.transforms as transforms
-from transformers import AutoModel
-from executorch.exir.backend.backend_details import CompileSpec
-from executorch.backends.openvino.preprocess import OpenvinoBackend
-from executorch.backends.openvino.partitioner import OpenvinoPartitioner
-from executorch.exir import EdgeProgramManager, to_edge
-from torch.export import export, ExportedProgram
-from torch.export.exported_program import ExportedProgram
-import argparse
 from executorch.backends.openvino import OpenVINOQuantizer
-#from nncf.experimental.torch.fx.quantization.quantizer.openvino_quantizer import OpenVINOQuantizer
-from nncf.experimental.torch.fx.quantization.quantize_pt2e import quantize_pt2e
-from torch.ao.quantization.quantize_pt2e import (
-    convert_pt2e,
-    prepare_pt2e,
-)
+from executorch.backends.openvino.partitioner import OpenvinoPartitioner
+from executorch.exir import EdgeProgramManager
+from executorch.exir import to_edge
+from executorch.exir.backend.backend_details import CompileSpec
 from sklearn.metrics import accuracy_score
 from timm.data import resolve_data_config
 from timm.data.transforms_factory import create_transform
+from torch.export import ExportedProgram
+from torch.export import export
+from torch.export.exported_program import ExportedProgram
+from transformers import AutoModel
+
+import nncf
+import nncf.experimental
+import nncf.experimental.torch
+from nncf.experimental.torch.fx.quantization.quantize_pt2e import quantize_pt2e
+
 
 # Function to load a model based on the selected suite
 def load_model(suite: str, model_name: str):
@@ -54,10 +52,7 @@ def load_calibration_dataset(dataset_path: str, suite: str, model: torch.nn.Modu
     else:
         transform = create_transform(**resolve_data_config(model.pretrained_cfg, model=model))
 
-    val_dataset = datasets.ImageFolder(
-        val_dir,
-        transform=transform
-    )
+    val_dataset = datasets.ImageFolder(val_dir, transform=transform)
 
     calibration_dataset = torch.utils.data.DataLoader(
         val_dataset, batch_size=1, shuffle=False, num_workers=0, pin_memory=True
@@ -78,7 +73,7 @@ def main(suite: str, model_name: str, input_shape, quantize: bool, dataset_path:
     model = model.eval()
 
     # Provide input
-    example_args = (torch.randn(*input_shape), )
+    example_args = (torch.randn(*input_shape),)
 
     # Export the model to the aten dialect
     aten_dialect: ExportedProgram = export(model, example_args)
@@ -93,14 +88,19 @@ def main(suite: str, model_name: str, input_shape, quantize: bool, dataset_path:
         calibration_dataset = load_calibration_dataset(dataset_path, suite, model)
 
         captured_model = aten_dialect.module()
-        #visualize_fx_model(captured_model, f"{model_name}_fp32.svg")
         quantizer = OpenVINOQuantizer()
 
         print("PTQ: Quantize the model")
+
         def transform(x):
             return x[0]
 
-        quantized_model = quantize_pt2e(captured_model, quantizer, calibration_dataset=nncf.Dataset(calibration_dataset, transform_func=transform), fold_quantize=False)
+        quantized_model = quantize_pt2e(
+            captured_model,
+            quantizer,
+            calibration_dataset=nncf.Dataset(calibration_dataset, transform_func=transform),
+            fold_quantize=False,
+        )
 
         aten_dialect: ExportedProgram = export(quantized_model, example_args)
 
@@ -154,69 +154,53 @@ def transform(x):
         # 2: Run the executor
         print("Run openvino_executor_runner...")
         import subprocess
-        breakpoint()
-        subprocess.run(["../../../cmake-openvino-out/examples/openvino/openvino_executor_runner",
-                    f"--model_path={model_name}",
-                    f"--input_list_path={inp_list_file}",
-                    f"--output_folder_path={out_path}",
-                    #f"--num_iter={len(input_files)}"
-        ])
+
+        subprocess.run(
+            [
+                "../../../cmake-openvino-out/examples/openvino/openvino_executor_runner",
+                f"--model_path={model_name}",
+                f"--input_list_path={inp_list_file}",
+                f"--output_folder_path={out_path}",
+                # f"--num_iter={len(input_files)}"
+            ]
+        )
 
         # 3: load the outputs and compare with the targets
         import numpy as np
+
         predictions = []
         for i in range(len(input_files)):
-            predictions.append(
-                np.fromfile(
-                    os.path.join(out_path, f"output_{i}.raw"), dtype=np.float32
-                )
-            )
+            predictions.append(np.fromfile(os.path.join(out_path, f"output_{i}.raw"), dtype=np.float32))
 
-        k_val = [1, 5]
         acc_top1 = accuracy_score(predictions, targets)
         print(f"acc@1: {acc_top1}")
 
 
-from torch.fx.passes.graph_drawer import FxGraphDrawer
-def visualize_fx_model(model: torch.fx.GraphModule, output_svg_path: str):
-    g = FxGraphDrawer(model, output_svg_path)
-    g.get_dot_graph().write_svg(output_svg_path)
-
-def generate_inputs(dest_path: str, file_name: str, inputs=None, input_list=None):
-    input_list_file = None
-    input_files = []
-
-    # Prepare input list
-    if input_list is not None:
-        input_list_file = f"{dest_path}/{file_name}"
-        with open(input_list_file, "w") as f:
-            f.write(input_list)
-            f.flush()
-
-    # Prepare input data
-    if inputs is not None:
-        for idx, data in enumerate(inputs):
-            for i, d in enumerate(data):
-                file_name = f"{dest_path}/input_{idx}_{i}.raw"
-                if not isinstance(d, torch.Tensor):
-                    d = torch.tensor(d)
-                d.detach().numpy().tofile(file_name)
-                input_files.append(file_name)
-
-    return input_list_file, input_files
-
 if __name__ == "__main__":
     # Argument parser for dynamic inputs
     parser = argparse.ArgumentParser(description="Export models with executorch.")
-    parser.add_argument("--suite", type=str, required=True, choices=["timm", "torchvision", "huggingface"],
-                        help="Select the model suite (timm, torchvision, huggingface).")
+    parser.add_argument(
+        "--suite",
+        type=str,
+        required=True,
+        choices=["timm", "torchvision", "huggingface"],
+        help="Select the model suite (timm, torchvision, huggingface).",
+    )
     parser.add_argument("--model", type=str, required=True, help="Model name to be loaded.")
-    parser.add_argument("--input_shape", type=eval, required=True,
-                        help="Input shape for the model as a list or tuple (e.g., [1, 3, 224, 224] or (1, 3, 224, 224)).")
+    parser.add_argument(
+        "--input_shape",
+        type=eval,
+        required=True,
+        help="Input shape for the model as a list or tuple (e.g., [1, 3, 224, 224] or (1, 3, 224, 224)).",
+    )
     parser.add_argument("--quantize", action="store_true", help="Enable model quantization.")
     parser.add_argument("--dataset", type=str, help="Path to the calibration dataset.")
-    parser.add_argument("--device", type=str, default="CPU",
-                        help="Target device for compiling the model (e.g., CPU, GPU). Default is CPU.")
+    parser.add_argument(
+        "--device",
+        type=str,
+        default="CPU",
+        help="Target device for compiling the model (e.g., CPU, GPU). Default is CPU.",
+    )
 
     args = parser.parse_args()
 

examples/openvino/executor_runner/openvino_executor_runner.cpp

@@ -180,6 +180,7 @@ int main(int argc, char** argv) {
       while (std::getline(input_list, file_path)) {
         auto input_files = split(file_path, " ");
         ET_LOG(Info, "INPUT_FILES.SIZE: %ld", input_files.size());
+        ET_LOG(Info, "NUM_INPUTS: %ld", num_inputs);
         if (input_files.size() == 0) {
           break;
         }
@@ -189,6 +190,7 @@ int main(int argc, char** argv) {
                 method_meta.input_tensor_meta(input_index);
             auto input_data_ptr = inputs[input_index].toTensor().data_ptr<char>();
 
+            ET_LOG(Info, "READ FILE %s", std::string(input_files[input_index]));
             std::ifstream fin(input_files[input_index], std::ios::binary);
             fin.seekg(0, fin.end);
             size_t file_size = fin.tellg();