步驟

一、安裝python

sudo apt-get install python3

若存在多個版本python，請先設定版本優先順序

update-alternatives: using /usr/bin/python3.5 to provide /usr/bin/python (python) in auto mode

設定之後

二、安裝pip

問題：使用apt install python-pip安裝python報錯

解決

在Ubuntu14.04上，建議通過下面的方法安裝，這是一種通用的方法，也適用於Windows，當然在Windows下

手動下載下來就行了

wget https://bootstrap.pypa.io/get-pip.py  --no-check-certificate
sudo python get-pip.py

三、安裝paddlepaddle

apt update && apt install python-dev python-pip && pip install numpy==1.14.0 paddlepaddle && export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH

會下載很多東西，等著就好了，下載完成

若報錯，請參考安裝說明

四、驗證安裝

依次輸入

python
import paddle.fluid

沒有報錯即為安裝成功

不放心的話，可以用以下測試檔案跑一下（注意編碼選擇utf-8），否則會報錯

執行結果如下，說明環境安裝成功了

下面程式碼就是上圖中測試的test.py的原始碼

import paddle
import paddle.dataset.imdb as imdb
import paddle.fluid as fluid
import numpy as np


def rnn_net(ipt, input_dim):
    emb = fluid.layers.embedding(input=ipt, size=[input_dim, 128], is_sparse=True)
    sentence = fluid.layers.fc(input=emb, size=128, act='tanh')

    rnn = fluid.layers.DynamicRNN()
    with rnn.block():
        word = rnn.step_input(sentence)
        prev = rnn.memory(shape=[128])
        hidden = fluid.layers.fc(input=[word, prev], size=128, act='relu')
        rnn.update_memory(prev, hidden)
        rnn.output(hidden)

    last = fluid.layers.sequence_last_step(rnn())
    out = fluid.layers.fc(input=last, size=2, act='softmax')
    return out


# 定義長短期記憶網路
def lstm_net(ipt, input_dim):
    # 以資料的IDs作為輸入
    emb = fluid.layers.embedding(input=ipt, size=[input_dim, 128], is_sparse=True)

    # 第一個全連線層
    fc1 = fluid.layers.fc(input=emb, size=128)
    # 進行一個長短期記憶操作
    lstm1, _ = fluid.layers.dynamic_lstm(input=fc1, size=128)

    # 第一個最大序列池操作
    fc2 = fluid.layers.sequence_pool(input=fc1, pool_type='max')
    # 第二個最大序列池操作
    lstm2 = fluid.layers.sequence_pool(input=lstm1, pool_type='max')

    # 以softmax作為全連線的輸出層，大小為2,也就是正負面
    out = fluid.layers.fc(input=[fc2, lstm2], size=2, act='softmax')
    return out


# 定義輸入資料， lod_level不為0指定輸入資料為序列資料
words = fluid.layers.data(name='words', shape=[1], dtype='int64', lod_level=1)
label = fluid.layers.data(name='label', shape=[1], dtype='int64')

# 獲取資料字典
print("載入資料字典中...")
word_dict = imdb.word_dict()
# 獲取資料字典長度
dict_dim = len(word_dict)
# 獲取長短期記憶網路
model = lstm_net(words, dict_dim)
# model = rnn_net(words, dict_dim)

# 獲取損失函式和準確率
cost = fluid.layers.cross_entropy(input=model, label=label)
avg_cost = fluid.layers.mean(cost)
acc = fluid.layers.accuracy(input=model, label=label)

# 獲取預測程式
test_program = fluid.default_main_program().clone(for_test=True)

# 定義優化方法
optimizer = fluid.optimizer.AdagradOptimizer(learning_rate=0.002)
opt = optimizer.minimize(avg_cost)

# 建立一個解析器
place = fluid.CPUPlace()
# place = fluid.CUDAPlace(0)
exe = fluid.Executor(place)
# 進行引數初始化
exe.run(fluid.default_startup_program())

# 獲取訓練和預測資料
print("載入訓練資料中...")
train_reader = paddle.batch(
    paddle.reader.shuffle(imdb.train(word_dict), 25000), batch_size=128)
print("載入測試資料中...")
test_reader = paddle.batch(imdb.test(word_dict), batch_size=128)

# 定義輸入資料的維度
feeder = fluid.DataFeeder(place=place, feed_list=[words, label])

# 開始訓練
for pass_id in range(1):
    # 進行訓練
    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, Batch:%d, Cost:%0.5f' % (pass_id, batch_id, train_cost[0]))
            # 進行測試
            test_costs = []
            test_accs = []
            for batch_id, data in enumerate(test_reader()):
                test_cost, test_acc = exe.run(program=test_program,
                                              feed=feeder.feed(data),
                                              fetch_list=[avg_cost, acc])
                test_costs.append(test_cost[0])
                test_accs.append(test_acc[0])
            # 計算平均預測損失在和準確率
            test_cost = (sum(test_costs) / len(test_costs))
            test_acc = (sum(test_accs) / len(test_accs))
            print('Test:%d, Cost:%0.5f, ACC:%0.5f' % (pass_id, test_cost, test_acc))


# 定義預測資料
reviews_str = ['read the book forget the movie', 'this is a great movie', 'this is very bad']
# 把每個句子拆成一個個單詞
reviews = [c.split() for c in reviews_str]

# 獲取結束符號的標籤
UNK = word_dict['<unk>']
# 獲取每句話對應的標籤
lod = []
for c in reviews:
    # 需要把單詞進行字串編碼轉換
    lod.append([word_dict.get(words.encode('utf-8'), UNK) for words in c])

# 獲取每句話的單詞數量
base_shape = [[len(c) for c in lod]]

# 生成預測資料
tensor_words = fluid.create_lod_tensor(lod, base_shape, place)

# 預測獲取預測結果,因為輸入的是3個數據，所以要模擬3個label的輸入
results = exe.run(program=test_program,
                  feed={'words': tensor_words, 'label': np.array([[0], [0], [0]]).astype('int64')},
                  fetch_list=[model])
# 列印每句話的正負面概率
for i, r in enumerate(results[0]):
    print("\'%s\'的預測結果為：正面概率為：%0.5f，負面概率為：%0.5f" % (reviews_str[i], r[0], r[1]))