nnfw_experimental.h

Go to the documentation of this file.

/*
 * Copyright (c) 2019 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 __NNFW_EXPERIMENTAL_H__
#define __NNFW_EXPERIMENTAL_H__
 
#include "nnfw.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
// Used for custom kernel development
 
/*
 * operand type, used only for custom operations
 */
typedef struct
{
  nnfw_tensorinfo type;
  void *allocation;
} nnfw_operand;
 
/*
 * Used as input to custom operation eval function
 */
typedef struct
{
  size_t ninputs;
  nnfw_operand *inputs;
 
  size_t noutputs;
  nnfw_operand *outputs;
} nnfw_custom_kernel_params;
 
/*
 * Custom kernel evaluation function
 *
 * param[in] params custom operation parameters
 * param[in] userdata pointer to user-specified buffer( kernel instance specific )
 */
typedef void (*nnfw_custom_eval)(nnfw_custom_kernel_params *params, char *userdata,
                                 size_t userdata_size);
 
/*
 * custom operation registration info
 */
typedef struct
{
  nnfw_custom_eval eval_function;
} custom_kernel_registration_info;
 
NNFW_STATUS nnfw_register_custom_op_info(nnfw_session *session, const char *id,
                                         custom_kernel_registration_info *info);
 
NNFW_STATUS nnfw_input_tensorindex(nnfw_session *session, const char *tensorname, uint32_t *index);
 
NNFW_STATUS nnfw_output_tensorindex(nnfw_session *session, const char *tensorname, uint32_t *index);
 
NNFW_STATUS nnfw_set_backends_per_operation(nnfw_session *session, const char *backend_settings);
 
NNFW_STATUS nnfw_prepare_pipeline(nnfw_session *session, const char *map_file_path = nullptr);
 
NNFW_STATUS nnfw_push_pipeline_input(nnfw_session *session, void *inputs, void *lengths);
 
NNFW_STATUS nnfw_pop_pipeline_output(nnfw_session *session, void *outputs);
 
// 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 enum
{
  NNFW_TRAIN_TRAINABLE_INCORRECT_STATE = -2,
  NNFW_TRAIN_TRAINABLE_ALL = -1,
  NNFW_TRAIN_TRAINABLE_NONE = 0,
 
} NNFW_TRAIN_NUM_OF_TRAINABLE_OPS_SPECIAL_VALUES;
 
typedef struct nnfw_train_info
{
  float learning_rate = 0.001f;
  uint32_t batch_size = 1;
  nnfw_loss_info loss_info{.loss = NNFW_TRAIN_LOSS_MEAN_SQUARED_ERROR,
                           .reduction_type = NNFW_TRAIN_LOSS_REDUCTION_SUM_OVER_BATCH_SIZE};
  NNFW_TRAIN_OPTIMIZER opt = NNFW_TRAIN_OPTIMIZER_SGD;
 
  int32_t num_of_trainable_ops = NNFW_TRAIN_TRAINABLE_NONE;
} nnfw_train_info;
 
NNFW_STATUS nnfw_train_get_traininfo(nnfw_session *session, nnfw_train_info *info);
 
NNFW_STATUS nnfw_train_set_traininfo(nnfw_session *session, const nnfw_train_info *info);
 
NNFW_STATUS nnfw_train_prepare(nnfw_session *session);
 
NNFW_STATUS nnfw_train_set_input(nnfw_session *session, uint32_t index, const void *input,
                                 const nnfw_tensorinfo *input_info);
 
NNFW_STATUS nnfw_train_set_expected(nnfw_session *session, uint32_t index, const void *expected,
                                    const nnfw_tensorinfo *expected_info);
 
NNFW_STATUS nnfw_train_set_output(nnfw_session *session, uint32_t index, NNFW_TYPE type,
                                  void *buffer, size_t length);
 
NNFW_STATUS nnfw_train(nnfw_session *session, bool update_weights);
 
NNFW_STATUS nnfw_train_get_loss(nnfw_session *session, uint32_t index, float *loss);
 
NNFW_STATUS nnfw_train_export_circle(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_train_import_checkpoint(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_train_export_checkpoint(nnfw_session *session, const char *path);
 
// Optional APIs for training
 
NNFW_STATUS nnfw_train_input_tensorinfo(nnfw_session *session, uint32_t index,
                                        nnfw_tensorinfo *info);
 
NNFW_STATUS nnfw_train_expected_tensorinfo(nnfw_session *session, uint32_t index,
                                           nnfw_tensorinfo *info);
 
// Not planned to be implemented
 
// NNFW_STATUS nnfw_set_training_mode(nnfw_session *session, bool train);
 
typedef enum
{
  NNFW_QUANTIZE_TYPE_NOT_SET,
  NNFW_QUANTIZE_TYPE_U8_ASYM,
  NNFW_QUANTIZE_TYPE_I16_SYM,
  NNFW_QUANTIZE_TYPE_WO_I8_SYM,
  NNFW_QUANTIZE_TYPE_WO_I16_SYM,
 
} NNFW_QUANTIZE_TYPE;
 
NNFW_STATUS nnfw_set_quantization_type(nnfw_session *session, NNFW_QUANTIZE_TYPE qtype);
 
NNFW_STATUS nnfw_set_quantized_model_path(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_quantize(nnfw_session *session);
 
typedef enum
{
  NNFW_CODEGEN_PREF_DEFAULT,
  // TODO Support Traffic and Cycle code generation preference
  NNFW_CODEGEN_PREF_PERFORMANCE_FIRST,
  NNFW_CODEGEN_PREF_MEMORY_FIRST,
  NNFW_CODEGEN_PREF_COMPILE_TIME_FIRST,
} NNFW_CODEGEN_PREF;
 
NNFW_STATUS nnfw_set_codegen_model_path(nnfw_session *session, const char *path);
 
NNFW_STATUS nnfw_codegen(nnfw_session *session, const char *target, NNFW_CODEGEN_PREF pref);
 
NNFW_STATUS nnfw_set_odc_param_minmax_records_count(nnfw_session *session,
                                                    int minmax_records_count);
 
NNFW_STATUS nnfw_odc_delete_minmax_file(nnfw_session *session);
 
NNFW_STATUS nnfw_run_with_auto_compilation(nnfw_session *session, const char *target,
                                           NNFW_CODEGEN_PREF pref);
 
// APIs for configuration
 
typedef enum
{
  NNFW_PREPARE_CONFIG_PROFILE,
} NNFW_PREPARE_CONFIG;
 
NNFW_STATUS nnfw_set_prepare_config(nnfw_session *session, NNFW_PREPARE_CONFIG key,
                                    const char *value);
 
NNFW_STATUS nnfw_reset_prepare_config(nnfw_session *session);
 
typedef enum
{
  NNFW_RUN_CONFIG_DUMP_MINMAX,
  NNFW_RUN_CONFIG_TRACE,
  NNFW_RUN_CONFIG_PROFILE,
} NNFW_RUN_CONFIG;
 
NNFW_STATUS nnfw_set_execute_config(nnfw_session *session, const NNFW_RUN_CONFIG key,
                                    const char *value);
 
NNFW_STATUS nnfw_reset_execute_config(nnfw_session *session);
 
#ifdef __cplusplus
}
#endif
 
#endif // __NNFW_EXPERIMENTAL_H__