Пример #1
0
def inference(opt):
    device = check_envirionment(opt.use_cuda)
    model = load_test_model(opt, device)

    audio_paths, script_paths = load_data_list(opt.data_list_path, opt.dataset_path)
    target_dict = load_targets(script_paths)

    testset = SpectrogramDataset(audio_paths=audio_paths, script_paths=script_paths,  sos_id=SOS_token, eos_id=EOS_token,
                                 target_dict=target_dict,  opt=opt, spec_augment=False, noise_augment=False)

    evaluator = Evaluator(testset, opt.batch_size, device, opt.num_workers, opt.print_every, opt.decode, opt.k)
    evaluator.evaluate(model)
Пример #2
0
def split_dataset(opt, audio_paths, script_paths):
    """
    split into training set and validation set.

    Args:
        opt (ArgumentParser): set of options
        audio_paths (list): set of audio path
        script_paths (list): set of script path

    Returns: train_batch_num, train_dataset_list, valid_dataset
        - **train_time_step** (int): number of time step for training
        - **trainset_list** (list): list of training dataset
        - **validset** (data_loader.MelSpectrogramDataset): validation dataset
    """
    target_dict = load_targets(script_paths)

    logger.info("split dataset start !!")
    trainset_list = list()
    train_num = math.ceil(len(audio_paths) * (1 - opt.valid_ratio))
    total_time_step = math.ceil(len(audio_paths) / opt.batch_size)
    valid_time_step = math.ceil(total_time_step * opt.valid_ratio)
    train_time_step = total_time_step - valid_time_step
    base_time_step = train_time_step

    if opt.spec_augment:
        train_time_step += base_time_step

    if opt.noise_augment:
        train_time_step += base_time_step

    train_num_per_worker = math.ceil(train_num / opt.num_workers)

    # audio_paths & script_paths shuffled in the same order
    # for seperating train & validation
    tmp = list(zip(audio_paths, script_paths))
    random.shuffle(tmp)
    audio_paths, script_paths = zip(*tmp)

    # seperating the train dataset by the number of workers
    for idx in range(opt.num_workers):
        train_begin_idx = train_num_per_worker * idx
        train_end_idx = min(train_num_per_worker * (idx + 1), train_num)

        trainset_list.append(
            SpectrogramDataset(audio_paths[train_begin_idx:train_end_idx],
                               script_paths[train_begin_idx:train_end_idx],
                               SOS_token,
                               EOS_token,
                               target_dict=target_dict,
                               opt=opt,
                               spec_augment=opt.spec_augment,
                               noise_augment=opt.noise_augment,
                               dataset_path=opt.dataset_path,
                               noiseset_size=opt.noiseset_size,
                               noise_level=opt.noise_level))

    validset = SpectrogramDataset(audio_paths=audio_paths[train_num:],
                                  script_paths=script_paths[train_num:],
                                  sos_id=SOS_token,
                                  eos_id=EOS_token,
                                  target_dict=target_dict,
                                  opt=opt,
                                  spec_augment=False,
                                  noise_augment=False)

    logger.info("split dataset complete !!")
    return train_time_step, trainset_list, validset