tvm.relay.frontend¶
Frontends for constructing Relay programs.
Contains the model importers currently defined for Relay.
Functions:
|
Convert from MXNet"s model into compatible relay Function. |
|
Quantized conv2d bias |
|
Convert keras model to relay Function. |
|
Convert a OneFlow model into an equivalent Relay Function. |
|
Convert a ONNX model into an equivalent Relay Function. |
|
Convert from tflite model into compatible relay Function. |
|
Convert from coreml model into Relay Function. |
|
Load caffe2 graph which contains init_net and predict_net into Relay Function. |
|
Load tensorflow graph which is a python tensorflow graph object into relay. |
|
Convert from Darknet's model into compatible relay Function. |
|
Load PyTorch model in the form of a scripted PyTorch model and convert into relay. |
|
Convert from caffe model into compatible relay Function. |
|
Convert a PaddlePaddle model into an equivalent Relay Function. |
Classes:
|
Mutator for changing the datatype of Relay programs. |
- tvm.relay.frontend.from_mxnet(symbol, shape=None, dtype='float32', arg_params=None, aux_params=None)¶
Convert from MXNet”s model into compatible relay Function.
- Parameters
symbol (mxnet.Symbol or mxnet.gluon.HybridBlock) – MXNet symbol.
shape (dict of str to tuple, optional) – The input shape to the graph
dtype (str or dict of str to str) – The input types to the graph
arg_params (dict of str to mx.NDArray) – The argument parameters in mxnet
aux_params (dict of str to mx.NDArray) – The auxiliary parameters in mxnet
- Returns
mod (tvm.IRModule) – The relay module for compilation
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by nnvm
- tvm.relay.frontend.quantize_conv_bias_mkldnn_from_var(bias_var, bias_scale)¶
Quantized conv2d bias
- tvm.relay.frontend.from_keras(model, shape=None, layout='NCHW')¶
Convert keras model to relay Function.
- Parameters
model (keras.engine.training.Model or tensorflow.keras.models.Model) – The keras model to be converted.
shape (dict of str to int list/tuple) – Input shapes of the model, optional
layout (str) – One of ‘NCHW’ or ‘NHWC’, indicates how data should be arranged in the output model. Default layout is ‘NCHW’ as it in general performs better across TVM.
- Returns
mod (tvm.IRModule) – The relay module for compilation.
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by Relay.
- tvm.relay.frontend.from_oneflow(graph, model_dir_path)¶
Convert a OneFlow model into an equivalent Relay Function.
At present, there are two ways to run models in deep learning framework Dynamic Graph and Static Graph, which are also called Eager Mode and Graph Mode in OneFlow.
In general, dynamic graphs are easier to use and static graphs have better performance. OneFlow offers nn.Graph, so that users can use the eager-like programming style to build static graphs and train the models.
We utilize the intermediate representation of nn.Graph to convert the OneFlow model to Reley.
- tvm.relay.frontend.from_onnx(model, shape=None, dtype='float32', opset=None, freeze_params=True, convert_config=None)¶
Convert a ONNX model into an equivalent Relay Function.
ONNX graphs are represented as Python Protobuf objects. The companion parameters will be handled automatically. However, the input names from onnx graph is vague, mixing inputs and network weights/bias such as “1”, “2”… For convenience, we rename the real input names to “input_0”, “input_1”… And renaming parameters to “param_0”, “param_1”…
By default, ONNX defines models in terms of dynamic shapes. The ONNX importer retains that dynamism upon import, and the compiler attempts to convert the model into a static shapes at compile time. If this fails, there may still be dynamic operations in the model. Not all TVM kernels currently support dynamic shapes, please file an issue on discuss.tvm.apache.org if you hit an error with dynamic kernels.
- Parameters
model (protobuf object) – ONNX ModelProto after ONNX v1.1.0
shape (dict of str to tuple, optional) – The input shape to the graph
dtype (str or dict of str to str) – The input types to the graph
opset (int, optional) – Override to autodetected opset. This can be helpful for some testing.
freeze_params (bool) – If this parameter is true, the importer will take any provided onnx input values (weights, shapes, etc) and embed them into the relay model as Constants instead of variables. This allows more aggressive optimizations at compile time and helps in making models static if certain inputs represent attributes relay would traditionally consider compile-time constants.
convert_config (Optional[Dict[str, Any]]) –
- Default config:
- use_nt_batch_matmulbool = True
True to convert qualified onnx matmul to nn.batch_matmul strict to NT format (transpose_a=False, transpose_b=True).
- Returns
mod (tvm.IRModule) – The relay module for compilation
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by relay
- tvm.relay.frontend.from_tflite(model, shape_dict=None, dtype_dict=None, op_converter=<class 'tvm.relay.frontend.tflite.OperatorConverter'>)¶
Convert from tflite model into compatible relay Function.
- Parameters
model – tflite.Model or tflite.Model.Model (depending on tflite version)
shape_dict (dict of str to int list/tuple) – Input shapes of the model.
dtype_dict (dict of str to str) – Input types of the model.
- Returns
mod (tvm.IRModule) – The relay module for compilation.
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by relay
- tvm.relay.frontend.from_coreml(model, shape=None)¶
Convert from coreml model into Relay Function.
- Parameters
model – coremltools.models.MLModel of a NeuralNetworkClassifier
shape (dict of str to int list/tuple, optional) – The input shapes
- Returns
mod (tvm.IRModule) – The relay module for compilation.
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by Relay.
- tvm.relay.frontend.from_caffe2(init_net, predict_net, shape=None, dtype='float32')¶
Load caffe2 graph which contains init_net and predict_net into Relay Function.
- Parameters
init_net (protobuf object) – Caffe2 NetDef containing the weights
predict_net (protobuf object) – Caffe2 NetDef containing the graph
shape (dict of str to tuple) – The input shape to the graph
dtype (str or dict of str to str) – The input types to the graph
- Returns
mod (tvm.IRModule) – The module that optimizations will be performed on.
params (dict of str to tvm.nd.NDArray) – Dict of converted parameters stored in tvm.nd.NDArray format
- tvm.relay.frontend.from_tensorflow(graph, layout='NHWC', shape=None, outputs=None, convert_config=None)¶
Load tensorflow graph which is a python tensorflow graph object into relay. The companion parameters will be handled automatically.
- Parameters
graph (GraphDef object) – Tensorflow GraphDef
layout (target layout to be used (Optional)) – NCHW only supported now to enable NHWC models on GPU.
shape (Dictionary of input dimensions (Optional)) – Graph level input shape dictionary.
outputs (List of output tensor names (Optional)) – if not specified then the last node is assumed as graph output.
convert_config (Optional[Dict[str, Any]]) –
- Default config:
- use_densebool = True
Ture to convert tf.matmul to nn.dense, else to nn.matmul. The nn.dense op requires the data tensor to be non-transposed and weight tensor to be transposed, may insert extra transpose to the original graph.
- use_nt_batch_matmulbool = True
True to convert tf.batch_matmul to nn.batch_matmul strict to NT format (transpose_a=False, transpose_b=True).
- Returns
mod (tvm.IRModule) – The module that optimizations will be performed on.
params (dict of str to tvm.nd.NDArray) – Dict of converted parameters stored in tvm.nd.NDArray format
- tvm.relay.frontend.from_darknet(net, shape=None, dtype='float32')¶
Convert from Darknet’s model into compatible relay Function.
- Parameters
net (Darknet net parameter) – Darknet net structure.
shape (dict of str to tuple, optional) – The input shape to the graph
dtype (str or dict of str to str) – The input types to the graph
- Returns
mod (tvm.IRModule) – The relay module for compilation.
params (dict of str to tvm.nd.NDArray) – The parameter dict to be used by relay
- tvm.relay.frontend.from_pytorch(script_module, input_infos, custom_convert_map=None, default_dtype='float32', use_parser_friendly_name=False, keep_quantized_weight=False)¶
Load PyTorch model in the form of a scripted PyTorch model and convert into relay. The companion parameters will be handled automatically.
- Parameters
script_module (TopLevelTracedModule object) – TorchScripted PyTorch graph Note: We currently only support traces (ie: torch.jit.trace(model, input))
input_infos (List of tuples) – Can be (input name, input shape) or (input name, (input shape, input types)) Graph level input shape and type list The same input names need to be used for deployment, so choose easy to remember names (such as: input0, input1) e.g. [(‘input0’, (1, 2)), (‘input1’, (3, 4))] or [(‘input0’, ((1, 2), ‘int’)), (‘input1’, ((3, 4), ‘float’))]
custom_convert_map (Dictionary of str to Relay op) – A custom op conversion map in the same format as _convert_map above
default_type (str) – The default dtype to use when type information is not provided by PyTorch.
use_parser_friendly_name (bool) – When True, replace ‘.’ with `_’ in a original parameter name. The Relay text parser treats a variable name followed by a period as a tuple element access, so a variable name like “dense.weight” cannot be parsed correctly. Use this option when you want to run the AnnotateSpans pass on the imported module.
keep_quantized_weight (bool) – Return quantized weights and bias, rather than float ones. PyTorch stores quantized weights in a custom format, so we cannot directly access 8 bit weights as Numpy arrays. We use a PyTorch function to unpack quantized weights into float32 arrays and quantization parameters. By default, we return float32 weights and rely on the QNN lowering and the Relay constant folding pass to quantize weights at compile time. In BYOC use cases, however, we cannot apply the constant folding pass on a QNN graph. If keep_quantized_weight is True, we quantize weights in the frontend using a function that is equivalent to qnn.op.quantize(…) operating on Numpy arrays.
- Returns
mod (tvm.IRModule) – The module that optimizations will be performed on.
params (dict of str to tvm.runtime.NDArray) – Dict of converted parameters stored in tvm.runtime.ndarray format
- tvm.relay.frontend.from_caffe(init_net, predict_net, shape_dict, dtype_dict)¶
Convert from caffe model into compatible relay Function.
- Parameters
init_net (caffe_pb2.NetParameter) – caffemodel
predict_net (caffe_pb2.NetParameter) – caffe prototxt
shape_dict (dict of str to int list/tuple) – Input shapes of the model.
dtype_dict (dict of str to str) – Input types of the model.
- Returns
mod (tvm.IRModule) – The relay module for compilation.
params (dict of str to tvm.NDArray) – The parameter dict to be used by relay
- tvm.relay.frontend.from_paddle(program_or_layer, shape_dict=None, scope=None)¶
Convert a PaddlePaddle model into an equivalent Relay Function. PaddlePaddle Program/TranslatedLayer represent the computation graph of PaddlePaddle model, and PaddlePaddle scope stores all the weights of PaddlePaddle model.
- Parameters
program_or_layer (object of paddle.static.Program or paddle.jit.TranslatedLayer) – Loaded model by paddle.static.load_inference_model or paddle.jit.load
shape_dict (dict of str to tuple/list, optional) – The input shape of model
scope (object of paddle.static.Scope, optional) – The scope that saves all the weights of model, use paddle.static.global_scope by default
- Returns
mod (tvm.IRModule) – The relay module for compilation
params (dict of str to tvm.nd.NDArray)
- class tvm.relay.frontend.ChangeDatatype(src, dst)¶
Mutator for changing the datatype of Relay programs.
This pass should be useful for users of the Bring Your Own Datatypes framework. TODO(@gussmith23 @hypercubestart) Add link to documentation when it exists
Example:
from tvm.relay.testing.inception_v3 import get_workload mod, params = get_workload() def change_dtype(mod, params, src, dst): mod = ChangeDatatype(src, dst)(mod) params = dict((p, tvm.nd.array(params[p].numpy().astype(dst))) for p in params) return mod, params mod, params = change_dtype(mod, params, "float32", "custom[posites2]32")
- Parameters
- Returns
mod – Module where all nodes of dtype src have been changed to have dtype dst.
- Return type
tvm.IRModule