Write the Understand Sentiment book example with stacked LSTM using new API

python/paddle/fluid/tests/book/understand_sentiment/notest_understand_sentiment_stacked_lstm.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2018 PaddlePaddle Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import print_function
+
+import paddle
+import paddle.fluid as fluid
+from functools import partial
+
+CLASS_DIM = 2
+EMB_DIM = 128
+HID_DIM = 512
+STACKED_NUM = 3
+
+
+def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
+ assert stacked_num % 2 == 1
+
+ emb = fluid.layers.embedding(
+ input=data, size=[input_dim, emb_dim], is_sparse=True)
+
+ fc1 = fluid.layers.fc(input=emb, size=hid_dim)
+ lstm1, cell1 = fluid.layers.dynamic_lstm(input=fc1, size=hid_dim)
+
+ inputs = [fc1, lstm1]
+
+ for i in range(2, stacked_num + 1):
+ fc = fluid.layers.fc(input=inputs, size=hid_dim)
+ lstm, cell = fluid.layers.dynamic_lstm(
+ input=fc, size=hid_dim, is_reverse=(i % 2) == 0)
+ inputs = [fc, lstm]
+
+ fc_last = fluid.layers.sequence_pool(input=inputs[0], pool_type='max')
+ lstm_last = fluid.layers.sequence_pool(input=inputs[1], pool_type='max')
+
+ prediction = fluid.layers.fc(input=[fc_last, lstm_last],
+ size=class_dim,
+ act='softmax')
+ return prediction
+
+
+def inference_network(word_dict):
+ data = fluid.layers.data(
+ name="words", shape=[1], dtype="int64", lod_level=1)
+
+ dict_dim = len(word_dict)
+ net = stacked_lstm_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM,
+ STACKED_NUM)
+ return net
+
+
+def train_network(word_dict):
+ prediction = inference_network(word_dict)
+ label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+ cost = fluid.layers.cross_entropy(input=prediction, label=label)
+ avg_cost = fluid.layers.mean(cost)
+ accuracy = fluid.layers.accuracy(input=prediction, label=label)
+ return avg_cost, accuracy
+
+
+def train(use_cuda, save_path):
+ BATCH_SIZE = 128
+ EPOCH_NUM = 5
+
+ word_dict = paddle.dataset.imdb.word_dict()
+
+ train_data = paddle.batch(
+ paddle.reader.shuffle(
+ paddle.dataset.imdb.train(word_dict), buf_size=1000),
+ batch_size=BATCH_SIZE)
+
+ test_data = paddle.batch(
+ paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
+
+ def event_handler(event):
+ if isinstance(event, fluid.EndIteration):
+ if (event.batch_id % 10) == 0:
+ avg_cost, accuracy = trainer.test(reader=test_data)
+
+ print('BatchID {1:04}, Loss {2:2.2}, Acc {3:2.2}'.format(
+ event.batch_id + 1, avg_cost, accuracy))
+
+ if accuracy > 0.01: # Low threshold for speeding up CI
+ trainer.params.save(save_path)
+ return
+
+ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+ trainer = fluid.Trainer(
+ partial(train_network, word_dict),
+ optimizer=fluid.optimizer.Adagrad(learning_rate=0.002),
+ place=place,
+ event_handler=event_handler)
+
+ trainer.train(train_data, EPOCH_NUM, event_handler=event_handler)
+
+
+def infer(use_cuda, save_path):
+ params = fluid.Params(save_path)
+ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
+ word_dict = paddle.dataset.imdb.word_dict()
+ inferencer = fluid.Inferencer(
+ partial(inference_network, word_dict), params, place=place)
+
+ def create_random_lodtensor(lod, place, low, high):
+ data = np.random.random_integers(low, high,
+ [lod[-1], 1]).astype("int64")
+ res = fluid.LoDTensor()
+ res.set(data, place)
+ res.set_lod([lod])
+ return res
+
+ lod = [0, 4, 10]
+ tensor_words = create_random_lodtensor(
+ lod, place, low=0, high=len(word_dict) - 1)
+ results = inferencer.infer({'words': tensor_words})
+ print("infer results: ", results)
+
+
+def main(use_cuda):
+ if use_cuda and not fluid.core.is_compiled_with_cuda():
+ return
+ save_path = "understand_sentiment_stacked_lstm.inference.model"
+ train(use_cuda, save_path)
+ infer(use_cuda, save_path)
+
+
+if __name__ == '__main__':
+ for use_cuda in (False, True):
+ main(use_cuda=use_cuda)