在 AWS 上运行 Julia + Gurobi + Jupyter
如果你在麻省理工学院参加任何数据科学课程，你可能已经处于这种状态:
如果像我一样，你没有一个超级 16gb 内存的计算机，你可能会发现自己不得不等待几个小时才能运行完你的模型。
考虑到你可能不会把一周的每个小时都花在运行 Julia 模型上，你可以让它们在云上运行，只需运行时间的一小部分。今天我们来看看如何让 Julia 和 Gurobi 一起运行在云上。
1.设置 AWS 实例
您应该做的第一件事是在 AWS 上设置一个服务器。我假设你已经有一个帐户(如果没有，请在这里检查)。
为此，我决定使用一个 r5a.large 实例，运行 16gb 内存的 ubuntu 16。对于那些需要 GPU 的人，亚马逊也有一大堆。
一旦你继续通过审查(8gb 磁盘对我来说很好，所以没有必要改变什么)你将需要生成一个密钥对。这是访问服务器所需的密钥文件。我把我的命名为朱丽娅，把它下载到你电脑上的一个安全位置。
然后继续运行实例。因为我们将在默认端口上运行 jupyter 笔记本，所以我们需要在实例上打开端口 8888。单击列表中的实例，向下滚动到安全组并单击该组(如果您没有选择自定义组，名称应该以 launch-wizard-XX 开头)。
进入安全组页面后，单击您的安全组并向下滚动到入站选项卡。点击编辑并打开 TCP 端口 8888，允许所有连接。
您已经为新服务器做好了一切准备！我们现在将 ssh 到它，并开始安装我们需要的文件。
2.安装必要的软件包
以下假设你在 Macbook 或 Linux 机器上。如果你用的是 windows，那么我建议用 Putty 来访问服务器。在这里阅读如何做。
打开一个终端，首先对您之前下载的密钥文件授予适当的权限:
chmod 400 ~/Desktop/julia.pem
Sssh 进入您的服务器(在 AWS 的实例页面上找到公共 DNS 名称):
ssh-I ~/Desktop/Julia . PEM ubuntu@ec2–XX.compute-1.amazonaws.com
更新和升级必要的 ubuntu 软件包:
sudo apt 更新；sudo apt 升级-y
安装 Julia 1.2.0
在撰写本文时，最新的稳定版本是 1.2.0，下载页面在这里。
在服务器上运行:
wgethttps://Julia lang-S3 . Julia lang . org/bin/Linux/x64/1.2/Julia-1 . 2 . 0-Linux-x86 _ 64 . tar . gz
tar xvfz Julia-1 . 2 . 0-Linux-x86 _ 64 . tar . gz
安装 Gurobi
为了让它工作，你需要安装 Gurobi v7.x.x(稍后会详细介绍)。
在服务器上运行:
https://packages.gurobi.com/7.5/gurobi7.5.2_linux64.tar.gzwget
tar xvfz guro bi 7 . 5 . 2 _ Linux 64 . tar . gz
然后将 Julia 和 Gurobi 添加到文件系统路径中。打开 ~/。bashrc 使用您最喜欢的文本编辑器，并将其附加到末尾:
export guro bi _ HOME = "//HOME/Ubuntu/guro bi 752/Linux 64 "
导出 LD _ LIBRARY _ PATH = "/home/Ubuntu/guro bi 752/Linux 64/lib "
导出 GRB 许可证文件= "/home/Ubuntu/guro bi 752/Linux 64/guro bi . lic "
导出路径= "/home/Ubuntu/guro bi 752/Linux 64/bin:/home/Ubuntu/Julia-1 . 2 . 0/bin:$ PATH "
要测试新添加的变量，请运行:
来源~/。bashrc
朱莉娅
如果您看到提示，就可以开始了！
设置 Gurobi 许可证(棘手的部分)
我们现在需要激活古罗比。现在的困难是，我们将使用学术许可证在云上运行 Gurobi。但是为了提取激活所需的许可文件，主机必须在麻省理工学院的网络上。我们将使用另一种方法来获取许可证的详细信息。它假设你的个人电脑连接到麻省理工学院的网络，并只与 Gurobi 的 v7 版本。
首先，通过在服务器上运行以下命令来获取主机信息的详细信息:
grbprobe
头部到https://www.gurobi.com/downloads/free-academic-license/，在底部拿到你的执照密钥。
您现在必须构建这个 URL(用实际数据替换):
http://apps.gurobi.com/keyserver?id =& hostname =& hostid =& username = Ubuntu & OS = Linux & sockets = 5 & local date = YYYY-MM-DD
在我的例子中，url 是:
在你连接到麻省理工网络的个人电脑上运行这个。在文本编辑器中格式化输出，如下所示:
现在在 AWS 服务器上将它粘贴到一个新文件中，该文件位于*/home/Ubuntu/gurobi 752/Linux 64/gurobi . lic*
(如果您更改这些位置中的任何一个，请更新之前设置的环境变量)。
要检查激活是否成功，请在服务器上运行以下命令:
gurobi.sh
如果命令返回与上面相同的输出，就可以开始了！
安装 Jupyter 笔记本
安装 jupyter 笔记本很容易，只需运行这 3 个命令:
卷发https://bootstrap.pypa.io/get-pip.py|须藤蟒 3
sudo apt-get -y 安装 ipython
pip3 安装 jupyter
最后安装下面的 julia 包
朱莉娅
使用 Pkg
Pkg.add("JuMP ")
Pkg.add("Gurobi ")
Pkg.add("IJulia ")
运行笔记本
我更喜欢使用存储所有笔记本的特定目录。当然这是可选的
mkdir ~/笔记本
CD ~/笔记本
在后台启动 jupyter 笔记本
nohup jupyter 笔记本>日志&
将日志文件打开到带有令牌的 url
尾部原木
3.打开个人电脑上的笔记本
您首先需要打开一个从您的计算机到远程服务器的隧道。运行以下命令(或通过 putty 执行):
ssh -i ~/Desktop/julia.pem -L 8888:本地主机:8888 ubuntu@ec2–XX.compute-1.amazonaws.com
现在，您可以在浏览器中粘贴带有上图中令牌的 url，并开始使用笔记本！
希望这样你可以更快地在后台运行你的模型！
下一个 :我会试着建立一个亚马逊 AMI 镜像，这样你就可以开始一个预装了所有东西的新服务器了！
在远程服务器上运行 Jupyter 笔记本电脑
Jupyter 笔记本是许多数据科学家工具箱中的必备工具。作为一个工具，Jupyter Notebook 可以通过以交互方式更容易地执行数据分析、模型原型制作和实验来提高生产力，从而缩短从编码到看到结果的反馈循环。
在许多情况下，在笔记本电脑或工作站上运行 Jupyter 笔记本就足够了。然而，如果您正在处理大型数据集，进行计算成本高昂的数据处理，或者学习复杂的模型，您可能需要比笔记本电脑更强大的功能。也许你正在大型图上运行图卷积网络，或者在大型文本语料库上使用递归神经网络进行机器翻译，并且需要更多的 CPU 内核、RAM 或几个 GPU。幸运的是，您可能在远程服务器上拥有这些资源！
如果您的远程服务器有图形用户界面(GUI ),那么您很幸运。您可以使用远程桌面软件访问远程服务器，或者像在笔记本电脑上一样使用 Jupyter Notebook。
然而，许多服务器没有 GUI。如果您处于这种情况，您可以通过在您的笔记本电脑上编写 Python 脚本来设置您的实验，在您的一小部分数据上运行它以验证它可以运行，将它复制到远程服务器，并从命令行执行它。您甚至可以在笔记本中设置实验，并使用jupyter nbconvert --to script your_notebook.ipynb将笔记本导出到脚本中。尽管这种工作流确实允许您在远程服务器上运行代码，但是您不能再使用 Jupyter Notebook 来进行交互操作，例如，试验您的模型和可视化您的结果。太可惜了！
在这篇文章中，我将向你展示如何在远程服务器上运行 Jupyter 笔记本，以及如何在你的笔记本上访问它。我还将展示如何设置两个bash命令来简化整个过程。
启动远程笔记本服务器
我们将使用安全 Shell 协议 (SSH)在远程服务器上启动 Jupyter 笔记本服务器。SSH 允许我们向远程服务器发送命令。基本语法如下:
ssh username:password@remote_server_ip command
您应该发送的确切命令在一定程度上取决于您的上下文。在我的例子中，我与其他人共享一个远程服务器，因此没有在共享环境中安装 Jupyter。因此，我的第一步是转到我的项目文件夹，激活虚拟环境，并启动笔记本服务器。特别是，我想在远程服务器上执行以下三个bash命令:
cd project_folder
. virtual_environment/bin/activate
jupyter notebook --no-browser --port=8889
我执行带有--no-browser标志的jupyter notebook命令来启动 Jupyter 笔记本，启动一个浏览器，因为远程服务器如果没有 GUI 就不能显示浏览器。我还使用--port=8889标志将端口从默认端口 8888 更改为端口 8889。这是个人喜好；将本地和远程笔记本放在不同的端口上，以便更容易看到我的代码在哪里运行。
为了在远程服务器上执行命令，我们运行组合命令
nohup ssh -f username:password@remote_server_ip "cd project_folder; . virtual_environment/bin/activate; jupyter notebook --no-browser --port=8889"
请注意，我将这三个命令排成一行，并用;代替换行符将它们分开。执行此命令将在端口 8889 上启动 Jupyter 笔记本服务器，并让它在后台运行。最后，我在ssh命令中添加了-f标志，将进程推到后台，并在前面添加了nohup命令，使进程的所有输出静音，这样您就可以继续使用终端窗口。你可以在这里阅读更多关于nohup命令的内容。
访问您的笔记本
您现在可以通过输入 url 来访问笔记本
remote_server_ip:8889
该命令要求您记忆 IP 地址或标记网页。然而，我们可以通过使用端口转发让访问远程笔记本就像访问本地笔记本一样简单:
nohup ssh -N -f -L localhost:8889:localhost:8889 username:password@remote_server_ip
-N标志告诉ssh不会执行任何远程命令。此时，我们不需要执行任何远程命令。如前所述，-f标志将ssh进程推到后台。最后，-L标志使用语法local_server:local_port:remote_server:remote_port指定端口转发配置。该配置指定所有发送到本地机器上端口8889的请求，例如，您的笔记本电脑，发送到远程机器上username:password@remote_server_ip的端口8889。如前所述，nohup命令被添加到前面，以使输出静音。
上述命令的效果是，您现在可以在浏览器中访问远程 Jupyter 笔记本服务器
localhost:8889
就像您在本地运行笔记本一样。
停止远程笔记本服务器
原则上，您可以让笔记本服务器在远程服务器上无限期运行(除非重启或崩溃)，但是您可能需要停止服务器，例如升级您的jupyter版本。如果你需要停止它有两种方法:通过浏览器或命令行。
通过浏览器窗口
在 Jupyter 笔记本的最新版本中，您可以在浏览器窗口的右上角找到一个退出按钮，如下图中的箭头所示。如果您按下它，您将不得不使用我们之前看到的启动命令重新启动服务器。
The Quit Button
通过命令行
如果您无法升级到具有 Quit 按钮的较新版本的 Jupyter，或者只是喜欢通过终端工作，您也可以从命令行停止服务器。Jupyter 有一个停止笔记本的 shell 命令:
jupyter notebook stop 8889
其中8889是端口号。您可以使用命令在远程服务器上执行它
ssh username:password@remote_server_ip "jupyter notebook stop 8889"
不幸的是，这个命令目前正在被调试，但是我已经把它包含在这里，希望它在将来能够工作。但是，作为一种变通方法，您可以使用以下命令终止jupyter进程:
ssh username:password@remote_server_ip "pkill -u username jupyter"
其中-u username表示只有由username启动的jupyter进程应该被终止。这样做的缺点是，如果您同时运行多个笔记本服务器，您将关闭所有的笔记本服务器。最后，您当然可以通过登录到远程服务器、启动笔记本服务器并保持终端窗口打开来手动管理服务器。这允许您使用常用的CTRL+C键盘命令关闭笔记本服务器。
简化您的工作流程
记住所有这些命令可能相当麻烦。幸运的是，我们可以通过为每个命令创建 bash 别名来简化工作。将下面几行添加到您的~/.bashrc文件中:
通过在终端中键入source .bashrc来加载命令。现在，您可以在终端中使用命令remote_notebook_start和remote_notebook_stop分别启动远程笔记本服务器(并设置端口转发)和关闭它。
总结
在这篇文章中，我向您展示了如何使用 bash 命令在远程服务器上启动、访问和停止 Jupyter 笔记本，并展示了如何创建 bash 别名来简化这些操作。
我希望这些命令可以提高您的数据科学生产力，几乎无缝地允许您获得 Jupyter 笔记本和远程服务器上可用的任何计算资源的好处。
喜欢你读的书吗？考虑在Twitter上关注我，在那里，除了我自己的帖子之外，我还分享与数据科学和机器学习的实践、理论和伦理相关的论文、视频和文章。
如需专业咨询，请在LinkedIn上联系我，或在Twitter上直接留言。
在 STM32 MCUs 上运行 Mobilenet
作者:Alessandro Capotondi&Manuele Rusci，博洛尼亚大学
人工智能驱动的高能效边缘设备
物联网现已成为现实。今天，主要的供应商正在通过他们的在线平台向提供数十种云服务来加工和存储个人数据。另一方面，边缘设备的技术仍然存在一些限制。例如，你们中的任何人想要在他家门口放置无线摄像机，都很可能会遇到缺少电源插头或电池组的情况，如果连续播放图像，就需要经常更换。因此，始终在线功能的最终目标与能源限制密切相关。
为了打破这一障碍，驱动关键词是智能:边缘的物体应该表现得像小大脑一样，高效地执行数据到信息的转换，对数据流量的减少产生明显的影响，从而在能源方面节省大量资金。
当遇到深度学习(DL)方法时，节能智能提出了两个主要挑战，如以下问题所示:
- 哪种深度学习模型最适合我们能源受限设备的可用资源，以及我们如何在其上高效运行该模型？我们能否在不降低准确性指标的情况下，对模型进行微调，以适应目标架构上的实现？
- 我们能否改进边缘设备架构，以有效支持给定的 DL 模型工作平台？
我们认为回答这些问题没有正确的顺序。相反，两边同时工作会产生最好的结果。在这篇文章中，我们将描述最近的深度学习模型，已经针对能效进行了训练和优化，如何通过我们优化的 CMSIS-NN 库扩展映射到 STM32H7 MCU 等边缘设备上。我们的代码是在线。
高能效嵌入式深度学习
谷歌通过发布新的工具和方法来拦截这种必要性，以支持将最先进的深度学习模型从能源昂贵的 GPU 转移到资源受限的边缘设备。可以观察到两个主要趋势:
- 网络拓扑很重要。为什么不缩小模型来减少参数和 MAC 运算量呢？尽管这一过程听起来像是魔法，但 Mobilenet 的经验表明，这是一种可行的方法，可以在模型大小和识别准确性指标之间实现最佳平衡。
- Tensorflow Lite 现在是一个众所周知的工具，用于将现有模型压缩到一个“更简单”的数值域(例如 8 位定点数据)，目标是减少内存占用并加快计算。压缩的成本包括一个“特殊的”重新训练过程，需要达到与原始未压缩模型相同的精度水平。
在应用压缩后，8 位版本的 Mobilenet 在浮点基线方面没有表现出精度下降，目前用于分类任务或作为对象识别框架的主干 (TF Lite on Raspberry )。
基于 ARM Cortex-M7 的 MCU 上的 MobileNet
现在，要在能源受限的设备上运行压缩的 DL 模型，还缺少什么？ARM 试图通过发布 Cortex-M target 的 CMSIS NN 库来回答这个问题。不幸的是，该库没有跟踪 DL 模型压缩和量化的最新特性。事实上，有效的量化过程包括不对称范围内的线性量化。假设卷积层的权重参数在范围[a，b]内被量化，其中 a > 0 和 b < 0，则
asymmmetric quantization of real values r
因此，量化卷积核的内环可以计算为:
asymmetric convolution between q1 and q2 inputs
很容易注意到，现在 8 位卷积核必须执行偏置卷积运算，然后是缩放(和箝位)运算。我们在发布的 CMSIS-NN 扩展中提供了这些新的卷积内核。
最后但同样重要的是，内存！存储器很可能是 MCU 系统中最珍贵的构建模块。能量游戏的最大部分是在从存储器来回移动数据时进行的。
创新的架构解决方案在这里可以发挥关键作用(你还记得帖子开头的第二个问题吗？).然而，当试图在 ST32H7 设备上实现 MobileNet 时，内存限制是存在的(2MB 闪存+ 512kB L2 SRAM ),我们需要面对它。最简单的解决方案是使用 R/W L2 存储器存储临时层激活(输入和输出),同时将网络参数存储在只读闪存中。下一个问题是:哪种类型的 MobileNet 符合这些限制？
memory footprint requirement to map mobilenet networks on a STM32H7 MCU
上图中的每个点代表一个 Mobilenet 模型，具有特定的输入大小(128、160、192、224)和宽度乘数(0.25、0.5、0.75、1.0)。激活记忆要求在 x 轴上，权重参数在 y 轴上。红框界定了符合 STM32H7 MCU 存储器限制的模型的解空间。您会发现，并不是所有的网络都适合有限的内存空间(实际上，top1 得分最高的网络不适合)。
因此，我们从 TensorFlow 下载了一个 8 位量化 Mobilnet 160_0.25，并通过使用我们的库扩展移植到 STM32H7 中。结果:一个 1000 类的分类任务可以在 165 毫秒内运行(在 400MHz 下 65 个周期)。如果你想了解更多，你可以查看我们的 github 回购。关于这个话题的更多见解将很快出现。敬请期待！
使用 MagicStat 运行 Pearson 关联
相关性衡量两个变量之间的关系，例如，一个人的智商与他们的收入有关吗？
对于皮尔逊相关，我们需要两个变量。通常，两个变量都需要是连续的、正态分布的、无界的，比如身高或年龄。如果一个变量是绝对的，就像职业，或者如果有很多有界限的分数，就像一次考试中有很多 0 或 100 分，那么它就不起作用。
皮尔逊相关性的测试分数是 r ，其范围从-1 到+1。 r 分数告诉你两个变量之间关系的两件事:关系的强度和方向。 r 得分的绝对值越大，关系越强。如果数字是正数，那么这两个变量是直接相关的:一个变量上升，另一个也上升。如果值是负的，那么它们成反比:一个上升，另一个下降，反之亦然。
皮尔逊相关性的测试分数是 r ，其范围从-1 到+1。 r 得分告诉你两个变量之间关系的两件事:关系的强度和方向。 r 得分的绝对值越大，关系越强。如果数字是正数，那么这两个变量是直接相关的:一个变量上升，另一个也上升。如果值是负的，那么它们成反比:一个上升，另一个下降，反之亦然。
重要的是要记住，虽然皮尔逊相关可以确定两个变量之间的关系，但它不能(本身)确定是否存在因果关系，更不用说哪个变量导致了另一个变量。有些关系显然是第三个变量的产物。例如，冰淇淋销量与溺水呈正相关。现在，买冰淇淋会导致人淹死吗？当然不是。事实上，第三个变量(温度)负责冰淇淋和溺水之间的关系:随着天气变热，人们更有可能吃冰淇淋，也更有可能去游泳。
r 分数还与一个 p 值相关联，用于测试统计显著性。如果零假设为真，p 值评估我们偶然获得该数据集的可能性。因此， p 值越低，零假设为真的可能性就越小。通常，我们的阿尔法水平，统计显著性的阈值，被设置为 0.05。也就是说，如果我们的 p 值低于 0 . 05，那么我们拒绝零假设。
皮尔逊相关性的 p 值由两个因素决定:关系的强度和自由度。关系越强(无论是负的还是正的)，p 的值越低。皮尔逊相关的自由度是 N 减 2，所以你的样本越大，自由度就越多，你的 p 值就越低。
现在我们知道了什么是相关性，让我们来看一个例子。假设我们想知道一个人的智商和收入是否相关。我们有下面的数据集。
我们的假设是，更聪明的人更有技能，需求更高，因此赚更多的钱。然而，智商和收入之间的关系并不完美，不是吗？影响一个人收入的不仅仅是他们的智商:他们在哪个领域工作，他们有多少经验，甚至他们住在哪里。所以，智商和收入之间不会是完美的关系，甚至可能不会是特别强的关系。因此，我们将假设智商和收入之间存在适度的正相关关系。一般来说，我们希望有理论支持的假设。这样我们就可以避免“钓鱼探险”,这种探险会将变量随机放在一起。在没有基于理论的假设的情况下进行测试，会增加你可能发现的任何关系只是由于偶然的可能性。在最后一栏，我们也有每个人的脚的大小。显然，我们不会假设脚的大小与智商或收入之间有任何差异。
现在我们有了假设，让我们看看如何在 MagicStat (版本 1.0.8)上执行关联。
1-)选择一个数据文件
通过单击“选择数据文件”按钮选择您自己的数据集。如果您想使用样本数据文件，请单击工具栏上的“样本数据集”，将其保存到您的硬盘上，然后单击“选择数据文件”并导航到您保存它的位置。
2-)浏览数据集
选择数据集后，单击“浏览”按钮。
选择数据集后，单击“浏览”按钮。窗口右侧是数据集的一览信息，包括变量信息、条形图和直方图。
4-选择“皮尔逊相关”模型
单击“选择一个模型来分析您的数据”，并在下拉列表中选择“Pearson Correlation”。
5-选择变量
单击“选择变量”按钮，并选择您想要在模型中包含的变量。在这里，我们选择“智商”、“收入”和“脚的大小”。
6-分析数据集
最后，单击“分析”按钮。
口译结果
现在是解释我们在前面步骤中获得的结果的时候了。
在皮尔逊相关中，自由度纯粹是样本大小的函数，N 减 2。所以，是 52。
接下来是我们的相关表。正如我们假设的那样，在 0.41 的时候，智商和收入之间有一个适度的相关性，而脚的大小和智商或收入之间没有相关性。
下面是每种关系的 p 值，我们看到智商和收入之间的中度相关性的 p 值为 0.02，这意味着如果智商和收入之间没有关系，我们预计得到的数据集大约是千分之二——不太可能！。脚的尺寸-智商和脚的尺寸-收入的 p 值接近 1，这意味着它们之间不太可能有关系。
在相关表之后， MagicStat 给了我们一些图表。首先是关联热图，显示最强的关系在哪里。我们可以看到紫色表示智商和收入之间的适度关系，蓝色表示与脚的大小没有关系。
然后，我们可以选择一个散点图来可视化关系并检查异常值。如果我们看看智商-收入散点图，似乎没有任何明显的异常值。有了这个散点图和智商与收入之间的理论联系，我们可以对我们在数据集中发现的关系充满信心。
**注:**本文有两位作者，法提赫恩(PhD) 和布伦特摩根(PhD) 。
在 TPU 运行 PyTorch:一包把戏
在写这几行的时候，在 TPUs 上运行 PyTorch 代码还不是一个常用的方法。当然，TPU 已经针对 TensorFlow 进行了优化，并且主要用于 tensor flow。但 Kaggle 和谷歌在其一些比赛中分配了免费的 TPU 时间，人们不会简单地改变他最喜欢的框架，因此这是我与 TPU 在 GCP 训练 PyTorch 模型的经验(大部分是成功的)的备忘录。
Image by author
PyTorch/XLA 是允许这么做的项目。它仍在积极发展，问题得到解决。希望在不久的将来，运行它的体验会变得更加顺畅，一些错误会得到修复，最佳实践会得到更好的传播。
设置事物
我的设置包括:
- 带有预建 PyTorch/XLA 映像的 GCP 计算引擎虚拟机。按照 PyTorch/XLA github 第页的“使用预构建的计算虚拟机映像”部分进行设置。
- TPU 节点，使用本指令与“GCP 控制台”选项为自己创建一个。如果您的 GCP 项目有一个免费的 TPU 配额，您会收到一封电子邮件，描述您可以使用的版本和区域。除此之外，我没有找到一个直接的方法来验证创建 TPU 节点确实是免费的，除了看法案。
- Jupyter 笔记本，跟着这篇搞笑文章来套吧。没有朱庇特我再也无法工作了。你可能会注意到，当它对你起作用时，你会深呼吸。
- 我还发现，在某些情况下，使用谷歌云存储传输文件非常方便。例如，您可以在虚拟机上使用以下代码行来复制 Kaggle API 令牌，并使用它下载竞争数据。还可以使用
gsutil cp将文件复制回 GS bucket。
gcloud auth login
gsutil cp gs://bucket-name/kaggle-keys/kaggle.json ~/.kaggle
chmod 600 ~/.kaggle/kaggle.json
kaggle competitions download -c recursion-cellular-image-classification
除了 google storage，我还使用 github repository 将数据和代码从我的本地机器转移到 GCP 虚拟机，然后再转移回来。
请注意，TPU 节点上也运行着一些软件版本。它必须与您在虚拟机上使用的 conda 环境相匹配。由于 PyTorch/XLA 目前正在积极开发中，所以我使用夜间 TPU 版本:
与 TPU 一起训练
让我们来看看代码。PyTorch/XLA 有自己运行多核的方式，由于 TPU 是多核的，所以你想利用它。但是在此之前，您可能希望将模型中的device = ‘cuda’替换为
import torch_xla_py.xla_model as xm...
device = xm.xla_device()...
xm.optimizer_step(optimizer)
xm.mark_step()
...
只在 TPU 的一个核心上测试你的模型。上面代码片段中的最后两行替换了常规的optimizer.step()调用。
对于多核培训，PyTorch/XLA 使用自己的 DataParallel 类。在测试目录的中可以找到一个带有数据并行的训练循环的例子，我想强调与之相关的以下三点。
- DataParallel 保存模型对象的副本(每个 TPU 设备一个)，这些副本以相同的权重保持同步。用户可以通过访问其中一个模型来保存重量:
torch.save(model_parallel._models[0].state_dict(), filepath)
2)每个数据并行内核必须运行相同数量的批处理，并且只允许运行完整的批处理。因此，每个历元使用少于 100%的样本运行，残差被忽略。对于数据集洗牌，这对于训练循环来说不是大问题，但是对于推断来说却是个问题。我使用单核运行进行推理，如上所述。
3)直接从 jupyter 笔记本上运行数据并行代码对我来说非常不稳定。它可以运行一段时间，但之后会抛出系统错误、内核死亡甚至 jupyter 崩溃。将它作为脚本运行似乎是稳定的，所以我创建了第二个笔记本来运行，代码如下:
!jupyter nbconvert --to script MyModel.ipynb
!python MyModel.py
绕过限制
PyTorch/XLA 设计导致 PyTorch 功能上的一系列限制。事实上，这些限制对 TPU 设备是通用的，显然也适用于张量流模型，至少部分适用。明确地
- 建议张量形状在迭代之间是相同的，这也限制了遮罩的使用。
- 要避免步骤之间迭代次数不同的循环。
不遵循这些准则会导致(严重的)性能下降。不幸的是，在我的损失函数中，我需要同时使用遮罩和循环。就我而言，我把所有东西都移到了 CPU 上，现在速度快多了。在你所有的张量上做my_tensor.cpu().detach().numpy()就行了。当然，它在需要跟踪梯度的张量上不起作用，而且由于转移到 CPU 上，它本身也会导致速度变慢。
性能比较
我的 Kaggle 比赛队友 Yuval Reina 已经善意地同意在本节分享他的机器配置和训练速度以供比较。我还为我的笔记本(一台物理机器，这次不是 jupyter)添加了一个专栏，但是它与这些重量级的不匹配，并且在其上运行的代码没有针对性能进行很好的优化。
网络的输入是具有 6 个通道的 512×512 图像。我们测量了训练循环中每秒处理的图像，在这个指标上，所描述的 TPU 配置以 110 比 57 的比例优于 Yuval 的 Tesla V100。
TPU vs GPU performance comparison
如上所述(不含DataParallel)单核 TPU 的性能为每秒 26 幅图像，比全部 8 个内核加在一起大约慢 4 倍。
我们没有透露 Yuval 使用的架构，因为竞争仍在进行中，但它在大小上与 resnet50 没有明显不同。但是请注意，由于我们没有运行相同的架构，这种比较是不公平的。
试图切换到 GCP SSD 磁盘的火车图像并没有提高性能。
结论
总之，我在 PyTorch/XLA 的经历是复杂的。我遇到了几个 bugs 工件(这里没有全部提到)，现有的文档和例子是有限的，TPU 固有的限制对于更有创造性的架构来说可能太过禁止。另一方面，它大部分是有效的，并且当它有效时，性能是好的。
最后，也可以说是最重要的，完成后不要忘记停止 GCP 虚拟机！
在本地模式下连续运行 StormCrawler，不使用 Storm cluster
在之前的文章中，我分享了我如何使用 StormCrawler 抓取网页并将其索引到 Elasticsearch 服务器的经验。然而，我使用了 Apache Flux 在本地模式下运行注入器和爬虫拓扑。运行这两种拓扑的缺点是，flux 使用 60 秒的 TTL，我们必须重复运行注入器和爬虫。此外，我们使用一个 FileSpout 从注入器拓扑中的一个文本文件中读取预定义的 URL。
在本文中，我将解释如何在没有 Storm 集群的情况下，在本地模式下同时运行注入器和爬虫拓扑。此外，我将使用 AWS 的简单队列服务(SQS)向注入器提供 URL，而不是从文本文件中读取 URL。
我将跳过最初的步骤，因为我在上一篇文章中简要地解释了它们。此外，我将本文分为两个部分。
第 1 部分— StormCrawler 基本配置
第一步
使用以下命令创建 maven 项目。假设你已经在你的电脑上安装了 maven 。
mvn archetype:generate -DarchetypeGroupId=com.digitalpebble.stormcrawler -DarchetypeArtifactId=storm-crawler-archetype -DarchetypeVersion=1.15
我已经给了 com.cnf271 和 stormcrawlersqs 分别作为 groupId 和 artifactId。
第二步
删除 crawler.flux 文件，并将以下文件从 StormCrawler GitHub 资源库的*/external/elastic search*文件夹添加到 source 文件夹。
- ES_IndexInit.sh
- es-conf.yaml
另外，删除*src/main/Java/com/{ your-group-name }*文件夹中的以下文件
- 爬虫拓扑
第三步
将storm crawler elastic search依赖项和 AWS Java SQS SDK 添加到 pom.xml 文件中。
<dependency>
<groupId>com.digitalpebble.stormcrawler</groupId>
<artifactId>storm-crawler-elasticsearch</artifactId>
<version>1.15</version>
</dependency><dependency>
<groupId>com.amazonaws</groupId>
<artifactId>aws-java-sdk-sqs</artifactId>
<version>LATEST</version>
</dependency>
第四步
更改 ES_IndexInit.sh bash 脚本中的配置以启用内容存储。
..."_source": {
"enabled": true
},
"properties": {
"content": {
"type": "text",
"index": "true",
"store": true
}
}
}...
第五步
执行 ES_IndexInit.sh bash 脚本在 Elasticsearch 服务器中创建索引。
E:\stormcrawlersqs\stormcrawlersqs>ES_IndexInit.sh
既然基本配置已经完成，我将继续讨论本文的实际目标。
第 2 部分-为 URL 注入和 web 爬行创建单独的实例
在没有风暴集群的情况下，在本地模式下连续运行 StormCrawler，实际上是什么意思？
我将解释我是如何设法在没有任何风暴集群在后台运行的情况下连续运行爬虫的。为了做到这一点，我创建了两个单独的 StormCrawler 实例，Injector 和 Crawler 分别执行 URL 注入和 web 抓取。此外，我还创建了一个 SQSSpout 来读取来自 AWS SQS 的队列消息。下图给出了它是如何发生的大致情况。
从上图中可以明显看出，AWS SQS 已被用于向注入器实例发送队列消息，注入器实例用状态索引的域细节更新 Elasticsearch 服务器。
*Crawler 实例，*另一方面，持续寻找新的 URL(处于 DISCOVERED 状态的 URL ),这些 URL 已经由 Injector 实例发送到 ES 服务器。Crawler 实例将从相关页面中抓取数据，并用内容数据更新 Elasticsearch 服务器。
在源文件夹中为 Injector 和 Crawler 以及 SQSSpout 类创建两个单独的类。
- 注射拓扑
- 爬虫拓扑
- 风暴 sqsqqueuespout
注射器实例( 注射器拓扑 )
如前所述，注入器实例将使用stormsqqueuespout从 AWS 的 SQS 读取消息，我已经实现了类似于FileSpout的 StormCrawler 核心库。
因此，Injector 实例包含一个 spout 和两个 bolts，用于从队列中读取消息、过滤 URL 和更新爬行状态。
以下要点显示了使用stormsqsquespout从 SQS 队列中读取数据的注入器实例。我使用了一个 config.properties 文件来存储和读取 AWS 凭证以访问 SQS 消息。
保存在 config.properties 文件中的 AWS 信息如下、**
*# AWS SQS CREDENTIALS
aws.sqs.followerQueueUrl={queueUrl}
aws.sqs.accessKey={accessKey}
aws.sqs.secretAccessKey={secretAccessKey}
aws.sqs.region={Region}*
SQS 壶嘴(stormsqqueuespout)
stormsqsquespout 是本文的重点之一。当注入器实例启动并运行时，它使用 StormSqsQueueSpout 来读取由 SQS 发送的要被爬网的 URL。
注意，我使用了下面的 json 格式来发送 url 到使用 SQS 的注射器实例。
*{"url":"[https://www.bbc.co.uk/](https://www.bbc.co.uk/)"}*
以下要点显示了如何使用 ISpout 接口的 nextTuple() 来接收和处理发送到消息队列的 SQS 消息。
*next tuple()**-*调用此方法时，Storm 请求 Spout 向输出收集器发出元组。此方法应该是非阻塞的，因此如果 Spout 没有要发出的元组，此方法应该返回。nextTuple、ack 和 fail 都是在 spout 任务的单线程中的一个紧循环中调用的。当没有元组要发出时，礼貌的做法是让 nextTuple 休眠一小段时间(比如一毫秒)，以免浪费太多 CPU。
爬虫实例( 爬虫拓扑 )
顾名思义，Crawler 实例使用单个喷口和几个螺栓来完成实际的爬行部分。
以下要点是如何使用aggregation spout从 ES 服务器检索 URL，以及如何使用其他 bolts 获取、过滤、抓取和索引抓取的内容的示例。
一旦正确配置了所有必需的类，就可以构建 maven 项目。
**mvn clean package**
现在项目已经打包，您可以使用下面的命令启动两个独立的注入器和爬虫实例。打开两个终端并运行以下命令。
喷油器
**java -cp target\stormcrawlersqs-1.0-SNAPSHOT.jar com.cnf271.InjectorTopology -conf es-conf.yaml -local**
履带
**java -cp target\stormcrawlersqs-1.0-SNAPSHOT.jar com.cnf271.CrawlerTopology -conf es-conf.yaml -local**
继续发送 SQS 消息，并检查 Elasticsearch 服务器不断更新。
使用 ExecutorService 在一个实例中同时运行注入器和爬虫
您可以使用 util.concurrent 包中的 ExecutorService 来运行单个实例，而不是分别运行两个实例。
**ExecutorService executorService = Executors.*newFixedThreadPool*(2);
executorService.execute(new InjectorTopology());
executorService.execute(new CrawlerTopology());**
我已经将示例项目添加到我的 GitHub 资源库中，供您参考。
使用数据运行
2019 波士顿马拉松赛分析
距离 TCS 纽约市马拉松还有不到一个月的时间，这让我们这些跑步者开始思考我们为穿越五个区的 26.2 英里旅程做了多少准备。虽然我们都在分析课程，继续训练，并对比赛日的天气感到压力，但我想对 2019 年波士顿马拉松赛进行统计分析。我选择这场马拉松有 3 个原因:这是世界上最大的马拉松之一，2019 年 4 月 15 日的结果已经公布，很多波士顿马拉松选手来自纽约(你会在下面看到)。
美国每年大约有 570 场马拉松比赛。波士顿马拉松是世界上最古老的马拉松，始于 1897 年。我想从统计分析开始这个项目。分析包括图表和描述，随后是数据的结论。
网页抓取
我从网上收集数据开始这个项目。用来抓取比赛结果的来源是 https://www.baa.org/races/boston-marathon/results.的
我使用 python 库 Beautiful Soup 将结果放入 list/dataframe。然后对数据进行了统计。
统计观测结果
在 26647 名跑步者中，平均年龄为 42 岁，平均正式时间为 3 小时 53 分 2 秒。年龄最大的选手是 83 岁，年龄最小的选手是 18 岁。
下图显示了每个年龄组的参与者。你会发现 40 到 50 岁之间的年龄相当高。
下图中橙色的男性通常比参加 2019 年马拉松比赛的女性年龄大。男性平均年龄约为 45 岁，而女性平均年龄约为 40 岁。
下面的最后一张图表显示了居民来自的前 20 个城市。
年龄反映了跑步者的总体排名吗？
让我们来看看…
你可以看到我们 42 岁时正常化前的分布。标准化后显示为粉红色。我们希望将官方时间转换为秒，以便查看年龄和时间之间是否存在相关性。
重要的是要注意我们的自变量和因变量。自变量是独立的变量，不能被其他变量改变。在这种情况下，我们的独立变量是跑步者的年龄。因变量是依赖于自变量的值的变量。在这种情况下，我们认为官方时间取决于跑步者的年龄。
- 官方时间。应用(lambda x: x.total_seconds()/3600)
- lr_model = ols(公式= ‘年龄~官方 _ 时间’，数据=df2)。适合()
y = 3.16 + 0.017x
你可以看到我们有一个极低的 R 平方值。这可能是因为我们的数据集非常大(超过 26，000)。所以我们想通过绘制两个变量的相关性来进一步挖掘。
相互关系
我想分析年龄变量与参与者的总体排名之间的相关性有多强。我对此的想法是，年龄越大，速度越慢，这意味着整体排名越高。我们的总体排名和年龄之间的相关性= 0.3，这意味着这两个变量具有正的但低的相关性。
y = 3.16 + 0.017x
如你所见，在我们的分析中有许多观察结果。穿过观测值的线称为回归线。这条线符合我们所有的观察。回归线基于最小二乘法。
请注意，y 轴截距为 3.16，斜率为 0.017(这就是为什么我们的回归线略有倾斜。我们的线性方程表明，y(因变量)是跑步者年龄的结果。
Mean Age - 42
Mean Official Time - 3.88(42, 3.88) is the point at which the X and Y cross
上面的 Q-Q(分位数-分位数)图是一个概率图，这是一种通过绘制两个概率分布的分位数来比较它们的图形方法。这是根据要求的分布对数据的整体形状进行的直观检查。
结论
我们可以在上面的图表中看到，跑步者的年龄和跑步者的官方时间之间存在正相关关系。我们有低相关性和低 r 平方，这可能是因为我们有超过 26，000 个观察值。
我是一名顾问，试图找出公司对这些数据感兴趣的原因。当分析一个公司的营销组合时，你用 4 P 制定战略:产品、价格、促销和地点。
假设你是一家刚起步的服装公司，你想在大城市的跑步者中有效地推广你的产品(产品)。根据上面分析的研究，我建议春天在波士顿地区(地点/促销)设立一个 popup 位置。如上所述，波士顿马拉松是美国最古老和最著名的马拉松之一。让你的目标市场年龄组在 40-50 岁之间，你的定价策略要针对这个年龄段(价格)。
集成学习案例研究:在 Google Colab 免费 GPU 上运行 XGBoost
本文是一个案例研究的第二部分，我们正在探索 1994 年人口普查收入数据集。在的第一部分中，我们深入研究了数据集，比较了一些集成方法的性能，然后探索了一些有助于模型可解释性的工具。
在第二部分中，我们将探索一种叫做梯度增强的技术和谷歌合作实验室，这是一个免费的 Jupyter 笔记本环境，不需要设置，完全在云中运行。
什么是梯度增强和 XGBoost？
梯度推进是一种集成方法，很像我们上次讨论的打包和粘贴。然而，Boosting 与前面提到的方法的不同之处在于它如何进行这种模型组合。它使用技术将几个弱学习者组合成一个强学习者。
其他集成方法依赖于同时构建几个孤立的基础学习器，然后用于进行预测，而 Boosting 算法依赖于顺序过程，其中每个模型试图纠正以前模型的错误。这导致了一个主要的效率缺陷，因为模型是一次创建一个，并且依赖于先前迭代获得的结果
梯度推进采用梯度下降算法来最小化顺序模型中的误差。因此，本质上，它是一个优化问题，目标是最小化误差(损失)函数。
XGBoost(极限梯度增强)反过来也是梯度增强算法的优化实现。它的特点(除了其他增强):并行树构建，缓存感知访问，稀疏感知，正则化(L1 和 L2)，加权分位数草图。该库已经成为近年来赢得许多数据科学竞赛的首选解决方案之一。
一些 XGBoost 超参数
原作者将 XGBoost 超参数分为 3 类:
- 通用参数:控制算法整体功能的超参数；
- **助推器参数:**在算法的每一步控制单个助推器(树或回归)的超参数；
- **学习任务参数:**配置要执行的优化的超参数；
XGBoost 最大的优势之一是可定制的数量。要查看可用超参数的完整列表(它非常广泛)，我强烈建议您查看项目文档页面。
XGBoost 提供了一个 scikit-learn 兼容的 API，一些参数的名称略有不同，但它们的工作方式与常规库 API 相同。
我们将简要回顾一些将在案例研究中调整的超参数，以便更好地理解它们:
- booster: 允许我们选择要使用的每个 booster:GB tree，用于基于树的模型，或者 gblinear，用于线性模型。
- 目标:是学习任务超参数的一部分，它规定了优化过程中要使用的学习任务(回归、分类、排序等)和函数。
- tree_method: 我们将使用选项“gpu_exact”在 gpu 上运行
- eval_metric: 用于评估训练数据性能的指标。我们可以以 python 列表的格式传递多个指标，因此，我们将在案例研究中使用“error”(二进制分类错误)和“auc”。
- learning_rate (eta): 在每一步树提升之后，对新增加的权重进行缩放。这种技术被称为“收缩”，负责减少每棵树的影响，为未来的树留下空间来改进模型。通常，发现低于 0.1 的 learning_rates 产生更好的泛化误差。
- gamma: 当产生的分裂产生损失函数的正减少时，树节点被分裂。gamma 参数指定执行这种分割所需的最小缩减。它的值取决于所使用的损失函数。
- max_depth: 限制树木允许生长的最大深度。较大的树容易过度生长。
- colsample_bytree: 设置拟合每棵树时随机使用的要素(数据集列)的分数。
- **子样本:**设置拟合每棵树时随机使用的观察值(数据集行)的分数。
- reg_alpha: 控制 L1 正则化。由于 L1 正则化倾向于将权重拉至零，因此当使用线性增强器或高维数据时，更推荐使用 L1 正则化。
- reg_lambda: 控制 L2 正则化。由于 L2 正则化鼓励较低的权重(但不一定是 0)，它可以用于树助推器。
- n_estimators: 要拟合的树的数量
正如您所看到的，有多个超参数需要优化，上面给出的这些参数甚至还没有接近全部参数。
评估 XGBoost 性能
首先，我们将安装一个现成的 XGBoost 分类器，以获得对模型性能的基本了解，这意味着我们不会调整模型的大多数参数。
XGBoost 库实现了两个用于模型训练的主要 API:默认的学习 API 、，对模型进行更精细的控制；以及 Scikit-Learn API ，这是一个 Scikit-Learn 包装器，使我们能够将 XGBoost 模型与 scikit-learn 对象结合使用，如管道和随机搜索 CV 。
我们现在将主要关注于 Scikit-Learn API 。这个 API 提供了一种方法来评估随着新树的增加模型的性能变化。为此，我们必须向 fit 方法提供以下附加参数: eval_set ，要使用的评估集(通常是训练集和测试集)，以及 eval_metric ，执行评估时要使用的度量。如果提供了这两个参数，评估结果将由拟合模型的 eval_results 属性提供。
但是说够了，让我们最后展示一些代码！由于本文是案例研究的第 2 部分，我们将不讨论预处理管道步骤的开发，因为这已经在本系列的第 1 部分中讨论过了。
首先，我们加载数据集，将其转换为 X 特征矩阵和 y 目标向量，执行预处理步骤，最后，将数据分成训练集和测试集。下面的代码突出显示了这个过程:
# load the dataset
income = pd.read_csv("income.csv")# Create the X feature matrix and the y target vector
X = income.drop(labels=["high_income", 'fnlwgt'], axis=1)
y = income["high_income"]# the only step necessary to be done outside of pipeline
# convert the target column to categorical
col = pd.Categorical(y)
y = pd.Series(col.codes)# validate the preprocessing pipeline by passing data through it
clean_X = preprocessing_pipeline.fit_transform(X)
clean_X_df = pd.DataFrame(clean_X, columns=X.columns)# split the clean_X into train and test sets
X_train, X_test, y_train, y_test = train_test_split(clean_X, y, test_size=0.20, random_state=seed, shuffle=True, stratify=y)
这样，我们终于可以训练我们的第一个 XGBoost 分类器了！为了更好地理解模型的演变，我们将把 n_estimators 超参数设置为 500。下面的代码片段突出显示了模型训练:
import time
from xgboost import XGBClassifier# create a default XGBoost classifier
model = XGBClassifier(n_estimators=500, random_state=seed)# define the eval set and metric
eval_set = [(X_train, y_train), (X_test, y_test)]
eval_metric = ["auc","error"]# fit the model
%time model.fit(X_train, y_train, eval_metric=eval_metric, eval_set=eval_set, verbose=False)
jupyter magic 命令返回 Python 语句或表达式的执行时间。在这种情况下，训练花费了 11.2 秒完成，对于一个开始来说还不错。
然后，我们可以通过进行一些预测来衡量模型性能:
# final model assessment
pred_test = model.predict(X_test)
pred_train = model.predict(X_train)print('Train Accuracy: ', accuracy_score(y_train, pred_train))
print('Test Accuraccy: ', accuracy_score(y_test, pred_test))print('Classification Report:')
print(classification_report(y_test,pred_test))
Figure 1: Default XGBoost performance
默认模型已经给了我们比上一篇文章中的 tunned random forest 更好的测试精度！让我们看看随着新估计量的增加，模型的表现如何:
# retrieve performance metrics
results = model.evals_result()
epochs = len(results['validation_0']['error'])
x_axis = range(0, epochs)fig, ax = plt.subplots(1, 2, figsize=(15,5))# plot auc
ax[0].plot(x_axis, results['validation_0']['auc'], label='Train')
ax[0].plot(x_axis, results['validation_1']['auc'], label='Test')
ax[0].legend()
ax[0].set_title('XGBoost AUC-ROC')
ax[0].set_ylabel('AUC-ROC')
ax[0].set_xlabel('N estimators')# plot classification error
ax[1].plot(x_axis, results['validation_0']['error'], label='Train')
ax[1].plot(x_axis, results['validation_1']['error'], label='Test')
ax[1].legend()
ax[1].set_title('XGBoost Classification Error')
ax[1].set_ylabel('Classification Error')
ax[1].set_xlabel('N estimators')plt.show()
plt.tight_layout()
嗯，看起来我们的模型运行良好，直到大约 300 个估计器，然后训练集的误差继续下降，而测试集的误差或多或少保持稳定。那可能是过度适应的迹象！避免这种情况的一种方法是使用 early_stopping_rounds 参数，一旦在指定的轮数后没有观察到改进，就停止执行。
使用随机搜索调整超参数
因此，看起来我们的默认模型通过其开箱即用的配置表现得相当好。然而，我们仍然可以通过调整一些超参数来从中获取更多信息，但是我们应该如何做呢？
想象一下，如果我们想要调整 7 个超参数，并为每个参数测试 3 个不同的值。手动调谐是不可能的，因为有大量不同的可能组合。如果我们随后决定使用简单的网格搜索来完成这项工作，我们将使用 37 = 2187 个不同的模型来结束 um！在这种情况下，如果我们将拟合默认模型所需的时间(11.2 秒)视为一般经验法则，那么训练将需要大约 408 分钟或 6.8 小时！
因此，正如我们上次所做的，我们将使用随机搜索来调整参数，它可能不会找到最佳解决方案，但会在合理的时间内找到“足够好”的解决方案。
使用 scikit-learn 的randomzedsearccv，我们配置了搜索空间，以包括 learning_rate 、 colsample_bytree 、子样本、 max_depth 、 n_estimators 、 **reg_lambda、**和 gamma 超参数。我们还将迭代次数限制为 50 次，这样实验不会运行太长时间。配置和安装该模型的过程如下所示:
# create a default XGBoost classifier
model = XGBClassifier(
random_state=seed,
eval_metric=["error", "auc"]
)# Create the grid search parameter grid and scoring funcitons
param_grid = {
"learning_rate": [0.1, 0.01],
"colsample_bytree": [0.6, 0.8, 1.0],
"subsample": [0.6, 0.8, 1.0],
"max_depth": [2, 3, 4],
"n_estimators": [100, 200, 300, 400],
"reg_lambda": [1, 1.5, 2],
"gamma": [0, 0.1, 0.3],
}scoring = {
'AUC': 'roc_auc',
'Accuracy': make_scorer(accuracy_score)
}# create the Kfold object
num_folds = 10
kfold = StratifiedKFold(n_splits=num_folds, random_state=seed)# create the grid search object
n_iter=50grid = RandomizedSearchCV(
estimator=model,
param_distributions=param_grid,
cv=kfold,
scoring=scoring,
n_jobs=-1,
n_iter=n_iter,
refit="AUC",
)# fit grid search
%time best_model = grid.fit(X_train,y_train)
我们再次使用 %time 命令来测量训练过程的执行速度。这一次大约花了 20 分 19 秒在执行 50 轮后返回最佳模型。如果我们使用更大的搜索空间和更多的迭代次数，你现在可以知道这个过程是如何变得非常耗时的。
然后，我们可以检查最佳模型 AUC 分数和超参数:
print(f'Best score: {best_model.best_score_}')
print(f'Best model: {best_model.best_params_}')
Figure 3: XGBoost AUC score and hyperparameters after running on CPU
最后，我们可以进行一些预测来评估模型的整体性能:
pred_test = best_model.predict(X_test)
pred_train = best_model.predict(X_train)print('Train Accuracy: ', accuracy_score(y_train, pred_train))
print('Test Accuraccy: ', accuracy_score(y_test, pred_test))print('\nConfusion Matrix:')
print(confusion_matrix(y_test,pred_test))
print('\nClassification Report:')
print(classification_report(y_test,pred_test))
Figure 4: Tunned XGBoost performance
看起来我们在训练和测试的准确性上都有了一点点的提高，但是说实话并没有那么多。
利用 GPU 的力量
我们终于到达了你可能正在等待的部分！我们将使用 Google 联合实验室的免费 GPU 访问，有望加快拟合 XGBoost 模型的过程。
但是你如何配置你的工作空间呢？这是一个相当简单的两步过程:首先，你需要进入编辑>笔记本偏好设置，然后，在硬件加速器下拉菜单中选择 GPU 并按保存。就是这样！您的运行时将重新启动，然后就可以运行了。
在 XGBoost 方面，唯一改变的是包含了 tree_method 超参数。在创建模型时，随机搜索的其他内容保持不变！模型创建的变化可以在下面的代码片段中看到:
model = XGBClassifier(
tree_method = "gpu_hist",
random_state=seed,
eval_metric=["error", "auc"]
)
在用这种配置重新训练模型后，我们证实完成整个过程大约需要 18 分钟。这可能看起来不是一个很大的进步，但它比之前的运行快了大约10%****！使用 GPU 的优势在较大的数据集上更容易看到，其中并行化开销将更多地由并行化速度的提高来补偿。
之后，我们重复这个过程来检查最佳的模型参数和性能。结果如下图所示:
Figure 5: XGBoost AUC score and hyperparameters after running on GPU
Figure 6: GPUtunned XGBoost performance
我们可以看到培训和测试准确性的又一次轻微提高，这总是很好的，不是吗！？
模型的可解释性如何？
因此，为了帮助更好地理解 XGBoost 模型预测，我们可以使用本系列最后一部分中介绍的任何技术:检查并绘制拟合模型的 feature_importances_ 属性；使用 ELI5 特征权重表和预测说明；最后，使用 SHAP 图。
然而，XGBoost 库还有另一个锦囊妙计，它提供了一个内置的绘图 API，用于生成 boosting 中使用的各个树的特性重要性和表示图！
为了绘制全局特征重要性，我们可以使用 plot_importances 方法。可以指定三个度量之一来计算单个特征分数:
- ****特征权重:根据特征在树中出现的次数计算得分
- ****增益:根据使用该特性的拆分的平均增益计算得分
- ****覆盖率:根据使用该特性的分割的平均覆盖率(受分割影响的样本数)计算得分
下面的代码显示了这三个示例:
# store the winning model in a new variable
xgc = best_model_gpu.best_estimator_
# saving the feature names to the model
xgc.get_booster().feature_names = X.columns.to_list()# Create the feature importances plot
fig, ax = plt.subplots(1, 3, figsize=(15,5))# plot importances with feature weight
xgb.plot_importance(
booster=xgc,
importance_type='weight',
title='Feature Weight',
show_values=False,
height=0.5,
ax=ax[0],
)# plot importances with split mean gain
xgb.plot_importance(
booster=xgc,
importance_type='gain',
title='Split Mean Gain',
show_values=False,
height=0.5,
ax=ax[1]
)# plot importances with sample coverage
xgb.plot_importance(
xgc,
importance_type='cover',
title='Sample Coverage',
show_values=False,
height=0.5,
ax=ax[2]
)plt.tight_layout()
plt.show()
Figure 7: XGBoost feature importances
最后，为了绘制特定的树，我们可以使用如下所示的 plot_tree 方法:
# Create the feature importances plot
fig, ax = plt.subplots(figsize=(20,20))# plot a decision tree from the booster
xgb.plot_tree(booster=xgc, num_trees=0, ax=ax, rankdir='LR')plt.tight_layout()
plt.show()
Figure 8: XGBoost tree
结论
至此，我们结束了这个关于整体学习的两部分系列，我希望它是令人愉快的，也许还有点用处！
感谢阅读！请在下面留下你的想法。
在 Windows 10 上运行 Apache Kafka
卡夫卡的成长呈爆炸式增长。超过三分之一的财富 500 强公司使用卡夫卡。这些公司包括顶级旅游公司、银行、十大保险公司中的八家、十大电信公司中的九家，等等。LinkedIn、微软和网飞每天用 Kafka 处理四个逗号的消息(10 亿条)。
Kafka 用于实时数据流，收集大数据，或进行实时分析(或两者兼有)。Kafka 与内存中的微服务一起使用，以提供耐用性，并可用于向 CEP (复杂事件流系统)和 IoT/IFTTT 风格的自动化系统提供事件。— DZone
网上有很多关于这个话题的文章，但是很多都是断章取义的，或者只是从不能在 Windows 上运行的文章中复制粘贴而来的。虽然这是一个简单的安装有一些问题。
这篇文章将帮助你远离陷阱，在 Windows 10 平台上培养 Kafka。
Kafka 依赖 Zookeeper 作为其分布式消息传递核心。所以 zookeeper 服务器需要先启动并运行，这样 Kafka 服务器才能连接到它。
在你下载 Zookeeper 和 Kafka 之前，确保你的系统已经安装了 7-zip。(处理 tar 和 gz 文件的伟大工具。)
在本文中，首先，我们将确保我们有一些必要的工具。然后我们将安装、配置和运行 Zookeeper。之后，我们将安装、配置和运行 Kafka。
所以，让我们开始吧。
安装工具
《动物园管理员》和《卡夫卡》是用 Java 写的，所以你需要 JDK。许多网站会告诉你只安装 JRE。不用麻烦了。只需安装 JDK。这是 JRE 附带的。然后设置 HOME 和 PATH 变量。但首先，7 比 0。
安装 7-zip
你可以在这里找到 7-zip—
英文中文更简单。中国传统。世界语法语德语印度尼西亚语日语葡萄牙语巴西西班牙语泰语…
www.7-zip.org](https://www.7-zip.org/download.html)
当您安装 7-zip 时，请确保将其添加到您的右键菜单快捷方式中。这会让你的生活更轻松。
安装 JDK
它过去是免费的，现在仍然是免费的，只是现在你需要在 Oracle 创建一个帐户才能下载它。这是链接-
Java SE 13.0.1 是 Java SE 平台的最新版本了解更多信息寻找 Oracle OpenJDK 版本？甲骨文…
www.oracle.com](https://www.oracle.com/technetwork/java/javase/downloads/index.html)
JDK 将首先安装自己，然后它会问你要安装 JRE 的位置。
默认安装位置是“C:\Program Files\…”
通常把 Java 放在那里是没问题的，但是最好不要放在你的 Kafka 系统中。卡夫卡是为 Linux 设计的。我不会用包含空格的 Windows 目录名来推它。
我把我的 JDK 和 JRE 放在一个没有空格的路径中。我的安装位置是 C:\Java
设置路径
我们需要为所有的安装设置路径。因此，我们将在本文中多次讨论这个问题。我们将设置两种路径变量——用户变量和系统变量。在用户变量中，我们将添加安装位置的路径，在系统变量中，我们将设置 bin 目录的路径。
在 Windows 搜索栏中键入“Environment”。它会出现一个选项来编辑控制面板中的系统变量。点击它，你就会进入系统属性。点击右下角写着环境变量…的按钮。
用户变量
在顶部框中的用户变量下，单击 New 并添加 JAVA_HOME 和 JRE_HOME。对于 JAVA_HOME 的值，单击浏览目录按钮并导航到安装 JDK 的位置。我用的是 C:\Java\jdk1.8.0_221\
对于 JRE_HOME 的值，单击 Browse Directories 按钮并导航到安装 JRE 的位置。对我来说，那就是 C:\Java\jre1.8.0_221\
系统变量
在系统变量框中，双击路径并在末尾添加以下两个条目
%JAVA_HOME%\bin
%JRE_HOME%\bin
试验
如果设置正确，可以在任何目录下打开命令提示符。(一种快速的方法是使用 windows 文件资源管理器转到任何目录，然后在文件资源管理器的地址栏中键入“cmd”(不带引号)。它会在那个位置打开一个提示。)
导航到一个不同于 Java 安装的目录，这样您就可以真正知道您的路径变量是否在工作。
java 类型-版本
你应该看看这个-
C:\>java -version
java version “1.8.0_221”
Java(TM) SE Runtime Environment (build 1.8.0_221-b11)
Java HotSpot(TM) 64-Bit Server VM (build 25.221-b11, mixed mode)
如果您得到类似于 *java 不被识别为内部或外部命令，*那么您的路径设置不正确。为了确保这不是安装本身的问题，您可以转到 JDK 的 bin 目录并键入上面的命令。如果它在那里工作，但在其他地方不工作，这意味着系统找不到它。
对于在命令提示符下键入的每个命令，您的计算机都会在路径变量列表中查找匹配项。这就是为什么像这样的错误通常是路径问题。
安装动物园管理员
下载 Zookeeper 二进制文件。这里有一个可以下载的镜像
确保下载名称中包含 bin 的文件，而不是另一个文件。如果你下载了非 bin 文件，那么当你试图启动服务器时，你会得到一个错误。
[http://apache-mirror.8birdsvideo.com/zookeeper/stable/](http://apache-mirror.8birdsvideo.com/zookeeper/stable/)
右键单击该文件，并使用 7-zip 在同一位置提取它。这将提取 tar 文件，但它仍然不是真正的文件，所以您将该文件提取到哪里并不重要。
对于下一步，位置很重要:
右键单击 tar 文件，将其解压缩到名称中没有空格的目录。我把我的目录放在 C:\Apache
中，所以我得到了一个类似这样的目录。所以
C:\Apache\apache-zookeeper-3.5.6-bin
截至本文撰写之时，zookeeper 的稳定版是 3.5.6。你的可能不一样。
请注意名称后面的-bin。如果你没有看到这个，那么你已经下载并提取了错误的文件。回到镜子前。这很重要，否则当你启动 Zookeeper 服务器时，你会得到一个类似这样的错误
Error: Could not find or load main class org.apache.zookeeper.server.quorum.QuorumPeerMain
配置 Zookeeper
所有的配置都发生在一个文件中——配置文件，它在 conf 目录中。
转到 zookeeper 安装的 conf 目录。对我来说，它在
C:\Apache\apache-zookeeper-3.5.6-bin\conf
将 zoo_sample.cfg 文件重命名为 zoo.cfg
用文本编辑器打开它。
在这个文件中，您将看到一个名为 dataDir 的条目，其值为/tmp。它基本上告诉你该做什么
# the directory where the snapshot is stored.
# do not use /tmp for storage, /tmp here is just
# example sakes.
大多数网上的文章都告诉你用类似 dataDir=:\zookeeper-3.5.6\data 这样的东西来替换这一行
如果你这样做，你会遇到这样的错误-
ERROR— Unable to access datadir, exiting abnormally
Unable to create data directory :zookeeper-3.5.6data\version-2
Unable to access datadir, exiting abnormally
为了避免这个错误，请将您的日志指向比 bin 目录高一级的路径，如下所示
dataDir=../logs
(它可以是更高一级，也可以在同一目录中。您也可以键入从根目录 C:\)开始的绝对 windows 路径
这将在你的 zookeeper 安装目录中创建一个日志目录，当你运行服务器时，它将存储快照。
配置完成。让我们设置路径变量，这样系统可以从任何地方找到它。
设置路径
像以前一样，开始在 Windows 搜索栏中键入 Environment。它会出现一个选项来编辑控制面板中的系统变量。点击它，你就会进入系统属性。点击右下角写着环境变量…的按钮。
用户变量
在顶框的用户变量下，点击 New 并添加 ZOOKEEPER_HOME。对于该值，单击浏览目录按钮并导航到 Zookeeper 的安装位置。对我来说，那就是 C:\ Apache \ Apache-zookeeper-3 . 5 . 6-bin
系统变量
在系统变量框中，双击路径并在末尾添加以下内容
%ZOOKEEPER_HOME%\bin
启动 Zookeeper 服务器
在 zookeeper bin 目录下打开命令提示符，输入
zkserver
它会开始发出一大堆信息。下面是一些有趣的例子。(为了视觉上的清晰，我已经清理了多余的词语)。它们看起来像这样
2019–11–19 11:17:17986[myid:]—信息-> 获取信息
2019–11–19 11:17:17986[myid:]—WARN->获取警告
myid 为空，因为我的 dataDir 中没有 myid 文件。Zookeeper 通过 id 跟踪集群中的每台机器。要给机器分配一个 id，只需输入一个包含一个数字的文件名 myid(没有任何扩展名)。我在单一服务器模式下运行 Zookeeper 进行开发，因此没有必要设置 id。但是，如果我创建一个编号为 5 的文件(可以是任意的，但是如果集群中有多台机器，则需要是唯一的)，那么命令行应该是这样的
2019–11–19 12:05:21400**[myid:5]**—INFO[main:FileSnap @ 83]—读取快照…\ logs \版本 2\snapshot.a6
Server environment:os.name=Windows 10
Server environment:os.arch=amd64
Server environment:os.version=10.0
Server environment:user.name=Bivas Biswas
Server environment:user.home=C:\Users\Bivas Biswas
Server environment:user.dir=C:\Apache\apache-zookeeper-3.5.6-bin\bin
Server environment:os.memory.free=946MB
Server environment:os.memory.max=14491MB
Server environment:os.memory.total=977MB
minSessionTimeout set to 4000
maxSessionTimeout set to 40000
Created server with tickTime 2000 minSessionTimeout 4000 maxSessionTimeout 40000 datadir ..\logs\version-2 snapdir ..\logs\version-2
Logging initialized [@5029ms](http://twitter.com/5029ms) to org.eclipse.jetty.util.log.Slf4jL
最后一行中对 log4j 的引用是对 zookeeper 使用的日志基础设施的引用。您还会注意到，它正在将快照记录到我们之前在配置文件中指定的日志目录中。
Snapshotting: 0x0 to C:Apachezookeeper-3.5.6-binlogs\version-2\snapshot.0
经过几秒钟的数据喷涌，它应该来到这些黄金线
Started AdminServer on address 0.0.0.0, port 8080 and command URL /commands
Using org.apache.zookeeper.server.NIOServerCnxnFactory as server connection factory
Configuring NIO connection handler with 10s sessionless connection timeout, 3 selector thread(s), 40 worker threads, and 64 kB direct buffers.
binding to port 0.0.0.0/0.0.0.0:2181
现在 Zookeeper 服务器运行在 localhost:2181 上。端口 8080 上的 AdminServer 是新增的。我们可以使用浏览器上的端口来监控 zookeeper。
但是，你不能去运行 zookeeper 的 2181 端口。Zookeeper 是 Kafka 用来作为 Kafka 集群的核心内核的。如果您在浏览器上导航到该端口，这将向它发送一些它不期望的 TCP 流量，您将使服务器崩溃。这是你将得到的—
Exception causing close of session 0x0: Len error 1195725856
所以，就这样了。你的 Zookeeper 可以在 Windows 10 上运行，而不需要使用 docker composer 或 Linux VM。
下一个——卡夫卡
卡夫卡是一个信息经纪人。它可以让你创建你认为像聊天室的话题。您在该主题上发布一条消息，订阅该主题的人将会收到该消息。接受者被称为消费者。信息张贴者被称为生产者。
Kafka 还有另外两种能力。一个是流处理 API，它基本上接收这些消息，并在接收者收到之前将它们转换为不同的值。这在实时数据流中实时发生。
另一个是连接器 API，让 Kafka 连接到数据库或存储系统来存储数据。然后，这些数据可用于 Hadoop、Map Reduce 等集群的进一步处理。除了向消费者实时传递消息之外，这种情况也会发生。
如今，卡夫卡是一个一体化的解决方案。以前，你需要一个像 Apache Storm 这样的流处理框架来转换流，但是有了 Kafka 的原生流 API，我们就不像以前那样需要 Storm 了。这取决于您的使用案例和对您有意义的拓扑，但最好有选择。
安装卡夫卡
从这里下载卡夫卡-
http://kafka.apache.org/downloads.html
获取二进制下载。在这一部分，你可能会看到多个标有 Scala x.xxx 的版本。如果你使用 Scala 作为客户端，那么就获取与你的 Scala 版本相匹配的版本。我使用 NodeJS 作为我的客户端，所以我得到哪个并不重要。在撰写本文时，Apache 推荐Kafka _ 2.12–2 . 3 . 1 . tgz所以这是我得到的版本。
使用 7-zip 将 tgz 解压缩到一个 tar 文件中。然后使用 7-zip 将 tar 文件解压到一个路径中没有空格的位置。我用 C:\Apache，所以解压后，我的卡夫卡住在这里——
C:\Apache\kafka_2.12–2.3.1
这篇文章越来越长，所以我打算把它分成两部分。接下来，我们将了解如何设置和配置 Kafka 服务器。
配置 Kafka
我们不会为 Kafka 设置任何环境变量。卡夫卡是寻找动物园管理员和 JDK 的人。甚至生产者和消费者都生活在卡夫卡生态系统中。它们不是在你的电脑上寻找卡夫卡的独立应用程序。简而言之，没有环境变量可以乱来。
但是，需要设置配置文件。
转到您的 Kafka 配置目录。对我来说是在
C:\Apache\kafka_2.12–2.3.1\config
我们可以从一个示例 server.properties 文件开始。
对于一个经纪人，我们只需要建立这一个文件。如果我们需要多个代理，那么为每个代理复制一次这个文件。例如，如果您需要两个消息代理，那么您最终会得到 server.b1.properties 和 server.b2.properties。
在每个文件中，您将更改以下内容—
- 经纪人 id
# The id of the broker. This must be set to a unique integer for each broker.broker.id=0
如果您只使用 1 个代理，则将其保留为 0。没什么好改变的。如果您有另一个代理，那么更改其他文件中的 id，使它们是唯一的。
# The id of the broker. This must be set to a unique integer for each broker.broker.id=1
- 更改日志目录。我坚持我的绝对路线。您可以在这里使用任何 Windows 风格的路径
# A comma separated list of directories under which to store log fileslog.dirs=C:\Apache\kafka_2.12–2.3.1\logs
- 复制因素就像硬盘上的 RAID。它将数据从一个代理复制到另一个代理，以实现冗余和容错。对于开发，我将把它保持在 1
浏览该文件中的字段。您会注意到超时值、分区值和默认 Zookeeper 端口号，如果出现问题，这些都将在以后的调试中派上用场。
默认情况下，Apache Kafka 将在端口 9092 上运行，Apache Zookeeper 将在端口 2181 上运行。
至此，我们完成了卡夫卡的配置。让我们启动服务器。
运行卡夫卡
确保 Zookeeper 服务器仍在运行。
导航到 Kafka 安装目录中的 bin 目录。在那里你会看到一个 windows 目录，进入那里。这是所有令人敬畏的 windows 实用程序存储的地方。对我来说，就是这里-
打开一个新的终端窗口
C:\Apache\kafka_2.12–2.3.1\bin\windows
(如果您忘记进入 windows 目录，而只是从 bin 目录启动，下面的命令将只是在 Visual Studio 代码中打开 shell 文件，而不是运行批处理文件)
kafka-server-start.bat C:\Apache\kafka_2.12–2.3.1\config\server.properties
你会看到这样的结果-
Client environment:java.compiler=<NA> (org.apache.zookeeper.ZooKeeper)
Windows 10 (org.apache.zookeeper.ZooKeeper)
Client environment:os.arch=amd64 (org.apache.zookeeper.ZooKeeper)
Client environment:os.version=10.0 (org.apache.zookeeper.ZooKeeper)
Client environment:user.name=Bivas Biswas
Client environment:user.home=C:\Users\Bivas Biswas Client environment:user.dir=C:\Apache\kafka_2.12–2.3.1\bin\windows (org.apache.zookeeper.ZooKeeper)
Initiating client connection, connectString=localhost:2181 sessionTimeout=6000 watcher=kafka.zookeeper.ZooKeeperClient$ZooKeeperClientWatcher$@57c758ac (org.apache.zookeeper.ZooKeeper)
[ZooKeeperClient Kafka server] Waiting until connected. (kafka.zookeeper.ZooKeeperClient)
此时，如果服务器等待 Zookeeper 响应超时，请转到运行 Zookeeper 的命令终端，然后按 enter 键。有时候如果《动物园管理员》空闲一段时间，我见过卡夫卡超时。
如果一切顺利，您将看到来自组协调器的一些元数据转储和偏移消息，看起来像这样，带有闪烁的等待光标
[GroupCoordinator 0]: Preparing to rebalance group console-consumer-83701 in state PreparingRebalance with old generation 1 (__consumer_offsets-10) (reason: removing member consumer-1–9bf4ef2d-97af-4e59–964e-5bb57b457289 on heartbeat expiration) (kafka.coordinator.group.GroupCoordinator)[GroupCoordinator 0]: Group console-consumer-83701 with generation 2 is now empty (__consumer_offsets-10) (kafka.coordinator.group.GroupCoordinator)
你会在动物园管理员终端看到一些活动。它可能会拍摄新的快照并启动新的日志文件。此时，您的卡夫卡已经启动并运行。
包扎
动物园管理员需要记住的几件事——
我们设置为日志目录的 dataDir 将很快被快照填满。
在我的测试中，用一个主题运行 Kafka 不到 15 分钟，产生了两个 65MB 的快照文件。这些快照是事务性日志文件，每次检测到节点发生变化时都会写入这些文件。
当 Zookeeper 将几个日志文件合并成一个更大的文件时，它会创建副本，但不会清理旧文件。所以自己清理这个目录。您可以使用 bin 目录中的 zkTxnLogToolkit 来配置日志保留策略。
如果您在 AWS 上部署 EC2 实例，并且使用 t2.micro 的免费层，服务器不会启动。
这是因为 zookeeper 和 Kafka 的默认堆大小约为 1 GB，而 t2.micro 上的内存为 1GB，因此它会抱怨内存空间不足。
为了避免这个错误，请在具有 4GB 内存的 t3.medium 实例上运行 Kafka，而不是在配置文件中减少堆大小。
没有什么比跟随一篇文章更令人沮丧的了，这篇文章的步骤并不像它所说的那样有效。这就是我开始写这篇文章的原因，当时我浏览了大量的破碎的文章并修复了错误。
如果您在这些步骤中遇到任何错误，请告诉我。如果你有困难，请在下面留言，我会尽快回复你。
快乐流媒体！
俄语开放语音转文本(STT/ASR)数据集
4000 小时的俄语 STT 数据
如果你不付铁价，你知道有人替你付了。生活的方方面面都是这样
原帖spark-in . me2019 年 5 月 1 日
TLDR
这是我们发布的俄语开放语音转文本(STT/ASR)数据集的附带帖子。这意味着有点轻松和开玩笑。所有的观点都是我自己的，可能我的同事们的观点不一样。这是非技术性的总结。不要太认真，可能 50%的文字是某种微妙的玩笑(如果你找到所有的复活节彩蛋，请敲我一下！).
总之，这里是数据集:
Dataset composition
TLDR:
- 我们已经收集并发布了一个具有4000+小时的数据集，用于训练俄语的语音到文本模型；
- 数据非常多样，跨领域，注释的质量从足够好到几乎完美不等。我们的目的是收集一个数据集，以某种方式将现实生活/商业应用联系起来。以学术的方式只收集纯粹/干净的数据没什么意思。理想情况下，该数据集是使用预先训练好的 STT 模型进行回购的第一步；
- 我们打算将这一数量增加到大约 10，000 小时，甚至可能增加到 20，000 小时，如果情况合适的话(我们知道如何达到 6-7k，我们会随机应变)；
- 我们没有投入任何真金白银来创建这个数据集(当然除了我们的时间和精力)，所以我们在 cc-by-nc 许可下发布它。如果您想将数据集用于商业目的，请点击此处；
- 你可以在这里看到发布历史；
加速 Imagenet 时刻
理想情况是这样的:
- 提取现有的公共模型和数据集；
- 收集一些你所在领域的 MVP 数据集；
- 建立一个 MVP 模型；
- 增加更多疑难病例；
- 验证、测试、冲洗和重复；
在计算机视觉(CV)和自然语言处理(NLP)等领域，有一些东西可以建立，这些东西只在 95%的情况下有效:
- 广泛共享的 Imagenet 预训练模型。每个框架都有一个类似于 this 的回购——在这里你可以得到任何种类的带有权重的 CV 模型。加水就行了；
- 在 NLP 中，根据我的经验，像 FastText 这样的工具效果最好。像伯特这样的现代巨大网络也能工作，但是在现实生活中我们并没有发现它们实用；
但是在俄罗斯的 STT，没有什么可以真正建设的
- 当然也有付费的 APIs 商业最新产品/来自政府相关实体的产品——但是它们有它们的缺点(除了是私有的或者是由不太透明的技术构建的)；
- 公共数据集充其量是稀缺的(<100 hours) and non-diverse / too clean at worst;
- Even English public datasets … are academic and detached from real life usage;
- STT has a long history, and it has a bias towards being developed by large tech companies;
- Unlike Google / Facebook / Baidu which are known to publish stellar research (FAIR’s papers are awesome and accessible, Google less so), Yandex is not really known to add anything to the community;
在 STT 也有几个较少讨论的“抓住你”的好处:
- 有一种推测，即您需要多少数据来进行适当的归纳-估计范围从 5，000 小时到 20，000 小时。例如，Librispeech ( LS ，最流行的数据集之一)是 1000 小时，非常“干净”。谷歌和百度在各种论文中报告了针对各种设置的 10，000-100，000 小时数据的培训；
- 如果在 CV 中，你学习特征的“领域”是例如在 STT 的**“猫”(也就是说，在某些位置上，参见 Hinton 关于这个的 CapsNets 的解释)，那就有点复杂了。你的数据可以是干净的/嘈杂的**。另外每种声音都有自己的领域，模特对声音的适应能力惊人。词汇也是一个问题。因此，基本上当有人报告 LS 提高了 3 个百分点(即 10%的 WER 降低到 7%的 WER)时，你应该对此持保留态度。我在 1-2 天内建立的初始管道能够很好地在 LS 上工作；
- 跨领域转移(即，当你在书本上训练，在电话上验证)是可行的，但效果很差。你很容易得到+20 便士的 WER。一些小事情也很重要，比如在嘈杂的环境中语调/说话方式的不同；
所以——你可以把我们的冒险视为第一步，为社区提供一套我们语言的公共模型(俄语，我们的大部分方法可以扩展到其他语言),让 Imagenet 时刻更近一步/为公众制作相当好的 STT 模型。
你可以说现在我们深陷在数据中。为了成功，我们需要更深入！请阻止我说出这些可怕的双关语。
寻求贡献者
如果你愿意为我们的数据集/事业做出合理的贡献，我们欢迎你！我们将确保尽可能友好地发布尽可能多的内容。
请在这里联系我们。
可以这样框。如果 4 个人(不是只在这个项目上花费 100%的时间)可以有所作为，那么你的加入可能会使天平向构建一个真正灵活的可部署模型倾斜？
如何不共享数据集
首先，这里列出了我不喜欢人们在分享数据集时一直做的事情:
- 显然，付费墙没有办法预先检查你将得到什么；
- 学术象牙塔态度——“我们的数据集很酷，很大，但在现实生活中毫无用处”；
- 注册墙。是的，“我们的数据集是公开的，但我们将只为被选中者共享它”。这东西。是的，如果我们决定不与你分享，你不会得到通知。或者最有可能的是——没人付钱给版主；
- 通过 Google Drive 分享(顺便说一句，你可以通过 Google Drive 使用
wget，你需要下载一个 cookie 并使用他们的链接结构)或者依靠临时/动态链接的东西。理想情况下，你应该能够使用wget或者更好的aria2c来获取数据； - 托管差，CDN 差，速度差。当人们共享一个数据集时，这是可笑的，这可能会花费 10 万美元以上——从零开始手工注释需要 100 万美元，但每月节省 100 美元用于真正正确地托管数据集；
- 通过 torrent 共享…没有至少 100 Mbit/s 上行速度的活动种子。学术洪流是伟大的，但任何时候都没有种子；
- 文件夹组织不好，没有元数据文件，结构不合逻辑；
- 用于加载数据集(hello
xml和对象检测数据集)的臃肿、过时的工具和文件格式； - 晦涩难懂的代码来读取这样的数据。你可以在熊猫身上创造奇迹。不，真的；
- 没有办法检查你的数据；
- 一般不关心用户；
- 以专有格式共享数据/推动某种形式的议程；
我们尽了最大努力不犯任何错误:
- 首先，所有链接都是公开的。我们的大部分数据来源于互联网，所以我们尽可能地分享数据。
- 我们还没有做到这一点(帮助美国，为什么不)，但你可以写一个脚本，将下载一切，解压一切，检查 md5 和文件一气呵成；
- 数据集是托管在 AWS 兼容桶与 CDN 下载速度会很好。您可以使用带有-x 标志的
aria2c来更快地加载文件； - 数据大多以相同的格式检查和写入；
- 数据被收集在一个优化的磁盘数据库中(详情见 repo ),即使在硬盘上也能工作**(我们没有测试)。我相信 RAID 阵列或 NVME 高速缓存将完全解决 IO 问题(我们自己使用 SSD NVME 驱动器)；**
- 元数据文件；
- 一些基本的可破解代码片段，以便更容易开始；
寻找动机，有所作为，道德和动机
最后，我想提出一组观点:
- 在我做了一些基线原型和数据集之后，我对结果非常失望。如果没有尤里的建议、经验和合作，我可能会放弃这个项目。尤里，我永远感激你的帮助。是的，我看到 STT 在俄罗斯是成熟的“ImageNet 时刻”采摘，但我们不会保持动力，如果没有你；
- 显然，即使我们无法为公众提供可用/稳健的模型，我们的数据/模型也将作为这一方向的第一步；
- “哦，这样的数据集应该很贵”。是的，从头开始建造这样的东西可能会花费数百万美元。但我们并不孤独，生活也不是零和游戏——所以更容易；
- 生活不是零和游戏——因此我们看到了公开数据集的机会——我们做到了；
- 不，以我们使用数据的方式使用数据并不是不道德的。首先，对于我们使用的 100%的数据— 我们没有放在那里。有人做到了。我们不会将数据用于与上传时相同的目的；
- 最后，房间里的大象。通过发布这样一个数据集，我们让奥威尔在《1984》中描述的即将到来的末日更加接近。是也不是。你看，我不相信这是可行的，以达到这样的准确性，实际上根据 STT 的结果关押人在经济上是有意义的。如果你有 10%的真实 WER——对于大多数商业应用程序来说，你已经开发出了惊人的产品！但是把人关进监狱太过分了——你最终只会处理假阳性。据我所知，在更文明的国家，采取这种行动需要法院裁决。我相信其他一些技术天生比 STT 更有毒(比如人脸识别)。毕竟——如果你想私下说点什么——私下说点什么(使用加密或者只是当面说)。你不能私下出去。我知道我们正在谈论这种技术的大规模应用，但即使你正在做一些粗略的事情，你也可以选择打电话给某人来谈论它。去购物中心，因为看起来像少数民族而被逮捕(I)首先在许多国家已经是一个问题(ii)不是你的选择。隐藏你的外表也可能会带来问题；
- “你的数据集烂是因为 X”！是的，请给出反馈，但要有逻辑性，最好给我们发一封电子邮件或 Github 问题。大多数情况下，我们只是收集了所有能得到的数据。但如果你这么在意，欢迎投稿！；
- 我也喜欢像这样的批评“你假装通过做某事(例如，分享数据集)来采取一种高尚的道德立场，你为什么这么做”。我在上面主要提到了这两点；
俄罗斯巨魔推文:使用 BERT 分类
Photo by Alex Knight on Pexels
网络部队，也被称为俄罗斯巨魔机器人，是国家支持的匿名政治评论员。他们经常通过 Twitter 和脸书等社交媒体平台传播政治分裂内容。网络部队瞄准了一些事件，如 MH17 坠机事件、2014 年 T2 乌克兰冲突事件和 2016 年 T4 美国大选事件。考虑到政治分裂内容的大规模传播可能会产生严重后果，例如干扰选举，因此开发有助于准确检测这些不良行为者的方法非常重要。在本文中，我们将使用 BERT 构建一个机器学习分类器，来预测一条推文是否来自俄罗斯机器人。我们将使用来自 Kaggle 的俄罗斯巨魔推文数据集，可以在这里找到。
在我们进入数据之前，我们将简要回顾一下伯特。BERT 代表来自变压器的双向编码器表示。描述 BERT 算法的论文由 Google 发布，可以在这里找到。BERT 的工作原理是随机屏蔽单词标记，并用基于上下文的向量来表示每个被屏蔽的单词。BERT 的两个应用是“预训练”和“微调”。
预训练 BERT
对于预训练 BERT 算法，研究人员训练了两个无监督学习任务。第一个任务被描述为屏蔽 LM。其工作原理是随机屏蔽 15%的文档，并预测这些被屏蔽的标记。第二个任务是下一句预测(NSP)。这是由问答和自然语言推理等任务激发的。这些任务需要模型来准确捕捉句子之间的关系。为了解决这个问题，他们对二进制预测任务进行了预训练，该任务可以从单一语言的任何语料库中轻松生成。他们在论文中给出的例子如下:如果你有句子 A 和 B，A 有 50%的时间被标注为“isNext”，另外 50%的时间是从语料库中随机选取的句子，被标注为“notNext”。针对这一任务的预训练被证明对于问题回答和自然语言推理任务是有益的。
微调伯特
微调 BERT 的工作原理是用自我关注对连接在一起的文本对进行编码。自我注意是学习当前单词和先前单词之间相关性的过程。这一点的早期应用是在长短期记忆()论文(Dong2016)中，研究人员使用自我注意进行机器阅读。BERT 的好处在于，通过对具有自我关注的串联文本进行编码，可以捕捉句子对之间的双向交叉关注。
在本文中，我们将应用 BERT 来预测一个文档是否是假新闻。数据集的名称是弄真假新闻，在这里可以找到。这篇文章的灵感来自于BERT to Rescue，它使用 BERT 对 IMDB 数据集进行情感分类。从 伯特到营救 的代码可以在这里找到。
BERT 算法的输入是单词序列，输出是编码的单词表示(向量)。对于单句分类，我们使用每个单词的向量表示作为分类模型的输入。
现在让我们开始吧！
- 导入包
import pandas as pd
import numpy as np
import torch.nn as nn
from pytorch_pretrained_bert import BertTokenizer, BertModel
import torch
from torchnlp.datasets import imdb_dataset
from keras.preprocessing.sequence import pad_sequences
from sklearn.metrics import classification_report
2.数据探索
俄罗斯巨魔推文数据集只包括俄罗斯巨魔推文，所以我们需要提取一些额外的数据，我们可以将其标记为“非机器人”或“正常”推文。我使用 twitter python API Tweepy 来提取使用流行关键字的额外推文。关于使用 Tweepy 的综合教程，你可以阅读我写的另一篇文章:来自 Twitter 的患者对药物的看法。我使用的关键词是’ #followfriday ‘，’ #tuesdaymotivation ‘，’ # thankful ‘，’ #birthday ‘，’ #pet ‘，’ #funny ‘和’ #influencer '，它们取自 twitter 上 2018 年以来的热门标签列表，可以在这里找到。拉“正常”推文的代码将在 GitHub 上提供。
现在让我们将数据读入 dataframe 并打印前五行。我们还可以将最大显示列数设置为“无”。为简单起见，让我们看看“文本”和“类型”列:
pd.set_option('display.max_columns', None)
df = pd.read_csv("training_data.csv")
df = df[['text', 'type']]
print(df.head())
3.数据准备
使用“计数器”方法，我们可以了解数据中“机器人”和“正常”值的分布情况:
print(Counter(df['type'].values))
让我们也放弃“南”值:
df.dropna(inplace = True)
接下来，我们希望平衡我们的数据集，使我们有相同数量的“机器人”和“正常”类型。我们还应该随机改变目标:
df_bot = df[df['type'] == 'bot']
df_normal = df[df['type'] == 'normal']
df_bot = df_bot.sample(n=len(df_normal))
df = df_normal.append(df_bot)
df = df.sample(frac=1, random_state = 24).reset_index(drop=True)
再次验证我们得到了想要的结果:
print(Counter(df['type'].values))
接下来，我们要格式化数据，这样它就可以用作我们的 BERT 模型的输入。我们将数据分为训练集和测试集。我们总共使用 100 条记录进行培训和测试:
train_data = df.head(50)
test_data = df.tail(50)
我们用“文本”和“类型”关键字生成一个字典列表:
train_data = [{'text': text, 'type': type_data } for text in list(train_data['text']) for type_data in list(train_data['type'])]
test_data = [{'text': text, 'type': type_data } for text in list(test_data['text']) for type_data in list(test_data['type'])]
从字典列表中生成元组列表:
train_texts, train_labels = list(zip(*map(lambda d: (d['text'], d['type']), train_data)))
test_texts, test_labels = list(zip(*map(lambda d: (d['text'], d['type']), test_data)))
生成令牌和令牌 id:
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)
train_tokens = list(map(lambda t: ['[CLS]'] + tokenizer.tokenize(t)[:511], train_texts))
test_tokens = list(map(lambda t: ['[CLS]'] + tokenizer.tokenize(t)[:511], test_texts))train_tokens_ids = list(map(tokenizer.convert_tokens_to_ids, train_tokens))
test_tokens_ids = list(map(tokenizer.convert_tokens_to_ids, test_tokens))train_tokens_ids = pad_sequences(train_tokens_ids, maxlen=128, truncating="post", padding="post", dtype="int")
test_tokens_ids = pad_sequences(test_tokens_ids, maxlen=128, truncating="post", padding="post", dtype="int")
请注意，我们将输入字符串截断为 128 个字符。BERT 可以处理的最大长度是 512，但是为了节省计算时间，我们将使用 128。
最后，为我们的测试和训练集生成一个基于“type”值的布尔数组:
train_y = np.array(train_labels) == 'bot'
test_y = np.array(test_labels) == 'bot'
4.模型建筑
我们创建了我们的 BERT 分类器，它包含一个“初始化”方法和一个返回令牌概率的“转发”方法:
class BertBinaryClassifier(nn.Module):
def __init__(self, dropout=0.1):
super(BertBinaryClassifier, self).__init__()self.bert = BertModel.from_pretrained('bert-base-uncased')self.dropout = nn.Dropout(dropout)
self.linear = nn.Linear(768, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, tokens, masks=None):
_, pooled_output = self.bert(tokens, attention_mask=masks, output_all_encoded_layers=False)
dropout_output = self.dropout(pooled_output)
linear_output = self.linear(dropout_output)
proba = self.sigmoid(linear_output)
return proba
接下来，我们生成训练和测试掩码:
train_masks = [[float(i > 0) for i in ii] for ii in train_tokens_ids]
test_masks = [[float(i > 0) for i in ii] for ii in test_tokens_ids]
train_masks_tensor = torch.tensor(train_masks)
test_masks_tensor = torch.tensor(test_masks)
生成用于训练和测试的令牌张量:
train_tokens_tensor = torch.tensor(train_tokens_ids)
train_y_tensor = torch.tensor(train_y.reshape(-1, 1)).float()
test_tokens_tensor = torch.tensor(test_tokens_ids)
test_y_tensor = torch.tensor(test_y.reshape(-1, 1)).float()
最后，准备我们的数据加载器:
train_dataset = torch.utils.data.TensorDataset(train_tokens_tensor, train_masks_tensor, train_y_tensor)
train_sampler = torch.utils.data.RandomSampler(train_dataset)
train_dataloader = torch.utils.data.DataLoader(train_dataset, sampler=train_sampler, batch_size=BATCH_SIZE)test_dataset = torch.utils.data.TensorDataset(test_tokens_tensor, test_masks_tensor, test_y_tensor)
test_sampler = torch.utils.data.SequentialSampler(test_dataset)
test_dataloader = torch.utils.data.DataLoader(test_dataset, sampler=test_sampler, batch_size=BATCH_SIZE)
5.微调
我们使用 Adam 优化器来最小化二进制交叉熵损失，并且我们使用 1 个时期的批量大小 1 来训练:
BATCH_SIZE = 1
EPOCHS = 1bert_clf = BertBinaryClassifier()
optimizer = torch.optim.Adam(bert_clf.parameters(), lr=3e-6)for epoch_num in range(EPOCHS):
bert_clf.train()
train_loss = 0
for step_num, batch_data in enumerate(train_dataloader):
token_ids, masks, labels = tuple(t for t in batch_data)
probas = bert_clf(token_ids, masks)
loss_func = nn.BCELoss()
batch_loss = loss_func(probas, labels)
train_loss += batch_loss.item()
bert_clf.zero_grad()
batch_loss.backward()
optimizer.step()
print('Epoch: ', epoch_num + 1)
print("\r" + "{0}/{1} loss: {2} ".format(step_num, len(train_data) / BATCH_SIZE, train_loss / (step_num + 1)))
我们评估我们的模型:
bert_clf.eval()
bert_predicted = []
all_logits = []
with torch.no_grad():
for step_num, batch_data in enumerate(test_dataloader):token_ids, masks, labels = tuple(t for t in batch_data)logits = bert_clf(token_ids, masks)
loss_func = nn.BCELoss()
loss = loss_func(logits, labels)
numpy_logits = logits.cpu().detach().numpy()
bert_predicted += list(numpy_logits[:, 0] > 0.5)
all_logits += list(numpy_logits[:, 0])
print(classification_report(test_y, bert_predicted))
Classification Report
鉴于我们没有太多的训练数据，结果证明性能精度相当低。尝试将模型拟合到更多的数据，看看是否可以提高准确性。此外，你可以尝试使用 Tweepy 和一些常用的关键字来增加额外的推文，从而增强“正常”标签。
在BERT to the Rescue*中可以找到对代码的更详细的介绍。*这篇文章的代码可以在 GitHub 上找到。感谢阅读，机器学习快乐！
标准普尔 500 再创历史新高！
Photo Credit: Sam Valadi, “Charging Bull”, taken on 7/22/2011, Flickr. (CC BY 2.0)
那又怎样？“历史新高”有点武断，而且毫无意义。
从 1950 年 1 月 3 日到 2019 年 4 月 24 日，标准普尔 500 有 1251 天以“创纪录高位”收盘，这是比以前记录的“创纪录高位”高的任何数字，可以小到一位数。在 17，438 天中，只有 7%的日子里数字上升——或者在大多数情况下飙升——达到新的“历史新高”
然而，据我所知，当我们看到这些数字在 70 多年里一点一点地增长时，达到一个新的“历史新高”并没有什么特别令人震惊的。从更大的角度来看，只有一位总统在任期间至少一次没有创下历史新高，那就是杰拉尔德·福特(Gerald Ford)，所有人都认为他在尼克松辞职后遭遇了政治困境。
下图显示了 1950 年至 2019 年的标准普尔 500。结果是，自 1950 年初以来，这一指数已经增长了 17，540%——这是一个毫无意义的数值，只能说它比过去高了很多。更重要的是，任意宣布“历史新高”的事实是，平均而言，标准普尔 500 每个交易日的增长率为 1.0058%。(当我们包括周末/假期时，当交易不发生时，我们谈论的是每天 0.69%——这仍然具有向上移动的净影响。)
Figure 1
第二个图像显示了两种不同的度量。蓝柱显示的是 S&P 在每位总统的整个任期内达到的最大值。注意，每一个蓝色的柱子都比前一个柱子高*(除了杰拉德·福特——如果你能看出来的话)。绿色的柱子代表总统宣誓就职时的标准普尔值。你会注意到从乔治·w·布什到巴拉克·奥巴马这一栏出现了非常显著的下降——37%——这是由于经济衰退。这也发生在尼克松于 1974 年 8 月辞职后，福特总统被迫就职时。但是总的来说，对于每一位宣誓就职的总统来说，绿色的柱子应该比他们的前任高。*
Figure 2
下图显示了从第一次就职演说的收盘价格到最后一天任期的增长(或亏损——红色)。例如，S&P(当时是 S&P 90 指数)在德怀特·戴维·艾森豪威尔的就职日收于 26.41，在他担任总统的最后一天收于 59.77——上涨了 129%。而对于乔治·w·布什总统来说，经济遭受了-37%的下降。看待这个问题的一种方式是，理查德·尼克松(Richard Nixon)和乔治·w·布什(George W. Bush)离任时，S&P 收盘价低于他们宣誓就职时的水平。
Figure 3
下一张图显示了每位总统在任期间最小值收盘值和最大值收盘值的增长情况(或方差)。例如，罗纳德·里根总统任期内的最低收盘价为 102.42，最高收盘价为 336.77，相差 229%。**
Figure 4
下一张图显示了 S&P 以“新高”收盘的在任天数百分比
Figure 5
请注意，福特总统没有看到破纪录的天数，乔治·w·布什总统看到了第二少的天数，不到 1%。中位数为 7%。值得指出两件事:杜鲁门和特朗普分别有 1109 天和 825 天的任期，这反映在这些图表中。
在这方面，杜鲁门看到了 109 个新的“历史新高”，特朗普看到了 80 个。我建议谨慎对待这些数据，因为如果没有完整的总统任期，这些数据将会失真。例如，乔治·w·布什看到了技术的增长，至少在延续良好的经济方面，但随后就崩溃了。这是图 5 的弱点，但是在图 1 的上下文中，您可以看到它的价值。
延续同样的趋势，我们看不到在巴拉克·奥巴马总统的第一个任期内有没有*“历史新高”。他的所有成长都发生在担任总统的最后三年里——这令人震惊。如果我们将这个图表按任期细分，我们会看到，在奥巴马第二个任期的前 825 天里，他看到了 104 个新的“创纪录高点”——比特朗普目前的第一个任期高出 20%。*
为什么是标准普尔 500？
标准普尔，即 S&P，自 1860 年以来一直存在，但它的现代版本是 1941 年普尔出版公司和标准统计局合并的结果。在这次合并之前，普尔出版公司已经在 1923 年创建了它的第一个“综合指数”。从 1926 年到 1957 年，综合指数由 90 种股票组成，这里称为 S&P 90。1957 年这一指数扩大到 500，尽管今天是 505。
纳斯达克综合指数成立于 1971 年，所以我认为为了趋势，增加 21 年的数据会很好。道琼斯工业平均指数(DJI)，虽然它已经存在了一段时间，但这些股票都包含在标准普尔 500 中，所以与 DJI 一起做二次分析是多余的。此外，S&P 是市场中行业的代表，这使其成为分析的理想基准。
我是如何获得“历史新高”的
我从雅虎上下载了这些数据，然后煞费苦心地在每个高于前一个记录高点的数值旁边加上 1，并因此构成了一个“新高”。例如:
110.55 | 1
111.00 | 1
108.87 | 0
105.20 | 0
114.68 | 1
114.68 | 0
总共有 17438 天的记录。然后我统计(合计)了每位总统的天数，得出标准普尔 500 收盘创“新高”的总天数我四舍五入到两位小数(尽管雅虎给出了 10 位以上),以便找到新记录的高点。你可能会想“这是一个武断的”决定，这是真的，但是考虑到“创纪录的 S & P 高点”是相当小的。
但是，我决定保留小数点后两位的主要原因是，这是指数通常的显示方式。这意味着在我的分析中，如果之前的记录是 15.00，那么 15.01 将被视为新高。
总统对经济或标准普尔 500 有什么影响？
研究表明很少。艾伦·布林德和马克·沃森(美国国家经济研究局)的一份工作报告发现，民主党总统的 GDP 增长率比共和党总统高 1.8%，但至少有 50%是由总统无法控制的市场因素造成的——如石油冲击、消费者支出等。实际上，他们认为共和党在这方面运气较差，但经济更稳定，而民主党则增长更快，问题更少，也更脆弱。
类似的观点——总统对经济几乎没有控制力——在538、、、、、《纽约时报》、、国家评论和彭博的人们都提出过。教训是:1)总统对经济的实时影响非常小，最大的整体影响是他们对美联储主席的选择，但这种影响甚至是最小的。2)无论你如何衡量或定义，运气都有更大的影响。在经济衰退中期当选的总统(例如福特、奥巴马)，起步时大有作为。3)经济政策往往会在相关总统离任后很久才产生影响。需要年*。*
结论
虽然看到“破纪录”的数字令人兴奋，但这一切都是在某种背景下发生的，而且几乎完全是在西翼(或高尔夫球场)范围之外的背景下发生的。
例如，4 月 23 日标准普尔 500 创下历史新高的反弹更令人兴奋，因为它弥补了自 9 月以来的损失(超过 25 点)。从经济角度来看，这种情况比 S&P 创造新纪录更令人兴奋。
但是，考虑到标准普尔 500 和其他市场指数没有理论上的最大值，也就是说，它将永远继续向上移动(在熊市、衰退、萧条和典型波动之外)。
这篇文章更重要的一点是，它是武断地继续吹嘘“新的历史新高”，而不是简单地因为除非资本主义、通货膨胀、市场等。不再存在，而是因为它是一个被放弃的结论。例如，除了杰拉尔德·福特，每一位总统都看到了历史新高。
Figure 6
上图显示了每位总统在给定的 30 天内的平均“创纪录高点”数量。例如，唐纳德·特朗普(Donald Trump)目前每 10 天就会看到一次新高。奥巴马总统大约每 23 天就会看到一个新的记录。但是，从长远来看，奥巴马直到 2013 年 3 月 28 日才开始看到新的纪录(在他的第二个任期内)。一旦开始，他看到每 11 天就有一个新的记录。理查德·尼克松每 58 天就看到一次新纪录，而乔治·w·布什每 325 天才看到一次新纪录——这是有道理的，因为经济崩溃了。
这幅图的目的是为了强调一点，我们将会看到平均一周一次的新高。这个实际上看起来会是什么样子，我们会经历几周或几个月的下降和停滞，然后是几个创纪录的日子。有点像我们现在在4 月 23 日，然后在4 月 26 日看到的，市场观察在一周内两次惊呼我们看到了 S & P 500 创下的“新纪录”。
背景很重要，我想说这是区分好消息和任意消息的地方。
有人脸识别的那个。
全面互动的人脸识别入门指南。跟随并创建一个自定义的人脸识别程序，它能够检测和识别视频或直播网络摄像头流中的人脸。
这是一个繁忙的市场场景；七月刺目的阳光照耀着头顶。酷热并没有阻止顾客的到来。人们不知道的是，在他们中间隐藏着一个怀有恶意的人。他伪装成一副正常人的样子，步行去实现他邪恶的目的。在一个角落里，一个监控摄像头定期扫描这个区域，这时它瞥见了这个家伙。它看到的每一张脸都会立刻被认出来，而且碰巧这家伙是个通缉犯。在几毫秒的时间里，他附近的警察得到了警报，他们开始着手消除这一威胁。这个故事曾经出现在科幻小说中，但现在情况大不相同了。事实上，中国使用人工智能驱动的监控工具来监视其公民。智能手机制造商也在积极利用人脸识别来验证手机用户的身份。人脸识别有许多不同的应用，不管你想用它做什么，在这篇文章中，我将指导你创建一个自定义的人脸识别程序。您将构建一个小程序，该程序将在视频剪辑或网络摄像头流中识别您选择的人脸。
Like what you see? This is what we will get.
在本文中，我们将构建一个自定义的人脸识别程序。这篇文章很容易理解，也阐明了这个机器学习项目的理论方面。如果你愿意，请使用目录来确定重要的部分并浏览文章。
目录
专业提示:如果你想快速完成工作，请随意跳过理论部分，直接进入第二部分。
- Facenet
一、什么事？
二。Facenet 是如何工作的？
三。三重损失 - 让我们开始建造吧！
一、前提条件
二。数据变脏
三。下载 Facenet
四。对齐
v .获取预训练模型
vi。根据我们的数据训练模型
vii。在视频上测试我们的模型 - 弊端
- 结论
- 参考文献
Facenet
在这个项目中，我们将采用一个名为 Facenet 的系统来为我们进行人脸识别。
这是什么？
Facenet[1]是由 Florian Schroff、Dmitry Kalenichenko、James Philbin。他们也写了一篇关于它的论文。它直接学习从人脸图像到紧致欧几里得空间的映射，其中距离直接对应于人脸相似性的度量。一旦创建了这些嵌入，就可以利用这些嵌入作为特征来完成像人脸识别和验证这样的过程。
Facenet 是如何工作的？
Facenet 使用卷积层直接从面部的像素学习表示。这个网络是在一个大数据集上训练的，以实现对光照、姿态和其他可变条件的不变性。该系统在野生的 (LFW)数据集中的标记的人脸上进行训练。该数据集包含从网络上收集的 13，000 多张不同人脸的图像，每张人脸都有一个名称(标签)。
Facenet 从图像中创建 128 维嵌入并将它们插入到特征空间中，以这种方式，不管成像条件如何，相同身份的所有人脸之间的平方距离很小，而来自不同人物的一对人脸图像之间的平方距离很大。下图描述了模型架构:
Model Structure: The model contains a batch input layer, followed by a Deep CNN architecture, and an L2 layer. This results in the creation of facial embeddings.
三重损失
该系统采用一种称为三重态损耗的特殊损耗函数。三元组损失最小化相同身份的图像之间的 L2 距离，最大化不同人物的面部图像之间的 L2 距离。
该系统采用三重损失，因为它更适合于面部验证。使用三重损失背后的动机是，它鼓励一个身份的所有图像被投影到嵌入空间中的单个点。
Triplet loss: Before and after the learning process.
创作者设计了一种有效的三重选择机制，每次智能地选择三幅图像。这些图像有以下三种类型:
1。 主播 :一个随机出现的人的形象。
2。 正面 形象 :同一个人的另一个形象。
3。 负面 形象 :一个不同的人的形象。
测量两个欧几里德距离:一个是锚和正图像之间的距离，我们称之为 A。另一个是锚和负图像之间的距离，我们称之为 B。训练过程旨在减小 A 并最大化 B，使得相似的图像彼此靠近，而不同的图像位于嵌入空间的远处。
好了，Facenet 很酷，现在怎么办？
最好的部分是前方的路。我们可以使用 Facenet 为我们自己选择的人脸创建嵌入，然后训练 SVM(支持向量机)使用这些嵌入进行分类。让我们开始构建一个自定义的人脸识别程序吧！
你可以看看这个项目的 Github 库，因为它包含一个自定义数据集和脚本来检测视频中的人脸。
先决条件
在我们开始之前，请确保您的系统上安装了以下库:
- 张量流==1.7
- scipy
- sci kit-学习
- opencv-python
- h5py
- matplotlib
- 枕头
- 要求
- psutil
被数据弄脏
在这个项目中，我们将创建一个人脸识别程序，它将能够识别 90 年代情景喜剧《老友记》中的核心人物。如果你想建立这个来识别一组不同的面孔，那么就用你的图像来代替。只要确保你遵循类似的目录结构——为你想要被识别的每个身份创建一个文件夹，并将这些文件夹存储在名为*‘raw’*的文件夹中。
Dataset Directory: Note how each character has a folder of its own.
用这些人的脸的照片填满每个文件夹。请注意，每张图片只有一张清晰可见的脸。我为每个角色添加了 20 张图片，尽管更少的图片就足够了。每个文件夹都有相同数量的图片。你可以在这里下载我从创建的朋友的数据集。哦，对了，这是*【钱德勒】*文件夹的样子:
Could it be any more fuller?
下载 Facenet
既然收集数据已经结束。请继续下载 Facenet repo 。下载它，提取它，并将*‘Dataset’*文件夹放入其中。
远离对齐
关于该模型的一个问题是，它可能会错过一些面部标志，为了解决这个问题，我们必须对齐数据集中的所有图像，以使眼睛和嘴唇出现在所有照片的相同位置。我们将使用 M.T.C.N.N .(多任务 C.N.N .)来做同样的事情，并将所有对齐的图像存储在一个名为 processed 的文件夹中。
打开终端/命令提示符并导航到 Facenet 目录。然后运行 align_dataset_mtcnn.py 以及以下参数。
python src/align_dataset_mtcnn.py \
./Dataset/Friends/raw \
./Dataset/Friends/processed \
--image_size 160 \
--margin 32 \
--random_order \
--gpu_memory_fraction 0.25
运行此命令将对齐所有图像，并将它们存储在各自的文件夹中，然后将所有内容存储在’*已处理’*文件夹中。下图将让您了解对齐是如何工作的:
All images are cropped and aligned to a standard 160x160 pixel image.
获取预先训练的模型
现在，为了在您自己的图像上训练模型，您需要下载预训练的模型。请从这里下载。
在 Facenet 根目录下创建一个名为“Models”的文件夹。下载完成后，将 zip 文件的内容解压到名为*‘facenet’的目录中，并将该文件夹放在‘Models’*文件夹中。
Here you go, another direcTREE image. Get it?
这个模型是在 LFW 数据集上训练的，因此所有的面部嵌入都存储在这些文件中。这让我们有机会冻结图表，并根据我们自己的图像对其进行训练。这样做将把我们提供的所有面嵌入到维度空间中。
根据我们的数据训练模型
我们已经万事俱备了！我们有一个预先训练好的模型，我们的自定义数据集已经对齐并准备就绪。现在，该训练模型了！
python src/classifier.py TRAIN \
./Dataset/Friends/processed \
./Models/facenet/20180402-114759.pb \
./Models/Friends/Friends.pkl \
--batch_size 1000
执行上述命令将加载预训练模型并开始训练过程。一旦训练结束，嵌入新图像的图像将被导出到模型/朋友/ 中。
由于我们使用预先训练的模型和相对较少数量的图像，训练过程很快就结束了。
在视频上测试我们的模型
为了测试我们的模型，我使用了朋友们的摘录。你可以使用自己的视频，甚至使用网络摄像头。在这一节中，我们将编写脚本来促进视频提要中的人脸识别。您可以继续学习以更好地理解这个脚本，或者从这里下载这个脚本。
导航到*‘src’*文件夹，创建一个新的 python 脚本。我将其命名为 faceRec.py。接下来，我们导入所有需要的库。
这个脚本将只接受一个参数，那就是视频文件的路径。如果没有提到路径，那么我们将通过网络摄像头传输视频。因此，该参数的默认值为 0。
我们将初始化一些变量。确保根据文件夹结构改变路径。
加载自定义分类器。
设置一个张量流图，然后加载面网模型。使用 GPU 将加快检测和识别过程。
设置输入和输出张量。
pnet、rnet 和 onet 是 M.T.C.N.N .的组成部分，将用于检测和对齐人脸。
接下来，我们将创建一个集合和一个集合来跟踪检测到的每个身份。
设置视频捕获对象。
因此，如果在运行程序时没有将 VIDEO_PATH 作为参数传递，它将采用默认值 0。如果发生这种情况，视频捕获对象将从网络摄像头传输视频。
然后，视频被逐帧捕获，并且通过 detect_face 模块在这些帧中检测人脸。找到的面数存储在 faces_found 变量中。
如果找到了面，那么我们将迭代每个面，并将边界框的坐标保存在变量 bb 中。
然后这些脸被提取、裁剪、缩放、整形并输入字典。
我们将使用该模型来预测人脸的身份。我们提取最佳类别概率或置信度。它是我们的模型在多大程度上确定预测的身份属于给定的脸的度量。
最后，我们将在脸部周围画一个边界框，并在边界框旁边写下预测的身份以及置信度。如果置信度低于某个阈值，我们会将该名称填充为未知。
务必放置 except 语句。这将确保任何抛出的错误被成功忽略。确保放置 except 语句。这样做有助于我们忽略错误。
except: pass
过程结束后，显示视频并关闭视频显示窗口。由于每一帧都要经过大量处理，视频回放可能会很慢。
恭喜你，你的耐心有了回报！我们已经完成了剧本，准备隆隆作响！快速启动 cmd 并执行以下命令来启动人脸识别程序。确保将待测试视频的路径作为参数传递，或者留空以从网络摄像头传输视频。
python src/faceRec.py --path ./Dataset/Friends/friends.mp
维奥拉。
My reaction when I saw this program work.
这个系统并不完美，也有一些缺点。
缺点
- 该系统总是试图将每张脸放入一个给定的身份中。如果一个新面孔出现在屏幕上，系统会给它分配一个身份。这个问题可以通过仔细选择阈值来解决。
- 身份之间的混淆。在上面的 gif 中，你可以观察到乔伊和钱德勒之间的预测是如何波动的。而且，置信度得分很低。用更多图像训练模型将解决这个问题。
- 在一定距离内无法识别人脸，即如果人脸看起来很小。
让我们结束这一切。
结论
不管是无形地照顾你的员工还是在野外寻找违法者。人脸识别技术可以证明是一个真正的宝石。这个项目包括创建一个人脸识别程序，它可以识别你选择的人脸。您创建了一个自定义数据集，训练了模型，并编写了在视频剪辑上运行人脸识别系统的脚本。然而，有一些缺点，但我们的系统运行良好。
祝你愉快。
参考文献
[1] Florian Schroff、Dmitry Kalenichenko 和 James Philbin， FaceNet:人脸识别和聚类的统一嵌入 (2015)，arxiv.org
安全人工通用智能
Photo by @the_las_memperor
未来生命研究所的 AGI 安全研究人员 2018 项目
未来生命研究所(FLI)已经出现在人工智能领域的各种文章和领域中，至少在我看来是这样。他们似乎关心未知的未来以及它对我们的影响。由于我一直在探索人工智能安全的话题，现在它确实有意义，因为 FLI 在过去五年里资助了一系列不同的项目，特别是两轮，都是由埃隆·马斯克和不同的研究机构资助的。第一轮似乎是在 2015 年，重点是人工智能安全研究人员，第二轮是在 2018 年，重点是人工通用智能(AGI)安全研究人员。由于项目总结都在网上，我决定依次思考一下。
关于生命的未来研究所
FLI 有一个**使命:促进和支持保护生命和发展未来乐观愿景的研究和倡议，包括人类在考虑新技术和挑战的情况下引导自身发展的积极方式。 FLI 目前正专注于保持人工智能的益处，他们也在探索降低核武器和生物技术风险的方法。他们位于波士顿，并于 2014 年在麻省理工学院举行了发布会。他们在 2015 年组织了一次关于人工智能未来的会议。5000 名研究人员在一封信上签名，让人工智能变得强大。2015 年，埃隆·马斯克宣布他将提供 1000 万美元的支持，第一笔 600 万美元的资金将在那时到位。37 名研究人员被选中，获奖者发表了超过 45 篇科学论文。我可能会从 2015 年开始接触这些出版物，但首先我将重点关注最近一轮及其大纲。
FLI 2018 资助轮项目总结及对技术摘要的思考
2018 年春天，FLI 启动了他们的第二个人工智能安全研究计划，这次专注于人工通用智能(AGI。到夏天， 10 名研究人员获得了超过 200 万美元的奖金，以解决与筹备 AGI 相关的技术和战略问题。我已经重新发布了技术摘要，并将给出一些想法，或者看看我是否发现任何值得简单探索的术语或方向。如果你觉得这太简单，我很抱歉，我这样做是为了更好地理解这些建议。
1。艾伦·达福
“技术摘要: 人工通用智能(AGI)可能在本世纪内开发出来。虽然这一事件可以带来巨大的好处，如科学和经济进步的急剧加速，但它也带来了重大的风险。最近的一项调查显示，中等人工智能研究人员认为，至少有二十分之一的可能性会出现像人类灭绝这样极端的负面结果。确保 AGI 得到安全有益的发展，避免最坏的风险，将需要尚不存在的机构。
然而，设计和理解这些机构的需求迄今为止还没有激发出多少学术工作。我们的项目旨在解决治理高级人工智能系统的几个基本问题。我们将朝着这一目标追求四个工作流，涉及中国人工智能研究和政策思想的状态，政府和人工智能研究公司之间不断发展的关系，验证人工智能使用和发展协议的前景，以及可能指导各国人工智能治理方法的人工智能系统的战略相关属性。该计划的产出将包括学术出版物，研讨会，以及与人工智能发展和政策的主要行为者的磋商。”
主线程:
- 这是一个研究项目，旨在了解开发人工智能的机构，着眼于人工智能治理和国际关系的方法。
它有四个*【工作流】*；
- 中国人工智能研究与政策思想
- 政府和人工智能研究公司的关系。
- 验证人工智能使用和开发协议的前景
- 人工智能系统的战略相关属性，这些属性可以 指导国家对人工智能治理的方法
Allan Dafoe 是人类未来研究所人工智能治理中心的主任。他是人工智能国际政治副教授。他的背景是政治学和经济学。他是和平与冲突研究部的客座研究员。
你可以在这里找到更多关于 GovAI 的信息:【https://www.fhi.ox.ac.uk/GovAI/
如果你想要一个关于这个主题的介绍和艾伦·达福的讲座，你可以在 Youtube 上看看这个视频。
2。斯特凡诺·埃尔蒙
"技术摘要: 报酬规范是价值调整中的一个关键挑战，在有多个主体的环境中尤其困难，因为设计者必须在个人收益和整体社会效用之间进行平衡。我们考虑逆向强化学习(IRL ),而不是手工设计奖励，这是一种模仿学习技术，代理直接从人类演示中学习。这些技术是为单个代理开发的，虽然它们有局限性，但它们通常被认为是解决价值一致性问题的关键组件。然而，多代理设置相对来说还没有被探索过。
我们建议填补这一空白，开发专门为多智能体设置设计的模仿学习和逆向强化学习算法。我们的目标是:1)开发模仿观察到的人类行为和交互的技术，2)显式地恢复可以解释多智能体系统中复杂策略行为的奖励，使智能体能够对人类行为进行推理并安全共存，3)开发可解释的技术，以及 4)处理非理性智能体以最大限度地提高安全性。这些方法将极大地提高我们理解和推理复杂环境中多主体间相互作用的能力。”
主线程:
- 通过模仿学习和反向强化学习算法在复杂的多主体设置中平衡奖励规范。
目标。
- 开发技法 模仿观察人类行为 以及互动
- 显式 恢复奖励 能够解释多智能体系统中复杂的策略行为，使智能体能够对人类行为进行推理并安全共存
- 培养 可解释性 技巧
- 对付不理智的特工 最大化安全。
Stefano Ermon 是斯坦福大学计算机科学系的助理教授和伍兹环境研究所的研究员。他隶属于人工智能实验室。他拥有电子工程教育背景，计算机科学博士学位，辅修应用数学。你可以在这里阅读他关于 arXiv 的一篇论文。
如果你想看斯特凡诺的演讲，请点击这里。他谈到了他对这个话题的一些想法，这些想法可能更符合当前的情况:
3。欧文·埃文斯
"技术摘要: 我们的目标是了解机器学习如何以一种“安全可扩展”的方式用于 AGI，即随着 ML 组件的改进，变得越来越符合人类的利益。现有的 AGI 方法(包括 RL 和 IRL)被认为是不安全的:一旦智能体的认知资源超过人类监督者的认知资源，智能体就会变得不一致。Christiano 的迭代蒸馏和放大(IDA)是一个有前途的替代方案。在 IDA 中，通过允许人类调用代理的前一次迭代，人类和代理被“放大”成一个足智多谋(但缓慢)的监督者。从结构上来说，这个监督者总是要走在被监督者的前面。
如果有足够先进的 ML 成分，IDA 能生产出高性能的校准试剂吗？虽然我们今天无法直接获得经验证据，但我们可以通过将人类作为人工智能的替身进行放大来间接研究它。这对应于对“分解认知”的研究，即复杂的推理是否可以被分解成许多小的和大部分独立的子任务。我们将根据经验探索分解认知的方案，并通过 ML 开发自动化来处理更大的任务。”
主螺纹:
- 如何在迭代提取和放大(IDA)中使用分解认知通过允许人类调用代理的前一次迭代，人类和代理被“放大”成一个足智多谋(但缓慢)的监督者。
你可以在这里阅读更多关于因子认知的内容:
注:本帖(最初发布于此[https://ough . org/presentations/factured-cognition-2018-05])是…
www.alignmentforum.org](https://www.alignmentforum.org/posts/DFkGStzvj3jgXibFG/factored-cognition)
我认为这篇文章中的一幅图片可以更简洁地解释它，然而我可能是错的:
欧文·埃文斯是牛津大学人工智能领域的亚历山大·塔马斯研究科学家。他是在人类未来研究所(由尼克·博斯特罗姆导演)从事人工智能安全和强化学习研究的科学家。他的博士学位来自麻省理工学院，在那里他研究了认知科学、人工智能和哲学。
4。韩英豪
***"技术摘要:***AI 为了技术优势而向强大的 AI 系统的竞赛可能会导致严重的负面后果，尤其是当伦理和安全程序被低估甚至忽视的时候。为了让所有人都享受到安全、道德和值得信赖的人工智能所带来的好处，关键是要制定适当的激励策略，确保所有相关方的互利、规范行为和安全合规性。使用进化博弈论的方法，该项目将开发计算模型(分析和模拟),捕捉人工智能竞赛的关键因素，揭示在竞赛的不同条件和假设场景中可能出现的战略行为。
此外，应用激励和协议建模的方法，我们将系统地分析不同类型的激励(即积极与消极、同行与机构及其组合)如何随着时间的推移影响安全合规行为，以及应如何配置此类行为以确保预期的全球结果，同时避免会减缓发展的不当限制。因此，该项目将提供基础，在此基础上，激励将刺激这种结果，以及如何需要在适合玩家类型的激励边界内使用和部署它们，以便在合作安全协议中实现高水平的合规性，并避免 AI 灾难。”
主螺纹:
- 用进化博弈论的方法模拟和分析人工智能竞赛建筑计算模型，以观察随着时间的推移影响安全合规行为的不同激励。
Anh Han 目前是蒂塞德大学计算、媒体和艺术学院的计算机科学高级讲师。
5。何塞·埃尔南德斯-奥拉洛
"技术摘要: 存在许多范式，并且将会创造更多，用于开发和理解 AI。在这些范式下，关键的利益和风险以非常不同的方式出现。贯穿所有这些范式的一个维度是一般性的概念，它起着核心作用，并提供了中间的字母，在 AGI，人工一般智能。该项目从一般性措施的角度探索了目前和未来 AGI 范式的安全问题，作为性能的补充维度。
我们考察以下研究问题:
1 .我们应该根据任务、目标或优势来定义一般性吗？通用性与能力、计算资源以及最终的风险有什么关系？
2。在具有有限能力的通用系统和具有更高能力的不太通用的系统之间的安全权衡是什么？这与自动化的效率和风险有什么关系？
3。我们可以用广度增长来取代性能爆炸的单一概念吗？这如何帮助开发更强大的 AGI 系统的安全途径？
对这些问题进行了范例分析，例如强化学习、反向强化学习、对抗设置(图灵学习)、神谕、认知即服务、通过演示、控制或跟踪进行学习、教学情景、课程和迁移学习、自然化归纳、认知架构、大脑启发的人工智能等。”
主线程:
- 探索一般性测量的观点，作为绩效的补充维度:(1)定义，(2)权衡，(3)替代。
José Hernández-Orallo 是西班牙瓦棱西亚理工大学的信息系统和计算教授。他已经出版了四本书和一百多篇关于人工智能、机器学习、数据挖掘、认知科学和信息系统的文章和论文。他在机器智能评估领域的工作已经被科学和大众媒体报道，包括《经济学人》和《新科学家》。他率先将算法信息论应用于人工智能测试的开发。
6。马库斯·哈特
《技术摘要: 智能体框架、期望效用原理、顺序决策理论以及归纳推理和机器学习的信息论基础，已经为人工智能(AI)这个以前异构分散的领域带来了显著的秩序。在此基础上，在过去的十年里，我发展了通用人工智能理论。这是第一个也是目前唯一一个数学上严格的自顶向下的方法来形式化人工智能。
这个项目将推动通用人工智能理论的发展，以解决可能是 21 世纪最重大的存在风险:解决控制问题，即随着人工超级智能代理的产生而出现的独特的委托代理问题。目标是扩展现有的理论，使一般智能代理的控制问题的正式调查成为可能。我们的重点是通用人工智能理论所缺乏的最基本的属性，即嵌入现实世界的智能体理论:它不能可靠地建模，它是对单个智能体的约束，它不能安全地探索，以及它不能很好地理解如何指定与人类价值观一致的目标。”
主线程:
- 推进通用人工智能理论，通过嵌入现实世界的智能体理论来解决超级智能体产生的控制问题的风险。
马库斯·赫特是澳大利亚国立大学( ANU )计算机科学研究院( RSCS )的教授。之前他在瑞士和 IDSIA 以及 NICTA 在一起。他在 RSCS/ANU/NICTA/IDSIA 的研究围绕着通用人工智能，这是一种自上而下的人工智能数学方法，基于 Kolmogorov 复杂性、算法概率、通用 Solomonoff 归纳、奥卡姆剃刀、莱文搜索、序列决策理论、动态编程、强化学习和理性代理。
7。詹姆斯·米勒
【技术摘要: 经济学家长期以来致力于创造描述超理性人行为的数学工具，他们可能已经设计出了一种模拟未来计算机超级智能的出色方法。本指南解释了效用函数的用途、假设和限制，希望成为人工通用智能(AGI)理论家的宝贵资源。
该指南将对 AGI 关于工具收敛的文献进行评论，该文献认为对于许多类型的效用函数，AGI 将具有相似的中间目标。该指南考虑了正交性论题，该论题认为增加 AGI 的智能并不缩小它可能具有的效用函数集。本指南探讨了在 AGI 中可能出现但在经济研究中通常不会出现的效用函数，例如不稳定的效用函数、总是增加的边际效用函数、极高或极低的贴现率函数、可以自我修改的效用函数，或者偏好违反冯诺依曼-摩根斯坦效用定理假设之一的效用函数。
该指南考虑了外星人已经开发出计算机超级智能的可能性，这种智能已经收敛于与费米悖论一致的效用函数。最后，探索了 AGI 从人类效用函数中获取其值的合理性，即使给定了人类具有不同偏好的挑战。”
主线程:
- 一本评论 AGI 文学和探索效用函数的指南。
让我来解释两个看起来容易混淆的概念。
冯诺依曼-摩根斯坦效用定理 表明，在理性行为的某些公理下，面对不同选择的风险(概率)结果的决策者会表现得好像他或她正在最大化定义在未来某个特定点的潜在结果上的某个函数的期望值。
费米悖论:暗示我们应该寻求基于天文观测的科学数据，而这些数据是远古时代的文明无法获得的，我们应该制造机器，在我们的文明崩溃的情况下，用无线电信号淹没我们的星系。
费米悖论可能听起来令人困惑，确实如此，所以这里有一个 Kurzgesagt 视频可能有助于解释。
8。多尔萨·萨迪格
"技术摘要: 人工智能(AI)的最新发展使我们能够建造能够执行复杂任务的 AI 智能体和机器人，包括许多与人类互动的智能体和机器人。在这些任务中，机器人需要建立人类行为和偏好的预测性和鲁棒性模型:与人类合作的机器人操作者需要预测她的未来轨迹，或者坐在自动驾驶汽车中的人类可能对汽车应该如何谨慎驾驶有偏好。
在现实中，人类有不同的偏好，这些偏好可以以混合奖励函数的形式被捕获。由于有不同类型的人，学习这种混合可能具有挑战性。通常还假设这些人在近似优化习得的奖励函数。然而，在许多安全关键场景中，由于缺乏数据或对奖励函数结构的错误描述，人类遵循的行为不容易用学习到的奖励函数来解释。我们在这个项目中的目标是通过从一组混合的人类中引出比较来主动学习一种混合的奖励函数，并进一步分析这种模型的可推广性和鲁棒性，以便与 AI 代理进行安全和无缝的交互。”
主线程:
- 目标是从具有不同偏好的不同人那里学习混合的奖励函数。在安全至关重要的场景中，人类遵循的行为不容易用习得的奖励函数来解释。
多尔萨·辛格是斯坦福大学计算机科学系和电子工程系的助理教授。她的工作专注于自主系统的算法设计，这些系统可以安全可靠地与人交互。
她在斯坦福大学 HAI 的发布会上谈到了这个话题，在这方面，一个特别的图像引起了我的注意。
你可以在这里看到图片拍摄的完整视频:
9。皮特·斯通
【技术摘要: 随着技术的发展，智能体将能够长期(通用)自主，即在很长一段时间内需要自己选择自己的行为，这只是时间问题。因此，在许多情况下，代理将不能预先与它们可能交互的所有其他代理进行协调。
相反，代理将需要合作，以便在没有预先协调的情况下完成意想不到的联合目标。因此，“特别团队合作”问题，即队友必须一起工作以获得共同的目标，而事先没有任何关于如何做到这一点的协议，已经成为人工智能文献中最近的研究领域。
然而，到目前为止，还没有人关注代理人行为的道德方面。在这项研究中，我们介绍了 M-TAMER 框架(TAMER 的一种新变体),用于向代理传授人类道德的理念。使用混合团队(代理人和人)，如果采取被认为是道德上不好的行动，代理人将收到来自人类队友的负面反馈。使用 M-TAMER，代理人将能够发展一种“内心良知”,这将使他们的行为与人类道德一致。"
主线程:
- 代理人专门解决问题的团队合作引起了关于代理人行为的道德方面的问题。驯兽师框架用于通过负反馈向代理传授人类道德的理念。
皮特·斯通是德克萨斯大学奥斯汀分校计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系的创始人和主任，德克萨斯大学计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系计算机科学系。
你可以在这里观看他关于机器人世界杯的 TED 演讲:
10。乔希·特南鲍姆
《技术摘要: 人类认知的一个标志就是在存在不确定性的情况下，与他人一起跨越新奇情境进行规划的灵活性。我们与各种复杂程度和知识的合作伙伴一起行动，对抗那些自身既不同又灵活的对手。虽然一个代理团队可能因为共同的目标而团结在一起，但是这个团队通常有多种方式来实际实现这些目标。
在缺乏集中规划或感知以及受限或昂贵的通信的情况下，代理团队必须针对代理之间的潜在差异有效地协调他们的计划。不同的代理可能具有不同的技能、能力或获取知识的途径。当环境和目标发生变化时，这种协调具有临时性的因素。
不协调会导致不安全的互动，并造成伤害和财产损失，因此人类和代理之间的特别团队合作必须不仅高效，而且稳健。我们将研究人类的特别和动态合作，并建立正式的计算模型，逆向工程这些能力。这些模型是构建能够像人一样协作并与人协作的机器的关键一步。"
主线程:
- 这项研究将调查人类的特别和动态合作，并建立正式的计算模型，逆向工程这些能力。这是制造能够协作的机器的关键一步。
约书亚·布雷特·特南鲍姆是麻省理工学院认知科学和计算教授。他因对数学心理学和贝叶斯认知科学的贡献而闻名。
他在 2018 年的视频中谈到了这一研究方向:
结论
从 2018 年开始，未来生命研究所项目中有很多有趣的研究人员。因此，我现在确实比以前有更多的东西需要探索。对于人工通用智能安全，似乎既有批判性的方法，也有好奇心。
这是#500daysofAI 的第 68 天。我目前第 50-100 天的重点是人工智能安全。如果你喜欢这个，请给我一个答复，因为我确实想提高我的写作或发现新的研究，公司和项目。
基于显著性的图像分割
一种寻找物体的自主方法
通常当我们看到一幅图像时，图像中会有一个焦点。这可能是一个人，一座建筑，甚至是一个桶。图像中有些清晰的部分没什么意思。这种区域通常以图像中缺少焦点、单调着色或平滑纹理为特征。当呈现这样一类图像时，可能希望从图像的其余部分中分割出感兴趣的对象。本文探讨了这种突出的图像分割。
Examples of salient images. The bucket (left) and person (right) are the objects of interest.
这个项目最初源于开发一种自动生成图像三分图的方法的兴趣。三分图是图像遮罩，当与抠图算法结合时，用于分割图像，同时注意前景和背景之间的细节。三分图通常包含定义前景的白色区域、定义背景的黑色区域以及代表不确定区域的灰色区域。
Example of Trimap from [2]
大多数抠图算法的问题是，它们期望三分图由用户提供，这是一项耗时的任务。我引用的两篇主要论文试图解决自主三分图生成【1】【2】。在第一篇论文中，Hsieh 等人使用了一种相当简单且易于实现的方法。不幸的是，他们的方法不是完全自主的，因为它要求用户为 Grabcut 算法提供一个矩形区域。相反，Gupta 等人使用显著性方法来预测感兴趣的区域是什么。然而，他们的显著性方法相当复杂，结合了三种不同的显著性算法的结果。其中一种算法利用了复杂的神经网络，这是一种我为了易于实现而想避免的技术。
除了需要人工协助之外，Hsieh 等人的算法产生了合理的结果。我想如果我能自动完成论文的 Grabcut 部分，他们算法的其余部分将解决最初的问题。我从古普塔等人提出的创造这种自主性的方法中获得了灵感。
方法
对于大多数形式的图像分割，目标是将图像二值化为感兴趣的区域。这个项目的目标没有什么不同。首先，我想大致确定感兴趣的对象在哪里。对图像应用高斯模糊滤波器。从模糊的图像中，产生平均 15 像素大小的超级像素。超级像素算法旨在根据像素区域中的颜色和距离值来分割图像。具体来说，使用了简单的线性迭代聚类(SLIC)算法。
Superpixel map of a bucket and a person
超像素将图像分割成大致相同的区域。这样做的一个优点是超像素允许区域的一般化。我们可以假设超像素中的大多数像素具有相似的属性。
在确定图像中超像素的同时，计算图像的显著图。使用了两种不同的显著性技术。第一种方法使用内置的 OpenCV 方法，称为细粒度显著性。第二种方法包括取精细颗粒显著性图像的平均值，并将其从图像的高斯模糊版本中减去，随后是新图像的绝对值。
这两种方法在结果的激进程度上有所不同。下图都突出显示了感兴趣的区域。由细颗粒显著性产生的图像要柔和得多。此外，细粒度显著性图像主要勾勒出显著图像的边界，而替代方法也捕捉显著图像的内部。与细粒度方法相比，主动方法确实会拾取更多噪声。噪声去除是该过程的下一步。
Salience images for the bucket and person using fine grain approach.
Salience images for the bucket and person using aggressive saliency.
下面的技术是从 Gupta 等人的论文中挖掘出来的。为了将图像二值化，迭代从彩色图像生成的每个超像素。如果显著性图像内的超像素区域的中值像素值大于阈值T1，则整个超像素被二值化为白色。否则，整个超像素保持黑色。T1，由用户选择。在[2]中，T1被设置为显著性图像中最大像素值的 30%，然而，在该项目中使用了 25%的值。
在图像的二值化之后，基于所使用的显著性技术对图像进行膨胀。在细粒度显著性方法中，图像被放大了平均超像素大小的两倍。积极凸极法没有扩大。图像中的噪声越大，任何扩张都有风险。
Bucket after dilated with fine grain saliency (left) and binarized aggressive saliency (right)
最后一步还是取决于使用哪种显著性方法。在这两种情况下，白色像素的最大区域被提取。在 OpenCV 中，这样的操作是通过在图像中找到轮廓并选择具有最大面积的轮廓来执行的。边界框适合所选区域。
据观察，细粒度显著性方法经常导致碎片化的区域。生成边界框后，落入该框中不属于最大区域的任何其他白色区域都被添加到该框中。盒子的边界增加到包括这些区域。积极的显著性方法不需要这样做。经常地，最大的地区捕获了比期望更多的东西。
最后一步是将最终找到的边界框提供给 Grabcut 算法。 Grabcut 是一种常用的图像分割方法。赋予 Grabcut 函数的边界框将算法认为明确的背景和前景分开。在大多数包含 Grabcutting 应用程序的软件包中，用户可以编辑矩形区域，并可以为算法提供更多信息，以获得更清晰的结果。在这个项目中，使用了 OpenCV 的内置 Grabcut 函数。
In the case of the bucket, both approaches produced the same solution.
此过程在[1]开始的地方结束。在未来，我计划继续开发这个自动旅行地图生成器。
结果
在这两者中，积极的显著图似乎为大多数图像产生了精确的遮罩。精细颗粒方法难以处理突出物体不“庞大”的图像。如果图像很长或有卷须，这些片段与图像的其余部分断开是很常见的。然而，由于其保守性，当图像特别嘈杂时，细粒度方法更好。蒙版不一定能捕捉到完整的图像，但它不会像侵略性方法那样频繁溢出。
Sample results of the two methods
还需要指出的是，对于[1]中开发的算法，不发达的掩模并不坏。因为最终目标是开发一个三分图图像，所以遮罩将由一个灰色区域填充。这个灰色区域将有助于区分前景和背景。
对于任何周刊读者来说，学习 C++中的 OpenCV 并实现这个算法都是惊人的耗时。抱歉的延误，但期待这个项目在未来的延续以及更多的内容！
Github 代码:
用于分割显著的彩色图像并确定抓取的代码。- TimChinenov/GraspPicture
github.com](https://github.com/TimChinenov/GraspPicture)
参考
[1] C. Hsieh 和 M. Lee，“数字图像抠图的自动三分图生成”， 2013 年亚太信号与信息处理协会年度峰会和会议，高雄，2013 年，第 1–5 页。
[2]古普塔，维卡斯&拉曼，尚穆加纳坦。(2017).用于图像抠图的三分图自动生成。
样本手形生物特征识别系统
生物识别建模过程的一个简单示例
这篇文章改编自我完成的一项任务——我认为这个项目很好地展示了数据建模的基本过程，并且有一个直观的应用程序，使人们更容易理解。这个例子强调了数据分析的 6 个一般步骤，并讨论了它将涉及哪种元素。
1.0 实验目标
本报告解释了一种使用监督学习实现“基于手形的实体识别”系统的方法。提供带标签的训练数据，测试数据必须由设计的系统进行分类和标记。分类系统将通过准确性来衡量。
准确度定义为所有评估中正确评估的百分比。
Accuracy = (TN + TP)/ (TN + TP + FN + FP)
2.0 数据准备
我们得到了训练和测试数据——每个数据由 23 个 2D 点的 100 个样本组成，描绘了手的几何形状**(图 2.0)** 。训练数据被标记(我们知道这是谁的手)，而测试数据是我们必须识别的(这是谁的手？).
Figure 2.0: Hand Geometry Data Points
训练和测试数据被加载到数据帧中，23 个 2D 点中的每一个都相应地标注在适当的栏中。为了以后的计算和分类目的，所有分类标签都被转换成整数代码。所有原始数据点都被确认为非空的和数字的。
下面的图 2.1 显示了训练和测试数据的六进制图，以查看数据点的高级概述。他们展示了一个手印的轮廓。
Figure 2.1: Hex-bin plots of training (left) and test (right) datasets
3.0 特征工程
为数据集中的每个轮廓生成了以下要素:
- 欧几里得和曼哈顿任意两点之间的距离
- 任意 3 个点的三角形周长和面积
图 3.1 描绘了这些几何特征，它们似乎是理解手部轮廓和位置的直观方法。
Figure 3.1: Geometric Feature Extraction
在去除原始原始数据点之后，这导致了4049总特征。进行相关性分析以去除高度相关的特征(因为它们不具有辨别能力)。这导致剩下总共460个特征，用于后续步骤。
4.0 分类
该实验的分类需要特征缩放、特征缩减或选择，以及训练分类器。
4.1 特征缩放
由于我们准备了特征来区分不同标签的手形轮廓，因此特征缩放将我们的特征转换为相对于任何给定特征的其余值的相对度量。特征缩放还经常用于将特征空间转换为固定范围的值，以减少标准偏差，从而减少异常值的影响。在本实验中，比较了两种流行的缩放方法:最小-最大缩放和标准缩放。
最小-最大缩放将特征缩放到[0,1]之间的固定范围内，而标准缩放通过移除平均值和缩放来转换特征空间，使得每个特征分布具有单位方差。
4.2 特征简化或选择
特征缩减或选择将特征空间缩减为一个极小的高鉴别特征集。这有助于训练分类器，从而更好地进行归纳以及提高计算效率。当训练集只有很少的样本(只有 100 个)时，使用 as 的所有特征会导致过度拟合，从而无法准确预测测试集中的样本。该实验比较 PCA(称为PCA)来减少特征，以及 ANOVA F 值分数(称为*SelectKBest*)来选择顶部的N特征。尝试了各种N值，以找到最高精度的值。
4.3 训练分类器
使用缩放和简化的特征，执行监督学习任务以使用提供的分类标签训练分类器。四个分类器— LinearSVC、SVC、a Gaussian Process Classifier和 a Random Forest Classifier —与它们各自的超参数一起进行了超参数调整实验。进行超参数调整是为了根据经验确定分类器的哪个设置会产生最佳结果。这些参数很难从理论上推导出来，因为它们的效果严重依赖于训练数据的种类和形式。
4.4 交叉验证
对特征缩放、特征缩减/选择(具有不同的N值)和分类(具有不同的超参数值)的所有组合进行了模拟，总共产生了 500 次模拟。
分层的五重交叉验证方法——因此每类中的一个标签被留出作为验证数据——被用于评估每个模拟的准确性。这导致一起选择特征减少/选择和分类器的最佳组合，其导致跨交叉验证集的最佳准确度。执行交叉验证是为了有效地判断模型的准确性——训练和验证样本的简单分割可能会让模型变得幸运。将每个类的 5 个样本中的每一个作为验证样本放入我们的训练集中，保证了模型的准确性将由所有的拆分组合来判断。
5.0 培训和验证结果
模拟的最终精度分布如图 5.1 中的所示。可以看出，大多数模拟导致了[0.8,0.98]之间的精确度。
Figure 5.1: Accuracy Probability Density Distribution across 500 simulations
图 5.2 比较了各种预处理(特征缩放+特征缩减/选择)方案的精度，发现方差分析 F 值评分(SelectKBest)特征选择方法通常会在系统中产生更好的精度。这在某种程度上是意料之中的，因为 ANOVA F 值方法通过根据类别标签执行统计测试来直接确定特征区分，而 PCA 是一种“无监督”的特征约简方法，并不直接处理分类的特征区分。这也可能是为什么缩放方法的选择似乎显著影响 PCA 而不是 ANOVA F 值分数的原因。
Figure 5.2: Comparing Accuracy distributions for various Pre-processing schemes
图 5.3 比较了各种分类器的准确度。SVC和Gaussian Process Classifier的表现普遍优于其他品牌，SVC的得分更为稳定。
Figure 5.3: Comparing Accuracy distributions for various Classifiers
图 5.4 给出了更详细的视图，显示了不同预处理方案、分类器以及特征减少/选择组件数量的精度分布(跨超参数值)。图 5.5 中的表格显示了超参数调整后，通过不同配置获得的最大精度。
与线性 SVC 相比，SVC 的优异表现表明非线性决策边界更好地区分不同的类别。高斯过程分类器在正确的条件下也表现得和 SVC 一样好，并且在其模拟中具有 0 的标准偏差。这显示了 SVC 相对于高斯过程分类器的灵敏度——正则化超参数C必须被调整以获得最佳结果，而高斯过程分类器隐式地学习正则化参数本身，而不管你从哪个随机状态开始。这表明高斯过程分类器一般更稳定。高斯过程分类器在寻找类之间的最佳决策边界时也隐式地学习核，而 SVC 核必须预先定义(在这个实验中它被设置为rbf)。然而，SVC 对于训练来说要快得多，并且当 hyper 参数调整正确时可以做得稍微好一点。
Figure 5.4: Box Charts of Accuracies for each classifier, preprocessing scheme, and # of reduced components
Figure 5.5: Final Results (max Accuracy obtained by configuration with best hyper-parameters)
6.0 结论和分析
从上述数据中，系统的最佳配置(导致平均交叉验证准确度为98%)选择如下:
- **特征定标器:**标准定标器
- 特征选择: ANOVA F-value 得分，用于选择顶部的
15特征 - **分类器:**带正则化超参数的 SVC
C=10.0
6.1 最显著的特征
功能选择方法选择了以下 15 大功能:
{P1}_e_{P2} = Euclidean Distance between P1 and P2
TA_{P1}_{P2}_{P3} = Area of Triangle made with P1, P2, and P*where Point #s correspond to the positions in Figure 3.1.
Top 15 Features:['01_e_19',
'01_e_20',
'04_e_06',
'06_e_08',
'08_e_10',
'12_e_14',
'14_e_16',
'16_e_19',
'TA_01_08_09',
'TA_01_12_13',
'TA_01_16_17',
'TA_01_21_22',
'TA_04_06_10',
'TA_08_10_14',
'TA_08_19_21']
图 6.1 显示了手部轮廓样本图像上最具鉴别性的特征。红色实线形成三角形，黑色实线表示欧几里得距离。似乎自动特征选择已经找到了我们可能凭直觉猜测为最具辨别能力的特征——主要是三角形和从指尖到手的边缘或手指开始的长度，这将在很大程度上定义手的大小和范围。
Figure 6.1: Discriminative Features (Black= Euclidean Distance, Red=Triangles)
图 6.2 显示了所选区别特征之间的相关性——表明它们相关性不高，并且各自提供了有价值(或至少不同)的信息。
Figure 6.2: Correlation Heat map between Top Discriminative Features
6.4 推理
然后，所选择的分类器以及预处理方法被用于在测试数据集上进行预测。虽然由于我们有未标记的样本，很难看到测试数据集的结果，但我们可以通过将特征空间缩减到 2D(使用 PCA 或 TSNE)并绘制出结果来了解预测的质量。(这丢失了信息，但只是粗略地了解我们结果的聚类结构)。在**图 6.3 中，**方块是测试分类——视觉表明分类器确实在将测试样本分类到一个标签中，该标签的训练样本表现出与测试特征向量相似的特征集。图中出现的聚集行为是一个很好的迹象，表明我们的特征具有足够的区分能力，可以将相同标签的样本分组在一起。
Figure 6.3: 2D Reduced Mapping for Visualization of Results (Squares are test classifications)
总之，分类系统成功地选择了有价值的区别特征，导致正的 98%确认分数，并预测测试样本标签，使得它们在缩减的特征空间中接近相应的训练样本。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
