def type_inference(self):
init_length = self.init_length.val
if self.elem_shape is None or self.elem_shape.sym_val is None:
return types.list(
types.unknown,
init_length=init_length,
dynamic_length=self.dynamic_length.val,
)
builtin_dtype = types.string_to_builtin(self.dtype.val)
if builtin_dtype is None:
raise ValueError("Unsupported dtype {}".format(self.dtype.val))
elem_type = types.tensor(builtin_dtype, self.elem_shape.sym_val)
return types.list(elem_type,
init_length=init_length,
dynamic_length=self.dynamic_length.val)
def __init__(self,
name,
elem_type=None,
init_length=None,
dynamic_length=True,
sym_val=None,
**kwargs):
"""
elem_type (builtin.tensor)
init_length (int): initial length
dynamic_length (bool): True to allow list to grow. False uses
init_length as the fixed size (init_length is runtime length).
sym_val: value of the list, if available
"""
super(ListVar,
self).__init__(name=name,
sym_type=types.list(elem_type, init_length,
dynamic_length),
sym_val=sym_val,
**kwargs)
self._elem_type = elem_type
self.init_length = init_length
self.dynamic_length = dynamic_length
def type_inference(self):
builtin_dtype = types.string_to_builtin(self.dtype.val)
if builtin_dtype is None:
raise ValueError("Unsupported dtype {}".format(self.dtype.val))
# Replace string with symbol
elem_shape_sym = []
for s_var in self.elem_shape:
# s is str or int
s = s_var.val
if s is None:
msg = 'make_list elem_shape must be tuple of const. ' +\
'Tuple elem {} is not'
raise ValueError(msg.format(s_var.name))
if isinstance(s, str):
try:
symbol = get_existing_symbol(s)
except ValueError:
# Must be a new symbol
symbol = get_new_symbol(s)
elem_shape_sym.append(symbol)
else:
elem_shape_sym.append(s)
elem_type = types.tensor(builtin_dtype, elem_shape_sym)
return types.list(
elem_type,
init_length=self.init_length.val,
dynamic_length=self.dynamic_length.val,
)
def type_inference(self):
list_elem_type = self.ls.elem_type
value_type = self.value.sym_type
dynamic_length = self.ls.dynamic_length
init_length = self.ls.init_length
if list_elem_type is None:
# fill in the elem type using value's type info.
return types.list(value_type,
init_length=init_length,
dynamic_length=dynamic_length)
if list_elem_type == types.unknown:
msg = "Input ls elem type unknown. Override with {}"
logging.warning(msg.format(value_type))
return types.list(value_type,
init_length=init_length,
dynamic_length=dynamic_length)
if not types.is_subtype(value_type, list_elem_type):
msg = "Elem type mismatch: ls elem type {} vs " + "value type {}"
raise ValueError(msg.format(list_elem_type, value_type))
return self.ls.sym_type
def proto_to_types(valuetype):
"""
A helper function that maps the proto value type to PyMIL types.
"""
if valuetype.WhichOneof("type") == "tensorType":
tensortype = valuetype.tensorType
dtype = types.proto_to_builtin_types[tensortype.dataType]
if tensortype.rank < 0:
raise ValueError("Negative or Dynamic ranks not supported")
if tensortype.rank != len(tensortype.dimensions):
raise ValueError("Rank doesn't match the number of dimensions")
if tensortype.attributes != {}:
raise ValueError("Attributes on tensorType not supported")
shape = []
for i in range(tensortype.rank):
shape.append(get_proto_dim(tensortype.dimensions[i]))
# For the zero rank tensor, we always convert it back to scalar in PyMIL first
if tensortype.rank == 0:
return dtype
return types.tensor(dtype, shape)
elif valuetype.WhichOneof("type") == "listType":
listtype = valuetype.listType
elem_type = proto_to_types(listtype.type)
if listtype.length.unknown:
init_length = None
else:
init_length = listtype.length.constant.size
# In the MIL proto, there is no such thing of "dynamic_length", hence we set it to True when
# converting back to PyMIL
return types.list(elem_type, init_length, dynamic_length=True)
elif valuetype.WhichOneof("type") == "dictionaryType":
dicttype = valuetype.dictionaryType
keytype = proto_to_types(dicttype.keyType)
valuetype = proto_to_types(dicttype.valueType)
return types.dict(keytype, valuetype)
else:
raise NotImplementedError("Types {} not yet implemented".format(
valuetype.WhichOneof("type")))
def type_inference(self):
num_indices = self.indices.shape[0]
num_values = self.value.shape[0]
if num_values != num_indices:
raise ValueError("Cannot scatter {} values to {} indices".format(
num_values, num_indices))
list_elem_type = self.ls.elem_type
value_type = self.value.sym_type
dynamic_length = self.ls.dynamic_length
init_length = self.ls.init_length
elem_type = types.tensor(value_type.get_primitive(),
value_type.get_shape()[1:])
if list_elem_type == types.unknown:
# fill in the elem type using value's type info.
return types.list(elem_type,
dynamic_length=dynamic_length,
init_length=init_length)
if not types.is_subtype(elem_type, list_elem_type):
msg = "Elem type mismatch: ls elem type {} vs " + "value type {}"
raise ValueError(msg.format(list_elem_type, elem_type))
return self.ls.sym_type
