我是跟著b站乙個up主的部落格學的**，然後自己新增了一些注釋
import torch
import torch.nn as nn
import torch.optim
import torch.utils.data as data
dtype = torch.floattensor
sentences = ['i like cat', 'i love coffee', 'i hate milk']
#將上面的單詞逐個分開
word_list = " ".join(sentences).split()
#將分詞後的結果去重
word_list = list(set(word_list))
#對單詞建立索引，for迴圈裡面是先取索引，再取單詞
word_dict =
#反向建立索引
number_dict =
#計算詞典長度
n_class = len(word_dict)
#nnlm的計算步長
n_step = len(sentences[0].split())-1
#隱藏層的參數量
n_hidden = 2
#嵌入詞向量的維度
m = 2
#構建輸入輸出資料
def make_batch(sentences):
input_batch =
target_batch =
for sen in sentences:
word = sen.split()#將句子中每個詞分詞
#:-1表示取每個句子裡面的前兩個單詞作為輸入
#然後通過word_dict取出這兩個單詞的下標，作為整個網路的輸入
input = [word_dict[n] for n in word[:-1]] # [0, 1], [0, 3], [0, 5]
#target取的是**單詞的下標，這裡就是cat,coffee和milk
target = word_dict[word[-1]] # 2, 4, 6
#輸入資料集
#輸出資料集
return input_batch, target_batch
input_batch, target_batch = make_batch(sentences)
#將資料裝載到torch上
input_batch = torch.longtensor(input_batch)
target_batch = torch.longtensor(target_batch)
dataset = data.tensordataset(input_batch, target_batch)
loader = data.dataloader(dataset=dataset, batch_size=16, shuffle=true)
#定義網路結構，繼承nn.module
class nnlm(nn.module):
def __init__(self):
super(nnlm, self).__init__()
#計算詞向量表，大小是len(word_dict) * m
self.c = nn.embedding(n_class, m)
#下面就是初始化網路引數，公式如下
"""hiddenout = tanh(d + x*h)
y = b + x*h + hiddenout*u
"""self.h = nn.parameter(torch.randn(n_step * m, n_hidden).type(dtype))
self.w = nn.parameter(torch.randn(n_step * m, n_class).type(dtype))
self.d = nn.parameter(torch.randn(n_hidden).type(dtype))
self.u = nn.parameter(torch.randn(n_hidden, n_class).type(dtype))
self.b = nn.parameter(torch.randn(n_class).type(dtype))
def forward(self, x):
'''x: [batch_size, n_step]
'''#根據詞向量表，將我們的輸入資料轉換成三維資料
#將每個單詞替換成相應的詞向量
x = self.c(x) # [batch_size, n_step] => [batch_size, n_step, m]
#將替換後的詞向量表的相同行進行拼接
#view的第乙個引數為-1表示自動判斷需要合併成幾行
x = x.view(-1, n_step * m) # [batch_size, n_step * m]
hidden_out = torch.tanh(self.d + torch.mm(x, self.h)) # [batch_size, n_hidden]
output = self.b + torch.mm(x, self.w) + torch.mm(hidden_out, self.u) # [batch_size, n_class]
return output
model = nnlm()
#分類問題用交叉熵作為損失函式
criterion = nn.crossentropyloss()
#優化器使用adam
#所謂的優化器，實際上就是你用什麼方法去更新網路中的引數
optimizer = torch.optim.adam(model.parameters(), lr=1e-3)
# 開始訓練
for epoch in range(5000):
for batch_x, batch_y in loader:
optimizer.zero_grad()
output = model(batch_x)
# output : [batch_size, n_class], batch_y : [batch_size] (longtensor, not one-hot)
loss = criterion(output, batch_y)
#每1000次列印一次結果
if (epoch + 1)%1000 == 0:
print('epoch:', '%04d' % (epoch + 1), 'cost =', ''.format(loss))
#反向傳播更新梯度
loss.backward()
optimizer.step()
# predict
# max()取的是最內層維度中最大的那個數的值和索引，[1]表示取索引
predict = model(input_batch).data.max(1, keepdim=true)[1]
# test
# squeeze()表示將陣列中維度為1的維度去掉
print([sen.split()[:n_step] for sen in sentences], '->', [number_dict[n.item()] for n in predict.squeeze()])
epoch: 1000 cost = 0.371559
epoch: 2000 cost = 0.069313
epoch: 3000 cost = 0.012472
epoch: 4000 cost = 0.004256
epoch: 5000 cost = 0.001829
[['i', 'like'], ['i', 'love'], ['i', 'hate']] -> ['cat', 'coffee', 'milk']
linux 裝置模型簡析
file operations 不可能被拋棄。它是字元裝置的基礎結構，各種裝置模型或者說匯流排，只是對字元裝置進行了包裝。驅動一定是核心模組 核心模組不一定是驅動 裝置模型的初衷 是省電 建立一條 掛有 所有裝置的樹 全域性裝置樹 與使用者空間的通訊 裝置間的通訊 都是通過 sysfs檔案系統實現的...
python評分卡模型 簡書 評分卡模型
信用評分卡分類 a卡 申請評分卡，側重貸前，在客戶獲取期，建立信用風險評分，客戶帶來違約風險的概率大小 b卡 行為評分卡，側重貸中，在客戶申請處理期，建立申請風險評分模型，客戶開戶後一定時期內違約拖欠的風險概率，有效排除了信用不良客戶和非目標客戶的申請 c卡 催收評分卡，側重貸後，在帳戶管理期，建立...
《大道至簡》閱讀筆記 EHM模型
2007 07 01 愚公移山只是一種精神追求，而做工程最求的則是完成工程。在忙忙碌碌的日常開發中，不要忘了自己的位置，時刻提醒自己，你在做什麼？ehm模型分析了軟體工程中各個環節的由來，價值及其內在關係。可以很清楚的知道自己在工程的位置。實現 程式 演算法 資料結構 方法 面向過程 oop mda...