algo::classification::LDC< T > Class Template Reference

Public Member Functions
	LDC ()
	LDC (const size_t &num_class, const double &lambda)
	LDC (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t &num_class)
	LDC (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t &num_class, const double &lambda)
	LDC (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t &num_class, const double &lambda, const arma::Row< T > &priors)
void	Train (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels)
void	Train (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t num_class)
void	Classify (const arma::Mat< T > &inputs, arma::Row< size_t > &labels) const
void	Classify (const arma::Mat< T > &inputs, arma::Row< size_t > &labels, arma::Mat< T > &scores) const
T	ComputeError (const arma::Mat< T > &points, const arma::Row< size_t > &responses) const
T	ComputeAccuracy (const arma::Mat< T > &points, const arma::Row< size_t > &responses) const
template<typename Archive >
void	serialize (Archive &ar, const unsigned int)

Public Attributes
size_t	dim_
size_t	num_class_
size_t	size_
double	lambda_
double	jitter_ = 1.e-8
std::map< size_t, arma::Row< T > >	means_
std::map< size_t, arma::Mat< T > >	covs_
arma::Mat< T >	cov_
arma::Mat< T >	mean_
arma::Row< size_t >	unique_
arma::Row< size_t >	class_
arma::Row< T >	priors_

Detailed Description

template<class T = DTYPE>
class algo::classification::LDC< T >

Definition at line 19 of file paramclass.h.

Constructor & Destructor Documentation

LDC() [1/5]

template<class T = DTYPE>

algo::classification::LDC< T >::LDC ( )

inline

Non-working model

Definition at line 26 of file paramclass.h.

: lambda_(0.) { };

LDC() [2/5]

template<class T = DTYPE>

algo::classification::LDC< T >::LDC ( const size_t &  num_class, const double &  lambda  )

inline

Parameters

lambda

: regularization

Definition at line 31 of file paramclass.h.

                                                        : num_class_(num_class),
                                                          lambda_(lambda) { } ;

LDC() [3/5]

template<class T >

algo::classification::LDC< T >::LDC	(	const arma::Mat< T > &	inputs,
		const arma::Row< size_t > &	labels,
		const size_t &	num_class
	)

Parameters

inputs	: X
labels	: y
num_class	: number of classes

Definition at line 19 of file paramclass_impl.h.

                                        :  num_class_(num_class), lambda_(0.)
{
  Train(inputs, labels);
}

References algo::classification::LDC< T >::Train().

Here is the call graph for this function:

LDC() [4/5]

template<class T >

algo::classification::LDC< T >::LDC	(	const arma::Mat< T > &	inputs,
		const arma::Row< size_t > &	labels,
		const size_t &	num_class,
		const double &	lambda
	)

Parameters

inputs	: X
labels	: y
num_class	: number of classes
lambda	: regularization

Definition at line 38 of file paramclass_impl.h.

                                     : num_class_(num_class), lambda_(lambda)
{
  Train(inputs, labels);
}

References algo::classification::LDC< T >::Train().

Here is the call graph for this function:

LDC() [5/5]

template<class T >

algo::classification::LDC< T >::LDC	(	const arma::Mat< T > &	inputs,
		const arma::Row< size_t > &	labels,
		const size_t &	num_class,
		const double &	lambda,
		const arma::Row< T > &	priors
	)

Parameters

inputs	: X
labels	: y
num_class	: number of classes
lambda	: regularization
priors	: known priors

Definition at line 27 of file paramclass_impl.h.

                                         : num_class_(num_class),
                                             lambda_(lambda), priors_(priors)
{
  Train(inputs, labels);
}

References algo::classification::LDC< T >::Train().

Here is the call graph for this function:

Member Function Documentation

Classify() [1/2]

template<class T >

void algo::classification::LDC< T >::Classify	(	const arma::Mat< T > &	inputs,
		arma::Row< size_t > &	labels
	)		const

Parameters

inputs	: X*
labels	: y*

Definition at line 94 of file paramclass_impl.h.

{
  arma::Mat<T> temp;
  Classify(inputs, labels, temp);
}

Classify() [2/2]

template<class T >

void algo::classification::LDC< T >::Classify	(	const arma::Mat< T > &	inputs,
		arma::Row< size_t > &	labels,
		arma::Mat< T > &	scores
	)		const

Parameters

inputs	: X*
labels	: y*
probs	: scores*

Definition at line 102 of file paramclass_impl.h.

{
  const size_t N = inputs.n_cols;
  labels.resize(N);
  probs.resize(num_class_,N);
  if ( unique_.n_elem == 1 )
  {
    labels.fill(unique_(0));
    probs.row(unique_(0)).fill(1.);
  }
  else
  {
    #pragma omp parallel for 
    for ( size_t n=0; n<inputs.n_cols; n++ ) 
    {
      for ( size_t c=0; c<unique_.n_elem; c++ )
      {
        probs(class_(unique_(c)),n) = std::log(priors_(c)) 
                       -  0.5*arma::dot(means_.at(unique_(c))*
                        cov_, means_.at(unique_(c)))
                    + arma::dot(inputs.col(n).t()*cov_,means_.at(unique_(c)));
      }
      labels(n) = class_(probs.col(n).index_max());
    }
 
    probs = arma::exp(probs.each_row() - arma::max(probs,0));
    probs = probs.each_row()/arma::sum(probs,0);
  }
 
}

ComputeAccuracy()

template<class T >

T algo::classification::LDC< T >::ComputeAccuracy	(	const arma::Mat< T > &	points,
		const arma::Row< size_t > &	responses
	)		const

Calculate the Accuracy

Parameters

inputs	: X*
labels	: y*

Definition at line 146 of file paramclass_impl.h.

{
  return (1. - ComputeError(points, responses))*100;
}

ComputeError()

template<class T >

T algo::classification::LDC< T >::ComputeError	(	const arma::Mat< T > &	points,
		const arma::Row< size_t > &	responses
	)		const

Calculate the Error Rate

Parameters

inputs	: X*
labels	: y*

Definition at line 136 of file paramclass_impl.h.

{
  arma::Row<size_t> predictions;
  Classify(points,predictions);
  arma::Row<size_t> temp =  predictions - responses; 
  return (arma::accu(temp != 0))/T(predictions.n_elem);
}

serialize()

template<class T = DTYPE>

template<typename Archive >

void algo::classification::LDC< T >::serialize ( Archive &  ar, const unsigned int    )

inline

Serialize the model.

Definition at line 119 of file paramclass.h.

  {
    ar (cereal::make_nvp("dim",dim_),
        cereal::make_nvp("num_class",num_class_),
        cereal::make_nvp("size",size_),
        cereal::make_nvp("lambda",lambda_),
        cereal::make_nvp("means",means_),
        cereal::make_nvp("covs",covs_),
        cereal::make_nvp("mean",mean_),
        cereal::make_nvp("cov",cov_),
        cereal::make_nvp("class",class_),
        cereal::make_nvp("unique",unique_),
        cereal::make_nvp("priors",priors_));
  }

Train() [1/2]

template<class T >

void algo::classification::LDC< T >::Train	(	const arma::Mat< T > &	inputs,
		const arma::Row< size_t > &	labels
	)

Parameters

inputs	: X
labels	: y

Definition at line 47 of file paramclass_impl.h.

{
  class_ = arma::regspace<arma::Row<size_t>>(0,1,num_class_);
  priors_ = get_prior<T>(labels, num_class_);
 
  dim_ = inputs.n_rows;
  size_ = inputs.n_cols;
  unique_ = arma::unique(labels);
  if (unique_.n_elem != 1)
  {
    cov_.resize(dim_,dim_);
    cov_.zeros();
    
    arma::Row<size_t>::iterator it = unique_.begin();
    arma::Row<size_t>::iterator end = unique_.end();
 
    arma::Mat<T> inx;
 
    for(; it!=end; it++)
    {
      auto extract = extract_class(inputs, labels, *it);
      inx = std::get<0>(extract);
      means_[*it] = arma::conv_to<arma::Row<T>>::from(arma::mean(inx,1));
      if ( inx.n_cols == 1 )
        covs_[*it] = arma::eye<arma::Mat<T>>(dim_,dim_);
      else
      {
        covs_[*it] = arma::cov(inx.t());
        covs_[*it].diag() += jitter_+lambda_;
      }
      cov_ += covs_[*it];
    }
    cov_ = arma::pinv(cov_) / num_class_;
  }
}

Referenced by algo::classification::LDC< T >::LDC().

Here is the caller graph for this function:

Train() [2/2]

template<class T >

void algo::classification::LDC< T >::Train	(	const arma::Mat< T > &	inputs,
		const arma::Row< size_t > &	labels,
		const size_t	num_class
	)

Parameters

inputs	: X
labels	: y
num_class	: number of classes

Definition at line 85 of file paramclass_impl.h.

{
  this->num_class_ = num_class;
  this->Train(inputs,labels);
}

---

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

• paramclass.h
• paramclass_impl.h