案例-价格分类

一.前言

前面学习了深度学习的基础部分，本章来介绍一个案例，当然里面代码可能不太懂，但是大家可以当个了解一下

找出⼿机的功能（例如：RAM等）与其售价之间的某种关系。我们可以使⽤机器学习的 ⽅法来解决这个问题，也可以构建⼀个全连接的⽹络。

需要注意的是: 在这个问题中，我们不需要预测实际价格，⽽是⼀个价格范围，它的范围使⽤ 0、1、2、3 来表示，所以该问题也是⼀个分类问题。

二. 构建数据集

数据共有 2000 条, 其中 1600 条数据作为训练集, 400 条数据⽤作测试集。 我们使⽤ sklearn 的数据集划分 ⼯作来完成。并使⽤ PyTorch 的 TensorDataset 来将数据集构建为 Dataset 对象，⽅便构造数据集加载对象。 

# 构建数据集
def create_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)
    # 构建数据集
    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()

三.构建分类网络模型 

我们构建的⽤于⼿机价格分类的模型叫做全连接神经⽹络。它主要由三个线性层来构建，在每个线性层后， 我们使⽤的时 sigmoid 激活函数

class PhonePriceModel(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, output_dim)

    def _activation(self, x):
        return torch.sigmoid(x)

    def forward(self, x):
        x = self._activation(self.linear1(x))
        x = self._activation(self.linear2(x))
        output = self.linear3(x)
        return output

我们的⽹络共有 3 个全连接层, 具体信息如下:

1. 第⼀层: 输⼊为维度为 20, 输出维度为: 128

2. 第⼆层: 输⼊为维度为 128, 输出维度为: 256

3. 第三层: 输⼊为维度为 256, 输出维度为: 4 

我们使⽤ sigmoid 激活函数.

四.编写训练函数 

⽹络编写完成之后，我们需要编写训练函数。所谓的训练函数，指的是输⼊数据读取、送⼊⽹络、计算损 失、更新参数的流程，该流程较为固定。我们使⽤的是多分类交叉⽣损失函数、使⽤ SGD 优化⽅法。最终，将训练好的模型持久化到磁盘中。 

五.编写评估函数

评估函数、也叫预测函数、推理函数，主要使⽤训练好的模型，对未知的样本的进⾏预测的过程。我们这⾥使⽤前⾯单独划分出来的测试集来进⾏评估。 

def test():
    # 加载模型
    model = PhonePriceModel(input_dim, class_num)
    model.load_state_dict(torch.load('phone-price-model.bin'))
    # 构建加载器
    dataloader = DataLoader(valid_dataset, batch_size=8, shuffle=False)
    # 评估测试集
    correct = 0
    for x, y in dataloader:
        output = model(x)
        y_pred = torch.argmax(output, dim=1)
        correct += (y_pred == y).sum()
    print('Acc: %.5f' % (correct.item() / len(valid_dataset)))

程序输出结果:

Acc: 0.51000 

六.网络性能调优 

我们前⾯的⽹络模型在测试集的准确率为:0.51000  我们可以通过以下⽅⾯进⾏调优: 

1. 对输⼊数据进⾏标准化
2. 调整优化⽅法

3. 调整学习率

4. 增加批量归⼀化层

5. 增加⽹络层数、神经元个数

6. 增加训练轮数

7. 等等... 

我进⾏下如下调整:

1. 优化⽅法由 SGD 调整为 Adam

2. 学习率由 1e-3 调整为 1e-4

3. 对数据数据进⾏标准化 

4. 增加⽹络深度, 即: 增加⽹络参数量

⽹络模型在测试集的准确率由 0.51000  上升到 0.97500，调整后的完整代码为: 

import torch
import torch.nn as nn
import torch.nn.functional as F
import pandas as pd
from sklearn.model_selection import train_test_split
from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torch.optim as optim
import numpy as np
import time
from sklearn.preprocessing import StandardScaler


# 构建数据集
def create_dataset():
    data = pd.read_csv('手机价格预测.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)
    # 数据标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_valid = transfer.transform(x_valid)
    # 构建数据集
    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))


train_dataset, valid_dataset, input_dim, class_num = create_dataset()


# 构建⽹络模型
class PhonePriceModel(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, 256)
        self.linear5 = nn.Linear(256, output_dim)

    def _activation(self, x):
        return torch.sigmoid(x)

    def forward(self, x):
        x = self._activation(self.linear1(x))
        x = self._activation(self.linear2(x))
        x = self._activation(self.linear3(x))
        x = self._activation(self.linear4(x))
        output = self.linear5(x)
        return output

# 编写训练函数
def train():
    # 固定随机数种⼦
    torch.manual_seed(0)
    # 初始化模型
    model = PhonePriceModel(input_dim, class_num)
    # 损失函数
    criterion = nn.CrossEntropyLoss()
    # 优化⽅法
    optimizer = optim.Adam(model.parameters(), lr=1e-4)
    # 训练轮数
    num_epoch = 50
    for epoch_idx in range(num_epoch):
        # 初始化数据加载器
        dataloader = DataLoader(train_dataset, shuffle=True, batch_size=8)
        # 训练时间
        start = time.time()
        # 计算损失
        total_loss = 0.0
        total_num = 1
        # 准确率
        correct = 0
        for x, y in dataloader:
            output = model(x)
            # 计算损失
            loss = criterion(output, y)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 参数更新
            optimizer.step()
            total_num += len(y)
            total_loss += loss.item() * len(y)
        print('epoch: %4s loss: %.2f, time: %.2fs' %
              (epoch_idx + 1, total_loss / total_num, time.time() - start))
        # 模型保存
    torch.save(model.state_dict(), 'phone-price-model.bin')


def test():
    # 加载模型
    model = PhonePriceModel(input_dim, class_num)
    model.load_state_dict(torch.load('phone-price-model.bin'))
    # 构建加载器
    dataloader = DataLoader(valid_dataset, batch_size=8, shuffle=False)
    # 评估测试集
    correct = 0
    for x, y in dataloader:
        output = model(x)
        y_pred = torch.argmax(output, dim=1)
        correct += (y_pred == y).sum()

    print('Acc: %.5f' % (correct.item() / len(valid_dataset)))

if __name__ == '__main__':
    train()
    test()

七.总结 

通过这个案例，大家可以初步了解一下训练模型的流程，这个代码大家也可以拷贝下来去用，数据的话我会上传的，作为一个了解。