Merge branch 'win_multi_instance_fix' of https://github.com/intel/neural-compressor into win_multi_instance_fix

Author: Spycsh

examples/pytorch/object_detection/maskrcnn/quantization/ptq/fx/pytorch/tools/test_net.py

@@ -159,14 +159,13 @@ def eval_func(q_model):
                                         is_distributed=distributed, is_calib=True)
     cal_dataloader = MASKRCNN_DataLoader(data_loaders_val)
     if args.tune:
-        from neural_compressor.experimental import Quantization, common
-        quantizer = Quantization("./conf.yaml")
-        quantizer.model = common.Model(model,
-                                       **{'prepare_custom_config_dict': prepare_custom_config_dict}
-                                      )
-        quantizer.calib_dataloader = cal_dataloader
-        quantizer.eval_func = eval_func
-        q_model = quantizer.fit()
+        from neural_compressor import quantization
+        from neural_compressor.experimental import common
+        from neural_compressor.config import PostTrainingQuantConfig
+        model = common.Model(model, **{'prepare_custom_config_dict': prepare_custom_config_dict})
+        conf = PostTrainingQuantConfig(approach="static", backend="pytorch_fx", calibration_sampling_size=[50])
+        q_model = quantization.fit(model, conf=conf, calib_dataloader=cal_dataloader, eval_func=eval_func)
+
         q_model.save(args.tuned_checkpoint)
         return
 

examples/pytorch/object_detection/ssd_resnet34/quantization/ptq/fx/python/main.py

@@ -5,7 +5,8 @@
 from __future__ import division
 from __future__ import print_function
 from __future__ import unicode_literals
-from neural_compressor.experimental import Quantization, common
+from neural_compressor import quantization
+from neural_compressor.config import PostTrainingQuantConfig, TuningCriterion, AccuracyCriterion, AccuracyLoss
 from queue import Queue
 
 import argparse
@@ -586,10 +587,25 @@ def benchmark(model):
     os.chdir(os.path.join(sys.path[0], ".."))
     if args.tune:
         # Quantization with Neural Compressor
-        quantizer = Quantization("./conf.yaml")
-        quantizer.model = common.Model(raw_model)
-        quantizer.eval_func = eval_func
-        q_model = quantizer.fit()
+        import torchvision.datasets as dset
+        import torchvision.transforms as transforms
+        import torch
+        dataset = dset.CocoDetection(root=args.dataset_path + "/val2017",
+                                     annFile=args.dataset_path +
+                                     "/annotations/instances_val2017.json",
+                                     transform=transforms.ToTensor())
+        dataloader = torch.utils.data.DataLoader(dataset, batch_size=1)
+
+        tuning_criterion = TuningCriterion(timeout=0, max_trials=600)
+        accuracy_criterion = AccuracyCriterion(tolerable_loss=AccuracyLoss(0.05))
+
+        conf = PostTrainingQuantConfig(approach="static", backend="pytorch_fx",
+            calibration_sampling_size=[50,100,500], tuning_criterion=tuning_criterion, accuracy_criterion=accuracy_criterion)
+        q_model = quantization.fit(raw_model,
+            conf=conf,
+            eval_func=eval_func,
+            calib_dataloader=dataloader
+        )
         q_model.save(args.tuned_checkpoint)
 
     elif args.int8:

examples/pytorch/object_detection/ssd_resnet34/quantization/ptq/ipex/infer.py

@@ -624,16 +624,23 @@ def coco_eval(model):
             return False
 
     if args.tune:
-         ssd_r34.eval()
-         ssd_r34.model = optimization.fuse(ssd_r34.model)
-         from neural_compressor.experimental import Quantization, common
-         quantizer = Quantization("./conf.yaml")
-         quantizer.model = common.Model(ssd_r34)
-         quantizer.calib_dataloader = val_dataloader
-         quantizer.eval_func = coco_eval
-         q_model = quantizer.fit()
-         q_model.save(args.tuned_checkpoint)
-         return
+        ssd_r34.eval()
+        ssd_r34.model = optimization.fuse(ssd_r34.model)
+
+        from neural_compressor import quantization
+        from neural_compressor.config import PostTrainingQuantConfig, TuningCriterion, AccuracyCriterion, AccuracyLoss
+        tuning_criterion = TuningCriterion(timeout=0, max_trials=600)
+        accuracy_criterion = AccuracyCriterion(tolerable_loss=AccuracyLoss(0.05))
+
+        conf = PostTrainingQuantConfig(approach="static", backend="pytorch_ipex",
+            calibration_sampling_size=[800], tuning_criterion=tuning_criterion, accuracy_criterion=accuracy_criterion)
+        q_model = quantization.fit(ssd_r34,
+            conf=conf,
+            eval_func=coco_eval,
+            calib_dataloader=val_dataloader
+        )
+        q_model.save(args.tuned_checkpoint)
+        return
 
     if args.benchmark or args.accuracy_mode:
         ssd_r34.eval()

examples/pytorch/object_detection/ssd_resnet34/quantization/qat/fx/ssd/main.py

@@ -300,7 +300,9 @@ def eval_func(model):
         return current_accuracy
 
     if args.tune:
-        def training_func_for_nc(model):
+        def training_func_for_nc(compression_manager, model, dataloader=None):
+            compression_manager.callbacks.on_train_begin(dataloader=dataloader)
+
             current_lr = args.lr * (global_batch_size / 32)
             current_momentum = 0.9
             optim = torch.optim.SGD(model.parameters(), lr=current_lr,
@@ -392,15 +394,18 @@ def training_func_for_nc(model):
                         print("Iteration: {:6d}, Loss function: {:5.3f}, Average Loss: {:.3f}"\
                             .format(iter_num, loss.item(), avg_loss))
                     iter_num += 1
+            compression_manager.callbacks.on_train_end()
             return model
 
-        from neural_compressor.experimental import Quantization, common
-        quantizer = Quantization("./conf.yaml")
-        quantizer.model = common.Model(ssd300)
-        quantizer.eval_func = eval_func
-        quantizer.q_func = training_func_for_nc
-        quantizer.calib_dataloader = val_dataloader
-        q_model = quantizer.fit()
+        from neural_compressor import quantization
+        from neural_compressor.config import QuantizationAwareTrainingConfig
+        import copy
+
+        conf = QuantizationAwareTrainingConfig(backend="pytorch_fx")
+        from neural_compressor.training import prepare_compression
+        compression_manager = prepare_compression(copy.deepcopy(ssd300), conf)
+        q_model = training_func_for_nc(compression_manager, compression_manager.model, val_dataloader)
+
         q_model.save(args.tuned_checkpoint)
 
     if args.benchmark or args.accuracy:

examples/pytorch/object_detection/yolo_v3/quantization/ptq/eager/test.py

@@ -169,18 +169,24 @@ def eval_func(model):
 
         model.eval()
         model.fuse_model()
-        from neural_compressor.experimental import Quantization, common
+
+        from neural_compressor import quantization
+        from neural_compressor.config import PostTrainingQuantConfig, TuningCriterion, AccuracyCriterion, AccuracyLoss
         dataset = ListDataset(valid_path, img_size=opt.img_size, augment=False, multiscale=False)
         dataloader = torch.utils.data.DataLoader(
             dataset, batch_size=opt.batch_size, shuffle=False, num_workers=1, collate_fn=dataset.collate_fn
         )
         nc_dataloader = yolo_dataLoader(dataloader)
-        quantizer = Quantization("./conf.yaml")
-        quantizer.model = common.Model(model)
-        quantizer.eval_func = eval_func
-        quantizer.calib_dataloader = nc_dataloader
-
-        q_model = quantizer.fit()
+        tuning_criterion = TuningCriterion(timeout=0)
+        accuracy_criterion = AccuracyCriterion(tolerable_loss=AccuracyLoss(0.05))
+
+        conf = PostTrainingQuantConfig(approach="static", backend="pytorch",
+            tuning_criterion=tuning_criterion, accuracy_criterion=accuracy_criterion)
+        q_model = quantization.fit(model,
+            conf=conf,
+            eval_func=eval_func,
+            calib_dataloader=nc_dataloader
+        )
         q_model.save(opt.tuned_checkpoint)
         exit(0)