def METHOD_NAME():
    args = parser.parse_args()
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    bundle = model_dict[args.model]
    model = bundle.get_model().to(device)
    logger.info("Sample Rate:", bundle.sample_rate)
    logger.info("Labels:", bundle.get_labels())
    logger.info(model.__class__)
    #prepare dataset
    dataset = torchaudio.datasets.LIBRISPEECH(args.root, args.url, args.folder_in_archive)
    val_dataloader = torch.utils.data.DataLoader(dataset, batch_size=args.batch_size, shuffle=True)
    decoder = GreedyCTCDecoder(labels=bundle.get_labels())
    def eval_func(model):
        predict = []
        text = []
        with torch.inference_mode():
            for index, wave in enumerate(val_dataloader):
                emission, _ = model(wave[0][0])
                transcript = decoder(emission[0])
                predict.append(transcript)
                text.append(wave[2][0])
                prediction = [pre.replace("|", " ")for pre in predict]
                WER = wer(text, prediction)
            print("Accuracy: %.5f" % (1-WER))
        return 1-WER
    #tune
    if args.tune:
        def calib_func(model):
            for index, wave in enumerate(val_dataloader):
                model(wave[0][0])
                if index == 100:
                    break
        from neural_compressor import PostTrainingQuantConfig, quantization
        for index, wave in enumerate(val_dataloader):
            example_inputs = wave[0][0]
            break
        conf = PostTrainingQuantConfig(approach="static",
                                       example_inputs=example_inputs)
        q_model = quantization.fit(model,
                                   conf=conf,
                                   eval_func=eval_func,
                                   calib_func=calib_func,
                                   calib_dataloader=val_dataloader
                                   )
        q_model.save(args.tuned_checkpoint)
        exit(0)
    #benchmark
    if args.int8:
        from neural_compressor.utils.pytorch import load
        model = load(
                os.path.abspath(os.path.expanduser(args.tuned_checkpoint)), model)
    if args.benchmark:
        def b_func(model):
            predict = []
            text = []
            results = {}
            batch_time = AverageMeter('Time', ':6.3f')
            with torch.inference_mode():
                for i, wave in enumerate(val_dataloader): 
                    if i >= args.warmup_iter:
                        start = time.time()
                    emission, _ = model(wave[0][0])
                    transcript = decoder(emission[0])
                    # measure elapsed time
                    if i >= args.warmup_iter:
                        batch_time.update(time.time() - start)
                    predict.append(transcript)
                    text.append(wave[2][0])
                    if args.iters > 0 and i >= (args.warmup_iter + args.iters - 1):
                        break
                prediction = [pre.replace("|", " ")for pre in predict]
                WER = wer(text, prediction)
            results['WER'] = WER
            results['accuracy'] = 1 - WER
            results['average_batch_time'] = batch_time.avg
            print("Accuracy: %.5f" % results['accuracy'])
            print('Latency: %.3f ms' % (results['average_batch_time'] * 1000))
            print('Throughput: %.3f images/sec' % (args.batch_size / results['average_batch_time']))
            print('Batch size = %d' % args.batch_size)
            return results['accuracy']
        from neural_compressor.config import BenchmarkConfig
        from neural_compressor import benchmark
        b_conf = BenchmarkConfig(
                                 cores_per_instance=4,
                                 num_of_instance=1
                                 )
        benchmark.fit(model, b_conf, b_func=b_func)
        exit(0)
    if args.accuracy_only:
        eval_func(model)
        exit(0)