@tensorflow/tfjs-converter
Version:
Tensorflow model converter for javascript
284 lines • 43 kB
JavaScript
/**
* @license
* Copyright 2019 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 { parseNodeName } from '../operations/executors/utils';
/**
* Given graph inputs and desired outputs, find the minimal set of nodes
* to execute in order to compute the outputs. In addition return other useful
* info such:
* - Missing inputs needed to compute the output.
* - Whether the subgraph contains dynamic ops (control flow, dynamic shape).
* - Alternative inputs in order to avoid async (dynamic op) execution.
*/
export function getExecutionSubgraph(inputs, outputs, weightMap, initNodes) {
const usedNodes = new Set();
const missingInputs = [];
let dynamicNode = null;
let syncInputs = null;
// Start with the outputs, going backwards and find all the nodes that are
// needed to compute those outputs.
const seen = new Set();
const inputNodeNames = new Set(Object.keys(inputs).map((name) => parseNodeName(name)[0]));
initNodes = initNodes || [];
const initNodeNames = new Set(initNodes.map((node) => parseNodeName(node.name)[0]));
const frontier = [...outputs];
while (frontier.length > 0) {
const node = frontier.pop();
if (isControlFlow(node) || isDynamicShape(node) || isHashTable(node)) {
if (dynamicNode == null) {
dynamicNode = node;
syncInputs = dynamicNode.children.map(child => child.name)
.filter(name => usedNodes.has(name));
}
}
usedNodes.add(node.name);
// Weights are dead end since we already have their values.
if (weightMap[node.name] != null) {
continue;
}
// This node is a dead end since it's one of the user-provided inputs.
if (inputNodeNames.has(node.name)) {
continue;
}
// This node is a dead end since it doesn't have any inputs.
if (initNodeNames.has(node.name)) {
continue;
}
if (node.inputs.length === 0) {
missingInputs.push(node.name);
continue;
}
node.inputs.forEach(input => {
// Don't add to the frontier if it is already there.
if (seen.has(input.name)) {
return;
}
seen.add(input.name);
frontier.push(input);
});
}
return { inputs, outputs, usedNodes, missingInputs, dynamicNode, syncInputs };
}
/**
* Given the execution info, return a list of nodes in topological order that
* need to be executed to compute the output.
*/
export function getNodesInTopologicalOrder(graph, executionInfo) {
const { usedNodes, inputs } = executionInfo;
const inputNodes = Object.keys(inputs)
.map(name => parseNodeName(name)[0])
.map(name => graph.nodes[name]);
const initNodes = graph.initNodes || [];
const isUsed = (node) => usedNodes.has(typeof node === 'string' ? node : node.name);
function unique(nodes) {
return [...new Map(nodes.map((node) => [node.name, node])).values()];
}
const predefinedNodes = unique([
...inputNodes,
...graph.weights,
...initNodes,
]).filter(isUsed);
const allNodes = unique([
...predefinedNodes,
...Object.values(graph.nodes),
]).filter(isUsed);
const nameToNode = new Map(allNodes.map((node) => [node.name, node]));
const inCounts = {};
for (const node of allNodes) {
inCounts[node.name] = inCounts[node.name] || 0;
for (const child of node.children) {
// When the child is unused, set in counts to infinity so that it will
// never be decreased to 0 and added to the execution list.
if (!isUsed(child)) {
inCounts[child.name] = Number.POSITIVE_INFINITY;
}
inCounts[child.name] = (inCounts[child.name] || 0) + 1;
}
}
// Build execution order for all used nodes regardless whether they are
// predefined or not.
const frontier = Object.entries(inCounts)
.filter(([, inCount]) => inCount === 0)
.map(([name]) => name);
const orderedNodeNames = [...frontier];
while (frontier.length > 0) {
const nodeName = frontier.pop();
const node = nameToNode.get(nodeName);
for (const child of node.children.filter(isUsed)) {
if (--inCounts[child.name] === 0) {
orderedNodeNames.push(child.name);
frontier.push(child.name);
}
}
}
const orderedNodes = orderedNodeNames.map((name) => nameToNode.get(name));
const filteredOrderedNodes = filterPredefinedReachableNodes(orderedNodes, predefinedNodes);
// TODO: Turn validation on/off with tf env flag.
validateNodesExecutionOrder(filteredOrderedNodes, predefinedNodes);
return filteredOrderedNodes;
}
/**
* This is a helper function of `getNodesInTopologicalOrder`.
* Returns ordered nodes reachable by at least one predefined node.
* This can help us filter out redundant nodes from the returned node list.
* For example:
* If we have four nodes with dependencies like this:
* a --> b --> c --> d
* when node `c` is predefined (e.g. given as an input tensor), we can
* skip node `a` and `b` since their outputs will never be used.
*
* @param orderedNodes Graph nodes in execution order.
* @param predefinedNodes Graph inputs, weights, and init nodes. Nodes in this
* list must have distinct names.
*/
function filterPredefinedReachableNodes(orderedNodes, predefinedNodes) {
const nameToNode = new Map(orderedNodes.map((node) => [node.name, node]));
// TODO: Filter out more nodes when >=2 nodes are predefined in a path.
const stack = predefinedNodes.map((node) => node.name);
const predefinedReachableNodeNames = new Set(stack);
// Perform a DFS starting from the set of all predefined nodes
// to find the set of all nodes reachable from the predefined nodes.
while (stack.length > 0) {
const nodeName = stack.pop();
const node = nameToNode.get(nodeName);
for (const child of node.children) {
if (!nameToNode.has(child.name) ||
predefinedReachableNodeNames.has(child.name)) {
continue;
}
predefinedReachableNodeNames.add(child.name);
stack.push(child.name);
}
}
// Filter out unreachable nodes and build the ordered node list.
const filteredOrderedNodes = orderedNodes.filter((node) => predefinedReachableNodeNames.has(node.name));
return filteredOrderedNodes;
}
class NodesExecutionOrderError extends Error {
constructor(message) {
super(`NodesExecutionOrderError: ${message}`);
}
}
/**
* This is a helper function of `getNodesInTopologicalOrder`.
* Validates property: given nodes `a` and `b`, Order(a) > Order(b) if `a`
* is a child of `b`. This function throws an error if validation fails.
*
* @param orderedNodes Graph nodes in execution order.
* @param predefinedNodes Graph inputs, weights, and init nodes. Nodes in this
* list must have distinct names.
*/
function validateNodesExecutionOrder(orderedNodes, predefinedNodes) {
const nodeNameToOrder = new Map(orderedNodes.map((node, order) => [node.name, order]));
const predefinedNodeNames = new Set(predefinedNodes.map((node) => node.name));
const isPredefined = (node) => predefinedNodeNames.has(typeof node === 'string' ? node : node.name);
const willBeExecutedNodeNames = new Set(orderedNodes.map((node) => node.name));
const willBeExecuted = (node) => willBeExecutedNodeNames.has(typeof node === 'string' ? node : node.name);
for (const node of orderedNodes) {
for (const child of node.children.filter(willBeExecuted)) {
if (!nodeNameToOrder.has(child.name)) {
throw new NodesExecutionOrderError(`Child ${child.name} of node ${node.name} is unreachable.`);
}
if (nodeNameToOrder.get(node.name) > nodeNameToOrder.get(child.name)) {
throw new NodesExecutionOrderError(`Node ${node.name} is scheduled to run after its child ${child.name}.`);
}
}
if (!isPredefined(node)) {
for (const input of node.inputs) {
if (!nodeNameToOrder.has(input.name)) {
throw new NodesExecutionOrderError(`Input ${input.name} of node ${node.name} is unreachable.`);
}
if (nodeNameToOrder.get(input.name) > nodeNameToOrder.get(node.name)) {
throw new NodesExecutionOrderError(`Node ${node.name} is scheduled to run before its input ${input.name}.`);
}
}
}
}
}
/**
* Given the execution info, return a map from node name to the disposable
* node name list after its execution.
*
* @returns A map from node name to disposable nodes after its
* execution. That is, for a node `x`, `nodeLiveUntilMap[x]` indicates
* all nodes which their intermediate tensors should be disposed after `x`
* being executed.
*/
export function getNodeLiveUntilMap(orderedNodes) {
const nodeNameToOrder = new Map(orderedNodes.map((node, order) => [node.name, order]));
const INF_LIFE = Number.MAX_SAFE_INTEGER;
// Make control flow nodes (and consequently their direct parents)
// live forever since they're tricky to track correctly.
const selfLifespans = orderedNodes.map((node, nodeOrder) => isControlFlow(node) ? INF_LIFE : nodeOrder);
const getSelfLifeSpan = (node) => {
const selfLife = selfLifespans[nodeNameToOrder.get(node.name)];
if (selfLife == null) {
// If nodeToOrder does not contain the node, it is unused or
// unreachable in graph.
return -1;
}
return selfLife;
};
// `liveUntil[i]` points to the last node in the `orderedNodes` array that
// may depend on tensors from node `i`. It indicates that all the
// intermediate tensors from `orderedNodes[i]` should be disposed after
// `orderedNodes[liveUntil[i]]` is executed.
// A node lives long enough to pass on its tensors to its children.
// It lives until at least `max(node's position, children's positions)`.
const liveUntilOrders = orderedNodes.map((node, nodeOrder) => {
return node.children.map(getSelfLifeSpan)
.reduce((a, b) => Math.max(a, b), selfLifespans[nodeOrder]);
});
// liveUntilMap:
// - Key: Name of a node `x`
// - Values: All nodes whose intermediate tensors should be disposed
// after `x` is executed.
const liveUntilMap = new Map();
for (let nodeOrder = 0; nodeOrder < orderedNodes.length; ++nodeOrder) {
const liveUntilOrder = liveUntilOrders[nodeOrder];
if (liveUntilOrder === INF_LIFE) {
continue;
}
const node = orderedNodes[nodeOrder];
const liveUntilNode = orderedNodes[liveUntilOrder];
if (!liveUntilMap.has(liveUntilNode.name)) {
liveUntilMap.set(liveUntilNode.name, []);
}
liveUntilMap.get(liveUntilNode.name).push(node);
}
return liveUntilMap;
}
const CONTROL_FLOW_OPS = new Set([
'Switch', 'Merge', 'Enter', 'Exit', 'NextIteration', 'StatelessIf',
'StatelessWhile', 'if', 'While'
]);
const DYNAMIC_SHAPE_OPS = new Set([
'NonMaxSuppressionV2', 'NonMaxSuppressionV3', 'NonMaxSuppressionV5', 'Where'
]);
const HASH_TABLE_OPS = new Set([
'HashTable', 'HashTableV2', 'LookupTableImport', 'LookupTableImportV2',
'LookupTableFind', 'LookupTableFindV2', 'LookupTableSize', 'LookupTableSizeV2'
]);
export function isControlFlow(node) {
return CONTROL_FLOW_OPS.has(node.op);
}
export function isDynamicShape(node) {
return DYNAMIC_SHAPE_OPS.has(node.op);
}
export function isHashTable(node) {
return HASH_TABLE_OPS.has(node.op);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"model_analysis.js","sourceRoot":"","sources":["../../../../../../tfjs-converter/src/executor/model_analysis.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2019 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\nimport {NamedTensorMap} from '@tensorflow/tfjs-core';\n\nimport {NamedTensorsMap} from '../data/types';\nimport {parseNodeName} from '../operations/executors/utils';\nimport {Graph, Node} from '../operations/types';\n\nexport interface ExecutionInfo {\n  inputs: NamedTensorMap;\n  outputs: Node[];\n  usedNodes: Set<string>;\n  missingInputs: string[];\n  dynamicNode: Node;\n  syncInputs: string[];\n}\n\n/**\n * Given graph inputs and desired outputs, find the minimal set of nodes\n * to execute in order to compute the outputs. In addition return other useful\n * info such:\n * - Missing inputs needed to compute the output.\n * - Whether the subgraph contains dynamic ops (control flow, dynamic shape).\n * - Alternative inputs in order to avoid async (dynamic op) execution.\n */\nexport function getExecutionSubgraph(\n    inputs: NamedTensorMap, outputs: Node[], weightMap: NamedTensorsMap,\n    initNodes?: Node[]): ExecutionInfo {\n  const usedNodes = new Set<string>();\n  const missingInputs: string[] = [];\n  let dynamicNode: Node = null;\n  let syncInputs: string[] = null;\n\n  // Start with the outputs, going backwards and find all the nodes that are\n  // needed to compute those outputs.\n  const seen = new Set<string>();\n  const inputNodeNames =\n      new Set(Object.keys(inputs).map((name) => parseNodeName(name)[0]));\n\n  initNodes = initNodes || [];\n  const initNodeNames =\n      new Set(initNodes.map((node) => parseNodeName(node.name)[0]));\n\n  const frontier = [...outputs];\n  while (frontier.length > 0) {\n    const node = frontier.pop();\n    if (isControlFlow(node) || isDynamicShape(node) || isHashTable(node)) {\n      if (dynamicNode == null) {\n        dynamicNode = node;\n        syncInputs = dynamicNode.children.map(child => child.name)\n                         .filter(name => usedNodes.has(name));\n      }\n    }\n    usedNodes.add(node.name);\n\n    // Weights are dead end since we already have their values.\n    if (weightMap[node.name] != null) {\n      continue;\n    }\n    // This node is a dead end since it's one of the user-provided inputs.\n    if (inputNodeNames.has(node.name)) {\n      continue;\n    }\n    // This node is a dead end since it doesn't have any inputs.\n    if (initNodeNames.has(node.name)) {\n      continue;\n    }\n    if (node.inputs.length === 0) {\n      missingInputs.push(node.name);\n      continue;\n    }\n    node.inputs.forEach(input => {\n      // Don't add to the frontier if it is already there.\n      if (seen.has(input.name)) {\n        return;\n      }\n      seen.add(input.name);\n      frontier.push(input);\n    });\n  }\n  return {inputs, outputs, usedNodes, missingInputs, dynamicNode, syncInputs};\n}\n\n/**\n * Given the execution info, return a list of nodes in topological order that\n * need to be executed to compute the output.\n */\nexport function getNodesInTopologicalOrder(\n    graph: Graph, executionInfo: ExecutionInfo): Node[] {\n  const {usedNodes, inputs} = executionInfo;\n  const inputNodes = Object.keys(inputs)\n                         .map(name => parseNodeName(name)[0])\n                         .map(name => graph.nodes[name]);\n  const initNodes = graph.initNodes || [];\n\n  const isUsed = (node: Node|string) =>\n      usedNodes.has(typeof node === 'string' ? node : node.name);\n\n  function unique(nodes: Node[]): Node[] {\n    return [...new Map(nodes.map((node) => [node.name, node])).values()];\n  }\n  const predefinedNodes = unique([\n                            ...inputNodes,\n                            ...graph.weights,\n                            ...initNodes,\n                          ]).filter(isUsed);\n  const allNodes = unique([\n                     ...predefinedNodes,\n                     ...Object.values(graph.nodes),\n                   ]).filter(isUsed);\n  const nameToNode =\n      new Map<string, Node>(allNodes.map((node) => [node.name, node]));\n\n  const inCounts: Record<string, number> = {};\n  for (const node of allNodes) {\n    inCounts[node.name] = inCounts[node.name] || 0;\n    for (const child of node.children) {\n      // When the child is unused, set in counts to infinity so that it will\n      // never be decreased to 0 and added to the execution list.\n      if (!isUsed(child)) {\n        inCounts[child.name] = Number.POSITIVE_INFINITY;\n      }\n      inCounts[child.name] = (inCounts[child.name] || 0) + 1;\n    }\n  }\n\n  // Build execution order for all used nodes regardless whether they are\n  // predefined or not.\n  const frontier = Object.entries(inCounts)\n                       .filter(([, inCount]) => inCount === 0)\n                       .map(([name]) => name);\n  const orderedNodeNames = [...frontier];\n  while (frontier.length > 0) {\n    const nodeName = frontier.pop();\n    const node = nameToNode.get(nodeName)!;\n    for (const child of node.children.filter(isUsed)) {\n      if (--inCounts[child.name] === 0) {\n        orderedNodeNames.push(child.name);\n        frontier.push(child.name);\n      }\n    }\n  }\n\n  const orderedNodes = orderedNodeNames.map((name) => nameToNode.get(name));\n  const filteredOrderedNodes =\n      filterPredefinedReachableNodes(orderedNodes, predefinedNodes);\n\n  // TODO: Turn validation on/off with tf env flag.\n  validateNodesExecutionOrder(filteredOrderedNodes, predefinedNodes);\n\n  return filteredOrderedNodes;\n}\n\n/**\n * This is a helper function of `getNodesInTopologicalOrder`.\n * Returns ordered nodes reachable by at least one predefined node.\n * This can help us filter out redundant nodes from the returned node list.\n * For example:\n * If we have four nodes with dependencies like this:\n *   a --> b --> c --> d\n * when node `c` is predefined (e.g. given as an input tensor), we can\n * skip node `a` and `b` since their outputs will never be used.\n *\n * @param orderedNodes Graph nodes in execution order.\n * @param predefinedNodes Graph inputs, weights, and init nodes. Nodes in this\n *     list must have distinct names.\n */\nfunction filterPredefinedReachableNodes(\n    orderedNodes: Node[], predefinedNodes: Node[]) {\n  const nameToNode =\n      new Map<string, Node>(orderedNodes.map((node) => [node.name, node]));\n\n  // TODO: Filter out more nodes when >=2 nodes are predefined in a path.\n  const stack = predefinedNodes.map((node) => node.name);\n  const predefinedReachableNodeNames = new Set(stack);\n  // Perform a DFS starting from the set of all predefined nodes\n  // to find the set of all nodes reachable from the predefined nodes.\n  while (stack.length > 0) {\n    const nodeName = stack.pop();\n    const node = nameToNode.get(nodeName)!;\n    for (const child of node.children) {\n      if (!nameToNode.has(child.name) ||\n          predefinedReachableNodeNames.has(child.name)) {\n        continue;\n      }\n      predefinedReachableNodeNames.add(child.name);\n      stack.push(child.name);\n    }\n  }\n\n  // Filter out unreachable nodes and build the ordered node list.\n  const filteredOrderedNodes = orderedNodes.filter(\n      (node) => predefinedReachableNodeNames.has(node.name));\n\n  return filteredOrderedNodes;\n}\n\nclass NodesExecutionOrderError extends Error {\n  constructor(message: string) {\n    super(`NodesExecutionOrderError: ${message}`);\n  }\n}\n\n/**\n * This is a helper function of `getNodesInTopologicalOrder`.\n * Validates property: given nodes `a` and `b`, Order(a) > Order(b) if `a`\n * is a child of `b`. This function throws an error if validation fails.\n *\n * @param orderedNodes Graph nodes in execution order.\n * @param predefinedNodes Graph inputs, weights, and init nodes. Nodes in this\n *     list must have distinct names.\n */\nfunction validateNodesExecutionOrder(\n    orderedNodes: Node[], predefinedNodes: Node[]) {\n  const nodeNameToOrder = new Map<string, number>(\n      orderedNodes.map((node, order) => [node.name, order]));\n  const predefinedNodeNames = new Set(predefinedNodes.map((node) => node.name));\n  const isPredefined = (node: Node|string) =>\n      predefinedNodeNames.has(typeof node === 'string' ? node : node.name);\n  const willBeExecutedNodeNames =\n      new Set(orderedNodes.map((node) => node.name));\n  const willBeExecuted = (node: Node|string) =>\n      willBeExecutedNodeNames.has(typeof node === 'string' ? node : node.name);\n\n  for (const node of orderedNodes) {\n    for (const child of node.children.filter(willBeExecuted)) {\n      if (!nodeNameToOrder.has(child.name)) {\n        throw new NodesExecutionOrderError(\n            `Child ${child.name} of node ${node.name} is unreachable.`);\n      }\n      if (nodeNameToOrder.get(node.name) > nodeNameToOrder.get(child.name)) {\n        throw new NodesExecutionOrderError(`Node ${\n            node.name} is scheduled to run after its child ${child.name}.`);\n      }\n    }\n    if (!isPredefined(node)) {\n      for (const input of node.inputs) {\n        if (!nodeNameToOrder.has(input.name)) {\n          throw new NodesExecutionOrderError(\n              `Input ${input.name} of node ${node.name} is unreachable.`);\n        }\n        if (nodeNameToOrder.get(input.name) > nodeNameToOrder.get(node.name)) {\n          throw new NodesExecutionOrderError(`Node ${\n              node.name} is scheduled to run before its input ${input.name}.`);\n        }\n      }\n    }\n  }\n}\n\n/**\n * Given the execution info, return a map from node name to the disposable\n * node name list after its execution.\n *\n * @returns A map from node name to disposable nodes after its\n *     execution. That is, for a node `x`, `nodeLiveUntilMap[x]` indicates\n *     all nodes which their intermediate tensors should be disposed after `x`\n *     being executed.\n */\nexport function getNodeLiveUntilMap(orderedNodes: Node[]): Map<string, Node[]> {\n  const nodeNameToOrder = new Map<string, number>(\n      orderedNodes.map((node, order) => [node.name, order]));\n\n  const INF_LIFE = Number.MAX_SAFE_INTEGER;\n  // Make control flow nodes (and consequently their direct parents)\n  // live forever since they're tricky to track correctly.\n  const selfLifespans = orderedNodes.map(\n      (node, nodeOrder) => isControlFlow(node) ? INF_LIFE : nodeOrder);\n  const getSelfLifeSpan = (node: Node) => {\n    const selfLife = selfLifespans[nodeNameToOrder.get(node.name)!];\n    if (selfLife == null) {\n      // If nodeToOrder does not contain the node, it is unused or\n      // unreachable in graph.\n      return -1;\n    }\n    return selfLife;\n  };\n\n  // `liveUntil[i]` points to the last node in the `orderedNodes` array that\n  // may depend on tensors from node `i`. It indicates that all the\n  // intermediate tensors from `orderedNodes[i]` should be disposed after\n  // `orderedNodes[liveUntil[i]]` is executed.\n  // A node lives long enough to pass on its tensors to its children.\n  // It lives until at least `max(node's position, children's positions)`.\n  const liveUntilOrders = orderedNodes.map((node, nodeOrder) => {\n    return node.children.map(getSelfLifeSpan)\n        .reduce((a, b) => Math.max(a, b), selfLifespans[nodeOrder]);\n  });\n\n  // liveUntilMap:\n  // - Key: Name of a node `x`\n  // - Values: All nodes whose intermediate tensors should be disposed\n  //           after `x` is executed.\n  const liveUntilMap = new Map<string, Node[]>();\n  for (let nodeOrder = 0; nodeOrder < orderedNodes.length; ++nodeOrder) {\n    const liveUntilOrder = liveUntilOrders[nodeOrder];\n    if (liveUntilOrder === INF_LIFE) {\n      continue;\n    }\n    const node = orderedNodes[nodeOrder];\n    const liveUntilNode = orderedNodes[liveUntilOrder];\n    if (!liveUntilMap.has(liveUntilNode.name)) {\n      liveUntilMap.set(liveUntilNode.name, []);\n    }\n    liveUntilMap.get(liveUntilNode.name)!.push(node);\n  }\n  return liveUntilMap;\n}\n\nconst CONTROL_FLOW_OPS = new Set([\n  'Switch', 'Merge', 'Enter', 'Exit', 'NextIteration', 'StatelessIf',\n  'StatelessWhile', 'if', 'While'\n]);\nconst DYNAMIC_SHAPE_OPS = new Set([\n  'NonMaxSuppressionV2', 'NonMaxSuppressionV3', 'NonMaxSuppressionV5', 'Where'\n]);\nconst HASH_TABLE_OPS = new Set([\n  'HashTable', 'HashTableV2', 'LookupTableImport', 'LookupTableImportV2',\n  'LookupTableFind', 'LookupTableFindV2', 'LookupTableSize', 'LookupTableSizeV2'\n]);\n\nexport function isControlFlow(node: Node) {\n  return CONTROL_FLOW_OPS.has(node.op);\n}\n\nexport function isDynamicShape(node: Node) {\n  return DYNAMIC_SHAPE_OPS.has(node.op);\n}\n\nexport function isHashTable(node: Node) {\n  return HASH_TABLE_OPS.has(node.op);\n}\n"]}