onert-micro.h

Go to the documentation of this file.

/*
 * Copyright (c) 2024 Samsung Electronics Co., Ltd. All Rights Reserved
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _ONERT_MICRO_H_
#define _ONERT_MICRO_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*
 * typical training flow in onert-micro
 *
 * 1. load model or checkpoint
 *   1-1. (optional) configure training options
 * 2. feed training input / output(e.g. label) data (cf. unit of a step)
 * 3. train a step
 * 4. check loss
 *   4-0. save checkpoint for recovery/resume training
 *   4-1. no more traning -> go to 5
 *   4-2. more training -> go to 2
 * 5. save current state to inference model
 * 6. inference with inference model
// sample example
// 0. create context
nnfw_session *session;
nnfw_create_session(&session);
// 1. load model (and checkpoint if continue training)
nnfw_load_model_from_file(session, MODEL_PATH);
// 1-1. (optional, TBD) configure training options
nnfw_load_ckpt_from_file(session, CKPT_PATH);
nnfw_train_prepare(session);
float training_input[BATCH_SIZE*INPUT_SIZE];
float training_label[BATCH_SIZE*OUTPUT_SIZE];
// main training loop
for(int epoch=0; epoch < NUM_EPOCHS; epoch++) {
  for(int step=0; step < NUM_BATCHES ; step++) {
    // prepare this steps's intput/label
    memcpy(training_input, train_input_data + THIS_BATCH_OFFSET, BATCH_SIZE*INPUT_SIZE);
    memcpy(training_output, train_output_data + THIS_BATCH_OFFSET, BATCH_SIZE*OUTPUT_SIZE);
    // 2. feed training input / expected output
    nnfw_train_set_input(session, 0 , training_input, NULL);
    nnfw_train_set_expected(session, 0 , training_output, NULL);
    // 3. train a step
    nnfw_train(session);
  }
  // 4. check loss
  float loss;
  nnfw_train_get_loss(ctx, 0, &loss);
  if(loss > TARGET_LOSS) {
    nnfw_train_save_as_checkpoint(ctx, CKPT_PATH);
  }
  else {
    nnfw_train_export_circle(ctx, CIRCLE_PATH);
  }
}
*/
 
typedef struct nnfw_session nnfw_session;
 
typedef enum
{
  NNFW_TYPE_TENSOR_FLOAT32 = 0,
  NNFW_TYPE_TENSOR_INT32 = 1,
} NNFW_TYPE;
 
typedef enum
{
  NNFW_STATUS_NO_ERROR = 0,
  NNFW_STATUS_ERROR = 1,
  NNFW_STATUS_UNEXPECTED_NULL = 2,
  NNFW_STATUS_INVALID_STATE = 3,
  NNFW_STATUS_OUT_OF_MEMORY = 4,
  NNFW_STATUS_INSUFFICIENT_OUTPUT_SIZE = 5,
  NNFW_STATUS_DEPRECATED_API = 6,
} NNFW_STATUS;
 
#define NNFW_MAX_RANK (6)
 
typedef struct nnfw_tensorinfo
{
  NNFW_TYPE dtype;
  int32_t rank;
  int32_t dims[NNFW_MAX_RANK];
} nnfw_tensorinfo;
 
// Essential APIs for training
typedef enum
{
  NNFW_TRAIN_LOSS_UNDEFINED = 0,
  NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR = 1,
  NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY = 2,
} NNFW_TRAIN_LOSS;
 
typedef enum
{
  NNFW_TRAIN_LOSS_REDUCTION_UNDEFINED = 0,
  NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE = 1,
  NNFW_TRAIN_LOSS_REDUCTION_SUM = 2,
} NNFW_TRAIN_LOSS_REDUCTION;
 
typedef enum
{
  NNFW_TRAIN_OPTIMIZER_UNDEFINED = 0,
  NNFW_TRAIN_OPTIMIZER_SGD = 1,
  NNFW_TRAIN_OPTIMIZER_ADAM = 2,
} NNFW_TRAIN_OPTIMIZER;
 
typedef struct nnfw_loss_info
{
  NNFW_TRAIN_LOSS loss;
  NNFW_TRAIN_LOSS_REDUCTION reduction_type;
} nnfw_loss_info;
 
typedef struct nnfw_adam_option
{
  float beta;
  float beta2;
  float epsilon;
} nnfw_adam_option;
 
#define NNFW_TRAINABLE_OPS_MAX_SIZE (256)
 
typedef struct nnfw_train_info
{
  float learning_rate = 0.001f;
  uint32_t batch_size = 1;
  nnfw_loss_info loss_info{.loss = NNFW_TRAIN_LOSS_CATEGORICAL_CROSSENTROPY,
                           .reduction_type = NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE};
  NNFW_TRAIN_OPTIMIZER opt = NNFW_TRAIN_OPTIMIZER_ADAM;
 
  uint32_t num_trainble_ops = 0;
 
  nnfw_adam_option adam_opt{.beta = 0.9f,
 
                            .beta2 = 0.999f,
                            .epsilon = 1e-7f};
} nnfw_train_info;
 
NNFW_STATUS nnfw_train_set_traininfo(nnfw_session *session, const nnfw_train_info *info);
 
NNFW_STATUS nnfw_create_session(nnfw_session **session);
 
NNFW_STATUS nnfw_close_session(nnfw_session *session);
 
NNFW_STATUS nnfw_load_model_from_file(nnfw_session *session, const char *package_file_path);
 
NNFW_STATUS nnfw_train_prepare(nnfw_session *session);
 
NNFW_STATUS nnfw_train(nnfw_session *session, bool update_weights);
 
NNFW_STATUS nnfw_train_export_circle(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_train_export_checkpoint(nnfw_session *session, const char *path);
NNFW_STATUS nnfw_train_import_checkpoint(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_train_set_input(nnfw_session *session, uint32_t index, void *input,
                                 const nnfw_tensorinfo *input_info);
 
NNFW_STATUS nnfw_train_set_expected(nnfw_session *session, uint32_t index, void *expected,
                                    const nnfw_tensorinfo *expected_info);
 
NNFW_STATUS nnfw_train_get_loss(nnfw_session *session, uint32_t index, float *loss);
 
NNFW_STATUS nnfw_train_set_output(nnfw_session *session, uint32_t index, NNFW_TYPE type,
                                  void *buffer, size_t length);
 
#ifdef __cplusplus
}
#endif
 
#endif //_ONERT_MICRO_H_