Detectando sílabas em uma palavra

Preciso encontrar uma maneira bastante eficiente de detectar sílabas em uma palavra. Por exemplo,

Invisível -> in-vi-sib-le

Existem algumas regras de silabificação que podem ser usadas:

V CV VC CVC CCV CCCV CVCC

* onde V é uma vogal e C é uma consoante. Por exemplo,

Pronúncia (5 Pro-freira-cação; CV-CVC-CV-V-CVC)

Eu tentei alguns métodos, entre os quais estavam usando regex (que ajuda apenas se você quiser contar sílabas) ou definição de regra codificada (uma abordagem de força bruta que se mostra muito ineficiente) e finalmente usando um autômato de estado finito (que fez não resultar em nada útil).

O objetivo do meu aplicativo é criar um dicionário de todas as sílabas em um determinado idioma. Este dicionário será usado posteriormente para aplicativos de verificação ortográfica (usando classificadores bayesianos) e síntese de texto para fala.

Eu apreciaria se alguém pudesse me dar dicas de uma maneira alternativa de resolver esse problema, além das abordagens anteriores.

Eu trabalho em Java, mas qualquer dica em C / C ++, C #, Python, Perl ... funcionaria para mim.

Leia sobre a abordagem TeX para esse problema para fins de hifenização. Veja, em especial, a dissertação da tese de Frank Liang, Word Hy-phen-a-by, do autor . Seu algoritmo é muito preciso e inclui um pequeno dicionário de exceções para casos em que o algoritmo não funciona.

Eu tropecei nesta página procurando a mesma coisa e encontrei algumas implementações do documento de Liang aqui: https://github.com/mnater/hyphenator ou o sucessor: https://github.com/mnater/Hyphenopoly

Ou seja, a menos que você goste de ler uma tese de 60 páginas em vez de adaptar o código disponível gratuitamente para problemas não exclusivos. :)

Aqui está uma solução usando o NLTK :

from nltk.corpus import cmudict
d = cmudict.dict()
def nsyl(word):
  return [len(list(y for y in x if y[-1].isdigit())) for x in d[word.lower()]] 

Estou tentando resolver esse problema em um programa que calcula a pontuação de leitura de um bloco de texto flesch-kincaid e flesch. Meu algoritmo usa o que encontrei neste site: http://www.howmanysyllables.com/howtocountsyllables.html e fica razoavelmente próximo. Ele ainda tem problemas com palavras complicadas, como invisível e hifenização, mas descobri que isso entra no campo dos meus propósitos.

Ele tem a vantagem de ser fácil de implementar. Eu descobri que os "es" podem ser silábicos ou não. É uma aposta, mas decidi remover os es no meu algoritmo.

private int CountSyllables(string word)
    {
        char[] vowels = { 'a', 'e', 'i', 'o', 'u', 'y' };
        string currentWord = word;
        int numVowels = 0;
        bool lastWasVowel = false;
        foreach (char wc in currentWord)
        {
            bool foundVowel = false;
            foreach (char v in vowels)
            {
                //don't count diphthongs
                if (v == wc && lastWasVowel)
                {
                    foundVowel = true;
                    lastWasVowel = true;
                    break;
                }
                else if (v == wc && !lastWasVowel)
                {
                    numVowels++;
                    foundVowel = true;
                    lastWasVowel = true;
                    break;
                }
            }

            //if full cycle and no vowel found, set lastWasVowel to false;
            if (!foundVowel)
                lastWasVowel = false;
        }
        //remove es, it's _usually? silent
        if (currentWord.Length > 2 && 
            currentWord.Substring(currentWord.Length - 2) == "es")
            numVowels--;
        // remove silent e
        else if (currentWord.Length > 1 &&
            currentWord.Substring(currentWord.Length - 1) == "e")
            numVowels--;

        return numVowels;
    }

Este é um problema particularmente difícil que não é completamente resolvido pelo algoritmo de hifenização LaTeX. Um bom resumo de alguns métodos disponíveis e dos desafios envolvidos pode ser encontrado no artigo Avaliando algoritmos de silabificação automática para inglês (Marchand, Adsett e Damper 2007).

Por que calculá-lo? Todo dicionário on-line tem essa informação. http://dictionary.reference.com/browse/invisible em · vis · i · ble

Obrigado Joe Basirico, por compartilhar sua implementação rápida e suja em C #. Eu usei as grandes bibliotecas, e elas funcionam, mas geralmente são um pouco lentas e, para projetos rápidos, seu método funciona bem.

Aqui está o seu código em Java, junto com os casos de teste:

public static int countSyllables(String word)
{
    char[] vowels = { 'a', 'e', 'i', 'o', 'u', 'y' };
    char[] currentWord = word.toCharArray();
    int numVowels = 0;
    boolean lastWasVowel = false;
    for (char wc : currentWord) {
        boolean foundVowel = false;
        for (char v : vowels)
        {
            //don't count diphthongs
            if ((v == wc) && lastWasVowel)
            {
                foundVowel = true;
                lastWasVowel = true;
                break;
            }
            else if (v == wc && !lastWasVowel)
            {
                numVowels++;
                foundVowel = true;
                lastWasVowel = true;
                break;
            }
        }
        // If full cycle and no vowel found, set lastWasVowel to false;
        if (!foundVowel)
            lastWasVowel = false;
    }
    // Remove es, it's _usually? silent
    if (word.length() > 2 && 
            word.substring(word.length() - 2) == "es")
        numVowels--;
    // remove silent e
    else if (word.length() > 1 &&
            word.substring(word.length() - 1) == "e")
        numVowels--;
    return numVowels;
}

public static void main(String[] args) {
    String txt = "what";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "super";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "Maryland";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "American";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "disenfranchized";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
    txt = "Sophia";
    System.out.println("txt="+txt+" countSyllables="+countSyllables(txt));
}

O resultado foi o esperado (funciona suficientemente bem para Flesch-Kincaid):

txt=what countSyllables=1
txt=super countSyllables=2
txt=Maryland countSyllables=3
txt=American countSyllables=3
txt=disenfranchized countSyllables=5
txt=Sophia countSyllables=2

Bumping @Tihamer e @ joe-basirico. Função muito útil, não perfeita , mas boa para a maioria dos projetos de pequeno a médio porte. Joe, reescrevi uma implementação do seu código em Python:

def countSyllables(word):
    vowels = "aeiouy"
    numVowels = 0
    lastWasVowel = False
    for wc in word:
        foundVowel = False
        for v in vowels:
            if v == wc:
                if not lastWasVowel: numVowels+=1   #don't count diphthongs
                foundVowel = lastWasVowel = True
                        break
        if not foundVowel:  #If full cycle and no vowel found, set lastWasVowel to false
            lastWasVowel = False
    if len(word) > 2 and word[-2:] == "es": #Remove es - it's "usually" silent (?)
        numVowels-=1
    elif len(word) > 1 and word[-1:] == "e":    #remove silent e
        numVowels-=1
    return numVowels

Espero que alguém ache isso útil!

Perl tem o Lingua :: Fonologia :: Sílaba módulo . Você pode tentar isso ou tentar analisar seu algoritmo. Também vi outros módulos antigos lá.

Não entendo por que uma expressão regular fornece apenas uma contagem de sílabas. Você deve conseguir as sílabas usando parênteses de captura. Supondo que você possa construir uma expressão regular que funcione, ou seja.

Hoje encontrei essa implementação em Java do algoritmo de hifenização de Frank Liang com padrão para inglês ou alemão, que funciona muito bem e está disponível no Maven Central.

Cave: É importante remover as últimas linhas dos .texarquivos de padrão, pois, caso contrário, esses arquivos não poderão ser carregados com a versão atual no Maven Central.

Para carregar e usar o hyphenator, você pode usar o seguinte snippet de código Java. texTableé o nome dos .texarquivos que contêm os padrões necessários. Esses arquivos estão disponíveis no site do projeto github.

 private Hyphenator createHyphenator(String texTable) {
        Hyphenator hyphenator = new Hyphenator();
        hyphenator.setErrorHandler(new ErrorHandler() {
            public void debug(String guard, String s) {
                logger.debug("{},{}", guard, s);
            }

            public void info(String s) {
                logger.info(s);
            }

            public void warning(String s) {
                logger.warn("WARNING: " + s);
            }

            public void error(String s) {
                logger.error("ERROR: " + s);
            }

            public void exception(String s, Exception e) {
                logger.error("EXCEPTION: " + s, e);
            }

            public boolean isDebugged(String guard) {
                return false;
            }
        });

        BufferedReader table = null;

        try {
            table = new BufferedReader(new InputStreamReader(Thread.currentThread().getContextClassLoader()
                    .getResourceAsStream((texTable)), Charset.forName("UTF-8")));
            hyphenator.loadTable(table);
        } catch (Utf8TexParser.TexParserException e) {
            logger.error("error loading hyphenation table: {}", e.getLocalizedMessage(), e);
            throw new RuntimeException("Failed to load hyphenation table", e);
        } finally {
            if (table != null) {
                try {
                    table.close();
                } catch (IOException e) {
                    logger.error("Closing hyphenation table failed", e);
                }
            }
        }

        return hyphenator;
    }

Depois o Hyphenatorestá pronto para uso. Para detectar sílabas, a idéia básica é dividir o termo nos hífens fornecidos.

    String hyphenedTerm = hyphenator.hyphenate(term);

    String hyphens[] = hyphenedTerm.split("\u00AD");

    int syllables = hyphens.length;

Você precisa se separar "\u00AD", pois a API não retorna um normal "-".

Essa abordagem supera a resposta de Joe Basirico, uma vez que suporta muitos idiomas diferentes e detecta a hifenização alemã mais precisa.

Encontrei exatamente esse mesmo problema há pouco tempo.

Acabei usando o Dicionário de Pronúncia da CMU para pesquisas rápidas e precisas da maioria das palavras. Para palavras que não estão no dicionário, voltei a um modelo de aprendizado de máquina com ~ 98% de precisão na previsão da contagem de sílabas.

Eu envolvi tudo em um módulo python fácil de usar aqui: https://github.com/repp/big-phoney

Instalar: pip install big-phoney

Contagem de sílabas:

from big_phoney import BigPhoney
phoney = BigPhoney()
phoney.count_syllables('triceratops')  # --> 4

Se você não está usando Python e deseja tentar a abordagem baseada no modelo ML, escrevi bastante detalhadamente como o modelo de contagem de sílabas funciona no Kaggle .

Obrigado @ joe-basirico e @tihamer. Portei o código do @ tihamer para Lua 5.1, 5.2 e luajit 2 ( provavelmente também será executado em outras versões do lua ):

countsyllables.lua

function CountSyllables(word)
  local vowels = { 'a','e','i','o','u','y' }
  local numVowels = 0
  local lastWasVowel = false

  for i = 1, #word do
    local wc = string.sub(word,i,i)
    local foundVowel = false;
    for _,v in pairs(vowels) do
      if (v == string.lower(wc) and lastWasVowel) then
        foundVowel = true
        lastWasVowel = true
      elseif (v == string.lower(wc) and not lastWasVowel) then
        numVowels = numVowels + 1
        foundVowel = true
        lastWasVowel = true
      end
    end

    if not foundVowel then
      lastWasVowel = false
    end
  end

  if string.len(word) > 2 and
    string.sub(word,string.len(word) - 1) == "es" then
    numVowels = numVowels - 1
  elseif string.len(word) > 1 and
    string.sub(word,string.len(word)) == "e" then
    numVowels = numVowels - 1
  end

  return numVowels
end

E alguns testes divertidos para confirmar que funciona ( tanto quanto deveria ):

countsyllables.tests.lua

require "countsyllables"

tests = {
  { word = "what", syll = 1 },
  { word = "super", syll = 2 },
  { word = "Maryland", syll = 3},
  { word = "American", syll = 4},
  { word = "disenfranchized", syll = 5},
  { word = "Sophia", syll = 2},
  { word = "End", syll = 1},
  { word = "I", syll = 1},
  { word = "release", syll = 2},
  { word = "same", syll = 1},
}

for _,test in pairs(tests) do
  local resultSyll = CountSyllables(test.word)
  assert(resultSyll == test.syll,
    "Word: "..test.word.."\n"..
    "Expected: "..test.syll.."\n"..
    "Result: "..resultSyll)
end

print("Tests passed.")

Não consegui encontrar uma maneira adequada de contar sílabas, então eu mesmo projetei um método.

Você pode ver meu método aqui: https://stackoverflow.com/a/32784041/2734752

Eu uso uma combinação de um método de dicionário e algoritmo para contar sílabas.

Você pode ver minha biblioteca aqui: https://github.com/troywatson/Lawrence-Style-Checker

Acabei de testar meu algoritmo e tinha uma taxa de ataque de 99,4%!

Lawrence lawrence = new Lawrence();

System.out.println(lawrence.getSyllable("hyphenation"));
System.out.println(lawrence.getSyllable("computer"));

Resultado:

4
3

Depois de fazer muitos testes e experimentar pacotes de hifenização, escrevi os meus com base em vários exemplos. Eu também tentei os pacotes pyhyphene pyphenque fazem interface com os dicionários de hifenização, mas eles produzem o número errado de sílabas em muitos casos. O nltkpacote estava muito lento para este caso de uso.

Minha implementação em Python faz parte de uma classe que escrevi e a rotina de contagem de sílabas é colada abaixo. Superestima um pouco o número de sílabas, pois ainda não encontrei uma boa maneira de explicar as terminações de palavras silenciosas.

A função retorna a proporção de sílabas por palavra, conforme é usada para uma pontuação de legibilidade de Flesch-Kincaid. O número não precisa ser exato, apenas perto o suficiente para uma estimativa.

Na minha CPU i7 de 7ª geração, essa função levou 1,1-1,2 milissegundos para um texto de amostra de 759 palavras.

def _countSyllablesEN(self, theText):

    cleanText = ""
    for ch in theText:
        if ch in "abcdefghijklmnopqrstuvwxyz'’":
            cleanText += ch
        else:
            cleanText += " "

    asVow    = "aeiouy'’"
    dExep    = ("ei","ie","ua","ia","eo")
    theWords = cleanText.lower().split()
    allSylls = 0
    for inWord in theWords:
        nChar  = len(inWord)
        nSyll  = 0
        wasVow = False
        wasY   = False
        if nChar == 0:
            continue
        if inWord[0] in asVow:
            nSyll += 1
            wasVow = True
            wasY   = inWord[0] == "y"
        for c in range(1,nChar):
            isVow  = False
            if inWord[c] in asVow:
                nSyll += 1
                isVow = True
            if isVow and wasVow:
                nSyll -= 1
            if isVow and wasY:
                nSyll -= 1
            if inWord[c:c+2] in dExep:
                nSyll += 1
            wasVow = isVow
            wasY   = inWord[c] == "y"
        if inWord.endswith(("e")):
            nSyll -= 1
        if inWord.endswith(("le","ea","io")):
            nSyll += 1
        if nSyll < 1:
            nSyll = 1
        # print("%-15s: %d" % (inWord,nSyll))
        allSylls += nSyll

    return allSylls/len(theWords)

Eu usei o jsoup para fazer isso uma vez. Aqui está um exemplo de analisador de sílaba:

public String[] syllables(String text){
        String url = "https://www.merriam-webster.com/dictionary/" + text;
        String relHref;
        try{
            Document doc = Jsoup.connect(url).get();
            Element link = doc.getElementsByClass("word-syllables").first();
            if(link == null){return new String[]{text};}
            relHref = link.html(); 
        }catch(IOException e){
            relHref = text;
        }
        String[] syl = relHref.split("·");
        return syl;
    }