latest/amd_openvx/openvx/include/VX/vx_khr_nn.h Source File

latest/amd_openvx/openvx/include/VX/vx_khr_nn.h Source File#

MIVisionX: latest/amd_openvx/openvx/include/VX/vx_khr_nn.h Source File
 /*
  * Copyright (c) 2012-2020 The Khronos Group Inc.
  *
  * 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 _VX_KHR_NN_H_
 #define _VX_KHR_NN_H_
  
 #define OPENVX_KHR_NN   "vx_khr_nn"
  
 #include <VX/vx.h>
  
  
 #ifdef  __cplusplus
 extern "C" {
 #endif
  
  
 /*==============================================================================
 CONVOLUTIONAL_NETWORK structs and enums
 =============================================================================*/
  
 #define VX_LIBRARY_KHR_NN_EXTENSION (0x1)
  
 enum vx_kernel_nn_ext_e {
     VX_KERNEL_CONVOLUTION_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x0,
     VX_KERNEL_FULLY_CONNECTED_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x1,
     VX_KERNEL_POOLING_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x2,
     VX_KERNEL_SOFTMAX_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x3,
     VX_KERNEL_ACTIVATION_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x5,
     VX_KERNEL_ROI_POOLING_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x6,
     VX_KERNEL_DECONVOLUTION_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x7,
     VX_KERNEL_LOCAL_RESPONSE_NORMALIZATION_LAYER = VX_KERNEL_BASE(VX_ID_KHRONOS, VX_LIBRARY_KHR_NN_EXTENSION) + 0x8,
 };
  
 enum vx_nn_enum_e
 {
     VX_ENUM_NN_ROUNDING_TYPE    = 0x1A,
     VX_ENUM_NN_POOLING_TYPE = 0x1B,
     VX_ENUM_NN_NORMALIZATION_TYPE   = 0x1C,
     VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE = 0x1D,
 };
  
 enum vx_nn_rounding_type_e
 {
     VX_NN_DS_SIZE_ROUNDING_FLOOR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ROUNDING_TYPE) + 0x0,
     VX_NN_DS_SIZE_ROUNDING_CEILING = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ROUNDING_TYPE) + 0x1
 };
  
  
 enum vx_nn_pooling_type_e
 {
     VX_NN_POOLING_MAX = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_POOLING_TYPE) + 0x0,
     VX_NN_POOLING_AVG = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_POOLING_TYPE) + 0x1
 };
  
  
 enum vx_nn_norm_type_e
 {
     VX_NN_NORMALIZATION_SAME_MAP = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_NORMALIZATION_TYPE) + 0x0,
     VX_NN_NORMALIZATION_ACROSS_MAPS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_NORMALIZATION_TYPE) + 0x1,
 };
  
  
  
 enum vx_nn_activation_function_e
 {
     VX_NN_ACTIVATION_LOGISTIC = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x0,
     VX_NN_ACTIVATION_HYPERBOLIC_TAN = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x1,
     VX_NN_ACTIVATION_RELU = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x2,
     VX_NN_ACTIVATION_BRELU = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x3,
     VX_NN_ACTIVATION_SOFTRELU = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x4,
     VX_NN_ACTIVATION_ABS = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x5,
     VX_NN_ACTIVATION_SQUARE = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x6,
     VX_NN_ACTIVATION_SQRT = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x7,
     VX_NN_ACTIVATION_LINEAR = VX_ENUM_BASE(VX_ID_KHRONOS, VX_ENUM_NN_ACTIVATION_FUNCTION_TYPE) + 0x8,
 };
  
  
 enum vx_nn_type_e {
     VX_TYPE_NN_CONVOLUTION_PARAMS     = 0x025,
     VX_TYPE_NN_DECONVOLUTION_PARAMS   = 0x026,
     VX_TYPE_NN_ROI_POOL_PARAMS        = 0x027,
 };
  
 typedef struct _vx_nn_convolution_params_t
 {
     vx_size padding_x;                 
     vx_size padding_y;                 
     vx_enum overflow_policy;         
     vx_enum rounding_policy;         
     vx_enum down_scale_size_rounding; 
     vx_size dilation_x;            
     vx_size dilation_y;            
 } vx_nn_convolution_params_t;
  
  
 typedef struct _vx_nn_deconvolution_params_t
 {
     vx_size padding_x;                 
     vx_size padding_y;                 
     vx_enum overflow_policy;         
     vx_enum rounding_policy;         
     vx_size a_x;                 
     vx_size a_y;                 
 } vx_nn_deconvolution_params_t;
  
 typedef struct _vx_nn_roi_pool_params_t
 {
     vx_enum pool_type;  
 } vx_nn_roi_pool_params_t;
  
 /*==============================================================================
     NN Nodes
 =============================================================================*/
 VX_API_ENTRY vx_node VX_API_CALL vxConvolutionLayer(vx_graph graph, vx_tensor inputs, vx_tensor weights, vx_tensor biases, const vx_nn_convolution_params_t *convolution_params, vx_size size_of_convolution_params, vx_tensor outputs);
  
 VX_API_ENTRY vx_node VX_API_CALL vxFullyConnectedLayer(vx_graph graph, vx_tensor inputs, vx_tensor weights, vx_tensor biases, vx_enum overflow_policy, vx_enum rounding_policy, vx_tensor outputs);
  
  
 VX_API_ENTRY vx_node VX_API_CALL vxPoolingLayer(vx_graph graph, vx_tensor inputs, vx_enum pooling_type,
         vx_size pooling_size_x,
         vx_size pooling_size_y,
         vx_size pooling_padding_x,
         vx_size pooling_padding_y,
         vx_enum rounding,
         vx_tensor outputs);
  
 VX_API_ENTRY vx_node VX_API_CALL vxSoftmaxLayer(vx_graph graph, vx_tensor inputs, vx_tensor outputs);
  
 VX_API_ENTRY vx_node VX_API_CALL vxLocalResponseNormalizationLayer(vx_graph graph, vx_tensor inputs, vx_enum type,
         vx_size normalization_size,
         vx_float32 alpha,
         vx_float32 beta,
         vx_float32 bias,
         vx_tensor outputs);
  
 VX_API_ENTRY vx_node VX_API_CALL vxActivationLayer(vx_graph graph, vx_tensor inputs, vx_enum function, vx_float32 a,vx_float32 b, vx_tensor outputs);
  
 VX_API_ENTRY vx_node VX_API_CALL vxROIPoolingLayer(vx_graph graph, vx_tensor input_data, vx_tensor input_rois, const vx_nn_roi_pool_params_t *roi_pool_params, vx_size size_of_roi_params, vx_tensor output_arr);
  
  
 VX_API_ENTRY vx_node VX_API_CALL vxDeconvolutionLayer(vx_graph graph, vx_tensor inputs, vx_tensor weights, vx_tensor  biases, const vx_nn_deconvolution_params_t *deconvolution_params, vx_size size_of_deconv_params, vx_tensor outputs);
  
  
 #ifdef  __cplusplus
 }
 #endif
  
  
 #endif