def make_node(op_type, inputs, outputs, name=None, doc_string=None, **kwargs):
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if kwargs:
node.attribute.extend(
make_attribute(key, value) for key, value in kwargs.items())
return node
def make_node(
op_type, # type: Text
inputs, # type: Sequence[Text]
outputs, # type: Sequence[Text]
name=None, # type: Optional[Text]
doc_string=None, # type: Optional[Text]
**kwargs # type: Any
): # type: (...) -> NodeProto
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if kwargs:
node.attribute.extend(
make_attribute(key, value)
for key, value in sorted(kwargs.items()))
return node
def make_node(op_type, inputs, outputs, name=None, doc_string=None, **kwargs):
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if kwargs:
node.attribute.extend(
make_attribute(key, value) for key, value in kwargs.items())
return node
def create_node_from_schema(schema):
"""
Convert an OpSchema to a NodeProto
:param schema: the input OpSchema
:return: the equivalent NodeProto
"""
node_proto = NodeProto()
for attribute in schema.attributes:
attr_value = schema.attributes[attribute]
if attr_value.default_value.name == '':
attr_value_new = onnx.helper.make_attribute(attr_value.name, '')
attr_value_new.type = convert_attr_type_to_enum(attr_value)
node_proto.attribute.append(attr_value_new)
else:
node_proto.attribute.append(attr_value.default_value)
node_proto.op_type = schema.name
node_proto.doc_string = schema.doc
node_proto.name = schema.name
for input_arr in schema.inputs:
input_types = input_arr.types
type_attr = onnx.helper.make_attribute(input_arr.name + '-types', [
str(data_type).replace('tensor(', '').replace(')', '')
for data_type in input_types
])
node_proto.attribute.append(type_attr)
if node_proto.input is None:
node_proto.input = []
node_proto.input.append(input_arr.name)
for output_arr in schema.outputs:
if node_proto.output is None:
node_proto.output = []
output_types = output_arr.types
type_attr = onnx.helper.make_attribute(
output_arr.name + '-types', [
str(data_type).replace('tensor(', '').replace(')', '')
for data_type in output_types
])
node_proto.attribute.append(type_attr)
node_proto.output.append(output_arr.name)
return node_proto
def make_node(
op_type, # type: Text
inputs, # type: Sequence[Text]
outputs, # type: Sequence[Text]
name=None, # type: Optional[Text]
doc_string=None, # type: Optional[Text]
domain=None, # type: Optional[Text]
_dtype=None, # type: [np.float32, np.float64]
**kwargs # type: Any
): # type: (...) -> NodeProto
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation
string for NodeProto
dtype: dtype for double used to infer
domain (string, default None): optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
"""
if _dtype is None:
raise ValueError("dtype cannot be None")
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if domain is not None:
node.domain = domain
if kwargs:
node.attribute.extend(
make_attribute(key, value, dtype=_dtype, domain=domain)
for key, value in sorted(kwargs.items()))
return node
def make_node(
op_type: Text,
inputs: Sequence[Text],
outputs: Sequence[Text],
name: Optional[Text] = None,
doc_string: Optional[Text] = None,
domain: Optional[Text] = None,
**kwargs: Any
) -> NodeProto:
"""Construct a NodeProto.
Arguments:
op_type (string): The name of the operator to construct
inputs (list of string): list of input names
outputs (list of string): list of output names
name (string, default None): optional unique identifier for NodeProto
doc_string (string, default None): optional documentation string for NodeProto
domain (string, default None): optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
**kwargs (dict): the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
Returns:
NodeProto
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if domain is not None:
node.domain = domain
if kwargs:
node.attribute.extend(
make_attribute(key, value)
for key, value in sorted(kwargs.items())
if value is not None)
return node
def _make_node(op_type,
inputs,
outputs,
name=None,
doc_string=None,
domain=None,
attributes=None):
"""
Constructs a NodeProto.
:param op_type: (string): The name of the operator to construct
:param inputs: list of input names
:param outputs: list of output names
:param name: optional unique identifier for NodeProto
:param doc_string: optional documentation
string for NodeProto
:param domain: optional domain for NodeProto.
If it's None, we will just use default domain (which is empty)
:param attributes: the attributes of the node. The acceptable values
are documented in :func:`make_attribute`.
:return: node
"""
node = NodeProto()
node.op_type = op_type
node.input.extend(inputs)
node.output.extend(outputs)
if name:
node.name = name
if doc_string:
node.doc_string = doc_string
if domain is not None:
node.domain = domain
if isinstance(attributes, dict):
if len(attributes) > 0:
node.attribute.extend(
make_attribute(key, value)
for key, value in sorted(attributes.items()))
elif attributes:
for att in attributes:
node.attribute.extend([att])
return node
