xmmModel.hpp

Go to the documentation of this file.

/*
 * xmmModel.hpp
 *
 * Probabilistic machine learning model for multiclass recognition and
 * regression
 *
 * Contact:
 * - Jules Francoise <jules.francoise@ircam.fr>
 *
 * This code has been initially authored by Jules Francoise
 * <http://julesfrancoise.com> during his PhD thesis, supervised by Frederic
 * Bevilacqua <href="http://frederic-bevilacqua.net>, in the Sound Music
 * Movement Interaction team <http://ismm.ircam.fr> of the
 * STMS Lab - IRCAM, CNRS, UPMC (2011-2015).
 *
 * Copyright (C) 2015 UPMC, Ircam-Centre Pompidou.
 *
 * This File is part of XMM.
 *
 * XMM is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * XMM is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with XMM.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef xmmModel_h
#define xmmModel_h

#include "xmmModelConfiguration.hpp"
#include "xmmModelResults.hpp"
#include "xmmModelSingleClass.hpp"
#include <atomic>
#include <thread>

namespace xmm {
template <typename SingleClassModel, typename ModelType>
class Model : public Writable {
  public:
    Model(bool bimodal = false)
        : shared_parameters(std::make_shared<SharedParameters>()),
          cancel_required_(false),
          is_training_(false),
          is_joining_(false),
          models_still_training_(0) {
        shared_parameters->bimodal.set(bimodal);
        if (shared_parameters->bimodal.get()) {
            shared_parameters->dimension.set(2, true);
            shared_parameters->dimension_input.set(1, true);
        } else {
            shared_parameters->dimension.set(1, true);
            shared_parameters->dimension_input.set(0, true);
        }
    }

    Model(Model<SingleClassModel, ModelType> const& src)
        : shared_parameters(
              std::make_shared<SharedParameters>(*src.shared_parameters)),
          configuration(src.configuration),
          training_events(src.training_events),
          cancel_required_(false),
          is_training_(false),
          is_joining_(false),
          models_still_training_(0) {
        if (src.is_training_)
            throw std::runtime_error(
                "Cannot copy: source model is still training");
        models = src.models;
        for (auto& model : models) {
            model.second.training_events.removeListeners();
            model.second.training_events.addListener(
                this,
                &xmm::Model<SingleClassModel, ModelType>::onTrainingEvent);
        }
    }

    explicit Model(Json::Value const& root)
        : shared_parameters(std::make_shared<SharedParameters>()),
          cancel_required_(false),
          is_training_(false),
          is_joining_(false),
          models_still_training_(0) {
        shared_parameters->fromJson(root["shared_parameters"]);
        configuration.fromJson(root["configuration"]);
        models.clear();
        for (auto p : root["models"]) {
            std::string l = p["label"].asString();
            models.insert(std::pair<std::string, SingleClassModel>(
                l, SingleClassModel(shared_parameters, p)));
            models[l].training_events.removeListeners();
            models[l].training_events.addListener(
                this,
                &xmm::Model<SingleClassModel, ModelType>::onTrainingEvent);
        }
    }

    Model<SingleClassModel, ModelType>& operator=(
        Model<SingleClassModel, ModelType> const& src) {
        if (this != &src) {
            if (is_training_)
                throw std::runtime_error(
                    "Cannot copy: target model is still training");
            if (src.is_training_)
                throw std::runtime_error(
                    "Cannot copy: source model is still training");
            shared_parameters =
                std::make_shared<SharedParameters>(*src.shared_parameters);
            configuration = src.configuration;
            training_events = src.training_events;
            is_joining_ = false;
            is_training_ = false;
            cancel_required_ = false;
            models_still_training_ = 0;

            models.clear();
            models = src.models;
            for (auto& model : this->models) {
                model.second.training_events.removeListeners();
                model.second.training_events.addListener(
                    this,
                    &xmm::Model<SingleClassModel, ModelType>::onTrainingEvent);
            }
        }
        return *this;
    }

    virtual ~Model() {
        cancelTraining();
        clear();
    }


    unsigned int size() const {
        return static_cast<unsigned int>(models.size());
    }

    bool hasClass(std::string const& label) const {
        checkTraining();
        return (models.count(label) > 0);
    }

    int getIndex(std::string const& label) const {
        checkTraining();
        int i(-1);
        for (auto& m : models) {
            i++;
            if (m.first == label) {
                return i;
            }
        }
        return -1;
    }

    virtual void removeClass(std::string const& label) {
        while (is_joining_) {
        }
        cancelTraining(label);
        auto it = models.find(label);
        if (it == models.end())
            throw std::out_of_range("Class " + label + " does not exist");
        models.erase(it);
        reset();
    }

    virtual void clear() {
        if (is_training_) cancelTraining();
        models.clear();
        reset();
    }



    bool trained() const { return (!is_training_ && size() > 0); }

    bool training() const { return is_training_; }

    virtual void train(TrainingSet* trainingSet) {
        if (!trainingSet) return;
        cancelTraining();
        clear();

        is_training_ = true;

        // Fetch training set parameters
        shared_parameters->dimension.set(trainingSet->dimension.get());
        if (shared_parameters->bimodal.get()) {
            shared_parameters->dimension_input.set(
                trainingSet->dimension_input.get());
        }
        shared_parameters->column_names.set(trainingSet->column_names.get());

        // Update models
        bool contLoop(true);
        while (contLoop) {
            contLoop = false;
            for (auto it = models.begin(); it != models.end(); ++it) {
                if (trainingSet->labels().count(it->first) == 0) {
                    models.erase(it->first);
                    contLoop = true;
                    break;
                }
            }
        }
        for (typename std::set<std::string>::iterator it =
                 trainingSet->labels().begin();
             it != trainingSet->labels().end(); ++it) {
            addModelForClass(*it);
        }

        // Start class training
        for (auto it = this->models.begin(); it != this->models.end(); ++it) {
            it->second.is_training_ = true;
            it->second.cancel_training_ = false;
            models_still_training_++;
            if ((configuration.multithreading ==
                 MultithreadingMode::Parallel) ||
                (configuration.multithreading ==
                 MultithreadingMode::Background)) {
                training_threads_[it->first] =
                    std::thread(&SingleClassModel::train, &it->second,
                                trainingSet->getPhrasesOfClass(it->first));
            } else {
                it->second.train(trainingSet->getPhrasesOfClass(it->first));
            }
        }
        if (configuration.multithreading == MultithreadingMode::Parallel) {
            joinTraining();
        }
        if (configuration.multithreading == MultithreadingMode::Sequential) {
            is_training_ = false;
        }
    }

    virtual void train(TrainingSet* trainingSet, std::string const& label) {
        if (!trainingSet) return;
        if (trainingSet->labels().count(label) == 0)
            throw std::out_of_range("Class " + label + " does not exist");

        // Cancel Training of the class
        cancelTraining(label);

        // Check Consistency of the new Training Set
        if (size() > 0) {
            if ((shared_parameters->dimension.get() !=
                 trainingSet->dimension.get()) ||
                (shared_parameters->bimodal.get() &&
                 (shared_parameters->dimension_input.get() !=
                  trainingSet->dimension_input.get())))
                throw std::runtime_error(
                    "Dimensions of the new Training Set do not match existing "
                    "models");
        }

        is_training_ = true;

        // Fetch training set parameters
        shared_parameters->dimension.set(trainingSet->dimension.get());
        if (shared_parameters->bimodal.get()) {
            shared_parameters->dimension_input.set(
                trainingSet->dimension_input.get());
        }
        shared_parameters->column_names.set(trainingSet->column_names.get());

        addModelForClass(label);

        // Start class training
        models[label].is_training_ = true;
        models[label].cancel_training_ = false;
        models_still_training_++;
        if (configuration.multithreading == MultithreadingMode::Sequential) {
            models[label].train(trainingSet->getPhrasesOfClass(label));
        } else {
            training_threads_[label] =
                std::thread(&SingleClassModel::train, &(this->models[label]),
                            trainingSet->getPhrasesOfClass(label));
        }
        if (configuration.multithreading == MultithreadingMode::Parallel) {
            joinTraining();
        }
        if (configuration.multithreading == MultithreadingMode::Sequential) {
            is_training_ = false;
        }
    }

    void cancelTraining() {
        if (is_training_) {
            for (auto& it : this->models) {
                cancel_required_ = true;
                it.second.cancelTraining();
                while (it.second.isTraining()) {
                }
            }
            joinTraining();
        }
        cancel_required_ = false;
    }

    void cancelTraining(std::string const& label) {
        if (is_training_ && (this->models.count(label) > 0)) {
            cancel_required_ = true;
            models[label].cancelTraining();
            while (models[label].isTraining()) {
            }
            if (models_still_training_ == 0) {
                joinTraining();
            }
        }
        cancel_required_ = false;
    }



    virtual void reset() {
        checkTraining();
        // checkConfigurationChanges();
        for (auto it = this->models.begin(); it != this->models.end(); ++it) {
            it->second.reset();
        }
    }

    virtual void filter(std::vector<float> const& observation) {
        checkTraining();
        // checkConfigurationChanges();
    }



    virtual Json::Value toJson() const {
        Json::Value root;
        root["shared_parameters"] = shared_parameters->toJson();
        root["configuration"] = configuration.toJson();
        root["models"].resize(static_cast<Json::ArrayIndex>(size()));
        Json::ArrayIndex modelIndex(0);
        for (auto& it : models) {
            root["models"][modelIndex++] = it.second.toJson();
        }
        return root;
    }

    void fromJson(Json::Value const& root) {
        try {
            EventGenerator<TrainingEvent> _tmp_training_events(training_events);
            Model<SingleClassModel, ModelType> tmp(root);
            *this = tmp;
            training_events = _tmp_training_events;
        } catch (JsonException& e) {
            throw e;
        }
    }


    std::shared_ptr<SharedParameters> shared_parameters;

    Configuration<ModelType> configuration;

    EventGenerator<TrainingEvent> training_events;

    std::map<std::string, SingleClassModel> models;

  protected:
    virtual void joinTraining() {
        if (!is_training_) return;
        bool expectedState(false);
        if (is_joining_.compare_exchange_weak(expectedState, true)) {
            while (!training_threads_.empty()) {
                training_threads_.begin()->second.join();
                training_threads_.erase(training_threads_.begin());
            }
            bool classesUntrained(true);
            while (classesUntrained) {
                classesUntrained = false;
                for (auto it = this->models.begin(); it != this->models.end();
                     it++) {
                    if (it->second.training_status.status ==
                            TrainingEvent::Status::Cancel ||
                        it->second.training_status.status ==
                            TrainingEvent::Status::Error) {
                        models.erase(it);
                        classesUntrained = true;
                        break;
                    }
                }
            }
            is_joining_ = false;
            is_training_ = false;
            reset();
            TrainingEvent event(this, "", TrainingEvent::Status::Alldone);
            training_events.notifyListeners(event);
        } else {
            while (is_joining_) {
            }
        }
    }

    void onTrainingEvent(TrainingEvent const& e) {
        event_mutex_.lock();
        TrainingEvent event(e);
        event.model = this;
        training_events.notifyListeners(event);
        if (e.status != TrainingEvent::Status::Run) {
            models_still_training_--;
            ((SingleClassModel*)e.model)->is_training_ = false;
            if (configuration.multithreading ==
                    MultithreadingMode::Background &&
                !is_joining_ &&       // avoid to call "joinTraining" if already
                                      // called by the main thread
                !cancel_required_ &&  // avoid to call "joinTraining" if cancel
                                      // required by the main thread
                models_still_training_ == 0) {
                is_joining_ = false;
                std::thread(&Model<SingleClassModel, ModelType>::joinTraining,
                            this)
                    .detach();
            }
        }
        event_mutex_.unlock();
    }

    inline void checkTraining() const {
        if (is_training_) throw std::runtime_error("The Model is training");
        while (is_joining_) {
        }
    }

    inline void checkConfigurationChanges() const {
        bool configChanged(false);
        if (configuration.changed) configChanged = true;
        for (auto& config : configuration.class_parameters_) {
            if (config.second.changed) configChanged = true;
        }
        if (configChanged) {
            throw std::runtime_error(
                "Configuration has changed, models need to be trained.");
        }
    }

    virtual void addModelForClass(std::string const& label) {
        if (models.count(label) > 0 && models[label].isTraining())
            throw std::runtime_error("The Model is already training");

        if (models.find(label) == models.end()) {
            models.insert(std::pair<std::string, SingleClassModel>(
                label, shared_parameters));
            models[label].training_events.addListener(
                this,
                &xmm::Model<SingleClassModel, ModelType>::onTrainingEvent);
            models[label].label = label;
        }
        if (configuration.class_parameters_.count(label) > 0) {
            models[label].parameters = configuration.class_parameters_[label];
        } else {
            models[label].parameters = configuration;
        }
    }

    std::map<std::string, std::thread> training_threads_;

    std::atomic<bool> cancel_required_;

    std::atomic<bool> is_training_;

    std::atomic<bool> is_joining_;

    unsigned int models_still_training_;

    std::mutex event_mutex_;
};
}

#endif