Classes
class	add_filter

class	binary_feature

class	binary_feature_factory

struct	binary_rule

class	character_ngram

class	combination_add_feature

class	combination_feature

class	combination_feature_factory

class	combination_mul_feature

struct	combination_rule

struct	converter_config

class	converter_exception

class	counter

struct	datum

class	datum_to_fv_converter

class	datum_to_fv_converter_impl
	impl More...

class	exact_match

class	except_match

class	factory_extender

class	feature_hasher

struct	filter_rule

class	gaussian_normalization_filter

class	json_converter

class	key_matcher

class	key_matcher_factory

class	keyword_weights

class	libsvm_converter

class	linear_normalization_filter

class	match_all

class	msgpack_converter

class	num_feature

class	num_feature_factory

class	num_filter

class	num_filter_factory

class	num_log_feature

struct	num_rule

class	num_string_feature

class	num_value_feature

class	prefix_match

class	regexp_filter

class	regexp_match

class	regexp_splitter

class	sigmoid_normalization_filter

class	space_splitter

struct	splitter_weight_type

class	string_feature

struct	string_feature_element

class	string_feature_factory

class	string_filter

class	string_filter_factory

struct	string_rule

class	suffix_match

struct	versioned_weight_diff

class	weight_manager

class	without_split

class	word_splitter

Typedefs
typedef framework::linear_mixable_helper< weight_manager, versioned_weight_diff >	mixable_weight_manager

typedef std::map< std::string, std::string >	param_t

Enumerations
enum	frequency_weight_type { FREQ_BINARY, TERM_FREQUENCY, LOG_TERM_FREQUENCY }

enum	term_weight_type { TERM_BINARY, IDF, WITH_WEIGHT_FILE }

Functions
int	get_int_or_die (const std::map< std::string, std::string > &params, const std::string &key)

const std::string &	get_or_die (const std::map< std::string, std::string > &params, const std::string &key)

std::string	get_with_default (const std::map< std::string, std::string > &params, const std::string &key, const std::string &default_value)

void	initialize_converter (const converter_config &config, datum_to_fv_converter &conv, const factory_extender *ext)

jubatus::util::lang::shared_ptr< datum_to_fv_converter >	make_fv_converter (const converter_config &config, const factory_extender *extender)

void	revert_feature (const common::sfv_t &fv, fv_converter::datum &data)

bool	revert_num_value (const std::pair< std::string, float > &feature, std::pair< std::string, float > &num_value)

bool	revert_string_value (const std::pair< std::string, float > &feature, std::pair< std::string, std::string > &string_value)

Typedef Documentation

typedef framework::linear_mixable_helper<weight_manager, versioned_weight_diff> jubatus::core::fv_converter::mixable_weight_manager

Definition at line 29 of file mixable_weight_manager.hpp.

typedef std::map<std::string, std::string> jubatus::core::fv_converter::param_t

Definition at line 28 of file type.hpp.

Enumeration Type Documentation

enum jubatus::core::fv_converter::frequency_weight_type

Enumerator
FREQ_BINARY
TERM_FREQUENCY
LOG_TERM_FREQUENCY

Definition at line 33 of file datum_to_fv_converter.hpp.

                            {
   FREQ_BINARY,
   TERM_FREQUENCY,
   LOG_TERM_FREQUENCY
 };

enum jubatus::core::fv_converter::term_weight_type

Enumerator
TERM_BINARY
IDF
WITH_WEIGHT_FILE

Definition at line 39 of file datum_to_fv_converter.hpp.

                       {
   TERM_BINARY,
   IDF,
   WITH_WEIGHT_FILE
 };

Function Documentation

int jubatus::core::fv_converter::get_int_or_die	(	const std::map< std::string, std::string > &	params,
		const std::string &	key
	)

Definition at line 51 of file util.cpp.

References get_or_die(), and JUBATUS_EXCEPTION.

                           {
   const std::string& s = get_or_die(params, key);
   try {
     return jubatus::util::lang::lexical_cast<int>(s);
   } catch (const std::bad_cast&) {
     throw JUBATUS_EXCEPTION(converter_exception(
         std::string("\"" + key + "\" must be an integer value: " + s)));
   }
 }

Here is the call graph for this function:

const std::string & jubatus::core::fv_converter::get_or_die	(	const std::map< std::string, std::string > &	params,
		const std::string &	key
	)

Definition at line 28 of file util.cpp.

References JUBATUS_EXCEPTION.

Referenced by get_int_or_die().

                           {
   std::map<std::string, std::string>::const_iterator it = params.find(key);
   if (it == params.end()) {
     throw JUBATUS_EXCEPTION(converter_exception(
         std::string("\"" + key + "\" is not specified in parameters")));
   }
   return it->second;
 }

Here is the caller graph for this function:

std::string jubatus::core::fv_converter::get_with_default	(	const std::map< std::string, std::string > &	params,
		const std::string &	key,
		const std::string &	default_value
	)

Definition at line 39 of file util.cpp.

                                     {
   std::map<std::string, std::string>::const_iterator it = params.find(key);
   if (it == params.end()) {
     return default_value;
   } else {
     return it->second;
   }
 }

void jubatus::core::fv_converter::initialize_converter	(	const converter_config &	config,
		datum_to_fv_converter &	conv,
		const factory_extender *	ext
	)

Definition at line 363 of file converter_config.cpp.

Referenced by make_fv_converter(), make_fv_converter(), and make_tf_idf_fv_converter().

                                  {
   using jubatus::util::lang::bind;
   using jubatus::util::lang::_1;
   using jubatus::util::lang::_2;
 
   if (config.hash_max_size.bool_test() && *config.hash_max_size.get() <= 0) {
     stringstream msg;
     msg << "hash_max_size must be positive, but is "
         << *config.hash_max_size.get();
     throw JUBATUS_EXCEPTION(converter_exception(msg.str()));
   }
 
   map<string, string_filter_ptr> string_filters;
   if (config.string_filter_types) {
     string_filter_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_string_filter, ext, _1, _2);
     }
     init_string_filter_types(*config.string_filter_types, string_filters, f);
   }
 
   map<string, num_filter_ptr> num_filters;
   if (config.num_filter_types) {
     num_filter_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_num_filter, ext, _1, _2);
     }
     init_num_filter_types(*config.num_filter_types, num_filters, f);
   }
 
   map<string, string_feature_ptr> splitters;
   register_default_string_types(splitters);
   if (config.string_types) {
     string_feature_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_string_feature, ext, _1, _2);
     }
     init_string_types(*config.string_types, splitters, f);
   }
 
   map<string, num_feature_ptr> num_features;
   register_default_num_types(num_features);
   if (config.num_types) {
     num_feature_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_num_feature, ext, _1, _2);
     }
     init_num_types(*config.num_types, num_features, f);
   }
 
   map<string, binary_feature_ptr> binary_features;
   if (config.binary_types) {
     binary_feature_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_binary_feature, ext, _1, _2);
     }
     init_binary_types(*config.binary_types, binary_features, f);
   }
 
   map<string, combination_feature_ptr> combination_features;
   register_default_combination_types(combination_features);
   if (config.combination_types) {
     combination_feature_factory::create_function f;
     if (ext) {
       f = bind(&factory_extender::create_combination_feature, ext, _1, _2);
     }
     init_combination_types(*config.combination_types, combination_features, f);
   }
 
   conv.clear_rules();
   if (config.string_filter_rules) {
     init_string_filter_rules(*config.string_filter_rules, string_filters, conv);
   }
   if (config.num_filter_rules) {
     init_num_filter_rules(*config.num_filter_rules, num_filters, conv);
   }
   if (config.string_rules) {
     init_string_rules(*config.string_rules, splitters, conv);
   }
   if (config.num_rules) {
     init_num_rules(*config.num_rules, num_features, conv);
   }
   if (config.binary_rules) {
     init_binary_rules(*config.binary_rules, binary_features, conv);
   }
   if (config.combination_rules) {
     init_combination_rules(
         *config.combination_rules,
         combination_features, conv);
   }
 
   if (config.hash_max_size.bool_test()) {
     conv.set_hash_max_size(*config.hash_max_size.get());
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

jubatus::util::lang::shared_ptr< datum_to_fv_converter > jubatus::core::fv_converter::make_fv_converter	(	const converter_config &	config,
		const factory_extender *	extender
	)

Definition at line 462 of file converter_config.cpp.

References initialize_converter().

                                                                       {
   jubatus::util::lang::shared_ptr<fv_converter::datum_to_fv_converter>
     converter(new fv_converter::datum_to_fv_converter);
   fv_converter::initialize_converter(config, *converter, extender);
   return converter;
 }

Here is the call graph for this function:

void jubatus::core::fv_converter::revert_feature	(	const common::sfv_t &	fv,
		fv_converter::datum &	data
	)

Definition at line 31 of file revert.cpp.

References jubatus::core::fv_converter::datum::num_values_, revert_num_value(), revert_string_value(), and jubatus::core::fv_converter::datum::string_values_.

Referenced by jubatus::core::driver::recommender::complete_row_from_datum(), jubatus::core::driver::recommender::complete_row_from_id(), jubatus::core::driver::recommender::decode_row(), and jubatus::core::driver::clustering::to_datum().

                                                                     {
   for (size_t i = 0; i < fv.size(); ++i) {
     std::pair<std::string, float> num_value;
     std::pair<std::string, std::string> string_value;
     if (revert_num_value(fv[i], num_value)) {
       data.num_values_.push_back(num_value);
     } else if (revert_string_value(fv[i], string_value)) {
       data.string_values_.push_back(string_value);
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

bool jubatus::core::fv_converter::revert_num_value	(	const std::pair< std::string, float > &	feature,
		std::pair< std::string, float > &	num_value
	)

Definition at line 43 of file revert.cpp.

Referenced by revert_feature().

                                           {
   // Only 'num' features and 'str' features can be reverted.
   // Formats of two features are below:
   // ("<KEY_NAME>@num", value)
   // ("<KEY_NAME>@str$<VALUE>", 1)
   const std::string& key = feature.first;
   float value = feature.second;
   size_t at = key.rfind('@');
   if (at == std::string::npos) {
     return false;
   }
   std::string num_value_key(key.substr(0, at));
   std::string feature_value(key.substr(at + 1));
   const std::string str_prefix = "str$";
   if (feature_value == "num") {
     num_value.first.swap(num_value_key);
     num_value.second = value;
     return true;
   } else if (starts_with(feature_value, str_prefix)) {
     std::string val_string(feature_value.substr(str_prefix.size()));
     try {
       float val = jubatus::util::lang::lexical_cast<float>(val_string);
       num_value.first.swap(num_value_key);
       num_value.second = val;
       return true;
     } catch (const std::bad_cast&) {
       return false;
     }
   } else {
     return false;
   }
 }

Here is the caller graph for this function:

bool jubatus::core::fv_converter::revert_string_value	(	const std::pair< std::string, float > &	feature,
		std::pair< std::string, std::string > &	string_value
	)

Definition at line 78 of file revert.cpp.

Referenced by revert_feature().

                                                  {
   // Format of string feature is
   // "<KEY_NAME>$<VALUE>@<FEATURE_TYPE>#<SAMPLE_WEIGHT>/<GLOBAL_WEIGHT>"
   const std::string& f = feature.first;
   size_t sharp = f.rfind('#');
   if (sharp == std::string::npos) {
     return false;
   }
   size_t at = f.rfind('@', sharp);
   if (at == std::string::npos) {
     return false;
   }
   size_t dollar = f.find('$');
   if (dollar == std::string::npos) {
     return false;
   }
   if (f.substr(at + 1, sharp - at - 1) != "str") {
     return false;
   }
 
   std::string key(f.substr(0, dollar));
   std::string value(f.substr(dollar + 1, at - dollar - 1));
 
   string_value.first.swap(key);
   string_value.second.swap(value);
   return true;
 }

Here is the caller graph for this function:

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation