missing_policy.hpp

Go to the documentation of this file.

#ifndef MLPACK_CORE_DATA_MAP_POLICIES_MISSING_POLICY_HPP
#define MLPACK_CORE_DATA_MAP_POLICIES_MISSING_POLICY_HPP

#include <mlpack/prereqs.hpp>
#include <unordered_map>
#include <boost/bimap.hpp>
#include <mlpack/core/data/map_policies/datatype.hpp>
#include <limits>

namespace mlpack {
namespace data {
class MissingPolicy
{
 public:
  // typedef of MappedType
  using MappedType = double;

  MissingPolicy()
  {
    // Nothing to initialize here.
  }

  explicit MissingPolicy(std::set<std::string> missingSet) :
      missingSet(std::move(missingSet))
  {
    // Nothing to initialize here.
  }

  template <typename MapType>
  MappedType MapString(const std::string& string,
                       const size_t dimension,
                       MapType& maps,
                       std::vector<Datatype>& types)
  {
    // mute the unused parameter warning (does nothing here.)
    (void)types;
    // If this condition is true, either we have no mapping for the given string
    // or we have no mappings for the given dimension at all.  In either case,
    // we create a mapping.
    const double NaN = std::numeric_limits<double>::quiet_NaN();
    if (missingSet.count(string) != 0 &&
        (maps.count(dimension) == 0 ||
         maps[dimension].first.left.count(string) == 0))
    {
      // This string does not exist yet.
      typedef boost::bimap<std::string, MappedType>::value_type PairType;
      maps[dimension].first.insert(PairType(string, NaN));

      size_t& numMappings = maps[dimension].second;
      ++numMappings;
      return NaN;
    }
    else
    {
      // This string already exists in the mapping or not included in
      // the missingSet.
      return NaN;
    }
  }

  template <typename eT, typename MapType>
  void MapTokens(const std::vector<std::string>& tokens,
                 size_t& row,
                 arma::Mat<eT>& matrix,
                 MapType& maps,
                 std::vector<Datatype>& types)
  {
    // MissingPolicy allows double type matrix only, because it uses NaN.
    static_assert(std::is_same<eT, double>::value, "You must use double type "
        " matrix in order to apply MissingPolicy");

    std::stringstream token;
    for (size_t i = 0; i != tokens.size(); ++i)
    {
      token.str(tokens[i]);
      token>>matrix.at(row, i);
      // if the token is not number, map it.
      // or if token is a number, but is included in the missingSet, map it.
      if (token.fail() || missingSet.find(tokens[i]) != std::end(missingSet))
      {
        const eT val = static_cast<eT>(this->MapString(tokens[i], row, maps,
                                                       types));
        matrix.at(row, i) = val;
      }
      token.clear();
    }
  }

 private:
  // Note that missingSet and maps are different.
  // missingSet specifies which value/string should be mapped.
  std::set<std::string> missingSet;
}; // class MissingPolicy

} // namespace data
} // namespace mlpack

#endif