def main(): argparser = get_common_argparser() argparser.add_argument( '-a', '--annotation-file', help='File with Imagenet annotations in .txt format', required=True) # Steps 1-7: Model optimization compressed_model, pipeline = optimize_model(argparser.parse_args()) # Step 8: Save the compressed model to the desired path. save_model(compressed_model, os.path.join(os.path.curdir, 'optimized')) # Step 9 (Optional): Evaluate the compressed model. Print the results. metric_results = pipeline.evaluate(compressed_model) if metric_results: for name, value in metric_results.items(): print('{: <27s}: {}'.format(name, value))
def optimize(self, optimization_type: OptimizationType, dataset: DatasetEntity, output_model: ModelEntity, optimization_parameters: Optional[OptimizationParameters]): if optimization_type is not OptimizationType.POT: raise ValueError( "POT is the only supported optimization type for OpenVino models" ) data_loader = OTEOpenVinoDataLoader(dataset, self.inferencer) with tempfile.TemporaryDirectory() as tempdir: xml_path = os.path.join(tempdir, "model.xml") bin_path = os.path.join(tempdir, "model.bin") with open(xml_path, "wb") as f: f.write(self.model.get_data("openvino.xml")) with open(bin_path, "wb") as f: f.write(self.model.get_data("openvino.bin")) model_config = ADDict({ 'model_name': 'openvino_model', 'model': xml_path, 'weights': bin_path }) model = load_model(model_config) if get_nodes_by_type(model, ["FakeQuantize"]): raise RuntimeError("Model is already optimized by POT") engine_config = ADDict({'device': 'CPU'}) stat_subset_size = self.hparams.pot_parameters.stat_subset_size preset = self.hparams.pot_parameters.preset.name.lower() algorithms = [{ 'name': 'DefaultQuantization', 'params': { 'target_device': 'ANY', 'preset': preset, 'stat_subset_size': min(stat_subset_size, len(data_loader)), 'shuffle_data': True } }] engine = IEEngine(config=engine_config, data_loader=data_loader, metric=None) pipeline = create_pipeline(algorithms, engine) compressed_model = pipeline.run(model) compress_model_weights(compressed_model) with tempfile.TemporaryDirectory() as tempdir: save_model(compressed_model, tempdir, model_name="model") with open(os.path.join(tempdir, "model.xml"), "rb") as f: output_model.set_data("openvino.xml", f.read()) with open(os.path.join(tempdir, "model.bin"), "rb") as f: output_model.set_data("openvino.bin", f.read()) output_model.set_data( "label_schema.json", label_schema_to_bytes(self.task_environment.label_schema)) # set model attributes for quantized model output_model.model_format = ModelFormat.OPENVINO output_model.optimization_type = ModelOptimizationType.POT output_model.optimization_methods = [OptimizationMethod.QUANTIZATION] output_model.precision = [ModelPrecision.INT8] self.model = output_model self.inferencer = self.load_inferencer()
"device": "CPU", "stat_requests_number": 4, "eval_requests_number": 4 }) dataset_config = Dict({ "preprocessed_data_dir": args.preprocessed_data_dir, }) algorithms = [{ 'name': 'DefaultQuantization', 'params': { 'target_device': 'CPU', 'preset': 'performance', 'stat_subset_size': 300 } }] model = load_model(model_config) data_loader = MyDataLoader(dataset_config) metric = MyMetric() loss = None engine = IEEngine(engine_config, data_loader, metric) pipeline = create_pipeline(algorithms, engine) compressed_model = pipeline.run(model) save_model(compressed_model, args.int8_directory) print('Calibrated model successfully saved to: {}'.format(args.int8_directory))
def optimize( self, optimization_type: OptimizationType, dataset: DatasetEntity, output_model: ModelEntity, optimization_parameters: Optional[OptimizationParameters], ): """Optimize the model. Args: optimization_type (OptimizationType): Type of optimization [POT or NNCF] dataset (DatasetEntity): Input Dataset. output_model (ModelEntity): Output model. optimization_parameters (Optional[OptimizationParameters]): Optimization parameters. Raises: ValueError: When the optimization type is not POT, which is the only support type at the moment. """ if optimization_type is not OptimizationType.POT: raise ValueError( "POT is the only supported optimization type for OpenVINO models" ) data_loader = OTEOpenVINOAnomalyDataloader(config=self.config, dataset=dataset, inferencer=self.inferencer) with tempfile.TemporaryDirectory() as tempdir: xml_path = os.path.join(tempdir, "model.xml") bin_path = os.path.join(tempdir, "model.bin") self.__save_weights( xml_path, self.task_environment.model.get_data("openvino.xml")) self.__save_weights( bin_path, self.task_environment.model.get_data("openvino.bin")) model_config = { "model_name": "openvino_model", "model": xml_path, "weights": bin_path, } model = load_model(model_config) if get_nodes_by_type(model, ["FakeQuantize"]): logger.warning("Model is already optimized by POT") return engine = IEEngine(config=ADDict({"device": "CPU"}), data_loader=data_loader, metric=None) pipeline = create_pipeline( algo_config=self._get_optimization_algorithms_configs(), engine=engine) compressed_model = pipeline.run(model) compress_model_weights(compressed_model) with tempfile.TemporaryDirectory() as tempdir: save_model(compressed_model, tempdir, model_name="model") self.__load_weights(path=os.path.join(tempdir, "model.xml"), output_model=output_model, key="openvino.xml") self.__load_weights(path=os.path.join(tempdir, "model.bin"), output_model=output_model, key="openvino.bin") output_model.set_data( "label_schema.json", label_schema_to_bytes(self.task_environment.label_schema)) output_model.set_data( "threshold", self.task_environment.model.get_data("threshold")) output_model.model_status = ModelStatus.SUCCESS output_model.model_format = ModelFormat.OPENVINO output_model.optimization_type = ModelOptimizationType.POT output_model.optimization_methods = [OptimizationMethod.QUANTIZATION] output_model.precision = [ModelPrecision.INT8] self.task_environment.model = output_model self.inferencer = self.load_inferencer()
'name': 'DefaultQuantization', # Optimization algorithm name 'params': { 'target_device': 'CPU', 'preset': 'performance', # Preset [performance (default), accuracy] which controls the quantization mode # (symmetric and asymmetric respectively) 'stat_subset_size': 300 # Size of subset to calculate activations statistics that can be used # for quantization parameters calculation. } }] # Load the model. model = load_model(model_config) # Initialize the data loader and metric. data_loader = DatasetsDataLoader(dataset_config) metric = AccuracyMetric() # Initialize the engine for metric calculation and statistics collection. engine = IEEngine(engine_config, data_loader, metric) # Initialize the engine for metric calculation and statistics collection. pipeline = create_pipeline(algorithms, engine) # Execute the pipeline. compressed_model = pipeline.run(model) # Save the compressed model. save_model(compressed_model, argv.int8_dir)
os.path.join(os.path.dirname(__file__), '..', '..', 'data', 'candy.xml'), "weights": os.path.join(os.path.dirname(__file__), '..', '..', 'data', 'candy.bin') }) engine_config = { 'device': 'CPU', 'stat_requests_number': 4, 'eval_requests_number': 4 } dataset_config = { 'images': None, } algorithms = [{ 'name': 'DefaultQuantization', 'params': { 'target_device': 'CPU', 'preset': 'performance', 'stat_subset_size': 300, } }] model = load_model(model_config) data_loader = DatasetsDataLoader(dataset_config) engine = IEEngine(engine_config, data_loader, metric=None, loss=None) pipeline = create_pipeline(algorithms, engine) compressed_model = pipeline.run(model) save_model(compressed_model, 'optimized', model_name='candy_int8')