TrainingData.h

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Taylor Woll and panann contributors. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for
// full license information.
//-------------------------------------------------------------------------------------------------------
 
#ifndef TRAININGDATA_H__
#define TRAININGDATA_H__
 
#include <cstdint>
#include <vector>
 
namespace panann {
 
struct Example {
  std::vector<double> input;
  std::vector<double> output;
};
 
class TrainingData : public std::vector<Example> {
 public:
  enum class ScalingAlgorithm : uint8_t {
    None = 0,
 
    Simple,
 
    StandardDeviation,
 
    UniformNorm
  };
 
  TrainingData() = default;
  TrainingData(const TrainingData&) = delete;
  TrainingData& operator=(const TrainingData&) = delete;
  ~TrainingData() = default;
 
  void SetScalingAlgorithm(ScalingAlgorithm algorithm);
  ScalingAlgorithm GetScalingAlgorithm() const;
 
  void SetSimpleScalingNewMin(double val);
  double GetSimpleScalingNewMin() const;
 
  void SetSimpleScalingNewMax(double val);
  double GetSimpleScalingNewMax() const;
 
  void SetStandardDeviationMultiplier(double val);
  double GetStandardDeviationMultiplier() const;
 
  void SetUniformNormMultiplier(double val);
  double GetUniformNormMultiplier() const;
 
  void Scale();
 
  void Descale();
 
  void ScaleInput(std::vector<double>* vec) const;
 
  void ScaleOutput(std::vector<double>* vec) const;
 
  void DescaleInput(std::vector<double>* vec) const;
 
  void DescaleOutput(std::vector<double>* vec) const;
 
  void FromSequentialData(const std::vector<double>& data, size_t input_length);
 
 protected:
  void CalculateMinMax();
  void CalculateMean();
  void CalculateStdev();
  void CalculateUniformNorm();
 
  void ScaleSimple();
  void ScaleStandardDeviation();
  void ScaleUniformNorm();
 
  void DescaleSimple();
  void DescaleStandardDeviation();
  void DescaleUniformNorm();
 
 private:
  static constexpr double DefaultSimpleScalingNewMin = -1.0;
  static constexpr double DefaultSimpleScalingNewMax = 1.0;
  static constexpr double DefaultStandardDeviationMultiplier = 2.5;
  static constexpr double DefaultUniformNormMultiplier = 1.0;
 
  double simple_scaling_new_min_ = DefaultSimpleScalingNewMin;
  double simple_scaling_new_max_ = DefaultSimpleScalingNewMax;
  double input_old_min_ = 0;
  double input_old_max_ = 0;
  double output_old_min_ = 0;
  double output_old_max_ = 0;
  double input_factor_ = 0;
  double output_factor_ = 0;
  double input_mean_ = 0;
  double input_standard_deviation_ = 0;
  double output_mean_ = 0;
  double output_standard_deviation_ = 0;
  double standard_deviation_multiplier_ = DefaultStandardDeviationMultiplier;
  double input_uniform_norm_ = 0;
  double output_uniform_norm_ = 0;
  double uniform_norm_multiplier_ = DefaultUniformNormMultiplier;
  ScalingAlgorithm scaling_algorithm_ = ScalingAlgorithm::Simple;
};
 
}  // namespace panann
 
#endif  // TRAININGDATA_H__