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;
}
