discrete_distribution.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_DISTRIBUTIONS_DISCRETE_DISTRIBUTION_HPP
#define MLPACK_CORE_DISTRIBUTIONS_DISCRETE_DISTRIBUTION_HPP

#include <mlpack/prereqs.hpp>
#include <mlpack/core/util/log.hpp>
#include <mlpack/core/math/random.hpp>

namespace mlpack {
namespace distribution  {

class DiscreteDistribution
{
 public:
  DiscreteDistribution() :
      probabilities(std::vector<arma::vec>(1)){ /* Nothing to do. */ }

  DiscreteDistribution(const size_t numObservations) :
      probabilities(std::vector<arma::vec>(1,
          arma::ones<arma::vec>(numObservations) / numObservations))
  { /* Nothing to do. */ }

  DiscreteDistribution(const arma::Col<size_t>& numObservations)
  {
    for (size_t i = 0; i < numObservations.n_elem; i++)
    {
      const size_t numObs = size_t(numObservations[i]);
      if (numObs <= 0)
      {
        std::ostringstream oss;
        oss << "number of observations for dimension " << i << " is 0, but "
            << "must be greater than 0";
        throw std::invalid_argument(oss.str());
      }
      probabilities.push_back(arma::ones<arma::vec>(numObs) / numObs);
    }
  }

  DiscreteDistribution(const std::vector<arma::vec>& probabilities)
  {
    for (size_t i = 0; i < probabilities.size(); i++)
    {
      arma::vec temp = probabilities[i];
      double sum = accu(temp);
      if (sum > 0)
        this->probabilities.push_back(temp / sum);
      else
      {
        this->probabilities.push_back(arma::ones<arma::vec>(temp.n_elem)
            / temp.n_elem);
      }
    }
  }

  size_t Dimensionality() const { return probabilities.size(); }

  double Probability(const arma::vec& observation) const
  {
    double probability = 1.0;
    // Ensure the observation has the same dimension with the probabilities
    if (observation.n_elem != probabilities.size())
    {
      Log::Debug << "the obversation must has the same dimension with the probabilities"
          << "the observation's dimension is" << observation.n_elem << "but the dimension of "
          << "probabilities is" << probabilities.size() << std::endl;
      return probability;
    }
    for (size_t dimension = 0; dimension < observation.n_elem; dimension++)
    {
      // Adding 0.5 helps ensure that we cast the floating point to a size_t
      // correctly.
      const size_t obs = size_t(observation(dimension) + 0.5);

      // Ensure that the observation is within the bounds.
      if (obs >= probabilities[dimension].n_elem)
      {
        Log::Debug << "DiscreteDistribution::Probability(): received observation "
             << obs << "; observation must be in [0, " << probabilities[dimension].n_elem
             << "] for this distribution." << std::endl;
      }
      probability *= probabilities[dimension][obs];
    }

    return probability;
  }

  double LogProbability(const arma::vec& observation) const
  {
    // TODO: consider storing log probabilities instead?
    return log(Probability(observation));
  }

  arma::vec Random() const;

  void Train(const arma::mat& observations);

  void Train(const arma::mat& observations,
             const arma::vec& probabilities);

  arma::vec& Probabilities(const size_t dim = 0) { return probabilities[dim]; }
  const arma::vec& Probabilities(const size_t dim = 0) const
  { return probabilities[dim]; }

  template<typename Archive>
  void Serialize(Archive& ar, const unsigned int /* version */)
  {
    // We serialize the vector manually since there seem to be some problems
    // with some boost versions.
    size_t dimensionality;
    dimensionality = probabilities.size();
    ar & data::CreateNVP(dimensionality, "dimensionality");

    if (Archive::is_loading::value)
    {
      probabilities.clear();
      probabilities.resize(dimensionality);
    }

    for (size_t i = 0; i < dimensionality; ++i)
    {
      std::ostringstream oss;
      oss << "probabilities" << i;
      ar & data::CreateNVP(probabilities[i], oss.str());
    }
  }

 private:
  std::vector<arma::vec> probabilities;
};

} // namespace distribution
} // namespace mlpack

#endif