Text Processing and Linguistic Analysis

TL;DR

Before a computer can "speak" text, it needs to understand what the text actually means and how it's structured. We break down raw text into smaller, meaningful pieces and then analyze those pieces to figure out pronunciation, rhythm, and intonation. This process is crucial for making computer voices sound natural and understandable.

1. The Mental Model

Imagine you're trying to read a complicated sentence out loud perfectly, even if you don't fully understand all the words. Now imagine you have to teach a child how to do that, giving them tiny, specific instructions. That's essentially what we're doing: preparing text for a machine to "read" by giving it all the clues it needs to sound human.

2. The Core Material

When we talk about text processing and linguistic analysis for Text-to-Speech (TTS), we're generally discussing a pipeline of steps that transform raw text into a format ready for sound generation. This isn't just about reading words; it's about making them sound natural.

2.1 Normalization and Tokenization

First, we need to clean up the text and break it into manageable parts.

• Normalization: This is about standardizing the text. Think about converting numbers ("$12.50" to "twelve dollars and fifty cents"), abbreviations ("Dr." to "Doctor"), and symbols. It ensures the pronunciation engine gets consistent input.

• Tokenization: This step breaks the normalized text into smaller units called tokens. Usually, these are words or punctuation marks. It's like separating all the words in a sentence so you can look at each one individually.

  ```python
  import re

  def simple_normalize_and_tokenize(text):
  # Very basic normalization: expand common abbreviations/symbols
  text = text.replace("$", " dollars ")
  text = text.replace("Dr.", "Doctor ")
  text = text = re.sub(r'(\d+)([a-zA-Z]+)', r'\1 \2', text) # "10km" -> "10 km"

  # Basic tokenization: split by spaces and keep punctuation attached for a moment
  # We'll refine punctuation later
  tokens = text.split()
  return tokens
  

  text = "The Dr. said it costs $12.50. 10km away."
  tokens = simple_normalize_and_tokenize(text)
  print(tokens)

  Expected output: ['The', 'Doctor', 'said', 'it', 'costs', '12.50', 'dollars.', '10', 'km', 'away.']

  ```

2.2 Linguistic Analysis: Parts of Speech and Prosody

Once we have tokens, we need to understand their linguistic role.

• Part-of-Speech (POS) Tagging: We identify if a word is a noun, verb, adjective, etc. This helps with pronunciation (e.g., "read" the book vs. "read" the past tense) and intonation.
• Prosodic Analysis: This is about the "music" of speech—rhythm, stress, and intonation.
  • Stress: Which syllable in a word gets emphasized? ("CON'-tract" vs. "con-TRACT'").
  • Intonation: How does the pitch of your voice change? (rising for questions, falling for statements). This is often inferred from punctuation and sentence structure.
  • Pauses: Where should the system pause, and for how long? Commas, periods, and even grammatical structure can indicate pauses.

The diagram below shows this pipeline.

graph TD
    A["Raw Text"] --> B["Text Normalization"]
    B --> C["Tokenization"]
    C --> D["Part-of-Speech (POS) Tagging"]
    D --> E["Prosodic Analysis (Stress, Intonation, Pauses)"]
    E --> F["Phonetic Transcription (Grapheme-to-Phoneme)"]
    F --> G["Ready for Acoustic Model (Sound Generation)"]

2.3 Grapheme-to-Phoneme (G2P) Conversion

Finally, we need to turn the actual letters (graphemes) into sounds (phonemes).

• Grapheme-to-Phoneme (G2P): This is the process of converting written words into their phonetic representation. For English, "ough" can sound very different in "through," "tough," "bough," and "thought." G2P tackles this. Often, a dictionary is used for common words, and rules or machine learning models handle unknown or difficult words. The output of G2P is typically a sequence of phonemes (like IPA or X-SAMPA symbols).

  Example phonemes (simplified):
  * "cat" -> /k/ /æ/ /t/
  * "thought" -> /θ/ /ɔː/ /t/

3. Worked Example

Let's take the sentence: "Dr. Smith read the daily report, which cost $2.99." and process it.

1. Raw Text: "Dr. Smith read the daily report, which cost $2.99."

2. Text Normalization:

   • "Dr." becomes "Doctor"
   • "$2.99" becomes "two dollars ninety-nine cents"
   • Result: "Doctor Smith read the daily report, which cost two dollars ninety-nine cents."

3. Tokenization:

   • Tokens: ['Doctor', 'Smith', 'read', 'the', 'daily', 'report', ',', 'which', 'cost', 'two', 'dollars', 'ninety-nine', 'cents', '.']

4. Part-of-Speech (POS) Tagging: (Simplified)

   • "Doctor" (Noun), "Smith" (Noun), "read" (Verb, past tense), "the" (Determiner), "daily" (Adjective), "report" (Noun), "," (Punctuation), "which" (Determiner), "cost" (Verb, past tense), "two" (Number), "dollars" (Noun), "ninety-nine" (Number), "cents" (Noun), "." (Punctuation)
   • Insight: Knowing "read" is past tense tells us how to pronounce it (rhymes with "red"). If it was "I will read," it would rhyme with "reed."

5. Prosodic Analysis:

   • Stress: "DOC-tor," "SMITH," "DAI-ly," "RE-port," "DOL-lars," "NINE-ty-NINE," "CENTS."
   • Pauses: A short pause after "report" (due to the comma), a longer pause at the end of the sentence.
   • Intonation: Generally falling at the end of this declarative sentence.

6. Grapheme-to-Phoneme (G2P):

   • "Doctor" -> /dɒktər/
   • "Smith" -> /smɪθ/
   • "read" (past tense) -> /rɛd/
   • "the" -> /ðə/
   • "daily" -> /deɪli/
   • "report" -> /rɪˈpɔːrt/
   • "which" -> /wɪʧ/
   • "cost" -> /kɒst/
   • "two" -> /tuː/
   • "dollars" -> /ˈdɒlərz/
   • "ninety-nine" -> /ˈnaɪntiˈnaɪn/
   • "cents" -> /sɛnts/
   • The combined phoneme sequence, along with stress and intonation markers, is now ready for the acoustic model to synthesize into speech.

4. Key Takeaways

• Text processing breaks raw text into structured information useful for speech synthesis.
• Normalization standardizes irregular text elements like numbers and abbreviations.
• Tokenization separates text into individual words and punctuation for further analysis.
• Part-of-Speech tagging identifies grammatical roles, which helps with pronunciation and prosody.
• Prosodic analysis determines speech rhythm, stress, and intonation for natural-sounding speech.
• Grapheme-to-Phoneme (G2P) converts letters into their phonetic sounds.
• This entire pipeline ensures the synthetic voice sounds natural and understandable.

Common mistakes you should avoid:
* Assuming raw text is ready for speech; it needs significant pre-processing.
* Ignoring punctuation; it's vital for pauses and intonation.
* Neglecting normalization; numbers and symbols need to be spoken, not spelled.
* Underestimating the complexity of G2P; English spelling isn't always phonetic.

5. Now Try It

Take the sentence: "The new product, XYZ-2000, will launch at 9:00 AM on 1/1/2024, costing only £59.99."
Go through each step we discussed (normalization, tokenization, POS tagging, basic prosodic notes, and G2P for a few key words) and write down the result for each.
Success looks like: You have a list of tokens, suggested POS tags, notes on where pauses and stress might occur, and a phonetic spelling (using a simple, common sense approach if you don't know IPA) for challenging words like "XYZ-2000" or "£59.99".