/**
|
* @license
|
* Copyright 2018 Google LLC. All Rights Reserved.
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
* you may not use this file except in compliance with the License.
|
* You may obtain a copy of the License at
|
*
|
* http://www.apache.org/licenses/LICENSE-2.0
|
*
|
* Unless required by applicable law or agreed to in writing, software
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
* See the License for the specific language governing permissions and
|
* limitations under the License.
|
*
|
* =============================================================================
|
*/
|
import * as tf from '@tensorflow/tfjs-core';
|
/**
|
* Apply a mapping function to a nested structure in a recursive manner.
|
*
|
* The result of the mapping is an object with the same nested structure (i.e.,
|
* of arrays and dicts) as the input, except that some subtrees are replaced,
|
* according to the results of the mapping function.
|
*
|
* Mappings are memoized. Thus, if the nested structure contains the same
|
* object in multiple positions, the output will contain the same mapped object
|
* in those positions. Cycles are not supported, however.
|
*
|
* @param input: The object to which to apply the mapping function.
|
* @param mapFn: A function that expects a single node of the object tree, and
|
* returns a `DeepMapResult`. The `DeepMapResult` either provides a
|
* replacement value for that node (i.e., replacing the subtree), or indicates
|
* that the node should be processed recursively.
|
*/
|
export function deepMap(input, mapFn) {
|
return deepMapInternal(input, mapFn);
|
}
|
/**
|
* @param seen: A Map of known object mappings (i.e., memoized results of
|
* `mapFn()`)
|
* @param containedIn: An set containing objects on the reference path currently
|
* being processed (used to detect cycles).
|
*/
|
function deepMapInternal(input, mapFn, seen = new Map(), containedIn = new Set()) {
|
if (input == null) {
|
return null;
|
}
|
if (typeof Blob === 'function' && input instanceof Blob) {
|
return input.slice();
|
}
|
if (containedIn.has(input)) {
|
throw new Error('Circular references are not supported.');
|
}
|
if (seen.has(input)) {
|
return seen.get(input);
|
}
|
const result = mapFn(input);
|
if (result.recurse && result.value !== null) {
|
throw new Error('A deep map function may not return both a value and recurse=true.');
|
}
|
if (!result.recurse) {
|
seen.set(input, result.value);
|
return result.value;
|
}
|
else if (isIterable(input)) {
|
// tslint:disable-next-line:no-any
|
const mappedIterable = Array.isArray(input) ? [] : {};
|
containedIn.add(input);
|
for (const k in input) {
|
const child = input[k];
|
const childResult = deepMapInternal(child, mapFn, seen, containedIn);
|
mappedIterable[k] = childResult;
|
}
|
containedIn.delete(input);
|
if (input.__proto__) {
|
mappedIterable.__proto__ = input.__proto__;
|
}
|
return mappedIterable;
|
}
|
else {
|
throw new Error(`Can't recurse into non-iterable type: ${input}`);
|
}
|
}
|
// TODO(soergel, kangyizhang) Reconsider naming of deepZip() to avoid confusion
|
// with zip()
|
/**
|
* Zip nested structures together in a recursive manner.
|
*
|
* This has the effect of transposing or pivoting data, e.g. converting it from
|
* a row-major representation to a column-major representation.
|
*
|
* For example, `deepZip([{a: 1, b: 2}, {a: 3, b: 4}])` returns
|
* `{a: [1, 3], b: [2, 4]}`.
|
*
|
* The inputs should all have the same nested structure (i.e., of arrays and
|
* dicts). The result is a single object with the same nested structure, where
|
* the leaves are arrays collecting the values of the inputs at that location
|
* (or, optionally, the result of a custom function applied to those arrays).
|
*
|
* @param inputs: An array of the objects to zip together.
|
* @param zipFn: (optional) A function that expects an array of elements at a
|
* single node of the object tree, and returns a `DeepMapResult`. The
|
* `DeepMapResult` either provides a result value for that node (i.e.,
|
* representing the subtree), or indicates that the node should be processed
|
* recursively. The default zipFn recurses as far as possible and places
|
* arrays at the leaves.
|
*/
|
export function deepZip(inputs, zipFn = zipToList) {
|
return deepZipInternal(inputs, zipFn);
|
}
|
/**
|
* @param containedIn: An set containing objects on the reference path currently
|
* being processed (used to detect cycles).
|
*/
|
function deepZipInternal(inputs, zipFn, containedIn = new Set()) {
|
// The recursion follows the structure of input 0; it's assumed that all the
|
// other inputs have the same structure.
|
const input = inputs[0];
|
if (containedIn.has(input)) {
|
throw new Error('Circular references are not supported.');
|
}
|
const result = zipFn(inputs);
|
if (result.recurse && result.value !== null) {
|
throw new Error('A deep zip function may not return both a value and recurse=true.');
|
}
|
if (!result.recurse) {
|
return result.value;
|
}
|
else if (isIterable(input)) {
|
// tslint:disable-next-line:no-any
|
const mappedIterable = Array.isArray(input) ? [] : {};
|
containedIn.add(input);
|
for (const k in input) {
|
const children = inputs.map(x => x[k]);
|
const childResult = deepZipInternal(children, zipFn, containedIn);
|
mappedIterable[k] = childResult;
|
}
|
containedIn.delete(input);
|
return mappedIterable;
|
}
|
else {
|
throw new Error(`Can't recurse into non-iterable type: ${input}`);
|
}
|
}
|
// tslint:disable-next-line:no-any
|
export function zipToList(x) {
|
if (x === null) {
|
return null;
|
}
|
// TODO(soergel): validate array type?
|
if (isIterable(x[0])) {
|
return { value: null, recurse: true };
|
}
|
else {
|
return { value: x, recurse: false };
|
}
|
}
|
/**
|
* Apply an async mapping function to a nested structure in a recursive manner.
|
*
|
* This first creates a nested structure of Promises, and then awaits all of
|
* those, resulting in a single Promise for a resolved nested structure.
|
*
|
* The result of the mapping is an object with the same nested structure (i.e.,
|
* of arrays and dicts) as the input, except that some subtrees are replaced,
|
* according to the results of the mapping function.
|
*
|
* Mappings are memoized. Thus, if the nested structure contains the same
|
* object in multiple positions, the output will contain the same mapped object
|
* in those positions. Cycles are not supported, however.
|
*
|
* @param input: The object to which to apply the mapping function.
|
* @param mapFn: A function that expects a single node of the object tree, and
|
* returns a `DeepMapAsyncResult`. The `DeepMapAsyncResult` either provides
|
* a `Promise` for a replacement value for that node (i.e., replacing the
|
* subtree), or indicates that the node should be processed recursively. Note
|
* that the decision whether or not to recurse must be made immediately; only
|
* the mapped value may be promised.
|
*/
|
export async function deepMapAndAwaitAll(input, mapFn) {
|
const seen = new Map();
|
// First do a normal deepMap, collecting Promises in 'seen' as a side effect.
|
deepMapInternal(input, mapFn, seen);
|
// Replace the Promises in 'seen' in place.
|
// Note TypeScript provides no async map iteration, and regular map iteration
|
// is broken too, so sadly we have to do Array.from() to make it work.
|
// (There's no advantage to Promise.all(), and that would be tricky anyway.)
|
for (const key of Array.from(seen.keys())) {
|
const value = seen.get(key);
|
if (tf.util.isPromise(value)) {
|
const mappedValue = await value;
|
seen.set(key, mappedValue);
|
}
|
}
|
// Normal deepMap again, this time filling in the resolved values.
|
// It's unfortunate that we have to do two passes.
|
// TODO(soergel): test performance and think harder about a fast solution.
|
const result = deepMapInternal(input, mapFn, seen);
|
return result;
|
}
|
/**
|
* Determine whether the argument is iterable.
|
*
|
* @returns true if the argument is an array or any non-Tensor object.
|
*/
|
// tslint:disable-next-line:no-any
|
export function isIterable(obj) {
|
let isTextDecoder = false;
|
if (tf.env().get('IS_BROWSER')) {
|
isTextDecoder = obj instanceof TextDecoder;
|
}
|
else {
|
// tslint:disable-next-line:no-require-imports
|
const { StringDecoder } = require('string_decoder');
|
isTextDecoder = obj instanceof StringDecoder;
|
}
|
return obj != null && (!ArrayBuffer.isView(obj)) &&
|
(Array.isArray(obj) ||
|
(typeof obj === 'object' && !(obj instanceof tf.Tensor) &&
|
!(obj instanceof Promise) && !isTextDecoder));
|
}
|
/**
|
* Determine whether the argument can be converted to Tensor.
|
*
|
* Tensors, primitives, arrays, and TypedArrays all qualify; anything else does
|
* not.
|
*
|
* @returns true if the argument can be converted to Tensor.
|
*/
|
// tslint:disable-next-line:no-any
|
export function canTensorify(obj) {
|
return obj == null || isPrimitive(obj) || Array.isArray(obj) ||
|
(typeof obj === 'object' && (obj instanceof tf.Tensor)) ||
|
tf.util.isTypedArray(obj);
|
}
|
/**
|
* Returns true if the given `value` is a primitive type. Otherwise returns
|
* false. This is equivalant to node util.isPrimitive
|
*/
|
function isPrimitive(value) {
|
return (value === null ||
|
(typeof value !== 'object' && typeof value !== 'function'));
|
}
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"deep_map.js","sourceRoot":"","sources":["../../../../../../tfjs-data/src/util/deep_map.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2018 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n * =============================================================================\n */\n\nimport * as tf from '@tensorflow/tfjs-core';\n\n// tslint:disable:no-any\n\n/**\n * A return value for a mapping function that can be applied via deepMap.\n *\n * If recurse is true, the value should be empty, and iteration will continue\n * into the object or array.\n */\nexport type DeepMapResult = {\n  value: any,\n  recurse: boolean\n};\n\n/**\n * Apply a mapping function to a nested structure in a recursive manner.\n *\n * The result of the mapping is an object with the same nested structure (i.e.,\n * of arrays and dicts) as the input, except that some subtrees are replaced,\n * according to the results of the mapping function.\n *\n * Mappings are memoized.  Thus, if the nested structure contains the same\n * object in multiple positions, the output will contain the same mapped object\n * in those positions.  Cycles are not supported, however.\n *\n * @param input: The object to which to apply the mapping function.\n * @param mapFn: A function that expects a single node of the object tree, and\n *   returns a `DeepMapResult`.  The `DeepMapResult` either provides a\n *   replacement value for that node (i.e., replacing the subtree), or indicates\n *   that the node should be processed recursively.\n */\nexport function deepMap(input: any, mapFn: (x: any) => DeepMapResult): any|\n    any[] {\n  return deepMapInternal(input, mapFn);\n}\n\n/**\n * @param seen: A Map of known object mappings (i.e., memoized results of\n *   `mapFn()`)\n * @param containedIn: An set containing objects on the reference path currently\n *   being processed (used to detect cycles).\n */\nfunction deepMapInternal(\n    input: any, mapFn: (x: any) => DeepMapResult,\n    seen: Map<any, any> = new Map(), containedIn: Set<{}> = new Set()): any|\n    any[] {\n  if (input == null) {\n    return null;\n  }\n  if (typeof Blob === 'function' && input instanceof Blob) {\n    return input.slice();\n  }\n\n  if (containedIn.has(input)) {\n    throw new Error('Circular references are not supported.');\n  }\n  if (seen.has(input)) {\n    return seen.get(input);\n  }\n  const result = mapFn(input);\n\n  if (result.recurse && result.value !== null) {\n    throw new Error(\n        'A deep map function may not return both a value and recurse=true.');\n  }\n\n  if (!result.recurse) {\n    seen.set(input, result.value);\n    return result.value;\n  } else if (isIterable(input)) {\n    // tslint:disable-next-line:no-any\n    const mappedIterable: any|any[] = Array.isArray(input) ? [] : {};\n    containedIn.add(input);\n    for (const k in input) {\n      const child = input[k];\n      const childResult = deepMapInternal(child, mapFn, seen, containedIn);\n      mappedIterable[k] = childResult;\n    }\n    containedIn.delete(input);\n    if (input.__proto__) {\n      mappedIterable.__proto__ = input.__proto__;\n    }\n    return mappedIterable;\n  } else {\n    throw new Error(`Can't recurse into non-iterable type: ${input}`);\n  }\n}\n\n// TODO(soergel, kangyizhang) Reconsider naming of deepZip() to avoid confusion\n// with zip()\n\n/**\n * Zip nested structures together in a recursive manner.\n *\n * This has the effect of transposing or pivoting data, e.g. converting it from\n * a row-major representation to a column-major representation.\n *\n * For example, `deepZip([{a: 1, b: 2}, {a: 3, b: 4}])` returns\n * `{a: [1, 3], b: [2, 4]}`.\n *\n * The inputs should all have the same nested structure (i.e., of arrays and\n * dicts).  The result is a single object with the same nested structure, where\n * the leaves are arrays collecting the values of the inputs at that location\n * (or, optionally, the result of a custom function applied to those arrays).\n *\n * @param inputs: An array of the objects to zip together.\n * @param zipFn: (optional) A function that expects an array of elements at a\n *   single node of the object tree, and returns a `DeepMapResult`.  The\n *   `DeepMapResult` either provides a result value for that node (i.e.,\n *   representing the subtree), or indicates that the node should be processed\n *   recursively.  The default zipFn recurses as far as possible and places\n *   arrays at the leaves.\n */\nexport function deepZip(\n    inputs: any[], zipFn: (xs: any[]) => DeepMapResult = zipToList): any|any[] {\n  return deepZipInternal(inputs, zipFn);\n}\n\n/**\n * @param containedIn: An set containing objects on the reference path currently\n *   being processed (used to detect cycles).\n */\nfunction deepZipInternal(\n    inputs: any[], zipFn: (xs: any[]) => DeepMapResult,\n    containedIn: Set<{}> = new Set()): any|any[] {\n  // The recursion follows the structure of input 0; it's assumed that all the\n  // other inputs have the same structure.\n  const input = inputs[0];\n  if (containedIn.has(input)) {\n    throw new Error('Circular references are not supported.');\n  }\n  const result = zipFn(inputs);\n\n  if (result.recurse && result.value !== null) {\n    throw new Error(\n        'A deep zip function may not return both a value and recurse=true.');\n  }\n\n  if (!result.recurse) {\n    return result.value;\n  } else if (isIterable(input)) {\n    // tslint:disable-next-line:no-any\n    const mappedIterable: any|any[] = Array.isArray(input) ? [] : {};\n    containedIn.add(input);\n    for (const k in input) {\n      const children = inputs.map(x => x[k]);\n      const childResult = deepZipInternal(children, zipFn, containedIn);\n      mappedIterable[k] = childResult;\n    }\n    containedIn.delete(input);\n    return mappedIterable;\n  } else {\n    throw new Error(`Can't recurse into non-iterable type: ${input}`);\n  }\n}\n\n// tslint:disable-next-line:no-any\nexport function zipToList(x: any[]): DeepMapResult {\n  if (x === null) {\n    return null;\n  }\n  // TODO(soergel): validate array type?\n\n  if (isIterable(x[0])) {\n    return {value: null, recurse: true};\n  } else {\n    return {value: x, recurse: false};\n  }\n}\n\n/**\n * A return value for an async map function for use with deepMapAndAwaitAll.\n *\n * If recurse is true, the value should be empty, and iteration will continue\n * into the object or array.\n */\nexport type DeepMapAsyncResult = {\n  value: Promise<any>,\n  recurse: boolean\n};\n\n/**\n * Apply an async mapping function to a nested structure in a recursive manner.\n *\n * This first creates a nested structure of Promises, and then awaits all of\n * those, resulting in a single Promise for a resolved nested structure.\n *\n * The result of the mapping is an object with the same nested structure (i.e.,\n * of arrays and dicts) as the input, except that some subtrees are replaced,\n * according to the results of the mapping function.\n *\n * Mappings are memoized.  Thus, if the nested structure contains the same\n * object in multiple positions, the output will contain the same mapped object\n * in those positions.  Cycles are not supported, however.\n *\n * @param input: The object to which to apply the mapping function.\n * @param mapFn: A function that expects a single node of the object tree, and\n *   returns a `DeepMapAsyncResult`.  The `DeepMapAsyncResult` either provides\n *   a `Promise` for a replacement value for that node (i.e., replacing the\n *   subtree), or indicates that the node should be processed recursively.  Note\n *   that the decision whether or not to recurse must be made immediately; only\n *   the mapped value may be promised.\n */\nexport async function deepMapAndAwaitAll(\n    input: any, mapFn: (x: any) => DeepMapAsyncResult): Promise<any|any[]> {\n  const seen: Map<any, any> = new Map();\n\n  // First do a normal deepMap, collecting Promises in 'seen' as a side effect.\n  deepMapInternal(input, mapFn, seen);\n\n  // Replace the Promises in 'seen' in place.\n  // Note TypeScript provides no async map iteration, and regular map iteration\n  // is broken too, so sadly we have to do Array.from() to make it work.\n  // (There's no advantage to Promise.all(), and that would be tricky anyway.)\n  for (const key of Array.from(seen.keys())) {\n    const value = seen.get(key);\n    if (tf.util.isPromise(value)) {\n      const mappedValue = await value;\n      seen.set(key, mappedValue);\n    }\n  }\n\n  // Normal deepMap again, this time filling in the resolved values.\n  // It's unfortunate that we have to do two passes.\n  // TODO(soergel): test performance and think harder about a fast solution.\n  const result = deepMapInternal(input, mapFn, seen);\n  return result;\n}\n\n/**\n * Determine whether the argument is iterable.\n *\n * @returns true if the argument is an array or any non-Tensor object.\n */\n// tslint:disable-next-line:no-any\nexport function isIterable(obj: any): boolean {\n  let isTextDecoder = false;\n  if (tf.env().get('IS_BROWSER')) {\n    isTextDecoder = obj instanceof TextDecoder;\n  } else {\n    // tslint:disable-next-line:no-require-imports\n    const {StringDecoder} = require('string_decoder');\n    isTextDecoder = obj instanceof StringDecoder;\n  }\n  return obj != null && (!ArrayBuffer.isView(obj)) &&\n      (Array.isArray(obj) ||\n       (typeof obj === 'object' && !(obj instanceof tf.Tensor) &&\n        !(obj instanceof Promise) && !isTextDecoder));\n}\n\n/**\n * Determine whether the argument can be converted to Tensor.\n *\n * Tensors, primitives, arrays, and TypedArrays all qualify; anything else does\n * not.\n *\n * @returns true if the argument can be converted to Tensor.\n */\n// tslint:disable-next-line:no-any\nexport function canTensorify(obj: any): boolean {\n  return obj == null || isPrimitive(obj) || Array.isArray(obj) ||\n      (typeof obj === 'object' && (obj instanceof tf.Tensor)) ||\n      tf.util.isTypedArray(obj);\n}\n\n/**\n * Returns true if the given `value` is a primitive type. Otherwise returns\n * false. This is equivalant to node util.isPrimitive\n */\nfunction isPrimitive(value: any): boolean {\n  return (\n      value === null ||\n      (typeof value !== 'object' && typeof value !== 'function'));\n}\n"]}
|
