def METHOD_NAME():
    # Parse Arguments
    parser = argparse.ArgumentParser(description='TTS Generator')
    parser.add_argument('--mel', type=str, help='[string/path] path to test mel file')
    parser.add_argument('--hp_file', metavar='FILE', default='hparams.py',
                        help='The file to use for the hyperparameters')
    parser.add_argument('--batched', '-b', dest='batched', action='store_true', help='Fast Batched Generation')
    parser.add_argument('--voc_weights', type=str, help='[string/path] Load in different FastSpeech weights', default="pretrained/wave_800K.pyt")
    args = parser.parse_args()
    if not os.path.exists('onnx'):
        os.mkdir('onnx')
    hp.configure(args.hp_file)
    device = torch.device('cpu')
    print('Using device:', device)
    #####
    print('\nInitialising WaveRNN Model...\n')
    # Instantiate WaveRNN Model
    voc_model = WaveRNN(rnn_dims=hp.voc_rnn_dims,
                        fc_dims=hp.voc_fc_dims,
                        bits=hp.bits,
                        pad=hp.voc_pad,
                        upsample_factors=hp.voc_upsample_factors,
                        feat_dims=hp.num_mels,
                        compute_dims=hp.voc_compute_dims,
                        res_out_dims=hp.voc_res_out_dims,
                        res_blocks=hp.voc_res_blocks,
                        hop_length=hp.hop_length,
                        sample_rate=hp.sample_rate,
                        mode=hp.voc_mode).to(device)
    voc_load_path = args.voc_weights
    voc_model.load(voc_load_path)
    voc_upsampler = WaveRNNUpsamplerONNX(voc_model, args.batched, hp.voc_target, hp.voc_overlap)
    voc_infer = WaveRNNONNX(voc_model)
    voc_model.eval()
    voc_upsampler.eval()
    voc_infer.eval()
    opset_version = 11
    with torch.no_grad():
        mels = np.load(args.mel)
        mels = torch.from_numpy(mels)
        mels = mels.unsqueeze(0)
        mels = voc_upsampler.pad_tensor(mels)
        mels_onnx = mels.clone()
        torch.onnx.export(voc_upsampler, mels_onnx, "./onnx/wavernn_upsampler.onnx",
                          opset_version=opset_version,
                          do_constant_folding=True,
                          input_names=["mels"],
                          output_names=["upsample_mels", "aux"])
        mels, aux = voc_upsampler(mels)
        mels = mels[:, 550:-550, :]
        mels, aux = voc_upsampler.fold(mels, aux)
        h1, h2, x = voc_infer.get_initial_parameters(mels)
        aux_split = voc_infer.split_aux(aux)
        b_size, seq_len, _ = mels.size()
        if seq_len:
            m_t = mels[:, 0, :]
            a1_t, a2_t, a3_t, a4_t = \
                (a[:, 0, :] for a in aux_split)
            rnn_input = (m_t, a1_t, a2_t, a3_t, a4_t, h1, h2, x)
            torch.onnx.export(voc_infer, rnn_input, "./onnx/wavernn_rnn.onnx",
                              opset_version=opset_version,
                              do_constant_folding=True,
                              input_names=["m_t", "a1_t", "a2_t", "a3_t", "a4_t", "h1", "h2", "x"],
                              output_names=["logits", "h1", "h2"])
    print('Done!')