プロペラ百度アーキテクチャの手はあなたのゼロの基礎の実践の深さを持って21日間の学習ノートを勉強します--プロペラを使ってボストンの住宅価格の予測モデルを書き直します

プロペラを使ってモデルを書く場合、前に紹介したのと同じ流れになります.次に、プロペラを使ってモデルを書く方法をまとめます.
プロペラライブラリのロード
メインライブラリ:paddle/fluidダイナミッククラスライブラリ:digraph(デバッグが容易)
スタティツクパターン(宣言式プログラミングパターン、クラス比C++)
ダイナミックパターン
先にコンパイルして実行する方法.計算結果を取得するには、ユーザーが完全なネットワーク構造を事前に定義してから、ネットワーク構造をコンパイルして最適化する必要があります.
解析式の実行方式.ユーザーは、完全なネットワーク構造を事前に定義する必要がなく、1行のネットワークコードを書くたびに、計算結果を同時に得ることができます.
全接続レイヤー:Linear(指定関数をアクティブ化可能)
データしょり
このセクションには、データのインポート、フォーマットの変更、トレーニングテストセットの分割、データ正規化処理が含まれます.プロペラで書くのは前と完全に一致しています.
モデル設計
実質的には線形回帰を定義する構造である.2つの関数、init関数、forward関数が必要です.
init
forward
クラスの初期化関数に各レイヤネットワークの実装関数を宣言します.
ニューラルネットワーク構造を構築し,順方向計算過程を実現し,予測結果を返す.
注意:ここではアクティブ化関数は使用しません
トレーニング構成

作業環境を定義する

定義モデル(訓練と予測状態がある)モデルの例は、訓練状態.train()と予測状態の2つの状態である.eval().訓練時には順方向計算と逆方向伝搬勾配の2つのプロセスを実行し,予測時には順方向計算のみを実行する.モデルの動作状態を指定するには、(1)一部の高度な演算子(Drop outやBatch Normalizationなど)がコンピュータの視覚の章で詳細に説明される)の2つの状態で実行される論理が異なる点があります.(2)性能と記憶空間の考慮から、状態を予測するとメモリが節約され、パフォーマンスが向上します.

訓練モード

をオンにする

データ

を読み出す.

最適化アルゴリズムSDGを定義し、学習率0.01

を定義する

は、2層サイクル+4つのステップ(まずnumpy.arrayフォーマットと書く)の訓練を開始する

.

モデルを保存して保存し、ロードしてからテストを行います.モデルは異なるシーンに適用できるからです.

モデルをロードし、予測(1)生産モデルインスタンスを行い、リソースを構成する.(2)モデルパラメータをロードし、モデル状態を「eval」に設定する(予測時に逆伝播勾配を必要としないため)(3)モデルを呼び出し、予測値と真実値

を印刷する
まとめ:作成コストの大幅な削減
悟り:プロペラは深い学習フレームワークを提供し、仕事の半分の効果を達成することができます.この章を勉強した後、実はコードの作成過程が大幅に減少したことを発見することができますが、プロペラのいくつかの関数の定義と呼び出しはまだ特にはっきりしていません.init関数とforward関数の定義ではまだ理解されていません.次の学習過程で、より良い理解と理解が必要です.
ボストンの住宅価格予測モデルをプロペラで書き換えるpythonを直接使用する例を以下に書きます.ここでは、完全な手順です.

#    、Numpy     
import paddle
import paddle.fluid as fluid
import paddle.fluid.dygraph as dygraph
from paddle.fluid.dygraph import Linear
import numpy as np
import os
import random

#    ，           ，                  
def load_data():
    #        
    datafile = './work/housing.data'
    data = np.fromfile(datafile, sep=' ')

    #       14 ，    13      ， 14            
    feature_names = [ 'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', \
                      'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT', 'MEDV' ]
    feature_num = len(feature_names)

    #        Reshape，  [N, 14]     
    data = data.reshape([data.shape[0] // feature_num, feature_num])

    #                
    #     80%      ，20%      
    #                
    ratio = 0.8
    offset = int(data.shape[0] * ratio)
    training_data = data[:offset]

    #   train       ，   ，   
    maximums, minimums, avgs = training_data.max(axis=0), training_data.min(axis=0), \
                                 training_data.sum(axis=0) / training_data.shape[0]
    
    #           ，           
    global max_values
    global min_values
    global avg_values
    max_values = maximums
    min_values = minimums
    avg_values = avgs

    #           
    for i in range(feature_num):
        #print(maximums[i], minimums[i], avgs[i])
        data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i])

    #             
    #ratio = 0.8
    #offset = int(data.shape[0] * ratio)
    training_data = data[:offset]
    test_data = data[offset:]
    return training_data, test_data

#        
class Regressor(fluid.dygraph.Layer):
    def __init__(self):
        super(Regressor, self).__init__()
        #       init
        #         ，     1，     None，        
        self.fc = Linear(input_dim=13, output_dim=1, act=None)
    
    #          
    def forward(self, inputs):
        x = self.fc(inputs)
        return x

#             
with fluid.dygraph.guard():
    #             
    model = Regressor()
    #         
    model.train()
    #     
    training_data, test_data = load_data()
    #       ，          -SGD
    #       0.01
    opt = fluid.optimizer.SGD(learning_rate=0.01, parameter_list=model.parameters())

with dygraph.guard(fluid.CPUPlace()):
    EPOCH_NUM = 10   #         
    BATCH_SIZE = 10  #   batch  
    
    #       
    for epoch_id in range(EPOCH_NUM):
        #          ，             
        np.random.shuffle(training_data)
        #          ，  batch  10   
        mini_batches = [training_data[k:k+BATCH_SIZE] for k in range(0, len(training_data), BATCH_SIZE)]
        #       
        for iter_id, mini_batch in enumerate(mini_batches):
            x = np.array(mini_batch[:, :-1]).astype('float32') #           
            y = np.array(mini_batch[:, -1:]).astype('float32') #           （    ）
            #  numpy         variable  
            house_features = dygraph.to_variable(x)
            prices = dygraph.to_variable(y)
            
            #     
            predicts = model(house_features)
            
            #     
            loss = fluid.layers.square_error_cost(predicts, label=prices)
            avg_loss = fluid.layers.mean(loss)
            if iter_id%20==0:
                print("epoch: {}, iter: {}, loss is: {}".format(epoch_id, iter_id, avg_loss.numpy()))
            
            #     
            avg_loss.backward()
            #    loss,    
            opt.minimize(avg_loss)
            #     
            model.clear_gradients()
    #     
    fluid.save_dygraph(model.state_dict(), 'LR_model')
   
#            
with fluid.dygraph.guard():
    #       ，    LR_model
    fluid.save_dygraph(model.state_dict(), 'LR_model')
    print("      ，       LR_model ")

#    
def load_one_example(data_dir):
    f = open(data_dir, 'r')
    datas = f.readlines()
    #      10       
    tmp = datas[-10]
    tmp = tmp.strip().split()
    one_data = [float(v) for v in tmp]

    #           
    for i in range(len(one_data)-1):
        one_data[i] = (one_data[i] - avg_values[i]) / (max_values[i] - min_values[i])

    data = np.reshape(np.array(one_data[:-1]), [1, -1]).astype(np.float32)
    label = one_data[-1]
    return data, label

with dygraph.guard():
    #               
    model_dict, _ = fluid.load_dygraph('LR_model')
    model.load_dict(model_dict)
    model.eval()

    #            
    test_data, label = load_one_example('./work/housing.data')
    #          variable  
    test_data = dygraph.to_variable(test_data)
    results = model(test_data)

    #           
    results = results * (max_values[-1] - min_values[-1]) + avg_values[-1]
    print("Inference result is {}, the corresponding label is {}".format(results.numpy(), label))