@tensorflow/tfjs-core

  • Version 3.9.0
  • Published
  • 33.5 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' | conv_util.ExplicitPadding,
                                                          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 broadcastArgs

                                                                                            const broadcastArgs: <R extends Rank>(
                                                                                            s0: Tensor<Rank> | TensorLike,
                                                                                            s1: Tensor<Rank> | TensorLike
                                                                                            ) => Tensor<R>;

                                                                                              variable BroadcastArgs

                                                                                              const BroadcastArgs: string;

                                                                                                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' | ExplicitPadding,
                                                                                                                                              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
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R4
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                grayscaleToRGB: <T extends unknown>(image: any) => T;
                                                                                                                                                                                                                                                                                                resizeNearestNeighbor: <T extends unknown>(
                                                                                                                                                                                                                                                                                                images: any,
                                                                                                                                                                                                                                                                                                size: [number, number],
                                                                                                                                                                                                                                                                                                alignCorners?: boolean,
                                                                                                                                                                                                                                                                                                halfPixelCenters?: boolean
                                                                                                                                                                                                                                                                                                ) => T;
                                                                                                                                                                                                                                                                                                resizeBilinear: <T extends unknown>(
                                                                                                                                                                                                                                                                                                images: any,
                                                                                                                                                                                                                                                                                                size: [number, number],
                                                                                                                                                                                                                                                                                                alignCorners?: boolean,
                                                                                                                                                                                                                                                                                                halfPixelCenters?: boolean
                                                                                                                                                                                                                                                                                                ) => T;
                                                                                                                                                                                                                                                                                                rotateWithOffset: (
                                                                                                                                                                                                                                                                                                image:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R4
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                radians: number,
                                                                                                                                                                                                                                                                                                fillValue?: number | [number, number, number],
                                                                                                                                                                                                                                                                                                center?: number | [number, number]
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                cropAndResize: (
                                                                                                                                                                                                                                                                                                image:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R4
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                boxInd:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                cropSize: [number, number],
                                                                                                                                                                                                                                                                                                method?: 'bilinear' | 'nearest',
                                                                                                                                                                                                                                                                                                extrapolationValue?: number
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                nonMaxSuppression: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                nonMaxSuppressionAsync: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number
                                                                                                                                                                                                                                                                                                ) => Promise<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                >;
                                                                                                                                                                                                                                                                                                nonMaxSuppressionWithScore: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number,
                                                                                                                                                                                                                                                                                                softNmsSigma?: number
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                nonMaxSuppressionWithScoreAsync: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number,
                                                                                                                                                                                                                                                                                                softNmsSigma?: number
                                                                                                                                                                                                                                                                                                ) => Promise<import('@tensorflow/tfjs-core/dist/tensor_types').NamedTensorMap>;
                                                                                                                                                                                                                                                                                                nonMaxSuppressionPadded: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number,
                                                                                                                                                                                                                                                                                                padToMaxOutputSize?: boolean
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                nonMaxSuppressionPaddedAsync: (
                                                                                                                                                                                                                                                                                                boxes:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                scores:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                maxOutputSize: number,
                                                                                                                                                                                                                                                                                                iouThreshold?: number,
                                                                                                                                                                                                                                                                                                scoreThreshold?: number,
                                                                                                                                                                                                                                                                                                padToMaxOutputSize?: boolean
                                                                                                                                                                                                                                                                                                ) => Promise<import('@tensorflow/tfjs-core/dist/tensor_types').NamedTensorMap>;
                                                                                                                                                                                                                                                                                                threshold: (
                                                                                                                                                                                                                                                                                                image:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R3
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                method?: string,
                                                                                                                                                                                                                                                                                                inverted?: boolean,
                                                                                                                                                                                                                                                                                                threshValue?: number
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                transform: (
                                                                                                                                                                                                                                                                                                image:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R4
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                transforms:
                                                                                                                                                                                                                                                                                                | string
                                                                                                                                                                                                                                                                                                | number
                                                                                                                                                                                                                                                                                                | boolean
                                                                                                                                                                                                                                                                                                | Float32Array
                                                                                                                                                                                                                                                                                                | Int32Array
                                                                                                                                                                                                                                                                                                | Uint8Array
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                >
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                | Uint8Array[]
                                                                                                                                                                                                                                                                                                | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                >,
                                                                                                                                                                                                                                                                                                interpolation?: 'bilinear' | 'nearest',
                                                                                                                                                                                                                                                                                                fillMode?: 'reflect' | 'nearest' | 'constant' | 'wrap',
                                                                                                                                                                                                                                                                                                fillValue?: number,
                                                                                                                                                                                                                                                                                                outputShape?: [number, number]
                                                                                                                                                                                                                                                                                                ) => any;
                                                                                                                                                                                                                                                                                                };

                                                                                                                                                                                                                                                                                                  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 any>(a: any, numLower: number, numUpper: number) => T;
                                                                                                                                                                                                                                                                                                                              gramSchmidt: (
                                                                                                                                                                                                                                                                                                                              xs:
                                                                                                                                                                                                                                                                                                                              | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                              | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                                              >[]
                                                                                                                                                                                                                                                                                                                              ) =>
                                                                                                                                                                                                                                                                                                                              | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').Rank.R2
                                                                                                                                                                                                                                                                                                                              >
                                                                                                                                                                                                                                                                                                                              | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').Rank.R1
                                                                                                                                                                                                                                                                                                                              >[];
                                                                                                                                                                                                                                                                                                                              qr: (
                                                                                                                                                                                                                                                                                                                              x: any,
                                                                                                                                                                                                                                                                                                                              fullMatrices?: boolean
                                                                                                                                                                                                                                                                                                                              ) => [
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                              >,
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                              import('@tensorflow/tfjs-core/dist/types').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 any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  computeWeightedLoss: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  losses: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  cosineDistance: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  axis: number,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  hingeLoss: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  huberLoss: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  delta?: number,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  logLoss: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  epsilon?: number,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  meanSquaredError: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  labels: any,
                                                                                                                                                                                                                                                                                                                                                                  predictions: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  sigmoidCrossEntropy: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  multiClassLabels: any,
                                                                                                                                                                                                                                                                                                                                                                  logits: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  labelSmoothing?: number,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => O;
                                                                                                                                                                                                                                                                                                                                                                  softmaxCrossEntropy: <T extends any, O extends any>(
                                                                                                                                                                                                                                                                                                                                                                  onehotLabels: any,
                                                                                                                                                                                                                                                                                                                                                                  logits: any,
                                                                                                                                                                                                                                                                                                                                                                  weights?:
                                                                                                                                                                                                                                                                                                                                                                  | string
                                                                                                                                                                                                                                                                                                                                                                  | number
                                                                                                                                                                                                                                                                                                                                                                  | boolean
                                                                                                                                                                                                                                                                                                                                                                  | Float32Array
                                                                                                                                                                                                                                                                                                                                                                  | Int32Array
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<
                                                                                                                                                                                                                                                                                                                                                                  number | number[] | Float32Array | Int32Array | Uint8Array
                                                                                                                                                                                                                                                                                                                                                                  >
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<boolean>
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/types').RecursiveArray<string>
                                                                                                                                                                                                                                                                                                                                                                  | Uint8Array[]
                                                                                                                                                                                                                                                                                                                                                                  | import('@tensorflow/tfjs-core/dist/tensor').Tensor<
                                                                                                                                                                                                                                                                                                                                                                  import('@tensorflow/tfjs-core/dist/types').Rank
                                                                                                                                                                                                                                                                                                                                                                  >,
                                                                                                                                                                                                                                                                                                                                                                  labelSmoothing?: number,
                                                                                                                                                                                                                                                                                                                                                                  reduction?: any
                                                                                                                                                                                                                                                                                                                                                                  ) => 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' | conv_util.ExplicitPadding,
                                                                                                                                                                                                                                                                                                                                                                                  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 mul: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                                          a: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                                          b: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                                                                                          ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                            variable multinomial

                                                                                                                                                                                                                                                                                                                                                                                                                            const multinomial: (
                                                                                                                                                                                                                                                                                                                                                                                                                            logits: TensorLike | Tensor1D | Tensor2D,
                                                                                                                                                                                                                                                                                                                                                                                                                            numSamples: number,
                                                                                                                                                                                                                                                                                                                                                                                                                            seed?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                            normalized?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                            ) => Tensor1D | Tensor2D;

                                                                                                                                                                                                                                                                                                                                                                                                                              variable Multinomial

                                                                                                                                                                                                                                                                                                                                                                                                                              const Multinomial: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                variable Multiply

                                                                                                                                                                                                                                                                                                                                                                                                                                const Multiply: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                  variable multiRNNCell

                                                                                                                                                                                                                                                                                                                                                                                                                                  const multiRNNCell: (
                                                                                                                                                                                                                                                                                                                                                                                                                                  lstmCells: LSTMCellFunc[],
                                                                                                                                                                                                                                                                                                                                                                                                                                  data: TensorLike | Tensor2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                  c: (TensorLike | Tensor2D)[],
                                                                                                                                                                                                                                                                                                                                                                                                                                  h: (TensorLike | Tensor2D)[]
                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => [Tensor2D[], Tensor2D[]];

                                                                                                                                                                                                                                                                                                                                                                                                                                    variable neg

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

                                                                                                                                                                                                                                                                                                                                                                                                                                      variable Neg

                                                                                                                                                                                                                                                                                                                                                                                                                                      const Neg: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                        variable NonMaxSuppressionV3

                                                                                                                                                                                                                                                                                                                                                                                                                                        const NonMaxSuppressionV3: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                          variable NonMaxSuppressionV4

                                                                                                                                                                                                                                                                                                                                                                                                                                          const NonMaxSuppressionV4: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                            variable NonMaxSuppressionV5

                                                                                                                                                                                                                                                                                                                                                                                                                                            const NonMaxSuppressionV5: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                              variable norm

                                                                                                                                                                                                                                                                                                                                                                                                                                              const norm: (
                                                                                                                                                                                                                                                                                                                                                                                                                                              x: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                                                              ord?: number | 'euclidean' | 'fro',
                                                                                                                                                                                                                                                                                                                                                                                                                                              axis?: number | number[],
                                                                                                                                                                                                                                                                                                                                                                                                                                              keepDims?: boolean
                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Tensor<Rank>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                variable notEqual

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable NotEqual

                                                                                                                                                                                                                                                                                                                                                                                                                                                  const NotEqual: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable oneHot

                                                                                                                                                                                                                                                                                                                                                                                                                                                    const oneHot: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                    indices: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    depth: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    onValue?: number,
                                                                                                                                                                                                                                                                                                                                                                                                                                                    offValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Tensor<Rank>;

                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable OneHot

                                                                                                                                                                                                                                                                                                                                                                                                                                                      const OneHot: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable onesLike

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable OnesLike

                                                                                                                                                                                                                                                                                                                                                                                                                                                          const OnesLike: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable OP_SCOPE_SUFFIX

                                                                                                                                                                                                                                                                                                                                                                                                                                                            const OP_SCOPE_SUFFIX: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable outerProduct

                                                                                                                                                                                                                                                                                                                                                                                                                                                              const outerProduct: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                              v1: TensorLike | Tensor1D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                              v2: TensorLike | Tensor1D
                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => Tensor2D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable Pack

                                                                                                                                                                                                                                                                                                                                                                                                                                                                const Pack: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable pad

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const pad: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  x: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  paddings: [number, number][],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  constantValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable pad1d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const pad1d: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    x: TensorLike | Tensor1D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    paddings: [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    constantValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    ) => Tensor1D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable pad2d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const pad2d: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      x: TensorLike | Tensor2D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      paddings: [[number, number], [number, number]],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      constantValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ) => Tensor2D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        variable pad3d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        const pad3d: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        x: TensorLike | Tensor3D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        paddings: [[number, number], [number, number], [number, number]],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        constantValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) => Tensor3D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          variable pad4d

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          const pad4d: (
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          x: TensorLike | Tensor4D,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          paddings: [
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          [number, number]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          constantValue?: number
                                                                                                                                                                                                                                                                                                                                                                                                                                                                          ) => Tensor4D;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            variable PadV2

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            const PadV2: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              variable pool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              const pool: <T extends Tensor3D | Tensor4D>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              input: TensorLike | T,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              windowShape: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              poolingType: 'avg' | 'max',
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              pad: number | 'valid' | 'same' | conv_util.ExplicitPadding,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              dilations?: number | [number, number],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              strides?: number | [number, number]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                variable Pool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                const Pool: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  variable pow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  const pow: <T extends Tensor<Rank>>(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  base: Tensor<Rank> | TensorLike,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  exp: Tensor<Rank> | TensorLike
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ) => T;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    variable Pow

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    const Pow: string;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      variable prelu

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      const prelu: <T extends Tensor<Rank>>(x: TensorLike | T, alpha: TensorLike | T)