深度学习之二手手机价格预测

特征解释

battery_power：电池一次可储存的总能量，单位为毫安时
blue ：是否有蓝牙
clock_speed：微处理器执行指令的速度
dual_sim：是否支持双卡
fc：前置摄像头百万像素
four_g：是否有4G
int_memory：内存（GB）
m_dep：移动深度（cm）
mobile_wt：手机重量
n_cores：处理器内核数
pc：主摄像头百万像素
px_height：像素分辨率高度
px_width：像素分辨率宽度
ram：随机存取存储器（兆字节）
sc_h：手机屏幕高度（cm）
sc_w：手机屏幕宽度（cm）
talk_time：一次电池充电持续时间最长的时间
three_g：是否有3G
touch_screen：是否有触控屏
wifi：是否能连wifi
price_range：价格区间（0，1，2，3）

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

代碼分布解析

导包

from torch.utils.data import TensorDataset
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
from sklearn.datasets import make_regression
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import time

构建数据集

# 构建数据集
def create_dataset(load_str = '../data/手机价格预测.csv'):


    # 使用pandas读取数据
    data = pd.read_csv(load_str)
    # 特征值和目标值
    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)
    # 构建数据集,转换为pytorch的形式
    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("输入特征数：",input_dim)
print("分类个数：",class_num)

创建模型

# 构建网络模型
class PhonePriceModel(nn.Module):


    def __init__(self, input_dim, output_dim):
        super(PhonePriceModel, self).__init__()
        # 1. 第一层: 输入为维度为 20, 输出维度为: 128
        self.linear1 = nn.Linear(input_dim, 128)
        # 2. 第二层: 输入为维度为 128, 输出维度为: 256
        self.linear2 = nn.Linear(128, 256)
        # 3. 第三层: 输入为维度为 256, 输出维度为: 4
        self.out = nn.Linear(256, output_dim)

    def forward(self, x):
        # 前向传播过程
        x = torch.relu(self.linear1(x))
        x = torch.relu(self.linear2(x))
        output = self.out(x)
        # 获取数据结果
        return output

模型训练

# 模型训练过程
def train(train_dataset,input_dim,class_num,):
    # 固定随机数种子
    torch.manual_seed(0)
    # 初始化模型
    model = PhonePriceModel(input_dim, class_num)
    # 损失函数
    criterion = nn.CrossEntropyLoss()
    # 优化方法
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    # 训练轮数
    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
        # 遍历每个batch数据进行处理
        for x, y in dataloader:
            # 将数据送入网络中进行预测
            output = model(x)
            # 计算损失
            loss = criterion(output, y)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播
            loss.backward()
            # 参数更新
            optimizer.step()
            # 损失计算
            total_num += 1
            total_loss += loss.item()
        # 打印损失变换结果
        print('epoch: %4s loss: %.2f, time: %.2fs' %
              (epoch_idx + 1, total_loss / total_num, time.time() - start))

    # 模型保存
    torch.save(model.state_dict(), 'model/phone.pth')

模型预测效果

# 模型预测结果评估
def test(valid_dataset,input_dim,class_num):
    # 加载模型和训练好的网络参数
    model = PhonePriceModel(input_dim, class_num)
    model.load_state_dict(torch.load('data/phone.pth'))
    # 构建加载器
    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)))

运行结果：