for yapf check

fluid/sequence_tagging_for_ner/network_conf.py

@@ -3,6 +3,7 @@ from paddle.fluid.initializer import NormalInitializer
 from utils import logger, load_dict, get_embedding
 import math
 
+
 def ner_net(word_dict_len, label_dict_len, stack_num=2, is_train=True):
     mark_dict_len = 2
     word_dim = 50
@@ -11,8 +12,7 @@ def ner_net(word_dict_len, label_dict_len, stack_num=2, is_train=True):
     IS_SPARSE = True
     embedding_name = 'emb'
 
-    word = fluid.layers.data(
-        name='word', shape=[1], dtype='int64', lod_level=1)
+    word = fluid.layers.data(name='word', shape=[1], dtype='int64', lod_level=1)
 
     word_embedding = fluid.layers.embedding(
         input=word,
@@ -20,10 +20,9 @@ def ner_net(word_dict_len, label_dict_len, stack_num=2, is_train=True):
         dtype='float32',
         is_sparse=IS_SPARSE,
         param_attr=fluid.ParamAttr(
-                name=embedding_name, trainable=False))
-   
-    mark = fluid.layers.data(
-        name='mark', shape=[1], dtype='int64', lod_level=1)
+            name=embedding_name, trainable=False))
+
+    mark = fluid.layers.data(name='mark', shape=[1], dtype='int64', lod_level=1)
 
     mark_embedding = fluid.layers.embedding(
         input=mark,
@@ -31,13 +30,17 @@ def ner_net(word_dict_len, label_dict_len, stack_num=2, is_train=True):
         dtype='float32',
         is_sparse=IS_SPARSE)
 
-    word_caps_vector = fluid.layers.concat(input=[word_embedding, mark_embedding], axis = 1)
+    word_caps_vector = fluid.layers.concat(
+        input=[word_embedding, mark_embedding], axis=1)
     mix_hidden_lr = 1
-    
+
     rnn_para_attr = fluid.ParamAttr(
-        initializer=NormalInitializer(loc=0.0, scale=0.0, seed=0), learning_rate=mix_hidden_lr) 
+        initializer=NormalInitializer(
+            loc=0.0, scale=0.0, seed=0),
+        learning_rate=mix_hidden_lr)
     hidden_para_attr = fluid.ParamAttr(
-        initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0),
+        initializer=NormalInitializer(
+            loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0),
         learning_rate=mix_hidden_lr)
 
     hidden = fluid.layers.fc(
@@ -45,60 +48,68 @@ def ner_net(word_dict_len, label_dict_len, stack_num=2, is_train=True):
         name="__hidden00__",
         size=hidden_dim,
         act="tanh",
-        bias_attr=fluid.ParamAttr(
-            initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)),
-        param_attr=fluid.ParamAttr(
-            initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)))
+        bias_attr=fluid.ParamAttr(initializer=NormalInitializer(
+            loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)),
+        param_attr=fluid.ParamAttr(initializer=NormalInitializer(
+            loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)))
     fea = []
     for direction in ["fwd", "bwd"]:
         for i in range(stack_num):
             if i != 0:
-		hidden = fluid.layers.fc(
+                hidden = fluid.layers.fc(
                     name="__hidden%02d_%s__" % (i, direction),
                     size=hidden_dim,
                     act="stanh",
-                    bias_attr=fluid.ParamAttr(initializer=NormalInitializer(loc=0.0, scale=1.0, seed=0)),
+                    bias_attr=fluid.ParamAttr(initializer=NormalInitializer(
+                        loc=0.0, scale=1.0, seed=0)),
                     input=[hidden, rnn[0], rnn[1]],
-                    param_attr=[hidden_para_attr, rnn_para_attr, rnn_para_attr])
+                    param_attr=[
+                        hidden_para_attr, rnn_para_attr, rnn_para_attr
+                    ])
             rnn = fluid.layers.dynamic_lstm(
                 name="__rnn%02d_%s__" % (i, direction),
                 input=hidden,
-		size=hidden_dim,
+                size=hidden_dim,
                 candidate_activation='relu',
                 gate_activation='sigmoid',
                 cell_activation='sigmoid',
-                bias_attr=fluid.ParamAttr(initializer=NormalInitializer(loc=0.0, scale=1.0, seed=0)),
+                bias_attr=fluid.ParamAttr(initializer=NormalInitializer(
+                    loc=0.0, scale=1.0, seed=0)),
                 is_reverse=(i % 2) if direction == "fwd" else not i % 2,
                 param_attr=rnn_para_attr)
         fea += [hidden, rnn[0], rnn[1]]
 
     rnn_fea = fluid.layers.fc(
         size=hidden_dim,
-        bias_attr=fluid.ParamAttr(initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)),
+        bias_attr=fluid.ParamAttr(initializer=NormalInitializer(
+            loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)),
         act="stanh",
         input=fea,
         param_attr=[hidden_para_attr, rnn_para_attr, rnn_para_attr] * 2)
 
     emission = fluid.layers.fc(size=label_dict_len,
-        input=rnn_fea,
-        param_attr=fluid.ParamAttr(initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0)))
+                               input=rnn_fea,
+                               param_attr=fluid.ParamAttr(
+                                   initializer=NormalInitializer(
+                                       loc=0.0,
+                                       scale=(1. / math.sqrt(hidden_dim) / 3),
+                                       seed=0)))
 
     if is_train:
         target = fluid.layers.data(
-            name="target",
-            shape=[1], dtype='int64', lod_level=1)
-        
+            name="target", shape=[1], dtype='int64', lod_level=1)
+
         crf_cost = fluid.layers.linear_chain_crf(
             input=emission,
             label=target,
             param_attr=fluid.ParamAttr(
                 name='crfw',
-                initializer=NormalInitializer(loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0),
+                initializer=NormalInitializer(
+                    loc=0.0, scale=(1. / math.sqrt(hidden_dim) / 3), seed=0),
                 learning_rate=mix_hidden_lr))
         return crf_cost, emission, word, mark, target
 
     else:
         predict = fluid.layers.crf_decoding(
-            input=emission,
-            param_attr=fluid.ParamAttr(name='crfw'))
-        return predict    
+            input=emission, param_attr=fluid.ParamAttr(name='crfw'))
+        return predict

fluid/sequence_tagging_for_ner/train.py

@@ -7,6 +7,7 @@ import os
 import math
 import numpy as np
 
+
 def to_lodtensor(data, place):
     seq_lens = [len(seq) for seq in data]
     cur_len = 0
@@ -21,17 +22,19 @@ def to_lodtensor(data, place):
     res.set_lod([lod])
     return res
 
+
 def test(exe, chunk_evaluator, inference_program, test_data, place):
     chunk_evaluator.reset(exe)
     for data in test_data():
-        word = to_lodtensor(map(lambda x:x[0], data), place)
-        mark = to_lodtensor(map(lambda x:x[1], data), place)
-        target = to_lodtensor(map(lambda x:x[2], data), place)
+        word = to_lodtensor(map(lambda x: x[0], data), place)
+        mark = to_lodtensor(map(lambda x: x[1], data), place)
+        target = to_lodtensor(map(lambda x: x[2], data), place)
         acc = exe.run(inference_program,
                       feed={"word": word,
                             "mark": mark,
                             "target": target})
-    return  chunk_evaluator.eval(exe)
+    return chunk_evaluator.eval(exe)
+
 
 def main(train_data_file,
          test_data_file,
@@ -52,12 +55,11 @@ def main(train_data_file,
     word_dict_len = len(word_dict)
     label_dict_len = len(label_dict)
 
-    crf_cost, feature_out, word, mark, target = ner_net(word_dict_len, label_dict_len)    
+    crf_cost, feature_out, word, mark, target = ner_net(word_dict_len,
+                                                        label_dict_len)
     avg_cost = fluid.layers.mean(x=crf_cost)
-    
-    sgd_optimizer = fluid.optimizer.Momentum(
-        momentum=0.0,
-        learning_rate=1e-3)
+
+    sgd_optimizer = fluid.optimizer.Momentum(momentum=0.0, learning_rate=1e-3)
     sgd_optimizer.minimize(avg_cost)
 
     crf_decode = fluid.layers.crf_decoding(
@@ -73,7 +75,7 @@ def main(train_data_file,
     with fluid.program_guard(inference_program):
         test_target = chunk_evaluator.metrics + chunk_evaluator.states
         inference_program = fluid.io.get_inference_program(test_target)
-    
+
     train_reader = paddle.batch(
         paddle.reader.shuffle(
             reader.data_reader(train_data_file, word_dict, label_dict),
@@ -86,11 +88,7 @@ def main(train_data_file,
         batch_size=batch_size)
 
     place = fluid.CPUPlace()
-    feeder = fluid.DataFeeder(
-        feed_list=[
-            word, mark, target
-        ],
-        place=place)
+    feeder = fluid.DataFeeder(feed_list=[word, mark, target], place=place)
     exe = fluid.Executor(place)
 
     exe.run(fluid.default_startup_program())
@@ -107,14 +105,22 @@ def main(train_data_file,
                 fluid.default_main_program(),
                 feed=feeder.feed(data),
                 fetch_list=[avg_cost] + chunk_evaluator.metrics)
-	    if batch_id % 5 == 0:
-                print("Pass " + str(pass_id) + ", Batch " + str(batch_id) + ", Cost " + str(cost) + ", Precision " + str(precision) + ", Recall " + str(recall) + ", F1_score" + str(f1_score))
+            if batch_id % 5 == 0:
+                print("Pass " + str(pass_id) + ", Batch " + str(batch_id) +
+                      ", Cost " + str(cost) + ", Precision " + str(precision) +
+                      ", Recall " + str(recall) + ", F1_score" + str(f1_score))
             batch_id = batch_id + 1
 
-        pass_precision, pass_recall, pass_f1_score = test(exe, chunk_evaluator, inference_program, train_reader, place)
-	print("[TrainSet] pass_id:" + str(pass_id) + " pass_precision:" + str(pass_precision) + " pass_recall:" + str(pass_recall) + " pass_f1_score:" + str(pass_f1_score))
-        pass_precision, pass_recall, pass_f1_score = test(exe, chunk_evaluator, inference_program, test_reader, place)
-        print("[TestSet] pass_id:" + str(pass_id) + " pass_precision:" + str(pass_precision) + " pass_recall:" + str(pass_recall) + " pass_f1_score:" + str(pass_f1_score))
+        pass_precision, pass_recall, pass_f1_score = test(
+            exe, chunk_evaluator, inference_program, train_reader, place)
+        print("[TrainSet] pass_id:" + str(pass_id) + " pass_precision:" + str(
+            pass_precision) + " pass_recall:" + str(pass_recall) +
+              " pass_f1_score:" + str(pass_f1_score))
+        pass_precision, pass_recall, pass_f1_score = test(
+            exe, chunk_evaluator, inference_program, test_reader, place)
+        print("[TestSet] pass_id:" + str(pass_id) + " pass_precision:" + str(
+            pass_precision) + " pass_recall:" + str(pass_recall) +
+              " pass_f1_score:" + str(pass_f1_score))
 
 
 if __name__ == "__main__":
@@ -125,4 +131,4 @@ if __name__ == "__main__":
         target_file="data/target.txt",
         emb_file="data/wordVectors.txt",
         model_save_dir="models/",
-	num_passes=1000)
+        num_passes=1000)