PyTorch 亲笔签名
理解 PyTorch 魔法的核心
来源:https://www . cs . Toronto . edu/~ rgrosse/courses/CSC 321 _ 2018/slides/LEC 10 . pdf
资料来源:http://bumpybrains.com/comics.php?comic=34
让我们只是同意，当涉及到大型神经网络时，我们都不擅长微积分。通过显式求解数学方程来计算如此大的复合函数的梯度是不切实际的，尤其是因为这些曲线存在于大量的维度中并且是不可能理解的。
为了处理 14 维空间中的超平面，想象一个 3 维空间并大声对自己说“14”。每个人都这样做——杰弗里·辛顿
这就是 PyTorch 的亲笔签名的来源。它抽象了复杂的数学，帮助我们“神奇地”用几行代码计算高维曲线的梯度。这篇文章试图描述亲笔签名的魔力。
PyTorch 基础
在继续之前，我们需要了解一些基本的 PyTorch 概念。
Tensors :简单来说就是 PyTorch 中的一个 n 维数组。Tensors 支持一些额外的增强功能，这使它们独一无二:除了 CPU，它们还可以加载到 GPU 上进行更快的计算。在设置.requires_grad = True时，它们开始形成一个反向图，跟踪应用于它们的每一个操作，以使用一种叫做动态计算图(DCG)的东西来计算梯度(在帖子中进一步解释)。
在 PyTorch 的早期版本中， *torch.autograd.Variable* 类用于创建支持梯度计算和操作跟踪的张量，但从 PyTorch v0.4.0 变量类开始， 已被弃用。 torch.Tensor和torch.autograd.Variable现在是一个档次。更准确地说，torch.Tensor能够追踪历史，并且表现得像旧的Variable
Code to show various ways to create gradient enabled tensors
****亲笔签名:这个类是一个计算导数的引擎(更准确地说是雅可比向量积)。它记录了在梯度张量上执行的所有操作的图形，并创建了一个称为动态计算图的非循环图形。这个图的叶子是输入张量，根是输出张量。梯度的计算方法是从根到叶追踪图形，并使用链式法则将每个梯度相乘。
神经网络和反向传播
神经网络只不过是经过微妙调整(训练)以输出所需结果的复合数学函数。调整或训练是通过一种叫做反向传播的非凡算法来完成的。反向传播用于计算损失相对于输入权重的梯度，以便稍后更新权重并最终减少损失。
在某种程度上，反向传播只是链式法则——杰瑞米·霍华德的别称
创建和训练神经网络包括以下基本步骤:
- 定义架构
- 使用输入数据在架构上向前传播
- 计算损失
- 反向传播以计算每个权重的梯度
- 使用学习率更新权重
输入权重的微小变化引起的损失变化称为该权重的梯度，使用反向传播进行计算。然后，使用学习率将梯度用于更新权重，以总体减少损失并训练神经网络。
这是以迭代的方式完成的。对于每次迭代，都要计算几个梯度，并建立一个称为计算图的东西来存储这些梯度函数。PyTorch 通过构建一个动态计算图(DCG)来做到这一点。该图是在每次迭代中从头开始构建的，为梯度计算提供了最大的灵活性。例如，对于前向操作(函数)Mul来说，称为MulBackward的后向操作(函数)被动态集成到后向图中，用于计算梯度。
动态计算图
启用梯度的张量(变量)与函数(运算)结合起来创建动态计算图。数据流和应用于数据的操作是在运行时定义的，因此可以动态地构建计算图。此图由引擎盖下的亲笔签名类动态制作。在开始训练之前，你不必对所有可能的路径进行编码——你跑的就是你与众不同的。
两个张量相乘的简单 DCG 如下所示:
DCG with requires_grad = False (Diagram created using draw.io)
图中的每个虚线框是一个变量，紫色矩形框是一个操作。
每个变量对象都有几个成员，其中包括:
数据:变量保存的数据。 x 保存一个值等于 1.0 的 1x1 张量，而 y 保存 2.0。 z 表示两者的乘积，即 2.0
requires_grad :该成员，如果为 true，则开始跟踪所有的操作历史，并形成一个用于梯度计算的反向图。对于任意张量 a 它可以被就地操作如下:a.requires_grad_(True).
grad: grad 保存渐变的值。如果requires_grad为假，它将保持一个 None 值。即使requires_grad为真，它也将保持一个 None 值，除非从其他节点调用.backward()函数。例如，如果您为某个变量 out 调用out.backward()，该变量在其计算中涉及，那么x.grad将持有 ∂out/∂x 。**
grad_fn: 这是用于计算梯度的反向函数。
is_leaf :如果:
- 它是由类似于
x = torch.tensor(1.0)或x = torch.randn(1, 1)的函数显式初始化的(基本上是本文开头讨论的所有张量初始化方法)。 - 它是在对所有具有
requires_grad = False.的张量进行运算后创建的 - 它是通过在某个张量上调用
.detach()方法创建的。
在调用backward()时，只为requires_grad和is_leaf都为真的节点填充渐变。渐变是从调用.backward()的输出节点开始的，相对于其他叶节点。
打开requires_grad = True时，PyTorch 将开始跟踪操作，并存储每个步骤的梯度函数，如下所示:
DCG with requires_grad = True (Diagram created using draw.io)
PyTorch 引擎下生成上图的代码是:
来源:https://www . cs . Toronto . edu/~ rgrosse/courses/CSC 321 _ 2018/slides/LEC 10 . pdf
为了阻止 PyTorch 跟踪历史和形成后向图，可以将代码包装在with torch.no_grad():中，这将使代码在不需要梯度跟踪时运行得更快。
Backward()函数
Backward 是这样一个函数，它实际上是通过将其参数(默认情况下是 1x1 单位张量)通过后向图一直传递到可从调用根张量追踪到的每个叶节点来计算梯度的。然后将计算出的梯度存储在每个叶节点的.grad中。记住，反向图形已经在正向传递过程中动态生成。Backward function 仅使用已经制作的图形计算梯度，并将它们存储在叶节点中。
让我们分析下面的代码
需要注意的一件重要事情是，当调用z.backward()时，一个张量被自动作为z.backward(torch.tensor(1.0))传递。torch.tensor(1.0)是为终止链式法则梯度乘法而提供的外部梯度。该外部梯度作为输入传递给MulBackward函数，以进一步计算 x 的梯度。传入.backward()的张量的维数必须与正在计算梯度的张量的维数相同。例如，如果梯度使能张量 x 和 y 如下:
x = torch.tensor([0.0, 2.0, 8.0], requires_grad = True)
y = torch.tensor([5.0 , 1.0 , 7.0], requires_grad = True)
和z = x * y
然后，为了计算z(1×3 张量)相对于x或y的梯度，需要将外部梯度传递给 z.backward()函数，如下所示:z.backward(torch.FloatTensor([1.0, 1.0, 1.0])
*z.backward()*会给一个*RuntimeError: grad can be implicitly created only for scalar outputs*
传递给后向函数的张量的作用类似于梯度加权输出的权重。从数学上来说，这是向量乘以非标量张量的雅可比矩阵(在本文中进一步讨论)，因此它几乎总是与张量backward 维数相同的单位张量，除非需要计算加权输出。
tldr:反向图是由自动签名的类在正向传递过程中自动动态创建的。
Backward()简单地通过将参数传递给已经制作好的反向图来计算梯度。
数学——雅可比和向量
从数学上来说，亲笔签名的类只是一个雅可比矢量积计算引擎。一个雅可比矩阵用非常简单的话来说就是一个表示两个向量所有可能偏导数的矩阵。它是一个向量相对于另一个向量的梯度。
注意:在这个过程中 PyTorch 从不显式地构造整个 Jacobian。直接计算 JVP(雅可比向量积)通常更简单、更有效。
如果一个向量X =【x1，x2，…。xn]* 用于计算其他一些向量 f(X) = [f1，f2，…。fn] 通过函数 f 然后雅可比矩阵( J )简单地包含所有偏导数组合如下:***
Jacobian matrix (Source: Wikipedia)
以上矩阵表示 f(X) 相对于 X 的梯度
假设 PyTorch 梯度启用张量 X 为:
X = [x1，x2，……xn] (假设这是某个机器学习模型的权重)
X 经过一些运算形成一个矢量 Y
Y = f(X) = [y1，y2，…。ym]
Y 然后用于计算标量损失 l. 假设向量 v 恰好是标量损失 l 的梯度，关于向量 Y 如下
向量 v 被称为 *grad_tensor* 并作为自变量传递给 *backward()* 函数
为了得到损失 l 相对于权重 X 的梯度，雅可比矩阵 J 被向量乘以向量 v
这种计算雅可比矩阵并将其与矢量 v 相乘的方法使得 PyTorch 能够轻松提供外部梯度，即使是非标量输出。
进一步阅读
PyTorch:自动分化包—torch . autogradated
视频:PyTorch 亲笔签名讲解——深度教程作者埃利奥特·韦特
感谢您的阅读！欢迎在回复中表达任何疑问。
PyTorch 深度学习模板
一个干净简单的模板来启动你的下一个 dl 项目🚀🚀
这里的模板是这里的
在本文中，我们将向您展示一个基于 Pytorch 的深度学习模板。这个模板旨在让你更容易用 PyTorch 开始一个新的深度学习计算机视觉项目。主要特点是:
- 模块化:我们将每个逻辑块分成不同的 python 子模块
- 数据扩充:我们包括了伊姆高格
- 蓄势待发:通过使用类似 Keras 的框架 poutyne ，你不必编写任何 train 循环。
- 火炬摘要展示您的模型摘要
- 在稳定期降低学习率
- 自动保存最佳模型
- 用彗星进行实验跟踪
动机
让我们面对它，通常，数据科学家不是软件工程师，他们通常以意大利面条代码结束，大部分时间在一个大的不可用的木星笔记本上。有了这个 repo，你已经提出了一个清晰的例子，说明你的代码应该如何拆分和模块化，以使可伸缩性和可共享性成为可能。在这个例子中，我们将尝试对达斯·维德和卢克·天行者进行分类。我们用谷歌图片收集了每个班级 100 张图片。数据集在这里是这里是。你只需要在这个文件夹中精确它并运行 main.py。我们正在微调 resnet18，它应该能够在 5/10 个周期内达到 90%的准确性。
模板在./template里面。
我们强烈建议使用模板
保持你的结构干净简洁
每个深度学习项目至少有三个主要步骤:
- 数据收集/处理
- 建模
- 培训/评估
一个好主意是将所有路径存储在一个感兴趣的位置，例如数据集文件夹，存储在一个共享类中，该文件夹中的任何人都可以访问它。你不应该硬编码任何路径，总是定义一次并导入它们。所以，如果你以后改变你的结构，你只需要修改一个文件。如果我们看一下Project.py，我们可以看到我们是如何一劳永逸地定义了data_dir和checkpoint_dir。我们正在使用“新的”路径API，它支持开箱即用的不同操作系统，并且还使加入和连接路径变得更加容易。
例如，如果我们想知道数据位置，我们可以:
from Project import project
print(projct.data_dir) # /foo/baa/…/dataset
在data包中，您可以定义自己的数据集，一如既往地通过子类化torch.data.utils.Dataset，公开转换和实用程序来处理您的数据。在我们的例子中，我们直接使用了来自torchvision的ImageDataset，但是我们在/data/MyDataset中包含了一个定制Dataset的框架
转换
您通常需要对数据进行一些预处理，例如调整图像大小和应用数据扩充。你所有的转变都应该在.data.trasformation里面。在我们的模板中，我们包含了一个 imgaug 的包装器
数据加载器
如您所知，您必须创建一个Dataloader来将您的数据输入到模型中。在data.__init__.py文件中，我们公开了一个非常简单的函数get_dataloaders，使用几个参数自动配置训练、val 和测试数据加载器
你所有的模型都在models里面，在我们的例子中，我们有一个非常基本的 cnn，我们覆盖resnet18函数来提供一个冻结的模型来微调。
在我们的例子中，我们保持事情简单，所有的训练和评估逻辑都在.main.py中，我们使用 poutyne 作为主库。我们已经定义了一个有用的回调列表:
- 学习率调度程序
- 最佳模型的自动保存
- 通常提前停止，这就是你所需要的！
追踪你的实验
我们使用彗星来自动跟踪我们模型的结果。这是慧星的板子运行了几个模型后的样子。
运行main.py产生以下输出:
我们还创建了不同的工具函数来绘制展位数据集和数据加载器。他们在utils.py。例如，在我们的 train 和 val 数据集上调用show_dl会产生以下输出。
正如你所看到的，数据扩充被正确地应用在训练集上。
这里的代码是这里是
结论
我希望你能找到一些有用的信息，希望这个模板能对你下一个令人惊叹的项目有所帮助:)
如果你有什么改进的想法/建议，请告诉我。
您可能也会发现这些文章很有趣:
弗朗西斯科·萨维里奥·祖皮奇尼
towardsdatascience.com](/a-journey-into-convolutional-neural-network-visualization-1abc71605209)
感谢您的阅读。
深度学习 PyTorch:初学者快速指南
2019 年，ML 框架的战争有两个主要竞争者: PyTorch 和 TensorFlow 。由于 PyTorch 易于使用，越来越多的研究人员和学生采用 py torch，而在工业界，Tensorflow 目前仍是首选平台。
PyTorch 的一些主要优势包括:
- 简单性:它非常 Python 化，可以很容易地与 Python 生态系统的其他部分集成。它易于学习、使用、扩展和调试。
- PyTorch 在可用性方面大放异彩，因为它设计了更好的面向对象的类，这些类封装了所有重要的数据选择以及模型架构的选择。PyTorch 的文档也很出彩，对初学者很有帮助。
- 动态图: PyTorch 实现了动态计算图。这意味着网络可以在运行时改变行为，只需很少或不需要开销。这对于调试和以最小的努力构建复杂的模型非常有帮助。允许 PyTorch 表达式自动区分。
PyTorch 在研究中越来越受欢迎。下图显示了在其他深度学习框架中，单词“PyTorch”每月被提及的次数占所有被提及次数的百分比。我们可以看到，2019 年 arXiv 中 PyTorch 的上升趋势非常明显，几乎达到了 50%。
arXiv papers mentioning PyTorch is growing
动态图形生成，紧密的 Python 语言集成，以及相对简单的 API使得 PyTorch 成为一个优秀的研究和实验平台。
装置
PyTorch 提供了一个非常简洁的界面来获得要安装的工具的正确组合。下面是快照选择和相应的命令。Stable 代表 PyTorch 的最新测试和支持版本。这个应该适合很多用户。预览是可用的，如果你想要最新的版本，没有完全测试和支持。您可以从 Anaconda(推荐)和 Pip 安装包中进行选择，并支持各种 CUDA 版本。
PyTorch 模块
现在我们将讨论 PyTorch 库的关键模块，如张量、亲笔签名、优化器和神经网络(NN ) ，它们对于创建和训练神经网络是必不可少的。
张量
张量是 PyTorch 的主力。我们可以把张量想象成多维数组。PyTorch 有一个由 torch 模块提供的大量操作库。PyTorch 张量非常接近非常流行的 NumPy 阵列。事实上，PyTorch 具有与 NumPy 无缝互操作的特性。与 NumPy 数组相比，PyTorch 张量增加了一个优势，即张量和相关操作都可以在 CPU 或 GPU 上运行。PyTorch 提供的第二个重要功能是允许张量跟踪对它们执行的操作，这有助于计算输出相对于任何输入的梯度或导数。
基本张量运算
张量是指将向量和矩阵推广到任意维数。张量的维数与用于引用张量内标量值的索引的数量一致。零阶张量(0D 张量)只是一个数字或者一个标量。一阶张量(1D 张量)是一组数字或一个矢量。类似地，二阶张量(2D)是一组向量或一个矩阵。
现在让我们在 PyTorch 中创建一个张量。
导入 torch 模块后，我们调用了一个函数 torch.ones ，它创建了一个大小为 9 的(2D)张量，其中填充了值 1.0。
其他方式包括使用**t*orch.zeros****；零填充张量，***torch.randn***，；*来自随机均匀分布。
类型和尺寸
每个张量都有相关的类型和大小。使用**torch.Tensor**构造函数时，默认的张量类型是**torch.FloatTensor**。但是，您可以将张量转换为不同的类型(**float** 、、**long**、、、**double**等)。)通过在初始化时或稍后使用类型转换方法之一指定它。指定初始化类型有两种方法:要么直接调用特定张量类型的构造函数，如**FloatTensor** 或**LongTensor**，要么使用特殊的方法 **torch.tensor()**，并提供**dtype**.
一些有用的张量运算:
找出张量中的最大值项以及包含最大值的索引。这些可以通过***max()***和***argmax()***功能完成。我们还可以使用**item()**从 1D 张量中提取标准的 Python 值。
大多数对张量进行操作并返回张量的函数都会创建一个新的张量来存储结果。如果你需要一个 就地 函数，寻找一个附加了下划线(
*_*)的函数，例如***torch.transpose_***将对一个张量进行就地转置。
使用***torch.from_numpy*** & ***torch.numpy()*** ，张量和 Numpy 之间的转换非常简单。
另一个常见的操作是 重塑 一个张量。这是经常使用的操作之一，也非常有用。我们可以用***view()***或***reshape()***来做这件事:
***Tensor.reshape()***和***Tensor.view()***虽然不一样。
***Tensor.view()***只作用于连续的张量，并且永远不会复制内存。这将在非连续张量上引起误差。但是你可以通过调用***contiguous()***使张量连续，然后你可以调用***view()***。***Tensor.reshape()***将对任何张量起作用，如果需要的话可以克隆。
张量广播
PyTorch 支持类似 NumPy 的广播。广播可以让你在两个张量之间进行运算。广播语义参见这里的。
张量简而言之:什么，如何在哪里
唯一定义张量的三个属性是:
dtype: 张量的每个元素中实际存储的是什么？这可以是浮点数或整数等。PyTorch 有九种不同的数据类型。
布局:我们如何从逻辑上解释这个物理内存。最常见的布局是步进张量。跨距是一个整数列表:第 k 个跨距表示从张量的第 k 维中的一个元素到下一个元素所必需的内存跳跃。
设备:张量的物理内存实际存储在哪里，例如在 CPU 或 GPU 上。**torch.device**包含设备类型('**cpu**'或'**cuda**')和设备类型的可选设备序号。
亲笔签名
亲笔签名是自动区分系统。自动微分是干什么的？给定一个网络，它会自动计算梯度。当计算向前传球时，自动签名同时执行请求的计算并建立一个表示计算梯度的函数的图形。
这是如何实现的？
PyTorch 张量可以根据产生它们的操作和父张量来记住它们来自哪里，并且它们可以自动提供这种操作相对于它们的输入的导数链。这是通过**requires_grad** 实现的，如果设置为真。
**t= torch.tensor([1.0, 0.0], requires_grad=True)**
计算完梯度后，导数的值被自动填充为张量的**grad** 属性。对于具有任意数量张量的函数的任意组合用**requires_grad= True**；PyTorch 将计算整个函数链的导数，并在这些张量的**grad** 属性中累加它们的值。
优化者
优化器用于更新权重和偏差，即模型的内部参数，以减少误差。更多细节请参考我的另一篇文章。
PyTorch 有一个**torch.optim**包，里面有各种优化算法，比如 SGD(随机梯度下降)、Adam、RMSprop 等。
让我们看看如何创建一个提供的优化器 SGD 或 Adam。
**import torch.optim as optim
params = torch.tensor([1.0, 0.0], requires_grad=True)****learning_rate = 1e-3****## SGD
optimizer = optim.SGD([params], lr=learning_rate)****## Adam
optimizer = optim.Adam([params], lr=learning_rate)**
如果不使用优化器，我们将需要手动更新模型参数，如下所示:
**for params in model.parameters():
params -= params.grad * learning_rate**
我们可以使用优化器中的**step()**方法向前迈进一步，而不是手动更新每个参数。
**optimizer.step()**
调用 step 时，params 的值会更新。优化器查看**params.grad**，并通过从中减去**learning_rate** 乘以**grad** 来更新**params** ，就像我们在没有使用优化器的情况下所做的一样。
**torch.optim** 模块通过传递一个参数列表，帮助我们抽象出具体的优化方案。由于有多种优化方案可供选择，我们只需要为我们的问题选择一种，然后让底层 PyTorch 库为我们施展魔法。
神经网络
在 PyTorch 中,**torch.nn**包定义了一组类似于神经网络层的模块。模块接收输入张量并计算输出张量。**torch.nn**包还定义了一组训练神经网络时常用的有用损失函数。
构建神经网络的步骤是:
- **神经网络构建:**创建神经网络层。设置参数(权重、偏差)
- **正向传播:**计算预测输出。测量误差。
- **反向传播:**找到误差后，我们反向传播我们的误差梯度以更新我们的权重参数。我们通过对误差函数相对于我们的神经网络的参数进行求导来做到这一点。
- **迭代优化:**我们要尽可能的把误差降到最低。我们通过梯度下降不断迭代更新参数。
建立一个神经网络
让我们按照上面的步骤，在 PyTorch 中创建一个简单的神经网络。
第一步:神经网络构建
我们这里把我们的 NN **Net** 叫做**。**我们继承了**nn.Module**。与super().__init__()结合，这创建了一个跟踪架构的类，并提供了许多有用的方法和属性。
我们的神经网络**Net**有一个隐含层**self.hl**和一个输出层 **self.ol**。
**self.hl = nn.Linear(1, 10)**
这一行创建了一个具有 1 个输入和 10 个输出的线性变换模块。它还会自动创建权重和偏差张量。一旦用**net.hl.weight**和**net.hl.bias**创建了网络**net**，就可以访问权重和偏差张量。
我们已经使用**self.relu = nn.ReLU()**定义了激活。
第二步:正向传播
用**nn.Module**创建的 PyTorch 网络必须定义一个**forward()**方法。它接受一个张量**x**并通过您在**__init__**方法中定义的操作传递它。
**def** forward(self, x):
hidden = self.hl(x)
activation = self.relu(hidden)
output = self.ol(activation)
我们可以看到，输入张量经过隐层，然后是激活函数(relu)，最后是输出层。
步骤 3:反向传播
这里，我们必须计算误差或损失，并反向传播我们的误差梯度，以更新我们的权重参数。
损失函数获取(输出，目标)并计算一个估计**output** 离**target**有多远的值。在**torch.nn**包下有几个不同的损失函数。一个简单的损失是**nn.MSELoss**，它计算输入和目标之间的均方误差。
**output = net(input)
loss_fn = nn.MSELoss()
loss = loss_fn(output, target)**
反向投影
一个简单的函数调用**loss.backward()** 传播错误。不要忘记清除现有的梯度，否则梯度将积累到现有的梯度。调用**loss.backward()**后，查看反向调用前后的隐藏层偏差梯度。
所以在调用 backward()之后，我们看到渐变是为隐藏层计算的。
步骤 4:迭代优化
我们已经看到 optimizer 如何帮助我们更新模型的参数。
***# create your optimizer*
optimizer = optim.Adam(net.parameters(), lr=1e-2)****optimizer.zero_grad() *# zero the gradient buffers*****output = net(input) # calculate output
loss = loss_fn(output, target) #calculate loss
loss.backward() # calculate gradient****optimizer.step() *# update parameters***
请注意不要错过**zero_grad()** 来电。如果你错过调用它，梯度会在每次调用 backward 时累积，你的梯度下降不会收敛。下面是 Andrej 最近的一条推文，展示了修复这些漏洞的沮丧和时间。
现在，我们的基本步骤(1，2，3)已经完成，我们只需要迭代训练我们的神经网络，以找到最小的损失。所以我们运行**training_loop** 多次，直到损失最小。
让我们运行我们的神经网络来训练输入**x_t**和目标**y_t**。
我们称**training_loop** 为 1500 个时代，可以通过所有其他的论点，如**optimizer**、**model**、**loss_fn**、、**inputs**、**、**和**target**。每 300 个周期后，我们打印损失，我们可以看到每次迭代后损失都在减少。看起来我们最基本的神经网络正在学习。
我们绘制了模型输出(黑叉)和目标数据(红圈)，模型似乎学得很快。
到目前为止，我们已经讨论了 PyTorch 的基本或必要元素，以帮助您入门。我们可以看到我们构建的代码是如何模块化的，每个组件都提供了基本块，可以根据我们的要求进一步扩展以创建机器学习解决方案。
为实际问题创建基于机器学习的解决方案涉及到大量的数据准备工作。然而，PyTorch 库提供了许多工具来使数据加载变得容易和更具可读性，如分别处理图像、文本和音频数据的**torchvision**、**torchtext** 和**torchaudio**、、。
训练机器学习模型通常非常困难。当我们遇到一些问题时，总是需要一个工具来帮助可视化我们的模型和理解训练进度。tensor board就是这样一个工具，帮助我们记录来自模型训练的事件，包括各种标量(如精度、损失)、图像、直方图等。自从 PyTorch 1.2.0 发布以来，TensorBoard 现在是 PyTorch 的内置特性。请按照本和本教程安装和使用 Pytorch 中的张量板。
谢谢你的阅读。下一篇文章再见:)
参考资料:
[2]https://pytorch.org/
https://www.kdnuggets.com/2018/05/wtf-tensor.html
PyTorch 基础
PyTorch 是最著名的深度学习框架之一。我个人更喜欢 PyTorch，因为它的 pythonic 性质。很容易将每一行代码都视为一个函数，有清晰的输入和输出。
在这篇文章中，我将讨论在使用 PyTorch 进行深度学习时起关键作用的以下基本结构和操作。
- 矩阵或张量
- 张量运算
- 变量和梯度
矩阵或张量
矩阵被正式定义为“数字的矩形阵列”。在 numpy 图书馆，他们被称为“ndarrays ”,而在 PyTorch，他们被称为“男高音”。
Taken from https://www.onlinemathlearning.com/matrices-rows-columns.html
上图所示的张量是一个 3 行 2 列的 2D 张量。让我们看看如何在 PyTorch 中创建张量。
**import** numpy **as** np
**import** torch
*# 1) Create a PyTorch Tensor an array* arr = [[3, 4], [8, 5]] *# python array* pyt_tensor = torch.Tensor(arr) *# PyTorch tensor
# 2) Create a tensor* ones_tensor = torch.ones((2, 2)) *# tensor containing all ones* torch.manual_seed(0) *# to have same values for random generation* rand_tensor = torch.rand((2, 2)) *# tensor containing random values
# if running on GPU, set random seed value as follows* **if** torch.cuda.is_available():
torch.cuda.manual_seed_all(0)
*# 3) Create a tensor from numpy array (dtype must be either double, float, int64, int32, or uint8)* np_arr = np.ones((2, 2))
pyt_tensor = torch.from_numpy(np_arr)
np_arr_from_tensor = pyt_tensor.numpy() *# convert tensor to numpy array*
张量运算
所有适用于数组的运算也适用于张量。下面是 PyTorch 中的做法。
**import** numpy **as** np
**import** torch
*# 1) Resizing a tensor* pyt_tensor = torch.ones((2, 2))
print(pyt_tensor.size()) *# shows the size of this tensor* pyt_tensor = pyt_tensor.view(4) *# resizing 2x2 tensor to 4x1
# 2) Mathematical Operations* pyt_tensor_a = torch.ones((2, 2))
pyt_tensor_b = torch.ones((2, 2))
res_tensor = pyt_tensor_a + pyt_tensor_b *# simple element wise addidtion* res_tensor = torch.add(pyt_tensor_a, pyt_tensor_b) *# another way of addidtion* pyt_tensor_a.add_(pyt_tensor_b) *# In-place addition
# Operation operator function_name
# => Addition + add
# => Subtraction - sub
# => Multiplication * mul
# => Divide / div
# 3) Mean and Standart deviation* pyt_tensor = torch.Tensor([1, 2, 3, 4, 5])
mean = pyt_tensor.mean(dim=0) *# if multiple rows then dim = 1* std_dev = pyt_tensor.std(dim=0) *# if multiple rows then dim = 1*
变量和梯度
梯度计算是深度学习中的关键事情之一。在 PyTorch 中，变量用于计算梯度。本质上，变量只是张量的包装，具有梯度计算的功能。
以下是用于管理变量的 python 代码
****import** numpy **as** np
**import** torch
**from** torch.autograd **import** Variable
pyt_var = Variable(torch.ones((2, 2)), requires_grad = **True**)
*# behaves exactly the same as tensors, so we can apply all operations in the same way***
现在，我们来看看如何在 PyTorch 中使用变量来计算梯度。
****import** numpy **as** np
**import** torch
**from** torch.autograd **import** Variable
*# let's consider the following equation
# y = 5(x + 1)^2* x = Variable(torch.ones(1), requires_grad = **True**)
y = 5 * (x + 1) ** 2 *# implementing the equation.* y.backward() *# calculate gradient* print(x.grad) *# get the gradient of variable x
# differentiating the above mentioned equation
# => 5(x + 1)^2 = 10(x + 1) = 10(2) = 20***
这篇文章中提到的事情非常简单直接，但也非常重要。如果基础知识以正确的方式学习，框架的知识会增长得很快。我自己发现偶尔回顾一下这些基础知识是很有用的，可以避免在实际编写代码时不必要的时间延迟。
Pytorch 闪电 vs PyTorch Ignite vs Fast.ai
Apparently a lion, bear, and tiger are friends
PyTorch-lightning 是一个最近发布的库，是 PyTorch 的一个类似 Kera 的 ML 库。它将核心培训和验证逻辑留给您，并将其余部分自动化。(顺便说一句，我说的 Keras 是指没有样板，没有过度简化)。
作为《闪电》的核心作者，我几次被问到《闪电》和 fast.ai、 PyTorch ignite 的核心区别。
在这里，我将尝试对所有三个框架进行客观的比较。这种比较来自于在所有三个框架的教程和文档中客观发现的相似性和差异。
注意:本文捕获了撰写本文时(2019 年 8 月)这些框架中可用的特性。这些框架有更新的版本。
动机
Ummmm
Fast.ai 最初是为了便于教授 fast.ai 课程而创建的。它最近还演变成一个常用方法的实现库，如 GANs、RL 和迁移学习。
PyTorch Ignite 和 Pytorch Lightning 都是为了给研究人员尽可能多的灵活性，要求他们为训练循环和验证循环中发生的事情定义函数。
Lightning 还有另外两个更加雄心勃勃的动机:可复制性和民主化的最佳实践，只有 PyTorch 超级用户才会实施(分布式培训、16 位精度等等)。我将在后面的章节中详细讨论这些动机。
因此，在基本层面上，目标用户是明确的:对于 fast.ai 来说，它是对深度学习感兴趣的人，而另外两个则专注于活跃的人工智能研究人员(即生物学家、神经科学家等)
学习曲线
Framework Overload
Lightning 和 Ignite 都有非常简单的界面，因为大部分工作仍然由用户在纯 PyTorch 中完成。主要工作分别发生在发动机和训练器物体内部。
然而，Fast.ai 确实需要在 PyTorch 上学习另一个库。大多数时候，API 并不直接在纯 PyTorch 代码上操作(有些地方是这样的)，但是它需要像 DataBunches 、 DataBlocs 等抽象。当做某事的“最佳”方式不明显时，这些 API 非常有用。
然而，对于研究人员来说，重要的是不必学习另一个库，直接控制研究的关键部分，如数据处理，而无需其他抽象操作。
在这种情况下，fast.ai 库具有更高的学习曲线，但如果您不一定知道做某事的“最佳”方法，而只想采用好的方法作为黑盒，那么这是值得的。
闪电 vs 点燃
More like sharing
从上面可以清楚地看到，考虑到用例和用户的不同，将 fast.ai 与这两个框架进行比较是不公平的(然而，我仍然会将 fast.ai 添加到本文末尾的比较表中)。
Lightning 和 ignite 之间的第一个主要区别是它的操作界面。
在 Lightning 中，有一个标准接口(见 LightningModule )包含每个模型必须遵循的 9 个必需方法。
这种灵活的形式为培训和验证提供了最大的自由度。这个接口应该被认为是一个 系统， 不是一个模型。系统可能有多个模型(GANs、seq-2-seq 等),也可能是 as 模型，比如这个简单的 MNIST 例子。
因此，研究人员可以随心所欲地尝试许多疯狂的事情，只需担心这 9 种方法。
Ignite 需要非常相似的设置，但没有每个型号都需要遵循的标准 接口。
注意运行功能可能有不同的定义，即:可能有许多不同的事件被添加到训练器中，或者它甚至可能被命名为不同的名称，如 main、train 等……
在一个复杂的系统中，训练可能会以奇怪的方式发生(看看你的 GANs 和 RL)，对于查看这些代码的人来说，发生了什么并不明显。而在 Lightning 中，您会知道查看 training_step 来弄清楚发生了什么。
再现性
When you try to reproduce work
正如我提到的，创造闪电还有第二个更远大的动机:再现性。
如果你试图阅读某人对一篇论文的实现，很难弄清楚发生了什么。我们只是设计不同的神经网络架构的日子已经一去不复返了。
现代 SOTA 模型实际上是 系统、，它们采用许多模型或训练技术来实现特定的结果。
如前所述，LightningModule 是一个 系统 ，而不是一个模型。因此，如果你想知道所有疯狂的技巧和超级复杂的训练发生在哪里，你可以看看训练步骤和验证步骤。
如果每个研究项目和论文都使用 LightningModule 模板来实现，那么就很容易发现发生了什么(但可能不容易理解哈哈)。
人工智能社区的这种标准化也将允许生态系统蓬勃发展，该生态系统可以使用 LightningModule 接口来做一些很酷的事情，如自动部署，审计系统的偏差，甚至支持将权重散列到区块链后端，以重建用于可能需要审计的关键预测的模型。
现成的功能
Ignite 和 Lightning 的另一个主要区别是 Lightning 支持开箱即用的功能。开箱即用意味着您没有额外的代码。
为了说明，让我们尝试在同一台机器上的多个 GPU 上训练一个模型
点燃( 演示 )
闪电( 演示 )
好吧，两者都不错…但是如果我们想在许多机器上使用多 GPU 呢？让我们在 200 个 GPU 上训练。
点燃
…
嗯，对此没有内置的支持…你必须对这个例子进行一些扩展，并添加一个容易提交脚本的方法。然后你必须负责加载/保存，而不是用所有的进程覆盖权重/日志，等等…你明白了吧。
闪电
使用 lightning，您只需设置节点数量并提交适当的作业。这里有一个关于正确配置作业的深入教程。
开箱即用的特性是您 不需要做任何事情就能获得的特性。 这意味着你现在可能不需要它们中的大部分，但当你需要说…积累渐变，或渐变剪辑，或 16 位训练时，你不会花几天/几周的时间通读教程来让它工作。
只要设置合适的闪电标志，继续你的研究。
Lightning 预建了这些功能，因此用户可以花更多时间进行研究，而不是进行工程设计。这对于非 CS/DS 研究人员特别有用，例如物理学家、生物学家等，他们可能不太熟悉编程部门。
这些特性使 PyTorch 的特性民主化，只有超级用户才可能花时间去实现。
下面的表格比较了所有 3 个框架的功能，并按功能集进行了分组。
如果我错过了什么重要的东西，请发表评论，我会更新表格！
高性能计算
调试工具
可用性
结束语
在这里，我们对三个框架进行了多层次的深入比较。每个人都有自己的优点。
如果你刚刚开始学习或者没有掌握所有最新的最佳实践，不需要超高级的培训技巧，并且有时间学习新的库，那么就用 fast.ai 吧。
如果你需要最大的灵活性，选择点燃闪电。
如果你不需要超级先进的功能，并且可以添加你的 tensorboard 支持、累积梯度、分布式训练等，那么就用 Ignite 吧。
如果您需要更多高级功能、分布式培训、最新和最棒的深度学习培训技巧，并且希望看到一个实现在全球范围内标准化的世界，请使用 Lightning。
编辑:
2019 年 8 月:编辑以反映 Ignite 团队的反馈。
2021 年 2 月:正在进行研究以验证 Fast.ai v1.0.55 中可用的功能
PyTorch 1.3 —有什么新功能？
支持 Android 和 iOS，命名张量，TPU 支持，量化和更多。
脸书刚刚发布了 PyTorch v1.3，它包含了一些最令人期待的特性。最吸引人的三个是:
- 名为张量——这将使机器学习实践者的生活变得更加容易。
- 量化 —针对物联网设备和嵌入式系统等性能关键型系统。
- 移动支持 —适用于 Android 和 iOS 设备。
我将简要介绍所有这些功能，并将链接到其他一些重要功能。
名为张量
PyTorch v1.3 最终增加了对命名张量的支持，允许用户使用显式关联的名称访问张量维度，而不是记住维度编号。例如，到目前为止，在与计算机视觉相关的任务中，我们必须记住批处理的一般结构，如下所示— [N，C，H，W]。其中 N 是批量大小，C 是通道数量，H 和 W 分别是图像的高度和宽度。在对这个批处理执行操作时，我们必须跟踪这样一个结构，但是现在我们可以只使用维度名称，而不是跟踪它的索引。此外，这些命名表示可以提供增强的运行时错误检查。我将在本文中进一步讨论它们。
Creating Named Tensors.
batch.names按顺序打印张量batch上每个维度的名称。
按名称对齐
使用[align_as()](https://pytorch.org/docs/master/named_tensor.html#torch.Tensor.align_as)或[align_to()](https://pytorch.org/docs/master/named_tensor.html#torch.Tensor.align_to)将张量维度按名称排列成指定的顺序。
在计算机视觉模型中，批次的表示通常需要在N，C，H，W和N，H，W，C之间变化。到目前为止，这必须像batch.permute([0, 2, 3, 1])一样反直觉地完成，但是现在可以通过使用[align_as()](https://pytorch.org/docs/master/named_tensor.html#torch.Tensor.align_as)或[align_to()](https://pytorch.org/docs/master/named_tensor.html#torch.Tensor.align_to)操作符以更简单的方式完成。
对于大量的维度，普通的置换操作符需要所有维度的显式列表，即使只是交换两个维度的位置。然而，在命名张量的情况下，维度的排列或重新排序可以以更容易和更简单的方式完成，如下所示:
复选姓名
除了使张量更加直观，命名张量还提供了额外的错误检查。操作符应用于命名张量时(对于二元操作符，任何一个或两个命名张量)，将在运行时隐式检查某些维度名称是否匹配。这为防止错误提供了额外的安全性。如下例所示:
在上面的例子中，如果不是对于命名张量，batch1和batch2可以无误差地相加，因为 height = width = 100。然而，batch2的高度和宽度尺寸互换，将其添加到batch1可能不是预期的操作。由于命名张量，这个逻辑错误将被名称检查捕获，因为(’ N ‘，’ C ‘，’ H ‘，’ W ‘)和(’ N ‘，’ C ‘，’ W ‘，’ H ')是不同的。
名字什么时候匹配？
这些规则非常类似于 numpy 或 PyTorch 中的维度广播规则。引用 PyTorch 官方文件:
如果两个名字相等(字符串相等)或者至少有一个是
*None*，则两个名字匹配。Nones 本质上是一个特殊的“通配符”名称。
下面的例子展示了这一点:
名称传播
在张量上执行操作后，您不需要再次输入尺寸名称，它们将被自动传播。PyTorch 使用两个操作符— match和unify 进行名称传播。
match与上面定义的操作符相同，它检查两个指定的张量是否匹配。unify是一个算子，用于确定两个输入张量中的哪一个的名字应当被传播到结果张量中。引用 PyTorch 官方文件:
*unify(A, B)*决定将*A*和*B*中的哪一个名称传播到输出。如果匹配，它将返回两个名称中更具体的一个。如果名称不匹配，就会出错。
下面的示例展示了名称传播:
-
一元运算符:
-
二元运算符:
限制
在写这篇文章的时候，命名的张量功能还处于实验阶段，可能会有很多变化。然而，命名张量目前最大的一个限制是，它们不完全支持亲笔签名的引擎。虽然命名张量的梯度计算是完全相同的，但自动签名引擎完全忽略了名称及其提供的额外安全性。
量子化
PyTorch 1.3 现在支持张量的量子化。这是 Tensorflow 已经支持并在 PyTorch 中期待已久的东西。量子化是一个相当简单却复杂的概念。在这里，我将通过回答三个问题——什么、为什么和如何——来尝试用高度抽象的方式简要地描述它们。
什么是量子化？
量化是以低精度格式执行操作或将高精度数据格式转换为低精度数据格式的技术。例如，这是通过将 32 位浮点格式视为 8 位定点格式来实现的。如果感兴趣，你可以阅读一下定点和浮点运算及其相关的复杂性，以便更好地理解量化的需要。
为什么要 量子化？
从事研究和创建神经网络模型的全部目的是部署它们并使它们为公众利益服务。虽然模型训练需求只与研究人员和机器学习实践者的数量成比例增长，但模式推理的需求与消费者的数量成比例增长。为了允许更多更好地访问最终用户，为推理而部署的模型的表示需要比它们在训练时的表示更紧凑。另一件要记住的事情是，反向传播需要模型权重和偏差的高精度表示。然而，在推理过程中，模型更加稳健，并且不需要高精度的表示。因此，以 32 位浮点表示的大小为 113.9MB 的模型可以被量化为 int8，大小为 76.8 MB。
py torch v 1.3 中如何使用量化？
引用 PyTorch 官方文档:
与典型的 FP32 型号相比，PyTorch 支持 INT8 量化，允许型号大小减少 4 倍，内存带宽需求减少 4 倍。对 INT8 计算的硬件支持通常比 FP32 计算快 2 到 4 倍。
对于量化，PyTorch 引入了如下三种新的数据类型:
torch.quint8— 8 位无符号整数。torch.qint8— 8 位有符号整数。torch.qint32— 32 位有符号整数。
PyTorch 现在为模型提供了三种量化方法:
- 训练后动态量化 —提前量化权重，但在运行时动态量化网络激活。操作如下:
torch.quantization.quantize_dynamic(model, dtype=torch.qint8) - 训练后静态量化 —提前量化权重和激活偏差以及比例因子。这是通过调用校准函数来完成的。有关更多详细信息，请参考原始文档。
- 量化感知训练 —在该模型中，对 FP32 表示进行训练，但随后量化为较低精度的精度表示，如 INT8。这用于正常量化不能提供精确结果的罕见情况。因此，我们开始用量化值训练模型。
另一件需要注意的事情是 PyTorch 完全支持量化。这意味着，我们也可以用下面的等式(非常直观)和代码来量化张量:
This equation is used for the int representation of the quantized tensor that can be accessed using t.int_repr()
这里的是对量子化张量的所有支持操作的列表。
移动支持
允许量化的自然目的是在性能关键的移动电话(和其他设备)上运输 PyTorch 模型。他们已经为 Android 和 iOS 实现了端到端的 PyTorch API。这对降低推理延迟和用户隐私会有很大的影响。然而，PyTorch mobile 目前仍处于早期试验阶段，存在一些局限性。例如，当前版本只支持向前传播(推断)，不支持向后操作。
你可以在 PyTorch 官方网站上访问 iOS 和 Android 的 hello world 教程。
更多更新
除了这三个主要更新，PyTorch v1.3 还实现了其他一些更改和错误修复。你可以在官方 PyTorch Github 库上查看所有变更的列表。这些功能包括:
- TPU 支持谷歌云 PyTorch。这里有一个 Github repo 展示了如何在 PyTorch 中使用 TPU。
- 对 TensorBoard 的扩展支持:3D 网格和超参数
- torchscript 的主要更新(主要针对手机)
- 在
torch.nn、torch.nn.functional、自动签名引擎等方面的性能提升。
此外，如果您想将您的代码从 PyTorch 以前的版本移植到 PyTorch v1.3，您需要注意可能导致错误或意外行为的特性。其中一些特性是(我直接引用了前面提到的发行说明中的这些变化):
- 数据类型提升:例如，
torch.tensor(5) + 1.5输出一个值为 6.5 的张量。在早期版本中，输出应该是 6。 - 就地操作符的数据类型提升:例如，考虑下面的代码:
a = torch.tensor(0); a.add_(0.5)在早期版本中，这会给出一个值为 1 的张量作为输出。但是到目前为止，PyTorch 不再支持较低数据类型的就地操作，因此上面这段代码输出了一个错误。 - torch . flatten:
torch.flatten(torch.tensor(0))的输出与之前的tensor(0)相比为tensor([0])。它现在返回的不是 0D 张量，而是 1D 张量。 nn.functional.affine_grid:当 align_corners = True 时，更改了 1D 数据上的 2D 仿射变换和 2D 数据上的 3D 仿射变换的行为(即，当空间维度之一具有单位大小时)。以前，沿着一个单位维度的所有网格点被任意认为是在-1，现在它们被认为是在 0(输入图像的中心)。- torch.gels:删除了不推荐使用的运算符，使用
torch.lstsq代替。 - 使一些迭代器属性私有(例如 num_workers，pin_memory)。
- py torch for c++的其他变化…
感谢阅读！
PyViz:简化 Python 中的数据可视化过程。
PyViz 生态系统概述，使 Python 中的数据可视化更容易使用、学习和更强大。
Photo by Isaac Smith on Unsplash
可视化的目的是洞察力，而不是图片。本·施奈德曼
如果你和数据打交道，那么数据可视化就是你日常工作的一个重要部分。如果您使用 Python 进行分析，您应该会被数据可视化库形式的大量选择所淹没。一些像 Matplotlib 这样的库用于最初的基本探索，但对于显示数据中的复杂关系并不那么有用。有一些可以很好地处理大型数据集，而还有一些主要关注 3D 渲染。事实上，没有一个可视化库可以称得上是最好的。一个比另一个有某些特征，反之亦然。简而言之，有很多选择，不可能学会并尝试所有的选择，或者让它们一起工作。那么我们如何完成我们的工作呢？PyViz 可能有答案
Python 当前的可视化前景
现有的 Python 数据可视化系统似乎是一个混乱的网格。
现在，从所有这些工具中选择最适合我们工作的工具有点棘手和令人困惑。PyViz 试图堵住这种情况。它有助于简化在 web 浏览器中处理小型和大型数据集(从几个点到几十亿)的过程，无论是进行探索性分析、制作简单的基于小部件的工具还是构建功能全面的仪表板
PyViz 生态系统
PyViz 是一个协调的努力，使 Python 中的数据可视化更容易使用、学习和更强大。PyViz 由一组开源 Python 包组成，可以在 web 浏览器中轻松处理大小数据集。PyViz 只是像 EDA 这样简单的东西或者像创建一个支持小部件的仪表板这样复杂的东西的选择。
这是 Python 使用 PyViz 的可视化景观。
PyViz 目标
Pyviz 的一些重要目标是:
- 重点应该放在没有编码的任何大小的数据上
- 完整的功能和交互性应该可以在浏览器(而不是桌面)中获得
- 重点应该更多地放在 Python 用户而不是 web 程序员身上。
- 再次强调，我们应该更多地关注 2D，而不是 3D。
- 利用 Python 用户已经熟悉的通用 SciPy/PyData 工具。
图书馆
构成 PyViz 的开源库有:
- :用于即时可视化数据的声明性对象，从方便的高级规范构建散景图
- 【geo views】:可与 HoloViews 对象混合匹配的可视化地理数据
- 散景:web 浏览器中的交互式绘图，运行 JavaScript 但受 Python 控制
- 面板 :将许多不同库中的对象组装到一个布局或应用程序中，无论是在 Jupyter 笔记本中还是在独立的可服务仪表板中
- Datashader :将庞大的数据集快速栅格化为固定大小的图像
- hvPlot :从你的熊猫、Xarray 或其他数据结构中快速返回交互式全息视图或地理视图对象
- Param :声明与用户相关的参数，使得在笔记本上下文内外使用小部件变得简单
除此之外，PyViz 核心工具可以与以下库无缝协作。
此外，几乎所有其他绘图库中的对象都可以与 面板 一起使用，包括对这里列出的所有对象的特定支持，以及任何可以生成 HTML、PNG 或 SVG 的对象。 HoloViews 也支持 Plotly 进行 3D 可视化。
资源
PyViz 提供了示例、演示和培训材料，记录了如何解决可视化问题。本教程为解决您自己的可视化问题提供了起点。整个教程材料也存放在他们的 Github 仓库中。
** [## PyViz 教程— PyViz 0.9.13a3 文档
如何用 Python 工具解决可视化问题？
pyviz.org](http://pyviz.org/tutorial/index.html#)**
装置
请咨询pyviz.org获取这些教程中使用的软件安装的完整说明。假设你已经下载并安装了 Anaconda 或 Miniconda ，以下是这些指令的精简版:
**conda create -n pyviz-tutorial python=3.6
conda activate pyviz-tutorial
conda install -c pyviz/label/dev pyviz
pyviz examples
cd pyviz-examples
jupyter notebook**
一旦安装完毕，下面的单元格应该会显示“1.11.0a4”或更高版本:
**import** **holoviews** **as** **hv**
hv.__version__'1.11.0a11'hv.extension('bokeh', 'matplotlib')
#should see the HoloViews, Bokeh, and Matplotlib logos**#Import necessary libraries
import** **pandas**
**import** **datashader**
**import** **dask**
**import** **geoviews**
**import** **bokeh**
如果它没有错误地完成，您的环境应该准备好了。
使用 PyViz 探索数据
在这一节中，我们将看到不同的库如何有效地从数据中获得不同的见解，它们的结合确实有助于以更好的方式分析数据。
资料组
正在使用的数据集与美国各州每 10 万人中记录的麻疹和百日咳病例数有关。数据集预装在 PyViz 教程中。
熊猫的数据探索
在任何数据科学项目中，从熊猫开始探索是很自然的。让我们导入并显示数据集的前几行。
**import** **pandas** **as** **pd**diseases_data = pd.read_csv('../data/diseases.csv.gz')
diseases_data.head()
数字是好的，但图表会让我们对数据中的模式有更好的了解。
使用 Matplotlib 进行数据探索
**%matplotlib inline****diseases_data.plot();**
这个传达的不多。让我们对熊猫进行一些操作，以获得有意义的结果。
**import numpy as np****diseases_by_year = diseases_data[["Year","measles"]].groupby("Year").aggregate(np.sum)****diseases_by_year.plot();**
这更有意义。在这里，我们可以清楚地推断出，在 1970 年左右，发生了一些事情，使麻疹发病率下降到几乎为零。这是事实，因为麻疹疫苗在 1963 年左右被引入美国
使用 HVPlot 和散景进行数据探索
上面的图传达了正确的信息，但没有提供交互性。这是因为它们是静态图，没有 web 浏览器中的平移、悬停或缩放功能。然而，我们可以通过简单地导入 **hvplot**包来实现这种交互功能。
**import hvplot.pandas****diseases_by_year.hvplot()**
该调用返回的内容被称为一个 全息视图 对象(此处为全息视图曲线),其中将显示为散景图。Holoviews 图丰富得多，在探索数据时很容易捕捉到您的理解。
让我们看看 HoloViews 还能做些什么:
捕捉情节本身的要点
1963 年对麻疹来说很重要，我们把这一点记录在图表上怎么样。这也将有助于我们比较接种疫苗前后的麻疹病例数。
**import holoviews as hv
vline = hv.VLine(1963).options(color='red')****vaccination_introduced = diseases_by_year.hvplot() * vline * \
hv.Text(1963, 27000, "Measles Vaccine Introduced", halign='left')****vaccination_introduced**
与其他绘图库不同，Holoviews 对象保留原始数据。例如，可以访问表格格式的原始数据。
**print(vaccination_introduced)
vaccination_introduced.Curve.I.data.head()**
在这里，我们能够使用用于绘制图表的数据。此外，现在很容易以多种不同的方式分解数据。
**measles_agg = diseases_data.groupby(['Year', 'State'])['measles'].sum()
by_state = measles_agg.hvplot('Year', groupby='State', width=500, dynamic=False)****by_state * vline**
为了更好地比较，我们可以将图表并排放置，而不是下拉列表。
**by_state["Alabama"].relabel('Alabama') + by_state["Florida"].relabel('Florida')**
我们也可以改变图的类型，比如说条形图。让我们比较四个州从 1980 年到 1985 年的麻疹模式。
**states = ['New York', 'Alabama', 'California', 'Florida']
measles_agg.loc[1980:1990, states].hvplot.bar('Year', by='State', rot=90)**
从上面的例子中可以明显看出，通过选择全息视图+散景图，我们能够在浏览器中探索数据，具有完全的交互性和最少的代码。
用 PyViz 可视化大型数据集
PyViz 还支持轻松处理非常大的数据集。对于这样的数据集，PyViz 套件的其他成员也参与进来。
为了向您展示这些库在处理大量数据时的能力，让我们使用 NYC taxi 数据集，该数据集包含与多达 1000 万次出租车出行相关的数据。这个数据已经在教程中提供了。
**#Importing the necessary libraries**import dask.dataframe as dd, geoviews as gv, cartopy.crs as crs
from colorcet import fire
from holoviews.operation.datashader import datashade
from geoviews.tile_sources import EsriImagery
Dask 是 Python 中一个灵活的并行计算库。Dask 数据帧是一个大型并行数据帧，由许多较小的 Pandas 数据帧组成，沿索引拆分。这些 Pandas 数据帧可能存在于磁盘上，用于单台机器或集群中许多不同机器上的大内存计算。一个 Dask 数据帧操作触发对组成 Pandas 数据帧的许多操作。
Cartopy 是一个 Python 包，设计用于地理空间数据处理，以生成地图和其他地理空间数据分析。
**topts = dict(width=700, height=600, bgcolor='black', xaxis=None, yaxis=None, show_grid=False)
tiles = EsriImagery.clone(crs=crs.GOOGLE_MERCATOR).options(**topts)****dopts = dict(width=1000, height=600, x_sampling=0.5, y_sampling=0.5)**
读入并绘制数据:
**taxi = dd.read_parquet('../data/nyc_taxi_wide.parq').persist()
pts = hv.Points(taxi, ['pickup_x', 'pickup_y'])
trips = datashade(pts, cmap=fire, **dopts)****tiles * trips**
我们还可以添加小部件来控制选择。这既可以在笔记本中完成，也可以在独立的服务器中完成，方法是用.servable()标记可服务对象，然后运行。ipynb 文件或通过散景服务器提取代码到一个单独的。py 文件并做同样的事情:
**import param, panel as pn
from colorcet import palette****class NYCTaxi(param.Parameterized):
alpha = param.Magnitude(default=0.75, doc="Map tile opacity")
cmap = param.ObjectSelector('fire', objects=['fire','bgy','bgyw','bmy','gray','kbc'])
location = param.ObjectSelector(default='dropoff', objects=['dropoff', 'pickup'])** **def make_view(self, **kwargs):
pts = hv.Points(taxi, [self.location+'_x', self.location+'_y'])
trips = datashade(pts, cmap=palette[self.cmap], **dopts)
return tiles.options(alpha=self.alpha) * trips****explorer = NYCTaxi(name="Taxi explorer")
pn.Row(explorer.param, explorer.make_view).servable()**
出租车探险家
所有运行代码的笔记本可以从这里访问。然而，交互性并没有在 GitHub 上表现出来，但是你仍然可以访问笔记本并在本地运行。
结论
PyViz 工具可以帮助我们用少量的代码创建漂亮的可视化效果。PyViz 工具捆绑在一起构建高性能、可伸缩、灵活和可部署的可视化、应用程序和仪表板，而无需显式使用 JavaScript 或其他 web 技术。本文只是对多用途 PyViz 生态系统的简单介绍。浏览整个教程，了解不同类型数据的复杂性及其用法。
问答:数据科学中的常见问题
问我们任何事情
回答在“走向数据科学”团队中最常见的一些问题。
Photo by Ian Schneider on Unsplash
介绍
最近，走向数据科学(TDS)推出了一个名为“向我们提问”的新专栏，让 TDS 的读者有机会向团队提出任何有关数据科学的问题。在这篇文章中，我将回答一些到目前为止我们收到的最常见的问题。
人们对数据科学如此感兴趣的一个主要原因是它的各种应用。数据一直是人类历史上非常重要的组成部分，根据过去的经验和提供的信息做出明智的决策对个人或组织都至关重要。
由于这一主题的跨学科性(图 1)，数据科学可能既是一个真正令人兴奋的工作领域，也是一个令人望而生畏的起点。这就是为什么在这个栖息地提问可以自然而然的到来。
Figure 1: Data Science in summary. [1]
读者提问
数据科学如何入门？
开始一个新的领域总是出乎意料地让人既兴奋又害怕。幸运的是，在过去的几年中，为了增加公众对数据科学的兴趣，已经创建了许多免费资源。一些例子是:
- 在线课程:谷歌 AI 教育、 Coursera:吴恩达机器学习等…
- 书籍:Christopher Bishop 著的《模式识别与机器学习》，Gareth James 等人著的《统计学习导论》等…
- 在线出版物:走向数据科学！、提取、无自由预感等…
- YouTube 频道: 3Blue1Brown ， Arxiv Insights ，走向数据科学，两分钟论文等…
- 播客: DeepMind 播客， TDS 播客等…
获得必要的数据科学背景知识后，对于初学者来说，开始实际项目非常重要。如果你正在寻找一些灵感，Kaggle 可能是一个很好的起点。
我如何写一篇伟大的数据科学文章？
一旦你获得了一些数据科学的知识，尝试展示一些你研究过的项目和主题是一个很好的主意。最简单的方法之一是在你自己的个人网站或在线出版物上写文章(以获得更广泛的受众)。如果你对撰写《走向数据科学》感兴趣，你可以在这篇我以前的文章中找到更多信息和技巧。撰写数据科学相关文章的一些主要指导原则是:
确定数据集中哪些变量对响应变量影响最大的最佳选择是什么？
了解哪些特性会在数据分析中带来更多信息是一项至关重要的任务(尤其是在处理大量数据时！).减少数据集中要素数量的一些主要好处是:
- 精度提高。
- 过度拟合风险降低。
- 在训练中加速。
- 改进的数据可视化。
- 增加我们模型的可解释性。
为了减少数据集中的要素数量，有两种主要方法:特征选择和特征提取。
- 特征选择:在特征选择中，我们利用不同的技术，如过滤器/包装器/嵌入式方法，来选择从数据集中保留哪些特征，丢弃哪些特征。
- 特征提取:在特征提取中，我们通过从现有特征中创建新的特征(然后丢弃原始特征)来减少数据集中的特征数量。这可以通过使用诸如主成分分析(PCA)、局部线性嵌入(LLE)等技术来实现
如果你有兴趣了解更多关于特征选择和特征提取技术的信息，更多信息请点击这里和这里。
你如何在你的模型中考虑专家知识？
当试图决定将哪些特征输入用于预测任务的机器学习模型时，对正在分析的数据具有良好的背景知识会有很大的帮助。
例如，假设我们有一个数据集，其中包含不同出租车行程的出发、到达时间和行驶距离，我们希望预测每次不同行程的出租车费用。将出发和到达时间直接输入机器学习模型可能不是最好的主意，因为我们必须让 ML 模型来计算这两个特征之间的关系对预测出租车费用是有用的。使用专业知识，我们可以首先尝试计算到达和离开之间的时间差(通过简单地减去这两列)，然后将这一新列(与行驶距离一起)输入到我们的模型中。这样，我们的模型更有可能表现得更好。为机器学习分析准备原始特征的技术通常被称为特征工程。
如果您有兴趣了解更多关于不同特征工程技术的信息，更多信息请点击这里。
如何入门机器人流程自动化(RPA)？
机器人流程自动化(RPA)是一项正在开发的用于自动化手动任务的技术。RPA 与传统编程的区别在于其图形用户界面(GUI)。RPA 自动化是通过分解用户执行的任务并重复它们来执行的。这项技术可以使基于图形的过程的自动化编程变得更加容易。平均而言，机器人执行同等过程的速度比人快三倍，而且它们能够全年 24 小时不间断地工作。RPA 公司的一些常见例子有 Automation Anywhere、UIPath 和 blueprism [2]。
如果您打算开始使用 RPA，可以在 Windows 上免费下载 ui path Community Edition。使用 UIPath，可以实现复杂的工作流，创建序列和基于流程图的架构。然后，每个序列/流程图可以由许多子活动组成，例如记录机器人要执行的一组动作或筛选和数据采集指令。此外，UIPath 还支持错误处理机制，以防决策情况或不同流程之间出现意外延迟。
如果你想了解更多关于 RPA 的信息，你可以看看我的 GitHub 库里面有一些例子或者这个我以前的文章。
联系人
如果你想了解我最新的文章和项目，请通过媒体关注我，并订阅我的邮件列表。以下是我的一些联系人详细信息:
文献学
[1]您需要了解的数据科学概念！迈克尔·巴伯。访问:https://towardsdatascience . com/introduction-to-statistics-e9d 72d 818745
[2] Analytics Insight，Kamalika Some=https://www . Analytics Insight . net/top-10-robotic-process-automation-companies-of-2018/
q 学习
通过一个简单的基于表的实施介绍学习率、折扣系数和探索
Q-learning 是最流行的强化学习算法之一，与搜索大量论文和文章相比，它更容易通过实现玩具问题来学习。
这是一个使用 Q-learning 表实现的概念的简单介绍。我将设置我们正在做的事情的背景，建立一个玩具游戏来进行实验，定义 Q-learning 算法，提供 101 实现并探索概念——所有这些都在一个任何人都可以跟随的希望很短的帖子中。
问题是
我们需要一种算法来学习(1)一种政策(2)，它将告诉我们如何在不同的情况下(5)与环境(4)进行交互(3)，以最大化回报(6)。
(1)学习——这意味着我们不应该手工编码任何特定的策略，而是算法应该自己学习。
(2)政策——这是学习的结果。给定一个环境的状态*，政策会告诉我们如何最好地与之互动*，从而最大化回报。
(3)互动——这只不过是算法应该建议我们在不同情况下采取的“行动”。
(4)环境——这是算法与之交互的黑盒。这是一场它理应获胜的比赛。这就是我们生活的世界。是宇宙，所有的太阳、星星和其他一切可以影响环境的东西，以及它对所采取的行动的反应。
(5)环境——这些是环境可能处于的不同“状态”。
(6)奖励——这是目标。与环境互动的目的。玩游戏的目的。
如果无人驾驶汽车是问题所在，那么行动就是我们驾驶的方式，比如转向、刹车等等。奖励就是安全到达目的地。道路、车道、其他车辆和人、光线条件、交通规则、路标和其他一切都是环境。在某个时间点拍摄所有这些的快照，这就是环境的状态。
但这不是我们在这个例子中要用的例子。我们要一个简单得多的。
游戏
想象一个有 5 行 5 列的棋盘——图 1 中所有的白色单元。我们可以从任何一个白细胞开始。目标是尽可能少的走几步，到达右下角的绿色单元格(5，5)。我们可以向上、向下、向左或向右走。我们一次只能走一步。我们不能从棋盘上掉下来，也就是说，进入红细胞，如果我们这样做，我们就会死，我们就会输掉比赛。
Fig 1: The Game
让我们手动制定策略
在潜入可以学习一个有效玩这个游戏的算法之前，我们先来运筹帷幄如何手动玩。给定一个起始位置，我们如何决定向哪个方向移动？嗯，我们将朝着我们的目标前进，而不是远离它。
那么我们如何量化这个“走向”和“远离”的概念呢？我们可以从给所有单元分配一个“距离”值开始。离我们的最终状态目标单元格(5，5)最远的单元格是(1，1) —对角线上的单元格。使用我们可以执行的四个动作(即向上、向下、向左或向右移动)，从(1，1)到(5，5)至少需要 8 个步骤。我们把它的值定为 8。图 2 为每隔一个单元提供了与目标单元的距离的类似注释。
Fig 2: The Game, annotated with distance
但是 Q-learning 和强化学习一般是关于选择一个给我们最大回报的行动。在这里，奖励是距离的倒数——代表我们离目标有多近，而不是我们离目标有多远。此外，在这里发车意味着我们输了，因此应该受到处罚。图 3 进行了这些调整，并提供了与每个单元格相关的奖励(和惩罚)的修订视图。
Fig 3: The Game with rewards and penalties
让我们将图 3 中的内容展开成一个“动作与状态”的表格。这个扩展的“动作对状态”表示就是 Q 学习表。这个表和表中的值是我们的算法应该得到的。
Fig 4: Q-Learning table of Actions vs States
一些细微差别
现在我们已经有了一些奖励的概念，让我们更仔细地看看几个要点。
首先，总报酬的期望值，即 Q 值，实际上是从当前状态开始，在所有可能的连续步骤中总报酬的期望值。而我们上面贴的，其实就是基于那个特定小区距离的奖励，也就是“即时奖励”。我们将在稍后的实现过程中注意到，只有当我们要求算法显式忽略未来奖励时，才会导出图 4 中描绘的值。
碰巧的是，在这个玩具的例子中，迈出回报最大的一步也能获得最大的回报。在其他不那么好玩的例子中，短期回报较低的行动可能会产生长期的最大回报。
为了证明这一点，在我们的玩具示例中，假设我们在(2，2)中，并想象在板的中间有一个障碍物，如图 5 所示。
Fig 5: Actions with lower immediate rewards could still yield max overall rewards
所以实际上，从当前动作将导致的给定的下一个状态，我们必须遍历后续动作和状态的所有可能轨迹，以获得当前动作的真实 Q 值。
第二，我们在图 3 和图 4 中看到的并不是一个完美的奖励系统。以“奖励最大化”为目标，该算法可能会学习在通往目标单元的路上无限或长时间地遍历绿色单元，以积累许多奖励点，而不是最短路径。
但是考虑到这里的目的是使用一个玩具问题来学习概念，我暂时不会太在意这种细微差别，但是理想情况下远离目标应该受到负奖励的惩罚(例如，从 42 移动到 41 不应该得到“3”，这是一个较低的奖励，而是一个更大的惩罚，如-1000)。
该算法
让我们回到我们的目标，定义一个算法来学习“最优策略”，即告诉我们在游戏的当前状态下应该采取什么行动的东西。
图 4 中看到的 Q 学习表将首先被初始化为 0 或某个其它值，并且 Q 学习算法的目标将是学习将被填充到该表中的最佳值，使得在学习结束时，人们可以简单地查看给定状态的表，并且选择具有最大值的动作，这将最大化赢得游戏的机会。
Q-learning 算法通过多次玩游戏来做到这一点，在每场游戏的每一步结束时，我们研究我们获得的奖励，并使用上面的算法来不断更新表格。最终我们会得出一组最优值。下面粘贴的是维基百科来源的 Q-learning 算法的图像，详细说明了我们如何进行这些更新。
Fig 6: Q-Learning algorithm from Wikipedia
在学习期间进行移动之后，给定状态和动作的 Q 值被新值取代。
新值是两部分的和。第一部分是(1-学习率)*旧值。这就是我们保留的旧价值。学习率为 0 意味着不会学到任何新东西。学习率为 1 意味着旧值将被完全丢弃。
第二部分是学习率*(行动的即时回报+最优未来值的贴现估计)。如上所述的学习率决定了将使用多少新的学习值。学习价值是即时回报和最优未来价值的贴现估计值之和。折扣系数决定了未来奖励的重要性。当设置为 0 时，我们将只考虑即时奖励，1 将使算法完全接受。
图 6 中还没有提到探索的概念。也许在最初的几次尝试中，算法会发现给定状态的特定行为是有回报的。如果它一直选择最大回报动作，那么它将继续执行相同的动作，不会尝试任何其他动作，也许其他未尝试的动作会有比这更好的回报。
我们通过引入一个探索因子来处理这个问题，该因子将使算法以预定的%的次数选择一个随机动作，如下图 7 所示。
Fig 7: Exploration
实施
这是上面提到的 Q 学习算法的一个非常简单的实现。导入相关包后，“Game”类代表我们的玩具游戏。它有一个简单的“移动”功能，将“方向”作为输入，并根据上述奖励和规则，返回移动的奖励和游戏结束指示符。
接下来，我们定义并初始化 Q 表、学习率、折扣因子和探索因子。我们有一个循环来玩这个游戏很多次。每局游戏进行到结束，每一步都是最大 Q 值动作(1-探索系数)次，否则是随机动作。在每次移动之后，除了终端状态之外，我们按照算法中的描述更新旧的 Q 值。
结果和观察
我特意将学习率设为 1，折扣因子设为 0。这将确保每次移动后初始值的完全替换，并且只考虑即时奖励。如果您还记得前面讨论的第一个细微差别，这个设置应该会产生一个类似于图 4 所示的 Q 表。
Fig 8: The results
另一方面，将贴现因子设置为 1，即当我们考虑所有的最优未来值时，我们开始面临第二个细微差别中描述的问题。也就是说，假设我们没有真正惩罚远离目标单元格的移动，算法倾向于在棋盘中停留更长的时间，以积累更多的奖励，从而产生真正大的 Q 值，如图 9 所示。
Fig 9: Results with discount factor of 1
这里有一个实现可以解决这个问题，如果我们离开目标单元格，它会提供-1000 的奖励。
我还将探索系数更新为 30%，并增加了 10K 训练游戏的数量，以更好地收敛，结果如图 10 所示。
Fig 10: Results with Game penalizing moving away from target
虽然实际值不同，但我们可以看到，早期状态的最大奖励行为与我们在图 8 中看到的相同。后来的国家似乎仍然不完全符合建议(见 51)，但这只是一个时间问题(或更多的试验)之前，他们这样做。毕竟，Q-在给定无限时间和部分随机策略的情况下，学习可以为任何有限马尔可夫决策过程识别出最优策略！
希望这不仅为 Q 学习和相关概念提供了一个良好的起点，而且随着这些概念的转移，也为深度 Q 学习和其他一般的强化学习算法提供了一个良好的起点。
问答:机器学习和数据科学黑客马拉松
这是黑客马拉松三部曲的最后一部。第一部分是关于参与此类活动的动机。第二部讲述了组织者的错误及其后果。最后一部分提供了所有剩余问题的答案，这在前两部分中是不合适的。
说说你的第一次黑客马拉松。
我是芬兰 Lappeenranta 技术大学的一名硕士学生，同时还参加了数据分析竞赛。我典型的一天是这样的:早上 8 点起床，在大学里呆上几个小时，参加各种比赛直到午夜。经过 3 个月如此紧张的日程安排，我成功赢得了 MERC-2017 数据分析比赛。因此，我的自信心增强了，所以我偶然发现了即将在莫斯科举行的 SkinHack 2 黑客马拉松。所以，我决定在一天内完成两件事——拜访我的父母，参加我的第一次黑客马拉松。
黑客马拉松有点搞笑。提供了两个数据分析跟踪，具有定义的指标和数据集。两条赛道的奖励金额约为 1.5 万€。第三轨道致力于应用程序的开发，奖励金额为 850€，但它没有任何参与者。因此，组织者说，带有按钮的无功能窗口的创造者可以获得 850€，因为提供的奖励金额应该支付。我没有学会如何创建应用程序(因为我不参加比赛，在这方面我很容易被打败)。但这是一个非常明显的迹象，表明黑客马拉松有很多机会。
组织者说，一个带有按钮的无功能窗口的创造者可以赢得 850€，因为提供的奖励金额应该支付。
然后，我通过单独分析数据来解决这两个问题。我发现了一个数据泄漏，这使我获得了一个理想的分数，但是有泄漏的列在测试数据中不存在，我在事件截止日期前两个小时获得了这些数据(顺便说一下，当时我确实知道训练数据集中的目标列不被认为是泄漏)。我的自由泄漏提交在五个团队中排名第三。为了避免浪费时间，我决定退出比赛，因为与第一场比赛的分数差距很大。
然后，当我用新的思维分析所有发生的事情时，我发现了很多错误(我用笔记本在脑海中滚动发生的事情，并分析错误、它们的原因和可以改变的事情。由于经常玩扑克，我养成了这样的习惯。但是我设法明确地认识到以下事实——黑客马拉松提供了多种价值，我必须实现它。然后我开始监控事件和团体，并继续参与黑客马拉松。
我习惯用笔记本在脑海中滚动发生的事情，并分析错误、它们的原因和可以改变的事情。由于经常玩扑克，我养成了这样的习惯。
为什么你会参与黑客马拉松而不是 Kaggle？
我不喜欢卡格尔。Kaggle 在没有特定参与理由的情况下获得了一定的技能等级后变得不那么有用。我早先参加了它，但是后来我发现了更有趣的活动。
你为什么选择黑客马拉松而不是宠物项目？
我有一个宠物项目的几个想法，我将稍后实现它。
有可能单独在黑客马拉松中获胜吗？如果我没有团队呢？
数据科学黑客马拉松提供了这样一个机会(我设法独自获胜)。至于产品，我不确定，但我认为也有可能。不幸的是，有时组织者会设定最低参赛人数。我猜原因是孤独者未能进入决赛(即他们一旦遇到第一个困难就离开比赛)，而团队参与则表现出更好的结果。此外，这样的事件意味着更进一步的项目开发，这在团队中更容易执行。
总的来说，我基于经验的建议是始终参与一个团队。活动组织者将帮助寻找或创建一个团队，如果你失败了。
你觉得这些活动怎么样？
我使用的主要来源是 hackathon.com(世界)和俄罗斯黑客(俄罗斯联邦)。对了，不是真正黑客的聊天。此外，活动公告也可以在社交网络(脸书、VK、LinkedIn)的广告中看到。关于即将举行的活动的信息也可以在这里找到:mlh.io，devpost.com，hackevents.co，hackalist.org，HackathonsNear.me，hackathon.io
参与前是否准备了一定的计划？例如，你会在黑客马拉松前一周考虑找一些专家吗？
我为产品黑客马拉松做准备。几周前，我想出了我的后续行动的想法，并找到了所需的专家，如果有的话，并组成我的朋友或过去的黑客马拉松成员团队一起参与。
你如何应对黑客马拉松中的疲劳？
通常提供 2 天工作时间，即 48 小时(30–48 小时，为简化计算，我们取 48 小时)。规定的睡眠时间是 16-20 小时，所以只有 30 小时可以工作。实际工作(即深度工作)的最大时间约为 8 小时。如果能够合理地组织自己的工作过程，你可以将这个数字增加到 12-14(适当的睡眠和食物，呼吸新鲜空气，进行体育锻炼，与团队进行正确的交流，转换活动，正念)。在 hackathon 完成这样的工作后，你会感到筋疲力尽，但这是一种愉快的疲劳。不睡觉和充满干扰的编码肯定会导致失败，不满足和之后的坏心情。
在 hackathon 完成这样的工作后，你会感到筋疲力尽，但这是一种愉快的疲劳。
你有现成的黑客马拉松管道吗？你是如何设法创造它们的，它们是如何组织的(你有吗？将文件复制到单独的文件夹中，每个文件夹用于特定的任务，等等。)以及如何开始他们的创作？
我不使用完全现成的解决方案，这些方案可以从过去的黑客马拉松中获得。相反，我从过去的比赛中获得了自己的模型和管道列表。因此，我不必从头开始重新开发标准部分(例如，正确的目标编码或简单的神经网络来从文本中提取意图)，这将节省大量时间。
现在它看起来是这样的:我在 GitHub 上有一个单独的私人回购，用于存储关于正在发生的事情的笔记本、脚本和小文档。此外，我已经为所有装箱的特性准备了一个单独的 repo(比如带有交叉验证的正确目标编码)。我不认为这是最好的解决方案，但目前为止它适合我。
我的建议是从将所有自己的代码保存在文件夹中以及创建简短的文档开始(为什么、什么、操作方式和结果)。
有可能在这么短的时间内从零开始建立 MVP 或者所有参与者都有现成的解决方案吗？
至于数据科学相关的项目——是的，有可能。至于 MVP，我觉得取决于两个因素:
●定位为产品的可行想法(即提供商业画布)。需要提供产品开发的原因和目标受众。有时，没有原型但基础良好的项目会获奖。不幸的是，许多参与者未能应对失败，并指责活动组织者自己的失败，同时在接下来的黑客马拉松中继续毫无意义的产品创作。
●提供某些指标，确认您是否可以创建产品(演示应用程序、代码、详细的渠道描述)。
所以，如果你能合理安排时间，这也是有可能的。有时团队带着现成的解决方案来参加黑客马拉松，试图让它适应组织者的任务。这样的团队在技术筛选中失败了，或者只是在黑客马拉松中实现的解决方案的一部分被考虑在内。我还没有看到这样的团队成功获胜的案例，但我想他们为了获得未来的价值(某些联系、数据集等)而参观这样的活动仍然是有益的。)。
不幸的是，许多参与者未能应对失败，并指责活动组织者自己的失败，同时在接下来的黑客马拉松中继续毫无意义的产品创作。
是否有一些将黑客马拉松项目投入生产或启动的例子？
是的。我参与了三个这样的案例。一次是我自己完成的，两次是别人完成的，基于想法和代码，都是在黑客马拉松中创建的。此外，我知道有几个团队作为顾问继续与该公司合作。我不知道最终的结果，但最有可能的是一些事情已经完全完成。我自己没有组织过创业公司，尽管我肯定有很多这样的例子。
如果你能回到过去并改变一些事情，你会给曾经参加过黑客马拉松的人提供什么建议？
●战术最重要。确保将每个解决方案作为完整的产品提供。如果有支付能力的目标受众不在场，创意、Jupyter 笔记本或算法都没有用。
●回答为什么？而不是什么？以及“怎么做？”在开始做某事之前。
●与团队一起参与。
黑客马拉松中最常见的食物是什么？
通常，黑客马拉松提供糟糕的一餐，即披萨、能量饮料、苏打水。几乎所有的食物都是以自助餐的形式提供的，所以总是要排很长的队。通常，晚上不提供这顿饭。虽然有一次在巴黎举行的比赛期间，晚上给我们提供了一顿饭，即薯条、甜甜圈和一杯可乐。所以，我来介绍一下组织者的心路历程:那么，程序员以前都是吃什么的？哦，对了！薯条、油炸圈饼——就这些。让我们给他们那些垃圾食物。第二天我问活动组织者是否可以提供其他东西，比如粥。但是他们没有回答，只是看着我，好像我很傻，问了这么愚蠢的问题。
那么，程序员以前都吃什么？哦，对了！薯条、油炸圈饼——就这些。让我们给他们那些垃圾食物
组织良好的黑客马拉松提供树食盒类型，即常规，素食和犹太餐。此外，他们还在冰箱里放了酸奶和麦片，供那些想在一天中吃一点的人使用。茶、咖啡和水是标准配置。对我来说，最好的例子之一是 Hack Moscow 2，它在 1C office 的餐厅为参与者提供罗宋汤和肉丸(俄罗斯灵魂食物)。
黑客马拉松的组织水平是否取决于组织者的专业领域(例如，最好的黑客马拉松是否真的是由顾问提供的)？
最好的黑客马拉松是由那些以前组织过或参加过的人组织的。也许，这是事件质量所依赖的唯一因素。
如何意识到是时候开始参加黑客马拉松了？
参观黑客马拉松的最佳时间是一年前。第二好的时间就是现在。所以，现在就开始参与吧。不要害怕:犯错并不断学习。即使是人类继轮子和爬树后最伟大的发明——神经网络，也无法在训练的第一阶段区分猫和狗。
参观黑客马拉松的最佳时间是一年前。第二好的时间就是现在。
哪些指标证实该事件不值得参与？
● 更清晰的任务描述(与产品黑客马拉松相关)。如果在注册期间会给你一个明确的任务，你最好呆在家里。对我来说，我想不出任何一个好的黑客马拉松能在开始前提供规范。例如，好的黑客马拉松要求做一些与音频对话分析相关的事情，而坏的黑客马拉松要求开发一个应用程序，能够为每个人将对话分成两个独立的音频轨道。
● 小奖池。如果被要求用人工智能为在线商店创建一个火绒，并且提供的第一名奖励仅为 500 欧元，而最小团队成员数量为 5 人，请确保避免浪费时间(是的，这是去年在慕尼黑举行的一次真实的黑客马拉松)。
● 缺少数据(与数据科学黑客马拉松相关)。组织者通常提供基本的活动数据，有时也提供数据集样本。如果他们没有提供，在活动开始前询问。
● 新活动主办方。一定要在活动开始前谷歌一下黑客马拉松的组织者。如果他们第一次组织这种类型的活动，很可能会出问题。但如果组织者和评审团成员已经举办过黑客马拉松，或者过去积极参与过，这是一个好迹象。
在一次黑客马拉松中，有人告诉我:你提供了最好的分数解决方案，但对我们来说，团队合作很重要。不幸的是，你独自工作。例如，如果你和某个学生或女孩一起参加，你可能会赢。你遇到过这样的不公吗？你是如何应对的？
是的，我见过不止一次。我以坚忍的态度对待发生的一切:我做了力所能及的一切。如果没有成功，那就随它去吧。
你为什么从事黑客马拉松？
一切都只是出于无聊。
Qrash 课程:10 分钟强化学习 101 和深度 Q 网络
从头开始学习强化学习和深度 Q 网络的基础知识
这篇博文现在也有韩语版本，请在 jeinalog.tistory.com上阅读
Qrash 课程系列:
- 第 1 部分:强化学习和 Q 学习简介
- 第二部分: 政策梯度和优评
本文假设没有强化学习的先验知识，但是假设对神经网络有一些基本的了解。
在所有不同类型的机器学习领域中，最让我着迷的是强化学习。对于那些不太熟悉它的人来说，监督学习处理基于标记数据的预测值或类，而非监督学习处理聚类和在未标记数据中寻找关系，强化学习处理一些任意存在(正式称为“代理”)在给定环境中应该如何行动和表现。其方式是根据代理在不同场景下的表现给予奖励或惩罚。
我学到的第一个实用的强化学习方法是深度 Q 网络，我相信这是这个旅程的一个很好的开端。所以请允许我带你走一遍我尝试学习 RL 时走过的路——包括一个“Hello World”练习，它对我的帮助比我能解释的还要多。
定义世界
强化学习任务是关于训练一个代理与其环境互动。通过执行动作*，代理在环境的不同场景之间转换，称为状态。反过来，行动会产生回报，回报可能是正的、负的或零。代理的唯一目的是最大化它在集中收集的总奖励，这是在初始状态和结束状态之间发生的所有事情。因此，我们通过提供正奖励来加强代理执行某些行为，并通过提供负奖励来远离他人。这就是一个代理如何学习制定一个策略，或者一个政策。*
以超级马里奥为例:马里奥是与世界(环境)交互的智能体。状态就是我们在屏幕上看到的，一集就是一个关卡:初始状态是关卡如何开始的，终结状态是关卡如何结束的，是我们完成了还是在尝试中灭亡了。动作有前进、后退、跳跃等。奖励取决于行动的结果:当马里奥收集硬币或奖金时，它会收到正奖励，当它倒下或被敌人击中时，它会收到负奖励。当马里奥只是四处好奇时，它得到的奖励是零，仿佛在说“你没做什么特别的事”。
In a Super Mario game, Mario is the Agent interacting with the world — the Environment
但这里有一个问题:为了能够收集奖励，需要采取一些“非特殊”的行动——你必须走向硬币，然后才能收集它们。因此，代理人必须学会如何处理延迟奖励*，学会将这些与真正导致它们的行为联系起来。在我看来，这是强化学习最迷人的地方。*
马尔可夫决策过程
代理所处的每个状态都是前一个状态和所选动作的直接结果。前一个状态也是前一个状态的直接结果，如此类推，直到我们到达初始状态。这些步骤中的每一步，以及它们的顺序，都保存着关于当前状态的信息——因此对代理下一步应该选择哪个动作有直接的影响。但是这里有一个明显的问题:我们走得越远，代理在每一步需要保存和处理的信息就越多。这很容易达到执行计算根本不可行的程度。
为了解决这个问题，我们假设所有状态都是马尔可夫状态；也就是说——我们假设任何状态都只依赖于它之前的状态，以及从那个状态到当前状态的转换(执行的动作和给予的奖励)。让我们来看一个例子，看看这两个井字游戏:
两个游戏都达到了同样的境界，只是方式不同。尽管如此，在这两种情况下，蓝色玩家必须捕获右上角的单元格，否则他将失败。为了确定这是最后一个状态，我们只需要这个，不需要别的。
重要的是要记住，当使用马尔可夫假设时，数据就是丢失——在复杂的游戏中，如国际象棋或围棋，走法的顺序可能会有一些关于对手策略或思维方式的隐含信息。尽管如此，当试图计算长期战略时，马尔可夫状态假设是基本的。
贝尔曼方程
让我们继续发展我们的第一个策略。考虑最简单的情况:假设我们已经知道每一步的每一个行动的预期回报是什么。在这种情况下，我们将如何选择行动？很简单——我们将选择最终会产生最高回报的行动顺序。我们将获得的这种累积奖励通常被称为 Q 值(质量值的缩写)，我们可以用数学方法将我们的策略形式化为:
The Bellman Equation
上面的等式表明，从处于状态 s 并选择动作 a 产生的 Q 值是收到的即时奖励*、 r(s，a) ，加上状态*s’可能的最高 Q 值(这是我们在从状态 s 采取动作 a 之后的状态)。通过选择最大化 Q 值的动作，我们将从s’获得最高的 Q 值。我们还引入了 γ，通常被称为贴现因子，它控制着长期回报相对于眼前回报的重要性。
这个方程被称为贝尔曼方程，它的维基百科页面提供了对其数学推导的全面解释。这个优雅的等式非常强大，对我们非常有用，因为它有两个重要的特征:
- 虽然我们仍然保留马尔可夫状态假设，但是贝尔曼方程的递归性质允许来自未来状态的回报传播到遥远的过去状态。
- 当我们开始的时候，没有必要知道什么是真正的 Q 值；由于它是递归的，我们可以猜测一些东西，它最终会收敛到真实值。
q 学习
我们现在有了一个基本策略——在任何给定的状态下，执行最终会产生最高累积回报的行动。像这样的算法被称为贪婪*，原因很明显。*
我们如何实现这一点来解决现实生活中的挑战？一种方法是画一个表来存储所有可能的状态-动作组合，并用它来保存 Q 值。然后，我们可以使用贝尔曼方程作为更新规则来更新它:
Q Learning update rule. The “:=” notation is used here to explicitly mark assignment rather than equality.
让我们看一个例子:
Q Learning table update demonstration
现在记住有些状态是终态。当代理达到 1 时，没有动作或状态转换是可能的。所以，如果未来状态s’是一个终态，我们就剩下:
Q Learning update rule for terminal state s’
还没有完成——我们的贪婪算法有一个严重的问题:如果你一直选择同样的最佳行动，你将永远不会尝试任何新的东西，并且你可能会错过一个更有回报的方法，仅仅因为你从来没有尝试过它。
为了解决这个问题，我们使用一种ε-贪婪方法:对于一些 0 < ε < 1 ，我们选择概率为 p = 1-ε 的贪婪动作，或者概率为 p = ε的随机动作*。因此，我们给代理一个机会去探索新的机会。***
这种算法被称为 Q 学习(或 Q 表)。恭喜你！你刚刚学会了你的第一个强化学习算法！
深度 Q 网络
你可能会问自己 Q 学习是如何扩展的——如果你没有，让我们一起来问:当状态和动作的数量变得非常大时会发生什么？这实际上并不罕见——即使是像井字游戏这样的简单游戏也有数百种不同的状态(尝试计算这一点),不要忘记我们将这个数字乘以 9，这是可能的操作数。那么我们将如何解决真正复杂的问题呢？
进入深度学习！我们把 Q 学习和深度学习结合起来，产生了深度 Q 网络。这个想法很简单:我们将用一个试图逼近 Q 值的神经网络来代替 Q 学习表。通常称为逼近器或逼近函数，记为 Q(s，a；θ ，其中 θ 表示网络的可训练权值。
现在只有使用贝尔曼方程作为成本函数才有意义——但是我们到底要最小化什么呢？让我们再来看一看:
“=”符号表示赋值，但是有没有条件也满足一个等式？是的，当 Q 值达到收敛的最终值时。这正是我们的目标——因此我们可以最小化左侧和右侧之间的差异——还有，viola！我们的成本函数:
DQN cost function
这看起来眼熟吗？大概——是均方误差函数，其中当前 Q 值是预测( y )，当下和未来的回报是目标(y’):
Mean square error function
这就是为什么 Q(s)，a；θ 通常被称为 Q 目标。
继续:训练。在强化学习中，训练集是在我们进行的过程中创建的；我们要求代理使用当前网络尝试并选择最佳行动——我们记录下状态、行动、奖励以及它结束时的下一个状态。我们决定一个批量大小 b ，每次 b 记录新记录后，我们随机选择 b 记录**(!！)从记忆中，训练网络。使用的内存缓冲区通常被称为体验回放。这种内存有几种类型——一种非常常见的是循环内存缓冲区。这确保代理保持对其新行为的训练，而不是可能不再相关的事情。**
事情越来越真实，所以让我们谈谈架构:如果模仿一张桌子，网络应该接收状态和动作作为输入，并应该输出 Q 值:
虽然这是正确的，但从技术角度来看，这种架构是非常低效的。请注意，成本函数需要最大未来 Q 值，因此我们需要多次网络预测来进行单次成本计算。因此，我们可以使用以下架构:
这里，我们仅向网络提供状态 s 作为输入，并同时接收所有可能动作的 Q 值。好多了。
嗯，你知道吗——差不多就是这样。再次恭喜！你刚刚学会了如何设计一个深度 Q 网络！
奖励—双重深度 Q 学习
在我们结束之前，这里有一些额外的东西:几段前我们比较了深度 Q 网络成本函数和均方误差。但是 MSE 将预测 y 与真实标签y’—进行比较，并且真实标签在整个训练过程中保持不变。显然，在深度 Q 网络中不是这种情况:网络本身预测了 y 和y’，因此可能在每次迭代中变化。影响显而易见。
介绍:双深 Q 网络，训练时使用半常数标签。怎么会？我们保留了 Q 网络的两个副本，但是只有一个被更新——另一个保持不变。不过，每隔一段时间，我们会用经过训练的 Q 网络的副本来替换常数网络，因此我们称之为“半常数”。所以:
DDQN cost function
这里， ϑ 表示半常数权重，所以q(s’，a；ϑ)* 表示由半常数网络预测的 q 值。就这样，你做到了。*
你好世界！
我个人认为掌握新概念的最好方法是自己尝试去实现它们。为了尝试 Q 学习和深度 Q 网络，我编了一个简单的游戏:一个有 4 个槽的棋盘，要由代理来填充。当代理选择一个空位置时，它将获得+1 的奖励，并且该位置将被填满。如果它选择了一个非空的位置，它将获得-1 的奖励。当整个棋盘填满时，游戏结束。
试一试，尝试使用这两种方法实现一个学习掌握这个游戏的代理。你可以在这里找到我的尝试。
祝你好运，今天是第三次——祝贺你！
准备好自己尝试一些强化学习了吗？下面是我写的另一篇博文，里面有一些实用的技巧。**
Qrash 课程 II:12 分钟内从 Q-学习到梯度政策&行动者-批评家
朝着真正理解强化学习的基础又迈进了一步
本帖讨论的所有算法的实现都可以在 我的 GitHub 页面 找到。
使用此 好友链接 即使不是普通会员也可以阅读这篇博文
Qrash 课程系列:
- 第一部分: 强化学习和 Q-Learning 简介
- 第二部分:政策梯度和行动者-批评家
之前——也是第一个——Qrash 课程帖子带我们从对强化学习一无所知一路走到完全理解 RL 最基础的算法之一: Q 学习，以及它的深度学习版本 Deep Q-Network 。继续我们的旅程，再介绍两个算法:渐变策略和演员-评论家。这两个人，加上 DQN，可能是现代深度强化学习最基本的组成部分。
为什么 Q-Learning 不够用？
我们可能应该问自己的第一个问题是为什么我们应该从 Q-Learning 前进？它在哪里失败或表现不佳？这个算法确实有一些缺陷，理解它们很重要:
- **在大量操作中表现不佳:**让我们假设一个操作数量很大的环境。非常大，比如几千，甚至更多。使用ε-贪婪策略探索所有可能的动作可能会花费太长时间，并且该算法很容易收敛到局部最大值，而不是真正的最佳可能解决方案。不太好。
- **动作集合必须是有限的:**让我们把可能动作的数量拉伸到它的绝对极限:无限。这实际上很常见——想象一下一辆自动驾驶汽车，它的动作是转动方向盘的程度。这是一个连续的数字范围，因此是无限的。很明显为什么 Q 学习算法不能处理这种情况。
- **糟糕的探索策略:**我们来举个例子——假设一个环境中有 10 种不同的行动是可能的，一个 Q-学习代理使用一个ε-贪婪策略，其中 ε = 0.1。现在让我们假设行动#1 是在这个给定时刻具有最高 Q 值的行动。这意味着代理人有 91%的机会选择行动#1 (90%的机会选择贪婪行动+ 1%的机会随机选择这个行动)，而所有其他行动只有 1%的机会被选中。现在考虑这些 q 值: Q(s，a ) = 3.01，Q(s，a ) = 3.00，…，Q(s，a ⁰) = 0.03。 尽管行动#1 和#2 的 Q 值非常接近，但选择#1 而不是#2 的机会要大得多，正如刚才解释的那样。更糟糕的是，选择行动#2 和#10 的几率是完全一样的，尽管行动#2 实际上是百倍(！！)更好。现在结合第 1 节中的问题，您可以看到为什么在这种情况下这可能不是最好的算法。
我们应该如何处理这些情况？让我们来认识一下我们的救世主吧！
政策梯度
Q 学习算法通过试图找到每个状态的动作值函数—Q 值函数来学习。它的整个学习过程是基于计算出每个可能动作的质量的思想，并根据这些知识进行选择。因此，Q-Learning 试图对所有可能的动作有完整和公正的了解——这也是它最大的缺点，因为这需要对每个可能的状态和动作进行足够次数的尝试。策略梯度算法以更稳健的方式学习，通过而不是尝试评估每个动作的值——而是简单地评估它应该偏好哪个动作。
让我更好地说明一下:每个模型最终都有一些它试图优化的学习参数(这些通常是神经网络的权重)。让我们将这些参数表示为 θ 。在 DQN，学习周期是:
这意味着训练过程优化了网络的学习参数，然后用于计算 Q 值。然后，我们使用这些 Q 值来决定我们的策略π(其中策略就是每个行动被选择的概率)，DQN 的ε-贪婪策略取决于预测的 Q 值，因为它给具有最高 Q 值的行动最高的概率:
Policy of a Deep Q-Learning algorithm
策略梯度算法的学习周期更短，跳过了 Q 值部分:
这意味着网络将直接输出选择每个动作的概率，跳过额外的计算。这将允许该算法更加鲁棒。
我们现在剩下一个非常重要的问题— *我们如何优化网络的权重？*在 DQN，事情很简单:我们知道如何计算 Q 值，因此我们可以根据它们优化算法。但是我们现在做什么？我们的主要目标是确保模型在每个学习阶段后变得更好。让我们试着把这写成在每个时间步 t 的权重的一个非常通用的更新规则:
在这里，我们将 J 定义为一些性能度量，我们稍后会讲到，而 α 是学习率。我想花一点时间来澄清时间步长 t 和 s 之间的区别，时间步长 t 表示一集的步和s步状态。状态由环境定义，例如——所有可能的棋盘。步骤由代理定义，并标记它所经历的状态序列。这意味着步骤 t=3 和 t=7 可能是相同的状态 s ，因为一些环境允许代理多次返回完全相同的状态。另一方面，每集每一步只出现一次。步骤是按时间顺序排列的时间顺序。
让我们回到我们的更新规则，我们将它定义为依赖于新的 J 参数的梯度。虽然它可能对神经网络训练的反向传播阶段很熟悉，但这里有一个非常重要的区别:在梯度策略中，我们希望提高的性能，因此我们希望最大化对 J 的导数，而不是最小化它。这被称为梯度上升— 与反向传播中执行的梯度下降相反。其实也是差不多的逻辑，只是反过来而已。
设计我们的第一个梯度策略算法
在这一点上，很明显我们如何定义 J 将会有所不同，但是这也完全取决于 us 来决定什么是正确的定义。让我们尝试找到一些简单的东西——一些取决于 Q 值的东西(即使算法从来不会计算它)。回想一下，Q 值 Q(s，a) 是从状态 s 开始并在执行动作a之后，代理人应获得的所有奖励的度量，所有奖励的总和似乎是一个相当好的表现度量——毕竟，代理人的唯一目的是增加其收集的总奖励。因此，我们可以使用整个剧集的总累积奖励作为我们的绩效衡量标准:
这是初始状态 s⁰的所有 q 值的总和，乘以选择每个动作的概率。这正是我们期待的一整集的总体回报。现在，某一状态的所有 Q 值乘以它们的概率的总和有了一个名字:它被称为状态的值函数，并被表示为 V(s) 。一个状态的价值函数是从状态 s 到这一集结束的预期回报的度量，而不知道将选择哪个行动。所以我们基本上将初始状态的价值函数定义为我们的性能度量: J = V(s⁰) 。
现在我们有了 J ，我们需要计算它的梯度。这涉及到一些复杂的数学问题，因为 J 依赖于行动选择的概率*p(a)*哪个是从策略 π — 中派生出来的，但是π依赖于 J ，因为这是我们如何定义它的。你可以在萨顿·巴尔托的《强化学习导论》中找到完整的数学推导。)，第 325–327 页(这里有一个免费网络版)。我在这里跳过它，写下解决方案:
其中 G_t 是从步骤 t 到该集结束的总累积奖励。这意味着我们的 θ 的更新规则是:
对一项政策进行对数运算可能看起来令人生畏或者很奇怪——但这只是我们需要应用的另一个数学函数，仅此而已。
勘探和开发
我想再次强调策略梯度算法的一个重要特性——它直接学习策略*。这意味着网络的输入是当前状态 s ，输出是选择每个动作的概率:*
那么我们实际上如何选择一个动作呢？我们简单地对动作进行加权采样。这也解决了我们探索的需要——每个行动都有被选中的机会，但不是均等的，因为最好的行动最有可能被选中。
培养
与 Q-Learning 不同，Policy Gradient 算法是一种 on-policy 算法，这意味着它只使用当前活动策略进行的状态-动作转换进行学习。从技术上来说，这意味着没有像 DQN 那样的经验回放记忆。一旦模型被训练，它的 θ 参数会改变，因此它的策略也会改变。这意味着在这次训练之前收集的所有经验必须被丢弃，并且不能再用于训练。所以我们为训练收集的每一条数据都被使用一次，而且只有一次。
梯度政策在起作用
虽然在这一点上一般的想法有望被理解，但是举例总是更好。使用强化学习解决的一个非常受欢迎的任务是车杆问题:一辆可以向左或向右移动的车，需要确保站在它上面的杆不会倒下。这是我对这个挑战的解决方案。你也试着去实现它。
Cart-Pole
演员兼评论家
让我们花一分钟的时间来认识到目前为止我们已经开发了什么:我们现在有一个代理，它学习一个策略，而不需要学习每个动作的实际值。它真正需要的唯一东西是一些性能指标，它将试图最大化——在我们的例子中，我们选择了一整集的总预期回报。
这种方法的好处很简单——不需要访问和尝试每一个可能的状态-动作对，因为代理对它应该做什么产生了某种“直觉”。但是由于代理对其性能度量的绝对依赖性，这带来了一个缺点。让我们考虑一下我们的例子，我们选择了一集的总体回报作为表现:考虑一集采取了一百步。每一步产生+10 的奖励，但是第 47 步产生-100 的奖励。我们选择的绩效衡量标准无法区分这个陷阱，因为它只知道总体回报。这意味着当我们的代理到达第 47 步时，它可能永远不会尝试另一个动作，因为它不会学习任何特定于状态和动作的知识。
我们如何解决这个问题？我们希望有一个智能体，一方面，以类似于梯度策略方法的方式学习策略，尽管另一方面，我们理解特定于状态和特定于动作的知识的重要性，就像 Q 学习方法一样。解决办法？将两者结合在一起。
这种组合方法被称为行动者-批评家，由两个子代理一起学习组成:一个学习应该采取行动的政策(因此被称为行动者)，另一个学习每个状态和行动的 Q 值(因此被称为批评家)。然后，我们将 θ 的更新规则改为:
请注意，我们只是用 Q 值替换了总报酬 G ，但是 Q 值现在也是一个学习参数——由第二个子代理学习。这产生了稍微复杂一点的架构:
A schematic view of an Actor-Critic architecture. Dashed lines represent flows only relevant during training, so during inference (prediction) phase, only the Actor is being used
请注意，就像策略梯度一样，行动者-批评者也是基于策略的模型——这再次意味着在每次训练之后，所有以前的训练数据都将被丢弃。
仅此而已。你猜对了！你现在可以尝试自己实现一个演员评论家，或者看看我的实现解决 Acrobot 挑战。
A2C、A3C 和 DDPG
这里我们已经做得差不多了，但是让我们再往前走一步，了解一些对我们的演员评论家代理非常有用的优化。
A2C
回想一下，我们现在在更新规则中使用 Q 值，以便允许代理拥有一些特定于状态-动作的知识。现在让我问你一个问题: Q(s，a)=100 是不是一个好的 Q 值？答案是— 我们不知道。我们不知道，因为我们没有关于其他可能行动的 Q 值的信息。如果所有其他动作产生的 Q 值为 1，那么 100 真的非常好。但是如果所有其他的都产生 10，000，那么 100 实际上是相当糟糕的。这不仅让你困惑，也让模型困惑。如果知道某个动作与休息相比有多好，或者换句话说，采取某个特定动作的优势是什么，将会很有帮助。因此，我们可以用一个动作的优势替换演员-评论家更新规则中的 Q 值，其定义为:
其中 V(s) 是状态的价值函数，我们之前已经讨论过了。学习一个动作的优点要容易得多——积极的 A(s，a) 是好的，消极的是不好的。这种演员-评论家模型的变体被称为优势演员-评论家，缩写为 AAC，或者更常见的是:A2C(这只是一种有趣的写法，有两个 a 和一个 C)。
你可能会注意到 A2C 版本似乎让学习变得更复杂了，因为现在代理需要学习 Q(s，a) 和 V(s) 。但事实并非如此。如果 Q 值是从状态 s 和动作 a 收到的奖励，然后一直持续到该集结束，我们可以这样写:
意思是——一个 Q 值实际上是直接回报 r 和下一个状态的值s’。这意味着我们可以将优势写成:
所以我们实际上只需要学习值函数，并使用它两次——对于状态 s 和下一个状态s’。这个小小的调整实际上使得 A2C 比原来的演员兼评论家更容易实现。你可以在 GitHub 上查看我对 A2C 的实现。
A3C
既然我们可以拥有多个代理，为什么只拥有一个代理？这是 A3C 模型背后的核心思想，它代表异步优势 Actor-criterion。想法很简单:有许多不同的代理，每个代理都在自己的环境副本中玩，但它们都共享相同的策略和参数。每个代理都在自己的时间上更新共享策略(与其他代理异步)，这使得学习过程更快、更健壮。
DDPG
DDPG(深度确定性策略梯度)算法的设计考虑了连续动作空间的问题。Actor-criterion 模型的训练阶段非常嘈杂，因为它基于自己的预测进行学习。为了解决这个问题，DDPG 借用了我们钟爱的 DQN 的一些元素:首先，它使用了 Experience Replay 内存，这让它成为了一个脱离政策的模型。其次，它使用了与 Double DQN 模型相同的降噪方法——它使用了 Actor 和 criterion 的两个副本，一个副本经过训练，另一个副本以如下方式缓慢更新:
在这里，线上的网络是训练有素的那一个，而<的< 1 个。详见我对 DDPG 的实现。
结束语
在本教程中，我们扩展了增强学习的基本构造块的知识，在算法库中添加了梯度策略和 Actor-criterion。现代强化学习的规模要大得多，但最终它都依赖于一些类似的理念——现在你已经理解了。好样的。
质量控制图:x-条形图、R-图和过程能力分析
r 代表工业工程师
使用“qcc”R 包创建质量控制图
Image by Analytics Association of the Philippines on LinkedIn
质量控制图
质量控制图是工程师监控一个过程是否在统计控制下的重要工具。它们有助于可视化变化，发现并纠正出现的问题，预测预期的结果范围，并分析特殊或常见原因导致的流程变化模式。质量控制图常用于精益六适马项目和 DMAIC 项目的控制阶段，被认为是过程改进的七个基本质量工具之一。
然而，我们如何确定用于监控过程的正确的质量控制图？以下决策树可用于根据给定数据确定哪一个是要使用的正确质量控制图:
Quality Control Charts Decision Tree
在下面的例子中，当样本量大于 1 小于 11 时，我们将关注连续数据的质量控制图。
x 条形图
x-bar 和 R-chart 是质量控制图，用于根据给定时间内采集的样本监控过程的均值和变异。两个 chats 上的控制限制用于监控流程的平均值和变化。如果一个点超出了控制极限，则表明过程的平均值或变化超出了控制范围；在这一点上，可能怀疑有可分配的原因。在 x 条形图上，y 轴显示的是总体平均值和控制限，而 x 轴显示的是样品组。让我们来看看使用 qcc 包生成 x-bar 图的 R 代码。
x-bar chart R code
x-bar chart example using qcc R package
由 R 生成的 x 条形图为其解释提供了重要信息，包括样本(组数)、控制限、总体平均值(中间值)标准差(标准偏差)，最重要的是，超出控制限的点和违规运行。工程师必须特别注意这些点，以便识别和确定导致过程失控的系统变化的原因。
r 图表
为了将 R 图与 x 条形图一起使用，样本大小 n 必须大于 1 且小于 11。对于更大的样本，必须使用 s 图来监控样本的标准偏差，而不是其范围。在 R 图中，y 轴显示范围平均值和控制限，而 x 轴显示样本组。一旦您创建了一个 x-bar 图表，您将只需要添加以下代码行来生成 R-chart。
R-chart R code
R-chart example using qcc R package
R 生成的 R 图也为其解读提供了重要信息，就像上面生成的 x-bar 图一样。同样，工程师必须特别注意超出控制极限的点和违反运行，以便识别和确定导致过程失控的系统变化的原因。
过程能力分析
过程能力是给定特性的固有过程可变性的统计度量。换句话说，过程满足给定规范(如客户要求、工程公差或其他规范)的能力。
使用 R 生成 x-bar 和 R-charts 后，您只需添加以下代码行，指定控制下限、控制上限和目标。完成后，添加下面的最后一行代码来生成流程能力总结图表。
Process Capability Analysis R code
Process Capability Analysis using qcc R package
上面的过程能力分析总结图为工程师解释满足给定规范的过程能力提供了重要的信息和能力估计。有兴趣进一步了解这种能力评估的含义吗？点击此处进入 ASQ(美国质量协会)网站。
总结想法
我们已经经历了 R 和 qcc 封装必须提供的众多工业工程应用之一。您可能已经注意到，只需几行代码，我们就能构建质量控制图，并获得重要信息，用于精益六适马和 DMAIC 项目的流程改进。我再一次邀请你继续发现作为一名工业工程师，你可以使用 R 完成的令人惊奇的事情。
— —
如果你觉得这篇文章有用，欢迎在GitHub上下载我的个人代码。你也可以直接在 rsalaza4@binghamton.edu 给我发邮件，在LinkedIn上找到我。有兴趣了解工程领域的数据分析、数据科学和机器学习应用的更多信息吗？通过访问我的介质 简介 来探索我以前的文章。感谢阅读。
-罗伯特
质量控制图:x-条形图、s-图和过程能力分析
r 代表工业工程师
使用“qcc”R 包创建质量控制图
Image by Analytics Association of the Philippines on LinkedIn
质量控制图
质量控制图是工程师监控一个过程是否在统计控制下的重要工具。它们有助于可视化变化，发现并纠正出现的问题，预测预期的结果范围，并分析特殊或常见原因导致的流程变化模式。质量控制图常用于精益六适马项目和 DMAIC 项目的控制阶段，被认为是过程改进的七个基本质量工具之一。
然而，我们如何确定用于监控过程的正确的质量控制图？以下决策树可用于根据给定数据确定哪一个是要使用的正确质量控制图:
Quality Control Charts Decision Tree
在下面的例子中，当样本量大于 10 时，我们将关注连续数据的质量控制图。
x 条形图
x-bar 和 s-chart 是质量控制图，用于根据给定时间内采集的样本监控过程的均值和变异。两个 chats 上的控制限制用于监控流程的平均值和变化。如果一个点超出了控制极限，则表明过程的平均值或变化超出了控制范围；在这一点上，可能怀疑有可分配的原因。在 x 条形图上，y 轴显示的是总体平均值和控制限，而 x 轴显示的是样品组。让我们来看看使用 qcc 包生成 x-bar 图的 R 代码。
x-bar chart R code
x-bar chart example using qcc R package
由 R 生成的 x 条形图为其解释提供了重要信息，包括样本(组数)、控制限、总体平均值(中间值)标准差(标准偏差)，最重要的是，超出控制限的点和违规运行。工程师必须特别注意这些点，以便识别和确定导致过程失控的系统变化的原因。
s 形图
为了将 s 图与 x 条形图一起使用，样本大小 n 必须大于 10。在 s 图中，y 轴显示样本标准差、标准差总体均值和控制限，而 x 轴显示样本组。一旦创建了 x-bar 图，您只需要添加以下代码行来生成 s-chart。
s-chart R code
s-chart example using qcc R package
R 生成的 s 图也为其解读提供了重要信息，就像上面生成的 x 条形图一样。同样，工程师必须特别注意超出控制极限的点和违反运行，以便识别和确定导致过程失控的系统变化的原因。
过程能力分析
过程能力是给定特性的固有过程可变性的统计度量。换句话说，过程满足给定规范(如客户要求、工程公差或其他规范)的能力。
使用 R 生成 x-bar 和 R-charts 后，您只需添加以下代码行，指定控制下限、控制上限和目标。完成后，添加下面的最后一行代码来生成流程能力总结图表。
Process capability analysis R code
Process Capability Analysis using qcc R package
总结想法
我们已经完成了 R 和 qcc 封装必须提供的众多工业工程应用之一。您可能已经注意到，只需几行代码，我们就能构建质量控制图，并获得重要信息，用于精益六适马和 DMAIC 项目的流程改进。我再一次邀请你继续发现作为一名工业工程师，你可以使用 R 完成的令人惊奇的事情。
— —
如果你觉得这篇文章有用，欢迎在GitHub上下载我的个人代码。你也可以直接在 rsalaza4@binghamton.edu 给我发邮件，在LinkedIn上找到我。有兴趣了解工程领域的数据分析、数据科学和机器学习应用的更多信息吗？通过访问我的介质 简介 来探索我以前的文章。感谢阅读。
-罗伯特
利用机器学习进行质量控制
Python 中的工作流、图形表示和有用的人类见解
Photo by Glenn Hansen on Unsplash
质量控制是每个生产系统中的一个重要步骤。许多商业投资旨在加强这一过程，以授予更高性能的产品。在过去的几年里，机器学习解决方案在这项投资计划中发挥了关键作用，因为它们能够轻松适应每一场比赛，并取得了巨大的成绩。
在本文中，我以分类问题的形式提出了一个标准生产单位质量控制的人工智能解决方案。遵循一种非常有趣的方法，我试图实现最佳的性能，给出结果的直观解释，并考虑到有用的人类洞察力。
我想强调这个最新的话题，因为人类的洞察力在机器学习中经常被低估！这并不奇怪，他们允许我们达到最好的表现，并采用最聪明的解决方案。
数据集
我从忠实的 UCI 存储库(钢板缺陷数据集)获取了用于分析的数据集。数据描述很差但没关系，因为很容易理解…我们有一个数据集，包含钢板的元信息，如光度、周长、边缘、厚度、面积、钢的类型等(共 27 个自变量)。
我们可以想象管理一个工厂，在生产系统的最后一步加工钢铁，生产钢板，在批发市场销售。我们的目标是最大化生产系统的效率，仅考虑产品的元数据，尝试识别钢板故障的可能类型(总共 7 种)。这样，我们将能够识别生产系统的谬误，并做出相应的反应。
在我们处理的 1941 个样本中，总故障的分布是不平衡的，有利于’其他故障’类:
df = pd.read_csv('./Steel_Plates_Faults.csv')
label = df.Fault
df = df.drop('Fault',axis=1)
label.value_counts().plot.pie(figsize=(6,6))
label distribution
第一个模型
我们很着急，想马上得到一些结果。所以我们收集了所有的数据并进行梯度推进。
X_train, X_test, y_train, y_test = train_test_split(df, label, random_state=42, test_size=0.2)gbc = GradientBoostingClassifier(n_estimators=500)
gbc.fit(X_train, y_train)
我们能够实现 0.807%的整体精度。
cnf_matrix = confusion_matrix(y_test, gbc.predict(X_test))
plot_confusion_matrix(cnf_matrix, classes=np.unique(label), title=”Confusion matrix”)
plt.show()
如果我们画出混淆矩阵，可以看出我们的算法不能很好地分类 Other_faults 类。第一个结果迫使我们放慢脚步，稍微思考一下。
个人认为，调查一个现象最好的方法是制作一个情节。出于这个原因，我把我们用来拟合梯度推进的所有变量都画了出来。为此，我将初始维度(27 个变量)减少到仅 2 个维度来拟合 TSNE。
scaler = StandardScaler()
scaler.fit(X_train.astype('float64'))tsne = TSNE(n_components=2, random_state=42, n_iter=300, perplexity=5)
T = tsne.fit_transform(scaler.transform(df.astype('float64')))plt.figure(figsize=(16,9))
colors = {0:'red', 1:'blue', 2:'green', 3:'pink', 4:'black', 5:'orange', 6:'cyan'}
plt.scatter(T.T[0], T.T[1], c=[colors[i] for i in LabelEncoder().fit_transform(label)])
TSNE on ALL the data at our disposal
这是对我们结果的清晰而漂亮的解释！我们(以及算法)无法将其他错误(粉色点)与剩余的类明确区分开来。这样，来自混淆矩阵的 Other_Faults 的召回值是有意义的。Other_Faults 是一个噪声类，我们必须在分析中考虑这一方面。
要点
Other_Faults 是一个吵闹的班级是什么意思？为了回答这个问题，我们利用臭名昭著且被低估的人类洞察力。
假设人类在今天的生产系统中进行质量检查。如果这些人检查一块表面有明显凸起或污点的钢板，这块钢板很容易贴上标签。但是，如果这些人检查一个表面有凸起和污点的盘子，同时贴上标签，那就不那么容易了！(如有疑问，放在其他 _ 故障)。
这只是一个例子，但就个人而言，它澄清了我们的情况:Other_Faults 类需要小心处理，因为它包含了许多质量检查的未定义情况。
有了这个宝贵的考虑，我们就可以安全前进了！如上所述，我尝试绘制数据集中的所有钢板，考虑所有变量，但不包括属于其他断层的钢板(粉色点)。
tsne = TSNE(n_components=2, random_state=42, n_iter=300, perplexity=5)
T = tsne.fit_transform(scaler.transform(df[label != 'Other_Faults'].astype('float64')))plt.figure(figsize=(16,9))
colors = {0:'red', 1:'blue', 2:'green', 3:'black', 4:'orange', 5:'cyan'}
plt.scatter(T.T[0], T.T[1], c=[colors[i] for i in LabelEncoder().fit_transform(label[label != 'Other_Faults'])])
TSNE on ALL the data without Other_Faults
相当不错！我们已经去除了由其他故障引起的噪声，现在类别被很好地分开了。
第二个模型
在这一点上，我们试图建立一个不考虑 Other_Faults 类的模型。我们如上所述进行梯度增强。
X_train2, y_train2 = X_train[y_train != 'Other_Faults'].copy(), y_train[y_train != 'Other_Faults'].copy()
X_test2, y_test2 = X_test[y_test != 'Other_Faults'].copy(), y_test[y_test != 'Other_Faults'].copy()gbc2 = GradientBoostingClassifier(n_estimators=500)
gbc2.fit(X_train2, y_train2)
现在准确率 0.909%，提高了 10 个百分点。
当然，这是一个好结果，证实了我们推理的正确性，但是第二个模型再现了一个不现实的场景。这样，我们假设 Other_Faults 类不存在，并且所有的错误都很容易区分和标记。通过我们的第一个模型，我们已经证明这不是我们的情况。因此，我们需要一种方法来翻译机器学习语言中的不确定性，这种不确定性出现在人们试图对模糊的钢板进行分类时。
强加一个门槛
我已经对这种不确定性进行了编码，在我们的最终预测中为每一类设定了一个阈值。为了建立这个阈值，我用我们的第二个模型对 Other_Faults 样本进行了预测，并保存了它，保持了每个预测类的分离度(如下所示)。
def predict(feature, model, threshold_map=None): confidence = model.predict_proba(feature).max()
label = model.predict(feature)[0] if threshold_map and label in threshold_map:
if confidence >= threshold_map[label]:
return {"label": label, "confidence": confidence}
else:
return {"label": "OTHERS", "confidence": confidence}
elif threshold_map == None:
return {"label": label, "confidence": confidence}
else:
print(label, 'not in threshold map') pred_lab = []
pred_conf = []
for row in tqdm.tqdm(X_train[y_train == 'Other_Faults'].values):
pred = predict([row], gbc2)
pred_lab.append(pred['label'])
pred_conf.append(pred['confidence'])other_pred = pd.DataFrame({'label':pred_lab, 'pred':pred_conf})
diz_score = other_pred.groupby('label')['pred'].apply(list).to_dict()plt.figure(figsize=(18,5))
plt.boxplot(diz_score.values(), labels=diz_score.keys())
plt.grid(False); plt.show()
probability scores and associated predicted labels in Other_Faults
接下来，我计算了每个预测类别的移动阈值:我在每个类别(红色方块)中采用了根据分数分布计算的 0.30 个百分点。
threshold_p = {}
for lab in diz_score.keys():
threshold_p[lab] = np.percentile(diz_score[lab],30)plt.boxplot(list(diz_score.values()), labels=list(diz_score.keys()))
plt.plot(range(1,len(threshold_p.keys())+1), list(threshold_p.values()), 'rs')
plt.show()
thresholds for every probability scores distributions
实际上，我们利用这个阈值来判断钢板是否确实属于给定的失效类别。如果我们的预测低于阈值，我们就没有足够的信心将其分类，因此我们将其标记为 Other_Faults。
采用这种技术，我们能够达到 0.861%的准确度(在没有其它故障的测试数据中)。如果我们将提高阈值，我们将失去精度点，但我们将获得更高的精度，等等。
Red: Accuracy, Blue: Precision
关于 Other_Faults 类，我们假设它是以‘优柔寡断类’的形式存在的，它包含了被模型分类为低置信度的所有样本。同时，如果置信度高于阈值(我们相信这一点)，我们假设原始 Other_Faults 类的所有样本都属于模型所指向的类。
最后，如果我们采用调整 Other_Faults 类的大小再次绘制原始数据，我们可以看到噪声减少(粉红色点集中)。
final_pred = []
for row in tqdm.tqdm(X_test2.values):
final_pred.append(
predict([row], gbc2, threshold_map=threshold_p)["label"]
)tsne = TSNE(n_components=2, random_state=42, n_iter=300, perplexity=5)
T = tsne.fit_transform(scaler.transform(pd.concat([X_train,X_test]).astype('float64')))plt.figure(figsize=(16,9))
colors = {0:'red', 1:'blue', 2:'green', 3:'pink', 4:'black', 5:'orange', 6:'cyan'}
plt.scatter(T.T[0], T.T[1], c=[colors[i] for i in LabelEncoder().fit_transform(other_final_pred)])
TSNE on ALL the data with the threshold
摘要
在这篇文章中，我提出了质量控制中故障分类的工作流程。我收到了一些钢板样本，并开始对它们进行分析，以便对故障进行正确分类。在第一步之后，我注意到数据结构中的一些模糊行为，于是我开始调查… 基于我的人类洞察力，我提出了一个新的问题愿景，我试图解决它，并提出了我个人的解决方案。
保持联系: Linkedin
质量胜于数量:构建完美的数据科学项目
credit: https://www.housetohouse.com/diamonds-in-the-rough/
在初创公司的行话中，“虚荣指标”是公司为了让世界——有时是自己——相信他们比实际情况做得更好而跟踪的一个数字。
举一个突出的例子，大约八年前，Twitter 宣布每天有 2 亿条推文通过其应用程序发送。这是一个很大的数字，但它并不像看起来那样相关:这些推文的很大一部分是由机器人发送的。此外，对 Twitter 作为一家公司的长期生存能力来说，真正重要的不是每天发送的推文数量；它是每日活跃用户的数量，以及在他们离开网站之前你可以向他们展示的广告数量。
虚荣指标无处不在，当我们为它们优化时，它们真的会阻碍我们，而不是为重要的事情优化。他们让我们团团转，不明白为什么我们的努力没有结果。
现在，我在一家数据科学导师创业公司工作。作为我工作的一部分，我审阅了许多由有抱负的数据科学家整理的 GitHub 投资组合。人们很难忽视一个特别的虚荣指标，许多人似乎以取得实际进展为代价来优化这个指标:他们投资组合中数据科学项目的数量。据我所见，很大一部分有抱负的数据科学家陷入了一个螺旋，即使用像sklearn和pandas这样的工具构建越来越多的数据科学项目，每个项目在过去的时间里都只有增量改进。
我想在这里探索的是打破这种恶性循环的方法，通过使用我们从看到几十个学员将他们的项目转化为工作面试并最终转化为工作机会中学到的一些关键经验。
所以，事不宜迟，以下是:一步一步地指导你建立一个伟大的数据科学项目，将带你超越 scikit-learn/pandas 螺旋，并让你尽快获得面试机会。
0.关键项目设计原则
在我们进入细节之前，这里有一些我们发现的一般原则，可以最大化一个项目转化为面试或工作的机会:
- 你的项目应该是原创的。
- 你的项目应该证明你有尽可能多的相关技能。
- 你的项目应该表明你能做的不仅仅是处理数字。
- 你的项目应该易于展示。
现在让我们看看这四个原则如何转化为具体的项目特性。
1.从哪里获取数据
决定要使用哪个数据集是设计项目时最关键的步骤之一。
当你这样做的时候，永远记住原则 1 :你的项目应该是原创的。
以分析简历为生的技术主管和招聘人员每天会看到数百份简历，每份都有 3 到 4 个展示项目。你不希望你的简历成为他们今天看到的第 23 份分析泰坦尼克号生存数据集或 MNIST 的简历。作为一条规则，远离流行的数据集，甚至远离“训练轮”数据集，如 MNIST。正如我在之前所讨论的，在简历中引用这些对你的伤害大于帮助。
另外要记住的是原则 2 :你的项目应该展示尽可能多的相关技能。
除非你在一家大公司工作，在那里你的工作是高度专业化的，否则你将在工业中使用的数据很可能是肮脏的。非常脏。设计不良的模式，应该是float的int，T2 值，缺少条目，半缺少条目，缺少列名，等等。等。如果你想让雇主相信你具备在第一天就提高工作效率的所有技能，使用脏数据是一个很好的方法。出于这个原因，我一般建议避免 Kaggle 数据集(通常是预先清理过的)。
那么如果你也不能用 Kaggle 还剩下什么呢？网页抓取。很多很多。
使用像beautifulsoup或scrapy这样的库，从网上搜集你需要的数据。要么这样做，要么使用免费的 API 来构建一个别人没有的自定义数据集——并且您必须自己清理和争论。
是的，它比从 scikit-learn 导入虹膜数据集花费的时间更长。但这正是为什么很少有人这么做——也是为什么如果你这么做了，你更有可能被注意到。
2.使用 model.fit()之前要做什么
“训练轮”数据集通常有一两个明显的应用。
例如，泰坦尼克号数据集似乎提出了一个明确的分类问题:很难不想到，你可以做的最明显的事情是试图预测一个给定的人是否会在灾难中幸存。
但行业问题并不总是这样。通常，您会有一堆(肮脏的)数据，您需要弄清楚如何利用这些数据为您的公司创造价值。这就是原则 3 的用武之地:一个理想的项目不仅能证明你能够回答重要的数据科学问题，还能证明你能够提出这些问题。
一般来说，你如何提出好的问题来问？一个好的开始是做数据探索。
散点图、相关矩阵、维度缩减和可视化技术几乎都应该包含在这个步骤中。它们帮助你理解你收集的数据，以便你可以在进入项目的机器学习/预测阶段时想到好的问题，并通过为你提供易于在面试前和面试期间向面试官和招聘人员展示的情节，获得满足原则 4 的额外好处。
人们很容易忽视数据探索的重要性，但它确实是任何优秀数据科学项目中最关键的步骤之一。理想情况下，光是数据探索就能产生一两个令人惊讶的见解——这些见解将成为你在技术面试中讨论的绝佳素材。
3.主要结果
credit: screenshot from https://www.youtube.com/watch?v=BxizdTrItTk
当你决定你希望你的项目的主要产出是什么(即，你希望返回什么样的预测，或者你希望能够得出什么样的结论作为你的项目的主要结果)时，记住原则 4 是很重要的:不管产出是什么，如果它容易炫耀、好玩或者两者兼而有之，那是最好的。
出于这个原因，我建议将您的项目作为一个 web 应用程序向外界公开(使用 Flask 或其他一些基于 Python 的 web 开发框架)。理想情况下，你应该能够在聚会或面试中接近某人，让他们尝试几个输入参数，或摆弄几个旋钮，并向他们返回一些(理想情况下视觉上有吸引力的)结果。
将最终模型部署为 web 应用程序的另一个好处是，如果你还不知道 web 开发的基础知识，它会迫使你学习这些知识(如果你已经知道了，那么它会向雇主证明事实就是如此)。因为大多数面向产品的公司在他们产品的某一点上使用 web dev，如果有必要的话，理解服务器/客户机架构和基本的 web dev 可以帮助您更容易地将您的模型集成到生产环境中。
4.球场
一旦你建立了你的项目，你会想要开始向潜在的雇主推销它。这种推销应该不仅仅是在某人面前闪烁你的手机屏幕，告诉他们玩几个旋钮。
为了让你的项目更吸引人，确保你有一个关于你所做的事情的故事。理想情况下，这个故事应该包括你在数据探索或模型评估阶段获得的一两个意想不到的见解(例如，“事实证明，这个类很难与其他类区分开来，因为[原因]”)。
这对您有所帮助，因为它:
- 围绕你的项目编一个更容易(也更有趣)让面试官记住的故事；和
- 清楚地表明，你是一个重视弄清数据科学问题的人。
重复
当你向潜在雇主推销你的项目，并向其他数据科学家炫耀时，尽可能多地获得反馈，并迭代你的项目，以增加它的影响。
当你决定根据反馈对项目进行哪些改进时，优先考虑那些涉及学习新技能的事情，优先考虑那些当时最需要的技能。充分发展你的项目，而不是分散你的精力，最终你会拥有全面的技能。
但最重要的是，你会省去为虚荣指标盲目优化的时间，比如你已经完成的项目总数，所以你可以专注于唯一有价值的指标:被聘用。
量化、理解、建模和预测金融时间序列
确定时间序列动量的赫斯特指数
动量识别和计量经济学方法
Image by author
准确预测股票价格是一项艰巨的任务。由于内在的复杂行为，不规则的时间行为在股票市场价格中无处不在。在这里，我将展示一个预测模型框架，用三阶段方法预测金融市场的未来回报。
- 分形建模和递归分析，并检验有效市场假说以理解时间行为，从而考察自回归特性。
- 在 VAR 环境下进行格兰杰因果检验，以探索因果互动结构，并确定预测分析的解释变量。
- ML 和 ANN 算法学习内在模式和预测未来运动。
我将使用 2000 -2019 年以来的贵金属(黄金和白银)股票价格、能源股票(原油)价格和 S&P500 指数。目标是估计未来收益以及这些产品与 S&P 指数的关系。
数据预处理和描述性统计:
在做了所有必要的数据净化后，用以前的值填充丢失的值，重命名列，索引日期等。下面是我们可以做进一步分析和调查的输出。数据净化需要花费大量的时间和精力。因此，我将跳过对数据处理过程的解释，而是专注于这里的目标。
if __name__ == "__main__":
df = pd.read_excel('brownian data.xlsx', index_col=0)
# removing unnecessary columns
df = df.drop(['Date', 'Year', 'NaturalGasPrice'], axis=1)
# converting 'DatesAvailable' to datetime
df['DatesAvailable']= pd.to_datetime(df['DatesAvailable'])
# setting 'DatesAvailable' as index column
df.set_index('DatesAvailable', inplace=True)
df1 = pd.read_excel('S&P Futures.xlsx', parse_dates = True,
index_col=0)
DF = df1.loc['20190729':'20000104']
data = [DF,df] # combining dataframes
result = pd.concat(data, axis=1)
# renaming column
result = result.rename(columns = {"Price": "SPPrice"})
DATA = result.fillna(method ='pad')
# filling the missing values with previous ones
DATA.index.name = 'Date'
print(DATA.head())
DATA.plot(subplots=True, layout = (2,2),
figsize = (15,6), sharex = False, grid =True)
plt.tight_layout()
plt.show()
所有系列都采用每日收盘价。这些图显示了 S&P 指数的明显趋势；对于本质上相当随机的商品。视觉上可以假设，没有一个序列是稳定的，商品具有布朗运动。为了便于理解，结果以表格的形式给出。
偏斜度和峰度值证实没有一个序列遵循正态分布。百分位数和标准差表明指数和黄金价格有很大的差距。如果是由随机波动引起的，这一系列中黄金的巨大价差可能会使准确预测变得困难。
Mann-Whitney test
Mann-Whitney U 检验的零假设是数据样本的分布之间没有差异。
Unit root test Original series
检验统计证实没有一个序列符合正态分布。这也是非参数和非平稳序列的指示，并证明了高级 ML 和 DNN 算法用于预测建模练习的部署。然而，如果时间序列遵循布朗运动，我们不会得到一个稳定的结果。所以，检验 RWH(随机漫步假说)是很重要的。
Unit root test 1st order difference
结果表明该序列是一阶平稳的。因此，我将考虑回报序列进行计量经济分析，以评估因果关系的方向。
非线性动力学:
在这里，我们将执行分形建模和递归量化分析(RQA)来检查 RWH，并获得关于时间演化模式的更深入的见解。让我们看看 FD(分形维数)，R/S(重标范围)，H(赫斯特指数)和 RQA(递归量化分析)。
让我们来了解一下赫斯特指数。赫斯特指数被用来衡量时间序列的长期记忆。赫斯特指数的目标是为我们提供一个标量值，帮助我们识别一个序列是均值回复、随机游走还是趋势。这是一个统计推断。特别是:
- h< 0:5 — Anti-persistent time-series which roughly translates to mean reverting.
- H = 0:5 — The time series is random walk and prediction of future based on past data is not possible.
- H >0:5——持久的时间序列，大致可以解释为趋势。
FD = ln(N)/ln(1/d)，N =圈数，D =直径。这个等式显示了圆的数量与直径的关系。对于时间序列，FD 的值介于 1 和 2 之间。布朗运动的 FD 是 1.5。If 1.5 < FD < 2, then a time series is an anti-persistent process, and if 1 < FD < 1.5, then the series is a long memory process (persistent). H is related to FD (FD =2-H) and a characteristic parameter of long-range dependence. In case of H, the value of 0.5 signifies no long-term memory, < 0.5 means anti-persistence and > 0.5 表示该过程是跨时间相关的，并且是持久的。R/S 是 FD 的中心工具，其计算方法是将其平均调整累积离差序列的范围除以时间序列本身的标准离差(1)。它是表征时间序列散度的度量，定义为给定持续时间(T)的均值中心值范围除以该持续时间(2)的标准偏差。
递归量化分析(RQA)可以处理序列中的非平稳性，有助于理解隐藏在金融市场中的复杂动态。
现在，让我们通过计算 REC、DET、TT 和 LAM 等指标来使用量化技术。
计算 H:
if __name__ == "__main__":
index = DATA[['SPIndex']]
lag1, lag2 = 2,20
lags = range(lag1, lag2)
tau = [sqrt(std(subtract(index[lag:], index[:-lag]))) for lag in lags]
m = polyfit(log(lags), log(tau), 1)
hurst = m[0]*2
gold = DATA[['GoldPrice']]
lag1, lag2 = 2,20
lags = range(lag1, lag2)
tau = [sqrt(std(subtract(gold[lag:], gold[:-lag]))) for lag in lags]
m = polyfit(log(lags), log(tau), 1)
hurst = m[0]*2 crude = DATA[['CrudeOilPrice']]
lag1, lag2 = 2,20
lags = range(lag1, lag2)
tau = [sqrt(std(subtract(crude[lag:], crude[:-lag]))) for lag in lags]
m = polyfit(log(lags), log(tau), 1)
hurst = m[0]*2 silver = DATA[['SilverPrice']]
lag1, lag2 = 2,20
lags = range(lag1, lag2)
tau = [sqrt(std(subtract(silver[lag:], silver[:-lag]))) for lag in lags]
m = polyfit(log(lags), log(tau), 1)
hurst = m[0]*2print('*'*60)
print( 'hurst (Index), 2-20 lags = ',hurst[0])
print('*'*60)
print( 'hurst (Crude), 2-20 lags = ',hurst[0])
print('*'*60)
print( 'hurst (Gold), 2-20 lags = ',hurst[0])
print('*'*60)
print( 'hurst (Silver), 2-20 lags = ',hurst[0])
np.random.seed(42)
random_changes = 1\. + np.random.randn(5019) / 1000.
DATA.index = np.cumprod(random_changes)
H, c, result = compute_Hc(DATA.SPIndex, kind='price',
simplified=True)plt.rcParams['figure.figsize'] = 10, 5
f, ax = plt.subplots()
_ = ax.plot(result[0], c*result[0]**H)
_ = ax.scatter(result[0], result[1])
_ = ax.set_xscale('log')
_ = ax.set_yscale('log')
_ = ax.set_xlabel('log(time interval)')
_ = ax.set_ylabel('log(R/S ratio)')
print("H={:.3f}, c={:.3f}".format(H,c))
赫斯特指数“H”是每个范围的对数(R/S)与每个范围的对数(大小)的曲线斜率。这里 log(R/S)是因变量或 y 变量，log(size)是自变量或 x 变量。这个值表明我们的数据是持久的。然而，我们正在研究一个小数据集，不能从输出中得出 H 值明显更高的结论，尤其是商品值(0.585)，但给定的时间序列具有一定程度的可预测性。RQA 将帮助我们理解可预测性的程度。
计算 RQA:
time_series = TimeSeries(DATA.SPIndex, embedding_dimension=2,
time_delay=2)
settings = Settings(time_series,
analysis_type=Classic,
neighbourhood=FixedRadius(0.65),
similarity_measure=EuclideanMetric,
theiler_corrector=1)computation = RQAComputation.create(settings,verbose=True)
result = computation.run()
result.min_diagonal_line_length = 2
result.min_vertical_line_length = 2
result.min_white_vertical_line_lelngth = 2
print(result)
在这里，我们看到，所有时间序列的 RR(重复率)值并没有偏高，表明周期性程度较低。DET (S&P，原油和白银)和拉姆值原油，黄金和白银)较高，支持确定性结构。然而，这也证实了高阶确定性混沌的存在。
计量经济学方法:
这里采用了一系列测试程序来探索变量之间的因果相互作用结构，并确定预测分析的解释变量。
皮尔森相关性显示了 S&P 和黄金、原油和黄金、原油和白银以及黄金和白银之间的显著相关性。进行瞬时相位同步(IPA)和格兰杰因果检验。
实证研究表明，即使两个变量之间有很强的相关性，也不能保证因果关系。它不提供关于两个信号之间的方向性的信息，例如哪个信号在前，哪个信号在后。
现在，我将使用格兰杰因果检验来检查因果关系，以确定预测因素。VAR 被认为是进行格兰杰因果关系检验的一种手段。在风险值模型中，每个变量被建模为其自身的过去值和系统中其他变量的过去值的线性组合。我们有 4 个相互影响的时间序列，因此，我们将有一个由 4 个方程组成的系统。
- Y1，t = α1 + β11，1Y1，t-1 + β12，1Y2，t-1 + β13，1Y3，t-1 + β14，1Y4，t-1 + ε1，t
- Y2，t = α2 + β21，1Y1，t-1 + β22，1Y2，t-1 + β23，1Y3，t-1 + β24，1Y4，t-1 + ε2，t
- Y3，t = α3 + β31，1Y1，t-1 + β32，1Y2，t-1 + β33，1Y3，t-1 + β34，1Y4，t-1 + ε3，t
- Y4，t = α4 + β41，1Y1，t-1 + β42，1Y2，t-1 + β43，1Y3，t-1 + β44，1Y4，t-1 + ε4，t
这里，Y{1，t-1，Y{2，t-1}，Y{3，t-1}，Y{4，t-1}分别是时间序列 Y1，Y2，Y3，Y4 的第一滞后。上述方程被称为 VAR (1)模型，因为每个方程都是一阶的，也就是说，它包含每个预测值(Y1、Y2、Y3 和 Y4)的一个滞后。因为方程中的 Y 项是相互关联的，所以 Y 被认为是内生变量，而不是外生预测因子。为了防止结构不稳定的问题，我使用了 VAR 框架，根据 AIC 选择滞后长度。
# make a VAR model
model = VAR(DATA_diff)
model.select_order(12)
x = model.select_order(maxlags=12)
x.summary()
Lag selection (VAR)
滞后 4 时获得的最低 AIC 值。所以，因果关系分析是在此基础上进行的。
A = model.fit(maxlags=4, ic=’aic’) # pass a maximum number of lags and the order criterion to use for order selectionR1=A.test_causality(‘Index’, [‘CrudeOilPrice’, ‘GoldPrice’, ‘SilverPrice’], kind=’f’)R2=A.test_causality(‘CrudeOilPrice’, [‘Index’, ‘GoldPrice’, ‘SilverPrice’], kind=’f’)R3=A.test_causality(‘GoldPrice’, [‘Index’, ‘CrudeOilPrice’, ‘SilverPrice’], kind=’f’)R4=A.test_causality(‘SilverPrice’, [‘Index’, ‘GoldPrice’, ‘CrudeOilPrice’], kind=’f’)R5=A.test_causality(‘Index’, [‘CrudeOilPrice’], kind=’f’)
Granger Casuality test result
从上表中我们可以看出，S&P 指数并没有引起系列中其他股票的价格，但是其他股票的价格对 S&P 指数有显著的影响。因此，这里的因果结构是单向的。
granger_test_result = grangercausalitytests(DATA_diff[[‘Index’, ‘CrudeOilPrice’]].values,maxlag=4)granger_test_result = grangercausalitytests(DATA_diff[[‘Index’, ‘GoldPrice’]].values,maxlag=4)granger_test_result = grangercausalitytests(DATA_diff[[‘Index’, ‘SilverPrice’]].values,maxlag=4)granger_test_result = grangercausalitytests(DATA_diff[[‘CrudeOilPrice’, ‘SilverPrice’]].values,maxlag=4)granger_test_result = grangercausalitytests(DATA_diff[[‘CrudeOilPrice’, ‘GoldPrice’]].values,maxlag=4)granger_test_result = grangercausalitytests(DATA_diff[[‘GoldPrice’, ‘SilverPrice’]].values,maxlag=4)
接下来，估算 IR(脉冲响应),以评估一种资产对另一种资产的冲击影响。
IR 图显示了给定时期内预期的冲击水平，虚线代表 95%的置信区间(低估计值和高估计值)。此外，所有四个系列的回报率的方差百分比在短期内很大程度上可以由它们自己来解释。从短期来看，自身运动的冲击往往会在波动中扮演重要角色。通过格兰杰因果关系发现对其他序列有影响的序列，对方差也有边际影响。因此，因果分析的总体结果通过方差分解的结果得到验证。因果互动的结果有助于理解相互关系的结构。为了进一步证明，预测误差方差分解(FEVD)执行。基本思想是分解方差-协方差矩阵，使σ= PP 1，其中 P 是具有正对角元素的下三角矩阵，通过 Chelsi 分解获得。
Forecast error variance decomposition
FEVD 表示在自动回归中每个变量贡献给其他变量的信息量。它决定了每个变量的预测误差方差中有多少可以用对其他变量的外生冲击来解释。所有三个股票指数的回报率的方差百分比在短期内很大程度上由它们自己来解释。
但是，格兰杰因果关系不一定反映真实的因果关系。因此，为了严谨起见，使用 IPA(瞬时相位同步)从统计上验证了资产之间同步的存在。这里 IPA 用于视觉模式识别。它通过增量移动一个时间序列向量并重复计算两个信号之间的相关性来进行测量。中间的峰值相关性表示两个时间序列在那个时间最同步。带通滤波后通过希尔伯特变换实现的频域变换。
在执行任何相位同步之前，预处理阶段需要对金融数据进行去趋势分析，并去除高频噪声成分。滤波级将 SST 用作带通滤波器(SST 是一种块算法，因此数据首先被加窗)，仅应用于去趋势信号的低频振荡。带通滤波的一个重要标准是确保最终信号尽可能窄。
Pearson r 是对全局同步性的度量，它将两个信号之间的关系简化为单个值。然而，我们在这里使用瞬时相位同步测量来计算两个信号之间的瞬时同步，而不像滚动窗口相关那样任意决定窗口大小。
S&P Index & Crude Oil
S&P Index and Gold
S&P Index and Silver
Crude Oil & Gold
Crude Oil & Silver
Gold & Silver
每个图由过滤的时间序列(顶部)、每个时刻每个信号的角度(中间一行)和 IPS 测量值(底部)组成。当两个信号同相排列时，它们的角度差为零。通过信号的希尔伯特变换计算角度。这里，我模拟了一个相位同步的信号。对于每个图，信号 y1 和 y2 都处于 30Hz (30 天)。我在数据中加入了随机噪声，看看它如何改变结果。波动相位同步图表明 IPS 对噪声敏感，并强调了滤波和选择分析频带的重要性。在对波形进行实际处理之前，使用简单的移动平均和带通滤波器来消除信号中的噪声。然而，IPA 产生了一个全球指标。因此，在将信号分解成多分量的过程中，一个关键的标准是确保相关的频率在本地有效。同步的存在和持续时间反映了金融市场的动态。
预测模型
解释性结构的选择是预测建模的关键。一些广泛使用的技术指标是 SMA，MACD 和 CCI 用于趋势，STD 和 BB 用于波动，RSI 和 WR 用于动量。因此，使用原油、黄金和白银作为输入变量的多变量框架对模型进行了测试，这些变量会显著影响 S&P 指数和一系列技术指标，如下所示。
原始数据集被随机分成 85%的训练数据和 15%的验证数据。对 kNN、DT、RF、GBM、SVN 和 DNN 进行了算法搜索，以选择稳健的模型在给定数据集上进行训练。
目标是获得最低的错误，根据这一逻辑，可以看出 GBM/XGB 在训练和测试数据上都显示最低的错误率。这证明了使用 GBM 算法开发给定时间序列的预测模型的合理性。DNN 以其处理连续和大容量数据的能力而闻名。因此，DNN 也被选中开发一个能够处理高速大数据的混合预测模型。
我用五重 CV 技术进行了重型性能调整，以获得两种算法(XGB 和 DNN)的最佳性能。最后使用堆叠集成技术，将两者相结合以获得更好的预测性能。
发现原油和白银的平均均方误差、RMSE 和平均平均误差值较小，表明该模型对所有原油和白银的有效预测能力。这一结果也支持了这样一个事实，即从历史上看，黄金在股市崩盘期间往往具有弹性，两者呈负相关。这里也没有显示高 MSE 值的异常。让我们看看我们的功能是如何优先排序的。
Feature importance-XGB
Feature importance-DNN
这些特征是根据它们的相对强度和重要性顺序绘制的。这意味着几乎所有选择的特征，对模型的建立都有一定程度的重要性。
结论
在这里，我解释了精选股票和 S&P 的主要特征，并随后深入研究了它们之间的因果关系和预测分析。这里解释了一些关键的技术指标。这种预测结构是计量经济学模型和机器学习算法的结合。虽然我用 ML 算法测试过，但是，技术指标也可以用于成功的交易策略。随后必须对验证集进行前滚验证。
参考:
(1)曼德尔布罗，B. B .，&沃利斯，J. R. (1969)。分数高斯噪声的计算机实验:第 2 部分，重新标度的范围和光谱。水资源研究，5(1)，242–259 页。
(2)赫斯特，H. E .布莱克，r . p .&斯迈卡，Y. M. (1965)。长期储存:康斯特布尔的实验研究。英国伦敦。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
