DAY2 线性回归
#DAY2 线性回归
import numpy as np
import matplotlib.pyplot as plt
# 1. 生成模拟数据
np.random.seed(42)
X = 2 * np.random.rand(100, 1) # 100个随机点
y = 4 + 3 * X + np.random.randn(100, 1) # y = 4 + 3x + 噪声
# 2. 初始化参数 学习力设置为0.01会导致数值爆炸现象
#w = np.random.randn(1)
#b = np.random.randn(1)
w=0
b=0
learning_rate = 0.001
epochs = 6000 # 迭代次数,可改变值观察loss和w b拟合情况
# 3. 梯度下降法
for epoch in range(epochs):
y_pred = w * X + b
error = y_pred - y
loss = (error ** 2).mean()
# 计算梯度
dw = (2 * X.T @ error).mean()
db = 2 * error.mean()
# 更新参数
w -= learning_rate * dw
b -= learning_rate * db
# 每100次迭代打印一次损失
if epoch % 100 == 0:
print(f"Epoch {epoch}, Loss: {loss}, w:{w}, b:{b}")
# 4. 可视化结果
plt.scatter(X, y, color='blue', label='Data')
plt.plot(X, w * X + b, color='red', label='Regression Line')
plt.legend()
plt.show()
DAY3 神经网络基本架构与前向传播
import numpy as np
# 1. 初始化网络参数
input_size = 2 # 输入层节点数
hidden_size = 3 # 隐藏层节点数
output_size = 1 # 输出层节点数（回归任务）
# 随机初始化权重和偏置
np.random.seed(42)
W1 = np.random.randn(input_size, hidden_size) # 输入层到隐藏层的权重
b1 = np.random.randn(1, hidden_size) # 隐藏层的偏置
W2 = np.random.randn(hidden_size, output_size) # 隐藏层到输出层的权重
b2 = np.random.randn(1, output_size) # 输出层的偏置
# 2. 定义激活函数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def relu(x):
return np.maximum(0, x)
# 3. 输入数据
X = np.array([[0.1, 0.2], [0.4, 0.5], [0.9, 0.8]]) # 3个样本，每个样本有2个特征
# 4. 前向传播过程
# 第一层：输入层到隐藏层
z1 = np.dot(X, W1) + b1 # 线性变换
a1 = relu(z1) # ReLU 激活
# 第二层：隐藏层到输出层
z2 = np.dot(a1, W2) + b2 # 线性变换
a2 = sigmoid(z2) # Sigmoid 激活（回归任务可以改为其他激活函数）
# 5. 输出结果
print("Output of the neural network:")
print(a2)
DAY4 反向传播与梯度下降优化
import numpy as np
# 1. 初始化网络参数
input_size = 2 # 输入层节点数
hidden_size = 3 # 隐藏层节点数
output_size = 1 # 输出层节点数（回归任务）
# 随机初始化权重和偏置
np.random.seed(42)
W1 = np.random.randn(input_size, hidden_size) # 输入层到隐藏层的权重
b1 = np.random.randn(1, hidden_size) # 隐藏层的偏置
W2 = np.random.randn(hidden_size, output_size) # 隐藏层到输出层的权重
b2 = np.random.randn(1, output_size) # 输出层的偏置
# 2. 定义激活函数和其导数
def sigmoid(x):
return 1 / (1 + np.exp(-x))
def sigmoid_derivative(x):
return x * (1 - x)
def relu(x):
return np.maximum(0, x)
def relu_derivative(x):
return (x > 0).astype(float)
# 3. 输入数据
X = np.array([[0.1, 0.2], [0.4, 0.5], [0.9, 0.8]]) # 3个样本，每个样本有2个特征
y = np.array([[0], [1], [1]]) # 目标输出
# 4. 前向传播
def forward_propagation(X, W1, b1, W2, b2):
z1 = np.dot(X, W1) + b1
a1 = relu(z1) # 隐藏层激活
z2 = np.dot(a1, W2) + b2
a2 = sigmoid(z2) # 输出层激活
return a1, a2
# 5. 反向传播
def backpropagation(X, y, a1, a2, W1, W2, b1, b2, learning_rate=0.1):
# 计算输出层的误差
error_output = a2 - y
#dW2 = np.dot(a1.T, error_output * sigmoid_derivative(a2))
dW2 = a1.T @ (error_output * sigmoid_derivative(a2))/len(error_output)
#print(np.dot(a1.T, error_output * sigmoid_derivative(a2)) == a1.T @ (error_output * sigmoid_derivative(a2)))
#db2 = np.sum(error_output * sigmoid_derivative(a2), axis=0, keepdims=True)
db2 = np.mean(error_output * sigmoid_derivative(a2))
# 计算隐藏层的误差
error_hidden = np.dot(error_output * sigmoid_derivative(a2), W2.T) * relu_derivative(a1)
dW1 = np.dot(X.T, error_hidden)
db1 = np.sum(error_hidden, axis=0, keepdims=True)
# 更新权重和偏置
W1 -= learning_rate * dW1
b1 -= learning_rate * db1
W2 -= learning_rate * dW2
b2 -= learning_rate * db2
return W1, b1, W2, b2
# 6. 训练模型
epochs = 2000
for epoch in range(epochs):
# 前向传播
a1, a2 = forward_propagation(X, W1, b1, W2, b2)
# 反向传播
W1, b1, W2, b2 = backpropagation(X, y, a1, a2, W1, W2, b1, b2, learning_rate=0.1)
# 每100次打印一次损失
if epoch % 100 == 0:
loss = np.mean((a2 - y) ** 2) # 均方误差损失
print(f"Epoch {epoch}, Loss: {loss}")
# 7. 训练完毕后的预测
print("Final Predictions:")
print(a2)
