dataset_mapper.hpp

Go to the documentation of this file.

 
#ifndef MLPACK_CORE_DATA_DATASET_INFO_HPP
#define MLPACK_CORE_DATA_DATASET_INFO_HPP
 
#include <mlpack/prereqs.hpp>
#include <unordered_map>
 
#include "map_policies/increment_policy.hpp"
 
namespace mlpack {
namespace data {
 
template<typename PolicyType, typename InputType = std::string>
class DatasetMapper
{
 public:
  explicit DatasetMapper(const size_t dimensionality = 0);
 
  explicit DatasetMapper(PolicyType& policy, const size_t dimensionality = 0);
 
  void SetDimensionality(const size_t dimensionality);
 
  template<typename T>
  void MapFirstPass(const InputType& input, const size_t dimension);
 
  template<typename T>
  T MapString(const InputType& input,
              const size_t dimension);
 
  template<typename T>
  const InputType& UnmapString(const T value,
                               const size_t dimension,
                               const size_t unmappingIndex = 0) const;
 
  template<typename T>
  size_t NumUnmappings(const T value, const size_t dimension) const;
 
  typename PolicyType::MappedType UnmapValue(const InputType& input,
                                             const size_t dimension);
 
  Datatype Type(const size_t dimension) const;
  Datatype& Type(const size_t dimension);
 
  size_t NumMappings(const size_t dimension) const;
 
  size_t Dimensionality() const;
 
  template<typename Archive>
  void serialize(Archive& ar, const unsigned int /* version */)
  {
    ar & BOOST_SERIALIZATION_NVP(types);
    ar & BOOST_SERIALIZATION_NVP(maps);
  }
 
  const PolicyType& Policy() const;
 
  PolicyType& Policy();
  void Policy(PolicyType&& policy);
 
 private:
  std::vector<Datatype> types;
 
  // Forward mapping type.
  using ForwardMapType = typename std::unordered_map<InputType, typename
      PolicyType::MappedType>;
 
  // Reverse mapping type.  Multiple inputs may map to a single output, hence
  // the need for std::vector.
  using ReverseMapType = std::unordered_map<typename PolicyType::MappedType,
      std::vector<InputType>>;
 
  // Mappings from strings to integers.
  // Map entries will only exist for dimensions that are categorical.
  // MapType = map<dimension, pair<bimap<string, MappedType>, numMappings>>
  using MapType = std::unordered_map<size_t, std::pair<ForwardMapType,
      ReverseMapType>>;
 
  MapType maps;
 
  //  mapped to the maps object. It is used in MapString() and MapTokens().
  PolicyType policy;
};
 
// Use typedef to provide backward compatibility
using DatasetInfo = DatasetMapper<data::IncrementPolicy>;
 
} // namespace data
} // namespace mlpack
 
#include "dataset_mapper_impl.hpp"
 
#endif