pytorch深度学习如何入门？

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

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

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

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

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

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

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

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

importtorch

importtorch.autogradasautograd

importtorch.nn.functionalasF

importtorch.nnasnn

importtorch.optimasoptim

importnumpyasnp

#序列标注模型

classSeqModel(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()

definit_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)))

defforward(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

returntag_scores

classRunModel():

def__init__(self,model):

self.model = model

self.loss_function = nn.NLLLoss()

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

defrun(self,training_datas,n_epoch=300):

self.traing_datas = training_datas

forepochinrange(n_epoch):

self._run_epoch(epoch)

def_run_epoch(self,epoch):

print('当前epoch:',epoch)

losses = []

forwords_idxs,tags_idxsinself.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()[])

loss.backward()

self.optimizer.step()

print('loss:',np.mean(losses))

defpredict(self,input):

result =self.model(input)

idx = np.argmax(result.data.numpy(),axis=1)

print(idx)

returnidx

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