模型

模型

关注
发信
关注(28)粉丝(399)

PaddlePaddle的基本使用

PaddlePaddle的基本使用

PaddlePaddle

基础

安装：

基本操作：

  • 导入：import paddle.fluid as fluid
  • 定义数据：
  1. # 定义数组维度及数据类型，可以修改shape参数定义任意大小的数组
  2. data = fluid.layers.ones(shape=[5], dtype='int64')
  3. # 在CPU上执行运算
  4. place = fluid.CPUPlace()
  5. # 创建执行器
  6. exe = fluid.Executor(place)
  7. # 执行计算
  8. ones_result = exe.run(fluid.default_main_program(),
  9.                         # 获取数据data
  10.                         fetch_list=[data],
  11.                         return_numpy=True)
  12. # 输出结果
  13. print(ones_result[0])
  • 操作数据：
  1. # 调用 elementwise_op 将生成的一维数组按位相加
  2. add = fluid.layers.elementwise_add(data,data)
  3. # 定义运算场所
  4. place = fluid.CPUPlace()
  5. exe = fluid.Executor(place)
  6. # 执行计算
  7. add_result = exe.run(fluid.default_main_program(),
  8.                  fetch_list=[add],
  9.                  return_numpy=True)
  10. # 输出结果
  11. print (add_result[0])

线性回归

  1. #加载库
  2. import paddle.fluid as fluid
  3. import numpy as np
  5. #生成数据
  6. np.random.seed(0) # 设置随机种子
  7. outputs = np.random.randint(5, size=(10, 4))
  8. res = []
  9. for i in range(10):
  10.         # 假设方程式为 y=4a+6b+7c+2d
  11.         y = 4*outputs[i][0]+6*outputs[i][1]+7*outputs[i][2]+2*outputs[i][3]
  12.         res.append([y])

上面这段代码产生了10个随机向量，每个向量包含4个元素：
然后根据向量算得一组y：

  1. # 定义数据
  2. train_data=np.array(outputs).astype('float32')
  3. y_true = np.array(res).astype('float32')
  4. #定义网络
  5. x = fluid.layers.data(name="x",shape=[4],dtype='float32')
  6. y = fluid.layers.data(name="y",shape=[1],dtype='float32')
  7. y_predict = fluid.layers.fc(input=x,size=1,act=None)

在这段代码中可以很清晰地看到样本的输入/输出空间
用机器学习的方式来表达就是：样本特征维数为4，样本数为10

  1. #定义损失函数
  2. cost = fluid.layers.square_error_cost(input=y_predict,label=y)
  3. avg_cost = fluid.layers.mean(cost)
  4. #定义优化方法
  5. sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.05)
  6. sgd_optimizer.minimize(avg_cost)

fluid.layers层包含了各种数据及其操作的定义，这里我们用到了平方差和平均值
fluid.optimizer对优化方法进行了封装，损失函数和学习率是它的输入
这里要注意梳理各个方法之间的抽象关系

  1. #参数初始化
  2. cpu = fluid.CPUPlace()
  3. exe = fluid.Executor(cpu)
  4. exe.run(fluid.default_startup_program())
  5. ##开始训练，迭代500次
  6. for i in range(500):
  7.         outs = exe.run(
  8.                 feed={'x':train_data,'y':y_true},
  9.                 fetch_list=[y_predict.name,avg_cost.name])
  10.         if i%50==0:
  11.                 print ('iter={:.0f},cost={}'.format(i,outs[1][0]))

feed代表训练数据（训练集），fetch_list定义了运算过程，这里我们传入了模型结构和损失函数。有了这几个要素，我们就可以对模型进行训练了。

  1. #存储训练结果
  2. params_dirname = "result"
  3. fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)
  5. # 开始预测
  6. infer_exe = fluid.Executor(cpu)
  7. inference_scope = fluid.Scope()
  8. # 加载训练好的模型
  9. with fluid.scope_guard(inference_scope):
  10.         [inference_program, feed_target_names,
  11.          fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe)
  13. # 生成测试数据
  14. test = np.array([[[9],[5],[2],[10]]]).astype('float32')
  15. # 进行预测
  16. results = infer_exe.run(inference_program,
  17.                                                 feed={"x": test},
  18.                                                 fetch_list=fetch_targets)
  19. # 给出题目为 【9,5,2,10】 输出y=4*9+6*5+7*2+10*2的值
  20. print ("9a+5b+2c+10d={}".format(results[0][0]))

波士顿房价预测

Step1：准备数据

  1. BUF_SIZE=500
  2. BATCH_SIZE=20
  4. #用于训练的数据提供器，每次从缓存中随机读取批次大小的数据
  5. train_reader = paddle.batch(
  6.     paddle.reader.shuffle(paddle.dataset.uci_housing.train(), 
  7.                           buf_size=BUF_SIZE),                    
  8.     batch_size=BATCH_SIZE)   
  9. #用于测试的数据提供器，每次从缓存中随机读取批次大小的数据
  10. test_reader = paddle.batch(
  11.     paddle.reader.shuffle(paddle.dataset.uci_housing.test(),
  12.                           buf_size=BUF_SIZE),
  13.     batch_size=BATCH_SIZE)
  • uci-housing数据集共506行,每行14列。前13列用来描述房屋的各种信息，最后一列为该类房屋价格中位数
  • 读取uci_housing训练集和测试集:
    • paddle.dataset.uci_housing.train()
    • paddle.dataset.uci_housing.test()
  • paddle.reader.shuffle()表示每次缓存BUF_SIZE个数据项，并进行打乱
  • paddle.batch()表示每BATCH_SIZE组成一个batch
  1. # 打印数据
  2. train_data=paddle.dataset.uci_housing.train();
  3. sampledata=next(train_data())
  4. print(sampledata)

Step2：网络配置

网络配置包括3块内容：1. 模型定义，2. 损失函数，3. 优化方法

模型定义

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

注意：paddle文档中把数据向量称之为‘张量’(tensor)，暂时还不知道为啥要这么称呼。不过就目前来看，这个玩意和向量没啥区别

损失函数

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

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

优化方法

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

在模型配置完毕后，我们可以得到两个fluid.Program：

  • fluid.default_startup_program()
    • fluid.default_startup_program()用于执行参数初始化操作
  • fluid.default_main_program()
    • fluid.default_main_program()用于获取默认或全局main program(主程序)。
    • 该主程序用于训练和测试模型。fluid.layers 中的所有layer函数可以向 default_main_program 中添加算子和变量。
    • default_main_program 是fluid的许多编程接口（API）的Program参数的缺省值。例如,当用户program没有传入的时候， Executor.run() 会默认执行 default_main_program 。

Step3：模型训练 and Step4：模型评估

Step5：模型预测

12-25 12:33
Powered by LMLPHP ©2024 模型 0.065315