人工智能与大数据—线性回归之波士顿房价预测

一,首先导入必要的包

1,paddle.fluid--->PaddlePaddle深度学习框架

2,numpy---------->python基本库,用于科学计算

3,os------------------>python的模块,可使用该模块对操作系统进行操作

4,matplotlib----->python绘图库,可方便绘制折线图、散点图等图形

具体操作:

import paddle.fluid as fluid
import paddle
import numpy as np
import os
import matplotlib.pyplot as plt

二,准备数据

1,uci-housing 数据集介绍

  数据集共506行,每行14列。前13列用来描述房屋的各种信息,最后一列为该类房屋价格中位数

补充:

2,数据集的训练和测试

补充

数据训练集和测试集的区别:

一部分称之为训练集,用以学习数据的特征属性,这部分数据需要人工标定,为数据生成标签

另一部分称为测试集,测试集不需要人工处理,用于测试结果

PaddlePaddle提供了读取uci_housing训练集和测试集的接口。

分别为:

  • paddle.dataset.uci_housing.train()
  • paddle.dataset.uci_housing.test()

PaddlePaddle提供了读取uci_housing数据处理大小和取出训练大小。

  • paddle.reader.shuffle()    表示每次缓存BUF_SIZE个数据项,并进行打乱
  • paddle.batch()                  表示每BATCH_SIZE组成一个batch

具体操作:

BUF_SIZE=500    表示每次缓存BUF_SIZE个数据项,并进行打乱
BATCH_SIZE=20  表示每BATCH_SIZE组成一个batch

#用于训练的数据提供器,每次从缓存中随机读取批次大小的数据
train_reader = paddle.batch(
    paddle.reader.shuffle(paddle.dataset.uci_housing.train(),buf_size=BUF_SIZE),
       batch_size=BATCH_SIZE)   
#用于测试的数据提供器,每次从缓存中随机读取批次大小的数据
test_reader = paddle.batch(
    paddle.reader.shuffle(paddle.dataset.uci_housing.test(),buf_size=BUF_SIZE),
    batch_size=BATCH_SIZE)  

三,函数的准备

1,假设函数

具体操作:

#(1)假设函数的准备
#定义张量变量x,表示13维的特征值
x = fluid.layers.data(name='x', shape=[13], dtype='float32')
#定义张量y,表示目标值
y = fluid.layers.data(name='y', shape=[1], dtype='float32')
#定义一个简单的线性网络,连接输入和输出的全连接层
#input:输入tensor;
#size:该层输出单元的数目
#act:激活函数
y_predict=fluid.layers.fc(input=x,size=1,act=None)

2,损失函数的准备

此处使用均方差损失函数

square_error_cost(input,lable):接受输入预测值和目标值,并返回方差估计,即为(y-y_predict)的平方

具体操作:

#(2)损失函数的准备
#求一个batch的损失值,cost为(y-y_predict)的平方
cost = fluid.layers.square_error_cost(input=y_predict, label=y)
#对损失值求平均值,即均方差
avg_cost = fluid.layers.mean(cost)  

3,梯度下降函数的准备

                          

具体操作:

#(3)梯度下降函数的准备(采用随机梯度下降)
optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
#采用optimizer.minimize(均方差)进行优化
opts = optimizer.minimize(avg_cost)

4,函数准备完成后,会获得两个fluid.Program

分别是:

  • fluid.default_startup_program()    参数初始化操作会被写入
  • fluid.default_startup_program()   用来获取默认或全局main program主程序,该主程序用于训练和测试模型

具体操作:

test_program = fluid.default_main_program().clone(for_test=True)

四,模型训练

1,创建一个运算场所

首先定义运算场所:

fluid.CPUPlace()表示运行场所在CPU

fluid.CUDAPlace(0)表示运算场所为GPU

Executor:接收传入的program,通过run()方法运行program

场所使用CPU和GPU的区别

CPU主要用于串行运算,一个规格一个规格的计算;而GPU则是大规模并行运算,所有数据一起计算。

具体操作:

#(1)创建模型运行的场所
#use_cuda为False,表示运算场所为CPU;use_cuda为True,表示运算场所为GPU 
use_cuda = False                         
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
#创建一个Executor实例exe
exe = fluid.Executor(place)              
#Executor的run()方法执行startup_program(),进行参数初始化
exe.run(fluid.default_startup_program()) 

2,定义输入训练数据维度

DataFeeder负责将数据提供器(train_reader,test_reader)返回的数据转成一种特殊的数据结构,使其可以输入到Executor中。

feed_list设置向模型输入的向变量表或者变量表名

具体操作:

#(2)定义输入数据维度
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])#feed_list:向模型输入的变量表或变量表名

3,定义绘制损失值变化趋势的函数

具体操作:

#(3)定义损失值变化的函数
iter=0;
iters=[]
train_costs=[]

def draw_train_process(iters,train_costs):
    title="training cost"
    plt.title(title, fontsize=24)
    plt.xlabel("iter", fontsize=14)
    plt.ylabel("cost", fontsize=14)
    plt.plot(iters, train_costs,color='red',label='training cost') 
    plt.grid()  #生成网格
    plt.show()  #显示图像

4,训练并保存模型

Executor接收传入的program,并根据feed map(输入映射表)和fetch_list(结果获取表) 向program中添加feed operators(数据输入算子)和fetch operators(结果获取算子)。

feed map为该program提供输入数据。

fetch_list提供program训练结束后用户预期的变量。

注:enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列,同时列出数据和数据下标,

具体操作:

#(4)训练并保存模型
EPOCH_NUM=50
model_save_dir = "/home/aistudio/work/fit_a_line.inference.model"

for pass_id in range(EPOCH_NUM):                                  #训练EPOCH_NUM轮
    # 开始训练并输出最后一个batch的损失值
    train_cost = 0
    for batch_id, data in enumerate(train_reader()):              #遍历train_reader迭代器
        train_cost = exe.run(program=fluid.default_main_program(),#运行主程序
                             feed=feeder.feed(data),              #喂入一个batch的训练数据,根据feed_list和data提供的信息,将输入数据转成一种特殊的数据结构
                             fetch_list=[avg_cost])    
        if batch_id % 40 == 0:
            print("Pass:%d, Cost:%0.5f" % (pass_id, train_cost[0][0]))    #打印最后一个batch的损失值
        iter=iter+BATCH_SIZE
        iters.append(iter)
        train_costs.append(train_cost[0][0])
       
   
    # 开始测试并输出最后一个batch的损失值

    test_cost = 0
    for batch_id, data in enumerate(test_reader()):               #遍历test_reader迭代器
        test_cost= exe.run(program=test_program, #运行测试cheng
                            feed=feeder.feed(data),               #喂入一个batch的测试数据
                            fetch_list=[avg_cost])                #fetch均方误差
    print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))     #打印最后一个batch的损失值
    
    #保存模型
    # 如果保存路径不存在就创建
if not os.path.exists(model_save_dir):
    os.makedirs(model_save_dir)
print ('save models to %s' % (model_save_dir))
#保存训练参数到指定路径中,构建一个专门用预测的program
fluid.io.save_inference_model(model_save_dir,   #保存推理model的路径
                                  ['x'],            #推理(inference)需要 feed 的数据
                                  [y_predict],      #保存推理(inference)结果的 Variables
                                  exe)              #exe 保存 inference model
draw_train_process(iters,train_costs)

五,模型预测

1,创建预测用的Executor

具体操作:

#(1)创建预测用的Executor
infer_exe = fluid.Executor(place)    #创建推测用的executor
inference_scope = fluid.core.Scope() #Scope指定作用域

2,可视化真实值与预测值方法的定义

具体操作:

#(2)可视化真实值与预测值方法定义
infer_results=[]
groud_truths=[]

#绘制真实值和预测值对比图
def draw_infer_result(groud_truths,infer_results):
    title='Boston'
    plt.title(title, fontsize=24)
    x = np.arange(1,20) 
    y = x
    plt.plot(x, y)
    plt.xlabel('ground truth', fontsize=14)
    plt.ylabel('infer result', fontsize=14)
    plt.scatter(groud_truths, infer_results,color='green',label='training cost') 
    plt.grid()
    plt.show()
    

3,开始预测

通过fluid.io.load_inference_model,预测器会从params_dirname中读取已经训练好的模型,来对从未遇见过的数据进行预测。

具体操作:

#(3)开始预测
with fluid.scope_guard(inference_scope):#修改全局/默认作用域(scope), 运行时中的所有变量都将分配给新的scope。
    #从指定目录中加载 推理model(inference model)
    [inference_program,                             #推理的program
     feed_target_names,                             #需要在推理program中提供数据的变量名称
     fetch_targets] = fluid.io.load_inference_model(#fetch_targets: 推断结果
                                    model_save_dir, #model_save_dir:模型训练路径 
                                    infer_exe)      #infer_exe: 预测用executor
    #获取预测数据
    infer_reader = paddle.batch(paddle.dataset.uci_housing.test(),  #获取uci_housing的测试数据
                          batch_size=200)                           #从测试数据中读取一个大小为200的batch数据
    #从test_reader中分割x
    test_data = next(infer_reader())
    test_x = np.array([data[0] for data in test_data]).astype("float32")
    test_y= np.array([data[1] for data in test_data]).astype("float32")
    results = infer_exe.run(inference_program,                              #预测模型
                            feed={feed_target_names[0]: np.array(test_x)},  #喂入要预测的x值
                            fetch_list=fetch_targets)                       #得到推测结果 
                            
    print("infer results: (House Price)")
    for idx, val in enumerate(results[0]):
        print("%d: %.2f" % (idx, val))
        infer_results.append(val)
    print("ground truth:")
    for idx, val in enumerate(test_y):
        print("%d: %.2f" % (idx, val))
        groud_truths.append(val)
    draw_infer_result(groud_truths,infer_results)

 

全部代码实现在如下链接:

https://aistudio.baidu.com/aistudio/projectdetail/161197

评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值