├── tests ├── __init__.py ├── cmudict_test.py ├── text_test.py └── numbers_test.py ├── datasets ├── __init__.py ├── vc.py └── datafeeder.py ├── .gitignore ├── figs └── align.png ├── samples ├── clb_arctic_a0001-eval.wav ├── clb_arctic_a0002-eval.wav └── clb_arctic_a0003-eval.wav ├── models ├── __init__.py ├── rnn_wrappers.py ├── helpers.py ├── modules.py └── tacotron.py ├── eval.sh ├── requirements.txt ├── util ├── __init__.py ├── plot.py ├── infolog.py └── audio.py ├── text ├── symbols.py ├── cmudict.py ├── numbers.py ├── __init__.py └── cleaners.py ├── README.md ├── LICENSE ├── hparams.py ├── download_data.sh ├── synthesizer.py ├── preprocess.py ├── eval.py ├── parallel_data ├── test.lst └── metadata.csv ├── TRAINING_DATA.md ├── demo_server.py ├── train.py └── origin-readme.md /tests/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /datasets/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | __pycache__/ 2 | .cache/ 3 | *.pyc 4 | .DS_Store 5 | run*.sh 6 | -------------------------------------------------------------------------------- /figs/align.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahdeslami11/-/HEAD/figs/align.png -------------------------------------------------------------------------------- /samples/clb_arctic_a0001-eval.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahdeslami11/-/HEAD/samples/clb_arctic_a0001-eval.wav -------------------------------------------------------------------------------- /samples/clb_arctic_a0002-eval.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahdeslami11/-/HEAD/samples/clb_arctic_a0002-eval.wav -------------------------------------------------------------------------------- /samples/clb_arctic_a0003-eval.wav: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/mahdeslami11/-/HEAD/samples/clb_arctic_a0003-eval.wav -------------------------------------------------------------------------------- /models/__init__.py: -------------------------------------------------------------------------------- 1 | from .tacotron import Tacotron 2 | 3 | 4 | def create_model(name, hparams): 5 | if name == 'tacotron': 6 | return Tacotron(hparams) 7 | else: 8 | raise Exception('Unknown model: ' + name) 9 | -------------------------------------------------------------------------------- /eval.sh: -------------------------------------------------------------------------------- 1 | python eval.py --checkpoint ./logs-tacotron/model.ckpt-22000 --ref ./parallel_data/wavs/clb_arctic_a0001.wav 2 | python eval.py --checkpoint ./logs-tacotron/model.ckpt-22000 --ref ./parallel_data/wavs/clb_arctic_a0003.wav 3 | -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | # Note: this doesn't include tensorflow or tensorflow-gpu because the package you need to install 2 | # depends on your platform. It is assumed you have already installed tensorflow. 3 | falcon==1.2.0 4 | inflect==0.2.5 5 | librosa==0.5.1 6 | matplotlib==2.0.2 7 | numpy==1.14.3 8 | scipy==0.19.0 9 | tqdm==4.11.2 10 | Unidecode==0.4.20 11 | -------------------------------------------------------------------------------- /util/__init__.py: -------------------------------------------------------------------------------- 1 | class ValueWindow(): 2 | def __init__(self, window_size=100): 3 | self._window_size = window_size 4 | self._values = [] 5 | 6 | def append(self, x): 7 | self._values = self._values[-(self._window_size - 1):] + [x] 8 | 9 | @property 10 | def sum(self): 11 | return sum(self._values) 12 | 13 | @property 14 | def count(self): 15 | return len(self._values) 16 | 17 | @property 18 | def average(self): 19 | return self.sum / max(1, self.count) 20 | 21 | def reset(self): 22 | self._values = [] 23 | -------------------------------------------------------------------------------- /util/plot.py: -------------------------------------------------------------------------------- 1 | import matplotlib 2 | matplotlib.use('Agg') 3 | import matplotlib.pyplot as plt 4 | 5 | 6 | def plot_alignment(alignment, path, info=None): 7 | fig, ax = plt.subplots() 8 | im = ax.imshow( 9 | alignment, 10 | aspect='auto', 11 | origin='lower', 12 | interpolation='none') 13 | fig.colorbar(im, ax=ax) 14 | xlabel = 'Decoder timestep' 15 | if info is not None: 16 | xlabel += '\n\n' + info 17 | plt.xlabel(xlabel) 18 | plt.ylabel('Encoder timestep') 19 | plt.tight_layout() 20 | plt.savefig(path, format='png') 21 | -------------------------------------------------------------------------------- /text/symbols.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Defines the set of symbols used in text input to the model. 3 | 4 | The default is a set of ASCII characters that works well for English or text that has been run 5 | through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details. 6 | ''' 7 | from text import cmudict 8 | 9 | _pad = '_' 10 | _eos = '~' 11 | _characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!\'(),-.:;? ' 12 | 13 | # Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters): 14 | _arpabet = ['@' + s for s in cmudict.valid_symbols] 15 | 16 | # Export all symbols: 17 | symbols = [_pad, _eos] + list(_characters) + _arpabet 18 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # VC_Tacotron 2 | 3 | Voice Conversion using Tacotron Model. 4 | 5 | ### Quick Start 6 | #### 1. Download dataset and Preprocess 7 | ```shell 8 | ./download_data.sh 9 | python preprocess.py 10 | ``` 11 | 12 | 13 | #### 2. Training 14 | ``` shell 15 | python train.py 16 | ``` 17 | 18 | #### 3. Evaluation 19 | ```shell 20 | ./eval.sh 21 | ``` 22 | 23 | ### Results 24 | #### 1. Audio samples 25 | clb -> dbl 26 | ``` 27 | ./samples 28 | ``` 29 | #### 2. Alignments 30 | ![alignments](https://github.com/vBaiCai/vc_tacotron/raw/master/figs/align.png) 31 | 32 | ## Reference 33 | 34 | * [Tacotron: Towards End-to-End Speech Synthesis](https://arxiv.org/pdf/1703.10135.pdf), 35 | 36 | * [keithito's tacotron implementation](https://github.com/keithito/tacotron) 37 | * [cmu_arctic dataset](http://festvox.org/cmu_arctic/) -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2017 Keith Ito 2 | 3 | Permission is hereby granted, free of charge, to any person obtaining a copy 4 | of this software and associated documentation files (the "Software"), to deal 5 | in the Software without restriction, including without limitation the rights 6 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 7 | copies of the Software, and to permit persons to whom the Software is 8 | furnished to do so, subject to the following conditions: 9 | 10 | The above copyright notice and this permission notice shall be included in 11 | all copies or substantial portions of the Software. 12 | 13 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 14 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 16 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 18 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 19 | THE SOFTWARE. 20 | -------------------------------------------------------------------------------- /tests/cmudict_test.py: -------------------------------------------------------------------------------- 1 | import io 2 | from text import cmudict 3 | 4 | 5 | test_data = ''' 6 | ;;; # CMUdict -- Major Version: 0.07 7 | )PAREN P ER EH N 8 | 'TIS T IH Z 9 | ADVERSE AE0 D V ER1 S 10 | ADVERSE(1) AE1 D V ER2 S 11 | ADVERSE(2) AE2 D V ER1 S 12 | ADVERSELY AE0 D V ER1 S L IY0 13 | ADVERSITY AE0 D V ER1 S IH0 T IY2 14 | BARBERSHOP B AA1 R B ER0 SH AA2 P 15 | YOU'LL Y UW1 L 16 | ''' 17 | 18 | 19 | def test_cmudict(): 20 | c = cmudict.CMUDict(io.StringIO(test_data)) 21 | assert len(c) == 6 22 | assert len(cmudict.valid_symbols) == 84 23 | assert c.lookup('ADVERSITY') == ['AE0 D V ER1 S IH0 T IY2'] 24 | assert c.lookup('BarberShop') == ['B AA1 R B ER0 SH AA2 P'] 25 | assert c.lookup("You'll") == ['Y UW1 L'] 26 | assert c.lookup("'tis") == ['T IH Z'] 27 | assert c.lookup('adverse') == [ 28 | 'AE0 D V ER1 S', 29 | 'AE1 D V ER2 S', 30 | 'AE2 D V ER1 S', 31 | ] 32 | assert c.lookup('') == None 33 | assert c.lookup('foo') == None 34 | assert c.lookup(')paren') == None 35 | 36 | 37 | def test_cmudict_no_keep_ambiguous(): 38 | c = cmudict.CMUDict(io.StringIO(test_data), keep_ambiguous=False) 39 | assert len(c) == 5 40 | assert c.lookup('adversity') == ['AE0 D V ER1 S IH0 T IY2'] 41 | assert c.lookup('adverse') == None 42 | -------------------------------------------------------------------------------- /hparams.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | 3 | 4 | # Default hyperparameters: 5 | hparams = tf.contrib.training.HParams( 6 | # Comma-separated list of cleaners to run on text prior to training and eval. For non-English 7 | # text, you may want to use "basic_cleaners" or "transliteration_cleaners" See TRAINING_DATA.md. 8 | cleaners='english_cleaners', 9 | 10 | # Audio: 11 | num_mels=80, 12 | num_freq=800, 13 | sample_rate=16000, 14 | frame_length_ms=50, 15 | frame_shift_ms=12.5, 16 | preemphasis=0.97, 17 | min_level_db=-100, 18 | ref_level_db=20, 19 | 20 | # Model: 21 | outputs_per_step=2, 22 | prenet_depths=[256, 128], 23 | encoder_depth=256, 24 | postnet_depth=256, 25 | attention_depth=256, 26 | decoder_depth=256, 27 | 28 | # Training: 29 | batch_size=64, 30 | adam_beta1=0.9, 31 | adam_beta2=0.999, 32 | initial_learning_rate=0.002, 33 | decay_learning_rate=True, 34 | use_cmudict=False, # Use CMUDict during training to learn pronunciation of ARPAbet phonemes 35 | 36 | # Eval: 37 | max_iters=230, 38 | griffin_lim_iters=80, 39 | power=1.5, # Power to raise magnitudes to prior to Griffin-Lim 40 | ) 41 | 42 | 43 | def hparams_debug_string(): 44 | values = hparams.values() 45 | hp = [' %s: %s' % (name, values[name]) for name in sorted(values)] 46 | return 'Hyperparameters:\n' + '\n'.join(hp) 47 | -------------------------------------------------------------------------------- /util/infolog.py: -------------------------------------------------------------------------------- 1 | import atexit 2 | from datetime import datetime 3 | import json 4 | from threading import Thread 5 | from urllib.request import Request, urlopen 6 | 7 | 8 | _format = '%Y-%m-%d %H:%M:%S.%f' 9 | _file = None 10 | _run_name = None 11 | _slack_url = None 12 | 13 | 14 | def init(filename, run_name, slack_url=None): 15 | global _file, _run_name, _slack_url 16 | _close_logfile() 17 | _file = open(filename, 'a', encoding="utf-8") 18 | _file.write('\n-----------------------------------------------------------------\n') 19 | _file.write('Starting new training run\n') 20 | _file.write('-----------------------------------------------------------------\n') 21 | _run_name = run_name 22 | _slack_url = slack_url 23 | 24 | 25 | def log(msg, slack=False): 26 | print(msg) 27 | if _file is not None: 28 | _file.write('[%s] %s\n' % (datetime.now().strftime(_format)[:-3], msg)) 29 | if slack and _slack_url is not None: 30 | Thread(target=_send_slack, args=(msg,)).start() 31 | 32 | 33 | def _close_logfile(): 34 | global _file 35 | if _file is not None: 36 | _file.close() 37 | _file = None 38 | 39 | 40 | def _send_slack(msg): 41 | req = Request(_slack_url) 42 | req.add_header('Content-Type', 'application/json') 43 | urlopen(req, json.dumps({ 44 | 'username': 'tacotron', 45 | 'icon_emoji': ':taco:', 46 | 'text': '*%s*: %s' % (_run_name, msg) 47 | }).encode()) 48 | 49 | 50 | atexit.register(_close_logfile) 51 | -------------------------------------------------------------------------------- /download_data.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | #download dataset 4 | wget http://festvox.org/cmu_arctic/cmu_arctic/packed/cmu_us_bdl_arctic-0.95-release.zip -P /tmp 5 | wget http://festvox.org/cmu_arctic/cmu_arctic/packed/cmu_us_clb_arctic-0.95-release.zip -P /tmp 6 | # wget http://festvox.org/cmu_arctic/cmu_arctic/packed/cmu_us_rms_arctic-0.95-release.zip -P /tmp 7 | # wget http://festvox.org/cmu_arctic/cmu_arctic/packed/cmu_us_slt_arctic-0.95-release.zip -P /tmp 8 | 9 | #unzip 10 | unzip -q /tmp/cmu_us_bdl_arctic-0.95-release.zip -d /tmp/bdl 11 | unzip -q /tmp/cmu_us_clb_arctic-0.95-release.zip -d /tmp/clb 12 | # unzip -q /tmp/cmu_us_rms_arctic-0.95-release.zip -d /tmp/rms 13 | # unzip -q /tmp/cmu_us_slt_arctic-0.95-release.zip -d /tmp/slt 14 | 15 | repo=$PWD 16 | 17 | # process bdl 18 | cd /tmp/bdl/cmu_us_bdl_arctic/wav 19 | for f in `ls`; 20 | do 21 | new_name="bdl_$f" 22 | mv $f $new_name 23 | done 24 | 25 | # process clb 26 | cd /tmp/clb/cmu_us_clb_arctic/wav 27 | for f in `ls`; 28 | do 29 | new_name="clb_$f" 30 | mv $f $new_name 31 | done 32 | 33 | # return repo dir 34 | cd $repo 35 | 36 | cp "/tmp/clb/cmu_us_clb_arctic/wav/"* "parallel_data/wavs/" 37 | cp "/tmp/bdl/cmu_us_bdl_arctic/wav/"* "parallel_data/wavs/" 38 | 39 | ls "parallel_data/wavs"|grep "clb"|tail -n +101|sort > /tmp/source.txt 40 | ls "parallel_data/wavs"|grep "bdl"|tail -n +101|sort > /tmp/target.txt 41 | 42 | ls "parallel_data/wavs"|grep "clb"|head -n 100|sort > "parallel_data/test.lst" 43 | paste -d\| /tmp/source.txt /tmp/target.txt > "parallel_data/metadata.csv" 44 | 45 | -------------------------------------------------------------------------------- /synthesizer.py: -------------------------------------------------------------------------------- 1 | import io 2 | import numpy as np 3 | import tensorflow as tf 4 | from hparams import hparams 5 | from librosa import effects 6 | from models import create_model 7 | from text import text_to_sequence 8 | from util import audio 9 | import soundfile as sf 10 | 11 | 12 | class Synthesizer: 13 | def load(self, checkpoint_path, model_name='tacotron'): 14 | print('Constructing model: %s' % model_name) 15 | inputs = tf.placeholder(tf.float32, [1, None, hparams.num_mels], 'inputs') 16 | input_lengths = tf.placeholder(tf.int32, [1], 'input_lengths') 17 | with tf.variable_scope('model') as scope: 18 | self.model = create_model(model_name, hparams) 19 | self.model.initialize(inputs, input_lengths) 20 | self.wav_output = audio.inv_spectrogram_tensorflow(self.model.linear_outputs[0]) 21 | 22 | print('Loading checkpoint: %s' % checkpoint_path) 23 | self.session = tf.Session() 24 | self.session.run(tf.global_variables_initializer()) 25 | saver = tf.train.Saver() 26 | saver.restore(self.session, checkpoint_path) 27 | 28 | 29 | def synthesize(self, input_path): 30 | s, sr = sf.read(input_path) 31 | spec = audio.melspectrogram(s).astype(np.float32).T 32 | 33 | feed_dict = { 34 | self.model.inputs: [np.asarray(spec, dtype=np.float32)], 35 | self.model.input_lengths: np.asarray([spec.shape[0]], dtype=np.int32) 36 | } 37 | wav = self.session.run(self.wav_output, feed_dict=feed_dict) 38 | wav = audio.inv_preemphasis(wav) 39 | wav = wav[:audio.find_endpoint(wav)] 40 | out = io.BytesIO() 41 | audio.save_wav(wav, out) 42 | return out.getvalue() 43 | -------------------------------------------------------------------------------- /preprocess.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import os 3 | from multiprocessing import cpu_count 4 | from tqdm import tqdm 5 | from datasets import vc 6 | from hparams import hparams 7 | from functools import partial 8 | import numpy as np 9 | from util import audio 10 | 11 | 12 | def preprocess_vc(args): 13 | metas = [] 14 | with open(os.path.join(args.data_dir, 'metadata.csv')) as f: 15 | for line in f: 16 | metas.append(line.strip('\n').strip().split('|')) 17 | 18 | in_dir = os.path.join(args.base_dir, args.data_dir, 'wavs') 19 | out_dir = os.path.join(args.base_dir, args.output) 20 | os.makedirs(out_dir, exist_ok=True) 21 | metadata = vc.build_from_path(metas, in_dir, out_dir, args.num_workers, tqdm=tqdm) 22 | print('len(metadata)',len(metadata)) 23 | write_metadata(metadata, out_dir) 24 | 25 | 26 | def write_metadata(metadata, out_dir): 27 | with open(os.path.join(out_dir, 'train.txt'), 'w', encoding='utf-8') as f: 28 | for m in metadata: 29 | f.write('|'.join([str(x) for x in m]) + '\n') 30 | 31 | frames = sum([m[1] for m in metadata]) 32 | hours = frames * hparams.frame_shift_ms / (3600 * 1000) 33 | print('Wrote %d utterances, %d frames (%.2f hours)' % (len(metadata), frames, hours)) 34 | #print('Max input length: %d' % max(len(m[3]) for m in metadata)) 35 | print('Max output length: %d' % max([m[1] for m in metadata])) 36 | 37 | 38 | def main(): 39 | parser = argparse.ArgumentParser() 40 | parser.add_argument('--base_dir', default=os.path.expanduser('.')) 41 | parser.add_argument('--data_dir', default=os.path.expanduser('parallel_data')) 42 | parser.add_argument('--output', default='training') 43 | # parser.add_argument('--dataset', required=True, choices=['mg', 'we']) 44 | parser.add_argument('--num_workers', type=int, default=cpu_count()) 45 | args = parser.parse_args() 46 | preprocess_vc(args) 47 | 48 | 49 | if __name__ == "__main__": 50 | main() 51 | -------------------------------------------------------------------------------- /models/rnn_wrappers.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import tensorflow as tf 3 | from tensorflow.contrib.rnn import RNNCell 4 | from .modules import prenet 5 | 6 | 7 | class DecoderPrenetWrapper(RNNCell): 8 | '''Runs RNN inputs through a prenet before sending them to the cell.''' 9 | def __init__(self, cell, is_training, layer_sizes): 10 | super(DecoderPrenetWrapper, self).__init__() 11 | self._cell = cell 12 | self._is_training = is_training 13 | self._layer_sizes = layer_sizes 14 | 15 | @property 16 | def state_size(self): 17 | return self._cell.state_size 18 | 19 | @property 20 | def output_size(self): 21 | return self._cell.output_size 22 | 23 | def call(self, inputs, state): 24 | prenet_out = prenet(inputs, self._is_training, self._layer_sizes, scope='decoder_prenet') 25 | return self._cell(prenet_out, state) 26 | 27 | def zero_state(self, batch_size, dtype): 28 | return self._cell.zero_state(batch_size, dtype) 29 | 30 | 31 | 32 | class ConcatOutputAndAttentionWrapper(RNNCell): 33 | '''Concatenates RNN cell output with the attention context vector. 34 | 35 | This is expected to wrap a cell wrapped with an AttentionWrapper constructed with 36 | attention_layer_size=None and output_attention=False. Such a cell's state will include an 37 | "attention" field that is the context vector. 38 | ''' 39 | def __init__(self, cell): 40 | super(ConcatOutputAndAttentionWrapper, self).__init__() 41 | self._cell = cell 42 | 43 | @property 44 | def state_size(self): 45 | return self._cell.state_size 46 | 47 | @property 48 | def output_size(self): 49 | return self._cell.output_size + self._cell.state_size.attention 50 | 51 | def call(self, inputs, state): 52 | output, res_state = self._cell(inputs, state) 53 | return tf.concat([output, res_state.attention], axis=-1), res_state 54 | 55 | def zero_state(self, batch_size, dtype): 56 | return self._cell.zero_state(batch_size, dtype) 57 | -------------------------------------------------------------------------------- /eval.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import os 3 | import re 4 | from hparams import hparams, hparams_debug_string 5 | from synthesizer import Synthesizer 6 | 7 | 8 | sentences = [ 9 | # From July 8, 2017 New York Times: 10 | 'Scientists at the CERN laboratory say they have discovered a new particle.', 11 | 'There’s a way to measure the acute emotional intelligence that has never gone out of style.', 12 | 'President Trump met with other leaders at the Group of 20 conference.', 13 | 'The Senate\'s bill to repeal and replace the Affordable Care Act is now imperiled.', 14 | # From Google's Tacotron example page: 15 | 'Generative adversarial network or variational auto-encoder.', 16 | 'The buses aren\'t the problem, they actually provide a solution.', 17 | 'Does the quick brown fox jump over the lazy dog?', 18 | 'Talib Kweli confirmed to AllHipHop that he will be releasing an album in the next year.', 19 | ] 20 | 21 | 22 | def get_output_base_path(checkpoint_path): 23 | base_dir = os.path.dirname(checkpoint_path) 24 | m = re.compile(r'.*?\.ckpt\-([0-9]+)').match(checkpoint_path) 25 | name = 'eval-%d' % int(m.group(1)) if m else 'eval' 26 | return os.path.join(base_dir, name) 27 | 28 | 29 | def run_eval(args): 30 | print(hparams_debug_string()) 31 | synth = Synthesizer() 32 | synth.load(args.checkpoint) 33 | base_path = get_output_base_path(args.checkpoint) 34 | with open('{}-eval.wav'.format(args.ref.split('/')[-1].replace('.wav', '')), 'wb') as f: 35 | f.write(synth.synthesize(args.ref)) 36 | 37 | 38 | def main(): 39 | parser = argparse.ArgumentParser() 40 | parser.add_argument('--checkpoint', required=True, help='Path to model checkpoint') 41 | parser.add_argument('--ref', required=True, help='Path to ref audio') 42 | parser.add_argument('--hparams', default='', 43 | help='Hyperparameter overrides as a comma-separated list of name=value pairs') 44 | args = parser.parse_args() 45 | hparams.parse(args.hparams) 46 | run_eval(args) 47 | 48 | 49 | if __name__ == '__main__': 50 | main() 51 | -------------------------------------------------------------------------------- /text/cmudict.py: -------------------------------------------------------------------------------- 1 | import re 2 | 3 | 4 | valid_symbols = [ 5 | 'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1', 'AH2', 6 | 'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0', 'AY1', 'AY2', 7 | 'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0', 'ER1', 'ER2', 'EY', 8 | 'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0', 'IH1', 'IH2', 'IY', 'IY0', 'IY1', 9 | 'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0', 10 | 'OY1', 'OY2', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW', 11 | 'UW0', 'UW1', 'UW2', 'V', 'W', 'Y', 'Z', 'ZH' 12 | ] 13 | 14 | _valid_symbol_set = set(valid_symbols) 15 | 16 | 17 | class CMUDict: 18 | '''Thin wrapper around CMUDict data. http://www.speech.cs.cmu.edu/cgi-bin/cmudict''' 19 | def __init__(self, file_or_path, keep_ambiguous=True): 20 | if isinstance(file_or_path, str): 21 | with open(file_or_path, encoding='latin-1') as f: 22 | entries = _parse_cmudict(f) 23 | else: 24 | entries = _parse_cmudict(file_or_path) 25 | if not keep_ambiguous: 26 | entries = {word: pron for word, pron in entries.items() if len(pron) == 1} 27 | self._entries = entries 28 | 29 | 30 | def __len__(self): 31 | return len(self._entries) 32 | 33 | 34 | def lookup(self, word): 35 | '''Returns list of ARPAbet pronunciations of the given word.''' 36 | return self._entries.get(word.upper()) 37 | 38 | 39 | 40 | _alt_re = re.compile(r'\([0-9]+\)') 41 | 42 | 43 | def _parse_cmudict(file): 44 | cmudict = {} 45 | for line in file: 46 | if len(line) and (line[0] >= 'A' and line[0] <= 'Z' or line[0] == "'"): 47 | parts = line.split(' ') 48 | word = re.sub(_alt_re, '', parts[0]) 49 | pronunciation = _get_pronunciation(parts[1]) 50 | if pronunciation: 51 | if word in cmudict: 52 | cmudict[word].append(pronunciation) 53 | else: 54 | cmudict[word] = [pronunciation] 55 | return cmudict 56 | 57 | 58 | def _get_pronunciation(s): 59 | parts = s.strip().split(' ') 60 | for part in parts: 61 | if part not in _valid_symbol_set: 62 | return None 63 | return ' '.join(parts) 64 | -------------------------------------------------------------------------------- /tests/text_test.py: -------------------------------------------------------------------------------- 1 | from text import cleaners, symbols, text_to_sequence, sequence_to_text 2 | from unidecode import unidecode 3 | 4 | 5 | def test_symbols(): 6 | assert len(symbols) >= 3 7 | assert symbols[0] == '_' 8 | assert symbols[1] == '~' 9 | 10 | 11 | def test_text_to_sequence(): 12 | assert text_to_sequence('', []) == [1] 13 | assert text_to_sequence('Hi!', []) == [9, 36, 54, 1] 14 | assert text_to_sequence('"A"_B', []) == [2, 3, 1] 15 | assert text_to_sequence('A {AW1 S} B', []) == [2, 64, 83, 132, 64, 3, 1] 16 | assert text_to_sequence('Hi', ['lowercase']) == [35, 36, 1] 17 | assert text_to_sequence('A {AW1 S} B', ['english_cleaners']) == [28, 64, 83, 132, 64, 29, 1] 18 | 19 | 20 | def test_sequence_to_text(): 21 | assert sequence_to_text([]) == '' 22 | assert sequence_to_text([1]) == '~' 23 | assert sequence_to_text([9, 36, 54, 1]) == 'Hi!~' 24 | assert sequence_to_text([2, 64, 83, 132, 64, 3]) == 'A {AW1 S} B' 25 | 26 | 27 | def test_collapse_whitespace(): 28 | assert cleaners.collapse_whitespace('') == '' 29 | assert cleaners.collapse_whitespace(' ') == ' ' 30 | assert cleaners.collapse_whitespace('x') == 'x' 31 | assert cleaners.collapse_whitespace(' x. y, \tz') == ' x. y, z' 32 | 33 | 34 | def test_convert_to_ascii(): 35 | assert cleaners.convert_to_ascii("raison d'être") == "raison d'etre" 36 | assert cleaners.convert_to_ascii('grüß gott') == 'gruss gott' 37 | assert cleaners.convert_to_ascii('안녕') == 'annyeong' 38 | assert cleaners.convert_to_ascii('Здравствуйте') == 'Zdravstvuite' 39 | 40 | 41 | def test_lowercase(): 42 | assert cleaners.lowercase('Happy Birthday!') == 'happy birthday!' 43 | assert cleaners.lowercase('CAFÉ') == 'café' 44 | 45 | 46 | def test_expand_abbreviations(): 47 | assert cleaners.expand_abbreviations('mr. and mrs. smith') == 'mister and misess smith' 48 | 49 | 50 | def test_expand_numbers(): 51 | assert cleaners.expand_numbers('3 apples and 44 pears') == 'three apples and forty-four pears' 52 | assert cleaners.expand_numbers('$3.50 for gas.') == 'three dollars, fifty cents for gas.' 53 | 54 | 55 | def test_cleaner_pipelines(): 56 | text = 'Mr. Müller ate 2 Apples' 57 | assert cleaners.english_cleaners(text) == 'mister muller ate two apples' 58 | assert cleaners.transliteration_cleaners(text) == 'mr. muller ate 2 apples' 59 | assert cleaners.basic_cleaners(text) == 'mr. müller ate 2 apples' 60 | 61 | -------------------------------------------------------------------------------- /text/numbers.py: -------------------------------------------------------------------------------- 1 | import inflect 2 | import re 3 | 4 | 5 | _inflect = inflect.engine() 6 | _comma_number_re = re.compile(r'([0-9][0-9\,]+[0-9])') 7 | _decimal_number_re = re.compile(r'([0-9]+\.[0-9]+)') 8 | _pounds_re = re.compile(r'£([0-9\,]*[0-9]+)') 9 | _dollars_re = re.compile(r'\$([0-9\.\,]*[0-9]+)') 10 | _ordinal_re = re.compile(r'[0-9]+(st|nd|rd|th)') 11 | _number_re = re.compile(r'[0-9]+') 12 | 13 | 14 | def _remove_commas(m): 15 | return m.group(1).replace(',', '') 16 | 17 | 18 | def _expand_decimal_point(m): 19 | return m.group(1).replace('.', ' point ') 20 | 21 | 22 | def _expand_dollars(m): 23 | match = m.group(1) 24 | parts = match.split('.') 25 | if len(parts) > 2: 26 | return match + ' dollars' # Unexpected format 27 | dollars = int(parts[0]) if parts[0] else 0 28 | cents = int(parts[1]) if len(parts) > 1 and parts[1] else 0 29 | if dollars and cents: 30 | dollar_unit = 'dollar' if dollars == 1 else 'dollars' 31 | cent_unit = 'cent' if cents == 1 else 'cents' 32 | return '%s %s, %s %s' % (dollars, dollar_unit, cents, cent_unit) 33 | elif dollars: 34 | dollar_unit = 'dollar' if dollars == 1 else 'dollars' 35 | return '%s %s' % (dollars, dollar_unit) 36 | elif cents: 37 | cent_unit = 'cent' if cents == 1 else 'cents' 38 | return '%s %s' % (cents, cent_unit) 39 | else: 40 | return 'zero dollars' 41 | 42 | 43 | def _expand_ordinal(m): 44 | return _inflect.number_to_words(m.group(0)) 45 | 46 | 47 | def _expand_number(m): 48 | num = int(m.group(0)) 49 | if num > 1000 and num < 3000: 50 | if num == 2000: 51 | return 'two thousand' 52 | elif num > 2000 and num < 2010: 53 | return 'two thousand ' + _inflect.number_to_words(num % 100) 54 | elif num % 100 == 0: 55 | return _inflect.number_to_words(num // 100) + ' hundred' 56 | else: 57 | return _inflect.number_to_words(num, andword='', zero='oh', group=2).replace(', ', ' ') 58 | else: 59 | return _inflect.number_to_words(num, andword='') 60 | 61 | 62 | def normalize_numbers(text): 63 | text = re.sub(_comma_number_re, _remove_commas, text) 64 | text = re.sub(_pounds_re, r'\1 pounds', text) 65 | text = re.sub(_dollars_re, _expand_dollars, text) 66 | text = re.sub(_decimal_number_re, _expand_decimal_point, text) 67 | text = re.sub(_ordinal_re, _expand_ordinal, text) 68 | text = re.sub(_number_re, _expand_number, text) 69 | return text 70 | -------------------------------------------------------------------------------- /text/__init__.py: -------------------------------------------------------------------------------- 1 | import re 2 | from text import cleaners 3 | from text.symbols import symbols 4 | 5 | 6 | # Mappings from symbol to numeric ID and vice versa: 7 | _symbol_to_id = {s: i for i, s in enumerate(symbols)} 8 | _id_to_symbol = {i: s for i, s in enumerate(symbols)} 9 | 10 | # Regular expression matching text enclosed in curly braces: 11 | _curly_re = re.compile(r'(.*?)\{(.+?)\}(.*)') 12 | 13 | 14 | def text_to_sequence(text, cleaner_names): 15 | '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text. 16 | 17 | The text can optionally have ARPAbet sequences enclosed in curly braces embedded 18 | in it. For example, "Turn left on {HH AW1 S S T AH0 N} Street." 19 | 20 | Args: 21 | text: string to convert to a sequence 22 | cleaner_names: names of the cleaner functions to run the text through 23 | 24 | Returns: 25 | List of integers corresponding to the symbols in the text 26 | ''' 27 | sequence = [] 28 | 29 | # Check for curly braces and treat their contents as ARPAbet: 30 | while len(text): 31 | m = _curly_re.match(text) 32 | if not m: 33 | sequence += _symbols_to_sequence(_clean_text(text, cleaner_names)) 34 | break 35 | sequence += _symbols_to_sequence(_clean_text(m.group(1), cleaner_names)) 36 | sequence += _arpabet_to_sequence(m.group(2)) 37 | text = m.group(3) 38 | 39 | # Append EOS token 40 | sequence.append(_symbol_to_id['~']) 41 | return sequence 42 | 43 | 44 | def sequence_to_text(sequence): 45 | '''Converts a sequence of IDs back to a string''' 46 | result = '' 47 | for symbol_id in sequence: 48 | if symbol_id in _id_to_symbol: 49 | s = _id_to_symbol[symbol_id] 50 | # Enclose ARPAbet back in curly braces: 51 | if len(s) > 1 and s[0] == '@': 52 | s = '{%s}' % s[1:] 53 | result += s 54 | return result.replace('}{', ' ') 55 | 56 | 57 | def _clean_text(text, cleaner_names): 58 | for name in cleaner_names: 59 | cleaner = getattr(cleaners, name) 60 | if not cleaner: 61 | raise Exception('Unknown cleaner: %s' % name) 62 | text = cleaner(text) 63 | return text 64 | 65 | 66 | def _symbols_to_sequence(symbols): 67 | return [_symbol_to_id[s] for s in symbols if _should_keep_symbol(s)] 68 | 69 | 70 | def _arpabet_to_sequence(text): 71 | return _symbols_to_sequence(['@' + s for s in text.split()]) 72 | 73 | 74 | def _should_keep_symbol(s): 75 | return s in _symbol_to_id and s is not '_' and s is not '~' 76 | -------------------------------------------------------------------------------- /tests/numbers_test.py: -------------------------------------------------------------------------------- 1 | from text.numbers import normalize_numbers 2 | 3 | 4 | def test_normalize_numbers(): 5 | assert normalize_numbers('1') == 'one' 6 | assert normalize_numbers('15') == 'fifteen' 7 | assert normalize_numbers('24') == 'twenty-four' 8 | assert normalize_numbers('100') == 'one hundred' 9 | assert normalize_numbers('101') == 'one hundred one' 10 | assert normalize_numbers('456') == 'four hundred fifty-six' 11 | assert normalize_numbers('1000') == 'one thousand' 12 | assert normalize_numbers('1800') == 'eighteen hundred' 13 | assert normalize_numbers('2,000') == 'two thousand' 14 | assert normalize_numbers('3000') == 'three thousand' 15 | assert normalize_numbers('18000') == 'eighteen thousand' 16 | assert normalize_numbers('24,000') == 'twenty-four thousand' 17 | assert normalize_numbers('124,001') == 'one hundred twenty-four thousand one' 18 | assert normalize_numbers('6.4 sec') == 'six point four sec' 19 | 20 | 21 | def test_normalize_ordinals(): 22 | assert normalize_numbers('1st') == 'first' 23 | assert normalize_numbers('2nd') == 'second' 24 | assert normalize_numbers('9th') == 'ninth' 25 | assert normalize_numbers('243rd place') == 'two hundred and forty-third place' 26 | 27 | 28 | def test_normalize_dates(): 29 | assert normalize_numbers('1400') == 'fourteen hundred' 30 | assert normalize_numbers('1901') == 'nineteen oh one' 31 | assert normalize_numbers('1999') == 'nineteen ninety-nine' 32 | assert normalize_numbers('2000') == 'two thousand' 33 | assert normalize_numbers('2004') == 'two thousand four' 34 | assert normalize_numbers('2010') == 'twenty ten' 35 | assert normalize_numbers('2012') == 'twenty twelve' 36 | assert normalize_numbers('2025') == 'twenty twenty-five' 37 | assert normalize_numbers('September 11, 2001') == 'September eleven, two thousand one' 38 | assert normalize_numbers('July 26, 1984.') == 'July twenty-six, nineteen eighty-four.' 39 | 40 | 41 | def test_normalize_money(): 42 | assert normalize_numbers('$0.00') == 'zero dollars' 43 | assert normalize_numbers('$1') == 'one dollar' 44 | assert normalize_numbers('$10') == 'ten dollars' 45 | assert normalize_numbers('$.01') == 'one cent' 46 | assert normalize_numbers('$0.25') == 'twenty-five cents' 47 | assert normalize_numbers('$5.00') == 'five dollars' 48 | assert normalize_numbers('$5.01') == 'five dollars, one cent' 49 | assert normalize_numbers('$135.99.') == 'one hundred thirty-five dollars, ninety-nine cents.' 50 | assert normalize_numbers('$40,000') == 'forty thousand dollars' 51 | assert normalize_numbers('for £2500!') == 'for twenty-five hundred pounds!' 52 | -------------------------------------------------------------------------------- /parallel_data/test.lst: -------------------------------------------------------------------------------- 1 | clb_arctic_a0001.wav 2 | clb_arctic_a0002.wav 3 | clb_arctic_a0003.wav 4 | clb_arctic_a0004.wav 5 | clb_arctic_a0005.wav 6 | clb_arctic_a0006.wav 7 | clb_arctic_a0007.wav 8 | clb_arctic_a0008.wav 9 | clb_arctic_a0009.wav 10 | clb_arctic_a0010.wav 11 | clb_arctic_a0011.wav 12 | clb_arctic_a0012.wav 13 | clb_arctic_a0013.wav 14 | clb_arctic_a0014.wav 15 | clb_arctic_a0015.wav 16 | clb_arctic_a0016.wav 17 | clb_arctic_a0017.wav 18 | clb_arctic_a0018.wav 19 | clb_arctic_a0019.wav 20 | clb_arctic_a0020.wav 21 | clb_arctic_a0021.wav 22 | clb_arctic_a0022.wav 23 | clb_arctic_a0023.wav 24 | clb_arctic_a0024.wav 25 | clb_arctic_a0025.wav 26 | clb_arctic_a0026.wav 27 | clb_arctic_a0027.wav 28 | clb_arctic_a0028.wav 29 | clb_arctic_a0029.wav 30 | clb_arctic_a0030.wav 31 | clb_arctic_a0031.wav 32 | clb_arctic_a0032.wav 33 | clb_arctic_a0033.wav 34 | clb_arctic_a0034.wav 35 | clb_arctic_a0035.wav 36 | clb_arctic_a0036.wav 37 | clb_arctic_a0037.wav 38 | clb_arctic_a0038.wav 39 | clb_arctic_a0039.wav 40 | clb_arctic_a0040.wav 41 | clb_arctic_a0041.wav 42 | clb_arctic_a0042.wav 43 | clb_arctic_a0043.wav 44 | clb_arctic_a0044.wav 45 | clb_arctic_a0045.wav 46 | clb_arctic_a0046.wav 47 | clb_arctic_a0047.wav 48 | clb_arctic_a0048.wav 49 | clb_arctic_a0049.wav 50 | clb_arctic_a0050.wav 51 | clb_arctic_a0051.wav 52 | clb_arctic_a0052.wav 53 | clb_arctic_a0053.wav 54 | clb_arctic_a0054.wav 55 | clb_arctic_a0055.wav 56 | clb_arctic_a0056.wav 57 | clb_arctic_a0057.wav 58 | clb_arctic_a0058.wav 59 | clb_arctic_a0059.wav 60 | clb_arctic_a0060.wav 61 | clb_arctic_a0061.wav 62 | clb_arctic_a0062.wav 63 | clb_arctic_a0063.wav 64 | clb_arctic_a0064.wav 65 | clb_arctic_a0065.wav 66 | clb_arctic_a0066.wav 67 | clb_arctic_a0067.wav 68 | clb_arctic_a0068.wav 69 | clb_arctic_a0069.wav 70 | clb_arctic_a0070.wav 71 | clb_arctic_a0071.wav 72 | clb_arctic_a0072.wav 73 | clb_arctic_a0073.wav 74 | clb_arctic_a0074.wav 75 | clb_arctic_a0075.wav 76 | clb_arctic_a0076.wav 77 | clb_arctic_a0077.wav 78 | clb_arctic_a0078.wav 79 | clb_arctic_a0079.wav 80 | clb_arctic_a0080.wav 81 | clb_arctic_a0081.wav 82 | clb_arctic_a0082.wav 83 | clb_arctic_a0083.wav 84 | clb_arctic_a0084.wav 85 | clb_arctic_a0085.wav 86 | clb_arctic_a0086.wav 87 | clb_arctic_a0087.wav 88 | clb_arctic_a0088.wav 89 | clb_arctic_a0089.wav 90 | clb_arctic_a0090.wav 91 | clb_arctic_a0091.wav 92 | clb_arctic_a0092.wav 93 | clb_arctic_a0093.wav 94 | clb_arctic_a0094.wav 95 | clb_arctic_a0095.wav 96 | clb_arctic_a0096.wav 97 | clb_arctic_a0097.wav 98 | clb_arctic_a0098.wav 99 | clb_arctic_a0099.wav 100 | clb_arctic_a0100.wav 101 | -------------------------------------------------------------------------------- /text/cleaners.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Cleaners are transformations that run over the input text at both training and eval time. 3 | 4 | Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners" 5 | hyperparameter. Some cleaners are English-specific. You'll typically want to use: 6 | 1. "english_cleaners" for English text 7 | 2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using 8 | the Unidecode library (https://pypi.python.org/pypi/Unidecode) 9 | 3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update 10 | the symbols in symbols.py to match your data). 11 | ''' 12 | 13 | import re 14 | from unidecode import unidecode 15 | from .numbers import normalize_numbers 16 | 17 | 18 | # Regular expression matching whitespace: 19 | _whitespace_re = re.compile(r'\s+') 20 | 21 | # List of (regular expression, replacement) pairs for abbreviations: 22 | _abbreviations = [(re.compile('\\b%s\\.' % x[0], re.IGNORECASE), x[1]) for x in [ 23 | ('mrs', 'misess'), 24 | ('mr', 'mister'), 25 | ('dr', 'doctor'), 26 | ('st', 'saint'), 27 | ('co', 'company'), 28 | ('jr', 'junior'), 29 | ('maj', 'major'), 30 | ('gen', 'general'), 31 | ('drs', 'doctors'), 32 | ('rev', 'reverend'), 33 | ('lt', 'lieutenant'), 34 | ('hon', 'honorable'), 35 | ('sgt', 'sergeant'), 36 | ('capt', 'captain'), 37 | ('esq', 'esquire'), 38 | ('ltd', 'limited'), 39 | ('col', 'colonel'), 40 | ('ft', 'fort'), 41 | ]] 42 | 43 | 44 | def expand_abbreviations(text): 45 | for regex, replacement in _abbreviations: 46 | text = re.sub(regex, replacement, text) 47 | return text 48 | 49 | 50 | def expand_numbers(text): 51 | return normalize_numbers(text) 52 | 53 | 54 | def lowercase(text): 55 | return text.lower() 56 | 57 | 58 | def collapse_whitespace(text): 59 | return re.sub(_whitespace_re, ' ', text) 60 | 61 | 62 | def convert_to_ascii(text): 63 | return unidecode(text) 64 | 65 | 66 | def basic_cleaners(text): 67 | '''Basic pipeline that lowercases and collapses whitespace without transliteration.''' 68 | text = lowercase(text) 69 | text = collapse_whitespace(text) 70 | return text 71 | 72 | 73 | def transliteration_cleaners(text): 74 | '''Pipeline for non-English text that transliterates to ASCII.''' 75 | text = convert_to_ascii(text) 76 | text = lowercase(text) 77 | text = collapse_whitespace(text) 78 | return text 79 | 80 | 81 | def english_cleaners(text): 82 | '''Pipeline for English text, including number and abbreviation expansion.''' 83 | text = convert_to_ascii(text) 84 | text = lowercase(text) 85 | text = expand_numbers(text) 86 | text = expand_abbreviations(text) 87 | text = collapse_whitespace(text) 88 | return text 89 | -------------------------------------------------------------------------------- /TRAINING_DATA.md: -------------------------------------------------------------------------------- 1 | # Training Data 2 | 3 | 4 | This repo supports the following speech datasets: 5 | * [LJ Speech](https://keithito.com/LJ-Speech-Dataset/) (Public Domain) 6 | * [Blizzard 2012](http://www.cstr.ed.ac.uk/projects/blizzard/2012/phase_one) (Creative Commons Attribution Share-Alike) 7 | 8 | You can use any other dataset if you write a preprocessor for it. 9 | 10 | 11 | ### Writing a Preprocessor 12 | 13 | Each training example consists of: 14 | 1. The text that was spoken 15 | 2. A mel-scale spectrogram of the audio 16 | 3. A linear-scale spectrogram of the audio 17 | 18 | The preprocessor is responsible for generating these. See [ljspeech.py](datasets/ljspeech.py) for a 19 | commented example. 20 | 21 | For each training example, a preprocessor should: 22 | 23 | 1. Load the audio file: 24 | ```python 25 | wav = audio.load_wav(wav_path) 26 | ``` 27 | 28 | 2. Compute linear-scale and mel-scale spectrograms (float32 numpy arrays): 29 | ```python 30 | spectrogram = audio.spectrogram(wav).astype(np.float32) 31 | mel_spectrogram = audio.melspectrogram(wav).astype(np.float32) 32 | ``` 33 | 34 | 3. Save the spectrograms to disk: 35 | ```python 36 | np.save(os.path.join(out_dir, spectrogram_filename), spectrogram.T, allow_pickle=False) 37 | np.save(os.path.join(out_dir, mel_spectrogram_filename), mel_spectrogram.T, allow_pickle=False) 38 | ``` 39 | Note that the transpose of the matrix returned by `audio.spectrogram` is saved so that it's 40 | in time-major format. 41 | 42 | 4. Generate a tuple `(spectrogram_filename, mel_spectrogram_filename, n_frames, text)` to 43 | write to train.txt. n_frames is just the length of the time axis of the spectrogram. 44 | 45 | 46 | After you've written your preprocessor, you can add it to [preprocess.py](preprocess.py) by 47 | following the example of the other preprocessors in that file. 48 | 49 | 50 | ### Non-English Data 51 | 52 | If your training data is in a language other than English, you will probably want to change the 53 | text cleaners by setting the `cleaners` hyperparameter. 54 | 55 | * If your text is in a Latin script or can be transliterated to ASCII using the 56 | [Unidecode](https://pypi.python.org/pypi/Unidecode) library, you can use the transliteration 57 | cleaners by setting the hyperparameter `cleaners=transliteration_cleaners`. 58 | 59 | * If you don't want to transliterate, you can define a custom character set. 60 | This allows you to train directly on the character set used in your data. 61 | 62 | To do so, edit [symbols.py](text/symbols.py) and change the `_characters` variable to be a 63 | string containing the UTF-8 characters in your data. Then set the hyperparameter `cleaners=basic_cleaners`. 64 | 65 | * If you're not sure which option to use, you can evaluate the transliteration cleaners like this: 66 | 67 | ```python 68 | from text import cleaners 69 | cleaners.transliteration_cleaners('Здравствуйте') # Replace with the text you want to try 70 | ``` 71 | -------------------------------------------------------------------------------- /models/helpers.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import tensorflow as tf 3 | from tensorflow.contrib.seq2seq import Helper 4 | 5 | 6 | # Adapted from tf.contrib.seq2seq.GreedyEmbeddingHelper 7 | class TacoTestHelper(Helper): 8 | def __init__(self, batch_size, output_dim, r): 9 | with tf.name_scope('TacoTestHelper'): 10 | self._batch_size = batch_size 11 | self._output_dim = output_dim 12 | self._end_token = tf.tile([0.0], [output_dim * r]) 13 | 14 | @property 15 | def batch_size(self): 16 | return self._batch_size 17 | 18 | @property 19 | def sample_ids_shape(self): 20 | return tf.TensorShape([]) 21 | 22 | @property 23 | def sample_ids_dtype(self): 24 | return np.int32 25 | 26 | def initialize(self, name=None): 27 | return (tf.tile([False], [self._batch_size]), _go_frames(self._batch_size, self._output_dim)) 28 | 29 | def sample(self, time, outputs, state, name=None): 30 | return tf.tile([0], [self._batch_size]) # Return all 0; we ignore them 31 | 32 | def next_inputs(self, time, outputs, state, sample_ids, name=None): 33 | '''Stop on EOS. Otherwise, pass the last output as the next input and pass through state.''' 34 | with tf.name_scope('TacoTestHelper'): 35 | finished = tf.reduce_all(tf.equal(outputs, self._end_token), axis=1) 36 | # Feed last output frame as next input. outputs is [N, output_dim * r] 37 | next_inputs = outputs[:, -self._output_dim:] 38 | return (finished, next_inputs, state) 39 | 40 | 41 | class TacoTrainingHelper(Helper): 42 | def __init__(self, inputs, targets, output_dim, r): 43 | # inputs is [N, T_in], targets is [N, T_out, D] 44 | with tf.name_scope('TacoTrainingHelper'): 45 | self._batch_size = tf.shape(inputs)[0] 46 | self._output_dim = output_dim 47 | 48 | # Feed every r-th target frame as input 49 | self._targets = targets[:, r-1::r, :] 50 | 51 | # Use full length for every target because we don't want to mask the padding frames 52 | num_steps = tf.shape(self._targets)[1] 53 | self._lengths = tf.tile([num_steps], [self._batch_size]) 54 | 55 | @property 56 | def batch_size(self): 57 | return self._batch_size 58 | 59 | @property 60 | def sample_ids_shape(self): 61 | return tf.TensorShape([]) 62 | 63 | @property 64 | def sample_ids_dtype(self): 65 | return np.int32 66 | 67 | def initialize(self, name=None): 68 | return (tf.tile([False], [self._batch_size]), _go_frames(self._batch_size, self._output_dim)) 69 | 70 | def sample(self, time, outputs, state, name=None): 71 | return tf.tile([0], [self._batch_size]) # Return all 0; we ignore them 72 | 73 | def next_inputs(self, time, outputs, state, sample_ids, name=None): 74 | with tf.name_scope(name or 'TacoTrainingHelper'): 75 | finished = (time + 1 >= self._lengths) 76 | next_inputs = self._targets[:, time, :] 77 | return (finished, next_inputs, state) 78 | 79 | 80 | def _go_frames(batch_size, output_dim): 81 | '''Returns all-zero frames for a given batch size and output dimension''' 82 | return tf.tile([[0.0]], [batch_size, output_dim]) 83 | 84 | -------------------------------------------------------------------------------- /demo_server.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | import falcon 3 | from hparams import hparams, hparams_debug_string 4 | import os 5 | from synthesizer import Synthesizer 6 | 7 | 8 | html_body = '''Demo 9 | 20 | 21 |
22 | 23 | 24 |
25 |

26 | 27 | 57 | ''' 58 | 59 | 60 | class UIResource: 61 | def on_get(self, req, res): 62 | res.content_type = 'text/html' 63 | res.body = html_body 64 | 65 | 66 | class SynthesisResource: 67 | def on_get(self, req, res): 68 | if not req.params.get('text'): 69 | raise falcon.HTTPBadRequest() 70 | res.data = synthesizer.synthesize(req.params.get('text')) 71 | res.content_type = 'audio/wav' 72 | 73 | 74 | synthesizer = Synthesizer() 75 | api = falcon.API() 76 | api.add_route('/synthesize', SynthesisResource()) 77 | api.add_route('/', UIResource()) 78 | 79 | 80 | if __name__ == '__main__': 81 | from wsgiref import simple_server 82 | parser = argparse.ArgumentParser() 83 | parser.add_argument('--checkpoint', required=True, help='Full path to model checkpoint') 84 | parser.add_argument('--port', type=int, default=9000) 85 | parser.add_argument('--hparams', default='', 86 | help='Hyperparameter overrides as a comma-separated list of name=value pairs') 87 | args = parser.parse_args() 88 | os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' 89 | hparams.parse(args.hparams) 90 | print(hparams_debug_string()) 91 | synthesizer.load(args.checkpoint) 92 | print('Serving on port %d' % args.port) 93 | simple_server.make_server('0.0.0.0', args.port, api).serve_forever() 94 | else: 95 | synthesizer.load(os.environ['CHECKPOINT']) 96 | -------------------------------------------------------------------------------- /datasets/vc.py: -------------------------------------------------------------------------------- 1 | from concurrent.futures import ProcessPoolExecutor 2 | from functools import partial 3 | import numpy as np 4 | import os 5 | from util import audio 6 | 7 | 8 | def build_from_path(metas, in_dir, out_dir, num_workers=1, tqdm=lambda x: x): 9 | '''Preprocesses the LJ Speech dataset from a given input path into a given output directory. 10 | 11 | Args: 12 | metas: list of metadata, like [[source_wav_path, target_wav_path], ...] 13 | in_dir: The directory where you raw parallel corpus stored 14 | out_dir: The directory to write the output into 15 | num_workers: Optional number of worker processes to parallelize across 16 | tqdm: You can optionally pass tqdm to get a nice progress bar 17 | 18 | Returns: 19 | A list of tuples describing the training examples. This should be written to train.txt 20 | ''' 21 | 22 | # We use ProcessPoolExecutor to parallelize across processes. This is just an optimization and you 23 | # can omit it and just call _process_utterance on each input if you want. 24 | executor = ProcessPoolExecutor(max_workers=num_workers) 25 | futures = [] 26 | index = 1 27 | 28 | for m in metas: 29 | source_wav_path = os.path.join(in_dir, m[0]) 30 | target_wav_path = os.path.join(in_dir, m[1]) 31 | futures.append(executor.submit(partial(_process_utterance, out_dir, index, source_wav_path, target_wav_path))) 32 | index += 1 33 | 34 | return [future.result() for future in tqdm(futures)] 35 | 36 | 37 | def _process_utterance(out_dir, index, source_wav_path, target_wav_path): 38 | '''Preprocesses a single utterance audio/text pair. 39 | 40 | This writes the mel and linear scale spectrograms to disk and returns a tuple to write 41 | to the train.txt file. 42 | 43 | Args: 44 | out_dir: The directory to write the spectrograms into 45 | index: The numeric index to use in the spectrogram filenames. 46 | wav_path: Path to the audio file containing the speech input 47 | text: The text spoken in the input audio file 48 | 49 | Returns: 50 | A (spectrogram_filename, mel_filename, n_frames, text) tuple to write to train.txt 51 | ''' 52 | 53 | # Load the audio to a numpy array: 54 | source_wav = audio.load_wav(source_wav_path) 55 | target_wav = audio.load_wav(target_wav_path) 56 | 57 | # Compute the linear-scale spectrogram from the wav: 58 | target_spectrogram = audio.spectrogram(target_wav).astype(np.float32) 59 | n_frames = target_spectrogram.shape[1] 60 | 61 | # Compute a mel-scale spectrogram from the wav: 62 | source_mel_spectrogram = audio.melspectrogram(source_wav).astype(np.float32) 63 | target_mel_spectrogram = audio.melspectrogram(target_wav).astype(np.float32) 64 | 65 | # Write the spectrograms to disk: 66 | #source_spectrogram_filename = 'source-spec-%05d.npy' % index 67 | source_mel_filename = 'source-mel-%05d.npy' % index 68 | target_spectrogram_filename = 'target-spec-%05d.npy' % index 69 | target_mel_filename = 'target-mel-%05d.npy' % index 70 | #np.save(os.path.join(out_dir, source_spectrogram_filename), source_spectrogram.T, allow_pickle=False) 71 | 72 | np.save(os.path.join(out_dir, source_mel_filename), source_mel_spectrogram.T, allow_pickle=False) 73 | np.save(os.path.join(out_dir, target_spectrogram_filename), target_spectrogram.T, allow_pickle=False) 74 | np.save(os.path.join(out_dir, target_mel_filename), target_mel_spectrogram.T, allow_pickle=False) 75 | 76 | # Return a tuple describing this training example: 77 | return (source_mel_filename, n_frames, target_spectrogram_filename,target_mel_filename ) 78 | -------------------------------------------------------------------------------- /models/modules.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | from tensorflow.contrib.rnn import GRUCell 3 | 4 | 5 | def prenet(inputs, is_training, layer_sizes, scope=None): 6 | x = inputs 7 | drop_rate = 0.5 if is_training else 0.0 8 | with tf.variable_scope(scope or 'prenet'): 9 | for i, size in enumerate(layer_sizes): 10 | dense = tf.layers.dense(x, units=size, activation=tf.nn.relu, name='dense_%d' % (i+1)) 11 | x = tf.layers.dropout(dense, rate=drop_rate, training=is_training, name='dropout_%d' % (i+1)) 12 | return x 13 | 14 | 15 | def encoder_cbhg(inputs, input_lengths, is_training, depth): 16 | input_channels = inputs.get_shape()[2] 17 | return cbhg( 18 | inputs, 19 | input_lengths, 20 | is_training, 21 | scope='encoder_cbhg', 22 | K=16, 23 | projections=[128, input_channels], 24 | depth=depth) 25 | 26 | def encoder_simple(inputs, input_lengths, is_training, depth): 27 | with tf.variable_scope('encoder'): 28 | outputs, states = tf.nn.bidirectional_dynamic_rnn( 29 | GRUCell(depth//2), 30 | GRUCell(depth//2), 31 | inputs, 32 | sequence_length=input_lengths, 33 | dtype=tf.float32) 34 | return tf.concat(outputs, axis=2) # Concat forward and backward 35 | 36 | 37 | 38 | 39 | def post_cbhg(inputs, input_dim, is_training, depth): 40 | return cbhg( 41 | inputs, 42 | None, 43 | is_training, 44 | scope='post_cbhg', 45 | K=8, 46 | projections=[256, input_dim], 47 | depth=depth) 48 | 49 | 50 | def cbhg(inputs, input_lengths, is_training, scope, K, projections, depth): 51 | with tf.variable_scope(scope): 52 | with tf.variable_scope('conv_bank'): 53 | # Convolution bank: concatenate on the last axis to stack channels from all convolutions 54 | conv_outputs = tf.concat( 55 | [conv1d(inputs, k, 128, tf.nn.relu, is_training, 'conv1d_%d' % k) for k in range(1, K+1)], 56 | axis=-1 57 | ) 58 | 59 | # Maxpooling: 60 | maxpool_output = tf.layers.max_pooling1d( 61 | conv_outputs, 62 | pool_size=2, 63 | strides=1, 64 | padding='same') 65 | 66 | # Two projection layers: 67 | proj1_output = conv1d(maxpool_output, 3, projections[0], tf.nn.relu, is_training, 'proj_1') 68 | proj2_output = conv1d(proj1_output, 3, projections[1], None, is_training, 'proj_2') 69 | 70 | # Residual connection: 71 | highway_input = proj2_output + inputs 72 | 73 | half_depth = depth // 2 74 | assert half_depth*2 == depth, 'encoder and postnet depths must be even.' 75 | 76 | # Handle dimensionality mismatch: 77 | if highway_input.shape[2] != half_depth: 78 | highway_input = tf.layers.dense(highway_input, half_depth) 79 | 80 | # 4-layer HighwayNet: 81 | for i in range(4): 82 | highway_input = highwaynet(highway_input, 'highway_%d' % (i+1), half_depth) 83 | rnn_input = highway_input 84 | 85 | # Bidirectional RNN 86 | outputs, states = tf.nn.bidirectional_dynamic_rnn( 87 | GRUCell(half_depth), 88 | GRUCell(half_depth), 89 | rnn_input, 90 | sequence_length=input_lengths, 91 | dtype=tf.float32) 92 | return tf.concat(outputs, axis=2) # Concat forward and backward 93 | 94 | 95 | def highwaynet(inputs, scope, depth): 96 | with tf.variable_scope(scope): 97 | H = tf.layers.dense( 98 | inputs, 99 | units=depth, 100 | activation=tf.nn.relu, 101 | name='H') 102 | T = tf.layers.dense( 103 | inputs, 104 | units=depth, 105 | activation=tf.nn.sigmoid, 106 | name='T', 107 | bias_initializer=tf.constant_initializer(-1.0)) 108 | return H * T + inputs * (1.0 - T) 109 | 110 | 111 | def conv1d(inputs, kernel_size, channels, activation, is_training, scope): 112 | with tf.variable_scope(scope): 113 | conv1d_output = tf.layers.conv1d( 114 | inputs, 115 | filters=channels, 116 | kernel_size=kernel_size, 117 | activation=activation, 118 | padding='same') 119 | return tf.layers.batch_normalization(conv1d_output, training=is_training) 120 | -------------------------------------------------------------------------------- /util/audio.py: -------------------------------------------------------------------------------- 1 | import librosa 2 | import librosa.filters 3 | import math 4 | import numpy as np 5 | import tensorflow as tf 6 | import scipy 7 | from hparams import hparams 8 | 9 | 10 | def load_wav(path): 11 | return librosa.core.load(path, sr=hparams.sample_rate)[0] 12 | 13 | 14 | def save_wav(wav, path): 15 | wav *= 32767 / max(0.01, np.max(np.abs(wav))) 16 | scipy.io.wavfile.write(path, hparams.sample_rate, wav.astype(np.int16)) 17 | 18 | 19 | def preemphasis(x): 20 | return scipy.signal.lfilter([1, -hparams.preemphasis], [1], x) 21 | 22 | 23 | def inv_preemphasis(x): 24 | return scipy.signal.lfilter([1], [1, -hparams.preemphasis], x) 25 | 26 | 27 | def spectrogram(y): 28 | D = _stft(preemphasis(y)) 29 | S = _amp_to_db(np.abs(D)) - hparams.ref_level_db 30 | return _normalize(S) 31 | 32 | 33 | def inv_spectrogram(spectrogram): 34 | '''Converts spectrogram to waveform using librosa''' 35 | S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db) # Convert back to linear 36 | return inv_preemphasis(_griffin_lim(S ** hparams.power)) # Reconstruct phase 37 | 38 | 39 | def inv_spectrogram_tensorflow(spectrogram): 40 | '''Builds computational graph to convert spectrogram to waveform using TensorFlow. 41 | 42 | Unlike inv_spectrogram, this does NOT invert the preemphasis. The caller should call 43 | inv_preemphasis on the output after running the graph. 44 | ''' 45 | S = _db_to_amp_tensorflow(_denormalize_tensorflow(spectrogram) + hparams.ref_level_db) 46 | return _griffin_lim_tensorflow(tf.pow(S, hparams.power)) 47 | 48 | 49 | def melspectrogram(y): 50 | D = _stft(preemphasis(y)) 51 | S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db 52 | return _normalize(S) 53 | 54 | 55 | def find_endpoint(wav, threshold_db=-40, min_silence_sec=0.8): 56 | window_length = int(hparams.sample_rate * min_silence_sec) 57 | hop_length = int(window_length / 4) 58 | threshold = _db_to_amp(threshold_db) 59 | for x in range(hop_length, len(wav) - window_length, hop_length): 60 | if np.max(wav[x:x+window_length]) < threshold: 61 | return x + hop_length 62 | return len(wav) 63 | 64 | 65 | def _griffin_lim(S): 66 | '''librosa implementation of Griffin-Lim 67 | Based on https://github.com/librosa/librosa/issues/434 68 | ''' 69 | angles = np.exp(2j * np.pi * np.random.rand(*S.shape)) 70 | S_complex = np.abs(S).astype(np.complex) 71 | y = _istft(S_complex * angles) 72 | for i in range(hparams.griffin_lim_iters): 73 | angles = np.exp(1j * np.angle(_stft(y))) 74 | y = _istft(S_complex * angles) 75 | return y 76 | 77 | 78 | def _griffin_lim_tensorflow(S): 79 | '''TensorFlow implementation of Griffin-Lim 80 | Based on https://github.com/Kyubyong/tensorflow-exercises/blob/master/Audio_Processing.ipynb 81 | ''' 82 | with tf.variable_scope('griffinlim'): 83 | # TensorFlow's stft and istft operate on a batch of spectrograms; create batch of size 1 84 | S = tf.expand_dims(S, 0) 85 | S_complex = tf.identity(tf.cast(S, dtype=tf.complex64)) 86 | y = _istft_tensorflow(S_complex) 87 | for i in range(hparams.griffin_lim_iters): 88 | est = _stft_tensorflow(y) 89 | angles = est / tf.cast(tf.maximum(1e-8, tf.abs(est)), tf.complex64) 90 | y = _istft_tensorflow(S_complex * angles) 91 | return tf.squeeze(y, 0) 92 | 93 | 94 | def _stft(y): 95 | n_fft, hop_length, win_length = _stft_parameters() 96 | return librosa.stft(y=y, n_fft=n_fft, hop_length=hop_length, win_length=win_length) 97 | 98 | 99 | def _istft(y): 100 | _, hop_length, win_length = _stft_parameters() 101 | return librosa.istft(y, hop_length=hop_length, win_length=win_length) 102 | 103 | 104 | def _stft_tensorflow(signals): 105 | n_fft, hop_length, win_length = _stft_parameters() 106 | return tf.contrib.signal.stft(signals, win_length, hop_length, n_fft, pad_end=False) 107 | 108 | 109 | def _istft_tensorflow(stfts): 110 | n_fft, hop_length, win_length = _stft_parameters() 111 | return tf.contrib.signal.inverse_stft(stfts, win_length, hop_length, n_fft) 112 | 113 | 114 | def _stft_parameters(): 115 | n_fft = (hparams.num_freq - 1) * 2 116 | hop_length = int(hparams.frame_shift_ms / 1000 * hparams.sample_rate) 117 | win_length = int(hparams.frame_length_ms / 1000 * hparams.sample_rate) 118 | return n_fft, hop_length, win_length 119 | 120 | 121 | # Conversions: 122 | 123 | _mel_basis = None 124 | 125 | def _linear_to_mel(spectrogram): 126 | global _mel_basis 127 | if _mel_basis is None: 128 | _mel_basis = _build_mel_basis() 129 | return np.dot(_mel_basis, spectrogram) 130 | 131 | def _build_mel_basis(): 132 | n_fft = (hparams.num_freq - 1) * 2 133 | return librosa.filters.mel(hparams.sample_rate, n_fft, n_mels=hparams.num_mels) 134 | 135 | def _amp_to_db(x): 136 | return 20 * np.log10(np.maximum(1e-5, x)) 137 | 138 | def _db_to_amp(x): 139 | return np.power(10.0, x * 0.05) 140 | 141 | def _db_to_amp_tensorflow(x): 142 | return tf.pow(tf.ones(tf.shape(x)) * 10.0, x * 0.05) 143 | 144 | def _normalize(S): 145 | return np.clip((S - hparams.min_level_db) / -hparams.min_level_db, 0, 1) 146 | 147 | def _denormalize(S): 148 | return (np.clip(S, 0, 1) * -hparams.min_level_db) + hparams.min_level_db 149 | 150 | def _denormalize_tensorflow(S): 151 | return (tf.clip_by_value(S, 0, 1) * -hparams.min_level_db) + hparams.min_level_db 152 | -------------------------------------------------------------------------------- /datasets/datafeeder.py: -------------------------------------------------------------------------------- 1 | import numpy as np 2 | import os 3 | import random 4 | import tensorflow as tf 5 | import threading 6 | import time 7 | import traceback 8 | from text import cmudict, text_to_sequence 9 | from util.infolog import log 10 | 11 | 12 | _batches_per_group = 32 13 | _p_cmudict = 0.5 14 | _pad = 0 15 | 16 | 17 | class DataFeeder(threading.Thread): 18 | '''Feeds batches of data into a queue on a background thread.''' 19 | 20 | def __init__(self, coordinator, metadata_filename, hparams): 21 | super(DataFeeder, self).__init__() 22 | self._coord = coordinator 23 | self._hparams = hparams 24 | self._cleaner_names = [x.strip() for x in hparams.cleaners.split(',')] 25 | self._offset = 0 26 | 27 | # Load metadata: 28 | self._datadir = os.path.dirname(metadata_filename) 29 | with open(metadata_filename, encoding='utf-8') as f: 30 | self._metadata = [line.strip().split('|') for line in f] 31 | hours = sum((int(x[1]) for x in self._metadata)) * hparams.frame_shift_ms / (3600 * 1000) 32 | log('Loaded metadata for %d examples (%.2f hours)' % (len(self._metadata), hours)) 33 | 34 | # Create placeholders for inputs and targets. Don't specify batch size because we want to 35 | # be able to feed different sized batches at eval time. 36 | self._placeholders = [ 37 | tf.placeholder(tf.float32, [None, None, hparams.num_mels], 'inputs'), 38 | tf.placeholder(tf.int32, [None], 'input_lengths'), 39 | tf.placeholder(tf.float32, [None, None, hparams.num_mels], 'mel_targets'), 40 | tf.placeholder(tf.float32, [None, None, hparams.num_freq], 'linear_targets') 41 | ] 42 | 43 | # Create queue for buffering data: 44 | queue = tf.FIFOQueue(8, [tf.float32, tf.int32, tf.float32, tf.float32], name='input_queue') 45 | self._enqueue_op = queue.enqueue(self._placeholders) 46 | self.inputs, self.input_lengths, self.mel_targets, self.linear_targets = queue.dequeue() 47 | self.inputs.set_shape(self._placeholders[0].shape) 48 | self.input_lengths.set_shape(self._placeholders[1].shape) 49 | self.mel_targets.set_shape(self._placeholders[2].shape) 50 | self.linear_targets.set_shape(self._placeholders[3].shape) 51 | 52 | 53 | # Load CMUDict: If enabled, this will randomly substitute some words in the training data with 54 | # their ARPABet equivalents, which will allow you to also pass ARPABet to the model for 55 | # synthesis (useful for proper nouns, etc.) 56 | #if hparams.use_cmudict: 57 | # print('hparams.use_cmudict',hparams.use_cmudict) 58 | # print('self._datadir',self._datadir) 59 | # cmudict_path = os.path.join(self._datadir, 'cmudict-0.7b') 60 | # if not os.path.isfile(cmudict_path): 61 | # raise Exception('If use_cmudict=True, you must download ' + 62 | # 'http://svn.code.sf.net/p/cmusphinx/code/trunk/cmudict/cmudict-0.7b to %s' % cmudict_path) 63 | # self._cmudict = cmudict.CMUDict(cmudict_path, keep_ambiguous=False) 64 | # log('Loaded CMUDict with %d unambiguous entries' % len(self._cmudict)) 65 | #else: 66 | # self._cmudict = None 67 | 68 | 69 | def start_in_session(self, session): 70 | self._session = session 71 | self.start() 72 | 73 | 74 | def run(self): 75 | try: 76 | while not self._coord.should_stop(): 77 | self._enqueue_next_group() 78 | except Exception as e: 79 | traceback.print_exc() 80 | self._coord.request_stop(e) 81 | 82 | 83 | def _enqueue_next_group(self): 84 | start = time.time() 85 | 86 | # Read a group of examples: 87 | n = self._hparams.batch_size 88 | r = self._hparams.outputs_per_step 89 | examples = [self._get_next_example() for i in range(n * _batches_per_group)] 90 | 91 | # Bucket examples based on similar output sequence length for efficiency: 92 | examples.sort(key=lambda x: x[-1]) 93 | batches = [examples[i:i+n] for i in range(0, len(examples), n)] 94 | random.shuffle(batches) 95 | 96 | log('Generated %d batches of size %d in %.03f sec' % (len(batches), n, time.time() - start)) 97 | for batch in batches: 98 | feed_dict = dict(zip(self._placeholders, _prepare_batch(batch, r))) 99 | self._session.run(self._enqueue_op, feed_dict=feed_dict) 100 | 101 | 102 | def _get_next_example(self): 103 | '''Loads a single example (input, mel_target, linear_target, cost) from disk''' 104 | if self._offset >= len(self._metadata): 105 | self._offset = 0 106 | random.shuffle(self._metadata) 107 | meta = self._metadata[self._offset] 108 | self._offset += 1 109 | 110 | #text = meta[3] 111 | #if self._cmudict and random.random() < _p_cmudict: 112 | #text = ' '.join([self._maybe_get_arpabet(word) for word in text.split(' ')]) 113 | 114 | input_data = np.load(os.path.join(self._datadir, meta[0])) 115 | mel_target = np.load(os.path.join(self._datadir, meta[3])) 116 | linear_target = np.load(os.path.join(self._datadir, meta[2])) 117 | return (input_data, mel_target, linear_target, len(linear_target)) 118 | 119 | 120 | def _maybe_get_arpabet(self, word): 121 | arpabet = self._cmudict.lookup(word) 122 | return '{%s}' % arpabet[0] if arpabet is not None and random.random() < 0.5 else word 123 | 124 | 125 | def _prepare_batch(batch, outputs_per_step): 126 | random.shuffle(batch) 127 | inputs = _prepare_inputs([x[0] for x in batch]) 128 | input_lengths = np.asarray([x[0].shape[0] for x in batch], dtype=np.int32) 129 | 130 | mel_targets = _prepare_targets([x[1] for x in batch], outputs_per_step) 131 | linear_targets = _prepare_targets([x[2] for x in batch], outputs_per_step) 132 | return (inputs, input_lengths, mel_targets, linear_targets) 133 | 134 | 135 | def _prepare_inputs(inputs): 136 | max_len = max((len(x) for x in inputs)) 137 | return np.stack([_pad_input(x, max_len) for x in inputs]) 138 | 139 | 140 | def _prepare_targets(targets, alignment): 141 | max_len = max((len(t) for t in targets)) + 1 142 | return np.stack([_pad_target(t, _round_up(max_len, alignment)) for t in targets]) 143 | 144 | 145 | def _pad_input(t, length): 146 | return np.pad(t,[(0, length - t.shape[0]), (0,0)], mode='constant', constant_values=_pad) 147 | 148 | 149 | def _pad_target(t, length): 150 | return np.pad(t, [(0, length - t.shape[0]), (0,0)], mode='constant', constant_values=_pad) 151 | 152 | 153 | def _round_up(x, multiple): 154 | remainder = x % multiple 155 | return x if remainder == 0 else x + multiple - remainder 156 | -------------------------------------------------------------------------------- /train.py: -------------------------------------------------------------------------------- 1 | import argparse 2 | from datetime import datetime 3 | import math 4 | import os 5 | import numpy as np 6 | import subprocess 7 | import time 8 | import tensorflow as tf 9 | import traceback 10 | 11 | from datasets.datafeeder import DataFeeder 12 | from hparams import hparams, hparams_debug_string 13 | from models import create_model 14 | from util import audio, infolog, plot, ValueWindow 15 | log = infolog.log 16 | 17 | 18 | def get_git_commit(): 19 | subprocess.check_output(['git', 'diff-index', '--quiet', 'HEAD']) # Verify client is clean 20 | commit = subprocess.check_output(['git', 'rev-parse', 'HEAD']).decode().strip()[:10] 21 | log('Git commit: %s' % commit) 22 | return commit 23 | 24 | 25 | def add_stats(model): 26 | with tf.variable_scope('stats') as scope: 27 | tf.summary.histogram('linear_outputs', model.linear_outputs) 28 | tf.summary.histogram('linear_targets', model.linear_targets) 29 | tf.summary.histogram('mel_outputs', model.mel_outputs) 30 | tf.summary.histogram('mel_targets', model.mel_targets) 31 | tf.summary.scalar('loss_mel', model.mel_loss) 32 | tf.summary.scalar('loss_linear', model.linear_loss) 33 | tf.summary.scalar('learning_rate', model.learning_rate) 34 | tf.summary.scalar('loss', model.loss) 35 | gradient_norms = [tf.norm(grad) for grad in model.gradients] 36 | tf.summary.histogram('gradient_norm', gradient_norms) 37 | tf.summary.scalar('max_gradient_norm', tf.reduce_max(gradient_norms)) 38 | return tf.summary.merge_all() 39 | 40 | 41 | def time_string(): 42 | return datetime.now().strftime('%Y-%m-%d %H:%M') 43 | 44 | 45 | def train(log_dir, args): 46 | commit = get_git_commit() if args.git else 'None' 47 | checkpoint_path = os.path.join(log_dir, 'model.ckpt') 48 | input_path = os.path.join(args.base_dir, args.input) 49 | log('Checkpoint path: %s' % checkpoint_path) 50 | log('Loading training data from: %s' % input_path) 51 | log('Using model: %s' % args.model) 52 | log(hparams_debug_string()) 53 | 54 | # Set up DataFeeder: 55 | coord = tf.train.Coordinator() 56 | with tf.variable_scope('datafeeder') as scope: 57 | feeder = DataFeeder(coord, input_path, hparams) 58 | 59 | # Set up model: 60 | global_step = tf.Variable(0, name='global_step', trainable=False) 61 | with tf.variable_scope('model') as scope: 62 | model = create_model(args.model, hparams) 63 | model.initialize(feeder.inputs, feeder.input_lengths, feeder.mel_targets, feeder.linear_targets) 64 | model.add_loss() 65 | model.add_optimizer(global_step) 66 | stats = add_stats(model) 67 | 68 | # Bookkeeping: 69 | step = 0 70 | time_window = ValueWindow(100) 71 | loss_window = ValueWindow(100) 72 | saver = tf.train.Saver(max_to_keep=5, keep_checkpoint_every_n_hours=2) 73 | 74 | # Train! 75 | 76 | config = tf.ConfigProto() 77 | config.gpu_options.allow_growth = True 78 | with tf.Session(config=config) as sess: 79 | try: 80 | summary_writer = tf.summary.FileWriter(log_dir, sess.graph) 81 | sess.run(tf.global_variables_initializer()) 82 | 83 | if args.restore_step: 84 | # Restore from a checkpoint if the user requested it. 85 | restore_path = '%s-%d' % (checkpoint_path, args.restore_step) 86 | saver.restore(sess, restore_path) 87 | log('Resuming from checkpoint: %s at commit: %s' % (restore_path, commit), slack=True) 88 | else: 89 | log('Starting new training run at commit: %s' % commit, slack=True) 90 | 91 | feeder.start_in_session(sess) 92 | 93 | while not coord.should_stop(): 94 | start_time = time.time() 95 | step, loss, opt = sess.run([global_step, model.loss, model.optimize]) 96 | time_window.append(time.time() - start_time) 97 | loss_window.append(loss) 98 | message = 'Step %-7d [%.03f sec/step, loss=%.05f, avg_loss=%.05f]' % ( 99 | step, time_window.average, loss, loss_window.average) 100 | log(message, slack=(step % args.checkpoint_interval == 0)) 101 | 102 | if loss > 100 or math.isnan(loss): 103 | log('Loss exploded to %.05f at step %d!' % (loss, step), slack=True) 104 | raise Exception('Loss Exploded') 105 | 106 | if step % args.summary_interval == 0: 107 | log('Writing summary at step: %d' % step) 108 | summary_writer.add_summary(sess.run(stats), step) 109 | 110 | if step % args.checkpoint_interval == 0: 111 | log('Saving checkpoint to: %s-%d' % (checkpoint_path, step)) 112 | saver.save(sess, checkpoint_path, global_step=step) 113 | log('Saving audio and alignment...') 114 | input_seq, spectrogram, alignment = sess.run([ 115 | model.inputs[0], model.linear_outputs[0], model.alignments[0]]) 116 | waveform = audio.inv_spectrogram(spectrogram.T) 117 | audio.save_wav(waveform, os.path.join(log_dir, 'step-%d-audio.wav' % step)) 118 | plot.plot_alignment(alignment, os.path.join(log_dir, 'step-%d-align.png' % step), 119 | info='%s, %s, %s, step=%d, loss=%.5f' % (args.model, commit, time_string(), step, loss)) 120 | 121 | except Exception as e: 122 | log('Exiting due to exception: %s' % e, slack=True) 123 | traceback.print_exc() 124 | coord.request_stop(e) 125 | 126 | 127 | def main(): 128 | parser = argparse.ArgumentParser() 129 | parser.add_argument('--base_dir', default=os.path.expanduser('.')) 130 | parser.add_argument('--input', default='training/train.txt') 131 | parser.add_argument('--model', default='tacotron') 132 | parser.add_argument('--name', help='Name of the run. Used for logging. Defaults to model name.') 133 | parser.add_argument('--hparams', default='', 134 | help='Hyperparameter overrides as a comma-separated list of name=value pairs') 135 | parser.add_argument('--restore_step', type=int, help='Global step to restore from checkpoint.') 136 | parser.add_argument('--summary_interval', type=int, default=100, 137 | help='Steps between running summary ops.') 138 | parser.add_argument('--checkpoint_interval', type=int, default=1000, 139 | help='Steps between writing checkpoints.') 140 | parser.add_argument('--slack_url', help='Slack webhook URL to get periodic reports.') 141 | parser.add_argument('--tf_log_level', type=int, default=1, help='Tensorflow C++ log level.') 142 | parser.add_argument('--git', action='store_true', help='If set, verify that the client is clean.') 143 | args = parser.parse_args() 144 | os.environ['TF_CPP_MIN_LOG_LEVEL'] = str(args.tf_log_level) 145 | run_name = args.name or args.model 146 | log_dir = os.path.join(args.base_dir, 'logs-%s' % run_name) 147 | os.makedirs(log_dir, exist_ok=True) 148 | infolog.init(os.path.join(log_dir, 'train.log'), run_name, args.slack_url) 149 | hparams.parse(args.hparams) 150 | train(log_dir, args) 151 | 152 | 153 | if __name__ == '__main__': 154 | main() 155 | -------------------------------------------------------------------------------- /origin-readme.md: -------------------------------------------------------------------------------- 1 | # Tacotron 2 | 3 | An implementation of Tacotron speech synthesis in TensorFlow. 4 | 5 | 6 | ### Audio Samples 7 | 8 | * **[Audio Samples](https://keithito.github.io/audio-samples/)** from models trained using this repo. 9 | * The first set was trained for 441K steps on the [LJ Speech Dataset](https://keithito.com/LJ-Speech-Dataset/) 10 | * Speech started to become intelligble around 20K steps. 11 | * The second set was trained by [@MXGray](https://github.com/MXGray) for 140K steps on the [Nancy Corpus](http://www.cstr.ed.ac.uk/projects/blizzard/2011/lessac_blizzard2011/). 12 | 13 | 14 | ### Recent Updates 15 | 16 | 1. @npuichigo [fixed](https://github.com/keithito/tacotron/pull/205) a bug where dropout was not being applied in the prenet. 17 | 18 | 2. @begeekmyfriend created a [fork](https://github.com/begeekmyfriend/tacotron) that adds location-sensitive attention and the stop token from the [Tacotron 2](https://arxiv.org/abs/1712.05884) paper. This can greatly reduce the amount of data required to train a model. 19 | 20 | 21 | ## Background 22 | 23 | In April 2017, Google published a paper, [Tacotron: Towards End-to-End Speech Synthesis](https://arxiv.org/pdf/1703.10135.pdf), 24 | where they present a neural text-to-speech model that learns to synthesize speech directly from 25 | (text, audio) pairs. However, they didn't release their source code or training data. This is an 26 | independent attempt to provide an open-source implementation of the model described in their paper. 27 | 28 | The quality isn't as good as Google's demo yet, but hopefully it will get there someday :-). 29 | Pull requests are welcome! 30 | 31 | 32 | 33 | ## Quick Start 34 | 35 | ### Installing dependencies 36 | 37 | 1. Install Python 3. 38 | 39 | 2. Install the latest version of [TensorFlow](https://www.tensorflow.org/install/) for your platform. For better 40 | performance, install with GPU support if it's available. This code works with TensorFlow 1.3 and later. 41 | 42 | 3. Install requirements: 43 | ``` 44 | pip install -r requirements.txt 45 | ``` 46 | 47 | 48 | ### Using a pre-trained model 49 | 50 | 1. **Download and unpack a model**: 51 | ``` 52 | curl http://data.keithito.com/data/speech/tacotron-20180906.tar.gz | tar xzC /tmp 53 | ``` 54 | 55 | 2. **Run the demo server**: 56 | ``` 57 | python3 demo_server.py --checkpoint /tmp/tacotron-20180906/model.ckpt 58 | ``` 59 | 60 | 3. **Point your browser at localhost:9000** 61 | * Type what you want to synthesize 62 | 63 | 64 | 65 | ### Training 66 | 67 | *Note: you need at least 40GB of free disk space to train a model.* 68 | 69 | 1. **Download a speech dataset.** 70 | 71 | The following are supported out of the box: 72 | * [LJ Speech](https://keithito.com/LJ-Speech-Dataset/) (Public Domain) 73 | * [Blizzard 2012](http://www.cstr.ed.ac.uk/projects/blizzard/2012/phase_one) (Creative Commons Attribution Share-Alike) 74 | 75 | You can use other datasets if you convert them to the right format. See [TRAINING_DATA.md](TRAINING_DATA.md) for more info. 76 | 77 | 78 | 2. **Unpack the dataset into `~/tacotron`** 79 | 80 | After unpacking, your tree should look like this for LJ Speech: 81 | ``` 82 | tacotron 83 | |- LJSpeech-1.1 84 | |- metadata.csv 85 | |- wavs 86 | ``` 87 | 88 | or like this for Blizzard 2012: 89 | ``` 90 | tacotron 91 | |- Blizzard2012 92 | |- ATrampAbroad 93 | | |- sentence_index.txt 94 | | |- lab 95 | | |- wav 96 | |- TheManThatCorruptedHadleyburg 97 | |- sentence_index.txt 98 | |- lab 99 | |- wav 100 | ``` 101 | 102 | 3. **Preprocess the data** 103 | ``` 104 | python3 preprocess.py --dataset ljspeech 105 | ``` 106 | * Use `--dataset blizzard` for Blizzard data 107 | 108 | 4. **Train a model** 109 | ``` 110 | python3 train.py 111 | ``` 112 | 113 | Tunable hyperparameters are found in [hparams.py](hparams.py). You can adjust these at the command 114 | line using the `--hparams` flag, for example `--hparams="batch_size=16,outputs_per_step=2"`. 115 | Hyperparameters should generally be set to the same values at both training and eval time. 116 | The default hyperparameters are recommended for LJ Speech and other English-language data. 117 | See [TRAINING_DATA.md](TRAINING_DATA.md) for other languages. 118 | 119 | 120 | 5. **Monitor with Tensorboard** (optional) 121 | ``` 122 | tensorboard --logdir ~/tacotron/logs-tacotron 123 | ``` 124 | 125 | The trainer dumps audio and alignments every 1000 steps. You can find these in 126 | `~/tacotron/logs-tacotron`. 127 | 128 | 6. **Synthesize from a checkpoint** 129 | ``` 130 | python3 demo_server.py --checkpoint ~/tacotron/logs-tacotron/model.ckpt-185000 131 | ``` 132 | Replace "185000" with the checkpoint number that you want to use, then open a browser 133 | to `localhost:9000` and type what you want to speak. Alternately, you can 134 | run [eval.py](eval.py) at the command line: 135 | ``` 136 | python3 eval.py --checkpoint ~/tacotron/logs-tacotron/model.ckpt-185000 137 | ``` 138 | If you set the `--hparams` flag when training, set the same value here. 139 | 140 | 141 | ## Notes and Common Issues 142 | 143 | * [TCMalloc](http://goog-perftools.sourceforge.net/doc/tcmalloc.html) seems to improve 144 | training speed and avoids occasional slowdowns seen with the default allocator. You 145 | can enable it by installing it and setting `LD_PRELOAD=/usr/lib/libtcmalloc.so`. With TCMalloc, 146 | you can get around 1.1 sec/step on a GTX 1080Ti. 147 | 148 | * You can train with [CMUDict](http://www.speech.cs.cmu.edu/cgi-bin/cmudict) by downloading the 149 | dictionary to ~/tacotron/training and then passing the flag `--hparams="use_cmudict=True"` to 150 | train.py. This will allow you to pass ARPAbet phonemes enclosed in curly braces at eval 151 | time to force a particular pronunciation, e.g. `Turn left on {HH AW1 S S T AH0 N} Street.` 152 | 153 | * If you pass a Slack incoming webhook URL as the `--slack_url` flag to train.py, it will send 154 | you progress updates every 1000 steps. 155 | 156 | * Occasionally, you may see a spike in loss and the model will forget how to attend (the 157 | alignments will no longer make sense). Although it will recover eventually, it may 158 | save time to restart at a checkpoint prior to the spike by passing the 159 | `--restore_step=150000` flag to train.py (replacing 150000 with a step number prior to the 160 | spike). **Update**: a recent [fix](https://github.com/keithito/tacotron/pull/7) to gradient 161 | clipping by @candlewill may have fixed this. 162 | 163 | * During eval and training, audio length is limited to `max_iters * outputs_per_step * frame_shift_ms` 164 | milliseconds. With the defaults (max_iters=200, outputs_per_step=5, frame_shift_ms=12.5), this is 165 | 12.5 seconds. 166 | 167 | If your training examples are longer, you will see an error like this: 168 | `Incompatible shapes: [32,1340,80] vs. [32,1000,80]` 169 | 170 | To fix this, you can set a larger value of `max_iters` by passing `--hparams="max_iters=300"` to 171 | train.py (replace "300" with a value based on how long your audio is and the formula above). 172 | 173 | * Here is the expected loss curve when training on LJ Speech with the default hyperparameters: 174 | ![Loss curve](https://user-images.githubusercontent.com/1945356/36077599-c0513e4a-0f21-11e8-8525-07347847720c.png) 175 | 176 | 177 | ## Other Implementations 178 | * By Alex Barron: https://github.com/barronalex/Tacotron 179 | * By Kyubyong Park: https://github.com/Kyubyong/tacotron 180 | -------------------------------------------------------------------------------- /models/tacotron.py: -------------------------------------------------------------------------------- 1 | import tensorflow as tf 2 | from tensorflow.contrib.rnn import GRUCell, MultiRNNCell, OutputProjectionWrapper, ResidualWrapper 3 | from tensorflow.contrib.seq2seq import BasicDecoder, BahdanauAttention, AttentionWrapper 4 | from text.symbols import symbols 5 | from util.infolog import log 6 | from .helpers import TacoTestHelper, TacoTrainingHelper 7 | from .modules import encoder_cbhg, post_cbhg, prenet, encoder_simple 8 | from .rnn_wrappers import DecoderPrenetWrapper, ConcatOutputAndAttentionWrapper 9 | 10 | 11 | 12 | class Tacotron(): 13 | def __init__(self, hparams): 14 | self._hparams = hparams 15 | 16 | 17 | def initialize(self, inputs, input_lengths, mel_targets=None, linear_targets=None): 18 | '''Initializes the model for inference. 19 | 20 | Sets "mel_outputs", "linear_outputs", and "alignments" fields. 21 | 22 | Args: 23 | inputs: int32 Tensor with shape [N, T_in] where N is batch size, T_in is number of 24 | steps in the input time series, and values are character IDs 25 | input_lengths: int32 Tensor with shape [N] where N is batch size and values are the lengths 26 | of each sequence in inputs. 27 | mel_targets: float32 Tensor with shape [N, T_out, M] where N is batch size, T_out is number 28 | of steps in the output time series, M is num_mels, and values are entries in the mel 29 | spectrogram. Only needed for training. 30 | linear_targets: float32 Tensor with shape [N, T_out, F] where N is batch_size, T_out is number 31 | of steps in the output time series, F is num_freq, and values are entries in the linear 32 | spectrogram. Only needed for training. 33 | ''' 34 | with tf.variable_scope('inference') as scope: 35 | is_training = linear_targets is not None 36 | batch_size = tf.shape(inputs)[0] 37 | hp = self._hparams 38 | 39 | # Encoder 40 | prenet_outputs = prenet(inputs, is_training, hp.prenet_depths) # [N, T_in, prenet_depths[-1]=128] 41 | 42 | encoder_outputs = encoder_cbhg(prenet_outputs, input_lengths, is_training, # [N, T_in, encoder_depth=256] 43 | hp.encoder_depth) 44 | #encoder_outputs = encoder_simple(prenet_outputs, input_lengths, is_training, # [N, T_in, encoder_depth=256] 45 | # hp.encoder_depth) 46 | #encoder_outputs = prenet_outputs 47 | 48 | # Attention 49 | attention_cell = AttentionWrapper( 50 | GRUCell(hp.attention_depth), 51 | BahdanauAttention(hp.attention_depth, encoder_outputs), 52 | alignment_history=True, 53 | output_attention=False) # [N, T_in, attention_depth=256] 54 | 55 | # Apply prenet before concatenation in AttentionWrapper. 56 | attention_cell = DecoderPrenetWrapper(attention_cell, is_training, hp.prenet_depths) 57 | 58 | # Concatenate attention context vector and RNN cell output into a 2*attention_depth=512D vector. 59 | concat_cell = ConcatOutputAndAttentionWrapper(attention_cell) # [N, T_in, 2*attention_depth=512] 60 | 61 | # Decoder (layers specified bottom to top): 62 | decoder_cell = MultiRNNCell([ 63 | OutputProjectionWrapper(concat_cell, hp.decoder_depth), 64 | ResidualWrapper(GRUCell(hp.decoder_depth)), 65 | ResidualWrapper(GRUCell(hp.decoder_depth)) 66 | ], state_is_tuple=True) # [N, T_in, decoder_depth=256] 67 | 68 | # Project onto r mel spectrograms (predict r outputs at each RNN step): 69 | output_cell = OutputProjectionWrapper(decoder_cell, hp.num_mels * hp.outputs_per_step) 70 | decoder_init_state = output_cell.zero_state(batch_size=batch_size, dtype=tf.float32) 71 | 72 | if is_training: 73 | helper = TacoTrainingHelper(inputs, mel_targets, hp.num_mels, hp.outputs_per_step) 74 | else: 75 | helper = TacoTestHelper(batch_size, hp.num_mels, hp.outputs_per_step) 76 | 77 | (decoder_outputs, _), final_decoder_state, _ = tf.contrib.seq2seq.dynamic_decode( 78 | BasicDecoder(output_cell, helper, decoder_init_state), 79 | maximum_iterations=hp.max_iters) # [N, T_out/r, M*r] 80 | 81 | # Reshape outputs to be one output per entry 82 | mel_outputs = tf.reshape(decoder_outputs, [batch_size, -1, hp.num_mels]) # [N, T_out, M] 83 | 84 | # Add post-processing CBHG: 85 | post_outputs = post_cbhg(mel_outputs, hp.num_mels, is_training, # [N, T_out, postnet_depth=256] 86 | hp.postnet_depth) 87 | linear_outputs = tf.layers.dense(post_outputs, hp.num_freq) # [N, T_out, F] 88 | 89 | # Grab alignments from the final decoder state: 90 | alignments = tf.transpose(final_decoder_state[0].alignment_history.stack(), [1, 2, 0]) 91 | 92 | self.inputs = inputs 93 | self.input_lengths = input_lengths 94 | self.mel_outputs = mel_outputs 95 | self.linear_outputs = linear_outputs 96 | self.alignments = alignments 97 | self.mel_targets = mel_targets 98 | self.linear_targets = linear_targets 99 | log('Initialized Tacotron model. Dimensions: ') 100 | log(' prenet out: %d' % prenet_outputs.shape[-1]) 101 | log(' encoder out: %d' % encoder_outputs.shape[-1]) 102 | log(' attention out: %d' % attention_cell.output_size) 103 | log(' concat attn & out: %d' % concat_cell.output_size) 104 | log(' decoder cell out: %d' % decoder_cell.output_size) 105 | log(' decoder out (%d frames): %d' % (hp.outputs_per_step, decoder_outputs.shape[-1])) 106 | log(' decoder out (1 frame): %d' % mel_outputs.shape[-1]) 107 | log(' postnet out: %d' % post_outputs.shape[-1]) 108 | log(' linear out: %d' % linear_outputs.shape[-1]) 109 | 110 | 111 | def add_loss(self): 112 | '''Adds loss to the model. Sets "loss" field. initialize must have been called.''' 113 | with tf.variable_scope('loss') as scope: 114 | hp = self._hparams 115 | self.mel_loss = tf.reduce_mean(tf.abs(self.mel_targets - self.mel_outputs)) 116 | l1 = tf.abs(self.linear_targets - self.linear_outputs) 117 | # Prioritize loss for frequencies under 3000 Hz. 118 | n_priority_freq = int(3000 / (hp.sample_rate * 0.5) * hp.num_freq) 119 | self.linear_loss = 0.5 * tf.reduce_mean(l1) + 0.5 * tf.reduce_mean(l1[:,:,0:n_priority_freq]) 120 | self.loss = self.mel_loss + self.linear_loss 121 | 122 | 123 | def add_optimizer(self, global_step): 124 | '''Adds optimizer. Sets "gradients" and "optimize" fields. add_loss must have been called. 125 | 126 | Args: 127 | global_step: int32 scalar Tensor representing current global step in training 128 | ''' 129 | with tf.variable_scope('optimizer') as scope: 130 | hp = self._hparams 131 | if hp.decay_learning_rate: 132 | self.learning_rate = _learning_rate_decay(hp.initial_learning_rate, global_step) 133 | else: 134 | self.learning_rate = tf.convert_to_tensor(hp.initial_learning_rate) 135 | optimizer = tf.train.AdamOptimizer(self.learning_rate, hp.adam_beta1, hp.adam_beta2) 136 | gradients, variables = zip(*optimizer.compute_gradients(self.loss)) 137 | self.gradients = gradients 138 | clipped_gradients, _ = tf.clip_by_global_norm(gradients, 1.0) 139 | 140 | # Add dependency on UPDATE_OPS; otherwise batchnorm won't work correctly. See: 141 | # https://github.com/tensorflow/tensorflow/issues/1122 142 | with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)): 143 | self.optimize = optimizer.apply_gradients(zip(clipped_gradients, variables), 144 | global_step=global_step) 145 | 146 | 147 | def _learning_rate_decay(init_lr, global_step): 148 | # Noam scheme from tensor2tensor: 149 | warmup_steps = 4000.0 150 | step = tf.cast(global_step + 1, dtype=tf.float32) 151 | return init_lr * warmup_steps**0.5 * tf.minimum(step * warmup_steps**-1.5, step**-0.5) 152 | -------------------------------------------------------------------------------- /parallel_data/metadata.csv: -------------------------------------------------------------------------------- 1 | clb_arctic_a0101.wav|bdl_arctic_a0101.wav 2 | clb_arctic_a0102.wav|bdl_arctic_a0102.wav 3 | clb_arctic_a0103.wav|bdl_arctic_a0103.wav 4 | clb_arctic_a0104.wav|bdl_arctic_a0104.wav 5 | clb_arctic_a0105.wav|bdl_arctic_a0105.wav 6 | clb_arctic_a0106.wav|bdl_arctic_a0106.wav 7 | clb_arctic_a0107.wav|bdl_arctic_a0107.wav 8 | clb_arctic_a0108.wav|bdl_arctic_a0108.wav 9 | clb_arctic_a0109.wav|bdl_arctic_a0109.wav 10 | clb_arctic_a0110.wav|bdl_arctic_a0110.wav 11 | clb_arctic_a0111.wav|bdl_arctic_a0111.wav 12 | clb_arctic_a0112.wav|bdl_arctic_a0112.wav 13 | clb_arctic_a0113.wav|bdl_arctic_a0113.wav 14 | clb_arctic_a0114.wav|bdl_arctic_a0114.wav 15 | clb_arctic_a0115.wav|bdl_arctic_a0115.wav 16 | clb_arctic_a0116.wav|bdl_arctic_a0116.wav 17 | clb_arctic_a0117.wav|bdl_arctic_a0117.wav 18 | clb_arctic_a0118.wav|bdl_arctic_a0118.wav 19 | clb_arctic_a0119.wav|bdl_arctic_a0119.wav 20 | clb_arctic_a0120.wav|bdl_arctic_a0120.wav 21 | clb_arctic_a0121.wav|bdl_arctic_a0121.wav 22 | clb_arctic_a0122.wav|bdl_arctic_a0122.wav 23 | clb_arctic_a0123.wav|bdl_arctic_a0123.wav 24 | clb_arctic_a0124.wav|bdl_arctic_a0124.wav 25 | clb_arctic_a0125.wav|bdl_arctic_a0125.wav 26 | clb_arctic_a0126.wav|bdl_arctic_a0126.wav 27 | clb_arctic_a0127.wav|bdl_arctic_a0127.wav 28 | clb_arctic_a0128.wav|bdl_arctic_a0128.wav 29 | clb_arctic_a0129.wav|bdl_arctic_a0129.wav 30 | clb_arctic_a0130.wav|bdl_arctic_a0130.wav 31 | clb_arctic_a0131.wav|bdl_arctic_a0131.wav 32 | clb_arctic_a0132.wav|bdl_arctic_a0132.wav 33 | clb_arctic_a0133.wav|bdl_arctic_a0133.wav 34 | clb_arctic_a0134.wav|bdl_arctic_a0134.wav 35 | clb_arctic_a0135.wav|bdl_arctic_a0135.wav 36 | clb_arctic_a0136.wav|bdl_arctic_a0136.wav 37 | clb_arctic_a0137.wav|bdl_arctic_a0137.wav 38 | clb_arctic_a0138.wav|bdl_arctic_a0138.wav 39 | clb_arctic_a0139.wav|bdl_arctic_a0139.wav 40 | clb_arctic_a0140.wav|bdl_arctic_a0140.wav 41 | clb_arctic_a0141.wav|bdl_arctic_a0141.wav 42 | clb_arctic_a0142.wav|bdl_arctic_a0142.wav 43 | clb_arctic_a0143.wav|bdl_arctic_a0143.wav 44 | clb_arctic_a0144.wav|bdl_arctic_a0144.wav 45 | clb_arctic_a0145.wav|bdl_arctic_a0145.wav 46 | clb_arctic_a0146.wav|bdl_arctic_a0146.wav 47 | clb_arctic_a0147.wav|bdl_arctic_a0147.wav 48 | clb_arctic_a0148.wav|bdl_arctic_a0148.wav 49 | clb_arctic_a0149.wav|bdl_arctic_a0149.wav 50 | clb_arctic_a0150.wav|bdl_arctic_a0150.wav 51 | clb_arctic_a0151.wav|bdl_arctic_a0151.wav 52 | clb_arctic_a0152.wav|bdl_arctic_a0152.wav 53 | clb_arctic_a0153.wav|bdl_arctic_a0153.wav 54 | clb_arctic_a0154.wav|bdl_arctic_a0154.wav 55 | clb_arctic_a0155.wav|bdl_arctic_a0155.wav 56 | clb_arctic_a0156.wav|bdl_arctic_a0156.wav 57 | clb_arctic_a0157.wav|bdl_arctic_a0157.wav 58 | clb_arctic_a0158.wav|bdl_arctic_a0158.wav 59 | clb_arctic_a0159.wav|bdl_arctic_a0159.wav 60 | clb_arctic_a0160.wav|bdl_arctic_a0160.wav 61 | clb_arctic_a0161.wav|bdl_arctic_a0161.wav 62 | clb_arctic_a0162.wav|bdl_arctic_a0162.wav 63 | clb_arctic_a0163.wav|bdl_arctic_a0163.wav 64 | clb_arctic_a0164.wav|bdl_arctic_a0164.wav 65 | clb_arctic_a0165.wav|bdl_arctic_a0165.wav 66 | clb_arctic_a0166.wav|bdl_arctic_a0166.wav 67 | clb_arctic_a0167.wav|bdl_arctic_a0167.wav 68 | clb_arctic_a0168.wav|bdl_arctic_a0168.wav 69 | clb_arctic_a0169.wav|bdl_arctic_a0169.wav 70 | clb_arctic_a0170.wav|bdl_arctic_a0170.wav 71 | clb_arctic_a0171.wav|bdl_arctic_a0171.wav 72 | clb_arctic_a0172.wav|bdl_arctic_a0172.wav 73 | clb_arctic_a0173.wav|bdl_arctic_a0173.wav 74 | clb_arctic_a0174.wav|bdl_arctic_a0174.wav 75 | clb_arctic_a0175.wav|bdl_arctic_a0175.wav 76 | clb_arctic_a0176.wav|bdl_arctic_a0176.wav 77 | clb_arctic_a0177.wav|bdl_arctic_a0177.wav 78 | clb_arctic_a0178.wav|bdl_arctic_a0178.wav 79 | clb_arctic_a0179.wav|bdl_arctic_a0179.wav 80 | clb_arctic_a0180.wav|bdl_arctic_a0180.wav 81 | clb_arctic_a0181.wav|bdl_arctic_a0181.wav 82 | clb_arctic_a0182.wav|bdl_arctic_a0182.wav 83 | clb_arctic_a0183.wav|bdl_arctic_a0183.wav 84 | clb_arctic_a0184.wav|bdl_arctic_a0184.wav 85 | clb_arctic_a0185.wav|bdl_arctic_a0185.wav 86 | clb_arctic_a0186.wav|bdl_arctic_a0186.wav 87 | clb_arctic_a0187.wav|bdl_arctic_a0187.wav 88 | clb_arctic_a0188.wav|bdl_arctic_a0188.wav 89 | clb_arctic_a0189.wav|bdl_arctic_a0189.wav 90 | clb_arctic_a0190.wav|bdl_arctic_a0190.wav 91 | clb_arctic_a0191.wav|bdl_arctic_a0191.wav 92 | clb_arctic_a0192.wav|bdl_arctic_a0192.wav 93 | clb_arctic_a0193.wav|bdl_arctic_a0193.wav 94 | clb_arctic_a0194.wav|bdl_arctic_a0194.wav 95 | clb_arctic_a0195.wav|bdl_arctic_a0195.wav 96 | clb_arctic_a0196.wav|bdl_arctic_a0196.wav 97 | clb_arctic_a0197.wav|bdl_arctic_a0197.wav 98 | clb_arctic_a0198.wav|bdl_arctic_a0198.wav 99 | clb_arctic_a0199.wav|bdl_arctic_a0199.wav 100 | clb_arctic_a0200.wav|bdl_arctic_a0200.wav 101 | clb_arctic_a0201.wav|bdl_arctic_a0201.wav 102 | clb_arctic_a0202.wav|bdl_arctic_a0202.wav 103 | clb_arctic_a0203.wav|bdl_arctic_a0203.wav 104 | clb_arctic_a0204.wav|bdl_arctic_a0204.wav 105 | clb_arctic_a0205.wav|bdl_arctic_a0205.wav 106 | clb_arctic_a0206.wav|bdl_arctic_a0206.wav 107 | clb_arctic_a0207.wav|bdl_arctic_a0207.wav 108 | clb_arctic_a0208.wav|bdl_arctic_a0208.wav 109 | clb_arctic_a0209.wav|bdl_arctic_a0209.wav 110 | clb_arctic_a0210.wav|bdl_arctic_a0210.wav 111 | clb_arctic_a0211.wav|bdl_arctic_a0211.wav 112 | clb_arctic_a0212.wav|bdl_arctic_a0212.wav 113 | clb_arctic_a0213.wav|bdl_arctic_a0213.wav 114 | clb_arctic_a0214.wav|bdl_arctic_a0214.wav 115 | clb_arctic_a0215.wav|bdl_arctic_a0215.wav 116 | clb_arctic_a0216.wav|bdl_arctic_a0216.wav 117 | clb_arctic_a0217.wav|bdl_arctic_a0217.wav 118 | clb_arctic_a0218.wav|bdl_arctic_a0218.wav 119 | clb_arctic_a0219.wav|bdl_arctic_a0219.wav 120 | clb_arctic_a0220.wav|bdl_arctic_a0220.wav 121 | clb_arctic_a0221.wav|bdl_arctic_a0221.wav 122 | clb_arctic_a0222.wav|bdl_arctic_a0222.wav 123 | clb_arctic_a0223.wav|bdl_arctic_a0223.wav 124 | clb_arctic_a0224.wav|bdl_arctic_a0224.wav 125 | clb_arctic_a0225.wav|bdl_arctic_a0225.wav 126 | clb_arctic_a0226.wav|bdl_arctic_a0226.wav 127 | clb_arctic_a0227.wav|bdl_arctic_a0227.wav 128 | clb_arctic_a0228.wav|bdl_arctic_a0228.wav 129 | clb_arctic_a0229.wav|bdl_arctic_a0229.wav 130 | clb_arctic_a0230.wav|bdl_arctic_a0230.wav 131 | clb_arctic_a0231.wav|bdl_arctic_a0231.wav 132 | clb_arctic_a0232.wav|bdl_arctic_a0232.wav 133 | clb_arctic_a0233.wav|bdl_arctic_a0233.wav 134 | clb_arctic_a0234.wav|bdl_arctic_a0234.wav 135 | clb_arctic_a0235.wav|bdl_arctic_a0235.wav 136 | clb_arctic_a0236.wav|bdl_arctic_a0236.wav 137 | clb_arctic_a0237.wav|bdl_arctic_a0237.wav 138 | clb_arctic_a0238.wav|bdl_arctic_a0238.wav 139 | clb_arctic_a0239.wav|bdl_arctic_a0239.wav 140 | clb_arctic_a0240.wav|bdl_arctic_a0240.wav 141 | clb_arctic_a0241.wav|bdl_arctic_a0241.wav 142 | clb_arctic_a0242.wav|bdl_arctic_a0242.wav 143 | clb_arctic_a0243.wav|bdl_arctic_a0243.wav 144 | clb_arctic_a0244.wav|bdl_arctic_a0244.wav 145 | clb_arctic_a0245.wav|bdl_arctic_a0245.wav 146 | clb_arctic_a0246.wav|bdl_arctic_a0246.wav 147 | clb_arctic_a0247.wav|bdl_arctic_a0247.wav 148 | clb_arctic_a0248.wav|bdl_arctic_a0248.wav 149 | clb_arctic_a0249.wav|bdl_arctic_a0249.wav 150 | clb_arctic_a0250.wav|bdl_arctic_a0250.wav 151 | clb_arctic_a0251.wav|bdl_arctic_a0251.wav 152 | clb_arctic_a0252.wav|bdl_arctic_a0252.wav 153 | clb_arctic_a0253.wav|bdl_arctic_a0253.wav 154 | clb_arctic_a0254.wav|bdl_arctic_a0254.wav 155 | clb_arctic_a0255.wav|bdl_arctic_a0255.wav 156 | clb_arctic_a0256.wav|bdl_arctic_a0256.wav 157 | clb_arctic_a0257.wav|bdl_arctic_a0257.wav 158 | clb_arctic_a0258.wav|bdl_arctic_a0258.wav 159 | clb_arctic_a0259.wav|bdl_arctic_a0259.wav 160 | clb_arctic_a0260.wav|bdl_arctic_a0260.wav 161 | clb_arctic_a0261.wav|bdl_arctic_a0261.wav 162 | clb_arctic_a0262.wav|bdl_arctic_a0262.wav 163 | clb_arctic_a0263.wav|bdl_arctic_a0263.wav 164 | clb_arctic_a0264.wav|bdl_arctic_a0264.wav 165 | clb_arctic_a0265.wav|bdl_arctic_a0265.wav 166 | clb_arctic_a0266.wav|bdl_arctic_a0266.wav 167 | clb_arctic_a0267.wav|bdl_arctic_a0267.wav 168 | clb_arctic_a0268.wav|bdl_arctic_a0268.wav 169 | clb_arctic_a0269.wav|bdl_arctic_a0269.wav 170 | clb_arctic_a0270.wav|bdl_arctic_a0270.wav 171 | clb_arctic_a0271.wav|bdl_arctic_a0271.wav 172 | clb_arctic_a0272.wav|bdl_arctic_a0272.wav 173 | clb_arctic_a0273.wav|bdl_arctic_a0273.wav 174 | clb_arctic_a0274.wav|bdl_arctic_a0274.wav 175 | clb_arctic_a0275.wav|bdl_arctic_a0275.wav 176 | clb_arctic_a0276.wav|bdl_arctic_a0276.wav 177 | clb_arctic_a0277.wav|bdl_arctic_a0277.wav 178 | clb_arctic_a0278.wav|bdl_arctic_a0278.wav 179 | clb_arctic_a0279.wav|bdl_arctic_a0279.wav 180 | clb_arctic_a0280.wav|bdl_arctic_a0280.wav 181 | clb_arctic_a0281.wav|bdl_arctic_a0281.wav 182 | clb_arctic_a0282.wav|bdl_arctic_a0282.wav 183 | clb_arctic_a0283.wav|bdl_arctic_a0283.wav 184 | clb_arctic_a0284.wav|bdl_arctic_a0284.wav 185 | clb_arctic_a0285.wav|bdl_arctic_a0285.wav 186 | clb_arctic_a0286.wav|bdl_arctic_a0286.wav 187 | clb_arctic_a0287.wav|bdl_arctic_a0287.wav 188 | clb_arctic_a0288.wav|bdl_arctic_a0288.wav 189 | clb_arctic_a0289.wav|bdl_arctic_a0289.wav 190 | clb_arctic_a0290.wav|bdl_arctic_a0290.wav 191 | clb_arctic_a0291.wav|bdl_arctic_a0291.wav 192 | clb_arctic_a0292.wav|bdl_arctic_a0292.wav 193 | clb_arctic_a0293.wav|bdl_arctic_a0293.wav 194 | clb_arctic_a0294.wav|bdl_arctic_a0294.wav 195 | clb_arctic_a0295.wav|bdl_arctic_a0295.wav 196 | clb_arctic_a0296.wav|bdl_arctic_a0296.wav 197 | clb_arctic_a0297.wav|bdl_arctic_a0297.wav 198 | clb_arctic_a0298.wav|bdl_arctic_a0298.wav 199 | clb_arctic_a0299.wav|bdl_arctic_a0299.wav 200 | clb_arctic_a0300.wav|bdl_arctic_a0300.wav 201 | clb_arctic_a0301.wav|bdl_arctic_a0301.wav 202 | clb_arctic_a0302.wav|bdl_arctic_a0302.wav 203 | clb_arctic_a0303.wav|bdl_arctic_a0303.wav 204 | clb_arctic_a0304.wav|bdl_arctic_a0304.wav 205 | clb_arctic_a0305.wav|bdl_arctic_a0305.wav 206 | clb_arctic_a0306.wav|bdl_arctic_a0306.wav 207 | clb_arctic_a0307.wav|bdl_arctic_a0307.wav 208 | clb_arctic_a0308.wav|bdl_arctic_a0308.wav 209 | clb_arctic_a0309.wav|bdl_arctic_a0309.wav 210 | clb_arctic_a0310.wav|bdl_arctic_a0310.wav 211 | clb_arctic_a0311.wav|bdl_arctic_a0311.wav 212 | clb_arctic_a0312.wav|bdl_arctic_a0312.wav 213 | clb_arctic_a0313.wav|bdl_arctic_a0313.wav 214 | clb_arctic_a0314.wav|bdl_arctic_a0314.wav 215 | clb_arctic_a0315.wav|bdl_arctic_a0315.wav 216 | clb_arctic_a0316.wav|bdl_arctic_a0316.wav 217 | clb_arctic_a0317.wav|bdl_arctic_a0317.wav 218 | clb_arctic_a0318.wav|bdl_arctic_a0318.wav 219 | clb_arctic_a0319.wav|bdl_arctic_a0319.wav 220 | clb_arctic_a0320.wav|bdl_arctic_a0320.wav 221 | clb_arctic_a0321.wav|bdl_arctic_a0321.wav 222 | clb_arctic_a0322.wav|bdl_arctic_a0322.wav 223 | clb_arctic_a0323.wav|bdl_arctic_a0323.wav 224 | clb_arctic_a0324.wav|bdl_arctic_a0324.wav 225 | clb_arctic_a0325.wav|bdl_arctic_a0325.wav 226 | clb_arctic_a0326.wav|bdl_arctic_a0326.wav 227 | clb_arctic_a0327.wav|bdl_arctic_a0327.wav 228 | clb_arctic_a0328.wav|bdl_arctic_a0328.wav 229 | clb_arctic_a0329.wav|bdl_arctic_a0329.wav 230 | clb_arctic_a0330.wav|bdl_arctic_a0330.wav 231 | clb_arctic_a0331.wav|bdl_arctic_a0331.wav 232 | clb_arctic_a0332.wav|bdl_arctic_a0332.wav 233 | clb_arctic_a0333.wav|bdl_arctic_a0333.wav 234 | clb_arctic_a0334.wav|bdl_arctic_a0334.wav 235 | clb_arctic_a0335.wav|bdl_arctic_a0335.wav 236 | clb_arctic_a0336.wav|bdl_arctic_a0336.wav 237 | clb_arctic_a0337.wav|bdl_arctic_a0337.wav 238 | clb_arctic_a0338.wav|bdl_arctic_a0338.wav 239 | clb_arctic_a0339.wav|bdl_arctic_a0339.wav 240 | clb_arctic_a0340.wav|bdl_arctic_a0340.wav 241 | clb_arctic_a0341.wav|bdl_arctic_a0341.wav 242 | clb_arctic_a0342.wav|bdl_arctic_a0342.wav 243 | clb_arctic_a0343.wav|bdl_arctic_a0343.wav 244 | clb_arctic_a0344.wav|bdl_arctic_a0344.wav 245 | clb_arctic_a0345.wav|bdl_arctic_a0345.wav 246 | clb_arctic_a0346.wav|bdl_arctic_a0346.wav 247 | clb_arctic_a0347.wav|bdl_arctic_a0347.wav 248 | clb_arctic_a0348.wav|bdl_arctic_a0348.wav 249 | clb_arctic_a0349.wav|bdl_arctic_a0349.wav 250 | clb_arctic_a0350.wav|bdl_arctic_a0350.wav 251 | clb_arctic_a0351.wav|bdl_arctic_a0351.wav 252 | clb_arctic_a0352.wav|bdl_arctic_a0352.wav 253 | clb_arctic_a0353.wav|bdl_arctic_a0353.wav 254 | clb_arctic_a0354.wav|bdl_arctic_a0354.wav 255 | clb_arctic_a0355.wav|bdl_arctic_a0355.wav 256 | clb_arctic_a0356.wav|bdl_arctic_a0356.wav 257 | clb_arctic_a0357.wav|bdl_arctic_a0357.wav 258 | clb_arctic_a0358.wav|bdl_arctic_a0358.wav 259 | clb_arctic_a0359.wav|bdl_arctic_a0359.wav 260 | clb_arctic_a0360.wav|bdl_arctic_a0360.wav 261 | clb_arctic_a0361.wav|bdl_arctic_a0361.wav 262 | clb_arctic_a0362.wav|bdl_arctic_a0362.wav 263 | clb_arctic_a0363.wav|bdl_arctic_a0363.wav 264 | clb_arctic_a0364.wav|bdl_arctic_a0364.wav 265 | clb_arctic_a0365.wav|bdl_arctic_a0365.wav 266 | clb_arctic_a0366.wav|bdl_arctic_a0366.wav 267 | clb_arctic_a0367.wav|bdl_arctic_a0367.wav 268 | clb_arctic_a0368.wav|bdl_arctic_a0368.wav 269 | clb_arctic_a0369.wav|bdl_arctic_a0369.wav 270 | clb_arctic_a0370.wav|bdl_arctic_a0370.wav 271 | clb_arctic_a0371.wav|bdl_arctic_a0371.wav 272 | clb_arctic_a0372.wav|bdl_arctic_a0372.wav 273 | clb_arctic_a0373.wav|bdl_arctic_a0373.wav 274 | clb_arctic_a0374.wav|bdl_arctic_a0374.wav 275 | clb_arctic_a0375.wav|bdl_arctic_a0375.wav 276 | clb_arctic_a0376.wav|bdl_arctic_a0376.wav 277 | clb_arctic_a0377.wav|bdl_arctic_a0377.wav 278 | clb_arctic_a0378.wav|bdl_arctic_a0378.wav 279 | clb_arctic_a0379.wav|bdl_arctic_a0379.wav 280 | clb_arctic_a0380.wav|bdl_arctic_a0380.wav 281 | clb_arctic_a0381.wav|bdl_arctic_a0381.wav 282 | clb_arctic_a0382.wav|bdl_arctic_a0382.wav 283 | clb_arctic_a0383.wav|bdl_arctic_a0383.wav 284 | clb_arctic_a0384.wav|bdl_arctic_a0384.wav 285 | clb_arctic_a0385.wav|bdl_arctic_a0385.wav 286 | clb_arctic_a0386.wav|bdl_arctic_a0386.wav 287 | clb_arctic_a0387.wav|bdl_arctic_a0387.wav 288 | clb_arctic_a0388.wav|bdl_arctic_a0388.wav 289 | clb_arctic_a0389.wav|bdl_arctic_a0389.wav 290 | clb_arctic_a0390.wav|bdl_arctic_a0390.wav 291 | clb_arctic_a0391.wav|bdl_arctic_a0391.wav 292 | clb_arctic_a0392.wav|bdl_arctic_a0392.wav 293 | clb_arctic_a0393.wav|bdl_arctic_a0393.wav 294 | clb_arctic_a0394.wav|bdl_arctic_a0394.wav 295 | clb_arctic_a0395.wav|bdl_arctic_a0395.wav 296 | clb_arctic_a0396.wav|bdl_arctic_a0396.wav 297 | clb_arctic_a0397.wav|bdl_arctic_a0397.wav 298 | clb_arctic_a0398.wav|bdl_arctic_a0398.wav 299 | clb_arctic_a0399.wav|bdl_arctic_a0399.wav 300 | clb_arctic_a0400.wav|bdl_arctic_a0400.wav 301 | clb_arctic_a0401.wav|bdl_arctic_a0401.wav 302 | clb_arctic_a0402.wav|bdl_arctic_a0402.wav 303 | clb_arctic_a0403.wav|bdl_arctic_a0403.wav 304 | clb_arctic_a0404.wav|bdl_arctic_a0404.wav 305 | clb_arctic_a0405.wav|bdl_arctic_a0405.wav 306 | clb_arctic_a0406.wav|bdl_arctic_a0406.wav 307 | clb_arctic_a0407.wav|bdl_arctic_a0407.wav 308 | clb_arctic_a0408.wav|bdl_arctic_a0408.wav 309 | clb_arctic_a0409.wav|bdl_arctic_a0409.wav 310 | clb_arctic_a0410.wav|bdl_arctic_a0410.wav 311 | clb_arctic_a0411.wav|bdl_arctic_a0411.wav 312 | clb_arctic_a0412.wav|bdl_arctic_a0412.wav 313 | clb_arctic_a0413.wav|bdl_arctic_a0413.wav 314 | clb_arctic_a0414.wav|bdl_arctic_a0414.wav 315 | clb_arctic_a0415.wav|bdl_arctic_a0415.wav 316 | clb_arctic_a0416.wav|bdl_arctic_a0416.wav 317 | clb_arctic_a0417.wav|bdl_arctic_a0417.wav 318 | clb_arctic_a0418.wav|bdl_arctic_a0418.wav 319 | clb_arctic_a0419.wav|bdl_arctic_a0419.wav 320 | clb_arctic_a0420.wav|bdl_arctic_a0420.wav 321 | clb_arctic_a0421.wav|bdl_arctic_a0421.wav 322 | clb_arctic_a0422.wav|bdl_arctic_a0422.wav 323 | clb_arctic_a0423.wav|bdl_arctic_a0423.wav 324 | clb_arctic_a0424.wav|bdl_arctic_a0424.wav 325 | clb_arctic_a0425.wav|bdl_arctic_a0425.wav 326 | clb_arctic_a0426.wav|bdl_arctic_a0426.wav 327 | clb_arctic_a0427.wav|bdl_arctic_a0427.wav 328 | clb_arctic_a0428.wav|bdl_arctic_a0428.wav 329 | clb_arctic_a0429.wav|bdl_arctic_a0429.wav 330 | clb_arctic_a0430.wav|bdl_arctic_a0430.wav 331 | clb_arctic_a0431.wav|bdl_arctic_a0431.wav 332 | clb_arctic_a0432.wav|bdl_arctic_a0432.wav 333 | clb_arctic_a0433.wav|bdl_arctic_a0433.wav 334 | clb_arctic_a0434.wav|bdl_arctic_a0434.wav 335 | clb_arctic_a0435.wav|bdl_arctic_a0435.wav 336 | clb_arctic_a0436.wav|bdl_arctic_a0436.wav 337 | clb_arctic_a0437.wav|bdl_arctic_a0437.wav 338 | clb_arctic_a0438.wav|bdl_arctic_a0438.wav 339 | clb_arctic_a0439.wav|bdl_arctic_a0439.wav 340 | clb_arctic_a0440.wav|bdl_arctic_a0440.wav 341 | clb_arctic_a0441.wav|bdl_arctic_a0441.wav 342 | clb_arctic_a0442.wav|bdl_arctic_a0442.wav 343 | clb_arctic_a0443.wav|bdl_arctic_a0443.wav 344 | clb_arctic_a0444.wav|bdl_arctic_a0444.wav 345 | clb_arctic_a0445.wav|bdl_arctic_a0445.wav 346 | clb_arctic_a0446.wav|bdl_arctic_a0446.wav 347 | clb_arctic_a0447.wav|bdl_arctic_a0447.wav 348 | clb_arctic_a0448.wav|bdl_arctic_a0448.wav 349 | clb_arctic_a0449.wav|bdl_arctic_a0449.wav 350 | clb_arctic_a0450.wav|bdl_arctic_a0450.wav 351 | clb_arctic_a0451.wav|bdl_arctic_a0451.wav 352 | clb_arctic_a0452.wav|bdl_arctic_a0452.wav 353 | clb_arctic_a0453.wav|bdl_arctic_a0453.wav 354 | clb_arctic_a0454.wav|bdl_arctic_a0454.wav 355 | clb_arctic_a0455.wav|bdl_arctic_a0455.wav 356 | clb_arctic_a0456.wav|bdl_arctic_a0456.wav 357 | clb_arctic_a0457.wav|bdl_arctic_a0457.wav 358 | clb_arctic_a0458.wav|bdl_arctic_a0458.wav 359 | clb_arctic_a0459.wav|bdl_arctic_a0459.wav 360 | clb_arctic_a0460.wav|bdl_arctic_a0460.wav 361 | clb_arctic_a0461.wav|bdl_arctic_a0461.wav 362 | clb_arctic_a0462.wav|bdl_arctic_a0462.wav 363 | clb_arctic_a0463.wav|bdl_arctic_a0463.wav 364 | clb_arctic_a0464.wav|bdl_arctic_a0464.wav 365 | clb_arctic_a0465.wav|bdl_arctic_a0465.wav 366 | clb_arctic_a0466.wav|bdl_arctic_a0466.wav 367 | clb_arctic_a0467.wav|bdl_arctic_a0467.wav 368 | clb_arctic_a0468.wav|bdl_arctic_a0468.wav 369 | clb_arctic_a0469.wav|bdl_arctic_a0469.wav 370 | clb_arctic_a0470.wav|bdl_arctic_a0470.wav 371 | clb_arctic_a0471.wav|bdl_arctic_a0471.wav 372 | clb_arctic_a0472.wav|bdl_arctic_a0472.wav 373 | clb_arctic_a0473.wav|bdl_arctic_a0473.wav 374 | clb_arctic_a0474.wav|bdl_arctic_a0474.wav 375 | clb_arctic_a0475.wav|bdl_arctic_a0475.wav 376 | clb_arctic_a0476.wav|bdl_arctic_a0476.wav 377 | clb_arctic_a0477.wav|bdl_arctic_a0477.wav 378 | clb_arctic_a0478.wav|bdl_arctic_a0478.wav 379 | clb_arctic_a0479.wav|bdl_arctic_a0479.wav 380 | clb_arctic_a0480.wav|bdl_arctic_a0480.wav 381 | clb_arctic_a0481.wav|bdl_arctic_a0481.wav 382 | clb_arctic_a0482.wav|bdl_arctic_a0482.wav 383 | clb_arctic_a0483.wav|bdl_arctic_a0483.wav 384 | clb_arctic_a0484.wav|bdl_arctic_a0484.wav 385 | clb_arctic_a0485.wav|bdl_arctic_a0485.wav 386 | clb_arctic_a0486.wav|bdl_arctic_a0486.wav 387 | clb_arctic_a0487.wav|bdl_arctic_a0487.wav 388 | clb_arctic_a0488.wav|bdl_arctic_a0488.wav 389 | clb_arctic_a0489.wav|bdl_arctic_a0489.wav 390 | clb_arctic_a0490.wav|bdl_arctic_a0490.wav 391 | clb_arctic_a0491.wav|bdl_arctic_a0491.wav 392 | clb_arctic_a0492.wav|bdl_arctic_a0492.wav 393 | clb_arctic_a0493.wav|bdl_arctic_a0493.wav 394 | clb_arctic_a0494.wav|bdl_arctic_a0494.wav 395 | clb_arctic_a0495.wav|bdl_arctic_a0495.wav 396 | clb_arctic_a0496.wav|bdl_arctic_a0496.wav 397 | clb_arctic_a0497.wav|bdl_arctic_a0497.wav 398 | clb_arctic_a0498.wav|bdl_arctic_a0498.wav 399 | clb_arctic_a0499.wav|bdl_arctic_a0499.wav 400 | clb_arctic_a0500.wav|bdl_arctic_a0500.wav 401 | clb_arctic_a0501.wav|bdl_arctic_a0501.wav 402 | clb_arctic_a0502.wav|bdl_arctic_a0502.wav 403 | clb_arctic_a0503.wav|bdl_arctic_a0503.wav 404 | clb_arctic_a0504.wav|bdl_arctic_a0504.wav 405 | clb_arctic_a0505.wav|bdl_arctic_a0505.wav 406 | clb_arctic_a0506.wav|bdl_arctic_a0506.wav 407 | clb_arctic_a0507.wav|bdl_arctic_a0507.wav 408 | clb_arctic_a0508.wav|bdl_arctic_a0508.wav 409 | clb_arctic_a0509.wav|bdl_arctic_a0509.wav 410 | clb_arctic_a0510.wav|bdl_arctic_a0510.wav 411 | clb_arctic_a0511.wav|bdl_arctic_a0511.wav 412 | clb_arctic_a0512.wav|bdl_arctic_a0512.wav 413 | clb_arctic_a0513.wav|bdl_arctic_a0513.wav 414 | clb_arctic_a0514.wav|bdl_arctic_a0514.wav 415 | clb_arctic_a0515.wav|bdl_arctic_a0515.wav 416 | clb_arctic_a0516.wav|bdl_arctic_a0516.wav 417 | clb_arctic_a0517.wav|bdl_arctic_a0517.wav 418 | clb_arctic_a0518.wav|bdl_arctic_a0518.wav 419 | clb_arctic_a0519.wav|bdl_arctic_a0519.wav 420 | clb_arctic_a0520.wav|bdl_arctic_a0520.wav 421 | clb_arctic_a0521.wav|bdl_arctic_a0521.wav 422 | clb_arctic_a0522.wav|bdl_arctic_a0522.wav 423 | clb_arctic_a0523.wav|bdl_arctic_a0523.wav 424 | clb_arctic_a0524.wav|bdl_arctic_a0524.wav 425 | clb_arctic_a0525.wav|bdl_arctic_a0525.wav 426 | clb_arctic_a0526.wav|bdl_arctic_a0526.wav 427 | clb_arctic_a0527.wav|bdl_arctic_a0527.wav 428 | clb_arctic_a0528.wav|bdl_arctic_a0528.wav 429 | clb_arctic_a0529.wav|bdl_arctic_a0529.wav 430 | clb_arctic_a0530.wav|bdl_arctic_a0530.wav 431 | clb_arctic_a0531.wav|bdl_arctic_a0531.wav 432 | clb_arctic_a0532.wav|bdl_arctic_a0532.wav 433 | clb_arctic_a0533.wav|bdl_arctic_a0533.wav 434 | clb_arctic_a0534.wav|bdl_arctic_a0534.wav 435 | clb_arctic_a0535.wav|bdl_arctic_a0535.wav 436 | clb_arctic_a0536.wav|bdl_arctic_a0536.wav 437 | clb_arctic_a0537.wav|bdl_arctic_a0537.wav 438 | clb_arctic_a0538.wav|bdl_arctic_a0538.wav 439 | clb_arctic_a0539.wav|bdl_arctic_a0539.wav 440 | clb_arctic_a0540.wav|bdl_arctic_a0540.wav 441 | clb_arctic_a0541.wav|bdl_arctic_a0541.wav 442 | clb_arctic_a0542.wav|bdl_arctic_a0542.wav 443 | clb_arctic_a0543.wav|bdl_arctic_a0543.wav 444 | clb_arctic_a0544.wav|bdl_arctic_a0544.wav 445 | clb_arctic_a0545.wav|bdl_arctic_a0545.wav 446 | clb_arctic_a0546.wav|bdl_arctic_a0546.wav 447 | clb_arctic_a0547.wav|bdl_arctic_a0547.wav 448 | clb_arctic_a0548.wav|bdl_arctic_a0548.wav 449 | clb_arctic_a0549.wav|bdl_arctic_a0549.wav 450 | clb_arctic_a0550.wav|bdl_arctic_a0550.wav 451 | clb_arctic_a0551.wav|bdl_arctic_a0551.wav 452 | clb_arctic_a0552.wav|bdl_arctic_a0552.wav 453 | clb_arctic_a0553.wav|bdl_arctic_a0553.wav 454 | clb_arctic_a0554.wav|bdl_arctic_a0554.wav 455 | clb_arctic_a0555.wav|bdl_arctic_a0555.wav 456 | clb_arctic_a0556.wav|bdl_arctic_a0556.wav 457 | clb_arctic_a0557.wav|bdl_arctic_a0557.wav 458 | clb_arctic_a0558.wav|bdl_arctic_a0558.wav 459 | clb_arctic_a0559.wav|bdl_arctic_a0559.wav 460 | clb_arctic_a0560.wav|bdl_arctic_a0560.wav 461 | clb_arctic_a0561.wav|bdl_arctic_a0561.wav 462 | clb_arctic_a0562.wav|bdl_arctic_a0562.wav 463 | clb_arctic_a0563.wav|bdl_arctic_a0563.wav 464 | clb_arctic_a0564.wav|bdl_arctic_a0564.wav 465 | clb_arctic_a0565.wav|bdl_arctic_a0565.wav 466 | clb_arctic_a0566.wav|bdl_arctic_a0566.wav 467 | clb_arctic_a0567.wav|bdl_arctic_a0567.wav 468 | clb_arctic_a0568.wav|bdl_arctic_a0568.wav 469 | clb_arctic_a0569.wav|bdl_arctic_a0569.wav 470 | clb_arctic_a0570.wav|bdl_arctic_a0570.wav 471 | clb_arctic_a0571.wav|bdl_arctic_a0571.wav 472 | clb_arctic_a0572.wav|bdl_arctic_a0572.wav 473 | clb_arctic_a0573.wav|bdl_arctic_a0573.wav 474 | clb_arctic_a0574.wav|bdl_arctic_a0574.wav 475 | clb_arctic_a0575.wav|bdl_arctic_a0575.wav 476 | clb_arctic_a0576.wav|bdl_arctic_a0576.wav 477 | clb_arctic_a0577.wav|bdl_arctic_a0577.wav 478 | clb_arctic_a0578.wav|bdl_arctic_a0578.wav 479 | clb_arctic_a0579.wav|bdl_arctic_a0579.wav 480 | clb_arctic_a0580.wav|bdl_arctic_a0580.wav 481 | clb_arctic_a0581.wav|bdl_arctic_a0581.wav 482 | clb_arctic_a0582.wav|bdl_arctic_a0582.wav 483 | clb_arctic_a0583.wav|bdl_arctic_a0583.wav 484 | clb_arctic_a0584.wav|bdl_arctic_a0584.wav 485 | clb_arctic_a0585.wav|bdl_arctic_a0585.wav 486 | clb_arctic_a0586.wav|bdl_arctic_a0586.wav 487 | clb_arctic_a0587.wav|bdl_arctic_a0587.wav 488 | clb_arctic_a0588.wav|bdl_arctic_a0588.wav 489 | clb_arctic_a0589.wav|bdl_arctic_a0589.wav 490 | clb_arctic_a0590.wav|bdl_arctic_a0590.wav 491 | clb_arctic_a0591.wav|bdl_arctic_a0591.wav 492 | clb_arctic_a0592.wav|bdl_arctic_a0592.wav 493 | clb_arctic_a0593.wav|bdl_arctic_a0593.wav 494 | clb_arctic_b0001.wav|bdl_arctic_b0001.wav 495 | clb_arctic_b0002.wav|bdl_arctic_b0002.wav 496 | clb_arctic_b0003.wav|bdl_arctic_b0003.wav 497 | clb_arctic_b0004.wav|bdl_arctic_b0004.wav 498 | clb_arctic_b0005.wav|bdl_arctic_b0005.wav 499 | clb_arctic_b0006.wav|bdl_arctic_b0006.wav 500 | clb_arctic_b0007.wav|bdl_arctic_b0007.wav 501 | clb_arctic_b0008.wav|bdl_arctic_b0008.wav 502 | clb_arctic_b0009.wav|bdl_arctic_b0009.wav 503 | clb_arctic_b0010.wav|bdl_arctic_b0010.wav 504 | clb_arctic_b0011.wav|bdl_arctic_b0011.wav 505 | clb_arctic_b0012.wav|bdl_arctic_b0012.wav 506 | clb_arctic_b0013.wav|bdl_arctic_b0013.wav 507 | clb_arctic_b0014.wav|bdl_arctic_b0014.wav 508 | clb_arctic_b0015.wav|bdl_arctic_b0015.wav 509 | clb_arctic_b0016.wav|bdl_arctic_b0016.wav 510 | clb_arctic_b0017.wav|bdl_arctic_b0017.wav 511 | clb_arctic_b0018.wav|bdl_arctic_b0018.wav 512 | clb_arctic_b0019.wav|bdl_arctic_b0019.wav 513 | clb_arctic_b0020.wav|bdl_arctic_b0020.wav 514 | clb_arctic_b0021.wav|bdl_arctic_b0021.wav 515 | clb_arctic_b0022.wav|bdl_arctic_b0022.wav 516 | clb_arctic_b0023.wav|bdl_arctic_b0023.wav 517 | clb_arctic_b0024.wav|bdl_arctic_b0024.wav 518 | clb_arctic_b0025.wav|bdl_arctic_b0025.wav 519 | clb_arctic_b0026.wav|bdl_arctic_b0026.wav 520 | clb_arctic_b0027.wav|bdl_arctic_b0027.wav 521 | clb_arctic_b0028.wav|bdl_arctic_b0028.wav 522 | clb_arctic_b0029.wav|bdl_arctic_b0029.wav 523 | clb_arctic_b0030.wav|bdl_arctic_b0030.wav 524 | clb_arctic_b0031.wav|bdl_arctic_b0031.wav 525 | clb_arctic_b0032.wav|bdl_arctic_b0032.wav 526 | clb_arctic_b0033.wav|bdl_arctic_b0033.wav 527 | clb_arctic_b0034.wav|bdl_arctic_b0034.wav 528 | clb_arctic_b0035.wav|bdl_arctic_b0035.wav 529 | clb_arctic_b0036.wav|bdl_arctic_b0036.wav 530 | clb_arctic_b0037.wav|bdl_arctic_b0037.wav 531 | clb_arctic_b0038.wav|bdl_arctic_b0038.wav 532 | clb_arctic_b0039.wav|bdl_arctic_b0039.wav 533 | clb_arctic_b0040.wav|bdl_arctic_b0040.wav 534 | clb_arctic_b0041.wav|bdl_arctic_b0041.wav 535 | clb_arctic_b0042.wav|bdl_arctic_b0042.wav 536 | clb_arctic_b0043.wav|bdl_arctic_b0043.wav 537 | clb_arctic_b0044.wav|bdl_arctic_b0044.wav 538 | clb_arctic_b0045.wav|bdl_arctic_b0045.wav 539 | clb_arctic_b0046.wav|bdl_arctic_b0046.wav 540 | clb_arctic_b0047.wav|bdl_arctic_b0047.wav 541 | clb_arctic_b0048.wav|bdl_arctic_b0048.wav 542 | clb_arctic_b0049.wav|bdl_arctic_b0049.wav 543 | clb_arctic_b0050.wav|bdl_arctic_b0050.wav 544 | clb_arctic_b0051.wav|bdl_arctic_b0051.wav 545 | clb_arctic_b0052.wav|bdl_arctic_b0052.wav 546 | clb_arctic_b0053.wav|bdl_arctic_b0053.wav 547 | clb_arctic_b0054.wav|bdl_arctic_b0054.wav 548 | clb_arctic_b0055.wav|bdl_arctic_b0055.wav 549 | clb_arctic_b0056.wav|bdl_arctic_b0056.wav 550 | clb_arctic_b0057.wav|bdl_arctic_b0057.wav 551 | clb_arctic_b0058.wav|bdl_arctic_b0058.wav 552 | clb_arctic_b0059.wav|bdl_arctic_b0059.wav 553 | clb_arctic_b0060.wav|bdl_arctic_b0060.wav 554 | clb_arctic_b0061.wav|bdl_arctic_b0061.wav 555 | clb_arctic_b0062.wav|bdl_arctic_b0062.wav 556 | clb_arctic_b0063.wav|bdl_arctic_b0063.wav 557 | clb_arctic_b0064.wav|bdl_arctic_b0064.wav 558 | clb_arctic_b0065.wav|bdl_arctic_b0065.wav 559 | clb_arctic_b0066.wav|bdl_arctic_b0066.wav 560 | clb_arctic_b0067.wav|bdl_arctic_b0067.wav 561 | clb_arctic_b0068.wav|bdl_arctic_b0068.wav 562 | clb_arctic_b0069.wav|bdl_arctic_b0069.wav 563 | clb_arctic_b0070.wav|bdl_arctic_b0070.wav 564 | clb_arctic_b0071.wav|bdl_arctic_b0071.wav 565 | clb_arctic_b0072.wav|bdl_arctic_b0072.wav 566 | clb_arctic_b0073.wav|bdl_arctic_b0073.wav 567 | clb_arctic_b0074.wav|bdl_arctic_b0074.wav 568 | clb_arctic_b0075.wav|bdl_arctic_b0075.wav 569 | clb_arctic_b0076.wav|bdl_arctic_b0076.wav 570 | clb_arctic_b0077.wav|bdl_arctic_b0077.wav 571 | clb_arctic_b0078.wav|bdl_arctic_b0078.wav 572 | clb_arctic_b0079.wav|bdl_arctic_b0079.wav 573 | clb_arctic_b0080.wav|bdl_arctic_b0080.wav 574 | clb_arctic_b0081.wav|bdl_arctic_b0081.wav 575 | clb_arctic_b0082.wav|bdl_arctic_b0082.wav 576 | clb_arctic_b0083.wav|bdl_arctic_b0083.wav 577 | clb_arctic_b0084.wav|bdl_arctic_b0084.wav 578 | clb_arctic_b0085.wav|bdl_arctic_b0085.wav 579 | clb_arctic_b0086.wav|bdl_arctic_b0086.wav 580 | clb_arctic_b0087.wav|bdl_arctic_b0087.wav 581 | clb_arctic_b0088.wav|bdl_arctic_b0088.wav 582 | clb_arctic_b0089.wav|bdl_arctic_b0089.wav 583 | clb_arctic_b0090.wav|bdl_arctic_b0090.wav 584 | clb_arctic_b0091.wav|bdl_arctic_b0091.wav 585 | clb_arctic_b0092.wav|bdl_arctic_b0092.wav 586 | clb_arctic_b0093.wav|bdl_arctic_b0093.wav 587 | clb_arctic_b0094.wav|bdl_arctic_b0094.wav 588 | clb_arctic_b0095.wav|bdl_arctic_b0095.wav 589 | clb_arctic_b0096.wav|bdl_arctic_b0096.wav 590 | clb_arctic_b0097.wav|bdl_arctic_b0097.wav 591 | clb_arctic_b0098.wav|bdl_arctic_b0098.wav 592 | clb_arctic_b0099.wav|bdl_arctic_b0099.wav 593 | clb_arctic_b0100.wav|bdl_arctic_b0100.wav 594 | clb_arctic_b0101.wav|bdl_arctic_b0101.wav 595 | clb_arctic_b0102.wav|bdl_arctic_b0102.wav 596 | clb_arctic_b0103.wav|bdl_arctic_b0103.wav 597 | clb_arctic_b0104.wav|bdl_arctic_b0104.wav 598 | clb_arctic_b0105.wav|bdl_arctic_b0105.wav 599 | clb_arctic_b0106.wav|bdl_arctic_b0106.wav 600 | clb_arctic_b0107.wav|bdl_arctic_b0107.wav 601 | clb_arctic_b0108.wav|bdl_arctic_b0108.wav 602 | clb_arctic_b0109.wav|bdl_arctic_b0109.wav 603 | clb_arctic_b0110.wav|bdl_arctic_b0110.wav 604 | clb_arctic_b0111.wav|bdl_arctic_b0111.wav 605 | clb_arctic_b0112.wav|bdl_arctic_b0112.wav 606 | clb_arctic_b0113.wav|bdl_arctic_b0113.wav 607 | clb_arctic_b0114.wav|bdl_arctic_b0114.wav 608 | clb_arctic_b0115.wav|bdl_arctic_b0115.wav 609 | clb_arctic_b0116.wav|bdl_arctic_b0116.wav 610 | clb_arctic_b0117.wav|bdl_arctic_b0117.wav 611 | clb_arctic_b0118.wav|bdl_arctic_b0118.wav 612 | clb_arctic_b0119.wav|bdl_arctic_b0119.wav 613 | clb_arctic_b0120.wav|bdl_arctic_b0120.wav 614 | clb_arctic_b0121.wav|bdl_arctic_b0121.wav 615 | clb_arctic_b0122.wav|bdl_arctic_b0122.wav 616 | clb_arctic_b0123.wav|bdl_arctic_b0123.wav 617 | clb_arctic_b0124.wav|bdl_arctic_b0124.wav 618 | clb_arctic_b0125.wav|bdl_arctic_b0125.wav 619 | clb_arctic_b0126.wav|bdl_arctic_b0126.wav 620 | clb_arctic_b0127.wav|bdl_arctic_b0127.wav 621 | clb_arctic_b0128.wav|bdl_arctic_b0128.wav 622 | clb_arctic_b0129.wav|bdl_arctic_b0129.wav 623 | clb_arctic_b0130.wav|bdl_arctic_b0130.wav 624 | clb_arctic_b0131.wav|bdl_arctic_b0131.wav 625 | clb_arctic_b0132.wav|bdl_arctic_b0132.wav 626 | clb_arctic_b0133.wav|bdl_arctic_b0133.wav 627 | clb_arctic_b0134.wav|bdl_arctic_b0134.wav 628 | clb_arctic_b0135.wav|bdl_arctic_b0135.wav 629 | clb_arctic_b0136.wav|bdl_arctic_b0136.wav 630 | clb_arctic_b0137.wav|bdl_arctic_b0137.wav 631 | clb_arctic_b0138.wav|bdl_arctic_b0138.wav 632 | clb_arctic_b0139.wav|bdl_arctic_b0139.wav 633 | clb_arctic_b0140.wav|bdl_arctic_b0140.wav 634 | clb_arctic_b0141.wav|bdl_arctic_b0141.wav 635 | clb_arctic_b0142.wav|bdl_arctic_b0142.wav 636 | clb_arctic_b0143.wav|bdl_arctic_b0143.wav 637 | clb_arctic_b0144.wav|bdl_arctic_b0144.wav 638 | clb_arctic_b0145.wav|bdl_arctic_b0145.wav 639 | clb_arctic_b0146.wav|bdl_arctic_b0146.wav 640 | clb_arctic_b0147.wav|bdl_arctic_b0147.wav 641 | clb_arctic_b0148.wav|bdl_arctic_b0148.wav 642 | clb_arctic_b0149.wav|bdl_arctic_b0149.wav 643 | clb_arctic_b0150.wav|bdl_arctic_b0150.wav 644 | clb_arctic_b0151.wav|bdl_arctic_b0151.wav 645 | clb_arctic_b0152.wav|bdl_arctic_b0152.wav 646 | clb_arctic_b0153.wav|bdl_arctic_b0153.wav 647 | clb_arctic_b0154.wav|bdl_arctic_b0154.wav 648 | clb_arctic_b0155.wav|bdl_arctic_b0155.wav 649 | clb_arctic_b0156.wav|bdl_arctic_b0156.wav 650 | clb_arctic_b0157.wav|bdl_arctic_b0157.wav 651 | clb_arctic_b0158.wav|bdl_arctic_b0158.wav 652 | clb_arctic_b0159.wav|bdl_arctic_b0159.wav 653 | clb_arctic_b0160.wav|bdl_arctic_b0160.wav 654 | clb_arctic_b0161.wav|bdl_arctic_b0161.wav 655 | clb_arctic_b0162.wav|bdl_arctic_b0162.wav 656 | clb_arctic_b0163.wav|bdl_arctic_b0163.wav 657 | clb_arctic_b0164.wav|bdl_arctic_b0164.wav 658 | clb_arctic_b0165.wav|bdl_arctic_b0165.wav 659 | clb_arctic_b0166.wav|bdl_arctic_b0166.wav 660 | clb_arctic_b0167.wav|bdl_arctic_b0167.wav 661 | clb_arctic_b0168.wav|bdl_arctic_b0168.wav 662 | clb_arctic_b0169.wav|bdl_arctic_b0169.wav 663 | clb_arctic_b0170.wav|bdl_arctic_b0170.wav 664 | clb_arctic_b0171.wav|bdl_arctic_b0171.wav 665 | clb_arctic_b0172.wav|bdl_arctic_b0172.wav 666 | clb_arctic_b0173.wav|bdl_arctic_b0173.wav 667 | clb_arctic_b0174.wav|bdl_arctic_b0174.wav 668 | clb_arctic_b0175.wav|bdl_arctic_b0175.wav 669 | clb_arctic_b0176.wav|bdl_arctic_b0176.wav 670 | clb_arctic_b0177.wav|bdl_arctic_b0177.wav 671 | clb_arctic_b0178.wav|bdl_arctic_b0178.wav 672 | clb_arctic_b0179.wav|bdl_arctic_b0179.wav 673 | clb_arctic_b0180.wav|bdl_arctic_b0180.wav 674 | clb_arctic_b0181.wav|bdl_arctic_b0181.wav 675 | clb_arctic_b0182.wav|bdl_arctic_b0182.wav 676 | clb_arctic_b0183.wav|bdl_arctic_b0183.wav 677 | clb_arctic_b0184.wav|bdl_arctic_b0184.wav 678 | clb_arctic_b0185.wav|bdl_arctic_b0185.wav 679 | clb_arctic_b0186.wav|bdl_arctic_b0186.wav 680 | clb_arctic_b0187.wav|bdl_arctic_b0187.wav 681 | clb_arctic_b0188.wav|bdl_arctic_b0188.wav 682 | clb_arctic_b0189.wav|bdl_arctic_b0189.wav 683 | clb_arctic_b0190.wav|bdl_arctic_b0190.wav 684 | clb_arctic_b0191.wav|bdl_arctic_b0191.wav 685 | clb_arctic_b0192.wav|bdl_arctic_b0192.wav 686 | clb_arctic_b0193.wav|bdl_arctic_b0193.wav 687 | clb_arctic_b0194.wav|bdl_arctic_b0194.wav 688 | clb_arctic_b0195.wav|bdl_arctic_b0195.wav 689 | clb_arctic_b0196.wav|bdl_arctic_b0196.wav 690 | clb_arctic_b0197.wav|bdl_arctic_b0197.wav 691 | clb_arctic_b0198.wav|bdl_arctic_b0198.wav 692 | clb_arctic_b0199.wav|bdl_arctic_b0199.wav 693 | clb_arctic_b0200.wav|bdl_arctic_b0200.wav 694 | clb_arctic_b0201.wav|bdl_arctic_b0201.wav 695 | clb_arctic_b0202.wav|bdl_arctic_b0202.wav 696 | clb_arctic_b0203.wav|bdl_arctic_b0203.wav 697 | clb_arctic_b0204.wav|bdl_arctic_b0204.wav 698 | clb_arctic_b0205.wav|bdl_arctic_b0205.wav 699 | clb_arctic_b0206.wav|bdl_arctic_b0206.wav 700 | clb_arctic_b0207.wav|bdl_arctic_b0207.wav 701 | clb_arctic_b0208.wav|bdl_arctic_b0208.wav 702 | clb_arctic_b0209.wav|bdl_arctic_b0209.wav 703 | clb_arctic_b0210.wav|bdl_arctic_b0210.wav 704 | clb_arctic_b0211.wav|bdl_arctic_b0211.wav 705 | clb_arctic_b0212.wav|bdl_arctic_b0212.wav 706 | clb_arctic_b0213.wav|bdl_arctic_b0213.wav 707 | clb_arctic_b0214.wav|bdl_arctic_b0214.wav 708 | clb_arctic_b0215.wav|bdl_arctic_b0215.wav 709 | clb_arctic_b0216.wav|bdl_arctic_b0216.wav 710 | clb_arctic_b0217.wav|bdl_arctic_b0217.wav 711 | clb_arctic_b0218.wav|bdl_arctic_b0218.wav 712 | clb_arctic_b0219.wav|bdl_arctic_b0219.wav 713 | clb_arctic_b0220.wav|bdl_arctic_b0220.wav 714 | clb_arctic_b0221.wav|bdl_arctic_b0221.wav 715 | clb_arctic_b0222.wav|bdl_arctic_b0222.wav 716 | clb_arctic_b0223.wav|bdl_arctic_b0223.wav 717 | clb_arctic_b0224.wav|bdl_arctic_b0224.wav 718 | clb_arctic_b0225.wav|bdl_arctic_b0225.wav 719 | clb_arctic_b0226.wav|bdl_arctic_b0226.wav 720 | clb_arctic_b0227.wav|bdl_arctic_b0227.wav 721 | clb_arctic_b0228.wav|bdl_arctic_b0228.wav 722 | clb_arctic_b0229.wav|bdl_arctic_b0229.wav 723 | clb_arctic_b0230.wav|bdl_arctic_b0230.wav 724 | clb_arctic_b0231.wav|bdl_arctic_b0231.wav 725 | clb_arctic_b0232.wav|bdl_arctic_b0232.wav 726 | clb_arctic_b0233.wav|bdl_arctic_b0233.wav 727 | clb_arctic_b0234.wav|bdl_arctic_b0234.wav 728 | clb_arctic_b0235.wav|bdl_arctic_b0235.wav 729 | clb_arctic_b0236.wav|bdl_arctic_b0236.wav 730 | clb_arctic_b0237.wav|bdl_arctic_b0237.wav 731 | clb_arctic_b0238.wav|bdl_arctic_b0238.wav 732 | clb_arctic_b0239.wav|bdl_arctic_b0239.wav 733 | clb_arctic_b0240.wav|bdl_arctic_b0240.wav 734 | clb_arctic_b0241.wav|bdl_arctic_b0241.wav 735 | clb_arctic_b0242.wav|bdl_arctic_b0242.wav 736 | clb_arctic_b0243.wav|bdl_arctic_b0243.wav 737 | clb_arctic_b0244.wav|bdl_arctic_b0244.wav 738 | clb_arctic_b0245.wav|bdl_arctic_b0245.wav 739 | clb_arctic_b0246.wav|bdl_arctic_b0246.wav 740 | clb_arctic_b0247.wav|bdl_arctic_b0247.wav 741 | clb_arctic_b0248.wav|bdl_arctic_b0248.wav 742 | clb_arctic_b0249.wav|bdl_arctic_b0249.wav 743 | clb_arctic_b0250.wav|bdl_arctic_b0250.wav 744 | clb_arctic_b0251.wav|bdl_arctic_b0251.wav 745 | clb_arctic_b0252.wav|bdl_arctic_b0252.wav 746 | clb_arctic_b0253.wav|bdl_arctic_b0253.wav 747 | clb_arctic_b0254.wav|bdl_arctic_b0254.wav 748 | clb_arctic_b0255.wav|bdl_arctic_b0255.wav 749 | clb_arctic_b0256.wav|bdl_arctic_b0256.wav 750 | clb_arctic_b0257.wav|bdl_arctic_b0257.wav 751 | clb_arctic_b0258.wav|bdl_arctic_b0258.wav 752 | clb_arctic_b0259.wav|bdl_arctic_b0259.wav 753 | clb_arctic_b0260.wav|bdl_arctic_b0260.wav 754 | clb_arctic_b0261.wav|bdl_arctic_b0261.wav 755 | clb_arctic_b0262.wav|bdl_arctic_b0262.wav 756 | clb_arctic_b0263.wav|bdl_arctic_b0263.wav 757 | clb_arctic_b0264.wav|bdl_arctic_b0264.wav 758 | clb_arctic_b0265.wav|bdl_arctic_b0265.wav 759 | clb_arctic_b0266.wav|bdl_arctic_b0266.wav 760 | clb_arctic_b0267.wav|bdl_arctic_b0267.wav 761 | clb_arctic_b0268.wav|bdl_arctic_b0268.wav 762 | clb_arctic_b0269.wav|bdl_arctic_b0269.wav 763 | clb_arctic_b0270.wav|bdl_arctic_b0270.wav 764 | clb_arctic_b0271.wav|bdl_arctic_b0271.wav 765 | clb_arctic_b0272.wav|bdl_arctic_b0272.wav 766 | clb_arctic_b0273.wav|bdl_arctic_b0273.wav 767 | clb_arctic_b0274.wav|bdl_arctic_b0274.wav 768 | clb_arctic_b0275.wav|bdl_arctic_b0275.wav 769 | clb_arctic_b0276.wav|bdl_arctic_b0276.wav 770 | clb_arctic_b0277.wav|bdl_arctic_b0277.wav 771 | clb_arctic_b0278.wav|bdl_arctic_b0278.wav 772 | clb_arctic_b0279.wav|bdl_arctic_b0279.wav 773 | clb_arctic_b0280.wav|bdl_arctic_b0280.wav 774 | clb_arctic_b0281.wav|bdl_arctic_b0281.wav 775 | clb_arctic_b0282.wav|bdl_arctic_b0282.wav 776 | clb_arctic_b0283.wav|bdl_arctic_b0283.wav 777 | clb_arctic_b0284.wav|bdl_arctic_b0284.wav 778 | clb_arctic_b0285.wav|bdl_arctic_b0285.wav 779 | clb_arctic_b0286.wav|bdl_arctic_b0286.wav 780 | clb_arctic_b0287.wav|bdl_arctic_b0287.wav 781 | clb_arctic_b0288.wav|bdl_arctic_b0288.wav 782 | clb_arctic_b0289.wav|bdl_arctic_b0289.wav 783 | clb_arctic_b0290.wav|bdl_arctic_b0290.wav 784 | clb_arctic_b0291.wav|bdl_arctic_b0291.wav 785 | clb_arctic_b0292.wav|bdl_arctic_b0292.wav 786 | clb_arctic_b0293.wav|bdl_arctic_b0293.wav 787 | clb_arctic_b0294.wav|bdl_arctic_b0294.wav 788 | clb_arctic_b0295.wav|bdl_arctic_b0295.wav 789 | clb_arctic_b0296.wav|bdl_arctic_b0296.wav 790 | clb_arctic_b0297.wav|bdl_arctic_b0297.wav 791 | clb_arctic_b0298.wav|bdl_arctic_b0298.wav 792 | clb_arctic_b0299.wav|bdl_arctic_b0299.wav 793 | clb_arctic_b0300.wav|bdl_arctic_b0300.wav 794 | clb_arctic_b0301.wav|bdl_arctic_b0301.wav 795 | clb_arctic_b0302.wav|bdl_arctic_b0302.wav 796 | clb_arctic_b0303.wav|bdl_arctic_b0303.wav 797 | clb_arctic_b0304.wav|bdl_arctic_b0304.wav 798 | clb_arctic_b0305.wav|bdl_arctic_b0305.wav 799 | clb_arctic_b0306.wav|bdl_arctic_b0306.wav 800 | clb_arctic_b0307.wav|bdl_arctic_b0307.wav 801 | clb_arctic_b0308.wav|bdl_arctic_b0308.wav 802 | clb_arctic_b0309.wav|bdl_arctic_b0309.wav 803 | clb_arctic_b0310.wav|bdl_arctic_b0310.wav 804 | clb_arctic_b0311.wav|bdl_arctic_b0311.wav 805 | clb_arctic_b0312.wav|bdl_arctic_b0312.wav 806 | clb_arctic_b0313.wav|bdl_arctic_b0313.wav 807 | clb_arctic_b0314.wav|bdl_arctic_b0314.wav 808 | clb_arctic_b0315.wav|bdl_arctic_b0315.wav 809 | clb_arctic_b0316.wav|bdl_arctic_b0316.wav 810 | clb_arctic_b0317.wav|bdl_arctic_b0317.wav 811 | clb_arctic_b0318.wav|bdl_arctic_b0318.wav 812 | clb_arctic_b0319.wav|bdl_arctic_b0319.wav 813 | clb_arctic_b0320.wav|bdl_arctic_b0320.wav 814 | clb_arctic_b0321.wav|bdl_arctic_b0321.wav 815 | clb_arctic_b0322.wav|bdl_arctic_b0322.wav 816 | clb_arctic_b0323.wav|bdl_arctic_b0323.wav 817 | clb_arctic_b0324.wav|bdl_arctic_b0324.wav 818 | clb_arctic_b0325.wav|bdl_arctic_b0325.wav 819 | clb_arctic_b0326.wav|bdl_arctic_b0326.wav 820 | clb_arctic_b0327.wav|bdl_arctic_b0327.wav 821 | clb_arctic_b0328.wav|bdl_arctic_b0328.wav 822 | clb_arctic_b0329.wav|bdl_arctic_b0329.wav 823 | clb_arctic_b0330.wav|bdl_arctic_b0330.wav 824 | clb_arctic_b0331.wav|bdl_arctic_b0331.wav 825 | clb_arctic_b0332.wav|bdl_arctic_b0332.wav 826 | clb_arctic_b0333.wav|bdl_arctic_b0333.wav 827 | clb_arctic_b0334.wav|bdl_arctic_b0334.wav 828 | clb_arctic_b0335.wav|bdl_arctic_b0335.wav 829 | clb_arctic_b0336.wav|bdl_arctic_b0336.wav 830 | clb_arctic_b0337.wav|bdl_arctic_b0337.wav 831 | clb_arctic_b0338.wav|bdl_arctic_b0338.wav 832 | clb_arctic_b0339.wav|bdl_arctic_b0339.wav 833 | clb_arctic_b0340.wav|bdl_arctic_b0340.wav 834 | clb_arctic_b0341.wav|bdl_arctic_b0341.wav 835 | clb_arctic_b0342.wav|bdl_arctic_b0342.wav 836 | clb_arctic_b0343.wav|bdl_arctic_b0343.wav 837 | clb_arctic_b0344.wav|bdl_arctic_b0344.wav 838 | clb_arctic_b0345.wav|bdl_arctic_b0345.wav 839 | clb_arctic_b0346.wav|bdl_arctic_b0346.wav 840 | clb_arctic_b0347.wav|bdl_arctic_b0347.wav 841 | clb_arctic_b0348.wav|bdl_arctic_b0348.wav 842 | clb_arctic_b0349.wav|bdl_arctic_b0349.wav 843 | clb_arctic_b0350.wav|bdl_arctic_b0350.wav 844 | clb_arctic_b0351.wav|bdl_arctic_b0351.wav 845 | clb_arctic_b0352.wav|bdl_arctic_b0352.wav 846 | clb_arctic_b0353.wav|bdl_arctic_b0353.wav 847 | clb_arctic_b0354.wav|bdl_arctic_b0354.wav 848 | clb_arctic_b0355.wav|bdl_arctic_b0355.wav 849 | clb_arctic_b0356.wav|bdl_arctic_b0356.wav 850 | clb_arctic_b0357.wav|bdl_arctic_b0357.wav 851 | clb_arctic_b0358.wav|bdl_arctic_b0358.wav 852 | clb_arctic_b0359.wav|bdl_arctic_b0359.wav 853 | clb_arctic_b0360.wav|bdl_arctic_b0360.wav 854 | clb_arctic_b0361.wav|bdl_arctic_b0361.wav 855 | clb_arctic_b0362.wav|bdl_arctic_b0362.wav 856 | clb_arctic_b0363.wav|bdl_arctic_b0363.wav 857 | clb_arctic_b0364.wav|bdl_arctic_b0364.wav 858 | clb_arctic_b0365.wav|bdl_arctic_b0365.wav 859 | clb_arctic_b0366.wav|bdl_arctic_b0366.wav 860 | clb_arctic_b0367.wav|bdl_arctic_b0367.wav 861 | clb_arctic_b0368.wav|bdl_arctic_b0368.wav 862 | clb_arctic_b0369.wav|bdl_arctic_b0369.wav 863 | clb_arctic_b0370.wav|bdl_arctic_b0370.wav 864 | clb_arctic_b0371.wav|bdl_arctic_b0371.wav 865 | clb_arctic_b0372.wav|bdl_arctic_b0372.wav 866 | clb_arctic_b0373.wav|bdl_arctic_b0373.wav 867 | clb_arctic_b0374.wav|bdl_arctic_b0374.wav 868 | clb_arctic_b0375.wav|bdl_arctic_b0375.wav 869 | clb_arctic_b0376.wav|bdl_arctic_b0376.wav 870 | clb_arctic_b0377.wav|bdl_arctic_b0377.wav 871 | clb_arctic_b0378.wav|bdl_arctic_b0378.wav 872 | clb_arctic_b0379.wav|bdl_arctic_b0379.wav 873 | clb_arctic_b0380.wav|bdl_arctic_b0380.wav 874 | clb_arctic_b0381.wav|bdl_arctic_b0381.wav 875 | clb_arctic_b0382.wav|bdl_arctic_b0382.wav 876 | clb_arctic_b0383.wav|bdl_arctic_b0383.wav 877 | clb_arctic_b0384.wav|bdl_arctic_b0384.wav 878 | clb_arctic_b0385.wav|bdl_arctic_b0385.wav 879 | clb_arctic_b0386.wav|bdl_arctic_b0386.wav 880 | clb_arctic_b0387.wav|bdl_arctic_b0387.wav 881 | clb_arctic_b0388.wav|bdl_arctic_b0388.wav 882 | clb_arctic_b0389.wav|bdl_arctic_b0389.wav 883 | clb_arctic_b0390.wav|bdl_arctic_b0390.wav 884 | clb_arctic_b0391.wav|bdl_arctic_b0391.wav 885 | clb_arctic_b0392.wav|bdl_arctic_b0392.wav 886 | clb_arctic_b0393.wav|bdl_arctic_b0393.wav 887 | clb_arctic_b0394.wav|bdl_arctic_b0394.wav 888 | clb_arctic_b0395.wav|bdl_arctic_b0395.wav 889 | clb_arctic_b0396.wav|bdl_arctic_b0396.wav 890 | clb_arctic_b0397.wav|bdl_arctic_b0397.wav 891 | clb_arctic_b0398.wav|bdl_arctic_b0398.wav 892 | clb_arctic_b0399.wav|bdl_arctic_b0399.wav 893 | clb_arctic_b0400.wav|bdl_arctic_b0400.wav 894 | clb_arctic_b0401.wav|bdl_arctic_b0401.wav 895 | clb_arctic_b0402.wav|bdl_arctic_b0402.wav 896 | clb_arctic_b0403.wav|bdl_arctic_b0403.wav 897 | clb_arctic_b0404.wav|bdl_arctic_b0404.wav 898 | clb_arctic_b0405.wav|bdl_arctic_b0405.wav 899 | clb_arctic_b0406.wav|bdl_arctic_b0406.wav 900 | clb_arctic_b0407.wav|bdl_arctic_b0407.wav 901 | clb_arctic_b0408.wav|bdl_arctic_b0408.wav 902 | clb_arctic_b0409.wav|bdl_arctic_b0409.wav 903 | clb_arctic_b0410.wav|bdl_arctic_b0410.wav 904 | clb_arctic_b0411.wav|bdl_arctic_b0411.wav 905 | clb_arctic_b0412.wav|bdl_arctic_b0412.wav 906 | clb_arctic_b0413.wav|bdl_arctic_b0413.wav 907 | clb_arctic_b0414.wav|bdl_arctic_b0414.wav 908 | clb_arctic_b0415.wav|bdl_arctic_b0415.wav 909 | clb_arctic_b0416.wav|bdl_arctic_b0416.wav 910 | clb_arctic_b0417.wav|bdl_arctic_b0417.wav 911 | clb_arctic_b0418.wav|bdl_arctic_b0418.wav 912 | clb_arctic_b0419.wav|bdl_arctic_b0419.wav 913 | clb_arctic_b0420.wav|bdl_arctic_b0420.wav 914 | clb_arctic_b0421.wav|bdl_arctic_b0421.wav 915 | clb_arctic_b0422.wav|bdl_arctic_b0422.wav 916 | clb_arctic_b0423.wav|bdl_arctic_b0423.wav 917 | clb_arctic_b0424.wav|bdl_arctic_b0424.wav 918 | clb_arctic_b0425.wav|bdl_arctic_b0425.wav 919 | clb_arctic_b0426.wav|bdl_arctic_b0426.wav 920 | clb_arctic_b0427.wav|bdl_arctic_b0427.wav 921 | clb_arctic_b0428.wav|bdl_arctic_b0428.wav 922 | clb_arctic_b0429.wav|bdl_arctic_b0429.wav 923 | clb_arctic_b0430.wav|bdl_arctic_b0430.wav 924 | clb_arctic_b0431.wav|bdl_arctic_b0431.wav 925 | clb_arctic_b0432.wav|bdl_arctic_b0432.wav 926 | clb_arctic_b0433.wav|bdl_arctic_b0433.wav 927 | clb_arctic_b0434.wav|bdl_arctic_b0434.wav 928 | clb_arctic_b0435.wav|bdl_arctic_b0435.wav 929 | clb_arctic_b0436.wav|bdl_arctic_b0436.wav 930 | clb_arctic_b0437.wav|bdl_arctic_b0437.wav 931 | clb_arctic_b0438.wav|bdl_arctic_b0438.wav 932 | clb_arctic_b0439.wav|bdl_arctic_b0439.wav 933 | clb_arctic_b0440.wav|bdl_arctic_b0440.wav 934 | clb_arctic_b0441.wav|bdl_arctic_b0441.wav 935 | clb_arctic_b0442.wav|bdl_arctic_b0442.wav 936 | clb_arctic_b0443.wav|bdl_arctic_b0443.wav 937 | clb_arctic_b0444.wav|bdl_arctic_b0444.wav 938 | clb_arctic_b0445.wav|bdl_arctic_b0445.wav 939 | clb_arctic_b0446.wav|bdl_arctic_b0446.wav 940 | clb_arctic_b0447.wav|bdl_arctic_b0447.wav 941 | clb_arctic_b0448.wav|bdl_arctic_b0448.wav 942 | clb_arctic_b0449.wav|bdl_arctic_b0449.wav 943 | clb_arctic_b0450.wav|bdl_arctic_b0450.wav 944 | clb_arctic_b0451.wav|bdl_arctic_b0451.wav 945 | clb_arctic_b0452.wav|bdl_arctic_b0452.wav 946 | clb_arctic_b0453.wav|bdl_arctic_b0453.wav 947 | clb_arctic_b0454.wav|bdl_arctic_b0454.wav 948 | clb_arctic_b0455.wav|bdl_arctic_b0455.wav 949 | clb_arctic_b0456.wav|bdl_arctic_b0456.wav 950 | clb_arctic_b0457.wav|bdl_arctic_b0457.wav 951 | clb_arctic_b0458.wav|bdl_arctic_b0458.wav 952 | clb_arctic_b0459.wav|bdl_arctic_b0459.wav 953 | clb_arctic_b0460.wav|bdl_arctic_b0460.wav 954 | clb_arctic_b0461.wav|bdl_arctic_b0461.wav 955 | clb_arctic_b0462.wav|bdl_arctic_b0462.wav 956 | clb_arctic_b0463.wav|bdl_arctic_b0463.wav 957 | clb_arctic_b0464.wav|bdl_arctic_b0464.wav 958 | clb_arctic_b0465.wav|bdl_arctic_b0465.wav 959 | clb_arctic_b0466.wav|bdl_arctic_b0466.wav 960 | clb_arctic_b0467.wav|bdl_arctic_b0467.wav 961 | clb_arctic_b0468.wav|bdl_arctic_b0468.wav 962 | clb_arctic_b0469.wav|bdl_arctic_b0469.wav 963 | clb_arctic_b0470.wav|bdl_arctic_b0470.wav 964 | clb_arctic_b0471.wav|bdl_arctic_b0471.wav 965 | clb_arctic_b0472.wav|bdl_arctic_b0472.wav 966 | clb_arctic_b0473.wav|bdl_arctic_b0473.wav 967 | clb_arctic_b0474.wav|bdl_arctic_b0474.wav 968 | clb_arctic_b0475.wav|bdl_arctic_b0475.wav 969 | clb_arctic_b0476.wav|bdl_arctic_b0476.wav 970 | clb_arctic_b0477.wav|bdl_arctic_b0477.wav 971 | clb_arctic_b0478.wav|bdl_arctic_b0478.wav 972 | clb_arctic_b0479.wav|bdl_arctic_b0479.wav 973 | clb_arctic_b0480.wav|bdl_arctic_b0480.wav 974 | clb_arctic_b0481.wav|bdl_arctic_b0481.wav 975 | clb_arctic_b0482.wav|bdl_arctic_b0482.wav 976 | clb_arctic_b0483.wav|bdl_arctic_b0483.wav 977 | clb_arctic_b0484.wav|bdl_arctic_b0484.wav 978 | clb_arctic_b0485.wav|bdl_arctic_b0485.wav 979 | clb_arctic_b0486.wav|bdl_arctic_b0486.wav 980 | clb_arctic_b0487.wav|bdl_arctic_b0487.wav 981 | clb_arctic_b0488.wav|bdl_arctic_b0488.wav 982 | clb_arctic_b0489.wav|bdl_arctic_b0489.wav 983 | clb_arctic_b0490.wav|bdl_arctic_b0490.wav 984 | clb_arctic_b0491.wav|bdl_arctic_b0491.wav 985 | clb_arctic_b0492.wav|bdl_arctic_b0492.wav 986 | clb_arctic_b0493.wav|bdl_arctic_b0493.wav 987 | clb_arctic_b0494.wav|bdl_arctic_b0494.wav 988 | clb_arctic_b0495.wav|bdl_arctic_b0495.wav 989 | clb_arctic_b0496.wav|bdl_arctic_b0496.wav 990 | clb_arctic_b0497.wav|bdl_arctic_b0497.wav 991 | clb_arctic_b0498.wav|bdl_arctic_b0498.wav 992 | clb_arctic_b0499.wav|bdl_arctic_b0499.wav 993 | clb_arctic_b0500.wav|bdl_arctic_b0500.wav 994 | clb_arctic_b0501.wav|bdl_arctic_b0501.wav 995 | clb_arctic_b0502.wav|bdl_arctic_b0502.wav 996 | clb_arctic_b0503.wav|bdl_arctic_b0503.wav 997 | clb_arctic_b0504.wav|bdl_arctic_b0504.wav 998 | clb_arctic_b0505.wav|bdl_arctic_b0505.wav 999 | clb_arctic_b0506.wav|bdl_arctic_b0506.wav 1000 | clb_arctic_b0507.wav|bdl_arctic_b0507.wav 1001 | clb_arctic_b0508.wav|bdl_arctic_b0508.wav 1002 | clb_arctic_b0509.wav|bdl_arctic_b0509.wav 1003 | clb_arctic_b0510.wav|bdl_arctic_b0510.wav 1004 | clb_arctic_b0511.wav|bdl_arctic_b0511.wav 1005 | clb_arctic_b0512.wav|bdl_arctic_b0512.wav 1006 | clb_arctic_b0513.wav|bdl_arctic_b0513.wav 1007 | clb_arctic_b0514.wav|bdl_arctic_b0514.wav 1008 | clb_arctic_b0515.wav|bdl_arctic_b0515.wav 1009 | clb_arctic_b0516.wav|bdl_arctic_b0516.wav 1010 | clb_arctic_b0517.wav|bdl_arctic_b0517.wav 1011 | clb_arctic_b0518.wav|bdl_arctic_b0518.wav 1012 | clb_arctic_b0519.wav|bdl_arctic_b0519.wav 1013 | clb_arctic_b0520.wav|bdl_arctic_b0520.wav 1014 | clb_arctic_b0521.wav|bdl_arctic_b0521.wav 1015 | clb_arctic_b0522.wav|bdl_arctic_b0522.wav 1016 | clb_arctic_b0523.wav|bdl_arctic_b0523.wav 1017 | clb_arctic_b0524.wav|bdl_arctic_b0524.wav 1018 | clb_arctic_b0525.wav|bdl_arctic_b0525.wav 1019 | clb_arctic_b0526.wav|bdl_arctic_b0526.wav 1020 | clb_arctic_b0527.wav|bdl_arctic_b0527.wav 1021 | clb_arctic_b0528.wav|bdl_arctic_b0528.wav 1022 | clb_arctic_b0529.wav|bdl_arctic_b0529.wav 1023 | clb_arctic_b0530.wav|bdl_arctic_b0530.wav 1024 | clb_arctic_b0531.wav|bdl_arctic_b0531.wav 1025 | clb_arctic_b0532.wav|bdl_arctic_b0532.wav 1026 | clb_arctic_b0533.wav|bdl_arctic_b0533.wav 1027 | clb_arctic_b0534.wav|bdl_arctic_b0534.wav 1028 | clb_arctic_b0535.wav|bdl_arctic_b0535.wav 1029 | clb_arctic_b0536.wav|bdl_arctic_b0536.wav 1030 | clb_arctic_b0537.wav|bdl_arctic_b0537.wav 1031 | clb_arctic_b0538.wav|bdl_arctic_b0538.wav 1032 | clb_arctic_b0539.wav|bdl_arctic_b0539.wav 1033 | --------------------------------------------------------------------------------