PyTorch深度學習實踐---筆記

2.線性模型（Linear Model）
- 2.exercise
3. 梯度下降算法（Gradient Descent）
- 3.1梯度下降（Gradient Descent）
- 3.2 隨機梯度下降（Stochastic Gradient Descent）
4. 反向傳播（Back Propagation）
5. 用PyTorch實現線性回歸
6. 邏輯回歸（Logistics Regression）
7. 處理多維特征的輸入（Multiple Dimension Input）
8. 加載數據集
9. 多分類問題

2.線性模型（Linear Model）

import numpy as np
import matplotlib.pyplot as pltx_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]def forward(x):return x*wdef loss(x,y):y_pred=forward(x)return (y_pred-y)*(y_pred-y)w_list=[]
mse_list=[]
for w in np.arange(0.0,4.1,0.1):print('w=',w)l_sum=0for x_val,y_val in zip(x_data,y_data):y_pred_val=forward(x_val)loss_val=loss(x_val,y_val)l_sum+=loss_valprint('\t',x_val,y_val,y_pred_val,loss_val)print('MSE=',l_sum/3)w_list.append(w)mse_list.append(l_sum/3)plt.plot(w_list,mse_list)
plt.ylabel('Loss')
plt.xlabel('w')
plt.show()

在這里插入圖片描述

Exercise：
在這里插入圖片描述

[Link](The mplot3d toolkit — Matplotlib 3.7.1 documentation)
[docs](numpy.meshgrid — NumPy v1.25 Manual)

2.exercise

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib notebookx_data=[1.0,2.0,3.0]
y_data=[3.0,5.0,7.0]def forward(x):return x*w+bdef loss(x,y):y_pred=forward(x)return (y_pred-y)*(y_pred-y)w_list=[]
mse_list=[]
b_list=[]
for w in np.arange(0.0,3.1,0.1):for b in np.arange(-1,1.1,0.1):print('w=',w)print('b=',b)l_sum=0for x_val,y_val in zip(x_data,y_data):y_pred_val=forward(x_val)loss_val=loss(x_val,y_val)l_sum+=loss_valprint('\t',x_val,y_val,y_pred_val,loss_val)print('MSE=',l_sum/3)w_list.append(w)b_list.append(b)mse_list.append(l_sum/3)
W=np.array(w_list)
W=np.unique(W)
B=np.array(b_list)
B=np.unique(B)
MSE=np.array(mse_list)W,B=np.meshgrid(W,B)
MSE=MSE.reshape(21,31)
fig=plt.figure()
ax=Axes3D(fig)
ax.plot_surface(W, B, MSE, cmap='rainbow')ax.set_xlabel('W', color='b')
ax.set_ylabel('B', color='g')
ax.set_zlabel('MSE', color='r')
plt.show()

在這里插入圖片描述

3. 梯度下降算法（Gradient Descent）

3.1梯度下降（Gradient Descent）

import matplotlib.pyplot as plt  x_data = [1.0, 2.0, 3.0]  
y_data = [2.0, 4.0, 6.0]  w = 1.0  def forward(x):  return x * w  def cost(xs, ys):  cost = 0  for x, y in zip(xs, ys):  y_pred = forward(x)  cost += (y_pred - y) ** 2  return cost / len(xs)  def gradient(xs, ys):  grad = 0  for x, y in zip(xs, ys):  grad += 2 * x * (x * w - y)  return grad / len(xs)  print('Predict(before training)', 4, forward(4))  
cost_list = []  
epoch_list = []  
for epoch in range(100):  cost_val = cost(x_data, y_data)  grad_val = gradient(x_data, y_data)  w -= 0.01 * grad_val  cost_list.append(cost_val)  epoch_list.append(epoch)  print('Epoch:', epoch, 'w=', w, 'loss', cost_val)  
print('Predict(after training)', 4, forward(4))  plt.plot(epoch_list, cost_list)  
plt.xlabel('Epoch')  
plt.ylabel('MSE')  
plt.show()

在這里插入圖片描述

3.2 隨機梯度下降（Stochastic Gradient Descent）

import matplotlib.pyplot as plt  x_data = [1.0, 2.0, 3.0]  
y_data = [2.0, 4.0, 6.0]  w = 1.0  def forward(x):  return x * w  def loss(x, y):  y_pred = forward(x)  return (y_pred - y) ** 2  def gradient(x, y):  return 2 * x * (x * w - y)  print('Predict(before training)', 4, forward(4))  
loss_list = []  
epoch_list = []  
for epoch in range(100):  for x, y in zip(x_data, y_data):  grad = gradient(x, y)  w -= 0.01 * grad  print("\tgrad:", x, y, grad)  l = loss(x, y)  print("progress:", epoch, "w=", w, "loss=", l)  epoch_list.append(epoch)  loss_list.append(l)  
print('Predict(after training)', 4, forward(4))  plt.plot(epoch_list, loss_list)  
plt.xlabel('Epoch')  
plt.ylabel('Loss')  
plt.show()

在這里插入圖片描述

4. 反向傳播（Back Propagation）

在這里插入圖片描述

Example 1:
在這里插入圖片描述

在這里插入圖片描述

Exercise 4-1：Answer=-8
在這里插入圖片描述

Exercise 4-2 Answer.1=2，Answer.2=2

import torch
from matplotlib import pyplot as plt
x_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]w=torch.Tensor([1.0])
w.requires_grad=Truedef forward(x):return x*wdef loss(x,y):y_pred=forward(x)return (y_pred-y)**2print("predict (before training)",4,forward(4).item)epoch_list=[]
MSE_list=[]
for epoch in range(100):epoch_list.append(epoch)for x,y in zip(x_data,y_data):l=loss(x,y)l.backward()print('\tgrad:',x,y,w.grad.item())w.data=w.data-0.01*w.grad.dataw.grad.data.zero_()print("progress:",epoch,l.item())MSE_list.append(l.item())
print("prdict (after training)",4,forward(4).item())plt.plot(epoch_list,MSE_list)
plt.xlabel('Epoch')  
plt.ylabel('Loss')
plt.set_tittle("PyTorch")
plt.show()

在這里插入圖片描述

Answer.1：
$\frac{\partial Loss}{\partial w_1}=2*(w_1*x^2+w_2*x+b-y)*x^2$

Answer.2：
$\frac {\partial Loss}{\partial w_2}=2*(w_1*x^2+w_2*x+b-y)*x$

Answer.3：
$\frac {\partial Loss}{\partial b}=2*(w_1*x^2+w_2*x+b-y)$

在這里插入圖片描述

import torch
from matplotlib import pyplot as plt
x_data=[1.0,2.0,3.0]
y_data=[2.0,4.0,6.0]w_1=torch.Tensor([1.0])
w_1.requires_grad=True
w_2=torch.Tensor([2.0])
w_2.requires_grad=True
b=torch.Tensor([3.0])
b.requires_grad=Truedef forward(x):return w_1*(x**2)+w_2*x+bdef loss(x,y):y_pred=forward(x)return (y_pred-y)**2print("predict (before training)",4,forward(4).item)epoch_list=[]
MSE_list=[]
for epoch in range(100):epoch_list.append(epoch)for x,y in zip(x_data,y_data):l=loss(x,y)l.backward()print('\tgrad:','X:',x,'Y:',y,w_1.grad.item(),w_2.grad.item(),b.grad.item())w_1.data=w_1.data-0.01*w_1.grad.dataw_2.data=w_2.data-0.01*w_2.grad.datab.data=b.data-0.01*b.grad.dataw_1.grad.data.zero_()w_2.grad.data.zero_()b.grad.data.zero_()print("progress:",epoch,l.item())MSE_list.append(l.item())
print("prdict (after training)",4,forward(4).item(),'w_1=',w_1.item(),'w_2=',w_2.item(),'b=',b.data.item())plt.plot(epoch_list,MSE_list)
plt.xlabel('Epoch')  
plt.ylabel('Loss')
plt.title("PyTorch")
plt.show()

在這里插入圖片描述

5. 用PyTorch實現線性回歸

在這里插入圖片描述

前饋->反饋->更新
前饋算損失，反饋算梯度，然后更新，反反復復
在這里插入圖片描述

import torch
x_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[2.0],[4.0],[6.0]])class LinearModel(torch.nn.Module):#LinearModel相當于是繼承torch.nn.Module的子類def __init__(self):#Python中類的初始化都是__init__()super(LinearModel,self).__init__()#繼承父類的__init__方法,在__init__初始化方法后還想繼承父類的__init__(),就在子類中使用super（）函數self.linear=torch.nn.Linear(1,1)#定義子類的linear屬性def forward(self,x):y_pred=self.linear(x)#調用子類的linear屬性return y_pred
model=LinearModel()#創建類LinearModel的實例criterion=torch.nn.MSELoss(reduction='sum')#損失函數
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)#優化器for epoch in range(1000):#訓練迭代y_pred=model(x_data)loss=criterion(y_pred,y_data)print(epoch,loss.item())optimizer.zero_grad()#梯度清零loss.backward()#反向傳播optimizer.step()#計算梯度，梯度更新print('w =',model.linear.weight.item())
print('b =',model.linear.bias.item())x_test=torch.Tensor([4.0])
y_test=model(x_test)
print('y_pred =',y_test.data)

這篇文章可以幫助理解LinearModel的寫法

python類中super()_wanghua609的博客-CSDN博客

6. 邏輯回歸（Logistics Regression）

邏輯回歸主要用于分類問題，線性回歸的輸出值是連續空間
Classification Problem

類別之間沒有大小關系

分類問題的輸出是一個概率問題，為Ⅰ類的概率是多少，為Ⅱ類的概率是多少…
根據概率值的最大值判斷所屬類別。
在這里插入圖片描述

實際上計算的就是 y_hat=1 的概率。
要將輸出值映射到【0，1】，因為概率值是在【0，1】的。
Sigmoid函數也是一種飽和函數（輸入值x大于某個值后，輸出值y基本不變）。
sigmoid函數中最出名的函數就是Logistics函數，因此大多數書籍資料中將Logistics函數成為sigmoid函數。
σ（）就是sigmoid函數。
在這里插入圖片描述

計算分布之間的差異。
這個用于二分類的函數，叫做BCE函數。（CE：cross-entropy）
在這里插入圖片描述

在這里插入圖片描述

#torch.nn.Functional.sigmoid() use torch.sigmoid() instead.
import torch
import numpy as np
import matplotlib.pyplot as pltx_data=torch.Tensor([[1.0],[2.0],[3.0]])
y_data=torch.Tensor([[0],[0],[1]])class LogisticRegressionModel(torch.nn.Module):def __init__(self):super(LogisticRegressionModel,self).__init__()self.linear=torch.nn.Linear(1,1)def forward(self,x):y_pred=torch.sigmoid(self.linear(x))return y_predmodel=LogisticRegressionModel()criterion=torch.nn.BCELoss(reduction='sum')
#size_average=True
#size_average and reduce args will be deprecated, 
#please use reduction='mean' instead.
optimizer=torch.optim.SGD(model.parameters(),lr=0.01)for epoch in range(1000):y_pred=model(x_data)loss=criterion(y_pred,y_data)print(epoch,loss.item())optimizer.zero_grad()loss.backward()optimizer.step()x=np.linspace(0,10,200)
x_t=torch.Tensor(x).view((200,1))
y_t=model(x_t)
y=y_t.data.numpy()
plt.plot(x,y)
plt.plot([0,10],[0.5,0.5],c='r')
plt.xlabel('Hours')
plt.ylabel('Probability of Pass')
plt.grid()
plt.show()

在這里插入圖片描述

7. 處理多維特征的輸入（Multiple Dimension Input）

輸入值有多個特征
每一行成為Record，每一列叫做Feature（特征/字段），結構化的數據。
在這里插入圖片描述

每一個特征值都要與一個權重相乘，x看成一個向量，乘上w1到w8，標量轉置相乘做內積。
σ就是sigmoid函數。
計算轉化成向量化的運算，然后通過并行計算，通過GPU的能力，提高運算速度。
矩陣可以看作是空間變換的函數。
在這里插入圖片描述

從8個特征（8維）學到6個特征（6維）再到4個特征，最后到1個特征。
當然也可以直接從8個特征學到1個特征

import numpy as np
import torch
import matplotlib.pyplot as pltxy = np.loadtxt('diabetes.csv', delimiter=',', dtype=np.float32)
x_data = torch.from_numpy(xy[:, :-1]) 
y_data = torch.from_numpy(xy[:, [-1]]) class Model(torch.nn.Module):def __init__(self):super(Model, self).__init__()self.linear1 = torch.nn.Linear(8, 6)self.linear2 = torch.nn.Linear(6, 4)self.linear3 = torch.nn.Linear(4, 1)self.sigmoid = torch.nn.Sigmoid() def forward(self, x):x = self.sigmoid(self.linear1(x))x = self.sigmoid(self.linear2(x))x = self.sigmoid(self.linear3(x)) return xmodel = Model()criterion = torch.nn.BCELoss(reduction='mean')  
optimizer = torch.optim.SGD(model.parameters(), lr=0.1)epoch_list = []
loss_list = []for epoch in range(100000):y_pred = model(x_data)loss = criterion(y_pred, y_data)print(epoch, loss.item())epoch_list.append(epoch)loss_list.append(loss.item())optimizer.zero_grad()loss.backward()optimizer.step()plt.plot(epoch_list, loss_list)
plt.ylabel('loss')
plt.xlabel('epoch')
plt.show()