【NLP】BERT代码实现--Bert4keras源码及矩阵计算解析

最新推荐文章于 2024-08-08 07:51:43 发布
最新推荐文章于 2024-08-08 07:51:43 发布
阅读量2.9k 收藏 14
点赞数 1
分类专栏： NLP-乘着Keras遨游人工智能世界 文章标签： 深度学习 nlp
本文链接：https://blog.csdn.net/ZJJDJJ/article/details/108646389
版权

bert4keras源码及矩阵计算

前言

bert4keras是苏剑林通过keras封装Bert，可以更快速、更友好的使用Bert。
bert4keras链接：https://github.com/bojone/bert4keras
本文是对该链接下bert4keras/bert4keras/的源码进行解析

源码重要性

个人认为了解源码非常重要，主要有两个看法：

  1. 了解源码会让你对原理有个更好的了解，在做下游任务或者模改的时候就更加游刃有余；
  2. 源码中会有很多在代码实现的骚套路，学学后会大大提升自己写代码的能力和简洁性。

在解析bert4keras源码前，需要各位具备如下知识：

  • BERT的基本原理(或Transformer原理)
  • Keras中层(Layer)的定义方式和使用(可以参考苏神科学空间的：“让Keras更酷一些！”：精巧的层与花式的回调：https://kexue.fm/archives/5765)
  • MultiAttention(可以参考本人写的：“基于keras的MultiAttention实现及实例”：https://zhuanlan.zhihu.com/p/231631291)

Bert4keras框架

bert4keras的总体架构由6个代码文件组成，主文件是models.py，其余的文件均为主文件服务，或者为下游任务的建模过程中服务。

models.py：主文件，主体Transformer类，其余的都是以Transformer为父类实现其算法，包括BERT，ALBERT，NEZHA，ELECTRA，GPT2_ML，T5的算法及其优化

layers.py: 实现各类功能的层，类似Keras中的layer，这里包括Embedding，MultiHeadAttention（多头注意力），LayerNormalization，PositionEmbedding（位置编码），RelativePositionEmbedding（相对位置编码），FeedForward等实现

本篇从主文件models.py开始介绍

Transformer类

Transformer类写好了bert等这类预训练模型的整体框架，主要在build，call两个函数中实现。
包括三大内容(在build函数中)：Input(输入)，self.call(算法计算流程)，Model(建模)
实现框架如下图：
在这里插入图片描述
apply函数的妙用：在Transformer类中的apply函数的妙用:通过apply调用层会自动重用同名层，每次层进来都会存储在self.layers字典中，相同名字的层会重复使用，这样很好用而且在后面的Albert中要共享参数的时候也方便实现。

    def apply(self, inputs, layer=None, arguments=None, **kwargs):
        """通过apply调用层会自动重用同名层
        inputs: 上一层的输出；
        layer: 要调用的层类名；
        arguments: 传递给layer.call的参数；
        kwargs: 传递给层初始化的参数。
        """
        if layer is Dropout and self.dropout_rate == 0:
            return inputs

        arguments = arguments or {}
        name = kwargs.get('name')  # name='Embedding-Token'
        if name not in self.layers:
            layer = layer(**kwargs)
            name = layer.name
            self.layers[name] = layer  # 保存下来,方便重复调用

        return self.layers[name](inputs, **arguments)  # 可以看Bert中的详细用法

算法实现（以Bert为例）

依照Transformer类的逻辑顺序，总结如下：

  1. Input(输入)
    get_inputs函数：
    实现bert的输入: token(x_in)和segment(s_in)
    shape均为：shape=(btz, seq_len)
    输出：[x_in, s_in]
  2. self.call(算法计算流程)

  • apply_embedding：转成字向量
    x embedding – s embedding – x&s add – Position embedding – LN – dropout
    输出shape=(btz, seq_len, hidden_size)

  • apply_main_layers：计算流程主体
    循环num_hidden_layers次：
    Bert计算主体：Att --> DROPOUT --> Add --> LN --> FFN --> DROPOUT --> Add --> LN
    输出shape=(btz, seq_len, intermediate_size)

  • apply_final_layers：根据下流任务调整输出
    with_pool:提取CLS向量，用CLS向量表示这句话的句向量 shape=(btz, 768)
    with_nsp:预测是否是下一句，shape=(btz, 2)
    with_mask:Mask LM mask语言模型，在预训练的时候会用到，或者要预测句中某个字或词的时候可以用到

代码及矩阵张量运算见代码注释：

class BERT(Transformer):
    """构建BERT模型
    """
    def __init__(
            self,
            max_position,  # 序列最大长度
            with_pool=False,  # 是否包含Pool部分
            with_nsp=False,  # 是否包含NSP部分
            with_mlm=False,  # 是否包含MLM部分
            **kwargs  # 其余参数
    ):
        super(BERT, self).__init__(**kwargs)
        self.max_position = max_position
        self.with_pool = with_pool
        self.with_pool = with_pool
        self.with_nsp = with_nsp
        self.with_mlm = with_mlm

    def get_inputs(self):
        """BERT的输入是token_ids和segment_ids
        """
        x_in = Input(shape=(self.sequence_length,), name='Input-Token')  # shape=(btz, seq_len)
        s_in = Input(shape=(self.sequence_length,), name='Input-Segment')  # shape=(btz, seq_len)
        return [x_in, s_in]

    def apply_embeddings(self, inputs):
        """BERT的embedding是token、position、segment三者embedding之和
        """
        x, s = inputs  # x和s均为shape=(btz, seq_len)
        z = self.layer_norm_conds[0]  # 条件概率

        # x embedding嵌入
        x = self.apply(
            inputs=x,
            layer=Embedding,
            input_dim=self.vocab_size,
            output_dim=self.embedding_size,
            embeddings_initializer=self.initializer,
            mask_zero=True,
            name='Embedding-Token'
        )  # 可以拆成四个部分：1、inputs=x 是上一个的输出； 2、layer=Embedding层函数；3、从layer一直到name之间的参数，都是层函数中的参数；4、name该层的名字，存储在self.layer中
        # 实为Embedding(input_dim=self.vocab_size, output_dim=self.embedding_size, embeddings_initializer=self.initializer, mask_zero=True)(x)； 后面全部同理

        # s embedding嵌入
        s = self.apply(
            inputs=s,
            layer=Embedding,
            input_dim=2,
            output_dim=self.embedding_size,
            embeddings_initializer=self.initializer,
            name='Embedding-Segment'
        ) # Embedding(input_dim=2,output_dim=self.embedding_size,embeddings_initializer=self.initializer)(s)
        # x和s相加，不是通过concat
        x = self.apply(inputs=[x, s], layer=Add, name='Embedding-Token-Segment') # Add([x, s])
        # x和s相加后，在和位置编码相加
        x = self.apply(
            inputs=x,
            layer=PositionEmbedding,
            input_dim=self.max_position,
            output_dim=self.embedding_size,
            merge_mode='add',
            embeddings_initializer=self.initializer,
            name='Embedding-Position'
        ) # PositionEmbedding(input_dim=self.max_position,output_dim=self.embedding_size,merge_mode='add',embeddings_initializer=self.initializer)(x)
        # 进行LN归一化
        x = self.apply(
            inputs=self.simplify([x, z]),
            layer=LayerNormalization,
            conditional=(z is not None),
            hidden_units=self.layer_norm_conds[1],
            hidden_activation=self.layer_norm_conds[2],
            hidden_initializer=self.initializer,
            name='Embedding-Norm'
        ) # LayerNormalization(conditional=(z is not None),hidden_units=self.layer_norm_conds[1],hidden_activation=self.layer_norm_conds[2],hidden_initializer=self.initializer)(self.simplify([x, z]))
        # dropout
        x = self.apply(
            inputs=x,
            layer=Dropout,
            rate=self.dropout_rate,
            name='Embedding-Dropout'
        )
        # 控制输出维度为(btz, seq_len, hidden_size)
        if self.embedding_size != self.hidden_size:
            x = self.apply(
                inputs=x,
                layer=Dense,
                units=self.hidden_size,
                kernel_initializer=self.initializer,
                name='Embedding-Mapping'
            )

        return x

    def apply_main_layers(self, inputs, index):
        """BERT的主体是基于Self-Attention的模块
        顺序：Att --> Add --> LN --> FFN --> Add --> LN
        """
        x = inputs  # shape=(btz, seq_len, 768)
        z = self.layer_norm_conds[0] # 条件概率

        attention_name = 'Transformer-%d-MultiHeadSelfAttention' % index # Encode中每一块transformer的名字不同，代表着参数不共享了，mapping到原本bert中的每一块中
        feed_forward_name = 'Transformer-%d-FeedForward' % index # Encode中每一块的FeedForward的名字不同。
        attention_mask = self.compute_attention_mask() # mask

        # Self Attention
        xi, x, arguments = x, [x, x, x], {'a_mask': None} # 注意这里的x是[x, x, x]，输入多头注意力中代表着QKV
        if attention_mask is not None:
            arguments['a_mask'] = True
            x.append(attention_mask)
        # 多头注意力
        x = self.apply(
            inputs=x,
            layer=MultiHeadAttention,
            arguments=arguments,
            heads=self.num_attention_heads,
            head_size=self.attention_head_size,
            key_size=self.attention_key_size,
            kernel_initializer=self.initializer,
            name=attention_name
        ) # 相当于MultiHeadAttention(heads=self.num_attention_heads,head_size=self.attention_head_size,key_size=self.attention_key_size,kernel_initializer=self.initializer,arguments=arguments)(x)
        # 下面每一层同理
        x = self.apply(
            inputs=x,
            layer=Dropout,
            rate=self.dropout_rate,
            name='%s-Dropout' % attention_name
        )
        # 残差连接:将多头注意力得到的张量和一开始输入进来的x相加
        x = self.apply(
            inputs=[xi, x], layer=Add, name='%s-Add' % attention_name
        )
        x = self.apply(
            inputs=self.simplify([x, z]),
            layer=LayerNormalization,
            conditional=(z is not None),
            hidden_units=self.layer_norm_conds[1],
            hidden_activation=self.layer_norm_conds[2],
            hidden_initializer=self.initializer,
            name='%s-Norm' % attention_name
        )

        # Feed Forward
        xi = x
        x = self.apply(
            inputs=x,
            layer=FeedForward,
            units=self.intermediate_size,
            activation=self.hidden_act,
            kernel_initializer=self.initializer,
            name=feed_forward_name
        )
        x = self.apply(
            inputs=x,
            layer=Dropout,
            rate=self.dropout_rate,
            name='%s-Dropout' % feed_forward_name
        )
        x = self.apply(
            inputs=[xi, x], layer=Add, name='%s-Add' % feed_forward_name
        )
        x = self.apply(
            inputs=self.simplify([x, z]),
            layer=LayerNormalization,
            conditional=(z is not None),
            hidden_units=self.layer_norm_conds[1],
            hidden_activation=self.layer_norm_conds[2],
            hidden_initializer=self.initializer,
            name='%s-Norm' % feed_forward_name
        )

        return x # 输出shape=(btz, seq_len, intermediate_size)

    def apply_final_layers(self, inputs):
        """根据剩余参数决定输出
        """
        x = inputs # shape=(btz, seq_len, intermediate_size)
        z = self.layer_norm_conds[0]
        outputs = [x] # outputs是一个list，在任务下游的时候可以用bert.model.output,也可以用bert.model.outputs，只是这是个list

        if self.with_pool or self.with_nsp:
            # Pooler部分（提取CLS向量）
            x = outputs[0]
            x = self.apply(
                inputs=x,
                layer=Lambda,
                function=lambda x: x[:, 0],
                name='Pooler'
            ) # shape=(btz, intermediate_size)需要用lambda层来做，否则Keras在训练识别不出来，会报错
            # 全连接并用激活
            pool_activation = 'tanh' if self.with_pool is True else self.with_pool
            x = self.apply(
                inputs=x,
                layer=Dense,
                units=self.hidden_size,
                activation=pool_activation,
                kernel_initializer=self.initializer,
                name='Pooler-Dense'
            ) # shape=(btz, hidden_size)
            if self.with_nsp:
                # Next Sentence Prediction部分
                # 如果是NSP需要输出shape=(btz, 2)
                x = self.apply(
                    inputs=x,
                    layer=Dense,
                    units=2,
                    activation='softmax',
                    kernel_initializer=self.initializer,
                    name='NSP-Proba'
                )
            outputs.append(x)

        if self.with_mlm:
            # Masked Language Model部分
            x = outputs[0]
            x = self.apply(
                inputs=x,
                layer=Dense,
                units=self.embedding_size,
                activation=self.hidden_act,
                kernel_initializer=self.initializer,
                name='MLM-Dense'
            )
            x = self.apply(
                inputs=self.simplify([x, z]),
                layer=LayerNormalization,
                conditional=(z is not None),
                hidden_units=self.layer_norm_conds[1],
                hidden_activation=self.layer_norm_conds[2],
                hidden_initializer=self.initializer,
                name='MLM-Norm'
            )
            mlm_activation = 'softmax' if self.with_mlm is True else self.with_mlm
            x = self.apply(
                inputs=x,
                layer=EmbeddingDense,
                embedding_name='Embedding-Token',
                activation=mlm_activation,
                name='MLM-Proba'
            )
            outputs.append(x)

        if len(outputs) == 1:
            outputs = outputs[0]
        elif len(outputs) == 2:
            outputs = outputs[1]
        else:
            outputs = outputs[1:]

        return outputs # 由pool，nsp，mlm的T/F决定，全没有的话，就直接输出shape=(btz, seq_len, intermediate_size)

更多源码详见：ZJJDJJ/bert4keras_note
祝各位看官品尝愉快~
我是卓师叔，谢谢各位！

卓师叔
关注
  • 1
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于bert4keras进行nlp工作，包含文本分类，实体识别，实体关系抽取.zip
01-18
基于bert4keras进行nlp工作，包含文本分类，实体识别，实体关系抽取
简洁优美的深度学习包-bert4keras
weixin_44597588的博客
04-01 5866
简洁优美的bert4keras
探索与实现：BERT4Keras中的T5模型
gitblog_00067的博客
06-05 380
探索与实现：BERT4Keras中的T5模型 项目地址:https://gitcode.com/bojone/t5_in_bert4keras 在这个快速发展的自然语言处理（NLP）领域里，谷歌推出的Transformer-XL预训练模型T5（Text-to-Text Transfer Transformer）因其出色的表现，引起了广泛的关注。现在，我们有机会在BERT4Keras框架下轻松地使用...
探秘BERT4Keras：轻松构建高效的深度学习模型
gitblog_00018的博客
03-21 461
探秘BERT4Keras：轻松构建高效的深度学习模型 bert4keraskeras implement of transformers for humans项目地址:https://gitcode.com/gh_mirrors/be/bert4keras 在自然语言处理（NLP）领域，预训练模型如BERT已经取得了显著的突破。然而，将这些先进的模型应用到实际项目中并不总是那么简单。幸运的是，B...
Bert4keras相关环境安装
try2find的专栏
12-06 676
特别要注意：keras-nightly 2.5.0.dev2021021100 的安装，其版本号有点特别。安装：cudatoolkit 10.1.243。安装：bert4keras 0.11.3。1. 创建虚拟环境，先安装cudatoolkit和cudnn。cudatoolkit版本不对容易报so库找不到的错。2. 安装对应的tensorflow版本与依赖。(2) tf转onnx错误。(1) so库找不到。
bert4keras使用笔记
hxl
04-05 3353
什么是bert4keras bert4keras是一个基于keras的预训练模型加载框架，目前支持多种预训练模型（BERT、ALBERT、RoBERTa、ALBERT、NEZHA、GPT2、T5等），并支持多种环境（python 2.7、python 3.x）和后端（keras、tf.keras、tf 1.x、tf 2.x）。 keras-bert依赖于keras-transformer，而keras-transformer依赖于keras-multi-head，keras-multi-head依赖于ker
项目实战-Bert文本分类（keras-bert实现）源代码及数据集.zip
04-09
1、内容概要：本资源主要基于bert（keras）实现文本分类，适用于初学者学习文本分类使用。 2、数据集为电商真实商品评论数据，主要包括训练集...4、源代码：bert_model.py是基于keras-bert构建Bert模型对文本进行分类。
人工智能-项目实践-文本分类-本项目采用Keras和Keras-bert实现文本多标签分类任务，对BERT进行微调。
05-25
人工智能-项目实践-文本分类-本项目采用Keras和Keras-bert实现文本多标签分类任务，对BERT进行微调。 本项目采用Keras和Keras-bert实现文本多标签分类任务。 数据集 2020语言与智能技术竞赛：事件抽取任务 本...
huggingface的bert-base-uncased
03-03
**描述解析：** "https://huggingface.co/google-bert/bert-base-uncased" 是该模型在Hugging Face Model Hub上的链接，这是一个存储和分享自然语言处理模型的平台。该描述表明，这个BERT模型支持PyTorch和...
bert-for-tf2：BERT，ALBERT和适配器-BERT的Keras TensorFlow 2.0实现
02-06
这个项目是针对机器学习领域的自然语言处理（NLP）任务，特别是利用BERT（Bidirectional Encoder Representations from Transformers）模型的一个实现，它基于TensorFlow 2.0框架和Keras库。BERT是一种预训练语言...
keras-bert-:使用Keras-bert实现二分类
05-11
在自然语言处理领域，预训练模型如BERT（Bidirectional Encoder Representations from Transformers）已经取得了显著的成果，它能够理解和生成高质量的文本。Keras-BERT是将BERT模型集成到Keras框架中的一个库，使得...
keras_bert与bert4keras的使用
Mark_Australia的博客
08-20 4798
keras_bert和bert4keras的使用
[Python人工智能] 四十三.命名实体识别 (4)利用bert4keras构建Bert+BiLSTM-CRF实体识别模型（异常解决中）
杨秀璋的专栏
03-19 515
从本专栏开始，作者正式研究Python深度学习、神经网络及人工智能相关知识。前文讲解如何实现中文命名实体识别研究，构建BiGRU-CRF模型实现。这篇文章将继续以中文语料为主，介绍融合Bert的实体识别研究，使用bert4keras和kears包来构建Bert+BiLSTM-CRF模型。然而，该代码最终结果有些问题，目前还在解决中，但现阶段方法先作为在线笔记分享出来。基础性文章，希望对您有帮助，如果存在错误或不足之处，还请海涵。且看且珍惜！
bert4keras、transformers 加载预训练bert模型、句向量cls，字向量提取；tokenizer使用
weixin_42357472的博客
12-08 8977
bert4keras 分词器 Tokenizer from bert4keras.models import build_transformer_model from bert4keras.tokenizers import Tokenizer import numpy as np config_path = '/Users/lonng/Desktop/v+/xl/chinese_L-12_H-768_A-12/bert_config.json' checkpoint_path = '/Users/lo
BERT4KERAS简单使用
studyvcmfc的专栏
10-11 1323
bert4keras的简单使用 - 知乎
[LLM] 自然语言处理--- 基于Keras Bert使用（上）
热门推荐
摩登都市天空---专栏
12-23 1万+
1. bert ---- keras keras_bert 是 CyberZHG 封装好了Keras版的Bert，可以直接调用官方发布的预训练权重。 github：https://github.com/CyberZHG/keras-bert 快速安装：pip install keras-bert bert4keras是封装好了Keras版的Bert，可以直接调用官方发布的预训...
bert4keras快速使用以及对抗训练
weixin_42517469的博客
08-18 5691
文章目录1. bert4keras快速上手2.对抗训练 1. bert4keras快速上手 下面是一个调用bert base模型来编码句子的简单例子： from bert4keras.models import build_transformer_model from bert4keras.tokenizers import Tokenizer import numpy as np config_path = '/root/kg/bert/chinese_L-12_H-768_A-12/bert_conf
Bert4Keras: Keras 实现的 Transformers 模型库
最新发布
gitblog_00521的博客
08-08 611
Bert4Keras: Keras 实现的 Transformers 模型库 bert4keraskeras implement of transformers for humans项目地址:https://gitcode.com/gh_mirrors/be/bert4keras 1. 项目介绍 Bert4Keras 是由 bojone 开发的一个易于使用的 Keras 库，它提供了对 Goog...
[LLM] 自然语言处理--- 基于Keras Bert使用（下）
摩登都市天空---专栏
12-27 4822
bert4keras 使用最新版本 本文所用bert4keras时间：2019-12-23 https://github.com/bojone/bert4keras 使用bert4keras(TF2.0) import os #使用tf2.0.0 版本 os.environ['TF_KERAS'] = '1' import numpy as np import json i...
BERT -IDCNN-CRF
09-12
具体来说，BERT是谷歌开发的一种预训练语言模型，可以用于各种自然语言处理任务。而IDCNN-CRF是一种深层双向卷积神经网络和条件随机场模型的结合，在命名实体识别中表现出色。通过结合这两种模型，BERT-IDCNN-CRF...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值