/**
|
* @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.
|
* =============================================================================
|
*/
|
/* Original source: utils/generic_utils.py */
|
import { util } from '@tensorflow/tfjs-core';
|
import { AssertionError, ValueError } from '../errors';
|
// tslint:enable
|
/**
|
* If `value` is an Array, equivalent to Python's `value * numValues`.
|
* If `value` is not an Array, equivalent to Python's `[value] * numValues`
|
*/
|
// tslint:disable-next-line:no-any
|
export function pyListRepeat(value, numValues) {
|
if (Array.isArray(value)) {
|
// tslint:disable-next-line:no-any
|
let newArray = [];
|
for (let i = 0; i < numValues; i++) {
|
newArray = newArray.concat(value);
|
}
|
return newArray;
|
}
|
else {
|
const newArray = new Array(numValues);
|
newArray.fill(value);
|
return newArray;
|
}
|
}
|
export function assert(val, message) {
|
if (!val) {
|
throw new AssertionError(message);
|
}
|
}
|
/**
|
* Count the number of elements of the `array` that are equal to `reference`.
|
*/
|
export function count(array, refernce) {
|
let counter = 0;
|
for (const item of array) {
|
if (item === refernce) {
|
counter++;
|
}
|
}
|
return counter;
|
}
|
/**
|
* If an array is of length 1, just return the first element. Otherwise, return
|
* the full array.
|
* @param tensors
|
*/
|
export function singletonOrArray(xs) {
|
if (xs.length === 1) {
|
return xs[0];
|
}
|
return xs;
|
}
|
/**
|
* Normalizes a list/tensor into a list.
|
*
|
* If a tensor is passed, we return
|
* a list of size 1 containing the tensor.
|
*
|
* @param x target object to be normalized.
|
*/
|
// tslint:disable-next-line:no-any
|
export function toList(x) {
|
if (Array.isArray(x)) {
|
return x;
|
}
|
return [x];
|
}
|
/**
|
* Generate a UID for a list
|
*/
|
// tslint:disable-next-line:no-any
|
export function objectListUid(objs) {
|
const objectList = toList(objs);
|
let retVal = '';
|
for (const obj of objectList) {
|
if (obj.id == null) {
|
throw new ValueError(`Object ${obj} passed to objectListUid without an id`);
|
}
|
if (retVal !== '') {
|
retVal = retVal + ', ';
|
}
|
retVal = `${retVal}${Math.abs(obj.id)}`;
|
}
|
return retVal;
|
}
|
/**
|
* Converts string to snake-case.
|
* @param name
|
*/
|
export function toSnakeCase(name) {
|
const intermediate = name.replace(/(.)([A-Z][a-z0-9]+)/g, '$1_$2');
|
const insecure = intermediate.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
|
/*
|
If the class is private the name starts with "_" which is not secure
|
for creating scopes. We prefix the name with "private" in this case.
|
*/
|
if (insecure[0] !== '_') {
|
return insecure;
|
}
|
return 'private' + insecure;
|
}
|
export function toCamelCase(identifier) {
|
// quick return for empty string or single character strings
|
if (identifier.length <= 1) {
|
return identifier;
|
}
|
// Check for the underscore indicating snake_case
|
if (identifier.indexOf('_') === -1) {
|
return identifier;
|
}
|
return identifier.replace(/[_]+(\w|$)/g, (m, p1) => p1.toUpperCase());
|
}
|
// tslint:disable-next-line:no-any
|
let _GLOBAL_CUSTOM_OBJECTS = {};
|
export function serializeKerasObject(instance) {
|
if (instance === null || instance === undefined) {
|
return null;
|
}
|
const dict = {};
|
dict['className'] = instance.getClassName();
|
dict['config'] = instance.getConfig();
|
return dict;
|
}
|
/**
|
* Replace ndarray-style scalar objects in serialization objects with numbers.
|
*
|
* Background: In some versions of tf.keras, certain scalar values in the HDF5
|
* model save file can be serialized as: `{'type': 'ndarray', 'value': num}`,
|
* where in `num` is a plain number. This method converts such serialization
|
* to a `number`.
|
*
|
* @param config The keras-format serialization object to be processed
|
* (in place).
|
*/
|
function convertNDArrayScalarsInConfig(config) {
|
if (config == null || typeof config !== 'object') {
|
return;
|
}
|
else if (Array.isArray(config)) {
|
config.forEach(configItem => convertNDArrayScalarsInConfig(configItem));
|
}
|
else {
|
const fields = Object.keys(config);
|
for (const field of fields) {
|
const value = config[field];
|
if (value != null && typeof value === 'object') {
|
if (!Array.isArray(value) && value['type'] === 'ndarray' &&
|
typeof value['value'] === 'number') {
|
config[field] = value['value'];
|
}
|
else {
|
convertNDArrayScalarsInConfig(value);
|
}
|
}
|
}
|
}
|
}
|
/**
|
* Deserialize a saved Keras Object
|
* @param identifier either a string ID or a saved Keras dictionary
|
* @param moduleObjects a list of Python class names to object constructors
|
* @param customObjects a list of Python class names to object constructors
|
* @param printableModuleName debug text for the object being reconstituted
|
* @param fastWeightInit Optional flag to use fast weight initialization
|
* during deserialization. This is applicable to cases in which
|
* the initialization will be immediately overwritten by loaded weight
|
* values. Default: `false`.
|
* @returns a TensorFlow.js Layers object
|
*/
|
// tslint:disable:no-any
|
export function deserializeKerasObject(identifier, moduleObjects = {}, customObjects = {}, printableModuleName = 'object', fastWeightInit = false) {
|
// tslint:enable
|
if (typeof identifier === 'string') {
|
const functionName = identifier;
|
let fn;
|
if (functionName in customObjects) {
|
fn = customObjects[functionName];
|
}
|
else if (functionName in _GLOBAL_CUSTOM_OBJECTS) {
|
fn = _GLOBAL_CUSTOM_OBJECTS[functionName];
|
}
|
else {
|
fn = moduleObjects[functionName];
|
if (fn == null) {
|
throw new ValueError(`Unknown ${printableModuleName}: ${identifier}. ` +
|
`This may be due to one of the following reasons:\n` +
|
`1. The ${printableModuleName} is defined in Python, in which ` +
|
`case it needs to be ported to TensorFlow.js or your JavaScript ` +
|
`code.\n` +
|
`2. The custom ${printableModuleName} is defined in JavaScript, ` +
|
`but is not registered properly with ` +
|
`tf.serialization.registerClass().`);
|
// TODO(cais): Add link to tutorial page on custom layers.
|
}
|
}
|
return fn;
|
}
|
else {
|
// In this case we are dealing with a Keras config dictionary.
|
const config = identifier;
|
if (config['className'] == null || config['config'] == null) {
|
throw new ValueError(`${printableModuleName}: Improper config format: ` +
|
`${JSON.stringify(config)}.\n` +
|
`'className' and 'config' must set.`);
|
}
|
const className = config['className'];
|
let cls, fromConfig;
|
if (className in customObjects) {
|
[cls, fromConfig] = customObjects[className];
|
}
|
else if (className in _GLOBAL_CUSTOM_OBJECTS) {
|
[cls, fromConfig] = _GLOBAL_CUSTOM_OBJECTS['className'];
|
}
|
else if (className in moduleObjects) {
|
[cls, fromConfig] = moduleObjects[className];
|
}
|
if (cls == null) {
|
throw new ValueError(`Unknown ${printableModuleName}: ${className}. ` +
|
`This may be due to one of the following reasons:\n` +
|
`1. The ${printableModuleName} is defined in Python, in which ` +
|
`case it needs to be ported to TensorFlow.js or your JavaScript ` +
|
`code.\n` +
|
`2. The custom ${printableModuleName} is defined in JavaScript, ` +
|
`but is not registered properly with ` +
|
`tf.serialization.registerClass().`);
|
// TODO(cais): Add link to tutorial page on custom layers.
|
}
|
if (fromConfig != null) {
|
// Porting notes: Instead of checking to see whether fromConfig accepts
|
// customObjects, we create a customObjects dictionary and tack it on to
|
// config['config'] as config['config'].customObjects. Objects can use it,
|
// if they want.
|
// tslint:disable-next-line:no-any
|
const customObjectsCombined = {};
|
for (const key of Object.keys(_GLOBAL_CUSTOM_OBJECTS)) {
|
customObjectsCombined[key] = _GLOBAL_CUSTOM_OBJECTS[key];
|
}
|
for (const key of Object.keys(customObjects)) {
|
customObjectsCombined[key] = customObjects[key];
|
}
|
// Add the customObjects to config
|
const nestedConfig = config['config'];
|
nestedConfig['customObjects'] = customObjectsCombined;
|
const backupCustomObjects = Object.assign({}, _GLOBAL_CUSTOM_OBJECTS);
|
for (const key of Object.keys(customObjects)) {
|
_GLOBAL_CUSTOM_OBJECTS[key] = customObjects[key];
|
}
|
convertNDArrayScalarsInConfig(config['config']);
|
const returnObj = fromConfig(cls, config['config'], customObjects, fastWeightInit);
|
_GLOBAL_CUSTOM_OBJECTS = Object.assign({}, backupCustomObjects);
|
return returnObj;
|
}
|
else {
|
// Then `cls` may be a function returning a class.
|
// In this case by convention `config` holds
|
// the kwargs of the function.
|
const backupCustomObjects = Object.assign({}, _GLOBAL_CUSTOM_OBJECTS);
|
for (const key of Object.keys(customObjects)) {
|
_GLOBAL_CUSTOM_OBJECTS[key] = customObjects[key];
|
}
|
// In python this is **config['config'], for tfjs-layers we require
|
// classes that use this fall-through construction method to take
|
// a config interface that mimics the expansion of named parameters.
|
const returnObj = new cls(config['config']);
|
_GLOBAL_CUSTOM_OBJECTS = Object.assign({}, backupCustomObjects);
|
return returnObj;
|
}
|
}
|
}
|
/**
|
* Compares two numbers for sorting.
|
* @param a
|
* @param b
|
*/
|
export function numberCompare(a, b) {
|
return (a < b) ? -1 : ((a > b) ? 1 : 0);
|
}
|
/**
|
* Comparison of two numbers for reverse sorting.
|
* @param a
|
* @param b
|
*/
|
export function reverseNumberCompare(a, b) {
|
return -1 * numberCompare(a, b);
|
}
|
/**
|
* Convert a string into the corresponding DType.
|
* @param dtype
|
* @returns An instance of DType.
|
*/
|
export function stringToDType(dtype) {
|
switch (dtype) {
|
case 'float32':
|
return 'float32';
|
default:
|
throw new ValueError(`Invalid dtype: ${dtype}`);
|
}
|
}
|
/**
|
* Test the element-by-element equality of two Arrays of strings.
|
* @param xs First array of strings.
|
* @param ys Second array of strings.
|
* @returns Wether the two arrays are all equal, element by element.
|
*/
|
export function stringsEqual(xs, ys) {
|
if (xs == null || ys == null) {
|
return xs === ys;
|
}
|
if (xs.length !== ys.length) {
|
return false;
|
}
|
for (let i = 0; i < xs.length; ++i) {
|
if (xs[i] !== ys[i]) {
|
return false;
|
}
|
}
|
return true;
|
}
|
/**
|
* Get the unique elements of an array.
|
* @param xs Array.
|
* @returns An Array consisting of the unique elements in `xs`.
|
*/
|
export function unique(xs) {
|
if (xs == null) {
|
return xs;
|
}
|
const out = [];
|
// TODO(cais): Maybe improve performance by sorting.
|
for (const x of xs) {
|
if (out.indexOf(x) === -1) {
|
out.push(x);
|
}
|
}
|
return out;
|
}
|
/**
|
* Determine if an Object is empty (i.e., does not have own properties).
|
* @param obj Object
|
* @returns Whether the Object is empty.
|
* @throws ValueError: If object is `null` or `undefined`.
|
*/
|
export function isObjectEmpty(obj) {
|
if (obj == null) {
|
throw new ValueError(`Invalid value in obj: ${JSON.stringify(obj)}`);
|
}
|
for (const key in obj) {
|
if (obj.hasOwnProperty(key)) {
|
return false;
|
}
|
}
|
return true;
|
}
|
/**
|
* Helper function used to build type union/enum run-time checkers.
|
* @param values The list of allowed values.
|
* @param label A string name for the type
|
* @param value The value to test.
|
* @throws ValueError: If the value is not in values nor `undefined`/`null`.
|
*/
|
export function checkStringTypeUnionValue(values, label, value) {
|
if (value == null) {
|
return;
|
}
|
if (values.indexOf(value) < 0) {
|
throw new ValueError(`${value} is not a valid ${label}. Valid values are ${values} or null/undefined.`);
|
}
|
}
|
/**
|
* Helper function for verifying the types of inputs.
|
*
|
* Ensures that the elements of `x` are all of type `expectedType`.
|
* Also verifies that the length of `x` is within bounds.
|
*
|
* @param x Object to test.
|
* @param expectedType The string expected type of all of the elements in the
|
* Array.
|
* @param minLength Return false if x.length is less than this.
|
* @param maxLength Return false if x.length is greater than this.
|
* @returns true if and only if `x` is an `Array<expectedType>` with
|
* length >= `minLength` and <= `maxLength`.
|
*/
|
// tslint:disable:no-any
|
export function checkArrayTypeAndLength(x, expectedType, minLength = 0, maxLength = Infinity) {
|
assert(minLength >= 0);
|
assert(maxLength >= minLength);
|
return (Array.isArray(x) && x.length >= minLength && x.length <= maxLength &&
|
x.every(e => typeof e === expectedType));
|
}
|
// tslint:enable:no-any
|
/**
|
* Assert that a value or an array of value are positive integer.
|
*
|
* @param value The value being asserted on. May be a single number or an array
|
* of numbers.
|
* @param name Name of the value, used to make the error message.
|
*/
|
export function assertPositiveInteger(value, name) {
|
if (Array.isArray(value)) {
|
util.assert(value.length > 0, () => `${name} is unexpectedly an empty array.`);
|
value.forEach((v, i) => assertPositiveInteger(v, `element ${i + 1} of ${name}`));
|
}
|
else {
|
util.assert(Number.isInteger(value) && value > 0, () => `Expected ${name} to be a positive integer, but got ` +
|
`${formatAsFriendlyString(value)}.`);
|
}
|
}
|
/**
|
* Format a value into a display-friendly, human-readable fashion.
|
*
|
* - `null` is formatted as `'null'`
|
* - Strings are formated with flanking pair of quotes.
|
* - Arrays are formatted with flanking pair of square brackets.
|
*
|
* @param value The value to display.
|
* @return Formatted string.
|
*/
|
// tslint:disable-next-line:no-any
|
export function formatAsFriendlyString(value) {
|
if (value === null) {
|
return 'null';
|
}
|
else if (Array.isArray(value)) {
|
return '[' + value.map(v => formatAsFriendlyString(v)).join(',') + ']';
|
}
|
else if (typeof value === 'string') {
|
return `"${value}"`;
|
}
|
else {
|
return `${value}`;
|
}
|
}
|
/**
|
* Returns a function `f2` (decorator) which wraps the original function
|
* `f`. `f2` guarantees that `f` can be called at most once
|
* every `waitMs` ms. If `f2` is called more often, it will return
|
* the last returned result of `f`.
|
*
|
* @param f The original function `f` to wrap.
|
* @param waitMs The time between two consecutive calls to `f` in ms.
|
*/
|
export function debounce(f, waitMs, nowFunc) {
|
let lastTime = nowFunc != null ? nowFunc() : util.now();
|
let lastResult;
|
const f2 = (...args) => {
|
const now = nowFunc != null ? nowFunc() : util.now();
|
if (now - lastTime < waitMs) {
|
return lastResult;
|
}
|
lastTime = now;
|
lastResult = f(...args);
|
return lastResult;
|
};
|
return f2;
|
}
|
/**
|
* Returns the fusable activation given a layers identifier.
|
*
|
* @param activationName The layers identifier string.
|
* @return The name of the fusable activation.
|
*/
|
export function mapActivationToFusedKernel(activationName) {
|
if (activationName === 'relu') {
|
return 'relu';
|
}
|
if (activationName === 'linear') {
|
return 'linear';
|
}
|
if (activationName === 'elu') {
|
return 'elu';
|
}
|
return null;
|
}
|
/**
|
* Returns the cartesian product of sets of values.
|
* This works the same as itertools.product in Python.
|
*
|
* Example:
|
*
|
* filters = [128, 256, 512]
|
* paddings = ['same', 'valid']
|
*
|
* product = [ [128, 'same'], [128, 'valid'], [256, 'same'], [256, 'valid'],
|
* [512, 'same'], [512, 'valid']]
|
*
|
* @param arrayOfValues List/array of values.
|
* @return The cartesian product.
|
*/
|
export function getCartesianProductOfValues(...arrayOfValues) {
|
assert(arrayOfValues.length > 0, 'arrayOfValues is empty');
|
for (const values of arrayOfValues) {
|
assert(Array.isArray(values), 'one of the values is not an array');
|
assert(values.length > 0, 'one of the values is empty');
|
}
|
return arrayOfValues.reduce((products, values) => {
|
if (products.length === 0) {
|
return values.map(value => [value]);
|
}
|
return values
|
.map(value => {
|
return products.map((prevValue) => [...prevValue, value]);
|
})
|
.reduce((flattenedProduct, unflattenedProduct) => {
|
return flattenedProduct.concat(unflattenedProduct);
|
}, []);
|
}, []);
|
}
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generic_utils.js","sourceRoot":"","sources":["../../../../../../tfjs-layers/src/utils/generic_utils.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/* Original source: utils/generic_utils.py */\n\nimport {DataType, fused, serialization, util} from '@tensorflow/tfjs-core';\n\nimport {AssertionError, ValueError} from '../errors';\n\n// tslint:enable\n\n/**\n * If `value` is an Array, equivalent to Python's `value * numValues`.\n * If `value` is not an Array, equivalent to Python's `[value] * numValues`\n */\n// tslint:disable-next-line:no-any\nexport function pyListRepeat(value: any, numValues: number): any[] {\n  if (Array.isArray(value)) {\n    // tslint:disable-next-line:no-any\n    let newArray: any[] = [];\n    for (let i = 0; i < numValues; i++) {\n      newArray = newArray.concat(value);\n    }\n    return newArray;\n  } else {\n    const newArray = new Array(numValues);\n    newArray.fill(value);\n    return newArray;\n  }\n}\n\nexport function assert(val: boolean, message?: string): void {\n  if (!val) {\n    throw new AssertionError(message);\n  }\n}\n\n/**\n * Count the number of elements of the `array` that are equal to `reference`.\n */\nexport function count<T>(array: T[], refernce: T) {\n  let counter = 0;\n  for (const item of array) {\n    if (item === refernce) {\n      counter++;\n    }\n  }\n  return counter;\n}\n\n/**\n * If an array is of length 1, just return the first element. Otherwise, return\n * the full array.\n * @param tensors\n */\nexport function singletonOrArray<T>(xs: T[]): T|T[] {\n  if (xs.length === 1) {\n    return xs[0];\n  }\n  return xs;\n}\n\n/**\n * Normalizes a list/tensor into a list.\n *\n * If a tensor is passed, we return\n * a list of size 1 containing the tensor.\n *\n * @param x target object to be normalized.\n */\n// tslint:disable-next-line:no-any\nexport function toList<T>(x: T|T[]): T[] {\n  if (Array.isArray(x)) {\n    return x;\n  }\n  return [x];\n}\n\n/**\n * Generate a UID for a list\n */\n// tslint:disable-next-line:no-any\nexport function objectListUid(objs: any|any[]): string {\n  const objectList = toList(objs);\n  let retVal = '';\n  for (const obj of objectList) {\n    if (obj.id == null) {\n      throw new ValueError(\n          `Object ${obj} passed to objectListUid without an id`);\n    }\n    if (retVal !== '') {\n      retVal = retVal + ', ';\n    }\n    retVal = `${retVal}${Math.abs(obj.id)}`;\n  }\n  return retVal;\n}\n/**\n * Converts string to snake-case.\n * @param name\n */\nexport function toSnakeCase(name: string): string {\n  const intermediate = name.replace(/(.)([A-Z][a-z0-9]+)/g, '$1_$2');\n  const insecure =\n      intermediate.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();\n  /*\n   If the class is private the name starts with \"_\" which is not secure\n   for creating scopes. We prefix the name with \"private\" in this case.\n   */\n  if (insecure[0] !== '_') {\n    return insecure;\n  }\n  return 'private' + insecure;\n}\n\nexport function toCamelCase(identifier: string): string {\n  // quick return for empty string or single character strings\n  if (identifier.length <= 1) {\n    return identifier;\n  }\n  // Check for the underscore indicating snake_case\n  if (identifier.indexOf('_') === -1) {\n    return identifier;\n  }\n  return identifier.replace(/[_]+(\\w|$)/g, (m, p1) => p1.toUpperCase());\n}\n\n// tslint:disable-next-line:no-any\nlet _GLOBAL_CUSTOM_OBJECTS = {} as {[objName: string]: any};\n\nexport function serializeKerasObject(instance: serialization.Serializable):\n    serialization.ConfigDictValue {\n  if (instance === null || instance === undefined) {\n    return null;\n  }\n  const dict: serialization.ConfigDictValue = {};\n  dict['className'] = instance.getClassName();\n  dict['config'] = instance.getConfig();\n  return dict;\n}\n\n/**\n * Replace ndarray-style scalar objects in serialization objects with numbers.\n *\n * Background: In some versions of tf.keras, certain scalar values in the HDF5\n * model save file can be serialized as: `{'type': 'ndarray', 'value': num}`,\n * where in `num` is a plain number. This method converts such serialization\n * to a `number`.\n *\n * @param config The keras-format serialization object to be processed\n *   (in place).\n */\nfunction convertNDArrayScalarsInConfig(config: serialization.ConfigDictValue):\n    void {\n  if (config == null || typeof config !== 'object') {\n    return;\n  } else if (Array.isArray(config)) {\n    config.forEach(configItem => convertNDArrayScalarsInConfig(configItem));\n  } else {\n    const fields = Object.keys(config);\n    for (const field of fields) {\n      const value = config[field];\n      if (value != null && typeof value === 'object') {\n        if (!Array.isArray(value) && value['type'] === 'ndarray' &&\n            typeof value['value'] === 'number') {\n          config[field] = value['value'];\n        } else {\n          convertNDArrayScalarsInConfig(value as serialization.ConfigDict);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Deserialize a saved Keras Object\n * @param identifier either a string ID or a saved Keras dictionary\n * @param moduleObjects a list of Python class names to object constructors\n * @param customObjects a list of Python class names to object constructors\n * @param printableModuleName debug text for the object being reconstituted\n * @param fastWeightInit Optional flag to use fast weight initialization\n *   during deserialization. This is applicable to cases in which\n *   the initialization will be immediately overwritten by loaded weight\n *   values. Default: `false`.\n * @returns a TensorFlow.js Layers object\n */\n// tslint:disable:no-any\nexport function deserializeKerasObject(\n    identifier: string|serialization.ConfigDict,\n    moduleObjects = {} as {[objName: string]: any},\n    customObjects = {} as {[objName: string]: any},\n    printableModuleName = 'object', fastWeightInit = false): any {\n  // tslint:enable\n  if (typeof identifier === 'string') {\n    const functionName = identifier;\n    let fn;\n    if (functionName in customObjects) {\n      fn = customObjects[functionName];\n    } else if (functionName in _GLOBAL_CUSTOM_OBJECTS) {\n      fn = _GLOBAL_CUSTOM_OBJECTS[functionName];\n    } else {\n      fn = moduleObjects[functionName];\n      if (fn == null) {\n        throw new ValueError(\n            `Unknown ${printableModuleName}: ${identifier}. ` +\n            `This may be due to one of the following reasons:\\n` +\n            `1. The ${printableModuleName} is defined in Python, in which ` +\n            `case it needs to be ported to TensorFlow.js or your JavaScript ` +\n            `code.\\n` +\n            `2. The custom ${printableModuleName} is defined in JavaScript, ` +\n            `but is not registered properly with ` +\n            `tf.serialization.registerClass().`);\n        // TODO(cais): Add link to tutorial page on custom layers.\n      }\n    }\n    return fn;\n  } else {\n    // In this case we are dealing with a Keras config dictionary.\n    const config = identifier;\n    if (config['className'] == null || config['config'] == null) {\n      throw new ValueError(\n          `${printableModuleName}: Improper config format: ` +\n          `${JSON.stringify(config)}.\\n` +\n          `'className' and 'config' must set.`);\n    }\n    const className = config['className'] as string;\n    let cls, fromConfig;\n    if (className in customObjects) {\n      [cls, fromConfig] = customObjects[className];\n    } else if (className in _GLOBAL_CUSTOM_OBJECTS) {\n      [cls, fromConfig] = _GLOBAL_CUSTOM_OBJECTS['className'];\n    } else if (className in moduleObjects) {\n      [cls, fromConfig] = moduleObjects[className];\n    }\n    if (cls == null) {\n      throw new ValueError(\n          `Unknown ${printableModuleName}: ${className}. ` +\n          `This may be due to one of the following reasons:\\n` +\n          `1. The ${printableModuleName} is defined in Python, in which ` +\n          `case it needs to be ported to TensorFlow.js or your JavaScript ` +\n          `code.\\n` +\n          `2. The custom ${printableModuleName} is defined in JavaScript, ` +\n          `but is not registered properly with ` +\n          `tf.serialization.registerClass().`);\n      // TODO(cais): Add link to tutorial page on custom layers.\n    }\n    if (fromConfig != null) {\n      // Porting notes: Instead of checking to see whether fromConfig accepts\n      // customObjects, we create a customObjects dictionary and tack it on to\n      // config['config'] as config['config'].customObjects. Objects can use it,\n      // if they want.\n\n      // tslint:disable-next-line:no-any\n      const customObjectsCombined = {} as {[objName: string]: any};\n      for (const key of Object.keys(_GLOBAL_CUSTOM_OBJECTS)) {\n        customObjectsCombined[key] = _GLOBAL_CUSTOM_OBJECTS[key];\n      }\n      for (const key of Object.keys(customObjects)) {\n        customObjectsCombined[key] = customObjects[key];\n      }\n      // Add the customObjects to config\n      const nestedConfig = config['config'] as serialization.ConfigDict;\n      nestedConfig['customObjects'] = customObjectsCombined;\n\n      const backupCustomObjects = {..._GLOBAL_CUSTOM_OBJECTS};\n      for (const key of Object.keys(customObjects)) {\n        _GLOBAL_CUSTOM_OBJECTS[key] = customObjects[key];\n      }\n      convertNDArrayScalarsInConfig(config['config']);\n      const returnObj =\n          fromConfig(cls, config['config'], customObjects, fastWeightInit);\n      _GLOBAL_CUSTOM_OBJECTS = {...backupCustomObjects};\n\n      return returnObj;\n    } else {\n      // Then `cls` may be a function returning a class.\n      // In this case by convention `config` holds\n      // the kwargs of the function.\n      const backupCustomObjects = {..._GLOBAL_CUSTOM_OBJECTS};\n      for (const key of Object.keys(customObjects)) {\n        _GLOBAL_CUSTOM_OBJECTS[key] = customObjects[key];\n      }\n      // In python this is **config['config'], for tfjs-layers we require\n      // classes that use this fall-through construction method to take\n      // a config interface that mimics the expansion of named parameters.\n      const returnObj = new cls(config['config']);\n      _GLOBAL_CUSTOM_OBJECTS = {...backupCustomObjects};\n      return returnObj;\n    }\n  }\n}\n\n/**\n * Compares two numbers for sorting.\n * @param a\n * @param b\n */\nexport function numberCompare(a: number, b: number) {\n  return (a < b) ? -1 : ((a > b) ? 1 : 0);\n}\n\n/**\n * Comparison of two numbers for reverse sorting.\n * @param a\n * @param b\n */\nexport function reverseNumberCompare(a: number, b: number) {\n  return -1 * numberCompare(a, b);\n}\n\n/**\n * Convert a string into the corresponding DType.\n * @param dtype\n * @returns An instance of DType.\n */\nexport function stringToDType(dtype: string): DataType {\n  switch (dtype) {\n    case 'float32':\n      return 'float32';\n    default:\n      throw new ValueError(`Invalid dtype: ${dtype}`);\n  }\n}\n\n/**\n * Test the element-by-element equality of two Arrays of strings.\n * @param xs First array of strings.\n * @param ys Second array of strings.\n * @returns Wether the two arrays are all equal, element by element.\n */\nexport function stringsEqual(xs: string[], ys: string[]): boolean {\n  if (xs == null || ys == null) {\n    return xs === ys;\n  }\n  if (xs.length !== ys.length) {\n    return false;\n  }\n  for (let i = 0; i < xs.length; ++i) {\n    if (xs[i] !== ys[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Get the unique elements of an array.\n * @param xs Array.\n * @returns An Array consisting of the unique elements in `xs`.\n */\nexport function unique<T>(xs: T[]): T[] {\n  if (xs == null) {\n    return xs;\n  }\n  const out: T[] = [];\n  // TODO(cais): Maybe improve performance by sorting.\n  for (const x of xs) {\n    if (out.indexOf(x) === -1) {\n      out.push(x);\n    }\n  }\n  return out;\n}\n\n/**\n * Determine if an Object is empty (i.e., does not have own properties).\n * @param obj Object\n * @returns Whether the Object is empty.\n * @throws ValueError: If object is `null` or `undefined`.\n */\nexport function isObjectEmpty(obj: {}): boolean {\n  if (obj == null) {\n    throw new ValueError(`Invalid value in obj: ${JSON.stringify(obj)}`);\n  }\n  for (const key in obj) {\n    if (obj.hasOwnProperty(key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Helper function used to build type union/enum run-time checkers.\n * @param values The list of allowed values.\n * @param label A string name for the type\n * @param value The value to test.\n * @throws ValueError: If the value is not in values nor `undefined`/`null`.\n */\nexport function checkStringTypeUnionValue(\n    values: string[], label: string, value: string): void {\n  if (value == null) {\n    return;\n  }\n  if (values.indexOf(value) < 0) {\n    throw new ValueError(`${value} is not a valid ${label}.  Valid values are ${\n        values} or null/undefined.`);\n  }\n}\n\n/**\n * Helper function for verifying the types of inputs.\n *\n * Ensures that the elements of `x` are all of type `expectedType`.\n * Also verifies that the length of `x` is within bounds.\n *\n * @param x Object to test.\n * @param expectedType The string expected type of all of the elements in the\n * Array.\n * @param minLength Return false if x.length is less than this.\n * @param maxLength Return false if x.length is greater than this.\n * @returns true if and only if `x` is an `Array<expectedType>` with\n * length >= `minLength` and <= `maxLength`.\n */\n// tslint:disable:no-any\nexport function checkArrayTypeAndLength(\n    x: any, expectedType: string, minLength = 0,\n    maxLength = Infinity): boolean {\n  assert(minLength >= 0);\n  assert(maxLength >= minLength);\n  return (\n      Array.isArray(x) && x.length >= minLength && x.length <= maxLength &&\n      x.every(e => typeof e === expectedType));\n}\n// tslint:enable:no-any\n\n/**\n * Assert that a value or an array of value are positive integer.\n *\n * @param value The value being asserted on. May be a single number or an array\n *   of numbers.\n * @param name Name of the value, used to make the error message.\n */\nexport function assertPositiveInteger(value: number|number[], name: string) {\n  if (Array.isArray(value)) {\n    util.assert(\n        value.length > 0, () => `${name} is unexpectedly an empty array.`);\n    value.forEach(\n        (v, i) => assertPositiveInteger(v, `element ${i + 1} of ${name}`));\n  } else {\n    util.assert(\n        Number.isInteger(value) && value > 0,\n        () => `Expected ${name} to be a positive integer, but got ` +\n            `${formatAsFriendlyString(value)}.`);\n  }\n}\n\n/**\n * Format a value into a display-friendly, human-readable fashion.\n *\n * - `null` is formatted as `'null'`\n * - Strings are formated with flanking pair of quotes.\n * - Arrays are formatted with flanking pair of square brackets.\n *\n * @param value The value to display.\n * @return Formatted string.\n */\n// tslint:disable-next-line:no-any\nexport function formatAsFriendlyString(value: any): string {\n  if (value === null) {\n    return 'null';\n  } else if (Array.isArray(value)) {\n    return '[' + value.map(v => formatAsFriendlyString(v)).join(',') + ']';\n  } else if (typeof value === 'string') {\n    return `\"${value}\"`;\n  } else {\n    return `${value}`;\n  }\n}\n\n/**\n * Returns a function `f2` (decorator) which wraps the original function\n * `f`. `f2` guarantees that `f` can be called at most once\n * every `waitMs` ms. If `f2` is called more often, it will return\n * the last returned result of `f`.\n *\n * @param f The original function `f` to wrap.\n * @param waitMs The time between two consecutive calls to `f` in ms.\n */\nexport function debounce<T>(\n    f: (...args: Array<{}>) => T, waitMs: number,\n    nowFunc?: Function): (...args: Array<{}>) => T {\n  let lastTime = nowFunc != null ? nowFunc() : util.now();\n  let lastResult: T;\n  const f2 = (...args: Array<{}>) => {\n    const now = nowFunc != null ? nowFunc() : util.now();\n    if (now - lastTime < waitMs) {\n      return lastResult;\n    }\n    lastTime = now;\n    lastResult = f(...args);\n    return lastResult;\n  };\n  return f2;\n}\n\n/**\n * Returns the fusable activation given a layers identifier.\n *\n * @param activationName The layers identifier string.\n * @return The name of the fusable activation.\n */\nexport function mapActivationToFusedKernel(activationName: string):\n    fused.Activation {\n  if (activationName === 'relu') {\n    return 'relu';\n  }\n  if (activationName === 'linear') {\n    return 'linear';\n  }\n  if (activationName === 'elu') {\n    return 'elu';\n  }\n  return null;\n}\n\ntype PossibleValues = Array<Array<boolean|string|number>>;\n\n/**\n * Returns the cartesian product of sets of values.\n * This works the same as itertools.product in Python.\n *\n * Example:\n *\n * filters = [128, 256, 512]\n * paddings = ['same', 'valid']\n *\n * product = [ [128, 'same'], [128, 'valid'], [256, 'same'], [256, 'valid'],\n * [512, 'same'], [512, 'valid']]\n *\n * @param arrayOfValues List/array of values.\n * @return The cartesian product.\n */\nexport function getCartesianProductOfValues(...arrayOfValues: PossibleValues):\n    PossibleValues {\n  assert(arrayOfValues.length > 0, 'arrayOfValues is empty');\n\n  for (const values of arrayOfValues) {\n    assert(Array.isArray(values), 'one of the values is not an array');\n    assert(values.length > 0, 'one of the values is empty');\n  }\n\n  return arrayOfValues.reduce((products, values) => {\n    if (products.length === 0) {\n      return values.map(value => [value]);\n    }\n\n    return values\n        .map(value => {\n          return products.map((prevValue) => [...prevValue, value]);\n        })\n        .reduce((flattenedProduct, unflattenedProduct) => {\n          return flattenedProduct.concat(unflattenedProduct);\n        }, []);\n  }, [] as PossibleValues);\n}\n"]}
|
