lesson1-lesson4 pytorch深度学习实战（刘二老师）

rookiexxj01

已于 2024-03-14 19:28:55 修改

阅读量356

点赞数 6

文章标签：深度学习 pytorch 人工智能

于 2024-03-14 18:59:54 首次发布

本文链接：https://blog.csdn.net/rookiexxj/article/details/136719051

版权

文章详细介绍了使用Python进行前馈神经网络的构建，包括单层和多层模型，以及如何利用MSELoss和随机梯度下降(SGD)进行训练和优化。每个示例展示了从基本的前馈函数到损失函数计算，再到权重更新的过程。

摘要由CSDN通过智能技术生成

LESSON1

import numpy as np
import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def forward(x): # 计算前馈结果的函数
    return x * w

def loss(x, y, w):
    y_hat = forward(x)
    return (y - y_hat)*(y - y_hat)
w_list = []
mse_data = []
for w in np.arange(0.0, 4.0, 0.1):
    sum = 0
    w_list.append(w)
    for x_std, y_std in zip(x_data, y_data):
        sum += loss(x_std, y_std, w)
    mse_data.append(sum/3)
plt.plot(w_list, mse_data)
plt.ylabel('loss')
plt.xlabel('w')
fig=plt.gcf()  # 一定要放在plt.show之前的最后两句
plt.savefig('./11.png')
plt.show()

在这里插入图片描述

import numpy as np 
import matplotlib.pyplot as plt
from matplotlib import cm
from mpl_toolkits.mplot3d import Axes3D

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def forward(x, w, b):
    return w * x + b

def loss(x, y, w, b):
    y_hat = forward(x, w, b)
    return (y - y_hat) * (y - y_hat)

w_list = []
mse_data = []
b_list = []

for w in np.arange(0.0, 4.0, 0.1):
    w_list.append(w)
    for b in np.arange(0, 4, 0.1):
        if len(b_list) < 40:
            b_list.append(b)
        sum_loss = 0
        for x_std, y_std in zip(x_data, y_data):
            sum_loss += loss(x_std, y_std, w, b)
        mse_data.append(sum_loss/3)

fig = plt.figure(figsize=(8, 6))
ax = fig.add_subplot(111, projection='3d')
X, Y = np.meshgrid(w_list, b_list)
Z = np.array(mse_data).reshape(X.shape)

surf = ax.plot_surface(X, Y, Z, cmap=cm.viridis, alpha=0.8)
ax.set_zlim(-5, 20)
ax.set_xlabel('w')
ax.set_ylabel('b')
ax.set_zlabel('MSE')

plt.show()

在这里插入图片描述

LESSON2

import numpy as np
import matplotlib.pyplot as plt

w = 1 
x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

def forward(x, w):
    return w * x

def loss(x, y, w):
    y_hat = forward(x, w)
    return (y - y_hat)**2

def gradient(x, y, w):
    return 2 * x * (x * w - y)

for epoch in range(100):
    for x, y in zip(x_data, y_data):
        gradient_hred = gradient(x, y, w)
        w = w - 0.1 * gradient_hred
        loss_hred = loss(x, y ,w)
        print(f"now {epoch} {loss_hred} {w}")

now 15 1.050959940980693e-27 2.0000000000000324
now 15 1.7749370367472766e-28 2.0000000000000067
now 15 2.279808016088724e-28 1.999999999999995
now 16 1.597443333072549e-29 1.999999999999996
now 16 3.1554436208840472e-30 1.9999999999999991
now 16 7.099748146989106e-30 2.000000000000001
now 17 7.888609052210118e-31 2.000000000000001
now 17 0.0 2.0
now 17 0.0 2.0
now 18 0.0 2.0
now 18 0.0 2.0
now 18 0.0 2.0

LESSON3

import torch

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w = torch.Tensor([1.0])
w.requires_grad = True

def forward(x):
    return x * w

def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) ** 2

print("predict (before training)", 4, forward(4).item())
for epoch in range(100):
    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.1 * w.grad.data
        w.grad.data.zero_()
        print('progress:', epoch, l.item())

progress: 7 2.2737367544323206e-13
grad: 2.0 4.0 3.814697265625e-06
progress: 7 9.094947017729282e-13
grad: 3.0 6.0 0.0
progress: 7 0.0
grad: 1.0 2.0 0.0
progress: 8 0.0

# 这个作业一开始遇到了一些问题，学习率取得太大导致过拟合了
import torch
import matplotlib.pyplot as plt

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w1 = torch.Tensor([1.0])
w1.requires_grad = True
w2 = torch.Tensor([1.0])
w2.requires_grad = True
b = torch.Tensor([0.0])
b.requires_grad = True

def forward(x):
    return (x**2)*w1 + x*w2 + b

def loss(x, y):
    y_pred = forward(x)
    return (y_pred - y) ** 2

l_list = []
e_list = []

print("predict (before training)", 4, forward(4).item())

for epoch in range(100):
    e_list.append(epoch)
    l_list.append(l.item())
    for x, y in zip(x_data, y_data):
        #计算损失函数
        l = loss(x,y)
        l.backward()
        print('\tgrad:', x, y, w1.grad.item())
        print('\tgrad:', x, y, w2.grad.item())
        print('\tgrad:', x, y, b.grad.item())
        #更新数据
        w1.data = w1.data - 0.01 * w1.grad.data
        w2.data = w2.data - 0.01 * w2.grad.data
        b.data = b.data - 0.01 * b.grad.data
        #数据清零
        w1.grad.data.zero_()
        w2.grad.data.zero_()
        b.grad.data.zero_()
plt.plot(e_list, l_list)
plt.xlabel("epoch")
plt.ylabel("loss")
plt.show()

在这里插入图片描述

LESSON4

# MSELoss  和  SGD
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):
    def __init__(self):
        super(LinearModel, self).__init__()
        self.linear = torch.nn.Linear(1, 1)

    def forward(self, x):
        y_pred = self.linear(x)
        return y_pred
model = LinearModel()

criterion = torch.nn.MSELoss(size_average=True)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)

for epoch in range(1000):
    y_pred = model(x_data) # pytorch大类中用call函数自动调用forward
    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)

w = 1.9656314849853516
b = 0.07808531075716019
998 0.0008748557302169502
w = 1.9657137393951416
b = 0.07789839804172516
999 0.0008706683875061572
w = 1.9657957553863525
b = 0.07771193236112595