[人工智能]使用paddlepaddle来预测房价

导读

这篇文章我们介绍如何使用paddlepaddle来预测UCI房价，UCI房价数据集一共包含了506条数据，每条数据包含13个特征和该类房价的中位数。

paddlepaddle预测房价

• 加载数据集

import os,paddle
import numpy as np

#设置加载数据集的batch_size
BATCH_SIZE = 32

#加载训练集和验证集
train_datasets = paddle.text.datasets.UCIHousing(mode="train")
val_datasets = paddle.text.datasets.UCIHousing(mode="test")

#数据加载器用于训练时加载数据
train_dataloader = paddle.io.DataLoader(train_datasets,batch_size=BATCH_SIZE,shuffle=True,drop_last=True)
val_dataloader = paddle.io.DataLoader(val_datasets,batch_size=BATCH_SIZE,shuffle=True,drop_last=True)

• 查看UCI数据

print(train_datasets[0])
"""
(array([-0.0405441 ,  0.06636363, -0.32356226, -0.06916996, -0.03435197,
         0.05563625, -0.03475696,  0.02682186, -0.37171334, -0.21419305,
        -0.33569506,  0.10143217, -0.21172912], dtype=float32),
 array([24.], dtype=float32))
"""

• 定义预测网络结构
  这里我们使用一个全连接层来构建房价的预测网络，即全连接层的输入是13个节点，输出是1个节点，实现的数学公式如下
  $$z={\omega }_1{x}_1+{\omega }_2{x}_2+.....+{\omega }_{13}{x}_{13}+b$$
  

#模型的输入是[13]输出[1]
model = paddle.nn.Linear(13,1)

• 定义损失函数
  对于回归问题，我们通常都是采用平方误差函数作为损失函数

#predict为模型的预测值,true_label表示数据对应的真实标签
paddle.nn.functional.square_error_cost(predict,true_label)

• 优化器
  设置优化算法，优化算法我们采用SGD

#设置学习率
optimizer = paddle.optimizer.SGD(learning_rate=0.001,parameters=net.parameters())

• 绘制迭代次数随loss的变化关系

import matplotlib.pyplot as plt

def draw_loss_change(epoch_list,loss_list,title):
    plt.title(title,fontsize=24)
    plt.xlabel("epoch",fontsize=24)
    plt.ylabel("loss",fontsize=24)
    plt.plot(epoch_list,loss_list,color="red",label="loss")
    plt.grid()
    plt.show()

• 模型的验证

def evaluate(model):
    #用来统计模型在验证集上的loss
    val_total_loss = 0
    val_batch_num = 0
    for batch_id,batch_data in enumerate(val_dataloader):
        batch_input = paddle.to_tensor(batch_data[0])
        batch_label = paddle.to_tensor(batch_data[1])
        batch_output = model(batch_input)
        #计算batch data上的loss
        batch_loss = paddle.mean(paddle.nn.functional.square_error_cost(batch_output,batch_label)).numpy()[0]
        val_total_loss += batch_loss
        val_batch_num += 1
    return val_total_loss / val_batch_num

• 训练模型

def train():
    #记录每个epoch训练集loss的变化情况
    epoch_list = []
    train_loss_list = []
    val_loss_list = []
    #用来保存最小的loss
    best_val_loss = 1000
    #定义迭代的轮数
    EPOCH_NUM = 100
    for epoch in range(EPOCH_NUM):
        #用来统计total loss和计算每个epoch的平均loss
        epoch_total_loss = 0
        epoch_batch_num = 0
        for batch_idx,batch_data in enumerate(train_dataloader):
            batch_input = paddle.to_tensor(batch_data[0])
            batch_label = paddle.to_tensor(batch_data[1])
            #获取数据的预测结果
            batch_output = model(batch_input)
            #计算数据的平均loss
            batch_loss = paddle.mean(paddle.nn.functional.square_error_cost(batch_output,batch_label))
        
            #计算batch loss的梯度
            batch_loss.backward()
            #更新参数
            optimizer.step()
            #梯度清零
            optimizer.clear_grad()

            epoch_total_loss += batch_loss.numpy()[0]
            epoch_batch_num += 1
        
        #计算epoch loss
        epoch_loss = epoch_total_loss / epoch_batch_num
        epoch_list.append(epoch+1)
        train_loss_list.append(epoch_loss)
        
        #计算模型在验证集上的loss
        val_loss = evaluate(model)
        if val_loss < best_val_loss:
            paddle.save(model.state_dict(),"best_fit.pdparams")

        print("epoch num:{},train loss:{:.2f},val loss:{:.2f}".format(epoch+1,epoch_loss,val_loss))
             
    #绘制loss和epoch的变化
    draw_loss_change(epoch_list,train_loss_list,title="train loss")

• 模型预测

def draw_predict_grounds(ground_truths,predict_results,title="Boston"):
    plt.title(title,fontsize=24)
    
    x = np.arange(1,30)
    y = x
    plt.plot(x,y,color="red")
    plt.xlabel("ground truth",fontsize=14)
    plt.ylabel("predict result",fontsize=14)
    plt.scatter(ground_truths,predict_results,color="green",label="ground-predict cost")
    plt.grid()
    plt.show()


import paddle

#加载验证集
valid_dataset = paddle.text.UCIHousing(mode="test")
valid_data_loader = paddle.io.DataLoader(valid_dataset,batch_size=200)

#加载模型
model = paddle.nn.Linear(13,1)
param = paddle.load("best_fit.pdparams")
model.set_dict(param)

#用来保存模型的预测结果和真实值
predict_results = []
groud_truths = []

for batch_data in valid_data_loader:
    batch_input = paddle.to_tensor(batch_data[0])
    batch_predict = model(batch_input).numpy()

    predict_results.extend(batch_predict)
    groud_truths.extend(batch_data[1].numpy())

predict_results = np.squeeze(np.array(predict_results))
groud_truths = np.squeeze(np.array(groud_truths))


draw_predict_grounds(groud_truths,predict_results)