✓ 使用 fastText 做中文文本分类(1)
✓ 使用 fastText 做中文文本分类(2)
✓ 使用 fastText 做中文文本分类(3)
✓ 使用 fastText 做中文文本分类(4)
✓ 使用 fastText 做中文文本分类(5)

前面说的模型训练、预测过程，是用 fastText 可执行程序完成的。fastText提供了Python的接口，同样的功能也可以用Python实现。如果数据量比较小，单机做文本分类没啥问题。但我的数据量比较大，几十G的文本数据，单机加载模型、预测分类太耗资源了，而且速度慢。
并行这种事嘛，交给Map-Reduce job来做是最合适不过了，不过，要在Hadoop集群上安装fastText的Python包是不可能的，所以我只能找一下，fastText的模型怎么用Java加载，从而在M-R job中并行地去做预测。

✓ 选择
网上能搜到好些个 fastText 的“Java版”，比如 JFastText，它是 fastText 的一个Java wrapper；又比如 FastText4j，它是一个完全由 Kotlin & Java 实现的 fastText 实现。还有其他的，没有调研。
看了 FastText4j 的自我介绍：

● 100%由Kotlin & Java实现

● 良好的API

● 兼容官方原版的预训练模型

● 提供所有的包括train、test等api

● 支持自有模型存储格式，可以使用MMAP快速加载大模型

<dependency>
  <groupId>com.mayabot.mynlp</groupId>
  <artifactId>fastText4j</artifactId>
  <version>3.1.7</version>
</dependency>

// 用FastText4j训练一个文本分类模型，模型保存成单个文件
File trainFile = new File("/home/codelast/labeled-data_train");
InputArgs inputArgs = new InputArgs();
inputArgs.setLoss(LossName.softmax);
inputArgs.setLr(1.0);
inputArgs.setEpoch(25);
inputArgs.setWordNgrams(2);

FastText model = FastText.trainSupervised(trainFile, inputArgs);
model.saveModelToSingleFile(new File("/home/codelast/model"));

// 加载模型
FastText model = FastText.Companion.loadModelFromSingleFile(new File("/home/codelast/model"));
System.out.println("load model done, will do test...");
// 测试模型效果
model.test(new File("/home/codelast/labeled-data_valid"), 1, 0, true);

// 预测一个分好词的string的label
List<ScoreLabelPair> result = model.predict(Arrays.asList("人民网 辽宁 频道 人民网 沈阳 月 10 日电 日前 进一步 增强 全民 节能 意识".split(" ")), 1, 0);
System.out.println(result.get(0).getLabel());

// 压缩模型并保存。加载压缩过的模型可以节省内存
FastText qmodel = model.quantize(2, false, false);
qmodel.saveModelToSingleFile(new File("/home/codelast/model_compressed"));

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

✓ 开始训练第一个文本分类模型
标注好的数据，其格式为：

__label__科技 月 10 日 网通 社从 高合 汽车 获悉 华人 运通 微软 2020 世界 人工智能 大会 云端 峰会 WAIC 2020 上 达成 战略 合作 依托 微软 小冰 人工智能 技术 高合 汽车 上 落地 全球 首个 主动式 人工智能 伙伴 HiPhiGo 用户 提供 更好 交通 出行 体验 人工智能 交通 行业 创新 融合 发展 探讨 成立 联合 智能 计算 实验室 智能 汽车 载体 智捷 交通 多个 领域 展开 深度 合作 人工智能 前瞻 技术 研发 推动 智慧 出行 社会 持续 发展 微软 亚洲 互联网 工程院 院长 王永东 微软 华人 运通 合作 使 人工智能 技术 切实可行 落地 场景 得以 转化 真实有效 生产力 发挥 更大 价值 微软 华人 运通 携手 推进 人工智能 新兴 科技 汽车 智慧 智慧 出行 领域 广泛应用 产业 升级 社会 持续 发展 注入 新 活力 华人 运通 董事长 丁磊 此次 合作 顶级 人工智能 企业 智能 汽车 公司 强强 联手 AI 多项 领先 技术 全球 汽车行业 首次 量产 落地 世界 内 技术 领先 性 首款 智能 汽车 高合 HiPhi 有条不紊 推进 全球 首条 车路 协同 自动 驾驶 智能化 城市道路 示范 项目 盐城 开通 试运行 再 全球 首个 车路 城 一体化 5G 无人驾驶 交通 运营 样板 上海 张江 未来 公园 成功 落地 华人 运通 以人为本 人性化 需求 出发 人性化 智慧 打造 智能 汽车 智捷 交通 智慧 城市 三智 战略 各项 业务 稳步 推进 高合 首款 量产 车 HiPhi 2020 年底 小批量 试生产 2021 年 上市 交付

按 fastText 的指南，把这份数据按大概 9:1 的比例，分成training集和validation集，然后开始训练模型：

./fasttext supervised -input labeled-data_train -output model

其中，labeled-data_train 是training集文件，model 是输出模型的文件名前缀。
经过一段时间的等待（速度很快），当前目录下就生成了模型文件：model.bin 和 model.vec。

现在可以用validation集来检验一下模型效果了：

./fasttext test model.bin labeled-data_valid 1

其中，labeled-data_valid 是validation集文件，1表示只预测top 1的label。
输出：

N 10705

P@1 0.842

R@1 0.842

./fasttext supervised -input labeled-data_train -output model -lr 1.0 -epoch 25 -wordNgrams 2

为 training 数据做标注，这可能是一个艰巨的任务，也可能是一个有捷径的任务。
有时候，我们可以依据一些已知的规则来标注文本，比如不同的数据是从不同的来源获取到的，从来源可以知道它们所属的类别，这是一个捷径。不过我这里不具备这样的条件。
我的数据来源是网上的各种新闻，不是某些专业领域的数据，这种比较常见的文本分类任务，可以利用国内的几大云服务商提供的免费接口来完成。阿里云、腾讯云都有这样的接口。
以腾讯云为例，其“人工智能→自然语言处理”产品提供了文本分类功能：

文本分类接口能够对用户输入的文本进行自动分类，将其映射到具体的类目上，用户只需要提供待分类的文本，而无需关注具体实现。

该功能基于千亿级大规模互联网语料和LSTM、BERT等深度神经网络模型进行训练，并持续迭代更新，以保证效果不断提升。

目前已提供：

● 通用领域分类体系，包括15个分类类目，分别是汽车、科技、健康、体育、旅行、教育、职业、文化、军事、房产、娱乐、女性、奥运、财经以及其他，适用于通用的场景。

● 新闻领域分类体系，包括37个一级分类类目，285个二级分类（详细请见 类目体系映射表），已应用于腾讯新闻的文章分类。

更多垂直领域的分类体系即将推出，敬请期待。

默认接口请求频率限制：20次/秒。

该API每天有50万次免费调用额度，用来标注数据够用了：

如果你对这个接口的分类结果准确性有疑虑的话，可以亲自拿一些新闻的文本试一试，就会发现它的效果真的不错，完全可以用来当作人工标注的结果了，毕竟是大厂出品嘛。

同理，阿里云也有类似的接口。作为电商界的龙头，阿里云的文本分类接口不仅适用于新闻资讯领域类目体系，还能用于电商领域类目体系。所以，如果你的文本是电商领域的，可以试试阿里云。
文章来源：https://www.codelast.com/
下面，就来看看怎么薅腾讯云的羊毛。注册腾讯云账号、开通自然语言处理接口的权限，这些就不用说了，自己在网页上点几下就可以完成。
✓ 测试接口
腾讯云NLP接口提供了一个在线测试的网页，从这个链接可以进去（“点击调试”）：

进入调试页面：

对这个接口：
Region只能选“华南地区(广州)”。
Text是待分类的文本，注意不需要分词。只需要把我们前面清洗过（去掉了HTML tag等内容）的句子拿来用即可。
Flag为 1 表示通用领域，为 2 表示新闻领域。
文章来源：https://www.codelast.com/
接口返回的数据是JSON格式，FirstClassName 是一级分类的名称，SecondClassName 是二级分类的名称。
调试页面还提供了“代码生成”功能，Java、Python、PHP、Go等都有，支持非常全面。选一个你熟悉的语言，就可以在代码里实现了。

由于免费的接口的QPS上限为20次/秒，所以并行什么的就不要想了，单线程就能跑满。
通过腾讯云的接口，我们能在半天内为几十万条文本打上标签，再整理成 fastText 规定的格式，就可以训练模型了。
如果觉得50万条都不够多，可以注册多个腾讯云账号来薅羊毛，或者用几天的时间累积够标注数据。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

做好文本预处理，才能输入fastText训练一个效果好的模型出来。

✓ 原文示例
有时我们拿到的源数据是很粗糙的，带有很多会影响模型效果的内容，例如下面这样：

<p>罗望子，是豆科酸豆属唯一的种，是热带乔木，原产于东部非洲，包括马达加斯加落叶森林，但已被引入热带亚洲、拉丁美洲和加勒比海。柽柳是中国海南省三亚的一种城市树木。罗望子最适合生长在温度高、日照长、气候干燥、干湿季节分明的地区。</p><p><img src="http://p0.qhimg.com/t014b83dc78c7cc5000.jpg?size=741x320"/><br /></p><p>罗望子富含糖、乙酸、酒石酸、甲酸、柠檬酸等成分，主要用于调味品、饮料、果酱等食品领域。吃一点罗望子有很多好处。当我们吃罗望子时，罗望子中含有的多糖是一种非常好的抗光物质。当我们吃这种物质时，它可以防止紫外线辐射伤害皮肤。通常吃一点罗望子，饭前吃一点罗望子可以增进食欲，改善我们的饮食质量。在炎热的夏日，吃一点罗望子可以生津止渴，清热解毒，降低中暑的风险。</p><p><img src="http://p1.qhimg.com/t01ecdbbc26c329a78b.jpg?size=533x409"/><br /></p><p>罗望子种子含有丰富的抗氧化物质。多吃罗望子籽可以延缓人体衰老，保持皮肤湿润有光泽。罗望子种子还含有一些清热解毒、消炎的物质，可以帮助我们的人体抵抗一些有害细菌，保护我们的健康。

    /**
     * 移除一个字符串中的HTML标签。
     *
     * @param inputStr 输入的字符串。
     * @return 移除了HTML标签之后的字符串。
     */
    private String removeHtmlTags(String inputStr) {
      if (StringUtils.isEmpty(inputStr)) {
        return inputStr;
      }
      return inputStr.replaceAll("<[^>]*>", "");
    }

    /**
     * 移除一个字符串中的URL。
     *
     * @param inputStr 输入的字符串。
     * @return 移除了URL之后的字符串。
     */
    private String removeUrl(String inputStr) {
      String urlPattern = "((https?|ftp|gopher|telnet|file|Unsure|http):((//)|(\\\$$)+[\\w\\d:#@%/;$()~_?+-=\\\\.&]*)";
      Pattern p = Pattern.compile(urlPattern, Pattern.CASE_INSENSITIVE);
      Matcher m = p.matcher(inputStr);
      StringBuffer sb = new StringBuffer(inputStr.length());
      while (m.find()) {
        m.appendReplacement(sb, "");
      }
      return sb.length() == 0 ? inputStr : sb.toString();
    }

罗望子，是豆科酸豆属唯一的种，是热带乔木，原产于东部非洲，包括马达加斯加落叶森林，但已被引入热带亚洲、拉丁美洲和加勒比海。柽柳是中国海南省三亚的一种城市树木。罗望子最适合生长在温度高、日照长、气候干燥、干湿季节分明的地区。罗望子富含糖、乙酸、酒石酸、甲酸、柠檬酸等成分，主要用于调味品、饮料、果酱等食品领域。吃一点罗望子有很多好处。当我们吃罗望子时，罗望子中含有的多糖是一种非常好的抗光物质。当我们吃这种物质时，它可以防止紫外线辐射伤害皮肤。通常吃一点罗望子，饭前吃一点罗望子可以增进食欲，改善我们的饮食质量。在炎热的夏日，吃一点罗望子可以生津止渴，清热解毒，降低中暑的风险。罗望子种子含有丰富的抗氧化物质。多吃罗望子籽可以延缓人体衰老，保持皮肤湿润有光泽。罗望子种子还含有一些清热解毒、消炎的物质，可以帮助我们的人体抵抗一些有害细菌，保护我们的健康。

import jieba


my_text = '罗望子，是豆科酸豆属唯一的种，...'



# 分词
segmented_words = jieba.cut(my_text, cut_all=False)  # 精确分词模式



# 去除停用词

for single_word in segmented_words:
    #TODO: 去除停用词

    <dependency>
      <groupId>com.hankcs</groupId>
      <artifactId>hanlp</artifactId>
      <version>portable-1.7.8</version>
    </dependency>

import com.hankcs.hanlp.seg.common.Term;
import com.hankcs.hanlp.tokenizer.StandardTokenizer;

String myText = "罗望子，是豆科酸豆属唯一的种，...";

List<Term> termList = StandardTokenizer.segment(myText);
for (Term term : termList) {
    System.out.println(term.word);  // term.word即分出来的每个词
    //TODO: 去除停用词
}

罗 望子 豆科 酸 豆 属 唯一 种 热带 乔木 原产 东部 非洲 包括 马达加斯加 落 叶森林 已 引入 热带 亚洲 拉丁美洲 加勒比海 柽 柳是 中国 海南省 三亚 种 城市 树木 罗 望子 最 适合 生长 温度 高 日照 长 气候 干燥 干湿 季节 分明 地区 罗 望子 富含 糖 乙酸 酒石酸 甲酸 柠檬酸 成分 用于 调味品 饮料 果酱 食品 领域 吃 一点 罗 望子 很多 好处 吃 罗 望子 时 罗 望子 中 含有 多糖 种 好 抗光 物质 吃 物质 时 紫外线 辐射 伤害 皮肤 吃 一点 罗 望子 饭前 吃 一点 罗 望子 增进 食欲 改善 饮食 质量 炎热 夏日 吃 一点 罗 望子 生津止渴 清热 解毒 降低 中暑 风险 罗 望子 种子 含有 抗氧化 物质 吃 罗 望子 籽 延缓 人体 衰老 皮肤 湿润 光泽 罗 望子 种子 还 含有 清热 解毒 消炎 物质 人体 抵抗 有害 细菌 保护 健康

✓ 什么是“文本分类”

它是图书馆学， 信息学和计算机科学中的一个问题。其任务是将一个文档分配到一个或者多个类别中。

举例：

其中，“类别”是事先定义好的。一段文本可以属于多个类别，例如，第2个例子可以同时属于“历史”和“明朝”这两个类别。

✓ fastText是什么
fastText是Facebook于2016年开源的一个词向量计算和文本分类工具，官方定义：

Library for efficient text classification and representation learning

工具如其名，“fast”，表明它的速度很快。
fastText应用很广泛，本文以只有1个类别的中文文本分类任务为例，展示如何从源数据开始，到数据处理，到最后完成分类的过程。
文章来源：https://www.codelast.com/
✓ 安装fastText
fastText 有一个在命令行直接就能用的可执行程序，也有Python的接口，这两样东西我们都装上。
安装、使用fastText对编译器版本、Python版本都有一定的要求，可以查看fastText网站了解这些信息。

wget https://github.com/facebookresearch/fastText/archive/v0.9.2.zip
unzip v0.9.2.zip
cd fastText-0.9.2
make
pip install .

本文写作时，fastText的最新版是 0.9.2，如果版本有更新，上面的命令要跟着修改。
我们会看到当前目录下生成了一个名为“fasttext”的可执行程序。这样，fastText就可以开始用了。但这只是万里长征第一步，之后的文本预处理、类别标注才是最麻烦的。

✓ 文本分类的流程
并不是我们有了文本数据（一行一个字符串），就能直接喂给fastText训练出来一个分类模型了，我们不仅要对数据进行一些细致的清洗，还要把输入fastText的数据做成它要求的格式，这样它才能识别并训练出模型。

简单地说，文本分类的过程主要由以下步骤构成：
● 对待分类的文本数据做预处理。例如：去掉文本里的乱七八糟的字符、标点符号，等等。并且，由于中文不像英文有天然的空格做为词与词之间的分隔符，因此，我们只能使用分词器来对中文句子进行分词。
● 对文本进行标注。fastText训练的是有监督的文本分类模型，你得先给它一堆例子：什么样的文本，对应的正确分类是什么。这样它才能学出一个模型，用于预测一个没有见过的文本的类别。标注可以由人工完成（效率低，一般不现实），也可以从一些可信的数据源获取文本的正确分类。
● 把处理好的文本数据拆分成training集和validation集，training集用于训练模型，validation集用于检验模型效果。
● 用fastText训练training集得到一个模型，用validation集检验模型效果，如果效果不好，调整模型训练的参数训练一个新模型继续检验效果。

下面，就依次描述以上各项。请看下一篇文章。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

前言：这是一篇很不严肃的实验文章。每一个会修电脑的人，都可以很容易地照着本文的描述，自己去操作一遍。

大概一周前，百度不是发布了一个“取得重要进展”的对话生成网络 PLATO-2 吗？我当时一看到那消息，精神就来了，为什么？这得先从解释一下“这玩意是干什么用的”说起——毕竟，这篇文章要让每一个群众都能看得懂，大家好才是真的好。

近日，百度发布对话生成网络 PLATO-2，宣布在开放域对话生成模型上迎来重要进展。PLATO-2 承袭 PLATO 隐变量进行回复多样化生成特性，模型参数高达 16 亿，涵盖中英文版本，可就开放域话题深度畅聊。实验结果显示，PLATO-2 中英文对话效果已超越谷歌 Meena、微软小冰和 Facebook Blender 等先进模型。

咳咳，这些专业术语说的是什么鬼？
如果你完全看不明白这段话，只需要知道：它说的是和NLP（自然语言处理，一门机器学习的分支学科）相关的一些东西。
可能有的人只听说过这段话里提到的“微软小冰”——她的主要功能就是一个【聊天机器人】，和小米的“小爱同学”颇为相似。
“小爱同学，帮我把空调打开！” “好的，开啦！”
——相信这样的场景，早已飞入我国千千万万寻常百姓家。
所以，百度发布的这个 PLATO-2，它可以用来做“小爱同学”的大脑，也就是最核心的那一块功能。不过现实中的“小爱同学”远比这个复杂，在这里只是做一个比喻而已。

其实我对NLP也是一窍不通，但是我却算是半个英语学习爱好者，每周几乎都要在Cambly平台上和native English speaker对话交流两次。另外，2020年1月的时候，Google发布了一个号称是技术极其牛B的聊天机器人：Meena，我做梦都想能把花在Cambly上练口语的钱给省下来啊！苦于Google只是写了篇文章把Meena推到众人面前，却没有提供任何代码以及demo，所以当我看到度娘说“我整了一个比Meena还要牛B的机器人”的时候，我简直要感动哭了——度娘，你是我的救世主！
文章来源：https://www.codelast.com/
还等什么？赶紧把这个机器人的代码跑起来啊！等不及了我马上就要上车！
2话不说，找到PLATO-2的GitHub地址，checkout下来，看了一眼 README，貌似开箱即可用，我的心情乐开了花。
看一下运行PLATO-2的要求：

- python >= 3.7.0
- paddlepaddle-gpu >= 1.8.1
- numpy
- sentencepiece
- termcolor

没有什么过多的依赖，这很好。
文章来源：https://www.codelast.com/
看到 paddlepaddle-gpu 的时候，就知道用CPU的机器还不行，可能是inference的速度真的太慢了吧？但我去哪搞一台GPU的机器呢？当然是蹭公司的啦。感谢公司！
为了干净，最好还是在Anaconda下新建一个Python 3.7的 env，然后再安装其他依赖的 Python package。
按百度官方文档就可以很容易搞定一切。
我这里只简要地把几个主要步骤描述一下。
先添加清华的源，再创建为PaddlePaddle创建一个单独的 env：

conda create --name paddle python=3.7
conda activate paddle

完了之后，剩下的安装步骤就简单啦：

conda install paddlepaddle-gpu cudatoolkit=10.0
conda install -c conda-forge sentencepiece
conda install termcolor

注意，这里我使用的是 cudatoolkit=10.0，这是因为我机器上的 CUDA Version 是10.x 版本。
最后按百度官方文档测试一下安装上的 PaddlePaddle 是否正常，就行了。
文章来源：https://www.codelast.com/
现在可以把 PLATO-2 用起来了。把它 GitHub 页面上提供的那两个预训练模型下载到GPU机器上（一个体积小参数少，另一个体积大参数多），按百度的文档里说的，解压到 Knover 目录下：

下面就可以把“交互式对话”的程序跑起来了（会加载刚下载的模型）：

cd Knover/plato-2/
bash ./scripts/32L_plato_interact.sh

在这里，我用的是体积大参数多的那个模型 32L。
经过一小段时间的耐心等待，模型完全加载好了，看一下显存占用情况，17个G：

+-------------------------------------------------------------------------+

| Processes:                                                       GPU Memory |

|  GPU       PID   Type   Process name                             Usage      |

|============================================================|

|    0     38736      C   python                                     17229MiB |

判断能不能使用GPU
可能有多种原因会导致不能使用GPU，比如PyTorch安装的是CPU版的，显卡驱动没有正确安装等。下面的 if 语句在正常的情况下会返回 True：

if torch.cuda.is_available():
    print('PyTorch can use GPU on current machine!')

文章来源：https://www.codelast.com/
 设置模型使用GPU

model = MyModel(*args, **kwargs)
model.load_state_dict(torch.load(your_model_file_path))
model.eval()  # 设置成evaluation模式
if torch.cuda.is_available():
    print('PyTorch can use GPU on current machine!')
    device = torch.device("cuda")
    model.to(device)

your_model_file_path 是模型文件的路径。

 inference/predict的时候使用GPU
对一次 inference 来说，假设模型的输入数据为 model_input_tensor（torch.Tensor类型），那么计算模型输出的方法是：

if torch.cuda.is_available():  # GPU available
    model_input_tensor = model_input_tensor.to(torch.device('cuda'))
model_output = model(model_input_tensor)  # inference

 检查程序跑起来之后是不是真的用了GPU
用 nvidia-smi 命令来查看。

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

就这几天的事：Google已经开始用强化学习技术来设计芯片了！
如果说用强化学习来玩游戏、下围棋，甚至用来帮助提升互联网广告的点击率、收入，都不是什么新鲜事的话，那么用强化学习来设计芯片，就也太新鲜了吧？但Google就做到了^[1]：

我们提出了一种基于学习的芯片布局方法，这是芯片设计过程中最复杂、最耗时的阶段之一。与之前的方法不同，我们的方法具有从过去的经验中学习并随着时间的推移而改进的能力。特别是随着我们对更多的芯片块进行训练，我们的方法在快速生成以前未见过的芯片块的优化布局方面变得更好。为了实现这些结果，我们将芯片布局作为一个强化学习（RL）问题，并训练一个Agent将芯片网表的节点放置到芯片画布上。为了使我们的RL策略能够泛化到未见过的芯片块，我们将表征学习置于预测布局质量的有监督任务中。通过设计一个能够准确预测各种网表及其布局质量的神经架构，我们能够生成丰富的输入网表的特征嵌入。然后，我们使用这个架构作为我们的策略和价值网络的编码器来实现转移学习。我们的目标是将PPA（功率、性能和面积）降到最低，我们表明，在6个小时内，我们的方法可以在现代加速器网表上生成超越人类或可与之相媲美的芯片布局，而现有的基线需要人类专家在循环中进行，并需要几周的时间。

硬件工程师为之虎躯一颤。

这是我今年看到的第二个跟我多少有点关系，并且又让我马上喊出一句“卧槽”的技术应用了。
文章来源：https://www.codelast.com/
在机器学习领域，强化学习可能是目前人类发明的、最接近人类成长过程的机器学习范式了。从婴儿的咿呀学步，到掌握海量知识，人都是在不断接受外界反馈中对自我行为做出修正，而强化学习正是模仿了这一过程。
目前科学家们正在不断拓展强化学习的应用边界，从一开始的相对简单领域，到越来越复杂的工作，都尝试用强化学习来完成。
事实上，在现实世界，真正比较大规模的、普通人摸得着看得见的强化学习应用，还是当属游戏领域的AI玩家，但考虑到游戏受众占总人口数的比例很小，所以客观地说，强化学习并没有像人脸识别、语音识别等机器学习技术一样渗透到民生的方方面面。不过，由于强化学习的可预见潜力很大，我们有理由相信，它会在很多领域代替人类的工作，而这些工作，不是低水平的重复工作，而是需要较高知识储备才能胜任的。
文章来源：https://www.codelast.com/

还是Google，在今年1月的时候发布了一个聊天机器人：Meena^[2]（“米娜”？）。当然，说是发布，其实并没有公开地提供这个服务，也没有App提供下载，Google只是发了篇论文说他们达到了什么样的技术成果。
这个Meena有多牛呢？
举个大家生活中随处可见的例子：无论你是在京东淘宝上购物的时候在线咨询，还是在打各种客服电话的时候接线的是个“机器人”，可能都会很容易遇到这样一种情况：只要问题问得不是那么直接，那些“聊天机器人”就不知道怎么回答了。
再比如，我家里有一个“小爱同学”（小米的智能音箱），我问她“明天的天气怎么样”，她能完美回答我；但如果我用和人类随意聊天的方式来和她对话，她马上就会进入懵逼状态：“哎呀，你说的这个问题小爱不懂”。
理想和现实的差距，就是人类和市面上所有聊天机器人的差距。
而Google的Meena是一个“开放领域聊天机器人”。开放领域聊天机器人不会仅限于在某个特定领域，而是能够和用户聊近乎所有的话题——这不就是人类的正常表现嘛。
文章来源：https://www.codelast.com/

Meena是一个有着26亿参数的端到端神经对话模型，也就是GPT-2模型最大版本（15 亿参数）的1.7倍。通过实验可以看到，Meena 比现有的 SOTA 聊天机器人能够更好地完成对话，对话内容显得更为具体、清楚。

Google也给出了一些实例，用来说明Meena与人类的对话有多自然。
如果Meena真能达到真人水平，那她一定是我做梦都想拥有的一个chatbot。
我现在每周都在Cambly上和外国人聊天练口语，我当然想把这钱省下来，我曾经也找过英语的chatbot，但没有什么好的结果，在语言学习方面，和人类交流目前还是具有不可替代性。我可以和外国人聊新冠疫情的近况，聊时事政治的发展，但是我和一个chatbot讲这些，它可能当我是傻子（其实它才是傻子）。
所以，如果有一个像Meena那样的chatbot可以和我在开放领域以人类水平用英语聊天，那我真要笑开了花！
文章来源：https://www.codelast.com/

随着技术的发展，在我有生之年，我一定会看到很多本来“不可替代”的人类，会因为技术的发展而失业，这当中，或许就包含了我这样的工程师。而技术的目标之一就是节省更大的成本，我也相信在未来几十年，AI在语言学习上一定可以代替人类，和学生进行几乎无障碍的交流对话。
文章来源：https://www.codelast.com/

[1] https://ai.googleblog.com/2020/04/chip-design-with-deep-reinforcement.html
[2] https://ai.googleblog.com/2020/01/towards-conversational-agent-that-can.html

文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

安装GPU版的PyTorch
在Anaconda下，利用rlpyt自带的 linux_cuda10.yml 或 linux_cuda9.yml 来安装 rlpyt 依赖的Anaconda env（取决于你使用的CUDA Version是多少）。
使用 nvidia-smi 命令查看 CUDA Version：

NVIDIA-SMI 410.72       Driver Version: 410.72       CUDA Version: 10.0

cudatoolkit=10.

cudatoolkit=10.0

我测试下来，如果不改，rlpyt env也可以安装成功，但是装上的是CPU版的PyTorch；不仅如此，如果你服务器上的CUDA Version是10.1的，你也要把 yml 配置文件里改成 10.0，否则装上的也是CPU版的PyTorch：

~$ conda list | grep pytorch

_pytorch_select           0.1                       cpu_0    defaults

pytorch                   1.2.0           cpu_py37h00be3c6_0    defaults

文章来源：https://www.codelast.com/
改了之后装上的就是GPU版的PyTorch了：

~$ conda list | grep pytorch

_pytorch_select           0.2                       gpu_0    defaults

pytorch                   1.2.0           cuda100py37h938c94c_0    defaults

 在模型训练程序调度GPU
具体应该怎么写GPU相关的程序，取决于你要实现什么样的功能。例如，使用同步/异步模式，它们对应的Sampler是不同的，等等。
涉及到具体的代码，这里难以给出一个详细的说明，可以参考 rlpyt 的examples代码。
文章来源：https://www.codelast.com/
 确认真的在使用GPU训练
依然使用 nvidia-smi 命令来检测，正常情况下，在模型开始训练后，会看到 Processes 列表中有你的模型训练进程：

3     17754      C   .../.anaconda/envs/rlpyt/bin/python   459MiB

此外，在模型训练的过程中，查看GPU使用率应该不为0：

dstat --nvidia-gpu -af

这样就OK了。
据我实测，在我的应用场景中，同样功能的强化学习程序，GPU版比CPU版的模型训练速度快50%左右，GPU单卡使用率最高约为14%（只使用了一张卡，Nvidia P40显卡）。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

rlpyt 是BAIR(Berkeley Artificial Intelligence Research，伯克利人工智能研究所)开源的一个强化学习(RL)框架。我之前写了一篇它的简介。 
当你使用 rlpyt 来实现自己的强化学习程序时，可能会遇到类似于下面这样的错误：

RuntimeError: size mismatch, m1: [1 x 365], m2: [461 x 32] at /tmp/pip-req-build-_357f2zr/aten/src/TH/generic/THTensorMath.cpp:752

本文分析错误原因及解决办法。

 错误原因
可能是由于observation space的期望shape与实际shape不匹配造成的。
observation space的期望shape定义在自己写的environment类中，例如：

self._observation_space = IntBox(
            low=0, high=1,
            shape=461,
            dtype="int32")

里面的 shape 必须与输入network的特征向量的长度相同。

实际的shape，由自定义的environment类的 get_obs() 函数所决定：

def get_obs(self) -> np.ndarray:
    observation: np.ndarray = xxx  # 此处需要自己实现
    return observation

文章来源：https://www.codelast.com/
 解决办法
当出现上面的错误时，以串行模式断点调试上面的程序，在上面两处地方都加上断点，看看期望的shape以及实际的observation shape是不是不相等，如果不相等，就要去调查为什么实际的shape是错的了。解决这个问题以后，上面的问题就迎刃而解。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

rlpyt 是BAIR(Berkeley Artificial Intelligence Research，伯克利人工智能研究所)开源的一个强化学习(RL)框架。我之前写了一篇它的简介。 本文是上一篇文章的续文，继续分析CpuSampler的源码。
本文将分析 CPU并行模式下的 ParallelSamplerBase 类的worker实现。

 worker的代码在哪
rlpyt/samplers/parallel/worker.py

 worker是做什么用的
用于采样agent与environment交互得到的数据。
文章来源：https://www.codelast.com/
 代码分析
我直接在代码里加了大量注释：

def initialize_worker(rank, seed=None, cpu=None, torch_threads=None):
    """
    初始化采样用的worker。

    :param rank: 采样进程的标识序号。
    :param seed: 种子，一个整数值。
    :param cpu: CPU序号，例如 0, 1, 2 等等。
    :param torch_threads: CPU并发执行的线程数。
    """
    log_str = f"Sampler rank {rank} initialized"
    cpu = [cpu] if isinstance(cpu, int) else cpu
    p = psutil.Process()
    try:
        if cpu is not None:
            p.cpu_affinity(cpu)  # 设置CPU亲和性(MacOS不支持)
        cpu_affin = p.cpu_affinity()
    except AttributeError:
        cpu_affin = "UNAVAILABLE MacOS"
    log_str += f", CPU affinity {cpu_affin}"
    torch_threads = (1 if torch_threads is None and cpu is not None else
        torch_threads)  # Default to 1 to avoid possible MKL hang.
    if torch_threads is not None:
        torch.set_num_threads(torch_threads)  # 设置CPU并发执行的线程数
    log_str += f", Torch threads {torch.get_num_threads()}"
    if seed is not None:
        set_seed(seed)
        time.sleep(0.3)  # (so the printing from set_seed is not intermixed)
        log_str += f", Seed {seed}"
    logger.log(log_str)


def sampling_process(common_kwargs, worker_kwargs):
    """
    Arguments fed from the Sampler class in master process.

    采样进程函数。

    :param common_kwargs: 各个worker通用的参数列表。
    :param worker_kwargs: 各个worker可能不同的参数列表。
    """
    c, w = AttrDict(**common_kwargs), AttrDict(**worker_kwargs)
    initialize_worker(w.rank, w.seed, w.cpus, c.torch_threads)
    # 初始化用于training的environment实例和collector实例
    envs = [c.EnvCls(**c.env_kwargs) for _ in range(w.n_envs)]
    collector = c.CollectorCls(
        rank=w.rank,
        envs=envs,
        samples_np=w.samples_np,
        batch_T=c.batch_T,
        TrajInfoCls=c.TrajInfoCls,
        agent=c.get("agent", None),  # Optional depending on parallel setup.
        sync=w.get("sync", None),
        step_buffer_np=w.get("step_buffer_np", None),
        global_B=c.get("global_B", 1),
        env_ranks=w.get("env_ranks", None),
    )
    agent_inputs, traj_infos = collector.start_envs(c.max_decorrelation_steps)  # 这里会做收集(采样)第一批数据的工作
    collector.start_agent()  # collector的初始化

    # 初始化用于evaluation的environment实例和collector实例
    if c.get("eval_n_envs", 0) > 0:
        eval_envs = [c.EnvCls(**c.eval_env_kwargs) for _ in range(c.eval_n_envs)]
        eval_collector = c.eval_CollectorCls(
            rank=w.rank,
            envs=eval_envs,
            TrajInfoCls=c.TrajInfoCls,
            traj_infos_queue=c.eval_traj_infos_queue,
            max_T=c.eval_max_T,
            agent=c.get("agent", None),
            sync=w.get("sync", None),
            step_buffer_np=w.get("eval_step_buffer_np", None),
        )
    else:
        eval_envs = list()

    ctrl = c.ctrl  # 用于控制多个worker进程同时运行时能正确运作的控制器
    ctrl.barrier_out.wait()  # 每个worker都有一个wait()，加上ParallelSamplerBase.initialize()中的一个wait()，刚好n_worker+1个
    while True:
        collector.reset_if_needed(agent_inputs)  # Outside barrier?
        ctrl.barrier_in.wait()
        if ctrl.quit.value:  # 在主进程中set了这个值为True时，所有worker进程会退出采样
            break
        if ctrl.do_eval.value:  # 在主进程的evaluate_agent()函数里set了这个值为True时，这里才会收集evaluation用的数据
            eval_collector.collect_evaluation(ctrl.itr.value)  # Traj_infos to queue inside.
        else:  # 不是做evaluation
            agent_inputs, traj_infos, completed_infos = collector.collect_batch(
                agent_inputs, traj_infos, ctrl.itr.value)
            for info in completed_infos:
                c.traj_infos_queue.put(info)  # 向所有worker进程共享的队列塞入当前worker的统计数据
        ctrl.barrier_out.wait()

    # 清理environment
    for env in envs + eval_envs:
        env.close()

文章来源：https://www.codelast.com/
在worker的代码中，比较绕的就是，worker是怎么把采样到的数据返回放到replay buffer里的？
在上一篇文章中，我们知道 ParallelSamplerBase.initialize() 函数初始化了replay buffer：

examples = self._build_buffers(env, bootstrap_value)

以及：

def _build_buffers(self, env, bootstrap_value):
    self.samples_pyt, self.samples_np, examples = build_samples_buffer(
        self.agent, env, self.batch_spec, bootstrap_value,
        agent_shared=True, env_shared=True, subprocess=True)
    return examples

在这里，self.samples_np 对应的是replay buffer的存储对象。而 worker 的参数 workers_kwargs 初始化的时候，会把 self.samples_np 拆分成多个slice，并传入 worker：

samples_np=self.samples_np[:, slice_B],

在 worker 中，构造 collector 对象的时候，会把这个传入的 samples_np 再传给 collector 的构造函数。这样，replay buffer 就与 collector 关联起来了。
最后，在 collector.collect_batch() 的时候，会把采样得到的数据放入 samples_np 中，也就是相当于放到了 replay buffer 里。
文章来源：https://www.codelast.com/
这一节就到这，且听下回分解。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

rlpyt 是BAIR(Berkeley Artificial Intelligence Research，伯克利人工智能研究所)开源的一个强化学习(RL)框架。我之前写了一篇它的简介。 本文是上一篇文章的续文，继续分析CpuSampler的源码。
我们已经知道了CpuSampler有两个父类：BaseSampler 和 ParallelSamplerBase。其中，BaseSampler主要是定义了一堆接口，没什么好说的，因此本文接着分析另一个父类 ParallelSamplerBase。在 ParallelSamplerBase 中，初始化函数 initialize() 做了很多重要的工作，已经够写一篇长长的文章来分析了，这正是本文的主要内容。

 初始化函数 initialize() 做了哪些重要工作
一句话总结 initialize() 的重要功能：计算一些特殊参数的值，初始化agent，创建并行控制器，创建并启动多个worker进程。
这里说的“并行控制器”(parallel ctrl)是指用Python multiprocessing模块来实现并行功能的时候，需要使用一些变量来协调各个并行的进程，使它们可以正确运作。这些用于协调的变量就是“并行控制器”。

 计算特殊参数的值
在并行模式下，有些参数（比如采样用的worker的数量）不是由用户直接设置的，而是计算出来的。而且这样的参数还挺多，所以有大段大段的代码都用来干这事了。
如果下面的代码没有注释的话，肯定会让人一头雾水：

n_envs_list = self._get_n_envs_list(affinity=affinity)  # 用户设置的worker数不一定与environment数相匹配，这里会重新调整
self.n_worker = n_worker = len(n_envs_list)  # 经过调整之后的worker数
B = self.batch_spec.B  # environment实例的数量
global_B = B * world_size  # "平行宇宙"概念下的environment实例的数量
env_ranks = list(range(rank * B, (rank + 1) * B))  # 含义可参考：https://www.codelast.com/?p=10932
self.world_size = world_size
self.rank = rank

if self.eval_n_envs > 0:  # 在example_*.py中传入的参数
    self.eval_n_envs_per = max(1, self.eval_n_envs // n_worker)  # 计算每个worker至少承载几个evaluation的environment(至少1)
    self.eval_n_envs = eval_n_envs = self.eval_n_envs_per * n_worker  # 保证至少有"worker数量"个eval environment实例
    logger.log(f"Total parallel evaluation envs: {eval_n_envs}.")
    self.eval_max_T = eval_max_T = int(self.eval_max_steps // eval_n_envs)

最为“神奇”的就是 self._get_n_envs_list() 这个函数，它用来计算每个worker承载几个environment实例。这个说法是不是特别奇怪？原因是：用户可以指定environment实例的数量，也可以指定worker的数量，但这两个数量可能是不相等的，于是，要么worker数不够，要么worker数有多；在第1种情况下，一个worker需要带>1个environment实例，在第2种情况下，不需要那么多worker，所以要减少worker的数量，才能保证一个worker刚好带一个environment实例。
文章来源：https://www.codelast.com/
我给 self._get_n_envs_list() 函数加上了注释，相信足以让大家理解它的功能了：

def _get_n_envs_list(self, affinity=None, n_worker=None, B=None):
    """
    根据environment实例的数量(所谓的"B")，以及用户设定的用于采样的worker的数量(n_worker)，来计算得到一个list，这个list的元素的总数，
    就是最终的worker的数量；而这个list里的每个元素的值，分别是每个worker承载的environment实例的数量。

    :param affinity: 一个字典(dict)，包含硬件亲和性定义。
    :param n_worker: 用户设定的用于采样的worker的数量。
    :param B: environment实例的数量。
    :return 一个list，其含义如上所述。
    """
    B = self.batch_spec.B if B is None else B  # 参考BatchSpec类，可以认为B是environment实例的数量
    n_worker = len(affinity["workers_cpus"]) if n_worker is None else n_worker  # worker的数量(不超过物理CPU数否则在别处报错)
    """
    当environment实例的数量<worker的数量时，例如有8个worker(即8个物理CPU)，5个environment实例，每一个物理CPU运行一个environment，
    那么此时会有3个物理CPU多余，此时就会把worker的数量设置成和environment实例数量一样，使得每个CPU都刚好运行一个environment实例。
    """
    if B < n_worker:
        logger.log(f"WARNING: requested fewer envs ({B}) than available worker "
            f"processes ({n_worker}). Using fewer workers (but maybe better to "
            "increase sampler's `batch_B`.")
        n_worker = B
    n_envs_list = [B // n_worker] * n_worker
    """
    当environment实例的数量不是worker数量的整数倍时，每个worker被分配到的environment实例的数量是不均等的。
    """
    if not B % n_worker == 0:
        logger.log("WARNING: unequal number of envs per process, from "
            f"batch_B {self.batch_spec.B} and n_worker {n_worker} "
            "(possible suboptimal speed).")
        for b in range(B % n_worker):
            n_envs_list[b] += 1
    return n_envs_list

文章来源：https://www.codelast.com/
 初始化agent
agent对象只有一个！并不是每一个worker进程都对应到不同的agent对象！这是理解CpuSampler时需要知晓的一个重要概念。
agent通过以下代码初始化（ParallelSamplerBase.initialize() 函数）：

env = self.EnvCls(**self.env_kwargs)
self._agent_init(agent, env, global_B=global_B,
    env_ranks=env_ranks)
examples = self._build_buffers(env, bootstrap_value)
env.close()
del env

可以看到，这里初始化了environment对象，并把它作为一个参数传给了agent初始化函数 self._agent_init()，事实上，在 self._agent_init() 函数里，只用到了 env 对象的 spaces 这个属性，而没有引用整个 env 对象，因此在使用完之后，使用 env.close() 以及 del env 来清理掉env不会有问题。
self._build_buffers() 是一个非常复杂的操作，它的主要功能是创建强化学习中必备的replay buffer。直觉上，有人可能认为replay buffer这个东西，不就是创建一个list或者类似的数据结构就能搞定的吗？但实际上不是这么简单，从这个函数一级级点进去就会发现代码还不少，而且它里面甚至还用到了Python multiprocessing，所以创建replay buffer的实现就不在本文分析了。
文章来源：https://www.codelast.com/
self._agent_init() 函数的实现很简单：

def _agent_init(self, agent, env, global_B=1, env_ranks=None):
    agent.initialize(env.spaces, share_memory=True,
        global_B=global_B, env_ranks=env_ranks)
    self.agent = agent

在这里看到：agent初始化之后，赋值给了 self.agent，这就是 CpuSampler 中唯一使用的 agent 对象。
文章来源：https://www.codelast.com/
 创建并行控制器
并行控制器(parallel ctrl)用于协调多个采样用的worker进程。
在 initialize() 里，创建并行控制器的代码只有一句：

def _build_parallel_ctrl(self, n_worker):
    """
    创建用于控制并行训练过程的一些数据结构。

    multiprocessing.RawValue：不存在lock的多进程间共享值。
    multiprocessing.Barrier：一种简单的同步原语，用于固定数目的进程相互等待。当所有进程都调用wait以后，所有进程会同时开始执行。
    multiprocessing.Queue：用于多进程间数据传递的消息队列。

    :param n_worker: 真正的worker数(不一定等于用户设置的那个原始值)。
    """
    self.ctrl = AttrDict(
        quit=mp.RawValue(ctypes.c_bool, False),
        barrier_in=mp.Barrier(n_worker + 1),
        barrier_out=mp.Barrier(n_worker + 1),
        do_eval=mp.RawValue(ctypes.c_bool, False),
        itr=mp.RawValue(ctypes.c_long, 0),
    )
    self.traj_infos_queue = mp.Queue()
    self.eval_traj_infos_queue = mp.Queue()
    self.sync = AttrDict(stop_eval=mp.RawValue(ctypes.c_bool, False))

这里AttrDict是一个“扩展的”dict，mp就是Python multiprocessing模块，而Python multiprocessing是一个巨大的话题，我自己也只是初步了解，所以没办法讲透彻，这里只举两个例子，来说明这些并行控制器的作用：
 ctrl.quit 可以理解为一个bool类型的进程间共享变量。在 minibatch_rl.py 中，训练完成后，会执行 shutdown()，它会调用 sampler.shutdown()，从而会把 ctrl.quit 的值设置为True；同时，在 worker.py 中会看到，当检测到 ctrl.quit 的值为True时，会退出采样过程。所有采样的worker进程都受这个变量控制。所以这样就做到了在主进程中控制并行跑的worker进程。
 multiprocessing.Queue() 用于在多进程间传递消息。在每个采样的worker进程中，会把收集到的trajectory info放到同一个traj_infos_queue中，在主进程中会把汇总的trajectory info进一步处理成统计数据，然后记日志、打印到屏幕上，等等。
文章来源：https://www.codelast.com/
 创建并启动多个worker进程
worker进程用于采样(agent与environment交互得到的)数据。
在创建这些进程之前，需要先为它们构建所需的参数：

common_kwargs = self._assemble_common_kwargs(affinity, global_B)
workers_kwargs = self._assemble_workers_kwargs(affinity, seed, n_envs_list)

为什么需要分成 common_kwargs 以及 workers_kwargs 两个参数？这是因为：对每个worker进程来说，有些参数是通用的，有些参数是不通用的（例如，每个worker使用的CPU数量、承载的environment实例的数量等），因此，rlpyt把它们分成了两拨，分别放在两个对象里。

在准备好了参数之后，就开始创建多个worker进程，并把它们启动起来了：

# 创建一批子进程
target = sampling_process if worker_process is None else worker_process
self.workers = [mp.Process(target=target,
    kwargs=dict(common_kwargs=common_kwargs, worker_kwargs=w_kwargs))
    for w_kwargs in workers_kwargs]
# 启动子进程
for w in self.workers:
    w.start()

self.ctrl.barrier_out.wait()  # Wait for workers ready (e.g. decorrelate).

在这里，使用的是 multiprocessing.Process() 来创建的进程，target 为进程函数名，进程函数是可以自行指定的，rlpyt也提供了默认的实现，即 worker.py 中的 sampling_process() 函数。采样进程的实现代码 worker.py 虽然不长，但要完全看懂并不容易，所以留到后面的文章再分析。
在worker进程启动之后，它就进入了持续的采样过程。注意上面代码的最后一句 self.ctrl.barrier_out.wait()，这里使用了 multiprocessing的Barrier来控制各个worker进程同步。由于 barrier_out 创建的时候是这样的：

barrier_out=mp.Barrier(n_worker + 1)

所以，它需要 n_worker + 1 个 wait() 才能让所有进程同时“解锁”（即同时开始执行），在 initialize() 函数里的 self.ctrl.barrier_out.wait() 算一个，每个worker函数——即 sampling_process()——里也分别有一个 barrier_out.wait()，所有这些 wait() 加起来刚好是 n_worker + 1 个，这使得 initialize() 函数执行完，所有 worker 就会“跑起来”开始采样。
文章来源：https://www.codelast.com/
这一节就到这，且听下回分解。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：

查看关于 rlpyt 的更多文章请点击这里。

rlpyt 是BAIR(Berkeley Artificial Intelligence Research，伯克利人工智能研究所)开源的一个强化学习(RL)框架。我之前写了一篇它的简介。 

在单机上支持丰富的并行(Parallelism)模式是 rlpyt 有别于很多其他强化学习框架的一个显著特征。rlpyt可以使用纯CPU，或CPU、GPU混合的方式来并行执行训练过程。

 rlpyt的sampler模块概览
rlpyt有一种叫做“Sampler”的模块，我们姑且称之为“采样器”，它用于采样/收集agent与environment交互的数据，对于不同的训练模式(串行、并行、异步)，rlpyt有不同的sampler实现：

├── async_

│   ├── action_server.py

│   ├── alternating_sampler.py

│   ├── base.py

│   ├── collectors.py

│   ├── cpu_sampler.py

│   ├── gpu_sampler.py

│   └── serial_sampler.py

├── base.py

├── buffer.py

├── collections.py

├── collectors.py

├── parallel

│   ├── base.py

│   ├── cpu

│   │   ├── collectors.py

│   │   └── sampler.py

│   ├── gpu

│   │   ├── action_server.py

│   │   ├── alternating_sampler.py

│   │   ├── collectors.py

│   │   └── sampler.py

│   └── worker.py

├── serial

│   ├── collectors.py

│   └── sampler.py

直观感受：串行(serial)模式的sampler代码最简单，并行(parallel)模式下的cpu并行实现比gpu并行实现简单一些，异步(async_)模式下的实现最复杂。
不知道会不会有人好奇：为什么异步模式的module名是带下划线的async_而不是async呢？因为async在Python 3里是一个关键字，rlpyt的作者应该是为了避开这个问题才加了一个下划线。
文章来源：https://www.codelast.com/
在前面的系列源码分析文章中，我已经分析过了串行(serial)模式下的sampler代码，本文想分析的是并行(parallel)模式下的CPU并行实现代码，也就是树形图里的这一部分：

├── cpu

│   ├── collectors.py

│   └── sampler.py

CPU sampler在采样/收集数据的时候，完全不使用GPU，因此相对于GPU sampler来说会简单得多（只是相对而言）。它只有两个代码文件。当然，由于这两个文件里的class会继承其他父类，因此最终有关联的代码文件远不止这两个。下面我们就来详细分析一下。
文章来源：https://www.codelast.com/
 CPU sampler概览
CPU sampler的实现类是 CpuSampler，一级级向上，有多个父类：

这个BaseSampler，同时也是 GpuSampler 的最顶级父类。
文章来源：https://www.codelast.com/
前面的文章已经讲过，sampler是collector外面包装的一层，真正去做数据收集工作的是collector类。对 CpuSampler 来说，它对应的collector代码实现在collectors.py中，里面包含多个collector类：CpuResetCollector，CpuWaitResetCollector，CpuEvalCollector等。
所以应该从两条线来分析sampler class，一条线是 CpuSampler→ParallelSamplerBase→BaseSampler，另一条线是collector class。为了不让篇幅过长，本文只分析第一条线，把collector class留到后面的文章。

 BaseSampler：一个主要用于定义各种接口的父类
最顶层的父类BaseSampler主要定义了各种接口，很多函数都没有实现：

def initialize(self, *args, **kwargs):
    raise NotImplementedError

def obtain_samples(self, itr):
    raise NotImplementedError  # type: Samples

def evaluate_agent(self, itr):
    raise NotImplementedError

def shutdown(self):
    pass

而__init__()函数还是像之前见识过的套路一样，使用save__init__args()来把可变参数保存到对象属性里：

save__init__args(locals())

其余就没啥好说的了。
文章来源：https://www.codelast.com/
 CpuSampler：主要充当一个入口
CpuSampler类的代码相当少，它主要充当一个入口，而不是实现主要逻辑：

class CpuSampler(ParallelSamplerBase):

    def __init__(self, *args, CollectorCls=CpuResetCollector,
            eval_CollectorCls=CpuEvalCollector, **kwargs):
        # e.g. or use CpuWaitResetCollector, etc...
        super().__init__(*args, CollectorCls=CollectorCls,
            eval_CollectorCls=eval_CollectorCls, **kwargs)

    def obtain_samples(self, itr):
        self.agent.sync_shared_memory()  # New weights in workers, if needed.
        return super().obtain_samples(itr)

    def evaluate_agent(self, itr):
        self.agent.sync_shared_memory()
        return super().evaluate_agent(itr)

其中，obtain_samples() 用于采样一批数据，evaluate_agent() 用于评估agent——或者说是评估模型，差不多的意思。
这两个函数都调用父类ParallelSamplerBase的同名函数来实现对应功能，后面会在其他文章里具体分析。
在这两个函数的开头，都有一个 self.agent.sync_shared_memory() 的操作，这是干嘛？
其功能是：在并行模式下，采样/评估之前先同步shared model。
sync_shared_memory() 函数的实现是：

def sync_shared_memory(self):
    if self.shared_model is not self.model:
        self.shared_model.load_state_dict(strip_ddp_state_dict(
            self.model.state_dict()))

这里的意思是：当 self.model 被训练过之后，可能已经和 self.shared_model 不是一个东西了，此时需要把 self.model 的参数copy到 self.shared_model 里。
strip_ddp_state_dict()函数是一个很tricky的操作，为什么从 self.model 取出来的 state_dict 不能直接用 load_state_dict() 加载到 self.shared_model 里呢？关于这一点，我觉得代码的注释里写得比较清楚，建议直接去看它。
这里就产生了两个问题：✓ 什么是shared model？ ✓ 为什么要同步shared model？
文章来源：https://www.codelast.com/
 什么是shared model
从名字上猜测，shared model就是一个“共享的模型”，之所以会有“共享”这个概念，是因为在多个进程中都需要使用模型，所以才需要“共享”。
rlpyt在并行(parallel)模式下，会产生多个“worker”跑在多个进程里，这些worker会各自在environment中采样，采样得到的数据用于优化模型。
 worker在采样的时候会选择action，此时会用模型来做action selection。
 所有worker关联到同一个agent对象(agent包含了策略网络的参数)，只有一个进程会去做优化模型(也就是反向传播之类)的工作，这一点要特别注意，是一个进程，而不是所有worker进程！
 在每个agent对象内部，会有一个类型为 torch.nn.Module 的 self.model 对象，还有一个 self.shared_model 对象，我们可以从agent的父类 BaseAgent 的__init__()函数中看到这一点：

def __init__(self, ModelCls=None, model_kwargs=None, initial_model_state_dict=None):
    save__init__args(locals())
    self.model = None  # type: torch.nn.Module
    self.shared_model = None

在agent对象初始化的时候，即在 BaseAgent.initialize() 函数中，会把 self.shared_model 初始化成和 self.model 一样：

def initialize(self, env_spaces, share_memory=False, **kwargs):
    """In this default setup, self.model is treated as the model needed
    for action selection, so it is the only one shared with workers."""
    self.env_model_kwargs = self.make_env_to_model_kwargs(env_spaces)
    self.model = self.ModelCls(**self.env_model_kwargs,
        **self.model_kwargs)
    if share_memory:
        self.model.share_memory()
        self.shared_model = self.model

上面代码中的 if share_memory 这个条件是否得到满足呢？
在并行模式下，也就是从 ParallelSamplerBase._agent_init() 函数的代码我们可以发现，agent初始化的时候 share_memory 参数被设置成了 True：

agent.initialize(env.spaces, share_memory=True,
    global_B=global_B, env_ranks=env_ranks)

所以 if share_memory 的条件是满足的。
文章来源：https://www.codelast.com/
如果使用GPU训练模型，那么rlpyt会把model挪到用户指定的设备上，而shared_model需要放在CPU上(经查，PyTorch的Tensor或模型参数也是可以放在GPU上共享的，但有一些容易出错、需要谨慎处理的细节，所以我猜由于这个原因，作者选择了把shared_model放在CPU上)，因此，这里创建出来了一个self.shared_model，用来防止之后self.model有可能被挪到GPU的情况发生——如果发生了，self.shared_model这个放在CPU上的模型才是多个进程间的共享模型。
那么这个shared_model在CpuSampler中真的有用吗？下面我们就一层层地挖下去，看看这个东西到底有没有用。
文章来源：https://www.codelast.com/
 为什么要同步shared model
先说结论：在CpuSampler里，完全不需要同步。
为了确认这个结论，我们看看在使用CPU sampler的时候，BaseAgent类里的 self.shared_model 到底用在了什么地方。通过搜索代码，发现除了 sync_shared_memory() 函数之外，只有两个地方在用：
1、上面提到的 BaseAgent.initialize() 函数。在这里，对 self.shared_model 只有赋值操作，没有使用。
2、to_device() 函数：

def to_device(self, cuda_idx=None):
    if cuda_idx is None:
        return
    if self.shared_model is not None:
        self.model = self.ModelCls(**self.env_model_kwargs,
            **self.model_kwargs)
        self.model.load_state_dict(self.shared_model.state_dict())
    self.device = torch.device("cuda", index=cuda_idx)
    self.model.to(self.device)

在这一段代码中，当使用CPU sampler时，cuda_idx 为 None，因此直接return了，self.shared_model 根本触达不到。
此外，BaseAgent的其他所有使用 self.shared_model 的地方，都是和异步(async_)模式相关的，和并行(parallel)模式无关。
因此，对CpuSampler来说，shared_model没用，不需要调用 sync_shared_memory() 来同步shared_model。
文章来源：https://www.codelast.com/
 shared model在什么情况下有意义
对CpuSampler来说，BaseAgent里的 self.model 对各个采样的worker来说都会实时更新，在action selection的时候使用的也是 self.model，而不是 self.shared_model，所以 shared_model 对CpuSampler来说其实没有意义。
但在其他模式下 shared model 还是有意义的，而且机制更复杂。
文章来源：https://www.codelast.com/
这一节就到这，且听下回分解。
文章来源：https://www.codelast.com/
➤➤ 版权声明 ➤➤ 
转载需注明出处：codelast.com 
感谢关注我的微信公众号（微信扫一扫）：