企业官网建设流程全解析

线性回归：

线性回归就是找一条直线，让这条直线贴合数据，用来预测新的数据

成本函数：

成本函数就是用来衡量这条直线画的好不好的一个数字。误差越大，成本越高，画的越差。

梯度下降：

梯度下降是一种方法，通过不断调整参数，让成本函数越来越小，最后找到最好的直线

从何而来：

线性回归：因为显示数据中很多都是线性关系，我们想用一个简单模型去描述它。

代码：

import numpy as np
import matplotlib.pyplot as plt

# 生成模拟数据：房子的面积和价格
x = np.array([?,? ?,? ?, ], dtype=float) # 面积
y = np.array([?,?,?,?,?], dtype=float) # 价格

# 线性回归：y = w * x + b
# 用最小二乘法直接求解析解
n = len(x)

# 求斜率 w
w = (n * np.sum(x * y) - np.sum(x) * np.sum(y)) / (n * np.sum(x**2) - np.sum(x)**2)

# 求截距 b
b = (np.sum(y) - w * np.sum(x)) / n

print(f"斜率 w = {w}")
print(f"截距 b = {b}")
print(f"预测函数：y = {w:.2f} * x + {b:.2f}")

# 画图
plt.scatter(x, y, color='blue', label='真实数据')
plt.plot(x, w * x + b, color='red', label='预测直线')
plt.xlabel('面积')
plt.ylabel('价格')
plt.title('线性回归')
plt.legend()
plt.grid(True)
plt.show()

成本函数：因为我们需要一个标准，来比较不同直线的优劣。

代码：

import numpy as np
import matplotlib.pyplot as plt

# 模拟数据
x = np.array([?,?,?,?,?], dtype=float)
y = np.array([?,?,?,?,?], dtype=float)

def compute_cost(x, y, w, b):
"""
计算均方误差成本函数
J(w, b) = (1 / 2n) * Σ(wx + b - y)²
"""
n = len(x)
predictions = w * x + b
cost = (1 / (2 * n)) * np.sum((predictions - y) ** 2)
return cost

# 测试几组 w 和 b，看看成本函数的变化
print("当 w = 0, b = 0 时，成本 =", compute_cost(x, y, 0, 0))
print("当 w = 1, b = 0 时，成本 =", compute_cost(x, y, 1, 0))
print("当 w = 2, b = 1 时，成本 =", compute_cost(x, y, 2, 1))

# 画出成本函数随 w 变化的曲线
w_values = np.linspace(0, 4, 100)
costs = [compute_cost(x, y, w, 0) for w in w_values]

plt.plot(w_values, costs)
plt.xlabel('w')
plt.ylabel('成本 J(w)')
plt.title('成本函数曲线')
plt.grid(True)
plt.show()

梯度下降：因为很多问题没有解析解，需要一个能一步步逼近最优解的方法。

代码：

import numpy as np
import matplotlib.pyplot as plt

# 模拟数据
x = np.array([?,?,?,?,?], dtype=float)
y = np.array([?,?,?,?,?], dtype=float)

def gradient_descent(x, y, w_init, b_init, learning_rate, iterations):
"""
用梯度下降找最优的 w 和 b
"""
w = w_init
b = b_init
n = len(x)
cost_history = [] # 记录每次迭代的成本

for i in range(iterations):
# 预测值
predictions = w * x + b

# 计算梯度
dw = (1 / n) * np.sum((predictions - y) * x)
db = (1 / n) * np.sum(predictions - y)

# 更新参数
w = w - learning_rate * dw
b = b - learning_rate * db

# 计算并记录成本
cost = (1 / (2 * n)) * np.sum((predictions - y) ** 2)
cost_history.append(cost)

return w, b, cost_history

# 初始参数
w_init = 0
b_init = 0
learning_rate = 0.01
iterations = 1000

# 执行梯度下降
w_final, b_final, cost_history = gradient_descent(x, y, w_init, b_init, learning_rate, iterations)

print(f"最终的 w = {w_final}")
print(f"最终的 b = {b_final}")
print(f"预测函数：y = {w_final:.2f} * x + {b_final:.2f}")

# 画成本函数随迭代次数的变化
plt.plot(cost_history)
plt.xlabel('迭代次数')
plt.ylabel('成本 J(w, b)')
plt.title('梯度下降过程')
plt.grid(True)
plt.show()

线性回归：预测

成本函数：判断好坏

梯度下降：找到最优参数