pytorch 实现LSTM

客官°小女子只卖身不卖艺 2022-03-28 09:44 229阅读 0赞

\*\*

## Pytorch基础知识点整理 ##

\*\*  
梯度 下降：

#_*_coding:utf-8_*_
    from math import pi
    import torch
    import torch.optim
    x = torch.tensor([pi /3,pi /6],requires_grad = True)
    optim = torch.optim.SGD([x,],lr = 0.1,momentum=0)
    
    for step in range(11):
        if step:
            optim.zero_grad()#清零
            f.backward()#计算梯度
            optim.step()#更新参数
        f = - ((x.cos() ** 2).sum()) ** 2       #实验下来f函数的定义也可以放在if前面，结果不变
        print('step:{},x = {},f(x) = {}'.format(step,x.tolist(),f))

\*\*

## Pytorch实现LSTM ##

\*\*

#_*_coding:utf-8_*_
    import os
    import codecs
    import string
    from nltk.corpus import stopwords
    import snowballstemmer
    import re
    from itertools import chain
    from gensim import models
    import torch
    from torch import nn
    import torch.optim as optim
    import torch.utils.data.dataloader as dataloader
    from torch.autograd import Variable
    import time
    from sklearn.metrics import accuracy_score
    
    def read_Data(path,seg = 'train'):
        labels = ['pos','neg']
        data = []
        for label in labels:
            files = os.listdir(os.path.join(path,seg,label))
            for file in files:
                file_data = codecs.open(os.path.join(path,seg,label,file),'r','utf-8')
                review = file_data.read().replace('\n','')
                if label == 'pos':
                    data.append([review,1])
                elif label == 'neg':
                    data.append([review,0])
        return data
    
    train_data = read_Data('/Users/yangyang/Desktop/aclImdb')
    test_data = read_Data('/Users/yangyang/Desktop/aclImdb','test')
    
    def tokenizer(text):
        return [token.lower() for token in text.split(' ')]
    
    #全部小写的data [[]]
    train_token = []
    test_token = []
    
    for text,label in train_data:
        train_token.append(tokenizer(text))
    for text,label in test_data:
        test_token.append(tokenizer(text))
    
    #词表去重
    vocab = set(chain(*train_token))
    vocab_size = len(vocab)
    
    model = models.KeyedVectors.load_word2vec_format('/Users/yangyang/Desktop/glove/word2vec.6B.100d.txt',binary=False,encoding='utf-8')
    
    
    #给每个词一个特定的编号
    word_to_idx = {word:i+1 for i,word in enumerate(vocab)}
    word_to_idx['<unk>'] = 0
    # idx_to_word = {word_to_idx[k]:k for k,v in word_to_idx}
    idx_to_word = {i+1: word for i, word in enumerate(vocab)}
    idx_to_word[0] = '<unk>'
    
    #取编码
    def encode_samples(data,vocab):
        result = []
        for items in data:
            tmp = []
            for strs in items:
                if strs in word_to_idx:
                    tmp.append(word_to_idx[strs])
                else:
                    tmp.append(0)
            result.append(tmp)
        return result
    #解决长度问题  所有文本的长度统一为max_length
    def pad_samples(data,max_length = 500,PAD = 0):
        padded_features = []
        for item in data:
            if len(item) >= max_length:
                pad_item = item[:max_length]
            else:
                pad_item = item
                while(len(pad_item) < max_length):
                    pad_item.append(PAD)
            padded_features.append(pad_item)
        return padded_features
    
    train_features = torch.Tensor(pad_samples(encode_samples(train_token,vocab)))
    train_labels = torch.Tensor([label for _,label in train_data])
    test_features = torch.Tensor(pad_samples(encode_samples(test_data,vocab)))
    test_labels = torch.Tensor([label for _,label in test_data])
    
    class LSTM(nn.Module):
        def __init__(self,vocab_size,embed_size,num_hiddens,num_layers,bidirectional,weight,lables,use_gpu,**kwargs):
    
            super(LSTM,self).__init__(**kwargs)
            self.num_hiddens = num_hiddens
            self.num_layers = num_layers
            self.use_gpu = use_gpu
            self.bidirectional = bidirectional
            self.embedding = nn.Embedding.from_pretrained(weight)
            self.embedding.weight.requires_grad = False
            self.encoder = nn.LSTM(input_size=embed_size,hidden_size=self.num_hiddens,
                                   num_layers=num_layers,bidirectional=self.bidirectional
                                   ,dropout=0)
            #bidirectional：True则为双向lstm默认为False
            if self.bidirectional:
                self.decoder = nn.Linear(num_hiddens*4,lables)
            else:
                self.decoder = nn.Linear(num_hiddens*2,lables)
    
        def forward(self, inputs):
            #size(64,500,300)
            embeddings = self.embedding(inputs)
            #permute后(500,64,300)   (batch,seq,input_size)
            #states.size(500,64,200)
            output, hidden = self.encoder(embeddings.permute([1, 0, 2]))
            #states[i] size(64,200)   -> encoding.size(64,400)
            encoding = torch.cat([output[0], output[-1]], dim=1)
            #这里就可以矩阵相乘了
            outputs = self.decoder(encoding)
            return outputs
    
    num_epochs = 5
    embed_size = 300
    num_hiddens = 100
    num_layers = 2
    bidirectional = True
    batch_size = 64
    labels = 2
    lr = 0.8
    device = torch.device('cuda:0')
    use_gpu = True
    
    weight = torch.zeros(vocab_size+1,embed_size)
    
    for i in range(len(model.index2word)):
        try:
            index = word_to_idx[model.index2word[i]]
        except:
            continue
        weight[index,:] = torch.from_numpy(model.get_vector(
            idx_to_word[word_to_idx[model.index2word[i]]]
        ))
    
    net = LSTM(vocab_size=(vocab_size+1),embed_size=embed_size,num_hiddens=num_hiddens,num_layers=num_layers,
               bidirectional=bidirectional,weight=weight,
               lables=labels,use_gpu=use_gpu)
    net.to(device)
    loss_function = nn.CrossEntropyLoss()
    optimizer = optim.SGD(filter(lambda p:p.requires_grad,net.parameters()),lr=lr)
    
    
    train_set = torch.utils.data.TensorDataset(train_features,train_labels)
    test_set = torch.utils.data.TensorDataset(test_features,test_labels)
    
    train_iter = torch.utils.data.DataLoader(train_set,batch_size=batch_size,shuffle=True)
    test_iter = torch.utils.data.DataLoader(test_set,batch_size=batch_size,shuffle=False)
    
    for epoch in range(num_epochs):
        start = time.time()
        train_loss,test_losses = 0,0
        train_acc,test_acc = 0,0
        n,m = 0,0
        for feature,label in train_iter:
            n += 1
            net.zero_grad()
            feature = Variable(feature.cuda())
            label = Variable(label.cuda())
            score = net(feature)
            loss = loss_function(score,label)
            loss.backward()
            optimizer.step()
    
            train_acc += accuracy_score(torch.argmax(score.cpu().data,dim=1),label.cpu())
            train_loss += loss
    
        with torch.no_grad():
            for test_feature,test_label in test_iter:
                m += 1
                test_feature = test_feature.cuda()
                test_label = test_label.cuda()
                test_score = net(test_feature)
                test_loss = loss_function(test_score,test_label)
                test_acc += accuracy_score(torch.argmax(test_score.cpu().data,dim=1),test_label.cpu())
                test_losses += test_loss
    
        end = time.time()
        runtime = end - start
    print('epoch: %d, train loss: %.4f, train acc: %.2f, test loss: %.4f, test acc: %.2f, time: %.2f' %
              (epoch, train_loss.data / n, train_acc / n, test_losses.data / m, test_acc / m, runtime))

[参考博客https://samaelchen.github.io/pytorch\_lstm\_sentiment/][https_samaelchen.github.io_pytorch_lstm_sentiment]

[https_samaelchen.github.io_pytorch_lstm_sentiment]: https://samaelchen.github.io/pytorch_lstm_sentiment/