@tensorflow/tfjs-core
Version:
Hardware-accelerated JavaScript library for machine intelligence
111 lines (110 loc) • 3.73 kB
TypeScript
/**
* @license
* Copyright 2018 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 } from '../tensor';
import { TensorLike } from '../types';
/**
* Computes rectified linear element-wise: `max(x, 0)`.
*
* ```js
* const x = tf.tensor1d([-1, 2, -3, 4]);
*
* x.relu().print(); // or tf.relu(x)
* ```
* @param x The input tensor. If the dtype is `bool`, the output dtype will be
* `int32'.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function relu_<T extends Tensor>(x: T | TensorLike): T;
/**
* Computes rectified linear 6 element-wise: `min(max(x, 0), 6)`.
*
* ```js
* const x = tf.tensor1d([-1, 2, -3, 8]);
*
* x.relu6().print(); // or tf.relu6(x)
* ```
* @param x The input tensor. If the dtype is `bool`, the output dtype will be
* `int32'.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function relu6_<T extends Tensor>(x: T | TensorLike): T;
/**
* Computes exponential linear element-wise: `x > 0 ? e ^ x - 1 : 0`.
*
* ```js
* const x = tf.tensor1d([-1, 1, -3, 2]);
*
* x.elu().print(); // or tf.elu(x)
* ```
* @param x The input tensor.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function elu_<T extends Tensor>(x: T | TensorLike): T;
/**
* Computes scaled exponential linear element-wise.
*
* `x < 0 ? scale * alpha * (exp(x) - 1) : x`
*
* ```js
* const x = tf.tensor1d([-1, 2, -3, 4]);
*
* x.selu().print(); // or tf.selu(x)
* ```
* @param x The input tensor.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function selu_<T extends Tensor>(x: T | TensorLike): T;
/**
* Computes leaky rectified linear element-wise.
*
* See
* [http://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf](
* http://web.stanford.edu/~awni/papers/relu_hybrid_icml2013_final.pdf)
*
* ```js
* const x = tf.tensor1d([-1, 2, -3, 4]);
*
* x.leakyRelu(0.1).print(); // or tf.leakyRelu(x, 0.1)
* ```
* @param x The input tensor.
* @param alpha The scaling factor for negative values, defaults to 0.2.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function leakyRelu_<T extends Tensor>(x: T | TensorLike, alpha?: number): T;
/**
* Computes leaky rectified linear element-wise with parametric alphas.
*
* `x < 0 ? alpha * x : f(x) = x`
*
* ```js
* const x = tf.tensor1d([-1, 2, -3, 4]);
* const alpha = tf.scalar(0.1);
*
* x.prelu(alpha).print(); // or tf.prelu(x, alpha)
* ```
* @param x The input tensor.
* @param alpha Scaling factor for negative values.
*/
/** @doc {heading: 'Operations', subheading: 'Basic math'} */
declare function prelu_<T extends Tensor>(x: T | TensorLike, alpha: T | TensorLike): T;
export declare const elu: typeof elu_;
export declare const leakyRelu: typeof leakyRelu_;
export declare const prelu: typeof prelu_;
export declare const relu: typeof relu_;
export declare const relu6: typeof relu6_;
export declare const selu: typeof selu_;
export {};