prob_calc.cpp

Intel开发的IPP库的应用实例

   max_len      = F;
   min_len      = M;

   gauss_num    = header.wgtNum;
   if (gauss_num<=0)                      {fclose(fptr_32f); return -1;}
   if (header.fileType&0x0111!=0)         {fclose(fptr_32f); return -1;}

   int ret=Init_Arrays();
   if (ret<0)                             {fclose(fptr_32f); return ret;};

   if (!(exstates  = (File_Mixture*)malloc(sizeof(File_Mixture)*state_number+
      sizeof(float)*(gauss_num*space_dim4+gauss_num*space_dim4+header.trpNum))))
      return -2;
   if ((int)fread((void*)exstates, sizeof(File_Mixture), state_number, fptr_32f)<state_number) {
      fclose(fptr_32f); free(exstates); return -3;
   }
   for (i=0; i<state_number; i++) {
      if (max_gauss<exstates[i].compNum) max_gauss=exstates[i].compNum;
      states[i].compInd=exstates[i].compInd;
      states[i].compNum=exstates[i].compNum;
   }

   means_32f=(float*)(exstates+state_number);
   vars_32f=means_32f+gauss_num*space_dim4;
   trans=vars_32f+gauss_num*space_dim4;

   if ((int)fread((void*)weights, sizeof(float), gauss_num, fptr_32f)<gauss_num) {
      fclose(fptr_32f); free(means_32f); free(exstates); return -3;
   }
   if ((int)fread((void*)means_32f, sizeof(float)*space_dim4, gauss_num, fptr_32f)<gauss_num) {
      fclose(fptr_32f); free(means_32f); free(exstates); return -3;
   }
   if ((int)fread((void*)vars_32f, sizeof(float)*space_dim4, gauss_num, fptr_32f)<gauss_num) {
      fclose(fptr_32f); free(means_32f); free(exstates); return -3;
   }
   if ((int)fread((void*)dets, sizeof(float), gauss_num, fptr_32f)<gauss_num) {
      fclose(fptr_32f); free(means_32f); free(exstates); return -3;
   }
   if ((int)fread((void*)trans, sizeof(float), header.trpNum, fptr_32f)<header.trpNum) {
      fclose(fptr_32f); free(means_32f); free(exstates); return -3;
   }
   fclose(fptr_32f);
   /* Convert means and vars to shorts, use float weights       */
   /* and dets for 16s32f ipp functions                         */
   /* Further pass mean factors to feature producer             */
   /* Raw feature multiplied by factors, then convert to shorts */
   /* Feature normalization and delta calculation in integers   */

   if (!(mul_mean  = ippsMalloc_16s(space_dim4*2)))      return -2;
   if (!(mul_mean_flt  = ippsMalloc_32f(space_dim4*4)))  return -2;
   Normalize_MeanVar(means_32f,vars_32f);

   ippsConvert_32f16s_Sfs(means_32f,means,space_dim4*gauss_num,ippRndNear,-mean_factor);
   ippsConvert_32f16s_Sfs(vars_32f,vars,space_dim4*gauss_num,ippRndNear,-var_factor);
   if (Save_Short_File(file,&header,exstates,weights,means,vars,dets,mul_mean,trans)<0) {
      free(means_32f); free(exstates); return -3;
   }
   free(exstates);

   ippsConvert_32f32s_Sfs((float*)weights,weights,gauss_num,ippRndNear,-prob_factor);
   ippsConvert_32f32s_Sfs((float*)dets,dets,gauss_num,ippRndNear,-prob_factor);
   ippsOutProbPreCalc_32s_I(Weight(0),Det(0),gauss_num);

   ippsMaxOrder_32f(mul_mean_flt,space_dim,&order);
   mul_factor = 15-order;
   ippsConvert_32f16s_Sfs(mul_mean_flt,mul_mean,space_dim,ippRndNear,-mul_factor);

   ready=-1;
   return 0;
}

int Prob_Calc::Init_Calc_Short(char* file, int F, int M) {

   int i,order;
   FILE  *fptr;
   Param_File_Header header;
   File_Mixture *exstates=NULL;

   if (ready!=-2)                                            return -10;

   if (!(fptr=fopen(file, "rb")))                            return -3;
   if (fread((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
      fclose(fptr); return -3;
   }
   if (header.fileType==0) {
      fclose(fptr);
      return Init_Calc(file,F,M);
   }

   state_number = header.mixNum;
   max_gauss    = 1;
   space_dim    = header.vecSize;
   max_len      = F;
   min_len      = M;

   gauss_num    = header.wgtNum;
   if (gauss_num<=0)                          {fclose(fptr); return -1;}
   if (header.fileType!=0x0100)               {fclose(fptr); return -1;}

   int ret=Init_Arrays();
   if (ret<0)                                 {fclose(fptr); return ret;};

   if (!(exstates  = (File_Mixture*)malloc(sizeof(File_Mixture)*state_number)))
      return -2;
   if ((int)fread((void*)exstates, sizeof(File_Mixture), state_number, fptr)<state_number) {
      fclose(fptr); free(exstates); return -1;
   }
   for (i=0; i<state_number; i++) {
      if (max_gauss<exstates[i].compNum) max_gauss=exstates[i].compNum;
      states[i].compInd=exstates[i].compInd;
      states[i].compNum=exstates[i].compNum;
   }
   free(exstates);

   if (!(mul_mean  = ippsMalloc_16s(space_dim4*2)))          return -2;
   if (!(mul_mean_flt  = ippsMalloc_32f(space_dim4*4)))      return -2;

   if ((int)fread((void*)weights, sizeof(float), gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fread((void*)means, sizeof(short)*space_dim4, gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fread((void*)vars, sizeof(short)*space_dim4, gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fread((void*)dets, sizeof(float), gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fread((void*)mul_mean_flt, sizeof(float), space_dim4, fptr)<space_dim4) {
      fclose(fptr); return -3;
   }

   ippsConvert_32f32s_Sfs((float*)weights,weights,gauss_num,ippRndNear,-prob_factor);
   ippsConvert_32f32s_Sfs((float*)dets,dets,gauss_num,ippRndNear,-prob_factor);
   ippsOutProbPreCalc_32s_I(Weight(0),Det(0),gauss_num);

   ippsMaxOrder_32f(mul_mean_flt,space_dim,&order);
   mul_factor = 15-order;
   ippsConvert_32f16s_Sfs(mul_mean_flt,mul_mean,space_dim,ippRndNear,-mul_factor);

   ready=-1;
   return 0;
}

Prob_Calc::~Prob_Calc(void) {
   mean_factor  = 0;
   var_factor   = 0;
   sum_factor   = 0;
   mul_factor   = 0;
   state_number = 0;
   max_gauss    = 0;
   space_dim    = 0;
   gauss_num    = 0;
   max_len      = 0;
   min_len      = 0;
   space_dim4   = 0;
   state_number4= 0;
   gauss_num4   = 0;
   curidx       = 0;
   lastidx      = 0;
   delta_delay  = 0;
   sen_end      = false;
   type         = calcNone;
   if (features) ippsFree(features);
   if (tmp_prob) ippsFree(tmp_prob);
   if (buffer)   ippsFree(buffer);
   if (mul_mean) ippsFree(mul_mean);
   if (mul_mean_flt) ippsFree(mul_mean_flt);
   if (flog)     fclose(flog);
   feat         = NULL;
   buffer       = NULL;
   features     = NULL;
   tmp_prob     = NULL;
   states       = NULL;
   weights      = NULL;
   dets         = NULL;
   means        = NULL;
   vars         = NULL;
   curfeat      = NULL;
   endfeat      = NULL;
   lastfeat     = NULL;
   mul_mean     = NULL;
   mul_mean_flt = NULL;
   tmp_prob     = NULL;
   flog         = NULL;
   ready        = -2;
}

bool Prob_Calc::Attach_Feat(Feat_Calc *f) {
   if (ready!=-1)                                      return false;
   feat=f;
   if (!feat)                                          return false;
   if (!feat->Ready())                                 return false;
   if (feat->Feature_Length()!=space_dim)              return false;

   sen_end     = false;
   curfeat     = features;
   endfeat     = features;
   lastfeat    = features;
   curidx      = 0;
   lastidx     = 0;
   delta_delay = feat->Delta_Delay();

   if (flog)
      feat->Write_LogHeader(flog);

   if (!feat->Set_Scale(mean_factor))                  return false;
// double delta calculated with coeffs 0.1, 0.1 for features without energy
// not for features with energy because delta is done before CMS and VN
   if (!feat->Var_Norm()) {
      ippsCopy_16s(mul_mean,mul_mean+space_dim4,space_dim);
      ippsMulC_16s_ISfs(((1<<mul_factor)+5)/10,mul_mean+space_dim4+space_dim/3,space_dim/3,
         mul_factor);
      ippsMulC_16s_ISfs(((1<<mul_factor)+50)/100,mul_mean+space_dim4+space_dim/3+space_dim/3,space_dim/3,
         mul_factor);
      int order,diff;
      // enhance precision
      ippsMaxOrder_16s(mul_mean+space_dim4,space_dim,&order);
      if (order>=14) {
         ippsCopy_16s(mul_mean+space_dim4,mul_mean,space_dim);
      } else {
         diff=14-order;
         mul_factor+=diff;
         ippsMulC_16s_ISfs(((1<<mul_factor)+5)/10,mul_mean+space_dim/3,space_dim/3,
            mul_factor-diff);
         ippsMulC_16s_ISfs(((1<<mul_factor)+50)/100,mul_mean+space_dim/3+space_dim/3,space_dim/3,
            mul_factor-diff);
         ippsLShiftC_16s_I(diff,mul_mean,space_dim/3);
      }
   }
   if (!feat->Set_Delta(mul_mean,mul_factor))                     return false;

   ready       = 0;
   return true;
}

bool Prob_Calc::Detach_Feat(void) {
   if (ready!=0)                                       return false;
   sen_end=true;
   feat=NULL;
   curfeat=NULL;
   endfeat=NULL;
   lastfeat=NULL;
   curidx=0;
   lastidx=0;
   delta_delay=0;
   ready=-1;
   if (flog)
      fclose(flog);
   flog=NULL;
   return true;
}

bool Prob_Calc::Step_Forward(void) {
   if (ready!=0)                                       return false;
   curfeat+=space_dim4;
   curidx++;
   if ((sen_end)&&(lastidx==curidx)) {
      return false;
   } else if (curidx>=max_len-min_len-delta_delay) {  //  switch to buffer beginning
      ippsCopy_16s(curfeat,features,lastfeat-curfeat+delta_delay*space_dim4);
      lastfeat=features+(lastfeat-curfeat);
      lastidx=lastidx-curidx;
      curfeat=features;
      curidx=0;
   }
   return true;
}

int Prob_Calc::Obv_Prob_Vec(int state, int *result, int len) {
   int m,num;
   if (ready!=0)                                       return -1;
   if (!sen_end) {
      if (lastidx-curidx<min_len) {
         num=feat->Get_Feature(lastfeat,max_len-lastidx,&sen_end);
         if (flog) {
            float *buf=mul_mean_flt+space_dim4;
            for (m=0; m<num; m++) {
               ippsConvert_16s32f_Sfs(lastfeat+m*space_dim4,buf,space_dim,mean_factor);
               ippsDiv_32f_I(mul_mean_flt,buf,space_dim);
               fwrite((void*)buf, sizeof(float), space_dim, flog);
            }
         }
         // here wait if num==0 if features are consumed faster
         lastidx+=num;
         lastfeat+=num*space_dim4;
      }
   }

   num=lastidx-curidx;
   if (len<num) num=len;

   short *mean=Mean(state);
   short *var=Var(state);
   int *det=Det(state);
   short *feat=curfeat;


   switch (type) {
   case calcVect:
       ippsLogGauss_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
         det[0],sum_factor-prob_factor);
      for (m=1; m<states[state].compNum; m++) {
         mean+=space_dim4;
         var+=space_dim4;
         ippsLogGauss_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,tmp_prob,num,
            det[m],sum_factor-prob_factor);
         ippsLogAdd_32s_Sfs(tmp_prob,result,num,prob_factor,ippAlgHintNone);
      }
      break;
   case calcVecM:
      ippsLogGauss_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
              det[0],sum_factor-prob_factor);
      for (m=1; m<states[state].compNum; m++) {
         mean+=space_dim4;
         var+=space_dim4;
         ippsLogGaussMax_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
            det[m],sum_factor-prob_factor);
      }
      break;
   case calcMMix:
   case calcMix:

       for (m=0; m<num; m++) {
         ippsCopy_32f((float*)det,(float*)tmp_prob,states[state].compNum);
         ippsLogGaussMultiMix_16s32s_D2Sfs(mean,var,space_dim4,feat,space_dim,
            tmp_prob,states[state].compNum,sum_factor-prob_factor);
         ippsLogSum_32s_Sfs(tmp_prob,result+m,states[state].compNum,prob_factor,ippAlgHintNone);
         feat+=space_dim4;
       }
      break;
   case calcVectLow:
      ippsLogGauss_Low_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
         det[0],sum_factor-prob_factor);
      for (m=1; m<states[state].compNum; m++) {
         mean+=space_dim4;
         var+=space_dim4;
         ippsLogGauss_Low_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,tmp_prob,num,
            det[m],sum_factor-prob_factor);
         ippsLogAdd_32s_Sfs(tmp_prob,result,num,prob_factor,ippAlgHintNone);
      }
      break;
   case calcVecMLow:
      ippsLogGauss_Low_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
              det[0],sum_factor-prob_factor);
      for (m=1; m<states[state].compNum; m++) {
         mean+=space_dim4;
         var+=space_dim4;
         ippsLogGaussMax_Low_16s32s_D2Sfs(curfeat,space_dim4,mean,var,space_dim,result,num,
            det[m],sum_factor-prob_factor);
      }
      break;
   case calcMMixLow:
   case calcMixLow:
       for (m=0; m<num; m++) {
         ippsCopy_32f((float*)det,(float*)tmp_prob,states[state].compNum);
         ippsLogGaussMultiMix_Low_16s32s_D2Sfs(mean,var,space_dim4,feat,space_dim,
            tmp_prob,states[state].compNum,sum_factor-prob_factor);
         ippsLogSum_32s_Sfs(tmp_prob,result+m,states[state].compNum,prob_factor,ippAlgHintNone);
         feat+=space_dim4;
       }

       break;
   case calcNone:
      fake_sum=det[0];
      for (m=0; m<space_dim4*states[state].compNum; m+=8)
         fake_sum+=mean[m];
      for (m=0; m<space_dim4*states[state].compNum; m+=8)
         fake_sum+=var[m];
      for (m=0; m<space_dim4*num; m+=8)
         fake_sum+=curfeat[m];
      break;
   default:
      return -1;
   }

   return num;
}