compile(inputs, outputs) {
        const executionInfo = (0, _modelAnalysis.getExecutionSubgraph)(inputs, outputs, this.weightMap, this._initNodes);
        const { missingInputs, dynamicNode, syncInputs } = executionInfo;
        if (dynamicNode != null) throw new Error(`This execution contains the node '${dynamicNode.name}', which has ` + `the dynamic op '${dynamicNode.op}'. Please use ` + `model.executeAsync() instead. Alternatively, to avoid the ` + `dynamic ops, specify the inputs [${syncInputs}]`);
        if (missingInputs.length > 0) {
            const outNames = outputs.map((n)=>n.name);
            const inNames = Object.keys(inputs);
            throw new Error(`Cannot compute the outputs [${outNames}] from the provided inputs ` + `[${inNames}]. Missing the following inputs: [${missingInputs}]`);
        }
        const orderedNodes = (0, _modelAnalysis.getNodesInTopologicalOrder)(this.graph, executionInfo);
        const nodeLiveUntilMap = (0, _modelAnalysis.getNodeLiveUntilMap)(orderedNodes);
        return {
            orderedNodes,
            nodeLiveUntilMap
        };
    }
Compiles the inference graph and returns the minimal set of nodes that are
required for execution, in the correct execution order.
@returns {Object} compilation The compile result.
@returns {Node[]} compilation.orderedNodes Nodes in the correct execution
    order.
@returns {Map<string, Node[]>} compilation.nodeLiveUntilMap A map from node
    to disposable nodes after its execution. That is, for a node `x`,
    `nodeLiveUntilMap[x]` indicates all nodes whose intermediate
    tensors should be disposed after `x` is executed.