jubatus::core::classifier::classifier_factory Class Reference

#include <classifier_factory.hpp>

Collaboration diagram for jubatus::core::classifier::classifier_factory:

Static Public Member Functions
static jubatus::util::lang::shared_ptr< classifier_base >	create_classifier (const std::string &name, const common::jsonconfig::config &param, jubatus::util::lang::shared_ptr< storage::storage_base > storage)

Detailed Description

Definition at line 44 of file classifier_factory.hpp.

Member Function Documentation

shared_ptr< classifier_base > jubatus::core::classifier::classifier_factory::create_classifier ( const std::string &  name, const common::jsonconfig::config &  param, jubatus::util::lang::shared_ptr< storage::storage_base >  storage  )

static

Definition at line 89 of file classifier_factory.cpp.

References jubatus::core::nearest_neighbor::create_nearest_neighbor(), jubatus::core::unlearner::create_unlearner(), JUBATUS_EXCEPTION, jubatus::core::common::jsonconfig::config::type(), and unlearner.

                                                            {
  jubatus::util::lang::shared_ptr<unlearner::unlearner_base> unlearner;
  shared_ptr<classifier_base> res;
  if (name == "perceptron") {
    // perceptron doesn't have parameter
    if (param.type() != jubatus::util::text::json::json::Null) {
      unlearner_config conf = config_cast_check<unlearner_config>(param);
      unlearner = create_unlearner(conf);
    }
    res.reset(new perceptron(storage));
  } else if (name == "PA" || name == "passive_aggressive") {
    // passive_aggressive doesn't have parameter
    if (param.type() != jubatus::util::text::json::json::Null) {
      unlearner_config conf = config_cast_check<unlearner_config>(param);
      unlearner = create_unlearner(conf);
    }
    res.reset(new passive_aggressive(storage));
  } else if (name == "PA1" || name == "passive_aggressive_1") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    unlearning_classifier_config conf
        = config_cast_check<unlearning_classifier_config>(param);
    unlearner = create_unlearner(conf);
    res.reset(new passive_aggressive_1(conf, storage));
  } else if (name == "PA2" || name == "passive_aggressive_2") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    unlearning_classifier_config conf
        = config_cast_check<unlearning_classifier_config>(param);
    unlearner = create_unlearner(conf);
    res.reset(new passive_aggressive_2(conf, storage));
  } else if (name == "CW" || name == "confidence_weighted") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    unlearning_classifier_config conf
        = config_cast_check<unlearning_classifier_config>(param);
    unlearner = create_unlearner(conf);
    res.reset(new confidence_weighted(conf, storage));
  } else if (name == "AROW" || name == "arow") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    unlearning_classifier_config conf
        = config_cast_check<unlearning_classifier_config>(param);
    unlearner = create_unlearner(conf);
    res.reset(new arow(conf, storage));
  } else if (name == "NHERD" || name == "normal_herd") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    unlearning_classifier_config conf
        = config_cast_check<unlearning_classifier_config>(param);
    unlearner = create_unlearner(conf);
    res.reset(new normal_herd(conf, storage));
  } else if (name == "NN" || name == "nearest_neighbor") {
    if (param.type() == jubatus::util::text::json::json::Null) {
      throw JUBATUS_EXCEPTION(
          common::config_exception() << common::exception::error_message(
              "parameter block is not specified in config"));
    }
    nearest_neighbor_classifier_config conf
        = config_cast_check<nearest_neighbor_classifier_config>(param);
    unlearner = create_unlearner(conf);
    shared_ptr<storage::column_table> table(new storage::column_table);
    shared_ptr<nearest_neighbor::nearest_neighbor_base>
        nearest_neighbor_engine(nearest_neighbor::create_nearest_neighbor(
            conf.method, conf.parameter, table, ""));
    res.reset(
        new nearest_neighbor_classifier(nearest_neighbor_engine,
                                        conf.nearest_neighbor_num,
                                        conf.local_sensitivity));
  } else {
    throw JUBATUS_EXCEPTION(
        common::unsupported_method("classifier(" + name + ")"));
  }

  if (unlearner) {
    res->set_label_unlearner(unlearner);
  }
  return res;
}

Here is the call graph for this function:

---

The documentation for this class was generated from the following files:

• jubatus/core/classifier/classifier_factory.hpp
• jubatus/core/classifier/classifier_factory.cpp