Skip to main content.

Archive for Mayo, 2007

Integración de Verbio en Asterisk

Miércoles, Mayo 23rd, 2007

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

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

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.

Posted in AGI, ASR, Asterisk, TTS, Teléfonos IP, Verbio | 4 Comments »

2005 © Irontec S.L. :: Powered by Irontec & Wordpress
[ IRONTEC S.L. - C.I.F. B-95274890 ]
[ Ctra. Basurto-Kastrexana nº70 / Enpresaldea ]
[ 48002 - Bilbao - Bizkaia ]