CaffeOp.fbs

include "Tensor.fbs";
namespace MNN;
enum PadMode : byte{
    CAFFE=0,
    VALID=1,
    SAME=2
}

table Convolution2DCommon {
    padX:int = 0;
    padY:int = 0;
    kernelX:int = 1;
    kernelY:int = 1;
    strideX:int = 1;
    strideY:int = 1;
    dilateX:int = 1;
    dilateY:int = 1;
    padMode:PadMode = CAFFE;
    group:int = 1;
    outputCount:int = 0;
    inputCount:int = 0;
    relu:bool=false;
    relu6:bool=false;
}

// idst param
table IDSTQuan {
    buffer:[byte];
    alpha:[float];
    type:int;
    useInt32:bool;
    quantScale:float;
    scaleIn:float;
    scaleOut:float;
    aMax:int;
    aMin:int;
    readType:int;
    has_scaleInt:bool;
}

table QuantizedFloatParam{
    weight:[byte];
    bias:[int];
    // scale channel-wise(depthwise conv/batchnorm...)
    // which is used to int32*scale->int8
    scale:[float];
    // tensor scale, which is used to dequantize the int8 value to float value 
    // only used for debug or output op
    tensorScale:[float];
}

table Convolution2D {
    common:Convolution2DCommon;
    weight:[float];
    bias:[float];

    quanParameter:IDSTQuan;
    symmetricQuan:QuantizedFloatParam;
}

table InnerProduct {
    outputCount:int;
    biasTerm:int;
    weightSize:int;
    weight:[float];
    bias:[float];
    axis:int;
    transpose:bool;
    // idst param
    quanParameter:IDSTQuan;
}

enum PoolType : byte {
    MAXPOOL=0,
    AVEPOOL
}
enum PoolPadType : byte {
    CAFFE=0,
    VALID,
    SAME
}
table Pool {
    padX:int;
    padY:int;
    isGlobal:bool=false;
    kernelX:int;
    kernelY:int;
    strideX:int;
    strideY:int;
    type:PoolType;
    padType:PoolPadType;
    dataType:DataType=DT_FLOAT;
    ceilModel:bool=true;
}

table Relu {
    slope:float;
}

table Relu6 {
    slope:float;
}

table PRelu {
    slopeCount:int;
    slope:[float];
}

table LRN {
    regionType:int;
    localSize:int;
    alpha:float;
    beta:float;
}

table ArgMax {
    outMaxVal:int;
    topK:int;
    axis:int;
    softmaxThreshold:int;
}

table Axis {
    axis:int;
}

table Input {
    dims:[int];
    dtype:DataType = DT_FLOAT;
    dformat:MNN_DATA_FORMAT = NC4HW4;
}

table LSTM {
    // param
  outputCount:int;
  weightSize:int;
  clippingThreshold:float;
  // model
  weightI:Blob;
  weightH:Blob;
  bias:Blob;
  weightIQ:Blob;
  weightIA:Blob;
  quantScale:float;
}

table Slice {
    axis:int;
    slicePoints:[int];
    sourceType:NetSource=CAFFE;
}

table BatchNorm {
  channels:int;
  slopeData:[float];
  meanData:[float];
  varData:[float];
  biasData:[float];
  Adata:[float];
  Bdata:[float];
  epsilon:float=0.001;
}

table Scale {
    channels:int;
    scaleData:[float];
    biasData:[float];
}

enum EltwiseType : byte {
    PROD = 0,
    SUM = 1,
    MAXIMUM = 2,
    SUB = 3
}

table Eltwise {
    type:EltwiseType;
    coeff:[float];
}

table Flatten {
    axis:int;
    endAxis:int;
}

table Permute {
    dims:[int];
}

table Reshape {
    dims:[int];
    dimType: MNN_DATA_FORMAT;    
}

table DetectionOutput {
    classCount:int;
    nmsThresholdold:float;
    nmsTopK:int;
    keepTopK:int;
    confidenceThreshold:float;
    shareLocation:int;
    backgroundLable:int;
    varianceEncodedTarget:int;
    codeType:int;
    objectnessScore:float=0.01;
}

table RoiPooling {
    pooledWidth:int;
    pooledHeight:int;
    spatialScale:float;
}

table Proposal {
    featStride:int;
    baseSize:int;
    preNmsTopN:int;
    afterNmsTopN:int;
    nmsThreshold:float;
    minSize:int;
    ratios:Blob;
    scales:Blob;
    anchors:Blob;
}

table Interp {
    widthScale:float;
    heightScale:float;
    outputWidth:int;
    outputHeight:int;
    resizeType:int;
    alignCorners:bool;
}

table Resize {
    xScale:float;
    yScale:float;
}

table PriorBox {
  minSizes : [float];
  maxSizes : [float];
  aspectRatios : [float];
  variances:[float];
  flip:bool;
  clip:bool;
  imageWidth:int;
  imageHeight:int;
  stepWidth:int;
  stepHeight:int;
  offset:float;
}

table Normalize {
  acrossSpatial:int;
  channelShared:int;
  eps:float;
  scale:[float];
}