/**
|
* @license
|
* Copyright 2018 Google LLC
|
*
|
* Use of this source code is governed by an MIT-style
|
* license that can be found in the LICENSE file or at
|
* https://opensource.org/licenses/MIT.
|
* =============================================================================
|
*/
|
/**
|
* TensorFlow.js Layers: Pooling Layers.
|
*/
|
import * as tfc from '@tensorflow/tfjs-core';
|
import { serialization, tidy } from '@tensorflow/tfjs-core';
|
import { imageDataFormat } from '../backend/common';
|
import * as K from '../backend/tfjs_backend';
|
import { checkDataFormat, checkPaddingMode, checkPoolMode } from '../common';
|
import { InputSpec } from '../engine/topology';
|
import { Layer } from '../engine/topology';
|
import { NotImplementedError, ValueError } from '../errors';
|
import { convOutputLength } from '../utils/conv_utils';
|
import { assertPositiveInteger } from '../utils/generic_utils';
|
import { getExactlyOneShape, getExactlyOneTensor } from '../utils/types_utils';
|
import { preprocessConv2DInput, preprocessConv3DInput } from './convolutional';
|
/**
|
* 2D pooling.
|
* @param x
|
* @param poolSize
|
* @param strides strides. Defaults to [1, 1].
|
* @param padding padding. Defaults to 'valid'.
|
* @param dataFormat data format. Defaults to 'channelsLast'.
|
* @param poolMode Mode of pooling. Defaults to 'max'.
|
* @returns Result of the 2D pooling.
|
*/
|
export function pool2d(x, poolSize, strides, padding, dataFormat, poolMode) {
|
return tidy(() => {
|
checkDataFormat(dataFormat);
|
checkPoolMode(poolMode);
|
checkPaddingMode(padding);
|
if (strides == null) {
|
strides = [1, 1];
|
}
|
if (padding == null) {
|
padding = 'valid';
|
}
|
if (dataFormat == null) {
|
dataFormat = imageDataFormat();
|
}
|
if (poolMode == null) {
|
poolMode = 'max';
|
}
|
// TODO(cais): Remove the preprocessing step once deeplearn.js supports
|
// dataFormat as an input argument.
|
x = preprocessConv2DInput(x, dataFormat); // x is NHWC after preprocessing.
|
let y;
|
const paddingString = (padding === 'same') ? 'same' : 'valid';
|
if (poolMode === 'max') {
|
// TODO(cais): Rank check?
|
y = tfc.maxPool(x, poolSize, strides, paddingString);
|
}
|
else { // 'avg'
|
// TODO(cais): Check the dtype and rank of x and give clear error message
|
// if those are incorrect.
|
y = tfc.avgPool(
|
// TODO(cais): Rank check?
|
x, poolSize, strides, paddingString);
|
}
|
if (dataFormat === 'channelsFirst') {
|
y = tfc.transpose(y, [0, 3, 1, 2]); // NHWC -> NCHW.
|
}
|
return y;
|
});
|
}
|
/**
|
* 3D pooling.
|
* @param x
|
* @param poolSize. Default to [1, 1, 1].
|
* @param strides strides. Defaults to [1, 1, 1].
|
* @param padding padding. Defaults to 'valid'.
|
* @param dataFormat data format. Defaults to 'channelsLast'.
|
* @param poolMode Mode of pooling. Defaults to 'max'.
|
* @returns Result of the 3D pooling.
|
*/
|
export function pool3d(x, poolSize, strides, padding, dataFormat, poolMode) {
|
return tidy(() => {
|
checkDataFormat(dataFormat);
|
checkPoolMode(poolMode);
|
checkPaddingMode(padding);
|
if (strides == null) {
|
strides = [1, 1, 1];
|
}
|
if (padding == null) {
|
padding = 'valid';
|
}
|
if (dataFormat == null) {
|
dataFormat = imageDataFormat();
|
}
|
if (poolMode == null) {
|
poolMode = 'max';
|
}
|
// x is NDHWC after preprocessing.
|
x = preprocessConv3DInput(x, dataFormat);
|
let y;
|
const paddingString = (padding === 'same') ? 'same' : 'valid';
|
if (poolMode === 'max') {
|
y = tfc.maxPool3d(x, poolSize, strides, paddingString);
|
}
|
else { // 'avg'
|
y = tfc.avgPool3d(x, poolSize, strides, paddingString);
|
}
|
if (dataFormat === 'channelsFirst') {
|
y = tfc.transpose(y, [0, 4, 1, 2, 3]); // NDHWC -> NCDHW.
|
}
|
return y;
|
});
|
}
|
/**
|
* Abstract class for different pooling 1D layers.
|
*/
|
export class Pooling1D extends Layer {
|
/**
|
*
|
* @param args Parameters for the Pooling layer.
|
*
|
* config.poolSize defaults to 2.
|
*/
|
constructor(args) {
|
if (args.poolSize == null) {
|
args.poolSize = 2;
|
}
|
super(args);
|
if (typeof args.poolSize === 'number') {
|
this.poolSize = [args.poolSize];
|
}
|
else if (Array.isArray(args.poolSize) &&
|
args.poolSize.length === 1 &&
|
typeof args.poolSize[0] === 'number') {
|
this.poolSize = args.poolSize;
|
}
|
else {
|
throw new ValueError(`poolSize for 1D convolutional layer must be a number or an ` +
|
`Array of a single number, but received ` +
|
`${JSON.stringify(args.poolSize)}`);
|
}
|
assertPositiveInteger(this.poolSize, 'poolSize');
|
if (args.strides == null) {
|
this.strides = this.poolSize;
|
}
|
else {
|
if (typeof args.strides === 'number') {
|
this.strides = [args.strides];
|
}
|
else if (Array.isArray(args.strides) &&
|
args.strides.length === 1 &&
|
typeof args.strides[0] === 'number') {
|
this.strides = args.strides;
|
}
|
else {
|
throw new ValueError(`strides for 1D convolutional layer must be a number or an ` +
|
`Array of a single number, but received ` +
|
`${JSON.stringify(args.strides)}`);
|
}
|
}
|
assertPositiveInteger(this.strides, 'strides');
|
this.padding = args.padding == null ? 'valid' : args.padding;
|
checkPaddingMode(this.padding);
|
this.inputSpec = [new InputSpec({ ndim: 3 })];
|
}
|
computeOutputShape(inputShape) {
|
inputShape = getExactlyOneShape(inputShape);
|
const length = convOutputLength(inputShape[1], this.poolSize[0], this.padding, this.strides[0]);
|
return [inputShape[0], length, inputShape[2]];
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
this.invokeCallHook(inputs, kwargs);
|
// Add dummy last dimension.
|
inputs = K.expandDims(getExactlyOneTensor(inputs), 2);
|
const output = this.poolingFunction(getExactlyOneTensor(inputs), [this.poolSize[0], 1], [this.strides[0], 1], this.padding, 'channelsLast');
|
// Remove dummy last dimension.
|
return tfc.squeeze(output, [2]);
|
});
|
}
|
getConfig() {
|
const config = {
|
poolSize: this.poolSize,
|
padding: this.padding,
|
strides: this.strides,
|
};
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
class MaxPooling1D extends Pooling1D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool2d(inputs, poolSize, strides, padding, dataFormat, 'max');
|
}
|
}
|
/** @nocollapse */
|
MaxPooling1D.className = 'MaxPooling1D';
|
export { MaxPooling1D };
|
serialization.registerClass(MaxPooling1D);
|
class AveragePooling1D extends Pooling1D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool2d(inputs, poolSize, strides, padding, dataFormat, 'avg');
|
}
|
}
|
/** @nocollapse */
|
AveragePooling1D.className = 'AveragePooling1D';
|
export { AveragePooling1D };
|
serialization.registerClass(AveragePooling1D);
|
/**
|
* Abstract class for different pooling 2D layers.
|
*/
|
export class Pooling2D extends Layer {
|
constructor(args) {
|
if (args.poolSize == null) {
|
args.poolSize = [2, 2];
|
}
|
super(args);
|
this.poolSize = Array.isArray(args.poolSize) ?
|
args.poolSize :
|
[args.poolSize, args.poolSize];
|
if (args.strides == null) {
|
this.strides = this.poolSize;
|
}
|
else if (Array.isArray(args.strides)) {
|
if (args.strides.length !== 2) {
|
throw new ValueError(`If the strides property of a 2D pooling layer is an Array, ` +
|
`it is expected to have a length of 2, but received length ` +
|
`${args.strides.length}.`);
|
}
|
this.strides = args.strides;
|
}
|
else {
|
// `config.strides` is a number.
|
this.strides = [args.strides, args.strides];
|
}
|
assertPositiveInteger(this.poolSize, 'poolSize');
|
assertPositiveInteger(this.strides, 'strides');
|
this.padding = args.padding == null ? 'valid' : args.padding;
|
this.dataFormat =
|
args.dataFormat == null ? 'channelsLast' : args.dataFormat;
|
checkDataFormat(this.dataFormat);
|
checkPaddingMode(this.padding);
|
this.inputSpec = [new InputSpec({ ndim: 4 })];
|
}
|
computeOutputShape(inputShape) {
|
inputShape = getExactlyOneShape(inputShape);
|
let rows = this.dataFormat === 'channelsFirst' ? inputShape[2] : inputShape[1];
|
let cols = this.dataFormat === 'channelsFirst' ? inputShape[3] : inputShape[2];
|
rows =
|
convOutputLength(rows, this.poolSize[0], this.padding, this.strides[0]);
|
cols =
|
convOutputLength(cols, this.poolSize[1], this.padding, this.strides[1]);
|
if (this.dataFormat === 'channelsFirst') {
|
return [inputShape[0], inputShape[1], rows, cols];
|
}
|
else {
|
return [inputShape[0], rows, cols, inputShape[3]];
|
}
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
this.invokeCallHook(inputs, kwargs);
|
return this.poolingFunction(getExactlyOneTensor(inputs), this.poolSize, this.strides, this.padding, this.dataFormat);
|
});
|
}
|
getConfig() {
|
const config = {
|
poolSize: this.poolSize,
|
padding: this.padding,
|
strides: this.strides,
|
dataFormat: this.dataFormat
|
};
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
class MaxPooling2D extends Pooling2D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool2d(inputs, poolSize, strides, padding, dataFormat, 'max');
|
}
|
}
|
/** @nocollapse */
|
MaxPooling2D.className = 'MaxPooling2D';
|
export { MaxPooling2D };
|
serialization.registerClass(MaxPooling2D);
|
class AveragePooling2D extends Pooling2D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool2d(inputs, poolSize, strides, padding, dataFormat, 'avg');
|
}
|
}
|
/** @nocollapse */
|
AveragePooling2D.className = 'AveragePooling2D';
|
export { AveragePooling2D };
|
serialization.registerClass(AveragePooling2D);
|
/**
|
* Abstract class for different pooling 3D layers.
|
*/
|
export class Pooling3D extends Layer {
|
constructor(args) {
|
if (args.poolSize == null) {
|
args.poolSize = [2, 2, 2];
|
}
|
super(args);
|
this.poolSize = Array.isArray(args.poolSize) ?
|
args.poolSize :
|
[args.poolSize, args.poolSize, args.poolSize];
|
if (args.strides == null) {
|
this.strides = this.poolSize;
|
}
|
else if (Array.isArray(args.strides)) {
|
if (args.strides.length !== 3) {
|
throw new ValueError(`If the strides property of a 3D pooling layer is an Array, ` +
|
`it is expected to have a length of 3, but received length ` +
|
`${args.strides.length}.`);
|
}
|
this.strides = args.strides;
|
}
|
else {
|
// `config.strides` is a number.
|
this.strides = [args.strides, args.strides, args.strides];
|
}
|
assertPositiveInteger(this.poolSize, 'poolSize');
|
assertPositiveInteger(this.strides, 'strides');
|
this.padding = args.padding == null ? 'valid' : args.padding;
|
this.dataFormat =
|
args.dataFormat == null ? 'channelsLast' : args.dataFormat;
|
checkDataFormat(this.dataFormat);
|
checkPaddingMode(this.padding);
|
this.inputSpec = [new InputSpec({ ndim: 5 })];
|
}
|
computeOutputShape(inputShape) {
|
inputShape = getExactlyOneShape(inputShape);
|
let depths = this.dataFormat === 'channelsFirst' ? inputShape[2] : inputShape[1];
|
let rows = this.dataFormat === 'channelsFirst' ? inputShape[3] : inputShape[2];
|
let cols = this.dataFormat === 'channelsFirst' ? inputShape[4] : inputShape[3];
|
depths = convOutputLength(depths, this.poolSize[0], this.padding, this.strides[0]);
|
rows =
|
convOutputLength(rows, this.poolSize[1], this.padding, this.strides[1]);
|
cols =
|
convOutputLength(cols, this.poolSize[2], this.padding, this.strides[2]);
|
if (this.dataFormat === 'channelsFirst') {
|
return [inputShape[0], inputShape[1], depths, rows, cols];
|
}
|
else {
|
return [inputShape[0], depths, rows, cols, inputShape[4]];
|
}
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
this.invokeCallHook(inputs, kwargs);
|
return this.poolingFunction(getExactlyOneTensor(inputs), this.poolSize, this.strides, this.padding, this.dataFormat);
|
});
|
}
|
getConfig() {
|
const config = {
|
poolSize: this.poolSize,
|
padding: this.padding,
|
strides: this.strides,
|
dataFormat: this.dataFormat
|
};
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
class MaxPooling3D extends Pooling3D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool3d(inputs, poolSize, strides, padding, dataFormat, 'max');
|
}
|
}
|
/** @nocollapse */
|
MaxPooling3D.className = 'MaxPooling3D';
|
export { MaxPooling3D };
|
serialization.registerClass(MaxPooling3D);
|
class AveragePooling3D extends Pooling3D {
|
constructor(args) {
|
super(args);
|
}
|
poolingFunction(inputs, poolSize, strides, padding, dataFormat) {
|
checkDataFormat(dataFormat);
|
checkPaddingMode(padding);
|
return pool3d(inputs, poolSize, strides, padding, dataFormat, 'avg');
|
}
|
}
|
/** @nocollapse */
|
AveragePooling3D.className = 'AveragePooling3D';
|
export { AveragePooling3D };
|
serialization.registerClass(AveragePooling3D);
|
/**
|
* Abstract class for different global pooling 1D layers.
|
*/
|
export class GlobalPooling1D extends Layer {
|
constructor(args) {
|
super(args);
|
this.inputSpec = [new InputSpec({ ndim: 3 })];
|
}
|
computeOutputShape(inputShape) {
|
return [inputShape[0], inputShape[2]];
|
}
|
call(inputs, kwargs) {
|
throw new NotImplementedError();
|
}
|
}
|
class GlobalAveragePooling1D extends GlobalPooling1D {
|
constructor(args) {
|
super(args || {});
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
const input = getExactlyOneTensor(inputs);
|
return tfc.mean(input, 1);
|
});
|
}
|
}
|
/** @nocollapse */
|
GlobalAveragePooling1D.className = 'GlobalAveragePooling1D';
|
export { GlobalAveragePooling1D };
|
serialization.registerClass(GlobalAveragePooling1D);
|
class GlobalMaxPooling1D extends GlobalPooling1D {
|
constructor(args) {
|
super(args || {});
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
const input = getExactlyOneTensor(inputs);
|
return tfc.max(input, 1);
|
});
|
}
|
}
|
/** @nocollapse */
|
GlobalMaxPooling1D.className = 'GlobalMaxPooling1D';
|
export { GlobalMaxPooling1D };
|
serialization.registerClass(GlobalMaxPooling1D);
|
/**
|
* Abstract class for different global pooling 2D layers.
|
*/
|
export class GlobalPooling2D extends Layer {
|
constructor(args) {
|
super(args);
|
this.dataFormat =
|
args.dataFormat == null ? 'channelsLast' : args.dataFormat;
|
checkDataFormat(this.dataFormat);
|
this.inputSpec = [new InputSpec({ ndim: 4 })];
|
}
|
computeOutputShape(inputShape) {
|
inputShape = inputShape;
|
if (this.dataFormat === 'channelsLast') {
|
return [inputShape[0], inputShape[3]];
|
}
|
else {
|
return [inputShape[0], inputShape[1]];
|
}
|
}
|
call(inputs, kwargs) {
|
throw new NotImplementedError();
|
}
|
getConfig() {
|
const config = { dataFormat: this.dataFormat };
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
class GlobalAveragePooling2D extends GlobalPooling2D {
|
call(inputs, kwargs) {
|
return tidy(() => {
|
const input = getExactlyOneTensor(inputs);
|
if (this.dataFormat === 'channelsLast') {
|
return tfc.mean(input, [1, 2]);
|
}
|
else {
|
return tfc.mean(input, [2, 3]);
|
}
|
});
|
}
|
}
|
/** @nocollapse */
|
GlobalAveragePooling2D.className = 'GlobalAveragePooling2D';
|
export { GlobalAveragePooling2D };
|
serialization.registerClass(GlobalAveragePooling2D);
|
class GlobalMaxPooling2D extends GlobalPooling2D {
|
call(inputs, kwargs) {
|
return tidy(() => {
|
const input = getExactlyOneTensor(inputs);
|
if (this.dataFormat === 'channelsLast') {
|
return tfc.max(input, [1, 2]);
|
}
|
else {
|
return tfc.max(input, [2, 3]);
|
}
|
});
|
}
|
}
|
/** @nocollapse */
|
GlobalMaxPooling2D.className = 'GlobalMaxPooling2D';
|
export { GlobalMaxPooling2D };
|
serialization.registerClass(GlobalMaxPooling2D);
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pooling.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/layers/pooling.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Use of this source code is governed by an MIT-style\n * license that can be found in the LICENSE file or at\n * https://opensource.org/licenses/MIT.\n * =============================================================================\n */\n\n/**\n * TensorFlow.js Layers: Pooling Layers.\n */\n\nimport * as tfc from '@tensorflow/tfjs-core';\nimport {serialization, Tensor, Tensor3D, Tensor4D, Tensor5D, tidy} from '@tensorflow/tfjs-core';\n\nimport {imageDataFormat} from '../backend/common';\nimport * as K from '../backend/tfjs_backend';\nimport {checkDataFormat, checkPaddingMode, checkPoolMode} from '../common';\nimport {InputSpec} from '../engine/topology';\nimport {Layer, LayerArgs} from '../engine/topology';\nimport {NotImplementedError, ValueError} from '../errors';\nimport {DataFormat, PaddingMode, PoolMode, Shape} from '../keras_format/common';\nimport {Kwargs} from '../types';\nimport {convOutputLength} from '../utils/conv_utils';\nimport {assertPositiveInteger} from '../utils/generic_utils';\nimport {getExactlyOneShape, getExactlyOneTensor} from '../utils/types_utils';\n\nimport {preprocessConv2DInput, preprocessConv3DInput} from './convolutional';\n\n/**\n * 2D pooling.\n * @param x\n * @param poolSize\n * @param strides strides. Defaults to [1, 1].\n * @param padding padding. Defaults to 'valid'.\n * @param dataFormat data format. Defaults to 'channelsLast'.\n * @param poolMode Mode of pooling. Defaults to 'max'.\n * @returns Result of the 2D pooling.\n */\nexport function pool2d(\n    x: Tensor, poolSize: [number, number], strides?: [number, number],\n    padding?: PaddingMode, dataFormat?: DataFormat,\n    poolMode?: PoolMode): Tensor {\n  return tidy(() => {\n    checkDataFormat(dataFormat);\n    checkPoolMode(poolMode);\n    checkPaddingMode(padding);\n    if (strides == null) {\n      strides = [1, 1];\n    }\n    if (padding == null) {\n      padding = 'valid';\n    }\n    if (dataFormat == null) {\n      dataFormat = imageDataFormat();\n    }\n    if (poolMode == null) {\n      poolMode = 'max';\n    }\n\n    // TODO(cais): Remove the preprocessing step once deeplearn.js supports\n    // dataFormat as an input argument.\n    x = preprocessConv2DInput(x, dataFormat);  // x is NHWC after preprocessing.\n    let y: Tensor;\n    const paddingString = (padding === 'same') ? 'same' : 'valid';\n    if (poolMode === 'max') {\n      // TODO(cais): Rank check?\n      y = tfc.maxPool(x as Tensor4D, poolSize, strides, paddingString);\n    } else {  // 'avg'\n      // TODO(cais): Check the dtype and rank of x and give clear error message\n      //   if those are incorrect.\n      y = tfc.avgPool(\n          // TODO(cais): Rank check?\n          x as Tensor3D | Tensor4D, poolSize, strides, paddingString);\n    }\n    if (dataFormat === 'channelsFirst') {\n      y = tfc.transpose(y, [0, 3, 1, 2]);  // NHWC -> NCHW.\n    }\n    return y;\n  });\n}\n\n/**\n * 3D pooling.\n * @param x\n * @param poolSize. Default to [1, 1, 1].\n * @param strides strides. Defaults to [1, 1, 1].\n * @param padding padding. Defaults to 'valid'.\n * @param dataFormat data format. Defaults to 'channelsLast'.\n * @param poolMode Mode of pooling. Defaults to 'max'.\n * @returns Result of the 3D pooling.\n */\nexport function pool3d(\n    x: Tensor5D, poolSize: [number, number, number],\n    strides?: [number, number, number], padding?: PaddingMode,\n    dataFormat?: DataFormat, poolMode?: PoolMode): Tensor {\n  return tidy(() => {\n    checkDataFormat(dataFormat);\n    checkPoolMode(poolMode);\n    checkPaddingMode(padding);\n    if (strides == null) {\n      strides = [1, 1, 1];\n    }\n    if (padding == null) {\n      padding = 'valid';\n    }\n    if (dataFormat == null) {\n      dataFormat = imageDataFormat();\n    }\n    if (poolMode == null) {\n      poolMode = 'max';\n    }\n\n    // x is NDHWC after preprocessing.\n    x = preprocessConv3DInput(x as Tensor, dataFormat) as Tensor5D;\n    let y: Tensor;\n    const paddingString = (padding === 'same') ? 'same' : 'valid';\n    if (poolMode === 'max') {\n      y = tfc.maxPool3d(x, poolSize, strides, paddingString);\n    } else {  // 'avg'\n      y = tfc.avgPool3d(x, poolSize, strides, paddingString);\n    }\n    if (dataFormat === 'channelsFirst') {\n      y = tfc.transpose(y, [0, 4, 1, 2, 3]);  // NDHWC -> NCDHW.\n    }\n    return y;\n  });\n}\n\nexport declare interface Pooling1DLayerArgs extends LayerArgs {\n  /**\n   * Size of the window to pool over, should be an integer.\n   */\n  poolSize?: number|[number];\n  /**\n   * Period at which to sample the pooled values.\n   *\n   * If `null`, defaults to `poolSize`.\n   */\n  strides?: number|[number];\n  /** How to fill in data that's not an integer multiple of poolSize. */\n  padding?: PaddingMode;\n}\n\n/**\n * Abstract class for different pooling 1D layers.\n */\nexport abstract class Pooling1D extends Layer {\n  protected readonly poolSize: [number];\n  protected readonly strides: [number];\n  protected readonly padding: PaddingMode;\n\n  /**\n   *\n   * @param args Parameters for the Pooling layer.\n   *\n   * config.poolSize defaults to 2.\n   */\n  constructor(args: Pooling1DLayerArgs) {\n    if (args.poolSize == null) {\n      args.poolSize = 2;\n    }\n    super(args);\n    if (typeof args.poolSize === 'number') {\n      this.poolSize = [args.poolSize];\n    } else if (\n        Array.isArray(args.poolSize) &&\n        (args.poolSize as number[]).length === 1 &&\n        typeof (args.poolSize as number[])[0] === 'number') {\n      this.poolSize = args.poolSize;\n    } else {\n      throw new ValueError(\n          `poolSize for 1D convolutional layer must be a number or an ` +\n          `Array of a single number, but received ` +\n          `${JSON.stringify(args.poolSize)}`);\n    }\n    assertPositiveInteger(this.poolSize, 'poolSize');\n    if (args.strides == null) {\n      this.strides = this.poolSize;\n    } else {\n      if (typeof args.strides === 'number') {\n        this.strides = [args.strides];\n      } else if (\n          Array.isArray(args.strides) &&\n          (args.strides as number[]).length === 1 &&\n          typeof (args.strides as number[])[0] === 'number') {\n        this.strides = args.strides;\n      } else {\n        throw new ValueError(\n            `strides for 1D convolutional layer must be a number or an ` +\n            `Array of a single number, but received ` +\n            `${JSON.stringify(args.strides)}`);\n      }\n    }\n    assertPositiveInteger(this.strides, 'strides');\n\n    this.padding = args.padding == null ? 'valid' : args.padding;\n    checkPaddingMode(this.padding);\n    this.inputSpec = [new InputSpec({ndim: 3})];\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = getExactlyOneShape(inputShape);\n    const length = convOutputLength(\n        inputShape[1], this.poolSize[0], this.padding, this.strides[0]);\n    return [inputShape[0], length, inputShape[2]];\n  }\n\n  protected abstract poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor;\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      this.invokeCallHook(inputs, kwargs);\n      // Add dummy last dimension.\n      inputs = K.expandDims(getExactlyOneTensor(inputs), 2);\n      const output = this.poolingFunction(\n          getExactlyOneTensor(inputs), [this.poolSize[0], 1],\n          [this.strides[0], 1], this.padding, 'channelsLast');\n      // Remove dummy last dimension.\n      return tfc.squeeze(output, [2]);\n    });\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config = {\n      poolSize: this.poolSize,\n      padding: this.padding,\n      strides: this.strides,\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\n\nexport class MaxPooling1D extends Pooling1D {\n  /** @nocollapse */\n  static className = 'MaxPooling1D';\n  constructor(args: Pooling1DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool2d(inputs, poolSize, strides, padding, dataFormat, 'max');\n  }\n}\nserialization.registerClass(MaxPooling1D);\n\nexport class AveragePooling1D extends Pooling1D {\n  /** @nocollapse */\n  static className = 'AveragePooling1D';\n  constructor(args: Pooling1DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool2d(inputs, poolSize, strides, padding, dataFormat, 'avg');\n  }\n}\nserialization.registerClass(AveragePooling1D);\n\nexport declare interface Pooling2DLayerArgs extends LayerArgs {\n  /**\n   * Factors by which to downscale in each dimension [vertical, horizontal].\n   * Expects an integer or an array of 2 integers.\n   *\n   * For example, `[2, 2]` will halve the input in both spatial dimensions.\n   * If only one integer is specified, the same window length\n   * will be used for both dimensions.\n   */\n  poolSize?: number|[number, number];\n\n  /**\n   * The size of the stride in each dimension of the pooling window. Expects\n   * an integer or an array of 2 integers. Integer, tuple of 2 integers, or\n   * None.\n   *\n   * If `null`, defaults to `poolSize`.\n   */\n  strides?: number|[number, number];\n\n  /** The padding type to use for the pooling layer. */\n  padding?: PaddingMode;\n  /** The data format to use for the pooling layer. */\n  dataFormat?: DataFormat;\n}\n\n/**\n * Abstract class for different pooling 2D layers.\n */\nexport abstract class Pooling2D extends Layer {\n  protected readonly poolSize: [number, number];\n  protected readonly strides: [number, number];\n  protected readonly padding: PaddingMode;\n  protected readonly dataFormat: DataFormat;\n\n  constructor(args: Pooling2DLayerArgs) {\n    if (args.poolSize == null) {\n      args.poolSize = [2, 2];\n    }\n    super(args);\n    this.poolSize = Array.isArray(args.poolSize) ?\n        args.poolSize :\n        [args.poolSize, args.poolSize];\n    if (args.strides == null) {\n      this.strides = this.poolSize;\n    } else if (Array.isArray(args.strides)) {\n      if (args.strides.length !== 2) {\n        throw new ValueError(\n            `If the strides property of a 2D pooling layer is an Array, ` +\n            `it is expected to have a length of 2, but received length ` +\n            `${args.strides.length}.`);\n      }\n      this.strides = args.strides;\n    } else {\n      // `config.strides` is a number.\n      this.strides = [args.strides, args.strides];\n    }\n    assertPositiveInteger(this.poolSize, 'poolSize');\n    assertPositiveInteger(this.strides, 'strides');\n    this.padding = args.padding == null ? 'valid' : args.padding;\n    this.dataFormat =\n        args.dataFormat == null ? 'channelsLast' : args.dataFormat;\n    checkDataFormat(this.dataFormat);\n    checkPaddingMode(this.padding);\n\n    this.inputSpec = [new InputSpec({ndim: 4})];\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = getExactlyOneShape(inputShape);\n    let rows =\n        this.dataFormat === 'channelsFirst' ? inputShape[2] : inputShape[1];\n    let cols =\n        this.dataFormat === 'channelsFirst' ? inputShape[3] : inputShape[2];\n    rows =\n        convOutputLength(rows, this.poolSize[0], this.padding, this.strides[0]);\n    cols =\n        convOutputLength(cols, this.poolSize[1], this.padding, this.strides[1]);\n    if (this.dataFormat === 'channelsFirst') {\n      return [inputShape[0], inputShape[1], rows, cols];\n    } else {\n      return [inputShape[0], rows, cols, inputShape[3]];\n    }\n  }\n\n  protected abstract poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor;\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      this.invokeCallHook(inputs, kwargs);\n      return this.poolingFunction(\n          getExactlyOneTensor(inputs), this.poolSize, this.strides,\n          this.padding, this.dataFormat);\n    });\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config = {\n      poolSize: this.poolSize,\n      padding: this.padding,\n      strides: this.strides,\n      dataFormat: this.dataFormat\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\n\nexport class MaxPooling2D extends Pooling2D {\n  /** @nocollapse */\n  static className = 'MaxPooling2D';\n  constructor(args: Pooling2DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool2d(inputs, poolSize, strides, padding, dataFormat, 'max');\n  }\n}\nserialization.registerClass(MaxPooling2D);\n\nexport class AveragePooling2D extends Pooling2D {\n  /** @nocollapse */\n  static className = 'AveragePooling2D';\n  constructor(args: Pooling2DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number], strides: [number, number],\n      padding: PaddingMode, dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool2d(inputs, poolSize, strides, padding, dataFormat, 'avg');\n  }\n}\nserialization.registerClass(AveragePooling2D);\n\nexport declare interface Pooling3DLayerArgs extends LayerArgs {\n  /**\n   * Factors by which to downscale in each dimension [depth, height, width].\n   * Expects an integer or an array of 3 integers.\n   *\n   * For example, `[2, 2, 2]` will halve the input in three dimensions.\n   * If only one integer is specified, the same window length\n   * will be used for all dimensions.\n   */\n  poolSize?: number|[number, number, number];\n\n  /**\n   * The size of the stride in each dimension of the pooling window. Expects\n   * an integer or an array of 3 integers. Integer, tuple of 3 integers, or\n   * None.\n   *\n   * If `null`, defaults to `poolSize`.\n   */\n  strides?: number|[number, number, number];\n\n  /** The padding type to use for the pooling layer. */\n  padding?: PaddingMode;\n  /** The data format to use for the pooling layer. */\n  dataFormat?: DataFormat;\n}\n\n/**\n * Abstract class for different pooling 3D layers.\n */\nexport abstract class Pooling3D extends Layer {\n  protected readonly poolSize: [number, number, number];\n  protected readonly strides: [number, number, number];\n  protected readonly padding: PaddingMode;\n  protected readonly dataFormat: DataFormat;\n\n  constructor(args: Pooling3DLayerArgs) {\n    if (args.poolSize == null) {\n      args.poolSize = [2, 2, 2];\n    }\n    super(args);\n    this.poolSize = Array.isArray(args.poolSize) ?\n        args.poolSize :\n        [args.poolSize, args.poolSize, args.poolSize];\n    if (args.strides == null) {\n      this.strides = this.poolSize;\n    } else if (Array.isArray(args.strides)) {\n      if (args.strides.length !== 3) {\n        throw new ValueError(\n            `If the strides property of a 3D pooling layer is an Array, ` +\n            `it is expected to have a length of 3, but received length ` +\n            `${args.strides.length}.`);\n      }\n      this.strides = args.strides;\n    } else {\n      // `config.strides` is a number.\n      this.strides = [args.strides, args.strides, args.strides];\n    }\n    assertPositiveInteger(this.poolSize, 'poolSize');\n    assertPositiveInteger(this.strides, 'strides');\n    this.padding = args.padding == null ? 'valid' : args.padding;\n    this.dataFormat =\n        args.dataFormat == null ? 'channelsLast' : args.dataFormat;\n    checkDataFormat(this.dataFormat);\n    checkPaddingMode(this.padding);\n\n    this.inputSpec = [new InputSpec({ndim: 5})];\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = getExactlyOneShape(inputShape);\n    let depths =\n        this.dataFormat === 'channelsFirst' ? inputShape[2] : inputShape[1];\n    let rows =\n        this.dataFormat === 'channelsFirst' ? inputShape[3] : inputShape[2];\n    let cols =\n        this.dataFormat === 'channelsFirst' ? inputShape[4] : inputShape[3];\n    depths = convOutputLength(\n        depths, this.poolSize[0], this.padding, this.strides[0]);\n    rows =\n        convOutputLength(rows, this.poolSize[1], this.padding, this.strides[1]);\n    cols =\n        convOutputLength(cols, this.poolSize[2], this.padding, this.strides[2]);\n    if (this.dataFormat === 'channelsFirst') {\n      return [inputShape[0], inputShape[1], depths, rows, cols];\n    } else {\n      return [inputShape[0], depths, rows, cols, inputShape[4]];\n    }\n  }\n\n  protected abstract poolingFunction(\n      inputs: Tensor, poolSize: [number, number, number],\n      strides: [number, number, number], padding: PaddingMode,\n      dataFormat: DataFormat): Tensor;\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      this.invokeCallHook(inputs, kwargs);\n      return this.poolingFunction(\n          getExactlyOneTensor(inputs), this.poolSize, this.strides,\n          this.padding, this.dataFormat);\n    });\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config = {\n      poolSize: this.poolSize,\n      padding: this.padding,\n      strides: this.strides,\n      dataFormat: this.dataFormat\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\n\nexport class MaxPooling3D extends Pooling3D {\n  /** @nocollapse */\n  static className = 'MaxPooling3D';\n  constructor(args: Pooling3DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number, number],\n      strides: [number, number, number], padding: PaddingMode,\n      dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool3d(\n        inputs as Tensor5D, poolSize, strides, padding, dataFormat, 'max');\n  }\n}\nserialization.registerClass(MaxPooling3D);\n\nexport class AveragePooling3D extends Pooling3D {\n  /** @nocollapse */\n  static className = 'AveragePooling3D';\n  constructor(args: Pooling3DLayerArgs) {\n    super(args);\n  }\n\n  protected poolingFunction(\n      inputs: Tensor, poolSize: [number, number, number],\n      strides: [number, number, number], padding: PaddingMode,\n      dataFormat: DataFormat): Tensor {\n    checkDataFormat(dataFormat);\n    checkPaddingMode(padding);\n    return pool3d(\n        inputs as Tensor5D, poolSize, strides, padding, dataFormat, 'avg');\n  }\n}\nserialization.registerClass(AveragePooling3D);\n\n/**\n * Abstract class for different global pooling 1D layers.\n */\nexport abstract class GlobalPooling1D extends Layer {\n  constructor(args: LayerArgs) {\n    super(args);\n    this.inputSpec = [new InputSpec({ndim: 3})];\n  }\n\n  override computeOutputShape(inputShape: Shape): Shape {\n    return [inputShape[0], inputShape[2]];\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    throw new NotImplementedError();\n  }\n}\n\nexport class GlobalAveragePooling1D extends GlobalPooling1D {\n  /** @nocollapse */\n  static className = 'GlobalAveragePooling1D';\n  constructor(args?: LayerArgs) {\n    super(args || {});\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      const input = getExactlyOneTensor(inputs);\n      return tfc.mean(input, 1);\n    });\n  }\n}\nserialization.registerClass(GlobalAveragePooling1D);\n\nexport class GlobalMaxPooling1D extends GlobalPooling1D {\n  /** @nocollapse */\n  static className = 'GlobalMaxPooling1D';\n  constructor(args: LayerArgs) {\n    super(args || {});\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      const input = getExactlyOneTensor(inputs);\n      return tfc.max(input, 1);\n    });\n  }\n}\nserialization.registerClass(GlobalMaxPooling1D);\n\nexport declare interface GlobalPooling2DLayerArgs extends LayerArgs {\n  /**\n   * One of `CHANNEL_LAST` (default) or `CHANNEL_FIRST`.\n   *\n   * The ordering of the dimensions in the inputs. `CHANNEL_LAST` corresponds\n   * to inputs with shape `[batch, height, width, channels]` while\n   * `CHANNEL_FIRST` corresponds to inputs with shape\n   * `[batch, channels, height, width]`.\n   */\n  dataFormat?: DataFormat;\n}\n\n/**\n * Abstract class for different global pooling 2D layers.\n */\nexport abstract class GlobalPooling2D extends Layer {\n  protected dataFormat: DataFormat;\n  constructor(args: GlobalPooling2DLayerArgs) {\n    super(args);\n    this.dataFormat =\n        args.dataFormat == null ? 'channelsLast' : args.dataFormat;\n    checkDataFormat(this.dataFormat);\n    this.inputSpec = [new InputSpec({ndim: 4})];\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = inputShape as Shape;\n    if (this.dataFormat === 'channelsLast') {\n      return [inputShape[0], inputShape[3]];\n    } else {\n      return [inputShape[0], inputShape[1]];\n    }\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    throw new NotImplementedError();\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config = {dataFormat: this.dataFormat};\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\n\nexport class GlobalAveragePooling2D extends GlobalPooling2D {\n  /** @nocollapse */\n  static className = 'GlobalAveragePooling2D';\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      const input = getExactlyOneTensor(inputs);\n      if (this.dataFormat === 'channelsLast') {\n        return tfc.mean(input, [1, 2]);\n      } else {\n        return tfc.mean(input, [2, 3]);\n      }\n    });\n  }\n}\nserialization.registerClass(GlobalAveragePooling2D);\n\nexport class GlobalMaxPooling2D extends GlobalPooling2D {\n  /** @nocollapse */\n  static className = 'GlobalMaxPooling2D';\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      const input = getExactlyOneTensor(inputs);\n      if (this.dataFormat === 'channelsLast') {\n        return tfc.max(input, [1, 2]);\n      } else {\n        return tfc.max(input, [2, 3]);\n      }\n    });\n  }\n}\nserialization.registerClass(GlobalMaxPooling2D);\n"]}
|
