利用PyTorch搭建神經網路

神經網路可以使用PyTorch的torch.nn包來構建。
autograd實現了反向傳播的功能，但是直接用來深度學習的程式碼在很多情況下還是稍顯複雜。
torch.nn是專門為神經網路設計的模組化介面，nn構建於autograd之上，可以用來定義和執行神經網路。nn.Moudle是nn中最重要的類，可把它看成是一個網路的封裝，包含網路各層定義以及forward方法，呼叫forward(input)方法，可返回前向傳播的結果。

一個典型的神經網路訓練過程如下：

• 定義具有一些可學習引數（或權重）的神經網路
• 迭代輸入資料集
• 通過網路處理輸入
• 計算損失（輸出的預測值於實際值之間的距離）
• 將梯度傳播回網路
• 更新網路的權重，通常使用一個簡單的更新規則：weight = weight - learning_rate * gradient

1、Variable變數
在神經網路裡，資料都是Variable變數的形式，是把tensor的資料放入神經網路的variable變數中，來慢慢更新神經網路中的引數。

import torch
from torch.autograd import Variable

tensor = torch.FloatTensor([[1,2],[3,4]])
variable = Variable(tensor,requires_grad=True)  #用Variable將tensor放入variable變數中
 

執行結果：

可以看到tensor的結果是7.5，variable的結果是Variable containing巴拉巴拉下面一堆，這說明。tensor只得到一個結果，而variable卻是屬於圖的一部分，什麼圖呢，就是神經網路的流程圖，這裡有必要提到PyTorch於TensorFlow的區別了，TensorFlow是先建立一個靜態的流程圖在放資料，而PyTorch是一邊放資料一邊搭圖，所以tensor不能夠作為神經網路中的變數，因為它不是圖的一部分同時也不能進行反向傳播。
下面來看下兩者在反向傳播中的差別：

variable是神經網路中的變數，它有梯度grad的屬性，也有data的屬性，它的data的屬性就是tensor型別的資料，所以從variable轉化為Numpy的話，要用variable.data.numpy()，也就是先轉為tensor再轉為numpy。
而tensor只是資料並沒有任何屬性。

2、激勵函式（Activation Function）
首先來看神馬是激勵函式：

現實生活中很多問題都是非線性的，不規則的，所以這就需要激勵函式幫助我們處理這些非線性問題。
Linear function：y = wx
Unlinear function： y = AF(Wx) 其中AF就是激勵函式，其實激勵函式就是一個非線性函式，將這個非線性函式作用線上性結果上，強行將線性結果變非線性，從而使輸出結果也會帶有非線性的特徵。

甚至可以自己創造激勵函式處理問題，但是要保證你的激勵函式是可以微分的，因為誤差反向傳播的過程，只有可以微分的函式才可以將誤差反向傳遞回去。
當神經網路層數較少的情況下，你可以隨意選擇激勵函式都沒問題，但是當神經網路層數較多的情況下，就不能在隨意選擇了，因為會涉及到梯度消失，梯度爆炸的問題。
卷積神經網路中推薦用relu，迴圈神經網路中推薦用relu和tanh。

下面來看下激勵函式的用法：

注意在神經網路中進行運算的資料都是variable變數，所以要接受激勵函式的作用就要先將numpy的資料利用torch.tensor(numpy)來轉化為variable型別的資料，但是使用matplotlib畫圖的時候還是需要numpy的資料，所以要利用x.data.numpy()來轉化回numpy。

3、初步搭建神經網路

（1）關係擬合迴歸:

import torch
from torch.autograd import Variable
import torch.nn.function as F
import matplotlib.pyplot as plt

x = torch.unsqueeze(torch.linspace(-1,1,100),dim=1) #因為在torch中它的資料是有維度的，unsqueeze就是把一維的資料轉化為二維
y = x.pow(2) + 0.2*torch.rand(x.size())
x,y = Variable(x), Varitable(y)
#plt.scatter(x.data.numpy(),y.data.numpy())  #這裡是畫圖
#plt.show()

#下面開始搭建神經網路：
class Net(torch.nn.Module):
    #init中設定好每一層的輸入輸出口有幾個
    def __init__(self,n_feature,n_hidden,n_output):
        super(Net,self).__init__()
        self.hidden = torch.nn.Linear(n_features,n_hidden)
        self.predict = torch.nn.Linear(n_hidden,n_output)
    #forward才算是真正開始搭建神經網路,x是輸入資訊，
    def forward(self,x):
        #輸入資料先經過一個隱藏層，然後再用激勵函式啟用
        x = F.relu(self.hidden(x))
        #再讓x經過輸出層，這裡可以不再用激勵函式啟用，因為大多數我們所預測的結果的取值都是從正無窮到負無窮，所以並不需要使用激勵函式進行擷取（因為一般的激勵函式的值域都只是在一定區間內）
        x = self.predict(x)
        return x
net = Net(1,10,1)
print(net)
#到此為止，神經網路就算是搭建完成了

總結下以上的一些類：

• torch.Tensor是一個多維陣列，於ndarrary類似，只不過可以利用張量在GPU上加速運算
• Variable:是神經網路內的變數，variable不僅含有資料，也包括資料在神經網路中的一些操作行為，換句話說variable就是用來包裝tensor，並且記錄tensor資料在網路中的歷史操作，variable有梯度grad。
• nn.Module 是一個神經網路模組，說白了就是一個封裝好的網路，包含初始化，網路中每層的定義等，我們可以通過繼承這個類，重寫它的函式來方便的形成我們自己的網路。
• torch.functional是torch的方法類，用來獲得激勵函式。

計算損失函式並更新權重：

我們使用神經網路的優化器來對網路引數進行優化，，torch.optim中有很多optimizer，這裡使用的是SGD，net.parameters()就是網路中所有的引數，lr是學習率，學習率越高，學習的越快，但是學習的越快就會忽視一些內容，造成學習效率並不高的結果，所以一般lr小於1。

損失函式採用（output，target）輸入對，並計算預測輸出結果與實際目標的距離。
在nn包裡有幾種不同的損失函式，一個簡單的損失函式是nn.MSELoss計算輸出和目標之間的均方誤差，迴歸問題用這個就足夠了，如果是分類問題，就用另外一個，下面會提到

optimizer = torch.optim.SGD(net.parameters(),lr=0.5)#定義優化器
loss_func = torch.nn.MSELoss()  #計算損失值

#開始訓練
for t in range(100):
    prediction = net(x) #經過網路得到結果
    loss = loss_func(prediction,y)    #計算預測值與真實值之間的距離，注意順序，loss_func(預測值，真實值)，因為反過來有可能會出錯。
    optimizer.zero_grad()    #把之前的梯度清零，否則梯度會累加之前的梯度（詳細的原因還在探究中，稍後補上）
    loss.backward() #進行反向誤差傳播，計算各結點梯度
    optimizer.step()  #用optimizer優化更新網路引數

（2）分類神經網路

整體的程式碼和迴歸其實都差不多，只需修改下資料和損失函式。

import torch
from torch.autograd import Variable
import torch.nn.functional as F
import matplotlib.pyplot as plt

n_data = torch.ones(100,2)
x0 = torch.normal (2*n_data,1)
y0 = torch.zeros(100)
x1 = torch.normal(-2*n_data,1)
y1 = torch.ones(100)
x = torch.cat((x0.x1),0).type(torch.FloatTensor)
y = torch.cat((y0,y1),).type(torch.LongTensor)

x,y = Variable(x), Variable(y)

class Net(torch.nn.Module):
      def __init__(self,n_feature,n_hidden,n_output):
            super(Net,self).__init__()
            self.hidden = torch.nn.Linear(n_feature,n_hidden)
            self.predict = torch.nn.Linear(n_hidden,n_output)
      def forward(self,x):
            x = F.relu(self.hidden(x))
            x = self.predict(x)
            return x
 net = Net(2,10,2)
 print(net)

optimizer = torch.optim.SGD(net.parameters(),lr=0.02)
loss_func = torch.nn.CrossEntropyLoss()

for t in range(100):
     prediction = net(x)
     loss = loss_func(prediction,y)
     optimizer.zero_grad()
     loss.backward()
     optimizer.step()