PredictiveTuning.h

Go to the documentation of this file.

 
#pragma once
 
#include <limits>
#include <set>
#include <utility>
 
#include "TuningStrategyInterface.h"
#include "autopas/containers/CompatibleLoadEstimators.h"
#include "autopas/containers/CompatibleTraversals.h"
#include "autopas/options/ExtrapolationMethodOption.h"
#include "autopas/tuning/Configuration.h"
#include "autopas/tuning/searchSpace/EvidenceCollection.h"
#include "autopas/tuning/selectors/OptimumSelector.h"
#include "autopas/utils/ExceptionHandler.h"
#include "autopas/utils/Math.h"
#include "autopas/utils/logging/PredictionLogger.h"
 
namespace autopas {
 
class PredictiveTuning final : public TuningStrategyInterface {
 public:
  using PredictionsType = std::unordered_map<Configuration, long, ConfigHash>;
 
  PredictiveTuning(double relativeOptimum, unsigned int maxTuningIterationsWithoutTest,
                   unsigned int testsUntilFirstPrediction, ExtrapolationMethodOption extrapolationMethodOption,
                   const std::string &outputSuffix = "");
 
  TuningStrategyOption getOptionType() const override;
 
  void addEvidence(const Configuration &configuration, const Evidence &evidence) override;
 
  bool reset(size_t iteration, size_t tuningPhase, std::vector<Configuration> &configQueue,
             const autopas::EvidenceCollection &evidenceCollection) override;
 
  bool optimizeSuggestions(std::vector<Configuration> &configQueue,
                           const EvidenceCollection &evidenceCollection) override;
 
  void rejectConfiguration(const Configuration &configuration, bool indefinitely) override;
 
  PredictiveTuning::PredictionsType calculatePredictions(size_t iteration, size_t tuningPhase,
                                                         const std::vector<Configuration> &configurations,
                                                         const autopas::EvidenceCollection &evidenceCollection);
 
 private:
  long linePrediction(size_t iteration, size_t tuningPhase, const Configuration &configuration,
                      const std::vector<Evidence> &evidenceVec);
  long linearRegression(size_t iteration, size_t tuningPhase, const Configuration &configuration,
                        const std::vector<Evidence> &evidenceVec);
  long newtonPolynomial(size_t iteration, size_t tuningPhase, const Configuration &configuration,
                        const std::vector<Evidence> &evidenceVec);
 
  long lastResult(size_t tuningPhase, const Configuration &configuration, const std::vector<Evidence> &evidenceVec);
 
  constexpr static long _predictionErrorValue{std::numeric_limits<long>::max()};
 
  constexpr static long _predictionOverflowValue{std::numeric_limits<long>::max() - 1};
 
  constexpr static long _predictionUnderflowValue{1l};
 
  std::unordered_map<Configuration, std::vector<double>, ConfigHash> _predictionFunctionParameters{};
  std::set<Configuration> _tooLongNotTestedSearchSpace{};
  double _relativeOptimumRange{1.2};
  unsigned int _maxTuningPhasesWithoutTest{100};
 
  ExtrapolationMethodOption _extrapolationMethod{ExtrapolationMethodOption::linearRegression};
  unsigned int _minNumberOfEvidence{3};
 
  PredictionLogger _predictionLogger;
};
 
}  // namespace autopas