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

Public Member Functions
	NMC ()
	NMC (const size_t &num_classes)
	NMC (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t &num_class)
	NMC (const arma::Mat< T > &inputs, const arma::Row< size_t > &labels, const size_t &num_class, const double &shrink)
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
const arma::Mat< T > &	Parameters () const
arma::Mat< T > &	Parameters ()
template<typename Archive >
void	serialize (Archive &ar, const unsigned int)

Detailed Description

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

Definition at line 301 of file paramclass.h.

Constructor & Destructor Documentation

NMC() [1/4]

template<class T = DTYPE>

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

inline

Non-working model

Definition at line 308 of file paramclass.h.

{ } ;

NMC() [2/4]

template<class T = DTYPE>

algo::classification::NMC< T >::NMC

(

const size_t &

num_classes

)

Parameters

num_class

: number of classes

NMC() [3/4]

template<class T >

algo::classification::NMC< T >::NMC	(	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 303 of file paramclass_impl.h.

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

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

Here is the call graph for this function:

NMC() [4/4]

template<class T >

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

Parameters

inputs	: X
labels	: y
num_class	: number of classes
shrink	: s

Definition at line 294 of file paramclass_impl.h.

                                     : shrink_(shrink), num_class_(num_class)
{
  Train(inputs, labels);
}

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

Here is the call graph for this function:

Member Function Documentation

Classify() [1/2]

template<class T >

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

Parameters

inputs	: X*
labels	: y*

Definition at line 368 of file paramclass_impl.h.

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

Classify() [2/2]

template<class T >

void algo::classification::NMC< 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 376 of file paramclass_impl.h.

{
  const size_t N =  inputs.n_cols;
  probs.resize(num_class_, N);
  labels.resize(N);
  if ( unique_.n_elem == 1 )
  {
    labels.fill(unique_(0));
    probs.row(unique_(0)).fill(1.);
  }
  else
  {
    arma::Mat<T> distances(num_class_, N);
    distances.fill(arma::datum::inf);
    for ( size_t j=0; j<N; j++ )
    {
      for ( size_t i=0; i<unique_.n_elem; i++ )
      { 
        distances(unique_(i), j) = metric_.Evaluate(parameters_.col(unique_(i))
                                                    ,inputs.col(j));
      }
        labels(j) = arma::index_min(distances.col(j));
    }
    if (unique_.n_elem == num_class_)
      probs = distances.each_row() / arma::sum(distances,0);
    else
    {
      for (arma::uword i = 0; i < distances.n_rows; ++i) 
      {
        // Check if the row contains any infinite values
        if (arma::is_finite(distances.row(i))) 
        // Perform the division for this row only if all values are finite 
        // and sum is nonzero
          probs.row(i) = distances.row(i) / arma::sum(distances, 0);
      }
    }
    probs.elem(arma::find_nonfinite(probs)).fill(1/num_class_);
  }
}

ComputeAccuracy()

template<class T >

T algo::classification::NMC< 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 430 of file paramclass_impl.h.

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

ComputeError()

template<class T >

T algo::classification::NMC< 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 419 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::NMC< T >::serialize ( Archive &  ar, const unsigned int    )

inline

Serialize the model.

Definition at line 391 of file paramclass.h.

  {
    ar (  cereal::make_nvp("parameters",parameters_),
          cereal::make_nvp("dim",dim_),
          cereal::make_nvp("num_class",num_class_),
          cereal::make_nvp("centroid",centroid_),
          cereal::make_nvp("unique",unique_),
          cereal::make_nvp("shrink",shrink_),
          cereal::make_nvp("size",size_) );
  }

Train() [1/2]

template<class T >

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

Parameters

inputs	: X
labels	: y

Definition at line 311 of file paramclass_impl.h.

{
  dim_ = inputs.n_rows;
  unique_ = arma::unique(labels);
  /* num_class_ = unique_.n_cols; */
  size_ =  inputs.n_cols;
  arma::vec nk(num_class_);
  parameters_.resize(inputs.n_rows, num_class_);
  arma::uvec index;
  arma::Row<size_t>::iterator it = unique_.begin();
  arma::Row<size_t>::iterator it_end = unique_.end();
  size_t counter =0;
  // you should just iterate over the unique labels here instead of starting 
  // from 0
 
  for ( ;it!=it_end; ++it)
  {
    auto extract = extract_class(inputs, labels, *it);
    index = std::get<1>(extract);
    nk(counter) = index.n_rows;
    parameters_.col(counter) = arma::mean(inputs.cols(index),1);
    counter++;
  }
  centroid_ = arma::mean(inputs, 1); 
  
  // Just for the shrinkage part 
  if (shrink_ > 0 && num_class_ != 1) 
  {
    arma::Mat<T> nk = arma::ones<arma::Mat<T>>(num_class_,1);
    arma::Mat<T> m = arma::sqrt(1./nk)-1/size_;
    arma::uvec labs = arma::conv_to<arma::uvec>::from(labels);
    arma::Mat<T> variance = arma::sum(
                              arma::pow(inputs - parameters_.cols(labs),2),1);
    arma::Mat<T> s = arma::sqrt(variance/(size_-num_class_)).t();
    arma::Mat<T> ms = m*s;
    arma::inplace_trans(ms);
    arma::Mat<T> devi = (parameters_.each_col() - centroid_) / ms;
    arma::Mat<T> signs = arma::sign(devi);
    arma::Mat<T> dev = arma::abs(devi) - shrink_;
    dev = arma::clamp(dev, 0, arma::datum::inf);
    dev  %= signs; 
    arma::Mat<T> msd = dev % ms;
    parameters_ = centroid_ + msd.each_col();
  }
}

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

Here is the caller graph for this function:

Train() [2/2]

template<class T >

void algo::classification::NMC< 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 359 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