精华内容
下载资源
问答
  • 5个NLP代码

    2020-09-25 14:34:37
    来源于:每个人都应该知道的5个NLP代码库 1. Spacy spaCy 是Python中比较出名,专门用于自然语言处理的库。它有助于实现最先进的效率和敏捷性,并拥有活跃的开源组织积极贡献代码。 加分项: 与所有主要的深度学习...

    来源于:每个人都应该知道的5个NLP代码库
    1. Spacy
    spaCy 是Python中比较出名,专门用于自然语言处理的库。它有助于实现最先进的效率和敏捷性,并拥有活跃的开源组织积极贡献代码。
    加分项:

    • 与所有主要的深度学习框架很好地结合,并预装了一些出色且有用的语言模型
    • 由于Cython支持,速度相对较快
      使用spaCy最适合做的事情
    1. 词性(POS)标注:这是给单词标记制定语法属性(例如名词,动词,形容词,副词等)过程。
    2. 实体识别:将文本中发现的命名实体标记到预定义实体类型。
    3. 依存分析:分配语法依存标签,描述各个标记(例如主题或客体)之间的关系。
    4. 文本分类:为整个文档或文档的一部分分配类别或标签。
    5. 句子边界检测(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库的基本目标是简化文本预处理。 目前有许多...

        在本文中,将详细介绍目前常用的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机器学习——文本情感分析(英文文本情感分析)代码下载,代码完整可以运行。希望可以帮助到正在学习的伙伴们。
  • 在本文中,将详细介绍目前常用的Python NLP库。内容译自网络。 这些软件包可处理多种NLP任务,例如词性(POS)标注,依存分析,文档分类,主题建模等等。NLP库的基本目标是简化文本预处理。 目前有许多工具和库用于...

    76b0168a88d847fbd1048505376f2934.png

    在本文中,将详细介绍目前常用的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/

    ce76a465ea67d38d1bfb5f7f58310b3e.png

    官方课程

    更多资源

    · 一篇不错的博客文章,包括安装过程和其他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

    6b0e21a5aa8d74829b77bf8f28c5c297.png

    来自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的使用(待补充)

    展开全文
  • 推荐github上的一个NLP代码教程:nlp-tutorial,教程中包含常见的NLP模型代码实现(基于Pytorch1.0+),而且教程中的大多数NLP模型都使用少于100行代码。教...
  • NLP之旅(包含NLP文章/代码集锦)
  • 推荐github上的一个NLP代码教程:nlp-tutorial,教程中包含常见的NLP模型代码实现(基于TensorFlow和Pytorch),而且教程中的大多数NLP...
  • nlp学习code c代码

    2019-02-14 17:35:45
    语言分析 nlp学习ppt及代码
  • 推荐github上的一个NLP代码教程:nlp-tutorial,教程中包含常见的NLP模型代码实现(基于TensorFlow和Pytorch),而且教...
  • 推荐github上的一个NLP代码实现的教程:nlp-tutorial,一个使用TensorFlow和Pytorch学习NLP(自然语言处理)的教程,教程中的大多数NLP模型都使用少于100行代码实现。教程说明这是使用TensorFlow和Pytorch学习NLP...
  • 系列语:本系列是nlp-tutorial代码注释系列,github上原项目地址为:nlp-tutorial,本系列每一篇文章的大纲是相关知识点介绍 + 详细代码注释。 传送门: nlp-tutorial代码注释1-1,语言模型、n-gram简介 nlp-...
  • NLP相似度计算代码

    2018-03-15 13:22:13
    Natural Language Processing
  • NLP-tutorial代码笔记1

    2019-07-04 19:24:44
    现在开的坑系列是Github上一个即将3k+Star的NLP-tutorial项目,里面是一些NLP方面的Deep-learning代码,框架Tensor和Torch都有,而且实现行数基本都控制在了100行以内,比较适合去研究一下。这样之后搭框架的时候就...
  • NLP_代码表示文本向量

    2020-07-23 15:12:23
    第一种表示方式 Count 次数 from sklearn.feature_extraction.text import CountVectorizer corpus = [ 'This is the first document .... 'this document is the second document.', 'the last one' ...
  • NLP 主题抽取Topic LDA代码实践 gensim包 代码  分享一个代码实践:用gensim包的LDA模型实践NLP的一个典型任务,主题抽取。  顺带提一点,对于NLP任务,最好的方式就是先在代码上跑通起来,然后再进行理论深究...
  • NLP-tutorial代码笔记2

    2019-07-09 22:02:39
    现在开的坑系列是Github上一个即将3k+Star的NLP-tutorial项目,里面是一些NLP方面的Deep-learning代码,框架Tensor和Torch都有,而且实现行数基本都控制在了100行以内,比较适合去研究一下。这样之后搭框架的时候就...
  • NLP课程的笔记与代码

    2021-01-17 10:36:48
    2019最新AI自然语言处理之深度机器学习顶级项目实战课程做的笔记与代码
  • 内包含宗成庆讲课录像,课件,第二版教材,课程作业,期末题,哥伦比亚大学NLP实战代码
  • Github https://github.com/sebastianruder/NLP-progress ...NLP-Progress 同时涵盖了传统的NLP任务,如依赖解析和词性标注,和一些新的任务,如阅读理解和自然语言推理。它的不仅为读者提供这些任务的 ba...
  • 这是一个练手MLP、CNN、RNN的demo,pytorch实现。包含预处理,数据加载,模型构建,训练,测试,性能展示训练模型全套。细致讲解整个代码实现过程的每一步。
  • 在获得文本之后   将所有字母转换为小写或大写   目录 在获得文本之后 ...将所有字母转换为小写或大写 ...分块是一种自然的语言过程,用于识别组成部分把句子(名词、动词、形容词等)联系起来具有离散语法意义的顺...
  • Harvard NLP The Annotated Transformer 学习代码: The Annotated Transformer 论文: 注意力模型:       多注意力模型结构:    Transformer 编码器、解码器结构:   Tran...
  • NLP整体流程的代码

    2018-07-26 02:46:00
    import nltk import numpy as np import re from nltk.corpus import stopwords # 1 分词1 ...text = "Sentiment analysis is a challenging subject in machine learning.\ ... People express their emotions in.....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,558
精华内容 1,023
关键字:

nlp代码