Integración de Verbio en Asterisk

VerbioVerbio es un sistema de reconocimiento y síntesis de voz (ASR y TTS) independiente del locutor. Mediante un AGI podemos llamar a Verbio para así crear un IVR controlado mediante voz en vez de marcaciones.

Usando las diferentes gramáticas que nos ofrece Verbio o las creadas por nosotros mismos, podemos reconocer teléfonos, DNI, nombres y lo que se nos ocurra. Esto permite una interacción mucho más natural con nuestra centralita Asterisk que la típica marcación para navegar un menú.

Supondremos Verbio instalado y configurado ya en nuestro servidor por lo que no hablaremos de la configuración de Verbio. Eso sería material de otro artículo.

Un ejemplo sencillo: La centralita da un mensaje de bienvenida a una llamada entrante. Pide el nombre de Juan o de Pepe para transferir a la extensión adecuada o se disculpa y pide de nuevo el nombre si no ha entendido lo dicho.

DIALPLAN:

exten => 888,1,NoOp(Llamada entrante)
exten => 888,n,Playback(bienvenido_diga_nombre)
exten => 888,n,Goto(889,1)
exten => 889,1,AGI(ASR.agi|nombres.txt|ISOLATED|2|5000)
exten => 889,n,GotoIf($[$[${VASR_RESULT} != ERROR] & $[${VASR_SCORE}>${UMBRAL}]]?400,1:401,1)
;
;Si no hay error en el reconocimiento
;si juan vete a juan y si no vete a pepe
exten => 400,1,n,GotoIf($[${VASR_RESULT} = JUAN]?200,1:201,1)
;
;Si hay error en el reconocimiento disculpas y vuelve al ASR
exten => 401,1,Playback(no_he_entendido_repita)
exten => 401,n,Goto(889,1)
;
exten => 200,1,NoOp(Extension de Juan)
exten => 201,1,NoOp(Extension de Pepe)
;
;si queremos tts
exten => xxx,1,AGI(TTS.agi|es|laura|Hola mundo hoy es ${DIA_DE_LA SEMANA})

El ASR.agi es un script que recibe como parámetro el tipo de gramática así como el fichero de gramática que vamos a usar. De esta forma, podemos usar el mismo AGI para interpretar nombres, números…

Su funcionamiento es muy simple: Graba lo que el usuario ha dicho, ejecuta el cliente de verbio para ASR y devuelve el valor reconocido así como una puntuación que nos indica lo fiable que ha sido el reconocimiento. Estos valores son los que utilizamos en el dialplan para saltar a una u otra extensión.

ASR.agi:

  1. #!/usr/bin/perl
  2. use strict;
  3. #
  4. $|=1;
  5. #
  6. # Setup some variables
  7. my %AGI; my $tests = 0; my $fail = 0; my $pass = 0;
  8. #
  9. #
  10. #Recogemos las cosas que nos pasa asterisk
  11. while() {
  12. last unless length($_);
  13. if (/^agi_(w+):s+(.*)$/) {
  14. $AGI{$1} = $2;
  15. }
  16. }
  17. #
  18. #Ahora unas cuantas variables mas
  19. my $uid     = "$AGI{uniqueid}";
  20. my $ruid     = sprintf("%d", $uid);#%d signed int, %u unsigned int
  21. my $asr_cfg     = "es";
  22. my $lang     = "es";
  23. my $voc_file     = $ARGV[0];
  24. my $gram_type     = $ARGV[1];
  25. my $rectime     = $ARGV[3];
  26. my $vf2t_cmd    = "verbiof2t";
  27. my $result     = 0;
  28. my $basedir     = "/var/lib/asterisk/verbio";
  29. my $vf2tpath     = "/usr/bin";
  30. my $verbiowavedir = "audio";
  31. my $myrecpath     = "$basedir/$verbiowavedir";
  32. my $voc_path     = "$basedir/gram";
  33. my $myrecfile     = "verbio-rec-$ruid";
  34. my $codec     = "alaw";
  35. my $skip     = "0";
  36. my $silence     = $ARGV[3]
  37. my $offset     = "0";
  38. my $voxserver     = "127.0.0.1";
  39. #
  40. #
  41. #Vamos a grabar lo que se dice
  42. print STDERR "Empezamos a grabarn";
  43. print "RECORD FILE  $myrecpath/$myrecfile $codec $stoprec $rectime $offset $playbeep s=$silence n";
  44. my $result = <STDIN> ;
  45. #
  46. #
  47. # Creamos el comando de reconocimiento
  48. my $comando = "/usr/bin/verbiof2t -l $lang -g $voc_path/$voc_file -t $gram_type -f $myrecpath/$myrecfile.$codec -c $codec -d $ruid -s $voxserver -k $skip";
  49. #ahora ejecutamos el comando
  50. system($comando);
  51. my $result = <STDIN> ;
  52. #
  53. open VF2T, "$comando |" or die "Error en ejecucion del cliente verbio";
  54. my $data = ;
  55. my @datax = split(‘:_##_:’, $data);
  56. close VF2T;
  57. #
  58. my $exit_value=$? >>8;
  59. if( $exit_value != 1)
  60. {
  61. print "SET VARIABLE VASR_RESULT \"ERROR\"n";
  62. unlink($myrecpath."/".$myrecfile.".".$codec);
  63. }
  64. #
  65. #
  66. #Quitar espacios de las variables
  67. $datax[0] =~ s/ /_/g;
  68. $datax[1] =~ s/ /_/g;
  69. $datax[2] =~ s/ /_/g;
  70. #
  71. #Redondeo del score
  72. $datax[2] = sprintf("%d", $datax[2]);
  73. #
  74. #Seteamos las variables de asterisk
  75. print "SET VARIABLE VASR_INDEX $datax[0]n";
  76. print "SET VARIABLE VASR_RESULT $datax[1]n";
  77. print "SET VARIABLE VASR_SCORE $datax[2]n";
  78. #
  79. #
  80. print STDERR "ASR terminadon";
  81. #
  82. #borramos ficheros temporales y salimos
  83. unlink($myrecpath."/".$myrecfile.".".$codec);

Se puede ver que el script setea las variables VASR_RESULT con el resultado del ASR y VASR_SCORE con la puntuación obtenida. En el dialplan se comprueba que el resultado no sea ERROR y que la puntuación supere un cierto umbral de fiabilidad para que el ASR se considere correcto.

En este ejemplo hemos usado el tipo de gramática ISOLATED y un fichero de gramática nombres.txt. EL fichero de gramática es muy sencillo: Es un fichero de texto con las salidas del ASR asociadas a las entradas esperadas y separadas mediante un tabulador:

NOMBRES.TXT:

JUAN juan
PEPE pepe

Es importante observar, que sea cual sea la entrada del usuario, Verbio lo interpretará como una de las entradas esperadas y por lo tanto, aunque se diga patata, Verbio nos devolverá JUAN o PEPE. Naturalmente, la puntuación del reconocimiento será menor y podemos dar por inválido el reconocimiento en el dialplan al no haber superado ${UMBRAL}.
El valor de UMBRAL es algo que se ha de estimar después de hacer pruebas, pero un valor de 25-30 para una gramática ISOLATED de este ejemplo es una buena aproximación.
La parte del TTS es casi idéntica a la de ASR: Un script que genera un fichero de audio a partir del texto que se le pasa como parámetro y que lo reproduce.

TTS.agi:

  1. #!/usr/bin/perl
  2. use strict;
  3. #
  4. $|=1;
  5. my %AGI; my $tests = 0; my $fail = 0; my $pass = 0;
  6. #
  7. #
  8. #Recogemos las cosas que nos pasa asterisk
  9. while() {
  10. last unless length($_);
  11. if (/^agi_(w+):s+(.*)$/) {
  12. $AGI{$1} = $2;
  13. }
  14. }
  15. #
  16. #Ahora unas cuantas variables
  17. my $uid = "$AGI{uniqueid}";
  18. my $ruid = sprintf("%d", $uid);
  19. my $language     = $ARGV[0];
  20. my $speaker     = $ARGV[1];
  21. my $text    = $ARGV[2];
  22. my $textfile     = "verbio-tts-$ruid.txt";
  23. my $wavefile     = "verbio-tts-$ruid";
  24. my $result     = 0;
  25. my $basedir         = "/var/lib/asterisk/verbio";
  26. my $verbiowavedir     = "audio";
  27. my $verbiotextdir     = "text";
  28. my $text2filedir     = "/usr/bin";
  29. my $vt2f_cmd        = "verbiot2f";
  30. my $voxserver         = "127.0.0.1";
  31. my $codec         = "alaw";
  32. my $sounddir         = "$basedir/$verbiowavedir";
  33. my $textfiledir     = "$basedir/$verbiotextdir";
  34. #
  35. #
  36. # Vamos a crear un fichero de texto con los parametros que nos pasa el asr por medio de asterisk
  37. open(fileOUT, ">$textfiledir"."/$textfile");
  38. print fileOUT "$text";
  39. close(fileOUT);
  40. #
  41. #Generamos el fichero audio para poder reproducirlo
  42. my $comando = $text2filedir."/$vt2f_cmd -l $language -k $speaker -t $textfiledir/$textfile -f $sounddir/$wavefile -c $codec -d $ruid -s $voxserver";
  43. system($comando);
  44. #
  45. #
  46. my $filetoplay = $sounddir."/".$wavefile;
  47. print "STREAM FILE $filetoplay \"#\"n";
  48. #

Con esto ya tenemos una implementación sencilla de Verbio integrado en Asterisk. Hacer un menú personalizado, mejorar los TTS con el uso de variables y usar diferentes gramáticas es trivial a partir de este punto.

Para terminar con este post sólo queda comentar lo bueno y lo malo de mis primeras experiencias con Verbio y Asterisk.

LO BUENO:

  • Verbio es independiente del locutor y no requiere entrenamiento previo para reconocer voces en un ASR.
  • El reconocimiento tiene muy buen desempeño en ficheros de gramática pequeños.
  • El servicio técnico de Verbio ha sido sencillamente genial en cada llamada que le hemos hecho con dudas y problemas.
  • Desarrollado por empresa catalana, verbio ofrece gramáticas para castellano, euskera, gallego y catalán entre otras.

LO MALO:

  • Las gramáticas buit-in de Verbio no se han comportado tan bien como la ISOLATED. En concreto, la de telefonía, aunque reconoce muy bien el número dado, no devuelve un score fiable.
  • La documentación que viene con Verbio es insuficiente y anticuada.
  • Los paquetes debian que hemos usado eran rpm “alienizados”. Faltaba una librería que hubo que pedir al servicio técnico de Verbio.
  • Verbio no es software libre.

CONCLUSIONES

Por las pruebas que hemos hecho, se puede usar verbio para un IVR controlado por voz o para recoger datos de clientes que llamen para dejarlos (un concurso o una reserva de billetes por ejemplo) siempre y cuando haya una extensión con un operador humano que coja las llamadas fallidas.

Hemos comprobado que muy por encima del error técnico (fallos de reconocimiento o de la centralita) esta el error social: Mucha gente no se siente cómoda hablando con un operador artificial y no hace caso de las instrucciones, por muy sencillas que estas sean; esta gente ha de tener el recurso de poder acceder a un operador humano. Aún no se puede dejar todo en manos de la máquina.

ACTUALIZACIÓN: Ahora ya hay una forma de usar verbio directamente desde dialplan sin necesidad de usar AGIs. En este mismo blog se puede encontrar una entrada al respecto.

Be Sociable, Share!
Leave a comment

6 Comments.

  1. Sobre el tema del TTS.agi:

    ¿Qué tal es la calidad de la voz generada comparada por ejemplo con Festival? a mí me gusta la voz de Festival de Pedro.

    ¿En qué idiomas genera la voz? ¿calidad?

  2. A mi no me gustan nada las voces de festival, ni siquiera las nuevas. Puede que en inglés tengan un desempeño aceptable pero no en castellano.

    Las voces generadas por Verbio me parecen mejores que las de festival en las pruebas que he hecho de TTS.

    Los idiomas dependen de las gramáticas que hayas instalado con verbio, ya que el idioma es un parámetro que le pasas al motor de síntesis cuando lo llamas. Para ver los idiomas disponibles lo mejor es pasarse por la web de Verbio.

  3. Las voces generadas por verbio son de primer nivel, tal como las de loquendo. Festival está todavía bastante lejos de esto.

  4. Había estado buscando un TTS eficiente y que pudiera leer bien las particularidades del español hablado en México, definitivamente Festival no es la opción y Cepstral también esta muy limitado. Probaré Verbio que de primera me ha leído bien Oaxaca, no Oacsaca como lo leen nuestros buenos amigos de la madre patria :-P

    Salu2!!

  5. Olá Amigo, parabéns pelo blog cheio de informação. Nao estou conseguindo fazer funcionar o agi do ASR, teria como me enviar por email o seu arquivo, esse tem alguns erros que encontrei mas nao consegui fazer funcionar
    Muito obrigado

Leave a Reply


[ Ctrl + Enter ]

*

Trackbacks and Pingbacks: