chore: import upstream snapshot with attribution

2026-07-13 13:36:55 +08:00
commit c8a779b1bb
1887 changed files with 3245738 additions and 0 deletions
@@ -0,0 +1,657 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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 datetime
+import inspect
+import os
+import sys
+import time
+import argparse
+import warnings
+import collections
+
+import subprocess
+
+import torch
+import torch.utils.data
+
+from collections import namedtuple
+from torch import nn
+
+from tqdm import tqdm
+
+import torchvision
+from torchvision import transforms
+from torch.hub import load_state_dict_from_url
+
+from pytorch_quantization import nn as quant_nn
+from pytorch_quantization import calib
+from pytorch_quantization.tensor_quant import QuantDescriptor
+from pytorch_quantization import quant_modules
+
+import onnxruntime
+import numpy as np
+import models.classification as models
+
+from prettytable import PrettyTable
+
+# The following path assumes running in nvcr.io/nvidia/pytorch:20.08-py3
+sys.path.insert(0, "/opt/pytorch/vision/references/classification/")
+
+# Import functions from torchvision reference
+try:
+    from train import evaluate, train_one_epoch, load_data, utils
+except Exception as e:
+    raise ModuleNotFoundError(
+        "Add https://github.com/pytorch/vision/blob/master/references/classification/ to PYTHONPATH")
+
+
+def get_parser():
+    """
+    Creates an argument parser.
+    """
+    parser = argparse.ArgumentParser(description='Classification quantization flow script')
+
+    parser.add_argument('--data-dir', '-d', type=str, help='input data folder', required=True)
+    parser.add_argument('--model-name', '-m', default='resnet50', help='model name: default resnet50')
+    parser.add_argument('--disable-pcq',
+                        '-dpcq',
+                        action="store_true",
+                        help='disable per-channel quantization for weights')
+    parser.add_argument('--out-dir', '-o', default='/tmp', help='output folder: default /tmp')
+    parser.add_argument('--print-freq', '-pf', type=int, default=20, help='evaluation print frequency: default 20')
+    parser.add_argument('--threshold',
+                        '-t',
+                        type=float,
+                        default=-1.0,
+                        help='top1 accuracy threshold (less than 0.0 means no comparison): default -1.0')
+
+    parser.add_argument('--fp16', action="store_true", help="Enable FP16 model training, evaluation and export")
+
+    parser.add_argument('--batch-size-train', type=int, default=128, help='batch size for training: default 128')
+    parser.add_argument('--batch-size-test', type=int, default=128, help='batch size for testing: default 128')
+    parser.add_argument('--batch-size-onnx', type=int, default=1, help='batch size for onnx: default 1')
+
+    parser.add_argument('--seed', type=int, default=12345, help='random seed: default 12345')
+
+    checkpoint = parser.add_mutually_exclusive_group(required=True)
+    checkpoint.add_argument('--ckpt-path', default='', type=str, help='path to latest checkpoint (default: none)')
+    checkpoint.add_argument('--ckpt-url', default='', type=str, help='url to latest checkpoint (default: none)')
+    checkpoint.add_argument('--pretrained', action="store_true")
+
+    parser.add_argument('--num-calib-batch',
+                        default=4,
+                        type=int,
+                        help='Number of batches for calibration. 0 will disable calibration. (default: 4)')
+    parser.add_argument('--num-finetune-epochs',
+                        default=0,
+                        type=int,
+                        help='Number of epochs to fine tune. 0 will disable fine tune. (default: 0)')
+    parser.add_argument('--calibrator', type=str, choices=["max", "histogram"], default="max")
+    parser.add_argument('--percentile', nargs='+', type=float, default=[99.9, 99.99, 99.999, 99.9999])
+    parser.add_argument('--sensitivity', action="store_true", help="Build sensitivity profile")
+    parser.add_argument('--evaluate-onnx', action="store_true", help="Evaluate exported ONNX")
+    parser.add_argument('--evaluate-trt', action="store_true", help="Export and evaluate TRT")
+
+    return parser
+
+
+def prepare_model(model_name,
+                  data_dir,
+                  per_channel_quantization,
+                  batch_size_train,
+                  batch_size_test,
+                  batch_size_onnx,
+                  calibrator,
+                  pretrained=True,
+                  ckpt_path=None,
+                  ckpt_url=None,
+                  fp16=False):
+    """
+    Prepare the model for the classification flow.
+    Arguments:
+        model_name: name to use when accessing torchvision model dictionary
+        data_dir: directory with train and val subdirs prepared "imagenet style"
+        per_channel_quantization: iff true use per channel quantization for weights
+                                   note that this isn't currently supported in ONNX-RT/Pytorch
+        batch_size_train: batch size to use when training
+        batch_size_test: batch size to use when testing in Pytorch
+        batch_size_onnx: batch size to use when testing with ONNX-RT
+        calibrator: calibration type to use (max/histogram)
+
+        pretrained: if true a pretrained model will be loaded from torchvision
+        ckpt_path: path to load a model checkpoint from, if not pretrained
+        ckpt_url: url to download a model checkpoint from, if not pretrained and no path was given
+        * at least one of {pretrained, path, url} must be valid
+
+    The method returns a the following list:
+        [
+            Model object,
+            data loader for training,
+            data loader for Pytorch testing,
+            data loader for onnx testing
+        ]
+    """
+    # Use 'spawn' to avoid CUDA reinitialization with forked subprocess
+    torch.multiprocessing.set_start_method('spawn')
+
+    ## Initialize quantization, model and data loaders
+    if per_channel_quantization:
+        quant_desc_input = QuantDescriptor(calib_method=calibrator)
+        quant_nn.QuantConv2d.set_default_quant_desc_input(quant_desc_input)
+        quant_nn.QuantLinear.set_default_quant_desc_input(quant_desc_input)
+    else:
+        ## Force per tensor quantization for onnx runtime
+        quant_desc_input = QuantDescriptor(calib_method=calibrator, axis=None)
+        quant_nn.QuantConv2d.set_default_quant_desc_input(quant_desc_input)
+        quant_nn.QuantConvTranspose2d.set_default_quant_desc_input(quant_desc_input)
+        quant_nn.QuantLinear.set_default_quant_desc_input(quant_desc_input)
+
+        quant_desc_weight = QuantDescriptor(calib_method=calibrator, axis=None)
+        quant_nn.QuantConv2d.set_default_quant_desc_weight(quant_desc_weight)
+        quant_nn.QuantConvTranspose2d.set_default_quant_desc_weight(quant_desc_weight)
+        quant_nn.QuantLinear.set_default_quant_desc_weight(quant_desc_weight)
+
+    if model_name in models.__dict__:
+        model = models.__dict__[model_name](pretrained=pretrained, quantize=True)
+    else:
+        quant_modules.initialize()
+        model = torchvision.models.__dict__[model_name](pretrained=pretrained)
+        quant_modules.deactivate()
+
+    if not pretrained:
+        if ckpt_path:
+            checkpoint = torch.load(ckpt_path)
+        else:
+            checkpoint = load_state_dict_from_url(ckpt_url)
+        if 'state_dict' in checkpoint.keys():
+            checkpoint = checkpoint['state_dict']
+        elif 'model' in checkpoint.keys():
+            checkpoint = checkpoint['model']
+        model.load_state_dict(checkpoint)
+    model.eval()
+    model.cuda()
+
+    if fp16:
+        model = model.half()
+
+    ## Prepare the data loaders
+    traindir = os.path.join(data_dir, 'train')
+    valdir = os.path.join(data_dir, 'val')
+    _args = collections.namedtuple("mock_args", [
+        "model", "distributed", "cache_dataset", "val_resize_size", "val_crop_size", "train_crop_size", "interpolation",
+        "ra_magnitude", "augmix_severity", "weights", "backend", "use_v2"
+    ])
+    dataset, dataset_test, train_sampler, test_sampler = load_data(
+        traindir, valdir,
+        _args(model=model_name,
+              distributed=False,
+              cache_dataset=False,
+              val_resize_size=256,
+              val_crop_size=224,
+              train_crop_size=224,
+              interpolation="bilinear",
+              ra_magnitude=9,
+              augmix_severity=3,
+              weights=None,
+              backend="pil",
+              use_v2=False))
+
+    data_loader_train = torch.utils.data.DataLoader(dataset,
+                                                    batch_size=batch_size_train,
+                                                    sampler=train_sampler,
+                                                    num_workers=4,
+                                                    pin_memory=True)
+
+    data_loader_test = torch.utils.data.DataLoader(dataset_test,
+                                                   batch_size=batch_size_test,
+                                                   sampler=test_sampler,
+                                                   num_workers=4,
+                                                   pin_memory=True)
+
+    data_loader_onnx = torch.utils.data.DataLoader(dataset_test,
+                                                   batch_size=batch_size_onnx,
+                                                   sampler=test_sampler,
+                                                   num_workers=4,
+                                                   pin_memory=True)
+
+    return model, data_loader_train, data_loader_test, data_loader_onnx
+
+
+def main(cmdline_args):
+    parser = get_parser()
+    args = parser.parse_args(cmdline_args)
+    print(parser.description)
+    print(args)
+
+    torch.manual_seed(args.seed)
+    np.random.seed(args.seed)
+
+    ## Prepare the pretrained model and data loaders
+    model, data_loader_train, data_loader_test, data_loader_onnx = prepare_model(
+        args.model_name, args.data_dir, not args.disable_pcq, args.batch_size_train, args.batch_size_test,
+        args.batch_size_onnx, args.calibrator, args.pretrained, args.ckpt_path, args.ckpt_url, args.fp16)
+
+    ## Initial accuracy evaluation
+    CrossEntropy = nn.CrossEntropyLoss()
+
+    # nn.CrossEntropyLoss expects float inputs
+    def criterion(output, target):
+        return CrossEntropy(output.float(), target)
+
+    with torch.no_grad():
+        print('Initial evaluation:')
+        top1_initial = evaluate(model, criterion, data_loader_test, device="cuda", print_freq=args.print_freq)
+
+    ## Calibrate the model
+    with torch.no_grad():
+        calibrate_model(model=model,
+                        model_name=args.model_name,
+                        data_loader=data_loader_train,
+                        num_calib_batch=args.num_calib_batch,
+                        calibrator=args.calibrator,
+                        hist_percentile=args.percentile,
+                        out_dir=args.out_dir)
+
+    ## Evaluate after calibration
+    if args.num_calib_batch > 0:
+        with torch.no_grad():
+            print('Calibration evaluation:')
+            top1_calibrated = evaluate(model, criterion, data_loader_test, device="cuda", print_freq=args.print_freq)
+    else:
+        top1_calibrated = -1.0
+
+    ## Build sensitivy profile
+    if args.sensitivity:
+        build_sensitivity_profile(model, criterion, data_loader_test)
+
+    ## Finetune the model
+    criterion = nn.CrossEntropyLoss()
+    optimizer = torch.optim.SGD(model.parameters(), lr=0.0001)
+    lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, args.num_finetune_epochs)
+    for epoch in range(args.num_finetune_epochs):
+        # Training a single epch
+        if "print_freq" in inspect.signature(train_one_epoch).parameters:
+            train_one_epoch(model, criterion, optimizer, data_loader_train, "cuda", 0, 100)
+        else:
+            _args = collections.namedtuple("mock_args",
+                                           ["print_freq", "clip_grad_norm", "model_ema_steps", "lr_warmup_epochs"])
+            train_one_epoch(model, criterion, optimizer, data_loader_train, "cuda", 0,
+                            _args(print_freq=100, clip_grad_norm=None, model_ema_steps=32, lr_warmup_epochs=0))
+        lr_scheduler.step()
+
+    if args.num_finetune_epochs > 0:
+        ## Evaluate after finetuning
+        with torch.no_grad():
+            print('Finetune evaluation:')
+            top1_finetuned = evaluate(model, criterion, data_loader_test, device="cuda")
+    else:
+        top1_finetuned = -1.0
+
+    ## Export to ONNX
+    onnx_filename = args.out_dir + '/' + args.model_name + ".onnx"
+    top1_onnx = -1.0
+    if args.evaluate_onnx and export_onnx(model, onnx_filename, args.batch_size_onnx, not args.disable_pcq):
+        ## Validate ONNX and evaluate
+        top1_onnx = evaluate_onnx(onnx_filename, data_loader_onnx, criterion, args.print_freq)
+
+    trt_filename = args.out_dir + '/' + args.model_name + ".trt"
+    top1_trt = -1.0
+    if args.evaluate_trt and export_trt(model, trt_filename, args.batch_size_onnx, args.fp16):
+        ## Validate TRT and evaluate
+        top1_trt = evaluate_trt(trt_filename, data_loader_onnx, criterion, args.print_freq)
+
+    ## Print summary
+    print("Accuracy summary:")
+    table = PrettyTable(['Stage', 'Top1'])
+    table.align['Stage'] = "l"
+    table.add_row(['Initial', "{:.2f}".format(top1_initial)])
+    table.add_row(['Calibrated', "{:.2f}".format(top1_calibrated)])
+    table.add_row(['Finetuned', "{:.2f}".format(top1_finetuned)])
+    table.add_row(['ONNX', "{:.2f}".format(top1_onnx)])
+    if args.evaluate_trt:
+        table.add_row(['TRT', "{:.2f}".format(top1_trt)])
+    print(table)
+
+    ## Compare results
+    if args.threshold >= 0.0:
+        if args.evaluate_onnx and top1_onnx < 0.0:
+            print("Failed to export/evaluate ONNX!")
+            return 1
+        if args.evaluate_trt and top1_trt < 0.0:
+            print("Failed to export/evaluate TRT!")
+            return 1
+        if args.num_finetune_epochs > 0:
+            if top1_finetuned >= (top1_onnx - args.threshold):
+                print("Accuracy threshold was met!")
+            else:
+                print("Accuracy threshold was missed!")
+                return 1
+
+            if args.evaluate_trt and top1_finetuned >= (top1_trt - args.threshold):
+                print("TRT Accuracy threshold was met!")
+            elif args.evaluate_trt:
+                print("TRT Accuracy threshold was missed!")
+                return 1
+
+    return 0
+
+
+def evaluate_onnx(onnx_filename, data_loader, criterion, print_freq):
+    """Evaluate accuracy on the given ONNX file using the provided data loader and criterion.
+       The method returns the average top-1 accuracy on the given dataset.
+    """
+    print("Loading ONNX file: ", onnx_filename)
+    ort_session = onnxruntime.InferenceSession(onnx_filename, providers=['CUDAExecutionProvider', 'CPUExecutionProvider'])
+    with torch.no_grad():
+        metric_logger = utils.MetricLogger(delimiter="  ")
+        header = 'Test:'
+        with torch.no_grad():
+            for image, target in metric_logger.log_every(data_loader, print_freq, header):
+                image = image.to("cpu", non_blocking=True)
+                image_data = np.array(image)
+                input_data = image_data
+
+                # run the data through onnx runtime instead of torch model
+                input_name = ort_session.get_inputs()[0].name
+                raw_result = ort_session.run([], {input_name: input_data})
+                output = torch.tensor((raw_result[0])).float()
+
+                loss = criterion(output, target)
+                acc1, acc5 = utils.accuracy(output, target, topk=(1, 5))
+                batch_size = image.shape[0]
+                metric_logger.update(loss=loss.item())
+                metric_logger.meters['acc1'].update(acc1.item(), n=batch_size)
+                metric_logger.meters['acc5'].update(acc5.item(), n=batch_size)
+        # gather the stats from all processes
+        metric_logger.synchronize_between_processes()
+
+        print('  ONNXRuntime: Acc@1 {top1.global_avg:.3f} Acc@5 {top5.global_avg:.3f}'.format(top1=metric_logger.acc1,
+                                                                                              top5=metric_logger.acc5))
+        return metric_logger.acc1.global_avg
+
+
+def evaluate_trt(trt_filename, data_loader, criterion, print_freq):
+    print("Loading TRT file: ", trt_filename)
+
+    import pycuda.driver as cuda
+    try:
+        import pycuda.autoprimaryctx
+    except ModuleNotFoundError:
+        import pycuda.autoinit
+
+    import tensorrt as trt
+
+    TRT_LOGGER = trt.Logger()
+
+    TRT_tensor = namedtuple('TRT_tensor', ['binding_idx', 'shape', 'dtype', 'device_memory', 'host_memory'])
+
+    def load_engine(engine_file_path):
+        assert os.path.exists(engine_file_path)
+        print("Reading engine from file {}".format(engine_file_path))
+        with open(engine_file_path, "rb") as f, trt.Runtime(TRT_LOGGER) as runtime:
+            return runtime.deserialize_cuda_engine(f.read())
+
+    def setup_context(engine):
+        return engine.create_execution_context()
+
+    def allocate_buffers(engine, context):
+
+        # Allocate host and device buffers
+        bindings = []
+        inputs = {}
+        outputs = {}
+        for binding_idx in range(engine.num_bindings):
+            binding = engine.get_tensor_name(binding_idx)
+            shape = tuple(context.get_tensor_shape(binding))
+
+            size = trt.volume(context.get_tensor_shape(binding))
+            dtype = np.dtype(trt.nptype(engine.get_tensor_dtype(binding)))
+
+            device_memory = cuda.mem_alloc(size * dtype.itemsize)
+            bindings.append(int(device_memory))
+
+            if engine.get_tensor_mode(binding) == trt.TensorIOMode.INPUT:
+                inputs[binding] = TRT_tensor(binding_idx, shape, dtype, device_memory, None)
+            else:
+                host_memory = cuda.pagelocked_empty(size, dtype)
+                outputs[binding] = TRT_tensor(binding_idx, shape, dtype, device_memory, host_memory)
+
+        stream = cuda.Stream()
+        return bindings, inputs, outputs, stream
+
+    def infer(batch, context, bindings, inputs, outputs, stream):
+
+        # Transfer input data to the GPU.
+        for name, trt_in_t in inputs.items():
+            buffer = np.ascontiguousarray(batch[name])
+            cuda.memcpy_htod_async(trt_in_t.device_memory, buffer, stream)
+
+        # Run inference
+        context.execute_async_v2(bindings=bindings, stream_handle=stream.handle)
+
+        # Transfer predictions back from the GPU.
+        for _, trt_out_t in outputs.items():
+            cuda.memcpy_dtoh_async(trt_out_t.host_memory, trt_out_t.device_memory, stream)
+
+        # Synchronize the stream
+        stream.synchronize()
+
+        return {k: torch.tensor(v.host_memory).reshape(v.shape) for k, v in outputs.items()}
+
+    engine = load_engine(trt_filename)
+    context = setup_context(engine)
+    bindings, inputs, outputs, stream = allocate_buffers(engine, context)
+
+    with torch.no_grad():
+        metric_logger = utils.MetricLogger(delimiter="  ")
+        header = 'Test:'
+        with torch.no_grad():
+            for image, target in metric_logger.log_every(data_loader, print_freq, header):
+                image = image.to("cpu", non_blocking=True)
+                image_data = np.array(image)
+
+                output = infer({"input": image_data}, context, bindings, inputs, outputs, stream)["output"].float()
+
+                loss = criterion(output, target)
+                acc1, acc5 = utils.accuracy(output, target, topk=(1, 5))
+                batch_size = image.shape[0]
+                metric_logger.update(loss=loss.item())
+                metric_logger.meters['acc1'].update(acc1.item(), n=batch_size)
+                metric_logger.meters['acc5'].update(acc5.item(), n=batch_size)
+        # gather the stats from all processes
+        metric_logger.synchronize_between_processes()
+
+        print('  TRTRuntime: Acc@1 {top1.global_avg:.3f} Acc@5 {top5.global_avg:.3f}'.format(top1=metric_logger.acc1,
+                                                                                             top5=metric_logger.acc5))
+        return metric_logger.acc1.global_avg
+
+
+def _export_onnx(model, dummy_input, onnx_filename, opset_version):
+    try:
+        if "enable_onnx_checker" in inspect.signature(torch.onnx.export).parameters:
+            torch.onnx.export(model,
+                              dummy_input,
+                              onnx_filename,
+                              verbose=False,
+                              input_names=["input"],
+                              output_names=["output"],
+                              opset_version=opset_version,
+                              enable_onnx_checker=False,
+                              do_constant_folding=True)
+        else:
+            torch.onnx.export(model,
+                              dummy_input,
+                              onnx_filename,
+                              verbose=False,
+                              input_names=["input"],
+                              output_names=["output"],
+                              opset_version=opset_version,
+                              do_constant_folding=True)
+    except ValueError:
+        print("Failed to export to ONNX")
+        return False
+
+    return True
+
+
+def export_onnx(model, onnx_filename, batch_onnx, per_channel_quantization):
+    model.eval()
+
+    if per_channel_quantization:
+        opset_version = 13
+    else:
+        opset_version = 12
+
+    # Export ONNX for multiple batch sizes
+    print("Creating ONNX file: " + onnx_filename)
+    dummy_input = torch.randn(batch_onnx, 3, 224, 224, device='cuda')  #TODO: switch input dims by model
+    return _export_onnx(model, dummy_input, onnx_filename, opset_version)
+
+
+def export_trt(model, trt_filename, batch_trt, fp16=False):
+    model.eval()
+
+    # Export TRT for multiple batch sizes
+    print("Creating TRT file: " + trt_filename)
+    dummy_input = torch.randn(batch_trt, 3, 224, 224, device='cuda')  #TODO: switch input dims by model
+
+    OPSET = 17
+    onnx_filename = trt_filename.replace(".trt", ".onnx")
+
+    if not _export_onnx(model, dummy_input, onnx_filename, OPSET):
+        return False
+
+    trt_cmd = f"trtexec --onnx={onnx_filename} --saveEngine={trt_filename} --int8"
+
+    if fp16:
+        trt_cmd += " --fp16"
+
+    print(trt_cmd)
+    try:
+        trt_stdout = subprocess.check_output(trt_cmd, shell=True).decode("utf-8")
+    except:
+        print("Failed to export to TRT")
+        return False
+
+    print(trt_stdout)
+    return 'PASSED' in trt_stdout
+
+
+def calibrate_model(model, model_name, data_loader, num_calib_batch, calibrator, hist_percentile, out_dir):
+    """
+        Feed data to the network and calibrate.
+        Arguments:
+            model: classification model
+            model_name: name to use when creating state files
+            data_loader: calibration data set
+            num_calib_batch: amount of calibration passes to perform
+            calibrator: type of calibration to use (max/histogram)
+            hist_percentile: percentiles to be used for historgram calibration
+            out_dir: dir to save state files in
+    """
+
+    if num_calib_batch > 0:
+        print("Calibrating model")
+        with torch.no_grad():
+            collect_stats(model, data_loader, num_calib_batch)
+
+        if not calibrator == "histogram":
+            compute_amax(model, method="max")
+            calib_output = os.path.join(out_dir, F"{model_name}-max-{num_calib_batch*data_loader.batch_size}.pth")
+            torch.save(model.state_dict(), calib_output)
+        else:
+            for percentile in hist_percentile:
+                print(F"{percentile} percentile calibration")
+                compute_amax(model, method="percentile")
+                calib_output = os.path.join(
+                    out_dir, F"{model_name}-percentile-{percentile}-{num_calib_batch*data_loader.batch_size}.pth")
+                torch.save(model.state_dict(), calib_output)
+
+            for method in ["mse", "entropy"]:
+                print(F"{method} calibration")
+                compute_amax(model, method=method)
+                calib_output = os.path.join(out_dir,
+                                            F"{model_name}-{method}-{num_calib_batch*data_loader.batch_size}.pth")
+                torch.save(model.state_dict(), calib_output)
+
+
+def collect_stats(model, data_loader, num_batches):
+    """Feed data to the network and collect statistics"""
+    # Enable calibrators
+    for name, module in model.named_modules():
+        if isinstance(module, quant_nn.TensorQuantizer):
+            if module._calibrator is not None:
+                module.disable_quant()
+                module.enable_calib()
+            else:
+                module.disable()
+
+    # Feed data to the network for collecting stats
+    for i, (image, _) in tqdm(enumerate(data_loader), total=num_batches):
+        model(image.cuda())
+        if i >= num_batches:
+            break
+
+    # Disable calibrators
+    for name, module in model.named_modules():
+        if isinstance(module, quant_nn.TensorQuantizer):
+            if module._calibrator is not None:
+                module.enable_quant()
+                module.disable_calib()
+            else:
+                module.enable()
+
+
+def compute_amax(model, **kwargs):
+    # Load calib result
+    for name, module in model.named_modules():
+        if isinstance(module, quant_nn.TensorQuantizer):
+            if module._calibrator is not None:
+                if isinstance(module._calibrator, calib.MaxCalibrator):
+                    module.load_calib_amax()
+                else:
+                    module.load_calib_amax(**kwargs)
+            print(F"{name:40}: {module}")
+    model.cuda()
+
+
+def build_sensitivity_profile(model, criterion, data_loader_test):
+    quant_layer_names = []
+    for name, module in model.named_modules():
+        if name.endswith("_quantizer"):
+            module.disable()
+            layer_name = name.replace("._input_quantizer", "").replace("._weight_quantizer", "")
+            if layer_name not in quant_layer_names:
+                quant_layer_names.append(layer_name)
+    for i, quant_layer in enumerate(quant_layer_names):
+        print("Enable", quant_layer)
+        for name, module in model.named_modules():
+            if name.endswith("_quantizer") and quant_layer in name:
+                module.enable()
+                print(F"{name:40}: {module}")
+        with torch.no_grad():
+            evaluate(model, criterion, data_loader_test, device="cuda")
+        for name, module in model.named_modules():
+            if name.endswith("_quantizer") and quant_layer in name:
+                module.disable()
+                print(F"{name:40}: {module}")
+
+
+if __name__ == '__main__':
+    res = main(sys.argv[1:])
+    exit(res)
@@ -0,0 +1,18 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+from . import classification
+
@@ -0,0 +1,18 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+from .resnet import *
+
@@ -0,0 +1,495 @@
+#
+# SPDX-FileCopyrightText: Copyright (c) 1993-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+#
+# 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.
+#
+
+# BSD 3-Clause License
+#
+# Copyright (c) Soumith Chintala 2016,
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice, this
+#   list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+#
+# * Neither the name of the copyright holder nor the names of its
+#   contributors may be used to endorse or promote products derived from
+#   this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import torch
+from torch import Tensor
+import torch.nn as nn
+from torch.hub import load_state_dict_from_url
+from typing import Type, Any, Callable, Union, List, Optional
+from pytorch_quantization import quant_modules
+from pytorch_quantization import nn as quant_nn
+
+__all__ = [
+    'ResNet', 'resnet18', 'resnet34', 'resnet50', 'resnet101', 'resnet152', 'resnext50_32x4d', 'resnext101_32x8d',
+    'wide_resnet50_2', 'wide_resnet101_2'
+]
+
+model_urls = {
+    'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
+    'resnet34': 'https://download.pytorch.org/models/resnet34-b627a593.pth',
+    'resnet50': 'https://download.pytorch.org/models/resnet50-0676ba61.pth',
+    'resnet101': 'https://download.pytorch.org/models/resnet101-63fe2227.pth',
+    'resnet152': 'https://download.pytorch.org/models/resnet152-394f9c45.pth',
+    'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
+    'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
+    'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
+    'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
+}
+
+
+def conv3x3(in_planes: int,
+            out_planes: int,
+            stride: int = 1,
+            groups: int = 1,
+            dilation: int = 1,
+            quantize: bool = False) -> nn.Conv2d:
+    """3x3 convolution with padding"""
+    if quantize:
+        return quant_nn.QuantConv2d(in_planes,
+                                    out_planes,
+                                    kernel_size=3,
+                                    stride=stride,
+                                    padding=dilation,
+                                    groups=groups,
+                                    bias=False,
+                                    dilation=dilation)
+    else:
+        return nn.Conv2d(in_planes,
+                         out_planes,
+                         kernel_size=3,
+                         stride=stride,
+                         padding=dilation,
+                         groups=groups,
+                         bias=False,
+                         dilation=dilation)
+
+
+def conv1x1(in_planes: int, out_planes: int, stride: int = 1, quantize: bool = False) -> nn.Conv2d:
+    """1x1 convolution"""
+    if quantize:
+        return quant_nn.QuantConv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+    else:
+        return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
+
+
+class BasicBlock(nn.Module):
+    expansion: int = 1
+
+    def __init__(self,
+                 inplanes: int,
+                 planes: int,
+                 stride: int = 1,
+                 downsample: Optional[nn.Module] = None,
+                 groups: int = 1,
+                 base_width: int = 64,
+                 dilation: int = 1,
+                 norm_layer: Optional[Callable[..., nn.Module]] = None,
+                 quantize: bool = False) -> None:
+        super(BasicBlock, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        if groups != 1 or base_width != 64:
+            raise ValueError('BasicBlock only supports groups=1 and base_width=64')
+        if dilation > 1:
+            raise NotImplementedError("Dilation > 1 not supported in BasicBlock")
+        # Both self.conv1 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv3x3(inplanes, planes, stride, quantize=quantize)
+        self.bn1 = norm_layer(planes)
+        self.relu = nn.ReLU(inplace=True)
+        self.conv2 = conv3x3(planes, planes, quantize=quantize)
+        self.bn2 = norm_layer(planes)
+        self.downsample = downsample
+        self.stride = stride
+        self._quantize = quantize
+        if self._quantize:
+            self.residual_quantizer = quant_nn.TensorQuantizer(quant_nn.QuantConv2d.default_quant_desc_input)
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        if self._quantize:
+            out += self.residual_quantizer(identity)
+        else:
+            out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class Bottleneck(nn.Module):
+    # Bottleneck in torchvision places the stride for downsampling at 3x3 convolution(self.conv2)
+    # while original implementation places the stride at the first 1x1 convolution(self.conv1)
+    # according to "Deep residual learning for image recognition"https://arxiv.org/abs/1512.03385.
+    # This variant is also known as ResNet V1.5 and improves accuracy according to
+    # https://ngc.nvidia.com/catalog/model-scripts/nvidia:resnet_50_v1_5_for_pytorch.
+
+    expansion: int = 4
+
+    def __init__(self,
+                 inplanes: int,
+                 planes: int,
+                 stride: int = 1,
+                 downsample: Optional[nn.Module] = None,
+                 groups: int = 1,
+                 base_width: int = 64,
+                 dilation: int = 1,
+                 norm_layer: Optional[Callable[..., nn.Module]] = None,
+                 quantize: bool = False) -> None:
+        super(Bottleneck, self).__init__()
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        width = int(planes * (base_width / 64.)) * groups
+        # Both self.conv2 and self.downsample layers downsample the input when stride != 1
+        self.conv1 = conv1x1(inplanes, width, quantize=quantize)
+        self.bn1 = norm_layer(width)
+        self.conv2 = conv3x3(width, width, stride, groups, dilation, quantize=quantize)
+        self.bn2 = norm_layer(width)
+        self.conv3 = conv1x1(width, planes * self.expansion, quantize=quantize)
+        self.bn3 = norm_layer(planes * self.expansion)
+        self.relu = nn.ReLU(inplace=True)
+        self.downsample = downsample
+        self.stride = stride
+        self._quantize = quantize
+        if self._quantize:
+            self.residual_quantizer = quant_nn.TensorQuantizer(quant_nn.QuantConv2d.default_quant_desc_input)
+
+    def forward(self, x: Tensor) -> Tensor:
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        if self._quantize:
+            out += self.residual_quantizer(identity)
+        else:
+            out += identity
+        out = self.relu(out)
+
+        return out
+
+
+class ResNet(nn.Module):
+
+    def __init__(self,
+                 block: Type[Union[BasicBlock, Bottleneck]],
+                 layers: List[int],
+                 quantize: bool = False,
+                 num_classes: int = 1000,
+                 zero_init_residual: bool = False,
+                 groups: int = 1,
+                 width_per_group: int = 64,
+                 replace_stride_with_dilation: Optional[List[bool]] = None,
+                 norm_layer: Optional[Callable[..., nn.Module]] = None) -> None:
+        super(ResNet, self).__init__()
+        self._quantize = quantize
+
+        if norm_layer is None:
+            norm_layer = nn.BatchNorm2d
+        self._norm_layer = norm_layer
+
+        self.inplanes = 64
+        self.dilation = 1
+        if replace_stride_with_dilation is None:
+            # each element in the tuple indicates if we should replace
+            # the 2x2 stride with a dilated convolution instead
+            replace_stride_with_dilation = [False, False, False]
+        if len(replace_stride_with_dilation) != 3:
+            raise ValueError("replace_stride_with_dilation should be None "
+                             "or a 3-element tuple, got {}".format(replace_stride_with_dilation))
+        self.groups = groups
+        self.base_width = width_per_group
+
+        if quantize:
+            self.conv1 = quant_nn.QuantConv2d(3,
+                                        self.inplanes,
+                                        kernel_size=7,
+                                        stride=2,
+                                        padding=3,
+                                        bias=False)
+        else:
+            self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
+
+        self.bn1 = norm_layer(self.inplanes)
+        self.relu = nn.ReLU(inplace=True)
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+        self.layer1 = self._make_layer(block, 64, layers[0], quantize=quantize)
+        self.layer2 = self._make_layer(block,
+                                       128,
+                                       layers[1],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[0],
+                                       quantize=quantize)
+        self.layer3 = self._make_layer(block,
+                                       256,
+                                       layers[2],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[1],
+                                       quantize=quantize)
+        self.layer4 = self._make_layer(block,
+                                       512,
+                                       layers[3],
+                                       stride=2,
+                                       dilate=replace_stride_with_dilation[2],
+                                       quantize=quantize)
+        self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
+
+        if quantize:
+            self.fc = quant_nn.QuantLinear(512 * block.expansion, num_classes)
+        else:
+            self.fc = nn.Linear(512 * block.expansion, num_classes)
+
+        for m in self.modules():
+            if isinstance(m, nn.Conv2d):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
+                nn.init.constant_(m.weight, 1)
+                nn.init.constant_(m.bias, 0)
+
+        # Zero-initialize the last BN in each residual branch,
+        # so that the residual branch starts with zeros, and each residual block behaves like an identity.
+        # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
+        if zero_init_residual:
+            for m in self.modules():
+                if isinstance(m, Bottleneck):
+                    nn.init.constant_(m.bn3.weight, 0)  # type: ignore[arg-type]
+                elif isinstance(m, BasicBlock):
+                    nn.init.constant_(m.bn2.weight, 0)  # type: ignore[arg-type]
+
+    def _make_layer(self,
+                    block: Type[Union[BasicBlock, Bottleneck]],
+                    planes: int,
+                    blocks: int,
+                    stride: int = 1,
+                    dilate: bool = False,
+                    quantize: bool = False) -> nn.Sequential:
+        norm_layer = self._norm_layer
+        downsample = None
+        previous_dilation = self.dilation
+        if dilate:
+            self.dilation *= stride
+            stride = 1
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                conv1x1(self.inplanes, planes * block.expansion, stride, quantize=quantize),
+                norm_layer(planes * block.expansion),
+            )
+
+        layers = []
+        layers.append(
+            block(self.inplanes, planes, stride, downsample, self.groups, self.base_width, previous_dilation,
+                  norm_layer, self._quantize))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(
+                block(self.inplanes,
+                      planes,
+                      groups=self.groups,
+                      base_width=self.base_width,
+                      dilation=self.dilation,
+                      norm_layer=norm_layer,
+                      quantize=quantize))
+
+        return nn.Sequential(*layers)
+
+    def _get_dtype(self):
+        return self.conv1.weight.dtype
+
+    def _forward_impl(self, x: Tensor) -> Tensor:
+        # See note [TorchScript super()]
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        x = self.maxpool(x)
+
+        x = self.layer1(x)
+        x = self.layer2(x)
+        x = self.layer3(x)
+        x = self.layer4(x)
+
+        x = self.avgpool(x)
+        x = torch.flatten(x, 1)
+        x = self.fc(x)
+
+        return x
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self._forward_impl(x.to(self._get_dtype()))
+
+
+def _resnet(arch: str, block: Type[Union[BasicBlock, Bottleneck]], layers: List[int], pretrained: bool, progress: bool,
+            quantize: bool, **kwargs: Any) -> ResNet:
+    model = ResNet(block, layers, quantize, **kwargs)
+    if pretrained:
+        state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)
+        model.load_state_dict(state_dict)
+    return model
+
+
+def resnet18(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNet-18 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet18', BasicBlock, [2, 2, 2, 2], pretrained, progress, quantize, **kwargs)
+
+
+def resnet34(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNet-34 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet34', BasicBlock, [3, 4, 6, 3], pretrained, progress, quantize, **kwargs)
+
+
+def resnet50(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNet-50 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet50', Bottleneck, [3, 4, 6, 3], pretrained, progress, quantize, **kwargs)
+
+
+def resnet101(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNet-101 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet101', Bottleneck, [3, 4, 23, 3], pretrained, progress, quantize, **kwargs)
+
+
+def resnet152(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNet-152 model from
+    `"Deep Residual Learning for Image Recognition" <https://arxiv.org/pdf/1512.03385.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    return _resnet('resnet152', Bottleneck, [3, 8, 36, 3], pretrained, progress, quantize, **kwargs)
+
+
+def resnext50_32x4d(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNeXt-50 32x4d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 4
+    return _resnet('resnext50_32x4d', Bottleneck, [3, 4, 6, 3], pretrained, progress, quantize, **kwargs)
+
+
+def resnext101_32x8d(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""ResNeXt-101 32x8d model from
+    `"Aggregated Residual Transformation for Deep Neural Networks" <https://arxiv.org/pdf/1611.05431.pdf>`_.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['groups'] = 32
+    kwargs['width_per_group'] = 8
+    return _resnet('resnext101_32x8d', Bottleneck, [3, 4, 23, 3], pretrained, progress, quantize, **kwargs)
+
+
+def wide_resnet50_2(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""Wide ResNet-50-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_.
+
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet50_2', Bottleneck, [3, 4, 6, 3], pretrained, progress, quantize, **kwargs)
+
+
+def wide_resnet101_2(pretrained: bool = False, progress: bool = True, quantize: bool = False, **kwargs: Any) -> ResNet:
+    r"""Wide ResNet-101-2 model from
+    `"Wide Residual Networks" <https://arxiv.org/pdf/1605.07146.pdf>`_.
+
+    The model is the same as ResNet except for the bottleneck number of channels
+    which is twice larger in every block. The number of channels in outer 1x1
+    convolutions is the same, e.g. last block in ResNet-50 has 2048-512-2048
+    channels, and in Wide ResNet-50-2 has 2048-1024-2048.
+
+    Args:
+        pretrained (bool): If True, returns a model pre-trained on ImageNet
+        progress (bool): If True, displays a progress bar of the download to stderr
+    """
+    kwargs['width_per_group'] = 64 * 2
+    return _resnet('wide_resnet101_2', Bottleneck, [3, 4, 23, 3], pretrained, progress, quantize, **kwargs)