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進行任務特定的結構修改。