/**
|
* @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: Merge Layers.
|
*/
|
import * as tfc from '@tensorflow/tfjs-core';
|
import { serialization, tidy, util } from '@tensorflow/tfjs-core';
|
import * as K from '../backend/tfjs_backend';
|
import { Layer } from '../engine/topology';
|
import { NotImplementedError, ValueError } from '../errors';
|
import { l2Normalize } from '../losses';
|
import * as generic_utils from '../utils/generic_utils';
|
import * as mathUtils from '../utils/math_utils';
|
import { getExactlyOneShape } from '../utils/types_utils';
|
/**
|
* Generic Merge layer for element-wise merge functions.
|
*
|
* Used to implement `Sum`, `Average`, `Concatenate`, etc.
|
*/
|
export class Merge extends Layer {
|
constructor(args) {
|
super(args || {});
|
this.supportsMasking = true;
|
}
|
/**
|
* Logic for merging multiple tensors, to be overridden by subclasses.
|
* @param inputs
|
*/
|
mergeFunction(inputs) {
|
throw new NotImplementedError();
|
}
|
/**
|
* Computes the shape of the result of an elementwise operation.
|
*
|
* @param shape1: Shape of the first tensor.
|
* @param shape2: Shape of the second tensor.
|
* @returns Expected output shape when an elementwise operation is carried
|
* out on 2 tensors with shapes `shape1` and `shape2`.
|
* @throws ValueError: If `shape1` and `shape2` are not compatible for
|
* element-wise operations.
|
*/
|
computeElementwiseOpOutputShape(shape1, shape2) {
|
if (shape1 == null || shape2 == null) {
|
return null;
|
}
|
else if (shape1.length < shape2.length) {
|
return this.computeElementwiseOpOutputShape(shape2, shape1);
|
}
|
else if (shape2.length === 0) {
|
return shape1;
|
}
|
const outputShape = shape1.slice(0, shape1.length - shape2.length);
|
for (let k = 0; k < shape2.length; ++k) {
|
const i = shape1[shape1.length - shape2.length + k];
|
const j = shape2[k];
|
if (i == null || j == null || i < 0 || j < 0) {
|
outputShape.push(null);
|
}
|
else if (i === 1) {
|
outputShape.push(j);
|
}
|
else if (j === 1) {
|
outputShape.push(i);
|
}
|
else {
|
if (i !== j) {
|
throw new ValueError('Operands could not be broadcast together with shapes ' +
|
JSON.stringify(shape1) + ' ' + JSON.stringify(shape2));
|
}
|
outputShape.push(i);
|
}
|
}
|
return outputShape;
|
}
|
build(inputShape) {
|
// Used purely for shape validation.
|
if (Array.isArray(inputShape) && !Array.isArray(inputShape[0])) {
|
// Make sure that inputShape is an Array of shape.
|
inputShape = [getExactlyOneShape(inputShape)];
|
}
|
inputShape = inputShape;
|
if (inputShape.length < 2) {
|
throw new ValueError('A merge layer should be called on an Array of at least 2 inputs.' +
|
` Got ${inputShape.length} input(s).`);
|
}
|
// Make sure that there is at most one unique batch size among the input
|
// shapes.
|
let batchSizes = [];
|
for (const shape of inputShape) {
|
if (shape != null && shape[0] !== null) {
|
batchSizes.push(shape[0]);
|
}
|
}
|
batchSizes = generic_utils.unique(batchSizes);
|
if (batchSizes.length > 1) {
|
throw new ValueError(`Can not merge tensors with different batch sizes. ` +
|
`Got tensors with shapes: ${JSON.stringify(inputShape)}.`);
|
}
|
let outputShape = inputShape[0] == null ? null : inputShape[0].slice(1);
|
for (let i = 1; i < inputShape.length; ++i) {
|
const shape = inputShape[i] == null ? null : inputShape[i].slice(1);
|
outputShape = this.computeElementwiseOpOutputShape(outputShape, shape);
|
}
|
// If the inputs have different ranks, we have to reshape them to make them
|
// broadcastable.
|
const allRanks = inputShape.map(shape => shape.length);
|
if (inputShape.indexOf(null) === -1 &&
|
generic_utils.unique(allRanks).length === 1) {
|
this.reshapeRequired = false;
|
}
|
else {
|
this.reshapeRequired = true;
|
}
|
}
|
call(inputs, kwargs) {
|
return tidy(() => {
|
inputs = inputs;
|
if (this.reshapeRequired) {
|
const reshapedInputs = [];
|
const inputDims = inputs.map(input => input.rank);
|
if (inputDims.indexOf(null) === -1) {
|
// If ranks of all inputs are available, we simply expand each of them
|
// at axis=1 until all of them have the same rank.
|
const maxNDim = mathUtils.max(inputDims);
|
for (let x of inputs) {
|
const xNDim = x.rank;
|
for (let k = 0; k < maxNDim - xNDim; ++k) {
|
x = K.expandDims(x, 1);
|
}
|
reshapedInputs.push(x);
|
}
|
return this.mergeFunction(reshapedInputs);
|
}
|
else {
|
// Transpose all inputs so that batch size is the last dimension.
|
// [batchSize, dim1, dim2, ...] -> [dim1, dim2, ..., batchSize]
|
let transposed = false;
|
for (const x of inputs) {
|
const xNDim = x.rank;
|
if (xNDim == null) {
|
const xShape = x.shape;
|
const batchSize = xShape[0];
|
const newShape = xShape.slice(1).concat([batchSize]);
|
let xTransposed = tfc.reshape(x, [batchSize].concat(mathUtils.arrayProd(xShape.slice(1))));
|
xTransposed = tfc.transpose(xTransposed, [1, 0]);
|
xTransposed = tfc.reshape(xTransposed, newShape);
|
reshapedInputs.push(xTransposed);
|
transposed = true;
|
}
|
else if (xNDim > 1) {
|
const dims = mathUtils.range(1, xNDim).concat([0]);
|
reshapedInputs.push(tfc.transpose(x, dims));
|
transposed = true;
|
}
|
else {
|
// We don't transpose inputs if they are 1D vectors or scalars.
|
reshapedInputs.push(x);
|
}
|
}
|
let y = this.mergeFunction(reshapedInputs);
|
const yNDim = y.rank;
|
if (transposed) {
|
// If inputs have been transposed, we have to transpose the output
|
// too.
|
if (yNDim == null) {
|
const yShape = y.shape;
|
const yNDim = yShape.length;
|
const batchSize = yShape[yNDim - 1];
|
const newShape = [batchSize].concat(yShape.slice(0, yShape.length - 1));
|
y = tfc.reshape(tfc.transpose(tfc.reshape(y, [-1, batchSize]), [1, 0]), newShape);
|
}
|
else if (yNDim > 1) {
|
const dims = [yNDim - 1].concat(mathUtils.range(0, yNDim - 1));
|
y = tfc.transpose(y, dims);
|
}
|
}
|
return y;
|
}
|
}
|
else {
|
return this.mergeFunction(inputs);
|
}
|
});
|
}
|
computeOutputShape(inputShape) {
|
inputShape = inputShape;
|
let outputShape;
|
if (inputShape[0] == null) {
|
outputShape = null;
|
}
|
else {
|
outputShape = inputShape[0].slice(1);
|
}
|
for (let i = 1; i < inputShape.length; ++i) {
|
const shape = inputShape[i] == null ? null : inputShape[i].slice(1);
|
outputShape = this.computeElementwiseOpOutputShape(outputShape, shape);
|
}
|
let batchSizes = [];
|
for (const shape of inputShape) {
|
if (shape != null && shape[0] !== null) {
|
batchSizes.push(shape[0]);
|
}
|
}
|
batchSizes = generic_utils.unique(batchSizes);
|
if (batchSizes.length === 1) {
|
outputShape = batchSizes.concat(outputShape);
|
}
|
else {
|
outputShape = [null].concat(outputShape);
|
}
|
return outputShape;
|
}
|
computeMask(inputs, mask) {
|
return tfc.tidy(() => {
|
if (mask == null) {
|
return null;
|
}
|
if (!Array.isArray(mask)) {
|
throw new ValueError('`mask` should be an Array');
|
}
|
if (!Array.isArray(inputs)) {
|
throw new ValueError('`inputs` should be an Array');
|
}
|
if (mask.length !== inputs.length) {
|
throw new ValueError(`The Array 'inputs' and 'mask' are expected to have the same ` +
|
`length, but have different lengths ` +
|
`(${inputs.length} vs ${mask.length})`);
|
}
|
if (mask.every(m => m == null)) {
|
return null;
|
}
|
mask = mask.map(m => m == null ? m : tfc.expandDims(m, 0));
|
let output = mask[0];
|
for (let i = 1; i < mask.length - 1; ++i) {
|
output = tfc.logicalAnd(output, mask[i]);
|
}
|
return output;
|
});
|
}
|
}
|
class Add extends Merge {
|
constructor(args) {
|
super(args);
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
let output = inputs[0].clone();
|
for (let i = 1; i < inputs.length; ++i) {
|
output = tfc.add(output, inputs[i]);
|
}
|
return output;
|
});
|
}
|
}
|
/** @nocollapse */
|
Add.className = 'Add';
|
export { Add };
|
serialization.registerClass(Add);
|
/**
|
* Calculate the element-wise sum of inputs, which all have the same shape.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Add` layer, by using no input argument
|
* or a single configuration argument. The resultant `Add` layer can then
|
* be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const addLayer = tf.layers.add();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = addLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = tf.layers.add([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);
|
* const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);
|
* tf.layers.add([input1, input2]).print();
|
* // Gives [[11, 22], [33, 44]].
|
*
|
*/
|
export function add(config) {
|
if (Array.isArray(config)) {
|
const layer = new Add({});
|
return layer.apply(config);
|
}
|
else {
|
return new Add(config);
|
}
|
}
|
class Multiply extends Merge {
|
constructor(args) {
|
super(args);
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
let output = inputs[0].clone();
|
for (let i = 1; i < inputs.length; ++i) {
|
output = tfc.mul(output, inputs[i]);
|
}
|
return output;
|
});
|
}
|
}
|
/** @nocollapse */
|
Multiply.className = 'Multiply';
|
export { Multiply };
|
serialization.registerClass(Multiply);
|
/**
|
* Calculate the element-wise product of inputs, which all have the same shape.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Multiply` layer, by using no input argument
|
* or a single configuration argument. The resultant `Multiply` layer can
|
* then be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const multiplyLayer = tf.layers.multiply();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = multiplyLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = tf.layers.multiply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);
|
* const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);
|
* tf.layers.multiply([input1, input2]).print();
|
* // Gives [[10, 40], [90, 160]].
|
*
|
*/
|
export function multiply(config) {
|
if (Array.isArray(config)) {
|
const layer = new Multiply({});
|
return layer.apply(config);
|
}
|
else {
|
return new Multiply(config);
|
}
|
}
|
class Average extends Merge {
|
constructor(args) {
|
super(args);
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
let output = inputs[0].clone();
|
for (let i = 1; i < inputs.length; ++i) {
|
output = tfc.add(output, inputs[i]);
|
}
|
return tfc.mul(1 / inputs.length, output);
|
});
|
}
|
}
|
/** @nocollapse */
|
Average.className = 'Average';
|
export { Average };
|
serialization.registerClass(Average);
|
/**
|
* Calculate the element-wise arithmetic mean of inputs, which all have the same
|
* shape.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Average` layer, by using no input argument
|
* or a single configuration argument. The resultant `Average` layer can then
|
* be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const averageLayer = tf.layers.average();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = averageLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = tf.layers.average([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);
|
* const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);
|
* tf.layers.average([input1, input2]).print();
|
* // Gives [[5.5, 11], [16.5, 22]].
|
*
|
*/
|
export function average(config) {
|
if (Array.isArray(config)) {
|
const layer = new Average({});
|
return layer.apply(config);
|
}
|
else {
|
return new Average(config);
|
}
|
}
|
class Maximum extends Merge {
|
constructor(args) {
|
super(args);
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
let output = inputs[0];
|
for (let i = 1; i < inputs.length; ++i) {
|
output = tfc.maximum(output, inputs[i]);
|
}
|
return output;
|
});
|
}
|
}
|
/** @nocollapse */
|
Maximum.className = 'Maximum';
|
export { Maximum };
|
serialization.registerClass(Maximum);
|
/**
|
* Calculate the element-wise maximum of inputs, which all have the same shape.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Maximum` layer, by using no input argument
|
* or a single configuration argument. The resultant `Maximum` layer can then
|
* be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const maximumLayer = tf.layers.maximum();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = maximumLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = tf.layers.maximum([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([1, 20, 3, 40], [2, 2]);
|
* const input2 = tf.tensor2d([10, 2, 30, 4], [2, 2]);
|
* tf.layers.maximum([input1, input2]).print();
|
* // Gives [[10, 20], [30, 40]].
|
*
|
*/
|
export function maximum(config) {
|
if (Array.isArray(config)) {
|
const layer = new Maximum({});
|
return layer.apply(config);
|
}
|
else {
|
return new Maximum(config);
|
}
|
}
|
class Minimum extends Merge {
|
constructor(args) {
|
super(args);
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
let output = inputs[0];
|
for (let i = 1; i < inputs.length; ++i) {
|
output = tfc.minimum(output, inputs[i]);
|
}
|
return output;
|
});
|
}
|
}
|
/** @nocollapse */
|
Minimum.className = 'Minimum';
|
export { Minimum };
|
serialization.registerClass(Minimum);
|
/**
|
* Calculate the element-wise minimum of inputs, which all have the same shape.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Minimum` layer, by using no input argument
|
* or a single configuration argument. The resultant `Minimum` layer can then
|
* be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const minimumLayer = tf.layers.minimum();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = minimumLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 2]});
|
* const input2 = tf.input({shape: [2, 2]});
|
* const output = tf.layers.minimum([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([1, 20, 3, 40], [2, 2]);
|
* const input2 = tf.tensor2d([10, 2, 30, 4], [2, 2]);
|
* tf.layers.minimum([input1, input2]).print();
|
* // Gives [[1, 2], [3, 4]].
|
*
|
*/
|
export function minimum(config) {
|
if (Array.isArray(config)) {
|
const layer = new Minimum({});
|
return layer.apply(config);
|
}
|
else {
|
return new Minimum(config);
|
}
|
}
|
class Concatenate extends Merge {
|
constructor(args) {
|
super(args);
|
this.DEFAULT_AXIS = -1;
|
if (args == null) {
|
args = {};
|
}
|
this.axis = args.axis == null ? this.DEFAULT_AXIS : args.axis;
|
this.supportsMasking = true;
|
this.reshapeRequired = false;
|
}
|
build(inputShape) {
|
// Used purely for shape validation.]
|
if (!(Array.isArray(inputShape) && Array.isArray(inputShape[0])) ||
|
inputShape.length === 1) {
|
throw new ValueError('A `Concatenate` layer should be called on a list of at least 2 ' +
|
'inputs');
|
}
|
inputShape = inputShape;
|
let allNoneShape = true;
|
for (const shape of inputShape) {
|
if (shape != null) {
|
allNoneShape = false;
|
break;
|
}
|
}
|
if (allNoneShape) {
|
return;
|
}
|
const shapeSet = [];
|
for (let i = 0; i < inputShape.length; ++i) {
|
const shapeWithoutConcatAxis = inputShape[i].slice();
|
shapeWithoutConcatAxis.splice(this.axis, 1);
|
let exists = false;
|
for (const shape of shapeSet) {
|
if (util.arraysEqual(shape, shapeWithoutConcatAxis)) {
|
exists = true;
|
break;
|
}
|
}
|
if (!exists) {
|
shapeSet.push(shapeWithoutConcatAxis);
|
}
|
}
|
if (shapeSet.length > 1) {
|
throw new ValueError('A `Concatenate` layer requires inputs with matching shapes ' +
|
'except for the concat axis. Got input shapes: ' +
|
JSON.stringify(inputShape));
|
}
|
}
|
mergeFunction(inputs) {
|
return tidy(() => {
|
return K.concatenate(inputs, this.axis);
|
});
|
}
|
computeOutputShape(inputShape) {
|
if (!(Array.isArray(inputShape) && Array.isArray(inputShape[0]))) {
|
throw new ValueError('A `Concatenate` layer should be called on a list of inputs.');
|
}
|
const inputShapes = inputShape;
|
const outputShape = inputShapes[0].slice();
|
const axis = this.axis < 0 ? outputShape.length + this.axis : this.axis;
|
// Porting Note: the line above is because TypeScript doesn't support
|
// negative indices.
|
for (const shape of inputShapes.slice(1)) {
|
if (outputShape[axis] == null || shape[axis] == null) {
|
outputShape[axis] = null;
|
break;
|
}
|
outputShape[axis] += shape[axis];
|
}
|
return outputShape;
|
}
|
computeMask(inputs, mask) {
|
if (mask == null) {
|
return null;
|
}
|
if (!Array.isArray(mask)) {
|
throw new ValueError('`mask` should be an array for Concatenate');
|
}
|
if (!Array.isArray(inputs)) {
|
throw new ValueError('`inputs` should be an array for Concatenate');
|
}
|
if (mask.length !== inputs.length) {
|
throw new ValueError(`Mismatch in the length of mask (${mask.length}) ` +
|
`and the legnth of inputs (${inputs.length})`);
|
}
|
return tfc.tidy(() => {
|
let allNullMasks = true;
|
mask.forEach(m => {
|
if (m != null) {
|
allNullMasks = false;
|
return;
|
}
|
});
|
if (allNullMasks) {
|
return null;
|
}
|
const outputMasks = [];
|
for (let i = 0; i < inputs.length; ++i) {
|
if (mask[i] == null) {
|
// Input is unmasked. Append all 1's to masks.
|
outputMasks.push(tfc.cast(tfc.onesLike(inputs[i]), 'bool'));
|
}
|
else if (mask[i].rank < inputs[i].rank) {
|
// Mask is smaller than the input, expand it.
|
outputMasks.push(tfc.expandDims(mask[i], -1));
|
}
|
else {
|
outputMasks.push(mask[i]);
|
}
|
}
|
const concatenatedMasks = tfc.concat(outputMasks, this.axis);
|
return tfc.all(concatenatedMasks, -1, false);
|
});
|
}
|
getConfig() {
|
const config = {
|
'axis': this.axis,
|
};
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
/** @nocollapse */
|
Concatenate.className = 'Concatenate';
|
export { Concatenate };
|
serialization.registerClass(Concatenate);
|
/**
|
* Concatenate an `Array` of inputs.
|
*
|
* This function can be invoked in three ways.
|
*
|
* 1. Construct an instance of `Concatenate` layer, by using no input argument
|
* or a single configuration argument. The resultant `Concatenate` layer can
|
* then be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:
|
*
|
* ```js
|
* const concatLayer = tf.layers.concatenate();
|
*
|
* // The layer can be applied to inputs.
|
* const input1 = tf.input({shape: [2, 3]});
|
* const input2 = tf.input({shape: [2, 4]});
|
* const output = concatLayer.apply([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 7], with the first dimension as the undetermined batch
|
* // dimension and the last dimension as the result of concatenating the
|
* // last dimensions of the two inputs.
|
* ```
|
*
|
* 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.SymbolicTensor`. For example:
|
*
|
* ```js
|
* const input1 = tf.input({shape: [2, 3]});
|
* const input2 = tf.input({shape: [2, 4]});
|
* const output = tf.layers.concatenate([input1, input2]);
|
* console.log(output.shape);
|
* // You get [null, 2, 2], with the first dimension as the undetermined batch
|
* // dimension and the last dimension as the result of concatenating the
|
* // last dimensions of the two inputs.
|
* ```
|
*
|
* 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs
|
* an `Layer` object internally and calls its `apply` method on the inputs,
|
* generating a new `tf.Tensor` as the result of the computation. For
|
* example:
|
*
|
* ```js
|
* const input1 = tf.tensor2d([[1, 2], [3, 4]], [2, 2]);
|
* const input2 = tf.tensor2d([[10, 20], [30, 40]], [2, 2]);
|
* tf.layers.concatenate([input1, input2]).print();
|
* // Gives [[1, 2, 10, 20], [3, 4, 30, 40]].
|
*
|
*/
|
export function concatenate(config) {
|
if (Array.isArray(config)) {
|
const layer = new Concatenate({});
|
return layer.apply(config);
|
}
|
else {
|
return new Concatenate(config);
|
}
|
}
|
/**
|
* Interpretable potentially negative axis index.
|
*
|
* For example, given axis = -1, and dim = 3, this function will return 2.
|
*
|
* @param axis The axis index, may be a positive, zero or negative integer.
|
* @param dim Total number of dimensions, a positive integer.
|
* @returns A non-negative axis index equivalent to the input `axis`.
|
*/
|
function interpretAxis(axis, dim) {
|
while (axis < 0) {
|
axis += dim;
|
}
|
return axis;
|
}
|
function batchDot(x, y, axes) {
|
if (x.shape.length > 3 || y.shape.length > 3) {
|
throw new NotImplementedError('batchDot is not implemented for tensors of 4D or higher rank yet');
|
}
|
tfc.util.assert(x.shape.length >= 2, () => `batchDot requires the rank of x to be >= 2, ` +
|
`but got ${x.shape.length}`);
|
tfc.util.assert(x.shape.length >= 2, () => `batchDot requires the rank of y to be >= 2, ` +
|
`but got ${y.shape.length}`);
|
if (typeof axes === 'number') {
|
axes = [axes, axes];
|
}
|
if (x.dtype === 'complex64' || y.dtype === 'complex64') {
|
throw new NotImplementedError('batchDot is not implemented for complex64-type Tensors yet.');
|
}
|
const xNDim = x.shape.length;
|
const yNDim = y.shape.length;
|
if (axes == null) {
|
// Behave like batchMatmul by default.
|
axes = [xNDim - 1, yNDim - 2];
|
}
|
const axesArray = axes;
|
return tfc.tidy(() => {
|
let diff;
|
if (xNDim > yNDim) {
|
diff = xNDim - yNDim;
|
const diffShape = [];
|
for (let i = 0; i < diff; ++i) {
|
diffShape.push(1);
|
}
|
y = tfc.reshape(y, y.shape.concat(diffShape));
|
}
|
else if (yNDim > xNDim) {
|
diff = yNDim - xNDim;
|
const diffShape = [];
|
for (let i = 0; i < diff; ++i) {
|
diffShape.push(1);
|
}
|
x = tfc.reshape(x, x.shape.concat(diffShape));
|
}
|
else {
|
diff = 0;
|
}
|
let out;
|
if (x.shape.length === 2 && y.shape.length === 2) {
|
if (axesArray[0] === axesArray[1]) {
|
out = tfc.sum(tfc.mul(x, y), axesArray[0]);
|
}
|
else {
|
out = tfc.sum(tfc.mul(tfc.transpose(x, [1, 0]), y), axesArray[1]);
|
}
|
}
|
else {
|
const adjX = axesArray[0] !== x.shape.length - 1;
|
const adjY = axesArray[1] === y.shape.length - 1;
|
out = tfc.matMul(x, y, adjX, adjY);
|
}
|
if (diff > 0) {
|
let idx;
|
if (xNDim > yNDim) {
|
idx = xNDim + yNDim - 3;
|
}
|
else {
|
idx = xNDim - 1;
|
}
|
const squeezeAxes = [];
|
for (let i = idx; i < idx + diff; ++i) {
|
squeezeAxes.push(i);
|
}
|
out = tfc.squeeze(out, squeezeAxes);
|
}
|
if (out.shape.length === 1) {
|
out = tfc.expandDims(out, 1);
|
}
|
return out;
|
});
|
}
|
class Dot extends Merge {
|
constructor(args) {
|
super(args);
|
this.axes = args.axes;
|
this.normalize = args.normalize == null ? false : args.normalize;
|
this.supportsMasking = true;
|
this.reshapeRequired = false;
|
}
|
build(inputShape) {
|
tfc.util.assert(Array.isArray(inputShape) && inputShape.length === 2 &&
|
Array.isArray(inputShape[0]) && Array.isArray(inputShape[1]), () => 'A `Dot` layer should be called on a list of exactly 2 inputs.');
|
const shape1 = inputShape[0];
|
const shape2 = inputShape[1];
|
if (shape1.length > 3 || shape2.length > 3) {
|
throw new NotImplementedError('Dot layer does not support tensors of 4D or higher rank yet.');
|
}
|
const axes = this.interpretAxes(shape1, shape2);
|
if (shape1[axes[0]] !== shape2[axes[1]]) {
|
throw new ValueError(`Dimension incompatibility: ` +
|
`${shape1[axes[0]]} !== ${shape2[axes[1]]}`);
|
}
|
}
|
mergeFunction(inputs) {
|
if (inputs.length !== 2) {
|
throw new ValueError('A `Dot` layer must be called on exactly 2 inputs, ' +
|
`but received ${inputs.length} input(s).`);
|
}
|
let x1 = inputs[0];
|
let x2 = inputs[1];
|
let axes;
|
if (!Array.isArray(this.axes)) {
|
axes = [
|
interpretAxis(this.axes, x1.shape.length),
|
interpretAxis(this.axes, x2.shape.length)
|
];
|
}
|
else {
|
axes = this.axes.map((axis, i) => interpretAxis(axis, inputs[i].shape.length));
|
}
|
if (this.normalize) {
|
x1 = l2Normalize(x1, axes[0]);
|
x2 = l2Normalize(x2, axes[1]);
|
}
|
return batchDot(x1, x2, axes);
|
}
|
interpretAxes(shape1, shape2) {
|
let axes;
|
if (!Array.isArray(this.axes)) {
|
// `this.axes` is a single integer.
|
axes = [
|
interpretAxis(this.axes, shape1.length),
|
interpretAxis(this.axes, shape2.length)
|
];
|
}
|
else {
|
// `this.axes` is an Array of integers.
|
axes = this.axes;
|
}
|
return axes;
|
}
|
computeOutputShape(inputShape) {
|
tfc.util.assert(Array.isArray(inputShape) && inputShape.length === 2 &&
|
Array.isArray(inputShape[0]) && Array.isArray(inputShape[1]), () => 'A `Dot` layer should be called on a list of exactly 2 inputs.');
|
const shape1 = inputShape[0].slice();
|
const shape2 = inputShape[1].slice();
|
if (shape1.length > 3 || shape2.length > 3) {
|
throw new NotImplementedError('Dot layer does not support tensors of 4D or higher rank yet.');
|
}
|
const axes = this.interpretAxes(shape1, shape2);
|
shape1.splice(axes[0], 1);
|
shape2.splice(axes[1], 1);
|
shape2.splice(0, 1);
|
const outputShape = shape1.concat(shape2);
|
if (outputShape.length === 1) {
|
outputShape.push(1);
|
}
|
return outputShape;
|
}
|
computeMask(inputs, mask) {
|
return null;
|
}
|
getConfig() {
|
const config = {
|
'axes': this.axes,
|
'normalize': this.normalize
|
};
|
const baseConfig = super.getConfig();
|
Object.assign(config, baseConfig);
|
return config;
|
}
|
}
|
/** @nocollapse */
|
Dot.className = 'Dot';
|
export { Dot };
|
serialization.registerClass(Dot);
|
// TODO(cais): Add functional interfaces for the merge layers.
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"merge.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/layers/merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AAEH,OAAO,KAAK,GAAG,MAAM,uBAAuB,CAAC;AAC7C,OAAO,EAAC,aAAa,EAAU,IAAI,EAAE,IAAI,EAAC,MAAM,uBAAuB,CAAC;AACxE,OAAO,KAAK,CAAC,MAAM,yBAAyB,CAAC;AAC7C,OAAO,EAAC,KAAK,EAA4B,MAAM,oBAAoB,CAAC;AACpE,OAAO,EAAC,mBAAmB,EAAE,UAAU,EAAC,MAAM,WAAW,CAAC;AAE1D,OAAO,EAAC,WAAW,EAAC,MAAM,WAAW,CAAC;AAEtC,OAAO,KAAK,aAAa,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,SAAS,MAAM,qBAAqB,CAAC;AACjD,OAAO,EAAC,kBAAkB,EAAC,MAAM,sBAAsB,CAAC;AAExD;;;;GAIG;AACH,MAAM,OAAgB,KAAM,SAAQ,KAAK;IAGvC,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC;QAClB,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;IAC9B,CAAC;IAED;;;OAGG;IACO,aAAa,CAAC,MAAgB;QACtC,MAAM,IAAI,mBAAmB,EAAE,CAAC;IAClC,CAAC;IAED;;;;;;;;;OASG;IACK,+BAA+B,CAAC,MAAa,EAAE,MAAa;QAClE,IAAI,MAAM,IAAI,IAAI,IAAI,MAAM,IAAI,IAAI,EAAE;YACpC,OAAO,IAAI,CAAC;SACb;aAAM,IAAI,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE;YACxC,OAAO,IAAI,CAAC,+BAA+B,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;SAC7D;aAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YAC9B,OAAO,MAAM,CAAC;SACf;QACD,MAAM,WAAW,GAAU,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1E,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YACtC,MAAM,CAAC,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;YACpD,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACpB,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;gBAC5C,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;aACxB;iBAAM,IAAI,CAAC,KAAK,CAAC,EAAE;gBAClB,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACrB;iBAAM,IAAI,CAAC,KAAK,CAAC,EAAE;gBAClB,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACrB;iBAAM;gBACL,IAAI,CAAC,KAAK,CAAC,EAAE;oBACX,MAAM,IAAI,UAAU,CAChB,uDAAuD;wBACvD,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,GAAG,GAAG,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;iBAC5D;gBACD,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACrB;SACF;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEQ,KAAK,CAAC,UAAyB;QACtC,oCAAoC;QACpC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAAE;YAC9D,kDAAkD;YAClD,UAAU,GAAG,CAAC,kBAAkB,CAAC,UAAU,CAAC,CAAC,CAAC;SAC/C;QACD,UAAU,GAAG,UAAqB,CAAC;QACnC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,UAAU,CAChB,kEAAkE;gBAClE,QAAQ,UAAU,CAAC,MAAM,YAAY,CAAC,CAAC;SAC5C;QAED,wEAAwE;QACxE,UAAU;QACV,IAAI,UAAU,GAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE;YAC9B,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;gBACtC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3B;SACF;QACD,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC9C,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE;YACzB,MAAM,IAAI,UAAU,CAChB,oDAAoD;gBACpD,4BAA4B,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;SAChE;QAED,IAAI,WAAW,GACX,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC1D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YAC1C,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpE,WAAW,GAAG,IAAI,CAAC,+BAA+B,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;SACxE;QACD,2EAA2E;QAC3E,iBAAiB;QACjB,MAAM,QAAQ,GAAG,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACvD,IAAI,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC/B,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,KAAK,CAAC,EAAE;YAC/C,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;SAC9B;aAAM;YACL,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;SAC7B;IACH,CAAC;IAEQ,IAAI,CAAC,MAAuB,EAAE,MAAc;QACnD,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,MAAM,GAAG,MAAkB,CAAC;YAC5B,IAAI,IAAI,CAAC,eAAe,EAAE;gBACxB,MAAM,cAAc,GAAa,EAAE,CAAC;gBACpC,MAAM,SAAS,GAAG,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAClD,IAAI,SAAS,CAAC,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE;oBAClC,sEAAsE;oBACtE,kDAAkD;oBAClD,MAAM,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;oBACzC,KAAK,IAAI,CAAC,IAAI,MAAM,EAAE;wBACpB,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC;wBACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,GAAG,KAAK,EAAE,EAAE,CAAC,EAAE;4BACxC,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;yBACxB;wBACD,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;qBACxB;oBACD,OAAO,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;iBAC3C;qBAAM;oBACL,iEAAiE;oBACjE,+DAA+D;oBAC/D,IAAI,UAAU,GAAG,KAAK,CAAC;oBACvB,KAAK,MAAM,CAAC,IAAI,MAAM,EAAE;wBACtB,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC;wBACrB,IAAI,KAAK,IAAI,IAAI,EAAE;4BACjB,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;4BACvB,MAAM,SAAS,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;4BAC5B,MAAM,QAAQ,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC;4BACrD,IAAI,WAAW,GAAG,GAAG,CAAC,OAAO,CACzB,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BACjE,WAAW,GAAG,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;4BACjD,WAAW,GAAG,GAAG,CAAC,OAAO,CAAC,WAAW,EAAE,QAAQ,CAAC,CAAC;4BACjD,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;4BACjC,UAAU,GAAG,IAAI,CAAC;yBACnB;6BAAM,IAAI,KAAK,GAAG,CAAC,EAAE;4BACpB,MAAM,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;4BACnD,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;4BAC5C,UAAU,GAAG,IAAI,CAAC;yBACnB;6BAAM;4BACL,+DAA+D;4BAC/D,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;yBACxB;qBACF;oBACD,IAAI,CAAC,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;oBAC3C,MAAM,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC;oBACrB,IAAI,UAAU,EAAE;wBACd,kEAAkE;wBAClE,OAAO;wBACP,IAAI,KAAK,IAAI,IAAI,EAAE;4BACjB,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;4BACvB,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC;4BAC5B,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC;4BACpC,MAAM,QAAQ,GACV,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC;4BAC3D,CAAC,GAAG,GAAG,CAAC,OAAO,CACX,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EACtD,QAAQ,CAAC,CAAC;yBACf;6BAAM,IAAI,KAAK,GAAG,CAAC,EAAE;4BACpB,MAAM,IAAI,GAAG,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC,CAAC;4BAC/D,CAAC,GAAG,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;yBAC5B;qBACF;oBACD,OAAO,CAAC,CAAC;iBACV;aACF;iBAAM;gBACL,OAAO,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;aACnC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,kBAAkB,CAAC,UAAyB;QACnD,UAAU,GAAG,UAAqB,CAAC;QACnC,IAAI,WAAkB,CAAC;QACvB,IAAI,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;YACzB,WAAW,GAAG,IAAI,CAAC;SACpB;aAAM;YACL,WAAW,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;SACtC;QACD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YAC1C,MAAM,KAAK,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpE,WAAW,GAAG,IAAI,CAAC,+BAA+B,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;SACxE;QAED,IAAI,UAAU,GAAa,EAAE,CAAC;QAC9B,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE;YAC9B,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE;gBACtC,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;aAC3B;SACF;QACD,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC;QAC9C,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,WAAW,GAAG,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;SAC9C;aAAM;YACL,WAAW,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;SAC1C;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEQ,WAAW,CAAC,MAAuB,EAAE,IAAsB;QAElE,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE;YACnB,IAAI,IAAI,IAAI,IAAI,EAAE;gBAChB,OAAO,IAAI,CAAC;aACb;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;gBACxB,MAAM,IAAI,UAAU,CAAC,2BAA2B,CAAC,CAAC;aACnD;YACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;gBAC1B,MAAM,IAAI,UAAU,CAAC,6BAA6B,CAAC,CAAC;aACrD;YACD,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE;gBACjC,MAAM,IAAI,UAAU,CAChB,8DAA8D;oBAC9D,qCAAqC;oBACrC,IAAI,MAAM,CAAC,MAAM,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;aAC7C;YACD,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,EAAE;gBAC9B,OAAO,IAAI,CAAC;aACb;YACD,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;YAC3D,IAAI,MAAM,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YACrB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,EAAE,CAAC,EAAE;gBACxC,MAAM,GAAG,GAAG,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;aAC1C;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAa,GAAI,SAAQ,KAAK;IAG5B,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACrC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;;AAdD,kBAAkB;AACX,aAAS,GAAG,KAAK,CAAC;SAFd,GAAG;AAiBhB,aAAa,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;AAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,GAAG,CAAC,MAA4C;IAE9D,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,EAAE,CAAC,CAAC;QAC1B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC;KACxB;AACH,CAAC;AAED,MAAa,QAAS,SAAQ,KAAK;IAGjC,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACrC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;;AAdD,kBAAkB;AACX,kBAAS,GAAG,UAAU,CAAC;SAFnB,QAAQ;AAiBrB,aAAa,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;AAEtC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,QAAQ,CAAC,MAA4C;IAEnE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC/B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,QAAQ,CAAC,MAAM,CAAC,CAAC;KAC7B;AACH,CAAC;AAED,MAAa,OAAQ,SAAQ,KAAK;IAGhC,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACrC;YACD,OAAO,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAC5C,CAAC,CAAC,CAAC;IACL,CAAC;;AAdD,kBAAkB;AACX,iBAAS,GAAG,SAAS,CAAC;SAFlB,OAAO;AAiBpB,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,MAAM,UAAU,OAAO,CAAC,MAA4C;IAElE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,EAAE,CAAC,CAAC;QAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KAC5B;AACH,CAAC;AAED,MAAa,OAAQ,SAAQ,KAAK;IAGhC,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACzC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;;AAdD,kBAAkB;AACX,iBAAS,GAAG,SAAS,CAAC;SAFlB,OAAO;AAiBpB,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,OAAO,CAAC,MAA4C;IAElE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,EAAE,CAAC,CAAC;QAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KAC5B;AACH,CAAC;AAED,MAAa,OAAQ,SAAQ,KAAK;IAGhC,YAAY,IAAgB;QAC1B,KAAK,CAAC,IAAI,CAAC,CAAC;IACd,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,IAAI,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;YACvB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;aACzC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC,CAAC,CAAC;IACL,CAAC;;AAdD,kBAAkB;AACX,iBAAS,GAAG,SAAS,CAAC;SAFlB,OAAO;AAiBpB,aAAa,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC;AAErC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,MAAM,UAAU,OAAO,CAAC,MAA4C;IAElE,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,EAAE,CAAC,CAAC;QAC9B,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;KAC5B;AACH,CAAC;AASD,MAAa,WAAY,SAAQ,KAAK;IAMpC,YAAY,IAA2B;QACrC,KAAK,CAAC,IAAI,CAAC,CAAC;QAJL,iBAAY,GAAG,CAAC,CAAC,CAAC;QAKzB,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,IAAI,GAAG,EAAE,CAAC;SACX;QACD,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QAC9D,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAEQ,KAAK,CAAC,UAAyB;QACtC,qCAAqC;QACrC,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YAC5D,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,UAAU,CAChB,iEAAiE;gBACjE,QAAQ,CAAC,CAAC;SACf;QACD,UAAU,GAAG,UAAqB,CAAC;QAEnC,IAAI,YAAY,GAAG,IAAI,CAAC;QACxB,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE;YAC9B,IAAI,KAAK,IAAI,IAAI,EAAE;gBACjB,YAAY,GAAG,KAAK,CAAC;gBACrB,MAAM;aACP;SACF;QACD,IAAI,YAAY,EAAE;YAChB,OAAO;SACR;QAED,MAAM,QAAQ,GAAY,EAAE,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;YAC1C,MAAM,sBAAsB,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;YACrD,sBAAsB,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC;YAC5C,IAAI,MAAM,GAAG,KAAK,CAAC;YACnB,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE;gBAC5B,IAAI,IAAI,CAAC,WAAW,CAAC,KAAK,EAAE,sBAAsB,CAAC,EAAE;oBACnD,MAAM,GAAG,IAAI,CAAC;oBACd,MAAM;iBACP;aACF;YACD,IAAI,CAAC,MAAM,EAAE;gBACX,QAAQ,CAAC,IAAI,CAAC,sBAAsB,CAAC,CAAC;aACvC;SACF;QACD,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE;YACvB,MAAM,IAAI,UAAU,CAChB,6DAA6D;gBAC7D,gDAAgD;gBAChD,IAAI,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC,CAAC;SACjC;IACH,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,OAAO,IAAI,CAAC,GAAG,EAAE;YACf,OAAO,CAAC,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;QAC1C,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,kBAAkB,CAAC,UAAyB;QACnD,IAAI,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;YAChE,MAAM,IAAI,UAAU,CAChB,6DAA6D,CAAC,CAAC;SACpE;QACD,MAAM,WAAW,GAAG,UAAqB,CAAC;QAC1C,MAAM,WAAW,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,CAAC,WAAW,CAAC,MAAM,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACxE,qEAAqE;QACrE,sBAAsB;QACtB,KAAK,MAAM,KAAK,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE;YACxC,IAAI,WAAW,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,EAAE;gBACpD,WAAW,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;gBACzB,MAAM;aACP;YACD,WAAW,CAAC,IAAI,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC,CAAC;SAClC;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEQ,WAAW,CAAC,MAAuB,EAAE,IAAsB;QAElE,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,OAAO,IAAI,CAAC;SACb;QACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE;YACxB,MAAM,IAAI,UAAU,CAAC,2CAA2C,CAAC,CAAC;SACnE;QACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;YAC1B,MAAM,IAAI,UAAU,CAAC,6CAA6C,CAAC,CAAC;SACrE;QACD,IAAI,IAAI,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM,EAAE;YACjC,MAAM,IAAI,UAAU,CAChB,mCAAmC,IAAI,CAAC,MAAM,IAAI;gBAClD,6BAA6B,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;SACpD;QACD,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE;YACnB,IAAI,YAAY,GAAG,IAAI,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE;gBACf,IAAI,CAAC,IAAI,IAAI,EAAE;oBACb,YAAY,GAAG,KAAK,CAAC;oBACrB,OAAO;iBACR;YACH,CAAC,CAAC,CAAC;YACH,IAAI,YAAY,EAAE;gBAChB,OAAO,IAAI,CAAC;aACb;YACD,MAAM,WAAW,GAAa,EAAE,CAAC;YACjC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE;gBACtC,IAAI,IAAI,CAAC,CAAC,CAAC,IAAI,IAAI,EAAE;oBACnB,8CAA8C;oBAC9C,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;iBAC7D;qBAAM,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE;oBACxC,6CAA6C;oBAC7C,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC/C;qBAAM;oBACL,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;iBAC3B;aACF;YACD,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,CAAC,WAAW,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC;YAC7D,OAAO,GAAG,CAAC,GAAG,CAAC,iBAAiB,EAAE,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC;QAC/C,CAAC,CAAC,CAAC;IACL,CAAC;IAEQ,SAAS;QAChB,MAAM,MAAM,GAA6B;YACvC,MAAM,EAAE,IAAI,CAAC,IAAI;SAClB,CAAC;QACF,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;;AAxID,kBAAkB;AACX,qBAAS,GAAG,aAAa,AAAhB,CAAiB;SAFtB,WAAW;AA2IxB,aAAa,CAAC,aAAa,CAAC,WAAW,CAAC,CAAC;AAEzC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,WAAW,CAAC,MACoB;IAC9C,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE;QACzB,MAAM,KAAK,GAAG,IAAI,WAAW,CAAC,EAAE,CAAC,CAAC;QAClC,OAAO,KAAK,CAAC,KAAK,CAAC,MAAM,CAA4B,CAAC;KACvD;SAAM;QACL,OAAO,IAAI,WAAW,CAAC,MAAM,CAAC,CAAC;KAChC;AACH,CAAC;AAoBD;;;;;;;;GAQG;AACH,SAAS,aAAa,CAAC,IAAY,EAAE,GAAW;IAC9C,OAAO,IAAI,GAAG,CAAC,EAAE;QACf,IAAI,IAAI,GAAG,CAAC;KACb;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAS,QAAQ,CAAC,CAAS,EAAE,CAAS,EAAE,IAA6B;IACnE,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE;QAC5C,MAAM,IAAI,mBAAmB,CACzB,kEAAkE,CAAC,CAAC;KACzE;IACD,GAAG,CAAC,IAAI,CAAC,MAAM,CACX,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,EACnB,GAAG,EAAE,CAAC,8CAA8C;QAChD,WAAW,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IACrC,GAAG,CAAC,IAAI,CAAC,MAAM,CACX,CAAC,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,EACnB,GAAG,EAAE,CAAC,8CAA8C;QAChD,WAAW,CAAC,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC;IAErC,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE;QAC5B,IAAI,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;KACrB;IAED,IAAI,CAAC,CAAC,KAAK,KAAK,WAAW,IAAI,CAAC,CAAC,KAAK,KAAK,WAAW,EAAE;QACtD,MAAM,IAAI,mBAAmB,CACzB,6DAA6D,CAAC,CAAC;KACpE;IAED,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;IAC7B,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC;IAC7B,IAAI,IAAI,IAAI,IAAI,EAAE;QAChB,sCAAsC;QACtC,IAAI,GAAG,CAAC,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,CAAC,CAAC,CAAC;KAC/B;IACD,MAAM,SAAS,GAAG,IAAwB,CAAC;IAE3C,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,EAAE;QACnB,IAAI,IAAY,CAAC;QACjB,IAAI,KAAK,GAAG,KAAK,EAAE;YACjB,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;YACrB,MAAM,SAAS,GAAU,EAAE,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,EAAE;gBAC7B,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACnB;YACD,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;SAC/C;aAAM,IAAI,KAAK,GAAG,KAAK,EAAE;YACxB,IAAI,GAAG,KAAK,GAAG,KAAK,CAAC;YACrB,MAAM,SAAS,GAAU,EAAE,CAAC;YAC5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,EAAE,EAAE,CAAC,EAAE;gBAC7B,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACnB;YACD,CAAC,GAAG,GAAG,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC;SAC/C;aAAM;YACL,IAAI,GAAG,CAAC,CAAC;SACV;QAED,IAAI,GAAW,CAAC;QAChB,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YAChD,IAAI,SAAS,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE;gBACjC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;aAC5C;iBAAM;gBACL,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC;aACnE;SACF;aAAM;YACL,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YACjD,MAAM,IAAI,GAAG,SAAS,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC;YACjD,GAAG,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;SACpC;QAED,IAAI,IAAI,GAAG,CAAC,EAAE;YACZ,IAAI,GAAW,CAAC;YAChB,IAAI,KAAK,GAAG,KAAK,EAAE;gBACjB,GAAG,GAAG,KAAK,GAAG,KAAK,GAAG,CAAC,CAAC;aACzB;iBAAM;gBACL,GAAG,GAAG,KAAK,GAAG,CAAC,CAAC;aACjB;YACD,MAAM,WAAW,GAAa,EAAE,CAAC;YACjC,KAAK,IAAI,CAAC,GAAG,GAAG,EAAE,CAAC,GAAG,GAAG,GAAG,IAAI,EAAE,EAAE,CAAC,EAAE;gBACrC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;aACrB;YACD,GAAG,GAAG,GAAG,CAAC,OAAO,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;SACrC;QACD,IAAI,GAAG,CAAC,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE;YAC1B,GAAG,GAAG,GAAG,CAAC,UAAU,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;SAC9B;QACD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAa,GAAI,SAAQ,KAAK;IAO5B,YAAY,IAAkB;QAC5B,KAAK,CAAC,IAAI,CAAC,CAAC;QACZ,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC;QACjE,IAAI,CAAC,eAAe,GAAG,IAAI,CAAC;QAC5B,IAAI,CAAC,eAAe,GAAG,KAAK,CAAC;IAC/B,CAAC;IAEQ,KAAK,CAAC,UAAyB;QACtC,GAAG,CAAC,IAAI,CAAC,MAAM,CACX,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;YAChD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAChE,GAAG,EAAE,CAAC,+DAA+D,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAU,CAAC;QACtC,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAU,CAAC;QACtC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1C,MAAM,IAAI,mBAAmB,CACzB,8DAA8D,CAAC,CAAC;SACrE;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChD,IAAI,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE;YACvC,MAAM,IAAI,UAAU,CAChB,6BAA6B;gBAC7B,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;SAClD;IACH,CAAC;IAEkB,aAAa,CAAC,MAAgB;QAC/C,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE;YACvB,MAAM,IAAI,UAAU,CAChB,oDAAoD;gBACpD,gBAAgB,MAAM,CAAC,MAAM,YAAY,CAAC,CAAC;SAChD;QAED,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACnB,IAAI,EAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;QACnB,IAAI,IAAsB,CAAC;QAC3B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YAC7B,IAAI,GAAG;gBACL,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC;gBACzC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC;aAC1C,CAAC;SACH;aAAM;YACL,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CACT,CAAC,IAAI,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CACtB,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,MAAM,CAAC,CAAqB,CAAC;SACnE;QACD,IAAI,IAAI,CAAC,SAAS,EAAE;YAClB,EAAE,GAAG,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;YAC9B,EAAE,GAAG,WAAW,CAAC,EAAE,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;SAC/B;QACD,OAAO,QAAQ,CAAC,EAAE,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;IAChC,CAAC;IAEO,aAAa,CAAC,MAAa,EAAE,MAAa;QAChD,IAAI,IAAc,CAAC;QACnB,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE;YAC7B,mCAAmC;YACnC,IAAI,GAAG;gBACL,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC;gBACvC,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC;aACxC,CAAC;SACH;aAAM;YACL,uCAAuC;YACvC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;SAClB;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEQ,kBAAkB,CAAC,UAAyB;QACnD,GAAG,CAAC,IAAI,CAAC,MAAM,CACX,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;YAChD,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,EAChE,GAAG,EAAE,CAAC,+DAA+D,CAAC,CAAC;QAC3E,MAAM,MAAM,GAAI,UAAU,CAAC,CAAC,CAAW,CAAC,KAAK,EAAE,CAAC;QAChD,MAAM,MAAM,GAAI,UAAU,CAAC,CAAC,CAAW,CAAC,KAAK,EAAE,CAAC;QAChD,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE;YAC1C,MAAM,IAAI,mBAAmB,CACzB,8DAA8D,CAAC,CAAC;SACrE;QAED,MAAM,IAAI,GAAG,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAChD,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QACpB,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAC1C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE;YAC5B,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;SACrB;QACD,OAAO,WAAW,CAAC;IACrB,CAAC;IAEQ,WAAW,CAAC,MAAuB,EAAE,IAAsB;QAElE,OAAO,IAAI,CAAC;IACd,CAAC;IAEQ,SAAS;QAChB,MAAM,MAAM,GAA6B;YACvC,MAAM,EAAE,IAAI,CAAC,IAAI;YACjB,WAAW,EAAE,IAAI,CAAC,SAAS;SAC5B,CAAC;QACF,MAAM,UAAU,GAAG,KAAK,CAAC,SAAS,EAAE,CAAC;QACrC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAClC,OAAO,MAAM,CAAC;IAChB,CAAC;;AAhHD,kBAAkB;AACX,aAAS,GAAG,KAAK,CAAC;SAFd,GAAG;AAmHhB,aAAa,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;AAEjC,8DAA8D","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: Merge Layers.\n */\n\nimport * as tfc from '@tensorflow/tfjs-core';\nimport {serialization, Tensor, tidy, util} from '@tensorflow/tfjs-core';\nimport * as K from '../backend/tfjs_backend';\nimport {Layer, LayerArgs, SymbolicTensor} from '../engine/topology';\nimport {NotImplementedError, ValueError} from '../errors';\nimport {Shape} from '../keras_format/common';\nimport {l2Normalize} from '../losses';\nimport {Kwargs} from '../types';\nimport * as generic_utils from '../utils/generic_utils';\nimport * as mathUtils from '../utils/math_utils';\nimport {getExactlyOneShape} from '../utils/types_utils';\n\n/**\n * Generic Merge layer for element-wise merge functions.\n *\n * Used to implement `Sum`, `Average`, `Concatenate`, etc.\n */\nexport abstract class Merge extends Layer {\n  protected reshapeRequired: boolean;\n\n  constructor(args?: LayerArgs) {\n    super(args || {});\n    this.supportsMasking = true;\n  }\n\n  /**\n   * Logic for merging multiple tensors, to be overridden by subclasses.\n   * @param inputs\n   */\n  protected mergeFunction(inputs: Tensor[]): Tensor {\n    throw new NotImplementedError();\n  }\n\n  /**\n   * Computes the shape of the result of an elementwise operation.\n   *\n   * @param shape1: Shape of the first tensor.\n   * @param shape2: Shape of the second tensor.\n   * @returns Expected output shape when an elementwise operation is carried\n   *   out on 2 tensors with shapes `shape1` and `shape2`.\n   * @throws ValueError: If `shape1` and `shape2` are not compatible for\n   *   element-wise operations.\n   */\n  private computeElementwiseOpOutputShape(shape1: Shape, shape2: Shape): Shape {\n    if (shape1 == null || shape2 == null) {\n      return null;\n    } else if (shape1.length < shape2.length) {\n      return this.computeElementwiseOpOutputShape(shape2, shape1);\n    } else if (shape2.length === 0) {\n      return shape1;\n    }\n    const outputShape: Shape = shape1.slice(0, shape1.length - shape2.length);\n    for (let k = 0; k < shape2.length; ++k) {\n      const i = shape1[shape1.length - shape2.length + k];\n      const j = shape2[k];\n      if (i == null || j == null || i < 0 || j < 0) {\n        outputShape.push(null);\n      } else if (i === 1) {\n        outputShape.push(j);\n      } else if (j === 1) {\n        outputShape.push(i);\n      } else {\n        if (i !== j) {\n          throw new ValueError(\n              'Operands could not be broadcast together with shapes ' +\n              JSON.stringify(shape1) + ' ' + JSON.stringify(shape2));\n        }\n        outputShape.push(i);\n      }\n    }\n    return outputShape;\n  }\n\n  override build(inputShape: Shape|Shape[]): void {\n    // Used purely for shape validation.\n    if (Array.isArray(inputShape) && !Array.isArray(inputShape[0])) {\n      // Make sure that inputShape is an Array of shape.\n      inputShape = [getExactlyOneShape(inputShape)];\n    }\n    inputShape = inputShape as Shape[];\n    if (inputShape.length < 2) {\n      throw new ValueError(\n          'A merge layer should be called on an Array of at least 2 inputs.' +\n          ` Got ${inputShape.length} input(s).`);\n    }\n\n    // Make sure that there is at most one unique batch size among the input\n    // shapes.\n    let batchSizes: number[] = [];\n    for (const shape of inputShape) {\n      if (shape != null && shape[0] !== null) {\n        batchSizes.push(shape[0]);\n      }\n    }\n    batchSizes = generic_utils.unique(batchSizes);\n    if (batchSizes.length > 1) {\n      throw new ValueError(\n          `Can not merge tensors with different batch sizes. ` +\n          `Got tensors with shapes: ${JSON.stringify(inputShape)}.`);\n    }\n\n    let outputShape: Shape =\n        inputShape[0] == null ? null : inputShape[0].slice(1);\n    for (let i = 1; i < inputShape.length; ++i) {\n      const shape = inputShape[i] == null ? null : inputShape[i].slice(1);\n      outputShape = this.computeElementwiseOpOutputShape(outputShape, shape);\n    }\n    // If the inputs have different ranks, we have to reshape them to make them\n    // broadcastable.\n    const allRanks = inputShape.map(shape => shape.length);\n    if (inputShape.indexOf(null) === -1 &&\n        generic_utils.unique(allRanks).length === 1) {\n      this.reshapeRequired = false;\n    } else {\n      this.reshapeRequired = true;\n    }\n  }\n\n  override call(inputs: Tensor|Tensor[], kwargs: Kwargs): Tensor|Tensor[] {\n    return tidy(() => {\n      inputs = inputs as Tensor[];\n      if (this.reshapeRequired) {\n        const reshapedInputs: Tensor[] = [];\n        const inputDims = inputs.map(input => input.rank);\n        if (inputDims.indexOf(null) === -1) {\n          // If ranks of all inputs are available, we simply expand each of them\n          // at axis=1 until all of them have the same rank.\n          const maxNDim = mathUtils.max(inputDims);\n          for (let x of inputs) {\n            const xNDim = x.rank;\n            for (let k = 0; k < maxNDim - xNDim; ++k) {\n              x = K.expandDims(x, 1);\n            }\n            reshapedInputs.push(x);\n          }\n          return this.mergeFunction(reshapedInputs);\n        } else {\n          // Transpose all inputs so that batch size is the last dimension.\n          // [batchSize, dim1, dim2, ...] -> [dim1, dim2, ..., batchSize]\n          let transposed = false;\n          for (const x of inputs) {\n            const xNDim = x.rank;\n            if (xNDim == null) {\n              const xShape = x.shape;\n              const batchSize = xShape[0];\n              const newShape = xShape.slice(1).concat([batchSize]);\n              let xTransposed = tfc.reshape(\n                  x, [batchSize].concat(mathUtils.arrayProd(xShape.slice(1))));\n              xTransposed = tfc.transpose(xTransposed, [1, 0]);\n              xTransposed = tfc.reshape(xTransposed, newShape);\n              reshapedInputs.push(xTransposed);\n              transposed = true;\n            } else if (xNDim > 1) {\n              const dims = mathUtils.range(1, xNDim).concat([0]);\n              reshapedInputs.push(tfc.transpose(x, dims));\n              transposed = true;\n            } else {\n              // We don't transpose inputs if they are 1D vectors or scalars.\n              reshapedInputs.push(x);\n            }\n          }\n          let y = this.mergeFunction(reshapedInputs);\n          const yNDim = y.rank;\n          if (transposed) {\n            // If inputs have been transposed, we have to transpose the output\n            // too.\n            if (yNDim == null) {\n              const yShape = y.shape;\n              const yNDim = yShape.length;\n              const batchSize = yShape[yNDim - 1];\n              const newShape =\n                  [batchSize].concat(yShape.slice(0, yShape.length - 1));\n              y = tfc.reshape(\n                  tfc.transpose(tfc.reshape(y, [-1, batchSize]), [1, 0]),\n                  newShape);\n            } else if (yNDim > 1) {\n              const dims = [yNDim - 1].concat(mathUtils.range(0, yNDim - 1));\n              y = tfc.transpose(y, dims);\n            }\n          }\n          return y;\n        }\n      } else {\n        return this.mergeFunction(inputs);\n      }\n    });\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    inputShape = inputShape as Shape[];\n    let outputShape: Shape;\n    if (inputShape[0] == null) {\n      outputShape = null;\n    } else {\n      outputShape = inputShape[0].slice(1);\n    }\n    for (let i = 1; i < inputShape.length; ++i) {\n      const shape = inputShape[i] == null ? null : inputShape[i].slice(1);\n      outputShape = this.computeElementwiseOpOutputShape(outputShape, shape);\n    }\n\n    let batchSizes: number[] = [];\n    for (const shape of inputShape) {\n      if (shape != null && shape[0] !== null) {\n        batchSizes.push(shape[0]);\n      }\n    }\n    batchSizes = generic_utils.unique(batchSizes);\n    if (batchSizes.length === 1) {\n      outputShape = batchSizes.concat(outputShape);\n    } else {\n      outputShape = [null].concat(outputShape);\n    }\n    return outputShape;\n  }\n\n  override computeMask(inputs: Tensor|Tensor[], mask?: Tensor|Tensor[]):\n      Tensor {\n    return tfc.tidy(() => {\n      if (mask == null) {\n        return null;\n      }\n      if (!Array.isArray(mask)) {\n        throw new ValueError('`mask` should be an Array');\n      }\n      if (!Array.isArray(inputs)) {\n        throw new ValueError('`inputs` should be an Array');\n      }\n      if (mask.length !== inputs.length) {\n        throw new ValueError(\n            `The Array 'inputs' and 'mask' are expected to have the same ` +\n            `length, but have different lengths ` +\n            `(${inputs.length} vs ${mask.length})`);\n      }\n      if (mask.every(m => m == null)) {\n        return null;\n      }\n      mask = mask.map(m => m == null ? m : tfc.expandDims(m, 0));\n      let output = mask[0];\n      for (let i = 1; i < mask.length - 1; ++i) {\n        output = tfc.logicalAnd(output, mask[i]);\n      }\n      return output;\n    });\n  }\n}\n\nexport class Add extends Merge {\n  /** @nocollapse */\n  static className = 'Add';\n  constructor(args?: LayerArgs) {\n    super(args);\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      let output = inputs[0].clone();\n      for (let i = 1; i < inputs.length; ++i) {\n        output = tfc.add(output, inputs[i]);\n      }\n      return output;\n    });\n  }\n}\nserialization.registerClass(Add);\n\n/**\n * Calculate the element-wise sum of inputs, which all have the same shape.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Add` layer, by using no input argument\n *    or a single configuration argument. The resultant `Add` layer can then\n *    be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const addLayer = tf.layers.add();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = addLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = tf.layers.add([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);\n * const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);\n * tf.layers.add([input1, input2]).print();\n * // Gives [[11, 22], [33, 44]].\n *\n */\nexport function add(config?: SymbolicTensor[]|Tensor[]|LayerArgs): Layer|\n    SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Add({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Add(config);\n  }\n}\n\nexport class Multiply extends Merge {\n  /** @nocollapse */\n  static className = 'Multiply';\n  constructor(args?: LayerArgs) {\n    super(args);\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      let output = inputs[0].clone();\n      for (let i = 1; i < inputs.length; ++i) {\n        output = tfc.mul(output, inputs[i]);\n      }\n      return output;\n    });\n  }\n}\nserialization.registerClass(Multiply);\n\n/**\n * Calculate the element-wise product of inputs, which all have the same shape.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Multiply` layer, by using no input argument\n *    or a single configuration argument. The resultant `Multiply` layer can\n *    then be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const multiplyLayer = tf.layers.multiply();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = multiplyLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = tf.layers.multiply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);\n * const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);\n * tf.layers.multiply([input1, input2]).print();\n * // Gives [[10, 40], [90, 160]].\n *\n */\nexport function multiply(config?: SymbolicTensor[]|Tensor[]|LayerArgs): Layer|\n    SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Multiply({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Multiply(config);\n  }\n}\n\nexport class Average extends Merge {\n  /** @nocollapse */\n  static className = 'Average';\n  constructor(args?: LayerArgs) {\n    super(args);\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      let output = inputs[0].clone();\n      for (let i = 1; i < inputs.length; ++i) {\n        output = tfc.add(output, inputs[i]);\n      }\n      return tfc.mul(1 / inputs.length, output);\n    });\n  }\n}\nserialization.registerClass(Average);\n\n/**\n * Calculate the element-wise arithmetic mean of inputs, which all have the same\n * shape.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Average` layer, by using no input argument\n *    or a single configuration argument. The resultant `Average` layer can then\n *    be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const averageLayer = tf.layers.average();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = averageLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = tf.layers.average([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([1, 2, 3, 4], [2, 2]);\n * const input2 = tf.tensor2d([10, 20, 30, 40], [2, 2]);\n * tf.layers.average([input1, input2]).print();\n * // Gives [[5.5, 11], [16.5, 22]].\n *\n */\nexport function average(config?: SymbolicTensor[]|Tensor[]|LayerArgs): Layer|\n    SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Average({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Average(config);\n  }\n}\n\nexport class Maximum extends Merge {\n  /** @nocollapse */\n  static className = 'Maximum';\n  constructor(args?: LayerArgs) {\n    super(args);\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      let output = inputs[0];\n      for (let i = 1; i < inputs.length; ++i) {\n        output = tfc.maximum(output, inputs[i]);\n      }\n      return output;\n    });\n  }\n}\nserialization.registerClass(Maximum);\n\n/**\n * Calculate the element-wise maximum of inputs, which all have the same shape.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Maximum` layer, by using no input argument\n *    or a single configuration argument. The resultant `Maximum` layer can then\n *    be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const maximumLayer = tf.layers.maximum();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = maximumLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = tf.layers.maximum([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([1, 20, 3, 40], [2, 2]);\n * const input2 = tf.tensor2d([10, 2, 30, 4], [2, 2]);\n * tf.layers.maximum([input1, input2]).print();\n * // Gives [[10, 20], [30, 40]].\n *\n */\nexport function maximum(config?: SymbolicTensor[]|Tensor[]|LayerArgs): Layer|\n    SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Maximum({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Maximum(config);\n  }\n}\n\nexport class Minimum extends Merge {\n  /** @nocollapse */\n  static className = 'Minimum';\n  constructor(args?: LayerArgs) {\n    super(args);\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      let output = inputs[0];\n      for (let i = 1; i < inputs.length; ++i) {\n        output = tfc.minimum(output, inputs[i]);\n      }\n      return output;\n    });\n  }\n}\nserialization.registerClass(Minimum);\n\n/**\n * Calculate the element-wise minimum of inputs, which all have the same shape.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Minimum` layer, by using no input argument\n *    or a single configuration argument. The resultant `Minimum` layer can then\n *    be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const minimumLayer = tf.layers.minimum();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = minimumLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 2]});\n * const input2 = tf.input({shape: [2, 2]});\n * const output = tf.layers.minimum([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([1, 20, 3, 40], [2, 2]);\n * const input2 = tf.tensor2d([10, 2, 30, 4], [2, 2]);\n * tf.layers.minimum([input1, input2]).print();\n * // Gives [[1, 2], [3, 4]].\n *\n */\nexport function minimum(config?: SymbolicTensor[]|Tensor[]|LayerArgs): Layer|\n    SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Minimum({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Minimum(config);\n  }\n}\n\nexport declare interface ConcatenateLayerArgs extends LayerArgs {\n  /**\n   * Axis along which to concatenate.\n   */\n  axis?: number;\n}\n\nexport class Concatenate extends Merge {\n  /** @nocollapse */\n  static className = 'Concatenate';\n  readonly DEFAULT_AXIS = -1;\n  private readonly axis: number;\n\n  constructor(args?: ConcatenateLayerArgs) {\n    super(args);\n    if (args == null) {\n      args = {};\n    }\n    this.axis = args.axis == null ? this.DEFAULT_AXIS : args.axis;\n    this.supportsMasking = true;\n    this.reshapeRequired = false;\n  }\n\n  override build(inputShape: Shape|Shape[]): void {\n    // Used purely for shape validation.]\n    if (!(Array.isArray(inputShape) && Array.isArray(inputShape[0])) ||\n        inputShape.length === 1) {\n      throw new ValueError(\n          'A `Concatenate` layer should be called on a list of at least 2 ' +\n          'inputs');\n    }\n    inputShape = inputShape as Shape[];\n\n    let allNoneShape = true;\n    for (const shape of inputShape) {\n      if (shape != null) {\n        allNoneShape = false;\n        break;\n      }\n    }\n    if (allNoneShape) {\n      return;\n    }\n\n    const shapeSet: Shape[] = [];\n    for (let i = 0; i < inputShape.length; ++i) {\n      const shapeWithoutConcatAxis = inputShape[i].slice();\n      shapeWithoutConcatAxis.splice(this.axis, 1);\n      let exists = false;\n      for (const shape of shapeSet) {\n        if (util.arraysEqual(shape, shapeWithoutConcatAxis)) {\n          exists = true;\n          break;\n        }\n      }\n      if (!exists) {\n        shapeSet.push(shapeWithoutConcatAxis);\n      }\n    }\n    if (shapeSet.length > 1) {\n      throw new ValueError(\n          'A `Concatenate` layer requires inputs with matching shapes ' +\n          'except for the concat axis. Got input shapes: ' +\n          JSON.stringify(inputShape));\n    }\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    return tidy(() => {\n      return K.concatenate(inputs, this.axis);\n    });\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    if (!(Array.isArray(inputShape) && Array.isArray(inputShape[0]))) {\n      throw new ValueError(\n          'A `Concatenate` layer should be called on a list of inputs.');\n    }\n    const inputShapes = inputShape as Shape[];\n    const outputShape = inputShapes[0].slice();\n    const axis = this.axis < 0 ? outputShape.length + this.axis : this.axis;\n    // Porting Note: the line above is because TypeScript doesn't support\n    //   negative indices.\n    for (const shape of inputShapes.slice(1)) {\n      if (outputShape[axis] == null || shape[axis] == null) {\n        outputShape[axis] = null;\n        break;\n      }\n      outputShape[axis] += shape[axis];\n    }\n    return outputShape;\n  }\n\n  override computeMask(inputs: Tensor|Tensor[], mask?: Tensor|Tensor[]):\n      Tensor {\n    if (mask == null) {\n      return null;\n    }\n    if (!Array.isArray(mask)) {\n      throw new ValueError('`mask` should be an array for Concatenate');\n    }\n    if (!Array.isArray(inputs)) {\n      throw new ValueError('`inputs` should be an array for Concatenate');\n    }\n    if (mask.length !== inputs.length) {\n      throw new ValueError(\n          `Mismatch in the length of mask (${mask.length}) ` +\n          `and the legnth of inputs (${inputs.length})`);\n    }\n    return tfc.tidy(() => {\n      let allNullMasks = true;\n      mask.forEach(m => {\n        if (m != null) {\n          allNullMasks = false;\n          return;\n        }\n      });\n      if (allNullMasks) {\n        return null;\n      }\n      const outputMasks: Tensor[] = [];\n      for (let i = 0; i < inputs.length; ++i) {\n        if (mask[i] == null) {\n          // Input is unmasked. Append all 1's to masks.\n          outputMasks.push(tfc.cast(tfc.onesLike(inputs[i]), 'bool'));\n        } else if (mask[i].rank < inputs[i].rank) {\n          // Mask is smaller than the input, expand it.\n          outputMasks.push(tfc.expandDims(mask[i], -1));\n        } else {\n          outputMasks.push(mask[i]);\n        }\n      }\n      const concatenatedMasks = tfc.concat(outputMasks, this.axis);\n      return tfc.all(concatenatedMasks, -1, false);\n    });\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {\n      'axis': this.axis,\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(Concatenate);\n\n/**\n * Concatenate an `Array` of inputs.\n *\n * This function can be invoked in three ways.\n *\n * 1. Construct an instance of `Concatenate` layer, by using no input argument\n *    or a single configuration argument. The resultant `Concatenate` layer can\n *    then be used on `tf.SymbolicTensor`s or `tf.Tensor`s. For example:\n *\n * ```js\n * const concatLayer = tf.layers.concatenate();\n *\n * // The layer can be applied to inputs.\n * const input1 = tf.input({shape: [2, 3]});\n * const input2 = tf.input({shape: [2, 4]});\n * const output = concatLayer.apply([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 7], with the first dimension as the undetermined batch\n * // dimension and the last dimension as the result of concatenating the\n * // last dimensions of the two inputs.\n * ```\n *\n * 2. Invoke directly on an `Array` of `tf.SymbolicTensor`s. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.SymbolicTensor`. For example:\n *\n * ```js\n * const input1 = tf.input({shape: [2, 3]});\n * const input2 = tf.input({shape: [2, 4]});\n * const output = tf.layers.concatenate([input1, input2]);\n * console.log(output.shape);\n * // You get [null, 2, 2], with the first dimension as the undetermined batch\n * // dimension and the last dimension as the result of concatenating the\n * // last dimensions of the two inputs.\n * ```\n *\n * 3. Invoke directly on `tf.Tensor`s, i.e., concrete values. This constructs\n *    an `Layer` object internally and calls its `apply` method on the inputs,\n *    generating a new `tf.Tensor` as the result of the computation. For\n * example:\n *\n * ```js\n * const input1 = tf.tensor2d([[1, 2], [3, 4]], [2, 2]);\n * const input2 = tf.tensor2d([[10, 20], [30, 40]], [2, 2]);\n * tf.layers.concatenate([input1, input2]).print();\n * // Gives [[1, 2, 10, 20], [3, 4, 30, 40]].\n *\n */\nexport function concatenate(config?: SymbolicTensor[]|Tensor[]|\n                            ConcatenateLayerArgs): Layer|SymbolicTensor|Tensor {\n  if (Array.isArray(config)) {\n    const layer = new Concatenate({});\n    return layer.apply(config) as SymbolicTensor | Tensor;\n  } else {\n    return new Concatenate(config);\n  }\n}\n\nexport declare interface DotLayerArgs extends LayerArgs {\n  /**\n   * Axis or axes along which the dot product will be taken.\n   *\n   * Integer or an Array of integers.\n   */\n  axes: number|[number, number];\n\n  /**\n   * Whether to L2-normalize samples along the dot product axis\n   * before taking the dot product.\n   *\n   * If set to `true`, the output of the dot product is the cosine\n   * proximity between the two samples.\n   */\n  normalize?: boolean;\n}\n\n/**\n * Interpretable potentially negative axis index.\n *\n * For example, given axis = -1, and dim = 3, this function will return 2.\n *\n * @param axis The axis index, may be a positive, zero or negative integer.\n * @param dim Total number of dimensions, a positive integer.\n * @returns A non-negative axis index equivalent to the input `axis`.\n */\nfunction interpretAxis(axis: number, dim: number): number {\n  while (axis < 0) {\n    axis += dim;\n  }\n  return axis;\n}\n\nfunction batchDot(x: Tensor, y: Tensor, axes: number|[number, number]): Tensor {\n  if (x.shape.length > 3 || y.shape.length > 3) {\n    throw new NotImplementedError(\n        'batchDot is not implemented for tensors of 4D or higher rank yet');\n  }\n  tfc.util.assert(\n      x.shape.length >= 2,\n      () => `batchDot requires the rank of x to be >= 2, ` +\n          `but got ${x.shape.length}`);\n  tfc.util.assert(\n      x.shape.length >= 2,\n      () => `batchDot requires the rank of y to be >= 2, ` +\n          `but got ${y.shape.length}`);\n\n  if (typeof axes === 'number') {\n    axes = [axes, axes];\n  }\n\n  if (x.dtype === 'complex64' || y.dtype === 'complex64') {\n    throw new NotImplementedError(\n        'batchDot is not implemented for complex64-type Tensors yet.');\n  }\n\n  const xNDim = x.shape.length;\n  const yNDim = y.shape.length;\n  if (axes == null) {\n    // Behave like batchMatmul by default.\n    axes = [xNDim - 1, yNDim - 2];\n  }\n  const axesArray = axes as [number, number];\n\n  return tfc.tidy(() => {\n    let diff: number;\n    if (xNDim > yNDim) {\n      diff = xNDim - yNDim;\n      const diffShape: Shape = [];\n      for (let i = 0; i < diff; ++i) {\n        diffShape.push(1);\n      }\n      y = tfc.reshape(y, y.shape.concat(diffShape));\n    } else if (yNDim > xNDim) {\n      diff = yNDim - xNDim;\n      const diffShape: Shape = [];\n      for (let i = 0; i < diff; ++i) {\n        diffShape.push(1);\n      }\n      x = tfc.reshape(x, x.shape.concat(diffShape));\n    } else {\n      diff = 0;\n    }\n\n    let out: Tensor;\n    if (x.shape.length === 2 && y.shape.length === 2) {\n      if (axesArray[0] === axesArray[1]) {\n        out = tfc.sum(tfc.mul(x, y), axesArray[0]);\n      } else {\n        out = tfc.sum(tfc.mul(tfc.transpose(x, [1, 0]), y), axesArray[1]);\n      }\n    } else {\n      const adjX = axesArray[0] !== x.shape.length - 1;\n      const adjY = axesArray[1] === y.shape.length - 1;\n      out = tfc.matMul(x, y, adjX, adjY);\n    }\n\n    if (diff > 0) {\n      let idx: number;\n      if (xNDim > yNDim) {\n        idx = xNDim + yNDim - 3;\n      } else {\n        idx = xNDim - 1;\n      }\n      const squeezeAxes: number[] = [];\n      for (let i = idx; i < idx + diff; ++i) {\n        squeezeAxes.push(i);\n      }\n      out = tfc.squeeze(out, squeezeAxes);\n    }\n    if (out.shape.length === 1) {\n      out = tfc.expandDims(out, 1);\n    }\n    return out;\n  });\n}\n\nexport class Dot extends Merge {\n  /** @nocollapse */\n  static className = 'Dot';\n\n  private axes: number|[number, number];\n  private normalize: boolean;\n\n  constructor(args: DotLayerArgs) {\n    super(args);\n    this.axes = args.axes;\n    this.normalize = args.normalize == null ? false : args.normalize;\n    this.supportsMasking = true;\n    this.reshapeRequired = false;\n  }\n\n  override build(inputShape: Shape|Shape[]): void {\n    tfc.util.assert(\n        Array.isArray(inputShape) && inputShape.length === 2 &&\n            Array.isArray(inputShape[0]) && Array.isArray(inputShape[1]),\n        () => 'A `Dot` layer should be called on a list of exactly 2 inputs.');\n    const shape1 = inputShape[0] as Shape;\n    const shape2 = inputShape[1] as Shape;\n    if (shape1.length > 3 || shape2.length > 3) {\n      throw new NotImplementedError(\n          'Dot layer does not support tensors of 4D or higher rank yet.');\n    }\n\n    const axes = this.interpretAxes(shape1, shape2);\n    if (shape1[axes[0]] !== shape2[axes[1]]) {\n      throw new ValueError(\n          `Dimension incompatibility: ` +\n          `${shape1[axes[0]]} !== ${shape2[axes[1]]}`);\n    }\n  }\n\n  protected override mergeFunction(inputs: Tensor[]): Tensor {\n    if (inputs.length !== 2) {\n      throw new ValueError(\n          'A `Dot` layer must be called on exactly 2 inputs, ' +\n          `but received ${inputs.length} input(s).`);\n    }\n\n    let x1 = inputs[0];\n    let x2 = inputs[1];\n    let axes: [number, number];\n    if (!Array.isArray(this.axes)) {\n      axes = [\n        interpretAxis(this.axes, x1.shape.length),\n        interpretAxis(this.axes, x2.shape.length)\n      ];\n    } else {\n      axes = this.axes.map(\n                 (axis, i) => interpretAxis(\n                     axis, inputs[i].shape.length)) as [number, number];\n    }\n    if (this.normalize) {\n      x1 = l2Normalize(x1, axes[0]);\n      x2 = l2Normalize(x2, axes[1]);\n    }\n    return batchDot(x1, x2, axes);\n  }\n\n  private interpretAxes(shape1: Shape, shape2: Shape): number[] {\n    let axes: number[];\n    if (!Array.isArray(this.axes)) {\n      // `this.axes` is a single integer.\n      axes = [\n        interpretAxis(this.axes, shape1.length),\n        interpretAxis(this.axes, shape2.length)\n      ];\n    } else {\n      // `this.axes` is an Array of integers.\n      axes = this.axes;\n    }\n    return axes;\n  }\n\n  override computeOutputShape(inputShape: Shape|Shape[]): Shape|Shape[] {\n    tfc.util.assert(\n        Array.isArray(inputShape) && inputShape.length === 2 &&\n            Array.isArray(inputShape[0]) && Array.isArray(inputShape[1]),\n        () => 'A `Dot` layer should be called on a list of exactly 2 inputs.');\n    const shape1 = (inputShape[0] as Shape).slice();\n    const shape2 = (inputShape[1] as Shape).slice();\n    if (shape1.length > 3 || shape2.length > 3) {\n      throw new NotImplementedError(\n          'Dot layer does not support tensors of 4D or higher rank yet.');\n    }\n\n    const axes = this.interpretAxes(shape1, shape2);\n    shape1.splice(axes[0], 1);\n    shape2.splice(axes[1], 1);\n    shape2.splice(0, 1);\n    const outputShape = shape1.concat(shape2);\n    if (outputShape.length === 1) {\n      outputShape.push(1);\n    }\n    return outputShape;\n  }\n\n  override computeMask(inputs: Tensor|Tensor[], mask?: Tensor|Tensor[]):\n      Tensor {\n    return null;\n  }\n\n  override getConfig(): serialization.ConfigDict {\n    const config: serialization.ConfigDict = {\n      'axes': this.axes,\n      'normalize': this.normalize\n    };\n    const baseConfig = super.getConfig();\n    Object.assign(config, baseConfig);\n    return config;\n  }\n}\nserialization.registerClass(Dot);\n\n// TODO(cais): Add functional interfaces for the merge layers.\n"]}
|
