GaussianCluster.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <utility>
 
#include "autopas/options/AcquisitionFunctionOption.h"
#include "autopas/tuning/tuningStrategy/GaussianModel/GaussianModelTypes.h"
#include "autopas/tuning/tuningStrategy/GaussianModel/GaussianProcess.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/Math.h"
#include "autopas/utils/NumberSet.h"
#include "autopas/utils/Random.h"
#include "autopas/utils/WrapOpenMP.h"
#include "autopas/utils/logging/GaussianClusterLogger.h"
 
namespace autopas {
 
class GaussianCluster {
  // number of samples to find optimal hyperparameters
  static constexpr size_t hp_sample_size = 500;
  // number of hyperparameters
  static constexpr size_t hp_size = 25;
 
 public:
  enum WeightFunction {
    evidenceMatchingProbabilityGM,
    evidenceMatchingScaledProbabilityGM,
    wasserstein2
  };
 
  GaussianCluster(const std::vector<int> &dimRestriction, size_t continuousDims, WeightFunction weightFun, double sigma,
                  Random &rngRef, const GaussianModelTypes::VectorToStringFun &vectorToString = defaultVecToString,
                  const std::string &outputSuffix = "");
 
  ~GaussianCluster();
 
  [[nodiscard]] const std::vector<int> &getDimensions() const;
 
  void setDimensions(const std::vector<int> &newValue);
 
  [[nodiscard]] const GaussianProcess &getCluster(size_t index1D) const;
 
  void clear();
 
  [[nodiscard]] size_t numEvidence() const;
 
  void addEvidence(const GaussianModelTypes::VectorDiscrete &inputDiscrete,
                   const GaussianModelTypes::VectorContinuous &inputContinuous, double output);
 
  void addEvidence(const GaussianModelTypes::VectorPairDiscreteContinuous &input, double output);
 
  [[nodiscard]] GaussianModelTypes::VectorPairDiscreteContinuous getEvidenceMax() const;
 
  [[nodiscard]] std::vector<GaussianModelTypes::VectorAcquisition> sampleAcquisition(
      AcquisitionFunctionOption af, const GaussianModelTypes::NeighbourFunction &neighbourFun,
      const std::vector<GaussianModelTypes::VectorContinuous> &continuousSamples) const;
 
  void logDebugGraph(const GaussianModelTypes::NeighbourFunction &neighbourFun,
                     const std::vector<GaussianModelTypes::VectorContinuous> &continuousSamples) const;
  void setVectorToStringFun(const GaussianModelTypes::VectorToStringFun &fun);
 
  [[nodiscard]] GaussianModelTypes::VectorAcquisition sampleAcquisitionMax(
      AcquisitionFunctionOption af, const GaussianModelTypes::NeighbourFunction &neighbourFun,
      const std::vector<GaussianModelTypes::VectorContinuous> &continuousSamples) const;
 
  [[nodiscard]] std::vector<GaussianModelTypes::VectorPairDiscreteContinuous> sampleOrderedByAcquisition(
      AcquisitionFunctionOption af, const GaussianModelTypes::NeighbourFunction &neighbourFun,
      const std::vector<GaussianModelTypes::VectorContinuous> &continuousSamples) const;
 
  static std::string defaultVecToString(const GaussianModelTypes::VectorPairDiscreteContinuous &vec);
 
 private:
  void initClusters();
 
  [[nodiscard]] size_t getIndex(const GaussianModelTypes::VectorDiscrete &x) const;
 
  void discreteIncrement(GaussianModelTypes::VectorDiscrete &x) const;
 
  [[nodiscard]] std::tuple<std::vector<double>, std::vector<double>, std::vector<double>> precalculateDistributions(
      const GaussianModelTypes::VectorContinuous &continuousTuple) const;
 
  [[nodiscard]] std::vector<double> precalculateAcquisitions(AcquisitionFunctionOption af,
                                                             const std::vector<double> &means,
                                                             const std::vector<double> &vars) const;
 
  [[nodiscard]] GaussianModelTypes::NeighboursWeights initNeighbourWeights(
      const GaussianModelTypes::NeighbourFunction &neighbourFun) const;
 
  void updateNeighbourWeights(GaussianModelTypes::NeighboursWeights &neighbourWeights, const std::vector<double> &means,
                              const std::vector<double> &vars, const std::vector<double> &stddevs) const;
 
  std::vector<int> _dimRestriction;
  const size_t _continuousDims;
 
  std::vector<GaussianProcess> _clusters;
 
  std::vector<GaussianModelTypes::VectorDiscrete> _discreteVectorMap;
 
  WeightFunction _weightFun;
 
  double _evidenceMinValue;
  double _evidenceMaxValue;
  GaussianModelTypes::VectorPairDiscreteContinuous _evidenceMaxVector;
  size_t _numEvidence;
 
  const double _sigma;
 
  Random &_rng;
 
  std::unique_ptr<GaussianClusterLogger> _logger;
};
}  // namespace autopas