@tensorflow/tfjs-core

@tensorflow/tfjs-core

Version 3.7.0
Published 3 days ago
35 MB
7 dependencies
Apache-2.0 license

Install

npm i @tensorflow/tfjs-core

yarn add @tensorflow/tfjs-core

pnpm add @tensorflow/tfjs-core

Overview

Hardware-accelerated JavaScript library for machine intelligence

Index

Variables

variable abs

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

variable Abs

const Abs: string;

variable acos

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

variable Acos

const Acos: string;

variable acosh

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

variable Acosh

const Acosh: string;

variable add

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

variable Add

const Add: string;

variable addN

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

variable AddN

const AddN: string;

variable all

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

variable All

const All: string;

variable any

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

variable Any

const Any: string;

variable argMax

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

variable ArgMax

const ArgMax: string;

variable argMin

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

variable ArgMin

const ArgMin: string;

variable asin

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

variable Asin

const Asin: string;

variable asinh

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

variable Asinh

const Asinh: string;

variable atan

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

variable Atan

const Atan: string;

variable atan2

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

variable Atan2

const Atan2: string;

variable atanh

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

variable Atanh

const Atanh: string;

variable avgPool

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

variable AvgPool

const AvgPool: string;

variable avgPool3d

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

variable AvgPool3D

const AvgPool3D: string;

variable AvgPool3DGrad

const AvgPool3DGrad: string;

variable AvgPoolGrad

const AvgPoolGrad: string;

variable basicLSTMCell

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

variable BatchMatMul

const BatchMatMul: string;

variable batchNorm

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

variable batchNorm2d

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

variable batchNorm3d

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

variable batchNorm4d

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

variable batchToSpaceND

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

variable BatchToSpaceND

const BatchToSpaceND: string;

variable bincount

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

variable Bincount

const Bincount: string;

variable booleanMaskAsync

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

variable broadcastTo

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

variable BroadcastTo

const BroadcastTo: string;

variable cast

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

variable Cast

const Cast: string;

variable ceil

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

variable Ceil

const Ceil: string;

variable clipByValue

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

variable ClipByValue

const ClipByValue: string;

variable clone

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

variable complex

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

variable Complex

const Complex: string;

variable ComplexAbs

const ComplexAbs: string;

variable concat

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

variable Concat

const Concat: string;

variable concat1d

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

variable concat2d

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

variable concat3d

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

variable concat4d

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

variable conv1d

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

variable conv2d

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

variable Conv2D

const Conv2D: string;

variable Conv2DBackpropFilter

const Conv2DBackpropFilter: string;

variable Conv2DBackpropInput

const Conv2DBackpropInput: string;

variable conv2dTranspose

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

variable conv3d

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

variable Conv3D

const Conv3D: string;

variable Conv3DBackpropFilterV2

const Conv3DBackpropFilterV2: string;

variable Conv3DBackpropInputV2

const Conv3DBackpropInputV2: string;

variable conv3dTranspose

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

variable cos

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

variable Cos

const Cos: string;

variable cosh

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

variable Cosh

const Cosh: string;

variable CropAndResize

const CropAndResize: string;

variable cumsum

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

variable Cumsum

const Cumsum: string;

variable denseBincount

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

variable DenseBincount

const DenseBincount: string;

variable depthToSpace

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

variable DepthToSpace

const DepthToSpace: string;

variable depthwiseConv2d

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

variable DepthwiseConv2dNative

const DepthwiseConv2dNative: string;

variable DepthwiseConv2dNativeBackpropFilter

const DepthwiseConv2dNativeBackpropFilter: string;

variable DepthwiseConv2dNativeBackpropInput

const DepthwiseConv2dNativeBackpropInput: string;

variable diag

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

variable Diag

const Diag: string;

variable dilation2d

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

variable Dilation2D

const Dilation2D: string;

variable Dilation2DBackpropFilter

const Dilation2DBackpropFilter: string;

variable Dilation2DBackpropInput

const Dilation2DBackpropInput: string;

variable div

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

variable divNoNan

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

variable dot

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

variable dropout

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

variable einsum

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

variable Einsum

const Einsum: string;

variable elu

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

variable Elu

const Elu: string;

variable EluGrad

const EluGrad: string;

variable ENV

let ENV: Environment;

variable equal

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

variable Equal

const Equal: string;

variable erf

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

variable Erf

const Erf: string;

variable exp

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

variable Exp

const Exp: string;

variable expandDims

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

variable ExpandDims

const ExpandDims: string;

variable expm1

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

variable Expm1

const Expm1: string;

variable eye

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

variable fft

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

variable FFT

const FFT: string;

variable Fill

const Fill: string;

variable FlipLeftRight

const FlipLeftRight: string;

variable floor

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

variable Floor

const Floor: string;

variable floorDiv

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

variable FloorDiv

const FloorDiv: string;

variable FromPixels

const FromPixels: string;

variable FusedBatchNorm

const FusedBatchNorm: string;

variable FusedConv2D

const FusedConv2D: string;

variable FusedDepthwiseConv2D

const FusedDepthwiseConv2D: string;

variable gather

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

variable gatherND

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

variable GatherNd

const GatherNd: string;

variable GatherV2

const GatherV2: string;

variable greater

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

variable Greater

const Greater: string;

variable greaterEqual

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

variable GreaterEqual

const GreaterEqual: string;

variable Identity

const Identity: string;

variable ifft

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

variable IFFT

const IFFT: string;

variable imag

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

variable Imag

const Imag: string;

variable image

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

variable inTopKAsync

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

variable irfft

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

variable isFinite

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

variable IsFinite

const IsFinite: string;

variable isInf

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

variable IsInf

const IsInf: string;

variable isNaN

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

variable IsNan

const IsNan: string;

variable leakyRelu

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

variable LeakyRelu

const LeakyRelu: string;

variable less

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

variable Less

const Less: string;

variable lessEqual

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

variable LessEqual

const LessEqual: string;

variable linalg

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

variable LinSpace

const LinSpace: string;

variable localResponseNormalization

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

variable log

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

variable Log

const Log: string;

variable log1p

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

variable Log1p

const Log1p: string;

variable logicalAnd

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

variable LogicalAnd

const LogicalAnd: string;

variable logicalNot

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

variable LogicalNot

const LogicalNot: string;

variable logicalOr

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

variable LogicalOr

const LogicalOr: string;

variable logicalXor

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

variable logSigmoid

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

variable logSoftmax

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

variable LogSoftmax

const LogSoftmax: string;

variable logSumExp

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

variable losses

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

variable LRN

const LRN: string;

variable LRNGrad

const LRNGrad: string;

variable matMul

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

variable max

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

variable Max

const Max: string;

variable maximum

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

variable Maximum

const Maximum: string;

variable maxPool

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

variable MaxPool

const MaxPool: string;

variable maxPool3d

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

variable MaxPool3D

const MaxPool3D: string;

variable MaxPool3DGrad

const MaxPool3DGrad: string;

variable MaxPoolGrad

const MaxPoolGrad: string;

variable maxPoolWithArgmax

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

variable MaxPoolWithArgmax

const MaxPoolWithArgmax: string;

variable mean

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

variable Mean

const Mean: string;

variable min

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

variable Min

const Min: string;

variable minimum

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

variable Minimum

const Minimum: string;

variable mirrorPad

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

variable MirrorPad

const MirrorPad: string;

variable mod

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

variable Mod

const Mod: string;

variable moments

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

variable movingAverage

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

variable mul

const

@tensorflow/tfjs-core

Install

Overview

Index

Variables

Functions

Classes

Interfaces

Enums

Type Aliases

Namespaces

Variables

variable abs

variable Abs

variable acos

variable Acos

variable acosh

variable Acosh

variable add

variable Add

variable addN

variable AddN

variable all

variable All

variable any

variable Any

variable argMax

variable ArgMax

variable argMin

variable ArgMin

variable asin

variable Asin

variable asinh

variable Asinh

variable atan

variable Atan

variable atan2

variable Atan2

variable atanh

variable Atanh

variable avgPool

variable AvgPool

variable avgPool3d

variable AvgPool3D

variable AvgPool3DGrad

variable AvgPoolGrad

variable basicLSTMCell

variable BatchMatMul

variable batchNorm

variable batchNorm2d

variable batchNorm3d

variable batchNorm4d

variable batchToSpaceND

variable BatchToSpaceND

variable bincount

variable Bincount

variable booleanMaskAsync

variable broadcastTo

variable BroadcastTo

variable cast

variable Cast

variable ceil

variable Ceil

variable clipByValue

variable ClipByValue

variable clone

variable complex

variable Complex

variable ComplexAbs

variable concat

variable Concat

variable concat1d

variable concat2d

variable concat3d

variable concat4d

variable conv1d

variable conv2d

variable Conv2D

variable Conv2DBackpropFilter

variable Conv2DBackpropInput