def instance_converter(m, i):
if links_builtin.is_builtin_chainer_link(i):
return links_builtin.ChainerLinkInstance(m, i)
if isinstance(i, chainer.ChainList):
module = values.ValueRef(
values.ModuleValue(sys.modules[i.__module__]))
return links_builtin.ChainerChainListInstance(module, i)
if isinstance(i, chainer.Link):
module = values.ValueRef(
values.ModuleValue(sys.modules[i.__module__]))
return links_builtin.ChainerChainInstance(module, i)
return None
def veval_ast_unary_op(astc: 'AstContext', local_field: 'values.Field',
graph: 'graphs.Graph'):
"""
eval unary operation.
Ex. -xx
"""
assert (isinstance(astc.nast, gast.gast.UnaryOp))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
unaryop = nodes.UnaryOpType.Unknown
if isinstance(astc.nast.op, gast.UAdd):
unaryop = nodes.UnaryOpType.UAdd
if isinstance(astc.nast.op, gast.USub):
unaryop = nodes.UnaryOpType.USub
if isinstance(astc.nast.op, gast.Not):
unaryop = nodes.UnaryOpType.Not
operand = veval_ast(astc.c(astc.nast.operand), local_field, graph)
operand_value = try_get_value(operand, 'unary', lineprop)
node = nodes.NodeUnaryOp(operand_value, unaryop)
ret_value = veval_unary.veval(unaryop, operand_value)
node.set_outputs([ret_value])
graph.add_node(node)
return values.ValueRef(ret_value)
def vcall(self,
module: 'values.Field',
graph: 'graphs.Graph',
inst: 'values.ValueRef',
args: 'FunctionArgInput',
line=-1):
ret = values.ValueRef(
values.UserDefinedInstance(module, None, self.classinfo))
inst = ret
func_field = values.Field()
func_field.set_module(module)
# add args
funcArgs = self.args.merge_inputs(inst, args)
for k, v in funcArgs.keywords.items():
func_field.get_field().get_attribute(k,
from_module=False).revise(v)
astc = vevaluator.AstContext(self.ast.body,
self.lineno - 1,
filename=self.filename)
vevaluator.veval_ast(astc, func_field, graph)
return ret
def veval_ast_bool_op(astc: 'AstContext', local_field: 'values.Field',
graph: 'graphs.Graph'):
"""
eval bool operations.
Ex. x and y
"""
assert (isinstance(astc.nast, gast.gast.BoolOp))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
multiaryop = nodes.MultiaryOpType.Unknown
if isinstance(astc.nast.op, gast.And):
multiaryop = nodes.MultiaryOpType.And
if isinstance(astc.nast.op, gast.Or):
multiaryop = nodes.MultiaryOpType.Or
values_list = [
veval_ast(astc.c(value_), local_field, graph)
for value_ in astc.nast.values
]
values_list_value = [
try_get_value(value_, 'multiary', lineprop) for value_ in values_list
]
node = nodes.NodeMultiaryOp(values_list_value, multiaryop)
ret_value = veval_multiary.veval(multiaryop, values_list_value)
node.set_outputs([ret_value])
graph.add_node(node)
return values.ValueRef(ret_value)
def return_value_or_ref(obj: 'value.Object'):
if isinstance(obj.get_value(), values.NumberValue):
return values.ValueRef(obj.get_value())
if isinstance(obj.get_value(), values.StrValue):
return values.ValueRef(obj.get_value())
if isinstance(obj.get_value(), values.BoolValue):
return values.ValueRef(obj.get_value())
if isinstance(obj.get_value(), values.NoneValue):
return values.ValueRef(obj.get_value())
if isinstance(obj.get_value(), values.TupleValue):
return values.ValueRef(obj.get_value())
return obj
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1):
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.ValueRef(value)
def vcall(self,
module: 'Field',
graph: 'Graph',
inst: 'values.ValueRef',
args: 'functions.FunctionArgInput',
line=-1):
assert (inst is None)
return values.ValueRef(values.NoneValue)
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 vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1):
funcArgs = self.args.merge_inputs(inst, args)
node = nodes.NodeCall(self, funcArgs, line)
graph.add_node(node)
#value = functions.generate_value_with_same_type(vargs[0])
value = self.ret_value_func()
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.ValueRef(value)
def veval_ast_name_constant(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. True
'''
assert (isinstance(astc.nast, gast.gast.NameConstant))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
ret = None
if astc.nast.value == True:
ret = values.ValueRef(values.BoolValue(True))
if astc.nast.value == False:
ret = values.ValueRef(values.BoolValue(False))
if astc.nast.value is None:
ret = values.ValueRef(values.NoneValue())
name = values.create_ref_value_name_with_constant(ret)
ret.name = name
ret.get_value().name = name
return ret
def add_arg(self, name, value):
if isinstance(value, values.Value):
value = values.ValueRef(value)
assert not (name in self.args.keys())
fa = FunctionArg(name, value)
self.args_list.append(fa)
self.args[fa.name] = fa
def veval_ast_str(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. "str"
'''
assert (isinstance(astc.nast, gast.gast.Str))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
value = values.StrValue(astc.nast.s)
ret = values.ValueRef(value)
name = values.create_ref_value_name_with_constant(ret)
ret.name = name
ret.get_value().name = name
return ret
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1):
assert(inst is None)
funcArgs = self.args.merge_inputs(inst, args)
vargs = funcArgs.get_value().inputs
value = values.ListValue()
if isinstance(vargs[0], values.NoneValue):
node = nodes.NodeGenerate('List', [], line)
graph.add_node(node)
else:
node = nodes.NodeConvert('List', vargs[0], line)
graph.add_node(node)
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.ValueRef(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.TupleValue()
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
graph.add_node(node)
return values.ValueRef(value)
def vcall(self,
module: 'Field',
graph: 'Graph',
inst: 'values.ValueRef',
args: 'functions.FunctionArgInput',
line=-1):
assert (inst is None)
funcArgs = self.args.merge_inputs(inst, args)
vargs = funcArgs.get_value().inputs
dtype_value = vargs[1]
if isinstance(dtype_value, values.StrValue):
if not dtype_value.has_constant_value():
utils.print_error('Failed to get dtype str ', line)
return None
if dtype_value.get_constant_value() == 'q':
dtype = np.int64
elif dtype_value.get_constant_value() == 'i':
dtype = np.int32
elif dtype_value.get_constant_value() == 'g':
dtype = np.float64
elif dtype_value.get_constant_value() == 'f':
dtype = np.float32
else:
assert (False)
elif dtype_value is not None and not isinstance(
dtype_value, values.NoneValue):
# TODO : make better
dtype = np.array(1, dtype=dtype_value.func.dtype).dtype
elif isinstance(vargs[0], values.TensorValue):
dtype = vargs[0].dtype
else:
dtype = None
node = nodes.NodeGenerate('array', funcArgs, line)
graph.add_node(node)
value = values.TensorValue()
value.dtype = dtype
value.name = '@F.{}.{}'.format(line, self.name)
node.set_outputs([value])
return values.ValueRef(value)
def veval_ast_compare(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
"""
eval Compare.
Ex. a >= b, a != b, a is b, etc
"""
assert (isinstance(astc.nast, gast.gast.Compare))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
left = veval_ast(astc.c(astc.nast.left), local_field, graph)
right = veval_ast(astc.c(astc.nast.comparators[0]), local_field, graph)
left_value = try_get_value(left, 'compare', lineprop)
right_value = try_get_value(right, 'compare', lineprop)
compare = nodes.CompareType.unknown
if isinstance(astc.nast.ops[0], gast.Eq):
compare = nodes.CompareType.Eq
if isinstance(astc.nast.ops[0], gast.NotEq):
compare = nodes.CompareType.NotEq
if isinstance(astc.nast.ops[0], gast.Is):
compare = nodes.CompareType.Is
if isinstance(astc.nast.ops[0], gast.IsNot):
compare = nodes.CompareType.IsNot
if isinstance(astc.nast.ops[0], gast.Gt):
compare = nodes.CompareType.Gt
if isinstance(astc.nast.ops[0], gast.GtE):
compare = nodes.CompareType.GtE
if isinstance(astc.nast.ops[0], gast.Lt):
compare = nodes.CompareType.Lt
if isinstance(astc.nast.ops[0], gast.LtE):
compare = nodes.CompareType.LtE
node_compare = nodes.NodeCompare(left_value, right_value, compare,
astc.lineno)
ret_value = values.BoolValue(None)
ret_value.name = '@{}'.format(lineprop)
node_compare.set_outputs([ret_value])
graph.add_node(node_compare)
return values.ValueRef(ret_value)
def veval_ast_bin_op(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
"""
eval binary operation.
Ex. a + b, b // c, etc
"""
assert (isinstance(astc.nast, gast.gast.BinOp))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
left = veval_ast(astc.c(astc.nast.left), local_field, graph)
right = veval_ast(astc.c(astc.nast.right), local_field, graph)
left_value = try_get_value(left, 'compare', lineprop)
right_value = try_get_value(right, 'compare', lineprop)
binop = nodes.BinOpType.Unknown
if isinstance(astc.nast.op, gast.Add):
binop = nodes.BinOpType.Add
elif isinstance(astc.nast.op, gast.Sub):
binop = nodes.BinOpType.Sub
elif isinstance(astc.nast.op, gast.Mult):
binop = nodes.BinOpType.Mul
elif isinstance(astc.nast.op, gast.Div):
binop = nodes.BinOpType.Div
elif isinstance(astc.nast.op, gast.FloorDiv):
binop = nodes.BinOpType.FloorDiv
else:
utils.print_warning('Unknown binary operator {}'.format(astc.nast.op),
lineprop)
return None
node_bin_op = nodes.NodeBinOp(left_value, right_value, binop, astc.lineno)
ret_value = veval_bin.veval(binop, left_value, right_value, lineprop)
node_bin_op.set_outputs([ret_value])
graph.add_node(node_bin_op)
return values.ValueRef(ret_value)
def veval_ast_list(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
assert (isinstance(astc.nast, gast.gast.List))
'''
Ex. [],[x,y,z]
TODO : Initializer
'''
lineprop = utils.LineProperty(astc.lineno, astc.filename)
elts = []
for elt in astc.nast.elts:
elt_ = veval_ast(astc.c(elt), local_field, graph)
elt_obj = try_get_ref(elt_, 'list', lineprop)
elts.append(elt_obj)
node = nodes.NodeGenerate('List', [elt.get_value() for elt in elts],
lineprop)
graph.add_node(node)
value = values.ListValue(elts)
node.set_outputs([value])
return values.ValueRef(value)
def veval_ast_tuple(astc: 'AstContext',
local_field: 'values.Field',
graph: 'Graph',
option: 'VEvalOption' = None):
assert (isinstance(astc.nast, gast.gast.Tuple))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
if option is not None and option.eval_as_written_target:
vs = []
for v in astc.nast.elts:
a_ = veval_ast(astc.c(v), local_field, graph, option=option)
vs.append(a_)
return vs
else:
vs_ref = []
vs = []
for v in astc.nast.elts:
a_ = veval_ast(astc.c(v), local_field, graph, option=option)
v_ = try_get_ref(a_, 'tuple', lineprop)
if v_ is None:
utils.print_warning('Unknown tuple element {}'.format(v),
lineprop)
return None
vs_ref.append(v_)
vs.append(v_.get_value())
v_.in_container = True
tuple_value = values.TupleValue(vs_ref)
node = nodes.NodeGenerate('Tuple', vs, line=lineprop)
node.set_outputs([tuple_value])
graph.add_node(node)
return values.ValueRef(tuple_value)
def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args: 'functions.FunctionArgInput', line=-1):
node = nodes.NodeCopy(args.inputs[0].get_value())
graph.add_node(node)
ret = functions.generate_copied_value(args.inputs[0].get_value())
node.set_outputs([ret])
return values.ValueRef(ret)
def __init__(self):
super().__init__()
self.name = 'list'
self.args.add_arg('value', values.ValueRef(values.NoneValue()))
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_subscript(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
'''
Ex. x[1], x[y,z]
'''
assert (isinstance(astc.nast, gast.gast.Subscript))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
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 get_slice_indices(slice):
if slice.lower is None and slice.upper is None and slice.step is None:
return []
indices = [
veval_with_default(slice.lower, 0),
veval_with_default(slice.upper, utils.slice_int_max)
]
if slice.step is not None:
indices.append(veval_with_default(slice.step, 1))
return indices
value = veval_ast(astc.c(astc.nast.value), local_field, graph)
value_value = try_get_value(value, 'subscript', lineprop)
if isinstance(astc.nast.slice, gast.gast.Index):
slice_ = veval_ast(astc.c(astc.nast.slice.value), local_field, graph)
slice_value = try_get_value(slice_, 'subscript', lineprop)
if isinstance(slice_value, values.TupleValue):
# ex. x[1,2]
if slice_value.has_constant_value():
values_ = [
try_get_value(x, 'subscript', lineprop)
for x in slice_value.get_constant_value()
]
node = nodes.NodeGetItem(value_value, values_, line=lineprop)
else:
if config.show_warnings:
print('This subscript is not supported. in L.{}'.format(
astc.lineno))
node = nodes.NodeInvalid(line=lineprop)
else:
# ex. x[1]
node = nodes.NodeGetItem(value_value, [slice_value])
if isinstance(value_value,
values.ListValue) and value_value.vtype != None:
ret_value = value_value.vtype()
ret_value.dtype = value_value.dtype
elif isinstance(value_value,
values.TupleValue) and value_value.vtype != None:
ret_value = value_value.vtype()
ret_value.dtype = value_value.dtype
else:
ret_value = values.UnknownValue()
node.set_outputs([ret_value])
graph.add_node(node)
return values.ValueRef(ret_value)
elif isinstance(astc.nast.slice, gast.gast.Slice):
indices = get_slice_indices(astc.nast.slice)
node = nodes.NodeSlice(value_value, indices, [len(indices)])
ret_value = functions.generate_value_with_same_type(value_value)
node.set_outputs([ret_value])
graph.add_node(node)
return values.ValueRef(ret_value)
elif isinstance(astc.nast.slice, gast.gast.ExtSlice):
indices = []
slice_specs = []
for dim in astc.nast.slice.dims:
if isinstance(dim, gast.gast.Index):
indices.append(
try_get_value(
veval_ast(astc.c(dim.value), local_field, graph),
'subscript', lineprop))
slice_specs.append(1)
elif isinstance(dim, gast.gast.Slice):
ni = get_slice_indices(dim)
indices.extend(ni)
slice_specs.append(len(ni))
else:
assert False, 'Unknown slice: %s in %s' % (dim, nast.slice)
node = nodes.NodeSlice(value_value, indices, slice_specs)
ret_value = functions.generate_value_with_same_type(value_value)
node.set_outputs([ret_value])
graph.add_node(node)
return values.ValueRef(ret_value)
return None
def veval_ast_if(astc: 'AstContext', local_field: 'values.Field',
graph: 'Graph'):
assert (isinstance(astc.nast, gast.gast.If))
lineprop = utils.LineProperty(astc.lineno, astc.filename)
# if condition
test = veval_ast(astc.c(astc.nast.test), local_field, graph)
test_value = try_get_value(test, 'if', lineprop)
id_str = str(utils.get_guid())
if_id = 'if_' + id_str
true_id = 'true_' + id_str
false_id = 'false_' + id_str
# True
values.push_history(true_id)
true_graph = Graph()
true_graph.root_graph = graph.root_graph
true_graph.name = 'True'
true_body = veval_ast(astc.c(astc.nast.body), local_field, true_graph)
true_value_inputs = values.get_inputs()
true_value_outputs = values.get_outputs()
values.pop_history()
# False
values.push_history(false_id)
false_graph = Graph()
false_graph.root_graph = graph.root_graph
false_graph.name = 'False'
false_body = veval_ast(astc.c(astc.nast.orelse), local_field, false_graph)
false_value_inputs = values.get_inputs()
false_value_outputs = values.get_outputs()
values.pop_history()
# generate pairs
value_pairs = {}
for v in true_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]['true_input_value'] = v.input_value
value_pairs[key]['true_input_body_value'] = v.value
value_pairs[key]['true_input_obj'] = v.obj
for v in true_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]['true_output_body_value'] = v.value
value_pairs[key]['true_output_obj'] = v.obj
for v in false_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]['false_input_value'] = v.input_value
value_pairs[key]['false_input_body_value'] = v.value
value_pairs[key]['false_input_obj'] = v.obj
for v in false_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]['false_output_body_value'] = v.value
value_pairs[key]['false_output_obj'] = v.obj
inputs = []
outputs = []
for k, v in value_pairs.items():
name = v['name']
field = v['field']
input_value = None
true_input_body_value = None
false_input_body_value = None
# search input value
if 'true_input_value' in v:
input_value = v['true_input_value']
elif 'false_input_value' in v:
input_value = v['false_input_value']
if input_value is not None:
if 'true_input_body_value' in v:
true_input_body_value = v['true_input_body_value']
else:
true_input_body_value = functions.generate_value_with_same_type(
input_value)
if 'false_input_body_value' in v:
false_input_body_value = v['false_input_body_value']
else:
false_input_body_value = functions.generate_value_with_same_type(
input_value)
true_output_body_value = None
false_output_body_value = None
output_value = None
# search output value
if 'true_output_body_value' in v:
true_output_body_value = v['true_output_body_value']
if 'false_output_body_value' in v:
false_output_body_value = v['false_output_body_value']
if true_output_body_value is not None or false_output_body_value is not None:
if true_output_body_value is None:
if true_input_body_value is not None:
# e.x. not changed
true_output_body_value = true_input_body_value
else:
# e.x. make a value in false statement
true_output_body_value = functions.generate_value_with_same_type(
false_output_body_value, is_dummy_value=True)
if false_output_body_value is None:
if false_input_body_value is not None:
# e.x. not changed
false_output_body_value = false_input_body_value
else:
# e.x. make a value in true statement
false_output_body_value = functions.generate_value_with_same_type(
true_output_body_value, is_dummy_value=True)
# check types between true and false
true_output_body_value_type = None
false_output_body_value_type = None
if true_output_body_value is not None and true_output_body_value.is_not_none_or_any_value(
):
true_output_body_value_type = true_output_body_value
if false_output_body_value is not None and false_output_body_value.is_not_none_or_any_value(
):
false_output_body_value_type = false_output_body_value
if true_output_body_value_type is not None and false_output_body_value_type is not None and type(
true_output_body_value_type) != type(
false_output_body_value_type):
utils.print_warning(
'Values with differenet type were generated {} between true ande false'
.format(k), lineprop)
if true_output_body_value_type != None:
output_value = functions.generate_value_with_same_type(
true_output_body_value_type)
elif false_output_body_value_type != None:
output_value = functions.generate_value_with_same_type(
false_output_body_value_type)
elif true_output_body_value is not None:
output_value = functions.generate_value_with_same_type(
true_output_body_value)
elif false_output_body_value is not None:
output_value = functions.generate_value_with_same_type(
false_output_body_value)
if input_value is not None:
inputs.append(input_value)
true_graph.add_input_value(true_input_body_value)
false_graph.add_input_value(false_input_body_value)
if output_value is not None:
outputs.append(output_value)
true_graph.add_output_value(true_output_body_value)
false_graph.add_output_value(false_output_body_value)
if 'true_output_obj' in v and not 'false_output_obj' in v:
obj = v['true_output_obj']
elif not 'true_output_obj' in v and 'false_output_obj' in v:
obj = v['false_output_obj']
elif 'true_output_obj' in v and 'false_output_obj' in v:
obj = None
else:
assert (False)
if obj is not None:
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))
node = nodes.NodeIf(test_value, inputs, true_graph, false_graph,
astc.lineno)
node.set_outputs(outputs)
graph.add_node(node)
return None
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 convert_model(model: 'chainer.Chain', args=[]):
# reset values
values.reset_field_and_attributes()
utils.reset_guid()
values.function_converters.clear()
values.builtin_function_converters.clear()
values.instance_converters.clear()
def instance_converter(m, i):
if links_builtin.is_builtin_chainer_link(i):
return links_builtin.ChainerLinkInstance(m, i)
if isinstance(i, chainer.ChainList):
module = values.ValueRef(
values.ModuleValue(sys.modules[i.__module__]))
return links_builtin.ChainerChainListInstance(module, i)
if isinstance(i, chainer.Link):
module = values.ValueRef(
values.ModuleValue(sys.modules[i.__module__]))
return links_builtin.ChainerChainInstance(module, i)
return None
values.instance_converters.append(instance_converter)
# chainer
c_variable = values.FuncValue(functions_ndarray.NDArrayFunction(), None)
values.function_converters[chainer.Variable] = c_variable
# chainer.functions
def add_chainer_funtion(name: 'str', func, ret_value_func=None):
if ret_value_func is None:
f = values.FuncValue(functions_builtin.ChainerFunction(func), None)
else:
f = values.FuncValue(
functions_builtin.ChainerFunction(
func, ret_value_func=ret_value_func), None)
values.function_converters[func] = f
def ret_tuple():
ret = values.TupleValue()
ret.vtype = values.TensorValue
return ret
add_chainer_funtion('relu', F.relu)
add_chainer_funtion('softmax', F.softmax)
add_chainer_funtion('softmax_cross_entropy', F.softmax_cross_entropy)
add_chainer_funtion('pad_sequence', F.pad_sequence)
add_chainer_funtion('average_pooling_2d', F.average_pooling_2d)
add_chainer_funtion('unpooling_2d', F.unpooling_2d)
add_chainer_funtion('reshape', F.reshape)
add_chainer_funtion('split_axis', F.split_axis, ret_value_func=ret_tuple)
add_chainer_funtion('hstack', F.hstack)
add_chainer_funtion('vstack', F.vstack)
add_chainer_funtion('stack', F.stack)
add_chainer_funtion('separate', F.separate, ret_value_func=ret_tuple)
add_chainer_funtion('squeeze', F.squeeze)
add_chainer_funtion('swapaxes', F.swapaxes)
add_chainer_funtion('dropout', F.dropout)
add_chainer_funtion('concat', F.concat)
add_chainer_funtion('matmul', F.matmul)
add_chainer_funtion('max_pooling_2d', F.max_pooling_2d)
add_chainer_funtion('resize_images', F.resize_images)
add_chainer_funtion('tanh', F.tanh)
add_chainer_funtion('sigmoid', F.sigmoid)
add_chainer_funtion('broadcast_to', F.broadcast_to)
add_chainer_funtion('expand_dims', F.expand_dims)
add_chainer_funtion('local_response_normalization',
F.local_response_normalization)
add_chainer_funtion('mean', F.mean)
add_chainer_funtion('average', F.average)
add_chainer_funtion('sum', F.sum)
if int(chainer.__version__[0]) >= 6:
add_chainer_funtion('roi_max_pooling_2d', F.roi_max_pooling_2d)
add_chainer_funtion('roi_average_pooling_2d', F.roi_average_pooling_2d)
add_chainer_funtion('roi_max_align_2d', F.roi_max_align_2d)
add_chainer_funtion('roi_average_align_2d', F.roi_average_align_2d)
# numpy
f_array = values.FuncValue(functions_ndarray.NDArrayFunction(), None)
f_zeros = values.FuncValue(functions_ndarray.NDArrayZerosFunction(), None)
f_full = values.FuncValue(functions_ndarray.NDArrayFullFunction(), None)
f_ceil = values.FuncValue(functions_ndarray.NDArrayCeilFunction(), None)
f_cumsum = values.FuncValue(functions_ndarray.NDArrayCumsumFunction(),
None)
f_int32 = values.FuncValue(functions_ndarray.NDArrayInt32(), None)
f_float32 = values.FuncValue(functions_ndarray.NDArrayFloat32(), None)
values.function_converters[np.array] = f_array
values.function_converters[np.zeros] = f_zeros
values.function_converters[np.full] = f_full
values.function_converters[np.ceil] = f_ceil
values.function_converters[np.cumsum] = f_cumsum
values.function_converters[np.int32] = f_int32
values.function_converters[np.float32] = f_float32
m_range = values.FuncValue(functions_builtin.RangeFunction(), None)
values.builtin_function_converters['range'] = m_range
m_len = values.FuncValue(functions_builtin.LenFunction(), None)
values.builtin_function_converters['len'] = m_len
values.function_converters[six.moves.range] = m_range
m_list = values.FuncValue(functions_builtin.ListFunction(), None)
values.builtin_function_converters['list'] = m_list
m_to_gpu = values.FuncValue(functions_builtin.CopyFunction(cuda.to_gpu),
None)
values.function_converters[cuda.to_gpu] = m_to_gpu
m_to_cpu = values.FuncValue(functions_builtin.CopyFunction(cuda.to_cpu),
None)
values.function_converters[cuda.to_cpu] = m_to_cpu
# generate default module
default_module = values.ValueRef(
values.ModuleValue(sys.modules[model.__module__]))
model_inst = values.parse_instance(default_module, '', model)
forward_func = model_inst.try_get_and_store_obj('forward', None)
# convert args
finput = functions.FunctionArgInput()
value_args = []
ind = 0
node_input = nodes.NodeInput('input')
for arg in args:
varg = values.parse_instance(default_module, '', arg, None)
varg.name = 'in_' + str(ind)
varg.get_value().name = 'in_' + str(ind)
# make value unknown
varg.get_value().internal_value = None
finput.inputs.append(varg)
value_args.append(varg.get_value())
ind += 1
node_input.set_outputs(value_args)
graph = Graph()
graph.root_graph = graph
graph.add_node(node_input)
forward_func_value = forward_func.get_value()
ret = forward_func_value.func.vcall(default_module, graph,
forward_func_value.obj, finput)
assert (ret is None or isinstance(ret, values.ValueRef))
def try_get_value(value) -> 'values.Value':
if isinstance(value, values.Value):
return value
if isinstance(value, values.ValueRef):
return value.get_value()
if isinstance(value, values.Attribute):
return value.get_ref().get_value()
if ret is None or isinstance(ret, values.NoneValue):
if config.show_warnings:
print('Failed to compile. output is None.')
return (value_args, None, graph)
ret_ = []
if isinstance(ret.get_value(), values.TupleValue):
if ret.get_value().internal_value is not None:
for v in ret.get_value().internal_value:
assert (v is not None)
ret_.append(try_get_value(v))
else:
ret_ = [ret.get_value()]
elif isinstance(ret, list):
ret_ = [r.get_value() for r in ret]
else:
ret_ = [ret.get_value()]
for v in value_args:
graph.add_input_value(v)
for v in ret_:
graph.add_output_value(v)
return (value_args, ret_, graph)
