bool MyEventListener::update(IEvents &events, ssi_size_t n_new_events, ssi_size_t time_ms) { EventAddress ea; ssi_event_t *e = 0; for (ssi_size_t i = 0; i < n_new_events; i++) { e = events.next(); ea.clear(); ea.setSender(Factory::GetString(e->sender_id)); ea.setEvents(Factory::GetString(e->event_id)); ssi_print("received event %s of type %s at %ums for %ums\n", ea.getAddress(), SSI_ETYPE_NAMES[e->type], e->time, e->dur); if (e->type == SSI_ETYPE_FLOATS) { ssi_real_t *ptr = ssi_pcast(ssi_real_t, e->ptr); ssi_size_t n = e->tot / sizeof(ssi_real_t); for (ssi_size_t j = 0; j < n; j++) { ssi_print("%.2f ", *ptr++); } ssi_print("\n"); } } return true; }
void QRSDetection::sendEvent_h(ITransformer::info &info, ssi_time_t sample_rate, ssi_size_t frame_count, ssi_size_t sample_number){ ssi_size_t samples_per_frame = info.frame_num; ssi_size_t frame_time = ssi_sec2ms (info.time); ssi_real_t time_per_sample = 1000.0f / (ssi_real_t) sample_rate; ssi_size_t current_sample = frame_count * samples_per_frame + sample_number; ssi_size_t current_sample_time = ssi_cast (ssi_size_t, current_sample * time_per_sample + 0.5); if (_listener) { _r_event.time = current_sample_time; _r_event.dur = ssi_cast (ssi_size_t, time_per_sample + 0.5); if(_send_etuple) { ssi_event_map_t *ptr = ssi_pcast (ssi_event_map_t, _r_event.ptr); ptr[0].value = ssi_real_t (current_sample_time - _last_R); } else { ssi_real_t *ptr = ssi_pcast (ssi_real_t, _r_event.ptr); ptr[0] = ssi_real_t(current_sample_time - _last_R); } _listener->update (_r_event); } else { ssi_print("\nR-spike detected in \n\tframe number %u with starting time %u ms", frame_count, frame_time); ssi_print("\n\tat sample number %u at time %u ms", current_sample, current_sample_time); } _last_R = current_sample_time; }
void EVector::print(){ ssi_print("'%d'\t\t'%d'\t\t'%0.2f'\t", _creation_time, _lifetime, _norm); for(ssi_size_t i = 0; i < _dim; i++){ ssi_print("%0.2f ", _value[i]); }ssi_print("\n\t\t\t\t\t'%0.2f'\t", _norm_decay); for(ssi_size_t i = 0; i < _dim; i++){ ssi_print("%0.2f ", _value_decay[i]); }ssi_print("\n"); }
bool FileReader::wait() { if (_options.loop) { ssi_print("\n"); ssi_print_off("press enter to stop\n\n"); getchar(); } else { _event.wait(); } return !_interrupted; }
bool MajorityVoting::forward (ssi_size_t n_models, IModel **models, ssi_size_t n_streams, ssi_stream_t *streams[], ssi_size_t n_probs, ssi_real_t *probs) { if (n_streams != _n_streams) { ssi_wrn ("#streams (%u) differs from #streams (%u)", n_streams, _n_streams); return false; } if (_n_streams != n_models) { ssi_wrn ("#models (%u) differs from #streams (%u)", n_models, _n_streams); return false; } if (_n_classes != n_probs) { ssi_wrn ("#probs (%u) differs from #classes (%u)", n_probs ,_n_classes); return false; } bool found_data = false; IModel *model = 0; ssi_stream_t *stream = 0; //calculate actual models ssi_size_t miss_counter = 0; ssi_size_t *available = new ssi_size_t[n_models]; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { stream = streams[n_model]; if (stream->num > 0) { found_data = true; available[n_model] = 1; } else{ miss_counter++; available[n_model] = 0; } } ssi_size_t counter = 0; ssi_size_t *models_actual = new ssi_size_t[(n_models - miss_counter)]; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { if(available[n_model] == 1){ models_actual[counter] = n_model; counter++; } } if(found_data){ ssi_size_t *votes = new ssi_size_t[(n_models - miss_counter)]; for (ssi_size_t n_model = 0; n_model < (n_models - miss_counter); n_model++) { model = models[models_actual[n_model]]; stream = streams[models_actual[n_model]]; model->forward (*stream, n_probs, probs); ssi_size_t max_ind = 0; ssi_real_t max_val = probs[0]; for (ssi_size_t i = 1; i < n_probs; i++) { if (probs[i] > max_val) { max_val = probs[i]; max_ind = i; } } votes[n_model] = max_ind; if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){ ssi_print("%f ", probs[num_probs]); }ssi_print("- vote: %d\n", max_ind); } } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\n"); } //clear probs for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){ probs[num_probs] = 0; } //fill probs with votes for(ssi_size_t n_model = 0; n_model < (n_models - miss_counter); n_model++){ probs[votes[n_model]]++; } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){ ssi_print("%f ", probs[num_probs]); }ssi_print("\n\n"); } if(votes){ delete[] votes; votes = 0; } if(available){ delete [] available; available = 0; } if(models_actual){ delete [] models_actual; models_actual = 0; } } /// is there a draw ? /// ssi_size_t max_ind = 0; ssi_size_t max_ind_draw = 0; ssi_real_t max_val = probs[0]; bool draw = false; for (ssi_size_t i = 1; i < n_probs; i++) { if (probs[i] >= max_val) { if(probs[i] == max_val){ draw = true; max_ind_draw = i; } max_val = probs[i]; max_ind = i; } } if(draw && (max_ind == max_ind_draw)){ return false; }else{ return found_data; } }
bool FileSamplesOut::write (ssi_sample_t &data) { if (data.num != _n_streams) { ssi_wrn ("#streams differs ('%u' != '%u')", data.num, _n_streams); return false; } for (ssi_size_t i = 0; i < _n_streams; i++) { if (data.streams[i]->byte != _streams[i].byte || data.streams[i]->dim != _streams[i].dim || data.streams[i]->type != _streams[i].type) { ssi_wrn ("stream is not compatible"); return false; } } if (data.class_id >= _n_classes && data.class_id != SSI_ISAMPLES_GARBAGE_CLASS_ID) { ssi_wrn ("class id '%u' exceeds #classes '%u')", data.class_id, _n_classes); return false; } if (data.user_id >= _n_users) { ssi_wrn ("user id '%u' exceeds #users '%u')", data.user_id, _n_users); return false; } if (_console) { ssi_print ("class=%u user=%u time=%.2lf prob=%.2f\n", data.class_id, data.user_id, data.time, data.prob); } else { _n_samples++; if (data.class_id == SSI_ISAMPLES_GARBAGE_CLASS_ID) { _n_garbage_class++; } else { _n_per_class[data.class_id]++; } _n_per_user[data.user_id]++; switch (_version) { case File::V2: { if (_file_data->getType () == File::ASCII) { sprintf (_string, "%u %u %lf %.2f %u", data.user_id, data.class_id, data.time, data.prob, data.num); _file_data->writeLine (_string); } else { _file_data->write (&data.user_id, sizeof (data.user_id), 1); _file_data->write (&data.class_id, sizeof (data.class_id), 1); _file_data->write (&data.time, sizeof (data.time), 1); _file_data->write (&data.prob, sizeof (data.prob), 1); _file_data->write (&data.num, sizeof (data.num), 1); } for (ssi_size_t i = 0; i < _n_streams; i++) { ssi_stream_t &stream = *data.streams[i]; if (_file_data->getType () == File::ASCII) { sprintf (_string, "%u", stream.num); _file_data->writeLine (_string); if (stream.num > 0) { _file_data->setType (stream.type); _file_data->write (stream.ptr, stream.dim, stream.num * stream.dim); } else { _has_missing_data = true; } } else { _file_data->write (&stream.num, sizeof (stream.num), 1); if (stream.num > 0) { _file_data->write (stream.ptr, sizeof (ssi_byte_t), stream.tot); } else { _has_missing_data = true; } } } } break; case File::V3: { if (_file_data->getType () == File::ASCII) { sprintf (_string, "%u %d %.2f %lf", data.user_id, data.class_id, data.prob, data.time); _file_data->writeLine (_string); } else { _file_data->write (&data.user_id, sizeof (data.user_id), 1); _file_data->write (&data.class_id, sizeof (data.class_id), 1); _file_data->write (&data.prob, sizeof (data.prob), 1); _file_data->write (&data.time, sizeof (data.time), 1); } for (ssi_size_t i = 0; i < _n_streams; i++) { ssi_stream_t &stream = *data.streams[i]; stream.time = data.time; _file_streams[i].write (stream, false); if (stream.num == 0) { _has_missing_data = true; } } } break; } } return true; }
bool FeatureFusion::train (ssi_size_t n_models, IModel **models, ISamples &samples) { if (samples.getSize () == 0) { ssi_wrn ("empty sample list"); return false; } if (isTrained ()) { ssi_wrn ("already trained"); return false; } _n_streams = samples.getStreamSize (); _n_classes = samples.getClassSize (); _n_models = n_models; //initialize weights ssi_real_t **weights = new ssi_real_t*[n_models]; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { weights[n_model] = new ssi_real_t[_n_classes+1]; } if (samples.hasMissingData ()) { _handle_md = true; ISMissingData samples_h (&samples); Evaluation eval; if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nMissing data detected.\n"); } //models[0] is featfuse_model, followed by singlechannel_models ISMergeDim ffusionSamples (&samples); ISMissingData ffusionSamples_h (&ffusionSamples); ffusionSamples_h.setStream(0); if (!models[0]->isTrained ()) { models[0]->train (ffusionSamples_h, 0); } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { eval.eval (*models[0], ffusionSamples_h, 0); eval.print(); } //dummy weights for fused model for (ssi_size_t n_class = 0; n_class < _n_classes; n_class++) { weights[0][n_class] = 0.0f; } weights[0][_n_classes] = 0.0f; for (ssi_size_t n_model = 1; n_model < n_models; n_model++) { if (!models[n_model]->isTrained ()) { samples_h.setStream (n_model - 1); models[n_model]->train (samples_h, n_model - 1); } eval.eval (*models[n_model], samples_h, n_model - 1); if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { eval.print(); } for (ssi_size_t n_class = 0; n_class < _n_classes; n_class++) { weights[n_model][n_class] = eval.get_class_prob (n_class); } weights[n_model][_n_classes] = eval.get_classwise_prob (); } //calculate fillers _filler = new ssi_size_t[_n_streams]; for (ssi_size_t n_fill = 0; n_fill < _n_streams; n_fill++) { _filler[n_fill] = 1; ssi_real_t filler_weight = weights[1][_n_classes]; for (ssi_size_t n_model = 2; n_model < n_models; n_model++) { if (filler_weight < weights[n_model][_n_classes]) { _filler[n_fill] = n_model; filler_weight = weights[n_model][_n_classes]; } } weights[_filler[n_fill]][_n_classes] = 0.0f; } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nfiller:\n"); for (ssi_size_t n_model = 0; n_model < _n_streams; n_model++) { ssi_print("%d ", _filler[n_model]); }ssi_print("\n"); } } else{ _handle_md = false; if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nNo missing data detected.\n"); } ISMergeDim ffusionSamples (&samples); if (!models[0]->isTrained ()) { models[0]->train (ffusionSamples, 0); } //dummy _filler = new ssi_size_t[_n_streams]; for (ssi_size_t n_fill = 0; n_fill < _n_streams; n_fill++) { _filler[n_fill] = 0; } } if (weights) { for (ssi_size_t n_model = 0; n_model < _n_models; n_model++) { delete[] weights[n_model]; } delete[] weights; weights = 0; } return true; }
bool FeatureFusion::forward (ssi_size_t n_models, IModel **models, ssi_size_t n_streams, ssi_stream_t *streams[], ssi_size_t n_probs, ssi_real_t *probs) { if (!isTrained ()) { ssi_wrn ("not trained"); return false; } if (n_streams != _n_streams) { ssi_wrn ("#streams (%u) differs from #streams (%u)", n_streams, _n_streams); return false; } if (_n_models != n_models) { ssi_wrn ("#models (%u) differs from #models (%u)", n_models, _n_models); return false; } if (_n_classes != n_probs) { ssi_wrn ("#probs (%u) differs from #classes (%u)", n_probs ,_n_classes); return false; } //No Missing Data: if(!_handle_md){ IModel *model = 0; ssi_stream_t *stream = 0; model = models[0]; ssi_stream_t *fusion_stream = new ssi_stream_t; ssi_size_t fusion_stream_dim = 0; for(ssi_size_t nstrm = 0; nstrm < _n_streams; nstrm++){ fusion_stream_dim += streams[nstrm]->dim; } //create aligned streams ssi_stream_init (*fusion_stream, 1, fusion_stream_dim, streams[0]->byte, streams[0]->type, streams[0]->sr); ssi_byte_t *ptr = fusion_stream->ptr; for(ssi_size_t i = 0; i < _n_streams; i++){ memcpy(ptr, streams[i]->ptr, ( streams[i]->byte * streams[i]->dim ) ); ptr += ( streams[i]->byte * streams[i]->dim ); } //clear probs for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){ probs[num_probs] = 0.0f; } model->forward (*fusion_stream, n_probs, probs); ssi_stream_destroy(*fusion_stream); delete fusion_stream; fusion_stream = 0; ///// is there a draw ? /// ssi_size_t max_ind = 0; ssi_size_t max_ind_draw = 0; ssi_real_t max_val = probs[0]; bool draw = false; for (ssi_size_t i = 1; i < n_probs; i++) { if (probs[i] >= max_val) { if(probs[i] == max_val){ draw = true; max_ind_draw = i; } max_val = probs[i]; max_ind = i; } } if(draw && (max_ind == max_ind_draw)){ return false; }else{ return true; } }//No Missing Data //Missing Data: bool found_data = false; IModel *model = 0; ssi_stream_t *stream = 0; //calculate actual models ssi_size_t miss_counter = 0; ssi_size_t *available = new ssi_size_t[n_models]; available[0] = 1; for (ssi_size_t n_model = 1; n_model < _n_models; n_model++) { stream = streams[n_model - 1]; if (stream->num > 0) { found_data = true; available[n_model] = 1; } else{ miss_counter++; available[n_model] = 0; if(available[0] == 1){ available[0] = 0; miss_counter++; } } } ssi_size_t counter = 0; ssi_size_t *models_actual = new ssi_size_t[(n_models - miss_counter)]; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { if(available[n_model] == 1){ models_actual[counter] = n_model; counter++; } } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\n\n-----------------------------\navailable models:\n"); for(ssi_size_t i = 0; i < (n_models - miss_counter); i++){ ssi_print("%d ", models_actual[i]); }ssi_print("\n"); } if(found_data){ if(available[0] == 1){ //feature fusion possible if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nfeature fusion possible\n"); } model = models[0]; stream = 0; ssi_stream_t *fusion_stream = new ssi_stream_t; ssi_size_t fusion_stream_dim = 0; for(ssi_size_t nstrm = 0; nstrm < _n_streams; nstrm++){ fusion_stream_dim += streams[nstrm]->dim; } //create aligned streams ssi_stream_init (*fusion_stream, 1, fusion_stream_dim, streams[0]->byte, streams[0]->type, streams[0]->sr); ssi_byte_t *ptr = fusion_stream->ptr; for(ssi_size_t i = 0; i < _n_streams; i++){ memcpy(ptr, streams[i]->ptr, ( streams[i]->byte * streams[i]->dim ) ); ptr += ( streams[i]->byte * streams[i]->dim ); } //clear probs for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){ probs[num_probs] = 0.0f; } model->forward (*fusion_stream, n_probs, probs); ssi_stream_destroy(*fusion_stream); delete fusion_stream; fusion_stream = 0; if(available){ delete [] available; available = 0; } if(models_actual){ delete [] models_actual; models_actual = 0; } return true; }else{ //feature fusion not possible, choose filler ... if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nfeature fusion not possible: filler needed\n"); ssi_print("\nfiller:\n"); for (ssi_size_t n_model = 0; n_model < _n_streams; n_model++) { ssi_print("%d ", _filler[n_model]); }ssi_print("\n"); } bool model_available = false; ssi_size_t model_id = 0; for(ssi_size_t h = 0; h < _n_streams; h++){ model_id = _filler[h]; for(ssi_size_t i = 0; i < (n_models - miss_counter); i++){ if(model_id == models_actual[i]){ model_available = true; break; } } if(model_available == true){ model = models[model_id]; if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nSelected Model: %d", model_id); } break; } } model->forward(*streams[model_id - 1], n_probs, probs); } } if(available){ delete [] available; available = 0; } if(models_actual){ delete [] models_actual; models_actual = 0; } /// is there a draw ? /// ssi_size_t max_ind = 0; ssi_size_t max_ind_draw = 0; ssi_real_t max_val = probs[0]; bool draw = false; for (ssi_size_t i = 1; i < n_probs; i++) { if (probs[i] >= max_val) { if(probs[i] == max_val){ draw = true; max_ind_draw = i; } max_val = probs[i]; max_ind = i; } } if(draw && (max_ind == max_ind_draw)){ return false; }else{ return found_data; } }
bool WeightedMajorityVoting::train (ssi_size_t n_models, IModel **models, ISamples &samples) { if (samples.getSize () == 0) { ssi_wrn ("empty sample list"); return false; } if (samples.getStreamSize () != n_models) { ssi_wrn ("#models (%u) differs from #streams (%u)", n_models, samples.getStreamSize ()); return false; } if (isTrained ()) { ssi_wrn ("already trained"); return false; } _n_streams = samples.getStreamSize (); _n_classes = samples.getClassSize (); _n_models = n_models; _weights = new ssi_real_t*[n_models]; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { _weights[n_model] = new ssi_real_t[_n_classes+1]; } if (samples.hasMissingData ()) { ISMissingData samples_h (&samples); Evaluation eval; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { if (!models[n_model]->isTrained ()) { samples_h.setStream (n_model); models[n_model]->train (samples_h, n_model); } eval.eval (*models[n_model], samples_h, n_model); for (ssi_size_t n_class = 0; n_class < _n_classes; n_class++) { _weights[n_model][n_class] = eval.get_class_prob (n_class); } _weights[n_model][_n_classes] = eval.get_classwise_prob (); } } else{ Evaluation eval; for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { if (!models[n_model]->isTrained ()) { models[n_model]->train (samples, n_model); } eval.eval (*models[n_model], samples, n_model); for (ssi_size_t n_class = 0; n_class < _n_classes; n_class++) { _weights[n_model][n_class] = eval.get_class_prob (n_class); } _weights[n_model][_n_classes] = eval.get_classwise_prob (); } } if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) { ssi_print("\nClassifier Weights: \n"); for (ssi_size_t n_model = 0; n_model < n_models; n_model++) { for (ssi_size_t n_class = 0; n_class < _n_classes; n_class++) { ssi_print ("%f ", _weights[n_model][n_class]); } ssi_print ("%f\n", _weights[n_model][_n_classes]); } } return true; }