bert源码model

❶ GPT的auto-regressive语言模型架构在信息表示方面有什么架构上的缺陷具体如何改进

1） GPT

在Bert 之后，OpenAI 的 GPT-2 就是其中之一。它在文本生成上有着惊艳的表现，其生成的文本在上下文连贯性和情感表达上都超过了人们对目前阶段语言模型的预期。仅从模型架构而言，GPT-2 并没有特别新颖的架构，它和 transformer 的 Decoder 类似。相比较于GPT-1，GPT -2 使用了更大的预料，更大和更深的模型。

从transformer的decoder里移除了decoder对encoder的attention部分。也就是消除掉了seq2seq的过程。

GPT是一个语言模型，每一个时刻只能看见当前时刻前面时刻的信息，是一个auto regressive的过程。

GPT2，hidden state的大小有变化，根据层数的多少有small，mem，large，extra large的划分。

GPT的训练过程是交叉式的预测下一个单词，测试的时候是输入一个句子生成另外一个句子。

GPT的预训练就是训练一个语言模型。而bert的预训练是masked language model和nsp的任务。

GPT由多个decocer block组成，每一个decoder block由masked self-attention和feed forward neural network组成。

一个timestamp的hidden state经过线性层转换为vocab size大小的embedding， 然后经过softmax，算出每个词汇的概率，找出其中概率最大的词作为预测输出，然后下一个时刻的词作为真实输出，计算两者的cross entropy来训练模型。

每一个timestamp后面的位置都mask掉，设置一个负无群大的值，做softmax的时候，该位置的值就为0。

2）总结

• transformer decoder的构造

• 预训练的时候做语言模型的训练

• GPT2用更多更深的block

• BERT是做NLU，generation做不了

• GPT天生就是语言模型，非常适合做generation的任务，在bert里能做的在gpt里也可以做

除了GPT-2 ，GPT-3依旧延续自己的单向语言模型训练方式，只不过把模型尺寸增大到了1750亿，并且使用45TB数据进行训练

❷ knockoutjs基于什么开发

Knockoutjs可以帮助我们实现复杂的客户端交互，但是在很多的时候我们需要和我们的服务器进行数据交互或者至少将数据序列化到我们的本地存储器。此时我们就可以使用JSON格式数据进行数据的交互和保存了。
一、加载和保存数据。
Knockoutjs并不强制要求我们使用某个具体的技术来进行数据的读取和保存，我们可以根据自己的需要使用不同的技术，我们经常使用的是JQuery的Ajax方式，比如：getJSON、post和ajax等，我们可以使用下面的方法从服务器取得数据：
1 $.getJSON("/some/url", function(data) {
2 // Now use this data to update your view models, 3 // and Knockout will update your UI automatically 4 })

你也可以使用下面的方法向你的服务器发送数据：
1 var data = /* Your data in JSON format - see below */;
2 $.post("/some/url", data, function(returnedData) {
3 // This callback is executed if the post was successful 4 })

如果你不想使用JQuery的话，你也可以使用其他的技术来取得和发送数据，无论如何，Knockoutjs可以帮助你做如下的两件事情：
（1）、保存数据：Knockoutjs可以将View Model中的数据保存到JSON中，这样你就可以使用相应的技术将数据传到服务器进行保存。
（2）、加载数据：Knockoutjs将你取得到的数据传送到对应的View Model，从而改变View Model层的数据，这样你的页面展示的数据也会随之改变了。
二、将View Model层数据转换成JSON数据。
我们的View Model是一个个的javaScript对象，所以在某种意义上，我们可以使用JSON的序列化函数将此转换为JSON数据，比如：JSON.serialize()（现在有很多浏览器内嵌了此函数）和json2.js。但是，我们的View Model中可能包含observables、computed observables和observable arrays等，这些内容都是作为JavaScript方法进行编译的，此时使用以上的方式并不能完全按照我们的意思把View Model转换为JSON数据。
为了更加方便的将View Model的数据转换为JSON数据，Knockoutjs为我们提供了一些帮助：
（1）、ko.toJS：克隆View Model对象的结构，以当前observable的值代替observable，因此我们仅仅得到了一个View Model的备份，这个备份和Knockoutjs绑定并无关联。
（2）、ko.toJSON：此方法将View Model的数据转换为JSON格式数据，其实现原理就是先通过ko.toJS得到一份View Model的备份，然后通过浏览器本地的JSON序列化函数得到JSON数据。（注：有的浏览器可能没有内置JSON的序列化函数，此时我们可以导入json2.js来进行使用）。
例：定义以下的View Model。
1 <script type="text/javascript"> 2 var viewModel = { 3 firstName: ko.observable("Bert"), 4 lastName: ko.observable("Smith"), 5 pets: ko.observableArray(["Cat", "Dog", "Fish"]), 6 type: "Customer" 7 }; 8 viewModel.hasALotOfPets = ko.computed(function () { 9 return this.pets().length > 210 }, viewModel);11 ko.applyBindings(viewModel);12 </script>
此View Model中包含了observables、computed observables、observable arrays和plain values，此时我们可以使用ko.toJSON将其转换为JSON数据：
1 var jsonData = ko.toJSON(viewModel);2 3 // Result: jsonData is now a string equal to the following value 4 // '{"firstName":"Bert","lastName":"Smith","pets":["Cat","Dog","Fish"],"type":"Customer","hasALotOfPets":true}'

或者你仅仅想得到他的备份你可以使用：
1 var plainJs = ko.toJS(viewModel);
2 3 // Result: plainJS is now a plain JavaScript object in which nothing is observable. It's just data. 4 // The object is equivalent to the following: 5 // { 6 // firstName: "Bert", 7 // lastName: "Smith", 8 // pets: ["Cat","Dog","Fish"], 9 // type: "Customer", 10 // hasALotOfPets: true 11 // }
我们的ko.toJSON也可以接受和JSON.stringify同样的参数，此时我们就可以像如下去使用ko.toJSON了：
1 <pre data-bind="text: ko.toJSON($root, null, 2)"></pre>

三、使用JSON数据来更新View Model的数据。
如果我们已经从服务段接受到了数据，并且想要用它来更新我们View Model层的数据，此时最直接的方法就是要我们自己去实现了：
1 // Load and parse the JSON 2 var someJSON = /* Omitted: fetch it from the server however you want */;
3 var parsed = JSON.parse(someJSON);
4 5 // Update view model properties 6 viewModel.firstName(parsed.firstName);
7 viewModel.pets(parsed.pets);
在很多的情况下，我们还是要丰衣足食的，当我们更新完View Model的数据之后，Knockoutjs会自动的帮助我们更新UI层的展示。
然而，在很多情况下，很多的开发者可能会使用更为方便的方法来更新View Model层的数据，此时可能只需要编写一行代码对应View Model中的数据就全部更新了，这样就非常的方便，比如我们的View Model有很多的属性，或者嵌套了很多层，我们就可以使用此方式，可以大大减少我们的代码量，具体的方法我们在mapping plugin会具体的介绍。

❸ bert和lda区别

IDAPro是反汇编工具，bert是双向Transformer的Encoder。
BERT的实现主要是围绕工程化的项目来进行的。bert模型的主要创新点都在pre-train方法上，即用了MaskedLM和NextSentencePrediction两种方法分别捕捉词语和句子级别的representation。
作为反汇编程序的IDAPro能够创建其执行映射，以符号表示（汇编语言）显示处理器实际执行的二进制指令。IDAPro可以从机器可执行代码生成汇编语言源代码，并使这些复杂的代码更具人类可读性（这个可读具有相对性）。

❹ bert模型插入特殊符号后，如何获取它的值

使用输入连接器（文件/SFTP）在读取输入文件时转换数据。
配置文件内容并在入站连接器配置中添加转义字符配置。具有特殊字符的数据，例如特定语言（拉丁语）或HTML标记。
BERT是一个预训练的语言表征模型。它强调了不再像以往一样采用传统的单向语言模型或者把两个单向语言模型进行浅层拼接的方法进行预训练，而是采用新的maskedlanguagemodel（MLM），以致能生成深度的双向语言表征。

❺ bert不同句子中的词向量会变化吗

我们都体会到了BERT预训练模型的强大，主要一点就是它可以动态生成句向量，根据不同的上下文而得到不同的句向量，当然也可以得到词向量，但是如果我想比较不同语境下的词向量该怎么做呢？比如这两句话“在手机品牌中，我喜欢苹果”和“在水果中，我喜欢苹果”中“苹果”一词的相似度，显然，此“苹果”非彼“苹果”，如果我直接将这两句话输入给bert-as-service，它输出的是这两句话的句向量，如果我们想验证“苹果”这个词向量的话，我们可以这么做。

下面的代码只需要把预训练模型地址更改就可以运行：

import torch
from pytorch_pretrained_bert import BertTokenizer,BertModel

text0 = '水果中很多对人有好处，比如苹果' #句子0
text1 = '外国手机有很多都不错，比如苹果' #句子1
text2 = '我喜欢在饭吃不同水果，比如苹果' #句子2

marked_text0 = '[CLS]' + text0 + '[SEP]' #因为BERT的输入是按照[CLS]和[SEP]来区分句子的，所以加上
marked_text1 = '[CLS]' + text1 + '[SEP]'
marked_text2 = '[CLS]' + text2 + '[SEP]'
tokenizer = BertTokenizer('/home/zhu/BERT-BiLSTM-CRF-NER-master/chinese_L-12_H-768_A-12/vocab.txt') #加载你的预训练词表地址
tokenized_text0 = tokenizer.tokenize(marked_text0) #将输入按照BERT的处理方式进行分割
tokenized_text1 = tokenizer.tokenize(marked_text1)
tokenized_text2 = tokenizer.tokenize(marked_text2)
# print(tokenized_text0)
indexed_tokens = tokenizer.convert_tokens_to_ids(tokenized_text0) #将字符映射到id
indexed_tokens1 = tokenizer.convert_tokens_to_ids(tokenized_text1)
indexed_tokens2 = tokenizer.convert_tokens_to_ids(tokenized_text2)
# for tup in zip(tokenized_text0,indexed_tokens):
# print(tup)
segments_ids = [1] * len(tokenized_text0) #segment_id是用来区分句子的，这里我们的输入是一句话一句话的输入，所以都标成1即可。
segments_ids1 = [1] * len(tokenized_text1)
segments_ids2 = [1] * len(indexed_tokens2)
tokens_tensor = torch.tensor([indexed_tokens]) #将输入转换成张量的形式
segments_tensors = torch.tensor([segments_ids])
tokens_tensor1 = torch.tensor([indexed_tokens1])
segments_tensors1 = torch.tensor([segments_ids1])
segments_tensors2 = torch.tensor([segments_ids2])
tokens_tensor2 = torch.tensor([indexed_tokens2])
model = BertModel.from_pretrained('/home/zhu/BERT-BiLSTM-CRF-NER-master/chinese_L-12_H-768_A-12') #加载预训练模型地址
model.eval() #这里是验证模型，可以节省很多不必要的反向传播
with torch.no_grad(): #将输入传入模型，得到每一层的输出信息，这里的encoded_layers为12层，可以打印验证
encoded_layers,_ = model(tokens_tensor,segments_tensors)
with torch.no_grad():
encoded_layers1,_ = model(tokens_tensor1,segments_tensors1)
with torch.no_grad():
encoded_layers2,_ = model(tokens_tensor2,segments_tensors2)
# print(len(encoded_layers))
batch_i = 0 #因为我们就输入一句话，所以batch的批大小为1，从0开始索引
token_embeddings = []
for token_i in range(len(tokenized_text0)): #这里是将一句话中每个字符的每一层信息添加到token_embedding集合中
hidden_layers = []
for layer_i in range(len(encoded_layers)):
vec = encoded_layers[layer_i][batch_i][token_i]
hidden_layers.append(vec)
token_embeddings.append(hidden_layers)
token_embeddings1 = []
for token_i in range(len(tokenized_text1)):
hidden_layers1 = []
for layer_i in range(len(encoded_layers1)):
vec = encoded_layers1[layer_i][batch_i][token_i]
hidden_layers1.append(vec)
token_embeddings1.append(hidden_layers1)

token_embeddings2 = []
for token_i in range(len(tokenized_text2)):
hidden_layers2 = []
for layer_i in range(len(encoded_layers2)):
vec = encoded_layers2[layer_i][batch_i][token_i]
hidden_layers2.append(vec)
token_embeddings2.append(hidden_layers2)

# 有了一句话的每一层输出信息后，我们可以制定如何去拼接这些信息，这里我们选择将最后四层输出层的信息想加
#concatenated_last_4_layers = [torch.cat((layer[-1],layer[-2],layer[-3],layer[-4]),0) for layer in token_embeddings]
summed_last_4_layers = [torch.sum(torch.stack(layer)[-4:],0) for layer in token_embeddings]
#concatenated_last_4_layers1 = [torch.cat((layer[-1],layer[-2],layer[-3],layer[-4]),0) for layer in token_embeddings1]
summed_last_4_layers1 = [torch.sum(torch.stack(layer)[-4:],0) for layer in token_embeddings1]

#concatenated_last_4_layers2 = [torch.cat((layer[-1],layer[-2],layer[-3],layer[-4]),0) for layer in token_embeddings2]
summed_last_4_layers2 = [torch.sum(torch.stack(layer)[-4:],0) for layer in token_embeddings2]
# print(sentence_embedding[0].shape[0])
# for i,x in enumerate(tokenized_text0):
# print(i,x)
# for i,x in enumerate(tokenized_text1):
# print(i,x)
# for i,x in enumerate(tokenized_text2):
# print(i,x)
token_0 = (summed_last_4_layers[14] + summed_last_4_layers[15]) / 2 #找到苹果两个字符的索引，并相加取平均值得到我们最终“苹果”的词向量
token_1 = (summed_last_4_layers1[14] + summed_last_4_layers1[15]) / 2
token_2 = (summed_last_4_layers2[14] + summed_last_4_layers2[15]) / 2
from sklearn.metrics.pairwise import cosine_similarity
print(cosine_similarity(token_0.reshape(1,-1),token_1.reshape(1,-1))[0][0],'0和1')
print(cosine_similarity(token_0.reshape(1,-1),token_2.reshape(1,-1))[0][0],'0和2')
print(cosine_similarity(token_1.reshape(1,-1),token_2.reshape(1,-1))[0][0],'1和2')

运行结果如上图所示，很明显三句话中苹果的相似度比较相对来说符合常理，虽然苹果手机和水果苹果也有着75%的相似度，个人认为句式的影响也很重要。

❻ 学bert是什么专业的

BERT是一个预训练的语言表征模型。
BERT的全称为，是一个预训练的语言表征模型。它强调了不再像以往一样采用传统的单向语言模型或者把两个单向语言模型进行浅层拼接的方法进行预训练，而是采用新的maskedlanguagemodel（MLM），以致能生成深度的双向语言表征。BERT论文发表时提及在11个NLP（NaturalLanguageProcessing，自然语言处理）任务中获得了新的state-of-the-art的结果，令人目瞪口呆。

该模型有以下主要优点：

1）采用MLM对双向的Transformers进行预训练，以生成深层的双向语言表征。

2）预训练后，只需要添加一个额外的输出层进行fine-tune，就可以在各种各样的下游任务中取得state-of-the-art的表现。在这过程中并不需要对BERT进行任务特定的结构修改。