pytorch深度学习如何入门？

入门在这个快速迭代的时代，是个常新的话题。

我们都在不停的学习新知识。

tensorflow的学习，大部分时间是花在学习tensorflow上，以及适应它那非常不稳定的api。而不是深度学习本身。

另外很多例子，论文，大量时间是花在语料的准备和预处理上。也与深度学习无关。

去掉这两块包装的外衣，很多模型，论文都非常单薄。

所以，我们选择pytorch，选择用示例的corpus，只呈现深度学习本身的细节与魅力。

神经网络确实有通用性。传统SVM或CRF,HMM都只能干特定的事情，如果修改，那得重新去论证，推导；而深度神经网络，你改个激活函数，或者加几个层，就是左手右手一个慢动作的事情。

做NLP，本质上是一个序列标注的问题。我们先写一个序列标注的处理模型。这个维度是确定了，如果

import torch
import torch.autograd as autograd
import torch.nn.functional as F
import torch.nn as nn
import torch.optim as optim

import numpy as np

#序列标注模型
class SeqModel(nn.Module):

    #词嵌入维度，隐层大小，词汇表大小，目标分类
    def __init__(self, embedding_dim, hidden_dim, vocab_size, tagset_size):
        super(SeqModel, self).__init__()
        self.hidden_dim = hidden_dim

        #embedding接受是句子（字或词的下标向量，长度N个字）-> N*embedding_dim的矩阵
        self.word_embeddings = nn.Embedding(vocab_size, embedding_dim)

        self.lstm = nn.LSTM(embedding_dim, hidden_dim)

        #分成几类
        self.hidden2tag = nn.Linear(hidden_dim, tagset_size)
        self.hidden = self.init_hidden()

    def init_hidden(self):
        # Before we've done anything, we dont have any hidden state.
        # Refer to the Pytorch documentation to see exactly why they have this dimensionality.
        # The axes semantics are (num_layers, minibatch_size, hidden_dim)
        return (autograd.Variable(torch.zeros(1, 1, self.hidden_dim)),
                autograd.Variable(torch.zeros(1, 1, self.hidden_dim)))

    def forward(self, sentence):
        embeds = self.word_embeddings(sentence)
        lstm_out, self.hidden = self.lstm(embeds.view(len(sentence), 1, -1), self.hidden)#seq_len个1xhidden_size
        tag_space = self.hidden2tag(lstm_out.view(len(sentence), -1))#seqxhidden_dim ->target
        tag_scores = F.log_softmax(tag_space,dim=1)#N*target_space
        return tag_scores


class RunModel():
   def __init__(self,model):
       self.model = model

       self.loss_function = nn.NLLLoss()
       self.optimizer = optim.SGD(model.parameters(), lr=0.1)

   def run(self,training_datas,n_epoch=300):
       self.traing_datas = training_datas

       for epoch in range(n_epoch):
        self._run_epoch(epoch)

   def _run_epoch(self,epoch):
       print('当前epoch:',epoch)
       losses = []
       for words_idxs,tags_idxs in self.traing_datas:
           #print(words_idxs)
           print(tags_idxs)
           #每一句，也就是说每一个序列，都需要清零导数，并重置隐层
           self.model.zero_grad()
           self.model.hidden = self.model.init_hidden()

           pred = self.model(words_idxs) #seq个word下标

           loss = self.loss_function(pred, tags_idxs)
           #losses.append(loss.data[0])
           losses.append(loss.data.tolist()[0])
           loss.backward()
           self.optimizer.step()
       print('loss:',np.mean(losses))

   def predict(self,input):
        result = self.model(input)
        idx = np.argmax(result.data.numpy(),axis=1)
        print(idx)
        return idx

关于作者：魏佳斌，互联网产品/技术总监，北京大学光华管理学院（MBA）,特许金融分析师（CFA），资深产品经理/码农。偏爱python，深度关注互联网趋势，人工智能，AI金融量化。致力于使用最前沿的认知技术去理解这个复杂的世界。