test/tizen_capi/unittest_tizen_capi_lr_scheduler.cpp

   1 /**
   2  * Copyright (C) 2023 Samsung Electronics Co., Ltd. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *   http://www.apache.org/licenses/LICENSE-2.0
   8  * Unless required by applicable law or agreed to in writing, software
   9  * distributed under the License is distributed on an "AS IS" BASIS,
  10  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  11  * See the License for the specific language governing permissions and
  12  * limitations under the License.
  13  */
  14 /**
  15  * @file        unittest_tizen_capi_lr_scheduler.cpp
  16  * @date        13 April 2023
  17  * @brief       Unit test utility for learning rate scheduler.
  18  * @see         https://github.com/nnstreamer/nntrainer
  19  * @author      Hyeonseok Lee <hs89.lee@samsung.com>
  20  * @bug         No known bugs
  21  */
  22 #include <gtest/gtest.h>
  23
  24 #include <nntrainer.h>
  25 #include <nntrainer_internal.h>
  26 #include <nntrainer_test_util.h>
  27
  28 /**
  29  * @brief Learning rate scheduler Create / Destruct Test (positive test)
  30  */
  31 TEST(nntrainer_capi_lr_scheduler, create_destruct_01_p) {
  32   ml_train_lr_scheduler_h handle;
  33   int status;
  34   status =
  35     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
  36   EXPECT_EQ(status, ML_ERROR_NONE);
  37   status = ml_train_lr_scheduler_destroy(handle);
  38   EXPECT_EQ(status, ML_ERROR_NONE);
  39 }
  40
  41 /**
  42  * @brief Learning rate scheduler Create / Destruct Test (positive test)
  43  */
  44 TEST(nntrainer_capi_lr_scheduler, create_destruct_02_p) {
  45   ml_train_lr_scheduler_h handle;
  46   int status;
  47   status = ml_train_lr_scheduler_create(&handle,
  48                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
  49   EXPECT_EQ(status, ML_ERROR_NONE);
  50   status = ml_train_lr_scheduler_destroy(handle);
  51   EXPECT_EQ(status, ML_ERROR_NONE);
  52 }
  53
  54 /**
  55  * @brief Learning rate scheduler Create / Destruct Test (positive test)
  56  */
  57 TEST(nntrainer_capi_lr_scheduler, create_destruct_03_p) {
  58   ml_train_lr_scheduler_h handle;
  59   int status;
  60   status =
  61     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_STEP);
  62   EXPECT_EQ(status, ML_ERROR_NONE);
  63   status = ml_train_lr_scheduler_destroy(handle);
  64   EXPECT_EQ(status, ML_ERROR_NONE);
  65 }
  66
  67 /**
  68  * @brief Learning rate scheduler Create / Destruct Test (negative test)
  69  */
  70 TEST(nntrainer_capi_lr_scheduler, create_destruct_04_n) {
  71   ml_train_lr_scheduler_h handle = NULL;
  72   int status;
  73   status = ml_train_lr_scheduler_destroy(handle);
  74   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
  75 }
  76
  77 /**
  78  * @brief Learning rate scheduler Create / Destruct Test (negative test)
  79  */
  80 TEST(nntrainer_capi_lr_scheduler, create_destruct_05_n) {
  81   ml_train_lr_scheduler_h handle;
  82   int status;
  83   status =
  84     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_UNKNOWN);
  85   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
  86 }
  87
  88 /**
  89  * @brief Learning rate scheduler Create / Destruct Test (negative test)
  90  */
  91 TEST(nntrainer_capi_lr_scheduler, create_destruct_06_n) {
  92   ml_train_optimizer_h opt_handle;
  93   ml_train_lr_scheduler_h lr_sched_handle;
  94   int status;
  95   status = ml_train_optimizer_create(&opt_handle, ML_TRAIN_OPTIMIZER_TYPE_SGD);
  96   EXPECT_EQ(status, ML_ERROR_NONE);
  97
  98   status = ml_train_lr_scheduler_create(&lr_sched_handle,
  99                                         ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
 100   EXPECT_EQ(status, ML_ERROR_NONE);
 101
 102   status = ml_train_optimizer_set_lr_scheduler(opt_handle, lr_sched_handle);
 103   EXPECT_EQ(status, ML_ERROR_NONE);
 104
 105   status = ml_train_lr_scheduler_destroy(lr_sched_handle);
 106   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 107
 108   status = ml_train_optimizer_destroy(opt_handle);
 109   EXPECT_EQ(status, ML_ERROR_NONE);
 110 }
 111
 112 /**
 113  * @brief Learning rate scheduler Create / Destruct Test (negative test)
 114  */
 115 TEST(nntrainer_capi_lr_scheduler, create_destruct_07_n) {
 116   int status = ML_ERROR_NONE;
 117
 118   ml_train_model_h model;
 119   ml_train_optimizer_h optimizer;
 120   ml_train_lr_scheduler_h lr_scheduler;
 121
 122   status = ml_train_model_construct(&model);
 123   EXPECT_EQ(status, ML_ERROR_NONE);
 124
 125   status = ml_train_optimizer_create(&optimizer, ML_TRAIN_OPTIMIZER_TYPE_ADAM);
 126   EXPECT_EQ(status, ML_ERROR_NONE);
 127
 128   status = ml_train_optimizer_set_property(optimizer, "beta1=0.002",
 129                                            "beta2=0.001", "epsilon=1e-7", NULL);
 130   EXPECT_EQ(status, ML_ERROR_NONE);
 131
 132   status = ml_train_lr_scheduler_create(&lr_scheduler,
 133                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 134   EXPECT_EQ(status, ML_ERROR_NONE);
 135
 136   status = ml_train_lr_scheduler_set_property(
 137     lr_scheduler, "learning_rate=0.0001", "decay_rate=0.96", "decay_steps=1000",
 138     NULL);
 139   EXPECT_EQ(status, ML_ERROR_NONE);
 140
 141   status = ml_train_model_set_optimizer(model, optimizer);
 142   EXPECT_EQ(status, ML_ERROR_NONE);
 143
 144   status = ml_train_optimizer_set_lr_scheduler(optimizer, lr_scheduler);
 145   EXPECT_EQ(status, ML_ERROR_NONE);
 146
 147   status = ml_train_lr_scheduler_destroy(lr_scheduler);
 148   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 149
 150   status = ml_train_model_destroy(model);
 151   EXPECT_EQ(status, ML_ERROR_NONE);
 152 }
 153
 154 /**
 155  * @brief Learning rate scheduler set Property Test (positive test)
 156  */
 157 TEST(nntrainer_capi_lr_scheduler, setProperty_01_p) {
 158   ml_train_lr_scheduler_h handle;
 159   int status;
 160   status =
 161     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
 162   EXPECT_EQ(status, ML_ERROR_NONE);
 163   status =
 164     ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001", NULL);
 165   EXPECT_EQ(status, ML_ERROR_NONE);
 166   status = ml_train_lr_scheduler_destroy(handle);
 167   EXPECT_EQ(status, ML_ERROR_NONE);
 168 }
 169
 170 /**
 171  * @brief Learning rate scheduler set Property Test (positive test)
 172  */
 173 TEST(nntrainer_capi_lr_scheduler, setProperty_02_p) {
 174   ml_train_lr_scheduler_h handle;
 175   int status;
 176   status = ml_train_lr_scheduler_create(&handle,
 177                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 178   EXPECT_EQ(status, ML_ERROR_NONE);
 179   status = ml_train_lr_scheduler_set_property(
 180     handle, "learning_rate=0.001", "decay_rate=0.9", "decay_steps=2", NULL);
 181   EXPECT_EQ(status, ML_ERROR_NONE);
 182   status = ml_train_lr_scheduler_destroy(handle);
 183   EXPECT_EQ(status, ML_ERROR_NONE);
 184 }
 185
 186 /**
 187  * @brief Learning rate scheduler set Property Test (positive test)
 188  */
 189 TEST(nntrainer_capi_lr_scheduler, setProperty_03_p) {
 190   ml_train_lr_scheduler_h handle;
 191   int status;
 192   status =
 193     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_STEP);
 194   EXPECT_EQ(status, ML_ERROR_NONE);
 195   status = ml_train_lr_scheduler_set_property(
 196     handle, "learning_rate=0.01, 0.001", "iteration=100", NULL);
 197   EXPECT_EQ(status, ML_ERROR_NONE);
 198   status = ml_train_lr_scheduler_destroy(handle);
 199   EXPECT_EQ(status, ML_ERROR_NONE);
 200 }
 201
 202 /**
 203  * @brief Learning rate scheduler set Property Test (negative test)
 204  */
 205 TEST(nntrainer_capi_lr_scheduler, setProperty_04_n) {
 206   ml_train_lr_scheduler_h handle;
 207   int status;
 208   status =
 209     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
 210   EXPECT_EQ(status, ML_ERROR_NONE);
 211   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 212                                               "iteration=10", NULL);
 213   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 214   status = ml_train_lr_scheduler_destroy(handle);
 215   EXPECT_EQ(status, ML_ERROR_NONE);
 216 }
 217
 218 /**
 219  * @brief Learning rate scheduler set Property Test (negative test)
 220  */
 221 TEST(nntrainer_capi_lr_scheduler, setProperty_05_n) {
 222   ml_train_lr_scheduler_h handle;
 223   int status;
 224   status =
 225     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
 226   EXPECT_EQ(status, ML_ERROR_NONE);
 227   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 228                                               "decay_rate=0.9", NULL);
 229   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 230   status = ml_train_lr_scheduler_destroy(handle);
 231   EXPECT_EQ(status, ML_ERROR_NONE);
 232 }
 233
 234 /**
 235  * @brief Learning rate scheduler set Property Test (negative test)
 236  */
 237 TEST(nntrainer_capi_lr_scheduler, setProperty_06_n) {
 238   ml_train_lr_scheduler_h handle;
 239   int status;
 240   status =
 241     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_CONSTANT);
 242   EXPECT_EQ(status, ML_ERROR_NONE);
 243   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 244                                               "decay_steps=2", NULL);
 245   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 246   status = ml_train_lr_scheduler_destroy(handle);
 247   EXPECT_EQ(status, ML_ERROR_NONE);
 248 }
 249
 250 /**
 251  * @brief Learning rate scheduler set Property Test (negative test)
 252  */
 253 TEST(nntrainer_capi_lr_scheduler, setProperty_07_n) {
 254   ml_train_lr_scheduler_h handle;
 255   int status;
 256   status = ml_train_lr_scheduler_create(&handle,
 257                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 258   EXPECT_EQ(status, ML_ERROR_NONE);
 259   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 260                                               "iteration=100", NULL);
 261   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 262   status = ml_train_lr_scheduler_destroy(handle);
 263   EXPECT_EQ(status, ML_ERROR_NONE);
 264 }
 265
 266 /**
 267  * @brief Learning rate scheduler set Property Test (negative test)
 268  */
 269 TEST(nntrainer_capi_lr_scheduler, setProperty_08_n) {
 270   ml_train_lr_scheduler_h handle;
 271   int status;
 272   status =
 273     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_STEP);
 274   EXPECT_EQ(status, ML_ERROR_NONE);
 275   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 276                                               "decay_rate=0.9", NULL);
 277   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 278   status = ml_train_lr_scheduler_destroy(handle);
 279   EXPECT_EQ(status, ML_ERROR_NONE);
 280 }
 281
 282 /**
 283  * @brief Learning rate scheduler set Property Test (negative test)
 284  */
 285 TEST(nntrainer_capi_lr_scheduler, setProperty_09_n) {
 286   ml_train_lr_scheduler_h handle;
 287   int status;
 288   status =
 289     ml_train_lr_scheduler_create(&handle, ML_TRAIN_LR_SCHEDULER_TYPE_STEP);
 290   EXPECT_EQ(status, ML_ERROR_NONE);
 291   status = ml_train_lr_scheduler_set_property(handle, "learning_rate=0.001",
 292                                               "decay_steps=2", NULL);
 293   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 294   status = ml_train_lr_scheduler_destroy(handle);
 295   EXPECT_EQ(status, ML_ERROR_NONE);
 296 }
 297
 298 /**
 299  * @brief Learning rate scheduler set Property Test (positive test)
 300  */
 301 TEST(nntrainer_capi_lr_scheduler, setProperty_with_single_param_01_p) {
 302   ml_train_lr_scheduler_h handle;
 303   int status;
 304   status = ml_train_lr_scheduler_create(&handle,
 305                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 306   EXPECT_EQ(status, ML_ERROR_NONE);
 307   status = ml_train_lr_scheduler_set_property_with_single_param(
 308     handle, "learning_rate=0.001 | decay_rate=0.9 | decay_steps=2");
 309   EXPECT_EQ(status, ML_ERROR_NONE);
 310   status = ml_train_lr_scheduler_destroy(handle);
 311   EXPECT_EQ(status, ML_ERROR_NONE);
 312 }
 313
 314 /**
 315  * @brief Learning rate scheduler set Property Test (negative test)
 316  */
 317 TEST(nntrainer_capi_lr_scheduler, setProperty_with_single_param_02_n) {
 318   ml_train_lr_scheduler_h handle;
 319   int status;
 320   status = ml_train_lr_scheduler_create(&handle,
 321                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 322   EXPECT_EQ(status, ML_ERROR_NONE);
 323   status = ml_train_lr_scheduler_set_property_with_single_param(
 324     handle, "learning_rate=0.001, decay_rate=0.9, decay_steps=2");
 325   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 326   status = ml_train_lr_scheduler_destroy(handle);
 327   EXPECT_EQ(status, ML_ERROR_NONE);
 328 }
 329
 330 /**
 331  * @brief Learning rate scheduler set Property Test (negative test)
 332  */
 333 TEST(nntrainer_capi_lr_scheduler, setProperty_with_single_param_03_n) {
 334   ml_train_lr_scheduler_h handle;
 335   int status;
 336   status = ml_train_lr_scheduler_create(&handle,
 337                                         ML_TRAIN_LR_SCHEDULER_TYPE_EXPONENTIAL);
 338   EXPECT_EQ(status, ML_ERROR_NONE);
 339   status = ml_train_lr_scheduler_set_property_with_single_param(
 340     handle, "learning_rate=0.001 ! decay_rate=0.9 ! decay_steps=2");
 341   EXPECT_EQ(status, ML_ERROR_INVALID_PARAMETER);
 342   status = ml_train_lr_scheduler_destroy(handle);
 343   EXPECT_EQ(status, ML_ERROR_NONE);
 344 }
 345
 346 /**
 347  * @brief Main gtest
 348  */
 349 int main(int argc, char **argv) {
 350   int result = -1;
 351
 352   try {
 353     testing::InitGoogleTest(&argc, argv);
 354   } catch (...) {
 355     std::cerr << "Error duing IniGoogleTest" << std::endl;
 356     return 0;
 357   }
 358
 359   /** ignore tizen feature check while running the testcases */
 360   set_feature_state(ML_FEATURE, SUPPORTED);
 361   set_feature_state(ML_FEATURE_INFERENCE, SUPPORTED);
 362   set_feature_state(ML_FEATURE_TRAINING, SUPPORTED);
 363
 364   try {
 365     result = RUN_ALL_TESTS();
 366   } catch (...) {
 367     std::cerr << "Error duing RUN_ALL_TSETS()" << std::endl;
 368   }
 369
 370   /** reset tizen feature check state */
 371   set_feature_state(ML_FEATURE, NOT_CHECKED_YET);
 372   set_feature_state(ML_FEATURE_INFERENCE, NOT_CHECKED_YET);
 373   set_feature_state(ML_FEATURE_TRAINING, NOT_CHECKED_YET);
 374
 375   return result;
 376 }