#include <normal_herd.hpp>

Inheritance diagram for jubatus::core::classifier::normal_herd:

Collaboration diagram for jubatus::core::classifier::normal_herd:

Public Member Functions
std::string	name () const

	normal_herd (storage_ptr storage)

	normal_herd (const classifier_config &config, storage_ptr storage)

void	train (const common::sfv_t &fv, const std::string &label)

Public Member Functions inherited from jubatus::core::classifier::linear_classifier
std::string	classify (const common::sfv_t &fv) const

void	classify_with_scores (const common::sfv_t &fv, classify_result &scores) const

void	clear ()

bool	delete_label (const std::string &label)

std::vector< std::string >	get_labels () const

framework::mixable *	get_mixable ()

virtual void	get_status (std::map< std::string, std::string > &status) const

jubatus::util::lang::shared_ptr< unlearner::unlearner_base >	label_unlearner () const

	linear_classifier (storage_ptr storage)

void	pack (framework::packer &pk) const

bool	set_label (const std::string &label)

void	set_label_unlearner (jubatus::util::lang::shared_ptr< unlearner::unlearner_base > label_unlearner)

bool	unlearn_label (const std::string &label)

void	unpack (msgpack::object o)

virtual	~linear_classifier ()

Public Member Functions inherited from jubatus::core::classifier::classifier_base
	classifier_base ()

virtual	~classifier_base ()

Private Member Functions
void	update (const common::sfv_t &sfv, float margin, float variance, const std::string &pos_label, const std::string &neg_label)

Private Attributes
classifier_config	config_

Additional Inherited Members
Protected Member Functions inherited from jubatus::core::classifier::linear_classifier
float	calc_margin (const common::sfv_t &sfv, const std::string &label, std::string &incorrect_label) const

float	calc_margin_and_variance (const common::sfv_t &sfv, const std::string &label, std::string &incorrect_label, float &variance) const

void	check_touchable (const std::string &label)

std::string	get_largest_incorrect_label (const common::sfv_t &sfv, const std::string &label, classify_result &scores) const

void	touch (const std::string &label)

void	update_weight (const common::sfv_t &sfv, float step_weigth, const std::string &pos_label, const std::string &neg_class)

Static Protected Member Functions inherited from jubatus::core::classifier::linear_classifier
static float	squared_norm (const common::sfv_t &sfv)

Protected Attributes inherited from jubatus::core::classifier::linear_classifier
framework::linear_function_mixer	mixable_storage_

storage_ptr	storage_

jubatus::util::lang::shared_ptr< unlearner::unlearner_base >	unlearner_

Detailed Description

Definition at line 28 of file normal_herd.hpp.

Constructor & Destructor Documentation

jubatus::core::classifier::normal_herd::normal_herd ( storage_ptr storage )

explicit

Definition at line 33 of file normal_herd.cpp.

References config_, and jubatus::core::classifier::classifier_config::regularization_weight.

     : linear_classifier(storage) {
   config_.regularization_weight = 0.1f;
 }

jubatus::core::classifier::normal_herd::normal_herd	(	const classifier_config &	config,
		storage_ptr	storage
	)

Definition at line 38 of file normal_herd.cpp.

References JUBATUS_EXCEPTION, and jubatus::core::classifier::classifier_config::regularization_weight.

     : linear_classifier(storage),
       config_(config) {
 
   if (!(0.f < config.regularization_weight)) {
     throw JUBATUS_EXCEPTION(
         common::invalid_parameter("0.0 < regularization_weight"));
   }
 }

Member Function Documentation

std::string jubatus::core::classifier::normal_herd::name ( ) const

virtual

Implements jubatus::core::classifier::linear_classifier.

Definition at line 111 of file normal_herd.cpp.

                                   {
   return string("normal_herd");
 }

void jubatus::core::classifier::normal_herd::train	(	const common::sfv_t &	fv,
		const std::string &	label
	)

virtual

Implements jubatus::core::classifier::linear_classifier.

Definition at line 50 of file normal_herd.cpp.

References jubatus::core::classifier::linear_classifier::calc_margin_and_variance(), jubatus::core::classifier::linear_classifier::check_touchable(), jubatus::core::classifier::linear_classifier::storage_, and update().

                                                                    {
   check_touchable(label);
 
   string incorrect_label;
   float variance = 0.f;
   float margin = -calc_margin_and_variance(sfv, label, incorrect_label,
                                            variance);
   if (margin >= 1.f) {
     storage_->register_label(label);
     return;
   }
   update(sfv, margin, variance, label, incorrect_label);
 }

Here is the call graph for this function:

void jubatus::core::classifier::normal_herd::update	(	const common::sfv_t &	sfv,
		float	margin,
		float	variance,
		const std::string &	pos_label,
		const std::string &	neg_label
	)

private

Definition at line 64 of file normal_herd.cpp.

References config_, jubatus::core::classifier::ClassifierUtil::get_two(), jubatus::core::classifier::classifier_config::regularization_weight, jubatus::core::classifier::linear_classifier::storage_, jubatus::core::classifier::linear_classifier::touch(), jubatus::core::storage::val2_t::v1, and jubatus::core::storage::val2_t::v2.

Referenced by train().

                              {
   util::concurrent::scoped_lock lk(storage_->get_lock());
   for (common::sfv_t::const_iterator it = sfv.begin(); it != sfv.end(); ++it) {
     const string& feature = it->first;
     float val = it->second;
     storage::feature_val2_t ret;
     storage_->get2_nolock(feature, ret);
 
     storage::val2_t pos_val(0.f, 1.f);
     storage::val2_t neg_val(0.f, 1.f);
     ClassifierUtil::get_two(ret, pos_label, neg_label, pos_val, neg_val);
 
     float val_covariance_pos = val * pos_val.v2;
     float val_covariance_neg = val * neg_val.v2;
 
     const float C = config_.regularization_weight;
     storage_->set2_nolock(
         feature,
         pos_label,
         storage::val2_t(
             pos_val.v1
                 + (1.f - margin) * val_covariance_pos
                     / (variance + 1.f / C),
             1.f
                 / ((1.f / pos_val.v2) + (2 * C + C * C * variance)
                     * val * val)));
     if (neg_label != "") {
       storage_->set2_nolock(
           feature,
           neg_label,
           storage::val2_t(
               neg_val.v1
                   - (1.f - margin) * val_covariance_neg
                       / (variance + 1.f / C),
               1.f
                   / ((1.f / neg_val.v2) + (2 * C + C * C * variance)
                       * val * val)));
     }
   }
   touch(pos_label);
 }