@tensorflow/tfjs-layers
Version:
TensorFlow layers API in JavaScript
486 lines • 67.9 kB
JavaScript
/**
* @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.
* =============================================================================
*/
/**
* Layers that augment the functionality of a base layer.
*/
import * as tfc from '@tensorflow/tfjs-core';
import { serialization, tidy } from '@tensorflow/tfjs-core';
import * as K from '../backend/tfjs_backend';
import { nameScope } from '../common';
import { InputSpec, Layer, SymbolicTensor } from '../engine/topology';
import { NotImplementedError, ValueError } from '../errors';
import { VALID_BIDIRECTIONAL_MERGE_MODES } from '../keras_format/common';
import * as generic_utils from '../utils/generic_utils';
import { getExactlyOneShape, getExactlyOneTensor } from '../utils/types_utils';
import { rnn, standardizeArgs } from './recurrent';
import { deserialize } from './serialization';
/**
* Abstract wrapper base class.
*
* Wrappers take another layer and augment it in various ways.
* Do not use this class as a layer, it is only an abstract base class.
* Two usable wrappers are the `TimeDistributed` and `Bidirectional` wrappers.
*/
export class Wrapper extends Layer {
constructor(args) {
// Porting Note: In PyKeras, `self.layer` is set prior to the calling
// `super()`. But we can't do that here due to TypeScript's restriction.
// See: https://github.com/Microsoft/TypeScript/issues/8277
// As a result, we have to add checks in `get trainable()` and
// `set trainable()` below in order to prevent using `this.layer` when
// its value is `undefined`. The super constructor does use the getter
// and the setter of `this.layer`.
super(args);
this.layer = args.layer;
}
build(inputShape) {
this.built = true;
}
// TODO(cais): Implement activityRegularizer getter.
get trainable() {
// Porting Note: the check of `this.layer` here is necessary due to the
// way the `constructor` of this class is written (see Porting Note
// above).
if (this.layer != null) {
return this.layer.trainable;
}
else {
return false;
}
}
set trainable(value) {
// Porting Note: the check of `this.layer` here is necessary due to the
// way the `constructor` of this class is written (see Porting Note
// above).
if (this.layer != null) {
this.layer.trainable = value;
}
}
get trainableWeights() {
return this.layer.trainableWeights;
}
// TODO(cais): Implement setter for trainableWeights.
get nonTrainableWeights() {
return this.layer.nonTrainableWeights;
}
// TODO(cais): Implement setter for nonTrainableWeights.
get updates() {
// tslint:disable-next-line:no-any
return this.layer._updates;
}
// TODO(cais): Implement getUpdatesFor().
get losses() {
return this.layer.losses;
}
// TODO(cais): Implement getLossesFor().
getWeights() {
return this.layer.getWeights();
}
setWeights(weights) {
this.layer.setWeights(weights);
}
getConfig() {
const config = {
'layer': {
'className': this.layer.getClassName(),
'config': this.layer.getConfig(),
}
};
const baseConfig = super.getConfig();
Object.assign(config, baseConfig);
return config;
}
setFastWeightInitDuringBuild(value) {
super.setFastWeightInitDuringBuild(value);
if (this.layer != null) {
this.layer.setFastWeightInitDuringBuild(value);
}
}
/** @nocollapse */
static fromConfig(cls, config, customObjects = {}) {
const layerConfig = config['layer'];
const layer = deserialize(layerConfig, customObjects);
delete config['layer'];
const newConfig = { layer };
Object.assign(newConfig, config);
return new cls(newConfig);
}
}
class TimeDistributed extends Wrapper {
constructor(args) {
super(args);
this.supportsMasking = true;
}
build(inputShape) {
inputShape = getExactlyOneShape(inputShape);
if (inputShape.length < 3) {
throw new ValueError(`TimeDistributed layer expects an input shape >= 3D, but received ` +
`input shape ${JSON.stringify(inputShape)}`);
}
this.inputSpec = [{ shape: inputShape }];
const childInputShape = [inputShape[0]].concat(inputShape.slice(2));
if (!this.layer.built) {
this.layer.build(childInputShape);
this.layer.built = true;
}
super.build(inputShape);
}
computeOutputShape(inputShape) {
inputShape = getExactlyOneShape(inputShape);
const childInputShape = [inputShape[0]].concat(inputShape.slice(2));
const childOutputShape = this.layer.computeOutputShape(childInputShape);
const timesteps = inputShape[1];
return [childOutputShape[0], timesteps].concat(childOutputShape.slice(1));
}
call(inputs, kwargs) {
return tidy(() => {
// TODO(cais): Add 'training' and 'useLearningPhase' to kwargs.
inputs = getExactlyOneTensor(inputs);
// Porting Note: In tfjs-layers, `inputs` are always concrete tensor
// values. Hence the inputs can't have an undetermined first (batch)
// dimension, which is why we always use the K.rnn approach here.
const step = (inputs, states) => {
// TODO(cais): Add useLearningPhase.
// NOTE(cais): `layer.call` may return a length-1 array of Tensor in
// some cases (e.g., `layer` is a `Sequential` instance), which is
// why `getExactlyOneTensor` is used below.
const output = getExactlyOneTensor(this.layer.call(inputs, kwargs));
return [output, []];
};
const rnnOutputs = rnn(step, inputs, [], false /* goBackwards */, null /* mask */, null /* constants */, false /* unroll */, true /* needPerStepOutputs */);
const y = rnnOutputs[1];
// TODO(cais): Add activity regularization.
// TODO(cais): Add useLearningPhase.
return y;
});
}
}
/** @nocollapse */
TimeDistributed.className = 'TimeDistributed';
export { TimeDistributed };
serialization.registerClass(TimeDistributed);
export function checkBidirectionalMergeMode(value) {
generic_utils.checkStringTypeUnionValue(VALID_BIDIRECTIONAL_MERGE_MODES, 'BidirectionalMergeMode', value);
}
const DEFAULT_BIDIRECTIONAL_MERGE_MODE = 'concat';
class Bidirectional extends Wrapper {
constructor(args) {
super(args);
// Note: When creating `this.forwardLayer`, the original Layer object
// (`config.layer`) ought to be cloned. This is why we call
// `getConfig()` followed by `deserialize()`. Without this cloning,
// the layer names saved during serialization will incorrectly contain
// the 'forward_' prefix. In Python Keras, this is done using
// `copy.copy` (shallow copy), which does not have a simple equivalent
// in JavaScript. JavaScript's `Object.assign()` does not copy
// methods.
const layerConfig = args.layer.getConfig();
const forwDict = {};
forwDict['className'] = args.layer.getClassName();
forwDict['config'] = layerConfig;
this.forwardLayer = deserialize(forwDict);
layerConfig['goBackwards'] =
layerConfig['goBackwards'] === true ? false : true;
const backDict = {};
backDict['className'] = args.layer.getClassName();
backDict['config'] = layerConfig;
this.backwardLayer = deserialize(backDict);
this.forwardLayer.name = 'forward_' + this.forwardLayer.name;
this.backwardLayer.name = 'backward_' + this.backwardLayer.name;
this.mergeMode = args.mergeMode === undefined ?
DEFAULT_BIDIRECTIONAL_MERGE_MODE :
args.mergeMode;
checkBidirectionalMergeMode(this.mergeMode);
if (args.weights) {
throw new NotImplementedError('weights support is not implemented for Bidirectional layer yet.');
}
this._stateful = args.layer.stateful;
this.returnSequences = args.layer.returnSequences;
this.returnState = args.layer.returnState;
this.supportsMasking = true;
this._trainable = true;
this.inputSpec = args.layer.inputSpec;
this.numConstants = null;
}
get trainable() {
return this._trainable;
}
set trainable(value) {
// Porting Note: the check of `this.layer` here is necessary due to the
// way the `constructor` of this class is written (see Porting Note
// above).
this._trainable = value;
if (this.forwardLayer != null) {
this.forwardLayer.trainable = value;
}
if (this.backwardLayer != null) {
this.backwardLayer.trainable = value;
}
}
getWeights() {
return this.forwardLayer.getWeights().concat(this.backwardLayer.getWeights());
}
setWeights(weights) {
const numWeights = weights.length;
const numeightsOver2 = Math.floor(numWeights / 2);
this.forwardLayer.setWeights(weights.slice(0, numeightsOver2));
this.backwardLayer.setWeights(weights.slice(numeightsOver2));
}
computeOutputShape(inputShape) {
let layerShapes = this.forwardLayer.computeOutputShape(inputShape);
if (!(Array.isArray(layerShapes) && Array.isArray(layerShapes[0]))) {
layerShapes = [layerShapes];
}
layerShapes = layerShapes;
let outputShape;
let outputShapes;
let stateShape;
if (this.returnState) {
stateShape = layerShapes.slice(1);
outputShape = layerShapes[0];
}
else {
outputShape = layerShapes[0];
}
outputShape = outputShape;
if (this.mergeMode === 'concat') {
outputShape[outputShape.length - 1] *= 2;
outputShapes = [outputShape];
}
else if (this.mergeMode == null) {
outputShapes = [outputShape, outputShape.slice()];
}
else {
outputShapes = [outputShape];
}
if (this.returnState) {
if (this.mergeMode == null) {
return outputShapes.concat(stateShape).concat(stateShape.slice());
}
return [outputShape].concat(stateShape).concat(stateShape.slice());
}
return generic_utils.singletonOrArray(outputShapes);
}
apply(inputs, kwargs) {
let initialState = kwargs == null ? null : kwargs['initialState'];
let constants = kwargs == null ? null : kwargs['constants'];
if (kwargs == null) {
kwargs = {};
}
const standardized = standardizeArgs(inputs, initialState, constants, this.numConstants);
inputs = standardized.inputs;
initialState = standardized.initialState;
constants = standardized.constants;
if (Array.isArray(inputs)) {
initialState = inputs.slice(1);
inputs = inputs[0];
}
if ((initialState == null || initialState.length === 0) &&
constants == null) {
return super.apply(inputs, kwargs);
}
const additionalInputs = [];
const additionalSpecs = [];
if (initialState != null) {
const numStates = initialState.length;
if (numStates % 2 > 0) {
throw new ValueError('When passing `initialState` to a Bidrectional RNN, ' +
'the state should be an Array containing the states of ' +
'the underlying RNNs.');
}
kwargs['initialState'] = initialState;
additionalInputs.push(...initialState);
const stateSpecs = initialState
.map(state => new InputSpec({ shape: state.shape }));
this.forwardLayer.stateSpec = stateSpecs.slice(0, numStates / 2);
this.backwardLayer.stateSpec = stateSpecs.slice(numStates / 2);
additionalSpecs.push(...stateSpecs);
}
if (constants != null) {
throw new NotImplementedError('Support for constants in Bidirectional layers is not ' +
'implemented yet.');
}
const isSymbolicTensor = additionalInputs[0] instanceof SymbolicTensor;
for (const tensor of additionalInputs) {
if (tensor instanceof SymbolicTensor !== isSymbolicTensor) {
throw new ValueError('The initial state of a Bidirectional layer cannot be ' +
'specified as a mix of symbolic and non-symbolic tensors');
}
}
if (isSymbolicTensor) {
// Compute the full input and specs, including the states.
const fullInput = [inputs].concat(additionalInputs);
const fullInputSpec = this.inputSpec.concat(additionalSpecs);
// Perform the call temporarily and replace inputSpec.
// Note: with initial states symbolic calls and non-symbolic calls to
// this method differ in how the initial states are passed. For
// symbolic calls, the initial states are passed in the first arg, as
// an Array of SymbolicTensors; for non-symbolic calls, they are
// passed in the second arg as a part of the kwargs. Hence the need to
// temporarily modify inputSpec here.
// TODO(cais): Make refactoring so that this hacky code below is no
// longer needed.
const originalInputSpec = this.inputSpec;
this.inputSpec = fullInputSpec;
const output = super.apply(fullInput, kwargs);
this.inputSpec = originalInputSpec;
return output;
}
else {
return super.apply(inputs, kwargs);
}
}
call(inputs, kwargs) {
return tidy(() => {
const initialState = kwargs['initialState'];
let y;
let yRev;
if (initialState == null) {
y = this.forwardLayer.call(inputs, kwargs);
yRev = this.backwardLayer.call(inputs, kwargs);
}
else {
const forwardState = initialState.slice(0, initialState.length / 2);
const backwardState = initialState.slice(initialState.length / 2);
y = this.forwardLayer.call(inputs, Object.assign(kwargs, { initialState: forwardState }));
yRev = this.backwardLayer.call(inputs, Object.assign(kwargs, { initialState: backwardState }));
}
let states;
if (this.returnState) {
if (Array.isArray(y)) {
states = y.slice(1).concat(yRev.slice(1));
}
else {
}
y = y[0];
yRev = yRev[0];
}
if (this.returnSequences) {
yRev = tfc.reverse(yRev, 1);
}
let output;
if (this.mergeMode === 'concat') {
output = K.concatenate([y, yRev]);
}
else if (this.mergeMode === 'sum') {
output = tfc.add(y, yRev);
}
else if (this.mergeMode === 'ave') {
output = tfc.mul(.5, tfc.add(y, yRev));
}
else if (this.mergeMode === 'mul') {
output = tfc.mul(y, yRev);
}
else if (this.mergeMode == null) {
output = [y, yRev];
}
// TODO(cais): Properly set learning phase.
if (this.returnState) {
if (this.mergeMode == null) {
return output.concat(states);
}
return [output].concat(states);
}
return output;
});
}
resetStates(states) {
this.forwardLayer.resetStates();
this.backwardLayer.resetStates();
}
build(inputShape) {
nameScope(this.forwardLayer.name, () => {
this.forwardLayer.build(inputShape);
});
nameScope(this.backwardLayer.name, () => {
this.backwardLayer.build(inputShape);
});
this.built = true;
}
computeMask(inputs, mask) {
if (Array.isArray(mask)) {
mask = mask[0];
}
let outputMask;
if (this.returnSequences) {
if (this.mergeMode == null) {
outputMask = [mask, mask];
}
else {
outputMask = mask;
}
}
else {
if (this.mergeMode == null) {
outputMask = [null, null];
}
else {
outputMask = null;
}
}
if (this.returnState) {
const states = this.forwardLayer.states;
const stateMask = states.map(state => null);
if (Array.isArray(outputMask)) {
return outputMask.concat(stateMask).concat(stateMask);
}
else {
return [outputMask].concat(stateMask).concat(stateMask);
}
}
else {
return outputMask;
}
}
get trainableWeights() {
return this.forwardLayer.trainableWeights.concat(this.backwardLayer.trainableWeights);
}
get nonTrainableWeights() {
return this.forwardLayer.nonTrainableWeights.concat(this.backwardLayer.nonTrainableWeights);
}
// TODO(cais): Implement constraints().
setFastWeightInitDuringBuild(value) {
super.setFastWeightInitDuringBuild(value);
if (this.forwardLayer != null) {
this.forwardLayer.setFastWeightInitDuringBuild(value);
}
if (this.backwardLayer != null) {
this.backwardLayer.setFastWeightInitDuringBuild(value);
}
}
getConfig() {
const config = {
'mergeMode': this.mergeMode,
};
// TODO(cais): Add logic for `numConstants` once the property is added.
const baseConfig = super.getConfig();
Object.assign(config, baseConfig);
return config;
}
/** @nocollapse */
static fromConfig(cls, config) {
const rnnLayer = deserialize(config['layer']);
delete config['layer'];
// TODO(cais): Add logic for `numConstants` once the property is added.
if (config['numConstants'] != null) {
throw new NotImplementedError(`Deserialization of a Bidirectional layer with numConstants ` +
`present is not supported yet.`);
}
// tslint:disable-next-line:no-any
const newConfig = config;
newConfig['layer'] = rnnLayer;
return new cls(newConfig);
}
}
/** @nocollapse */
Bidirectional.className = 'Bidirectional';
export { Bidirectional };
serialization.registerClass(Bidirectional);
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wrappers.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/layers/wrappers.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 * Layers that augment the functionality of a base layer.\n */\n\nimport * as tfc from '@tensorflow/tfjs-core';\nimport {serialization, Tensor, tidy} from '@tensorflow/tfjs-core';\nimport * as K from '../backend/tfjs_backend';\nimport {nameScope} from '../common';\nimport {InputSpec, Layer, LayerArgs, SymbolicTensor} from '../engine/topology';\nimport {NotImplementedError, ValueError} from '../errors';\nimport {BidirectionalMergeMode, Shape, VALID_BIDIRECTIONAL_MERGE_MODES} from '../keras_format/common';\nimport {Kwargs} from '../types';\nimport {RegularizerFn, RnnStepFunction} from '../types';\nimport * as generic_utils from '../utils/generic_utils';\nimport {getExactlyOneShape, getExactlyOneTensor} from '../utils/types_utils';\nimport {LayerVariable} from '../variables';\n\nimport {rnn, RNN, standardizeArgs} from './recurrent';\nimport {deserialize} from './serialization';\n\nexport declare interface WrapperLayerArgs extends LayerArgs {\n  /**\n   * The layer to be wrapped.\n   */\n  layer: Layer;\n}\n\n/**\n * Abstract wrapper base class.\n *\n * Wrappers take another layer and augment it in various ways.\n * Do not use this class as a layer, it is only an abstract base class.\n * Two usable wrappers are the `TimeDistributed` and `Bidirectional` wrappers.\n */\nexport abstract class Wrapper extends Layer {\n  readonly layer: Layer;\n\n  constructor(args: WrapperLayerArgs) {\n    // Porting Note: In PyKeras, `self.layer` is set prior to the calling\n    //   `super()`. But we can't do that here due to TypeScript's restriction.\n    //   See: https://github.com/Microsoft/TypeScript/issues/8277\n    //   As a result, we have to add checks in `get trainable()` and\n    //   `set trainable()` below in order to prevent using `this.layer` when\n    //   its value is `undefined`. The super constructor does use the getter\n    //   and the setter of `this.layer`.\n    super(args);\n    this.layer = args.layer;\n  }\n\n  override build(inputShape: Shape|Shape[]): void {\n    this.built = true;\n  }\n\n  // TODO(cais): Implement activityRegularizer getter.\n\n  override get trainable(): boolean {\n    // Porting Note: the check of `this.layer` here is necessary due to the\n    //   way the `constructor` of this class is written (see Porting Note\n    //   above).\n    if (this.layer != null) {\n      return this.layer.trainable;\n    } else {\n      return false;\n    }\n  }\n\n  override set trainable(value: boolean) {\n    // Porting Note: the check of `this.layer` here is necessary due to the\n    //   way the `constructor` of this class is written (see Porting Note\n    //   above).\n    if (this.layer != null) {\n      this.layer.trainable = value;\n    }\n  }\n\n  override get trainableWeights(): LayerVariable[] {\n    return this.layer.trainableWeights;\n  }\n  // TODO(cais): Implement setter for trainableWeights.\n\n  override get nonTrainableWeights(): LayerVariable[] {\n    return this.layer.nonTrainableWeights;\n  }\n  // TODO(cais): Implement setter for nonTrainableWeights.\n\n  override get updates(): Tensor[] {\n    // tslint:disable-next-line:no-any\n    return (this.layer as any)._updates;\n  }\n\n  // TODO(cais): Implement getUpdatesFor().\n\n  override get losses(): RegularizerFn[] {\n    return this.layer.losses;\n  }\n\n  // TODO(cais): Implement getLossesFor().\n\n  override getWeights(): Tensor[] {\n    return this.layer.getWeights();\n  }\n\n  override setWeights(weights: Tensor[]): void {\n    this.layer.setWeights(weights);\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {\n      'layer': {\n        'className': this.layer.getClassName(),\n        'config': this.layer.getConfig(),\n      }\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n\n  override setFastWeightInitDuringBuild(value: boolean) {\n    super.setFastWeightInitDuringBuild(value);\n    if (this.layer != null) {\n      this.layer.setFastWeightInitDuringBuild(value);\n    }\n  }\n\n  /** @nocollapse */\n  static override fromConfig<T extends serialization.Serializable>(\n      cls: serialization.SerializableConstructor<T>,\n      config: serialization.ConfigDict,\n      customObjects = {} as serialization.ConfigDict): T {\n    const layerConfig = config['layer'] as serialization.ConfigDict;\n    const layer = deserialize(layerConfig, customObjects) as Layer;\n    delete config['layer'];\n    const newConfig = {layer};\n    Object.assign(newConfig, config);\n    return new cls(newConfig);\n  }\n}\n\nexport class TimeDistributed extends Wrapper {\n  /** @nocollapse */\n  static className = 'TimeDistributed';\n  constructor(args: WrapperLayerArgs) {\n    super(args);\n    this.supportsMasking = true;\n  }\n\n  override build(inputShape: Shape|Shape[]): void {\n    inputShape = getExactlyOneShape(inputShape);\n    if (inputShape.length < 3) {\n      throw new ValueError(\n          `TimeDistributed layer expects an input shape >= 3D, but received ` +\n          `input shape ${JSON.stringify(inputShape)}`);\n    }\n    this.inputSpec = [{shape: inputShape}];\n    const childInputShape = [inputShape[0]].concat(inputShape.slice(2));\n    if (!this.layer.built) {\n      this.layer.build(childInputShape);\n      this.layer.built = true;\n    }\n    super.build(inputShape);\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = getExactlyOneShape(inputShape);\n    const childInputShape = [inputShape[0]].concat(inputShape.slice(2));\n    const childOutputShape =\n        this.layer.computeOutputShape(childInputShape) as Shape;\n    const timesteps = inputShape[1];\n    return [childOutputShape[0], timesteps].concat(childOutputShape.slice(1));\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      // TODO(cais): Add 'training' and 'useLearningPhase' to kwargs.\n      inputs = getExactlyOneTensor(inputs);\n      // Porting Note: In tfjs-layers, `inputs` are always concrete tensor\n      // values. Hence the inputs can't have an undetermined first (batch)\n      // dimension, which is why we always use the K.rnn approach here.\n      const step: RnnStepFunction = (inputs: Tensor, states: Tensor[]) => {\n        // TODO(cais): Add useLearningPhase.\n        // NOTE(cais): `layer.call` may return a length-1 array of Tensor in\n        //   some cases (e.g., `layer` is a `Sequential` instance), which is\n        //   why `getExactlyOneTensor` is used below.\n        const output = getExactlyOneTensor(this.layer.call(inputs, kwargs));\n        return [output, []];\n      };\n      const rnnOutputs =\n          rnn(step, inputs, [], false /* goBackwards */, null /* mask */,\n              null /* constants */, false /* unroll */,\n              true /* needPerStepOutputs */);\n      const y = rnnOutputs[1];\n      // TODO(cais): Add activity regularization.\n      // TODO(cais): Add useLearningPhase.\n      return y;\n    });\n  }\n\n  // TODO(cais): Implement detailed computeMask() logic.\n}\nserialization.registerClass(TimeDistributed);\n\nexport function checkBidirectionalMergeMode(value?: string): void {\n  generic_utils.checkStringTypeUnionValue(\n      VALID_BIDIRECTIONAL_MERGE_MODES, 'BidirectionalMergeMode', value);\n}\n\nexport declare interface BidirectionalLayerArgs extends WrapperLayerArgs {\n  /**\n   * The instance of an `RNN` layer to be wrapped.\n   */\n  layer: RNN;\n\n  /**\n   * Mode by which outputs of the forward and ba