多层感知机
隐藏层
多层感知机（MLP)通常包括输入层、一个或多个隐藏层以及输出层。输入层接收外部数据，隐藏层对数据进行处理和变换，输出层则产生最终的结果
单隐藏层 多隐藏层
可以通过在网络中加入一个或多个隐藏层来克服线性模型的限制， 使其能处理更普遍的函数关系类型。
激活函数
sigmoid函数
import torch
import matplotlib.pyplot as plt
# 创建自变量x
x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
# 计算y = sigmoid(x)
y = torch.sigmoid(x)
# 绘制sigmoid(x)的图像
plt.figure(figsize=(5, 2.5))
plt.plot(x.detach().numpy(), y.detach().numpy())
plt.xlabel('x')
plt.ylabel('sigmoid(x)')
plt.title('Sigmoid Activation Function')
plt.grid()
plt.show()
# 清除以前的梯度
if x.grad is not None:
x.grad.data.zero_()
# 计算y相对于x的梯度
y.backward(torch.ones_like(x), retain_graph=True)
# 绘制sigmoid的梯度图像
plt.figure(figsize=(5, 2.5))
plt.plot(x.detach().numpy(), x.grad.numpy())
plt.xlabel('x')
plt.ylabel('grad of sigmoid')
plt.title('Gradient of Sigmoid')
plt.grid()
plt.show()
运行结果：
sigmoid(x)的图像 sigmoid(x)的梯度图像（该函数导数图像）
ReLU函数
import torch
import matplotlib.pyplot as plt
# 创建自变量x
x = torch.arange(-8.0, 8.0, 0.1, requires_grad=True)
# 计算y = relu(x)
y = torch.relu(x)
# 绘制relu(x)的图像
plt.figure(figsize=(5, 2.5))
plt.plot(x.detach().numpy(), y.detach().numpy())
plt.xlabel('x')
plt.ylabel('relu(x)')
plt.title('ReLU Activation Function')
plt.grid()
plt.show()
# 计算y相对于x的梯度
y.backward(torch.ones_like(x), retain_graph=True)
# 绘制relu的梯度图像
plt.figure(figsize=(5, 2.5))
plt.plot(x.detach().numpy(), x.grad.numpy())
plt.xlabel('x')
plt.ylabel('grad of relu')
plt.title('Gradient of ReLU')
plt.grid()
plt.show()
运行结果：
relu(x)的图像 relu(x)的梯度图像（该函数导数图像）
tanh函数 
import numpy as np
import matplotlib.pyplot as plt
# 定义tanh函数及其导数
def tanh(x):
return np.tanh(x)
def tanh_derivative(x):
return 1 - np.tanh(x)**2
# 生成x值
x = np.linspace(-5, 5, 100)
# 计算tanh函数和导数
y_tanh = tanh(x)
y_derivative = tanh_derivative(x)
# 绘制图像
plt.figure(figsize=(12, 6))
# 绘制tanh函数
plt.subplot(1, 2, 1)
plt.plot(x, y_tanh, label='tanh(x)', color='blue')
plt.title('tanh Function')
plt.xlabel('x')
plt.ylabel('tanh(x)')
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid()
plt.legend()
# 绘制tanh导数
plt.subplot(1, 2, 2)
plt.plot(x, y_derivative, label="tanh'(x)", color='orange')
plt.title('Derivative of tanh Function')
plt.xlabel('x')
plt.ylabel("tanh'(x)")
plt.axhline(0, color='black', lw=0.5, ls='--')
plt.axvline(0, color='black', lw=0.5, ls='--')
plt.grid()
plt.legend()
plt.tight_layout()
plt.show()
tanh(x)的图像 tanh(x)的梯度图像（该函数导数图像）
多层感知机从零开始
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
# 1. 导入数据集
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
# 2. 初始化参数
class MLP(nn.Module):
def __init__(self):
super(MLP, self).__init__()
self.fc1 = nn.Linear(28 * 28, 128) # 输入层到隐藏层1
self.fc2 = nn.Linear(128, 64) # 隐藏层1到隐藏层2
self.fc3 = nn.Linear(64, 10) # 隐藏层2到输出层
def forward(self, x):
x = x.view(-1, 28 * 28) # 将28x28的图像展平为784维的向量
x = torch.relu(self.fc1(x)) # 激活函数
x = torch.relu(self.fc2(x)) # 激活函数
x = self.fc3(x) # 输出层
return x
model = MLP()
# 3. 激活函数和损失函数
criterion = nn.CrossEntropyLoss() # 交叉熵损失函数
optimizer = optim.Adam(model.parameters(), lr=0.001) # Adam优化器
# 4. 训练
num_epochs = 5
for epoch in range(num_epochs):
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad() # 清除梯度
output = model(data) # 前向传播
loss = criterion(output, target) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新参数
if batch_idx % 100 == 0: # 每100个batch打印一次信息
print(f'Epoch [{epoch+1}/{num_epochs}], Step [{batch_idx}/{len(train_loader)}], Loss: {loss.item():.4f}')
# 5. 预测
def predict(model, data):
model.eval() # 切换到评估模式
with torch.no_grad(): # 不计算梯度
output = model(data)
_, predicted = torch.max(output, 1) # 获取预测的类
return predicted
# 使用训练好的模型进行预测
test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
test_loader = DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
# 获取一些测试数据进行预测
data_iter = iter(test_loader)
images, labels = next(data_iter)
predicted_labels = predict(model, images)
# 可视化预测结果
def visualize(images, labels, predictions):
plt.figure(figsize=(10, 4))
for i in range(10):
plt.subplot(2, 10, i + 1)
plt.imshow(images[i].squeeze(), cmap='gray')
plt.title(f'True: {labels[i].item()}\nPred: {predictions[i].item()}')
plt.axis('off')
plt.show()
visualize(images, labels, predicted_labels)
多层感知机简洁实现
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader
# 数据集导入
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])
train_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
# 定义多层感知机
class MLP(nn.Module):
def __init__(self):
super(MLP, self).__init__()
self.flatten = nn.Flatten() # 展平层
self.fc1 = nn.Linear(28 * 28, 128) # 隐藏层
self.relu = nn.ReLU() # 激活函数
self.fc2 = nn.Linear(128, 10) # 输出层
def forward(self, x):
x = self.flatten(x) # 展平
x = self.fc1(x) # 隐藏层
x = self.relu(x) # 激活函数
x = self.fc2(x) # 输出层
return x
# 模型、损失函数和优化器
model = MLP()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# 训练
num_epochs = 5
for epoch in range(num_epochs):
for data, target in train_loader:
optimizer.zero_grad() # 清除梯度
output = model(data) # 前向传播
loss = criterion(output, target) # 计算损失
loss.backward() # 反向传播
optimizer.step() # 更新参数
print(f'Epoch {epoch + 1}, Loss: {loss.item():.4f}')欠拟合和过拟合
欠拟合
在训练数据时表现不好，模型太简单
解决方法：
- 选择一个更复杂的模型，以增加模型的学习能力。
- 增加模型的参数数量。
- 延长训练时间，确保模型有足够的时间去学习数据。
- 尝试不同的特征组合或特征变换，以改善数据的表达性。
过拟合
训练表现很好，泛化能力很弱
解决方法：
增加数据量：更多的数据可以提供更多的信息，帮助模型学习到更一般的规律，而不是只关注训练数据中的细节。
正则化：通过在损失函数中添加正则化项（如L1或L2正则化），可以限制模型的复杂度，防止模型学习到过多的细节。
特征选择：减少特征的数量，只保留对模型预测有用的特征，可以降低模型的复杂度。
交叉验证：使用交叉验证来选择最优的模型参数，以防止模型在训练数据上过拟合。
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
# 生成合成数据
np.random.seed(42)
X = 5 * np.random.rand(80, 1)
y = np.sin(X).ravel() + np.random.normal(0, 0.1, X.shape[0])
# 将数据转换为DataFrame
data = pd.DataFrame({'X': X.ravel(), 'y': y})
# 拆分数据集
train_size = int(0.8 * len(data))
train_data = data[:train_size]
test_data = data[train_size:]
X_train = train_data[['X']].values
y_train = train_data['y'].values
X_test = test_data[['X']].values
y_test = test_data['y'].values
# 线性模型
def linear_model(X, y):
X_b = np.c_[np.ones((X.shape[0], 1)), X] # 添加偏置项
theta_best = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
return theta_best
theta_linear = linear_model(X_train, y_train)
# 预测
def predict(X, theta):
X_b = np.c_[np.ones((X.shape[0], 1)), X]
return X_b @ theta
y_pred_train_linear = predict(X_train, theta_linear)
y_pred_test_linear = predict(X_test, theta_linear)
# 多项式模型
def polynomial_features(X, degree):
return np.hstack([X**i for i in range(degree + 1)])
X_poly_train = polynomial_features(X_train, 15)
X_poly_test = polynomial_features(X_test, 15)
theta_poly = linear_model(X_poly_train, y_train)
y_pred_train_poly = predict(X_poly_train, theta_poly)
y_pred_test_poly = predict(X_poly_test, theta_poly)
# 绘制结果
plt.figure(figsize=(14, 6))
# 欠拟合
plt.subplot(1, 2, 1)
plt.scatter(X_train, y_train, color='black', label='Data')
plt.plot(X_train, y_pred_train_linear, color='red', label='Model')
plt.title('Underfitting: Linear Model')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.grid()
# 过拟合
plt.subplot(1, 2, 2)
plt.scatter(X_train, y_train, color='black', label='Data')
plt.plot(X_train, y_pred_train_poly, color='red', label='Model')
plt.title('Overfitting: Polynomial Model')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.tight_layout()
plt.show()
# 输出均方误差
def mean_squared_error(y_true, y_pred):
return np.mean((y_true - y_pred) ** 2)
print("Underfitting Train MSE:", mean_squared_error(y_train, y_pred_train_linear))
print("Underfitting Test MSE:", mean_squared_error(y_test, y_pred_test_linear))
print("Overfitting Train MSE:", mean_squared_error(y_train, y_pred_train_poly))
print("Overfitting Test MSE:", mean_squared_error(y_test, y_pred_test_poly))
权重衰减
权重衰减是一种常用的正则化技术，旨在减少模型的过拟合现象。正则化项通常使用L1范数或L2范数来度量，L2范数正则化（也称为权重衰减）是指将模型的权重的平方和添加到损失函数中，乘以一个较小的正则化参数。
对于一个损失函数，权重衰减的实现方式：
正则化参数的选择对模型的性能有重要影响。较小的
值会导致较强的正则化效果，可能会使模型欠拟合。而较大的
值可能会减少正则化效果，使模型过拟合
import numpy as np
import matplotlib.pyplot as plt
# 生成合成数据
np.random.seed(42)
X = 5 * np.random.rand(80, 1)
y = 2 + 3 * X.ravel() + np.random.normal(0, 0.5, X.shape[0])
# 拆分数据集
train_size = int(0.8 * len(X))
X_train, y_train = X[:train_size], y[:train_size]
X_test, y_test = X[train_size:], y[train_size:]
# 线性回归与权重衰减
def linear_regression_with_weight_decay(X, y, lambda_reg, learning_rate=0.01, n_iterations=1000):
m, n = X.shape
theta = np.random.randn(n + 1, 1) # 初始化权重
X_b = np.c_[np.ones((m, 1)), X] # 添加偏置项
y = y.reshape(-1, 1) # 确保 y 是二维列向量
for iteration in range(n_iterations):
predictions = X_b @ theta
errors = predictions - y
gradients = (2 / m) * X_b.T @ errors + lambda_reg * np.vstack(([0], theta[1:])) # 使用 vstack 确保形状一致
theta -= learning_rate * gradients # 直接更新 theta
return theta
lambda_reg = 0.1
theta = linear_regression_with_weight_decay(X_train, y_train, lambda_reg)
# 预测
def predict(X, theta):
X_b = np.c_[np.ones((X.shape[0], 1)), X]
return X_b @ theta
y_pred_train = predict(X_train, theta)
y_pred_test = predict(X_test, theta)
# 绘制结果
plt.scatter(X, y, color='black', label='Data')
plt.plot(X_train, y_pred_train, color='red', label='Model (Weight Decay)')
plt.title('Linear Regression with Weight Decay')
plt.xlabel('X')
plt.ylabel('y')
plt.legend()
plt.grid()
plt.show()
# 输出均方误差
def mean_squared_error(y_true, y_pred):
return np.mean((y_true - y_pred.flatten()) ** 2)
print("Train MSE:", mean_squared_error(y_train, y_pred_train))
print("Test MSE:", mean_squared_error(y_test, y_pred_test))
扫一扫
407
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
