来源于：每个人都应该知道的5个NLP代码库

1. Spacy

spaCy 是Python中比较出名，专门用于自然语言处理的库。它有助于实现最先进的效率和敏捷性，并拥有活跃的开源组织积极贡献代码。

加分项：

与所有主要的深度学习框架很好地结合，并预装了一些出色且有用的语言模型
由于Cython支持，速度相对较快

使用spaCy最适合做的事情


词性（POS）标注：这是给单词标记制定语法属性（例如名词，动词，形容词，副词等）过程。
实体识别：将文本中发现的命名实体标记到预定义实体类型。
依存分析：分配语法依存标签，描述各个标记（例如主题或客体）之间的关系。
文本分类：为整个文档或文档的一部分分配类别或标签。
句子边界检测（SBD）：查找和分割单个句子。

2. NLTK

NLTK是目前可用的最优秀的NLP模型训练库之一。该库是NLP入门python库。它是NLP的初学者常用的库。它具有许多预先训练的模型和语料库，可帮助我们非常快速地分析事物。

加分项：内置支持数十种语料库和训练完备的模型

使用NLTK可以实现一下需求：

1. 推荐：可以基于相似性来推荐内容。

2. 情感分析：通过自然语言处理来衡量人们的观点倾向

3. Wordnet [1]支持：我们可以使用Synset 在WordNet中查找单词。因此可以访问许多单词的同音异义词，上位词，同义词，定义，词族等

4. 机器翻译：用于将源语言翻译成目标语言

3.Transformers

该Transformers库是开源，基于社区的信息库，使用和共享模型基于Transformer结构[2]如Bert[3]，Roberta[4]，GPT2 [5]，XLNet [6]，等等
该库提供自然语言理解（NLU）和自然语言生成（NLG）任务预训练模型下载。

加分项：超过32种采用100种以上语言的训练的预训练模型，以及TensorFlow 2.0和PyTorch之间的深度互操作性。最适合深度学习。
Transformers可以做到一下事情
1. 摘要生成：摘要是将文本/文章摘要为较短文本的任务。
2. 翻译：将文本从一种语言翻译成另一种语言的任务。
3. 文本生成：基于上下文，生成连贯的下文。
4. 抽取式问答：从给定问题的文本中提取答案的任务。

4. Gensim

Gensim是一个Python库，专门用于通过向量空间建模和主题建模工具包来识别两个文档之间的语义相似性

顺便说一下，它是“ Generate Similar”（Gensim）的缩写：)
优点：高水平的处理速度和可以处理大量文本。
Gensim适合处理的需求：
1. 分布式计算：它可以在计算机集群上运行隐语义分析和隐Dirichlet分配。（可以处理大量数据的原因）
2. 文档索引：将信息与文件或特定标签相关联的过程，以便以后可以轻松检索
3. 主题建模：自动聚类单词group和定义一组文档的相似表达式。
4. 相似性检索：处理文档存储库中相似信息的组织，存储，检索和评估（此处为文本信息）

5. Stanza

Stanza将许多准确而有效自然语言处理工具收集在一起，组成工具包。从原始文本到句法分析和实体识别，Stanza将最新的NLP模型引入语言处理中。
该工具包建立在PyTorch库的之上，并支持使用GPU和预训练的神经模型。

此外，Stanza包括一个CoreNLP Java包的Python接口，并从那里继承了附加功能。

优点：快速，准确，并且能够支持几种主要语言。适用于生产部署环境。

    在本文中，将详细介绍目前常用的Python NLP库。

    内容译自网络。

 

    这些软件包可处理多种NLP任务，例如词性（POS）标注，依存分析，文档分类，主题建模等等。

 

    NLP库的基本目标是简化文本预处理。

 

    目前有许多工具和库用于解决NLP问题……但是只要掌握了其中的一些基本知识，就可以掌握相关基本知识。这就是为什么只介绍其中最常用的五个Python NLP库的原因。

    但是在此之前，应该掌握有关NLP的各个组成领域和主题的一些基础知识。

 

    扎实基础

    对于学习自然语言处理的理论基础，网络上有丰富的资源可以学习：

    · 斯坦福课程 — 深度学习中的自然语言处理（http://web.stanford.edu/class/cs224n/）

    · Deeplearning.ai专业化 - 自然语言处理专业（https://www.coursera.org/specializations/natural-language-processing）

    · 适用于基础知识的最佳书籍（又名NLP圣经） — 自然语言处理，语音识别和计算语言学导论（https://web.stanford.edu/~jurafsky/slp3/）

    · 另一本不错的参考书 - 统计自然语言处理的基础（https://nlp.stanford.edu/fsnlp/）

 

    1. Spacy

    spaCy 是Python中比较出名，专门用于自然语言处理的库。它有助于实现最先进的效率和敏捷性，并拥有活跃的开源组织积极贡献代码。

    加分项：

    · 与所有主要的深度学习框架很好地结合，并预装了一些出色且有用的语言模型

    · 由于Cython支持，速度相对较快

    使用spaCy最适合做的事情

    1. 词性（POS）标注：这是给单词标记制定语法属性（例如名词，动词，形容词，副词等）过程。

    2. 实体识别：将文本中发现的命名实体标记到预定义实体类型。

    3. 依存分析：分配语法依存标签，描述各个标记（例如主题或客体）之间的关系。

    4. 文本分类：为整个文档或文档的一部分分配类别或标签。

    5. 句子边界检测（SBD）：查找和分割单个句子。

 

    相关资源

    免费官方课程的链接：基于spaCy的高级NLP（https://course.spacy.io/en/）



    官方课程

    更多资源

    · 一篇不错的博客文章，包括安装过程和其他Spacy用法（入门博客）：使用Python中的spaCy进行自然语言处理（https://realpython.com/natural-language-processing-spacy-python/）

    · Python Spacy简介（视频）— 视频讲座和教程（https://realpython.com/natural-language-processing-spacy-python/）

 

    2. NLTK

    NLTK是目前可用的最优秀的NLP模型训练库之一。该库是NLP入门python库。它是NLP的初学者常用的库。它具有许多预先训练的模型和语料库，可帮助我们非常快速地分析事物。

    加分项：内置支持数十种语料库和训练完备的模型

    使用NLTK可以实现一下需求：

    1. 推荐：可以基于相似性来推荐内容。

    2. 情感分析：通过自然语言处理来衡量人们的观点倾向

    3. Wordnet [1]支持：我们可以使用Synset 在WordNet中查找单词。因此可以访问许多单词的同音异义词，上位词，同义词，定义，词族等

    4. 机器翻译：用于将源语言翻译成目标语言

 

    其他资源

    · 学习NLTK的最佳资源是官方的教材：《使用自然语言工具包分析文本》（https://www.nltk.org/book/）

    · 相关文章整理：Python的NLTK（自然语言工具包）教程（https://www.guru99.com/nltk-tutorial.html）

    · Wordnet文档— WordNet 3.0参考手册（https://wordnet.princeton.edu/documentation）

    与spaCy专注于提供用于生产用途的软件不同，NLTK被广泛用于教学和研究— Wikipedia

 

    3.Transformers



    来自Transformers GitHub Repo

    该Transformers库是开源，基于社区的信息库，使用和共享模型基于Transformer结构[2]如Bert[3]，Roberta[4]，GPT2 [5]，XLNet [6]，等等

 

    该库提供自然语言理解（NLU）和自然语言生成（NLG）任务预训练模型下载。

 

    加分项：超过32种采用100种以上语言的训练的预训练模型，以及TensorFlow 2.0和PyTorch之间的深度互操作性。最适合深度学习。

    Transformers可以做到一下事情

    1. 摘要生成：摘要是将文本/文章摘要为较短文本的任务。

    2. 翻译：将文本从一种语言翻译成另一种语言的任务。

    3. 文本生成：基于上下文，生成连贯的下文。

    4. 抽取式问答：从给定问题的文本中提取答案的任务。

 

    相关资源：

    · 官方文档-HuggingfaceTransformers（https://huggingface.co/transformers/）

    · 使用BERT，HuggingFace和AWS Lambda构建问题解答API – 使用HuggingFace和AWS Lambda的无服务器BERT（https://towardsdatascience.com/serverless-bert-with-huggingface-and-aws-lambda-625193c6cc04）

    · 了解如何微调BERT以进行情感分析— 使用BERT和Transformers进行情感分析（https://www.curiousily.com/posts/sentiment-analysis-with-bert-and-hugging-face-using-pytorch-and-python/）

 

    4. Gensim

    Gensim是一个Python库，专门用于通过向量空间建模和主题建模工具包来识别两个文档之间的语义相似性

    顺便说一下，它是“ Generate Similar”（Gensim）的缩写：)

 

    优点：高水平的处理速度和可以处理大量文本。

 

    Gensim适合处理的需求：

    1. 分布式计算：它可以在计算机集群上运行隐语义分析和隐Dirichlet分配。（可以处理大量数据的原因）

    2. 文档索引：将信息与文件或特定标签相关联的过程，以便以后可以轻松检索

    3. 主题建模：自动聚类单词group和定义一组文档的相似表达式。

    4. 相似性检索：处理文档存储库中相似信息的组织，存储，检索和评估（此处为文本信息）

 

    资源

    · 官方API文档-API参考（https://radimrehurek.com/gensim/apiref.html）

    · 官方教程- 核心教程（https://radimrehurek.com/gensim/auto_examples/）

    · 使用Gensim LDA进行分层文档聚类— 使用Python进行文档聚类（http://brandonrose.org/clustering#Latent-Dirichlet-Allocation）

    · 安装，处理等入门教程— 适用于NLP的Python：使用Gensim库（https://stackabuse.com/python-for-nlp-working-with-the-gensim-library-part-1/）

 

    5. Stanza

    Stanza将许多准确而有效自然语言处理工具收集在一起，组成工具包。从原始文本到句法分析和实体识别，Stanza将最新的NLP模型引入语言处理中。

 

    该工具包建立在PyTorch库的之上，并支持使用GPU和预训练的神经模型。

 

    此外，Stanza包括一个CoreNLP Java包的Python接口，并从那里继承了附加功能。

 

    优点：快速，准确，并且能够支持几种主要语言。适用于生产部署环境。

 

    资源：CoreNLP的Python包装器列表（http://stanfordnlp.github.io/CoreNLP/other-languages.html#python）

 

    Stanza适合处理的需求：

    1. 形态特征标记：对于句子中的每个单词，Stanza都会评估其普遍的形态特征（例如，单身/复数，第一/第二/第三人称等）。

    2. 多词令牌扩展：将句子扩展成句法词，作为下游处理的基础。

     

    这五个库的固有特性使其成为依赖于机器对人类表达的理解的所有项目的首选。

 

    参考文献

    1. WordNet简介：在线词汇数据库 — George A. Miller等。1993年（https://wordnetcode.princeton.edu/5papers.pdf）

    2. Attention Is All You Need — Vaswani等人，2017。(https://arxiv.org/abs/1706.03762)

    3. BERT：用于语言理解的深度双向Transformers的预训练 — Devlin等人，2018年。（https://arxiv.org/abs/1810.04805）

    4. RoBERTa：一种经过严格优化的BERT预训练方法 — Liu等，2019年。(https://arxiv.org/abs/1907.11692)

    5. 语言模型是无监督的多任务学习者（GPT2） — Radford等人，2019年。（https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf）

    6. XLNet：用于语言理解的广义自回归预训练 — Yang等人，2019年。(https://arxiv.org/abs/1906.08237)

    7. Stanza：适用于多种人类语言的Python自然语言处理工具包 — Peng等人，2020年。(https://arxiv.org/abs/2003.07082)

 

 

往期精品内容推荐

观点问题如何练就“火眼金睛”？百度人工智能开源大赛开启报名

20年校招DL/NLP/推荐系统/ML/算法基础面试必看300问及答案

2020年新书-《神经网络新手入门必备数学基础》免费pdf分享

免费好书-《机器学习入门-第二版》最新pdf分享

GPT-3语言模型原理详细解读

机器学习基础-《统计学习-SLT》教材分享

DeepMind 2020年新课-《强化学习进阶课程》视频分享

中文自然语言处理医疗、法律等公开数据集整理分享

自然语言领域中图神经网络模型（GNN）应用现状（论文）

深度学习基础：正向模型、可微损失函数与优化

新书分享-嵌入式深度学习：持续性神经网路算法、结构和电路设计

深度神经网络压缩和加速相关最全资源分享

  在本文中，将详细介绍目前常用的Python NLP库。
内容译自网络。
    这些软件包可处理多种NLP任务，例如词性（POS）标注，依存分析，文档分类，主题建模等等。
NLP库的基本目标是简化文本预处理。
    目前有许多工具和库用于解决NLP问题……但是只要掌握了其中的一些基本知识，就可以掌握相关基本知识。这就是为什么只介绍其中最常用的五个Python NLP库的原因。
    但是在此之前，应该掌握有关NLP的各个组成领域和主题的一些基础知识。
    扎实基础
    对于学习自然语言处理的理论基础，网络上有丰富的资源可以学习：
    · 斯坦福课程 — 深度学习中的自然语言处理（http://web.stanford.edu/class/cs224n/）
    · Deeplearning.ai专业化 - 自然语言处理专业（https://www.coursera.org/specializations/natural-language-processing）
    · 适用于基础知识的最佳书籍（又名NLP圣经） — 自然语言处理，语音识别和计算语言学导论（https://web.stanford.edu/~jurafsky/slp3/）
    · 另一本不错的参考书 - 统计自然语言处理的基础（https://nlp.stanford.edu/fsnlp/）
    1. Spacy
    spaCy 是Python中比较出名，专门用于自然语言处理的库。它有助于实现最先进的效率和敏捷性，并拥有活跃的开源组织积极贡献代码。
   加分项：
    · 与所有主要的深度学习框架很好地结合，并预装了一些出色且有用的语言模型
    · 由于Cython支持，速度相对较快
    使用spaCy最适合做的事情
1. 词性（POS）标注：这是给单词标记制定语法属性（例如名词，动词，形容词，副词等）过程。
    2. 实体识别：将文本中发现的命名实体标记到预定义实体类型。
  3. 依存分析：分配语法依存标签，描述各个标记（例如主题或客体）之间的关系。
  4. 文本分类：为整个文档或文档的一部分分配类别或标签。
5. 句子边界检测（SBD）：查找和分割单个句子。
    相关资源
    免费官方课程的链接：基于spaCy的高级NLP（https://course.spacy.io/en/）
 官方课程
    更多资源
    · 一篇不错的博客文章，包括安装过程和其他Spacy用法（入门博客）：使用Python中的spaCy进行自然语言处理（https://realpython.com/natural-language-processing-spacy-python/）
    · Python Spacy简介（视频）— 视频讲座和教程（https://realpython.com/natural-language-processing-spacy-python/）
    2. NLTK
    NLTK是目前可用的最优秀的NLP模型训练库之一。该库是NLP入门python库。它是NLP的初学者常用的库。它具有许多预先训练的模型和语料库，可帮助我们非常快速地分析事物。
加分项：内置支持数十种语料库和训练完备的模型
    使用NLTK可以实现一下需求：
1. 推荐：可以基于相似性来推荐内容。
2. 情感分析：通过自然语言处理来衡量人们的观点倾向
 3. Wordnet [1]支持：我们可以使用Synset 在WordNet中查找单词。因此可以访问许多单词的同音异义词，上位词，同义词，定义，词族等
    4. 机器翻译：用于将源语言翻译成目标语言
    其他资源
    · 学习NLTK的最佳资源是官方的教材：《使用自然语言工具包分析文本》（https://www.nltk.org/book/）
    · 相关文章整理：Python的NLTK（自然语言工具包）教程（https://www.guru99.com/nltk-tutorial.html）
    · Wordnet文档— WordNet 3.0参考手册（https://wordnet.princeton.edu/documentation）
    与spaCy专注于提供用于生产用途的软件不同，NLTK被广泛用于教学和研究— Wikipedia
    3.Transformers
    来自Transformers GitHub Repo
    该Transformers库是开源，基于社区的信息库，使用和共享模型基于Transformer结构[2]如Bert[3]，Roberta[4]，GPT2 [5]，XLNet [6]，等等
    该库提供自然语言理解（NLU）和自然语言生成（NLG）任务预训练模型下载。
  加分项：超过32种采用100种以上语言的训练的预训练模型，以及TensorFlow 2.0和PyTorch之间的深度互操作性。最适合深度学习。
   Transformers可以做到一下事情
1. 摘要生成：摘要是将文本/文章摘要为较短文本的任务。
2. 翻译：将文本从一种语言翻译成另一种语言的任务。
  3. 文本生成：基于上下文，生成连贯的下文。
  4. 抽取式问答：从给定问题的文本中提取答案的任务。
  相关资源：
 · 官方文档-HuggingfaceTransformers（https://huggingface.co/transformers/）
    · 使用BERT，HuggingFace和AWS Lambda构建问题解答API – 使用HuggingFace和AWS Lambda的无服务器BERT（https://towardsdatascience.com/serverless-bert-with-huggingface-and-aws-lambda-625193c6cc04）
    · 了解如何微调BERT以进行情感分析— 使用BERT和Transformers进行情感分析（https://www.curiousily.com/posts/sentiment-analysis-with-bert-and-hugging-face-using-pytorch-and-python/）
    4. Gensim
    Gensim是一个Python库，专门用于通过向量空间建模和主题建模工具包来识别两个文档之间的语义相似性
    顺便说一下，它是“ Generate Similar”（Gensim）的缩写：)
    优点：高水平的处理速度和可以处理大量文本。
    Gensim适合处理的需求：
 1. 分布式计算：它可以在计算机集群上运行隐语义分析和隐Dirichlet分配。（可以处理大量数据的原因）
 2. 文档索引：将信息与文件或特定标签相关联的过程，以便以后可以轻松检索
3. 主题建模：自动聚类单词group和定义一组文档的相似表达式。
4. 相似性检索：处理文档存储库中相似信息的组织，存储，检索和评估（此处为文本信息）
资源
    · 官方API文档-API参考（https://radimrehurek.com/gensim/apiref.html）
· 官方教程- 核心教程（https://radimrehurek.com/gensim/auto_examples/）
    · 使用Gensim LDA进行分层文档聚类— 使用Python进行文档聚类（http://brandonrose.org/clustering#Latent-Dirichlet-Allocation）
    · 安装，处理等入门教程— 适用于NLP的Python：使用Gensim库（https://stackabuse.com/python-for-nlp-working-with-the-gensim-library-part-1/）
    5. Stanza
Stanza将许多准确而有效自然语言处理工具收集在一起，组成工具包。从原始文本到句法分析和实体识别，Stanza将最新的NLP模型引入语言处理中。
    该工具包建立在PyTorch库的之上，并支持使用GPU和预训练的神经模型。
此外，Stanza包括一个CoreNLP Java包的Python接口，并从那里继承了附加功能。
优点：快速，准确，并且能够支持几种主要语言。适用于生产部署环境。
资源：CoreNLP的Python包装器列表（http://stanfordnlp.github.io/CoreNLP/other-languages.html#python）
Stanza适合处理的需求：
 1. 形态特征标记：对于句子中的每个单词，Stanza都会评估其普遍的形态特征（例如，单身/复数，第一/第二/第三人称等）。
 2. 多词令牌扩展：将句子扩展成句法词，作为下游处理的基础。
  这五个库的固有特性使其成为依赖于机器对人类表达的理解的所有项目的首选。
  参考文献
    1. WordNet简介：在线词汇数据库 — George A. Miller等。1993年（https://wordnetcode.princeton.edu/5papers.pdf）
    2. Attention Is All You Need — Vaswani等人，2017。(https://arxiv.org/abs/1706.03762)
    3. BERT：用于语言理解的深度双向Transformers的预训练 — Devlin等人，2018年。（https://arxiv.org/abs/1810.04805）
    4. RoBERTa：一种经过严格优化的BERT预训练方法 — Liu等，2019年。(https://arxiv.org/abs/1907.11692)
    5. 语言模型是无监督的多任务学习者（GPT2） — Radford等人，2019年。（https://cdn.openai.com/better-language-models/language_models_are_unsupervised_multitask_learners.pdf）
    6. XLNet：用于语言理解的广义自回归预训练 — Yang等人，2019年。(https://arxiv.org/abs/1906.08237)
    7. Stanza：适用于多种人类语言的Python自然语言处理工具包 — Peng等人，2020年。(https://arxiv.org/abs/2003.07082)
往期精品内容推荐
观点问题如何练就“火眼金睛”？百度人工智能开源大赛开启报名
20年校招DL/NLP/推荐系统/ML/算法基础面试必看300问及答案
2020年新书-《神经网络新手入门必备数学基础》免费pdf分享
免费好书-《机器学习入门-第二版》最新pdf分享
GPT-3语言模型原理详细解读
机器学习基础-《统计学习-SLT》教材分享
DeepMind 2020年新课-《强化学习进阶课程》视频分享
中文自然语言处理医疗、法律等公开数据集整理分享
自然语言领域中图神经网络模型（GNN）应用现状（论文）
深度学习基础：正向模型、可微损失函数与优化
新书分享-嵌入式深度学习：持续性神经网路算法、结构和电路设计
深度神经网络压缩和加速相关最全资源分享

简述
上一篇简单概述了下Relation Classification via Convolutional Deep Neural Network（2014）的论文内容，这一篇简单地阅读学习下此篇论文的复现代码（来自FrankWork from github）。

项目结构主要如下：

base_model.py: 为模型设置保存、加载路径（ckpt）。
cnn_model.py：主要层（nonlinear、CNN）以及整体模型的实现。
train.py：参数及超参数设置，训练及测试实现。
base.py: 数据预处理及训练集、测试集的加载。

下面主要关注前三个文件：
base_model.py
class BaseModel(object):

  @classmethod
  def set_saver(cls, save_dir):
    '''
    Args:
      save_dir: relative path to FLAGS.logdir
    '''
    # shared between train and valid model instance
    # saver
    cls.saver = tf.train.Saver(var_list=None)
    # 保存路径
    cls.save_dir = os.path.join(FLAGS.logdir, save_dir)
    # 保存文件ckpt
    cls.save_path = os.path.join(cls.save_dir, "model.ckpt")

  @classmethod
  def restore(cls, session):
    # 加载模型
    ckpt = tf.train.get_checkpoint_state(cls.save_dir)
    cls.saver.restore(session, ckpt.model_checkpoint_path)

  @classmethod
  def save(cls, session, global_step):
    # 保存模型
    cls.saver.save(session, cls.save_path, global_step)

这段比较简单，设置下模型训练中基本的保存和加载路径等信息，之后BaseModel类方便CNNModel继承。
cnn_model.py
def linear_layer(name, x, in_size, out_size, is_regularize=False):
    # 非线性全连接层
  with tf.variable_scope(name):
      # L2正则化
    loss_l2 = tf.constant(0, dtype=tf.float32)
    w = tf.get_variable('linear_W', [in_size, out_size],
                      initializer=tf.truncated_normal_initializer(stddev=0.1))
    b = tf.get_variable('linear_b', [out_size], 
                      initializer=tf.constant_initializer(0.1))
    o = tf.nn.xw_plus_b(x, w, b) # batch_size, out_size
    if is_regularize:
        # 对W和b均使用正则化
      loss_l2 += tf.nn.l2_loss(w) + tf.nn.l2_loss(b)
    return o, loss_l2

这个函数为非线性全连接层的实现，可以看到，作者简单地对W和b应用了L2正则化。这样使用正则化在较小的模型中没有问题，如果模型复杂的话，不方便这样使用，会让loss部分代码冗长。
def cnn_forward(name, sent_pos, lexical, num_filters):
    # 文本CNN
  with tf.variable_scope(name):
    # [batch, seq_length, emb_size+2*pos_emb, 1]
    input = tf.expand_dims(sent_pos, axis=-1)
    input_dim = input.shape.as_list()[2]

    # convolutional layer
    pool_outputs = []
    # 3种size的卷积核
    for filter_size in [3,4,5]:
      with tf.variable_scope('conv-%s' % filter_size):
        # [ filter_size, emb_size, in_channel, num_filters ]
        conv_weight = tf.get_variable('W1', 
                            [filter_size, input_dim, 1, num_filters],
                            initializer=tf.truncated_normal_initializer(stddev=0.1))
        # [num_filters]
        conv_bias = tf.get_variable('b1', [num_filters], 
                              initializer=tf.constant_initializer(0.1))
        # SAME考虑边界，用 0 填充
        conv = tf.nn.conv2d(input,
                            conv_weight,
                            strides=[1, 1, input_dim, 1],
                            padding='SAME')
        # [batch_size, len, 1, num_filters]
        conv = tf.nn.relu(conv + conv_bias)
        max_len = FLAGS.max_len
        # [batch_size, 1, 1, num_filters],去除与长度相关的这一维
        pool = tf.nn.max_pool(conv, 
                              ksize= [1, max_len, 1, 1],# 池化窗口大小
                              strides=[1, max_len, 1, 1],  #每一维度滑动步长
                              padding='SAME') # batch_size, 1, 1, num_filters
        pool_outputs.append(pool)
    # [batch, 3*num_filters]
    pools = tf.reshape(tf.concat(pool_outputs, 3), [-1, 3*num_filters])

    # feature 
    feature = pools
    if lexical is not None:
      # [batch, 6*emb_size + 3*num_filters]
      feature = tf.concat([lexical, feature], axis=1)
    return feature

这段是此模型中sentence level的部分的关键一层，代码作者用了3、4、5三个filter_size的各filter_num个卷积核来做普通的文本卷积，然后接了个max池化层，最后和lexical level的词向量（多个词向量concat后）进行concat。需要注意的是，这里的max polling对应的维度是seq_length这一维，论文中这样实现是为了尽量减小文本长度不一的影响。最后输出的tensor的形状是 [batch, 6emb_size + 3num_filters]。
class CNNModel(BaseModel):
  '''
  Relation Classification via Convolutional Deep Neural Network
  http://www.aclweb.org/anthology/C14-1220
  '''

  def __init__(self, word_embed, data, word_dim, 
              pos_num, pos_dim, num_relations,
              keep_prob, num_filters,
              lrn_rate, is_train):
    # input data
    lexical, rid, sentence, pos1, pos2 = data

    # embedding initialization
    w_trainable = True if FLAGS.word_dim==50 else False
    # emb_table词向量表
    word_embed = tf.get_variable('word_embed', 
                      initializer=word_embed,
                      dtype=tf.float32,
                      trainable=w_trainable)
    # [pos_num, pos_emb]
    pos1_embed = tf.get_variable('pos1_embed', shape=[pos_num, pos_dim])
    pos2_embed = tf.get_variable('pos2_embed', shape=[pos_num, pos_dim])


    # # embedding lookup
    # 词级别，[batch, 6] -> [batch, 6, emb_size]
    lexical = tf.nn.embedding_lookup(word_embed, lexical) # batch_size, 6, word_dim
    lexical = tf.reshape(lexical, [-1, 6*word_dim])     # [batch, 6*emb_size]
    self.labels = tf.one_hot(rid, num_relations)       # batch_size, num_relations

    # [batch, seq_length] ->[batch, seq_length, emb_size]
    sentence = tf.nn.embedding_lookup(word_embed, sentence)   # batch_size, max_len, word_dim
    pos1 = tf.nn.embedding_lookup(pos1_embed, pos1)       # batch_size, max_len, pos_dim
    pos2 = tf.nn.embedding_lookup(pos2_embed, pos2)       # batch_size, max_len, pos_dim

    # cnn model
    sent_pos = tf.concat([sentence, pos1, pos2], axis=2) # [batch, seq_length, emb_size+2*pos_emb]
    if is_train:
      # 句级别
      sent_pos = tf.nn.dropout(sent_pos, keep_prob)

    # 词级别+句级别， [batch, 6*emb_size+3*num_filters]
    feature = cnn_forward('cnn', sent_pos, lexical, num_filters)
    feature_size = feature.shape.as_list()[1]
    self.feature = feature
    
    if is_train:
      feature = tf.nn.dropout(feature, keep_prob)

    # Map the features to n classes
    # 非线性层
    logits, loss_l2 = linear_layer('linear_cnn', feature, 
                                  feature_size, num_relations, 
                                  is_regularize=True)

    prediction = tf.nn.softmax(logits) # 0<prebs<1
    prediction = tf.argmax(prediction, axis=1)
    accuracy = tf.equal(prediction, tf.argmax(self.labels, axis=1))
    accuracy = tf.reduce_mean(tf.cast(accuracy, tf.float32))
    # 平均交叉熵
    loss_ce = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=self.labels, logits=logits))

    self.logits = logits
    self.prediction = prediction
    self.accuracy = accuracy
    # 正则化（只包含全连接层的w和b）
    self.loss = loss_ce + 0.01*loss_l2

    if not is_train:
      return 

    # global_step = tf.train.get_or_create_global_step()
    global_step = tf.Variable(0, trainable=False, name='step', dtype=tf.int32)
    optimizer = tf.train.AdamOptimizer(lrn_rate)

    # for Batch norm
    # 为了更新 moving_mean和moving_variance
    # tf.GraphKeys.UPDATE_OPS，
    # 这是一个tensorflow的计算图中内置的一个集合，
    # 其中会保存一些需要在训练操作之前完成的操作，
    # 并配合tf.control_dependencies函数使用。
    # 关于在batch_norm中，即为更新mean和variance的操作
    update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS)
    # tf.control_dependencies，该函数保证其辖域中的操作必须要在该函数所传递的参数中的操作完成后再进行
    with tf.control_dependencies(update_ops):
      self.train_op = optimizer.minimize(self.loss, global_step)
    self.global_step = global_step

这一部分就是把之前写好的nonlinear层和CNN层按照论文思路组装好，CNNModel类继承了之前提到的BaseModel类（保存加载等信息），需要注意的是作者最后这里提到了使用Batch Norm，上面的注释写的很清楚了，注意想要正确使用BN的话，要利用好tf.get_collection(tf.GraphKeys.UPDATE_OPS)和tf.control_dependencies这两个API。这里的loss和L2正则化这样做加法没有问题，但当网络复杂了后会不怎么方便，推荐下述使用方法使用正则化。
def build_train_valid_model(word_embed, train_data, test_data):
  '''Relation Classification via Convolutional Deep Neural Network'''
  # 实际调用CNN_model
  with tf.name_scope("Train"):
    with tf.variable_scope('CNNModel', reuse=None):
      m_train = CNNModel( word_embed, train_data, FLAGS.word_dim,
                    FLAGS.pos_num, FLAGS.pos_dim, FLAGS.num_relations,
                    FLAGS.keep_prob, FLAGS.num_filters, 
                    FLAGS.lrn_rate, is_train=True)
  with tf.name_scope('Valid'):
    with tf.variable_scope('CNNModel', reuse=True):
      m_valid = CNNModel( word_embed, test_data, FLAGS.word_dim,
                    FLAGS.pos_num, FLAGS.pos_dim, FLAGS.num_relations,
                    1.0, FLAGS.num_filters, 
                    FLAGS.lrn_rate, is_train=False)
  return m_train, m_valid

这段函数没什么好说的，返回两个CNNModel的实例（训练用和验证用）。
正则化
当网络复杂的时候定义网络的结构部分和计算损失函数的部分可能不在一个函数中，这样通过上面那种简单的变量这种计算损失函数就不方便了。此时可以使用Tensorflow中提供的集合，它可以在一个计算图（tf.Graph）中保存一组实体（比如张量）。
def get_weight(shape, lambda1):
 	# 生成一个变量
    var = tf.Variable(tf.random_normal(shape), dtype=tf.float32)
    # add_to_collection()函数将新生成变量的L2正则化损失加入集合losses
    # lambda1为正则化乘上的系数
    tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambda1)(var)) 
    return var # 返回生成的变量
	
.......
weight = get_weight([in_dimension, out_dimension], 0.003)
.......

# 在定义神经网络前向传播的同时已经将所有的L2正则化损失加入了图上的集合，这里是损失函数的定义。 
mean_loss = tf.reduce_mean(loss)
# 将均方误差损失函数加入损失集合
tf.add_to_collection('losses', mean_loss) 
# get_collection()返回一个列表，这个列表是所有这个集合中的元素，
# 在本样例中这些元素就是损失函数的不同部分，将他们加起来就是最终的损失函数 
loss = tf.add_n(tf.get_collection('losses'))

.......

# 用优化器最小化加了L2正则的loss即可
train_op = tf.train.AdamOptimizer(0.001).minimize(loss)

train.py
flags = tf.app.flags

flags.DEFINE_string("train_file", "data/train.cln", 
                             "original training file")
flags.DEFINE_string("test_file", "data/test.cln", 
                             "original test file")

flags.DEFINE_string("vocab_file", "data/vocab.txt", 
                              "vocab of train and test data")

flags.DEFINE_string("google_embed300_file", 
                             "data/embed300.google.npy", 
                             "google news word embeddding")
flags.DEFINE_string("google_words_file", 
                             "data/google_words.lst", 
                             "google words list")
flags.DEFINE_string("trimmed_embed300_file", 
                             "data/embed300.trim.npy", 
                             "trimmed google embedding")

flags.DEFINE_string("senna_embed50_file", 
                             "data/embed50.senna.npy", 
                             "senna words embeddding")
flags.DEFINE_string("senna_words_file", 
                             "data/senna_words.lst", 
                             "senna words list")
flags.DEFINE_string("trimmed_embed50_file", 
                             "data/embed50.trim.npy", 
                             "trimmed senna embedding")

flags.DEFINE_string("train_record", "data/train.tfrecord", 
                             "training file of TFRecord format")
flags.DEFINE_string("test_record", "data/test.tfrecord", 
                             "Test file of TFRecord format")


flags.DEFINE_string("relations_file", "data/relations.txt", "relations file")
flags.DEFINE_string("results_file", "data/results.txt", "predicted results file")
flags.DEFINE_string("logdir", "saved_models/", "where to save the model")

flags.DEFINE_integer("max_len", 96, "max length of sentences")
flags.DEFINE_integer("num_relations", 19, "number of relations")
flags.DEFINE_integer("word_dim", 50, "word embedding size")
flags.DEFINE_integer("num_epochs", 200, "number of epochs")
flags.DEFINE_integer("batch_size", 100, "batch size")

flags.DEFINE_integer("pos_num", 123, "number of position feature")
flags.DEFINE_integer("pos_dim", 5, "position embedding size")
flags.DEFINE_integer("num_filters", 100, "cnn number of output unit")

flags.DEFINE_float("lrn_rate", 1e-3, "learning rate")
flags.DEFINE_float("keep_prob", 0.5, "dropout keep probability")

flags.DEFINE_boolean('test', False, 'set True to test')
flags.DEFINE_boolean('trace', False, 'set True to test')

FLAGS = tf.app.flags.FLAGS


def trace_runtime(sess, m_train):
  '''
  trace runtime bottleneck using timeline api
  navigate to the URL 'chrome://tracing' in a Chrome web browser, 
  click the 'Load' button and locate the timeline file.
  '''
  # 运行时记录运行信息的protocolmessage
  run_metadata=tf.RunMetadata()
  options = tf.RunOptions(trace_level=tf.RunOptions.FULL_TRACE)
  from tensorflow.python.client import timeline
  trace_file = open('timeline.ctf.json', 'w')

  fetches = [m_train.train_op, m_train.loss, m_train.accuracy]
  _, loss, acc = sess.run(fetches, 
                            options=options, 
                            run_metadata=run_metadata)
                            
  trace = timeline.Timeline(step_stats=run_metadata.step_stats)
  trace_file.write(trace.generate_chrome_trace_format())
  trace_file.close()


def train(sess, m_train, m_valid):
  n = 1
  best = .0
  best_step = n
  start_time = time.time()
  orig_begin_time = start_time

  fetches = [m_train.train_op, m_train.loss, m_train.accuracy]

  while True:
    try:
      _, loss, acc = sess.run(fetches)

      epoch = n // 80
      if n % 80 == 0:
        now = time.time()
        duration = now - start_time
        start_time = now
        v_acc = sess.run(m_valid.accuracy)
        if best < v_acc:
          best = v_acc
          best_step = n
          m_train.save(sess, best_step)
        print("Epoch %d, loss %.2f, acc %.2f %.4f, time %.2f" % 
                                  (epoch, loss, acc, v_acc, duration))
        sys.stdout.flush()
      n += 1
    except tf.errors.OutOfRangeError:
      break

  duration = time.time() - orig_begin_time
  duration /= 3600
  print('Done training, best_step: %d, best_acc: %.4f' % (best_step, best))
  print('duration: %.2f hours' % duration)
  sys.stdout.flush()

def test(sess, m_valid):
  m_valid.restore(sess)
  fetches = [m_valid.accuracy, m_valid.prediction]
  accuracy, predictions = sess.run(fetches)
  print('accuracy: %.4f' % accuracy)
  
  base_reader.write_results(predictions, FLAGS.relations_file, FLAGS.results_file)

这段代码主要用flag设置了本模型的一些参数和超参等信息，并且设置了三个函数来调用之前写好的训练和验证用的模型类实例。
def main(_):
  with tf.Graph().as_default():
    train_data, test_data, word_embed = base_reader.inputs()
    
    
    m_train, m_valid = cnn_model.build_train_valid_model(word_embed, 
                                                      train_data, test_data)
    
    m_train.set_saver('cnn-%d-%d' % (FLAGS.num_epochs, FLAGS.word_dim))
    
    init_op = tf.group(tf.global_variables_initializer(),
                        tf.local_variables_initializer())# for file queue

    # GPU config
    config = tf.ConfigProto()
    # config.gpu_options.per_process_gpu_memory_fraction = 0.9 # 占用GPU90%的显存 
    config.gpu_options.allow_growth = True
    
    # sv finalize the graph
    with tf.Session(config=config) as sess:
      sess.run(init_op)
      print('='*80)

      if FLAGS.trace:
        trace_runtime(sess, m_train)
      elif FLAGS.test:
        test(sess, m_valid)
      else:
        train(sess, m_train, m_valid)



if __name__ == '__main__':
  # 如果你的代码中的入口函数不叫main()，而是一个其他名字的函数，
  # 如test()，则你应该这样写入口tf.app.run(test)
  # 通过处理flag解析，然后执行main函数
  tf.app.run()

这里主要用了tf.app.run()这个API来训练。
dataset的使用（待补充）