@vladmandic/human - v3.3.6
    Preparing search index...

    Interface Tensor<R>

    A tf.Tensor object represents an immutable, multidimensional array of numbers that has a shape and a data type.

    For performance reasons, functions that create tensors do not necessarily perform a copy of the data passed to them (e.g. if the data is passed as a Float32Array), and changes to the data will change the tensor. This is not a feature and is not supported. To avoid this behavior, use the tensor before changing the input data or create a copy with copy = tf.add(yourTensor, 0).

    See tf.tensor for details on how to create a tf.Tensor.

    interface Tensor<R extends Rank = Rank> {
        dataId: object;
        dtype: keyof DataTypeMap;
        id: number;
        kept: boolean;
        kerasMask?: Tensor<Rank>;
        rankType: R;
        scopeId: number;
        shape: ShapeMap[R];
        size: number;
        strides: number[];
        get isDisposed(): boolean;
        get rank(): number;
        abs<T extends Tensor<Rank>>(this: T): T;
        acos<T extends Tensor<Rank>>(this: T): T;
        acosh<T extends Tensor<Rank>>(this: T): T;
        add<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        all<T extends Tensor<Rank>>(
            this: T,
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        any<T extends Tensor<Rank>>(
            this: T,
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        argMax<T extends Tensor<Rank>>(axis?: number): T;
        argMin<T extends Tensor<Rank>>(axis?: number): T;
        array(): Promise<ArrayMap[R]>;
        arraySync(): ArrayMap[R];
        as1D<T extends Tensor<Rank>>(): Tensor1D;
        as2D<T extends Tensor<Rank>>(rows: number, columns: number): Tensor2D;
        as3D<T extends Tensor<Rank>>(
            rows: number,
            columns: number,
            depth: number,
        ): Tensor3D;
        as4D<T extends Tensor<Rank>>(
            rows: number,
            columns: number,
            depth: number,
            depth2: number,
        ): Tensor4D;
        as5D<T extends Tensor<Rank>>(
            rows: number,
            columns: number,
            depth: number,
            depth2: number,
            depth3: number,
        ): Tensor5D;
        asin<T extends Tensor<Rank>>(this: T): T;
        asinh<T extends Tensor<Rank>>(this: T): T;
        asScalar<T extends Tensor<Rank>>(): Scalar;
        asType<T extends Tensor<Rank>>(this: T, dtype: keyof DataTypeMap): T;
        atan<T extends Tensor<Rank>>(this: T): T;
        atan2<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        atanh<T extends Tensor<Rank>>(this: T): T;
        avgPool<T extends Tensor3D | Tensor4D>(
            filterSize: number | [number, number],
            strides: number | [number, number],
            pad: number | "valid" | "same" | ExplicitPadding,
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        batchNorm<T extends Tensor<Rank>>(
            mean: Tensor<R> | TensorLike | Tensor1D,
            variance: Tensor<R> | TensorLike | Tensor1D,
            offset?: Tensor<R> | TensorLike | Tensor1D,
            scale?: Tensor<R> | TensorLike | Tensor1D,
            varianceEpsilon?: number,
        ): Tensor<R>;
        batchToSpaceND<R extends Rank>(
            blockShape: number[],
            crops: number[][],
        ): Tensor<R>;
        broadcastTo<R extends Rank>(shape: ShapeMap[R]): Tensor<R>;
        buffer<D extends keyof DataTypeMap = "float32">(): Promise<
            TensorBuffer<R, D>,
        >;
        bufferSync<D extends keyof DataTypeMap = "float32">(): TensorBuffer<R, D>;
        bytes(): Promise<
            Uint8Array<ArrayBufferLike>
            | Uint8Array<ArrayBufferLike>[],
        >;
        cast<T extends Tensor<Rank>>(dtype: keyof DataTypeMap): T;
        ceil<T extends Tensor<Rank>>(this: T): T;
        clipByValue<T extends Tensor<Rank>>(min: number, max: number): Tensor;
        clone<T extends Tensor<Rank>>(this: T): T;
        concat<T extends Tensor<Rank>>(
            tensors: T | (TensorLike | T)[],
            axis?: number,
        ): T;
        conv1d<T extends Tensor2D | Tensor3D>(
            filter: Tensor3D | TensorLike3D,
            stride: number,
            pad: number | "valid" | "same" | ExplicitPadding,
            dataFormat?: "NWC" | "NCW",
            dilation?: number,
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        conv2d<T extends Tensor3D | Tensor4D>(
            filter: Tensor4D | TensorLike4D,
            strides: number | [number, number],
            pad: number | "valid" | "same",
            dataFormat?: "NHWC" | "NCHW",
            dilations?: number | [number, number],
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        conv2dTranspose<T extends Tensor3D | Tensor4D>(
            filter: Tensor4D | TensorLike4D,
            outputShape: [number, number, number] | [number, number, number, number],
            strides: number | [number, number],
            pad: number | "valid" | "same",
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        cos<T extends Tensor<Rank>>(this: T): T;
        cosh<T extends Tensor<Rank>>(this: T): T;
        cumprod<R extends Rank>(
            axis?: number,
            exclusive?: boolean,
            reverse?: boolean,
        ): Tensor<R>;
        cumsum<R extends Rank>(
            axis?: number,
            exclusive?: boolean,
            reverse?: boolean,
        ): Tensor<R>;
        data<D extends keyof DataTypeMap = NumericDataType>(): Promise<
            DataTypeMap[D],
        >;
        dataSync<D extends keyof DataTypeMap = NumericDataType>(): DataTypeMap[D];
        dataToGPU(options?: DataToGPUWebGLOption): GPUData;
        depthToSpace<T extends Tensor4D>(
            blockSize: number,
            dataFormat: "NHWC" | "NCHW",
        ): T;
        depthwiseConv2d<T extends Tensor3D | Tensor4D>(
            filter: Tensor4D | TensorLike4D,
            strides: number | [number, number],
            pad: number | "valid" | "same",
            dataFormat?: "NHWC" | "NCHW",
            dilations?: number | [number, number],
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        dilation2d<T extends Tensor3D | Tensor4D>(
            filter: Tensor3D | TensorLike3D,
            strides: number | [number, number],
            pad: "valid" | "same",
            dilations?: number | [number, number],
            dataFormat?: "NHWC",
        ): T;
        dispose(): void;
        div<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        divNoNan<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        dot<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): Tensor;
        elu<T extends Tensor<Rank>>(): T;
        equal<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        erf<T extends Tensor<Rank>>(this: T): T;
        euclideanNorm<T extends Tensor<Rank>>(
            this: T,
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        exp<T extends Tensor<Rank>>(this: T): T;
        expandDims<T extends Tensor<Rank>>(axis?: number): T;
        expm1<T extends Tensor<Rank>>(this: T): T;
        fft<T extends Tensor<Rank>>(this: Tensor): Tensor;
        flatten<T extends Tensor<Rank>>(): Tensor1D;
        floor<T extends Tensor<Rank>>(this: T): T;
        floorDiv<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        gather<T extends Tensor<Rank>>(
            this: T,
            indices: Tensor<Rank> | TensorLike,
            axis?: number,
            batchDims?: number,
        ): T;
        greater<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        greaterEqual<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        ifft<T extends Tensor<Rank>>(this: Tensor): Tensor;
        irfft<T extends Tensor<Rank>>(this: Tensor): Tensor;
        isFinite<T extends Tensor<Rank>>(this: T): T;
        isInf<T extends Tensor<Rank>>(this: T): T;
        isNaN<T extends Tensor<Rank>>(this: T): T;
        leakyRelu<T extends Tensor<Rank>>(alpha: number): T;
        less<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        lessEqual<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        localResponseNormalization<T extends Tensor<Rank>>(
            depthRadius?: number,
            bias?: number,
            alpha?: number,
            beta?: number,
        ): T;
        log<T extends Tensor<Rank>>(this: T): T;
        log1p<T extends Tensor<Rank>>(this: T): T;
        logicalAnd<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        logicalNot<T extends Tensor<Rank>>(): T;
        logicalOr<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        logicalXor<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        logSigmoid<T extends Tensor<Rank>>(this: T): T;
        logSoftmax<T extends Tensor<Rank>>(this: T, axis?: number): T;
        logSumExp<T extends Tensor<Rank>>(
            this: T,
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        matMul<T extends Tensor<Rank>>(
            b: Tensor<Rank> | TensorLike,
            transposeA?: boolean,
            transposeB?: boolean,
        ): Tensor;
        max<T extends Tensor<Rank>>(
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        maximum<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        maxPool<T extends Tensor3D | Tensor4D>(
            filterSize: number | [number, number],
            strides: number | [number, number],
            pad: number | "valid" | "same" | ExplicitPadding,
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        mean<T extends Tensor<Rank>>(
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        min<T extends Tensor<Rank>>(
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        minimum<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        mirrorPad<T extends Tensor<Rank>>(
            paddings: [number, number][],
            mode: "reflect" | "symmetric",
        ): T;
        mod<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        mul<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        neg<T extends Tensor<Rank>>(this: T): T;
        norm<T extends Tensor<Rank>>(
            ord?: number | "euclidean" | "fro",
            axis?: number | number[],
            keepDims?: boolean,
        ): Tensor;
        notEqual<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        oneHot(depth: number, onValue: number, offValue: number): Tensor;
        onesLike<T extends Tensor<Rank>>(this: T): T;
        pad<T extends Tensor<Rank>>(
            paddings: [number, number][],
            constantValue?: number,
        ): T;
        pool<T extends Tensor3D | Tensor4D>(
            windowShape: number | [number, number],
            poolingType: "avg" | "max",
            padding: number | "valid" | "same" | ExplicitPadding,
            diationRate?: number | [number, number],
            strides?: number | [number, number],
            dimRoundingMode?: "floor" | "round" | "ceil",
        ): T;
        pow<T extends Tensor<Rank>>(exp: Tensor<Rank> | TensorLike): T;
        prelu<T extends Tensor<Rank>>(alpha: TensorLike | T): T;
        print(verbose?: boolean): void;
        prod<T extends Tensor<Rank>>(
            this: T,
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        reciprocal<T extends Tensor<Rank>>(this: T): T;
        relu<T extends Tensor<Rank>>(): T;
        relu6<T extends Tensor<Rank>>(): T;
        reshape<T extends Tensor<Rank>>(shape: number[]): T;
        reshapeAs<T extends Tensor<Rank>>(x: T): T;
        resizeBilinear<T extends Tensor3D | Tensor4D>(
            newShape2D: [number, number],
            alignCorners?: boolean,
            halfPixelCenters?: boolean,
        ): T;
        resizeNearestNeighbor<T extends Tensor3D | Tensor4D>(
            newShape2D: [number, number],
            alignCorners?: boolean,
            halfFloatCenters?: boolean,
        ): T;
        reverse<T extends Tensor<Rank>>(this: T, axis?: number | number[]): T;
        rfft<T extends Tensor<Rank>>(this: Tensor): Tensor;
        round<T extends Tensor<Rank>>(this: T): T;
        rsqrt<T extends Tensor<Rank>>(this: T): T;
        selu<T extends Tensor<Rank>>(): T;
        separableConv2d<T extends Tensor3D | Tensor4D>(
            depthwiseFilter: Tensor4D | TensorLike4D,
            pointwiseFilter: TensorLike | Tensor4D,
            strides: number | [number, number],
            pad: "valid" | "same",
            dilation?: number | [number, number],
            dataFormat?: "NHWC" | "NCHW",
        ): T;
        sigmoid<T extends Tensor<Rank>>(this: T): T;
        sign<T extends Tensor<Rank>>(this: T): T;
        sin<T extends Tensor<Rank>>(this: T): T;
        sinh<T extends Tensor<Rank>>(this: T): T;
        slice<T extends Tensor<Rank>>(
            this: T,
            begin: number | number[],
            size?: number | number[],
        ): T;
        softmax<T extends Tensor<Rank>>(this: T, dim?: number): T;
        softplus<T extends Tensor<Rank>>(this: T): T;
        spaceToBatchND<R extends Rank>(
            blockShape: number[],
            paddings: number[][],
        ): Tensor<R>;
        split<T extends Tensor<Rank>>(
            numOrSizeSplits: number | number[],
            axis?: number,
        ): T[];
        sqrt<T extends Tensor<Rank>>(this: T): T;
        square<T extends Tensor<Rank>>(this: T): T;
        squaredDifference<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        squeeze<T extends Tensor<Rank>>(axis?: number[]): T;
        stack<T extends Tensor<Rank>>(
            x: Tensor<Rank> | Tensor<Rank>[],
            axis?: number,
        ): T;
        step<T extends Tensor<Rank>>(this: T, alpha?: number): T;
        stridedSlice<T extends Tensor<Rank>>(
            this: Tensor,
            begin: number[],
            end: number[],
            strides: number[],
            beginMask?: number,
            endMask?: number,
            ellipsisMask?: number,
            newAxisMask?: number,
            shrinkAxisMask?: number,
        ): Tensor;
        sub<T extends Tensor<Rank>>(b: Tensor<Rank> | TensorLike): T;
        sum<T extends Tensor<Rank>>(
            axis?: number | number[],
            keepDims?: boolean,
        ): T;
        tan<T extends Tensor<Rank>>(this: T): T;
        tanh<T extends Tensor<Rank>>(this: T): T;
        throwIfDisposed(): void;
        tile<T extends Tensor<Rank>>(b: number[]): T;
        toBool<T extends Tensor<Rank>>(this: T): T;
        toFloat<T extends Tensor<Rank>>(this: T): T;
        toInt<T extends Tensor<Rank>>(this: T): T;
        topk<T extends Tensor<Rank>>(
            this: T,
            k?: number,
            sorted?: boolean,
        ): { indices: T; values: T };
        toString(verbose?: boolean): string;
        transpose<T extends Tensor<Rank>>(perm?: number[]): T;
        unique<T extends Tensor<Rank>>(
            this: T,
            axis?: number,
        ): { indices: T; values: T };
        unsortedSegmentSum<T extends Tensor<Rank>>(
            this: T,
            segmentIds: Tensor1D | TensorLike1D,
            numSegments: number,
        ): T;
        unstack<T extends Tensor<Rank>>(axis?: number): T[];
        variable(
            trainable?: boolean,
            name?: string,
            dtype?: keyof DataTypeMap,
        ): Variable<R>;
        where<T extends Tensor<Rank>>(
            condition: Tensor<Rank> | TensorLike,
            x: Tensor<Rank> | TensorLike,
        ): T;
        zerosLike<T extends Tensor<Rank>>(this: T): T;
    }

    Type Parameters

    Implements

    • TensorInfo
    Index

    Properties

    dataId: object

    Id of the bucket holding the data for this tensor. Multiple arrays can point to the same bucket (e.g. when calling array.reshape()).

    dtype: keyof DataTypeMap

    The data type for the array.

    id: number

    Unique id of this tensor.

    kept: boolean

    Whether this tensor has been globally kept.

    kerasMask?: Tensor<Rank>

    The keras mask that some keras layers attach to the tensor

    rankType: R

    The rank type for the array (see Rank enum).

    scopeId: number

    The id of the scope this tensor is being tracked in.

    shape: ShapeMap[R]

    The shape of the tensor.

    size: number

    Number of elements in the tensor.

    strides: number[]

    Number of elements to skip in each dimension when indexing. See https://docs.scipy.org/doc/numpy/reference/generated/\ numpy.ndarray.strides.html

    Accessors

    • get isDisposed(): boolean

      Returns boolean

    • get rank(): number

      Returns number

    Methods

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number

      Returns T

    • Returns the tensor data as a nested array. The transfer of data is done asynchronously.

      Returns Promise<ArrayMap[R]>

    • Returns the tensor data as a nested array. The transfer of data is done synchronously.

      Returns ArrayMap[R]

    • Type Parameters

      Returns Tensor1D

    • Type Parameters

      Parameters

      • rows: number
      • columns: number

      Returns Tensor2D

    • Type Parameters

      Parameters

      • rows: number
      • columns: number
      • depth: number

      Returns Tensor3D

    • Type Parameters

      Parameters

      • rows: number
      • columns: number
      • depth: number
      • depth2: number

      Returns Tensor4D

    • Type Parameters

      Parameters

      • rows: number
      • columns: number
      • depth: number
      • depth2: number
      • depth3: number

      Returns Tensor5D

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Returns Scalar

    • Type Parameters

      Parameters

      • this: T
      • dtype: keyof DataTypeMap

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • filterSize: number | [number, number]
      • strides: number | [number, number]
      • pad: number | "valid" | "same" | ExplicitPadding
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • blockShape: number[]
      • crops: number[][]

      Returns Tensor<R>

    • Type Parameters

      Parameters

      • shape: ShapeMap[R]

      Returns Tensor<R>

    • Returns a promise of tf.TensorBuffer that holds the underlying data.

      Type Parameters

      • D extends keyof DataTypeMap = "float32"

      Returns Promise<TensorBuffer<R, D>>

    • Returns a tf.TensorBuffer that holds the underlying data.

      Type Parameters

      • D extends keyof DataTypeMap = "float32"

      Returns TensorBuffer<R, D>

    • Returns the underlying bytes of the tensor's data.

      Returns Promise<Uint8Array<ArrayBufferLike> | Uint8Array<ArrayBufferLike>[]>

    • Type Parameters

      Parameters

      • dtype: keyof DataTypeMap

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • min: number
      • max: number

      Returns Tensor

    • Returns a copy of the tensor. See tf.clone for details.

      Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      Returns T

    • Type Parameters

      Parameters

      • filter: Tensor3D | TensorLike3D
      • stride: number
      • pad: number | "valid" | "same" | ExplicitPadding
      • OptionaldataFormat: "NWC" | "NCW"
      • Optionaldilation: number
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • filter: Tensor4D | TensorLike4D
      • strides: number | [number, number]
      • pad: number | "valid" | "same"
      • OptionaldataFormat: "NHWC" | "NCHW"
      • Optionaldilations: number | [number, number]
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • filter: Tensor4D | TensorLike4D
      • outputShape: [number, number, number] | [number, number, number, number]
      • strides: number | [number, number]
      • pad: number | "valid" | "same"
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number
      • Optionalexclusive: boolean
      • Optionalreverse: boolean

      Returns Tensor<R>

    • Type Parameters

      Parameters

      • Optionalaxis: number
      • Optionalexclusive: boolean
      • Optionalreverse: boolean

      Returns Tensor<R>

    • Asynchronously downloads the values from the tf.Tensor. Returns a promise of TypedArray that resolves when the computation has finished.

      Type Parameters

      • D extends keyof DataTypeMap = NumericDataType

      Returns Promise<DataTypeMap[D]>

    • Synchronously downloads the values from the tf.Tensor. This blocks the UI thread until the values are ready, which can cause performance issues.

      Type Parameters

      • D extends keyof DataTypeMap = NumericDataType

      Returns DataTypeMap[D]

    • Copy the tensor's data to a new GPU resource. Comparing to the dataSync() and data(), this method prevents data from being downloaded to CPU.

      For WebGL backend, the data will be stored on a densely packed texture. This means that the texture will use the RGBA channels to store value.

      For WebGPU backend, the data will be stored on a buffer. There is no parameter, so can not use a user-defined size to create the buffer.

      Parameters

      • Optionaloptions: DataToGPUWebGLOption

      Returns GPUData

      For WebGL backend, a GPUData contains the new texture and its information. { tensorRef: The tensor that is associated with this texture, texture: WebGLTexture, texShape: [number, number] // [height, width] }

      For WebGPU backend, a GPUData contains the new buffer.
      {
         tensorRef: The tensor that is associated with this buffer,
         buffer: GPUBuffer,
      }
      
      Remember to dispose the GPUData after it is used by
      `res.tensorRef.dispose()`.
      
    • Type Parameters

      Parameters

      • blockSize: number
      • dataFormat: "NHWC" | "NCHW"

      Returns T

    • Type Parameters

      Parameters

      • filter: Tensor4D | TensorLike4D
      • strides: number | [number, number]
      • pad: number | "valid" | "same"
      • OptionaldataFormat: "NHWC" | "NCHW"
      • Optionaldilations: number | [number, number]
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • filter: Tensor3D | TensorLike3D
      • strides: number | [number, number]
      • pad: "valid" | "same"
      • Optionaldilations: number | [number, number]
      • OptionaldataFormat: "NHWC"

      Returns T

    • Disposes tf.Tensor from memory.

      Returns void

    • Type Parameters

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      Returns Tensor

    • Type Parameters

      Returns Tensor1D

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      Returns T

    • Type Parameters

      Parameters

      Returns Tensor

    • Type Parameters

      Parameters

      Returns Tensor

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • alpha: number

      Returns T

    • Type Parameters

      Parameters

      • OptionaldepthRadius: number
      • Optionalbias: number
      • Optionalalpha: number
      • Optionalbeta: number

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      Returns Tensor

    • Type Parameters

      Parameters

      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • filterSize: number | [number, number]
      • strides: number | [number, number]
      • pad: number | "valid" | "same" | ExplicitPadding
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • paddings: [number, number][]
      • mode: "reflect" | "symmetric"

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • Optionalord: number | "euclidean" | "fro"
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns Tensor

    • Parameters

      • depth: number
      • onValue: number
      • offValue: number

      Returns Tensor

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • paddings: [number, number][]
      • OptionalconstantValue: number

      Returns T

    • Type Parameters

      Parameters

      • windowShape: number | [number, number]
      • poolingType: "avg" | "max"
      • padding: number | "valid" | "same" | ExplicitPadding
      • OptionaldiationRate: number | [number, number]
      • Optionalstrides: number | [number, number]
      • OptionaldimRoundingMode: "floor" | "round" | "ceil"

      Returns T

    • Type Parameters

      Parameters

      Returns T

    • Prints the tf.Tensor. See tf.print for details.

      Parameters

      • Optionalverbose: boolean

        Whether to print verbose information about the tensor, including dtype and size.

      Returns void

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Returns T

    • Type Parameters

      Returns T

    • Type Parameters

      Parameters

      • shape: number[]

      Returns T

    • Type Parameters

      Parameters

      Returns T

    • Type Parameters

      Parameters

      • newShape2D: [number, number]
      • OptionalalignCorners: boolean
      • OptionalhalfPixelCenters: boolean

      Returns T

    • Type Parameters

      Parameters

      • newShape2D: [number, number]
      • OptionalalignCorners: boolean
      • OptionalhalfFloatCenters: boolean

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number | number[]

      Returns T

    • Type Parameters

      Parameters

      Returns Tensor

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Returns T

    • Type Parameters

      Parameters

      • depthwiseFilter: Tensor4D | TensorLike4D
      • pointwiseFilter: TensorLike | Tensor4D
      • strides: number | [number, number]
      • pad: "valid" | "same"
      • Optionaldilation: number | [number, number]
      • OptionaldataFormat: "NHWC" | "NCHW"

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • begin: number | number[]
      • Optionalsize: number | number[]

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionaldim: number

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • blockShape: number[]
      • paddings: number[][]

      Returns Tensor<R>

    • Type Parameters

      Parameters

      • numOrSizeSplits: number | number[]
      • Optionalaxis: number

      Returns T[]

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number[]

      Returns T

    • Type Parameters

      Parameters

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalalpha: number

      Returns T

    • Type Parameters

      Parameters

      • this: Tensor
      • begin: number[]
      • end: number[]
      • strides: number[]
      • OptionalbeginMask: number
      • OptionalendMask: number
      • OptionalellipsisMask: number
      • OptionalnewAxisMask: number
      • OptionalshrinkAxisMask: number

      Returns Tensor

    • Type Parameters

      Parameters

      • Optionalaxis: number | number[]
      • OptionalkeepDims: boolean

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Returns void

    • Type Parameters

      Parameters

      • b: number[]

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalk: number
      • Optionalsorted: boolean

      Returns { indices: T; values: T }

    • Returns a human-readable description of the tensor. Useful for logging.

      Parameters

      • Optionalverbose: boolean

      Returns string

    • Type Parameters

      Parameters

      • Optionalperm: number[]

      Returns T

    • Type Parameters

      Parameters

      • this: T
      • Optionalaxis: number

      Returns { indices: T; values: T }

    • Type Parameters

      Parameters

      • this: T
      • segmentIds: Tensor1D | TensorLike1D
      • numSegments: number

      Returns T

    • Type Parameters

      Parameters

      • Optionalaxis: number

      Returns T[]

    • Parameters

      • Optionaltrainable: boolean
      • Optionalname: string
      • Optionaldtype: keyof DataTypeMap

      Returns Variable<R>

    • Type Parameters

      Parameters

      • this: T

      Returns T