Integración de Verbio en Asterisk II

VerbioEn uno de los últimos post de este blog hablábamos sobre la integración del motor de ASR y TTS Verbio en nuestra centralita Asterisk. La gente de Verbio y Avanzada7 han desarrollado nuevas aplicaciones para poder usar el motor de Verbio directamente desde el dialplan sin necesidad de usar AGI.

Estas aplicaciones están disponibles aquí. Además de las aplicaciones podemos encontrar una documentación muy clara sobre cómo instalar y cómo hacer pruebas, además de unos ejemplos. No voy a hacer un howto ya que todo esta perfectamente explicado en la documentación y sería redundante.

Llevo unos días probando esta nueva forma de usar verbio directamente desde el dialplan y por ahora tengo buenas vibraciones. Hay algunas diferencias sobre la forma antigua basada en AGI, la mayoría buenas:

  • La detección de silencio la hace Asterisk y no Verbio. Podemos configurar VAD para afinar aún mejor la detección.
  • Podemos lanzar simultáneamente un ASR y un TTS.
  • La opción bargein nos permite cancelar la locución durante un ASR cuando detectamos voz.
  • Tenemos la posibilidad de detectar tonos DTMF durante un ASR y dar así la opción al usuario de responder usando la voz o usando las teclas.
  • Tenemos opción de usar modo verbose para depurar la detección en cada canal. El demonio de verbio no ofrece debug cuando se ejecuta desde una consola. En este caso declara variables de control que nos permite controlar el flujo en el dialplan en caso de que haya errores.
  • El motor de verbio debe estar corriendo cuando se inicia Asterisk o éste dará error y no arrancará.

En general me parece un gran salto hacia delante en el reconocimiento de voz para los usuarios de Asterisk y apertura de mercado para Verbio. Buenas noticias para todos.

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.