Merge pull request drowe67#245 from drowe67/ms-optimization-mbest

Slight optimizations for mbest_search() and mbest_insert().

Author: drowe67

CMakeLists.txt

@@ -841,7 +841,7 @@ endif()
         COMMAND sh -c "cd ${CMAKE_CURRENT_SOURCE_DIR}/unittest; ./reliable_text_fade.sh 700D -19 8 1 '${CMAKE_CURRENT_BINARY_DIR}/src'")
 
   add_test(NAME test_freedv_reliable_text_fade_700E
-        COMMAND sh -c "cd ${CMAKE_CURRENT_SOURCE_DIR}/unittest; ./reliable_text_fade.sh 700E -22 9 1 '${CMAKE_CURRENT_BINARY_DIR}/src'")
+        COMMAND sh -c "cd ${CMAKE_CURRENT_SOURCE_DIR}/unittest; ./reliable_text_fade.sh 700E -22 8 1 '${CMAKE_CURRENT_BINARY_DIR}/src'")
 
 if(LPCNET)
     add_test(NAME test_freedv_reliable_text_ideal_2020
@@ -991,10 +991,11 @@ endif(NOT APPLE)
 
      add_test(NAME test_vq_mbest
              COMMAND sh -c "./tvq_mbest; \
-                            cat target.f32 | ../misc/vq_mbest -k 2 -q vq1.f32,vq2.f32 --mbest 2 -v > out.f32; \
-                            diff target.f32 out.f32"
+                            cat target.f32 | \
+                            ../misc/vq_mbest -k 4 -q vq1.f32,vq2.f32 --st 1 --en 2 --mbest 2 -v > /dev/null;"
              WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/unittest
              )
+             set_tests_properties(test_vq_mbest PROPERTIES PASS_REGULAR_EXPRESSION "MSE: 0.00")
 
      add_test(NAME test_700c_eq
              COMMAND sh -c "cd ${CMAKE_CURRENT_SOURCE_DIR}/unittest;

misc/vq_mbest.c

@@ -19,18 +19,19 @@
 #define MAX_ENTRIES 4096
 #define MAX_STAGES  5
 
-void quant_pred_mbest(float vec_out[],
-                      int   indexes[],
-                      float vec_in[],
-                      int   num_stages,
-                      float vq[],
-                      int   m[], int k,
-                      int   mbest_survivors, int st, int en);
+void quant_mbest(float vec_out[],
+                 int   indexes[],
+                 float vec_in[],
+                 int   num_stages,
+                 float vqw[], float vq[], 
+                 int   m[], int k,
+                 int   mbest_survivors);
 
 int verbose = 0;
 
 int main(int argc, char *argv[]) {
     float vq[MAX_STAGES*MAX_K*MAX_ENTRIES];
+    float vqw[MAX_STAGES*MAX_K*MAX_ENTRIES];
     int   m[MAX_STAGES];
     int   k=0, mbest_survivors=1, num_stages=0;
     char  fnames[256], fn[256], *comma, *p;
@@ -143,11 +144,27 @@ int main(int argc, char *argv[]) {
     if (st == -1) st = 0; 
     if (en == -1) en = k-1;
 
-    int   indexes[num_stages], nvecs = 0; int vec_usage[m[0]];
+    float w[k];
+    for(int i=0; i<st; i++)
+        w[i] = 0.0;
+    for(int i=st; i<=en; i++)
+        w[i] = 1.0;
+    for(int i=en+1; i<k; i++)
+        w[i] = 0.0;
+
+    /* apply weighting to codebook (rather than in search) */
+    memcpy(vqw, vq, sizeof(vq));
+    for(int s=0; s<num_stages; s++) {
+        mbest_precompute_weight(&vqw[s*k*MAX_ENTRIES], w, k, m[s]);
+    }
+    
+    int indexes[num_stages], nvecs = 0; int vec_usage[m[0]];
     for(int i=0; i<m[0]; i++) vec_usage[i] = 0;
     float target[k], quantised[k];
     float sqe = 0.0;
     while(fread(&target, sizeof(float), k, stdin) && (nvecs < num)) {
+	for(int i=0; i<k; i++)
+            target[i] *= w[i];
 	int dont_count = 0;
 	/* optional clamping to lower limit or mean */
 	float mean = 0.0;
@@ -161,7 +178,7 @@ int main(int argc, char *argv[]) {
 		target[i] += -difference;
 	    dont_count = 1;
 	}
-	quant_pred_mbest(quantised, indexes, target, num_stages, vq, m, k, mbest_survivors, st, en);
+	quant_mbest(quantised, indexes, target, num_stages, vqw, vq, m, k, mbest_survivors);
 	if (dont_count == 0) {
 	    for(int i=st; i<=en; i++)
 		sqe += pow(target[i]-quantised[i], 2.0);
@@ -172,7 +189,7 @@ int main(int argc, char *argv[]) {
 	vec_usage[indexes[0]]++;
     }
 
-    fprintf(stderr, "%4.2f\n", sqe/(nvecs*(en-st+1)));
+    fprintf(stderr, "MSE: %4.2f\n", sqe/(nvecs*(en-st+1)));
 
     if (output_vec_usage) {
       for(int i=0; i<m[0]; i++)
@@ -196,15 +213,15 @@ void pv(char s[], float v[], int k) {
 
 // mbest algorithm version, backported from LPCNet/src
 
-void quant_pred_mbest(float vec_out[],
-                      int   indexes[],
-                      float vec_in[],
-                      int   num_stages,
-                      float vq[],
-                      int   m[], int k,
-                      int   mbest_survivors, int st, int en)
+void quant_mbest(float vec_out[],
+                 int   indexes[],
+                 float vec_in[],
+                 int   num_stages,
+                 float vqw[], float vq[],
+                 int   m[], int k,
+                 int   mbest_survivors)
 {
-    float err[k], w[k], se1;
+    float err[k], se1;
     int i,j,s,s1,ind;
 
     struct MBEST *mbest_stage[num_stages];
@@ -216,24 +233,17 @@ void quant_pred_mbest(float vec_out[],
         index[i] = 0;
     }
 
-    for(i=0; i<st; i++)
-        w[i] = 0.0;
-    for(i=st; i<=en; i++)
-        w[i] = 1.0;
-    for(i=en+1; i<k; i++)
-        w[i] = 0.0;
-
     se1 = 0.0;
     for(i=0; i<k; i++) {
         err[i] = vec_in[i];
-        se1 += err[i]*err[i]*w[i]*w[i];
+        se1 += err[i]*err[i];
     }
     se1 /= k;
 
     /* now quantise err[] using multi-stage mbest search, preserving
        mbest_survivors at each stage */
 
-    mbest_search(vq, err, w, k, m[0], mbest_stage[0], index);
+    mbest_search(vqw, err, k, m[0], mbest_stage[0], index);
     if (verbose) mbest_print("Stage 1:", mbest_stage[0]);
 
     for(s=1; s<num_stages; s++) {
@@ -251,11 +261,11 @@ void quant_pred_mbest(float vec_out[],
                 ind = index[s-s1];
                 if (verbose) fprintf(stderr, "   s: %d s1: %d s-s1: %d ind: %d\n", s,s1,s-s1,ind);
                 for(i=0; i<k; i++) {
-                    target[i] -= vq[s1*k*MAX_ENTRIES+ind*k+i];
+                    target[i] -= vqw[s1*k*MAX_ENTRIES+ind*k+i];
                 }
             }
             pv("   target: ", target, k);
-            mbest_search(&vq[s*k*MAX_ENTRIES], target, w, k, m[s], mbest_stage[s], index);
+            mbest_search(&vqw[s*k*MAX_ENTRIES], target, k, m[s], mbest_stage[s], index);
         }
         char str[80]; sprintf(str,"Stage %d:", s+1);
         if (verbose) mbest_print(str, mbest_stage[s]);
@@ -272,9 +282,9 @@ void quant_pred_mbest(float vec_out[],
         int ind = indexes[s];
         float se2 = 0.0;
         for(i=0; i<k; i++) {
-            err[i] -= vq[s*k*MAX_ENTRIES+ind*k+i];
+            err[i] -= vqw[s*k*MAX_ENTRIES+ind*k+i];
             vec_out[i] += vq[s*k*MAX_ENTRIES+ind*k+i];
-            se2 += err[i]*err[i]*w[i]*w[i];
+            se2 += err[i]*err[i];
         }
         se2 /= k;
         pv("    err: ", err, k);

src/defines.h

@@ -103,14 +103,8 @@ struct lsp_codebook {
 
 extern const struct lsp_codebook lsp_cb[];
 extern const struct lsp_codebook lsp_cbd[];
-extern const struct lsp_codebook lsp_cbvq[];
-extern const struct lsp_codebook lsp_cbjnd[];
-extern const struct lsp_codebook lsp_cbdt[];
 extern const struct lsp_codebook lsp_cbjvm[];
-extern const struct lsp_codebook lsp_cbvqanssi[];
-extern const struct lsp_codebook mel_cb[];
 extern const struct lsp_codebook ge_cb[];
-extern const struct lsp_codebook lspmelvq_cb[];
 extern const struct lsp_codebook newamp1vq_cb[];
 extern const struct lsp_codebook newamp1_energy_cb[];
 extern const struct lsp_codebook newamp2vq_cb[];

src/generate_codebook.c

@@ -4,7 +4,7 @@
   AUTHOR......: Bruce Perens
   DATE CREATED: 29 Sep 2010
 
-  Generate header files containing LSP quantisers, runs at compile time.
+  Generate header files containing quantisers, runs at compile time.
 
 \*---------------------------------------------------------------------------*/
 

src/mbest.c

@@ -64,6 +64,15 @@ void mbest_destroy(struct MBEST *mbest) {
 }
 
 
+/* apply weighting to VQ for efficient VQ search */
+
+void mbest_precompute_weight(float cb[], float w[], int k, int m) {
+    for (int j=0; j<m; j++) {
+        for(int i=0; i<k; i++)
+            cb[k*j+i] *= w[i];
+    }
+}
+
 /*---------------------------------------------------------------------------*\
 
   mbest_insert
@@ -75,18 +84,16 @@ void mbest_destroy(struct MBEST *mbest) {
 \*---------------------------------------------------------------------------*/
 
 void mbest_insert(struct MBEST *mbest, int index[], float error) {
-    int                i, j, found;
+    int                i, found;
     struct MBEST_LIST *list    = mbest->list;
     int                entries = mbest->entries;
 
     found = 0;
     for(i=0; i<entries && !found; i++)
 	if (error < list[i].error) {
 	    found = 1;
-	    for(j=entries-1; j>i; j--)
-		list[j] = list[j-1];
-	    for(j=0; j<MBEST_STAGES; j++)
-		list[i].index[j] = index[j];
+            memmove(&list[i+1], &list[i], sizeof(struct MBEST_LIST) * (entries - i - 1));
+            memcpy(&list[i].index[0], &index[0], sizeof(int) * MBEST_STAGES);
 	    list[i].error = error;
 	}
 }
@@ -114,30 +121,49 @@ void mbest_print(char title[], struct MBEST *mbest) {
 \*---------------------------------------------------------------------------*/
 
 void mbest_search(
-		  const float  *cb,     /* VQ codebook to search         */
-		  float         vec[],  /* target vector                 */
-		  float         w[],    /* weighting vector              */
-		  int           k,      /* dimension of vector           */
-		  int           m,      /* number on entries in codebook */
-		  struct MBEST *mbest,  /* list of closest matches       */
-		  int           index[] /* indexes that lead us here     */
+		  const float  *cb,      /* VQ codebook to search         */
+		  float         vec[],   /* target vector                 */
+                  int           k,       /* dimension of vector           */
+		  int           m,       /* number on entries in codebook */
+		  struct MBEST *mbest,   /* list of closest matches       */
+		  int           index[]  /* indexes that lead us here     */
 )
 {
-   float   e;
-   int     i,j;
-   float   diff;
+    int j;
 
-   for(j=0; j<m; j++) {
-	e = 0.0;
-	for(i=0; i<k; i++) {
-	    diff = cb[j*k+i]-vec[i];
-	    e += diff*w[i]*diff*w[i];
-	}
-	index[0] = j;
-	mbest_insert(mbest, index, e);
-   }
-}
+    /* note weighting can be applied externally by modifiying cb[] and vec:
 
+      float e = 0.0;
+      for(i=0; i<k; i++)
+        e += pow(w[i]*(cb[j*k+i] - vec[i]),2.0)
+           
+       |
+      \|/
+
+      for(i=0; i<k; i++)
+         e += pow(w[i]*cb[j*k+i] - w[i]*vec[i]),2.0)
+
+       |
+      \|/
+
+      for(i=0; i<k; i++)
+         e += pow(cb1[j*k+i] - vec1[i]),2.0)
+
+      where cb1[j*k+i] = w[i]*cb[j*k+i], and vec1[i] = w[i]*vec[i]
+    */
+
+    for(j=0; j<m; j++) {
+        float e = 0.0;
+        for(int i=0; i<k; i++) {
+	    float diff = *cb++ - vec[i];
+            e += diff*diff;
+        }
+        
+        index[0] = j;
+        if (e < mbest->list[mbest->entries - 1].error)
+            mbest_insert(mbest, index, e);
+    }
+}
 
 /*---------------------------------------------------------------------------*\
 
@@ -146,7 +172,7 @@ void mbest_search(
   Searches vec[] to a codebbook of vectors, and maintains a list of the mbest
   closest matches. Only searches the first NewAmp2_K Vectors
 
-  \*---------------------------------------------------------------------------*/
+\*---------------------------------------------------------------------------*/
 
 void mbest_search450(const float  *cb, float vec[], float w[], int k,int shorterK, int m, struct MBEST *mbest, int index[])
 

src/mbest.h

@@ -44,8 +44,9 @@ struct MBEST {
 
 struct MBEST *mbest_create(int entries);
 void mbest_destroy(struct MBEST *mbest);
+void mbest_precompute_weight(float cb[], float w[], int k, int m);
 void mbest_insert(struct MBEST *mbest, int index[], float error);
-void mbest_search(const float  *cb, float vec[], float w[], int k, int m, struct MBEST *mbest, int index[]);
+void mbest_search(const float  *cb, float vec[], int k, int m, struct MBEST *mbest, int index[]);
 void mbest_search450(const float  *cb, float vec[], float w[], int k,int shorterK, int m, struct MBEST *mbest, int index[]);
 
 void mbest_print(char title[], struct MBEST *mbest);

src/newamp1.c

@@ -166,35 +166,29 @@ float rate_K_mbest_encode(int *indexes, float *x, float *xq, int ndim, int mbest
   const float *codebook2 = newamp1vq_cb[1].cb;
   struct MBEST *mbest_stage1, *mbest_stage2;
   float target[ndim];
-  float w[ndim];
   int   index[MBEST_STAGES];
   float mse, tmp;
 
   /* codebook is compiled for a fixed K */
 
   assert(ndim == newamp1vq_cb[0].k);
 
-  /* equal weights, could be argued mel freq axis gives freq dep weighting */
-
-  for(i=0; i<ndim; i++)
-      w[i] = 1.0;
-
   mbest_stage1 = mbest_create(mbest_entries);
   mbest_stage2 = mbest_create(mbest_entries);
   for(i=0; i<MBEST_STAGES; i++)
       index[i] = 0;
 
   /* Stage 1 */
 
-  mbest_search(codebook1, x, w, ndim, newamp1vq_cb[0].m, mbest_stage1, index);
+  mbest_search(codebook1, x, ndim, newamp1vq_cb[0].m, mbest_stage1, index);
 
   /* Stage 2 */
 
   for (j=0; j<mbest_entries; j++) {
       index[1] = n1 = mbest_stage1->list[j].index[0];
       for(i=0; i<ndim; i++)
 	  target[i] = x[i] - codebook1[ndim*n1+i];
-      mbest_search(codebook2, target, w, ndim, newamp1vq_cb[1].m, mbest_stage2, index);
+      mbest_search(codebook2, target, ndim, newamp1vq_cb[1].m, mbest_stage2, index);
   }
 
   n1 = mbest_stage2->list[0].index[1];

src/sine.c

@@ -372,11 +372,15 @@ void hs_pitch_refinement(MODEL *model, COMP Sw[], float pmin, float pmax, float
   for(p=pmin; p<=pmax; p+=pstep) {
     E = 0.0;
     Wo = TWO_PI/p;
+    
+    float bFloat = Wo * one_on_r;
+    float currentBFloat = bFloat;
 
     /* Sum harmonic magnitudes */
     for(m=1; m<=model->L; m++) {
-        b = (int)(m*Wo*one_on_r + 0.5);
+        b = (int)(currentBFloat + 0.5);
         E += Sw[b].real*Sw[b].real + Sw[b].imag*Sw[b].imag;
+        currentBFloat += bFloat;
     }
     /* Compare to see if this is a maximum */