@tensorflow/tfjs-core

  • Version 3.7.0
  • Published
  • 35 MB
  • 7 dependencies
  • Apache-2.0 license

Install

npm i @tensorflow/tfjs-core
yarn add @tensorflow/tfjs-core
pnpm add @tensorflow/tfjs-core

Overview

Hardware-accelerated JavaScript library for machine intelligence

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable abs

const abs: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

    variable Abs

    const Abs: string;

      variable acos

      const acos: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

        variable Acos

        const Acos: string;

          variable acosh

          const acosh: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

            variable Acosh

            const Acosh: string;

              variable add

              const add: <T extends Tensor<Rank>>(
              a: Tensor<Rank> | TensorLike,
              b: Tensor<Rank> | TensorLike
              ) => T;

                variable Add

                const Add: string;

                  variable addN

                  const addN: <T extends Tensor<Rank>>(tensors: (TensorLike | T)[]) => T;

                    variable AddN

                    const AddN: string;

                      variable all

                      const all: <T extends Tensor<Rank>>(
                      x: Tensor<Rank> | TensorLike,
                      axis?: number | number[],
                      keepDims?: boolean
                      ) => T;

                        variable All

                        const All: string;

                          variable any

                          const any: <T extends Tensor<Rank>>(
                          x: Tensor<Rank> | TensorLike,
                          axis?: number | number[],
                          keepDims?: boolean
                          ) => T;

                            variable Any

                            const Any: string;

                              variable argMax

                              const argMax: <T extends Tensor<Rank>>(
                              x: Tensor<Rank> | TensorLike,
                              axis?: number
                              ) => T;

                                variable ArgMax

                                const ArgMax: string;

                                  variable argMin

                                  const argMin: <T extends Tensor<Rank>>(
                                  x: Tensor<Rank> | TensorLike,
                                  axis?: number
                                  ) => T;

                                    variable ArgMin

                                    const ArgMin: string;

                                      variable asin

                                      const asin: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                        variable Asin

                                        const Asin: string;

                                          variable asinh

                                          const asinh: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                            variable Asinh

                                            const Asinh: string;

                                              variable atan

                                              const atan: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                variable Atan

                                                const Atan: string;

                                                  variable atan2

                                                  const atan2: <T extends Tensor<Rank>>(
                                                  a: Tensor<Rank> | TensorLike,
                                                  b: Tensor<Rank> | TensorLike
                                                  ) => T;

                                                    variable Atan2

                                                    const Atan2: string;

                                                      variable atanh

                                                      const atanh: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                        variable Atanh

                                                        const Atanh: string;

                                                          variable avgPool

                                                          const avgPool: <T extends Tensor3D | Tensor4D>(
                                                          x: TensorLike | T,
                                                          filterSize: number | [number, number],
                                                          strides: number | [number, number],
                                                          pad: number | 'valid' | 'same',
                                                          dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                          ) => T;

                                                            variable AvgPool

                                                            const AvgPool: string;

                                                              variable avgPool3d

                                                              const avgPool3d: <T extends Tensor4D | Tensor5D>(
                                                              x: TensorLike | T,
                                                              filterSize: number | [number, number, number],
                                                              strides: number | [number, number, number],
                                                              pad: number | 'valid' | 'same',
                                                              dimRoundingMode?: 'floor' | 'round' | 'ceil',
                                                              dataFormat?: 'NDHWC' | 'NCDHW'
                                                              ) => T;

                                                                variable AvgPool3D

                                                                const AvgPool3D: string;

                                                                  variable AvgPool3DGrad

                                                                  const AvgPool3DGrad: string;

                                                                    variable AvgPoolGrad

                                                                    const AvgPoolGrad: string;

                                                                      variable basicLSTMCell

                                                                      const basicLSTMCell: (
                                                                      forgetBias: Scalar | TensorLike,
                                                                      lstmKernel: TensorLike | Tensor2D,
                                                                      lstmBias: TensorLike | Tensor1D,
                                                                      data: TensorLike | Tensor2D,
                                                                      c: TensorLike | Tensor2D,
                                                                      h: TensorLike | Tensor2D
                                                                      ) => [Tensor2D, Tensor2D];

                                                                        variable BatchMatMul

                                                                        const BatchMatMul: string;

                                                                          variable batchNorm

                                                                          const batchNorm: <R extends Rank>(
                                                                          x: TensorLike | Tensor<R>,
                                                                          mean: TensorLike | Tensor1D | Tensor<R>,
                                                                          variance: TensorLike | Tensor1D | Tensor<R>,
                                                                          offset?: TensorLike | Tensor1D | Tensor<R>,
                                                                          scale?: TensorLike | Tensor1D | Tensor<R>,
                                                                          varianceEpsilon?: number
                                                                          ) => Tensor<R>;

                                                                            variable batchNorm2d

                                                                            const batchNorm2d: (
                                                                            x: TensorLike | Tensor2D,
                                                                            mean: TensorLike | Tensor1D | Tensor2D,
                                                                            variance: TensorLike | Tensor1D | Tensor2D,
                                                                            offset?: TensorLike | Tensor1D | Tensor2D,
                                                                            scale?: TensorLike | Tensor1D | Tensor2D,
                                                                            varianceEpsilon?: number
                                                                            ) => Tensor2D;

                                                                              variable batchNorm3d

                                                                              const batchNorm3d: (
                                                                              x: TensorLike | Tensor3D,
                                                                              mean: TensorLike | Tensor1D | Tensor3D,
                                                                              variance: TensorLike | Tensor1D | Tensor3D,
                                                                              offset?: TensorLike | Tensor1D | Tensor3D,
                                                                              scale?: TensorLike | Tensor1D | Tensor3D,
                                                                              varianceEpsilon?: number
                                                                              ) => Tensor3D;

                                                                                variable batchNorm4d

                                                                                const batchNorm4d: (
                                                                                x: TensorLike | Tensor4D,
                                                                                mean: TensorLike | Tensor1D | Tensor4D,
                                                                                variance: TensorLike | Tensor1D | Tensor4D,
                                                                                offset?: TensorLike | Tensor1D | Tensor4D,
                                                                                scale?: TensorLike | Tensor1D | Tensor4D,
                                                                                varianceEpsilon?: number
                                                                                ) => Tensor4D;

                                                                                  variable batchToSpaceND

                                                                                  const batchToSpaceND: <T extends Tensor<Rank>>(
                                                                                  x: TensorLike | T,
                                                                                  blockShape: number[],
                                                                                  crops: number[][]
                                                                                  ) => T;

                                                                                    variable BatchToSpaceND

                                                                                    const BatchToSpaceND: string;

                                                                                      variable bincount

                                                                                      const bincount: <T extends Tensor1D>(
                                                                                      x: TensorLike | T,
                                                                                      weights: TensorLike | T,
                                                                                      size: number
                                                                                      ) => T;

                                                                                        variable Bincount

                                                                                        const Bincount: string;

                                                                                          variable booleanMaskAsync

                                                                                          const booleanMaskAsync: (
                                                                                          tensor: Tensor<Rank> | TensorLike,
                                                                                          mask: Tensor<Rank> | TensorLike,
                                                                                          axis?: number
                                                                                          ) => Promise<Tensor<Rank>>;

                                                                                            variable broadcastTo

                                                                                            const broadcastTo: <R extends Rank>(
                                                                                            x: Tensor<Rank> | TensorLike,
                                                                                            shape: ShapeMap[R]
                                                                                            ) => Tensor<R>;

                                                                                              variable BroadcastTo

                                                                                              const BroadcastTo: string;

                                                                                                variable cast

                                                                                                const cast: <T extends Tensor<Rank>>(
                                                                                                x: TensorLike | T,
                                                                                                dtype: keyof DataTypeMap
                                                                                                ) => T;

                                                                                                  variable Cast

                                                                                                  const Cast: string;

                                                                                                    variable ceil

                                                                                                    const ceil: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                      variable Ceil

                                                                                                      const Ceil: string;

                                                                                                        variable clipByValue

                                                                                                        const clipByValue: <T extends Tensor<Rank>>(
                                                                                                        x: TensorLike | T,
                                                                                                        clipValueMin: number,
                                                                                                        clipValueMax: number
                                                                                                        ) => T;

                                                                                                          variable ClipByValue

                                                                                                          const ClipByValue: string;

                                                                                                            variable clone

                                                                                                            const clone: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                              variable complex

                                                                                                              const complex: <T extends Tensor<Rank>>(
                                                                                                              real: TensorLike | T,
                                                                                                              imag: TensorLike | T
                                                                                                              ) => T;

                                                                                                                variable Complex

                                                                                                                const Complex: string;

                                                                                                                  variable ComplexAbs

                                                                                                                  const ComplexAbs: string;

                                                                                                                    variable concat

                                                                                                                    const concat: <T extends Tensor<Rank>>(
                                                                                                                    tensors: (TensorLike | T)[],
                                                                                                                    axis?: number
                                                                                                                    ) => T;

                                                                                                                      variable Concat

                                                                                                                      const Concat: string;

                                                                                                                        variable concat1d

                                                                                                                        const concat1d: (tensors: (TensorLike | Tensor1D)[]) => Tensor1D;

                                                                                                                          variable concat2d

                                                                                                                          const concat2d: (tensors: (TensorLike | Tensor2D)[], axis: number) => Tensor2D;

                                                                                                                            variable concat3d

                                                                                                                            const concat3d: (tensors: (TensorLike | Tensor3D)[], axis: number) => Tensor3D;

                                                                                                                              variable concat4d

                                                                                                                              const concat4d: (tensors: (TensorLike | Tensor4D)[], axis: number) => Tensor4D;

                                                                                                                                variable conv1d

                                                                                                                                const conv1d: <T extends Tensor2D | Tensor3D>(
                                                                                                                                x: TensorLike | T,
                                                                                                                                filter: TensorLike | Tensor3D,
                                                                                                                                stride: number,
                                                                                                                                pad: number | 'valid' | 'same' | conv_util.ExplicitPadding,
                                                                                                                                dataFormat?: 'NWC' | 'NCW',
                                                                                                                                dilation?: number,
                                                                                                                                dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                                                                                                ) => T;

                                                                                                                                  variable conv2d

                                                                                                                                  const conv2d: <T extends Tensor3D | Tensor4D>(
                                                                                                                                  x: TensorLike | T,
                                                                                                                                  filter: TensorLike | Tensor4D,
                                                                                                                                  strides: number | [number, number],
                                                                                                                                  pad: number | 'valid' | 'same' | conv_util.ExplicitPadding,
                                                                                                                                  dataFormat?: 'NHWC' | 'NCHW',
                                                                                                                                  dilations?: number | [number, number],
                                                                                                                                  dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                                                                                                  ) => T;

                                                                                                                                    variable Conv2D

                                                                                                                                    const Conv2D: string;

                                                                                                                                      variable Conv2DBackpropFilter

                                                                                                                                      const Conv2DBackpropFilter: string;

                                                                                                                                        variable Conv2DBackpropInput

                                                                                                                                        const Conv2DBackpropInput: string;

                                                                                                                                          variable conv2dTranspose

                                                                                                                                          const conv2dTranspose: <T extends Tensor3D | Tensor4D>(
                                                                                                                                          x: TensorLike | T,
                                                                                                                                          filter: TensorLike | Tensor4D,
                                                                                                                                          outputShape: [number, number, number] | [number, number, number, number],
                                                                                                                                          strides: number | [number, number],
                                                                                                                                          pad: number | 'valid' | 'same',
                                                                                                                                          dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                                                                                                          ) => T;

                                                                                                                                            variable conv3d

                                                                                                                                            const conv3d: <T extends Tensor4D | Tensor5D>(
                                                                                                                                            x: TensorLike | T,
                                                                                                                                            filter: TensorLike | Tensor5D,
                                                                                                                                            strides: number | [number, number, number],
                                                                                                                                            pad: 'valid' | 'same',
                                                                                                                                            dataFormat?: 'NDHWC' | 'NCDHW',
                                                                                                                                            dilations?: number | [number, number, number]
                                                                                                                                            ) => T;

                                                                                                                                              variable Conv3D

                                                                                                                                              const Conv3D: string;

                                                                                                                                                variable Conv3DBackpropFilterV2

                                                                                                                                                const Conv3DBackpropFilterV2: string;

                                                                                                                                                  variable Conv3DBackpropInputV2

                                                                                                                                                  const Conv3DBackpropInputV2: string;

                                                                                                                                                    variable conv3dTranspose

                                                                                                                                                    const conv3dTranspose: <T extends Tensor4D | Tensor5D>(
                                                                                                                                                    x: TensorLike | T,
                                                                                                                                                    filter: TensorLike | Tensor5D,
                                                                                                                                                    outputShape:
                                                                                                                                                    | [number, number, number, number]
                                                                                                                                                    | [number, number, number, number, number],
                                                                                                                                                    strides: number | [number, number, number],
                                                                                                                                                    pad: 'valid' | 'same'
                                                                                                                                                    ) => T;

                                                                                                                                                      variable cos

                                                                                                                                                      const cos: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                        variable Cos

                                                                                                                                                        const Cos: string;

                                                                                                                                                          variable cosh

                                                                                                                                                          const cosh: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                            variable Cosh

                                                                                                                                                            const Cosh: string;

                                                                                                                                                              variable CropAndResize

                                                                                                                                                              const CropAndResize: string;

                                                                                                                                                                variable cumsum

                                                                                                                                                                const cumsum: <T extends Tensor<Rank>>(
                                                                                                                                                                x: Tensor<Rank> | TensorLike,
                                                                                                                                                                axis?: number,
                                                                                                                                                                exclusive?: boolean,
                                                                                                                                                                reverse?: boolean
                                                                                                                                                                ) => T;

                                                                                                                                                                  variable Cumsum

                                                                                                                                                                  const Cumsum: string;

                                                                                                                                                                    variable denseBincount

                                                                                                                                                                    const denseBincount: <T extends Tensor1D | Tensor2D>(
                                                                                                                                                                    x: TensorLike | T,
                                                                                                                                                                    weights: TensorLike | T,
                                                                                                                                                                    size: number,
                                                                                                                                                                    binaryOutput?: boolean
                                                                                                                                                                    ) => T;

                                                                                                                                                                      variable DenseBincount

                                                                                                                                                                      const DenseBincount: string;

                                                                                                                                                                        variable depthToSpace

                                                                                                                                                                        const depthToSpace: (
                                                                                                                                                                        x: Tensor4D | TensorLike4D,
                                                                                                                                                                        blockSize: number,
                                                                                                                                                                        dataFormat?: 'NHWC' | 'NCHW'
                                                                                                                                                                        ) => Tensor4D;

                                                                                                                                                                          variable DepthToSpace

                                                                                                                                                                          const DepthToSpace: string;

                                                                                                                                                                            variable depthwiseConv2d

                                                                                                                                                                            const depthwiseConv2d: <T extends Tensor3D | Tensor4D>(
                                                                                                                                                                            x: TensorLike | T,
                                                                                                                                                                            filter: TensorLike | Tensor4D,
                                                                                                                                                                            strides: number | [number, number],
                                                                                                                                                                            pad: number | 'valid' | 'same' | ExplicitPadding,
                                                                                                                                                                            dataFormat?: 'NHWC' | 'NCHW',
                                                                                                                                                                            dilations?: number | [number, number],
                                                                                                                                                                            dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                                                                                                                                            ) => T;

                                                                                                                                                                              variable DepthwiseConv2dNative

                                                                                                                                                                              const DepthwiseConv2dNative: string;

                                                                                                                                                                                variable DepthwiseConv2dNativeBackpropFilter

                                                                                                                                                                                const DepthwiseConv2dNativeBackpropFilter: string;

                                                                                                                                                                                  variable DepthwiseConv2dNativeBackpropInput

                                                                                                                                                                                  const DepthwiseConv2dNativeBackpropInput: string;

                                                                                                                                                                                    variable diag

                                                                                                                                                                                    const diag: (x: Tensor<Rank>) => Tensor<Rank>;

                                                                                                                                                                                      variable Diag

                                                                                                                                                                                      const Diag: string;

                                                                                                                                                                                        variable dilation2d

                                                                                                                                                                                        const dilation2d: <T extends Tensor3D | Tensor4D>(
                                                                                                                                                                                        x: TensorLike | T,
                                                                                                                                                                                        filter: TensorLike | Tensor3D,
                                                                                                                                                                                        strides: number | [number, number],
                                                                                                                                                                                        pad: 'valid' | 'same',
                                                                                                                                                                                        dilations?: number | [number, number],
                                                                                                                                                                                        dataFormat?: 'NHWC'
                                                                                                                                                                                        ) => T;

                                                                                                                                                                                          variable Dilation2D

                                                                                                                                                                                          const Dilation2D: string;

                                                                                                                                                                                            variable Dilation2DBackpropFilter

                                                                                                                                                                                            const Dilation2DBackpropFilter: string;

                                                                                                                                                                                              variable Dilation2DBackpropInput

                                                                                                                                                                                              const Dilation2DBackpropInput: string;

                                                                                                                                                                                                variable div

                                                                                                                                                                                                const div: <T extends Tensor<Rank>>(
                                                                                                                                                                                                a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                ) => T;

                                                                                                                                                                                                  variable divNoNan

                                                                                                                                                                                                  const divNoNan: <T extends Tensor<Rank>>(
                                                                                                                                                                                                  a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                  b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                    variable dot

                                                                                                                                                                                                    const dot: (
                                                                                                                                                                                                    t1: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                    t2: Tensor<Rank> | TensorLike
                                                                                                                                                                                                    ) => Tensor<Rank>;

                                                                                                                                                                                                      variable dropout

                                                                                                                                                                                                      const dropout: (
                                                                                                                                                                                                      x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                      rate: number,
                                                                                                                                                                                                      noiseShape?: number[],
                                                                                                                                                                                                      seed?: string | number
                                                                                                                                                                                                      ) => Tensor<Rank>;

                                                                                                                                                                                                        variable einsum

                                                                                                                                                                                                        const einsum: (equation: string, ...tensors: Tensor<Rank>[]) => Tensor<Rank>;

                                                                                                                                                                                                          variable Einsum

                                                                                                                                                                                                          const Einsum: string;

                                                                                                                                                                                                            variable elu

                                                                                                                                                                                                            const elu: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                              variable Elu

                                                                                                                                                                                                              const Elu: string;

                                                                                                                                                                                                                variable EluGrad

                                                                                                                                                                                                                const EluGrad: string;

                                                                                                                                                                                                                  variable ENV

                                                                                                                                                                                                                  let ENV: Environment;

                                                                                                                                                                                                                    variable equal

                                                                                                                                                                                                                    const equal: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                    a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                    b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                      variable Equal

                                                                                                                                                                                                                      const Equal: string;

                                                                                                                                                                                                                        variable erf

                                                                                                                                                                                                                        const erf: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                          variable Erf

                                                                                                                                                                                                                          const Erf: string;

                                                                                                                                                                                                                            variable exp

                                                                                                                                                                                                                            const exp: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                              variable Exp

                                                                                                                                                                                                                              const Exp: string;

                                                                                                                                                                                                                                variable expandDims

                                                                                                                                                                                                                                const expandDims: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                axis?: number
                                                                                                                                                                                                                                ) => T;

                                                                                                                                                                                                                                  variable ExpandDims

                                                                                                                                                                                                                                  const ExpandDims: string;

                                                                                                                                                                                                                                    variable expm1

                                                                                                                                                                                                                                    const expm1: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                      variable Expm1

                                                                                                                                                                                                                                      const Expm1: string;

                                                                                                                                                                                                                                        variable eye

                                                                                                                                                                                                                                        const eye: (
                                                                                                                                                                                                                                        numRows: number,
                                                                                                                                                                                                                                        numColumns?: number,
                                                                                                                                                                                                                                        batchShape?:
                                                                                                                                                                                                                                        | [number]
                                                                                                                                                                                                                                        | [number, number]
                                                                                                                                                                                                                                        | [number, number, number]
                                                                                                                                                                                                                                        | [number, number, number, number],
                                                                                                                                                                                                                                        dtype?: keyof DataTypeMap
                                                                                                                                                                                                                                        ) => Tensor2D;

                                                                                                                                                                                                                                          variable fft

                                                                                                                                                                                                                                          const fft: (input: Tensor<Rank>) => Tensor<Rank>;

                                                                                                                                                                                                                                            variable FFT

                                                                                                                                                                                                                                            const FFT: string;

                                                                                                                                                                                                                                              variable Fill

                                                                                                                                                                                                                                              const Fill: string;

                                                                                                                                                                                                                                                variable FlipLeftRight

                                                                                                                                                                                                                                                const FlipLeftRight: string;

                                                                                                                                                                                                                                                  variable floor

                                                                                                                                                                                                                                                  const floor: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                    variable Floor

                                                                                                                                                                                                                                                    const Floor: string;

                                                                                                                                                                                                                                                      variable floorDiv

                                                                                                                                                                                                                                                      const floorDiv: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                      a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                      b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                      ) => T;

                                                                                                                                                                                                                                                        variable FloorDiv

                                                                                                                                                                                                                                                        const FloorDiv: string;

                                                                                                                                                                                                                                                          variable FromPixels

                                                                                                                                                                                                                                                          const FromPixels: string;

                                                                                                                                                                                                                                                            variable FusedBatchNorm

                                                                                                                                                                                                                                                            const FusedBatchNorm: string;

                                                                                                                                                                                                                                                              variable FusedConv2D

                                                                                                                                                                                                                                                              const FusedConv2D: string;

                                                                                                                                                                                                                                                                variable FusedDepthwiseConv2D

                                                                                                                                                                                                                                                                const FusedDepthwiseConv2D: string;

                                                                                                                                                                                                                                                                  variable gather

                                                                                                                                                                                                                                                                  const gather: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                  x: TensorLike | T,
                                                                                                                                                                                                                                                                  indices: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                  axis?: number,
                                                                                                                                                                                                                                                                  batchDims?: number
                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                    variable gatherND

                                                                                                                                                                                                                                                                    const gatherND: (
                                                                                                                                                                                                                                                                    x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                    indices: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                    ) => Tensor<Rank>;

                                                                                                                                                                                                                                                                      variable GatherNd

                                                                                                                                                                                                                                                                      const GatherNd: string;

                                                                                                                                                                                                                                                                        variable GatherV2

                                                                                                                                                                                                                                                                        const GatherV2: string;

                                                                                                                                                                                                                                                                          variable greater

                                                                                                                                                                                                                                                                          const greater: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                          a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                          b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                          ) => T;

                                                                                                                                                                                                                                                                            variable Greater

                                                                                                                                                                                                                                                                            const Greater: string;

                                                                                                                                                                                                                                                                              variable greaterEqual

                                                                                                                                                                                                                                                                              const greaterEqual: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                              a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                              b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                variable GreaterEqual

                                                                                                                                                                                                                                                                                const GreaterEqual: string;

                                                                                                                                                                                                                                                                                  variable Identity

                                                                                                                                                                                                                                                                                  const Identity: string;

                                                                                                                                                                                                                                                                                    variable ifft

                                                                                                                                                                                                                                                                                    const ifft: (input: Tensor<Rank>) => Tensor<Rank>;

                                                                                                                                                                                                                                                                                      variable IFFT

                                                                                                                                                                                                                                                                                      const IFFT: string;

                                                                                                                                                                                                                                                                                        variable imag

                                                                                                                                                                                                                                                                                        const imag: <T extends Tensor<Rank>>(input: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                          variable Imag

                                                                                                                                                                                                                                                                                          const Imag: string;

                                                                                                                                                                                                                                                                                            variable image

                                                                                                                                                                                                                                                                                            const image: {
                                                                                                                                                                                                                                                                                            flipLeftRight: (
                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R4>
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R4>;
                                                                                                                                                                                                                                                                                            resizeNearestNeighbor: <T extends Tensor<Rank.R3> | Tensor<Rank.R4>>(
                                                                                                                                                                                                                                                                                            images:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | T,
                                                                                                                                                                                                                                                                                            size: [number, number],
                                                                                                                                                                                                                                                                                            alignCorners?: boolean,
                                                                                                                                                                                                                                                                                            halfPixelCenters?: boolean
                                                                                                                                                                                                                                                                                            ) => T;
                                                                                                                                                                                                                                                                                            resizeBilinear: <T extends Tensor<Rank.R3> | Tensor<Rank.R4>>(
                                                                                                                                                                                                                                                                                            images:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | T,
                                                                                                                                                                                                                                                                                            size: [number, number],
                                                                                                                                                                                                                                                                                            alignCorners?: boolean,
                                                                                                                                                                                                                                                                                            halfPixelCenters?: boolean
                                                                                                                                                                                                                                                                                            ) => T;
                                                                                                                                                                                                                                                                                            rotateWithOffset: (
                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R4>,
                                                                                                                                                                                                                                                                                            radians: number,
                                                                                                                                                                                                                                                                                            fillValue?: number | [number, number, number],
                                                                                                                                                                                                                                                                                            center?: number | [number, number]
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R4>;
                                                                                                                                                                                                                                                                                            cropAndResize: (
                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R4>,
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            boxInd:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            cropSize: [number, number],
                                                                                                                                                                                                                                                                                            method?: 'nearest' | 'bilinear',
                                                                                                                                                                                                                                                                                            extrapolationValue?: number
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R4>;
                                                                                                                                                                                                                                                                                            nonMaxSuppression: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R1>;
                                                                                                                                                                                                                                                                                            nonMaxSuppressionAsync: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number
                                                                                                                                                                                                                                                                                            ) => Promise<import('..').Tensor<import('..').Rank.R1>>;
                                                                                                                                                                                                                                                                                            nonMaxSuppressionWithScore: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number,
                                                                                                                                                                                                                                                                                            softNmsSigma?: number
                                                                                                                                                                                                                                                                                            ) => import('..').NamedTensorMap;
                                                                                                                                                                                                                                                                                            nonMaxSuppressionWithScoreAsync: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number,
                                                                                                                                                                                                                                                                                            softNmsSigma?: number
                                                                                                                                                                                                                                                                                            ) => Promise<import('..').NamedTensorMap>;
                                                                                                                                                                                                                                                                                            nonMaxSuppressionPadded: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number,
                                                                                                                                                                                                                                                                                            padToMaxOutputSize?: boolean
                                                                                                                                                                                                                                                                                            ) => import('..').NamedTensorMap;
                                                                                                                                                                                                                                                                                            nonMaxSuppressionPaddedAsync: (
                                                                                                                                                                                                                                                                                            boxes:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            scores:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R1>,
                                                                                                                                                                                                                                                                                            maxOutputSize: number,
                                                                                                                                                                                                                                                                                            iouThreshold?: number,
                                                                                                                                                                                                                                                                                            scoreThreshold?: number,
                                                                                                                                                                                                                                                                                            padToMaxOutputSize?: boolean
                                                                                                                                                                                                                                                                                            ) => Promise<import('..').NamedTensorMap>;
                                                                                                                                                                                                                                                                                            threshold: (
                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R3>,
                                                                                                                                                                                                                                                                                            method?: string,
                                                                                                                                                                                                                                                                                            inverted?: boolean,
                                                                                                                                                                                                                                                                                            threshValue?: number
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R3>;
                                                                                                                                                                                                                                                                                            transform: (
                                                                                                                                                                                                                                                                                            image:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R4>,
                                                                                                                                                                                                                                                                                            transforms:
                                                                                                                                                                                                                                                                                            | string
                                                                                                                                                                                                                                                                                            | number
                                                                                                                                                                                                                                                                                            | boolean
                                                                                                                                                                                                                                                                                            | Float32Array
                                                                                                                                                                                                                                                                                            | Int32Array
                                                                                                                                                                                                                                                                                            | Uint8Array
                                                                                                                                                                                                                                                                                            | Uint8Array[]
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                            number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                            >
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                            | import('..').RecursiveArray<string>
                                                                                                                                                                                                                                                                                            | import('..').Tensor<import('..').Rank.R2>,
                                                                                                                                                                                                                                                                                            interpolation?: 'nearest' | 'bilinear',
                                                                                                                                                                                                                                                                                            fillMode?: 'reflect' | 'nearest' | 'constant' | 'wrap',
                                                                                                                                                                                                                                                                                            fillValue?: number,
                                                                                                                                                                                                                                                                                            outputShape?: [number, number]
                                                                                                                                                                                                                                                                                            ) => import('..').Tensor<import('..').Rank.R4>;
                                                                                                                                                                                                                                                                                            };

                                                                                                                                                                                                                                                                                              variable inTopKAsync

                                                                                                                                                                                                                                                                                              const inTopKAsync: <T extends Tensor<Rank>, U extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                              predictions: TensorLike | T,
                                                                                                                                                                                                                                                                                              targets: TensorLike | U,
                                                                                                                                                                                                                                                                                              k?: number
                                                                                                                                                                                                                                                                                              ) => Promise<U>;

                                                                                                                                                                                                                                                                                                variable irfft

                                                                                                                                                                                                                                                                                                const irfft: (input: Tensor<Rank>) => Tensor<Rank>;

                                                                                                                                                                                                                                                                                                  variable isFinite

                                                                                                                                                                                                                                                                                                  const isFinite: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                    variable IsFinite

                                                                                                                                                                                                                                                                                                    const IsFinite: string;

                                                                                                                                                                                                                                                                                                      variable isInf

                                                                                                                                                                                                                                                                                                      const isInf: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                        variable IsInf

                                                                                                                                                                                                                                                                                                        const IsInf: string;

                                                                                                                                                                                                                                                                                                          variable isNaN

                                                                                                                                                                                                                                                                                                          const isNaN: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                            variable IsNan

                                                                                                                                                                                                                                                                                                            const IsNan: string;

                                                                                                                                                                                                                                                                                                              variable leakyRelu

                                                                                                                                                                                                                                                                                                              const leakyRelu: <T extends Tensor<Rank>>(x: TensorLike | T, alpha?: number) => T;

                                                                                                                                                                                                                                                                                                                variable LeakyRelu

                                                                                                                                                                                                                                                                                                                const LeakyRelu: string;

                                                                                                                                                                                                                                                                                                                  variable less

                                                                                                                                                                                                                                                                                                                  const less: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                  a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                  b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                    variable Less

                                                                                                                                                                                                                                                                                                                    const Less: string;

                                                                                                                                                                                                                                                                                                                      variable lessEqual

                                                                                                                                                                                                                                                                                                                      const lessEqual: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                      a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                      b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                      ) => T;

                                                                                                                                                                                                                                                                                                                        variable LessEqual

                                                                                                                                                                                                                                                                                                                        const LessEqual: string;

                                                                                                                                                                                                                                                                                                                          variable linalg

                                                                                                                                                                                                                                                                                                                          const linalg: {
                                                                                                                                                                                                                                                                                                                          bandPart: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                          a:
                                                                                                                                                                                                                                                                                                                          | string
                                                                                                                                                                                                                                                                                                                          | number
                                                                                                                                                                                                                                                                                                                          | boolean
                                                                                                                                                                                                                                                                                                                          | Uint8Array
                                                                                                                                                                                                                                                                                                                          | Uint8Array[]
                                                                                                                                                                                                                                                                                                                          | Float32Array
                                                                                                                                                                                                                                                                                                                          | Int32Array
                                                                                                                                                                                                                                                                                                                          | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                          | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                          | RecursiveArray<
                                                                                                                                                                                                                                                                                                                          number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                          >
                                                                                                                                                                                                                                                                                                                          | T,
                                                                                                                                                                                                                                                                                                                          numLower: number,
                                                                                                                                                                                                                                                                                                                          numUpper: number
                                                                                                                                                                                                                                                                                                                          ) => T;
                                                                                                                                                                                                                                                                                                                          gramSchmidt: (
                                                                                                                                                                                                                                                                                                                          xs:
                                                                                                                                                                                                                                                                                                                          | import('..').Tensor<import('..').Rank.R2>
                                                                                                                                                                                                                                                                                                                          | import('..').Tensor<import('..').Rank.R1>[]
                                                                                                                                                                                                                                                                                                                          ) =>
                                                                                                                                                                                                                                                                                                                          | import('..').Tensor<import('..').Rank.R2>
                                                                                                                                                                                                                                                                                                                          | import('..').Tensor<import('..').Rank.R1>[];
                                                                                                                                                                                                                                                                                                                          qr: (
                                                                                                                                                                                                                                                                                                                          x: import('..').Tensor<import('..').Rank>,
                                                                                                                                                                                                                                                                                                                          fullMatrices?: boolean
                                                                                                                                                                                                                                                                                                                          ) => [
                                                                                                                                                                                                                                                                                                                          import('..').Tensor<import('..').Rank>,
                                                                                                                                                                                                                                                                                                                          import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                          ];
                                                                                                                                                                                                                                                                                                                          };

                                                                                                                                                                                                                                                                                                                            variable LinSpace

                                                                                                                                                                                                                                                                                                                            const LinSpace: string;

                                                                                                                                                                                                                                                                                                                              variable localResponseNormalization

                                                                                                                                                                                                                                                                                                                              const localResponseNormalization: <T extends Tensor3D | Tensor4D>(
                                                                                                                                                                                                                                                                                                                              x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                              depthRadius?: number,
                                                                                                                                                                                                                                                                                                                              bias?: number,
                                                                                                                                                                                                                                                                                                                              alpha?: number,
                                                                                                                                                                                                                                                                                                                              beta?: number
                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                variable log

                                                                                                                                                                                                                                                                                                                                const log: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                                                  variable Log

                                                                                                                                                                                                                                                                                                                                  const Log: string;

                                                                                                                                                                                                                                                                                                                                    variable log1p

                                                                                                                                                                                                                                                                                                                                    const log1p: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                                                      variable Log1p

                                                                                                                                                                                                                                                                                                                                      const Log1p: string;

                                                                                                                                                                                                                                                                                                                                        variable logicalAnd

                                                                                                                                                                                                                                                                                                                                        const logicalAnd: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                        a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                        b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                        ) => T;

                                                                                                                                                                                                                                                                                                                                          variable LogicalAnd

                                                                                                                                                                                                                                                                                                                                          const LogicalAnd: string;

                                                                                                                                                                                                                                                                                                                                            variable logicalNot

                                                                                                                                                                                                                                                                                                                                            const logicalNot: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                                                              variable LogicalNot

                                                                                                                                                                                                                                                                                                                                              const LogicalNot: string;

                                                                                                                                                                                                                                                                                                                                                variable logicalOr

                                                                                                                                                                                                                                                                                                                                                const logicalOr: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                ) => T;

                                                                                                                                                                                                                                                                                                                                                  variable LogicalOr

                                                                                                                                                                                                                                                                                                                                                  const LogicalOr: string;

                                                                                                                                                                                                                                                                                                                                                    variable logicalXor

                                                                                                                                                                                                                                                                                                                                                    const logicalXor: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                    a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                    b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                                                                                                                                                      variable logSigmoid

                                                                                                                                                                                                                                                                                                                                                      const logSigmoid: <T extends Tensor<Rank>>(x: TensorLike | T) => T;

                                                                                                                                                                                                                                                                                                                                                        variable logSoftmax

                                                                                                                                                                                                                                                                                                                                                        const logSoftmax: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                        logits: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                        axis?: number
                                                                                                                                                                                                                                                                                                                                                        ) => T;

                                                                                                                                                                                                                                                                                                                                                          variable LogSoftmax

                                                                                                                                                                                                                                                                                                                                                          const LogSoftmax: string;

                                                                                                                                                                                                                                                                                                                                                            variable logSumExp

                                                                                                                                                                                                                                                                                                                                                            const logSumExp: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                            x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                            axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                            keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                            ) => T;

                                                                                                                                                                                                                                                                                                                                                              variable losses

                                                                                                                                                                                                                                                                                                                                                              const losses: {
                                                                                                                                                                                                                                                                                                                                                              absoluteDifference: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              computeWeightedLoss: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              losses:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              cosineDistance: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              axis: number,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              hingeLoss: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              huberLoss: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              delta?: number,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              logLoss: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              epsilon?: number,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              meanSquaredError: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              labels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              predictions:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              sigmoidCrossEntropy: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              multiClassLabels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              logits:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              labelSmoothing?: number,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              softmaxCrossEntropy: <T extends Tensor<Rank>, O extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                              onehotLabels:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              logits:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                              | RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Uint8Array | Float32Array | Int32Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | T,
                                                                                                                                                                                                                                                                                                                                                              weights?:
                                                                                                                                                                                                                                                                                                                                                              | string
                                                                                                                                                                                                                                                                                                                                                              | number
                                                                                                                                                                                                                                                                                                                                                              | boolean
                                                                                                                                                                                                                                                                                                                                                              | import('..').Tensor<import('..').Rank>
                                                                                                                                                                                                                                                                                                                                                              | Float32Array
                                                                                                                                                                                                                                                                                                                                                              | Int32Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                              number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                              | import('..').RecursiveArray<string>,
                                                                                                                                                                                                                                                                                                                                                              labelSmoothing?: number,
                                                                                                                                                                                                                                                                                                                                                              reduction?: import('./loss_ops_utils').Reduction
                                                                                                                                                                                                                                                                                                                                                              ) => O;
                                                                                                                                                                                                                                                                                                                                                              };

                                                                                                                                                                                                                                                                                                                                                                variable LRN

                                                                                                                                                                                                                                                                                                                                                                const LRN: string;

                                                                                                                                                                                                                                                                                                                                                                  variable LRNGrad

                                                                                                                                                                                                                                                                                                                                                                  const LRNGrad: string;

                                                                                                                                                                                                                                                                                                                                                                    variable matMul

                                                                                                                                                                                                                                                                                                                                                                    const matMul: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                    a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                    b: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                    transposeA?: boolean,
                                                                                                                                                                                                                                                                                                                                                                    transposeB?: boolean
                                                                                                                                                                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                                                                                                                                                                      variable max

                                                                                                                                                                                                                                                                                                                                                                      const max: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                      x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                      axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                                      keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                                      ) => T;

                                                                                                                                                                                                                                                                                                                                                                        variable Max

                                                                                                                                                                                                                                                                                                                                                                        const Max: string;

                                                                                                                                                                                                                                                                                                                                                                          variable maximum

                                                                                                                                                                                                                                                                                                                                                                          const maximum: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                          a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                          b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                                          ) => T;

                                                                                                                                                                                                                                                                                                                                                                            variable Maximum

                                                                                                                                                                                                                                                                                                                                                                            const Maximum: string;

                                                                                                                                                                                                                                                                                                                                                                              variable maxPool

                                                                                                                                                                                                                                                                                                                                                                              const maxPool: <T extends Tensor3D | Tensor4D>(
                                                                                                                                                                                                                                                                                                                                                                              x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                              filterSize: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                              strides: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                              pad: number | 'valid' | 'same',
                                                                                                                                                                                                                                                                                                                                                                              dimRoundingMode?: 'floor' | 'round' | 'ceil'
                                                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                                                variable MaxPool

                                                                                                                                                                                                                                                                                                                                                                                const MaxPool: string;

                                                                                                                                                                                                                                                                                                                                                                                  variable maxPool3d

                                                                                                                                                                                                                                                                                                                                                                                  const maxPool3d: <T extends Tensor4D | Tensor5D>(
                                                                                                                                                                                                                                                                                                                                                                                  x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                  filterSize: number | [number, number, number],
                                                                                                                                                                                                                                                                                                                                                                                  strides: number | [number, number, number],
                                                                                                                                                                                                                                                                                                                                                                                  pad: number | 'valid' | 'same',
                                                                                                                                                                                                                                                                                                                                                                                  dimRoundingMode?: 'floor' | 'round' | 'ceil',
                                                                                                                                                                                                                                                                                                                                                                                  dataFormat?: 'NDHWC' | 'NCDHW'
                                                                                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                                                                                    variable MaxPool3D

                                                                                                                                                                                                                                                                                                                                                                                    const MaxPool3D: string;

                                                                                                                                                                                                                                                                                                                                                                                      variable MaxPool3DGrad

                                                                                                                                                                                                                                                                                                                                                                                      const MaxPool3DGrad: string;

                                                                                                                                                                                                                                                                                                                                                                                        variable MaxPoolGrad

                                                                                                                                                                                                                                                                                                                                                                                        const MaxPoolGrad: string;

                                                                                                                                                                                                                                                                                                                                                                                          variable maxPoolWithArgmax

                                                                                                                                                                                                                                                                                                                                                                                          const maxPoolWithArgmax: <T extends Tensor4D>(
                                                                                                                                                                                                                                                                                                                                                                                          x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                          filterSize: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                                          strides: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                                          pad: number | 'valid' | 'same',
                                                                                                                                                                                                                                                                                                                                                                                          includeBatchInIndex?: boolean
                                                                                                                                                                                                                                                                                                                                                                                          ) => NamedTensorMap;

                                                                                                                                                                                                                                                                                                                                                                                            variable MaxPoolWithArgmax

                                                                                                                                                                                                                                                                                                                                                                                            const MaxPoolWithArgmax: string;

                                                                                                                                                                                                                                                                                                                                                                                              variable mean

                                                                                                                                                                                                                                                                                                                                                                                              const mean: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                              x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                              axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                                                              keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                variable Mean

                                                                                                                                                                                                                                                                                                                                                                                                const Mean: string;

                                                                                                                                                                                                                                                                                                                                                                                                  variable min

                                                                                                                                                                                                                                                                                                                                                                                                  const min: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                  x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                  axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                                                                  keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                    variable Min

                                                                                                                                                                                                                                                                                                                                                                                                    const Min: string;

                                                                                                                                                                                                                                                                                                                                                                                                      variable minimum

                                                                                                                                                                                                                                                                                                                                                                                                      const minimum: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                      a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                      b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                                                                      ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                        variable Minimum

                                                                                                                                                                                                                                                                                                                                                                                                        const Minimum: string;

                                                                                                                                                                                                                                                                                                                                                                                                          variable mirrorPad

                                                                                                                                                                                                                                                                                                                                                                                                          const mirrorPad: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                          x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                                          paddings: [number, number][],
                                                                                                                                                                                                                                                                                                                                                                                                          mode: 'reflect' | 'symmetric'
                                                                                                                                                                                                                                                                                                                                                                                                          ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                            variable MirrorPad

                                                                                                                                                                                                                                                                                                                                                                                                            const MirrorPad: string;

                                                                                                                                                                                                                                                                                                                                                                                                              variable mod

                                                                                                                                                                                                                                                                                                                                                                                                              const mod: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                              a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                              b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                variable Mod

                                                                                                                                                                                                                                                                                                                                                                                                                const Mod: string;

                                                                                                                                                                                                                                                                                                                                                                                                                  variable moments

                                                                                                                                                                                                                                                                                                                                                                                                                  const moments: (
                                                                                                                                                                                                                                                                                                                                                                                                                  x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                                  axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                                                                                  keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                  ) => { mean: Tensor<Rank>; variance: Tensor<Rank> };

                                                                                                                                                                                                                                                                                                                                                                                                                    variable movingAverage

                                                                                                                                                                                                                                                                                                                                                                                                                    const movingAverage: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                                    v: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                                                    x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                                                    decay: number | Scalar,
                                                                                                                                                                                                                                                                                                                                                                                                                    step?: number | Scalar,
                                                                                                                                                                                                                                                                                                                                                                                                                    zeroDebias?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                    ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                      variable mul

                                                                                                                                                                                                                                                                                                                                                                                                                      const