Estado do reconhecimento de voz

À medida que computadores diminuem de tamanho e aumentam em questões de portabilidade, a necessidade de interagir com eles sem usar um teclado ou um mouse aumenta. A voz é uma alternativa. Superficialmente, muito menos largura da banda está disponível para comunicações de voz do que para interação visual. Como resultado da impressão de que "uma figura equivale a mil palavras", os computadores exibem em telas como resposta a entrada periférica mecânica muito mais prontamente do que aceitam entrada de áudio e respondem de maneira similar.

Já existem técnicas bem-sucedidas, mas limitadas, para emitir instruções para computadores menores com voz. O objetivo é fazer com que um computador reaja à voz e tome uma ação específica com base no comando. O processo geral para atingir esta meta é construir (ou adaptar) um modelo, aplicar um comando com relação àquele modelo em um processo de reconhecimento e, a seguir, decidir sobre uma ação em um gerenciador de diálogos. Os modelos podem ser amplos, no sentido de reconhecer uma variedade de vozes, porém com poucos comandos. Ou é possível treinar seu próprio modelo a partir de uma gramática específica que ofereça a possibilidade de interpretação e interação muito complexas. A Figura 1 mostra o fluxo de desenvolvimento de reconhecimento e interpretação de voz.

É importante fazer uma distinção entre natural language processing (NLP) e gramáticas n-gram específicas. A última determina categoricamente o que o reconhecedor pode esperar ouvir, enquanto que o primeiro faz o melhor possível para decodificar o idioma natural em uma estrutura mais simples, descartando alguns elementos do discurso recebido e reajustando outros. Enquanto que tecnologias, como SRGS e SISR, inclinam-se principalmente na direção do processamento de idioma natural, os programadores procuram formas de usar as mesmas ferramentas para outros tipos de gramáticas.

Este artigo usa a abordagem de SRGS para definir gramáticas fixas e trata as questões de contexto e solicitações out-of-vocabulary (OOV) no gerenciador de diálogos, usando o exemplo de um conjunto de amostras de 2-gram ou bigram.

Voltar para parte superior

A perspectiva da programação

De uma perspectiva da programação, algumas questões são importantes. Primeiro, é possível expressar uma gramática de várias formas diferentes, dependendo do aplicativo reconhecedor de discurso que for usado. Segundo, essas gramáticas não são bem-coordenadas com os gerenciadores de diálogos que as usam. Gerenciadores de diálogos são importantes por si só porque oferecem formas de lidar com questões como resposta inteligente e reconhecimento de OOV. Terceiro, como estamos conversando sobre gramáticas específicas projetadas para realizar um trabalho específico, é preciso reescrever ou adaptar o modelo e o gerenciador de diálogos para cada uma. Quanto mais automaticamente você puder gerá-las, melhor.

A resposta inteligente implica que o computador leva o contexto em consideração. Se sua pergunta solicitar uma temperatura e a questão anterior perguntar sobre seu computador, então deve ser a temperatura do computador que você necessita.

OOV é um problema comum em gramáticas pequenas. De forma simples, ele diz que algumas solicitações são importantes e outras são necessárias para construir o modelo, porém não são importantes para o processamento posterior.

A geração automática é direta, usando scripts, como Bash, Perl e PHP, ou linguagens de programação comuns, como C e C++, desde que existam regras claras. E o SRGS foi projetado para resumir essas regras.

Voltar para parte superior

Um exemplo

A listagem 1 é uma gramática em texto simples em protótipo.

COMPUTER WAKE
COMPUTER STATUS
COMPUTER SLEEP

A gramática na listagem 1 é bastante simples e específica. Ela diz ao computador que só escuta três solicitações possíveis. Cada solicitação é iniciada com a palavra COMPUTER e pode ser seguida de WAKE, STATUS(SLEEP. Nenhum outro comando é possível. O reconhecedor de discurso tem somente uma tarefa, que é escolher qual das três opções ele considera mais próxima do que ouviu e passar aquele comando para a próxima etapa. Por exemplo, se eu disser MAKE COFFEE, ele retorna COMPUTER mais uma das três palavras alternativas. O gerenciador de diálogos deverá aplicar a mesma inteligência. Por exemplo, se ele ouvir COMPUTER SLEEP, não deverá responder a nenhum outro comando até que escute COMPUTER WAKE. Ele deverá responder a COMPUTER STATUS somente se estiver em um estado WAKE e, neste ponto, poderá anunciar a temperatura do processador, espaço livre em disco e uma série de outras coisas interessantes. Isto não é uma gramática prática de maneira nenhuma— ao construir um modelo acústico de gramáticas pequenas como esta, você terá, em pouco tempo, problemas relacionados a amostras insuficientes. Este protótipo tem como finalidade somente uma ilustração do princípio.

Treinar um computador para reconhecer sons falados e aplicar regras de gramática ao que ele escuta é um processo relativamente direto, mesmo se relacionado ao software livre. Para obter orientações completas sobre como obter um sistema efetivo de reconhecimento de discurso usando um vocabulário fixo, consulte o site VoxForge. Os tutoriais do VoxForge usam ferramentas como o HTK, da Universidade de Cambridge, e o mecanismo de reconhecimento de voz Julius, da Universidade de Nagoya no Japão. Consulte a seção Recursos para obter links para todos esses sites.

Construir um modelo de áudio com o HTK requer que você expresse a gramática em um formato particular, como na listagem 2.

$major =  COMPUTER ;
$minor = WAKE | STATUS | SLEEP ;
( SENT-START ( $major $minor ) SENT-END )

O mesmo processo com o mecanismo Julius requer um formato um pouco diferente, como na listagem 3.

S : NS_B SENT NS_E
SENT: MAJOR MINOR
MAJOR: COMPUTER
MINOR: WAKE STATUS SLEEP

Os formatos HTK e Julius compartilham similaridades estruturais do ponto de vista de programação, mas são suficientemente diferentes para não serem intercambiáveis.

A listagem 4 mostra um gerenciador de diálogos simples em PHP que pode lidar com esta gramática.

<?php
...
function dm($prompt_heard) {
global $wake_state; // FALSE is asleep so do not respond, TRUE is awake
  $parts = explode(" ",$prompt_heard);
  $minor = $parts[1];
  switch ($minor) {
    case 'WAKE':
      $wake_state = TRUE ;
    break;
    case 'SLEEP':
      $wake_state = FALSE ;
    break;
    case 'STATUS':
      if ($wake_state) {
        announce_status();
      } else {
        // do nothing
      }
    break;
    default:
      // OOV - any other prompt, just ignore it.
    break;
  }
}
?>

Esta função PHP passa o resultado do reconhecedor com um argumento em $prompt_heard. A variável $wake_state é declarada como global e é conhecida em todo o gerenciador de diálogos. O explode() analisa as partes da solicitação ouvida. Neste caso de exemplo, você sabe que a primeira parte será COMPUTER, portanto o switch seguinte lê somente a parte menor. Se for WAKE, então defina o estado wake para TRUE. Se for SLEEP, então defina o estado wake para FALSE. Se a parte menor for STATUS, anuncie o resultado, mas somente se o estado wake for TRUE. É possível anunciar o status para as pessoas que falam usando um processo similar ao explorado no artigo do developerWorks "PHP bees and audio honey: Accessible agent-based audio alerts and feedback" (consulte Recursos ). A seção padrão capturará quaisquer solicitações adicionais que forem incluídas a fim de exercitar o reconhecedor— para solicitações não reconhecidas, não tome nenhuma ação, a não ser gravar um registro para resolução de problemas posteriores.

Do ponto de vista de eficiência de programação, se for possível gerar automaticamente parte da gramática e do gerenciador de diálogos, você economizará tempo e esforço, e melhorará a precisão. Os esforços para criar até mesmo gramáticas de nível mais alto para fazer isto (consulte Recursos ) estão amplamente no domínio de NLP.

Voltar para parte superior

Como SRGS pode ajudar

O SRGS destina-se a exprimir as mesmas ideias que a listagem 2 e alistagem 3 , mas em uma estrutura mais rigorosa fornecida pelo XML, como na listagem 5.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE grammar PUBLIC "-//W3C//DTD GRAMMAR 1.0//EN"
                  "http://www.w3.org/TR/speech-grammar/grammar.dtd">
<grammar xmlns="http://www.w3.org/2001/06/grammar" xml:lang="en"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
         xsi:schemaLocation="http://www.w3.org/2001/06/grammar 
                             http://www.w3.org/TR/speech-grammar/grammar.xsd"
         version="1.0" 
         mode="voice" 
         root="myroot">
<meta name="author" content="Colin Beckingham"/>
<rule id="myroot" scope="public">
  <example> COMPUTER WAKE </example>
  <example> COMPUTER SLEEP </example>
  <example> COMPUTER STATUS </example>
  <ruleref uri="#command1"/>
  <!-- ruleref uri="#command2"/ -->
</rule>
<rule id="command1">
  <ruleref uri="#major"/> <ruleref uri="#minor"/>
</rule>
<rule id="major">
   <one-of>
      <item> COMPUTER </item>
    </one-of>
</rule>
<rule id="minor">
    <one-of>
      <item> WAKE </item>
      <item> SLEEP </item>
      <item> STATUS </item>
    </one-of>
</rule>
</grammar>

A listagem 5 mostra a declaração XML usual, seguida de uma instrução DOCTYPE que localiza o DTD. Neste caso, ele aponta detalhes relacionados a gramáticas. Ele, então, acompanha o elemento-raiz <grammar>. O elemento grammar contém uma série de atributos importantes, incluindo espaços de nomes, o modo (que neste caso é voice porque o destino dos dados é o reconhecedor de discurso) e o ID da regra raiz, que é o local no qual iniciar a procurar por solicitações correspondentes (neste caso, myroot). A regra myroot contém rulerefs que apontam para outras regras. O DTD permite elementos <example> como informações. A regra com ID command1 vem a seguir. Depois, há mais duas regras, major e minor. A regra major contém uma única palavra COMPUTER. A regra minor contém as alternativas WAKE, SLEEPe STATUS. Estes últimos são elementos <item> em uma estrutura <one-of> , indicando que uma, e somente uma, se aplica de cada vez. Usando o elemento <ruleref> da regra raiz, as regras major e minor tornam-se parte da estrutura geral de regras.

Em resumo, as regras seguem esta estrutura:

1. O atributo da gramática root aponta para a regra raiz myroot.
2. A regra myroot contém um ou mais rulerefs, cada um dos quais tem um URI que aponta para outra regra, neste caso command1, que é a regra principal para uma n-gram. O ruleref para command2 está comentado porque é um marcador para uma regra principal ainda inexistente.
3. A regra principal command1 contém ruleref que mostra que outras regras são usadas, major seguida de minor.

Os processos de geração de modelo para HTK e Julius não são agentes do usuário em termos de W3C porque não leem atualmente o formato SRGS diretamente, mas, em vez disso, usam o SRGS para definir as chamadas de gramática para que um script converta o SRGS para outros formatos. Além disso, nem o HTK ou o Julius geram um gerenciador de diálogos por causa de informações insuficientes. Como, por exemplo, ele pode saber que SLEEP significa parar de responder?

Voltar para parte superior

Convertendo o SRGS para HTK ou Julius

A listagem 6 é um conversor simples em PHP que examina a versão do SRGS e cria saída na forma de uma gramática básica equivalente ao formato HTK ou Julius.

<?php
// test translator: SRGS to HTK/Julius
$xml = simplexml_load_file("mysrgs.xml");
$roote = trim($xml['root']);
// find the root rule, get the basic rulerefs
foreach ($xml->rule as $rule) { 
  if ($rule['id'] == $roote) { 
    foreach ($rule->ruleref as $rref) {
      $rulerefs[] = substr($rref['uri'],1);
} } }
// find the rules indicated by the rulerefs
foreach ($rulerefs as $ruleid) {
  foreach ($xml->rule as $rule) {
    if ($rule['id'] == $ruleid) {
      $i = 0;
      foreach ($rule->ruleref as $rref) {
        $myrules[$ruleid][$i] = substr($rref['uri'],1);
        $i++;
} } } }
// load the words array
foreach ($myrules as $mr=>$myr) {
  foreach ($myr as $md=>$myd) {
    foreach ($xml->rule as $rule) {
      if ($rule['id'] == $myd) {
        foreach ($rule->{'one-of'}->item as $item) {
          $words[$mr][$md][] = $item;
} } } } }
// now the output
$varnamestr .= "";
$jvarnamestr = "";
foreach ($words as $k=>$v) { // master
  $jvarnamestr .= "\nSENT: ";
  foreach ($v as $kk=>$vv) { // sub
    $i = 0;
    foreach ($vv as $wd) { // word
      $j = count($vv);
      $htkwds[$k][$kk] .= " $wd ";
      $i++;
      $jwds[$k][$kk] .= " $wd ";
      if ($i < $j) $htkwds[$k][$kk] .= "|";
    }
    // htk
    $varname = "$".$k."_".$kk."";
    $htkv .= "$varname = ".$htkwds[$k][$kk].";\n";
    $varnamestr .= " ".$varname;
    // julius
    $jvarname = strtoupper($k."_".$kk);
    $jvarwordstr .= "$jvarname: ".$jwds[$k][$kk]."\n";
    $jvarnamestr .= " ".$jvarname." ";
  }
  $varnamestr = $varnamestr." |";
}
// output as HTK
echo "\n-------------------------\n";
echo "HTK Version\n-------------------------\n";
$varnamestr = substr($varnamestr,0,-2);
$htk = $htkv."( SENT-START (".$varnamestr." ) SENT-END )";
echo "$htk\n-------------------------\n";
// output as Julius
echo "Julius Version\n-------------------------\n";
$julius = "S : NS_B SENT NS_E";
$julius .= "$jvarnamestr\n";
$julius .= "$jvarwordstr";
echo "$julius-------------------------\n";
// end
echo "Done\n\n";
?>

A meta geral do programa na listagem 6 é varrer o documento SRGS e preencher uma matriz multidimensional com objetos SimpleXML que representam a estrutura da solicitação. Quando a matriz estiver concluída, ele gera as variáveis de sequência necessárias daquela matriz e grava os formatos HTK e Julius. A matriz é preenchida usando uma série de instruções foreach que escolhem a regra raiz, as regras principais e as regras as quais as regras principais se referem. O resultado é uma matriz em que a primeira chave é o nome da regra principal e a segunda chave é a posição —0 (major) ou 1 (minor). As variáveis $i e $j são contadores que controlam a adição de uma barra vertical (|), que é um símbolo OR no formato HTK. Finalmente, a saída usa variáveis criadas a partir das palavras e dos IDs das regras principais. A listagem 7 é a saída de uma sessão de amostra.

 
> php mytrans.php

-------------------------
HTK Version
-------------------------
$command_0 =  COMPUTER ;
$command_1 =  WAKE | SLEEP | STATUS ;
$zoo_0 =  ANIMALS ;
$zoo_1 =  TIGER | LION | LEOPARD ;
( SENT-START ( $command_0 $command_1 | $zoo_0 $zoo_1 ) SENT-END )
-------------------------
Julius Version
-------------------------
S : NS_B SENT NS_E
SENT:  COMMAND_0  COMMAND_1
SENT:  ZOO_0  ZOO_1
COMMAND_0:  COMPUTER
COMMAND_1:  WAKE  SLEEP  STATUS
ZOO_0:  ANIMALS
ZOO_1:  TIGER  LION  LEOPARD
-------------------------
Done

Este código leva você de volta ao formato das Listagens 2 e 3. Para fins de teste, uma segunda regra principal foi adicionada, a fim de garantir que várias regras principais sejam processadas. Note que este é um conversor básico que não lida com repetições (por exemplo, onde um conjunto de números pode ser repetido, como em um número de telefone). Ainda é preciso definir outros arquivos dependendo do vocabulário, léxico e estrutura de fonemas escolhidos antes que seja possível construir o modelo, mas isto ao menos proporciona a você o ponto de partida. Consulte o tutorial do VoxForge em Recursos para obter orientação adicional.

Voltar para parte superior

Gerador do gerenciador de diálogos

O programador agora se volta para o gerenciador de diálogos. Será útil se você puder gerar pelo menos parte do diálogo a partir da origem do SRGS. Se trabalhar com uma gramática livre de contexto, a estrutura do n-gram (consulte Recursos ) poderá ser o que você precisa. Nesta situação do n-gram atual, a gramática é fixa. A gramática contém quatro palavras e o uso dessas palavras só permite três respostas possíveis.

Ao mesmo tempo que permanece rigorosamente dentro do padrão, a definição do SRGS permite adicionar alguns detalhes que são úteis ao gerar um gerenciador de diálogos. Primeiro, ela permite a adição de um atributo weight ao elemento <item> como um número inteiro ou decimal. Segundo, ela permite a edição de elementos <tag> a regras como filhos que podem conter sequências arbitrárias. Elas são, mais frequentemente, expressões ECMAScript (JavaScript). E são comumente usadas para emitir instruções SISR para analisadores NLP em navegadores, mas, neste exemplo, poderão ser úteis para enviar dicas a um gerador de gerenciador de diálogos.

Você já tem algumas informações da gramática: O formato do bigram pede duas instruções switch, que são menores aninhadas dentro de maiores. Isto é bem direto. Mas o contexto e o OOV pedem mais do que isso. Esta proposta usa o atributo weight para lidar com o OOV e o elemento tag a fim de identificar o contexto.

...
<item weight="1"> COMPUTER <tag>$context = "tech";</tag></item>
...
<item weight=""> WAKE <tag>$wake_state = TRUE;</tag></item>
<item weight=""> SLEEP <tag>$wake_state = FALSE;</tag></item>
<item weight=""> STATUS <tag>
      if ($wake_state) {
        announce_status();
      }</tag></item>
...      
<item weight="0"> ANIMALS <tag></tag></item>
...

Note que COMPUTER maior tem peso 1, mas ANIMALS tem peso 0. Neste contexto, você quer que COMPUTER * seja reconhecido, mas ANIMALS * deverá ser ignorado como OOV. Adicionalmente, os elementos tag contêm fragmentos de código PHP que o gerador poderá inserir.

A meta do gerador do gerenciador de diálogos mostrado na listagem 9 é construir uma função dm() semelhante à listagem 4.

<?php
// Dialog manager generator
// Colin Beckingham, 2010
// test dmgen
$xml = simplexml_load_file("mysrgs.xml");
$roote = trim($xml['root']);
// find the root rule, get the basic rulerefs
foreach ($xml->rule as $rule) { 
  if ($rule['id'] == $roote) { 
    foreach ($rule->ruleref as $rref) {
      $rulerefs[] = substr($rref['uri'],1);
} } }
// find the rules indicated by the rulerefs
foreach ($rulerefs as $ruleid) {
  foreach ($xml->rule as $rule) {
    if ($rule['id'] == $ruleid) {
      $i = 0;
      foreach ($rule->ruleref as $rref) {
        $myrules[$ruleid][$i] = substr($rref['uri'],1);
        $i++;
} } } }
// load the words array
foreach ($myrules as $mr=>$myr) {
  foreach ($myr as $md=>$myd) {
    foreach ($xml->rule as $rule) {
      if ($rule['id'] == $myd) {
        foreach ($rule->{'one-of'}->item as $item) {
          $words[$mr][$md][] = $item;
} } } } }
$dmout1 = "<?php
...
function dm(\$prompt_heard) {
global \$wake_state; // FALSE is asleep so do not respond, TRUE is awake
  \$parts = explode(\" \",\$prompt_heard);
  \$major = \$parts[0];
  \$minor = \$parts[1];
  switch (\$major) {";
    foreach ($words as $mw) {
      $mww = $mw[0][0]->attributes();
      if ($mww->weight == 1) {
$maj = "    case '".trim($mw[0][0])."':\n      ";
$maj .= "".$mw[0][0]->tag."";
$min1 = "\n      switch (\$minor) {";
        $ins .= "\n$maj$min1";
        foreach ($mw[1] as $mm) {
$min2 = "\n        case '".trim($mm)."':\n";
$min3 = "        ".$mm->tag."\n";
$min4 = "        break;";
        $ins .= "$min2$min3$min4";
      }
$min5 = "\n        case default:\n        break;\n      }";
        $ins .= $min5;
      }
    }
$dmout2= "
    default:
      // OOV - any other prompt, just ignore it.
    break;
  }
}
?>
";
echo "$dmout1$ins$dmout2\n";
?>

A primeira metade do código na listagem 9 é exatamente a mesma que o código do conversor na listagem 6. Esta duplicação é intencional pois, eventualmente, a geração da gramática e do gerenciador de diálogos poderá ser realizada no mesmo programa. Tendo estabelecido a matriz $words com objetos SimpleXML, agora é possível varrer aqueles objetos e escolher valores não só para itens, como também para pesos e tags. Depois da gravação de parte do código estático introdutório, o gerador do gerenciador de diálogos faz iteração pelos objetos SimpleXML, renderizando a saída em formato de código PHP e aninhando as instruções switch conforme necessário.

A listagem 10 mostra uma saída de amostra a partir de um arquivo SRGS de origem para teste que contém três regras principais, uma das quais deverá ser ignorada somente como dados de teste.

> php dmgen2.php

<?php                                                          
...                                                            
function dm($prompt_heard) {                                   
global $wake_state; // FALSE is asleep so do not respond, TRUE is awake
  $parts = explode(" ",$prompt_heard);                                 
  $major = $parts[0];                                                  
  $minor = $parts[1];                                                  
  switch ($major) {                                                    
    case 'COMPUTER':                                                   
      $context = "tech";                                               
      switch ($minor) {                                                
        case 'WAKE':                                                   
          $wake_state = TRUE;
        break;
        case 'SLEEP':
          $wake_state = FALSE;
        break;
        case 'STATUS':
          if ($wake_state) { announce_status(); }
        break;
        case default:
        break;
      }
    case 'APPLES':
      $context = "fruit";
      switch ($minor) {
        case 'PIPPIN':
          pippin apple
        break;
        case 'DELICIOUS':
          delicious apple
        break;
        case 'SPARTAN':
          spartan apple
        break;
        case default:
        break;
      }
    default:
      // OOV - any other prompt, just ignore it.
    break;
  }
}
?>

Os arquivos que geraram esta saída estão disponíveis em Download.

Voltar para parte superior

Conclusão

Com o SRGS, é possível determinar requisitos para uma gramática fixa, além de sua função usual em NLP, fornecendo um local central para a geração de arquivos de gramática e do gerenciador de diálogos. Usando o atributo weight para definir se uma regra principal deverá ser detectada e o elemento <tag> para instruir o gerenciador de diálogos sobre qual ação tomar quando uma solicitação específica for detectada, a geração automática de gramática e de gerenciadores de diálogos é mais rigorosa e efetiva.

Interagir com um computador somente por voz é um trabalho muito mais difícil do que usar vários dispositivos de hardware de entrada e monitorar o estado do computador com feedback visual. Como programadores de voz, um objetivo principal seria facilitar a interação de usuários por voz— particularmente para aqueles que não têm opção além de usar a voz e os ouvidos. Apesar de os geradores de gramática e de o gerenciador de diálogos apresentados aqui não serem simples em si, seus produtos podem tornar mais fácil o processo de criar ferramentas simples e que possam ser empilhadas.

Voltar para parte superior

Download

Informações sobre métodos de download

Recursos

Aprender

• Tutoriais do VoxForge : Construa seu próprio modelo de interação com voz.
  
  
• Speech Recognition Grammar Compilation in Grammatical Framework" (ACL Anthology Network, 2007): Aprenda a gerar modelos de linguagem com base em gramática para sistemas de reconhecimento de discurso a partir das gramáticas da Grammatical Framework.
  
  
• Especificação de gramática para reconhecimento de discurso Versão 1.0: Examine a sintaxe W3C para representar gramáticas para reconhecimento de discurso e para especificar as palavras e padrões de palavras buscados por um reconhecedor de discursos.
  
  
• Interpretação semântica para reconhecimento de discurso Versão 1.0: Revise a sintaxe e a semântica W3C das tags de interpretação semântica para gramáticas de reconhecimento de discurso.
  
  
• Especificação de modelos de idiomas estocásticos (N-Gram) : Examine a sintaxe W3C para representação de gramáticas estocásticas N-Gram (Markovian). Gramáticas estocásticas suportam vocabulário grande e aplicativos de vocabulário aberto, e representam conceitos ou semânticas.
  
  
• PHP bees and audio honey: Accessible agent-based audio alerts and feedback (Colin Beckingham, developerWorks, outubro de 2009): Alimente alto-falantes de computadores com informações de áudio nesta abordagem PHP.
  
  
• Querying a database using open source voice control software (Colin Beckingham, Linux.com, maio de 2008): Confira esta tentativa bem-sucedida de consultar um banco de dados por meio de voz, em que o computador responde verbalmente.
  
  
• Área de XML do developerWorks: Obtenha os recursos necessários para melhorar suas qualificações na esfera de XML.
  
  
• My developerWorks: Personalize sua experiência no developerWorks.
  
  
• Certificação XML da IBM: Descubra como se tornar um Desenvolvedor Certificado pela IBM em XML e tecnologias relacionadas.
  
  
• Biblioteca técnica de XML: Consulte a zona de XML para obter uma ampla gama de artigos técnicos e dicas, tutoriais, padrões e Redbooks da IBM. Leia também mais dicas de XML.
  
  
• eventos técnicos e webcasts do developerWorks : Mantenha-se atualizado em relação à tecnologia nessas sessões.
  
  
• DeveloperWorks no Twitter: Inscreva-se hoje para seguir os tweets do developerWorks.
  
  
• Podcasts do developerWorks: Ouça entrevistas e discussões interessantes para desenvolvedores de software.
  
  
• Demos on demand no developerWorks: Acompanhe demos que abrangem desde a instalação de produto e configuração para iniciantes até funcionalidade avançada para desenvolvedores experientes.
  
  

Obter produtos e tecnologias

• Julius: Explore um software decodificador de alto desempenho, com large vocabulary continuous speech recognition (LVCSR) em duas etapas, para pesquisadores e desenvolvedores, o qual é baseado em N-gram de palavras e HMM dependente de contexto.
  
  
• HTK: Descubra este kit de ferramentas portátil para construir e manipular modelos Markov ocultos. Usado principalmente para pesquisa de reconhecimento de discurso, o HTK também é usado para pesquisas em síntese de discurso, reconhecimento de caracteres e sequenciamento de DNA.
  
  
• Versões de avaliação de produto IBM: Faça o download ou explore as versões de teste online no IBM SOA Sandbox e entre em contato com as ferramentas de desenvolvimento de aplicativos e produtos de middleware do DB2®, Lotus®, Rational®, Tivoli®e WebSphere®.
  
  

Discutir

• Fóruns de discussão da zona de XML: Participe de qualquer uma das várias discussões relacionadas à XML.
  
  
• Blogs do developerWorks: Confira esses blogs e participe.
  
  

Sobre o autor

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Estado do reconhecimento de voz
• A perspectiva da programação
• Um exemplo
• Como SRGS pode ajudar
• Convertendo o SRGS para HTK ou Julius
• Gerador do gerenciador de diálogos
• Conclusão
• Download
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais