DimensionReductionModel.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef TTK_ENABLE_TORCH
 
#include <torch/torch.h>
 
namespace ttk {

  class DimensionReductionModel : public torch::nn::Module {
  public:
    virtual torch::Tensor forward(torch::Tensor const &x) = 0;
    virtual torch::Tensor encode(torch::Tensor const &x) = 0;
    virtual torch::Tensor decode(torch::Tensor const &x) = 0;
  }; // DimensionReductionModel class

  class AutoEncoder : public DimensionReductionModel {
  public:
    AutoEncoder(int inputDim,
                int latentDim,
                const std::string &layersDescription,
                const std::string &activation = "ReLU",
                bool useBN = true);
 
    inline torch::Tensor forward(torch::Tensor const &x) override {
      return decoder->forward(encoder->forward(x));
    }
 
    inline torch::Tensor encode(torch::Tensor const &x) override {
      return encoder->forward(x);
    }
 
    inline torch::Tensor decode(torch::Tensor const &x) override {
      return decoder->forward(x);
    }
 
    static bool isStringValid(const std::string &s);
 
  private:
    torch::nn::Sequential encoder;
    torch::nn::Sequential decoder;
  }; // AutoEncoder class

  class AutoDecoder : public DimensionReductionModel {
  public:
    AutoDecoder(int inputDim,
                int inputSize,
                int latentDim,
                const std::string &layersDescription,
                const std::string &activation = "ReLU",
                bool useBN = true);
 
    inline torch::Tensor forward(torch::Tensor const & /*x*/) override {
      return decoder->forward(latent);
    }
 
    inline torch::Tensor encode(torch::Tensor const & /*x*/) override {
      return latent;
    }
 
    inline torch::Tensor decode(torch::Tensor const & /*x*/) override {
      return decoder->forward(latent);
    }
 
  private:
    torch::Tensor latent;
    torch::nn::Sequential decoder;
  }; // AutoDecoder class

  class DirectOptimization : public DimensionReductionModel {
  public:
    DirectOptimization(int inputSize, int latentDim);
 
    inline torch::Tensor forward(torch::Tensor const &x) override {
      return x;
    }
 
    inline torch::Tensor encode(torch::Tensor const &x) override {
      input = x;
      return latent;
    }
 
    inline torch::Tensor decode(torch::Tensor const & /*x*/) override {
      return input;
    }
 
  private:
    torch::Tensor latent;
    torch::Tensor input;
  }; // DirectOptimization class

  class ConvolutionalAutoEncoder : public DimensionReductionModel {
  public:
    ConvolutionalAutoEncoder(int imageSide,
                             int latentDim,
                             const std::string &layersDescription,
                             bool useBN);
 
    inline torch::Tensor forward(torch::Tensor const &x) override {
      return decoder->forward(encoder->forward(x));
    }
 
    inline torch::Tensor encode(torch::Tensor const &x) override {
      return encoder->forward(x);
    }
 
    inline torch::Tensor decode(torch::Tensor const &x) override {
      return decoder->forward(x);
    }
 
    static bool isStringValid(const std::string &s);
 
  private:
    torch::nn::Sequential encoder;
    torch::nn::Sequential decoder;
  }; // ConvolutionalAutoEncoder class
 
} // namespace ttk
 
#endif