One vs one few doubts about labels

[UlrichVonRekkenin]

Hi there,

I have a bunch of image into two folders (1855 for the first kind and 1920 for second one). There are the jpeg 24*24.

• For the start point I took multiclass_classification_ex.cpp
• I convert them into png through cv::imencode() and save to the using sample_type = dlib::matrix<double, 668, 1>; by loop:

    sample_type result;
    for (unsigned int r = 0; r < result.nr(); r += 1) { result(r, 1) = data[r];  }

• also using label_type = double;
• then define another types:

using ovo_trainer = dlib::one_vs_one_trainer<dlib::any_trainer<sample_type>>;
using poly_kernel = dlib::polynomial_kernel<sample_type>;
using rbf_kernel = dlib::radial_basis_kernel<sample_type>;
using decision_function = dlib::one_vs_one_decision_function<ovo_trainer, dlib::decision_function<poly_kernel>, dlib::decision_function<rbf_kernel>>;

• populate training data by:

void populateSamples(const std::filesystem::path & path, label_type state, std::vector<sample_type> & samples, std::vector<label_type> & labels);

• and train net:

void trainNet()
{
    std::vector<sample_type> samples;
    std::vector<label_type> labels;

    populateSamples(c_trainingOpened, 100, samples, labels);
    populateSamples(c_trainingClosed, 10, samples, labels);

    TRACE("samples.size(): {}", samples.size());

    ovo_trainer trainer;
    trainer.be_verbose();
    trainer.set_num_threads(16);// NOLINT

    dlib::krr_trainer<rbf_kernel> rbfTrainer;
    dlib::svm_nu_trainer<poly_kernel> polyTrainer;
    polyTrainer.set_kernel(poly_kernel(0.1, 1, 3));// NOLINT
    rbfTrainer.set_kernel(rbf_kernel(0.1));        // NOLINT

    trainer.set_trainer(rbfTrainer);
    trainer.set_trainer(polyTrainer, 1, 2);

    dlib::randomize_samples(samples, labels);
    TRACE("cross validation: \n{}", cross_validate_multiclass_trainer(trainer, samples, labels, 5));

    dlib::one_vs_one_decision_function<ovo_trainer> decisionFunction = trainer.train(samples, labels);

    decision_function df = decisionFunction;
    dlib::serialize(c_trainingResult.string()) << df;

    TRACE("test deserialized function: {}", test_multiclass_decision_function(df, samples, labels));

    const auto& table = decisionFunction.get_binary_decision_functions();
    TRACE("table size is {}", table.size());
}

• at the log I see Training classifier for 10 vs. 100 aka labels passed to trainer.
• cross validation output cross validation: [0, 1855, 0, 1920]
• test deserialized function: [0, 1859, 0, 1920]

The doubts are:

1. the size of decisionFunction.get_binary_decision_functions() is 1
2. prediction only for one class is matched (for randomized sample and for validation data excluded from training data).

[davisking]

You only have two classes right? So decisionFunction.get_binary_decision_functions() is always 1 since there is only one binary decision to decide which class it is.

If I understand what you are saying though you are compressing images to PNGs and then taking the bytes of the PNG and using those as features? That will definitely not work well. You have to somehow put the images into a feature space where the classes are linearly separable. How best to do that is highly dependent on your problem space.

[davisking]

I mean I could concoct some problem space where the bytes in a PNG linearly separated some classes. It's not impossible. But it is almost certainly not what you want :)

[UlrichVonRekkenin]

Thanks for your answer ;)

I made another way:

using labelType = double;
using sampleType = dlib::matrix<double, c_pngSize, 1>;
using kernelType = dlib::radial_basis_kernel<sampleType>;
using trainerType = dlib::krr_trainer<kernelType>;
using decisionFunctionType = dlib::decision_function<kernelType>;
using NormalizedFunctionType = dlib::normalized_function<decisionFunctionType>;

using probabilisticDecisionFunctionType = dlib::probabilistic_decision_function<kernelType>;
using normalizedProbabilisticDecisionFunctionType = dlib::normalized_function<probabilisticDecisionFunctionType>;

with the same approach.

In this case the instance of normalizedProbabilisticDecisionFunctionType gives me the probability greater than 0.985 for one kind. It's enough for my problem.

NB
The kernels for classification requires that COMPILE_TIME_ASSERT(T::NC == 1 || T::NC == 0); so I linealized the data. This is what makes it difficult.