modified gcn and lstm experiments

graph_convolutional_network/README.md

-# Graph_Convolutional_Network
+# Graph Convolutional Network
 
-## Graph_Convolutional_Network原理
+## 实验介绍
+
+图卷积网络（Graph Convolutional Network，GCN）是近年来逐渐流行的一种神经网络结构。不同于只能用于网格结构（grid-based）数据的传统网络模型LSTM和CNN，图卷积网络能够处理具有广义拓扑图结构的数据，并深入发掘其特征和规律。
+
+本实验主要介绍在下载的Cora和Citeseer数据集上使用MindSpore进行图卷积网络的训练。
 
 ### 图卷积神经网络由来
 
@@ -15,18 +19,18 @@
 > 1. 在图像为代表的欧式空间中，结点的邻居数量都是固定的。比如说绿色结点的邻居始终是8个。在图这种非欧空间中，结点有多少邻居并不固定。目前绿色结点的邻居结点有2个，但其他结点也会有5个邻居的情况。
 > 2. 欧式空间中的卷积操作实际上是用固定大小可学习的卷积核来抽取像素的特征。对于非欧式空间因为邻居结点不固定，所以传统的卷积核不能直接用于抽取图上结点的特征。
 
-![GCN](images/gcn1.png)
+![Graph data](images/gcn1.png)
 
-为了解决传统卷积不能直接应用在邻居结点数量不固定的非欧式空间数据上的问题。
+为了解决传统卷积不能直接应用在邻居结点数量不固定的非欧式空间数据上的问题，目前有两种主流的方法：
 
 1. 提出一种方式把非欧空间的图转换成欧式空间。
-2. 找出一种可处理变长邻居结点的卷积核在图上抽取特征。（图卷积属于这一种，后边又将其分为基于空间域和基于频域）
+2. 找出一种可处理变长邻居结点的卷积核在图上抽取特征。图卷积属于这一种，又分为基于空间域和基于频域的方法。
 
 ### 图卷积神经网络概述
 
-GCN的本质目的就是用来提取拓扑图的空间特征。 图卷积神经网络主要有两类，一类是基于空间域（spatial domain）或顶点域（vertex domain）的，另一类则是基于频域或谱域（spectral domain）的。GCN属于频域图卷积神经网络。
+GCN的本质目的就是用来提取拓扑图的空间特征。图卷积神经网络主要有两类，一类是基于空间域（spatial domain）或顶点域（vertex domain）的，另一类则是基于频域或谱域（spectral domain）的。GCN属于频域图卷积神经网络。
 
-基于空域卷积的方法直接将卷积操作定义在每个结点的连接关系上，它跟传统的卷积神经网络中的卷积更相似一些。在这个类别中比较有代表性的方法有 Message Passing Neural Networks(MPNN), GraphSage, Diffusion Convolution Neural Networks(DCNN), PATCHY-SAN等。
+空间域方法直接将卷积操作定义在每个结点的连接关系上，它跟传统的卷积神经网络中的卷积更相似一些。在这个类别中比较有代表性的方法有Message Passing Neural Networks(MPNN), GraphSage, Diffusion Convolution Neural Networks(DCNN), PATCHY-SAN等。
 
 频域方法希望借助图谱的理论来实现拓扑图上的卷积操作。从整个研究的时间进程来看：首先研究GSP（graph signal processing）的学者定义了graph上的傅里叶变化（Fourier Transformation），进而定义了graph上的卷积，最后与深度学习结合提出了Graph Convolutional Network（GCN）。
 
@@ -34,12 +38,13 @@ GCN的本质目的就是用来提取拓扑图的空间特征。 图卷积神经
 
 过程：
 
-1. 定义graph上的Fourier Transformation傅里叶变换
-2. 定义graph上的convolution卷积
+1. 定义graph上的Fourier Transformation傅里叶变换；
+2. 定义graph上的convolution卷积。
 
 #### 图上的傅里叶变换
 
 传统的傅里叶变换：
+
 $$
 F(w) = \int f(t)e^{-jwt}dt
 $$
@@ -48,11 +53,13 @@ $$
 
 注：特征向量定义：特征方程$ AV= \lambda V $中V为特征向量，$\lambda $为特征值
 
-由于图节点为离散的，我们将上面傅里叶变换离散化，使用有限项分量来近似F(w) ，得到图上的傅里叶变换：
+由于图节点为离散的，我们将上面傅里叶变换离散化，使用有限项分量来近似F(w)，得到图上的傅里叶变换：
 
-​                                                              $ F(\lambda _l) = \hat {f(\lambda _l)} = \sum_{i=1}^{N}{f(i)}u_l(i)i $
+$$
+F(\lambda _l) = \hat {f(\lambda _l)} = \sum_ {i=1}^{N} f(i) u_l(i)
+$$
 
-其中$u_l(i)$为基函数、特征向量，$\lambda _l$为$u_l(i)$对应的特征值，$ f(i）$为特i征值$\lambda _l$下的$f$ 。即：特征值$\lambda _l$下的$f$ 的傅里叶变换是该分量与$\lambda _l$对应的特征向量$u_l$进行内积运算。这里用拉普拉斯向量$u_l$替换傅里叶变换的基$ e^{-jwt} $，后边我们将定义拉普拉斯矩阵。
+其中$u_l(i)$为基函数、特征向量，$\lambda _l$为$u_l(i)$对应的特征值，$f(i)$为特征值$\lambda _l$下的$f$ 。即：特征值$\lambda _l$下的$f$ 的傅里叶变换是该分量与$\lambda _l$对应的特征向量$u_l$进行内积运算。这里用拉普拉斯正交向量$u_l$替换傅里叶变换的基$ e^{-jwt} $，后边我们将定义拉普拉斯矩阵。
 
 利用矩阵乘法将Graph上的傅里叶变换推广到矩阵形式：
 
@@ -63,11 +70,12 @@ $$
 \left[ \begin{matrix} {f(1)} \\  {f(2)} \\ ...  \\  {f(N)} \end{matrix} \right]
 $$
 
-即 f 在Graph上傅里叶变换的矩阵形式为：$\hat f = U^Tf$
+即：
 
- f 在Graph上傅里叶逆变换的矩阵形式为：$f = U\hat f$
+- f 在Graph上傅里叶变换的矩阵形式为：$\hat f = U^Tf$
+- f 在Graph上傅里叶逆变换的矩阵形式为：$f = U\hat f$
 
-其中$U$为f的特征矩阵，拉普拉斯矩阵的正交基（后边我们会提到拉普拉斯矩阵）。它是一个对称正交矩阵，故$U^T=U^{-1}$
+其中$U$为f的特征矩阵，拉普拉斯矩阵的正交基（后边我们会提到拉普拉斯矩阵）。它是一个对称正交矩阵，故$U^T=U^{-1}$。
 
 #### 图卷积
 
@@ -119,15 +127,9 @@ $$
 
 U取图的度矩阵（如下图中的degree matrix）,H取图的邻接矩阵（如下图中的adjacency matrix）
 
-![GCN](images/gcn2.png)
+![png](images/gcn2.png)
 
-[Graph_Convolutional_Network原理引用于论文]: https://arxiv.org/pdf/1609.02907.pdf
-
-## 实验介绍
-
-图卷积网络（Graph Convolutional Network，GCN）是近年来逐渐流行的一种神经网络结构。不同于只能用于网格结构（grid-based）数据的传统网络模型 LSTM 和 CNN，图卷积网络能够处理具有广义拓扑图结构的数据，并深入发掘其特征和规律。
-
-本实验主要介绍在下载的Cora和Citeseer数据集上使用MindSpore进行图卷积网络的训练。
+[1] Graph Convolutional Network原理引用自论文：https://arxiv.org/pdf/1609.02907.pdf
 
 ## 实验目的
 
@@ -149,43 +151,47 @@ U取图的度矩阵（如下图中的degree matrix）,H取图的邻接矩阵（
 
 ### 数据集准备
 
-从[github](https://github.com/kimiyoung/planetoid)下载/kimiyoung/planetoid提供的数据集Cora或Citeseer。这是Planetoid的一种实现，以下论文提出了一种基于图的半监督学习方法：[图嵌入技术在半监督学习中的应用](https://arxiv.org/abs/1603.08861)
+Cora和CiteSeer是图神经网络常用的数据集，数据集官网[LINQS Datasets](https://linqs.soe.ucsc.edu/data)。
+
+Cora数据集包含2708个科学出版物，分为七个类别。 引用网络由5429个链接组成。 数据集中的每个出版物都用一个0/1值的词向量描述，0/1指示词向量中是否出现字典中相应的词。 该词典包含1433个独特的单词。 数据集中的README文件提供了更多详细信息。
+
+CiteSeer数据集包含3312种科学出版物，分为六类。 引用网络由4732个链接组成。 数据集中的每个出版物都用一个0/1值的词向量描述，0/1指示词向量中是否出现字典中相应的词。 该词典包含3703个独特的单词。 数据集中的README文件提供了更多详细信息。
+
+本实验使用Github上[kimiyoung/planetoid](https://github.com/kimiyoung/planetoid/tree/master/data)预处理和划分好的数据集。
 
 将数据集放置到所需的路径下，该文件夹应包含以下文件：
 
 ```
-└─data 
-    ├─ind.cora.allx 
-    ├─ind.cora.ally 
-    ├─...
-    ├─ind.cora.test.index 
-    ├─trans.citeseer.tx
-    ├─trans.citeseer.ty
-    ├─...
-    └─trans.pubmed.y
+data 
+├── ind.cora.allx 
+├── ind.cora.ally 
+├── ...
+├── ind.cora.test.index 
+├── trans.citeseer.tx
+├── trans.citeseer.ty
+├── ...
+└── trans.pubmed.y
 ```
 
-其中模型的输入包含：
+inductive模型的输入包含：
 
-- `x`，标记训练实例的特征向量，
-- `y`，即已标记的训练实例的热门标签，
-- `allx`，标记的和未标记的训练实例（的超集`x`）的特征向量，
-- `graph`，`dict`格式为`{index: [index_of_neighbor_nodes]}.`
+- `x`，已标记的训练实例的特征向量，
+- `y`，已标记的训练实例的one-hot标签，
+- `allx`，标记的和未标记的训练实例（`x`的超集）的特征向量，
+- `graph`，一个`dict`，格式为`{index: [index_of_neighbor_nodes]}.`
 
-令n为标记和未标记训练实例的数量。这n个实例的索引应从0到n-1 `graph`，其顺序与中的顺序相同`allx`。
+令n为标记和未标记训练实例的数量。在`graph`中这n个实例的索引应从0到n-1，其顺序与`allx`中的顺序相同。
 
 除了`x`，`y`，`allx`，和`graph`如上所述，预处理的数据集还包括：
 
 - `tx`，测试实例的特征向量，
-- `ty`，测试实例的热门标签，
-- `test.index`，`graph`对于归纳设置，中的测试实例的索引，
-- `ally`，是中实例的标签`allx`。
-
-`graph`转换设置中测试实例的索引是从`#x`到`#x + #tx - 1`，与中的顺序相同`tx`。
+- `ty`，测试实例的one-hot标签，
+- `test.index`，`graph`中测试实例的索引，
+- `ally`，是`allx`中实例的标签。
 
 ### 脚本准备
 
-从[MindSpore model_zoo](https://gitee.com/mindspore/mindspore/tree/r0.5/model_zoo/gcn)中下载GCN代码；[课程gitee仓库](https://gitee.com/mindspore/course)上下载本实验相关脚本。
+从[MindSpore model_zoo](https://gitee.com/mindspore/mindspore/tree/r0.5/model_zoo/gcn)中下载GCN代码；从[课程gitee仓库](https://gitee.com/mindspore/course)中下载本实验相关脚本。
 
 ### 上传文件
 
@@ -195,16 +201,15 @@ U取图的度矩阵（如下图中的degree matrix）,H取图的邻接矩阵（
 experiment
 ├── data
 ├── graph_to_mindrecord 
-│   ├── citeseer 
+│   ├── citeseer
 │   ├── cora
 │   ├── graph_map_schema.py
-│   ├── writer.py
+│   └── writer.py
 │── src
-│   ├── config.py 
-│   ├── dataset.py 
-│   ├── gcn.py 
-│   ├── metrics.py
-│── README.md
+│   ├── config.py
+│   ├── dataset.py
+│   ├── gcn.py
+│   └── metrics.py
 └── main.py
 ```
 
@@ -214,52 +219,26 @@ experiment
 
 #### 数据处理
 
-将Cora或Citeseer生成mindrecord格式的数据集。（可在cfg中设置`DATASET_NAME`为cora或者citeseer来转换不同的数据集）
+`graph_to_mindrecord/writer.py`用于将Cora或Citeseer数据集转换为mindrecord格式，便于提高数据集读取和处理的性能。（可在`main.py`的cfg中设置`DATASET_NAME`为cora或者citeseer来切换不同的数据集）
 
 ```python
-def run(cfg):
-    args = read_args()
-    #建立输出文件夹
-    cur_path = os.getcwd()
-    M_PATH = os.path.join(cur_path, cfg.MINDRECORD_PATH)
-    if os.path.exists(M_PATH):
-        shutil.rmtree(M_PATH)  # 删除文件夹
-    os.mkdir(M_PATH)
-    cfg.SRC_PATH = os.path.join(cur_path, cfg.SRC_PATH)
-    #参数
-    args.mindrecord_script= cfg.DATASET_NAME
-    args.mindrecord_file=os.path.join(cfg.MINDRECORD_PATH,cfg.DATASET_NAME)
-    args.mindrecord_partitions=cfg.mindrecord_partitions
-    args.mindrecord_header_size_by_bit=cfg.mindrecord_header_size_by_bit
-    args.mindrecord_page_size_by_bit=cfg.mindrecord_header_size_by_bit
-    args.graph_api_args=cfg.SRC_PATH
-
-    start_time = time.time()
-    # pass mr_api arguments
-    os.environ['graph_api_args'] = args.graph_api_args
-
-    try:
-        mr_api = import_module('graph_to_mindrecord.'+args.mindrecord_script + '.mr_api')
-    except ModuleNotFoundError:
-        raise RuntimeError("Unknown module path: {}".format(args.mindrecord_script + '.mr_api'))
-
-    # init graph schema
-    graph_map_schema = GraphMapSchema()
-
-    num_features, feature_data_types, feature_shapes = mr_api.node_profile
-    graph_map_schema.set_node_feature_profile(num_features, feature_data_types, feature_shapes)
-
-    num_features, feature_data_types, feature_shapes = mr_api.edge_profile
-    graph_map_schema.set_edge_feature_profile(num_features, feature_data_types, feature_shapes)
-
-    graph_schema = graph_map_schema.get_schema()
+# init writer
+writer = init_writer(graph_schema)
+
+# write nodes data
+mindrecord_dict_data = mr_api.yield_nodes
+run_parallel_workers()
+
+# write edges data
+mindrecord_dict_data = mr_api.yield_edges
+run_parallel_workers()
 ```
 
-### 参数配置
+#### 参数配置
 
-训练参数可以在config.py中设置。
+训练参数可以在`src/config.py`中设置。
 
-```shell
+```python
 "learning_rate": 0.01,            # Learning rate
 "epochs": 200,                    # Epoch sizes for training
 "hidden1": 16,                    # Hidden size for the first graph convolution layer
@@ -268,12 +247,98 @@ def run(cfg):
 "early_stopping": 10,             # Tolerance for early stopping
 ```
 
-### 运行训练
+#### 模型定义
 
-```shell
-def train(args_opt):
-    """Train model."""
-    np.random.seed(args_opt.seed)
+图卷积网络及其依赖的图卷积算子定义在`gcn/src/gcn.py`中。
+
+图卷积算子基于MindSpore `nn.Dense()`和`P.MatMul()`算子实现。
+
+```python
+class GraphConvolution(nn.Cell):
+    """
+    GCN graph convolution layer.
+
+    Args:
+        feature_in_dim (int): The input feature dimension.
+        feature_out_dim (int): The output feature dimension.
+        dropout_ratio (float): Dropout ratio for the dropout layer. Default: None.
+        activation (str): Activation function applied to the output of the layer, eg. 'relu'. Default: None.
+
+    Inputs:
+        - **adj** (Tensor) - Tensor of shape :math:`(N, N)`.
+        - **input_feature** (Tensor) - Tensor of shape :math:`(N, C)`.
+
+    Outputs:
+        Tensor, output tensor.
+    """
+
+    def __init__(self,
+                 feature_in_dim,
+                 feature_out_dim,
+                 dropout_ratio=None,
+                 activation=None):
+        super(GraphConvolution, self).__init__()
+        self.in_dim = feature_in_dim
+        self.out_dim = feature_out_dim
+        self.weight_init = glorot([self.out_dim, self.in_dim])
+        self.fc = nn.Dense(self.in_dim,
+                           self.out_dim,
+                           weight_init=self.weight_init,
+                           has_bias=False)
+        self.dropout_ratio = dropout_ratio
+        if self.dropout_ratio is not None:
+            self.dropout = nn.Dropout(keep_prob=1-self.dropout_ratio)
+        self.dropout_flag = self.dropout_ratio is not None
+        self.activation = get_activation(activation)
+        self.activation_flag = self.activation is not None
+        self.matmul = P.MatMul()
+
+    def construct(self, adj, input_feature):
+        dropout = input_feature
+        if self.dropout_flag:
+            dropout = self.dropout(dropout)
+
+        fc = self.fc(dropout)
+        output_feature = self.matmul(adj, fc)
+
+        if self.activation_flag:
+            output_feature = self.activation(output_feature)
+        return output_feature
+```
+
+图卷积网络使用了两层图卷积层，即只采集二阶邻居。
+
+```python
+class GCN(nn.Cell):
+    """
+    GCN architecture.
+
+    Args:
+        config (ConfigGCN): Configuration for GCN.
+        adj (numpy.ndarray): Numbers of block in different layers.
+        feature (numpy.ndarray): Input channel in each layer.
+        output_dim (int): The number of output channels, equal to classes num.
+    """
+
+    def __init__(self, config, adj, feature, output_dim):
+        super(GCN, self).__init__()
+        self.adj = Tensor(adj)
+        self.feature = Tensor(feature)
+        input_dim = feature.shape[1]
+        self.layer0 = GraphConvolution(input_dim, config.hidden1, activation="relu", dropout_ratio=config.dropout)
+        self.layer1 = GraphConvolution(config.hidden1, output_dim, dropout_ratio=None)
+
+    def construct(self):
+        output0 = self.layer0(self.adj, self.feature)
+        output1 = self.layer1(self.adj, output0)
+        return output1
+```
+
+#### 模型训练
+
+训练和验证的主要逻辑在`main.py`中。包括数据集、网络、训练函数和验证函数的初始化，以及训练逻辑的控制。
+
+```python
     config = ConfigGCN()
     adj, feature, label = get_adj_features_labels(args_opt.data_dir)
 
@@ -305,10 +370,9 @@ def train(args_opt):
         eval_accuracy = eval_result[1].asnumpy()
 
         loss_list.append(eval_loss)
-        if epoch%10==0:
-            print("Epoch:", '%04d' % (epoch), "train_loss=", "{:.5f}".format(train_loss),
-                "train_acc=", "{:.5f}".format(train_accuracy), "val_loss=", "{:.5f}".format(eval_loss),
-                "val_acc=", "{:.5f}".format(eval_accuracy), "time=", "{:.5f}".format(time.time() - t))
+        print("Epoch:", '%04d' % (epoch + 1), "train_loss=", "{:.5f}".format(train_loss),
+              "train_acc=", "{:.5f}".format(train_accuracy), "val_loss=", "{:.5f}".format(eval_loss),
+              "val_acc=", "{:.5f}".format(eval_accuracy), "time=", "{:.5f}".format(time.time() - t))
 
         if epoch > config.early_stopping and loss_list[-1] > np.mean(loss_list[-(config.early_stopping+1):-1]):
             print("Early stopping...")
@@ -321,55 +385,9 @@ def train(args_opt):
     test_accuracy = test_result[1].asnumpy()
     print("Test set results:", "loss=", "{:.5f}".format(test_loss),
           "accuracy=", "{:.5f}".format(test_accuracy), "time=", "{:.5f}".format(time.time() - t_test))
-          
-if __name__ == '__main__':
-    #------------------------定义变量------------------------------
-    parser = argparse.ArgumentParser(description='GCN')
-    parser.add_argument('--data_url', type=str, default='./data', help='Dataset directory')
-    args_opt = parser.parse_args()
-
-    dataname = 'cora'
-    datadir_save = './data_mr'
-    datadir = os.path.join(datadir_save, dataname)
-    cfg = edict({
-        'SRC_PATH': './data',
-        'MINDRECORD_PATH': datadir_save,
-        'DATASET_NAME': dataname,  # citeseer,cora
-        'mindrecord_partitions':1,
-        'mindrecord_header_size_by_bit' : 18,
-        'mindrecord_page_size_by_bit' : 20,
-
-        'data_dir': datadir,
-        'seed' : 123,
-        'train_nodes_num':140,
-        'eval_nodes_num':500,
-        'test_nodes_num':1000
-    })
-
-    #转换数据格式
-    print("============== Graph To Mindrecord ==============")
-    run(cfg)
-    #训练
-    print("============== Starting Training ==============")
-    train(cfg)       
-```
-
-MindSpore暂时没有提供直接访问OBS数据的接口，需要通过MoXing提供的API与OBS交互。将OBS中存储的数据拷贝至执行容器：
-
-```python
-import moxing as mox
-mox.file.copy_parallel(args.data_url, dst_url='./data')
-```
-
-将训练模型Checkpoint从执行容器拷贝至OBS：
-
-```python
-mox.file.copy_parallel(src_url='data_mr', dst_url=cfg.MINDRECORD_PATH)
 ```
 
-### 实验结果
-
-训练结果将存储在脚本路径中，该路径的文件夹名称以“ train”开头。可以在日志中找到类似以下结果。
+训练结果将存储在脚本路径中，该路径的文件夹名称以“train”开头。可以在日志中找到类似以下结果。
 
 ```shell
 Epoch: 0000 train_loss= 1.95401 train_acc= 0.12143 val_loss= 1.94917 val_acc= 0.31400 time= 36.95478
@@ -406,17 +424,24 @@ Test set results: loss= 1.01702 accuracy= 0.81400 time= 6.51215
 ```python
 import argparse
 parser = argparse.ArgumentParser()
-parser.add_argument('--data_url', required=False, default=None, help='Location of data.')
-parser.add_argument('--train_url', required=False, default=None, help='Location of training outputs.')
-args = parser.parse_args()
-dataset = args.dataset
+parser.add_argument('--data_url', required=True, default=None, help='Location of data.')
+parser.add_argument('--train_url', required=True, default=None, help='Location of training outputs.')
+args, unknown = parser.parse_known_args()
 ```
 
-MindSpore暂时没有提供直接访问OBS数据的接口，需要通过MoXing提供的API与OBS交互。将OBS中存储的数据拷贝至执行容器（见`start.py`）：
+MindSpore暂时没有提供直接访问OBS数据的接口，需要通过MoXing提供的API与OBS交互。将OBS中存储的数据拷贝至执行容器：
+
+```python
+import moxing
+moxing.file.copy_parallel(src_url=args.data_url, dst_url='./data')
+```
+
+如需将训练输出（如模型Checkpoint）从执行容器拷贝至OBS，请参考：
 
 ```python
-import moxing as mox
-mox.file.copy_parallel(src_url=args.data_url, dst_url='data/')
+import moxing
+# dst_url形如's3://OBS/PATH'，将ckpt目录拷贝至OBS后，可在OBS的`args.train_url`目录下看到ckpt目录
+moxing.file.copy_parallel(src_url='ckpt', dst_url=os.path.join(args.train_url, 'ckpt'))
 ```
 
 ### 创建训练作业
@@ -427,7 +452,7 @@ mox.file.copy_parallel(src_url=args.data_url, dst_url='data/')
 
 - 算法来源：常用框架->Ascend-Powered-Engine->MindSpore
 - 代码目录：选择上述新建的OBS桶中的experiment目录
-- 启动文件：选择上述新建的OBS桶中的experiment目录下的`start.py`
+- 启动文件：选择上述新建的OBS桶中的experiment目录下的`main.py`
 - 数据来源：数据存储位置->选择上述新建的OBS桶中的experiment目录下的data目录
 - 训练输出位置：选择上述新建的OBS桶中的experiment目录并在其中创建output目录
 - 作业日志路径：同训练输出位置
@@ -441,3 +466,6 @@ mox.file.copy_parallel(src_url=args.data_url, dst_url='data/')
 3. 点击运行中的训练作业，在展开的窗口中可以查看作业配置信息，以及训练过程中的日志，日志会不断刷新，等训练作业完成后也可以下载日志到本地进行查看；
 4. 参考上述代码梳理，在日志中找到对应的打印信息，检查实验是否成功。
 
+## 实验总结
+
+本实验介绍在Cora和Citeseer数据集上使用MindSpore进行GCN实验，GCN能很好的处理和学习图结构数据。

nlp_lstm/README.md → lstm/README.md

@@ -14,17 +14,13 @@ RNN是一个包含大量重复神经网络模块的链式形式，在标准RNN
 
 ![LSTM1](./images/LSTM1.png)
 
-​													**标准RNN中只包含单个tanh层的重复模块**
-
 LSTM也有与之相似的链式结构，但不同的是它的重复模块结构不同，是4个以特殊方式进行交互的神经网络。
 
 ![LSTM2](./images/LSTM2.png)
 
-​																				**LSTM示意图**
-
 这里我们先来看看图中的这些符号：
 
-![LSTM3](./IMAGES/LSTM3.png)
+![LSTM3](./images/LSTM3.png)
 
 在示意图中，从某个节点的输出到其他节点的输入，每条线都传递一个完整的向量。粉色圆圈表示pointwise操作，如节点求和，而黄色框则表示用于学习的神经网络层。合并的两条线表示连接，分开的两条线表示信息被复制成两个副本，并将传递到不同的位置。
 
@@ -66,19 +62,10 @@ sigmoid层输出0到1之间的数字，点乘操作决定多少信息可以传
 
 ### 数据集介绍
 
-IMDB是一个与国内豆瓣比较类似的与电影相关的网站，而本次实验用到的数据集是这个网站中的一些用户评论。IMDB数据集共包含50000项影评文字，训练数据和测试数据各25000项，每一项影评文字都被标记为正面评价或负面评价，所ff以本实验可以看做一个二分类问题。
-
-l 从华为云对象存储服务（OBS）获取
-
-华为云开通了相应的数据存储服务OBS可直接通过链接进行数据集下载。
-
-[数据集链接]: https://obs-deeplearning.obs.cn-north-1.myhuaweicloud.com/obs-80d2/aclImdb_v1.tar.gz
-
-l 从斯坦福大学网站获取
-
-[数据集链接]: http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
-
+IMDB是一个与国内豆瓣比较类似的与电影相关的网站，而本次实验用到的数据集是这个网站中的一些用户评论。IMDB数据集共包含50000项影评文字，训练数据和测试数据各25000项，每一项影评文字都被标记为正面评价或负面评价，所以本实验可以看做一个二分类问题。IMDB数据集官网：[Large Movie Review Dataset](http://ai.stanford.edu/~amaas/data/sentiment/)。
 
+- 方式一，从斯坦福大学官网下载[aclImdb_v1.tar.gz](http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz)并解压。
+- 方式二，从华为云OBS中下载[aclImdb_v1.tar.gz](https://obs-deeplearning.obs.cn-north-1.myhuaweicloud.com/obs-80d2/aclImdb_v1.tar.gz)并解压。
 
 ## 实验目的