• Lab 1 实验 MapReduce

    👂 若月亮没来 (若是月亮还没来)（若是月亮还没来） - 王宇宙Leto/乔浚丞 - 单曲 - 网易云音乐

    目录

    🌼参考代码

    🐙解析 

    🐟mrsequential.go

    🐟mrapps/wc.go

    📕实验--准备

    🎂概念

    🐋思路梳理

    🦖注意要点 

    🐆初始代码--研读

    main/mrcoordinator.go

    main/mrworker.go

    mr/coordinator.go

    mr/worker.go

    mr/rpc.go

    🦈实验--开始

    🐋伪代码

    mr/coordinator.go

    mr/worker.go

    mr/rpc.go

    🐎结果

    🌼参考代码

    🐙解析 

     实验原文要求仔细研读两份代码，并在作业过程中大胆借鉴

    wc.go

    • MapReduce 的插件，实现了 Map 和 Reduce 两个函数
    • Map 函数接收输入文本的内容，分割成单词，并为每个单词生成一个键值对（键是单词，值是1）
    • Reduce 函数接收 Map 生成的所有键值对，统计每个单词出现次数，并返回这个次数

    mrsequential.go

    • MapReduce 的主体，协调 Map 和 Reduce 任务的执行
    • 检查命令行参数
      （
      os.Args[0]  // 可执行文件
      os.Args[1]  // "wc.so"（插件）
      os.Args[2]  // "pg1.txt"（输入文件）
      os.Args[3]  // "pg2.txt"
      ）
    • 加载 wc.go，执行其中的 Map 和 Reduce 函数
    • 读取输入文件内容，对每个文件调用 Map 函数
    • Map 函数的输出按键 排序（输出单词）
    • 排序的键值对进行 Reduce（归约）
    • Reduce 函数的输出写入输出文件（统计次数）

    🐟mrsequential.go

    代码是单线程的，输入 --> Map --> sort --> Reduce --> 输出

    1. package main
    2.  
    3. import (
    4.     "fmt"
    5.     "6.824/mr"      // 引入MapReduce相关的数据结构和接口
    6.     "plugin"       // 用于动态加载插件
    7.     "os"           // 用于操作系统相关的功能，如命令行参数
    8.     "log"          // 用于日志记录
    9.     "io/ioutil"    // 用于I/O操作，如读取文件
    10.     "sort"         // 用于排序
    11. )
    12.  
    13. // ByKey 是一个用于按键排序的切片类型
    14. type ByKey []mr.KeyValue
    15.  
    16. // Len 实现了 sort.Interface 接口的 Len 方法
    17. func (a ByKey) Len() int { return len(a) }
    18.  
    19. // Swap 实现了 sort.Interface 接口的 Swap 方法
    20. func (a ByKey) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
    21.  
    22. // Less 实现了 sort.Interface 接口的 Less 方法
    23. func (a ByKey) Less(i, j int) bool { return a[i].Key < a[j].Key }
    24.  
    25. func main() {
    26.     // 检查命令行参数数量
    27.     if len(os.Args) < 3 {
    28.         fmt.Fprintf(os.Stderr, "Usage: mrsequential xxx.so inputfiles...\n")
    29.         os.Exit(1)
    30.     }
    31.  
    32.     // 加载插件中的 Map 和 Reduce 函数
    33.     mapf, reducef := loadPlugin(os.Args[1])
    34.  
    35.     // 用于存储Map阶段的中间输出
    36.     intermediate := []mr.KeyValue{}
    37.  
    38.     // 遍历所有输入文件
    39.     for _, filename := range os.Args[2:] {
    40.         // 打开文件
    41.         file, err := os.Open(filename)
    42.         if err != nil {
    43.             log.Fatalf("cannot open %v", filename)
    44.         }
    45.         // 读取文件全部内容
    46.         content, err := ioutil.ReadAll(file)
    47.         if err != nil {
    48.             log.Fatalf("cannot read %v", filename)
    49.         }
    50.         file.Close()
    51.         // 调用 Map 函数处理文件内容
    52.         kv := mapf(filename, string(content))
    53.         // 将Map结果添加到中间输出
    54.         intermediate = append(intermediate, kv...)
    55.     }
    56.  
    57.     // 对中间输出按键排序
    58.     sort.Sort(ByKey(intermediate))
    59.  
    60.     // 创建输出文件
    61.     oname := "mr-out-0"
    62.     ofile, _ := os.Create(oname)
    63.  
    64.     // 调用 Reduce 函数并写入输出文件
    65.     i := 0
    66.     for i < len(intermediate) {
    67.         j := i + 1
    68.         for j < len(intermediate) && intermediate[j].Key == intermediate[i].Key {
    69.             j++
    70.         }
    71.         // 收集相同键的所有值
    72.         values := []string{}
    73.         for k := i; k < j; k++ {
    74.             values = append(values, intermediate[k].Value)
    75.         }
    76.         // 调用 Reduce 函数
    77.         output := reducef(intermediate[i].Key, values)
    78.         // 按格式写入输出文件
    79.         fmt.Fprintf(ofile, "%v %v\n", intermediate[i].Key, output)
    80.         i = j
    81.     }
    82.  
    83.     // 关闭输出文件
    84.     ofile.Close()
    85. }
    86.  
    87. // loadPlugin 从插件文件中加载 Map 和 Reduce 函数
    88. func loadPlugin(filename string) (func(string, string) []mr.KeyValue, func(string, []string) string) {
    89.     // 打开插件
    90.     p, err := plugin.Open(filename)
    91.     if err != nil {
    92.         log.Fatalf("cannot load plugin %v", filename)
    93.     }
    94.     // 查找 Map 函数
    95.     xmapf, err := p.Lookup("Map")
    96.     if err != nil {
    97.         log.Fatalf("cannot find Map in %v", filename)
    98.     }
    99.     mapf := xmapf.(func(string, string) []mr.KeyValue)
    100.     // 查找 Reduce 函数
    101.     xreducef, err := p.Lookup("Reduce")
    102.     if err != nil {
    103.         log.Fatalf("cannot find Reduce in %v", filename)
    104.     }
    105.     reducef := xreducef.(func(string, []string) string)
    106.     // 返回 Map 和 Reduce 函数
    107.     return mapf, reducef
    108. }

    🐟mrapps/wc.go

    Map 函数返回键值对切片，Reduce 函数将单词出现次数转化为字符串后返回

    1. // 定义包名为 main，这是一个插件，可以被 MapReduce 框架动态加载。
    2. package main
    3.  
    4. // 导入 MapReduce 框架的包，用于实现 Map 和 Reduce 函数。
    5. import "6.824/mr"
    6. // 导入 unicode 包，用于判断字符是否为字母。
    7. import "unicode"
    8. // 导入 strings 包，用于字符串操作。
    9. import "strings"
    10. // 导入 strconv 包，用于字符串和基本数据类型之间的转换。
    11. import "strconv"
    12.  
    13. // Map 函数是 MapReduce 框架中的第一个阶段，它将对输入文件的每一行调用一次。
    14. // 参数 filename 是输入文件的名称，contents 是文件的全部内容。
    15. // 这个函数返回一系列键值对，其中键是单词，值是 "1"。
    16. func Map(filename string, contents string) []mr.KeyValue {
    17.     // FieldsFunc 函数将根据 ff 函数来分割字符串。
    18.     // ff 函数是一个过滤函数，它返回 true 如果字符不是字母。
    19.     ff := func(r rune) bool { return !unicode.IsLetter(r) }
    20.  
    21.     // 使用 FieldsFunc 函数根据 ff 函数分割 contents 字符串，得到单词数组。
    22.     words := strings.FieldsFunc(contents, ff)
    23.  
    24.     // 初始化一个空的键值对切片，用于存储 Map 函数的输出。
    25.     kv := []mr.KeyValue{}
    26.     for _, w := range words {
    27.         // 对于每个单词 w，创建一个键值对，键是单词本身，值是 "1"。
    28.         kv = append(kv, mr.KeyValue{w, "1"})
    29.     }
    30.     // 返回包含所有单词和计数的键值对切片。
    31.     return kv
    32. }
    33.  
    34. // Reduce 函数是 MapReduce 框架中的第二个阶段，它对每个唯一的键调用一次。
    35. // 参数 key 是键，values 是所有映射任务为该键生成的值的列表。
    36. // 这个函数返回一个字符串，表示键出现的次数。
    37. func Reduce(key string, values []string) string {
    38.     // 使用 strconv.Itoa 函数将 values 切片的长度（即 key 出现的次数）转换为字符串。
    39.     return strconv.Itoa(len(values))
    40. }

    📕实验--准备

    🎂概念

    所谓“单机”，整个项目部署在一台机器上

    所谓“集群”，集群中的每一个节点就是一个单机，每个单机运行同一个的项目，通过设置“调度者”，用户请求先发送到“调度者”，再由“调度者”根据所有节点的负载情况，分配任务，即负载均衡

    （从单机到集群，代码无需修改，只需多部署几台服务器）

    所谓 “分布式”，类似流水线（只是将串行改成了并行），每条线负责不同的功能，最终将一个个小功能，整合成一个项目

    （也就是将原本部署在单机上的系统，拆分成一个个子系统，每个子系统都是独立的）

    这些子系统存在依赖关系，在网络中通过 rpc(remote procedure call) 通信

    🐋思路梳理

    wc.go 是一个实现了 Map 和 Reduce 函数的插件

    而 mrsequential.go 是 MapReduce 的顺序实现

    （可以理解为“单机”实现，一台机器，单个进程，顺序执行）

    我们要做的就是，将 mrsequential.go 拆分成 5 个文件，实现 MapReduce（词频统计） 的分布式部署 / 并行执行

    main（程序入口）

    • main/mrcoordinator.go  协调者初始化
    • main/mrworker.go  工作者初始化

    两个 main 文件不用修改，我们只需完成以下 3 个 mr/.... 文件即可 

    mr（具体实现）

    • mr/coordinator.go  实现协调者（监视 worker，分配任务，处理失败，重新分配）
    • mr/worker.go  实现工作者（请求任务，执行 Map，执行 Reduce，写入中间结果，写入最终结果）
    • mr/rpc.go  协调者 与 工作者 间的远程调用 （定义了通信接口和数据结构）

    🦖注意要点 

    •  修改 mr/ 下任何文件后，需要重新构建插件 wc.go，确保插件不依赖旧版本
    go build -race -buildmode=plugin ../mrapps/wc.go
    • 修改 mr/worker.go 中的 Worker() 函数，通过 RPC 请求 coordinator 分配任务
    • 中间文件命名 mr-X-Y（X 为 Map 任务编号，Y 为 Reduce 任务编号）
    • 使用 Go 的 encoding/json 包写入和读取 JSON 文件
    1. enc := json.NewEncoder(file) // json.Encoder实例，编码为 json 格式
    2. for _, kv := ... {
    3.     err := enc.Encode(&kv)
    1. dec := json.NewDecoder(file) // json.Decoder 实例，解码为 json 格式
    2. for {
    3.     var kv KeyValue
    4.     if err := dec.Decode(&kv); err != nil {
    5.         break
    6.     }
    7.     kva = append(kva, kv)
    8. }
    • 使用 mrapps/crash.go 插件测试崩溃恢复
    1. go build -race -buildmode=plugin crash.go // 编译插件文件
    2. go run -race mrcoordinator.go pg-*.txt // 根据输入文件，启动 MapReduce 作业
    3. go run -race mrworker.go crash.so // 运行 worker 进程，使用插件故意崩溃
    • 为防止崩溃时部分写入，用 ioutil.TempFile 创建临时文件，os.Rename 原子地重命名

    🐆初始代码--研读

    初始代码可以先抄一遍，理解一下，捋清楚思路后，再开始做 

    main/mrcoordinator.go

    创建协调者，通过命令行参数，传递输入文件给工作者，并在作业完成后退出程序

    1. // 程序入口点
    2. package main
    3.  
    4. // 引入 MapReduce 包，包含协调者和工作者的实现
    5. import "6.824/mr"
    6. // time 包，暂停时间
    7. import "time"
    8. // 引入 os 包，读取命令行参数。
    9. import "os"
    10. // 格式化输入输出
    11. import "fmt"
    12.  
    13. func main() {
    14.     // 访问命令行参数，至少读取一个文件，第一个参数是程序名本身
    15.     if len(os.Args) < 2 {
    16.         // 如果参数数量小于2，打印到标准错误
    17.         fmt.Fprintf(os.Stderr, "Usage: mrcoordinator inputfiles...\n")
    18.         os.Exit(1)
    19.     }
    20.  
    21.     // 创建协调者实例，除了程序名，剩下的参数作为输入文件传递
    22.     m := mr.MakeCoordinator(os.Args[1:], 10) // 10 个工作者
    23.     // 循环直到 MapReduce 作业完成
    24.     for m.Done() == false { // m.Done() 检查 mr 作业是否完成
    25.         // time.Sleep 暂停一秒
    26.         time.Sleep(time.Second)
    27.     }
    28.  
    29.     // 作业完成后，再等待一秒钟，可能是为了确保所有输出都已经写入
    30.     time.Sleep(time.Second)
    31. }

    main/mrworker.go

    从命令行参数中，获取插件文件，并将插件文件中的 Map 和 Reduce 函数，转化为具体函数类型（便于后续调用）

    因为接口类型本身，不能直接被调用，需要转化为具体类型

    1. package main
    2.  
    3. import (
    4.     "6.824/mr"
    5.     "plugin"
    6.     "os"
    7.     "fmt"
    8.     "log"
    9. )
    10.  
    11. // main 是程序的入口点，当程序启动时最先执行的函数
    12. func main() {
    13.     // 参数1：程序名  参数2：插件文件路径
    14.     if len(os.Args) != 2 {
    15.         // 写入标准错误流
    16.         fmt.Fprintf(os.Stderr, "Usage: mrworker xxx.so\n")
    17.         // 终止程序，并返回状态码 1 表示错误
    18.         os.Exit(1)
    19.     }
    20.  
    21.     // 调用 loadPlugin 函数加载 Map 和 Reduce 函数
    22.     // Map, Reduce 函数，都来自于插件文件
    23.     // mapf 是 Map 函数，reducef 是 Reduce 函数
    24.     mapf, reducef := loadPlugin(os.Args[1])
    25.  
    26.     // 调用 mr.Worker 启动 MapReduce 工作者进程，传入加载的 Map 和 Reduce 函数
    27.     mr.Worker(mapf, reducef)
    28. }
    29.  
    30. // loadPlugin 函数用于从插件文件中加载 Map 和 Reduce 函数
    31. // filename 插件文件的路径
    32. func loadPlugin(filename string) (func(string, string) []mr.KeyValue, func(string, []string) string) {
    33.     // 使用 plugin.Open 函数打开插件文件，返回插件对象实例 p 和可能发生的错误 err
    34.     // p 包含 Map 和 Reduce 函数
    35.     p, err := plugin.Open(filename)
    36.  
    37.     if err != nil {
    38.         log.Fatalf("cannot load plugin: %v", filename)
    39.     }
    40.  
    41.     // p.Lookup 方法查找插件中名为 "Map" 的导出符号，其实就是 Map 函数
    42.     // xmapf 是一个 plugin.Symbol 类型的变量，用于存储从插件中查找到的 Map 函数符号
    43.     // plugin.Symbol 是一个接口类型，代表插件中的任意导出符号
    44.     xmapf, err := p.Lookup("Map")
    45.     if err != nil {
    46.         log.Fatalf("cannot find Map function in plugin: %v", filename)
    47.     }
    48.  
    49.     // 类型断言用于确定 xmapf 中存储的具体函数类型
    50.     // 并将其从 plugin.Symbol 接口类型断言回其静态的函数类型
    51.     // xmapf.() 就是类型断言, 将 plugin.Symbol 转化为具体函数类型
    52.     mapf := xmapf.(func(string, string) []mr.KeyValue)
    53.  
    54.     // 同上，查找并断言 Reduce 函数
    55.     xreducef, err := p.Lookup("Reduce")
    56.     if err != nil {
    57.         log.Fatalf("cannot find Reduce function in plugin: %v", filename)
    58.     }
    59.     reducef := xreducef.(func(string, []string) string)
    60.  
    61.     // 返回加载并断言成功的 Map 和 Reduce 函数
    62.     return mapf, reducef
    63. }

    mr/coordinator.go

    struct Coordinator：分配 MapReduce 任务到对应 worker

    Example()：rpc 处理函数的例子

    server()：启动 rpc 服务，监听来自 worker 的请求

    Done()：检查 MapReduce 作业是否完成

    MakeCoordinator()：创建并初始化 Coordinator 实例

    1. package mr
    2.  
    3. import (
    4.     "log"
    5.     "net"
    6.     "os"
    7.     "net/rpc"
    8.     "net/http"
    9. )
    10.  
    11. // Coordinator 负责管理和分配任务
    12. type Coordinator struct {
    13.     // Your definitions here.
    14. }
    15.  
    16. // RPC handlers for the worker to call.
    17. // an example RPC handler.
    18. // the RPC argument and reply types are defined in rpc.go
    19. // rpc 调用的参数和返回值，在 rpc.go 中定义
    20. func (c *Coordinator) Example(args *ExampleArgs, reply *ExampleReply) error {
    21.     reply.Y = args.X + 1
    22.     return nil // rpc 调用成功
    23. }
    24.  
    25. // start a thread that listens for RPCs from worker.go
    26. func (c *Coordinator) server() {
    27.     // 注册协调者实例，处理 RPC 调用
    28.     rpc.Register(c)
    29.     // 允许使用 HTTP 协议进行 RPC 通信
    30.     rpc.HandleHTTP()
    31.     // 协调者 socket 文件名
    32.     sockname := coordinatorSock()
    33.     // 监听前移除已存在的 socket 文件，避免监听失败
    34.     os.Remove(sockname)
    35.     // 监听 UNIX socket，准备接收来自 worker 的连接
    36.     l, e := net.Listen("unix", sockname)
    37.     if e != nil {
    38.         log.Fatal("listen error:", e)
    39.     }
    40.     // 新的 goroutine 中启动 HTTP 服务，以处理 RPC 请求
    41.     go http.Serve(l, nil)
    42. }
    43.  
    44. // main/mrcoordinator.go 会定期调用 Done() 函数来检查整个作业是否已完成。
    45. func (c *Coordinator) Done() bool {
    46.     ret := false
    47.  
    48.     // Your code here to implement the check for completion of all tasks
    49.     // 在这里实现检查所有任务是否完成的逻辑，例如检查所有 Map 和 Reduce 任务的状态
    50.  
    51.  
    52.     return ret // 作业是否完成
    53. }
    54.  
    55. // create a Coordinator
    56. // main/mrcoordinator.go calls this function
    57. // nReduce is the number of reduce tasks to use.
    58. // The returned value is a pointer to the newly created Coordinator instance.
    59. func MakeCoordinator(files []string, nReduce int) *Coordinator {
    60.     c := Coordinator{}
    61.  
    62.     // Your code here to initialize the Coordinator, e.g., load input files, setup tasks, etc
    63.  
    64.  
    65.     // 启动 RPC 服务器线程，以便监听和处理来自 worker 的 RPC 请求
    66.     c.server()
    67.     // 返回指向新创建的协调者实例的指针，这样调用者就可以通过这个指针来访问和操作协调者实例
    68.     return &c
    69. }

    mr/worker.go

    KeyValue 结构体

    ihash()：返回 reduce 任务编号（用于发送 Map 输出的数据）

    Worker()：调用插件中的 map() 和 reduce() 函数

    CallExample()：展示 rpc 调用的完整流程，需要借助 call()

    call()：建立 rpc 连接，再发送 rpc 请求

    1. // package mr - 定义了MapReduce作业的工作者包，包含实现MapReduce算法所需的结构和函数
    2.  
    3. // import语句 - 日志记录、rpc远程过程调用、哈希计算
    4.  
    5. package mr
    6.  
    7. import (
    8.     "fmt"
    9.     "log"
    10.     "net/rpc"
    11.     "hash/fnv"
    12. )
    13.  
    14. // 定义 MapReduce 中的键值对
    15. type KeyValue struct {
    16.     Key   string
    17.     Value string
    18. }
    19.  
    20. // 自定义的哈希函数，用于确定Map输出的键值对，应该发送到哪个Reduce任务
    21. // Map阶段输出的键分配到不同的Reduce任务
    22. func ihash(key string) int {
    23.     h := fnv.New32a() // 创建FNV-1a哈希生成器
    24.     // 字符串 key 转为 []byte 字节切片，因为 Wirte() 需要操作字节数据
    25.     h.Write([]byte(key)) // 将键的字节序列写入哈希生成器
    26.     // 使用按位与操作确保结果是一个非负整数，适合作为索引使用
    27.     // 0x7fffffff 就是 0111 1111 ... 1111，符号位为正，其他不变
    28.     return int(h.Sum32() & 0x7fffffff)
    29. }
    30.  
    31. // Worker 函数 - 是MapReduce工作者的主要工作函数
    32. // 它调用用户提供的map和reduce函数
    33. // main/mrworker.go calls this function.
    34. // 传入的两个参数是 mapf() 和 reducef()
    35. func Worker(mapf func(string, string) []KeyValue, 
    36.             reducef func(string, []string) string) {
    37.     // 工作者实现细节将在这里编写，包括从协调者接收任务和发送结果
    38. }
    39.  
    40.  
    41. // example function to show how to make an RPC call to the coordinator.
    42. func CallExample() {
    43.     // {X: 99} 结构体字面量, X 初始化为 99
    44.     args := ExampleArgs{X: 99} // rpc通信中传递的参数
    45.     reply := ExampleReply{}  // 用于存储响应的返回值
    46.     // 发送RPC请求到协调者，等待回复
    47.     // 服务名称.方法名称，rpc包会根据这个字符串，找到对应的服务和方法进行调用
    48.     call("Coordinator.Example", &args, &reply)
    49.     fmt.Printf("reply.Y %v\n", reply.Y) 
    50. }
    51.  
    52. // send an RPC request to the coordinator, wait for the response.
    53. func call(rpcname string, args interface{}, reply interface{}) bool {
    54.     sockname := coordinatorSock() // 获取协调者socket名称
    55.     c, err := rpc.DialHTTP("unix", sockname) // 建立RPC连接
    56.     if err != nil {
    57.         log.Fatal("dialing:", err)
    58.     }
    59.     defer c.Close()
    60.     // Call 方法是 net/rpc 包中的 *rpc.Client 类型的一个实例方法
    61.     err = c.Call(rpcname, args, reply) // 发送RPC请求
    62.     if err == nil {
    63.         return true
    64.     }
    65.     fmt.Println(err)
    66.     return false
    67. }

    mr/rpc.go

    ExampleArgs 和 ExampleReply，表示 rpc 参数和 rpc 返回值两种类型

    coordinatorSock()：为协调者生成 socket 文件名

    1. package mr
    2.  
    3. // RPC definitions
    4. // remember to capitalize(大写) all names
    5.  
    6. import "os"  // 操作系统功能，获取用户ID
    7. import "strconv"  // 字符串转换
    8.  
    9. // example to show how to declare the arguments(参数)
    10. // and reply(返回值) for an RPC
    11.  
    12. type ExampleArgs struct {
    13.     X int 
    14. }
    15.  
    16. type ExampleReply struct {
    17.     Y int 
    18. }
    19.  
    20. // Add your RPC definitions here
    21.  
    22.  
    23.  
    24. // Cook up a unique-ish UNIX-domain socket name
    25. // in /var/tmp, for the coordinator
    26.  
    27. // Can't use the current directory since
    28. // Athena AFS doesn't support UNIX-domain sockets.
    29.  
    30. // 这里指定的是一个UNIX域socket的文件路径前缀，它位于/var/tmp目录下
    31. // 并且以"824-mr-"作为前缀，以确保socket文件名的唯一性
    32. // 用于获取协调者的socket文件名，以便建立RPC连接
    33. func coordinatorSock() string {
    34.     // 定义UNIX域socket的基础路径，前缀为"/var/tmp/824-mr-"
    35.     s := "/var/tmp/824-mr-"  
    36.     // 将当前用户的UID转换为字符串并追加到基础路径之后，创建一个唯一的socket文件名
    37.     s += strconv.Itoa(os.Getuid())  
    38.     return s  // 协调者监听的socket文件的路径
    39. }

    🦈实验--开始

    🐋伪代码

    mr/coordinator.go

    。

    mr/worker.go

    .

    mr/rpc.go

    .

    🐎结果

  • 相关阅读:
    实验6、白盒测试：路径测试及测试用例设计
    CentOS7安装Oracle-19c
    Python 实验四 面向对象程序设计
    大数据培训课程MapTask工作机制
    计算模型参数量的方法
    nlp之加载电商评论集
    Yolo算法检测之Anchor Boxes原理详解
    “一篇长文教你进行全方位的使用appium“
    李沐动手学深度学习V2-使用Pytorch框架实现RNN循环神经网络
    【HTML】三种加载动画
  • 原文地址：https://blog.csdn.net/csdner250/article/details/140667936