#include <confidence_weighted.hpp>

Inheritance diagram for jubatus::core::classifier::confidence_weighted:

Collaboration diagram for jubatus::core::classifier::confidence_weighted:

Public Member Functions
	confidence_weighted (storage_ptr storage)

	confidence_weighted (const classifier_config &config, storage_ptr storage)

std::string	name () const

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 &fv, float step_weigth, 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 confidence_weighted.hpp.

Constructor & Destructor Documentation

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

explicit

Definition at line 33 of file confidence_weighted.cpp.

34 : linear_classifier(storage) {

35 }

jubatus::core::classifier::linear_classifier::linear_classifier

linear_classifier(storage_ptr storage)

Definition: linear_classifier.cpp:42

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

Definition at line 37 of file confidence_weighted.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

string jubatus::core::classifier::confidence_weighted::name ( ) const

virtual

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

Definition at line 104 of file confidence_weighted.cpp.

                                        {
   return string("confidence_weighted");
 }

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

virtual

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

Definition at line 49 of file confidence_weighted.cpp.

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

                                                                            {
   check_touchable(label);
 
   const float C = config_.regularization_weight;
   string incorrect_label;
   float variance = 0.f;
   float margin = -calc_margin_and_variance(sfv, label, incorrect_label,
                                            variance);
   float b = 1.f + 2 * C * margin;
   float gamma = -b + std::sqrt(b * b - 8 * C * (margin - C * variance));
 
   if (gamma <= 0.f) {
     storage_->register_label(label);
     return;
   }
   gamma /= 4 * C * variance;
   update(sfv, gamma, label, incorrect_label);
 }

Here is the call graph for this function:

void jubatus::core::classifier::confidence_weighted::update	(	const common::sfv_t &	fv,
		float	step_weigth,
		const std::string &	pos_label,
		const std::string &	neg_label
	)

private

Definition at line 68 of file confidence_weighted.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 val2;
     storage_->get2_nolock(feature, val2);
 
     storage::val2_t pos_val(0.f, 1.f);
     storage::val2_t neg_val(0.f, 1.f);
     ClassifierUtil::get_two(val2, pos_label, neg_label, pos_val, neg_val);
 
     const float C = config_.regularization_weight;
     float covar_pos_step = 2.f * step_width * val * val * C;
     float covar_neg_step = 2.f * step_width * val * val * C;
 
     storage_->set2_nolock(
         feature,
         pos_label,
         storage::val2_t(pos_val.v1 + step_width * pos_val.v2 * val,
                         1.f / (1.f / pos_val.v2 + covar_pos_step)));
     if (neg_label != "") {
       storage_->set2_nolock(
           feature,
           neg_label,
           storage::val2_t(neg_val.v1 - step_width * neg_val.v2 * val,
                           1.f / (1.f / neg_val.v2 + covar_neg_step)));
     }
   }
   touch(pos_label);
 }