【深度学习】PyTorch深度学习笔记02-线性模型

1. 监督学习

2. 数据集的划分

3. 平均平方误差MSE

4. 线性模型Linear Model - y = x * w

用穷举法确定线性模型的参数

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):
    y_pred = forward(x)
    return (y_pred - y) * (y_pred - y)

w_list = []
mse_list = []

for w in np.arange(0.0, 4.0, 0.1):
    print('w=', w)
    l_sum = 0
    for 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_val
        print('\t', x_val, y_val, y_pred_val, loss_val)
    print('MSE=', l_sum / len(x_data))  
    w_list.append(w)
    mse_list.append(l_sum / len(x_data))

plt.plot(w_list, mse_list)
plt.ylabel('Loss')
plt.xlabel('w')
plt.show()

详细过程

    本课程的主要任务是构建一个完整的线性模型：
        导入numpy和matplotlib库；
        导入数据 x_data 和 y_data;
        定义前向传播函数:
            forward：输出是预测值y_hat
        定义损失函数：
            loss：平方误差
        创建两个空列表，后面绘图的时候要用：
            分别是横轴的w_list和纵轴的mse_list
        开始计算（这里没有训练的概念，只是单纯的计算每一个数据对应的预测值，然后让预测值跟真实y值求MSE）：
            外层循环：
                在0.0~4.0之间均匀取点，步长0.1，作为n个横坐标自变量，用w表示；
            内层循环：核心计算内容
                从数据集中，按数据对取出自变量x_val和真实值y_val；
                先调用forward函数，计算y的预测值 w*x
                调用loss函数，计算单个数据的平方误差；
                累加损失；
                打印想要看到的数值；
                在外层循环中，把计算的结果放进之前的空列表，用于绘图；
    在获得了打印所需的数据列表之后，模式化地打印图像：

运行结果

ps:

visdom库可用于可视化

np.meshgrid()可用于绘制三维图

5. 线性模型Linear Model - y = x * w + b

有w，b两个参数，穷举最小值

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

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

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

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

w_list = np.arange(0.0, 4.1, 0.1)
b_list = np.arange(-2.0, 2.1, 0.1)

# np.zeros(): 返回给定维度的全零数组; mse_matrix用于存储不同 w,b 组合下的均方误差损失
mse_matrix = np.zeros((len(w_list), len(b_list)))

for i, w in enumerate(w_list):
    for j, b in enumerate(b_list):
        l_sum = 0
        for x_val, y_val in zip(x_data, y_data):
            l_sum += loss(x_val, y_val, w, b)
        mse_matrix[i, j] = l_sum / len(x_data)

W, B = np.meshgrid(w_list, b_list)
fig = plt.figure('Linear Model Cost Value')
ax = fig.add_subplot(111, projection='3d')
ax.plot_surface(W, B, mse_matrix.T, cmap='viridis')
ax.set_xlabel('w')
ax.set_ylabel('b')
ax.set_zlabel('loss')
plt.show()

可以得出，穷举法算法的时间复杂度 随着参数的个数增大 而变得很大，因此使用穷举法找到最优解，很不合理。

原文地址：https://blog.csdn.net/weixin_52553215/article/details/140299336

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！