TopologicalDimensionReduction.h

Go to the documentation of this file.

 
#pragma once
 
// ttk includes
#include <Debug.h>
#include <DimensionReductionModel.h>
#include <TopologicalLoss.h>
 
namespace ttk {

  class TopologicalDimensionReduction : virtual public Debug {
 
  public:
    enum class OPTIMIZER : std::uint8_t {
      ADAM = 0,
      SGD = 1,
      LBFGS = 2,
    };
 
    enum class MODEL : std::uint8_t {
      AUTOENCODER = 0,
      AUTODECODER = 1,
      DIRECT = 2,
    };
 
    using REGUL = TopologicalLoss::REGUL;
 
#ifdef TTK_ENABLE_TORCH
 
    TopologicalDimensionReduction(bool useCUDA,
                                  bool deterministic,
                                  int seed,
                                  int numberOfComponents,
                                  int epochs,
                                  double learningRate,
                                  OPTIMIZER optimizer,
                                  REGUL method,
                                  MODEL modelType,
                                  const std::string &architecture,
                                  const std::string &activation,
                                  int batchSize,
                                  bool batchNormalization,
                                  double regCoefficient,
                                  bool inputIsImages,
                                  bool preOptimize,
                                  int preOptimizeEpochs);

    int execute(std::vector<std::vector<double>> &outputEmbedding,
                const std::vector<double> &inputMatrix,
                size_t n);
 
  protected:
    const int NumberOfComponents;
    const int Epochs;
    const double LearningRate;
    const OPTIMIZER Optimizer;
    const REGUL Method;
    const MODEL ModelType;
    const bool InputIsImages;
    const std::string Architecture;
    const std::string Activation;
    const int BatchSize;
    const bool BatchNormalization;
    const double RegCoefficient;
    const bool PreOptimize;
    const int PreOptimizeEpochs;
 
  private:
    torch::DeviceType device{torch::kCPU};
    std::unique_ptr<DimensionReductionModel> model{nullptr};
    std::unique_ptr<torch::optim::Optimizer> torchOptimizer{nullptr};
    std::unique_ptr<TopologicalLoss> topologicalLossContainer{nullptr};
 
    int initializeModel(int inputSize, int inputDimension);
    void initializeOptimizer();
 
    void preOptimize(const torch::Tensor &input,
                     const torch::Tensor &target) const;
 
    void optimize(const torch::Tensor &input) const;
    void optimizeSimple(const torch::Tensor &input) const;
 
    inline void printLoss(int epoch, int maxEpoch, double loss) const;
 
#endif
 
  }; // TopologicalDimensionReduction class
 
} // namespace ttk