#define APP_VALIDATE
#endif
+#include <iostream>
#include <limits.h>
#include <stdlib.h>
#include <time.h>
#include <activation_layer.h>
#include <blas_interface.h>
#include <common_properties.h>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <nntrainer_log.h>
#include <util_func.h>
+#include <layer_context.h>
+
namespace nntrainer {
static constexpr size_t SINGLE_INOUT_IDX = 0;
*/
#include <attention_layer.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
*/
#include <bn_layer.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <functional>
#include <vector>
+#include <common_properties.h>
#include <layer_devel.h>
namespace nntrainer {
#include <sstream>
#include <centroid_knn.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <string>
#include <common_properties.h>
-#include <layer_context.h>
#include <layer_devel.h>
namespace nntrainer {
#include <concat_layer.h>
#include <cstring>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#define __CONCAT_LAYER_H__
#ifdef __cplusplus
+#include <common_properties.h>
#include <layer_devel.h>
-
+#include <tensor_dim.h>
namespace nntrainer {
/**
#include <string>
#include <conv1d_layer.h>
+#include <conv2d_layer.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
conv2d_layer = std::make_unique<Conv2DLayer>();
}
+Conv1DLayer::~Conv1DLayer() {}
+
void Conv1DLayer::finalize(InitLayerContext &context) {
if (context.getNumInputs() != 1) {
throw std::invalid_argument("Convolution layer takes only one input");
#define __CONV1D_LAYER_H_
#ifdef __cplusplus
-#include <conv2d_layer.h>
+#include <common_properties.h>
#include <layer_impl.h>
#include <memory.h>
namespace nntrainer {
+class Conv2DLayer;
+
/**
* @class Convolution 1D Layer
* @brief Convolution 1D Layer
/**
* @brief Destructor of Conv 1D Layer
*/
- ~Conv1DLayer() = default;
+ ~Conv1DLayer();
/**
* @brief Move constructor of Conv 1D Layer.
#include <blas_interface.h>
#include <conv2d_layer.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <profiler.h>
+#include <tensor_dim.h>
#include <util_func.h>
namespace nntrainer {
#include <memory.h>
+#include <common_properties.h>
#include <layer_impl.h>
namespace nntrainer {
*/
#include <dropout.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
+#include <node_exporter.h>
#include <util_func.h>
namespace nntrainer {
#include <common_properties.h>
#include <layer_devel.h>
-#include <node_exporter.h>
namespace nntrainer {
*/
#include <embedding.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#define __EMBEDDING_H__
#ifdef __cplusplus
+#include <common_properties.h>
#include <layer_impl.h>
namespace nntrainer {
*/
#include <fc_layer.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
*/
#include <flatten_layer.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
+#include <node_exporter.h>
namespace nntrainer {
#include <cmath>
#include <gru.h>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
*/
#include <input_layer.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#ifdef __cplusplus
#include <common_properties.h>
-#include <layer_context.h>
#include <layer_devel.h>
-#include <tensor.h>
namespace nntrainer {
#include <string>
#include <vector>
-#include <layer_context.h>
-#include <tensor.h>
-
namespace ml::train {
class Layer;
}
namespace nntrainer {
+class InitLayerContext;
+class RunLayerContext;
class Exporter;
enum class ExportMethods;
class RunLayerContext;
class Exporter;
+namespace props {
+class WeightRegularizer;
+class WeightRegularizerConstant;
+class WeightInitializer;
+class BiasInitializer;
+} // namespace props
+
enum class ExportMethods;
/**
#include <constant_derivative_loss_layer.h>
+#include <layer_context.h>
+
namespace nntrainer {
static constexpr int SINGLE_INOUT_IDX = 0;
static constexpr float value = 1.0f;
ConstantDerivativeLossLayer::ConstantDerivativeLossLayer() : LossLayer() {}
-ConstantDerivativeLossLayer::~ConstantDerivativeLossLayer() = default;
+ConstantDerivativeLossLayer::~ConstantDerivativeLossLayer(){};
void ConstantDerivativeLossLayer::forwarding(RunLayerContext &context,
bool training) {
#ifdef __cplusplus
#include <loss_layer.h>
+#include <nntrainer_error.h>
namespace nntrainer {
#include <cross_entropy_sigmoid_loss_layer.h>
#include <acti_func.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <util_func.h>
#include <cross_entropy_softmax_loss_layer.h>
#include <acti_func.h>
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <util_func.h>
*
*/
+#include <layer_context.h>
#include <loss_layer.h>
namespace nntrainer {
+void LossLayer::finalize(InitLayerContext &context) {
+ context.setOutputDimensions(context.getInputDimensions());
+}
void LossLayer::updateLoss(RunLayerContext &context, const Tensor &l) {
float loss_sum = 0.0f;
#include <layer_devel.h>
+#include <tensor.h>
+
namespace nntrainer {
/**
/**
* @copydoc Layer::finalize(InitLayerContext &context)
*/
- virtual void finalize(InitLayerContext &context) override {
- context.setOutputDimensions(context.getInputDimensions());
- }
+ virtual void finalize(InitLayerContext &context) override;
/**
* @copydoc Layer::setProperty(const std::vector<std::string> &values)
*
*/
+#include <layer_context.h>
#include <lazy_tensor.h>
#include <mse_loss_layer.h>
*/
#include <cmath>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <lstm.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
*/
#include <cmath>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <lstmcell.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
*/
#include <cstring>
+#include <layer_context.h>
#include <multiout_layer.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <fstream>
#include <common_properties.h>
+#include <layer_context.h>
#include <nnstreamer_layer.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
static constexpr size_t SINGLE_INOUT_IDX = 0;
-int NNStreamerLayer::nnst_info_to_tensor_dim(ml_tensors_info_h &out_res,
- TensorDim &dim) {
+static int nnst_info_to_tensor_dim(ml_tensors_info_h &out_res, TensorDim &dim) {
int status = ML_ERROR_NONE;
unsigned int count;
ml_tensor_type_e type;
* @brief release the layer resources
*/
void release() noexcept;
-
- /**
- * @brief convert nnstreamer's tensor_info to nntrainer's tensor_dim
- * @param[in] out_res nnstreamer's tensor_info
- * @param[out] dim nntrainer's tensor_dim
- * @retval 0 on success, -errno on failure
- */
- static int nnst_info_to_tensor_dim(ml_tensors_info_h &out_res,
- TensorDim &dim);
};
} // namespace nntrainer
#include <string>
#include <tuple>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
+#include <node_exporter.h>
#include <permute_layer.h>
#include <tensor.h>
#include <tensor_dim.h>
#include <base_properties.h>
#include <layer_devel.h>
-#include <node_exporter.h>
+
namespace nntrainer {
namespace props {
#include <cstring>
#include <limits>
-#include <lazy_tensor.h>
+#include <common_properties.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <pooling2d_layer.h>
#include <util_func.h>
-
namespace nntrainer {
static constexpr size_t SINGLE_INOUT_IDX = 0;
}
}
+void Pooling2DLayer::setBatch(RunLayerContext &context, unsigned int batch) {
+ context.updateTensor(pool_helper_idx, batch);
+ props::PoolingTypeInfo::Enum pooling_type =
+ std::get<props::PoolingType>(pooling2d_props).get();
+ if (pooling_type == props::PoolingTypeInfo::Enum::global_max)
+ pool_helper_size.resize(batch * context.getInput(0).channel());
+}
+
} /* namespace nntrainer */
#include <vector>
#include <base_properties.h>
+#include <common_properties.h>
#include <layer_devel.h>
namespace nntrainer {
/**
* @copydoc Layer::setBatch(RunLayerContext &context, unsigned int batch)
*/
- void setBatch(RunLayerContext &context, unsigned int batch) override {
- context.updateTensor(pool_helper_idx, batch);
- props::PoolingTypeInfo::Enum pooling_type =
- std::get<props::PoolingType>(pooling2d_props).get();
- if (pooling_type == props::PoolingTypeInfo::Enum::global_max)
- pool_helper_size.resize(batch * context.getInput(0).channel());
- }
+ void setBatch(RunLayerContext &context, unsigned int batch) override;
private:
std::array<unsigned int, POOLING2D_DIM * 2> padding;
#include <random>
+#include <common_properties.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <random>
+#include <common_properties.h>
#include <layer_devel.h>
namespace nntrainer {
#include <regex>
#include <sstream>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
-
+#include <node_exporter.h>
#include <preprocess_l2norm_layer.h>
namespace nntrainer {
#define __PREPROCESS_L2NORM_LAYER_H__
#include <string>
-#include <layer_context.h>
#include <layer_devel.h>
-#include <node_exporter.h>
namespace nntrainer {
#include <random>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <opencv2/highgui/highgui.hpp>
#endif
+#include <common_properties.h>
#include <layer_devel.h>
namespace nntrainer {
* @todo Update flatten to work in-place properly.
*/
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <reshape_layer.h>
-
namespace nntrainer {
static constexpr size_t SINGLE_INOUT_IDX = 0;
*/
#include <cmath>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#include <cmath>
-#include <lazy_tensor.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
*/
#include <cstring>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#define __SPLIT_LAYER_H__
#ifdef __cplusplus
+#include <common_properties.h>
#include <layer_devel.h>
+#include <tensor_dim.h>
namespace nntrainer {
*/
#include <base_properties.h>
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <node_exporter.h>
#ifdef __cplusplus
#include <layer_devel.h>
+#include <vector>
#include <tensorflow/contrib/lite/interpreter.h>
#include <tensorflow/contrib/lite/kernels/register.h>
#include <tensorflow/contrib/lite/model.h>
+namespace ml::train {
+class TensorDim;
+}
+
namespace nntrainer {
class PropsTflModelPath;
* @param is_output check if output
*/
void setDimensions(const std::vector<int> &tensor_idx_list,
- std::vector<TensorDim> &dim, bool is_output);
+ std::vector<ml::train::TensorDim> &dim, bool is_output);
};
} // namespace nntrainer
*
*/
+#include <layer_context.h>
#include <nntrainer_error.h>
#include <nntrainer_log.h>
#include <time_dist.h>
#ifdef __cplusplus
#include <layer_devel.h>
+#include <weight.h>
namespace nntrainer {
namespace nntrainer {
+class Weight;
+class Var_Grad;
+
/**
* @class DynamicTraining Optimization
* @brief Dynamic Training Optimization
#include <layers_common_tests.h>
+#include <layer_context.h>
#include <layer_devel.h>
+#include <nntrainer_error.h>
+#include <tensor_dim.h>
constexpr unsigned SAMPLE_TRIES = 10;
}
TEST_P(LayerSemantics, finalizeValidate_p) {
- nntrainer::TensorDim in_dim({1, 1, 1, 1});
- std::vector<nntrainer::TensorDim> input_dims(num_inputs, in_dim);
+ ml::train::TensorDim in_dim({1, 1, 1, 1});
+ std::vector<ml::train::TensorDim> input_dims(num_inputs, in_dim);
nntrainer::InitLayerContext init_context =
nntrainer::InitLayerContext(input_dims, 1, false, "layer");
EXPECT_EQ(init_context.validate(), true);
}
TEST_P(LayerSemantics, setBatchValidate_p) {
- nntrainer::TensorDim in_dim({1, 1, 1, 1});
- std::vector<nntrainer::TensorDim> input_dims(num_inputs, in_dim);
+ ml::train::TensorDim in_dim({1, 1, 1, 1});
+ std::vector<ml::train::TensorDim> input_dims(num_inputs, in_dim);
nntrainer::InitLayerContext init_context =
nntrainer::InitLayerContext(input_dims, 1, false, "layer");
EXPECT_EQ(init_context.validate(), true);