PaddlePaddle实现线性回归

╰半橙微兮° 2023-06-10 12:29 32阅读 0赞

**知识点回顾**  
*机器学习是怎么一个工作过程呢？*  
是这样的：  
我们首先输入训练数据集，利用特定的机器学习方法建立估计函数，并进行训练。训练后得到一个模型。然后向这一模型输入测试数据集，函数有能力对没有见过的数据进行正确估计，这就是机器学习的过程。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70]

## 第一阶段：训练阶段 ##

**1 - 引用库**  
首先载入需要用到的库，它们分别是：

> **paddle.fluid**：引入PaddlePaddle深度学习框架的fluid版本库；

> **numpy**：NumPy是Python语言的一个扩展程序库。支持高端大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。NumPy的核心功能是"ndarray"(即n-dimensional array，多维数组)数据结构。

> **os**: python的模块，可使用该模块对操作系统、目录、文件等进行操作

> **matplotlib.pyplot**：用于生成图，在验证模型准确率和展示成本变化趋势时会使用到

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

## 2 - 数据集介绍 ##

> 本次所用数据集已经集成在paddle.dataset中了，并且已经为我们拆分成了训练集和测试集；我们可以通过调用paddle.dataset.uci\_housing.train()和paddle.dataset.uci\_housing.test()两个接口来获取训练集和测试集，非常的方便。

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

## 3 - 数据提供器 ##

> 接下来我们通过paddle.batch这个接口，来定义数据提供器：train\_reader和test\_reader。分别向我们的网络提供训练数据和测试数据。

> 提供器每次读入一个大小为BATCH\_SIZE的数据批次。如果用户希望加一些随机性，它可以同时定义一个批次大小和一个缓存大小。这样的话，每次数据提供器会从缓存中随机读取批次大小那么多的数据。我们都可以通过batch\_size进行设置，这个大小一般是2的N次方。

**关于参数的解释如下：**

*`paddle.reader.shuffle(train(), buf_size=500)`表示`trainer`从`train()`这个`reader`中读取了`buf_size=500`大小的数据并打乱顺序  
`paddle.batch(reader(), batch_size=BATCH_SIZE)`表示从打乱的数据中再取出`BATCH_SIZE=20`大小的数据进行一次迭代训练  
如果`buf_size`设置的数值大于数据集本身，就直接把整个数据集打乱顺序；如果`buf_size`设置的数值小于数据集本身，就按照`buf_size`的大小打乱顺序。*

BUF_SIZE=500
    BATCH_SIZE=20
    
    #用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
    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)

## 4 - 配置网络结构和设置参数 ##

**配置网络结构:**

> 线性回归的模型其实就是一个采用线性激活函数（linear activation）的全连接层（fully-connected layer，fc\_layer），因此在Peddlepeddle中利用全连接层模型构造线性回归，这样一个全连接层就可以看做是一个简单的神经网络，只包含输入层和输出层即可。本次的模型由于只有一个影响参数，因此输入只含一个 X 0 X\_0 X0 。  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 1]  
> 接下来就让我们利用PaddlePaddle提供的接口，搭建我们自己的网络吧！

> 输入层:  
> 我们可以用 `x = fluid.layers.data(name='x', shape=[13], dtype='float32')`来表示数据的一个输入层，其中name属性的名称为"x"，数据的shape为13维向量，这是因为本次所用的房价数据集的每条数据有13个属性，所以shape=13。

> 输出层:  
> 用`y_predict = fluid.layers.fc(input=x, size=1, act=None)`来表示输出层：其中paddle.layer.fc表示全连接层，input=x表示该层输入数据为x，size=1表示该层有一个神经元，在Fluid版本中使用的激活函数不再是调用一个函数了，而是传入一个字符串就可以，比如：act='relu’就表示使用relu激活函数。act=None表示激活函数为线性激活函数。

> 标签层:  
> 用y = fluid.layers.data(name=‘y’, shape=\[1\], dtype=‘float32’)来表示标签数据，名称为y，有时我们名称不用y而用label。数据类型为一维向量。

#定义张量变量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)

## 5 - 定义损失函数 ##

> PaddlePaddle提供了很多的损失函数的接口，比如交叉熵损失函数(cross\_entropy)。因为本项目是一个线性回归任务，所以我们使用的是均方差损失函数。可以调用`fluid.layers.square_error_cost(input= ,laybel= )`实现方差计算。因为`fluid.layers.square_error_cost(input= ,laybel= )`求的是一个Batch的损失值，所以我们还要通过调用fluid.layers.mean(loss)对方差求平均。

> 将输入定义为 房价预测值，label定义为 标签数据。进而计算损失值。

cost = fluid.layers.square_error_cost(input=y_predict, label=y) #求一个batch的损失值
    avg_cost = fluid.layers.mean(cost)    #对损失值求平均值

## 6 - 优化方法 ##

> 损失函数定义确定后，需要定义参数优化方法。为了改善模型的训练速度以及效果，学术界先后提出了很多优化算法，包括： Momentum、RMSProp、Adam 等，已经被封装在fluid内部，读者可直接调用。本次可以用 `fluid.optimizer.SGD(learning_rate= )` 使用随机梯度下降的方法优化，其中learning\_rate表示学习率，大家可以自己尝试修改。

optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
    opts = optimizer.minimize(avg_cost)

> fluid有两个program，一个是`default_main_program`，一个是`default_startup_program`;  
> fluid.default\_main\_program()用于获取默认或全局main program(主程序)。该主程序用于训练和测试模型。fluid.layers 中的所有layer函数可以向 `default_main_program` 中添加算子和变量。

> 参数初始化操作会被写入`fluid.default_startup_program();`  
> 使用`fluid.default_main_program().clone(for_test=True)`语句，我们可以克隆一个default\_main\_program，以备将来测试时使用。

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

## 7 - 设置训练场所+创建执行器+参数初始化 ##

**设置训练场所：**

> 首先进行设置训练使用的设备。也就是选择是在CPU上进行训练，还是在GPU上进行训练。在复杂量较低的时候使用 CPU 就可以完成任务，但是对于大规模计算就需要使用 GPU 训练。目前 GPU 训练都是基于 CUDA 工具之上的。

> 代码实现也很简单，我们使用两行代码就可以实现，如下面所示：

use_cuda=False 表示不使用 GPU 进行训练

**创建执行器：**

> 为了能够运行开发者定义的网络拓扑结构和优化器，需要定义执行器。由执行器来真正的执行参数的初始化和网络的训练过程。fulid使用了一个C++类Executor用于运行一个程序，Executor类似一个解释器，Fluid将会使用这样一个解析器来训练和测试模型。

> 之后我们run一下，初始化执行器； 用户配置完模型后，参数初始化操作会被写入到 `fluid.default_startup_program()` 中。 使用 `fluid.Executor()` 运行 这一程序，即可在全局中随机初始化参数。

#使用CPU训练
    use_cuda = False
    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace() 
    exe = fluid.Executor(place)              #创建一个Executor实例exe
    exe.run(fluid.default_startup_program()) #Executor的run()方法执行startup_program(),进行参数初始化

**接下来定义映射**

> 输入网络的数据要与网络本身应该接受的数据相匹配。在paddle的 fluid 中使用 `feed_list` 的概念来保证输入的数据与网络接受的数据的顺序是一致的。本示例中使用 `feed_list = [x,y]` 来告知网络，输入的数据是分为两部分，第一部分是 x 值，第二部分是 label 值。

> 映射完之后，创建 `DataFeeder` 对象，在训练的时候，用户可调用其 feeder.feed(iterable) 方法将用户传入的iterable 数据转换为 LoDTensor。

# 定义feeder 
    feeder = fluid.DataFeeder(place=place, feed_list=[x, y])#feed_list:向模型输入的变量名

> 为了便于观察训练过程，我们可以定义一个绘制函数，用来把“训练过程的损失值变化趋势”实时的展示出来：

iter=0;
    iters=[]
    train_costs=[]
    
    def plot_train_cost(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='blue',label='training cost') 
        plt.grid()
        plt.show()

## 8 - 开始训练 ##

> 接下来我们就是用双层循环，来进行训练；  
> 在训练之前还要定义一个模型保存路径，用来保存我们训练好的模型；  
> 我们还要定义一个变量，来规定训练的总epoch；

EPOCH_NUM=100
    model_save_dir = "/home/aistudio/data/model_save_dir/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(),#运行主程
     #喂入一个batch的训练数据，根据feed_list和data提供的信息，将输入数据转成一种特殊的数据结构
                                 feed=feeder.feed(data),              
                                 fetch_list=[avg_cost])     
            #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迭代器
            print("batch_id:%d" % (batch_id))
            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
    plot_train_cost(iters,train_costs)

运行截图

batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:0, Cost:12.97408
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:1, Cost:8.27916
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:2, Cost:16.52091
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:3, Cost:6.78491
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    
    Test:66, Cost:3.09493
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:67, Cost:16.64656
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:68, Cost:5.22725
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:69, Cost:3.34186
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:70, Cost:5.03149
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    Test:71, Cost:14.10795
    save models to /home/aistudio/data/model_save_dir/inference.model
    batch_id:0
    batch_id:1
    batch_id:2
    batch_id:3
    batch_id:4
    batch_id:5
    ...
    ...
    ...
    Test:72, Cost:34.10251
    save models to /home/aistudio/data/model_save_dir/inference.model

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 2]

# 第二阶段： 预测阶段 #

我们同样可以定义一个画图的函数，把我们的预测结果展示出来

#先定两个list，用来存放预测结果、真实值；
    infer_results=[]
    groud_truths=[]
    
    #绘制真实值和预测值对比图
    def plot_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='red',label='training cost') 
        plt.grid()
        plt.show()

#预测之前，我们需要创建预测用的Executor
    infer_exe = fluid.Executor(place)    #创建推测用的executor
    inference_scope = fluid.core.Scope() #Scope指定作用域
    
    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)   #从测试数据中读取一个大小为10的batch数据
        #从test_reader中分割x和label
        test_data = next(infer_reader())
        test_x = np.array([data[0] for data in test_data]).astype("float32") # 提取测试集中的x
        test_y= np.array([data[1] for data in test_data]).astype("float32")  # 提取测试集中的label
        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)
        plot_infer_result(groud_truths,infer_results)

运行结果

infer results: (House Price)
    0: -0.87
    1: -0.92
    2: -0.56
    3: -0.64
    4: -0.66
    5: -0.84
    6: -0.87
    7: -0.89
    8: -0.76
    9: -0.69
    10: -0.92
    11: -1.00
    12: -1.00
    13: -0.85
    14: -1.10
    15: -1.03
    16: -0.79
    17: -0.74
    18: -0.63
    19: -0.85
    20: -0.74
    21: -0.91
    22: -0.78
    23: -0.98
    24: -0.87
    25: -0.91
    26: -0.78
    27: -0.85
    28: -0.75
    29: -0.87
    30: -0.87
    31: -0.97
    32: -0.98
    33: -1.00
    34: -1.00
    35: -0.73
    36: -0.80
    37: -0.80
    38: -0.74
    39: -0.80
    40: -0.84
    41: -0.99
    42: -0.80
    43: -0.76
    44: -0.73
    45: -0.80
    46: -0.96
    47: -0.78
    48: -0.73
    49: -0.85
    50: -0.97
    51: -0.91
    52: -0.87
    53: -0.87
    54: -0.78
    55: -0.69
    56: -0.82
    57: -0.71
    58: -0.71
    59: -0.70
    60: -0.66
    61: -0.64
    62: -0.79
    63: -0.62
    64: -0.63
    65: -0.58
    66: -0.57
    67: -0.51
    68: -0.60
    69: -0.70
    70: -0.54
    71: -0.68
    72: -0.66
    73: -0.63
    74: -0.65
    75: -0.66
    76: -0.52
    77: -0.55
    78: -0.58
    79: -0.46
    80: -0.55
    81: -0.57
    82: -0.56
    83: -0.55
    84: -0.29
    85: -0.34
    86: -0.35
    87: -0.34
    88: -0.32
    89: 0.18
    90: 0.13
    91: 0.13
    92: 0.18
    93: 0.18
    94: 0.15
    95: 0.19
    96: 0.15
    97: 0.44
    98: 0.50
    99: 0.44
    100: 0.46
    101: 0.53
    ground truth:
    0: 8.50
    1: 5.00
    2: 11.90
    3: 27.90
    4: 17.20
    5: 27.50
    6: 15.00
    7: 17.20
    8: 17.90
    9: 16.30
    10: 7.00
    11: 7.20
    12: 7.50
    13: 10.40
    14: 8.80
    15: 8.40
    16: 16.70
    17: 14.20
    18: 20.80
    19: 13.40
    20: 11.70
    21: 8.30
    22: 10.20
    23: 10.90
    24: 11.00
    25: 9.50
    26: 14.50
    27: 14.10
    28: 16.10
    29: 14.30
    30: 11.70
    31: 13.40
    32: 9.60
    33: 8.70
    34: 8.40
    35: 12.80
    36: 10.50
    37: 17.10
    38: 18.40
    39: 15.40
    40: 10.80
    41: 11.80
    42: 14.90
    43: 12.60
    44: 14.10
    45: 13.00
    46: 13.40
    47: 15.20
    48: 16.10
    49: 17.80
    50: 14.90
    51: 14.10
    52: 12.70
    53: 13.50
    54: 14.90
    55: 20.00
    56: 16.40
    57: 17.70
    58: 19.50
    59: 20.20
    60: 21.40
    61: 19.90
    62: 19.00
    63: 19.10
    64: 19.10
    65: 20.10
    66: 19.90
    67: 19.60
    68: 23.20
    69: 29.80
    70: 13.80
    71: 13.30
    72: 16.70
    73: 12.00
    74: 14.60
    75: 21.40
    76: 23.00
    77: 23.70
    78: 25.00
    79: 21.80
    80: 20.60
    81: 21.20
    82: 19.10
    83: 20.60
    84: 15.20
    85: 7.00
    86: 8.10
    87: 13.60
    88: 20.10
    89: 21.80
    90: 24.50
    91: 23.10
    92: 19.70
    93: 18.30
    94: 21.20
    95: 17.50
    96: 16.80
    97: 22.40
    98: 20.60
    99: 23.90
    100: 22.00
    101: 11.90

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70]: /images/20230531/0ae7ab9a1fca4d9d94372141ee8ef3dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 1]: /images/20230531/f532da9485d247a5adf0b438b209033f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 2]: /images/20230531/49c4b5ed048440a883fad549bb816ff6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0NDQ3J1bm5lcg_size_16_color_FFFFFF_t_70 3]: /images/20230531/32764d289d18465b893d3e3c52fb0a20.png