GaussianProcess.h

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <utility>
 
#include "AcquisitionFunction.h"
#include "GaussianHyperparameters.h"
#include "autopas/options/AcquisitionFunctionOption.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/Math.h"
#include "autopas/utils/NumberSet.h"
#include "autopas/utils/Random.h"
 
namespace autopas {
 
class GaussianProcess {
  friend GaussianHyperparameters;
 
  using Vector = Eigen::VectorXd;
 
  // number of samples to find optimal hyperparameters
  static constexpr size_t hp_sample_size = 10000;
  // number of hyperparameters
  static constexpr size_t hp_size = 100;
 
 public:
  GaussianProcess(size_t dims, double sigma, Random &rngRef);
 
  virtual ~GaussianProcess();
 
  void setDimension(size_t dims);
 
  void clear();
 
  [[nodiscard]] size_t numEvidence() const;
 
  [[nodiscard]] std::pair<const std::vector<Vector> &, const Vector &> getEvidence() const;
 
  void addEvidence(const Vector &input, double output, bool tuneHypers);
 
  [[nodiscard]] const Vector &getEvidenceMax() const;
 
  [[nodiscard]] double predictMean(const Vector &input) const;
 
  [[nodiscard]] double getDefaultVar() const;
 
  [[nodiscard]] double predictVar(const Vector &input) const;
 
  [[nodiscard]] double predictOutputPDF(const Vector &input, double output) const;
 
  [[nodiscard]] double predictOutputScaledPDF(const Vector &input, double output) const;
 
  [[nodiscard]] double calcAcquisition(AcquisitionFunctionOption af, const Vector &input) const;
 
  [[nodiscard]] Vector sampleAquisitionMax(AcquisitionFunctionOption af, const std::vector<Vector> &samples) const;
 
  [[nodiscard]] static std::tuple<std::vector<double>, std::vector<double>,
                                  std::vector<autopas::GaussianProcess::Vector>>
  generateHyperparameterSamples(size_t sampleSize, Random &rng, size_t dims, double sigma, double evidenceMinValue,
                                double evidenceMaxValue);
 
  [[nodiscard]] std::vector<GaussianHyperparameters> &getHyperparameters();
 
  void setHyperparameters(const std::vector<double> &sample_means, const std::vector<double> &sample_thetas,
                          const std::vector<autopas::GaussianProcess::Vector> &sample_dimScales);
 
  void normalizeHyperparameters();
 
 private:
  void tuneHyperparameters();
 
  [[nodiscard]] static double kernel(const Vector &input1, const Vector &input2, double theta,
                                     const autopas::GaussianProcess::Vector &dimScale);
 
  [[nodiscard]] autopas::GaussianProcess::Vector kernelVector(const Vector &input, double theta,
                                                              const autopas::GaussianProcess::Vector &dimScale) const;
 
  std::vector<Vector> _inputs;
  Vector _outputs;
 
  size_t _dims;
 
  double _evidenceMinValue;
  double _evidenceMaxValue;
  Vector _evidenceMaxVector;
 
  const double _sigma;
 
  std::vector<GaussianHyperparameters> _hypers;
 
  Random &_rng;
};
}  // namespace autopas