简单有趣的NLP教程:手把手教你用 PyTorch 辨别自然语言(附代码)

大数据
本文手把手教你用 PyTorch 辨别自然语言(附代码)。

手把手教你用 PyTorch 辨别自然语言(附代码)

最近在学pyTorch的实际应用例子。这次说个简单的例子:给定一句话,判断是什么语言。这个例子是比如给定一句话:

  1. Give it to me 
  2.  
  3. 判断是 ENGLISH 
  4.  
  5. me gusta comer en la cafeteria 
  6.  
  7. 判断是 SPANISH  

就是这么简单的例子。

来看怎么实现:

准备数据 格式 [(语句,类型),…]

data是train的时候用的语句,test_data是test的时候用的语句

  1. data = [ ("me gusta comer en la cafeteria".split(), "SPANISH"), 
  2.  
  3.          ("Give it to me".split(), "ENGLISH"), 
  4.  
  5.          ("No creo que sea una buena idea".split(), "SPANISH"), 
  6.  
  7.          ("No it is not a good idea to get lost at sea".split(), "ENGLISH") ] 
  8.  
  9. test_data = [("Yo creo que si".split(), "SPANISH"), 
  10.  
  11.               ("it is lost on me".split(), "ENGLISH")]  

因为文本计算机室识别不出来的,他们只认识01串,也就是数字。所以我们得把文本映射到数字上。

  1. word_to_ix = {} 
  2.  
  3. for sent, _ in data + test_data: 
  4.  
  5.     for word in sent: 
  6.  
  7.         if word not in word_to_ix: 
  8.  
  9.             word_to_ix[word] = len(word_to_ix) 
  10.  
  11. print(word_to_ix)  

输出word_to_ix (意思是word to index)是:

  1. {'me': 0, 'gusta': 1, 'comer': 2, 'en': 3, 'la': 4, 'cafeteria': 5, 'Give': 6, 'it': 7, 'to': 8, 'No': 9, 
  2.  'creo': 10, 'que': 11, 'sea': 12, 'una': 13, 'buena': 14, 'idea': 15, 'is': 16, 'not': 17, 'a': 18, 'good': 19, 
  3.  'get': 20, 'lost': 21, 'at': 22, 'Yo': 23, 'si': 24, 'on': 25}  

这里先提前设置下接下来要用到的参数

  1. VOCAB_SIZE = len(word_to_ix) 
  2.  
  3. NUM_LABELS = 2#只有两类 ENGLISH SPANISH  

固定模板

def init(self, num_labels, vocab_size):初始化,就是输入和输出的大小。这里我们要输入是一个句子,句子***就是拥有所有字典的词,这里也就是vocab_size(下面再说怎么将一句话根据字典转换成一个数字序列的),输出就是分类,这里分为2类,即num_labels。这里我们用的是线性分类 ,即nn.Linear()。

def forward(self, bow_vec):bow_vec是一个句子的数字化序列,经过self.linear()得到一个线性结果(也就是预测结果),之后对这个结果进行softmax(这里用log_softmax是因为下面的损失函数用的是NLLLoss() 即负对数似然损失,需要log以下)

  1. class BoWClassifier(nn.Module):#nn.Module 这是继承torch的神经网络模板 
  2.  
  3.     def __init__(self, num_labels, vocab_size):  
  4.  
  5.         super(BoWClassifier, self).__init__() 
  6.  
  7.         self.linear = nn.Linear(vocab_size, num_labels) 
  8.  
  9.     def forward(self, bow_vec): 
  10.  
  11.         return F.log_softmax(self.linear(bow_vec)) 
  12.  
  13. def make_bow_vector(sentence, word_to_ix)  

大概能看懂什么意思吧。就是把一个句子sentence通过word_to_ix转换成数字化序列.比如 sentence=我 是 一只 小 小 鸟 word_to_id={你:0,我:1,他:2,不:3,是:4,大:5,小:6,猪:7,鸟:8,,} make_bow_vector之后的结果是[0,1,0,0,1,0,2,0,1]。view()就是改变下向量维数。

这里是讲len(word_to_ix)1->1len(word_to_ix)

  1. def make_bow_vector(sentence, word_to_ix): 
  2.  
  3.     vec = torch.zeros(len(word_to_ix)) 
  4.  
  5.     for word in sentence: 
  6.  
  7.         vec[word_to_ix[word]] += 1 
  8.  
  9.     return vec.view(1, -1)  

这个就不用说了吧 一样。(如果想知道torch.LongTensor啥意思的话。可以看看。Torch中,Tensor主要有ByteTensor(无符号char),CharTensor(有符号),ShortTensor(shorts), IntTensor(ints), LongTensor(longs), FloatTensor(floats), DoubleTensor(doubles),默认存放为double类型,如果需要特别指出,通过torch.setdefaulttensortype()方法进行设定。例如torch.setdefaulttensortype(‘torch.FloatTensor’)。 )

  1. def make_target(label, label_to_ix): 
  2.  
  3.     return torch.LongTensor([label_to_ix[label]])  

这里再介绍下model.parameters()这个函数。他的返回结果是model里的所有参数。这里我们用的是线性函数,所以就是f(x)=Ax+b中的A和b(x即输入的数据),这些参数在之后的反馈和更新参数需要的。

  1. model = BoWClassifier(NUM_LABELS, VOCAB_SIZE) 
  2.  
  3. for param in model.parameters(): 
  4.  
  5.     print("param:", param)  

可以看出A是2len(vocab_size),b是21

  1. param: Parameter containing: 
  2.  
  3. Columns 0 to 9  
  4.  
  5.  0.0786  0.1596  0.1259  0.0054  0.0558 -0.0911 -0.1804 -0.1526 -0.0287 -0.1086 
  6.  
  7. -0.0651 -0.1096 -0.1807 -0.1907 -0.0727 -0.0179  0.1530 -0.0910  0.1943 -0.1148 
  8.  
  9. Columns 10 to 19  
  10.  
  11.  0.0452 -0.0786  0.1776  0.0425  0.1194 -0.1330 -0.1877 -0.0412 -0.0269 -0.1572 
  12.  
  13. -0.0361  0.1909  0.1558  0.1309  0.1461 -0.0822  0.1078 -0.1354 -0.1877  0.0184 
  14.  
  15. Columns 20 to 25  
  16.  
  17.  0.1818 -0.1401  0.1118  0.1002  0.1438  0.0790 
  18.  
  19.  0.1812 -0.1414 -0.1876  0.1569  0.0804 -0.1897 
  20.  
  21. [torch.FloatTensor of size 2x26] 
  22.  
  23. param: Parameter containing: 
  24.  
  25.  0.1859 
  26.  
  27.  0.1245 
  28.  
  29. [torch.FloatTensor of size 2]  

我们再看看model的def forward(self, bow_vec):怎么用。这里就想下面的代码一样,直接在mode()填一个参数即可,就调用forward函数。

  1. sample = data[0] 
  2.  
  3. bow_vector = make_bow_vector(sample[0], word_to_ix) 
  4.  
  5. log_probs = model(autograd.Variable(bow_vector)) 
  6.  
  7. print("log_probs", log_probs) 

输出是:(就是log_softmax后的值)

  1. log_probs Variable containing: 
  2.  
  3. -0.6160 -0.7768 
  4.  
  5. [torch.FloatTensor of size 1x2]  

我们这里看看在test上的预测

  1. label_to_ix = { "SPANISH": 0, "ENGLISH": 1 } 
  2.  
  3. for instance, label in test_data: 
  4.  
  5.     bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix)) 
  6.  
  7.     log_probs = model(bow_vec) 
  8.  
  9.     print log_probs 
  10.  
  11. print next(model.parameters())[:,word_to_ix["creo"]]  

结果是

  1. Variable containing: 
  2.  
  3. -0.5431 -0.8698 
  4.  
  5. [torch.FloatTensor of size 1x2] 
  6.  
  7. Variable containing: 
  8.  
  9. -0.7405 -0.6480 
  10.  
  11. [torch.FloatTensor of size 1x2] 
  12.  
  13. Variable containing: 
  14.  
  15. -0.0467 
  16.  
  17.  0.1065 
  18.  
  19. [torch.FloatTensor of size 2]  

下面就该进行重要的部分了。

循环训练和更新参数

这里我们用的损失函数是nn.NLLLoss()负对数似然损失,优化依然用的最常见的optim.SGD() 梯度下降法,一般训练5-30次最终优化基本不再变化。

每一步过程:

a. 首先都要model.zero_grad(),因为接下来要极端梯度,得清零,以防问题

b. 将数据向量化(也可以说是数字序列化,转成计算机能看懂的形式)

c. 得到预测值

d. 求损失loss_function

e. 求梯度loss.backward()

f. 更新参数optimizer.step()

  1. loss_function = nn.NLLLoss() 
  2.  
  3. optimizer = optim.SGD(model.parameters(), lr=0.1) 
  4.  
  5. for epoch in range(100): 
  6.  
  7.     for instance, label in data: 
  8.  
  9.         model.zero_grad() 
  10.  
  11.         bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix)) 
  12.  
  13.         target = autograd.Variable(make_target(label, label_to_ix)) 
  14.  
  15.         log_probs = model(bow_vec) 
  16.  
  17.         loss = loss_function(log_probs, target) 
  18.  
  19.         loss.backward() 
  20.  
  21.         optimizer.step()  

在测试集上测试

  1. for instance, label in test_data: 
  2.  
  3.     bow_vec = autograd.Variable(make_bow_vector(instance, word_to_ix)) 
  4.  
  5.     log_probs = model(bow_vec) 
  6.  
  7.     print log_probs  

我们在结果上很容易看到***个例子预测是SPANISH***,第二个是ENGLISH***。成功了。

  1. Variable containing:  
  2. -0.0842 -2.5161 
  3.  
  4. [torch.FloatTensor of size 1x2] 
  5.  
  6. Variable containing: 
  7.  
  8. -2.4886 -0.0867 
  9.  
  10. [torch.FloatTensor of size 1x2]  
责任编辑:庞桂玉 来源: 36大数据
相关推荐

2018-12-10 10:00:06

Python神经网络编程语言

2022-10-19 14:30:59

2018-06-23 07:38:10

2017-10-29 21:43:25

人脸识别

2022-08-04 10:39:23

Jenkins集成CD

2018-12-29 09:38:16

Python人脸检测

2009-04-22 09:17:19

LINQSQL基础

2021-08-09 13:31:25

PythonExcel代码

2020-03-08 22:06:16

Python数据IP

2021-12-11 20:20:19

Python算法线性

2012-01-11 13:40:35

移动应用云服务

2021-02-02 13:31:35

Pycharm系统技巧Python

2021-08-02 23:15:20

Pandas数据采集

2018-03-23 20:45:23

机器学习NLP文本数据

2011-03-28 16:14:38

jQuery

2021-02-04 09:00:57

SQLDjango原生

2021-02-06 14:55:05

大数据pandas数据分析

2009-08-27 18:10:58

PHP绘制3D图形

2021-05-17 21:30:06

Python求均值中值

2021-01-30 10:37:18

ScrapyGerapy网络爬虫
点赞
收藏

51CTO技术栈公众号