@tensorflow/tfjs-core/dist/kernel_names.d.ts

Hardware-accelerated JavaScript library for machine intelligence

/// <amd-module name="@tensorflow/tfjs-core/dist/kernel_names" />
/**
 * @license
 * Copyright 2020 Google LLC. 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.
 * =============================================================================
 */
import { NamedTensorInfoMap } from './kernel_registry';
import { ExplicitPadding } from './ops/conv_util';
import { Activation } from './ops/fused_types';
import { TensorInfo } from './tensor_info';
import { DataType, DrawOptions, PixelData } from './types';
export declare const Abs = "Abs";
export type AbsInputs = UnaryInputs;
export declare const Acos = "Acos";
export type AcosInputs = UnaryInputs;
export declare const Acosh = "Acosh";
export type AcoshInputs = UnaryInputs;
export declare const Add = "Add";
export type AddInputs = BinaryInputs;
export declare const AddN = "AddN";
export type AddNInputs = TensorInfo[];
export declare const All = "All";
export type AllInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface AllAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const Any = "Any";
export type AnyInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface AnyAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const ArgMax = "ArgMax";
export type ArgMaxInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface ArgMaxAttrs {
    axis: number;
}
export declare const ArgMin = "ArgMin";
export type ArgMinInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface ArgMinAttrs {
    axis: number;
}
export declare const Asin = "Asin";
export type AsinInputs = UnaryInputs;
export declare const Asinh = "Asinh";
export type AsinhInputs = UnaryInputs;
export declare const Atan = "Atan";
export type AtanInputs = UnaryInputs;
export declare const Atanh = "Atanh";
export type AtanhInputs = UnaryInputs;
export declare const Atan2 = "Atan2";
export type Atan2Inputs = BinaryInputs;
export declare const AvgPool = "AvgPool";
export type AvgPoolInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface AvgPoolAttrs {
    filterSize: [number, number] | number;
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const AvgPoolGrad = "AvgPoolGrad";
export type AvgPoolGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input'>;
export interface AvgPoolGradAttrs {
    filterSize: [number, number] | number;
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
}
export declare const AvgPool3D = "AvgPool3D";
export type AvgPool3DInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface AvgPool3DAttrs {
    filterSize: [number, number, number] | number;
    strides: [number, number, number] | number;
    pad: 'valid' | 'same' | number;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
    dataFormat: 'NDHWC' | 'NCDHW';
}
export declare const AvgPool3DGrad = "AvgPool3DGrad";
export type AvgPool3DGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input'>;
export interface AvgPool3DGradAttrs {
    filterSize: [number, number, number] | number;
    strides: [number, number, number] | number;
    pad: 'valid' | 'same' | number;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const BatchMatMul = "BatchMatMul";
export type BatchMatMulInputs = Pick<NamedTensorInfoMap, 'a' | 'b'>;
export interface BatchMatMulAttrs {
    transposeA: boolean;
    transposeB: boolean;
}
export declare const BatchToSpaceND = "BatchToSpaceND";
export type BatchToSpaceNDInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface BatchToSpaceNDAttrs {
    blockShape: number[];
    crops: number[][];
}
export type BinaryInputs = Pick<NamedTensorInfoMap, 'a' | 'b'>;
export declare const Bincount = "Bincount";
export type BincountInputs = Pick<NamedTensorInfoMap, 'x' | 'weights'>;
export interface BincountAttrs {
    size: number;
}
export declare const BitwiseAnd = "BitwiseAnd";
export type BitwiseAndInputs = BinaryInputs;
export declare const BroadcastTo = "BroadcastTo";
export type BroadcastToInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface BroadCastToAttrs {
    shape: number[];
    inputShape: number[];
}
export declare const BroadcastArgs = "BroadcastArgs";
export type BroadcastArgsInputs = Pick<NamedTensorInfoMap, 's0' | 's1'>;
export declare const Cast = "Cast";
export type CastInputs = UnaryInputs;
export interface CastAttrs {
    dtype: DataType;
}
export declare const Ceil = "Ceil";
export type CeilInputs = UnaryInputs;
export declare const ClipByValue = "ClipByValue";
export type ClipByValueInputs = UnaryInputs;
export interface ClipByValueAttrs {
    clipValueMin: number;
    clipValueMax: number;
}
export declare const Complex = "Complex";
export type ComplexInputs = Pick<NamedTensorInfoMap, 'real' | 'imag'>;
export declare const ComplexAbs = "ComplexAbs";
export type ComplexAbsInputs = UnaryInputs;
export declare const Concat = "Concat";
export type ConcatInputs = TensorInfo[];
export interface ConcatAttrs {
    axis: number;
}
export declare const Conv2D = "Conv2D";
export type Conv2DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
export interface Conv2DAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dilations: [number, number] | number;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const Conv2DBackpropFilter = "Conv2DBackpropFilter";
export type Conv2DBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
export interface Conv2DBackpropFilterAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
    filterShape: [number, number, number, number];
}
export declare const Conv2DBackpropInput = "Conv2DBackpropInput";
export type Conv2DBackpropInputInputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
export interface Conv2DBackpropInputAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
    inputShape: [number, number, number, number];
}
export declare const Conv3D = "Conv3D";
export type Conv3DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
export interface Conv3DAttrs {
    strides: [number, number, number] | number;
    pad: 'valid' | 'same';
    dataFormat: 'NDHWC' | 'NCDHW';
    dilations: [number, number, number] | number;
}
export declare const Conv3DBackpropFilterV2 = "Conv3DBackpropFilterV2";
export type Conv3DBackpropFilterV2Inputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
export interface Conv3DBackpropFilterV2Attrs {
    strides: [number, number, number] | number;
    pad: 'valid' | 'same';
    filterShape: [number, number, number, number, number];
}
export declare const Conv3DBackpropInputV2 = "Conv3DBackpropInputV2";
export type Conv3DBackpropInputV2Inputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
export interface Conv3DBackpropInputV2Attrs {
    strides: [number, number, number] | number;
    pad: 'valid' | 'same';
    inputShape: [number, number, number, number, number];
}
export declare const Cos = "Cos";
export type CosInputs = UnaryInputs;
export declare const Cosh = "Cosh";
export type CoshInputs = UnaryInputs;
export declare const Cumprod = "Cumprod";
export type CumprodInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface CumprodAttrs {
    axis: number;
    exclusive: boolean;
    reverse: boolean;
}
export declare const Cumsum = "Cumsum";
export type CumsumInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface CumsumAttrs {
    axis: number;
    exclusive: boolean;
    reverse: boolean;
}
export declare const CropAndResize = "CropAndResize";
export type CropAndResizeInputs = Pick<NamedTensorInfoMap, 'image' | 'boxes' | 'boxInd'>;
export interface CropAndResizeAttrs {
    cropSize: [number, number];
    method: 'bilinear' | 'nearest';
    extrapolationValue: number;
}
export declare const DenseBincount = "DenseBincount";
export type DenseBincountInputs = Pick<NamedTensorInfoMap, 'x' | 'weights'>;
export interface DenseBincountAttrs {
    size: number;
    binaryOutput?: boolean;
}
export declare const DepthToSpace = "DepthToSpace";
export type DepthToSpaceInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface DepthToSpaceAttrs {
    blockSize: number;
    dataFormat: 'NHWC' | 'NCHW';
}
export declare const DepthwiseConv2dNative = "DepthwiseConv2dNative";
export type DepthwiseConv2dNativeInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
export interface DepthwiseConv2dNativeAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dilations: [number, number] | number;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const DepthwiseConv2dNativeBackpropFilter = "DepthwiseConv2dNativeBackpropFilter";
export type DepthwiseConv2dNativeBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'dy'>;
export interface DepthwiseConv2dNativeBackpropFilterAttrs {
    strides: [number, number] | number;
    dilations: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
    filterShape: [number, number, number, number];
}
export declare const DepthwiseConv2dNativeBackpropInput = "DepthwiseConv2dNativeBackpropInput";
export type DepthwiseConv2dNativeBackpropInputInputs = Pick<NamedTensorInfoMap, 'dy' | 'filter'>;
export interface DepthwiseConv2dNativeBackpropInputAttrs {
    strides: [number, number] | number;
    dilations: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
    inputShape: [number, number, number, number];
}
export declare const Diag = "Diag";
export type DiagInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const Dilation2D = "Dilation2D";
export type Dilation2DInputs = Pick<NamedTensorInfoMap, 'x' | 'filter'>;
export interface Dilation2DAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number;
    dilations: [number, number] | number;
}
export declare const Dilation2DBackpropInput = "Dilation2DBackpropInput";
export type Dilation2DBackpropInputInputs = Pick<NamedTensorInfoMap, 'x' | 'filter' | 'dy'>;
export declare const Dilation2DBackpropFilter = "Dilation2DBackpropFilter";
export type Dilation2DBackpropFilterInputs = Pick<NamedTensorInfoMap, 'x' | 'filter' | 'dy'>;
export declare const Draw = "Draw";
export type DrawInputs = Pick<NamedTensorInfoMap, 'image'>;
export interface DrawAttrs {
    canvas: HTMLCanvasElement;
    options?: DrawOptions;
}
export declare const RealDiv = "RealDiv";
export type RealDivInputs = BinaryInputs;
export declare const Einsum = "Einsum";
export type EinsumInputs = TensorInfo[];
export interface EinsumAttrs {
    equation: string;
}
export declare const Elu = "Elu";
export type EluInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const EluGrad = "EluGrad";
export type EluGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'y'>;
export declare const Erf = "Erf";
export type ErfInputs = UnaryInputs;
export declare const Equal = "Equal";
export type EqualInputs = BinaryInputs;
export declare const Exp = "Exp";
export type ExpInputs = UnaryInputs;
export declare const ExpandDims = "ExpandDims";
export type ExpandDimsInputs = Pick<NamedTensorInfoMap, 'input'>;
export interface ExpandDimsAttrs {
    dim: number;
}
export declare const Expm1 = "Expm1";
export type Expm1Inputs = UnaryInputs;
export declare const FFT = "FFT";
export type FFTInputs = Pick<NamedTensorInfoMap, 'input'>;
export declare const Fill = "Fill";
export interface FillAttrs {
    shape: number[];
    value: number | string;
    dtype: DataType;
}
export declare const FlipLeftRight = "FlipLeftRight";
export type FlipLeftRightInputs = Pick<NamedTensorInfoMap, 'image'>;
export declare const Floor = "Floor";
export type FloorInputs = UnaryInputs;
export declare const FloorDiv = "FloorDiv";
export type FloorDivInputs = BinaryInputs;
export declare const FusedBatchNorm = "FusedBatchNorm";
export type FusedBatchNormInputs = Pick<NamedTensorInfoMap, 'x' | 'scale' | 'offset' | 'mean' | 'variance'>;
export interface FusedBatchNormAttrs {
    varianceEpsilon: number;
}
export declare const GatherV2 = "GatherV2";
export type GatherV2Inputs = Pick<NamedTensorInfoMap, 'x' | 'indices'>;
export interface GatherV2Attrs {
    axis: number;
    batchDims: number;
}
export declare const GatherNd = "GatherNd";
export type GatherNdInputs = Pick<NamedTensorInfoMap, 'params' | 'indices'>;
export declare const Greater = "Greater";
export type GreaterInputs = BinaryInputs;
export declare const GreaterEqual = "GreaterEqual";
export type GreaterEqualInputs = BinaryInputs;
export declare const Identity = "Identity";
export type IdentityInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const IFFT = "IFFT";
export type IFFTInputs = Pick<NamedTensorInfoMap, 'input'>;
export declare const Imag = "Imag";
export type ImagInputs = Pick<NamedTensorInfoMap, 'input'>;
export declare const IsFinite = "IsFinite";
export type IsFiniteInputs = UnaryInputs;
export declare const IsInf = "IsInf";
export type IsInfInputs = UnaryInputs;
export declare const IsNan = "IsNan";
export type IsNanInputs = UnaryInputs;
export declare const LeakyRelu = "LeakyRelu";
export type LeakyReluInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface LeakyReluAttrs {
    alpha: number;
}
export declare const Less = "Less";
export type LessInputs = BinaryInputs;
export declare const LessEqual = "LessEqual";
export type LessEqualInputs = BinaryInputs;
export declare const LinSpace = "LinSpace";
export interface LinSpaceAttrs {
    start: number;
    stop: number;
    num: number;
}
export declare const Log = "Log";
export type LogInputs = UnaryInputs;
export declare const Log1p = "Log1p";
export type Log1pInputs = UnaryInputs;
export declare const LogicalAnd = "LogicalAnd";
export type LogicalAndInputs = BinaryInputs;
export declare const LogicalNot = "LogicalNot";
export type LogicalNotInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const LogicalOr = "LogicalOr";
export type LogicalOrInputs = BinaryInputs;
export declare const LogicalXor = "LogicalXor";
export type LogicalXorInputs = BinaryInputs;
export declare const LogSoftmax = "LogSoftmax";
export type LogSoftmaxInputs = Pick<NamedTensorInfoMap, 'logits'>;
export interface LogSoftmaxAttrs {
    axis: number;
}
export declare const LowerBound = "LowerBound";
export type LowerBoundInputs = Pick<NamedTensorInfoMap, 'sortedSequence' | 'values'>;
export declare const LRN = "LRN";
export type LRNInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface LRNAttrs {
    depthRadius: number;
    bias: number;
    alpha: number;
    beta: number;
}
export declare const LRNGrad = "LRNGrad";
export type LRNGradInputs = Pick<NamedTensorInfoMap, 'x' | 'y' | 'dy'>;
export interface LRNGradAttrs {
    depthRadius: number;
    bias: number;
    alpha: number;
    beta: number;
}
export declare const MatrixBandPart = "MatrixBandPart";
export type MatrixBandPartInputs = Pick<NamedTensorInfoMap, 'input' | 'numLower' | 'numUpper'>;
export interface MatrixBandPartAttrs {
}
export declare const Max = "Max";
export type MaxInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MaxAttrs {
    reductionIndices: number | number[];
    keepDims: boolean;
}
export declare const Maximum = "Maximum";
export type MaximumInputs = BinaryInputs;
export declare const MaxPool = "MaxPool";
export type MaxPoolInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MaxPoolAttrs {
    filterSize: [number, number] | number;
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const MaxPoolGrad = "MaxPoolGrad";
export type MaxPoolGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input' | 'output'>;
export interface MaxPoolGradAttrs {
    filterSize: [number, number] | number;
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const MaxPool3D = "MaxPool3D";
export type MaxPool3DInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MaxPool3DAttrs {
    filterSize: [number, number, number] | number;
    strides: [number, number, number] | number;
    pad: 'valid' | 'same' | number;
    dataFormat: 'NDHWC' | 'NCDHW';
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const MaxPool3DGrad = "MaxPool3DGrad";
export type MaxPool3DGradInputs = Pick<NamedTensorInfoMap, 'dy' | 'input' | 'output'>;
export interface MaxPool3DGradAttrs {
    filterSize: [number, number, number] | number;
    strides: [number, number, number] | number;
    pad: 'valid' | 'same' | number;
    dimRoundingMode?: 'floor' | 'round' | 'ceil';
}
export declare const MaxPoolWithArgmax = "MaxPoolWithArgmax";
export type MaxPoolWithArgmaxInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MaxPoolWithArgmaxAttrs {
    filterSize: [number, number] | number;
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number;
    includeBatchInIndex: boolean;
}
export declare const Mean = "Mean";
export type MeanInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MeanAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const Min = "Min";
export type MinInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MinAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const Minimum = "Minimum";
export type MinimumInputs = BinaryInputs;
export declare const MirrorPad = "MirrorPad";
export type MirrorPadInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface MirrorPadAttrs {
    paddings: Array<[number, number]>;
    mode: 'reflect' | 'symmetric';
}
export declare const Mod = "Mod";
export type ModInputs = BinaryInputs;
export declare const Multinomial = "Multinomial";
export type MultinomialInputs = Pick<NamedTensorInfoMap, 'logits'>;
export interface MultinomialAttrs {
    numSamples: number;
    seed: number;
    normalized: boolean;
}
export declare const Multiply = "Multiply";
export type MultiplyInputs = BinaryInputs;
export declare const Neg = "Neg";
export type NegInputs = UnaryInputs;
export declare const NotEqual = "NotEqual";
export type NotEqualInputs = BinaryInputs;
export declare const NonMaxSuppressionV3 = "NonMaxSuppressionV3";
export type NonMaxSuppressionV3Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
export interface NonMaxSuppressionV3Attrs {
    maxOutputSize: number;
    iouThreshold: number;
    scoreThreshold: number;
}
export declare const NonMaxSuppressionV4 = "NonMaxSuppressionV4";
export type NonMaxSuppressionV4Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
export interface NonMaxSuppressionV4Attrs {
    maxOutputSize: number;
    iouThreshold: number;
    scoreThreshold: number;
    padToMaxOutputSize: boolean;
}
export declare const NonMaxSuppressionV5 = "NonMaxSuppressionV5";
export type NonMaxSuppressionV5Inputs = Pick<NamedTensorInfoMap, 'boxes' | 'scores'>;
export interface NonMaxSuppressionV5Attrs {
    maxOutputSize: number;
    iouThreshold: number;
    scoreThreshold: number;
    softNmsSigma: number;
}
export declare const OnesLike = "OnesLike";
export type OnesLikeInputs = UnaryInputs;
export declare const OneHot = "OneHot";
export type OneHotInputs = Pick<NamedTensorInfoMap, 'indices'>;
export interface OneHotAttrs {
    depth: number;
    onValue: number;
    offValue: number;
    dtype: DataType;
}
export declare const Pack = "Pack";
export type PackInputs = TensorInfo[];
export interface PackAttrs {
    axis: number;
}
export declare const PadV2 = "PadV2";
export type PadV2Inputs = Pick<NamedTensorInfoMap, 'x'>;
export interface PadV2Attrs {
    paddings: Array<[number, number]>;
    constantValue: number;
}
export declare const Pool = "Pool";
export type PoolInputs = Pick<NamedTensorInfoMap, 'input'>;
export declare const Pow = "Pow";
export type PowInputs = BinaryInputs;
export declare const Prelu = "Prelu";
export type PreluInputs = Pick<NamedTensorInfoMap, 'x' | 'alpha'>;
export declare const Prod = "Prod";
export type ProdInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface ProdAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const RaggedGather = "RaggedGather";
export type RaggedGatherInputs = {
    paramsNestedSplits: TensorInfo[];
} & Pick<NamedTensorInfoMap, 'paramsDenseValues' | 'indices'>;
export interface RaggedGatherAttrs {
    outputRaggedRank: number;
}
export declare const RaggedRange = "RaggedRange";
export type RaggedRangeInputs = Pick<NamedTensorInfoMap, 'starts' | 'limits' | 'deltas'>;
export declare const RaggedTensorToTensor = "RaggedTensorToTensor";
export type RaggedTensorToTensorInputs = Pick<NamedTensorInfoMap, 'shape' | 'values' | 'defaultValue'> & {
    rowPartitionTensors: TensorInfo[];
};
export interface RaggedTensorToTensorAttrs {
    rowPartitionTypes: string[];
}
export declare const Range = "Range";
export interface RangeAttrs {
    start: number;
    stop: number;
    step: number;
    dtype: 'float32' | 'int32';
}
export declare const Real = "Real";
export type RealInputs = Pick<NamedTensorInfoMap, 'input'>;
export declare const Reciprocal = "Reciprocal";
export type ReciprocalInputs = UnaryInputs;
export declare const Relu = "Relu";
export type ReluInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const Reshape = "Reshape";
export type ReshapeInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface ReshapeAttrs {
    shape: number[];
}
export declare const ResizeNearestNeighbor = "ResizeNearestNeighbor";
export type ResizeNearestNeighborInputs = Pick<NamedTensorInfoMap, 'images'>;
export interface ResizeNearestNeighborAttrs {
    alignCorners: boolean;
    halfPixelCenters: boolean;
    size: [number, number];
}
export declare const ResizeNearestNeighborGrad = "ResizeNearestNeighborGrad";
export type ResizeNearestNeighborGradInputs = Pick<NamedTensorInfoMap, 'images' | 'dy'>;
export type ResizeNearestNeighborGradAttrs = ResizeNearestNeighborAttrs;
export declare const ResizeBilinear = "ResizeBilinear";
export type ResizeBilinearInputs = Pick<NamedTensorInfoMap, 'images'>;
export interface ResizeBilinearAttrs {
    alignCorners: boolean;
    halfPixelCenters: boolean;
    size: [number, number];
}
export declare const ResizeBilinearGrad = "ResizeBilinearGrad";
export type ResizeBilinearGradInputs = Pick<NamedTensorInfoMap, 'images' | 'dy'>;
export type ResizeBilinearGradAttrs = ResizeBilinearAttrs;
export declare const Relu6 = "Relu6";
export type Relu6Inputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const Reverse = "Reverse";
export type ReverseInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface ReverseAttrs {
    dims: number | number[];
}
export declare const Round = "Round";
export type RoundInputs = UnaryInputs;
export declare const Rsqrt = "Rsqrt";
export type RsqrtInputs = UnaryInputs;
export declare const ScatterNd = "ScatterNd";
export type ScatterNdInputs = Pick<NamedTensorInfoMap, 'indices' | 'updates'>;
export interface ScatterNdAttrs {
    shape: number[];
}
export declare const TensorScatterUpdate = "TensorScatterUpdate";
export type TensorScatterUpdateInputs = Pick<NamedTensorInfoMap, 'tensor' | 'indices' | 'updates'>;
export interface TensorScatterUpdateAttrs {
}
export declare const SearchSorted = "SearchSorted";
export type SearchSortedInputs = Pick<NamedTensorInfoMap, 'sortedSequence' | 'values'>;
export interface SearchSortedAttrs {
    side: 'left' | 'right';
}
export declare const Select = "Select";
export type SelectInputs = Pick<NamedTensorInfoMap, 'condition' | 't' | 'e'>;
export declare const Selu = "Selu";
export type SeluInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const Slice = "Slice";
export type SliceInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface SliceAttrs {
    begin: number | number[];
    size: number | number[];
}
export declare const Sin = "Sin";
export type SinInputs = UnaryInputs;
export declare const Sinh = "Sinh";
export type SinhInputs = UnaryInputs;
export declare const Sign = "Sign";
export type SignInputs = UnaryInputs;
export declare const Sigmoid = "Sigmoid";
export type SigmoidInputs = UnaryInputs;
export declare const Softplus = "Softplus";
export type SoftplusInputs = UnaryInputs;
export declare const Sqrt = "Sqrt";
export type SqrtInputs = UnaryInputs;
export declare const Sum = "Sum";
export type SumInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface SumAttrs {
    axis: number | number[];
    keepDims: boolean;
}
export declare const SpaceToBatchND = "SpaceToBatchND";
export type SpaceToBatchNDInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface SpaceToBatchNDAttrs {
    blockShape: number[];
    paddings: number[][];
}
export declare const SplitV = "SplitV";
export type SplitVInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface SplitVAttrs {
    numOrSizeSplits: number[] | number;
    axis: number;
}
export declare const Softmax = "Softmax";
export type SoftmaxInputs = Pick<NamedTensorInfoMap, 'logits'>;
export interface SoftmaxAttrs {
    dim: number;
}
export declare const SparseFillEmptyRows = "SparseFillEmptyRows";
export type SparseFillEmptyRowsInputs = Pick<NamedTensorInfoMap, 'indices' | 'values' | 'denseShape' | 'defaultValue'>;
export declare const SparseReshape = "SparseReshape";
export type SparseReshapeInputs = Pick<NamedTensorInfoMap, 'inputIndices' | 'inputShape' | 'newShape'>;
export declare const SparseSegmentMean = "SparseSegmentMean";
export type SparseSegmentMeanInputs = Pick<NamedTensorInfoMap, 'data' | 'indices' | 'segmentIds'>;
export declare const SparseSegmentSum = "SparseSegmentSum";
export type SparseSegmentSumInputs = Pick<NamedTensorInfoMap, 'data' | 'indices' | 'segmentIds'>;
export declare const SparseToDense = "SparseToDense";
export type SparseToDenseInputs = Pick<NamedTensorInfoMap, 'sparseIndices' | 'sparseValues' | 'defaultValue'>;
export interface SparseToDenseAttrs {
    outputShape: number[];
}
export declare const SquaredDifference = "SquaredDifference";
export type SquaredDifferenceInputs = BinaryInputs;
export declare const Square = "Square";
export type SquareInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const StaticRegexReplace = "StaticRegexReplace";
export type StaticRegexReplaceInputs = UnaryInputs;
export interface StaticRegexReplaceAttrs {
    pattern: string;
    rewrite: string;
    replaceGlobal: boolean;
}
export declare const StridedSlice = "StridedSlice";
export type StridedSliceInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface StridedSliceAttrs {
    begin: number[];
    end: number[];
    strides: number[];
    beginMask: number;
    endMask: number;
    ellipsisMask: number;
    newAxisMask: number;
    shrinkAxisMask: number;
}
export declare const StringNGrams = "StringNGrams";
export type StringNGramsInputs = Pick<NamedTensorInfoMap, 'data' | 'dataSplits'>;
export interface StringNGramsAttrs {
    separator: string;
    nGramWidths: number[];
    leftPad: string;
    rightPad: string;
    padWidth: number;
    preserveShortSequences: boolean;
}
export declare const StringSplit = "StringSplit";
export type StringSplitInputs = Pick<NamedTensorInfoMap, 'input' | 'delimiter'>;
export interface StringSplitAttrs {
    skipEmpty: boolean;
}
export declare const StringToHashBucketFast = "StringToHashBucketFast";
export type StringToHashBucketFastInputs = Pick<NamedTensorInfoMap, 'input'>;
export interface StringToHashBucketFastAttrs {
    numBuckets: number;
}
export declare const Sub = "Sub";
export type SubInputs = BinaryInputs;
export declare const Tan = "Tan";
export type TanInputs = UnaryInputs;
export declare const Tanh = "Tanh";
export type TanhInputs = UnaryInputs;
export declare const Tile = "Tile";
export type TileInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface TileAttrs {
    reps: number[];
}
export declare const TopK = "TopK";
export type TopKInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface TopKAttrs {
    k: number;
    sorted: boolean;
}
export declare const Transform = "Transform";
export type TransformInputs = Pick<NamedTensorInfoMap, 'image' | 'transforms'>;
export interface TransformAttrs {
    interpolation: 'nearest' | 'bilinear';
    fillMode: 'constant' | 'reflect' | 'wrap' | 'nearest';
    fillValue: number;
    outputShape?: [number, number];
}
export declare const Transpose = "Transpose";
export type TransposeInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface TransposeAttrs {
    perm: number[];
}
export declare const Unique = "Unique";
export type UniqueInputs = Pick<NamedTensorInfoMap, 'x'>;
export interface UniqueAttrs {
    axis: number;
}
export type UnaryInputs = Pick<NamedTensorInfoMap, 'x'>;
export declare const Unpack = "Unpack";
export type UnpackInputs = Pick<NamedTensorInfoMap, 'value'>;
export interface UnpackAttrs {
    axis: number;
}
export declare const UnsortedSegmentSum = "UnsortedSegmentSum";
export type UnsortedSegmentSumInputs = Pick<NamedTensorInfoMap, 'x' | 'segmentIds'>;
export interface UnsortedSegmentSumAttrs {
    numSegments: number;
}
export declare const UpperBound = "UpperBound";
export type UpperBoundInputs = Pick<NamedTensorInfoMap, 'sortedSequence' | 'values'>;
export declare const ZerosLike = "ZerosLike";
export type ZerosLikeInputs = UnaryInputs;
/**
 * TensorFlow.js-only kernels
 */
export declare const Step = "Step";
export type StepInputs = UnaryInputs;
export interface StepAttrs {
    alpha: number;
}
export declare const FromPixels = "FromPixels";
export interface FromPixelsInputs {
    pixels: PixelData | ImageData | HTMLImageElement | HTMLCanvasElement | HTMLVideoElement | ImageBitmap;
}
export interface FromPixelsAttrs {
    numChannels: number;
}
export declare const RotateWithOffset = "RotateWithOffset";
export type RotateWithOffsetInputs = Pick<NamedTensorInfoMap, 'image'>;
export interface RotateWithOffsetAttrs {
    radians: number;
    fillValue: number | [number, number, number];
    center: number | [number, number];
}
export declare const _FusedMatMul = "_FusedMatMul";
export interface _FusedMatMulInputs extends NamedTensorInfoMap {
    a: TensorInfo;
    b: TensorInfo;
    bias?: TensorInfo;
    preluActivationWeights?: TensorInfo;
}
export interface _FusedMatMulAttrs {
    transposeA: boolean;
    transposeB: boolean;
    activation: Activation;
    leakyreluAlpha?: number;
}
export declare const FusedConv2D = "FusedConv2D";
export interface FusedConv2DInputs extends NamedTensorInfoMap {
    x: TensorInfo;
    filter: TensorInfo;
    bias?: TensorInfo;
    preluActivationWeights?: TensorInfo;
}
export interface FusedConv2DAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dilations: [number, number] | number;
    dimRoundingMode: 'floor' | 'round' | 'ceil';
    activation: Activation;
    leakyreluAlpha?: number;
}
export declare const FusedDepthwiseConv2D = "FusedDepthwiseConv2D";
export interface FusedDepthwiseConv2DInputs extends NamedTensorInfoMap {
    x: TensorInfo;
    filter: TensorInfo;
    bias?: TensorInfo;
    preluActivationWeights?: TensorInfo;
}
export interface FusedDepthwiseConv2DAttrs {
    strides: [number, number] | number;
    pad: 'valid' | 'same' | number | ExplicitPadding;
    dataFormat: 'NHWC' | 'NCHW';
    dilations: [number, number] | number;
    dimRoundingMode: 'floor' | 'round' | 'ceil';
    activation: Activation;
    leakyreluAlpha?: number;
}