prob_calc.cpp

Intel开发的IPP库的应用实例

/*
//
//                  INTEL CORPORATION PROPRIETARY INFORMATION
//     This software is supplied under the terms of a license agreement or
//     nondisclosure agreement with Intel Corporation and may not be copied
//     or disclosed except in accordance with the terms of that agreement.
//          Copyright(c) 1999-2006 Intel Corporation. All Rights Reserved.
//
//     Intel(R) Integrated Performance Primitives Gaussian Mixture Sample for Windows*
//
//  By downloading and installing this sample, you hereby agree that the
//  accompanying Materials are being provided to you under the terms and
//  conditions of the End User License Agreement for the Intel(R) Integrated
//  Performance Primitives product previously accepted by you. Please refer
//  to the file ippEULA.rtf located in the root directory of your Intel(R) IPP
//  product installation for more information.
//
//
//     Gaussian Mixture Calculation Class
//
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ipps.h>
#include <ippsr.h>

#include "prob_calc.h"
#include "feat_calc.h"

struct Param_File_Header{
   int vecSize;                    // feature vector size
   unsigned short maxComp;         // maximum component number in mixture
   unsigned short fileType;        // mixture parameter file type
   int mixNum;                     // number of Gaussian mixtures
   int wgtNum;                     // total number of weights
   int gaussNum;                   // total number of Gaussians
   int trpNum;                     // total number of transition values
};

struct File_Mixture{
   int compNum;                     // component number
   int wgtInd;                      // compInd of the first weight
   int compInd;                     // compInd of the first component
};

/////////////////////////////////////////////////////////////
//                                                         //
//       Mixture parameter file structure                  //
//                                                         //
//       Param_File_Header header;                         //
//       File_Mixture exstates[header.mixNum]              //
//       float weights[wgtNum]                             //
//       float means_32f[wgtNum*((vecSize+3)&(-3))]        //
//       float vars_32f[wgtNum*((vecSize+3)&(-3))]         //
//       float dets[wgtNum]                                //
//       float trpdets[trpNum]                             //
//                                                         //
//                                                         //
//       Short mixture parameter file structure            //
//                                                         //
//       Param_File_Header header;                         //
//       File_Mixture exstates[header.mixNum]              //
//       float weights[wgtNum]                             //
//       short means_32f[wgtNum*((vecSize+3)&(-3))]        //
//       short vars_32f[wgtNum*((vecSize+3)&(-3))]         //
//       float dets[wgtNum]                                //
//       float mul_mean[(vecSize+3)&(-3)]                  //
//       float trpdets[trpNum]                             //
//                                                         //
/////////////////////////////////////////////////////////////

Prob_Calc::Prob_Calc(int mf, int vf, Calc_Hint hint) {
   mean_factor  = mf;
   var_factor   = vf;
   sum_factor   = mean_factor+mean_factor+var_factor;
   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         = hint;
   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;
   flog         = NULL;
   ready        = -2;
}

int Prob_Calc::Init_Arrays(void) {
   int model_len=0;
   if ((type!=calcNone)&&(type!=calcVect)&&(type!=calcVecM)&&(type!=calcMix)&&(type!=calcMMix)&&
       (type!=calcVectLow)&&(type!=calcVecMLow)&&(type!=calcMixLow)&&(type!=calcMMixLow))
                                return -1;
   if (state_number<=0)         return -1;
   if (max_gauss<=0)            return -1;
   if (space_dim<=0)            return -1;
   if (max_len<=0)              return -1;
   if (min_len<=0)              return -1;
   if (max_len<100)             max_len=100;
   if (min_len<12)              min_len=12;
   if (min_len>(max_len>>3))    min_len=(max_len>>3);
   space_dim4=(space_dim+3)&(~3);
   state_number4=(state_number+3)&(~3);
   gauss_num4=(gauss_num+3)&(~3);
   model_len=sizeof(Mixture)*state_number4+sizeof(float)*(gauss_num4+gauss_num4)+
             sizeof(short)*(gauss_num*space_dim4+gauss_num*space_dim4);

   if (!(features  = ippsMalloc_16s(space_dim4*max_len)))   return -2;

   int tmp_len=(max_gauss>max_len)?max_gauss:max_len;
   if (!(tmp_prob  = ippsMalloc_32f(tmp_len)))              return -2;

   if (!(buffer    = (void*)ippsMalloc_8u(model_len)))      return -2;

   states      = (Mixture*)buffer;
   weights     = (float*)(states+state_number4);
   dets        = weights+gauss_num4;
   means = (short*)(dets+gauss_num4);
   vars  = means+gauss_num*space_dim4;

   return 0;
}

int Prob_Calc::Init_LogFile(char *feat_log) {

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

   if (!feat_log) {
      flog=NULL;
   } else if (!feat_log[0]) {
      flog=NULL;
   } else {
      if (!(flog=fopen(feat_log, "wb")))                           return -3;
   }
   return 0;
}

int Prob_Calc::Init_Calc(int N, int G, int L, int F, int M) {

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

   state_number = N;
   max_gauss    = G;
   space_dim    = L;
   max_len      = F;
   min_len      = M;
   gauss_num    = state_number*max_gauss;

   int ret=Init_Arrays();
   if (ret<0) return ret;

   for (int i=0; i<state_number; i++) {
      states[i].compInd=i*max_gauss;
      states[i].compNum=max_gauss;
   }

   if (!(mul_mean  = ippsMalloc_32f(space_dim4*2)))         return -2;
   ippsSet_32f(1.0f,mul_mean,space_dim4);

   ippsSet_32f(1.0f/(float)max_gauss,weights,state_number);
   ippsSet_32f((float)space_dim,dets,state_number);
   ippsSet_16s((short)0,means,state_number*space_dim4);
   ippsSet_16s((short)(1<<var_factor),vars,state_number*space_dim4);
   ippsOutProbPreCalc_32f_I(Weight(0),Det(0),gauss_num);

   ready=-1;
   return 0;
}

void Prob_Calc::Normalize_MeanVar(float *means_32f, float *vars_32f) {

   int i;
   float *avr_mean, *mul_var, *avr_var;
   avr_mean = mul_mean+space_dim4;
   mul_var  = avr_mean+space_dim4;
   avr_var  = mul_var +space_dim4;

   /* normalize means_32f and vars_32f and convert to shorts */
   ippsMeanColumn_32f_D2(vars_32f,gauss_num,space_dim4,avr_var,space_dim);
   ippsSet_32f(1.0f,mul_var,space_dim4);
   ippsSet_32f(1.0f,mul_mean,space_dim4);
   for (i=0; i<space_dim; i++) {
      if (avr_var[i]>2.0f) while (avr_var[i]>2.0f) {
            avr_var[i]*=0.25f;
            mul_var[i]*=0.25f;
            mul_mean[i]*=2.0f;
      } else while (avr_var[i]<=0.25f) {
            avr_var[i]*=4.0f;
            mul_var[i]*=4.0f;
            mul_mean[i]*=0.5f;
      }
   }
   for (i=0; i<gauss_num; i++) {
      ippsMul_32f_I(mul_mean,means_32f+i*space_dim4,space_dim4);
      ippsMul_32f_I(mul_var,vars_32f+i*space_dim4,space_dim4);
   }
}

int Prob_Calc::Save_Short_File(char *file, void *header, void *exstates, void *weights, void *means,
                               void *vars, void *dets, void *mul_mean, void *trans) {

// create param file with short normalized means_32f and vars_32f

   FILE  *fptr;
   Param_File_Header *head=(Param_File_Header*)header;

   int lname=(int)strlen(file);
   char *short_file=(char*)malloc(lname+10);
   strcpy(short_file,file);
   strcat(short_file,"_16s");

   if (!(fptr=fopen(short_file, "wb"))) {
      free(short_file); return -3;
   }
   free(short_file);
   head->fileType|=0x0100;
   if ((int)fwrite((void*)header, sizeof(Param_File_Header), 1, fptr)<1) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)exstates, sizeof(File_Mixture), state_number, fptr)<state_number) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)weights, sizeof(float), gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)means, sizeof(short)*space_dim4, gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)vars, sizeof(short)*space_dim4, gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)dets, sizeof(float), gauss_num, fptr)<gauss_num) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)mul_mean, sizeof(float), space_dim4, fptr)<space_dim4) {
      fclose(fptr); return -3;
   }
   if ((int)fwrite((void*)trans, sizeof(float), head->trpNum, fptr)<head->trpNum) {
      fclose(fptr); return -3;
   }
   fclose(fptr);
   return 0;
}

static FILE* create_param_file(char *file, int stateNum, int maxComp, int vecSize, int trpNum) {
   Param_File_Header header;
   FILE *fptr=NULL;
   int i;
   if (!(fptr=fopen(file, "wb")))  return fptr;
   header.vecSize=vecSize;
   header.maxComp=3;
   header.fileType=0;
   header.mixNum=stateNum;
   header.wgtNum=stateNum*maxComp;
   header.gaussNum=stateNum*maxComp;
   header.trpNum=trpNum;
   if (fwrite((void*)(&header), sizeof(Param_File_Header), 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   File_Mixture *states=(File_Mixture*)calloc(sizeof(File_Mixture),header.mixNum);
   if (!states) {
      fclose(fptr); return fptr;
   }
   for (i=0; i<header.mixNum; i++) {
       states[i].compNum=maxComp;
       states[i].wgtInd=maxComp*i;
       states[i].compInd=maxComp*i;
   }
   if (fwrite((void*)(states), sizeof(File_Mixture), header.mixNum, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(states);
   float *weights=(float*)calloc(sizeof(float),header.wgtNum);
   for (i=0; i<header.mixNum; i++) {
//       weights[i]=(float)log(1.0/maxComp);
       weights[i]=-1.0f-((float)(rand())/(float)RAND_MAX); // -2.0 ... -1.0
   }
   if (fwrite((void*)(weights), sizeof(float)*header.wgtNum, 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(weights);
   float *means=(float*)calloc(sizeof(float),header.gaussNum*((header.vecSize+3)&(-3)));
   for (i=0; i<stateNum*((header.vecSize+3)&(-3)); i++) {
//       means[i]=0.0f;
       means[i]=-4.0f+((float)(rand())*8.0f/(float)RAND_MAX); // -4.0 ... 4.0
   }
   if (fwrite((void*)(means), sizeof(float)*header.gaussNum*((header.vecSize+3)&(-3)), 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(means);
   float *vars=(float*)calloc(sizeof(float),header.gaussNum*((header.vecSize+3)&(-3)));
   for (i=0; i<stateNum*((header.vecSize+3)&(-3)); i++) {
//       vars[i]=1.0f;
       vars[i]=0.1f+((float)(rand())*0.4f/(float)RAND_MAX); // 0.1 ... 0.5
   }
   if (fwrite((void*)(vars), sizeof(float)*header.gaussNum*((header.vecSize+3)&(-3)), 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(vars);
   float *dets=(float*)calloc(sizeof(float),header.gaussNum);
   for (i=0; i<header.mixNum; i++) {
//       dets[i]=10.0f;
       dets[i]=90.0f+((float)(rand())*40.0f/(float)RAND_MAX); // 90.0 ... 130.0
   }
   if (fwrite((void*)(dets), sizeof(float)*header.gaussNum, 1, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(dets);
   float *trans=(float*)calloc(sizeof(float),header.trpNum);
   for (i=0; i<header.trpNum; i++) {
       trans[i]=0.1f;
   }
   if (fwrite((void*)(trans), sizeof(float), header.trpNum, fptr)<1) {
      fclose(fptr); return fptr;
   }
   free(trans);
   fclose(fptr);
   fptr=fopen(file, "rb");
   return fptr;
}

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

   int i;
   FILE  *fptr_32f;
   Param_File_Header header;
   File_Mixture *exstates=NULL;
   float *means_32f=NULL, *vars_32f=NULL, *trans=NULL;

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

   if (!(fptr_32f=fopen(file, "rb")))
   if (!(fptr_32f=create_param_file(file,6000,4,36,100)))       return -3;
   if ((int)fread((void*)(&header), sizeof(Param_File_Header), 1, fptr_32f)<1) {
      fclose(fptr_32f); return -3;
   }

   state_number = header.mixNum;
   max_gauss    = 1;