def veval_with_default(nast, default_value):
if nast is None:
ret = values.NumberValue(default_value)
ret.name = '@SliceDefault'
return ret
obj = veval_ast(astc.c(nast), local_field, graph)
return try_get_value(obj, 'subscript', lineprop)
def generate_value_with_type(value: 'values.Value', type_, suffix_type = SuffixType.Unknown):
assert(isinstance(value, values.Value))
ret = None
if isinstance(value, values.TensorValue):
ret = values.TensorValue()
ret.shape = value.shape
ret.dtype = type_
elif isinstance(value, values.NumberValue):
ret = values.NumberValue(None)
ret.dtype = type_
else:
assert(False)
if suffix_type == SuffixType.Unknown:
ret.name = value.name + '_st'
elif suffix_type == SuffixType.Unused:
ret.name = value.name + '_unused'
elif suffix_type == SuffixType.Dummy:
ret.name = value.name + '_dummy'
elif suffix_type == SuffixType.Input:
ret.name = value.name + '_in'
else:
assert(False)
return ret
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
context: 'functions.VEvalContext' = None,
line=-1):
if context._for_unroll:
for ref in args.inputs:
if not ref.get_value().has_constant_value():
assert False, 'Loop unrolling was requested for non-constant sequence at %s' % line
refs = []
for num in range(*(ref.get_value().internal_value
for ref in args.inputs)):
refs.append(values.Object(values.NumberValue(num)))
value = values.ListValue(refs)
return values.Object(value)
else:
node = nodes.NodeGenerate('range',
[v.get_value() for v in args.inputs],
line)
graph.add_node(node)
value = values.RangeValue()
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.Object(value)
def __init__(self):
super().__init__()
self.name = 'array'
self.args.add_arg('object', values.NoneValue())
self.args.add_arg('dtype', values.NoneValue())
self.args.add_arg('copy', values.BoolValue(True))
self.args.add_arg('order', values.StrValue('K'))
self.args.add_arg('subok', values.BoolValue(False))
self.args.add_arg('ndmin', values.NumberValue(0))
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1):
node = nodes.NodeLen(
args.inputs[0].get_value(), # TODO: Check this.
line
)
graph.add_node(node)
value = values.NumberValue(None)
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.ValueRef(value)
def veval(op: 'nodes.UnaryOpType', value: 'values.Value'):
if isinstance(value, values.NumberValue):
if value.internal_value is not None:
if op == nodes.UnaryOpType.UAdd:
return values.NumberValue(value.internal_value)
if op == nodes.UnaryOpType.USub:
return values.NumberValue(-value.internal_value)
else:
return functions.generate_value_with_same_type(value)
else:
return functions.generate_value_with_same_type(value)
if isinstance(value, values.BoolValue):
return functions.generate_value_with_same_type(value)
if op == nodes.UnaryOpType.Not and isinstance(value, values.ListValue):
return values.BoolValue(None)
return values.Value()
def generate_copied_value(value: 'values.Value'):
assert(isinstance(value, values.Value))
if isinstance(value, values.NumberValue):
copied = values.NumberValue(value.internal_value)
copied.dtype = value.dtype
return copied
if isinstance(value, values.TensorValue):
copied = values.TensorValue()
copied.value = value.value
copied.shape = value.shape
copied.dtype = value.dtype
return copied
if isinstance(value, values.ListValue):
copied = values.ListValue()
copied.dtype = value.dtype
copied.vtype = value.vtype
if value.internal_value is not None:
copied.internal_value = value.internal_value.copy()
return copied
if isinstance(value, values.NoneValue):
copied = values.NoneValue()
return copied
if isinstance(value, values.BoolValue):
copied = values.BoolValue(value.internal_value)
return copied
if isinstance(value, values.StrValue):
copied = values.StrValue(value.internal_value)
return copied
if isinstance(value, values.RangeValue):
copied = values.RangeValue()
return copied
if isinstance(value, values.TupleValue):
if value.internal_value is not None:
copied = values.TupleValue(value.internal_value.copy())
else:
copied = values.TupleValue(value.internal_value)
copied.dtype = value.dtype
copied.vtype = value.vtype
return copied
if config.show_warnings:
print('Unknown type {} is copied'.format(value))
return values.Value()
def veval_ast_num(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. 1, 2, ...
'''
assert (isinstance(astc.nast, gast.gast.Num))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
value = values.NumberValue(astc.nast.n)
ret = values.ValueRef(value)
name = values.create_ref_value_name_with_constant(ret)
ret.name = name
ret.get_value().name = name
return ret
def veval(op: 'nodes.BinOpType', left: 'values.Value', right: 'values.Value',
lineprop: 'utils.LineProperty'):
initialize_lazy()
if isinstance(left, values.ListValue):
return functions.generate_value_with_same_type(left)
if isinstance(left, values.TupleValue):
return functions.generate_value_with_same_type(left)
if isinstance(right, values.NumberValue) or isinstance(
right, values.TensorValue):
if not isinstance(left, values.NumberValue) and not isinstance(
left, values.TensorValue):
utils.print_warning('Unestimated type is on left', lineprop)
left = values.NumberValue(0.0)
left_type = left.dtype
right_type = right.dtype
if not config.float_restrict:
if left_type == utils.dtype_float64:
left_type = utils.dtype_float32
if right_type == utils.dtype_float64:
right_type = utils.dtype_float32
if left_type is None:
left_type = np.array(0.0, np.float32).dtype
if right_type is None:
right_type = np.array(0.0, np.float32).dtype
result_type = None
for v in binop_type_table:
if v[0] == op and v[1] == left_type and v[2] == right_type:
result_type = v[3]
break
assert (result_type is not None)
if isinstance(right, values.TensorValue):
return functions.generate_value_with_type(right, type_=result_type)
else:
return functions.generate_value_with_type(left, type_=result_type)
return values.Value()
def vcall(self,
module: 'Field',
graph: 'Graph',
inst: 'values.ValueRef',
args: 'functions.FunctionArgInput',
line=-1):
args = functions.FunctionArgInput()
args.inputs.append(inst)
args.keywords['self'] = inst
node = nodes.NodeCall(self, args, line)
value = values.NumberValue(None)
value.dtype = np.array(0).dtype
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
graph.add_node(node)
return values.ValueRef(value)
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
context: 'functions.VEvalContext' = None,
line=-1):
node = nodes.NodeCall(self, args, line)
graph.add_node(node)
item = args.get_value().inputs[0]
default_value = None
# constant propagation whenever possible
if item.has_constant_value():
default_value = len(item.internal_value)
value = values.NumberValue(default_value)
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.Object(value)
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.Object',
args: 'functions.FunctionArgInput',
context: 'functions.VEvalContext' = None,
line=-1):
funcArgs = self.args.merge_inputs(inst, args)
node = nodes.NodeCall(self, funcArgs, line)
graph.add_node(node)
axis = funcArgs.keywords['axis']
if isinstance(axis, values.NoneValue):
value = values.NumberValue(None)
value.dtype = np.int64
else:
value = values.TensorValue()
value.dtype = np.int64
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.Object(value)
def generate_value_with_same_type(value: 'values.Value', is_dummy_value = False, suffix_type = SuffixType.Unknown):
assert(isinstance(value, values.Value))
ret = None
if isinstance(value, values.TensorValue):
ret = values.TensorValue()
ret.shape = value.shape
ret.dtype = value.dtype
elif isinstance(value, values.NumberValue):
dtype = None
if value.internal_value is None:
dtype = value.dtype
elif isinstance(value.internal_value, int):
dtype = np.array(value.internal_value).dtype
elif isinstance(value.internal_value, float):
dtype = np.array(value.internal_value).dtype
ret = values.NumberValue(None)
ret.dtype = dtype
elif isinstance(value, values.StrValue):
ret = values.StrValue(None)
elif isinstance(value, values.BoolValue):
ret = values.BoolValue(None)
elif isinstance(value, values.ListValue):
ret = values.ListValue(None)
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.NoneValue):
ret = values.NoneValue()
elif isinstance(value, values.TupleValue):
ret = values.TupleValue()
ret.dtype = value.dtype
ret.vtype = value.vtype
elif isinstance(value, values.RangeValue):
ret = values.RangeValue()
elif isinstance(value, values.UnknownValue):
ret = values.UnknownValue()
elif ret is None and isinstance(value, values.Value):
ret = values.Value()
else:
assert(False)
assert(ret is not None)
ret.is_dummy_value = is_dummy_value
if suffix_type == SuffixType.Unknown:
ret.name = value.name + '_st'
elif suffix_type == SuffixType.Unused:
ret.name = value.name + '_unused'
elif suffix_type == SuffixType.Dummy:
ret.name = value.name + '_dummy'
elif suffix_type == SuffixType.Input:
ret.name = value.name + '_in'
else:
assert(False)
return ret
def veval_ast_listcomp(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. [x for x in xx]
[elt for target in iter]
'''
assert (isinstance(astc.nast, gast.gast.ListComp))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
listcomp_guid = str(utils.get_guid())
listcomp_id = 'listcomp_' + listcomp_guid
body_id = 'listcomp_body_' + listcomp_guid
internal_counter_id = '@internal/listcomp_counter_' + listcomp_guid
internal_list_id = '@internal/listcomp_list_' + listcomp_guid
internal_cond_id = '@internal/listcomp_cond_' + listcomp_guid
generator = astc.nast.generators[0]
iter_value = try_get_value(
veval_ast(astc.c(generator.iter), local_field, graph), 'generator',
lineprop)
list_value = values.ListValue()
list_obj = values.ValueRef(list_value)
node_generate_list = nodes.NodeGenerate('List', [], lineprop)
node_generate_list.set_outputs([list_value])
graph.add_node(node_generate_list)
# body
target_name = ''
if isinstance(generator.target, gast.gast.Name):
target_name = generator.target.id
else:
if config.show_warnings:
print('This for is not supported. in L.{}'.format(astc.lineno))
return None
counter_value = values.NumberValue(None)
counter_value.dtype = np.array(0).dtype
counter_value.name = internal_counter_id
cond_value = values.BoolValue(None)
cond_value.name = internal_cond_id
# set values with internal name
local_field.get_attribute(internal_list_id).revise(list_obj)
values.push_history(listcomp_id)
body_graph = Graph()
body_graph.root_graph = graph.root_graph
body_graph.name = 'Body_' + listcomp_guid
node_forgen = nodes.NodeForGenerator(counter_value, iter_value)
target_ref = iter_value.get_iterator()
if target_ref is None:
target_ref = values.ValueRef(values.UnknownValue())
if config.show_warnings:
print('unknown iteratable type in L.{}'.format(lineprop))
target_value = target_ref.get_value()
node_forgen.set_outputs([target_ref.get_value()])
local_field.get_attribute(target_name).revise(target_ref)
body_graph.add_node(node_forgen)
elt = veval_ast(astc.c(astc.nast.elt), local_field, body_graph)
elt_obj = try_get_ref(elt, 'listcomp', lineprop)
finput = functions.FunctionArgInput()
finput.inputs.append(elt_obj)
append_value = local_field.get_attribute(internal_list_id).get_ref(
).get_field().get_attribute('append').get_ref().get_value()
append_value.func.vcall(
None, body_graph,
local_field.get_attribute(internal_list_id).get_ref(), finput,
lineprop)
value_inputs = values.get_inputs()
value_outputs = values.get_outputs()
values.pop_history()
inputs = []
outputs = []
# default input for subgraph's input
body_graph.add_input_value(counter_value)
body_graph.add_input_value(cond_value)
body_graph.add_input_value(iter_value)
# default output for subgraph's output
body_graph.add_output_value(cond_value)
body_graph.add_output_value(iter_value)
# default output
outputs.append(functions.generate_value_with_same_type(iter_value))
# generate pairs
value_pairs = {}
for v in value_inputs:
key = str(v.field.id) + '_' + v.name
if not (key in value_pairs.keys()):
value_pairs[key] = {}
value_pairs[key]['field'] = v.field
value_pairs[key]['name'] = v.name
value_pairs[key]['input_value'] = v.input_value
value_pairs[key]['input_body_value'] = v.value
for v in value_outputs:
key = str(v.field.id) + '_' + v.name
if not (key in value_pairs.keys()):
value_pairs[key] = {}
value_pairs[key]['field'] = v.field
value_pairs[key]['name'] = v.name
value_pairs[key]['output_body_value'] = v.value
value_pairs[key]['output_obj'] = v.obj
# remove iterator
removed_name = str(local_field.id) + '_' + target_value.name
del value_pairs[removed_name]
for k, v in value_pairs.items():
name = v['name']
field = v['field']
if 'input_body_value' in v:
inputs.append(v['input_value'])
body_graph.add_input_value(v['input_body_value'])
else:
temp_value1 = functions.generate_value_with_same_type(
v['output_body_value'])
temp_value2 = functions.generate_value_with_same_type(
v['output_body_value'])
inputs.append(temp_value1)
body_graph.add_input_value(temp_value2)
if 'output_body_value' in v:
body_graph.add_output_value(v['output_body_value'])
output_value = functions.generate_value_with_same_type(
v['output_body_value'])
outputs.append(output_value)
if 'output_obj' in v:
obj = v['output_obj']
obj.revise(output_value)
field.get_attribute(name).revise(obj)
elif field.get_attribute(name).has_obj():
field.get_attribute(name).get_ref().revise(output_value)
else:
field.get_attribute(name).revise(values.ValueRef(output_value))
else:
temp_value1 = v['input_body_value']
temp_value2 = functions.generate_value_with_same_type(
v['input_body_value'])
body_graph.add_output_value(temp_value1)
outputs.append(temp_value2)
node = nodes.NodeListcomp(iter_value, inputs, body_graph, astc.lineno)
node.set_outputs(outputs)
graph.add_node(node)
return local_field.get_attribute(internal_list_id).get_ref()
def veval_ast_for(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
for target in iter:
...
'''
assert (isinstance(astc.nast, gast.gast.For))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
# for target in iter:
iter_ = veval_ast(astc.c(astc.nast.iter), local_field, graph)
input_iter_value = try_get_value(iter_, 'for', lineprop)
body_iter_value = functions.generate_value_with_same_type(
input_iter_value, suffix_type=functions.SuffixType.Input)
# get target name
target_name = ''
if isinstance(astc.nast.target, gast.gast.Name):
target_name = astc.nast.target.id
else:
if config.show_warnings:
print('This for is not supported. in L.{}'.format(astc.lineno))
return None
# unroll?
if isinstance(input_iter_value,
values.ListValue) and input_iter_value.has_constant_value(
) and input_iter_value.dtype is None:
return veval_ast_for_unroll(astc, target_name, input_iter_value,
local_field, graph)
for_guid = utils.get_guid()
for_id = 'for_' + str(for_guid)
body_id = 'body_' + str(for_guid)
values.push_history(for_id)
# body
body_graph = Graph()
body_graph.root_graph = graph.root_graph
body_graph.name = 'Body_' + str(for_guid)
# generate a node for input
node_input = nodes.NodeInput('input')
body_graph.add_node(node_input)
body_counter_value = values.NumberValue(None)
body_counter_value.dtype = np.array(0).dtype
body_counter_value.name = 'for_counter_' + str(for_guid)
body_cond_value = values.BoolValue(None)
body_cond_value.name = 'for_cond_' + str(for_guid)
# create a node to lookup a value from sequence
node_forgen = nodes.NodeForGenerator(body_counter_value, body_iter_value)
# generate iterator
target_ref = input_iter_value.get_iterator()
if target_ref is None:
target_ref = values.ValueRef(values.UnknownValue())
if config.show_warnings:
print('unknown iteratable type in L.{}'.format(astc.lineno))
target_value = target_ref.get_value()
node_forgen.set_outputs([target_ref.get_value()])
target_attribute = local_field.get_attribute(target_name)
target_attribute.revise(target_ref)
body_graph.add_node(node_forgen)
# veval body
body = veval_ast(astc.c(astc.nast.body), local_field, body_graph)
value_inputs = values.get_inputs()
value_outputs = values.get_outputs()
break_attribute = local_field.get_attribute('#keepgoing')
if break_attribute.has_obj():
break_attribute_ref = break_attribute.get_ref()
break_attribute_value = break_attribute_ref.get_value()
else:
break_attribute_value = body_cond_value
values.pop_history()
inputs = []
outputs = []
node_input_outputs = []
# default input for subgraph's input
body_graph.add_input_value(body_counter_value)
body_graph.add_input_value(body_cond_value)
body_graph.add_input_value(body_iter_value)
# default output for subgraph's output
body_graph.add_output_value(break_attribute_value)
body_graph.add_output_value(body_iter_value)
# default output
outputs.append(functions.generate_value_with_same_type(input_iter_value))
# generate pairs
value_pairs = {}
for v in value_inputs:
key = str(v.field.id) + '_' + v.name
if not (key in value_pairs.keys()):
value_pairs[key] = {}
value_pairs[key]['field'] = v.field
value_pairs[key]['name'] = v.name
value_pairs[key]['input_value'] = v.input_value
value_pairs[key]['input_body_value'] = v.value
for v in value_outputs:
key = str(v.field.id) + '_' + v.name
if not (key in value_pairs.keys()):
value_pairs[key] = {}
value_pairs[key]['field'] = v.field
value_pairs[key]['name'] = v.name
value_pairs[key]['output_body_value'] = v.value
value_pairs[key]['output_obj'] = v.obj
for k, v in value_pairs.items():
name = v['name']
field = v['field']
if 'input_body_value' in v:
inputs.append(v['input_value'])
body_graph.add_input_value(v['input_body_value'])
else:
temp_value1 = functions.generate_value_with_same_type(
v['output_body_value'],
is_dummy_value=True,
suffix_type=functions.SuffixType.Dummy)
temp_value2 = functions.generate_value_with_same_type(
v['output_body_value'], suffix_type=functions.SuffixType.Dummy)
inputs.append(temp_value1)
body_graph.add_input_value(temp_value2)
node_input_outputs.append(temp_value2)
if 'output_body_value' in v:
body_graph.add_output_value(v['output_body_value'])
output_value = functions.generate_value_with_same_type(
v['output_body_value'])
outputs.append(output_value)
if 'output_obj' in v:
obj = v['output_obj']
obj.revise(output_value)
field.get_attribute(name).revise(obj)
elif field.get_attribute(name).has_obj():
field.get_attribute(name).get_ref().revise(output_value)
else:
field.get_attribute(name).revise(values.ValueRef(output_value))
else:
temp_value1 = v['input_body_value']
temp_value2 = functions.generate_value_with_same_type(
v['input_body_value'])
body_graph.add_output_value(temp_value1)
outputs.append(temp_value2)
node = nodes.NodeFor(input_iter_value, inputs, body_graph, body_cond_value,
astc.lineno)
node.set_outputs(outputs)
node_input.set_outputs(node_input_outputs)
graph.add_node(node)
return None
def return_NStepLSTM():
list_tensor = values.ListValue()
list_tensor.vtype = values.TensorValue
return [values.TensorValue(), values.TensorValue(), list_tensor]
def return_NStepBiLSTM():
list_tensor = values.ListValue()
list_tensor.vtype = values.TensorValue
return [values.TensorValue(), values.TensorValue(), list_tensor]
chainer_links[chainer.links.Linear] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('x', values.NoneValue()),
('n_batch_axes', values.NumberValue(1))],
estimate_shape=estimate_linear_shape)
chainer_links[chainer.links.Convolution2D] = ChainerLinkDefinition(
estimate_shape=estimate_convolution2D_shape)
chainer_links[chainer.links.ConvolutionND] = ChainerLinkDefinition(
estimate_shape=estimate_convolutionND_shape)
chainer_links[chainer.links.BatchNormalization] = ChainerLinkDefinition(
estimate_shape=estimate_batch_norm_shape)
chainer_links[chainer.links.NStepLSTM] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('hx', values.NoneValue()),
('cx', values.NoneValue()), ('xs', values.NoneValue())],
estimate_shape=estimate_NStepLSTM_shape,
get_ret=return_NStepLSTM)
chainer_links[chainer.links.NStepBiLSTM] = ChainerLinkDefinition(
args=[('self', values.NoneValue()), ('hx', values.NoneValue()),
('cx', values.NoneValue()), ('xs', values.NoneValue())],
def veval(op: 'nodes.BinOpType', left: 'values.Value', right: 'values.Value',
lineprop: 'utils.LineProperty'):
initialize_lazy()
if isinstance(left, values.ListValue):
return functions.generate_value_with_same_type(left)
if isinstance(left, values.TupleValue):
return functions.generate_value_with_same_type(left)
if isinstance(left, values.StrValue):
if not (isinstance(right, values.NumberValue) or isinstance(
right, values.StrValue) or isinstance(right, values.BoolValue)
or isinstance(right, values.TupleValue)):
assert False
if not (left.has_constant_value() or right.has_constant_value()):
assert False
if op == nodes.BinOpType.Add:
if not isinstance(right, values.StrValue):
assert False
return values.StrValue(left.internal_value + right.internal_value)
elif op == nodes.BinOpType.Mod:
right_internal_value = right.internal_value
if isinstance(right, values.TupleValue):
values_ = []
for ref in right_internal_value:
if not (isinstance(ref.get_value(), values.NumberValue)
or isinstance(ref.get_value(), values.StrValue)
or isinstance(ref.get_value(), values.BoolValue)):
assert False
if not ref.get_value().has_constant_value():
assert False
values_.append(ref.get_value())
right_internal_value = tuple(value.internal_value
for value in values_)
return values.StrValue(left.internal_value % right_internal_value)
return values.StrValue("")
if isinstance(right, values.NumberValue) or isinstance(
right, values.TensorValue):
if not isinstance(left, values.NumberValue) and not isinstance(
left, values.TensorValue):
utils.print_warning('Unestimated type is on left', lineprop)
left = values.NumberValue(0.0)
left_type = left.dtype
right_type = right.dtype
if not config.float_restrict:
if left_type == utils.dtype_float64:
left_type = utils.dtype_float32
if right_type == utils.dtype_float64:
right_type = utils.dtype_float32
if left_type is None:
left_type = np.array(0.0, np.float32).dtype
if right_type is None:
right_type = np.array(0.0, np.float32).dtype
result_type = None
for v in binop_type_table:
if v[0] == op and v[1] == left_type and v[2] == right_type:
result_type = v[3]
break
assert (result_type is not None)
if isinstance(right, values.TensorValue):
return functions.generate_value_with_type(right, type_=result_type)
else:
return functions.generate_value_with_type(left, type_=result_type)
return values.Value()
