TowardsDataScience 博客中文翻译 2021（六百八十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

训练你自己的象棋人工智能

原文：https://towardsdatascience.com/train-your-own-chess-ai-66b9ca8d71e4?source=collection_archive---------0-----------------------

看着你的作品打败你

迈克尔在 Unsplash 上的照片

介绍

TLDR: Colab 链接

深度学习已经接管了计算机象棋世界。2017 年 AlphaZero ，AlphaGo 针对国际象棋的迭代，通过轻松击败 Stockfish 迷住了国际象棋迷。该领域的新发展，如 Leela Zero (一个开源的 AlphaZero 实现，碰巧使用了 my chess lib )和 Stockfish NNUE (可高效更新的反向神经网络)表明，在可预见的未来，神经网络将继续主导国际象棋。

作为一名国际象棋爱好者和人工智能实践者，我开始创造自己的国际象棋人工智能，但一个令人生畏的传言让我气馁: AlphaZero 花费 3500 万美元训练。AlphaZero 完全通过强化学习和自我游戏进行训练，以避免外部依赖。虽然明显有效，但从成本角度来看，自我游戏的效率低得令人难以置信。今天的引擎已经可以区分好位置和坏位置。这种先验知识可以用来引导学习过程，并使以非常有限的成本(或在 Colab 上免费)训练象棋 AI 成为可能。让我们试试吧！并使用来自现有引擎的数据集使用监督机器学习来训练神经网络。

定义模型

模型图，图片由作者提供

引擎如何决定一个位置好不好？给定一个位置，引擎返回从白色角度看这个位置有多好的分数。这个分数被称为评估，通常简称为 eval，eval 函数是国际象棋引擎的核心。eval 是一个以卒当量为单位的真实实力衡量标准。例如，如果白棋是一个棋子，评估将是+1。如果黑棋是骑士，评估将是-3。原材料不是决定评估的唯一因素，位置信息和未来的移动也会被考虑在内。

传统上，eval 功能是通过手工算法实现的，这些算法定量测量材料不平衡、工件移动性和国王安全等概念。这些直接测量，结合迭代加深单独产生超人的结果。神经网络可以取代这些手工算法，并直接返回评估结果，无需专门编码。总的来说，eval 函数接受一个位置并返回一个评估分数。我们如何把它变成一个模型？

输出 eval 可以由单个基于浮点的神经元来表示。代表棋盘位置的输入可以使用每种棋子类型的位棋盘 (64 位，棋盘上的每个方格一个)进行编码，剩余的几个位用于移动索引、要移动的颜色和路过的方格。这些输入数据一起形成了一个 808 位(1 和 0)的字符串，可以转换成浮点数并直接输入到模型中。

现在我们已经计划好了输入、输出和一般模型概念，让我们开始构建数据集。

建立数据集

我在Lichess.com上玩，因为它是免费的，开源的，由开发者运营。Lichess 拥有网站上所有游戏的每月下载片段。2021 年 7 月包含 9200 多万场比赛。在注释部分，它提到了一个非常重要的细节:“大约 6%的游戏包括 Stockfish 分析评估”，在这种情况下，这将是 550 多万个游戏。一般的国际象棋游戏持续大约 40 步，80 个位置(每一方每“步”得到一个回合)，七月应该包含 441，600，000 个非唯一位置。这似乎足以创建我们的初始数据集。

Lichess 的每月碎片编码为. pgn.bz2 文件。文件扩展名. bz2 是一种压缩形式。pgn 是“可移植游戏符号”，这是一种基于文本的格式，用于将国际象棋游戏编码为代数符号中的一系列移动。以下是单个 PGN 文件记录的文本:

[Event "Rated Bullet tournament https://lichess.org/tournament/yc1WW2Ox"]
[Site "https://lichess.org/PpwPOZMq"]
[Date "2017.04.01"]
[Round "-"]
[White "Abbot"]
[Black "Costello"]
[Result "0-1"]
[UTCDate "2017.04.01"]
[UTCTime "11:32:01"]
[WhiteElo "2100"]
[BlackElo "2000"]
[WhiteRatingDiff "-4"]
[BlackRatingDiff "+1"]
[WhiteTitle "FM"]
[ECO "B30"]
[Opening "Sicilian Defense: Old Sicilian"]
[TimeControl "300+0"]
[Termination "Time forfeit"]

1\. e4 { [%eval 0.17] [%clk 0:00:30] } c5 { [%eval 0.19] [%clk 0:00:30] }
2\. Nf3 { [%eval 0.25] [%clk 0:00:29] } 2... Nc6 { [%eval 0.33] [%clk 0:00:30] }
3\. Bc4 { [%eval -0.13] [%clk 0:00:28] } 3... e6 { [%eval -0.04] [%clk 0:00:30] }
4\. c3 { [%eval -0.4] [%clk 0:00:27] } 4... b5? { [%eval 1.18] [%clk 0:00:30] }
5\. Bb3?! { [%eval 0.21] [%clk 0:00:26] } 5... c4 { [%eval 0.32] [%clk 0:00:29] }
6\. Bc2 { [%eval 0.2] [%clk 0:00:25] } 6... a5 { [%eval 0.6] [%clk 0:00:29] }
7\. d4 { [%eval 0.29] [%clk 0:00:23] } 7... cxd3 { [%eval 0.6] [%clk 0:00:27] }
8\. Qxd3 { [%eval 0.12] [%clk 0:00:22] } 8... Nf6 { [%eval 0.52] [%clk 0:00:26] }
9\. e5 { [%eval 0.39] [%clk 0:00:21] } 9... Nd5 { [%eval 0.45] [%clk 0:00:25] }
10\. Bg5?! { [%eval -0.44] [%clk 0:00:18] } 10... Qc7 { [%eval -0.12] [%clk 0:00:23] }
11\. Nbd2?? { [%eval -3.15] [%clk 0:00:14] } 11... h6 { [%eval -2.99] [%clk 0:00:23] }
12\. Bh4 { [%eval -3.0] [%clk 0:00:11] } 12... Ba6? { [%eval -0.12] [%clk 0:00:23] }
13\. b3?? { [%eval -4.14] [%clk 0:00:02] } 13... Nf4? { [%eval -2.73] [%clk 0:00:21] } 0-1

每次移动后，在注释部分，基于 Stockfish 的评估以定制的文本格式编写。

1\. e4 { [%eval 0.24] [%clk 0:05:00] }

这给了我们与位置配对的 eval(从一系列移动中计算)。2021 年 7 月的原始压缩月度碎片为 25.2 GB，因此单个 CSV 文件很可能是不可能的。带有适当索引的 SQLite 数据库似乎更合适。该架构包括 FEN(用于调试的位置的文本编码)、供模型直接使用的二进制以及对定型输出的评估:

> select * from evaluations limit 7;id|fen|binary|eval
1|rnbqkbnr/pppppppp/8/8/3P4/8/PPP1PPPP/RNBQKBNR b KQkq d3 0 1|0.0
2|rnbqkbnr/ppp1pppp/8/3p4/3P4/8/PPP1PPPP/RNBQKBNR w KQkq d6 0 2|0.27
3|rnbqkbnr/ppp1pppp/8/3p4/2PP4/8/PP2PPPP/RNBQKBNR b KQkq c3 0 2|0.0
4|rnbqkbnr/ppp2ppp/4p3/3p4/2PP4/8/PP2PPPP/RNBQKBNR w KQkq - 0 3|0.09
5|rnbqkbnr/ppp2ppp/4p3/3P4/3P4/8/PP2PPPP/RNBQKBNR b KQkq - 0 3|0.1
6|rnbqkbnr/ppp2ppp/8/3p4/3P4/8/PP2PPPP/RNBQKBNR w KQkq - 0 4|0.0
7|rnbqkbnr/ppp2ppp/8/3p4/3P4/2N5/PP2PPPP/R1BQKBNR b KQkq - 1 4|0.09

现在我们有了数据，让我们开始训练吧！

培养

对于这个项目，让我们使用 Pytorch Lightning ，它是 Pytorch 上面的一个便利层。为了训练，我们必须首先实现两个类:Dataset 和 LightningModule。由于数据集的规模很大(数据库最终有 37 毫米的位置)，IterableDataset 最有意义，它将数据视为无限流。next 方法只需要返回随机的一行数据。因为我们不担心在数千万个位置上过度拟合，所以我们不需要将数据分成训练集、验证集和测试集。

Pytorch 数据集的实现，使用 https://carbon.now.sh 创建

EvaluationDataset 从 SQLite 表中随机提取一行，并通过提取原始字节中的二进制值对其进行预处理，使用 numpy 的 frombuffer 和 unpackbits 函数将这些字节转换为浮点型，并形成所需的 808 长度的浮点型数组作为输入。评估值 is 被提取并限制在-15 和 15 之间。边界保护防止极端赢的位置支配损失函数(例如+45 白)。±15 是非常肯定的胜利，每一方，并评估过去，这是不必要的，我们的目的，将减缓训练收敛。

Pytorch 模型的实现，用 https://carbon.now.sh 创建

该模型由 808 个神经元的 N 层(初始设置为 4)组成，直到直接输出评估的 1 个神经元的最终输出层。使用 L1 损失，或标签和预测之间的绝对平均差异，因为输出是直观的。例如，如果 L1 损失是 2.0，那么平均而言，该模型与 stockfish 的评估相差 2 个卒。

Tensorboard 的训练损失，图片由作者提供

成功了，失败了！最终我们的模型的两个版本被训练。四层的一个达到 1.29 的损耗，六层的一个达到 1.06 的损耗。

测试

JESHOOTS.COM 在 Unsplash 上的照片

测试我们 AI 最好的方法就是玩！使用阿尔法贝塔搜索，换位表，和一些其他标准的国际象棋人工智能技术，我们可以创建一个完整的国际象棋引擎来对抗。AI 客户端在 Go ( 中实现，所以我可以使用我的象棋库)，模型托管在一个基于 python 的 gRPC 服务器上，该服务器为我家里的 Nvidia 2080 加速 linux 服务器上的模型提供服务。

基于围棋的象棋引擎少于 300 LOC，这里是主要走法的代码。

Go 客户端的实现

这是服务于该模型的 pthon gRPC 服务器实现。它接受成批的编码位置并返回评估结果。

Python 服务器的实现

现在，我们已经连接了我们的机器人和我们的模型服务板评估，我们已经准备好玩了！这个机器人的对手(我自己)在快速、闪电战和子弹上只有可怜的 1200 左右的平均等级。这些游戏没有时间限制。我花了我需要的时间，a I 每一步花了大约 20 秒。在我与机器人的两场比赛中，我仁慈地给了自己白。

不幸的是，Medium 不允许嵌入，所以我在 Lichess 上放了一张整个游戏的 Gif 和一个完整游戏的链接，还有一个 Stockfish 分析。

第一场:洛根·斯皮尔斯(白)对切斯·博特·DNN-4 层-损失-1.29(黑)

洛根斯皮尔斯(白)诉国际象棋机器人 DNN-4 层-损失-1.29(黑)。画吧。完整游戏:https://lichess.org/rh7jL6rL

https://lichess.org/rh7jL6rL

我玩 E4(我总是玩 E4)，人工智能选择了被称为“西西里防御”的 C5。黑棋的第一步很吸引人，因为人工智能没有打开的书，也没有玩游戏的经验，却为黑棋选择了一个最受欢迎的防御。开局相当平衡，没有一方获得明显的优势，直到我用我的黑暗广场主教换了移动中的黑骑士。事后看来，这揭开了布莱克的黑暗广场主教，暴露了 B2 广场上的弱点。然后我在移动 13 时与另一个骑士交易的主教复合了这个错误，他掉了一个兵，让黑方女王的攻击线通过。我蹲下身子，尽我最大的努力防守，通过移动 25 让比赛接近平手。由于忽略了拿走我的兵，黑棋低估了 E8 的潜在升级，并在移动 26 时犯了个错误，让骑士去 B3，他认为如果骑士拿走了我可以强迫车交易，主教不能保护 A 的兵不被升级。不幸的是，我也没有看到这一点，我让我暂时的优势溜走了。游戏以一系列平淡无奇的举动结束，我同意和棋(斯托克菲什同意双方势均力敌)。

第二场:洛根·斯皮尔斯(白)对切斯·博特·DNN-6 层-损失-1.06(黑)

洛根斯皮尔斯(白)诉国际象棋机器人 DNN-6 层-损失-1.06(黑)。黑棋赢了。完整游戏:https://lichess.org/rh7jL6rL

https://lichess.org/K5OEAa3w

以法国开局，黑棋允许我通过移动 8 占据中心位置，导致白棋的 stockfish 评估为+1.1。有趣的是 Stockfish 想让我站在城堡女王一边，把我的优势推到中间。我有一个王侧易位的习惯，以更安全的方式玩，以避免不熟悉的游戏。在移动中 11 ，黑棋提供了一个女王交易，我接受了这个交易，把女王从棋盘上拿走，减少了可能有利于人工智能的战术机会。我做得很好，直到我在移动 16 时出错。我看不出黑棋可以用它的方形象串我的车并赢得交换。由于移动中的兵推 32 没有导致获胜的机会(即使平衡了车)，黑棋逐渐吃掉我的兵，迫使我放弃。

虽然人工智能赢了，但我不知道是计算机变得更好了，还是我的失误让比较变得不公平。解决这个问题的最公平的方法是让人工智能版本互相比赛。

第三场:切斯博特 DNN-6 层-损失-1.06(白)对切斯博特 DNN-4 层-损失-1.29(黑)

象棋机器人 DNN-6 层-损失-1.06(白)对象棋机器人 DNN-4 层-损失-1.29(黑)。白棋赢了。完整游戏:https://lichess.org/es0pajXC

https://lichess.org/es0pajXC

最初我给了 4 层人工智能白色，但它以一个平淡无奇的画结束，所以我尊重颜色的分配。第二场比赛导致了一场令人难以置信的精彩比赛。快节奏的行动开始于第 12 步,主教拿走了 G7 的兵，并分别叉走了 H6 和 H8 的骑士和车。黑棋回应了一个狂野的牺牲，使用了黑方主教，然后是女王检定。白棋冷静地偏转，最终拿到了悬车。在移动中 16 黑棋牺牲了另一个棋子，这次是一个骑士，为了保住对白棋国王的攻击。在防守并掷出自己的皇后检查牌后，白棋自信地检查了黑王的移动 22 。这是非常危险的，因为如果给黑棋自由移动的话，它可以一步就将死！怀特发现了原力交配序列，在一场令人兴奋的将死中获胜，并证明了其较低的训练损失会导致更好的象棋。

分析

分析这些游戏最显著的方面是人工智能感觉有多“像人”。常见的开局，等待失误，以及用疯狂的牺牲来试图卷土重来是在线人类游戏中的标准公平。

我们的方法当然有改进的余地。许多众所周知的技术没有被使用，以保持这个项目的复杂性易于管理，并专注于人工智能部分:

• 移动排序优先搜索“感兴趣的”移动序列
• Endgame Tablebase 用于预先计算的获胜残局位置
• 预计算开口的开口书
• 只搜索 4 层的几十万个位置
• 许多其他人

我们过于简单的模型和训练程序也存在一些缺陷

• 移动计数以位的形式输入到模型中，而不是以浮点数的形式输入
• 模型架构是第一个没有优化的设计
• 学习率和批量大小调度器可以导致较低的总损失
• 象棋位置在数据库中是唯一的，因此更可能是唯一的较后位置在数据集中被过度表示
• 大多数游戏都是业余玩家玩的，高级游戏的搜索空间可能没有得到充分的体现
• 该模型可以被训练更长时间

总的来说，这很有趣！对现有发动机评估的监督训练是一种比自玩和蒙特卡罗树搜索(a la AlphaZero)更快和更经济的权重初始化方法，并且一个可玩的模型可以在几个 GPU 小时内生成。希望你喜欢这篇文章，我期待在评论中看到你的 AI 游戏的链接！

使用 AWS SageMaker 训练您自己的声音生成可变自动编码器

原文：https://towardsdatascience.com/train-your-own-variational-auto-encoder-for-sound-generation-with-aws-sagemaker-1ecb82918695?source=collection_archive---------34-----------------------

在脚本模式下使用 AWS SageMaker 训练您的定制 TensorFlow 模型的简单方法。

经过 10 个小时的训练，我进入了 150 个纪元中的第 22 个，我意识到 3000 wav 文件数据集对于我 5 岁的 MacBook Pro 来说有点难以接受。自由口述数字数据集包含来自 6 个说话者的录音，每个说话者 50 个 8kHz 的数字。wav 格式。当我在跟踪 Valerio Velardo 的关于神经网络 声音生成的优秀视频系列时，我发现自己陷入了一个无休止的训练阶段。目标是训练一个定制的可变自动编码器来生成声音数字。

Pawel Czerwinski 在 Unsplash 上拍摄的照片

FSDD wav 文件的预处理在本地进行，并在中生成 3000 个光谱图的训练数据集。npy 格式(我的 TensorFlow 模型的预期输入格式)。虽然 SageMaker 现在支持各种数据源，如亚马逊 FSx 和亚马逊 EFS ，但我将训练数据集上传到了位于美国东一区(N. Virginia)的 S3 的一个桶中。请注意这一点，因为 SageMaker 需要与您的铲斗在同一区域。

我的源代码由两个文件组成:

• autoencoder.py —自动编码器“ VAE ”类定义:具有镜像编码器/解码器和潜在空间的深度卷积自动编码器。包含所有 TensorFlow 库导入。
• train.py —训练初始化:访问训练数据，实例化模型，定义所有参数(输入形状、滤波器、核、步幅、潜在空间维度和各种超参数)。包含从 autoencoder.py 导入的 VAE 类

这两个文件在本地培训时在我的本地硬盘上协同工作，但是如何转移到云中呢？

与 SageMaker 一起训练

SageMaker 主要提供了 5 种训练模型的方法:

• 内置算法
• 脚本模式
• 码头集装箱
• 市场
• 笔记本实例

在我们的特殊情况下，脚本模式是可行的，因为我们提供了在 TensorFlow 兼容的容器(由 AWS 管理)中执行的源代码。

选择一个基本的 SageMaker 笔记本配置(一个 ml.t2.medium 就可以了)，确保附加的 IAM-execution-role 允许访问您的 S3 bucket，并从管理控制台启动实例(与 bucket 在同一区域)。在脚本模式下，注意这个 SageMaker 笔记本实例只用于脚本启动，不用于培训。

我将我的源代码上传到 SageMaker 笔记本实例存储的工作目录中，在那里我还创建了自己的 script.ipynb 来编排培训过程。在这个脚本中，我包含了以下导入:

import sagemaker
from sagemaker.tensorflow import TensorFlow
import boto3

然后，我将所有有用的 SageMaker 变量定义如下:

bucket = 'mytrainingdatabucket'
role = sagemaker.get_execution_role()numpy_train_s3_prefix = f"**{**bucket**}**/spectrograms"
numpy_train_s3_uri = f"s3://**{**numpy_train_s3_prefix**}**"inputs = {'data' : numpy_train_s3_uri}

最重要的是，估算器处理所有端到端的 SageMaker 训练任务。以下是需要特别注意的参数:

• 入口点:你的训练代码的路径(在我的例子中是 train.py )
• source_dir :剩余源代码的路径(依赖、库等)。
• model_dir :指定你的代码将你的算法生成的模型写入容器的预期位置，通常为’ opt/ml/model ‘。在训练结束时，SageMaker 获取它在’ opt/ml/model '中找到的任何东西，并将其输出给 S3。
• 去找一个强大的，因为它只会用于训练。
• output_path :保存模型工件和输出文件的 S3 路径。
• script_mode : boolean，在这种情况下选择 True 。

下面是我如何为 AWS 管理的 TensorFlow 兼容容器初始化我的 estimator 实例:

estimator = TensorFlow(entry_point='train.py',
                       source_dir='.',
                       model_dir = "/opt/ml/model",
                       train_instance_type='ml.p2.xlarge',
                       output_path=f"s3://**{**bucket**}**/output",
                       train_instance_count=1,
                       role=sagemaker.get_execution_role(), 
                       framework_version='2.0',
                       py_version='py3',
                       script_mode=**True**)

然后，将通过调用估计器上的 fit() 来启动训练，如下所示，但在此之前，我们需要定义下一段中描述的所有环境变量。

estimator.fit(inputs)

环境变量

我在我的 train.py 文件中实现了 parse_args() 函数来收集所有必要的 SageMaker 环境变量，比如路径和超参数:

def parse_args(): parser = argparse.ArgumentParser() parser.add_argument('--epochs', type=int, default=150)
 parser.add_argument('--batch_size', type=int, default=64)
 parser.add_argument('--learning_rate', type=float, default=0.0005)       # data directories    
 parser.add_argument('--data', type=str,
 default=os.environ.get('SM_CHANNEL_DATA'))     parser.add_argument('--output', type=str,
 default=os.environ.get('SM_CHANNEL_OUTPUT'))     parser.add_argument('--train', type=str,
 default=os.environ.get('SM_CHANNEL_TRAIN'))        parser.add_argument('--model_dir', type=str,
 default=os.environ.get('SM_MODEL_DIR')) return parser.parse_known_args()

因此，我可以加载训练数据:

x_train = get_train_data(args.data)

然后我可以实例化 VAE 类，并相应地调用训练方法:

autoencoder = train(x_train, args.learning_rate, args.batch_size, args.epochs)

最后，一旦模型训练完毕，我就可以从 VAE 类中调用 save() 方法来将我的模型工件( parameters.pkl 和 weights.h5 )存储在’ opt/ml/model '中。这一步是必不可少的，因为 SageMaker 不会自动保存你的模型，而是简单地获取容器文件夹中的内容。因此，请明确执行此操作:

autoencoder.save(args.model_dir)

就是这样！下面是我的 script.ipynb 的执行快照:

结论

如上所述，培训工作需要大约 2 个小时才能完成，费用大约为。根据我在自由层帐户上的 AWS 计费仪表板，3.20 美元(计算+存储)。

新生成的模型存储在我的“输出/ 文件夹的 S3 桶中，并以 8.4 MBmodel.tar.gz档案的形式出现。下载并解压后，我能够使用 VAE 类的 load() 方法，并成功地做出推理来生成声音。以下是我的模型生成的“零”声音数字的示例:

查看我的 GitHub 资源库这个项目，感谢阅读！

使用随机矩阵的可训练宏观交通建模

原文：https://towardsdatascience.com/trainable-macroscopic-traffic-modeling-using-stochastic-matrices-e5fc4dedf259?source=collection_archive---------24-----------------------

通过用真实世界的数据训练交通模型来获得真实的交通模拟。

图片由大卫·马克从皮克斯拜拍摄

在这篇文章中，我将讨论我如何定义一个交通网络，一个交通模型，以及我如何用我收集的流量数据来训练它。

交通网络可以表示为有向图，道路上的车辆负载可以表示为图边上的负载数值。微观交通模型阐述了单个车辆之间的相互作用，而宏观交通模型则考虑了交通流量。通过定义一个交通模型，将在图上形成一个动态系统，并且可以模拟交通行为。

收集和预处理好的真实世界交通流数据可用于训练交通模型。然后，可以使用该模型来研究交通网络的拓扑薄弱部分，以修改网络来改善较低的拥塞水平。

交通网络

让我们给出我们需要的初步定义。

特殊类型的矩阵可以用来保存图的属性信息。

图形是保存节点间关系信息的对象。图的线图直观地展示了图的边的关系。由于交通网络的动力学，如交通流，考虑了道路之间的关系，我们需要考虑交通网络的线图。

交通网络可以被认为是有向图 G，其中每个节点 r 是一条边，每个交叉点 j 可以被认为是一个节点。

为了获得真实的结果，我们需要关于道路类型和道路长度的信息。然后，我们可以根据这些值为每个图定义一个容量常数。设 H_r 为道路类型， l_r 为道路 r 的道路长度，定义一个函数 λ(H_r) 为道路类型 H_r. 的车道数然后定义 r 的通行能力为 C_r = λ(H_r)l_r 。

容量是一条道路所能承受的最大交通负荷。设每条道路持有一个荷载值 L_r(t)∈[0，C _ r】。此外，道路的拥挤程度被定义为 L_r(t)Cr。

使用 Python 的 osmnx 包，我们能够将真实世界的交通网络导入到网络 x 图中。该软件包从开放街道地图中收集真实的空间信息，并使用它生成一个网络。图书馆给了我们以下信息:名称、长度和道路类型。

对于这篇文章，我选择了伊斯坦布尔的交通网络 Kadikoy。

import osmnx as oxfrom networkx import *# Defining the map boundaries
#Kadikoy kordinatlarinorth, east, south, west = 40.9939, 29.0346, 40.9786, 29.0146# Downloading the map as a graph objectG = ox.graph_from_bbox(north, south, east, west, *network_type* = 'drive')draw(G, *linewidths*=1, *node_color*='w', *node_size*=15, *arrowsize*=5, *pos*=pos)ax = plt.gca() # to get the current axisax.collections[0].set_edgecolor("#000000")

现在，让我们创建这个网络的线图。

L = nx.line_graph(G)draw(L, *linewidths*=1, *node_color*='w', *node_size*=15, *arrowsize*=5, *pos*=pos2)ax = plt.gca() # to get the current axisax.collections[0].set_edgecolor("#000000")

通信模型

在前面的部分中，生成了一个交通网络。要模拟该网络中的流量，需要一个流量模型。我们需要定义一个模型，它可以获得每个节点持有的信息，并给我们结果。通常，流行的宏观模型，如 METANET，不考虑较小的市内道路，而只关注高速公路。

我们将要定义的模型将考虑网络中的每一条道路。这些模型是用随机过程和随机行走的思想来表述的。

设 P 是一个 n×n 概率转移矩阵，设 π(t) 是一个 n 维非负向量，它保存在时间 t 节点上的初始负载分布。那么下一个时间步的分布就是 *π(t+ 1) =(π(t)^T)P，*其中 x^T 定义 x 的转置。

我们有两个假设。第一个假设是，在每个时间步，每个交通灯是同步的，在每个路口，在每个时间步变绿一次。第二个假设是总负载不变。第二个假设是临时假设，稍后将引入基于时间的负载控制机制。

通常，最常见的随机游走是根据度数定义的。

设 G 为图，设 A 为邻接矩阵，设 D 为图的度矩阵。基于度的概率转移矩阵定义为 *P = D^(-1)A，*其中 P_(i，j)=A_(i，j)/deg(i)。

但是这个模型不考虑道路的通行能力，所以我们不能模拟交通的级联效应。

为了防止这种情况，并能够优化模型，稍后，公路关系矩阵 M 出现，其中 M(H_i，H_j)是从公路类型为 H _ I 的公路到公路类型为 H_j 的公路的流量常数。假设有一个从道路 r 到 p 的流量，如果λ(Hr)> λ(Hp)随着汽车的行驶，道路变得更窄，我们就面临一个瓶颈。瓶颈使汽车在不减速的情况下更难继续行驶，因为车道的数量减少了，汽车不得不变道，这导致了机动性的整体下降。随着道路类型的差异越来越大，流量变得越来越慢。所以，M(H _ r，H_p)应该很小。然而，如果λ(Hr)< λ(Hp)，那么流量不会减慢，因为车道实际上是在增加的，汽车不必为了变道而减速。道路 r 上的载荷计算如下

概率转移矩阵是:

优化模型

我们希望模型以现实的方式行动。在建模阶段，模型被赋予一个道路型流量常数。在本节中，我们将使用这些参数优化模型。从这里，一家使用他们的 API 提供交通流量数据的导航公司，以 20 分钟的间隔收集 1080 步的真实世界交通数据。收集的数据用于优化模型。对未处理的数据进行处理，使其成为保持 Eminonu 地区主要道路拥堵程度的时间序列数据。之所以选择 Eminonu，而不是 Kadikoy，是因为它是这里最大的地区，有许多不同的道路类型。

设 D_i(t)表示时间 t 时道路 I 的真实世界拥堵水平，设所选成本函数为 MSE。设 N 是数据实例的数量，K 是道路的数量。因为 L(t)是递归函数，随着 t→ ∞，求导会越来越难。此外，考虑到现实世界的数据取决于实时性，这意味着在一天中的某些时候，流量水平会更高或更低。为了训练模型，在每个时间步 t+1，取 L_i(t)为 D_i(t)，并对 L_i(t+ 1)进行优化，因此 L_i(t)被视为常数而不是函数，优化过程变得更容易。

假设时间序列数据为:

D(0)，D(1)，D(2)，D(3)，D(4)，D(5)，D(6)…

数据将被分组为(X，Y ),其中 X 是特征，Y 是预测值。将时间序列数据分组如下:

(D(0)，D(1))，(D(1)，D(2))，(D(2)，D(3))，…

我们试图找到 8×8 M 矩阵，它给出了在总模拟时间τ上求和的成本函数的最小值。所以每 64 个变量都应该进行优化。对于时间 t+ 1，我们希望优化以下成本函数:

在哪里，

对于每个 M_，其中 a，b ∈[1，8]，用梯度下降法进行优化。

现在，当我们求梯度时，我们需要计算每个时间步的最小值函数，并对最小值部分求导。因此我们有下面的梯度，

优化进行了 30 个时期。在每个时期，我们获取不同的矩阵 M。这 30 个不同的 M 矩阵用于预测下一个时间步中的流量负载值。

左图显示了前 10 代 M 矩阵的不同成本值，右图显示了后 10 代的成本值。对于这两个图，线形图是训练前的成本值，这些值是我直观给出的，所以理想的结果是成本值保持在线形图以下。可以观察到，在用 20 个数据对/数据实例训练模型 30 个时期之后，低于线图的成本值的数量增加了。

因此，我们可以看到，在预测下一次迭代中的负载分布时，经过训练的模型比未经训练的模型表现得更好。目前，正在以更短的时间间隔收集另一个真实世界的数据，以更高的精度训练模型。

训练 CNN 在没有任何人工注释图像的情况下检测停车标志

原文：https://towardsdatascience.com/training-a-cnn-to-detect-stop-signs-without-any-manually-annotated-images-715a91954006?source=collection_archive---------25-----------------------

实践教程

额外游戏:这篇文章中有一句话是故意错误的。你能找到它吗？

一个停车标志。图片由作者提供。

注释大型影像数据集是一项劳动密集型工作，因此成本高昂。在某些情况下，只有大公司才有资源来构建数据集，这将使他们的卷积神经网络(CNN)在给定的应用中具有优势。

解决这个问题的一个可能方法是图像合成。当 object 类如此简单，以至于我们可以以编程方式创建逼真的示例时，我们可以生成带有相应目标热图的图像。这些对将用作完全卷积神经网络(FCNN)的训练观测值，该网络将图像作为输入，并预测相应的热图。

当你看到一个红色的八角形时，必须停下来

作为一个简单的例子，我们将为停止标志的单色图像创建一个生成器，这是自动驾驶汽车必须处理的许多信号之一。忽略颜色信息会给训练带来额外的困难，但是如果我们成功了，得到的 FCNN 就不太可能被例如圆形的红斑所混淆。

你可以在这里找到本文中使用的代码。

发生器从随机背景图像开始。它将绘制一个内部带有“停止”字样的八边形。添加噪声、模糊和应用仿射变换将完成在随机背景上渲染合理逼真的停车标志图像的过程。在某些情况下，生成器会绘制一个额外的随机均匀八边形。这个八角形模拟了停车标志的背面，FCNN 人必须学会忽略它。生成器有时还会在八边形之外写“停止”这个词。通过仿射变换变形的八边形表面将成为 FCNN 需要学习生成的目标热图。

左图:随机背景图片。中心:合成图像。右图:对应的热图。图片由作者提供。

使用合成图像的主要优点之一是实际上无限的训练数据集。即使可用的背景图像的数量是有限的，各种变换、随机位置和绘制对象的比例也向我们保证了神经网络在训练期间将不会两次看到相同的图像。

训练图像是按需合成的，但是验证图像只生成一次并被保留，以提供从一个时期到另一个时期的损失的公平比较。

验证图像的样本。图片由作者提供。从 Picsum 中获得随机背景。

FCNN 建筑

我选择的架构(在令人尴尬的多次失败迭代之后)是三个卷积层的堆叠，后面是一系列三个转置卷积。

FCNN 建筑。图片由作者提供。

这个 FCNN 架构的实现接受一列输入张量，并返回每个张量输出的像素最大值作为其最终输出。这项功能的动机是观察到训练有素的 FCNN 倾向于对应用于输入图像的模糊水平非常敏感。在某些情况下，当输入图像没有模糊时，输出热图不会突出显示停车标志。当输入图像有点模糊时，热图会突出显示停车标志。在某些情况下，情况正好相反:当输入图像没有模糊时，停止标志会被检测到，但当输入图像模糊时，停止标志不会被检测到。这种观察导致提交越来越模糊的图像，并保留每个输出的像素最大值。这种机制被集成到神经网络的 forward()函数的定义中。

通过提供两个图像的列表来训练 FCNN:未模糊的图像和用 3×3 内核模糊的图像。

培养

使用二元交叉熵损失似乎对这类任务很有效。

作为时代函数的训练和验证损失。图片由作者提供。

真实场景图像的热图(编码在红色通道中)的演变，如 FCNN 正在训练。图片由作者提供。

测试训练有素的 FCNN

在使用合成图像进行训练之后，我们可以在真实场景图像上进行测试。这些图像中的一些包括停止标志，而另一些没有。一些场景以停止标志的背面为特色，这不应该激活热图。

神经网络的输出，用于真实场景图像(512 x 512)。红色通道对热图进行编码。图片由作者提供。

用于训练的合成图像的大小是 256 x 256，但是根据推断，当真实场景图像在被传递到 FCNN 之前被调整到 512 x 512 时，结果是最好的。

左图:调整为 256 x 256 后真实场景的热图(红色通道中)。右图:调整为 512 x 512 后同一图像的热图。热图被调整回原始图像的大小以便显示。图片由作者提供。

我们观察到，我们没有获得假阳性(即，当场景不包括停车标志时，热图不会显示高强度的区域)，但发生了一些假阴性(即，错过了一些停车标志)。用合成图像观察不到这种现象。

经过训练的神经网络的输出，用于验证合成图像(256 x 256)。红色通道对热图进行编码。图片由作者提供。从 Picsum 中获得随机背景。

遗漏病例研究

对于神经网络，故障原因的识别通常是困难的。我们可以做的一件事是改变有问题的输入图像，并观察输出是否有所改善。

多重模糊

两个未能生成良好热图的案例被提交了多种模糊尺寸:1x1(即无模糊)，高达 9x9:

模糊输入图像的效果，从 1x1(左上)到 9x9(右下)。当模糊度为 6x6(中间偏右)时，此特定图像会产生更好的效果。作者图片

模糊输入图像的效果，从 1x1(左上)到 9x9(右下)。当模糊度为 5x5(中间)或 6x6(中间偏右)时，此特定图像会产生更好的效果。图片由作者提供。

调整大小

使用全卷积神经网络可以将输入图像的大小调整为各种分辨率，因为它们的架构不包括输入和输出维度固定的全连接层。这种灵活性允许我们在通过 FCNN 之前选择应用于原始图像的调整尺寸。在通过神经网络之前，同样的有问题的图像被调整到不同的大小。

在通过 FCNN 之前，将图像调整到(128，128)(左)、(256，256)、(512，512)和(1024，1024)(右)的效果。在这种情况下，(256，256)给出了更好的结果。图片由作者提供。

在通过 FCNN 之前，将图像调整到(128，128)(左)、(256，256)、(512，512)和(1024，1024)(右)的效果。在这种情况下，这些尺寸都没有给出好的结果。图片由作者提供。

印刷文字的重要性

对于训练图像，单词“停止”出现在八边形的中心。我们可以测试这个词的出现是否是一个必要的特征。下图显示了提交不带任何文本的八边形合成图像的结果。

八边形内没有任何文本的合成图像的结果。图片由作者提供。

对于八角形表面的大部分，FCNN 没有激活。我们可以得出结论，文本的存在是必要的。

下图显示了打印文本是从牛津英语词典中随机选择的单词时的热图。

合成图像的结果，带有“停止”以外的单词。图片由作者提供。

结论

我们在随机背景上生成了停车标志的合成图像。这些图像用于训练一个完全卷积的神经网络，以生成停车标志八角形的热图。

最初观察到 FCNN 对输入图像中的模糊程度非常敏感，这一点通过对有问题的案例的分析得到了加强。虽然 FCNN 训练使用大小为 1 和 3 的模糊图像，但这对于一些真实场景输入来说是不够的。我会推荐模糊大小为[1，3，5，7]的训练。

左图:模糊尺寸为[1，3]时的结果。右图:模糊尺寸为[1，3，5，7]时的结果。图片由作者提供。

至于调整大小，在两个被研究的丢失物体的案例中，只有一个在特定维度上有所改善，而另一个没有改善。出于这个原因，我建议将调整大小保持为(512，512)，这样总体来说效果不错。

最后，经过训练的 FCNN 似乎对写在八角形内部的单词不敏感，只要在深色背景上至少有一个浅色字母。虽然这个功能没有被明确地设计出来，但是它很有用，尤其是如果你像我一样，生活在一个停车标志可以显示“停止”、“arrêT”或“arrêT STOP”的地方。

这个项目既有挑战性又有趣！用简单的编程技巧就能弥补昂贵的手动注释图像数据集的不足，这是一种极大的满足感。让我知道你的想法！

[1]模糊是用相邻像素值的加权平均值替换图像中每个像素值的过程。在典型的场景中，邻域将是围绕中心像素的小正方形(例如:5×5)，并且加权将是均匀的。在本文的剩余部分中，“N 的模糊大小”是指围绕中心像素的 N×N 个像素的邻域上的均匀平均值。

[2]通过利用从 https://picsum.photos 下载的随机背景图像来合成训练和验证图像。根据 Picsum 网站，这些图片是从https://unsplash.com/获得的

为意大利语培训上下文拼写检查器

原文：https://towardsdatascience.com/training-a-contextual-spell-checker-for-italian-language-66dda528e4bf?source=collection_archive---------11-----------------------

图片鸣谢:Unsplash。

介绍

在之前的帖子中，我们已经介绍了拼写检查，以及在生成更正时需要考虑上下文线索。我们还讨论了 Spark-NLP 库中用于拼写检查的预训练模型的可用性。虽然，预先训练的模型在许多情况下都很方便，但有时你需要针对特定的领域，如金融或特定的语言，如德语。在这篇文章中，我们将从头开始探索训练一个上下文拼写检查器。

我们将深入研究创建上下文拼写检查模型所涉及的训练过程和数据建模。我们将使用通用意大利语作为我们的目标语言，但是这些步骤可以应用于您感兴趣的任何其他领域或语言。

我们将使用PaisàCorpus作为我们的训练数据集，我们将添加自定义的单词类来处理像地点和名称这样的事情；最后，我们将看到如何使用 GPU 和 Spark-NLP 来加速训练。我们开始吧！。

本文的代码

您可以在下面的笔记本中找到本文的完整代码以及一些附加示例，

训练上下文拼写检查器——意大利语。

数据准备

您将从这个 URL 下载语料库文件。接下来，我们将应用一些清理原始文本，以消除一些噪音。

让我们从添加一些基本导入开始，

from sparknlp.annotator import *
from sparknlp.common import *
from sparknlp.base import *
import sparknlp
spark = sparknlp.start()

接下来让我们加载语料库数据。

from pyspark.sql.functions import *
paisaCorpusPath = “/path/to/paisa.raw.utf8”# do some brief DS exploration, and preparation to get clean text
df = spark.read.text(paisaCorpusPath)
df = df.filter(~col(‘value’).contains(‘</text’)).\
 filter(~col(‘value’).contains(‘<text’)).\
 filter(~col(‘value’).startswith(‘#’)).\
 limit(10000)df.show(truncate=False)

这就是我们得到的，

+--------------------+
|               value|
+--------------------+
|Davide Guglielmin...|
|Avete partecipato...|
|Otto mesi di rita...|
|Il prezzo dei big...|
|Dopo la “Shopping...|
|Il nome è tutto u...|
|Ovvero? Ovvero do...|
|Il patto ha lo sc...|
|La tre giorni org...|
|Quanto pagate per...|
|Per contro, nell’...|
|Non è poco, ovvia...|
|Dopo una lunga as...|
|La serata sarà un...|
|I primi 4 negozi ...|
|La Chaingang Rota...|
|La Chaingang Rota...|
|Tra le molte rami...|
|Un primo corollar...|
|E' proprio nel di...|
+--------------------+
only showing top 20 rows

我们有 7555997 个段落，每个段落包含几个句子，由于训练不需要带标签的数据，这就是我们所需要的。

基本管道设置

现在我们已经有了良好的数据，我们将设置一个基本的管道来进行处理。这是典型的 Spark-NLP 管道，数据在注释器中作为注释流动。

assembler = DocumentAssembler()\
 .setInputCol(“value”)\
 .setOutputCol(“document”)\tokenizer = RecursiveTokenizer()\
 .setInputCols(“document”)\
 .setOutputCol(“token”)\
 .setPrefixes([“\””, ““”, “(“, “[“, “\n”, “.”, “l’”, “dell’”, “nell’”, “sull’”, “all’”, “d’”, “un’”])\
 .setSuffixes([“\””, “””, “.”, “,”, “?”, “)”, “]”, “!”, “;”, “:”])spellChecker = ContextSpellCheckerApproach().\
    setInputCols("token").\
    setOutputCol("corrected").\
    setLanguageModelClasses(1650).\
    setWordMaxDistance(3).\
    setEpochs(10).\
    addVocabClass('_NAME_', names).\
    updateRegexClass('_DATE_', date_regex)

我们从我们的 DocumentAssembler 开始，为它输入我们在上一步中准备好的数据。然后我们继续我们的 RecursiveTokenizer，其中我们设置了一些特殊的选项来处理意大利语的一些细节。

最后，我们有我们的拼写检查。前两个方法调用是管道中连接输入和输出的常用方法。然后，我们在拼写检查器 setLanguageModelClasses()中为语言模型设置了一个依赖于词汇大小的设置，模型将使用它来控制语言模型中的因子分解。

基本上，因式分解背后的思想是，我们不会孤立地对待单词，而是将它们分组，给每个单词分配一个特定的类，以及该类中的一个 id。这有助于加快训练和推理过程中的内部处理。

接下来是 setWordMaxDistance(3)，它简单地告诉拼写检查器我们的错误最多在编辑距离 3 处。

历元数是您从神经网络中了解到的典型梯度下降参数，它将由拼写检查器中的神经语言模型使用。

最后但同样重要的是，我们增加了一个特殊的词类，在这个例子中是用来处理名字的。让我们进入更多的细节！。

添加特殊类别

这一节是可选的，它解释了我们在注释器设置代码末尾进行的 addVocabClass()和 addRegexClass()调用。如果您不想添加特殊的类或者您想稍后再来，只需注释掉这两行。

在这一点上，我们有一个相当大的语料库，足以让我们很好地接触到不同风味的意大利语。

尽管如此，除了我们在语料库中看到的，我们可能还想有另一种机制来构建我们的模型词汇表。这就是特殊类发挥作用的地方。

有了这个，我们就可以释放包含在特定数据集中的知识的力量，如名称词典或地名词典。

它们不仅允许我们教会拼写检查器保留一些单词，还可以提出更正建议，而且与主词汇表中的单词不同，一旦模型经过训练，您就可以更新它们。例如，如果在模型被训练之后，您仍然希望能够支持一个新名称，您可以通过更新 names 类来实现，而不需要从头开始重新训练。

当你像我们在这里做的那样从头开始训练拼写检查器时，你会得到两个预定义的特殊类:DATE，和 NUM，分别用于处理日期和数字。您可以覆盖它们，也可以添加更多的类。

按照我们关于名字的例子，我们将在 Spark-NLP 的上下文拼写检查器中添加意大利名字作为一个特殊的类，

import pandas as pd
import io
import requests# Get a list of common Italian names
url=”[https://gist.githubusercontent.com/pdesterlich/2562329/raw/7c09ac44d769539c61df15d5b3c441eaebb77660/nomi_italiani.txt](https://gist.githubusercontent.com/pdesterlich/2562329/raw/7c09ac44d769539c61df15d5b3c441eaebb77660/nomi_italiani.txt)"
s=requests.get(url).content# remove the first couple of lines (which are comments) & capitalize first letter
names = [name[0].upper() + name[1:] for name in s.decode(‘utf-8’).split(‘\n’)[7:]]# visualize
names

这是我们得到的结果(被截断)，

['Abaco',
 'Abbondanza',
 'Abbondanzia',
 'Abbondanzio',
 'Abbondazio',
 'Abbondia',
 'Abbondina',
 'Abbondio',
 'Abdelkrim',
 'Abdellah',
 'Abdenago',
 'Abdon',
 'Abdone',
 'Abela',
 'Abelarda',
 'Abelardo',
 'Abele',

这就是我们在前面清单中注释器设置期间传递给拼写检查器的名称变量。

如果您关注了我们如何设置注释器，您可能还会注意到，我们使用 updateRegexClass()函数调用为数字配置了第二个特殊的类。

这与为修正候选项添加额外来源的目的是一样的，但是这次是针对日期，所以我们需要传递一个正则表达式来描述我们想要覆盖的日期。

这里我们将集中讨论一种特定的格式，但是您也可以添加自己的格式，

**格式:**日/月/年

正则表达式:

([0–2][0–9]|30|31)\/(01|02|03|04|05|06|07|08|09|10|11|12) \/(19|20)[0–9]{2}

理解我们刚刚创建的正则表达式的幕后发生的事情很重要。首先，我们创建的正则表达式是一个有限的正则表达式，也就是说，它匹配的词汇表或字符串集是有限的。这很重要，因为拼写检查器将枚举正则表达式，并用它创建一个 Levenshtein 自动机。

训练模型

现在我们已经准备好了管道，我们将调用 fit()，并传递我们的数据集。

pipeline = Pipeline(
 stages = [
    assembler,
    tokenizer,
    spellChecker
 ])
model = pipeline.fit(df)

使用 GPU

你会注意到训练过程不是很快。那是因为到目前为止我们只使用了 CPU。我们可以通过用 spark-nlp-gpu 替换 spark-nlp 库来显著加快训练速度。

您几乎不需要做任何更改就可以做到这一点，只需像这样将正确的标志传递给 Spark-NLP start()函数，

sparknlp.start(gpu=True)

玩模型

让我们看看这个模型能做什么！。

lp.annotate(“sonno Glorea ho lasciatth la paterte sul tavolo acanto allu fruttu”)[‘corrected’]['sono',
 'Gloria',
 'ho',
 'lasciato',
 'la',
 'patente',
 'sul',
 'tavolo',
 'accanto',
 'alla',
 'frutta']

我们可以看到，模型确实在生成考虑上下文的校正，例如,“allu”被校正为“alla ”,而其他选项如“alle”或“allo”也在离输入单词 1 的相同编辑距离处，然而模型做出了正确的选择。我们还可以看到名字的词汇化有助于模型理解和纠正专有名称“Gloria”。

总的来说，这就是我们从这个模型中所能期待的，当多个相似的、距离相等的候选对象都有可能时，采取正确的选择。该模型可以做出一些更冒险的决定，比如实际替换词汇表中存在的输入单词。

这更多的是语法检查的工作，例如，从语法上来看。尽管如此，如果您想探索您可以在多大程度上扩展这个模型来执行这些修正，在本文的配套笔记本中有更多的例子。

通过模型中心访问模型

虽然这个模型并不完美，但我已经把它上传到了模型中心，并在社区上公开，以防有人觉得有用。您可以通过以下方式访问它，

ContextSpellChecker.pretrained(“italian_spell”, “it”)

你也可以训练你自己的模型，并按照这些步骤与社区分享。

关于标记化的一句话

这一部分是可选的，但是推荐给那些试图为特定语言或领域微调模型的人。

在许多 NLP 任务中，标记化部分是至关重要的，拼写检查也不例外。您将从标记化中获得的单元将非常重要，因为这些单元将定义您的模型检测错误、生成更正以及利用上下文对不同的更正进行排序的级别。

这里，我们使用 RecursiveTokenizer，之所以这样叫是因为它将继续递归地应用它的标记化策略，也就是说，应用到前面的标记化步骤的结果，直到该策略不能再应用为止。

RecursiveTokenizer 中的默认标记化是在空白上分割。为了进一步标记化，您可以指定中缀模式、前缀模式和后缀模式。

中缀模式是可以在标记中间找到的字符，您希望在其上进行拆分。相应地，前缀模式和后缀模式是您想要拆分的字符，它们将分别出现在每个标记的开头和结尾。

您可以在文档中找到这个 RecursiveTokenizer 的更多选项。Spark-NLP 库中也有其他的记号赋予器。

结论

我们已经探索了如何训练我们自己的拼写检查器，如何准备我们的数据和管道，如何为特殊类提供规则，如何使用 GPU，以及如何调整标记化以更好地满足我们的特定需求。

Spark-NLP 库提供了一些合理的默认行为，但是也可以针对特定的领域和用例进行调整。

希望你可以开始训练和分享你自己的模型，在博卡阿尔卢波！！

用 Tez 和 PyTorch 训练多标签情感分类器

原文：https://towardsdatascience.com/training-a-multi-label-emotion-classifier-with-tez-and-pytorch-af04c899a63a?source=collection_archive---------19-----------------------

让您的培训脚本更上一层楼

作者图片

如果您厌倦了在 PyTorch 中重写相同的培训管道样板代码，我发现了一个非常简洁的解决方案，可以让您的生活更加轻松。别担心，这不是一个会改变你做事方式的沉重的库。

它是一个轻量级的包装器，将训练逻辑封装在一个类中。它是基于 PyTorch 之上构建的，虽然是最近才有的，但是我已经测试过了，我认为它确实做到了它所承诺的。

它叫做 Tez ，我们今天将看到它在一个有趣的多标签文本分类问题上的应用。以下是我们将要介绍的内容:

• 使用🤗数据集库，用于加载和操作数据
• 用 Tez 和变形金刚定义培训管道
• 针对多标签分类问题训练一个 SqueezeBert 轻量模型，并在验证和测试数据上达到+0.9 AUC

让我们直接跳进来吧！

***【PS *😗**在继续本教程之前，我要向Abhishek tha kur致敬，他为构建 Tez 并使深度学习能够为更大的社区所用付出了努力和精力。

PS** :所有代码以及训练好的模型在我的 Githubrepo上都有。

在 GoEmotion 🧱上构建一个不寻常的情感分类器

您可能熟悉基于二进制(例如 IMDB 电影评论)或多类数据(例如亚马逊产品评论)构建情感分析模型。

我们今天仍将关注情绪分析，但我们会做一些稍微不同的事情。

在搜索 Huggingface 的网站寻找数据集时，我遇到了一个有趣的数据集，叫做 GoEmotions: 它包含了 58k 条精心策划的 Reddit 评论，分为 28 个类别，包括中性类别。

这些数据来自英语，旨在进行多标签分类，用有趣的类别描述社交网络上的人类行为。我不得不尝试这个数据集！

以下是 28 种不同的情绪:

[‘admiration’, ‘amusement’, ‘anger’, ‘annoyance’, ‘approval’, ‘caring’, ‘confusion’, ‘curiosity’, ‘desire’, ‘disappointment’, ‘disapproval’, ‘disgust’, ‘embarrassment’, ‘excitement’, ‘fear’, ‘gratitude’, ‘grief’, ‘joy’, ‘love’, ‘nervousness’, ‘optimism’, ‘pride’, ‘realization’, ‘relief’, ‘remorse’, ‘sadness’, ‘surprise’, ‘neutral’]

我发现这个数据集很有趣，因为它提供了详细情绪的标记数据，如好奇、感激或惊讶，这些情绪很难用典型的数据集来检测。

我也发现这样一个数据集的影响。部署将文本数据分类为这些情绪的模型可以有多种应用:

• 通过对客户评论的精细分析来评估客户行为
• 检测社交媒体上的有害评论或仇恨言论
• 建立一个代理来评估你的文章(电子邮件、报告、博客帖子)的语气
• 用元数据丰富数据集:例如，在通过模型进行分析之后，您可以使用这个模型用标签来补充电影概要

这样的例子不胜枚举。在评论区告诉我你还能想到哪些应用。

1 —设置您的环境💻

要重现本教程，您需要安装 python 3。我会选择 Anaconda ，但是你可以使用任何你想要的软件包管理器。

然后，您必须安装:

• PyTorch (最好是最新版本)
• 🤗transformers :一个库，提供了数千个预训练的模型来执行文本任务，如分类、翻译、100 多种语言的文本生成
• 🤗Datasets :一个轻量级库，为许多公共数据集(包括 GoEmotions)提供一行数据加载器和预处理
• Tez:py torch 的超简单轻量训练器

您还需要scikit-learn和pandas来进行通常的数据处理和操作。

你应该准备好了:让我们开始编码吧！

同样的老进口先:

2-从获取数据🤗数据集

数据可以很容易地从🤗数据集库，在训练中提取，验证和测试分割并转换为熊猫数据帧。

下面先来看一下数据:每个评论都有一个对应的 id 列表，这些 id 映射到 28 种情绪中的一种。

作者图片

将每个标签转换为原始值，我们可以获得更全面的视图。

为了将数据正确地输入到分类器中，我们需要将标签转换成一个热点向量。

作者图片

快速查看目标在训练、验证和测试之间的分布表明，它遵循相同的模式。(id 27 对应于中性情绪，该中性情绪恰好在 30%的数据中被标记)

作者图片

在训练一个模型之前，让我们先快速浏览一些根据他们的情绪取样的评论:

钦佩

Wow, your posting history is a real... interesting ride.
---
I've never heard the insult 'Galaxy-Brain' before, but it's a wonderful! I'm gonna have to use it more often.
---
That or spot up shooting. I like the confidence though, he’s not scared to expand his game.
---
Congratulations!! Colorado is an amazing place! I just moved away a year ago and miss it terribly :) Best of luck to you!
---
Your artwork is amazing.
---

游乐

A stork bite your baby?!?! *kidding*
---
I like how because it’s on topic you assume everyone involved is making it their entire being. Lmao.
---
It's funny cause you say socialists have an "ignorance of economics" while posting on an anarcho-capitalist sub :) I think you clearly fundamentally misunderstand socialism. 
---
Oh hahaha, is it a reputable vendor?
---
This just made my day! Thanks for the laugh!!
---

愤怒

[NAME], don't f**king front the pass if your help defender is [NAME] he will not help you
---
I will kill you all
---
How aren’t you in f**king school
---
I hate betting unders.
---
How dare you disrespect [NAME].
---

关爱

Yes. One of her fingers is getting a sore on it and there’s concern it may push her into needing braces.
---
Most important!!! ALWAYS AIM THE HEAD! [NAME] arrows are pretty fat woodsticks, so keep aiming on the head on long distance. Thats it
---
special for you my dude :)
---
you did drug her though, and assault her by undressing her and taking her photo. you committed multiple crimes. you need professional help.
---
Sure, they can help nurse [NAME] back to health. 
---

3-定义 PyTorch 数据集🗂

这不会改变:您仍然需要定义如何加载和预处理数据。

我们将在类的构造函数中定义记号赋予器。每次访问样本时都会调用标记器，将文本转换成标记 id 和注意掩码。

令牌 id 和注意力屏蔽稍后将被提供给模型以生成预测。

• 令牌 id 是令牌索引:它们只是构建将被模型用作输入的序列的令牌的数字表示。
• 注意掩码是一个可选参数，在将序列批处理在一起时使用。该参数向模型指示哪些令牌应该被关注，哪些不应该被关注。

请注意:

1. 我们使用了一个 SqueezeBertTokenizer，因为我们将使用的模型是一个 SqueezeBert(更多细节见下文)
2. 最大长度是 35，因为它对应于注释的最大长度

4——奇迹发生的地方:定义⚡️模式

使用 Tez 时，只需将代码定义为从 tez.Model 继承的类。

这个类实现了你必须重写的特殊方法。

填写每个方法都相当容易。让我们一个一个来做:

构造函数 init 将定义我们将使用的主干模型。在尝试了功能强大但非常大的型号，如Bert-base-unc cased和 roberta-base 后，我决定选择 SqueezeBERT ，它比 Bert-base-unc cased 快 4.3 倍，但性能相同。剩下的参数都很标准:dropout layer，带有类的数量和训练步骤的数量的输出层。

• 关于 fetch_optimizer 和 fetch_scheduler 方法，我使用了我在 repo 中找到的例子。如果这些设置对您不起作用，请随意尝试其他设置

• 损失:由于我们正在处理多标签分类，我们将在每个输出神经元使用二进制交叉熵。这对应于 PyTorch 中的 BCEWithLogitsLoss。

• monitor_metrics :关于指标，我们可以分别计算每个目标的 F1 或 AUC 分数，但由于这会导致显示大量指标，所以我只选择了微 AUC。这里的技巧是在一维向量中展开目标和输出的批次，并计算它们之间的 AUC。由于目标是相互独立的，这非常有意义。

• forward: 这是我们定义模型如何对输入数据执行正向传递的地方。这个方法应该返回一个由输出、损失和度量组成的元组。

5 —开始培训⏱

我们快到了！现在我们开始训练。如果您熟悉 Keras API，这看起来非常相似:训练模型是一行程序。

Tez 还提供了回调，允许您在模型训练时引入一些功能。我们将使用其中的两个:

1. TensorBoardLogger 在 Tensorboard 中记录训练和验证指标
2. 提前停止检查最佳模型并过早停止训练

嘭！在短短两个时期内，该模型达到了惊人的 0.922 AUC 分数或验证数据。

作者图片

在 8 个时期的训练后，模型在训练数据上达到 0.97 AUC，在验证数据上达到 0.95。

现在让我们看看模型在测试数据上的得分，并评估它在每个类中的表现。

作者图片

很神奇吧？该模型在除类别 21(对应于 pride )之外的所有类别上都有+0.8 的 AUC 分数。

在一些自由文本上测试模型

让我们在一些自由文本上测试这个模型。(你会在我的回购上找到 score_sentence 的实现)

**score_sentence("i miss my friends")** #sadness 0.863369 
#disappointment 0.20503707 
#neutral 0.05794677 
#remorse 0.02818036 
#annoyance 0.023128381 **score_sentence("i miss my friends")** #sadness 0.863369 
#disappointment 0.20503707 
#neutral 0.05794677 
#remorse 0.02818036 
#annoyance 0.023128381**score_sentence("you might have a point, but i strongly disagree with you")** #disapproval 0.77016926 
#annoyance 0.11454596 
#approval 0.08423975 
#disappointment 0.04763091 
#disgust 0.04497903**score_sentence("i'm feeling very confident about this situation") ** #optimism 0.456496 
#approval 0.43606034 
#admiration 0.1233574 
#caring 0.096342765 
#realization 0.07383881**score_sentence("try to be safe my friend")** #caring 0.73572147 
#optimism 0.0856328 
#neutral 0.071999945 
#sadness 0.06158314 
#approval 0.038069934

结论和未来工作🔜

本教程提供了一个机会，在一个多标签数据集上应用一个名为 SqueezeBert 的最先进的语言模型，该数据集包含 50K 条评论和 28 个类别。

使用 Tez 非常有效地组织了培训渠道，同时保留了很大程度的定制化。在几行代码之后，经过训练的模型在测试数据上达到了惊人的 0.95 AUC 分数。

但是旅程并没有到此为止:现在是时候将模型部署到互联网上，以便其他人可以通过 API 端点与之交互:如果您对这个主题感兴趣，可以看看我以前的文章中的一篇，在那里我使用 AWS Lambda 在无服务器架构上部署了一个生成模型。

感谢阅读！如果你有问题，请不要犹豫，尽管来找我。

如果你对代码感兴趣，你可以在我的回购上找到。
如果你喜欢 Tez 你可以查看一下这里！

训练蛇游戏人工智能:文献综述

原文：https://towardsdatascience.com/training-a-snake-game-ai-a-literature-review-1cdddcd1862f?source=collection_archive---------7-----------------------

方法综述，从非最大似然技术到遗传算法到深度强化学习

维多利亚博物馆在 Unsplash 拍摄的照片

0.介绍

你可能玩过，或者至少看过，蛇的游戏。玩家通过按箭头键控制一条蛇，蛇必须在屏幕上移动，吃苹果。每吃一个苹果，尾巴上的蛇就长一个单位。目标是在不碰到墙或蛇不断增长的尾巴的情况下吃尽可能多的苹果。

构建一个人工智能代理来玩 Snake 是一个经典的编程挑战，YouTube 上的许多视频显示了使用广泛技术的各种尝试。在本文中，我回顾了各种方法的优缺点，并提供了原始资料的链接。广义地说，人工智能蛇智能体的方法属于三类之一:非最大似然方法，遗传算法和强化学习。从这些主题中可以学到很多东西，所以让我们开始吧！

1.非 ML 技术

蛇的游戏实际上有一个微不足道的，无与伦比的解决方案。创建一个循环路径，该路径穿过棋盘上的每个方格，但不与自身交叉(这被称为哈密顿循环)，然后继续沿着这个循环路径，直到蛇头与整个路径一样长。这样每次都会奏效，但是很无聊，也浪费了很多招式。在一个 NxN 网格中，大约需要 N 个苹果才能长出一条足够长的尾巴来填满棋盘。如果苹果随机出现，我们预计蛇将需要穿过一半当前开放的方块才能从当前位置到达苹果，或者在游戏开始时大约 N /2 步。由于这个数字随着蛇变长而减少，我们预计平均来说，蛇将需要~N⁴/4 移动来击败使用这种策略的游戏。对于 20x20 的棋盘来说，这大约是 40，000 步。

通过棋盘上所有点的哈密尔顿圈。如果蛇只是停留在这个循环上，那就保证赢。图片由作者基于谷歌 Snake 截图(合理使用)。

我在互联网上找到的几种方法本质上只是对这种幼稚的第一种方法的优化，找到聪明的方法来缩短周期而不困住蛇，这样就可以用更少的动作够到苹果。这包括动态地切割和重切哈密尔顿循环以快速到达苹果。有一种方法甚至在一部旧的诺基亚手机上实现了这一点！玩贪吃蛇还有其他非 ML 的技巧，比如使用 A*算法寻找食物的最短路径，但是不像哈密尔顿循环方法，这不能保证打败游戏。

优点:保证最终击败游戏。

**缺点:**不涉及机器学习——算法必须手工编码。需要对图论有所了解。对于大型游戏板可能会很慢。

下面的例子来自 YouTube 上的 AlphaPhoenix。

视频来源:AlphaPhoenix (YouTube)。

2.遗传算法

遗传算法是解决这类问题的另一种流行方法。这种方法是模仿生物进化和自然选择的。机器学习模型(例如，可以是神经网络，但不是必须的)将感知输入映射到动作输出。输入可以是蛇在四个主要方向(上、下、左、右)到障碍物的距离。输出将是类似左转或右转的动作。模型的每个实例对应于自然选择类比中的一个有机体，而模型的参数对应于有机体的基因。

首先，一组随机模型(例如，具有随机权重的神经网络)在环境中被初始化并被释放。一旦所有的蛇(即模型)死亡，一个适应度函数从给定的一代中选择最好的个体。在蛇的情况下，适应度函数将只挑选得分最高的蛇。然后，通过添加随机突变(例如，随机调整网络权重)，从最佳个体中培育出新一代。这些突变有些会造成伤害，有些不会有任何影响，有些是有益的。随着时间的推移，进化的压力会选择越来越好的模型。要通过遗传算法来体验和可视化学习，请看 Keiwan 的这个工具。

**优点:**概念简单易懂。一旦模型被训练，预测下一步行动是很快的。

**缺点:**收敛慢，因为突变是随机的。性能取决于模型可用的输入。如果输入仅仅描述了在蛇的附近是否有障碍物，那么蛇不会意识到“大局”,并且容易被自己的尾巴困住。

下面的例子来自 Code Bullet，而 Greer Viau 的另一个例子也可以在 YouTube 上找到。

视频来源:代码子弹(YouTube)

3.强化学习

强化学习是人工智能的一个快速发展和令人兴奋的领域。在一个非常基础的层面上，强化学习包括一个代理、一个环境、代理可以采取的一组动作****，以及一个奖励函数，奖励代理的好动作或者惩罚代理的坏动作。当代理探索环境时，它更新它的参数以最大化它自己的期望回报。在蛇的情况下，代理人显然是蛇。环境是 NxN 板(根据食物和蛇的位置，该环境有许多可能的状态)。可能的行动是左转、右转和直行。

深度强化学习(DRL)将强化学习的上述思想与深度神经网络相结合。DRL 最近被用来建造超人的[国际象棋和围棋系统](http://Mastering Atari, Go, Chess and Shogi by Planning with aLearned Model)，学习只用屏幕上的像素作为输入来玩雅达利游戏，以及控制机器人。

强化学习示意图。来源:维基百科(公共领域)。https://en . Wikipedia . org/wiki/reinforce _ learning #/media/File:Reinforcement _ learning _ diagram . SVG

深度 Q 学习是 DRL 的一种特殊类型。虽然一开始有点难以理解，但其背后的推理极其优雅。神经网络学习“Q 函数”，它将当前的环境状态作为输入，并输出一个包含每个可能行为的预期回报的向量。然后代理可以选择最大化 Q 函数的动作。基于该动作，游戏然后将环境更新到新的状态并分配奖励(例如，吃苹果+10，撞墙-10)。在训练开始时，Q 函数只是由一个随机初始化的神经网络来近似。现在，你可能会问:为了产生损失并更新权重，我们将输出与什么进行比较？

这就是**贝尔曼方程 的用武之地。该等式用于提供 Q 的近似值，以将神经网络引导到正确的方向。随着网络的改进，贝尔曼方程的输出也会改进。至关重要的是，在 Q 函数的定义中有递归(这是我在程序中使用的 Bellman 变体)😗*

Q(state, action) = 
    reward(state, action) + discount * max(Q(next_state, actions))

因此，Q 函数被递归定义为这步棋 *的奖励加上下一步棋**的最佳可能 Q 函数* 。该项将扩展到下一个奖励加上下一个最佳行动的 Q 函数，以此类推。随着训练的进行，这个 Q 函数(有希望)接近给定移动的真实预期未来回报。(请注意折扣系数的存在，它给予即时回报比预期更大的权重，但不确定未来的回报)。**

观看 Snake AI 使用深度 Q-Learning 训练自己的酷之处在于，你可以看到它的探索和利用的过程，现场发生。在一些游戏中，蛇走了 5 步就死了。这一开始可能会令人失望，但请记住，这将招致惩罚，网络将自我更新，以避免将来出现类似的举动。在一些游戏中，蛇会存活很长时间，并聚集一条长尾巴，获得大量奖励。无论哪种方式，这些动作都是积极或消极的强化来教会蛇如何在未来玩得更好。

为了了解更多关于 Q-learning 的知识，我强烈推荐计算机科学家在 YouTube 上的介绍视频。我还推荐 Lex Fridman 的麻省理工学院强化学习讲座，也可以在 YouTube 上看到。

优点:这是一个非常酷又优雅的概念。RL 也可以应用于许多其他任务，除了建立环境和奖励系统之外，不需要监督。根据我的经验，它比遗传算法收敛得更快，因为它可以利用梯度下降而不是随机变异。

****缺点:一开始有点挠头去理解。与遗传算法一样，模型的性能取决于网络可用的输入，输入越多意味着模型参数越多，这意味着训练时间越长。

下面的视频是 Python 工程师在 YouTube 上制作的惊人的** 4 部分教程的第 1 部分，我强烈推荐。相应的代码可以在 GitHub 上找到。**

视频来源:Python 工程师(YouTube)。

结论

最好的学习方法是边做边学。跟随上面链接的教程/解释并实现我自己的 Snake AI 教会了我更多关于手边主题的东西，这是任何数量的阅读或观看都无法做到的。我鼓励你自己尝试一下，并考虑将这些方法应用到不同的游戏中，例如 Pong、Asteroids 或 Breakout。感谢阅读！

参考

[1]哈密顿路径，https://en.wikipedia.org/wiki/Hamiltonian_path

[2]格里尔·维亚乌，神经网络学会玩蛇，https://www.youtube.com/watch?v=zIkBYwdkuTk

[3]贝尔曼方程，https://en.wikipedia.org/wiki/Bellman_equation

[4]进化论由基万著，https://keiwan.itch.io/evolution

[5] 通过学习模型规划掌握雅达利、围棋、国际象棋和日本象棋、https://arxiv.org/pdf/1911.08265.pdf

【Python 工程师，教 AI 打蛇，https://www.youtube.com/watch?v=PJl4iabBEz0&t = 3s

[7]代码子弹， AI 利用遗传算法和深度学习学习打蛇，https://www.youtube.com/watch?v=3bhP7zulFfY&t = 18s

机器人控制在人类环境中使用深度强化学习，https://ieeexplore.ieee.org/document/8961517

[9]莱克斯·弗里德曼，麻省理工学院 6。S091:深度强化学习介绍(Deep RL) ，https://www.youtube.com/watch?v=zR11FLZ-O9M&t = 3036s

在 Google Colab 中训练 AlphaZero

原文：https://towardsdatascience.com/training-alphazero-in-google-colab-cc2f1d6bd0ba?source=collection_archive---------25-----------------------

借助朱莉娅的力量在短短 5 小时内

训练如此之快，你甚至不会意识到它已经打败了你(图片:杰克·吉文斯， Unsplash

随着 Kaggle 对强化学习(RL)的推进，我一直在深入研究 RL 算法，同时研究哪些算法可以实际训练(我们并不都有一大群 GPU！).在这篇文章中，我讨论了如何使用 Google 的在线笔记本系统 Collaboratory，在不到 4 小时的时间内训练一个代理人玩人类级别的 connect four。

这篇文章是完全可复制的，你可以在这里找到笔记本，训练你自己的代理人，亲眼看看 AlphaZero + Colab + Julia 的力量是多么惊人！

AlphaZero 谷歌合作实验室笔记本链接

向 Alphazero.jl 的所有者以及那些努力让 Julia 起床并在 Google Colab 中运行的人们大声疾呼，这一切才成为可能。

背景

在深入研究之前，先了解一些关键组件的背景知识，如果您对此不感兴趣，请跳到下一部分。

阿尔法零

AlphaZero 是 Deepmind 在 2017 年首次分享的强化学习程序。它能够玩围棋、日本兵棋和国际象棋，这三种独特的复杂策略游戏。它完全通过自我游戏来学习如何做到这一点，当它发现和开发策略时，不断地与自己玩游戏。它是世界著名的 AlphaGo 的继任者，AlphaGo 作为第一个在围棋比赛中击败人类大师的系统而成为头条新闻。

该算法的一大卖点是它可以被训练的速度，Deepmind 报告说，在训练的一天内就达到了超人的水平。当然，这是在一台超级计算机上训练出来的，但是我们要用少得多的东西来管理。

谷歌合作实验室

本文使用的 Google Collaboratory 笔记本——眼熟吗？(作者创作)

想象一个 Jupyter 笔记本，现在想象你不需要设置任何东西，你不需要担心资源，你做的任何工作都可以在你的设备上和其他人即时共享——这就是 Google Collaboratory。这是一项基于云的服务，它复制了我们喜爱的 Jupyter 笔记本电脑，其工作方式与常规桌面安装相同。

这里的主要好处是，您不再受到您个人设置的计算资源的限制。您可以在云中运行这些笔记本电脑的多个实例，特别是对于我们的用例，您甚至可以使用 GPU 资源！

朱莉娅

Julia 是一种灵活的动态语言(易于使用)，适用于科学和数值计算(不慢)，其性能可与传统的静态类型语言相媲美( Julia Docs )。

茱莉亚于 2012 年推出，从那以后知名度慢慢增长。它在投资公司的时间序列分析和保险业的风险建模中得到了应用。最值得注意的是，纽约美联储银行使用 Julia 制作美国经济模型，并指出该语言使模型估计比之前的 MATLAB 实现“快大约 10 倍”(维基百科)。

由于其高性能的能力，它对 ML 项目特别有用，允许网络训练比在 Python 中本地运行快得多。

连接四个

Connect Four(也有许多其他名字，我最喜欢的名字是 Gravitrips )是一款双人游戏，玩家选择一种颜色，然后轮流将彩色圆盘投入 7x6 的格子中。碎片垂直下落，占据塔内最低的可用空间。游戏的目标是第一个形成自己的四个圆盘的水平线、垂直线或对角线。

Connect Four 实际上是在 1995 年解决的，这意味着我们知道如果第一个玩家采取正确的行动，他们总是能赢(完美的行动需要 41 步)，但要在我们的大脑中存储所有可能的 5 万亿步并不容易，所以我们改为使用一些策略来解决游戏，导致有趣的游戏方式，使游戏在发布时受到欢迎。

连接四个游戏(维基共享)

现在，所有的部分都固定好了(看到我做了什么吗？)，我们继续任务吧。

任务

概括一下，在本文中，我们将实现 AlphaZero 来玩简单的连接四个的游戏。我们将使用 Julia 作为基础语言，利用其惊人的速度，在云中这样做，使用 Colab 笔记本在云中训练。

提醒如果你想跟进: AlphaZero 谷歌合作实验室笔记本链接

第一步，设置环境。Google Colab 通常用于 Python，但实际上也可以在其中设置不同的环境。为了快速训练我们的神经网络，我们将安装 Julia 并默认启用 IJulia 运行时。在附带的笔记本中，这意味着运行第一个单元，然后使用启用的新环境进行刷新。

下一步是从 git 安装 Alphazero 的 Julia 实现。这可以通过运行下一部分来完成。笔记本将连接到 git 并获取该项目的文件。然后我们将把这个包加载到 Julia 中，并确保我们已经安装了所有需要的依赖项。

run(`git clone --branch v0.3.0 [https://github.com/jonathan-laurent/AlphaZero.jl.git`)](https://github.com/jonathan-laurent/AlphaZero.jl.git`))
cd("AlphaZero.jl")
run(`julia --project -e "import Pkg; Pkg.instantiate()"`)

安装好库后，我们就可以开始训练网络了。这可以用另一个简单的一行程序来执行，它启动了一个运行 Alphazero 核心算法的脚本。

run(`julia --project --color=yes scripts/alphazero.jl --game connect-four train`)

这将从列出网络的参数开始，用初始化的参数运行一个基准，然后进入第一轮自我游戏。每一轮自我游戏应该持续 30 分钟到 1 小时。这将取决于初始化的参数。

参数初始化(作者创建)

考虑到这需要多长时间，最好现在就离开这个会话，几个小时后再回来。在之前的测试中，我发现它会在 5-10 次迭代中表现良好，这取决于你初始化的运气。

当你准备好了，你可以停止运行单元，它会在最近一次迭代时切断训练。这样做的最佳时机是当您看到您的代理在所有基准代理中表现良好时(或者您已经没有耐心了)。注意:如果您决定继续提高代理的能力，也可以随时使用以下单元格重新开始培训。

一轮自我发挥(作者创作)

下一步是最有趣的——和你的经纪人比赛！希望现在你已经训练出了下一个世界排名前四的玩家，你已经做好了被打败的准备。理想情况下，运行下一个单元将加载您训练过的代理，然后启动一个交互环境，但是…我实际上很难让这部分工作起来。或者，您可以从您的培训工作中下载数据，并在您本地的 Julia 环境中运行(代理仍然是在云中培训的！).

您可以通过运行笔记本中的最后一个单元格来下载数据，这将压缩所有数据。或者，您可以导航到 sessions/connect-four 中的数据，其中包含已学习的网络参数以及用于训练的数据。

一旦你在本地完成设置，你就可以按照有用的维基上的说明进行操作。我和我的经纪人玩了很多游戏，但只有一两次能赢——你玩得怎么样？

接下来连接四颗星(来源

后续步骤

在本文中，我们看到了如何在几个小时内使用 AlphaZero 代理训练 connect four 代理。所使用的 AlphaZero 库可以访问其他游戏，你可能想用它们来进行训练实验。你也可以尝试实现不同的游戏，比如 Snake(这是我目前正在尝试的 Kaggle 比赛的一部分！).

希望这是明确的，任何问题或反馈都欢迎在评论中。

训练人工智能玩战锤 40k:第一部分

原文：https://towardsdatascience.com/training-an-ai-to-play-warhammer-40k-part-one-planning-78aa5dfa888a?source=collection_archive---------11-----------------------

实践教程

我们如何以一种人工智能友好的方式构建一个像战锤一样复杂的游戏？

https://www.instagram.com/p/CR7zpt2tHK-图片由大卫·梅耶授权给本·威廉姆斯

你是否曾经想玩战锤，但发现设置游戏和与其他玩家一起玩太累了？你希望你可以一遍又一遍地与人工智能对抗，磨练你的技能并尝试其他策略吗？如果是这样，你来对地方了。在本文中，我，一个谦逊的软件工程师和战锤迷，开始了一个新项目，训练一个战锤 40k 第 9 版 AI。

为什么，你会问吗？为什么有人会训练人工智能在游戏中打人？可能是因为这很有趣，然后我就可以宣称自己比他们都好。等等，我的意思是为了人类的利益推进深度学习领域(总是把那些事情搞砸。)另外，谁不想和一些可恶的 AI 一起进入一个美好的 ole 技术黑暗时代呢？

我的意思是，我创造了人工智能，人工智能打败了他们，就好像是我做的一样，对吗？

强化学习——是什么？

视频游戏 AI 等控制任务最知名的训练方法是强化学习。强化学习，简称 RL，是一种深度学习技术，多智能体在竞争环境中执行任务。随着时间的推移，这些代理被奖励和加强以诱导期望的行为。有了足够的计算能力和一个结构良好的奖励方案，不可思议的行为就会出现。

必须训练才能有结果！在 Unsplash 上 Karsten Winegeart 拍照

这与监督学习有很大不同，在监督学习中，大量带标签的数据被输入到 ML 模型中，输出与基础事实进行比较。游戏人工智能代理在如此动态的环境中运行，几乎不可能生成和标记如此大量的数据，更不用说理解这些数据了。不断变化的输入会影响短期和长期规划，强化学习提供了完成工作的工具。

对于任何成功的强化学习项目，所有数据科学的通用原则都适用:

• 大量的好数据会产生更好的结果。
• 模拟的质量对于代理学习任何东西都是至关重要的
• 不惜一切代价避免偏差(人口过多或过少)
• 如果你知道一个信号对问题很重要，直接输入。当你可以加快速度的时候，不要等着人工智能去抓东西。
• 更新的神经网络拓扑、训练技术或其他方法会有所帮助，但最终好的、净化过的数据会得到更好的结果

那么，我们该怎么做呢？

我不是深度学习研究者。当谈到神经网络、训练方法或其他方面时，我不太了解任何事情的相对好处。幸运的是，我不需要！有一个很棒的项目就是为像我这样的人准备的——开放健身房。Gym 是一个 RL 框架——本质上是一组最流行的深度学习模型插入的公共 API。

它的明确目的是创建标准的虚拟环境，强化学习在其中进行。这方面的一些例子包括 Atari 游戏、平衡摆、国际象棋环境等等。

开放式健身环境范例——钢管舞。按作者分类的源视频

OpenAI 健身房挺简单的。在其核心，它是一个容易构建或消费标准环境的框架，因此我们可以测量不同的 ML 模型在同一任务上的表现如何(基准测试)。)我们程序的顶层将继承基本的环境类，在未来的某一天，它将被世界上每一个人工智能研究者所使用。

还有，需要朋友的 40k 玩家。

量化板卡状态

游戏的整个状态需要被存储，通过动作更新，然后再次反馈给我们的强化学习代理。在 OpenAI 健身房的世界中，这被称为观察—观察被反馈到模型中，以理解刚刚发生的事情。这意味着我需要模拟与游戏性相关的一切——棋盘的大小、地形的位置、模型底座的大小、剩余的伤口、模型是否是交通工具、它是否会爆炸等等。

人工智能模型输入和输出— ( 作者图片)

为了使数据能够被健身房代理理解，必须使用空格来组织数据。空格是框架可以理解的标准类型。它们本质上可以归结为:

• 离散值(枚举或整数)
• 盒子(N 维空间，连续或离散)
• 布尔运算
• 将上述类型组织成有意义的块的方法，比如字典和元组

按照我的说法，游戏状态是一种分层的、面向对象的模式，其中每个不同的项目都包含在一个对象中。我目前的计划是开发自己的 Warhammer 40k 引擎(目前正在开发中，将在后续文章中概述)，并简单地维护一个翻译层，其中包含我自己的动态模式与 OpenAI Gym 使用的固定模式之间的任何差异。

步骤和动作类型

健身房环境最重要的作用就是步()。代理调用步骤()告诉程序消费它的动作，模拟结果，并更新观察。

step() 是单个时间步，动作之间的周期。这是战锤 40k 的实际游戏进行的地方，给出代理指定的动作。

OpenAI Gym step()函数—图片由作者提供

为了让我正确设计 step() ，我必须先知道什么是动作！在现实生活战锤，行动可以从选择一个目标射击的所有方式，以中断战斗使用战略。既然我们人类如此善于处理模糊性，我们就可以合理地凭直觉判断何时需要执行某个动作，以及如何理解它。对人工智能来说，事情变得更加棘手！

所有神经网络的输出层都是固定的。它们将永远是相同的维度。这使得将网络输出与战锤 40k 的动态动作联系起来变得棘手。游戏有很多来回的互动。策略是一个突出的痛苦的例子——一些可以在掷骰子之前或之后使用，甚至可以用来中断战斗解决的顺序。

即使在正常的回合顺序中，也有几个反复的决定——否定心灵力量，或者分配攻击给单位中的哪个模型，等等。掷骰子的结果通常会影响玩家随后做出的决定，这也可能随时发生。

让我们考虑下面的操作序列，如下所示:

40K AI 动作示例序列— 作者图片

在这种情况下，轮到蓝色玩家了。蓝色玩家选择向前移动两个单位，用远程武器射击第一个橙色敌人。他们选择用不同的敌人模式来攻击他们的第三个单位。橙色玩家选择向第三个蓝色单位发射警戒。

让我们探讨一下在这种情况下如何组织行动的不同可能性。

1。 小动作(真实动作)

对于我提议的小动作，一个动作正是游戏规则中定义的一个动作——这将是战锤规则到代码的最直译。任何时候一个玩家可以合法地对一种情况做出行动或反应，人工智能代理也将被允许这样做。这将意味着从移动命令，到宣布射击目标，到决定战斗顺序的任何事情都将是人工智能做出的独特动作。这为代理提供了最大限度的信息，以便在所有时间点做出最佳决策。这也是人工智能可以不受任何限制地玩 40K 的完整游戏的唯一方式(取决于那些讨厌的开发人员正确编码！)

动作序列示例—每个玩家交替动作和反应— 作者图片

以我自己不专业的观点来看，这样做最大的缺点是，这将变得难以置信地难以为人工智能建模。几乎所有的 OpenAI 健身房项目都倾向于只有一种类型的动作可以发出——他们在平台上平衡横梁(向左、向右、停止)或击败吃豆人(向上、向右、向下、向左或停止)。)通过的小动作，我们的模型现在必须了解它处于哪个阶段，它处于哪个环境中(瞄准、传球、移动、分配伤口等)。)甚至开始做出好的决定。本质上，它必须学习游戏规则，同时也要学习游戏中的最佳策略——也就是说，它很可能会有一大堆动作，当它们不相关时，它可以发出来。这意味着算法有很多模糊性——传统的学习算法可能无法很好地处理这一点。我们人类学习规则已经够辛苦了，我们还有参考文本要通读！

形成良好的输出图层模式在这里也很困难-我们要么为不同的操作重用相同的输出字段，要么创建一个大规模的输出表面来同时处理所有可能的操作。这可能会导致难以置信的漫长和困难的学习时间，因为学习过程会对大面积的不连续输出进行实验。

2。 大动作

有了大动作，一个动作就是战锤的一个完整回合——玩家回合的每一个集体动作、射击、冲锋命令都在一个巨大的输出中完成。对于我们上面概述的场景，所有蓝色命令(移动、射击和冲锋)在蓝色玩家的回合开始时同时输出。

样本大动作——所有蓝色订单同时提交——作者本人法师

这样做的最大好处是每个步骤()都是一样的——得到一组动作，然后玩完整个回合。这使得训练代理比小动作更容易一些，因为它不需要担心不同的“模式”或动作类型。只有一个动作的内容每个步骤()。这也使得开发变得容易——我们只需要大规模的动作输出，然后一举完成回合。

这种方法最大的缺点是代理人丢失了信息——它必须在任何决定执行之前做出决定，不像游戏的实际参与者。虽然我们人类玩家倾向于在每个回合开始时都有一个计划，但拙劣的射击或冲锋的结果会导致计划的改变。这可能发生得非常突然，如果可能的话，我不想妨碍人工智能这么做。随着大动作，人工智能无法利用我们都爱的战锤的动态来回方面。它还阻止了人工智能玩完整的游戏——无序的动作是规则的一部分。

3。 每型号或每单位动作

这是第三个概念，其中人工智能交替激活模型，在更像杀戮团队的模式下玩战锤，而不是完全成熟的桌面战争游戏。人工智能将被允许选择一个模型，并采取一系列行动，如站立和射击、 前进和射击、 冲锋、正常移动、等。这将防止大动作的一些问题——当激活一个模型时，AI 有更多的信息，随后将能够以近乎完美的信息玩游戏。

逐模式动作的主要缺点是 40k 不是这么玩的。很接近，但不是完全匹配。这可以通过缓存模型/单位的订单得到部分缓解，这样引擎就可以等到射击阶段再解决射击问题，直到充电阶段再充电，等等。它仍然有一个问题，即人工智能在对玩家的行为做出反应的方式上是有限的——它通常仍然只能使用标准的命令，而不是反动的策略。

以神经网络兼容的方式格式化 40k 的规则

如果我不小心，代理将有可能提交不合法的行动。没有真正的方法来告诉代理一个他们不能做的动作。我们有办法告诉他们不应该做这样的输出，但这不会阻止他们仍然不时地这样做。迫使代理人遵守 40k 规则的唯一真正方法是将行动空间限制在纯粹有效的移动范围内。

无效移动动作示例— 作者图片

例如，让我们使用上面的同一个示例图。我们的三个蓝队都在前进。我们给 AI 代理浮点 X 和 Y 位置输出来表示移动的目的地。如果我们想让一个警卫班几乎完全控制移动位置，它可以有几乎无限的非法移动:重叠基地，移动到无法通行的地形，离开单位一致性，移动到合格距离之外，或移动到交战范围内。

一种解决方案是净化代理的输出。如果代理人的行动会导致非法游戏状态，使用启发式后处理器来做出下一个允许的最佳决策。净化代理输出的缺点是，它只能达到我们的后处理器代码允许的程度。

如果我们想要一个具有卓越的微观和定位的代理，如果我们离开这种“训练轮”，我们并不总是能得到它——它们限制了代理的灵活性和控制力。

我想到的另一个解决方案是让代理人自由支配将模型放在无效的位置上，但是对这样做给予负面的奖励。这样，代理人就不愿意做非法的动作，而愿意做合法的动作。理论上，随着时间的推移，代理人会了解 40k 的规则，通常不会做出违反游戏规则的举动。这里的一个大风险是过度奖励移动的合法性，而低估我们试图训练的实际东西——40k 控制算法！

这可能会导致模型认为它做得很好，而执行愚蠢的动作，如在一条线上来回移动模型。这将导致我们只能成功地训练一个知道 40k 的规则但不知道策略的人工智能。

我们能想到的另一个简单的策略是，当无效的移动被指定时，不采取任何行动，或者将违规的模型移出游戏。这将作为一个有效的强制函数来惩罚 AI 的无效移动，而不必以某种方式计算奖励。这样做的主要风险是再次暴露了不是有效动作的动作空间——它似乎引入了各种各样的问题。

最后一个选项是我们提到的第一件事——将动作空间限制在纯粹有效的移动。虽然原则上很棒，但我对实现每一步可能的动作的巨大复杂性不感兴趣。

部署

渴望离开部署区的大虫子——图片由作者提供

部署是战锤 40k 战略的关键部分。然而，完成部署阶段与游戏的常规回合有很大不同。在我看来，训练一个机器学习模型以某种方式理解部署期间采取的行动和游戏流程中采取的行动之间的差异是相当困难的。

因此，我决定跳过第一次构建的部署阶段。相反，我计划使用一个基本的布局算法来开始。随着这个引擎的其他部分走到一起，我们可以开始考虑让 AI 也可以进行部署。

奖励代理

我想谈的最后一个话题是一个棘手的问题(我猜他们都是，不是吗。)OpenAI 健身房的模特在每走完步()后，都会从我们的环境中收到一个介于-无穷大和+无穷大之间的数字。这被称为奖励，为了从强化学习中获得好的结果，我们必须提供一个好的奖励指标。

一般来说，从一个小的奖励开始，随着时间的推移，随着模型的训练逐渐增加，这被认为是好的。通过这种方式，模型不会在训练开始时过度奖励自己的行为，因为它不太可能是正确的，并且随着训练的进行，开始更多地奖励自己，以磨练真正积极的行为。

对于我们所关心的，在每个步骤()之后返回一个奖励是很棘手的——在我之前提到的任何情况下，手写的算法都不可能知道模型采取的行动是好是坏！如果这是可能的，那么我们就不会使用深度学习来解决这个该死的问题了！我们可以尝试使用某些东西，比如:

• 这个动作是否导致敌方模型被移出桌面？
• 这一行动是否导致我的团队得分？

但这两者都有可能返回误报——在一天结束时，我们只关心人工智能是否赢得了比赛。正因为如此，我们应该只根据胜利和失败进行奖励。达到这一点的所有其他任务都是高度主观和视情况而定的。因此，在步骤()结束时(导致权重不变，中立)，不会向 AI 提供奖励，直到确定游戏是否获胜(在集结束时)。)

插曲

一个情节是一系列相关的步骤。它们通常属于一个连续的序列，如战锤 40k 的单个游戏。一集结束后，我们可以决定要么结束训练，要么开始新的训练。

我的决策概述

经过深思熟虑，以下是我为本文中讨论的这个项目的第一个版本(称为 V0)所做的高层决策:

• 最后的可交付成果是一个开放式人工智能健身房环境。我将把这个环境插入到各种 RL 模型中，看看最终什么会做得好。
• 代理商将在每一集结束时根据胜负获得奖励
• 我将用 Python 编写这个环境，用 PyGame 中的可视化工具
• 我将动作定义为每个单元的动作，尽力模拟完整的规则集。
• 我将通过输入一个离散观察(enum)空间来处理动作变化，告诉代理我希望它执行哪个动作。
• 我省略了许多高级规则，如战略、部署、攻击分配和我的第一版引擎的精神阶段——这简直太多了。
• 除了移动之外，我通过不采取任何行动来处理非法输出——这比编写一大堆代码来试图辨别代理的意图要容易得多。对于移动，我将沿直线移动模型，尽可能靠近所需的位置。

下一步

嗯，说了很多，但没写多少代码。我敢肯定，你们都很兴奋地看到人工智能做什么的一些漂亮的可视化效果——在正义的荣耀中玩 40K。我们会到达那里，但是现在基本的决定已经决定了——为了我自己！

在张量处理器上训练 BERT 文本分类器

原文：https://towardsdatascience.com/training-bert-text-classifier-on-tensor-processing-unit-ce0adc8ae449?source=collection_archive---------37-----------------------

为突尼斯阿拉比齐社交媒体情感分析培训拥抱 TPU 最著名的模特

由作者设计|元素由 cookie-studio ， rawpixel-com

介绍

说阿拉伯语的人通常在社交媒体上用当地方言表达自己，所以突尼斯人使用突尼斯阿拉伯语，它由以拉丁字母形式书写的阿拉伯语组成。**情感分析依靠文化知识和带上下文信息的词义。我们将使用阿拉伯方言和情感分析来解决这个项目中的问题。

比赛在津迪举行，由 AI4D 组织。在这场比赛中，我们获得了训练和测试数据集。训练数据集由阿拉伯文文本和该文本的情感组成。我们需要建立一个模型，并改进我们的指标，以便在竞争领先者排行榜中获得第一名。

数据集是从不同的社交媒体平台收集的，这个项目的目标是预测测试数据集的标签。标签将决定我们的句子是积极的、消极的还是中性的。

描述

在这个项目中，我们将使用 TPU 训练多语言 BERT 模型。

TPU

张量处理单元(TPU)是谷歌开发的人工智能加速器专用集成电路(ASIC)，有助于减少深度学习模型的训练时间，尤其是谷歌自己的 TensorFlow 包张量处理单元。与 PyTorch 相比，在 TensorFlow python 库中在 TPU 上训练深度学习模型要简单得多。

张量处理单元| 维基百科

云 TPUs 资源最大限度地减少了计算线性代数问题的时间，并且使用大多数线性代数来开发机器学习应用。以前，用庞大的数据集训练一个复杂的深度学习模型需要几周时间，但使用 TPUs，训练时间减少到几个小时。谷歌云。

伯特

BERT(来自变形金刚的双向编码器表示)是 Google Research 的研究人员在 2018 年提出的 NLP(自然语言处理模型)。BERT 基本上是 transformer 架构的编码器栈 analyticsvidhya 。最初，当 BERT 发布它时，在许多 NLP 任务的准确性方面采用了其他模型，不久之后，其他研究人员开始使用 BERT 架构，并在不同语言中发布更新更好的模型版本。这就是我们基于 BERT 的多语言封装模型的由来，它在新的低资源语言上表现得相当好。我们的模型是使用最大的维基百科多语言数据语料库对前 104 种语言进行预训练的，要了解更多关于这个模型的信息，请阅读的论文。研究人员使用掩蔽语言建模(MLM)使其对多种语言有效。要了解更多关于该型号的信息，请查看型号卡Bert-base-多语言环境。

伯特多语模式| 拥抱脸

密码

我们将首先设置我们的模型在 TPU 上训练，然后我们将设置我们的超参数来提高性能。我们将加载和训练突尼斯阿拉伯语方言情感分析数据，然后在 ai4d.ai 提供的测试数据集上进行预测。

导入库

我们已经导入了所有必要的库，以便对 BERT 模型进行实验或预训练。

*import tensorflow as tf
import logging
from tensorflow.keras.layers import (
    Dense,
    Flatten,
    Conv1D,
    Dropout,
    Input,
)
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import Adam
from tensorflow.keras import Model
from tensorflow.keras import regularizers
from transformers import BertTokenizer, TFBertModel
import os
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from tqdm import tqdm
tqdm.pandas()
import re
import random*

为 TPU 做准备

该代码尝试检查 TPU 集群，然后初始化 TPU，最后创建一个 TPU 策略，稍后我们将使用该策略在云上训练我们的模型。如果你没有 TPU，代码将根据你的机器转移到 GPU 或 CPU。

*try:
    tpu = tf.distribute.cluster_resolver.TPUClusterResolver()
    tf.config.experimental_connect_to_cluster(tpu)
    tf.tpu.experimental.initialize_tpu_system(tpu)
    strategy = tf.distribute.experimental.TPUStrategy(tpu)
except ValueError:
    strategy = tf.distribute.get_strategy() # for CPU and single GPU
    print('Number of replicas:', strategy.num_replicas_in_sync)*

设置超参数

这些超参数是用于实验的，以便我们可以做出改变并获得更好的结果。目前，这些参数产生了迄今为止最好的结果。

*max_length = 140
batch_size = 16
dev_size = 0.1
num_class = 4*

正在加载 BERT 标记器

使用变形金刚库从拥抱脸下载 BERT tokenizer。

*model_name = "bert-base-multilingual-cased"
tokenizer = BertTokenizer.from_pretrained(model_name)Downloading: 100% 996k/996k [00:00<00:00, 5.62MB/s]Downloading: 100% 29.0/29.0 [00:00<00:00, 950B/s]Downloading: 100% 1.96M/1.96M [00:00<00:00, 11.8MB/s]*

读取列车数据集

数据集可以在这里找到，并且是在麻省理工学院的许可下。

训练数据集包含 70，000 个样本，而我们的测试数据集包含 30，000 个样本。火车数据集有一个包含唯一标识符的 id 列、文本列，其中包含用阿拉伯语写的推文*、和标签*列，其中包含情感 {-1，0，1}。

• ***读取数据:*使用熊猫读取 CSV 文件
• ***删除重复的推文:*这提高了模型的性能
• ***重新映射标签:*这使得编码和解码-1 情感变得容易，并最终提高了我们的性能指标。
• ***培训开发分割:*用于培训和评估。

*train_df = pd.read_csv('../input/aranizi-dailect-training-data/Arabizi-Dailect-Train.csv')

train_df.text = train_df.text.astype(str)
train_df.drop_duplicates(subset=['text'],inplace=True)
train_df.label=train_df.label.map({-1:0,1:2,0:1})
train, dev = train_test_split(train_df, test_size=dev_size, random_state=42)*

加载数据并进行处理

我们使用 transformers batch encode plus 来编码文本数据，并将最大长度限制为 150。我们使用 TensorFlow 函数将我们的标签转换为分类类型，并将其加载到 TensorFlow 数据集，该数据集为模型使用我们的数据做准备。我认为缓存有助于 TPU 存储数据，但你可以删除它或添加它，你的模型将在任何情况下工作。

*def bert_encode(data):
    tokens = tokenizer.batch_encode_plus(
        data, max_length=max_length, padding="max_length", truncation=True
    )
    return tf.constant(tokens["input_ids"])
train_encoded = bert_encode(train.text)
dev_encoded = bert_encode(dev.text)
train_labels = tf.keras.utils.to_categorical(train.label.values, num_classes=num_class)
dev_labels = tf.keras.utils.to_categorical(dev.label.values, num_classes=num_class)
train_dataset = (
    tf.data.Dataset.from_tensor_slices((train_encoded, train_labels))
    .shuffle(100)
    .batch(batch_size)
).cache()
dev_dataset = (
    tf.data.Dataset.from_tensor_slices((dev_encoded, dev_labels))
    .shuffle(100)
    .batch(batch_size)
).cache()*

模型

这个模型受到了卡格尔的笔记本的影响，他使用了 LSTM，而我只是使用了辍学的密集层。Kaggle 还提供 30 小时的免费 TPU，这使得任何人都可以更容易地免费使用云计算。

我们的模型非常简单，我们使用了相同的 BERT 架构，并添加了 3 个密集层，丢失率= 0.3 。我使用了前两层的 relu 激活，对于输出层，我们使用了在 TPU 上表现惊人的 soft plus。

我也试验过双向密集 LSTM 层和简单 LSTM，但这些模型表现不佳。

*def bert_tweets_model():
    bert_encoder = TFBertModel.from_pretrained(model_name, output_attentions=True)
    input_word_ids = Input(
        shape=(max_length,), dtype=tf.int32, name="input_ids"
    )
    last_hidden_states = bert_encoder(input_word_ids)[0]
    clf_output = Flatten()(last_hidden_states)
    net = Dense(512, activation="relu")(clf_output)
    net = Dropout(0.3)(net)
    net = Dense(440, activation="relu")(net)
    net = Dropout(0.3)(net)
    output = Dense(num_class, activation="softplus")(net)
    model = Model(inputs=input_word_ids, outputs=output)
    return model*

编译模型

您需要添加 with strategy.scope():并运行我们的模型，该模型将从 Hugging Face 服务器下载模型并将其加载到模型变量中。您的模型、优化器和模型编译应该在 strategy.scope()下完成，以便在云 TPU 上进行训练。

*with strategy.scope():
    model = bert_tweets_model()
    adam_optimizer = Adam(learning_rate=1e-5)
    model.compile(
        loss="categorical_crossentropy", optimizer=adam_optimizer, metrics=["accuracy"]
    )
    model.summary()Downloading: 100% 625/625 [00:00<00:00, 19.9kB/s]Downloading: 100% 1.08G/1.08G [00:38<00:00, 29.6MB/s]*

模型结构

你可以看到我们用 Dropout 添加的模型结构和密集层。

*Model: "model_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_ids (InputLayer)       [(None, 140)]             0         
_________________________________________________________________
tf_bert_model_1 (TFBertModel TFBaseModelOutputWithPool 177853440 
_________________________________________________________________
flatten_1 (Flatten)          (None, 107520)            0         
_________________________________________________________________
dense_3 (Dense)              (None, 512)               55050752  
_________________________________________________________________
dropout_76 (Dropout)         (None, 512)               0         
_________________________________________________________________
dense_4 (Dense)              (None, 440)               225720    
_________________________________________________________________
dropout_77 (Dropout)         (None, 440)               0         
_________________________________________________________________
dense_5 (Dense)              (None, 4)                 1764      
=================================================================
Total params: 233,131,676
Trainable params: 233,131,676
Non-trainable params: 0
_________________________________________________________________*

培训模式

终于到了我们在 TPU 上训练模型的时候了。该模型在 TPU 上训练需要 17 分钟，在 GPU 上训练需要 45 分钟，在 CPU 上训练需要 2.5 小时。你可以清楚地看到性能差异。通过使用 model.fit ，我们在训练数据集上训练了我们的模型，并使用 dev_dataset 作为验证。我们训练精度随着每个时期以及我们的验证精度而提高。

*history = model.fit(
    train_dataset,
    batch_size=batch_size,
    epochs=5,
    validation_data=dev_dataset,
    verbose=1,
)Epoch 1/5
4166/4166 [==============================] - 313s 60ms/step - loss: 0.7691 - accuracy: 0.6309 - val_loss: 0.4994 - val_accuracy: 0.7810
Epoch 2/5
4166/4166 [==============================] - 246s 59ms/step - loss: 0.5092 - accuracy: 0.7870 - val_loss: 0.4541 - val_accuracy: 0.8027
Epoch 3/5
4166/4166 [==============================] - 248s 59ms/step - loss: 0.4232 - accuracy: 0.8271 - val_loss: 0.4680 - val_accuracy: 0.8081
Epoch 4/5
4166/4166 [==============================] - 247s 59ms/step - loss: 0.3577 - accuracy: 0.8606 - val_loss: 0.4994 - val_accuracy: 0.8103
Epoch 5/5
4166/4166 [==============================] - 247s 59ms/step - loss: 0.2980 - accuracy: 0.8849 - val_loss: 0.6219 - val_accuracy: 0.8166*

节省重量

让我们保存或建模，以便我们可以再次使用它或将其部署为 streamlit web 应用程序。

*model.save_weights('weights.h5', overwrite=True)*

显示损失和准确性

我们可以在下面的线图中看到结果，每个时期我们的训练和验证准确性都有所提高。损失线情节中的故事是非常不同的，在纪元 3 之后损失开始增加。为了在测试数据集上获得更好的结果，我们应该将历元的数量保持在 3。

*import matplotlib.pyplot as plt
def plot_graphs(history, string):
    plt.plot(history.history[string])
    plt.plot(history.history["val_" + string])
    plt.xlabel("Epochs")
    plt.ylabel(string)
    plt.legend([string, "val_" + string])
    plt.show()
plot_graphs(history, "accuracy")
plot_graphs(history, "loss")*

**

预测测试数据集并保存提交

是时候使用我们的微调模型来预测测试数据集上的标签了。我们将重复用于训练数据集和预测标签的步骤。

1. 读取测试数据
2. 编码
3. TF 数据集
4. 批量预测
5. 熊猫提交的数据框
6. 重新映射标签
7. 保存 CSV

*test = pd.read_csv("../input/arabizi-dialect/Test (1).csv")
test.text = test.text.astype(str)
test_encoded = bert_encode(test.text)##Loading Test Data
test_dataset = tf.data.Dataset.from_tensor_slices(test_encoded).batch(batch_size)## Prediction on test Datasets
predicted_tweets = model.predict(test_dataset, batch_size=batch_size)
predicted_tweets_binary = np.argmax(predicted_tweets, axis=-1)## Submisssion 
my_submission = pd.DataFrame({"ID": test.ID, "label": predicted_tweets_binary})
my_submission.label = my_submission.label.map({1: -1, 3: 1, 2: 0})
my_submission.to_csv("/kaggle/working/my_submission.csv", index=False)*

检查课程和结果

我们的模型在测试数据集上表现得相当好，并且仅用很少的实验我们就得到最好的结果。你可以尝试嵌入和其他深度学习架构，以产生更好的结果。你也可以尝试集成多个模型来提高你的准确率。

图片作者| Zindi 测试分数

通过使用值计数，我们可以检查预测标签的分布。

*my_submission.label.value_counts() 1    15356
-1    14208
 0      436*

我希望你喜欢我的工作，请♥并与你的朋友和同事分享它，如果你想阅读更多关于数据科学/机器学习的文章，请在 LinkedIn 和 Polywork 上关注我。

原载于 2021 年 8 月 4 日 https://www.analyticsvidhya.comhttps://www.analyticsvidhya.com/blog/2021/08/training-bert-text-classifier-on-tensor-processing-unit-tpu。**

使用拥抱脸从头开始训练 BPE、单词块和单字标记器

原文：https://towardsdatascience.com/training-bpe-wordpiece-and-unigram-tokenizers-from-scratch-using-hugging-face-3dd174850713?source=collection_archive---------13-----------------------

使用 Hugging Face 的 tokenizers 包比较 SOTA 标记化算法生成的标记

作者图片

继续深入 NLP 的海洋，这篇文章是关于利用humping Face 的 tokenizers 包从头开始训练 tokenizers。

标记化通常被认为是 NLP 的一个子领域，但它有自己的进化故事，以及它是如何达到当前阶段的，它正在支撑最先进的 NLP 模型。

在我们开始训练和比较不同的记号赋予器的有趣部分之前，我想给你一个算法之间的关键区别的简要总结。

主要区别在于选择要合并的字符对和合并策略，这些算法中的每一个用来生成最终的令牌集。

BPE——基于频率的模型

• 字节对编码使用子字模式的频率将它们列入合并的候选名单。
• 使用频率作为驱动因素的缺点是，最终可能会产生模糊的最终编码，这对新的输入文本可能没有用。
• 在生成明确的令牌方面，它仍有改进的余地。

unigram——基于概率的模型

• Unigram 模型通过计算每个子词组合的可能性来解决合并问题，而不是选择最常见的模式。
• 它计算每个子词标记的概率，然后根据损失函数将其丢弃，该损失函数在本研究论文的中有所说明。
• 基于损失值的特定阈值，您可以触发模型丢弃底部 20–30%的子词标记。
• Unigram 是一种完全概率算法，它根据概率选择字符对，并最终决定在每次迭代中合并(或不合并)。

文字片

• 随着 2018 年 BERT 的发布，出现了一种新的子词标记化算法，称为 WordPiece，可以认为是 BPE 和 Unigram 算法的中介。
• WordPiece 也是一种贪婪算法，它利用似然性而不是计数频率来合并每次迭代中的最佳配对，但配对字符的选择是基于计数频率的。
• 因此，在选择要配对的字符方面，它类似于 BPE，在选择要合并的最佳字符对方面，它类似于 Unigram。

考虑到算法上的差异，我尝试实现这些算法中的每一个(不是从头开始)，以比较它们各自生成的输出。

训练 BPE、Unigram 和 WordPiece 算法

现在，为了对输出进行无偏见的比较，我不想使用预先训练的算法，因为这会将数据集的大小、质量和内容带入图片中。

一种方法可能是使用研究论文从头开始编写这些算法，然后测试它们，这是一种很好的方法，以便真正理解每个算法的工作原理，但你可能会花费数周时间来完成这项工作。

相反，我使用了拥抱脸的记号赋予器包，它提供了所有当今最常用的记号赋予器的实现。它还允许我在我选择的数据集上从头开始训练这些模型，然后标记我们自己选择的输入字符串。

训练数据集

我选择了两个不同的数据集来训练这些模型，一个是来自古腾堡的免费书籍，作为一个小数据集，另一个是 wikitext-103 ，它是 516M 的文本。

在 Colab 中，您可以先下载数据集并解压缩(如果需要的话)，

!wget [http://www.gutenberg.org/cache/epub/16457/pg16457.txt](http://www.gutenberg.org/cache/epub/16457/pg16457.txt)!wget [https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip](https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip)!unzip wikitext-103-raw-v1.zip

导入所需的模型和训练器

浏览文档，你会发现这个包的主要 API 是类Tokenizer.

然后，您可以用您选择的模型(BPE/ Unigram/ WordPiece)实例化任何记号化器。

在这里，我导入了主类，所有我想测试的模型，以及它们的训练器，因为我想从头开始训练这些模型。

## importing the tokenizer and subword BPE trainer
from tokenizers import Tokenizer
from tokenizers.models import BPE, Unigram, WordLevel, WordPiece
from tokenizers.trainers import BpeTrainer, WordLevelTrainer, \
                                WordPieceTrainer, UnigramTrainer## a pretokenizer to segment the text into words
from tokenizers.pre_tokenizers import Whitespace

自动化培训和令牌化的 3 步流程

因为我需要为三个不同的模型执行有些相似的过程，所以我将这些过程分成三个函数。我只需要为每个模型调用这些函数，我在这里的工作就完成了。

那么，这些函数是什么样子的呢？

步骤 1 —准备标记器

准备 tokenizer 需要我们用我们选择的模型实例化 tokenizer 类，但是因为我们有四个模型(还添加了一个简单的单词级算法)要测试，我们将编写 if/else 案例来用正确的模型实例化 Tokenizer。

为了在小型和大型数据集上训练实例化的记号赋予器，我们还需要实例化一个训练器，在我们的例子中，它们是[**BpeTrainer**](https://huggingface.co/docs/tokenizers/python/latest/api/reference.html#tokenizers.trainers.BpeTrainer)**, WordLevelTrainer, WordPieceTrainer, and UnigramTrainer.**

实例化和训练将需要我们指定一些特殊的令牌。这些是未知单词的标记和其他特殊标记，我们以后需要使用它们来增加我们的词汇。

您还可以在此指定其他训练参数的词汇大小或最小频率。

unk_token = "<UNK>"  # token for unknown words
spl_tokens = ["<UNK>", "<SEP>", "<MASK>", "<CLS>"]  # special tokensdef prepare_tokenizer_trainer(alg):
    """
    Prepares the tokenizer and trainer with unknown & special tokens.
    """
    if alg == 'BPE':
        tokenizer = Tokenizer(BPE(unk_token = unk_token))
        trainer = BpeTrainer(special_tokens = spl_tokens)
    elif alg == 'UNI':
        tokenizer = Tokenizer(Unigram())
        trainer = UnigramTrainer(unk_token= unk_token, special_tokens = spl_tokens)
    elif alg == 'WPC':
        tokenizer = Tokenizer(WordPiece(unk_token = unk_token))
        trainer = WordPieceTrainer(special_tokens = spl_tokens)
    else:
        tokenizer = Tokenizer(WordLevel(unk_token = unk_token))
        trainer = WordLevelTrainer(special_tokens = spl_tokens)

    tokenizer.pre_tokenizer = Whitespace()
    return tokenizer, trainer

我们还需要添加一个预标记器来将我们的输入拆分成单词，因为没有预标记器，我们可能会得到重叠几个单词的标记:例如，我们可以得到一个**"there is"**标记，因为这两个单词经常相邻出现。

使用预标记器将确保没有标记大于预标记器返回的单词。

该函数将返回 tokenizer 及其 trainer 对象，可用于在数据集上训练模型。

这里，我们对所有模型使用相同的预标记器(Whitespace)。可以选择用其他来测试。

步骤 2 —培训分词器

准备好记号赋予者和训练者之后，我们就可以开始训练过程了。

这里有一个函数，它将获取我们打算用来训练我们的标记器的文件以及算法标识符。

• ‘WLV’ -词级算法
• ‘WPC’ -计件算法
• ‘BPE’ -字节对编码
• ‘UNI’ -单字

def train_tokenizer(files, alg='WLV'):
    """
    Takes the files and trains the tokenizer.
    """
    tokenizer, trainer = prepare_tokenizer_trainer(alg)
    tokenizer.train(files, trainer) # training the tokenzier
    tokenizer.save("./tokenizer-trained.json")
    tokenizer = Tokenizer.from_file("./tokenizer-trained.json")
    return tokenizer

这是我们在训练分词器时需要调用的主要函数，它将首先准备分词器和训练器，然后用提供的文件开始训练分词器。

训练之后，它将模型保存在一个 JSON 文件中，从该文件中加载它，并返回经过训练的标记器，开始对新输入进行编码。

步骤 3 —对输入字符串进行标记

最后一步是开始对新的输入字符串进行编码，并比较每个算法生成的标记。

这里，我们将编写一个嵌套的 for 循环，首先在较小的数据集上训练每个模型，然后在较大的数据集上训练，并标记输入字符串。

输入字符串— “这是一个深度学习的记号化教程。标记化是深度学习 NLP 管道的第一步。我们将比较每个令牌化模型生成的令牌。很兴奋吗？！😍"

small_file = ['pg16457.txt']
large_files = [f"./wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]for files in [small_file, large_files]:
    print(f"========Using vocabulary from {files}=======")
    for alg in ['WLV', 'BPE', 'UNI', 'WPC']:
        trained_tokenizer = train_tokenizer(files, alg)
        input_string = "This is a deep learning tokenization tutorial. Tokenization is the first step in a deep learning NLP pipeline. We will be comparing the tokens generated by each tokenization model. Excited much?!😍"
        output = tokenize(input_string, trained_tokenizer)
        tokens_dict[alg] = output.tokens
        print("----", alg, "----")
        print(output.tokens, "->", len(output.tokens))

# #输出:

作者图片

输出分析:

查看输出，您将看到令牌生成方式的差异，这反过来导致生成不同数量的令牌。

• 一个简单的单词级算法创建了 35 个标记，不管它是在哪个数据集上被训练的。
• BPE 算法在较小数据集上训练时创建了 55 个令牌，在较大数据集上训练时创建了 47 个令牌。这表明，当在更大的数据集上训练时，它能够合并更多的字符对。
• Unigram 模型为两个数据集创建了数量相似(68 和 67)的令牌。但是您可以看到生成的令牌之间的差异:

作者图片

对于更大的数据集，合并更接近于生成更适合编码我们经常使用的真实世界英语语言的标记。

作者图片

• 在较小的数据集上训练时，WordPiece 创建了 52 个令牌，在较大的数据集上训练时，创建了 48 个令牌。生成的标记有两个##，表示标记用作前缀/后缀。

由作者制作的图像

• 当在更大的数据集上训练时，这三种算法都生成了更少和更好的子词标记。

比较令牌

为了比较标记，我将每个算法的输出存储在一个字典中，并将它转换成一个数据帧，以便更好地查看标记的差异。

由于每个模型生成的令牌数量不同，我添加了一个令牌来使数据呈矩形并适合一个数据帧。

基本上是数据帧中的 nan。

import pandas as pdmax_len = max(len(tokens_dict['UNI']), len(tokens_dict['WPC']), len(tokens_dict['BPE']))
diff_bpe = max_len - len(tokens_dict['BPE'])
diff_wpc = max_len - len(tokens_dict['WPC'])tokens_dict['BPE'] = tokens_dict['BPE'] + ['<PAD>']*diff_bpe
tokens_dict['WPC'] = tokens_dict['WPC'] + ['<PAD>']*diff_wpcdel tokens_dict['WLV']df = pd.DataFrame(tokens_dict)
df.head(10)

# #输出:

作者图片

您还可以使用集合来查看标记的差异:

作者图片

作者图片作者图片

所有的代码都可以在这个 Colab 笔记本里找到。

结束想法和后续步骤！

根据生成的标记的种类，WPC 似乎确实生成了在英语中更常见的子词标记，但我并不认为这是一种观察结果。

这些算法彼此略有不同，但在开发一个像样的 NLP 模型方面做得有些类似。但是大部分性能取决于语言模型的用例、词汇量、速度和其他因素。

这些算法的进一步发展是 SentencePiece 算法，这是一种解决整个标记化问题的有益方法，但这个问题的大部分通过 HuggingFace 得以缓解，甚至更好的是，他们在单个 GitHub repo 中实现了所有算法。

这就结束了标记化算法，下一步是理解什么是嵌入，标记化如何在创建这些嵌入中发挥重要作用，以及它们如何影响模型的性能。

参考文献和注释

如果你不同意我的分析或我在这篇文章中的任何工作，我强烈建议你查看这些资源，以准确理解每个算法的工作原理:

1. 子词正则化:改进神经网络翻译模型使用拥抱脸从头开始训练 BPE、单词块和单字标记器
2. 具有子词单元的稀有词的神经机器翻译 —讨论基于 BPE 压缩算法的不同分割技术的研究论文。
3. 拥抱脸的 tokenizer 包。

和我联系！

如果你想在数据科学或 ML 领域起步，请查看我的课程 数据科学基础& ML 。

如果你想看到更多这样的内容，并且你不是订阅者，可以考虑订阅我的简讯。

如有任何补充或建议，您可以通过以下方式联系我:

• YouTube
• 推特
• 领英

在您自己的数据集上训练 DETR

原文：https://towardsdatascience.com/training-detr-on-your-own-dataset-bcee0be05522?source=collection_archive---------8-----------------------

什么是 DETR？是什么让它在对象检测算法的世界中脱颖而出？而你是怎么用自己的数据训练它的？

照片由 note thanun 在 Unsplash 上拍摄

DETR——或检测变压器——是脸书基于深度学习的物体检测解决方案市场的最新成员。简单地说，它利用 transformer 架构来预测图像中的对象及其位置。

什么是 DETR？

来源:https://s content . fbll 1-1 . FNA . FBC dn . net/v/t 39.8562-6/101177000 _ 245125840263462 _ 1160672288488554496 _ n . pdf？_ NC _ cat = 104&CCB = 1-3&_ NC _ sid = ae5e 01&_ NC _ OHC = oki PD 6 ovnkkax 968 fln&_ NC _ ht = s content . fbll 1-1 . FNA&oh = ab 6 dcdc 2307471 a 56 fdbe 2 ebb 98 faf 6b&OE = 606 Abd 47

DETR 是一个联合卷积神经网络(CNN)和变压器，以前馈网络为头。这种架构允许网络使用由 CNN 提取的特征，使用 Transformer 架构中固有的强大多头注意力机制，可靠地推理图像中的对象关系。

来源:https://colab . research . Google . com/github/Facebook research/detr/blob/colab/notebooks/detr _ demo . ipynb

简单地说，网络能够估计图像中任何一点与图像其余部分的关系。给定一个样本点，自我注意地图显示周围区域与该点正相关的可能性。在上面的例子中，这意味着尽管有两只猫和两个遥控器，网络的注意力可以通过观察每个区域与其他区域的关系来区分不同的情况。

来源:https://colab . research . Google . com/github/Facebook research/detr/blob/colab/notebooks/detr _ attention . ipynb

上图显示了四个样本点和它们的自我关注地图。这些表示网络假定与每个点相关的区域。最终，每个注意力头可以被聚集在一个包含多个边界框和匹配概率分布的解决方案中。该解决方案基于大量的对象查询，或自动提供这些样本点的学习位置嵌入。每个输出嵌入通过一个共享的前馈网络，该网络估计上述检测(包围盒和分类概率)或*无对象。*流程结果如下所示:

来源:https://colab . research . Google . com/github/Facebook research/detr/blob/colab/notebooks/detr _ attention . ipynb

DETR 与其他物体探测器有何不同？

所有对象检测算法都有其优点和缺点；R-CNN (及其衍生)是一个两步算法，需要区域提议计算和检测计算。最近的进展，如 SSD (单次多盒检测器)和 YOLO (你只看一次)被称为单级物体检测器，因为它们在单次向前传递中计算它们的估计。他们如何实现这一点的细节各不相同，但这些网络的一个共同点是要求“先验知识”。

先验是锚盒、标度、网格大小、重复检测识别算法以及用于降低问题维度的类似技术。它们最终用于对输入进行下采样，或者在某些情况下，用于避免计算量大的区域提议步骤。通过应用这些技术，问题从计算问题转变为人类观察者的问题，因为他们必须在训练开始之前估计和提供这些先验。

相比之下，DETR 是对象检测问题的直接集合解决方案。基于上述学习到的位置嵌入，网络提供了许多估计的边界框和类得分。然而，DETR 并非没有先验信息。例如，在开始训练之前，需要手动设置置信度阈值之前的估计边界框的数量，并且应该“明显大于图像中对象的典型数量”。

我如何为自己训练 DETR？

DETR 通常需要非常密集的训练计划。在原始论文中，作者使用 16 个 Nvidia V100 GPUs 在 300 个时期内训练他们的模型，总共超过 3 天的训练时间(在 AWS 大约 4000 美元)。您可以自己尝试一下，但这不是本节的内容。我们对在个人数据集上微调预训练的 DETR 模型感兴趣，可能使用不同于 COCO 的类别数。

我们的 DETR 分叉(在这里找到:https://github.com/aivclab/detr)允许我们通过改变一些关键元素来做到这一点。首先，我们改变模型构建结构以支持任意数量的类。然后，我们将预训练模型的权重(没有类嵌入)提供给构建器。此外，我们将随机变换中图像的最大宽度改为 800 像素。这应该允许在大多数 GPU 上进行训练，但如果您的 GPU 可以处理它，建议改回原来的 1333。默认情况下，我们会将头部的学习速度和主干的学习速度分别降低到 1e-5 和 1e-6，但是您可以自行调整。

根据数据集中的样本数量，最好从头开始重新训练模型。原始 COCO 数据集有超过 200，000 个带注释的图像，超过 150 万个实例，分布在 90 多个类中，因此如果您的数据集具有可比性，它可能会改进您的培训计划，以便在笔记本中设置pretrained = False。

笔记本在这里找到:https://github . com/aivclab/detr/blob/master/fine tune _ detr . ipynb

下面的示例参数显示了如何简单地为自己微调这样一个模型:

微调 DETR 很容易。来源:https://github . com/aivclab/detr/blob/master/fine tune _ detr . ipynb

结论

DETR 是物体探测领域令人激动的一步。它标志着先验知识的显著减少和简单、易于配置的网络架构。在大多数任务中，它的表现优于速度更快的 R-CNN，而不需要太多专门的额外工作，尽管它仍然比可比的单级对象检测器慢。其简单的结构使其易于根据研究人员提供的强大基线进行重建、实验和微调。

我在 Alexandra Institute 工作，这是一家丹麦非营利公司，专门研究最先进的 it 解决方案。在视觉计算实验室，我们专注于利用最新的计算机视觉和计算机图形研究。我们目前正在探索技术，以允许较小的公司和个人开始深度学习。我们永远欢迎合作！

脸书深度学习模型的训练效率

原文：https://towardsdatascience.com/training-efficiency-of-deep-learning-models-from-facebook-862816cd20da?source=collection_archive---------56-----------------------

影响深度学习推荐模型的关键因素

沙哈达特·拉赫曼在 Unsplash 上拍摄的照片

在脸书人工智能研究所发表的一项研究中，讨论了深度学习模型的训练效率，展示了与行业和学术界相关的模型架构和物理基础设施的数据。

深度学习模型效率的重要性

深度学习模型被科技巨头广泛使用。根据脸书人工智能研究公司的数据，以下公司利用深度学习推荐模型:谷歌、微软、网飞、阿里巴巴、脸书/Instagram。此外，像特斯拉汽车和 Waymo 团队这样的公司正在与 PyTorch 和 TensorFlow 一起做令人印象深刻的工作。从 Andrej Karpathy 关于特斯拉工作的视频中可以看到特斯拉的一瞥。该视频强调了用海量数据集训练深度学习模型的重要挑战。

从脸书人工智能研究看深度学习模型的效率

在论文“理解深度学习推荐模型在规模上的训练效率”中，脸书 AI Research 讨论了训练深度学习推荐模型的关键方面和挑战。我绝对鼓励读者深入研究那篇论文。然而，这篇文章似乎是强调那篇论文中发现的几个关键方面的最佳和合适的地方，这些方面可能对机器学习工程师和数据科学家有用。

首先，“并非所有的培训工作流都是相同的”，这直接来自论文，因为它们强调了培训持续时间的差异，这取决于输入模型的数据类型。下图描述了各种工作负载的培训持续时间和培训频率，即新闻馈送、搜索数据、语言翻译和人脸检测。

图片由作者提供，灵感来自脸书人工智能研究

可以看出，并非所有的训练工作流都是相同的，尽管这是一个相当直观的说法，但理解深度学习模型如何工作的特殊性是有用的。例如，语言翻译比搜索和新闻提要更难训练。

深度学习推荐模型的一个关键挑战是嵌入表格。脸书人工智能研究强调，嵌入表格有很大的内存需求，这激励了行业进一步开发他们的分布式训练系统。如果术语“嵌入表格”不清楚，我推荐读者查看这篇论文以获得进一步的解释(链接到期刊论文)。此外，谷歌机器学习速成班提供了一个关于嵌入的很好的教程(链接此处

另一个要考虑的重要特征是批量大小。根据 Goyal 等人(2018) 的说法，这是一个关键的超参数，直接影响训练表现和模型质量。总体而言，下图显示了批量大小如何影响脸书研究的深度学习推荐模型的准确性损失。

图片作者，灵感来自脸书人工智能研究

可以看出，批量越大，损失值越高。尽管 0.2%的损失看起来微不足道，但该期刊论文已经证明了 0.1-0.2%的损失对于推荐模型来说是不可容忍的(特别是在脸书的规模下)。

结束语

最后，我想鼓励读者通读这篇期刊论文，因为它有更多关于深度学习模型的其他挑战的数据，如硬件和系统配置。

总而言之，让我们记住批处理大小和嵌入表是需要记住的事情，至少对于大型数据集是如此。另外，请记住“并非所有的培训工作流程都是相同的”。

感谢您的阅读，感谢您对本文的任何反馈。你可以在我的 GitHub 页面上看到我在机器学习方面的公开工作，并随时关注我或通过 LinkedIn 联系我。

训练生成性对抗网络(提供代码)

原文：https://towardsdatascience.com/training-generative-adversarial-network-with-codes-2a6af80cf1f0?source=collection_archive---------23-----------------------

打造您的 GAN 系列——第 4 部分，共 4 部分

图片由com break来自 Pixabay

生成敌对网络(GANs)是强大的模型，它学习产生难以与现有真实对象区分的现实对象，如图像和音频(语音/音乐)。

在之前的教程中，我们已经看到了 GAN 中的两个组件——T4 发生器和鉴别器。

在本教程中，我们将合并生成器和鉴别器，并开始训练模型。

这是构建你的生成性敌对网络的第 4 部分:

第一部分:生成对抗网络背后的直觉
第二部分:甘鉴别器背后的直觉
第三部分:甘生成器背后的直觉
第四部分:训练生成对抗网络(本)

笔记本:训练甘生成手写数字
GitHub repo :包含本教程系列

鉴频器损耗

首先，我们给生成器输入一个随机噪声，生成器会产生一些假样本。这些生成的样本与来自数据集的真实样本一起被输入到鉴别器中。

鉴别器将试图区分样品是真的还是假的。这产生了将在二进制交叉熵损失函数中使用的概率，以与真实标签(真实或虚假)进行比较，并确定错误率和反向传播以更新鉴别器的参数。

发电机损耗

然后，我们来训练发电机。同样，我们将噪声向量输入生成器，它会生成一些假样本。这些假样本被送入鉴别器(这次没有真样本)。

鉴别器做出预测，产生这些样本有多假的概率。这些概率在二进制交叉熵损失函数中进行计算，以与真实标签进行比较，因为当鉴别器将这些生成的样本分类为真实时，生成器得分。根据错误率，我们将反向传播并更新生成器的参数。

训练循环

在训练过程中，我们交替进行训练，使得在任何时候只有一个网络被训练，在生成器和鉴别器之间交替。

我们的目标是确保两个网络具有相似的技能水平。因此，两个网络不能同时更新。否则，鉴别器的性能将优于生成器；因为鉴别器学习区分真假样本要比生成器学习生成样本容易得多。

两个网络都需要以相似的速度改进

为什么两个网络应该一起提高，并保持在相似的技能水平？如果鉴别器优于生成器，则所有生成的样本都被分类为 100%假的，因为“100%假”(概率1假)损失函数对于网络学习是没有用的。因此没有学习的机会。

0.7为假的概率对于网络在反向传播期间更新参数更有意义。(额外:在一个强化学习的情境中，任务是如此的困难，以至于无论代理做什么都失败了，才能给出任何奖励。)

同样，假设发生器优于鉴别器。在这种情况下，来自鉴别器的预测都是 100%真实的，鉴别器将没有机会学会区分真实和伪造的样本。

概括起来

鉴别器的目标是最小化真假样本之间的错误分类造成的损失。而生成器的目标是最大化鉴别者成为real的概率。

在培训过程中，我们在生成器和鉴别器之间交替进行培训，以确保他们的技能水平相似。

笔记本:训练甘生成手写数字
GitHub repo :包含本教程系列

仅使用 JSON 训练 ML 模型

原文：https://towardsdatascience.com/training-ml-model-using-just-json-d69eb5d147c4?source=collection_archive---------20-----------------------

用尼龙创建自然语言表示的机器学习模型

阿瑟尼·托古列夫在 Unsplash 上的照片

机器学习建模是一项艰巨的任务，因为首先，我们需要准备数据，执行特征工程，为建模做好准备，然后创建不同的机器学习模型，以找出性能最佳的模型。但是，如果我告诉您，您可以使用 JSON 文件用几行代码完成所有这些工作，会怎么样呢？是的，你没看错。

我们只需要创建一个 JSON 文件，在其中定义目标变量和运行数据所需的模型列表。同样，我们也可以对数据进行预处理，在将数据传递给模型之前对其进行操作。在 JSON 文件中，我们只需要传递我们需要执行的操作的自然语言表示。

Nylon 是一个开源的 Python 库，它使用普通英语以 JSON 语法轻松构建机器学习模型。在这篇文章中，我们将探索尼龙及其功能。

让我们开始吧…

安装所需的库

我们将从使用 pip 安装尼龙开始。下面给出的命令可以做到这一点。

!pip install nylon

导入所需的库并创建尼龙对象

在这一步中，我们将导入创建 ML 模型所需的库。在执行任何操作之前，我们只需要初始化一个对象，并传递我们将要处理的数据的路径。在这里，我将向您展示如何创建一个对象并将数据传递给它。

from nylon import Polymer
nylon_object = Polymer('/content/diabetes.csv')

在这里，您可以看到我已经将数据集的路径作为参数传递给了对象。

创建 JSON 代码/文件

我们可以创建一个 JSON 文件或 JSON 风格的代码，用于建模。下面给出的代码创建了这个模型。模型的名称可以用作随机森林的“rf”，梯度下降的“sgd”，等等。

json_file = {
    "data": {
        "target": "Outcome"
    },
    "preprocessor": {
        "fill": "ALL",

    },
    "modeling": {
        "type": ["svms", "neighbors", "rf", "mlp","sgd"]
    }
}

在这里，您可以看到我们已经传递了目标变量、预处理器和我们需要创建的所有模型。如果我们没有通过任何预处理程序，它会自动处理。通过运行这段代码，我们将能够创建 JSON 文件/代码，之后，我们可以通过传递 JSON 文件来运行 nylon 对象，这将运行模型。

nylon_object.run(json_file)

来源:作者

分析结果

在最后一步中，我们将分析我们创建的所有模型的结果，并查看哪个模型的性能最好。

nylon_object.results

结果(来源:作者)

在这里，我们可以分析所有模型的结果，并选择性能最佳的模型。尼龙非常容易使用，可以很容易地集成到机器学习工作流中。

继续尝试不同的数据集，并执行机器学习模型。如果您发现任何困难，请在回复部分告诉我。

本文是与 Piyush Ingale 合作完成的。

在你走之前

感谢 的阅读！如果你想与我取得联系，请随时联系我在 hmix13@gmail.com 或我的 LinkedIn 简介 。可以查看我的Github简介针对不同的数据科学项目和包教程。还有，随意探索 我的简介 ，阅读我写过的与数据科学相关的不同文章。

使用亚马逊 SageMaker 自动驾驶仪检测信用卡欺诈的训练模型

原文：https://towardsdatascience.com/training-models-to-detect-credit-card-frauds-with-amazon-sagemaker-autopilot-d49a6b667b2e?source=collection_archive---------14-----------------------

亚马逊 Sagemaker Autopilot 如何帮助你快速训练模型

米卡·鲍梅斯特在 Unsplash 上的照片

典型的数据科学项目生命周期经历许多阶段。第一阶段是理解业务和数据，随后是数据准备、模型训练、模型评估和生产部署。这些阶段并不简单。它们乏味、重复，并且仅限于少数有技能的个人，如研究人员、数据科学家和 ML 工程师。

实际上，数据科学家花大量时间做重复性的任务，比如清理、寻找和准备用于训练模型的数据。其中一些重复性的任务可以自动化。

对智能系统的需求持续增长，然而大多数组织缺乏资源来满足需求。许多企业都在争夺人工智能(AI)领域的稀缺人才，这一事实只会让情况变得更糟。

所有这些结合在一起使 AutoML 变得必不可少。AutoML 允许你将 ML 自动化并应用于商业问题。它为那些没有理论知识的人提供了 AI 开发的途径。

这篇文章将着眼于亚马逊的 AutoML 产品(亚马逊 SageMaker Autopilot ),并应用它来训练一个检测信用卡欺诈的模型。

如果你正在寻找这篇文章所用代码的 Jupyter 笔记本的链接，请点击这里。

亚马逊 SageMaker 自动驾驶仪

2019 年宣布， SageMaker Autopilot 是亚马逊的 AutoML 产品，允许你建立、训练端到端的 ML 模型。它通过浏览数据来简化您的任务，找到最适合您的数据的最佳算法，并为模型调整和训练准备数据。

自动驾驶仪为每次试验生成笔记本，因为它试图为你的数据选择最佳算法。这些笔记本显示了数据是如何争论的，以及模型选择过程的细节。这些笔记本还提供指导材料，教你关于训练过程和如何训练你自己的实验。

亚马逊 SageMaker 自动驾驶仪的一些好处

SageMaker Autopilot 的一些额外优势包括:

• ML 模型的自动训练
• 自动特征工程
• 提供培训过程的可见性
• 如何挑选候选人的逐步说明
• 如果需要，您可以灵活地手动调整您的模型
• 您可以从 UI 和 SDK 中使用它，从而为自动化留出空间。

虽然您可以使用 AutoML 来自动化机器学习(ML)过程以实现各种目的，如价格预测、流失预测、风险评估等。在本教程中，我们将使用亚马逊 SageMaker 自动驾驶仪来训练一个检测欺诈交易的模型。

亚马逊 SageMaker 自动驾驶仪的自动模型训练

欺诈交易有一些具体特征，可以通过学习将它们与合法交易区分开来。我不会在这篇文章中深入探讨这些特征。我们将使用托管在 Kaggle 上的现有公共数据集。该数据集包含 2013 年 9 月欧洲持卡人的信用卡交易。

对于本教程的其余部分，我们将遵循下列步骤:

1. 在亚马逊 SageMaker 上创建一个笔记本
2. 获取数据
3. 检查数据
4. 准备数据
5. 创建一个亚马逊 SageMaker 自动驾驶作业
6. 探索培训结果

在亚马逊 SageMaker 上创建新笔记本

登录 AWS 云，创建一个新的笔记本。如果您没有帐户，您可以在这里创建一个新帐户。

获取数据

要将数据集下载到您的笔记本，请按照以下说明授予您的笔记本对 Kaggle 的访问权限。

• 登录 Kaggle
• 单击您的个人资料图片，然后从下拉菜单中单击帐户。
• 向下滚动到 API 部分。
• 单击“创建新的 API 令牌”按钮，以 JSON 文件的形式下载一个新的令牌，该文件包含用户名和 API 密钥。
• 将 JSON 文件复制到~/。kaggle/该目录如下面的代码示例所示

!mkdir ~/.kaggle!echo '{"username":"your-user-name","key":"your-key"}' >> ~/.kaggle/kaggle.json !chmod 600 /home/ec2-user/.kaggle/kaggle.json

授予 Kaggle 笔记本访问权限

检查数据

用 panda 加载 CSV 数据并检查数据。

!kaggle datasets download -d  "arockiaselciaa/creditcardcsv"dataset_path = './creditcard.csv'import pandas as pddf = pd.read_csv(dataset_path)
pd.set_option('display.max_columns', 500)
pd.set_option('display.max_rows', 10)
df

准备数据集

我们将做一些预处理。在此步骤中，我们将执行以下操作:

• 将数据分成训练和测试数据集
• 将拆分上传至 s3 时段

测试数据将用于稍后执行推理。

df = df.drop(['Amount', 'Time'], axis = 1)
train_data = df.sample(frac=0.8, random_state=200)
test_data = df.drop(train_data.index)test_data_no_y = test_data.drop(columns=['Class'])
test_data_no_y.head()

将训练数据集上传至 s3

train_file = 'train_data.csv'
train_data.to_csv(train_file, index=False, header=True)
train_path = session.upload_data(path=train_file, key_prefix=prefix + "/train")
print(f"Upload file to {train_path}")

我们将对测试数据集做同样的事情

test_file = 'test_data.csv'
test_data_no_y.to_csv(test_file, index=False, header=False)
test_path = session.upload_data(path=test_file, key_prefix=prefix + "/test")
print(f"Upload file to {test_path}")

创建亚马逊 SageMaker 自动驾驶作业

为了找到性能最佳的模型，我们首先需要配置自动驾驶仪的工作、输入数据和输出数据。

我们使用下面的代码片段配置自动驾驶仪的工作

auto_ml_job_config = {
        'CompletionCriteria': {
            'MaxCandidates': 5
        }
    }input_data_config = [{
      'DataSource': {
        'S3DataSource': {
          'S3DataType': 'S3Prefix',
          'S3Uri': 's3://{}/{}/train'.format(bucket, prefix)
        }
      },
      'TargetAttributeName': 'Class'
    }
  ]output_data_config = {
    'S3OutputPath': 's3://{}/{}/output/'.format(bucket, prefix)
  }from time import gmtime, strftime, sleep
timestamp_suffix = strftime('%d-%H-%M-%S', gmtime())auto_ml_job_name = f'automl-fraudcase-{timestamp_suffix}'
print(f"AutoMLJobName:{auto_ml_job_name}")

现在，我们创建实际的自动驾驶仪的工作

role = get_execution_role()
sm = boto3.Session().client(service_name='sagemaker',region_name=region)
sm.create_auto_ml_job(AutoMLJobName=auto_ml_job_name,
                      InputDataConfig=input_data_config,
                      OutputDataConfig=output_data_config,
                      AutoMLJobConfig=auto_ml_job_config,
                      RoleArn=role)

SageMaker Autopilot 分析数据集，以开发一个应在数据上尝试的 ML 管道列表。它还对数据执行要素工程，例如对每个数据集要素执行要素变换。最后，它执行模型调整，选择性能最好的管道。

您可以使用describe _ auto _ ml _ jobAPI将信息返回给 SageMaker 自动驾驶仪的作业。

我们将利用 describe_auto_ml_jon API 来监控正在运行的作业的进度，如下面的代码所示:

print('JobStatus  Secondary Status')print('-------------------------------------')
describe_response = sm.describe_auto_ml_job(AutoMLJobName=auto_ml_job_name)
print(f"{describe_response['AutoMLJobStatus']} - {describe_response['AutoMLJobSecondaryStatus']}")job_run_status = describe_response['AutoMLJobStatus']

while job_run_status not in ('Failed', 'Completed', 'Stopped'):

      describe_response = sm.describe_auto_ml_job(AutoMLJobName=auto_ml_job_name)
      job_run_status = describe_response['AutoMLJobStatus']print(f"{describe_response['AutoMLJobStatus']} - {describe_response['AutoMLJobSecondaryStatus']}")
      sleep(30)

使用最佳候选人进行批量推断

在训练了一些模型之后，这里，我们将使用 SageMaker 自动驾驶仪提供的最佳候选来执行批量推理工作。步骤如下:

• 从最佳候选中创建模型
• 使用 Amazon SageMaker 自动驾驶作业利用批量推理

您可以使用最佳候选项创建模型，如下所示:

model_name = 'automl-fraudcase-model-' + timestamp_suffixmodel = sm.create_model(Containers=best_candidate['InferenceContainers'],
                            ModelName=model_name,
                            ExecutionRoleArn=role)print('Model ARN corresponding to the best candidate is : {}'.format(model['ModelArn']))

创建一个匹配转换作业:

transform_job_name = 'automl-fraudcase-transform-' + timestamp_suffixtransform_input = {
        'DataSource': {
            'S3DataSource': {
                'S3DataType': 'S3Prefix',
                'S3Uri': test_path
            }
        },
        'ContentType': 'text/csv',
        'CompressionType': 'None',
        'SplitType': 'Line'
    }transform_output = {
        'S3OutputPath': 's3://{}/{}/inference-results'.format(bucket, prefix),
    }transform_resources = {
        'InstanceType': 'ml.m5.4xlarge',
        'InstanceCount': 1
    }sm.create_transform_job(TransformJobName = transform_job_name,
                        ModelName = model_name,
                        TransformInput = transform_input,
                        TransformOutput = transform_output,
                        TransformResources = transform_resources
)

最后，您可以看到 Autopilot 试图为您的数据找到最佳算法时生成的模型列表，如下所示:

candidates = sm.list_candidates_for_auto_ml_job(AutoMLJobName=auto_ml_job_name, SortBy='FinalObjectiveMetricValue')['Candidates']
index = 1
for candidate in candidates:
  print(f"{str(index)} {candidate['CandidateName']} {str(candidate['FinalAutoMLJobObjectiveMetric']['Value'])}")
  index += 1

生成的笔记本

亚马逊 SageMaker Autopilot 生成笔记本，让你深入了解训练过程以及模型是如何选择的，如前所述。

你可以在这里找到生成的笔记本。

参考

信用卡欺诈数据集
亚马逊 SageMaker 示例