void wrl::atom::save(app::node node)
{
const vec3 x = xvector(default_M);
const vec3 y = yvector(default_M);
const vec3 z = zvector(default_M);
const vec3 p = wvector(default_M);
const quat q(mat3(x, y, z));
// Add the entity transform to this element.
app::node n;
n = app::node("rot_x"); n.set_f(q[0]); n.insert(node);
n = app::node("rot_y"); n.set_f(q[1]); n.insert(node);
n = app::node("rot_z"); n.set_f(q[2]); n.insert(node);
n = app::node("rot_w"); n.set_f(q[3]); n.insert(node);
n = app::node("pos_x"); n.set_f(p[0]); n.insert(node);
n = app::node("pos_y"); n.set_f(p[1]); n.insert(node);
n = app::node("pos_z"); n.set_f(p[2]); n.insert(node);
if (body_id)
{
n = app::node("body");
n.set_i(body_id);
n.insert(node);
}
save_params(node);
}
/* ===================================================================*/
void flash_Init() {
if (ButtonPressed) {
// button pressed on power on -> Restore factory settings
set_led(TOPSIDE, 0, MAGENTA);
LEDred_ClrVal();
LEDblue_ClrVal();
write_ledColumn(TOPSIDE);
wait_ledColumn();
set_params();
save_params();
// initialize some images and scripts
images_Init();
script_Init();
while (!ButtonReleased) {
;
}
set_led(TOPSIDE, 0, BLACK);
LEDred_SetVal();
LEDblue_SetVal();
write_ledColumn(TOPSIDE);
wait_ledColumn();
} else {
get_params();
if (configParameter.valid == FLASH_RECORD_VALID) {
set_config();
} else {
// no valid data in Flash -> initialize from global variables
set_params();
save_params();
// initialize some images and scripts
images_Init();
script_Init();
}
}
}
/* Train model */
int train_glove() {
long long a, file_size;
int b;
FILE *fin;
real total_cost = 0;
fprintf(stderr, "TRAINING MODEL\n");
fin = fopen(input_file, "rb");
if(fin == NULL) {fprintf(stderr,"Unable to open cooccurrence file %s.\n",input_file); return 1;}
fseeko(fin, 0, SEEK_END);
file_size = ftello(fin);
num_lines = file_size/(sizeof(CREC)); // Assuming the file isn't corrupt and consists only of CREC's
fclose(fin);
fprintf(stderr,"Read %lld lines.\n", num_lines);
if(verbose > 1) fprintf(stderr,"Initializing parameters...");
initialize_parameters();
if(verbose > 1) fprintf(stderr,"done.\n");
if(verbose > 0) fprintf(stderr,"vector size: %d\n", vector_size);
if(verbose > 0) fprintf(stderr,"vocab size: %lld\n", vocab_size);
if(verbose > 0) fprintf(stderr,"x_max: %lf\n", x_max);
if(verbose > 0) fprintf(stderr,"alpha: %lf\n", alpha);
pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
lines_per_thread = (long long *) malloc(num_threads * sizeof(long long));
// Lock-free asynchronous SGD
for(b = 0; b < num_iter; b++) {
//fprintf(stderr,"iter: %d\n", b);
total_cost = 0;
for (a = 0; a < num_threads - 1; a++) lines_per_thread[a] = num_lines / num_threads;
lines_per_thread[a] = num_lines / num_threads + num_lines % num_threads;
for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, glove_thread, (void *)a);
//fprintf(stderr,"iter: %d started threads \n", b);
for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
//fprintf(stderr,"iter: %d done threads \n", b);
for (a = 0; a < num_threads; a++) total_cost += cost[a];
//for (a = 0; a < num_threads; a++) fprintf(stderr,"T: %d, cost: %lf\n",a,cost[a]);
fprintf(stderr,"iter: %03d, cost: %lf\n", b+1, total_cost/num_lines);
}
//fprintf(stderr,"returning to save params");
return save_params();
}
/* ===================================================================*/
void set_Mode() {
windowT win;
operating_mode = MODE_BUTTON;
clear_leds(TOPSIDE);
LEDred_SetVal();
LEDgreen_SetVal();
LEDblue_SetVal();
// button pressed
while (! ButtonReleased) {
// wait till button released
wait_10ms(2);
}
if (ButtonLongPressed) {
ButtonLongPressed = FALSE;
// toggle low energy mode
if (energy_mode == ENERGY_LOW || energy_mode == ENERGY_ALWAYS_ON) {
if (energy_mode == ENERGY_LOW) {
energy_mode = ENERGY_STANDARD;
}
set_led(TOPSIDE, LED1, WHITE);
LEDred_ClrVal();
LEDgreen_ClrVal();
LEDblue_ClrVal();
oled_setState(OLED_ON);
} else {
energy_mode = ENERGY_LOW;
set_led(TOPSIDE, LED1, YELLOW);
LEDred_ClrVal();
LEDgreen_ClrVal();
oled_setState(OLED_OFF);
}
write_ledColumn(TOPSIDE);
wait_10ms(100);
clear_leds(TOPSIDE);
LEDred_SetVal();
LEDgreen_SetVal();
LEDblue_SetVal();
write_ledColumn(TOPSIDE);
wait_ledColumn();
ButtonReleased = FALSE;
ButtonPressed = FALSE;
ButtonLongPressed = FALSE;
} else {
// start/stop trip
ButtonPressed = FALSE;
ButtonReleased = FALSE;
if (tripMode == TRIP_STOPPED) {
// stopped -> start trip
tripMode = TRIP_STARTED;
chronoMode = TRIP_STARTED;
set_led(TOPSIDE, LED1, GREEN);
LEDgreen_ClrVal();
} else {
// started (or paused) -> stop trip
tripMode = TRIP_STOPPED;
chronoMode = TRIP_STOPPED;
set_led(TOPSIDE, LED1, RED);
LEDred_ClrVal();
// save the configuration and data
set_params();
save_params();
}
write_ledColumn(TOPSIDE);
wait_10ms(100);
if (ButtonPressed) {
// reset trip
set_led(TOPSIDE, LED1, BLUE);
LEDblue_ClrVal();
LEDred_SetVal();
LEDgreen_SetVal();
write_ledColumn(TOPSIDE);
tripDistance = 0.0;
maxSpeed = 0.0;
avgSpeed = 0.0;
tripElevationGain = 0.0;
maxAltitude = 0.0;
chronoTime = 0.0;
tripTime = 0.0;
while (! ButtonReleased) {
// wait till button released
wait_10ms(2);
}
ButtonPressed = FALSE;
ButtonReleased = FALSE;
ButtonLongPressed = FALSE;
wait_10ms(100);
}
clear_leds(TOPSIDE);
write_ledColumn(TOPSIDE);
wait_ledColumn();
}
operating_mode = NORMAL;
}
uchar setup_dstout(uchar para)
{
uchar status = 0, disp_stat = 0, i;
uchar incr_step = 0;
unsigned int val;
unsigned long *src,*dst;
status = 0;
disp_stat = 1;
val = SetupImg.Timer[para].dst_out;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
RTclock.timer = 1000; //4sec
while((RTclock.timer2 > 0)&&(status < 2))
{
if(disp_stat == 1)
{
if(status != 0)
lcd_write_cmd (0x0F); /* Display ctrl:Disp=ON,Curs/Blnk=ON */
set_cursor (0, 0);
sprintf(str,"TIMER%d CHANNEL ",para);
lcd_print ((const unsigned char*)str);
set_cursor (0, 1);
if ( val > 5)
sprintf(str,"DISABLED ");
else
sprintf(str,"%s ",out_names[val]);
lcd_print ((const unsigned char*)str);
if(status != 0)
set_cursor (1, 1);
disp_stat = 0;
}
switch(get_evnt_queue())
{
// case WE_MODE:
// lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
// status = 2;
// break;
case WE_ENTER:
status++;
if(status > 1)
{
SetupImg.Timer[para].dst_out = val;
save_params();
// /* put checksum to the last halfword */
// ((unsigned short*)&SetupImg)[sizeof(SetupImg_t)/2 - 1] = crc16((unsigned char*)&SetupImg, sizeof(SetupImg_t) - 2);
// src = (unsigned long*)&SetupImg;
// dst = (unsigned long*)&BSR_setup_img_t;
// for(i = 0;i<sizeof(SetupImg_t)/4;i++,dst++,src++)
// *dst = *src;
//// memcpy(BSR_setup_img_t,SetupImg,sizeof(SetupImg_t));
status = 0;
lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
}
disp_stat = 1;
break;
case WE_UPHLD:
incr_step = TRUE;
case WE_UPKEY:
if(status == 1)
{
if(val < 7)
val++;
else
val=0;
}
disp_stat = 1;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
break;
case WE_DWNHLD:
incr_step = TRUE;
case WE_DWNKEY:
if(status == 1)
{
if(val > 0)
val--;
else
val=7;
}
disp_stat = 1;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
break;
// case WE_UPDWNREL:
// incr_step = 0;
// RTclock.timer2 = SETUP_TOUT_MS; //4sec
// break;
default:
break;
}
}
lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
return 0;
}
uchar setup_end(uchar para)
{
uchar status = 0, disp_stat = 0, i;
uchar incr_step = 0;
unsigned int val;
unsigned long *src,*dst;
RTCTime timeval;
status = 0;
disp_stat = 1;
timeval.RTC_Hour = SetupImg.Timer[para].end/3600;
val = SetupImg.Timer[para].end%3600 ;
timeval.RTC_Min = val/60;
timeval.RTC_Sec = val%60;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
RTclock.timer = 1000; //4sec
while((RTclock.timer2 > 0)&&(status < 4))
{
if(disp_stat == 1)
{
if(status != 0)
lcd_write_cmd (0x0F); /* Display ctrl:Disp=ON,Curs/Blnk=ON */
set_cursor (0, 0);
sprintf(str,"TIMER1 END ");
lcd_print ((const unsigned char*)str);
set_cursor (0, 1);
sprintf(str,"%02d:%02d:%02d ",timeval.RTC_Hour,timeval.RTC_Min,timeval.RTC_Sec);
lcd_print ((const unsigned char*)str);
if(status>2)
set_cursor (7, 1);
else if(status>1)
set_cursor (4, 1);
else if(status>0)
set_cursor (1, 1);
disp_stat = 0;
}
switch(get_evnt_queue())
{
// case WE_MODE:
// lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
// status = 4;
// break;
case WE_ENTER:
status++;
if(status == 3)
timeval.RTC_Sec = 0;
if(status > 3)
{
SetupImg.Timer[para].end = timeval.RTC_Hour*60*60+ timeval.RTC_Min*60 + timeval.RTC_Sec;
save_params();
// /* put checksum to the last halfword */
// ((unsigned short*)&SetupImg)[sizeof(SetupImg_t)/2 - 1] = crc16((unsigned char*)&SetupImg, sizeof(SetupImg_t) - 2);
// src = (unsigned long*)&SetupImg;
// dst = (unsigned long*)&BSR_setup_img_t;
// for(i = 0;i<sizeof(SetupImg_t)/4;i++,dst++,src++)
// *dst = *src;
//// memcpy(BSR_setup_img_t,SetupImg,sizeof(SetupImg_t));
status = 0;
lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
}
disp_stat = 1;
break;
case WE_UPHLD:
incr_step = TRUE;
case WE_UPKEY:
if(status == 1)
{
if((timeval.RTC_Hour) < 23)
timeval.RTC_Hour++;
}
else if(status == 2)
{
if((timeval.RTC_Min) < 59)
timeval.RTC_Min++;
}
else if(status == 3)
{
if((timeval.RTC_Sec) < 59)
timeval.RTC_Sec++;
}
disp_stat = 1;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
break;
case WE_DWNHLD:
incr_step = TRUE;
case WE_DWNKEY:
if(status == 1)
{
if((timeval.RTC_Hour) > 0)
timeval.RTC_Hour--;
}
else if(status == 2)
{
if((timeval.RTC_Min) > 0)
timeval.RTC_Min--;
}
else if(status == 3)
{
if((timeval.RTC_Sec) > 0)
timeval.RTC_Sec--;
}
disp_stat = 1;
RTclock.timer2 = SETUP_TOUT_MS; //4sec
break;
// case WE_UPDWNREL:
// incr_step = 0;
// RTclock.timer2 = SETUP_TOUT_MS; //4sec
// break;
default:
break;
}
}
lcd_write_cmd (0x0C); /* Display ctrl:Disp=ON,Curs/Blnk=OFF */
return 0;
}
/* main loop */
static int run_grd(CRF_ENG_PTR crf_ptr) {
int r,iterate,old_valid,converged,conv_time,saved = 0;
double likelihood,old_likelihood = 0.0;
double crf_max_iterate = 0.0;
double tmp_epsilon,alpha0,gf_sd,old_gf_sd = 0.0;
config_crf(crf_ptr);
initialize_weights();
if (crf_learn_mode == 1) {
initialize_LBFGS();
printf("L-BFGS mode\n");
}
if (crf_learning_rate==1) {
printf("learning rate:annealing\n");
} else if (crf_learning_rate==2) {
printf("learning rate:backtrack\n");
} else if (crf_learning_rate==3) {
printf("learning rate:golden section\n");
}
if (max_iterate == -1) {
crf_max_iterate = DEFAULT_MAX_ITERATE;
} else if (max_iterate >= +1) {
crf_max_iterate = max_iterate;
}
for (r = 0; r < num_restart; r++) {
SHOW_PROGRESS_HEAD("#crf-iters", r);
initialize_crf_count();
initialize_lambdas();
initialize_visited_flags();
old_valid = 0;
iterate = 0;
tmp_epsilon = crf_epsilon;
LBFGS_index = 0;
conv_time = 0;
while (1) {
if (CTRLC_PRESSED) {
SHOW_PROGRESS_INTR();
RET_ERR(err_ctrl_c_pressed);
}
RET_ON_ERR(crf_ptr->compute_feature());
crf_ptr->compute_crf_probs();
likelihood = crf_ptr->compute_likelihood();
if (verb_em) {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\n", iterate, likelihood);
}
if (debug_level) {
prism_printf("After I-step[%d]:\n", iterate);
prism_printf("likelihood = %.9f\n", likelihood);
print_egraph(debug_level, PRINT_EM);
}
if (!isfinite(likelihood)) {
emit_internal_error("invalid log likelihood: %s (at iteration #%d)",
isnan(likelihood) ? "NaN" : "infinity", iterate);
RET_ERR(ierr_invalid_likelihood);
}
/* if (old_valid && old_likelihood - likelihood > prism_epsilon) {
emit_error("log likelihood decreased [old: %.9f, new: %.9f] (at iteration #%d)",
old_likelihood, likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}*/
if (likelihood > 0.0) {
emit_error("log likelihood greater than zero [value: %.9f] (at iteration #%d)",
likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}
if (crf_learn_mode == 1 && iterate > 0) restore_old_gradient();
RET_ON_ERR(crf_ptr->compute_gradient());
if (crf_learn_mode == 1 && iterate > 0) {
compute_LBFGS_y_rho();
compute_hessian(iterate);
} else if (crf_learn_mode == 1 && iterate == 0) {
initialize_LBFGS_q();
}
converged = (old_valid && fabs(likelihood - old_likelihood) <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_likelihood = likelihood;
old_valid = 1;
if (debug_level) {
prism_printf("After O-step[%d]:\n", iterate);
print_egraph(debug_level, PRINT_EM);
}
SHOW_PROGRESS(iterate);
if (crf_learning_rate == 1) { // annealing
tmp_epsilon = (annealing_weight / (annealing_weight + iterate)) * crf_epsilon;
} else if (crf_learning_rate == 2) { // line-search(backtrack)
if (crf_learn_mode == 1) {
gf_sd = compute_gf_sd_LBFGS();
} else {
gf_sd = compute_gf_sd();
}
if (iterate==0) {
alpha0 = 1;
} else {
alpha0 = tmp_epsilon * old_gf_sd / gf_sd;
}
if (crf_learn_mode == 1) {
tmp_epsilon = line_search_LBFGS(crf_ptr,alpha0,crf_ls_rho,crf_ls_c1,likelihood,gf_sd);
} else {
tmp_epsilon = line_search(crf_ptr,alpha0,crf_ls_rho,crf_ls_c1,likelihood,gf_sd);
}
if (tmp_epsilon < EPS) {
emit_error("invalid alpha in line search(=0.0) (at iteration #%d)",iterate);
RET_ERR(err_line_search);
}
old_gf_sd = gf_sd;
} else if (crf_learning_rate == 3) { // line-search(golden section)
if (crf_learn_mode == 1) {
tmp_epsilon = golden_section_LBFGS(crf_ptr,0,crf_golden_b);
} else {
tmp_epsilon = golden_section(crf_ptr,0,crf_golden_b);
}
}
crf_ptr->update_lambdas(tmp_epsilon);
iterate++;
}
SHOW_PROGRESS_TAIL(converged, iterate, likelihood);
if (r == 0 || likelihood > crf_ptr->likelihood) {
crf_ptr->likelihood = likelihood;
crf_ptr->iterate = iterate;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (crf_learn_mode == 1) clean_LBFGS();
INIT_VISITED_FLAGS;
return BP_TRUE;
}
/* Train model */
int train_glove() {
long long a, file_size;
int save_params_return_code;
int b;
FILE *fin;
real total_cost = 0;
fprintf(stderr, "TRAINING MODEL\n");
fin = fopen(input_file, "rb");
if (fin == NULL) {fprintf(stderr,"Unable to open cooccurrence file %s.\n",input_file); return 1;}
fseeko(fin, 0, SEEK_END);
file_size = ftello(fin);
num_lines = file_size/(sizeof(CREC)); // Assuming the file isn't corrupt and consists only of CREC's
fclose(fin);
fprintf(stderr,"Read %lld lines.\n", num_lines);
if (verbose > 1) fprintf(stderr,"Initializing parameters...");
initialize_parameters();
if (verbose > 1) fprintf(stderr,"done.\n");
if (verbose > 0) fprintf(stderr,"vector size: %d\n", vector_size);
//!@#$%^&*
if (verbose > 0) fprintf(stderr,"words size: %lld\n", words_size);
if (verbose > 0) fprintf(stderr,"contexts size: %lld\n", contexts_size);
if (verbose > 0) fprintf(stderr,"x_max: %lf\n", x_max);
if (verbose > 0) fprintf(stderr,"alpha: %lf\n", alpha);
pthread_t *pt = (pthread_t *)malloc(num_threads * sizeof(pthread_t));
lines_per_thread = (long long *) malloc(num_threads * sizeof(long long));
time_t rawtime;
struct tm *info;
char time_buffer[80];
// Lock-free asynchronous SGD
for (b = 0; b < num_iter; b++) {
total_cost = 0;
for (a = 0; a < num_threads - 1; a++) lines_per_thread[a] = num_lines / num_threads;
lines_per_thread[a] = num_lines / num_threads + num_lines % num_threads;
long long *thread_ids = (long long*)malloc(sizeof(long long) * num_threads);
for (a = 0; a < num_threads; a++) thread_ids[a] = a;
for (a = 0; a < num_threads; a++) pthread_create(&pt[a], NULL, glove_thread, (void *)&thread_ids[a]);
for (a = 0; a < num_threads; a++) pthread_join(pt[a], NULL);
for (a = 0; a < num_threads; a++) total_cost += cost[a];
free(thread_ids);
time(&rawtime);
info = localtime(&rawtime);
strftime(time_buffer,80,"%x - %I:%M.%S%p", info);
fprintf(stderr, "%s, iter: %03d, cost: %lf\n", time_buffer, b+1, total_cost/num_lines);
if (checkpoint_every > 0 && (b + 1) % checkpoint_every == 0) {
fprintf(stderr," saving itermediate parameters for iter %03d...", b+1);
save_params_return_code = save_params(b+1);
if (save_params_return_code != 0)
return save_params_return_code;
fprintf(stderr,"done.\n");
}
}
free(pt);
free(lines_per_thread);
return save_params(0);
}
/* ===================================================================*/
void clear_params() {
configParameter.valid = 0;
save_params();
}
void save_params(FILE* ofile) {
save_params(ofile, n_examples);
}
int main(int argc, char **argv)
{
LR_PARAM input_params;
long int i,j, m, d;
double *w, *Y, **X, precision, *h, Erreur, Precision, Rappel, F, PosPred, PosEffect, PosEffPred;
char input_filename[200], params_filename[200];
srand(time(NULL));
// Reading the parameters line
lire_commande(&input_params,input_filename, params_filename,argc, argv);
// Scan of the training file
// definition in utilitaire.c
FileScan(input_filename,&m,&d);
printf("Training set containing %ld examples in dimension %ld\n",m,d);
Y = (double *) malloc((m+1)*sizeof(double ));
X = (double **) malloc((m+1)*sizeof(double *));
if(!X){
printf("Memory allocation problem (1)\n");
exit(0);
}
X[1]=(double *)malloc((size_t)((m*d+1)*sizeof(double)));
if(!X[1]){
printf("Memory allocation problem (2)\n");
exit(0);
}
for(i=2; i<=m; i++)
X[i]=X[i-1]+d;
w = (double *) malloc((d+1) * sizeof(double ));
// Loading of the data matrix procedure defined in utilitaire.c
ChrgMatrix(input_filename, m, d, X, Y);
// Adaline algorithm
adaline(X, Y, w, m, d, input_params.eta, input_params.T);
h = (double *) malloc((m+1)*sizeof(double ));
for(i=1; i<=m; i++)
/*@$\rhd h_t(\mathbf{x}_i)\leftarrow w^{(t)}_0+\left\langle \boldsymbol w^{(t)},\mathbf{x}_i\right\rangle$@*/
for(h[i]=w[0], j=1; j<=d; j++)
h[i]+=(w[j]*X[i][j]);
for(i = 1, Erreur = 0.0; i <= m; ++i) {
Erreur += (Y[i] - h[i]) * (Y[i] - h[i]);
}
Erreur /= (double)m;
printf("Erreur=%lf\n", Erreur);
/*
for(i=1,PosPred=PosEffect=PosEffPred=Erreur=0.0; i<=m; i++){
if(Y[i]*h[i]<=0.0)
Erreur+=1.0;
if(Y[i]==1.0){
PosEffect++;
if(h[i]>0.0)
PosEffPred++;
}
if(h[i]>0.0)
PosPred++;
}
Erreur/=(double)m;
Precision=PosEffPred/PosPred;
Rappel=PosEffPred/PosEffect;
F=2.0*Precision*Rappel/(Precision+Rappel);
printf("Precision:%lf Recall:%lf F1-measure:%lf Error=%lf\n",Precision,Rappel,F,Erreur);
*/
free((char *)h);
save_params(params_filename, w,d);
return 1;
}
int run_em(EM_ENG_PTR em_ptr)
{
int r, iterate, old_valid, converged, saved = 0;
double likelihood, log_prior;
double lambda, old_lambda = 0.0;
config_em(em_ptr);
for (r = 0; r < num_restart; r++) {
SHOW_PROGRESS_HEAD("#em-iters", r);
initialize_params();
itemp = daem ? itemp_init : 1.0;
iterate = 0;
/* [21 Aug 2007, by yuizumi]
* while-loop for inversed temperature (DAEM). Note that this
* loop is evaluated only once for EM without annealing, since
* itemp initially set to 1.0 by the code above.
*/
while (1) {
if (daem) {
SHOW_PROGRESS_TEMP(itemp);
}
old_valid = 0;
while (1) {
if (CTRLC_PRESSED) {
SHOW_PROGRESS_INTR();
RET_ERR(err_ctrl_c_pressed);
}
RET_ON_ERR(em_ptr->compute_inside());
RET_ON_ERR(em_ptr->examine_inside());
likelihood = em_ptr->compute_likelihood();
log_prior = em_ptr->smooth ? em_ptr->compute_log_prior() : 0.0;
lambda = likelihood + log_prior;
if (verb_em) {
if (em_ptr->smooth) {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\tlog_prior=%.9f\tlog_post=%.9f\n", iterate, likelihood, log_prior, lambda);
}
else {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\n", iterate, likelihood);
}
}
if (debug_level) {
prism_printf("After I-step[%d]:\n", iterate);
prism_printf("likelihood = %.9f\n", likelihood);
print_egraph(debug_level, PRINT_EM);
}
if (!isfinite(lambda)) {
emit_internal_error("invalid log likelihood or log post: %s (at iteration #%d)",
isnan(lambda) ? "NaN" : "infinity", iterate);
RET_ERR(ierr_invalid_likelihood);
}
if (old_valid && old_lambda - lambda > prism_epsilon) {
emit_error("log likelihood or log post decreased [old: %.9f, new: %.9f] (at iteration #%d)",
old_lambda, lambda, iterate);
RET_ERR(err_invalid_likelihood);
}
if (itemp == 1.0 && likelihood > 0.0) {
emit_error("log likelihood greater than zero [value: %.9f] (at iteration #%d)",
likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}
converged = (old_valid && lambda - old_lambda <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_lambda = lambda;
old_valid = 1;
RET_ON_ERR(em_ptr->compute_expectation());
if (debug_level) {
prism_printf("After O-step[%d]:\n", iterate);
print_egraph(debug_level, PRINT_EM);
}
SHOW_PROGRESS(iterate);
RET_ON_ERR(em_ptr->update_params());
iterate++;
}
/* [21 Aug 2007, by yuizumi]
* Note that 1.0 can be represented exactly in IEEE 754.
*/
if (itemp == 1.0) {
break;
}
itemp *= itemp_rate;
if (itemp >= 1.0) {
itemp = 1.0;
}
}
SHOW_PROGRESS_TAIL(converged, iterate, lambda);
if (r == 0 || lambda > em_ptr->lambda) {
em_ptr->lambda = lambda;
em_ptr->likelihood = likelihood;
em_ptr->iterate = iterate;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (saved) {
restore_params();
}
em_ptr->bic = compute_bic(em_ptr->likelihood);
em_ptr->cs = em_ptr->smooth ? compute_cs(em_ptr->likelihood) : 0.0;
return BP_TRUE;
}
int mpm_run_em(EM_ENG_PTR emptr) {
int r, iterate, old_valid, converged, saved=0;
double likelihood, log_prior;
double lambda, old_lambda=0.0;
config_em(emptr);
for (r = 0; r < num_restart; r++) {
SHOW_PROGRESS_HEAD("#em-iters", r);
initialize_params();
mpm_bcast_inside();
clear_sw_msg_send();
itemp = daem ? itemp_init : 1.0;
iterate = 0;
while (1) {
if (daem) {
SHOW_PROGRESS_TEMP(itemp);
}
old_valid = 0;
while (1) {
if (CTRLC_PRESSED) {
SHOW_PROGRESS_INTR();
RET_ERR(err_ctrl_c_pressed);
}
if (failure_observed) {
inside_failure = mp_sum_value(0.0);
}
log_prior = emptr->smooth ? emptr->compute_log_prior() : 0.0;
lambda = mp_sum_value(log_prior);
likelihood = lambda - log_prior;
mp_debug("local lambda = %.9f, lambda = %.9f", log_prior, lambda);
if (verb_em) {
if (emptr->smooth) {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\tlog_prior=%.9f\tlog_post=%.9f\n", iterate, likelihood, log_prior, lambda);
} else {
prism_printf("Iteration #%d:\tlog_likelihood=%.9f\n", iterate, likelihood);
}
}
if (!isfinite(lambda)) {
emit_internal_error("invalid log likelihood or log post: %s (at iterateion #%d)",
isnan(lambda) ? "NaN" : "infinity", iterate);
RET_ERR(ierr_invalid_likelihood);
}
if (old_valid && old_lambda - lambda > prism_epsilon) {
emit_error("log likelihood or log post decreased [old: %.9f, new: %.9f] (at iteration #%d)",
old_lambda, lambda, iterate);
RET_ERR(err_invalid_likelihood);
}
if (itemp == 1.0 && likelihood > 0.0) {
emit_error("log likelihood greater than zero [value: %.9f] (at iteration #%d)",
likelihood, iterate);
RET_ERR(err_invalid_likelihood);
}
converged = (old_valid && lambda - old_lambda <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_lambda = lambda;
old_valid = 1;
mpm_share_expectation();
SHOW_PROGRESS(iterate);
RET_ON_ERR(emptr->update_params());
iterate++;
}
if (itemp == 1.0) {
break;
}
itemp *= itemp_rate;
if (itemp >= 1.0) {
itemp = 1.0;
}
}
SHOW_PROGRESS_TAIL(converged, iterate, lambda);
if (r == 0 || lambda > emptr->lambda) {
emptr->lambda = lambda;
emptr->likelihood = likelihood;
emptr->iterate = iterate;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (saved) {
restore_params();
}
emptr->bic = compute_bic(emptr->likelihood);
emptr->cs = emptr->smooth ? compute_cs(emptr->likelihood) : 0.0;
return BP_TRUE;
}
int mps_run_em(EM_ENG_PTR emptr) {
int r, iterate, old_valid, converged, saved=0;
double likelihood;
double lambda, old_lambda=0.0;
config_em(emptr);
for (r = 0; r < num_restart; r++) {
mps_bcast_inside();
clear_sw_msg_send();
itemp = daem ? itemp_init : 1.0;
iterate = 0;
while (1) {
old_valid = 0;
while (1) {
RET_ON_ERR(emptr->compute_inside());
RET_ON_ERR(emptr->examine_inside());
if (failure_observed) {
inside_failure = mp_sum_value(inside_failure);
}
likelihood = emptr->compute_likelihood();
lambda = mp_sum_value(likelihood);
mp_debug("local lambda = %.9f, lambda = %.9f", likelihood, lambda);
converged = (old_valid && lambda - old_lambda <= prism_epsilon);
if (converged || REACHED_MAX_ITERATE(iterate)) {
break;
}
old_lambda = lambda;
old_valid = 1;
RET_ON_ERR(emptr->compute_expectation());
mps_share_expectation();
RET_ON_ERR(emptr->update_params());
iterate++;
}
if (itemp == 1.0) {
break;
}
itemp *= itemp_rate;
if (itemp >= 1.0) {
itemp = 1.0;
}
}
if (r == 0 || lambda > emptr->lambda) {
emptr->lambda = lambda;
saved = (r < num_restart - 1);
if (saved) {
save_params();
}
}
}
if (saved) {
restore_params();
}
return BP_TRUE;
}
