[NLP] nlp-lstm-cos -> sin

LSTM

看了官方lstm以及相关原理，然后自己按照理解写了一遍，然后在网上看到cos预测sin问题，然后用lstm完成了建模。

看到好多论文里图像文本特征用lstm的，对学ocr有点帮助。

官方lstm例子

给定句子对句子里的词进行词性分类。

'''
@Descripttion: This is Aoru Xue's demo,which is only for reference
@version:
@Author: Aoru Xue
@Date: 2019-08-17 21:58:08
@LastEditors: Aoru Xue
@LastEditTime: 2019-08-26 13:34:22
'''
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

training_data = [
    ("The dog ate the apple".split(), ["DET", "NN", "V", "DET", "NN"]),
    ("Everybody read that book".split(), ["NN", "V", "DET", "NN"])
]
words_set = list(set([word for data in training_data for word in data[0]]))
def word2idx(word):
    return words_set.index(word)
def target2idx(target):
    dic = {"NN":0,"DET":1,"V":2}
    return dic[target]
def get_training_idx(training_data):
    idxs = []
    for words,targets in training_data:
       idxs.append((torch.tensor([word2idx(word) for word in words],dtype = torch.long),
       torch.tensor([target2idx(target) for target in targets])))
    return idxs
class LSTMTagger(nn.Module):
    def __init__(self,hidden_dim,vocab_size,embedding_dim,tag_dim):
        super(LSTMTagger,self).__init__()
        self.embedding_dim = embedding_dim
        self.tag_dim = tag_dim
        self.words_embeddings = nn.Embedding(vocab_size,embedding_dim)
        self.lstm = nn.LSTM(embedding_dim,hidden_dim)
        self.hidden2tag = nn.Linear(hidden_dim,tag_dim)
    def forward(self,x):
        # x (len(wods),)
        x = self.words_embeddings(x) # (len(words),embedding_dim)
        x, _ = self.lstm(x.view(1,-1,self.embedding_dim)) # 默认batch_size 为1 是 (len(words),onehotdim).其实应该是(batch_size,len(words),onehotdim)
        x = self.hidden2tag(x) # (1,len(words),tag_dim)
        return x.view((-1,self.tag_dim))
if __name__ == "__main__":
    train_data = get_training_idx(training_data)
    model = LSTMTagger(hidden_dim = 64,vocab_size = len(words_set),embedding_dim = 32,tag_dim =3)
    loss_fn = nn.NLLLoss()
    optimizer = optim.SGD(model.parameters(),lr = 0.1)
    losses = []
    for epoch in range(300):
        for sentence,target in train_data:
            model.zero_grad()
            out = model(sentence)
            loss = loss_fn(out,target)
            losses.append(loss.item())
            loss.backward()
            optimizer.step()

    with torch.no_grad():

        for sentence,target in train_data:
            print(torch.argmax(model(sentence),dim = 1),target)

'''
[Running] set PYTHONIOENCODING=utf-8 && /home/xueaoru/.conda/envs/pytorch/bin/python -u "/home/xueaoru/文档/codes/LSTM.py"
tensor([1, 0, 2, 1, 0]) tensor([1, 0, 2, 1, 0])
tensor([0, 2, 1, 0]) tensor([0, 2, 1, 0])
'''

cos预测sin

cos值与sin值是多对多的关系，直接随便用一个nn无法完成建模，需要考虑前后数据关系来建模。

即由前面输入的数据的cos数据来确定该处sin值应该是多少。

训练感觉好慢。将近两分钟。

建模代码如下：

'''
@Descripttion: This is Aoru Xue's demo,which is only for reference
@version:
@Author: Aoru Xue
@Date: 2019-08-26 16:22:36
@LastEditors: Aoru Xue
@LastEditTime: 2019-08-26 17:05:54
'''
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F

raw_inputs = torch.tensor([i*np.pi / 20 for i in range(1000)],dtype = torch.float)
cosx =torch.cos(raw_inputs)
sinx = torch.sin(raw_inputs)

class RNNModule(nn.Module):
    def __init__(self,hidden2):
        super(RNNModule,self).__init__()
        self.lstm = nn.LSTM(1,hidden2)
        self.flatten = nn.Linear(hidden2,1)
    def forward(self,x):
        x = x.view((-1,1,1))
        x,_ = self.lstm(x)

        x = self.flatten(x)
        return x.view((1,-1))
if __name__ == "__main__":
    model = RNNModule(16)
    xs = [x*np.pi / 20 for x in range(0,2000)]
    optimizer = optim.Adam(model.parameters())
    loss_fn = nn.MSELoss()
    for epoch in range(100):
        for i in range(0,1000 - 20):
            model.zero_grad()
            cos_x = torch.cos(torch.tensor(xs[i:i+20],dtype = torch.float))
            out = model(cos_x)
            sin_x = torch.sin(torch.tensor(xs[i:i+20],dtype = torch.float))
            loss = loss_fn(out,sin_x.view(1,-1))
            loss.backward()
            optimizer.step()
    with torch.no_grad():
        x = cosx[0:20]
        output = model(x)
        print(output,sinx[0:20])

 '''
 tensor([[-0.0167,  0.0853,  0.2704,  0.4169,  0.5790,  0.7059,  0.8086,  0.9002,
          0.9675,  0.9988,  1.0050,  0.9896,  0.9524,  0.8948,  0.8171,  0.7172,
          0.5929,  0.4554,  0.3129,  0.1634]]) tensor([0.0000, 0.1564, 0.3090, 0.4540, 0.5878, 0.7071, 0.8090, 0.8910, 0.9511,
        0.9877, 1.0000, 0.9877, 0.9511, 0.8910, 0.8090, 0.7071, 0.5878, 0.4540,
        0.3090, 0.1564])

 '''