add text parameters in config.json

utils/generic_utils.py

@@ -425,6 +425,15 @@ def check_config(c):
     _check_argument('power', c['audio'], restricted=True, val_type=float, min_val=1, max_val=5)
     _check_argument('griffin_lim_iters', c['audio'], restricted=True, val_type=int, min_val=10, max_val=1000)
 
+    # vocabulary parameters
+    _check_argument('text', c, restricted=False, val_type=dict) # parameter not mandatory 
+    _check_argument('pad', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str) # mandatory if "text parameters" else no mandatory
+    _check_argument('eos', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str)
+    _check_argument('bos', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str)
+    _check_argument('characters', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str)
+    _check_argument('phonemes', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str)
+    _check_argument('punctuations', c['text'] if 'text' in c.keys() else {}, restricted=True if 'text' in c.keys() else False, val_type=str)
+
     # normalization parameters
     _check_argument('signal_norm', c['audio'], restricted=True, val_type=bool)
     _check_argument('symmetric_norm', c['audio'], restricted=True, val_type=bool)

utils/synthesis.py

@@ -9,10 +9,11 @@ def text_to_seqvec(text, CONFIG, use_cuda):
     if CONFIG.use_phonemes:
         seq = np.asarray(
             phoneme_to_sequence(text, text_cleaner, CONFIG.phoneme_language,
-                                CONFIG.enable_eos_bos_chars),
+                                CONFIG.enable_eos_bos_chars,
+                                tp=CONFIG.text if 'text' in CONFIG.keys() else None),
             dtype=np.int32)
     else:
-        seq = np.asarray(text_to_sequence(text, text_cleaner), dtype=np.int32)
+        seq = np.asarray(text_to_sequence(text, text_cleaner, tp=CONFIG.text if 'text' in CONFIG.keys() else None), dtype=np.int32)
     # torch tensor
     chars_var = torch.from_numpy(seq).unsqueeze(0)
     if use_cuda:

utils/text/__init__.py

@@ -4,7 +4,7 @@ import re
 import phonemizer
 from phonemizer.phonemize import phonemize
 from TTS.utils.text import cleaners
-from TTS.utils.text.symbols import symbols, phonemes, _phoneme_punctuations, _bos, \
+from TTS.utils.text.symbols import make_symbols, symbols, phonemes, _phoneme_punctuations, _bos, \
     _eos
 
 # Mappings from symbol to numeric ID and vice versa:
@@ -56,11 +56,23 @@ def text2phone(text, language):
     return ph
 
 
-def pad_with_eos_bos(phoneme_sequence):
+def pad_with_eos_bos(phoneme_sequence, tp=None):
+    global _PHONEMES_TO_ID, _bos, _eos
+    if tp:
+        _bos = tp['bos']
+        _eos = tp['eos']
+        _, phonemes = make_symbols(**tp)
+        _PHONEMES_TO_ID = {s: i for i, s in enumerate(phonemes)}
+        
     return [_PHONEMES_TO_ID[_bos]] + list(phoneme_sequence) + [_PHONEMES_TO_ID[_eos]]
 
 
-def phoneme_to_sequence(text, cleaner_names, language, enable_eos_bos=False):
+def phoneme_to_sequence(text, cleaner_names, language, enable_eos_bos=False, tp=None):
+    global _PHONEMES_TO_ID
+    if tp:
+        _, phonemes = make_symbols(**tp)
+        _PHONEMES_TO_ID = {s: i for i, s in enumerate(phonemes)}
+
     sequence = []
     text = text.replace(":", "")
     clean_text = _clean_text(text, cleaner_names)
@@ -72,13 +84,18 @@ def phoneme_to_sequence(text, cleaner_names, language, enable_eos_bos=False):
         sequence += _phoneme_to_sequence(phoneme)
     # Append EOS char
     if enable_eos_bos:
-        sequence = pad_with_eos_bos(sequence)
+        sequence = pad_with_eos_bos(sequence, tp=tp)
     return sequence
 
 
-def sequence_to_phoneme(sequence):
+def sequence_to_phoneme(sequence, tp=None):
     '''Converts a sequence of IDs back to a string'''
+    global _ID_TO_PHONEMES
     result = ''
+    if tp:
+        _, phonemes =  make_symbols(**tp)
+        _ID_TO_PHONEMES = {i: s for i, s in enumerate(phonemes)}
+        
     for symbol_id in sequence:
         if symbol_id in _ID_TO_PHONEMES:
             s = _ID_TO_PHONEMES[symbol_id]
@@ -86,7 +103,7 @@ def sequence_to_phoneme(sequence):
     return result.replace('}{', ' ')
 
 
-def text_to_sequence(text, cleaner_names):
+def text_to_sequence(text, cleaner_names, tp=None):
     '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
 
       The text can optionally have ARPAbet sequences enclosed in curly braces embedded
@@ -99,6 +116,11 @@ def text_to_sequence(text, cleaner_names):
       Returns:
         List of integers corresponding to the symbols in the text
     '''
+    global _SYMBOL_TO_ID
+    if tp:
+        symbols, _ = make_symbols(**tp)
+        _SYMBOL_TO_ID = {s: i for i, s in enumerate(symbols)}
+
     sequence = []
     # Check for curly braces and treat their contents as ARPAbet:
     while text:
@@ -113,8 +135,13 @@ def text_to_sequence(text, cleaner_names):
     return sequence
 
 
-def sequence_to_text(sequence):
+def sequence_to_text(sequence, tp=None):
     '''Converts a sequence of IDs back to a string'''
+    global _ID_TO_SYMBOL
+    if tp:
+        symbols, _ = make_symbols(**tp)
+        _ID_TO_SYMBOL = {i: s for i, s in enumerate(symbols)}
+
     result = ''
     for symbol_id in sequence:
         if symbol_id in _ID_TO_SYMBOL:

utils/text/symbols.py

@@ -5,6 +5,18 @@ Defines the set of symbols used in text input to the model.
 The default is a set of ASCII characters that works well for English or text that has been run
 through Unidecode. For other data, you can modify _characters. See TRAINING_DATA.md for details.
 '''
+def make_symbols(characters, phonemes, punctuations='!\'(),-.:;? ', pad='_', eos='~', bos='^'):
+    ''' Function to create symbols and phonemes '''
+    _phonemes = sorted(list(phonemes))
+
+    # Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters):
+    _arpabet = ['@' + s for s in _phonemes]
+
+    # Export all symbols:
+    symbols = [pad, eos, bos] + list(characters) + _arpabet
+    phonemes = [pad, eos, bos] + list(_phonemes) + list(punctuations)
+
+    return symbols, phonemes
 
 _pad = '_'
 _eos = '~'
@@ -20,14 +32,9 @@ _pulmonic_consonants = 'pbtdʈɖcɟkɡqɢʔɴŋɲɳnɱmʙrʀⱱɾɽɸβfvθðsz
 _suprasegmentals = 'ˈˌːˑ'
 _other_symbols = 'ʍwɥʜʢʡɕʑɺɧ'
 _diacrilics = 'ɚ˞ɫ'
-_phonemes = sorted(list(_vowels + _non_pulmonic_consonants + _pulmonic_consonants + _suprasegmentals + _other_symbols + _diacrilics))
+_phonemes = _vowels + _non_pulmonic_consonants + _pulmonic_consonants + _suprasegmentals + _other_symbols + _diacrilics
 
-# Prepend "@" to ARPAbet symbols to ensure uniqueness (some are the same as uppercase letters):
-_arpabet = ['@' + s for s in _phonemes]
-
-# Export all symbols:
-symbols = [_pad, _eos, _bos] + list(_characters) + _arpabet
-phonemes = [_pad, _eos, _bos] + list(_phonemes) + list(_punctuations)
+symbols, phonemes = make_symbols( _characters, _phonemes,_punctuations, _pad, _eos, _bos)
 
 # Generate ALIEN language
 # from random import shuffle

utils/visual.py

@@ -54,9 +54,10 @@ def visualize(alignment, spectrogram_postnet, stop_tokens, text, hop_length, CON
     plt.xlabel("Decoder timestamp", fontsize=label_fontsize)
     plt.ylabel("Encoder timestamp", fontsize=label_fontsize)
     if CONFIG.use_phonemes:
-        seq = phoneme_to_sequence(text, [CONFIG.text_cleaner], CONFIG.phoneme_language, CONFIG.enable_eos_bos_chars)
-        text = sequence_to_phoneme(seq)
+        seq = phoneme_to_sequence(text, [CONFIG.text_cleaner], CONFIG.phoneme_language, CONFIG.enable_eos_bos_chars, tp=CONFIG.text if 'text' in CONFIG.keys() else None)
+        text = sequence_to_phoneme(seq, tp=CONFIG.text if 'text' in CONFIG.keys() else None)
         print(text)
+        
     plt.yticks(range(len(text)), list(text))
     plt.colorbar()