Collaboration diagram for jubatus::core::fv_converter::datum_to_fv_converter_impl:

Classes
struct	binary_feature_rule

struct	combination_feature_rule

struct	num_feature_rule

struct	num_filter_rule

struct	string_feature_rule

struct	string_filter_rule

Public Member Functions
void	add_weight (const std::string &key, float weight)

void	clear_rules ()

void	clear_weights ()

void	convert (const datum &datum, common::sfv_t &ret_fv) const

void	convert_and_update_weight (const datum &datum, common::sfv_t &ret_fv)

void	convert_unweighted (const datum &datum, common::sfv_t &ret_fv) const

	datum_to_fv_converter_impl ()

void	register_binary_rule (const std::string &name, jubatus::util::lang::shared_ptr< key_matcher > matcher, jubatus::util::lang::shared_ptr< binary_feature > feature_func)

void	register_combination_rule (const std::string &name, jubatus::util::lang::shared_ptr< key_matcher > matcher_left, jubatus::util::lang::shared_ptr< key_matcher > matcher_right, jubatus::util::lang::shared_ptr< combination_feature > feature_func)

void	register_num_filter (jubatus::util::lang::shared_ptr< key_matcher > matcher, jubatus::util::lang::shared_ptr< num_filter > filter, const std::string &suffix)

void	register_num_rule (const std::string &name, jubatus::util::lang::shared_ptr< key_matcher > matcher, jubatus::util::lang::shared_ptr< num_feature > feature_func)

void	register_string_filter (jubatus::util::lang::shared_ptr< key_matcher > matcher, jubatus::util::lang::shared_ptr< string_filter > filter, const std::string &suffix)

void	register_string_rule (const std::string &name, jubatus::util::lang::shared_ptr< key_matcher > matcher, jubatus::util::lang::shared_ptr< string_feature > splitter, const std::vector< splitter_weight_type > &weights)

void	revert_feature (const std::string &feature, std::pair< std::string, std::string > &expect) const

void	set_hash_max_size (uint64_t hash_max_size)

void	set_weight_manager (jubatus::util::lang::shared_ptr< weight_manager > wm)

Private Types
typedef jubatus::util::data::unordered_map< std::string, float >	weight_t

Private Member Functions
bool	contains_idf (const string_feature_rule &s) const

void	convert_binaries (const datum::sv_t &binary_values, common::sfv_t &ret_fv) const

void	convert_binaries (const binary_feature_rule &feature, const datum::sv_t &binary_values, common::sfv_t &ret_fv) const

void	convert_combinations (common::sfv_t &ret_fv) const

void	convert_num (const std::string &key, double value, common::sfv_t &ret_fv) const

void	convert_nums (const datum::nv_t &num_values, common::sfv_t &ret_fv) const

void	convert_strings (const datum::sv_t &string_values, common::sfv_t &ret_fv) const

void	convert_strings (const string_feature_rule &splitter, const datum::sv_t &string_values, common::sfv_t &ret_fv) const

void	count_words (const string_feature_rule &splitter, const std::string &key, const std::string &value, counter< std::string > &counter) const

void	filter_nums (const datum::nv_t &num_values, datum::nv_t &filtered_values) const

void	filter_strings (const datum::sv_t &string_values, datum::sv_t &filtered_values) const

std::string	get_global_weight_name (term_weight_type type) const

double	get_sample_weight (frequency_weight_type type, double tf, std::string &name) const

void	make_string_features (const std::string &key, const std::string &splitter_name, const splitter_weight_type &weight_type, const counter< std::string > &count, common::sfv_t &ret_fv) const

Static Private Member Functions
static void	check_key (const std::string &key)

static std::string	make_feature (const std::string &key, const std::string &value, const std::string &splitter, const std::string &sample_weight, const std::string &global_weight)

static std::string	make_feature_key (const std::string &key, const std::string &value, const std::string &splitter)

Private Attributes
std::vector< binary_feature_rule >	binary_rules_

std::vector< combination_feature_rule >	combination_rules_

jubatus::util::data::optional< feature_hasher >	hasher_

jubatus::util::lang::shared_ptr< mixable_weight_manager >	mixable_weights_

std::vector< num_filter_rule >	num_filter_rules_

std::vector< num_feature_rule >	num_rules_

std::vector< string_filter_rule >	string_filter_rules_

std::vector< string_feature_rule >	string_rules_

Detailed Description

impl

Definition at line 48 of file datum_to_fv_converter.cpp.

Member Typedef Documentation

typedef jubatus::util::data::unordered_map<std::string, float> jubatus::core::fv_converter::datum_to_fv_converter_impl::weight_t

private

Definition at line 50 of file datum_to_fv_converter.cpp.

Constructor & Destructor Documentation

jubatus::core::fv_converter::datum_to_fv_converter_impl::datum_to_fv_converter_impl ( )

inline

Definition at line 167 of file datum_to_fv_converter.cpp.

     : mixable_weights_(
         new mixable_weight_manager(
             jubatus::util::lang::shared_ptr<weight_manager>(
                 new weight_manager))) {
   }

Member Function Documentation

void jubatus::core::fv_converter::datum_to_fv_converter_impl::add_weight	(	const std::string &	key,
		float	weight
	)

inline

Definition at line 235 of file datum_to_fv_converter.cpp.

                                                       {
     jubatus::util::lang::shared_ptr<weight_manager> weights =
         mixable_weights_->get_model();
     if (weights) {
       (*weights).add_weight(key, weight);
     }
   }

static void jubatus::core::fv_converter::datum_to_fv_converter_impl::check_key ( const std::string & key )

inlinestaticprivate

Definition at line 445 of file datum_to_fv_converter.cpp.

References JUBATUS_EXCEPTION.

Referenced by convert_binaries(), convert_num(), make_feature(), and make_feature_key().

                                               {
     if (key.find('$') != std::string::npos) {
       throw JUBATUS_EXCEPTION(
           converter_exception("feature key cannot contain '$': " + key));
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::clear_rules ( )

inline

Definition at line 174 of file datum_to_fv_converter.cpp.

                      {
     string_filter_rules_.clear();
     num_filter_rules_.clear();
     string_rules_.clear();
     num_rules_.clear();
     binary_rules_.clear();
     combination_rules_.clear();
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::clear_weights ( )

inline

Definition at line 338 of file datum_to_fv_converter.cpp.

                        {
     jubatus::util::lang::shared_ptr<weight_manager> weights =
         mixable_weights_->get_model();
     if (weights) {
       weights->clear();
     }
   }

bool jubatus::core::fv_converter::datum_to_fv_converter_impl::contains_idf ( const string_feature_rule & s ) const

inlineprivate

Definition at line 380 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::IDF, and jubatus::core::fv_converter::datum_to_fv_converter_impl::string_feature_rule::weights_.

                                                         {
     for (size_t i = 0; i < s.weights_.size(); ++i) {
       if (s.weights_[i].term_weight_type_ == IDF) {
         return true;
       }
     }
     return false;
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert	(	const datum &	datum,
		common::sfv_t &	ret_fv
	)		const

inline

Definition at line 243 of file datum_to_fv_converter.cpp.

References convert_combinations(), and convert_unweighted().

                                                               {
     common::sfv_t fv;
     convert_unweighted(datum, fv);
     jubatus::util::lang::shared_ptr<weight_manager> weights =
         mixable_weights_->get_model();
     if (weights) {
       weights->get_weight(fv);
     }
 
     convert_combinations(fv);
 
     if (hasher_) {
       hasher_->hash_feature_keys(fv);
     }
 
     fv.swap(ret_fv);
   }

Here is the call graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_and_update_weight	(	const datum &	datum,
		common::sfv_t &	ret_fv
	)

inline

Definition at line 261 of file datum_to_fv_converter.cpp.

References convert_combinations(), and convert_unweighted().

                                                                           {
     common::sfv_t fv;
     convert_unweighted(datum, fv);
     jubatus::util::lang::shared_ptr<weight_manager> weights =
         mixable_weights_->get_model();
     if (weights) {
       weights->update_weight(fv);
       weights->get_weight(fv);
     }
 
     convert_combinations(fv);
 
     if (hasher_) {
       hasher_->hash_feature_keys(fv);
     }
 
     fv.swap(ret_fv);
   }

Here is the call graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_binaries	(	const datum::sv_t &	binary_values,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 405 of file datum_to_fv_converter.cpp.

Referenced by convert_unweighted().

                                                     {
     for (size_t i = 0; i < binary_rules_.size(); ++i) {
       convert_binaries(binary_rules_[i], binary_values, ret_fv);
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_binaries	(	const binary_feature_rule &	feature,
		const datum::sv_t &	binary_values,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 412 of file datum_to_fv_converter.cpp.

References check_key(), jubatus::core::fv_converter::datum_to_fv_converter_impl::binary_feature_rule::feature_func_, and jubatus::core::fv_converter::datum_to_fv_converter_impl::binary_feature_rule::matcher_.

                                  {
     for (size_t j = 0; j < binary_values.size(); ++j) {
       const std::string& key = binary_values[j].first;
       const std::string& value = binary_values[j].second;
       if (feature.matcher_->match(key)) {
         check_key(key);
         feature.feature_func_->add_feature(key, value, ret_fv);
       }
     }
   }

Here is the call graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_combinations ( common::sfv_t & ret_fv ) const

inlineprivate

Definition at line 548 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::datum_to_fv_converter_impl::combination_feature_rule::feature_func_, jubatus::core::fv_converter::datum_to_fv_converter_impl::combination_feature_rule::matcher_left_, jubatus::core::fv_converter::datum_to_fv_converter_impl::combination_feature_rule::matcher_right_, and jubatus::core::fv_converter::datum_to_fv_converter_impl::combination_feature_rule::name_.

Referenced by convert(), and convert_and_update_weight().

                                                        {
     const size_t original_size = ret_fv.size();
 
     if (original_size < 2) {
       // Must have at least 2 features to generate combinations.
       return;
     }
 
     for (size_t i = 0; i < combination_rules_.size(); ++i) {
       const combination_feature_rule& r = combination_rules_[i];
       for (size_t j = 0 ; j < original_size - 1; ++j) {
         for (size_t m = j + 1; m < original_size; ++m) {
           if (r.matcher_left_->match(ret_fv[j].first)
               && r.matcher_right_->match(ret_fv[m].first)) {
             r.feature_func_->add_feature(
                 ret_fv[j].first + "&" + ret_fv[m].first + "/" + r.name_,
                 ret_fv[j].second,
                 ret_fv[m].second,
                 ret_fv);
           }
         }
       }
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_num	(	const std::string &	key,
		double	value,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 535 of file datum_to_fv_converter.cpp.

References check_key(), jubatus::core::fv_converter::datum_to_fv_converter_impl::num_feature_rule::feature_func_, jubatus::core::fv_converter::datum_to_fv_converter_impl::num_feature_rule::matcher_, and jubatus::core::fv_converter::datum_to_fv_converter_impl::num_feature_rule::name_.

Referenced by convert_nums().

                                               {
     for (size_t i = 0; i < num_rules_.size(); ++i) {
       const num_feature_rule& r = num_rules_[i];
       if (r.matcher_->match(key)) {
         check_key(key);
         std::string k = key + "@" + r.name_;
         r.feature_func_->add_feature(k, value, ret_fv);
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_nums	(	const datum::nv_t &	num_values,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 528 of file datum_to_fv_converter.cpp.

References convert_num().

Referenced by convert_unweighted().

                                                {
     for (size_t i = 0; i < num_values.size(); ++i) {
       convert_num(num_values[i].first, num_values[i].second, ret_fv);
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_strings	(	const datum::sv_t &	string_values,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 373 of file datum_to_fv_converter.cpp.

Referenced by convert_unweighted().

                                                   {
     for (size_t i = 0; i < string_rules_.size(); ++i) {
       convert_strings(string_rules_[i], string_values, ret_fv);
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_strings	(	const string_feature_rule &	splitter,
		const datum::sv_t &	string_values,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 389 of file datum_to_fv_converter.cpp.

References count_words(), make_string_features(), jubatus::core::fv_converter::datum_to_fv_converter_impl::string_feature_rule::name_, and jubatus::core::fv_converter::datum_to_fv_converter_impl::string_feature_rule::weights_.

                                  {
     for (size_t j = 0; j < string_values.size(); ++j) {
       const std::string& key = string_values[j].first;
       const std::string& value = string_values[j].second;
       counter<std::string> counter;
       count_words(splitter, key, value, counter);
       for (size_t i = 0; i < splitter.weights_.size(); ++i) {
         make_string_features(
             key, splitter.name_, splitter.weights_[i], counter, ret_fv);
       }
     }
   }

Here is the call graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::convert_unweighted	(	const datum &	datum,
		common::sfv_t &	ret_fv
	)		const

inline

Definition at line 280 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::datum::binary_values_, convert_binaries(), convert_nums(), convert_strings(), filter_nums(), filter_strings(), jubatus::core::fv_converter::datum::num_values_, and jubatus::core::fv_converter::datum::string_values_.

Referenced by convert(), and convert_and_update_weight().

                                                                          {
     common::sfv_t fv;
 
     std::vector<std::pair<std::string, std::string> > filtered_strings;
     filter_strings(datum.string_values_, filtered_strings);
     convert_strings(datum.string_values_, fv);
     convert_strings(filtered_strings, fv);
 
     std::vector<std::pair<std::string, double> > filtered_nums;
     filter_nums(datum.num_values_, filtered_nums);
     convert_nums(datum.num_values_, fv);
     convert_nums(filtered_nums, fv);
 
     convert_binaries(datum.binary_values_, fv);
 
     fv.swap(ret_fv);
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::count_words	(	const string_feature_rule &	splitter,
		const std::string &	key,
		const std::string &	value,
		counter< std::string > &	counter
	)		const

inlineprivate

Definition at line 452 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::datum_to_fv_converter_impl::string_feature_rule::matcher_, and jubatus::core::fv_converter::datum_to_fv_converter_impl::string_feature_rule::splitter_.

Referenced by convert_strings().

                                          {
     if (splitter.matcher_->match(key)) {
       std::vector<string_feature_element> elements;
       splitter.splitter_->extract(value, elements);
 
       for (size_t i = 0; i < elements.size(); i++) {
         counter[elements[i].value] += elements[i].score;
       }
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::filter_nums	(	const datum::nv_t &	num_values,
		datum::nv_t &	filtered_values
	)		const

inlineprivate

Definition at line 360 of file datum_to_fv_converter.cpp.

Referenced by convert_unweighted().

                                         {
     for (size_t i = 0; i < num_filter_rules_.size(); ++i) {
       datum::nv_t update;
       num_filter_rules_[i].filter(num_values, update);
       num_filter_rules_[i].filter(filtered_values, update);
 
       filtered_values.insert(
           filtered_values.end(), update.begin(), update.end());
     }
   }

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::filter_strings	(	const datum::sv_t &	string_values,
		datum::sv_t &	filtered_values
	)		const

inlineprivate

Definition at line 347 of file datum_to_fv_converter.cpp.

Referenced by convert_unweighted().

                                         {
     for (size_t i = 0; i < string_filter_rules_.size(); ++i) {
       datum::sv_t update;
       string_filter_rules_[i].filter(string_values, update);
       string_filter_rules_[i].filter(filtered_values, update);
 
       filtered_values.insert(filtered_values.end(), update.begin(),
                              update.end());
     }
   }

Here is the caller graph for this function:

std::string jubatus::core::fv_converter::datum_to_fv_converter_impl::get_global_weight_name ( term_weight_type type ) const

inlineprivate

Definition at line 489 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::IDF, JUBATUS_EXCEPTION, jubatus::core::fv_converter::TERM_BINARY, and jubatus::core::fv_converter::WITH_WEIGHT_FILE.

Referenced by make_string_features().

                                                                 {
     switch (type) {
       case TERM_BINARY:
         return "bin";
       case IDF:
         return "idf";
       case WITH_WEIGHT_FILE:
         return "weight";
       default:
         throw JUBATUS_EXCEPTION(
           jubatus::core::common::exception::runtime_error(
             "unknown global weight type"));
     }
   }

Here is the caller graph for this function:

double jubatus::core::fv_converter::datum_to_fv_converter_impl::get_sample_weight	(	frequency_weight_type	type,
		double	tf,
		std::string &	name
	)		const

inlineprivate

Definition at line 467 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::FREQ_BINARY, jubatus::core::fv_converter::LOG_TERM_FREQUENCY, and jubatus::core::fv_converter::TERM_FREQUENCY.

Referenced by make_string_features().

                              {
     switch (type) {
       case FREQ_BINARY:
         name = "bin";
         return 1.0;
 
       case TERM_FREQUENCY:
         name = "tf";
         return tf;
 
       case LOG_TERM_FREQUENCY:
         name = "log_tf";
         return std::log(1. + tf);
 
       default:
         return 0;
     }
   }

Here is the caller graph for this function:

static std::string jubatus::core::fv_converter::datum_to_fv_converter_impl::make_feature	(	const std::string &	key,
		const std::string &	value,
		const std::string &	splitter,
		const std::string &	sample_weight,
		const std::string &	global_weight
	)

inlinestaticprivate

Definition at line 426 of file datum_to_fv_converter.cpp.

References check_key().

Referenced by make_string_features().

                                       {
     check_key(key);
     return key + "$" + value + "@" + splitter + "#" + sample_weight + "/" +
         global_weight;
   }

Here is the call graph for this function:

Here is the caller graph for this function:

static std::string jubatus::core::fv_converter::datum_to_fv_converter_impl::make_feature_key	(	const std::string &	key,
		const std::string &	value,
		const std::string &	splitter
	)

inlinestaticprivate

Definition at line 437 of file datum_to_fv_converter.cpp.

References check_key().

                                  {
     check_key(key);
     return key + "$" + value + "@" + splitter;
   }

Here is the call graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::make_string_features	(	const std::string &	key,
		const std::string &	splitter_name,
		const splitter_weight_type &	weight_type,
		const counter< std::string > &	count,
		common::sfv_t &	ret_fv
	)		const

inlineprivate

Definition at line 504 of file datum_to_fv_converter.cpp.

References jubatus::core::fv_converter::counter< T >::begin(), jubatus::core::fv_converter::counter< T >::end(), jubatus::core::fv_converter::splitter_weight_type::freq_weight_type_, get_global_weight_name(), get_sample_weight(), make_feature(), jubatus::core::fv_converter::splitter_weight_type::term_weight_type_, and jubatus::core::common::jsonconfig::v().

Referenced by convert_strings().

                                  {
     for (counter<std::string>::const_iterator it = count.begin();
          it != count.end(); ++it) {
       std::string sample_weight_name;
       double sample_weight = get_sample_weight(
           weight_type.freq_weight_type_, it->second, sample_weight_name);
 
       std::string global_weight_name = get_global_weight_name(
           weight_type.term_weight_type_);
       float v = static_cast<float>(sample_weight);
       if (v != 0.0) {
         std::string f = make_feature(
             key, it->first, splitter_name, sample_weight_name,
             global_weight_name);
         ret_fv.push_back(std::make_pair(f, v));
       }
     }
   }

Here is the call graph for this function:

Here is the caller graph for this function:

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_binary_rule	(	const std::string &	name,
		jubatus::util::lang::shared_ptr< key_matcher >	matcher,
		jubatus::util::lang::shared_ptr< binary_feature >	feature_func
	)

inline

Definition at line 215 of file datum_to_fv_converter.cpp.

                                                               {
     binary_rules_.push_back(binary_feature_rule(name, matcher, feature_func));
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_combination_rule	(	const std::string &	name,
		jubatus::util::lang::shared_ptr< key_matcher >	matcher_left,
		jubatus::util::lang::shared_ptr< key_matcher >	matcher_right,
		jubatus::util::lang::shared_ptr< combination_feature >	feature_func
	)

inline

Definition at line 222 of file datum_to_fv_converter.cpp.

                                                                    {
     combination_rules_.push_back(
         combination_feature_rule(
             name,
             matcher_left,
             matcher_right,
             feature_func));
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_num_filter	(	jubatus::util::lang::shared_ptr< key_matcher >	matcher,
		jubatus::util::lang::shared_ptr< num_filter >	filter,
		const std::string &	suffix
	)

inline

Definition at line 191 of file datum_to_fv_converter.cpp.

                                {
     num_filter_rule rule = { matcher, filter, suffix };
     num_filter_rules_.push_back(rule);
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_num_rule	(	const std::string &	name,
		jubatus::util::lang::shared_ptr< key_matcher >	matcher,
		jubatus::util::lang::shared_ptr< num_feature >	feature_func
	)

inline

Definition at line 208 of file datum_to_fv_converter.cpp.

                                                            {
     num_rules_.push_back(num_feature_rule(name, matcher, feature_func));
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_string_filter	(	jubatus::util::lang::shared_ptr< key_matcher >	matcher,
		jubatus::util::lang::shared_ptr< string_filter >	filter,
		const std::string &	suffix
	)

inline

Definition at line 183 of file datum_to_fv_converter.cpp.

                                {
     string_filter_rule rule = { matcher, filter, suffix };
     string_filter_rules_.push_back(rule);
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::register_string_rule	(	const std::string &	name,
		jubatus::util::lang::shared_ptr< key_matcher >	matcher,
		jubatus::util::lang::shared_ptr< string_feature >	splitter,
		const std::vector< splitter_weight_type > &	weights
	)

inline

Definition at line 199 of file datum_to_fv_converter.cpp.

                                                       {
     string_rules_.push_back(
         string_feature_rule(name, matcher, splitter, weights));
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::revert_feature	(	const std::string &	feature,
		std::pair< std::string, std::string > &	expect
	)		const

inline

Definition at line 298 of file datum_to_fv_converter.cpp.

References JUBATUS_EXCEPTION.

                                                    {
     // format of string feature is
     // "<KEY_NAME>$<VALUE>@<FEATURE_TYPE>#<SAMPLE_WEIGHT>/<GLOBAL_WEIGHT>"
     size_t sharp = feature.rfind('#');
     if (sharp == std::string::npos) {
       throw JUBATUS_EXCEPTION(
           converter_exception("this feature is not string feature"));
     }
     size_t at = feature.rfind('@', sharp);
     if (at == std::string::npos) {
       throw JUBATUS_EXCEPTION(
           converter_exception("this feature is not valid feature"));
     }
     size_t dollar = feature.rfind('$', at);
     if (dollar == std::string::npos) {
       throw JUBATUS_EXCEPTION(
           converter_exception("this feature is not valid feature"));
     }
     if (feature.substr(at + 1, sharp - at - 1) != "str") {
       throw JUBATUS_EXCEPTION(
           converter_exception("this feature is not revertible"));
     }
 
     std::string key(feature.substr(0, dollar));
     std::string value(feature.substr(dollar + 1, at - dollar - 1));
 
     expect.first.swap(key);
     expect.second.swap(value);
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::set_hash_max_size ( uint64_t hash_max_size )

inline

Definition at line 330 of file datum_to_fv_converter.cpp.

                                                  {
     hasher_ = feature_hasher(hash_max_size);
   }

void jubatus::core::fv_converter::datum_to_fv_converter_impl::set_weight_manager ( jubatus::util::lang::shared_ptr< weight_manager > wm )

inline

Definition at line 334 of file datum_to_fv_converter.cpp.

                                                                         {
     mixable_weights_->set_model(wm);
   }

Member Data Documentation

std::vector<binary_feature_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::binary_rules_

private

Definition at line 154 of file datum_to_fv_converter.cpp.

std::vector<combination_feature_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::combination_rules_

private

Definition at line 155 of file datum_to_fv_converter.cpp.

jubatus::util::data::optional<feature_hasher> jubatus::core::fv_converter::datum_to_fv_converter_impl::hasher_

private

Definition at line 164 of file datum_to_fv_converter.cpp.

jubatus::util::lang::shared_ptr<mixable_weight_manager> jubatus::core::fv_converter::datum_to_fv_converter_impl::mixable_weights_

private

Definition at line 162 of file datum_to_fv_converter.cpp.

std::vector<num_filter_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::num_filter_rules_

private

Definition at line 158 of file datum_to_fv_converter.cpp.

std::vector<num_feature_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::num_rules_

private

Definition at line 160 of file datum_to_fv_converter.cpp.

std::vector<string_filter_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::string_filter_rules_

private

Definition at line 157 of file datum_to_fv_converter.cpp.

std::vector<string_feature_rule> jubatus::core::fv_converter::datum_to_fv_converter_impl::string_rules_

private

Definition at line 159 of file datum_to_fv_converter.cpp.

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

jubatus/core/fv_converter/datum_to_fv_converter.cpp

Classes

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation