예제 #1
0
 def save_model(model, model_path, model_name):
     torch.save(ModelSerializer.convert_param_to_cpu(model.state_dict()),
                os.path.join(model_path, '{}.mdl'.format(model_name)))
     ModelSerializer.save_config(
         os.path.join(model_path, '{}.cfg'.format(model_name)),
         model.get_config())
     json.dump(opts,
               open(os.path.join(opts['result'], 'script.opts'), 'w'),
               indent=2)
 def save_model(model, name, epoch) :
     torch.save(ModelSerializer.convert_param_to_cpu(model.state_dict()), os.path.join(opts['result'], 'model_{}_e{}.mdl'.format(name, epoch)))
     ModelSerializer.save_config(os.path.join(opts['result'], 'model_{}_e{}.cfg'.format(name, epoch)), model.get_config())
     pass
예제 #3
0
    feat_iterator = DataLoader.load_feat(data_cfg,
                                         data_type=LoaderDataType.TYPE_NP,
                                         in_memory=opts['mem'])
    text_iterator = DataLoader.load_text(data_cfg)

    feat_stat = pickle.load(open(data_cfg['feat']['stat'], 'rb'))
    feat_sil = feat_sil_from_stat(feat_stat)

    print("Finish loading dataset ...")

    NDIM = feat_iterator['train'].get_feat_dim() * group
    NVOCAB = len(text_iterator['train'].get_map_text2idx())

    if opts['model_pt'] is not None:
        model = ModelSerializer.load_config(
            os.path.join(opts['model_pt'], 'model.cfg'))
        model.load_state_dict(
            torch.load(os.path.join(opts['model_pt'], 'model.mdl')))
        assert model.TYPE in [
            TacotronType.SINGLE_SPEAKER, TacotronType.MULTI_SPEAKER
        ]
        print('[info] load pretrained model')
    else:
        _model_cfg = opts['model_cfg']
        _model_cfg['enc_in_size'] = NVOCAB
        _model_cfg['dec_in_size'] = NDIM
        _model_cfg['dec_out_size'] = NDIM
        model = ModelSerializer.load_config(_model_cfg)
        assert model.TYPE in [
            TacotronType.SINGLE_SPEAKER, TacotronType.MULTI_SPEAKER
        ]
예제 #4
0
def invert_mel_to_linear(model, feat_mat, feat_len, group=1):
    # model.reset()
    model.eval()
    pred_out = model(feat_mat, feat_len)
    return pred_out


if __name__ == '__main__':
    opts = vars(parse())

    feat_cfg = json.load(open(opts['feat_cfg']))
    # load model structure and weight #
    if opts['config'] is None:
        opts['config'] = os.path.splitext(opts['model'])[0] + '.cfg'

    model = ModelSerializer.load_config(opts['config'])
    model.train(False)
    model.load_state_dict(torch.load(opts['model']))

    # tacotron util helper #
    helper = TacotronHelper(feat_cfg)

    if opts['gpu'] >= 0:
        torch.cuda.set_device(opts['gpu'])
        model.cuda()

    data_cfg_target = yaml.load(open(opts['data_cfg_tgt']))
    data_iterator_target = DataLoader.load_feat_single(
        feat_path=data_cfg_target['feat']['all'])

    data_cfg_source = yaml.load(open(opts['data_cfg_src']))
예제 #5
0
    data_cfg = yaml.load(open(opts['data_cfg']))
    feat_iterator = DataLoader.load_feat(data_cfg,
                                         data_type=LoaderDataType.TYPE_NP,
                                         in_memory=opts['mem'])
    text_iterator = DataLoader.load_text(data_cfg)

    print("Finish loading dataset ...")

    NDIM = feat_iterator['train'].get_feat_dim()
    NVOCAB = len(text_iterator['train'].get_map_text2idx())
    if opts['model_pt'] is not None:
        assert opts['model_pt'].endswith(
            '.mdl'), 'model pretrained should have *.mdl file extension'
        _model_state_path = opts['model_pt']
        _model_cfg_path = os.path.splitext(opts['model_pt'])[0] + '.cfg'
        model = ModelSerializer.load_config(_model_cfg_path)
        model.load_state_dict(torch.load(_model_state_path))

        print('[info] load pretrained model')

        # additional #
        if opts['result'].startswith('+'):
            opts['result'] = os.path.dirname(
                opts['model_pt']) + opts['result'][1:]
            print('[info] append pretrained folder name to result')
    else:
        _model_cfg = opts['model_cfg']
        _model_cfg['enc_in_size'] = NDIM
        _model_cfg['dec_in_size'] = NVOCAB
        _model_cfg['dec_out_size'] = NVOCAB
        model = ModelSerializer.load_config(_model_cfg)
예제 #6
0
    )
    return parser.parse_args()


if __name__ == '__main__':
    args = parse()
    assert (args.chunk is None) != (args.chunkblk is None)

    # init logger #
    logging.basicConfig(level=logging.INFO)
    logger = logging.getLogger(__name__)

    # load model structure and weight #
    if args.config is None:
        args.config = os.path.splitext(args.model)[0] + '.cfg'
    model = ModelSerializer.load_config(args.config)
    model.train(False)
    model.load_state_dict(torch.load(args.model))

    if args.gpu >= 0:
        torch.cuda.set_device(args.gpu)
        model.cuda()

    # laod dict and feature scaler #
    data_cfg = yaml.load(open(args.data_cfg))

    map_text2idx = json.load(open(data_cfg['text']['vocab']))
    map_idx2text = dict([(y, x) for (x, y) in map_text2idx.items()])

    scaler = pickle.load(open(
        data_cfg['feat']['scaler'], 'rb')) if data_cfg['feat'].get(
예제 #7
0
        vocab=map_text2idx)
    DataLoader._check_intersect(list(feat_iterator.values()))
    DataLoader._check_intersect(list(text_iterator.values()))
    assert text_iterator['train'].get_map_text2idx(
    ) == text_iterator['unpair'].get_map_text2idx()

    feat_stat = pickle.load(open(data_pair_cfg['feat']['stat'], 'rb'))
    feat_sil = feat_sil_from_stat(feat_stat)

    NVOCAB = len(text_iterator['train'].get_map_text2idx())
    NDIM_FEAT = feat_iterator['train'].get_feat_dim()

    printe("Finish loading dataset ...")

    # load model #
    model_asr = ModelSerializer.load_config_and_state(
        filename_state=opts['asr_model_pt'])
    model_tts = ModelSerializer.load_config_and_state(
        filename_state=opts['tts_model_pt'])

    if opts['tts_loss_spk_emb'] is not None:
        model_spkrec = ModelSerializer.load_config_and_state(
            filename_state=opts['spkrec_model_pt'])
    else:
        model_spkrec = None

    if opts['gpu'] >= 0:
        model_asr.cuda(opts['gpu'])
        model_tts.cuda(opts['gpu'])
        if opts['tts_loss_spk_emb'] is not None:
            model_spkrec.cuda(opts['gpu'])