← Open Source
Kyubyong

tacotron

A TensorFlow Implementation of Tacotron: A Fully End-to-End Text-To-Speech Synthesis Model.

ModelsAudio/Speech modelsPython
Open on GitHub
Momentum
+0stars in 24 hours0.0%
1.83k
Stars
427
Forks
+0
This week
5
Contributors
Created 2017-05-16 · Updated 2026-10-13 · #9401 today
Top developers
Kyubyongcandlewillbetterenvi

Kyubyong/tacotron is ranked 9,401 with 1,833 stars.

Same-category comparison

Kyubyong/tacotron is ranked 9,401 among these 8 peers; NVIDIA/semantic-segmentation is ranked 9,402.

Same-category comparison
NameRankMetrics
microsoft/mattergen9,378
Language:
Python
Stars:
1,846
Forks:
358
VHellendoorn/Code-LMs9,388
Language:
Python
Stars:
1,840
Forks:
261
Description:
Guide to using pre-trained large language models of source code.
boundless-large-model/boundless-world-model9,391
Language:
Python
Stars:
1,839
Forks:
75
Description:
High-fidelity world models for general embodied intelligence, such as data engines and world simulators.
AlibabaResearch/AdvancedLiterateMachinery9,399
Language:
C++
Stars:
1,833
Forks:
195
Description:
A collection of original, innovative ideas and algorithms towards Advanced Literate Machinery. This project is maintained by the OCR Team in the Language Technology Lab, Tongyi Lab, Alibaba Group.
NVIDIA/semantic-segmentation9,402
Language:
Python
Stars:
1,832
Forks:
388
Description:
Nvidia Semantic Segmentation monorepo.
NVlabs/stylegan2-ada9,407
Language:
Python
Stars:
1,828
Forks:
481
Description:
StyleGAN2 with adaptive discriminator augmentation (ADA) - Official TensorFlow implementation.
potamides/DeTikZify9,415
Language:
Python
Stars:
1,824
Forks:
97
Description:
Synthesizing Graphics Programs for Scientific Figures and Sketches with TikZ.
zjy-ucas/ChineseNER9,419
Language:
Python
Stars:
1,823
Forks:
565
Description:
A neural network model for Chinese named entity recognition.
Key parameters and specifications
Key parameters and specifications
ParameterValue
LanguagePython
CategoryModels
SubcategoryAudio/Speech models
KeywordsTTS
Stars1,833
Forks427
Contributors5
Created date2017-05-16
Updated date2026-10-13
Stars in 1 day0
Stars in 7 days0
Rank9,401
Previous rank9,444
Rank change43
7-day stars rank12,285
Previous 7-day stars rank12,339
7-day stars rank change54
Total stars rank6,835
Previous total stars rank6,827
Total stars rank change-8
CountrySouth Korea
README summary

A (Heavily Documented) TensorFlow Implementation of Tacotron: A Fully End-to-End Text-To-Speech Synthesis Model Requirements NumPy >= 1. 3 librosa tqdm matplotlib scipy Data We train the model on three different speech datasets. The World English Bible LJ Speech Dataset is recently widely used as a benchmark dataset in the TTS task because it is publicly available. It has 24 hours of reasonable quality samples. Nick's audiobooks are additionally used to see if the model can learn even

with less data, variable speech samples. The World English Bible is a public domain update of the American Standard Version of 1901 into modern English. Its original audios are freely available here. Kyubyong split each chapter by verse manually and aligned the segmented audio clips to the text. You can download them at Kaggle Datasets. Download LJ Speech Dataset or prepare your own data. (If you want to do preprocessing, set True python train. **Perhaps the most important hyperparemeter is

the learning rate. 002 we were never able to learn a clean attention, the loss would frequently explode. 001 we were able to learn a clean attention and train for much longer get decernable words during synthesis. Check other TTS models such as DCTTS or deep voice 3. Differences from the original paper We use Noam style warmup and decay. After the last convolutional layer of the post-processing net, we apply an affine transformation to bring the dimensionality up

to 128 from 80, because the required dimensionality of highway net is 128. In the original highway networks paper, the authors mention that the dimensionality of the input can also be increased with zero-padding, but they used the affine transformation in all their experiments. We do not know what the Tacotron authors chose. Papers that referenced this repo Efficiently Trainable Text-to-Speech System Based on Deep Convolutional Networks with Guided Attention Storytime - End to end neural networks for

audiobooks Jan.

Frequently asked questions

How many stars and forks are recorded?

Kyubyong/tacotron has 1,833 stars and 427 forks.

What is the repository rank?

Kyubyong/tacotron is ranked 9,401.

What language and category are recorded?

Kyubyong/tacotron has 1,833 stars, uses Python and belongs to Models.

Which repository is closest in rank?

Kyubyong/tacotron is compared with NVIDIA/semantic-segmentation, ranked 9,402 with 1,832 stars.

README

A (Heavily Documented) TensorFlow Implementation of Tacotron: A Fully End-to-End Text-To-Speech Synthesis Model

Requirements

  • NumPy >= 1.11.1
  • TensorFlow >= 1.3
  • librosa
  • tqdm
  • matplotlib
  • scipy

Data

We train the model on three different speech datasets.

  1. LJ Speech Dataset
  2. Nick Offerman's Audiobooks
  3. The World English Bible

LJ Speech Dataset is recently widely used as a benchmark dataset in the TTS task because it is publicly available. It has 24 hours of reasonable quality samples. Nick's audiobooks are additionally used to see if the model can learn even with less data, variable speech samples. They are 18 hours long. The World English Bible is a public domain update of the American Standard Version of 1901 into modern English. Its original audios are freely available here. Kyubyong split each chapter by verse manually and aligned the segmented audio clips to the text. They are 72 hours in total. You can download them at Kaggle Datasets.

Training

  • STEP 0. Download LJ Speech Dataset or prepare your own data.
  • STEP 1. Adjust hyper parameters in hyperparams.py. (If you want to do preprocessing, set prepro True`.
  • STEP 2. Run python train.py. (If you set prepro True, run python prepro.py first)
  • STEP 3. Run python eval.py regularly during training.

Sample Synthesis

We generate speech samples based on Harvard Sentences as the original paper does. It is already included in the repo.

  • Run python synthesize.py and check the files in samples.

Training Curve

Attention Plot

Generated Samples

Pretrained Files

  • Keep in mind 200k steps may not be enough for the best performance.
  • LJ 200k
  • WEB 200k

Notes

  • It's important to monitor the attention plots during training. If the attention plots look good (alignment looks linear), and then they look bad (the plots will look similar to what they looked like in the begining of training), then training has gone awry and most likely will need to be restarted from a checkpoint where the attention looked good, because we've learned that it's unlikely that the loss will ever recover. This deterioration of attention will correspond with a spike in the loss.

  • In the original paper, the authors said, "An important trick we discovered was predicting multiple, non-overlapping output frames at each decoder step" where the number of of multiple frame is the reduction factor, r. We originally interpretted this as predicting non-sequential frames during each decoding step t. Thus were using the following scheme (with r=5) during decoding.

    t    frame numbers
    -----------------------
    0    [ 0  1  2  3  4]
    1    [ 5  6  7  8  9]
    2    [10 11 12 13 14]
    ...
    

    After much experimentation, we were unable to have our model learning anything useful. We then switched to predicting r sequential frames during each decoding step.

    t    frame numbers
    -----------------------
    0    [ 0  1  2  3  4]
    1    [ 5  6  7  8  9]
    2    [10 11 12 13 14]
    ...
    

    With this setup we noticed improvements in the attention and have since kept it.

  • Perhaps the most important hyperparemeter is the learning rate. With an intitial learning rate of 0.002 we were never able to learn a clean attention, the loss would frequently explode. With an initial learning rate of 0.001 we were able to learn a clean attention and train for much longer get decernable words during synthesis.

  • Check other TTS models such as DCTTS or deep voice 3.

Differences from the original paper

  • We use Noam style warmup and decay.
  • We implement gradient clipping.
  • Our training batches are bucketed.
  • After the last convolutional layer of the post-processing net, we apply an affine transformation to bring the dimensionality up to 128 from 80, because the required dimensionality of highway net is 128. In the original highway networks paper, the authors mention that the dimensionality of the input can also be increased with zero-padding, but they used the affine transformation in all their experiments. We do not know what the Tacotron authors chose.

Papers that referenced this repo

Jan. 2018, Kyubyong Park & Tommy Mulc

Nearby in the ranking
Similar items