从零开始搭建神经网络：手机价格分类实战

面向深度学习初学者的实战教程，从0到1掌握神经网络搭建与训练

📋 引言

你是否好奇手机厂商是如何根据手机的各项参数来定价的？或者想了解如何用深度学习来预测产品价格区间？今天，我们将通过一个手机价格分类案例 ，带你从零开始搭建神经网络模型，完整走过数据准备、模型构建、训练优化到评估测试的全流程。

这个案例非常适合深度学习初学者，我们会使用PyTorch框架，代码注释详细，步骤清晰，你可以跟着一步步操作，轻松入门神经网络。

🛠️ 准备工作

1. 环境搭建

首先，我们需要安装必要的Python库：

  
pip install torch torchvision pandas numpy scikit-learn

2. 数据集介绍

本次使用的手机价格数据集包含2000条记录，每条记录有20个手机参数特征（如RAM、存储容量、电池容量等），以及对应的价格区间（0-3四个类别）。

• 特征数量 ：20个
• 分类类别 ：4个（0-3，代表不同价格区间）
• 数据划分 ：1600条训练集，400条测试集

picture.image

🔍 实战步骤

步骤1：构建数据集

首先，我们需要读取数据并进行预处理：

  
# 导入相关库  
import torch  
from torch.utils.data import TensorDataset, DataLoader  
import torch.nn as nn  
import torch.optim as optim  
from sklearn.model\_selection import train\_test\_split  
import numpy as np  
import pandas as pd  
  
# 构建数据集函数  
defcreate\_dataset():  
# 使用pandas读取数据  
    data = pd.read\_csv('data/手机价格预测.csv')  
  
# 分离特征值和目标值  
    x, y = data.iloc[:, :-1], data.iloc[:, -1]  
  
# 类型转换  
    x = x.astype(np.float32)  
  
# 划分训练集和测试集（8:2）  
    x\_train, x\_valid, y\_train, y\_valid = train\_test\_split(  
        x, y, train\_size=0.8, random\_state=88)  
  
# 转换为PyTorch的Dataset对象  
    train\_dataset = TensorDataset(  
        torch.from\_numpy(x\_train.values),   
        torch.tensor(y\_train.values)  
    )  
  
    valid\_dataset = TensorDataset(  
        torch.from\_numpy(x\_valid.values),   
        torch.tensor(y\_valid.values)  
    )  
  
return train\_dataset, valid\_dataset, x\_train.shape[1], len(np.unique(y))  
  
# 测试数据集构建  
train\_dataset, valid\_dataset, input\_dim, class\_num = create\_dataset()  
print(f"输入特征数：{input\_dim}")  
print(f"分类类别数：{class\_num}")

关键说明 ：

• train\_test\_split ：将数据按8:2比例划分为训练集和测试集
• TensorDataset ：将特征和标签组合成PyTorch可处理的数据集格式
• random\_state ：固定随机种子，确保结果可复现

步骤2：搭建神经网络模型

接下来，我们构建一个简单的全连接神经网络：

  
# 定义神经网络模型  
classPhonePriceModel(nn.Module):  
def\_\_init\_\_(self, input\_dim, output\_dim):  
super(PhonePriceModel, self).\_\_init\_\_()  
  
# 定义网络层  
self.linear1 = nn.Linear(input\_dim, 128)  # 输入层→隐藏层1  
self.linear2 = nn.Linear(128, 256)       # 隐藏层1→隐藏层2  
self.linear3 = nn.Linear(256, output\_dim) # 隐藏层2→输出层  
  
defforward(self, x):  
# 前向传播过程  
        x = torch.relu(self.linear1(x))  # 第1层使用ReLU激活函数  
        x = torch.relu(self.linear2(x))  # 第2层使用ReLU激活函数  
        output = self.linear3(x)         # 输出层不使用激活函数（后续CrossEntropyLoss包含softmax）  
  
return output  
  
# 测试模型搭建  
model = PhonePriceModel(input\_dim, class\_num)  
print(model)

网络结构说明 ：

• 输入层：20个神经元（对应20个特征）
• 隐藏层1：128个神经元，使用ReLU激活函数
• 隐藏层2：256个神经元，使用ReLU激活函数
• 输出层：4个神经元（对应4个价格区间）

步骤3：模型训练

现在，我们编写训练函数，设置损失函数和优化器：

  
# 模型训练函数  
deftrain(train\_dataset, input\_dim, class\_num):  
# 固定随机数种子  
    torch.manual\_seed(0)  
  
# 创建数据加载器（批量处理数据）  
    dataloader = DataLoader(train\_dataset, shuffle=True, batch\_size=8)  
  
# 初始化模型  
    model = PhonePriceModel(input\_dim, class\_num)  
  
# 损失函数：多分类交叉熵损失（包含softmax）  
    criterion = nn.CrossEntropyLoss()  
  
# 优化器：随机梯度下降（SGD）  
    optimizer = optim.SGD(model.parameters(), lr=1e-3)  
  
# 训练轮数  
    num\_epoch = 50  
  
# 开始训练  
for epoch\_idx inrange(num\_epoch):  
        total\_loss = 0.0  
        total\_num = 0  
  
# 遍历每个批次的数据  
for x, y in dataloader:  
# 设置模型为训练模式  
            model.train()  
  
# 前向传播：获取模型预测结果  
            output = model(x)  
  
# 计算损失  
            loss = criterion(output, y)  
  
# 反向传播：计算梯度  
            optimizer.zero\_grad()  # 清零梯度  
            loss.backward()        # 反向传播  
            optimizer.step()        # 更新参数  
  
# 累计损失  
            total\_loss += loss.item()  
            total\_num += 1  
  
# 打印每轮训练结果  
print(f'epoch: {epoch\_idx+1:4d} loss: {total\_loss/total\_num:.2f}')  
  
# 保存训练好的模型  
    torch.save(model.state\_dict(), 'phone-price-model.pth')  
print("模型保存成功！")  
  
# 执行训练  
train(train\_dataset, input\_dim, class\_num)

训练关键参数说明 ：

• batch\_size=8 ：每次训练使用8个样本
• lr=1e-3 ：学习率设置为0.001
• num\_epoch=50 ：训练50轮
• shuffle=True ：每个epoch打乱训练数据

步骤4：模型评估

训练完成后，我们使用测试集评估模型性能：

  
# 模型评估函数  
deftest(valid\_dataset, input\_dim, class\_num):  
# 加载训练好的模型  
    model = PhonePriceModel(input\_dim, class\_num)  
    model.load\_state\_dict(torch.load('phone-price-model.pth'))  
  
# 创建测试数据加载器  
    dataloader = DataLoader(valid\_dataset, batch\_size=8, shuffle=False)  
  
# 设置模型为评估模式  
    model.eval()  
  
    correct = 0  
    total = len(valid\_dataset)  
  
# 遍历测试数据  
with torch.no\_grad():  # 关闭梯度计算，节省内存  
for x, y in dataloader:  
# 获取模型预测结果  
            output = model(x)  
  
# 获取预测类别（概率最大的类别）  
            y\_pred = torch.argmax(output, dim=1)  
  
# 统计正确预测的数量  
            correct += (y\_pred == y).sum().item()  
  
# 计算准确率  
    accuracy = correct / total  
print(f'测试集准确率: {accuracy:.5f}')  
  
# 执行评估  
test(valid\_dataset, input\_dim, class\_num)

评估结果说明 ：

• model.eval() ：设置模型为评估模式，关闭dropout等训练特有的层
• torch.no\_grad() ：关闭梯度计算，减少内存使用，加速推理
• torch.argmax() ：获取概率最大的类别作为预测结果

步骤5：模型优化

我们可以通过以下方式优化模型性能：

数据标准化 ：使用 StandardScaler 对数据进行标准化

调整网络结构 ：增加网络层数或神经元数量

更换优化器 ：使用Adam等更高级的优化器

调整学习率 ：使用更小的学习率

优化后的完整代码：

  
import torch  
import torch.nn as nn  
import pandas as pd  
from sklearn.model\_selection import train\_test\_split  
from torch.utils.data import TensorDataset, DataLoader  
import torch.optim as optim  
import numpy as np  
from sklearn.preprocessing import StandardScaler  
  
# 构建数据集（优化版）  
defcreate\_dataset():  
    data = pd.read\_csv('data/手机价格预测.csv')  
    x, y = data.iloc[:, :-1], data.iloc[:, -1]  
  
# 类型转换  
    x = x.astype(np.float32)  
    y = y.astype(np.int64)  
  
# 数据集划分  
    x\_train, x\_valid, y\_train, y\_valid = train\_test\_split(  
        x, y, train\_size=0.8, random\_state=88, stratify=y)  
  
# 数据标准化  
    scaler = StandardScaler()  
    x\_train = scaler.fit\_transform(x\_train)  
    x\_valid = scaler.transform(x\_valid)  
  
# 转换为Dataset对象  
    train\_dataset = TensorDataset(  
        torch.from\_numpy(x\_train), torch.tensor(y\_train.values))  
    valid\_dataset = TensorDataset(  
        torch.from\_numpy(x\_valid), torch.tensor(y\_valid.values))  
  
return train\_dataset, valid\_dataset, x\_train.shape[1], len(np.unique(y))  
  
# 优化后的网络模型  
classPhonePriceModel(nn.Module):  
def\_\_init\_\_(self, input\_dim, output\_dim):  
super(PhonePriceModel, self).\_\_init\_\_()  
  
# 增加网络深度  
self.linear1 = nn.Linear(input\_dim, 128)  
self.linear2 = nn.Linear(128, 256)  
self.linear3 = nn.Linear(256, 512)  # 新增隐藏层  
self.linear4 = nn.Linear(512, 128)  # 新增隐藏层  
self.linear5 = nn.Linear(128, output\_dim)  
  
defforward(self, x):  
        x = torch.relu(self.linear1(x))  
        x = torch.relu(self.linear2(x))  
        x = torch.relu(self.linear3(x))  
        x = torch.relu(self.linear4(x))  
        output = self.linear5(x)  
return output  
  
# 优化后的训练函数  
deftrain(train\_dataset, input\_dim, class\_num):  
    torch.manual\_seed(0)  
    dataloader = DataLoader(train\_dataset, shuffle=True, batch\_size=8)  
    model = PhonePriceModel(input\_dim, class\_num)  
  
    criterion = nn.CrossEntropyLoss()  
# 使用Adam优化器，学习率调整为1e-4  
    optimizer = optim.Adam(model.parameters(), lr=1e-4)  
  
    num\_epoch = 50  
for epoch\_idx inrange(num\_epoch):  
        total\_loss = 0.0  
        total\_num = 0  
  
for x, y in dataloader:  
            model.train()  
            output = model(x)  
            loss = criterion(output, y)  
  
            optimizer.zero\_grad()  
            loss.backward()  
            optimizer.step()  
  
            total\_loss += loss.item() * len(y)  
            total\_num += len(y)  
  
print(f'epoch: {epoch\_idx+1:4d} loss: {total\_loss/total\_num:.2f}')  
  
    torch.save(model.state\_dict(), 'phone-price-model-optimized.pth')  
  
# 执行优化后的训练和评估  
train\_dataset, valid\_dataset, input\_dim, class\_num = create\_dataset()  
train(train\_dataset, input\_dim, class\_num)  
test(valid\_dataset, input\_dim, class\_num)

📊 结果分析

1. 训练过程

优化前：

• 初始损失：约1.4
• 最终损失：约0.8
• 测试准确率：约56.25%

优化后：

• 初始损失：约1.4
• 最终损失：约0.3
• 测试准确率：约96%+（取决于具体运行结果）

2. 优化效果对比

| 优化措施 | 准确率提升 | | --- | --- | | 数据标准化 | +25% | | 增加网络深度 | +10% | | 使用Adam优化器 | +5% | | 调整学习率 | +3% |

🎓 常见问题解答

Q1：为什么使用CrossEntropyLoss而不是MSELoss？

A：CrossEntropyLoss是多分类问题的专用损失函数，它包含了softmax操作，可以直接处理类别标签，而MSELoss更适合回归问题。

Q2：为什么要将模型设置为train()和eval()模式？

A：train()模式启用dropout和batch normalization的训练行为，eval()模式关闭这些行为，确保测试结果的一致性。

Q3：学习率应该如何选择？

A：学习率过大可能导致模型不收敛，过小则训练速度太慢。通常建议从1e-3开始尝试，根据训练曲线调整。

Q4：batch_size应该如何设置？

A：batch_size太小会导致训练不稳定，太大则内存占用过高。一般建议设置为8-64，根据硬件条件调整。

📚 扩展学习资源

PyTorch官方教程 ：https://pytorch.org/tutorials/

《深度学习入门之PyTorch》 ：一本适合初学者的PyTorch入门书籍

Kaggle手机价格分类竞赛 ：https://www.kaggle.com/iabhishekofficial/mobile-price-classification

B站PyTorch实战教程 ：搜索"深度学习"，有很多优质视频教程

picture.image