add docs

docs/zh_CN/Overview.md

@@ -7,7 +7,7 @@
 
 
 ## 使用场景
-- 想要在**自己的环境**中尝试使用强化学习解决问题
+- 想要在**实际任务中**尝试使用强化学习解决问题
 - 想快速调研下**不同强化学习算法**在同一个问题上的效果
 - 强化学习算法训练速度太慢，想搭建**分布式**强化学习训练平台
 - python的GIL全局锁限制了多线程加速，想**加速python代码**
@@ -41,8 +41,8 @@
         <li><b>教程</b></li>
            <ul>
           <li><a href="tutorial/quick_start.md#quick_start">入门：解决cartpole问题</a></li>
-          <li><a href="tutorial/agent.md#agent">Agent搭建规范</a></li>
-          <li><a href="tutorial/param.md#param">参数管理</a></li>
+          <li><a href="tutorial/module.md#agent">子模块说明</a></li>
+          <li><a href="tutorial/param.md#param">模型参数管理</a></li>
           <li><a href="tutorial/summary.md#summary">绘制训练曲线</a></li>
            </ul>
         </ul>

docs/zh_CN/tutorial/agent.md

-# **教程：智能体（Agent）搭建规范**
-<p align="center">
-<img src="../../../.github/abstractions.png" width="300"/>
-</p>
\ No newline at end of file

docs/zh_CN/tutorial/module.md

+# **教程：子模块说明**
+<p align="center">
+<img src="../../../.github/abstractions.png" width="300"/>
+</p>
+在上一个教程中，我们快速地展示了如果通过PARL的三个基础模块：Model Algorithm, Agent 来搭建智能体和环境进行交互的。在这个教程中，我们将详细介绍每个模块的具体定位，以及使用规范。
+
+
+## Model
+- 定义：`Model` 用来定义前向(Forward)网络，这通常是一个策略网络(Policy Network)或者一个值函数网络(Value Function)，输入是当前环境状态(State)。
+- **注意事项**：用户得要继承`parl.Model`这个类来构建自己的Model。
+- 需要实现的函数：
+    - forward: 根据在初始化函数中声明的计算层来搭建前向网络。
+- 备注：在PARL中，实现强化学习常用的target很方便的，直接通过deepcopy即可。
+- 示例：
+```python
+import parl
+from parl import layers
+
+class CartpoleModel(parl.Model):
+    def __init__(self):
+        self.fc1 = layers.fc(size=10, act='tanh')
+        self.fc2 = layers.fc(size=2, act='softmax')
+    def forward(self, obs):
+        out = self.fc1(obs)
+        out = self.fc2(out)
+        return out
+if __name__ == '__main__:
+    model = CartpoleModel()
+    target_model = deepcopy.copy(model)
+```
+
+
+
+
+## Algorithm
+- 定义：`Algorithm` 定义了具体的算法来更新前向网络(Model)，也就是通过定义损失函数来更新Model。一个Algorithm包含至少一个Model。
+- **注意事项**：一般不自己开发，推荐直接import 仓库中已经实现好的算法。
+- 需要实现的函数（`开发新算法才需要`）：
+    - learn: 根据训练数据（观测量和输入的reward），定义损失函数，用于更新Model中的参数。
+    - predict: 根据当前的观测量，给出动作概率或者Q函数的预估值。
+- 示例：
+```python
+model = CartpoleModel()
+alg = parl.algorithms.PolicyGradient(model, lr=1e-3)
+```
+
+
+## Agent
+- 定义：`Agent` 负责算法与环境的交互，在交互过程中把生成的数据提供给Algorithm来更新模型(Model)，数据的预处理流程也一般定义在这里。
+- **注意事项**：需要继承`parl.Agent`来使用，要在构造函数中调用父类的构造函数。
+- 需要实现的函数：
+    - build_program: 定义paddle的program。用户通常在这里定义两个program：一个用于训练（在learn函数中调用），一个用于预测（用于sample、predict函数中）。
+    - learn: 根据输入的训练数据，更新模型参数。
+    - predict: 根据输入的观测量，返回要执行的动作（action）
+    - sample: 根据输入的观测量，返回要执行的动作，这个一般是添加了噪声的，用于探索用的。
+- 示例：
+```python
+class CartpoleAgent(parl.Agent):
+    def __init__(self, algorithm, obs_dim, act_dim):
+        self.obs_dim = obs_dim
+        self.act_dim = act_dim
+        super(CartpoleAgent, self).__init__(algorithm)
+
+    def build_program(self):
+        self.pred_program = fluid.Program()
+        self.train_program = fluid.Program()
+
+        with fluid.program_guard(self.pred_program):
+            obs = layers.data(
+                name='obs', shape=[self.obs_dim], dtype='float32')
+            self.act_prob = self.alg.predict(obs)
+
+        with fluid.program_guard(self.train_program):
+            obs = layers.data(
+                name='obs', shape=[self.obs_dim], dtype='float32')
+            act = layers.data(name='act', shape=[1], dtype='int64')
+            reward = layers.data(name='reward', shape=[], dtype='float32')
+            self.cost = self.alg.learn(obs, act, reward)
+
+    def sample(self, obs):
+        obs = np.expand_dims(obs, axis=0)
+        act_prob = self.fluid_executor.run(
+            self.pred_program,
+            feed={'obs': obs.astype('float32')},
+            fetch_list=[self.act_prob])[0]
+        act_prob = np.squeeze(act_prob, axis=0)
+        act = np.random.choice(range(self.act_dim), p=act_prob)
+        return act
+
+    def predict(self, obs):
+        obs = np.expand_dims(obs, axis=0)
+        act_prob = self.fluid_executor.run(
+            self.pred_program,
+            feed={'obs': obs.astype('float32')},
+            fetch_list=[self.act_prob])[0]
+        act_prob = np.squeeze(act_prob, axis=0)
+        act = np.argmax(act_prob)
+        return act
+
+    def learn(self, obs, act, reward):
+        act = np.expand_dims(act, axis=-1)
+        feed = {
+            'obs': obs.astype('float32'),
+            'act': act.astype('int64'),
+            'reward': reward.astype('float32')
+        }
+        cost = self.fluid_executor.run(
+            self.train_program, feed=feed, fetch_list=[self.cost])[0]
+        return cost
+if __name__ == '__main__':
+    model = CartpoleModel()
+    alg = parl.algorithms.PolicyGradient(model, lr=1e-3)
+    agent = CartpoleAgent(alg, obs_dim=4, act_dim=2)
+```
\ No newline at end of file

docs/zh_CN/tutorial/param.md

@@ -11,7 +11,7 @@ agent.restore('./model.ckpt')
 
 ```
 
-场景2: 并行训练过程中，经常需要把最新的模型参数同步到另一台服务器上，这时候，需要把模型参数拿到。
+场景2: 并行训练过程中，经常需要把最新的模型参数同步到另一台服务器上，这时候，需要把模型参数拿到内存中，然后再赋值给另一台机器上的agent（actor)。
 
 ```python
 #--------------Agent---------------