Fix docs nas (#830)

* fix_docs_nas

* fix_again

* fix_again_
Co-authored-by: Nceci3 <ceci3@users.noreply.github.com>

docs/en/quick_start/nas_tutorial_en.md

@@ -24,7 +24,9 @@ The following chapter describes each steps in order.
 Please make sure that you haved installed Paddle correctly, then do the necessary imports.
 ```python
 import paddle
-import paddle.fluid as fluid
+import paddle.nn as nn
+import paddle.nn.functional as F
+import paddle.static as static
 import paddleslim as slim
 import numpy as np
 ```
@@ -33,33 +35,35 @@ import numpy as np
 
 Please set a unused port when build instance of SANAS.
 ```python
-sanas = slim.nas.SANAS(configs=[('MobileNetV2Space')], server_addr=("", 8911), save_checkpoint=None)
+port = np.random.randint(8337, 8773)
+sanas = slim.nas.SANAS(configs=[('MobileNetV2Space')], server_addr=("", port), save_checkpoint=None)
 ```
 
 ## 3. define function about building program
 Build program about training and evaluation according to the model architecture.
 ```python
+paddle.enable_static()
 def build_program(archs):
-    train_program = fluid.Program()
-    startup_program = fluid.Program()
-    with fluid.program_guard(train_program, startup_program):
-        data = fluid.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
-        label = fluid.data(name='label', shape=[None, 1], dtype='int64')
+    train_program = static.Program()
+    startup_program = static.Program()
+    with static.program_guard(train_program, startup_program):
+        data = static.data(name='data', shape=[None, 3, 32, 32], dtype='float32')
+        label = static.data(name='label', shape=[None, 1], dtype='int64')
+        gt = paddle.reshape(label, [-1, 1])
         output = archs(data)
-        output = fluid.layers.fc(input=output, size=10)
+        output = static.nn.fc(output, size=10)
 
-        softmax_out = fluid.layers.softmax(input=output, use_cudnn=False)
-        cost = fluid.layers.cross_entropy(input=softmax_out, label=label)
-        avg_cost = fluid.layers.mean(cost)
-        acc_top1 = fluid.layers.accuracy(input=softmax_out, label=label, k=1)
-        acc_top5 = fluid.layers.accuracy(input=softmax_out, label=label, k=5)
-        test_program = fluid.default_main_program().clone(for_test=True)
+        softmax_out = F.softmax(output)
+        cost = F.cross_entropy(softmax_out, label=gt)
+        avg_cost = paddle.mean(cost)
+        acc_top1 = paddle.metric.accuracy(input=softmax_out, label=gt, k=1)
+        acc_top5 = paddle.metric.accuracy(input=softmax_out, label=gt, k=5)
+        test_program = static.default_main_program().clone(for_test=True)
 
-        optimizer = fluid.optimizer.Adam(learning_rate=0.1)
+        optimizer = paddle.optimizer.Adam(learning_rate=0.1)
         optimizer.minimize(avg_cost)
-
-        place = fluid.CPUPlace()
-        exe = fluid.Executor(place)
+        place = paddle.CPUPlace()
+        exe = static.Executor(place)
         exe.run(startup_program)
     return exe, train_program, test_program, (data, label), avg_cost, acc_top1, acc_top5
 ```
@@ -67,32 +71,47 @@ def build_program(archs):
 ## 4. define function about input data
 The dataset we used is cifar10, and `paddle.dataset.cifar` in Paddle including the download and pre-read about cifar.
 ```python
-def input_data(inputs):
-    train_reader = paddle.fluid.io.batch(paddle.reader.shuffle(paddle.dataset.cifar.train10(cycle=False), buf_size=1024),batch_size=256)
-    train_feeder = fluid.DataFeeder(inputs, fluid.CPUPlace())
-    eval_reader = paddle.fluid.io.batch(paddle.dataset.cifar.test10(cycle=False), batch_size=256)
-    eval_feeder = fluid.DataFeeder(inputs, fluid.CPUPlace())
-    return train_reader, train_feeder, eval_reader, eval_feeder
+import paddle.vision.transforms as T
+
+def input_data(image, label):
+    transform = T.Compose([T.Transpose(), T.Normalize([127.5], [127.5])])
+    train_dataset = paddle.vision.datasets.Cifar10(mode="train", transform=transform, backend='cv2')
+    train_loader = paddle.io.DataLoader(train_dataset,
+                    places=paddle.CPUPlace(),
+                    feed_list=[image, label],
+                    drop_last=True,
+                    batch_size=64,
+                    return_list=False,
+                    shuffle=True)
+    eval_dataset = paddle.vision.datasets.Cifar10(mode="test", transform=transform, backend='cv2')
+    eval_loader = paddle.io.DataLoader(eval_dataset,
+                    places=paddle.CPUPlace(),
+                    feed_list=[image, label],
+                    drop_last=False,
+                    batch_size=64,
+                    return_list=False,
+                    shuffle=False)
+    return train_loader, eval_loader
 ```
 
 ## 5. define function about training
 Start training.
 ```python
-def start_train(program, data_reader, data_feeder):
+def start_train(program, data_loader):
     outputs = [avg_cost.name, acc_top1.name, acc_top5.name]
-    for data in data_reader():
-        batch_reward = exe.run(program, feed=data_feeder.feed(data), fetch_list = outputs)
+    for data in data_loader():
+        batch_reward = exe.run(program, feed=data, fetch_list = outputs)
         print("TRAIN: loss: {}, acc1: {}, acc5:{}".format(batch_reward[0], batch_reward[1], batch_reward[2]))
 ```
 
 ## 6. define funciton about evaluation
 Start evaluating.
 ```python
-def start_eval(program, data_reader, data_feeder):
+def start_eval(program, data_loader):
     reward = []
     outputs = [avg_cost.name, acc_top1.name, acc_top5.name]
-    for data in data_reader():
-        batch_reward = exe.run(program, feed=data_feeder.feed(data), fetch_list = outputs)
+    for data in data_loader():
+        batch_reward = exe.run(program, feed=data, fetch_list = outputs)
         reward_avg = np.mean(np.array(batch_reward), axis=1)
         reward.append(reward_avg)
         print("TEST: loss: {}, acc1: {}, acc5:{}".format(batch_reward[0], batch_reward[1], batch_reward[2]))
@@ -114,23 +133,23 @@ archs = sanas.next_archs()[0]
 Get program according to the function in Step3 and model architecture from Step 7.1.
 ```python
 paddle.enable_static()
-exe, train_program, eval_program, inputs, avg_cost, acc_top1, acc_top5 = build_program(archs)
+exe, train_program, eval_program, (image, label), avg_cost, acc_top1, acc_top5 = build_program(archs)
 ```
 
 ### 7.3 define input data
 ```python
-train_reader, train_feeder, eval_reader, eval_feeder = input_data(inputs)
+train_loader, eval_loader = input_data(image, label)
 ```
 
 ### 7.4 train model
 Start training according to train program and data.
 ```python
-start_train(train_program, train_reader, train_feeder)
+start_train(train_program, train_loader)
 ```
 ### 7.5 evaluate model
 Start evaluation according to evaluation program and data.
 ```python
-finally_reward = start_eval(eval_program, eval_reader, eval_feeder)
+finally_reward = start_eval(eval_program, eval_loader)
 ```
 ### 7.6 reture score
 ```
@@ -142,17 +161,17 @@ The following is a full example about neural architecture search, it uses FLOPs
 ```python
 for step in range(3):
     archs = sanas.next_archs()[0]
-    exe, train_program, eval_progarm, inputs, avg_cost, acc_top1, acc_top5 = build_program(archs)
-    train_reader, train_feeder, eval_reader, eval_feeder = input_data(inputs)
+    exe, train_program, eval_program, (images,label), avg_cost, acc_top1, acc_top5 = build_program(archs)
+    train_loader, eval_loader = input_data(images, label)
 
     current_flops = slim.analysis.flops(train_program)
     if current_flops > 321208544:
         continue
 
     for epoch in range(7):
-        start_train(train_program, train_reader, train_feeder)
+        start_train(train_program, train_loader)
 
-    finally_reward = start_eval(eval_program, eval_reader, eval_feeder)
+    finally_reward = start_eval(eval_program, eval_loader)
 
     sanas.reward(float(finally_reward[1]))
 ```

docs/zh_cn/api_cn/static/nas/nas_api.rst

@@ -49,7 +49,7 @@ SANAS（Simulated Annealing Neural Architecture Search）是基于模拟退火
    from paddleslim.nas import SANAS
    config = [('MobileNetV2Space')]
    paddle.enable_static()
-   sanas = SANAS(configs=config, , server_addr=("",8821))
+   sanas = SANAS(configs=config, server_addr=("",8821))
 
 .. note::
 
@@ -94,6 +94,7 @@ SANAS（Simulated Annealing Neural Architecture Search）是基于模拟退火
       for arch in archs:
           output = arch(input)
           input = output
+
       print(output)
    
    .. py:method:: reward(score)

docs/zh_cn/quick_start/static/nas_tutorial.md

@@ -34,7 +34,8 @@ import numpy as np
 
 ## 2. 初始化SANAS搜索实例
 ```python
-sanas = slim.nas.SANAS(configs=[('MobileNetV2Space')], server_addr=("", 8337), save_checkpoint=None)
+port = np.random.randint(8337, 8773)
+sanas = slim.nas.SANAS(configs=[('MobileNetV2Space')], server_addr=("", port), save_checkpoint=None)
 ```
 
 ## 3. 构建网络
@@ -60,7 +61,6 @@ def build_program(archs):
 
         optimizer = paddle.optimizer.Adam(learning_rate=0.1)
         optimizer.minimize(avg_cost)
-
         place = paddle.CPUPlace()
         exe = static.Executor(place)
         exe.run(startup_program)

docs/zh_cn/tutorials/nas/static/sanas_darts_space.md

@@ -44,7 +44,7 @@ from paddleslim.nas import SANAS
 
 BATCH_SIZE=96
 SERVER_ADDRESS = ""
-PORT = 8377
+PORT = np.random.randint(8337, 8773)
 SEARCH_STEPS = 300
 RETAIN_EPOCH=30
 MAX_PARAMS=3.77
@@ -208,6 +208,7 @@ archs = sa_nas.next_archs()[0]
 #### 9.2 构造训练和预测program
 根据上一步中获得的模型结构分别构造训练program和预测program。
 ```python
+paddle.enable_static()
 train_program = fluid.Program()
 test_program = fluid.Program()
 startup_program = fluid.Program()
@@ -244,6 +245,7 @@ test_loader.set_sample_list_generator(test_reader, places=place)
 
 #### 9.6 启动训练和评估
 ```python
+valid_top1_list = []
 for epoch_id in range(RETAIN_EPOCH):
     train_top1 = train(train_program, exe, epoch_id, train_loader, train_fetch_list)
     print("TRAIN: Epoch {}, train_acc {:.6f}".format(epoch_id, train_top1))