voice_recognition_alg.cpp

Go to the documentation of this file.

#include "voice_recognition_alg.h"

static const arg_module_t online_module = {NULL, "General options",
    {
      {"save-lattices", ARG_BOOL, "false", 0, "Enables saving lattices"},
      {"lattice-directory", ARG_DIR, NULL, 0, "Directory where lattices will be saved"},
      {"print-time", ARG_BOOL, "false", 0, "Print realtime factor"},
      {"print-score", ARG_BOOL, "false", 0, "Print hypothesis score"},
      {"verbosity", ARG_INT, "0", 0, "Set verbosity level"},
      {"statistics-verbosity", ARG_INT, "0", 0, "Set statistics verbosity level"},
      {"print-default", ARG_BOOL, "false", 0, "Print default config file"},
      {"print-config", ARG_BOOL, "false", 0, "Print final config file"},
      {"preprocess-config", ARG_STRING, NULL, 0, "Preprocess config file"},
      {NULL, ARG_END_MODULE, NULL, 0, NULL}
    }
};

static const arg_shortcut_t shortcuts[] = {
    {"v", "verbosity"},
    {"s", "statistics-verbosity"},
    {"p", "preprocess-config"},
    {"t", "print-time"},
    {"d", "print-default"},
    {"l", "decoder.grammar-scale-factor"},
    {"w", "decoder.word-insertion-penalty"},
    {NULL, NULL}
};

VoiceRecognitionAlgorithm::VoiceRecognitionAlgorithm(void)
{
}

VoiceRecognitionAlgorithm::~VoiceRecognitionAlgorithm(void)
{
}

void VoiceRecognitionAlgorithm::config_update(Config& new_cfg, uint32_t level)
{
  this->lock();

  // save the current configuration
  this->config_=new_cfg;
  
  this->unlock();
}

// VoiceRecognitionAlgorithm Public API

void VoiceRecognitionAlgorithm::initialize()
{
  this->answerCode_=0;
  
  std::string conf1;
  std::string conf2;
  
  conf1=filePath_ + "/hcu_notask.cnf";
  conf2=filePath_ + "/conf.feat";
  
  char *argv[] = {"iatros", "-c", conf1.c_str(), "-p", conf2.c_str(), NULL};
  int argc = sizeof(argv) / sizeof(char*) - 1;
  
  arg_error_t aerr = ARG_OK;

  args = args_create();
  args_set_summary(args, "Online speech text recognizer");
  args_set_doc(args, "For more info see http://prhlt.iti.es");
  args_set_version(args, IATROS_SPEECH_PROJECT_STRING"\n"IATROS_SPEECH_BUILD_INFO"\n\n"
                         IATROS_PROJECT_STRING"\n"IATROS_BUILD_INFO);
  args_set_bug_report(args, "Report bugs to "IATROS_SPEECH_PROJECT_BUGREPORT".");
  args_add_module(args, &online_module);
  args_add_module(args, &decoder_module);
  args_add_module(args, &lattice_module);
  args_add_shortcuts(args, shortcuts);

  args_parse_command_line(args, argc, argv);


  if (args_get_bool(args, "print-default", &aerr))
  {
    args_write_default_config_file(args, stdout);
    args_delete(args);
    //return EXIT_SUCCESS;
  }

  if (args_get_bool(args, "print-config", &aerr))
  {
    args_dump(args, stderr);
  }


  SET_STATISTICS_VERBOSITY(args_get_int(args, "statistics-verbosity", &aerr));

  INIT_TRACE(args_get_int(args, "verbosity", &aerr));

  const char *prep_conf_filename = args_get_string(args, "preprocess-config", &aerr);
  REQUIRE(aerr == ARG_OK && prep_conf_filename != NULL, "Preprocess config file is missing");

  //Load all models
  decoder = decoder_create_from_args(args);

  acquisitor = acquisitor_create_from_file(prep_conf_filename);
  
}

void VoiceRecognitionAlgorithm::finalize()
{
  decoder_delete(decoder);
  acquisitor_delete(acquisitor);
  args_delete(args); 
}

void VoiceRecognitionAlgorithm::setFilePath(std::string path)
{
  filePath_=path;
}

std::string VoiceRecognitionAlgorithm::iteration()
{  
    //acquisitor_start(acquisitor);
    
    std::string generatedAnswer_;
    search_t *search = search_create(decoder);
    lattice_t *lattice = lattice_create_from_args(args, decoder);

    clock_t tim = clock();
    decode_online(search, acquisitor, lattice);

    clock_t tim2 = clock();
    printf("time %f\n", ((float) ((tim2 - tim) / CLOCKS_PER_SEC) / search->n_frames) / 0.01);
    fflush(stdout);

    generatedAnswer_ = outputs(args, lattice);

    lattice_delete(lattice);
    search_delete(search);

    acquisitor_clear(acquisitor);

    return generatedAnswer_;
}

std::string VoiceRecognitionAlgorithm::answer_type(std::string answerfn)
{
  FILE *f;
  char aux[2048];
  int n, r, i;
  
  answerfn = filePath_ + "/" + answerfn;
  
  std::cout <<"answer_type: "<< answerfn << std::endl;

  f=fopen(answerfn.c_str(),"r");
  if (f==NULL)
    return "Se me han frito los circuitos!!!"; //error

  n=0;
  while (fgets(aux,2047,f)!=NULL)
    n++;

  fclose(f);

  r=rand()%n;

  f=fopen(answerfn.c_str(),"r");
  for (i=0;i<r;i++)
    fgets(aux,2047,f);
  fclose(f);

  return std::string(aux); //error
}

std::string VoiceRecognitionAlgorithm::answer_type_location(std::string answerfn, std::string loc)
{
  FILE *f;
  char aux[2048];
  char *auxloc; //std::string auxloc;
  int n, r, i;
  
  answerfn = filePath_ + "/" + answerfn;
  
  std::cout <<"answer_type_location: "<< answerfn << std::endl;

  /* To avoid problems with common prefixes */
  auxloc=(char *) malloc((strlen(loc.c_str())+2)*sizeof(char));
  strcpy(auxloc,loc.c_str());
  auxloc[strlen(auxloc)+1]='\0';
  auxloc[strlen(auxloc)]='#';

  f=fopen(answerfn.c_str(),"r");
  if (f==NULL)
    return "Se me han frito los circuitos!!!";

  n=0;
  while (fgets(aux,2047,f)!=NULL) 
    if (!strncmp(aux,auxloc,strlen(auxloc)))
      n++;

  fclose(f);

  r=rand()%n+1;

  f=fopen(answerfn.c_str(),"r");
  i=0;
  while (i<r)
  {
    fgets(aux,2047,f);
    if (!strncmp(aux,auxloc,strlen(auxloc))) 
      i++;
  }
  fclose(f);

  return std::string(aux+strlen(loc.c_str())+1);
}

std::string VoiceRecognitionAlgorithm::generate_answer(double *probs, char **sentences_str, int n) 
{
  int i, j, k, classs, nb=0, nc=0;
  int classv[NCLASSES];
  double classp[NCLASSES];
  char **build;
  char **classrooms;
  int *buildc, *classroomsc;
  char *auxloc;
  int loccode;
  std::string auxstring;
  this->answerCode_=0;
  
  std::string currentAnswer;
  
  build=(char **) malloc(n*sizeof(char *));
  classrooms=(char **) malloc(n*sizeof(char *));
  
  for (i=0;i<n;i++)
  {
    build[i]=NULL; classrooms[i]=NULL;
  }

  for (i=0;i<NCLASSES;i++)
  { 
    classv[i]=0; classp[i]=0.0;
  }
  
  for (i=0;i<n;i++)
  {
    /* printf("REC%d->%s\n",i,sentences_str[i]); */
    if (sentences_str[i]!=NULL)
    {
      classs=NONE;
      for (j=0;j<strlen(sentences_str[i]);j++)
      {
        if (!strncmp("padre",sentences_str[i]+j,5)) classs=AUTORES;
        if (!strncmp("madre",sentences_str[i]+j,5)) classs=AUTORES;
        if (!strncmp("dise~n",sentences_str[i]+j,6)) classs=AUTORES;
        if (!strncmp("creo",sentences_str[i]+j,4)) classs=AUTORES;
        if (!strncmp("creado",sentences_str[i]+j,6)) classs=AUTORES;
        if (!strncmp("hizo",sentences_str[i]+j,4)) classs=AUTORES;
        if (!strncmp("hecho",sentences_str[i]+j,5)) classs=AUTORES;
        if (!strncmp("constru",sentences_str[i]+j,7)) classs=AUTORES;
  
        if (!strncmp("hacer",sentences_str[i]+j,5)) classs=HABILIDADES;
        if (!strncmp("dedicas",sentences_str[i]+j,7)) classs=HABILIDADES;

        if (!strncmp("nombre",sentences_str[i]+j,6)) classs=IDENTIFICACION;
        if (!strncmp("llamas",sentences_str[i]+j,6)) classs=IDENTIFICACION;
        if (!strncmp("quien eres",sentences_str[i]+j,10)) classs=IDENTIFICACION;

        if (!strncmp("donde estamos",sentences_str[i]+j,13)) classs=LUGAR;

        if (!strncmp("proyecto",sentences_str[i]+j,8)) classs=OTROS_PROYECTOS;
        if (!strncmp("investiga",sentences_str[i]+j,9)) classs=OTROS_PROYECTOS;
        if (!strncmp("realiza",sentences_str[i]+j,7)) classs=OTROS_PROYECTOS;
        if (!strncmp("cosas",sentences_str[i]+j,5)) classs=OTROS_PROYECTOS;

        if (!strncmp("familia",sentences_str[i]+j,7)) classs=OTROS_ROBOTS;
        if (!strncmp("herman",sentences_str[i]+j,6)) classs=OTROS_ROBOTS;
        if (!strncmp("otros",sentences_str[i]+j,5)) classs=OTROS_ROBOTS;
        if (!strncmp("otras",sentences_str[i]+j,5)) classs=OTROS_ROBOTS;
        if (!strncmp("conoces",sentences_str[i]+j,7)) classs=OTROS_ROBOTS;
  
        if (!strncmp("vives",sentences_str[i]+j,5)) classs=ZONA;
        if (!strncmp("trabajas",sentences_str[i]+j,8)) classs=ZONA;
        if (!strncmp("habitas",sentences_str[i]+j,7)) classs=ZONA;

        if (!strncmp("EDIF#",sentences_str[i]+j,5))
        {
          build[nb]=(char *) malloc((strlen(sentences_str[i]+j+5)+1)*sizeof(char));
          strcpy(build[nb],sentences_str[i]+j+5);
          k=0; 
          while (build[nb][k]!=' ' && build[nb][k]!='\0') 
            k++; 
          build[nb][k]='\0';
          nb++;
          classs=EDIF;
        }
        if (!strncmp("AUL#",sentences_str[i]+j,4))
        {
          classrooms[nc]=(char *) malloc((strlen(sentences_str[i]+j+4)+1)*sizeof(char));
          strcpy(classrooms[nc],sentences_str[i]+j+4);
          k=0; 
          while (classrooms[nc][k]!=' ' && classrooms[nc][k]!='\0')
            k++; 
          classrooms[nc][k]='\0';
          nc++;
          classs=AUL;
        }        
      }
      classv[classs]++;
      classp[classs]+=probs[i];
    }
  }
  /* for (j=0;j<nb;j++) printf("%s\n",build[j]); */
  /* for (j=0;j<nc;j++) printf("%s\n",classrooms[j]); */
  for (j=0;j<NCLASSES;j++)
    if (classv[j]>0)
      classp[j]=classp[j]/classv[j];
  /* for (j=0;j<NCLASSES;j++) printf("%f ",classp[j]); printf("\n"); */
  classs=0;
  for (j=1;j<NCLASSES;j++) 
  {
    if (classp[j]!=0.0 && (classp[classs]<classp[j] || classp[classs]==0.0) )
    {
      classs=j;
    }
  }

  switch(classs)
  {
    case NONE:
      this->answerCode_ = 10;
      return answer_type("answers/NONE.txt");
      break;
    case AUTORES:
      this->answerCode_ = 11;
      return answer_type("answers/AUTORES.txt");
      break;
    case HABILIDADES:
      this->answerCode_ = 12;
      return answer_type("answers/HABILIDADES.txt");
      break;
    case IDENTIFICACION:
      this->answerCode_ = 13;
      return answer_type("answers/IDENTIFICACION.txt");
      break;
    case LUGAR:
      this->answerCode_ = 14;
      return answer_type("answers/LUGAR.txt");
      break;
    case OTROS_PROYECTOS:
      this->answerCode_ = 15;
      return answer_type("answers/OTROS_PROYECTOS.txt");
      break;
    case OTROS_ROBOTS:
      this->answerCode_ = 16;
      return answer_type("answers/OTROS_ROBOTS.txt");
      break;
    case ZONA:
      this->answerCode_ = 17;
      return answer_type("answers/ZONA.txt");
      break;
    case EDIF:
      /* Calculate which is the building */
      buildc=(int *) malloc(nb*sizeof(int));
      for (j=0;j<nb;j++)
      {
        buildc[j]=0;
        for (k=j;k<nb;k++)
          if (!strcmp(build[j],build[k])) 
            buildc[j]++;
      }
      k=0;
      for (j=1;j<nb;j++)
        if (buildc[j]>buildc[k])
          k=j;
      auxstring = answer_type_location("answers/EDIF.txt", build[k]).c_str();
      auxloc = auxstring.c_str();
      currentAnswer.clear();
      j=0;
      while (auxloc[j]!='\0' && auxloc[j]!='#') 
      { 
        //putchar(auxloc[j]);
        currentAnswer+=auxloc[j];
        j++;
      }
      if (auxloc[j]=='#') 
        loccode=atoi(auxloc+j+1);
      else loccode=0;
      
      //printf(" MAPCODE = %d\n",loccode);
      this->answerCode_=loccode;
      std::cout << "!!! mapCode: " << this->answerCode_ << std::endl;
      free(buildc);
      return currentAnswer;
      break;
    case AUL:
      /* Calculate which is the building */
      classroomsc=(int *) malloc(nc*sizeof(int));
      for (j=0;j<nc;j++)
      {
        classroomsc[j]=0;
        for (k=j;k<nc;k++)
          if (!strcmp(classrooms[j],classrooms[k]))
            classroomsc[j]++;
      }
      k=0;
      for (j=1;j<nc;j++)
        if (classroomsc[j]>classroomsc[k])
          k=j;
      auxstring=answer_type_location("answers/AUL.txt", classrooms[k]).c_str();
      auxloc = auxstring.c_str();
      currentAnswer.clear();
      j=0;
      while (auxloc[j]!='\0' && auxloc[j]!='#')
      {
        //putchar(auxloc[j]);
        currentAnswer+=auxloc[j];
        j++;        
      }
      if (auxloc[j]=='#')
        loccode=atoi(auxloc+j+1);
      else loccode=0;
      
      //printf(" MAPCODE = %d\n",loccode);
      this->answerCode_=loccode;
      free(classroomsc);
      return currentAnswer;
      break;
    default:
      this->answerCode_ = 1000;
      return answer_type("answers/NONE.txt");
  }
}

std::string VoiceRecognitionAlgorithm::outputs(const args_t *args, lattice_t *lattice)
{
  std::string generatedAnswer_;
  int i, n=lattice->nbest/3;
  symbol_t **sentences;
  double *probs;
  char **sentences_str;

  if (n==0) n=1;

  //Word_graph
  if (args_get_bool(args, "save-lattices", NULL))
  {
    char filename[MAX_LINE];
    char path[MAX_LINE];

    time_t tm = time(NULL);
    strftime(filename, sizeof(filename), "%y-%m-%d_%M:%S", localtime(&tm));
    sprintf(filename, "%s_%d_PID%d", filename, (int)clock(), getpid());

    char const *lattices_dn = args_get_string(args, "lattice-directory", NULL);
    if (lattices_dn == NULL) lattices_dn = ".";
    printf("The word_graph is in %s/%s.lat.gz\n", lattices_dn, filename);

    //Name of file with word_graph
    sprintf(path, "%s/%s.lat.gz", lattices_dn, filename);
    FILE *lattice_file = gzopen(path, "w");
    REQUIRE(lattice_file != NULL, "Couldn't open lattice file '%s'\n", path);
    lattice_write(lattice, lattice_file, path);
    gzclose(lattice_file);
  }

  //Best hypothesis
  lattice_nbest_hyp(lattice, n, &sentences, &probs);
  sentences_str=(char **) malloc(n*sizeof(char *));
  if (sentences[0] != NULL)
  {
    for (i=0;i<n;i++)
    {
      if (sentences[i]!=NULL)
      {
        sentences_str[i] = NULL;
        extended_vocab_symbols_to_string(sentences[i], lattice->decoder->vocab, &(sentences_str[i]));
        /* if (sentences_str[i]!=NULL) printf("%f %s\n", probs[i], sentences_str[i]); */
        /* printf("%s\n", sentence_str); */
      }
      else sentences_str[i] = NULL;
    }

    generatedAnswer_ = generate_answer(probs,sentences_str, n);
    for (i=0;i<n;i++)
    {
      free(sentences[i]);
      free(sentences_str[i]);
    }
    free(probs);
  }
  else
  {
    printf("Sentence not recognized\n");
    fflush(stdout);
  }
  return generatedAnswer_;
  //XXX: playSound(acquisitor->hrwParam, acquisitor->record);
}