/**
|
* @license
|
* Copyright 2019 Google LLC. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
* =============================================================================
|
*/
|
import { Tensor, Tensor3D, Tensor4D } from '../tensor';
|
import { TensorLike } from '../types';
|
import { Activation } from './fused_util';
|
/**
|
* Computes the dot product of two matrices with optional activation and bias.
|
*
|
* ```js
|
* const a = tf.tensor2d([-1, -2], [1, 2]);
|
* const b = tf.tensor2d([1, 2, 3, 4], [2, 2]);
|
* const bias = tf.tensor2d([1, 2], [1, 2]);
|
*
|
* tf.fused.matMul({a, b, bias, activation: 'relu'}).print();
|
* ```
|
*
|
* @param obj An object with the following properties:
|
* - `a` First matrix in dot product operation.
|
* - `b` Second matrix in dot product operation.
|
* - `transposeA` If true, `a` is transposed before multiplication.
|
* - `transposeB` If true, `b` is transposed before multiplication.
|
* - `bias` Matrix to be added to the result.
|
* - `activation` Name of activation kernel (defaults to `linear`).
|
* - `preluActivationWeights` Tensor of prelu weights.
|
*/
|
declare function fusedMatMul_<T extends Tensor>({ a, b, transposeA, transposeB, bias, activation, preluActivationWeights }: {
|
a: T | TensorLike;
|
b: T | TensorLike;
|
transposeA?: boolean;
|
transposeB?: boolean;
|
bias?: Tensor | TensorLike;
|
activation?: Activation;
|
preluActivationWeights?: Tensor;
|
}): T;
|
/**
|
* Computes a 2D convolution over the input x, optionally fused with adding a
|
* bias and applying an activation.
|
*
|
* ```js
|
* const inputDepth = 2;
|
* const inShape = [2, 2, 2, inputDepth];
|
* const outputDepth = 2;
|
* const fSize = 1;
|
* const pad = 0;
|
* const strides = 1;
|
*
|
* const x = tf.tensor4d( [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
|
* 16], inShape);
|
* const w = tf.tensor4d([-1, 1, -2, 0.5], [fSize, fSize, inputDepth,
|
* outputDepth]);
|
*
|
* tf.fused.conv2d({ x, filter: w, strides, pad, dataFormat: 'NHWC',
|
* dilations: [1, 1], bias: tf.scalar(5), activation: 'relu' }).print();
|
* ```
|
*
|
* @param obj An object with the following properties:
|
* @param x The input tensor, of rank 4 or rank 3, of shape
|
* `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
|
* assumed.
|
* @param filter The filter, rank 4, of shape
|
* `[filterHeight, filterWidth, inDepth, outDepth]`.
|
* @param strides The strides of the convolution: `[strideHeight,
|
* strideWidth]`.
|
* @param pad The type of padding algorithm.
|
* - `same` and stride 1: output will be of same size as input,
|
* regardless of filter size.
|
* - `valid` output will be smaller than input if filter is larger
|
* than 1x1.
|
* - For more info, see this guide:
|
* [https://www.tensorflow.org/api_guides/python/nn#Convolution](
|
* https://www.tensorflow.org/api_guides/python/nn#Convolution)
|
* @param dataFormat An optional string from: "NHWC", "NCHW". Defaults to
|
* "NHWC". Specify the data format of the input and output data. With the
|
* default format "NHWC", the data is stored in the order of: [batch,
|
* height, width, channels]. Only "NHWC" is currently supported.
|
* @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
|
* in which we sample input values across the height and width dimensions
|
* in atrous convolution. Defaults to `[1, 1]`. If `dilations` is a single
|
* number, then `dilationHeight == dilationWidth`. If it is greater than
|
* 1, then all values of `strides` must be 1.
|
* @param dimRoundingMode The rounding mode used when computing output
|
* dimensions if pad is a number. If none is provided, it will not round
|
* and error if the output is of fractional size.
|
* @param bias Tensor to be added to the result.
|
* @param activation Name of activation kernel (defaults to `linear`) to be
|
* applied
|
* after biasAdd.
|
* @param preluActivationWeights Tensor of prelu weights to be applied as part
|
* of a `prelu` activation, typically the same shape as `x`.
|
*/
|
declare function fusedConv2d_<T extends Tensor3D | Tensor4D>({ x, filter, strides, pad, dataFormat, dilations, dimRoundingMode, bias, activation, preluActivationWeights }: {
|
x: T | TensorLike;
|
filter: Tensor4D | TensorLike;
|
strides: [number, number] | number;
|
pad: 'valid' | 'same' | number;
|
dataFormat?: 'NHWC' | 'NCHW';
|
dilations?: [number, number] | number;
|
dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
bias?: Tensor | TensorLike;
|
activation?: Activation;
|
preluActivationWeights?: Tensor;
|
}): T;
|
/**
|
* Computes depthwise 2D convolution, optionally fused with adding a
|
* bias and applying an activation.
|
*
|
* Given a 4D `input` array and a `filter` array of shape
|
* `[filterHeight, filterWidth, inChannels, channelMultiplier]` containing
|
* `inChannels` convolutional filters of depth 1, this op applies a
|
* different filter to each input channel (expanding from 1 channel to
|
* `channelMultiplier` channels for each), then concatenates the results
|
* together. The output has `inChannels * channelMultiplier` channels.
|
*
|
* See
|
* [https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d](
|
* https://www.tensorflow.org/api_docs/python/tf/nn/depthwise_conv2d)
|
* for more details.
|
*
|
* @param obj An object with the following properties:
|
* @param x The input tensor, of rank 4 or rank 3, of shape
|
* `[batch, height, width, inChannels]`. If rank 3, batch of 1 is
|
* assumed.
|
* @param filter The filter tensor, rank 4, of shape
|
* `[filterHeight, filterWidth, inChannels, channelMultiplier]`.
|
* @param strides The strides of the convolution: `[strideHeight,
|
* strideWidth]`. If strides is a single number, then `strideHeight ==
|
* strideWidth`.
|
* @param pad The type of padding algorithm.
|
* - `same` and stride 1: output will be of same size as input,
|
* regardless of filter size.
|
* - `valid`: output will be smaller than input if filter is larger
|
* than 1x1.
|
* - For more info, see this guide:
|
* [https://www.tensorflow.org/api_guides/python/nn#Convolution](
|
* https://www.tensorflow.org/api_guides/python/nn#Convolution)
|
* @param dilations The dilation rates: `[dilationHeight, dilationWidth]`
|
* in which we sample input values across the height and width dimensions
|
* in atrous convolution. Defaults to `[1, 1]`. If `rate` is a single
|
* number, then `dilationHeight == dilationWidth`. If it is greater than
|
* 1, then all values of `strides` must be 1.
|
* @param dataFormat: An optional string from: "NHWC", "NCHW". Defaults to
|
* "NHWC". Specify the data format of the input and output data. With the
|
* default format "NHWC", the data is stored in the order of: [batch,
|
* height, width, channels]. Only "NHWC" is currently supported.
|
* @param dimRoundingMode The rounding mode used when computing output
|
* dimensions if pad is a number. If none is provided, it will not round
|
* and error if the output is of fractional size.
|
* @param bias Tensor to be added to the result.
|
* @param activation Name of activation kernel (defaults to `linear`).
|
* @param preluActivationWeights Tensor of prelu weights to be applied as part
|
* of a `prelu` activation, typically the same shape as `x`.
|
*/
|
declare function fusedDepthwiseConv2d_<T extends Tensor3D | Tensor4D>({ x, filter, strides, pad, dataFormat, dilations, dimRoundingMode, bias, activation, preluActivationWeights }: {
|
x: T | TensorLike;
|
filter: Tensor4D | TensorLike;
|
strides: [number, number] | number;
|
pad: 'valid' | 'same' | number;
|
dataFormat?: 'NHWC' | 'NCHW';
|
dilations?: [number, number] | number;
|
dimRoundingMode?: 'floor' | 'round' | 'ceil';
|
bias?: Tensor | TensorLike;
|
activation?: Activation;
|
preluActivationWeights?: Tensor;
|
}): T;
|
export declare const matMul: typeof fusedMatMul_;
|
export declare const conv2d: typeof fusedConv2d_;
|
export declare const depthwiseConv2d: typeof fusedDepthwiseConv2d_;
|
export { Activation };
|
