环境

1. Python3安装
2. nltk库安装
   在cmd中输入pip install nltk，如果显示pip不是内部或外部命令，那就是未配置环境变量，自行百度。
3. 下载StanfordParser
   

下载好进行解压，得到文件夹stanford-parser-full-2018-10-17，文件夹的内容如下：

解压文件夹中的stanford-parser-3.9.2-models.jar，
得到

使用

import os
from nltk.parse import stanford

# 这里的三个引用文件都是根据我的目录来的
# 只需要根据你的实际目录更改D:\Google\stanford-parser-full-2018-10-17即可
os.environ['STANFORD_PARSER'] = r"D:\Google\stanford-parser-full-2018-10-17\stanford-parser.jar"
os.environ['STANFORD_MODELS'] = r"D:\Google\stanford-parser-full-2018-10-17\stanford-parser-3.9.2-models.jar"
parser = stanford.StanfordDependencyParser(model_path=r"D:\Google\stanford-parser-full-2018-10-17\edu\stanford\nlp\models\lexparser\chinesePCFG.ser.gz")

res = list(parser.parse(['我','爱','NLP']))
for row in res[0].triples():
    print(row)

输出：

(('爱', 'VV'), 'nsubj', ('我', 'PN'))
(('爱', 'VV'), 'dobj', ('NLP', 'NN'))

('爱', 'VV')表示爱是句子中的VV(动词)
('我', 'PN')表示我是句子中的PN(代词)
('NLP', 'NN')表示NLP是句子中的NN(名词)

nsubj表示我是爱的名词主语
dobj表示NLP是爱的直接宾语

更多句法符号表示见https://www.jianshu.com/p/5c461cf096c4

Reference

1. https://blog.csdn.net/lizzy05/article/details/88148097
2. https://blog.csdn.net/qq_41618091/article/details/97239505
3. https://nlp.stanford.edu/software/lex-parser.shtml#Download
4. https://blog.csdn.net/lihaitao000/article/details/51812618

上一篇文章CS224n之句法分析总结，介绍了句法分析以及具体的依存分析中的arc-standard算法。arc-standard系统是transition systems中最流行的一个系统之一。而本文将介绍一个基于神经网络的依存句法分析器，它基于arc-standard 系统，使用分类器根据从配置信息中提取的特征来预测正确的转换操作。尽管它的性能比基于搜索的解析器略差，但是它的计算效率非常高。本代码已经上传github

1、模型

模型如下图所示：

模型包括输入层，隐含层和softmax层。隐含层的激活函数比较特殊，使用cube激活函数也就是取3次方。arc-standard 算法介绍过，一个configuration包括Stack，Buffer，依存弧集合。如图最下方所示，这就是一个具体的configuration，包含了stack，buffer，依存弧集合的信息。模型根据configuration信息来提取出一个特征向量，这个特征向量由(words，POS tags，arc labels)三个向量拼接而成。这个向量因此包含了对应configuration的信息。模型的目标就是输入特征向量，然后预测出对应的转换类型，如LEFT-ARC，SHIFT等。预测出转换类型就进行相应的转换操作，这样就更新了配置信息，然后得到新的向量，再输入模型中预测，如此循环。最后就能得到依存弧集合找出句子中依存关系。

首先模型使用了 word embeddings，将one-hot编码转为词向量，不仅word，对应单词的词性和依存关系标签也被映射为向量，同样有自己的embeddings矩阵。那么如何根据配置信息提取出特征向量呢？根据论文所讲述的，系统会分别选择18、18、12个元素作为$x^w，x^t，x^l$的值。
对于$x^w$，栈和缓冲区的前3个单词：s1,s2,s3,b1,b2,b3；堆栈顶部两个单词的第一个和第二个最左/最右边的子项，也就是依赖于该单词的单词，如果没有就是NULL。lc1(si), rc1(si), lc2(si), rc2(si), i = 1, 2.；堆栈顶部两个单词的最左边或最左边节点的最左边或最左边节点（孩子的孩子）lc1(lc1(si)), rc1(rc1(si)), i = 1, 2. 最后将这18个单词输入经过word embeddings映射为词向量。
对于$x^t$ 选择$x^w$中18个词的对应词性作为输入值。
对于$x^l$ 选择除了堆栈/缓冲区上的6个字之外的单词的相应弧标签。这些元素同样根据自己的embeddings映射为向量。
这样将所有的向量拼接起来就是input layer的输入。

2、代码详解

（1）数据集操作

首先语料库是这样的：

第一列是单词在句子中的序号，第二列是单词，第五列是POS tags，第七列是所依赖的序号，第八列是依赖关系也是arc labels。

先用read_conll方法分别读取训练集，验证集，测试集数据，将语料库中的word，pos，head，label存储在examples变量中，代码如下：

def read_conll(in_file, lowercase=False, max_example=None):
    examples = []
    with open(in_file) as f:
        word, pos, head, label = [], [], [], []
        for line in f.readlines():
            sp = line.strip().split('\t')
            if len(sp) == 10:
                if '-' not in sp[0]:
                    word.append(sp[1].lower() if lowercase else sp[1])
                    pos.append(sp[4])
                    head.append(int(sp[6]))
                    label.append(sp[7])
            elif len(word) > 0:
                examples.append({'word': word, 'pos': pos, 'head': head, 'label': label})
                word, pos, head, label = [], [], [], []
                if (max_example is not None) and (len(examples) == max_example):
                    break
        if len(word) > 0:
            examples.append({'word': word, 'pos': pos, 'head': head, 'label': label})
    return examples

接下来把获得的信息向量化，使用one-hot编码，代码如下：

 def vectorize(self, examples):
        vec_examples = []
        for ex in examples:
            word = [self.ROOT] + [self.tok2id[w] if w in self.tok2id
                                  else self.UNK for w in ex['word']]
            pos = [self.P_ROOT] + [self.tok2id[P_PREFIX + w] if P_PREFIX + w in self.tok2id
                                   else self.P_UNK for w in ex['pos']]
            head = [-1] + ex['head']
            label = [-1] + [self.tok2id[L_PREFIX + w] if L_PREFIX + w in self.tok2id
                            else -1 for w in ex['label']]
            vec_examples.append({'word': word, 'pos': pos,
                                 'head': head, 'label': label})
        return vec_examples

接下来使用create_instances方法产生训练集，先初始化stack，buffer，arc，将三个参数放入get_oracle方法中self.get_oracle(stack, buf, ex) ex为examples其中一句话的部分。这个方法会根据输入的参数的信息根据ex中head返回一个转换操作，用数字代替，0为left-arc，1为right-arc，2为SHIFT。代码如下：

def get_oracle(self, stack, buf, ex):
        if len(stack) < 2:
            return self.n_trans - 1

        i0 = stack[-1]
        i1 = stack[-2]
        h0 = ex['head'][i0]
        h1 = ex['head'][i1]
        l0 = ex['label'][i0]
        l1 = ex['label'][i1]

        if self.unlabeled:
            if (i1 > 0) and (h1 == i0):
                return 0
            elif (i1 >= 0) and (h0 == i1) and \
                 (not any([x for x in buf if ex['head'][x] == i0])):
                return 1
            else:
                return None if len(buf) == 0 else 2
        else:
            if (i1 > 0) and (h1 == i0):
                return l1 if (l1 >= 0) and (l1 < self.n_deprel) else None
            elif (i1 >= 0) and (h0 == i1) and \
                 (not any([x for x in buf if ex['head'][x] == i0])):
                return l0 + self.n_deprel if (l0 >= 0) and (l0 < self.n_deprel) else None
            else:
                return None if len(buf) == 0 else self.n_trans - 1

create_instances会根据stack, buf, arcs, ex信息提取特征向量，函数为extract_features(stack, buf, arcs, ex)，代码如下：

def extract_features(self, stack, buf, arcs, ex):
        if stack[0] == "ROOT":
            stack[0] = 0

        def get_lc(k):
            return sorted([arc[1] for arc in arcs if arc[0] == k and arc[1] < k])

        def get_rc(k):
            return sorted([arc[1] for arc in arcs if arc[0] == k and arc[1] > k],
                          reverse=True)

        p_features = []
        l_features = []
        features = [self.NULL] * (3 - len(stack)) + [ex['word'][x] for x in stack[-3:]]
        features += [ex['word'][x] for x in buf[:3]] + [self.NULL] * (3 - len(buf))
        if self.use_pos:
            p_features = [self.P_NULL] * (3 - len(stack)) + [ex['pos'][x] for x in stack[-3:]]
            p_features += [ex['pos'][x] for x in buf[:3]] + [self.P_NULL] * (3 - len(buf))

        for i in xrange(2):
            if i < len(stack):
                k = stack[-i-1]
                lc = get_lc(k)
                rc = get_rc(k)
                llc = get_lc(lc[0]) if len(lc) > 0 else []
                rrc = get_rc(rc[0]) if len(rc) > 0 else []

                features.append(ex['word'][lc[0]] if len(lc) > 0 else self.NULL)
                features.append(ex['word'][rc[0]] if len(rc) > 0 else self.NULL)
                features.append(ex['word'][lc[1]] if len(lc) > 1 else self.NULL)
                features.append(ex['word'][rc[1]] if len(rc) > 1 else self.NULL)
                features.append(ex['word'][llc[0]] if len(llc) > 0 else self.NULL)
                features.append(ex['word'][rrc[0]] if len(rrc) > 0 else self.NULL)

                if self.use_pos:
                    p_features.append(ex['pos'][lc[0]] if len(lc) > 0 else self.P_NULL)
                    p_features.append(ex['pos'][rc[0]] if len(rc) > 0 else self.P_NULL)
                    p_features.append(ex['pos'][lc[1]] if len(lc) > 1 else self.P_NULL)
                    p_features.append(ex['pos'][rc[1]] if len(rc) > 1 else self.P_NULL)
                    p_features.append(ex['pos'][llc[0]] if len(llc) > 0 else self.P_NULL)
                    p_features.append(ex['pos'][rrc[0]] if len(rrc) > 0 else self.P_NULL)

                if self.use_dep:
                    l_features.append(ex['label'][lc[0]] if len(lc) > 0 else self.L_NULL)
                    l_features.append(ex['label'][rc[0]] if len(rc) > 0 else self.L_NULL)
                    l_features.append(ex['label'][lc[1]] if len(lc) > 1 else self.L_NULL)
                    l_features.append(ex['label'][rc[1]] if len(rc) > 1 else self.L_NULL)
                    l_features.append(ex['label'][llc[0]] if len(llc) > 0 else self.L_NULL)
                    l_features.append(ex['label'][rrc[0]] if len(rrc) > 0 else self.L_NULL)
            else:
                features += [self.NULL] * 6
                if self.use_pos:
                    p_features += [self.P_NULL] * 6
                if self.use_dep:
                    l_features += [self.L_NULL] * 6

        features += p_features + l_features
        assert len(features) == self.n_features
        return features

然后将返回的向量以及对应get_oracle返回的转换保存在instances数组中，分别作为训练数据和标签。接下来执行刚才得到的转换操作，更新stack，buffer，arc。再循环执行上面的操作。如果一句话有n个单词，则执行循环2×n次，因为每个单词都要进栈一次，出栈一次。 这样模型的数据集就完成了。 create_instances函数的代码如下：

def create_instances(self, examples):
        all_instances = []
        succ = 0
        for id, ex in enumerate(logged_loop(examples)):
            n_words = len(ex['word']) - 1

            # arcs = {(h, t, label)}
            stack = [0]
            buf = [i + 1 for i in xrange(n_words)]
            arcs = []
            instances = []
            for i in xrange(n_words * 2):
                gold_t = self.get_oracle(stack, buf, ex)
                if gold_t is None:
                    break
                legal_labels = self.legal_labels(stack, buf)
                assert legal_labels[gold_t] == 1
                instances.append((self.extract_features(stack, buf, arcs, ex),
                                  legal_labels, gold_t))
                if gold_t == self.n_trans - 1:
                    stack.append(buf[0])
                    buf = buf[1:]
                elif gold_t < self.n_deprel:
                    arcs.append((stack[-1], stack[-2], gold_t))
                    stack = stack[:-2] + [stack[-1]]
                else:
                    arcs.append((stack[-2], stack[-1], gold_t - self.n_deprel))
                    stack = stack[:-1]
            else:
                succ += 1
                all_instances += instances

        return all_instances

（2）模型训练

其实模型非常简单，就是普通的全连接神经网络加sotfmax分类。框架用的tensorflow。过程依次是：1. 添加占位符 2. 创建feed_dict 3. 创建embedding层，4、add_prediction_op 网络的前向传播操作 5、add_loss_op 定义loss 使用softmax_cross_entropy_with_logits损失。6、 定义优化器 add_training_op
代码都在q2_parser_model.py 文件中。大家可以去看看。

（3）解析

系统在解析中执行贪心解码。在每一步，我们从当前配置c中提取所有相应的单词，POS和标签嵌入，计算隐藏层h(c)，并选择具有最高分数的转换，然后再执行转换。

总结

本篇文章跟上一篇文章介绍了NLP中的技术句法分析，以及讲解了基于神经网络的依存分析算法。这两篇文章只是笔者自己的总结概括，如果大家想深入了解句法分析可以去CS224n公开课上学习，对于基于神经网络的依存分析算法可以查看这篇论文：《A Fast and Accurate Dependency Parser using Neural Networks》，我的github上就有.