NNLM代码

Zzz_25

已于 2022-04-08 20:58:08 修改

阅读量749

点赞数 1

文章标签： python 自然语言处理 pytorch

于 2022-04-08 20:54:58 首次发布

本文链接：https://blog.csdn.net/qq_40478639/article/details/124037437

版权

一、引入torch

二、 make_batch

三、定义模型class NNLM(nn.Module)

1、super(Model, self).__init__()

（1）self

（2）__ init__ ()方法

（3）super(MyModel, self).__init__()

2、nn.Embedding

3、nn.Linear(in_features, out_features, bias=True)

4、nn.Parameter()

nn.Parameter()和nn.Linear()

！博客内容就是自己想仔细研究一下这个代码里面各个方法的具体用法

https://github.com/graykode/nlp-tutorial

nlp-tutorial/1-1.NNLM at master · graykode/nlp-tutorial · GitHub

一、引入torch

import torch
import torch.nn
import torch.optim as optim

二、 make_batch

创建语料

# 语料
sentences = ["I like dog", "I love coffee", "I hate milk"]

创建word2idx字典

word_list = " ".join(sentences).split()  # 每句话所有词切分出来
word_list = list(set(word_list))  # 去重
word_dict = {w: i for i, w in enumerate(word_list)}   #  word:idx  word_dict['word']=idx
number_dict = {i: w for i, w in enumerate(word_list)}  # idx:word  number_dict[idx]='word'
n_class = len(word_dict)  # number of Vocabulary  # 字典大小

构造batch

def make_batch():
    input_batch = []  # 输入batch
    target_batch = []  # 目标batch

    for sen in sentences:  # 扫描每句话，构建batch
        # 把一句话的每个词切分
        # ["I like coffee"]  --> ["I", "like", "coffee"]
        word = sen.split()  # space tokenizer  
        # 最后一个词作为target，其他词作为input
        input = [word_dict[n] for n in word[:-1]]  # create (1~n-1) as input
        target = word_dict[word[-1]]  # create (n) as target, We usually call this 'casual language model'

        # 将一句话切分后分别放入input_batch和target_batch
        input_batch.append(input)
        target_batch.append(target)

    return input_batch, target_batch

三、定义模型class NNLM(nn.Module)

class NNLM(nn.Module):
    def __init__(self):
        super(NNLM, self).__init__()

        self.C = nn.Embedding(n_class, m)
        
        self.H = nn.Linear(n_step * m, n_hidden, bias=False)
        self.d = nn.Parameter(torch.ones(n_hidden))
        
        self.U = nn.Linear(n_hidden, n_class, bias=False)
        
        self.W = nn.Linear(n_step * m, n_class, bias=False)
        self.b = nn.Parameter(torch.ones(n_class))

    def forward(self, X):
        X = self.C(X)  # X : [batch_size, n_step, m]
        
        X = X.view(-1, n_step * m)  # [batch_size, n_step * m]
        
        tanh = torch.tanh(self.d + self.H(X))  # [batch_size, n_hidden]
        
        output = self.b + self.W(X) + self.U(tanh)  # [batch_size, n_class]
        return output

自己写模型类的优势就是可以自定义层与层之间的连接关系，自定义数据流x的流向。

1、super(Model, self).init()

（1）self

self指的是实例Instance本身，在Python类中规定，函数的第一个参数是实例对象本身，并且约定俗成，把其名字写为self，也就是说，类中的方法的第一个参数一定要是self，而且不能省略。

（2） init ()方法

在python中创建类后，通常会创建一个 __ init__ ()方法，这个方法会在创建类的实例的时候自动执行。 __ init__ ()方法必须包含一个self参数，而且要是第一个参数。

__ init__ ()方法在实例化的时候就已经自动执行了，但是如果不是 __ init__ ()方法，那肯定就只有调用才执行。如果 __ init__ ()方法中还需要传入另一个参数name，但是我们在创建Bob的实例的时候没有传入name，那么程序就会报错，说我们少了一个__ init__ ()方法的参数，因为__ init__ ()方法是会在创建实例的过程中自动执行的，这个时候发现没有name参数，肯定就报错了。

当我们认为一些属性、操作是在创建实例的时候就有的时候，就应该把这个量定义在__ init__ ()方法中。我们写神经网络的代码的时候，一些网络结构的设置，也最好放在__ init__ ()方法中。

（3）super(MyModel, self).init()

简单理解就是子类把父类的__init__()放到自己的__init__()当中，这样子类就有了父类的__init__()的那些东西。

2、nn.Embedding

#建立词向量层
embed = torch.nn.Embedding(n_vocabulary,embedding_size)

实际上，上面通过随机初始化建立了词向量层后，建立了一个“二维表”，存储了词典中每个词的词向量。

！

nn.embedding 的输入只能是编号，不能是隐藏变量，比如one-hot，或者其他。这种情况可以自己建一个自定义维度的线性网络层，参数训练可以单独训练或者跟随整个网络一起训练。

3、nn.Linear(in_features, out_features, bias=True)

in_features 指的是输入的二维张量的大小，即输入的[batch_size, size]中的size。
out_features 指的是输出的二维张量的大小，即输出的二维张量的形状为[batch_size，output_size]

输入[batch_size, in_features] --> [batch_size, out_features]