TL;DR
This paper introduces Proteno, a novel text normalization (TN) system for Text-to-Speech (TTS) that significantly reduces the data requirements for new languages. By treating TN as a sequence classification problem with a granular tokenizer, Proteno learns most normalizations automatically from data, achieving comparable performance to state-of-the-art English systems with drastically less data.
What Problem Does This Paper Address?
Text Normalization (TN) is a crucial first step in Text-to-Speech (TTS) systems, responsible for converting written text into its spoken form. This involves handling various "semiotic classes" like numbers, dates, and abbreviations, which are written differently than they are spoken. Traditional TN systems often rely on extensive, hand-coded rules or require vast amounts of annotated data, making them difficult to scale to new languages and maintain. While machine learning approaches have shown promise, they still face challenges with "unacceptable errors" (e.g., misinterpreting currency) and often depend on significant linguistic expertise. The core problem this paper addresses is the high data and labor cost associated with developing robust TN systems for new languages, hindering their rapid deployment.
Methods
Proteno tackles TN as a sequence classification problem, breaking it down into four stages: tokenization, data preparation, classification, and normalization.
- Granular Tokenization: The system employs a novel, deterministic tokenizer that splits sentences based on spaces and then further segments text when Unicode classes change. This allows it to break down complex entities (like dates) into smaller, manageable units (e.g., '1/1/2020' becomes ['1', '/', '1', '/', '2020']). This granular approach is language-agnostic, relying on basic rules and Unicode properties.
- Data-Driven Normalization: The core idea is to learn the majority of normalization rules directly from data. The system defines two types of classes:
- Pre-defined Classes: A small set of basic classes (e.g., 'self' for unchanged text, 'sil' for punctuation, 'digit', 'cardinal', 'ordinal') with some language-specific verbalization rules.
- Auto-Generated (AG) Classes: For any unnormalized token-to-normalized token mapping that cannot be handled by pre-defined classes, a new AG class is automatically created. These AG classes learn specific mappings directly from the data.
- Classification: Proteno models the problem as a sequence tagging task. It transforms the unnormalized token sequences into sequences of class labels. The paper explores various classifiers, including Conditional Random Fields (CRFs), Bi-LSTMs, BiLSTM-CRFs, and Transformers, using word embeddings as features.
- Error Curtailment: By limiting the classes a token can be accepted into, Proteno aims to prevent unacceptable errors. If multiple classes can normalize a token, the model predicts the most appropriate one based on context. Special handling is also included for currency and measure units to ensure correct realignment.
Datasets
The paper introduces new annotated TN datasets for Spanish and Tamil, crucial for evaluating Proteno's multilingual capabilities.
- Spanish: A dataset of 135k tokens (5k sentences) was collected from Wikipedia, focusing on sentences with entities requiring normalization.
- Tamil: Data was sourced from English-Tamil parallel and comparable corpora, resulting in 500k tokens (30k sentences) with a preference for sentences needing normalization.
- English: A subset of data from Sproat and Jaitly (2016) was used, comprising 300k tokens (24.7k sentences). This dataset size is significantly smaller (1.5%-3%) than those used in previous English TN benchmarks.
Key Insights and Ideas
- Data Efficiency is Key: The most striking insight is that Proteno can achieve competitive performance with a fraction of the data typically required for state-of-the-art TN systems, especially for new languages. This democratizes the development of TTS systems.
- Granular Tokenization as a Game Changer: Breaking down complex entities into smaller tokens and learning their normalizations individually is a powerful mechanism. It reduces the need for complex, pre-defined rules for every possible variation.
- Automatic Learning of Normalizations: The Auto-Generated (AG) class mechanism is central to Proteno's success. It allows the system to learn a vast majority of normalizations directly from data, minimizing manual effort and linguistic expertise.
- Transferability: The language-agnostic nature of the granular tokenizer and the reliance on data-driven learning make Proteno highly transferable across languages, provided they use space-separated words.
- WER as a More Meaningful Metric: The paper advocates for Word Error Rate (WER) over classification accuracy for evaluating TN systems, as multiple classes can sometimes produce the same correct normalization, making accuracy misleading.
Key Results
- Spanish: Proteno's Transformer model achieved a test WER of 2.3, comparable to the baseline rule-based system, while other NN models like BiLSTM and BiLSTM-CRF achieved a WER of 0.89.
- Tamil: The BiLSTM model achieved a WER of 0.6 on the training set and 3.3 on the test set.
- English: The BiLSTM model achieved a WER of 0.47 on the training set and 2.6 on the test set. Notably, 88.2% of non-self normalizations were learned automatically via AGs.
- Data Reduction: Proteno uses only 1.5%-3% of the data used by previous English TN benchmarks while achieving comparable performance.
- Classification Accuracy: While not the primary metric, classification accuracy was reported, showing that even with lower accuracy, WER can remain competitive due to multiple classes yielding the same correct output.
Limitations and Future Work
- Language Dependency: The current granular tokenizer relies on space-separated words. Languages without spaces or with highly inflected structures (like Icelandic) present a challenge for Proteno's current tokenizer.
- Handling Ambiguity: While Proteno attempts to handle cases where multiple classes can normalize a token by picking the least frequent class, more sophisticated approaches for handling such ambiguities could be explored.
- Future Work: The authors suggest adapting Proteno to more challenging languages and exploring more optimal ways to handle multiple matching classes. They also aim to further benchmark Proteno against existing systems.
Summary updated