sparse_coding.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_METHODS_SPARSE_CODING_SPARSE_CODING_HPP
#define MLPACK_METHODS_SPARSE_CODING_SPARSE_CODING_HPP
 
#include <mlpack/prereqs.hpp>
#include <mlpack/methods/lars/lars.hpp>
 
// Include our three simple dictionary initializers.
#include "nothing_initializer.hpp"
#include "data_dependent_random_initializer.hpp"
#include "random_initializer.hpp"
 
namespace mlpack {
namespace sparse_coding {
 
class SparseCoding
{
 public:
  template<typename DictionaryInitializer = DataDependentRandomInitializer>
  SparseCoding(const arma::mat& data,
               const size_t atoms,
               const double lambda1,
               const double lambda2 = 0,
               const size_t maxIterations = 0,
               const double objTolerance = 0.01,
               const double newtonTolerance = 1e-6,
               const DictionaryInitializer& initializer =
                   DictionaryInitializer());
 
  SparseCoding(const size_t atoms = 0,
               const double lambda1 = 0,
               const double lambda2 = 0,
               const size_t maxIterations = 0,
               const double objTolerance = 0.01,
               const double newtonTolerance = 1e-6);
 
  template<typename DictionaryInitializer = DataDependentRandomInitializer>
  double Train(const arma::mat& data,
               const DictionaryInitializer& initializer =
                   DictionaryInitializer());
 
  void Encode(const arma::mat& data, arma::mat& codes);
 
  double OptimizeDictionary(const arma::mat& data,
                            const arma::mat& codes,
                            const arma::uvec& adjacencies);
 
  void ProjectDictionary();
 
  double Objective(const arma::mat& data, const arma::mat& codes) const;
 
  const arma::mat& Dictionary() const { return dictionary; }
  arma::mat& Dictionary() { return dictionary; }
 
  size_t Atoms() const { return atoms; }
  size_t& Atoms() { return atoms; }
 
  double Lambda1() const { return lambda1; }
  double& Lambda1() { return lambda1; }
 
  double Lambda2() const { return lambda2; }
  double& Lambda2() { return lambda2; }
 
  size_t MaxIterations() const { return maxIterations; }
  size_t& MaxIterations() { return maxIterations; }
 
  double ObjTolerance() const { return objTolerance; }
  double& ObjTolerance() { return objTolerance; }
 
  double NewtonTolerance() const { return newtonTolerance; }
  double& NewtonTolerance() { return newtonTolerance; }
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */);
 
 private:
  size_t atoms;
 
  arma::mat dictionary;
 
  double lambda1;
  double lambda2;
 
  size_t maxIterations;
  double objTolerance;
  double newtonTolerance;
};
 
} // namespace sparse_coding
} // namespace mlpack
 
// Include implementation.
#include "sparse_coding_impl.hpp"
 
#endif