async predictAsync(inputs, config) {
        const outputTensors = await this.executeAsync(inputs, this.outputNodes);
        return this.addStructuredOutputNames(outputTensors);
    }
Execute the inference for the input tensors in async fashion, use this
method when your model contains control flow ops.

@param input The input tensors, when there is single input for the model,
inputs param should be a `tf.Tensor`. For models with mutliple inputs,
inputs params should be in either `tf.Tensor`[] if the input order is
fixed, or otherwise NamedTensorMap format.

For model with multiple inputs, we recommend you use NamedTensorMap as the
input type, if you use `tf.Tensor`[], the order of the array needs to
follow the
order of inputNodes array. @see {@link GraphModel.inputNodes}

You can also feed any intermediate nodes using the NamedTensorMap as the
input type. For example, given the graph
   InputNode => Intermediate => OutputNode,
you can execute the subgraph Intermediate => OutputNode by calling
   model.execute('IntermediateNode' : tf.tensor(...));

This is useful for models that uses tf.dynamic_rnn, where the intermediate
state needs to be fed manually.

For batch inference execution, the tensors for each input need to be
concatenated together. For example with mobilenet, the required input shape
is [1, 244, 244, 3], which represents the [batch, height, width, channel].
If we are provide a batched data of 100 images, the input tensor should be
in the shape of [100, 244, 244, 3].

@param config Prediction configuration for specifying the batch size.
Currently the batch size option is ignored for graph model.

@returns A Promise of inference result tensors. If the model is converted
and it originally had structured_outputs in tensorflow, then a
NamedTensorMap will be returned matching the structured_outputs. If no
structured_outputs are present, the output will be single `tf.Tensor` if
the model has single output node, otherwise Tensor[].

@doc {heading: 'Models', subheading: 'Classes'}