[Dataset] Change factory signature

Add properties to factory, given contructor argument, it is delegated to
the constructor

**Self evaluation:**
1. Build test: [X]Passed [ ]Failed [ ]Skipped
2. Run test: [X]Passed [ ]Failed [ ]Skipped

Cc: Parichay Kapoor<pk.kapoor@samsung.com>
Signed-off-by: Jihoon Lee <jhoon.it.lee@samsung.com>

diff --git a/api/ccapi/include/dataset.h b/api/ccapi/include/dataset.h
index 8a744c4be503b7e8c1e6822eb078746040f23cfd..8799cf35d0f1db6f7b6d13e41ff5f2c05886c96d 100644 (file)
--- a/api/ccapi/include/dataset.h
+++ b/api/ccapi/include/dataset.h
@@ -1,4 +1,3 @@
-
 // SPDX-License-Identifier: Apache-2.0
 /**
  * Copyright (C) 2020 Parichay Kapoor <pk.kapoor@samsung.com>
@@ -87,23 +86,40 @@ public:
 };
 
 /**
- * @brief Factory creator with constructor for dataset
+ * @brief Create a Dataset object with given arguements
+ *
+ * @param type dataset type
+ * @param properties property representations
+ * @return std::unique_ptr<Dataset> created dataset
  */
 std::unique_ptr<Dataset>
 createDataset(DatasetType type,
               const std::vector<std::string> &properties = {});
 
 /**
- * @brief Factory creator with constructor for dataset
+ * @brief Create a Dataset object
+ *
+ * @param type dataset type
+ * @param path path to a file or folder
+ * @param properties property representations
+ * @return std::unique_ptr<Dataset> created dataset
  */
-std::unique_ptr<Dataset> createDataset(DatasetType type, const char *file);
+std::unique_ptr<Dataset>
+createDataset(DatasetType type, const char *path,
+              const std::vector<std::string> &properties = {});
 
 /**
- * @brief Factory creator with constructor for dataset
+ * @brief Create a Dataset object
+ *
+ * @param type dataset type
+ * @param cb callback
+ * @param user_data user data
+ * @param properties property representations
+ * @return std::unique_ptr<Dataset> created dataset
  */
-std::unique_ptr<Dataset> createDataset(DatasetType type, datagen_cb cb,
-                                       void *user_data = nullptr);
-
+std::unique_ptr<Dataset>
+createDataset(DatasetType type, datagen_cb cb, void *user_data = nullptr,
+              const std::vector<std::string> &properties = {});
 } // namespace train
 } // namespace ml
 

diff --git a/api/ccapi/src/factory.cpp b/api/ccapi/src/factory.cpp
index 53db60fccfd3179091da99db4d4e0d9d8505e20b..d30800c883e9ef5644ae6ed6cac80a3db7222da3 100644 (file)
--- a/api/ccapi/src/factory.cpp
+++ b/api/ccapi/src/factory.cpp
@@ -82,25 +82,31 @@ std::unique_ptr<Model> createModel(ModelType type,
 std::unique_ptr<Dataset>
 createDataset(DatasetType type, const std::vector<std::string> &properties) {
   std::unique_ptr<Dataset> dataset = nntrainer::createDataBuffer(type);
-
   dataset->setProperty(properties);
 
   return dataset;
 }
 
-/**
- * @brief Factory creator with constructor for dataset
- */
-std::unique_ptr<Dataset> createDataset(DatasetType type, const char *file) {
-  return nntrainer::createDataBuffer(type, file);
+std::unique_ptr<Dataset>
+createDataset(DatasetType type, const char *file,
+              const std::vector<std::string> &properties) {
+  std::unique_ptr<Dataset> dataset = nntrainer::createDataBuffer(type, file);
+  dataset->setProperty(properties);
+
+  return dataset;
 }
 
 /**
  * @brief Factory creator with constructor for dataset
  */
-std::unique_ptr<Dataset> createDataset(DatasetType type, datagen_cb cb,
-                                       void *user_data) {
-  return nntrainer::createDataBuffer(type, cb, user_data);
+std::unique_ptr<Dataset>
+createDataset(DatasetType type, datagen_cb cb, void *user_data,
+              const std::vector<std::string> &properties) {
+  std::unique_ptr<Dataset> dataset =
+    nntrainer::createDataBuffer(type, cb, user_data);
+  dataset->setProperty(properties);
+
+  return dataset;
 }
 
 } // namespace train

diff --git a/nntrainer/dataset/databuffer_factory.cpp b/nntrainer/dataset/databuffer_factory.cpp
index 07c2b765bdb06d04962b90f736b0b77970a9396e..bbd12e53e53e785a5c0fa603e3c6faa173a9d03e 100644 (file)
--- a/nntrainer/dataset/databuffer_factory.cpp
+++ b/nntrainer/dataset/databuffer_factory.cpp
@@ -23,14 +23,12 @@ namespace nntrainer {
  */
 std::unique_ptr<DataBuffer> createDataBuffer(DatasetType type) {
   switch (type) {
-  case DatasetType::GENERATOR:
-    return std::make_unique<DataBufferFromCallback>();
   case DatasetType::FILE:
     return std::make_unique<DataBufferFromDataFile>();
   case DatasetType::UNKNOWN:
-    /** fallthrough intended */
+    [[fallthrough]];
   default:
-    throw std::invalid_argument("Unknown type for the dataset");
+    throw std::invalid_argument("Unsupported constructor type for the dataset");
   }
 }
 
@@ -39,17 +37,19 @@ std::unique_ptr<DataBuffer> createDataBuffer(DatasetType type) {
  */
 std::unique_ptr<DataBuffer> createDataBuffer(DatasetType type,
                                              const char *file) {
-  if (type != DatasetType::FILE)
-    throw std::invalid_argument(
-      "Cannot create dataset with files with the given dataset type");
-
-  std::unique_ptr<DataBuffer> dataset = createDataBuffer(type);
+  NNTR_THROW_IF(file == nullptr, std::invalid_argument)
+    << "file shall not be null, use empty constructor instead";
 
-  NNTR_THROW_IF(file == nullptr || dataset->setDataFile(file) != ML_ERROR_NONE,
-                std::invalid_argument)
-    << "invalid train file, path: " << (file ? file : "null");
-
-  return dataset;
+  switch (type) {
+  case DatasetType::FILE:
+    return std::make_unique<DataBufferFromDataFile>(file);
+  case DatasetType::UNKNOWN:
+    [[fallthrough]];
+  default:
+    throw std::invalid_argument(
+      "Unsupported constructor type for the dataset of type: " +
+      static_cast<int>(type));
+  };
 }
 
 /**
@@ -57,16 +57,16 @@ std::unique_ptr<DataBuffer> createDataBuffer(DatasetType type,
  */
 std::unique_ptr<DataBuffer> createDataBuffer(DatasetType type, datagen_cb cb,
                                              void *user_data) {
-  if (type != DatasetType::GENERATOR)
-    throw std::invalid_argument("Cannot create dataset with generator "
-                                "callbacks with the given dataset type");
-
-  std::unique_ptr<DataBuffer> dataset = createDataBuffer(type);
-
-  if (dataset->setGeneratorFunc(cb, user_data) != ML_ERROR_NONE)
-    throw std::invalid_argument("Invalid train data generator");
-
-  return dataset;
+  switch (type) {
+  case DatasetType::GENERATOR:
+    return std::make_unique<DataBufferFromCallback>(cb, user_data);
+  case DatasetType::UNKNOWN:
+    [[fallthrough]];
+  default:
+    throw std::invalid_argument(
+      "Unsupported constructor type for the dataset of type: " +
+      static_cast<int>(type));
+  };
 }
 
 } // namespace nntrainer

diff --git a/nntrainer/dataset/databuffer_file.h b/nntrainer/dataset/databuffer_file.h
index e15f39c6d34e9a314cb53f9d2d1afaeb70b3734b..44ff9eeaee9da449f405668a925b7c8aa772103d 100644 (file)
--- a/nntrainer/dataset/databuffer_file.h
+++ b/nntrainer/dataset/databuffer_file.h
@@ -31,6 +31,7 @@
 #include <vector>
 
 #include <databuffer.h>
+#include <nntrainer_error.h>
 
 namespace nntrainer {
 
@@ -46,6 +47,14 @@ public:
    */
   DataBufferFromDataFile() : DataBuffer(DatasetType::FILE) {}
 
+  /**
+   * @brief     Constructor
+   */
+  DataBufferFromDataFile(const std::string &path) : DataBufferFromDataFile() {
+    NNTR_THROW_IF(setDataFile(path) != ML_ERROR_NONE, std::invalid_argument)
+      << "invalid train file, path: " << path;
+  }
+
   /**
    * @brief     Destructor
    */

diff --git a/nntrainer/dataset/databuffer_func.h b/nntrainer/dataset/databuffer_func.h
index 845b174ca5f642c99606383a8bc1c89ce7fcf220..74fea22350f03f0f3889d1892885076189d51cc4 100644 (file)
--- a/nntrainer/dataset/databuffer_func.h
+++ b/nntrainer/dataset/databuffer_func.h
@@ -46,6 +46,15 @@ public:
    */
   DataBufferFromCallback() : DataBuffer(DatasetType::GENERATOR) {}
 
+  /**
+   * @brief Construct a new Data Buffer From Callback object
+   *
+   */
+  DataBufferFromCallback(datagen_cb func, void *user_data = nullptr) :
+    DataBuffer(DatasetType::GENERATOR) {
+    setGeneratorFunc(func, user_data);
+  }
+
   /**
    * @brief     Destructor
    */

diff --git a/nntrainer/models/model_loader.cpp b/nntrainer/models/model_loader.cpp
index 6301344b185643f3f72e331f7bbffe31642cd898..eec6f2d5a3ff15a624a95b80859d2f626cce13e5 100644 (file)
--- a/nntrainer/models/model_loader.cpp
+++ b/nntrainer/models/model_loader.cpp
@@ -208,13 +208,6 @@ int ModelLoader::loadDatasetConfigIni(dictionary *ini, NeuralNetwork &model) {
     return ML_ERROR_INVALID_PARAMETER;
   }
 
-  model.data_buffers[static_cast<int>(DatasetDataUsageType::DATA_TRAIN)] =
-    nntrainer::createDataBuffer(DatasetType::FILE);
-  model.data_buffers[static_cast<int>(DatasetDataUsageType::DATA_VAL)] =
-    nntrainer::createDataBuffer(DatasetType::FILE);
-  model.data_buffers[static_cast<int>(DatasetDataUsageType::DATA_TEST)] =
-    nntrainer::createDataBuffer(DatasetType::FILE);
-
   /// @todo ini bufferSize -> buffer_size to unify
   std::string bufsizepros("buffer_size=");
   bufsizepros += iniparser_getstring(ini, "DataSet:BufferSize", "1");
@@ -227,12 +220,16 @@ int ModelLoader::loadDatasetConfigIni(dictionary *ini, NeuralNetwork &model) {
       return required ? ML_ERROR_INVALID_PARAMETER : ML_ERROR_NONE;
     }
 
-    auto dbuffer = std::static_pointer_cast<DataBufferFromDataFile>(
-      model.data_buffers[static_cast<int>(dt)]);
-
-    dbuffer->setProperty({bufsizepros});
+    try {
+      model.data_buffers[static_cast<int>(dt)] =
+        createDataBuffer(DatasetType::FILE, resolvePath(path).c_str());
+      model.data_buffers[static_cast<int>(dt)]->setProperty({bufsizepros});
+    } catch (...) {
+      ml_loge("path is not valid, path: %s", resolvePath(path).c_str());
+      return ML_ERROR_INVALID_PARAMETER;
+    }
 
-    return dbuffer->setDataFile(resolvePath(path));
+    return ML_ERROR_NONE;
   };
 
   status =

diff --git a/test/ccapi/unittest_ccapi.cpp b/test/ccapi/unittest_ccapi.cpp
index e4e1843ce5e1b3cae386a449eed4f34f0acd8247..5bfa2f0ccfd7c6e4730de1fc235d52b6b944b556 100644 (file)
--- a/test/ccapi/unittest_ccapi.cpp
+++ b/test/ccapi/unittest_ccapi.cpp
@@ -151,9 +151,9 @@ TEST(ccapi_dataset, construct_01_n) {
 /**
  * @brief Neural Network Dataset Contruct Test
  */
-TEST(ccapi_dataset, construct_02_p) {
-  EXPECT_NO_THROW(ml::train::createDataset(ml::train::DatasetType::GENERATOR));
-  EXPECT_NO_THROW(ml::train::createDataset(ml::train::DatasetType::FILE));
+TEST(ccapi_dataset, construct_02_n) {
+  EXPECT_THROW(ml::train::createDataset(ml::train::DatasetType::GENERATOR),
+               std::invalid_argument);
 }
 
 static nntrainer::IniSection model_base("Model", "Type = NeuralNetwork"