File: NeuralNetwork.proto

package info (click to toggle)
chromium 138.0.7204.183-1
links: PTS, VCS
area: main
in suites: trixie
size: 6,071,908 kB
sloc: cpp: 34,937,088; ansic: 7,176,967; javascript: 4,110,704; python: 1,419,953; asm: 946,768; xml: 739,971; pascal: 187,324; sh: 89,623; perl: 88,663; objc: 79,944; sql: 50,304; cs: 41,786; fortran: 24,137; makefile: 21,806; php: 13,980; tcl: 13,166; yacc: 8,925; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (6371 lines) | stat: -rw-r--r-- 182,643 bytes
parent folder | download | duplicates (6)
// Copyright (c) 2017-2019, Apple Inc. All rights reserved.
//
// Use of this source code is governed by a BSD-3-clause license that can be
// found in LICENSE.txt or at https://opensource.org/licenses/BSD-3-Clause

/*
 * A neural network is defined through a collection of layers
 * and represents a directed acyclic graph (DAG).
 * Each layer has a name, a layer type,
 * a list of input names, a list of output names,
 * and a collection of parameters specific to the layer type.
 *
 * The graph structure and connectivity of the neural network
 * is inferred from the input and output names.
 * A neural network starts with the layer
 * whose input name is equal to the value specified in
 * ``Model.description.input.name``,
 * and ends with the layer
 * whose output name is equal to the value specified in
 * ``Model.description.output.name``.
 * Layers must have unique input and output names,
 * and a layer may not have input or output names that
 * refer to layers that are not yet defined.
 *
 * For Core ML specification version <=3,
 * all inputs are mapped to static rank 5 tensors, with axis notations
 * [Sequence, Batch, Channel, Height, Width].
 *
 * From specification version 4 onwards (iOS >= 13, macOS >= 10.15), more
 * options are available (see enums ``NeuralNetworkMultiArrayShapeMapping``,
 * ``NeuralNetworkImageShapeMapping``) to map inputs to generic N-Dimensional
 * (or N rank) tensors, where N >= 1.
 *
 * Each layer type may have specific constraints on the ranks of its inputs and
 * outputs.
 *
 * Some of the layers (such as softmax, reduce, etc) have parameters that have
 * been described in terms of notational axis "Channel", "Height", "Width" or
 * "Sequence". They can be re-interpreted easily in the general ND setting by
 * using the following rule: "width" is same as axis = -1 (i.e. the last axis
 * from the end) "height" is same as axis = -2 (i.e. the second last axis from
 * the end) "channel" is same as axis = -3 (i.e. the third last axis from the
 * end) "sequence" is same as axis = -5 (i.e. the fifth last axis from the end)
 *
 * Several layers are available in 3 different variations, with the names ending
 * in identifiers: ``like``, ``static`` and ``dynamic``. For instance,
 * ``FillLike``,
 * ``FillStatic`` and ``FillDynamic``. The ``static`` variation generally will
 * have a property corresponding to the shape of the output. For instance, if
 * the output of the ``FillStatic`` layer is desired to be of shape (10, 4), the
 * property ``targetShape`` will have to be set to [10, 4]. In the ``dynamic``
 * case, the shape is an input, hence it can be changed at runtime. For
 * instance, for a ``FillDynamic`` layer, the input would have to be an array
 * containing the values 10 and 4, if the desired output is of shape (10, 4).
 * Whereas in the
 * ``like`` case, the additional input's shape is used as the output shape,
 * ignoring its values. For instance, for a ``FillLike`` layer, for an input
 * with shape (10, 4), the output generated will also be of shape (10, 4),
 * values of the input will be ignored.
 */

syntax = "proto3";
option optimize_for = LITE_RUNTIME;

import public "DataStructures.proto";
import public "Parameters.proto";

package CoreML.Specification;

enum NeuralNetworkMultiArrayShapeMapping {
  /*
   * Describes how the MultiArray shape for the inputs,
   * provided in Features Types proto via model description,
   * is mapped to construct tensors that are fed into the Neural Network layers.
   */

  /*
   * Default legacy value. Only supported for Core ML Specification version
   * <= 3.
   *
   * The default legacy shape mapping resolves all input shapes to a rank 5
   * equivalent with axis notation of [Seq, Batch, Channel, Height, Width].
   *
   * When this enum value is selected,
   * the repeated shape field in the message "ArrayFeatureType" in feature types
   * proto, must be either length 1 or length 3.
   *
   * The following rule is used to map the values in the shape field to the
   * actual tensor shape: rank 1 shape is mapped to shape [1,1,C,1,1] rank 3
   * shape is mapped to shape [1,1,C,H,W] At runtime, the first two dimensions
   * (Seq or Batch) can be presented as well, with non-1 values.
   *
   * It is invalid to use this enum value if any of the layers added
   * Specification version 4 (iOS >= 13, macOS >= 10.15) onwards are used in the
   * network. Validator will raise an error in that case.
   */
  RANK5_ARRAY_MAPPING = 0;

  /*
   * The exact shape and rank (i.e. number of dimensions in the shape) of the
   * input, as specified in the message "ArrayFeatureType", is passed through to
   * the layers. Supported only for Specification version >= 4 (iOS >= 13, macOS
   * >= 10.15).
   */
  EXACT_ARRAY_MAPPING = 1;
}

enum NeuralNetworkImageShapeMapping {
  /*
   * Describes how the shape of the input tensors is constructed from image
   * inputs.
   */

  /*
   * In this case, image input is mapped to a rank 5 tensor.
   * For Color images, input tensor is shaped as [1,1,3,H,W].
   * For Gray images, input tensor is shaped as [1,1,1,H,W].
   */
  RANK5_IMAGE_MAPPING = 0;

  /*
   * For Color images, input tensor is shaped as [1,3,H,W].
   * For Gray images, input tensor is shaped as [1,1,H,W].
   * Supported only for Specification version >= 4 (iOS >= 13, macOS >= 10.15).
   */
  RANK4_IMAGE_MAPPING = 1;
}

/*
 A neural network.
 */
message NeuralNetwork {
  repeated NeuralNetworkLayer layers = 1;
  repeated NeuralNetworkPreprocessing preprocessing = 2;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for multiarray inputs
  NeuralNetworkMultiArrayShapeMapping arrayInputShapeMapping = 5;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for image inputs
  NeuralNetworkImageShapeMapping imageInputShapeMapping = 6;

  NetworkUpdateParameters updateParams = 10;
}

// Preprocessing
// -------------

/*
 * A neural network preprocessor that
 * performs a scalar multiplication of an image
 * followed by addition of scalar biases to the channels.
 *
 * Input: X
 *    An image in BGR or RGB format with shape ``[3, H, W]``
 *    or in grayscale format with shape ``[1, H, W]``.
 * Output: Y
 *    An image with format and shape corresponding to the input.
 *
 * If the input image is in BGR format:
 *
 * .. code::
 *
 *     Y[0, :, :] = channelScale * X[0, :, :] + blueBias
 *     Y[1, :, :] = channelScale * X[1, :, :] + greenBias
 *     Y[2, :, :] = channelScale * X[2, :, :] + redBias
 *
 * If the input image is in RGB format:
 *
 * .. code::
 *
 *     Y[0, :, :] = channelScale * X[0, :, :] + redBias
 *     Y[1, :, :] = channelScale * X[1, :, :] + greenBias
 *     Y[2, :, :] = channelScale * X[2, :, :] + blueBias
 *
 * If the input image is in grayscale format:
 *
 * .. code::
 *
 *     Y[0, :, :] = channelScale * X[0, :, :] + grayBias
 */
message NeuralNetworkImageScaler {
  float channelScale = 10;  // Scalar to be multiplied.
  float blueBias = 20;      // Scalar blue bias to be added.
  float greenBias = 21;     // Scalar green bias to be added.
  float redBias = 22;       // Scalar red bias to be added.
  float grayBias = 30;      // Scalar bias to be added for grayscale images.
}

/*
 * A neural network preprocessor that
 * subtracts the provided mean image from the input image.
 * The mean image is subtracted from the input named
 * ``NeuralNetworkPreprocessing.featureName``.
 */
message NeuralNetworkMeanImage {
  /*
   * Mean image stored as a flattened array of floats,
   * representing shape [Channel,Height,Width].
   */
  repeated float meanImage = 1;
}

// Preprocessing parameters for image inputs.
message NeuralNetworkPreprocessing {
  string featureName = 1;  // must be equal to the input name to which the
                           // preprocessing is applied
  oneof preprocessor {
    NeuralNetworkImageScaler scaler = 10;
    NeuralNetworkMeanImage meanImage = 11;
  }
}

// Activation Functions
// --------------------

/*
 * A rectified linear unit (ReLU) activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \text{max}(0, x)
 */
message ActivationReLU {}

/*
 * A leaky rectified linear unit (ReLU) activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \begin{cases}
 *             x      & \text{if } x \geq 0 \\
 *             \alpha x & \text{if } x < 0
 *            \end{cases}
 */
message ActivationLeakyReLU {
  float alpha = 1;  // negative slope value for leakyReLU
}

/*
 * A hyperbolic tangent activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \dfrac{1 - e^{-2x}}{1 + e^{-2x}}
 */
message ActivationTanh {}

/*
 * A scaled hyperbolic tangent activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \alpha \tanh(\beta x)
 */
message ActivationScaledTanh {
  float alpha = 1;
  float beta = 2;
}

/*
 * A sigmoid activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \dfrac{1}{1 + e^{-x}}
 */
message ActivationSigmoid {}

/*
 * A linear activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \alpha x + \beta
 */
message ActivationLinear {
  float alpha = 1;
  float beta = 2;
}

/*
 * A hard sigmoid activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \text{min}(\text{max}(\alpha x + \beta, 0), 1)
 */
message ActivationSigmoidHard {
  float alpha = 1;
  float beta = 2;
}

/*
 * A parameterized rectified linear unit (PReLU) activation function.
 * Input must be at least rank 3. Axis = -3 is denoted by "C", or channels.
 * "alpha" parameter can be a vector of length C.
 *
 * This function has the following formula:
 *
 * .. math::
 *    f(x_i) = \begin{cases}
 *                 x_i          & \text{if } x_i \geq 0 \\
 *                 \alpha_i x_i & \text{if } x_i < 0
 *             \end{cases} \;,\;i=1,...,C
 */
message ActivationPReLU {
  // parameter of length C or 1.
  // If length is 1, same value is used for all channels
  WeightParams alpha = 1;
}

/*
 * An exponential linear unit (ELU) activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \begin{cases}
 *             x              & \text{if } x \geq 0 \\
 *             \alpha (e^x - 1) & \text{if } x < 0
 *            \end{cases}
 */
message ActivationELU {
  float alpha = 1;
}

/*
 * A thresholded rectified linear unit (ReLU) activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \begin{cases}
 *             x & \text{if } x \geq \alpha \\
 *             0 & \text{if } x < \alpha
 *            \end{cases}
 */
message ActivationThresholdedReLU {
  float alpha = 1;
}

/*
 * A softsign activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \dfrac{x}{1 + |x|}
 */
message ActivationSoftsign {}

/*
 * A softplus activation function.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \text{log}(1 + e^x)
 */
message ActivationSoftplus {}

/*
 * A parametric softplus activation function.
 * Input must be at least rank 3. axis = -3 is denoted by "C", or channels.
 * "alpha"/"beta" parameter can be a vector of length C.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x_i) = \alpha_i \text{log}(1 + e^{\beta_i x_i}) \;,\;i=1,...,C
 */
message ActivationParametricSoftplus {
  // If length is 1, same value is used for all channels
  WeightParams alpha = 1;  // parameter of length C or 1
  WeightParams beta = 2;   // parameter of length C or 1
}

message ActivationParams {
  oneof NonlinearityType {
    ActivationLinear linear = 5;

    ActivationReLU ReLU = 10;
    ActivationLeakyReLU leakyReLU = 15;
    ActivationThresholdedReLU thresholdedReLU = 20;
    ActivationPReLU PReLU = 25;

    ActivationTanh tanh = 30;
    ActivationScaledTanh scaledTanh = 31;

    ActivationSigmoid sigmoid = 40;
    ActivationSigmoidHard sigmoidHard = 41;

    ActivationELU ELU = 50;

    ActivationSoftsign softsign = 60;
    ActivationSoftplus softplus = 70;
    ActivationParametricSoftplus parametricSoftplus = 71;
  }
}

/*
 * Representation of the intermediate tensors
 */
message Tensor {
  // Number of dimensions in the tensor shape
  uint32 rank = 1;
  // actual value of the tensor shape.
  // must be of length "rank". Can contain -1s for unknown dimensions.
  repeated int64 dimValue = 2;
}

/*
 * A single neural network layer.
 */
message NeuralNetworkLayer {
  string name = 1;  // descriptive name of the layer
  repeated string input = 2;
  repeated string output = 3;

  repeated Tensor inputTensor =
      4;  // must be the same length as the "input" field
  repeated Tensor outputTensor =
      5;  // must be the same length as the "output" field

  // Must be set to true to mark the layer as updatable.
  // If true, the weightParams in the layer's properties must also be set to
  // updatable If false, the value of the isUpdatable parameter within the
  // layer's weights are ignored
  bool isUpdatable = 10;

  oneof layer {
    // Start at 100 here
    ConvolutionLayerParams convolution = 100;

    PoolingLayerParams pooling = 120;

    ActivationParams activation = 130;

    InnerProductLayerParams innerProduct = 140;
    EmbeddingLayerParams embedding = 150;

    // Normalization-related Layers
    BatchnormLayerParams batchnorm = 160;
    MeanVarianceNormalizeLayerParams mvn = 165;
    L2NormalizeLayerParams l2normalize = 170;
    SoftmaxLayerParams softmax = 175;
    LRNLayerParams lrn = 180;

    CropLayerParams crop = 190;
    PaddingLayerParams padding = 200;
    UpsampleLayerParams upsample = 210;

    ResizeBilinearLayerParams resizeBilinear = 211;
    CropResizeLayerParams cropResize = 212;

    UnaryFunctionLayerParams unary = 220;

    // Element-wise Operations
    AddLayerParams add = 230;
    MultiplyLayerParams multiply = 231;

    AverageLayerParams average = 240;
    ScaleLayerParams scale = 245;

    BiasLayerParams bias = 250;
    MaxLayerParams max = 260;
    MinLayerParams min = 261;

    DotProductLayerParams dot = 270;
    ReduceLayerParams reduce = 280;
    LoadConstantLayerParams loadConstant = 290;

    // Data Reorganization
    ReshapeLayerParams reshape = 300;
    FlattenLayerParams flatten = 301;
    PermuteLayerParams permute = 310;
    ConcatLayerParams concat = 320;
    SplitLayerParams split = 330;
    SequenceRepeatLayerParams sequenceRepeat = 340;

    ReorganizeDataLayerParams reorganizeData = 345;
    SliceLayerParams slice = 350;

    // Recurrent Layers
    SimpleRecurrentLayerParams simpleRecurrent = 400;
    GRULayerParams gru = 410;
    UniDirectionalLSTMLayerParams uniDirectionalLSTM = 420;
    BiDirectionalLSTMLayerParams biDirectionalLSTM = 430;

    // Custom (user-implemented) Layer
    CustomLayerParams custom = 500;

    // Following layers are available only after Core ML Specification
    // version >= 4 (iOS >= 13, macOS >= 10.15)

    // Control Flow related Layers
    CopyLayerParams copy = 600;
    BranchLayerParams branch = 605;

    LoopLayerParams loop = 615;
    LoopBreakLayerParams loopBreak = 620;
    LoopContinueLayerParams loopContinue = 625;

    RangeStaticLayerParams rangeStatic = 635;
    RangeDynamicLayerParams rangeDynamic = 640;

    // Element-wise Unary Layers
    ClipLayerParams clip = 660;
    CeilLayerParams ceil = 665;
    FloorLayerParams floor = 670;

    SignLayerParams sign = 680;
    RoundLayerParams round = 685;

    Exp2LayerParams exp2 = 700;

    SinLayerParams sin = 710;
    CosLayerParams cos = 715;
    TanLayerParams tan = 720;

    AsinLayerParams asin = 730;
    AcosLayerParams acos = 735;
    AtanLayerParams atan = 740;

    SinhLayerParams sinh = 750;
    CoshLayerParams cosh = 755;
    TanhLayerParams tanh = 760;

    AsinhLayerParams asinh = 770;
    AcoshLayerParams acosh = 775;
    AtanhLayerParams atanh = 780;

    ErfLayerParams erf = 790;
    GeluLayerParams gelu = 795;

    // Element-wise Binary with Broadcasting Support
    EqualLayerParams equal = 815;
    NotEqualLayerParams notEqual = 820;
    LessThanLayerParams lessThan = 825;
    LessEqualLayerParams lessEqual = 827;
    GreaterThanLayerParams greaterThan = 830;
    GreaterEqualLayerParams greaterEqual = 832;

    LogicalOrLayerParams logicalOr = 840;
    LogicalXorLayerParams logicalXor = 845;
    LogicalNotLayerParams logicalNot = 850;
    LogicalAndLayerParams logicalAnd = 855;

    ModBroadcastableLayerParams modBroadcastable = 865;
    MinBroadcastableLayerParams minBroadcastable = 870;
    MaxBroadcastableLayerParams maxBroadcastable = 875;
    AddBroadcastableLayerParams addBroadcastable = 880;
    PowBroadcastableLayerParams powBroadcastable = 885;
    DivideBroadcastableLayerParams divideBroadcastable = 890;
    FloorDivBroadcastableLayerParams floorDivBroadcastable = 895;
    MultiplyBroadcastableLayerParams multiplyBroadcastable = 900;
    SubtractBroadcastableLayerParams subtractBroadcastable = 905;

    // Tensor Manipulations
    TileLayerParams tile = 920;
    StackLayerParams stack = 925;
    GatherLayerParams gather = 930;
    ScatterLayerParams scatter = 935;
    GatherNDLayerParams gatherND = 940;
    ScatterNDLayerParams scatterND = 945;
    SoftmaxNDLayerParams softmaxND = 950;
    GatherAlongAxisLayerParams gatherAlongAxis = 952;
    ScatterAlongAxisLayerParams scatterAlongAxis = 954;

    ReverseLayerParams reverse = 960;
    ReverseSeqLayerParams reverseSeq = 965;

    SplitNDLayerParams splitND = 975;
    ConcatNDLayerParams concatND = 980;
    TransposeLayerParams transpose = 985;

    SliceStaticLayerParams sliceStatic = 995;
    SliceDynamicLayerParams sliceDynamic = 1000;
    SlidingWindowsLayerParams slidingWindows = 1005;

    TopKLayerParams topK = 1015;
    ArgMinLayerParams argMin = 1020;
    ArgMaxLayerParams argMax = 1025;

    EmbeddingNDLayerParams embeddingND = 1040;
    BatchedMatMulLayerParams batchedMatmul = 1045;

    // Tensor Allocation / Reshape-related Operations
    GetShapeLayerParams getShape = 1065;
    LoadConstantNDLayerParams loadConstantND = 1070;

    FillLikeLayerParams fillLike = 1080;
    FillStaticLayerParams fillStatic = 1085;
    FillDynamicLayerParams fillDynamic = 1090;

    BroadcastToLikeLayerParams broadcastToLike = 1100;
    BroadcastToStaticLayerParams broadcastToStatic = 1105;
    BroadcastToDynamicLayerParams broadcastToDynamic = 1110;

    SqueezeLayerParams squeeze = 1120;
    ExpandDimsLayerParams expandDims = 1125;
    FlattenTo2DLayerParams flattenTo2D = 1130;
    ReshapeLikeLayerParams reshapeLike = 1135;
    ReshapeStaticLayerParams reshapeStatic = 1140;
    ReshapeDynamicLayerParams reshapeDynamic = 1145;
    RankPreservingReshapeLayerParams rankPreservingReshape = 1150;

    ConstantPaddingLayerParams constantPad = 1155;

    // Random Distributions
    RandomNormalLikeLayerParams randomNormalLike = 1170;
    RandomNormalStaticLayerParams randomNormalStatic = 1175;
    RandomNormalDynamicLayerParams randomNormalDynamic = 1180;

    RandomUniformLikeLayerParams randomUniformLike = 1190;
    RandomUniformStaticLayerParams randomUniformStatic = 1195;
    RandomUniformDynamicLayerParams randomUniformDynamic = 1200;

    RandomBernoulliLikeLayerParams randomBernoulliLike = 1210;
    RandomBernoulliStaticLayerParams randomBernoulliStatic = 1215;
    RandomBernoulliDynamicLayerParams randomBernoulliDynamic = 1220;

    CategoricalDistributionLayerParams categoricalDistribution = 1230;

    // Reduction-related Layers:
    ReduceL1LayerParams reduceL1 = 1250;
    ReduceL2LayerParams reduceL2 = 1255;
    ReduceMaxLayerParams reduceMax = 1260;
    ReduceMinLayerParams reduceMin = 1265;
    ReduceSumLayerParams reduceSum = 1270;
    ReduceProdLayerParams reduceProd = 1275;
    ReduceMeanLayerParams reduceMean = 1280;
    ReduceLogSumLayerParams reduceLogSum = 1285;
    ReduceSumSquareLayerParams reduceSumSquare = 1290;
    ReduceLogSumExpLayerParams reduceLogSumExp = 1295;

    // Masking / Selection Layers
    WhereNonZeroLayerParams whereNonZero = 1313;
    MatrixBandPartLayerParams matrixBandPart = 1315;
    LowerTriangularLayerParams lowerTriangular = 1320;
    UpperTriangularLayerParams upperTriangular = 1325;
    WhereBroadcastableLayerParams whereBroadcastable = 1330;

    // Normalization Layers
    LayerNormalizationLayerParams layerNormalization = 1350;

    NonMaximumSuppressionLayerParams NonMaximumSuppression = 1400;

    // Following layers are available only after Core ML Specification
    // version >= 5 (iOS >= 14, macOS >= 11.0)
    OneHotLayerParams oneHot = 1450;
    CumSumLayerParams cumSum = 1455;
    ClampedReLULayerParams clampedReLU = 1460;
    ArgSortLayerParams argSort = 1461;
    Pooling3DLayerParams pooling3d = 1465;
    GlobalPooling3DLayerParams globalPooling3d = 1466;
    SliceBySizeLayerParams sliceBySize = 1470;
    Convolution3DLayerParams convolution3d = 1471;
  }
}

/*
 * Branching Layer
 *
 * A layer that provides the functionality of branching or an If-Else block.
 *
 * Must have 1 input. There are no outputs as the execution is transferred to
 * either the if or the else branch based on the value of the input.
 *
 * Input is the condition predicate. Must be a scalar (length 1 tensor).
 *
 */
message BranchLayerParams {
  /*
   * execute this graph if the absolute value of the input Tensor is greater
   * than 1e-6 This must be present.
   */
  NeuralNetwork ifBranch = 1;
  /*
   * execute this graph if the absolute value of the input Tensor is less than
   * 1e-6 This is optional.
   */
  NeuralNetwork elseBranch = 2;
}

/*
 * Loop Layer
 *
 * A layer that provides the functionality of a "for" loop or a "while" loop.
 *
 * There are either no inputs or 1 input. When an input is present, it
 * corresponds to the maximum loop count, in that case the value of the
 * "maxLoopIterations" field is ignored. Input must be a scalar. (For
 * description below, maxLoopIterations is assumed to be the value of the input,
 * when its present)
 *
 * No outputs are produced. Blobs produced by the condition or the body network
 * are visible in the scope of the overall network.
 *
 * "conditionNetwork" must produce a tensor with the name specified in the
 * "conditionVar" field.
 *
 * There are 3 possible cases for determining the termination condition:
 *
 * Case 1:
 *
 * If there is no "conditionNetwork", in this case the layer corresponds to a
 * pure for loop, which is run "maxLoopIterations" number of times. Equivalent
 * pseudo-code:
 *
 * for loopIterator = 0 : maxLoopIterations
 *      bodyNetwork()
 *
 *
 * Case 2:
 *
 * "conditionNetwork" is present, and "maxLoopIterations" is 0 and there is no
 * input, in this case the layer corresponds to a while loop. Equivalent
 * pseudo-code:
 *
 * conditionVar = conditionNetwork()
 * while conditionVar:
 *      bodyNetwork()
 *      conditionVar = conditionNetwork()
 *
 *
 * Case 3:
 *
 * "conditionNetwork" is provided, and "maxLoopIterations" is positive or there
 * is an input, in this case the layer corresponds to a while loop with a joint
 * condition. Equivalent pseudo-code:
 *
 * loopIterator = 0
 * conditionVar = conditionNetwork()
 * while (conditionVar and loopIterator < maxLoopIterations):
 *      bodyNetwork()
 *      loopIterator = loopIterator + 1
 *      conditionVar = conditionNetwork()
 *
 */
message LoopLayerParams {
  /*
   * maximum number of iterations. Ignored if input is present.
   */
  uint64 maxLoopIterations = 1;
  /*
   * This field provides the name of the tensor which is produced by the
   * conditionNetwork and whose value is checked to start/continue/terminate the
   * loop. Value close to 0.0f is treated as False. This field is optional. Must
   * be a non empty string if and only if "conditionNetwork" is present.
   */
  string conditionVar = 2;
  /*
   * Must generate a tensor with the name provided in the "conditionVar" field.
   * This field is optional.
   * Must be present if and only if "conditionVar" field is a non empty string.
   */
  NeuralNetwork conditionNetwork = 3;
  /*
   * Body of the loop.
   * This field must be present.
   */
  NeuralNetwork bodyNetwork = 4;
}

/*
 * Loop break Layer
 *
 * Terminate the loop that has this layer.
 * If present, it should always reside in the "bodyNetwork" of the loop layer
 *
 * No inputs/outputs
 *
 */
message LoopBreakLayerParams {}

/*
 * Loop Continue Layer
 *
 * Stop the current loop iteration and continue on the next iteration.
 * If present, it should always reside in the "bodyNetwork" of the loop layer
 *
 * No inputs/outputs
 *
 */
message LoopContinueLayerParams {}

/*
 * Copy Layer
 *
 * A layer that copies its input tensor to the output tensor.
 * Must have 1 input and 1 output, with distinct names.
 * This is the only layer that is allowed to re-generate an output that is
 * already present in the neural network prior to this layer, in which case it
 * will overwrite the output tensor.
 *
 */
message CopyLayerParams {}

/*
 * GreaterThan Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise greater than operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 > x2
 *          or
 *      y = x1 > alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message GreaterThanLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 2;
}

/*
 * GreaterEqual Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise greater equal operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 >= x2
 *          or
 *      y = x1 >= alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message GreaterEqualLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 2;
}

/*
 * LessThan Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise less than operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 < x2
 *          or
 *      y = x1 < alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message LessThanLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 2;
}

/*
 * LessEqual Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise less equal operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 <= x2
 *          or
 *      y = x1 <= alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message LessEqualLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 2;
}

/*
 * Equal Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise equal operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 == x2
 *          or
 *      y = x1 == alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message EqualLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 1;
}

/*
 * NotEqual Layer
 *
 * Either 1 or 2 inputs.
 * Produces 1 output.
 * Perform elementwise not equal operation.
 *
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = x1 != x2
 *          or
 *      y = x1 != alpha, if only one input is provided
 *
 * Broadcasting is supported.
 *
 */
message NotEqualLayerParams {
  /*
   * Compare to the scalar value provided here if there is 1 input
   */
  float alpha = 1;
}

/*
 * LogicalAnd Layer
 *
 * Must have 2 inputs, produces 1 output.
 * Perform elementwise logical AND operation.
 *
 * Input is considered False if equal to 0.0f otherwise True.
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = AND(x1, x2)
 *
 * Broadcasting is supported.
 *
 */
message LogicalAndLayerParams {}

/*
 * LogicalOr Layer
 *
 * Must have 2 inputs, produces 1 output.
 * Perform elementwise logical OR operation.
 *
 * Input is considered False if equal to 0.0f otherwise True.
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = OR(x1, x2)
 *
 * Broadcasting is supported.
 *
 */
message LogicalOrLayerParams {}

/*
 * LogicalXor Layer
 *
 * Must have 2 inputs, produces 1 output.
 * Perform elementwise logical XOR operation.
 *
 * Input is considered False if equal to 0.0f otherwise True.
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = XOR(x1, x2)
 *
 * Broadcasting is supported.
 *
 */
message LogicalXorLayerParams {}

/*
 * LogicalNot Layer
 *
 * Must have 1 input, produces 1 output.
 * Perform elementwise logical NOT operation.
 *
 * Input is considered False if equal to 0.0f otherwise True.
 * Output is 1.0f if the condition is true otherwise 0.0f.
 *
 * .. code::
 *
 *      y = NOT(x)
 *
 *
 */
message LogicalNotLayerParams {}

// Border Amounts
// --------------

/*
 * Specifies the amount of spatial border to be either padded or cropped.
 *
 * For padding:
 *
 * .. code::
 *
 *     H_out = borderAmounts[0].startEdgeSize + H_in +
 * borderAmounts[0].endEdgeSize W_out = borderAmounts[1].startEdgeSize + W_in +
 * borderAmounts[1].endEdgeSize
 *
 *     topPaddingAmount == Height startEdgeSize
 *     bottomPaddingAmount == Height endEdgeSize
 *     leftPaddingAmount == Width startEdgeSize
 *     rightPaddingAmount == Width endEdgeSize
 *
 * For cropping:
 *
 * .. code::
 *
 *     H_out = (-borderAmounts[0].startEdgeSize) + H_in +
 * (-borderAmounts[0].endEdgeSize) W_out = (-borderAmounts[1].startEdgeSize) +
 * W_in + (-borderAmounts[1].endEdgeSize)
 *
 *     topCropAmount == Height startEdgeSize
 *     bottomCropAmount == Height endEdgeSize
 *     leftCropAmount == Width startEdgeSize
 *     rightCropAmount == Width endEdgeSize
 */
message BorderAmounts {
  message EdgeSizes {
    /*
     * The amount to be padded or cropped from the beginning.
     */
    uint64 startEdgeSize = 1;

    /*
     * The amount to be padded or cropped from the end.
     */
    uint64 endEdgeSize = 2;
  }

  /*
   * The border amounts.
   * This must be length 2 in the order ``[H, W]``.
   */
  repeated EdgeSizes borderAmounts = 10;
}

/*
 * Specifies the type of padding to be used with Convolution/Deconvolution and
 * Pooling layers. After padding, input spatial shape: ``[H_in, W_in]``, gets
 * modified to the output spatial shape ``[H_out, W_out]``.
 *
 * .. code::
 *
 *      topPaddingAmount == Height startEdgeSize ==
 * borderAmounts[0].startEdgeSize bottomPaddingAmount == Height endEdgeSize ==
 * borderAmounts[0].endEdgeSize leftPaddingAmount == Width startEdgeSize ==
 * borderAmounts[1].startEdgeSize rightPaddingAmount == Width endEdgeSize ==
 * borderAmounts[1].endEdgeSize
 *
 * With Convolution or Pooling:
 *
 * .. code::
 *
 *    H_out = int_division_round_down((H_in + topPaddingAmount +
 * bottomPaddingAmount - KernelSize[0]),stride[0]) + 1
 *
 * which is same as:
 *
 * .. code::
 *
 *    H_out = int_division_round_up((H_in + topPaddingAmount +
 * bottomPaddingAmount - KernelSize[0] + 1),stride[0])
 *
 * With Deconvolution:
 *
 * .. code::
 *
 *    H_out = (H_in-1) * stride[0] + kernelSize[0] - (topPaddingAmount +
 * bottomPaddingAmount)
 *
 *
 * The equivalent expressions hold true for ``W_out`` as well.
 *
 *
 * By default, the values of ``paddingAmounts`` are set to ``0``,
 * which results in a "true" valid padding.
 * If non-zero values are provided for ``paddingAmounts``,
 * "valid" convolution/pooling is performed within the spatially expanded input.
 *
 */
message ValidPadding {
  BorderAmounts paddingAmounts = 1;
}

/*
 * Specifies the type of padding to be used with Convolution/Deconvolution and
 * pooling layers. After padding, input spatial shape: ``[H_in, W_in]``, gets
 * modified to the output spatial shape ``[H_out, W_out]``. With Convolution or
 * pooling:
 *
 * .. code::
 *
 *      H_out = int_division_round_up(H_in,stride[0])
 *      W_out = int_division_round_up(W_in,stride[1])
 *
 * This is achieved by using the following padding amounts:
 *
 * .. code::
 *
 *     totalPaddingHeight = max(0,(H_out-1) * stride[0] + KernelSize[0] - Hin)
 *     totalPaddingWidth = max(0,(W_out-1) * stride[1] + KernelSize[1] - Win)
 *
 * There are two modes of asymmetry:
 * ``BOTTOM_RIGHT_HEAVY``, and ``TOP_LEFT_HEAVY``.
 *
 * If the mode is ``BOTTOM_RIGHT_HEAVY``:
 *
 * .. code::
 *
 *     topPaddingAmount = floor(totalPaddingHeight / 2)
 *     bottomPaddingAmount = totalPaddingHeight - topPaddingAmount
 *     leftPaddingAmount = floor(totalPaddingWidth / 2)
 *     rightPaddingAmount = totalPaddingWidth - leftPaddingAmount
 *
 * If the mode is ``TOP_LEFT_HEAVY``:
 *
 * .. code::
 *
 *     bottomPaddingAmount = floor(totalPaddingHeight / 2)
 *     topPaddingAmount = totalPaddingHeight - bottomPaddingAmount
 *     rightPaddingAmount = floor(totalPaddingWidth / 2)
 *     leftPaddingAmount = totalPaddingWidth - rightPaddingAmount
 *
 *
 * With Deconvolution:
 *
 * .. code::
 *
 *    H_out = H_in * stride[0]
 *    W_out = W_in * stride[1]
 */
message SamePadding {
  enum SamePaddingMode {
    BOTTOM_RIGHT_HEAVY = 0;
    TOP_LEFT_HEAVY = 1;
  }
  SamePaddingMode asymmetryMode = 1;
}

/*
 * Specifies how grid points are sampled from an interval.
 * Without the loss of generality, assume the interval to be [0, X-1] from which
 * N points are to be sampled. Here X may correspond to an input image's height
 * or width. All the methods can be expressed in terms of numpy's linspace
 * function, along with the constraint that grid points have to lie in the
 * interval [0, X-1]. Note: numpy.linspace(start = start, end = end, num = N,
 * endpoint = True) corresponds to sampling N points uniformly from the interval
 * [start, end], endpoints included. The methods vary in how the ``start`` and
 * ``end`` values are computed.
 */
message SamplingMode {
  enum Method {
    /*
     * start = 0, end = X-1
     * grid points = numpy.linspace(start, end)
     */
    STRICT_ALIGN_ENDPOINTS_MODE = 0;

    /*
     * if N == 1: start = end = (X-1)/2
     * otherwise, start = 0, end = X-1
     * grid points = numpy.linspace(start, end)
     */
    ALIGN_ENDPOINTS_MODE = 1;

    /*
     * start = 0, end = X - X/N
     * grid points = min(X-1, numpy.linspace(start, end))
     * This is same as the mode used in the upsample layer in this
     * specification, when used with bilinear interpolation. In that case N/X =
     * upsample ratio.
     */
    UPSAMPLE_MODE = 2;

    /*
     * spacing = max(1, X-1)/N
     * start = 0.5 * spacing
     * end = start + (N-1) * spacing
     * grid points = min(X-1, numpy.linspace(start, end))
     */
    ROI_ALIGN_MODE = 3;
  }

  Method samplingMethod = 1;
}

/*
 * Specifies the convention used to specify four bounding box coordinates for an
 * image of size (Height, Width). The (0,0) coordinate corresponds to the
 * top-left corner of the image.
 */
message BoxCoordinatesMode {
  enum Coordinates {
    /*
     * [h_start, w_start, h_end, w_end]
     */
    CORNERS_HEIGHT_FIRST = 0;

    /*
     * [w_start, h_start, w_end, h_end]
     */
    CORNERS_WIDTH_FIRST = 1;

    /*
     * [h_center, w_center, box_height, box_width]
     */
    CENTER_SIZE_HEIGHT_FIRST = 2;

    /*
     * [w_center, h_center, box_width, box_height]
     */
    CENTER_SIZE_WIDTH_FIRST = 3;
  }

  Coordinates boxMode = 1;
}

/*
 * Weights for layer parameters.
 * Weights are stored as repeated floating point numbers
 * using row-major ordering
 * and can represent 1-, 2-, 3-, or 4-dimensional data.
 */
message WeightParams {
  /*
   * Values specified in single / float / FP32 precision.
   */
  repeated float floatValue = 1;

  /*
   * Values in 16-bit half precision floating point.
   */
  bytes float16Value = 2;

  /*
   * Raw value specification for quantized lower precisions.
   *
   * This field is interpreted as uintN, where N is the number of bits in
   * quantization. E.g. if n=8, the field is interpreted as an array of UINT8.
   * Use this field for quantized parameters unless specifically noted to use
   * int8RawValue.
   */
  bytes rawValue = 30;

  /*
   * Field to be used if int8DynamicQuantize is set in the parent layer.
   * Cannot be set if rawValue is also set.
   * The values in this field are interpreted as INT8.
   *
   * If this field is set, following conditions must hold true:
   * * QuantizationType == LinearQuantizationParams, such that
   *   * size of the "scale" field is 1 and "bias" field is empty in
   * "LinearQuantizationParams"
   */
  bytes int8RawValue = 31;

  /*
   * Quantization related parameters.
   */
  QuantizationParams quantization = 40;

  bool isUpdatable = 50;
}

/*
 * Quantization parameters.
 */
message QuantizationParams {
  uint64 numberOfBits = 1;
  oneof QuantizationType {
    LinearQuantizationParams linearQuantization = 101;
    LookUpTableQuantizationParams lookupTableQuantization = 102;
  }
}

message LinearQuantizationParams {
  /*
   * Stores scale and bias values corresponding to the quantized weights.
   * Must be an array of 1 element, or an array of C elements, where C
   * is number of output channels. For recurrent layers it is equal to
   * the output vector size.
   *
   * Relationship between quantized weights, unquantized weights, scale and
   * bias:
   *
   * W_unquantized = W_quantized * scale + bias
   *
   */
  repeated float scale = 1;
  repeated float bias = 2;
}

message LookUpTableQuantizationParams {
  /* Stores look-up table quantization values. Must be an array of
  (2^numberOfBits) Elements.
  */
  repeated float floatValue = 1;
}

// Layers
// ------

/*
 * A layer that performs spatial convolution or deconvolution.
 *
 * .. code::
 *
 *      y = ConvolutionLayer(x)
 *
 * Requires 1 or 2 inputs and produces 1 output.
 *
 * Input
 *    First Input:
 *      A blob with rank greater than or equal to 4.
 *      Rank 4 blob represents [Batch, channels, height, width].
 *      For ranks greater than 4, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 *     From Core ML specification version 4 onwards (iOS >= 13, macOS >= 10.15).
 *     convolution layer can have 2 inputs, in which case the second input is
 *     the blob representing the weights. This is allowed when "isDeconvolution"
 * = False. The weight blob should have shape
 *     ``[outputChannels, kernelChannels, kernelHeight, kernelWidth]``,
 *     where kernelChannels == inputChannels / nGroups.
 *
 * Output
 *   Rank is same as the input. e.g.: for rank 4 input, output shape is [B,
 * C_out, H_out, W_out]
 *
 *
 * If ``dilationFactor`` is not 1, effective kernel size is
 * modified as follows:
 *
 * .. code::
 *
 *      KernelSize[0] <-- (kernelSize[0]-1) * dilationFactor[0] + 1
 *      KernelSize[1] <-- (kernelSize[1]-1) * dilationFactor[1] + 1
 *
 * Type of padding can be ``valid`` or ``same``. Output spatial dimensions
 * depend on the the type of padding. For details, refer to the descriptions of
 * the messages "ValidPadding" and "SamePadding". Padded values are all zeros.
 *
 * For Deconvolution, ``ConvolutionPaddingType`` (``valid`` or ``same``) is
 * ignored when ``outputShape`` is set.
 *
 *
 */
message ConvolutionLayerParams {
  /*
   * The number of kernels.
   * Same as ``C_out`` used in the layer description.
   */
  uint64 outputChannels = 1;

  /*
   * Channel dimension of the kernels.
   * Must be equal to ``inputChannels / nGroups``, if isDeconvolution == False
   * Must be equal to ``inputChannels``, if isDeconvolution == True
   */
  uint64 kernelChannels = 2;

  /*
   * Group convolution, i.e. weight reuse along channel axis.
   * Input and kernels are divided into g groups
   * and convolution / deconvolution is applied within the groups independently.
   * If not set or 0, it is set to the default value 1.
   */
  uint64 nGroups = 10;

  /*
   * Must be length 2 in the order ``[H, W]``.
   * If not set, default value ``[3, 3]`` is used.
   */
  repeated uint64 kernelSize = 20;

  /*
   * Must be length 2 in the order ``[H, W]``.
   * If not set, default value ``[1, 1]`` is used.
   */
  repeated uint64 stride = 30;

  /*
   * Must be length 2 in order ``[H, W]``.
   * If not set, default value ``[1, 1]`` is used.
   * It is ignored if ``isDeconvolution == true``.
   */
  repeated uint64 dilationFactor = 40;

  /*
   * The type of padding.
   */
  oneof ConvolutionPaddingType {
    ValidPadding valid = 50;
    SamePadding same = 51;
  }

  /*
   * Flag to specify whether it is a deconvolution layer.
   */
  bool isDeconvolution = 60;

  /*
   * Flag to specify whether a bias is to be added or not.
   */
  bool hasBias = 70;

  /*
   * Weights associated with this layer.
   * If convolution (``isDeconvolution == false``), weights have the shape
   * ``[outputChannels, kernelChannels, kernelHeight, kernelWidth]``, where
   * kernelChannels == inputChannels / nGroups If deconvolution
   * (``isDeconvolution == true``) weights have the shape
   * ``[kernelChannels, outputChannels / nGroups, kernelHeight, kernelWidth]``,
   * where kernelChannels == inputChannels
   */
  WeightParams weights = 90;
  WeightParams bias = 91;  // Must be of size [outputChannels].

  /*
   * The output shape, which has length 2 ``[H_out, W_out]``.
   * This is used only for deconvolution (``isDeconvolution == true``).
   * If not set, the deconvolution output shape is calculated
   * based on ``ConvolutionPaddingType``.
   */
  repeated uint64 outputShape = 100;
}

/*
 * A layer that performs a 3-dimensional convolution.
 *
 * .. code::
 *
 *      y = Convolution3DLayer(x)
 *
 * Input
 *    A blob of rank 5.
 *    The input blob's shape should be ``[batch, channels, depth, height,
 * width]``.
 *
 * Fields
 *   The bias field, if set, should have shape of ``[channelsOut]``.
 *
 * Output
 *   A blob of rank 5.
 *   The output blob's shape is ``[batch, channelsOut, depthOut, heightOut,
 * widthOut]``.
 *
 * Type of padding can be ``custom``, ``valid``, or ``same``. Padded values are
 * all zeros. Output spatial dimensions depend on the the type of padding. For
 * details, refer to the descriptions of the ``PaddingType`` field of this
 * ``Convolution3DLayerParams`` message.
 *
 * Example
 *   For example, given an input of size ``[1, 3, 3, 8, 8]``, a stride of 2 in
 * each dimension, a kernel of 3 in each dimension, 2 output channels, and
 * ``same`` padding, this layer will compute the total padding applied in the
 * depth, height, and width dimensions to be 2, 1, and 1, respectively. The
 * depth padding is even and will be applied equally to both sides of the depth
 *   dimension. Since the height and width padding values are odd, they'll be
 * applied to the bottom/right of the height/width dimensions. Thus, the padding
 * applied to the input will be
 *   ``[1, 1, 0, 1, 0, 1]`` (front, back, top, bottom, left, right). Finally,
 * the output produced will have size ``[1, 2, 2, 4, 4]``.
 *
 */
message Convolution3DLayerParams {
  /*
   * The number of channels in the output (channelsOut). Must be a positive
   * integer.
   */
  int32 outputChannels = 1;

  /*
   * The number of channels in the input (channels). Must be a positive integer.
   */
  int32 inputChannels = 2;

  /*
   * Group convolution, i.e., weight reuse along the channel axis.
   * It must evenly divide both the number of input and output channels and be
   * at most the number of input channels (a depthwise convolution). Input and
   * kernels are divided into g groups and convolution is applied within the
   * groups independently.
   */
  int32 nGroups = 10;

  /* Depth of the convolution kernel. Must be a positive integer.
   */
  int32 kernelDepth = 20;

  /* Height of the convolution kernel. Must be a positive integer.
   */
  int32 kernelHeight = 21;

  /* Width of the convolution kernel. Must be a positive integer.
   */
  int32 kernelWidth = 22;

  /* Stride along the depth direction. Must be a positive integer.
   */
  int32 strideDepth = 31;

  /* Stride along the height direction. Must be a positive integer.
   */
  int32 strideHeight = 32;

  /* Stride along the width direction. Must be a positive integer.
   */
  int32 strideWidth = 33;

  /* Dilation along the depth direction. Must be a positive integer.
   */
  int32 dilationDepth = 40;

  /* Dilation along the height direction. Must be a positive integer.
   */
  int32 dilationHeight = 41;

  /* Dilation along the width direction. Must be a positive integer.
   */
  int32 dilationWidth = 42;

  /*
   * Flag to specify whether a bias is to be added or not.
   * If false, then no bias is added.
   */
  bool hasBias = 50;

  /*
   * Weights associated with this layer.
   * Weights have the shape
   * if deconvolution == False
   * ``[outputChannels, kernelChannels, kernelDepth, kernelHeight,
   * kernelWidth]``, where kernelChannels == inputChannels / nGroups else if
   * deconvolution == True
   * ``[outputChannels / nGroups, kernelChannels, kernelDepth, kernelHeight,
   * kernelWidth]``, where
   */
  WeightParams weights = 60;

  /*
   * Must be of size ``[outputChannels]``.
   */
  WeightParams bias = 61;

  /*
   * The type of padding.
   * All padding types pad the input shape with zeros.
   * CUSTOM padding will add the custom padding values specified below to their
   * respective dimensions, e.g., `customPaddingFront` number of zeros will be
   * added to one side of the input's depth dimension and `customPaddingBack`
   * number of zeros will be added to the other side of the input's depth
   * dimension. VALID padding adds no padding to any dimension. In this case,
   * the last convolution along each dimension will be dropped if the input
   * dimension and the kernel size, stride, and dilation do not match. SAME
   * padding adds enough padding to each dimension such that the output of the
   * convolution has size ``Ceiling(inputShape / stride)``. Padding is added
   * evenly to both sides of each dimension unless the total padding to add is
   * odd, in which case it is added to the back/bottom/right side of the
   * respective dimension. For example, if the total padding needed in the depth
   * dimension is 3, 1 zero will be added to the front side of the depth
   * dimension and 2 zeros will be added to the back side.
   */
  enum PaddingType {
    CUSTOM = 0;
    VALID = 1;
    SAME = 2;
  }
  PaddingType paddingType = 70;

  /* Padding before the input in the depth direction. Must be zero or a positive
   * integer. Used when the `PaddingType` is `CustomPadding`, otherwise ignored
   * by other padding types.
   */
  int32 customPaddingFront = 80;

  /* Padding after the input in the depth direction. Must be zero or a positive
   * integer. Used when the `PaddingType` is `CustomPadding`, otherwise ignored
   * by other padding types.
   */
  int32 customPaddingBack = 81;

  /* Padding before the input in the height direction. Must be zero or a
   * positive integer. Used when the `PaddingType` is `CustomPadding`, otherwise
   * ignored by other padding types.
   */
  int32 customPaddingTop = 82;

  /* Padding after the input in the height direction. Must be zero or a positive
   * integer. Used when the `PaddingType` is `CustomPadding`, otherwise ignored
   * by other padding types.
   */
  int32 customPaddingBottom = 83;

  /* Padding before the input in the width direction. Must be zero or a positive
   * integer. Used when the `PaddingType` is `CustomPadding`, otherwise ignored
   * by other padding types.
   */
  int32 customPaddingLeft = 84;

  /* Padding after the input in the width direction. Must be zero or a positive
   * integer. Used when the `PaddingType` is `CustomPadding`, otherwise ignored
   * by other padding types.
   */
  int32 customPaddingRight = 85;

  /* Flag to specify if this is Convolution Transpose or not.
   */
  bool isDeconvolution = 86;

  /*
   * The output shape, which has length 3 ``[D_out, H_out, W_out]``.
   * This is used only for deconvolution (``isDeconvolution == true``).
   * If not set, the deconvolution output shape is calculated
   * based on ``PaddingType``.
   */
  repeated uint64 outputShape = 87;
}

/*
 * A layer that performs a matrix-vector or matrix-matrix product.
 * This is equivalent to a fully-connected, or dense layer.
 * The weight parameters correspond to a matrix of dimensions (inputChannels,
 * outputChannels) i.e. (C_in, C_out)
 *
 * .. code::
 *
 *      y = InnerProductLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *      Input can have rank 1 to rank 5. This is how it is reshaped in to the
 * matrix (for rank > 1): rank 1 (x1) : in this case, the layer corresponds to a
 * matrix-vector product. x1 must be equal to C_in rank 2 (x1, x2): x2 must be
 * equal to C_in rank 3 (x1, x2, x3) --> (x1 * x2, x3). x3 must be equal to C_in
 *      rank 4 (x1, x2, x3, x4) ---> (x1, x2 * x3 * x4). x2 * x3 * x4 must be
 * equal to C_in rank 5 (x1, x2, x3, x4, x5) ---> (x1 * x2, x3 * x4 * x5). x3 *
 * x4 * x5 must be equal to C_in
 *
 * Output
 *      Output rank is same as the input rank
 *      rank 1: (C_out)
 *      rank 2: (x1, C_out)
 *      rank 3: (x1, x2, C_out)
 *      rank 4: (x1, C_out, 1, 1)
 *      rank 5: (x1, x2, C_out, 1, 1)
 *
 */
message InnerProductLayerParams {
  uint64 inputChannels = 1;   // Input size: C_in.
  uint64 outputChannels = 2;  // Output size: C_out.

  bool hasBias = 10;  // Whether a bias is added or not.

  WeightParams weights = 20;  // Weight matrix [C_out, C_in].
  WeightParams bias = 21;     // Bias vector [C_out].

  /*
   * If set, this layer, at runtime, quantizes the floating point input blob to
   * int8 before applying an inner product using INT8 weight matrix parameters,
   * as provided in weights->int8RawValue. The result is then dequantized.
   * Requires:
   * * hasBias == false
   * * QuantizationType == LinearQuantizationParams, such that
   *   * size of the "scale" field is 1 and "bias" field is empty in
   * "LinearQuantizationParams"
   * * numberOfBits == 8
   * * weights->rawValue_size to be empty
   */
  bool int8DynamicQuantize = 22;
}

/*
 * A layer that performs a matrix lookup and optionally adds a bias.
 * The weights matrix is stored with dimensions [outputChannels, inputDim].
 *
 * .. code::
 *
 *      y = EmbeddingLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     Input values must be in the range ``[0, inputDim - 1]``.
 *
 *     Input must have rank equal to 4 or 5, such that the last 3 dimensions are
 * all 1. rank 4: shape (x1, 1, 1, 1). x1 is effectively the batch/sequence
 * length. rank 5: shape (x1, x2 , 1, 1, 1). x1 * x2 is effectively the combined
 * batch/sequence length.
 *
 * Output
 *      Output rank is same as the input rank. Please see input description
 * above. rank 4: shape (x1, outputChannels, 1, 1) rank 5: shape (x1, x2,
 * outputChannels, 1, 1)
 *
 */
message EmbeddingLayerParams {
  uint64 inputDim = 1;        // Size of the input dictionary.
  uint64 outputChannels = 2;  // Size of the output vectors.

  bool hasBias = 10;  // Whether a bias is added or not.

  WeightParams weights =
      20;  // 2-D weights of dimensions [outputChannels, inputDim].
  WeightParams bias = 21;  // Bias of size [outputChannels].
}

/*
 * A layer that performs a matrix lookup and optionally adds a bias.
 * The weights matrix is stored with dimensions [embeddingSize, vocabSize].
 *
 * .. code::
 *
 *      y = EmbeddingNDLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     Input values must be in the range ``[0, vocabSize - 1]``.
 *     Input must have rank at least 2. The last dimension must always be 1.
 *     rank 2: shape (x1, 1). x1 is the batch/sequence length.
 *     rank 3: shape (x1, x2, 1). x1 * x2 is effectively the combined
 * batch/sequence length. rank 4: shape (x1, x2, x3, 1). x1 * x2 * x2 is
 * effectively the combined batch/sequence length. rank 5: shape (x1, x2 , x3,
 * x4, 1). x1 * x2 * x3 * x4 is effectively the combined batch/sequence length.
 *
 * Output
 *      Output rank is same as the input rank. Please see input description
 * above. rank 2: shape (x1, embeddingSize) rank 3: shape (x1, x2,
 * embeddingSize) rank 4: shape (x1, x2, x3, embeddingSize) rank 5: shape (x1,
 * x2, x3, x4, embeddingSize)
 *
 */
message EmbeddingNDLayerParams {
  uint64 vocabSize = 1;      // Size of the input dictionary.
  uint64 embeddingSize = 2;  // Size of the output vectors.
  bool hasBias = 3;          // Whether a bias is added or not.
  WeightParams weights =
      20;  // 2-D weights of dimensions [embeddingSize, vocabSize].
  WeightParams bias = 21;  // Bias of size [embeddingSize].
}

/*
 * A layer that performs batch normalization,
 * which is performed along axis = -3,
 * and repeated along the other axes, if present.
 *
 * .. code::
 *
 *      y = BatchnormLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * This operation is described by the following formula:
 *
 * .. math::
 *     y_i = \gamma_i \dfrac{ (x_i - \mu_i)}{\sqrt{\sigma_i^2 + \epsilon}} +
 * \beta_i \;,\;i=1,....,C
 *
 * Input
 *     A blob with rank greater than equal to 3.
 *     Example: Rank 4 blob represents [Batch, channels, height, width]
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     A blob with the same shape as the input.
 */
message BatchnormLayerParams {
  uint64 channels = 1;  // Size of the channel dimension in the input.

  /*
   * If ``computeMeanVar == true``,
   * the mean and variance are calculated from either
   * the single input instance, if ``instanceNormalization == true``,
   * or the whole batch, if ``instanceNormalization = false``.
   * and the values provided in parameters "mean" and "variance" are ignored.
   */
  bool computeMeanVar = 5;
  bool instanceNormalization = 6;

  /*
   * A small constant to avoid division by 0 while normalizing by variance.
   * Defaults to ``1e-5`` if not set or set to ``0``.
   */
  float epsilon = 10;

  WeightParams gamma = 15;     // Parameter of length [channels]
  WeightParams beta = 16;      // Parameter of length [channels]
  WeightParams mean = 17;      // Parameter of length [channels]
  WeightParams variance = 18;  // Parameter of length [channels]
}

/*
 * A spatial pooling layer.
 *
 * .. code::
 *
 *      y = PoolingLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank greater than equal to 4.
 *     Rank 4 blob represents [Batch, channels, height, width]
 *     For ranks greater than 4, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     Rank is same as the input. e.g.: for rank 4 input, output shape is [B, C,
 * H_out, W_out]
 *
 * Padding options are similar to ``ConvolutionLayerParams``
 * with the additional option of ``ValidCompletePadding``
 * (``includeLastPixel``), which ensures that the last application of the kernel
 * always includes the last pixel of the input image, if there is padding.
 *
 * .. code::
 *
 *     H_out = ceil(float(H_in + 2 * paddingAmounts[0] -
 * kernelSize[0])/float(Stride[0])) + 1 if (paddingAmounts[0] > 0 or
 * paddingAmounts[1] > 0) if ((H_out - 1) * Stride >= H_in + paddingAmounts[0])
 * { H_out = H_out - 1
 *          }
 *     }
 *
 * The equivalent expressions hold true for ``W_out`` as well.
 * Only symmetric padding is supported with this option.
 */
message PoolingLayerParams {
  enum PoolingType {
    MAX = 0;
    AVERAGE = 1;
    L2 = 2;
  }
  PoolingType type = 1;  // Type of pooling operation.

  /*
   * Must be length 2 in the order ``[H, W]``.
   * If not set, default value ``[3, 3]`` is used.
   */
  repeated uint64 kernelSize = 10;

  /*
   * Must be length 2 in the order ``[H, W]``.
   * If not set, default value ``[1, 1]`` is used.
   */
  repeated uint64 stride = 20;

  message ValidCompletePadding {
    /*
     * Must be length 2 in order ``[H, W]``.
     * If not set, value ``[0, 0]`` is used.
     */
    repeated uint64 paddingAmounts = 10;
  }

  oneof PoolingPaddingType {
    ValidPadding valid = 30;
    SamePadding same = 31;
    ValidCompletePadding includeLastPixel = 32;
  }

  /*
   * If true, padded values are excluded from the count (denominator)
   * when computing average pooling.
   */
  bool avgPoolExcludePadding = 50;

  /*
   * If true, global pooling is performed.
   * Kernel size is inferred from the input data spatial dimensions.
   */
  bool globalPooling = 60;
}

/*
 * A layer to pool three spatial dimensions
 *
 * Input
 *      A blob with rank equal to 5, representing [Batch, channels, depth,
 * height, width].
 *
 * Output
 *      Rank is same as the input: A blob with rank equal to 5, representing
 * [Batch, channels, depth, height, width].
 *
 * Requires 1 input and produces 1 output.
 *
 * For example, given an input of shape (1,1,2,3,3):
 *        +----+----+----+
 *      / | 10 | 11 | 12 |
 *     /  +----+----+----+
 *    /   | 13 | 14 | 15 |
 *   /    +----+----+----+
 *  /     | 16 | 17 | 18 |
 * /      +----+----+----+
 * +----+----+----+      /
 * |  1 |  2 |  3 |     /
 * +----+----+----+    /
 * |  4 |  5 |  6 |   /
 * +----+----+----+  /
 * |  7 |  8 |  9 | /
 * +----+----+----+
 *
 * And applying MAX pooling using:
 *      Kernel: 2x2x2
 *      Stride: 1x1x1
 *      Valid Padding
 * We expect to get an output with shape: (1,1,1,2,2) and value:
 * +----+----+
 * | 14 | 15 |
 * +----+----+
 * | 17 | 18 |
 * +----+----+
 */
message Pooling3DLayerParams {
  enum PoolingType3D {
    MAX = 0;
    AVERAGE = 1;
  }

  // Whether to use Max or Average
  PoolingType3D type = 1;

  // Depth of the pooling region.
  int32 kernelDepth = 2;

  // Height of the pooling region.
  int32 kernelHeight = 3;

  // Width of the pooling region.
  int32 kernelWidth = 4;

  // Stride along the depth direction
  int32 strideDepth = 5;

  // Stride along the height direction
  int32 strideHeight = 6;

  // Stride along the width direction
  int32 strideWidth = 7;

  /*
   * The type of padding.
   * All padding types pad the input shape with zeros.
   * CUSTOM padding will add the custom padding values specified below to their
   * respective dimensions, e.g., `customPaddingFront` number of zeros will be
   * added to one side of the input's depth dimension and `customPaddingBack`
   * number of zeros will be added to the other side of the input's depth
   * dimension. VALID padding adds no padding to any dimension. In this case,
   * the last pool along each dimension will be dropped if the input dimension
   * and the kernel size, and stride do not match. SAME padding adds enough
   * padding to each dimension such that the output has the same spatial
   * dimensions as the input. Padding is added evenly to both sides of each
   * dimension unless the total padding to add is odd, in which case the extra
   * padding is added to the back/bottom/right side of the respective dimension.
   * For example, if the the total horizontal padding is 3, then there will be 1
   * padding on the left, and 2 padding on the right.
   */
  enum Pooling3DPaddingType {
    CUSTOM = 0;
    VALID = 1;
    SAME = 2;
  }
  Pooling3DPaddingType paddingType = 15;

  // Padding before the input in the depth direction.
  int32 customPaddingFront = 8;

  // Padding after the input in the depth direction.
  int32 customPaddingBack = 9;

  // Padding before the input in the height direction.
  int32 customPaddingTop = 10;

  // Padding after the input in the height direction.
  int32 customPaddingBottom = 11;

  // Padding before the input in the width direction.
  int32 customPaddingLeft = 12;

  // Padding after the input in the width direction.
  int32 customPaddingRight = 13;

  // If true, exclude zeros from padding in Average pooling.  Meaningless in Max
  // Pooling.
  bool countExcludePadding = 14;
}

/*
 * A layer to pool three spatial dimensions down to one value.
 * This behaves like a special case of Pooling3DLayerParams in which
 * the Kernel is the size of the input and there is no padding.
 *
 * Input
 *      A blob with rank equal to 5, representing [Batch, channels, depth,
 * height, width].
 *
 * Output
 *      Rank is same as the input: A blob with rank equal to 5, representing
 * [Batch, channels, depth, height, width]. Depth, height, and width of the
 * output will always be 1.
 *
 * Requires 1 input and produces 1 output.
 *
 * For example, given an input of shape (1,1,2,3,3):
 *        +----+----+----+
 *      / | 10 | 11 | 12 |
 *     /  +----+----+----+
 *    /   | 13 | 14 | 15 |
 *   /    +----+----+----+
 *  /     | 16 | 17 | 18 |
 * /      +----+----+----+
 * +----+----+----+      /
 * |  1 |  2 |  3 |     /
 * +----+----+----+    /
 * |  4 |  5 |  6 |   /
 * +----+----+----+  /
 * |  7 |  8 |  9 | /
 * +----+----+----+
 *
 * And applying MAX global 3d pooling, we expect to get an output with shape:
 * (1,1,1,1,1) and value:
 * +----+
 * | 18 |
 * +----+
 */
message GlobalPooling3DLayerParams {
  enum GlobalPoolingType3D {
    MAX = 0;
    AVERAGE = 1;
  }

  // Whether to use Max or Average
  GlobalPoolingType3D type = 1;
}

/*
 * A layer that performs padding along spatial dimensions.
 *
 * .. code::
 *
 *      y = PaddingLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 2.
 *     e.g.: blob with shape ``[H_in, W_in]``.
 *     For ranks greater than 2, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch i.e. Padding is applied on last two
 * dimensions.
 *
 * Output
 *     Same rank as the input.
 *     e.g.: blob with shape ``[H_out, W_out]``.
 *
 * Output dimensions are calculated as follows:
 *
 * .. code::
 *
 *     H_out = H_in + topPaddingAmount + bottomPaddingAmount
 *     W_out = W_in + leftPaddingAmount + rightPaddingAmount
 *
 *     topPaddingAmount == Height startEdgeSize ==
 * borderAmounts[0].startEdgeSize bottomPaddingAmount == Height endEdgeSize ==
 * borderAmounts[0].endEdgeSize leftPaddingAmount == Width startEdgeSize ==
 * borderAmounts[1].startEdgeSize rightPaddingAmount == Width endEdgeSize ==
 * borderAmounts[1].endEdgeSize
 *
 * There are three types of padding:
 *
 * - ``PaddingConstant``, which fills a constant value at the border.
 * - ``PaddingReflection``, which reflects the values at the border.
 * - ``PaddingReplication``, which replicates the values at the border.
 *
 * Given the following input:
 *
 * .. code::
 *
 *     [1, 3, 4]  :  1   2   3   4
 *                   5   6   7   8
 *                   9   10  11  12
 *
 * Here is the output of applying the padding
 * ``(top=2, left=2, bottom=0, right=0)``
 * with each of the supported types:
 *
 * - ``PaddingConstant`` (``value = 0``):
 *   .. code::
 *
 *       [1, 5, 6]  :  0   0   0  0   0   0
 *                     0   0   0  0   0   0
 *                     0   0   1  2   3   4
 *                     0   0   5  6   7   8
 *                     0   0   9  10  11  12
 *
 * - ``PaddingReflection``:
 *   .. code::
 *
 *       [1, 5, 6]  :  11  10  9  10  11  12
 *                     7   6   5  6   7   8
 *                     3   2   1  2   3   4
 *                     7   6   5  6   7   8
 *                     11  10  9  10  11  12
 *
 * - ``PaddingReplication``:
 *   .. code::
 *
 *       [1, 5, 6]  :  1   1   1  2   3   4
 *                     1   1   1  2   3   4
 *                     1   1   1  2   3   4
 *                     5   5   5  6   7   8
 *                     9   9   9  10  11  12
 */
message PaddingLayerParams {
  /*
   * Fill a constant value in the padded region.
   */
  message PaddingConstant {
    float value = 1;
  }

  /*
   * Reflect the values at the border for padding.
   */
  message PaddingReflection {}

  /*
   * Replicate the values at the border for padding.
   */
  message PaddingReplication {}

  oneof PaddingType {
    PaddingConstant constant = 1;
    PaddingReflection reflection = 2;
    PaddingReplication replication = 3;
  }

  BorderAmounts paddingAmounts = 10;  // Amounts to be padded to the input.
}

/*
 * A layer that concatenates along the axis = -3 or -5.
 * For general concatenation along any axis, see ConcatNDLayer.
 *
 * .. code::
 *
 *      y = ConcatLayer(x1,x2,....)
 *
 * Requires more than 1 input and produces 1 output.
 *
 * Input
 *   All input blobs must have same rank.
 *   If "sequenceConcat" = False, rank must be greater than equal to 3. In this
 * case concatenation is along axis = -3 If "sequenceConcat" = True, rank must
 * be greater than equal to 5. In this case concatenation is along axis = -5
 *
 * Output
 *   Same rank as the input.
 *
 */
message ConcatLayerParams {
  /*
   * If true, concatenate along the axis = -5 instead of axis = -3.
   */
  bool sequenceConcat = 100;
}

/*
 * A layer that performs local response normalization (LRN).
 *
 * .. code::
 *
 *      y = LRNLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank greater than equal to 3.
 *     Example: Rank 4 blob represents [Batch, channels, height, width]
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output A blob with the same shape as
 * the input.
 *
 * This layer is described by the following formula:
 *
 * .. math::
 *     x_i \leftarrow  \dfrac{x_i}{\left ( k + \dfrac{\alpha}{\text{localSize}}
 * \sum_j x_j^2 \right )^\beta}
 *
 * where the summation is done over a ``(localSize, 1, 1)`` neighborhood ---
 * that is, over a window "across" channels in 1x1 spatial neighborhoods.
 */
message LRNLayerParams {
  float alpha = 1;
  float beta = 2;
  uint64 localSize = 3;  // Number of channels in the normalization window.
  float k = 4;  // Defaults to 1 if not set or 0. Must be strictly positive.
}

/*
 * Softmax Normalization Layer
 *
 * A layer that performs softmax normalization.
 * Normalization is applied along axis = -3 or N-3 (where N is the rank of the
 * input) For softmax layer that can operate on any axis, see SoftmaxNDLayer.
 *
 *
 * .. code::
 *
 *      y = SoftmaxLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     Must be a blob with rank >= 3.
 * Output
 *     A blob with the same shape as the input.
 *
 * This layer is described by the following formula:
 *
 * .. math::
 *     x_i \leftarrow \dfrac{e^{x_i}}{\sum_i{e^{x_i}}}
 */
message SoftmaxLayerParams {}

/*
 * A layer that uniformly splits across axis = -3 to produce a specified number
 * of outputs. For general split operation along any axis, see SplitNDLayer.
 *
 * .. code::
 *
 *      (y1,y2,...yN) = SplitLayer(x), where N = nOutputs
 *
 * Requires 1 input and produces multiple outputs.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H, W]``
 * Output
 *     ``nOutputs`` blobs each with same rank as the input.
 *     e.g.: For input that is of shape ``[C, H, W]``, output shapes will be
 * ``[C/nOutputs, H, W]``
 */
message SplitLayerParams {
  uint64 nOutputs = 1;  // The number of outputs.
}

/*
 * A layer that performs elementwise addition.
 * This layer has limited broadcasting support. For general broadcasting see
 * AddBroadcastableLayer.
 *
 * .. code::
 *
 *      y = AddLayer(x1,x2,...)
 *
 * Requires 1 or more than 1 input and produces 1 output.
 *
 * Input
 *     In general, there are no rank constraints.
 *     However, only certain set of shapes are broadcastable. For example:
 *     [B, 1, 1, 1], [B, C, 1, 1], [B, 1, H, W], [B, C, H, W]
 * Output
 *     A blob with shape equal to the input blob.
 *
 * If only one input is provided, scalar addition is performed:
 *
 * .. math::
 *     y = x + \alpha
 *
 */
message AddLayerParams {
  /*
   * Scalar to be added to the input.
   * Only used if there is a single input.
   */
  float alpha = 1;
}

/*
 * A layer that performs elementwise multiplication.
 * This layer has limited broadcasting support. For general broadcasting see
 * MultiplyBroadcastableLayer.
 *
 * .. code::
 *
 *      y = MultiplyLayer(x1,x2,...)
 *
 * Requires 1 or more than 1 input and produces 1 output.
 *
 * Input
 *     In general, there are no rank constraints.
 *     However, only certain set of shapes are broadcastable. For example:
 *     [B, 1, 1, 1], [B, C, 1, 1], [B, 1, H, W], [B, C, H, W]
 * Output
 *     A blob with shape equal to the first input blob.
 *
 * If only one input is provided, scalar multiplication is performed:
 *
 * .. math::
 *     y = \alpha x
 *
 */
message MultiplyLayerParams {
  /*
   * Scalar to be multiplied with the input.
   * Only used if there is a single input.
   */
  float alpha = 1;
}

/*
 * A layer that applies a unary function.
 *
 * .. code::
 *
 *      y = UnaryFunctionLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with no rank constraints.
 * Output
 *     A blob with the same shape as the input.
 *
 * The input is first modified by shifting and scaling:
 *
 * .. math::
 *     x \leftarrow \text{scale} \cdot x + \text{shift}
 */
message UnaryFunctionLayerParams {
  /*
   * A unary operator.
   *
   * The following functions are supported:
   *
   * ``SQRT``
   *     .. math:: f(x) = \sqrt{x}
   *
   * ``RSQRT``
   *     .. math:: f(x) = \dfrac{1}{\sqrt{x + \epsilon}}
   *
   * ``INVERSE``
   *     .. math:: f(x) = \dfrac{1}{x + \epsilon}
   *
   * ``POWER``
   *     .. math:: f(x) = x^\alpha
   *
   * ``EXP``
   *     .. math:: f(x) = e^x
   *
   * ``LOG``
   *     .. math:: f(x) = \log x
   *
   * ``ABS``
   *     .. math:: f(x) = |x|
   *
   * ``THRESHOLD``
   *     .. math:: f(x) = \text{max}(\alpha, x)
   */
  enum Operation {
    SQRT = 0;
    RSQRT = 1;
    INVERSE = 2;
    POWER = 3;
    EXP = 4;
    LOG = 5;
    ABS = 6;
    THRESHOLD = 7;
  }
  Operation type = 1;  // The type of unary function.

  /*
   * A constant used in ``POWER`` and ``THRESHOLD`` functions.
   */
  float alpha = 2;

  /*
   * A small constant to avoid division by 0 while normalizing variance.
   * Defaults to ``1e-6`` if not set or set to ``0``.
   */
  float epsilon = 3;

  /*
   * Input is shifted by this amount
   * before the unary function is applied.
   * Defaults to ``0.0`` if not set.
   */
  float shift = 4;

  /*
   * Input is scaled by this amount
   * before the unary function is applied.
   * Defaults to ``1.0`` if not set or set to ``0``.
   */
  float scale = 5;
}

/*
 * A layer that scales up spatial dimensions.
 * It supports two modes: nearest neighbour (default) and bilinear.
 *
 * .. code::
 *
 *      y = UpsampleLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H, W]``.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     Same rank as the input.
 *     e.g.: blob with shape ``[C, scalingFactor[0] * H, scalingFactor[1] * W]``
 */
message UpsampleLayerParams {
  /*
   * Scaling Factor. Mutually exclusive with fractionalScalingFactor.
   * Must be length 2 in order ``[H, W]``.
   * If not set, default value ``[1, 1]`` is used.
   */
  repeated uint64 scalingFactor = 1;

  /*
   * Fractional scaling factor. Mutually exclusive with scalingFactor.
   * Must be length 2 in order ``[H, W]``.
   * If not set, default value ``[1.0, 1.0]`` is used.
   */
  repeated float fractionalScalingFactor = 7;

  /*
   * Overall mode for interpolating new elements when upsampling.
   * NN - Nearest Neighbors - simply pick the nearest true value for
   * interpolated values. BILINEAR - Use bilinear interpolation. See
   * LinearUpsamplingMode for behavior.
   */
  enum InterpolationMode {
    NN = 0;        // Nearest Neighbour
    BILINEAR = 1;  // Bilinear
  }

  InterpolationMode mode = 5;

  /*
   * LinearUpsampleMode specifies the behavior for linear upsampling. Only valid
   * when Interpolation Mode is BILINEAR. If input grid is [0, Xin-1]
   * (corresponding to an input size of Xin), and if the output size is Xout,
   * then the grid points are sampled in the following manner:
   * DEFAULT:
   *   spacing = (Xin-Xin/Xout) / (Xout-1)
   *   grid_point[i] = min(Xin-1, max(0, i * spacing)), for i = 0,1,2,….,Xout-1
   * ALIGN_CORNERS_TRUE:
   *   spacing = (Xin-1) / (Xout-1)
   *   grid_point[i] = min(Xin-1, max(0, i * spacing)), for i = 0,1,2,….,Xout-1
   * ALIGN_CORNERS_FALSE:
   *   spacing = Xin / Xout
   *   grid_point[i] = min(Xin-1, max(0, i * spacing + 0.5 * spacing - 0.5)),
   * for i = 0,1,2,….,Xout-1
   */
  enum LinearUpsampleMode {
    DEFAULT = 0;
    ALIGN_CORNERS_TRUE = 1;
    ALIGN_CORNERS_FALSE = 2;
  }

  LinearUpsampleMode linearUpsampleMode = 6;
}

/*
 * A layer that resizes the input to a pre-specified spatial size using bilinear
 * interpolation.
 *
 * .. code::
 *
 *      y = ResizeBilinearLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H_in, W_in]``.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     Same rank as the input.
 *     e.g.: blob with shape ``[C, H_out, W_out]``.
 *
 */
message ResizeBilinearLayerParams {
  /*
   * Target Spatial Size.
   * Must be length 2 in order ``[Height, Width]``, i.e. ``[H_out, W_out]``.
   * If not set, default value ``[1, 1]`` is used.
   */
  repeated uint64 targetSize = 1;

  /*
   * Mode used to compute the grid on which the spatial output values are
   * evaluated. Same mode is applied to both the height and width axes.
   */
  SamplingMode mode = 2;
}

/*
 * A layer that extracts cropped spatial patches or RoIs (regions of interest)
 * from the input and resizes them to a pre-specified size using bilinear
 * interpolation. Note that RoI Align layer can be implemented with this layer
 * followed by a pooling layer.
 *
 * .. code::
 *
 *      y = CropResizeLayer(x)
 *
 * Requires 2 inputs and produces 1 output.
 *
 * Input
 *     There are two inputs.
 *     First input represents an image feature map.
 *     Second input represents the bounding box coordinates for N patches or
 * RoIs (region of interest).
 *
 *     First input is rank 5: [1, Batch, C, H_in, W_in].
 *     Second input is rank 5. Its shape can be either [N, 1, 4, 1, 1] or [N, 1,
 * 5, 1, 1].
 *
 *     N: number of patches/RoIs to be extracted
 *
 *     If RoI shape = ``[N, 1, 4, 1, 1]``
 *                    The axis=-3 corresponds to the four coordinates specifying
 * the bounding box. All the N RoIs are extracted from all the batches of the
 * input.
 *
 *     If RoI shape = ``[N, 1, 5, 1, 1]``
 *                     The first element of the axis=-3 specifies the input
 * batch id from which to extract the RoI and must be in the interval ``[0,
 * Batch - 1]``. That is, n-th RoI is extracted from the RoI[n,0,0,0,0]-th input
 * batch id. The last four elements of the axis=-3 specify the bounding box
 * coordinates.
 *
 * Output
 *     A blob with rank 5.
 *           - Shape is [N, Batch, C, H_out, W_out] if input RoI shape is [N, 1,
 * 4, 1, 1]
 *           - Shape is [N, 1, C, H_out, W_out] if input RoI shape is [N, 1, 5,
 * 1, 1]
 *
 */
message CropResizeLayerParams {
  /*
   * Target Spatial Size.
   * Must be length 2 in order ``[Height, Width]``, i.e. ``[H_out, W_out]``.
   * If not set, default value ``[1, 1]`` is used.
   */
  repeated uint64 targetSize = 1;

  /*
   * If true the bounding box coordinates must be in the interval [0, 1].
   * They are scaled by (H_in - 1), (W_in - 1), i.e. based on the input spatial
   * dimensions. If false the bounding box coordinates must be in the interval
   * [0, H_in -1] and [0, W_in - 1], respectively for height and width
   * dimensions.
   */
  bool normalizedCoordinates = 2;

  /*
   * Mode used to compute the grid on which the spatial output values are
   * evaluated. Same mode is applied to both the height and width axes.
   */
  SamplingMode mode = 3;

  /*
   * Representation used to express the bounding box coordinates.
   * It determines how the values of the second input are interpreted.
   */
  BoxCoordinatesMode boxIndicesMode = 4;

  /*
   * Additional spatial scale that multiplies the bounding box coordinates.
   * Generally used while implementing the RoI Align layer,
   * which uses unnormalized RoI coordinates along with a spatial scale less
   * than or equal to 1.
   */
  float spatialScale = 5;
}

/*
 * A layer that performs elementwise addition of a bias,
 * which is broadcasted to match the input shape.
 *
 * .. code::
 *
 *      y = BiasLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H, W]``.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output A blob with the same shape as
 * the input.
 */
message BiasLayerParams {
  /*
   * The shape of the bias.
   * Must be one of the following:
   * ``[1]``, ``[C]``, ``[1, H, W]`` or ``[C, H, W]``.
   */
  repeated uint64 shape = 1;

  /*
   * The bias values.
   * The size must be equal to the product of the ``shape`` dimensions.
   */
  WeightParams bias = 2;
}

/*
 * A layer that performs elmentwise multiplication by a scale factor
 * and optionally adds a bias;
 * both the scale and bias are broadcasted to match the input shape.
 *
 * .. code::
 *
 *      y = ScaleLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H, W]``.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output A blob with the same shape as
 * the input.
 */
message ScaleLayerParams {
  /*
   * The shape of the scale.
   * Must be one of the following:
   * ``[1]``, ``[C]``, ``[1, H, W]`` or ``[C, H, W]``.
   */
  repeated uint64 shapeScale = 1;

  /*
   * The scale values.
   * The size must be equal to the product of the ``shape`` dimensions.
   */
  WeightParams scale = 2;  // Scale values. Size must be equal to the product of
                           // dimensions specified in shapeScale.

  bool hasBias = 3;  // If true, a bias is added after scaling.

  /*
   * The shape of the bias.
   * Must be one of the following:
   * ``[1]``, ``[C]``, ``[1, H, W]`` or ``[C, H, W]``.
   */
  repeated uint64 shapeBias = 4;

  /*
   * The bias values.
   * The size must be equal to the product of the ``shape`` dimensions.
   */
  WeightParams bias = 5;
}

/*
 * A layer that loads data as a parameter and provides it as an output.
 * The output is rank 5. For general rank, see LoadConstantNDLayer.
 *
 * .. code::
 *
 *      y = LoadConstantLayer()
 *
 * Requires no input and produces 1 output.
 *
 * Output:
 *     A blob with rank 5 and shape ``[1, 1, C, H, W]``
 */
message LoadConstantLayerParams {
  /*
   * The shape of the constant to be loaded,
   * which must be``[C, H, W]``, that is length 3.
   */
  repeated uint64 shape = 1;

  /*
   * The data values,
   * of size ``C * H * W``.
   */
  WeightParams data = 2;
}

/*
 * A layer that performs L2 normalization, i.e. divides by the
 * the square root of the sum of squares of all elements of input.
 *
 * .. code::
 *
 *      y = L2NormalizeLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank greater than equal to 3.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output A blob with the same shape as
 * the input.
 *
 * This layer is described by the following formula:
 *
 * .. math::
 *     x_i \leftarrow \dfrac{x_i}{\sqrt{\sum{x_i^2} + \epsilon}}
 */
message L2NormalizeLayerParams {
  /*
   * A small constant to avoid division by 0 while normalizing variance.
   * Defaults to ``1e-6`` if not set or set to ``0``.
   */
  float epsilon = 1;
}

// Data Reorganization Layers
// --------------------------

/*
 * A layer that flattens the input.
 *
 * .. code::
 *
 *      y = FlattenLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank greater than equal to 3.
 *     e.g.: Rank 4 blob represents [Batch, C, H, W]
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output Same rank as the input, such
 * that last two dimensions are both 1. e.g.: For rank 4 input, output shape is
 * ``[Batch, C * H * W, 1, 1]``
 *
 * There are two X orders: ``CHANNEL_FIRST`` and ``CHANNEL_LAST``.
 * ``CHANNEL_FIRST`` does not require data to be rearranged,
 * because row major ordering is used by internal storage.
 * ``CHANNEL_LAST`` requires data to be rearranged.
 */
message FlattenLayerParams {
  enum FlattenOrder {
    CHANNEL_FIRST = 0;
    CHANNEL_LAST = 1;
  }
  FlattenOrder mode = 1;
}

/*
 * A layer that recasts the input into a new shape.
 *
 * .. code::
 *
 *      y = ReshapeLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank 5.
 *     e.g.: ``[1, 1, C, H, W]`` or ``[Seq, 1, C, H, W]``.
 * Output
 *     A blob with rank 5.
 *     e.g.: ``[1, 1, C_out, H_out, W_out]`` or ``[Seq_out, 1, C_out, H_out,
 * W_out]``.
 *
 * There are two reshape orders: ``CHANNEL_FIRST`` and ``CHANNEL_LAST``.
 * ``CHANNEL_FIRST`` is equivalent to
 * flattening the input to ``[Seq, 1, C * H * W, 1, 1]`` in channel first order
 * and then reshaping it to the target shape;
 * no data rearrangement is required.
 * ``CHANNEL_LAST`` is equivalent to
 * flattening the input to ``[Seq, 1, H * W * C, 1, 1]`` in channel last order,
 * reshaping it to ``[Seq_out, 1, H_out, W_out, C_out]`` (it is now in
 * "H_out-major"" order), and then permuting it to ``[C_out, H_out, W_out]``;
 * both the flattening and permuting requires the data to be rearranged.
 */
message ReshapeLayerParams {
  /*
   * The shape of the output.
   * Must be of length 3 or 4.
   * If set to 3, ``targetShape`` is interpreted as
   * ``[1, 1, C_out, H_out, W_out]``, and sequence length of the input is
   * preserved. If set to 4, ``targetShape`` is interpreted as
   * ``[Seq_out, 1, C_out, H_out, W_out]``,
   * where ``Seq_out`` is the new sequence length.
   */
  repeated int64 targetShape = 1;

  enum ReshapeOrder {
    CHANNEL_FIRST = 0;
    CHANNEL_LAST = 1;
  }
  ReshapeOrder mode = 2;
}

/*
 * A layer that rearranges the dimensions and data of an input.
 * For generic transpose/permute operation see TransposeLayer.
 *
 * .. code::
 *
 *      y = PermuteLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     Must be a rank 5 blob.
 *     e.g.: shape ``[Seq, B, C, H, W]``.
 * Output
 *     Rank 5 blob. Transposed version of the input, such that dimensions at
 * axis=1 or axis=-4 is unchanged.
 *
 *
 * Examples:
 *
 *  Assume input shape is [Seq, B, C, H, W]
 *
 * - If ``axis`` is set to ``[0, 3, 1, 2]``,
 *   then the output has shape ``[Seq, B, W, C, H]``
 *
 * - If ``axis`` is set to ``[3, 1, 2, 0]``,
 *   then the output has shape ``[W, B, C, H, Seq]``
 *
 * - If ``axis`` is set to ``[0, 3, 2, 1]``,
 *   then the output has shape ``[Seq, B, W, H, C]``
 *
 * - If ``axis`` is not set, or is set to ``[0, 1, 2, 3]``,
 *   the output is the same as the input.
 */
message PermuteLayerParams {
  /*
   * The order in which to permute the dimensions.
   * Must have length 4 and a permutation of ``[0, 1, 2, 3]``.
   */
  repeated uint64 axis = 1;
}

/*
 * A layer that reorganizes data in the input in specific ways.
 *
 * .. code::
 *
 *      y = ReorganizeDataLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 3.
 *     e.g.: blob with shape ``[C, H, W]``.
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch. Output Same rank as the input. e.g.:
 * blob with shape ``[C_out, H_out, W_out]``.
 *
 * mode == SPACE_TO_DEPTH
 *  ``[C_out, H_out, W_out]`` : ``[C * blockSize * blockSize, H/blockSize,
 * W/blockSize]``. blockSize must divide H and W. Data is moved from the spatial
 * dimensions to the channel dimension. Input is spatially divided into
 *  non-overlapping blocks of size blockSize X blockSize and data from each
 * block is moved into the channel dimension.
 *
 * mode == DEPTH_TO_SPACE
 *  ``[C_out, H_out, W_out]`` : ``[C/(blockSize * blockSize), H * blockSize, W *
 * blockSize]``. Square of blockSize must divide C. Reverse of SPACE_TO_DEPTH.
 * Data is moved from the channel dimension to the spatial dimensions.
 *
 * mode == PIXEL_SHUFFLE
 *  ``[C_out, H_out, W_out]`` : ``[C/(blockSize * blockSize), H * blockSize, W *
 * blockSize]``. Square of blockSize must divide C. Similar to DEPTH_TO_SPACE,
 * but using the pixel-shuffle semantics for channel order in the output space.
 *  In both modes, elements along the channel dimension are collapsed into
 *  blocks in the spatial dimensions. The difference is in the arrangement of
 *  the input-channels' data in the output space. See below example for more
 *  detail.
 *  (Only available in Core ML Specification >= 5 (iOS >= 14, macOS >= 11.0)
 *
 *
 * Examples:
 *
 * Assume input is the following [C = 8, H = 1, W = 2] tensor:
 *
 * .. code::
 *
 *    [[[1 2]] [[3 4]] [[5 6]] [[7 8]] [[9 10]] [[11 12]] [[13 14]] [[15 16]]]
 *
 * If block_size == 2 and mode == DEPTH_TO_SPACE, output will be the following
 * [C = 2, H = 2, W = 4] tensor:
 *
 * .. code::
 *
 *    [[[ 1  5  2  6]
 *      [ 9 13 10 14]]
 *
 *     [[ 3  7  4  8]
 *      [11 15 12 16]]]
 *
 * For mode == SPACE_TO_DEPTH, the behavior is the same as mode ==
 * DEPTH_TO_SPACE, but with the input and output swapped.
 *
 * If block_size == 2 and mode == PIXEL_SHUFFLE, output will be the following
 * [C = 2, H = 2, W = 4] tensor:
 *
 * .. code::
 *
 *    [[[ 1  3  2  4]
 *      [ 5  7  6  8]]
 *
 *     [[ 9 11 10 12]
 *      [13 15 14 16]]]
 *
 */
message ReorganizeDataLayerParams {
  enum ReorganizationType {
    SPACE_TO_DEPTH = 0;
    DEPTH_TO_SPACE = 1;
    PIXEL_SHUFFLE = 2;
  }
  ReorganizationType mode = 1;
  uint64 blockSize = 2;  // must be greater than 1
}

/*
 * A layer that slices the input data along axis = -1 or -2 or -3.
 * For general slice along any axis, please see
 * SliceStaticLayer/SliceDynamicLayer.
 *
 * .. code::
 *
 *      y = SliceLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob that can, in general, have any rank. However, depending on the
 * value of "axis" , there may be additional rank constraints. Output A blob
 * with the same rank as the input.
 *
 * Sliced section is taken from the interval ``[startIndex, endIndex)``, i.e.
 * startIndex is inclusive while endIndex is exclusive.
 * stride must be positive and represents the step size for slicing.
 * Negative indexing is supported for startIndex and endIndex.
 * -1 denotes N-1, -2 denotes N-2 and so on, where N is the length of the
 * dimension to be sliced.
 *
 */
message SliceLayerParams {
  int64 startIndex = 1;  // start of the sliced section. Inclusive.
  int64 endIndex = 2;    // end of sliced section. Exclusive.
  uint64 stride = 3;     // The step size. Must be positive.

  enum SliceAxis {
    CHANNEL_AXIS = 0;
    HEIGHT_AXIS = 1;
    WIDTH_AXIS = 2;
  }
  // The following mapping is used for interpreting this parameter:
  // CHANNEL_AXIS => axis = -3, input must have rank at least 3.
  // HEIGHT_AXIS => axis = -2, input must have rank at least 2.
  // WIDTH_AXIS => axis = -1
  SliceAxis axis = 4;
}

/*
 * A layer that reduces the input using a specified operation.
 *
 * .. code::
 *
 *      y = ReduceLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob that can, in general, have any rank. However, depending on the
 * value of "axis" , there may be additional rank constraints. Output A blob
 * with the same rank as the input, which has 1s on the dimensions specified in
 * the parameter "axis"
 *
 *     Values supported for axis are [-1], [-2], [-3], [-2,-1], [-3,-2,-1]
 *     and the equivalent positive values (depending on the rank of the input)
 *     For mode == 'ArgMax', axis must be [-1] or [-2] or [-3].
 */
message ReduceLayerParams {
  /*
   * The following reduction operations are supported
   * and are applied on the specified axis of the input array:
   *
   * ``SUM``
   *     Sum of all elements
   *
   *     .. math:: \sum{x_i}
   *
   * ``AVG``
   *     Sum of all elements divided by the number of elements
   *
   *     .. math:: \dfrac{\sum^n{x_i}}{n}
   *
   * ``PROD``
   *     Product of all elements
   *
   *     .. math:: \prod{x_i}
   *
   * ``LOGSUM``
   *     Sum of the natural logarithm of all elements
   *
   *     .. math:: \sum{\ln{(x_i + \epsilon)}}
   *
   * ``SUMSQUARE``
   *     Sum of squares of all elements
   *
   *     .. math:: \sum{x^2}
   *
   * ``L1``
   *     L1 normalization of all elements
   *
   *     .. math:: ||x||_1 = \sum{|x_i|}
   *
   * ``L2``
   *     L2 normalization of all elements
   *
   *     .. math:: ||x||_2 = \sqrt{\sum{x_i^2}}
   *
   * ``MAX``
   *     Maximum of all elements
   *
   *     .. math:: \text{max}(x_i)
   *
   * ``MIN``
   *     Minimum of all elements
   *
   *     .. math:: \text{min}(x_i)
   *
   * ``ARGMAX``
   *     Argument of the maximum of all elements
   *
   *     .. math:: \text{argmax}(x_i)
   *
   */
  enum ReduceOperation {
    SUM = 0;
    AVG = 1;
    PROD = 2;
    LOGSUM = 3;
    SUMSQUARE = 4;
    L1 = 5;
    L2 = 6;
    MAX = 7;
    MIN = 8;
    ARGMAX = 9;  // only supported with axis = C, H or W.
  }
  ReduceOperation mode = 1;  // Specifies function used to reduce.

  /*
   * Used if mode is ``LOGSUM``.
   * Defaults to ``1e-6`` if not set or is set to ``0``.
   */
  float epsilon = 2;

  enum ReduceAxis {
    CHW = 0;
    HW = 1;
    C = 2;
    H = 3;
    W = 4;
  }

  // The following mapping is used for interpreting this parameter:
  // CHW = axis [-3, -2, -1], input must have rank at least 3.
  // HW = axis [-2, -1], input must have rank at least 2.
  // C = axis [-3]
  // H = axis [-2]
  // W = axis [-1]
  ReduceAxis axis = 3;
}

/*
 * A layer that crops the spatial dimensions of an input.
 * If two inputs are provided, the shape of the second input is used as the
 * reference shape.
 *
 * .. code::
 *
 *      y = CropLayer(x1) or y = CropLayer(x1,x2)
 *
 * Requires 1 or 2 inputs and produces 1 output.
 *
 * Input
 *    1 or 2 tensors, each with rank at least 3, both inputs must have equal
 * rank. Example:
 *     - 1 input case: A blob with shape ``[C, H_in, W_in]``.
 *     - 2 input case: 1st blob with shape ``[C, H_in, W_in]``, 2nd blob with
 * shape ``[C, H_out, W_out]``.
 *
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     Same rank as the inputs.
 *     e.g.: A blob with shape ``[C, H_out, W_out]``.
 *
 * If one input is used, output is computed as follows:
 *
 * .. code::
 *
 *      y = x1[:, topCropAmount:H_in - bottomCropAmount, leftCropAmount:W_in -
 * rightCropAmount]
 *
 *      topCropAmount == Height startEdgeSize == borderAmounts[0].startEdgeSize
 *      bottomCropAmount == Height endEdgeSize == borderAmounts[0].endEdgeSize
 *      leftCropAmount == Width startEdgeSize == borderAmounts[1].startEdgeSize
 *      rightCropAmount == Width endEdgeSize == borderAmounts[1].endEdgeSize
 *
 *      H_out = H_in - topCropAmount - bottomCropAmount
 *      W_out = W_in - leftCropAmount - rightCropAmount
 *
 * If two inputs are used, output is computed as follows:
 *
 * .. code::
 *
 *      y = x1[:, offset[0]:offset[0] + H_out, offset[1]:offset[1] + W_out]
 */
message CropLayerParams {
  /*
   * The amounts to be cropped from the input.
   * Used only if a single input is provided.
   */
  BorderAmounts cropAmounts = 1;

  /*
   * The offset amounts.
   * Used only if two inputs are provided.
   * Must be of length 2, in order ``[H, W]``.
   */
  repeated uint64 offset = 5;
}

/*
 * A layer that computes the elementwise average of the inputs.
 * This layer has limited broadcasting support. For general broadcasting see
 * AddBroadcastableLayer.
 *
 * .. code::
 *
 *      y = AverageLayer(x1,x2,...)
 *
 * Requires multiple inputs and produces 1 output.
 *
 * Input
 *     In general, there are no rank constraints.
 *     However, only certain set of shapes are broadcastable. For example:
 *     [B, 1, 1, 1], [B, C, 1, 1], [B, 1, H, W], [B, C, H, W]
 * Output
 *     A blob with the same shape as each input.
 */
message AverageLayerParams {}

/*
 * A layer that computes the elementwise maximum over the inputs.
 *
 * .. code::
 *
 *      y = MaxLayer(x1,x2,...)
 *
 * Requires multiple inputs and produces 1 output.
 *
 * Input
 *     In general, there are no rank constraints.
 *     However, only certain set of shapes are broadcastable. For example:
 *     [B, C, 1, 1], [B, C, H, W]
 * Output
 *     A blob with the same shape as each input.
 */
message MaxLayerParams {}

/*
 * A layer that computes the elementwise minimum over the inputs.
 *
 * .. code::
 *
 *      y = MinLayer(x1,x2,...)
 *
 * Requires multiple inputs and produces 1 output.
 *
 * Input
 *     In general, there are no rank constraints.
 *     However, only certain set of shapes are broadcastable. For example:
 *     [B, C, 1, 1], [B, C, H, W]
 * Output
 *     A blob with the same shape as each input.
 */
message MinLayerParams {}

/*
 * A layer that computes the dot product of two vectors.
 *
 * .. code::
 *
 *      y = DotProductLayer(x1,x2)
 *
 * Requires 2 inputs and produces 1 output.
 *
 * Input
 *     Two blobs with rank at least 3, such that the last two dimensions must
 * be 1. e.g.: blobs with shape ``[B, C, 1, 1]``. For ranks greater than 3, the
 * leading dimensions, starting from 0 to -4 (inclusive), are all treated as
 * batch.
 *
 * Output
 *     Same rank as the input.
 *     e.g. for rank 4 inputs, output shape: [B, 1, 1, 1]
 */
message DotProductLayerParams {
  /*
   * If true, inputs are normalized first,
   * thereby computing the cosine similarity.
   */
  bool cosineSimilarity = 1;
}

/*
 * A layer that performs mean variance normalization, along axis = -3.
 *
 * .. code::
 *
 *      y = MeanVarianceNormalizeLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank greater than equal to 3.
 *     Example: Rank 4 blob represents [Batch, channels, height, width]
 *     For ranks greater than 3, the leading dimensions, starting from 0 to -4
 * (inclusive), are all treated as batch.
 *
 * Output
 *     A blob with the same shape as the input.
 *
 * If ``acrossChannels == true``
 * normalization is performed on flattened input, i.e. the input is reshaped to
 * (Batch,C), where "Batch" contains all dimensions from 0 to -4 (inclusive),
 * and C contains dimensions -1, -2, -3.
 *
 * If ``acrossChannels == false``
 * normalization is performed within a channel,
 * across spatial dimensions (i.e. last two dimensions).
 */
message MeanVarianceNormalizeLayerParams {
  /*
   * If true, mean and variance are computed across channels.
   */
  bool acrossChannels = 1;

  /*
   * If false, only mean is subtracted.
   */
  bool normalizeVariance = 2;

  /*
   * A small constant to avoid division by 0 while normalizing variance.
   * Defaults to ``1e-6`` if not set or set to ``0``.
   */
  float epsilon = 3;
}

/*
 * A layer that repeats a sequence or the dimension sitting at axis = -5
 *
 * .. code::
 *
 *      y = SequenceRepeatLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A blob with rank at least 5.
 *     e.g: shape ``[Seq, B, C, H, W]``
 * Output
 *     A blob with the same rank as the input.
 *     e.g.: for input shape ``[Seq, B, C, H, W]``, output shape is
 * ``[nRepetitions * Seq, B, C, H, W]``.
 */
message SequenceRepeatLayerParams {
  /*
   * Number of repetitions.
   * Defaults to ``1`` if not set or set to ``0``.
   */
  uint64 nRepetitions = 1;
}

// Recurrent Layers
// ----------------

/*
 * The following activations are supported with recurrent layers:
 * - Linear
 * - Sigmoid
 * - Tanh
 * - ReLU
 * - Scaled Hyperbolic Tangent: alpha * tanh(beta * x), currently only supported
 * for alpha = 1.7159, beta = 2/3
 * - Hard Sigmoid: min(max(alpha * x + beta, 0), 1), currently only supported
 * for alpha = 0.2, beta = 0.5
 */

/*
 * A simple recurrent layer.
 *
 * .. code::
 *
 *      y_t = SimpleRecurrentLayer(x_t, y_{t-1})
 *
 * Input
 *    A blob of rank 5, with shape `[Seq, Batch, inputVectorSize, 1, 1]``.
 *    This represents a sequence of vectors of size ``inputVectorSize``.
 * Output
 *    Same rank as the input.
 *    Represents a vector of size ``outputVectorSize``. It is either the final
 * output or a sequence of outputs at all time steps.
 *
 * - Output Shape: ``[1, Batch, outputVectorSize, 1, 1]`` , if ``sequenceOutput
 * == false``
 * - Output Shape: ``[Seq, Batch, outputVectorSize, 1, 1]`` , if
 * ``sequenceOutput == true``
 *
 * This layer is described by the following equation:
 *
 * .. math::
 *     \boldsymbol{y_t} = f(\mathrm{clip}(W \boldsymbol{x_t} + \
 *                                        R \boldsymbol{y_{t-1}} + b))
 *
 * - ``W`` is a 2-dimensional weight matrix
 *   (``[outputVectorSize, inputVectorSize]``, row-major)
 * - ``R`` is a 2-dimensional recursion matrix
 *   (``[outputVectorSize, outputVectorSize]``, row-major)
 * - ``b`` is a 1-dimensional bias vector (``[outputVectorSize]``)
 * - ``f()`` is an activation
 * - ``clip()`` is a function that constrains values between ``[-50.0, 50.0]``
 */
message SimpleRecurrentLayerParams {
  uint64 inputVectorSize = 1;   // The size of the input vectors.
  uint64 outputVectorSize = 2;  // The size of the output vectors.

  /*
   * Activations supported are Linear, Sigmoid, Tanh, ReLU, Scaled Tanh (alpha
   * = 1.71, beta = 2/3), Hard sigmoid (alpha = 0.2, beta = 0.5)
   */
  ActivationParams activation = 10;  // The activation function.

  /*
      If false output is just the result after final state update.
      If true, output is a sequence, containing outputs at all time steps.
  */
  bool sequenceOutput = 15;

  bool hasBiasVector = 20;  // If false, no bias is added.

  WeightParams weightMatrix = 30;     // Weight matrix W.
  WeightParams recursionMatrix = 31;  // Recursion Weight matrix R.
  WeightParams biasVector = 32;       // Bias vector b.

  bool reverseInput = 100;
  // If true, then the node processes the input sequence from right to left
}

/*
 * Gated-Recurrent Unit (GRU) Layer
 *
 * .. code::
 *
 *      y_t = GRULayer(x_t, y_{t-1})
 *
 * Input
 *    A blob of rank 5, with shape `[Seq, Batch, inputVectorSize, 1, 1]``.
 *    This represents a sequence of vectors of size ``inputVectorSize``.
 * Output
 *    Same rank as the input.
 *    Represents a vector of size ``outputVectorSize``. It is either the final
 * output or a sequence of outputs at all time steps.
 *
 * - Output Shape: ``[1, Batch, outputVectorSize, 1, 1]`` , if ``sequenceOutput
 * == false``
 * - Output Shape: ``[Seq, Batch, outputVectorSize, 1, 1]`` , if
 * ``sequenceOutput == true``
 *
 * This layer is described by the following equations:
 *
 * Update Gate
 *     .. math::
 *         \boldsymbol{z_t} = \
 *             f(\mathrm{clip}(W_z \boldsymbol{x_t} + \
 *                             R_z \boldsymbol{y_{t-1}} + b_z)
 *
 * Reset Gate
 *     .. math::
 *         \boldsymbol{r_t} = \
 *             f(\mathrm{clip}(W_r \boldsymbol{x_t} + \
 *                             R_r \boldsymbol{y_{t-1}} + b_r))
 *
 * Cell Memory State
 *     .. math::
 *         \boldsymbol{c_t} = \
 *             \boldsymbol{y_{t-1}} \odot \boldsymbol{r_t}
 *
 * Output Gate
 *     .. math::
 *         \boldsymbol{o_t} = \
 *             g(\mathrm{clip}(W_o \boldsymbol{x_t} + \
 *                             R_o \boldsymbol{c_t} + b_o))
 *
 * Output
 *     .. math::
 *         \boldsymbol{y_t} = \
 *             (1 - \boldsymbol{z_t}) \odot \boldsymbol{o_t} + \
 *              \boldsymbol{z_t} \odot \boldsymbol{y_{t-1}}
 *
 * - ``W_z``, ``W_r``, ``W_o`` are 2-dimensional input weight matrices
 *   (``[outputVectorSize, inputVectorSize]``, row-major)
 * - ``R_z``, ``R_r``, ``R_o`` are 2-dimensional recursion matrices
 *   (``[outputVectorSize, outputVectorSize]``, row-major)
 * - ``b_z``, ``b_r``, ``b_o`` are 1-dimensional bias vectors
 *   (``[outputVectorSize]``)
 * - ``f()``, ``g()`` are activations
 * - ``clip()`` is a function that constrains values between ``[-50.0, 50.0]``
 * - ``⊙`` denotes the elementwise product of matrices
 */
message GRULayerParams {
  uint64 inputVectorSize = 1;   // Size of the input vectors.
  uint64 outputVectorSize = 2;  // Size of the output vectors.

  /*
   * 2 element array representing activations [f(), g()] in that order.
   * Typical values used = [sigmoid, tanh].
   * Activations supported are Linear, Sigmoid, Tanh, ReLU, Scaled Tanh (alpha
   * = 1.71, beta = 2/3), Hard sigmoid (alpha = 0.2, beta = 0.5)
   */
  repeated ActivationParams activations = 10;

  /*
   * If false output is just the result after final state update.
   * If true, output is a sequence, containing outputs at all time steps.
   */
  bool sequenceOutput = 15;

  /*
   * If false, no biases (``b_z``, ``b_r``, ``b_o``) are added.
   */
  bool hasBiasVectors = 20;

  WeightParams updateGateWeightMatrix = 30;  // Weight Matrix W_z.
  WeightParams resetGateWeightMatrix = 31;   // Weight Matrix W_r.
  WeightParams outputGateWeightMatrix = 32;  // Weight Matrix W_o.

  WeightParams updateGateRecursionMatrix = 50;  // Recursion Weight Matrix R_z.
  WeightParams resetGateRecursionMatrix = 51;   // Recursion Weight Matrix R_r.
  WeightParams outputGateRecursionMatrix = 52;  // Recursion Weight Matrix R_o.

  WeightParams updateGateBiasVector = 70;  // Bias vector b_z.
  WeightParams resetGateBiasVector = 71;   // Bias vector b_r.
  WeightParams outputGateBiasVector = 72;  // Bias vector b_o.

  // If true, then the node processes the input sequence from right to left
  bool reverseInput = 100;
}

/*
 * Long short-term memory (LSTM) parameters.
 *
 * This is described by the following equations:
 *
 * Input Gate
 *     .. math::
 *         \boldsymbol{i_t} = \
 *             f(\mathrm{clip}(W_i \boldsymbol{x_t} + \
 *                             R_i \boldsymbol{y_{t-1}} + \
 *                             p_i \odot c_{t-1} + b_i))
 *
 * Forget Gate
 *     .. math::
 *         \boldsymbol{f_t} = \
 *             f(\mathrm{clip}(W_f \boldsymbol{x_t} + \
 *                             R_f \boldsymbol{y_{t-1}} + \
 *                             p_f \odot c_{t-1} + b_f))
 *
 * Block Input
 *     .. math::
 *         \boldsymbol{z_t} = \
 *             g(\mathrm{clip}(W_z \boldsymbol{x_t} + \
 *                             R_z \boldsymbol{y_{t-1}} + b_z))
 *
 * Cell Memory State
 *     .. math::
 *         \boldsymbol{c_t} = \
 *             \boldsymbol{c_{t-1}} \odot \boldsymbol{f_t} + \
 *             \boldsymbol{i_t} \odot \boldsymbol{z_t}
 *
 * Output Gate
 *     .. math::
 *         \boldsymbol{o_t} = \
 *             f(\mathrm{clip}(W_o \boldsymbol{x_t} + \
 *                             R_o \boldsymbol{y_{t-1}} + \
 *                             p_o \odot c_t + b_o))
 *
 * Output
 *     .. math::
 *         \boldsymbol{y_t} = \
 *             h(\boldsymbol{c_t}) \odot \boldsymbol{o_t}
 *
 * - ``W_i``, ``W_f``, ``W_z``, ``W_o`` are 2-dimensional input weight matrices
 *   (``[outputVectorSize, inputVectorSize]``, row-major)
 * - ``R_i``, ``R_f``, ``R_z``, ``R_o`` are 2-dimensional recursion matrices
 *   (``[outputVectorSize, outputVectorSize]``, row-major)
 * - ``b_i``, ``b_f``, ``b_z``, ``b_o`` are 1-dimensional bias vectors
 *   (``[outputVectorSize]``)
 * - ``p_``, ``p_f``, ``p_o`` are 1-dimensional peephole vectors
 *   (``[outputVectorSize]``)
 * - ``f()``, ``g()``, ``h()`` are activations
 * - ``clip()`` is a function that constrains values between ``[-50.0, 50.0]``
 * - ``⊙`` denotes the elementwise product of matrices
 */
message LSTMParams {
  /*
   * If true, output is a sequence, containing outputs at all time steps.
   * If false, output is just the result after final state update.
   */
  bool sequenceOutput = 10;

  /*
   * If false, no biases (``b_i``, ``b_f``, ``b_z``, ``b_o``) are added.
   */
  bool hasBiasVectors = 20;

  /*
   * If true, a vector of ``1`` values is added to ``b_f``.
   */
  bool forgetBias = 30;

  /*
   * If true, peephole vectors are included.
   */
  bool hasPeepholeVectors = 40;

  /*
   * If the coupled Input and Forget flag is on, the behaviour of
   * ``c_t`` is changed to the following (i.e. forget gate is not used):
   *
   * .. math::
   *     \boldsymbol{c_t} = \
   *         \boldsymbol{c_{t-1}} \odot (1 - \boldsymbol{i_t}) + \
   *         \boldsymbol{i_t} \odot \boldsymbol{z_t}
   *
   */
  bool coupledInputAndForgetGate = 50;

  /*
   * Places a limit on the maximum and minimum values of ``c_t``.
   * c_t = min(c_t, cellClipThreshold)
   * c_t = max(c_t, -cellClipThreshold)
   * If 0, it is set to its default value = 50.0.
   */
  float cellClipThreshold = 60;
}

/*
 * Weights for long short-term memory (LSTM) layers
 */
message LSTMWeightParams {
  WeightParams inputGateWeightMatrix = 1;   // Weight Matrix W_i.
  WeightParams forgetGateWeightMatrix = 2;  // Weight Matrix W_f.
  WeightParams blockInputWeightMatrix = 3;  // Weight Matrix W_z.
  WeightParams outputGateWeightMatrix = 4;  // Weight Matrix W_o.

  WeightParams inputGateRecursionMatrix = 20;   // Recursion Weight Matrix R_i.
  WeightParams forgetGateRecursionMatrix = 21;  // Recursion Weight Matrix R_f.
  WeightParams blockInputRecursionMatrix = 22;  // Recursion Weight Matrix R_z.
  WeightParams outputGateRecursionMatrix = 23;  // Recursion Weight Matrix R_o.

  // biases:
  WeightParams inputGateBiasVector = 40;   // Bias vector b_i.
  WeightParams forgetGateBiasVector = 41;  // Bias vector b_f.
  WeightParams blockInputBiasVector = 42;  // Bias vector b_z.
  WeightParams outputGateBiasVector = 43;  // Bias vector b_o.

  // peepholes:
  WeightParams inputGatePeepholeVector = 60;   // Peephole vector p_i.
  WeightParams forgetGatePeepholeVector = 61;  // Peephole vector p_f.
  WeightParams outputGatePeepholeVector = 62;  // Peephole vector p_o.
}

/*
 * A unidirectional long short-term memory (LSTM) layer.
 *
 * .. code::
 *
 *      (y_t, c_t) = UniDirectionalLSTMLayer(x_t, y_{t-1}, c_{t-1})
 *
 * Input
 *    A blob of rank 5, with shape `[Seq, Batch, inputVectorSize, 1, 1]``.
 *    This represents a sequence of vectors of size ``inputVectorSize``.
 * Output
 *    Same rank as the input.
 *    Represents a vector of size ``outputVectorSize``. It is either the final
 * output or a sequence of outputs at all time steps.
 *
 * - Output Shape: ``[1, Batch, outputVectorSize, 1, 1]`` , if ``sequenceOutput
 * == false``
 * - Output Shape: ``[Seq, Batch, outputVectorSize, 1, 1]`` , if
 * ``sequenceOutput == true``
 *
 */
message UniDirectionalLSTMLayerParams {
  uint64 inputVectorSize = 1;   // Size of the input vectors.
  uint64 outputVectorSize = 2;  // Size of the output vectors.

  /*
   * 3 element array representing activations [f(),g(),h()] in that order.
   * Typical values used = [sigmoid, tanh, tanh].
   * Activations supported are Linear, Sigmoid, Tanh, ReLU, Scaled Tanh (alpha
   * = 1.71, beta = 2/3), Hard sigmoid (alpha = 0.2, beta = 0.5)
   */
  repeated ActivationParams activations = 10;

  LSTMParams params = 15;

  LSTMWeightParams weightParams = 20;  // Weights, biases and peepholes.

  // If true, then the node processes the input sequence from right to left
  bool reverseInput = 100;
}

/*
 * Bidirectional long short-term memory (LSTM) layer
 *
 * .. code::
 *
 *      (y_t, c_t, y_t_reverse, c_t_reverse) = BiDirectionalLSTMLayer(x_t,
 * y_{t-1}, c_{t-1}, y_{t-1}_reverse, c_{t-1}_reverse)
 *
 * Input
 *    A blob of rank 5, with shape `[Seq, Batch, inputVectorSize, 1, 1]``.
 *    This represents a sequence of vectors of size ``inputVectorSize``.
 * Output
 *    Same rank as the input.
 *    Represents a vector of size ``2 * outputVectorSize``. It is either the
 * final output or a sequence of outputs at all time steps.
 *
 * - Output Shape: ``[1, Batch, 2 * outputVectorSize, 1, 1]`` , if
 * ``sequenceOutput == false``
 * - Output Shape: ``[Seq, Batch, 2 * outputVectorSize, 1, 1]`` , if
 * ``sequenceOutput == true``
 *
 *
 * The first LSTM operates on the input sequence in the forward direction.
 * The second LSTM operates on the input sequence in the reverse direction.
 *
 * Example: given the input sequence ``[x_1, x_2, x_3]``,
 * where ``x_i`` are vectors at time index ``i``:
 *
 * The forward LSTM output is ``[yf_1, yf_2, yf_3]``,
 *
 * where ``yf_i`` are vectors of size ``outputVectorSize``:
 *
 * - ``yf_1`` is the output at the end of sequence {``x_1``}
 * - ``yf_2`` is the output at the end of sequence {``x_1``, ``x_2``}
 * - ``yf_3`` is the output at the end of sequence {``x_1``, ``x_2``, ``x_3``}
 *
 * The backward LSTM output: ``[yb_1, yb_2, yb_3]``,
 *
 * where ``yb_i`` are vectors of size ``outputVectorSize``:
 *
 * - ``yb_1`` is the output at the end of sequence {``x_3``}
 * - ``yb_2`` is the output at the end of sequence {``x_3``, ``x_2``}
 * - ``yb_3`` is the output at the end of sequence {``x_3``, ``x_2``, ``x_1``}
 *
 * Output of the bi-dir layer:
 *
 * - if ``sequenceOutput = True`` : { ``[yf_1, yb_3]``,  ``[yf_2, yb_2]``,
 * ``[yf_3, yb_1]`` }
 * - if ``sequenceOutput = False`` : { ``[yf_3, yb_3]`` }
 */
message BiDirectionalLSTMLayerParams {
  /*
   * Size of the input vectors.
   */
  uint64 inputVectorSize = 1;
  /*
   * Size of the outputs vectors.
   * It is same for both forward and backward LSTMs.
   */
  uint64 outputVectorSize = 2;

  /*
   * 3 element array representing activations [f(),g(),h()] in that order.
   * Typical values used = [sigmoid, tanh, tanh].
   * Activations supported are Linear, Sigmoid, Tanh, ReLU, Scaled Tanh (alpha
   * = 1.71, beta = 2/3), Hard sigmoid (alpha = 0.2, beta = 0.5)
   */
  repeated ActivationParams activationsForwardLSTM = 10;
  /*
   * Currently, backward LSTM activations
   * must be same as the ones for the forward LSTM.
   */
  repeated ActivationParams activationsBackwardLSTM = 11;

  /*
   * Common parameters shared by the forward and backward LSTMs.
   */
  LSTMParams params = 15;

  /*
   * Weights and biases.
   * Must be a length 2 message,
   * for the forward and backward LSTM respectively.
   */
  repeated LSTMWeightParams weightParams = 20;
}

message CustomLayerParams {
  message CustomLayerParamValue {
    oneof value {
      double doubleValue = 10;
      string stringValue = 20;
      int32 intValue = 30;
      int64 longValue = 40;
      bool boolValue = 50;
    }
  }

  string className = 10;  // The name of the class (conforming to MLCustomLayer)
                          // corresponding to this layer
  repeated WeightParams weights = 20;  // Any weights -- these are serialized in
                                       // binary format and memmapped at runtime
  map<string, CustomLayerParamValue> parameters =
      30;  // these may be handled as strings, so this should not be large
  string description =
      40;  // An (optional) description of the layer provided by the model
           // creator. This information is displayed when viewing the model, but
           // does not affect the model's execution on device.
}

/*
 * A layer that rearranges the dimensions and data of an input.
 *
 * .. code::
 *
 *      y = TransposeLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     A N-Dimensional tensor.
 * Output
 *     A N-Dimensional tensor of the same rank but with dimensions and data
 * permuted according to axes. Shape: ``[InputShape[axis[0]],
 * InputShape[axis[1]], ... , InputShape[axis[N-1]]]``
 *
 * Examples:
 *
 * - If ``axes`` is set to ``[3, 1, 2, 0]`` and the input shape is
 * ``[6,7,8,9]``, then the output has shape ``[9,7,8,6]``
 */

message TransposeLayerParams {
  /*
   * Length of "axes" should match the rank of input & output tensor
   * "axes" should be a permutation of "[0,1,2,...,N-1]" where N is the rank.
   */
  repeated uint64 axes = 1;  //
}

/*
 * A layer that computes the matrix multiplication of two tensors with
 * numpy-like broadcasting where the matrices reside in the last two indices of
 * the tensor.
 *
 * .. code::
 *
 *      y = BatchedMatMul(a,b)
 *
 * Requires 1 or 2 inputs and produces 1 output.
 *
 * The first tensor, "a", must be provided as an input. The second tensor can
 * either be an input or provided as a weight matrix parameter.
 *
 * Input
 *     - a: First N-Dimensional tensor
 *     - b: Second N-Dimensional tensor (either a rank-N input or a matrix, i.e.
 * N=2, provided as a layer parameter)
 *
 * Output
 *     A tensor containing the matrix product of two tensors.
 *     When there are two inputs: rank is max(2, rank(a), rank(b))
 *     When there is one input: rank is same as that of the input.
 *
 * This operation behaves as following:
 *
 *  When there are two inputs:
 *      - If N >= 2 for both tensors, it is treated as a batch of matrices
 * residing in the last two indices. All the indices, except for the last two,
 * are broadcasted using conventional rules.
 *      - If the first tensor is 1-D, it is converted to a 2-D tensor by
 * prepending a 1 to its shape. Eg. (D) -> (1,D)
 *      - If the second tensor is 1-D, it is converted to a 2-D tensor by
 * appending a 1 to its shape. Eg. (D) -> (D,1)
 *
 *  When there is one input:
 *      - The weight matrix corresponds to a matrix, of shape (X1, X2). Values
 * of X1, X2 must be provided as layer parameters.
 *      - The input, "a", is reshaped into a matrix by combining all the leading
 * dimensions, except the last, into a batch dimension. eg:
 *             - if "a" is rank 1 (X1,) -->  (1, X1). Output shape will be (X2,)
 *             - if "a" is rank 2 (B1, X1) --> no need to reshape. Output shape
 * will be (B1, X2)
 *             - if "a" is rank 3 (B1, B2, X1) --> (B1 * B2, X1). Output shape
 * will be (B1, B2, X2)
 *             - etc
 */
message BatchedMatMulLayerParams {
  /*
   * If transposeA is true, it transposes the left matrix on the fly before
   * matrix multiplication. (is ignored when there is one input)
   */
  bool transposeA = 1;
  /*
   * If transposeB is true, it transposes the right matrix on the fly before
   * matrix multiplication. (is ignored when there is one input)
   */
  bool transposeB = 2;

  /*
   * Following parameters are ignored when there are two inputs.
   */

  uint64 weightMatrixFirstDimension =
      5;  // X1: same as the last dimension of the input tensor
  uint64 weightMatrixSecondDimension =
      6;  // X2: same as the last dimension of the output tensor

  bool hasBias = 7;  // Whether a bias is added or not. Supported only when
                     // there is one input.

  /*
   * Weight matrix representing shape [X1, X2].
   * Values are however stored in column major order,
   * in the "repeated float" or "bytes" fields of the message "WeightParams"
   */
  WeightParams weights = 8;
  WeightParams bias =
      9;  // Bias vector [X2]. Supported only when there is one input.

  /*
   * If set, this layer, at runtime, quantizes the floating point input blob to
   * int8 before applying the matrix multiplication using the INT8 weight
   * parameters provided in weights->int8RawValue. The result is then
   * dequantized. Requires:
   * * number of inputs to be 1
   * * hasBias == false
   * * QuantizationType == LinearQuantizationParams, such that
   *   * size of the "scale" field is 1 and "bias" field is empty in
   * "LinearQuantizationParams"
   * * numberOfBits == 8
   * * weights->rawValue_size to be empty
   */
  bool int8DynamicQuantize = 10;
}

/*
 * A layer that concatenates a list of tensors along a specified axis.
 *
 * .. code::
 *
 *      y = ConcatNDLayer(x1,x2,....)
 *
 * Requires at least 2 input and produces 1 output.
 *
 * Input
 *     The rank of the input tensors must match and all dimensions also must
 * match, except for the dimension 'axis'.
 *
 *
 * Output
 *     Same rank as the input. The dimension along "axis", is the sum of the
 * dimensions of the inputs.
 *
 * example:
 *
 * in1 : shape (3, 2), value = [[1, 2], [3, 4], [5, 6]]
 * in2 : shape (3, 2), value = [[7, 8], [9, 10], [11, 12]]
 * axis = 0
 *
 * if interleave = False (default)
 * output : shape (6, 2)
 * output[0:3, :] = in1
 * output[3:6, :] = in2
 * value = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]]
 *
 * if interleave = True
 * output : shape (6, 2)
 * output[0::2, :] = in1
 * output[1::2, :] = in2
 * value = [[1, 2], [7, 8], [3, 4], [9, 10], [5, 6], [11, 12]]
 *
 */
message ConcatNDLayerParams {
  /*
   * Dimension along which to concatenate. Supports negative values of the
   * parameter 'axis'.
   */
  int64 axis = 1;

  /*
   * (Only available in Core ML Specification >= 5 (iOS >= 14, macOS >= 11.0)
   * Interleave option. If True, concatenation is done via interleaving the
   * inputs. This requires all inputs to have the exact same shape.
   */
  bool interleave = 2;
}

/*
 * A layer that performs softmax normalization along a specified axis.
 *
 * .. code::
 *
 *      y = SoftmaxNDLayer(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Output shape is same as the input.
 */
message SoftmaxNDLayerParams {
  /*
   * Dimension on which the softmax would be performed. Supports negative values
   * of the parameter 'axis'.
   */
  int64 axis = 1;
}

/*
 * A layer that reverses specific dimensions of the input tensor.
 * It is similar in functionality to the numpy.flip method.
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 */
message ReverseLayerParams {
  /*
   * Reverses each dimension of the input tensor for which corresponding
   * reverseDim is set to True. Requires len(reverseDim) == rank(inputTensor)
   */
  repeated bool reverseDim = 1;
}

/*
 * A layer that reverses variable length slices.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * 2 inputs, in order are denoted by "data", "seq_lengths".
 * "seq_lenghts" must be a rank 1 tensor, i.e. seq_lengths.shape = (B,)
 * which contains the lengths of the amount of sequence to be reversed, for each
 * element of the batch. Dimension "batchAxis" in "data" must be equal to B,
 * i.e, data.shape[batchAxis] = B.
 *
 * According to the batch axis, input "data" is first divided into a batch of B
 * inputs, each of which is flipped along the dimension "sequenceAxis", by the
 * amount specified in "seq_lengths", the second input.
 *
 * e.g.:
 *
 * data [shape = (2,4)]:
 * [0 1 2 3]
 * [4 5 6 7]
 * seq_lengths [shape = (2,)]:
 * [3, 0]
 * batchAxis = 0
 * sequenceAxis = 1
 *
 * output [shape = (2,4)]:
 * [2 1 0 3]
 * [4 5 6 7]
 *
 *
 * data [shape = (2,3,2)]:
 * [0 1]
 * [2 3]
 * [4 5] (slice = 0)
 * [6 7]
 * [8 9]
 * [10 11] (slice = 1)
 * seq_lengths [shape = (2,)]:
 * [2, 3]
 * batchAxis = 0
 * sequenceAxis = 1
 *
 * output [shape = (2,3,2)]:
 * [2 3]
 * [0 1]
 * [4 5] (slice = 0)
 * [10 11]
 * [8 9]
 * [6 7] (slice = 1)
 *
 * Output shape is same as the input.
 */
message ReverseSeqLayerParams {
  int64 batchAxis = 1;  // batch axis has to be strictly less than seq_axis
  int64 sequenceAxis = 2;
}

/*
 * A layer that loads data as a parameter and provides it as an output.
 *
 * .. code::
 *
 *      y = LoadConstantNDLayer()
 *
 * Requires no input and produces 1 output.
 *
 * Output: A tensor with shape as provided in the parameter "shape"
 */
message LoadConstantNDLayerParams {
  /*
   * The shape of the constant to be loaded.
   */
  repeated uint64 shape = 1;
  WeightParams data = 2;
}

/*
 * A layer that generates an output tensor with a constant value.
 * Input is only used to determine the shape of the output.
 * This layer is used to allocate a tensor with a dynamic shape (that of the
 * input) and constant value.
 *
 * Requires 1 input and produces 1 output.
 *
 * .. code::
 *
 *      y = FillLikeLayer(x)
 *
 * Input
 *     A N-Dimensional tensor, whose values are ignored. Only the shape is used
 * to infer the shape of the output.
 *
 * Output
 *     A N-Dimensional tensor with the same shape as the input tensor.
 *
 */
message FillLikeLayerParams {
  float value = 1;
}

/*
 * A layer that generates an output tensor with a constant value.
 * This layer is used to allocate a tensor with a static shape and constant
 * value.
 *
 * Requires no input and produces 1 output.
 *
 * .. code::
 *
 *      y = FillStaticLayer(x)
 *
 * Output
 *     A N-Dimensional tensor of shape "targetShape".
 *
 */
message FillStaticLayerParams {
  float value = 1;
  repeated uint64 targetShape = 2;
}

/*
 * A layer that generates an output tensor with a constant value.
 * This layer is used to allocate a tensor with a dynamic shape (as specified by
 * the input) and constant value.
 *
 * Requires 1 input and produces 1 output.
 *
 * .. code::
 *
 *      y = FillDynamicLayer(x)
 *
 * Input
 *     A rank 1 tensor specifying the shape of the output
 *
 * Output
 *     An N-Dimensional tensor with the shape specified by the values in the
 * input tensor.
 *
 */
message FillDynamicLayerParams {
  float value = 1;
}

/*
 * A layer that returns the elements either from tensor x or tensor y,
 * depending on the value in the condition tensor.
 * It is similar in functionality to the numpy.where method with 3 inputs.
 *
 * Requires 3 inputs and produces 1 output.
 * Inputs, in order, are the condition tensor, x and y.
 *
 * for each vector index (i,...,j):
 *    output[i,...,j] = x[i,...,j] if condition[i,...,j] = True
 *                      y[i,...,j] if condition[i,...,j] = False
 *
 * All the 3 inputs are first broadcasted to a common shape.
 * (the shapes must be broadcastable)
 *
 * output.rank = max(input[0].rank, input[1].rank, input[2].rank)
 *
 */
message WhereBroadcastableLayerParams {}

/*
 * A layer that computes elementwise trigonometric sine function.
 *
 *
 * .. code::
 *
 *      y = SinLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message SinLayerParams {}

/*
 * A layer that computes elementwise trigonometric cosine function.
 *
 *
 * .. code::
 *
 *      y = CosLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message CosLayerParams {}

/*
 * A layer that computes elementwise trigonometric tangent function.
 *
 *
 * .. code::
 *
 *      y = TanLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message TanLayerParams {}

/*
 * A layer that computes elementwise trigonometric arcsine function.
 *
 *
 * .. code::
 *
 *      y = AsinLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AsinLayerParams {}

/*
 * A layer that computes elementwise trigonometric arccosine function.
 *
 *
 * .. code::
 *
 *      y = AcosLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AcosLayerParams {}

/*
 * A layer that computes elementwise trigonometric arctangent function.
 *
 *
 * .. code::
 *
 *      y = AtanLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AtanLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic sine function.
 *
 *
 * .. code::
 *
 *      y = SinhLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message SinhLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic cosine function.
 *
 *
 * .. code::
 *
 *      y = CoshLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message CoshLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic tangent function.
 *
 *
 * .. code::
 *
 *      y = TanhLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message TanhLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic arcsine function.
 *
 *
 * .. code::
 *
 *      y = AsinhLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AsinhLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic arccosine
 * function.
 *
 *
 * .. code::
 *
 *      y = AcoshLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AcoshLayerParams {}

/*
 * A layer that computes elementwise trigonometric hyperbolic arctangent
 * function.
 *
 *
 * .. code::
 *
 *      y = AtanhLayer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message AtanhLayerParams {}
/*
 * A layer that raises each element in first tensor to the power of
 * corresponding element in the second tensor.
 * Supports conventional numpy-like broadcasting.
 *
 * .. code::
 *
 *      y = PowBroadcastableLayer(x)
 *
 * Requires 2 inputs and produces 1 output.
 *
 * Input
 *     - First N-Dimensional tensor
 *     - Second N-Dimensional tensor
 *
 * Output
 *     An N-Dimensional tensor with the broadcast shape.
 *
 */
message PowBroadcastableLayerParams {}

/*
 * A layer that computes the exponential of all elements in the input tensor,
 * with the base 2.
 *
 *
 * .. code::
 *
 *      y = Exp2Layer(x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message Exp2LayerParams {}

/*
 * A layer that returns a tensor containing the indices of all non-zero
 * elements of input tensor.
 * It is similar in functionality to the numpy.where method with 1 input.
 *
 * Requires 1 input and produces 1 output.
 * Output is of rank 2, of shape (N,R),
 * where N is the number of non-zero elements in the input and R is the rank of
 * the input.
 *
 * Output contains indices represented in the multi-index form
 *
 * e.g.:
 * input {shape = (4,)}:
 * [0 1 0 2]
 * output {shape = (2,1)}:
 * [1]
 * [3]
 *
 *
 * input {shape = (3, 3)}:
 * [1 2 1]
 * [0 2 2]
 * [2 1 0]
 * output {shape = (7,1)}:
 * [0. 0.]
 * [0. 1.]
 * [0. 2.]
 * [1. 1.]
 * [1. 2.]
 * [2. 0.]
 * [2. 1.]
 *
 */
message WhereNonZeroLayerParams {}

/*
 * A layer that copies a tensor setting everything outside a central band in
 * each inner-most matrix to zero.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters for matrix_band_part layer
 * band(m, n) = (num_lower < 0 || (m-n) <= num_lower) && (num_upper < 0 || (n-m)
 * <= num_upper). output[i, j, k, ..., m, n] = band(m, n) * input[i, j, k, ...,
 * m, n]
 *
 *
 * Output shape is same as the input shape.
 * Rank of the input must be at least 2.
 * For rank higher than 2, the last 2 dimensions are treated as the matrix,
 * while the rest are treated as batch.
 */
message MatrixBandPartLayerParams {
  int64 numLower = 1;
  int64 numUpper = 2;
}

/*
 * A layer that copies a tensor setting everything outside upper triangular to
 * zero.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output shape is same as the input shape.
 * Rank of the input must be at least 2.
 * For rank higher than 2, the last 2 dimensions are treated as the matrix,
 * while the rest are treated as batch.
 */
message UpperTriangularLayerParams {
  int64 k = 1;  // Diagonal below which to zero elements. k = 0 (the default) is
                // the main diagonal, k < 0 is below it and k > 0 is above
}

/*
 * A layer that copies a tensor setting everything outside lower triangular to
 * zero.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output shape is same as the input shape.
 * Rank of the input must be at least 2.
 * For rank higher than 2, the last 2 dimensions are treated as the matrix,
 * while the rest are treated as batch.
 */
message LowerTriangularLayerParams {
  int64 k = 1;  // Diagonal above which to zero elements. k = 0 (the default) is
                // the main diagonal, k < 0 is below it and k > 0 is above
}

/*
 *
 * A layer that broadcasts a tensor to a new shape.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * First input is broadcast to produce the output, while the second input is
 * only used to determine the shape of the output. Values of second input are
 * not used.
 *
 * Output is a tensor with the same shape as the second input.
 *
 */
message BroadcastToLikeLayerParams {}

/*
 *
 * A layer that broadcasts a tensor to a new shape.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output tensor is the broadcasted version of the input and has shape as
 * specified in the parameter "targetShape".
 */
message BroadcastToStaticLayerParams {
  repeated uint64 targetShape = 1;
}

/*
 *
 * A layer that broadcasts a tensor to a new shape.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * First input is the one that is broadcasted to produce the output.
 * Second input is a rank 1 tensor specifying the shape of the output.
 * Output tensor has shape as specified by the values in the 2nd input tensor.
 */
message BroadcastToDynamicLayerParams {}

/*
 * A layer that performs element-wise addition operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message AddBroadcastableLayerParams {}

/*
 * A layer that performs element-wise maximum operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message MaxBroadcastableLayerParams {}

/*
 * A layer that performs element-wise minimum operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message MinBroadcastableLayerParams {}

/*
 * A layer that performs element-wise modular operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message ModBroadcastableLayerParams {}

/*
 * A layer that performs element-wise floor division operation with broadcast
 * support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message FloorDivBroadcastableLayerParams {}

/*
 * A layer that performs element-wise subtract operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message SubtractBroadcastableLayerParams {}

/*
 * A layer that performs element-wise multiply operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message MultiplyBroadcastableLayerParams {}

/*
 * A layer that performs element-wise division operation with broadcast support.
 *
 * Requires 2 inputs and produces 1 output.
 */
message DivideBroadcastableLayerParams {}

/*
 * Gather layer that gathers elements from the first input, along a specified
 * axis, at indices specified in the second input. It is similar in
 * functionality to the numpy.take method.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * Given two inputs, 'data' and 'indices', gather the slices of 'data'
 * and store into output.
 * e.g.
 * for i in [0, length(indices) - 1]
 *    output[i] = data[indices[i]]  (1-D case, axis=0)
 *
 * if axis = 0:
 * for each vector index (i,...,j)
 *    output[i,...,j,:,..,:] = data[indices[i,...,j],:,..,:]
 *
 * output.rank = (data.rank - 1) + indices.rank
 *
 * Negative indices and negative axis are supported.
 *
 * e.g:
 *
 * data shape = (2, 3)
 * indices shape = (6, 8)
 * axis = 0
 * output shape = (6, 8) + (3,) = (6, 8, 3)
 *
 * data shape = (2, 3, 5)
 * indices shape = (6, 8)
 * axis = 1
 * output shape = (2,) + (6, 8) + (5,) =  (2, 6, 8, 5)
 *
 */
message GatherLayerParams {
  int64 axis = 1;
}

/*
 * Scatter accumulation mode.
 */
enum ScatterMode {
  SCATTER_UPDATE = 0;
  SCATTER_ADD = 1;  // add
  SCATTER_SUB = 2;  // subtract
  SCATTER_MUL = 3;  // multiply
  SCATTER_DIV = 4;  // divide
  SCATTER_MAX = 5;  // maximum
  SCATTER_MIN = 6;  // minimum
}

/*
 * A layer that scatters data into a new tensor according to indices from the
 * input. This is the inverse operation of Gather.
 *
 * Requires 3 inputs and produces 1 output.
 *
 * Output is initialized with the first input.
 * Then updated with the values in the third input, at indices specified by the
 * second input.
 *
 * An example when axis=0:
 * Given three inputs, in order, "container", "indices", "updates", where
 *
 * - "container" is a rank R+1 tensor of shape [D_0, D_1, ..., D_R], which
 *   contains D_0 number of tensors, each with shape [D_1, ..., D_R].
 *
 * - "indices" is a rank 1 tensor with shape [N], where N is the number of
 * updates. The values in this tensor must be in the range [0, D_0 - 1].
 * (negative indexing is supported)
 *
 * - "updates" is a rank R+1 tensor with shape [N, D_1, ..., D_R], which
 * represents a total number of N tensors, each of shape [D_1, ..., D_R].
 *
 * The effect of this operation is as follows:
 *
 * output = container;
 * For each i in 0, ..., N - 1
 *    output[indices[i], :, ..., :] = updates[i, :, ..., :] // if mode ==
 * "SCATTER_UPDATE"
 *
 * or
 * For each i in 0, ..., N - 1
 *    output[indices[i], :, ..., :] += updates[i, :, ..., :] // if mode ==
 * "SCATTER_ADD"
 *
 * etc
 *
 * When "indices" is a tensor of rank greater than 1, the equation becomes (for
 * axis=0): For each vector index (i,...,j) output[indices[i,...,j],...] -=
 * updates[i,...,j,...] // if mode == "SCATTER_SUB"
 *
 *
 * The output has the same shape as the first input.
 * "indices" input must have rank less than or equal to the "updates" input and
 * its shape must be a subset of the the shape of the "updates" input.
 *
 * e.g:
 *
 * container shape = (4, 3)
 * indices shape = (5, 2, 3)
 * updates shape = (4, 5, 2, 3)
 * axis = 1
 * output shape = (4, 3)
 *
 * container shape = (4, 4, 3)
 * indices shape = (6,)
 * updates shape = (4, 6, 3)
 * axis = -2
 * output shape = (4, 4, 3)
 *
 * container shape = (5,)
 * indices shape = (5, 7, 5, 6)
 * updates shape = (5, 7, 5, 6)
 * axis = -1
 * output shape = (5,)
 */

message ScatterLayerParams {
  int64 axis = 1;
  ScatterMode mode = 2;  // mode of accumulation.
}

/*
 * A layer that gathers elements from the first input, 'params', at the
 * multi-indices specified by the second input, 'indices'.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * 'params' = input[0], 'indices' = input[1]
 *
 * 'indices' is a rank K+1 tensor of shape [I_0, I_1, .., I_(K-1), I_K] which is
 * viewed as a collection of indices of (I_0 * I_1 * ... * I_(K-1)) points in
 * the I_K dimensional space. For instance, the multi-index of the first point
 * is indices[0,0,...,0,:].
 *
 * Here is how the output is constructed:
 *
 * for i = 0,1,...,(I_0-1)
 *   ...
 *     for j = 0,1,....,(I_(K-1)-1)
 *          output[i,....,j,:,:,..,:] = params[indices[i,...,j,:], :,:,..,:]
 *
 * Hence, output shape is [I_0, I_1,...,I(K-1)] + params.shape[I_K:]
 *
 * output.rank = indices.rank - 1 + params.rank - indices.shape[-1]
 *
 * e.g:
 *
 * input[0] shape = (4, 2, 3, 4)
 * input[1] shape = (6, 2)
 * output shape = (6,) + (3, 4) = (6, 3, 4)
 *
 * input[0] shape = (3, 3, 3, 4, 7)
 * input[1] shape = (3, 5)
 * output shape = (3,) + () = (3,)
 *
 * input[0] shape = (5, 3, 2, 5)
 * input[1] shape = (2, 7, 3, 2)
 * output shape = (2, 7, 3) + (2, 5) = (2, 7, 3, 2, 5)
 *
 */
message GatherNDLayerParams {}

/*
 * A layer that scatters data into a new tensor according to multi-indices from
 * the input. This is the inverse operation of GatherND.
 *
 * Requires 3 inputs and produces 1 output.
 * 3 inputs, in order are denoted as "container", "indices", "updates".
 *
 * 'indices' is a rank K+1 tensor of shape [I_0, I_1, .., I_(K-1), I_K] which is
 * viewed as a collection of indices of (I_0 * I_1 * ... * I_(K-1)) points in
 * the I_K dimensional space. For instance, the multi-index of the first point
 * is indices[0,0,...,0,:].
 *
 * container.rank >= I_K
 * updates.rank = K + (container.rank - I_K)
 * shape of 'updates' = [I_0, I_1,...,I(K-1)] + container.shape[I_K:]
 *
 * output = container
 * For each vector index (i,...,j) s.t. 0<=i<I_0,..., 0<=j<I_K
 *   output[indices[i,...,j,:], :,:,..,:] = updates[i,....,j,:,:,..,:] // if
 * mode == "SCATTER_UPDATE"
 *
 * The output has the same shape as the first input.
 *
 * e.g:
 *
 * container shape = (3, 2)
 * indices shape = (4, 2)
 * updates shape = (4,)
 * output shape = (3, 2)
 *
 * container shape = (7, 6)
 * indices shape = (4, 7, 2, 5, 1)
 * updates shape = (4, 7, 2, 5, 6)
 * output shape = (7, 6)
 *
 */
message ScatterNDLayerParams {
  ScatterMode mode = 1;  // mode of accumulation.
}

/*
 * Gather layer that gathers elements from the first input, along a specified
 * axis, at indices specified in the second input. It is similar in
 * functionality to the numpy.take_along_axis method.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * Given two inputs, 'data' and 'indices', gather the slices of 'data'
 * and store into output.
 *
 * Both inputs and output have the same rank.
 * Output shape is same as the shape of 'indices'
 * Shapes of 'indices' and 'data' match, except at the 'axis' dimension.
 *
 * This operation performs the following operation for axis=0:
 * for each vector index (i,j,....,k)
 *    output[i,j,....,k] = data[index[i,j,....,k],j,....,k]
 *
 * Negative indices and negative axis are supported.
 *
 * e.g:
 *
 * data shape = (4, 4, 7)
 * indices shape = (4, 5, 7)
 * axis = 1
 * output shape = (4, 5, 7)
 *
 */
message GatherAlongAxisLayerParams {
  int64 axis = 1;
}

/*
 * A layer that scatters data into a new tensor according to indices from
 * the input along the given axis into the output tensor.
 * This is the inverse operation of GatherAlongAxis.
 * It is similar in functionality to the numpy.put_along_axis method.
 *
 * Requires 3 inputs and produces 1 output.
 * 3 inputs, in order are denoted as "container", "indices", "updates".
 *
 * All inputs and output have the same rank.
 * Output shape is same as the shape of 'container'
 * Shapes of 'indices' and 'updates' match, which is same as the shape of
 * 'container' except at the 'axis' dimension.
 *
 * Negative indices and negative axis are supported.
 *
 * This operation performs the following operation for axis=0:
 * output = container
 * for each vector index (i,j,....,k)
 *    output[index[i,j,....,k],j,....,k] = updates[i,j,....,k]
 *
 * e.g.:
 *
 * container shape = (2, 5, 6)
 * indices shape = (2, 2, 6)
 * updates shape = (2, 2, 6)
 * axis = -2
 * output shape = (2, 5, 6)
 *
 */
message ScatterAlongAxisLayerParams {
  int64 axis = 1;
  ScatterMode mode = 2;  // mode of accumulation.
}

/*
 * A layer that stacks the input tensors along the given axis.
 * It is similar in functionality to the numpy.stack method.
 *
 * Requires at least 2 inputs and produces 1 output.
 * All inputs must have the same shape.
 * Rank of the output is 1 greater than the rank of the inputs.
 *
 * Negative indexing is supported for the "axis" parameter.
 *
 * e.g.:
 *
 * input shape = (2, 4, 2)
 * number of inputs = 5
 * axis = 3
 * output shape = (2, 4, 2, 5)
 *
 * input shape = (2, 4, 2)
 * number of inputs = 5
 * axis = -2
 * output shape = (2, 4, 5, 2)
 */
message StackLayerParams {
  int64 axis = 1;
}

/*
 * A layer that reshapes a tensor that does not alter the rank of the input.
 * Order of the data is left unchanged.
 *
 * Requires 1 input and produces 1 output.
 *
 * e.g:
 *
 * input shape = (20,10)
 * targetShape = (5,-1)
 * output shape = (5,40)
 *
 * input shape = (20,10,5)
 * targetShape = (0,2,25)
 * output shape = (20,2,25)
 *
 * input shape = (10,3,5)
 * targetShape = (25,0,-1)
 * output shape = (25,3,2)
 */
message RankPreservingReshapeLayerParams {
  /*
   * Length of this field must be same as the input/output rank.
   * It can have 0's, in which case the corresponding input dimension is kept
   * intact. At most one element can be -1, in which case the output dimension
   * is calculated from rest of the shape.
   */
  repeated int64 targetShape = 1;
}

/*
 * Constant padding layer.
 * Pad the input array with a constant value, either along a single given axis
 * or along a set of axes.
 *
 * Requires 1 or 2 inputs and produces 1 output.
 * The amount of padding can be either set as a parameter ("padAmounts") or
 * provided as a second input.
 *
 * Output rank is same as the rank of the first input.
 *
 * when "padToGivenOutputSizeMode" is False:
 *
 * output_shape[i] = input_shape[i] + padAmounts[2*i] + padAmounts[2*i+1],
 * i=0,...,rank-1
 *
 * Examples:
 *
 * input shape = (20,10)
 * padAmounts = [0,1,4,0]
 * output shape = (21,14)
 *
 * input shape = (20,10,5)
 * padAmounts = [0,0,3,4,0,9]
 * output shape = (20,17,14)
 *
 *
 * when "padToGivenOutputSizeMode" is True
 *
 * output_shape[i] = max(input_shape[i], max(padAmounts[2*i] +
 * padAmounts[2*i+1])), i=0,...,rank-1
 *
 * input shape = (20,10)
 * padAmounts = [0,21,14,0]
 * output shape = (21,14)
 *
 * input shape = (20,10,5)
 * padAmounts = [0,0,17,0,0,14]
 * output shape = (20,17,14)
 */
message ConstantPaddingLayerParams {
  /*
   * The value to be used for padding.
   */
  float value = 1;

  /*
   * Length of this repeated field must be twice the rank of the first input.
   * 2*i-th and (2*i+1)-th values represent the amount of padding to be applied
   * to the the i-th input dimension, "before" and "after" the input values,
   * respectively.
   */
  repeated uint64 padAmounts = 2;

  /*
   * When this is True, positive values in "padAmounts" are equivalent to the
   * output shape. In that case only one of padAmounts[2*i] and
   * padAmounts[2*i+1] can be non zero, for i=0,..,rank-1.
   */
  bool padToGivenOutputSizeMode = 3;
}

/*
 * A layer that returns a tensor filled with values from the normal
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the normal distribution.
 *     mean: mean of the normal distribution.
 *     stdDev: standard deviation of the normal distribution.
 *
 * Input
 *     An N-Dimensional tensor, whose values are ignored. Only the shape is used
 * to infer the shape of the output.
 *
 * Output
 *     An N-Dimensional tensor with the same shape as the input tensor.
 *
 */
message RandomNormalLikeLayerParams {
  int64 seed = 1;
  float mean = 2;
  float stdDev = 3;
}

/*
 * A layer that returns a tensor filled with values from the normal
 * distribution.
 *
 * Requires no input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the normal distribution.
 *     mean: mean of the normal distribution.
 *     stdDev: standard deviation of the normal distribution.
 *     outputShape: shape of the output tensor.
 *
 * Output
 *     An N-Dimensional tensor of shape "outputShape".
 *
 */
message RandomNormalStaticLayerParams {
  int64 seed = 1;
  float mean = 2;
  float stdDev = 3;
  repeated uint64 outputShape = 4;
}

/*
 * A layer that returns a tensor filled with values from the normal
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *     seed: seed used for the normal distribution.
 *     mean: mean of the normal distribution.
 *     stdDev: standard deviation of the normal distribution.
 *
 * Input
 *     A rank 1 tensor specifying the shape of the output
 *
 * Output
 *     An N-Dimensional tensor with the shape specified by the values in the
 * input tensor.
 */
message RandomNormalDynamicLayerParams {
  int64 seed = 1;
  float mean = 2;
  float stdDev = 3;
}

/*
 * A layer that returns a tensor filled with values from the uniform
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the uniform distribution.
 *     minVal: lower bound on the range of random values for the uniform
 * distribution. maxVal: upper bound on the range of random values for the
 * uniform distribution.
 *
 * Input
 *     An N-Dimensional tensor, whose values are ignored. Only the shape is used
 * to infer the shape of the output.
 *
 * Output
 *     An N-Dimensional tensor with the same shape as the input tensor.
 *
 */
message RandomUniformLikeLayerParams {
  int64 seed = 1;
  float minVal = 2;
  float maxVal = 3;
}

/*
 * A layer that returns a tensor filled with values from the uniform
 * distribution.
 *
 * Requires no input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the uniform distribution.
 *     minVal: lower bound on the range of random values for the uniform
 * distribution. maxVal: upper bound on the range of random values for the
 * uniform distribution. outputShape: shape of the output tensor.
 *
 * Output
 *     An N-Dimensional tensor of shape "outputShape".
 *
 */
message RandomUniformStaticLayerParams {
  int64 seed = 1;
  float minVal = 2;
  float maxVal = 3;
  repeated uint64 outputShape = 4;
}

/*
 * A layer that returns a tensor filled with values from the uniform
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *     seed: seed used for the uniform distribution.
 *     minVal: lower bound on the range of random values for the uniform
 * distribution. maxVal: upper bound on the range of random values for the
 * uniform distribution.
 *
 * Input
 *     A rank 1 tensor specifying the shape of the output
 *
 * Output
 *     An N-Dimensional tensor with the shape specified by the values in the
 * input tensor.
 *
 */
message RandomUniformDynamicLayerParams {
  int64 seed = 1;
  float minVal = 2;
  float maxVal = 3;
}

/*
 * A layer that returns a tensor filled with values from the Bernoulli
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the Bernoulli distribution.
 *     prob: probability of a 1 event.
 *
 * Input
 *     An N-Dimensional tensor, whose values are ignored. Only the shape is used
 * to infer the shape of the output.
 *
 * Output
 *     An N-Dimensional tensor with the same shape as the input tensor.
 *
 */
message RandomBernoulliLikeLayerParams {
  int64 seed = 1;
  float prob = 2;
}

/*
 * A layer that returns a tensor filled with values from the Bernoulli
 * distribution.
 *
 * Requires no input and produces 1 output.
 *
 * Parameters
 *     seed: seed used for the Bernoulli distribution.
 *     prob: probability of a 1 event.
 *     outputShape: shape of the output tensor.
 *
 * Output
 *     An N-Dimensional tensor of shape "outputShape".
 */
message RandomBernoulliStaticLayerParams {
  int64 seed = 1;
  float prob = 2;
  repeated uint64 outputShape = 3;
}

/*
 * A layer that returns a tensor filled with values from the Bernoulli
 * distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *     seed: seed used for the Bernoulli distribution.
 *     prob: probability of a 1 event.
 *
 * Input
 *     A rank 1 tensor specifying the shape of the output
 *
 * Output
 *     An N-Dimensional tensor with the shape specified by the values in the
 * input tensor.
 */
message RandomBernoulliDynamicLayerParams {
  int64 seed = 1;
  float prob = 2;
}

/*
 * A layer that returns a tensor of the specified shape filled with values from
 * the categorical distribution.
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameter:
 *     seed: seed used for the categorical distribution.
 *     numSamples: number of samples to draw.
 *     isLogits: true if the inputs are logits, false if the inputs are
 * probabilities. eps: default value is 1e-10. temperature: default value
 * is 1.0.
 *
 * Input tensor shape = [D_1, D_2, ... , D_(R-1), D_R] (Rank = R)
 * Then the shape of the output is [D_1, D_2, ... , D_(R-1), numSamples] (Rank =
 * R)
 *
 */
message CategoricalDistributionLayerParams {
  int64 seed = 1;
  int64 numSamples = 2;
  bool isLogits = 3;
  float eps = 4;
  float temperature = 5;
}

/*
 * A layer that performs reduction with L1 normalization operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceL1LayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with L2 normalization operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceL2LayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with max operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceMaxLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with min operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceMinLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with sum operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceSumLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with prod operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceProdLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with mean operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceMeanLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with logSum operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceLogSumLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with logSumExp operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceSumSquareLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that performs reduction with logSumExp operation.
 *
 * Negative indexing is supported.
 * Requires 1 input and produces 1 output.
 *
 * Parameters:
 *    axes: dimensions along which to perform reduction
 *    keepDims: if True, keep the reduced dimensions (value will be 1),
 * otherwise, reduced dimensions are squeezed reduceAll: ignore the "axes"
 * parameter, perform reduction along all axes
 *
 */
message ReduceLogSumExpLayerParams {
  repeated int64 axes = 1;
  bool keepDims = 2;
  bool reduceAll = 3;
}

/*
 * A layer that increases the rank of the input tensor by adding unit
 * dimensions.
 *
 * Requires 1 input and produces 1 output.
 *
 * e.g.:
 *
 * input shape = (10,5)
 * axes = (0,1)
 * output shape = (1,1,10,5)
 *
 * input shape = (10,5)
 * axes = (0,2)
 * output shape = (1,10,1,5)
 *
 * input shape = (10,5)
 * axes = (-2,-1)
 * output shape = (10,5,1,1)
 *
 */
message ExpandDimsLayerParams {
  /*
   * Axis values provided here get dimension 1 in the output tensor.
   * Negative indexing is supported.
   */
  repeated int64 axes = 1;
}

/*
 * A layer that flattens the input tensor into a 2-dimensional matrix.
 *
 * Requires 1 input and produces 1 output.
 * Output tensor is always rank 2.
 *
 * First dimension of output is the product of all the dimensions in
 * input[:axis] ("axis" is exclusive) Second dimension of output is the product
 * of all the dimensions in input[axis:] ("axis" is inclusive)
 *
 * e.g.:
 * input shape:  (3,)
 * axis:  -1
 * output shape:  (1, 3)
 *
 * input shape:  (3,)
 * axis:  1
 * output shape:  (3, 1)
 *
 * input shape:  (4, 3)
 * axis:  -1
 * output shape:  (4, 3)
 *
 * input shape:  (5, 2)
 * axis:  0
 * output shape:  (1, 10)
 *
 * input shape:  (5, 5, 3)
 * axis:  -2
 * output shape:  (5, 15)
 *
 * input shape:  (2, 3, 2)
 * axis:  -1
 * output shape:  (6, 2)
 *
 */
message FlattenTo2DLayerParams {
  int64 axis = 1;
}

/*
 * A layer that reshapes a tensor.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output tensor is the reshaped version of the input and has shape as specified
 * in the parameter "targetShape".
 *
 */
message ReshapeStaticLayerParams {
  repeated int64 targetShape = 1;
}

/*
 * A layer that reshapes a tensor.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * First input is reshaped to produce the output, while the second input is only
 * used to determine the shape of the output. Values of the second input are not
 * used.
 *
 * Output is a tensor with the same shape as the second input.
 *
 */
message ReshapeLikeLayerParams {}

/*
 * A layer that reshapes a tensor.
 *
 * Requires 2 inputs and produces 1 output.
 *
 * First input is the one that is reshaped to produce the output.
 * Second input is a rank 1 tensor specifying the shape of the output.
 * Output tensor has shape as specified by the values in the 2nd input tensor.
 */
message ReshapeDynamicLayerParams {}

/*
 * A layer that decreases the rank of the input tensor by removing unit
 * dimensions.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output rank is one less than input rank, if input rank is more than 1.
 * If input rank is 1, output rank is also 1.
 *
 * e.g.:
 *
 * input shape = (1,1,10,5)
 * axes = (0,1)
 * output shape = (10,5)
 *
 * input shape = (1,10,5,1)
 * axes = (0,3)
 * output shape = (10,5)
 *
 * input shape = (10,5,1,1)
 * axes = (-2,-1)
 * output shape = (10,5)
 *
 * input shape = (1,)
 * axes = (0)
 * output shape = (1,)
 *
 */
message SqueezeLayerParams {
  /*
   * Axis values provided here get removed from the input tensor.
   * Negative indexing is supported.
   */
  repeated int64 axes = 1;
  bool squeezeAll = 2;  // if true squeeze all dimensions that are 1.
}

/*
 * A layer that returns top K (or bottom K) values and the corresponding indices
 * of the input along a given axis.
 *
 * Requires 1 or 2 inputs and produces 2 outputs.
 *
 * The second input is the value of the K, and is optional.
 * If there is only one input, value of K that is specified in the layer
 * parameter is used.
 *
 * Both outputs have the same rank as the first input.
 * Second input must correspond to a scalar tensor.
 *
 * e.g.:
 *
 * first input's shape = (45, 34, 10, 5)
 * axis = 1
 * output shape, for both outputs = (45, K, 10, 5)
 *
 */
message TopKLayerParams {
  int64 axis = 1;  //  negative indexing is supported
  uint64 K = 2;    // is ignored if a second input is present.
  bool useBottomK =
      3;  // if true, bottom K (values, indices) are returned instead
}

/*
 * A layer that returns the indices of the maximum value along a specified axis
 * in a tensor.
 *
 * Requires 1 input and produces 1 output. Negative indexing is supported.
 *
 * Output has the same rank as the input if "removeDim" is False (default).
 * Output has rank one less than the input if "removeDim" is True and input rank
 * is more than 1.
 *
 * e.g.:
 *
 * input shape = (45, 34, 10, 5)
 * axis = -2
 * output shape = (45, 1, 10, 5), if removeDim = False (default)
 * output shape = (45, 10, 5), if removeDim = True
 *
 * input shape = (5,)
 * axis = 0
 * output shape = (1,), if removeDim = False or True
 *
 */
message ArgMaxLayerParams {
  int64 axis = 1;
  bool removeDim = 2;
}

/*
 * A layer that returns the indices of the minimum value along a specified axis
 * in a tensor.
 *
 * Requires 1 input and produces 1 output. Negative indexing is supported.
 *
 * Output has the same rank as the input if "removeDim" is False (default).
 * Output has rank one less than the input if "removeDim" is True and input rank
 * is more than 1.
 *
 * e.g.:
 *
 * input shape = (45, 34, 10, 5)
 * axis = -2
 * output shape = (45, 1, 10, 5), if removeDim = False (default)
 * output shape = (45, 10, 5), if removeDim = True
 *
 * input shape = (5,)
 * axis = 0
 * output shape = (1,), if removeDim = False or True
 *
 */
message ArgMinLayerParams {
  int64 axis = 1;
  bool removeDim = 2;
}

/*
 * A layer layer that splits the input tensor into multiple output tensors,
 * along the specified axis.
 *
 * The layer either uniformly splits the input tensor into ``num_splits``
 * tensors, or splits according to the given split sizes in ``split_sizes``.
 * Supports unequal splits and negative indexing.
 *
 * Requires 1 input and produces at least 2 outputs.
 * Rank of all the outputs is same as that of the input.
 *
 * If parameter "splitSizes" is provided, value of the parameter "numSplits" is
 * ignored, since in that case "numSplits" is automatically inferred to be the
 * length of "splitSizes".
 *
 *
 * e.g.:
 * input shape:  (5, 3, 4)
 * axis = -3, split_sizes = [3, 2]
 * output shape:  (3, 3, 4)
 * output shape:  (2, 3, 4)
 */
message SplitNDLayerParams {
  int64 axis = 1;
  uint64 numSplits = 2;
  repeated uint64 splitSizes = 3;
}

/*
 * A layer that performs element-wise ceil operation on the input tensor that
 * rounds the value to the smallest integer not less than x.
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message CeilLayerParams {}

/*
 * A layer that performs element-wise round operation on the input tensor
 * that rounds the value to the nearest integer.
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message RoundLayerParams {}

/*
 * A layer that performs element-wise floor operation on the input tensor
 * that rounds the value to the largest integer not greater than x.
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message FloorLayerParams {}

/*
 * A layer that performs element-wise sign operation (+1 for positive values,
 * -1 for negative values, 0 for zeros).
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message SignLayerParams {}

/*
 * A layer that performs element-wise clip operation. Clip the values in the
 * input tensor to the threshold values [min_value, max_value].
 *
 * Requires 1 input and produces 1 output.
 *
 * Parameter minVal: the minimum threshold.
 * Parameter maxVal: the maximum threshold.
 *
 * output =  min(max(input, minVal), maxVal)
 *
 * Output shape is same as the input.
 */
message ClipLayerParams {
  float minVal = 1;
  float maxVal = 2;
}

/*
 * A layer that extracts a slice of size ``(end - begin) / stride``
 * from the given input tensor.
 * Support negative indexing and negative strides.
 *
 * Requires 1 input and produces 1 output.
 * Output rank is same as the input rank.
 *
 * Value of beginIds, beginMasks, endIds, endMasks, strides are required
 * parameters. Lengths of all the parameters must equal the rank of the input.
 *
 * i-th element of "beginIds" is ignored and assumed to be 0 if the i-th element
 * of "beginMasks" is True
 *
 * i-th element of "endIds" is ignored and assumed to be -1 if the i-th element
 * of "endMasks" is True
 *
 * e.g.:
 * if i-th element of "squeezeMasks" is set to True, only beginIds[i] would be
 * sliced out, and all other masks and inputs are ignored.
 *
 * e.g. (without squeezeMasks):
 * input shape:  (5, 5, 5)
 * beginIds:  [1, 2, 3]
 * beginMasks:  [True, False, True]
 * endIds:  [3, -3, 2]
 * endMasks:  [False, True, True]
 * strides:  [2, 2, 2]
 * SqueezeMasks:  [False, False, False]
 * output shape:  (2, 2, 3)
 * This is equivalent to input[:3:2, 2::2, ::2]
 *
 * e.g. (with squeezeMasks):
 * input shape:  (5, 5, 5)
 * beginIds:  [1, 2, 3]
 * beginMasks:  [True, False, True]
 * endIds:  [3, -3, 2]
 * endMasks:  [False, True, True]
 * strides:  [2, 2, 2]
 * SqueezeMasks:  [False, True, False]
 * output shape:  (2, 3)
 * This is equivalent to input[:3:2, 2, ::2]
 *
 */
message SliceStaticLayerParams {
  repeated int64 beginIds = 1;
  repeated bool beginMasks = 2;
  repeated int64 endIds = 3;
  repeated bool endMasks = 4;
  repeated int64 strides = 5;
  repeated bool squeezeMasks = 6;
}

/*
 * A layer that extracts a slice of size ``(end - begin) / stride``
 * from the given input tensor.
 * Support negative indexing and negative strides.
 * See "SliceStaticLayerParams" for the description and an example of the
 * functionality of the layer.
 *
 * Requires 2 to 7 inputs and produces 1 output.
 * Rank of the output is same as the rank of the first input unless squeezeMask
 * is set.
 *
 * Value of beginIds, beginMasks, endIds, endMasks, strides can be passed in
 * either as dynamic inputs or as static parameters. Lengths of all the
 * parameters or inputs from 2-6 must equal the rank of the first input.
 *
 * The 2nd input represents the "beginIds".
 * The 3rd input, if present, corresponds to "endIds". In this case the value of
 * the "endIds" parameter is ignored. The 4th input, if present, corresponds to
 * "strides". In this case the value of the "strides" parameter is ignored. The
 * 5th input, if present, corresponds to "beginMasks". In this case the value of
 * the "beginMasks" parameter is ignored. The 6th input, if present, corresponds
 * to "endMasks". In this case the value of the "endMasks" parameter is ignored.
 * The 7th input, if present, corresponds to "squeezeMasks". In this case the
 * value of the "squeezeMasks" parameter is ignored.
 *
 */
message SliceDynamicLayerParams {
  repeated bool beginMasks = 2;
  repeated int64 endIds = 3;
  repeated bool endMasks = 4;
  repeated int64 strides = 5;
  repeated bool squeezeMasks = 6;
}

/*
 * A layer that constructs a tensor by repeating the input tensor multiple
 * number of times.
 *
 * Requires 1 or 2 inputs and produces 1 output.
 * Output rank is same as the input rank.
 *
 * If two inputs are provided, second input is used as "reps"
 * and "reps" parameter is ignored.
 *
 * If only one input is provided,
 * length of the "reps" parameter must be at least 1 and
 * not greater than the rank of the input.
 * If it is less than the input rank, it is made equal to the input rank by
 * prepending 1's to it.
 *
 * e.g.:
 *
 * input shape = (2, 4, 2)
 * reps = (1, 2, 6)
 * output shape = (2, 8, 12)
 *
 * input shape = (2, 4, 2)
 * reps = (6)
 * reps after prepending ones = (1, 1, 6)
 * output shape = (2, 4, 12)
 *
 * input shape = (2, 4, 2)
 * second input = [1, 2, 6] -> shape: (3,)
 * reps = N/A [Ignored]
 * output shape = (2, 8, 12)
 *
 */
message TileLayerParams {
  repeated uint64 reps = 1;
}

/*
 * A layer that returns the shape of an input tensor.
 *
 * Requires 1 input and produces 1 output.
 *
 * Input: a tensor.
 * Output: a vector of length R, where R is the rank of the input tensor
 * Output is always a rank 1 tensor.
 */
message GetShapeLayerParams {}

/*
 * A layer that computes the Gauss error function,
 * which is defined as:
 *
 * .. math::
 *     f(x) = \dfrac{1}{\sqrt{\pi}}\int_{-x}^{x}{e^{-t^2}dt}
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 */
message ErfLayerParams {}

/*
 * A layer that evaluates the Gaussian Error Linear Unit (GELU) activation.
 * Following equations are used to compute the activation based on the value of
 * the "mode" parameter:
 *
 * mode == 'EXACT':
 * .. math::
 *     f(x) = 0.5x\left ( 1+\rm{erf}\left ( \frac{x}{\sqrt{2}} \right ) \right )
 *
 * mode == 'TANH_APPROXIMATION':
 * .. math::
 *     f(x) = 0.5x\left ( 1+\rm{tanh}\left ( \sqrt{2/\pi}\left ( x + 0.044715x^3
 * \right ) \right ) \right )
 *
 * mode == 'SIGMOID_APPROXIMATION':
 * .. math::
 *     f(x) = x*\rm{sigmoid}(1.702x)
 *
 * Requires 1 input and produces 1 output.
 * Output shape is same as the input.
 *
 */
message GeluLayerParams {
  enum GeluMode {
    EXACT = 0;
    TANH_APPROXIMATION = 1;
    SIGMOID_APPROXIMATION = 2;
  }

  GeluMode mode = 1;  // mode of GELU operation.
}

/*
 * RangeStatic layer that returns a tensor that contains evenly spaced values.
 * It is similar in functionality to the numpy.arange method.
 *
 * Requires no input and produces 1 output.
 * Output is a rank 1 tensor.
 */
message RangeStaticLayerParams {
  float endValue = 1;
  float startValue = 2;
  float stepSizeValue = 3;
}

/*
 * A layer that returns a tensor that contains evenly spaced values.
 * Its functionality is similar to the numpy.arange method.
 *
 * Requires at least 1 input, up to a maximum of 3 inputs.
 * Produces 1 output, which is a rank 1 tensor.
 *
 * Each input must be a scalar, or rank 1 and shape (1,).
 *
 * The first input represents the "endValue".
 * The second input, if present, corresponds to "startValue". In this case the
 * value of the "startValue" parameter is ignored. The third input, if present,
 * corresponds to "stepSizeValue". In this case the value of the "stepSizeValue"
 * parameter is ignored.
 *
 */
message RangeDynamicLayerParams {
  float startValue = 2;
  float stepSizeValue = 3;
}

/*
 * A layer that returns a tensor containing all windows of size ``windowSize``
 * separated by ``step`` along the dimension ``axis``.
 *
 * .. code::
 *
 *      y = SlidingWindows(x)
 *
 * Requires 1 input and produces 1 output.
 *
 * Input
 *     An N-Dimensional tensor.
 *
 * Output
 *     An (N+1)-Dimensional tensor.
 *
 * This operation behaves as following:
 *      - if axis = 0 & input is rank 1 (L,). Output shape will be (M, W).
 *      - if axis = 1 & input is rank 3 (B1, L, C1). Output shape will be (B1,
 * M, W, C1)
 *      - if axis = 2 & input is rank 5 (B1, B2, L, C1, C2) --> (B1 * B2, L, C1
 * * C2) --> (B1 * B2, M, W, C1 * C2). Output shape will be (B1, B2, M, W, C1,
 * C2)
 *      - etc.
 * where
 *      - L, C, B refer to input length, feature dimension length & batch size
 * respectively
 *      - W is the window size.
 *      - M is the number of windows/slices calculated as M = (L - W) / step + 1
 */
message SlidingWindowsLayerParams {
  int64 axis = 1;
  uint64 windowSize = 2;
  uint64 step = 3;
}

/*
 * A layer that applies layer normalization over the input tensor.
 *
 * Requires 1 input and produces 1 output.
 *
 * output = gamma * (input - computed_mean) / (sqrt(computed_variance + eps)) +
 * beta
 *
 * Parameters
 *     normalizedShape: subset of the input shape, along with layer norm is
 * performed, rest of the input shape is treated as the batch dimension. The
 * mean and variance are computed for the input, over the last few dimensions as
 * specified by the normalizedShape parameter. gamma: must have shape =
 * "normalizedShape" beta: must have shape = "normalizedShape" eps: small
 * constant to avoid division by 0
 *
 * Output shape is same as the input.
 *
 * e.g.:
 * input shape = (10,5)
 * normalized shape = (5,) or (10,5)
 *
 * input shape = (10,5,6,7)
 * normalized shape = (7,) or (6,7) or (5,6,7) or (10,5,6,7)
 */
message LayerNormalizationLayerParams {
  repeated int64 normalizedShape = 1;
  float eps = 2;
  WeightParams gamma = 3;
  WeightParams beta = 4;
}

/*
 * Non maximum suppression (NMS) layer.
 * Applies the non maximum suppression algorithm to input bounding box
 * coordinates. The effect of this layer is similar to the functionality of the
 * "NonMaximumSuppression" model type (for details please see
 * NonMaximumSuppression.proto) with a couple of differences. One, this is a
 * layer in a neural network model, whereas that is a different model type.
 * Second, this layer supports a batch of bounding boxes.
 *
 * The NMS layer requires at least 2 inputs, and up to a maximum of 5 inputs. It
 * produces 4 outputs. Following is the description of inputs and outputs:
 *
 * input 1, shape (B,N,4): coordinates of N boxes, for a batch size B.
 * input 2, shape (B,N,C): class scores for each box. C can be 1 when there is
 * only 1 score per box, i.e., no class specific score.
 *
 * input 3, optional, shape (1,): IoU threshold. When present, it overwrites the
 * value provided in layer parameter "iouThreshold". input 4, optional, shape
 * (1,): Score threshold. When present, it overwrites the value provided in
 * layer parameter "scoreThreshold". input 5, optional, shape (1,): Maximum
 * number of boxes. When present, it overwrites the value provided in layer
 * parameter "maxBoxes".
 *
 * output 1, shape (B,maxBoxes,4): box coordinates, corresponding to the
 * surviving boxes. output 2, shape (B,maxBoxes,C): box scores, corresponding to
 * the surviving boxes. output 3, shape (B,maxBoxes): indices of the surviving
 * boxes. Hence it will have values in the range [0,N-1], except for padding.
 * output 4, shape (B,): number of boxes selected after the NMS algorithm, for
 * each batch.
 *
 * When surviving boxes are less than "maxBoxes", the first 3 outputs are
 * padded. For the first two outputs, the padding is done using values 0,
 * whereas for the third output the padding value used is -1, since the output
 * values represent indices.
 *
 * If no box survives, that is, all the scores are below the "scoreThreshold",
 * then for that batch, number of boxes (value of the fourth output) will be 1.
 * The first 3 outputs will correspond to the box with the highest score. This
 * is to avoid generating an "empty" output.
 *
 * The four values that describe the box dimensions are (in order):
 *
 *  - x (center location of the box along the horizontal axis)
 *  - y (center location of the box along the vertical axis)
 *  - width (size of box along the horizontal axis)
 *  - height (size of box on along the vertical axis)
 *
 * In each batch,
 * the N scores for N boxes, used for suppression, are generated by taking the
 * max of the matrix (N,C) along the columns. If "perClassSuppression" flag is
 * false, suppression happens across all classes. If "perClassSuppression" flag
 * is true, each box is assigned to the class with the highest score and then
 * the suppression happens separately for boxes within the same class.
 *
 * Note that the 4th output can be used to dynamically slice the first 3
 * outputs, in case the padded outputs are not required.
 *
 */
message NonMaximumSuppressionLayerParams {
  /*
   * The intersection over union (IoU) threshold over which boxes are
   * suppressed.
   */
  float iouThreshold = 1;

  /*
   * Before IoU suppression is performed, boxes with class scores below this
   * threshold are rejected.
   */
  float scoreThreshold = 2;

  /*
   * The maximum number of boxes to be given out as output.
   * If the number of surviving boxes are less, output is padded up to this
   * number.
   */
  uint64 maxBoxes = 3;

  /*
   * If true, suppression is performed independently within boxes of each class.
   */
  bool perClassSuppression = 4;
}

/*
 * A layer that performs element-wise clamped ReLU operation.
 *
 * Requires 1 input and produces 1 output.
 *
 * This function has the following formula:
 *
 * .. math::
 *     f(x) = \begin{cases}
 *               \text{min}(\text{beta},x) \;\; \text{if} \;\; x \geq 0\\
 *               \text{min}(\text{beta} ,\text{alpha}\cdot x) \;\; \text{if}
 * \;\; x<0
 *            \end{cases}
 *
 * Output shape is same as the input.
 *
 * Available (iOS >= 14, macOS >= 11.0, watchOS >= 7)
 */
message ClampedReLULayerParams {
  float alpha = 1;
  float beta = 2;
}

/*
 * A layer that returns the indices that would sort the input tensor, along a
 * specified axis.
 *
 * Requires 1 input and produces 1 output.
 *
 * Output has the same rank and shape as the input.
 *
 * Value of "axis" must be positive and less than the rank of the input.
 *
 * e.g.:
 *
 * input shape = (5,)
 * axis = 0
 * input values = [3.1, 5.4, 32.9, 3.2, 77.0]
 * output shape = (5,)
 * output values = [0, 3, 1, 2, 4], descending = False
 * output values = [4, 2, 1, 3, 0], descending = True
 *
 * input shape = (2,3)
 * axis = 1
 * input values = [[3, 5, 32], [3, 77, 6]]
 * output shape = (2,3)
 * output values = [[0, 1, 2], [0, 2, 1]], descending = False
 * output values = [[2, 1, 0], [1, 2, 0]], descending = True
 *
 */
message ArgSortLayerParams {
  int64 axis = 1;  // must be between [0, input_rank - 1]
  bool descending = 2;
}

/*
 * A layer that does slice operation by providing size to be extracted
 * from the given input tensor.
 *
 * Requires 2 inputs and produces 1 output.
 * Rank of the output is same as the rank of the first input.
 *
 * The 1st input represents the tensor to be sliced.
 * The 2nd input represents the beginning index to be sliced from.
 *
 * Example:
 * Input 1: x (x.shape = (2, 3, 4))
 * Input 2: begin
 * size: 2
 * axis: 1
 *
 * Output: x[:, begin:begin+2, :]
 *
 */
message SliceBySizeLayerParams {
  int64 size = 2;
  int64 axis = 3;
}

// Neural Network Specializations
// ------------------------------

/*
 * A neural network specialized as a classifier.
 */
message NeuralNetworkClassifier {
  repeated NeuralNetworkLayer layers = 1;
  repeated NeuralNetworkPreprocessing preprocessing = 2;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for multiarray inputs
  NeuralNetworkMultiArrayShapeMapping arrayInputShapeMapping = 5;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for image inputs
  NeuralNetworkImageShapeMapping imageInputShapeMapping = 6;

  NetworkUpdateParameters updateParams = 10;

  // The set of labels for every possible class.
  oneof ClassLabels {
    StringVector stringClassLabels = 100;
    Int64Vector int64ClassLabels = 101;
  }

  // The name of the output blob containing the probability of each class.
  // In other words, the score vector. Must be a 1-D tensor with the same
  // number and order of elements as ClassLabels.
  string labelProbabilityLayerName = 200;
}

/*
 * A layer that computes the one hot representation of the input.
 *
 * Requires 1 or 2 inputs and produces 1 output.
 * Rank of the output is one more than the first input.
 * If the second input is present, it is used to determine the value of
 * "oneHotVectorSize" and the parameter "oneHotVectorSize" is ignored.
 *
 * Input values correspond to indices and should typically be in the range
 * [0,"oneHotVectorSize" -1]. If it is outside this range, a vector of all
 * "offValue" will be chosen.
 *
 * Typically one hot vectors contain 0s everywhere, except 1 at the index that
 * the input corresponds to. However, instead of 0, any float value could be
 * generated by using the "offValue" parameter. Similarly, instead of 1, any
 * other value can be used by employing the "onValue" parameter.
 *
 * e.g.:
 * input shape: (10,), "oneHotVectorSize" : 32, axis=-1, then output shape will
 * be (10,32) input shape: (10,23), "oneHotVectorSize" : 32, axis=1, then output
 * shape will be (10,32,23) input shape: (10,), "oneHotVectorSize" : 32, axis=0,
 * then output shape will be (32,10)
 *
 * input shape: (2,), "oneHotVectorSize" : 4, axis=-1, then output shape will be
 * (2,4) say input values = [2, 0], and "onValue" = 5, and "offValue" = -1, then
 * output will be:
 * [-1, -1, 5, -1
 *  5, -1, -1, -1]
 *
 *  say input values = [2, -1], and "onValue" = 5, and "offValue" = -1, then
 * output will be:
 * [-1, -1, 5, -1
 *  -1, -1, -1, -1]
 *
 * Available (iOS >= 14, macOS >= 11.0, watchOS >= 7)
 */

message OneHotLayerParams {
  uint64 oneHotVectorSize = 1;  // size of the one hot vector
  int64 axis = 2;  //  negative indexing is supported. It refers to the axis in
                   //  the output tensor.
  float onValue = 3;
  float offValue = 4;
}

/*
 * A layer that computes the cumsum values of the input along a given axis.
 *
 * Requires 1 or 2 inputs and produces 1 output.
 *
 * Output shape and rank is same as the first input.
 * If the second input is present, it is used to determine the value of "axis"
 * and the parameter "axis" is ignored.
 *
 * e.g.:
 * Input shape = (3,), values it has:  [4, 6, 7]
 *
 * Then output values will be:
 *
 * if "excludeFinalSum" = False and "reverse" = False:
 * output values : [4, 10, 17]
 *
 * if "excludeFinalSum" = True and "reverse" = False:
 * output values : [0, 4, 10]
 *
 * if "excludeFinalSum" = False and "reverse" = True:
 * output values : [17, 13, 7]
 *
 * if "excludeFinalSum" = True and "reverse" = True:
 * output values : [13, 7, 0]
 *
 *
 * Available (iOS >= 14, macOS >= 11.0, watchOS >= 7)
 */

message CumSumLayerParams {
  int64 axis = 1;  //  negative indexing is supported

  // if true, the first element of the output is 0, and the last element
  // contains the sum of the input up to the penultimate value if false, the
  // first element of the output is same as the input and the last element is
  // the sum of all the input values (this behavior is reversed when "reverse"
  // flag is True)
  bool excludeFinalSum = 2;

  bool reverse = 3;  // if true, cumsum is performed in the opposite direction
}

/*
 * A neural network specialized as a regressor.
 */
message NeuralNetworkRegressor {
  repeated NeuralNetworkLayer layers = 1;
  repeated NeuralNetworkPreprocessing preprocessing = 2;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for multiarray inputs
  NeuralNetworkMultiArrayShapeMapping arrayInputShapeMapping = 5;

  // use this enum value to determine the input tensor shapes to the neural
  // network, for image inputs
  NeuralNetworkImageShapeMapping imageInputShapeMapping = 6;

  NetworkUpdateParameters updateParams = 10;
}

// ---------------------------------------------------------
// On-device Training related messages
// ---------------------------------------------------------

/*
 * Details on how the network will be updated
 */
message NetworkUpdateParameters {
  repeated LossLayer lossLayers = 1;
  Optimizer optimizer = 2;
  Int64Parameter epochs = 3;

  /*
   * Describes whether to shuffle the batch of data between epochs.
   */
  BoolParameter shuffle = 10;

  /*
   * The seed to be used in an associated random number generator.
   */
  Int64Parameter seed = 20;
}

/*
 * Loss layer - categorical cross entropy and mean squared error are the only
 * supported loss functions currently
 */
message LossLayer {
  string name = 1;
  oneof LossLayerType {
    CategoricalCrossEntropyLossLayer categoricalCrossEntropyLossLayer = 10;
    MeanSquaredErrorLossLayer meanSquaredErrorLossLayer = 11;
  }
}

/*
 * Categorical cross entropy loss layer
 * Categorical cross entropy is used for single label categorization (only one
 * category is applicable for each data point).
 *
 * The input is a vector of length N representing the distribution over N
 * categories.  It must be the output of a softmax.
 *
 * The target is a single value representing the true category or class label.
 * If the target is the predictedFeatureName of a neural network classifier it
 * will be inverse mapped to the corresponding categorical index for you.
 *
 * math:
 * Loss_{CCE}(input, target) = -\sum_{i=1}^{N} (target == i) log( input[i] ) = -
 * log (input[target])
 */
message CategoricalCrossEntropyLossLayer {
  string input = 1;
  string target = 2;
}

/*
 * Mean squared error loss layer,
 * specifying input and target
 */
message MeanSquaredErrorLossLayer {
  string input = 1;
  string target = 2;
}

/*
 * Optimizer - stochastic gradient descent and adam are the only supported
 * optimizers currently
 */
message Optimizer {
  oneof OptimizerType {
    SGDOptimizer sgdOptimizer = 10;
    AdamOptimizer adamOptimizer = 11;
  }
}

/*
 * Stochastic gradient descent optimizer,
 * specifying configurable learning rate, mini batch size, and momentum
 */
message SGDOptimizer {
  DoubleParameter learningRate = 1;
  Int64Parameter miniBatchSize = 2;
  DoubleParameter momentum = 3;
}

/*
 * Adam optimizer,
 * specifying configurable learning rate, mini batch size, betas, and eps
 */
message AdamOptimizer {
  DoubleParameter learningRate = 1;
  Int64Parameter miniBatchSize = 2;
  DoubleParameter beta1 = 3;
  DoubleParameter beta2 = 4;
  DoubleParameter eps = 5;
}