BERT参数量计算

最新推荐文章于 2023-07-21 13:12:10 发布
最新推荐文章于 2023-07-21 13:12:10 发布
阅读量1.7k 收藏 1
点赞数 1
分类专栏： NLP 文章标签： BERT NLP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aibigdata/article/details/122642344
版权
参数详情说明参数量
name = bert/embeddings/word_embeddings:0, shape = (30522, 768)单词表每个单词向量长度是768，一共30522个单词23440896
name = bert/embeddings/token_type_embeddings:0, shape = (2, 768)对于输入的任务是两个句子的，需要两个768维度的向量表示是第一个句子还是第二个句子1536
name = bert/embeddings/position_embeddings:0, shape = (512, 768)每个位置的embedding向量的表示，每一个位置向量是768维393216
name = bert/embeddings/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/embeddings/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_0/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_0/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_0/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_0/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_0/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_0/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_0/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768，全连接之后进行的残差连接589824
name = bert/encoder/layer_0/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_0/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_0/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_0/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_0/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_0/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_0/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_0/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_0/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_1/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_1/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_1/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_1/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_1/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_1/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_1/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_1/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_1/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_1/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_1/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_1/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_1/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_1/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_1/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_1/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_2/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_2/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_2/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_2/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_2/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_2/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_2/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_2/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_2/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_2/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_2/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_2/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_2/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_2/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_2/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_2/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_3/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_3/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_3/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_3/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_3/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_3/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_3/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_3/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_3/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_3/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_3/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_3/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_3/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_3/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_3/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_3/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_4/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_4/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_4/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_4/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_4/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_4/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_4/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_4/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_4/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_4/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_4/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_4/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_4/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_4/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_4/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_4/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_5/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_5/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_5/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_5/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_5/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_5/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_5/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_5/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_5/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_5/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_5/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_5/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_5/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_5/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_5/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_5/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_6/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_6/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_6/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_6/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_6/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_6/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_6/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_6/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_6/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_6/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_6/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_6/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_6/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_6/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_6/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_6/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_7/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_7/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_7/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_7/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_7/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_7/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_7/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_7/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_7/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_7/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_7/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_7/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_7/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_7/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_7/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_7/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_8/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_8/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_8/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_8/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_8/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_8/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_8/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_8/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_8/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_8/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_8/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_8/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_8/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_8/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_8/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_8/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_9/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_9/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_9/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_9/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_9/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_9/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_9/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_9/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_9/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_9/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_9/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_9/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_9/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_9/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_9/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_9/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_10/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_10/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_10/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_10/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_10/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_10/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_10/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_10/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_10/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_10/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_10/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_10/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_10/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_10/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_10/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_10/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_11/attention/self/query/kernel:0, shape = (768, 768)这个是输入矩阵形状对应的query,正常是(768,12*64)所以最后变成了(768, 768)589824
name = bert/encoder/layer_11/attention/self/query/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_11/attention/self/key/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的key，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_11/attention/self/key/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量768
name = bert/encoder/layer_11/attention/self/value/kernel:0, shape = (768, 768)这个是输出矩阵形状对应的value，因为是self-attention,所以输出与输入的形状是相同的，所以也是(768, 12*64)589824
name = bert/encoder/layer_11/attention/self/value/bias:0, shape = (768,)因为上面后者是12*64=768，所以最后是768维度的向量589824
name = bert/encoder/layer_11/attention/output/dense/kernel:0, shape = (768, 768)全连接第一层 768*768589824
name = bert/encoder/layer_11/attention/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_11/attention/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_11/attention/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_11/intermediate/dense/kernel:0, shape = (768, 3072)全连接第二层是768*30722359296
name = bert/encoder/layer_11/intermediate/dense/bias:0, shape = (3072,)全连接对应的bias3072
name = bert/encoder/layer_11/output/dense/kernel:0, shape = (3072, 768)全连接第三层，将神经元的个数降低到768，好进行下一层的multi-head attention2359296
name = bert/encoder/layer_11/output/dense/bias:0, shape = (768,)全连接对应的bias768
name = bert/encoder/layer_11/output/LayerNorm/beta:0, shape = (768,)LayerNorm beta参数，因为单词向量表示是768维，所以是768个768
name = bert/encoder/layer_11/output/LayerNorm/gamma:0, shape = (768,)LayerNorm gamma参数，因为单词向量表示是768维，所以是768个768
name = bert/pooler/dense/kernel:0, shape = (768, 768)因为该任务是判断两个句子是否是一个含义的任务，使用[CLS]向量，先进行一层全连接589824
name = bert/pooler/dense/bias:0, shape = (768,)全连接对应的bias768
name = output_weights:0, shape = (2, 768)因为是二分类任务，所以需要将向量的维度降低到21536
name = output_bias:0, shape = (2,)全连接对应的bias2
116552450
AiBigData
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于torch transformers 直接加载bert预训练模型计算句子相似度
02-05
基于torch transformers 直接加载bert预训练模型计算句子相似度
NLP Bert-base” 模型参数量计算
人工智能曾小健
08-21 328
Bert 的模型由多层双向的Transformer编码器组成，由12层组成768隐藏单元，12个head，总参数量110M，约1.15亿参数量。
Bert_base参数计算
bingmeishi的博客
08-27 1679
变量设定 设定如下变量： V – 词汇表大小 E – Embedding维度 P – 位置编码最大长度 H – Hidden维度 I – Intermediate维度 各模块参数 BertEmbeddings 模块 参数 word_embeddings V*E position_embeddings P*E token_type_embeddings 2*E LayerNorm E+E 所以，总的参数量为: V*E + P*E + 2*E + E + E = (V+P+
BERT参数计算，RBT3模型结构
weixin_64017116的博客
07-21 785
Bert沿用了惯用的全连接层大小设置，即4 * dmodle = 3072，其中用到了两个参数W1，W2，其中W1（768,3072），W2（3072,768），b1（768，1），b2（3072，1）。的模型由多层双向的Transformer编码器组成，由12层组成，768隐藏单元，12个head，总参数量110M，约1.15亿参数量。解释：m为输入的单词的数量，768位每个词的维度，64是因为分成了12个head（768/12）。：词汇量的大小为30522，每个词都是768维，共30522*768。
bert 模型参数统计
听雨轩的博客
05-01 3526
使用代码验证bert模型中的参数
如何计算Bert模型的参数量
机器学习，深度学习
08-18 7385
如何计算Bert模型的参数量
BERT参数计算
dataastron的博客
07-25 1248
参考 https://zhuanlan.zhihu.com/p/144582114小白 本文计算针对英文版本bert base bert base 12层 768隐藏单元 12个head 共110M vocab_size=30522， hidden_size=768， max_position_embeddings=512， token_type_embeddings=2 第 1 部分：输入 Token Embeddings：总词汇是30522每个输出维度都是768，参数量是30522*768 Posit
ernie和Bert的参数理解
weixin_42631192的博客
10-22 2542
BERT参数的理解 bert参数量隐藏在每一层的shape当中。把如上shape累加即为全部参数量。 总参数量=input_parm+12*encoder_parm=(30522+512+2)768+12(76812643+12643+6412768+768+768+768+7683072+3072+3072*768+768+768+768)=101675520个 参数简单解释如下：input_parm=(30522+512+2)*768就是输入embeding层对应的参数，分别对应的是**token-em
Python-使用BERT模型作为句子编码服务将可变长度句子映射到固定长度向量
08-11
使用BERT模型作为句子编码服务，将可变长度句子映射到固定长度向量。
pytorch实现具备预训练参数加载功能的bert模型
01-03
在pytorch上实现了bert模型，并且实现了预训练参数加载功能，可以加载huggingface上的预训练模型参数。 主要包含以下内容： 1) 实现BertEmbeddings、Transformer、BerPooler等Bert模型所需子模块代码。 2) 在子模块...
BertSimilarity：使用Google的BERT算法计算两个句子的相似度。利用Bert计算句子相似度。语义相似度计算
02-03
基于Google的BERT模型来进行语义相似度计算。代码基于tensorflow 1。 1.基本原理 简单来说就是将需要需要计算的相似性的两个句子先分解在一起，然后通过伯特模型获取获取整体的编码信息，然后通过全连接层将维，输出...
BERT模型实战1
08-03
BERT模型实战1
BERT文本分类数据
01-11
BERT文本分类代码对应的数据
锂电池涂布模头，全球前7强生产商排名及市场份额.docx
05-06
锂电池涂布模头，全球前7强生产商排名及市场份额
ISO IEC 21964-2-2018.pdf
05-06
ISO IEC 21964-2-2018.pdf
编译程序构造的一般原理和基本方法.pdf
05-06
编译原理是计算机专业的一门核心课程，旨在介绍编译程序构造的一般原理和基本方法。编译原理不仅是计算机科学理论的重要组成部分，也是实现高效、可靠的计算机程序设计的关键。本文将对编译原理的基本概念、发展历程、主要内容和实际应用进行详细介绍编译原理是计算机专业的一门核心课程，旨在介绍编译程序构造的一般原理和基本方法。编译原理不仅是计算机科学理论的重要组成部分，也是实现高效、可靠的计算机程序设计的关键。本文将对编译原理的基本概念、发展历程、主要内容和实际应用进行详细介绍编译原理是计算机专业的一门核心课程，旨在介绍编译程序构造的一般原理和基本方法。编译原理不仅是计算机科学理论的重要组成部分，也是实现高效、可靠的计算机程序设计的关键。本文将对编译原理的基本概念、发展历程、主要内容和实际应用进行详细介绍编译原理是计算机专业的一门核心课程，旨在介绍编译程序构造的一般原理和基本方法。编译原理不仅是计算机科学理论的重要组成部分，也是实现高效、可靠的计算机程序设计的关键。本文将对编译原理的基本概念、发展历程、主要内容和实际应用进行详细介绍编译原理是计算机专业的一门核心课程，旨在介绍编译程序构造的一般原理和基本
海关商品编码/HS编码表
最新发布
05-06
用于海关申报商品编码/HS编码信息
如何解决Bert参数量大，收敛慢的问题
06-09
BERT 模型的参数量非常大，这是因为它采用了多层的 Transformer 结构，同时使用了较大的词表和隐藏层维度。这使得 BERT 的训练非常耗时，并且需要大量的计算资源。为了解决这个问题，可以采用以下方法： 1. 优化模型结构：可以根据实际需求选择合适的模型结构，例如使用 DistilBERT、ALBERT 等轻量级的 BERT 变体，或者使用其他的预训练模型如 GPT 等。 2. 改变训练策略：可以采用分布式训练、混合精度训练等技术来加速训练过程，同时也可以采用更小的 batch size 来加速收敛。 3. 增加训练数据：可以通过增加训练数据量来提高模型的泛化性能，同时也可以提高模型的收敛速度。 4. Fine-tuning：可以在预训练的基础上进行 Fine-tuning，这样可以大大减少训练时间，并且可以将模型的泛化性能提高到一个更高的水平。 总之，解决 BERT 模型参数量大、收敛慢的问题需要结合实际情况，采用多种方法综合优化，以达到更好的效果。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值