梯度下降 on JasperSao的博客

梯度下降实践：从手写实现到 Scikit-Learn

Mon, 27 Jul 2026 00:00:00 +0800

1. 学习目标

这组实验主要解决以下问题：

从零实现线性回归的代价函数和梯度；
使用批量梯度下降训练模型；
判断梯度下降是否正在收敛；
选择合适的学习率；
使用 Z-score 标准化加快收敛；
通过特征工程实现多项式回归；
使用 Scikit-Learn 完成标准化、训练与预测。

2. 梯度下降的核心流程

线性回归模型：

$$f_{\mathbf{w},b}(\mathbf{x}) = \mathbf{w}\cdot\mathbf{x}+b$$

整个训练过程可以概括为：

输入训练数据 X、y
 ↓
使用当前 w、b 计算预测
 ↓
预测值减去真实值得到误差
 ↓
根据全部误差计算梯度
 ↓
沿梯度反方向更新 w、b
 ↓
重复，直到代价不再明显下降

参数更新规则：

$$w_j \leftarrow w_j-\alpha\frac{\partial J}{\partial w_j}$$$$b \leftarrow b-\alpha\frac{\partial J}{\partial b}$$

其中：

$\alpha$：学习率，决定每一步走多远；
梯度：代价函数上升最快的方向；
减去梯度：向代价下降的方向移动。

3. 实践一：从零实现一元线性回归

实验使用城市人口预测餐厅利润：

x_train：城市人口，单位为 10,000 人；
y_train：餐厅月利润，单位为 10,000 美元；
数据集共有 97 个样本。

一元线性回归模型：

$$f_{w,b}(x^{(i)})=wx^{(i)}+b$$

3.1 实现代价函数

平方误差代价函数：

$$J(w,b) = \frac{1}{2m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)^2$$

代码：

def compute_cost(x, y, w, b):
 m = x.shape[0]
 total_cost = 0.0

 for i in range(m):
 prediction = w * x[i] + b
 error = prediction - y[i]
 total_cost += error ** 2

 return total_cost / (2 * m)

这里除以 $2m$：

除以 $m$：计算所有样本的平均损失；
除以 2：求导后平方项产生的 2 可以抵消，使梯度公式更简洁。

3.2 实现梯度

梯度公式：

$$\frac{\partial J}{\partial w} = \frac{1}{m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)x^{(i)}$$$$\frac{\partial J}{\partial b} = \frac{1}{m} \sum_{i=0}^{m-1} \left( f_{w,b}(x^{(i)})-y^{(i)} \right)$$

代码：

def compute_gradient(x, y, w, b):
 m = x.shape[0]
 dj_dw = 0.0
 dj_db = 0.0

 for i in range(m):
 prediction = w * x[i] + b
 error = prediction - y[i]

 dj_dw += error * x[i]
 dj_db += error

 dj_dw /= m
 dj_db /= m

 return dj_dw, dj_db

dj_dw 多乘了一个 x[i]，因为 $w$ 是和输入 $x$ 相乘的参数；而 $b$ 只是直接相加，因此 dj_db 不需要乘 x[i]。

3.3 批量梯度下降

import copy
import math

def gradient_descent(
 x, y,
 w_in, b_in,
 cost_function,
 gradient_function,
 alpha,
 num_iters
):
 w = copy.deepcopy(w_in)
 b = b_in
 J_history = []

 for i in range(num_iters):
 dj_dw, dj_db = gradient_function(x, y, w, b)

 # 必须使用同一次迭代计算出的梯度同步更新
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 if i < 100_000:
 J_history.append(cost_function(x, y, w, b))

 if i % math.ceil(num_iters / 10) == 0:
 print(
 f"Iteration {i:4d}: "
 f"Cost {J_history[-1]:8.2f}"
 )

 return w, b, J_history

实验参数：

initial_w = 0.0
initial_b = 0.0
iterations = 1500
alpha = 0.01

w, b, J_history = gradient_descent(
 x_train,
 y_train,
 initial_w,
 initial_b,
 compute_cost,
 compute_gradient,
 alpha,
 iterations
)

实验结果大约为：

w = 1.1664
b = -3.6303

预测利润：

profit_35k = (3.5 * w + b) * 10_000
profit_70k = (7.0 * w + b) * 10_000

print(profit_35k) # 约 4519.77 美元
print(profit_70k) # 约 45342.45 美元

这里的"批量"表示：

每轮使用全部 $m$ 个训练样本计算平均梯度，然后更新一次参数。

4. 多变量梯度下降

假设训练数据形状为：

X：(m, n)
y：(m,)
w：(n,)
b：标量

其中：

$m$：训练样本数量；
$n$：每个样本的特征数量。

预测：

y_hat = X @ w + b

误差：

errors = y_hat - y

向量化代价：

def compute_cost(X, y, w, b):
 errors = X @ w + b - y
 return np.sum(errors ** 2) / (2 * X.shape[0])

向量化梯度：

def compute_gradient(X, y, w, b):
 m = X.shape[0]
 errors = X @ w + b - y

 dj_dw = X.T @ errors / m
 dj_db = np.sum(errors) / m

 return dj_dw, dj_db

形状变化：

X.T ：(n, m)
errors ：(m,)
X.T @ errors ：(n,)
dj_dw ：(n,)
dj_db ：标量

最终得到的 dj_dw 恰好包含 $n$ 个梯度，对应 $w$ 中的 $n$ 个参数。

5. 学习率实验

在未缩放的房价数据中，不同学习率会产生不同表现。

$\alpha=9.9\times10^{-7}$

学习率过大：

参数更新越过最低点；
代价不断增加；
模型发散。

$\alpha=9\times10^{-7}$

学习率稍小：

代价持续下降；
参数仍会在最低点两侧震荡；
最终能够收敛。

$\alpha=1\times10^{-7}$

学习率更小：

参数较平稳地靠近最低点；
基本没有明显震荡；
但收敛速度更慢。

因此：

学习率太大 → 震荡或发散
学习率太小 → 稳定但很慢
学习率合适 → 快速且稳定下降

6. 为什么需要特征缩放？

房价数据包含以下特征：

面积：几百到几千
卧室：0 到 5
楼层：1 到 3
房龄：数十年

假设：

$$f(\mathbf{x})=w_1x_1+w_2x_2+b$$

如果 $x_1$ 是房屋面积，最大接近 2000；$x_2$ 是卧室数量，最大只有 5。

对于面积 2000、5 间卧室的房屋，一组合适的参数可能是：

$$w_1=0.1,\quad w_2=50,\quad b=50$$

预测为：

$$0.1\times2000+50\times5+50=500$$

单位是千美元，即 50 万美元。

可以看到：

数值范围大的特征，参数通常较小；
数值范围小的特征，参数通常较大。

这会让代价函数的等高线变得非常狭长：

未缩放：
梯度下降在狭长峡谷两侧反复震荡

缩放后：
等高线更接近圆形
梯度下降更直接地靠近最低点

特征缩放通常不会改变模型能够达到的最优结果，主要作用是让训练更快、更稳定。

7. 三种特征缩放方法

7.1 除以最大值

$$x_j' = \frac{x_j}{\max(x_j)}$$

例如：

面积范围：300～2000
缩放后：0.15～1

卧室范围：0～5
缩放后：0～1

7.2 均值归一化

$$x_j' = \frac{x_j-\mu_j} {\max(x_j)-\min(x_j)}$$

减去均值后，数据会以 0 为中心。

7.3 Z-score 标准化

$$x_j' = \frac{x_j-\mu_j}{\sigma_j}$$

其中：

$$\mu_j = \frac{1}{m} \sum_{i=0}^{m-1}x_j^{(i)}$$$$\sigma_j = \sqrt{ \frac{1}{m} \sum_{i=0}^{m-1} \left(x_j^{(i)}-\mu_j\right)^2 }$$

处理后，每个特征通常具有：

均值接近 0；
标准差接近 1；
各特征具有相似的数值范围。

NumPy 实现：

def zscore_normalize_features(X):
 mu = np.mean(X, axis=0)
 sigma = np.std(X, axis=0)
 X_norm = (X - mu) / sigma

 return X_norm, mu, sigma

使用：

X_norm, X_mu, X_sigma = zscore_normalize_features(X_train)

实验中，未缩放数据只能使用约 1e-7 的学习率；经过 Z-score 标准化后，可以从 0.1 左右开始尝试，收敛速度明显加快。

8. 预测新数据时的关键规则

标准化训练数据后，必须保存训练集的均值和标准差。

预测面积 1200 平方英尺、3 间卧室、1 层、房龄 40 年的房屋：

x_house = np.array([1200, 3, 1, 40])

x_house_norm = (
 x_house - X_mu
) / X_sigma

price = x_house_norm @ w_norm + b_norm

不能对新样本重新计算均值和标准差。

错误：

# 不要这样做
new_mu = np.mean(x_house)
new_sigma = np.std(x_house)

正确原则：

训练集：计算并保存 mu、sigma
验证集：使用训练集的 mu、sigma
测试集：使用训练集的 mu、sigma
新数据：使用训练集的 mu、sigma

否则训练和预测使用的不是同一个坐标系。

9. 如何判断梯度下降是否收敛？

记录每次更新后的代价：

J_history.append(
 compute_cost(X, y, w, b)
)

绘制学习曲线：

plt.plot(J_history)
plt.xlabel("Iteration")
plt.ylabel("Cost J")
plt.show()

正常曲线：

J
│\
│ \
│ \____
│ ───
└──────────── 迭代次数

如果代价持续下降并逐渐变平，说明梯度下降正在收敛。

也可以使用自动收敛条件：

$$\left| J^{(t)}-J^{(t-1)} \right|<\epsilon$$

例如：

if abs(J_history[-1] - J_history[-2]) < 1e-3:
 break

但实际学习中，直接观察学习曲线通常更直观。

10. 梯度下降调试方法

10.1 代价不断增加

可能原因：

学习率太大；
参数更新误写成了加号；
梯度公式实现错误。

错误：

w = w + alpha * dj_dw

正确：

w = w - alpha * dj_dw
b = b - alpha * dj_db

10.2 使用很小的学习率进行测试

把 alpha 设置得非常小。

如果代码正确，代价函数理论上应该缓慢下降。如果很小的学习率下代价仍然增加，通常说明代码存在错误。

需要注意：

很小的学习率适合调试，但不一定适合正式训练，因为它可能导致收敛非常慢。

10.3 尝试一系列学习率

可以按大约 3 倍的间隔尝试：

选择能够让代价快速、持续下降的较大学习率。

11. 特征工程

特征工程是利用业务知识，从已有特征构造更有意义的新特征。

例如：

$x_1$：土地宽度；
$x_2$：土地深度。

可以构造土地面积：

$$x_3=x_1x_2$$

代码：

area = width * depth

模型变为：

$$f(\mathbf{x}) = w_1x_1+w_2x_2+w_3x_3+b$$

相比只使用宽度和深度，面积可能与房价具有更直接的关系。

12. 多项式回归

假设真实数据为：

$$y=1+x^2$$

如果只使用原始特征 $x$，线性回归只能拟合直线：

$$f(x)=wx+b$$

可以构造平方特征：

x = np.arange(0, 20, 1)
y = 1 + x ** 2

X = (x ** 2).reshape(-1, 1)

模型变为：

$$f(x)=w_1x^2+b$$

虽然它对原始变量 $x$ 是非线性的，但对参数 $w_1,b$ 仍然是线性的，所以仍可以使用线性回归的训练方法。

不知道应该使用几次项时，可以构造多个候选特征：

X = np.c_[
 x,
 x ** 2,
 x ** 3
]

对应模型：

$$f(x) = w_1x+w_2x^2+w_3x^3+b$$

多项式特征必须注意尺度

如果：

x：1～1000

那么：

x²：1～1,000,000
x³：1～1,000,000,000

尺度差异会非常大，因此应进行标准化：

X = np.c_[x, x ** 2, x ** 3]
X_norm, mu, sigma = zscore_normalize_features(X)

特征缩放后，可以使用更大的学习率，训练速度会明显提高。

13. 使用 Scikit-Learn

Scikit-Learn 可以直接完成标准化和梯度下降回归。

import numpy as np

from sklearn.linear_model import SGDRegressor
from sklearn.preprocessing import StandardScaler

13.1 标准化训练数据

scaler = StandardScaler()
X_norm = scaler.fit_transform(X_train)

fit_transform() 包含两步：

fit → 从训练集计算均值和标准差
transform → 使用这些统计量转换数据

13.2 创建并训练模型

sgdr = SGDRegressor(
 max_iter=1000,
 random_state=0
)

sgdr.fit(X_norm, y_train)

查看训练信息：

print(sgdr.n_iter_) # 实际迭代轮数
print(sgdr.t_) # 权重更新次数

查看参数：

w_norm = sgdr.coef_
b_norm = sgdr.intercept_

print(w_norm)
print(b_norm)

这些参数对应的是标准化后的输入数据，不能直接按原始面积、卧室数量的单位解释。

13.3 进行预测

y_pred_sgd = sgdr.predict(X_norm)

也可以手动计算：

y_pred_manual = X_norm @ w_norm + b_norm

检查两种结果：

np.allclose(
 y_pred_sgd,
 y_pred_manual
)

不要使用：

(y_pred_sgd == y_pred_manual).all()

浮点数运算可能存在很小的舍入误差，应使用 np.allclose()。

13.4 预测新房屋

x_house = np.array([
 [1200, 3, 1, 40]
])

x_house_norm = scaler.transform(x_house)
price = sgdr.predict(x_house_norm)

print(price)

对新数据只能调用：

scaler.transform()

不能再次调用：

scaler.fit_transform()

因为重新 fit 会改变标准化使用的均值和标准差。

13.5 SGD 与批量梯度下降的区别

手写实验使用的是批量梯度下降：

使用全部训练样本
→ 计算一次平均梯度
→ 更新一次参数

SGDRegressor 使用随机梯度下降：

依次使用单个样本或小批次
→ 更频繁地更新参数

两者都在尝试降低代价函数，但参数更新方式不同。

14. Notebook 中的 NameError

实验中出现：

NameError: name 'plt' is not defined
NameError: name 'load_house_data' is not defined
NameError: name 'run_gradient_descent' is not defined

这通常不是模型或公式的问题，而是依赖单元格没有运行。

Notebook 中的变量只存在于当前内核的内存里。重启内核、断线或者跳过前面的单元格，都会导致变量不存在。

正确运行顺序：

1. 运行 import 单元格
2. 运行辅助函数单元格
3. 加载训练数据
4. 标准化数据
5. 训练模型
6. 计算预测
7. 绘制图像

如果 Notebook 状态混乱，可以使用：

Restart Kernel and Run All

15. 高频易错点

w 和 b 必须同步更新 同一轮参数更新必须使用更新前计算出的同一组梯度。
更新公式使用减号 梯度指向代价上升方向，因此需要减去梯度。
特征尺度差异会拖慢收敛 面积、卧室数量、楼层、房龄应进行缩放。
预测新数据必须复用训练集统计量 不能为新样本重新计算均值和标准差。
多项式特征更需要缩放 $x,x^2,x^3$ 的数值范围可能相差多个数量级。
浮点数不要直接使用 == 比较 使用 np.isclose() 或 np.allclose()。
权重较大不一定代表特征更重要 权重大小受到特征尺度影响，也不代表因果关系。
SGDRegressor 不是批量梯度下降 它使用随机梯度下降，只是优化目标与线性回归相似。

16. 一页实践模板

import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import SGDRegressor

# 1. 准备数据
X_train, y_train = load_house_data()

# 2. 标准化
scaler = StandardScaler()
X_norm = scaler.fit_transform(X_train)

# 3. 训练
model = SGDRegressor(
 max_iter=1000,
 random_state=0
)
model.fit(X_norm, y_train)

# 4. 训练集预测
y_pred = model.predict(X_norm)

# 5. 新数据预测
x_new = np.array([
 [1200, 3, 1, 40]
])
x_new_norm = scaler.transform(x_new)
prediction = model.predict(x_new_norm)

# 6. 检查手动计算
manual_prediction = (
 X_norm @ model.coef_
 + model.intercept_
)

print(np.allclose(
 y_pred,
 manual_prediction
))

整组实验最重要的主线是：

准备训练数据
→ 检查特征尺度
→ 使用训练集统计量标准化
→ 选择学习率
→ 运行梯度下降
→ 观察代价是否持续下降
→ 保存参数和标准化器
→ 用相同的转换处理新数据
→ 进行预测

一句话总结：

梯度下降负责寻找参数，特征缩放负责让寻找过程更快、更稳定，学习曲线负责判断训练是否正常，特征工程负责让线性模型表达更复杂的关系。

多元线性回归与 NumPy 向量化

Sun, 26 Jul 2026 00:00:00 +0800

1. 多元线性回归

1.1 从单特征到多特征

单变量线性回归只使用一个特征：

$$ f_{w,b}(x)=wx+b $$

多元线性回归同时使用多个特征。例如预测房价时，可以使用：

$x_0$：房屋面积
$x_1$：卧室数量
$x_2$：楼层数
$x_3$：房屋年龄

若共有 $n$ 个特征，则一个样本写成：

$$ \mathbf{x}^{(i)} = \left[x_0^{(i)},x_1^{(i)},\ldots,x_{n-1}^{(i)}\right] $$

其中：

$i$ 表示第几个训练样本；
$j$ 表示第几个特征；
$x_j^{(i)}$ 表示第 $i$ 个样本的第 $j$ 个特征。

数学教材常从 1 开始编号；Python 和本实验从 0 开始编号。

1.2 模型

多元线性回归模型为：

$$ f_{\mathbf{w},b}(\mathbf{x}) =w_0x_0+w_1x_1+\cdots+w_{n-1}x_{n-1}+b $$

使用向量点积可以简写为：

$$ \boxed{f_{\mathbf{w},b}(\mathbf{x})=\mathbf{w}\cdot\mathbf{x}+b} $$

其中：

$\mathbf{w}=[w_0,w_1,\ldots,w_{n-1}]$ 是长度为 $n$ 的参数向量；
$b$ 是标量偏置；
$\mathbf{w}\cdot\mathbf{x}=\sum_{j=0}^{n-1}w_jx_j$。

例如：

$$ f(\mathbf{x})=0.1x_0+4x_1+10x_2-2x_3+80 $$

如果房价单位为千美元，可解释为：面积每增加 1 平方英尺，预测价格增加 0.1 千美元；房龄每增加 1 年，预测价格减少 2 千美元。参数表达的是“其他特征保持不变时”的线性影响。

“多元线性回归”指多个输入特征。它不同于统计学中具有多个输出变量的“多变量回归”。

2. 训练数据的矩阵表示

若有 $m$ 个训练样本，每个样本有 $n$ 个特征，则输入数据组成矩阵：

$$ \mathbf{X}\in\mathbb{R}^{m\times n} $$

每一行是一个训练样本；
每一列是一种特征；
X[i, j] 是第 i 个样本的第 j 个特征；
X[i] 或 X[i, :] 是第 i 个样本的特征向量。

实验数据：

import numpy as np

X_train = np.array([
 [2104, 5, 1, 45],
 [1416, 3, 2, 40],
 [ 852, 2, 1, 35]
])
y_train = np.array([460, 232, 178])

其形状为：

X_train.shape # (3, 4)：3 个样本、4 个特征
y_train.shape # (3,)：3 个目标值

参数示例：

w_init = np.array([
 0.39133535,
 18.75376741,
 -53.36032453,
 -26.42131618
])
b_init = 785.1811367994083

w_init.shape # (4,)

3. 用 NumPy 实现预测

3.1 循环版本

def predict_single_loop(x, w, b):
 p = 0.0
 for j in range(x.shape[0]):
 p += x[j] * w[j]
 return p + b

3.2 向量化版本

def predict(x, w, b):
 return np.dot(x, w) + b

使用方式：

x_vec = X_train[0]
prediction = predict(x_vec, w_init, b_init)

x_vec 和 w_init 的形状都是 (4,)，np.dot(x_vec, w_init) 返回一个标量。

向量化版本的优势：

代码更短、更容易阅读；
底层使用经过优化的数值计算程序；
可利用 CPU 的并行指令及专门的线性代数库；
对大规模数据通常远快于 Python 层的显式循环。

向量化并不意味着“所有运算一定在一个时钟周期完成”，而是将循环交给优化后的底层实现，从而减少 Python 解释器开销并更充分地利用硬件。

4. 代价函数

单个样本的误差为：

$$ e^{(i)} =f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} $$

平方误差代价函数：

$$ \boxed{ J(\mathbf{w},b) =\frac{1}{2m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right)^2 } $$

Python 实现：

def compute_cost(X, y, w, b):
 m = X.shape[0]
 cost = 0.0

 for i in range(m):
 prediction = np.dot(X[i], w) + b
 cost += (prediction - y[i]) ** 2

 return cost / (2 * m)

进一步向量化：

def compute_cost_vectorized(X, y, w, b):
 errors = X @ w + b - y
 return np.sum(errors ** 2) / (2 * X.shape[0])

其中 @ 在这里执行矩阵与向量的乘法：

X : (m, n)
w : (n,)
X @ w : (m,)
y : (m,)

5. 多元线性回归的梯度

对每个参数 $w_j$：

$$ \boxed{ \frac{\partial J}{\partial w_j} =\frac{1}{m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right)x_j^{(i)} } $$

对偏置 $b$：

$$ \boxed{ \frac{\partial J}{\partial b} =\frac{1}{m} \sum_{i=0}^{m-1} \left( f_{\mathbf{w},b}(\mathbf{x}^{(i)})-y^{(i)} \right) } $$

循环实现：

def compute_gradient(X, y, w, b):
 m, n = X.shape
 dj_dw = np.zeros(n)
 dj_db = 0.0

 for i in range(m):
 error = np.dot(X[i], w) + b - y[i]
 for j in range(n):
 dj_dw[j] += error * X[i, j]
 dj_db += error

 return dj_db / m, dj_dw / m

完全向量化实现：

def compute_gradient_vectorized(X, y, w, b):
 m = X.shape[0]
 errors = X @ w + b - y
 dj_dw = X.T @ errors / m
 dj_db = np.sum(errors) / m
 return dj_db, dj_dw

形状检查：

errors : (m,)
X.T : (n, m)
X.T @ errors : (n,)
dj_dw : (n,)
dj_db : scalar

6. 批量梯度下降

更新规则：

$$ w_j \leftarrow w_j-\alpha\frac{\partial J}{\partial w_j} $$$$ b \leftarrow b-\alpha\frac{\partial J}{\partial b} $$

向量形式：

$$ \boxed{ \mathbf{w} \leftarrow \mathbf{w}-\alpha\nabla_{\mathbf{w}}J } $$

实现：

import copy
import math

def gradient_descent(
 X, y, w_in, b_in,
 cost_function, gradient_function,
 alpha, num_iters
):
 w = copy.deepcopy(w_in)
 b = b_in
 J_history = []

 for i in range(num_iters):
 dj_db, dj_dw = gradient_function(X, y, w, b)

 # 使用同一次迭代计算出的梯度，同时更新所有参数
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 if i < 100_000:
 J_history.append(cost_function(X, y, w, b))

 if i % math.ceil(num_iters / 10) == 0:
 print(f"Iteration {i:4d}: Cost {J_history[-1]:8.2f}")

 return w, b, J_history

实验设置：

initial_w = np.zeros_like(w_init)
initial_b = 0.0
iterations = 1000
alpha = 5.0e-7

w_final, b_final, J_hist = gradient_descent(
 X_train,
 y_train,
 initial_w,
 initial_b,
 compute_cost,
 compute_gradient,
 alpha,
 iterations
)

该实验的学习率很小，而且不同特征的数值范围差异大，因此 1000 次迭代后的预测仍不够准确。后续通常会通过特征缩放改善收敛速度。

7. NumPy 向量基础

7.1 一维数组

本课程用一维 NumPy 数组表示向量：

a = np.array([1, 2, 3, 4])
a.shape # (4,)

常用创建方式：

np.zeros(4) # 4 个 0
np.random.random_sample(4) # 4 个 [0, 1) 随机数
np.arange(4.0) # [0., 1., 2., 3.]
np.random.rand(4) # 4 个 [0, 1) 随机数

(4,) 表示含 4 个元素的一维数组，不是二维行矩阵 (1, 4)，也不是二维列矩阵 (4, 1)。

7.2 索引

a = np.arange(10)

a[2] # 第 3 个元素
a[-1] # 最后一个元素

访问一维数组的单个元素通常得到 NumPy 标量。

7.3 切片

格式：

a[start:stop:step]

stop 不包含在结果中。

a[2:7:1] # 索引 2、3、4、5、6
a[2:7:2] # 索引 2、4、6
a[3:] # 从索引 3 到末尾
a[:3] # 索引 0、1、2
a[:] # 全部元素，得到一个视图

7.4 常用向量运算

a = np.array([1, 2, 3, 4])

-a # 逐元素取负
np.sum(a) # 元素求和，返回标量
np.mean(a) # 均值，返回标量
a ** 2 # 逐元素平方
5 * a # 每个元素乘以 5

7.5 逐元素运算与点积

a = np.array([ 1, 2, 3, 4])
b = np.array([-1, 4, 3, 2])

a * b # 逐元素乘法，结果仍是向量
np.dot(a, b) # 点积：逐元素相乘后求和，结果是标量
a @ b # 对两个一维向量，同样是点积

手动实现点积：

def my_dot(a, b):
 result = 0.0
 for i in range(a.shape[0]):
 result += a[i] * b[i]
 return result

两个向量做逐元素运算或点积时，形状必须兼容。

7.6 向量性能示例

import time

size = 10_000_000
a = np.random.rand(size)
b = np.random.rand(size)

start = time.time()
vectorized_result = np.dot(a, b)
vectorized_time = time.time() - start

start = time.time()
loop_result = my_dot(a, b)
loop_time = time.time() - start

两种方法应给出近似相同的结果。浮点数运算顺序不同，可能造成极小的舍入误差，因此比较时宜使用：

np.isclose(vectorized_result, loop_result)

8. NumPy 矩阵基础

8.1 创建矩阵

二维数组使用形状元组：

np.zeros((1, 5)) # shape: (1, 5)
np.zeros((2, 1)) # shape: (2, 1)
np.random.random_sample((3, 4))

手动创建：

a = np.array([
 [5],
 [4],
 [3]
])

a.shape # (3, 1)

8.2 reshape

a = np.arange(6).reshape(3, 2)

结果：

[[0, 1],
 [2, 3],
 [4, 5]]

也可以写：

a = np.arange(6).reshape(-1, 2)

-1 表示让 NumPy 根据元素总数和另一个维度自动推断该维度。

8.3 矩阵索引

a[2, 0] # 第 3 行第 1 列的标量
a[2] # 第 3 行，返回 shape 为 (n,) 的一维数组
a[2, :] # 同上
a[:, 0] # 第 1 列，返回一维数组

8.4 矩阵切片

a = np.arange(20).reshape(-1, 10)

a[0, 2:7] # 第 1 行中索引 2 到 6
a[:, 2:7] # 所有行、索引 2 到 6 的列
a[:, :] # 全部行和列
a[1, :] # 第 2 行，结果是一维数组

9. 广播（Broadcasting）

广播允许 NumPy 在形状兼容时，将较小的数组“扩展”到较大的数组上执行逐元素运算。

最简单的例子是标量与向量：

a = np.array([1, 2, 3, 4])
a + 10
# [11, 12, 13, 14]

在线性模型中：

X @ w + b

X @ w 的形状是 (m,)，标量 b 会广播到每个预测值上。

判断广播是否兼容时，从形状的最后一个维度向前比较；对应维度相等，或其中一个为 1，通常即可广播。

广播很方便，但也可能隐藏形状错误。机器学习代码中应经常打印或断言 .shape。

10. 正态方程与梯度下降

线性回归还可以通过线性代数方法直接求解参数，常称为正态方程法。

特点：

无需像梯度下降那样反复迭代；
主要用于线性回归，不能自然推广到逻辑回归、神经网络等模型；
当特征数很大时，直接求解可能较慢；
实际项目中通常交给成熟的数值计算或机器学习库处理，不应手动计算矩阵逆。

本课程重点学习梯度下降，因为它能推广到更多机器学习模型。

11. 高频易错点

数学下标与 Python 下标不同

数学讲解可能从 1 开始；NumPy 从 0 开始。
(n,) 不等于 (n, 1)

前者是一维数组，后者是二维列矩阵。
a * b 不等于 np.dot(a, b)

前者逐元素相乘，后者对一维向量返回点积。
切片右端不包含

a[2:7] 包含索引 2 到 6。
更新梯度下降参数时要同步

同一轮中的 w 和 b 都应使用更新前的同一组梯度。
特征尺度会影响梯度下降速度

面积可能是上千，楼层数可能只有 1～3；尺度差异大会使代价函数狭长，导致收敛缓慢。
学习率过大或过小都不好

过大可能使代价震荡或发散；过小则收敛很慢。
浮点数结果不要直接用 == 比较

使用 np.isclose 或 np.allclose。
课程原文中的翻译错误

向量 [1,2,3,4] 的 shape (4,) 是一维，不是“二维向量”；向量的元素个数常称为长度或维数，而 NumPy 数组的 ndim 表示轴的数量。

12. 一页速记

# 预测
y_hat = X @ w + b

# 误差
errors = y_hat - y

# 代价
J = np.sum(errors ** 2) / (2 * m)

# 梯度
dj_dw = X.T @ errors / m
dj_db = np.sum(errors) / m

# 更新
w = w - alpha * dj_dw
b = b - alpha * dj_db

对应的核心公式：

$$ \boxed{ \hat{\mathbf{y}}=\mathbf{X}\mathbf{w}+b } $$$$ \boxed{ J(\mathbf{w},b)=\frac{1}{2m}\|\hat{\mathbf{y}}-\mathbf{y}\|_2^2 } $$$$ \boxed{ \nabla_{\mathbf{w}}J =\frac{1}{m}\mathbf{X}^{T}(\hat{\mathbf{y}}-\mathbf{y}) } $$$$ \boxed{ \frac{\partial J}{\partial b} =\frac{1}{m}\sum_{i=0}^{m-1}(\hat y^{(i)}-y^{(i)}) } $$

掌握这一条主线即可：

样本矩阵 X
→ 点积得到预测
→ 预测减目标得到误差
→ 由误差计算代价和梯度
→ 用梯度下降更新 w、b

机器学习基础：用梯度下降法训练模型

Sat, 25 Jul 2026 00:00:00 +0800

一、学习目标

梯度下降如何更新参数 $w$ 和 $b$？
导数项为什么能指引下降方向？
学习率 $\alpha$ 应该如何理解和选择？
如何用梯度下降训练一元线性回归模型？

二、梯度下降算法

梯度下降通过不断调整模型参数，使成本函数 $J(w,b)$ 尽可能小。

参数更新公式为：

$$w := w - \alpha \frac{\partial J(w,b)}{\partial w}$$$$b := b - \alpha \frac{\partial J(w,b)}{\partial b}$$

不断重复以上更新，直到算法收敛。

符号含义

符号	含义
$w, b$	模型参数
$J(w,b)$	成本函数，衡量预测误差
$\alpha$	学习率，控制每次更新的步长
$\frac{\partial J}{\partial w}$	成本函数相对于 $w$ 的偏导数
$\frac{\partial J}{\partial b}$	成本函数相对于 $b$ 的偏导数
$:=$	赋值，用右侧结果更新左侧变量

赋值与相等的区别

$w := w - \alpha \frac{\partial J}{\partial w}$ 表示“计算右边的结果，然后把结果存入 $w$”，而不是断言左右两边在数学上永远相等。

在 Python 中，= 是赋值，== 是相等性判断。

三、为什么必须同时更新 $w$ 和 $b$

梯度下降要求两个参数基于同一组旧参数进行更新。

正确做法：

temp_w = w - alpha * dj_dw # dj_dw 和 dj_db 都根据更新前的 w, b 计算
temp_b = b - alpha * dj_db

w = temp_w
b = temp_b

不正确的顺序更新：

temp_w = w - alpha * dj_dw
w = temp_w # w 已被更新

temp_b = b - alpha * dj_db # 此时计算用的是新的 w，不是旧的
b = temp_b

问题在于：计算新 $b$ 时，$w$ 已经被更新，两个参数不再基于同一个旧状态进行计算。标准梯度下降所指的是同步更新。

四、导数项的直观含义

为了理解导数，暂时只考虑一个参数：

$$w := w - \alpha \frac{dJ(w)}{dw}$$

导数表示成本曲线在当前位置的斜率。

导数为正

$$\frac{dJ}{dw} > 0 \implies w_{\text{new}} = w - \text{正数}$$

$w$ 变小，在图像上向左移动。当位于最低点右侧时，向左移动能够降低成本。

导数为负

$$\frac{dJ}{dw} < 0 \implies w_{\text{new}} = w - \alpha(\text{负数}) = w + \text{正数}$$

$w$ 变大，在图像上向右移动。当位于最低点左侧时，向右移动能够降低成本。

导数为零

在局部最小值处，$\frac{dJ}{dw} = 0$，于是 $w_{\text{new}} = w$，参数保持不变。梯度下降到达最低点后会自然停止移动。

核心直觉

梯度下降之所以使用“减去导数”，是因为导数指向函数增长最快的方向，而导数的反方向能够降低成本。

五、学习率 $\alpha$

学习率控制每次参数更新的步长，通常取较小的正数，例如 $\alpha = 0.01$。

学习率太小

每次更新的步长很小
成本通常仍会下降，但需要大量迭代
训练速度非常慢

学习率太大

参数可能跨过最低点
成本可能反而增加
参数可能在最低点两侧来回震荡
算法可能无法收敛，甚至发散

为什么固定学习率也能收敛

当参数逐渐接近最低点时，成本函数的斜率会越来越小：$\left|\frac{dJ}{dw}\right| \to 0$

即使学习率 $\alpha$ 保持不变，实际更新量 $\alpha \frac{dJ}{dw}$ 也会自然变小。因此梯度下降通常表现为：

离最低点较远时步长较大
接近最低点时步长逐渐减小
最终停留在最低点附近

六、一元线性回归模型

模型为：

$$f_{w,b}(x) = wx + b$$

其中 $x$ 是输入特征（如房屋面积），$f_{w,b}(x)$ 是预测值（如预测房价），$w$ 是斜率，$b$ 是截距。

七、平方误差成本函数

使用 $m$ 个训练样本时，成本函数为：

$$J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)^2$$

其中 $x^{(i)}$ 是第 $i$ 个样本的输入，$y^{(i)}$ 是真实值，$m$ 是训练样本数量。

前面的 $\frac{1}{2}$ 是为了在求导时抵消平方项产生的系数 2，使梯度公式更简洁。

八、线性回归的梯度公式

成本函数相对于 $w$ 的偏导数：

$$\frac{\partial J(w,b)}{\partial w} = \frac{1}{m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right) x^{(i)}$$

成本函数相对于 $b$ 的偏导数：

$$\frac{\partial J(w,b)}{\partial b} = \frac{1}{m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)$$

两者的区别：$w$ 的导数末尾需要乘 $x^{(i)}$，$b$ 的导数不需要。

九、完整的梯度下降算法

每轮迭代先计算：

$$d_w = \frac{1}{m} \sum_{i=1}^{m} \left(wx^{(i)} + b - y^{(i)}\right) x^{(i)}$$$$d_b = \frac{1}{m} \sum_{i=1}^{m} \left(wx^{(i)} + b - y^{(i)}\right)$$

然后同步更新：

$$w := w - \alpha \, d_w$$$$b := b - \alpha \, d_b$$

重复以上过程，直到成本不再明显下降，或者参数变化已经非常小。

十、收敛、局部最小值与全局最小值

收敛

梯度下降“收敛”通常表示：成本函数不再明显下降，$w$ 和 $b$ 的变化越来越小，参数已经接近某个最小值。

局部最小值 vs 全局最小值

局部最小值：某个点比附近其他点都低，但不一定是整个函数的最低点
全局最小值：在所有可能的参数取值中，成本函数值最低的点

线性回归的优势

线性回归的平方误差成本函数是凸函数（碗形函数），具有以下性质：

只有一个全局最小值
不存在多个不同的局部最小值
只要学习率选择合理，梯度下降就能收敛到全局最小值

十一、批量梯度下降

上述算法属于批量梯度下降（Batch Gradient Descent）。“批量”表示每次更新参数时都使用全部 $m$ 个训练样本（$\sum_{i=1}^{m}$），即每轮更新都会遍历整个训练集。

其他梯度下降方法可能每次只使用一个训练样本或一小批训练样本，但当前的一元线性回归使用的是完整训练集。

十二、Python 实现

计算梯度

def compute_gradient(x, y, w, b):
 m = x.shape[0]
 dj_dw = 0
 dj_db = 0

 for i in range(m):
 f_wb = w * x[i] + b # 预测值
 error = f_wb - y[i] # 预测误差

 dj_dw += error * x[i] # w 的梯度需要乘 x[i]
 dj_db += error # b 的梯度不需要乘 x[i]

 dj_dw /= m
 dj_db /= m

 return dj_dw, dj_db

计算成本

def compute_cost(x, y, w, b):
 m = x.shape[0]
 cost = 0

 for i in range(m):
 f_wb = w * x[i] + b
 cost += (f_wb - y[i]) ** 2

 return cost / (2 * m)

梯度下降主函数

def gradient_descent(x, y, w_in, b_in, alpha, num_iters,
 cost_function, gradient_function):
 J_history = []
 p_history = []

 w = w_in
 b = b_in

 for i in range(num_iters):
 # 先计算两个梯度（基于当前的 w, b）
 dj_dw, dj_db = gradient_function(x, y, w, b)

 # 同步更新参数
 w = w - alpha * dj_dw
 b = b - alpha * dj_db

 # 保存代价和参数（用于可视化）
 if i < 100000:
 J_history.append(cost_function(x, y, w, b))
 p_history.append([w, b])

 # 定期输出训练过程
 if i % math.ceil(num_iters / 10) == 0:
 print(f"Iteration {i:4}: Cost {J_history[-1]:0.2e} "
 f"w: {w:0.3e}, b: {b:0.5e}")

 return w, b, J_history, p_history

返回值：训练后的 w、b，每次迭代的代价 J_history，每次迭代的参数 p_history。

十三、运行实验

训练数据

x_train = np.array([1.0, 2.0]) # 房屋面积（千平方英尺）
y_train = np.array([300.0, 500.0]) # 房屋售价（千美元）

训练参数

w_init = 0
b_init = 0
iterations = 10000
alpha = 1.0e-2

运行

w_final, b_final, J_hist, p_hist = gradient_descent(
 x_train, y_train, w_init, b_init, alpha, iterations,
 compute_cost, compute_gradient
)

最终结果约为 $w \approx 199.99$，$b \approx 100.01$，即模型为 $f(x) = 200x + 100$。

梯度下降的收敛特点

成功运行时可以观察到：

代价在开始阶段迅速下降
dj_dw 和 dj_db 的绝对值逐渐减小
越接近最低点，梯度越小
梯度变小后，参数更新速度也会变慢
代价应持续下降并逐渐稳定

虽然学习率 $\alpha$ 保持不变，但实际更新量 = $\alpha \times$ 梯度，梯度变小时更新幅度自然变小。

十四、可视化

代价变化曲线

fig, (ax1, ax2) = plt.subplots(1, 2, constrained_layout=True, figsize=(12, 4))

ax1.plot(J_hist[:100]) # 训练初期：代价下降很快
ax2.plot(1000 + np.arange(len(J_hist[1000:])), J_hist[1000:]) # 训练后期：下降较慢

ax1.set_title("Cost vs. iteration (start)")
ax2.set_title("Cost vs. iteration (end)")
ax1.set_ylabel("Cost")
ax2.set_ylabel("Cost")
ax1.set_xlabel("Iteration step")
ax2.set_xlabel("Iteration step")
plt.show()

分开绘制是因为训练初期和后期下降速度差异大，用不同范围可以更清楚地观察变化。

梯度下降路径（等高线图）

fig, ax = plt.subplots(1, 1, figsize=(12, 6))
plt_contour_wgrad(x_train, y_train, p_hist, ax)
plt.show()

等高线代表不同的代价值，箭头代表参数 $(w, b)$ 的更新路径。可以观察到：参数不断向最低点移动，开始时梯度大步幅也大，接近最低点时梯度变小步幅缩短。

十五、模型预测

训练完成后，使用 $\hat{y} = w_{\text{final}} x + b_{\text{final}}$ 进行预测：

print(f"1000 sqft: {w_final * 1.0 + b_final:.1f} Thousand dollars")
print(f"1200 sqft: {w_final * 1.2 + b_final:.1f} Thousand dollars")
print(f"2000 sqft: {w_final * 2.0 + b_final:.1f} Thousand dollars")

房屋面积	预测售价
1000 平方英尺	300 千美元
1200 平方英尺	340 千美元
2000 平方英尺	500 千美元

虽然 1200 平方英尺不在训练数据中，模型仍可以根据学到的线性关系进行预测。

十六、学习率的影响

合适的学习率

代价持续下降，参数逐渐靠近最优值，算法最终收敛

学习率过小

更新步幅很小，算法能够稳定收敛，但训练速度较慢

学习率过大

参数可能跨过最低点，$w$ 和 $b$ 在正负之间振荡
梯度符号反复变化，参数绝对值越来越大
代价不断上升，算法最终发散

判断学习率过大的典型信号：

代价不降反升
参数绝对值越来越大
梯度不断改变符号
参数在最低点两侧大幅振荡

例如将学习率改为 0.8，只跑 10 次迭代就能观察到发散过程。

十七、常见错误与检查方法

没有同步更新参数：应先计算新 $w$ 和新 $b$，再统一赋值
学习率过小：成本下降但极其缓慢 → 适当增大 $\alpha$
学习率过大：成本上下震荡或越来越大 → 减小 $\alpha$
导数公式漏乘 $x^{(i)}$：计算 $w$ 的梯度时必须包含 $\text{error} \times x^{(i)}$，$b$ 的梯度只有误差项
没有观察成本变化：训练过程中应定期计算 $J(w,b)$，正常情况下成本应总体持续下降

十八、核心知识总结

梯度下降的目标是通过调整参数来最小化成本函数
学习率 $\alpha$ 控制每次更新的步长
导数的符号决定参数移动方向，大小影响移动幅度
$w$ 和 $b$ 必须基于同一组旧值同步更新
学习率太小导致收敛缓慢，太大导致震荡或发散
接近最低点时导数自然变小，更新步长也会变小
线性回归的平方误差成本函数是凸函数，只有一个全局最小值
批量梯度下降每次更新都会使用全部训练样本
训练完成后，使用 $f_{w,b}(x) = wx + b$ 对新数据进行预测

机器学习基础：线性回归模型

Tue, 21 Jul 2026 00:00:00 +0800

线性回归是机器学习里最适合入门的模型之一：它足够简单，可以把输入、预测、参数、成本函数这些核心概念讲清楚；它也足够重要，因为后续更复杂的模型训练，仍然离不开这些基本思想。本篇整理 Coursera 机器学习课程中的线性回归内容，从房价预测案例出发，梳理模型函数、训练数据、成本函数和梯度下降之间的关系。

线性回归的基本概念

线性回归（Linear Regression） 是一种监督学习模型，通过为数据拟合一条直线来预测连续数值。

以房价预测为例：

输入 x：房屋面积
输出 y：房屋价格
模型：一条尽可能贴合训练数据的直线

可将模型表示为：

$$\hat{y} = f_{w,b}(x) = wx + b$$

其中：

$x$：输入特征，例如房屋面积
$\hat{y}$：模型预测的房屋价格
$w$：直线的斜率
$b$：直线的截距

因为只有一个输入特征，这种模型称为单变量线性回归（Univariate Linear Regression）。“单变量”表示模型只有一个输入变量，而不是只有一个参数，该模型仍然包含两个参数 $w$ 和 $b$。

以后还可以使用多个输入特征预测房价，例如房屋面积、卧室数量、浴室数量、房屋年龄、地理位置等，属于多变量或多特征线性回归。

训练集与符号约定

训练集

用于训练模型的数据称为训练集（Training Set）。

房价预测的训练数据来自美国波特兰市，包含：

房屋面积，单位为平方英尺
房屋售价，单位为千美元

同一组数据可以通过两种方式表示：

散点图：横轴为房屋面积，纵轴为房屋价格，每个数据点对应一套已售房屋。如果训练集有 47 套房屋，图中就有 47 个数据点。

数据表：

房屋面积（平方英尺）	房屋价格（千美元）
2104	400
…	…

表格中的每一行对应一个训练示例，也对应散点图中的一个数据点。例如面积 2104 平方英尺，售价 400 千美元，即 400,000 美元。

符号约定

符号	含义	房价示例
$x$	输入特征（Feature）	房屋面积
$y$	真实值（Label / Target Variable）	房屋实际售价
$\hat{y}$	模型预测值	预测房价
$f_{w,b}(x)$	参数为 $w, b$ 的模型对 $x$ 的预测	$\hat{y} = wx + b$
$m$	训练样本总数	47
$(x^{(i)}, y^{(i)})$	第 $i$ 个训练样本	$(2104, 400)$

一个完整的训练示例由输入和正确输出组成 $(x, y)$。第 $i$ 个训练示例表示为 $(x^{(i)}, y^{(i)})$，其中 $x^{(i)}$ 是第 $i$ 个样本的输入，$y^{(i)}$ 是第 $i$ 个样本的正确输出。

需要特别注意：$x^{(2)}$ 表示“第二个训练示例的输入”，不是 $x$ 的平方。括号中的上标只是训练样本的编号。

为什么称为监督学习

训练集中同时提供了输入（房屋面积）和正确输出（房屋实际售价）。每套已售房屋的数据都相当于向模型提供一个带答案的学习示例，因此这种学习方式称为“监督学习”。

基本流程：

收集包含输入和正确输出的数据
使用这些数据训练模型
模型学习输入与输出之间的规律
将新输入交给模型
模型预测相应的输出

参数 $w$ 和 $b$ 的作用

斜率 $w$

$w$ 决定直线的倾斜程度：

w > 0：直线向右上方倾斜，x 增大时预测值增大
w = 0：直线是水平的，预测值不随 x 变化
w < 0：直线向右下方倾斜，x 增大时预测值减小

在房价问题中，$w$ 可以理解为房屋面积每增加一个单位，预测价格增加多少。$w$ 也称为权重或系数。

截距 $b$

$b$ 决定直线与纵轴的交点。当 $x = 0$ 时：

$$f(0) = b$$

因此 $b$ 是模型在输入为零时的预测值。

示例

当 $w = 0, b = 1.5$ 时：

$$f(x) = 1.5$$

无论输入是多少，预测结果始终为 1.5。

当 $w = 0.5, b = 0$ 时：

$$f(x) = 0.5x$$

直线斜率为 0.5，经过原点。

当 $w = 0.5, b = 1$ 时：

$$f(x) = 0.5x + 1$$

直线斜率仍为 0.5，但与纵轴相交于 1。

假设 $f(x) = 0.1x + 50$，当房屋面积为 1250 平方英尺时：

$$\hat{y} = 0.1 \times 1250 + 50 = 175$$

预测价格为 175,000 美元。

不同的 $w$ 和 $b$ 会形成不同的直线，也会产生不同的预测结果。

学习算法的任务

训练线性回归模型的核心任务，是根据训练数据选择合适的 $w$ 和 $b$，使直线尽可能贴近数据点。

完整过程可以表示为：

$$\{(x^{(i)}, y^{(i)})\}_{i=1}^{m} \longrightarrow \text{学习算法} \longrightarrow w, b \longrightarrow f_{w,b}(x)$$

也就是说：

将训练数据交给学习算法
学习算法寻找合适的 $w$ 和 $b$
得到模型 $f_{w,b}(x) = wx + b$
用模型预测新输入对应的 $\hat{y}$

客户的房屋尚未出售，因此其真实价格不在训练集中。模型需要先从已售房屋的数据中学习，再预测这套房屋的价格。

$y$ 与 $\hat{y}$ 的区别

$y$：实际目标值

$y$ 表示训练数据中的真实答案。例如 $y = 400$ 表示某套房屋的实际售价为 400 千美元。

$\hat{y}$：预测值

$\hat{y}$ 读作 “y hat”，表示模型对 $y$ 的估计：

$$\hat{y} = f_{w,b}(x) = wx + b$$

预测值不一定等于实际值：

$$\hat{y} \neq y$$

例如，模型预测某套房屋售价为 220,000 美元，但只有房屋真正售出后，才能知道真实售价 $y$。

需要明确区分：

$$\boxed{y = \text{真实值}, \qquad \hat{y} = \text{预测值}}$$

成本函数

为什么需要成本函数

不同的 $w$ 和 $b$ 会产生不同的直线。成本函数的作用是：

衡量一组 $w, b$ 所产生的直线，对训练数据拟合得有多好。

成本越小，通常说明预测值越接近真实值。

预测误差

对于第 $i$ 个训练样本 $(x^{(i)}, y^{(i)})$，模型预测值为：

$$\hat{y}^{(i)} = f_{w,b}(x^{(i)})$$

预测误差为：

$$\hat{y}^{(i)} - y^{(i)} = \text{预测值} - \text{真实值}$$

例如，模型预测价格为 280，真实价格为 300：

$$280 - 300 = -20$$

误差为 $-20$，表示模型低估了价格。

平方误差成本函数

线性回归常用的成本函数是平方误差成本函数：

$$\boxed{J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(f_{w,b}(x^{(i)}) - y^{(i)}\right)^2}$$

也可以写成：

$$J(w,b) = \frac{1}{2m} \sum_{i=1}^{m} \left(\hat{y}^{(i)} - y^{(i)}\right)^2$$

计算过程：

计算每个样本的预测值
用预测值减去真实值
将误差平方
把所有平方误差相加
除以 $2m$

为什么误差要平方

如果直接将误差相加，正负误差可能互相抵消：

$$(-20) + 20 = 0$$

但模型实际产生了两次误差。平方以后：

$$(-20)^2 + 20^2 = 800$$

因此：

所有误差都会变成非负数
较大的误差会受到更明显的惩罚
成本不会因为正负抵消而错误地变小

为什么除以 $m$ 和 $2$

除以 $m$：$m$ 是训练样本数量。除以 $m$ 相当于计算平均误差，使成本不会仅仅因为训练数据变多而自动增大。

再除以 $2$：主要是为了让后续求导和梯度下降的公式更简洁。是否除以 $2$ 不会改变最佳参数的位置。

成本函数的直观示例

为了方便观察，暂时令 $b = 0$，模型简化为：

$$f_w(x) = wx$$

训练集为：

$$(1, 1), \quad (2, 2), \quad (3, 3)$$

当 $w = 1$

预测值为 1, 2, 3，全部等于真实值：

$$J(1) = 0$$

模型完美拟合训练数据。

当 $w = 0.5$

预测值为 0.5, 1, 1.5。平方误差为：

$$(0.5-1)^2 + (1-2)^2 + (1.5-3)^2 = 0.25 + 1 + 2.25 = 3.5$$$$J(0.5) = \frac{3.5}{2 \times 3} \approx 0.58$$

当 $w = 0$

所有预测值都是 0：

$$J(0) = \frac{1^2 + 2^2 + 3^2}{6} = \frac{14}{6} \approx 2.33$$

当 $w = -0.5$

直线方向与数据趋势相反：

$$J(-0.5) = 5.25$$

结果对比

$w$	$J(w)$	拟合情况
$-0.5$	$5.25$	很差
$0$	$2.33$	较差
$0.5$	$0.58$	较好
$1$	$0$	最佳

这个例子中的最佳参数是 $w = 1$。

模型函数与成本函数的区别

两者容易混淆，需要明确区分：

模型函数 $f_{w,b}(x) = wx + b$

输入是 $x$（特征），输出是预测值 $\hat{y}$
模型图的坐标轴：横轴 $x$（房屋面积），纵轴 $y$ 或 $\hat{y}$（价格）
回答的问题：“这套房子预测多少钱？”

成本函数 $J(w,b)$

输入是模型参数 $w, b$，输出是模型的成本
成本图的坐标轴是参数和成本，而不是房屋面积与价格
回答的问题：“这组模型参数整体表现有多差？”

成本函数的图像

只有参数 $w$ 时（$b = 0$）

成本函数只有一个参数 $J(w)$，通常呈 U 形曲线：

成本 J
 ↑
 | \ /
 | \_____/
 +------------→ w
 最小值

最低点对应成本最小的 $w$。

同时使用 $w$ 和 $b$ 时

完整模型包含两个参数 $J(w,b)$，这时成本函数是一个三维曲面，通常类似碗形：

一个方向代表 $w$
一个方向代表 $b$
曲面的高度代表成本 $J(w,b)$

碗底对应成本函数的最小值，也就是最佳的 $w, b$。

等高线图

三维成本函数也可以用二维的等高线图表示。每条椭圆线表示成本相同的一组 $w, b$：

$$J(w_1, b_1) = J(w_2, b_2)$$

可以把等高线图理解成从正上方观察碗形曲面：

外层椭圆：成本通常较高
越靠近中心：成本通常越低
最内层椭圆中心：成本最小值附近

不同的 $w, b$ 即使成本相同，也可能对应不同的模型直线。

训练目标与梯度下降

训练目标

线性回归最终需要解决的问题是：

$$\boxed{\min_{w,b} J(w,b)}$$

也就是找到一组 $w, b$，使成本函数尽可能小。

完整逻辑：

选择 w, b
 ↓
得到直线 f(x) = wx + b
 ↓
计算每个样本的预测误差
 ↓
计算成本 J(w,b)
 ↓
不断调整 w, b
 ↓
找到成本最小的参数

为什么需要梯度下降

理论上可以手动尝试很多组 $w, b$，计算每一组参数的成本，再选择成本最低的一组。但这种方法效率非常低，当模型参数很多时，几乎无法手动完成。

因此需要一种能够自动调整参数、寻找成本函数最小值的算法：

$$\boxed{\text{梯度下降（Gradient Descent）}}$$

梯度下降不仅用于线性回归，也是训练神经网络和许多复杂人工智能模型的基础算法。

成本函数的代码实现

def compute_cost(x, y, w, b):
 m = x.shape[0] # 训练样本数量

 cost_sum = 0
 for i in range(m):
 f_wb = w * x[i] + b # 第 i 个样本的预测值
 cost = (f_wb - y[i]) ** 2 # 平方误差
 cost_sum = cost_sum + cost # 累加

 total_cost = cost_sum / (2 * m) # 计算平均成本
 return total_cost

逐步理解：

m = x.shape[0]：获取训练样本数量
cost_sum = 0：准备变量，累计所有样本的平方误差
for i in range(m)：逐个处理训练样本
f_wb = w * x[i] + b：计算预测值 $\hat{y}^{(i)} = wx^{(i)} + b$
cost = (f_wb - y[i]) ** 2：计算预测值和真实价格的平方误差
cost_sum = cost_sum + cost：把当前样本的误差加入总误差
total_cost = cost_sum / (2 * m)：按照成本函数公式计算最终成本

对应公式：

$$J(w,b) = \frac{1}{2m} \sum_{i=0}^{m-1} \left(wx^{(i)} + b - y^{(i)}\right)^2$$

验证示例

import numpy as np

x_train = np.array([1.0, 2.0])
y_train = np.array([300.0, 500.0])

w = 200
b = 100

两个预测分别是：

$$200 \times 1 + 100 = 300$$$$200 \times 2 + 100 = 500$$

预测值与真实值完全相同：

compute_cost(x_train, y_train, 200, 100) # 结果：0.0

这说明 $w = 200, b = 100$ 能完美拟合这两个数据点。

关键理解：

compute_cost() 只负责评价一组 $w, b$ 好不好
成本越小，模型对训练数据的拟合通常越好
两个点可以被一条直线完美穿过，因此成本可以为零；多个不共线的数据点无法全部完美命中，因此最低成本通常大于零

为什么先学线性模型

现实中的数据关系不一定是直线，也可能是曲线、抛物线或更复杂的非线性关系。但线性模型具有以下优点：

数学形式简单
容易理解和实现
便于观察模型参数的作用
是学习复杂机器学习模型的基础

因此，课程首先从线性函数入手，之后再扩展到非线性模型。