Pareamento De Vogais

Entendendo o que é pareamento de vogais na prática

Pareamento de vogais é o processo de associar sequências de sons vocálicos em uma string fonêmica com base em regras fonológicas e acústicas. A aplicação mais comum aparece quando você trabalha com síntese de fala, reconhecimento de fala ou normalização fonêmica em português brasileiro. O problema real surge quando duas vogais consecutivas criam ambiguidade silábica. "boa noite" pode ser segmentado como /bo.a/ ou interpretado erroneamente como um ditongo /bon/. O pareamento de vogais serve justamente para decidir quando vogais adjacentes se fundem ou permanecem separadas.

Por que o pareamento de vogais importa

Em pipelines de processamento de fala, erros de segmentação vocálica propagam para camadas downstream inteiras. Um fonema mal emparelhado gera tokenização errada, que gera pronúncia distorcida na síntese, e gera Word Error Rate inflado no reconhecimento. A correção manual não escala. Na minha experiência, o maior ganho não está na regra em si, mas em tratar vogais nasais como categoria separada desde o início. Vogal nasalizada não segue as mesmas regras de combinação que vogal oral, e misturar as duas no mesmo conjunto de regras é o erro mais comum que vejo em implementações novatas. Vogais orais alta e semifechada, como /i/ e /e/, tendem a formar ditongos decrescentes com vogais posteriores. Vogais abertas como /a/ se comportam de forma muito diferente. O pareamento precisa reconhecer essa assimetria fonética, senão você vai empilhar regras ad hoc que falham em produção.

Implementação prática em Python

Aqui está uma implementação funcional que usei em projetos de production. O código é direto, sem dependências externas pesadas, e começa com um mapeamento fonêmico do português brasileiro. O primeiro passo é definir o inventário vocálico com atributos fonológicos relevantes. Altura, abertura e nasalidade são suficientes para a maioria dos casos. Vogais arredondadas como /o/ e // merecem marcação separada porque afetam a transição formântica de forma diferente. Aqui está o código completo:

"""
pareamento de vogais - módulo de processamento fonêmico
Regras baseadas em atributos fonológicos do português brasileiro
"""

VOWEL_DB = {
    vogais orais
    "i": {"height": "high", "backness": "front", "rounded": False, "nasal": False},
    "": {"height": "high", "backness": "front", "rounded": False, "nasal": False},
    "e": {"height": "mid-high", "backness": "front", "rounded": False, "nasal": False},
    "": {"height": "mid-low", "backness": "front", "rounded": False, "nasal": False},
    "a": {"height": "low", "backness": "front", "rounded": False, "nasal": False},
    "": {"height": "mid", "backness": "central", "rounded": False, "nasal": False},
    "o": {"height": "mid-high", "backness": "back", "rounded": True, "nasal": False},
    "": {"height": "mid-low", "backness": "back", "rounded": True, "nasal": False},
    "u": {"height": "high", "backness": "back", "rounded": True, "nasal": False},

    vogais nasais
    "ĩ": {"height": "high", "backness": "front", "rounded": False, "nasal": True},
    "": {"height": "mid-high", "backness": "front", "rounded": False, "nasal": True},
    "ã": {"height": "mid-low", "backness": "front", "rounded": False, "nasal": True},
    "õ": {"height": "mid-high", "backness": "back", "rounded": True, "nasal": True},
    "ĩ": {"height": "high", "backness": "central", "rounded": False, "nasal": True},
}

def get_pairing_rules():
    rules = []

    Ditongos crescentes: vogal baixa/aberta + vogal alta/posterior
    rules.append({
        "pattern": [("low", False), ("high", False)],
        "type": "crescent_diphthong",
        "note": "/a/ + /i/ ou /u/ oral"
    })
    rules.append({
        "pattern": [("mid-low", False), ("high", False)],
        "type": "crescent_diphthong",
        "note": "// + /i/ ou /u/ oral"
    })

    Ditongos decrescentes: vogal alta + vogal não-alta
    rules.append({
        "pattern": [("high", False), ("mid-high", False), ("mid-low", False), ("low", False)],
        "type": "decrescent_diphthong",
        "note": "/i/ ou /u/ seguido de vogal mais aberta"
    })
    rules.append({
        "pattern": [("high", True), ("mid-high", True), ("mid-low", True), ("low", True)],
        "type": "nasal_diphthong",
        "note": "vogal nasal alta + vogal nasal menos alta"
    })

    Hiatos: vogais de alturas semelhantes mas não idênticas, ou com nasalição diferente
    rules.append({
        "pattern": ["same_height_no_nasal"],
        "type": "hiatus",
        "note": "vogais adjacentes de mesma altura, pareamento neutro"
    })

    return rules

def extract_vowel_sequences(text):
    vowels = set("aeiouĩãõ")
    seq = []
    current = ""
    for char in text:
        if char in vowels:
            current += char
        else:
            if current:
                seq.append(current)
                current = ""
    if current:
        seq.append(current)
    return seq

def match_vowels(text):
    sequences = extract_vowel_sequences(text)
    results = []

    for seq in sequences:
        if len(seq) < 2:
            results.append({"vowels": seq, "pairs": [], "type": "singleton"})
            continue

        pairs = []
        for i in range(len(seq) - 1):
            v1, v2 = seq[i], seq[i+1]
            attr1, attr2 = VOWEL_DB.get(v1), VOWEL_DB.get(v2)

            if not attr1 or not attr2:
                pairs.append({"v1": v1, "v2": v2, "type": "unknown"})
                continue

            matched = False
            if attr1["nasal"] != attr2["nasal"]:
                pairs.append({"v1": v1, "v2": v2, "type": "cross_nasality_hiccup"})
                matched = True
            elif attr1["height"] == attr2["height"]:
                pairs.append({"v1": v1, "v2": v2, "type": "hiatus_same_height"})
                matched = True
            elif attr1["height"] == "low" and attr2["height"] in ("high", "mid-high"):
                pairs.append({"v1": v1, "v2": v2, "type": "diphthong_crescent"})
                matched = True
            elif attr2["height"] == "low" and attr1["height"] in ("high", "mid-high"):
                pairs.append({"v1": v1, "v2": v2, "type": "diphthong_decrescent"})
                matched = True
            elif attr1["nasal"] and attr2["nasal"]:
                height_order = ["high", "mid-high", "mid-low", "low"]
                if height_order.index(attr1["height"]) height_order.index(attr2["height"]):
                    pairs.append({"v1": v1, "v2": v2, "type": "nasal_diphthong_rising"})
                else:
                    pairs.append({"v1": v1, "v2": v2, "type": "nasal_diphthong_falling"})
                matched = True

            if not matched:
                pairs.append({"v1": v1, "v2": v2, "type": "fallback"})

        results.append({"vowels": seq, "pairs": pairs, "type": "sequence"})

    return results

Casos limite que quebram implementações ingênuas

O cenário que mais causou dor de cabeça nos meus projetos foi a sequência de vogais nasais em palavras como "mãe ama" (/mãi ama/). O reconhecedor tratava a fronteira /ĩ/ + /a/ como ditongo nasal quando na verdade são dois morfemas adjacentes com boundary prosódico. A solução foi adicionar verificação de nasalição cruzada antes de qualquer regra de ditongo, e marcar explicitamente pares com nasalidade diferente como caso especial. Vogais neutras ou reduzidas, como o // central, geram muitos falsos positivos. Em português brasileiro falado rapidamente, o // pode se fundir com vogais vizinhas de forma imprevisível. Se o seu uso é para transcrição fonêmica com alta precisão, considere marcar // como não-pareável automaticamente e deixar para análise acústica manual nesses casos.

Testando com exemplos reais

Aqui estão alguns exemplos de saída do algoritmo: Perceba que "rio" gera /i/ + /o/ como ditongo decrescente, o que está fonologicamente correto para português. Já "janeiro" mostra a complexidade: /a/+/i/ é ditongo crescente, mas /i/+/e/ é hiato porque compartilham a mesma classe de altura. O pareamento de vogais captura essa distinção automaticamente. Este método funciona bem para português padrão com fala cuidadosa. Ele não lida bem com variação dialetal onde ditongos se fundem de forma diferente — em sotaques do Sul, por exemplo, /ej/ tende a se realizar como ditongo fechado, e o algoritmo acima pode classificar incorretamente.

Para contextos onde a fala é altamente coloquial ou com redução vocálica avançada, como em conversas rápidas no Brasil, o pareamento baseado puramente em regras fonêmicas perde precisão. Nesses casos, o ganho em usar modelos acústicos treinados localmente costuma compensar o esforço adicional de coleta e anotação. Outro ponto: vogals em posições pré-pausais, como no final de frase, frequentemente escoram ou se alongam de maneira que regras de pareamento não capturam. Se o seu pipeline processa frases completas com pauses finais, considere adicionar uma regra de contorno que desconsidera pareamento na última posição da frase.

Alternativa para quem precisa de precisão maior

Se o pareamento de vogais é apenas uma etapa num pipeline maior de processamento fonêmico, vale a pena integrar com uma biblioteca como o PHONETISAS ou treinar um GRU simples para classificação de pares. A abordagem baseada em regras que apresentei aqui é um bom baseline e funciona para a maioria dos casos, mas não substitui modelos aprendidos quando você tem volume de dados suficiente.