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)