ISAlignStrms::ISAlignStrms(ISamples *samples)
: ISMergeDim(samples)
{
ssi_wrn("class 'ISAlignStrms' has been replaced by 'ISMergeDim'");
}
bool WeightedMajorityVoting::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_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);
}
}
//clear probs
for (ssi_size_t num_probs = 0; num_probs < n_probs; num_probs++){
probs[num_probs] = 0;
}
//fill probs with votes
ssi_char_t weighting_method = 'a';
//a = average
//c = class
for(ssi_size_t n_model = 0; n_model < (n_models - miss_counter); n_model++){
switch (weighting_method)
{
case ('a'):
probs[votes[n_model]] = (probs[votes[n_model]])+(_weights[models_actual[n_model]][_n_classes]);
break;
case ('c'):
probs[votes[n_model]] = (probs[votes[n_model]])+(_weights[models_actual[n_model]][votes[n_model]]);
break;
}
}
if (ssi_log_level >= SSI_LOG_LEVEL_DEBUG) {
ssi_print("\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;
}
}
ssi_sample_t *FileSamplesIn::next () {
if (!_file_data || !_file_info) {
ssi_wrn ("files not open");
return 0;
}
if (_sample_count++ >= _n_samples) {
return 0;
}
switch (_version) {
case File::V2: {
switch (_file_data->getType ()) {
case File::ASCII: {
if (!_file_data->readLine (SSI_MAX_CHAR, _string)) {
ssi_wrn ("could not read <user_id> <class_id> <time> <prob> <num>");
return 0;
}
sscanf (_string, "%u %u %lf %f %u", &_sample.user_id, &_sample.class_id, &_sample.time, &_sample.prob, &_sample.num);
break;
}
case File::BINARY: {
if (!_file_data->read (&_sample.user_id, sizeof (_sample.user_id), 1)) {
ssi_wrn ("could not read <user_id>");
return 0;
}
if (!_file_data->read (&_sample.class_id, sizeof (_sample.class_id), 1)) {
ssi_wrn ("could not read <class_id>");
return 0;
}
if (!_file_data->read (&_sample.time, sizeof (_sample.time), 1)) {
ssi_wrn ("could not read <time>");
return 0;
}
if (!_file_data->read (&_sample.prob, sizeof (_sample.prob), 1)) {
ssi_wrn ("could not read <prob>");
return 0;
}
if (!_file_data->read (&_sample.num, sizeof (_sample.num), 1)) {
ssi_wrn ("could not read <num>");
return 0;
}
break;
}
}
for (ssi_size_t i = 0; i < _sample.num; i++) {
ssi_size_t num = 0;
switch (_file_data->getType ()) {
case File::ASCII: {
if (!_file_data->readLine (SSI_MAX_CHAR, _string)) {
ssi_wrn ("could not read <num>");
return 0;
}
sscanf (_string, "%u", &num);
break;
}
case File::BINARY: {
if (!_file_data->read (&num, sizeof (num), 1)) {
ssi_wrn ("could not read <num>");
return 0;
}
break;
}
}
if (num > 0) {
ssi_stream_adjust (*_sample.streams[i], num);
_file_data->setType (_sample.streams[i]->type);
if (num > 0) {
if (!_file_data->read (_sample.streams[i]->ptr, _sample.streams[i]->byte, num * _sample.streams[i]->dim)) {
ssi_wrn ("could not read <data>");
return 0;
}
}
} else {
_sample.streams[i]->num = 0;
}
}
break;
}
case File::V3: {
switch (_file_data->getType ()) {
case File::ASCII: {
if (!_file_data->readLine (SSI_MAX_CHAR, _string)) {
ssi_wrn ("could not read <user_id> <class_id> <prob> <time>");
return 0;
}
sscanf (_string, "%u %u %f %lf", &_sample.user_id, &_sample.class_id, &_sample.prob, &_sample.time);
break;
}
case File::BINARY: {
if (!_file_data->read (&_sample.user_id, sizeof (_sample.user_id), 1)) {
ssi_wrn ("could not read <user_id>");
return 0;
}
if (!_file_data->read (&_sample.class_id, sizeof (_sample.class_id), 1)) {
ssi_wrn ("could not read <class_id>");
return 0;
}
if (!_file_data->read (&_sample.prob, sizeof (_sample.prob), 1)) {
ssi_wrn ("could not read <prob>");
return 0;
}
if (!_file_data->read (&_sample.time, sizeof (_sample.time), 1)) {
ssi_wrn ("could not read <time>");
return 0;
}
break;
}
}
for (ssi_size_t i = 0; i < _sample.num; i++) {
_file_streams[i].read (*_sample.streams[i], _sample_count-1);
}
break;
}
}
return &_sample;
}
bool SimpleKNN::forward (ssi_stream_t &stream,
ssi_size_t n_probs,
ssi_real_t *probs) {
if (!_data) {
ssi_wrn ("not trained");
return false;
}
if (n_probs != _n_classes) {
ssi_wrn ("#classes differs");
return false;
}
if (stream.type != SSI_REAL) {
ssi_wrn ("type differs");
return false;
}
if (stream.dim != _n_features) {
ssi_wrn ("feature dimension differs");
return false;
}
ssi_size_t k = _options.k;
DistanceMeasureFunc dist_fptr;
switch (_options.dist) {
case SimpleKNN::EUCLIDIAN:
dist_fptr = SimpleKNN::EuclideanSquaredReal;
break;
default:
ssi_err ("unkown distance measure function");
return false;
}
std::multimap<ssi_real_t, ssi_size_t> closestSamplesMap;
typedef std::pair<ssi_real_t, ssi_size_t> samplePair;
std::multimap<ssi_real_t, ssi_size_t>::iterator mapIter;
ssi_real_t *probptr = probs;
for (ssi_size_t i = 0; i < n_probs; i++)
{
*probptr++ = 0;
}
ssi_real_t *data_ptr = _data;
ssi_size_t *class_ptr = _classes;
ssi_real_t currentMaxDistance = 0.0f;
ssi_real_t currentDistance = 0.0f;
ssi_real_t *sample_ptr = ssi_pcast (ssi_real_t, stream.ptr);
for (ssi_size_t i = 0; i < k; ++i)
{
currentDistance = (*dist_fptr) (sample_ptr, data_ptr, _n_features);
closestSamplesMap.insert (samplePair (currentDistance, *class_ptr));
currentMaxDistance = max (currentMaxDistance, currentDistance);
class_ptr++;
data_ptr += _n_features;
}
for (ssi_size_t i = k; i < _n_samples; ++i)
{
currentDistance = (*dist_fptr) (sample_ptr, data_ptr, _n_features);
if (currentDistance < currentMaxDistance)
{
closestSamplesMap.insert (samplePair (currentDistance, *class_ptr));
mapIter = --closestSamplesMap.end();
closestSamplesMap.erase (mapIter--);
currentMaxDistance = mapIter->first;
}
class_ptr++;
data_ptr += _n_features;
}
probptr = probs;
for (mapIter = closestSamplesMap.begin(); mapIter != closestSamplesMap.end(); ++mapIter)
{
ssi_size_t index = mapIter->second;
*(probptr + index) += 1.0f;
}
// normalize
probptr = probs;
for (ssi_size_t i = 0; i < n_probs; i++)
{
*probptr++ /= k;
}
return true;
}
bool ISNorm::LoadParams(const ssi_char_t *path, Params ¶ms) {
FilePath fp(path);
ssi_char_t *path_xml;
ssi_char_t *path_data;
if (ssi_strcmp(fp.getExtension(), ".norm", false)) {
path_xml = ssi_strcpy(path);
}
else {
path_xml = ssi_strcat(path, ".norm");
}
path_data = ssi_strcat(path_xml, "~");
TiXmlDocument doc;
if (!doc.LoadFile(path_xml)) {
ssi_wrn("failed loading trainer from file '%s' (r:%d,c:%d)", path_xml, doc.ErrorRow(), doc.ErrorCol());
return false;
}
TiXmlElement *body = doc.FirstChildElement();
if (!body || strcmp(body->Value(), "norm") != 0) {
ssi_wrn("tag <norm> missing");
return false;
}
TiXmlElement *element = 0;
element = body->FirstChildElement("method");
const ssi_char_t *method_s = element->GetText();
bool found = false;
METHOD::List method;
for (ssi_size_t i = 0; i < METHOD::NUM; i++) {
if (ssi_strcmp(method_s, METHOD_NAMES[i], false)) {
method = (METHOD::List) i;
found = true;
}
}
if (!found) {
ssi_wrn("unkown method '%s'", method_s);
return false;
}
ISNorm::ZeroParams(params, method);
element = body->FirstChildElement("dim");
const ssi_char_t *dim_s = element->GetText();
ssi_size_t dim;
if (sscanf(dim_s, "%u", &dim) != 1) {
ssi_wrn("could not parse dimension '%s'", dim_s);
return false;
}
ISNorm::InitParams(params, dim);
if (method == METHOD::SCALE) {
element = body->FirstChildElement("limits");
const ssi_char_t *limits_s = element->GetText();
if (sscanf(limits_s, "%f %f", params.limits, params.limits + 1) != 2) {
ssi_wrn("could not parse limits '%s'", limits_s);
return false;
}
}
element = body->FirstChildElement("type");
const ssi_char_t *type_s = element->GetText();
found = false;
File::TYPE type;
if (ssi_strcmp(type_s, File::TYPE_NAMES[File::ASCII], false)) {
type = File::ASCII;
found = true;
} else if (ssi_strcmp(type_s, File::TYPE_NAMES[File::BINARY], false)) {
type = File::BINARY;
found = true;
}
if (!found) {
ssi_wrn("unkown type '%s'", type_s);
return false;
}
if (method != METHOD::NONE) {
FILE *fp = fopen(path_data, type == File::BINARY ? "rb" : "r");
if (fp) {
switch (params.method) {
case METHOD::NONE:
break;
case METHOD::SCALE:
if (type == File::BINARY) {
fread(params.mins, params.n_features, sizeof(ssi_real_t), fp);
fread(params.maxs, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mins = params.mins;
ssi_real_t *maxs = params.maxs;
for (ssi_size_t i = 0; i < params.n_features; i++) {
fscanf(fp, "%f %f\n", mins++, maxs++);
}
}
break;
case METHOD::ZSCORE:
if (type == File::BINARY) {
fread(params.mean, params.n_features, sizeof(ssi_real_t), fp);
fread(params.stdv, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mean = params.mean;
ssi_real_t *stdv = params.stdv;
for (ssi_size_t i = 0; i < params.n_features; i++) {
fscanf(fp, "%f %f\n", mean++, stdv++);
}
}
break;
}
fclose(fp);
}
else {
ssi_wrn("could not open file '%s'", path_data);
return false;
}
}
delete[] path_xml;
delete[] path_data;
return true;
}
bool ISNorm::setNorm (ssi_size_t index,
Params ¶ms) {
if (index >= _n_streams) {
ssi_wrn("index exceeds #streams (%u != %u)", index, _n_streams);
return false;
}
if (params.inialized && params.n_features != _n_features[index]) {
ssi_wrn("precomputed parameters are bad #features (%u != %u)", params.n_features, _n_features[index]);
return false;
}
_params[index] = ¶ms;
if (!params.inialized) {
InitParams(params, _n_features[index]);
if (params.method != METHOD::NONE) {
ssi_real_t **matrix;
ssi_size_t *classes;
ModelTools::CreateSampleMatrix(_samples, index, _n_samples, params.n_features, &classes, &matrix);
switch (params.method) {
case METHOD::SCALE: {
ssi_minmax(_n_samples, params.n_features, matrix[0], params.mins, params.maxs);
ssi_real_t *aptr = params.mins;
ssi_real_t *bptr = params.maxs;
for (ssi_size_t j = 0; j < params.n_features; j++) {
*bptr -= *aptr++;
if (*bptr == 0.0f) {
ssi_wrn("zero interval '%u'", j);
*bptr = 1.0f;
}
bptr++;
}
break;
}
case METHOD::ZSCORE: {
ssi_mean(_n_samples, params.n_features, matrix[0], params.mean);
ssi_stdv(_n_samples, params.n_features, matrix[0], params.stdv);
ssi_real_t *bptr = params.stdv;
for (ssi_size_t j = 0; j < params.n_features; j++) {
*bptr = sqrt(*bptr);
if (*bptr == 0.0f) {
ssi_wrn("zero stdv '%u'", j);
*bptr = 1.0f;
}
bptr++;
}
break;
}
}
ModelTools::ReleaseSampleMatrix(_n_samples, classes, matrix);
}
params.inialized = true;
}
return true;
}
void Evaluation::print (FILE *file, PRINT::List format) {
if (!_conf_mat_ptr) {
ssi_wrn ("nothing to print");
return;
}
ssi_size_t max_label_len = 0;
for (ssi_size_t i = 0; i < _n_classes; ++i) {
ssi_size_t len = ssi_cast (ssi_size_t, strlen (_class_names[i]));
if (len > max_label_len) {
max_label_len = len;
}
}
if (format == PRINT::CSV || format == PRINT::CSV_EX) {
File *tmp = File::Create(File::ASCII, File::WRITE, 0, file);
tmp->setType(SSI_UINT);
tmp->setFormat(";", "");
ssi_fprint(file, "#classes;%u\n", _n_classes);
ssi_fprint(file, "#total;%u\n", _n_classified + _n_unclassified);
ssi_fprint(file, "#classified;%u\n", _n_classified);
ssi_fprint(file, "#unclassified;%u\n", _n_unclassified);
for (ssi_size_t i = 0; i < _n_classes; ++i) {
ssi_fprint(file, ";%s", _class_names[i]);
}
ssi_fprint(file, "\n");
for (ssi_size_t i = 0; i < _n_classes; ++i) {
ssi_fprint(file, "%s;", _class_names[i]);
tmp->write(_conf_mat_ptr[i], 0, _n_classes);
ssi_fprint(file, "%f\n", 100 * get_class_prob(i));
}
for (ssi_size_t i = 0; i < _n_classes; ++i) {
ssi_fprint(file, "; ");
}
ssi_fprint(file, ";%f;%f\n", 100 * get_classwise_prob(), 100 * get_accuracy_prob());
if (format == PRINT::CSV_EX) {
ssi_fprint(file, "\ntruth;prediction\n");
ssi_size_t *ptr = _result_vec;
for (ssi_size_t i = 0; i < _n_total; i++) {
ssi_fprint(file, "%u;%u\n", ptr[0], ptr[1]);
ptr += 2;
}
}
} else {
File *tmp = File::Create(File::ASCII, File::WRITE, 0, file);
tmp->setType(SSI_UINT);
tmp->setFormat(" ", "6");
ssi_fprint(file, "#classes: %u\n", _n_classes);
ssi_fprint(file, "#total: %u\n", _n_classified + _n_unclassified);
ssi_fprint(file, "#classified: %u\n", _n_classified);
ssi_fprint(file, "#unclassified: %u\n", _n_unclassified);
if (format != PRINT::CONSOLE_EX) {
for (ssi_size_t j = 0; j < max_label_len + 3; j++) {
ssi_fprint(file, " ");
}
ssi_char_t cut[7];
for (ssi_size_t i = 0; i < _n_classes; ++i) {
cutString(_class_names[i], 7, cut);
ssi_fprint(file, " %6s", cut);
}
}
ssi_fprint(file, "\n");
for (ssi_size_t i = 0; i < _n_classes; ++i) {
ssi_fprint(file, "%*s: ", max_label_len, _class_names[i]);
tmp->write(_conf_mat_ptr[i], 0, _n_classes);
ssi_fprint(file, " -> %8.2f%%\n", 100 * get_class_prob(i));
}
ssi_fprint(file, " %*s => %8.2f%% | %.2f%%\n", max_label_len + _n_classes * 7, "", 100 * get_classwise_prob(), 100 * get_accuracy_prob());
delete tmp;
}
fflush (file);
}
bool ISNorm::SaveParams(const ssi_char_t *path, Params ¶ms, File::TYPE type) {
ssi_char_t string[SSI_MAX_CHAR];
FilePath fp(path);
ssi_char_t *path_xml;
ssi_char_t *path_data;
if (ssi_strcmp(fp.getExtension(), "norm", false)) {
path_xml = ssi_strcpy(path);
} else {
path_xml = ssi_strcat(path, ".norm");
}
path_data = ssi_strcat(path_xml, "~");
TiXmlElement norm("norm");
TiXmlElement norm_method("method");
norm_method.InsertEndChild(TiXmlText(METHOD_NAMES[params.method]));
norm.InsertEndChild(norm_method);
if (params.method == METHOD::SCALE) {
TiXmlElement norm_limits("limits");
ssi_sprint(string, "%f %f", params.limits[0], params.limits[1]);
norm_limits.InsertEndChild(TiXmlText(string));
norm.InsertEndChild(norm_limits);
}
TiXmlElement norm_dim("dim");
ssi_sprint(string, "%u", params.n_features);
norm_dim.InsertEndChild(TiXmlText(string));
norm.InsertEndChild(norm_dim);
TiXmlElement norm_type("type");
norm_type.InsertEndChild(TiXmlText(File::TYPE_NAMES[type]));
norm.InsertEndChild(norm_type);
TiXmlDocument doc;
TiXmlDeclaration head("1.0", "", "");
doc.InsertEndChild(head);
doc.InsertEndChild(norm);
doc.SaveFile(path_xml);
if (params.method != METHOD::NONE) {
FILE *fp = fopen(path_data, type == File::BINARY ? "wb" : "w");
if (fp) {
switch (params.method) {
case METHOD::SCALE:
if (type == File::BINARY) {
fwrite(params.mins, params.n_features, sizeof(ssi_real_t), fp);
fwrite(params.maxs, params.n_features, sizeof(ssi_real_t), fp);
} else {
ssi_real_t *mins = params.mins;
ssi_real_t *maxs = params.maxs;
for (ssi_size_t i = 0; i < params.n_features; i++) {
ssi_fprint(fp, "%f %f\n", *mins++, *maxs++);
}
}
break;
case METHOD::ZSCORE:
if (type == File::BINARY) {
fwrite(params.mean, params.n_features, sizeof(ssi_real_t), fp);
fwrite(params.stdv, params.n_features, sizeof(ssi_real_t), fp);
}
else {
ssi_real_t *mean = params.mean;
ssi_real_t *stdv = params.stdv;
for (ssi_size_t i = 0; i < params.n_features; i++) {
ssi_fprint(fp, "%f %f\n", *mean++, *stdv++);
}
}
break;
}
}
else {
ssi_wrn("could not open file '%s'", path_data);
return false;
}
fclose(fp);
}
delete[] path_data;
delete[] path_xml;
return true;
}
ssi_size_t ElanTier::split (ElanTier &tier, ElanTier &inverse , String inverseValue, ssi_size_t framesize, ssi_size_t deltasize, ssi_size_t dropsize, ssi_size_t tiersize) {
if (dropsize >= framesize) {
ssi_wrn ("dropsize '%u' > framesize '%u'", framesize, dropsize);
return 0;
}
if (size () == 0) {
return 0;
}
ssi_size_t n_added = 0;
ssi_size_t pos = 0;
ssi_size_t maxsize = (end ()-1)->to;
ssi_size_t n_frames = (maxsize - (framesize-deltasize)) / framesize;
ElanAnnotation a;
ElanTier::iterator current = begin ();
for (ssi_size_t i = 0; i < n_frames; i++, pos += framesize) {
if (pos >= current->to) {
current++;
}
if (current->from >= pos + framesize) {
a.from = pos;
a.to = pos + framesize + deltasize;
a.value = inverseValue;
inverse.push_back (a);
continue;
}
ssi_size_t real_from = max (current->from, pos);
ssi_size_t real_to = min (current->to, pos + framesize + deltasize);
if (real_to - real_from >= dropsize) {
a.from = pos;
a.to = pos + framesize + deltasize;
a.value = current->value;
tier.push_back (a);
++n_added;
} else {
a.from = pos;
a.to = pos + framesize + deltasize;
a.value = inverseValue;
inverse.push_back (a);
}
}
if (tiersize > pos) {
ssi_size_t tailsize = tiersize - pos;
if (tailsize > framesize-deltasize) {
n_frames = (tailsize - (framesize-deltasize)) / framesize;
for (ssi_size_t i = 0; i < n_frames; i++, pos += framesize) {
a.from = pos;
a.to = pos + framesize + deltasize;
a.value = inverseValue;
inverse.push_back (a);
}
}
}
return n_added;
}
void Tensorflow::listen_enter() {
if (!_is_loaded && !loadTrainer()) {
ssi_wrn("could not load trainer '%s'", _options.trainer);
}
}
void Tensorflow::consume(IConsumer::info consume_info,
ssi_size_t stream_in_num,
ssi_stream_t stream_in[]) {
ssi_real_t *dataptr = ssi_pcast(ssi_real_t, stream_in[0].ptr);
tensorflow::Session *session;
tensorflow::Status status = NewSession(tensorflow::SessionOptions(), &session);
if (!status.ok()) {
ssi_wrn("status: %s \n", status.ToString().c_str());
return;
}
tensorflow::GraphDef graph_def;
#if __ANDROID__
status = ReadTextProto(tensorflow::Env::Default(), "/sdcard/android_xmlpipe/frozen_graph.pb", &graph_def);
#else
status = ReadTextProto(tensorflow::Env::Default(),
"/home/mainuser/code/SSI/mobileSSI/plugins/tensorflow/test_files/frozen_graph.pb",
&graph_def);
#endif
if (!status.ok()) {
ssi_wrn("status: %s \n", status.ToString().c_str());
return;
}
status = session->Create(graph_def);
if (!status.ok()) {
ssi_wrn("status: %s \n", status.ToString().c_str());
return;
}
int number_dim = stream_in[0].dim;
int number_test = stream_in[0].num; // 4072
int number_classes = 4;
tensorflow::Tensor input_tensor(tensorflow::DT_FLOAT, tensorflow::TensorShape({number_test, number_dim}));
auto dst = input_tensor.flat<float>().data();
for (int i = 0; i < stream_in[0].num; i++) {
std::copy_n(dataptr + i * number_dim, number_dim, dst);
dst += number_dim;
}
std::vector<std::pair<std::string, tensorflow::Tensor>> inputs = {{"input_TT", input_tensor}};
std::vector<tensorflow::Tensor> outputs;
status = session->Run(inputs, {"output_TT"}, {}, &outputs);
if (!status.ok()) {
ssi_wrn("status: %s \n", status.ToString().c_str());
return;
}
std::vector<int> number_hits(number_classes, 0);
for (std::vector<tensorflow::Tensor>::iterator it = outputs.begin(); it != outputs.end(); ++it) {
auto items = it->shaped<float, 2>({number_test, number_classes});
for (int i = 0; i < number_test; i++) {
int arg_max = 0;
float val_max = items(i, 0);
for (int j = 0; j < number_classes; j++) {
if (items(i, j) > val_max) {
arg_max = j;
val_max = items(i, j);
}
}
for (int i = 0; i < number_classes; i++) {
if (arg_max == i) {
number_hits[i]++;
}
}
}
}
std::string classes[] = {"ambient_animals", "rain", "running_water", "traffic"};
for (int i = 0; i < number_classes; i++) {
float accuracy = (float) number_hits[i] / number_test;
ssi_wrn("accuracy for class %s : %f \n", classes[i].c_str(), accuracy);
_probs[i] = accuracy;
}
session->Close();
_handler->handle(consume_info.time, consume_info.dur, 4, 0, _probs, _class_names, 0, 0);
}
bool FileStreamIn::open (ssi_stream_t &data,
const ssi_char_t *path,
ssi_size_t &n_meta,
void **meta) {
ssi_msg (SSI_LOG_LEVEL_DETAIL, "open stream file '%s'", path);
if (_file_info || _file_data) {
ssi_wrn ("stream already open");
return false;
}
if (path == 0 || path[0] == '\0') {
ssi_wrn ("'%s' is not a valid path", path);
return false;
}
FilePath fp (path);
ssi_char_t *path_info = 0;
if (strcmp (fp.getExtension (), SSI_FILE_TYPE_STREAM) != 0) {
path_info = ssi_strcat (path, SSI_FILE_TYPE_STREAM);
} else {
path_info = ssi_strcpy (path);
}
_path = ssi_strcpy (path_info);
_file_info = File::CreateAndOpen (File::ASCII, File::READ, path_info);
if (!_file_info) {
ssi_wrn ("could not open info file '%s'", path_info);
return false;
}
TiXmlDocument doc;
if (!doc.LoadFile (_file_info->getFile ())) {
ssi_wrn ("failed loading stream from file '%s'", path_info);
return false;
}
TiXmlElement *body = doc.FirstChildElement();
if (!body || strcmp (body->Value (), "stream") != 0) {
ssi_wrn ("tag <stream> missing");
return false;
}
int v = 0;
if (body->QueryIntAttribute ("ssi-v", &v) != TIXML_SUCCESS) {
ssi_wrn ("attribute <ssi-v> in tag <stream> missing");
return false;
}
_version = ssi_cast (File::VERSION, v);
if (_version < File::V2) {
ssi_wrn ("version < V2 not supported");
return false;
}
TiXmlElement *element = body->FirstChildElement ("info");
if (!element || strcmp (element->Value (), "info") != 0) {
ssi_wrn ("tag <info> missing");
return false;
}
ssi_time_t sample_rate = 0;
if (element->QueryDoubleAttribute ("sr", &sample_rate) != TIXML_SUCCESS) {
ssi_wrn ("attribute <sr> missing in tag <info>");
return false;
}
int sample_dimension = 0;
if (element->QueryIntAttribute ("dim", &sample_dimension) != TIXML_SUCCESS) {
ssi_wrn ("attribute <dim> missing in tag <info>");
return false;
}
int sample_byte = 0;
if (element->QueryIntAttribute ("byte", &sample_byte) != TIXML_SUCCESS) {
ssi_wrn ("attribute <byte> missing in tag <info>");
return false;
}
const char *type = element->Attribute ("type");
if (!type) {
ssi_wrn ("attribute <type> missing in tag <info>");
return false;
}
ssi_type_t sample_type;
if (!ssi_name2type (type, sample_type)) {
ssi_wrn ("could not parse type from '%s'", type);
return false;
}
const char *ftype_name = element->Attribute ("ftype");
if (!ftype_name) {
ssi_wrn ("attribute <ftype> missing in tag <info>");
return false;
}
File::TYPE ftype;
if (strcmp (ftype_name, File::TYPE_NAMES[0]) == 0) {
ftype = File::BINARY;
} else if (strcmp (ftype_name, File::TYPE_NAMES[1]) == 0) {
ftype = File::ASCII;
} else {
ssi_wrn ("attribute <ftype> has invalid value '%s' in tag <info>", ftype_name);
return false;
}
*meta = 0;
n_meta = 0;
element = body->FirstChildElement ("meta");
if (element && strcmp (element->Value (), "meta") == 0) {
switch (sample_type) {
case SSI_IMAGE: {
n_meta = sizeof (ssi_video_params_t);
ssi_video_params_t *params = new ssi_video_params_t ();
*meta = params;
if (element->QueryIntAttribute ("width", ¶ms->widthInPixels) != TIXML_SUCCESS) {
ssi_wrn ("attribute <width> missing in tag <meta>");
return false;
}
if (element->QueryIntAttribute ("height", ¶ms->heightInPixels) != TIXML_SUCCESS) {
ssi_wrn ("attribute <height> missing in tag <meta>");
return false;
}
if (element->QueryIntAttribute ("depth", ¶ms->depthInBitsPerChannel) != TIXML_SUCCESS) {
ssi_wrn ("attribute <depth> missing in tag <meta>");
return false;
}
if (element->QueryIntAttribute ("channels", ¶ms->numOfChannels) != TIXML_SUCCESS) {
ssi_wrn ("attribute <channels> missing in tag <meta>");
return false;
}
int flip = 0;
if (element->QueryIntAttribute ("channels", &flip) != TIXML_SUCCESS) {
ssi_wrn ("attribute <flip> missing in tag <meta>");
}
params->flipImage = flip != 0;
break;
}
default:
ssi_wrn ("type '%s' doesn't support meta information", SSI_TYPE_NAMES[sample_type]);
break;
}
}
ssi_char_t *path_data = ssi_strcat (path_info, "~");
_file_data = File::CreateAndOpen (ftype, File::READ, path_data);
if (!_file_data) {
ssi_wrn ("could not open data file '%s'", path_data);
return false;
}
ssi_stream_init (data, 0, sample_dimension, sample_byte, sample_type, sample_rate, 0);
ssi_stream_init (_stream, 0, sample_dimension, sample_byte, sample_type, sample_rate, 0);
// count chunks
_n_chunks = 0;
_next_chunk = 0;
element = body->FirstChildElement ("chunk");
if (element) {
do {
_n_chunks++;
element = element->NextSiblingElement ("chunk");
} while (element);
}
// read in chunks
_n_samples = 0;
_samples = new ssi_size_t[_n_chunks];
_time = new ssi_time_t[_n_chunks];
_bytes = new ssi_size_t[_n_chunks];
element = body->FirstChildElement ("chunk");
ssi_size_t n = 0;
if (element) {
do {
ssi_time_t time = 0;
if (element->QueryDoubleAttribute ("from", &time) != TIXML_SUCCESS) {
ssi_wrn ("attribute <time> missing in tag <chunk>");
return false;
}
_time[n] = time;
int bytes = 0;
if (element->QueryIntAttribute ("byte", &bytes) != TIXML_SUCCESS) {
ssi_wrn ("attribute <bytes> missing in tag <chunk>");
return false;
}
_bytes[n] = ssi_cast (ssi_size_t, bytes);
int samples = 0;
if (element->QueryIntAttribute ("num", &samples) != TIXML_SUCCESS) {
ssi_wrn ("attribute <time> missing in tag <chunk>");
return false;
}
_n_samples += ssi_cast (ssi_size_t, samples);
_samples[n++] = ssi_cast (ssi_size_t, samples);
element = element->NextSiblingElement ("chunk");
} while (element);
}
delete[] path_info;
delete[] path_data;
return true;
};
bool SVM::train (ISamples &samples,
ssi_size_t stream_index) {
if (_options.seed > 0) {
srand(_options.seed);
} else {
srand(ssi_time_ms());
}
ISamples *s_balance = 0;
switch (_options.balance) {
case BALANCE::OFF: {
s_balance = &samples;
break;
}
case BALANCE::OVER: {
s_balance = new ISOverSample(&samples);
ssi_pcast(ISOverSample, s_balance)->setOver(ISOverSample::RANDOM);
ssi_msg(SSI_LOG_LEVEL_BASIC, "balance training set '%u' -> '%u'", samples.getSize(), s_balance->getSize());
break;
}
case BALANCE::UNDER: {
s_balance = new ISUnderSample(&samples);
ssi_pcast(ISUnderSample, s_balance)->setUnder(ISUnderSample::RANDOM);
ssi_msg(SSI_LOG_LEVEL_BASIC, "balance training set '%u' -> '%u'", samples.getSize(), s_balance->getSize());
break;
}
}
_n_samples = s_balance->getSize();
if (_n_samples == 0) {
ssi_wrn ("empty sample list");
return false;
}
if (isTrained ()) {
ssi_wrn ("already trained");
return false;
}
_n_classes = s_balance->getClassSize();
_n_features = s_balance->getStream(stream_index).dim;
ssi_size_t elements = _n_samples * (_n_features + 1);
init_class_names(*s_balance);
_problem = new svm_problem;
_problem->l = ssi_cast (int, _n_samples);
_problem->y = new double[_problem->l];
_problem->x = new svm_node *[_problem->l];
s_balance->reset();
ssi_sample_t *sample;
int n_sample = 0;
float *ptr = 0;
svm_node *node = 0;
while (sample = s_balance->next()) {
ptr = ssi_pcast (float, sample->streams[stream_index]->ptr);
_problem->x[n_sample] = new svm_node[_n_features + 1];
_problem->y[n_sample] = ssi_cast (float, sample->class_id);
node = _problem->x[n_sample];
for (ssi_size_t nfeat = 0; nfeat < _n_features; nfeat++) {
node->index = nfeat+1;
node->value = *ptr;
ptr++;
++node;
}
node->index = -1;
++n_sample;
}
if(_options.params.gamma == 0 && _n_features > 0) {
_options.params.gamma = 1.0 / _n_features;
}
if (_options.params.kernel_type == PRECOMPUTED) {
int max_index = ssi_cast (int, _n_features);
for (int i = 0; i < _problem->l; i++) {
if (_problem->x[i][0].index != 0) {
ssi_err ("wrong input format: first column must be 0:sample_serial_number");
}
if ((int)_problem->x[i][0].value <= 0 || (int)_problem->x[i][0].value > max_index) {
ssi_err ("wrong input format: sample_serial_number out of range");
}
}
}
