PaddlePaddle——线性回归

一.目标

1. 了解深度学习过程
2. 掌握深度学习执行流程

深度学习固定套路

深度学习的目的就是通过数据寻找一个合适的函数来解决实际问题

1. 假设函数：用数学的方法描述自变量和因变量之间的关系，它们之间可以是一个线性函数或非线性函数
2. 优化目标：做出假设后需要找到一个合适的损失函数计算误差，再逐步降低误差
3. 寻解算法：通过求导等数学方法如梯度下降，找到合适的参数让假设更接近实际的过程

深度学习基本概念

1. 全连接神经网络，如图所示

   
   
   1.png

2. 神经网络的传输过程

• 正向传播：由输入计算预测值的过程就是正向传播的过程

  
  
  2.png

• 反向传播：反向传播借助 链式法则 ，计算两个或两个以上复合函数的导数，将输出单元的梯度反向传播回输入单元，根据计算出的梯度，调整网络的可学习参数

  
  
  3.png

• 梯度下降：是反向传播中迭代更新参数的一种算法

3. 其他常见概念

• 损失函数：用数学的方法衡量假设函数预测结果与真实值之间的误差。这个差距越小预测越准确，而算法的任务就是使这个差距越来越小
• 激活函数：增加模型的非线性变化

波士顿房价代码实践

1.涉及的paddle的API整理

1.paddle.reader.shuffle(reader, buf_size)

参数：

• reader (callable)输出会被打乱的原始reader
• buf_size (int) – 打乱缓冲器的大小

返回： 输出会被打乱的reader

返回类型： callable

data = fluid.layers.data(name='x', shape=[784], dtype='float32')

• name (str)-函数名或函数别名

• shape (list)-声明维度信息的list。如果 append_batch_size 为True且内部没有维度值为-1，则应将其视为每个样本的形状。 否则，应将其视为batch数据的形状。

• dtype (basestring)-数据类型：float32,float_16,int等

# 当输入为单个张量时

data = fluid.layers.data(name="data", shape=[32, 32], dtype="float32")
fc = fluid.layers.fc(input=data, size=1000, act="tanh")

# 当输入为多个张量时
data_1 = fluid.layers.data(name="data_1", shape=[32, 32], dtype="float32")
data_2 = fluid.layers.data(name="data_2", shape=[24, 36], dtype="float32")
fc = fluid.layers.fc(input=[data_1, data_2], size=1000, act="tanh")

• input (Variable|list of Variable) – 该层的输入tensor(s)（张量），其维度至少是2
• size (int) – 该层输出单元的数目
• act (str, default None) – 应用于输出的Activation（激励函数）

y = fluid.layers.data(name='y', shape=[1], dtype='float32')
y_predict = fluid.layers.data(name='y_predict', shape=[1], dtype='float32')
cost = fluid.layers.square_error_cost(input=y_predict, label=y)

• input (Variable) - 输入张量（Tensor），带有预测值
• label (Variable) - 标签张量（Tensor），带有目标值

place=fluid.CUDAPlace(0)
feeder = fluid.DataFeeder(place=place, feed_list=[data, label])
reader = feeder.decorate_reader(
        paddle.batch(flowers.train(), batch_size=16))

• feed_list (list) – 向模型输入的变量表或者变量表名
• place (Place) – place表明是向GPU还是CPU中输入数据。如果想向GPU中输入数据, 请使用 fluid.CUDAPlace(i) (i 代表 the GPU id)；如果向CPU中输入数据, 请使用 fluid.CPUPlace()
• program (Program) – 需要向其中输入数据的Program。如果为None, 会默认使用 default_main_program()。 缺省值为None

train_cost = exe.run(program=fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost])   

• program (Program|CompiledProgram) – 需要执行的program,如果没有给定那么默认使用default_main_program (未编译的)
• feed (dict) – 前向输入的变量，数据,词典dict类型, 例如 {“image”: ImageData, “label”: LabelData}
• fetch_list (list) – 用户想得到的变量或者命名的列表, 该方法会根据这个列表给出结果

exe = fluid.Executor(fluid.CPUPlace())
path = "./infer_model"
fluid.io.save_inference_model(dirname=path, feeded_var_names=['img'],
             target_vars=[predict_var], executor=exe)

• dirname (str) – 保存预测model的路径
• feeded_var_names (list[str]) – 预测（inference）需要 feed 的数据
• target_vars (list[Variable]) – 保存预测（inference）结果的 Variables
• executor (Executor) – executor 保存 inference model

fluid.scope_guard(inference_scope)

• scope - 新的全局/默认 scope。

[inference_program,feed_target_names,fetch_targets] = fluid.io.load_inference_model(model_save_dir,infer_exe)  

返回: 这个函数的返回有三个元素的元组(Program，feed_target_names, fetch_targets)。Program 是一个 Program ，它是预测 Program。 feed_target_names 是一个str列表，它包含需要在预测 Program 中提供数据的变量的名称。fetch_targets 是一个 Variable 列表，从中我们可以得到推断结果。
2.线性回归代码

import paddle.fluid as fluid
import paddle
import os
BUF_SIZE=500
BATCH_SIZE=20
#定义神经网络
#定义特征值,目标值
x=fluid.layers.data(name='x',shape=[13],dtype='float32')
y=fluid.layers.data(name='y',shape=[1],dtype='float32')
#网络结构
hidden=fluid.layers.fc(input=x,size=100,act='relu')
y_predict=fluid.layers.fc(input=hidden,size=1,act=None)
#定义损失函数
cost = fluid.layers.square_error_cost(input=y_predict,label=y)
avg_cost=fluid.layers.mean(cost)
#优化器，梯度下降
optimizer=fluid.optimizer.SGDOptimizer(learning_rate=0.01)
opts=optimizer.minimize(avg_cost)
#定义执行器和program
place=fluid.CPUPlace()
exe=fluid.Executor(place)
#克隆一个program test用
clone=fluid.default_main_program().clone(for_test=True)
#参数初始化
exe.run(fluid.default_startup_program())

#定义读取数据的reader和feeder

#用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
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)
feeder=fluid.DataFeeder(place=place,feed_list=[x,y])

#训练与test

EPOCH_NUM = 50
model_save_dir = "work/fit_a_line.inference.model"


#循环次数
for pass_id  in range(EPOCH_NUM):
    train_cost=0
    for batch_id,data in enumerate(train_reader()):
        train_cost=exe.run(program=fluid.default_main_program(),feed=feeder.feed(data),fetch_list=[avg_cost])
        if batch_id % 40 == 0:
            print("Pass:%d, Cost:%.5f" % (pass_id, train_cost[0][0]))  # 打印最后一个batch的损失值

    test_cost = 0
    for batch_id, data in enumerate(test_reader()):  # 遍历test_reader迭代器
        test_cost = exe.run(program=clone,  # 运行测试cheng
                            feed=feeder.feed(data),  # 喂入一个batch的测试数据
                            fetch_list=[avg_cost])  # fetch均方误差
    print('Test:%d, Cost:%0.5f' % (pass_id, test_cost[0][0]))  # 打印最后一个batch的损失值

#保存模型
model_save_dir = "work/fit_a_line.inference.model"
if not os.path.exists(model_save_dir):
    os.makedirs(model_save_dir)
fluid.io.save_inference_model(model_save_dir,['x'],[y_predict],exe)

参考链接：
https://blog.csdn.net/qq_33200967/article/details/83448448
https://www.paddlepaddle.org.cn/documentation/docs/zh/1.4/beginners_guide/basics/fit_a_line/README.cn.html