你是一位专业的时间管理教练，请根据以下信息为我制定今日计划：
课程表：[用户输入今日课程时间] ——> 连入教务系统获得，教务系统API更新频率：每30分钟同步（标注调课/临时会议等突发变更）
待办事项：[用户输入任务列表，如"大数据作业""预习英语""洗衣服"] ——> 可以手动预设，也可以根据以往信息推荐，比如：完成昨天未完成的英语单词的积累。用户也可以定制自己的学习进度数据库，筛选每门课程的教学大纲和教学进度输入，提供分析数据。手动输入覆盖规则：用户手动输入的数据优先级高于自动同步数据
健康数据：[可选输入如"早餐吃了燕麦+香蕉""昨晚睡了6小时"] ——> 连入手机 健康类app，健康APP数据权限：需授权读取睡眠周期（深/浅睡眠比例）、步数、心率变异率(HRV)
历史数据：[如晚上失眠早上调整起床时间] —— 定制历史数据库，如心情，学习进度，身体状况
替换平均池化（AvgPool）为最大池化（MaxPool），并输出结果。
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
# --------------------- 1. 定义 LeNet 网络 ---------------------
class LeNet(nn.Module):
def __init__(self, use_maxpool=True):
super(LeNet, self).__init__()
# 卷积层
self.conv1 = nn.Conv2d(1, 6, kernel_size=5, padding=2) # 28x28 -> 28x28
self.conv2 = nn.Conv2d(6, 16, kernel_size=5) # 14x14 -> 10x10
# 选择池化方式（默认使用 MaxPool）
self.pool = nn.MaxPool2d(kernel_size=2, stride=2) if use_maxpool else nn.AvgPool2d(kernel_size=2, stride=2)
# 全连接层
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = nn.Linear(84, 10)
def forward(self, x):
x = self.pool(torch.relu(self.conv1(x))) # 第一层卷积 + ReLU + 池化
x = self.pool(torch.relu(self.conv2(x))) # 第二层卷积 + ReLU + 池化
x = torch.flatten(x, 1) # 展平
x = torch.relu(self.fc1(x))
x = torch.relu(self.fc2(x))
x = self.fc3(x) # 最终输出 10 维
return x
# --------------------- 2. 载入 MNIST 数据集 ---------------------
mnist_data_path = "D:/603/pythonProject/data/MNIST/"
transform = transforms.Compose([
transforms.Grayscale(),
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,)) # 归一化到 [-1, 1]
])
# 加载训练和测试数据
trainset = torchvision.datasets.MNIST(root=mnist_data_path, train=True, download=False, transform=transform)
testset = torchvision.datasets.MNIST(root=mnist_data_path, train=False, download=False, transform=transform)
train_loader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)
# --------------------- 3. 训练模型 ---------------------
def train_model(model, train_loader, epochs=5, learning_rate=0.001):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=learning_rate)
for epoch in range(epochs):
model.train()
running_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad()
outputs = model(images)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
print(f"Epoch {epoch + 1}, Loss: {running_loss / len(train_loader):.4f}")
# --------------------- 4. 评估模型 ---------------------
def evaluate_model(model, test_loader):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
model.eval()
correct, total = 0, 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print(f"Test Accuracy: {100 * correct / total:.2f}%")
# --------------------- 5. 运行实验 ---------------------
# 训练并评估使用平均池化的 LeNet
print("\nTraining LeNet with Average Pooling...")
lenet_avg = LeNet(use_maxpool=False)
train_model(lenet_avg, train_loader, epochs=5, learning_rate=0.001)
print("\nEvaluating LeNet with Average Pooling...")
evaluate_model(lenet_avg, test_loader)
# 训练并评估使用最大池化的 LeNet
print("\nTraining LeNet with Max Pooling...")
lenet_max = LeNet(use_maxpool=True)
train_model(lenet_max, train_loader, epochs=5, learning_rate=0.001)
print("\nEvaluating LeNet with Max Pooling...")
evaluate_model(lenet_max, test_loader)According to the referenced code related to weight decay, plot the functions of the training loss and the test loss with respect to λ
import torch
from torch import nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
# 设定超参数
batch_size = 256
num_inputs, num_outputs = 784, 10
num_hiddens = 128
num_layers = 2
learning_rate = 0.1
num_epochs = 10
lambda_values = [0, 0.0001, 0.001, 0.01, 0.1, 1] # 不同的权重衰减系数 λ
# 预处理 FashionMNIST 数据集
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = torchvision.datasets.FashionMNIST(root="./data", train=True, transform=transform, download=True)
test_dataset = torchvision.datasets.FashionMNIST(root="./data", train=False, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
# 定义 MLP 网络
class MLP(nn.Module):
def __init__(self, num_inputs, num_hiddens, num_outputs, num_layers):
super(MLP, self).__init__()
layers = []
layers.append(nn.Linear(num_inputs, num_hiddens))
layers.append(nn.ReLU())
for _ in range(num_layers - 1):
layers.append(nn.Linear(num_hiddens, num_hiddens))
layers.append(nn.ReLU())
layers.append(nn.Linear(num_hiddens, num_outputs))
self.net = nn.Sequential(*layers)
def forward(self, X):
return self.net(X.view(-1, num_inputs)) # 展平输入
# 训练函数，接收不同的 weight_decay 参数
def train_with_weight_decay(lambda_values):
train_losses, val_losses = [], []
for weight_decay in lambda_values:
net = MLP(num_inputs, num_hiddens, num_outputs, num_layers)
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate, weight_decay=weight_decay) # 添加权重衰减
train_loss, val_loss = [], []
for epoch in range(num_epochs):
net.train()
total_loss, total_samples = 0, 0
for X, y in train_loader:
y_hat = net(X)
l = loss(y_hat, y)
optimizer.zero_grad()
l.backward()
optimizer.step()
total_loss += l.item() * y.size(0)
total_samples += y.size(0)
train_loss.append(total_loss / total_samples)
net.eval()
total, test_loss = 0, 0
with torch.no_grad():
for X, y in test_loader:
y_hat = net(X)
test_loss += loss(y_hat, y).item() * y.size(0)
total += y.size(0)
val_loss.append(test_loss / total)
train_losses.append(train_loss[-1])
val_losses.append(val_loss[-1])
print(f"λ={weight_decay:.5f}, Final Train Loss={train_loss[-1]:.4f}, Final Val Loss={val_loss[-1]:.4f}")
return train_losses, val_losses
# 训练并记录不同 λ 对损失的影响
train_losses, val_losses = train_with_weight_decay(lambda_values)
# 绘制 λ vs 训练损失 / 测试损失曲线
plt.figure(figsize=(8, 5))
plt.plot(lambda_values, train_losses, marker="o", label="Train Loss", color="blue")
plt.plot(lambda_values, val_losses, marker="s", label="Test Loss", color="orange", linestyle="dashed")
plt.xlabel("Weight Decay (λ)")
plt.ylabel("Loss")
plt.xscale("log") # 采用对数刻度更清晰
plt.legend()
plt.title("Effect of Weight Decay (λ) on Loss")
plt.show()import torch
from torch import nn
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
batch_size = 256
num_inputs, num_outputs = 784, 10
num_hiddens = 128
num_layers = 2
learning_rate = 0.1
num_epochs = 10
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = torchvision.datasets.FashionMNIST(root="./data", train=True, transform=transform, download=False)
test_dataset = torchvision.datasets.FashionMNIST(root="./data", train=False, transform=transform, download=False)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
class MLP(nn.Module):
def __init__(self, num_inputs, num_hiddens, num_outputs, num_layers):
super(MLP, self).__init__()
layers = []
layers.append(nn.Linear(num_inputs, num_hiddens))
layers.append(nn.ReLU())
for _ in range(num_layers - 1):
layers.append(nn.Linear(num_hiddens, num_hiddens))
layers.append(nn.ReLU())
layers.append(nn.Linear(num_hiddens, num_outputs))
self.net = nn.Sequential(*layers)
def forward(self, X):
return self.net(X.view(-1, num_inputs)) # 展平输入
net = MLP(num_inputs, num_hiddens, num_outputs, num_layers)
loss = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(net.parameters(), lr=learning_rate)
def train(net, train_loader, test_loader, loss, num_epochs):
train_loss, val_loss, val_acc = [], [], []
for epoch in range(num_epochs):
net.train()
total_loss, total_samples = 0, 0
for X, y in train_loader:
y_hat = net(X)
l = loss(y_hat, y)
optimizer.zero_grad()
l.backward()
optimizer.step()
total_loss += l.item() * y.size(0)
total_samples += y.size(0)
train_loss.append(total_loss / total_samples)
net.eval()
correct, total, test_loss = 0, 0, 0
with torch.no_grad():
for X, y in test_loader:
y_hat = net(X)
test_loss += loss(y_hat, y).item() * y.size(0)
correct += (y_hat.argmax(dim=1) == y).sum().item()
total += y.size(0)
val_loss.append(test_loss / total)
val_acc.append(correct / total)
print(
f"Epoch {epoch + 1}: train_loss={train_loss[-1]:.4f}, val_loss={val_loss[-1]:.4f}, val_acc={val_acc[-1]:.4f}")
plt.plot(range(1, num_epochs + 1), train_loss, label="train_loss", color="blue")
plt.plot(range(1, num_epochs + 1), val_loss, label="val_loss", color="orange", linestyle="dashed")
plt.plot(range(1, num_epochs + 1), val_acc, label="val_acc", color="green", linestyle="dashdot")
plt.xlabel("Epoch")
plt.legend()
plt.show()
# 训练模型
train(net, train_loader, test_loader, loss, num_epochs)该图展示了一个三层神经网络（输入层、隐藏层、输出层）。
输入层（Input Layer）：由 组成，表示输入特征，每个特征作为一个神经元。
隐藏层（Hidden Layer）：由 组成，表示经过线性变换和激活函数处理后的隐藏表示。
Softmax 回归：这是一种用于多类分类问题的回归方法，通常用于神经网络的输出层。
Softmax 与深度学习的关系：Softmax 回归是深度学习中的一个重要组成部分，特别是在处理分类问题时。它与线性回归和单层神经网络有联系，并可以追溯到深度学习的更广泛背景中。
线性回归在分类问题上的局限性
Linear Regression-->Discrete Classification
Problem: In the process of converting continuous values to discrete values, there is usually an element of experience. If the error is large, it will greatly affect the quality of classification. During the conversion process, it is easy for people to think of setting a threshold. Setting the threshold based on experience will bring a lot of uncertainties, and the quality of classification is also related to the different experiences of different people.