init

G_157000.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87e9b24e8cd7987f493629494018da15d4a4cbb34b1b788f3291a63851b2aaa1
+size 143295815

app.py

@@ -0,0 +1,99 @@
+import io
+import json
+import  os
+import gradio as gr
+import librosa
+import numpy as np
+import soundfile
+import torch
+import logging
+
+from egs.visinger2.models import SynthesizerTrn
+from infer import infer_ds
+from utils import utils
+
+logging.getLogger('numba').setLevel(logging.WARNING)
+logging.getLogger('markdown_it').setLevel(logging.WARNING)
+logging.getLogger('urllib3').setLevel(logging.WARNING)
+logging.getLogger('matplotlib').setLevel(logging.WARNING)
+
+config_json = "egs/visinger2/config.json"
+model_path = "G_157000.pth"
+
+
+hps = utils.get_hparams_from_file(config_json)
+net_g = SynthesizerTrn(hps)
+_ = net_g.eval()
+_ = utils.load_checkpoint(model_path, net_g, None)
+
+def vc_fn(speaker, ds, vc_transform):
+    try:
+        ds = json.loads(ds)
+    except:
+        return "工程文件json解析失败，请将ds文件的完整内容粘贴与此处", None
+
+    dur = 0
+    flag = False
+    try:
+        for inp in ds:
+            f0_seq = inp["f0_seq"]
+            ph_dur = inp["ph_dur"]
+            ph_dur= [float(i) for i in ph_dur.split(" ")]
+            f0_seq = [float(i) for i in f0_seq.split(" ")]
+            dur+=sum(ph_dur)
+            if sum(ph_dur) >30:
+                flag = True
+    except:
+        return "ds工程需要冻结f0和音素参数才能使用此模型合成", None
+    if flag:
+        return "单个切片时长必须小于30s，否则请使用本地推理", None
+    if dur>120:
+        return "总时长需要小于2分钟，否则请使用本地推理", None
+    out_audio = infer_ds(net_g, hps, ds, speaker, vc_transform)
+    # return "请上传小于45s的音频，需要转换长音频请本地进行转换", None
+    # out_audio, out_sr = inference_main.infer(sid, out_wav_path, model_map[model], vc_transform)
+    # _audio = out_audio.cpu().numpy()
+    return "Success", (44100, out_audio.astype(np.float32))
+
+
+app = gr.Blocks()
+with app:
+    with gr.Tabs():
+        with gr.TabItem("Basic"):
+            gr.Markdown(value="""
+                这是visinger2 塔菲、电棍模型的在线demo, github 仓库地址是[visinger2-nomidi](https://github.com/innnky/VISinger2-nomidi)
+                
+                由于训练集为录播数据全自动化制作，因此质量比较差，此模型并非visinger2的音质上限，最高质量模型效果请参照[VISinger2官方demo](https://zhangyongmao.github.io/VISinger2/)
+
+                其中ds工程文件为[DiffSinger](https://github.com/openvpi/DiffSinger)工程，需要通过[OpenSVIP](https://openvpi.github.io/) 转换器进行制作，原理是先通过别的歌声合成软件制作工程并转换为模型能够接受的输入格式。
+                
+                由于此模型是nomidi模型，因此导出ds工程时需要冻结音素和音高参数, 否则会报错，具体DiffSinger工程制作详细问题可以加入DiffSinger QQ交流群 907879266
+                
+                在线推理限制为总时长小于2分钟，且单个切片时长小于30s，有更大需求请下载本仓库或github仓库代码运行ds_inference.py进行本地推理
+                """)
+            sid = gr.Dropdown(label="音色", choices=["taffy", "otto"], value="taffy")
+            vc_input3 = gr.TextArea(label="ds工程（json格式）",value='''[
+                  {
+                "text": "SP 清 晨 SP",
+                "ph_seq": "SP q ing ch en SP",
+                "note_seq": "rest D4 D4 G4 G4 rest",
+                "note_dur_seq": "0.6 0.273 0.273 0.4089999 0.4089999 0.4",
+                "is_slur_seq": "0 0 0 0 0 0",
+                "ph_dur": "0.469318 0.130682 0.120727 0.152273 0.409 0.4",
+                "f0_timestep": "0.005",
+                "f0_seq": "301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 302.0 302.4 301.9 301.4 300.5 299.4 299.0 298.3 297.9 297.6 297.2 297.2 297.0 296.8 296.9 296.7 296.6 296.8 296.9 296.9 297.4 297.6 297.7 298.2 298.5 298.3 298.6 298.7 298.5 298.6 298.3 297.8 296.4 293.9 291.5 286.7 283.2 279.6 278.5 283.4 288.4 293.5 298.6 303.9 309.3 314.7 320.3 325.9 331.7 337.5 343.5 349.5 355.7 362.0 368.3 374.8 381.5 387.1 388.7 391.3 393.6 396.1 397.7 398.7 399.3 399.6 399.8 399.4 399.0 398.6 397.9 397.7 397.1 396.7 396.1 396.0 395.4 395.6 395.7 395.9 395.9 396.1 396.4 396.8 397.0 397.3 397.5 397.5 397.5 397.7 397.7 397.7 397.7 397.9 397.7 397.7 397.7 397.7 397.7 397.7 397.5 397.5 397.2 397.0 397.0 396.7 396.6 396.6 396.5 396.3 396.3 396.1 396.1 396.3 396.3 396.1 396.3 396.3 396.4 396.6 396.7 396.6 396.9 397.2 396.8 397.4 397.9 398.0 398.5 399.1 399.1 399.1 399.0 398.7 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2",
+                "input_type": "phoneme",
+                "offset": 0.0
+              }
+            ]''')
+            vc_transform = gr.Number(label="变调（整数，可以正负，半音数量，升高八度就是12）", value=0)
+            # model = gr.Dropdown(label="模型", choices=list(model_map.keys()), value="G_34000.pth")
+            vc_submit = gr.Button("合成", variant="primary")
+            vc_output1 = gr.Textbox(label="Output Message")
+            vc_output2 = gr.Audio(label="Output Audio")
+        vc_submit.click(vc_fn, [sid, vc_input3, vc_transform], [vc_output1, vc_output2])
+
+    app.launch()
+
+
+

ds_inference.py

@@ -0,0 +1,33 @@
+import json
+import os
+import time
+import re
+
+import numpy as np
+import soundfile
+import torch
+import tqdm
+from scipy.interpolate import interp1d
+
+from utils import utils
+from egs.visinger2.models import SynthesizerTrn
+from infer import preprocess, cross_fade, infer_ds
+
+trans = -12
+speaker = "otto"
+ds_path = "infer/share.ds"
+config_json = "egs/visinger2/config.json"
+checkpoint_path = f"/Volumes/Extend/下载/G_110000.pth"
+file_name = os.path.splitext(os.path.basename(ds_path))[0]
+step = re.findall(r'G_(\d+)\.pth', checkpoint_path)[0]
+
+
+if __name__ == '__main__':
+    ds = json.load(open(ds_path))
+    hps = utils.get_hparams_from_file(config_json)
+    net_g = SynthesizerTrn(hps)
+    _ = net_g.eval()
+    _ = utils.load_checkpoint(checkpoint_path, net_g, None)
+
+    audio = infer_ds(net_g, hps, ds, speaker, trans)
+    soundfile.write(f"{speaker}_{file_name}_{step}step.wav", audio, 44100)

egs/visinger2/bash/train.sh

@@ -0,0 +1,13 @@
+
+num_gpu=$1
+
+cd $(dirname $(dirname $0))
+exp_dir=$(pwd)
+base_dir=$(dirname $(dirname $exp_dir))
+config=${exp_dir}/config.json
+
+export PYTHONPATH=$base_dir
+export PYTHONIOENCODING=UTF-8
+
+CUDA_VISIBLE_DEVICES=${num_gpu} python train.py -c config.json
+

egs/visinger2/config.json

@@ -0,0 +1,68 @@
+{
+  "train": {
+    "log_interval": 200,
+    "eval_interval": 1000,
+    "seed": 1234,
+    "port": 8001,
+    "epochs": 10000,
+    "learning_rate": 2e-4,
+    "betas": [0.8, 0.99],
+    "eps": 1e-9,
+    "batch_size": 8,
+    "accumulation_steps": 1,
+    "fp16_run": false,
+    "lr_decay": 0.998,
+    "segment_size": 10240,
+    "init_lr_ratio": 1,
+    "warmup_epochs": 0,
+    "c_mel": 45,
+    "save_dir": "logdir/visinger2"
+  },
+  "data": {
+    "data_dir":"../../data",
+    "dataset_type": "SingDataset",
+    "collate_type": "SingCollate",
+    "training_filelist":"train.list",
+    "training_labellist":"transcriptions.txt",
+    "validation_filelist":"test.list",
+    "validation_labellist":"transcriptions.txt",
+    "max_wav_value": 32768.0,
+    "sample_rate": 44100,
+    "n_fft": 2048,
+    "fmin": 0,
+    "fmax": 22050,
+    "hop_size": 512,
+    "win_size": 2048,
+    "acoustic_dim": 80,
+    "min_level_db": -115,
+    "ref_level_db": 20,
+    "min_db": -115,
+    "max_abs_value": 4.0,
+    "n_speakers": 200,
+    "spk2id": {"opencpop": 0, "taffy": 1, "otto": 2, "nanami": 3}
+  },
+  "model": {
+    "hidden_channels": 192,
+    "spk_channels": 192,
+    "filter_channels": 768,
+    "n_heads": 2,
+    "n_layers": 4,
+    "kernel_size": 3,
+    "p_dropout": 0.1,
+    "prior_hidden_channels": 192,
+    "prior_filter_channels": 768,
+    "prior_n_heads": 2,
+    "prior_n_layers": 4,
+    "prior_kernel_size": 3,
+    "prior_p_dropout": 0.1,
+    "resblock": "1",
+    "use_spectral_norm": false,
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [8,8,4,2],
+    "upsample_initial_channel": 256,
+    "upsample_kernel_sizes": [16,16,8,4],
+    "n_harmonic": 64,
+    "n_bands": 65
+  }
+}

egs/visinger2/dataset.py

@@ -0,0 +1,334 @@
+
+import os
+import sys
+import string
+import random
+import numpy as np
+import math
+import json
+from torch.utils.data import DataLoader
+import torch
+
+sys.path.append('../..')
+from utils.audio import load_wav
+from text import npu
+
+class BaseDataset(torch.utils.data.Dataset):
+
+    def __init__(self, hparams, fileid_list_path):
+        self.hparams = hparams
+        self.fileid_list = self.get_fileid_list(fileid_list_path)
+        random.seed(hparams.train.seed)
+        random.shuffle(self.fileid_list)
+        if(hparams.data.n_speakers > 0):
+            self.spk2id = hparams.data.spk2id
+
+    def get_fileid_list(self, fileid_list_path):
+        fileid_list = []
+        with open(fileid_list_path, 'r') as f:
+            for line in f.readlines():
+                fileid_list.append(line.strip())
+
+        return fileid_list
+
+    def __len__(self):
+        return len(self.fileid_list)
+
+class SingDataset(BaseDataset):
+    def __init__(self, hparams, data_dir, fileid_list_path, label_list_path):
+        BaseDataset.__init__(self, hparams, os.path.join(data_dir, fileid_list_path))
+        self.hps = hparams
+
+        with open(os.path.join(data_dir, label_list_path), "r") as in_file:
+            self.id2label = {}
+            for line in in_file.readlines():
+                fileid, txt, phones, pitchid, dur, gtdur, slur = line.split('|')
+                self.id2label[fileid] = [phones, pitchid, dur, slur, gtdur]
+
+        self.data_dir = data_dir
+        # self.__filter__()
+
+    def __filter__(self):
+        new_fileid_list = []
+        print("before filter: ", len(self.fileid_list))
+        for file_id in self.fileid_list:
+            _is_qualified = True
+            if(not os.path.exists(os.path.join(self.label_dir, self.fileid_list[index] + '.lab')) or 
+                not os.path.exists(os.path.join(self.dur_dir, self.fileid_list[index] + '.lab')) or 
+                not os.path.exists(os.path.join(self.mel_dir, self.fileid_list[index] + '.npy')) or 
+                not os.path.exists(os.path.join(self.pitch_dir, self.fileid_list[index] + '.npy'))):
+                _is_qualified = False
+            if(_is_qualified):
+                new_fileid_list.append(file_id)
+        self.fileid_list = new_fileid_list
+        print("after filter: ", len(self.fileid_list))
+
+    def interpolate_f0(self, data):
+        '''
+        对F0进行插值处理
+        '''
+        data = np.reshape(data, (data.size, 1))
+
+        vuv_vector = np.zeros((data.size, 1),dtype=np.float32)
+        vuv_vector[data > 0.0] = 1.0
+        vuv_vector[data <= 0.0] = 0.0
+
+        ip_data = data
+
+        frame_number = data.size
+        last_value = 0.0
+        for i in range(frame_number):
+            if data[i] <= 0.0:
+                j = i + 1
+                for j in range(i + 1, frame_number):
+                    if data[j] > 0.0:
+                        break
+                if j < frame_number - 1:
+                    if last_value > 0.0:
+                        step = (data[j] - data[i - 1]) / float(j - i)
+                        for k in range(i, j):
+                            ip_data[k] = data[i - 1] + step * (k - i + 1)
+                    else:
+                        for k in range(i, j):
+                            ip_data[k] = data[j]
+                else:
+                    for k in range(i, frame_number):
+                        ip_data[k] = last_value
+            else:
+                ip_data[i] = data[i]
+                last_value = data[i]
+
+        return ip_data, vuv_vector
+
+    def parse_label(self, pho, pitchid, dur, slur, gtdur):
+        phos = []
+        pitchs = []
+        durs = []
+        slurs = []
+        gtdurs = []
+
+        for index in range(len(pho.split())):
+            phos.append(npu.symbol_converter.ttsing_phone_to_int[pho.strip().split()[index]])
+            pitchs.append(0)
+            durs.append(0)
+            slurs.append(0)
+            gtdurs.append(float(gtdur.strip().split()[index]))
+
+        phos = np.asarray(phos, dtype=np.int32)
+        pitchs = np.asarray(pitchs, dtype=np.int32)
+        durs = np.asarray(durs, dtype=np.float32)
+        slurs = np.asarray(slurs, dtype=np.int32)
+        gtdurs = np.asarray(gtdurs, dtype=np.float32)
+
+        acc_duration = np.cumsum(gtdurs)
+        acc_duration = np.pad(acc_duration, (1, 0), 'constant', constant_values=(0,))
+        acc_duration_frames = np.ceil(acc_duration / (self.hps.data.hop_size / self.hps.data.sample_rate))
+        gtdurs = acc_duration_frames[1:] - acc_duration_frames[:-1]
+
+        phos = torch.LongTensor(phos)
+        pitchs = torch.LongTensor(pitchs)
+        durs = torch.FloatTensor(durs)
+        slurs = torch.LongTensor(slurs)
+        gtdurs = torch.LongTensor(gtdurs)
+        return phos, pitchs, durs, slurs, gtdurs
+
+    def __getitem__(self, index):
+
+        pho, pitchid, dur, slur, gtdur = self.id2label[self.fileid_list[index]]
+        pho, pitchid, dur, slur, gtdur = self.parse_label(pho, pitchid, dur, slur, gtdur)
+        sum_dur = gtdur.sum()
+        spk, fileid = self.fileid_list[index].split("/")
+        spkid = self.spk2id[spk]
+        mel = np.load(os.path.join(self.data_dir, spk, "mels", fileid + '.npy'))
+        if mel.shape[0] <150:
+            print("drop short audio:", self.fileid_list[index])
+            return None
+        assert mel.shape[1] == 80
+        if(mel.shape[0] != sum_dur):
+            if(abs(mel.shape[0] - sum_dur) > 3):
+                print("dataset error mel: ",mel.shape, sum_dur)
+                return None
+            if(mel.shape[0] > sum_dur):
+                mel = mel[:sum_dur]
+            else:
+                mel = np.concatenate([mel, mel.min() * np.ones([sum_dur - mel.shape[0], self.hps.data.acoustic_dim])], axis=0)
+        mel = torch.FloatTensor(mel).transpose(0, 1)
+
+        f0 = np.load(os.path.join(self.data_dir, spk, "pitch", fileid + '.npy')).reshape([-1])
+        f0, _ = self.interpolate_f0(f0)
+        f0 = f0.reshape([-1])
+        if(f0.shape[0] != sum_dur):
+            if(abs(f0.shape[0] - sum_dur) > 3):
+                print("dataset error f0 : ",f0.shape, sum_dur)
+                return None
+            if(f0.shape[0] > sum_dur):
+                f0 = f0[:sum_dur]
+            else:
+                f0 = np.concatenate([f0, np.zeros([sum_dur - f0.shape[0]])], axis=0)
+        f0 = torch.FloatTensor(f0).reshape([1, -1])
+
+        wav = load_wav(os.path.join(self.data_dir, spk, "wavs", fileid + '.wav'),
+                       raw_sr=self.hparams.data.sample_rate,
+                       target_sr=self.hparams.data.sample_rate,
+                       win_size=self.hparams.data.win_size,
+                       hop_size=self.hparams.data.hop_size)
+        wav = wav.reshape(-1)
+        if(wav.shape[0] != sum_dur * self.hparams.data.hop_size):
+            if(abs(wav.shape[0] - sum_dur * self.hparams.data.hop_size) > 3 * self.hparams.data.hop_size):
+                print("dataset error wav : ", wav.shape, sum_dur)
+                return None
+            if(wav.shape[0] > sum_dur * self.hparams.data.hop_size):
+                wav = wav[:sum_dur * self.hparams.data.hop_size]
+            else:
+                wav = np.concatenate([wav, np.zeros([sum_dur * self.hparams.data.hop_size - wav.shape[0]])], axis=0)
+        wav = torch.FloatTensor(wav).reshape([1, -1])
+
+        return pho, pitchid, dur, slur, gtdur, mel, f0, wav, spkid
+
+
+class SingCollate():
+
+    def __init__(self, hparams):
+        self.hparams = hparams
+        self.mel_dim = self.hparams.data.acoustic_dim
+
+    def __call__(self, batch):
+        
+        batch = [b for b in batch if b is not None]
+
+        input_lengths, ids_sorted_decreasing = torch.sort(
+            torch.LongTensor([len(x[0]) for x in batch]),
+            dim=0, descending=True)
+        
+        max_phone_len = max([len(x[0]) for x in batch])
+        max_pitchid_len = max([len(x[1]) for x in batch])
+        max_dur_len = max([len(x[2]) for x in batch])
+        max_slur_len = max([len(x[3]) for x in batch])
+        max_gtdur_len = max([len(x[4]) for x in batch])
+        max_mel_len = max([x[5].size(1) for x in batch])
+        max_f0_len = max([x[6].size(1) for x in batch])
+        max_wav_len = max([x[7].size(1) for x in batch])
+
+        phone_lengths = torch.LongTensor(len(batch))
+        pitchid_lengths = torch.LongTensor(len(batch))
+        dur_lengths = torch.LongTensor(len(batch))
+        slur_lengths = torch.LongTensor(len(batch))
+        gtdur_lengths = torch.LongTensor(len(batch))
+        mel_lengths = torch.LongTensor(len(batch))
+        f0_lengths = torch.LongTensor(len(batch))
+        wav_lengths = torch.LongTensor(len(batch))
+
+        phone_padded = torch.LongTensor(len(batch), max_phone_len)
+        pitchid_padded = torch.LongTensor(len(batch), max_pitchid_len)
+        dur_padded = torch.FloatTensor(len(batch), max_dur_len)
+        slur_padded = torch.LongTensor(len(batch), max_slur_len)
+        gtdur_padded = torch.LongTensor(len(batch), 1, max_gtdur_len)
+        mel_padded = torch.FloatTensor(len(batch), self.hparams.data.acoustic_dim, max_mel_len)
+        f0_padded = torch.FloatTensor(len(batch), 1, max_f0_len)
+        wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
+        spkids = torch.LongTensor(len(batch))
+
+        phone_padded.zero_()
+        pitchid_padded.zero_()
+        dur_padded.zero_()
+        slur_padded.zero_()
+        gtdur_padded.zero_()
+        mel_padded.zero_()
+        f0_padded.zero_()
+        wav_padded.zero_()
+        
+        for i in range(len(ids_sorted_decreasing)):
+            row = batch[ids_sorted_decreasing[i]]
+
+            phone = row[0]
+            phone_padded[i, :phone.size(0)] = phone
+            phone_lengths[i] = phone.size(0)
+
+            pitchid = row[1]
+            pitchid_padded[i, :pitchid.size(0)] = pitchid
+            pitchid_lengths[i] = pitchid.size(0)
+
+            dur = row[2]
+            dur_padded[i, :dur.size(0)] = dur
+            dur_lengths[i] = dur.size(0)
+
+            slur = row[3]
+            slur_padded[i, :slur.size(0)] = slur
+            slur_lengths[i] = slur.size(0)
+
+            gtdur = row[4]
+            gtdur_padded[i, :, :gtdur.size(0)] = gtdur
+            gtdur_lengths[i] = gtdur.size(0)
+
+            mel = row[5]
+            mel_padded[i, :, :mel.size(1)] = mel
+            mel_lengths[i] = mel.size(1)
+            
+            f0 = row[6]
+            f0_padded[i, :, :f0.size(1)] = f0
+            f0_lengths[i] = f0.size(1)
+
+            wav = row[7]
+            wav_padded[i, :, :wav.size(1)] = wav
+            wav_lengths[i] = wav.size(1)
+
+            spkids[i] = row[8]
+
+        data_dict = {}
+        data_dict["phone"] = phone_padded
+        data_dict["phone_lengths"] = phone_lengths
+        data_dict["pitchid"] = pitchid_padded
+        data_dict["dur"] = dur_padded
+        data_dict["slur"] = slur_padded
+        data_dict["gtdur"] = gtdur_padded
+        data_dict["mel"] = mel_padded
+        data_dict["f0"] = f0_padded
+        data_dict["wav"] = wav_padded
+
+        data_dict["mel_lengths"] = mel_lengths
+        data_dict["f0_lengths"] = f0_lengths
+        data_dict["wav_lengths"] = wav_lengths
+        data_dict["spkid"] = spkids
+
+        return data_dict
+
+
+class DatasetConstructor():
+
+    def __init__(self, hparams, num_replicas=1, rank=1):
+        self.hparams = hparams
+        self.num_replicas = num_replicas
+        self.rank = rank
+        self.dataset_function = {"SingDataset": SingDataset}
+        self.collate_function = {"SingCollate": SingCollate}
+        self._get_components()
+
+    def _get_components(self):
+        self._init_datasets()
+        self._init_collate()
+        self._init_data_loaders()
+
+    def _init_datasets(self):
+        self._train_dataset = self.dataset_function[self.hparams.data.dataset_type](self.hparams, self.hparams.data.data_dir, self.hparams.data.training_filelist, self.hparams.data.training_labellist)
+        self._valid_dataset = self.dataset_function[self.hparams.data.dataset_type](self.hparams, self.hparams.data.data_dir, self.hparams.data.validation_filelist, self.hparams.data.validation_labellist)
+
+    def _init_collate(self):
+        self._collate_fn = self.collate_function[self.hparams.data.collate_type](self.hparams)
+
+    def _init_data_loaders(self):
+        train_sampler = torch.utils.data.distributed.DistributedSampler(self._train_dataset, num_replicas=self.num_replicas, rank=self.rank, shuffle=True)
+        
+        self.train_loader = DataLoader(self._train_dataset, num_workers=4, shuffle=False,
+                                       batch_size=self.hparams.train.batch_size, pin_memory=True,
+                                       drop_last=True, collate_fn=self._collate_fn, sampler=train_sampler)
+
+        self.valid_loader = DataLoader(self._valid_dataset, num_workers=1, shuffle=False,
+                                       batch_size=1, pin_memory=True,
+                                       drop_last=True, collate_fn=self._collate_fn)
+
+    def get_train_loader(self):
+        return self.train_loader
+
+    def get_valid_loader(self):
+        return self.valid_loader
+

egs/visinger2/inference.py

@@ -0,0 +1,123 @@
+import matplotlib.pyplot as plt
+import IPython.display as ipd
+
+import sys
+import os
+import json
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+
+import modules.commons as commons
+import utils.utils as utils
+from models import SynthesizerTrn
+from text import npu
+from scipy.io.wavfile import write
+from tqdm import tqdm
+import numpy as np
+import time
+import argparse
+
+def parse_label(hps, pho, pitchid, dur, slur, gtdur):
+    phos = []
+    pitchs = []
+    durs = []
+    slurs = []
+    gtdurs = []
+
+    for index in range(len(pho.split())):
+        phos.append(npu.symbol_converter.ttsing_phone_to_int[pho.strip().split()[index]])
+        pitchs.append(npu.symbol_converter.ttsing_opencpop_pitch_to_int[pitchid.strip().split()[index]])
+        durs.append(float(dur.strip().split()[index]))
+        slurs.append(int(slur.strip().split()[index]))
+        gtdurs.append(float(gtdur.strip().split()[index]))
+
+    phos = np.asarray(phos, dtype=np.int32)
+    pitchs = np.asarray(pitchs, dtype=np.int32)
+    durs = np.asarray(durs, dtype=np.float32)
+    slurs = np.asarray(slurs, dtype=np.int32)
+    gtdurs = np.asarray(gtdurs, dtype=np.float32)
+    gtdurs = np.ceil(gtdurs / (hps.data.hop_size / hps.data.sample_rate))
+
+    phos = torch.LongTensor(phos)
+    pitchs = torch.LongTensor(pitchs)
+    durs = torch.FloatTensor(durs)
+    slurs = torch.LongTensor(slurs)
+    gtdurs = torch.LongTensor(gtdurs)
+    return phos, pitchs, durs, slurs, gtdurs
+
+def load_model(model_dir):
+
+    # load config and model
+    model_path = utils.latest_checkpoint_path(model_dir)
+    config_path = os.path.join(model_dir, "config.json")
+    
+    hps = utils.get_hparams_from_file(config_path)
+
+    print("Load model from : ", model_path)
+    print("config: ", config_path)
+
+    net_g = SynthesizerTrn(hps)
+    _ = net_g.eval()
+    _ = utils.load_checkpoint(model_path, net_g, None)
+    return net_g, hps
+
+def inference_label2wav(net_g, label_list_path, output_dir, hps, cuda_id=None):
+
+    id2label = {}
+    with open(label_list_path, "r") as in_file:
+        for line in in_file.readlines():
+            fileid, txt, phones, pitchid, dur, gtdur, slur = line.split('|')
+            id2label[fileid] = [phones, pitchid, dur, slur, gtdur]
+
+    for file_name in tqdm(id2label.keys()):
+        pho, pitchid, dur, slur, gtdur = id2label[file_name]
+        pho, pitchid, dur, slur, gtdur = parse_label(hps, pho, pitchid, dur, slur, gtdur)
+
+        with torch.no_grad():
+
+            # data
+            pho_lengths = torch.LongTensor([pho.size(0)])
+            pho = pho.unsqueeze(0)
+            pitchid = pitchid.unsqueeze(0)
+            dur = dur.unsqueeze(0)
+            slur = slur.unsqueeze(0)
+
+            if(cuda_id != None):
+                net_g = net_g.cuda(0)
+                pho = pho.cuda(0)
+                pho_lengths = pho_lengths.cuda(0)
+                pitchid = pitchid.cuda(0)
+                dur = dur.cuda(0)
+                slur = slur.cuda(0)
+
+            # infer
+            o, _, _ = net_g.infer(pho, pho_lengths, pitchid, dur, slur)
+            audio = o[0,0].data.cpu().float().numpy()
+            audio = audio * 32768 #hps.data.max_wav_value
+            audio = audio.astype(np.int16)
+           
+            # save
+            write(os.path.join(output_dir, file_name.split('.')[0] + '.wav' ), hps.data.sample_rate, audio)
+
+if __name__ == "__main__":
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-model_dir', '--model_dir', type=str, required=True)
+    parser.add_argument('-input_dir', '--input_dir', type=str, required=True)
+    parser.add_argument('-output_dir', '--output_dir', type=str, required=True)
+    args = parser.parse_args()
+
+    model_dir = args.model_dir
+    input_dir = args.input_dir
+    output_dir = args.output_dir
+
+    model, hps = load_model(model_dir)
+    if(not os.path.exists(output_dir)):
+        os.makedirs(output_dir)
+    print("load model end!")
+
+    inference_label2wav(model, input_dir, output_dir, hps, cuda_id=0)
+

egs/visinger2/models.py

@@ -0,0 +1,1023 @@
+import sys
+import copy
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
+
+sys.path.append('../..')
+import modules.commons as commons
+import modules.modules as modules
+import modules.attentions as attentions
+
+from modules.commons import init_weights, get_padding
+from text.npu.symbols import ttsing_phone_set, ttsing_opencpop_pitch_set, ttsing_slur_set
+
+from modules.ddsp import mlp, gru, scale_function, remove_above_nyquist, upsample
+from modules.ddsp import harmonic_synth, amp_to_impulse_response, fft_convolve
+from modules.ddsp import resample
+
+from modules.stft import TorchSTFT
+
+import torch.distributions as D
+
+from modules.losses import (
+    generator_loss,
+    discriminator_loss,
+    feature_loss,
+    kl_loss
+)
+
+LRELU_SLOPE = 0.1
+
+
+class DurationPredictor(nn.Module):
+    def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_speakers=0, spk_channels=0):
+        super().__init__()
+
+        self.in_channels = in_channels
+        self.filter_channels = filter_channels
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.spk_channels = spk_channels
+
+        self.drop = nn.Dropout(p_dropout)
+        self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2)
+        self.norm_1 = modules.LayerNorm(filter_channels)
+        self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
+        self.norm_2 = modules.LayerNorm(filter_channels)
+        self.conv_3 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
+        self.norm_3 = modules.LayerNorm(filter_channels)
+        self.proj = nn.Conv1d(filter_channels, 2, 1)
+
+        if n_speakers != 0:
+            self.cond = nn.Conv1d(spk_channels, in_channels, 1)
+
+    def forward(self, x, x_mask, spk_emb=None):
+        # x = torch.detach(x)
+        if spk_emb is not None:
+            spk_emb = torch.detach(spk_emb)
+            x = x + self.cond(spk_emb)
+
+        x = self.conv_1(x * x_mask)
+        x = torch.relu(x)
+        x = self.norm_1(x)
+        x = self.drop(x)
+
+        x = self.conv_2(x * x_mask)
+        x = torch.relu(x)
+        x = self.norm_2(x)
+        x = self.drop(x)
+
+        x = self.conv_3(x * x_mask)
+        x = torch.relu(x)
+        x = self.norm_3(x)
+        x = self.drop(x)
+
+        x = self.proj(x * x_mask)
+        return x * x_mask
+
+
+class TextEncoder(nn.Module):
+    def __init__(self,
+                 n_vocab,
+                 out_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout):
+        super().__init__()
+        self.n_vocab = n_vocab
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+
+        self.emb_phone = nn.Embedding(len(ttsing_phone_set), 256)
+        nn.init.normal_(self.emb_phone.weight, 0.0, 256 ** -0.5)
+
+        self.pre_net = torch.nn.Linear(256, hidden_channels)
+
+        self.encoder = attentions.Encoder(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            p_dropout)
+        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+
+    def forward(self, phone, phone_lengths, pitchid, dur, slur):
+        phone_end = self.emb_phone(phone) * math.sqrt(256)
+        x = phone_end
+
+        x = self.pre_net(x)
+        x = torch.transpose(x, 1, -1)  # [b, h, t]
+
+        x_mask = torch.unsqueeze(commons.sequence_mask(phone_lengths, x.size(2)), 1).to(x.dtype)
+
+        x = self.encoder(x * x_mask, x_mask)
+        x = self.proj(x) * x_mask
+
+        return x, x_mask
+
+
+def pad_v2(input_ele, mel_max_length=None):
+    if mel_max_length:
+        max_len = mel_max_length
+    else:
+        max_len = max([input_ele[i].size(0) for i in range(len(input_ele))])
+
+    out_list = list()
+    for i, batch in enumerate(input_ele):
+        if len(batch.shape) == 1:
+            one_batch_padded = F.pad(
+                batch, (0, max_len - batch.size(0)), "constant", 0.0
+            )
+        elif len(batch.shape) == 2:
+            one_batch_padded = F.pad(
+                batch, (0, 0, 0, max_len - batch.size(0)), "constant", 0.0
+            )
+        out_list.append(one_batch_padded)
+    out_padded = torch.stack(out_list)
+    return out_padded
+
+
+class LengthRegulator(nn.Module):
+    """ Length Regulator """
+
+    def __init__(self):
+        super(LengthRegulator, self).__init__()
+
+    def LR(self, x, duration, max_len):
+        x = torch.transpose(x, 1, 2)
+        output = list()
+        mel_len = list()
+        for batch, expand_target in zip(x, duration):
+            expanded = self.expand(batch, expand_target)
+            output.append(expanded)
+            mel_len.append(expanded.shape[0])
+
+        if max_len is not None:
+            output = pad_v2(output, max_len)
+        else:
+            output = pad_v2(output)
+        output = torch.transpose(output, 1, 2)
+        return output, torch.LongTensor(mel_len)
+
+    def expand(self, batch, predicted):
+        predicted = torch.squeeze(predicted)
+        out = list()
+
+        for i, vec in enumerate(batch):
+            expand_size = predicted[i].item()
+            state_info_index = torch.unsqueeze(torch.arange(0, expand_size), 1).float()
+            state_info_length = torch.unsqueeze(torch.Tensor([expand_size] * expand_size), 1).float()
+            state_info = torch.cat([state_info_index, state_info_length], 1).to(vec.device)
+            new_vec = vec.expand(max(int(expand_size), 0), -1)
+            new_vec = torch.cat([new_vec, state_info], 1)
+            out.append(new_vec)
+        out = torch.cat(out, 0)
+        return out
+
+    def forward(self, x, duration, max_len):
+        output, mel_len = self.LR(x, duration, max_len)
+        return output, mel_len
+
+
+class PriorDecoder(nn.Module):
+    def __init__(self,
+                 out_bn_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout,
+                 n_speakers=0,
+                 spk_channels=0):
+        super().__init__()
+        self.out_bn_channels = out_bn_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.spk_channels = spk_channels
+
+        self.prenet = nn.Conv1d(hidden_channels + 2, hidden_channels, 3, padding=1)
+        self.decoder = attentions.FFT(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            p_dropout)
+        self.proj = nn.Conv1d(hidden_channels, out_bn_channels, 1)
+
+        if n_speakers != 0:
+            self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
+
+    def forward(self, x, x_lengths, spk_emb=None):
+        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+
+        x = self.prenet(x) * x_mask
+
+        if (spk_emb is not None):
+            x = x + self.cond(spk_emb)
+
+        x = self.decoder(x * x_mask, x_mask)
+
+        bn = self.proj(x) * x_mask
+
+        return bn, x_mask
+
+
+class Decoder(nn.Module):
+    def __init__(self,
+                 out_channels,
+                 hidden_channels,
+                 filter_channels,
+                 n_heads,
+                 n_layers,
+                 kernel_size,
+                 p_dropout,
+                 n_speakers=0,
+                 spk_channels=0):
+        super().__init__()
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.filter_channels = filter_channels
+        self.n_heads = n_heads
+        self.n_layers = n_layers
+        self.kernel_size = kernel_size
+        self.p_dropout = p_dropout
+        self.spk_channels = spk_channels
+
+        self.prenet = nn.Conv1d(hidden_channels + 2, hidden_channels, 3, padding=1)
+        self.decoder = attentions.FFT(
+            hidden_channels,
+            filter_channels,
+            n_heads,
+            n_layers,
+            kernel_size,
+            p_dropout)
+        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+
+        if n_speakers != 0:
+            self.cond = nn.Conv1d(spk_channels, hidden_channels, 1)
+
+    def forward(self, x, x_lengths, spk_emb=None):
+        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+
+        x = self.prenet(x) * x_mask
+
+        if (spk_emb is not None):
+            x = x + self.cond(spk_emb)
+
+        x = self.decoder(x * x_mask, x_mask)
+
+        x = self.proj(x) * x_mask
+
+        return x, x_mask
+
+
+class ConvReluNorm(nn.Module):
+    def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
+        super().__init__()
+        self.in_channels = in_channels
+        self.hidden_channels = hidden_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.n_layers = n_layers
+        self.p_dropout = p_dropout
+        assert n_layers > 1, "Number of layers should be larger than 0."
+
+        self.conv_layers = nn.ModuleList()
+        self.norm_layers = nn.ModuleList()
+        self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
+        self.norm_layers.append(LayerNorm(hidden_channels))
+        self.relu_drop = nn.Sequential(
+            nn.ReLU(),
+            nn.Dropout(p_dropout))
+        for _ in range(n_layers - 1):
+            self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size // 2))
+            self.norm_layers.append(LayerNorm(hidden_channels))
+        self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+        self.proj.weight.data.zero_()
+        self.proj.bias.data.zero_()
+
+    def forward(self, x):
+        x = self.conv_layers[0](x)
+        x = self.norm_layers[0](x)
+        x = self.relu_drop(x)
+
+        for i in range(1, self.n_layers):
+            x_ = self.conv_layers[i](x)
+            x_ = self.norm_layers[i](x_)
+            x_ = self.relu_drop(x_)
+            x = (x + x_) / 2
+        x = self.proj(x)
+        return x
+
+
+class PosteriorEncoder(nn.Module):
+    def __init__(self,
+                 hps,
+                 in_channels,
+                 out_channels,
+                 hidden_channels,
+                 kernel_size,
+                 dilation_rate,
+                 n_layers):
+        super().__init__()
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.hidden_channels = hidden_channels
+        self.kernel_size = kernel_size
+        self.dilation_rate = dilation_rate
+        self.n_layers = n_layers
+
+        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+        self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, n_speakers=hps.data.n_speakers, spk_channels=hps.model.spk_channels)
+        # self.enc = ConvReluNorm(hidden_channels,
+        #                         hidden_channels,
+        #                         hidden_channels,
+        #                         kernel_size,
+        #                         n_layers,
+        #                         0.1)
+        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+    def forward(self, x, x_lengths, g=None):
+        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+        x = self.pre(x) * x_mask
+        x = self.enc(x, x_mask, g=g)
+        stats = self.proj(x) * x_mask
+        return stats, x_mask
+
+
+class ResBlock3(torch.nn.Module):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
+        super(ResBlock3, self).__init__()
+        self.convs = nn.ModuleList([
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
+                               padding=get_padding(kernel_size, dilation[0])))
+        ])
+        self.convs.apply(init_weights)
+
+    def forward(self, x, x_mask=None):
+        for c in self.convs:
+            xt = F.leaky_relu(x, LRELU_SLOPE)
+            if x_mask is not None:
+                xt = xt * x_mask
+            xt = c(xt)
+            x = xt + x
+        if x_mask is not None:
+            x = x * x_mask
+        return x
+
+    def remove_weight_norm(self):
+        for l in self.convs:
+            remove_weight_norm(l)
+
+
+class Generator_Harm(torch.nn.Module):
+    def __init__(self, hps):
+        super(Generator_Harm, self).__init__()
+        self.hps = hps
+
+        self.prenet = Conv1d(hps.model.hidden_channels, hps.model.hidden_channels, 3, padding=1)
+
+        self.net = ConvReluNorm(hps.model.hidden_channels,
+                                hps.model.hidden_channels,
+                                hps.model.hidden_channels,
+                                hps.model.kernel_size,
+                                8,
+                                hps.model.p_dropout)
+
+        # self.rnn = nn.LSTM(input_size=hps.model.hidden_channels,
+        #    hidden_size=hps.model.hidden_channels,
+        #    num_layers=1,
+        #    bias=True,
+        #    batch_first=True,
+        #    dropout=0.5,
+        #    bidirectional=True)
+        self.postnet = Conv1d(hps.model.hidden_channels, hps.model.n_harmonic + 1, 3, padding=1)
+
+    def forward(self, f0, harm, mask):
+        pitch = f0.transpose(1, 2)
+        harm = self.prenet(harm)
+
+        harm = self.net(harm) * mask
+        # harm = harm.transpose(1, 2)
+        # harm, (hs, hc) = self.rnn(harm)
+        # harm = harm.transpose(1, 2)
+
+        harm = self.postnet(harm)
+        harm = harm.transpose(1, 2)
+        param = harm
+
+        param = scale_function(param)
+        total_amp = param[..., :1]
+        amplitudes = param[..., 1:]
+        amplitudes = remove_above_nyquist(
+            amplitudes,
+            pitch,
+            self.hps.data.sample_rate,
+        )
+        amplitudes /= amplitudes.sum(-1, keepdim=True)
+        amplitudes *= total_amp
+
+        amplitudes = upsample(amplitudes, self.hps.data.hop_size)
+        pitch = upsample(pitch, self.hps.data.hop_size)
+
+        n_harmonic = amplitudes.shape[-1]
+        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sample_rate, 1)
+        omegas = omega * torch.arange(1, n_harmonic + 1).to(omega)
+        signal_harmonics = (torch.sin(omegas) * amplitudes)
+        signal_harmonics = signal_harmonics.transpose(1, 2)
+        return signal_harmonics
+
+
+class Generator(torch.nn.Module):
+    def __init__(self, hps, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
+                 upsample_initial_channel, upsample_kernel_sizes, n_speakers=0, spk_channels=0):
+        super(Generator, self).__init__()
+        self.num_kernels = len(resblock_kernel_sizes)
+        self.num_upsamples = len(upsample_rates)
+        self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
+        self.upsample_rates = upsample_rates
+        self.n_speakers = n_speakers
+
+        resblock = modules.ResBlock1 if resblock == '1' else modules.R
+
+        self.downs = nn.ModuleList()
+        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+            i = len(upsample_rates) - 1 - i
+            u = upsample_rates[i]
+            k = upsample_kernel_sizes[i]
+            # print("down: ",upsample_initial_channel//(2**(i+1))," -> ", upsample_initial_channel//(2**i))
+            self.downs.append(weight_norm(
+                Conv1d(hps.model.n_harmonic + 2, hps.model.n_harmonic + 2,
+                       k, u, padding=k // 2)))
+
+        self.resblocks_downs = nn.ModuleList()
+        for i in range(len(self.downs)):
+            j = len(upsample_rates) - 1 - i
+            self.resblocks_downs.append(ResBlock3(hps.model.n_harmonic + 2, 3, (1, 3)))
+
+        self.concat_pre = Conv1d(upsample_initial_channel + hps.model.n_harmonic + 2, upsample_initial_channel, 3, 1,
+                                 padding=1)
+        self.concat_conv = nn.ModuleList()
+        for i in range(len(upsample_rates)):
+            ch = upsample_initial_channel // (2 ** (i + 1))
+            self.concat_conv.append(Conv1d(ch + hps.model.n_harmonic + 2, ch, 3, 1, padding=1, bias=False))
+
+        self.ups = nn.ModuleList()
+        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
+            self.ups.append(weight_norm(
+                ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)),
+                                k, u, padding=(k - u) // 2)))
+
+        self.resblocks = nn.ModuleList()
+        for i in range(len(self.ups)):
+            ch = upsample_initial_channel // (2 ** (i + 1))
+            for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
+                self.resblocks.append(resblock(ch, k, d))
+
+        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
+        self.ups.apply(init_weights)
+
+        if self.n_speakers != 0:
+            self.cond = nn.Conv1d(spk_channels, upsample_initial_channel, 1)
+
+    def forward(self, x, ddsp, g=None):
+
+        x = self.conv_pre(x)
+
+        if g is not None:
+            x = x + self.cond(g)
+
+        se = ddsp
+        res_features = [se]
+        for i in range(self.num_upsamples):
+            in_size = se.size(2)
+            se = self.downs[i](se)
+            se = self.resblocks_downs[i](se)
+            up_rate = self.upsample_rates[self.num_upsamples - 1 - i]
+            se = se[:, :, : in_size // up_rate]
+            res_features.append(se)
+
+        x = torch.cat([x, se], 1)
+        x = self.concat_pre(x)
+
+        for i in range(self.num_upsamples):
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            in_size = x.size(2)
+            x = self.ups[i](x)
+            # 保证维度正确，丢掉多余通道
+            x = x[:, :, : in_size * self.upsample_rates[i]]
+
+            x = torch.cat([x, res_features[self.num_upsamples - 1 - i]], 1)
+            x = self.concat_conv[i](x)
+
+            xs = None
+            for j in range(self.num_kernels):
+                if xs is None:
+                    xs = self.resblocks[i * self.num_kernels + j](x)
+                else:
+                    xs += self.resblocks[i * self.num_kernels + j](x)
+            x = xs / self.num_kernels
+
+        x = F.leaky_relu(x)
+        x = self.conv_post(x)
+        x = torch.tanh(x)
+
+        return x
+
+    def remove_weight_norm(self):
+        print('Removing weight norm...')
+        for l in self.ups:
+            remove_weight_norm(l)
+        for l in self.resblocks:
+            l.remove_weight_norm()
+
+
+class Generator_Noise(torch.nn.Module):
+    def __init__(self, hps):
+        super(Generator_Noise, self).__init__()
+        self.hps = hps
+        self.win_size = hps.data.win_size
+        self.hop_size = hps.data.hop_size
+        self.fft_size = hps.data.n_fft
+        self.istft_pre = Conv1d(hps.model.hidden_channels, hps.model.hidden_channels, 3, padding=1)
+
+        self.net = ConvReluNorm(hps.model.hidden_channels,
+                                hps.model.hidden_channels,
+                                hps.model.hidden_channels,
+                                hps.model.kernel_size,
+                                8,
+                                hps.model.p_dropout)
+
+        self.istft_amplitude = torch.nn.Conv1d(hps.model.hidden_channels, self.fft_size // 2 + 1, 1, 1)
+        self.window = torch.hann_window(self.win_size)
+
+    def forward(self, x, mask):
+        istft_x = x
+        istft_x = self.istft_pre(istft_x)
+
+        istft_x = self.net(istft_x) * mask
+
+        amp = self.istft_amplitude(istft_x).unsqueeze(-1)
+        phase = (torch.rand(amp.shape) * 2 * 3.14 - 3.14).to(amp)
+
+        real = amp * torch.cos(phase)
+        imag = amp * torch.sin(phase)
+        spec = torch.cat([real, imag], 3)
+        istft_x = torch.istft(spec, self.fft_size, self.hop_size, self.win_size, self.window.to(amp), True,
+                              length=x.shape[2] * self.hop_size, return_complex=False)
+
+        return istft_x.unsqueeze(1)
+
+
+class LayerNorm(nn.Module):
+    def __init__(self, channels, eps=1e-5):
+        super().__init__()
+        self.channels = channels
+        self.eps = eps
+
+        self.gamma = nn.Parameter(torch.ones(channels))
+        self.beta = nn.Parameter(torch.zeros(channels))
+
+    def forward(self, x):
+        x = x.transpose(1, -1)
+        x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+        return x.transpose(1, -1)
+
+
+class DiscriminatorP(torch.nn.Module):
+    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
+        super(DiscriminatorP, self).__init__()
+        self.period = period
+        self.use_spectral_norm = use_spectral_norm
+        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+        self.convs = nn.ModuleList([
+            norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
+            norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
+        ])
+        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
+
+    def forward(self, x):
+        fmap = []
+
+        # 1d to 2d
+        b, c, t = x.shape
+        if t % self.period != 0:  # pad first
+            n_pad = self.period - (t % self.period)
+            x = F.pad(x, (0, n_pad), "reflect")
+            t = t + n_pad
+        x = x.view(b, c, t // self.period, self.period)
+
+        for l in self.convs:
+            x = l(x)
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+
+        return x, fmap
+
+
+class DiscriminatorS(torch.nn.Module):
+    def __init__(self, use_spectral_norm=False):
+        super(DiscriminatorS, self).__init__()
+        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
+        self.convs = nn.ModuleList([
+            norm_f(Conv1d(1, 16, 15, 1, padding=7)),
+            norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
+            norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
+            norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
+            norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
+            norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
+        ])
+        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
+
+    def forward(self, x):
+        fmap = []
+
+        for l in self.convs:
+            x = l(x)
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            fmap.append(x)
+        x = self.conv_post(x)
+        fmap.append(x)
+        x = torch.flatten(x, 1, -1)
+
+        return x, fmap
+
+
+class MultiFrequencyDiscriminator(nn.Module):
+    def __init__(self,
+                 hop_lengths=[128, 256, 512],
+                 hidden_channels=[256, 512, 512],
+                 domain='double', mel_scale=True):
+        super(MultiFrequencyDiscriminator, self).__init__()
+
+        self.stfts = nn.ModuleList([
+            TorchSTFT(fft_size=x * 4, hop_size=x, win_size=x * 4,
+                      normalized=True, domain=domain, mel_scale=mel_scale)
+            for x in hop_lengths])
+
+        self.domain = domain
+        if domain == 'double':
+            self.discriminators = nn.ModuleList([
+                BaseFrequenceDiscriminator(2, c)
+                for x, c in zip(hop_lengths, hidden_channels)])
+        else:
+            self.discriminators = nn.ModuleList([
+                BaseFrequenceDiscriminator(1, c)
+                for x, c in zip(hop_lengths, hidden_channels)])
+
+    def forward(self, x):
+        scores, feats = list(), list()
+        for stft, layer in zip(self.stfts, self.discriminators):
+            # print(stft)
+            mag, phase = stft.transform(x.squeeze())
+            if self.domain == 'double':
+                mag = torch.stack(torch.chunk(mag, 2, dim=1), dim=1)
+            else:
+                mag = mag.unsqueeze(1)
+
+            score, feat = layer(mag)
+            scores.append(score)
+            feats.append(feat)
+        return scores, feats
+
+
+class BaseFrequenceDiscriminator(nn.Module):
+    def __init__(self, in_channels, hidden_channels=512):
+        super(BaseFrequenceDiscriminator, self).__init__()
+
+        self.discriminator = nn.ModuleList()
+        self.discriminator += [
+            nn.Sequential(
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    in_channels, hidden_channels // 32,
+                    kernel_size=(3, 3), stride=(1, 1)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels // 32, hidden_channels // 16,
+                    kernel_size=(3, 3), stride=(2, 2)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels // 16, hidden_channels // 8,
+                    kernel_size=(3, 3), stride=(1, 1)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels // 8, hidden_channels // 4,
+                    kernel_size=(3, 3), stride=(2, 2)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels // 4, hidden_channels // 2,
+                    kernel_size=(3, 3), stride=(1, 1)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels // 2, hidden_channels,
+                    kernel_size=(3, 3), stride=(2, 2)))
+            ),
+            nn.Sequential(
+                nn.LeakyReLU(0.2, True),
+                nn.ReflectionPad2d((1, 1, 1, 1)),
+                nn.utils.weight_norm(nn.Conv2d(
+                    hidden_channels, 1,
+                    kernel_size=(3, 3), stride=(1, 1)))
+            )
+        ]
+
+    def forward(self, x):
+        hiddens = []
+        for layer in self.discriminator:
+            x = layer(x)
+            hiddens.append(x)
+        return x, hiddens[-1]
+
+
+class Discriminator(torch.nn.Module):
+    def __init__(self, hps, use_spectral_norm=False):
+        super(Discriminator, self).__init__()
+        periods = [2, 3, 5, 7, 11]
+
+        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
+        discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
+        self.discriminators = nn.ModuleList(discs)
+        self.disc_multfrequency = MultiFrequencyDiscriminator(hop_lengths=[int(hps.data.sample_rate * 2.5 / 1000),
+                                                                           int(hps.data.sample_rate * 5 / 1000),
+                                                                           int(hps.data.sample_rate * 7.5 / 1000),
+                                                                           int(hps.data.sample_rate * 10 / 1000),
+                                                                           int(hps.data.sample_rate * 12.5 / 1000),
+                                                                           int(hps.data.sample_rate * 15 / 1000)],
+                                                              hidden_channels=[256, 256, 256, 256, 256])
+
+    def forward(self, y, y_hat):
+        y_d_rs = []
+        y_d_gs = []
+        fmap_rs = []
+        fmap_gs = []
+        for i, d in enumerate(self.discriminators):
+            y_d_r, fmap_r = d(y)
+            y_d_g, fmap_g = d(y_hat)
+            y_d_rs.append(y_d_r)
+            y_d_gs.append(y_d_g)
+            fmap_rs.append(fmap_r)
+            fmap_gs.append(fmap_g)
+        scores_r, fmaps_r = self.disc_multfrequency(y)
+        scores_g, fmaps_g = self.disc_multfrequency(y_hat)
+        for i in range(len(scores_r)):
+            y_d_rs.append(scores_r[i])
+            y_d_gs.append(scores_g[i])
+            fmap_rs.append(fmaps_r[i])
+            fmap_gs.append(fmaps_g[i])
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
+class SynthesizerTrn(nn.Module):
+    """
+    Model
+    """
+
+    def __init__(self, hps):
+        super().__init__()
+        self.hps = hps
+
+        self.text_encoder = TextEncoder(
+            len(ttsing_phone_set),
+            hps.model.prior_hidden_channels,
+            hps.model.prior_hidden_channels,
+            hps.model.prior_filter_channels,
+            hps.model.prior_n_heads,
+            hps.model.prior_n_layers,
+            hps.model.prior_kernel_size,
+            hps.model.prior_p_dropout)
+
+        self.decoder = PriorDecoder(
+            hps.model.hidden_channels * 2,
+            hps.model.prior_hidden_channels,
+            hps.model.prior_filter_channels,
+            hps.model.prior_n_heads,
+            hps.model.prior_n_layers,
+            hps.model.prior_kernel_size,
+            hps.model.prior_p_dropout,
+            n_speakers=hps.data.n_speakers,
+            spk_channels=hps.model.spk_channels
+        )
+
+        self.f0_decoder = Decoder(
+            1,
+            hps.model.prior_hidden_channels,
+            hps.model.prior_filter_channels,
+            hps.model.prior_n_heads,
+            hps.model.prior_n_layers,
+            hps.model.prior_kernel_size,
+            hps.model.prior_p_dropout,
+            n_speakers=hps.data.n_speakers,
+            spk_channels=hps.model.spk_channels
+        )
+
+        self.mel_decoder = Decoder(
+            hps.data.acoustic_dim,
+            hps.model.prior_hidden_channels,
+            hps.model.prior_filter_channels,
+            hps.model.prior_n_heads,
+            hps.model.prior_n_layers,
+            hps.model.prior_kernel_size,
+            hps.model.prior_p_dropout,
+            n_speakers=hps.data.n_speakers,
+            spk_channels=hps.model.spk_channels
+        )
+
+        self.posterior_encoder = PosteriorEncoder(
+            hps,
+            hps.data.acoustic_dim,
+            hps.model.hidden_channels,
+            hps.model.hidden_channels, 3, 1, 8)
+
+        self.dropout = nn.Dropout(0.2)
+
+        self.duration_predictor = DurationPredictor(
+            hps.model.prior_hidden_channels,
+            hps.model.prior_hidden_channels,
+            3,
+            0.5,
+            n_speakers=hps.data.n_speakers,
+            spk_channels=hps.model.spk_channels)
+        self.LR = LengthRegulator()
+
+        self.dec = Generator(hps,
+                             hps.model.hidden_channels,
+                             hps.model.resblock,
+                             hps.model.resblock_kernel_sizes,
+                             hps.model.resblock_dilation_sizes,
+                             hps.model.upsample_rates,
+                             hps.model.upsample_initial_channel,
+                             hps.model.upsample_kernel_sizes,
+                             n_speakers=hps.data.n_speakers,
+                             spk_channels=hps.model.spk_channels)
+
+        self.dec_harm = Generator_Harm(hps)
+
+        self.dec_noise = Generator_Noise(hps)
+
+        self.f0_prenet = nn.Conv1d(1, hps.model.prior_hidden_channels + 2, 3, padding=1)
+        self.energy_prenet = nn.Conv1d(1, hps.model.prior_hidden_channels + 2, 3, padding=1)
+        self.mel_prenet = nn.Conv1d(hps.data.acoustic_dim, hps.model.prior_hidden_channels + 2, 3, padding=1)
+
+        if hps.data.n_speakers > 1:
+            self.emb_spk = nn.Embedding(hps.data.n_speakers, hps.model.spk_channels)
+        self.flow = modules.ResidualCouplingBlock(hps.model.prior_hidden_channels, hps.model.hidden_channels, 5, 1, 4,n_speakers=hps.data.n_speakers, gin_channels=hps.model.spk_channels)
+
+    def forward(self, phone, phone_lengths, pitchid, dur, slur, gtdur, F0, mel, bn_lengths, spk_id=None):
+        if self.hps.data.n_speakers > 0:
+            g = self.emb_spk(spk_id).unsqueeze(-1)  # [b, h, 1]
+        else:
+            g = None
+
+        # Encoder
+        x, x_mask = self.text_encoder(phone, phone_lengths, pitchid, dur, slur)
+
+        # LR
+        decoder_input, mel_len = self.LR(x, gtdur, None)
+
+        LF0 = 2595. * torch.log10(1. + F0 / 700.)
+        LF0 = LF0 / 500
+
+        # aam
+        predict_mel, predict_bn_mask = self.mel_decoder(decoder_input + self.f0_prenet(LF0), bn_lengths, spk_emb=g)
+
+        predict_energy = predict_mel.detach().sum(1).unsqueeze(1) / self.hps.data.acoustic_dim
+
+        decoder_input = decoder_input + \
+                        self.f0_prenet(LF0) + \
+                        self.energy_prenet(predict_energy) + \
+                        self.mel_prenet(predict_mel.detach())
+        decoder_output, predict_bn_mask = self.decoder(decoder_input, bn_lengths, spk_emb=g)
+
+        prior_info = decoder_output
+        m_p = prior_info[:, :self.hps.model.hidden_channels, :]
+        logs_p = prior_info[:, self.hps.model.hidden_channels:, :]
+
+        # posterior
+        posterior, y_mask = self.posterior_encoder(mel, bn_lengths,g=g)
+        m_q = posterior[:, :self.hps.model.hidden_channels, :]
+        logs_q = posterior[:, self.hps.model.hidden_channels:, :]
+        z = (m_q + torch.randn_like(m_q) * torch.exp(logs_q)) * y_mask
+        z_p = self.flow(z, y_mask, g=g)
+
+        # kl loss
+        loss_kl = kl_loss(z_p, logs_q, m_p, logs_p, y_mask)
+
+        p_z = z
+        p_z = self.dropout(p_z)
+
+        pitch = upsample(F0.transpose(1, 2), self.hps.data.hop_size)
+        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sample_rate, 1)
+        sin = torch.sin(omega).transpose(1, 2)
+
+        # dsp synthesize
+        noise_x = self.dec_noise(p_z, y_mask)
+        harm_x = self.dec_harm(F0, p_z, y_mask)
+
+        # dsp waveform
+        dsp_o = torch.cat([harm_x, noise_x], axis=1)
+
+        decoder_condition = torch.cat([harm_x, noise_x, sin], axis=1)
+
+        # dsp based HiFiGAN vocoder
+        x_slice, ids_slice = commons.rand_slice_segments(p_z, bn_lengths,
+                                                         self.hps.train.segment_size // self.hps.data.hop_size)
+        F0_slice = commons.slice_segments(F0, ids_slice, self.hps.train.segment_size // self.hps.data.hop_size)
+        dsp_slice = commons.slice_segments(dsp_o, ids_slice * self.hps.data.hop_size, self.hps.train.segment_size)
+        condition_slice = commons.slice_segments(decoder_condition, ids_slice * self.hps.data.hop_size,
+                                                 self.hps.train.segment_size)
+        o = self.dec(x_slice, condition_slice.detach(), g=g)
+
+        return o, ids_slice, LF0 * predict_bn_mask, dsp_slice.sum(1), loss_kl, predict_mel, predict_bn_mask
+
+    def infer(self, phone, phone_lengths, pitchid, dur, slur, gtdur=None, spk_id=None, length_scale=1., F0=None, noise_scale=0.8):
+
+        if self.hps.data.n_speakers > 0:
+            g = self.emb_spk(spk_id).unsqueeze(-1)  # [b, h, 1]
+        else:
+            g = None
+
+        # Encoder
+        x, x_mask = self.text_encoder(phone, phone_lengths, pitchid, dur, slur)
+
+        # dur
+        y_lengths = torch.clamp_min(torch.sum(gtdur.squeeze(1), [1]), 1).long()
+        LF0 = 2595. * torch.log10(1. + F0 / 700.)
+        LF0 = LF0 / 500
+        # LR
+        decoder_input, mel_len = self.LR(x, gtdur, None)
+
+        # aam
+        predict_mel, predict_bn_mask = self.mel_decoder(decoder_input + self.f0_prenet(LF0), y_lengths, spk_emb=g)
+
+        predict_energy = predict_mel.sum(1).unsqueeze(1) / self.hps.data.acoustic_dim
+
+        decoder_input = decoder_input + \
+                        self.f0_prenet(LF0) + \
+                        self.energy_prenet(predict_energy) + \
+                        self.mel_prenet(predict_mel)
+        decoder_output, y_mask = self.decoder(decoder_input, y_lengths, spk_emb=g)
+
+        prior_info = decoder_output
+
+        m_p = prior_info[:, :self.hps.model.hidden_channels, :]
+        logs_p = prior_info[:, self.hps.model.hidden_channels:, :]
+        z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
+        z = self.flow(z_p, y_mask, g=g, reverse=True)
+
+        prior_z = z
+
+        noise_x = self.dec_noise(prior_z, y_mask)
+
+        harm_x = self.dec_harm(F0, prior_z, y_mask)
+
+        pitch = upsample(F0.transpose(1, 2), self.hps.data.hop_size)
+        omega = torch.cumsum(2 * math.pi * pitch / self.hps.data.sample_rate, 1)
+        sin = torch.sin(omega).transpose(1, 2)
+
+        decoder_condition = torch.cat([harm_x, noise_x, sin], axis=1)
+
+        # dsp based HiFiGAN vocoder
+        o = self.dec(prior_z, decoder_condition, g=g)
+
+        return o, harm_x.sum(1).unsqueeze(1), noise_x

egs/visinger2/train.py

@@ -0,0 +1,456 @@
+import os
+import sys
+import json
+import argparse
+import itertools
+import math
+import time
+import logging
+
+import torch
+from torch import nn, optim
+from torch.nn import functional as F
+from torch.utils.data import DataLoader
+from torch.utils.tensorboard import SummaryWriter
+import torch.multiprocessing as mp
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.cuda.amp import autocast, GradScaler
+
+sys.path.append('../..')
+import modules.commons as commons
+import utils.utils as utils
+
+from dataset import DatasetConstructor
+
+from models import (
+    SynthesizerTrn,
+    Discriminator
+)
+
+from modules.losses import (
+    generator_loss,
+    discriminator_loss,
+    feature_loss,
+    kl_loss,
+)
+from preprocess.mel_processing import mel_spectrogram_torch, spec_to_mel_torch, spectrogram_torch
+
+torch.backends.cudnn.benchmark = True
+global_step = 0
+use_cuda = torch.cuda.is_available()
+print("use_cuda, ", use_cuda)
+
+numba_logger = logging.getLogger('numba')
+numba_logger.setLevel(logging.WARNING)
+
+
+def main():
+    """Assume Single Node Multi GPUs Training Only"""
+
+    hps = utils.get_hparams()
+    os.environ['MASTER_ADDR'] = 'localhost'
+    os.environ['MASTER_PORT'] = str(hps.train.port)
+
+    if (torch.cuda.is_available()):
+        n_gpus = torch.cuda.device_count()
+        mp.spawn(run, nprocs=n_gpus, args=(n_gpus, hps,))
+    else:
+        cpurun(0, 1, hps)
+
+
+def run(rank, n_gpus, hps):
+    global global_step
+    if rank == 0:
+        logger = utils.get_logger(hps.train.save_dir)
+        logger.info(hps.train)
+        logger.info(hps.data)
+        logger.info(hps.model)
+        utils.check_git_hash(hps.train.save_dir)
+        writer = SummaryWriter(log_dir=hps.train.save_dir)
+        writer_eval = SummaryWriter(log_dir=os.path.join(hps.train.save_dir, "eval"))
+
+    dist.init_process_group(backend='nccl', init_method='env://', world_size=n_gpus, rank=rank)
+    torch.manual_seed(hps.train.seed)
+    torch.cuda.set_device(rank)
+    dataset_constructor = DatasetConstructor(hps, num_replicas=n_gpus, rank=rank)
+
+    train_loader = dataset_constructor.get_train_loader()
+    if rank == 0:
+        valid_loader = dataset_constructor.get_valid_loader()
+
+    net_g = SynthesizerTrn(hps).cuda(rank)
+    net_d = Discriminator(hps, hps.model.use_spectral_norm).cuda(rank)
+
+    optim_g = torch.optim.AdamW(
+        net_g.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    optim_d = torch.optim.AdamW(
+        net_d.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    net_g = DDP(net_g, device_ids=[rank], find_unused_parameters=True)
+    net_d = DDP(net_d, device_ids=[rank], find_unused_parameters=True)
+    try:
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.train.save_dir, "G_*.pth"), net_g,
+                                                   optim_g)
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.train.save_dir, "D_*.pth"), net_d,
+                                                   optim_d)
+        global_step = (epoch_str - 1) * len(train_loader)
+    except:
+        epoch_str = 1
+        global_step = 0
+
+    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+
+    for epoch in range(epoch_str, hps.train.epochs + 1):
+        if rank == 0:
+            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
+                               [train_loader, valid_loader], logger, [writer, writer_eval])
+        else:
+            train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
+                               [train_loader, None], None, None)
+        scheduler_g.step()
+        scheduler_d.step()
+
+
+def cpurun(rank, n_gpus, hps):
+    global global_step
+    if rank == 0:
+        logger = utils.get_logger(hps.train.save_dir)
+        logger.info(hps.train)
+        logger.info(hps.data)
+        logger.info(hps.model)
+        utils.check_git_hash(hps.train.save_dir)
+        writer = SummaryWriter(log_dir=hps.train.save_dir)
+        writer_eval = SummaryWriter(log_dir=os.path.join(hps.train.save_dir, "eval"))
+    torch.manual_seed(hps.train.seed)
+    dataset_constructor = DatasetConstructor(hps, num_replicas=n_gpus, rank=rank)
+
+    train_loader = dataset_constructor.get_train_loader()
+    if rank == 0:
+        valid_loader = dataset_constructor.get_valid_loader()
+
+    net_g = SynthesizerTrn(hps)
+    net_d = Discriminator(hps, hps.model.use_spectral_norm)
+
+    optim_g = torch.optim.AdamW(
+        net_g.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    optim_d = torch.optim.AdamW(
+        net_d.parameters(),
+        hps.train.learning_rate,
+        betas=hps.train.betas,
+        eps=hps.train.eps)
+    try:
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.train.save_dir, "G_*.pth"), net_g,
+                                                   optim_g)
+        _, _, _, epoch_str = utils.load_checkpoint(utils.latest_checkpoint_path(hps.train.save_dir, "D_*.pth"), net_g,
+                                                   optim_g)
+        global_step = (epoch_str - 1) * len(train_loader)
+    except:
+        epoch_str = 1
+        global_step = 0
+
+    scheduler_g = torch.optim.lr_scheduler.ExponentialLR(optim_g, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+    scheduler_d = torch.optim.lr_scheduler.ExponentialLR(optim_d, gamma=hps.train.lr_decay, last_epoch=epoch_str - 2)
+
+    for epoch in range(epoch_str, hps.train.epochs + 1):
+        train_and_evaluate(rank, epoch, hps, [net_g, net_d], [optim_g, optim_d], [scheduler_g, scheduler_d],
+                           [train_loader, valid_loader], logger, [writer, writer_eval])
+
+        scheduler_g.step()
+        scheduler_d.step()
+
+
+def train_and_evaluate(rank, epoch, hps, nets, optims, schedulers, loaders, logger, writers):
+    net_g, net_d = nets
+    optim_g, optim_d = optims
+    scheduler_g, scheduler_d = schedulers
+    train_loader, eval_loader = loaders
+    if writers is not None:
+        writer, writer_eval = writers
+
+    train_loader.sampler.set_epoch(epoch)
+    global global_step
+
+    net_g.train()
+    net_d.train()
+    for batch_idx, data_dict in enumerate(train_loader):
+
+        phone = data_dict["phone"]
+        pitchid = data_dict["pitchid"]
+        dur = data_dict["dur"]
+        slur = data_dict["slur"]
+        gtdur = data_dict["gtdur"]
+        mel = data_dict["mel"]
+        f0 = data_dict["f0"]
+        wav = data_dict["wav"]
+        spkid = data_dict["spkid"]
+
+        phone_lengths = data_dict["phone_lengths"]
+        mel_lengths = data_dict["mel_lengths"]
+        wav_lengths = data_dict["wav_lengths"]
+        f0_lengths = data_dict["f0_lengths"]
+
+        # data
+        if (use_cuda):
+            phone, phone_lengths = phone.cuda(rank, non_blocking=True), phone_lengths.cuda(rank, non_blocking=True)
+            pitchid = pitchid.cuda(rank, non_blocking=True)
+            dur = dur.cuda(rank, non_blocking=True)
+            slur = slur.cuda(rank, non_blocking=True)
+            gtdur = gtdur.cuda(rank, non_blocking=True)
+            mel, mel_lengths = mel.cuda(rank, non_blocking=True), mel_lengths.cuda(rank, non_blocking=True)
+            wav, wav_lengths = wav.cuda(rank, non_blocking=True), wav_lengths.cuda(rank, non_blocking=True)
+            f0, f0_lengths = f0.cuda(rank, non_blocking=True), f0_lengths.cuda(rank, non_blocking=True)
+            spkid = spkid.cuda(rank, non_blocking=True)
+
+        # forward
+        y_hat, ids_slice, LF0, y_ddsp, kl_div, predict_mel, mask = net_g(phone, phone_lengths, pitchid, dur, slur,
+                                                                         gtdur, f0, mel, mel_lengths, spk_id=spkid)
+        y_ddsp = y_ddsp.unsqueeze(1)
+
+        # Discriminator
+        y = commons.slice_segments(wav, ids_slice * hps.data.hop_size, hps.train.segment_size)  # slice
+        y_ddsp_mel = mel_spectrogram_torch(
+            y_ddsp.squeeze(1),
+            hps.data.n_fft,
+            hps.data.acoustic_dim,
+            hps.data.sample_rate,
+            hps.data.hop_size,
+            hps.data.win_size,
+            hps.data.fmin,
+            hps.data.fmax
+        )
+
+        y_logspec = torch.log(spectrogram_torch(
+            y.squeeze(1),
+            hps.data.n_fft,
+            hps.data.sample_rate,
+            hps.data.hop_size,
+            hps.data.win_size
+        ) + 1e-7)
+
+        y_ddsp_logspec = torch.log(spectrogram_torch(
+            y_ddsp.squeeze(1),
+            hps.data.n_fft,
+            hps.data.sample_rate,
+            hps.data.hop_size,
+            hps.data.win_size
+        ) + 1e-7)
+
+        y_mel = mel_spectrogram_torch(
+            y.squeeze(1),
+            hps.data.n_fft,
+            hps.data.acoustic_dim,
+            hps.data.sample_rate,
+            hps.data.hop_size,
+            hps.data.win_size,
+            hps.data.fmin,
+            hps.data.fmax
+        )
+        y_hat_mel = mel_spectrogram_torch(
+            y_hat.squeeze(1),
+            hps.data.n_fft,
+            hps.data.acoustic_dim,
+            hps.data.sample_rate,
+            hps.data.hop_size,
+            hps.data.win_size,
+            hps.data.fmin,
+            hps.data.fmax
+        )
+
+        y_d_hat_r, y_d_hat_g, _, _ = net_d(y, y_hat.detach())
+        loss_disc, losses_disc_r, losses_disc_g = discriminator_loss(y_d_hat_r, y_d_hat_g)
+        loss_disc_all = loss_disc
+
+        optim_d.zero_grad()
+        loss_disc_all.backward()
+        grad_norm_d = commons.clip_grad_value_(net_d.parameters(), None)
+        optim_d.step()
+
+        # loss
+        y_d_hat_r, y_d_hat_g, fmap_r, fmap_g = net_d(y, y_hat)
+
+        loss_mel = F.l1_loss(y_mel, y_hat_mel) * 45
+        loss_mel_dsp = F.l1_loss(y_mel, y_ddsp_mel) * 45
+        loss_spec_dsp = F.l1_loss(y_logspec, y_ddsp_logspec) * 45
+
+        loss_mel_am = F.mse_loss(mel * mask, predict_mel * mask)  # * 10
+
+        loss_fm = feature_loss(fmap_r, fmap_g)
+        loss_gen, losses_gen = generator_loss(y_d_hat_g)
+
+        loss_fm = loss_fm / 2
+        loss_gen = loss_gen / 2
+        loss_gen_all = loss_gen + loss_fm + loss_mel + loss_mel_dsp + kl_div + loss_mel_am + loss_spec_dsp
+
+        loss_gen_all = loss_gen_all / hps.train.accumulation_steps
+
+        loss_gen_all.backward()
+        if ((global_step + 1) % hps.train.accumulation_steps == 0):
+            grad_norm_g = commons.clip_grad_value_(net_g.parameters(), None)
+            optim_g.step()
+            optim_g.zero_grad()
+
+        if rank == 0:
+            if (global_step + 1) % (hps.train.accumulation_steps * 10) == 0:
+                logger.info(["step&time", global_step, time.asctime(time.localtime(time.time()))])
+                logger.info(["mel&mel_dsp&spec_dsp: ", loss_mel, loss_mel_dsp, loss_spec_dsp])
+                logger.info(["adv&fm: ", loss_gen, loss_fm])
+                logger.info(["kl: ", kl_div])
+                logger.info(["am&dur: ", loss_mel_am])
+
+            if global_step % hps.train.log_interval == 0:
+                lr = optim_g.param_groups[0]['lr']
+                losses = [loss_gen_all, loss_mel]
+                logger.info('Train Epoch: {} [{:.0f}%]'.format(
+                    epoch,
+                    100. * batch_idx / len(train_loader)))
+                logger.info([x.item() for x in losses] + [global_step, lr])
+
+                scalar_dict = {"loss/total": loss_gen_all,
+                               "loss/mel": loss_mel,
+                               "loss/adv": loss_gen,
+                               "loss/fm": loss_fm,
+                               "loss/mel_ddsp": loss_mel_dsp,
+                               "loss/spec_ddsp": loss_spec_dsp,
+                               "loss/mel_am": loss_mel_am,
+                               "loss/kl_div": kl_div,
+                               "learning_rate": lr}
+
+                utils.summarize(
+                    writer=writer,
+                    global_step=global_step,
+                    scalars=scalar_dict)
+
+            if global_step % hps.train.eval_interval == 0:
+                logger.info(['All training params(G): ', utils.count_parameters(net_g), ' M'])
+                # print('Sub training params(G): ', \
+                #      'text_encoder: ', utils.count_parameters(net_g.module.text_encoder), ' M, ', \
+                #      'decoder: ', utils.count_parameters(net_g.module.decoder), ' M, ', \
+                #      'mel_decoder: ', utils.count_parameters(net_g.module.mel_decoder), ' M, ', \
+                #      'dec: ', utils.count_parameters(net_g.module.dec), ' M, ', \
+                #      'dec_harm: ', utils.count_parameters(net_g.module.dec_harm), ' M, ', \
+                #      'dec_noise: ', utils.count_parameters(net_g.module.dec_noise), ' M, ', \
+                #      'posterior: ', utils.count_parameters(net_g.module.posterior_encoder), ' M, ', \
+                #     )
+
+                evaluate(hps, net_g, eval_loader, writer_eval)
+                utils.save_checkpoint(net_g, optim_g, hps.train.learning_rate, epoch,
+                                      os.path.join(hps.train.save_dir, "G_{}.pth".format(global_step)), hps.train.eval_interval)
+                utils.save_checkpoint(net_d, optim_d, hps.train.learning_rate, epoch,
+                                      os.path.join(hps.train.save_dir, "D_{}.pth".format(global_step)), hps.train.eval_interval)
+                net_g.train()
+        global_step += 1
+
+    if rank == 0:
+        logger.info('====> Epoch: {}'.format(epoch))
+
+
+def evaluate(hps, generator, eval_loader, writer_eval):
+    generator.eval()
+    image_dict = {}
+    audio_dict = {}
+    with torch.no_grad():
+        for batch_idx, data_dict in enumerate(eval_loader):
+            if batch_idx == 4:
+                break
+            phone = data_dict["phone"]
+            pitchid = data_dict["pitchid"]
+            dur = data_dict["dur"]
+            slur = data_dict["slur"]
+            gtdur = data_dict["gtdur"]
+            mel = data_dict["mel"]
+            f0 = data_dict["f0"]
+            wav = data_dict["wav"]
+            spkid = data_dict["spkid"]
+
+            phone_lengths = data_dict["phone_lengths"]
+            mel_lengths = data_dict["mel_lengths"]
+            wav_lengths = data_dict["wav_lengths"]
+            f0_lengths = data_dict["f0_lengths"]
+
+            # data
+            if (use_cuda):
+                phone, phone_lengths = phone.cuda(0), phone_lengths.cuda(0)
+                pitchid = pitchid.cuda(0)
+                dur = dur.cuda(0)
+                slur = slur.cuda(0)
+                wav = wav.cuda(0)
+                mel = mel.cuda(0)
+                f0 = f0.cuda(0)
+                gtdur = gtdur.cuda(0)
+                spkid = spkid.cuda(0)
+            # remove else
+            phone = phone[:1]
+            phone_lengths = phone_lengths[:1]
+            pitchid = pitchid[:1]
+            dur = dur[:1]
+            slur = slur[:1]
+            wav = wav[:1]
+            mel = mel[:1]
+            f0 = f0[:1]
+            gtdur = gtdur[:1]
+            spkid = spkid[:1]
+
+            y_hat, y_harm, y_noise = generator.module.infer(phone, phone_lengths, pitchid, dur, slur, gtdur=gtdur, F0=f0,
+                                                            spk_id=spkid)
+            spec = spectrogram_torch(
+                wav.squeeze(1),
+                hps.data.n_fft,
+                hps.data.sample_rate,
+                hps.data.hop_size,
+                hps.data.win_size
+            )
+
+            y_mel = mel_spectrogram_torch(
+                wav.squeeze(1),
+                hps.data.n_fft,
+                hps.data.acoustic_dim,
+                hps.data.sample_rate,
+                hps.data.hop_size,
+                hps.data.win_size,
+                hps.data.fmin,
+                hps.data.fmax
+            )
+            y_hat_mel = mel_spectrogram_torch(
+                y_hat.squeeze(1),
+                hps.data.n_fft,
+                hps.data.acoustic_dim,
+                hps.data.sample_rate,
+                hps.data.hop_size,
+                hps.data.win_size,
+                hps.data.fmin,
+                hps.data.fmax
+            )
+            image_dict.update({
+                f"gen/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(y_hat_mel[0].cpu().numpy()),
+            })
+            audio_dict.update( {
+                f"gen/audio_{batch_idx}": y_hat[0, :, :],
+                f"gen/harm_{batch_idx}": y_harm[0, :, :],
+                "gen/noise": y_noise[0, :, :]
+            })
+            # if global_step == 0:
+            image_dict.update({f"gt/mel_{batch_idx}": utils.plot_spectrogram_to_numpy(mel[0].cpu().numpy())})
+            audio_dict.update({f"gt/audio_{batch_idx}": wav[0, :, :wav_lengths[0]]})
+
+    utils.summarize(
+        writer=writer_eval,
+        global_step=global_step,
+        images=image_dict,
+        audios=audio_dict,
+        audio_sampling_rate=hps.data.sample_rate
+    )
+    generator.train()
+
+
+if __name__ == "__main__":
+    main()

infer/__init__.py

@@ -0,0 +1,122 @@
+import time
+
+import librosa
+import numpy as np
+import torch
+import tqdm
+from text import npu
+
+def resize2d_f0(x, target_len):
+    source = np.array(x)
+    source[source < 0.001] = np.nan
+    target = np.interp(np.arange(0, len(source) * target_len, len(source)) / target_len, np.arange(0, len(source)),
+                       source)
+    res = np.nan_to_num(target)
+    return res
+
+
+def preprocess(ds):
+    note_list = ds["note_seq"]
+    midis = [librosa.note_to_midi(x.split("/")[0]) if x != 'rest' else 0
+                         for x in note_list.split(" ")]
+    f0_seq = None
+    if ds["f0_seq"] is not None:
+        f0_seq = [float(i.strip()) for i in ds["f0_seq"].split(" ")]
+        f0_seq = np.array(f0_seq)
+    phseq = ds["ph_seq"].split(" ")
+    newphseq = []
+    for ph in phseq:
+        newphseq.append(npu.ttsing_phone_to_int[ph])
+    phseq = newphseq
+    phseq = np.array(phseq)
+    pitch = 440 * (2 ** ((np.array(midis) - 69) / 12))
+    durations = [float(i) for i in ds["ph_dur"].split(" ")]
+    accu_dur = 0
+    accu_durs = []
+    for dur in durations:
+        accu_dur += dur
+        accu_durs.append(accu_dur)
+    accu_durs = np.array(accu_durs)
+    accu_durs = (accu_durs * 44100 // 512).astype(int)
+    sub_durs = np.zeros_like(accu_durs)
+    sub_durs[1:accu_durs.shape[0]] = accu_durs[:accu_durs.shape[0]-1]
+    durations = accu_durs-sub_durs
+    f0_seq = resize2d_f0(f0_seq, sum(durations))
+    pos = 0
+    for i, d in enumerate(durations):
+        if phseq[i] == 0:
+            f0_seq[pos:pos + d] = 0
+        pos += d
+
+    return f0_seq,pitch, phseq, durations
+
+if __name__ == '__main__':
+    inp = {
+        "text": "SP 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 SP 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 SP 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 啊 SP",
+        "ph_seq": "SP x ing z ou z ai w ei x ian b ian y van s i0 y i d e g uai d ao SP z i0 y ou d e t iao zh e zh ir j ian sh ang d e w u d ao SP q ing y ing d e x iang an y ing zh ong c ang f u d e b o s i0 m ao d eng d ai x ia y i g e m u u b iao SP",
+        "note_seq": "rest D5 D5 B4 B4 D5 D5 G5 G5 D5 D5 C5 C5 B4 B4 A#4 A#4 A4 A4 G4 G4 D4 D4 G4 G4 rest D5 D5 B4 B4 D5 D5 G5 G5 D5 D5 C5 C5 B4 B4 C5 C5 C5 C5 G5 G5 C5 C5 rest D5 D5 B4 B4 D5 D5 G5 G5 D5 C5 C5 B4 B4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 G4 G4 D4 D4 G4 G4 F4 F4 G4 G4 A#4 A#4 C5 C5 C#5 D5 D5 rest",
+        "note_dur_seq": "0.6 0.136 0.136 0.137 0.137 0.545 0.545 0.546 0.546 0.2720001 0.2720001 0.273 0.273 0.273 0.273 0.2719998 0.2719998 0.546 0.546 0.5450001 0.5450001 0.2730002 0.2730002 0.4089999 0.4089999 0.1370001 0.1359997 0.1359997 0.1360002 0.1360002 0.546 0.546 0.5450001 0.5450001 0.2729998 0.2729998 0.2730002 0.2730002 0.2719998 0.2719998 0.546 0.546 0.2730002 0.2730002 0.5449996 0.5449996 0.6820002 0.6820002 0.1359997 0.1370001 0.1370001 0.1360006 0.1360006 0.5450001 0.5450001 0.5459995 0.5459995 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.3640003 0.3640003 0.1809998 0.1809998 0.3640003 0.3640003 0.1820002 0.1820002 0.3639994 0.3639994 0.1810007 0.1810007 0.3639994 0.3639994 0.1820002 0.1820002 0.4090004 0.4090004 0.4089994 0.4089994 0.2729998 0.2729998 0.2720003 0.2720003 0.5460005 0.8179989 0.8179989 0.5",
+        "is_slur_seq": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0",
+        "ph_dur": "0.3875 0.2125 0.070091 0.065909 0.082455 0.054545 0.474545 0.070455 0.339182 0.206818 0.244727 0.027273 0.207091 0.065909 0.163909 0.109091 0.272 0 0.442591 0.103409 0.447273 0.097727 0.224137 0.048864 0.409 0.088136 0.048864 0.070091 0.065909 0.081455 0.054545 0.452818 0.093182 0.37 0.175 0.103682 0.169318 0.115046 0.157955 0.1845 0.0875 0.475545 0.070455 0.273 0 0.506363 0.038636 0.682 0.054182 0.081818 0.076773 0.060227 0.097364 0.038636 0.354091 0.190909 0.546 0.202545 0.070455 0.168591 0.103409 0.218454 0.054545 0.2765 0.0875 0.148045 0.032955 0.325364 0.038636 0.067227 0.114773 0.270818 0.093182 0.148046 0.032955 0.286727 0.077273 0.057 0.125 0.409 0 0.381727 0.027273 0.152545 0.120455 0.272 0.441653 0.104348 0.817999 0.5",
+        "f0_timestep": "0.005",
+        "f0_seq": "587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.2 587.0 586.9 586.7 586.1 585.4 584.8 584.1 583.4 582.9 582.5 582.3 582.5 582.9 583.4 584.1 584.9 585.5 586.1 586.7 587.0 587.3 587.6 587.9 588.0 588.1 588.4 588.7 588.7 588.7 588.0 586.4 584.1 580.8 575.8 568.7 560.8 552.0 540.9 531.0 522.2 513.8 506.6 501.7 497.9 495.0 493.8 493.0 492.6 492.6 492.7 492.7 492.7 492.7 492.7 492.5 492.6 493.2 494.1 495.6 498.7 502.5 507.6 515.5 523.9 532.9 543.2 553.7 562.4 570.3 577.2 581.7 584.6 586.9 588.2 588.7 588.7 588.6 588.3 588.1 588.0 587.8 587.5 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.2 586.9 586.7 587.0 587.0 587.0 587.0 587.5 588.7 590.8 594.1 599.0 607.7 617.7 630.6 647.9 667.1 686.3 706.4 727.1 743.0 755.2 765.1 773.3 778.6 781.6 783.4 784.4 784.4 784.4 784.4 784.7 784.7 784.3 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.1 784.5 784.9 784.4 784.4 784.4 784.4 783.8 782.3 779.9 775.1 768.7 759.5 747.9 731.5 712.9 694.2 674.0 652.5 636.1 622.4 610.1 601.9 596.0 591.8 589.1 587.8 587.0 587.0 587.0 587.0 586.8 586.8 587.1 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.6 587.9 588.0 588.1 588.5 589.1 589.4 589.4 589.1 588.4 586.8 584.5 581.2 575.9 570.6 564.1 556.0 548.8 542.3 536.2 531.1 527.3 524.8 522.6 521.9 521.5 521.4 521.6 521.9 522.4 522.6 522.6 522.9 523.2 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.6 523.9 524.1 524.4 524.8 525.4 525.8 526.0 526.2 525.7 524.9 523.3 521.1 518.6 515.3 511.3 507.6 504.0 499.9 497.3 495.0 493.1 492.0 491.4 491.1 491.4 491.6 492.1 492.6 492.9 493.2 493.4 493.7 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 494.1 494.3 494.5 494.8 495.1 495.6 496.1 496.4 496.6 496.5 495.8 494.7 493.2 491.0 487.9 484.7 481.2 477.3 473.8 470.9 468.4 466.2 464.8 464.1 463.6 463.7 463.9 464.2 464.7 465.1 465.4 465.6 465.8 466.1 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.4 466.7 466.9 467.2 467.5 468.0 468.4 468.6 468.9 468.3 467.6 466.4 464.4 462.0 459.3 456.0 452.2 449.0 446.0 443.1 441.0 439.5 438.5 437.9 437.5 437.7 437.9 438.4 438.8 439.1 439.3 439.6 439.8 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.0 440.3 440.5 440.5 440.7 441.0 441.4 441.5 441.5 441.3 440.6 439.1 437.0 434.2 430.6 426.3 420.5 415.3 410.1 404.6 400.5 397.2 394.5 392.6 391.4 390.9 390.6 390.6 390.8 391.1 391.4 391.5 391.6 391.8 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.2 392.4 392.3 392.2 392.2 392.2 392.1 391.5 390.6 388.6 385.6 381.6 375.9 368.3 360.1 351.0 339.3 329.8 321.3 313.1 306.8 302.4 298.9 296.3 294.9 294.1 293.7 293.5 293.5 293.5 293.5 293.4 293.5 293.6 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.6 293.5 293.4 293.5 293.5 293.5 293.5 293.7 294.3 295.4 297.0 299.5 303.8 308.9 315.3 323.9 333.6 343.2 353.2 363.5 371.5 377.6 382.5 386.6 389.3 390.8 391.7 392.2 392.2 392.2 392.2 392.4 392.3 392.1 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 391.8 391.8 391.6 391.3 390.9 390.5 390.1 389.5 389.1 388.9 389.1 389.6 390.3 391.2 392.8 394.5 397.0 400.6 405.3 411.1 419.5 431.0 443.7 458.9 479.8 497.9 515.2 532.6 546.7 557.1 565.4 571.7 575.6 577.8 579.1 580.0 580.4 580.8 581.5 582.7 582.9 583.5 584.4 585.1 585.6 586.2 586.8 587.0 587.3 587.7 588.0 588.0 588.2 588.5 588.7 588.7 588.5 587.7 586.3 583.3 579.0 573.7 567.1 558.7 548.3 538.6 529.1 519.2 511.5 505.6 500.7 496.9 494.8 493.6 492.7 492.5 492.6 492.7 492.7 492.7 492.7 492.7 492.5 492.7 493.3 494.5 496.5 499.4 503.7 510.1 517.2 525.5 536.3 546.3 555.5 564.6 572.6 578.1 582.6 585.6 587.3 588.3 588.7 588.7 588.6 588.3 588.0 588.0 587.7 587.4 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.1 586.8 586.8 587.0 587.0 587.0 587.0 587.8 589.1 591.4 595.5 601.9 609.7 619.7 636.1 652.5 670.9 692.6 712.9 730.2 745.9 759.5 768.7 775.1 779.9 782.3 783.8 784.4 784.4 784.4 784.4 784.8 784.5 784.1 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.2 784.6 784.7 784.4 784.4 784.4 784.4 783.5 781.7 778.6 773.8 766.5 755.2 743.0 727.1 706.4 686.3 667.1 649.2 632.8 617.7 607.7 600.4 594.3 590.8 588.9 587.6 587.0 587.0 587.0 587.0 586.7 586.9 587.2 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.7 588.0 588.0 588.2 588.7 589.1 589.4 589.3 589.0 588.2 586.1 583.4 579.6 574.8 569.0 561.3 554.4 547.5 540.1 534.7 530.2 526.6 524.1 522.5 521.7 521.4 521.4 521.6 522.1 522.5 522.6 522.7 523.0 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.4 523.7 523.9 524.2 524.5 525.0 525.6 525.9 526.1 526.1 525.5 524.5 522.9 520.7 517.6 514.2 510.6 506.6 502.6 499.4 496.7 494.2 492.7 491.9 491.3 491.2 491.4 491.7 492.3 492.7 493.0 493.2 493.5 493.7 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.6 493.4 493.1 492.9 492.6 492.1 491.6 491.3 491.1 491.5 492.2 493.3 495.2 497.8 500.6 504.0 508.4 512.0 515.6 518.9 521.6 523.6 524.9 525.8 526.3 526.0 525.8 525.3 524.8 524.4 524.1 523.8 523.6 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.5 523.8 524.0 524.4 525.0 525.5 526.0 526.9 527.4 527.7 527.8 527.5 527.0 526.4 525.5 524.5 523.5 522.4 521.3 520.4 519.7 519.2 518.7 518.7 519.0 519.5 520.2 520.8 521.4 521.9 522.4 522.6 522.9 523.2 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.2 522.9 522.6 523.3 523.3 523.5 523.9 524.8 526.3 529.0 533.6 539.5 548.4 560.5 577.8 598.5 620.8 646.5 675.9 700.1 720.9 741.4 755.4 765.4 773.0 778.1 781.1 782.6 783.5 783.9 784.0 784.5 784.7 784.3 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.1 784.5 784.9 784.1 784.0 783.7 783.1 782.0 780.0 775.7 770.5 762.0 748.5 731.9 712.5 688.4 660.8 635.5 611.2 586.0 569.0 555.3 543.8 535.9 531.0 527.6 525.2 524.2 523.7 523.3 523.3 522.9 522.7 523.0 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.2 522.9 522.9 522.7 522.2 521.7 521.1 520.5 519.8 519.3 519.0 519.0 519.2 519.7 520.5 521.5 522.7 524.5 526.0 528.0 530.9 534.3 538.4 543.6 549.7 555.5 561.5 568.0 572.4 575.9 578.8 580.8 581.9 582.6 582.6 582.6 582.3 582.0 581.9 582.3 582.7 583.1 583.8 584.6 585.2 585.8 586.4 586.8 587.1 587.4 587.7 588.0 588.0 588.3 588.6 588.7 588.7 588.3 587.3 585.1 582.6 578.1 572.6 564.6 555.5 546.3 536.3 525.5 517.2 510.1 503.7 499.4 496.5 494.5 493.3 492.7 492.5 492.7 492.7 492.7 492.7 492.7 492.6 492.5 492.9 493.6 494.8 497.3 501.0 505.6 511.5 519.2 529.1 538.6 548.3 558.7 567.1 573.7 579.4 583.6 586.0 587.7 588.7 588.7 588.7 588.5 588.2 588.0 587.9 587.6 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.0 586.7 586.9 587.0 587.0 587.0 587.2 588.0 589.4 592.4 597.0 603.3 612.5 625.1 639.3 655.8 678.6 698.1 716.6 735.3 750.3 761.4 770.3 777.1 780.8 782.7 784.0 784.4 784.4 784.4 784.5 784.8 784.4 784.1 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.0 784.4 784.7 784.7 784.4 784.4 784.4 784.4 783.1 781.2 777.8 771.8 763.2 752.8 739.1 720.2 702.1 682.4 663.3 643.9 627.9 615.7 605.9 598.0 593.1 590.3 588.3 587.3 587.0 587.0 587.0 586.9 586.7 587.0 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.4 587.7 588.0 588.0 588.3 588.8 589.2 589.4 589.3 588.8 587.6 585.6 582.8 578.7 573.1 566.7 559.9 552.7 544.8 538.6 533.7 528.8 525.8 523.7 522.3 521.6 521.4 521.4 521.7 522.2 522.5 522.6 522.8 523.0 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.5 523.7 524.0 524.3 524.6 525.2 525.7 525.9 526.2 525.9 525.2 524.2 522.4 519.7 516.9 513.5 509.2 505.4 501.9 498.6 495.9 493.9 492.5 491.6 491.1 491.2 491.5 491.9 492.4 492.8 493.1 493.3 493.6 493.8 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 493.9 494.2 494.5 494.7 494.9 495.4 495.9 496.3 496.5 496.6 496.2 495.5 493.9 491.9 489.5 486.4 482.6 479.1 475.7 471.9 469.4 467.2 465.5 464.4 463.8 463.5 463.8 464.0 464.5 465.0 465.3 465.5 465.7 465.9 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.3 466.5 466.8 467.1 467.5 468.0 468.5 469.1 469.7 470.0 470.2 470.1 469.7 469.2 468.5 467.6 466.7 465.7 464.7 463.9 463.2 462.7 462.2 462.1 462.3 462.7 463.2 463.9 464.4 464.8 465.3 465.5 465.8 466.0 466.2 466.2 466.2 466.4 466.7 466.9 467.3 467.8 468.3 468.9 469.5 469.9 470.2 470.2 469.9 469.4 468.7 468.0 467.0 466.0 465.1 464.2 463.4 462.9 462.4 462.1 462.2 462.5 462.9 463.6 464.2 464.6 465.1 465.5 465.7 465.9 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.3 466.5 466.7 467.0 467.4 467.9 468.4 469.0 469.6 470.0 470.2 470.2 469.7 469.2 468.6 467.7 466.7 465.8 464.9 463.9 463.2 462.8 462.3 462.1 462.3 462.6 463.1 463.8 464.3 464.7 465.2 465.5 465.8 466.0 466.2 466.2 466.2 466.4 466.7 466.9 467.3 467.8 468.2 468.8 469.5 469.9 470.2 470.2 469.9 469.4 468.9 468.1 467.1 466.2 465.3 464.2 463.5 462.9 462.5 462.1 462.2 462.4 462.9 463.6 464.1 464.6 465.1 465.4 465.7 465.9 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.3 466.5 466.7 466.7 466.9 467.2 467.2 467.2 467.0 466.1 464.4 462.4 458.9 454.5 448.1 440.9 433.6 425.7 417.1 410.5 404.8 399.8 396.4 394.0 392.4 391.5 391.1 391.1 391.1 391.3 391.5 391.5 391.7 391.8 392.0 392.0 392.0 392.2 392.4 392.3 392.2 392.2 392.2 392.1 391.5 390.6 388.6 385.6 381.6 375.9 368.3 360.1 351.0 339.3 329.8 321.3 313.1 306.8 302.4 298.9 296.3 294.9 294.1 293.7 293.5 293.5 293.5 293.5 293.4 293.5 293.6 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.6 293.5 293.3 293.5 293.5 293.5 293.5 293.7 294.2 295.1 296.6 299.0 303.0 307.8 313.9 322.0 331.7 341.2 351.0 362.0 369.9 376.4 382.2 386.3 388.9 390.6 391.7 392.2 392.2 392.2 392.2 392.3 392.4 392.2 392.2 392.0 392.2 392.2 392.4 392.4 392.5 392.8 393.2 393.4 393.4 393.2 392.7 391.5 389.7 387.4 384.2 380.0 375.6 370.9 366.3 361.5 357.5 354.4 351.9 350.0 348.8 348.3 348.1 348.0 348.1 348.4 348.7 348.8 348.8 349.0 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.2 349.0 348.9 348.8 348.7 348.4 348.2 348.0 348.1 348.2 348.7 350.0 351.6 353.9 356.8 360.5 365.4 370.0 374.7 379.8 383.6 386.8 389.5 391.4 392.6 393.1 393.4 393.4 393.2 392.9 392.6 392.4 392.4 392.2 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 392.0 391.7 391.5 391.5 391.4 391.2 391.1 391.1 391.2 392.0 393.1 394.8 398.1 402.1 407.1 413.7 421.4 429.0 436.7 445.1 451.4 456.3 460.7 463.6 465.4 466.6 467.2 467.2 467.2 467.0 466.8 466.7 466.6 466.4 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.2 466.0 465.8 465.6 465.6 465.3 464.8 464.6 464.6 464.7 465.2 466.4 468.4 470.9 474.6 479.8 485.4 491.4 498.4 504.8 510.2 514.9 519.2 521.7 523.5 524.6 525.0 525.1 525.0 524.6 524.1 523.9 523.9 523.6 523.4 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.3 523.2 522.9 522.7 522.4 522.1 521.7 521.2 520.7 520.5 520.2 520.8 521.6 522.9 525.2 528.0 531.1 534.9 539.4 543.3 546.9 550.5 553.1 555.0 556.3 557.1 557.5 557.3 557.0 556.4 555.9 555.5 555.2 554.9 554.6 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.4 554.0 553.8 553.5 553.2 552.8 552.2 551.7 551.4 551.2 551.7 552.6 554.0 556.1 558.8 562.0 566.5 570.6 574.7 579.3 582.7 585.5 587.8 589.4 590.2 590.7 590.4 590.1 589.6 589.0 588.5 588.2 587.9 587.6 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.3 587.1 587.0 586.9 586.4 585.9 585.3 584.6 583.8 583.2 582.7 582.4 582.4 582.7 583.0 583.6 584.5 585.1 585.7 586.3 586.8 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0 587.0",
+        "input_type": "phoneme",
+        "offset": 72.491
+    }
+    res = preprocess(inp)
+    print(res)
+    print([float(i) for i in res[0]])
+
+def cross_fade(a: np.ndarray, b: np.ndarray, idx: int):
+    result = np.zeros(idx + b.shape[0])
+    fade_len = a.shape[0] - idx
+    np.copyto(dst=result[:idx], src=a[:idx])
+    k = np.linspace(0, 1.0, num=fade_len, endpoint=True)
+    result[idx: a.shape[0]] = (1 - k) * a[idx:] + k * b[: fade_len]
+    np.copyto(dst=result[a.shape[0]:], src=b[fade_len:])
+    return result
+
+
+def infer_ds(model, hps, ds, speaker, trans):
+
+    sample_rate = 44100
+
+    result = np.zeros(0)
+    current_length = 0
+    for inp in tqdm.tqdm(ds):
+        spkid = hps.data.spk2id[speaker]
+        f0_seq, pitch, phseq, durations = preprocess(inp)
+
+        f0 = torch.FloatTensor(f0_seq).unsqueeze(0)
+
+        text_norm = torch.LongTensor(phseq)
+        x_tst = text_norm.unsqueeze(0)
+        x_tst_lengths = torch.LongTensor([text_norm.size(0)])
+        spk = torch.LongTensor([spkid])
+        manual_f0 = torch.FloatTensor(f0).unsqueeze(0)
+        manual_dur = torch.LongTensor(durations).unsqueeze(0)
+        t1 = time.time()
+        infer_res = model.infer(x_tst, x_tst_lengths, None, None,
+                                None, gtdur=manual_dur, spk_id=spk,
+                                F0=manual_f0 * 2 ** (trans / 12))
+        seg_audio = infer_res[0][0, 0].data.float().numpy()
+        try:
+            offset_ = inp['offset']
+        except:
+            offset_ = 0
+        silent_length = round(offset_ * sample_rate) - current_length
+        if silent_length >= 0:
+            result = np.append(result, np.zeros(silent_length))
+            result = np.append(result, seg_audio)
+        else:
+            result = cross_fade(result, seg_audio, current_length + silent_length)
+        current_length = current_length + silent_length + seg_audio.shape[0]
+        print("infer time:", time.time() - t1)
+    return result
+
+
+
+
+#
+# midis = [librosa.note_to_midi(x.split("/")[0]) if x != 'rest' else 0
+#                      for x in note_lst]

infer/share.ds

@@ -0,0 +1,62 @@
+[
+  {
+    "text": "SP 清 晨 SP",
+    "ph_seq": "SP q ing ch en SP",
+    "note_seq": "rest D4 D4 G4 G4 rest",
+    "note_dur_seq": "0.6 0.273 0.273 0.4089999 0.4089999 0.4",
+    "is_slur_seq": "0 0 0 0 0 0",
+    "ph_dur": "0.469318 0.130682 0.120727 0.152273 0.409 0.4",
+    "f0_timestep": "0.005",
+    "f0_seq": "301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 301.9 302.0 302.4 301.9 301.4 300.5 299.4 299.0 298.3 297.9 297.6 297.2 297.2 297.0 296.8 296.9 296.7 296.6 296.8 296.9 296.9 297.4 297.6 297.7 298.2 298.5 298.3 298.6 298.7 298.5 298.6 298.3 297.8 296.4 293.9 291.5 286.7 283.2 279.6 278.5 283.4 288.4 293.5 298.6 303.9 309.3 314.7 320.3 325.9 331.7 337.5 343.5 349.5 355.7 362.0 368.3 374.8 381.5 387.1 388.7 391.3 393.6 396.1 397.7 398.7 399.3 399.6 399.8 399.4 399.0 398.6 397.9 397.7 397.1 396.7 396.1 396.0 395.4 395.6 395.7 395.9 395.9 396.1 396.4 396.8 397.0 397.3 397.5 397.5 397.5 397.7 397.7 397.7 397.7 397.9 397.7 397.7 397.7 397.7 397.7 397.7 397.5 397.5 397.2 397.0 397.0 396.7 396.6 396.6 396.5 396.3 396.3 396.1 396.1 396.3 396.3 396.1 396.3 396.3 396.4 396.6 396.7 396.6 396.9 397.2 396.8 397.4 397.9 398.0 398.5 399.1 399.1 399.1 399.0 398.7 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2 398.2",
+    "input_type": "phoneme",
+    "offset": 16.582
+  },
+  {
+    "text": "SP 阳 光 攀 过 窗 沿 隙 缝 SP 温 暖 了 我 的 被 窝 搅 醒 没 做 完 的 好 梦 SP 起 身 SP 手 忙 脚 乱 匆 匆 出 门 SP 怕 赶 不 上 整 点 开 走 的 巴 士 一 路 狂 奔 SP 铃 声 SP 唤 不 动 我 疲 惫 眼 神 SP 怪 自 己 昨 夜 睡 的 太 沉 闹 钟 不 够 大 声 SP",
+    "ph_seq": "SP y ang g uang p an g uo ch uang y En x i f eng SP w en n uan l e w o d e b ei w o j iao x ing m ei z uo w an d e h ao m eng SP q i sh en SP sh ou m ang j iao l uan c ong c ong ch u m en SP p a g an b u sh ang zh eng d ian k ai z ou d e b a sh ir y i l u k uang b en SP l ing sh eng SP h uan b u d ong w o p i b ei y En sh en SP g uai z i0 j i z uo y E sh ui d e t ai ch en n ao zh ong b u g ou d a sh eng SP",
+    "note_seq": "rest G4 G4 G4 G4 G4 G4 G4 G4 F#4 F#4 G4 G4 A4 A4 G4 G4 rest F#4 F#4 F#4 F#4 F#4 F#4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 D4 D4 E4 E4 G4 G4 D4 D4 D4 D4 D4 D4 rest D4 D4 G4 G4 rest G4 G4 G4 G4 G4 G4 G4 G4 F#4 F#4 G4 G4 A4 A4 G4 G4 rest F#4 F#4 F#4 F#4 F#4 F#4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 D4 D4 E4 E4 G4 G4 A4 A4 G4 G4 F#4 F#4 rest D4 D4 G4 G4 rest G4 G4 G4 G4 G4 G4 G4 G4 F#4 F#4 G4 G4 A4 A4 G4 G4 rest F#4 F#4 F#4 F#4 F#4 F#4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 E4 D4 D4 E4 E4 G4 G4 D4 D4 D4 D4 D4 D4 rest",
+    "note_dur_seq": "0.327 0.545 0.545 0.273 0.273 0.273 0.273 0.2720001 0.2720001 0.273 0.273 0.273 0.273 0.273 0.273 0.4089999 0.4089999 0.1359999 0.273 0.273 0.2720001 0.2720001 0.273 0.273 0.273 0.273 0.2730002 0.2730002 0.2719998 0.2719998 0.2729998 0.2729998 0.2730002 0.2730002 0.2729998 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.4089999 0.4089999 0.4090004 0.4090004 0.2729998 0.2729998 0.5450001 0.5450001 0.2729998 0.2730002 0.2730002 0.5450001 0.5450001 0.2729998 0.5450001 0.5450001 0.2729998 0.2729998 0.2730007 0.2730007 0.2729998 0.2729998 0.2719994 0.2719994 0.2730007 0.2730007 0.2729998 0.2729998 0.4090004 0.4090004 0.1359997 0.2729998 0.2729998 0.2729998 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.2730007 0.2730007 0.2729998 0.2729998 0.2719994 0.2719994 0.2730007 0.2730007 0.2729998 0.2729998 0.2729998 0.2729998 0.2720003 0.2720003 0.4089994 0.4089994 0.4090004 0.4090004 0.2729998 0.2729998 0.5459995 0.5459995 0.2720013 0.2729988 0.2729988 0.5460014 0.5460014 0.2719994 0.5459995 0.5459995 0.2720013 0.2720013 0.2729988 0.2729988 0.2730007 0.2730007 0.2729988 0.2729988 0.2720013 0.2720013 0.2729988 0.2729988 0.2730007 0.2730007 0.2730007 0.2719994 0.2719994 0.2730007 0.2730007 0.2729988 0.2729988 0.2720013 0.2720013 0.2729988 0.2729988 0.2730007 0.2730007 0.2729988 0.2729988 0.2720013 0.2720013 0.2729988 0.2729988 0.2730007 0.2730007 0.2730007 0.2730007 0.4089985 0.4089985 0.4090004 0.4090004 0.2720013 0.2720013 0.4099998 0.4099998 0.081",
+    "is_slur_seq": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
+    "ph_dur": "0.245182 0.081818 0.490454 0.054546 0.202546 0.070454 0.218454 0.054546 0.151545 0.120455 0.202546 0.070454 0.136636 0.136364 0.103683 0.169317 0.409 0.087136 0.048864 0.1855 0.0875 0.178818 0.093182 0.1855 0.0875 0.234363 0.038637 0.247999 0.025002 0.228817 0.043182 0.148 0.125 0.082092 0.190908 0.218453 0.054546 0.151546 0.120455 0.229817 0.043182 0.348773 0.060226 0.245363 0.163637 0.202546 0.070454 0.545 0.175273 0.097727 0.070728 0.202272 0.545 0.109363 0.163637 0.496136 0.048864 0.1855 0.0875 0.207092 0.065908 0.169591 0.103409 0.146999 0.125 0.136637 0.136364 0.115045 0.157955 0.409 0.087135 0.048864 0.245728 0.027271 0.234365 0.038635 0.119729 0.152271 0.196862 0.076138 0.247999 0.025002 0.185498 0.087502 0.195862 0.076138 0.234365 0.038635 0.234365 0.038635 0.115045 0.157955 0.168591 0.103409 0.343089 0.06591 0.327183 0.081818 0.218453 0.054546 0.546 0.206091 0.06591 0.10368 0.169319 0.546001 0.190182 0.081818 0.497137 0.048862 0.233366 0.038635 0.202545 0.070454 0.224138 0.048862 0.218452 0.054546 0.217455 0.054546 0.120728 0.152271 0.273001 0.240046 0.032955 0.217453 0.054546 0.202547 0.070454 0.179817 0.093182 0.24473 0.027271 0.130955 0.142044 0.234365 0.038635 0.147999 0.125 0.114046 0.157955 0.196861 0.076138 0.218454 0.054546 0.202547 0.070454 0.278318 0.13068 0.376045 0.032955 0.086775 0.185226 0.41 0.081",
+    "f0_timestep": "0.005",
+    "f0_seq": "371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.9 371.5 372.2 373.2 374.9 376.0 378.0 378.4 379.3 378.6 378.6 378.0 377.3 374.9 374.5 373.1 373.2 373.6 374.3 373.6 374.5 374.3 375.2 376.7 377.6 378.1 380.4 380.8 382.8 385.5 387.2 389.1 391.3 392.7 394.3 395.4 396.8 397.2 397.9 398.4 398.6 398.6 399.2 399.3 399.3 399.5 399.3 399.1 399.3 399.3 398.9 399.1 399.1 398.8 399.1 399.1 398.6 398.8 399.1 398.6 398.6 398.6 398.2 397.9 397.7 397.5 397.5 397.7 397.2 397.2 397.0 397.0 397.0 397.2 397.2 397.2 397.2 397.2 397.0 397.2 397.2 396.8 397.0 397.2 396.6 396.7 397.0 396.2 395.6 395.0 393.6 390.4 388.0 383.9 380.2 377.8 378.3 379.5 380.7 381.9 383.1 384.3 385.5 386.7 388.0 389.2 390.4 391.7 392.9 394.2 395.4 396.6 397.9 398.2 397.9 398.3 398.2 398.0 397.9 397.7 397.7 397.2 397.4 397.5 396.8 397.0 397.0 396.8 397.0 397.2 397.2 397.5 397.7 397.7 398.2 398.2 398.6 398.6 398.6 398.2 398.0 396.8 395.6 395.0 393.4 392.0 390.4 388.7 385.7 383.0 380.8 377.6 375.6 375.3 375.6 375.8 376.0 376.3 376.5 376.7 376.9 377.2 377.4 377.6 377.9 378.1 378.3 378.6 378.8 379.0 379.3 381.5 384.3 387.3 390.9 393.3 395.2 397.3 398.6 398.6 399.0 399.1 398.5 398.2 398.2 397.8 397.5 397.3 397.2 397.0 397.0 396.6 396.4 395.9 395.4 395.0 395.0 395.0 395.2 395.9 396.2 396.6 397.3 397.7 397.2 397.2 396.6 395.2 392.7 390.0 386.8 382.2 379.2 376.0 374.3 376.8 379.3 381.8 384.3 386.9 389.4 392.0 394.6 397.2 398.2 398.0 398.4 398.4 398.2 398.4 398.6 398.4 398.4 398.6 398.4 398.4 398.6 398.4 398.4 398.4 398.4 398.2 398.2 398.2 397.9 397.9 398.2 398.0 397.7 397.5 397.3 395.2 393.7 389.3 383.9 378.4 371.9 367.7 363.4 362.4 362.7 362.9 363.2 363.5 363.8 364.0 364.3 364.6 364.9 365.1 365.4 365.7 366.0 366.3 366.5 366.8 367.1 367.4 367.7 368.1 370.7 372.6 374.4 375.4 376.0 376.2 376.0 376.2 376.2 375.6 375.8 375.8 375.6 375.8 375.8 375.6 375.8 375.8 375.6 376.0 376.2 376.2 376.4 376.7 376.7 376.9 376.5 376.6 376.7 376.2 376.4 376.2 375.7 375.8 375.6 374.9 374.5 375.4 375.6 375.8 376.4 376.5 376.1 376.7 377.1 377.1 378.4 379.5 381.5 383.9 386.5 390.0 392.2 394.3 395.4 396.2 397.2 397.6 397.9 397.9 398.3 398.4 398.2 398.2 398.2 398.0 398.2 398.0 397.9 398.2 398.0 397.7 397.9 397.9 397.5 397.5 397.5 397.1 397.0 396.6 396.0 394.3 391.8 387.9 384.2 382.1 379.5 382.2 384.8 387.5 390.3 393.0 395.7 398.5 401.3 404.1 406.9 409.8 412.7 415.5 418.4 421.4 424.3 427.3 430.3 433.3 436.3 439.4 441.0 441.0 441.7 442.8 443.2 443.3 443.6 444.0 444.1 443.9 444.1 444.1 444.1 444.3 444.3 444.6 444.6 444.6 444.9 444.9 444.6 445.1 444.9 444.9 445.3 444.6 444.3 443.5 441.0 439.7 435.7 431.4 427.7 422.3 418.7 415.3 414.6 413.8 413.1 412.3 411.6 410.9 410.1 409.4 408.7 407.9 407.2 406.5 405.7 405.0 404.3 403.6 402.9 402.1 401.4 400.7 400.2 399.7 398.6 398.2 398.2 397.9 397.9 397.7 397.9 397.9 397.5 397.7 397.5 397.3 397.5 397.5 397.1 397.2 397.2 397.0 397.2 397.2 397.0 397.0 397.2 397.0 397.4 397.7 397.5 397.7 397.9 397.7 397.9 398.1 397.9 397.9 397.9 397.9 397.9 397.9 397.9 397.7 397.7 397.9 397.9 397.9 398.1 398.4 398.4 398.8 399.5 399.5 400.5 401.2 401.4 402.3 402.9 403.0 402.8 402.8 402.1 401.2 400.3 399.4 398.5 397.6 396.7 395.8 394.9 394.1 393.2 392.3 391.4 390.5 389.7 388.8 387.9 387.1 386.2 385.3 384.5 383.6 382.7 381.9 381.0 380.2 379.3 378.5 377.6 376.8 375.9 375.1 374.3 373.4 372.6 371.7 370.9 370.1 369.3 368.4 367.6 366.8 366.0 365.8 366.6 367.4 368.5 369.1 370.2 371.1 371.7 372.2 372.8 373.3 373.4 373.4 373.6 373.2 373.4 373.4 373.2 373.0 373.2 372.9 373.0 373.2 373.2 373.0 373.2 373.0 372.8 372.8 372.1 372.0 372.1 371.3 371.3 371.9 371.6 371.7 372.1 371.6 371.7 372.1 371.3 371.3 371.5 370.6 370.5 370.9 370.2 370.0 370.6 370.3 370.0 370.9 370.9 370.9 371.4 372.1 373.0 373.7 374.9 375.1 376.0 376.0 376.0 376.2 376.4 376.0 376.0 375.8 375.6 375.4 375.2 374.9 374.9 374.9 374.9 374.9 374.9 374.9 374.9 374.8 374.7 374.5 374.5 374.3 374.1 374.1 373.9 374.0 374.3 374.1 374.5 374.5 374.3 374.5 374.5 374.3 374.5 374.3 373.6 373.6 373.2 372.6 372.7 372.6 372.4 372.8 373.0 373.2 373.9 374.6 374.9 375.4 367.2 368.1 369.3 370.9 371.5 371.5 371.7 371.9 371.7 371.9 371.9 371.9 372.3 372.4 372.1 372.5 372.6 372.6 372.8 373.0 373.0 373.0 373.2 373.2 373.2 373.2 373.4 373.4 373.2 372.6 372.0 371.5 370.2 368.1 366.6 364.5 360.5 358.4 354.7 351.3 349.1 346.2 342.2 337.3 334.0 332.4 330.8 330.3 329.8 329.8 329.3 329.8 329.7 330.0 329.6 331.5 333.5 334.3 335.0 335.2 335.4 335.2 335.4 335.4 335.2 335.0 334.8 334.6 334.2 334.2 334.1 333.8 333.8 334.0 333.8 334.0 334.2 334.2 334.4 334.4 334.6 334.6 334.6 334.6 334.6 334.5 334.4 333.9 333.3 332.7 329.8 326.2 321.4 314.7 308.1 304.4 300.0 298.1 300.0 302.8 305.6 308.5 311.3 314.3 317.2 320.1 323.1 326.2 329.2 332.3 335.4 338.5 338.7 338.1 337.1 336.8 336.0 335.6 335.2 334.8 334.5 334.2 334.1 333.8 333.8 333.8 334.0 334.0 334.0 334.2 334.2 334.2 334.2 334.2 334.0 334.0 334.0 333.9 333.3 333.3 332.9 330.4 329.0 324.9 320.2 315.8 310.9 308.7 306.0 307.9 309.8 311.8 313.7 315.7 317.7 319.7 321.7 323.8 325.8 327.8 329.9 332.0 334.1 336.2 338.3 337.8 337.5 336.9 335.8 335.6 335.3 334.6 334.6 334.6 334.0 334.2 334.0 333.7 333.7 333.7 333.2 333.1 333.1 332.7 332.7 332.8 332.7 332.8 333.1 333.1 333.1 333.7 333.5 333.5 333.7 333.3 332.9 332.9 332.7 332.3 332.5 332.3 332.0 331.9 331.9 331.6 331.2 331.0 330.6 330.2 330.0 329.8 329.7 329.8 330.0 330.3 331.0 331.6 332.9 333.8 334.6 335.4 335.7 336.0 336.0 336.0 336.2 336.0 335.6 335.8 335.5 334.8 335.0 335.0 334.6 334.8 334.8 334.6 334.6 334.6 334.3 334.0 334.2 333.7 333.5 333.3 331.0 329.7 325.1 319.7 314.2 307.4 303.6 299.1 297.9 299.9 301.9 304.0 306.0 308.1 310.1 312.2 314.3 316.4 318.5 320.7 322.8 325.0 327.2 329.4 331.6 333.8 336.1 338.3 339.1 338.8 338.7 338.7 338.3 338.1 337.8 336.9 336.6 336.0 336.0 335.5 335.4 335.4 335.2 335.2 335.4 335.0 335.2 335.4 335.4 335.4 335.6 335.6 335.8 335.8 335.0 334.0 332.9 329.8 327.2 323.7 320.1 317.8 318.1 319.0 319.9 320.9 321.9 322.8 323.8 324.7 325.7 326.7 327.6 328.6 329.6 330.6 331.6 332.5 333.5 334.5 335.5 336.5 337.5 337.1 337.1 336.7 336.4 336.9 336.4 335.9 335.6 335.1 334.4 334.0 333.7 333.5 333.3 332.9 332.7 332.4 331.9 331.6 331.5 331.7 331.7 332.1 332.3 332.9 332.9 333.0 333.3 333.1 332.9 332.7 332.5 332.3 332.0 331.7 331.5 331.1 330.6 330.4 329.6 326.6 324.6 321.2 318.7 315.7 312.6 310.6 307.9 305.7 303.8 301.9 300.3 299.5 298.8 298.5 297.8 299.1 299.7 299.8 299.5 299.3 299.2 299.3 299.3 299.1 299.0 299.1 298.8 298.7 298.8 298.6 298.5 298.5 298.5 298.1 298.3 298.1 297.9 298.1 298.1 297.9 297.6 295.9 294.3 290.1 285.6 281.5 276.9 273.9 271.6 270.9 274.0 277.2 280.5 283.7 287.0 290.4 293.8 297.2 300.7 304.2 307.8 311.4 315.0 318.7 322.4 326.2 330.0 333.8 337.7 338.9 338.4 338.3 338.0 337.3 337.3 337.0 336.4 336.4 336.0 335.6 335.6 335.0 334.8 335.0 334.8 334.5 334.6 334.3 334.0 334.2 334.1 333.8 333.8 333.7 333.7 333.7 333.7 333.5 333.5 333.3 333.3 333.1 333.1 332.7 332.1 332.0 331.0 329.7 328.7 326.8 328.2 330.8 332.4 333.7 336.0 337.9 340.1 342.4 345.8 348.8 352.0 357.8 362.0 363.2 364.5 365.4 365.5 366.4 367.2 367.0 366.8 367.9 367.5 368.5 369.8 370.1 370.6 372.4 373.0 374.9 376.9 378.9 379.6 382.8 383.5 385.1 388.2 390.0 391.8 394.0 394.8 395.9 396.4 397.0 397.2 397.2 396.6 396.4 395.9 395.2 394.4 394.3 393.3 392.4 392.0 391.1 389.5 388.8 387.3 385.3 383.8 381.9 379.9 376.7 374.3 371.8 367.2 365.1 362.5 359.9 357.2 354.6 351.9 349.3 346.8 344.2 341.7 339.1 336.6 334.2 331.7 329.2 326.8 324.4 322.0 319.6 317.3 314.9 312.6 310.3 308.0 305.7 303.5 301.2 302.1 301.9 301.2 300.5 299.7 299.1 298.7 298.3 298.0 297.8 297.6 297.6 297.4 297.6 297.4 297.6 297.6 297.6 297.6 297.6 297.6 297.6 297.6 297.6 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.6 297.8 297.8 297.8 297.8 297.9 298.1 298.1 298.5 298.6 298.6 299.0 299.0 298.3 298.4 297.4 295.5 294.1 291.6 289.4 287.0 285.6 286.0 286.4 286.8 287.2 287.6 288.0 288.4 288.8 289.2 289.6 290.0 290.4 290.8 291.2 291.6 292.0 292.4 292.9 293.3 293.7 294.1 294.5 294.9 295.3 295.7 296.6 297.9 298.4 299.1 299.7 300.0 300.0 300.0 300.0 299.5 299.1 298.8 298.4 298.1 298.1 297.8 297.4 297.3 297.1 297.1 297.1 296.9 297.0 296.9 297.1 297.2 297.6 297.4 297.4 297.4 297.3 297.4 297.2 297.1 297.2 296.8 296.4 296.0 295.2 294.3 293.8 292.8 292.4 292.1 291.3 291.2 291.0 290.7 290.3 290.6 290.8 291.0 291.0 291.8 292.3 293.4 295.5 296.9 298.1 299.1 299.1 298.8 298.5 298.5 298.3 298.1 298.1 298.0 297.8 297.8 297.8 297.6 297.6 297.4 297.4 297.3 297.2 297.2 297.1 296.9 297.0 296.9 296.7 296.9 296.7 296.7 296.9 296.9 297.1 297.2 297.2 297.2 297.2 297.2 297.4 297.6 297.6 297.6 297.4 297.4 297.6 297.6 297.6 297.6 297.6 297.4 297.6 297.4 297.2 297.6 297.4 297.6 297.6 297.6 297.4 297.6 297.6 297.6 297.6 297.6 297.6 297.8 297.8 297.8 297.8 297.6 297.4 297.4 297.2 297.1 297.1 297.1 296.9 296.9 296.9 296.8 296.9 296.9 296.9 297.1 297.2 297.2 297.4 297.8 297.8 298.1 298.5 298.6 298.8 299.1 299.4 299.7 299.8 300.0 300.0 299.7 299.3 298.8 298.3 298.1 298.1 298.1 298.1 298.1 298.1 298.1 298.1 298.1 298.1 298.1 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 298.0 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.9 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.8 297.6 297.8 297.8 297.4 298.1 297.8 297.4 297.6 297.6 297.4 297.6 297.4 297.2 297.4 297.4 297.4 297.6 297.4 297.8 297.8 297.8 298.1 298.1 298.1 298.3 298.0 297.2 296.0 293.8 290.8 288.6 285.1 284.0 286.7 290.4 294.1 297.9 301.7 305.6 309.5 313.4 317.4 321.5 325.6 329.8 334.0 338.3 342.6 347.0 351.4 355.9 360.5 365.1 369.8 368.3 367.9 368.5 369.9 370.6 371.9 371.9 373.0 373.2 374.1 374.7 375.4 375.6 375.8 375.6 376.5 376.6 377.8 378.1 379.1 379.7 381.0 382.4 384.2 385.7 387.5 388.6 390.4 391.2 392.7 393.4 393.7 394.3 395.4 395.6 396.3 396.7 396.8 396.8 396.8 396.8 396.8 396.8 396.8 396.8 397.0 397.0 396.8 397.0 397.0 397.0 397.0 397.0 396.8 396.8 396.6 396.6 396.6 396.3 396.3 396.6 396.4 396.3 396.5 396.6 396.3 396.7 396.6 396.6 396.8 396.6 396.6 396.8 396.6 396.3 396.3 396.3 396.1 396.1 396.1 396.1 396.1 396.3 396.3 396.6 396.8 396.8 397.0 397.2 397.5 397.5 397.9 398.2 398.0 398.6 398.6 398.6 399.5 399.5 399.5 400.7 400.7 400.5 401.0 400.7 400.3 400.0 399.6 399.2 398.9 398.5 398.2 397.8 397.4 397.1 396.7 396.4 396.0 395.6 395.3 394.9 394.6 394.2 393.8 393.5 393.1 392.8 392.4 392.1 391.7 391.4 391.0 390.6 390.3 389.9 389.6 389.2 388.9 388.5 388.2 387.8 387.5 387.1 386.8 386.4 386.1 385.7 385.4 385.0 384.7 384.3 384.0 383.6 383.3 382.9 382.6 382.2 381.9 381.5 381.2 380.8 380.5 380.2 379.8 380.8 380.6 380.4 379.7 380.3 379.7 380.0 379.0 378.9 377.8 378.0 377.8 378.1 377.6 377.6 377.1 377.3 377.7 378.6 379.1 380.6 381.5 383.0 385.3 387.5 389.7 391.8 392.9 394.0 394.6 395.6 395.9 396.2 396.3 396.5 396.6 396.8 396.8 396.8 396.8 396.8 396.8 396.8 396.6 396.8 396.8 396.6 396.7 396.8 396.6 396.8 396.8 396.6 396.8 396.6 396.6 396.8 396.6 396.6 396.7 396.6 396.8 396.8 396.6 396.7 397.0 396.8 397.0 397.2 397.2 397.5 397.7 397.7 397.7 397.7 397.7 397.5 397.7 397.5 397.5 397.7 397.7 397.5 397.5 397.5 397.0 396.3 396.1 394.3 393.1 391.3 389.1 387.6 385.7 384.4 383.9 383.5 383.3 384.4 384.6 384.6 386.4 386.9 387.5 388.8 390.6 392.4 394.2 396.3 396.9 397.5 397.7 397.7 397.7 397.7 397.5 397.5 397.5 397.5 397.5 397.5 397.5 397.7 397.5 397.5 397.2 397.0 396.8 396.3 395.9 395.0 394.7 393.8 392.2 391.3 389.3 386.8 385.0 381.7 379.0 375.8 373.4 372.5 373.4 374.8 376.1 377.5 378.8 380.2 381.6 383.0 384.3 385.7 387.1 388.5 389.9 391.3 392.7 394.2 395.6 397.0 397.2 397.4 397.7 397.7 397.7 397.7 397.7 397.5 397.2 397.0 396.6 396.6 396.1 396.1 395.9 395.6 395.6 395.9 395.7 395.6 395.9 395.9 395.6 395.8 396.1 396.1 396.3 396.6 396.4 396.6 396.8 396.8 396.8 397.2 397.2 397.2 397.4 397.5 397.5 397.2 397.2 397.0 396.3 395.9 395.0 394.3 393.3 392.4 392.1 391.5 390.9 391.2 391.5 391.9 393.1 394.3 395.2 396.1 397.5 397.7 397.9 397.9 397.9 397.7 397.5 397.5 397.1 397.0 396.8 396.8 396.8 397.0 397.0 397.0 397.2 397.0 396.8 396.6 396.4 395.4 394.0 393.8 392.7 391.3 391.3 390.0 388.7 387.5 385.8 383.0 380.6 379.0 376.7 375.4 374.1 372.9 371.6 370.3 369.1 367.8 366.6 365.3 364.1 362.9 361.6 360.4 359.2 358.0 356.7 355.5 356.6 359.7 363.4 366.9 370.2 372.4 373.8 374.7 375.4 375.8 375.8 375.8 375.8 376.0 376.2 376.5 376.6 376.9 377.1 377.3 377.3 377.3 377.3 376.9 376.2 375.8 375.6 374.3 373.4 373.0 370.4 369.0 367.0 364.4 360.3 357.0 354.9 352.9 353.0 354.9 357.2 359.5 361.8 364.1 366.4 368.8 371.1 373.5 375.9 378.3 380.7 383.2 385.6 388.1 389.5 392.7 393.8 396.6 397.9 398.8 399.8 400.2 400.7 400.5 400.5 400.2 400.0 399.8 399.8 399.8 399.8 399.6 399.1 398.4 397.7 397.2 396.9 396.1 395.5 395.0 394.3 393.1 391.1 389.8 387.0 383.7 381.5 378.4 376.4 377.8 380.9 384.1 387.3 390.6 393.9 397.2 400.5 403.8 407.2 410.6 414.1 417.5 421.0 424.6 428.1 431.7 435.3 439.0 439.6 442.5 443.1 444.3 445.6 445.6 445.4 445.6 445.4 444.9 444.6 444.3 443.8 444.0 444.1 444.3 444.6 444.9 445.1 445.6 445.8 446.1 446.4 446.4 446.7 446.7 446.4 446.1 445.9 444.9 444.4 442.3 440.5 438.4 434.7 430.7 425.0 421.1 418.5 415.3 412.2 410.3 407.7 404.8 402.3 399.6 395.6 395.0 393.1 390.6 391.0 391.3 392.0 392.8 395.6 396.4 397.2 397.5 397.9 397.7 397.7 397.5 397.2 397.0 396.8 396.6 396.3 396.1 395.9 395.6 395.6 395.6 395.9 395.9 395.9 395.9 396.1 395.9 396.1 396.3 396.3 396.6 396.8 396.8 397.0 397.2 397.2 397.2 397.4 397.5 397.5 397.7 397.7 397.7 397.7 397.5 397.5 397.5 397.5 397.2 397.4 397.5 397.2 397.4 397.5 397.5 397.7 398.2 398.2 398.6 399.4 399.8 400.2 400.8 400.7 399.8 400.2 399.3 399.1 398.2 397.2 396.2 395.1 394.1 393.1 392.1 391.0 390.0 389.0 388.0 387.0 386.0 385.0 384.0 383.0 382.0 381.0 380.0 379.0 378.0 377.0 376.0 375.0 374.1 373.1 372.1 371.1 370.2 369.2 368.2 367.3 366.3 365.4 364.4 363.5 362.5 361.6 360.6 359.7 358.8 357.8 356.9 356.0 355.0 354.1 355.7 359.0 362.0 365.1 369.1 370.7 373.9 375.2 375.2 375.8 376.2 375.4 375.6 375.4 374.5 373.8 373.2 372.1 372.0 372.1 372.3 372.8 373.9 374.0 375.2 375.9 376.0 376.0 376.0 374.7 374.1 373.2 370.0 367.7 363.2 359.7 354.5 350.8 348.8 349.7 351.3 353.0 354.6 356.3 357.9 359.6 361.3 363.0 364.7 366.4 368.1 369.8 371.5 371.7 371.9 371.9 371.5 371.3 371.1 370.9 370.9 371.3 371.7 372.2 372.8 373.0 373.2 373.6 373.6 373.9 374.0 374.1 374.3 374.5 374.3 373.8 373.0 372.6 371.9 371.7 371.9 371.7 371.7 372.2 372.1 372.0 372.1 371.9 370.9 369.1 367.4 364.3 361.8 359.2 356.2 353.9 352.1 350.8 353.5 356.2 358.8 361.5 364.3 367.0 369.8 372.6 375.4 378.2 378.8 379.1 378.4 377.3 377.3 377.2 376.7 376.7 376.9 376.5 376.1 376.2 375.6 375.6 375.8 375.4 375.4 375.6 375.4 375.4 375.6 375.4 375.8 375.8 375.4 375.4 374.7 374.0 371.3 367.7 363.4 357.2 353.4 349.4 348.4 348.1 347.8 347.4 347.1 346.8 346.4 346.1 345.8 345.4 345.1 344.8 344.5 344.1 343.8 343.5 343.1 342.8 342.5 342.2 341.8 342.0 341.3 340.9 339.9 339.1 338.3 337.1 336.4 335.8 335.4 335.1 335.2 335.0 335.0 335.0 335.0 334.8 334.6 334.8 334.6 334.3 334.2 333.7 333.1 332.7 332.2 331.3 331.5 331.5 331.0 331.0 330.4 329.8 328.5 325.3 322.6 317.3 313.4 309.2 306.8 309.0 311.1 313.3 315.5 317.7 319.9 322.2 324.4 326.7 329.0 331.2 333.6 335.9 337.3 337.5 337.2 336.9 336.6 336.6 336.2 335.8 335.4 334.9 334.6 334.4 334.1 334.2 334.2 334.0 334.2 334.4 334.2 334.2 334.4 334.0 333.9 333.8 333.4 333.5 333.3 332.8 332.5 332.3 331.7 331.7 331.6 331.0 331.1 330.8 330.4 330.4 328.9 327.4 324.7 321.2 317.9 314.0 311.2 308.3 306.7 309.2 311.8 314.4 317.0 319.7 322.4 325.1 327.8 330.5 333.3 333.7 334.2 334.7 335.0 335.0 335.5 335.6 335.4 335.6 335.6 335.4 335.4 335.4 335.4 335.2 335.0 334.8 334.5 334.2 333.8 333.7 333.1 332.3 332.3 331.3 331.8 331.9 332.1 332.3 331.7 331.2 330.2 327.4 324.7 320.4 316.9 312.4 310.1 310.1 310.6 311.1 311.6 312.1 312.5 313.0 313.5 314.0 314.5 315.0 315.5 316.0 316.5 317.0 317.5 318.0 320.5 323.8 327.0 330.0 332.3 334.4 335.6 335.9 336.6 336.6 336.2 336.4 336.0 335.8 335.6 335.3 334.8 334.8 334.8 334.4 334.6 334.6 334.5 335.0 334.6 334.0 332.7 329.2 324.5 318.0 312.9 306.7 303.6 301.2 303.1 304.9 306.8 308.7 310.6 312.5 314.5 316.4 318.3 320.3 322.3 324.3 326.3 328.3 330.3 332.3 334.4 336.4 338.5 339.7 339.1 338.6 337.7 337.1 336.4 336.2 335.8 335.2 335.4 335.0 334.8 334.8 334.6 334.4 334.6 334.4 334.6 334.8 334.6 334.8 335.0 334.8 334.8 334.8 334.8 334.8 334.6 334.4 334.1 333.7 333.3 332.0 330.6 328.4 324.0 319.7 315.4 310.1 305.4 302.8 300.7 299.8 302.6 306.4 310.2 314.1 318.0 321.9 325.9 330.0 334.1 338.3 340.1 339.6 338.5 336.9 336.3 335.2 334.9 334.4 334.0 333.9 333.8 333.7 333.7 333.7 333.8 333.8 334.0 334.2 334.2 334.2 334.4 334.2 334.2 334.2 333.7 333.5 333.0 330.4 328.3 325.6 319.9 315.6 309.2 304.4 300.4 296.6 296.9 297.3 297.6 298.0 298.3 298.7 299.0 299.4 299.7 300.1 300.5 300.8 301.2 301.5 301.9 302.3 302.6 303.0 301.5 301.6 301.0 300.4 300.0 299.4 298.6 298.8 298.3 297.9 298.1 297.8 297.6 297.6 297.4 297.4 297.6 297.4 297.4 297.6 297.4 297.4 297.4 297.2 297.2 297.4 297.6 298.0 298.6 299.0 299.0 299.1 298.3 296.4 294.2 291.2 286.8 284.3 281.7 284.1 286.6 289.1 291.6 294.1 296.6 299.2 301.8 304.4 307.0 309.7 312.4 315.1 317.8 320.5 323.3 326.1 328.9 331.8 334.6 337.5 337.9 338.9 339.1 338.5 338.3 338.1 337.9 337.9 337.1 336.6 335.9 335.6 335.3 335.0 334.6 334.6 334.2 334.2 334.2 334.2 334.2 334.0 333.8 333.1 331.9 331.1 328.5 326.8 324.9 322.3 320.4 319.0 320.7 322.5 324.4 326.2 328.0 329.9 331.7 333.6 335.5 337.3 339.2 341.1 343.1 345.0 346.9 348.9 350.8 357.2 363.1 371.9 374.3 376.9 380.2 382.2 385.3 387.7 390.0 390.6 391.8 392.7 393.2 394.0 394.7 394.9 395.0 395.1 395.4 395.9 396.2 396.8 397.0 397.5 397.7 397.9 397.9 398.1 398.2 398.2 398.0 398.2 397.9 397.9 397.9 397.9 397.9 397.9 397.9 397.9 397.7 397.9 397.9 397.5 397.2 397.2 397.0 396.6 396.8 396.8 396.4 396.1 396.1 395.4 395.4 395.4 395.0 394.3 394.3 393.6 393.6 393.8 394.2 393.8 395.9 396.4 396.9 397.4 397.9 398.4 397.4 396.8 395.6 394.7 395.4 395.6 394.7 395.5 395.6 396.6 398.3 402.1 405.8 407.9 407.9 409.1 410.3 411.3 412.2 413.9 413.9 414.3 414.5 414.8 414.6 415.0 414.1 414.3 414.1 414.8 415.6 417.5 418.3 420.6 422.6 425.0 428.2 431.4 433.4 435.7 437.0 439.2 440.3 442.0 442.8 443.0 443.1 443.5 443.6 443.8 444.5 444.9 444.9 445.4 445.4 445.2 445.4 444.5 443.3 440.8 438.4 435.2 431.4 428.7 425.7 424.6 423.5 422.4 421.2 420.1 419.0 417.9 416.8 415.6 414.5 413.4 412.3 411.2 410.1 409.0 408.0 406.9 405.8 404.7 403.6 402.5 401.5 400.4 399.3 398.3 397.2 396.1 395.1 394.0 394.7 396.2 397.0 398.2 398.8 399.1 399.1 398.8 398.8 398.4 398.2 398.0 397.9 397.7 397.7 397.7 397.5 397.7 397.7 397.2 397.0 396.6 395.2 394.8 393.1 392.0 391.1 389.3 387.6 384.8 381.9 379.2 375.4 372.1 369.6 370.1 370.6 371.1 371.6 372.1 372.6 373.2 373.7 374.2 374.7 375.2 375.7 376.3 376.8 377.3 377.8 378.3 378.9 377.6 377.1 377.3 376.6 375.8 375.6 375.2 374.7 374.9 374.7 374.7 374.7 374.7 374.4 374.5 374.5 374.5 374.5 374.5 374.3 374.3 374.3 374.3 374.1 373.9 373.9 373.6 373.6 373.6 373.6 373.9 374.3 374.5 374.7 374.9 375.1 375.4 375.6 375.6 375.6 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 375.8 376.0 375.8 376.0 376.0 375.8 376.0 375.8 375.8 375.6 375.6 375.2 375.2 375.2 374.9 374.7 374.7 374.5 374.5 374.7 374.7 374.9 375.2 375.2 375.2 375.6 375.6 375.6 376.0 376.0 376.0 376.7 376.7 377.0 377.8 377.8 378.2 378.6 378.5 377.8 378.0 376.9 376.0 374.0 371.9 369.9 367.9 365.9 363.9 361.9 360.0 358.0 356.0 354.1 352.2 350.3 348.3 346.5 344.6 342.7 340.8 339.0 337.1 335.3 333.5 331.6 329.8 328.0 326.3 324.5 322.7 320.9 319.2 317.5 315.7 314.0 312.3 310.6 308.9 307.2 305.6 303.9 302.2 300.6 299.0 297.3 295.7 294.1 292.5 290.9 289.3 287.7 286.2 284.6 283.1 281.5 283.2 285.6 287.6 290.6 292.5 295.0 296.2 296.9 296.9 297.0 297.4 297.2 297.5 297.8 297.6 297.8 298.1 297.8 297.8 298.1 297.6 297.8 297.6 297.4 297.1 297.2 296.9 297.2 297.9 297.9 298.8 299.1 298.9 298.1 297.0 295.0 291.6 289.5 286.6 285.0 287.6 291.3 295.0 298.8 302.6 306.5 310.5 314.4 318.5 322.6 326.7 330.9 335.2 339.5 343.8 348.3 352.7 357.3 361.9 366.5 366.4 366.2 366.3 368.5 368.9 370.2 371.3 372.2 372.4 374.1 374.5 374.7 374.7 374.7 373.8 373.9 373.9 374.2 374.9 376.0 376.7 378.2 379.5 381.9 383.4 385.7 387.3 388.6 390.0 391.5 392.4 393.4 393.9 395.0 395.3 396.6 396.8 397.2 397.2 397.2 397.2 397.2 397.2 397.2 397.2 397.2 397.2 397.4 397.2 397.4 397.5 397.5 397.5 397.7 397.5 397.7 397.9 397.7 397.7 397.9 397.9 397.9 398.1 398.2 398.0 397.9 397.9 397.7 397.7 397.7 397.5 397.5 397.3 397.2 397.0 397.0 397.0 396.8 396.8 396.8 396.3 396.3 396.3 395.9 396.1 396.3 396.3 396.5 397.2 397.4 397.7 398.6 398.6 398.8 399.5 399.3 399.8 400.5 401.4 402.2 403.7 404.6 404.6 405.6 404.8 404.1 403.4 402.7 401.9 401.2 400.5 399.7 399.0 398.3 397.6 396.8 396.1 395.4 394.7 394.0 393.3 392.5 391.8 391.1 390.4 389.7 389.0 388.3 387.6 386.9 386.2 385.5 384.8 384.1 383.4 382.7 382.0 381.3 380.6 379.9 379.2 378.6 377.9 377.2 376.5 375.8 375.1 374.5 373.8 373.1 372.4 371.7 371.1 370.4 369.7 369.1 368.4 367.7 367.1 366.4 365.7 365.1 364.4 364.3 365.5 367.4 368.5 368.7 369.8 369.6 368.9 368.5 368.3 367.2 366.9 366.2 365.3 364.1 364.1 363.4 363.8 364.9 365.6 366.0 367.9 368.5 370.4 372.6 374.9 376.4 379.5 380.8 382.1 384.8 386.4 387.5 389.7 390.5 392.2 393.2 395.2 395.9 396.6 396.8 397.0 396.8 396.8 397.0 396.8 396.8 397.0 396.8 396.8 397.0 396.8 397.0 397.2 397.2 397.5 397.7 397.7 397.9 398.1 398.2 398.2 398.2 398.2 398.0 397.7 397.7 397.0 396.3 395.9 395.2 394.6 394.3 393.8 393.2 393.6 393.0 392.7 393.1 393.3 392.7 393.4 393.4 392.7 393.1 392.9 391.8 390.4 389.3 387.0 384.4 382.3 379.5 377.6 379.0 380.5 381.9 383.4 384.9 386.4 387.9 389.4 390.9 392.4 393.9 395.4 396.9 398.5 400.0 400.2 400.5 399.9 399.1 399.5 399.7 399.3 399.3 399.5 398.8 398.7 398.8 398.5 398.4 398.6 398.4 398.2 398.3 398.2 398.2 398.3 398.2 398.2 398.2 397.9 397.7 397.7 397.5 397.0 396.8 396.6 395.9 394.5 392.7 389.3 385.4 379.1 374.9 368.5 364.5 367.2 370.0 372.8 375.6 378.4 381.2 384.1 387.0 389.9 392.8 395.7 398.7 401.7 402.3 401.6 401.4 400.0 399.2 398.8 398.4 398.0 397.9 398.1 397.9 397.9 398.1 398.4 398.4 398.6 398.6 398.4 398.6 398.6 398.4 398.6 398.6 398.4 398.4 398.4 398.2 398.3 398.2 398.0 398.2 397.9 397.9 398.2 398.0 397.9 397.7 397.3 397.2 397.0 396.3 396.6 396.2 395.4 395.9 396.1 395.9 397.0 397.7 397.9 398.8 399.3 399.5 399.5 399.7 399.5 399.5 399.5 399.3 399.3 399.1 398.8 398.7 398.4 398.2 397.7 397.5 397.5 397.2 397.0 397.2 397.0 397.2 397.2 397.2 397.2 397.5 397.3 397.2 397.2 396.6 395.9 395.5 393.6 390.8 387.3 382.6 378.6 373.4 371.1 370.8 371.0 371.2 371.5 371.7 371.9 372.1 372.3 372.5 372.7 373.0 373.2 373.4 373.6 373.8 374.0 374.3 374.5 374.7 374.9 375.1 375.3 375.5 375.6 375.8 375.8 375.4 375.9 375.4 375.2 375.6 375.2 375.2 375.4 374.8 374.7 374.7 374.5 374.5 374.7 374.5 374.7 374.7 374.7 374.9 374.9 374.7 374.0 372.4 370.7 366.6 363.0 358.7 353.9 350.2 349.0 351.4 353.9 356.3 358.8 361.3 363.8 366.3 368.8 371.4 373.9 376.5 379.1 381.7 384.4 387.0 389.7 392.4 395.1 397.8 399.1 399.3 399.1 398.8 398.6 398.8 398.6 398.6 399.1 398.9 398.6 398.8 398.7 398.2 398.3 398.2 397.9 397.9 397.7 397.5 397.5 397.5 397.3 397.2 397.2 396.8 397.0 397.0 396.8 397.0 397.0 397.0 397.2 397.2 397.0 397.2 397.0 396.6 396.3 395.4 394.0 392.2 393.2 394.7 395.1 395.6 396.8 397.7 398.8 401.0 404.4 407.9 411.7 417.7 424.0 426.2 428.7 431.4 434.7 436.2 438.7 440.3 440.9 441.5 442.2 442.8 443.3 443.5 444.1 444.3 444.3 444.9 445.1 444.9 445.1 445.1 444.3 444.6 444.1 443.3 442.0 440.8 438.6 434.7 432.4 429.0 426.0 425.0 423.9 422.8 421.7 420.7 419.6 418.5 417.5 416.4 415.4 414.3 413.2 412.2 411.1 410.1 409.1 408.0 407.0 405.9 404.9 403.9 402.9 401.8 400.7 400.0 399.6 399.5 399.7 399.3 399.5 399.3 398.4 398.4 397.9 397.2 397.4 397.0 396.8 396.8 396.8 396.4 396.8 396.6 396.6 396.8 396.6 396.6 396.7 396.8 396.6 396.7 396.8 396.6 396.8 396.8 396.6 396.8 396.6 396.3 396.6 396.6 396.3 396.5 397.0 397.0 397.0 397.2 396.8 396.3 396.3 395.6 395.2 393.8 393.4 393.1 392.9 392.7 392.4 392.2 391.9 391.7 391.5 391.2 391.0 390.7 390.5 390.2 390.0 389.8 389.5 389.3 389.0 388.8 388.6 388.3 388.1 387.8 387.6 387.4 387.1 386.9 386.6 386.4 386.2 385.9 385.7 385.5 385.2 385.0 384.7 384.5 384.3 384.0 383.8 383.6 383.3 383.1 382.8 382.6 382.4 382.1 381.9 381.7 381.4 381.2 381.0 380.7 380.5 380.3 380.0 379.8 379.3 378.8 378.0 378.2 378.2 378.0 377.8 377.8 377.8 377.2 376.9 376.7 376.0 376.0 375.8 375.6 375.6 375.4 375.4 375.4 375.4 375.4 375.4 375.2 375.2 375.2 375.0 374.3 373.0 371.6 367.2 362.8 355.5 350.4 346.4 343.2 344.7 346.1 347.6 349.1 350.5 352.0 353.5 355.0 356.5 358.0 359.5 361.0 362.6 364.1 365.6 367.2 368.7 370.3 371.9 373.4 374.7 375.2 375.4 374.8 375.2 375.8 375.4 375.2 375.5 374.9 374.8 375.2 374.5 374.5 374.7 374.5 374.3 374.5 374.3 374.3 374.3 373.9 373.6 372.7 371.3 369.1 364.7 360.3 355.1 347.4 341.1 336.4 331.7 329.2 330.4 332.6 334.8 337.1 339.3 341.6 343.9 346.2 348.5 350.8 353.1 355.5 357.8 360.2 362.6 365.0 367.5 369.9 372.4 374.9 375.4 375.2 375.2 374.7 375.1 375.6 375.6 376.0 376.2 376.1 376.2 376.4 376.0 376.2 376.2 376.0 376.2 376.2 376.0 376.2 376.0 375.8 376.0 375.4 374.5 373.0 368.7 364.1 357.2 351.6 343.8 339.9 334.2 332.1 332.3 332.5 332.7 333.0 333.2 333.4 333.6 333.8 334.0 334.2 334.4 334.7 334.9 335.1 335.3 335.5 335.7 335.9 336.1 336.4 336.8 337.1 337.0 336.6 336.6 336.6 336.6 336.4 336.6 336.2 336.0 336.0 335.6 335.6 335.6 335.6 335.2 335.4 335.4 335.2 335.2 335.4 335.0 335.0 334.8 334.8 334.6 334.5 334.4 334.4 334.3 334.4 334.6 334.8 335.0 335.5 335.4 335.4 335.6 334.6 333.8 333.1 331.8 329.8 329.4 328.8 328.1 328.7 329.4 329.8 330.8 331.9 332.7 333.8 334.6 335.1 335.6 335.7 336.2 336.4 336.2 336.4 336.2 336.0 335.8 335.5 335.2 335.2 335.0 335.0 334.8 334.8 334.6 334.8 334.8 334.8 335.0 335.0 334.8 334.6 334.1 333.7 331.9 328.7 324.3 320.8 317.1 315.7 316.4 317.5 318.6 319.8 320.9 322.0 323.2 324.3 325.5 326.7 327.8 329.0 330.2 331.3 332.5 333.7 334.9 336.1 337.3 338.5 339.7 340.1 339.7 340.1 339.6 339.5 339.3 338.8 337.9 337.3 336.4 336.0 335.5 335.6 335.8 335.8 335.8 336.1 335.8 335.8 336.0 336.0 335.8 336.0 335.8 336.2 336.2 336.2 336.2 336.2 336.0 335.8 335.6 335.0 334.8 332.7 331.0 326.8 320.8 314.7 310.4 306.5 305.0 306.8 309.5 312.2 314.9 317.6 320.3 323.1 325.9 328.7 331.6 334.5 337.3 340.3 339.3 338.6 337.9 337.1 336.4 335.8 335.6 335.2 335.2 335.0 335.0 335.0 334.8 334.6 335.0 334.6 334.8 334.8 334.5 334.4 334.8 334.5 334.4 334.6 334.0 333.8 333.8 332.3 331.3 327.5 322.8 318.4 312.2 308.6 309.1 309.6 310.1 310.5 311.0 311.5 312.0 312.4 312.9 313.4 313.9 314.4 314.9 315.3 315.8 316.3 316.8 317.3 317.8 318.3 318.8 320.8 323.3 326.2 329.4 331.7 333.1 334.8 335.8 336.1 336.6 336.4 336.2 336.2 336.0 335.8 335.4 335.2 335.0 334.8 334.8 334.8 334.8 334.6 334.5 333.8 333.3 330.9 327.5 322.1 317.1 310.9 307.2 302.6 304.0 305.3 306.7 308.1 309.4 310.8 312.2 313.6 315.0 316.4 317.8 319.2 320.7 322.1 323.5 325.0 326.4 327.9 329.4 330.8 332.3 333.7 335.4 336.5 338.3 339.0 339.5 339.5 339.0 338.5 337.9 337.1 336.6 336.2 336.0 335.8 335.6 335.4 335.4 335.0 335.0 334.8 334.4 334.1 333.7 332.9 332.1 331.9 331.1 331.0 331.0 330.8 330.4 330.7 330.6 330.4 330.4 330.0 329.7 329.4 329.0 328.7 325.5 322.8 319.5 317.5 314.4 312.0 310.5 307.9 305.6 304.0 302.1 300.6 298.3 299.3 299.7 299.8 299.5 299.0 298.5 298.8 298.5 298.5 298.5 298.3 297.9 298.1 298.0 297.6 297.7 297.6 297.6 297.7 297.6 298.1 298.1 298.3 298.4 298.5 298.6 298.5 298.5 298.2 295.9 294.7 291.0 286.8 282.4 277.5 274.2 271.5 270.1 273.9 277.8 281.8 285.8 289.8 294.0 298.2 302.4 306.7 311.1 315.5 320.0 324.5 329.2 333.8 336.4 337.7 338.0 337.5 337.1 337.0 336.7 336.4 336.0 336.0 335.5 335.0 335.0 335.0 334.8 335.1 335.4 335.4 335.4 335.2 335.2 335.0 334.7 334.8 334.8 334.6 334.8 334.8 334.6 334.8 334.6 334.2 334.4 334.4 333.8 334.0 333.3 332.3 329.8 327.4 324.4 321.2 319.5 318.2 321.7 325.2 328.8 332.3 336.0 339.6 343.4 347.1 350.9 354.7 358.6 362.5 366.5 370.5 372.1 371.9 372.8 373.9 374.9 374.9 376.5 376.1 375.8 375.6 375.6 374.9 375.7 375.4 375.6 376.5 377.8 378.3 381.1 381.6 383.0 384.8 386.5 388.2 390.2 392.0 393.1 393.7 395.0 395.0 395.6 395.9 395.7 395.4 395.6 395.4 395.4 395.4 395.2 395.2 395.2 395.0 395.0 394.7 394.2 394.0 393.1 391.2 389.5 386.5 381.1 376.9 372.6 366.4 362.7 359.0 356.5 353.9 351.3 348.8 346.3 343.8 341.3 338.9 336.4 334.0 331.6 329.2 326.8 324.5 322.1 319.8 317.5 315.2 313.0 310.7 308.5 306.2 304.0 301.8 299.7 299.3 299.2 299.1 298.5 298.1 298.3 298.0 297.6 297.6 297.1 296.9 296.6 296.4 296.1 296.2 296.0 295.9 296.0 296.0 295.9 296.2 296.1 296.0 296.2 296.2 296.0 296.3 296.4 296.4 296.6 296.6 296.6 296.7 296.7 296.7 296.7 296.9 296.9 297.0 297.1 297.1 297.2 297.4 297.3 297.4 297.2 297.2 297.2 297.2 297.2 297.1 296.9 296.9 296.7 296.2 295.9 294.3 292.3 289.2 284.5 279.8 276.8 273.4 271.8 272.8 274.5 276.2 277.9 279.6 281.3 283.0 284.8 286.5 288.3 290.0 291.8 293.6 295.4 297.2 299.0 300.9 301.0 300.9 300.6 300.5 300.2 300.0 299.7 299.5 299.0 299.0 298.7 298.5 298.3 298.1 297.9 297.9 298.1 298.0 298.1 298.1 298.1 298.1 298.5 297.9 297.9 297.9 297.1 296.4 293.8 290.8 287.7 284.0 281.9 281.1 282.2 283.3 284.4 285.6 286.7 287.8 289.0 290.1 291.3 292.5 293.6 294.8 296.0 297.2 298.3 299.5 300.7 301.9 303.1 304.3 305.6 306.8 306.5 306.6 305.8 305.4 304.4 303.1 302.3 301.2 300.2 299.3 298.8 298.2 297.6 297.6 297.2 296.9 296.9 296.6 296.6 296.6 296.4 296.5 296.6 296.6 296.7 296.7 296.6 296.7 296.9 296.8 296.7 296.9 296.9 296.9 297.3 297.2 297.4 297.6 297.6 297.6 297.9 297.8 297.8 297.6 297.6 297.6 297.6 297.4 297.4 297.3 297.1 296.9 296.6 296.4 296.2 295.9 295.7 295.9 295.5 295.4 295.7 295.6 295.7 296.2 296.4 296.6 297.2 297.4 297.8 298.5 299.0 299.1 299.7 299.3 298.5 297.2 296.2 294.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7 293.7",
+    "input_type": "phoneme",
+    "offset": 17.946
+  },
+  {
+    "text": "SP 体 温 SP 伴 着 喘 息 有 点 上 升 SP 窗 外 吹 来 了 夏 天 的 风 SP",
+    "ph_seq": "SP t i w en SP b an zh e ch uan x i y ou d ian sh ang sh eng SP ch uang w ai ch ui l ai l e x ia t ian d e f eng SP",
+    "note_seq": "rest D4 D4 G4 G4 rest G4 G4 G4 G4 G4 G4 G4 G4 F#4 F#4 G4 G4 A4 A4 G4 G4 rest F#4 F#4 F#4 F#4 E4 E4 E4 E4 E4 E4 D#4 D#4 D#4 D#4 D#4 D#4 E4 E4 rest",
+    "note_dur_seq": "0.327 0.272 0.272 0.546 0.546 0.273 0.5450001 0.5450001 0.273 0.273 0.2719998 0.2719998 0.273 0.273 0.273 0.273 0.273 0.273 0.2720001 0.2720001 0.546 0.546 0.2730002 0.2719998 0.2719998 0.2729998 0.2729998 0.4090004 0.4090004 0.4089999 0.4089999 0.2729998 0.2729998 0.4089999 0.4089999 0.4090004 0.4090004 0.2729998 0.2729998 1.091 1.091 0.081",
+    "is_slur_seq": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
+    "ph_dur": "0.179272 0.147728 0.168591 0.103409 0.546 0.224138 0.048862 0.47909 0.06591 0.14232 0.13068 0.119729 0.152271 0.202546 0.070454 0.218454 0.054546 0.136636 0.136364 0.119729 0.152271 0.546 0.158227 0.114773 0.184498 0.087502 0.103681 0.169319 0.327183 0.081818 0.34309 0.06591 0.109365 0.163635 0.27832 0.13068 0.321499 0.087502 0.087773 0.185226 1.091 0.081",
+    "f0_timestep": "0.005",
+    "f0_seq": "294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.3 294.5 295.2 295.3 295.8 295.8 296.0 295.7 295.7 295.9 295.9 295.9 295.9 295.9 296.0 295.9 295.9 296.0 295.9 295.9 296.4 296.2 296.4 296.9 296.7 296.7 297.0 296.7 296.6 296.8 296.5 296.4 296.4 296.1 295.7 295.3 297.7 300.0 301.5 302.6 304.9 306.3 307.4 310.6 312.4 315.5 319.3 322.7 327.9 332.5 338.3 344.3 349.6 358.1 364.5 366.4 367.8 369.6 370.6 372.4 373.3 373.6 373.4 373.9 373.2 374.6 374.8 375.2 374.5 374.7 373.9 374.9 374.9 376.4 376.2 377.3 377.7 379.3 380.9 383.0 384.1 385.6 386.2 387.9 388.6 390.5 391.1 392.0 392.6 393.4 394.0 394.8 395.0 395.0 395.0 395.1 395.0 395.0 395.2 395.2 395.2 395.2 395.2 395.2 395.4 395.2 395.2 395.4 395.2 395.2 395.4 395.2 395.2 395.4 395.2 395.2 395.4 395.2 395.2 395.4 395.4 395.4 395.6 395.4 395.6 395.8 395.6 395.6 395.6 395.6 395.6 395.6 395.6 395.6 395.6 395.7 395.9 395.9 395.9 395.9 395.9 396.1 395.9 395.9 396.1 396.1 396.2 396.6 396.6 396.8 397.5 397.7 397.9 398.6 398.5 398.3 399.0 398.8 398.3 397.9 397.5 397.1 396.8 396.4 396.0 395.6 395.2 394.8 394.5 394.1 393.7 393.3 392.9 392.5 392.2 391.8 391.4 391.0 390.6 390.3 389.9 389.5 389.1 388.7 388.4 388.0 387.6 387.2 386.9 386.5 386.1 385.7 385.4 385.0 384.6 384.2 383.9 383.5 383.1 382.7 382.4 382.0 381.6 381.3 380.9 380.5 380.1 379.8 379.4 379.0 378.7 378.3 377.9 377.6 377.2 376.8 376.5 376.1 375.6 374.7 376.1 376.3 376.5 375.0 375.2 374.5 374.0 372.4 372.3 371.2 371.5 371.8 372.1 371.2 371.7 370.7 371.2 372.1 372.8 373.0 375.0 375.4 376.9 379.8 381.5 383.7 386.4 387.5 389.6 391.3 393.0 393.8 394.7 395.1 395.9 396.2 396.8 397.0 397.0 397.2 397.0 397.0 397.0 397.0 396.8 397.0 396.8 396.8 396.7 396.6 396.6 396.5 396.3 396.6 396.6 396.6 396.6 396.8 396.8 397.0 397.1 397.2 397.2 397.0 396.8 396.5 396.2 395.9 395.3 394.7 393.5 393.2 392.2 391.8 392.0 391.7 391.4 391.8 391.7 391.5 392.1 391.6 390.9 391.1 390.1 388.8 387.3 385.5 381.7 379.3 376.5 375.2 376.5 377.8 379.1 380.4 381.7 383.0 384.3 385.6 386.9 388.3 389.6 390.9 392.3 393.6 395.0 396.3 396.6 396.6 396.6 396.6 396.8 397.4 397.2 397.1 397.2 396.8 396.5 396.3 395.9 395.9 395.9 395.6 395.6 395.6 395.7 395.9 395.6 395.6 395.7 395.2 395.2 394.3 392.1 390.0 385.8 381.9 375.7 372.1 366.9 365.1 366.2 367.2 368.3 369.4 370.5 371.6 372.6 373.7 374.8 375.9 377.0 378.1 379.2 380.3 381.4 382.5 383.7 384.8 385.9 387.0 388.2 390.4 391.3 393.9 395.3 396.1 397.0 397.2 397.7 397.7 397.7 397.4 397.2 397.4 397.2 397.0 397.0 397.0 396.7 396.6 396.8 396.4 396.6 396.5 396.3 396.1 395.4 394.5 392.1 389.5 387.0 383.5 382.4 381.0 381.6 382.3 382.9 383.6 384.3 384.9 385.6 386.2 386.9 387.6 388.2 388.9 389.6 390.2 390.9 391.6 392.3 392.9 393.6 394.3 395.0 395.6 395.4 395.4 395.7 395.8 395.4 395.4 395.6 395.0 394.5 394.5 393.8 393.6 393.6 393.7 393.4 393.6 393.6 393.7 394.1 394.3 394.1 394.3 394.5 394.5 394.5 394.6 394.0 394.2 393.9 393.4 393.3 393.1 392.2 392.0 391.8 390.5 390.0 389.5 388.3 386.8 385.2 383.8 383.2 382.7 381.9 380.7 380.2 378.6 377.4 376.5 375.2 374.3 374.6 375.0 375.2 374.7 374.7 374.4 374.1 374.1 373.8 373.6 373.5 373.6 373.4 373.4 373.4 373.4 373.3 373.4 373.3 373.4 373.7 373.9 373.9 374.1 374.1 373.9 373.9 373.9 373.6 373.6 373.1 372.6 371.9 370.4 368.3 363.6 359.2 355.5 350.9 349.3 351.6 353.9 356.2 358.6 360.9 363.3 365.7 368.1 370.5 373.0 375.4 377.9 380.4 382.9 385.4 387.9 390.0 390.2 391.2 391.5 392.5 392.8 393.6 394.4 395.3 396.0 396.6 397.0 397.2 397.2 397.7 397.5 397.5 397.9 397.5 397.5 397.6 397.2 397.1 397.1 396.5 396.3 396.1 395.0 394.3 392.0 389.4 386.6 381.8 379.4 377.7 377.2 380.6 384.1 387.7 391.3 394.9 398.5 402.2 405.9 409.6 413.4 417.2 421.1 425.0 428.9 432.8 436.8 440.9 444.9 448.2 448.1 447.7 446.6 446.0 445.5 444.7 444.1 443.7 443.3 443.4 443.6 443.8 444.1 444.3 444.6 444.6 444.9 445.1 444.9 445.1 444.9 444.9 445.0 444.6 444.0 443.6 442.3 440.4 436.9 432.7 427.8 423.5 419.8 418.2 417.4 416.7 415.9 415.1 414.4 413.6 412.9 412.1 411.4 410.6 409.9 409.1 408.4 407.6 406.9 406.1 405.4 404.7 403.9 403.2 402.4 401.6 400.5 400.0 399.8 399.0 398.6 398.6 398.0 397.5 397.6 397.2 397.0 397.2 397.0 396.8 397.0 396.8 396.8 396.8 396.8 396.7 396.6 396.5 396.3 396.1 396.1 396.1 396.1 396.1 396.1 396.1 396.3 396.4 396.6 396.6 396.8 396.8 397.0 397.0 397.0 397.0 397.0 397.0 397.0 397.0 396.8 396.8 397.0 397.0 397.0 397.0 397.0 397.0 397.0 397.0 397.0 397.2 397.2 397.2 397.3 397.4 397.2 397.5 397.4 397.2 397.0 397.0 396.7 396.6 396.5 396.3 396.1 396.3 396.0 395.9 395.9 395.9 395.7 395.9 396.0 395.7 396.1 396.3 396.1 396.4 396.7 396.6 397.1 397.5 397.6 398.0 398.6 398.5 399.1 399.9 400.4 401.2 402.2 402.6 402.6 402.7 402.6 401.5 400.9 400.2 399.6 399.0 398.4 397.7 397.1 396.5 395.9 395.3 394.7 394.0 393.4 392.8 392.2 391.6 391.0 390.4 389.8 389.1 388.5 387.9 387.3 386.7 386.1 385.5 384.9 384.3 383.7 383.1 382.5 381.9 381.3 380.7 380.1 379.5 378.9 378.4 377.8 377.2 376.6 376.0 375.4 374.8 374.2 373.7 373.1 372.5 371.9 371.3 370.7 370.2 369.6 369.0 368.4 367.9 367.3 366.7 366.1 365.6 365.4 367.0 369.8 371.1 373.6 374.3 375.0 375.4 375.4 375.6 375.5 374.9 374.7 374.5 373.6 373.4 372.7 372.3 372.1 372.1 371.7 372.3 372.2 372.4 372.7 373.4 373.4 374.1 374.1 374.5 374.7 375.1 374.7 374.7 374.3 374.0 373.8 373.5 372.8 372.0 371.3 370.1 369.7 369.6 369.5 370.0 371.0 371.9 372.8 373.8 374.7 375.6 376.6 377.1 377.7 378.2 378.1 377.8 377.8 376.8 376.4 376.2 375.7 375.4 375.3 375.2 375.2 375.3 375.2 375.2 375.2 374.9 374.9 374.7 374.5 374.5 374.3 374.0 373.9 373.0 371.7 368.2 364.6 360.1 353.7 348.1 344.3 341.0 339.5 338.1 336.6 335.2 333.7 332.3 330.9 329.5 328.1 326.7 325.3 323.9 322.5 321.1 319.8 318.4 317.0 315.7 314.3 313.0 311.7 311.2 314.3 317.2 319.2 319.7 320.6 321.2 320.6 320.6 320.8 319.8 319.5 319.5 318.9 318.6 318.8 318.4 318.6 319.4 319.9 320.9 322.3 323.4 324.7 326.2 328.0 329.3 330.5 331.2 331.5 332.0 332.3 332.3 332.5 332.7 332.9 333.1 333.4 333.3 333.3 333.0 332.9 332.9 332.9 332.9 333.1 333.1 333.5 333.5 333.7 333.7 333.8 333.8 333.7 333.7 333.6 333.5 333.6 333.4 333.3 333.2 333.1 333.1 333.0 332.9 332.7 332.6 332.2 331.5 331.5 330.8 330.0 329.9 329.1 328.3 328.5 328.4 328.3 329.1 330.0 331.1 331.9 334.0 334.1 334.4 334.8 334.6 334.3 334.6 334.6 334.3 334.6 334.3 334.1 334.2 334.2 334.0 334.2 334.2 334.0 334.4 334.4 334.3 334.4 334.2 334.1 334.2 334.2 334.3 334.4 334.4 334.4 334.8 334.6 334.6 334.6 334.5 334.3 334.8 334.8 334.6 334.8 334.9 334.6 334.6 334.7 334.4 334.2 334.2 334.0 333.6 333.5 333.4 333.0 332.9 333.0 332.9 332.9 333.1 333.1 333.4 333.8 333.7 333.7 333.7 332.9 332.3 331.9 331.0 330.2 329.9 329.1 328.3 328.5 328.3 328.0 328.7 329.4 330.2 331.0 332.6 333.3 334.1 335.0 335.2 335.6 335.5 335.4 335.4 335.2 335.2 335.0 334.8 334.6 334.4 334.2 334.2 334.0 334.0 333.8 333.8 333.8 334.0 334.1 334.2 334.2 334.0 334.0 333.7 333.3 332.5 331.0 328.5 325.5 321.7 316.7 313.1 310.0 310.8 311.5 312.2 313.0 313.7 314.4 315.2 315.9 316.7 317.4 318.2 318.9 319.7 320.4 321.2 322.0 322.7 323.5 324.2 325.0 325.8 326.5 327.1 326.8 325.4 325.2 324.5 322.7 321.7 320.5 319.4 318.6 317.7 316.9 316.5 316.4 316.2 316.2 316.0 315.9 316.0 315.8 316.1 316.2 316.0 316.1 316.4 316.0 316.2 316.5 316.2 316.4 316.7 316.6 316.6 316.7 316.6 316.6 316.6 316.2 316.2 316.0 315.8 315.5 315.2 314.5 312.4 310.3 306.1 301.6 297.4 294.2 290.9 288.8 289.7 290.5 291.4 292.3 293.1 294.0 294.9 295.8 296.7 297.5 298.4 299.3 300.2 301.1 302.0 302.9 303.8 304.7 305.7 306.6 307.5 308.4 309.3 310.3 311.2 312.1 313.1 314.0 315.0 316.3 317.1 317.8 318.4 318.7 318.6 318.8 318.9 318.4 318.6 318.8 318.2 318.2 318.4 317.8 317.6 317.2 316.7 316.6 316.3 316.0 315.9 315.6 315.5 315.3 315.5 315.9 316.2 316.2 316.4 316.6 316.5 316.7 316.7 316.6 316.7 316.5 316.2 316.0 315.1 314.1 313.2 312.0 311.1 311.1 310.8 311.0 311.4 311.7 311.9 312.1 312.2 312.2 312.2 312.4 312.2 312.1 312.2 312.0 311.9 312.0 311.5 310.9 310.8 309.3 307.5 305.4 303.0 301.6 299.5 298.5 299.7 302.7 305.7 308.7 311.7 314.8 317.7 319.5 320.4 320.1 319.6 319.0 318.4 317.8 317.3 316.7 316.5 316.4 316.1 316.2 316.0 316.0 316.0 316.0 315.8 316.2 316.0 316.0 316.0 316.0 315.8 315.8 315.8 314.9 314.6 312.9 310.2 308.1 303.6 299.8 295.0 292.4 290.5 291.9 293.3 294.7 296.1 297.5 299.0 300.4 301.8 303.3 304.8 306.2 307.7 309.2 310.7 312.2 313.7 315.2 316.7 318.2 319.8 321.3 322.8 322.7 321.8 321.0 321.1 320.1 319.3 318.4 318.4 317.1 317.3 317.7 317.6 317.1 317.4 316.6 316.8 316.9 316.9 317.0 318.0 317.6 318.4 319.3 320.1 320.2 322.4 322.9 324.0 325.9 327.1 328.1 329.9 330.4 331.5 332.3 333.3 333.6 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.1 334.2 334.2 334.0 334.2 334.2 334.0 334.2 334.2 334.1 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.1 334.2 334.2 334.0 334.2 334.2 334.1 334.2 334.2 334.1 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.2 334.0 334.2 334.0 334.1 334.2 334.0 334.1 334.2 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.1 334.2 334.0 334.1 334.2 334.0 334.0 334.2 334.0 334.0 334.2 334.0 334.1 334.2 334.0 334.1 334.2 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 334.0 333.8 333.8 333.8 333.7 333.7 333.7 333.6 333.5 333.5 333.5 333.3 333.5 333.5 333.5 333.5 333.7 333.6 333.5 333.7 333.7 333.7 333.7 333.7 333.8 333.7 333.8 333.8 333.7 333.7 333.8 333.7 333.7 333.8 333.7 333.7 333.7 333.7 333.5 333.8 333.5 333.5 333.7 333.6 333.5 333.7 333.7 333.7 333.8 333.8 333.7 334.0 334.0 334.1 334.5 334.8 335.1 335.7 336.2 336.7 337.1 337.4 337.5 336.6 336.1 335.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6 334.6",
+    "input_type": "phoneme",
+    "offset": 43.037
+  },
+  {
+    "text": "SP 夕 阳 晚 照 轻 眺 余 晖 风 在 背 后 温 柔 的 吹 SP 看 得 见 的 青 春 体 会 SP 看 不 清 我 究 竟 是 谁 SP 风 高 夜 黑 星 目 剑 眉 从 来 不 会 空 手 而 归 无 声 的 鬼 魅 SP",
+    "ph_seq": "SP x i y ang w an zh ao q ing t iao y v h ui f eng z ai b ei h ou w en r ou d e ch ui SP k an d e j ian d e q ing ch un t i h ui SP k an b u q ing w o j iu j ing sh ir sh ui SP f eng g ao y E h ei x ing m u j ian m ei c ong l ai b u h ui k ong sh ou er g ui w u sh eng d e g ui m ei SP",
+    "note_seq": "rest G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 rest F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 F#4 rest G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 A4 A4 A4 A4 G4 G4 rest G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 G4 F#4 F#4 F#4 F#4 E4 E4 E4 E4 D#4 D#4 rest",
+    "note_dur_seq": "0.6 0.272 0.272 0.273 0.273 0.273 0.273 0.273 0.273 0.2720001 0.2720001 0.273 0.273 0.273 0.273 0.2719998 0.2719998 0.273 0.273 0.273 0.273 0.273 0.273 0.2720001 0.2720001 0.273 0.273 0.2730002 0.2730002 0.2729998 0.2729998 0.1360002 0.1360002 0.1359997 0.2730002 0.2730002 0.2729998 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.2730002 0.2730002 0.2729998 0.2729998 0.2720003 0.2720003 0.1369996 0.1369996 0.1360002 0.2730002 0.2730002 0.2729998 0.2729998 0.2719998 0.2719998 0.2730002 0.2730002 0.2729998 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.1370001 0.1370001 0.1359997 0.2730007 0.2730007 0.2719994 0.2719994 0.2730007 0.2730007 0.2729998 0.2729998 0.2729998 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.1359997 0.1359997 0.2720003 0.2720003 0.2729998 0.2729998 0.2729998 0.2729998 0.2730007 0.2730007 0.2719994 0.2719994 0.2730007 0.2730007 0.2729998 0.2729998 0.2729998 0.8179998 0.8179998 0.2720003 0.2720003 0.8190002 0.8190002 0.2719994 0.2719994 1.091 1.091 0.218",
+    "is_slur_seq": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0",
+    "ph_dur": "0.436365 0.163635 0.217454 0.054546 0.175271 0.097729 0.20709 0.06591 0.130956 0.142044 0.184499 0.087502 0.20709 0.06591 0.185498 0.087502 0.151547 0.120453 0.218454 0.054546 0.234365 0.038635 0.185498 0.087502 0.20609 0.06591 0.163907 0.109093 0.212774 0.060226 0.087773 0.185226 0.136 0.011 0.125 0.218454 0.054546 0.163907 0.109093 0.217454 0.054546 0.093453 0.179546 0.148 0.125 0.202546 0.070454 0.184499 0.087502 0.137 0.065547 0.070454 0.240045 0.032955 0.148 0.125 0.201546 0.070454 0.185499 0.087502 0.191182 0.081818 0.135636 0.136364 0.103681 0.169319 0.137 0.00532 0.13068 0.234365 0.038635 0.217453 0.054546 0.185499 0.087502 0.130956 0.142044 0.202542 0.070457 0.162908 0.109093 0.202542 0.070457 0.115048 0.157951 0.20609 0.06591 0.245725 0.027275 0.148 0.125 0.229818 0.043182 0.129955 0.142044 0.212774 0.235501 0.097725 0.185498 0.087502 0.594138 0.223862 0.178815 0.093185 0.709908 0.109093 0.233364 0.038635 1.091 0.218",
+    "f0_timestep": "0.005",
+    "f0_seq": "364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.7 364.5 364.3 365.2 366.3 367.1 368.3 369.0 369.8 370.8 371.3 372.2 373.5 374.5 376.1 377.4 378.9 381.2 383.4 385.1 386.9 389.0 390.6 392.3 393.8 394.6 395.3 395.8 396.0 396.5 396.7 396.4 396.6 396.6 396.2 396.3 396.6 396.3 396.2 396.3 396.1 396.0 396.1 395.7 395.5 395.6 395.5 395.6 396.0 396.4 396.8 397.2 397.6 397.7 397.7 397.7 397.6 397.4 397.0 396.2 395.7 395.5 395.0 394.5 394.4 394.2 394.0 394.0 393.9 393.9 394.0 394.2 394.3 394.3 394.4 394.5 394.6 394.9 395.1 395.2 395.4 395.6 395.6 395.5 395.3 394.8 393.9 392.7 391.3 389.6 388.2 386.9 385.7 384.6 383.9 383.7 383.9 384.7 386.3 388.6 390.5 392.6 394.8 396.3 397.3 398.2 398.7 398.8 399.0 398.9 398.5 398.2 397.9 397.4 396.7 396.7 396.6 396.3 396.5 396.6 396.7 396.9 397.0 397.1 397.1 396.9 396.6 395.9 395.4 394.6 393.7 393.0 392.4 391.9 391.9 392.0 391.8 391.7 391.5 390.4 389.2 387.7 385.1 382.5 380.2 378.2 377.6 378.9 380.2 381.5 382.8 384.2 385.5 386.8 388.1 389.5 390.8 392.1 393.5 394.8 396.2 397.0 397.0 397.1 397.1 397.0 396.8 396.3 395.8 395.5 395.3 395.1 394.8 394.7 394.6 394.5 394.6 394.9 395.1 395.5 395.9 396.1 396.4 396.9 397.0 397.2 397.5 397.4 397.1 396.9 396.4 395.2 393.4 390.9 387.0 382.7 377.8 373.0 369.0 368.3 369.8 371.2 372.7 374.2 375.7 377.2 378.7 380.2 381.7 383.2 384.7 386.2 387.8 389.3 390.9 392.4 394.0 395.5 397.1 398.7 399.1 399.1 399.3 399.3 399.6 399.5 399.1 398.6 398.1 397.5 397.0 396.6 396.3 396.2 396.4 396.6 396.6 396.6 396.6 396.6 396.3 396.1 396.1 395.7 394.9 394.5 393.8 392.4 391.3 389.9 388.1 385.6 382.5 379.2 375.8 373.3 371.3 371.1 372.4 373.6 374.8 376.0 377.2 378.4 379.7 380.9 382.1 383.4 384.6 385.9 387.1 388.4 389.7 391.4 393.8 395.1 396.1 396.9 396.9 396.8 396.7 396.3 396.0 395.6 395.1 394.7 394.4 394.3 394.3 394.3 394.5 394.8 395.0 395.2 395.5 395.7 396.1 396.4 396.6 396.7 396.7 396.4 396.3 396.2 395.7 395.4 395.3 395.1 395.0 395.0 394.6 393.9 393.4 392.6 391.5 390.8 389.9 389.4 389.4 389.2 389.6 390.6 391.3 392.1 393.1 393.6 394.2 395.0 395.8 396.5 397.1 397.6 397.9 398.2 398.3 398.4 398.4 398.4 398.3 398.0 398.0 397.9 397.6 397.5 397.3 397.1 397.1 397.1 397.0 397.0 396.7 396.6 396.5 396.0 395.9 395.1 393.0 390.5 387.5 383.7 380.8 378.1 375.8 375.4 377.0 378.5 380.2 381.8 383.4 385.0 386.6 388.3 389.9 391.6 393.2 394.9 396.6 398.3 399.9 401.6 402.3 402.4 402.6 402.3 401.9 401.5 400.9 400.3 399.8 399.3 398.8 398.6 398.5 398.4 398.4 398.4 398.4 398.4 398.4 398.4 398.5 398.6 398.8 398.8 398.6 398.4 398.0 397.4 396.4 394.6 392.3 389.2 385.3 381.2 377.5 375.3 374.8 376.1 377.5 378.8 380.2 381.5 382.9 384.2 385.6 386.9 388.3 389.7 391.1 392.4 393.8 395.2 396.6 398.0 399.4 395.7 391.9 392.2 392.2 391.8 391.5 391.9 392.5 392.9 393.8 394.6 395.1 395.6 396.3 396.7 397.0 397.4 397.5 397.6 397.7 397.7 397.6 397.2 397.0 396.7 396.3 395.7 395.4 394.6 392.9 391.9 390.3 387.7 385.5 382.9 380.3 377.4 375.4 374.2 374.7 376.5 378.3 380.1 381.9 383.7 385.5 387.3 389.2 391.0 392.9 394.7 396.6 398.5 400.4 400.7 400.6 400.7 400.4 400.4 400.3 400.3 400.3 400.2 399.9 399.5 399.4 399.0 398.6 398.5 398.0 397.7 397.6 397.2 397.0 396.9 396.7 396.7 396.8 396.9 397.3 397.6 397.8 398.2 398.4 398.2 398.2 397.8 396.9 395.7 393.4 390.2 385.6 379.9 375.0 371.3 371.1 373.1 375.0 376.9 378.9 380.8 382.8 384.8 386.8 388.8 390.8 392.8 394.8 396.9 398.9 399.8 399.8 399.8 399.7 399.4 399.2 399.1 399.1 398.9 399.0 399.0 398.7 398.6 398.5 398.1 397.9 397.9 397.8 397.7 397.7 397.6 397.7 397.9 397.9 398.2 398.4 398.4 398.4 398.2 397.7 396.9 395.4 393.5 391.0 387.7 384.7 381.8 379.5 378.8 379.8 380.9 381.9 382.9 383.9 385.0 386.0 387.0 388.1 389.1 390.2 391.2 392.3 393.3 394.4 395.4 396.3 397.6 399.2 399.9 400.6 400.9 400.9 400.9 400.8 400.4 400.2 400.0 399.4 399.1 398.8 398.5 398.4 398.2 398.2 398.3 398.3 398.3 398.4 398.3 398.3 398.5 398.5 398.5 398.6 398.5 398.5 398.6 398.4 398.2 398.2 397.9 397.7 397.6 397.0 396.1 395.4 394.3 393.2 392.4 391.7 391.9 392.7 393.9 395.3 396.4 396.9 397.4 397.8 398.2 398.7 399.0 399.2 399.3 399.2 399.1 399.0 398.5 398.0 397.7 397.2 397.0 396.9 396.5 396.5 396.4 396.2 396.2 396.2 396.2 396.3 396.3 396.3 396.7 397.1 397.4 397.8 398.2 398.0 398.2 398.4 398.3 398.3 398.4 398.2 397.9 397.9 397.7 397.5 397.5 397.2 396.9 396.8 396.4 395.7 395.4 395.1 394.4 394.2 394.4 394.6 395.0 395.5 395.9 396.1 396.5 396.7 396.9 397.0 396.9 396.9 397.0 396.9 396.8 396.8 396.6 396.6 396.7 396.8 396.8 396.9 396.9 396.8 396.9 397.0 397.1 397.2 397.2 397.4 397.5 397.5 397.6 397.7 397.6 397.5 397.5 397.2 396.7 396.0 394.8 392.3 389.6 386.0 381.3 376.2 371.3 367.5 364.1 364.9 368.9 372.9 376.9 380.9 385.1 389.2 393.4 397.7 401.2 402.2 402.0 401.3 400.5 399.3 398.6 398.1 397.7 397.5 397.4 397.2 397.2 397.1 396.9 396.9 396.9 396.8 396.9 397.0 397.0 397.1 397.1 397.0 397.2 397.4 397.1 397.1 396.8 396.3 395.5 393.2 390.2 386.1 381.6 376.2 371.4 367.4 364.9 365.0 365.8 366.6 367.4 368.2 369.0 369.9 370.7 371.5 372.3 373.2 374.0 374.8 375.7 376.5 377.3 378.2 379.0 379.9 380.7 381.7 384.4 387.8 390.9 393.5 395.1 396.2 396.7 397.1 397.2 397.1 397.1 397.2 397.2 397.2 397.2 397.2 397.2 397.2 397.5 397.7 397.7 397.8 397.8 397.6 397.4 396.9 396.0 394.2 390.6 386.9 382.7 378.5 376.8 376.2 375.6 375.0 374.4 373.8 373.2 372.6 372.1 371.5 370.9 370.3 369.7 369.2 368.6 368.0 367.4 366.9 366.3 365.7 365.1 366.2 368.4 370.6 373.3 375.7 377.0 378.1 379.2 379.5 379.7 379.5 379.0 378.4 378.0 377.7 377.4 377.4 377.4 377.3 377.2 376.7 376.0 375.3 374.6 373.9 373.2 372.9 372.1 371.2 371.3 370.7 370.0 369.9 369.6 368.7 367.8 366.8 364.7 361.8 358.9 355.4 352.6 350.0 347.1 346.4 347.3 349.2 353.6 359.7 365.9 372.3 376.9 379.8 380.3 379.5 378.6 377.7 376.8 376.1 375.7 375.3 375.1 374.9 374.8 374.6 374.5 374.4 374.4 374.4 374.4 374.5 374.5 374.5 374.6 374.6 374.5 374.6 374.5 374.2 373.7 371.9 369.5 365.4 359.7 353.8 348.7 345.1 342.0 341.8 343.5 345.1 346.7 348.4 350.1 351.7 353.4 355.1 356.8 358.5 360.2 361.9 363.6 365.4 367.1 368.8 370.6 372.4 373.8 374.3 374.9 375.4 375.5 375.7 376.2 376.5 376.6 376.8 376.8 376.5 376.3 376.1 376.0 376.0 376.0 376.0 375.9 375.8 375.8 375.7 375.5 375.1 374.8 374.3 373.5 373.2 372.6 371.9 371.5 370.7 370.1 370.4 370.2 369.8 369.9 369.6 368.7 367.5 365.7 362.8 359.3 355.7 352.9 350.9 350.9 351.8 355.2 359.8 365.4 371.7 376.7 379.6 380.3 379.8 379.0 378.2 377.2 376.6 376.1 375.6 375.4 375.2 375.1 374.8 374.7 374.6 374.5 374.5 374.5 374.6 374.6 374.5 374.6 374.7 374.6 374.5 374.3 373.9 373.2 371.3 368.5 364.1 359.3 353.3 347.4 343.2 342.6 344.2 345.7 347.3 348.9 350.5 352.1 353.7 355.4 357.0 358.6 360.3 361.9 363.6 365.3 366.9 368.6 370.3 372.0 373.7 375.4 377.2 378.0 378.0 378.1 377.9 377.9 378.0 378.0 377.9 377.5 377.0 376.5 375.9 375.5 375.1 374.7 374.4 374.3 374.0 374.1 374.5 374.8 375.3 375.9 376.2 376.5 376.8 376.8 376.8 376.9 376.5 376.0 375.7 374.6 373.1 371.5 369.0 365.1 361.5 358.7 356.8 356.4 357.4 358.4 359.4 360.4 361.5 362.5 363.5 364.6 365.6 366.7 367.7 368.8 369.8 370.9 371.9 372.7 374.1 375.8 376.8 377.3 377.7 377.7 377.4 377.3 377.1 376.6 376.5 376.2 376.1 376.2 376.1 375.8 375.5 374.9 374.4 374.2 373.6 373.0 372.7 371.9 371.5 371.9 371.6 371.3 371.3 370.6 370.0 369.1 368.1 366.1 363.3 361.0 358.7 358.4 359.5 360.5 361.6 362.6 363.7 364.8 365.8 366.9 368.0 369.1 370.1 371.2 372.3 373.4 374.5 375.6 376.2 376.6 376.9 376.8 376.9 376.9 376.7 376.7 376.5 376.1 376.0 375.7 375.4 375.4 375.3 375.3 375.2 375.0 375.4 375.8 375.6 375.8 376.1 375.7 375.4 375.1 374.3 373.2 371.7 369.4 365.7 362.4 359.0 356.3 354.3 354.6 356.4 358.3 360.1 362.0 363.9 365.7 367.6 369.5 371.5 373.4 375.3 377.2 379.2 381.2 383.1 383.8 383.8 383.5 382.7 381.7 380.7 379.7 379.0 378.2 377.4 377.0 376.6 376.4 376.2 376.0 375.8 375.8 375.8 375.8 375.8 375.8 375.9 376.0 376.1 376.2 376.2 376.1 375.9 375.5 374.6 373.0 369.7 366.1 361.6 357.4 356.1 357.4 358.7 360.0 361.4 362.7 364.0 365.4 366.7 368.1 369.5 370.8 372.2 373.6 375.0 376.3 377.7 379.1 380.5 381.9 383.4 385.1 387.4 389.7 392.3 395.3 397.2 398.6 399.9 400.1 400.0 399.9 399.5 399.1 398.7 398.4 398.0 397.9 397.8 397.4 397.2 397.0 396.6 396.1 395.5 394.9 394.3 394.3 394.2 393.7 394.0 394.4 394.2 394.0 393.9 392.9 391.4 390.0 387.5 384.9 382.5 379.6 377.7 376.1 376.9 379.1 381.4 383.6 385.9 388.2 390.5 392.8 395.1 397.4 399.7 401.2 401.3 401.0 400.3 400.0 400.1 399.8 399.4 399.5 399.4 398.8 398.9 398.8 398.5 398.7 398.6 398.4 398.5 398.5 398.4 398.5 398.6 398.5 398.4 398.3 397.9 397.6 397.2 396.7 395.1 393.0 389.5 385.1 379.3 373.4 368.3 364.0 363.8 365.5 367.2 369.0 370.7 372.4 374.2 376.0 377.7 379.5 381.3 383.1 384.9 386.7 388.5 390.3 392.1 394.0 395.8 397.7 399.6 400.5 400.3 400.5 400.5 400.6 400.7 400.6 400.3 400.1 399.8 399.2 398.7 398.3 397.9 397.6 397.2 396.7 396.2 396.1 396.0 395.9 396.1 396.6 397.1 397.5 397.9 398.0 398.2 398.7 398.7 398.7 399.0 398.9 399.0 399.1 398.8 398.6 398.5 398.0 397.7 397.6 397.1 396.8 396.9 396.8 396.9 397.5 397.7 398.0 398.4 398.6 398.7 399.1 399.3 399.4 399.7 399.8 399.6 399.7 399.7 399.5 399.4 399.3 399.0 398.7 398.5 398.3 398.2 398.2 398.0 397.9 397.9 397.8 397.6 397.6 397.6 397.2 397.0 396.7 395.7 394.3 391.8 387.9 383.2 378.6 373.5 368.5 365.9 366.4 368.1 369.9 371.7 373.5 375.3 377.1 378.9 380.8 382.6 384.4 386.3 388.2 390.0 391.9 393.8 395.7 397.6 398.9 399.2 399.2 399.2 399.0 399.0 399.1 398.8 398.6 398.5 398.2 397.8 397.7 397.6 397.5 397.5 397.5 397.5 397.6 397.7 397.8 397.9 397.9 397.9 397.8 397.7 397.6 396.9 396.3 394.8 391.4 387.1 381.9 377.0 372.0 368.6 368.8 372.3 375.8 379.3 382.9 386.5 390.1 393.8 397.5 401.3 405.1 408.9 412.7 416.6 420.5 424.5 428.5 432.5 436.6 438.7 439.9 441.3 442.3 443.4 444.2 444.7 445.0 445.0 445.0 444.4 444.1 443.9 443.4 442.9 442.9 442.9 442.7 442.9 443.2 442.9 443.3 443.9 444.1 444.5 445.2 444.9 444.4 443.7 442.5 441.3 439.0 436.3 434.4 432.8 432.5 433.0 433.4 433.9 434.4 434.9 435.3 435.8 436.3 436.8 437.2 437.7 438.2 438.7 439.2 439.7 440.1 440.6 441.1 441.6 441.9 442.3 443.3 444.5 445.1 445.1 445.4 445.6 445.6 445.6 445.8 445.6 445.5 445.8 445.8 445.8 446.0 446.1 446.3 446.4 446.4 446.2 446.0 445.8 445.5 444.9 443.7 441.4 438.6 435.3 431.3 428.2 426.8 425.7 424.5 423.3 422.1 420.9 419.6 418.4 417.2 416.0 414.8 413.6 412.4 411.2 410.1 408.9 407.7 406.5 405.4 404.2 403.0 402.4 402.0 401.1 400.6 400.3 400.3 400.3 400.1 399.9 399.5 399.0 398.6 398.3 398.3 398.4 398.5 398.6 398.8 398.7 398.6 398.6 398.6 398.5 398.5 398.6 398.6 398.5 398.4 398.1 397.7 397.1 396.2 395.0 393.5 390.5 387.5 384.5 381.3 380.9 382.1 383.4 384.6 385.8 387.1 388.3 389.6 390.8 392.1 393.3 394.6 395.8 397.1 398.4 399.7 401.0 402.2 402.7 402.1 401.5 400.6 400.1 399.8 399.5 399.4 399.2 399.1 399.1 398.9 399.0 399.1 398.8 398.8 399.1 399.1 399.2 399.4 399.4 399.2 399.1 399.1 399.0 398.7 398.6 398.6 398.3 398.3 398.4 398.2 398.4 398.6 398.3 397.9 397.7 396.6 394.4 391.9 388.5 384.4 380.7 377.9 376.1 374.7 373.3 371.9 370.5 369.1 367.8 366.4 365.0 365.4 366.8 368.4 369.4 370.2 370.9 371.2 371.1 371.1 371.0 371.0 371.1 371.0 370.4 370.4 370.6 371.3 373.4 376.0 378.2 381.6 384.5 387.6 391.1 394.0 396.0 396.8 397.4 397.3 397.1 396.9 396.7 396.3 396.0 395.5 394.9 394.5 393.9 393.4 393.0 392.6 392.3 392.1 391.9 391.8 391.9 391.9 392.0 392.6 393.1 393.8 394.5 395.4 396.3 397.1 397.7 398.0 398.2 398.3 398.4 398.2 398.3 398.3 398.0 398.0 397.9 397.7 397.8 397.7 397.5 397.5 397.2 397.0 397.1 397.1 397.1 397.4 397.4 397.2 397.4 397.1 396.7 395.5 392.7 389.6 385.7 381.7 377.8 374.8 372.7 372.4 373.6 374.7 375.9 377.0 378.2 379.4 380.5 381.7 382.9 384.1 385.3 386.5 387.7 388.9 390.1 391.3 393.0 395.1 397.0 398.4 399.3 400.0 400.3 400.3 400.1 399.8 399.4 399.3 399.2 398.8 398.6 398.6 398.5 398.2 398.2 398.0 397.9 397.9 397.8 397.7 397.6 397.4 396.3 394.3 391.9 388.7 384.8 381.2 377.9 377.0 378.0 379.0 379.9 380.9 381.9 382.9 383.9 384.8 385.8 386.8 387.8 388.8 389.8 390.8 391.8 392.8 393.8 394.8 395.8 396.9 397.9 398.9 398.8 398.4 398.0 397.7 397.9 398.2 398.0 397.9 397.9 397.8 397.6 397.3 397.1 396.8 396.3 396.0 395.5 395.0 395.0 394.7 394.6 394.9 395.2 395.5 396.0 396.6 396.9 397.3 397.6 397.7 397.8 397.9 397.8 397.6 397.6 397.4 396.8 396.7 396.4 395.7 395.4 395.1 394.4 394.0 393.7 392.8 392.6 392.4 391.8 391.9 392.7 393.0 393.8 394.5 395.2 396.1 397.0 398.0 398.8 399.4 399.8 400.1 400.2 400.0 399.9 399.9 399.5 399.4 399.4 399.2 399.2 399.3 399.2 399.2 399.3 399.2 399.1 399.1 398.8 398.5 398.2 397.4 395.4 393.2 389.3 383.1 376.5 370.8 366.3 361.9 358.8 359.1 361.0 362.8 364.7 366.6 368.5 370.4 372.3 374.2 376.1 378.1 380.0 382.0 383.9 385.9 387.9 389.9 391.9 393.6 393.9 394.5 395.2 395.5 396.2 397.1 397.2 397.7 397.9 397.7 397.5 397.3 397.1 397.1 397.0 396.8 396.8 396.6 396.4 396.4 396.4 396.3 396.3 396.3 396.2 396.1 396.0 395.7 395.5 395.3 394.9 394.4 394.1 393.7 392.8 392.2 391.4 390.2 390.0 390.2 390.0 390.1 390.7 390.3 390.1 390.4 389.7 389.6 390.1 390.0 390.4 391.5 392.9 394.7 397.0 398.3 398.5 398.6 398.6 398.5 398.4 398.4 398.4 398.3 398.0 398.0 398.0 397.9 397.9 397.9 397.9 397.9 397.9 397.8 397.8 397.8 397.7 397.6 397.4 396.8 395.2 393.3 389.9 385.6 380.4 374.8 369.8 366.1 365.7 367.0 368.4 369.7 371.1 372.4 373.8 375.1 376.5 377.9 379.3 380.6 382.0 383.4 384.8 386.2 387.6 389.0 390.5 391.9 393.0 394.6 395.9 396.9 397.7 398.2 398.7 399.1 399.2 399.4 399.2 398.7 398.5 398.2 397.9 398.0 397.9 397.8 398.1 398.0 398.0 398.2 398.2 398.3 398.5 398.7 398.8 398.8 399.0 398.9 398.8 398.7 398.5 398.2 397.7 397.5 397.2 396.8 396.6 396.3 395.9 395.6 395.5 395.4 395.7 396.1 396.4 397.0 397.5 398.1 398.5 399.1 399.8 400.0 400.0 399.9 399.4 398.8 398.4 397.9 397.7 397.6 397.4 397.2 397.2 397.1 397.0 397.0 396.9 396.8 396.8 396.8 396.9 397.0 397.1 397.1 397.2 397.6 397.7 397.8 397.8 397.6 397.2 396.6 395.5 393.4 389.4 384.5 379.1 373.7 370.3 369.4 371.1 372.8 374.6 376.3 378.0 379.8 381.5 383.3 385.1 386.9 388.7 390.5 392.3 394.1 395.9 397.7 399.1 399.6 399.4 399.0 399.0 399.3 399.1 399.0 399.2 398.8 398.4 398.5 398.3 398.0 398.3 398.2 398.3 398.5 398.4 398.3 398.7 398.7 398.7 399.0 399.0 398.8 399.0 399.0 399.0 399.1 398.8 398.6 397.6 395.9 393.3 389.3 384.5 380.2 375.4 371.3 369.1 369.6 371.8 374.0 376.2 378.5 380.7 383.0 385.3 387.6 389.9 392.2 394.5 396.9 399.2 401.6 402.8 403.0 403.2 403.2 402.9 402.4 401.7 400.9 400.0 399.4 398.8 398.6 398.6 398.5 398.4 398.4 398.4 398.3 398.2 398.3 398.5 398.6 398.7 398.8 398.6 398.2 397.9 396.4 393.8 390.1 385.2 380.5 375.8 371.8 370.9 371.7 372.6 373.4 374.2 375.1 375.9 376.7 377.6 378.4 379.3 380.1 381.0 381.8 382.7 383.5 384.4 385.2 386.1 387.0 387.8 389.2 391.4 393.6 395.5 396.9 397.7 398.2 398.5 399.0 399.3 399.2 399.2 399.3 399.2 399.1 399.2 399.2 399.1 399.2 399.3 399.4 399.4 399.4 399.4 399.2 398.9 398.4 397.5 395.8 393.7 391.3 388.1 384.4 381.0 378.7 378.7 379.8 380.9 382.0 383.1 384.3 385.4 386.6 387.7 388.8 390.0 391.1 392.3 393.5 394.6 395.8 397.0 398.1 399.3 399.6 399.5 399.2 398.6 398.2 398.0 397.7 397.2 397.0 396.9 396.6 396.3 396.3 396.1 395.9 395.9 395.9 396.0 396.3 396.7 396.8 396.9 397.1 397.4 397.6 397.8 397.9 397.8 397.6 396.9 396.1 394.6 392.7 390.3 387.9 385.3 382.6 381.3 379.8 378.9 379.1 379.4 379.5 380.0 380.7 381.4 382.0 382.7 383.4 384.1 384.5 384.6 385.1 385.9 387.2 388.5 389.4 390.2 391.0 391.5 392.1 392.4 392.7 393.0 393.2 393.6 394.1 394.4 394.7 395.1 395.5 395.8 395.9 396.0 396.0 395.9 396.1 396.2 396.1 396.2 396.0 395.5 394.5 392.2 388.6 384.4 379.4 375.4 373.6 374.6 375.5 376.5 377.5 378.5 379.4 380.4 381.4 382.4 383.4 384.4 385.4 386.3 387.3 388.3 389.3 390.4 391.4 392.4 393.2 394.3 395.7 396.6 397.1 397.8 398.2 398.3 398.7 398.7 398.6 398.5 398.4 398.4 398.4 398.5 398.6 398.6 398.8 399.0 399.0 399.0 399.1 398.9 398.8 399.0 398.8 398.5 398.1 397.7 397.1 396.7 396.3 395.4 394.6 393.7 392.4 390.9 389.0 387.2 384.9 382.4 380.4 378.8 377.0 375.3 374.2 373.7 373.8 373.8 373.6 373.5 373.0 372.4 372.2 372.0 371.7 372.1 373.3 373.9 374.2 374.6 374.7 374.7 374.8 374.9 374.8 374.9 374.9 374.9 374.9 374.9 374.8 375.0 375.2 375.2 375.3 375.5 375.3 375.4 375.6 375.5 375.6 375.9 375.8 375.7 375.9 375.9 375.9 376.0 375.9 375.9 376.0 375.9 375.9 376.0 375.9 375.9 376.0 375.9 375.9 376.0 375.9 375.9 376.0 375.9 375.8 375.9 375.9 375.8 375.9 375.9 375.8 375.9 375.8 375.7 375.9 375.8 375.7 375.9 375.8 375.7 375.9 375.9 375.8 375.9 375.9 375.9 376.0 375.9 375.9 376.1 376.1 376.0 376.1 376.0 375.9 376.0 375.8 375.7 375.8 375.5 375.5 375.6 375.5 375.5 375.6 375.5 375.5 375.6 375.5 375.5 375.5 375.4 375.4 375.4 375.3 375.2 375.2 375.1 375.1 375.2 374.8 374.6 374.8 374.8 375.0 375.4 375.6 375.7 375.9 375.8 375.7 375.9 375.7 375.3 374.9 374.4 373.3 371.9 370.0 367.2 364.3 361.5 359.9 358.3 357.8 358.5 359.1 359.8 360.5 361.2 361.8 362.5 363.2 363.9 364.6 365.3 365.9 366.6 367.3 368.0 368.7 369.4 370.1 370.8 371.5 372.2 372.9 373.6 374.3 375.0 375.7 376.4 377.1 377.8 378.5 379.2 379.0 378.2 377.7 377.2 376.8 376.7 376.8 376.6 376.1 376.0 375.9 375.7 375.7 375.8 375.7 375.6 375.5 375.3 374.9 374.5 373.6 373.0 372.4 371.7 371.1 370.3 369.2 367.2 364.2 360.9 356.4 352.2 348.0 343.0 337.9 333.5 329.9 328.1 328.7 329.2 329.8 330.3 330.9 331.4 331.9 332.5 333.0 333.6 334.1 334.7 335.3 335.8 336.4 336.9 335.9 335.1 335.4 335.4 335.0 334.8 334.8 334.6 334.5 334.6 334.6 334.7 334.7 334.6 334.7 334.7 334.6 334.7 334.6 334.4 334.5 334.5 334.3 334.3 334.3 334.1 334.2 334.1 334.1 334.3 334.3 334.3 334.5 334.6 334.7 334.9 334.9 335.0 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.3 335.2 335.3 335.2 335.1 335.3 335.2 335.1 335.3 335.2 335.1 335.2 335.1 335.0 335.1 335.0 334.8 334.8 334.6 334.4 334.5 334.4 334.3 334.4 334.3 334.3 334.4 334.4 334.5 334.7 334.7 334.7 334.9 334.9 335.0 335.3 335.2 335.0 335.0 334.8 334.5 334.4 334.3 334.2 334.2 334.1 334.0 333.9 333.7 333.5 333.0 332.8 332.5 332.2 331.9 331.5 331.2 330.1 328.6 326.5 323.9 321.5 320.5 321.1 321.7 322.3 322.9 323.5 324.1 324.7 325.3 326.0 326.6 327.2 327.8 328.4 329.0 329.7 330.3 330.9 331.5 332.1 332.8 333.4 334.0 334.3 334.7 335.4 335.4 335.1 335.4 335.3 335.0 335.1 335.0 334.7 334.6 334.6 334.6 334.7 334.8 335.0 335.2 335.3 335.6 335.7 335.7 335.9 335.9 335.7 335.5 335.1 334.7 334.4 334.0 333.6 333.2 332.6 331.6 330.7 329.7 328.6 327.5 326.7 325.8 325.0 324.3 323.2 321.8 320.9 319.8 318.9 318.2 317.6 317.0 317.0 316.8 316.8 316.9 317.3 317.8 317.8 317.6 317.4 317.1 317.2 317.3 317.1 317.0 317.1 317.0 316.9 317.1 317.0 316.9 317.1 316.9 316.7 316.6 316.2 316.0 316.0 315.8 315.7 315.7 315.3 315.2 315.4 315.4 315.5 315.9 316.1 316.4 316.7 316.8 317.2 317.4 317.5 317.6 317.7 317.6 317.5 317.6 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.6 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.3 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.3 317.2 317.2 317.4 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.4 317.5 317.4 317.3 317.4 317.3 317.2 317.3 317.2 317.1 317.0 316.7 316.6 316.7 316.7 316.7 316.9 316.8 316.7 316.7 316.7 316.6 316.7 316.7 316.6 316.5 316.4 316.3 316.3 316.4 316.5 316.6 316.5 316.4 316.4 316.4 316.3 316.2 316.2 316.0 315.7 315.7 315.7 315.7 315.7 315.7 315.7 315.9 316.0 316.2 316.7 317.0 317.3 317.7 317.9 318.3 318.6 318.9 319.0 319.0 319.1 319.1 319.2 319.2 319.0 319.0 318.9 318.1 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7 317.7",
+    "input_type": "phoneme",
+    "offset": 51.764
+  },
+  {
+    "text": "SP 行 走 在 危 险 边 缘 肆 意 的 怪 盗 SP 自 由 的 跳 着 指 尖 上 的 舞 蹈 SP 轻 盈 的 像 暗 影 中 藏 伏 的 波 斯 猫 等 待 下 一 个 目 标 SP",
+    "ph_seq": "SP x ing z ou z ai w ei x ian b ian y van s i0 y i d e g uai d ao SP z i0 y ou d e t iao zh e zh ir j ian sh ang d e w u d ao SP q ing y ing d e x iang an y ing zh ong c ang f u d e b o s i0 m ao d eng d ai x ia y i g e m u u b iao SP",
+    "note_seq": "rest D5 D5 B4 B4 D5 D5 G5 G5 D5 D5 C5 C5 B4 B4 A#4 A#4 A4 A4 G4 G4 D4 D4 G4 G4 rest D5 D5 B4 B4 D5 D5 G5 G5 D5 D5 C5 C5 B4 B4 C5 C5 C5 C5 G5 G5 C5 C5 rest D5 D5 B4 B4 D5 D5 G5 G5 D5 C5 C5 B4 B4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 A#4 G4 G4 D4 D4 G4 G4 F4 F4 G4 G4 A#4 A#4 C5 C5 C#5 D5 D5 rest",
+    "note_dur_seq": "0.6 0.136 0.136 0.137 0.137 0.545 0.545 0.546 0.546 0.2720001 0.2720001 0.273 0.273 0.273 0.273 0.2719998 0.2719998 0.546 0.546 0.5450001 0.5450001 0.2730002 0.2730002 0.4089999 0.4089999 0.1370001 0.1359997 0.1359997 0.1360002 0.1360002 0.546 0.546 0.5450001 0.5450001 0.2729998 0.2729998 0.2730002 0.2730002 0.2719998 0.2719998 0.546 0.546 0.2730002 0.2730002 0.5449996 0.5449996 0.6820002 0.6820002 0.1359997 0.1370001 0.1370001 0.1360006 0.1360006 0.5450001 0.5450001 0.5459995 0.5459995 0.2729998 0.2720003 0.2720003 0.2729998 0.2729998 0.3640003 0.3640003 0.1809998 0.1809998 0.3640003 0.3640003 0.1820002 0.1820002 0.3639994 0.3639994 0.1810007 0.1810007 0.3639994 0.3639994 0.1820002 0.1820002 0.4090004 0.4090004 0.4089994 0.4089994 0.2729998 0.2729998 0.2720003 0.2720003 0.5460005 0.8179989 0.8179989 0.5",
+    "is_slur_seq": "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0",
+    "ph_dur": "0.387498 0.212502 0.07009 0.06591 0.082457 0.054543 0.474542 0.070457 0.339182 0.206818 0.244725 0.027275 0.20709 0.06591 0.163907 0.109093 0.195866 0.076134 0.442591 0.103409 0.447275 0.097725 0.224134 0.048866 0.409 0.088134 0.048866 0.070089 0.06591 0.081458 0.054543 0.452815 0.093185 0.369997 0.175003 0.103681 0.169319 0.115049 0.157951 0.184498 0.087502 0.475543 0.070457 0.185499 0.087502 0.506364 0.038635 0.682 0.054182 0.081818 0.076774 0.060226 0.097365 0.038635 0.35409 0.19091 0.475542 0.273 0.070457 0.168591 0.103409 0.218457 0.054543 0.276499 0.087502 0.148048 0.032951 0.325365 0.038635 0.067231 0.114769 0.270814 0.093185 0.148049 0.032951 0.286729 0.077271 0.057 0.125 0.311275 0.097725 0.381724 0.027275 0.152547 0.120453 0.272 0.436908 0.109093 0.817999 0.5",
+    "f0_timestep": "0.005",
+    "f0_seq": "597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 597.9 596.0 595.2 593.7 593.4 592.8 591.4 591.1 589.4 588.3 588.3 586.1 585.0 583.9 580.6 577.6 573.9 570.6 565.6 556.0 549.7 543.5 537.4 531.3 525.3 519.4 513.6 507.8 501.0 501.9 501.6 501.2 500.5 500.2 500.1 499.6 498.9 498.5 497.1 494.8 492.5 487.8 483.2 476.1 469.3 464.6 459.2 456.3 463.8 471.3 479.0 486.9 494.8 502.9 511.1 519.5 527.9 536.6 545.3 552.2 550.9 550.5 551.8 554.3 555.6 557.3 557.6 559.2 559.6 560.4 561.5 562.0 561.5 562.6 562.2 562.4 563.5 563.7 563.1 564.7 564.4 566.4 568.3 570.1 571.5 574.2 575.3 577.2 580.0 581.6 581.6 584.3 584.3 586.3 588.1 590.0 591.4 592.8 592.9 593.2 593.5 593.5 593.5 593.5 593.5 593.5 593.4 593.1 593.1 593.1 593.1 593.1 592.8 592.4 592.5 592.8 592.4 592.4 592.4 592.3 591.8 591.9 591.1 590.5 590.8 591.1 590.9 591.8 591.7 591.5 592.1 591.7 591.4 591.6 591.0 590.4 590.6 590.0 589.4 589.6 589.0 588.7 589.0 588.8 588.0 587.7 587.2 586.3 586.0 586.1 585.3 597.7 606.6 619.7 629.9 639.4 651.2 660.0 673.2 683.2 692.8 706.5 716.4 733.0 746.8 759.5 776.4 779.0 782.6 784.9 787.2 789.2 790.4 791.0 791.7 791.7 790.4 790.4 789.7 789.0 789.0 788.9 788.5 789.0 789.1 789.4 789.5 789.9 789.1 789.5 789.9 789.9 789.9 790.7 790.4 790.4 791.7 791.7 792.0 793.0 792.6 792.4 793.6 793.4 792.9 794.0 793.9 793.1 794.1 794.2 793.1 794.0 794.0 793.3 794.0 794.0 792.8 793.6 792.9 792.3 792.6 792.6 792.2 793.0 792.6 792.6 793.1 793.1 792.8 793.5 793.1 793.2 793.6 793.6 793.6 794.0 793.6 793.6 793.5 792.9 791.7 790.0 788.1 785.0 783.0 780.4 776.1 768.4 760.7 753.1 745.5 738.1 730.7 723.4 716.2 709.0 701.9 694.9 688.0 681.1 674.3 667.5 660.9 654.3 647.7 641.2 634.8 628.5 622.2 616.0 609.8 603.7 597.7 591.7 587.0 587.3 589.1 589.4 590.6 591.5 592.1 592.5 592.8 593.1 593.0 592.4 593.0 592.4 592.9 593.5 593.8 594.3 594.8 594.8 594.8 594.5 593.8 593.5 592.6 591.6 590.7 590.0 588.3 587.9 588.6 588.3 589.1 589.7 589.8 589.0 588.7 587.0 585.3 583.5 580.9 577.2 574.5 572.6 566.3 560.1 553.9 547.9 541.9 535.9 530.0 524.2 518.5 512.8 507.4 508.5 510.7 513.6 514.9 518.0 520.4 522.6 525.3 526.6 527.9 528.2 528.4 528.1 528.1 528.0 527.5 527.5 528.0 527.5 527.9 528.4 528.1 528.2 528.7 528.8 529.1 529.3 529.4 529.6 529.9 529.9 529.9 529.8 529.3 528.8 528.9 528.1 527.2 527.2 525.7 524.7 524.5 523.4 522.3 519.5 517.3 514.9 512.6 511.6 508.5 506.4 505.1 501.9 500.5 498.8 497.4 496.2 497.7 497.9 498.5 498.5 498.5 498.8 498.8 498.9 499.6 499.3 499.7 500.2 500.0 500.5 500.8 500.5 500.8 500.7 500.2 500.2 499.8 499.3 498.7 498.3 497.6 496.3 495.3 493.0 490.4 488.5 484.2 481.2 478.9 477.2 476.7 476.2 475.7 475.2 474.6 474.1 473.6 473.1 472.6 472.1 471.5 471.0 470.5 470.0 469.5 469.0 468.5 468.0 467.5 466.9 466.4 468.1 468.3 469.7 469.9 469.9 469.4 469.4 469.4 469.1 468.9 468.5 468.1 467.8 467.8 467.8 468.1 468.1 468.4 468.6 468.6 468.6 468.9 468.9 468.9 469.1 469.1 469.1 469.4 469.1 468.9 468.9 468.9 468.3 467.9 467.2 466.5 465.4 464.2 462.5 461.9 460.4 459.7 458.7 456.1 453.9 452.0 450.3 448.5 446.4 444.9 442.8 441.8 440.3 441.4 441.8 441.8 442.0 442.5 442.6 443.1 443.3 443.1 443.4 443.8 443.6 443.9 444.1 443.8 443.9 444.3 444.1 444.3 444.8 444.6 444.6 445.1 444.9 445.0 445.3 445.1 445.2 445.4 445.3 445.2 445.4 445.3 445.1 445.3 445.1 445.1 445.3 445.1 445.2 445.3 445.1 445.2 445.4 445.1 445.2 445.4 445.3 445.1 445.6 445.3 445.1 445.3 445.1 444.9 444.8 444.3 443.9 444.1 443.6 443.6 443.6 442.8 442.8 443.0 442.6 443.1 442.7 439.5 437.3 433.1 430.0 425.0 422.6 421.7 420.9 420.1 419.3 418.5 417.7 416.8 416.0 415.2 414.4 413.6 412.8 412.0 411.2 410.4 409.6 408.8 408.0 407.2 406.4 405.6 404.8 404.0 403.3 402.5 401.7 400.9 400.1 399.4 398.6 397.8 397.0 396.3 395.6 395.6 395.8 395.4 395.2 395.2 395.2 395.0 395.4 395.4 395.6 395.6 395.6 395.4 395.6 395.4 395.6 395.6 395.4 395.4 395.4 395.2 395.5 395.6 395.4 395.7 395.9 395.7 395.9 396.1 395.9 396.1 396.3 396.1 396.3 396.5 396.3 396.6 396.6 396.6 396.6 396.6 396.3 396.3 396.3 396.3 396.3 396.3 396.1 396.3 396.3 396.3 396.3 396.3 396.3 396.3 396.1 396.0 395.8 395.4 395.1 394.5 393.5 391.3 390.0 385.9 383.7 380.8 379.4 378.0 377.8 377.1 375.0 372.9 370.9 368.8 366.8 364.8 362.7 360.7 358.7 356.7 354.8 352.8 350.9 348.9 347.0 345.1 343.1 341.2 339.4 337.5 335.6 333.7 331.9 330.1 328.2 326.4 324.6 322.8 321.0 319.2 317.5 315.7 314.0 312.2 310.5 308.8 307.1 305.4 303.4 300.5 301.1 301.5 301.7 300.9 300.4 300.0 299.9 299.5 299.7 300.0 299.6 299.9 300.2 299.9 300.0 299.9 299.7 299.7 299.7 299.1 299.3 299.1 299.1 298.9 299.5 299.0 298.1 297.4 293.6 291.0 285.9 282.5 280.6 285.1 289.6 294.3 299.0 303.8 308.7 313.6 318.7 323.8 329.0 334.2 339.6 345.0 350.6 356.2 361.9 367.7 373.6 379.6 385.7 390.1 389.5 387.9 385.9 384.6 384.1 383.7 383.9 384.1 384.8 385.1 385.7 386.4 386.4 385.7 386.3 385.9 387.0 387.8 388.4 388.4 389.5 389.5 390.4 391.5 392.8 393.1 394.5 394.6 395.0 395.3 395.6 395.3 395.6 395.2 395.2 395.4 395.4 395.5 395.9 395.9 395.9 396.1 396.3 396.3 396.6 396.6 396.6 396.6 396.6 396.6 396.8 396.6 396.9 397.2 397.8 398.2 398.9 399.0 398.8 399.2 398.4 398.2 399.3 402.8 406.3 409.8 413.3 416.9 420.5 424.2 427.8 431.5 435.3 439.0 442.9 446.7 450.6 454.5 458.4 462.4 466.4 470.4 474.5 478.6 482.7 486.9 491.1 495.4 499.7 504.0 508.4 512.8 517.2 521.7 526.2 530.8 535.4 540.0 544.7 549.4 554.2 559.0 563.8 568.7 573.6 578.6 583.6 588.0 589.4 590.4 590.4 591.5 591.8 592.1 591.4 591.4 592.0 591.7 591.4 591.6 590.7 590.5 590.7 590.4 589.1 581.3 569.7 560.6 553.1 542.3 534.6 523.8 514.8 507.2 497.4 491.9 493.7 494.0 494.5 495.0 494.7 494.1 493.5 491.6 487.9 485.1 478.8 473.6 468.9 463.3 459.7 468.3 477.0 485.8 494.9 504.0 513.4 522.9 532.6 542.5 552.6 563.2 573.4 575.9 577.2 578.9 580.2 581.8 582.6 584.2 583.6 584.1 583.6 583.6 583.9 583.9 583.0 583.2 582.6 583.7 584.3 585.2 585.1 586.0 585.7 586.3 587.3 588.4 588.7 589.5 590.0 590.5 590.8 591.4 591.5 591.8 591.8 591.8 591.8 592.1 592.1 592.4 592.4 592.4 592.4 592.4 592.4 592.5 592.8 592.4 592.4 592.8 592.8 592.8 592.7 592.4 592.5 592.7 592.4 592.4 592.4 592.1 592.1 592.1 592.1 592.1 592.1 592.1 592.1 592.1 592.1 592.4 592.4 592.4 592.4 592.1 591.8 590.6 589.7 585.3 581.9 575.8 570.7 568.0 573.4 578.8 584.4 589.9 595.5 601.2 606.9 612.7 618.5 624.4 630.4 636.4 642.4 648.5 654.7 660.9 667.2 673.6 680.0 686.5 693.0 699.6 706.2 713.0 719.8 726.6 733.5 740.5 747.6 754.7 759.5 761.7 766.0 767.9 770.1 772.2 773.6 772.6 773.5 772.8 772.5 773.2 773.3 772.2 773.6 773.8 774.5 777.0 778.1 778.1 781.3 781.3 783.2 785.7 787.2 787.5 789.0 789.4 789.6 790.4 791.2 790.8 792.1 791.7 791.7 792.3 792.6 792.8 793.6 793.6 793.5 793.1 793.0 792.7 793.1 792.6 792.2 792.2 792.1 791.7 792.1 791.7 792.2 792.2 792.2 792.3 792.6 792.3 792.6 792.6 792.2 792.2 792.1 791.7 791.3 791.3 791.3 791.3 791.3 791.3 790.9 791.3 790.7 790.3 789.9 789.4 789.4 789.4 789.0 789.0 786.0 784.4 777.8 771.6 765.6 757.1 751.6 742.7 733.9 725.2 716.6 708.2 699.8 691.5 683.3 675.2 667.2 659.3 651.5 643.8 636.2 628.6 621.2 613.8 606.6 599.4 592.3 586.7 586.8 587.3 588.9 589.7 591.2 591.9 592.4 593.2 593.5 593.2 593.5 593.5 593.2 593.5 593.3 592.8 592.8 592.7 592.4 592.8 592.8 592.8 593.1 592.8 592.1 591.9 590.7 588.4 585.3 579.1 573.4 567.7 561.2 556.6 554.7 552.9 551.0 549.1 547.3 545.4 543.6 541.8 539.9 538.1 536.3 534.5 532.7 530.9 529.1 527.3 525.5 523.8 522.0 520.2 520.4 521.2 521.4 523.4 524.2 524.6 525.5 526.0 526.3 526.6 526.8 526.6 526.6 526.8 526.6 527.0 527.2 527.2 527.2 527.2 527.2 527.2 527.5 527.5 527.5 527.8 527.7 527.2 526.0 523.3 519.8 514.6 510.1 502.5 497.9 493.3 493.2 493.0 492.9 492.7 492.6 492.5 492.3 492.2 492.1 491.9 491.8 491.7 491.5 491.4 491.3 491.1 491.0 490.8 490.7 490.6 490.7 491.6 493.5 494.2 495.8 496.8 497.3 498.6 499.0 499.3 499.3 499.3 499.2 498.8 499.0 499.0 499.0 498.8 498.8 498.4 498.2 498.2 497.3 497.3 496.9 496.4 496.2 495.7 495.0 492.6 490.8 489.6 486.1 485.4 487.4 489.4 491.5 493.5 495.5 497.6 499.7 501.7 503.8 505.9 508.0 510.1 512.2 514.3 516.5 518.6 520.8 522.9 525.1 527.3 529.2 530.0 530.6 530.7 531.2 530.2 529.7 528.4 527.8 527.5 526.8 526.3 526.6 526.1 525.4 525.9 525.6 525.4 526.3 526.3 525.9 526.8 526.6 527.3 528.1 529.0 529.2 530.2 530.2 530.2 530.7 531.1 530.9 531.5 531.5 531.2 531.5 531.8 531.8 532.1 532.1 532.1 532.1 532.1 532.1 532.1 532.0 531.8 531.8 531.8 531.5 531.5 531.5 531.5 531.5 531.5 531.5 531.5 531.4 531.2 531.4 531.2 531.2 530.9 530.9 530.9 530.8 530.6 530.5 530.2 529.9 529.5 529.0 528.3 527.8 527.3 526.5 526.3 526.5 526.3 525.7 526.0 526.0 526.4 526.9 528.1 528.0 527.9 527.8 527.7 527.6 527.5 527.4 527.3 527.3 527.2 527.1 527.0 526.9 526.8 526.7 526.6 526.5 526.4 526.3 526.2 526.1 526.1 526.0 526.3 526.9 526.8 526.6 526.6 526.9 526.6 526.9 527.2 526.9 526.9 526.8 526.6 526.6 526.6 526.6 526.6 526.8 526.6 526.6 526.9 526.6 526.6 526.6 526.5 526.3 526.2 525.9 525.7 525.6 525.4 524.9 524.4 523.9 521.8 520.8 519.2 517.4 516.6 516.5 516.0 535.7 553.0 567.0 587.5 603.8 625.6 643.9 661.5 683.9 700.9 728.8 750.6 769.6 772.1 771.0 771.1 771.9 771.9 771.3 772.8 770.3 769.7 770.1 769.5 768.7 770.0 767.9 767.9 768.5 769.6 771.3 774.5 774.5 777.2 779.0 780.8 783.2 785.8 786.4 787.2 788.4 788.1 788.1 788.9 788.5 788.6 788.9 788.5 788.2 788.5 788.1 788.2 788.5 788.1 788.1 788.4 788.0 787.6 788.4 787.6 787.7 788.0 787.6 787.3 788.1 787.1 786.8 787.2 786.7 786.7 787.5 787.2 787.2 787.6 787.6 787.8 788.5 788.5 788.6 789.0 788.5 788.6 789.0 789.0 789.0 789.0 788.9 788.5 788.6 789.0 788.4 787.6 787.6 783.6 781.7 774.6 768.4 762.1 754.4 750.8 739.7 728.9 718.2 707.6 697.2 687.0 676.9 667.0 657.2 647.5 638.0 628.6 619.4 610.3 601.4 592.5 583.8 575.3 566.8 558.5 550.3 542.2 534.2 524.3 525.1 525.9 525.7 526.0 526.0 526.3 526.9 526.9 527.2 527.5 527.5 527.8 527.8 527.5 527.8 527.8 527.9 528.2 528.4 528.5 529.0 529.0 529.0 529.0 529.0 529.0 529.3 529.0 529.0 529.3 529.3 529.1 529.3 529.3 529.1 529.3 529.0 529.0 529.0 529.0 528.7 529.0 528.7 528.7 528.7 528.7 528.5 528.7 528.4 528.5 528.7 528.4 528.5 528.7 528.4 528.4 528.7 528.4 528.4 528.7 528.4 528.5 528.7 528.4 528.5 528.7 528.7 528.8 529.0 528.7 528.7 529.0 529.0 528.7 529.0 529.0 528.8 529.0 528.7 528.8 529.0 528.7 528.7 528.7 528.5 528.7 529.0 528.8 529.0 529.3 529.0 529.3 529.3 529.0 529.0 529.0 528.8 529.1 529.3 528.8 529.3 529.6 529.7 529.9 530.5 530.2 530.7 531.2 531.2 531.6 532.4 532.7 531.6 532.4 532.3 533.5 534.7 535.9 537.1 538.3 539.5 540.7 541.9 543.2 544.4 545.6 546.8 548.0 549.3 550.5 551.7 553.0 554.2 555.4 556.7 557.9 559.2 560.4 561.7 562.9 564.2 565.5 566.7 568.0 569.3 570.5 571.8 573.1 574.4 575.7 577.0 578.3 579.6 580.9 582.2 583.5 584.8 586.1 587.4 588.7 590.0 591.2 591.9 592.4 593.3 594.2 593.9 594.2 594.2 594.1 593.8 593.7 593.0 592.4 592.0 591.4 591.0 590.6 590.0 578.6 570.6 559.6 551.0 543.9 533.3 525.7 514.8 506.0 498.5 498.0 497.3 496.9 496.0 495.3 494.3 493.6 490.6 488.3 486.0 481.8 479.3 475.7 473.2 471.6 479.4 487.4 495.6 503.8 512.2 520.7 529.4 538.2 547.2 556.3 565.6 574.9 578.1 579.1 580.2 581.5 582.9 583.9 585.1 584.3 585.2 584.6 585.0 585.4 585.6 585.1 585.6 585.1 585.7 586.3 587.3 587.3 588.4 588.7 589.0 589.9 590.7 591.2 591.8 591.8 592.2 592.4 592.8 592.8 592.8 593.1 592.8 593.1 593.1 593.1 593.2 593.5 593.1 593.2 593.5 593.2 593.5 593.4 593.2 593.5 593.5 593.5 593.5 593.4 593.1 593.2 593.5 593.5 593.5 593.5 593.8 593.8 593.9 594.2 594.2 593.9 594.2 594.0 593.6 594.2 593.6 592.4 591.6 590.4 588.7 585.6 583.9 580.4 579.6 584.7 589.8 595.0 600.3 605.6 610.9 616.3 621.7 627.2 632.7 638.3 643.9 649.6 655.3 661.0 666.9 672.7 678.7 684.6 690.7 696.7 702.9 709.1 715.3 721.6 728.0 734.4 740.8 747.4 753.9 760.6 767.3 774.0 780.0 782.6 784.4 785.7 787.2 788.4 789.7 791.3 791.5 792.6 793.0 792.6 792.6 792.5 791.7 792.1 791.7 791.3 792.2 792.2 792.0 793.0 792.6 792.8 793.6 793.8 793.3 794.5 793.9 793.1 793.6 793.4 792.6 793.4 792.6 792.7 793.3 794.0 793.8 794.9 794.8 794.6 794.9 794.5 794.5 794.4 794.0 794.0 794.5 794.5 794.6 794.9 794.9 795.1 795.9 795.5 795.9 796.3 796.4 796.8 797.6 797.3 797.7 797.7 797.7 797.6 797.2 796.8 796.6 795.9 794.4 793.9 793.6 792.6 792.2 791.6 791.0 789.9 787.3 785.8 781.2 776.6 773.6 765.0 756.5 748.1 739.8 731.6 723.5 715.4 707.5 699.6 691.9 684.2 676.6 669.1 661.6 654.3 647.0 639.8 632.7 625.7 618.7 611.9 605.1 597.7 588.3 581.3 573.7 576.2 578.6 582.0 583.9 585.7 587.7 589.7 589.9 591.1 591.8 591.8 592.5 592.8 592.8 592.8 592.8 592.8 592.8 593.1 593.1 593.1 593.2 593.5 593.5 593.6 594.2 594.1 593.9 594.2 594.1 593.8 593.8 593.7 593.1 592.4 592.4 591.5 590.4 590.4 589.2 588.3 581.9 577.0 572.6 567.6 564.1 558.6 554.3 550.9 545.0 541.1 535.5 531.0 527.2 527.6 527.8 527.9 528.2 528.4 528.2 528.7 528.7 528.4 528.4 528.1 527.8 527.7 527.5 527.5 527.5 527.5 526.9 526.9 526.9 526.6 526.9 526.6 526.6 526.9 526.9 526.9 527.5 527.6 527.8 527.8 527.5 527.1 526.2 524.5 522.6 521.1 516.6 513.9 511.9 508.2 507.4 506.7 505.9 505.1 504.4 503.6 502.9 502.1 501.3 500.6 499.8 499.1 498.5 498.5 499.0 499.0 499.4 499.9 499.9 500.2 499.9 499.8 499.3 499.0 499.0 498.8 498.8 498.8 498.8 498.5 498.8 498.5 498.5 498.5 498.4 498.2 497.5 497.2 496.5 496.4 495.9 495.0 494.9 494.2 492.6 491.9 489.3 486.7 484.8 482.5 480.7 477.6 473.2 469.0 464.7 460.5 456.3 452.2 448.1 444.0 440.0 436.0 432.1 428.2 424.3 420.5 416.7 414.1 416.3 418.6 421.6 425.1 428.1 430.9 433.1 433.7 435.3 434.7 434.7 435.4 434.9 435.6 437.3 437.5 439.7 442.0 443.9 446.0 449.2 451.2 453.4 457.8 460.1 461.9 465.6 467.0 469.1 470.4 471.3 471.9 472.4 472.7 472.7 472.7 472.9 472.9 472.7 472.7 472.7 471.5 471.0 468.9 466.6 464.8 460.6 458.4 454.7 452.5 453.3 454.1 454.9 455.7 456.5 457.3 458.0 458.8 459.6 460.4 461.2 462.0 462.8 463.6 464.4 465.2 466.1 466.9 467.7 468.5 469.3 470.1 470.8 470.1 469.7 469.9 470.5 470.5 470.4 469.9 469.7 469.3 468.6 468.3 468.2 467.8 467.8 468.1 467.5 465.9 464.8 460.4 456.8 450.1 445.3 441.0 437.1 440.2 443.3 446.4 449.6 452.8 456.0 459.2 462.5 465.8 469.1 472.4 473.8 473.7 473.2 472.4 472.4 472.0 471.6 471.6 471.5 471.0 470.7 470.4 469.9 469.9 469.9 469.7 469.7 469.9 470.2 470.2 470.2 470.2 470.2 470.5 470.5 470.5 470.7 470.5 470.5 470.8 470.8 470.8 471.0 470.8 470.8 471.0 471.0 470.8 470.8 470.8 470.5 470.5 470.5 470.4 470.2 469.9 469.4 467.8 465.8 462.9 458.9 454.9 451.6 448.1 446.1 447.6 449.1 450.5 452.0 453.5 455.0 456.5 458.0 459.5 461.0 462.5 464.0 465.5 467.0 468.5 470.1 471.4 471.9 472.0 471.3 471.6 471.9 472.1 471.9 472.1 472.3 471.8 471.6 470.7 470.2 468.1 465.4 463.2 457.1 452.1 443.6 437.8 432.9 429.2 430.3 431.4 432.6 433.7 434.9 436.0 437.2 438.3 439.5 440.6 441.8 443.0 444.1 445.3 446.5 447.6 448.8 449.8 449.8 449.9 450.8 451.6 451.8 452.9 454.0 454.5 455.6 456.1 456.6 457.1 457.4 458.3 459.0 459.2 460.1 460.8 461.2 462.1 462.9 463.6 464.0 465.4 465.7 465.9 466.9 466.7 467.1 467.5 467.5 467.6 468.1 468.1 468.4 468.6 468.3 468.3 468.2 467.5 467.2 466.5 465.6 464.7 464.0 462.7 460.9 460.0 457.2 455.1 453.2 449.3 444.3 437.3 432.9 430.0 425.5 423.1 420.7 417.5 415.1 412.5 409.4 405.3 403.7 401.2 398.8 398.4 397.0 396.0 395.4 396.9 397.7 398.2 398.2 398.4 398.4 398.4 398.0 397.1 396.3 393.6 391.5 388.6 386.0 381.9 377.4 372.4 364.3 357.8 353.9 348.6 346.4 342.8 339.3 335.8 332.3 328.9 325.5 322.1 318.8 315.5 312.3 309.0 305.8 302.7 300.4 301.2 302.0 301.6 301.1 300.3 300.0 299.0 298.4 298.1 298.1 297.8 297.9 297.9 297.8 297.8 297.9 297.8 297.8 297.9 297.8 297.8 297.6 297.6 297.6 297.6 297.8 297.9 297.9 297.9 298.3 298.1 298.1 297.9 297.8 297.4 297.2 296.9 296.8 296.9 296.8 296.9 297.2 297.0 297.2 297.4 297.2 297.9 297.9 297.9 298.1 297.4 296.7 295.7 294.9 293.4 291.8 291.0 291.6 298.1 304.8 311.6 318.5 325.6 332.9 340.4 348.0 355.7 363.7 371.8 380.1 388.6 396.9 397.5 397.7 397.5 397.5 397.5 397.7 397.7 397.7 397.7 397.3 396.7 396.6 395.7 394.7 393.1 391.7 389.1 384.3 380.4 374.6 371.4 370.9 370.5 370.0 369.6 369.1 368.7 368.2 367.8 367.3 366.9 366.4 366.0 365.5 365.1 364.7 364.2 363.8 363.4 364.2 363.7 362.8 362.3 361.8 361.1 360.8 360.1 359.2 359.0 358.4 358.2 358.0 357.4 357.2 356.9 356.8 356.8 356.9 356.8 356.7 356.6 356.6 356.5 356.4 356.1 355.9 355.9 355.8 355.9 355.8 355.9 355.9 355.8 355.9 356.1 356.0 356.2 356.1 355.9 355.9 355.9 355.9 355.9 355.9 356.0 356.1 355.9 355.9 355.5 355.3 355.1 354.7 354.9 354.7 354.7 354.7 354.7 354.4 353.7 354.3 354.9 355.5 356.0 356.6 357.2 357.8 358.4 359.0 359.6 360.2 360.8 361.4 362.0 362.6 366.5 370.9 374.3 376.4 378.0 380.7 382.6 385.0 387.4 389.3 390.6 391.7 392.4 393.4 393.6 394.5 394.5 394.5 394.8 395.2 395.5 395.9 396.1 396.4 396.6 397.1 397.3 397.7 397.7 397.9 398.2 398.4 398.4 398.6 398.6 398.6 398.6 398.6 398.6 398.6 398.4 398.4 398.6 398.4 398.4 398.3 398.1 397.9 397.9 397.7 397.5 397.4 397.0 397.0 396.8 396.5 396.3 396.1 395.4 394.0 392.4 389.9 387.3 383.9 381.3 377.9 377.5 381.6 385.7 389.9 394.1 398.4 402.7 407.1 411.5 415.9 420.4 425.0 429.6 434.2 438.9 443.7 448.5 453.4 458.3 463.2 467.3 467.5 468.1 468.1 469.0 469.5 469.7 470.0 470.5 470.5 470.5 470.5 470.7 470.5 470.8 470.8 471.0 470.8 471.0 471.3 471.4 471.9 472.1 472.1 472.4 472.4 472.4 472.4 472.4 472.0 471.2 470.5 469.0 468.1 466.5 464.8 465.9 466.8 468.6 471.9 474.9 477.6 482.3 485.1 488.4 492.1 494.5 497.4 500.5 503.8 506.0 508.9 513.4 516.3 521.6 523.4 523.9 524.2 524.2 524.4 522.9 522.9 521.0 520.2 519.6 519.6 519.3 520.2 520.2 521.0 521.9 522.6 523.8 525.1 525.7 526.1 526.9 527.5 527.5 528.2 528.6 528.1 528.5 529.0 528.5 528.8 529.0 528.7 528.7 529.0 528.7 528.7 529.0 528.7 528.8 529.0 529.1 529.4 529.8 530.6 531.5 532.4 533.7 534.9 536.7 538.2 539.6 541.4 543.0 545.0 546.6 548.1 549.9 551.5 553.1 554.5 555.6 556.9 557.8 558.8 559.3 559.6 559.9 560.2 560.2 560.4 560.2 560.2 560.5 560.2 560.2 560.5 560.2 560.2 560.4 560.2 560.2 560.4 560.2 560.2 560.4 560.2 560.2 560.5 560.2 560.2 560.5 560.2 560.5 560.7 560.2 560.5 560.7 560.2 560.5 560.7 560.2 560.5 560.8 560.2 560.2 560.5 559.9 560.2 560.1 559.8 559.8 560.1 559.8 559.9 560.1 559.8 560.2 560.2 559.9 560.2 560.2 559.8 559.8 560.3 559.6 559.8 559.6 558.2 556.4 552.1 548.9 542.1 537.7 534.2 535.4 536.7 537.9 539.1 540.4 541.6 542.9 544.1 545.4 546.7 547.9 549.2 550.5 551.7 553.0 554.3 555.6 556.9 558.2 559.4 560.7 562.0 563.3 564.6 565.9 567.4 569.6 570.4 572.9 576.5 579.5 582.6 586.2 589.0 591.0 592.3 593.5 593.5 593.5 593.4 593.2 593.8 593.8 593.8 594.6 594.8 594.8 595.5 595.5 595.5 595.5 595.2 595.2 595.2 594.5 594.4 594.2 593.8 593.8 593.8 593.9 594.2 594.1 593.8 594.2 594.1 593.8 594.2 594.2 593.9 594.2 594.2 593.9 594.2 594.4 593.9 594.2 594.4 593.8 594.2 594.4 593.8 594.2 594.5 593.9 594.2 594.5 593.9 594.2 594.4 593.9 594.2 594.1 593.8 594.2 594.1 593.8 594.2 594.2 593.8 593.9 594.2 593.8 593.8 594.1 593.8 593.8 594.1 593.8 593.9 594.1 593.8 593.9 594.2 593.8 593.9 594.2 593.8 593.8 594.1 593.8 593.8 594.1 593.8 593.9 594.1 593.8 593.9 594.2 593.5 593.9 594.2 593.5 593.5 593.7 593.2 593.5 593.4 592.8 593.1 593.0 592.4 592.8 593.1 592.5 592.8 593.1 592.6 593.1 593.1 592.8 593.1 593.4 592.8 593.2 593.4 592.8 593.2 593.5 592.9 593.2 593.5 592.8 593.1 593.3 592.9 593.5 593.8 593.5 594.2 594.5 594.5 596.3 596.6 597.9 599.5 600.4 601.3 602.4 603.6 604.0 604.5 604.9 604.9 604.3 605.0 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6 605.6",
+    "input_type": "phoneme",
+    "offset": 72.491
+  }
+]

modules/attentions.py

@@ -0,0 +1,397 @@
+import copy
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import modules.commons as commons
+
+
+class LayerNorm(nn.Module):
+  def __init__(self, channels, eps=1e-5):
+    super().__init__()
+    self.channels = channels
+    self.eps = eps
+
+    self.gamma = nn.Parameter(torch.ones(channels))
+    self.beta = nn.Parameter(torch.zeros(channels))
+
+  def forward(self, x):
+    x = x.transpose(1, -1)
+    x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+    return x.transpose(1, -1)
+
+
+class Encoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.window_size = window_size
+
+    self.drop = nn.Dropout(p_dropout)
+    self.attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask):
+    attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.attn_layers[i](x, x, attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+class Decoder(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+
+    self.drop = nn.Dropout(p_dropout)
+    self.self_attn_layers = nn.ModuleList()
+    self.norm_layers_0 = nn.ModuleList()
+    self.encdec_attn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_2 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+      self.norm_layers_0.append(LayerNorm(hidden_channels))
+      self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+      self.norm_layers_2.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask, h, h_mask):
+    """
+    x: decoder input
+    h: encoder output
+    """
+    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+    encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.self_attn_layers[i](x, x, self_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_0[i](x + y)
+
+      y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y)
+      
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_2[i](x + y)
+    x = x * x_mask
+    return x
+
+class FFT(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers=1, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+
+    self.drop = nn.Dropout(p_dropout)
+    self.self_attn_layers = nn.ModuleList()
+    self.norm_layers_0 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    for i in range(self.n_layers):
+      self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+      self.norm_layers_0.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask):
+    """
+    x: decoder input
+    h: encoder output
+    """
+    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      y = self.self_attn_layers[i](x, x, self_attn_mask)
+      y = self.drop(y)
+      x = self.norm_layers_0[i](x + y)
+      
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y) 
+    x = x * x_mask
+    return x
+
+
+class FFNs(nn.Module):
+  def __init__(self, hidden_channels, filter_channels, n_heads, n_layers=1, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
+    super().__init__()
+    self.hidden_channels = hidden_channels
+    self.filter_channels = filter_channels
+    self.n_heads = n_heads
+    self.n_layers = n_layers
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+
+    self.drop = nn.Dropout(p_dropout)
+    #self.self_attn_layers = nn.ModuleList()
+    #self.norm_layers_0 = nn.ModuleList()
+    self.ffn_layers = nn.ModuleList()
+    self.norm_layers_1 = nn.ModuleList()
+    for i in range(self.n_layers):
+      #self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
+      #self.norm_layers_0.append(LayerNorm(hidden_channels))
+      self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
+      self.norm_layers_1.append(LayerNorm(hidden_channels))
+
+  def forward(self, x, x_mask):
+    """
+    x: decoder input
+    h: encoder output
+    """
+    self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
+    x = x * x_mask
+    for i in range(self.n_layers):
+      #y = self.self_attn_layers[i](x, x, self_attn_mask)
+      #y = self.drop(y)
+      #x = self.norm_layers_0[i](x + y)
+      
+      y = self.ffn_layers[i](x, x_mask)
+      y = self.drop(y)
+      x = self.norm_layers_1[i](x + y) 
+    x = x * x_mask
+    return x
+
+class MultiHeadAttention(nn.Module):
+  def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
+    super().__init__()
+    assert channels % n_heads == 0
+
+    self.channels = channels
+    self.out_channels = out_channels
+    self.n_heads = n_heads
+    self.p_dropout = p_dropout
+    self.window_size = window_size
+    self.heads_share = heads_share
+    self.block_length = block_length
+    self.proximal_bias = proximal_bias
+    self.proximal_init = proximal_init
+    self.attn = None
+
+    self.k_channels = channels // n_heads
+    self.conv_q = nn.Conv1d(channels, channels, 1)
+    self.conv_k = nn.Conv1d(channels, channels, 1)
+    self.conv_v = nn.Conv1d(channels, channels, 1)
+    self.conv_o = nn.Conv1d(channels, out_channels, 1)
+    self.drop = nn.Dropout(p_dropout)
+
+    if window_size is not None:
+      n_heads_rel = 1 if heads_share else n_heads
+      rel_stddev = self.k_channels**-0.5
+      self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+      self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
+
+    nn.init.xavier_uniform_(self.conv_q.weight)
+    nn.init.xavier_uniform_(self.conv_k.weight)
+    nn.init.xavier_uniform_(self.conv_v.weight)
+    if proximal_init:
+      with torch.no_grad():
+        self.conv_k.weight.copy_(self.conv_q.weight)
+        self.conv_k.bias.copy_(self.conv_q.bias)
+      
+  def forward(self, x, c, attn_mask=None):
+    q = self.conv_q(x)
+    k = self.conv_k(c)
+    v = self.conv_v(c)
+    
+    x, self.attn = self.attention(q, k, v, mask=attn_mask)
+
+    x = self.conv_o(x)
+    return x
+
+  def attention(self, query, key, value, mask=None):
+    # reshape [b, d, t] -> [b, n_h, t, d_k]
+    b, d, t_s, t_t = (*key.size(), query.size(2))
+    query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
+    key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+    value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
+
+    scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
+    if self.window_size is not None:
+      assert t_s == t_t, "Relative attention is only available for self-attention."
+      key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
+      rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
+      scores_local = self._relative_position_to_absolute_position(rel_logits)
+      scores = scores + scores_local
+    if self.proximal_bias:
+      assert t_s == t_t, "Proximal bias is only available for self-attention."
+      scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
+    if mask is not None:
+      scores = scores.masked_fill(mask == 0, -1e4)
+      if self.block_length is not None:
+        assert t_s == t_t, "Local attention is only available for self-attention."
+        block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
+        scores = scores.masked_fill(block_mask == 0, -1e4)
+    p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
+    p_attn = self.drop(p_attn)
+    output = torch.matmul(p_attn, value)
+    if self.window_size is not None:
+      relative_weights = self._absolute_position_to_relative_position(p_attn)
+      value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
+      output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
+    output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
+    return output, p_attn
+
+  def _matmul_with_relative_values(self, x, y):
+    """
+    x: [b, h, l, m]
+    y: [h or 1, m, d]
+    ret: [b, h, l, d]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0))
+    return ret
+
+  def _matmul_with_relative_keys(self, x, y):
+    """
+    x: [b, h, l, d]
+    y: [h or 1, m, d]
+    ret: [b, h, l, m]
+    """
+    ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
+    return ret
+
+  def _get_relative_embeddings(self, relative_embeddings, length):
+    max_relative_position = 2 * self.window_size + 1
+    # Pad first before slice to avoid using cond ops.
+    pad_length = max(length - (self.window_size + 1), 0)
+    slice_start_position = max((self.window_size + 1) - length, 0)
+    slice_end_position = slice_start_position + 2 * length - 1
+    if pad_length > 0:
+      padded_relative_embeddings = F.pad(
+          relative_embeddings,
+          commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
+    else:
+      padded_relative_embeddings = relative_embeddings
+    used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
+    return used_relative_embeddings
+
+  def _relative_position_to_absolute_position(self, x):
+    """
+    x: [b, h, l, 2*l-1]
+    ret: [b, h, l, l]
+    """
+    batch, heads, length, _ = x.size()
+    # Concat columns of pad to shift from relative to absolute indexing.
+    x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
+
+    # Concat extra elements so to add up to shape (len+1, 2*len-1).
+    x_flat = x.view([batch, heads, length * 2 * length])
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
+
+    # Reshape and slice out the padded elements.
+    x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
+    return x_final
+
+  def _absolute_position_to_relative_position(self, x):
+    """
+    x: [b, h, l, l]
+    ret: [b, h, l, 2*l-1]
+    """
+    batch, heads, length, _ = x.size()
+    # padd along column
+    x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
+    x_flat = x.view([batch, heads, length**2 + length*(length -1)])
+    # add 0's in the beginning that will skew the elements after reshape
+    x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
+    x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
+    return x_final
+
+  def _attention_bias_proximal(self, length):
+    """Bias for self-attention to encourage attention to close positions.
+    Args:
+      length: an integer scalar.
+    Returns:
+      a Tensor with shape [1, 1, length, length]
+    """
+    r = torch.arange(length, dtype=torch.float32)
+    diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
+    return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
+
+
+class FFN(nn.Module):
+  def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
+    super().__init__()
+    self.in_channels = in_channels
+    self.out_channels = out_channels
+    self.filter_channels = filter_channels
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.activation = activation
+    self.causal = causal
+
+    if causal:
+      self.padding = self._causal_padding
+    else:
+      self.padding = self._same_padding
+
+    self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
+    self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
+    self.drop = nn.Dropout(p_dropout)
+
+  def forward(self, x, x_mask):
+    x = self.conv_1(self.padding(x * x_mask))
+    if self.activation == "gelu":
+      x = x * torch.sigmoid(1.702 * x)
+    else:
+      x = torch.relu(x)
+    x = self.drop(x)
+    x = self.conv_2(self.padding(x * x_mask))
+    return x * x_mask
+  
+  def _causal_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = self.kernel_size - 1
+    pad_r = 0
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x
+
+  def _same_padding(self, x):
+    if self.kernel_size == 1:
+      return x
+    pad_l = (self.kernel_size - 1) // 2
+    pad_r = self.kernel_size // 2
+    padding = [[0, 0], [0, 0], [pad_l, pad_r]]
+    x = F.pad(x, commons.convert_pad_shape(padding))
+    return x

modules/commons.py

@@ -0,0 +1,162 @@
+import math
+import numpy as np
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+
+def init_weights(m, mean=0.0, std=0.01):
+  classname = m.__class__.__name__
+  if classname.find("Conv") != -1:
+    m.weight.data.normal_(mean, std)
+
+
+def get_padding(kernel_size, dilation=1):
+  return int((kernel_size*dilation - dilation)/2)
+
+
+def convert_pad_shape(pad_shape):
+  l = pad_shape[::-1]
+  pad_shape = [item for sublist in l for item in sublist]
+  return pad_shape
+
+
+def intersperse(lst, item):
+  result = [item] * (len(lst) * 2 + 1)
+  result[1::2] = lst
+  return result
+
+
+def kl_divergence(m_p, logs_p, m_q, logs_q):
+  """KL(P||Q)"""
+  kl = (logs_q - logs_p) - 0.5
+  kl += 0.5 * (torch.exp(2. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * logs_q)
+  return kl
+
+
+def rand_gumbel(shape):
+  """Sample from the Gumbel distribution, protect from overflows."""
+  uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
+  return -torch.log(-torch.log(uniform_samples))
+
+
+def rand_gumbel_like(x):
+  g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
+  return g
+
+
+def slice_segments(x, ids_str, segment_size=4):
+  ret = torch.zeros_like(x[:, :, :segment_size])
+  # print("ret shape: ",ret.shape, ids_str)
+  for i in range(x.size(0)):
+    idx_str = ids_str[i]
+    idx_end = idx_str + segment_size
+    ret[i] = x[i, :, idx_str:idx_end]
+  return ret
+
+
+def rand_slice_segments(x, x_lengths=None, segment_size=4):
+  b, d, t = x.size()
+  if x_lengths is None:
+    x_lengths = t
+  ids_str_max = x_lengths - segment_size - 1
+  ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
+  ret = slice_segments(x, ids_str, segment_size)
+  return ret, ids_str
+
+
+def get_timing_signal_1d(
+    length, channels, min_timescale=1.0, max_timescale=1.0e4):
+  position = torch.arange(length, dtype=torch.float)
+  num_timescales = channels // 2
+  log_timescale_increment = (
+      math.log(float(max_timescale) / float(min_timescale)) /
+      (num_timescales - 1))
+  inv_timescales = min_timescale * torch.exp(
+      torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment)
+  scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
+  signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
+  signal = F.pad(signal, [0, 0, 0, channels % 2])
+  signal = signal.view(1, channels, length)
+  return signal
+
+
+def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
+  b, channels, length = x.size()
+  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+  return x + signal.to(dtype=x.dtype, device=x.device)
+
+
+def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
+  b, channels, length = x.size()
+  signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
+  return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
+
+
+def subsequent_mask(length):
+  mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
+  return mask
+
+
+@torch.jit.script
+def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
+  n_channels_int = n_channels[0]
+  in_act = input_a + input_b
+  t_act = torch.tanh(in_act[:, :n_channels_int, :])
+  s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
+  acts = t_act * s_act
+  return acts
+
+
+def convert_pad_shape(pad_shape):
+  l = pad_shape[::-1]
+  pad_shape = [item for sublist in l for item in sublist]
+  return pad_shape
+
+
+def shift_1d(x):
+  x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
+  return x
+
+
+def sequence_mask(length, max_length=None):
+  if max_length is None:
+    max_length = length.max()
+  x = torch.arange(max_length, dtype=length.dtype, device=length.device)
+  return x.unsqueeze(0) < length.unsqueeze(1)
+
+
+def generate_path(duration, mask):
+  """
+  duration: [b, 1, t_x]
+  mask: [b, 1, t_y, t_x]
+  """
+  device = duration.device
+  
+  b, _, t_y, t_x = mask.shape
+  cum_duration = torch.cumsum(duration, -1)
+  
+  cum_duration_flat = cum_duration.view(b * t_x)
+  path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
+  path = path.view(b, t_x, t_y)
+  path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
+  path = path.unsqueeze(1).transpose(2,3) * mask
+  return path
+
+
+def clip_grad_value_(parameters, clip_value, norm_type=2):
+  if isinstance(parameters, torch.Tensor):
+    parameters = [parameters]
+  parameters = list(filter(lambda p: p.grad is not None, parameters))
+  norm_type = float(norm_type)
+  if clip_value is not None:
+    clip_value = float(clip_value)
+
+  total_norm = 0
+  for p in parameters:
+    param_norm = p.grad.data.norm(norm_type)
+    total_norm += param_norm.item() ** norm_type
+    if clip_value is not None:
+      p.grad.data.clamp_(min=-clip_value, max=clip_value)
+  total_norm = total_norm ** (1. / norm_type)
+  return total_norm

modules/ddsp.py

@@ -0,0 +1,189 @@
+import torch
+import torch.nn as nn
+from torch.nn import functional as F
+import torch.fft as fft
+import numpy as np
+import librosa as li
+import math
+from scipy.signal import get_window
+
+def safe_log(x):
+    return torch.log(x + 1e-7)
+
+
+@torch.no_grad()
+def mean_std_loudness(dataset):
+    mean = 0
+    std = 0
+    n = 0
+    for _, _, l in dataset:
+        n += 1
+        mean += (l.mean().item() - mean) / n
+        std += (l.std().item() - std) / n
+    return mean, std
+
+
+def multiscale_fft(signal, scales, overlap):
+    stfts = []
+    for s in scales:
+        S = torch.stft(
+            signal,
+            s,
+            int(s * (1 - overlap)),
+            s,
+            torch.hann_window(s).to(signal),
+            True,
+            normalized=True,
+            return_complex=True,
+        ).abs()
+        stfts.append(S)
+    return stfts
+
+
+def resample(x, factor: int):
+    batch, frame, channel = x.shape
+    x = x.permute(0, 2, 1).reshape(batch * channel, 1, frame)
+
+    window = torch.hann_window(
+        factor * 2,
+        dtype=x.dtype,
+        device=x.device,
+    ).reshape(1, 1, -1)
+    y = torch.zeros(x.shape[0], x.shape[1], factor * x.shape[2]).to(x)
+    y[..., ::factor] = x
+    y[..., -1:] = x[..., -1:]
+    y = torch.nn.functional.pad(y, [factor, factor])
+    y = torch.nn.functional.conv1d(y, window)[..., :-1]
+
+    y = y.reshape(batch, channel, factor * frame).permute(0, 2, 1)
+
+    return y
+
+
+def upsample(signal, factor):
+    signal = signal.permute(0, 2, 1)
+    signal = nn.functional.interpolate(signal, size=signal.shape[-1] * factor)
+    return signal.permute(0, 2, 1)
+
+
+def remove_above_nyquist(amplitudes, pitch, sampling_rate):
+    n_harm = amplitudes.shape[-1]
+    pitches = pitch * torch.arange(1, n_harm + 1).to(pitch)
+    aa = (pitches < sampling_rate / 2).float() + 1e-4
+    return amplitudes * aa
+
+
+def scale_function(x):
+    return 2 * torch.sigmoid(x)**(math.log(10)) + 1e-7
+
+
+def extract_loudness(signal, sampling_rate, block_size, n_fft=2048):
+    S = li.stft(
+        signal,
+        n_fft=n_fft,
+        hop_length=block_size,
+        win_length=n_fft,
+        center=True,
+    )
+    S = np.log(abs(S) + 1e-7)
+    f = li.fft_frequencies(sampling_rate, n_fft)
+    a_weight = li.A_weighting(f)
+
+    S = S + a_weight.reshape(-1, 1)
+
+    S = np.mean(S, 0)[..., :-1]
+
+    return S
+
+
+def extract_pitch(signal, sampling_rate, block_size):
+    length = signal.shape[-1] // block_size
+    f0 = crepe.predict(
+        signal,
+        sampling_rate,
+        step_size=int(1000 * block_size / sampling_rate),
+        verbose=1,
+        center=True,
+        viterbi=True,
+    )
+    f0 = f0[1].reshape(-1)[:-1]
+
+    if f0.shape[-1] != length:
+        f0 = np.interp(
+            np.linspace(0, 1, length, endpoint=False),
+            np.linspace(0, 1, f0.shape[-1], endpoint=False),
+            f0,
+        )
+
+    return f0
+
+
+def mlp(in_size, hidden_size, n_layers):
+    channels = [in_size] + (n_layers) * [hidden_size]
+    net = []
+    for i in range(n_layers):
+        net.append(nn.Linear(channels[i], channels[i + 1]))
+        net.append(nn.LayerNorm(channels[i + 1]))
+        net.append(nn.LeakyReLU())
+    return nn.Sequential(*net)
+
+
+def gru(n_input, hidden_size):
+    return nn.GRU(n_input * hidden_size, hidden_size, batch_first=True)
+
+
+def harmonic_synth(pitch, amplitudes, sampling_rate):
+    n_harmonic = amplitudes.shape[-1]
+    omega = torch.cumsum(2 * math.pi * pitch / sampling_rate, 1)
+    omegas = omega * torch.arange(1, n_harmonic + 1).to(omega)
+    signal = (torch.sin(omegas) * amplitudes).sum(-1, keepdim=True)
+    return signal
+
+
+def amp_to_impulse_response(amp, target_size):
+    amp = torch.stack([amp, torch.zeros_like(amp)], -1)
+    amp = torch.view_as_complex(amp)
+    amp = fft.irfft(amp)
+
+    filter_size = amp.shape[-1]
+
+    amp = torch.roll(amp, filter_size // 2, -1)
+    win = torch.hann_window(filter_size, dtype=amp.dtype, device=amp.device)
+
+    amp = amp * win
+
+    amp = nn.functional.pad(amp, (0, int(target_size) - int(filter_size)))
+    amp = torch.roll(amp, -filter_size // 2, -1)
+
+    return amp
+
+
+def fft_convolve(signal, kernel):
+    signal = nn.functional.pad(signal, (0, signal.shape[-1]))
+    kernel = nn.functional.pad(kernel, (kernel.shape[-1], 0))
+
+    output = fft.irfft(fft.rfft(signal) * fft.rfft(kernel))
+    output = output[..., output.shape[-1] // 2:]
+
+    return output
+
+
+def init_kernels(win_len, win_inc, fft_len, win_type=None, invers=False):
+    if win_type == 'None' or win_type is None:
+        window = np.ones(win_len)
+    else:
+        window = get_window(win_type, win_len, fftbins=True)#**0.5
+    
+    N = fft_len
+    fourier_basis = np.fft.rfft(np.eye(N))[:win_len]
+    real_kernel = np.real(fourier_basis)
+    imag_kernel = np.imag(fourier_basis)
+    kernel = np.concatenate([real_kernel, imag_kernel], 1).T
+    
+    if invers :
+        kernel = np.linalg.pinv(kernel).T 
+
+    kernel = kernel*window
+    kernel = kernel[:, None, :]
+    return torch.from_numpy(kernel.astype(np.float32)), torch.from_numpy(window[None,:,None].astype(np.float32))
+

modules/losses.py

@@ -0,0 +1,62 @@
+import torch 
+from torch.nn import functional as F
+
+import modules.commons
+import math
+
+def feature_loss(fmap_r, fmap_g):
+  loss = 0
+  for dr, dg in zip(fmap_r, fmap_g):
+    for rl, gl in zip(dr, dg):
+      rl = rl.float().detach()
+      gl = gl.float()
+      loss += torch.mean(torch.abs(rl - gl))
+
+  return loss * 2 
+
+
+def discriminator_loss(disc_real_outputs, disc_generated_outputs):
+  loss = 0
+  r_losses = []
+  g_losses = []
+  for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
+    dr = dr.float()
+    dg = dg.float()
+    r_loss = torch.mean((1-dr)**2)
+    g_loss = torch.mean(dg**2)
+    loss += (r_loss + g_loss)
+    r_losses.append(r_loss.item())
+    g_losses.append(g_loss.item())
+
+  return loss, r_losses, g_losses
+
+
+def generator_loss(disc_outputs):
+  loss = 0
+  gen_losses = []
+  for dg in disc_outputs:
+    dg = dg.float()
+    l = torch.mean((1-dg)**2)
+    gen_losses.append(l)
+    loss += l
+
+  return loss, gen_losses
+
+
+def kl_loss(z_p, logs_q, m_p, logs_p, z_mask):
+  """
+  z_p, logs_q: [b, h, t_t]
+  m_p, logs_p: [b, h, t_t]
+  """
+  z_p = z_p.float()
+  logs_q = logs_q.float()
+  m_p = m_p.float()
+  logs_p = logs_p.float()
+  z_mask = z_mask.float()
+
+  kl = logs_p - logs_q - 0.5
+  kl += 0.5 * ((z_p - m_p)**2) * torch.exp(-2. * logs_p)
+  kl = torch.sum(kl * z_mask)
+  l = kl / torch.sum(z_mask)
+  return l
+

modules/modules.py

@@ -0,0 +1,450 @@
+import copy
+import math
+import numpy as np
+import scipy
+import torch
+from torch import nn
+from torch.nn import functional as F
+from torch.autograd import Function
+from typing import Any, Optional, Tuple
+
+from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm
+
+import modules.commons as commons
+import modules.attentions as attentions
+from modules.commons import init_weights, get_padding
+from modules.transforms import piecewise_rational_quadratic_transform
+
+
+LRELU_SLOPE = 0.1
+
+
+class LayerNorm(nn.Module):
+  def __init__(self, channels, eps=1e-5):
+    super().__init__()
+    self.channels = channels
+    self.eps = eps
+
+    self.gamma = nn.Parameter(torch.ones(channels))
+    self.beta = nn.Parameter(torch.zeros(channels))
+
+  def forward(self, x):
+    x = x.transpose(1, -1)
+    x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
+    return x.transpose(1, -1)
+
+ 
+class ConvReluNorm(nn.Module):
+  def __init__(self, in_channels, hidden_channels, out_channels, kernel_size, n_layers, p_dropout):
+    super().__init__()
+    self.in_channels = in_channels
+    self.hidden_channels = hidden_channels
+    self.out_channels = out_channels
+    self.kernel_size = kernel_size
+    self.n_layers = n_layers
+    self.p_dropout = p_dropout
+    assert n_layers > 1, "Number of layers should be larger than 0."
+
+    self.conv_layers = nn.ModuleList()
+    self.norm_layers = nn.ModuleList()
+    self.conv_layers.append(nn.Conv1d(in_channels, hidden_channels, kernel_size, padding=kernel_size//2))
+    self.norm_layers.append(LayerNorm(hidden_channels))
+    self.relu_drop = nn.Sequential(
+        nn.ReLU(),
+        nn.Dropout(p_dropout))
+    for _ in range(n_layers-1):
+      self.conv_layers.append(nn.Conv1d(hidden_channels, hidden_channels, kernel_size, padding=kernel_size//2))
+      self.norm_layers.append(LayerNorm(hidden_channels))
+    self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
+    self.proj.weight.data.zero_()
+    self.proj.bias.data.zero_()
+
+  def forward(self, x, x_mask):
+    x_org = x
+    for i in range(self.n_layers):
+      x = self.conv_layers[i](x * x_mask)
+      x = self.norm_layers[i](x)
+      x = self.relu_drop(x)
+    x = x_org + self.proj(x)
+    return x * x_mask
+
+
+class DDSConv(nn.Module):
+  """
+  Dialted and Depth-Separable Convolution
+  """
+  def __init__(self, channels, kernel_size, n_layers, p_dropout=0.):
+    super().__init__()
+    self.channels = channels
+    self.kernel_size = kernel_size
+    self.n_layers = n_layers
+    self.p_dropout = p_dropout
+
+    self.drop = nn.Dropout(p_dropout)
+    self.convs_sep = nn.ModuleList()
+    self.convs_1x1 = nn.ModuleList()
+    self.norms_1 = nn.ModuleList()
+    self.norms_2 = nn.ModuleList()
+    for i in range(n_layers):
+      dilation = kernel_size ** i
+      padding = (kernel_size * dilation - dilation) // 2
+      self.convs_sep.append(nn.Conv1d(channels, channels, kernel_size, 
+          groups=channels, dilation=dilation, padding=padding
+      ))
+      self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
+      self.norms_1.append(LayerNorm(channels))
+      self.norms_2.append(LayerNorm(channels))
+
+  def forward(self, x, x_mask, g=None):
+    if g is not None:
+      x = x + g
+    for i in range(self.n_layers):
+      y = self.convs_sep[i](x * x_mask)
+      y = self.norms_1[i](y)
+      y = F.gelu(y)
+      y = self.convs_1x1[i](y)
+      y = self.norms_2[i](y)
+      y = F.gelu(y)
+      y = self.drop(y)
+      x = x + y
+    return x * x_mask
+
+
+class WN(torch.nn.Module):
+  def __init__(self, hidden_channels, kernel_size, dilation_rate, n_layers, n_speakers=0, spk_channels=0, p_dropout=0):
+    super(WN, self).__init__()
+    assert(kernel_size % 2 == 1)
+    self.hidden_channels =hidden_channels
+    self.kernel_size = kernel_size,
+    self.dilation_rate = dilation_rate
+    self.n_layers = n_layers
+    self.n_speakers = n_speakers
+    self.spk_channels = spk_channels
+    self.p_dropout = p_dropout
+
+    self.in_layers = torch.nn.ModuleList()
+    self.res_skip_layers = torch.nn.ModuleList()
+    self.drop = nn.Dropout(p_dropout)
+
+    if n_speakers > 0:
+      cond_layer = torch.nn.Conv1d(spk_channels, 2*hidden_channels*n_layers, 1)
+      self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name='weight')
+
+    for i in range(n_layers):
+      dilation = dilation_rate ** i
+      padding = int((kernel_size * dilation - dilation) / 2)
+      in_layer = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, kernel_size,
+                                 dilation=dilation, padding=padding)
+      in_layer = torch.nn.utils.weight_norm(in_layer, name='weight')
+      self.in_layers.append(in_layer)
+
+      # last one is not necessary
+      if i < n_layers - 1:
+        res_skip_channels = 2 * hidden_channels
+      else:
+        res_skip_channels = hidden_channels
+
+      res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
+      res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name='weight')
+      self.res_skip_layers.append(res_skip_layer)
+
+  def forward(self, x, x_mask, g=None, **kwargs):
+    output = torch.zeros_like(x)
+    n_channels_tensor = torch.IntTensor([self.hidden_channels])
+
+    if g is not None:
+      g = self.cond_layer(g)
+
+    for i in range(self.n_layers):
+      x_in = self.in_layers[i](x)
+      if g is not None:
+        cond_offset = i * 2 * self.hidden_channels
+        g_l = g[:,cond_offset:cond_offset+2*self.hidden_channels,:]
+      else:
+        g_l = torch.zeros_like(x_in)
+
+      acts = commons.fused_add_tanh_sigmoid_multiply(
+          x_in,
+          g_l,
+          n_channels_tensor)
+      acts = self.drop(acts)
+
+      res_skip_acts = self.res_skip_layers[i](acts)
+      if i < self.n_layers - 1:
+        res_acts = res_skip_acts[:,:self.hidden_channels,:]
+        x = (x + res_acts) * x_mask
+        output = output + res_skip_acts[:,self.hidden_channels:,:]
+      else:
+        output = output + res_skip_acts
+    return output * x_mask
+
+  def remove_weight_norm(self):
+    if self.n_speakers > 0:
+      torch.nn.utils.remove_weight_norm(self.cond_layer)
+    for l in self.in_layers:
+      torch.nn.utils.remove_weight_norm(l)
+    for l in self.res_skip_layers:
+     torch.nn.utils.remove_weight_norm(l)
+
+
+class ResBlock1(torch.nn.Module):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
+        super(ResBlock1, self).__init__()
+        self.convs1 = nn.ModuleList([
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
+                               padding=get_padding(kernel_size, dilation[0]))),
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
+                               padding=get_padding(kernel_size, dilation[1]))),
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
+                               padding=get_padding(kernel_size, dilation[2])))
+        ])
+        self.convs1.apply(init_weights)
+
+        self.convs2 = nn.ModuleList([
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+                               padding=get_padding(kernel_size, 1))),
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+                               padding=get_padding(kernel_size, 1))),
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
+                               padding=get_padding(kernel_size, 1)))
+        ])
+        self.convs2.apply(init_weights)
+
+    def forward(self, x, x_mask=None):
+        for c1, c2 in zip(self.convs1, self.convs2):
+            xt = F.leaky_relu(x, LRELU_SLOPE)
+            if x_mask is not None:
+                xt = xt * x_mask
+            xt = c1(xt)
+            xt = F.leaky_relu(xt, LRELU_SLOPE)
+            if x_mask is not None:
+                xt = xt * x_mask
+            xt = c2(xt)
+            x = xt + x
+        if x_mask is not None:
+            x = x * x_mask
+        return x
+
+    def remove_weight_norm(self):
+        for l in self.convs1:
+            remove_weight_norm(l)
+        for l in self.convs2:
+            remove_weight_norm(l)
+
+
+class ResBlock2(torch.nn.Module):
+    def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
+        super(ResBlock2, self).__init__()
+        self.convs = nn.ModuleList([
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
+                               padding=get_padding(kernel_size, dilation[0]))),
+            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
+                               padding=get_padding(kernel_size, dilation[1])))
+        ])
+        self.convs.apply(init_weights)
+
+    def forward(self, x, x_mask=None):
+        for c in self.convs:
+            xt = F.leaky_relu(x, LRELU_SLOPE)
+            if x_mask is not None:
+                xt = xt * x_mask
+            xt = c(xt)
+            x = xt + x
+        if x_mask is not None:
+            x = x * x_mask
+        return x
+
+    def remove_weight_norm(self):
+        for l in self.convs:
+            remove_weight_norm(l)
+
+
+class Log(nn.Module):
+  def forward(self, x, x_mask, reverse=False, **kwargs):
+    if not reverse:
+      y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
+      logdet = torch.sum(-y, [1, 2])
+      return y, logdet
+    else:
+      x = torch.exp(x) * x_mask
+      return x
+    
+
+class Flip(nn.Module):
+  def forward(self, x, *args, reverse=False, **kwargs):
+    x = torch.flip(x, [1])
+    if not reverse:
+      logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
+      return x, logdet
+    else:
+      return x
+
+
+class ElementwiseAffine(nn.Module):
+  def __init__(self, channels):
+    super().__init__()
+    self.channels = channels
+    self.m = nn.Parameter(torch.zeros(channels,1))
+    self.logs = nn.Parameter(torch.zeros(channels,1))
+
+  def forward(self, x, x_mask, reverse=False, **kwargs):
+    if not reverse:
+      y = self.m + torch.exp(self.logs) * x
+      y = y * x_mask
+      logdet = torch.sum(self.logs * x_mask, [1,2])
+      return y, logdet
+    else:
+      x = (x - self.m) * torch.exp(-self.logs) * x_mask
+      return x
+
+
+class ResidualCouplingLayer(nn.Module):
+  def __init__(self,
+      channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      p_dropout=0,
+      n_speakers=0,
+      spk_channels=0,
+      mean_only=False):
+    assert channels % 2 == 0, "channels should be divisible by 2"
+    super().__init__()
+    self.channels = channels
+    self.hidden_channels = hidden_channels
+    self.kernel_size = kernel_size
+    self.dilation_rate = dilation_rate
+    self.n_layers = n_layers
+    self.half_channels = channels // 2
+    self.mean_only = mean_only
+
+    self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
+    self.enc = WN(hidden_channels, kernel_size, dilation_rate, n_layers, p_dropout=p_dropout, n_speakers=n_speakers, spk_channels=spk_channels)
+    self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
+    self.post.weight.data.zero_()
+    self.post.bias.data.zero_()
+
+  def forward(self, x, x_mask, g=None, reverse=False):
+    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
+    h = self.pre(x0) * x_mask
+    h = self.enc(h, x_mask, g=g)
+    stats = self.post(h) * x_mask
+    if not self.mean_only:
+      m, logs = torch.split(stats, [self.half_channels]*2, 1)
+    else:
+      m = stats
+      logs = torch.zeros_like(m)
+
+    if not reverse:
+      x1 = m + x1 * torch.exp(logs) * x_mask
+      x = torch.cat([x0, x1], 1)
+      logdet = torch.sum(logs, [1,2])
+      return x, logdet
+    else:
+      x1 = (x1 - m) * torch.exp(-logs) * x_mask
+      x = torch.cat([x0, x1], 1)
+      return x
+
+class ResidualCouplingBlock(nn.Module):
+  def __init__(self,
+      channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      n_flows=4,
+      n_speakers=0,
+      gin_channels=0):
+    super().__init__()
+    self.channels = channels
+    self.hidden_channels = hidden_channels
+    self.kernel_size = kernel_size
+    self.dilation_rate = dilation_rate
+    self.n_layers = n_layers
+    self.n_flows = n_flows
+    self.gin_channels = gin_channels
+
+    self.flows = nn.ModuleList()
+    for i in range(n_flows):
+      self.flows.append(ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, n_speakers=n_speakers, spk_channels=gin_channels, mean_only=True))
+      self.flows.append(Flip())
+
+  def forward(self, x, x_mask, g=None, reverse=False):
+    if not reverse:
+      for flow in self.flows:
+        x, _ = flow(x, x_mask, g=g, reverse=reverse)
+    else:
+      for flow in reversed(self.flows):
+        x = flow(x, x_mask, g=g, reverse=reverse)
+    return x
+
+
+class ConvFlow(nn.Module):
+  def __init__(self, in_channels, filter_channels, kernel_size, n_layers, num_bins=10, tail_bound=5.0):
+    super().__init__()
+    self.in_channels = in_channels
+    self.filter_channels = filter_channels
+    self.kernel_size = kernel_size
+    self.n_layers = n_layers
+    self.num_bins = num_bins
+    self.tail_bound = tail_bound
+    self.half_channels = in_channels // 2
+
+    self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
+    self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.)
+    self.proj = nn.Conv1d(filter_channels, self.half_channels * (num_bins * 3 - 1), 1)
+    self.proj.weight.data.zero_()
+    self.proj.bias.data.zero_()
+
+  def forward(self, x, x_mask, g=None, reverse=False):
+    x0, x1 = torch.split(x, [self.half_channels]*2, 1)
+    h = self.pre(x0)
+    h = self.convs(h, x_mask, g=g)
+    h = self.proj(h) * x_mask
+
+    b, c, t = x0.shape
+    h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
+
+    unnormalized_widths = h[..., :self.num_bins] / math.sqrt(self.filter_channels)
+    unnormalized_heights = h[..., self.num_bins:2*self.num_bins] / math.sqrt(self.filter_channels)
+    unnormalized_derivatives = h[..., 2 * self.num_bins:]
+
+    x1, logabsdet = piecewise_rational_quadratic_transform(x1,
+        unnormalized_widths,
+        unnormalized_heights,
+        unnormalized_derivatives,
+        inverse=reverse,
+        tails='linear',
+        tail_bound=self.tail_bound
+    )
+
+    x = torch.cat([x0, x1], 1) * x_mask
+    logdet = torch.sum(logabsdet * x_mask, [1,2])
+    if not reverse:
+        return x, logdet
+    else:
+        return x
+
+
+class ResStack(nn.Module):
+  def __init__(self, channel, kernel_size=3, base=3, nums=4):
+    super(ResStack, self).__init__()
+
+    self.layers = nn.ModuleList([
+      nn.Sequential(
+          nn.LeakyReLU(),
+          nn.utils.weight_norm(nn.Conv1d(channel, channel,
+              kernel_size=kernel_size, dilation=base**i, padding=base**i)),
+          nn.LeakyReLU(),
+          nn.utils.weight_norm(nn.Conv1d(channel, channel,
+              kernel_size=kernel_size, dilation=1, padding=1)),
+      )
+      for i in range(nums)
+    ])
+
+  def forward(self, x):
+    for layer in self.layers:
+      x = x + layer(x)
+    return x

modules/stft.py

@@ -0,0 +1,512 @@
+from librosa.util import pad_center, tiny
+from scipy.signal import get_window
+from torch import Tensor
+from torch.autograd import Variable
+from typing import Optional, Tuple
+
+import librosa
+import librosa.util as librosa_util
+import math
+import numpy as np
+import scipy
+import torch
+import torch.nn.functional as F
+import warnings
+
+
+def create_fb_matrix(
+        n_freqs: int,
+        f_min: float,
+        f_max: float,
+        n_mels: int,
+        sample_rate: int,
+        norm: Optional[str] = None
+) -> Tensor:
+    r"""Create a frequency bin conversion matrix.
+
+    Args:
+        n_freqs (int): Number of frequencies to highlight/apply
+        f_min (float): Minimum frequency (Hz)
+        f_max (float): Maximum frequency (Hz)
+        n_mels (int): Number of mel filterbanks
+        sample_rate (int): Sample rate of the audio waveform
+        norm (Optional[str]): If 'slaney', divide the triangular mel weights by the width of the mel band
+        (area normalization). (Default: ``None``)
+
+    Returns:
+        Tensor: Triangular filter banks (fb matrix) of size (``n_freqs``, ``n_mels``)
+        meaning number of frequencies to highlight/apply to x the number of filterbanks.
+        Each column is a filterbank so that assuming there is a matrix A of
+        size (..., ``n_freqs``), the applied result would be
+        ``A * create_fb_matrix(A.size(-1), ...)``.
+    """
+
+    if norm is not None and norm != "slaney":
+        raise ValueError("norm must be one of None or 'slaney'")
+
+    # freq bins
+    # Equivalent filterbank construction by Librosa
+    all_freqs = torch.linspace(0, sample_rate // 2, n_freqs)
+
+    # calculate mel freq bins
+    # hertz to mel(f) is 2595. * math.log10(1. + (f / 700.))
+    m_min = 2595.0 * math.log10(1.0 + (f_min / 700.0))
+    m_max = 2595.0 * math.log10(1.0 + (f_max / 700.0))
+    m_pts = torch.linspace(m_min, m_max, n_mels + 2)
+    # mel to hertz(mel) is 700. * (10**(mel / 2595.) - 1.)
+    f_pts = 700.0 * (10 ** (m_pts / 2595.0) - 1.0)
+    # calculate the difference between each mel point and each stft freq point in hertz
+    f_diff = f_pts[1:] - f_pts[:-1]  # (n_mels + 1)
+    slopes = f_pts.unsqueeze(0) - all_freqs.unsqueeze(1)  # (n_freqs, n_mels + 2)
+    # create overlapping triangles
+    down_slopes = (-1.0 * slopes[:, :-2]) / f_diff[:-1]  # (n_freqs, n_mels)
+    up_slopes = slopes[:, 2:] / f_diff[1:]  # (n_freqs, n_mels)
+    fb = torch.min(down_slopes, up_slopes)
+    fb = torch.clamp(fb, 1e-6, 1)
+
+    if norm is not None and norm == "slaney":
+        # Slaney-style mel is scaled to be approx constant energy per channel
+        enorm = 2.0 / (f_pts[2:n_mels + 2] - f_pts[:n_mels])
+        fb *= enorm.unsqueeze(0)
+    return fb
+
+
+def lfilter(
+        waveform: Tensor,
+        a_coeffs: Tensor,
+        b_coeffs: Tensor,
+        clamp: bool = True,
+) -> Tensor:
+    r"""Perform an IIR filter by evaluating difference equation.
+
+    Args:
+        waveform (Tensor): audio waveform of dimension of ``(..., time)``.  Must be normalized to -1 to 1.
+        a_coeffs (Tensor): denominator coefficients of difference equation of dimension of ``(n_order + 1)``.
+                                Lower delays coefficients are first, e.g. ``[a0, a1, a2, ...]``.
+                                Must be same size as b_coeffs (pad with 0's as necessary).
+        b_coeffs (Tensor): numerator coefficients of difference equation of dimension of ``(n_order + 1)``.
+                                 Lower delays coefficients are first, e.g. ``[b0, b1, b2, ...]``.
+                                 Must be same size as a_coeffs (pad with 0's as necessary).
+        clamp (bool, optional): If ``True``, clamp the output signal to be in the range [-1, 1] (Default: ``True``)
+
+    Returns:
+        Tensor: Waveform with dimension of ``(..., time)``.
+    """
+    # pack batch
+    shape = waveform.size()
+    waveform = waveform.reshape(-1, shape[-1])
+
+    assert (a_coeffs.size(0) == b_coeffs.size(0))
+    assert (len(waveform.size()) == 2)
+    assert (waveform.device == a_coeffs.device)
+    assert (b_coeffs.device == a_coeffs.device)
+
+    device = waveform.device
+    dtype = waveform.dtype
+    n_channel, n_sample = waveform.size()
+    n_order = a_coeffs.size(0)
+    n_sample_padded = n_sample + n_order - 1
+    assert (n_order > 0)
+
+    # Pad the input and create output
+    padded_waveform = torch.zeros(n_channel, n_sample_padded, dtype=dtype, device=device)
+    padded_waveform[:, (n_order - 1):] = waveform
+    padded_output_waveform = torch.zeros(n_channel, n_sample_padded, dtype=dtype, device=device)
+
+    # Set up the coefficients matrix
+    # Flip coefficients' order
+    a_coeffs_flipped = a_coeffs.flip(0)
+    b_coeffs_flipped = b_coeffs.flip(0)
+
+    # calculate windowed_input_signal in parallel
+    # create indices of original with shape (n_channel, n_order, n_sample)
+    window_idxs = torch.arange(n_sample, device=device).unsqueeze(0) + torch.arange(n_order, device=device).unsqueeze(1)
+    window_idxs = window_idxs.repeat(n_channel, 1, 1)
+    window_idxs += (torch.arange(n_channel, device=device).unsqueeze(-1).unsqueeze(-1) * n_sample_padded)
+    window_idxs = window_idxs.long()
+    # (n_order, ) matmul (n_channel, n_order, n_sample) -> (n_channel, n_sample)
+    input_signal_windows = torch.matmul(b_coeffs_flipped, torch.take(padded_waveform, window_idxs))
+
+    input_signal_windows.div_(a_coeffs[0])
+    a_coeffs_flipped.div_(a_coeffs[0])
+    for i_sample, o0 in enumerate(input_signal_windows.t()):
+        windowed_output_signal = padded_output_waveform[:, i_sample:(i_sample + n_order)]
+        o0.addmv_(windowed_output_signal, a_coeffs_flipped, alpha=-1)
+        padded_output_waveform[:, i_sample + n_order - 1] = o0
+
+    output = padded_output_waveform[:, (n_order - 1):]
+
+    if clamp:
+        output = torch.clamp(output, min=-1., max=1.)
+
+    # unpack batch
+    output = output.reshape(shape[:-1] + output.shape[-1:])
+
+    return output
+
+
+
+def biquad(
+        waveform: Tensor,
+        b0: float,
+        b1: float,
+        b2: float,
+        a0: float,
+        a1: float,
+        a2: float
+) -> Tensor:
+    r"""Perform a biquad filter of input tensor.  Initial conditions set to 0.
+    https://en.wikipedia.org/wiki/Digital_biquad_filter
+
+    Args:
+        waveform (Tensor): audio waveform of dimension of `(..., time)`
+        b0 (float): numerator coefficient of current input, x[n]
+        b1 (float): numerator coefficient of input one time step ago x[n-1]
+        b2 (float): numerator coefficient of input two time steps ago x[n-2]
+        a0 (float): denominator coefficient of current output y[n], typically 1
+        a1 (float): denominator coefficient of current output y[n-1]
+        a2 (float): denominator coefficient of current output y[n-2]
+
+    Returns:
+        Tensor: Waveform with dimension of `(..., time)`
+    """
+
+    device = waveform.device
+    dtype = waveform.dtype
+
+    output_waveform = lfilter(
+        waveform,
+        torch.tensor([a0, a1, a2], dtype=dtype, device=device),
+        torch.tensor([b0, b1, b2], dtype=dtype, device=device)
+    )
+    return output_waveform
+
+
+
+def _dB2Linear(x: float) -> float:
+    return math.exp(x * math.log(10) / 20.0)
+
+
+def highpass_biquad(
+        waveform: Tensor,
+        sample_rate: int,
+        cutoff_freq: float,
+        Q: float = 0.707
+) -> Tensor:
+    r"""Design biquad highpass filter and perform filtering.  Similar to SoX implementation.
+
+    Args:
+        waveform (Tensor): audio waveform of dimension of `(..., time)`
+        sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
+        cutoff_freq (float): filter cutoff frequency
+        Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)
+
+    Returns:
+        Tensor: Waveform dimension of `(..., time)`
+    """
+    w0 = 2 * math.pi * cutoff_freq / sample_rate
+    alpha = math.sin(w0) / 2. / Q
+
+    b0 = (1 + math.cos(w0)) / 2
+    b1 = -1 - math.cos(w0)
+    b2 = b0
+    a0 = 1 + alpha
+    a1 = -2 * math.cos(w0)
+    a2 = 1 - alpha
+    return biquad(waveform, b0, b1, b2, a0, a1, a2)
+
+
+
+def lowpass_biquad(
+        waveform: Tensor,
+        sample_rate: int,
+        cutoff_freq: float,
+        Q: float = 0.707
+) -> Tensor:
+    r"""Design biquad lowpass filter and perform filtering.  Similar to SoX implementation.
+
+    Args:
+        waveform (torch.Tensor): audio waveform of dimension of `(..., time)`
+        sample_rate (int): sampling rate of the waveform, e.g. 44100 (Hz)
+        cutoff_freq (float): filter cutoff frequency
+        Q (float, optional): https://en.wikipedia.org/wiki/Q_factor (Default: ``0.707``)
+
+    Returns:
+        Tensor: Waveform of dimension of `(..., time)`
+    """
+    w0 = 2 * math.pi * cutoff_freq / sample_rate
+    alpha = math.sin(w0) / 2 / Q
+
+    b0 = (1 - math.cos(w0)) / 2
+    b1 = 1 - math.cos(w0)
+    b2 = b0
+    a0 = 1 + alpha
+    a1 = -2 * math.cos(w0)
+    a2 = 1 - alpha
+    return biquad(waveform, b0, b1, b2, a0, a1, a2)
+
+
+def window_sumsquare(window, n_frames, hop_length=200, win_length=800,
+                     n_fft=800, dtype=np.float32, norm=None):
+    """
+    # from librosa 0.6
+    Compute the sum-square envelope of a window function at a given hop length.
+
+    This is used to estimate modulation effects induced by windowing
+    observations in short-time fourier transforms.
+
+    Parameters
+    ----------
+    window : string, tuple, number, callable, or list-like
+        Window specification, as in `get_window`
+
+    n_frames : int > 0
+        The number of analysis frames
+
+    hop_length : int > 0
+        The number of samples to advance between frames
+
+    win_length : [optional]
+        The length of the window function.  By default, this matches `n_fft`.
+
+    n_fft : int > 0
+        The length of each analysis frame.
+
+    dtype : np.dtype
+        The data type of the output
+
+    Returns
+    -------
+    wss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))`
+        The sum-squared envelope of the window function
+    """
+    if win_length is None:
+        win_length = n_fft
+
+    n = n_fft + hop_length * (n_frames - 1)
+    x = np.zeros(n, dtype=dtype)
+
+    # Compute the squared window at the desired length
+    win_sq = get_window(window, win_length, fftbins=True)
+    win_sq = librosa_util.normalize(win_sq, norm=norm)**2
+    win_sq = librosa_util.pad_center(win_sq, n_fft)
+
+    # Fill the envelope
+    for i in range(n_frames):
+        sample = i * hop_length
+        x[sample:min(n, sample + n_fft)] += win_sq[:max(0, min(n_fft, n - sample))]
+    return x
+
+
+class MelScale(torch.nn.Module):
+    r"""Turn a normal STFT into a mel frequency STFT, using a conversion
+    matrix.  This uses triangular filter banks.
+
+    User can control which device the filter bank (`fb`) is (e.g. fb.to(spec_f.device)).
+
+    Args:
+        n_mels (int, optional): Number of mel filterbanks. (Default: ``128``)
+        sample_rate (int, optional): Sample rate of audio signal. (Default: ``16000``)
+        f_min (float, optional): Minimum frequency. (Default: ``0.``)
+        f_max (float or None, optional): Maximum frequency. (Default: ``sample_rate // 2``)
+        n_stft (int, optional): Number of bins in STFT. Calculated from first input
+            if None is given.  See ``n_fft`` in :class:`Spectrogram`. (Default: ``None``)
+    """
+    __constants__ = ['n_mels', 'sample_rate', 'f_min', 'f_max']
+
+    def __init__(self,
+                 n_mels: int = 128,
+                 sample_rate: int = 24000,
+                 f_min: float = 0.,
+                 f_max: Optional[float] = None,
+                 n_stft: Optional[int] = None) -> None:
+        super(MelScale, self).__init__()
+        self.n_mels = n_mels
+        self.sample_rate = sample_rate
+        self.f_max = f_max if f_max is not None else float(sample_rate // 2)
+        self.f_min = f_min
+
+        assert f_min <= self.f_max, 'Require f_min: %f < f_max: %f' % (f_min, self.f_max)
+
+        fb = torch.empty(0) if n_stft is None else create_fb_matrix(
+            n_stft, self.f_min, self.f_max, self.n_mels, self.sample_rate)
+        self.register_buffer('fb', fb)
+
+    def forward(self, specgram: Tensor) -> Tensor:
+        r"""
+        Args:
+            specgram (Tensor): A spectrogram STFT of dimension (..., freq, time).
+
+        Returns:
+            Tensor: Mel frequency spectrogram of size (..., ``n_mels``, time).
+        """
+
+        # pack batch
+        shape = specgram.size()
+        specgram = specgram.reshape(-1, shape[-2], shape[-1])
+
+        if self.fb.numel() == 0:
+            tmp_fb = create_fb_matrix(specgram.size(1), self.f_min, self.f_max, self.n_mels, self.sample_rate)
+            # Attributes cannot be reassigned outside __init__ so workaround
+            self.fb.resize_(tmp_fb.size())
+            self.fb.copy_(tmp_fb)
+
+        # (channel, frequency, time).transpose(...) dot (frequency, n_mels)
+        # -> (channel, time, n_mels).transpose(...)
+        mel_specgram = torch.matmul(specgram.transpose(1, 2), self.fb).transpose(1, 2)
+
+        # unpack batch
+        mel_specgram = mel_specgram.reshape(shape[:-2] + mel_specgram.shape[-2:])
+
+        return mel_specgram
+
+
+class TorchSTFT(torch.nn.Module):
+    def __init__(self, fft_size, hop_size, win_size,
+                 normalized=False, domain='linear',
+                 mel_scale=False, ref_level_db=20, min_level_db=-100):
+        super().__init__()
+        self.fft_size = fft_size
+        self.hop_size = hop_size
+        self.win_size = win_size
+        self.ref_level_db = ref_level_db
+        self.min_level_db = min_level_db
+        self.window = torch.hann_window(win_size)
+        self.normalized = normalized
+        self.domain = domain
+        self.mel_scale = MelScale(n_mels=(fft_size // 2 + 1),
+            n_stft=(fft_size // 2 + 1)) if mel_scale else None
+        
+    def transform(self, x):
+        x_stft = torch.stft(x, self.fft_size, self.hop_size, self.win_size,
+                            self.window.type_as(x), normalized=self.normalized)
+        real = x_stft[..., 0]
+        imag = x_stft[..., 1]
+        mag = torch.clamp(real ** 2 + imag ** 2, min=1e-7)
+        mag = torch.sqrt(mag)
+        phase = torch.atan2(imag, real)
+
+        if self.mel_scale is not None:
+            mag = self.mel_scale(mag)
+
+        if self.domain == 'log':
+            mag = 20 * torch.log10(mag) - self.ref_level_db
+            mag = torch.clamp((mag - self.min_level_db) / -self.min_level_db, 0, 1)
+            return mag, phase
+        elif self.domain == 'linear':
+            return mag, phase
+        elif self.domain == 'double':
+            log_mag = 20 * torch.log10(mag) - self.ref_level_db
+            log_mag = torch.clamp((log_mag - self.min_level_db) / -self.min_level_db, 0, 1)
+            return torch.cat((mag, log_mag), dim=1), phase
+
+    def complex(self, x):
+        x_stft = torch.stft(x, self.fft_size, self.hop_size, self.win_size,
+                            self.window.type_as(x), normalized=self.normalized)
+        real = x_stft[..., 0]
+        imag = x_stft[..., 1]
+        return real, imag
+
+
+
+class STFT(torch.nn.Module):
+    """adapted from Prem Seetharaman's https://github.com/pseeth/pytorch-stft"""
+    def __init__(self, filter_length=800, hop_length=200, win_length=800,
+                 window='hann'):
+        super(STFT, self).__init__()
+        self.filter_length = filter_length
+        self.hop_length = hop_length
+        self.win_length = win_length
+        self.window = window
+        self.forward_transform = None
+        scale = self.filter_length / self.hop_length
+        fourier_basis = np.fft.fft(np.eye(self.filter_length))
+
+        cutoff = int((self.filter_length / 2 + 1))
+        fourier_basis = np.vstack([np.real(fourier_basis[:cutoff, :]),
+                                   np.imag(fourier_basis[:cutoff, :])])
+
+        forward_basis = torch.FloatTensor(fourier_basis[:, None, :])
+        inverse_basis = torch.FloatTensor(
+            np.linalg.pinv(scale * fourier_basis).T[:, None, :])
+
+        if window is not None:
+            assert(filter_length >= win_length)
+            # get window and zero center pad it to filter_length
+            fft_window = get_window(window, win_length, fftbins=True)
+            fft_window = pad_center(fft_window, filter_length)
+            fft_window = torch.from_numpy(fft_window).float()
+
+            # window the bases
+            forward_basis *= fft_window
+            inverse_basis *= fft_window
+
+        self.register_buffer('forward_basis', forward_basis.float())
+        self.register_buffer('inverse_basis', inverse_basis.float())
+
+    def transform(self, input_data):
+        num_batches = input_data.size(0)
+        num_samples = input_data.size(1)
+
+        self.num_samples = num_samples
+
+        # similar to librosa, reflect-pad the input
+        input_data = input_data.view(num_batches, 1, num_samples)
+        input_data = F.pad(
+            input_data.unsqueeze(1),
+            (int(self.filter_length / 2), int(self.filter_length / 2), 0, 0),
+            mode='reflect')
+        input_data = input_data.squeeze(1)
+
+        forward_transform = F.conv1d(
+            input_data,
+            Variable(self.forward_basis, requires_grad=False),
+            stride=self.hop_length,
+            padding=0)
+
+        cutoff = int((self.filter_length / 2) + 1)
+        real_part = forward_transform[:, :cutoff, :]
+        imag_part = forward_transform[:, cutoff:, :]
+
+        magnitude = torch.sqrt(real_part**2 + imag_part**2)
+        phase = torch.autograd.Variable(
+            torch.atan2(imag_part.data, real_part.data))
+
+        return magnitude, phase
+
+    def inverse(self, magnitude, phase):
+        recombine_magnitude_phase = torch.cat(
+            [magnitude*torch.cos(phase), magnitude*torch.sin(phase)], dim=1)
+
+        inverse_transform = F.conv_transpose1d(
+            recombine_magnitude_phase,
+            Variable(self.inverse_basis, requires_grad=False),
+            stride=self.hop_length,
+            padding=0)
+
+        if self.window is not None:
+            window_sum = window_sumsquare(
+                self.window, magnitude.size(-1), hop_length=self.hop_length,
+                win_length=self.win_length, n_fft=self.filter_length,
+                dtype=np.float32)
+            # remove modulation effects
+            approx_nonzero_indices = torch.from_numpy(
+                np.where(window_sum > tiny(window_sum))[0])
+            window_sum = torch.autograd.Variable(
+                torch.from_numpy(window_sum), requires_grad=False)
+            window_sum = window_sum.cuda() if magnitude.is_cuda else window_sum
+            inverse_transform[:, :, approx_nonzero_indices] /= window_sum[approx_nonzero_indices]
+
+            # scale by hop ratio
+            inverse_transform *= float(self.filter_length) / self.hop_length
+
+        inverse_transform = inverse_transform[:, :, int(self.filter_length/2):]
+        inverse_transform = inverse_transform[:, :, :-int(self.filter_length/2):]
+
+        return inverse_transform
+
+    def forward(self, input_data):
+        self.magnitude, self.phase = self.transform(input_data)
+        reconstruction = self.inverse(self.magnitude, self.phase)
+        return reconstruction
+

modules/transforms.py

@@ -0,0 +1,193 @@
+import torch
+from torch.nn import functional as F
+
+import numpy as np
+
+
+DEFAULT_MIN_BIN_WIDTH = 1e-3
+DEFAULT_MIN_BIN_HEIGHT = 1e-3
+DEFAULT_MIN_DERIVATIVE = 1e-3
+
+
+def piecewise_rational_quadratic_transform(inputs, 
+                                           unnormalized_widths,
+                                           unnormalized_heights,
+                                           unnormalized_derivatives,
+                                           inverse=False,
+                                           tails=None, 
+                                           tail_bound=1.,
+                                           min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+                                           min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+                                           min_derivative=DEFAULT_MIN_DERIVATIVE):
+
+    if tails is None:
+        spline_fn = rational_quadratic_spline
+        spline_kwargs = {}
+    else:
+        spline_fn = unconstrained_rational_quadratic_spline
+        spline_kwargs = {
+            'tails': tails,
+            'tail_bound': tail_bound
+        }
+
+    outputs, logabsdet = spline_fn(
+            inputs=inputs,
+            unnormalized_widths=unnormalized_widths,
+            unnormalized_heights=unnormalized_heights,
+            unnormalized_derivatives=unnormalized_derivatives,
+            inverse=inverse,
+            min_bin_width=min_bin_width,
+            min_bin_height=min_bin_height,
+            min_derivative=min_derivative,
+            **spline_kwargs
+    )
+    return outputs, logabsdet
+
+
+def searchsorted(bin_locations, inputs, eps=1e-6):
+    bin_locations[..., -1] += eps
+    return torch.sum(
+        inputs[..., None] >= bin_locations,
+        dim=-1
+    ) - 1
+
+
+def unconstrained_rational_quadratic_spline(inputs,
+                                            unnormalized_widths,
+                                            unnormalized_heights,
+                                            unnormalized_derivatives,
+                                            inverse=False,
+                                            tails='linear',
+                                            tail_bound=1.,
+                                            min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+                                            min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+                                            min_derivative=DEFAULT_MIN_DERIVATIVE):
+    inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
+    outside_interval_mask = ~inside_interval_mask
+
+    outputs = torch.zeros_like(inputs)
+    logabsdet = torch.zeros_like(inputs)
+
+    if tails == 'linear':
+        unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
+        constant = np.log(np.exp(1 - min_derivative) - 1)
+        unnormalized_derivatives[..., 0] = constant
+        unnormalized_derivatives[..., -1] = constant
+
+        outputs[outside_interval_mask] = inputs[outside_interval_mask]
+        logabsdet[outside_interval_mask] = 0
+    else:
+        raise RuntimeError('{} tails are not implemented.'.format(tails))
+
+    outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
+        inputs=inputs[inside_interval_mask],
+        unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
+        unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
+        unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
+        inverse=inverse,
+        left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
+        min_bin_width=min_bin_width,
+        min_bin_height=min_bin_height,
+        min_derivative=min_derivative
+    )
+
+    return outputs, logabsdet
+
+def rational_quadratic_spline(inputs,
+                              unnormalized_widths,
+                              unnormalized_heights,
+                              unnormalized_derivatives,
+                              inverse=False,
+                              left=0., right=1., bottom=0., top=1.,
+                              min_bin_width=DEFAULT_MIN_BIN_WIDTH,
+                              min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
+                              min_derivative=DEFAULT_MIN_DERIVATIVE):
+    if torch.min(inputs) < left or torch.max(inputs) > right:
+        raise ValueError('Input to a transform is not within its domain')
+
+    num_bins = unnormalized_widths.shape[-1]
+
+    if min_bin_width * num_bins > 1.0:
+        raise ValueError('Minimal bin width too large for the number of bins')
+    if min_bin_height * num_bins > 1.0:
+        raise ValueError('Minimal bin height too large for the number of bins')
+
+    widths = F.softmax(unnormalized_widths, dim=-1)
+    widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
+    cumwidths = torch.cumsum(widths, dim=-1)
+    cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
+    cumwidths = (right - left) * cumwidths + left
+    cumwidths[..., 0] = left
+    cumwidths[..., -1] = right
+    widths = cumwidths[..., 1:] - cumwidths[..., :-1]
+
+    derivatives = min_derivative + F.softplus(unnormalized_derivatives)
+
+    heights = F.softmax(unnormalized_heights, dim=-1)
+    heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
+    cumheights = torch.cumsum(heights, dim=-1)
+    cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
+    cumheights = (top - bottom) * cumheights + bottom
+    cumheights[..., 0] = bottom
+    cumheights[..., -1] = top
+    heights = cumheights[..., 1:] - cumheights[..., :-1]
+
+    if inverse:
+        bin_idx = searchsorted(cumheights, inputs)[..., None]
+    else:
+        bin_idx = searchsorted(cumwidths, inputs)[..., None]
+
+    input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
+    input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
+
+    input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
+    delta = heights / widths
+    input_delta = delta.gather(-1, bin_idx)[..., 0]
+
+    input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
+    input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
+
+    input_heights = heights.gather(-1, bin_idx)[..., 0]
+
+    if inverse:
+        a = (((inputs - input_cumheights) * (input_derivatives
+                                             + input_derivatives_plus_one
+                                             - 2 * input_delta)
+              + input_heights * (input_delta - input_derivatives)))
+        b = (input_heights * input_derivatives
+             - (inputs - input_cumheights) * (input_derivatives
+                                              + input_derivatives_plus_one
+                                              - 2 * input_delta))
+        c = - input_delta * (inputs - input_cumheights)
+
+        discriminant = b.pow(2) - 4 * a * c
+        assert (discriminant >= 0).all()
+
+        root = (2 * c) / (-b - torch.sqrt(discriminant))
+        outputs = root * input_bin_widths + input_cumwidths
+
+        theta_one_minus_theta = root * (1 - root)
+        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
+                                     * theta_one_minus_theta)
+        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
+                                                     + 2 * input_delta * theta_one_minus_theta
+                                                     + input_derivatives * (1 - root).pow(2))
+        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
+
+        return outputs, -logabsdet
+    else:
+        theta = (inputs - input_cumwidths) / input_bin_widths
+        theta_one_minus_theta = theta * (1 - theta)
+
+        numerator = input_heights * (input_delta * theta.pow(2)
+                                     + input_derivatives * theta_one_minus_theta)
+        denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
+                                     * theta_one_minus_theta)
+        outputs = input_cumheights + numerator / denominator
+
+        derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
+                                                     + 2 * input_delta * theta_one_minus_theta
+                                                     + input_derivatives * (1 - theta).pow(2))
+        logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
+
+        return outputs, logabsdet

preprocess/mel_processing.py

@@ -0,0 +1,104 @@
+import math
+import os
+import random
+import torch
+from torch import nn
+import torch.nn.functional as F
+import torch.utils.data
+import numpy as np
+import librosa
+import librosa.util as librosa_util
+from librosa.util import normalize, pad_center, tiny
+from scipy.signal import get_window
+from scipy.io.wavfile import read
+from librosa.filters import mel as librosa_mel_fn
+
+MAX_WAV_VALUE = 32768.0
+
+
+def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
+    """
+    PARAMS
+    ------
+    C: compression factor
+    """
+    return torch.log(torch.clamp(x, min=clip_val) * C)
+
+
+def dynamic_range_decompression_torch(x, C=1):
+    """
+    PARAMS
+    ------
+    C: compression factor used to compress
+    """
+    return torch.exp(x) / C
+
+
+def spectral_normalize_torch(magnitudes):
+    output = dynamic_range_compression_torch(magnitudes)
+    return output
+
+
+def spectral_de_normalize_torch(magnitudes):
+    output = dynamic_range_decompression_torch(magnitudes)
+    return output
+
+
+mel_basis = {}
+hann_window = {}
+
+
+def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
+    
+    global hann_window
+    dtype_device = str(y.dtype) + '_' + str(y.device)
+    wnsize_dtype_device = str(win_size) + '_' + dtype_device
+    if wnsize_dtype_device not in hann_window:
+        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
+
+    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
+    y = y.squeeze(1)
+
+    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
+                      center=center, pad_mode='reflect', normalized=False, onesided=True)
+
+    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
+    return spec
+
+
+def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
+    global mel_basis
+    dtype_device = str(spec.dtype) + '_' + str(spec.device)
+    fmax_dtype_device = str(fmax) + '_' + dtype_device
+    if fmax_dtype_device not in mel_basis:
+        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
+        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
+    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
+    spec = spectral_normalize_torch(spec)
+    return spec
+
+
+def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
+     
+    global mel_basis, hann_window
+    dtype_device = str(y.dtype) + '_' + str(y.device)
+    fmax_dtype_device = str(fmax) + '_' + dtype_device
+    wnsize_dtype_device = str(win_size) + '_' + dtype_device
+    if fmax_dtype_device not in mel_basis:
+        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
+        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
+    if wnsize_dtype_device not in hann_window:
+        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
+
+    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
+    y = y.squeeze(1)
+
+    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
+                      center=center, pad_mode='reflect', normalized=False, onesided=True)
+
+    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
+
+    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
+    spec = spectral_normalize_torch(spec)
+
+    return spec

preprocess/prepare_multispeaker.py

@@ -0,0 +1,10 @@
+import os
+import shutil
+
+for spk in os.listdir("data"):
+    if os.path.isdir(f"data/{spk}"):
+        if os.path.exists(f"data/{spk}/raw/wavs"):
+            shutil.move(f"data/{spk}/raw/wavs", f"data/{spk}")
+            shutil.move(f"data/{spk}/raw/transcriptions.txt", f"data/{spk}")
+            shutil.rmtree(f"data/{spk}/raw")
+

preprocess/preprocess.py

@@ -0,0 +1,103 @@
+import glob
+import os
+import sys
+import argparse
+import numpy as np
+from multiprocessing import cpu_count
+from concurrent.futures import ProcessPoolExecutor
+from functools import partial
+from utils import audio
+import utils.utils as utils
+from tqdm import tqdm
+import pyworld as pw
+from random import shuffle
+
+import warnings
+warnings.filterwarnings("ignore")
+
+def extract_mel(wav, hparams):
+    mel_spectrogram = audio.melspectrogram(wav, hparams).astype(np.float32)
+    return mel_spectrogram.T, wav
+
+def extract_pitch(wav, hps):
+    # rapt may be better
+    f0, _ = pw.harvest(wav.astype(np.float64),
+                   hps.sample_rate,
+                   frame_period=hps.hop_size / hps.sample_rate * 1000)
+    return f0
+
+def process_utterance(hps, data_root, item):
+    out_dir = data_root
+
+    wav_path = os.path.join(data_root, "wavs",
+                            "{}.wav".format(item))
+    wav = audio.load_wav(wav_path,
+                         raw_sr=hps.data.sample_rate,
+                         target_sr=hps.data.sample_rate,
+                         win_size=hps.data.win_size,
+                         hop_size=hps.data.hop_size)
+
+    mel, _ = extract_mel(wav, hps.data)
+    out_mel_dir = os.path.join(out_dir, "mels")
+    os.makedirs(out_mel_dir, exist_ok=True)
+    mel_path = os.path.join(out_mel_dir, item)
+    np.save(mel_path, mel)
+
+    pitch = extract_pitch(wav, hps.data)
+    out_pitch_dir = os.path.join(out_dir, "pitch")
+    os.makedirs(out_pitch_dir, exist_ok=True)
+    pitch_path = os.path.join(out_pitch_dir, item)
+    np.save(pitch_path, pitch)
+
+
+def process(args, hps, data_dir):
+    print(os.path.join(data_dir, "wavs"))
+    if(not os.path.exists(os.path.join(data_dir, "file.list"))):
+        with open(os.path.join(data_dir, "file.list") , "w") as out_file:
+            files = os.listdir(os.path.join(data_dir, "wavs"))
+            files = [i for i in files if i.endswith(".wav")]
+            for f in files:
+                out_file.write(f.strip().split(".")[0] + '\n')
+    metadata = [
+        item.strip() for item in open(
+            os.path.join(data_dir, "file.list")).readlines()
+    ]
+    executor = ProcessPoolExecutor(max_workers=args.num_workers)
+    results = []
+    for item in metadata:
+        results.append(executor.submit(partial(process_utterance, hps, data_dir, item)))
+    return [result.result() for result in tqdm(results)]
+
+def split_dataset(data_dir):
+    metadata = [
+        item.strip() for item in open(
+            os.path.join(data_dir, "file.list")).readlines()
+    ]
+    shuffle(metadata)
+    train_set = metadata[:-2]
+    test_set =  metadata[-2:]
+    with open(os.path.join(data_dir, "train.list"), "w") as ts:
+        for item in train_set:
+            ts.write(item+"\n")
+    with open(os.path.join(data_dir, "test.list"), "w") as ts:
+        for item in test_set:
+            ts.write(item+"\n")
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--config',
+                        default='config.json',
+                        help='json files for configurations.')
+    parser.add_argument('--num_workers', type=int, default=int(cpu_count()) // 2)
+
+    args = parser.parse_args()
+    hps = utils.get_hparams_from_file(args.config)
+    spklist = [spk for spk in os.listdir("data") if os.path.isdir(f"data/{spk}") and not os.path.exists(f"data/{spk}/test.list")]
+    for spk in tqdm(spklist):
+        print(f"preprocessing {spk}")
+        data_dir = f"data/{spk}"
+        process(args, hps, data_dir)
+        split_dataset(data_dir)
+
+if __name__ == "__main__":
+    main()

preprocess/preprocess_multispeaker.py

@@ -0,0 +1,28 @@
+import glob
+import json
+
+data_root = "data"
+
+
+transcriptions = glob.glob(f"{data_root}/*/transcriptions.txt")
+spk2id = {}
+spk_id = 0
+ms_transcriptions = open(f'{data_root}/transcriptions.txt', "w")
+ms_train_set = open(f'{data_root}/train.list', "w")
+ms_test_set = open(f'{data_root}/test.list', "w")
+for transcription in transcriptions:
+    spk = transcription.split("/")[-2]
+    spk2id[spk] = spk_id
+    spk_id += 1
+    for line in open(transcription).readlines():
+        ms_transcriptions.write(f"{spk}/{line}")
+    for line in open(transcription.replace("transcriptions.txt", "train.list")):
+        ms_train_set.write(f"{spk}/{line}")
+    for line in open(transcription.replace("transcriptions.txt", "test.list")):
+        ms_test_set.write(f"{spk}/{line}")
+
+ms_transcriptions.close()
+ms_train_set.close()
+ms_test_set.close()
+print("请手动将说话人与id的映射粘贴至config文件中")
+print(json.dumps(spk2id))

requirements.txt

@@ -0,0 +1,9 @@
+ipython==8.8.0
+librosa==0.8.1
+matplotlib==3.3.2
+numpy==1.19.2
+pyworld==0.3.0
+scipy==1.5.2
+soundfile==0.11.0
+torch==1.8.1
+tqdm==4.50.2

text/npu/__init__.py

@@ -0,0 +1,2 @@
+from text.npu import symbols
+from text.npu.symbol_converter import *

text/npu/symbol_converter.py

@@ -0,0 +1,34 @@
+import re
+import numpy as np
+from text.npu.symbols import *
+import os
+
+# Mappings from symbol to numeric ID and vice versa:
+_ttsing_phone_to_id = {p: i for i, p in enumerate(ttsing_phone_set)}
+_ttsing_pitch_to_id = {p: i for i, p in enumerate(ttsing_pitch_set)}
+_ttsing_slur_to_id = {s: i for i, s in enumerate(ttsing_slur_set)}
+
+ttsing_phone_to_int = {}
+int_to_ttsing_phone = {}
+for idx, item in enumerate(ttsing_phone_set):
+    ttsing_phone_to_int[item] = idx
+    int_to_ttsing_phone[idx] = item
+
+ttsing_pitch_to_int = {}
+int_to_ttsing_pitch = {}
+for idx, item in enumerate(ttsing_pitch_set):
+    ttsing_pitch_to_int[item] = idx
+    int_to_ttsing_pitch[idx] = item
+
+# opencpop
+ttsing_opencpop_pitch_to_int = {}
+for idx, item in enumerate(ttsing_opencpop_pitch_set):
+    ttsing_opencpop_pitch_to_int[item] = idx
+
+ttsing_slur_to_int = {}
+int_to_ttsing_slur = {}
+for idx, item in enumerate(ttsing_slur_set):
+    ttsing_slur_to_int[item] = idx
+    int_to_ttsing_slur[idx] = item
+
+

text/npu/symbols.py

@@ -0,0 +1,61 @@
+
+ttsing_phone_set = ['_'] + [
+    "b", "c", "ch", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r",
+    "s", "sh", "t", "x", "z", "zh", "a", "ai", "an", "ang", "ao", "e", "ei",
+    "en", "eng", "er", "iii", "ii", "i", "ia", "ian", "iang", "iao", "ie", "in",
+    "ing", "iong", "iou", "o", "ong", "ou", "u", "ua", "uai", "uan", "uang",
+    "uei", "uen", "ueng", "uo", "v", "van", "ve", "vn", "AH", "AA", "AO", "ER",
+    "IH", "IY", "UH", "UW", "EH", "AE", "AY", "EY", "OY", "AW", "OW", "P", "B",
+    "T", "D", "K", "G", "M", "N", "NG", "L", "S", "Z", "Y", "TH", "DH", "SH",
+    "ZH", "CH", "JH", "V", "W", "F", "R", "HH", "AH0", "AA0", "AO0", "ER0",
+    "IH0", "IY0", "UH0", "UW0", "EH0", "AE0", "AY0", "EY0", "OY0", "AW0", "OW0",
+    "AH1", "AA1", "AO1", "ER1", "IH1", "IY1", "UH1", "UW1", "EH1", "AE1", "AY1",
+    "EY1", "OY1", "AW1", "OW1", "AH2", "AA2", "AO2", "ER2", "IH2", "IY2", "UH2",
+    "UW2", "EH2", "AE2", "AY2", "EY2", "OY2", "AW2", "OW2", "AH3", "AA3", "AO3",
+    "ER3", "IH3", "IY3", "UH3", "UW3", "EH3", "AE3", "AY3", "EY3", "OY3", "AW3",
+    "OW3", "D-1", "T-1", "P*", "B*", "T*", "D*", "K*", "G*", "M*", "N*", "NG*",
+    "L*", "S*", "Z*", "Y*", "TH*", "DH*", "SH*", "ZH*", "CH*", "JH*", "V*",
+    "W*", "F*", "R*", "HH*", "sp", "sil", "or", "ar", "aor", "our", "angr",
+    "eir", "engr", "air", "ianr", "iaor", "ir", "ingr", "ur", "iiir", "uar",
+    "uangr", "uenr", "iir", "ongr", "uor", "ueir", "iar", "iangr", "inr",
+    "iour", "vr", "uanr", "ruai", "TR", "rest", 
+    # opencpop
+    'w', 'SP', 'AP', 'un', 'y', 'ui', 'iu',
+    "iour", "vr", "uanr", "ruai", "TR", "rest",
+    # opencpop
+    'w', 'SP', 'AP', 'un', 'y', 'ui', 'iu',
+    # opencpop-strict
+    'i0', 'E', 'En'
+]
+
+ttsing_pitch_set = ['_'] + [
+    "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C#/Db0", "C#/Db1", "C#/Db2",
+    "C#/Db3", "C#/Db4", "C#/Db5", "C#/Db6", "D0", "D1", "D2", "D3", "D4", "D5",
+    "D6", "D#/Eb0", "D#/Eb1", "D#/Eb2", "D#/Eb3", "D#/Eb4", "D#/Eb5", "D#/Eb6",
+    "E0", "E1", "E2", "E3", "E4", "E5", "E6", "F0", "F1", "F2", "F3", "F4",
+    "F5", "F6", "F#/Gb0", "F#/Gb1", "F#/Gb2", "F#/Gb3", "F#/Gb4", "F#/Gb5",
+    "F#/Gb6", "G0", "G1", "G2", "G3", "G4", "G5", "G6", "G#/Ab0", "G#/Ab1",
+    "G#/Ab2", "G#/Ab3", "G#/Ab4", "G#/Ab5", "G#/Ab6", "A0", "A1", "A2", "A3",
+    "A4", "A5", "A6", "A#/Bb0", "A#/Bb1", "A#/Bb2", "A#/Bb3", "A#/Bb4",
+    "A#/Bb5", "A#/Bb6", "B0", "B1", "B2", "B3", "B4", "B5", "B6", "RestRest"
+]
+
+ttsing_opencpop_pitch_set = ['_'] + [
+    "C0", "C1", "C2", "C3", "C4", "C5", "C6", 
+    "C#0/Db0", "C#1/Db1", "C#2/Db2", "C#3/Db3", "C#4/Db4", "C#5/Db5", "C#6/Db6", 
+    "D0", "D1", "D2", "D3", "D4", "D5", "D6", 
+    "D#0/Eb0", "D#1/Eb1", "D#2/Eb2", "D#3/Eb3", "D#4/Eb4", "D#5/Eb5", "D#6/Eb6",
+    "E0", "E1", "E2", "E3", "E4", "E5", "E6", 
+    "F0", "F1", "F2", "F3", "F4", "F5", "F6", 
+    "F#0/Gb0", "F#1/Gb1", "F#2/Gb2", "F#3/Gb3", "F#4/Gb4", "F#5/Gb5", "F#6/Gb6",
+    "G0", "G1", "G2", "G3", "G4", "G5", "G6", 
+    "G#0/Ab0", "G#1/Ab1", "G#2/Ab2", "G#3/Ab3", "G#4/Ab4", "G#5/Ab5", "G#6/Ab6", 
+    "A0", "A1", "A2", "A3", "A4", "A5", "A6", 
+    "A#0/Bb0", "A#1/Bb1", "A#2/Bb2", "A#3/Bb3", "A#4/Bb4", "A#5/Bb5", "A#6/Bb6", 
+    "B0", "B1", "B2", "B3", "B4", "B5", "B6", 
+    "RestRest", "rest"
+]
+
+ttsing_slur_set = ['_'] + ['0', '1']
+
+

utils/audio.py

@@ -0,0 +1,99 @@
+import numpy as np
+from numpy import linalg as LA
+import librosa
+from scipy.io import wavfile
+import soundfile as sf
+import librosa.filters
+
+
+def load_wav(wav_path, raw_sr, target_sr=16000, win_size=800, hop_size=200):
+    audio = librosa.core.load(wav_path, sr=raw_sr)[0]
+    if raw_sr != target_sr:
+        audio = librosa.core.resample(audio,
+                                      raw_sr,
+                                      target_sr,
+                                      res_type='kaiser_best')
+        target_length = (audio.size // hop_size +
+                         win_size // hop_size) * hop_size
+        pad_len = (target_length - audio.size) // 2
+        if audio.size % 2 == 0:
+            audio = np.pad(audio, (pad_len, pad_len), mode='reflect')
+        else:
+            audio = np.pad(audio, (pad_len, pad_len + 1), mode='reflect')
+    return audio
+
+
+def save_wav(wav, path, sample_rate, norm=False):
+    if norm:
+        wav *= 32767 / max(0.01, np.max(np.abs(wav)))
+        wavfile.write(path, sample_rate, wav.astype(np.int16))
+    else:
+        sf.write(path, wav, sample_rate)
+
+
+_mel_basis = None
+_inv_mel_basis = None
+
+
+def _build_mel_basis(hparams):
+    assert hparams.fmax <= hparams.sample_rate // 2
+    return librosa.filters.mel(hparams.sample_rate,
+                               hparams.n_fft,
+                               n_mels=hparams.acoustic_dim,
+                               fmin=hparams.fmin,
+                               fmax=hparams.fmax)
+
+
+def _linear_to_mel(spectogram, hparams):
+    global _mel_basis
+    if _mel_basis is None:
+        _mel_basis = _build_mel_basis(hparams)
+    return np.dot(_mel_basis, spectogram)
+
+
+def _mel_to_linear(mel_spectrogram, hparams):
+    global _inv_mel_basis
+    if _inv_mel_basis is None:
+        _inv_mel_basis = np.linalg.pinv(_build_mel_basis(hparams))
+    return np.maximum(1e-10, np.dot(_inv_mel_basis, mel_spectrogram))
+
+
+def _stft(y, hparams):
+    return librosa.stft(y=y,
+                        n_fft=hparams.n_fft,
+                        hop_length=hparams.hop_size,
+                        win_length=hparams.win_size)
+
+
+def _amp_to_db(x, hparams):
+    min_level = np.exp(hparams.min_level_db / 20 * np.log(10))
+    return 20 * np.log10(np.maximum(min_level, x))
+
+def _normalize(S, hparams):
+    return hparams.max_abs_value * np.clip(((S - hparams.min_db) /
+                                         (-hparams.min_db)), 0, 1)
+
+def _db_to_amp(x):
+    return np.power(10.0, (x) * 0.05)
+
+
+def _stft(y, hparams):
+    return librosa.stft(y=y,
+                        n_fft=hparams.n_fft,
+                        hop_length=hparams.hop_size,
+                        win_length=hparams.win_size)
+
+
+def _istft(y, hparams):
+    return librosa.istft(y,
+                         hop_length=hparams.hop_size,
+                         win_length=hparams.win_size)
+
+
+def melspectrogram(wav, hparams):
+    D = _stft(wav, hparams)
+    S = _amp_to_db(_linear_to_mel(np.abs(D), hparams),
+                   hparams) - hparams.ref_level_db
+    return _normalize(S, hparams)
+
+

utils/utils.py

@@ -0,0 +1,268 @@
+import os
+import glob
+import sys
+import argparse
+import logging
+import json
+import subprocess
+import numpy as np
+from scipy.io.wavfile import read
+import torch
+
+MATPLOTLIB_FLAG = False
+
+logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
+logger = logging
+
+
+def load_checkpoint(checkpoint_path, model, optimizer=None):
+    assert os.path.isfile(checkpoint_path)
+    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
+    iteration = checkpoint_dict['iteration']
+    learning_rate = checkpoint_dict['learning_rate']
+    if optimizer is not None:
+        optimizer.load_state_dict(checkpoint_dict['optimizer'])
+    saved_state_dict = checkpoint_dict['model']
+    if hasattr(model, 'module'):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    new_state_dict = {}
+    for k, v in state_dict.items():
+        try:
+            new_state_dict[k] = saved_state_dict[k]
+            assert saved_state_dict[k].shape == v.shape, (saved_state_dict[k].shape, v.shape)
+        except:
+            print("error, %s is not in the checkpoint" % k)
+            logger.info("%s is not in the checkpoint" % k)
+            new_state_dict[k] = v
+    if hasattr(model, 'module'):
+        model.module.load_state_dict(new_state_dict)
+    else:
+        model.load_state_dict(new_state_dict)
+    print("load ")
+    logger.info("Loaded checkpoint '{}' (iteration {})".format(
+        checkpoint_path, iteration))
+    return model, optimizer, learning_rate, iteration
+
+
+def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path, val_steps):
+    ckptname = checkpoint_path.split(os.sep)[-1]
+    newest_step = int(ckptname.split(".")[0].split("_")[1])
+    last_ckptname = checkpoint_path.replace(str(newest_step), str(newest_step - val_steps * 2))
+    if newest_step >= val_steps * 2:
+        os.system(f"rm {last_ckptname}")
+
+    logger.info("Saving model and optimizer state at iteration {} to {}".format(
+        iteration, checkpoint_path))
+    if hasattr(model, 'module'):
+        state_dict = model.module.state_dict()
+    else:
+        state_dict = model.state_dict()
+    torch.save({'model': state_dict,
+                'iteration': iteration,
+                'optimizer': optimizer.state_dict(),
+                'learning_rate': learning_rate}, checkpoint_path)
+
+
+def summarize(writer, global_step, scalars={}, histograms={}, images={}, audios={}, audio_sampling_rate=22050):
+    for k, v in scalars.items():
+        writer.add_scalar(k, v, global_step)
+    for k, v in histograms.items():
+        writer.add_histogram(k, v, global_step)
+    for k, v in images.items():
+        writer.add_image(k, v, global_step, dataformats='HWC')
+    for k, v in audios.items():
+        writer.add_audio(k, v, global_step, audio_sampling_rate)
+
+
+def latest_checkpoint_path(dir_path, regex="G_*.pth"):
+    f_list = glob.glob(os.path.join(dir_path, regex))
+    f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
+    x = f_list[-1]
+    print(x)
+    return x
+
+
+def plot_spectrogram_to_numpy(spectrogram):
+    global MATPLOTLIB_FLAG
+    if not MATPLOTLIB_FLAG:
+        import matplotlib
+        matplotlib.use("Agg")
+        MATPLOTLIB_FLAG = True
+        mpl_logger = logging.getLogger('matplotlib')
+        mpl_logger.setLevel(logging.WARNING)
+    import matplotlib.pylab as plt
+    import numpy as np
+
+    fig, ax = plt.subplots(figsize=(10, 2))
+    im = ax.imshow(spectrogram, aspect="auto", origin="lower",
+                   interpolation='none')
+    plt.colorbar(im, ax=ax)
+    plt.xlabel("Frames")
+    plt.ylabel("Channels")
+    plt.tight_layout()
+
+    fig.canvas.draw()
+    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data
+
+
+def plot_alignment_to_numpy(alignment, info=None):
+    global MATPLOTLIB_FLAG
+    if not MATPLOTLIB_FLAG:
+        import matplotlib
+        matplotlib.use("Agg")
+        MATPLOTLIB_FLAG = True
+        mpl_logger = logging.getLogger('matplotlib')
+        mpl_logger.setLevel(logging.WARNING)
+    import matplotlib.pylab as plt
+    import numpy as np
+
+    fig, ax = plt.subplots(figsize=(6, 4))
+    im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
+                   interpolation='none')
+    fig.colorbar(im, ax=ax)
+    xlabel = 'Decoder timestep'
+    if info is not None:
+        xlabel += '\n\n' + info
+    plt.xlabel(xlabel)
+    plt.ylabel('Encoder timestep')
+    plt.tight_layout()
+
+    fig.canvas.draw()
+    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
+    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
+    plt.close()
+    return data
+
+
+def load_wav_to_torch(full_path):
+    sampling_rate, data = read(full_path)
+    return torch.FloatTensor(data.astype(np.float32)), sampling_rate
+
+
+def load_filepaths_and_text(filename, split="|"):
+    with open(filename, encoding='utf-8') as f:
+        filepaths_and_text = [line.strip().split(split) for line in f]
+    return filepaths_and_text
+
+
+def get_hparams(init=True):
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
+                        help='JSON file for configuration')
+    # parser.add_argument('-m', '--model', type=str, required=True,
+    #                    help='Model name')
+
+    args = parser.parse_args()
+
+    config_path = args.config
+    with open(config_path, "r") as f:
+        data = f.read()
+    config = json.loads(data)
+
+    hparams = HParams(**config)
+    # hparams.model_dir = model_dir
+    model_dir = hparams.train.save_dir
+    config_save_path = os.path.join(model_dir, "config.json")
+
+    if not os.path.exists(model_dir):
+        os.makedirs(model_dir)
+
+    with open(config_save_path, "w") as f:
+        f.write(data)
+    return hparams
+
+
+def get_hparams_from_dir(model_dir):
+    config_save_path = os.path.join(model_dir, "config.json")
+    with open(config_save_path, "r") as f:
+        data = f.read()
+    config = json.loads(data)
+
+    hparams = HParams(**config)
+    hparams.model_dir = model_dir
+    return hparams
+
+
+def get_hparams_from_file(config_path):
+    with open(config_path, "r") as f:
+        data = f.read()
+    config = json.loads(data)
+
+    hparams = HParams(**config)
+    return hparams
+
+
+def check_git_hash(model_dir):
+    source_dir = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+    if not os.path.exists(os.path.join(source_dir, ".git")):
+        logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
+            source_dir
+        ))
+        return
+
+    cur_hash = subprocess.getoutput("git rev-parse HEAD")
+
+    path = os.path.join(model_dir, "githash")
+    if os.path.exists(path):
+        saved_hash = open(path).read()
+        if saved_hash != cur_hash:
+            logger.warn("git hash values are different. {}(saved) != {}(current)".format(
+                saved_hash[:8], cur_hash[:8]))
+    else:
+        open(path, "w").write(cur_hash)
+
+
+def get_logger(model_dir, filename="train.log"):
+    global logger
+    logger = logging.getLogger(os.path.basename(model_dir))
+    logger.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
+    if not os.path.exists(model_dir):
+        os.makedirs(model_dir)
+    h = logging.FileHandler(os.path.join(model_dir, filename))
+    h.setLevel(logging.DEBUG)
+    h.setFormatter(formatter)
+    logger.addHandler(h)
+    return logger
+
+
+def count_parameters(model):
+    return sum(p.numel() for p in model.parameters() if p.requires_grad) / 1e6
+
+
+class HParams():
+    def __init__(self, **kwargs):
+        for k, v in kwargs.items():
+            if type(v) == dict:
+                v = HParams(**v)
+            self[k] = v
+
+    def keys(self):
+        return self.__dict__.keys()
+
+    def items(self):
+        return self.__dict__.items()
+
+    def values(self):
+        return self.__dict__.values()
+
+    def __len__(self):
+        return len(self.__dict__)
+
+    def __getitem__(self, key):
+        return getattr(self, key)
+
+    def __setitem__(self, key, value):
+        return setattr(self, key, value)
+
+    def __contains__(self, key):
+        return key in self.__dict__
+
+    def __repr__(self):
+        return self.__dict__.__repr__()