Merge branch 'develop' of https://github.com/PaddlePaddle/book into change_None

.tools/build_docker.sh

@@ -59,6 +59,10 @@ fi
 
 cat >> Dockerfile <<EOF
 RUN pip install -U nltk \
+    && python3 -m pip install --user --upgrade pip==9.0.3 \
+    && pip3 install -U nltk \
+    && pip3.6 install -U nltk \
+    && pip3.7 install -U nltk \
     && python /book/.tools/cache_dataset.py
 
 RUN ${update_mirror_cmd}
@@ -67,8 +71,17 @@ RUN ${update_mirror_cmd}
     apt-get -y install gcc curl git vim && \
     apt-get -y clean && \
     localedef -f UTF-8 -i en_US en_US.UTF-8 && \
-    pip install --upgrade pip && \
-    pip install -U notedown pillow matplotlib jupyter numpy requests scipy
+    pip install -U notedown pillow matplotlib jupyter numpy requests scipy && \
+    pip3 install -U notedown pillow matplotlib numpy requests scipy && \
+    pip3.6 install -U notedown pillow matplotlib numpy requests scipy && \
+    pip3.7 install -U notedown pillow matplotlib numpy requests scipy
+
+RUN pip3.6 install ipykernel && \
+    pip3.7 install ipykernel && \
+    python3.6 -m ipykernel install --name python3.6 && \
+    python3.7 -m ipykernel install --name python3.7 && \
+    pip3 install ipykernel && \
+    python3 -m ipykernel install --name python3
 
 RUN curl https://storage.googleapis.com/golang/go1.8.linux-amd64.tar.gz -o go1.8.linux-amd64.tar.gz && \
     tar -zxvf go1.8.linux-amd64.tar.gz -C /usr/local/ && \

0.coding_guideline/appendix/README.MD

+Stores some images here.

01.fit_a_line/README.cn.md

@@ -154,52 +154,48 @@ test_reader = paddle.batch(
         batch_size=BATCH_SIZE)
 ```
 
-如果想直接从txt文件中读取数据的话，可以参考以下方式。
-
+如果想直接从txt文件中读取数据的话，可以参考以下方式(需要自行准备txt文件)。
+```text
 feature_names = [
     'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
     'PTRATIO', 'B', 'LSTAT', 'convert'
 ]
-
 feature_num = len(feature_names)
-
 data = numpy.fromfile(filename, sep=' ') # 从文件中读取原始数据
-
 data = data.reshape(data.shape[0] // feature_num, feature_num)
-
 maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]
 
 for i in six.moves.range(feature_num-1):
- data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves可以兼容python2和python3
+   data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves可以兼容python2和python3
 
 ratio = 0.8 # 训练集和验证集的划分比例
-
 offset = int(data.shape[0]*ratio)
-
 train_data = data[:offset]
-
 test_data = data[offset:]
 
-def reader(data):
-    for d in train_data:
-        yield d[:1], d[-1:]
+def reader_creator(train_data):  
+    def reader():  
+        for d in train_data:  
+            yield d[:-1], d[-1:]  
+    return reader
 
 train_reader = paddle.batch(
     paddle.reader.shuffle(
-        reader(train_data), buf_size=500),
+        reader_creator(train_data), buf_size=500),
         batch_size=BATCH_SIZE)
 
 test_reader = paddle.batch(
     paddle.reader.shuffle(
-        reader(test_data), buf_size=500),
+        reader_creator(test_data), buf_size=500),
         batch_size=BATCH_SIZE)
+```
 
 ### 配置训练程序
 训练程序的目的是定义一个训练模型的网络结构。对于线性回归来讲，它就是一个从输入到输出的简单的全连接层。更加复杂的结果，比如卷积神经网络，递归神经网络等会在随后的章节中介绍。训练程序必须返回`平均损失`作为第一个返回值，因为它会被后面反向传播算法所用到。
 
 ```python
-x = fluid.layers.data(name='x', shape=[13], dtype='float32') # 定义输入的形状和数据类型
-y = fluid.layers.data(name='y', shape=[1], dtype='float32') # 定义输出的形状和数据类型
+x = fluid.data(name='x', shape=[-1, 13], dtype='float32') # 定义输入的形状和数据类型
+y = fluid.data(name='y', shape=[-1, 1], dtype='float32') # 定义输出的形状和数据类型
 y_predict = fluid.layers.fc(input=x, size=1, act=None) # 连接输入和输出的全连接层
 
 main_program = fluid.default_main_program() # 获取默认/全局主函数

01.fit_a_line/README.md

@@ -156,48 +156,48 @@ test_reader = paddle.batch(
         batch_size=BATCH_SIZE)
 ```
 
-If you want to read data directly from \*.txt file, you can refer to the method as follows.
-
+If you want to read data directly from \*.txt file, you can refer to the method as follows(need to prepare txt file by yourself).
+```text
 feature_names = [
     'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
     'PTRATIO', 'B', 'LSTAT', 'convert'
 ]
-
 feature_num = len(feature_names)
-
 data = numpy.fromfile(filename, sep=' ') # Read primary data from file
-
 data = data.reshape(data.shape[0] // feature_num, feature_num)
-
 maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]
 
 for i in six.moves.range(feature_num-1):
- data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves is compatible to python2 and python3
+   data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves is compatible to python2 and python3
 
 ratio = 0.8 # distribution ratio of train dataset and verification dataset
-
 offset = int(data.shape[0]\*ratio)
-
 train_data = data[:offset]
-
 test_data = data[offset:]
 
+def reader_creator(train_data):  
+    def reader():  
+        for d in train_data:  
+            yield d[:-1], d[-1:]  
+    return reader
+
 train_reader = paddle.batch(
     paddle.reader.shuffle(
-        train_data, buf_size=500),
+        reader_creator(train_data), buf_size=500),
         batch_size=BATCH_SIZE)
 
 test_reader = paddle.batch(
     paddle.reader.shuffle(
-        test_data, buf_size=500),
+        reader_creator(test_data), buf_size=500),
         batch_size=BATCH_SIZE)
+```
 
 ### Configure Program for Training
 The aim of the program for training is to define a network structure of a training model. For linear regression, it is a simple fully connected layer from input to output. More complex result, such as Convolutional Neural Network and Recurrent Neural Network, will be introduced in later chapters. It must return `mean error` as the first return value in program for training, for that `mean error` will be used for BackPropagation.
 
 ```python
-x = fluid.layers.data(name='x', shape=[13], dtype='float32') # define shape and data type of input
-y = fluid.layers.data(name='y', shape=[1], dtype='float32') # define shape and data type of output
+x = fluid.data(name='x', shape=[-1, 13], dtype='float32') # define shape and data type of input
+y = fluid.data(name='y', shape=[-1, 1], dtype='float32') # define shape and data type of output
 y_predict = fluid.layers.fc(input=x, size=1, act=None) # fully connected layer connecting input and output
 
 main_program = fluid.default_main_program() # get default/global main function

01.fit_a_line/index.cn.html

@@ -196,52 +196,48 @@ test_reader = paddle.batch(
         batch_size=BATCH_SIZE)
 ```
 
-如果想直接从txt文件中读取数据的话，可以参考以下方式。
-
+如果想直接从txt文件中读取数据的话，可以参考以下方式(需要自行准备txt文件)。
+```text
 feature_names = [
     'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
     'PTRATIO', 'B', 'LSTAT', 'convert'
 ]
-
 feature_num = len(feature_names)
-
 data = numpy.fromfile(filename, sep=' ') # 从文件中读取原始数据
-
 data = data.reshape(data.shape[0] // feature_num, feature_num)
-
 maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]
 
 for i in six.moves.range(feature_num-1):
- data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves可以兼容python2和python3
+   data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves可以兼容python2和python3
 
 ratio = 0.8 # 训练集和验证集的划分比例
-
 offset = int(data.shape[0]*ratio)
-
 train_data = data[:offset]
-
 test_data = data[offset:]
 
-def reader(data):
-    for d in train_data:
-        yield d[:1], d[-1:]
+def reader_creator(train_data):  
+    def reader():  
+        for d in train_data:  
+            yield d[:-1], d[-1:]  
+    return reader
 
 train_reader = paddle.batch(
     paddle.reader.shuffle(
-        reader(train_data), buf_size=500),
+        reader_creator(train_data), buf_size=500),
         batch_size=BATCH_SIZE)
 
 test_reader = paddle.batch(
     paddle.reader.shuffle(
-        reader(test_data), buf_size=500),
+        reader_creator(test_data), buf_size=500),
         batch_size=BATCH_SIZE)
+```
 
 ### 配置训练程序
 训练程序的目的是定义一个训练模型的网络结构。对于线性回归来讲，它就是一个从输入到输出的简单的全连接层。更加复杂的结果，比如卷积神经网络，递归神经网络等会在随后的章节中介绍。训练程序必须返回`平均损失`作为第一个返回值，因为它会被后面反向传播算法所用到。
 
 ```python
-x = fluid.layers.data(name='x', shape=[13], dtype='float32') # 定义输入的形状和数据类型
-y = fluid.layers.data(name='y', shape=[1], dtype='float32') # 定义输出的形状和数据类型
+x = fluid.data(name='x', shape=[-1, 13], dtype='float32') # 定义输入的形状和数据类型
+y = fluid.data(name='y', shape=[-1, 1], dtype='float32') # 定义输出的形状和数据类型
 y_predict = fluid.layers.fc(input=x, size=1, act=None) # 连接输入和输出的全连接层
 
 main_program = fluid.default_main_program() # 获取默认/全局主函数

01.fit_a_line/index.html

@@ -198,48 +198,48 @@ test_reader = paddle.batch(
         batch_size=BATCH_SIZE)
 ```
 
-If you want to read data directly from \*.txt file, you can refer to the method as follows.
-
+If you want to read data directly from \*.txt file, you can refer to the method as follows(need to prepare txt file by yourself).
+```text
 feature_names = [
     'CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE', 'DIS', 'RAD', 'TAX',
     'PTRATIO', 'B', 'LSTAT', 'convert'
 ]
-
 feature_num = len(feature_names)
-
 data = numpy.fromfile(filename, sep=' ') # Read primary data from file
-
 data = data.reshape(data.shape[0] // feature_num, feature_num)
-
 maximums, minimums, avgs = data.max(axis=0), data.min(axis=0), data.sum(axis=0)/data.shape[0]
 
 for i in six.moves.range(feature_num-1):
- data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves is compatible to python2 and python3
+   data[:, i] = (data[:, i] - avgs[i]) / (maximums[i] - minimums[i]) # six.moves is compatible to python2 and python3
 
 ratio = 0.8 # distribution ratio of train dataset and verification dataset
-
 offset = int(data.shape[0]\*ratio)
-
 train_data = data[:offset]
-
 test_data = data[offset:]
 
+def reader_creator(train_data):  
+    def reader():  
+        for d in train_data:  
+            yield d[:-1], d[-1:]  
+    return reader
+
 train_reader = paddle.batch(
     paddle.reader.shuffle(
-        train_data, buf_size=500),
+        reader_creator(train_data), buf_size=500),
         batch_size=BATCH_SIZE)
 
 test_reader = paddle.batch(
     paddle.reader.shuffle(
-        test_data, buf_size=500),
+        reader_creator(test_data), buf_size=500),
         batch_size=BATCH_SIZE)
+```
 
 ### Configure Program for Training
 The aim of the program for training is to define a network structure of a training model. For linear regression, it is a simple fully connected layer from input to output. More complex result, such as Convolutional Neural Network and Recurrent Neural Network, will be introduced in later chapters. It must return `mean error` as the first return value in program for training, for that `mean error` will be used for BackPropagation.
 
 ```python
-x = fluid.layers.data(name='x', shape=[13], dtype='float32') # define shape and data type of input
-y = fluid.layers.data(name='y', shape=[1], dtype='float32') # define shape and data type of output
+x = fluid.data(name='x', shape=[-1, 13], dtype='float32') # define shape and data type of input
+y = fluid.data(name='y', shape=[-1, 1], dtype='float32') # define shape and data type of output
 y_predict = fluid.layers.fc(input=x, size=1, act=None) # fully connected layer connecting input and output
 
 main_program = fluid.default_main_program() # get default/global main function

01.fit_a_line/train.py

@@ -87,8 +87,8 @@ def main():
             batch_size=batch_size)
 
     # feature vector of length 13
-    x = fluid.layers.data(name='x', shape=[13], dtype='float32')
-    y = fluid.layers.data(name='y', shape=[1], dtype='float32')
+    x = fluid.data(name='x', shape=[-1, 13], dtype='float32')
+    y = fluid.data(name='y', shape=[-1, 1], dtype='float32')
 
     main_program = fluid.default_main_program()
     startup_program = fluid.default_startup_program()

02.recognize_digits/README.cn.md

@@ -195,7 +195,7 @@ import paddle.fluid as fluid
 ### Program Functions 配置
 
 我们需要设置 `inference_program` 函数。我们想用这个程序来演示三个不同的分类器，每个分类器都定义为 Python 函数。
-我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 `layer.data` 层。
+我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 `fluid.data` 层。
 让我们创建一个数据层来读取图像并将其连接到分类网络。
 
 - Softmax回归：只通过一层简单的以softmax为激活函数的全连接层，就可以得到分类的结果。
@@ -209,7 +209,7 @@ def softmax_regression():
         predict_image -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 以softmax为激活函数的全连接层，输出层的大小必须为数字的个数10
     predict = fluid.layers.fc(
         input=img, size=10, act='softmax')
@@ -229,7 +229,7 @@ def multilayer_perceptron():
         predict_image -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 第一个全连接层，激活函数为ReLU
     hidden = fluid.layers.fc(input=img, size=200, act='relu')
     # 第二个全连接层，激活函数为ReLU
@@ -251,7 +251,7 @@ def convolutional_neural_network():
         predict -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 第一个卷积-池化层
     # 使用20个5*5的滤波器，池化大小为2，池化步长为2，激活函数为Relu
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
@@ -296,7 +296,7 @@ def train_program():
 
     """
     # 标签层，名称为label,对应输入图片的类别标签
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
 
     # predict = softmax_regression() # 取消注释将使用 Softmax回归
     # predict = multilayer_perceptron() # 取消注释将使用 多层感知器

02.recognize_digits/README.md

@@ -174,7 +174,7 @@ import paddle.fluid as fluid
 ### Program Functions Configuration
 
 We need to configure `inference_program` function. We want to use this program to show three different classifiers, each of which is defined as a Python function.
-We need to input the image data into the classifier. Paddle provides a special layer `layer.data` for reading data.
+We need to input the image data into the classifier. Paddle provides a special layer `fluid.data` for reading data.
 Let's create a data layer to read the image and connect it to the network of classification.
 
 -Softmax regression: The results of the classification can be obtained only through a simple layer of simple fully connected layer with softmax as the activation function.
@@ -188,7 +188,7 @@ def softmax_regression():
     predict_image -- result of classification
     """
     # input original image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # With softmax as the fully connected layer of the activation function, the size of the output layer must be 10
     predict = fluid.layers.fc(
     input=img, size=10, act='softmax')
@@ -208,7 +208,7 @@ def multilayer_perceptron():
     predict_image -- result of classification
     """
     # input raw image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # the first fully connected layer, whose activation function is ReLU
     hidden = fluid.layers.fc(input=img, size=200, act='relu')
     # the second fully connected layer, whose activation function is ReLU
@@ -230,7 +230,7 @@ def convolutional_neural_network():
     predict -- result of classification
     """
     # input raw image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # the first convolution-pooling layer
     # Use 20 5*5 filters, the pooling size is 2, the pooling step is 2, and the activation function is Relu.
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
@@ -275,7 +275,7 @@ def train_program():
 
     """
     # label layer, called label, correspondent with label category of input picture
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
 
     # predict = softmax_regression() # cancel note and run Softmax regression
     # predict = multilayer_perceptron() # cancel note and run multiple perceptron

02.recognize_digits/index.cn.html

@@ -237,7 +237,7 @@ import paddle.fluid as fluid
 ### Program Functions 配置
 
 我们需要设置 `inference_program` 函数。我们想用这个程序来演示三个不同的分类器，每个分类器都定义为 Python 函数。
-我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 `layer.data` 层。
+我们需要将图像数据输入到分类器中。Paddle 为读取数据提供了一个特殊的层 `fluid.data` 层。
 让我们创建一个数据层来读取图像并将其连接到分类网络。
 
 - Softmax回归：只通过一层简单的以softmax为激活函数的全连接层，就可以得到分类的结果。
@@ -251,7 +251,7 @@ def softmax_regression():
         predict_image -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 以softmax为激活函数的全连接层，输出层的大小必须为数字的个数10
     predict = fluid.layers.fc(
         input=img, size=10, act='softmax')
@@ -271,7 +271,7 @@ def multilayer_perceptron():
         predict_image -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 第一个全连接层，激活函数为ReLU
     hidden = fluid.layers.fc(input=img, size=200, act='relu')
     # 第二个全连接层，激活函数为ReLU
@@ -293,7 +293,7 @@ def convolutional_neural_network():
         predict -- 分类的结果
     """
     # 输入的原始图像数据，大小为28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # 第一个卷积-池化层
     # 使用20个5*5的滤波器，池化大小为2，池化步长为2，激活函数为Relu
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
@@ -338,7 +338,7 @@ def train_program():
 
     """
     # 标签层，名称为label,对应输入图片的类别标签
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
 
     # predict = softmax_regression() # 取消注释将使用 Softmax回归
     # predict = multilayer_perceptron() # 取消注释将使用 多层感知器

02.recognize_digits/index.html

@@ -216,7 +216,7 @@ import paddle.fluid as fluid
 ### Program Functions Configuration
 
 We need to configure `inference_program` function. We want to use this program to show three different classifiers, each of which is defined as a Python function.
-We need to input the image data into the classifier. Paddle provides a special layer `layer.data` for reading data.
+We need to input the image data into the classifier. Paddle provides a special layer `fluid.data` for reading data.
 Let's create a data layer to read the image and connect it to the network of classification.
 
 -Softmax regression: The results of the classification can be obtained only through a simple layer of simple fully connected layer with softmax as the activation function.
@@ -230,7 +230,7 @@ def softmax_regression():
     predict_image -- result of classification
     """
     # input original image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # With softmax as the fully connected layer of the activation function, the size of the output layer must be 10
     predict = fluid.layers.fc(
     input=img, size=10, act='softmax')
@@ -250,7 +250,7 @@ def multilayer_perceptron():
     predict_image -- result of classification
     """
     # input raw image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # the first fully connected layer, whose activation function is ReLU
     hidden = fluid.layers.fc(input=img, size=200, act='relu')
     # the second fully connected layer, whose activation function is ReLU
@@ -272,7 +272,7 @@ def convolutional_neural_network():
     predict -- result of classification
     """
     # input raw image data in size of 28*28*1
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
     # the first convolution-pooling layer
     # Use 20 5*5 filters, the pooling size is 2, the pooling step is 2, and the activation function is Relu.
     conv_pool_1 = fluid.nets.simple_img_conv_pool(
@@ -317,7 +317,7 @@ def train_program():
 
     """
     # label layer, called label, correspondent with label category of input picture
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
 
     # predict = softmax_regression() # cancel note and run Softmax regression
     # predict = multilayer_perceptron() # cancel note and run multiple perceptron

02.recognize_digits/train.py

@@ -101,8 +101,8 @@ def train(nn_type,
         test_reader = paddle.batch(
             paddle.dataset.mnist.test(), batch_size=BATCH_SIZE)
 
-    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    img = fluid.data(name='img', shape=[-1, 1, 28, 28], dtype='float32')
+    label = fluid.data(name='label', shape=[-1, 1], dtype='int64')
 
     if nn_type == 'softmax_regression':
         net_conf = softmax_regression

03.image_classification/README.cn.md

@@ -314,8 +314,8 @@ def resnet_cifar10(ipt, depth=32):
 ```python
 def inference_program():
     # The image is 32 * 32 with RGB representation.
-    data_shape = [3, 32, 32]
-    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
+    data_shape = [None, 3, 32, 32]
+    images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
 
     predict = resnet_cifar10(images, 32)
     # predict = vgg_bn_drop(images) # un-comment to use vgg net
@@ -326,7 +326,7 @@ def inference_program():
 
 然后我们需要设置训练程序 `train_program`。它首先从推理程序中进行预测。
 在训练期间，它将从预测中计算 `avg_cost`。
-在有监督训练中需要输入图像对应的类别信息，同样通过`fluid.layers.data`来定义。训练中采用多类交叉熵作为损失函数，并作为网络的输出，预测阶段定义网络的输出为分类器得到的概率信息。
+在有监督训练中需要输入图像对应的类别信息，同样通过`fluid.data`来定义。训练中采用多类交叉熵作为损失函数，并作为网络的输出，预测阶段定义网络的输出为分类器得到的概率信息。
 
 **注意:** 训练程序应该返回一个数组，第一个返回参数必须是 `avg_cost`。训练器使用它来计算梯度。
 
@@ -334,7 +334,7 @@ def inference_program():
 def train_program():
     predict = inference_program()
 
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
     cost = fluid.layers.cross_entropy(input=predict, label=label)
     avg_cost = fluid.layers.mean(cost)
     accuracy = fluid.layers.accuracy(input=predict, label=label)

03.image_classification/README.md

@@ -305,13 +305,13 @@ def resnet_cifar10(ipt, depth=32):
 
 ## Inference Program Configuration
 
-The input to the network is defined as `fluid.layers.data` , corresponding to image pixels in the context of image classification. The images in CIFAR10 are 32x32 coloured images with three channels. Therefore, the size of the input data is 3072 (3x32x32).
+The input to the network is defined as `fluid.data` , corresponding to image pixels in the context of image classification. The images in CIFAR10 are 32x32 coloured images with three channels. Therefore, the size of the input data is 3072 (3x32x32).
 
 ```python
 def inference_program():
     # The image is 32 * 32 with RGB representation.
-    data_shape = [3, 32, 32]
-    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
+    data_shape = [None, 3, 32, 32]
+    images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
 
     predict = resnet_cifar10(images, 32)
     # predict = vgg_bn_drop(images) # un-comment to use vgg net
@@ -322,7 +322,7 @@ def inference_program():
 Then we need to set up the the `train_program`. It takes the prediction from the inference_program first.
 During the training, it will calculate the `avg_loss` from the prediction.
 
-In the context of supervised learning, labels of training images are defined in `fluid.layers.data` as well. During training, the multi-class cross-entropy is used as the loss function and becomes the output of the network. During testing, the outputs are the probabilities calculated in the classifier.
+In the context of supervised learning, labels of training images are defined in `fluid.data` as well. During training, the multi-class cross-entropy is used as the loss function and becomes the output of the network. During testing, the outputs are the probabilities calculated in the classifier.
 
 **NOTE:** A training program should return an array and the first returned argument has to be `avg_cost` .
 The trainer always uses it to calculate the gradients.
@@ -331,7 +331,7 @@ The trainer always uses it to calculate the gradients.
 def train_program():
     predict = inference_program()
 
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
     cost = fluid.layers.cross_entropy(input=predict, label=label)
     avg_cost = fluid.layers.mean(cost)
     accuracy = fluid.layers.accuracy(input=predict, label=label)

03.image_classification/index.cn.html

@@ -356,8 +356,8 @@ def resnet_cifar10(ipt, depth=32):
 ```python
 def inference_program():
     # The image is 32 * 32 with RGB representation.
-    data_shape = [3, 32, 32]
-    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
+    data_shape = [None, 3, 32, 32]
+    images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
 
     predict = resnet_cifar10(images, 32)
     # predict = vgg_bn_drop(images) # un-comment to use vgg net
@@ -368,7 +368,7 @@ def inference_program():
 
 然后我们需要设置训练程序 `train_program`。它首先从推理程序中进行预测。
 在训练期间，它将从预测中计算 `avg_cost`。
-在有监督训练中需要输入图像对应的类别信息，同样通过`fluid.layers.data`来定义。训练中采用多类交叉熵作为损失函数，并作为网络的输出，预测阶段定义网络的输出为分类器得到的概率信息。
+在有监督训练中需要输入图像对应的类别信息，同样通过`fluid.data`来定义。训练中采用多类交叉熵作为损失函数，并作为网络的输出，预测阶段定义网络的输出为分类器得到的概率信息。
 
 **注意:** 训练程序应该返回一个数组，第一个返回参数必须是 `avg_cost`。训练器使用它来计算梯度。
 
@@ -376,7 +376,7 @@ def inference_program():
 def train_program():
     predict = inference_program()
 
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
     cost = fluid.layers.cross_entropy(input=predict, label=label)
     avg_cost = fluid.layers.mean(cost)
     accuracy = fluid.layers.accuracy(input=predict, label=label)

03.image_classification/index.html

@@ -347,13 +347,13 @@ def resnet_cifar10(ipt, depth=32):
 
 ## Inference Program Configuration
 
-The input to the network is defined as `fluid.layers.data` , corresponding to image pixels in the context of image classification. The images in CIFAR10 are 32x32 coloured images with three channels. Therefore, the size of the input data is 3072 (3x32x32).
+The input to the network is defined as `fluid.data` , corresponding to image pixels in the context of image classification. The images in CIFAR10 are 32x32 coloured images with three channels. Therefore, the size of the input data is 3072 (3x32x32).
 
 ```python
 def inference_program():
     # The image is 32 * 32 with RGB representation.
-    data_shape = [3, 32, 32]
-    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
+    data_shape = [None, 3, 32, 32]
+    images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
 
     predict = resnet_cifar10(images, 32)
     # predict = vgg_bn_drop(images) # un-comment to use vgg net
@@ -364,7 +364,7 @@ def inference_program():
 Then we need to set up the the `train_program`. It takes the prediction from the inference_program first.
 During the training, it will calculate the `avg_loss` from the prediction.
 
-In the context of supervised learning, labels of training images are defined in `fluid.layers.data` as well. During training, the multi-class cross-entropy is used as the loss function and becomes the output of the network. During testing, the outputs are the probabilities calculated in the classifier.
+In the context of supervised learning, labels of training images are defined in `fluid.data` as well. During training, the multi-class cross-entropy is used as the loss function and becomes the output of the network. During testing, the outputs are the probabilities calculated in the classifier.
 
 **NOTE:** A training program should return an array and the first returned argument has to be `avg_cost` .
 The trainer always uses it to calculate the gradients.
@@ -373,7 +373,7 @@ The trainer always uses it to calculate the gradients.
 def train_program():
     predict = inference_program()
 
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
     cost = fluid.layers.cross_entropy(input=predict, label=label)
     avg_cost = fluid.layers.mean(cost)
     accuracy = fluid.layers.accuracy(input=predict, label=label)

03.image_classification/train.py

@@ -40,8 +40,8 @@ def parse_args():
 
 def inference_network():
     # The image is 32 * 32 with RGB representation.
-    data_shape = [3, 32, 32]
-    images = fluid.layers.data(name='pixel', shape=data_shape, dtype='float32')
+    data_shape = [None, 3, 32, 32]
+    images = fluid.data(name='pixel', shape=data_shape, dtype='float32')
 
     predict = resnet_cifar10(images, 32)
     # predict = vgg_bn_drop(images) # un-comment to use vgg net
@@ -49,7 +49,7 @@ def inference_network():
 
 
 def train_network(predict):
-    label = fluid.layers.data(name='label', shape=[1], dtype='int64')
+    label = fluid.data(name='label', shape=[None, 1], dtype='int64')
     cost = fluid.layers.cross_entropy(input=predict, label=label)
     avg_cost = fluid.layers.mean(cost)
     accuracy = fluid.layers.accuracy(input=predict, label=label)

05.recommender_system/README.cn.md

@@ -254,9 +254,9 @@ def get_usr_combined_features():
 
     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
 
-    uid = layers.data(name='user_id', shape=[1], dtype='int64')
+    uid = fluid.data(name='user_id', shape=[-1], dtype='int64')
 
-    usr_emb = layers.embedding(
+    usr_emb = fluid.embedding(
         input=uid,
         dtype='float32',
         size=[USR_DICT_SIZE, 32],
@@ -267,9 +267,9 @@ def get_usr_combined_features():
 
     USR_GENDER_DICT_SIZE = 2
 
-    usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
+    usr_gender_id = fluid.data(name='gender_id', shape=[-1], dtype='int64')
 
-    usr_gender_emb = layers.embedding(
+    usr_gender_emb = fluid.embedding(
         input=usr_gender_id,
         size=[USR_GENDER_DICT_SIZE, 16],
         param_attr='gender_table',
@@ -278,9 +278,9 @@ def get_usr_combined_features():
     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
 
     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
-    usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
+    usr_age_id = fluid.data(name='age_id', shape=[-1], dtype="int64")
 
-    usr_age_emb = layers.embedding(
+    usr_age_emb = fluid.embedding(
         input=usr_age_id,
         size=[USR_AGE_DICT_SIZE, 16],
         is_sparse=IS_SPARSE,
@@ -289,9 +289,9 @@ def get_usr_combined_features():
     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
 
     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
-    usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
+    usr_job_id = fluid.data(name='job_id', shape=[-1], dtype="int64")
 
-    usr_job_emb = layers.embedding(
+    usr_job_emb = fluid.embedding(
         input=usr_job_id,
         size=[USR_JOB_DICT_SIZE, 16],
         param_attr='job_table',
@@ -320,9 +320,9 @@ def get_mov_combined_features():
 
     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
 
-    mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
+    mov_id = fluid.data(name='movie_id', shape=[-1], dtype='int64')
 
-    mov_emb = layers.embedding(
+    mov_emb = fluid.embedding(
         input=mov_id,
         dtype='float32',
         size=[MOV_DICT_SIZE, 32],
@@ -333,10 +333,10 @@ def get_mov_combined_features():
 
     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
 
-    category_id = layers.data(
-        name='category_id', shape=[1], dtype='int64', lod_level=1)
+    category_id = fluid.data(
+        name='category_id', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_categories_emb = layers.embedding(
+    mov_categories_emb = fluid.embedding(
         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_categories_hidden = layers.sequence_pool(
@@ -344,10 +344,10 @@ def get_mov_combined_features():
 
     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
 
-    mov_title_id = layers.data(
-        name='movie_title', shape=[1], dtype='int64', lod_level=1)
+    mov_title_id = fluid.data(
+        name='movie_title', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_title_emb = layers.embedding(
+    mov_title_emb = fluid.embedding(
         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_title_conv = nets.sequence_conv_pool(
@@ -390,7 +390,7 @@ def train_program():
 
     scale_infer = inference_program()
 
-    label = layers.data(name='score', shape=[1], dtype='float32')
+    label = fluid.data(name='score', shape=[-1, 1], dtype='float32')
     square_cost = layers.square_error_cost(input=scale_infer, label=label)
     avg_cost = layers.mean(square_cost)
 
@@ -416,12 +416,12 @@ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
 下一步是为训练和测试定义数据提供器。提供器读入一个大小为 `BATCH_SIZE`的数据。`paddle.dataset.movielens.train` 每次会在乱序化后提供一个大小为`BATCH_SIZE`的数据，乱序化的大小为缓存大小`buf_size`。
 
 ```python
-train_reader = paddle.batch(
-    paddle.reader.shuffle(
+train_reader = fluid.io.batch(
+    fluid.io.shuffle(
         paddle.dataset.movielens.train(), buf_size=8192),
     batch_size=BATCH_SIZE)
 
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
 ```
 
@@ -533,13 +533,13 @@ train_loop()
 ```python
 infer_movie_id = 783
 infer_movie_name = paddle.dataset.movielens.movie_info()[infer_movie_id].title
-user_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
-gender_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
-age_id = fluid.create_lod_tensor([[np.int64(0)]], [[1]], place)
-job_id = fluid.create_lod_tensor([[np.int64(10)]], [[1]], place)
-movie_id = fluid.create_lod_tensor([[np.int64(783)]], [[1]], place) # Hunchback of Notre Dame
-category_id = fluid.create_lod_tensor([np.array([10, 8, 9], dtype='int64')], [[3]], place) # Animation, Children's, Musical
-movie_title = fluid.create_lod_tensor([np.array([1069, 4140, 2923, 710, 988], dtype='int64')], [[5]],
+user_id = np.array([1]).astype("int64").reshape(-1)
+gender_id = np.array([1]).astype("int64").reshape(-1)
+age_id = np.array([0]).astype("int64").reshape(-1)
+job_id = np.array([10]).astype("int64").reshape(-1)
+movie_id = np.array([783]).astype("int64").reshape(-1) # Hunchback of Notre Dame
+category_id = fluid.create_lod_tensor(np.array([10, 8, 9], dtype='int64'), [[3]], place) # Animation, Children's, Musical
+movie_title = fluid.create_lod_tensor(np.array([1069, 4140, 2923, 710, 988], dtype='int64'), [[5]],
                                       place) # 'hunchback','of','notre','dame','the'
 ```
 

05.recommender_system/README.md

@@ -206,9 +206,8 @@ mov_id = train_sample[len(user_info[uid].value())]
 print("User %s rates Movie %s with Score %s"%(user_info[uid], movie_info[mov_id], train_sample[-1]))
 ```
 
-```python
-User <UserInfo id(1), gender(F), age(1), job(10)> rates Movie <MovieInfo id(1193), title(One Flew Over the Cuckoo's Nest ), categories(['Drama'])> with Score [5.0]
-```
+    User <UserInfo id(1), gender(F), age(1), job(10)> rates Movie <MovieInfo id(1193), title(One Flew Over the Cuckoo's Nest ), categories(['Drama'])> with Score [5.0]
+
 
 That is, the user 1 evaluates the movie 1193 as 5 points.
 
@@ -242,9 +241,9 @@ def get_usr_combined_features():
 
     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
 
-    uid = layers.data(name='user_id', shape=[1], dtype='int64')
+    uid = fluid.data(name='user_id', shape=[-1], dtype='int64')
 
-    usr_emb = layers.embedding(
+    usr_emb = fluid.embedding(
         input=uid,
         dtype='float32',
         size=[USR_DICT_SIZE, 32],
@@ -255,9 +254,9 @@ def get_usr_combined_features():
 
     USR_GENDER_DICT_SIZE = 2
 
-    usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
+    usr_gender_id = fluid.data(name='gender_id', shape=[-1], dtype='int64')
 
-    usr_gender_emb = layers.embedding(
+    usr_gender_emb = fluid.embedding(
         input=usr_gender_id,
         size=[USR_GENDER_DICT_SIZE, 16],
         param_attr='gender_table',
@@ -266,9 +265,9 @@ def get_usr_combined_features():
     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
 
     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
-    usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
+    usr_age_id = fluid.data(name='age_id', shape=[-1], dtype="int64")
 
-    usr_age_emb = layers.embedding(
+    usr_age_emb = fluid.embedding(
         input=usr_age_id,
         size=[USR_AGE_DICT_SIZE, 16],
         is_sparse=IS_SPARSE,
@@ -277,9 +276,9 @@ def get_usr_combined_features():
     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
 
     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
-    usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
+    usr_job_id = fluid.data(name='job_id', shape=[-1], dtype="int64")
 
-    usr_job_emb = layers.embedding(
+    usr_job_emb = fluid.embedding(
         input=usr_job_id,
         size=[USR_JOB_DICT_SIZE, 16],
         param_attr='job_table',
@@ -308,9 +307,9 @@ def get_mov_combined_features():
 
     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
 
-    mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
+    mov_id = fluid.data(name='movie_id', shape=[-1], dtype='int64')
 
-    mov_emb = layers.embedding(
+    mov_emb = fluid.embedding(
         input=mov_id,
         dtype='float32',
         size=[MOV_DICT_SIZE, 32],
@@ -321,10 +320,10 @@ def get_mov_combined_features():
 
     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
 
-    category_id = layers.data(
-        name='category_id', shape=[1], dtype='int64', lod_level=1)
+    category_id = fluid.data(
+        name='category_id', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_categories_emb = layers.embedding(
+    mov_categories_emb = fluid.embedding(
         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_categories_hidden = layers.sequence_pool(
@@ -332,10 +331,10 @@ def get_mov_combined_features():
 
     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
 
-    mov_title_id = layers.data(
-        name='movie_title', shape=[1], dtype='int64', lod_level=1)
+    mov_title_id = fluid.data(
+        name='movie_title', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_title_emb = layers.embedding(
+    mov_title_emb = fluid.embedding(
         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_title_conv = nets.sequence_conv_pool(
@@ -379,7 +378,7 @@ def train_program():
 
     scale_infer = inference_program()
 
-    label = layers.data(name='score', shape=[1], dtype='float32')
+    label = fluid.data(name='score', shape=[-1, 1], dtype='float32')
     square_cost = layers.square_error_cost(input=scale_infer, label=label)
     avg_cost = layers.mean(square_cost)
 
@@ -405,12 +404,12 @@ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
 The next step is to define a data provider for training and testing. The provider reads in a data of size `BATCH_SIZE`. `paddle.dataset.movielens.train` will provide a data of size `BATCH_SIZE` after each scribbling, and the size of the out-of-order is the cache size `buf_size`.
 
 ```python
-train_reader = paddle.batch(
-    paddle.reader.shuffle(
+train_reader = fluid.io.batch(
+    fluid.io.shuffle(
         paddle.dataset.movielens.train(), buf_size=8192),
     batch_size=BATCH_SIZE)
 
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
 ```
 
@@ -522,13 +521,13 @@ In this prediction example, we try to predict the score given by user with ID1 f
 ```python
 infer_movie_id = 783
 infer_movie_name = paddle.dataset.movielens.movie_info()[infer_movie_id].title
-user_id = fluid.create_lod_tensor([[1]], [[1]], place)
-gender_id = fluid.create_lod_tensor([[1]], [[1]], place)
-age_id = fluid.create_lod_tensor([[0]], [[1]], place)
-job_id = fluid.create_lod_tensor([[10]], [[1]], place)
-movie_id = fluid.create_lod_tensor([[783]], [[1]], place) # Hunchback of Notre Dame
-category_id = fluid.create_lod_tensor([[10, 8, 9]], [[3]], place) # Animation, Children's, Musical
-movie_title = fluid.create_lod_tensor([[1069, 4140, 2923, 710, 988]], [[5]],
+user_id = np.array([1]).astype("int64").reshape(-1)
+gender_id = np.array([1]).astype("int64").reshape(-1)
+age_id = np.array([0]).astype("int64").reshape(-1)
+job_id = np.array([10]).astype("int64").reshape(-1)
+movie_id = np.array([783]).astype("int64").reshape(-1) # Hunchback of Notre Dame
+category_id = fluid.create_lod_tensor(np.array([10, 8, 9], dtype='int64'), [[3]], place) # Animation, Children's, Musical
+movie_title = fluid.create_lod_tensor(np.array([1069, 4140, 2923, 710, 988], dtype='int64'), [[5]],
                                       place) # 'hunchback','of','notre','dame','the'
 ```
 

05.recommender_system/index.cn.html

@@ -296,9 +296,9 @@ def get_usr_combined_features():
 
     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
 
-    uid = layers.data(name='user_id', shape=[1], dtype='int64')
+    uid = fluid.data(name='user_id', shape=[-1], dtype='int64')
 
-    usr_emb = layers.embedding(
+    usr_emb = fluid.embedding(
         input=uid,
         dtype='float32',
         size=[USR_DICT_SIZE, 32],
@@ -309,9 +309,9 @@ def get_usr_combined_features():
 
     USR_GENDER_DICT_SIZE = 2
 
-    usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
+    usr_gender_id = fluid.data(name='gender_id', shape=[-1], dtype='int64')
 
-    usr_gender_emb = layers.embedding(
+    usr_gender_emb = fluid.embedding(
         input=usr_gender_id,
         size=[USR_GENDER_DICT_SIZE, 16],
         param_attr='gender_table',
@@ -320,9 +320,9 @@ def get_usr_combined_features():
     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
 
     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
-    usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
+    usr_age_id = fluid.data(name='age_id', shape=[-1], dtype="int64")
 
-    usr_age_emb = layers.embedding(
+    usr_age_emb = fluid.embedding(
         input=usr_age_id,
         size=[USR_AGE_DICT_SIZE, 16],
         is_sparse=IS_SPARSE,
@@ -331,9 +331,9 @@ def get_usr_combined_features():
     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
 
     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
-    usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
+    usr_job_id = fluid.data(name='job_id', shape=[-1], dtype="int64")
 
-    usr_job_emb = layers.embedding(
+    usr_job_emb = fluid.embedding(
         input=usr_job_id,
         size=[USR_JOB_DICT_SIZE, 16],
         param_attr='job_table',
@@ -362,9 +362,9 @@ def get_mov_combined_features():
 
     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
 
-    mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
+    mov_id = fluid.data(name='movie_id', shape=[-1], dtype='int64')
 
-    mov_emb = layers.embedding(
+    mov_emb = fluid.embedding(
         input=mov_id,
         dtype='float32',
         size=[MOV_DICT_SIZE, 32],
@@ -375,10 +375,10 @@ def get_mov_combined_features():
 
     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
 
-    category_id = layers.data(
-        name='category_id', shape=[1], dtype='int64', lod_level=1)
+    category_id = fluid.data(
+        name='category_id', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_categories_emb = layers.embedding(
+    mov_categories_emb = fluid.embedding(
         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_categories_hidden = layers.sequence_pool(
@@ -386,10 +386,10 @@ def get_mov_combined_features():
 
     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
 
-    mov_title_id = layers.data(
-        name='movie_title', shape=[1], dtype='int64', lod_level=1)
+    mov_title_id = fluid.data(
+        name='movie_title', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_title_emb = layers.embedding(
+    mov_title_emb = fluid.embedding(
         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_title_conv = nets.sequence_conv_pool(
@@ -432,7 +432,7 @@ def train_program():
 
     scale_infer = inference_program()
 
-    label = layers.data(name='score', shape=[1], dtype='float32')
+    label = fluid.data(name='score', shape=[-1, 1], dtype='float32')
     square_cost = layers.square_error_cost(input=scale_infer, label=label)
     avg_cost = layers.mean(square_cost)
 
@@ -458,12 +458,12 @@ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
 下一步是为训练和测试定义数据提供器。提供器读入一个大小为 `BATCH_SIZE`的数据。`paddle.dataset.movielens.train` 每次会在乱序化后提供一个大小为`BATCH_SIZE`的数据，乱序化的大小为缓存大小`buf_size`。
 
 ```python
-train_reader = paddle.batch(
-    paddle.reader.shuffle(
+train_reader = fluid.io.batch(
+    fluid.io.shuffle(
         paddle.dataset.movielens.train(), buf_size=8192),
     batch_size=BATCH_SIZE)
 
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
 ```
 
@@ -575,13 +575,13 @@ train_loop()
 ```python
 infer_movie_id = 783
 infer_movie_name = paddle.dataset.movielens.movie_info()[infer_movie_id].title
-user_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
-gender_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
-age_id = fluid.create_lod_tensor([[np.int64(0)]], [[1]], place)
-job_id = fluid.create_lod_tensor([[np.int64(10)]], [[1]], place)
-movie_id = fluid.create_lod_tensor([[np.int64(783)]], [[1]], place) # Hunchback of Notre Dame
-category_id = fluid.create_lod_tensor([np.array([10, 8, 9], dtype='int64')], [[3]], place) # Animation, Children's, Musical
-movie_title = fluid.create_lod_tensor([np.array([1069, 4140, 2923, 710, 988], dtype='int64')], [[5]],
+user_id = np.array([1]).astype("int64").reshape(-1)
+gender_id = np.array([1]).astype("int64").reshape(-1)
+age_id = np.array([0]).astype("int64").reshape(-1)
+job_id = np.array([10]).astype("int64").reshape(-1)
+movie_id = np.array([783]).astype("int64").reshape(-1) # Hunchback of Notre Dame
+category_id = fluid.create_lod_tensor(np.array([10, 8, 9], dtype='int64'), [[3]], place) # Animation, Children's, Musical
+movie_title = fluid.create_lod_tensor(np.array([1069, 4140, 2923, 710, 988], dtype='int64'), [[5]],
                                       place) # 'hunchback','of','notre','dame','the'
 ```
 

05.recommender_system/index.html

@@ -248,9 +248,8 @@ mov_id = train_sample[len(user_info[uid].value())]
 print("User %s rates Movie %s with Score %s"%(user_info[uid], movie_info[mov_id], train_sample[-1]))
 ```
 
-```python
-User <UserInfo id(1), gender(F), age(1), job(10)> rates Movie <MovieInfo id(1193), title(One Flew Over the Cuckoo's Nest ), categories(['Drama'])> with Score [5.0]
-```
+    User <UserInfo id(1), gender(F), age(1), job(10)> rates Movie <MovieInfo id(1193), title(One Flew Over the Cuckoo's Nest ), categories(['Drama'])> with Score [5.0]
+
 
 That is, the user 1 evaluates the movie 1193 as 5 points.
 
@@ -284,9 +283,9 @@ def get_usr_combined_features():
 
     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
 
-    uid = layers.data(name='user_id', shape=[1], dtype='int64')
+    uid = fluid.data(name='user_id', shape=[-1], dtype='int64')
 
-    usr_emb = layers.embedding(
+    usr_emb = fluid.embedding(
         input=uid,
         dtype='float32',
         size=[USR_DICT_SIZE, 32],
@@ -297,9 +296,9 @@ def get_usr_combined_features():
 
     USR_GENDER_DICT_SIZE = 2
 
-    usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
+    usr_gender_id = fluid.data(name='gender_id', shape=[-1], dtype='int64')
 
-    usr_gender_emb = layers.embedding(
+    usr_gender_emb = fluid.embedding(
         input=usr_gender_id,
         size=[USR_GENDER_DICT_SIZE, 16],
         param_attr='gender_table',
@@ -308,9 +307,9 @@ def get_usr_combined_features():
     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
 
     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
-    usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
+    usr_age_id = fluid.data(name='age_id', shape=[-1], dtype="int64")
 
-    usr_age_emb = layers.embedding(
+    usr_age_emb = fluid.embedding(
         input=usr_age_id,
         size=[USR_AGE_DICT_SIZE, 16],
         is_sparse=IS_SPARSE,
@@ -319,9 +318,9 @@ def get_usr_combined_features():
     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
 
     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
-    usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
+    usr_job_id = fluid.data(name='job_id', shape=[-1], dtype="int64")
 
-    usr_job_emb = layers.embedding(
+    usr_job_emb = fluid.embedding(
         input=usr_job_id,
         size=[USR_JOB_DICT_SIZE, 16],
         param_attr='job_table',
@@ -350,9 +349,9 @@ def get_mov_combined_features():
 
     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
 
-    mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
+    mov_id = fluid.data(name='movie_id', shape=[-1], dtype='int64')
 
-    mov_emb = layers.embedding(
+    mov_emb = fluid.embedding(
         input=mov_id,
         dtype='float32',
         size=[MOV_DICT_SIZE, 32],
@@ -363,10 +362,10 @@ def get_mov_combined_features():
 
     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
 
-    category_id = layers.data(
-        name='category_id', shape=[1], dtype='int64', lod_level=1)
+    category_id = fluid.data(
+        name='category_id', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_categories_emb = layers.embedding(
+    mov_categories_emb = fluid.embedding(
         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_categories_hidden = layers.sequence_pool(
@@ -374,10 +373,10 @@ def get_mov_combined_features():
 
     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
 
-    mov_title_id = layers.data(
-        name='movie_title', shape=[1], dtype='int64', lod_level=1)
+    mov_title_id = fluid.data(
+        name='movie_title', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_title_emb = layers.embedding(
+    mov_title_emb = fluid.embedding(
         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_title_conv = nets.sequence_conv_pool(
@@ -421,7 +420,7 @@ def train_program():
 
     scale_infer = inference_program()
 
-    label = layers.data(name='score', shape=[1], dtype='float32')
+    label = fluid.data(name='score', shape=[-1, 1], dtype='float32')
     square_cost = layers.square_error_cost(input=scale_infer, label=label)
     avg_cost = layers.mean(square_cost)
 
@@ -447,12 +446,12 @@ place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
 The next step is to define a data provider for training and testing. The provider reads in a data of size `BATCH_SIZE`. `paddle.dataset.movielens.train` will provide a data of size `BATCH_SIZE` after each scribbling, and the size of the out-of-order is the cache size `buf_size`.
 
 ```python
-train_reader = paddle.batch(
-    paddle.reader.shuffle(
+train_reader = fluid.io.batch(
+    fluid.io.shuffle(
         paddle.dataset.movielens.train(), buf_size=8192),
     batch_size=BATCH_SIZE)
 
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
 ```
 
@@ -564,13 +563,13 @@ In this prediction example, we try to predict the score given by user with ID1 f
 ```python
 infer_movie_id = 783
 infer_movie_name = paddle.dataset.movielens.movie_info()[infer_movie_id].title
-user_id = fluid.create_lod_tensor([[1]], [[1]], place)
-gender_id = fluid.create_lod_tensor([[1]], [[1]], place)
-age_id = fluid.create_lod_tensor([[0]], [[1]], place)
-job_id = fluid.create_lod_tensor([[10]], [[1]], place)
-movie_id = fluid.create_lod_tensor([[783]], [[1]], place) # Hunchback of Notre Dame
-category_id = fluid.create_lod_tensor([[10, 8, 9]], [[3]], place) # Animation, Children's, Musical
-movie_title = fluid.create_lod_tensor([[1069, 4140, 2923, 710, 988]], [[5]],
+user_id = np.array([1]).astype("int64").reshape(-1)
+gender_id = np.array([1]).astype("int64").reshape(-1)
+age_id = np.array([0]).astype("int64").reshape(-1)
+job_id = np.array([10]).astype("int64").reshape(-1)
+movie_id = np.array([783]).astype("int64").reshape(-1) # Hunchback of Notre Dame
+category_id = fluid.create_lod_tensor(np.array([10, 8, 9], dtype='int64'), [[3]], place) # Animation, Children's, Musical
+movie_title = fluid.create_lod_tensor(np.array([1069, 4140, 2923, 710, 988], dtype='int64'), [[5]],
                                       place) # 'hunchback','of','notre','dame','the'
 ```
 

05.recommender_system/train.py

@@ -44,9 +44,9 @@ def get_usr_combined_features():
 
     USR_DICT_SIZE = paddle.dataset.movielens.max_user_id() + 1
 
-    uid = layers.data(name='user_id', shape=[1], dtype='int64')
+    uid = fluid.data(name='user_id', shape=[-1], dtype='int64')
 
-    usr_emb = layers.embedding(
+    usr_emb = fluid.embedding(
         input=uid,
         dtype='float32',
         size=[USR_DICT_SIZE, 32],
@@ -57,9 +57,9 @@ def get_usr_combined_features():
 
     USR_GENDER_DICT_SIZE = 2
 
-    usr_gender_id = layers.data(name='gender_id', shape=[1], dtype='int64')
+    usr_gender_id = fluid.data(name='gender_id', shape=[-1], dtype='int64')
 
-    usr_gender_emb = layers.embedding(
+    usr_gender_emb = fluid.embedding(
         input=usr_gender_id,
         size=[USR_GENDER_DICT_SIZE, 16],
         param_attr='gender_table',
@@ -68,9 +68,9 @@ def get_usr_combined_features():
     usr_gender_fc = layers.fc(input=usr_gender_emb, size=16)
 
     USR_AGE_DICT_SIZE = len(paddle.dataset.movielens.age_table)
-    usr_age_id = layers.data(name='age_id', shape=[1], dtype="int64")
+    usr_age_id = fluid.data(name='age_id', shape=[-1], dtype="int64")
 
-    usr_age_emb = layers.embedding(
+    usr_age_emb = fluid.embedding(
         input=usr_age_id,
         size=[USR_AGE_DICT_SIZE, 16],
         is_sparse=IS_SPARSE,
@@ -79,9 +79,9 @@ def get_usr_combined_features():
     usr_age_fc = layers.fc(input=usr_age_emb, size=16)
 
     USR_JOB_DICT_SIZE = paddle.dataset.movielens.max_job_id() + 1
-    usr_job_id = layers.data(name='job_id', shape=[1], dtype="int64")
+    usr_job_id = fluid.data(name='job_id', shape=[-1], dtype="int64")
 
-    usr_job_emb = layers.embedding(
+    usr_job_emb = fluid.embedding(
         input=usr_job_id,
         size=[USR_JOB_DICT_SIZE, 16],
         param_attr='job_table',
@@ -101,9 +101,9 @@ def get_mov_combined_features():
 
     MOV_DICT_SIZE = paddle.dataset.movielens.max_movie_id() + 1
 
-    mov_id = layers.data(name='movie_id', shape=[1], dtype='int64')
+    mov_id = fluid.data(name='movie_id', shape=[-1], dtype='int64')
 
-    mov_emb = layers.embedding(
+    mov_emb = fluid.embedding(
         input=mov_id,
         dtype='float32',
         size=[MOV_DICT_SIZE, 32],
@@ -114,10 +114,10 @@ def get_mov_combined_features():
 
     CATEGORY_DICT_SIZE = len(paddle.dataset.movielens.movie_categories())
 
-    category_id = layers.data(
-        name='category_id', shape=[1], dtype='int64', lod_level=1)
+    category_id = fluid.data(
+        name='category_id', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_categories_emb = layers.embedding(
+    mov_categories_emb = fluid.embedding(
         input=category_id, size=[CATEGORY_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_categories_hidden = layers.sequence_pool(
@@ -125,10 +125,10 @@ def get_mov_combined_features():
 
     MOV_TITLE_DICT_SIZE = len(paddle.dataset.movielens.get_movie_title_dict())
 
-    mov_title_id = layers.data(
-        name='movie_title', shape=[1], dtype='int64', lod_level=1)
+    mov_title_id = fluid.data(
+        name='movie_title', shape=[-1], dtype='int64', lod_level=1)
 
-    mov_title_emb = layers.embedding(
+    mov_title_emb = fluid.embedding(
         input=mov_title_id, size=[MOV_TITLE_DICT_SIZE, 32], is_sparse=IS_SPARSE)
 
     mov_title_conv = nets.sequence_conv_pool(
@@ -153,7 +153,7 @@ def inference_program():
     inference = layers.cos_sim(X=usr_combined_features, Y=mov_combined_features)
     scale_infer = layers.scale(x=inference, scale=5.0)
 
-    label = layers.data(name='score', shape=[1], dtype='float32')
+    label = fluid.data(name='score', shape=[-1, 1], dtype='float32')
     square_cost = layers.square_error_cost(input=scale_infer, label=label)
     avg_cost = layers.mean(square_cost)
 
@@ -168,16 +168,15 @@ def train(use_cuda, params_dirname):
     place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
 
     if args.enable_ce:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.dataset.movielens.train(), batch_size=BATCH_SIZE)
-        test_reader = paddle.batch(
+        test_reader = fluid.io.batch(
             paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
     else:
-        train_reader = paddle.batch(
-            paddle.reader.shuffle(
-                paddle.dataset.movielens.train(), buf_size=8192),
+        train_reader = fluid.io.batch(
+            fluid.io.shuffle(paddle.dataset.movielens.train(), buf_size=8192),
             batch_size=BATCH_SIZE)
-        test_reader = paddle.batch(
+        test_reader = fluid.io.batch(
             paddle.dataset.movielens.test(), batch_size=BATCH_SIZE)
 
     feed_order = [
@@ -293,28 +292,27 @@ def infer(use_cuda, params_dirname):
         # Correspondingly, recursive_sequence_lengths = [[3, 2]] contains one
         # level of detail info, indicating that `data` consists of two sequences
         # of length 3 and 2, respectively.
-        user_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
+        user_id = np.array([1]).astype("int64").reshape(-1)
 
         assert feed_target_names[1] == "gender_id"
-        gender_id = fluid.create_lod_tensor([[np.int64(1)]], [[1]], place)
+        gender_id = np.array([1]).astype("int64").reshape(-1)
 
         assert feed_target_names[2] == "age_id"
-        age_id = fluid.create_lod_tensor([[np.int64(0)]], [[1]], place)
+        age_id = np.array([0]).astype("int64").reshape(-1)
 
         assert feed_target_names[3] == "job_id"
-        job_id = fluid.create_lod_tensor([[np.int64(10)]], [[1]], place)
+        job_id = np.array([10]).astype("int64").reshape(-1)
 
         assert feed_target_names[4] == "movie_id"
-        movie_id = fluid.create_lod_tensor([[np.int64(783)]], [[1]], place)
+        movie_id = np.array([783]).astype("int64").reshape(-1)
 
         assert feed_target_names[5] == "category_id"
         category_id = fluid.create_lod_tensor(
-            [np.array([10, 8, 9], dtype='int64')], [[3]], place)
+            np.array([10, 8, 9], dtype='int64'), [[3]], place)
 
         assert feed_target_names[6] == "movie_title"
         movie_title = fluid.create_lod_tensor(
-            [np.array([1069, 4140, 2923, 710, 988], dtype='int64')], [[5]],
-            place)
+            np.array([1069, 4140, 2923, 710, 988], dtype='int64'), [[5]], place)
 
         # Construct feed as a dictionary of {feed_target_name: feed_target_data}
         # and results will contain a list of data corresponding to fetch_targets.

06.understand_sentiment/README.cn.md

@@ -151,7 +151,7 @@ BATCH_SIZE = 128  #batch的大小
 ```python
 #文本卷积神经网络
 def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
     conv_3 = fluid.nets.sequence_conv_pool(
         input=emb,
@@ -183,7 +183,7 @@ def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
 def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
     #计算词向量
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
 
     #第一层栈
@@ -218,8 +218,8 @@ def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
 ```python
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.data(
+        name="words", shape=[-1], dtype="int64", lod_level=1)
 
     dict_dim = len(word_dict)
     net = convolution_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM)
@@ -235,7 +235,7 @@ def inference_program(word_dict):
 
 ```python
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1,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)
@@ -269,12 +269,12 @@ print("Loading IMDB word dict....")
 word_dict = paddle.dataset.imdb.word_dict()
 
 print ("Reading training data....")
-train_reader = paddle.batch(
+train_reader = fluid.io.batch(
     paddle.reader.shuffle(
         paddle.dataset.imdb.train(word_dict), buf_size=25000),
     batch_size=BATCH_SIZE)
 print("Reading testing data....")
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 ```
 word_dict是一个字典序列，是词和label的对应关系，运行下一行可以看到具体内容：
@@ -401,11 +401,15 @@ reviews = [c.split() for c in reviews_str]
 
 UNK = word_dict['<unk>']
 lod = []
-for c in reviews:
-    lod.append([word_dict.get(words, UNK) for words in c])
+base_shape = []
 
-base_shape = [[len(c) for c in lod]]
+for c in reviews:
+    re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+    lod = np.concatenate([lod,re],axis = 0)
+    base_shape.insert(-1, re.shape[0])
 
+base_shape = [base_shape]
+lod = np.array(lod).astype('int64')
 tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
 ```
 

06.understand_sentiment/README.md

@@ -140,7 +140,7 @@ Note that `fluid.nets.sequence_conv_pool` contains both convolution and pooling
 ```python
 #Textconvolution neural network
 def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
     conv_3 = fluid.nets.sequence_conv_pool(
         input=emb,
@@ -172,7 +172,7 @@ The code of the stack bidirectional LSTM `stacked_lstm_net` is as follows:
 def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
     # Calculate word vectorvector
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
 
     #First stack
@@ -191,7 +191,7 @@ def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
         inputs = [fc, lstm]
 
     #pooling layer
-    pc_last = fluid.layers.sequence_pool(input=inputs[0], pool_type='max')
+    fc_last = fluid.layers.sequence_pool(input=inputs[0], pool_type='max')
     lstm_last = fluid.layers.sequence_pool(input=inputs[1], pool_type='max')
 
     #Fully connected layer, softmax prediction
@@ -207,8 +207,8 @@ Next we define the prediction program (`inference_program`). We use `convolution
 
 ```python
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.data(
+        name="words", shape=[-1], dtype="int64", lod_level=1)
 
     dict_dim = len(word_dict)
     net = convolution_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM)
@@ -224,7 +224,7 @@ During the testing, the classifier calculates the probability of each output. Th
 
 ```python
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1, 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)
@@ -258,12 +258,12 @@ print("Loading IMDB word dict....")
 word_dict = paddle.dataset.imdb.word_dict()
 
 print ("Reading training data....")
-train_reader = paddle.batch(
+train_reader = fluid.io.batch(
     paddle.reader.shuffle(
         paddle.dataset.imdb.train(word_dict), buf_size=25000),
     batch_size=BATCH_SIZE)
 print("Reading testing data....")
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 ```
 Word_dict is a dictionary sequence, which is the correspondence between words and labels. You can see it specifically by running the next code:
@@ -390,11 +390,15 @@ reviews = [c.split() for c in reviews_str]
 
 UNK = word_dict['<unk>']
 lod = []
-for c in reviews:
-    lod.append([word_dict.get(words, UNK) for words in c])
+base_shape = []
 
-base_shape = [[len(c) for c in lod]]
+for c in reviews:
+    re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+    lod = np.concatenate([lod,re],axis = 0)
+    base_shape.insert(-1, re.shape[0])
 
+base_shape = [base_shape]
+lod = np.array(lod).astype('int64')
 tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
 ```
 

06.understand_sentiment/index.cn.html

@@ -193,7 +193,7 @@ BATCH_SIZE = 128  #batch的大小
 ```python
 #文本卷积神经网络
 def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
     conv_3 = fluid.nets.sequence_conv_pool(
         input=emb,
@@ -225,7 +225,7 @@ def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
 def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
     #计算词向量
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
 
     #第一层栈
@@ -260,8 +260,8 @@ def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
 ```python
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.data(
+        name="words", shape=[-1], dtype="int64", lod_level=1)
 
     dict_dim = len(word_dict)
     net = convolution_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM)
@@ -277,7 +277,7 @@ def inference_program(word_dict):
 
 ```python
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1,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)
@@ -311,12 +311,12 @@ print("Loading IMDB word dict....")
 word_dict = paddle.dataset.imdb.word_dict()
 
 print ("Reading training data....")
-train_reader = paddle.batch(
+train_reader = fluid.io.batch(
     paddle.reader.shuffle(
         paddle.dataset.imdb.train(word_dict), buf_size=25000),
     batch_size=BATCH_SIZE)
 print("Reading testing data....")
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 ```
 word_dict是一个字典序列，是词和label的对应关系，运行下一行可以看到具体内容：
@@ -443,11 +443,15 @@ reviews = [c.split() for c in reviews_str]
 
 UNK = word_dict['<unk>']
 lod = []
-for c in reviews:
-    lod.append([word_dict.get(words, UNK) for words in c])
+base_shape = []
 
-base_shape = [[len(c) for c in lod]]
+for c in reviews:
+    re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+    lod = np.concatenate([lod,re],axis = 0)
+    base_shape.insert(-1, re.shape[0])
 
+base_shape = [base_shape]
+lod = np.array(lod).astype('int64')
 tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
 ```
 

06.understand_sentiment/index.html

@@ -182,7 +182,7 @@ Note that `fluid.nets.sequence_conv_pool` contains both convolution and pooling
 ```python
 #Textconvolution neural network
 def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
     conv_3 = fluid.nets.sequence_conv_pool(
         input=emb,
@@ -214,7 +214,7 @@ The code of the stack bidirectional LSTM `stacked_lstm_net` is as follows:
 def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
     # Calculate word vectorvector
-    emb = fluid.layers.embedding(
+    emb = fluid.embedding(
         input=data, size=[input_dim, emb_dim], is_sparse=True)
 
     #First stack
@@ -233,7 +233,7 @@ def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
         inputs = [fc, lstm]
 
     #pooling layer
-    pc_last = fluid.layers.sequence_pool(input=inputs[0], pool_type='max')
+    fc_last = fluid.layers.sequence_pool(input=inputs[0], pool_type='max')
     lstm_last = fluid.layers.sequence_pool(input=inputs[1], pool_type='max')
 
     #Fully connected layer, softmax prediction
@@ -249,8 +249,8 @@ Next we define the prediction program (`inference_program`). We use `convolution
 
 ```python
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.data(
+        name="words", shape=[-1], dtype="int64", lod_level=1)
 
     dict_dim = len(word_dict)
     net = convolution_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM)
@@ -266,7 +266,7 @@ During the testing, the classifier calculates the probability of each output. Th
 
 ```python
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1, 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)
@@ -300,12 +300,12 @@ print("Loading IMDB word dict....")
 word_dict = paddle.dataset.imdb.word_dict()
 
 print ("Reading training data....")
-train_reader = paddle.batch(
+train_reader = fluid.io.batch(
     paddle.reader.shuffle(
         paddle.dataset.imdb.train(word_dict), buf_size=25000),
     batch_size=BATCH_SIZE)
 print("Reading testing data....")
-test_reader = paddle.batch(
+test_reader = fluid.io.batch(
     paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 ```
 Word_dict is a dictionary sequence, which is the correspondence between words and labels. You can see it specifically by running the next code:
@@ -432,11 +432,15 @@ reviews = [c.split() for c in reviews_str]
 
 UNK = word_dict['<unk>']
 lod = []
-for c in reviews:
-    lod.append([word_dict.get(words, UNK) for words in c])
+base_shape = []
 
-base_shape = [[len(c) for c in lod]]
+for c in reviews:
+    re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+    lod = np.concatenate([lod,re],axis = 0)
+    base_shape.insert(-1, re.shape[0])
 
+base_shape = [base_shape]
+lod = np.array(lod).astype('int64')
 tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
 ```
 

06.understand_sentiment/train_conv.py

@@ -42,8 +42,7 @@ def parse_args():
 
 
 def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
-    emb = fluid.layers.embedding(
-        input=data, size=[input_dim, emb_dim], is_sparse=True)
+    emb = fluid.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
     conv_3 = fluid.nets.sequence_conv_pool(
         input=emb,
         num_filters=hid_dim,
@@ -62,16 +61,15 @@ def convolution_net(data, input_dim, class_dim, emb_dim, hid_dim):
 
 
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
-
     dict_dim = len(word_dict)
+    data = fluid.data(name="words", shape=[-1], dtype="int64", lod_level=1)
+
     net = convolution_net(data, dict_dim, CLASS_DIM, EMB_DIM, HID_DIM)
     return net
 
 
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1, 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)
@@ -90,16 +88,16 @@ def train(use_cuda, params_dirname):
 
     print("Reading training data....")
     if args.enable_ce:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.dataset.imdb.train(word_dict), batch_size=BATCH_SIZE)
     else:
-        train_reader = paddle.batch(
-            paddle.reader.shuffle(
+        train_reader = fluid.io.batch(
+            fluid.io.shuffle(
                 paddle.dataset.imdb.train(word_dict), buf_size=25000),
             batch_size=BATCH_SIZE)
 
     print("Reading testing data....")
-    test_reader = paddle.batch(
+    test_reader = fluid.io.batch(
         paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 
     feed_order = ['words', 'label']
@@ -213,11 +211,15 @@ def infer(use_cuda, params_dirname=None):
 
         UNK = word_dict['<unk>']
         lod = []
-        for c in reviews:
-            lod.append([np.int64(word_dict.get(words, UNK)) for words in c])
+        base_shape = []
 
-        base_shape = [[len(c) for c in lod]]
+        for c in reviews:
+            re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+            lod = np.concatenate([lod, re], axis=0)
+            base_shape.insert(-1, re.shape[0])
 
+        base_shape = [base_shape]
+        lod = np.array(lod).astype('int64')
         tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
         assert feed_target_names[0] == "words"
         results = exe.run(

06.understand_sentiment/train_dyn_rnn.py

@@ -42,44 +42,18 @@ def parse_args():
 
 
 def dynamic_rnn_lstm(data, input_dim, class_dim, emb_dim, lstm_size):
-    emb = fluid.layers.embedding(
-        input=data, size=[input_dim, emb_dim], is_sparse=True)
-    sentence = fluid.layers.fc(input=emb, size=lstm_size, act='tanh')
-
-    rnn = fluid.layers.DynamicRNN()
-    with rnn.block():
-        word = rnn.step_input(sentence)
-        prev_hidden = rnn.memory(value=0.0, shape=[lstm_size])
-        prev_cell = rnn.memory(value=0.0, shape=[lstm_size])
-
-        def gate_common(ipt, hidden, size):
-            gate0 = fluid.layers.fc(input=ipt, size=size, bias_attr=True)
-            gate1 = fluid.layers.fc(input=hidden, size=size, bias_attr=False)
-            return gate0 + gate1
-
-        forget_gate = fluid.layers.sigmoid(x=gate_common(word, prev_hidden,
-                                                         lstm_size))
-        input_gate = fluid.layers.sigmoid(x=gate_common(word, prev_hidden,
-                                                        lstm_size))
-        output_gate = fluid.layers.sigmoid(x=gate_common(word, prev_hidden,
-                                                         lstm_size))
-        cell_gate = fluid.layers.sigmoid(x=gate_common(word, prev_hidden,
-                                                       lstm_size))
-
-        cell = forget_gate * prev_cell + input_gate * cell_gate
-        hidden = output_gate * fluid.layers.tanh(x=cell)
-        rnn.update_memory(prev_cell, cell)
-        rnn.update_memory(prev_hidden, hidden)
-        rnn.output(hidden)
-
-    last = fluid.layers.sequence_last_step(rnn())
+    emb = fluid.embedding(input=data, size=[input_dim, emb_dim], is_sparse=True)
+    sentence = fluid.layers.fc(input=emb, size=lstm_size * 4, act='tanh')
+
+    lstm, _ = fluid.layers.dynamic_lstm(sentence, size=lstm_size * 4)
+
+    last = fluid.layers.sequence_last_step(lstm)
     prediction = fluid.layers.fc(input=last, size=class_dim, act="softmax")
     return prediction
 
 
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.data(name="words", shape=[-1], dtype="int64", lod_level=1)
 
     dict_dim = len(word_dict)
     pred = dynamic_rnn_lstm(data, dict_dim, CLASS_DIM, EMB_DIM, LSTM_SIZE)
@@ -87,7 +61,7 @@ def inference_program(word_dict):
 
 
 def train_program(prediction):
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1, 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)
@@ -105,16 +79,16 @@ def train(use_cuda, params_dirname):
 
     print("Reading training data....")
     if args.enable_ce:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.dataset.imdb.train(word_dict), batch_size=BATCH_SIZE)
     else:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.reader.shuffle(
                 paddle.dataset.imdb.train(word_dict), buf_size=25000),
             batch_size=BATCH_SIZE)
 
     print("Reading testing data....")
-    test_reader = paddle.batch(
+    test_reader = fluid.io.batch(
         paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 
     feed_order = ['words', 'label']
@@ -226,11 +200,15 @@ def infer(use_cuda, params_dirname=None):
 
         UNK = word_dict['<unk>']
         lod = []
-        for c in reviews:
-            lod.append([np.int64(word_dict.get(words, UNK)) for words in c])
+        base_shape = []
 
-        base_shape = [[len(c) for c in lod]]
+        for c in reviews:
+            re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+            lod = np.concatenate([lod, re], axis=0)
+            base_shape.insert(-1, re.shape[0])
 
+        base_shape = [base_shape]
+        lod = np.array(lod).astype('int64')
         tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
         assert feed_target_names[0] == "words"
         results = exe.run(

06.understand_sentiment/train_stacked_lstm.py

@@ -46,8 +46,7 @@ def parse_args():
 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)
+    emb = fluid.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)
@@ -69,8 +68,7 @@ def stacked_lstm_net(data, input_dim, class_dim, emb_dim, hid_dim, stacked_num):
 
 
 def inference_program(word_dict):
-    data = fluid.layers.data(
-        name="words", shape=[1], dtype="int64", lod_level=1)
+    data = fluid.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,
@@ -80,7 +78,7 @@ def inference_program(word_dict):
 
 def train_program(prediction):
     # prediction = inference_program(word_dict)
-    label = fluid.layers.data(name="label", shape=[1], dtype="int64")
+    label = fluid.data(name="label", shape=[-1, 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)
@@ -100,16 +98,16 @@ def train(use_cuda, params_dirname):
     print("Reading training data....")
 
     if args.enable_ce:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.dataset.imdb.train(word_dict), batch_size=BATCH_SIZE)
     else:
-        train_reader = paddle.batch(
+        train_reader = fluid.io.batch(
             paddle.reader.shuffle(
                 paddle.dataset.imdb.train(word_dict), buf_size=25000),
             batch_size=BATCH_SIZE)
 
     print("Reading testing data....")
-    test_reader = paddle.batch(
+    test_reader = fluid.io.batch(
         paddle.dataset.imdb.test(word_dict), batch_size=BATCH_SIZE)
 
     feed_order = ['words', 'label']
@@ -223,11 +221,15 @@ def infer(use_cuda, params_dirname=None):
 
         UNK = word_dict['<unk>']
         lod = []
-        for c in reviews:
-            lod.append([np.int64(word_dict.get(words, UNK)) for words in c])
+        base_shape = []
 
-        base_shape = [[len(c) for c in lod]]
+        for c in reviews:
+            re = np.array([np.int64(word_dict.get(words, UNK)) for words in c])
+            lod = np.concatenate([lod, re], axis=0)
+            base_shape.insert(-1, re.shape[0])
 
+        base_shape = [base_shape]
+        lod = np.array(lod).astype('int64')
         tensor_words = fluid.create_lod_tensor(lod, base_shape, place)
         assert feed_target_names[0] == "words"
         results = exe.run(

09.gan/README.cn.md

@@ -162,7 +162,7 @@ def bn(x, name=None, act='relu'):
 
 - 卷积层
 
-调用 `fluid.nets.simple_img_conv_pool` 实现卷积池化组，卷积核大小为3x3，池化窗口大小为2x2，窗口滑动步长为2，激活函数类型由具体网络结构指定。
+调用 `fluid.nets.simple_img_conv_pool` 实现卷积池化组，卷积核大小为5x5，池化窗口大小为2x2，窗口滑动步长为2，激活函数类型由具体网络结构指定。
 
 ```python
 def conv(x, num_filters, name=None, act=None):

09.gan/index.cn.html

@@ -204,7 +204,7 @@ def bn(x, name=None, act='relu'):
 
 - 卷积层
 
-调用 `fluid.nets.simple_img_conv_pool` 实现卷积池化组，卷积核大小为3x3，池化窗口大小为2x2，窗口滑动步长为2，激活函数类型由具体网络结构指定。
+调用 `fluid.nets.simple_img_conv_pool` 实现卷积池化组，卷积核大小为5x5，池化窗口大小为2x2，窗口滑动步长为2，激活函数类型由具体网络结构指定。
 
 ```python
 def conv(x, num_filters, name=None, act=None):