本文主要講述最簡單的線性迴歸函式：
$y=wx+b$

wx+b在pytorch的實現，主要包括神經網路實現的基本步驟和nn.Linear的原始碼解讀。

1. nn.Linear 原始碼解讀

先看一下Linear類的實現：
原始碼網址:https://pytorch.org/docs/stable/_modules/torch/nn/modules/linear.html

Linear繼承於nn.Module,內部函式主要有__init__，reset_parameters, forward和extra_repr函式

1. __init__(self, in_features, out_features, bias=True)

• in_features：前一層網路神經元的個數
• out_features： 該網路層神經元的個數
  以上兩者決定了weight的形狀[out_features , in_features]
• bias: 網路層是否有偏置，預設存在，且維度為[out_features ],若bias=False,則該網路層無偏置。

接下來看一下，輸入該網路層的形狀(N, *, in_features)，其中N為批量處理過成中每批資料的數量，*表示，單個樣本資料中間可以包含很多維度，但是單個數據的最後一個維度的形狀一定是in_features.

經過該網路輸出的形狀為(N, *, out_features),其中計算過程為：

$[$

N , ∗ , i n _ f e a t u r e s ] ∗ [ o u t _ f e a t u r e s , i n _ f e a t u r e s ] T = [ N , ∗ , i n _ f e a t u r e s ] [N, *, in\_{features}] * {[out\_{features }, in\_{features}]}^T = [N, *, in\_{features}]

接下來在看一下Linear包含的屬性：
從__init__函式中可以看出Linear中包含四個屬性

• in_features: 上層神經元個數
• out_features： 本層神經元個數
• weight：權重， 形狀[out_features , in_features]
• bias: 偏置， 形狀[out_features]

2. reset_parameters(self)
   引數初始化函式
   在__init__中呼叫此函式，權重採用Xvaier initialization 初始化方式初始引數。

3. forward(self, input)
   在Module的__call__函式呼叫此函式，使得類物件具有函式呼叫的功能，同過此功能實現pytorch的網路結構堆疊。
   具體實現方式請看下面兩篇部落格：

• https://blog.csdn.net/dss_dssssd/article/details/83750838
• https://blog.csdn.net/dss_dssssd/article/details/82977170

在自己寫自己的類結構是，繼承於Module，然後主要實現__init__函式和forward函式即可，至於可能的引數初始化方式，在後面的文章中會講到，在這只是用預設的初始化方式。

2. 結合程式碼講解神經網路實現的基本步驟

• 準備資料
• 定義網路結構model
• 定義損失函式
• 定義優化演算法 optimizer
• 訓練
  • 準備好tensor形式的輸入資料和標籤(可選)
  • 前向傳播計算網路輸出output和計算損失函式loss
  • 反向傳播更新引數
    以下三句話一句也不能少：
    1. 將上次迭代計算的梯度值清0
       optimizer.zero_grad()
    2. 反向傳播，計算梯度值
       loss.backward()
    3. 更新權值引數
       optimizer.step()
  • 儲存訓練集上的loss和驗證集上的loss以及準確率以及列印訓練資訊。（可選
• 圖示訓練過程中loss和accuracy的變化情況(可選)
• 在測試集上測試

3. Linear_Regression程式碼解讀

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt


# Hyper-parameters 定義迭代次數， 學習率以及模型形狀的超引數
input_size = 1
output_size = 1
num_epochs = 60
learning_rate = 0.001

# Toy dataset  1. 準備資料集
x_train = np.array([[3.3], [4.4], [5.5], [6.71], [6.93], [4.168], 
                    [9.779], [6.182], [7.59], [2.167], [7.042], 
                    [10.791], [5.313], [7.997], [3.1]], dtype=np.float32)

y_train = np.array([[1.7], [2.76], [2.09], [3.19], [1.694], [1.573], 
                    [3.366], [2.596], [2.53], [1.221], [2.827], 
                    [3.465], [1.65], [2.904], [1.3]], dtype=np.float32)

# Linear regression model  2. 定義網路結構 y=w*x+b 其中w的size [1,1], b的size[1,]
model = nn.Linear(input_size, output_size)

# Loss and optimizer 3.定義損失函式， 使用的是最小平方誤差函式
criterion = nn.MSELoss()
# 4.定義迭代優化演算法， 使用的是隨機梯度下降演算法
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)  
loss_dict = []
# Train the model 5. 迭代訓練
for epoch in range(num_epochs):
    # Convert numpy arrays to torch tensors  5.1 準備tensor的訓練資料和標籤
    inputs = torch.from_numpy(x_train)
    targets = torch.from_numpy(y_train)

    # Forward pass  5.2 前向傳播計算網路結構的輸出結果
    outputs = model(inputs)
    # 5.3 計算損失函式
    loss = criterion(outputs, targets)
    
    # Backward and optimize 5.4 反向傳播更新引數
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    
    # 可選 5.5 列印訓練資訊和儲存loss
    loss_dict.append(loss.item())
    if (epoch+1) % 5 == 0:
        print ('Epoch [{}/{}], Loss: {:.4f}'.format(epoch+1, num_epochs, loss.item()))

# Plot the graph 畫出原y與x的曲線與網路結構擬合後的曲線
predicted = model(torch.from_numpy(x_train)).detach().numpy()
plt.plot(x_train, y_train, 'ro', label='Original data')
plt.plot(x_train, predicted, label='Fitted line')
plt.legend()
plt.show()

# 畫loss在迭代過程中的變化情況
plt.plot(loss_dict, label='loss for every epoch')
plt.legend()
plt.show()

訓練結果：
每次迭代的損失函式

Epoch [5/60], Loss: 1.8269
Epoch [10/60], Loss: 0.9979
Epoch [15/60], Loss: 0.6616
Epoch [20/60], Loss: 0.5250
Epoch [25/60], Loss: 0.4693
Epoch [30/60], Loss: 0.4463
Epoch [35/60], Loss: 0.4366
Epoch [40/60], Loss: 0.4322
Epoch [45/60], Loss: 0.4301
Epoch [50/60], Loss: 0.4288
Epoch [55/60], Loss: 0.4279
Epoch [60/60], Loss: 0.4271