25 #define VAL_MACRO log((default_value == 0) ? (CMath::random(MIN_RAND, MAX_RAND)) : default_value)
26 #define ARRAY_SIZE 65336
75 const char Model::FIX_DISALLOWED=0 ;
76 const char Model::FIX_ALLOWED=1 ;
77 const char Model::FIX_DEFAULT=-1 ;
116 fix_pos_state[i] = FIX_DEFAULT ;
138 SG_FREE(fix_pos_state);
150 trans_list_forward_cnt=NULL;
151 trans_list_backward_cnt=NULL;
152 trans_list_forward=NULL;
153 trans_list_backward=NULL;
154 trans_list_forward_val=NULL;
166 #ifdef USE_LOGSUMARRAY
169 #ifdef USE_HMMPARALLEL_STRUCTURES
181 mem_initialized =
false;
187 #ifdef USE_HMMPARALLEL_STRUCTURES
205 #ifdef USE_HMMPARALLEL_STRUCTURES
221 #ifdef USE_HMMPARALLEL_STRUCTURES
236 trans_list_forward = NULL ;
237 trans_list_forward_cnt = NULL ;
238 trans_list_forward_val = NULL ;
239 trans_list_backward = NULL ;
240 trans_list_backward_cnt = NULL ;
242 mem_initialized = false ;
251 #ifdef USE_HMMPARALLEL_STRUCTURES
267 mem_initialized = true ;
289 trans_list_forward = NULL ;
290 trans_list_forward_cnt = NULL ;
291 trans_list_forward_val = NULL ;
292 trans_list_backward = NULL ;
293 trans_list_backward_cnt = NULL ;
295 mem_initialized = false ;
304 #ifdef USE_HMMPARALLEL_STRUCTURES
320 mem_initialized = true ;
322 trans_list_forward_cnt=NULL ;
324 trans_list_forward = SG_MALLOC(
T_STATES*,
N);
325 trans_list_forward_val = SG_MALLOC(
float64_t*,
N);
326 trans_list_forward_cnt = SG_MALLOC(
T_STATES,
N);
329 for (int32_t j=0; j<
N; j++)
331 int32_t old_start_idx=start_idx;
333 while (start_idx<num_trans && a_trans[start_idx+num_trans]==j)
337 if (start_idx>1 && start_idx<num_trans)
338 ASSERT(a_trans[start_idx+num_trans-1]<=
339 a_trans[start_idx+num_trans]);
342 if (start_idx>1 && start_idx<num_trans)
343 ASSERT(a_trans[start_idx+num_trans-1]<=
344 a_trans[start_idx+num_trans]);
346 int32_t len=start_idx-old_start_idx;
349 trans_list_forward_cnt[j] = 0 ;
353 trans_list_forward[j] = SG_MALLOC(
T_STATES, len);
354 trans_list_forward_val[j] = SG_MALLOC(
float64_t, len);
358 trans_list_forward[j] = NULL;
359 trans_list_forward_val[j] = NULL;
363 for (int32_t i=0; i<num_trans; i++)
365 int32_t from = (int32_t)a_trans[i+num_trans] ;
366 int32_t to = (int32_t)a_trans[i] ;
372 trans_list_forward[from][trans_list_forward_cnt[from]]=to ;
373 trans_list_forward_val[from][trans_list_forward_cnt[from]]=val ;
374 trans_list_forward_cnt[from]++ ;
392 #ifdef USE_HMMPARALLEL_STRUCTURES
403 if (trans_list_forward_cnt)
404 SG_FREE(trans_list_forward_cnt);
405 if (trans_list_backward_cnt)
406 SG_FREE(trans_list_backward_cnt);
407 if (trans_list_forward)
409 for (int32_t i=0; i<trans_list_len; i++)
410 if (trans_list_forward[i])
411 SG_FREE(trans_list_forward[i]);
412 SG_FREE(trans_list_forward);
414 if (trans_list_forward_val)
416 for (int32_t i=0; i<trans_list_len; i++)
417 if (trans_list_forward_val[i])
418 SG_FREE(trans_list_forward_val[i]);
419 SG_FREE(trans_list_forward_val);
421 if (trans_list_backward)
423 for (int32_t i=0; i<trans_list_len; i++)
424 if (trans_list_backward[i])
425 SG_FREE(trans_list_backward[i]);
426 SG_FREE(trans_list_backward);
433 #ifdef USE_HMMPARALLEL_STRUCTURES
448 #else // USE_HMMPARALLEL_STRUCTURES
453 #endif // USE_HMMPARALLEL_STRUCTURES
459 #ifdef USE_LOGSUMARRAY
460 #ifdef USE_HMMPARALLEL_STRUCTURES
469 #else //USE_HMMPARALLEL_STRUCTURES
471 #endif //USE_HMMPARALLEL_STRUCTURES
472 #endif //USE_LOGSUMARRAY
476 #ifdef USE_HMMPARALLEL_STRUCTURES
484 #endif //USE_HMMPARALLEL_STRUCTURES
496 SG_ERROR(
"Expected features of class string type word\n")
517 #ifdef USE_HMMPARALLEL_STRUCTURES
523 #else //USE_HMMPARALLEL_STRUCTURES
526 #endif //USE_HMMPARALLEL_STRUCTURES
529 #ifdef USE_HMMPARALLEL_STRUCTURES
531 arrayS[i]=SG_MALLOC(
float64_t, (int32_t)(this->
N/2+1));
532 #else //USE_HMMPARALLEL_STRUCTURES
533 arrayS=SG_MALLOC(
float64_t, (int32_t)(this->
N/2+1));
534 #endif //USE_HMMPARALLEL_STRUCTURES
535 #endif //LOG_SUMARRAY
541 #ifdef USE_HMMPARALLEL_STRUCTURES
543 #else //USE_HMMPARALLEL_STRUCTURES
545 #endif //USE_HMMPARALLEL_STRUCTURES
562 #ifdef USE_HMMPARALLEL_STRUCTURES
603 trans_list_forward = NULL ;
604 trans_list_forward_cnt = NULL ;
605 trans_list_forward_val = NULL ;
606 trans_list_backward = NULL ;
607 trans_list_backward_cnt = NULL ;
609 mem_initialized = false ;
620 #ifdef USE_HMMPARALLEL_STRUCTURES
628 this->beta_cache[i].table=NULL;
630 this->beta_cache[i].dimension=0;
631 this->states_per_observation_psi[i]=NULL ;
634 #else // USE_HMMPARALLEL_STRUCTURES
636 this->beta_cache.table=NULL;
638 this->beta_cache.dimension=0;
639 this->states_per_observation_psi=NULL ;
640 #endif //USE_HMMPARALLEL_STRUCTURES
645 #ifdef USE_HMMPARALLEL_STRUCTURES
654 #else // USE_HMMPARALLEL_STRUCTURES
657 #endif //USE_HMMPARALLEL_STRUCTURES
659 #ifdef USE_HMMPARALLEL_STRUCTURES
662 #endif //USE_HMMPARALLEL_STRUCTURES
665 #ifdef USE_HMMPARALLEL_STRUCTURES
667 #endif // USE_HMMPARALLEL_STRUCTURES
668 #endif //LOG_SUMARRAY
673 mem_initialized = true ;
676 return ((files_ok) &&
696 int32_t wanted_time=time;
698 if (ALPHA_CACHE(dimension).table)
700 alpha=&ALPHA_CACHE(dimension).table[0];
701 alpha_new=&ALPHA_CACHE(dimension).table[
N];
715 for (int32_t i=0; i<
N; i++)
722 for (int32_t j=0; j<
N; j++)
724 register int32_t i, num = trans_list_forward_cnt[j] ;
726 for (i=0; i < num; i++)
728 int32_t ii = trans_list_forward[j][i] ;
735 if (!ALPHA_CACHE(dimension).table)
749 if (time<p_observations->get_vector_length(dimension))
751 register int32_t i, num=trans_list_forward_cnt[state];
753 for (i=0; i<num; i++)
755 int32_t ii = trans_list_forward[state][i] ;
770 if (!ALPHA_CACHE(dimension).table)
774 ALPHA_CACHE(dimension).dimension=dimension;
775 ALPHA_CACHE(dimension).updated=
true;
776 ALPHA_CACHE(dimension).sum=sum;
778 if (wanted_time<p_observations->get_vector_length(dimension))
779 return ALPHA_CACHE(dimension).table[wanted_time*N+state];
781 return ALPHA_CACHE(dimension).sum;
799 int32_t wanted_time=time;
801 if (ALPHA_CACHE(dimension).table)
803 alpha=&ALPHA_CACHE(dimension).table[0];
804 alpha_new=&ALPHA_CACHE(dimension).table[
N];
818 for (int32_t i=0; i<
N; i++)
825 for (int32_t j=0; j<
N; j++)
828 #ifdef USE_LOGSUMARRAY
829 for (i=0; i<(N>>1); i++)
831 alpha[(i<<1)+1] +
get_a((i<<1)+1,j));
835 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
838 #else //USE_LOGSUMARRAY
844 #endif //USE_LOGSUMARRAY
847 if (!ALPHA_CACHE(dimension).table)
861 if (time<p_observations->get_vector_length(dimension))
864 #ifdef USE_LOGSUMARRAY
865 for (i=0; i<(N>>1); i++)
867 alpha[(i<<1)+1] +
get_a((i<<1)+1,state));
871 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
874 #else //USE_LOGSUMARRAY
880 #endif //USE_LOGSUMARRAY
887 #ifdef USE_LOGSUMARRAY
888 for (i=0; i<(N>>1); i++)
890 alpha[(i<<1)+1] +
get_q((i<<1)+1));
893 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
895 sum=CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1) ;
896 #else //USE_LOGSUMARRAY
900 #endif //USE_LOGSUMARRAY
902 if (!ALPHA_CACHE(dimension).table)
906 ALPHA_CACHE(dimension).dimension=dimension;
907 ALPHA_CACHE(dimension).updated=
true;
908 ALPHA_CACHE(dimension).sum=sum;
910 if (wanted_time<p_observations->get_vector_length(dimension))
911 return ALPHA_CACHE(dimension).table[wanted_time*N+state];
913 return ALPHA_CACHE(dimension).sum;
928 int32_t wanted_time=time;
931 forward(time, state, dimension);
933 if (BETA_CACHE(dimension).table)
952 for (
register int32_t i=0; i<
N; i++)
958 for (
register int32_t i=0; i<
N; i++)
960 register int32_t j, num=trans_list_backward_cnt[i] ;
962 for (j=0; j<num; j++)
964 int32_t jj = trans_list_backward[i][j] ;
970 if (!BETA_CACHE(dimension).table)
985 register int32_t j, num=trans_list_backward_cnt[state] ;
987 for (j=0; j<num; j++)
989 int32_t jj = trans_list_backward[state][j] ;
996 if (BETA_CACHE(dimension).table)
999 for (
register int32_t j=0; j<
N; j++)
1001 BETA_CACHE(dimension).sum=sum;
1002 BETA_CACHE(dimension).dimension=dimension;
1003 BETA_CACHE(dimension).updated=
true;
1005 if (wanted_time<p_observations->get_vector_length(dimension))
1006 return BETA_CACHE(dimension).table[wanted_time*N+state];
1008 return BETA_CACHE(dimension).sum;
1013 for (
register int32_t j=0; j<
N; j++)
1023 int32_t time, int32_t state, int32_t dimension)
1028 int32_t wanted_time=time;
1031 forward(time, state, dimension);
1033 if (BETA_CACHE(dimension).table)
1048 return get_q(state);
1052 for (
register int32_t i=0; i<
N; i++)
1058 for (
register int32_t i=0; i<
N; i++)
1060 register int32_t j ;
1061 #ifdef USE_LOGSUMARRAY
1062 for (j=0; j<(N>>1); j++)
1068 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
1070 beta_new[i]=CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1) ;
1071 #else //USE_LOGSUMARRAY
1077 #endif //USE_LOGSUMARRAY
1080 if (!BETA_CACHE(dimension).table)
1095 register int32_t j ;
1096 #ifdef USE_LOGSUMARRAY
1097 for (j=0; j<(N>>1); j++)
1103 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
1105 return CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1) ;
1106 #else //USE_LOGSUMARRAY
1112 #endif //USE_LOGSUMARRAY
1116 if (BETA_CACHE(dimension).table)
1118 #ifdef USE_LOGSUMARRAY//AAA
1119 for (int32_t j=0; j<(N>>1); j++)
1124 CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1)) ;
1126 BETA_CACHE(dimension).sum=CMath::logarithmic_sum_array(ARRAYS(dimension), N>>1) ;
1127 #else //USE_LOGSUMARRAY
1129 for (
register int32_t j=0; j<
N; j++)
1131 BETA_CACHE(dimension).sum=sum;
1132 #endif //USE_LOGSUMARRAY
1133 BETA_CACHE(dimension).dimension=dimension;
1134 BETA_CACHE(dimension).updated=
true;
1136 if (wanted_time<p_observations->get_vector_length(dimension))
1137 return BETA_CACHE(dimension).table[wanted_time*N+state];
1139 return BETA_CACHE(dimension).sum;
1144 for (
register int32_t j=0; j<
N; j++)
1163 SG_INFO(
"computing full viterbi likelihood\n")
1175 if (!STATES_PER_OBSERVATION_PSI(dimension))
1181 if (PATH_PROB_UPDATED(dimension) && dimension==PATH_PROB_DIMENSION(dimension))
1186 register float64_t* delta_new= ARRAYN1(dimension);
1189 for (
register int32_t i=0; i<
N; i++)
1196 #ifdef USE_PATHDEBUG
1203 register int32_t NN=
N ;
1204 for (
register int32_t j=0; j<NN; j++)
1207 register float64_t maxj=delta[0] + matrix_a[0];
1208 register int32_t argmax=0;
1210 for (
register int32_t i=1; i<NN; i++)
1212 register float64_t temp = delta[i] + matrix_a[i];
1221 if ((!
model) || (
model->get_fix_pos_state(t,j,NN)!=Model::FIX_DISALLOWED))
1228 set_psi(t, j, argmax, dimension);
1231 #ifdef USE_PATHDEBUG
1233 for (int32_t jj=0; jj<
N; jj++)
1234 if (delta_new[jj]>best)
1235 best=delta_new[jj] ;
1239 SG_DEBUG(
"worst case at %i: %e:%e\n", t, best, worst)
1252 register int32_t argmax=0;
1254 for (
register int32_t i=1; i<
N; i++)
1272 PATH(dimension)[t-1]=
get_psi(t, PATH(dimension)[t], dimension);
1275 PATH_PROB_UPDATED(dimension)=
true;
1276 PATH_PROB_DIMENSION(dimension)=dimension;
1281 #ifndef USE_HMMPARALLEL
1300 SG_INFO(
"computing full model probablity\n")
1303 for (int32_t cpu=0; cpu<
parallel->get_num_threads(); cpu++)
1305 params[cpu].hmm=this ;
1312 pthread_create(&threads[cpu], NULL, bw_dim_prefetch, (
void*)¶ms[cpu]);
1317 pthread_join(threads[cpu], NULL);
1323 SG_FREE(params[i].p_buf);
1324 SG_FREE(params[i].q_buf);
1325 SG_FREE(params[i].a_buf);
1326 SG_FREE(params[i].b_buf);
1336 void* CHMM::bw_dim_prefetch(
void* params)
1338 CHMM* hmm=((S_BW_THREAD_PARAM*) params)->hmm;
1339 int32_t start=((S_BW_THREAD_PARAM*) params)->dim_start;
1340 int32_t stop=((S_BW_THREAD_PARAM*) params)->dim_stop;
1341 float64_t* p_buf=((S_BW_THREAD_PARAM*) params)->p_buf;
1342 float64_t* q_buf=((S_BW_THREAD_PARAM*) params)->q_buf;
1343 float64_t* a_buf=((S_BW_THREAD_PARAM*) params)->a_buf;
1344 float64_t* b_buf=((S_BW_THREAD_PARAM*) params)->b_buf;
1345 ((S_BW_THREAD_PARAM*)params)->ret=0;
1347 for (int32_t dim=start; dim<stop; dim++)
1352 hmm->ab_buf_comp(p_buf, q_buf, a_buf, b_buf, dim) ;
1353 ((S_BW_THREAD_PARAM*)params)->ret+= modprob;
1358 void* CHMM::bw_single_dim_prefetch(
void * params)
1360 CHMM* hmm=((S_BW_THREAD_PARAM*)params)->hmm ;
1361 int32_t dim=((S_DIM_THREAD_PARAM*)params)->dim ;
1366 void* CHMM::vit_dim_prefetch(
void * params)
1368 CHMM* hmm=((S_DIM_THREAD_PARAM*)params)->hmm ;
1369 int32_t dim=((S_DIM_THREAD_PARAM*)params)->dim ;
1370 ((S_DIM_THREAD_PARAM*)params)->prob_sum = hmm->
best_path(dim);
1374 #endif //USE_HMMPARALLEL
1377 #ifdef USE_HMMPARALLEL
1379 void CHMM::ab_buf_comp(
1405 a_buf[N*i+j]=a_sum-dimmodprob ;
1419 b_buf[M*i+j]=b_sum-dimmodprob ;
1457 pthread_t *threads=SG_MALLOC(pthread_t, num_threads);
1458 S_BW_THREAD_PARAM *params=SG_MALLOC(S_BW_THREAD_PARAM, num_threads);
1463 for (cpu=0; cpu<num_threads; cpu++)
1465 params[cpu].p_buf=SG_MALLOC(
float64_t, N);
1466 params[cpu].q_buf=SG_MALLOC(
float64_t, N);
1467 params[cpu].a_buf=SG_MALLOC(
float64_t, N*N);
1468 params[cpu].b_buf=SG_MALLOC(
float64_t, N*M);
1470 params[cpu].hmm=hmm;
1478 params[cpu].dim_start=start;
1479 params[cpu].dim_stop=stop;
1481 pthread_create(&threads[cpu], NULL, bw_dim_prefetch, ¶ms[cpu]);
1484 for (cpu=0; cpu<num_threads; cpu++)
1486 pthread_join(threads[cpu], NULL);
1503 fullmodprob+=params[cpu].ret;
1507 for (cpu=0; cpu<num_threads; cpu++)
1509 SG_FREE(params[cpu].p_buf);
1510 SG_FREE(params[cpu].q_buf);
1511 SG_FREE(params[cpu].a_buf);
1512 SG_FREE(params[cpu].b_buf);
1527 #else // USE_HMMPARALLEL
1566 fullmodprob+=dimmodprob ;
1574 int32_t num = trans_list_backward_cnt[i] ;
1577 for (j=0; j<num; j++)
1579 int32_t jj = trans_list_backward[i][j] ;
1652 fullmodprob+=dimmodprob ;
1697 #endif // USE_HMMPARALLEL
1734 fullmodprob+=dimmodprob ;
1742 int32_t num = trans_list_backward_cnt[i] ;
1744 for (j=0; j<num; j++)
1746 int32_t jj = trans_list_backward[i][j] ;
1773 int32_t i,j,old_i,k,t,dim;
1807 #ifdef USE_HMMPARALLEL
1809 pthread_t *threads=SG_MALLOC(pthread_t, num_threads);
1810 S_DIM_THREAD_PARAM *params=SG_MALLOC(S_DIM_THREAD_PARAM, num_threads);
1819 #ifdef USE_HMMPARALLEL
1820 if (dim%num_threads==0)
1822 for (i=0; i<num_threads; i++)
1824 if (dim+i<p_observations->get_num_vectors())
1826 params[i].hmm=estimate ;
1827 params[i].dim=dim+i ;
1828 pthread_create(&threads[i], NULL, bw_single_dim_prefetch, (
void*)¶ms[i]) ;
1831 for (i=0; i<num_threads; i++)
1833 if (dim+i<p_observations->get_num_vectors())
1835 pthread_join(threads[i], NULL);
1836 dimmodprob = params[i].prob_sum;
1842 #endif // USE_HMMPARALLEL
1845 fullmodprob+= dimmodprob;
1912 #ifdef USE_HMMPARALLEL
1971 #ifdef USE_HMMPARALLEL
1973 pthread_t *threads=SG_MALLOC(pthread_t, num_threads);
1974 S_DIM_THREAD_PARAM *params=SG_MALLOC(S_DIM_THREAD_PARAM, num_threads);
1983 #ifdef USE_HMMPARALLEL
1984 if (dim%num_threads==0)
1986 for (i=0; i<num_threads; i++)
1988 if (dim+i<p_observations->get_num_vectors())
1990 params[i].hmm=estimate ;
1991 params[i].dim=dim+i ;
1992 pthread_create(&threads[i], NULL, vit_dim_prefetch, (
void*)¶ms[i]) ;
1995 for (i=0; i<num_threads; i++)
1997 if (dim+i<p_observations->get_num_vectors())
1999 pthread_join(threads[i], NULL);
2000 allpatprob += params[i].prob_sum;
2007 #endif // USE_HMMPARALLEL
2012 set_A(estimate->PATH(dim)[t], estimate->PATH(dim)[t+1],
get_A(estimate->PATH(dim)[t], estimate->PATH(dim)[t+1])+1);
2018 P[estimate->PATH(dim)[0]]++;
2022 #ifdef USE_HMMPARALLEL
2059 set_p(i, log(P[i]/sum));
2067 set_q(i, log(Q[i]/sum));
2096 #ifdef USE_HMMPARALLEL
2098 pthread_t *threads=SG_MALLOC(pthread_t, num_threads);
2099 S_DIM_THREAD_PARAM *params=SG_MALLOC(S_DIM_THREAD_PARAM, num_threads);
2106 #ifdef USE_HMMPARALLEL
2107 if (dim%num_threads==0)
2109 for (i=0; i<num_threads; i++)
2111 if (dim+i<p_observations->get_num_vectors())
2113 params[i].hmm=estimate ;
2114 params[i].dim=dim+i ;
2115 pthread_create(&threads[i], NULL, vit_dim_prefetch, (
void*)¶ms[i]) ;
2118 for (i=0; i<num_threads; i++)
2120 if (dim+i<p_observations->get_num_vectors())
2122 pthread_join(threads[i], NULL);
2123 allpatprob += params[i].prob_sum;
2127 #else // USE_HMMPARALLEL
2130 #endif // USE_HMMPARALLEL
2136 set_A(estimate->PATH(dim)[t], estimate->PATH(dim)[t+1],
get_A(estimate->PATH(dim)[t], estimate->PATH(dim)[t+1])+1);
2142 P[estimate->PATH(dim)[0]]++;
2146 #ifdef USE_HMMPARALLEL
2262 SG_INFO(
"log(Pr[O|model])=%e, #states: %i, #observationssymbols: %i, #observations: %ix%i\n",
2269 SG_INFO(
"\ntransition matrix\n")
2282 if (fabs(checksum)>1e-5)
2283 SG_DEBUG(
" checksum % E ******* \n",checksum)
2285 SG_DEBUG(
" checksum % E\n",checksum)
2289 SG_INFO(
"\ndistribution of start states\n")
2298 if (fabs(checksum)>1e-5)
2299 SG_DEBUG(
" checksum % E ******* \n",checksum)
2301 SG_DEBUG(
" checksum=% E\n", checksum)
2304 SG_INFO(
"\ndistribution of terminal states\n")
2313 if (fabs(checksum)>1e-5)
2314 SG_DEBUG(
" checksum % E ******* \n",checksum)
2316 SG_DEBUG(
" checksum=% E\n", checksum)
2319 SG_INFO(
"\ndistribution of observations given the state\n")
2330 if (fabs(checksum)>1e-5)
2331 SG_DEBUG(
" checksum % E ******* \n",checksum)
2333 SG_DEBUG(
" checksum % E\n",checksum)
2347 SG_INFO(
"log(Pr[O|model])=%e, #states: %i, #observationssymbols: %i, #observations: %ix%i\n",
2354 SG_INFO(
"\ntransition matrix\n")
2372 SG_INFO(
"\n\ndistribution of observations given the state\n")
2559 SG_FREE(R); R=NULL ;
2588 SG_FREE(R); R=NULL ;
2723 if (mem_initialized)
2725 if (trans_list_forward_cnt)
2726 SG_FREE(trans_list_forward_cnt);
2727 trans_list_forward_cnt=NULL ;
2728 if (trans_list_backward_cnt)
2729 SG_FREE(trans_list_backward_cnt);
2730 trans_list_backward_cnt=NULL ;
2731 if (trans_list_forward)
2733 for (int32_t i=0; i<trans_list_len; i++)
2734 if (trans_list_forward[i])
2735 SG_FREE(trans_list_forward[i]);
2736 SG_FREE(trans_list_forward);
2737 trans_list_forward=NULL ;
2739 if (trans_list_backward)
2741 for (int32_t i=0; i<trans_list_len; i++)
2742 if (trans_list_backward[i])
2743 SG_FREE(trans_list_backward[i]);
2744 SG_FREE(trans_list_backward);
2745 trans_list_backward = NULL ;
2748 trans_list_len =
N ;
2749 trans_list_forward = SG_MALLOC(
T_STATES*, N);
2750 trans_list_forward_cnt = SG_MALLOC(
T_STATES, N);
2752 for (int32_t j=0; j<
N; j++)
2754 trans_list_forward_cnt[j]= 0 ;
2755 trans_list_forward[j]= SG_MALLOC(
T_STATES, N);
2756 for (int32_t i=0; i<
N; i++)
2759 trans_list_forward[j][trans_list_forward_cnt[j]]=i ;
2760 trans_list_forward_cnt[j]++ ;
2764 trans_list_backward = SG_MALLOC(
T_STATES*, N);
2765 trans_list_backward_cnt = SG_MALLOC(
T_STATES, N);
2767 for (int32_t i=0; i<
N; i++)
2769 trans_list_backward_cnt[i]= 0 ;
2770 trans_list_backward[i]= SG_MALLOC(
T_STATES, N);
2771 for (int32_t j=0; j<
N; j++)
2774 trans_list_backward[i][trans_list_backward_cnt[i]]=j ;
2775 trans_list_backward_cnt[i]++ ;
2785 #ifdef USE_HMMPARALLEL_STRUCTURES
2795 #else // USE_HMMPARALLEL_STRUCTURES
2801 #endif // USE_HMMPARALLEL_STRUCTURES
2807 while (((value=fgetc(file)) != EOF) && (value!=
'['))
2814 error(
line,
"expected \"[\" in input file");
2816 while (((value=fgetc(file)) != EOF) && (isspace(value)))
2822 ungetc(value, file);
2828 while (((value=fgetc(file)) != EOF) && (value!=
']'))
2835 error(
line,
"expected \"]\" in input file");
2841 while (((value=fgetc(file)) != EOF) && (value!=
',') && (value!=
';') && (value!=
']'))
2848 ungetc(value, file);
2849 SG_ERROR(
"found ']' instead of ';' or ','\n")
2854 error(
line,
"expected \";\" or \",\" in input file");
2856 while (((value=fgetc(file)) != EOF) && (isspace(value)))
2861 ungetc(value, file);
2869 while (((value=fgetc(file)) != EOF) &&
2870 !isdigit(value) && (value!=
'A')
2871 && (value!=
'C') && (value!=
'G') && (value!=
'T')
2872 && (value!=
'N') && (value!=
'n')
2873 && (value!=
'.') && (value!=
'-') && (value!=
'e') && (value!=
']'))
2880 ungetc(value,file) ;
2904 while (((value=fgetc(file)) != EOF) &&
2905 (isdigit(value) || (value==
'.') || (value==
'-') || (value==
'e')
2906 || (value==
'A') || (value==
'C') || (value==
'G')|| (value==
'T')
2907 || (value==
'N') || (value==
'n')) && (i<length))
2923 case '1':
case '2':
case'3':
case '4':
case'5':
2924 case '6':
case '7':
case'8':
case '9':
case '0': break ;
2925 case '.':
case 'e':
case '-': break ;
2927 SG_ERROR(
"found crap: %i %c (pos:%li)\n",i,value,ftell(file))
2931 ungetc(value, file);
2934 return (i<=length) && (i>0);
2976 int32_t received_params=0;
2989 int32_t value=fgetc(file);
3001 if (received_params &
GOTN)
3002 error(
line,
"in model file: \"p double defined\"");
3006 else if (value==
'M')
3008 if (received_params &
GOTM)
3009 error(
line,
"in model file: \"p double defined\"");
3013 else if (value==
'%')
3021 if (received_params &
GOTp)
3022 error(
line,
"in model file: \"p double defined\"");
3028 if (received_params &
GOTq)
3029 error(
line,
"in model file: \"q double defined\"");
3033 else if (value==
'a')
3035 if (received_params &
GOTa)
3036 error(
line,
"in model file: \"a double defined\"");
3040 else if (value==
'b')
3042 if (received_params &
GOTb)
3043 error(
line,
"in model file: \"b double defined\"");
3047 else if (value==
'%')
3057 this->N= atoi(buffer);
3058 received_params|=
GOTN;
3070 this->M= atoi(buffer);
3071 received_params|=
GOTM;
3085 for (i=0; i<this->
N; i++)
3089 for (j=0; j<this->
N ; j++)
3092 if (fscanf( file,
"%le", &f ) != 1)
3108 received_params|=
GOTa;
3119 for (i=0; i<this->
N; i++)
3123 for (j=0; j<this->
M ; j++)
3126 if (fscanf( file,
"%le", &f ) != 1)
3142 received_params|=
GOTb;
3153 for (i=0; i<this->
N ; i++)
3155 if (fscanf( file,
"%le", &f ) != 1)
3165 received_params|=
GOTp;
3176 for (i=0; i<this->
N ; i++)
3178 if (fscanf( file,
"%le", &f ) != 1)
3188 received_params|=
GOTq;
3195 else if (value==
'\n')
3209 SG_WARNING(
"not normalizing anymore, call normalize_hmm to make sure the hmm is valid!!\n")
3279 int32_t received_params=0x0000000;
3306 int32_t value=fgetc(file);
3319 if (fgetc(file)==
'e' && fgetc(file)==
'a' && fgetc(file)==
'r' && fgetc(file)==
'n' && fgetc(file)==
'_')
3336 error(
line,
"a,b,p or q expected in train definition file");
3340 else if (value==
'c')
3342 if (fgetc(file)==
'o' && fgetc(file)==
'n' && fgetc(file)==
's'
3343 && fgetc(file)==
't' && fgetc(file)==
'_')
3360 error(
line,
"a,b,p or q expected in train definition file");
3364 else if (value==
'%')
3368 else if (value==EOF)
3377 bool finished=
false;
3381 SG_DEBUG(
"\nlearn for transition matrix: ")
3397 SG_ERROR(
"invalid value for learn_a(%i,0): %i\n",i/2,(
int)value)
3415 SG_ERROR(
"invalid value for learn_a(%i,1): %i\n",i/2-1,(
int)value)
3440 bool finished=
false;
3444 SG_DEBUG(
"\nlearn for emission matrix: ")
3452 for (int32_t j=0; j<2; j++)
3468 SG_ERROR(
"invalid value for learn_b(%i,0): %i\n",i/2,(
int)value)
3484 SG_ERROR(
"invalid value for learn_b(%i,1): %i\n",i/2-1,(
int)value)
3488 SG_DEBUG(
"%i Entries",(
int)(i/2-1))
3503 bool finished=
false;
3522 SG_ERROR(
"invalid value for learn_p(%i): %i\n",i-1,(
int)value)
3547 bool finished=
false;
3551 SG_DEBUG(
"\nlearn terminal states: ")
3565 SG_ERROR(
"invalid value for learn_q(%i): %i\n",i-1,(
int)value)
3590 bool finished=
false;
3595 SG_DEBUG(
"\nconst for transition matrix: \n")
3597 SG_DEBUG(
"\nconst for transition matrix: ")
3616 SG_ERROR(
"invalid value for const_a(%i,0): %i\n",i/2,(
int)value)
3635 SG_ERROR(
"invalid value for const_a(%i,1): %i\n",i/2-1,(
int)value)
3652 if ((dvalue>1.0) || (dvalue<0.0))
3653 SG_ERROR(
"invalid value for const_a_val(%i): %e\n",(
int)i/2-1,dvalue)
3682 bool finished=
false;
3687 SG_DEBUG(
"\nconst for emission matrix: \n")
3689 SG_DEBUG(
"\nconst for emission matrix: ")
3695 for (int32_t j=0; j<3; j++)
3712 SG_ERROR(
"invalid value for const_b(%i,0): %i\n",i/2-1,(
int)value)
3723 if ((dvalue>1.0) || (dvalue<0.0))
3724 SG_ERROR(
"invalid value for const_b_val(%i,1): %e\n",i/2-1,dvalue)
3748 SG_ERROR(
"invalid value for const_b(%i,1): %i\n",i/2-1, combine)
3750 if (verbose && !finished)
3771 bool finished=
false;
3776 SG_DEBUG(
"\nconst for start states: \n")
3778 SG_DEBUG(
"\nconst for start states: ")
3796 SG_ERROR(
"invalid value for const_p(%i): %i\n",i,(
int)value)
3814 if ((dvalue>1) || (dvalue<0))
3815 SG_ERROR(
"invalid value for const_p_val(%i): %e\n",i,dvalue)
3845 bool finished=
false;
3848 SG_DEBUG(
"\nconst for terminal states: \n")
3850 SG_DEBUG(
"\nconst for terminal states: ")
3868 SG_ERROR(
"invalid value for const_q(%i): %i\n",i,(
int)value)
3885 if ((dvalue>1) || (dvalue<0))
3886 SG_ERROR(
"invalid value for const_q_val(%i): %e\n",i,(
double) dvalue)
3914 else if (value==
'\n')
3986 fprintf(file,
"%s",
"% HMM - specification\n% N - number of states\n% M - number of observation_tokens\n% a is state_transition_matrix\n% size(a)= [N,N]\n%\n% b is observation_per_state_matrix\n% size(b)= [N,M]\n%\n% p is initial distribution\n% size(p)= [1, N]\n\n% q is distribution of end states\n% size(q)= [1, N]\n");
3987 fprintf(file,
"N=%d;\n",N);
3988 fprintf(file,
"M=%d;\n",M);
3990 fprintf(file,
"p=[");
3995 fprintf(file,
"%e,", (
double)
get_p(i));
3997 fprintf(file,
"%f,", NAN_REPLACEMENT);
4001 fprintf(file,
"%e", (
double)
get_p(i));
4003 fprintf(file,
"%f", NAN_REPLACEMENT);
4007 fprintf(file,
"];\n\nq=[");
4012 fprintf(file,
"%e,", (
double)
get_q(i));
4014 fprintf(file,
"%f,", NAN_REPLACEMENT);
4018 fprintf(file,
"%e", (
double)
get_q(i));
4020 fprintf(file,
"%f", NAN_REPLACEMENT);
4023 fprintf(file,
"];\n\na=[");
4027 fprintf(file,
"\t[");
4033 fprintf(file,
"%e,", (
double)
get_a(i,j));
4035 fprintf(file,
"%f,", NAN_REPLACEMENT);
4039 fprintf(file,
"%e];\n", (
double)
get_a(i,j));
4041 fprintf(file,
"%f];\n", NAN_REPLACEMENT);
4046 fprintf(file,
" ];\n\nb=[");
4050 fprintf(file,
"\t[");
4056 fprintf(file,
"%e,", (
double)
get_b(i,j));
4058 fprintf(file,
"%f,", NAN_REPLACEMENT);
4062 fprintf(file,
"%e];\n", (
double)
get_b(i,j));
4064 fprintf(file,
"%f];\n", NAN_REPLACEMENT);
4068 result= (fprintf(file,
" ];\n") == 5);
4082 result[i]=PATH(dim)[i];
4098 fprintf(file,
"%i. path probability:%e\nstate sequence:\n", dim, prob);
4100 fprintf(file,
"%d ", PATH(dim)[i]);
4102 fprintf(file,
"\n\n") ;
4120 fwrite(&prob,
sizeof(
float32_t), 1, file);
4134 fprintf(file,
"%% likelihood of model per observation\n%% P[O|model]=[ P[O|model]_1 P[O|model]_2 ... P[O|model]_dim ]\n%%\n");
4136 fprintf(file,
"P=[");
4147 #define FLOATWRITE(file, value) { float32_t rrr=float32_t(value); fwrite(&rrr, sizeof(float32_t), 1, file); num_floats++;}
4151 int32_t i,j,q, num_floats=0 ;
4163 SG_INFO(
"wrote %i parameters for p\n",N)
4167 SG_INFO(
"wrote %i parameters for q\n",N)
4173 SG_INFO(
"wrote %i parameters for a\n",N*N)
4178 SG_INFO(
"wrote %i parameters for b\n",N*M)
4197 int32_t num_p, num_q, num_a, num_b ;
4205 SG_INFO(
"wrote %i parameters for p\n",num_p)
4210 SG_INFO(
"wrote %i parameters for q\n",num_q)
4222 SG_INFO(
"wrote %i parameters for a\n",num_a)
4233 SG_INFO(
"wrote %i parameters for b\n",num_b)
4257 fprintf(logfile,
"%% lambda denotes the model\n%% O denotes the observation sequence\n%% Q denotes the path\n%% \n%% calculating derivatives of P[O,Q|lambda]=p_{Q1}b_{Q1}(O_1}*a_{Q1}{Q2}b_{Q2}(O2)*...*q_{T-1}{T}b_{QT}(O_T}q_{Q_T} against p,q,a,b\n%%\n");
4258 fprintf(logfile,
"%% dPr[...]=[ [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_NN]\n");
4259 fprintf(logfile,
"%% [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_NN]\n");
4260 fprintf(logfile,
"%% ............................. \n");
4261 fprintf(logfile,
"%% [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_MM]\n");
4262 fprintf(logfile,
"%% ];\n%%\n\ndPr(log()) = [\n");
4271 fprintf(logfile,
"[ ");
4289 fseek(logfile,ftell(logfile)-1,SEEK_SET);
4290 fprintf(logfile,
" ];\n");
4293 fprintf(logfile,
"];");
4303 int32_t num_floats=0 ;
4307 SG_WARNING(
"No definitions loaded -- writing derivatives of all weights\n")
4309 SG_INFO(
"writing derivatives of changed weights only\n")
4385 int32_t num_floats=0 ;
4388 SG_WARNING(
"No definitions loaded -- writing derivatives of all weights\n")
4390 SG_INFO(
"writing derivatives of changed weights only\n")
4392 #ifdef USE_HMMPARALLEL
4394 pthread_t *threads=SG_MALLOC(pthread_t, num_threads);
4395 S_DIM_THREAD_PARAM *params=SG_MALLOC(S_DIM_THREAD_PARAM, num_threads);
4409 #ifdef USE_HMMPARALLEL
4410 if (dim%num_threads==0)
4412 for (i=0; i<num_threads; i++)
4414 if (dim+i<p_observations->get_num_vectors())
4416 params[i].hmm=this ;
4417 params[i].dim=dim+i ;
4418 pthread_create(&threads[i], NULL, bw_dim_prefetch, (
void*)¶ms[i]) ;
4422 for (i=0; i<num_threads; i++)
4424 if (dim+i<p_observations->get_num_vectors())
4425 pthread_join(threads[i], NULL);
4455 SG_INFO(
"Number of parameters (including posterior prob.): %i\n", num_floats)
4486 SG_INFO(
"Number of parameters (including posterior prob.): %i\n", num_floats)
4492 #ifdef USE_HMMPARALLEL
4510 fprintf(file,
"%% lambda denotes the model\n%% O denotes the observation sequence\n%% Q denotes the path\n%%\n%% calculating derivatives of P[O|lambda]=sum_{all Q}p_{Q1}b_{Q1}(O_1}*a_{Q1}{Q2}b_{Q2}(O2)*...*q_{T-1}{T}b_{QT}(O_T}q_{Q_T} against p,q,a,b\n%%\n");
4511 fprintf(file,
"%% dPr[...]=[ [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_NN]\n");
4512 fprintf(file,
"%% [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_NN]\n");
4513 fprintf(file,
"%% ............................. \n");
4514 fprintf(file,
"%% [dp_1,...,dp_N,dq_1,...,dq_N, da_11,da_12,..,da_1N,..,da_NN, db_11,.., db_MM]\n");
4515 fprintf(file,
"%% ];\n%%\n\nlog(dPr) = [\n");
4520 fprintf(file,
"[ ");
4538 fseek(file,ftell(file)-1,SEEK_SET);
4539 fprintf(file,
" ];\n");
4543 fprintf(file,
"];");
4589 for (int32_t j=0; j<
M; j++)
4593 set_b(i,j, log(exp(old_b)-delta)) ;
4597 set_b(i,j, log(exp(old_b)+delta)) ;
4601 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4611 SG_INFO(
"deriv_calc[%i]=%e\n",dim,deriv_calc)
4614 SG_ERROR(
"b(%i,%i)=%e db(%i,%i) = %e:%e\t (%1.5f%%)\n", i,j,exp(old_b),i,j, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4631 for (int32_t j=0; j<
N; j++)
4635 set_a(i,j, log(exp(old_a)-delta)) ;
4639 set_a(i,j, log(exp(old_a)+delta)) ;
4643 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4649 SG_DEBUG(
"da(%i,%i) = %e:%e\t (%1.5f%%)\n", i,j, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4655 for (int32_t j=0; j<
M; j++)
4659 set_b(i,j, log(exp(old_b)-delta)) ;
4663 set_b(i,j, log(exp(old_b)+delta)) ;
4667 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4673 SG_DEBUG(
"db(%i,%i) = %e:%e\t (%1.5f%%)\n", i,j, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/(deriv_calc))
4682 set_p(i, log(exp(old_p)-delta)) ;
4686 set_p(i, log(exp(old_p)+delta)) ;
4689 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4696 SG_DEBUG(
"dp(%i) = %e:%e\t (%1.5f%%)\n", i, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4702 set_q(i, log(exp(old_q)-delta)) ;
4706 set_q(i, log(exp(old_q)+delta)) ;
4710 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4717 SG_DEBUG(
"dq(%i) = %e:%e\t (%1.5f%%)\n", i, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4725 bool CHMM::check_path_derivatives()
4736 for (int32_t j=0; j<
N; j++)
4740 set_a(i,j, log(exp(old_a)-delta)) ;
4744 set_a(i,j, log(exp(old_a)+delta)) ;
4748 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4754 SG_DEBUG(
"da(%i,%i) = %e:%e\t (%1.5f%%)\n", i,j, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4759 for (int32_t j=0; j<
M; j++)
4763 set_b(i,j, log(exp(old_b)-delta)) ;
4767 set_b(i,j, log(exp(old_b)+delta)) ;
4771 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4777 SG_DEBUG(
"db(%i,%i) = %e:%e\t (%1.5f%%)\n", i,j, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/(deriv_calc))
4785 set_p(i, log(exp(old_p)-delta)) ;
4789 set_p(i, log(exp(old_p)+delta)) ;
4792 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4799 SG_DEBUG(
"dp(%i) = %e:%e\t (%1.5f%%)\n", i, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4805 set_q(i, log(exp(old_q)-delta)) ;
4809 set_q(i, log(exp(old_q)+delta)) ;
4813 float64_t deriv = (prob_new-prob_old)/(2*delta) ;
4820 SG_DEBUG(
"dq(%i) = %e:%e\t (%1.5f%%)\n", i, deriv_calc, deriv, 100.0*(deriv-deriv_calc)/deriv_calc)
4825 #endif // USE_HMMDEBUG
4866 const int32_t num_states=app_model->
get_N();
4880 for (i=0; i<N+num_states; i++)
4885 for (j=0; j<N+num_states; j++)
4902 n_a[(N+num_states)*j+i]=
get_a(i,j);
4906 n_b[M*i+j]=
get_b(i,j);
4911 for (i=0; i<app_model->
get_N(); i++)
4913 n_q[i+
N]=app_model->
get_q(i);
4915 for (j=0; j<app_model->
get_N(); j++)
4916 n_a[(N+num_states)*(j+
N)+(i+N)]=app_model->
get_a(i,j);
4917 for (j=0; j<app_model->
get_M(); j++)
4918 n_b[M*(i+N)+j]=app_model->
get_b(i,j);
4925 for (j=N; j<N+num_states; j++)
4945 SG_WARNING(
"not normalizing anymore, call normalize_hmm to make sure the hmm is valid!!\n")
4950 SG_ERROR(
"number of observations is different for append model, doing nothing!\n")
4958 const int32_t num_states=app_model->
get_N()+2;
4970 for (i=0; i<N+num_states; i++)
4975 for (j=0; j<N+num_states; j++)
4992 n_a[(N+num_states)*j+i]=
get_a(i,j);
4996 n_b[M*i+j]=
get_b(i,j);
5001 for (i=0; i<app_model->
get_N(); i++)
5003 n_q[i+N+2]=app_model->
get_q(i);
5005 for (j=0; j<app_model->
get_N(); j++)
5006 n_a[(N+num_states)*(j+N+2)+(i+N+2)]=app_model->
get_a(i,j);
5007 for (j=0; j<app_model->
get_M(); j++)
5008 n_b[M*(i+N+2)+j]=app_model->
get_b(i,j);
5016 n_b[M*N+i]=cur_out[i];
5017 n_b[M*(N+1)+i]=app_out[i];
5021 for (i=0; i<N+num_states; i++)
5025 n_a[(N+num_states)*i + N]=0;
5030 n_a[(N+num_states)*N+i]=
get_q(i);
5035 n_a[(N+num_states)*i+(N+1)]=app_model->
get_p(i-(N+2));
5054 SG_WARNING(
"not normalizing anymore, call normalize_hmm to make sure the hmm is valid!!\n")
5083 n_a[(N+num_states)*j+i]=
get_a(i,j);
5086 n_b[M*i+j]=
get_b(i,j);
5089 for (i=N; i<N+num_states; i++)
5097 for (j=0; j<N+num_states; j++)
5125 for (int32_t i=0; i<
N; i++)
5129 if (exp(
get_p(i)) < value)
5132 if (exp(
get_q(i)) < value)
5137 if (exp(
get_a(i,j)) < value)
5143 if (exp(
get_b(i,j)) < value)
5156 int32_t* hist=SG_MALLOC(int32_t, histsize);
5157 int32_t* startendhist=SG_MALLOC(int32_t,
get_N());
5162 for (i=0; i<histsize; i++)
5165 for (i=0; i<
get_N(); i++)
5177 startendhist[(
get_N()-len)]++;
5186 for (i=0; i<
get_N()-1; i++)
5189 for (i=0; i<
get_N(); i++)
5192 for (i=0;i<
get_N();i++)
5194 for (int32_t j=0; j<
get_N(); j++)
5213 hist[i*
get_M() + *obs++]++;
5215 startendhist[len-1]++;
5221 for (i=1; i<
get_N(); i++)
5224 for (i=0; i<
get_N(); i++)
5229 for (i=0;i<
get_N();i++)
5231 total-= startendhist[i] ;
5233 for (int32_t j=0; j<
get_N(); j++)
5244 for (i=0;i<
get_N();i++)
5246 for (int32_t j=0; j<
get_M(); j++)
5259 SG_FREE(startendhist);
5280 #ifdef USE_HMMPARALLEL_STRUCTURES
5304 #endif //USE_HMMPARALLEL_STRUCTURES
5336 #ifdef USE_HMMPARALLEL_STRUCTURES
5360 #endif //USE_HMMPARALLEL_STRUCTURES
5369 #ifdef USE_HMMPARALLEL_STRUCTURES
5382 #endif //USE_HMMPARALLEL_STRUCTURES
5389 #ifdef USE_HMMPARALLEL_STRUCTURES
5390 SG_INFO(
"allocating mem for path-table of size %.2f Megabytes (%d*%d) each:\n", ((
float32_t)max_T)*N*
sizeof(
T_STATES)/(1024*1024), max_T, N)
5394 SG_DEBUG(
"path_table[%i] successfully allocated\n",i)
5396 SG_ERROR(
"failed allocating memory for path_table[%i].\n",i)
5399 #else // no USE_HMMPARALLEL_STRUCTURES
5400 SG_INFO(
"allocating mem of size %.2f Megabytes (%d*%d) for path-table ....", ((
float32_t)max_T)*N*
sizeof(
T_STATES)/(1024*1024), max_T, N)
5407 #endif // USE_HMMPARALLEL_STRUCTURES
5411 #ifdef USE_HMMPARALLEL_STRUCTURES
5415 SG_DEBUG(
"alpha_cache[%i].table successfully allocated\n",i)
5417 SG_ERROR(
"allocation of alpha_cache[%i].table failed\n",i)
5420 SG_DEBUG(
"beta_cache[%i].table successfully allocated\n",i)
5422 SG_ERROR(
"allocation of beta_cache[%i].table failed\n",i)
5424 #else // USE_HMMPARALLEL_STRUCTURES
5426 SG_DEBUG(
"alpha_cache.table successfully allocated\n")
5428 SG_ERROR(
"allocation of alpha_cache.table failed\n")
5431 SG_DEBUG(
"beta_cache.table successfully allocated\n")
5433 SG_ERROR(
"allocation of beta_cache.table failed\n")
5435 #endif // USE_HMMPARALLEL_STRUCTURES
5436 #else // USE_HMMCACHE
5437 #ifdef USE_HMMPARALLEL_STRUCTURES
5443 #else //USE_HMMPARALLEL_STRUCTURES
5446 #endif //USE_HMMPARALLEL_STRUCTURES
5447 #endif //USE_HMMCACHE
5458 ( sequence_number<0 || sequence_number < p_observations->get_num_vectors()))
5460 int32_t min_sequence=sequence_number;
5461 int32_t max_sequence=sequence_number;
5463 if (sequence_number<0)
5467 SG_INFO(
"numseq: %d\n", max_sequence)
5470 SG_INFO(
"min_sequence: %d max_sequence: %d\n", min_sequence, max_sequence)
5471 for (sequence_number=min_sequence; sequence_number<max_sequence; sequence_number++)
5473 int32_t sequence_length=0;
5477 int32_t histsize=
get_M();
5478 int64_t* hist=SG_MALLOC(int64_t, histsize);
5481 for (i=0; i<sequence_length-window_width; i++)
5483 for (j=0; j<histsize; j++)
5486 uint16_t* ptr=&obs[i];
5487 for (j=0; j<window_width; j++)
5493 for (j=0; j<
get_M(); j++)
5498 perm_entropy+=p*log(p);
5517 else if (num_param<2*N)
5519 else if (num_param<N*(N+2))
5521 int32_t k=num_param-2*
N;
5526 else if (num_param<N*(N+2+M))
5528 int32_t k=num_param-N*(N+2);
5541 return get_p(num_param);
5542 else if (num_param<2*N)
5543 return get_q(num_param-N);
5544 else if (num_param<N*(N+2))
5546 else if (num_param<N*(N+2+M))
5608 if (prob_max<prob_train)
5609 prob_max=prob_train;
5612 if (estimate ==
this)
int32_t get_learn_p(int32_t offset) const
get entry out of learn_p vector
int32_t * learn_p
start states to be learned
virtual int32_t get_max_vector_length()
SGVector< ST > get_feature_vector(int32_t num)
void set_observation_nocache(CStringFeatures< uint16_t > *obs)
float64_t * transition_matrix_a
transition matrix
bool mod_prob_updated
true if model probability is up to date
void chop(float64_t value)
set any model parameter with probability smaller than value to ZERO
float64_t backward_comp(int32_t time, int32_t state, int32_t dimension)
int32_t N
number of states
void convert_to_log()
convert model to log probabilities
float64_t backward(int32_t time, int32_t state, int32_t dimension)
inline proxies for backward pass
float64_t get_const_p_val(int32_t offset) const
get value out of const_p_val vector
static const int32_t GOTp
bool save_likelihood(FILE *file)
void close_bracket(FILE *file)
expect closing bracket
static int is_finite(double f)
checks whether a float is finite
float64_t * const_a_val
values for transitions that have constant probability
Model()
Constructor - initializes all variables/structures.
void set_const_p(int32_t offset, int32_t value)
set value in const_p vector