void train (const ssi_char_t *dir, const ssi_char_t *model) {
// load samples
StringList files;
FileTools::ReadFilesFromDir (files, dir, "*.wav");
SampleList samples;
samples.addUserName ("user");
for (ssi_size_t i = 0; i < files.size (); i++) {
ssi_stream_t *stream = new ssi_stream_t;
ssi_sample_t *sample = new ssi_sample_t;
const ssi_char_t *filename = files.get (i);
// parse class name
FilePath fp (files.get(i));
ssi_char_t *class_name = ssi_strcpy (fp.getName ());
for (ssi_size_t j = 0; j < strlen (class_name); j++) {
if (class_name[j] == '_') {
class_name[j] = '\0';
break;
}
}
ssi_size_t class_id = samples.addClassName (class_name);
delete[] class_name;
// read wave file
WavTools::ReadWavFile (filename, *stream);
// create sample
sample->class_id = class_id;
sample->num = 1;
sample->score = 1.0f;
sample->streams = new ssi_stream_t *[1];
sample->streams[0] = stream;
sample->time = 0;
sample->user_id = 0;
// add sample
samples.addSample (sample);
}
// extract features
SampleList samples_t;
EmoVoiceFeat *ev_feat = ssi_create (EmoVoiceFeat, "ev_feat", true);
ModelTools::TransformSampleList (samples, samples_t, *ev_feat);
// create model
IModel *bayes = ssi_create (NaiveBayes, "bayes", true);
Trainer trainer (bayes);
// evalulation
Evaluation eval;
eval.evalKFold (&trainer, samples_t, 10);
eval.print ();
// train & save
trainer.train (samples_t);
trainer.save (model);
}
bool ex_fusion(void *arg) {
ssi_tic ();
ssi_size_t n_classes = 4;
ssi_size_t n_samples = 50;
ssi_size_t n_streams = 3;
ssi_real_t train_distr[][3] = { 0.25f, 0.25f, 0.1f, 0.25f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f };
ssi_real_t test_distr[][3] = { 0.5f, 0.5f, 0.5f };
SampleList strain;
SampleList sdevel;
SampleList stest;
ModelTools::CreateTestSamples (strain, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples (sdevel, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples (stest, 1, n_samples * n_classes, n_streams, test_distr, "user");
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_class = 1; n_class < n_classes; n_class++) {
ssi_sprint (string, "class%02d", n_class);
stest.addClassName (string);
}
ssi_char_t *name = "fusion";
// strain
{
IModel **models = new IModel *[n_streams];
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_stream = 0; n_stream < n_streams; n_stream++) {
ssi_sprint (string, "%s.%02d", name, n_stream);
models[n_stream] = ssi_create(SimpleKNN, string, true);
}
SimpleFusion *fusion = ssi_create (SimpleFusion, name, true);
Trainer trainer (n_streams, models, fusion);
trainer.train (strain);
trainer.save ("fusion");
delete[] models;
}
// evaluation
{
Trainer trainer;
Trainer::Load (trainer, "fusion");
Evaluation eval;
eval.eval (&trainer, sdevel);
eval.print ();
}
ssi_print_off("");
ssi_toc_print ();
ssi_print("\n");
return true;
}
bool ex_model_norm(void *arg) {
Trainer::SetLogLevel(SSI_LOG_LEVEL_DEBUG);
ssi_size_t n_classes = 4;
ssi_size_t n_samples = 50;
ssi_size_t n_streams = 1;
ssi_real_t train_distr[][3] = { 0.25f, 0.25f, 0.1f, 0.25f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f };
ssi_real_t test_distr[][3] = { 0.5f, 0.5f, 0.5f };
SampleList strain;
SampleList sdevel;
SampleList stest;
ModelTools::CreateTestSamples(strain, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples(sdevel, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples(stest, 1, n_samples * n_classes, n_streams, test_distr, "user");
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_class = 1; n_class < n_classes; n_class++) {
ssi_sprint(string, "class%02d", n_class);
stest.addClassName(string);
}
// train svm
{
SVM *model = ssi_create(SVM, 0, true);
model->getOptions()->seed = 1234;
Trainer trainer(model);
ISNorm::Params params;
ISNorm::ZeroParams(params, ISNorm::METHOD::ZSCORE);
trainer.setNormalization(¶ms);
trainer.train(strain);
trainer.save("svm+norm");
}
// evaluation
{
Trainer trainer;
Trainer::Load(trainer, "svm+norm");
Evaluation eval;
eval.eval(&trainer, sdevel);
eval.print();
trainer.cluster(stest);
ModelTools::PlotSamples(stest, "svm (external normalization)", ssi_rect(650,0,400,400));
}
return true;
}
void ElanTools::LoadSampleList (SampleList &samples,
ssi_size_t num,
ssi_stream_t *streams[],
ElanTier &elanTier,
const ssi_char_t *user_name,
bool useTierNameAsLabel) {
// add user name
ssi_size_t user_id = samples.addUserName (user_name);
// add labels
ssi_size_t class_id;
if (useTierNameAsLabel) {
class_id = samples.addClassName (elanTier.name ());
}
// add samples
ElanTier::iterator anno;
for (anno = elanTier.begin (); anno != elanTier.end (); anno++) {
ssi_sample_t *sample = new ssi_sample_t;
ssi_stream_t **chops = new ssi_stream_t *[num];
bool success = false;
for (ssi_size_t j = 0; j < num; j++) {
// calculate start and stop index
ssi_size_t start_index = ssi_cast (ssi_size_t, (anno->from / 1000.0) * streams[j]->sr + 0.5);
ssi_size_t stop_index = ssi_cast (ssi_size_t, (anno->to / 1000.0) * streams[j]->sr + 0.5);
if (! (start_index <= stop_index && stop_index < streams[j]->num)) {
ssi_wrn ("invalid interval [%lf..%lf]s", anno->from/1000.0, anno->to/1000.0);
continue;
}
// extract sample
chops[j] = new ssi_stream_t;
ssi_stream_copy (*streams[j], *chops[j], start_index, stop_index);
success = true;
}
if (success) {
// create and add new sample
if (useTierNameAsLabel) {
sample->class_id = class_id;
} else {
sample->class_id = samples.addClassName (anno->value.str ());
}
sample->num = num;
sample->prob = 1.0f;
sample->streams = chops;
sample->time = anno->from / 1000.0;
sample->user_id = user_id;
samples.addSample (sample);
} else {
delete sample;
delete[] chops;
}
}
}
bool ex_hierarchical(void *arg) {
Trainer::SetLogLevel(SSI_LOG_LEVEL_DEBUG);
ssi_size_t n_classes = 6;
ssi_size_t n_samples = 50;
ssi_size_t n_streams = 1;
ssi_real_t train_distr[][3] = { 0.2f, 0.2f, 0.1f,
0.2f, 0.5f, 0.1f,
0.2f, 0.8f, 0.1f,
0.8f, 0.8f, 0.1f,
0.8f, 0.5f, 0.1f,
0.8f, 0.2f, 0.1f,
};
ssi_real_t test_distr[][3] = { 0.5f, 0.5f, 0.5f };
SampleList strain;
SampleList sdevel;
SampleList stest;
ModelTools::CreateTestSamples(strain, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples(sdevel, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples(stest, 1, n_samples * n_classes, n_streams, test_distr, "user");
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_class = 1; n_class < n_classes; n_class++) {
ssi_sprint(string, "class%02d", n_class);
stest.addClassName(string);
}
ModelTools::PlotSamples(strain, "train", ssi_rect(650, 0, 400, 400));
// non-hierarchical
{
SVM *model = ssi_create(SVM, 0, true);
model->getOptions()->params.kernel_type = LINEAR;
model->getOptions()->balance = SVM::BALANCE::OFF;
Trainer trainer(model);
trainer.train(strain);
trainer.eval(sdevel);
trainer.cluster(stest);
ModelTools::PlotSamples(stest, "svm", ssi_rect(650, 0, 400, 400));
OptionList::SaveXML("svm", model->getOptions());
}
// hierarchical
{
HierarchicalModel *hmodel = ssi_create(HierarchicalModel, 0, true);
/*
hmodel->initTree(5);
hmodel->addNode(0, 0, ssi_create(SVM, "svm", true), "0, 1, 2, 3, 4, 5");
hmodel->addNode(1, 0, ssi_create(SVM, "svm", true), "0, 1, 2, 3, 4");
hmodel->addNode(1, 1, ssi_create(SVM, "svm", true), "5");
hmodel->addNode(2, 0, ssi_create(SVM, "svm", true), "0, 1, 2");
hmodel->addNode(2, 1, ssi_create(SVM, "svm", true), "3, 4");
hmodel->addNode(3, 0, ssi_create(SVM, "svm", true), "0, 1");
hmodel->addNode(3, 1, ssi_create(SVM, "svm", true), "2");
*/
hmodel->initTree(2);
hmodel->addNode(0, 0, ssi_create(SVM, "svm", true), "0, 1, 2, 3, 4, 5");
hmodel->addNode(1, 0, ssi_create(SVM, "svm", true), "0, 1, 2", "1");
hmodel->addNode(1, 1, ssi_create(SVM, "svm", true), "3, 4, 5", "1");
hmodel->getTree()->print(HierarchicalModel::ToString);
Trainer trainer(hmodel);
trainer.train(strain);
trainer.eval(sdevel);
trainer.save("hierarchical");
}
{
Trainer trainer;
Trainer::Load(trainer, "hierarchical");
trainer.eval(sdevel);
trainer.cluster(stest);
ModelTools::PlotSamples(stest, "hierarchical svm", ssi_rect(650, 0, 400, 400));
}
return true;
}
bool ex_model(void *arg) {
Trainer::SetLogLevel (SSI_LOG_LEVEL_DEBUG);
ssi_size_t n_classes = 4;
ssi_size_t n_samples = 50;
ssi_size_t n_streams = 1;
ssi_real_t train_distr[][3] = { 0.25f, 0.25f, 0.1f, 0.25f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f, 0.75f, 0.75f, 0.1f };
ssi_real_t test_distr[][3] = { 0.5f, 0.5f, 0.5f };
SampleList strain;
SampleList sdevel;
SampleList stest;
ModelTools::CreateTestSamples (strain, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples (sdevel, n_classes, n_samples, n_streams, train_distr, "user");
ModelTools::CreateTestSamples (stest, 1, n_samples * n_classes, n_streams, test_distr, "user");
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_class = 1; n_class < n_classes; n_class++) {
ssi_sprint (string, "class%02d", n_class);
stest.addClassName (string);
}
// train svm
{
SVM *model = ssi_create(SVM, 0, true);
model->getOptions()->seed = 1234;
Trainer trainer(model);
trainer.train(strain);
trainer.save("svm");
}
// evaluation
{
Trainer trainer;
Trainer::Load(trainer, "svm");
Evaluation eval;
eval.eval(&trainer, sdevel);
eval.print();
trainer.cluster(stest);
ModelTools::PlotSamples(stest, "svm (internal normalization)", ssi_rect(650, 0, 400, 400));
}
// train knn
{
KNearestNeighbors *model = ssi_create(KNearestNeighbors, 0, true);
model->getOptions()->k = 5;
//model->getOptions()->distsum = true;
Trainer trainer (model);
trainer.train (strain);
trainer.save ("knn");
}
// evaluation
{
Trainer trainer;
Trainer::Load (trainer, "knn");
Evaluation eval;
eval.eval (&trainer, sdevel);
eval.print ();
trainer.cluster (stest);
ModelTools::PlotSamples(stest, "knn", ssi_rect(650, 0, 400, 400));
}
// train naive bayes
{
NaiveBayes *model = ssi_create(NaiveBayes, 0, true);
model->getOptions()->log = true;
Trainer trainer (model);
trainer.train (strain);
trainer.save ("bayes");
}
// evaluation
{
Trainer trainer;
Trainer::Load (trainer, "bayes");
Evaluation eval;
eval.eval (&trainer, sdevel);
eval.print ();
trainer.cluster (stest);
ModelTools::PlotSamples(stest, "bayes", ssi_rect(650, 0, 400, 400));
}
// training
{
LDA *model = ssi_create(LDA, "lda", true);
Trainer trainer (model);
trainer.train (strain);
model->print();
trainer.save ("lda");
}
// evaluation
{
Trainer trainer;
Trainer::Load (trainer, "lda");
Evaluation eval;
eval.eval (&trainer, sdevel);
eval.print ();
trainer.cluster (stest);
ModelTools::PlotSamples(stest, "lda", ssi_rect(650, 0, 400, 400));
}
ssi_print ("\n\n\tpress a key to contiue\n");
getchar ();
return true;
}
bool ex_eval(void *arg) {
ssi_size_t n_classes = 2;
ssi_size_t n_samples = 20;
ssi_size_t n_streams = 1;
ssi_real_t train_distr[][3] = { 0.3f, 0.3f, 0.2f, 0.3f, 0.6f, 0.2f, 0.6f, 0.3f, 0.2f, 0.6f, 0.6f, 0.2f };
ssi_real_t test_distr[][3] = { 0.5f, 0.5f, 0.5f };
SampleList samples;
ModelTools::CreateTestSamples (samples, n_classes, n_samples, n_streams, train_distr);
ssi_char_t string[SSI_MAX_CHAR];
for (ssi_size_t n_class = 1; n_class < n_classes; n_class++) {
ssi_sprint (string, "class%02d", n_class);
samples.addClassName (string);
}
Evaluation eval;
NaiveBayes *model = ssi_create (NaiveBayes, 0, true);
Trainer trainer (model);
trainer.train (samples);
Evaluation2Latex e2latex;
e2latex.open ("eval.tex");
ssi_print_off ("devel set:\n");
eval.eval (&trainer, samples);
eval.print (ssiout);
eval.print_result_vec ();
e2latex.writeHead (eval, "caption", "label");
e2latex.writeText ("results with different evaluation strategies", true);
e2latex.writeEval ("devel", eval);
ssi_print_off("k-fold:\n");
eval.evalKFold (&trainer, samples, 3);
eval.print ();
eval.print_result_vec ();
e2latex.writeEval ("k-fold", eval);
ssi_print_off("split:\n");
eval.evalSplit (&trainer, samples, 0.5f);
eval.print ();
eval.print_result_vec ();
e2latex.writeEval ("split", eval);
ssi_print_off("loo:\n");
eval.evalLOO (&trainer, samples);
eval.print ();
eval.print_result_vec ();
e2latex.writeEval ("loo", eval);
e2latex.writeTail ();
e2latex.close ();
FILE *fp = fopen("eval.csv", "w");
eval.print(fp, Evaluation::PRINT::CSV_EX);
fclose(fp);
return true;
}