神经网络-二手手机预测案例(神经网络入门最完整案例)

# 1.导入相关模块
import torch
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
from torchsummary import summary


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 forward(self, x):
        x = torch.relu(self.linear1(x))
        x = torch.relu(self.linear2(x))
        output = self.linear3(x)

        # 获取数据结果
        return output


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))
    print('x_train', x_train)
    print('x_valid', x_valid)
    # 构建数据集，转换为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))

    print('train_dataset', train_dataset)
    print('valid_dataset', valid_dataset)

    # 返回结果   todo x_train.shape[1]返回列数    0返回行数
    return train_dataset, valid_dataset, x_train.shape[1], len(np.unique(y))


def train(train_dataset, input_dim, class_num):
    # 固定随机种子
    torch.manual_seed(1)
    # 初始化模型
    model = PhonePriceModel(input_dim, class_num)
    # 损失函数
    criterion = nn.CrossEntropyLoss()
    # 优化方法 todo 最小化损失函数
    optimizer = optim.SGD(model.parameters(), lr=1e-3)
    # 训练轮数
    num_epoch = 50

    # 遍历每个batch数据进行处理
    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(), './phone.pth')


def test(valid_dataset,input_dim,class_num):
    # 加载模型和训练好的网络参数
    model=PhonePriceModel(input_dim,class_num)
    # todo load_state_dict : 保存模型中的w和b 用于恢复模型
    model.load_state_dict(torch.load('./phone.pth'))
    # 构建加载器
    dataloader=DataLoader(valid_dataset,batch_size=8,shuffle=False)
    # 评估测试集
    correct=0
    # 遍历测试集中的数据
    for x,y in dataloader:
        # 将其送入网络中
        output=model(x)
        # 获取类别结果  dim=1 行 todo  最大值代表分类结果
        y_pred=torch.argmax(output,dim=1)
        # 获取预测正确的个数
        correct+=(y_pred==y).sum()
    # 求预测精度
    print('Acc: %.5f' % (correct.item() / len(valid_dataset)))


if __name__ == '__main__':
    # # 1.获取数据
    train_dataset, valid_dataset, input_dim, class_num = create_dataset()
    # print("456728", input_dim)  # 列数
    # print("9:;28", class_num)  # 目标个数

    # 模型实例化
    model = PhonePriceModel(input_dim, class_num)
    summary(model, input_size=(input_dim,), batch_size=16)

    #  模型训练
    train(train_dataset,input_dim,class_num)

    # 模型预测
    test(valid_dataset,input_dim,class_num)