# Copyright 2020 The OneFlow Authors. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

# The following data types are allowed,
# {
#   "Tensor", "TensorTuple", "Scalar", "Int", "Int32", "Int64", "Float", "Double", "String", "Bool",
#   "ScalarList", "IntList", "Int32List", "Int64List", "FloatList", "DoubleList", "StringList",
#   "BoolList", "DataType", "Shape", "Generator", "TensorIndex", "Device", "Placement",
#   "Sbp", "SbpList"
# }

- name: "add"
  signature:
    [
      "Tensor (Tensor input, Tensor other, *, Scalar alpha=1, Bool inplace=False) => Add",
      "Tensor (Tensor input, Scalar other, *, Scalar alpha=1, Bool inplace=False) => ScalarAdd",
      "Tensor (Scalar input, Tensor other, *, Scalar alpha=1) => ScalarAdd",
      "Tensor (TensorTuple inputs, *, Bool inplace=False) => Add",
    ]
  bind_python: true

- name: "amin"
  signature: "Tensor (Tensor input, Int32List[1] dim=None, Bool keepdim=False) => Amin"
  bind_python: True

- name: "sub"
  signature:
    [
      "Tensor (Tensor input, Tensor other, *, Scalar alpha=1, Bool inplace=False) => Sub",
      "Tensor (Tensor input, Scalar other, *, Scalar alpha=1, Bool inplace=False) => ScalarSub",
      "Tensor (Scalar input, Tensor other, *, Scalar alpha=1) =>  ScalarSub",
    ]
  bind_python: true

- name: "mul"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => Mul",
      "Tensor (Tensor input, Scalar other, *, Bool inplace=False) => ScalarMul",
      "Tensor (Scalar input, Tensor other) => ScalarMul",
    ]
  bind_python: true

- name: "mul_"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => InplaceMul",
      "Tensor (Tensor input, Scalar other) => InplaceScalarMul",
    ]
  bind_python: true

- name: "addcmul"
  signature: "Tensor (Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1) => Addcmul"
  bind_python: true

- name: "addcmul_"
  signature: "Tensor (Tensor input, Tensor tensor1, Tensor tensor2, *, Scalar value=1) => InplaceAddcmul"
  bind_python: true

- name: "div"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => Div",
      "Tensor (Tensor input, Scalar other) => ScalarDiv",
      "Tensor (Scalar input, Tensor other) => ScalarDiv",
    ]
  bind_python: true

- name: "div_"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => InplaceDiv",
      "Tensor (Tensor input, Scalar other) => InplaceScalarDiv",
    ]
  bind_python: true

- name: "div_grad"
  signature: "Tensor (Tensor y, Tensor z, Tensor dz) => DivGrad"
  bind_python: False

- name: "equal"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastEqual",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalEqual",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalEqual",
    ]
  bind_python: true

- name: "not_equal"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastNotEqual",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalNotEqual",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalNotEqual",
    ]
  bind_python: true

- name: "greater"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastGreater",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalGreater",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalGreater",
    ]
  bind_python: true

- name: "greater_equal"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastGreaterEqual",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalGreaterEqual",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalGreaterEqual",
    ]
  bind_python: true

- name: "logical_and"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastLogicalAnd",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalAnd",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalAnd",
    ]
  bind_python: true

- name: "logical_or"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastLogicalOr",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalOr",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalOr",
    ]
  bind_python: true

- name: "logical_not"
  signature: "Tensor (Tensor input) => LogicalNot"
  bind_python: true

- name: "logical_xor"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastLogicalXor",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalXor",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalXor",
    ]
  bind_python: true

- name: "less"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastLess",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalLess",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalLess",
    ]
  bind_python: True

- name: "less_equal"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastLessEqual",
      "Tensor (Tensor input, Scalar other) => ScalarLogicalLessEqual",
      "Tensor (Scalar input, Tensor other) => ScalarLogicalLessEqual",
    ]
  bind_python: True

- name: "pow"
  signature:
    [
      "Tensor (Tensor input, Tensor exponent) => Pow",
      "Tensor (Tensor input, Scalar exponent, *, Bool inplace=False) => ScalarPow",
      "Tensor (Tensor input, Scalar exponent) => ScalarPow",
      "Tensor (Scalar exponent, Tensor input) => ScalarReversePow",
    ]
  bind_python: True

- name: "pow_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => PowXGrad"
  bind_python: False

- name: "pow_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => PowYGrad"
  bind_python: False

- name: "searchsorted"
  signature:
    [
      'Tensor (Tensor sorted_sequence, Tensor values, Bool out_int32=False, Bool right=False) => SearchSorted',
      'Tensor (Tensor sorted_sequence, Scalar values, Bool out_int32=False, Bool right=False) => SearchSortedScalar',
    ]
  bind_python: True

- name: "scalar_pow_grad"
  signature: "Tensor (Tensor input, Tensor dy, Scalar exponent) => ScalarPowGrad"
  bind_python: False

- name: "scalar_reverse_pow_grad"
  signature: "Tensor (Tensor input, Tensor dy, Scalar exponent) => ScalarReversePowGrad"
  bind_python: False

- name: "broadcast_pow"
  signature: "Tensor (Tensor x, Tensor y) => BroadcastPow"
  bind_python: False

- name: "broadcast_pow_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y, Tensor z) => BroadcastPowXGrad"
  bind_python: False

- name: "broadcast_pow_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y, Tensor z) => BroadcastPowYGrad"
  bind_python: False

- name: "floor_divide"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => FloorDiv",
      "Tensor (Tensor input, Scalar other, *, Bool inplace=False) => ScalarFloorDiv",
      "Tensor (Tensor input, Scalar other) => ScalarFloorDiv",
    ]
  bind_python: True

- name: "floordiv_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => FloorDivXGrad"
  bind_python: False

- name: "floordiv_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => FloorDivYGrad"
  bind_python: False

- name: "xdivy_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => XdivyXGrad"
  bind_python: False

- name: "xdivy_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => XdivyYGrad"
  bind_python: False

- name: "xlogy_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => XlogyXGrad"
  bind_python: False

- name: "xlogy_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => XlogyYGrad"
  bind_python: False

- name: "max"
  signature: [
    "Tensor (Tensor input) => Max",
    "TensorTuple (Tensor input, Int32 dim, Bool keepdim=False) => Max",
    "Tensor (Tensor input, Tensor other) => Max"
  ]
  bind_python: True

- name: "min"
  signature: [
    "Tensor (Tensor input) => Min",
    "TensorTuple (Tensor input, Int32 dim, Bool keepdim=False) => Min",
    "Tensor (Tensor input, Tensor other) => Min"
  ]
  bind_python: True

- name: "median"
  signature: [
    "Tensor (Tensor input) => Median",
    "TensorTuple (Tensor input, Int32 dim=-1, Bool keepdim=False) => MedianWithIndices",
  ]
  bind_python: True

- name: "reduce_max"
  signature: "Tensor (Tensor x, Int32List axis, Bool keepdim=False) => ReduceMax"
  bind_python: True

- name: "reduce_min"
  signature: "Tensor (Tensor x, Int32List axis, Bool keepdim=False) => ReduceMin"
  bind_python: True

- name: "reduce_sum"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim, Bool keepdim=False) => ReduceSum", 
    "Tensor (Tensor x) => ReduceSumWhole"
  ]
  bind_python: True

- name: "reduce_mean"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim, Bool keepdim=False) => ReduceMean",
    "Tensor (Tensor x) => ReduceMeanWhole"
  ]
  bind_python: True

- name: "reduce_all"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim, Bool keepdim=False) => ReduceAll",
    "Tensor (Tensor x) => ReduceAllWhole"
  ]
  bind_python: True

- name: "reduce_any"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim, Bool keepdim=False) => ReduceAny",
    "Tensor (Tensor x) => ReduceAnyWhole"
  ]
  bind_python: True

- name: "reduce_prod"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim, Bool keepdim=False, *, DataType dtype=None) => ReduceProd",
    "Tensor (Tensor x, *, DataType dtype=None) => ReduceProdWhole",
  ]
  bind_python: True

- name: "reduce_min_device_stage"
  signature: "TensorTuple (Tensor in, Int32List axis) => ReduceMinDeviceStage"
  bind_python: True

- name: "reduce_min_device_stage_grad"
  signature: "Tensor (Tensor out_diff, Tensor mask, Tensor count, Int32List axis) => ReduceMinDeviceStageGrad"
  bind_python: False

- name: "reduce_max_device_stage"
  signature: "TensorTuple (Tensor in, Int32List axis) => ReduceMaxDeviceStage"
  bind_python: True

- name: "reduce_max_device_stage_grad"
  signature: "Tensor (Tensor out_diff, Tensor mask, Tensor count, Int32List axis) => ReduceMaxDeviceStageGrad"
  bind_python: False

- name: "reduce_min_global_stage"
  signature: "TensorTuple (Tensor in, Tensor device_count, Int32List axis, Bool keepdims=False) => ReduceMinGlobalStage"
  bind_python: True

- name: "reduce_min_global_stage_grad"
  signature: "Tensor (Tensor out_diff, Tensor mask, Tensor device_count, Int32List axis, Bool keepdims=False) => ReduceMinGlobalStageGrad"
  bind_python: False

- name: "reduce_max_global_stage"
  signature: "TensorTuple (Tensor in, Tensor device_count, Int32List axis, Bool keepdims=False) => ReduceMaxGlobalStage"
  bind_python: True

- name: "reduce_max_global_stage_grad"
  signature: "Tensor (Tensor out_diff, Tensor mask, Tensor device_count, Int32List axis, Bool keepdims=False) => ReduceMaxGlobalStageGrad"
  bind_python: False

- name: "transpose"
  signature:
    [
      "Tensor (Tensor input, Int32List perm) => Transpose",
      "Tensor (Tensor input, Int32 dim0, Int32 dim1) => Transpose2dim",
    ]
  bind_python: True

- name: "as_strided"
  signature: "Tensor (Tensor input, Int32List size, Int32List stride, Int32 storage_offset=0) => AsStrided"
  bind_python: True

- name: "as_strided_grad"
  signature: "Tensor (Tensor dy, Tensor input, Int32List size, Int32List stride, Int32 storage_offset=0) => AsStridedGrad"
  bind_python: False

- name: "select"
  signature: "Tensor (Tensor input, Int32 dim, Int32 index) => Select"
  bind_python: True

- name: "swapaxes"
  signature: "Tensor (Tensor input, Int32 dim0, Int32 dim1) => Swapaxes"
  bind_python: True

- name: "swapdims"
  signature: "Tensor (Tensor input, Int32 dim0, Int32 dim1) => Swapdims"
  bind_python: True

- name: "amax"
  signature: "Tensor (Tensor input, Int32List[1] dim=None, Bool keepdim=False) => Amax"
  bind_python: True

- name: "permute"
  signature: "Tensor (Tensor input, Int32List dims) => Permute"
  bind_python: True

- name: "T"
  signature: "Tensor (Tensor input) => TransposeAllDimProperty"
  bind_python: True

- name: "t"
  signature: "Tensor (Tensor input) => TransposeAllDimFunction"
  bind_python: True 

- name: "not_equal_zero"
  signature: "Tensor (Tensor x) => NotEqualZero"
  bind_python: False

- name: "not_equal_zero_grad"
  signature: "Tensor (Tensor x, Tensor dy) => NotEqualZeroGrad"
  bind_python: False

- name: "reciprocal"
  signature: "Tensor (Tensor x) => Reciprocal"
  bind_python: True

- name: "reciprocal_grad"
  signature: "Tensor (Tensor x, Tensor dy) => ReciprocalGrad"
  bind_python: False

- name: "reciprocal_no_nan"
  signature: "Tensor (Tensor x) => ReciprocalNoNan"
  bind_python: True

- name: "reciprocal_no_nan_grad"
  signature: "Tensor (Tensor x, Tensor dy) => ReciprocalNoNanGrad"
  bind_python: False

- name: "image_flip"
  signature: "Tensor (Tensor x, Tensor flip_code) => ImageFlip"
  bind_python: True

- name: "sin"
  signature: "Tensor (Tensor x) => Sin"
  bind_python: True

- name: "sin_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SinGrad"
  bind_python: False

- name: "sin_grad_grad"
  signature: "Tensor (Tensor x, Tensor dydx) => SinGradGrad"
  bind_python: False

- name: "sin_"
  signature: "Tensor (Tensor x) => Sin_"
  bind_python: True

- name: "cos"
  signature: "Tensor (Tensor x) => Cos"
  bind_python: True

- name: "cos_grad"
  signature: "Tensor (Tensor x, Tensor dy) => CosGrad"
  bind_python: False

- name: "cos_grad_grad"
  signature: "Tensor (Tensor x, Tensor dydx) => CosGradGrad"
  bind_python: False

- name: "cosh"
  signature: "Tensor (Tensor x) => Cosh"
  bind_python: True

- name: "cosh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => CoshGrad"
  bind_python: True

- name: "fmod"
  signature:
    [
      "Tensor (Tensor input, Tensor other) => BroadcastFMod",
      "Tensor (Tensor input, Scalar other, *, Bool inplace=False) => ScalarFMod",
      "Tensor (Tensor input, Scalar other) => ScalarFMod",
    ]
  bind_python: true

- name: "log"
  signature: "Tensor (Tensor x) => Log"
  bind_python: True

- name: "log_grad"
  signature: "Tensor (Tensor x, Tensor dy) => LogGrad"
  bind_python: False

- name: "log2"
  signature: "Tensor (Tensor x) => Log2"
  bind_python: True

- name: "log2_grad"
  signature: "Tensor (Tensor x, Tensor dy) => Log2Grad"
  bind_python: False

- name: "sqrt"
  signature: "Tensor (Tensor x) => Sqrt"
  bind_python: True

- name: "sqrt_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SqrtGrad"
  bind_python: False

- name: "rsqrt"
  signature: "Tensor (Tensor x) => Rsqrt"
  bind_python: True

- name: "rsqrt_grad"
  signature: "Tensor (Tensor x, Tensor dy) => RsqrtGrad"
  bind_python: False

- name: "square"
  signature: "Tensor (Tensor x) => Square"
  bind_python: True

- name: "square_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SquareGrad"
  bind_python: False

- name: "sqrt_square_sum"
  signature: "Tensor (Tensor x) => SqrtSquareSum"
  bind_python: True

- name: "std"
  signature: "Tensor (Tensor x, Int32List[1] dim=None, Bool unbiased=None, Bool keepdim=None) => StandardDeviation"
  bind_python: True

- name: "var"
  signature: "Tensor (Tensor x, Int32List[1] dim=None, Bool unbiased=None, Bool keepdim=None) => Variance"
  bind_python: True

- name: "relu"
  signature: "Tensor (Tensor x, Bool inplace=False) => Relu"
  bind_python: True

- name: "relu_grad"
  signature: "Tensor (Tensor dy, Tensor y) => ReluGrad"
  bind_python: False

- name: "hardtanh"
  signature: "Tensor (Tensor x, Double min_val, Double max_val) => HardTanh"
  bind_python: True

- name: "hardtanh_grad"
  signature: "Tensor (Tensor y, Tensor dy, Double min_val, Double max_val) => HardTanhGrad"
  bind_python: False

- name: "tan"
  signature: "Tensor (Tensor x) => Tan"
  bind_python: True

- name: "tan_grad"
  signature: "Tensor (Tensor x, Tensor dy) => TanGrad"
  bind_python: True

- name: "tanh"
  signature: "Tensor (Tensor x) => Tanh"
  bind_python: True

- name: "tanh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => TanhGrad"
  bind_python: True

- name: "threshold"
  signature: "Tensor (Tensor x, *, Double threshold, Double value) => Threshold"
  bind_python: True

- name: "threshold_grad"
  signature: "Tensor (Tensor x, Tensor dy, Double threshold) => ThresholdGrad"
  bind_python: False

- name: "elu"
  signature: "Tensor (Tensor x, Double alpha) => Elu"
  bind_python: True

- name: "elu_grad"
  signature: "Tensor (Tensor x, Tensor dy, Double alpha) => EluGrad"
  bind_python: False

- name: "celu"
  signature: "Tensor (Tensor x, *, Double alpha=1.0, Bool inplace=False) => Celu"
  bind_python: True

- name: "celu_grad"
  signature: "Tensor (Tensor x, Tensor dy, Double alpha=1.0) => CeluGrad"
  bind_python: False

- name: "gelu"
  signature: "Tensor (Tensor x) => Gelu"
  bind_python: True

- name: "gelu_grad"
  signature: "Tensor (Tensor dy, Tensor x) => GeluGrad"
  bind_python: False

- name: "glu"
  signature: "Tensor (Tensor input, Int64 dim=-1) => Glu"
  bind_python: True

- name: "sigmoid"
  signature: "Tensor (Tensor x) => Sigmoid"
  bind_python: True

- name: "sigmoid_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SigmoidGrad"
  bind_python: True

- name: "hardsigmoid"
  signature: "Tensor (Tensor input, Bool inplace=False, *) => HardSigmoid"
  bind_python: True

- name: "hardsigmoid_grad"
  signature: "Tensor (Tensor dy, Tensor x) => HardSigmoidGrad"
  bind_python: False

- name: "hardshrink"
  signature: "Tensor (Tensor x, *, Double lambd=0.5, Bool inplace=False) => HardShrink"
  bind_python: True

- name: "hardshrink_grad"
  signature: "Tensor (Tensor y, Tensor dy, Double lambd=0.5) => HardShrinkGrad"
  bind_python: False

- name: "softmax"
  signature: "Tensor (Tensor x, Int64 dim=None) => Softmax"
  bind_python: True

- name: "softmax_grad"
  signature: "Tensor (Tensor dy, Tensor y) => SoftmaxGrad"
  bind_python: False

- name: "log_softmax"
  signature: "Tensor (Tensor x, Int64 dim=None) => LogSoftmax"
  bind_python: True

- name: "hardswish"
  signature: "Tensor (Tensor x) => HardSwish"
  bind_python: True

- name: "hardswish_grad"
  signature: "Tensor (Tensor dy, Tensor x) => HardSwishGrad"
  bind_python: False

- name: "leaky_relu"
  signature: "Tensor (Tensor x, Float alpha, Bool inplace=False) => LeakyRelu"
  bind_python: True

- name: "leaky_relu_grad"
  signature: "Tensor (Tensor x, Tensor dy, Float alpha) => LeakyReluGrad"
  bind_python: False

- name: "normal"
  signature: [
    "Tensor (Float mean, Float std, Shape size, *, Tensor out=None, DataType dtype=None, Device device=None, 
    Generator generator=None, Bool requires_grad=False) => Normal",
    "Tensor (Float mean, Float std, Int32 size, *, Tensor out=None, DataType dtype=None, Device device=None, 
    Generator generator=None, Bool requires_grad=False) => Normal2",
    "Tensor (Float mean, Float std, Shape size, *, Tensor out=None, Placement placement, SbpList sbp, DataType dtype=None,
    Generator generator=None, Bool requires_grad=False) => ConsistentNormal",
    "Tensor (Float mean, Float std, Int32 size, *, Tensor out=None, Placement placement, SbpList sbp, DataType dtype=None,
    Generator generator=None, Bool requires_grad=False) => ConsistentNormal2",
    ]
  bind_python: True

- name: "normalization"
  signature:
    "Tensor (Tensor x, Tensor moving_mean=None, Tensor moving_variance=None,
    Tensor gamma=None, Tensor beta=None, Int32 axis=1, Float epsilon=1e-5,
    Float momentum=0.9, Bool is_training=False) => Normalization"

  bind_python: True

- name: "normalization_grad"
  signature:
    "TensorTuple (Tensor grad, Tensor x, Tensor mean, Tensor inv_variance,
    Tensor gamma, Float epsilon, Int32 axis) => NormalizationGrad"
  bind_python: False

- name: "normalization_add_relu"
  signature:
    "Tensor (Tensor x, Tensor addend=None, Tensor moving_mean=None, Tensor moving_variance=None,
    Tensor gamma, Tensor beta, Int32 axis=1, Float epsilon=1e-5,
    Float momentum=0.9, Bool is_training=False) => NormalizationAddRelu"
  bind_python: True

- name: "normalization_add_relu_grad"
  signature:
    "TensorTuple (Tensor x, Tensor dy, Tensor moving_mean, Tensor moving_variance,
    Tensor gamma, Tensor beta, Tensor reserve_space, Tensor y, Int32 axis=1, 
    Float epsilon=1e-5, Bool has_addend) => NormalizationAddReluGrad"
  bind_python: False

- name: "eye"
  signature: [
    "Tensor (Scalar n, Scalar m=None, *, DataType dtype=kFloat, Device device=None, Bool requires_grad=False) => Eye",
    "Tensor (Scalar n, Scalar m=None, *, DataType dtype=kFloat, String device, Bool requires_grad=False) => Eye",
    "Tensor (Scalar n, Scalar m=None, *, DataType dtype=kFloat, Bool requires_grad=False, Placement placement, SbpList sbp) => Eye",
    "Tensor (Scalar n, Scalar m=None, *, DataType dtype=kFloat, Bool requires_grad=False, Placement placement, Sbp sbp) => Eye",
    ]
  bind_python: True

- name: "erfinv"
  signature: "Tensor (Tensor x) => Erfinv"
  bind_python: True

- name: "erfinv_"
  signature: "Tensor (Tensor x) => ErfinvInplace"
  bind_python: True

- name: "arange"
  signature: [
      "Tensor (Scalar start, Scalar end, Scalar step=1, *, DataType dtype=None,
      Device device=None) => Arange",
      "Tensor (Scalar end, *, DataType dtype=None, Device device=None) => Arange",
    ]
  bind_python: True

- name: "global_arange"
  signature: [
      "Tensor (Scalar start, Scalar end, Scalar step=1, *, DataType dtype=None,
      Placement placement, SbpList sbp) => ConsistentArange",
      "Tensor (Scalar end, *, DataType dtype=None, Placement placement, SbpList sbp) => ConsistentArange",
    ]
  bind_python: True

- name: "flatten"
  signature: "Tensor (Tensor x, Int32 start_dim=0, Int32 end_dim=-1) => Flatten"
  bind_python: True

- name: "argmax"
  signature: "Tensor (Tensor x, Int32 dim=None, Bool keepdim=None, DataType dtype=None) => ArgMax"
  bind_python: True

- name: "argmin"
  signature: "Tensor (Tensor x, Int32 dim=None, Bool keepdim=None, DataType dtype=None) => ArgMin"
  bind_python: True

- name: "argwhere"
  signature: "TensorTuple (Tensor x, DataType dtype=kInt32) => ArgWhere"
  bind_python: True

- name: "broadcast_like"
  signature: "Tensor (Tensor x, Tensor like, Int32List broadcast_axes=[]) => BroadcastLike"
  bind_python: True

- name: "cast"
  signature: "Tensor (Tensor x, DataType dtype, Bool pin_memory=False) => Cast"
  bind_python: True

- name: "constant"
  signature:
    [
      "Tensor (Shape shape, Scalar value, *, DataType dtype, Device device=None) => Constant",
    ]
  bind_python: True

- name: "global_constant"
  signature:
    [
      "Tensor (Shape shape, Scalar value, *, DataType dtype, Placement placement, SbpList sbp) => ConsistentConstant",
    ]
  bind_python: True

- name: "empty"
  signature: "Tensor (Shape shape, *, DataType dtype, Device device=None, Bool pin_memory=False) => Empty"
  bind_python: True

- name: "global_empty"
  signature:
    [
      "Tensor (Shape shape, *, DataType dtype, Placement placement, SbpList sbp) => ConsistentEmpty",
    ]
  bind_python: True

- name: "zeros_like"
  signature: "Tensor (Tensor x) => ZerosLike"
  bind_python: True

- name: "ones_like"
  signature: "Tensor (Tensor x) => OnesLike"
  bind_python: True

- name: "bernoulli"
  signature:
    [
      "Tensor (Tensor x, *, DataType dtype=kFloat, Generator generator=None) => Bernoulli",
    ]
  bind_python: True

- name: "concat"
  signature: "Tensor (TensorTuple inputs, Int64 dim=0) => Concat"
  bind_python: True

- name: "bias_add"
  signature: "Tensor (Tensor x, Tensor bias, Int32 axis=1) => BiasAdd"
  bind_python: True

- name: "conv1d"
  signature:
    "Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[1] stride=1,
    Int32List[1] padding=0, Int32List[1] dilation=1, Int32 groups=1,
    String channel_pos=\"channels_first\") => Conv1d"
  bind_python: True

- name: "conv2d"
  signature:
    "Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[2] stride=1,
    Int32List[2] padding=0, Int32List[2] dilation=1, Int32 groups=1,
    String channel_pos=\"channels_first\") => Conv2d"
  bind_python: True

- name: "conv3d"
  signature:
    "Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[3] stride=1,
    Int32List[3] padding=0, Int32List[3] dilation=1, Int32 groups=1,
    String channel_pos=\"channels_first\") => Conv3d"
  bind_python: True

- name: "fake_quantization"
  signature:
    "Tensor (Tensor in, Tensor scale, Tensor zero_point, String quantization_formula,
    Int32 quantization_bit, String quantization_scheme) => FakeQuantization"
  bind_python: True

- name: "quantization"
  signature:
    "Tensor (Tensor in, Tensor scale, Tensor zero_point, String quantization_formula,
    Int32 quantization_bit, String quantization_scheme) => Quantization"
  bind_python: True

- name: "min_max_observer"
  signature:
    "TensorTuple (Tensor in, String quantization_formula, Int32 quantization_bit,
    String quantization_scheme, Bool per_layer_quantization) => MinMaxObserver"
  bind_python: True

- name: "moving_average_min_max_observer"
  signature:
    "TensorTuple (Tensor in, Tensor current_train_step, Tensor moving_max, Tensor moving_min,
    Bool training, Int64 stop_update_after_iters, String quantization_formula, 
    Int32 quantization_bit, String quantization_scheme, Float momentum) => MovingAverageMinMaxObserver"
  bind_python: True

- name: "conv_data_grad"
  signature:
    'Tensor (Tensor dy, Tensor weight, Tensor x, Int32 num_spatial_dims,
    Int32List kernel_size, Int32List strides, Int32List padding_before,
    Int32List dilation_rate, Int32 groups=1,
    String data_format="channels_first") => ConvDataGrad'
  bind_python: False

- name: "conv_filter_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Int32 num_spatial_dims, Int32List kernel_size,
    Int32List strides, Int32List padding_before, Int32List dilation_rate,
    Int32 groups=1, String data_format="channels_first") => ConvFilterGrad'
  bind_python: False

- name: "conv_bias_grad"
  signature: 'Tensor (Tensor dy, Int32 num_spatial_dims,
    String data_format="channels_first") => ConvBiasGrad'
  bind_python: False

- name: "deconv1d"
  signature:
    'Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[1] stride=1, 
    Int32List[1] padding=0, Int32List[1] output_padding=0, Int32 groups=1, 
    Int32List[1] dilation=1, String data_format="channels_first") => Deconv1d'
  bind_python: True

- name: "deconv2d"
  signature:
    'Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[2] stride=1, 
    Int32List[2] padding=0, Int32List[2] output_padding=0, Int32 groups=1, 
    Int32List[2] dilation=1, String data_format="channels_first") => Deconv2d'
  bind_python: True

- name: "deconv3d"
  signature:
    'Tensor (Tensor x, Tensor weight, Tensor bias=None, Int32List[3] stride=1, 
    Int32List[3] padding=0, Int32List[3] output_padding=0, Int32 groups=1, 
    Int32List[3] dilation=1, String data_format="channels_first") => Deconv3d'
  bind_python: True

- name: "expand"
  signature: "Tensor (Tensor x, Shape shape) => Expand"
  bind_python: True

- name: "expand_grad"
  signature: "Tensor (Tensor dy, Int32List out, Int32List expand) => ExpandGrad"
  bind_python: False

- name: "repeat"
  signature: "Tensor (Tensor input, Shape repeat_shape) => Repeat"
  bind_python: True

- name: "repeat_interleave_index"
  signature: "Tensor (Tensor input, Tensor cumsum, Int32 dim) => RepeatInterLeaveIndex"
  bind_python: False

- name: "repeat_interleave"
  signature: [
    "Tensor (Tensor input, Int32 repeats, Int32 dim=None) => RepeatInterLeaveInt",
    "Tensor (Tensor input, Tensor repeats, Int32 dim, Int32 output_size=None) => RepeatInterLeaveTensor",
  ]
  bind_python: True

- name: "tile"
  signature: "Tensor (Tensor input, Shape dims) => Tile"
  bind_python: True

- name: "roll"
  signature: "Tensor (Tensor x, Int32List[1] shifts, Int32List[1] dims=None) => Roll"
  bind_python: True

- name: "expand_dims"
  signature: "Tensor (Tensor input, Int32 dim) => ExpandDims"
  bind_python: True

- name: "unsqueeze"
  signature: "Tensor (Tensor input, Int32 dim) => Unsqueeze"
  bind_python: True

- name: "squeeze"
  signature: [
    "Tensor (Tensor x, Int32List[1] dim=None) => Squeeze",
  ]
  bind_python: True

- name: "exp"
  signature: "Tensor (Tensor x) => Exp"
  bind_python: True

- name: "exp_grad"
  signature: "Tensor (Tensor x, Tensor dy) => ExpGrad"
  bind_python: False

- name: "gather"
  signature: "Tensor (Tensor x, Tensor indices, Int64 axis) => Gather"
  bind_python: True

- name: "dim_gather"
  signature: " Tensor (Tensor input, Int64 dim, Tensor index, Bool sparse_grad=False) => DimGather"
  bind_python: True

- name: "embedding_renorm_"
  signature: " Tensor (Tensor in, Tensor indices, Double max_norm, Double norm_type) => EmbeddingReNorm"
  bind_python: True

- name: "embedding"
  signature: " Tensor (Tensor weight, Tensor indices, Int64 padding_idx=None, Bool scale_grad_by_freq=False) => Embedding"
  bind_python: True

- name: "embedding_grad"
  signature: " Tensor (Tensor dy, Tensor weight, Tensor indices, Int64 padding_idx, Bool scale_grad_by_freq=False) => EmbeddingGrad"
  bind_python: False

- name: "arg_sort"
  signature: "Tensor (Tensor in, String direction) => ArgSort"
  bind_python: True

- name: "gather_nd"
  signature: "Tensor (Tensor params, Tensor indices) => GatherNd"
  bind_python: True

- name: "scatternd"
  signature: "Tensor (Tensor indices, Tensor updates, Shape shape) => ScatterNd"
  bind_python: True

- name: "tensor_scatter_nd_update"
  signature: "Tensor (Tensor tensor, Tensor indices, Tensor updates, Bool inplace=False) => TensorScatterNdUpdate"
  bind_python: True

- name: "scatterndlike"
  signature: "Tensor (Tensor like, Tensor updates, Tensor indices) => ScatterNdLike"
  bind_python: True

- name: "matmul"
  signature:
    "Tensor (Tensor input, Tensor other, Bool transpose_a=False, Bool transpose_b=False,
    Double alpha=1.0) => MatMul"
  bind_python: True

- name: "mm"
  signature:
    "Tensor (Tensor input, Tensor mat2) => MatMulNoBroadCast"
  bind_python: True

- name: "mv"
  signature:
    "Tensor (Tensor input, Tensor vec) => Mv"
  bind_python: True

- name: "fused_mlp"
  signature:
    "Tensor (Tensor x, TensorTuple weights, TensorTuple biases, Bool skip_final_activation) => FusedMLP"
  bind_python: True

- name: "cublas_bias_add_relu_matmul_grad"
  signature:
    "TensorTuple (Tensor dy, Tensor weight, Tensor aux, Double alpha=1.0) => CublasBiasAddReluMatmulGrad"
  bind_python: False

- name: "cublas_matmul_bias_add_grad"
  signature:
    "TensorTuple (Tensor dy, Tensor x) => CublasMatmulBiasAddGrad"
  bind_python: False

- name: "fused_matmul_bias_add_relu_dropout"
  signature:
    "Tensor (Tensor x, TensorTuple weights, TensorTuple biases, Bool skip_final_activation, FloatList dropout_rate_list, Generator generator=None) => FusedMatmulBiasAddReluDropout"
  bind_python: True

- name: "fused_relu_dropout_grad"
  signature:
    "Tensor (Tensor dy, Tensor mask, Float scale) => FusedReluDropoutGrad"
  bind_python: False

- name: "broadcast_matmul_grad_b"
  signature: "Tensor (Tensor a, Tensor b, Double alpha=1.0) => BroadcastMatmulGradB"
  bind_python: False

- name: "batch_matmul"
  signature:
    "Tensor (Tensor a, Tensor b, Bool transpose_a=False, Bool transpose_b=False,
    Double alpha=1.0) => BatchMatMul"
  bind_python: True

- name: "tensordot"
  signature: [
    "Tensor (Tensor a, Tensor b, Int32List dims_a, Int32List dims_b) => TensorDot",
    "Tensor (Tensor a, Tensor b, Int32 dims) => TensorDotIntDims"
  ]
  bind_python: True

- name: "l1_loss"
  signature: "Tensor(Tensor input, Tensor target, String reduction) => L1Loss"
  bind_python: True

- name: "mse_loss"
  signature: "Tensor(Tensor input, Tensor target, String reduction) => MseLoss"
  bind_python: True

- name: "kl_div_loss"
  signature: "Tensor(Tensor input, Tensor target, Bool log_target, String reduction) => KLDivLoss"
  bind_python: True

- name: "kl_div_loss_grad"
  signature: "Tensor(Tensor dy, Tensor input, Tensor target, Bool log_target) => KLDivLossGrad"
  bind_python: False

- name: "nll_loss"
  signature: "Tensor(Tensor input, Tensor target, Tensor weight=None, Int64 ignore_index, String reduction) => NLLLoss"
  bind_python: True

- name: "nll_grad"
  signature: "Tensor(Tensor out_grad, Tensor input, Tensor target, Tensor weight=None, Int64 ignore_index) => NLLGrad"
  bind_python: False

- name: "binary_cross_entropy_loss"
  signature: "Tensor(Tensor input, Tensor target, Tensor weight=None, String reduction) => BinaryCrossEntropyLoss"
  bind_python: True

- name: "binary_cross_entropy_loss_grad"
  signature: "Tensor(Tensor dy, Tensor input, Tensor target, Tensor weight=None) => BinaryCrossEntropyLossGrad"
  bind_python: False

- name: "binary_cross_entropy_with_logits_loss"
  signature: "Tensor(Tensor input, Tensor target, Tensor weight=None, Tensor pos_weight=None, String reduction) => BinaryCrossEntropyWithLogitsLoss"
  bind_python: True

- name: "binary_cross_entropy_with_logits_loss_grad"
  signature: "Tensor(Tensor dy, Tensor input, Tensor target, Tensor weight=None, Tensor pos_weight=None) => BinaryCrossEntropyWithLogitsLossGrad"
  bind_python: True

- name: "binary_cross_entropy_with_logits_reduce_mean_loss_grad"
  signature: "Tensor(Tensor dy, Tensor input, Tensor target) => BinaryCrossEntropyWithLogitsReduceMeanLossGrad"
  bind_python: False

- name: "sparse_cross_entropy"
  signature: "Tensor (Tensor prediction, Tensor label, Int64 depth) => SparseCrossEntropy"
  bind_python: True

- name: "sparse_cross_entropy_grad"
  signature: "Tensor (Tensor prediction, Tensor label, Tensor dy, Int64 depth) => SparseCrossEntropyGrad"
  bind_python: False

- name: "distributed_sparse_cross_entropy"
  signature: "Tensor (Tensor prediction, Tensor label, Int64 depth) => SparseCrossEntropyMs"
  bind_python: True

- name: "cross_entropy"
  signature: "Tensor(Tensor input, Tensor target, Tensor weight=None, Int64 ignore_index=-100, String reduction=\"mean\") => CrossEntropy"
  bind_python: True

- name: "distributed_sparse_cross_entropy_grad"
  signature: "Tensor (Tensor prediction, Tensor label, Tensor dy, Int64 depth) => SparseCrossEntropyMsGrad"
  bind_python: False

- name: "sparse_softmax_cross_entropy"
  signature: "Tensor (Tensor logits, Tensor label) => SparseSoftmaxCrossEntropy"
  bind_python: True

- name: "sparse_softmax_cross_entropy_grad"
  signature: "Tensor (Tensor dy, Tensor prob, Tensor label, Int64 depth) => SparseSoftmaxCrossEntropyGrad"
  bind_python: False

- name: "softmax_cross_entropy"
  signature: "Tensor (Tensor logits, Tensor label) => SoftmaxCrossEntropy"
  bind_python: True

- name: "softmax_cross_entropy_grad"
  signature: "Tensor (Tensor dy, Tensor label, Tensor prob) => SoftmaxCrossEntropyGrad"
  bind_python: True

- name: "smooth_l1_loss"
  signature: "Tensor (Tensor logits, Tensor label, Float beta, String reduction) => SmoothL1Loss"
  bind_python: True

- name: "smooth_l1_loss_grad"
  signature: "Tensor (Tensor loss_grad, Tensor prediction, Tensor label, Float beta) => SmoothL1LossGrad"
  bind_python: False

- name: "combined_margin_loss"
  signature: "Tensor (Tensor x, Tensor label, Float m1, Float m2, Float m3) => CombinedMarginLoss"
  bind_python: True

- name: "combined_margin_loss_grad"
  signature: "Tensor (Tensor dy, Tensor label, Tensor theta, Float m1, Float m2, Float m3, Int64 depth) => CombinedMarginLossGrad"
  bind_python: False


- name: "triplet_margin_loss"
  signature: "Tensor (Tensor anchor, Tensor positive, Tensor negative, *, Float margin, Float p, Float eps, Bool swap, String reduction) => TripletMarginLoss"
  bind_python: True
  
- name: "margin_ranking_loss"
  signature: "Tensor (Tensor input_1, Tensor input_2, Tensor target, Float margin, String reduction) => MarginRankingLoss"
  bind_python: True

- name: "ctc_loss"
  signature: "Tensor (Tensor log_probs, Tensor targets, Tensor input_lengths, Tensor target_lengths, Int64 max_target_length, Int32 blank, Bool zero_infinity, String reduction) => CtcLoss"
  bind_python: True

- name: "affine_grid"
  signature: "Tensor (Tensor theta, *, Shape size, Bool align_corners) => AffineGrid"
  bind_python: True

- name: "affine_grid_grad"
  signature: "Tensor (Tensor dgrid, *, Shape size, Bool align_corners) => AffineGridGrad"
  bind_python: False

- name: "grid_sample"
  signature: "Tensor (Tensor input, Tensor grid, *, String interpolation_mode, String padding_mode, Bool align_corners) => GridSample"
  bind_python: True

- name: "grid_sample_grad"
  signature: "TensorTuple (Tensor doutput, Tensor input, Tensor grid, *, String interpolation_mode, String padding_mode, Bool align_corners) => GridSampleGrad"
  bind_python: False

- name: "where"
  signature:
    [
      "Tensor (Tensor condition, Tensor x, Tensor y) => Where",
      "Tensor (Tensor condition, Scalar x, Tensor y) => WhereScalarX",
      "Tensor (Tensor condition, Tensor x, Scalar y) => WhereScalarY",
      "Tensor (Tensor condition, Scalar x, Scalar y) => WhereScalarXY",
    ]
  bind_python: true

- name: "masked_fill"
  signature: "Tensor (Tensor x, Tensor mask, Scalar value) => MaskedFill"
  bind_python: true

- name: "movedim"
  signature: [
    "Tensor (Tensor input, Int32 source, Int32 destination) => MovedimInt",
    "Tensor (Tensor input, Int32List source, Int32List destination) => MovedimVec",
  ]
  bind_python: True

- name: "tensor_split"
  signature: [
    "TensorTuple (Tensor input, Int32 indices_or_sections, Int32 dim=0) => TensorSplitInt",
    "TensorTuple (Tensor input, Int32List indices_or_sections, Int32 dim=0) => TensorSplitVec",
  ]
  bind_python: True

- name: "hsplit"
  signature: [
    "TensorTuple (Tensor input, Int32 indices_or_sections) => HsplitInt",
    "TensorTuple (Tensor input, Int32List indices_or_sections) => HsplitVec",
  ]
  bind_python: True

- name: "vsplit"
  signature: [
    "TensorTuple (Tensor input, Int32 indices_or_sections) => VsplitInt",
    "TensorTuple (Tensor input, Int32List indices_or_sections) => VsplitVec",
  ]
  bind_python: True

- name: "negative"
  signature: "Tensor (Tensor x) => Negative"
  bind_python: True

- name: "negative_grad"
  signature: "Tensor (Tensor x, Tensor dy) => NegativeGrad"
  bind_python: False

- name: "layer_norm_affine"
  signature:
    "Tensor (Tensor x, Tensor gamma, Tensor beta, Int64 begin_norm_axis,
    Int64 begin_params_axis, Double epsilon) => LayerNormAffine"
  bind_python: True

- name: "layer_norm"
  signature: "Tensor (Tensor x, Int64 begin_norm_axis, Int64 begin_params_axis, Double epsilon) => LayerNorm"
  bind_python: True

- name: "layer_norm_grad"
  signature: "Tensor (Tensor dy, Tensor x, Tensor mean, Tensor inv_variance, Int64 begin_norm_axis, Double epsilon) => LayerNormGrad"
  bind_python: False

- name: "layer_norm_affine_grad"
  signature: "Tensor (Tensor dy, Tensor x, Tensor mean, Tensor inv_variance, Tensor gamma, Int64 begin_norm_axis, Double epsilon) => LayerNormAffineGrad"
  bind_python: False

- name: "layer_norm_param_grad"
  signature: "TensorTuple (Tensor dy, Tensor x, Tensor mean, Tensor inv_variance, Int64 begin_params_axis, Double epsilon) => LayerNormParamGrad"
  bind_python: False

- name: "avg_pool2d_nhwc"
  signature:
    'Tensor (Tensor x, Int32List kernel_size, Int32List stride, String padding,
    Int32List padding_before, Int32List padding_after,
    String data_format="channels_first", Bool ceil_mode=False) => TFAvgPool2D'
  bind_python: True

- name: "ctc_loss_grad"
  signature:
    "Tensor (Tensor loss_grad, Tensor log_probs, Tensor targets,
      Tensor input_lengths, Tensor target_lengths, Tensor loss, Tensor alpha, Int32 blank, Bool zero_infinity, Int64 max_target_length) => CtcLossGrad"
  bind_python: False

- name: "adaptive_avg_pool1d"
  signature: "Tensor (Tensor x, Int64List[1] output_size) => AdaptiveAvgPool1D"
  bind_python: True

- name: "adaptive_avg_pool2d"
  signature: "Tensor (Tensor x, Int64List[2] output_size) => AdaptiveAvgPool2D"
  bind_python: True

- name: "adaptive_avg_pool3d"
  signature: "Tensor (Tensor x, Int64List[3] output_size) => AdaptiveAvgPool3D"
  bind_python: True

- name: "adaptive_pool_grad"
  signature: "Tensor (Tensor x, Tensor dy, String mode, Int32 ndims) => AdaptivePoolNdGrad"

- name: "tf_pool_grad"
  signature:
    "Tensor (Tensor x, Tensor y, Tensor dy, String mode, Int32 ndims, String data_format,
    String padding, Int32List padding_before, Int32List padding_after, Int32List pool_size,
    Int32List strides, Bool ceil_mode) => TFPoolNdGrad"
  bind_python: False

- name: "max_pool1d"
  signature:
    'TensorTuple (Tensor input, Int32List[1] kernel_size, Int32List[1] stride=None,
    Int32List[1] padding=0, Int32List[1] dilation=1,
    Bool return_indices=True, Bool ceil_mode=False,
    String data_format="channels_first") => MaxPool1D'
  bind_python: True

- name: "max_pool2d"
  signature:
    'TensorTuple (Tensor input, Int32List[2] kernel_size, Int32List[2] stride=None,
    Int32List[2] padding=0, Int32List[2] dilation=1,
    Bool return_indices=True, Bool ceil_mode=False,
    String data_format="channels_first") => MaxPool2D'
  bind_python: True

- name: "max_pool3d"
  signature:
    'TensorTuple (Tensor input, Int32List[3] kernel_size, Int32List[3] stride=None,
    Int32List[3] padding=0, Int32List[3] dilation=1,
    Bool return_indices=True, Bool ceil_mode=False,
    String data_format="channels_first") => MaxPool3D'
  bind_python: True

- name: "max_pool_grad"
  signature:
    "Tensor (Tensor x, Tensor indice, Tensor dy, Int32 ndims,
    String data_format, Int32List padding, Int32List kernel_size,
    Int32List stride, Int32List dilation, Bool return_indices, Bool ceil_mode) => MaxPoolNdGrad"
  bind_python: False

- name: "prelu"
  signature: "Tensor (Tensor x, Tensor alpha) => PRelu"
  bind_python: True

- name: "prelu_grad"
  signature: "TensorTuple (Tensor dy, Tensor x, Tensor alpha) => PReluGrad"
  bind_python: False

- name: "reshape"
  signature: "Tensor (Tensor x, Shape shape) => Reshape"
  bind_python: True

- name: "view"
  signature: "Tensor (Tensor x, Shape shape) => View"
  bind_python: True

- name: "contiguous"
  signature: "Tensor (Tensor input) => ToContiguous"
  bind_python: True

- name: "contiguous_"
  signature: "Tensor (Tensor input) => InplaceToContiguous"
  bind_python: True

- name: "slice_view_1d_contiguous"
  signature: "Tensor (Tensor x, Int64 start, Int64 end) => SliceView1dContiguous"
  bind_python: True

- name: "narrow"
  signature: "Tensor (Tensor input, Int64 dim, Int64 start, Int64 length) => Narrow"
  bind_python: True

- name: "narrow_grad"
  signature: "Tensor (Tensor dy, Tensor like, Int64 dim, Int64 start, Int64 length) => NarrowGrad"
  bind_python: False

- name: "slice"
  signature: "Tensor (Tensor x, Int64List start, Int64List stop, Int64List step, Bool enable_view_slice=None) => Slice"
  bind_python: True

- name: "slice_update"
  signature: "Tensor (Tensor ref, Tensor value, Int64List start, Int64List stop, Int64List step, Bool inplace=False) => SliceUpdate"
  bind_python: True

- name: "slice_grad"
  signature: "Tensor (Tensor dy, Shape like_shape, Int64List start, Int64List stop, Int64List step) => SliceGrad"
  bind_python: False

- name: "copy"
  signature: "Tensor (Tensor x, String device_type, Int64 device_id, Bool pin_memory=False) => Copy"
  bind_python: True

- name: "to"
  signature: [
    # type of device must be string for global tensor to perform argument validation
    "Tensor (Tensor x, String device=None, DataType dtype=None, Bool copy=False) => To",
    "Tensor (Tensor x, Device device=None, DataType dtype=None, Bool copy=False) => To",
    "Tensor (Tensor x, DataType dtype=None, Bool copy=False) => To",
    "Tensor (Tensor x, Tensor other, Bool copy=False) => To"
  ]
  bind_python: True

- name: "flip"
  signature: "Tensor (Tensor x, Int32List dims) => Flip"
  bind_python: True

- name: "upsample"
  signature:
    'Tensor (Tensor x, Double height_scale, Double width_scale, Bool align_corners,
    String interpolation, String data_format="channels_first") => Upsample'
  bind_python: True

- name: "upsample_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double height_scale, Double width_scale, Bool align_corners,
    String data_format, String interpolation) => UpsampleGrad'
  bind_python: False

- name: "upsample_linear_1d"
  signature: 'Tensor (Tensor x, Double scale_factor=0.0, Bool align_corners=False, Int64List[1] output_size=None, 
    String data_format="channels_first") => UpsampleLinear1D'
  bind_python: True

- name: "upsample_linear_1d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double scale_factor=0.0, Bool align_corners=False, Int64List[1] output_size=None, 
    String data_format="channels_first") => UpsampleLinear1DGrad'
  bind_python: False

- name: "upsample_nearest_1d"
  signature: 'Tensor (Tensor x, Double scale_factor=0.0, Int64List[1] output_size=None, 
    String data_format="channels_first") => UpsampleNearest1D'
  bind_python: True

- name: "upsample_nearest_1d_grad"
  signature: 'Tensor (Tensor dy, Tensor x, Double scale_factor=0.0, Int64List[1] output_size=None, 
    String data_format="channels_first") => UpsampleNearest1DGrad'
  bind_python: False

- name: "upsample_nearest_2d"
  signature: 'Tensor (Tensor x, Double height_scale=0.0, Double width_scale=0.0, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleNearest2D'
  bind_python: True

- name: "upsample_nearest_2d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double height_scale=0.0, Double width_scale=0.0, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleNearest2DGrad'
  bind_python: False

- name: "upsample_bilinear_2d"
  signature:
    'Tensor (Tensor x, Double height_scale=0.0, Double width_scale=0.0, Bool align_corners=False, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleBilinear2D'
  bind_python: True

- name: "upsample_bilinear_2d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double height_scale=0.0, Double width_scale=0.0, Bool align_corners=False, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleBilinear2DGrad'
  bind_python: False

- name: "upsample_bicubic_2d"
  signature:
    'Tensor (Tensor x, Double height_scale=0.0, Double width_scale=0.0, Bool align_corners=False, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleBicubic2D'
  bind_python: True

- name: "upsample_bicubic_2d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double height_scale=0.0, Double width_scale=0.0, Bool align_corners=False, Int64List[2] output_size=None, 
    String data_format="channels_first") => UpsampleBicubic2DGrad'
  bind_python: False

- name: "upsample_nearest_3d"
  signature:
    'Tensor (Tensor x, Double depth_scale=0.0, Double height_scale=0.0, Double width_scale=0.0, Int64List[3] output_size=None, 
    String data_format="channels_first") => UpsampleNearest3D'
  bind_python: True

- name: "upsample_nearest_3d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double depth_scale=0.0, Double height_scale=0.0, Double width_scale=0.0, Int64List[3] output_size=None, 
    String data_format="channels_first") => UpsampleNearest3DGrad'
  bind_python: False

- name: "upsample_trilinear_3d"
  signature:
    'Tensor (Tensor x, Double depth_scale=0.0, Double height_scale=0.0, Double width_scale=0.0, Bool align_corners=False, 
    Int64List[3] output_size=None, String data_format="channels_first") => UpsampleTrilinear3D'
  bind_python: True

- name: "upsample_trilinear_3d_grad"
  signature:
    'Tensor (Tensor dy, Tensor x, Double depth_scale=0.0, Double height_scale=0.0, Double width_scale=0.0,
    Bool align_corners=False, Int64List[3] output_size=None, String data_format="channels_first") => UpsampleTrilinear3DGrad'
  bind_python: False

- name: "abs"
  signature: "Tensor (Tensor x) => Abs"
  bind_python: True

- name: "abs_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AbsGrad"
  bind_python: False

- name: "acos"
  signature: "Tensor (Tensor x) => Acos"
  bind_python: True

- name: "acos_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AcosGrad"
  bind_python: False

- name: "acosh"
  signature: "Tensor (Tensor x) => Acosh"
  bind_python: True

- name: "acosh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AcoshGrad"
  bind_python: False

- name: "asin"
  signature: "Tensor (Tensor x) => Asin"
  bind_python: True

- name: "asin_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AsinGrad"
  bind_python: False

- name: "asinh"
  signature: "Tensor (Tensor x) => Asinh"
  bind_python: True

- name: "asinh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AsinhGrad"
  bind_python: False

- name: "atan"
  signature: "Tensor (Tensor x) => Atan"
  bind_python: True

- name: "atan_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AtanGrad"
  bind_python: False

- name: "atan2"
  signature: "Tensor (Tensor input, Tensor other) => Atan2"
  bind_python: True

- name: "atan2_x_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => Atan2XGrad"
  bind_python: False

- name: "atan2_y_grad"
  signature: "Tensor (Tensor dz, Tensor x, Tensor y) => Atan2YGrad"
  bind_python: False

- name: "atanh"
  signature: "Tensor (Tensor x) => Atanh"
  bind_python: True

- name: "atanh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => AtanhGrad"
  bind_python: False

- name: "ceil"
  signature: "Tensor (Tensor x) => Ceil"
  bind_python: True

- name: "ceil_grad"
  signature: "Tensor (Tensor x, Tensor dy) => CeilGrad"
  bind_python: False

- name: "erf"
  signature: "Tensor (Tensor x) => Erf"
  bind_python: True

- name: "erf_grad"
  signature: "Tensor (Tensor x, Tensor dy) => ErfGrad"
  bind_python: False

- name: "erfc"
  signature: "Tensor (Tensor x) => Erfc"
  bind_python: True

- name: "erfc_grad"
  signature: "Tensor (Tensor x, Tensor dy) => ErfcGrad"
  bind_python: False

- name: "expm1"
  signature: "Tensor (Tensor x) => Expm1"
  bind_python: True

- name: "expm1_grad"
  signature: "Tensor (Tensor x, Tensor dy) => Expm1Grad"
  bind_python: False

- name: "floor"
  signature: "Tensor (Tensor x) => Floor"
  bind_python: True

- name: "floor_"
  signature: "Tensor (Tensor x) => Floor_"
  bind_python: True

- name: "floor_grad"
  signature: "Tensor (Tensor x, Tensor dy) => FloorGrad"
  bind_python: False

- name: "lgamma"
  signature: "Tensor (Tensor x) => Lgamma"
  bind_python: True

- name: "lgamma_grad"
  signature: "Tensor (Tensor x, Tensor dy) => LgammaGrad"
  bind_python: False

- name: "log1p"
  signature: "Tensor (Tensor x) => Log1p"
  bind_python: True

- name: "log1p_grad"
  signature: "Tensor (Tensor x, Tensor dy) => Log1pGrad"
  bind_python: False

- name: "logsigmoid"
  signature: "Tensor (Tensor x) => LogSigmoid"
  bind_python: True

- name: "logsigmoid_grad"
  signature: "Tensor (Tensor x, Tensor dy) => LogSigmoidGrad"
  bind_python: False

- name: "rint"
  signature: "Tensor (Tensor x) => Rint"
  bind_python: True

- name: "rint_grad"
  signature: "Tensor (Tensor x, Tensor dy) => RintGrad"
  bind_python: False

- name: "round"
  signature: "Tensor (Tensor x) => Round"
  bind_python: True

- name: "round_grad"
  signature: "Tensor (Tensor x, Tensor dy) => RoundGrad"
  bind_python: False

- name: "sign"
  signature: "Tensor (Tensor x) => Sign"
  bind_python: True

- name: "sign_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SignGrad"
  bind_python: False

- name: "sinh"
  signature: "Tensor (Tensor x) => Sinh"
  bind_python: True

- name: "sinh_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SinhGrad"
  bind_python: False

- name: "softplus"
  signature: "Tensor (Tensor x, Double beta=1.0, Double threshold=20.0) => Softplus"
  bind_python: True

- name: "softplus_grad"
  signature: "Tensor (Tensor x, Tensor dy, Double beta=1.0, Double threshold=20.0) => SoftplusGrad"
  bind_python: False

- name: "softshrink"
  signature: "Tensor (Tensor x, *, Double alpha=0.5, Bool inplace=False) => SoftShrink"
  bind_python: True

- name: "softshrink_grad"
  signature: "Tensor (Tensor y, Tensor dy, Double alpha=0.5) => SoftShrinkGrad"
  bind_python: False

- name: "one_hot"
  signature: "Tensor (Tensor input, Int64 num_classes=-1, Scalar on_value=1, Scalar off_value=0) => OneHot"
  bind_python: True

- name: "unsorted_segment_sum_like"
  signature: "Tensor (Tensor x, Tensor segment_ids, Tensor like, Int64 axis) => UnsortedSegmentSumLike"
  bind_python: False

- name: "tril"
  signature: "Tensor (Tensor x, Int64 diagonal=0) => Tril"
  bind_python: True

- name: "triu"
  signature: "Tensor (Tensor x, Int64 diagonal=0) => Triu"
  bind_python: True

- name: "clamp"
  signature:
    ["Tensor (Tensor input, Scalar min=None, Scalar max=None) => Clamp"]
  bind_python: true

- name: "clamp_"
  signature:
    ["Tensor (Tensor input, Scalar min=None, Scalar max=None) => ClampInplace"]
  bind_python: true

- name: "clip"
  signature:
    ["Tensor (Tensor input, Scalar min=None, Scalar max=None) => Clip"]
  bind_python: true

- name: "clip_"
  signature:
    ["Tensor (Tensor input, Scalar min=None, Scalar max=None) => ClipInplace"]
  bind_python: true

- name: "clamp_grad"
  signature: "Tensor (Tensor dy, Tensor x, Scalar min=None, Scalar max=None) => ClampGrad"
  bind_python: False

- name: "vector_norm"
  signature: 
    [
      "Tensor (Tensor input, Scalar ord=2, Int32List dim=None, Bool keepdim=False, *, DataType dtype=None) => VectorNorm",
      "Tensor (Tensor input, Scalar ord=2, Scalar dim, Bool keepdim=False, *, DataType dtype=None) => VectorNorm",
    ]
  bind_python: True

- name: "matrix_norm"
  signature: 
    [
      "Tensor (Tensor input, Scalar ord, Int32List dim, Bool keepdim=False, *, DataType dtype=None) => MatrixNorm",
      "Tensor (Tensor input, String ord, Int32List dim, Bool keepdim=False, *, DataType dtype=None) => MatrixNorm",
    ]
  bind_python: True

- name: "norm"
  signature: 
    [
      "Tensor (Tensor input, Scalar ord=None, Int32List dim=None, Bool keepdim=False, *, DataType dtype=None) => Norm",
      "Tensor (Tensor input, String ord, Int32List dim=None, Bool keepdim=False, *, DataType dtype=None) => Norm",
      "Tensor (Tensor input, Scalar ord=None, Scalar dim, Bool keepdim=False, *, DataType dtype=None) => ScalarNorm",
      "Tensor (Tensor input, String ord, Scalar dim, Bool keepdim=False, *, DataType dtype=None) => ScalarNorm",
    ]
  bind_python: True

- name: "dropout"
  signature: "Tensor (Tensor input, Float p=0.5, Bool training=True, Bool inplace=False, Generator generator=None, *, Tensor addend=None) => Dropout"
  bind_python: True

- name: "dropout_grad"
  signature: "Tensor (Tensor dy, Tensor mask, Float scale) => DropoutGrad"
  bind_python: False

- name: "pad"
  signature: 'Tensor (Tensor x, Int64List pad, String mode="constant", Scalar value=0) => Pad'
  bind_python: True

- name: "pad_grad"
  signature: 'Tensor (Tensor dy, Int64List pad, String mode="constant", Scalar value=0) => PadGrad'
  bind_python: False

- name: "silu"
  signature: "Tensor (Tensor x) => Silu"
  bind_python: True

- name: "silu_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SiluGrad"
  bind_python: False

- name: "mish"
  signature: "Tensor (Tensor x) => Mish"
  bind_python: True

- name: "mish_grad"
  signature: "Tensor (Tensor x, Tensor dy) => MishGrad"
  bind_python: False

- name: "selu"
  signature: "Tensor (Tensor x) => Selu"
  bind_python: True

- name: "selu_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SeluGrad"
  bind_python: False

- name: "softsign"
  signature: "Tensor (Tensor x) => SoftSign"
  bind_python: True

- name: "softsign_grad"
  signature: "Tensor (Tensor x, Tensor dy) => SoftSignGrad"
  bind_python: False

- name: "diag"
  signature: "Tensor (Tensor x, Int32 diagonal=0) => Diag"
  bind_python: True

- name: "diag_grad"
  signature: "Tensor (Tensor dy, Tensor in, Int32 diagonal=0) => DiagGrad"
  bind_python: False

- name: "diagonal"
  signature: "Tensor (Tensor x, Int32 offset=0, Int32 dim1=0, Int32 dim2=1) => Diagonal"
  bind_python: True

- name: "diagonal_grad"
  signature: "Tensor (Tensor dy, Tensor in, Int32 offset=0) => DiagonalGrad"
  bind_python: False

- name: "tensor_getitem"
  signature: "Tensor (Tensor x, TensorIndex index) => TensorGetItem"
  bind_python: False

- name: "scatter"
  signature:
    [
      "Tensor (Tensor input, Int32 dim, Tensor index, Tensor src) => DimScatter",
      "Tensor (Tensor input, Int32 dim, Tensor index, Scalar src) => DimScatterUpdateScalar",
    ]
  bind_python: True

- name: "scatter_add"
  signature:
    [
      "Tensor (Tensor input, Int32 dim, Tensor index, Tensor src) => DimScatterAdd",
      "Tensor (Tensor input, Int32 dim, Tensor index, Scalar src) => DimScatterAddScalar",
    ]
  bind_python: True

- name: "scatter_add_like"
  signature: "Tensor (Tensor like, Int32 dim, Tensor index, Tensor src) => DimScatterAddLike"
  bind_python: False

- name: "tensor_setitem"
  signature: "Void (Tensor x, TensorIndex index, Tensor value) => TensorSetItem"
  bind_python: True

- name: "avg_pool1d"
  signature:
    'Tensor (Tensor input, Int32List[1] kernel_size, Int32List[1] stride=None, 
             Int32List[1] padding=0, Bool ceil_mode=False, Bool count_include_pad=True,
             Int32 divisor_override=0, String data_format="channels_first") => AvgPool1D'
  bind_python: True

- name: "avg_pool2d"
  signature:
    'Tensor (Tensor input, Int32List[2] kernel_size, Int32List[2] stride=None, 
             Int32List[2] padding=0, Bool ceil_mode=False, Bool count_include_pad=True,
             Int32 divisor_override=0, String data_format="channels_first") => AvgPool2D'
  bind_python: True

- name: "avg_pool3d"
  signature:
    'Tensor (Tensor input, Int32List[3] kernel_size, Int32List[3] stride=None, 
             Int32List[3] padding=0, Bool ceil_mode=False, Bool count_include_pad=True,
             Int32 divisor_override=0, String data_format="channels_first") => AvgPool3D'
  bind_python: True

- name: "avg_pool_grad"
  signature:
    "Tensor (Tensor x, Tensor dy, Int32 ndims, String data_format, Int32List padding,
    Int32List kernel_size, Int32List stride, Bool ceil_mode, Bool count_include_pad,
    Int32 divisor_override=0) => AvgPoolNdGrad"
  bind_python: False

- name: "minimum"
  signature: "Tensor (Tensor input, Tensor other) => Minimum"
  bind_python: True

- name: "maximum"
  signature: "Tensor (Tensor input, Tensor other) => Maximum"
  bind_python: True

- name: "elementwise_min_grad"
  signature: "TensorTuple (Tensor dz, Tensor x, Tensor y) => ElementwiseMinGrad"
  bind_python: False

- name: "elementwise_max_grad"
  signature: "TensorTuple (Tensor dz, Tensor x, Tensor y) => ElementwiseMaxGrad"
  bind_python: False

- name: "stack"
  signature: "Tensor (TensorTuple inputs, Int64 dim=0) => Stack"
  bind_python: True

- name: "stack_grad"
  signature: "TensorTuple (Tensor x, TensorTuple like, Int64 axis) => StackGrad"
  bind_python: False

- name: "local_to_global"
  signature: "Tensor (Tensor x, Placement placement, SbpList sbp, Shape shape, DataType dtype) => LocalToConsistent"
  bind_python: False

- name: "to_global"
  signature: "Tensor (Tensor x, Placement placement, SbpList sbp, SbpList grad_sbp, Bool check_meta) => ToConsistent"
  bind_python: True

- name: "to_local"
  signature: "Tensor (Tensor x) => ConsistentToLocal"
  bind_python: True

- name: "stream_touch"
  signature: "Void (TensorTuple x) => StreamTouch"
  bind_python: True

- name: "broadcast"
  signature: "Tensor (Tensor x, *, Int64 src_rank=0, Bool inplace=True) => Broadcast"
  bind_python: True

- name: "local_all_reduce"
  signature: "Tensor (Tensor x, Bool inplace=False) => LocalAllReduce"
  bind_python: True

- name: "local_reduce"
  signature: "Tensor (Tensor x, *, Int64 dst=0, Bool inplace=True) => LocalReduce"
  bind_python: True

- name: "eager_p_to_b"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, Shape shape) => EagerPToB"
  bind_python: False

- name: "eager_b_to_s"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, SbpList out_sbp, Shape shape) => EagerBToS"
  bind_python: False

- name: "eager_s_to_b"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, SbpList in_sbp, Shape shape) => EagerSToB"
  bind_python: False

- name: "eager_naive_s_to_s"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, SbpList in_sbp, SbpList out_sbp, Shape shape) => EagerNaiveSToS"
  bind_python: False

- name: "eager_p_to_s"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, SbpList out_sbp, Shape shape) => EagerPToS"
  bind_python: False

- name: "eager_s_to_p"
  signature: "Tensor (Tensor x, Placement in_placement, Placement out_placement, SbpList out_sbp, Shape shape) => EagerSToP"
  bind_python: False

- name: "global_all_reduce"
  signature: "Tensor (Tensor x) => ConsistentAllReduce"
  bind_python: False

- name: "global_reduce_scatter"
  signature: "Tensor (Tensor x, String op_type) => ConsistentReduceScatter"
  bind_python: False

- name: "global_all_gather"
  signature: "Tensor (Tensor x) => ConsistentAllGather"
  bind_python: False

- name: "global_s2s"
  signature: "Tensor (Tensor x, SbpList out_sbp) => ConsistentS2S"
  bind_python: False

- name: "select_top_n"
  signature: "TensorTuple (TensorTuple inputs, Int32 n) => SelectTopN"
  bind_python: True

- name: "cast_like"
  signature: "Tensor (Tensor x, Tensor like) => CastLike"
  bind_python: False

- name: "identity"
  signature: "Tensor (Tensor in) => Identity"
  bind_python: True

- name: "amp_white_identity"
  signature: "Tensor (Tensor in) => AmpWhiteIdentity"
  bind_python: True

- name: "reshape_like"
  signature: "Tensor (Tensor in, Tensor like) => ReshapeLike"
  bind_python: True

- name: "reduce_sum_like"
  signature: "Tensor (Tensor in, Tensor like, Int32List axis) => ReduceSumLike"
  bind_python: True

- name: "broadcast_reduce_sum_like"
  signature: "Tensor (Tensor in, Tensor like) => BroadcastReduceSumLike"
  bind_python: False

- name: "rand"
  signature: [
      "Tensor (Shape size, *, DataType dtype=None, Device device=None,
      Generator generator=None, Bool requires_grad=False) => Rand",
      "Tensor (Shape size, *, Placement placement, SbpList sbp, DataType dtype=None,
      Generator generator=None, Bool requires_grad=False) => ConsistentRand",
    ]
  bind_python: True

- name: "randn"
  signature: [
      "Tensor (Shape size, *, DataType dtype=None, Device device=None,
      Generator generator=None, Bool requires_grad=False) => RandN",
      "Tensor (Shape size, *, Placement placement, SbpList sbp, DataType dtype=None,
      Generator generator=None, Bool requires_grad=False) => ConsistentRandN",
    ]
  bind_python: True

- name: "randint"
  signature: [
      "Tensor (Int64 low, Int64 high, Shape size, *, DataType dtype=None,
      Device device=None, Generator generator=None, Bool requires_grad=False)=> RandInt",
      "Tensor (Int64 high, Shape size, *, DataType dtype=None,
      Device device=None, Generator generator=None, Bool requires_grad=False)=> RandInt",
      "Tensor (Int64 low, Int64 high, Shape size, *, Placement placement, SbpList sbp,
      DataType dtype=None, Generator generator=None, Bool requires_grad=False)=> ConsistentRandInt",
      "Tensor (Int64 high, Shape size, *, Placement placement, SbpList sbp,
      DataType dtype=None, Generator generator=None, Bool requires_grad=False)=> ConsistentRandInt",
    ]
  bind_python: True

- name: "randperm"
  signature:
    [
      "Tensor (Int32 n, *, Generator generator=None, DataType dtype=kInt64, Device device=None, Bool requires_grad=False) => RandPerm",
      "Tensor (Int32 n, *, Placement placement, SbpList sbp, Generator generator=None, DataType dtype=kInt64, Bool requires_grad=False) => ConsistentRandPerm",
    ]
  bind_python: True

- name: "unfold_tensor"
  signature: "Tensor (Tensor x, Int32 dimension, Int32 size, Int32 step) => UnfoldTensor"
  bind_python: True

- name: "unfold_tensor_grad"
  signature: "Tensor (Tensor dy, Tensor x, Int32 dimension, Int32 size, Int32 step) => UnfoldTensorGrad"
  bind_python: False

- name: "unfold"
  signature:
    'Tensor (Tensor x, String data_format="channels_first", Int32List kernel_size,
    Int32List dilation_rate, Int32List padding,
    Int32List strides) => Unfold'
  bind_python: True

- name: "fold"
  signature: 'Tensor (Tensor x, String data_format="channels_first",
    Int32List output_size, Int32List kernel_size,
    Int32List dilation_rate, Int32List padding,
    Int32List strides) => Fold'
  bind_python: True

- name: "split"
  signature: [
    "TensorTuple (Tensor x, Int64 split_size_or_sections, Int64 dim=0) => Split",
    "TensorTuple (Tensor x, Int64List split_size_or_sections, Int64 dim=0) => SplitWithSize",
  ]
  bind_python: True

- name: "unbind"
  signature: [
    "TensorTuple (Tensor x, Int64 dim=0) => Unbind",
  ]
  bind_python: True

- name: "chunk"
  signature: [
    "TensorTuple (Tensor x, Int64 chunks, Int64 dim=0) => Chunk",
  ]
  bind_python: True

- name: "split_like"
  signature: "TensorTuple (Tensor x, TensorTuple like, Int64 axis) => SplitLike"
  bind_python: True

- name: "cosine_similarity"
  signature: "Tensor (Tensor x, Tensor y, Int32 dim=1, Double eps=1e-8) => CosineSimilarity"
  bind_python: True

- name: "normalize"
  signature: "Tensor (Tensor input, Float p=2.0, Int32 dim=1, Float eps=1e-12, Bool use_l2_norm_kernel=True) => Normalize"
  bind_python: True

- name: "l2_normalize"
  signature: "Tensor (Tensor input, Int32 axis=0, Float epsilon=1e-12) => L2Normalize"
  bind_python: False

- name: "l2_normalize_grad"
  signature: "Tensor (Tensor dy, Tensor y, Tensor square_x_sum, Int32 axis, Float epsilon) => L2NormalizeGrad"
  bind_python: False

- name: "fused_self_attention"
  signature: "TensorTuple (Tensor hidden_states, Int64 head_size=8, Float alpha=1.0) => FusedSelfAttention"
  bind_python: True

- name: "fused_self_attention_grad"
  signature: "Tensor (Tensor query_mul_key_grad, Tensor value_grad, Tensor hidden_states, Float alpha=1.0) => FusedSelfAttentionGrad"
  bind_python: False

- name: "fused_scale_tril"
  signature: "Tensor (Tensor x, Int64 diagonal=0, Scalar fill_value=0, Scalar scale=1) => FusedScaleTril"
  bind_python: True

- name: "fused_bias_add_gelu"
  signature: "Tensor (Tensor a, Tensor b, *, Int32 axis) => FusedBiasAddGelu"
  bind_python: True

- name: "fused_bias_add_gelu_grad"
  signature: "Tensor (Tensor a, Tensor b, Tensor dy, Int32 axis) => FusedBiasAddGeluGrad"
  bind_python: false

- name: "fused_bias_add_dropout"
  signature: "Tensor (Tensor a, Tensor b, *, Float p=0.5, Int32 axis, Generator generator=None) => FusedBiasAddDropout"
  bind_python: True

- name: "fused_scale_mask_softmax"
  signature: "Tensor (Tensor x, Tensor mask, *, Float fill_value=0.0, Float scale=1.0) => FusedScaleMaskSoftmax"
  bind_python: True

- name: "fused_scale_mask_softmax_grad"
  signature: "Tensor (Tensor y, Tensor dy, Tensor mask, Float scale=1.0) => FusedScaleMaskSoftmaxGrad"
  bind_python: False

- name: "fused_scale_mask_softmax_dropout"
  signature: "TensorTuple (Tensor x, Tensor mask, *, Float fill_value=0.0, Float scale=1.0, Float p=0.5, Bool training=True, Generator generator=None) => FusedScaleMaskSoftmaxDropout"
  bind_python: True

- name: "fused_scale_mask_softmax_dropout_grad"
  signature: "Tensor (Tensor softmax_y, Tensor dy, Tensor mask, Tensor dropout_mask, Float scale=1.0, Float dropout_scale=1.0) => FusedScaleMaskSoftmaxDropoutGrad"
  bind_python: False

- name: "fused_scale_tril_softmax_mask_scale"
  signature: "TensorTuple (Tensor a, *, Float p=0.5, Int64 diagonal, Float tril_scale_value, Generator generator=None) => FusedScaleTrilSoftmaxMaskScale"
  bind_python: True

- name: "fused_scale_tril_softmax_mask_scale_grad"
  signature: "Tensor (Tensor softmax_y, Tensor dy, Tensor mask, Int64 diagonal, Float tril_scale_value, Float mask_scale_value) => FusedScaleTrilSoftmaxMaskScaleGrad"
  bind_python: False

- name: "send"
  signature: "Void (Tensor input, Int64 dst, Bool send_meta=True) => Send"
  bind_python: True

- name: "recv"
  signature: "Tensor (Int64 src, Shape shape=None, DataType dtype=None, Device device=None, *, Tensor out=None) => Recv"
  bind_python: True

- name: "batch_gather"
  signature: "Tensor (Tensor in, Tensor indices) => BatchGather"
  bind_python: True

- name: "unsorted_batch_segment_sum"
  signature: "Tensor (Tensor data, Tensor segment_ids, Int64 num_segments) => UnsortedBatchSegmentSum"
  bind_python: False

- name: "ctc_greedy_decoder"
  signature: "TensorTuple (Tensor log_probs, Tensor input_lengths, Bool merge_repeated=True) => CtcGreedyDecoder"
  bind_python: True

- name: "distributed_partial_fc_sample_disable_boxing"
  signature:
    "TensorTuple (Tensor sampled_weight_diff, Tensor sampled_label) => DistributedPariticalFCSampleDisableBoxing"
  bind_python: False

- name: "nms"
  signature:
    "Tensor (Tensor x, Float iou_threshold, Int32 keep_n=-1) => Nms"
  bind_python: True

- name: "roi_align"
  signature:
    "Tensor (Tensor x, Tensor rois, Float spatial_scale, Int32 pooled_h, Int32 pooled_w, Int32 sampling_ratio, Bool aligned) => RoiAlign"
  bind_python: True

- name: "roi_align_grad"
  signature:
    "Tensor (Tensor dy, Tensor x_like, Tensor rois, Float spatial_scale, Int32 pooled_h, Int32 pooled_w, Int32 sampling_ratio, Bool aligned) => RoiAlignGrad"
  bind_python: False

- name: "meshgrid"
  signature: 'TensorTuple (TensorTuple tensors, String indexing="ij") => Meshgrid'
  bind_python: True

- name: "index_select"
  signature:
    "Tensor (Tensor input, Int64 dim, Tensor index) => IndexSelect"
  bind_python: True

- name: "decode_onerec"
  signature: "Tensor (Tensor input, String key, DataType dtype, Shape shape, Bool is_dynamic=False, Shape reshape=None, Shape batch_padding=None) => DecodeOneRec"
  bind_python: True

- name: "dot"
  signature: "Tensor (Tensor input, Tensor other) => Dot"
  bind_python: True

- name: "fused_dot_feature_interaction"
  signature: "Tensor (TensorTuple features, Tensor output_concat=None, Bool self_interaction=False, Int32 output_padding=0, String pooling=\"none\") => FusedDotFeatureInteraction"
  bind_python: True

- name: "fused_dot_feature_interaction_grad"
  signature: "TensorTuple (Tensor dy, TensorTuple features, Bool has_output_concat_grad=False, Bool self_interaction=False, Int32 output_concat_grad_dim=0, String pooling=\"none\") => FusedDotFeatureInteractionGrad"
  bind_python: False

- name: "fused_cross_feature_interaction"
  signature: "Tensor (Tensor x, Tensor weight, Tensor x_0, Tensor bias, String interaction_mode) => FusedCrossFeatureInteraction"
  bind_python: True

- name: "fused_cross_feature_interaction_v1_grad"
  signature: "TensorTuple (Tensor dy, Tensor weight, Tensor x, Tensor x_0, Tensor matmul_result) => FusedCrossFeatureInteractionV1Grad"
  bind_python: False

- name: "fused_cross_feature_interaction_v2_grad"
  signature: "TensorTuple (Tensor dy, Tensor weight, Tensor bias, Tensor x, Tensor x_0, Tensor matmul_result) => FusedCrossFeatureInteractionV2Grad"
  bind_python: False

- name: "tensor_buffer_to_tensor"
  signature: "Tensor (Tensor input, Shape instance_shape, DataType dtype) => TensorBufferToTensor"
  bind_python: True

- name: "tensor_to_tensor_buffer"
  signature: "Tensor (Tensor input, Int32 instance_dims) => TensorToTensorBuffer"
  bind_python: True

- name: "gen_tensor_buffer"
  signature: "Tensor (Shape shape, ShapeList shape_list, FloatList value_list, DataType data_type, Bool dynamic_out) => GenTensorBuffer"
  bind_python: True

- name: "top_k"
  signature: "Tensor (Tensor input, Int32 k, Bool sorted=True) => TopK"
  bind_python: True

- name: "in_top_k"
  signature: "Tensor (Tensor targets, Tensor predictions, Int32 k) => InTopK"
  bind_python: True

- name: "cumsum"
  signature: "Tensor (Tensor input, Int64 dim, *, DataType dtype=None) => Cumsum"
  bind_python: True

- name: "cumprod"
  signature: "Tensor (Tensor input, Int64 dim, *, DataType dtype=None) => Cumprod"
  bind_python: True

- name: "cumprod_grad"
  signature: "Tensor (Tensor input, Tensor y, Tensor x, Int64 dim) => CumprodGrad"
  bind_python: False

- name: "one_embedding_id_shuffle"
  signature: "TensorTuple (Tensor ids, Tensor table_ids=None, Int32 num_tables=1) => OneEmbeddingIdShuffle"
  bind_python: True

- name: "one_embedding_embedding_shuffle"
  signature: "Tensor (Tensor cur_rank_embeddings, Tensor num_unique_matrix, Tensor cur_rank_inverse_indices, Tensor inverse_unique_partition_indices) => OneEmbeddingEmbeddingShuffle"
  bind_python: True

- name: "one_embedding_embedding_gradient_shuffle"
  signature: "Tensor (Tensor embedding_grad, Tensor num_unique_matrix, Tensor cur_rank_inverse_indices, Tensor inverse_unique_partition_indices) => OneEmbeddingEmbeddingGradientShuffle"
  bind_python: True

- name: "one_embedding_lookup"
  signature: "Tensor (Tensor shadow, Tensor ids, Tensor table_ids=None, DataType dtype, Int64 embedding_size, Int32 num_tables, String embedding_tables, String embedding_store_options) => OneEmbeddingLookup"
  bind_python: True

- name: "one_embedding_unique_key_value_pair"
  signature: "TensorTuple (Tensor keys, Tensor values=None, Int32 num_tables) => OneEmbeddingUniqueKeyValuePair"
  bind_python: True

- name: "one_embedding_sgd_update"
  signature: "Tensor (Tensor num_unique_ids, Tensor unique_embeddings, Tensor embedding_grad, Tensor learning_rate, Tensor down_scale_by_tensor, Tensor skip_if, Double scale, Float weight_decay, Float momentum) => OneEmbeddingSgdUpdate"
  bind_python: True

- name: "one_embedding_adam_update"
  signature: "Tensor (Tensor num_unique_ids, Tensor unique_embeddings, Tensor embedding_grad, Tensor learning_rate, Tensor down_scale_by_tensor, Tensor skip_if, Tensor bias_correction1=None, Tensor bias_correction2=None, Double scale=1.0, Float weight_decay=0.0, Float beta1=0.9, Float beta2=0.999, Float epsilon=0, Bool do_bias_correction=True) => OneEmbeddingAdamUpdate"
  bind_python: True

- name: "one_embedding_adagrad_update"
  signature: "Tensor (Tensor num_unique_ids, Tensor unique_embeddings, Tensor embedding_grad, Tensor learning_rate, Tensor down_scale_by_tensor, Tensor skip_if, Tensor train_step, Double scale=1.0, Float weight_decay=0.0, Float lr_decay=0.0, Float epsilon=0) => OneEmbeddingAdagradUpdate"
  bind_python: True

- name: "one_embedding_ftrl_update"
  signature: "Tensor (Tensor num_unique_ids, Tensor unique_embeddings, Tensor embedding_grad, Tensor learning_rate, Tensor down_scale_by_tensor, Tensor skip_if, Double scale, Float weight_decay, Float lr_power, Float lambda1, Float lambda2, Float beta) => OneEmbeddingFtrlUpdate"
  bind_python: True

- name: "einsum"
  signature: "Tensor (String equation, TensorTuple operands) => EinSum"
  bind_python: True

- name: "pixel_shuffle"
  signature: "Tensor (Tensor input, Int64 h_upscale_factor, Int64 w_upscale_factor) => PixelShuffle"
  bind_python: True

- name: "isnan"
  signature: "Tensor (Tensor input) => IsNan"
  bind_python: True

- name: "isinf"
  signature: "Tensor (Tensor input) => IsInf"
  bind_python: True

- name: "roc_auc_score"
  signature: "Tensor (Tensor label, Tensor pred) => RocAucScore"
  bind_python: True

- name: "pin_memory"
  signature: "Tensor (Tensor input) => PinMemory"
  bind_python: True

- name: "fill_"
  signature: [
    "Tensor (Tensor in, Scalar value) => Fill",
    "Tensor (Tensor in, Tensor value) => FillTensor"
    ]
  bind_python: True

- name: "rnn_tanh_cell"
  signature: "Tensor (Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih=None, Tensor b_hh=None) => RnnTanhCell"
  bind_python: True

- name: "rnn_relu_cell"
  signature: "Tensor (Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih=None, Tensor b_hh=None) => RnnReluCell"
  bind_python: True

- name: "lstm_cell"
  signature: "TensorTuple (Tensor input, TensorTuple hx, Tensor w_ih, Tensor w_hh, Tensor b_ih=None, Tensor b_hh=None) => LstmCell"
  bind_python: True

- name: "gru_cell"
  signature: "Tensor (Tensor input, Tensor hx, Tensor w_ih, Tensor w_hh, Tensor b_ih=None, Tensor b_hh=None) => GruCell"
  bind_python: True

- name: "_fused_gru_cell"
  signature: "TensorTuple (Tensor igates, Tensor hgates, Tensor hx, Tensor b_ih=None, Tensor b_hh=None) => FusedGruCell"
  bind_python: False

- name: "_fused_gru_cell_grad"
  signature: "TensorTuple (Tensor grad_hy, Tensor workspace, Bool has_bias, Bool hx_needs_grad) => FusedGruCellGrad"
  bind_python: False

- name: "_fused_lstm_cell"
  signature: "TensorTuple (Tensor igates, Tensor hgates, Tensor cx, Tensor b_ih=None, Tensor b_hh=None) => FusedLstmCell"
  bind_python: False

- name: "_fused_lstm_cell_grad"
  signature: "TensorTuple (Tensor grad_hy, Tensor grad_cy, Tensor cx, Tensor cy, Tensor workspace, Bool need_cx_grad, Bool has_bias) => FusedLstmCellGrad"
  bind_python: False

- name: "rnn_tanh"
  signature:
    [
      "TensorTuple (Tensor input, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional, Bool batch_first) => RnnTanhInput",
      "TensorTuple (Tensor data, Tensor batch_sizes, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional) => RnnTanhData"
    ]
  bind_python: True

- name: "rnn_relu"
  signature:
    [
      "TensorTuple (Tensor input, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional, Bool batch_first) => RnnReluInput",
      "TensorTuple (Tensor data, Tensor batch_sizes, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional) => RnnReluData"
    ]
  bind_python: True

- name: "lstm"
  signature:
    [
      "TensorTuple (Tensor input, TensorTuple hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional, Bool batch_first) => LstmInput",
      "TensorTuple (Tensor data, Tensor batch_sizes, TensorTuple hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional) => LstmData"
    ]
  bind_python: True

- name: "gru"
  signature:
    [
      "TensorTuple (Tensor input, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional, Bool batch_first) => GruInput",
      "TensorTuple (Tensor data, Tensor batch_sizes, Tensor hx, TensorTuple params, Bool has_biases, Int32 num_layers, Float dropout, Bool train, Bool bidirectional) => GruData"
    ]
  bind_python: True

- name: "pack_padded_sequence"
  signature: "TensorTuple (Tensor input, Tensor lengths, Bool batch_first) => PackPaddedSequence"
  bind_python: True
