def printable_type(t: TypeProto) -> Text:
if t.WhichOneof('value') == "tensor_type":
s = TensorProto.DataType.Name(t.tensor_type.elem_type)
if t.tensor_type.HasField('shape'):
if len(t.tensor_type.shape.dim):
s += str(', ' + 'x'.join(map(printable_dim, t.tensor_type.shape.dim)))
else:
s += str(', scalar')
return s
if t.WhichOneof('value') is None:
return ""
return 'Unknown type {}'.format(t.WhichOneof('value'))
def test_attr_type_proto(self): # type: () -> None
# type_proto
type = TypeProto()
attr = helper.make_attribute("type_proto", type)
self.assertEqual(attr.name, "type_proto")
self.assertEqual(attr.tp, type)
self.assertEqual(attr.type, AttributeProto.TYPE_PROTO)
# type_protos
types = [TypeProto(), TypeProto()]
attr = helper.make_attribute("type_protos", types)
self.assertEqual(attr.name, "type_protos")
self.assertEqual(list(attr.type_protos), types)
self.assertEqual(attr.type, AttributeProto.TYPE_PROTOS)
def make_optional_type_proto(
inner_type_proto: TypeProto,
) -> TypeProto:
"""Makes an optional TypeProto."""
type_proto = TypeProto()
type_proto.optional_type.elem_type.CopyFrom(inner_type_proto)
return type_proto
def make_sequence_type_proto(
inner_type_proto: TypeProto,
) -> TypeProto:
"""Makes a sequence TypeProto."""
type_proto = TypeProto()
type_proto.sequence_type.elem_type.CopyFrom(inner_type_proto)
return type_proto
def _load_proto(self, proto_filename: Text, target_list: List[Union[np.ndarray, List[Any]]], model_type_proto: TypeProto) -> None:
with open(proto_filename, 'rb') as f:
protobuf_content = f.read()
if model_type_proto.HasField('sequence_type'):
sequence = onnx.SequenceProto()
sequence.ParseFromString(protobuf_content)
target_list.append(numpy_helper.to_list(sequence))
elif model_type_proto.HasField('tensor_type'):
tensor = onnx.TensorProto()
tensor.ParseFromString(protobuf_content)
target_list.append(numpy_helper.to_array(tensor))
elif model_type_proto.HasField('optional_type'):
optional = onnx.OptionalProto()
optional.ParseFromString(protobuf_content)
target_list.append(numpy_helper.to_optional(optional))
else:
print('Loading proto of that specific type (Map/Sparse Tensor) is currently not supported')
def _extract_shape(type_proto: TypeProto):
which_value = type_proto.WhichOneof('value')
if which_value == 'tensor_type':
tensor = type_proto.tensor_type
else:
raise ValueError
return [
dim.dim_value if dim.WhichOneof('value') == 'dim_value' else None
for dim in tensor.shape.dim[1:]
]
def make_sparse_tensor_type_proto(
elem_type: int,
shape: Optional[Sequence[Union[Text, int, None]]],
shape_denotation: Optional[List[Text]] = None,
) -> TypeProto:
"""Makes a SparseTensor TypeProto based on the data type and shape."""
type_proto = TypeProto()
sparse_tensor_type_proto = type_proto.sparse_tensor_type
sparse_tensor_type_proto.elem_type = elem_type
sparse_tensor_shape_proto = sparse_tensor_type_proto.shape
if shape is not None:
# You might think this is a no-op (extending a normal Python
# list by [] certainly is), but protobuf lists work a little
# differently; if a field is never set, it is omitted from the
# resulting protobuf; a list that is explicitly set to be
# empty will get an (empty) entry in the protobuf. This
# difference is visible to our consumers, so make sure we emit
# an empty shape!
sparse_tensor_shape_proto.dim.extend([])
if shape_denotation:
if len(shape_denotation) != len(shape):
raise ValueError(
'Invalid shape_denotation. '
'Must be of the same length as shape.')
for i, d in enumerate(shape):
dim = sparse_tensor_shape_proto.dim.add()
if d is None:
pass
elif isinstance(d, int):
dim.dim_value = d
elif isinstance(d, str):
dim.dim_param = d
else:
raise ValueError(
'Invalid item in shape: {}. '
'Needs to be of int or text.'.format(d))
if shape_denotation:
dim.denotation = shape_denotation[i]
return type_proto
