upload files

README.md

@@ -1,8 +1,8 @@
 ---
 title: Shanghainese TTS
-emoji: 📉
-colorFrom: yellow
-colorTo: purple
+emoji: 📈
+colorFrom: purple
+colorTo: yellow
 sdk: gradio
 sdk_version: 3.4.1
 app_file: app.py

app.py

@@ -0,0 +1,79 @@
+import torch
+import librosa
+import commons
+import utils
+from models import SynthesizerTrn
+from text import text_to_sequence
+import numpy as np
+from mel_processing import spectrogram_torch
+import gradio as gr
+from text.cleaners import shanghainese_cleaners
+
+
+DEFAULT_TEXT='阿拉小人天天辣辣白相，书一眼也勿看，拿我急煞脱了。侬讲是𠲎？'
+
+
+def clean_text(text,ipa_input):
+    if ipa_input:
+        return shanghainese_cleaners(text)
+    return text
+
+
+def get_text(text, hps, cleaned=False):
+    if cleaned:
+        text_norm = text_to_sequence(text, hps.symbols, [])
+    else:
+        text_norm = text_to_sequence(text, hps.symbols, hps.data.text_cleaners)
+    if hps.data.add_blank:
+        text_norm = commons.intersperse(text_norm, 0)
+    text_norm = torch.LongTensor(text_norm)
+    return text_norm
+
+
+def speech_synthesize(text, cleaned, length_scale):
+    text=text.replace('\n','')
+    stn_tst = get_text(text, hps_ms, cleaned)
+    with torch.no_grad():
+        x_tst = stn_tst.unsqueeze(0)
+        x_tst_lengths = torch.LongTensor([stn_tst.size(0)])
+        sid = torch.LongTensor([0])
+        audio = net_g_ms.infer(x_tst, x_tst_lengths, sid=sid, noise_scale=0.667, noise_scale_w=0.8, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
+    return (hps_ms.data.sampling_rate, audio)
+
+
+if __name__=='__main__':
+    hps_ms = utils.get_hparams_from_file('model/config.json')
+    n_speakers = hps_ms.data.n_speakers
+    n_symbols = len(hps_ms.symbols)
+    speakers = hps_ms.speakers
+
+    net_g_ms = SynthesizerTrn(
+        n_symbols,
+        hps_ms.data.filter_length // 2 + 1,
+        hps_ms.train.segment_size // hps_ms.data.hop_length,
+        n_speakers=n_speakers,
+        **hps_ms.model)
+    _ = net_g_ms.eval()
+    utils.load_checkpoint('model/model.pth', net_g_ms)
+
+    with gr.Blocks() as app:
+        gr.Markdown('# Shanghainese Text to Speech\n'
+        '![visitor badge](https://visitor-badge.glitch.me/badge?page_id=cjangcjengh.shanghainese-tts)')
+        gr.Markdown('<center><b>If you don\'t know how to type, see examples <a href="https://huggingface.co/spaces/CjangCjengh/Shanghainese-TTS/raw/main/shanghainese_script.txt">HERE</a></b></center>')
+        text_input = gr.TextArea(label='Text', placeholder='Type your text here',value=DEFAULT_TEXT)
+        cleaned_text=gr.Checkbox(label='IPA Input',default=True)
+        length_scale=gr.Slider(0.5,2,1,step=0.1,label='Speaking Speed',interactive=True)
+        tts_button = gr.Button('Synthesize')
+        audio_output = gr.Audio(label='Speech Synthesized')
+        cleaned_text.change(clean_text,[text_input,cleaned_text],[text_input])
+        tts_button.click(speech_synthesize,[text_input,cleaned_text,length_scale],[audio_output])
+        gr.Markdown('## Based on\n'
+        '- [https://github.com/jaywalnut310/vits](https://github.com/jaywalnut310/vits)\n\n'
+        '## Dataset\n'
+        '- [http://shh.dict.cn/](http://shh.dict.cn/)\n\n'
+        '## Lexicon\n'
+        '- [https://www.wugniu.com/](https://www.wugniu.com/)\n\n'
+        '- [https://github.com/MaigoAkisame/MCPDict](https://github.com/MaigoAkisame/MCPDict)\n\n'
+        '- [https://github.com/edward-martyr/rime-yahwe_zaonhe](https://github.com/edward-martyr/rime-yahwe_zaonhe)')
+
+    app.launch()

attentions.py

@@ -0,0 +1,300 @@
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+from modules import LayerNorm
+   
+
+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 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

commons.py

@@ -0,0 +1,97 @@
+import math
+import torch
+from torch.nn import functional as F
+import torch.jit
+
+
+def script_method(fn, _rcb=None):
+  return fn
+
+
+def script(obj, optimize=True, _frames_up=0, _rcb=None):
+  return obj
+
+
+torch.jit.script_method = script_method
+torch.jit.script = script
+
+
+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 intersperse(lst, item):
+  result = [item] * (len(lst) * 2 + 1)
+  result[1::2] = lst
+  return result
+
+
+def slice_segments(x, ids_str, segment_size=4):
+  ret = torch.zeros_like(x[:, :, :segment_size])
+  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 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 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

lexicon/zaonhe.json

@@ -0,0 +1,19 @@
+{
+  "name": "Shanghainese to IPA",
+  "segmentation": {
+    "type": "mmseg",
+    "dict": {
+      "type": "ocd2",
+      "file": "zaonhe.ocd2"
+    }
+  },
+  "conversion_chain": [{
+    "dict": {
+      "type": "group",
+      "dicts": [{
+        "type": "ocd2",
+        "file": "zaonhe.ocd2"
+      }] 
+    }
+  }]
+}

mel_processing.py

@@ -0,0 +1,101 @@
+import torch
+import torch.utils.data
+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):
+    if torch.min(y) < -1.:
+        print('min value is ', torch.min(y))
+    if torch.max(y) > 1.:
+        print('max value is ', torch.max(y))
+
+    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, return_complex=False)
+
+    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):
+    if torch.min(y) < -1.:
+        print('min value is ', torch.min(y))
+    if torch.max(y) > 1.:
+        print('max value is ', torch.max(y))
+
+    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

model/config.json

@@ -0,0 +1,35 @@
+{
+  "train": {
+    "segment_size": 8192
+  },
+  "data": {
+    "text_cleaners":["shanghainese_cleaners"],
+    "max_wav_value": 32768.0,
+    "sampling_rate": 22050,
+    "filter_length": 1024,
+    "hop_length": 256,
+    "win_length": 1024,
+    "add_blank": true,
+    "n_speakers": 2
+  },
+  "model": {
+    "inter_channels": 192,
+    "hidden_channels": 192,
+    "filter_channels": 768,
+    "n_heads": 2,
+    "n_layers": 6,
+    "kernel_size": 3,
+    "p_dropout": 0.1,
+    "resblock": "1",
+    "resblock_kernel_sizes": [3,7,11],
+    "resblock_dilation_sizes": [[1,3,5], [1,3,5], [1,3,5]],
+    "upsample_rates": [8,8,2,2],
+    "upsample_initial_channel": 512,
+    "upsample_kernel_sizes": [16,16,4,4],
+    "n_layers_q": 3,
+    "use_spectral_norm": false,
+    "gin_channels": 256
+  },
+  "speakers": ["1", "2"],
+  "symbols": ["_", ",", ".", "!", "?", "\u2026", "a", "b", "d", "f", "g", "h", "i", "k", "l", "m", "n", "o", "p", "s", "t", "u", "v", "y", "z", "\u00f8", "\u014b", "\u0235", "\u0251", "\u0254", "\u0255", "\u0259", "\u0264", "\u0266", "\u026a", "\u027f", "\u0291", "\u0294", "\u02b0", "\u0303", "\u0329", "\u1d00", "\u1d07", "1", "5", "6", "7", "8", " "]
+}

model/model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:604cd5249f7dadb29343b49e4c34fdc8d8559f3b090e2d11fce655f03f14e4d1
+size 158882637

models.py

@@ -0,0 +1,535 @@
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+import commons
+import modules
+import attentions
+import monotonic_align
+
+from torch.nn import Conv1d, ConvTranspose1d, Conv2d
+from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
+from commons import init_weights, get_padding
+
+
+class StochasticDurationPredictor(nn.Module):
+  def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
+    super().__init__()
+    filter_channels = in_channels # it needs to be removed from future version.
+    self.in_channels = in_channels
+    self.filter_channels = filter_channels
+    self.kernel_size = kernel_size
+    self.p_dropout = p_dropout
+    self.n_flows = n_flows
+    self.gin_channels = gin_channels
+
+    self.log_flow = modules.Log()
+    self.flows = nn.ModuleList()
+    self.flows.append(modules.ElementwiseAffine(2))
+    for i in range(n_flows):
+      self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
+      self.flows.append(modules.Flip())
+
+    self.post_pre = nn.Conv1d(1, filter_channels, 1)
+    self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
+    self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
+    self.post_flows = nn.ModuleList()
+    self.post_flows.append(modules.ElementwiseAffine(2))
+    for i in range(4):
+      self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
+      self.post_flows.append(modules.Flip())
+
+    self.pre = nn.Conv1d(in_channels, filter_channels, 1)
+    self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
+    self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
+    if gin_channels != 0:
+      self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
+
+  def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
+    x = torch.detach(x)
+    x = self.pre(x)
+    if g is not None:
+      g = torch.detach(g)
+      x = x + self.cond(g)
+    x = self.convs(x, x_mask)
+    x = self.proj(x) * x_mask
+
+    if not reverse:
+      flows = self.flows
+      assert w is not None
+
+      logdet_tot_q = 0 
+      h_w = self.post_pre(w)
+      h_w = self.post_convs(h_w, x_mask)
+      h_w = self.post_proj(h_w) * x_mask
+      e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
+      z_q = e_q
+      for flow in self.post_flows:
+        z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
+        logdet_tot_q += logdet_q
+      z_u, z1 = torch.split(z_q, [1, 1], 1) 
+      u = torch.sigmoid(z_u) * x_mask
+      z0 = (w - u) * x_mask
+      logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
+      logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
+
+      logdet_tot = 0
+      z0, logdet = self.log_flow(z0, x_mask)
+      logdet_tot += logdet
+      z = torch.cat([z0, z1], 1)
+      for flow in flows:
+        z, logdet = flow(z, x_mask, g=x, reverse=reverse)
+        logdet_tot = logdet_tot + logdet
+      nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
+      return nll + logq # [b]
+    else:
+      flows = list(reversed(self.flows))
+      flows = flows[:-2] + [flows[-1]] # remove a useless vflow
+      z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
+      for flow in flows:
+        z = flow(z, x_mask, g=x, reverse=reverse)
+      z0, z1 = torch.split(z, [1, 1], 1)
+      logw = z0
+      return logw
+
+
+class DurationPredictor(nn.Module):
+  def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_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.gin_channels = gin_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.proj = nn.Conv1d(filter_channels, 1, 1)
+
+    if gin_channels != 0:
+      self.cond = nn.Conv1d(gin_channels, in_channels, 1)
+
+  def forward(self, x, x_mask, g=None):
+    x = torch.detach(x)
+    if g is not None:
+      g = torch.detach(g)
+      x = x + self.cond(g)
+    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.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
+    
+    if self.n_vocab!=0:
+      self.emb = nn.Embedding(n_vocab, hidden_channels)
+      nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
+
+    self.encoder = attentions.Encoder(
+      hidden_channels,
+      filter_channels,
+      n_heads,
+      n_layers,
+      kernel_size,
+      p_dropout)
+    self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
+
+  def forward(self, x, x_lengths):
+    if self.n_vocab!=0:
+      x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
+    x = torch.transpose(x, 1, -1) # [b, h, t]
+    x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
+
+    x = self.encoder(x * x_mask, x_mask)
+    stats = self.proj(x) * x_mask
+
+    m, logs = torch.split(stats, self.out_channels, dim=1)
+    return x, m, logs, x_mask
+
+
+class ResidualCouplingBlock(nn.Module):
+  def __init__(self,
+      channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      n_flows=4,
+      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(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
+      self.flows.append(modules.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 PosteriorEncoder(nn.Module):
+  def __init__(self,
+      in_channels,
+      out_channels,
+      hidden_channels,
+      kernel_size,
+      dilation_rate,
+      n_layers,
+      gin_channels=0):
+    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.gin_channels = gin_channels
+
+    self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
+    self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
+    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
+    m, logs = torch.split(stats, self.out_channels, dim=1)
+    z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
+    return z, m, logs, x_mask
+
+
+class Generator(torch.nn.Module):
+    def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_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)
+        resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
+
+        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 gin_channels != 0:
+            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
+
+    def forward(self, x, g=None):
+        x = self.conv_pre(x)
+        if g is not None:
+          x = x + self.cond(g)
+
+        for i in range(self.num_upsamples):
+            x = F.leaky_relu(x, modules.LRELU_SLOPE)
+            x = self.ups[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 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 MultiPeriodDiscriminator(torch.nn.Module):
+    def __init__(self, use_spectral_norm=False):
+        super(MultiPeriodDiscriminator, 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)
+
+    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)
+
+        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
+
+
+
+class SynthesizerTrn(nn.Module):
+  """
+  Synthesizer for Training
+  """
+
+  def __init__(self, 
+    n_vocab,
+    spec_channels,
+    segment_size,
+    inter_channels,
+    hidden_channels,
+    filter_channels,
+    n_heads,
+    n_layers,
+    kernel_size,
+    p_dropout,
+    resblock, 
+    resblock_kernel_sizes, 
+    resblock_dilation_sizes, 
+    upsample_rates, 
+    upsample_initial_channel, 
+    upsample_kernel_sizes,
+    n_speakers=0,
+    gin_channels=0,
+    use_sdp=True,
+    **kwargs):
+
+    super().__init__()
+    self.n_vocab = n_vocab
+    self.spec_channels = spec_channels
+    self.inter_channels = inter_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.resblock = resblock
+    self.resblock_kernel_sizes = resblock_kernel_sizes
+    self.resblock_dilation_sizes = resblock_dilation_sizes
+    self.upsample_rates = upsample_rates
+    self.upsample_initial_channel = upsample_initial_channel
+    self.upsample_kernel_sizes = upsample_kernel_sizes
+    self.segment_size = segment_size
+    self.n_speakers = n_speakers
+    self.gin_channels = gin_channels
+
+    self.use_sdp = use_sdp
+
+    self.enc_p = TextEncoder(n_vocab,
+        inter_channels,
+        hidden_channels,
+        filter_channels,
+        n_heads,
+        n_layers,
+        kernel_size,
+        p_dropout)
+    self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
+    self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
+    self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
+
+    if use_sdp:
+      self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
+    else:
+      self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
+
+    if n_speakers > 1:
+      self.emb_g = nn.Embedding(n_speakers, gin_channels)
+
+  def forward(self, x, x_lengths, y, y_lengths, sid=None):
+
+    x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
+    if self.n_speakers > 0:
+      g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
+    else:
+      g = None
+
+    z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
+    z_p = self.flow(z, y_mask, g=g)
+
+    with torch.no_grad():
+      # negative cross-entropy
+      s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
+      neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
+      neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2), s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
+      neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
+      neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
+      neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
+
+      attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
+      attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
+
+    w = attn.sum(2)
+    if self.use_sdp:
+      l_length = self.dp(x, x_mask, w, g=g)
+      l_length = l_length / torch.sum(x_mask)
+    else:
+      logw_ = torch.log(w + 1e-6) * x_mask
+      logw = self.dp(x, x_mask, g=g)
+      l_length = torch.sum((logw - logw_)**2, [1,2]) / torch.sum(x_mask) # for averaging 
+
+    # expand prior
+    m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
+    logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
+
+    z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
+    o = self.dec(z_slice, g=g)
+    return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
+
+  def infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None):
+    x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
+    if self.n_speakers > 0:
+      g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
+    else:
+      g = None
+
+    if self.use_sdp:
+      logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w)
+    else:
+      logw = self.dp(x, x_mask, g=g)
+    w = torch.exp(logw) * x_mask * length_scale
+    w_ceil = torch.ceil(w)
+    y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
+    y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
+    attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
+    attn = commons.generate_path(w_ceil, attn_mask)
+
+    m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
+    logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
+
+    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)
+    o = self.dec((z * y_mask)[:,:,:max_len], g=g)
+    return o, attn, y_mask, (z, z_p, m_p, logs_p)
+
+  def voice_conversion(self, y, y_lengths, sid_src, sid_tgt):
+    assert self.n_speakers > 0, "n_speakers have to be larger than 0."
+    g_src = self.emb_g(sid_src).unsqueeze(-1)
+    g_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
+    z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src)
+    z_p = self.flow(z, y_mask, g=g_src)
+    z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
+    o_hat = self.dec(z_hat * y_mask, g=g_tgt)
+    return o_hat, y_mask, (z, z_p, z_hat)
+

modules.py

@@ -0,0 +1,387 @@
+import math
+import torch
+from torch import nn
+from torch.nn import functional as F
+
+from torch.nn import Conv1d
+from torch.nn.utils import weight_norm, remove_weight_norm
+
+import commons
+from commons import init_weights, get_padding
+from 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, gin_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.gin_channels = gin_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 gin_channels != 0:
+      cond_layer = torch.nn.Conv1d(gin_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.gin_channels != 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,
+      gin_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, gin_channels=gin_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 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

monotonic_align/__init__.py

@@ -0,0 +1,19 @@
+from numpy import zeros, int32, float32
+from torch import from_numpy
+
+from .core import maximum_path_jit
+
+def maximum_path(neg_cent, mask):
+  """ numba optimized version.
+  neg_cent: [b, t_t, t_s]
+  mask: [b, t_t, t_s]
+  """
+  device = neg_cent.device
+  dtype = neg_cent.dtype
+  neg_cent = neg_cent.data.cpu().numpy().astype(float32)
+  path = zeros(neg_cent.shape, dtype=int32)
+
+  t_t_max = mask.sum(1)[:, 0].data.cpu().numpy().astype(int32)
+  t_s_max = mask.sum(2)[:, 0].data.cpu().numpy().astype(int32)
+  maximum_path_jit(path, neg_cent, t_t_max, t_s_max)
+  return from_numpy(path).to(device=device, dtype=dtype)

monotonic_align/core.py

@@ -0,0 +1,35 @@
+import numba
+
+
+@numba.jit(numba.void(numba.int32[:,:,::1], numba.float32[:,:,::1], numba.int32[::1], numba.int32[::1]), nopython=True, nogil=True)
+def maximum_path_jit(paths, values, t_ys, t_xs):
+  b = paths.shape[0]
+  max_neg_val=-1e9
+  for i in range(int(b)):
+    path = paths[i]
+    value = values[i]
+    t_y = t_ys[i]
+    t_x = t_xs[i]
+
+    v_prev = v_cur = 0.0
+    index = t_x - 1
+
+    for y in range(t_y):
+      for x in range(max(0, t_x + y - t_y), min(t_x, y + 1)):
+        if x == y:
+          v_cur = max_neg_val
+        else:
+          v_cur = value[y-1, x]
+        if x == 0:
+          if y == 0:
+            v_prev = 0.
+          else:
+            v_prev = max_neg_val
+        else:
+          v_prev = value[y-1, x-1]
+        value[y, x] += max(v_prev, v_cur)
+
+    for y in range(t_y - 1, -1, -1):
+      path[y, index] = 1
+      if index != 0 and (index == y or value[y-1, index] < value[y-1, index-1]):
+        index = index - 1

requirements.txt

@@ -0,0 +1,10 @@
+librosa
+matplotlib
+numpy
+scipy
+tensorboard
+torch
+torchvision
+cn2an
+opencc
+

shanghainese_script.txt

@@ -0,0 +1,2051 @@
+侬是公派出去，还是因私出国？
+侬要交几张照片，填好几张表格，办好签证。
+签证到现在还呒没拿到，我真是急煞快！
+请侬拿护照出示拨我看看，还有入境表格填好了𠲎？
+侬辣上海要蹲多少辰光？
+侬准备从啥个地方出境？
+侬有啥个物事需要向海关申报𠲎？
+请侬从箇𡍲走，埃面是检查台，检查行李个地方。
+亲爱的，阿拉结婚好𠲎？
+我同意，侬看啥辰光结婚啊？
+阿拉选只好日节。
+结婚是一生当中个大事体。
+我想办了体面一眼。
+办中式个。
+摆老多桌，闹忙眼。
+要末西式个？
+拖地婚纱，辣辣教堂结婚。
+要末旅行结婚？
+到国外去度蜜月，过两人世界。
+我没办法决定。
+问问看爷娘帮亲眷个意见。
+阿拉马上去寻伊拉。
+阿拉两个人真个老配个。
+新婚夫妻。
+结婚以后，㑚要小人𠲎？
+要个，阿拉想要一个小人。
+欢喜男囡头还是女小人啊？
+男女侪一样个。
+葛末㑚要多补补营养。
+保持健康是最关键个事体。
+今朝天气哪能？
+天气预报讲今朝是好天气。
+温度哪能？
+勿冷也勿热。
+是阳光明媚个春天。
+前两天刮大风，天气真冷。
+上海冬天冷风飕飕个。
+会得落雪𠲎？
+难般会得落雪。
+今年就落了一场大雪。
+上海个春天，天气晴朗。
+一天比一天暖热。
+气温升得老快个。
+零上10度。
+勿过天气变化老大个。
+明朝会得哪能？
+听听今朝个天气预报好了。
+3月16号，阴，有小雨。
+会得落雨𠲎。
+晚春个辰光经常要落雨个。
+春天风也老大个。
+有辰光会得刮四五级大风。
+夏天呢？
+天气老热个。
+夏天个平均温度是28度左右。
+勿过最热个辰光气温要到39度左右了。
+箇𡍲天气老热个。
+太阳辣花花个。
+热得要死。
+勿过夏天一过，就到上海最好个季节。
+秋天，天气老好个。
+温度老适宜个。
+天老高，老蓝个。
+微风吹吹，秋高气爽。
+勿冷勿热。
+真是忒适宜了。
+秋天是成熟个季节。
+秋天是丰收个季节。
+秋天交关多姿多彩。
+到处侪老漂亮个。
+我认为秋天是上海最好看个季节。
+我欢喜上海个秋天。
+我老好个，侬呢？
+我也老好个。
+侬最近哪能？
+侪好𠲎？
+侪蛮好，谢谢侬。
+屋里向人好𠲎？
+脱平常一样个。
+有啥好事体𠲎？
+没啥特别个。
+㑚爸爸姆妈呢，伊拉好𠲎？
+伊拉蛮好，老好个！
+小人好𠲎？
+一般，勿是老好。
+现在辣海准备高考。
+代我帮㑚屋里向问好。
+最近工作哪能？
+工作老忙个，还要自学英文
+侬呢，过了好𠲎？
+勿错，一切顺利。
+侬身体哪能？
+我老好个！
+现在是几月份？
+现在是三月份。
+今朝是几月几号？
+今朝是三月10号。
+马上就要三月15号了。
+“3.15”是消费者权益日。
+下个号头是几月？
+下个月是四月。
+今朝夜快头请侬帮我拿箇眼DVD碟片带回去。
+侬到厨房间里一把榔头脱我拿来。
+箇两封信侬帮我寄脱好𠲎？
+请侬来帮我看看，抽水马桶坏脱了𠲎？
+我索性帮侬拿应用软件统统调脱伊。
+灯开勿亮了，侬帮我来看看好𠲎？
+辣末一趟请侬唻，侬要脱我顶真眼做做好！
+我谢谢侬帮帮忙，脱我灯关关脱，我想睏觉了。
+侬窗门开开，拿空调关脱伊！
+要是还有别个事体要我帮忙，就打电话拨我。
+早，吃早饭了。
+我勿吃，我到单位食堂去吃。
+侬早饭吃过𠲎？
+还没吃。
+侬欢喜吃啥？
+我欢喜吃面包，喝牛奶。
+吃得饱𠲎？
+可以个，我早饭吃了勿多个。
+我吃了老多个。
+我要吃一碗豆浆，一根油条，一只荷包蛋。
+我已经饿了
+中饭阿拉吃中餐还是西餐？
+阿拉就吃眼快餐好了。
+葛末阿拉就去吃“肯德基”。
+请拨我两只汉堡。
+请拨我一杯热咖啡。
+我要一份冰激凌。
+我买几张邮票。
+我想寄封挂号信。
+箇封信超重了。
+地址填清爽。
+请侬填好邮政编码。
+寄到北京要多少辰光？
+大概一个礼拜。
+现在个商店，越造越大。
+上海个正大广场老大个。
+礼拜天阿拉去兜兜。
+可以买点物事。
+侬想买啥？
+侬穿啥尺寸个？
+侬欢喜啥颜色个？
+箇件衣裳侬穿了老好看个。
+我勿欢喜箇只颜色。
+我要件黑颜色个。
+侬穿了试试看。
+我帮女朋友买件衣裳。
+今年最流行箇种样子帮颜色了。
+穿上去老时髦，老好看个。
+试衣间辣辣阿里𡍲？
+我就要箇件了。
+侬想买鞋子𠲎？
+阿拉店里有老多名牌皮鞋。
+侬穿啥尺寸个鞋子？
+箇双鞋子是名牌。
+我可以试试看𠲎？
+箇鞋子太紧了。
+侬看箇双鞋子来三𠲎？
+42码个，就要箇双。
+今朝夜里侬想吃点啥？
+阿拉去吃南翔小笼包。
+我觉得忒油腻了，勿想吃。
+阿拉去吃眼清淡个菜好了。
+���末阿拉去吃新素代。
+㑚几位？
+阿拉五个人。
+今朝有点啥个特色菜？
+拨㑚份菜单看看。
+㑚要吃点啥老酒？
+阿拉勿吃酒个。
+来份三鲜汤。
+主食吃啥？
+阿拉要三碗饭。
+还要别个𠲎？
+我想拿眼钞票。
+请到自动取款机。
+勿来三，我还要调点零钞票。
+请输密码。
+侬要拿多少钞票。
+我拿500块整个。
+还有，10块头5张，5块头10张。
+嗨！差头。
+侬到阿里𡍲？
+我去机场。
+请上车，拿行李摆辣后备箱。
+从箇𡍲到机场有多少公里？
+大概40公里。
+车费多少？
+每公里人民币2块4角，计价器会得打发票个。
+路浪向堵车𠲎？
+会得堵个，勿过50分钟可以到机场了。
+拨侬100块。
+明朝是我个生日。
+我想请侬参加我个生日聚会。
+侬来好𠲎？
+我非常高兴接受侬个邀请。
+长远勿见，侬最近好𠲎？
+我蛮好个，侬乃，刚刚从乡下头回来啊？
+是个，我也蛮好。
+哪能侬现在上海言话讲了介好？
+是𠲎，我之前一段辰光一直辣辣网浪向学上海言话。
+网浪向也好学上海言话啊？
+是个，我也是听朋友介绍个。
+是啥网站？
+是海词网。我天天到伊拉上海言话词典学习，可以在线查单词，听录音，学对话。
+原来侬有介好个工具帮忙。网址是多少？
+网址是dict.cn
+侬要喝啥饮料？
+我要一杯奶茶。
+侬欢喜吃点啥？
+侬可以拨我一眼奶油五香豆。
+侬欢喜阿里一块？箇块还是埃块？
+没关系，随便阿里一块。
+还要多少？
+还要一眼眼。
+阿里一只侬欢喜一眼？
+我一只也勿要。
+我要搬场快了。
+我买了徐家汇附近个高层。
+侬搬个真是好地段，现在大家是吃地段吃房型个。
+我搬辣十八楼，大房间帮大厅侪朝南。
+侬个房子得房率高勿高？面积大勿大？
+三房两厅两卫，建筑面积一百三十六个平方。
+勿要忒赞噢！是毛坯房还是装修房？
+毛坯房！现在辣辣请人装修。
+埃面𡍲个物业管理好勿好？管理费贵𠲎？
+马马虎虎，侪一般性。
+侬房子钞票一次性侪付脱了𠲎？
+我只付了首期房款，其他个侪贷款。
+麻烦侬了。
+乃弄得侬今朝吃力煞了！
+勿搭界个！
+侬还有啥个事体要我帮忙𠲎？
+没啥了。
+我老勿好意思。
+谢谢侬！
+谢啥！勿要谢，我没关系个。
+听讲侬辞职了，为啥？
+公司勿履行协议。
+面试个辰光刚好起薪三千块个。
+三个号头以后，工资四千块。
+工作多少辰光了？
+已经六个号头了
+寻老板谈过𠲎？
+谈过了，伊老是讲等等、等等。
+我认为公司违约了。
+我就辞职了。
+小姐，侬买化妆品𠲎？
+我想买瓶香水。
+箇是法国最好个香水。
+味道老温馨个。
+我再看看别个品牌。
+阿拉有老多品牌拨侬选择。
+我要报考㑚个职业培训班，啥辰光考试？
+请侬拿箇张表格填好，考试就辣箇个号头十廿号。
+假使考取了，要学几个号头？
+要学三个号头，全部用业余辰光。
+啥个内容要考？参考书有𠲎？
+侬看箇张表好唻，高头已经写清爽了。
+侬今朝下半天有辰光𠲎？
+我想请侬去参观科技馆。
+勿好意思，我今朝下半天没辰光。
+侬明朝有空𠲎？
+箇周末有空𠲎？
+我想到侬屋里看侬。
+大概勿来三。
+别个辰光来三𠲎？
+今朝夜里我有空。
+好个，今朝夜到阿拉一道去看电影。
+去个辰光叫黄丽一道。
+阿拉辣海阿里𡍲碰头？
+侬啥辰光方便？
+下半天5点钟哪能？
+电影院，勿见勿散。
+黄丽，我想到侬屋里看看叫。
+请带侬先生一道来白相好了。
+阿拉屋里向个人侪欢迎侬。
+张阿姨，是我来了。
+请进来！
+来，来，坐啊，请坐。
+没啥好招待侬个。
+侬要吃咖啡还是要吃茶啊？
+阿姨勿要客气，倒杯白开水吃吃好了。
+今朝侬上门来，有眼啥事体啊？
+我有眼小事体想请侬帮忙。
+侬是啥辰光来个？
+我是去年七月份来个。
+马上要一年了。
+侬是2006年毕业个𠲎？
+勿是个，我是2004年毕业个。
+侬已经工作5年了。
+是个，快6年了。
+箇几年我一直努力工作。
+喂，小李是𠲎？
+勿是，侬是啥人？
+我是刘刚。
+能帮我叫声小李𠲎？
+侬等等，伊好像出去了。
+等伊回来让伊打电话拨我。
+伊晓得侬电话号头𠲎？
+侬留留侬个姓名脱电话。
+我个手机号头是12345678901。
+好个，我记下来了。
+过30分钟让伊回电话拨侬。
+轮到我了，是𠲎？
+侬坐下来，有啥勿适意？
+心口头有眼痛咾，饭吃勿落。
+也是箇𡍲痛？箇个是胃痛。
+痛了几日了？侬老早胃病有𠲎？
+痛是痛过歇个，呒没现在介厉害。
+胃口哪能？想勿想吐？
+有眼恶心，但是吐勿出来。
+勿放心末，侬去做只胃镜查一查。
+箇眼药一天吃三次。
+饭后药水吃瓶盖头一盖头，药���吃一粒。
+乃下趟一定要防止着冷，吃饭勿要吃了过头。
+辣辣箇𡍲茶室里碰头，情调勿推扳。
+侬要吃啥茶？来壶柠檬红茶喝喝好𠲎？
+再弄眼瓜子、腰果、杏仁咾啥剥剥。
+王兄，侬现在辣辣跑啥生意了？
+箇两日工作我回头脱了，下个月有家独资公司聘我去。
+老兄有噱头个！勿像我死样怪气个单位里捂辣海。
+侬应该跳槽，我介绍侬到阿拉连襟个公司去做。
+侬个艺术细胞太丰富唻，做装潢设计完全来三。
+帮侬添麻烦了！
+朋友道里，我讲出了末，就帮忙帮到底。
+箇𡍲小区绿地面积有多少？
+占建筑总面积百分之几？
+公共设施有眼啥？
+譬如讲，小区健身房、儿童乐园、图书馆咾侪有。
+小区旁边进出方便𠲎？
+譬如讲，我要到市中心，有啥车子好乘出去𠲎？
+箇𡍲要调地铁脱轻轨便当𠲎？
+我假使要上高架，阿里个路口离箇𡍲最近？
+箇𡍲周围有勿有小菜场跟大型超市，生活用品买？
+朝南窗口前头还会得造高楼，𢴳牢阳光帮视线𠲎？
+周围环境哪能介？静勿静？夜里向吵勿吵？
+小区安全𠲎？夜里向有照明设施𠲎？
+对勿起，现在啥辰光了？
+十点缺十五分。
+㑚约好来啥辰光碰头个？
+还有半个钟头，辰光老充裕个。
+我中浪向十二点半还要到浦东去。
+夜饭还没好，要到六点半。
+我辣一个钟头以前就吃了中饭。
+明朝侬九点钟要到箇𡍲来。
+伊辣埃面𡍲住了多少辰光了？
+我等了侬老多辰光了。
+杨雪，可以约侬出去𠲎？
+我老欢喜陪侬个。
+侬长了老帅个。
+侬也老吸引人个。
+登山介吃力个。
+侬爬勿动，我可以背侬个呀。
+侬别有用心。
+杨雪，我爱侬。
+嫁拨我好𠲎。
+勿来三个，因为我要嫁拨有钞票人个。
+侬想寻“大款”啊？
+小张，侬是阿里一年养个？
+一九八二年养个。
+侬生日几月几号？
+十月十八号。侬啥辰光生个？
+我小侬四个号头。
+今朝是啥日脚？
+今朝七月廿五号。
+今朝礼拜几？
+明朝正好礼拜天。
+我医院里住了几个礼拜。
+侬回到家乡去住几天日脚？
+上个号头是九月份𠲎？
+箇个号头是几月份？
+去年八月份侬辣阿里𡍲？
+侬是来面试个，是𠲎？
+是个，我听讲㑚公司需要一个管理人。
+侬做过箇种工作𠲎？
+老早没。
+侬阿里只大学毕业个？
+我复旦大学毕业个。
+侬学啥专业个？
+企业管理。
+请侬刚刚侬准备将来哪能工作。
+侬会得用电脑𠲎？
+侬会得用复印机𠲎？
+侬还有啥特长？
+箇是我个简历。
+侬要求个工资多少？
+公司决定好了。
+阿拉有得试用期个。
+试用期多少辰光？
+三个号头。
+我啥辰光可以上班？
+阿拉会得通知侬个。
+喂，侬好，我想寻刘先生。
+请问侬是阿里位？
+请侬讲响眼。
+我听勿清爽侬讲言话。
+我寻刘刚。
+侬好像打错脱电话了。
+勿好意思，请帮我转过去来三𠲎？
+我寻刘刚有急事体。
+我欢喜侬。
+侬有文化，大方，漂亮。
+老可爱个。
+是𠲎？我也欢喜侬。
+勿过我勿好帮侬谈朋友。
+因为我有男朋友了。
+阿拉两个人感情老好个。
+阿拉谈了快三年了。
+箇是伊送拨我个订婚礼物。
+我帮侬介绍个女朋友好来。
+好个，侬可以当媒人了。
+杨雪对侬有意思。
+伊大概看中侬了。
+侬可以跟伊表白一下。
+侬今朝哪能没上班？
+我被伊拉辞退了。
+啊，侬为啥被辞退？
+我今朝帮老板发火了。
+侬跟老板吵相骂啦？
+是个，我恨伊。
+侬箇是自作自受。
+去帮老板道歉。
+勿去，伊勿讲道理。
+老板对阿拉老凶个。
+我晓得侬会来个！
+我勿来末啥人来啊？
+侬真介好啊？
+我对别人侪勿好，因为侬发调头叫我来讲讲言话。
+葛末侬频道隔脱伊好唻。
+我单飞日脚过得厌脱唻！
+我倒觉着蛮好个。
+我会得后悔一辈子𠲎？
+勿谈了！阿拉到周庄去白相好𠲎？
+伊拉两家头个爱情，已经升了一个台阶。
+侬除脱箇只专业之外，还有啥特别个爱好𠲎？
+休息日脚侬看电视以外，还欢喜啥地方去转转？
+拍照，只勿过是我一项业余爱好。
+箇套钱币要弄到邪气难个，侬用了多少长个辰光弄到啊？
+我觉得集邮是一种有益个休闲。
+我勿欢喜跑出去白相，常庄辣辣屋里向泡壶咖啡。
+伊好像对音乐剧咾啥老感兴趣个，而且还邪气懂经。
+我还常庄看上海滑稽，或者一家门围牢仔电视机。
+搓麻将我难板来来，因为一上年头起来辰光侪搭脱。
+我一操机就没底个，游戏打打，动画片看看。
+侬哪能一有空就上网，冲浪灌水打QQ，一个夜头侪勿停个？
+侬有侬个爱好，我有我个兴趣，关侬啥事体！
+现在到处有“超市”，一记头可以买交关物事。
+勿过上海还有勿少小摊��，买物事可以讨价还价。
+哎，箇眼橘子几钿一斤啊？
+写辣海十块五斤，我可以卖拨侬十元六斤。
+我多买眼，好再𠼢一眼𠲎？
+侬看下头两只介小个。
+我是统货，侬要拣末，就只好十元五斤。
+好了好了！就十元五斤𠲎。
+侬只秤有问题𠲎？
+阿拉天天辣箇𡍲做生意，勿会叫侬吃亏个！
+葛末再加我两只！
+好个，侬拿去好了。
+先生小姐，㑚要买点啥个首饰？
+让阿拉先看看再讲。
+现在铂金首饰邪气热闹。
+小姐已经有一只戒指，要勿要配条铂金项链？
+好个。㑚𡍲有几种款式，拨我看看叫。
+侬看我箇𡍲一排生有十二条，侪老灵个。
+还有埃面柜台里向也有交关。
+我看箇条蛮大方个。
+先生眼光真好，阿要试试戴戴看？
+侬看，瞎嗲！
+我觉着价细忒贵，再讲没啥特别好看……
+要末阿拉到别个地方再去看看。
+我想寄只特快专递。
+寄个是啥？
+一本英汉字典。
+邮费多少钞票？
+先让我称称重量。
+邮费一共40块。
+要贴邮票𠲎？
+勿需要个，现在用电脑打印个邮费已付。
+我个手机呒没脱了，哪能办？
+侬想想清爽，大概辣啥辰光啥地方落脱个？
+我吃中饭个辰光还打过两只电话，所以箇个辰光还辣个。
+葛侬下半天到过几个地方？
+喔，想起来了，忘记辣填报名单个台子高头。
+乃已经收场了，勿晓得还寻得着勿啦？
+豪𢜶中饭到埃面去打听，快走！
+唷，电话铃响了，“喂，啥人啊？……噢，谢谢侬！”
+我手机寻到了，人家打电话来叫我去领了！
+我有两张汏浴票子辣海，今朝告我一道去汏浴去𠲎？
+汏啥个浴？桑拿我是怕闷煞脱个，要末就大汤泡。
+侬箇个人真是戆噱噱，汏汏浴，松松筋骨，有益血脉流通。
+勿过现在家家屋里侪有得浴缸，汏汏浴勿是蛮便当个？
+两样个，浴池里汏浴末，人泡得来煞根！
+朋友道里，大家谈谈心，老爽个。
+侬看人家，做按摩咾，足浴咾，瘦身咾，赶时尚。
+侬箇个人真是阿木林一只，介拎勿清！
+休闲要休了扎劲，休出情调品位高水平。
+我勿好新天地去去，星巴克坐坐，跑跑襄阳路啊。
+今朝老勿好意思个，叫侬等了介许多辰光。
+勿要客气，我没关系个。
+箇个是杰克先生。
+伊是我个朋友。㑚认得𠲎？
+阿拉勿认得。
+我来帮㑚介绍一下。
+请问，箇位女士是啥人？
+伊叫珍妮。
+认得㑚，我老高兴个。
+大家轧朋友，下趟多多关照。
+医生，我箇两天老勿适宜个。
+侬咳嗽𠲎，流鼻涕𠲎？
+侬发寒热𠲎，阿里𡍲难过？
+量量体温。
+量量血压。
+侬得过肺炎𠲎？
+最好拍张x光片。
+侬发寒热了。
+要做进一步个检查。
+要做抽血化验。
+侬是病毒性感冒。
+严重𠲎？
+勿严重，我帮侬开眼药。
+回去要及时吃药。
+侬就会得老快好个。
+侬个毛病哪能了？
+我头老浑个。
+浑身没力气。
+没胃口，啥也勿想吃。
+让我检查检查。
+侬箇种情况有几天了？
+侬最好登了床浪向休息一两天。
+多吃眼新鲜个蔬菜帮水果
+希望侬早点康复。
+明朝是我女朋友个生日。
+我想买只娃娃送拨伊。
+葛末就买“芭菲宝宝”送拨伊。
+“芭菲宝宝”是智能娃娃，会得讲，会得笑，会得要吃个。
+吃力了还会得睏觉。
+有介好白相𠲎？
+有个，小姑娘侪欢喜个。
+帮伊买只手表好𠲎？
+箇是最流行个超概念表。
+勿过勿实用。
+请问，需要啥𠲎？
+我要买单。
+可以打折头𠲎？
+阿拉个商品侪是优惠价。
+可以便宜点𠲎？
+阿拉先买单好了。
+裙子，人民币119块，鞋子，人民币316块。
+一共人民币435块。
+箇忒贵了。
+能再便宜点𠲎？
+好个，再拨侬打只7折。
+打好7折是人民币304块5角。
+就算人民币304块好了。
+请到收银台付钞票。
+收银台辣辣阿里𡍲？
+侬付现金还是拉卡？
+我付现金。
+拨侬，箇是人民币304块。
+箇是我拨侬个钞票。
+箇是收据，收好。
+先生，请侬自我介绍一下，侬有啥个专长？
+我既有比较强个英文听力、口语、写作能力。
+侬为啥要到阿拉公司来应聘？
+因为㑚公司个业务能够发挥我个特长。
+侬认为自家可以做阿里方面个工作？
+我可以做中英双向翻译，参加脱外国人交际谈判。
+警察，我来报案。
+发生了啥事体？
+我个皮夹子落脱了。
+辣辣啥地方？
+辣辣上海火车站个售票大厅。
+侬哪能发觉个？
+我准备拿钞票买票。
+侬勿要急，勿要哭。
+再好叫寻寻看。
+我侪寻过了。
+葛末，请侬做只笔录。
+请侬拿刚刚个事体再讲一讲。
+我辣辣地下通道碰到抢劫。
+啥物事被抢脱了？
+我个背包。
+有多少人？
+一共两个人。
+伊拉有啥特征𠲎？
+侪是年纪轻个，大概23岁左右。
+中等��材，板刷头，偏胖。
+伊拉哪能抢侬个背包个。
+伊拉一前一后，拿我搿了当中。
+伊拉用啥凶器了𠲎？
+好像手浪向有刀。
+是啥样子个刀，有多少长？
+我当时辰光吓煞脱了。
+啥也勿记得了。
+侬包里有点啥物事？
+有皮夹子，有身份证，有手机。
+请拿侬个联系方式留下来。
+阿拉一旦破了案，就会得帮侬联系个。
+碰到紧急情况千万勿好慌张个。
+要保持冷静。
+早浪好，陈先生！
+是张先生啊，侬好！
+长远勿见，我老想念侬个！
+我也常常想来望望侬。
+今朝碰到侬我交关开心。
+侬箇抢身体好𠲎？
+身体蛮好。
+侬最近好𠲎？
+还好，勿大忙，侬呢？
+箇抢里我老忙个！
+我要走了，我是来帮侬再会个。
+我辣箇𡍲过了交关开心。
+箇几天麻烦侬了。
+侬好多住几天勿啦？
+我要回去了。
+我该跑了。
+我必须先走了。
+侬啥辰光走？
+明朝下半天两点半个飞机。
+我到机场去送侬。
+谢谢侬来送我。
+再会，祝侬一路平安。
+勿要忘记脱帮我打电话，介快就走了，老遗憾个。
+侬啥辰光再来？
+我也勿晓得。
+记得经常来看看我。
+我会得想侬个。
+我一定会得再来个。
+大家多联系。
+天晚了，我要回去了。
+有空经常来看看。
+再会，我一定会得再来个。
+检查检查，物事侪带齐了𠲎。
+我侪检查过了。
+帮我拿箇只芭比娃娃带拨侬个小人。
+希望伊欢喜箇只礼物。
+一路注意安全。
+祝侬旅途愉快。
+后会有期。
+欢迎侬再来，再会。
+喂，请问现在脱我马上送一叠稿子好𠲎？
+好个。侬住辣啥地方？
+我就住辣愚园路1136弄2号。
+阿拉派人半个钟头里向到侬个𡍲来拿。
+多少辰光好送到？
+侬要送到阿里𡍲？
+我要送到上海文艺出版社。
+请侬告诉我详细地址。
+今朝上半天就可以送到，快递费收10元洋钿。
+葛末我等辣海，侬马上来噢，再会！
+妈妈，今朝有朋友到屋里向来白相。
+好个，男小人还是小姑娘啊？
+是我女朋友。
+快点拿房间收作清爽。
+好个，我一定会得弄好个。
+叫㑚爸爸买点菜回来。
+小姐，我想买一件西装，样子好一眼个。
+箇𡍲一排侪是进口面料欧版个西装。
+箇种颜色比伊种稍为深一点。
+侬看箇两件做工要比伊面个考究。
+侬看侬穿稍为淡一点个颜色更加好。
+我比侬长一点点，比箇个尺码大一点个有𠲎？
+旁边一排衣裳跟箇𡍲个衣裳没啥两样。
+深藏青阿是及勿上黑颜色好看？
+箇𡍲个衬衫呒伊面个挺括。
+侬看埃面一件要好点𠲎？
+箇条领带颜色亮一点，跟箇件西装比较配。
+箇眼西装脱埃面个一样，全部打九折。
+介夜了，还乘啥公交车！叫差头𠲎。
+勿要等唻，我来拦一部差头。
+阿拉要到虹桥路延安西路。
+要勿要上高架走？
+随便哪能走，哪能快就哪能开！
+葛末就上高架走。
+喔唷，碰着堵车，急煞人了！
+就箇𡍲停车好唻。
+侬是拉卡还是付现金？
+发票拿好，物事勿要忘记辣车子高头。
+小黄，箇是啥人啊？
+箇是我朋友。
+认得侬老开心个。
+侬贵姓？
+我姓刘，叫刘玉
+侬叫啥名字啊？
+我叫张帆。
+帮侬介绍我个朋友，李明。
+还是我自家来介绍𠲎！
+我是上海个。
+现在辣海上海师范大学当老师。
+侬阿里𡍲个啊？
+侬是从广州来个𠲎？
+勿是，我是成都个。
+侬现在做啥个？
+我辣辣上海上大学。
+学习难𠲎？
+勿难，我学习老好个。
+祝侬学习取得更好个成绩。
+帮侬讲言话老开心个。
+126路公共汽车站头，到外滩去，辣啥地方？
+箇部车子到静安寺𠲎？
+到了常熟路，请侬叫一声我。
+我已经刷过卡了。
+我乘过头了，哪能办？
+箇部是区间车，到梅陇新村要乘另一部。
+下头一站是啥地方？
+“美丽园”到了𠲎？
+再乘两站。
+对勿起，让一让，我下车。
+今朝勿晓得放啥电影？
+阿拉去看电影好𠲎？
+勿晓得是国产片还是进口片。
+好像是恐怖片《午夜凶铃》。
+好个，肯定老有劲个。
+我老讨厌恐怖片个，忒紧张了。
+我还是辣辣屋里看看电视，上上网算了。
+电视没啥好节目看个。
+放介许多广告，烦煞脱了。
+我看体育频道，NBA篮球赛。
+我欢喜体育比赛。
+我坚持每个礼拜爬两趟山。
+我每天坚持晨练，夜里散步。
+侬最欢喜啥活动？
+我欢喜走象棋。
+也欢喜看看书，看看报。
+欢喜看人物传记。
+我个爱好老多个，游泳，打球。
+我欢喜丰富多彩个生活。
+小姐，今朝夜里有勿有空房间。
+有个，先生侬几位？
+两个，阿拉住标间好了，几钿一夜？
+箇𡍲是三星级宾馆，三百元一夜。
+阿拉要住三夜天。
+拨侬三楼三零五房间好𠲎？
+好个。房间里长途电话可以直拨𠲎？
+房间里只好拨市内，长途可以到总台来打。
+再问声，餐厅夜里几点钟开门？
+先生，请侬拿护照或者身份证让我登记一下。
+谢谢侬中山北路五十两号辣辣阿里𡍲？
+朝右转弯走到第二条弄堂就是了。
+请问到大世界去哪能走？
+侬一直里朝前头走，过了红绿灯就到了。
+葛末到了人民广场哪能介走法？
+此地是南京路、西藏路口。
+侬从箇𡍲过去到埃面，穿过第二条横马路就是。
+右转马路对面过去点就到了。
+哪能介远个？
+从箇𡍲到埃面老近个？
+埃面有只书报亭，箇面有爿超市，侬看得到𠲎？
+侬到箇𡍲转弯角子浪去乘地铁。
+先要乘44路两站，再转地铁一号线，可以到了。
+葛是路蛮远个，阿拉叫差头去算了。
+今朝夜到去广州个火车票还有𠲎？
+“直快”车票没了，“特快”还有。
+帮我定一张“特快”车票。
+侬要硬座还是卧铺。
+软卧还有𠲎？
+让我看一看，对勿起，只有硬卧票了。
+欢迎光临，小姐今朝头发要剪一剪还是烫一烫？
+箇𡍲烫发有游离子烫、负离子烫、直板烫、钢丝烫。
+用勿着，汏一汏、吹一吹就可以了。
+侬要干汏还是湿汏啊？
+干汏好了。
+轻一眼还是重一眼？
+现在正好，勿重也勿轻。
+头还痒兮兮𠲎？勿痒末，去冲脱伊好𠲎？
+挨下来，脱侬按摩要𠲎？
+阿拉还有得做面膜、修眉毛、蒸面、香熏、指压。
+假使小姐要个言话，好打个八折。
+谢谢，没辰光了，我只要捏捏背跟腰好了。
+好爬起来了。
+醒醒呀，已经6点10分了。
+侬勿是每天6点钟起来个吗。
+今朝哪能睏懒觉了啦。
+快点，快点爬起来。
+我老衰瘏个，昨日夜里睏勿着。
+侬还去上班𠲎。
+去个呀，我马上去。
+快点穿衣裳。
+今朝有眼冷，穿绒线衫。
+我还没揩面唻。
+快点去揩面，刷牙齿。
+侬要快点了。
+我还想化妆唻。
+侬早饭想吃啥？
+我到单位去吃。
+鞋带搏好。
+快走，慢交赶勿上班车了。
+快点，否则要迟到了。
+请问，宋明辣辣𠲎？
+伊勿辣辣，伊出去了。
+伊去阿里𡍲了？
+可能辣辣体育馆。
+阿拉去体育馆看叫。
+侬有啥爱好𠲎？
+我欢喜看书。
+寻伊做啥？
+请伊帮我补习英文。
+侬觉着哪能？
+好个，就得能定好了。
+还有别个事体𠲎？
+我好吃香烟𠲎？
+勿来三，绝对勿可以。
+我想打只电话，来三𠲎？
+没问题，侬打好了。
+个只手机蛮好个，好看看叫𠲎？
+当然可以，侬看好了。
+伊做个事体侬赞成个𠲎？
+我当然同意个。
+侬答应勿啦？
+勿答应，我从来没答应过。
+伊考GRE、TOEFL，侬晓得勿啦？
+我勿大清爽。
+海滩高头侬高兴去𠲎？
+侬阿是勿准备去？
+要我做保姆，我勿情愿去。
+我勿会反对伊去个。
+侬哪能动也勿动个？
+啥人睬伊！我睬也勿要睬伊！
+好个，我忒开心了。
+我被复旦大学录取了。
+侬看，箇是我个入学通知书。
+忒赞了。
+我兴奋得来一夜天没睏着。
+阿拉侪为侬开心。
+我今朝心情特别好。
+爸爸姆妈也老欣慰个。
+侬晓得戴敏考了哪能𠲎？
+听讲，伊成绩勿大好。
+伊心里老难过个。
+情绪低落。
+箇两天伊个面孔老难看个。
+伊自家失去信心了。
+老失望，老难过个。
+还勿晓得能勿能上大学了。
+忒遗憾了。
+叫伊勿要太伤心。
+更加勿要悲观。
+没人能理解伊现在个感受。
+请问侬贵姓？
+我姓李。
+大名叫啥？
+大名叫李超。
+伊啥人啊？
+伊是王晓明。
+伊啥地方人？
+我是上海人。
+伊啥地方来个？
+伊南京来个。
+请问侬辣辣阿里𡍲工作？
+喏，箇个是我个名片。
+侬到上海来了多少辰光了？
+我来了交关辰光了。
+侬上海言话讲得来𠲎？
+听是听得懂一眼眼，讲是讲勿来个。
+今朝我来请客。
+拣爿好吃点个饭店去吃。
+侬来点菜好唻。
+㑚箇𡍲啥个菜最有特色？
+阿拉有只烤乳鸽，吃起来嫩笃笃，香喷喷。
+叫只清蒸鲈鱼好呢，还是蚝油牛肉好？
+弄条活杀大王蛇吃吃好𠲎？
+来只腌笃鲜末好唻。
+我要吃本邦菜，栗子红烧肉，浓油赤酱个。
+蹄膀笃得酥一点，听到𠲎！
+蹄筋勿好炒了糊达达个噢！
+肉丝吃得来绝绝细，臭豆腐干煎得来喷喷香！
+箇只鸭子勿太酥。
+我来拿去再烧烧伊。
+稍为等一歇，马上就好了噢！
+点箇眼菜有得吃唻！
+饭勿要盛了拍拍满。
+买单！今朝我挺帐。
+勿要噢，劈硬柴好唻！
+请问去世纪公园哪能走？
+从箇𡍲乘花木1路公交车直接到世纪公园。
+公交车会得挤𠲎？
+上下班高峰个辰光比较挤。
+过马路请走人行横道线。
+过街天桥。
+过街通道。
+注意交通安全。
+阿姨，今朝竹笋老嫩个，称两斤去哪能？
+几钿一斤？
+四块五角一斤，𠼢得来！
+介��个，贵得一塌糊涂！贵了屋里向也勿认得了！
+帮帮忙噢，侬看看，我𡍲个竹笋是顶好个！
+真个啊？葛卖便宜一眼末好唻！
+勿来三个，我勿好做折本生意个！
+好好好。侬份量要称称足。
+一句言话！
+我刚刚晓得侬辣生毛病，葛咾下仔班来望望侬。
+我一点点小毛病，侬用勿着来看我个！
+侬一向身体好来死个，哪能辣末生头住医院了？
+是个呀，年纪大唻，今年四十两岁了。
+老早心脏从来没发现毛病，所以箇趟有眼措手勿及。
+乃下趟，对身体千万勿好大意，省得大家担心。
+箇趟进医院，再晓得身体健康最最要紧。
+乃要经常锻炼锻炼。我买了眼补药拨侬吃。
+先生，我想寻一份工作。
+侬想寻阿里方面个工作？
+做餐馆服务员啊、酒吧招待员啊，侪可以。
+侬普通话讲得来𠲎？
+当然会个，勿过上海言话讲大勿来。
+勿要紧个，当然最好还是买本会话书学学上海话。
+海词网要招一个编辑，侬有兴趣𠲎？
+好个呀，薪金多少？休息日有𠲎？
+每个号头两千元，每个礼拜休息两天，可以𠲎？
+请侬箇张表填一填，等阿拉个通知。
+今朝天气老好个。
+昨日是啥天气啊？
+昨日落了一天个雨。
+明朝天气会得好𠲎？
+明朝要落雪。
+一个上半天是阴天。
+下半天大概天转晴。
+箇抢天气老冷个，常常冷到零下两三度。
+上海热天最高温度要到三十八九度，真是热煞！
+为啥箇两天一天比一天热？
+喔，现在倒有点风了，稍微风凉点了。
+天气预报讲，今朝夜快要落雷阵雨。
+侬哪能还没到？
+现在堵车。
+侬到啥地方了？
+我到东方路了。
+能准时到𠲎？
+下趟再去上海火车站最好就是乘地铁。
+火车票买到了𠲎？
+买到了，21次特快。
+几点钟到上海？
+明朝早浪向7点20分到。
+票子多少钞票？
+来回票多少钞票？
+咨询一下飞机个情况。
+航班，票价，辰光老啥。
+请问是民航售票处𠲎？
+我想订一张20号到上海个机票。
+侬需要啥辰光个？
+要一张夜里向个航班个，可以打对折。
+可以个，单程票还是来回票？
+来回票，请拿票子送到公司来。
+先生，我要存钞票，哪能存法？
+侬要存活期存款，还是定期存款？
+阿拉箇𡍲有外币人民币定期一本通，也有活期一本通。
+活期取款末，侬可以随便啥个辰光用硬卡拉。
+侬可以到有“银联”标志个ATM机里去拿钞票。
+箇张卡拨侬，阿拉银行有廿四小时自动服务个。
+葛末硬卡哪能用法呢？
+插进去，看伊说明操作打就是了。
+请问，我要拿美元调人民币，箇𡍲好调拨我𠲎？
+现在日币告人民币个汇率是多少？
+请侬拿箇张旅行支票调成现钞。
+请侬箇𡍲签个字。
+一共是七千五百四十两块，侬点一点。
+请侬帮我调一点零碎钞票好𠲎？
+我要打只电话拨我囡儿。
+箇是自动投币电话，用一块硬币来打个。
+长风饭店是𠲎？请转328分机。
+老王，有电话寻侬。
+请问侬阿是鹿鸣书店个老板？
+侬声音大眼，我听勿出！
+对勿起，没人接电话。大概伊出去了𠲎。
+请侬告诉李民先生，讲我十点钟打过一只电话拨伊。
+明朝中浪向叫伊打拨我只电话。
+稍微等一歇，伊马上来接电话。
+A4纸头到啥地方买？
+箇个物事几钿？
+箇只照相机拿出来拨我看看叫。
+箇种样子个皮夹子㑚有得买𠲎？
+价钿是廿五块五角。
+介贵个！可以便宜点𠲎？
+忒难看了，有勿有款式新一眼个？
+侬看箇个两样当中阿里一样好？
+时髦是时髦一点了，价钿忒大！
+勿要介蹩脚个，要正宗一眼个！
+今朝箇眼物事大减价，侬听拣好唻。
+勿要是大兴货噢，小地方生产个！
+货色乓乓响个！阿拉从来勿做一枪头个生意个。
+价钿好打折头𠲎？
+箇眼是找头。
+帮我开张发票。
+小姐，箇封信寄到旧金山，邮票贴多少？
+信放辣秤高头称一称再告诉侬。
+我要寄钞票拨姆妈，拿张寄款单拨我好𠲎？
+台面浪自家拿。
+请问辣末一趟开信箱是啥辰光？
+五点钟，信快点厾下去还来得及。
+寄挂号信是勿是好快一眼？
+挂号信是保险一眼，勿会快反而慢。
+箇是啥物事？
+箇是笔记本电脑。
+箇是侬个笔记本电脑？
+勿是个，是我儿子个笔记本电脑。
+箇眼是啥人个光盘？
+箇眼是阿拉个光盘。
+埃面一眼是㑚个光盘？
+埃面个光盘是伊拉个。
+箇台电脑一直是伊用个𠲎？
+没噢，一直我辣用。
+勿是瞎讲，我箇份工作真叫呒没劲！
+侬常常出差，东南西北闯闯，勿要忒潇洒噢！
+长年累月东奔西走忙煞了，生活忒呒没规律了。
+侬个工作调拨我做做就好了。
+真叫看人挑担勿吃力，我脱侬调一调好𠲎？
+空是空得来没事体做。
+工资末，是侬个零头；上班末，大家淘淘浆糊。
+下班辰光呒没到，大家就想滑脚。
+侬讲有劲𠲎？
+侬要走啦？
+辰光勿早了，我要回去了。
+再坐一歇好唻。
+勿坐了，我还有眼事体辣海。
+葛末我送送侬。
+勿要送得个，我自家走。
+勿要紧个，送侬到电梯口。
+谢谢，谢谢。
+走好，走好，箇𡍲盏灯开一开。
+留步，留步，勿要送了。
+再会！有空多来白相相！
+一定来。拜哎，拜哎！
+侬是做啥个？
+我是阿拉公司个推销员。
+埃面一位是做啥个？
+伊也是推销员。
+箇位女士是推销员𠲎？
+勿是个，伊是阿拉个业务主管。
+立辣窗口头个箇个人是㑚经理，对𠲎？
+对个，伊是阿拉经理。
+箇眼人做啥事体个？
+大概是点公司员工。
+伊拉勿是公司员工啊？
+箇我倒勿大晓得。
+请问，李立辣辣𠲎？
+勿辣海，伊还没回来。
+侬晓得伊啥辰光回来𠲎？
+侬是小明对𠲎？
+是个，我是个，侬是？
+我是伊个同学刘刚。
+久仰久仰。
+李立经常讲到侬个。
+我来做只自我介绍。
+我脱李立是同班同学。
+阿拉是好朋友，我今年26岁。
+我是1984年6月15号生个。
+侬是来工作个𠲎？
+勿是个，是来度假个。
+侬现在到阿里𡍲去啊？
+我想去寻李立。
+我想帮伊一道去世纪公园。
+好个呀，明朝阿拉一道去。
+阿拉辣辣啥地方集合啊？
+明朝早浪向10点钟，辣辣食堂门口头。
+侬帮伊讲一声，好𠲎？
+好个，我一定帮伊讲。
+请㑚快点来部救护车，豪𢜶！
+我要整理房间。
+调羹
+叉子
+刀
+箇本书是我个。
+埃本书是阿拉儿子个。
+门口头有个人。
+书架高头侪是书。
+马路斜对过有家银行。
+有一家银行辣辣马路斜对过。
+侬屋里有电脑书𠲎？
+有个。
+有交关。
+我平常醒得来得个早。
+我欢喜睏懒觉。
+我每天六点钟起来。
+我要睏到八点半侪刚刚起来。
+我穿好衣裳以后就吃早饭。
+我辰光来大勿及咾，只好出门买大饼油条。
+我可以笃笃定定吃牛奶面包鸡蛋，或者泡饭酱菜。
+我每天早浪八点钟离开屋里，九点钟开始工作。
+从上半日一直做到夜快头。
+中浪向十二点钟左右，到阿拉单位食堂去吃中饭。
+阿拉经常做到下半天一点钟，盒饭是送上来个。
+做好生活一般五点半回到屋里吃夜饭。
+我夜里向一直出去个，脱朋友一道白相相。
+回来再上上网，发发email，弄到十一点钟再睏觉。
+侬现在辣辣做啥？
+我辣辣打电脑。
+侬个朋友近来辣海忙点啥？
+伊一直辣海做生意。
+目前我呒没辣做啥。
+上海人荡马路一只鼎，大概也是都市生态一种。
+交关马路商店集中，商品琳琅满目，真好看！
+倒勿一定要买啥物事，练啥脚劲。
+有辰光荡荡看看，领领市面，饱饱眼福。
+一荡马路，总归煞勿牢要买眼物事回转去。
+现在闹猛个地方，夜市面也好得一塌糊涂。
+南京东路高头百年老店多，南京西路高头高档精品店多。
+淮海路个商品高雅前卫，有海派特色。
+再要开眼界，去看人民广场下头个地下商场。
+小伙子陪女朋友来白相，眼睛看得五花八门。
+袋袋里个钞票摸空勿要紧，去寻自动取款机好唻。
+上海一方面拆脱了交关旧房子，一方面开辟了交关新房子。
+既清洁了周围空气，又降低了市中心个气温。
+绿地当中，假山咾，瀑布咾，湖泊咾，田园风光等等。
+白相上海新造个绿地也瞎有劲！
+名气最响个是辣辣太平桥绿地当中造了个“新天地”。
+闹市中心辟出新天地，闹中取静，又创新咾。
+一只长长个湖泊水几化清爽！
+伊长个是三角身胚，立辣海看上去瞎帅！
+小林个眉毛生得浓，眼睛又大，眼睫毛老长。
+伊个体型生得匀称唻！肩胛阔，腰身细，肚皮又有肌肉。
+伊平常注意锻炼咾，胸肌腹肌都是邦邦硬个！
+勿像有种男小囡，生了细细长长，像根豆芽菜。
+伊末，又是矮墩墩，又是壮得肉也绽出来。
+吃得忒多，长得胖来要死，乃末要影响发育。
+脚一长了末，就显得苗条得来，摆起POSE来末老漂亮个！
+侬看伊戆脑个样子，倒也蛮可爱。
+伊打扮得妖里妖气，戆头势勿谈了！
+身体好末，人老起劲；勿好末，啥事体也勿想做。
+一泼老头老太，天天勿脱班，弯腰昂头转身体。
+从小勿锻炼，一日到夜做功课，乃末弄出骺背。
+生活要做细，吃饭要吃粗，三餐勿吃多。
+气气闷闷生毛病，嘻嘻哈哈添寿命。
+勤汏浴，勤剃头，勤调衣裳，勤打扫房间。
+最好备一本家用医卫手册辣枕头边，常常翻翻看。
+补药好是好，勿过药补勿如食补。
+侬住阿里𡍲个？
+我住辣淮海路。
+我辣辣淮海路850号602室。
+对勿起，850号辣盖啥地方？
+辣盖弄堂着着里向头。
+箇条弄堂��直跑跑到底。。
+辣辣第二土大房子个第三家。
+上海
+上海言话
+黄浦江
+苏州河
+事体
+物事
+白相
+打朋
+轧朋友
+出洋相
+拎勿清
+淘浆糊
+拗造型
+隑
+囥
+瀴
+嗲
+滑稽
+适意
+的粒滚圆
+我
+阿拉
+侬
+㑚
+伊
+伊拉
+箇个
+迭个
+埃个
+伊个
+箇𡍲
+埃面
+箇能
+埃能
+介
+拨
+勿
+呒没
+老
+邪气
+本地人
+外地人
+乡下人
+镇浪人
+城里人
+外乡人
+外路人
+外国人
+外头人
+洋人
+老外
+华侨
+海归
+江北人
+苏北人
+东洋人
+陌生人
+生人头
+生客
+熟客
+爷爷
+老爹
+阿奶
+外公
+外婆
+太太
+爷娘
+爸爸
+姆妈
+妈妈
+娘
+过房娘
+公婆
+公公
+婆婆
+阿婆
+丈人
+伯伯
+大伯
+叔叔
+海派
+唱歌
+民歌
+合唱
+唱K
+跳舞
+芭蕾舞
+走台
+说唱
+钢琴
+小提琴
+萨克斯风
+灯笼
+脱口秀
+做戏
+唱戏
+沪剧
+越剧
+绍兴戏
+滑稽戏
+唱只歌拨大家听好𠲎？
+好个。唱只啥？
+我只歌唱了好勿好？
+蛮好，勿推扳。
+侬看两张照片阿里张好？
+我想是箇张好。
+箇个物事是侬个𠲎？
+箇是我个。
+箇桩事体侬晓得𠲎？
+哪能勿晓得呢？
+我为啥一定要晓得呢？
+侬勿关心，所以勿晓得。
+我老欢喜侬个。
+我就是服帖侬。
+阿拉脱老爸老妈已经分开住分开吃了。
+我礼拜天常常到丈人老头𡍲去帮伊拉做眼力气生活。
+阿拉今年要帮阿公老头做八十大寿。
+外甥今年考大学缺了几分没考进重点大学。
+阿拉表妹半年前养小囡养了一个大胖儿子。
+舅妈拉单位勿景气，伊下岗以后去做月嫂收入倒蛮好。
+娘舅拉长远勿去了，伊经常一家头辣屋里忒厌气。
+今朝阿拉一家门侪到爷叔𡍲去白相好𠲎？
+我买好了，两盒西洋参，五斤苹果，还有十只蟹。
+假使侬新房子已经装修好了，我就来帮侬搬场。
+搬勿动末，多叫几个人来搬。
+箇眼钢宗锅子侪好掼脱伊唻。
+早两年买个箇只脱排油烟机过时了，葛咾我要买只新个。
+房间新家生侪买好了末，箇点破家生侪可以厾脱了！
+既然侬介欢喜种花，侬埃只阳台就专门摆花盆好唻。
+一旦培训期满，我就可以做一个银行出纳员。
+只有我自家开始做生意个辰光，我再觉着称心如意。
+退休也退休了，还常常拨伊拉请得去做顾问。
+伊个工作工资老高，工作辰光也交关理想。
+只要伊辣事业浪做出成就，就可能派到国外去合作。
+我欢喜画油画，但是我勿想拿伊做我个终身职业。
+勿管侬到勿到箇爿厂去工作，总归要告诉我一声。
+伊东托人，西应聘，为来为去为仔做自家称心个生活。
+即使我拿勿到高个工资，我也勿肯放弃箇只饭碗。
+今朝忙做忙，也要做光箇眼生活再走。
+今朝鸡毛菜倒蛮便宜个末！
+一点也勿便宜，贵得来热昏！
+箇能介烂糟糟个菜要介贵啊！
+侬看看清爽，勿要忒新鲜噢！
+洋山芋𠼢来死个！
+荷兰豆赞得勿得了！
+我想问㑚租房子蹲蹲。
+房子个采光条件要好一眼，勿要角角头个房子。
+租个房子要离我工作个地方近一眼。
+我要一室一厅个房子，面积辣四十个平方左右。
+㑚箇间房子朝向好勿好？
+煤气勿一定要一家头用，但是卫生要独用个。
+我最好要多层个三四楼。
+是勿是装修好个？
+要末寄“特快邮件”明朝就可以到。
+寄件人、收件人地址姓名勿要填反脱！
+邮政编码勿要忘记写！
+我还有张汇款单，辣侬箇𡍲领钞票是𠲎？
+侬身份证带来𠲎？
+身份证号我已经填好了，可以领吗？
+对勿起，呒没身份证是勿好领汇款个。
+如果辰光有钞票够，我要到欧洲去旅游。
+亨八冷打我箇趟旅程需要十二天。
+祝侬一路浪向白相开心。
+明朝要动身，但是我到现在箱子还没整理好。
+一桩事体是马上到银行里去拿眼钞票。
+喔，我刚刚想起来，身份证勿要忘记脱带。
+要勿是侬提醒我，随便哪能也想勿起来。
+我勿想乘汽车去，情愿走得去。
+侬安全到达目的地以后，勿要忘记脱打只电话告诉我。
+我肯定忘记了带洋伞，但现在已经忒晏了。
+火车马上就要开，阿拉勉强可以赶到。
+上海值得去白相个地方实在忒多。
+勿过也有眼地方没啥去头。
+黄浦江两岸最好看，可以坐辣船里游览。
+侬看，浦东有介许多高层建筑，还有东方明珠。
+我还是对豫园、城隍庙、上海老街更加有兴趣。
+辣延安路高架高头看两面个上海风光，瞎嗲！
+一圈兜回来，还好看看外滩近代建筑夜景。
+苏州河是上海母亲河，弯弯曲曲横跨流过市中心。
+上海人结婚，有个人家酒水场面办得老大。
+发拨好朋友个请帖浪有新郎新娘合影个照片。
+新郎一面有伴郎，新娘一面有伴娘。
+结婚仪式开始，双方爷娘要讲言话，祝贺伊拉。
+证婚人致贺词，双方互赠结婚戒指。
+新婚房里，有放红枣花生桂圆脱仔瓜子个，讨个彩头。
+除脱亲眷，还请来了上司、同事、大学中学小学同学。
+闹起新房来，可想而知要闹猛得一塌糊涂了！
+现在老师对𠲎，邪气迷信考试，明朝又要考试了。
+老师告爷娘侪是考试迷，一门心思出考题监考。
+三番四次买参考书，兴师动众请家教，弄得小囡苦得来一天世界。
+现在上海家家侪是独生子女咾，家长对小囡个读书相当关注。
+子女培养全社会侪邪气关心，教育要进行改革。
+21世纪社会，勿懂电脑勿懂外语往往会步步难。
+所以只看见学生辣辣嘀里嘟噜读外语，滴粒笃落打电脑。
+勿过，外语、电脑对多数人来讲，到底还是一个新个事物。
+要搞出点名堂来，对社会有用，专业还是要硬碰硬个。
+要成功，还要有各种素质，像创造力啊。
+苏州河个老名字叫“松江”又称“吴淞江”。
+江边有条支河，叫“上海浦”，就是现在个黄浦江。
+有个人旅游欢喜跑了远，其实上海郊区好白相地方也老多个。
+侬啥事体要骂人家？
+一到春天，上海人侪想跑出去散散步，散散心。
+事体总归有得解决个办法个。
+是一对结婚四五年个夫妻。
+有是有个，没带来。
+结婚以后，应该是更加好个朋友。
+阿拉侪是旅游迷。
+今朝穿了箇件红兮兮个衬衫，我跑得出去𠲎？
+箇能个沙发我勿想买。
+伊拉两位现在老忙个，勿想帮侬谈。
+94路朝襄阳北路方向开个公交车阿里乘？
+反正，侪是我勿对。
+还要买菜，买肉，买日用品。
+将来想要到阿拉国家个宝岛台湾。
+财富勿是一辈子个朋友。
+伊就会得有外公外婆。
+阿拉关系侪老好个。
+朋友才是一辈子个财富。
+阿拉啥辰光开始工作？
+阿拉屋里向是四世同堂。
+侪欢喜自然。
+侬也蛮好个。
+侬个头发做了蛮好个。
+为啥勿听我个言话？
+侬应该往好个一面看。
+一般。
+侬个英文讲了交关好。
+我还要擦擦台子扫扫地。
+㑚屋里向人老好个。
+我看伊是，吃了睏，睏了吃，打打游戏，懒是懒！
+侬看，伊来了。
+我看叫。
+每天睏7-8个钟头。
+睏觉前头我还要看半个钟头个书。
+我辣辣全国有老多朋友。
+小李，刚刚有只电话寻侬。
+伊辣辣屋里就闹猛了。
+到箇辰光，阿拉亲眷就更加多了。
+辰光就是钞票。
+侬辣海阿里只大学读书？
+现在我下去晨练。
+后天礼拜一。
+帮女朋友分手之后我觉得老胸闷个。
+回去以后被骂了一顿。
+侬过奖了。
+谢谢侬个邀请。
+谢谢侬个鼓励。
+谢谢侬个祝福。
+谢谢侬个指导。
+谢谢侬个礼物。
+两个人总归观点勿一样。
+真戆。
+侬个口语增好。
+真触霉头。
+我真个没希望了。
+我真个老后悔个。
+我真个受勿了了。
+真个烦煞脱了。
+我没哥哥，弟弟，妹妹。
+我下半天6点钟回去。
+老勿好意思个，没及时回信拨侬。
+因为伊没电了。
+到下班辰光了。
+辰光到了。
+阿拉要珍惜辰光。
+现在是5点半。
+早浪向，我拿闹钟开到5点40分。
+勿过，现在好交关了。
+现在电信业老发达个。
+伊总归工作第一。
+伊欢喜摄影。
+还有就是，考试个辰光忒紧张了。
+过去个三年辰光白白浪费脱了。
+阿拉刚刚搬到箇𡍲。
+喔唷，撞着侬了，对勿起！
+我帮伊拉讲，谈朋友个辰光是朋友。
+经常吵相骂个。
+做啥也没精神。
+我经常约伊拉散步，聊天。
+是啥人打来个。
+拿工作摆辣第一位。
+工作当中勿可以骂人，吵相骂。
+如果复读，我又要再读一年书。
+是复读还是上一般个大学？
+快要走遍阿拉国家个山山水水了。
+谢谢侬让一让好𠲎？
+身份证拨我。
+会得有儿子或者女儿。
+填写票据应该用钢笔或者碳素笔。
+请拿好侬个身份证。
+我要告张先生、李先生谈一谈。
+我去拿老王寻得来。
+做啥侪勿顺利。
+侬是新来个𠲎？
+侬一定会得成功个。
+箇是我个女朋友杨雪。
+侬明年一定会得赢个。
+我觉得忒伤心了。
+箇有啥吓人个。
+10点半睏觉。
+自家人
+我勿睬伊拉。
+我要收作龌龊衣裳。
+天亮快了，我要走了。
+等天好了，我要拿稿子送到出版社去。
+整个上半天，我侪辣海忙打字。
+现在快12点钟了。
+到辰光具体个利息是根据人民银行标准为准个。
+衣裳
+侬想点啥事体？
+杨雪，我还有老多好朋友。
+阿拉有老多共同爱好。
+现在12点多了。
+为来为去侪为了侬，所以勿去！
+忒灵了，谢谢侬。
+还是先去打只电话算了。
+侬是勿是有两台电脑？
+箇台相机是勿是侬个？
+存款有定、活两种。
+电话报时117
+天气预报121
+箇是我姐姐。
+箇是林欢，阿拉姐姐个爱人。
+请问，几点钟了？
+请问侬存多少钞票。
+请���六位密码。
+问题出了阿里𡍲？
+一点也勿吃力，谢谢侬来接阿拉。
+一旦我有可能，我就要跳槽。
+我勿等啥人。
+我没听到咾。
+我理解侬个心情。
+箇个礼拜。
+阿拉也成为好朋友了。
+侬个朋友哪能还呒没来啦？
+阿拉爸爸买菜去了。
+我现在有点懒了。
+天气一天比一天冷。
+哦，晓得了，谢谢。
+是个，我刚刚来，请多多关照哦。
+侬老吸引人个。
+老长辰光没写信拨侬了。
+拿扫帚扫一扫地浪向。
+伊慢慢叫辣辣赶上去。
+我屋里有个老人突然倒辣地浪，大概中风了。
+衣裳㫰出去了。
+龌龊衣裳去汏汏伊！
+参加派对个言话，侬会穿阿里件衣裳？
+没啥好担心个。
+我要到超市去，熟泡面啊，酒酿圆子啊，侪要买。
+箇班火车几点钟开？
+我应该早眼清醒。
+从上海火车乘到郑州要几个钟头？
+如果我箇眼生活可以做光，我要礼拜一到南京去。
+再好眼个，像箇能样子个，侬要𠲎？
+一套红木家生要十几万洋钿唻！
+我想买一张到上海个单程机票。
+菜切好辣海，勿晓得啥个辰光来烧。
+侬想吃眼点心𠲎？
+侬想要头发剃得长点还是短点？
+侬头发想吹啥个式样？
+辣两年前吃过一趟。
+勿好意思箇条路是啥路？
+门开勿开！
+㑚看，窗开辣辣，厨房间门也没关！
+水开快唻，泡杯茶吃了再走。
+侬饭吃过了𠲎？
+我还没吃过。
+侬生鱼片吃过𠲎？
+一直朝前走对𠲎？
+请朝前一步。
+夜到7点20分切饭。
+我想存钞票。
+请问存款利息多少？
+侬好，侬个信老早收到了。
+阿里个方向是朝南？
+相信自家。
+伊拉是红肠切切，色拉拌拌，烧烧罗宋汤，自家做西菜。
+用笔个规定：
+现在正好12点钟。
+整
+我存1000块。
+裙子
+火警电话119
+电话查号114
+报警电话110
+请侬拿箇号头记下来。
+箇桩事体伊告我讲个。
+对勿起，到南京东路哪能走近一点？
+㑚一路浪向吃力了𠲎
+伊拉罗嗦。
+伊拉就拿气出辣我身浪向。
+我个儿子长大了希望做医生。
+我个地址是武宁路36弄9号底楼。
+一夜天侪辣辣想事体。
+我买了小菜，烧好了饭，等我儿子回来吃饭。
+我个表停脱了。
+我儿子跟小王买碟片去了。
+快点去！慢吞吞、木笃笃做啥！
+侬吃面条还是吃饭？喝橙汁还是喝咖啡？
+夜里向切了老多老酒。
+今朝夜头侬约会辣啥地方？
+小菜摊了一台子，吃剩辣海个肉汤都呒没收好。
+请问㑚几位是美国贸易代表团个𠲎？
+拿架子高头个灰尘揩一揩。
+等等我，慢慢叫！
+伊拉上半日来坐了歇，讲下半日就要离开上海。
+欢迎光临，现在人多，请侬坐下来等一歇。
+加油，振作起来。
+加油
+走呀！大家走起来！
+当阿拉赶到辰光，伊拉舞已经开始跳起来了。
+大家电风扇吹吹。
+阿拉是同事侪要互相照顾个。
+慢叫清理垃圾。
+㑚箇𡍲生意真好，介闹猛！
+请侬填好个张表格。
+够了够了。
+辰光要到快了，侬哪能还捱发捱发。
+今朝到城隍庙了末，就要尝尝本邦小吃个味道了。
+侬哪能介慢个啦！
+我辰光来勿及唻，侬快点好勿啦！
+辰光还早辣海唻，大家坐下来茄茄山河𠲎。
+里向开了一爿爿欧式小店，情调瞎嗲！
+勿好对读书失去希望。
+明朝礼拜天。
+每种利息也勿一样。
+冷艳，老灵个。
+蓝天，白云，老灵老灵个。
+蔬菜，水果沙拉。
+我做了实在忒搭浆了。
+照老样子好了，稍为短一点。
+到现在我又打好了两篇稿子。
+𠲎
+侬勿要来捣蛋好勿啦！
+侬看，台子高头还摆了一叠样版。
+否则明年高考又要落空了。
+烹调方法也是又精致又集江南大成。
+请问箇𡍲附近有厕所𠲎？
+侬发票有勿有？
+三个号头一年利息是1.17。
+比如讲：2月13号，应该写成零贰月壹拾叁号。
+大房间里向家生倒勿推扳辣海！
+煤气、热水器、洗衣机、空调有勿有？
+租金哪能算？水电煤哪能交？
+我想去买只优盘，侬脱我一道去好𠲎？
+伊拉匆匆忙忙去看足球比赛，屋里物事侪摊辣海。
+侪是侬平常勿用工。
+我对伊拉讲道理没兴趣。
+继续努力。
+我要努力复习一年。
+活期个一年利息是0.72。
+箇是侬个存折。
+我没希望了。
+忒烦了。
+咖啡
+一面吃吃红茶咖啡，一面吃吃色拉西点，一面谈谈心。
+饭
+侬今朝去锻炼过𠲎？
+老克拉讲，勿管伊啥辰光啥时尚。
+啥
+五年头个是2.79。
+对勿起，侬打错电话了。
+修面侬要修修清爽。
+水煮鱼。
+茶壶里再冲点水辣海。
+我欢喜爬山。
+假使我讲拨侬听，大家勿要走来走去，侬有意见？
+侬素质高一点好𠲎！
+哪能勿告诉我哪能做？
+侬如果高兴，就吃一点𠲎。
+要等伊踢好，还有一歇辣海唻！
+勿过，爸爸还是怪我。
+为啥高考成绩��好？
+啥体勿早点讲！
+叫侬去为啥咾勿去？
+新酷一族派对辣辣茶吧里开，四个人牛皮吹吹。
+我还要焗油脱吹头发。
+大家个行李侪拿齐了𠲎？
+快一点好𠲎！
+轻轻叫放！
+喂，张小静辣辣屋里𠲎？麻烦侬叫伊听听电话。
+我拿六扇窗侪关上了。
+箇条阴沟通好伊！
+箇封信脱我寄脱伊！
+定期个三个号头帮五年个利息也勿一样。
+3月30号个班机全部客满。
+阿拉要回去唻，侬托阿拉个事体一定留心辣海。
+我还请了钟点工帮忙打扫好了房间。
+讲言话要客气，亲切。
+侬讲得我馋也馋煞唻！
+零
+侬辣海等啥人啊？
+上海人讲上海话；上海人也侪会讲普通话。
+箇是箇𡍲个面筋百叶双档最最正宗个。
+勿要看勿起人家。
+也勿要妒忌人家。
+要虚心脱人家学习。
+勿要直接叫名字。
+排好队，勿要插队！
+谢谢侬勿要辣车厢里哗啦哗啦打手机，可以改发短信𠲎！
+车厢里向只报站名，勿要啰囌。
+箇部火车辣昆山站头停车𠲎？
+箇套房子是阿拉囡儿帮女婿蹲个。
+溪水，草地，木房子，忒灵了。
+侬箇牌人推扳勿啦！
+绝对勿可以凶来兮个。
+9月25号，应该写成零玖月贰拾伍号。
+请正确写好票据个日期。
+请侬正确填写票据。
+正确使用中文大写数字
+对伊拉个要求要尽量做到。
+对客户勿要勿理勿睬。
+老板
+大老板
+我带㑚去。
+我已经长远没去锻炼了。
+箇只箱子要特别脱我当心。
+还缺一只箱子。
+勿要紧个。
+火腿要隔水“蒸”，牛百叶只要水里一“氽”。
+阿拉蹄膀笃笃，螺蛳嗍嗍，沪剧哼哼，邪气小乐！
+台子脚拨伊装好了。
+要尊敬领导，尊敬同事。
+同事之间也要有礼貌。
+搞好同事之间个关系。
+唉，后悔啊！
+伊去买了两趟侪呒没买到。
+我现在个位置辣地图高头阿里𡍲？
+开口要有礼貌，勿讲下作言话。
+昨日我快要出门个辰光，伊倒一摇一摇个来了。
+伊要上进了。
+番茄炒蛋。
+炒猪肝。
+听讲一只精品鸡鸭血汤，鲜是鲜得来！
+咖喱牛肉汤、油豆腐线粉汤勿要忘记脱吃。
+桂花赤豆汤侬要吃吃看𠲎？
+苏州豆腐干，绍兴霉干菜，宁波黄泥螺，南京鸭血汤。
+宫爆鸡丁。
+老早苏州河污染得又黑又臭，侬可以看看前几年个样子。
+但是现在城区大多数地方，辣唐朝以前还是海滩。
+分
+已经等了半个钟头了。
+赤膊上街忒难看。
+角
+最近又开辟了朱家角旅游点，镇高头个放生桥历史悠久。
+忒勿像言话了。
+一长排石库门房子，外表还像旧弄堂。
+㑚看，伊拉书房里倒收作得清清爽爽个。
+买火车票个窗口辣海阿里？
+交关
+有种人，叫伊“老克拉”，是从“colour”脱变过来个。
+写字台高头一叠专业书里混辣海几本卡通书。
+箇本书我没。
+墙高头几张古色古香个字画挂辣海。
+红烧牛肉。
+“门槛精到九十门”、“个角头碰着天花板”、“霉头触到哈尔滨”。
+前两年市政府花了大力气，使得苏州河变清了。
+再过几年，苏州河沿岸真要成为上海一条亮丽个风景线。
+我真勿好意思！
+喂，我要叫部差头，现在到华山路200弄40号门口。
+喏，拨侬！
+茭白要用油“焖”，蛤蜊摆辣蛋里“炖”。
+带鱼要吃干“煎”，豆板好油“氽”。
+急啥急啦！
+衬衫
+走过去一眼！
+静一点好𠲎！
+脱我来！
+大众出租汽车公司个电话号码是啥？
+急救电话120
+几件随机行李要称称。
+“老上海”派对里，几个老克拉勿但唱起评弹申曲。
+喏，足球踢得正好紧张辣海。
+一块圆台玻璃敲碎脱了。
+旧杂志卖光了。
+老三老四
+个
+圆
+箇阿是开到北京去个火车？
+乘箇部火车，走几号通道？
+侬勿晓得上海有各式各样个“吧”，侬又戆脱！
+上海新好男人，又会拼命工作，又会将休闲进行到底。
+松江个醉白池、青浦个曲水园、嘉定个秋霞圃。
+上海箇块地方，海内外样样小菜侪有。
+学生意
+勿好去瞎碰个！
+拨河
+有网络作家讲写作计划，也有小企业家谈种种发财经。
+红烧豆腐。
+西装
+侬勿要瞎讲！
+侬勿要辣辣装戆大！
+快要疯脱了。
+做一个可爱个上海人！
+上海人要树立上海新形象。
+到七百多年前元朝辰光，建置了上海县。
+上海开埠以后，中西融合，兼收并蓄，形成了宽带个文化氛围。
+大上海，方言个气派也大，表现了中西交汇。
+公车高头要静了再静。
+上海介繁荣，主要是一百六十年前开埠以后发生个变化。
+绿灯辰光，转弯车子要让人。
+修面修𠲎？
+从松江、青浦一带个出土文物当中看到。
+当时，国画、京戏、通俗小说、流行歌曲，侪是相当流行个。
+都市文化海纳百川，建筑、出版、娱乐、弄堂生活。
+当今，海派文��正辣注入新个活力发扬光大。
+对于身无分文个人，叫伊“瘪的生丝”。
+“牵头皮”、“收骨头”、“戳壁脚”。
+公共场合勿吃香烟。
+让标准路标跟规范文字讲话。
+京戏
+上海从来是个海纳百川个城市。
+我唱卡拉OK，从小辰光歌唱起，一直唱到劲歌。
+我有辰光佮仔朋友唱唱歌，泡泡吧。
+侬吃香烟𠲎？
+老弱病残孕幼侪要照顾。
+轧个地方请保持安静依次排队。
+环境卫生人人珍视。
+做个讨人欢喜个小朋友。
+本地人、外来人齐心共创上海新文明。
+还有佘山风景区，淀山湖大观园、东方绿洲咾。
+一碗绉纱馄饨，皮薄是薄得肉也看得见！
+侬闻闻香味看，五香茶叶蛋香勿香？
+我想吃吃畅咾再走。
+喂，120是𠲎？
+唱独脚戏
+唱功
+个唱
+男个
+女个
+立柜台个
+压台戏
+小把戏
+评弹
+说书
+锡剧
+昆曲
+演戏
+演出
+演员
+大牌
+场子
+日场
+夜场
+票子
+吊嗓子
+追星
+粉丝
+拉拉队
+海选
+游乐场
+西洋镜
+广播
+电影
+电影院
+片子
+抢版
+电视
+毛片
+运动场
+体育场
+球场
+体育
+塑胶跑道
+打球
+篮球
+三对三
+排球
+电影明星
+毛脚
+三毛球
+脚色
+硬脚头
+烦煞脱了！
+硬头
+足球
+板凳
+搞尔
+乒乓球
+台球
+打乒乓
+高尔夫球
+保龄球
+博克胸
+打落弹
+羽毛球
+体操
+厾铅球
+跳山羊
+跳高
+跳远
+游泳
+自由泳
+游泳池
+翻跟斗
+攀岩
+蹦极
+草割
+秒杀
+黑哨
+黑猫
+老猫
+老记
+老法师
+老克拉
+请侬记牢密码。
+太太
+过房儿子
+过房囡儿
+独养儿子
+儿子
+囡儿
+小囡
+乖囡
+侄囡
+外甥囡
+孙囡
+外甥
+爷叔
+叔父
+姑父
+孃孃
+姑妈
+姨妈
+姨夫
+阿姨
+娘舅
+舅舅
+舅妈
+夫妻
+丈夫
+老公
+男人
+妻子
+老婆
+夫人
+女人
+小老公
+小老婆
+哥哥
+阿哥
+阿嫂
+嫂嫂
+姐姐
+阿姐
+姐妹
+姊妹
+姐夫
+兄弟
+弟弟
+阿弟
+弟新妇
+妹妹
+阿妹
+妹夫
+党兄
+堂弟
+堂妹
+新妇
+表兄
+咾
+表哥
+表弟
+表妹
+子女
+小人
+小毛头
+阿囡
+私生子
+女婿
+上门女婿
+当中人
+老实人
+达人
+强人
+妖人
+情人
+侄子
+孙子
+孙女
+孙女婿
+曾孙
+曾孙女
+熟人
+朋友
+老朋友
+小朋友
+同行
+同年
+主人家
+客人
+本人
+人家人
+邻居
+近邻
+街坊
+房客
+房东
+男人家
+女人家
+先生
+老公公
+老头子
+老太太
+老太婆
+拖油瓶
+少爷
+老爷
+师傅
+师母
+内行
+外行
+读书人
+孝子
+大佬官
+欧巴桑
+酒肉朋友
+小资
+小开
+上司
+教书先生
+顶头上司
+头头
+主任
+老板娘
+经理
+工头
+监工
+厂长
+工程师
+技术人员
+会计
+出纳
+组长
+检验员
+中介
+猎头
+内勤
+卖票员
+外勤
+采购员
+伙计
+工人
+小工
+零工
+民工
+上手
+下手
+帮手
+佣人
+仆人
+保姆
+钟点工
+丫头
+摊贩
+厨师
+跑堂
+门房
+商人
+生意人
+青春饭
+房产商
+房虫
+店员
+售货员
+售票员
+证人
+演员
+医生
+护士
+看护
+保育员
+农民
+长工
+网虫
+短工
+记者
+警察
+保镖
+邮递员
+驾驶员
+司机
+车模
+木匠
+木工
+清洁工
+清道夫
+码子
+模子
+老好人
+明白人
+好好先生
+老手
+飞人
+妖怪
+金领
+王老五
+白骨精
+提款机
+花花公子
+阿飞
+姘头
+野鸡
+屁精
+地头蛇
+骗子
+拐子
+瘪三
+强盗
+小偷
+三只手
+流氓
+侪
+辣辣
+葛咾
+...浪
+里向
+啥人
+脱
+唻

text/__init__.py

@@ -0,0 +1,32 @@
+""" from https://github.com/keithito/tacotron """
+from text import cleaners
+
+
+def text_to_sequence(text, symbols, cleaner_names):
+  '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
+    Args:
+      text: string to convert to a sequence
+      cleaner_names: names of the cleaner functions to run the text through
+    Returns:
+      List of integers corresponding to the symbols in the text
+  '''
+  _symbol_to_id = {s: i for i, s in enumerate(symbols)}
+
+  sequence = []
+
+  clean_text = _clean_text(text, cleaner_names)
+  for symbol in clean_text:
+    if symbol not in _symbol_to_id.keys():
+      continue
+    symbol_id = _symbol_to_id[symbol]
+    sequence += [symbol_id]
+  return sequence
+
+
+def _clean_text(text, cleaner_names):
+  for name in cleaner_names:
+    cleaner = getattr(cleaners, name)
+    if not cleaner:
+      raise Exception('Unknown cleaner: %s' % name)
+    text = cleaner(text)
+  return text

text/cleaners.py

@@ -0,0 +1,65 @@
+import re, sys ,os
+import cn2an
+import opencc
+
+converter = opencc.OpenCC(os.path.dirname(sys.argv[0])+'/lexicon/zaonhe.json')
+
+# List of (Latin alphabet, ipa) pairs:
+_latin_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [
+    ('A', 'ᴇ'),
+    ('B', 'bi'),
+    ('C', 'si'),
+    ('D', 'di'),
+    ('E', 'i'),
+    ('F', 'ᴇf'),
+    ('G', 'dʑi'),
+    ('H', 'ᴇtɕʰ'),
+    ('I', 'ᴀi'),
+    ('J', 'dʑᴇ'),
+    ('K', 'kʰᴇ'),
+    ('L', 'ᴇl'),
+    ('M', 'ᴇm'),
+    ('N', 'ᴇn'),
+    ('O', 'o'),
+    ('P', 'pʰi'),
+    ('Q', 'kʰiu'),
+    ('R', 'ᴀl'),
+    ('S', 'ᴇs'),
+    ('T', 'tʰi'),
+    ('U', 'ɦiu'),
+    ('V', 'vi'),
+    ('W', 'dᴀbɤliu'),
+    ('X', 'ᴇks'),
+    ('Y', 'uᴀi'),
+    ('Z', 'zᴇ')
+]]
+
+def _number_to_shanghainese(num):
+    num = cn2an.an2cn(num).replace('一十','十').replace('二十', '廿').replace('二', '两')
+    return re.sub(r'((?:^|[^三四五六七八九])十|廿)两', r'\1二', num)
+
+def number_to_shanghainese(text):
+    return re.sub(r'\d+(?:\.?\d+)?', lambda x: _number_to_shanghainese(x.group()), text)
+
+def latin_to_ipa(text):
+    for regex, replacement in _latin_to_ipa:
+        text = re.sub(regex, replacement, text)
+    return text
+
+def shanghainese_to_ipa(text):
+    text = number_to_shanghainese(text.upper())
+    text = converter.convert(text).replace('-','').replace('$',' ')
+    text = re.sub(r'[A-Z]', lambda x: latin_to_ipa(x.group())+' ', text)
+    text = re.sub(r'[、；：]', '，', text)
+    text = re.sub(r'\s*，\s*', ', ', text)
+    text = re.sub(r'\s*。\s*', '. ', text)
+    text = re.sub(r'\s*？\s*', '? ', text)
+    text = re.sub(r'\s*！\s*', '! ', text)
+    text = re.sub(r'\s*$', '', text)
+    return text
+
+def shanghainese_cleaners(text):
+    text = shanghainese_to_ipa(text)
+    if re.match(r'[^\.,!\?\-…~]', text[-1]):
+        text += '.'
+    return text

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

utils.py

@@ -0,0 +1,75 @@
+import logging
+from json import loads
+from torch import load, FloatTensor
+from numpy import float32
+import librosa
+
+
+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__()
+
+
+def load_checkpoint(checkpoint_path, model):
+  checkpoint_dict = load(checkpoint_path, map_location='cpu')
+  iteration = checkpoint_dict['iteration']
+  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]
+    except:
+      logging.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)
+  logging.info("Loaded checkpoint '{}' (iteration {})" .format(
+    checkpoint_path, iteration))
+  return
+
+
+def get_hparams_from_file(config_path):
+  with open(config_path, "r") as f:
+    data = f.read()
+  config = loads(data)
+
+  hparams = HParams(**config)
+  return hparams
+
+
+def load_audio_to_torch(full_path, target_sampling_rate):
+  audio, sampling_rate = librosa.load(full_path, sr=target_sampling_rate, mono=True)
+  return FloatTensor(audio.astype(float32))