个新坑，系统学一遍深度学习好做毕设，能到河工大挺激动的，赶紧给刘二大人投自荐简历，但是已读不回，还是自己太菜了........不过已经到河工大了挺好的，梦校
第二讲
线性模型
image-20251125141224993
image-20251125141255872
可能x（输入）到y（答案）是一个线性模型，但是w或者其他的权重值不确定，所以机器随机选取权重数值，看看哪个公式得到的预期答案和真实答案偏差较小，就是训练的最优模型
评价方法MSE:（假设x到y的映射就是简单的y=x*w）
image-20251125141827375
（模型预期值-真实值）的平方再平均，就是MSE（均方误差）
还是假设y=w*x，找出最佳权重：
import numpy as np
import matplotlib.pyplot as plt
x_data=[1.0,2.0,3.0]
y_data=[3.0,6.0,9.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.1,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/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()
结果：
Figure_1
再试一个y=w*x+b的
# import numpy as np
# import matplotlib.pyplot as plt
#
# x_data=[1.0,2.0,3.0]
# y_data=[3.0,6.0,9.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.1,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/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()
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=[4.0,7.0,10.0]
def forward(x):
return x*w+b
def loss(x,y):
y_pred=forward(x)
return (y_pred-y)*(y_pred-y)
w_list=[]
b_list=[]
mse_list=[]
for w in np.arange(0.0,4.1,0.1):
for b in np.arange(0.0,4.1,0.1):
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/3)
w_list.append(w)
b_list.append(b)
mse_list.append(l_sum/3)
# 转换为numpy数组并重塑为网格格式
w_array = np.array(w_list)
b_array = np.array(b_list)
mse_array = np.array(mse_list)
# 创建网格数据
w_unique = np.unique(w_array)
b_unique = np.unique(b_array)
W, B = np.meshgrid(w_unique, b_unique)
MSE = mse_array.reshape(len(b_unique), len(w_unique))
# 绘图
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
# 使用plot_surface绘制曲面
surf = ax.plot_surface(W, B, MSE, cmap='viridis', alpha=0.8)
ax.set_xlabel('权重 w')
ax.set_ylabel('偏置 b')
ax.set_zlabel('MSE 损失')
ax.set_title('损失函数曲面: y = w*x + b')
# 添加颜色条
fig.colorbar(surf, ax=ax, shrink=0.5, aspect=5)
# 找到最小MSE的点
min_idx = np.argmin(mse_array)
best_w = w_array[min_idx]
best_b = b_array[min_idx]
best_mse = mse_array[min_idx]
# 标记最优点
ax.scatter([best_w], [best_b], [best_mse], color='red', s=100, label=f'最优: w={best_w:.1f}, b={best_b:.1f}')
ax.legend()
plt.show()
print(f"最优参数: w = {best_w:.1f}, b = {best_b:.1f}")
print(f"最小MSE: {best_mse:.4f}")
Figure_11251
坐标网格: W 和 B
值网格: MSE
最后的坐标网络,W和B也各自是二维数组，这样才能和MSE组成一个3维图
这段有点难理解，ai写了下
# 转换为numpy数组并重塑为网格格式
w_array = np.array(w_list)
b_array = np.array(b_list)
mse_array = np.array(mse_list)
# 创建网格数据
w_unique = np.unique(w_array)
b_unique = np.unique(b_array)
W, B = np.meshgrid(w_unique, b_unique)
MSE = mse_array.reshape(len(b_unique), len(w_unique))
最后几段分步详解
我们来一步步拆解每一行代码：
1. w_unique = np.unique(w_array)
w_array
这是一个一维的 NumPy 数组，里面存储了一系列的权重（weight）值。这些值可能有重复。
例如：w_array = [1, 2, 2, 3, 3, 3]
np.unique(): 这是 NumPy 的一个函数，它会返回输入数组中排序后的唯一值（即去重后的值）。
结果 w_unique
它将是
w_array
中所有不重复的权重值，并按从小到大排列。
例如：w_unique = [1, 2, 3]
这一步的目的是：找出所有不同的权重值，作为我们后续网格的 X 轴坐标。
2. b_unique = np.unique(b_array)
b_array
这是一个一维的 NumPy 数组，里面存储了一系列的偏置（bias）值。这些值也可能有重复。
例如：b_array = [4, 4, 5, 5, 6]
结果 b_unique
它将是
b_array
中所有不重复的偏置值，并按从小到大排列。
例如：b_unique = [4, 5, 6]
这一步的目的是：找出所有不同的偏置值，作为我们后续网格的 Y 轴坐标。
3. W, B = np.meshgrid(w_unique, b_unique)
np.meshgrid(): 这是最关键的一步。它接收两个一维数组，并返回两个二维数组。这两个二维数组共同构成了一个网格的坐标。
它会以第一个输入数组（w_unique）为列，以第二个输入数组（b_unique）为行，创建一个二维坐标网格。
结果 W 和 B:
W 是一个二维数组，它的每一行都是 w_unique。
B 是一个二维数组，它的每一列都是 b_unique。
举例说明：
输入: w_unique = [1, 2, 3], b_unique = [4, 5, 6]
输出:
W = [[1 2 3]
[1 2 3]
[1 2 3]]
B = [[4 4 4]
[5 5 5]
[6 6 6]]
这样，W 和 B 就共同定义了一个 3x3 的网格，每个网格点的坐标 (W[i][j], B[i][j]) 都对应一个 (权重, 偏置) 的组合。
这一步的目的是：创建一个完整的二维坐标网格，覆盖所有可能的(权重, 偏置)组合。
4. MSE = mse_array.reshape(len(b_unique), len(w_unique))
mse_array: 这是一个一维的 NumPy 数组，里面存储了与w_array和b_array中每一组(w, b)相对应的均方误差（Mean Squared Error）值。
它的长度必须与w_array和b_array相同。
例如，如果 w_array 和 b_array 都有 6 个元素，mse_array 也必须有 6 个元素。
len(b_unique) 和 len(w_unique): 它们分别是网格的行数和列数。在我们的例子中，行数是 3，列数是 3。
reshape(...): 这个函数将一维的mse_array转换成一个二维数组。
非常重要：reshape 函数默认是 ** 按行优先（C-style）** 的顺序重新排列元素的。这意味着，mse_array 中的元素必须是按照与 np.meshgrid 生成网格时相同的顺序排列的。
也就是说，mse_array 的元素顺序应该是先固定b，再遍历w。例如：[mse(w=1,b=4), mse(w=2,b=4), mse(w=3,b=4), mse(w=1,b=5), ...]
结果 MSE: 一个二维的 MSE 数组，它的形状是 (网格行数, 网格列数)，也就是 (len(b_unique), len(w_unique))。
这个二维数组MSE中的每一个元素MSE[i][j]，都对应于网格坐标(W[i][j], B[i][j])处的均方误差值。
这一步的目的是：将一维的 MSE 值数组，按照我们创建的网格形状，重新组织成一个二维的 MSE 矩阵。
总结：为什么要这么做？
假设你有一批数据点 (w, b, mse)，它们可能是这样散落的：
(1, 4, 0.1)
(2, 4, 0.2)
(3, 4, 0.15)
(1, 5, 0.3)
...
通过上述四行代码，你将这些散落的数据点，整理成了一个结构化的、可以直接用于绘图的二维数据结构：
坐标网格: W 和 B
值网格: MSE
这样，你就可以使用像 matplotlib 这样的库，轻松地绘制出一张关于 w 和 b 的 MSE 热力图（imshow(MSE)），或者一个 3D 曲
