PaddlePaddle的簡單使用

目錄

• 基礎
• 線性回歸
• 波士頓房價預測
  • Step1：准備數據
  • Step2：網絡配置
    • 模型定義
    • 損失函數
    • 優化方法
  • Step3：模型訓練 and Step4：模型評估
  • Step5：模型預測

基礎

安裝：

• pip install -U paddlepaddle
• GPU版本參考：安裝說明

基本操作：

• 導入：import paddle.fluid as fluid
• 定義數據：

# 定義數組維度及數據類型，可以修改shape參數定義任意大小的數組
data = fluid.layers.ones(shape=[5], dtype='int64')
# 在CPU上執行運算
place = fluid.CPUPlace()
# 創建執行器
exe = fluid.Executor(place)
# 執行計算
ones_result = exe.run(fluid.default_main_program(),
                        # 獲取數據data
                        fetch_list=[data],
                        return_numpy=True)
# 輸出結果
print(ones_result[0])

• 操作數據：

# 調用 elementwise_op 將生成的一維數組按位相加
add = fluid.layers.elementwise_add(data,data)
# 定義運算場所
place = fluid.CPUPlace()
exe = fluid.Executor(place)
# 執行計算
add_result = exe.run(fluid.default_main_program(),
                 fetch_list=[add],
                 return_numpy=True)
# 輸出結果
print (add_result[0])

線性回歸

#加載庫
import paddle.fluid as fluid
import numpy as np

#生成數據
np.random.seed(0) # 設置隨機種子
outputs = np.random.randint(5, size=(10, 4))
res = []
for i in range(10):
        # 假設方程式為 y=4a+6b+7c+2d
        y = 4*outputs[i][0]+6*outputs[i][1]+7*outputs[i][2]+2*outputs[i][3]
        res.append([y])

上面這段代碼產生了10個隨機向量，每個向量包含4個元素：\(a,b,c,d \in (0,5)\)
然后根據向量算得一組y：\(y=4a+6b+7c+2d\)

# 定義數據
train_data=np.array(outputs).astype('float32')
y_true = np.array(res).astype('float32')
#定義網絡
x = fluid.layers.data(name="x",shape=[4],dtype='float32')
y = fluid.layers.data(name="y",shape=[1],dtype='float32')
y_predict = fluid.layers.fc(input=x,size=1,act=None)

在這段代碼中可以很清晰地看到樣本的輸入/輸出空間
用機器學習的方式來表達就是：樣本特征維數為4，樣本數為10

#定義損失函數
cost = fluid.layers.square_error_cost(input=y_predict,label=y)
avg_cost = fluid.layers.mean(cost)
#定義優化方法
sgd_optimizer = fluid.optimizer.SGD(learning_rate=0.05)
sgd_optimizer.minimize(avg_cost)

fluid.layers層包含了各種數據及其操作的定義，這里我們用到了平方差和平均值
fluid.optimizer對優化方法進行了封裝，損失函數和學習率是它的輸入
這里要注意梳理各個方法之間的抽象關系

#參數初始化
cpu = fluid.CPUPlace()
exe = fluid.Executor(cpu)
exe.run(fluid.default_startup_program())
##開始訓練，迭代500次
for i in range(500):
        outs = exe.run(
                feed={'x':train_data,'y':y_true},
                fetch_list=[y_predict.name,avg_cost.name])
        if i%50==0:
                print ('iter={:.0f},cost={}'.format(i,outs[1][0]))

feed代表訓練數據（訓練集），fetch_list定義了運算過程，這里我們傳入了模型結構和損失函數。有了這幾個要素，我們就可以對模型進行訓練了。

#存儲訓練結果
params_dirname = "result"
fluid.io.save_inference_model(params_dirname, ['x'], [y_predict], exe)

# 開始預測
infer_exe = fluid.Executor(cpu)
inference_scope = fluid.Scope()
# 加載訓練好的模型
with fluid.scope_guard(inference_scope):
        [inference_program, feed_target_names,
         fetch_targets] = fluid.io.load_inference_model(params_dirname, infer_exe)

# 生成測試數據
test = np.array([[[9],[5],[2],[10]]]).astype('float32')
# 進行預測
results = infer_exe.run(inference_program,
                                                feed={"x": test},
                                                fetch_list=fetch_targets)
# 給出題目為 【9,5,2,10】 輸出y=4*9+6*5+7*2+10*2的值
print ("9a+5b+2c+10d={}".format(results[0][0]))

波士頓房價預測

Step1：准備數據

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)

• 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

# 打印數據
train_data=paddle.dataset.uci_housing.train();
sampledata=next(train_data())
print(sampledata)

Step2：網絡配置

網絡配置包括3塊內容：1. 模型定義，2. 損失函數，3. 優化方法

模型定義

#定義輸入向量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)

注意：paddle文檔中把數據向量稱之為‘張量’(tensor)，暫時還不知道為啥要這么稱呼。不過就目前來看，這個玩意和向量沒啥區別

損失函數

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

square_error_cost(input,lable):接受輸入預測值和目標值，並返回方差估計,即為（y-y_predict）的平方

優化方法

optimizer = fluid.optimizer.SGDOptimizer(learning_rate=0.001)
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：模型評估

創建Executor

• 定義運算場所 fluid.CPUPlace() 或 fluid.CUDAPlace(0)
• 上面兩條語句分別表示運算場所為CPU或GPU
• Executor:接收傳入的program，通過run()方法運行program

use_cuda = False                         #use_cuda為False,表示運算場所為CPU;use_cuda為True,表示運算場所為GPU           
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(),進行參數初始化

定義輸入數據維度

• DataFeeder負責將數據提供器（train_reader,test_reader）返回的數據轉成一種特殊的數據結構，使其可以輸入到Executor中
• 參數feed_list用於設置向模型輸入的向變量表或者變量表名

# 定義輸入數據維度
feeder = fluid.DataFeeder(place=place, feed_list=[x, y])  # feed_list:向模型輸入的變量表或變量表名

• 定義繪制訓練過程的損失值變化趨勢的方法draw_train_process

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()

訓練並保存模型

• Executor接收傳入的program,並根據feed map(輸入映射表)和fetch_list(結果獲取表) 向program中添加feed operators(數據輸入算子)和fetch operators（結果獲取算子)。 feed map為該program提供輸入數據。fetch_list提供program訓練結束后用戶預期的變量。

• 注：enumerate() 函數用於將一個可遍歷的數據對象(如列表、元組或字符串)組合為一個索引序列，同時列出數據和數據下標

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)

Step5：模型預測

infer_exe = fluid.Executor(place)    #創建推測用的executor
inference_scope = fluid.core.Scope() #Scope指定作用域

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()
    
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)