Mylstm elichika (WIP)

elichika/elichika/chainer2onnx.py

@@ -54,6 +54,10 @@ def compile_model(model, inputs) -> 'ONNXModel':
     oc.chainer_f_converter[F.concat] = fb.convert_concat
     oc.chainer_f_converter[F.max_pooling_2d] = fb.convert_max_pooling_2d
     oc.chainer_f_converter[F.resize_images] = fb.convert_resize_images
+    oc.chainer_f_converter[F.tanh] = fb.convert_tanh
+    oc.chainer_f_converter[F.sigmoid] = fb.convert_sigmoid
+    oc.chainer_f_converter[F.broadcast_to] = fb.convert_broadcast_to
+    oc.chainer_f_converter[F.expand_dims] = fb.convert_expand_dims
 
     if int(chainer.__version__[0]) >= 6:
         oc.chainer_f_converter[F.roi_max_pooling_2d] = fb.convert_roi_max_pooling_2d

elichika/elichika/functions_builtin.py

@@ -32,7 +32,21 @@ def convert_relu(onnx_graph, node):
                         [node.inputs[0]],
                         [node.outputs[0]],
                         name=str(node.lineprop))
+    return
+
+def convert_tanh(onnx_graph, node):
+    onnx_graph.add_node('Tanh',
+                        [node.inputs[0]],
+                        [node.outputs[0]],
+                        name=str(node.lineprop))
+    return
 
+def convert_sigmoid(onnx_graph, node):
+    onnx_graph.add_node("Sigmoid",
+                        [node.inputs[0]],
+                        [node.outputs[0]],
+                        name=str(node.lineprop))
+    return
 
 def convert_softmax(onnx_graph, node):
     onnx_graph.add_node(
@@ -125,7 +139,7 @@ def convert_softmax_cross_entropy(onnx_graph, node):
     ignore_label = oc.try_get_attribute(node.args.keywords['ignore_label'])
     reduce = oc.try_get_attribute(node.args.keywords['reduce'])
     enable_double_backprop = oc.try_get_attribute(node.args.keywords['enable_double_backprop'])
-    
+
     assert normalize  # TODO(hamaji): Not supported yet.
     assert cache_score  # TODO(hamaji): Not supported yet.
     assert class_weight is None  # TODO(hamaji): Not supported yet.
@@ -208,12 +222,12 @@ def convert_unpooling_2d(onnx_graph, node : 'nodes.NodeCall'):
     pad = oc.try_get_attribute(node.args.keywords['pad'])
     outsize = oc.try_get_attribute(node.args.keywords['outsize'])
     cover_all = oc.try_get_attribute(node.args.keywords['cover_all'])
-    
+
     assert(stride is None) # TODO(hamaji): Not supported yet.
     assert(pad == 0) # TODO(hamaji): Not supported yet.
     assert(outsize is None) # TODO(hamaji): Not supported yet.
     assert(cover_all is False) # TODO(hamaji): Not supported yet.
-    
+
     scales = np.array([1, 1] + list(_pair(ksize)), dtype=np.float32)
     scales_ = oc.ONNXValue(onnx_graph, scales, [node, '/Scale'], is_constant = True)
     onnx_graph.add_node(
@@ -361,3 +375,26 @@ def _pair(x):
         spatial_scale=oc.try_get_attribute(spatial_scale.value),
         sampling_ratio=_pair(oc.try_get_attribute(sampling_ratio.value)))
     return
+
+def convert_broadcast_to(onnx_graph, node):
+    node_ = node
+
+    shape = oc.ONNXValue(onnx_graph, node_.args.keywords['shape'])
+    onnx_graph.add_node(
+        "Expand",
+        [node_.inputs[0], shape.create_tensor()],
+        node_.outputs,
+        str(node.lineprop))
+    return
+
+
+def convert_expand_dims(onnx_graph, node):
+    node_ = node
+    axis = oc.try_get_attribute(node_.args.keywords['axis'])
+    onnx_graph.add_node(
+        'Unsqueeze',
+        [node_.inputs[0]],
+        node_.outputs,
+        str(node.lineprop),
+        axes=[int(axis)])
+    return

elichika/elichika/onnx_converters.py

@@ -928,6 +928,38 @@ def generate_tensors(values_):
 
                 onnx_graph.nodes.append(onnx_node)
 
+            if isinstance(node, nodes.NodeLen):
+                node_ = node  # type: nodes.NodeLen
+
+                onnx_node = oh.make_node(
+                    'ChainerGenericLen',
+                    [value2onnx_parameter[node_.iter_value].onnx_name],
+                    [value2onnx_parameter[node_.outputs[0]].onnx_name],
+                    str(node.lineprop)
+                )
+
+                onnx_graph.nodes.append(onnx_node)
+
+            if isinstance(node, nodes.NodeTensorAttribute):
+                node_ = node  # type: nodes.NodeShape
+
+                if node_.type == 'shape':
+                    onnx_node = oh.make_node(
+                        'ChainerSequenceSeparate',
+                        [value2onnx_parameter[node_.value].onnx_name],
+                        [value2onnx_parameter[node_.outputs[0]].onnx_name],
+                        str(node.lineprop)
+                    )
+                elif node_.type == 'size':
+                    onnx_node = oh.make_node(
+                        'Size',
+                        [value2onnx_parameter[node_.value].onnx_name],
+                        [value2onnx_parameter[node_.outputs[0]].onnx_name],
+                        str(node.lineprop)
+                    )
+
+                onnx_graph.nodes.append(onnx_node)
+
             if isinstance(node, nodes.NodeFor):
                 node_ = node  # type: nodes.NodeFor
 

elichika/elichika/parser/core.py

@@ -94,12 +94,16 @@ def ret_tuple():
         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)
 
         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)
 
         default_module.set_default_value(chainer_functions_module_name, f_dict)
@@ -134,6 +138,9 @@ def ret_tuple():
     m_list = values.FuncValue(functions_builtin.ListFunction(), None)
     default_module.set_default_value('list', values.ValueRef(m_list))
 
+    m_len = values.FuncValue(functions_builtin.LenFunction(), None)
+    default_module.set_default_value('len', values.ValueRef(m_len))
+
     model_inst = values.parse_instance(default_module, '', model)
     forward_func = model_inst.try_get_and_store_obj('forward')
 

elichika/elichika/parser/functions_builtin.py

@@ -46,6 +46,23 @@ def vcall(self, module: 'Field', graph: 'Graph', inst: 'values.ValueRef', args:
         return values.ValueRef(value)
 
 
+class LenFunction(functions.FunctionBase):
+    def __init__(self):
+        super().__init__()
+        self.name = 'len'
+
+    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)
+
+
 class ListFunction(functions.FunctionBase):
     def __init__(self):
         super().__init__()

elichika/elichika/parser/nodes.py

@@ -48,7 +48,7 @@ def remove_ref(value):
         converted = {}
 
         ret = functions.FunctionArgValueInput()
-        
+
         for v in value.inputs:
             converted_v = remove_ref(v)
             ret.inputs.append(converted_v)
@@ -58,7 +58,7 @@ def remove_ref(value):
         for k,v in value.keywords.items():
             if v in converted.keys():
                 keywords_[k] = converted[v]
-            else:        
+            else:
                 keywords_[k] = remove_ref(v)
         ret.keywords = keywords_
         return ret
@@ -401,3 +401,26 @@ def __init__(self, classtype, value, line=-1):
 
     def __str__(self):
         return 'Convert({},{})'.format(self.classtype, self.lineprop)
+
+class NodeLen(Node):
+    def __init__(self, iter_value, line=-1):
+        super().__init__(line)
+        iter_value = remove_ref(iter_value)
+
+        self.iter_value = iter_value
+        self.append_inputs(self.iter_value)
+
+    def __str__(self):
+        return 'Len({})'.format(self.lineprop)
+
+class NodeTensorAttribute(Node):
+    def __init__(self, type, value, line=-1):
+        super().__init__(line)
+        value = remove_ref(value)
+
+        self.value = value
+        self.type = type
+        self.append_inputs(self.value)
+
+    def __str__(self):
+        return 'TensorAttribute({},{})'.format(self.type, self.lineprop)

elichika/elichika/parser/values.py

@@ -258,7 +258,8 @@ def get_outputs(self) -> 'List[FieldOutput]':
         ret = []
 
         for key, att in self.attributes.items():
-
+            if att.name in ['shape', 'size']:
+                continue
             # instance or func
             if isinstance(att.get_ref().get_value(), Instance) or isinstance(att.get_ref().get_value(), FuncValue) or isinstance(att.get_ref().get_value(), ModuleValue):
                 continue
@@ -512,7 +513,7 @@ def __init__(self):
 
     def has_constant_value(self) -> 'bool':
         return self.internal_value is not None
-    
+
     def is_all_constant_values(self, is_ref_enabled = False) -> 'bool':
         return self.internal_value is not None
 
@@ -539,7 +540,7 @@ def __init__(self):
 
     def has_constant_value(self) -> 'bool':
         return True
-    
+
     def is_all_constant_values(self, is_ref_enabled = False) -> 'bool':
         return True
 
@@ -623,7 +624,7 @@ def is_all_constant_values(self, is_ref_enabled = False) -> 'bool':
                 else:
                     if not v.is_all_constant_values(is_ref_enabled):
                         return False
-        return True                    
+        return True
 
     def __str__(self):
         return self.name + '(Tp{})'

elichika/elichika/parser/vevaluator.py

@@ -108,9 +108,16 @@ def veval_ast_attribute(astc : 'AstContext', local_field : 'values.Field', graph
     if gotten_obj is not None:
         return value_ref.get_field().get_attribute(astc.nast.attr, from_module)
 
-    if option.eval_as_written_target:
+    if option is not None and option.eval_as_written_target:
         return attr
-
+
+    if attr.name in ['shape', 'size']:
+        node = nodes.NodeTensorAttribute(attr.name, value_ref, value_ref.get_value())
+        value = values.TupleValue()
+        node.set_outputs([value])
+        graph.add_node(node)
+        return values.ValueRef(value)
+
     # value is unknown
     if config.show_warnings:
         print('Assigning value is not found in L.{}'.format(astc.lineno))
@@ -155,7 +162,7 @@ def return_value_or_ref(obj : 'value.Object'):
         if not isinstance(value_obj.get_value(), values.TupleValue):
             # TODO fix it
             assert(False)   # not supported
-        
+
         for i in range(len(targets)):
             node_assign = nodes.NodeAssign(targets[i], value_obj.get_value().get_constant_value()[i], astc.lineno)
             targets[i].revise(try_get_ref(value_obj.get_value().get_constant_value()[i],'assign', lineprop))
@@ -320,7 +327,7 @@ def veval_ast_if(astc : 'AstContext', local_field : 'values.Field', graph : 'Gra
         input_value = None
         true_input_body_value = None
         false_input_body_value = None
-            
+
         if 'true_input_value' in v:
             input_value = v['true_input_value']
         elif 'false_input_value' in v:
@@ -366,7 +373,7 @@ def veval_ast_if(astc : 'AstContext', local_field : 'values.Field', graph : 'Gra
             outputs.append(output_value)
             true_graph.add_output_value(true_output_body_value)
             false_graph.add_output_value(false_output_body_value)
-            
+
             if field.get_attribute(name).has_obj():
                 field.get_attribute(name).get_ref().revise(output_value)
             else:
@@ -544,7 +551,7 @@ def veval_ast_listcomp(astc : 'AstContext', local_field : 'values.Field', graph
     target_value = values.Value()
     target_ref = values.ValueRef(target_value)
     node_forgen.set_outputs([target_value])
-    
+
     local_field.get_attribute(target_name).revise(target_ref)
 
     body_graph.add_node(node_forgen)
@@ -577,7 +584,7 @@ def veval_ast_listcomp(astc : 'AstContext', local_field : 'values.Field', graph
 
     # default output
     outputs.append(functions.generate_value_with_same_type(iter_value))
-    
+
     # generate pairs
     value_pairs = {}
     for v in value_inputs:
@@ -810,7 +817,7 @@ def veval_ast_tuple(astc : 'AstContext', local_field : 'values.Field', graph : '
             node = nodes.NodeGenerate('Tuple', vs.copy(), line=lineprop)
             node.set_outputs([tuple_value])
             graph.add_node(node)
-        
+
         return values.ValueRef(tuple_value)
 
 def veval_ast_list(astc : 'AstContext', local_field : 'values.Field', graph : 'Graph'):
@@ -914,7 +921,7 @@ def veval_ast_for(astc : 'AstContext', local_field : 'values.Field', graph : 'Gr
 
     # default output
     outputs.append(functions.generate_value_with_same_type(iter_value))
-    
+
     # generate pairs
     value_pairs = {}
     for v in value_inputs:

elichika/tests/model/MyLSTM.py

@@ -44,6 +44,17 @@ def forward(self, xs, h, c, mask):
         #h = self.initial_h
         #c = self.initial_c
         inputs = F.pad_sequence(xs)
+        x = None
+        input = None
+        gate = None
+        i = None
+        o = None
+        f = None
+        nc = None
+        nh = None
+        m = None
+        pmask = None
+        nmask = None
         for time in range(max_len):
             x = inputs[:, time]
             input = F.concat((x, h), axis=1)
@@ -83,7 +94,7 @@ def main():
     num_vocabs = 10
     num_hidden = 5
 
-    model_fn = lambda: MyLSTM(num_hidden, batch_size, sequence_length)
+    model_fn = MyLSTM(num_hidden, batch_size, sequence_length)
 
     labels, lengths = sequence_utils.gen_random_sequence(
         batch_size, sequence_length, num_vocabs)