#include <arow.hpp>

Inheritance diagram for jubatus::core::classifier::arow:

Collaboration diagram for jubatus::core::classifier::arow:

Public Member Functions
	arow (storage_ptr storage)

	arow (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 alpha, float beta, 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 arow.hpp.

Constructor & Destructor Documentation

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

explicit

Definition at line 33 of file arow.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::arow::arow	(	const classifier_config &	config,
		storage_ptr	storage
	)

Definition at line 37 of file arow.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::arow::name ( ) const

virtual

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

Definition at line 101 of file arow.cpp.

                         {
   return string("arow");
 }

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

virtual

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

Definition at line 49 of file arow.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);
 
   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;
   }
 
   float beta = 1.f / (variance + 1.f / config_.regularization_weight);
   float alpha = (1.f - margin) * beta;  // max(0, 1 - margin) = 1 - margin
   update(sfv, alpha, beta, label, incorrect_label);
 }

Here is the call graph for this function:

void jubatus::core::classifier::arow::update	(	const common::sfv_t &	fv,
		float	alpha,
		float	beta,
		const std::string &	pos_label,
		const std::string &	neg_label
	)

private

Definition at line 66 of file arow.cpp.

References jubatus::core::classifier::ClassifierUtil::get_two(), 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);
 
     storage_->set2_nolock(
         feature,
         pos_label,
         storage::val2_t(
             pos_val.v1 + alpha * pos_val.v2 * val,
             pos_val.v2 - beta * pos_val.v2 * pos_val.v2 * val * val));
     if (neg_label != "") {
       storage_->set2_nolock(
           feature,
           neg_label,
           storage::val2_t(
               neg_val.v1 - alpha * neg_val.v2 * val,
               neg_val.v2 - beta * neg_val.v2 * neg_val.v2 * val * val));
     }
   }
   touch(pos_label);
 }