nntrainer/layers/plugged_layer.h

   1 // SPDX-License-Identifier: Apache-2.0
   2 /**
   3  * Copyright (C) 2020 Jihoon Lee <jhoon.it.lee@samsung.com>
   4  *
   5  * @file   plugged_layer.h
   6  * @date   27 January 2021
   7  * @brief  This file contains a wrapper for a plugged layer, INTERNAL USE ONLY
   8  * @see    https://github.com/nnstreamer/nntrainer
   9  * @author Jihoon Lee <jhoon.it.lee@samsung.com>
  10  * @bug    No known bugs except for NYI items
  11  *
  12  */
  13
  14 #ifndef __PLUGGED_LAYER_H__
  15 #define __PLUGGED_LAYER_H__
  16
  17 #include <layer.h>
  18
  19 #include <layer_internal.h>
  20 #include <manager.h>
  21 #include <nntrainer_error.h>
  22
  23 namespace nntrainer {
  24 namespace internal {
  25
  26 /**
  27  * @brief PluggedLayer to wrap a layer from shared object file
  28  *
  29  */
  30 class PluggedLayer : public nntrainer::LayerV1 {
  31 public:
  32   /**
  33    * @brief Construct a new Plugged Layer object
  34    *
  35    * @param pluggable LayerPluggable structure from the symbol
  36    */
  37   PluggedLayer(const nntrainer::LayerV1Pluggable *pluggable) :
  38     /// @todo we won't need dynamic pointer cast here after api is fully
  39     /// implemented
  40     layerImpl(pluggable->createfunc()),
  41     destroy_func(pluggable->destroyfunc) {
  42     NNTR_THROW_IF(layerImpl == nullptr, std::invalid_argument)
  43       << "either create_func_ failed or cannot dynamic cast to layer_internal";
  44   }
  45
  46   /**
  47    * @brief Destroy the Plugged Layer object
  48    *
  49    */
  50   ~PluggedLayer() override { destroy_func(layerImpl); }
  51
  52   /**
  53    * @brief Move Contruct Plugged Layer object
  54    *
  55    * @param rhs layer to move
  56    */
  57   PluggedLayer(PluggedLayer &&rhs) noexcept = default;
  58
  59   /**
  60    * @brief Move assign Plugged Layer Object
  61    *
  62    * @param rhs layer to move
  63    * @return PluggedLayer& *this
  64    */
  65   PluggedLayer &operator=(PluggedLayer &&rhs) = default;
  66
  67   /**
  68    * @copydoc Layer::initialize(Manager &manager)
  69    */
  70   int initialize(Manager &manager) override {
  71     return layerImpl->initialize(manager);
  72   }
  73
  74   /**
  75    * @copydoc Layer::forwarding(bool training)
  76    */
  77   void forwarding(bool training = true) override {
  78     layerImpl->forwarding(training);
  79   }
  80
  81   /**
  82    * @copydoc Layer::calcDerivative()
  83    */
  84   void calcDerivative() override { layerImpl->calcDerivative(); }
  85
  86   /**
  87    * @copydoc Layer::calcGradient()
  88    */
  89   void calcGradient() override { layerImpl->calcGradient(); }
  90
  91   /**
  92    * @copydoc Layer::applyGradient(unsigned int, std::shared_ptr<Optimizer>)
  93    */
  94   void applyGradient(unsigned int iteration,
  95                      std::shared_ptr<Optimizer> optimizer) override {
  96     layerImpl->applyGradient(iteration, std::move(optimizer));
  97   }
  98
  99   /**
 100    * @copydoc Layer::read(std::ifstream &file)
 101    */
 102   void read(std::ifstream &file) override { layerImpl->read(file); }
 103
 104   /**
 105    * @copydoc Layer::save(std::ofstream &file)
 106    */
 107   void save(std::ofstream &file) override { layerImpl->save(file); }
 108
 109   /**
 110    * @copydoc Layer::setProperty(std::vector<std::string> values)
 111    */
 112   int setProperty(std::vector<std::string> values) override {
 113     return layerImpl->setProperty(std::move(values));
 114   }
 115
 116   /**
 117    * @copydoc Layer::checkValidation()
 118    */
 119   int checkValidation() override { return layerImpl->checkValidation(); }
 120
 121   /**
 122    * @copydoc Layer::getOutputDimension()
 123    */
 124   std::vector<TensorDim> getOutputDimension() override {
 125     return layerImpl->getOutputDimension();
 126   }
 127
 128   /**
 129    * @copydoc Layer::getInputDimension()
 130    */
 131   std::vector<TensorDim> getInputDimension() override {
 132     return layerImpl->getInputDimension();
 133   }
 134
 135   /**
 136    * @copydoc Layer::getLoss()
 137    */
 138   float getLoss() override { return layerImpl->getLoss(); }
 139
 140   /**
 141    * @copydoc Layer::copy(std::shared_ptr<Layer> l)
 142    */
 143   void copy(std::shared_ptr<LayerV1> l) override { layerImpl->copy(l); }
 144
 145   /**
 146    * @copydoc Layer::setTrainable(bool train)
 147    */
 148   void setTrainable(bool train) override { layerImpl->setTrainable(train); }
 149
 150   /**
 151    * @copydoc Layer::getTrainable()
 152    */
 153   bool getTrainable() noexcept override { return layerImpl->getTrainable(); }
 154
 155   /**
 156    * @copydoc Layer::getWeights()
 157    */
 158   std::vector<Weight> getWeights() override { return layerImpl->getWeights(); }
 159
 160   /**
 161    * @copydoc Layer::getType()
 162    */
 163   virtual const std::string getType() const override {
 164     return layerImpl->getType();
 165   }
 166
 167   /**
 168    * @copydoc Layer::printPreset(std::ostream &out, PrintPreset preset)
 169    */
 170   void printPreset(std::ostream &out,
 171                    PrintPreset preset = PrintPreset::PRINT_SUMMARY) override {
 172     return layerImpl->printPreset(out, preset);
 173   }
 174
 175   /**
 176    * @copydoc Layer::weightAt(const unsigned int position)
 177    */
 178   Weight &weightAt(const unsigned int position) override {
 179     return layerImpl->weightAt(position);
 180   }
 181
 182   /**
 183    * @copydoc Layer::getNumWeights()
 184    */
 185   unsigned int getNumWeights() override { return layerImpl->getNumWeights(); }
 186
 187   /**
 188    * @copydoc Layer::setBatch(unsigned int batch)
 189    */
 190   void setBatch(unsigned int batch) override {
 191     return layerImpl->setBatch(batch);
 192   }
 193
 194   /**
 195    * @copydoc Layer::scaleSize(float scalesize)
 196    */
 197   void scaleSize(float scalesize) noexcept override {
 198     return layerImpl->scaleSize(scalesize);
 199   }
 200
 201   /**
 202    * @copydoc Layer::resetDimension()
 203    */
 204   void resetDimension() override { return layerImpl->resetDimension(); }
 205
 206   /**
 207    * @copydoc Layer::getOutputs()
 208    */
 209   std::vector<Tensor> getOutputs() override { return layerImpl->getOutputs(); }
 210
 211   /**
 212    * @copydoc Layer::getDerivatives()
 213    */
 214   std::vector<Tensor> getDerivatives() override {
 215     return layerImpl->getDerivatives();
 216   }
 217
 218   /**
 219    * @copydoc Layer::getWeightsRef()
 220    */
 221   std::vector<Weight> &getWeightsRef() override {
 222     return layerImpl->getWeightsRef();
 223   }
 224
 225   /**
 226    * @copydoc Layer::setInputBuffers(std::vector<std::shared_ptr<VarGrad>>
 227    * inputs)
 228    */
 229   void setInputBuffers(std::vector<std::shared_ptr<Var_Grad>> inputs) override {
 230     return layerImpl->setInputBuffers(std::move(inputs));
 231   }
 232
 233   /**
 234    * @copydoc Layer::setOutputBuffers(std::vector<std::shared_ptr<Var_Grad>>
 235    * outputs)
 236    */
 237   void
 238   setOutputBuffers(std::vector<std::shared_ptr<Var_Grad>> outputs) override {
 239     return layerImpl->setOutputBuffers(std::move(outputs));
 240   }
 241
 242 #ifdef ENABLE_TEST
 243   unsigned int getNumInputs() override { return layerImpl->getNumInputs(); }
 244   unsigned int getNumOutputs() override { return layerImpl->getNumOutputs(); }
 245 #endif
 246
 247 private:
 248   /// @todo: migrate to ml::train::Layer
 249   // ml::train::Layer *layerImpl;
 250   nntrainer::LayerV1 *layerImpl;
 251   nntrainer::DestroyLayerV1Func destroy_func;
 252 };
 253 } // namespace internal
 254 } // namespace nntrainer
 255
 256 #endif // __PLUGGED_LAYER_H__