FeatureVectorEncoder.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <numeric>
#include <optional>
#include <vector>
 
#include "FeatureVector.h"
#include "autopas/utils/NumberSet.h"
 
namespace autopas {
 
class FeatureVectorEncoder {
  enum class DiscreteIndices { containerTraversalEstimator, dataLayout, newton3, vecPattern, TOTALNUMBER };
 
  enum class ContinuousIndices { cellSizeFactor, TOTALNUMBER };
 
 public:
  static constexpr size_t tunableDiscreteDims{static_cast<size_t>(DiscreteIndices::TOTALNUMBER)};
 
  static constexpr size_t tunableContinuousDims{static_cast<size_t>(ContinuousIndices::TOTALNUMBER)};
 
 private:
  using DiscreteDimensionType = std::array<int, tunableDiscreteDims>;
  using ContinuousDimensionType = std::array<double, tunableContinuousDims>;
 
 public:
  FeatureVectorEncoder();
 
  FeatureVectorEncoder(
      const std::vector<FeatureVector::ContainerTraversalEstimatorOption> &containerTraversalEstimatorOptions,
      const std::vector<DataLayoutOption> &dataLayoutOptions, const std::vector<Newton3Option> &newton3Options,
      const NumberSet<double> &cellSizeFactors, const InteractionTypeOption &interactionType,
      const std::vector<VectorizationPatternOption> &vecPatternOptions);
 
  ~FeatureVectorEncoder();
 
  void setAllowedOptions(
      const std::vector<FeatureVector::ContainerTraversalEstimatorOption> &containerTraversalEstimatorOptions,
      const std::vector<DataLayoutOption> &dataLayoutOptions, const std::vector<Newton3Option> &newton3Options,
      const NumberSet<double> &cellSizeFactors, const std::vector<VectorizationPatternOption> &vecPatternOptions);
 
  [[nodiscard]] size_t getOneHotDims() const;
 
  [[nodiscard]] const std::array<int, tunableDiscreteDims> &getDiscreteRestrictions() const;
 
  [[nodiscard]] Eigen::VectorXd oneHotEncode(const FeatureVector &vec) const;
 
  [[nodiscard]] FeatureVector oneHotDecode(const Eigen::VectorXd &vec);
 
  [[nodiscard]] std::pair<Eigen::VectorXi, Eigen::VectorXd> convertToCluster(const FeatureVector &vec,
                                                                             double iteration) const;
 
  [[nodiscard]] FeatureVector convertFromCluster(const std::pair<Eigen::VectorXi, Eigen::VectorXd> &vec);
 
  [[nodiscard]] std::vector<std::pair<Eigen::VectorXi, double>> clusterNeighboursManhattan1(
      const Eigen::VectorXi &target);
 
  [[nodiscard]] std::vector<std::pair<Eigen::VectorXi, double>> clusterNeighboursManhattan1Container(
      const Eigen::VectorXi &target);
 
  std::vector<FeatureVector> lhsSampleFeatures(size_t n, Random &rng) const;
 
  std::vector<Eigen::VectorXd> lhsSampleFeatureCluster(size_t n, Random &rng, double iteration) const;
 
 private:
  [[nodiscard]] std::pair<DiscreteDimensionType, ContinuousDimensionType> convertToTunable(
      const FeatureVector &vec) const;
 
  [[nodiscard]] FeatureVector convertFromTunable(const DiscreteDimensionType &discreteValues,
                                                 const ContinuousDimensionType &continuousValues) const;
 
  template <typename T>
  static size_t getIndex(const std::vector<T> &list, const T &value) {
    for (size_t i = 0; i < list.size(); ++i) {
      if (list[i] == value) return i;
    }
 
    utils::ExceptionHandler::exception("FeatureVectorEncoder.getIndex: Value not allowed!");
    return list.size();
  }
 
  std::vector<FeatureVector::ContainerTraversalEstimatorOption> _containerTraversalEstimatorOptions{};
  std::vector<DataLayoutOption> _dataLayoutOptions{};
  std::vector<Newton3Option> _newton3Options{};
  std::vector<VectorizationPatternOption> _vecPatternOptions{};
  InteractionTypeOption _interactionType;
  std::array<int, tunableDiscreteDims> _discreteRestrictions{};
 
  std::array<std::unique_ptr<NumberSet<double>>, tunableContinuousDims> _continuousRestrictions{};
 
  size_t _oneHotDims{0};
};
 
}  // namespace autopas