shared_ptr<recommender_base> recommender_factory::create_recommender(
const string& name,
const config& param,
const string& id) {
if (name == "inverted_index") {
// inverted_index doesn't have parameter
return shared_ptr<recommender_base>(new inverted_index);
} else if (name == "minhash") {
return shared_ptr<recommender_base>(
new minhash(config_cast_check<minhash::config>(param)));
} else if (name == "lsh") {
return shared_ptr<recommender_base>(
new lsh(config_cast_check<lsh::config>(param)));
} else if (name == "euclid_lsh") {
return shared_ptr<recommender_base>(
new euclid_lsh(config_cast_check<euclid_lsh::config>(param)));
} else if (starts_with(name, NEAREST_NEIGHBOR_PREFIX)) {
const std::string nearest_neighbor_method =
name.substr(NEAREST_NEIGHBOR_PREFIX.size());
shared_ptr<table::column_table> table(new table::column_table);
shared_ptr<nearest_neighbor::nearest_neighbor_base>
nearest_neighbor_engine(nearest_neighbor::create_nearest_neighbor(
nearest_neighbor_method, param, table, id));
return shared_ptr<recommender_base>(
new nearest_neighbor_recommender(nearest_neighbor_engine));
} else {
throw JUBATUS_EXCEPTION(common::unsupported_method(name));
}
}
shared_ptr<anomaly_base> anomaly_factory::create_anomaly(
const string& name,
const config& param,
const string& id) {
if (name == "lof") {
lof_config conf = config_cast_check<lof_config>(param);
return shared_ptr<anomaly_base>(new lof(
conf,
recommender::recommender_factory::create_recommender(
conf.method,
conf.parameter, id)));
} else if (name == "light_lof") {
light_lof_config conf = config_cast_check<light_lof_config>(param);
jubatus::util::lang::shared_ptr<table::column_table> nearest_neighbor_table(
new table::column_table);
jubatus::util::lang::shared_ptr<nearest_neighbor::nearest_neighbor_base>
nearest_neighbor_engine(nearest_neighbor::create_nearest_neighbor(
conf.method, conf.parameter, nearest_neighbor_table, id));
if (conf.unlearner) {
if (!conf.unlearner_parameter) {
throw JUBATUS_EXCEPTION(
common::config_exception()
<< common::exception::error_message(
"unlearner is set but unlearner_parameter is not found"));
}
jubatus::util::lang::shared_ptr<unlearner::unlearner_base> unlearner(
unlearner::create_unlearner(
*conf.unlearner,
*conf.unlearner_parameter));
return shared_ptr<anomaly_base>(
new light_lof(conf, id, nearest_neighbor_engine, unlearner));
}
return jubatus::util::lang::shared_ptr<anomaly_base>(
new light_lof(conf, id, nearest_neighbor_engine));
} else {
throw JUBATUS_EXCEPTION(common::unsupported_method(name));
}
};
shared_ptr<recommender_base> recommender_factory::create_recommender(
const string& name,
const config& param,
const string& id) {
if (name == "inverted_index") {
if (!param.is_null()) {
inverted_index_config conf =
config_cast_check<inverted_index_config>(param);
if (conf.unlearner) {
if (!conf.unlearner_parameter) {
throw JUBATUS_EXCEPTION(
common::config_exception() << common::exception::error_message(
"unlearner is set but unlearner_parameter is not found"));
}
return shared_ptr<recommender_base>(
new inverted_index(unlearner::create_unlearner(
*conf.unlearner, common::jsonconfig::config(
*conf.unlearner_parameter))));
} else {
if (conf.unlearner_parameter) {
throw JUBATUS_EXCEPTION(
common::config_exception() << common::exception::error_message(
"unlearner_parameter is set but unlearner is not found"));
}
}
}
return shared_ptr<recommender_base>(new inverted_index);
} else if (name == "inverted_index_euclid") {
if (!param.is_null()) {
return shared_ptr<recommender_base>(
new inverted_index_euclid(
config_cast_check<inverted_index_euclid::config>(param)));
} else {
return shared_ptr<recommender_base>(new inverted_index_euclid);
}
} else if (name == "minhash") {
return shared_ptr<recommender_base>(
new minhash(config_cast_check<minhash::config>(param)));
} else if (name == "lsh") {
return shared_ptr<recommender_base>(
new lsh(config_cast_check<lsh::config>(param)));
} else if (name == "euclid_lsh") {
return shared_ptr<recommender_base>(
new euclid_lsh(config_cast_check<euclid_lsh::config>(param)));
} else if (name == "nearest_neighbor_recommender") {
nearest_neighbor_recommender_config conf =
config_cast_check<nearest_neighbor_recommender_config>(param);
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, id));
if (conf.unlearner) {
if (!conf.unlearner_parameter) {
throw JUBATUS_EXCEPTION(
common::config_exception() << common::exception::error_message(
"unlearner is set but unlearner_parameter is not found"));
}
shared_ptr<unlearner::unlearner_base> unl(unlearner::create_unlearner(
*conf.unlearner, common::jsonconfig::config(
*conf.unlearner_parameter)));
return shared_ptr<recommender_base>(
new nearest_neighbor_recommender(nearest_neighbor_engine, unl));
}
return shared_ptr<recommender_base>(
new nearest_neighbor_recommender(nearest_neighbor_engine));
} else {
throw JUBATUS_EXCEPTION(common::unsupported_method(name));
}
}
shared_ptr<regression_base> regression_factory::create_regression(
const std::string& name,
const common::jsonconfig::config& param,
shared_ptr<storage::storage_base> storage) {
if (name == "PA" || name == "passive_aggressive") {
return shared_ptr<regression_base>(new regression::passive_aggressive(
config_cast_check<regression::passive_aggressive::config>(param),
storage));
} else if (name == "PA1" || name == "passive_aggressive_1") {
return shared_ptr<regression_base>(new regression::passive_aggressive_1(
config_cast_check<regression::passive_aggressive_1::config>(param),
storage));
} else if (name == "PA2" || name == "passive_aggressive_2") {
return shared_ptr<regression_base>(new regression::passive_aggressive_2(
config_cast_check<regression::passive_aggressive_2::config>(param),
storage));
} else if (name == "perceptron") {
return shared_ptr<regression_base>(new regression::perceptron(
config_cast_check<regression::perceptron::config>(param),
storage));
} else if (name == "CW" || name == "confidence_weighted") {
return shared_ptr<regression_base>(new regression::confidence_weighted(
config_cast_check<regression::confidence_weighted::config>(param),
storage));
} else if (name == "AROW") {
return shared_ptr<regression_base>(new regression::arow(
config_cast_check<regression::arow::config>(param),
storage));
} else if (name == "NHERD" || name == "normal_herd") {
return shared_ptr<regression_base>(new regression::normal_herd(
config_cast_check<regression::normal_herd::config>(param),
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"));
}
regression::nearest_neighbor_regression::config conf
= config_cast_check<regression::nearest_neighbor_regression::config>(
param);
jubatus::util::lang::shared_ptr<unlearner::unlearner_base> unlearner;
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, ""));
shared_ptr<regression_base> res(new regression::nearest_neighbor_regression(
nearest_neighbor_engine,
conf.nearest_neighbor_num));
if (unlearner) {
res->set_unlearner(unlearner);
}
return res;
} else if (name == "cosine") {
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"));
}
regression::inverted_index_regression::config conf
= config_cast_check<regression::inverted_index_regression::config>(param);
return shared_ptr<regression::cosine_similarity_regression> (
new regression::cosine_similarity_regression(conf.nearest_neighbor_num));
} else if (name == "euclidean") {
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"));
}
regression::inverted_index_regression::config conf
= config_cast_check<regression::inverted_index_regression::config>(param);
return shared_ptr<regression::euclidean_distance_regression> (
new regression::euclidean_distance_regression(conf.nearest_neighbor_num));
} else {
throw JUBATUS_EXCEPTION(common::unsupported_method(name));
}
}
