TowardsDataScience-博客中文翻译-2016-2018-三十五-
TowardsDataScience 博客中文翻译 2016~2018（三十五）
SQS 消费者设计:在 Go 中管理并发性的同时实现高可伸缩性
Photo by ThisisEngineering RAEng on Unsplash
最近我不得不重新设计一个异步排队系统。在研究了几个选项之后，我选择了 AWS 简单队列服务(SQS) 和简单通知服务(SNS) 。通过这两个服务的组合，我能够复制和改进以前的(失败的)RabbitMQ 设置。AWS 产品的伟大之处在于它们是为微服务而从头开始构建的。它们抽象了复杂的异步消息传递系统的大部分复杂性，从通过消息等待期处理水平扩展到死信队列和许多其他特性，开箱即用。
根据 AWS 关于伸缩 、的建议，他们建议通过利用多线程在多个服务之间以及单个服务内进行水平伸缩。在这篇博文中，我们将重点讨论在一个服务中利用多线程使用 Golang 检索和处理来自 SQS 的消息的最佳方式。
在整个示例中，我们将处理一个包含 20，000 条消息的 AWS 队列。我们将测量 Golang 中管理并发工作者的三种不同技术，以及一个同步控制测试。我们将测量 3 分钟内消耗的项目总数，并取平均每分钟消耗的邮件数(mpm)。
所有示例都将使用 go aws-sdk 来长轮询 sqs 服务器。消息的成功接收将由一个基本处理程序处理，该处理程序在返回和完成请求之前向另一个微服务发出 http 请求。完成后，我们从队列中删除消息，这是 SQS 表达消息已被消费的方式。
控制
在这个例子中，我们将有一个控件。同步消费者
func (c *consumer) Consume() {
for {
output, err := receiveSQSMessages(c.QueueURL)
if err != nil {
//log error
continue
} for _, m := range output.Messages {
c.run(newMessage(m)) if err := h(m); err != nil {
//log error
continue
}
c.delete(m) //MESSAGE CONSUMED
}
}
}
对于同步消费者，我们得到的平均处理时间为 160mpm
基本并发
让我们添加一些 goroutines。虽然 goroutines 很便宜，但我们还是想在一定程度上控制它们。随着时间的推移，允许一百万个 goroutines 产生可能会导致我们的程序耗尽内存，运行速度比我们控制的要慢。在本例中，我们将使用一个简单的原子计数器来跟踪和添加允许的工作人员总数的限制。我们使用原子包，因为并发使用它是安全的。虽然简单，但不建议在基本应用中使用原子包，因为它们的工作方式往往与预期不同。
在下面的例子中，我们现在将允许 SQS 为每个请求批处理 10 条消息
func (c *consumer) Consume() {
c.workerPool = 50 // should be configurable
c.workerCount = 0
maxMessages := 10 for {
if atomic.LoadInt32(&c.workerCount) < c.workerPool {
output, err := receiveSQSMessages(c.QueueURL, maxMessages)
if err != nil {
continue
} for _, m := range output.Messages {
atomic.AddInt32(&c.workerCount, 1)
go c.run(newMessage(m))
}
}
}
}func (c *consumer) run(m *message) error {
defer atomic.AddInt32(&c.workerCount, -1) if err := h(m); err != nil {
return err
}
return c.delete(m) //MESSAGE CONSUMED
}
对于一个基本的并发消费者，我们得到的平均处理时间为2700 MPM。这是一个巨大的进步。
有趣的是，尽管我们允许一次运行 50 个 go routine，但是一次只能运行 2 个响应(总共 20 个 go routine)。这是因为处理消息的速度比长轮询从 SQS 检索消息的速度快。我们现在发现来自 SQS 的 http 请求是主要的瓶颈
工人池
工作池是管理应用程序中 goroutines 的惯用方法。它们在内存和速度方面都更高效，并在所有准备好的工作人员之间合理地分配工作负载。在大多数情况下，这将是最终的解决方案(提示:它不是)
func (c *consumer) Consume() {
maxMessages := 10
jobs := make(chan *message)
for w := 1; w <= c.workerPool; w++ {
go c.worker(w, jobs)
} for {
output, err := retrieveSQSMessages(c.QueueURL, maxMessages)
if err != nil {
//log error
continue
} for _, m := range output.Messages {
jobs <- newMessage(m)
}
}
}// worker is an always-on concurrent worker that will take tasks when they are added into the messages buffer
func (c *consumer) worker(id int, messages <-chan *message) {
for m := range messages {
if err := h(m); err != nil {
//log error
continue
} c.delete(m) //MESSAGE CONSUMED
}
}
首先，我们创建一个工作池池(本例中有 50 个)。这些工人正在寻找工作。消息通道上的范围是一个阻塞操作，因此工作者将处于休眠状态，直到有消息可用。如果您以不同的方式处理错误或消息处理程序，您可以在 For 循环中使用 select 以相同的方式处理各种选项。
此外，在使用者中发送消息也是一种阻塞操作。只有在有工作人员可用的情况下，它才会继续。这确保了如果没有可用的工作线程，使用者将不会继续检索消息。
这种方法的伟大之处在于，它在不同的工作人员之间实现了一种近乎循环的方式，并且在大多数情况下速度更快。
对于一个工人池消费者，我们得到的平均处理时间为 2，766 mpm。与前面的例子相比，这并不是一个巨大的改进。在这种情况下，虽然代码更加习惯和可靠，但我们仍然有相同的单点故障和瓶颈，因为对 AWS 的长轮询请求只是不够快。
最终解决方案
下一个合乎逻辑的步骤是通过将 http 请求本身合并到 worker 中来消除瓶颈。我们脱离了工人池的概念，因为我们不再需要一个调度程序(即一个通过通道向工人池发送作业或工作负载的系统)。我们只需要一组 goroutines，它可以无限期地查询 sqs 服务器上的消息并处理它们。
func (c *consumer) Consume() {
for w := 1; w <= c.workerPool; w++ {
go c.worker(w)
}
}func (c *consumer) worker(id int) {
for {
output, err := retrieveSQSMessages(c.QueueURL, maxMessages)
if err != nil {
continue
} var wg sync.WaitGroup
for _, message := range output.Messages {
wg.Add(1)
go func(m *message) {
defer wg.Done()
if err := h(m); err != nil {
//log error
continue
}
c.delete(m) //MESSAGE CONSUMED
}(newMessage(m))
wg.Wait()
}
}
}
在 6750 mpm 时，我们成功地将消息处理速度提高了 200%,比同步示例提高了 4000%。
在本例中，我们根据可配置的数量创建了一组工作线程，它们都负责自己的长轮询和消息处理。当收到一组消息时，waitgroup 用于同步一组额外的 goroutines，以便在再次查询之前管理消息负载
虽然这种解决方案偏离了工人池的优雅，但它消除了瓶颈和单点故障。最终结果是消费者的速度成倍提高，只需一个实例就可以完成 50 个实例。
该解决方案可以通过添加额外的工作线程来扩展 CPU 容量，也可以通过添加额外的消费者实例来无限扩展。如果成本是一个问题，可以在休眠期间缩减工作人员，并在有更多消息需要处理时自动增加工作人员
有别的解决方法吗？请留下评论
更新:我已经在这里开源了我用来创建这个解决方案的库https://github.com/qhenkart/gosqs
SquadAI:用于构建、管理和评估机器学习工作流的群体驱动平台
由于近年来非结构化数据的爆炸式增长，企业缩小准确数据的监管和提取可操作的见解之间的差距变得越来越具有挑战性。随着众包的出现，现在更容易收集和注释训练机器学习(ML)模型所需的前所未有的大量数据。建立一个高效的机器学习模型需要不断的迭代和修正。
ML 工程师构建和部署机器学习模型所遵循的典型流程包括:
- 训练、验证和测试数据集的管理，
- 数据集的清理和预处理，
- 特征选择和参数调整，
- 比较各种验收指标(准确性、敏感性、特异性、精确度等)和
- 将模型移至生产环境，以进行大规模预测。
当一个人需要为不同的业务问题训练、部署和管理数百个这样的模型时，就会出现令人畏惧的情况。
在 Squad ，我们正在构建 SquadAI，这是一个人在回路中的机器学习平台，用于管理 ML 模型的数据管理、培训、测试、评估和部署的整个过程。在这篇博文中，我们将讨论 SquadAI 的架构和各个模块，以及它对扩展业务流程和满足我们的客户和 Squad 机器学习团队的速度、准确性、灵活性和成本 SLA 的影响。
小队的诞生
在每一个行业中，为了达到规模，都需要执行某些流程和数字操作。例如，像阿里巴巴和亚马逊这样的大型电子商务市场维护着数百万种产品。这些产品经过质量控制操作，如产品分类和标签，内容审核和丰富。所有这些操作都需要特定的数据工作流来将庞大的非结构化数据转换为更有用的格式，以便于分析和业务洞察。由于深度、密集和多样化数据的爆炸式增长，企业采用不同的方法使准确和可用的数据可用于数据驱动的流程变得至关重要。
在 Squad，我们正在使用一个智能工作流构建器来颠覆业务流程外包行业，该构建器在单个平台上结合了众包和机器学习的力量。众包利用高质量分布式劳动力的经验来执行定制的微任务。在对从这种微任务获得的注释数据进行严格检查之后，它可以用于训练机器学习模型。
机器学习团队的挑战
为现实世界的微任务创建 ML 模型需要不断的迭代、评估，当然还有修正。为了建立有效的 ML 模型，机器学习团队为给定的任务收集数据，为精选的数据构建假设，预处理数据以提取特征，运行算法以学习模型，对照假设验证模型，并基于它们的评估来改进模型和假设。
一旦密集的实验完成，模型就被部署到生产环境中进行实时推理。团队通常必须执行几个这样的实验，以便为给定业务流程的自动化在各种微任务上建立 ML 模型的优化工作流。
存在各种挑战，包括:
- 无法追溯模型构建的整个过程和不同实验的见解，
- 无法在团队中重用和共享公共模型管道，
- 花费在维护培训、发布和管理新模型的基础设施上的大量时间，
- 存储和分析不同阶段模型性能的效率低下，导致重复昂贵的实验。
Figure 1. Optimized Workflow for Data Quality Control with Human-in-the-Loop Machine Learning for Our Trust and Safety Product
小队概述
我们介绍了正在进行的 SquadAI 工作，这是一个用于构建、管理和评估机器学习工作流的人在回路平台。我们讨论了小队的不同组成部分。
SquadAI 是一个平台，旨在大规模地简化跨 Squad 的数据管理和模型构建过程。我们的愿景是构建一个产品，只需点击几下鼠标，就可以轻松地将新构建的 ML 工作流集成到生产环境中并进行管理。图 1 展示了使用 SquadAI 进行数据质量控制的优化工作流程。它由不同级别的各种块组成，使用 SquadAI 固有的共享代码块和管道构建。“人在回路”模块用于获取不同现实世界任务的学习模型的注释数据，以及基于专家反馈对这些模型的持续改进。这个平台的三个主要组件是构建器、自动机和内核。
Figure 2, illustrates major components of SquadAI training architecture. The Builder, Automator and Kernel.
建造者
构建器用于配置我们的机器学习工作流。一个工作流是一个带有边的图，只有在满足特定条件时才会被激活。例如:如果其中一个级别的答案是 A ，则可能流向节点 Na 或者答案是 B ，则应流向节点 Nb 。就像一个图一样，一个工作流由许多节点 ( 级 )组成。这些级别具有不同的复杂性，类似于现实世界的任务。例如，验证假货、NSFW、服装和模糊检查的列表的 C2C 问题的典型工作流程可以包括四个级别，每个级别用于假货检测、NSFW、布料分类和模糊检测。
对于任何复杂的 C2C 问题，我们都有一个由许多级别组成的工作流，机器学习团队在这些特定的级别上工作，并试图通过建立相关的机器学习模型来实现自动化。为了实现这一点，图中有一个节点将数据和级别名称发送给内核、小队骨干。内核根据为该级别设计的工作流异步运行数据。 自动机 对该数据调用一系列集成模型，并将预测返回给内核。所有这些预测都通过一个网络挂钩发送回构建器。整个过程必须满足特定的 SLA，时间从几秒钟到几分钟不等。如果内核没有在定义的 SLA 内回传结果，数据流向【HIL】模块进行判断。在满足 SLA 的情况下，针对特定级别超过 HIL 块，并且针对内容调节，将传入的样本【SKU】路由到进一步的级别。图 3 示出了一个典型的工作流构建，使用构建器来检测输入的 SKU 是否模糊以及它是否包含宠物玩具。
Figure 3, a typical two level workflow build using Builder for detecting if incoming SKU is blur or not and contains a Pet toy. Data Points are sent to each level, and corresponding model workflow at each level is used for predicting the target label, if the prediction score is above a threshold it is routed to next level, if the socre is below thresold, the data unit is routed to Human-in-the-loop.
自动机
Automator 由 BaseNode 组成，原生支持 python 中各种机器学习算法的开发。它还支持外部框架和库，如 TensorFlow 、 Tesseract 等。BaseNode 可以灵活地重复使用代码，并为不同的微观任务构建模型，例如检测假货、NSFW、基于价格和描述的可疑列表、基于文本分类的类别校正或图像中的对象检测。然后，可以将多个模型集成在一起，以对工作流所代表的复杂任务进行预测。任何新的工作流都可以轻松配置，相应的信息存储在内核中，这使得我们的机器学习团队可以轻松地将任何工作流投入生产。下面是我们的BaseTrainingPipeline的一些方法的代码片段。
内核
内核用于存储自动机和构建器的每个阶段。SKU 是由构建器消耗的非结构化数据，然后被转换成单个单元 数据点 并存储在表中的单独行中。每当数据单元 DU 被加载时，一个 DU_workflow_prediction 请求被创建并存储在相应的表中。这些预测请求 id 随后由自动机一起缓冲。每次从自动机接收到一个预测，它被保存在不同的表DU _ Workflow _ Prediction中。我们还节省了每个模型和模型管道每个阶段所花费的时间，包括预测时间。集合模型系列的所有预测都存储在表DP _ ML _ model _ prediction中，用于评估和分析。我们将从生成器获得的数据缓冲一段时间，然后进行批处理，而不是对每个数据单元进行单个预测。我们使用 R edis 队列来缓冲数据的预测请求 id，在定义的时间限制(可配置)后，我们弹出队列，获取它们的预测，并将其返回给构建器。我们使用类似于 芹菜 和 兔子 MQ 的工具用于异步基础设施。我们已经使用 Docker 设置了 RMQ 和芹菜工人。
Figure 3, illustrates interaction of Automator with Kernel. Automator is used to configure machine learning model workflow at a particular level of our C2C Data Quality Control workflow.
未来
正在进行的 SquadAI 工作是一个单一的平台，利用群体的智慧提取、预处理非结构化数据并将其转化为可用的形式，这将使我们能够解决复杂的问题，如 C2C 市场的内容审核。由于该平台不依赖于任何特定的领域，它可以用于任何类型的数据，无论是文本、图像还是语音。我们使用通过我们的劳动力获得的带注释的数据来学习一系列机器学习模型，这些模型可以通过最少的代码更改轻松配置。内核为 SquadAI 的每个阶段建立了索引，以便于查询和评估。SquadAI 的不同模块有助于管理模型构建过程中涉及的不同阶段，从而提高了 Squad 的数据科学团队的工作效率。squad 的 ML 工程师现在可以轻松地配置新的实验，将它们与基线进行比较，并且只需点击几下鼠标就可以概括见解。
感谢 Vedvasu Sharma 令人印象深刻的数字和整个 ML 团队( Aniket Bhatnagar 、 Medha Katehar a、 Pragya Jaiswal 、 Priyank Jain 和 Ketan Bhatt )为 SquadAI 做出的贡献。
点击链接阅读更多关于进化“内核”的进化:小队的骨干。
Squad 的机器学习团队最近冒险为我们的主要资格产品 SquadVoice 构建了一个令人惊叹的质量评分框架。请继续关注我们如何利用 SquadAI 进行语音数据快速实验的更多更新。
压缩和激励网络
在 ImageNet 上建立一个新的艺术状态
挤压和激励网络( SENets )为 CNN 引入了一个构建模块，以几乎没有计算成本的方式改善了通道的相互依赖性。它们被用于今年的 ImageNet 比赛，并帮助将结果比去年提高了 25%。除了这种巨大的性能提升，它们可以很容易地添加到现有的架构。主要想法是这样的:
让我们为卷积块的每个通道添加参数，以便网络可以自适应地调整每个特征图的权重。
虽然听起来很简单，但就是这样。所以，让我们更仔细地看看为什么这工作得这么好，以及我们如何用五行简单的代码潜在地改进任何模型。
“为什么”
CNN 使用他们的卷积滤波器从图像中提取等级信息。下层可以发现边缘或高频等琐碎的上下文，而上层可以检测人脸、文本或其他复杂的几何形状。他们提取有效解决任务所需的任何东西。
所有这些都是通过融合图像的空间和通道信息来实现的。不同的过滤器将首先在每个输入通道中找到空间特征，然后在所有可用的输出通道中添加信息。我在另一篇文章中详细介绍了这个操作。
您现在需要了解的是，在创建输出要素地图时，网络会对其每个通道进行同等加权。SENets 通过添加内容感知机制来自适应地加权每个频道来改变这一点。在最基本的形式中，这可能意味着给每个通道添加一个参数，并给它一个线性标量，表示每个通道的相关程度。
然而，作者把它推进了一点。首先，他们通过将特征图压缩为单个数值来获得每个通道的全局理解。这导致大小为 n 的向量，其中 n 等于卷积信道的数量。之后通过一个两层的神经网络进行馈入，输出一个同样大小的向量。这些 n 值现在可以用作原始特征图上的权重，根据重要性缩放每个通道。
“如何”
在最后一段中，你可能已经失去了一点信心，这真的像我承诺的那样简单。因此，让我们直接开始实施 SE-block。
def se_block(in_block, ch, ratio=16):
x = GlobalAveragePooling2D()(in_block)
x = Dense(ch//ratio, activation='relu')(x)
x = Dense(ch, activation='sigmoid')(x)
return multiply()([in_block, x])
- 给该函数一个输入卷积块和它所拥有的当前通道数
- 我们使用平均池将每个通道压缩为一个数值
- 一个全连接层后接一个 ReLU 函数，增加了必要的非线性。它的输出通道复杂度也降低了一定的比例。
- 第二个完全连接的层之后是 Sigmoid 激活，为每个通道提供平滑的门控功能。
- 最后，我们根据侧网络的结果对卷积块的每个特征图进行加权。
这五个步骤几乎不会增加额外的计算成本(不到 1%)，并且可以添加到任何模型中。
Vanilla ResNet Module vs the proposed SE-ResNet Module
作者表明，通过向 ResNet-50 添加 SE-blocks，您可以期望获得与 ResNet-101 几乎相同的精度。这对于一个只需要一半计算成本的模型来说是令人印象深刻的。本文进一步研究了其他体系结构，如 Inception、Inception-ResNet 和 ResNeXt。后者引导他们修改版本，在 ImageNet 上显示 3.79%的前 5 名错误。
How SENets improve existing architectures
SENets 最让我惊讶的是它们是如此简单而有效。能够以几乎零成本的方式将这种方法添加到任何模型中，应该会让您跳回绘图板，重新训练您曾经构建的所有东西。
这是我计划写的一系列论文摘要的第一篇。我想强迫自己阅读和理解新的论文，以跟上最近的 AI 趋势。如果你想投稿或者在我的文章中发现错误，请联系我。
SRGAN，TensorFlow 实现
(查找代码关注本帖此处。)
我们都在一部犯罪惊悚片中看到过这样的时刻，主人公让技术人员放大并增强图像，车牌变得可读，像素化的面孔变得清晰，破案所需的任何证据都被找到了。
我们都嘲笑过、笑过、小声嘀咕过丢失的信息是如何无法恢复的。
不再是了。嗯，算是吧。原来信息只是部分丢失了。类似地，作为人类，我们可能会根据我们对世界的了解来推断模糊图像的细节，现在我们可以成功地将相同的逻辑应用于图像，以恢复因分辨率效果而丢失的“照片级真实感”细节。
这是超分辨率的本质，通过对低到高分辨率图像转换的复杂理解，在亚像素尺度上解锁信息。
撇开 CSI 的陈词滥调不谈，超分辨率在现实生活中的应用数不胜数，而且利润丰厚。
缺乏细节的旧家庭照片可以被恢复和增强，以看到人们的脸，你手机上的相机现在可以像单反相机一样捕捉图像，一直到医学成像或自动驾驶汽车的传感器数据。
然后是商业方面，数据是新的石油。不管这种陈词滥调有多老套，可以肯定的是，高质量的数据是昂贵的，人们会为此付出高昂的代价。就数据科学项目而言，高质量的数据可能意味着燃煤和火箭燃料之间的差异。因此，有可能简单地“T6”增强“T7”公司已经拥有的形象集的想法？这是一个非常诱人的提议。
在过去的十年里，相机技术不断进步，我们现在希望我们看到的任何东西都有像素完美、丰富的图像。这听起来可能很有趣，但这种技术的早期采用者是用户策划的食谱网站，其图像可以追溯到十多年前。通过增强旧图像，他们希望保留旧食谱的价值。(此处)
将智能手机变成单反相机暗示了超分辨率方法的一个更微妙的细节，正在学习的是从一个空间到另一个空间的映射，在我们的情况下是从低分辨率到高分辨率。但是没有什么说这就是它所能做的，为什么不包括风格转换呢？将图像增强到高分辨率，同时调整曝光和对比度，增加一些深度，也许会让人们大开眼界？这些都是相同方法的例子。一篇涵盖更多“香草”式转会例子的精彩文章，请看这里。
在许多方面，最有趣的例子是传感器技术。大量的时间和金钱花费在开发用于医疗成像、安全和监控的传感器上，然后这些传感器通常被部署在具有挑战性的条件下，而没有预算来利用尖端硬件。
这在最近这篇关于 MRI 数据(这里是)或用于实验室显微镜检查(这里是)的 3D SRGANs 的论文中以多种方式达到高潮。将来，医院或实验室可以花必要的钱购买一台最先进的机器，或者购买几台较便宜的型号，雇用更多的员工，看更多的病人，但结果却是一样的？
不管应用程序如何，超分辨率将会一直存在，但事实是它已经存在很长时间了。
自从图像处理出现以来，各种方法就一直存在，(双三次，线性等)..)最近发展到一些非常有前途的神经网络方法来描述 LR 空间到 HR 空间之间复杂的多维转换矩阵。
然而，所有这些方法都遇到了最重要的绊脚石。它们都不能始终如一地产生人眼看起来自然的图像。
2017 年，Twitter 的一个小组取得了突破性进展(此处为)，他们没有在神经网络中做任何与同行完全不同的架构，而是将注意力转向了谦逊的损失函数。
他们实现了一种叫做感知损失函数的东西，这种函数可以更好地调整网络，以产生人眼满意的图像。
部分是通过使用一个聪明的表示技巧，其中预先训练的最先进的 CNN 模型( VGG 来自牛津大学的小组)基于生成的图像与其高分辨率真相相比的特征映射来计算损失。
这些改进产生了惊人的结果。细节并不总是完美的，但与大多数尝试不同的是，细节是存在的，图像的整体感觉非常好。
From the SRGAN paper, the proposed image is almost identical to the original even with a four times downsampling factor. Look at the details around the eyes or the whiskers.
与纯生成相比，当有一个参考图像开始时，为什么生成真实的图像会更难，这不是很直观，所以为了探索这个想法，让我们回到我们的伪造者和专家，考虑这个新的范式对他们意味着什么。
他们没有出售任何珍贵的旧艺术品，而是展出了几件著名的艺术品，预计会以创纪录的价格售出。
我们的伪造者对艺术界知之甚少(喜欢把工作和家庭生活分开)，也不知道这些画应该是什么样子。然而，就在他们坐下来画他们提交的作品之前，他们看到了传单上的一个小图像，上面有将要拍卖的画。太好了，现在他们有参考图像了！
唯一的问题是传单很小，而真正的画很大，他们知道专家会非常仔细地观察。他们必须弄清楚细节。
所以现在，画一幅伟大的作品不仅足够好，而且必须是那种特定的作品。尽管对细节一无所知，但伪造者并没有因此却步。
最初，伪造者决定最好的方法是改变细节，这样平均来说，在传单的像素大小上，伪造品与像素的颜色相匹配，并且作为一种现实主义的尝试，试图避免颜色的明显不连续，并确保笔触(像素)平滑地运行在一起。他们让一个朋友溜进拍卖行，对照真实图像逐一检查每一笔。
第一种方法类似于 MSE(均方误差，有艺术许可。)
这在最初对伪造者来说效果很好，但是遇到了一个绊脚石，专家不能很好地指出它，但是这些图像似乎有些不对劲。有一种与画布大小不匹配的模糊或缺乏清晰度，这些图像大多被视为赝品而被拒绝。通过匹配笔触，伪造者失去了整个图像的感觉，笔触的技术是完美的，但作为一个集合，笔触没有完全捕捉到风格，从图像到图像的概括是很难的工作。
因此，伪造者采取了不同的方法，而不是担心单独的笔触与图像匹配，他们希望这幅画类似于世界上的真实物体。于是他们请另一位朋友描述他们创作的画，这位朋友不是艺术家，所以不在乎技巧，但却一丝不苟地描述画中的物体。
然后，他们让同一位朋友去拍卖行，在伪造者试图复制的画作上做笔记。然后伪造者比较这些笔记，伪造品与真实图像的描述相符吗？这是 VGG 的感性损失。
因此，最终通过结合这两个朋友的反馈，伪造者了解到图像的细节，如此精致的细节，以至于他们可以仅仅从传单上的小图像和几个内部人士反馈的信息中制作出杰作的复制品，这样做让他们都赚了很多钱。
如果我们从技术角度考虑一下。在我之前的文章中，我们使用条件网络从 MNIST 数据集生成数字，即指定所生成图像的类别。这是一个约束，将产生的图像限制在学习分布的特定区域内。然而，通过选择一个特定的图像来填充，我们更明显地限制了生成器的自由。
我们现在需要一个长范围的连续性和细节，这样才能在大量信息丢失的情况下看起来令人信服。
突破来自感知损失函数的出现。这是上面伪造者使用的第二种方法。
这个令人惊讶的简单想法只是将内容损失(VGG)与适当加权的对抗性损失以 1000:1 的比例结合起来。这足以鼓励生成器在自然图像的 PDF 中找到解决方案，而不会过度限制网络进行复制而不是生成。
虽然再现正确的像素很重要，但通过 MSE 学习此制图表达缺乏上下文，使用 VGG 网络的想法是它对要素总体上有很好的“感觉”,并且像素之间的空间关系具有更大的权重，因此通过比较 VGG 网络每一层要素制图表达的潜在空间，高级别和低级别的要素都可以以现实的方式得到鼓励，并可以指导生成的图像的样式。
值得花一点时间来看看这些损失函数背后的数学原理，以理解其实现方式，但对于那些不感兴趣的人，可以直接跳到结果部分。
第一个等式显示了由鉴别器和发生器进行的标准最小/最大游戏。这是调节 gan 的标准方法，依赖于找到某种平衡，但相信鉴别器是发电机上的导向力。
The expectation values are minimised with respect to the generator parameters, and maximised w.r.t. the discriminator parameters, until an equilibrium is reached
感知损失在第二个等式中描述，这是本文的关键原创贡献，其中内容损失(本例中为 MSE 或 VGG)与试图欺骗鉴别器的标准发生器损失配对。
The Super Resolution loss is a sum of content loss (either MSE or VGG based) and the standard generator loss (to best fool the discriminator.)
在 MSE 损失(第三个等式)的情况下，它只是生成图像和目标图像的差和，当生成的图像接近目标时，这显然被最小化，但是使一般化变得困难，因为没有任何东西明确地鼓励上下文感知生成。
The MSE loss is summed over the width (W) and height (H) of the images, this is minimised by perfectly matching the pixels of the generated and original image
第四个等式显示了 SRGAN 论文中的突破，通过采用来自 VGG 网络的特征空间的差和而不是像素，特征被匹配。使得发生器比单纯的像素匹配更能产生看起来自然的图像。
The VGG loss is similar to MSE, but instead of summing over the image pixels, summing over the feature mapping of the image from the VGG network.
网络的结构在大多数方面类似于典型的 GAN，鉴频器网络只是一个标准的 CNN 二进制分类，末端有一个密集层，发生器的标准程度稍低，有去卷积层( conv2d_transpose )和增加的 skip 连接，以产生 4 倍的放大。
跳跃连接是网络循环块中的常规特征，本质上它意味着矩阵的状态在块开始时被保存，并在块结束时被添加到结果中。对于前五个块中的每一个，以及绕过整个前五个块的跳过连接，都会发生这种情况。最后一层的输出 deconv5 是期望的图像尺寸。请注意，由大约 15 个反卷积层组成，每一层都有一个批量规格化层(除了第一层是典型的)，并且始终有 relu 激活。
VGG 网络也是 15 个卷积层深(具有三个密集层),但在其他方面是相当标准的，唯一的附加是通过三层提取不同阶段的矩阵状态，以馈入感知损失。
实施细节可以在这里找到。
可以看出，训练进行得很快，仅在几个批次后，逼真的图像开始出现，然而，图形的长尾表明，找到照片级的细节是一个缓慢的过程。这个网络显然没有产生最先进的结果，但对于训练时间(几个小时的 CPU)来说，结果是惊人的。下面的三张 gif 展示了图像被打磨和细节显现的过程。
Example 1. From initial haze a clear face starts to emerge quickly, then fluctuates in exact tone before settling on a stable solution. Impressive detail reconstruction can be seen in the glasses frame, largely invisible in the input image. (Although less well recovered off the face.)
Example 2. The detail here is subtle, lines around the eyes and shapes of features. Features like mouth shape are close, bags under the eyes come out appropriately, and the appearance becomes much sharper.
Example 3. Details like the dark makeup and clean smile come out fairly well, but finer grain details like teeth and eyebrows are less well recovered. This may reflect the training data, this face is more of a portrait and closer up than typical, and shows the limitations of this implementation shown here. Despite this the result is still a significant improvement.
稳定基线:OpenAI 基线的一个分支——强化学习变得简单
统一的结构(scikit-learn like 接口)和单一的代码样式以及文档
Image Credit: L.M. Tenkes
经过几周的努力，我们很高兴地宣布稳定基线的发布，这是一组基于 OpenAI 基线的具有公共接口的强化学习(RL)算法的实现。我们关注易用性和一致性。在本文中，我们将展示各种例子(基本用法、保存/加载代理、简单的多重处理、Atari 游戏培训等等)以及 fork 的起源。
更新(2020 年 5 月):稳定-基线 3 (PyTorch 版)现已上线！https://github.com/DLR-RM/stable-baselines3
更新:文档现已在http://stable-baselines.readthedocs.io/上线，并增加了 Tensorboard 支持
更新:我们增加了一个 rl 基线动物园，集合包含 70+训练有素的特工https://github.com/araffin/rl-baselines-zoo
更新:我们写了一个完整的教程:https://github.com/araffin/rl-tutorial-jnrr19
稳定基线 OpenAI 基线的一个分支，强化学习算法的实现
github.com](https://github.com/hill-a/stable-baselines)
TL；博士:
有了稳定的基线，培训 PPO 代理就像以下一样简单:
Basic Usage: training an agent with stable baselines
但是我们能不能简单点？当然，我们可以！有了稳定的基线，你现在可以用一行代码定义和训练一个强化学习代理:
Train a RL agent in one line of code!
可以使用 Colab 笔记本在线试一试 。
叉子的历史
当我们开始使用 OpenAI 基线进行研究时，我们很高兴地发现强化学习算法正在工作 (1)。然而，从我们试图稍微调整它的那一刻起，例如用学习到的功能而不是图像工作，它就变成了地狱，我们必须修补未注释的代码。
在我们经历的困难中，有缺少注释，缺少有意义的变量名和一致性(没有共同的代码风格)以及大量重复的代码(2)。
Example of issue found in the OpenAI Baselines repo
当我们在 Github 库上查看问题时，我们并不孤单: #285 、 #400 、 #413 、 #445 、 Reddit 。
因此，在基线存储库的主分支上的一个新提交破坏了我们的代码之后，我们决定创建一个 fork，并牢记两个想法:
- 注释代码和单一代码样式
- 每种算法的通用接口
(1)在我们的实验中，与其他代码库相比，基线代码库提供了最好的结果(就性能而言)。此外，在 重要的深度强化学习 ，中，他们显示基线 DDPG 实现优于其他代码库。最近玩 Dota 2 的 OpenAI 5 在核心使用 PPO。
(2)在撰写本文的时候，OpenAI 似乎在改进他们的基准上付出了一些努力，然而仍然缺少很多。
包括什么？
OpenAI 基线(以及稳定的基线)包括 A2C、PPO、TRPO、DQN、ACKTR、ACER 和 DDPG。你可以在自述文件中找到一个关于支持的内容(动作空间、多处理)的总结表。
基线还带有有用的包装器，例如用于预处理或多重处理。我们将在示例中展示它们的效用。
有什么新鲜事？
统一界面
所有算法都遵循相同的结构，我们希望有一个 scikit-learn like 接口，正如你将在示例中看到的，这使事情变得容易得多！
我们为所有算法提供了通用的方法，如 train (相当于 fit) 、save、load 和 predict (与 sk-learn 中相同)。
支持加载、保存等
我们为所有算法添加了保存和加载功能，传递回调的能力(用于实时绘图)，全面的 tensorboard 支持和一个额外的输出动作概率的方法。
任何类型功能的培训
我们增加了对任意特征的 RL 训练的支持，也就是说 RL 算法可以在像素之外的其他东西上训练(当前的 OpenAI 基线只支持不使用图像作为输入时的连续动作)。
事实上，解耦 状态表示学习 ，从策略学习中提取特征是我们研究的主要课题，也是近期工作的重点(例如世界模型和好奇心驱动学习)。因此，我们认为这是我们 fork 的一个重要特性。
更多测试和覆盖范围
当我们开始重构 OpenAI 基线时，只有 16%的代码覆盖率。也就是说，只测试了所有代码语句的 16%。在重构过程中，我们添加了更多的测试，并且达到了 65% 的覆盖率！(大部分未被覆盖的代码来自 Mujoco 相关特性，而且由于这是一个商业物理引擎，很难与之有持续的集成)。
编辑:经过更多的重构(盖尔和她)，覆盖率现在是 85%！
错误修复
我们利用注释代码来修复一些问题。例如，用于帧堆叠的包装器只能处理灰度图像(完整的故事是，OpenAI 之前的一个错误修复被他们的新提交 …)之一删除了)。
例子:“空谈是廉价的。给我看看代码”
在下一节中，我们将通过不同的例子来说明如何使用稳定的基线。我们将涵盖 基本用法 ，保存/加载，多重处理，绘图，雅达利游戏上的训练等等！
Colab 笔记本列表
基本用法:训练、保存、加载
在下面的例子中，我们将在月球着陆器环境中训练、保存和加载一个 A2C 模型。
关联 Colab 笔记本: 在线试用 ！
Lunar Lander Environment
多重处理:释放矢量化环境的力量
关联 Colab 笔记本: 在线试用 ！
CartPole Environment
使用 Tensorboard 监控训练
v 2 . 0 . 0 中的新功能
OpenAI 提供了基本的 tensorboard 支持(参见文档中的 传统集成 )，我们添加了完整的 tensorboard 集成(图形可视化、学习曲线等)。
要启用 tensorboard 日志记录，只需用有效路径填充tensorboard_log参数:
Tensorboard integration
Cartpole does not seem so easy after all…
重现实验的代码:https://gist . github . com/araffin/ee 9 daee 110 af 3b 837 b 0 e 3 a 46 a6 bb 403 b
使用回拨:监控培训
您可以定义一个将在代理内部调用的自定义回调函数。当你想监控训练时，这可能是有用的，例如在 Tensorboard(或 Visdom)中显示实时学习曲线或保存最佳代理。
关联笔记本(含标图): 在线试用 ！
雅达利游戏
关联笔记本: 在线试用 ！
Pong Environment
多亏了make_atari_env助手功能，在 Atari 游戏上训练一个 RL 代理变得很简单。它会为你做所有的预处理和多重处理。
Mujoco:规范化输入要素
规范化输入特征可能是成功训练 RL 代理的关键(默认情况下，图像被缩放，但其他类型的输入不被缩放)，例如在 Mujoco 上训练时。为此，存在一个包装器，它将计算输入要素的运行平均值和标准差(它可以对奖励做同样的事情)。
注意:我们无法为此示例提供笔记本电脑，因为 Mujoco 是一个专有引擎，需要许可证。
复古索尼克
自定义策略网络
稳定基线为图像(CNN 策略)和其他类型的输入(MLP 策略)提供默认策略网络。但是，您也可以轻松地为策略网络定义自定义架构:
额外收获:持续学习
你也可以从一个学习环境转移到另一个环境进行持续学习 (PPO2 在DemonAttack-v0上，然后转移到SpaceInvaders-v0):
结论
我们提出了稳定的基线，这是一个旨在使强化学习面向广大受众的分叉。我们简化并统一了不同的算法，现在提供了一个类似 scikit-learn 的接口来进行 RL 实验。
对于任何对改进基线感兴趣的人来说，仍然有一些文档需要完成。因此，您可以随意在存储库上创建问题和提出请求。
当前 WIP:添加对 ACER/ACKTR 连续操作的支持
这篇文章是与阿什利·希尔共同撰写的。
感谢
稳定的基线是在 ENSTA ParisTech 的机器人实验室 U2IS ( INRIA 弗劳尔斯团队)创建的。
这项工作由梦想项目通过欧盟 Horizon 2020 FET 研究和创新计划根据第 640891 号拨款协议提供支持。
关于作者
我们都在研究机器人的强化学习。我们的研究重点是状态表示学习(RL 的特征提取)。在业余时间，我们喜欢做 DIY 项目的实验，例如建造一辆自主赛车。
Colab 笔记本列表
PS:如何制作一个训练有素的特工的 gif？
One line RL gif using terminalizer
稳定匹配，作为游戏
长期以来，我一直对选举和拍卖的数学很感兴趣。它们是经济学中更广阔领域的一部分，社会选择理论充满了有趣的组合问题和悖论。
最近，我(再次)偶然发现了稳定匹配的主题，这个主题显然也属于社会选择理论，它有一些相同的有趣方面。
在这篇文章中，我讨论了这个问题是否可以看作一个游戏。
问题的定义
我们有一组要配对的元素。每个元素/代理都有一个优先级列表。这种匹配必须以一种稳定的方式来完成。如果存在元素 A 和 B，则匹配不稳定，因此
- a 和 B 当前彼此不匹配
- a 更喜欢 B 而不是它当前的配对
- b 也更喜欢 A 而不是它当前的配对
这种情况意味着 A 和 B 可能会忽略其他元素的偏好，彼此跑掉。这种情况并不稳定。
这个问题有两种变体:
- 有两组大小相等的元素，S 和 T，并且配对必须由来自 S 的一个元素和来自 T 的一个元素组成。考虑到男性 S 和女性 T，这种变体也被称为稳定婚姻问题。
- 只有一个组具有偶数个元素。这叫稳定室友问题。
这两种变体有一些关键的要点，我在这里不详细介绍，只是总结一下:
(1)对于稳定的婚姻问题，总有一个稳定的匹配，并且有一个有效的算法来找到它:1962 年发明的 Gale-Shapley 算法。这个算法在这个 YouTube 视频中有介绍。令人惊讶的是，可以有多个稳定的匹配。Gale-Shapley 算法找到对“左集合”中的所有元素来说是最佳的匹配:左集合中的所有元素将在所有稳定的匹配中获得最佳可能的伙伴。这意味着(令我惊讶的是)，从左边集合的角度来看，没有权衡。这个解同时对左边集合中的每个人都是最优的。对正确的人来说，情况正好相反:每个人都可能得到最坏的结果。注意:这并不意味着他们都得到了他们最不喜欢的选择——但是在所有可能的稳定匹配中，他们得到了他们最不喜欢的伙伴。
(2)对于稳定的室友问题，并不总是存在稳定的匹配！这个问题是 D.E. Knuth 提出的稳定婚姻变异的 11 个难题之一。他寻求多项式解，而第一个构建这种算法的是 R. W. Irving，他在论文中提出了“稳定室友”问题的有效算法 (1984)。如果存在稳定的匹配，该算法将找到一个稳定的匹配。它比 Gale-Shapley 更复杂，证明正确性也更复杂。该算法在几个 YouYube 的视频中都有讲解，比如【1】【2】。
这里有一个例子(视频)稳定的室友问题无解
No solution to stable roommate
例如，匹配的 AB CM 不稳定，因为 A 和 C 都更喜欢对方而不是他们当前的匹配，这使得我们切换到 AC BM，AC BM 也因为类似的原因不稳定，等等。(这种情况类似于社会选择理论中的阿罗悖论:多数人可以偏好 B 而非 A，C 而非 B，A 而非 C，一个群体的多数偏好可以形成一个循环)。
作为游戏的变现？
事实上，每个元素都有一个排序的偏好列表，这使得这个问题显然可以被视为一个多代理人的游戏，每个元素都是一个自主代理人，寻求最大化他的自私的游戏结果。
匹配稳定的标准让我产生了疑问:
稳定真的是目标本身吗，还是不稳定更像是一种症状？也就是说，如果一场比赛不稳定，这只是一个信号它不好，出了问题。相反，仅仅是稳定，就足以获得“最佳”解决方案吗？当有多个解决方案时，我们应该如何选择——以及当没有稳定的匹配时该怎么办。随机化是一种解决方案吗？如果是，如何解决？如果问题有随机的一面，我们是否应该用数字分数代替排名，这样我们就可以表达如何权衡不同的概率？(举例:用排名 A B C，“100% B”比“50% A，50% C”好还是差？)
关于一个可能的博弈出现了几个问题:
这个博弈的正式规则是什么，当一个博弈存在时，这个博弈的最优博弈总是导致稳定的匹配吗？这能导致帕累托最优吗？如果没有，是不是有些悖论？是回合制游戏吗，每个回合会发生什么？两个或两个以上的代理人可以合谋来改善他们的游戏结果吗？公布一个人的排名会在多大程度上损害你的结果(反过来，对你的排名撒谎会改善你的结果吗)？规则中需要随机化吗，或者我们可以让代理决定随机化吗？
纳什均衡的框架适用于这个博弈吗？纳什均衡是一个 T2 玩家改变他的策略，而其他人保持他们的策略，在这个游戏中，至少有两个玩家同意改变匹配。这个游戏中的策略是什么？排名榜是一种策略吗？可能吧，不过要看游戏是怎么进行的。
这让我很困惑，所以我尝试了不同的方法。
从这里开始，我只考虑稳定的室友问题，假设稳定的婚姻问题是这个问题的一个更简单的子问题。我并不完全清楚稳定的室友是不是一个合适的超集，因为对于稳定的婚姻来说，你只排了一半的元素。
方法 1。结果分布
不是玩家同意一个匹配，也许他们可以同意匹配的概率分布？
事实证明并非如此。在室友匹配的反例中，我们可以假设这种分布:
**Probability Paring**
x AB, CM
y AC, BM
1-x-y BC, AM
但事实证明，无论我们如何初始化 x 和 y，没有任何更新可以得到所有四个玩家的同意。这意味着( x ， y ，1- x - y )的任何组合都是帕累托最优的。这不会让我们更进一步。
方法 2。基于回合的提议
游戏是这样进行的:在第 0 轮中，所有玩家同时公布他们的偏好列表。在每一回合，随机(统一)挑选一名玩家。然后，他按照自己的偏好列表向其他玩家求婚，第一个接受的玩家被选中。成对的玩家离开游戏，即被选中的伙伴没有机会求婚。游戏后期是没有办法改变自己的想法的。如果没有提议的玩家接受，提议的玩家将被移到休息组。提议玩家可以向休息组的成员提议。当只剩下休息组时，这些是随机匹配的。
让我们以上面 ABCM 的例子来玩这个游戏:
如果 A 被选为第一求婚者，他会向 B 求婚，B 会接受(为什么？因为如果 B 拒绝，他知道 C 会接受，然后 B 会和 M 结束)。通过对称性，B 或 c 会发生类似的匹配，如果 M 是第一个提议者，所有人都会拒绝，然后游戏照常进行。总的来说，我们会有这样的结果概率分布:
**Prob. Matching**
1/3 AB CM
1/3 AC BM
1/3 BC AM
问题
- 假设存在稳定匹配，假设每个人都最优博弈，结果会是稳定匹配吗？
- 在某些情况下发布错误的偏好会有帮助吗？似乎很明显，应该按照偏好的顺序提出建议，但是公布真实偏好的缺点是其他人会看到它们，并且他们的策略可能会依赖于它们。
- 玩家能在多大程度上成功合谋以提高结果？
我很乐意在评论中听到你的想法或主意。
用于预测的堆叠神经网络
机器学习和深度学习在金融机构中找到了自己的位置，因为它们能够高度准确地预测时间序列数据。有大量的研究正在进行中，以改进模型，使它们能够预测更高精度的数据。这篇文章是对我的项目 AIAlpha 的一个总结，它是一个堆叠神经网络架构，可以预测各种公司的股票价格。这个项目也是新加坡大学生黑客马拉松 iNTUtion 2018 的决赛选手之一。
工作流程
该项目的工作流程主要包括以下步骤:
- 获取股票价格数据
- 使用小波变换对数据去噪
- 使用堆叠自动编码器提取特征
- 列车 LSTM 使用功能
- 预测准确性的测试模型
在这篇文章中，我将详细介绍每一步的细节，以及为什么我选择做出某些决定。
数据采集
得益于雅虎财经的 API，股票价格数据很容易获得。因此，简单地用stock_data = pdr.get_data_yahoo(self.ticker, self.start, self.end)就完成了。
去噪数据
由于股票市场动态的复杂性，股票价格数据经常充满噪声，这可能会分散机器学习对趋势和结构的学习。因此，在保留数据中的趋势和结构的同时，去除一些噪声是我们感兴趣的。起初，我想使用傅立叶变换(不熟悉的人应该阅读本文)，但我认为小波变换可能是更好的选择，可以保留数据的时间因素，而不是产生仅仅基于频率的输出。
小波变换
小波变换与傅立叶变换非常相似，只是用于变换的函数不同，并且变换的方式也略有不同。
过程如下:使用小波变换对数据进行变换，然后(在所有系数中)移除超过全标准偏差的系数，并对新系数进行逆变换以获得去噪数据。
以下是小波变换如何对时间序列数据进行降噪的示例:
可以看到，初始信号中存在的随机噪声在去噪版本中并不存在。这正是我们希望用股票价格数据做的事情。
以下是如何对数据进行降噪的代码:
x = np.array(self.stock_data.iloc[i: i + 11, j])
(ca, cd) = pywt.dwt(x, "haar")
cat = pywt.threshold(ca, np.std(ca), mode="soft")
cdt = pywt.threshold(cd, np.std(cd), mode="soft")
tx = pywt.idwt(cat, cdt, "haar")
库pywt是优秀的小波变换工具，极大地减轻了我的负担。
提取特征
在通常的机器学习环境中，提取特征将需要专业领域知识。这是我没有的奢侈品。我也许可以尝试使用某种形式的技术指标，如移动平均线或移动平均线收敛发散(MACD)，或动量指标，但我觉得盲目使用它可能不是最佳选择。
然而，自动特征提取可以通过使用堆叠自动编码器或其他机器学习算法(如受限玻尔兹曼机器)来实现。我选择使用堆叠式自动编码器，因为与受限玻尔兹曼机器的概率相比，编码具有可解释性。
堆叠自动编码器
本质上，堆叠式自动编码器非常擅长压缩数据并再次将其复制回来。我们感兴趣的是压缩部分，因为这意味着再现数据所需的信息都以某种方式编码为压缩形式。这表明，这些压缩数据在某种程度上可以是我们试图从中提取特征的数据的特征。以下是堆叠式自动编码器的网络结构:
输入数据被压缩成任意数量的神经元，网络被迫使用自动编码器重建初始数据。这迫使模型提取数据的关键元素，我们可以将其解释为特征。需要注意的一个关键点是，该模型实际上属于无监督学习，因为没有输入输出对，但输入和输出是相同的。
我们可以使用keras来构建这样一个模型，使用函数式 API 比顺序式 API 更有用。
class AutoEncoder:
def __init__(self, encoding_dim):
self.encoding_dim = encoding_dim
def build_train_model(self, input_shape, encoded1_shape, encoded2_shape, decoded1_shape, decoded2_shape):
input_data = Input(shape=(1, input_shape))
encoded1 = Dense(encoded1_shape, activation="relu", activity_regularizer=regularizers.l2(0))(input_data)
encoded2 = Dense(encoded2_shape, activation="relu", activity_regularizer=regularizers.l2(0))(encoded1)
encoded3 = Dense(self.encoding_dim, activation="relu", activity_regularizer=regularizers.l2(0))(encoded2)
decoded1 = Dense(decoded1_shape, activation="relu", activity_regularizer=regularizers.l2(0))(encoded3)
decoded2 = Dense(decoded2_shape, activation="relu", activity_regularizer=regularizers.l2(0))(decoded1)
decoded = Dense(input_shape, activation="sigmoid", activity_regularizer=regularizers.l2(0))(decoded2)
autoencoder = Model(inputs=input_data, outputs=decoded)
encoder = Model(input_data, encoded3)
# Now train the model using data we already preprocessed
autoencoder.compile(loss="mean_squared_error", optimizer="adam")
train = pd.read_csv("preprocessing/rbm_train.csv", index_col=0)
ntrain = np.array(train)
train_data = np.reshape(ntrain, (len(ntrain), 1, input_shape))
# print(train_data)
# autoencoder.summary()
autoencoder.fit(train_data, train_data, epochs=1000)
我用 2000 年到 2008 年去噪后的股价数据来训练自动编码器。经过 1000 个周期的训练后，RMSE 下降到 0.9 左右。然后，我使用该模型将我剩余的股票价格数据编码成特征。
LSTM 模型
LSTM 模型无需介绍，因为它在预测时间序列方面已经变得非常广泛和流行。它从细胞状态的存在中获得其特殊的预测能力，这允许它理解和学习数据中的长期趋势。这对我们的股价数据尤其重要。下面我将讨论我认为重要的设计选择的一些方面。
【计算机】优化程序
所使用的优化器类型会极大地影响算法收敛到最小值的速度。此外，重要的是有一些随机性的概念，以避免陷入局部最小值，而不是达到全局最小值。有几个伟大的算法，但我已经选择使用亚当优化。Adam 优化器结合了其他两个优化器的优势:ADAgrad 和 RMSprop。
ADAgrad 优化器本质上对每个参数和每个时间步使用不同的学习率。ADAgrad 背后的推理是，不频繁的参数必须具有较大的学习率，而频繁的参数必须具有较小的学习率。换句话说，ADAgrad 的随机梯度下降更新变为
在哪里
学习率是基于已经为每个参数计算的过去梯度来计算的。因此，
其中 G 是过去梯度的平方和的矩阵。这种优化的问题在于，随着迭代次数的增加，学习率会很快消失。
RMSprop 考虑通过仅使用一定数量的先前梯度来固定递减的学习速率。更新变成了
在哪里
既然我们理解了这两个优化器是如何工作的，我们就可以研究 Adam 是如何工作的了。
自适应矩估计或 Adam 是另一种通过考虑过去平方梯度的指数衰减平均值和过去梯度的指数衰减平均值来计算每个参数的自适应学习率的方法。这可以表示为
v 和 m 可以分别被认为是梯度的一阶和二阶矩的估计，因此被命名为自适应矩估计。第一次使用这种方法时，研究人员观察到存在一种固有的偏向 0 的倾向，他们通过使用以下估计值对此进行了反驳:
这将我们带到最后的梯度更新规则
这是我使用的优化器，其优点总结如下:
- 对于每个参数和每次迭代，学习速率是不同的。
- 学习并不像阿达格勒那样减少。
- 梯度更新使用权重分布的矩，允许更统计上合理的下降。
正规化
训练模型的另一个重要方面是确保权重不会变得太大，并开始专注于一个数据点，从而过度拟合。因此，我们应该始终包括大重量的惩罚(大的定义将取决于使用的正则化类型)。我选择使用吉洪诺夫正则化，这可以被认为是以下最小化问题:
函数空间在再生核希尔伯特空间(RKHS)中的事实确保了范数的概念存在。这允许我们将规范的概念编码到我们的正则化器中。
辍学者
一种防止过度拟合的新方法考虑了当一些神经元突然不工作时会发生什么。这迫使模型不要过度依赖任何一组神经元，而要考虑所有的神经元。辍学者发现他们的用途是使神经元更加健壮，从而使他们能够预测趋势，而不用关注任何一个神经元。以下是使用辍学的结果
可以看出，存在压差时，误差继续下降，而不存在压差时，误差处于平稳状态。
模型实现
由于有了keras和它们的功能 API，上述所有分析都可以相对容易地实现。这是模型的代码(要查看完整的代码，请查看我的 GitHub: AlphaAI )
class NeuralNetwork:
def __init__(self, input_shape, stock_or_return):
self.input_shape = input_shape
self.stock_or_return = stock_or_return
def make_train_model(self):
input_data = kl.Input(shape=(1, self.input_shape))
lstm = kl.LSTM(5, input_shape=(1, self.input_shape), return_sequences=True, activity_regularizer=regularizers.l2(0.003),
recurrent_regularizer=regularizers.l2(0), dropout=0.2, recurrent_dropout=0.2)(input_data)
perc = kl.Dense(5, activation="sigmoid", activity_regularizer=regularizers.l2(0.005))(lstm)
lstm2 = kl.LSTM(2, activity_regularizer=regularizers.l2(0.01), recurrent_regularizer=regularizers.l2(0.001),
dropout=0.2, recurrent_dropout=0.2)(perc)
out = kl.Dense(1, activation="sigmoid", activity_regularizer=regularizers.l2(0.001))(lstm2)
model = Model(input_data, out)
model.compile(optimizer="adam", loss="mean_squared_error", metrics=["mse"])
# load data
train = np.reshape(np.array(pd.read_csv("features/autoencoded_train_data.csv", index_col=0)),
(len(np.array(pd.read_csv("features/autoencoded_train_data.csv"))), 1, self.input_shape))
train_y = np.array(pd.read_csv("features/autoencoded_train_y.csv", index_col=0))
# train_stock = np.array(pd.read_csv("train_stock.csv"))
# train model
model.fit(train, train_y, epochs=2000)
结果
以上是我对各个公司预测的结果。
很明显，使用这种神经网络架构的结果是不错的，并且如果在策略中实施，可以是有利可图的。
在线学习
除了从历史数据中学习模型之外，我还想让模型一直学习，甚至从预测中学习。因此，我把它变成了一个可以学习和预测的在线模型。换句话说，它学习历史数据，预测明天的价格，明天，当实际价格已知时，它也学习使用这些数据。所以模型一直在改进。
除了使用实际价格进行改进，我还考虑过制作一个二级模型，使用关于公司的新闻和 Twitter 的情感值。我将首先概述这些数据是如何获得的。
推特数据
除了股票价格数据，我还想尝试一些自然语言处理。因此，我尝试利用 twitter 和新闻中的情绪数据来改进股票预测。
第一个主要挑战是免费获取推文，因为获取整个档案的 Twitter API 是付费的。然而，我发现了一个 API，它允许我获取过去 10 天的推文，然后我可以实现某种形式的 NLP 来从推文中提取情感数据。这不是最佳的，但对我的在线学习模式仍然有用。
twitter api 用于收集过去 10 天的数据，情绪得分是使用 TextBlob 计算的，并对大量推文进行平均。
新闻数据
与 Twitter 类似，获取新闻数据非常困难。我试图分析彭博文章的网址，但意识到从 2000 年开始一直手动删除网站几乎是不可能的。因此，我选择了 Aylien API，它有一个非常强大的抓取模型。
新闻文章被删除，条件是它们只包括股票和金融新闻，过滤到 Alexa 网站的前 150 名，情绪得分使用指数加权移动平均进行平均，以更多地考虑最近的新闻而不是旧新闻。
在线模型
鉴于我的情绪得分，我使用了一个额外的神经网络层来纠正我预测的错误。然而，在撰写本文时，还没有得到这方面的结果，因为产生一个数据点需要一天的时间。
结论
神经网络非常擅长预测时间序列数据，当与情绪数据相结合时，确实可以做出实用的模型。虽然这里的结果令人印象深刻，但我仍在寻找改进的方法，也许真的能从中发展出一套完整的交易策略。目前，我正在研究使用强化学习来开发一个交易代理，使用预测模型的结果。
斯坦 vs PyMc3 (vs 爱德华)
神圣的三位一体说到贝氏。我将提供我使用前两个包的经验和我对第三个包的高水平看法(在实践中没有使用过)。当然，还有疯子(变得无关紧要的老教授)，他们实际上做了自己的吉布斯采样。
My reaction to people writing their own samplers
这是我对这三个部分的 30 秒介绍。您可以为数据指定创成式模型。您将数据作为观察值输入，然后它从数据的后面为您取样。神奇！
Stan 是我使用的第一种概率编程语言。如果你来自统计学背景，这将是最有意义的。可以做 mu~N(0，1)这样的事情。文档是绝对惊人的。就个人而言，我不介意使用 Stan 参考作为贝叶斯学习的介绍，因为它向您展示了如何对数据建模。例子相当广泛。
另一方面，PyMC3 是专门为 Python 用户设计的。如今，大多数数据科学社区都在向 Python 迁移，所以这根本不是问题。您可以在下面看到一个代码示例。语法没有 Stan 那么好，但仍然可行。我真的不喜欢你不得不再次命名变量，但这是在后端使用 theano 的副作用。pm.sample部分只是从后面取样。我喜欢这样一个事实，即使我有一个离散变量要采样，它也不会被扰乱，这是 Stan 到目前为止做不到的。
PyMC3 sample code
就文档而言，在我看来没有 Stan 那么广泛，但是的例子真的很好。结合 Thomas Wiecki 的博客，你就有了一个完整的 Python 数据分析指南。
PyMC3 成为我的(贝叶斯)工具的原因只有一个，那就是pm.variational.advi_minibatch函数。当贝叶斯模型必须处理相当大量的数据(大约 10000 多个数据点)时，它真的很难处理。变分推理是进行近似贝叶斯推理的一种方式。Stan 和 PyMC3 都有这个。但 PyMC3 采取了额外的步骤来扩展它，以便能够使用小批量的数据，这使我成为了它的粉丝。
数学(可选)
稍微了解一下数学，变分推理所做的是最大化数据 log p(y)的对数概率的下限。
Variational Bayes Equations
我们试图通过改变建议分布 q(z_i)和 q(z_g)的超参数来最大化这个下限。z_i 指的是数据实例 y_i 本地的隐藏变量，而 z_g 是全局隐藏变量。上次我用 PyMC3 检查时，它只能处理所有隐藏变量都是全局变量的情况(这里我可能错了)。
本质上，我觉得 PyMC3 做得还不够，它让我把它当作一个真正的优化问题。第二项可以近似为
其中 N 是小批量的大小，N 是整个集合的大小。这是 Matthew Hoffman 在这篇论文中所写内容的精髓。我想指定模型/联合概率，让 theano 简单地优化 q(z_i)，q(z_g)的超参数。这就是 GPU 加速真正发挥作用的地方。 Stan 在这方面确实落后了，因为它没有使用 theano/ tensorflow 作为后端。
爱德华
到目前为止，我对爱德华一直保持沉默。我没有在实践中使用过爱德华。我觉得主要原因是它没有好的文档和例子来轻松地使用它。的确，我可以将 PyMC3 或 Stan 模型直接提供给 Edward，但是听起来我需要编写 Edward 特定的代码来使用 Tensorflow 加速。我有一种感觉，Edward 可能在做随机变量推理，但遗憾的是文档和例子没有达到 PyMC3 和 Stan 那样的水平。然而，我必须说，当谈到贝叶斯学习的未来时，Edward 是最有前途的(由于在贝叶斯深度学习方面所做的大量工作)。
总之，PyMC3 对我来说是这些天的明显赢家。如果我不必时不时接触到 theano 框架，那就太好了，但除此之外，它确实是一个很好的工具。我希望看到 Edward 或 PyMC3 迁移到 Keras 或 Torch 后端，因为这意味着我们可以建模(和调试得更好)。快乐造型！
看这里是我的关于机器学习和深度学习的课程(使用代码 DEEPSCHOOL-MARCH 到 85 折)。
星巴克的顶点挑战
DSND uda city 顶石项目
这是 Udacity 数据科学家课程的顶点项目。该数据集包含模拟星巴克奖励移动应用程序上的客户行为的模拟数据。每隔几天，星巴克就会向手机应用程序的用户发出一次报价。当收到优惠的顾客的累计消费超过设计的阈值时，他/她将获得奖励。数据集包括 3 个文件，它们是:
- 投资组合，记录的报价类型
- 个人资料，客户资料
- 文字记录，记录人们收到报价、查看报价、完成报价和消费的时间。
它打算弄清楚顾客对这些广告的反应，以及什么样的人对每种类型的优惠反应最大？
问题陈述
我总是很好奇广告是否真的会促进生意。星巴克咖啡等产品曾经是我生活的一部分。即使没有任何折扣和 BOGO(买一送一)，我也会继续购买星巴克。我相信有很多人和我一样，所以我想验证我的假设，即那些发送给顾客的优惠对星巴克没有意义。因此，两个问题都解决了。
- 谁会对咖啡报价做出反应？
- 根据人口统计和优惠类型，人们会花多少钱？
数据探索和清理
1.文件夹文件
portfolio
- id(字符串)—优惠 id
- offer_type (string) —优惠的类型，如 BOGO、折扣、信息
- 难度(int) —完成报价所需的最低花费
- 奖励(int) —为完成一项提议而给予的奖励
- 持续时间(整数)
- 频道(字符串列表)
通过手机、电子邮件、社交网站和网络等渠道发送给客户的报价有 3 种类型，即 BOGO、折扣和信息。每个报价都有不同的难度和奖励。例如，用户可以收到一个买 10 美元减 2 美元的折扣优惠，此后，如果客户累积至少 10 美元的购买，则该优惠完成，并且将给予奖励。然而，信息稍有不同。这种类型的出价没有奖励，所以我们不会在抄本文件中找到任何出价已完成的记录。
2.概要文件
Head of profile
- 年龄(整数)—客户的年龄
- 成为会员日期(整数)—客户创建应用程序帐户的日期
- 性别(str) —客户的性别(请注意，有些条目包含“O”代表其他，而不是 M 或 F)
- id (str) —客户 id
- 收入(浮动)—客户的收入
17，000 名客户包含在个人资料中，当他们注册他们的 app 帐户时，他们的个人资料会被记录下来。有些信息不准确。有 2，175 名 118 岁人没有与性别和收入有关的信息。
Distributions
剔除这些无效资料后，14，825 名客户中女性占 41.3%，男性占 57.2%。超过 60%的人年龄在 45 到 80 岁之间。而他们的平均收入在每年 6.5 万左右。
3.抄本文件
Head of transcript
- 事件(str) —记录描述(即交易、收到的报价、查看的报价等。)
- 人员(字符串)—客户 id
- time (int) —以小时为单位的时间。数据开始于时间 t=0
- value —(字符串字典)—报价 id 或交易金额，具体取决于记录
该文件的 306，534 条记录来自应用程序。每个人可能会多次收到每种类型的报价。发送了 76，277 份报价，12，774 人至少完成了一份报价，422 人收到了没有任何消费的报价，16，834 人没有查看他们收到的任何报价，6 人购买了咖啡，而他们没有收到任何报价。
数据清理
- 从抄本文件的值字典中提取值。
- 替换包括自定义 id 在内的 id，并将 id 提供给更容易识别的 id。
- 根据事件的 4 种类型，将抄本文件分成 4 个表格。
- 将个人资料文件中的年龄和年龄的数字数据转换为类别数据。
Q1:谁会对咖啡有反应？
我们知道，当累计购买量超过阈值时，它将被记录为要约完成。然而，我们无法知道顾客购买咖啡是因为广告还是仅仅出于自然。也许我们可以设定标准来证明谁会对广告做出回应。
数据预处理
收到报价、查看报价并及时购买达到阈值金额的客户应被视为对三种报价类型之一做出响应的人。
然后，我用内部方法合并从人员和报价 id 的记录文件中分离出来的报价已接收、报价已查看和报价已完成表，并将新表命名为 response。然后根据报价 id 从投资组合表中添加持续时间变量，以确保每条记录都符合标准。
识别收到信息的人的方法略有不同。由于没有报价完成记录，另一个标准被定了下来。一个人在收到要约的时间加上持续时间内收到并查看了购买量大于零的信息性要约，则推断此人对该要约做出了响应。
探索数据分析
有 1，973 条记录符合标准。总体回答率为 2.59%。折扣要约的回复率最高，为 3.18%，信息要约的回复率最低，为 1.91%，BOGO 的回复率为 2.32%。
除了年轻人之外，每个年龄层的顾客对这些产品的态度都是一样的。他们喜欢打折，尤其是老年顾客。
3 年会员更容易受到折扣和 BOGO 的影响。也许他们更熟悉晋升的规则。然而奇怪的是为什么最早的成员不关心推广这么多。可能是样本小的原因。但是他们更容易受到信息的影响。
显然，收入较高的人如果得到促销优惠，会更愿意购物。当然，有钱人不在乎升职。为什么低收入人群较少受到星巴克促销的影响？一个合理的解释是，他们负担不起更频繁地去星巴克购物，因为只有 13%的顾客年收入低于 4 万英镑。
Q2:根据人口统计和产品类型，人们会花多少钱？
可承受的收入应该与消费有较高的正相关性。事实上，在这个给定的数据集中，收入和平均购买量之间的相关性是 0.80。因此，很容易得出结论，高收入的人平均会购买更多的星巴克咖啡。
然而，结果并不是我想要知道的。我更关心其他因素是否会对星巴克的消费产生积极影响。
数据预处理
内生变量是购买总量，外生变量是人口统计和优惠类型因素。
客户及其人口统计因素由档案文件提供。优惠类型因素来自响应表。这些广告只对有响应的人有意义。通过使用 subtotal on person 从交易表中得出购买的总金额。
其他变量是分类数据。它们将被转换成虚拟变量。
数据处理
- received_offer 表通过 left 方法合并到 person id 上的 profile 表中，以便标识身份客户收到的优惠类型。
- 消除他们没有收到任何报价的 id。
- 计算按每个人分组的交易金额的总和，然后用 left 方法加入到人员 id 的配置文件表中。
- 将分类数据转换为虚拟变量。
- 将数据分为训练集和测试集。
度量和模型选择
选择有监督的机器学习模型来解决这个问题。由于购买总额是连续数据，因此选择了三个回归模型作为候选模型。它们是多元线性回归模型、随机森林回归和支持向量回归。
三个度量是 con:
- R 平方，衡量预测值在多大程度上解释了实际值。
*过拟合，训练集和测试集的 R 平方之差。
*误差分布为线性回归模型。
结果
三个模型具有相似的 R 平方，但是都是欠拟合，没有过拟合。结果是可以预料的。如上图所示，收入与金额相比，数据集非常嘈杂。
改进
由于金额和收入是高度正偏的，最好将其转换为接近正态分布。
此外，应该消除异常值，并对数据集进行缩放。
r 平方比原始模型稍好，特别是对于推断过拟合较少而欠拟合仍然难以解决的测试数据集。此外，多因素线性回归模型的误差分布更接近正态分布，偏度为 0.3，峰度为 2.8。由于度量标准相似且易于理解，选择线性模型进行分析。
参数分析
尽管 R2 还不够好，但从模型中得到的因素参数提供了更有价值的信息。
- 收入因素、性别因素、成为会员因素和提供类型因素都显著不同于零，而年龄因素则不显著。
- 所有基于优惠类型的因素都有积极的贡献。这意味着广告真的可以帮助星巴克增加收入。
- 正参数值意味着女性比男性更有可能消费。
深入观察人口统计因素。
- 年龄大于 30 岁小于 80 岁的人更有可能消费星巴克。这是有道理的，因为他们有收入。因此，年龄并不重要。
- 与上述可视化分析结果类似，2015 年注册会员的客户贡献了更多的消费。
基于优惠类型的因素告诉我们:
- BOGO 和折扣比信息广告更能刺激消费。
- 持续时间越长，记录的购买量越多。这就产生了另一个问题，如果证明对这些类型的优惠做出反应的客户的标准过于严格。但是这个问题我不想深究。
- 更高的奖励吸引更多的消费。
结论
机器学习模型表明，广告确实能帮助增加收入，但不一定能增加利润。信息性报价的效果不如 BOGO 和折扣。然而，如果星巴克打算吸引更多的消费，促销成本可能会抵消收入，而没有足够的顾客反应。
然而，可视化分析显示回复率较低。结合可视化分析和机器学习模型的结论表明，广告 3 年会员的高收入女性似乎是一个好主意，因为她们很可能在星巴克花费更多。
用单个神经元启动神经网络
image from — https://unsplash.com/photos/ZiQkhI7417A
什么是分类问题？
分类是 ML 中一个重要的中心话题，它与训练机器如何按照特定的标准将数据分组有关。分类是计算机根据预定特征将数据分组的过程——这被称为监督学习。有一种无监督版本的分类，称为聚类，当类别未被指定时，计算机找到共享特征来对数据进行分组。
例如:
- 垃圾邮件:你的目标是预测一封邮件是否是垃圾邮件，是否应该发送到垃圾文件夹。(垃圾邮件/非垃圾邮件)。文本是输入(X)的简单单词序列。目标是预测二元响应 Y:是否是垃圾邮件。
- 手写数字识别:你的目标是正确识别 0-9 的图像。每个条目都是从 0(黑色)到 255(白色)像素强度范围内的整数。这个原始数据(X)将被输入，每个图像将被识别为(Y) 0 或 1 或 2 …或 9。
当你考虑第一个问题时，它被称为二项式逻辑回归，其中响应变量有两个值 0 和 1 或通过和失败或真和假。我们可以解释第二个问题，但是通过复杂性，我避免了对它的解释。对了，叫多类分类问题。
什么是逻辑回归？
如果你拿任何一个神经网络来说，它最基本的概念将依赖于一个分类算法逻辑回归。给定输入，输出为 1 的概率。它可以表示为条件概率:
例如，如果 x 是一封电子邮件，那么这封电子邮件是垃圾邮件的可能性有多大。
假设输入 x 只有一个值，我们需要 ŷ。通过下面的等式，我们推导出 ŷ.在该等式中，w(称为权重)和 b(偏差)是决定输出 ŷ精确度的参数。请注意， ŷ可以是任何值(100 或 103 或 3002.5 或-50)。为了使它在 0 到 1 之间，我们使用 Sigmoid 函数。不仅仅是我们使用的函数，还有许多具有不同特性的函数。为了教程的简单，我不打算深入讲解。
通常输入不是一个单一的值。因此，我们将所有输入表示为矩阵 X. 相应的参数值为矩阵 w 和 b 。将输入 x 作为 n 维矩阵。这里西格玛表示西格玛函数
让我们深入一点...
从这里你可能会对神经元中发生的事情有一种直觉。在继续下一步之前，请看下图。
Pic has been taken from Andrew Ng’s Data Science Course
这是一个简单的图表，显示了单个神经元对 cat 的预测。这里发生的是每一张猫的图像都被转换成一个矩阵向量。例如，RGB 图像将包含红色、蓝色和绿色的 3 个矩阵。如果我们取一个矩阵为 6464 像素，那么一个矩阵将包含 6464 个值。我们将所有三个向量组合成一个矩阵，并作为 1(64643)矩阵输入。如果你拍摄 n 张照片，那么矩阵就是 n(64643)。如图所示，最终输出将在 0 到 1 之间，如果值大于 0.5，我们可以区分猫图像。
就是这样…..😄
.
.
.
等等……那么参数呢——权重和偏差。谁给它赋值？
是的，神经网络的主要部分是通过训练模型使用损失函数来微调参数。我们使用损失函数来微调参数。
构建神经网络模型包括以下重要步骤。
- 首先，你必须初始化模型的参数。
- 通过最小化成本来学习模型的参数(w，b)。
- 使用学习到的参数进行预测(在测试集上)。
- 分析结果并得出结论。
以下函数表示 m 幅图像的总损失。其中 ŷ 是作为输出给出的值，而 y 是原始值。举个例子，如果你拍摄一张猫的照片，ŷ就是上面的逻辑回归函数给出的输入 x 的输出。y 是实际的标签，其中 y 表示标签(cat 与否)— 0 或 1
这个说不通。这些损失你打算怎么处理？
是的，通过减少损耗，我们提高了精确度。为了减少损失，必须更新参数。如果参数更新正确，那么只有输出 ŷ会自动靠近 y 轴。我们使用梯度下降来实现。
“梯度衡量的是，如果你稍微改变输入，函数的输出会改变多少。”——莱克斯·弗里德曼(麻省理工学院)
如果你想了解更多关于渐变得体的 请参考本教程 。
最后，我们将更新参数，以尽量减少损失，通过这一点，我们得到了良好的准确性。
我觉得，我已经给了你一点关于一个神经元的直觉。下次我会试着想出代码。如果你想了解神经网络，请参考我以前的教程。
感谢阅读。如果这是一本好书，请鼓掌。尽情享受吧！
创业生活:5 天 5 种编程语言
影响巨大的旋风项目
两年前，我开始在创业公司做开发人员。很明显，作为开发人员，最重要的技能是快速学习新技术的能力。不管是什么技术，我学习新技术的方法都非常相似。我从阅读“关于”页面开始，试图找出该技术试图解决的问题。然后，我查看用例并浏览快速入门指南。最后，我将开始编写我需要的代码。首先，我将在网上搜索一个例子，然后可能尝试修改现有的代码，或者猜测并检查我自己的实现。然后，我将运行代码并跟踪错误消息。这些年来，我非常擅长阅读回溯，这让我成为了一名更好的程序员。还有， stackoverflow ， stackoverflow 和 stackoverflow。在最近的一个项目中，我发现自己在 5 天内用 5 种不同的语言编写代码，这提醒了我快速学习新技术的技能是多么重要。我的任务是建立一个数据管道，在图像被用于训练卷积神经网络之前对其进行处理。
第一天:Ruby on Rails
尽管我在 R&D 团队工作，后端团队使用 Ruby on Rails 进行开发。他们开发了一个 ruby 脚本，将数据匿名化，然后转储给 R&D 使用。我们开会决定 R&D 可以使用生产数据库中的哪些表/列来构建神经网络，但我注意到数据匿名化程序从未更新过。我将此事提请工程部门注意，他们建议我更新程序，因为我确切地知道需要什么样的色谱柱。因此，第一天要求我用 Ruby 编写代码，这是一种我没有经验的语言。这并不太具有挑战性，因为我只是简单地更新了一个现有的脚本。
第二天:SQL
我现在有了需要为神经网络处理的原始图像的 URL。除了 URL，图像还需要与它们的类型和大小调整参数相关联，但是这些信息分散在数据库的六个表中。我需要编写一个 SQL 过程，将数据整理到一个表中。我以前在开发 Django web 应用程序时使用过数据库，但是 Django 的一个非常好的地方是它的对象关系模型(ORM)。这意味着我从未编写过原始 SQL，而是使用了 python API。然而，对于我当前的项目，我不再被 ORM 的便利所宠坏，而不得不写原始的 SQL。SQL 不是最复杂的语言，但它确实有一些我没有立即发现的行为。例如，如果没有对列进行聚合，就不能在 group by 过程中选择列(仔细想想，这是有意义的)。相反，您必须基于一个惟一的字段连接回原始表(有效地聚合该列)。此外，当在两个表之间进行连接时，可以返回比单个表中更多的行。最后，我对声明式编程有了一种欣赏，甚至开始喜欢它。
第 3 + 4 天:C++ & Python
在成功地修改了数据转储过程并编写了 sql 清理脚本之后，我获得了需要处理的数据。这个项目侧重于图像分割，需要进一步处理图像，并将它们与元数据相关联，然后才能输入到神经网络中。这是用 C++编写的，这是另一种我从未使用过的语言，老实说我很害怕(我从未使用过编译语言)。也许我的一半处理脚本用 python 写，另一半用 C++写是没问题的，但是我发现修改 C++脚本很有挑战性，所以我决定把 C++代码翻译成 python。为此，我必须编译并运行 C++代码，理解它，然后用 python 写它的等价物。这真的很有挑战性，但是我的一个同事帮我用 xcode 建立了我的构建环境。老实说，我发现调试 C++真的很有挑战性，主要是因为我无法打开一个解释器来测试我的逻辑。当我和我的同事谈到这一点时，他提出了它的优点，因为它避免了运行时错误。我注意到的一件事是 python 代码慢了多少。
第五天:哈希公司配置语言(HCL) — Terraform
现在我已经有了处理脚本(python)和适当的数据(postgres 表)，是时候实际处理图像了，这项任务可能需要几个小时，甚至几天。唯一的问题是，这些图像是在私人 S3 桶。在我看来，每个公司都需要双倍的 DevOps 工程师。让 DevOps 的小团队从维护和开发生产应用程序中抽出时间，我感到不舒服，因此，在他们的指导下，我进入了 terraform，一个作为代码框架的基础设施。使用这个框架，我编写了代码来为机器提供可以处理图像的适当模块。这非常具有挑战性。我知道如何编写程序，但是配置 VPCs、安全组、S3 资源完全超出了我的能力范围。多亏了预建模块的 terraform 注册表和 DevOps 的帮助，我才能够拼凑出一些东西。旁注:基于云的数据科学是一个被称为数据操作的新兴领域。这非常有趣，这次经历让我离它最近。
希望这篇文章对你自己的编码冒险有所启发，或者对你不是唯一一个不断走出舒适区的编码员有所启发。无论如何，小心编码，祝你好运！
https://pixabay.com/en/mario-luigi-figures-funny-colorful-1557974/
从问题开始您的数据探索
大多数已经经营了一段时间的公司已经积累了大量的数据，这些数据通常分布在多个数据库或数据存储中，并且具有多种格式，有些是结构化的，有些是自由格式的。
在数据分析和机器学习提供新工具和方法的时代，现有数据显然代表着一个机会。可以收集到哪些新的见解？可以从哪些机构流程中吸取经验并加以改进？哪些运营效率或机会被忽略了？
但是在数据收集过程中还存在许多障碍。很难知道哪些数据是最重要的。即使在结构化数据库中，数据的格式也可能随着需求的变化而改变。正如我在之前的文章中所描述的，数据挖掘——注意差距，数据之间的关系可能并不明显，可能无法通过加载和规范化过程。
在加载任何数据之前，应该有一个活跃的步骤，我称之为头脑风暴提问。一群知识渊博的人应该提出他们可能想知道的关于数据的问题。这里的重点不是回答问题，甚至不是预测什么问题真的会被问到。相反，我们的目标是探索回答每种类型的问题需要哪些联系。
如果项目的目的主要是数据分析，问题通常应该是分析性的。与劳动密集型项目相比，我们在资本密集型项目上取得了哪些成功？这种成功会随着时间而改变吗？某些人参与了最成功或最不成功的项目吗？与收入增长相比，每个部门的员工增长率是多少？
如果目的更多的是认知性的，问题可能更多的是对话性的和定性的？我们团队中的哪些人主动提出了建议？与那些沉默寡言的人相比，他们有什么样的建议？当某个特定产品的销量下降时，什么样的信息会向公众发布，什么样的信息会在内部发布？在我们公司内使用任何特定的短语是否倾向于暗示某项计划的成功或失败？
下面的简短视频展示了在数据分析之前使用的这一过程的简化快照。该演示基于一组真实的 Lotus Notes 数据库，其中包含业务合作伙伴可以向 IBM 报告的可能的错误报告，IBM 将对这些报告做出响应。注意，即使对于这个简单的系统，每个 bug 和 IBM 的响应都在由父子层次结构关联的单独文档中。修复列表数据库是一个独立的数据库，没有以任何明显的方式链接，但可以通过关键字进行搜索。有丰富的文本与自由形式的问题和答案。
关键的想法是，通过在开始挖掘之前提出问题，可以弄清楚哪些关系需要保留。您还可以决定在数据分析中将来自不同地方的信息汇总到一个“记录”中。
请记住，在实际准备和清理数据的过程中，任何可以节省的时间都是值得的。
因此，在你开始将数据加载到你的数据或认知分析系统之前，计划时间问一些自由形式的问题。它们可以帮助你理解你所拥有的数据，并确保你加载、规范化和准备数据的努力将导致一个系统来回答你还没有想到的问题。
开始一个数据科学项目
上周六，我在一次网络研讨会上谈到了如何进入数据科学领域。其中一个问题是“典型的一天是什么样子的？”我认为在大型项目的任何机器学习发生之前，有一个很好的机会来解释真正发生了什么。
我以前写过关于为功能工程进行创造性思维的文章，但为数据科学项目做准备还有更多，你需要从业务的其他领域获得对项目的支持，以确保你提供业务想要和需要的见解。
通向机器学习算法的道路看起来像这样:
- 会议
- 更多会议
- 数据采集
- 特征工程
- 然后是机器学习
在本文中，我们将只讨论前 3 个要点。研究最佳解决方案也可能是这个过程的一部分，但我知道我是在做细分。
在我为一个大项目写一行 SQL 之前，会有很多会议。如果你阅读了足够多关于数据科学的评论/博客，你会看到人们说 95%的数据聚合和 5%的建模(或其他类似的划分)，但这也不是全部。当你成为一名数据科学家的时候，我希望你能完全理解你所签署的协议。
正如我提到的，第一步是真正参与你的项目。作为分析部门，我们致力于解决业务需求，这一点很重要。我们希望通过在与这些利益相关者的会议上推销这一想法，帮助企业的其他部分理解细分可以带来的价值。另外，我也不是独角戏。只要有机会，我的老板就会抓住机会谈论我们可以从这个项目中学到什么，并采取行动。我们现在已经在多个团队中达成共识，他们希望我们提供行为客户细分。
但是我仍然不仅仅是一头扎进 SQL。我的团队和前面提到的业务领域中的一些人可以帮助我们集思广益，看看我们可能有哪些数据可以帮助我们了解我们的客户。在我们的案例中，存在我们以前没有机会分析的数据。
第一步是和我的团队开会，讨论我们能想到的所有相关数据。思考这样的事情:
- 如果某种东西可以代表更“精通技术”的客户。也许这是一个商业电子邮件地址，而不是谷歌地址，或者也许你正在利用我们更先进的功能
- 人口普查数据可以告诉我们一个客户的邮政编码是在农村还是在城市？它们可能是不同的。
- 大数据环境中有什么可用的？在数据仓库里？公司内部的其他数据源。当你真的想列出所有事情时，你会发现这可能是一个大事业。
接下来，我在不同的会议上会见了营销和运营部门，以确保我们没有遗漏任何东西，并看看他们是否对输入有更多潜在的想法。在整个项目过程中保持持续的沟通也是很好的实践。
在我们有了一个潜在数据列表后，会议开始帮助我们追踪所有的数据。你肯定不想在这里重新发明轮子。没有人会因为自己编写所有的 SQL 而得到加分，如果您利用以前编写的查询，这将花费您一半的时间。
如果我知道某个项目中有人已经创造了一些很酷的功能，我会给他们发电子邮件，询问他们的代码，我们是一个团队。
最后，在我的团队之外，我需要联系 6 个不同的人，他们比我的团队成员更了解这些表或数据源。所以是时候向其他人询问这些桌子了，这意味着安排更多的会议。
老实说，我很喜欢这个过程，这是一个了解我们所拥有的数据、与他人合作以及为功能工程考虑很酷的机会的机会。
同样值得注意的是，这些与团队以外的人的会议可能不是他们最优先考虑的事情，时间安排可能会变得棘手，不要气馁。坚持就好。你对自己需要从别人那里得到什么越清楚、越简洁，可能有助于你更快地获得帮助。如果他们在同一个办公室，你可以试着去他们的办公桌旁。
脑海中的画面通常是数据科学家独自坐在角落里几个月，然后带着一个无人问津的模型回来。但是通过获得认同，与其他团队和你的团队成员合作，这并不是必须的。您可以成为思想伙伴，主动提供解决方案，更好地锁定客户群，个性化客户体验。
如果你想订阅我未来的文章，你可以在这里订阅。
原载于 2018 年 7 月 3 日【datamovesme.com。
从生物信息学开始——DNA 核苷酸和链
在我介绍生物信息学的第一篇文章中，我提到我们将会学到很多关于 DNA、RNA 和蛋白质序列的知识。因为我对所有这些 DNA/RNA 术语都不熟悉，所以我决定先学习它们，然后尝试一些编码问题。所有的测序问题好像都有一些和遗传学有关的词。首先，让我们开始吧。😊
注:我假设你有基本的化学知识，从而假设你知道诸如氢键、磷酸基团、羟基等术语的含义。
什么是 DNA？
DNA 或脱氧核糖核酸，是一种携带所有生物遗传密码的分子。DNA 和它的朋友 RNA 或核糖核酸一起被称为核酸。DNA 是储存生物所有生物信息的结构。
什么是核苷酸？
DNA 是一种长的链状分子，由两条拧成双螺旋的链组成。这两条链由更简单的分子组成，叫做核苷酸 T21。每个核苷酸由四个含氮的核碱基 、中的一个组成
DNA chemical structure (https://en.wikipedia.org/wiki/Nucleobase)
- 胞嘧啶(C)
- 鸟嘌呤(G)
- 腺嘌呤 ( 一 )
- 胸腺嘧啶(T)
连同一种糖叫做，还有一种 磷酸 基团 。
这些核碱基通过在一个核碱基的糖和下一个核碱基的磷酸之间形成共价键而以链状结构相互连接，从而产生交替的糖-磷酸骨架。你可以参考上面给出的图表来清楚地理解。
代表一条 DNA 链
如上所述，通过连接核碱基形成的单个 DNA 链可以简单地表示如下。您可以将此表示映射到之前的图像。这将是上图中分子的一面。
Chained nucleotides constituting a DNA strand (Wiley: Bioinformatics For Dummies, 2nd Edition)
你可能会注意到，最左端有一个未使用的 磷酰基 (也叫5’-末端* )和最右端有一个未使用的 羟基 (也叫3’-末端 )。单链的 DNA 序列总是被定义为一系列组成它的核苷酸，按从未使用的磷酰基到未使用的羟基的顺序排列。上述 DNA 序列可以表示为:*
***TGACT** = **Thymine-Guanine-Adenine-Cytosine-Thymine***
DNA 序列的两个部分
根据碱基配对规则，两条独立链的核碱基连接在一起； A 带 T 和 C 带 G ，连同 氢键 。DNA 分子由两条互补链组成，如下图所示。也标记了核苷酸的阅读方向。
The two complementary strands of a complete DNA molecule (Wiley: Bioinformatics For Dummies, 2nd Edition)
互补性意味着两条链遵循碱基配对规则。一条链上的胸腺嘧啶总是面对腺嘌呤，反之亦然；鸟嘌呤总是面对着胞嘧啶，反之亦然。当你知道一条 DNA 链的核苷酸序列时，你可以自动推断出另一条链的序列。
上述 DNA 分子的相对链的表示将是，
***TGACT** and **AGTCA***
该练习了
我偶然发现了这个名为 Rosalind 的有趣的编程平台，在这里你可以通过解决现有的问题来学习生物信息学和编程。我将讨论与我在本文中讨论的内容相关的两个问题，并解释我是如何解决它们的。我将用我自己的例子来解释。你可以从上面的链接中尝试一下。
计算 DNA 核苷酸
给定的一个 DNA 序列可以被认为是一个带有字母表的字符串{"A "、" C "、" G "、" T"}。我们可以计算每个字母在字符串中出现的次数。
下面是我的 Python 解决方案。
Counting DNA Nucleotides solution in Python
我的 sample_dna.txt 文件包含以下 dna 字符串。
***GTAAACCCCTTTTCATTTAGACAGATCGACTCCTTATCCATTCTCAGAGATGTGTTGCTGGTCGCCG***
下面给出的是输出。
Counting DNA Nucleotides output
我们可以从文件中读取 DNA 字符串，然后使用 Python 的字符串计数方法来计算每个字母出现的次数。您还可以在循环中迭代字符串，并分别维护每个字母的计数。
补充一条 DNA 链
回忆一下我们所了解的 DNA 分子的互补链。这个问题是关于寻找另一个面对的链的序列。
下面是我的 Python 解决方案。
Complementing a Strand of DNA solution in Python
我的 sample_dna.txt 文件包含以下 dna 字符串。
***AAAACCCGGTGTCTTATATCGAGTCATGCAATTTTGGG***
下面给出的是输出。
Complementing a Strand of DNA output
在这个解决方案中，我反向遍历字符串，将 A 替换为 T，T 替换为 A，G 替换为 C，C 替换为 G，以获得互补的 DNA 字符串。
最后的想法
DNA 序列和相关数据存储在巨大的数据库中，并用于不同的领域，如法医学、系谱学和医学。这些简单的技术将成为开发更复杂问题的解决方案的基础。
希望你喜欢读这篇文章，并学到一些有用的东西。
因为我对这个领域还很陌生，所以我想听听你的建议。😇
感谢阅读…😃
从生物信息学开始——RNA 转录和翻译
在我之前的文章中，我已经介绍了 DNA 以及如何将 DNA 变成蛋白质。别忘了也去看看。在本文中，我们将涉及以下主题。
- 什么是 RNA？
- 如何从 DNA 中获取 RNA？
- 如何把 RNA 变成蛋白质？
在本文的最后，我们将尝试用 Python 编写一些代码来涵盖我们所学的内容。
什么是 RNA？
Nucleobases in an RNA molecule (https://en.wikipedia.org/wiki/RNA)
RNA 或核糖核酸是一种核酸，类似于 DNA。然而，与非常稳定的 DNA 不同，RNA 是核酸家族中更活跃的成员。在生物信息学的背景下，RNA 和 DNA 之间只有两个重要的区别:
- RNA 与 DNA 相差一个核苷酸。
- RNA 由单链(一个核苷酸)组成，不是螺旋。
RNA 由下列核碱基组成，
- 胞嘧啶 (C)
- 鸟嘌呤 (G)
- 腺嘌呤(一)
- 尿嘧啶 (U)
连同一种糖叫做 核糖 ，还有一种 磷酸 基团 。 尿嘧啶 是在 RNA 中发现的碱基，不同于在 DNA 中发现的胸腺嘧啶。这些核碱基通过在一个核碱基的糖和下一个核碱基的磷酸之间形成共价键而以链状结构相互连接，产生了交替的糖-磷酸骨架，类似于 DNA 链。你可以在我之前的文章中读到更多关于链形成过程的信息。
尽管 RNA 分子是单链的，但它们仍然强烈要求与互补序列配对。单链 RNA 分子与其序列的不同区域配对，形成稳定的双螺旋结构。每个 RNA 分子试图配对尽可能多的核苷酸，同时保持它们的形状。发夹形状如下图所示，是 RNA 结构的基本元素。它们由环(图中未配对的 C-U)和茎(图中配对的区域)组成。
How RNA turns itself into a double-stranded structure (Wiley: Bioinformatics For Dummies, 2nd Edition)
DNA 转录成 RNA
转录是一个过程，其中一条 DNA 链被用作模板，通过一次复制一个核苷酸来构建一条 RNA 链，其中尿嘧啶被用于替代胸腺嘧啶。
以下面的 DNA 字符串为例。
**AATTTGCTTGGCAAATCGTATGCCTTGGG**
通过将所有出现的 T 替换为 U ，可以获得如下相关的 RNA 字符串。
**AAUUUGCUUGGCAAAUCGUAUGCCUUGGG**
你可以在这里阅读关于转录的从一个更生物学的角度。
将 RNA 转化成蛋白质
如果你知道一个 RNA 序列，可以用遗传密码翻译成相应的蛋白质序列。这与细胞自身产生蛋白质序列的方式相同。
RNA 的遗传密码(也称为 RNA 密码子表)展示了我们如何将一个 4 核苷酸序列(A、U、G、C)与一组 20 个氨基酸唯一地联系起来。这和我上一篇文章讨论的 DNA 密码子表很像，只是我们用了“U”而不是“T”。下图以图表的形式显示了 RNA 的遗传密码。
Genetic code chart for RNA (https://stackoverflow.com/)
如何使用遗传密码图进行 RNA 到蛋白质的翻译
首先你应该得到你的 RNA 字符串。
**AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA**
然后开始一次读取 3 个核苷酸的序列(一个三联体)。
**AUG GCC AUG GCG CCC AGA ACU GAG AUC AAU AGU ACC CGU AUU AAC GGG UGA**
现在用遗传密码图读出当前三联体对应的是哪一个氨基酸(技术上称为密码子)。从中心开始的第一个圆圈代表三元组的第一个字符，第二个圆圈代表第二个字符，第三个圆圈代表最后一个字符。翻译后，你会得到与上述 RNA 序列相对应的蛋白质序列。
**M A M A P R T E I N S T R I N G STOP
M A M A P R T E I N S T R I N G**
UAA ， UAG 和 UGA 被称为终止信号，在此停止翻译过程。
该练习了
将 DNA 转录成 RNA
RNA 字符串可以用字母表示为{"A "，" U "，" G "，" C"}。通过用“U”替换 DNA 串中所有出现的“T ”,可以将 DNA 串转换成其相应的转录 RNA 串。下面给出了从给定的 DNA 字符串中获取 RNA 字符串的示例代码。请随意尝试代码，看看会发生什么。
Transcribing DNA in to RNA code in Python
我在 sample_dna.txt 文件中输入了以下 DNA 字符串。
**ATATATCCCGGGAATTTTCGTAGTTAGGCTGATTTTATTGGCGCGAAAATTTTTT**
下面给出了获得的输出。
Transcribing DNA in to RNA output
请注意，所有出现的“T”都被替换为“U”。
使用 Python 进行 RNA 到蛋白质的翻译
下面给出的 Python 代码获取一个 RNA 序列，并将其转换为相应的蛋白质序列。我已经创建了一个字典来存储遗传密码图的信息。请随意尝试代码，看看会发生什么。
Translating RNA into Protein code in Python
我使用了上面提到的同一个例子，作为对 sample_rna.txt 文件的输入。
AUGGCCAUGGCGCCCAGAACUGAGAUCAAUAGUACCCGUAUUAACGGGUGA
下面给出的是结果。
Translating RNA into Protein output
最后的想法
生物信息学中有一个独立的分支，名为 RNA 生物信息学，主要研究 RNA。目前有许多工具和技术可用于分析 RNA 序列。
希望你喜欢读这篇文章，并学到一些有用的东西。
因为我对这个领域还很陌生，所以我想听听你的建议。😇
请继续关注我关于生物信息学的下一篇文章。
感谢阅读…😃
从生物信息学开始——将 DNA 序列转化为蛋白质序列
在这篇文章中，我们将学习蛋白质以及如何将 DNA 序列转换成蛋白质序列。如果你错过了我之前的一篇关于 DNA 核苷酸和链的文章，我建议你读一读，这样你会觉得这篇文章更有意义。让我们继续来看蛋白质。
什么是蛋白质？
蛋白质是由氨基酸组成的链状大分子。蛋白质之间的区别主要在于它们的氨基酸序列，这是由它们基因的核苷酸序列决定的。在讨论蛋白质之前，让我们看看什么是氨基酸。
什么是氨基酸？
Structure of an amino acid (https://en.wikipedia.org/wiki/Amino_acid)
氨基酸是复杂的有机分子，主要由碳、氢、氧和氮以及其他一些原子组成。它包含一个 胺基 和一个 羧基 ，以及一个对每种氨基酸特异的 侧链 (R 基团)。
目前已知大约 500 种氨基酸，但只有 20 种出现在我们的遗传密码中。这 20 种氨基酸是我们感兴趣的组成部分。
20 种常见的氨基酸
下图显示了在我们的遗传密码中出现的 20 种常见氨基酸，以及它们的全名、三个字母的代码和一个字母的代码。
The 20 Common Amino Acids (Compound Interest: http://www.compoundchem.com/2014/09/16/aminoacids/)
用氨基酸代表蛋白质
生物化学家已经认识到，特定类型的蛋白质总是以相同的比例包含完全相同数量的总氨基酸(统称为残基)。举个例子，
**insulin = (30 glycines + 44 alanines + 5 tyrosines + 14 glutamines + . . .)**
此外，氨基酸以链的形式连接在一起。蛋白质的特性是从它的组成以及组成它的氨基酸的精确顺序中获得的。因此，胰岛素可以表示为，
**insulin = MALWMRLLPLLALLALWGPDPAAAFVNQHLCGSHLVEALYLVCGERG FFYTPKTRREAEDLQVGQVELGGGPGAGSLQPLALEGSLQKRGIVEQCCTSICSLYQLENYCN**
形成蛋白质
蛋白质是由氨基酸及其胺和羧基基团在序列中连续的残基之间形成被称为 肽键 的键而形成的。下面给出的两个图表描述了游离氨基酸如何通过形成肽键来形成蛋白质。
Free amino acids (Wiley: Bioinformatics For Dummies, 2nd Edition)
Amino acids chained together to form a protein molecule (Wiley: Bioinformatics For Dummies, 2nd Edition)
你可以看到在最左端有一个未使用的胺基，在最右端有一个未使用的羧基。这些末端分别被称为蛋白质链的 N 端和 C 端。蛋白质的序列是由组成它的氨基酸读出的，这些氨基酸按从 N-末端到 C-末端的顺序排列。因此，在上图中发现的蛋白质序列将是，
**MAVLD = Met-Ala-Val-Leu-Asp
= Methionine–Alanine-Valine–Leucine-Aspartic**
将 DNA 转化成蛋白质
当你知道一个 DNA 序列时，你可以通过使用遗传密码将其翻译成相应的蛋白质序列。这与细胞自身产生蛋白质序列的方式相同。这个过程被称为 DNA 到蛋白质的翻译。
遗传密码(称为 DNA 密码子表 用于 DNA 序列 ) 显示了我们如何将一个 4 核苷酸序列(A、T、G、C)与一组 20 个氨基酸唯一地联系起来。它描述了一套规则，通过这些规则，活细胞将遗传物质中编码的信息翻译成蛋白质。下图以图表的形式显示了 DNA 密码子表。
Genetic Code Chart for DNA (http://www.geneinfinity.org/sp/sp_gencode.html)
如何使用遗传密码图进行 DNA 到蛋白质的翻译
首先你应该得到你的 DNA 序列。
**ATGGAAGTATTTAAAGCGCCACCTATTGGGATATAAG**
然后开始一次读取 3 个核苷酸的序列(一个三联体)。
**ATG GAA GTA TTT AAA GCG CCA CCT ATT GGG ATA TAA G...**
现在用遗传密码图读出当前三联体对应的氨基酸(技术上称为密码子)。从中心开始的第一个圆圈代表三元组的第一个字符，第二个圆圈代表第二个字符，第三个圆圈代表最后一个字符。翻译后，你会得到与上述 DNA 序列相对应的蛋白质序列。
**M E V F K A P P I G I STOP
M E V F K A P P I G I**
TAA ， 标签 和 TGA 被称为终止信号，在此停止翻译过程。
使用 Python 进行 DNA 到蛋白质的翻译
下面给出的 Python 代码获取 DNA 序列，并将其转换为相应的蛋白质序列。我已经创建了一个字典来存储遗传密码图的信息。请随意尝试代码，看看会发生什么。
我已经在 sample_dna.txt 文件中输入了我们之前讨论过的相同 DNA 序列。
**ATGGAAGTATTTAAAGCGCCACCTATTGGGATATAAG**
下面给出了获得的结果。
Translating DNA into Protein output
最后的想法
如果你知道蛋白质编码区在 DNA 序列中的起始位置，你的计算机就可以用简单的代码生成相应的由氨基酸组成的蛋白质序列。许多序列分析程序使用这种翻译方法，因此您可以使用计算机将 DNA 序列作为虚拟蛋白质序列进行处理。
希望你喜欢读这篇文章，并学到一些有用的东西。
因为我对这个领域还很陌生，所以我想听听你的建议。😇
请继续关注我的下一篇关于生物信息学的文章，那将是关于 RNA 序列的。
感谢阅读…😃
从哈斯克尔张量流开始
上周，我们讨论了人工智能系统的蓬勃发展。我们看到了这些系统如何越来越多地影响我们生活的几个例子。我认为我们在选择架构时应该更加关注可靠性。毕竟，当我们现在正确编码时，人们的生命可能处于危险之中。自然，我建议 Haskell 作为开发可靠的人工智能系统的主要候选人。
所以现在我们实际上要写一些 Haskell 机器学习代码。我们将关注张量流绑定库。我第一次熟悉这个图书馆是在四月的 BayHac 。我在过去的几个月里学习了整个张量流和 Haskell 库。在第一篇文章中，我们将回顾张量流的基本概念。我们将看到它们是如何在 Python(TF 最常用的语言)中实现的。然后我们将把这些概念翻译给 Haskell。
请注意，本系列不是对机器学习概念的一般性介绍。Medium 上有一个很棒的系列，叫做机器学习很有趣！如果您对学习基本概念感兴趣，我强烈推荐您阅读该系列的第 1 部分。有了这个背景，我自己的文章系列中的许多观点会更加清晰。
张量
张量流是一个伟大的名字，因为它将库分解成两个基本概念。首先是张量。这些是张量流中数据表示的主要工具。低维张量其实挺直观的。但是，当你无法真正想象正在发生的事情时，你必须让理论思想来指导你。
在大数据的世界里，我们用数字来表示一切。当你有一组数字时，程序员的本能是把它们放在一个数组中。
[1.0, 2.0, 3.0, 6.7]
如果你有很多相同大小的不同数组，你想把它们关联在一起，你会怎么做？你创建了一个二维数组(数组的数组)，我们也称之为矩阵。
[[1.0, 2.0, 3.0, 6.7],
[5.0, 10.0, 3.0, 12.9],
[6.0, 12.0, 15.0, 13.6],
[7.0, 22.0, 8.0, 5.3]]
大多数程序员都非常熟悉这些概念。张量采用这种思想，并不断扩展。当你有很多相同大小的矩阵时会发生什么？您可以将它们组合成一个矩阵数组。我们可以称之为三维矩阵。但是“张量”是我们在所有维度中用来表示数据的术语。
每个张量都有度数。我们可以从一个数字开始。这是一个 0 度张量。那么一个正常的数组就是一个 1 阶张量。那么矩阵就是 2 次张量。最后一个例子是一个三阶张量。你可以不断地把这些加在一起，无穷无尽。
每个张量都有形状。形状是一个代表张量维数的数组。这个数组的长度就是张量的次数。所以一个数字的形状是空列表。一个数组将有一个长度为 1 的列表，包含数组的长度。一个矩阵将有一个长度为 2 的列表，包含它的行数和列数。诸如此类。有几种不同的方法可以在代码中表示张量，但是我们一会儿会讲到。
随波逐流
要理解的第二个重要概念是张量流如何执行计算。机器学习通常涉及简单的数学运算。许多简单的数学运算。由于规模如此之大，我们需要尽可能快地执行这些操作。我们需要使用针对这一特定任务而优化的软件和硬件。这就需要对正在发生的事情有一个底层的代码表示。这在 C 语言中比在 Haskell 或 Python 中更容易实现。
我们可以用 Haskell 编写大部分代码，但是用 C 语言使用外部函数接口来执行计算。但是这些接口有很大的开销，所以这很可能会抵消我们从使用 c 语言中获得的大部分好处。
张量流对这个问题的解决方案是，我们首先建立一个描述我们所有计算的图。一旦我们描述了这些，我们就用一个“会话”来“运行”我们的图表。因此，它一次执行整个语言转换过程，所以开销较低。
如果这听起来很熟悉，那是因为这是 Haskell 中动作的工作方式(在某种意义上)。例如，我们可以描述一个 IO 动作。这个动作不是我们在代码中出现的时候执行的一系列命令。更确切地说，动作是我们的程序将在某个时刻执行的操作的描述。这也类似于有效编程的概念。我们将在以后的博客中探讨这个话题。
那么我们的计算图是什么样的呢？我们会，每个张量都是一个节点。然后，我们可以为“运算”创建其他节点，这些节点以张量作为输入。例如，我们可以把两个张量加在一起，这是另一个节点。我们将在示例中看到如何构建计算图，然后运行它。
张量流的一个令人敬畏的特性是张量板应用程序。它可以让你可视化你的计算图表。我们将在本系列的后面看到如何做到这一点。
编码张量
因此，在这一点上，我们应该开始检查我们实际上是如何在代码中创建张量的。我们将从如何在 Python 中实现这一点开始，因为这样概念更容易理解。我们将考虑三种类型的张量。首先是“常数”。这些代表一组不变的值。我们可以在整个模型训练过程中使用这些值，并且每次都是相同的。因为我们预先定义了张量的值，所以没有必要给出任何大小参数。但是我们将指定用于它们的数据类型。
import tensorflow as tfnode1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0, dtype=tf.float32)
现在我们可以用这些张量做什么呢？为了快速举例，让我们试着添加它们。这在我们的图中创建了一个新的节点，表示这两个张量的相加。然后我们可以“运行”加法节点来查看结果。为了封装我们所有的信息，我们将创建一个“会话”:
import tensorflow as tfnode1 = tf.constant(3.0, dtype=tf.float32)
node2 = tf.constant(4.0, dtype=tf.float32)
additionNode = tf.add(node1, node2)sess = tf.Session()
result = sess.run(additionNode)
print result“””
Output:
7.0
“””
接下来是占位符。这些是我们每次运行都要改变的值。通常，我们将使用这些作为模型的输入。通过使用占位符，我们将能够改变输入并每次训练不同的值。当我们“运行”一个会话时，我们需要给每个节点赋值。
我们不知道将进入占位符的值，但我们仍然在构造时分配数据的类型。如果我们愿意，我们也可以指定一个尺寸。这里有一个简短的片段，展示了我们如何初始化占位符。然后，我们可以在每次运行应用程序时分配不同的值。即使我们的占位符张量没有值，我们仍然可以添加它们，就像我们添加常量张量一样。
node1 = tf.placeholder(tf.float32)
node2 = tf.placeholder(tf.float32)
adderNode = tf.add(node1, node2)sess = tf.Session()
result1 = sess.run(adderNode, {node1: 3, node2: 4.5 })
result2 = sess.run(adderNode, {node1: 2.7, node2: 8.9 })
print(result1)
print(result2)"""
Output:
7.5
11.6
"""
我们要用的最后一种张量是变量。这些是将构成我们“模型”的价值观。我们的目标是找到这些参数的值，使我们的模型能够很好地拟合数据。我们将一如既往地提供数据类型。在这种情况下，我们还将提供一个初始常数值。通常，我们会希望使用某种随机分布。张量实际上不会取值，直到我们运行一个全局变量初始化函数。在开始之前，我们必须创建这个初始化器，然后让我们的 session 对象运行它。
w = tf.Variable([3], dtype=tf.float32)
b = tf.Variable([1], dtype=tf.float32)sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
现在让我们使用我们的变量来创建一个“模型”的排序。在本文中，我们将制作一个简单的线性模型。让我们为输入张量和模型本身创建额外的节点。我们将设w为权重，b为“偏差”。这意味着我们将通过w*x + b构造我们的最终值，其中x是输入。
w = tf.Variable([3], dtype=tf.float32)
b = tf.Variable([1], dtype=tf.float32)
x = tf.placeholder(dtype=tf.float32)
linear_model = w * x + b
现在，我们想知道我们的模型有多好。所以让我们将它与y进行比较，它是我们期望值的输入。我们取差，平方，然后用reduce_sum库函数得到我们的“损失”。损失衡量的是我们希望我们的模型代表的东西和它实际代表的东西之间的差异。
w = tf.Variable([3], dtype=tf.float32)
b = tf.Variable([1], dtype=tf.float32)
x = tf.placeholder(dtype=tf.float32)
linear_model = w * x + b
y = tf.placeholder(dtype=tf.float32)
squared_deltas = tf.square(linear_model - y)
loss = tf.reduce_sum(squared_deltas)
这里的每条线都是一个不同的张量，或者是我们图形中的一个新节点。我们将通过使用学习率为 0.01 的内置GradientDescentOptimizer来完成我们的模型。我们将把我们的训练步骤设定为试图最小化损失函数。
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
现在我们将运行会话，初始化变量，并运行我们的训练步骤 1000 次。我们将传递一系列输入及其预期输出。我们来试着学一下台词y = 5x - 1。我们的预期产出y值将假设这一点。
sess = tf.Session()
init = tf.global_variables_initializer()
sess.run(init)
for i in range(1000):
sess.run(train, {x: [1, 2, 3, 4], y: [4,9,14,19]})print(sess.run([W,b]))
最后，我们打印出权重和偏差，并看到我们的结果！
[array([ 4.99999475], dtype=float32), array([-0.99998516], dtype=float32)]
所以我们可以看到我们学习到的值非常接近正确值 5 和-1！
用 Haskell 表示张量
最后，我将详细介绍如何在 Haskell 中应用这些张量概念。像字符串和数字一样，我们不能在 Haskell 中有这种“张量”类型，因为这种类型可能真的代表一些非常不同的概念。为了更深入地了解我们正在处理的张量类型，请查看我们的深度指南中的。
同时，让我们看一些简单的代码片段，复制我们在 Python 中的工作。下面是我们如何制作几个常数，并把它们加在一起。请注意“重载列表”扩展。它允许我们用和列表一样的语法来表示不同的类型。我们将此用于Shape物品和Vectors:
{-# LANGUAGE OverloadedLists #-}import Data.Vector (Vector)
import TensorFlow.Ops (constant, add)
import TensorFlow.Session (runSession, run)runSimple :: IO (Vector Float)
runSimple = runSession $ do
let node1 = constant [1] [3 :: Float]
let node2 = constant [1] [4 :: Float]
let additionNode = node1 `add` node2
run additionNodemain :: IO ()
main = do
result <- runSimple
print result{-
Output:
[7.0]
-}
我们使用constant函数，它接受一个Shape然后是我们想要的值。我们将创建我们的加法节点，然后run它得到输出，这是一个带有单个浮点数的向量。我们将一切都包装在runSession函数中。这封装了我们在 Python 中看到的初始化和运行动作。
现在假设我们想要占位符。这在 Haskell 中稍微复杂一点。我们将使用两个占位符，就像在 Python 中一样。我们将用placeholder函数和一个形状来初始化它们。我们将为函数的输入值提供参数。要真正传递参数来填充占位符，我们必须使用我们称之为“提要”的东西。
我们知道我们的adderNode取决于两个值。所以我们将把 run-step 写成一个函数，它接受两个“feed”值，每个占位符一个。然后我们将使用feed函数将这些提要分配给适当的节点。我们将把这些放在一个列表中，并将该列表作为参数传递给runWithFeeds。然后，我们通过对输入数据调用 run-step 来结束。我们将不得不encode原始向量作为张量。
import TensorFlow.Core (Tensor, Value, feed, encodeTensorData)
import TensorFlow.Ops (constant, add, placeholder)
import TensorFlow.Session (runSession, run, runWithFeeds)import Data.Vector (Vector)runPlaceholder :: Vector Float -> Vector Float -> IO (Vector Float)
runPlaceholder input1 input2 = runSession $ do
(node1 :: Tensor Value Float) <- placeholder [1]
(node2 :: Tensor Value Float) <- placeholder [1]
let adderNode = node1 `add` node2
let runStep = \node1Feed node2Feed -> runWithFeeds
[ feed node1 node1Feed
, feed node2 node2Feed
]
adderNode
runStep (encodeTensorData [1] input1) (encodeTensorData [1] input2)main :: IO ()
main = do
result1 <- runPlaceholder [3.0] [4.5]
result2 <- runPlaceholder [2.7] [8.9]
print result1
print result2{-
Output:
[7.5]
[11.599999] -- Yay rounding issues!
-}
现在，我们将通过我们已经在 Python 中看到的简单线性模型场景来总结。我们再一次将两个向量作为输入。这些将是我们试图匹配的价值观。接下来，我们将使用initializedVariable函数来获取我们的变量。我们不需要调用全局变量初始化器。但是这确实会影响会话的状态。注意，我们将它从 monad 上下文中提取出来，而不是使用 let。(占位符也是如此。)
import TensorFlow.Core (Tensor, Value, feed, encodeTensorData, Scalar(..))
import TensorFlow.Ops (constant, add, placeholder, sub, reduceSum, mul)
import TensorFlow.GenOps.Core (square)
import TensorFlow.Variable (readValue, initializedVariable, Variable)
import TensorFlow.Session (runSession, run, runWithFeeds)
import TensorFlow.Minimize (gradientDescent, minimizeWith)import Control.Monad (replicateM_)
import qualified Data.Vector as Vector
import Data.Vector (Vector)runVariable :: Vector Float -> Vector Float -> IO (Float, Float)
runVariable xInput yInput = runSession $ do
let xSize = fromIntegral $ Vector.length xInput
let ySize = fromIntegral $ Vector.length yInput
(w :: Variable Float) <- initializedVariable 3
(b :: Variable Float) <- initializedVariable 1
…
接下来，我们将制作占位符和线性模型。然后我们用和之前差不多的方法计算损失函数。然后，我们将使用相同的提要技巧来插入占位符。
runVariable :: Vector Float -> Vector Float -> IO (Float, Float)
...
(x :: Tensor Value Float) <- placeholder [xSize]
let linear_model = ((readValue w) `mul` x) `add` (readValue b)
(y :: Tensor Value Float) <- placeholder [ySize]
let square_deltas = square (linear_model `sub` y)
let loss = reduceSum square_deltas
trainStep <- minimizeWith (gradientDescent 0.01) loss [w,b]
let trainWithFeeds = \xF yF -> runWithFeeds
[ feed x xF
, feed y yF
]
trainStep
…
最后，我们将对输入数据运行 1000 次训练步骤。然后，我们将再次运行我们的模型，以提取权重和偏差的值。那我们就完了！
runVariable :: Vector Float -> Vector Float -> IO (Float, Float)
...
replicateM_ 1000
(trainWithFeeds (encodeTensorData [xSize] xInput) (encodeTensorData [ySize] yInput))
(Scalar w_learned, Scalar b_learned) <- run (readValue w, readValue b)
return (w_learned, b_learned)main :: IO ()
main = do
results <- runVariable [1.0, 2.0, 3.0, 4.0] [4.0, 9.0, 14.0, 19.0]
print results{-
Output:
(4.9999948,-0.99998516)
-}
结论
希望这篇文章让你对 Haskell 中张量流的一些可能性有所了解。我们看到了张量流基础的快速介绍。我们看到了三种不同的张量。然后我们看到了 Python 和 Haskell 中的代码示例。最后，我们看了一个简单线性模型的快速示例，并了解了如何学习适合该模型的值。下周，我们将做一道更复杂的学习题。我们将使用经典的“Iris”花卉数据集，并使用全神经网络训练分类器。
如果你想了解更多细节，你应该查看免费的哈斯克尔张量流指南。它将引导您使用张量流库作为依赖项，并运行一个基本模型！
也许你对 Haskell 完全陌生，但对使用它进行机器学习或其他任何事情的可能性很感兴趣。您应该下载我们的入门清单！它有一些关于安装 Haskell 和学习核心概念的很好的资源。
开始在 PySpark 中开发，Jupyter 安装在一个大数据集群中
众所周知，像 Jupyter、 Apache Zeppelin 或最近推出的云数据实验室和 Jupyter 实验室这样的数据科学工具对于日常工作来说是必不可少的，那么如何将轻松开发模型的能力与大数据集群的计算能力结合起来呢？在本文中，我将分享在 GCP 的一个数据处理集群中开始使用 PySpark 的 Jupyter 笔记本的简单步骤。
Final goal
先决条件
1.拥有一个谷歌云账户(只需登录你的 Gmail，就能自动获得一年 300 美元的信用额度)[1]
2.用您喜欢的名称创建一个新项目
步骤
- 为了使部署更容易，我将使用一个测试功能，它只能在通过 Google Cloud Shell 创建数据处理集群时应用。对于我们的集群，我们需要定义许多特性，比如工作人员的数量、master 的高可用性、RAM 和硬盘驱动器的数量等。为了简单起见，我建议通过 UI 模拟集群的创建。首先我们需要启用 Dataproc(图 1 和图 2)。
Figure 1 Enable Dataproc API I
Figure 2 Enable Dataproc API II
2.使用您自己的集群大小获得模拟创建过程的等效命令行。我将设定基本规格:
- 区域:全球
- 集群模式:标准
- 主节点:2 个 vCPUs、7.5GB 内存和 300 磁盘大小
- 工作节点:2 个 CPU、7.5GB 内存和 200 个磁盘大小
Simulate creating a cluster through UI
Basic specs
重要提示:您应该点击高级选项，将图像更改为 1.3 Debian 9，以使 beta 参数生效。
To access click Advance options
Change to 1.3 Debian 9
3.获取等效命令行
Click in command line
Copy the gcloud command
4.关闭模拟并单击以激活云壳
Activate Cloud Shell
5.修改您的命令添加并运行(可能需要几分钟)
--optional-components=ANACONDA,JUPYTER
变化
g cloud data proc星团至 gcloud beta dataproc 星团
奔跑
- 重要信息更改项目 id ctic-227716，在控制台中用黄色书写的名称，同时将 cluster-ctic 重命名为您喜欢的名称(记住使用小写)
gcloud beta dataproc clusters create cluster-ctic --subnet default --zone us-west1-a --master-machine-type n1-standard-2 --master-boot-disk-size 300 --num-workers 2 --worker-machine-type n1-standard-2 --worker-boot-disk-size 200 --optional-components=ANACONDA,JUPYTER --image-version 1.3-deb9 --project ctic-227716
running in shell
cluster created
6.允许 Jupyter 端口的传入流量，在登录页面中搜索防火墙规则并创建一个规则。
search Firewall rules VPC network
click on create a rule
7.定义防火墙规则开放端口 8123 并保存。
parameters
Rule working
8.检查您的所有节点是否都允许 http 和 https 流量，并添加在每个节点中创建的防火墙标记。
9.输入您的 Jupyter 笔记本！(您需要您的主 IP 并添加 jupyter 默认端口，例如http://30.195 . XXX . xx:8123)
get master´s IP
10.让我们创建我们的第一个 Pyspark 笔记本
create the first Pyspark notebook
11.验证运行良好
奖励:检查火花 UI
- 要访问 Spark UI，您需要添加另一个防火墙规则，如步骤 7。打开端口 8088、4040、9870 和 4041。
Create Spark UI rule
- 点击我们第一个笔记本中的 Spark UI 链接，您将看到一个 ERR_NAME_NOT_RESOLVED 错误，只需将 URL 替换为主 IP 即可
例如http://3x . XXX . xx . x:8088/proxy/application _ 1542773664669 _ 0001
Spark UI
结论
在本文中，我尝试在 Data Proc 集群中部署 Jupyter，使得在真实集群中使用 PySpark 更加方便。如果您对下一篇文章有任何问题或建议，请随意。
下一篇文章再见！快乐学习！
PS 如果你有任何问题，或者想要澄清一些事情，你可以在 Twitter 和 LinkedIn 上找到我。如果你想了解 Apache Arrow 和 Apache Spark，我有一篇文章用一些例子温和地介绍了 Apache Arrow 与 Apache Spark 和 Pandas 此外，今年还出版了一本了解 Apache Spark、Spark 的最佳书籍:权威指南
州政府关于鸦片滥用治疗的政策可能会驱使人们使用谷歌购物:一个数据可视化。
当人们需要某样东西而又很难得到它时，他们通常会在网上寻找愿意卖给他们的人。这不仅适用于收藏品、不寻常的配方成分和廉价的教科书，也适用于处方药。
用于治疗阿片成瘾或滥用的两种主要药物是美沙酮和丁丙诺啡。丁丙诺啡与纳洛酮混合，通常被称为 Suboxone。这些药物抑制了渴望和戒断症状，使人们在接受治疗的同时更好地发挥作用。美沙酮治疗需要患者每天到特定的配药地点领取药物，这对许多人来说是一种负担。相比之下，Suboxone 可以在药店买到，每月一次。作为一种仿制药，它有望使更多的鸦片上瘾者和滥用者得到成功的治疗。
但是由于多种原因，患者很难得到 Suboxone 根据联邦法律，它只能由经过专门认证培训的医生开出，而医生自己必须为此付费；各州只有少量医生持证；这些医生每年只能为 30、100 或 250 名患者开处方，这取决于他们的认证类型；一些获得认证的人可能会避免接受有需要的病人，因为他们可能是高维护费用的病人；病人排在注册医生的等候名单上是很常见的；一些州将 Medicaid 承保的治疗限制在 2 年或 3 年；一些保险政策，包括医疗补助或医疗保险(视州而定)，可能根本不涵盖 Suboxone。
因此，谷歌有一份关于“Suboxone”的谷歌购物搜索次数的记录。这可以按州进行细分，以获得搜索词“Suboxone”受欢迎程度的相对度量。
点击 此处 查看此图的互动版本…
Click here for an interactive version of this graph
你可能会认为，受阿片类药物流行影响最严重、过量致死率最高的州会有最多的关于 Suboxone 的谷歌购物搜索，可能是那些试图在没有处方的情况下购买 Suboxone 的人。这种趋势是存在的，但是有些州的搜索率比你预期的要高(用橙色突出显示)。有些州的搜索率比你预期的要低(用绿色突出显示)。死亡率根据各州年龄组比例的差异进行调整，因为一些死亡原因更可能影响特定年龄范围内的人。
由于 Suboxone 本身可能被吸毒者滥用或转移，试图避免得分之间的戒断症状，并不是所有谷歌购物搜索该药物的人都是积极试图恢复的人。纳洛酮成分被认为可以防止过量服用，但是丁丙诺啡成分确保了黑市的存在。
各州正在做什么与比预期更高或更低的次级搜索率相关联？一些因素包括州医疗补助扩展状况、州医疗补助对阿片类药物成瘾或滥用治疗的覆盖范围，以及州政府在认证医生开出 Suboxone 方面所做的努力。点击交互图左侧的按钮，查看哪些州在谷歌购物上的 Suboxone 搜索率高于或低于预期，以及州政府政策是如何相关的。我使用的是 2015 年的数据，因为这是我能够获得所有数据的最近一年。
点击 此处 查看此图的互动版本…
Click here for an interactive version of this graph
我们可以在谷歌购物搜索“Suboxone”上看到与这些因素相关的趋势。通过医疗补助政策或医学博士认证努力促进医生处方 Suboxone 使用的州，人们通过互联网寻找危险替代品的比率较低。不可能知道这些因素是否导致了搜索率的差异——我们只能观察一种趋势。这里还有许多其他因素没有涉及，比如 T2 限制阿片类止痛药处方的程度；针对毒品犯罪的州执法实践；和价格或街上是否有Suboxone。此外，一些因素也是相互关联的，例如一个州的医疗补助或医疗保险覆盖的子处方的百分比，以及该州是否参与了医疗补助的扩展。
鸦片成瘾治疗包括行为疗法、药物辅助治疗及其组合。关于每种治疗方法的疗效存在争议，此处不予讨论。美国医学协会、美国成瘾医学协会和世界卫生组织已经声明药物辅助治疗应该广泛可用。
感谢您的阅读。
我欢迎反馈——您可以“鼓掌”表示赞同，或者如果您有具体的回应或问题，请在此给我发消息。我也有兴趣听听你想在未来的帖子中涉及哪些主题。
阅读更多关于我的作品【jenny-listman.netlify.com】。欢迎随时通过 Twitter@ jblistman或LinkedIn联系我。
数据来源:
- 用药过量死亡率是按每 100，000 人中的死亡人数计算的年龄调整死亡率。在比较不同年龄分布的人口(如各州)时，按每个人口中年龄组的比例调整死亡率可以进行直接比较。如果某个特定的死亡原因更有可能影响某个年龄组的人，而某个州该年龄组的人口比例更高，那么在没有年龄调整的情况下，该原因导致的死亡率可能会被夸大。这些比率包括阿片类药物以外的药物过量。在某些情况下，死亡被报告为药物中毒，但不包含药物类型的信息。由于当地的报告惯例，阿片类药物报告的死亡人数在各州差异很大，但非阿片类药物中毒死亡的百分比在各州差异较小。在这项分析中，我使用了每 100，000 人中经年龄调整的药物中毒死亡率，包括没有特定药物的死亡。由于各州的用药过量死亡率和州的 Suboxone 搜索率被用作各州之间的相对衡量标准，这使得在面对不规则的药物类型报告做法时，可以进行合理的州与州之间的比较。用药过量死亡率的数据来自 2015 年，从 CDC 网站获得:https://www.cdc.gov/drugoverdose/data/statedeaths.html
- 按州和年份分列的有资格开 Suboxone 处方的医生人数和允许的病人人数的数据来自:https://www . Sam HSA . gov/medication-assisted-treatment/physician-program-data/certified-physicians
- 谷歌购物数据来自谷歌趋势:https://trends.google.com/trends/* * *谷歌趋势数据是符合趋势用户选择的搜索标准的所有谷歌搜索数据的随机子集。因此，使用相同搜索标准的 Google Trends 报告之间的结果略有不同。我正在开发一个 R 工具来最小化趋势报告中的偏差。
- 各州的 Suboxone 和阿片类药物处方数据以及 Medicaid Suboxone 和美沙酮覆盖政策来自 IMS 医疗保健信息学研究所的报告:阿片类药物康复治疗的使用:州级丁丙诺啡使用和支付类型的最新证据。https://www . IMS health . com/files/web/IMSH % 20 institute/Reports/health care % 20 briefs/IIHI _ Use _ of _ opoid _ Recovery _ drugs . pdf
- 2015 财年(截至 2016 年 1 月)医疗补助扩展州数据，来自凯泽家族基金会:http://www . kff . org/Medicaid/state-indicator/Medicaid-expansion-spending/？current time frame = 0&sort model = % 7B % 22 solid % 22:% 22 location % 22，%22sort%22:%22asc%22%7D
州
I don’t think he was quite as excited about this as I was.
我一直在思考我想写些什么。上一次我有机会以这种方式思考是在大约一年前，在来自默克公司的 grand incredible Priya Agrawal 的帮助下，我有机会向比尔和梅林达盖茨以及盖茨基金会的董事会介绍数字技术在全球卫生系统发展中的作用。
这是一次有趣的经历，它让我有机会以一种自 Wellframe 成立以来从未有过的方式整理思绪。还是在有孩子之前？
无论如何，我主要对两件事感兴趣
- 人类系统中存在的信息系统和激励网络。比我最初想象的更多的事情是信息处理任务。计算机不仅仅是一台机器，而是信息处理的隐喻。我有时甚至会说，计算机是自然存在的形式，但当我醒来时，我最终得出结论，计算机只是(几乎无处不在的)信息处理任务的最方便的隐喻。
- 如何使用计算机通过创造人机混合系统来改善物质事物的组织——人类和计算机一起工作来放大彼此。
多年来，我发现图灵机的简单模型是思考健康和社会其他系统的一种有趣方式。事实上，几年前我非常喜欢艾伦·图灵，以至于我想用他的名字给我们的第一个女儿取名，但是我找不到一个和他名字一样的女性衍生词。现在我重新认识了睡眠的全部好处，我们不太可能再要孩子了，但就我所见，这将是生男孩的主要好处。
卫生系统中的病人就像某种图灵机——每个人都经历一系列不同的状态，其中的转变就是卫生系统的行动。从这个角度来看，医院(或者可以说是任何医疗服务单位)在一般意义上从事信息处理和计算的业务，就像从事医疗服务一样。当然，我并不是说关心的因素不重要(我花了 10 年时间试图证明它们是重要的)，也不是说医学知识(这些隐喻程序中的真理)是完美的，但为了便于讨论，将这些东西抽象出来会更方便。
剩下的是两个核心计算任务:诊断(推理)和管理(基本上是带有一些推理的规则的应用，以使这一切不那么干净)。目前，诊断主要受到缺乏结构化数据的限制，这首先是一个传感问题，这实际上是基础科学领域的一个问题——在大多数情况下，我们需要更好的传感器来提供一些客观的可比性，否则就会受到人们如何使用语言描述发生在他们身上和他人身上的事情的变化的影响。有了大量的结构化数据(当然，现在也有结构化数据存在的领域)，诊断问题变成了一个非常有趣的推理问题，机器学习，特别是计算的认知方法的深刻飞跃可以发挥作用。
许多更有资格的人已经写了这方面的文章，所以没有必要贬低他们的基础工作。在没有结构化数据的情况下，人类在许多情况下实际上是最擅长诊断的，因为我们能够更有效地解释歧义，产生启发，并快速地以有时不明显的方式利用它们(我想是 House MD)。这些人看起来很像现在的临床医生，当然，尽管他们很有价值，但却难以培训，维护起来成本高昂，因此很难在需要他们的地方找到他们。随着更好的感知、学习和自我优化算法，很明显我们可以增加每个临床医生的杠杆作用，但这仍需要几年时间。
在未来的一篇文章中，在获得许可之前，我将写一写我的朋友 Sid 和 Michal 以及他们的公司，他们使用手机和微型化学技术，以现有成本的一小部分，将实验室测试带给各地的患者。他们目前正在通过 FDA 的许可，但最有趣的是，他们已经有数万家诊所在印度成功使用他们的测试——在剑桥和我们一起在麻省理工学院 CSAIL 的黑暗洞穴中开始之后。它有时被称为逆向创新，这是一个非常令人讨厌的术语，但稍后会有更多的介绍。
回到故事上来，我认为管理问题在短期内更容易解决。这在很大程度上是一个感知患者健康状态的问题(在随后的帖子中会详细介绍如何做到这一点)，并根据该健康状态确定最合适的干预措施，以使患者在通往理想健康状态的道路上达到下一个最佳健康状态——健康目标。同样，感知状态并基于该状态确定干预的能力在历史上一直是系统中的约束，但随着移动电话和云计算的出现，这些约束现在被有效地解除了。这是 Wellframe 运营的地方。
从管理问题来看，很明显，医学上并不缺乏规则，只是众所周知，它们没有得到应用，因为在资源、努力和直接不便方面的成本都非常高。我认为，通过使现有规则对患者来说更容易访问和用户友好，并利用这个机会使用生成的数据来定义至少对临床医生来说不明显的领域中的新规则，可以创造很多价值——即“体验”维度及其剪裁。
我认为，支撑这一切的是一种强制性的认识，即病人创造他们自己的“健康”,而我们只是为这种创造提供一些原材料和一些必要知识的供应商。考虑到这一点，我们采用了一种非常古怪的方式，这在任何其他制造流程中都是完全不可接受的，我们真的需要做得更好。我认为，如果我们围绕患者以这种方式重新构建任务，并意识到管理挑战是一种迭代的状态感知和转换，这是一项计算机非常擅长的任务，那么就可以节省更多的人类时间和精力，将它们花在人们真正擅长而计算机真正不擅长的事情上——让其他人感到被关心。
七年前，我非常幸运，在麻省理工学院和周围的一些不可思议的人一起工作了几年，他们仍然是我的朋友，他们向我介绍了这些想法，并从根本上改变了我的生活，或者至少改变了我对一个人的可能性的看法。
这个博客的目的是回到那种惊奇的感觉，并在我的才能和时间的限制下，传达它。我会试着在下面的帖子中包含更多的细节和具体的例子来进一步发展我的想法。
很多这样的想法都是着眼于长远，当然空白的事实是(至少现在是这样；)从长远来看，令人沮丧的是，我们都会死。遗憾的是，这比我想的要早得多，因为我那了不起的叔叔 Sithamparanathan Sivagnanam 最近去世了。他轻轻地踩在地上，把它变成了一个更好的地方。他是一个“做梦的傻瓜”,人类的所有进步都建立在这样的事情上。
作为纪念。
T
“统计学”成就了我的一天，是吗？
Bedtime Paradox cartoon
A 几乎所有的活动都必须与数据相关，数据可以通过多种不同的方式收集。自从 19 世纪初统计学被广泛使用和知晓以来，数据收集变得流行起来。由于统计数据的功能，它被用来使用有限的数据来解释一种现象，例如一个业务用例或者仅仅是一场赌博。它帮助了许多商人、经纪人、赌徒，尤其是现在的电子商务或科技公司，它们在短时间内产生许多数据。
由于对统计学家的高需求，许多人将他们的职业道路转变为能够做好统计的“数据向导”。目前，通过博客、文章或这里的“媒介”，甚至询问【大师】，就可以很容易地了解这些统计数据。每个人都可以使用它，每个人都可以教它，而且每个人都可能是错的，这就是问题所在。统计是一种工具，作为另一种有有限用途的工具，它也有许多假设和不同的解释。这里有一些在做统计分析时可以发现的悖论或谬误。
辛普森悖论
这个简单的统计数字不会伤害任何人，也不会让每个人都破产。然而，基于简单统计的错误输出的决策可能导致一个国家的毁灭。众所周知，统计学中的一个悖论会误导统计学家，这个悖论叫做辛普森悖论。
这是使用 A/B 测试的观察者或想要比较产品的研究者通常会遇到的矛盾。辛普森悖论是这样一种悖论，当不同组的数据被合并时，不同组中出现的趋势消失了，这是英国统计学家 Udny Yule 在 1903 年首次提到的。
Simple Simpson’s Paradox
这个悖论有很多不同的例子。在一个著名的例子中，研究人员得出结论，一种新的治疗肾结石的方法比传统手术更有效，但是后来发现这种新的治疗方法更常用于小肾结石。在研究人员根据肾结石的大小进行分割后，这一发现出现了。
此外，这在企业案例中也经常发生。例如，假设公司生产两种产品，并想知道哪一种是最好的。公司随机选择 200 个不同的好顾客作为样本来试用新产品，其中 100 个顾客试用产品 A，另外 100 个顾客得到产品 b。每个顾客必须给出对产品的意见，“喜欢还是不喜欢”。这是实验的结果，
Initial Result
很容易计算出，这些数据明显表明产品 A 比产品 b 更容易被客户接受。但是，如果公司知道并拥有关于性别的数据，并且研究人员将数据分为两种类型的客户，那么上面的报告将变为下表(具有相同的性别比例)。
Gender Centrist Result
简单的比例计算表明，只有对女性顾客来说，产品 B 比产品 A 更有利。
如果研究人员不在乎进行分割，上面的简单实验可能会导致错误的方向。为了防止这种情况发生，需要对每个调查进行适当的分组。然而，帕夫利德斯和帕尔曼的一篇论文证明了辛普森悖论发生的概率正好是 1/60。
啧啧嗖图
一幅画，总的来说，可以操纵任何观众，这幅画有许多不同的解读。因此，任何人创建的表格中的简单图表都可能改变研究人员甚至领导的决定。操纵数据解释视角的方法之一是 Gee Whiz 图。
那是什么？请注意下面的图表。
Famous Example of Gee Whiz Graph
左边的图表显示了“政府支出”的显著增长。1937 年 10 月以后，显示这一点的报纸似乎终究是反对政府的。同时，对于相同的数据，右边的线在同一个月之后没有显示出显著的差异。如果两个人一眼看到这些图表，他们可能会有不同的观点。
选择阿尔法
“用α0.05，假设检验表明..” 这句话通常写在研究论文或很多统计学教材上，问题是假设检验是否应该用 alpha 等于 0.05？。使用 0.05 作为显著性水平(α)似乎是不可否认的，并成为每个假设检验的强制性要求。然而，假设检验或统计显著性检验通常具有显著性水平。
假设检验中的显著性水平或通常写为 Alpha 是当假设检验或统计检验中的零假设为真时拒绝零假设的概率(假阳性的概率)。这意味着阿尔法值越小，拒绝真零假设的可能性就越小。它被用作确定是否拒绝零假设的基准。由于它的作用，α的值应该取决于情况和要处理的问题。如果研究者有兴趣拒绝一个真正的零假设，那么他可以使用一个更大的α，反之亦然。
Z-value of Alpha
尽管α值允许使用 0 到 1 之间的所有实数，但从理论上讲，用于统计测试是不实际的。通常，α的值是 0.01、0.05 或 0.1，即使没有数学定理表明这些是唯一可以使用的显著水平。因此，有必要为每一个显著性检验提供α值，并且每次阅读统计研究时都要小心。
伯克森悖论
这个悖论也被称为伯克森偏差或伯克森谬误，非常接近辛普森悖论。伯克森悖论是一种情况，其中两个指标在统计上可能是负相关的，即使它们在总体中似乎是正相关的，甚至是不相关的。
这种情况可能是由于观察者在收集数据时的选择偏差造成的。在这个悖论中，观察被限制在两个变量相加的地方。因为如果你知道 A+B 一定在某个范围内，那么 A 高导致 B 低，反之亦然。
例如，假设观察者想要分析订单值(OV)和某个电子商务上 VIP 客户的订单数量(N)之间的相关性。在本研究中，VIP 客户被定义为具有总标准化 OV 且标准化 N 高于某个基准 B_max 的客户。总体人口分布大致如下图所示，
Berkson’s Example
绿点(数据选择)在这些指标之间会有明显的负相关，因为在开始时有偏差选择。标准是“标准化 OV”+“标准化 N”≤B _ max，当 OV 较低时给出信息，则 N 的值由于其限制而必须较高。
上面的例子从一开始就有明显的错误，但是有一些情况很难被注意到有这种悖论，特别是在医学观察上，这种观察限制了获取样本的途径。另一个例子来自教育领域关于 GPA 和 SAT 成绩的相关性。
后特设谬误
Post Hoc 是“Post Hoc，Ergo Propter Hoc”的简称，意思是“在它之后，因此因为它”。这是一个逻辑谬误，认为第一个事件是紧随其后的第二个事件的原因。许多研究人员由于缺乏信息和经验而陷入这一悖论。此外，这是一个懒惰的答案，为研究者创造一个报告的研究结论。
Domino’s Cause and Effect
举一个我们熟悉的医学领域疾病及其治疗的例子。比方说，一个病人病了几天，然后他买了一种药来治疗，这种药能使他立即好转。之后，病人得出结论，由于药物的作用，疾病已经消失。然后，他会买同样的药，或者建议人们如果疾病感染了他们就买这种药。
并不是每一个事后谬误都会像上面的例子一样带来好的结果，大多数都不会有好的结局。例如，社交媒体、恶作剧和仇恨言论大多使用这种逻辑谬误来传播仇恨，从而在现实世界中制造冲突和混乱。这种现象通常发生在总统竞选期间，在社会中引发不同的群体。
在统计学中，这种谬误不是由错误的公式或公式的错误使用引起的，而是发生在观察者产生结果的方式上。这确实与观点偏见和观察者的经验有关。作为一名统计学家或数据分析人员，有多种统计测试来确定两组或多组数据的事后效应，如霍尔姆-邦费罗尼方法、图基检验或邓尼特校正。
结束注释
从数据中获得洞察力离不开统计，如果偏见(或个人观点)仍然存在，统计就无法给出最佳结果。如果观察者或“统计学家”不能理解公式中变量的含义，这也是一个自食其果的工具。不仅在使用统计数据时，而且观察者也必须注意在从公式中获得所有数字后再陈述结论。
巴塞罗那 Airbnb 市场的统计概览
本文对巴塞罗那的 Airbnb 经济进行了探索性的数据分析。Airbnb 在巴塞罗那非常受欢迎，与大型酒店行业平行。福布斯提到巴塞罗那是继巴黎和伦敦之后欧洲第三大 Airbnb 租赁城市，也是世界第六大。巴塞罗那的 Airbnb 活动也成为了针对使用该平台的东道主的政治和法律诉讼的对象。这座城市正在采取行动，从这个平台上移除数以千计没有旅游许可证和被关闭的房产。根据现有数据，Airbnb 在巴塞罗那的使用量每年都在增加，越来越多的主机在该平台上建立房源。
Airbnb 数据源
Airbnb 不共享原始数据，但是使用 Airbnb 内部的可以获得一些数据，这使得可以通过使用 Airbnb 网站上公开的信息来访问 Airbnb 数据。该数据是从 2018 年 2 月 7 日开始的可搜索列表的快照。这些数据包括:
- 未来可用日期的日期和价格
- 可搜索列表的评论
- 位置和列表元数据
探索性数据分析
我们可以预计，在一个需求如此之高的城市，大多数主持人将是“专业主持人”，他们出租完整的公寓或私人房间，并持有多个房源，以实现净利润的最大化，但数据告诉我们的情况不同。我们可以看到，大约 70%的活跃列表主机持有单一列表。这可能是市政厅关闭非许可房源的行动以及 Airbnb 自己制定的“一个主机一个家”政策的结果，该政策限制市中心的非旅游许可房源的每个主机只能有一个房源。
*如果在未来一年中有 1 到 364 个可用日期，并且在过去 8 个月中至少收到 1 次审核，则该列表被视为有效。
假设大多数房源是非专业的，我们可以预计最受欢迎的房源类型将是私人和共享房间，允许主人继续住在自己的家里。实际上，私人房间平均分布在整个公寓中。这表明了两种情况——主人住在他们的日常公寓里，并列出另一个完整的公寓，这是一年的 Airbnb 清单，或者整个公寓的收入足够高，以鼓励主人搬出去过夜。
季节性需求
我们可以通过查看给定评论的数量来估计预订量。Airbnb 内部已经估计审核率为大约 50% ，与 Airbnb 官方文件中的统计数据相比，该审核率也符合下图。
审查显示，从 2016 年到 2017 年，被审查的上市公司数量每年增长 40%。
需求也有月度季节性，在 8 月份达到需求高峰，在新年达到另一个较短的高峰。我们可以看到可用房源的价格是如何相互关联并适应假日需求的。
看到这些数据可以解释主人合租甚至搬出公寓的意愿。市中心一居室的平均租金可以达到每月 800€，日租金 32 美元。同样的公寓可以在 8 月份以 140 美元的价格在 Airbnb 上挂牌，即使扣除平台和清洁费，这对公寓租户来说也是一笔非常好的节省。将 8 月份 140 美元的平均挂牌价格与巴塞罗那酒店212 美元的平均每日房价进行比较，可以看出主人和客人都觉得 Airbnb 很划算。
专业主持
有多少专业 Airbnb 房源在巴塞罗那运营，这是 Airbnb 活动和这座城市之间的一个主要争议问题。全职主持人将努力最大化客人占用列表的时间，并最小化拜访方之间的时间。
可以使用审核日期来估计预订之间的平均时间。下图告诉我们，一个仅被审核 10 次的列表可以被认为是一个临时的-非专业的列表，预订间隔为 10 天(基于 50%的审核率)。
根据 Airbnb 的报告，每位客人的平均入住时间为 4.3 晚。这一措施被添加为橙色虚线。为了让列表每天晚上都工作，列表需要接收至少 90 个预订。
Airbnb 将每年预订超过 120 天的房源视为专业房源。我们将在这部分分析中使用相同的阈值。
根据预计预订量绘制的列表分布图显示，在 4320 个列表中，约 32%的列表可以根据 120 天标准被视为专业列表。
当比较 Airbnb 的 4320 个专业列表和该市酒店的 75000 个床位时，我们可以得出结论，这些列表只代表了巴塞罗那旅游专用住宿的 5%。
列表邻域分布
巴塞罗那 160 万人口居住在该市的 10 个街区。这座城市每年接待 3200 万游客，其中大约一半是一日游游客。让我们看看 Airbnb 是如何在邻里层面上影响这座城市的。对于这一部分，我们使用了 Tableau 10.2 GeoJSON 导入功能。
Ciutat Vella 和 Eixample 的市中心社区是最活跃的 Airbnb 社区，实际上，当查看特定区域时，reta de l'Eixample、Raval 和 Barri Gòtic 占据了整个城市 Airbnb 活动的 27%。
巴塞罗那只有市中心主机享受 Airbnb 的人气吗？似乎不是。我们可以注意到，列表和评论都分布在城市的不同区域，而大约 30%的列表和评论发生在三个中心社区之外。
Airbnb 是否占用了特定街区的居住空间？
回答这个问题的正确方法是计算每个街区使用 Airbnb 的家庭百分比，特别是专业房源。我们将通过使用按地区划分的人口数据来估计家庭数量，并假设每套公寓有 2 个人。
Ciutat Vella 街区是巴塞罗那最具影响力的街区，然而，只有 1.9%的公寓是真正的专业房源，其余 3.3%的公寓是临时 Airbnb 房源。Airbnb 正在吸引更多游客进入已经拥挤的市中心，但可能会减少对当地住宅公寓费用的考虑。
结论
Airbnb 在一个受政治、法规、季节性、文化和经济影响的动态市场中运营。巴塞罗那是一个美丽的旅游胜地，这使得 Airbnb 成为一种流行的创收方式，不仅在特定地区是专业的，而且在所有社区都是如此。大多数主机以一种随意的方式使用 Airbnb，通常只有一个列表，大约 30%的主机会管理多个列表。只要 Airbnb 提供比酒店更友好的预算选择，并为主机提供有意义的收入，我们可能会继续看到市场在当局监管主机的压力下增长。
解释统计显著性
用数据证明一件事是什么意思？
作为一所重点大学的院长，你收到一份令人担忧的报告，报告显示你的学生每晚平均睡眠时间为 6.80 小时，而全国大学的平均睡眠时间为 7.02 小时。学生会主席担心学生的健康，并指出这项研究证明家庭作业必须减少。另一方面，大学校长对这项研究不屑一顾，称其为无稽之谈:“在我年轻的时候，我们每晚能睡四个小时，就已经很幸运了。”你必须决定这是否是一个严重的问题。幸运的是，你精通统计学，并最终看到了一个运用你所受教育的机会！
How can we decide if this is meaningful?
统计显著性是我们经常听到但没有真正理解的术语之一。当有人声称数据证明了他们的观点时，我们点头接受，假设统计学家做了复杂的运算，得出了不容置疑的结果。事实上，统计显著性不是一个需要多年学习才能掌握的复杂现象，而是一个每个人都可以——也应该——理解的简单概念。像大多数技术概念一样，统计学意义建立在一些简单的概念上:假设检验、正态分布和 p 值。在本文中，我们将简要地触及所有这些概念(提供了更多的资源),以解决上面提出的难题。
作者注:这篇文章的早期版本过于简化了 p 值的定义。我要感谢教授蒂莫西·贝茨纠正了我的错误。这是在线协作学习的一个很好的例子，我鼓励任何反馈、纠正或讨论！
我们要讨论的第一个想法是假设检验，一种使用数据评估理论的技术。“假设”是指研究者在研究之前对情境的最初信念。这个最初的理论被称为 替代假设，相反的被称为无效假设。在我们的示例中，这些是:
- 替代假设:我们大学学生的平均睡眠时间低于全国大学生平均水平。
- 零假设:我们大学学生的平均睡眠时间不低于全国大学生平均水平。
请注意，我们必须小心措辞:我们正在寻找一个非常具体的效果，这需要在假设中形式化，因此在事实发生后，我们不能声称已经测试了其他东西！(这是一个单边假设检验的例子，因为我们只关心一个方向的变化。假设检验是统计学的基础之一，用于评估大多数研究的结果。这些研究可以是从评估药物有效性的医学试验到评估锻炼计划的观察性研究。所有的研究都有一个共同点，那就是它们都关注于进行比较，要么在两组之间进行比较，要么在一组和整个人群之间进行比较。在医学的例子中，我们可能会比较服用两种不同药物的两组之间的平均康复时间，或者，在我们作为院长的问题中，我们希望比较我们的学生和全国所有学生之间的睡眠。
假设检验的测试部分允许我们决定哪一个理论，无效的或替代的，更好地被证据支持。假设检验有很多种，我们将使用一种叫做 z 检验的方法。然而，在我们开始测试我们的数据之前，我们需要谈论两个更重要的想法。
具有统计意义的第二个构件是正态分布，也称为高斯曲线或钟形曲线。正态分布用于表示来自过程的数据是如何分布的，并且由给定希腊字母μ (mu)的平均值和给定字母σ (sigma)的标准偏差来定义。平均值表示数据中心的位置，标准偏差表示数据的分布。
Normal Distribution with mean μ and standard deviation σ
正态分布的应用来自根据标准偏差评估数据点。我们可以根据一个数据点相对于平均值的标准偏差来确定它的异常程度。正态分布具有以下有用的特性:
- 68%的数据在平均值的 1 个标准偏差范围内
- 95%的数据在平均值的 2 个标准偏差范围内
- 99.7%的数据在平均值的 3 个标准偏差之内
如果我们有一个正态分布的统计数据，我们可以用均值的标准差来描述任何一点。例如，美国女性的平均身高为 65 英寸(5 英尺 5 英寸)，标准差为 4 英寸。如果我们遇到一个 73 英寸高的新朋友，我们可以说她比平均值高两个标准差，是女性中最高的 2.5%。(2.5%的女性比μ-2σ(57 英寸)矮，2.5%的女性比μ+2σ高)。
在统计学中，我们不是说我们的数据是平均值的两个标准差，而是根据 z 分数来评估它，z 分数只是代表一个点与平均值的标准差的数量。通过从数据点中减去分布的平均值并除以标准偏差，可以转换为 z 得分。在身高示例中，您可以检查我们的朋友的 z 值是否为 2。如果我们对所有数据点都这样做，新的分布称为标准正态分布，平均值为 0，标准差为 1，如下所示。
Transformation from normal (right) to standard normal distribution (left). (Source)
每次我们做假设检验时，我们都需要假设检验统计量的分布，在我们的例子中，检验统计量是学生的平均睡眠时间。对于 z 检验，正态曲线用作检验统计分布的近似值。一般来说，根据中心极限定理，当我们从一个数据分布中取更多的平均值时，平均值将趋向于正态分布。然而，这将始终是一个估计值，因为真实世界的数据永远不会完全遵循正态分布。假设正态分布让我们决定我们在研究中观察到的结果有多大意义。z 值越高或越低，结果越不可能是偶然发生的，结果越有可能是有意义的。为了量化结果的意义，我们使用了另一个概念。
最后一个核心思想是 p 值。一个 p 值是当零假设为真时，观察结果至少与测量结果一样极端的概率。这看起来有点复杂，所以让我们看一个例子。
假设我们正在测量美国佛罗里达州和华盛顿州的平均智商。我们的零假设是华盛顿的平均智商并不比佛罗里达的平均智商高。我们进行了研究，发现华盛顿的智商高出 2.2 点，p 值为 0.346。这意味着，在一个零假设——华盛顿的平均智商不高于佛罗里达州的平均智商——为真的世界里，我们有 34.6%的机会测量华盛顿的智商至少高出 2.2 分。因此，如果华盛顿的智商实际上没有高，我们仍然会测量出他们比高至少 2.2 个点，大约 1/3 的时间是由于随机噪声。随后，p 值越低，结果越有意义，因为它不太可能是由噪声引起的。
结果能否被称为具有统计显著性，取决于我们在开始实验之前 为显著性确定的 p 值(称为α)。如果观察到的 p 值小于α，则结果具有统计学意义。我们需要在实验之前选择α，因为如果我们等到实验之后，我们可以选择一个数字来证明我们的结果是显著的，不管数据显示什么！
Choosing a p-value after the study in one good way to “Lie with Statistics”
α的选择取决于情况和研究领域，但最常用的值是 0.05，相当于随机出现结果的概率为 5%。在我的实验室中，我看到常用的值从 0.1 到 0.001。作为一个极端的例子，发现希格斯玻色子粒子的物理学家使用 0.0000003 的 p 值，或 350 万分之一的发现概率是因为噪音。(统计学家不愿意承认 0.05 的 p 值是任意的。现代统计学之父 R.A. Fischer 出于不确定的原因选择了 0.05 的 p 值，并坚持了下来！
要从正态分布的 z 值获得 p 值，我们可以使用表格或 r 等统计软件。结果将显示 z 值低于计算值的概率。例如，z 值为 2，p 值为 0.977，这意味着我们随机观察到 z 值大于 2 的概率只有 2.3%。
The percentage of the distribution below a z-score of 2 is 97.7%
到目前为止，我们总结了三个想法:
- 假设检验:一种用来检验理论的技术
- 正态分布:假设检验中数据的近似表示。
- p 值:如果零假设为真，则出现至少与观察到的结果一样极端的结果的概率。
现在，让我们把例子中的各个部分放在一起。以下是基本情况:
- 根据国家睡眠基金会的数据，全国学生平均每晚睡眠时间为 7.02 小时
- 在对我们大学 202 名学生的调查中，平均每晚睡眠时间为 6.90 小时，标准差为 0.84 小时。
- 我们的另一个假设是，我们大学学生的平均睡眠时间低于全国大学生的平均水平。
- 我们将使用α值 0.05，这意味着如果 p 值低于 0.05，结果是显著的。
首先，我们需要将我们的测量值转换成 z 值，或者说它偏离平均值的标准偏差数。我们通过从测量值中减去总体平均值(全国平均值)并除以样本数量平方根的标准偏差来计算。(随着样本数量的增加，标准偏差和变异减少。我们通过将标准偏差除以样本数量的平方根来说明这一点。)
Conversion to z-score
z 分数被称为我们的检验统计量。一旦我们有了一个检验统计量，我们就可以使用一个表格或一种编程语言(如 R)来计算 p 值。我在这里使用代码不是为了恐吓，而是为了展示用免费工具实现我们的解决方案是多么容易！(#是注释，粗体是输出)
# Calculate the results
z_score = (6.90 - 7.02) / (0.84 / sqrt(202))
p_value = pnorm(z_score)# Print our results
sprintf('The p-value is %0:5f for a z-score of %0.5f.', p_value, z_score)**"The p-value is 0.02116 for a z-score of -2.03038."**
基于 p 值 0.02116，我们可以拒绝零假设。统计学家喜欢我们说拒绝零，而不是接受替代。有统计上显著的证据表明，在 0.05 的显著性水平上，我们的学生比美国的大学生平均睡眠时间少。p 值显示我们的结果有 2.12%的可能性是由随机噪声引起的。在这场总统之战中，这个学生是对的。
在我们禁止所有作业之前，我们需要注意不要对这个结果赋予太多。请注意，如果我们使用阈值 0.01，那么我们的 p 值 0.02116 并不显著。有人想证明我们研究中的相反观点，可以简单地操纵 p 值。每当我们检查一项研究时，除了结论之外，我们还应该考虑 p 值和样本量。由于样本量相对较小，只有 202 人，我们的研究可能具有统计意义，但这确实意味着它具有实际意义。此外，这是一项观察性研究，这意味着只有证据表明的相关性，而不是因果关系。我们发现在我们学校的学生和较少的平均睡眠之间有一种相关性，但不是说去我们学校会导致睡眠减少。可能有其他因素影响睡眠，只有一项随机对照研究能够证明因果关系。
与大多数技术概念一样，统计意义并不复杂，只是许多小概念的组合。大部分的麻烦来自于学习词汇！一旦你把这些碎片放在一起，你就可以开始应用这些统计概念了。当你学会了统计学的基础知识，你就能更好地以健康的怀疑态度看待研究和新闻。你可以看到数据实际上在说什么，而不是别人告诉你它意味着什么。对付不诚实的政客和公司的最佳策略是一个持怀疑态度、受过良好教育的公众！
一如既往，我欢迎建设性的批评和反馈。可以在 Twitter @koehrsen_will 上找到我。
统计意义与实际意义
维基百科包含了一系列认知偏见。(有 170 左右)。心理学家经常进行实验来发现和理解这样的现象。通常，实验者会花很大力气来控制环境，以便唯一的真实变量是感兴趣的变量。显然，这是实验的目的，而且对于理解因果关系是极好的。另一方面，实验对于理解相对重要性并不是很好。
我的意思是，虽然你可能在实验室里发现一种因果效应，但这种效应在你的生活中可能并不十分重要。我来详细解释一下。
讲故事:一把双刃剑
学者和其他大多数人一样，喜欢好故事。研究报告通常围绕一个现象或问题展开。主持人用一个主要的冲突或挑战来设置情节:它可能是一个研究手段要解决的问题，一个要澄清的主题。然后，对研究进行解释，并提出解决冲突的方法。这使得演示更加有趣，并且易于理解。
研究报告中讲故事的优势和劣势是一样的:影响力。观众更关注，更享受体验，这些都是好事。另一方面，演讲的主题也似乎更重要。对于一些非常非常重要的话题来说，这可能是一件好事。对于认知偏差，我觉得不是那么好的事情。这可能是因为讲故事的方式让我们对这些偏见给予了过多的重视。
虽然我喜欢他的书，但马尔科姆·格拉德威尔提供了一个很好的例子。他编织精彩的故事，让人身临其境，增长见闻。的确，他是一个讲故事的大师。在我读完他的书(以及类似的书)后，我通常会对自己的发现感到兴奋。随着时间的推移，热情会消退，剩下的只是书中实用的智慧。我发现，那里的经常没有。没错，我从这些书中学到的大部分东西最终都没有什么实用价值。我很像一个人，兴奋地用新方法减肥，却在几个月后发现新方法有致命的缺点。
数量很重要
通常，当描述实验时(特别是在社会心理学中)，主要问题是因果关系。因果关系的标准标准包括“统计显著性”的概念。几乎在所有情况下，这都依赖于一种叫做假设检验的统计方法。如果你曾经处理过“零假设”和“替代假设”，这可能对你来说很熟悉我就不多讲技术细节了，关键是大部分研究都是用一个临界值来表示显著性(主要是 p>0.05)。
一旦某种效应越过了统计显著性的门槛，它就有了很大的可信度。通常它会停留在人们的大脑中(即使它不会转化为行为的改变)。但是，在现实生活中，清除统计门槛并没有多大意义。
记住，正如我提到的，实验是在严格控制的环境中进行的。目标是隔离一个效果，因此上下文被移除。但是把背景放回去，你会发现效果被它淹没了。这就是为什么数量很重要。特别是，相对于可能出现这种影响的常见环境的程度。
谁在乎呢。
你可能想知道我为什么花时间写这篇文章。这是一个合理的问题。主要是，我想帮助人们去除智力上的杂物。
我感觉被知识、建议、新闻和想法淹没了。随着互联网的发展，它给数十亿人的生活带来了新的信息和联系能力。与此同时，现在有一个巨大的负担，要从我们阅读和看到的东西中筛选出重要的东西。这可能很难。我希望为家务杂事提供一个工具:实际意义。
因为我们都喜欢简单的经验法则，所以我将提供一个统计经验法则的替代品，包括一个阈值。我姑且称之为贝尔法则对于现实意义来说，它是这样的:影响> 1 年。这个想法是，一个现象、效果、想法或策略，如果有人使用它，并持续感知一年以上的影响，它实际上是重要的。为什么是一年？我认为它足够长，足以建立一个真正强大的效果，但也足够短，它不是一个如此繁重的负担。当然，从理论上讲，理想的阈值是一个不确定持续时间的影响，但是基于这样一个阈值的经验法则是没有用的。
是的，我的门槛是随意的，但它很容易记住，而且它为思考实际意义提供了一个起点。
应用贝尔法则
如果我搜索我的记忆，一些非常重要的现象浮现在脑海中，通过贝尔法则。
- 确认偏差
- 收入与幸福曲线
- 马后炮偏差
- 损失厌恶与禀赋效应
- 体验与物质消费效应
可能有更多，但这些肯定通过了规则:影响> 1 年。
现在，让我强调一下，在实际意义上应用贝尔法则可以清理很多东西。我是一名博士生，读过大量流行的社会心理学书籍。我几乎每周都了解新的效果。我总共了解了数百种这样的效应，但在我看来，基本上只有 5 种是真正重要的。(讽刺的是，我这么做完全是后知后觉，所以第 3 条可能适用。😃
如果你坚持这篇文章，感谢阅读。我希望它能帮助你专注于重要的事情。
统计和概率复习
从 2020 年 6 月起，我将不再使用媒体发布新故事。想继续看我的文章请访问我的个人博客:https://val lant . in。
对于任何愿意从事机器学习工作的人来说，统计学基础是必备的。在这里，让我们讨论一下这一数学分支的一些基本概念，以及如何使用 Python 将它们应用于数据。
寻找中心
如果你想找到数据集中的地方，找到数据的中心是非常重要的。你可以用平均值、中间值或众数来计算。
平均值就是我们都知道的“平均值”。你把所有的数字相加，然后把结果除以数字的个数，就可以找到它。
用 Python 来做吧。假设您已经收集了一个城市中 10，000 套房屋的租赁价格，并且您想知道该城市的平均租赁价格。
Python 的库numpy提供了一种找到平均值的便捷方法。但是在跳到这个解决方案之前，让我们实现这个函数的版本，这样我们可以更好地理解平均值是如何计算的。然后，我将使用 numpy 的实现进行计算。
我们可以说，平均而言，房屋租金为 999 美元。但是如果我们在数据中加入 50 栋非常昂贵的房子会怎么样呢？假设这些房子的平均租赁价格为 10 万美元。我们的意思是什么？
我们的平均价格从 999 美元飙升至 1492 美元。在你看来，这个新的平均值代表现实吗？观察发现，只有 50 套房子能够拉动 1 万套房子的平均价格。事实上，平均值对异常值非常敏感。所以我们需要一个对此不太敏感的指标。
为此，我们有一个中位数，它是一个数字排序列表中的中间数字。
请注意，当我们的数据集中有异常值时，中位数更好地代表了数据中心点。所以，如果离群值对你很重要，就用平均值来计算中心点。如果你需要相反的，使用中间值。
但是，如果您想发现数据中最常见的值是什么呢？为此，我们可以使用模式。让我们创建一个新的数据集，包含 100，000 个年龄从 18 岁到 75 岁的人。我们来看看最常出现的值是多少。在我们的例子中，年龄是 34 岁，数据集上有 1835 个条目。
标准偏差和方差
这些度量告诉我们，考虑到中心点，数据是如何分散的。它们很重要，因为它们告诉我们数据是否或多或少远离平均值。
方差衡量数据相对于平均值的分布程度，而标准差是方差的平方根。
这些方法有助于发现异常值，异常值是指距离平均值太远的点，会改变我们对数据的看法和理解。以下是如何使用 Python 计算它们。
概率论
我用了一些来自 DataCamp 概率论 课程的例子。
概率是一种计算事件发生频率的数学方法。基本上，我们通过分析事件在过去发生的频率，使用概率来预测未来事件发生的可能性。
为了理解基本的概率概念，让我们以一副 52 张扑克牌为例。
但是首先，我们需要明白:
- 在概率方面，我们分析在相同条件下可以重复的事件。
- 试验是试图重现一个事件的行为，它会导致不同的结果。
- 所有可能结果的集合称为样本空间。
一个例子是扔硬币，期望正面朝上。我们通过尝试投掷硬币来计算正面朝上的概率。在这种情况下，我们有两种可能的结果:正面或反面。这是我们的样本空间。
单一事件的概率
这是计算概率最简单的方法。你只需将可能事件结果的数量除以样本空间。让我们回到卡片的例子。让我们计算一下在第一次尝试中从一副牌中拿到 a 的概率。因为我们有 4 张 a 和 52 张牌，所以概率是这样计算的:
组合和排列的概率
了解样本空间对于计算概率至关重要。但有时样本空间可能比我们之前看到的要大。想象一下，你必须在 0 和 9 之间选择一个数字。你有十分之一的可能性。
现在，想象一下，你必须在 0 和 9 之间选择一个数字四次(就像你必须选择一个 pin 来解锁你的电话)，并且你不能重复这些数字。在这种情况下，你有 10、9、8 和 7 种可能性。在这种情况下，我们说我们正在做一个排列。
注意，当我们谈论排列时，我们谈论两件事:
- 我们可以选择的选项数量(数字 0 到 9)。
- 我们必须填充的位数(4，因为它是一个 4 位数的 pin)。
为了发现概率，我们必须用选项数量的阶乘除以选项数量和位置数量之间的阶乘差。
所以:
10P4 = 10! / (10-4)!
现在，假设你要计算口袋 a 的排列数，我们可以从中选择 2。全套 a 是 4。
4P2 = 4! / (4 — 2)!
组合
对于排列，顺序是一件重要的事情。想象一下 PIN 码的例子:如果你的 PIN 码是 1234，如果你输入 4321，显然是不行的。有了组合，我们就不再有顺序限制了。想象一下，你必须去买一些杂货。是买苹果香蕉葡萄还是葡萄苹果香蕉都不重要。结果会是一样的。
在组合中，我们也试图计算在一个有限的集合中某件事情发生的方式的数量。但是我们不在乎事情发生的顺序。让我们回到食品杂货的例子。假设现在冰箱上有 5 种不同的水果，你必须去掉 3 种。为了解决这个问题，您将计算排列并除以冗余(3 x 2 x 1)。
5C3 = (5! / (5-3)!) / 3!
或者只是:
5C3 = 5P3 / 3!
让我们使用带有 ace 的卡片例子用 Python 来写这些。我们想找到从一副 52 张牌中去掉两张 a 的组合可能性。
从属和独立事件
当一个事件不影响另一个事件的概率时，可以将其归类为独立事件。当你拿了 52 张牌，拿走一张王牌，然后把它放回去，洗牌并拿走另一张牌，我们有两个独立的事件，因为在这两个事件中拿走一张王牌的概率是相同的。
然而，如果你移除一张王牌，然后移除另一张牌，而没有将王牌放回，那么我们有依赖事件，因为在第二个事件中移除另一张王牌的概率与第一个事件不同。在第二个例子中，样本空间从 52 变为 51，ace 的数量从 4 减少到 3。
让我们用 Python 来看看这一切:
多个事件
从一副牌中取出 3 张红心牌而不替换的概率是多少？要计算这一点，您需要确定事件的数量(3)，然后计算每个事件分别发生的概率。然后，你乘以概率。在我们的例子中，我们有一个 AND 概率(去除心脏和心脏和心脏)。所以:
互斥事件
有时候，两件事不可能同时发生。在这种情况下，我们必须计算多个互斥事件中任何一个的概率，并将它们相加。这是一个或概率(A 或 B 发生)。
假设我们想从 52 张牌中抽一张牌，但第一张牌必须是一张红心或一张梅花。
数据分布
数据分布是一种可视化所有可能的数据值的方法，以查看它们出现的频率。假设我们有一个包含 10，000 个年龄的数据集。为了发现数据分布，让我们绘制一个直方图。
检查橙色线。它有高度和宽度。它也比偏向图表的一边更居中。通过观察这些特征，我们能够猜测可能的分布类型。因为有很多可能的发行版，所以在这里检查其中的一些:
周期为 2 π的 Dirac 梳虽然不是严格意义上的函数，但却是许多方向分布的极限形式。它…
en.wikipedia.org](https://en.wikipedia.org/wiki/List_of_probability_distributions)
百分位数
假设您的数据可以分成 4 个子集。总数据对应 100%，所以每个子集对应 25%的数据。百分位数的概念帮助我们确定数据的给定值落在哪里。关于上面的年龄例子，20 岁在哪里？
正如我们所见，20 岁属于第一百分位。由于我们有一个正态分布，我们的大部分数据落入第二和第三百分位数。
朋友圈
矩是概率密度函数形状的定量度量。事实上，它是帮助您更好地理解数据分布的度量集合。它们是:
- 平均值(一阶矩)。
- 方差(二阶矩)。
- 偏斜(三阶矩)。
- 峰度(或数据分布的形状)(四阶矩)。
让我们使用 Python 来计算这些值:
协方差和相关性
当数据集中的两个变量有某种关系时，就产生了相关性。协方差是衡量两个变量一起变化的程度。协方差的范围从-1 到 1，其中:
- -1 表示负面关系。
- 0 表示没有关系。
- 1 表示积极的关系。
在数据科学世界，你可能已经听过吃咸菜会死人的笑话。为什么？因为每个人…
www.linkedin.com](https://www.linkedin.com/pulse/correlation-causation-sharks-ice-creams-wilame-vallantin/)
让我们看一个 Python 上的相关性示例:
请注意，在第一张图中，数据非常分散。如果我们计算相关系数，我们可以看到它非常接近 0 (0.01)。
现在，跳到第二张图。注意我们可以在这里画一条线。还观察到系数现在更接近-1(-0.6)。
相关性是机器学习中一个非常重要的概念。它可以帮助我们在数据集上找到重要的数据关联。
5 分钟内为数据科学家提供统计数据
事实是顽固的东西，但统计数字是柔韧的。―马克·吐温
Photo by Mike Kononov on Unsplash
总体参数与样本统计
研究者的目标不是得出关于样本的结论，而是从提供的样本中得出关于总体的结论。因此，研究人员必须使用样本的统计数据来推断人口中的数值。总体中的这些值称为参数。参数是整个总体的未知特征，如总体均值和中位数。样本统计描述了作为样本的一部分人口的特征。样本均值和中位数是固定的和已知的。
抽样误差
假设，我有 3000 人去公园散步。我可以得到他们的平均体重和人口平均值，这是平均身高的精确表示。实际上，计算真实平均值并不是每次都可行。因此，我们将从 3000 总人口中抽取一部分，即 1000 人。如果样本是随机选择的，而不是观察到的，那么期望均值与真实均值相似。然而，由于它是一个随机样本，平均值可能与真实平均值不同。样本均值和真实均值之间的差异称为抽样误差。
标准误差
指的是所有均值的标准差。它显示了一组样本的平均值之间的差异。
假设，我们想观察 3 天内有多少销售额。通过计算每天的销售额，我们可以得到平均销售额。然而，有许多外部因素影响销售，如折扣、假期等。因此，我们不是取一天的平均值，而是取三天的平均值。
平均值的标准误差现在是指每次不同观察的平均值的变化。
如果我们测量一个数据集的多个样本，均值将不会相同，并且会扩散。样本的标准差是样本平均值的标准偏差，它为我们提供了一个衡量分布的标准。
置信区间和置信水平
“根据一项调查，在 96%的置信度下，果园中的橙子重量在(132-139 克)之间”。
(132–139 GM)是置信区间。这是一个真正的价值所在的价值范围。CI 用于表示我们确定总体参数所在的范围。每当我们想表达一个总体参数的估计时，最好是说明它的置信区间。CI 的宽度告诉我们许多关于从收集的样本中得到的总体的确定性。当你不太了解总体的行为时，你需要使用 t 分布来寻找置信区间。
96%的置信水平意味着，如果在相同的条件下一次又一次地重复调查或民意测验，调查的结果将在 96%的时间里与实际人口的结果相匹配。
影响置信区间(CI)的两个因素是变异和样本量:-
变异:如果总体中的所有值都相似，那么样本的变异很小。人口中的每一个样本都是相似的。
- 低变异导致相似样本导致窄 CI
- 高变化导致样本变化导致CI 变宽
样本量:如果我们取小样本，我们没有任何发现可以作为我们推断的基础。小样本彼此不同，细节较少，导致 CI 较宽
- 大样本尺寸导致更多细节导致CI 狭窄
- 小样本尺寸导致细节较少导致CI 较宽
误差幅度
调查是基于从样本中收集的事实，而不是整个人口。当我们不得不根据样本推断真实的统计数据时，一定会出现一些误差，比如抽样误差，这是因为没有考虑到每个人。误差幅度用来衡量样本结果与实际总体结果的最大差异。它衡量的是准确性，而不是偏差量。
误差幅度=临界值标准误差*
例证:我们知道 49%的人会在选举中投票给迪克斯，信任度为+/-2。这意味着我有信心 47%(49%-2%)到 51%(49%+2%)的人会投她的票。
假设检验
主要目的是测试调查和投票的结果，以检查结果是否有意义和可重复，而不是随机的。这是我们是否可以接受或拒绝一个索赔使用统计数据。它检验了关于人口的两种说法。例:治头疼的药不会有效，还是男女生身高有差异？一般语句的形式是“If(对自变量这样)，then(对因变量也会这样)”。
无效假设和替代假设
零假设(H0)，通常是样本观察结果纯属偶然的假设。这是众所周知的事实。研究人员努力拒绝它。这个想法是没有关系，无论是反映在采样误差的结果。它认为在一组给定的观察值中不存在统计学意义。分析或统计程序的 功效 是指当零假设 H0 实际上为假时，它能够显示该假设为假。
另一个假设(H1 或哈)，是样本观察值受一些非随机原因影响的假设。这个想法是样本中的关系反映了总体中的关系。例子:
H0:地球是平的。人口与医管局有一定的关系。
替代假设:地球是圆的
第一类和第二类错误
I 型错误表示拒绝真零假设，接受备选假设。这是一个假阳性。没有烟雾时探测烟雾的烟雾探测器。
第二类错误是指当替代假设为真时接受零假设。这是一个假阴性。当火警未能探测到火灾时。
阿尔法和贝塔水平
z indicates the alpha level in a two-tailed test
α水平也称为显著性水平，α。它是作出错误决定的概率，即当假设为真时拒绝零假设。低α水平意味着我们需要强有力的证据来拒绝零假设。这意味着 1%的阿尔法水平需要比 5%更多的统计证据。
为什么这么普遍地用 5%作为显著性水平？ α水平越小，拒绝真零假设的机会就越小。而且，由于面积很小，拒绝虚假零假设的机会也就越小。你越是试图避免第一类错误，你就越有可能犯第二类错误。
一个置信水平是 1- α，这意味着当它为真时接受零假设。
β水平表示犯 II 型错误的概率，即当替代假设为真时拒绝该假设。
p 值
所有假设检验都使用它来检查总体以数据形式提供的证据的强度。这是反对零假设的证据。该值介于 0 和 1 之间:
较小的 p 值(≤ 0.05)表明有强有力的证据反对零假设，因此您拒绝零假设。这意味着样本结果与为真的零假设不一致。
大的 p 值(> 0.05)表明反对零假设的证据很弱，因此您无法拒绝零假设。这意味着样本结果与为真的零假设一致。
如果 p 值小于或等于α水平，我们拒绝零假设。
感谢阅读！ 这里也可以给支持:https😕/buymeacoffee.com/divadugar
为赶时间的人统计
Here’s the audio version of the article, read for you by the author.
曾经希望有人能告诉你什么是统计学的点以及术语用简单的英语是什么意思吗？让我试着帮你实现这个愿望吧！我将在 8 分钟内快速浏览统计学中所有最重要的观点！或者只有 1 分钟，如果你坚持使用大字体的话。
什么是 统计 ？这是任何使我们的数据变得混乱的老方法。没错。100%技术上正确的定义。现在我们来看看统计的学科是什么都是关于的。
统计学是改变你想法的科学。
根据事实做决定( 参数 )已经够难的了，但是——诅咒！-有时我们甚至没有我们需要的事实。相反，我们所知道的(我们的 样本 )和我们希望我们知道的(我们的 人口 )是不同的。有 不确定性 就是这个意思。
统计学 是在不确定的情况下改变自己想法的科学。你的想法是什么？一个 默认动作 或者一个 先验信念 。如果你的大脑是一张白纸呢？把这个改为。
Bayesians 人改变了他们对信仰的看法。
贝叶斯统计是处理整合数据以更新你的信念的思想流派。贝叶斯主义者喜欢用可信区间(两个数字被解释为“我相信答案在这里和这里之间”)来报告结果。
常客改变他们对行动的想法。
频繁主义者统计学处理改变你对行动的想法。你不需要有一个信念来拥有一个 默认动作如果你不分析任何数据，这只是你承诺要做的事情。Frequentist(也称为经典)统计是您在野外和 STAT101 类中更可能遇到的一种统计，所以在本文的其余部分，让我们保持经典。**
假设是对世界可能是什么样子的描述。
无效假设 描述了所有的世界，在那里做默认动作是一个快乐的选择； 替代假设 是所有其他世界。如果我用数据说服你！-那你不是生活在零假设的世界里，那么你最好改变你的想法，采取替代行动。
例如:“我们可以一起步行去上课(默认动作)，如果你通常花不到 15 分钟做好准备(无效假设，但是如果证据(数据)表明时间更长(替代假设，你可以自己步行，因为我要离开这里(替代动作)。”
简而言之，测试:“我们的证据让零假设看起来可笑吗？”
所有的 假设检验 都是在问:我们的证据让零假设看起来可笑吗？ 拒绝零假设 意味着我们学到了一些东西，我们应该改变我们的想法。不拒绝 null 的意思是 我们没学到什么有趣的 ，就像去树林里远足，没有看到人类并不能证明这个星球上没有人类。这只意味着我们没有学到任何关于人类存在的有趣的东西。学不到东西让你难过吗？不应该，因为你有一个可爱的保险政策:你确切地知道该采取什么行动。如果你什么也没学到，你没有理由改变主意，所以继续做默认动作。
那么，我们如何知道我们是否学到了一些有趣的东西……一些与我们想要继续做默认动作的世界不一致的东西呢？为了得到答案，我们可以看看一个 p 值或者一个置信区间。
p 值在元素周期表上:这是令人惊讶的元素。
p 值 表示，“如果我生活在一个我应该采取默认行动的世界，我的证据有多令人惊讶？” p 值越低，数据越是在大喊“哇，这太令人惊讶了，也许你应该改变主意了！”
为了执行测试，将该 p 值与称为 显著性水平 的阈值进行比较。这是一个旋钮，你可以用它来控制你愿意承受多大的风险。这是你愚蠢地离开你舒适的默认行为的最大可能性。如果您将显著性级别设置为 0，这意味着您拒绝错误地保留默认值。放下笔。不要分析任何数据，只采取你的默认动作。(但这意味着你可能会愚蠢地没有留下一个糟糕的默认操作。)
How to use p-values to get the outcome of your hypothesis test. (No one will suspect that my xkcd is a knockoff.)
一个 置信区间 简单来说就是一种报告假设检验结果的方式。要使用它，检查它是否与你的零假设重叠。如果确实有重叠，那就什么也别学。如果没有，那就改变你的想法。
只有当置信区间不与你的零假设重叠时，才改变你的想法。
虽然置信区间的技术含义有点奇怪(我将在未来的帖子中告诉你所有关于它的内容，它肯定不像我们之前遇到的可信区间那样简单，希望也不会使它如此)，但它也有两个有用的属性，分析师认为这有助于描述他们的数据:(1)最佳猜测总是在那里，(2)当有更多数据时，它会变得更窄。请注意，它和 p 值都不是用来谈论的，所以不要期待简洁的定义。它们只是总结测试结果的方法。(如果你上了一堂课，发现这些定义不可能记住，这就是原因。代表统计:不是你，是我。)
有什么意义？如果你按照我刚刚描述的方式进行测试，数学保证你犯错误的风险被限制在你选择的显著性水平(这就是为什么你选择它很重要……数学保证你选择的风险设置，如果你不费心去选择它们，这是毫无意义的)。
数学就是建立一个零假设宇宙的玩具模型。这就是获得 p 值的方法。
The math is all about making and examining toy universes (how cool is that, fellow megalomaniacs!? So cool!) to see how likely they are to spawn datasets like yours. If your toy model of the null hypothesis universe is unlikely to give you data like the data you got from the real world, your p-value will be low and you’ll end up rejecting the null hypothesis… change your mind!
那些疯狂的公式、概率和分布是怎么回事？它们允许我们表达管理零假设宇宙的规则，这样我们就可以弄清楚那个宇宙是否是那种会吐出与你在现实生活中得到的数据相似的数据的地方。如果不是，你就大喊:“荒谬！砍掉它的头！”如果是的话，你耸耸肩，什么也没学到。在以后的文章中会有更多的介绍。现在，只要把数学想象成为我们建造小玩具世界，这样我们就可以看看我们的数据集在其中是否看起来合理。p 值和置信区间是为你总结所有这些的方法，所以你不需要眯着眼睛看冗长的宇宙描述。它们是终局:用它们来决定是否离开你的默认动作。任务完成。
我们做作业了吗？这就是权力衡量的标准。
等等，我们是否做了功课，以确保我们确实收集了足够的证据，给自己一个改变主意的公平机会？这就是的概念力量的度量。找不到任何改变想法的证据真的很容易…只是不要去找。你的权力越大，你就有越多的机会改变你的想法，如果这是正确的事情。权力是正确离开你的默认动作的概率。****
当我们什么也没学到，继续做我们正在做的事情时，如果我们的过程充满力量，我们会感觉更好。至少我们做了功课。如果我们几乎没有任何力量，我们很清楚我们不会改变主意。还不如不去分析数据。
在开始之前，使用功效分析检查您是否预算了足够的数据。
功耗分析 是一种检查给定数据量的预期功耗的方法。在开始之前，你用它来计划你的学习。(也挺容易的；在以后的文章中，我会向你展示循环只需要几个。)
不确定性意味着你可能会得出错误的结论，即使你有世界上最好的数学。
什么不是统计学？神奇的魔法，让不确定变得确定。没有魔法能做到这一点。你仍然会犯错。说到错误，这里有两个你在 Frequentist 统计中可能犯的错误。(贝叶斯人不会犯错。开玩笑！嗯，算是吧。请继续关注我的贝叶斯帖子。)
I 型错误 是愚蠢地离开你的默认动作。嘿，你说你对那个默认动作很满意，现在由于你所有的计算，你离开了它。哎哟！ 第二类错误 是愚蠢地不离开你的默认动作。(我们统计学家在给东西命名时很有创造力。猜猜哪个错误更严重。I 型？没错。太有创意了。)
第一类错误是在不该改变主意的时候改变主意。
第二类错误是在你应该改变主意的时候没有改变。
第一类错误就像判一个无辜的人有罪，而第二类错误就像没能判一个有罪的人有罪。这两个错误概率是平衡的(更容易给有罪的人定罪也更容易给无辜的人定罪)，除非你得到更多的证据(数据！)，在这种情况下，两种错误都变得不太可能，一切都变得更好。这就是为什么统计学家希望你有更多更多的 MOAR 数据！当你有更多的数据时，一切都会变得更好。
更多的数据意味着更多的保护来避免得出错误的结论。
什么是 多重比较校正 ？如果你知道你打算问同一个数据集的多个问题，你必须用一种不同的、调整过的方式来做你的测试。如果你一次又一次地让无辜的嫌疑人接受审判(如果你一直在你的数据中钓鱼)，最终某件事会因为随机事故而看起来有罪。 统计意义上的 这个词并不是指宇宙眼中发生的重要事情。这仅仅意味着我们改变了主意。也许不正确。诅咒这种不确定性！
不要浪费时间严谨地回答错误的问题。智能地应用统计数据(仅在需要时)。
什么是III 型错误 ？这有点像统计学上的笑话:它指的是正确地拒绝错误的零假设。换句话说，用所有正确的数学方法来回答错误的问题。
在决策智能中可以找到解决提问和回答错误问题的方法，这是一门新学科，旨在应用数据科学来解决业务问题并做出正确的决策。通过掌握决策智能，你将增强对第三类错误和无用分析的免疫力。
总之，统计学是改变你想法的科学。有两种思想流派。更受欢迎的一个——Frequentist statistics——是关于检查你是否应该离开你的默认动作。贝叶斯统计就是要有一个先验的观点，并用数据更新这个观点。如果在开始之前你的大脑真的一片空白，看看你的数据，跟着感觉走。
感谢阅读！YouTube 课程怎么样？
如果你在这里玩得开心，并且你正在寻找一个为初学者和专家设计的有趣的应用人工智能课程，这里有一个我为你制作的娱乐课程:
Enjoy the entire course playlist here: bit.ly/machinefriend
喜欢作者？与凯西·科兹尔科夫联系
让我们做朋友吧！你可以在 Twitter 、 YouTube 、 Substack 和 LinkedIn 上找到我。有兴趣让我在你的活动上发言吗？使用表格联系。
统计异常困难:WTF 是激活函数
和任何事情一样，我不是在描述任何独特的事情。有很多人比我更了解这个话题。这个故事是写给我脑海中的另一个人的😬。我确实经常和他聊天，他突然表达了对统计学和机器学习的兴趣。
那么，什么是激活功能呢？神经网络中的神经元松散地模仿我们的大脑神经元。啊！现在，我明白为什么它的名字是一样的了。我们大脑中的神经元会根据输入信息来激发，这不知何故让我们变得聪明！！！神经网络神经元中的激活函数是决定神经元是否应该触发以及以何种强度触发的函数。
让我们来看看不同的常用激活函数及其特性。
这是神经元的样子
Neuron
激活函数的输入值将在-∞和∞之间
步进功能
阶跃函数由阈值定义。
如果输入值大于阈值，则输出为 1，否则为 0。
step function
是因为长得像台阶才叫台阶函数的吗？听起来比说基于阈值的函数更酷。
缺点是非常二进制。它会丢失输入值中的任何梯度知识。阈值的 10000000 倍对阈值具有相同的影响。此外，忽略任何低于阈值的输入值。
另外，考虑一个你正在开发分类器的例子。如果多个神经元触发，我们如何确定选择哪一个？所有放电神经元的值都是 1。
线性函数
函数是 y = cx。
linear function
这样做的一个好处是，在分类器的情况下，你现在可以决定选择哪个神经元。
缺点是你建立了多层神经元，每一层都是线性的，然后它们组合在一起形成一个更大的线性函数。因此，这些额外的层不提供任何价值。
Sigmoid 函数
y = 1 / 1 + e⁻ˣ
sigmoid function
这是更平滑和非线性的特征。这没有线性函数的缺点。另一个优点是该值介于 0 和 1 之间。
缺点是在更高的值上梯度知识消失。这就是所谓的消失梯度问题。
Tanh 函数
y = tanh(x)
tanh function
这非常类似于 sigmoid 函数。tanh 的梯度比 sigmoid 更陡。tanh 也有渐变消失的问题。
ReLu 函数
y =最大值(0，x)
ReLu function
这是非线性的，所以它没有线性函数的缺点。ReLu 的一个优点是激发的神经元数量较少。
从计算的角度来看，这是比较便宜的。
依我拙见，你可以根据你喜欢的特征选择任何激活函数。您可以组合这些功能，甚至调整上述基本激活功能，以获得您想要的特性。
统计学非常难:WTF 是时间序列——第一部分
我是一个记忆力和数学能力都很差的人。我不明白，到目前为止，我是如何在编程世界中生存下来的。Stackoverflow.com，我欠你 80%的工资。
尽管有种种限制，我还是接受了学习更多技能的挑战……跳舞。我忘了说我也是手眼协调有问题的人。但幸运的是，我足够理智，不会分享我学跳舞的经历。
但在系列帖子(更多的是独白)中，我计划揭露我在学习统计学和机器学习方面的斗争。
在目前的帖子里，我打算通过我对时间序列分析的理解来谈谈。与任何统计话题一样，它不可能在一篇文章中全面地重复。所以警告是苦难将会继续…
假设我们有不同时间实例的销售数据:T₀、T₁、T₂、T₃..Tn。
让我们考虑最简单的模型来预测任何时间实例 T 中的值。任何时间实例 T 的预测值是所有观察值的平均值。
这种模型可以满足不感兴趣的数据，其中数据围绕一个值波动。
观察值用黑色表示，预测值用红色表示。
在本例中，该值在 20 左右波动。扁平线是所有观察值的平均值。
如果数据是线性的(但本质上不是平坦的)，这种方法就不起作用。
观察值用黑色表示。预测值显示为红色。观察值似乎具有线性模式，但预测值遵循平坦的平均线
我们能做些什么来改进我们的模型？因此，预测值不是所有值的平均值，而是将预测值改为目前为止观察值的平均值。在这种情况下，下一个时间实例 n+1 的预测值是迄今为止所有 n 观测值的平均值。
观察值用黑色表示，预测值用红色表示。
预测值落后于观测值。它肯定比以前的型号更好。
思考这个模型的一种方式是，平均值对所有过去的观察值进行同等加权。所有观察值被赋予 1/n 的相等权重，以预测我们在下一个时间实例 n+1 的值。
Tn+1 =(1/n)T0+(1/n)T1+(1/n)T2…+(1/n)Tn
由于预测只考虑了以前的观察或预测，所以让我们添加一些误差来减少滞后。
Tn+1 =(1/n)T0+(1/n)T1+(1/n)T2…+(1/n)Tn+误差常数
观察值用黑色表示。先前的预测值以红色显示。添加常数后的当前预测值显示为绿色。
增加误差常数肯定会使预测值看起来更好。
似乎统计建模喜欢在矩阵运算中定义事物。那么，让我们试着在矩阵运算中用公式表示同样的方程。
w 是重量矢量。w 是 1×n 矩阵。
T 是时间实例值的逆向量。t 是 n×1 矩阵。
因此，Tn+1 = W×T
因此，对于上面的平均建模观点，
w =[(1/n)(1/n)……(1/n)]
t⁻=[t0 t1…TN]
需要记住的一点是，我们对每个过去的值都给予了同等的重视。很远的时间值与接近当前时间的值对预测下一个实例值具有相同的影响，这感觉是不正确的。在下一部分中，我们将研究平滑模型，在这种模型中，我们根据以前的值在多远的时间内发生，为它们赋予可变的权重。
谢谢你陪着我。苦难将会继续…在下一篇帖子中。
统计学非常难:WTF 是时间序列——第三部分
在这一部分，我将尝试解释指数平滑的一些基本概念。因此，在我们深入研究之前，让我们试着理解我们的指数平滑之旅。
在第 1 部分中，我们从一个非常简单的模型开始，在这个模型中，我们给所有先前的观察值赋予了相等的权重，这基本上是所有先前观察值的平均值。这意味着所有先前的观察结果同等地影响下一个预测值。
在第二部分中，我们转到了另一个极端，我们认为只有 n 先前的观察同样影响下一个结果。我们可以进一步将模型移动到极限，其中最后一个值是预测的下一个值，即 n = 1
让我们试着考虑一个中间地带，与早期的观察相比，后期的观察会产生指数级的影响。这就是指数平滑发挥作用的地方。在这一部分，我们将讨论简单指数平滑，也称为单指数平滑。
简单指数平滑的方程为:
Sn+1 = 𝛼Yn + (1-𝛼)Sn
其中，
sn→nᵗʰ实例预测值，
yn→nᵗʰ实例实际观测值
sn+1→n+1ᵗʰ实例预测值
𝛼 →平滑参数(0 ≤ 𝛼 ≤ 1)
现在，这个方程似乎不是指数的。让我们展开这个等式，试图理解它的指数性质
sn+1 = 𝛼yn+(1-𝛼)sn
sn+1 = 𝛼yn+(1-𝛼)(𝛼yn-1+(1-𝛼)sn-1)→展开 sn
sn+1 = 𝛼yn+𝛼(1-𝛼)yn-1+(1-𝛼)sn-1
sn+1 = yn+yn-1+(1-1)..+ 𝛼(1-𝛼)ⁿY1
现在，你可以看到这个等式的指数性质。权重基本是几何级数。相信我，所有重量的总和是 1。权重值呈指数减少，因此呈指数平滑。
介于 0 和 1 之间的𝛼值决定了如何抑制影响。当𝛼越接近 1 时，阻尼越快。当𝛼越接近 0 时，阻尼越慢。
Simple Exponential Smoothing
观察值显示为绿色。预测值用紫色表示。如你所见，简单的指数平滑法比之前文章中的模型预测得更好。
也许在下一篇文章中，我会提到双倍和三倍指数平滑。
统计学:数据的收集、分析和推断(上)
统计学的定义
统计数字是以某种有意义的方式总结原始事实和数字的数字。他们提出了一些关键的想法，这些想法仅仅通过查看原始数据可能不会立即显现出来，我们所说的数据是指我们可以从中得出结论的事实或数字。
为什么要学统计学？
要做出客观的决定，做出看似鼓舞人心的准确预测，并尽可能以最有效的方式传达你想要的信息。这是总结数据关键事实的一种便捷方式。对统计学有很好的理解会使你处于有利地位。当统计数据不准确或具有误导性时，你更容易判断出来。换句话说，学习统计学是确保你不被愚弄的好方法。
处理数据:分类与数字
当您处理数据时，您需要弄清楚的一个关键问题是您正在处理哪种数据。一旦你明白了这一点，你会发现对你的数据作出关键决策会更容易。
- 分类或定性数据被分成描述质量或特征的类别。定性数据的一个例子是游戏类型；每个流派形成一个独立的类别。
- 数值型或定量型数据则与数字相反。数据中的值具有数字的含义，这涉及到测量或计数。数值型数据又称为定量型数据，因为它描述的是数量。
测量中心趋势
有时候你只需要抓住事情的核心。在一大堆数字中很难看出模式和趋势，找到平均值通常是看到更大画面的第一步。有了平均值，您将能够快速找到数据中最具代表性的值，并得出重要的结论。
平均值
很可能你以前被要求算出平均值。求一串数的平均值的一种方法是把所有的数加在一起，然后除以有多少个数。
在统计学中，这叫做 意思是 。它由以下等式表示:
模糊含义的情况
让我们考虑一个简单的例子。假设我们计算了所有员工的平均工资，以及工资比其他员工高得多的首席执行官的平均工资。平均值会受到首席执行官工资的影响，因此我们无法推断给定群体的正确信息。在这里，首席执行官的工资被称为 离群值。当数据集中出现异常值时，均值会向异常值移动，从而给我们错误的信息。
当我们绘制包含异常值的数据时，它要么向左倾斜，要么向右倾斜，如下所示:
中位数
如果平均值因为数据失真和异常值而变得有误导性，那么我们需要一些其他的方法来说明什么是典型值。我们可以通过取中间值做到这一点。这是一种不同的平均值，它被称为中值。让我们考虑一组中位数待定的数字。
**
如果你有一组偶数，就取中间两个数的平均值。在这种情况下，中值计算为 20.5。
方式
在某些情况下，中位数不能给出正确的数据解释。假设中间值(在奇数个数据集的情况下)或两个中间值的平均值(在偶数个数据集的情况下)可能甚至不接近该组中的其余数据点。在这种情况下，就引入了 模式 的概念。
一组数据的众数是最受欢迎的值，出现频率最高的值。与平均值和中值不同，绝对模式的是数据集中的一个值，并且是最常见的值。
该模式不仅适用于数字数据；它也适用于分类数据。事实上，只有和这种平均值才能处理分类数据。当您处理分类数据时，模式是最常出现的类别。
以上三种方法是统计分析数据的基本方法。在我即将发布的帖子中，我还会涉及更多的话题。所以，在那之前请继续关注！
保持饥饿，保持愚蠢——深入了解 StackOverflow 2018 年调查
介绍
根据今年年初的 StackOverflow 调查，在 98，855 名开发人员中，有 11，971 人认为自己是数据科学专业人员。到目前为止，大约 65%的人对自己的职业感到满意，比开发人员社区高出 10%。作为一名 ML 人员，我对发现哪些技术将成为数据科学社区的趋势以及挖掘使数据科学专业人员对其职业满意的因素很感兴趣。
关于数据集
- 中位数工资约为 6.8 万英镑，平均工资为 11.5 万英镑
- 其中 75%是白人
- 其中 41%拥有高等学位(不限于计算机科学)
- 大约 50%的人拥有计算机科学学士学位
- 其中只有 6%是女性
- 他们中的一半大约在 25-34 岁之间
假设
- Stack overflow 的数据是数据科学家群体的代表
- 所有列出的薪水都是以美元计算的(有关他们如何将受访者使用的当地货币转换为美元的信息，请参见他们的方法)
- 全职/兼职员工的抽样调查对象
- 本分析考虑了答卷人数超过 100 人的国家
- 数据科学家/数据分析师/业务分析师等开发类型被视为数据科学专业人员
目标
总体目标是深入了解数据科学家的职业生涯。特别关注影响数据科学家职业满意度的因素以及数据科学家使用的工具。我通过 4 个问题来实现总体目标:
- 他们熟悉哪种语言、数据库或框架，他们正在寻找的另一个软件堆栈是什么？Python 和 R 无疑是数据科学社区的流行语言。然而，随着大数据成为一种新型的企业资产，数据科学专业人员可能必须更加熟悉 Scala 等其他语言，并开始从事并行编程工作。
- 他们的简介是什么样的？学历影响职业满意度吗？数据科学专业人员位于何处，位置如何影响？
- “权力越大，责任越大”的观念是否让他们对自己的工作感到满意？换句话说，当专业人士成为任何数据的关键人物时，职业满意度是什么样的？
- 工作环境或薪酬如何推动职业满意度？有太多的故事表明数据科学是 21 世纪最性感的工作，作为一名数据科学家，你可以赚很多钱，这看起来绝对是一份理想的工作。金钱真的是职业满意度的重中之重吗？
分析和总结
Q1 —首先，Python 是数据科学专业人士的通用语言。其次，由于非结构化数据的增加，数据科学专业人员热衷于学习非 SQL 数据库中的技术，如 Elasticsearch。最后，与前端和深度学习相关的框架，这可能表明数据科学界对探索黑盒更感兴趣。
在本节中，如果我们只查看每一栏中的整体技术，那么我们将忽略一些关系，例如最想使用并且与合作过的技术，或者最想使用但是没有与合作过的技术。所以我以集的形式对比了数据科学专业人士现在和明年在做的技术，这样我们就能找到两个问题的区别和交集。
编程语言图表摘要
- Python、SQL、Javascript 在当前的数据科学专业人士中很流行，这种编程语言的需求也是存在的。
- Go 是一种数据科学专业人员还没有机会接触但却很想探索的语言。
- 不管数据科学专业人员是否使用过 Python 语言，python 都很受欢迎。
数据库图表摘要
- 通过比较这些图，可以发现从 SQL 数据库到非 SQL 数据库的转变。
- 由于文本挖掘的需求，弹性搜索变得越来越流行
框架图概要
- 有趣的是，我们发现想要学习 pyTorch 的数据科学专业人士的数量正在增加。
- 数据科学专业更倾向于在前端和深度学习中学习框架。这是一个有趣的趋势，因为前端与可视化更相关。我想知道这些专业人士是否希望解耦黑盒算法。这也导致了一个结论，即数据科学专业人员希望学会以简单而有意义的方式交流和展示研究结果)
Q2:目前为止，非计算机科学相关专业(工程、社会科学)的博士对自己的职业不太满意；基于 x 检验的结果，国家可以被认为是影响职业满意度的因素之一。
教育类型
crosstab between education type and undergraduate major for the difference of career statisfication ratio
上表显示了各组之间的比率差异(满意与不满意)，除了统计学和自然科学背景之外，拥有非计算机科学本科专业博士学位的专业人士对他们的状况不太满意。另一方面，到目前为止，拥有硕士学位的计算机科学专业的受访者对他们的职业不太满意。更好地了解他们对工作不满意的原因。我想调查他们未来工作的下一步是什么。
地理
The darker the color means that more data science professionals are more satisfied with their career.
北美和北欧国家的数据科学专业人员似乎比其他国家多，约占调查受访者的 12%。(比率按国家标准化。)如地理图表所示，我们可以发现大多数国家的数据科学专业人员普遍对自己的职业感到满意。
最后，X 值为 311.13，p 值低于 0.05，因此，我会发现这是一个令人信服的证据，表明国家和职业满意度之间可能存在关系。
Q3 —通过实施网络分析法，可视化了职称之间的共现关系。结果显示，数据科学专业人士认为自己平均属于四种不同的工作类型。程度中心性和接近中心性是解释受访者日常任务的指标。
通过计算共生矩阵来创建网络。我们可以看到职称之间的加权优势。出现矩阵在自然语言处理中被广泛应用于单词表示。步骤如下:首先我们要清洗数据，考虑每个标题都是一个单词。其次，我们计算回答者的标题出现的次数。最后，我们通过乘以它的转置矩阵来计算共生矩阵。最后，我们将对角元素设置为零，因此网络中没有自循环
Co-occurrence network between job titles
上图是用网络分析软件 Gephi 应用网络分析探究职称关系的结果。度中心性和接近中心性是这里衡量的两个关键因素。通常，这两个因素用于衡量信息在网络中的共享程度。度中心性用于衡量职位如何连接在一起，而接近中心性一个节点越中心，它与所有其他节点的同现度就越低。再者，后端开发人员、前端开发人员、数据或业务分析师、数据科学家或 ML 专员等职位联系紧密，是学历较高的职位。另一方面，市场营销或销售专业人员具有最高的亲密度中心性，这表明这在数据科学专业人员中并不常见。与后端开发人员和数据科学家或 ML 专家头衔相关的更多细节见解将相应介绍。
Backend Developer
如上图所示，后端开发人员与数据或业务分析师的同现性更强。我认为他们的日常工作更多的是商业情报工作。我感到惊讶的是，数据分析师之间的权重比全栈开发人员之间的权重更大。虽然这里的权重可能是数据分析师认为自己是后端开发人员，或者相反，但权重仍然提供了大多数数据科学专业人员是跨职能的见解。
Data Scientist or Machine Learning Specialist
如上图所示，数据科学家或机器学习专家与后端工程师的同现度略强。然而，它几乎与每个标题都有联系。为了更好地理解，我们可以研究一下调查对象中头衔数量的分布。
如上图所示，职称的平均值介于 4 和 5 之间，中位数为 4。换句话说，大多数数据科学专业人员都认为自己是多重角色。可能是不同类型的开发人员或分析师。t 检验的结果表明 p 值接近于 0，从而拒绝了等均值的零假设。因此，头衔的数量也应该被认为是影响职业满意度的一个因素。
Q4——正在使用与工作环境和薪酬相关的功能对决策树模型进行训练。结果表明，公司的技术等级比其他因素更重要。然而，很难说这是最重要的问题，因为开发人员档案还没有包含在模型中
本节将使用决策树模型构建一个决策树模型，通过与工作环境和薪酬相关的特征来评估实现职业满意度的关键路径。
根据我们的模型，第一标准是技术评级，然后是工资。有趣的是，当工资低于 97217.5%时，受访者更关心基本生活福利，而不是办公环境。然而，上述结果不能作为数据科学专业人士的偏好，因为还有其他因素，如开发人员概况，技术不包括在该模式中。该模型可用于评估工作福利工作评估问卷的结果
正如你所看到的，数据科学家或机器学习专家拥有内向、外向、理性和情感技能的良好组合。更重要的是，数据科学是一个不断变化的领域。虽然基础知识——如数学背景或您必须使用的语言(Python、SQL、R、bash)——被认为是常青树知识，但新的方法、工具、技巧和解决方案每年都会出现。因此，如果你想找一份数据科学家的工作，学习是你必须享受的第一件事。
远离端到端深度学习
或者混合软件 1.0 和 2.0
在为客户端问题设计攻击策略时，我经常观察到最佳解决方案结合了基于实例编程(机器/深度学习，软件 2.0 )和基于规则编程/基于规则(RB，软件 1.0 )两种风格。我之前的帖子讨论了这两种极端风格之间的拉锯战。
重述一下:给定一堆输入/输出对例子，你需要猜测一个函数 f ，这样对于每一对 f(i) = o 。那么，你是自己编写 f 中的规则还是使用一个从这些输入/输出例子中学习 f 的 ML/DL 算法。或者，更好的是，将它们结合起来以克服其中任何一个的缺点。
有趣的是，对于大多数客户问题，我发现 组合最有效——事实上，人们经常需要设计出创造性的方法来结合这两种风格。你可以有一个断裂的组合，其中 RB 和 ML 组件之间的边界非常明显，或者一个更加密集的组合。交互可以是单向的或双向的。
令人惊讶的是，网上几乎没有关于这种混合编程风格的讨论。因此，这篇文章:我将列出并解释一堆问题的解决方案，所有这些都是这种混合风格的最好解决的。这些应用跨越了各种领域——NLP、视觉和语音，以及强化学习——所有这些都适用于深度学习。
更新: Andrej Karpathy 最近写了一篇文章关于软件 2.0 (程序带实例)将如何吞噬软件 1.0 ( 程序带规则)。相反，这篇文章解释了软件 1.0 和 2.0 将如何很好地结合在一起。
AlphaGo 。也许混合学习最著名的例子是 AlphaGo(现在，自我游戏 AlphaGo Zero )。像通常的深度强化学习(RL)方法一样，它学习一个深度网络 N (卷积残差层)来预测每个状态的值(我会赢的概率)以及在每个状态下要采取的下一步行动(策略)。现在，我们如何获得目标状态和动作值(~基本事实)来训练每个状态下的网络？这就是有趣的地方。
一种方法是根据从同一网络 N 或 N 的较早快照获得的下一状态的预测来推断 当前状态目标。当试图扩展时，这种方法有许多缺点。相反，AlphaGo Zero 采用了一种混合的方法。
为了估计目标，它从当前状态进行一系列模拟(蒙特卡罗树搜索)。这些模拟不是随机的:它们由来自 N 的预测引导，即，在从当前状态开始的树扩展期间，基于 N 的预测贪婪地选择边。构建这棵树让算法能够预见未来(每个 MCTS 1600 次模拟)。最后，使用该树上的局部反向计算来获得当前状态的目标值/动作估计。
简而言之，为了征服围棋，AlphaGo Zero 在核心部分采用了基于神经网络的值和动作预测，与图形探索/动态编程之类的规则精细地交织在一起。注意这里的联轴器是双向 DL < - > MCTS(或者 ML < - > RB)。为什么这样
神经网络需要个例子来学习:基于规则的 MCTS+推理帮助神经网络获得个好的目标值。另一方面，MC 树搜索很容易迷失在巨大的搜索空间中:NN 预测使 MC 搜索集中于更小的一组更高回报的动作和状态。
文/NLP 。
尽管围绕端到端(e2e)深度学习大肆宣传，但实际上 NLP 解决方案依赖于基于规则的(RB)引擎，该引擎由 ML 引擎提供的结果输入。这种耦合在大多数情况下是单向 ML - > RB(也不像 AlphaGo 那样纠结)。
例如，考虑一下将自然语言查询 Q 转换成 SQL 查询 s 的问题。一个常见的解决方案是首先用名词/动词/标记查询 Q..标签，或者使用依存解析器从 Q 中提取中心修饰关系。接下来，我们在 tags/dependency-parse 之上编写一堆 if-then-else 规则，以提取实体、关系并推断 SQL 语句的正确嵌套。这种组合工作得很好，因为解析器公开了一个句子的组成结构，足以让我们编写一堆特别的规则来解决最终目标。
依存句法分析——是自然语言处理中的一个基本问题，用来计算一个句子的成分结构。几个高阶的 NLP 问题(如上图)依赖于一个好的依赖解析器。为了找到给定句子 S 中的中心词和修饰语，必须比较 S 和中的每一对词，并对这对词进行评分。为了正确评分，你必须理解两个单词在和中的上下文，然后给单词评分。给上下文中的成对单词打分是很困难的——我们需要使用一个 ML 引擎从例子中学习分数。
在深度学习中，双 LSTM (+MLP)被用于获得分数。给定评分引擎，外部循环迭代地给几对评分，并挑选出具有最佳评分的依存关系树，例如，使用最小生成树算法。在这里，RB 外环和基于 ML 的评分引擎的组合是断裂，但足以解决问题。
聊天机器人。与人类进行自动化目标驱动对话的关键步骤是定位口语句子中的关键实体。关键问题是序列标记(槽填充),并通过使用 RNNs 从例子中学习来解决。这个肯尼亚支付聊天机器人集合了基于 ML 的槽填充规则，用于检测一些货币提及。另一个最近的例子是 Edina ，一个学习如何对话的社交机器人。与大多数分散的方法不同，Edina 以无缝的方式从 RB 转移到 ML 方法。
本文将 SQL 查询与单词嵌入结合在一起，在数据库中查找不完全匹配(平滑 DB 搜索)。在这里，学习到的嵌入被输入到基于规则的 SQL 语法和执行引擎中。现在，这是 RB 和 ML 方法之间的密集组合，对于解决结构化+非结构化文本领域的搜索至关重要。
形象、言语。
预处理原始图像或语音数据包括应用一组已知的滤波器将原始输入编码成特征。一个 ML 引擎发现使用这些特性来合成 f 更容易。例如，图像可以被 ZCA 白化、直方图均衡化以提高对比度、归一化等。本质上，预处理包括应用已知的转换规则，其输出被输入学习引擎。有趣的是，这是 RB - > ML 的一个实例(我们之前看到的 ML - > RB 的反例)。
表格 OCR ，从图像中提取表格结构的问题，例如申请表、收据等。该解决方案通常依次由两个模块组成。使用 ML/DL 可以更好地完成底层的工作(线条、字符边缘、文本边界框检测)。更高级的布局发现可以通过边界框上的一组解析规则来更直接地解决。当然，您可以使用 e2e 学习公式，它以适当的编码格式输出表格布局。然而，我的经验是，数据设置和训练比编写第二部分的规则更麻烦。
原始的时间-域语音数据通过计算快速傅立叶变换的变体( FFT )被变换到频率域，随后在馈送到学习引擎之前将频率宁滨到以人为中心的标度(例如梅尔标度/ MFCC )。一些方法摆脱了这种固定层，以实现基于 e2e 深度学习的语音解决方案，但它们几乎不是主流。也许网络发现学习 FFT 方程或 Mel 系数很难。即便如此，一遍又一遍地学习这些方程也是没有意义的，如果他们最终每次都学到了这些的话。我认为这个问题是一个很好的例子，说明了我们为什么更喜欢一个破碎的 RB+ML 方法，而不是 e2e ML 方法。
表示 。这篇最近的论文使用了一种破碎规则+ ML 的方法来从语音中去除噪声。这是一个有趣的案例研究，它如何结合:(I)使用现有的(RB)语音滤波器和 bark 系数作为特征；(ii)选择一种网络架构，将任务分解为预定义的组件:语音活动检测、噪声估计、减去噪声；(iii)用深度网络实现每个组件，通过跳过连接(ML)进行组合；(iv)允许多任务学习。我发现(ii)特别有趣:尽管它坚持 e2e 学习范式，但是架构选择的反映了我们将如何手动分解问题。
在这篇文章中，我们看到了混合(ML+Rules)学习如何用于解决实际问题的几个例子:它解决了严格规则方法的覆盖限制和严格 ML 方法的缺乏保证。
我将以一些关于 e2e 与断裂途径之间紧张的想法来结束我的发言。给定一个复杂的问题，人类很快将其分解为子任务(更容易解决，可以重用众所周知的解决方案)。虽然 e2e 深度学习承诺通过隐藏网络架构内部的分解来使生活变得更容易，但我相信我们有一种倾向，那就是回到我们的(有偏见的)解决方案分解，并使它们显化(也许通过使用一种分裂的方法)。
这导致了基于规则和基于例子的问题解决方式之间的内在矛盾。事实上，像 RNNnoise 或this这样的方法，试图通过挑选反映我们预定义的问题分解的架构来将世界聚集在一起，并一次性学习几个任务。
我希望这篇文章有助于阐明我们如何从例子中进行混合学习。我会继续在这篇文章中添加其他混合学习的例子。
无激光雷达自动驾驶汽车转向
自动驾驶汽车使用各种技术来检测周围环境，如雷达、激光、 GPS 、里程计和计算机视觉。S 传感器信息用于识别导航路径、障碍物和路标。自动驾驶汽车的控制系统能够分析传感数据，以区分道路上的不同汽车，检测车道线并预测转向角度
像激光雷达这样的传感器很贵。激光雷达的领先制造商威力登公司以 8000 美元的价格出售其目前用于原型机器人汽车的机械旋转激光雷达设备。有没有可能使用简单的相机图像和其他负担得起的感官数据来让自动驾驶汽车在道路上行驶？
对于行为克隆项目的想法是训练一个深度神经网络来克隆驾驶行为，以预测转向角度。 Udacity 的模拟器用于收集训练数据，也用于测试模型性能。训练数据由来自不同摄像机(中央、左侧和右侧)的一系列图像以及油门、速度、转向角度和制动的相应测量值组成。
Udacity Simulator
Training image from simulator
对于左边的图像，我们在模拟器上驾驶这辆车后记录了转向角测量值。在模拟器上记录 4 圈的训练数据
每个图像的尺寸为 160×320×3(RGB 图像),进一步用于训练深度神经网络以预测转向角。在我进入模型架构之前，让我给你看一下汽车在模拟器中自动驾驶的视频。
Behavioral Cloning Track Simulation
我使用的 CNN 架构的灵感来自 Nvidia 的架构:
数据预处理
使用模拟器 160 x 320 x 3 尺寸(RGB 图像)获得的训练图像，因为模拟器转向角训练期间的大部分时间为零。我不得不在零转向角的情况下随机清除 80%的数据。这是在预测过程中考虑偏差所必需的。并且为了更好的预测，RGB 图像也被裁剪并转换到 HLS 颜色空间。裁剪是必要的，因为它有助于从数据中去除噪声，因为与天空和风景相比，转向角度更依赖于对道路和转弯的感知。不用说，模型在进行数据预处理后表现得更好。
当 lap 向任一方向(左或右)转弯时，即使训练后数据也可能有偏差。为了避免这种情况，cv2。 [flip](http://docs.opencv.org/2.4/modules/core/doc/operations_on_arrays.html#void flip(InputArray src, OutputArray dst, int flipCode)) 用于扩充数据并生成更多数据集。左右图像用于恢复，转向校正系数为 0.20。
神经网络结构和超参数
在探索了 comma.ai 和 Nvidia 的架构之后，我决定从简单的架构开始。想法是从简单开始，如果需要，增加更多的复杂性。架构与上面张贴的图表相同。应用 5%的下降以避免过度拟合，并且所有层都跟随有 RELU 激活，以便引入非线性。
“MSE”用于计算优化器的损失和“adam”。我发现这个博客真的有助于理解不同的梯度下降优化算法。五个时期用于 20%验证分割的训练。经过五个时期的训练后，我的训练损失大约为 3 %,验证损失大约为 5%。
结论和讨论
虽然这个项目很有挑战性，但最终在模拟器中看到汽车自动驾驶的快乐让我意识到这是值得努力的。仔细收集训练数据很重要。我也不确定这种技术在弱光条件下是否有效。不用说，深度学习，或一类机器学习算法，正显示出巨大的前景，主要是因为它正在取得成果。我相信还有很多不同的技术有待探索，但这是一个很好的开始。
下面是链接到我的 github repo 与 keras 实现上面的代码并写上去。
参考
Udacity 自动驾驶汽车工程师纳米学位。
关于卷积神经网络的 CS231n 课程和安德烈·卡帕西的视频讲座。
我的 github 回购:https://github.com/linux-devil/behavioral-cloning
英伟达架构
Comma.ai 架构
隐写术:将一幅图像隐藏在另一幅图像中
在这个故事中，我们将学习一些图像处理的概念，以及如何将一个图像隐藏在另一个图像文件中。
为了提供一个功能示例，实现了一个 Python 类来执行本故事结尾提到的过程。
首先我们来了解一下什么是隐写术，数字图像，像素，颜色模型。
什么是隐写术？
隐写术是将一个文件、消息、图像或视频隐藏在另一个文件、消息、图像或视频中的做法。
隐写术比密码学有什么优势？
隐写术相对于单独的密码术的优势在于，预期的秘密消息不会引起对其自身作为审查对象的注意。显而易见的加密信息，无论如何无法破解，都会引起人们的兴趣，而且在加密不合法的国家，这些信息本身可能会被定罪。
换句话说，当我们想要发送秘密信息时，隐写术比密码学更谨慎。另一方面，隐藏的信息更容易提取。
什么是数字图像？
好了，现在我们知道了隐写术的基础知识，让我们学习一些简单的图像处理概念。
在了解如何将一幅图像隐藏在另一幅图像中之前，我们需要了解什么是数字图像。
我们可以将数字图像描述为一组有限的数字值，称为像素。像素是图像中最小的单个元素，包含代表给定颜色在任何特定点的亮度的值。所以我们可以把一幅图像想象成一个包含固定数量的行和列的像素矩阵(或二维数组)。
当在此使用“数字图像术语时，我们指的是“光栅图形，它基本上是一种点阵数据结构，代表像素网格，进而可以存储在不同格式的图像文件中。你可以在维基百科网站上阅读更多关于数字图像、光栅图形和位图的内容。
像素概念和颜色模型
如前所述，像素是图像的最小元素。因此，每个像素都是原始图像的样本。这意味着，更多的样本可以更准确地再现原始图像。每个像素的强度是可变的。在彩色成像系统中，一种颜色通常由三种或四种分量强度表示，如红色、绿色和蓝色，或青色、品红色、黄色和黑色。
这里，我们将使用 RGB 颜色模型。可以想象，RGB 颜色模型有 3 个通道，红、绿、蓝。
RGB 颜色模型是一种加色颜色模型，其中红色、绿色和蓝色光以各种方式相加在一起，以再现各种颜色。该型号的名称来自三种加色原色的首字母，即红、绿和蓝。RGB 颜色模型的主要用途是用于电子系统(如电视和计算机)中图像的感测、表示和显示，尽管它也用于传统的摄影。
因此，图像中的每个像素由 3 个值(红、绿、蓝)组成，这 3 个值是 8 位值(范围是 0–255)。
正如我们在上面的图像中看到的，对于每个像素，我们有三个值，可以用二进制代码(计算机语言)来表示。
处理二进制代码时，我们有较高的有效位和较低的有效位，如下图所示。
最左边的位是最高有效位。如果我们改变最左边的位，它将对最终值有很大的影响。例如，如果我们将最左边的位从 1 更改为 0 ( 11111111 更改为 01111111 )它会将十进制值从 255 更改为 127 。
另一方面，最右边的位是最低有效位。如果我们改变最右边的位，对最终值的影响会更小。例如，如果我们将最左边的位从 1 更改为0(111111111更改为 11111110 )它会将十进制值从 255 更改为 254 。注意，最右边的位在 256 的范围内只改变 1(它表示小于 1%)。
总结:每个像素有三个值(RGB)，每个 RGB 值都是 8 位(意味着我们可以存储 8 个二进制值)，最右边的位不太重要。因此，如果我们改变最右边的位，它将对最终图像有一个小的视觉影响。这是将一幅图像隐藏在另一幅图像中的隐写术密钥。更改一幅图像的较低有效位，并包含另一幅图像的最高有效位。
将图像隐藏在另一个图像中
既然我们理解了像素概念和颜色模型，我们就可以讨论将一个图像隐藏到另一个图像中的过程。
在本节中，我们可以找到使用 Python 代码的隐藏和显示过程的一步一步。
隐藏图像:
- 要将一个图像隐藏在另一个图像中，被隐藏的图像最多需要与隐藏它的图像大小相同。
2.我们必须创建两个循环来遍历图像的所有行和列(实际上是每个像素)。
3.因此，我们从图像 1 和图像 2 获得 RGB 二进制值:
我们可以使用 __int_to_bin 方法将十进制值转换为二进制值:
4.我们将图像 1 的最高有效位与图像 2 的最高有效位合并:
使用 __merge_rgb 方法:
请注意， __merge_rgb 函数使用每幅图像的 4 个最高有效位，但也可以改变。请记住，使用隐藏图像中较少的位会导致恢复图像的质量较低。
5.最后，我们将新的二进制值转换为十进制值:
使用 __bin_to_int 方法:
并将其设置为结果图像中的新像素位置。
现在我们有了一个隐藏在另一个图像中的图像。
整个合并的方法可以在这里找到。
露出一个形象:
- 要显示一幅图像，我们必须知道用了多少位来隐藏图像。在这种情况下，我们使用固定数量的 4 位。
- 首先，我们需要创建两个循环来遍历图像中的所有像素:
3.因此，我们从当前像素中提取每个 RGB 通道作为二进制值:
使用 __int_to_bin 方法:
4.然后，我们创建一个新的 RGB 值，只将当前像素最右边的 4 位与零值连接起来(以创建一个新的 8 位值):
5.最后，我们将二进制值转换为十进制值，并将其设置为新图像中的当前像素:
6.当隐藏的图像小于隐藏它的图像时，所开发的算法只有最后一步来去除黑边。
通过这个简单的代码，我们可以从另一幅图像中提取一幅图像。
整个解合并方法可以在这里找到。
您可以在下图中查看结果:
左上角的图像将隐藏右上角的图像。左下图像是两个合并的图像，右下图像是提取的(未合并的)图像。
正如你在上面的图像中看到的，我们在这个过程中损失了一些图像质量，但这并不影响对图像的理解。
你可以在 https://github.com/kelvins/steganography 的Github:上找到隐写术 Python 代码
隐写术:间谍如何相互欺骗
ste ga no 图形 y
ˌste-gə-ˈnä-grə-fē
名词
将一个消息、图像或文件隐藏在另一个消息、图像或文件中的艺术或实践
我是 Greg Rafferty，湾区的数据科学家。你可以在我的 github 上查看这个项目的代码。如有任何问题，请随时联系我！
第二次世界大战期间，盟军截获的德国电文如下:
他们要求他们最好的密码学家对隐藏的信息进行解码，因为显然这比看起来要复杂得多。但如果他们截获了一些德国人互相发送 1942 年的 Instagrams，他们可能不会费心去过多解读它。
Just a picture of a forest? Or something more ominous…?
“Steganography”来自希腊语 steganos，意为“被覆盖”或“沉默寡言”。密码学关注的是隐藏信息的内容，而隐写术关注的是隐藏信息的存在这一事实，这阻止了潜在的密码破译者深入研究。
这篇文章是关于某种隐写术，称为最低有效位(或 LSB 隐写术)。如果我给你 00000000 美元，并告诉你在我把钱交给你之前，你只能换其中的一个数字，只有傻瓜才会换最右边的数字并索要 00000001 美元。很明显，改变最左边的数字会得到 10，000，000 美元，或1000 万美元，而改变最右边的数字只会得到 1 美元。即使在这两种情况下，我们只是改变了一个数字，最右边的数字是最不重要的，因为它对总数的影响最小。这和 LSB 隐写术是一个概念。
O 一个字节的数据由 8 位组成——8 个 0 或 1 的数字，如 00011010。如果这个字节代表图像中一个像素的颜色，我们可以改变最右边的数字，并且只能非常细微地改变那个像素的颜色。我们可以将我们的秘密信息编码在这些最低有效位中，这样整个图像对人眼来说不会改变太多，也不会引起对其本身的注意，然后提取这些位来揭示秘密。
这里有一个直观的例子。计算机屏幕上的颜色可以用红、绿、蓝的各种平衡来表示。这被称为 RGB 颜色模型，每个像素可以有一个 0 到 255 之间的值。在上图中，左边的红色方块是由R=240, G=64, B=64的红色、绿色和蓝色像素值创建的。转换成二进制表示，这些数字就是R=11110000, G=0100000, B=0100000。右边的下一个方块将每个颜色通道的最低有效位从 0 更改为 1，从而得到R=1111000**1**, G=010000**1**, B=010000**1**的值。这个正方形和第一个正方形的颜色完全一样，我们在这个像素中编码了 3 位信息。下一个平方也改变了第二个最低有效位，导致值为R=111100**11**, G=01000**11**, B=01000**11**。每个方块的下一个最低有效位都发生了变化，您可以看到，直到我们到达序列的中间，颜色才会发生变化(这只是因为我们能够将其与原始值进行比较)。当我们到达最后一个方块时，红色、绿色和蓝色通道的每个字节中的每一位都被交换了，颜色已经完全改变了。当转换回整数值时，我们现在处于像素值R=**0000111**, G=**10111111**, B=**10111111**或R=15, G=191, B=191。
为了将最大量的信息编码到一个像素中而不改变太多，我选择丢弃 4 个最低有效位。因此，为了将一个图像隐藏在另一个图像中，我取封面图像的 4 个最高有效位和隐藏图像的 4 个最高有效位。我将隐藏图像的 4 位移动到最低有效位的位置，并将它们与封面图像的 4 位合并。然后，瞧！，封面图像看起来一点也没有改变，但它现在包含了重建隐藏图像所必需的信息。****
这是一个展示这一过程的动画:
我们首先遍历封面图像(上面视频中的红框)和隐藏图像(绿色)的每个像素，
- 将每个颜色通道的 RGB 值转换为二进制
- 同样，对于每个通道，从封面图像中取出 4 个最高有效位，从隐藏图像中取出 4 个最高有效位
- 将隐藏图像的 4 位移动到最低有效位的位置，并将它们与封面图像的 4 位组合
- 将 RGB 通道组合在一起，创建一个新像素，由封面图像的 4 个有效位控制，但隐藏图像的 4 个最高有效位编码在其中。由于隐藏在最低有效位的信息，颜色会稍微改变(注意，红色方块现在只是稍微变得橙色)**
- 要解码隐藏图像，从新像素中取出 4 个最低有效位，并将它们移回到最高有效位的位置
- 用 0 填充空出的最低有效位(这是我们由于编码而永远丢失的信息)
- 隐藏的图像现在会出现，由于最低有效位的数据丢失，与原始图像略有不同(看，它有点暗)
还记得上面那张森林的照片吗？里面藏着一幅图像。我已经用隐藏图像的最高有效位替换了所有最低有效位。所以，如果我拿这张图像，去掉每个像素的四个最高有效位，把最低有效位移过来，会出现什么？里克·阿斯特利！
You’ve been rickrolled!
没有看到那片森林的原始照片(即使你看到了！)，很难知道里面藏着什么图像。我故意选择了一个“忙碌”的图像，有很多随机的线条和对比，因为变化更难被注意到。不过，阿斯特利的解码图片确实显示了一些因最低有效位丢失而产生的伪像。看下面的图片；顺利(这么顺利！)阿斯特利前额和脸颊的皮肤在解码图像中显示出一些色调分离，其中颜色没有平滑过渡地突然变化。你也可以在砖块中看到，特别是在他右肩(左肩)上方的拱门开始处，砖块中的许多细节都丢失了，它们看起来是一种连续的颜色。
****
Top Left: original cover image; Top Right: coded image; Lower Left: original hidden image; Lower Right: decoded hidden image
对于 LSB 隐写术而不是来说，使用来自公共领域的图像是很重要的，因为人们可以很容易地将原始图像与编码图像进行比较。在这里，我已经采取了森林的原始图像，并从中减去编码图像。这将减去每个像素值，并有效地显示两张照片之间的差异。
A ghoulish rickroll emerges from the forest
森林图像大部分丢失，因为它的所有最高有效位已经彼此相减。我们只剩下最不重要的部分，这就是阿斯特利的藏身之处。此外，里克·阿斯特利的照片有不同的长宽比，所以照片底部的 1/8 没有任何隐藏的图像。上图的亮度也显著增加了。图像的变化如此难以察觉，以至于未增强的差异显示为纯黑色。
SB 隐写术不仅仅是间谍使用的工具。例如，电影工作室也经常使用这种技术。当他们需要在向公众发布电影之前将电影发送给审查者时，他们会在电影的一些帧中隐藏水印。这种水印是特定于每个提前拷贝的接收者的，所以如果电影后来在海盗湾上映，电影工作室只需要从拷贝中解码隐藏的水印，就可以发现是谁泄露了它。至关重要的是，如果图像被压缩，这些隐藏的图像仍然可以被解码——因为隐藏的图像只是其自身的“变暗”版本(不完全正确，但只是顺其自然)，即使图像被调整大小、压缩或裁剪，它仍然会在那里。
还可以用 LSB 隐写术将纯文本隐藏在另一幅图像中。但是文本需要稍微不同的过程；文本首先被转换成一个字节数组，然后每一位被依次覆盖到图像的最低有效位。因为顺序很重要，并且每个像素包含一长串位的一部分，所以图像必须保存为位图文件，并且不能被压缩(除非以无损格式保存，如. png 格式)、裁剪、调整大小、增强或任何其他会改变像素的过程。与隐藏另一个图像相反，在隐藏另一个图像时，对封面图像的任何改变都会改变但不会破坏隐藏的图像，而隐藏文本时，对底层像素值的任何改变都会完全破坏文本。对于大量的文本来说，这显然很不方便，因为生成的位图文件会非常大(我将《战争与和平》的全部内容编码到一张 243 兆字节的图像中)。这是森林图像的另一个版本，它包含的文本字符串比“战争与和平”短得多:
这幅图像中隐藏着什么？
我们对爱情并不陌生
你知道规则，我也知道
完全的承诺是我所想的
你不会从任何其他人那里得到这种承诺我只想告诉你我的感受，让你明白
永远不会放弃你
永远不会让你失望
永远不会跑来跑去抛弃你
永远不会让你哭泣
永远不会说再见
永远不会说谎伤害你我们相识已久
你的心一直在痛，但你羞于启齿
我们都知道发生了什么
我们知道这个游戏，我们会玩下去如果你问我感觉如何，不要告诉我你太盲目而看不到
永远不会放弃你
永远不会让你失望
永远不会到处乱跑抛弃你
永远不会让你哭泣
永远不会说再见
永远不会说谎伤害你
永远不会放弃你
永远不会让你失望
永远不会到处乱跑抛弃你
永远不会让你哭泣
永远不会说再见
永远不会说谎伤害你永不放弃，永不放弃
(放弃你)
(哦)永不放弃，永不放弃
(放弃你)我们相识已久
你的心一直在痛，但你羞于启齿
内心深处我们都知道发生了什么
我们知道这个游戏，我们会玩下去我只想告诉你我的感受，让你明白
永远不会放弃你
永远不会让你失望
永远不会到处乱跑抛弃你
永远不会让你哭泣
永远不会说再见
永远不会说谎伤害你
永远不会放弃你
永远不会让你失望
永远不会到处乱跑抛弃你
永远不会让你哭泣
永远不会说再见
永远不会说谎伤害你
永远不会 我会放弃你，永远不会让你失望，永远不会到处乱跑，抛弃你，永远不会让你哭泣，T21
词干？引理化？什么？
深入探究词干化和词汇化对自然语言处理任务有什么作用，以及它们是如何做到的。
词干化和词汇化
在自然语言处理中，有时您可能希望您的程序识别出单词“ask”和“asked”只是同一个动词的不同时态。这是将一个单词的不同形式简化为一个核心词根的想法。相互派生的单词可以映射到一个中心单词或符号，特别是如果它们具有相同的核心含义。
也许这是在一个信息检索设置中，你想提高你的算法的召回率。或者，您可能试图分析语料库中的单词用法，并希望压缩相关单词，这样就不会有太多的可变性。不管怎样，这种文本规范化技术可能对您有用。
这就是词干化或词汇化之类的东西出现的地方，这些东西你可能以前听说过！但是这两者有什么区别呢？他们实际上是做什么的？这是我们今天要探讨的两个问题！
那么它们是什么呢？
从本质上来说，这两种技术处理的是同一个想法:将一个单词简化为它的词根或基本单位。这通常是一个数据预处理步骤，熟悉它是件好事。虽然他们都希望解决这个相同的想法，但他们却以完全不同的方式去做。我们来看看吧！
堵塞物
词干处理无疑是这两种方法中较简单的一种。有了词干，单词就简化成了词干。词干不必与基于词典的词根是同一个词根，它只是等于或小于单词的形式。
词干算法通常是基于规则的。你可以把它们看作是一种启发性的过程，这种过程在某种程度上删减了单词的词尾。一个单词被查看并通过一系列决定如何删减的条件句。
例如，我们可能有一个后缀规则，基于一个已知后缀的列表，将它们删除。在英语中，我们有像“-ed”和“-ing”这样的后缀，为了把单词“cook”、“cooking”和“cook”都映射到同一个词干“cook”，去掉这些后缀可能是有用的。
转向过度和转向不足
然而，因为词干通常是基于启发式的，它远非完美。事实上，它通常有两个问题:转向过度和转向不足。
越界来自于一个词被砍掉太多。这会导致无意义的词干，单词的所有意思都丢失或混淆了。或者它可能导致单词被解析为相同的词干，尽管它们可能不应该被解析。
以大学、宇宙、大学和宇宙这四个词为例。将这四个单词解析为词干“univers”的词干算法已经越界。虽然把宇宙和宇宙放在一起，把大学和大学放在一起可能不错，但这四者都不合适。一个更好的解决方案可能是将前两个解析为“univers”，后两个解析为“universi”。但是执行这样的规则可能会导致更多的问题出现。
理解不足是相反的问题。当我们有几个词实际上是彼此的形式时，它就产生了。对他们来说，如果所有人都下定决心做同一件事就好了，但不幸的是，他们没有这样做。
如果我们有一个词干算法，将单词 data 和 datu 词干化为“dat”和“datu”，就可以看出这一点你可能会想，好吧，把这两个都归结为“dat”然而，我们该如何处理日期呢？有没有一个好的通用规则？或者我们只是为一个非常具体的例子执行一个非常具体的规则？
当涉及到词干时，这些问题很快就变成了问题。强制执行新的规则和试探法会很快失控。解决一两个过度/不足的问题会导致两个以上的问题出现！制作一个好的词干算法是一项艰巨的工作。
说到这个…
词干算法示例
当我第一次开始使用词干时，我立即接触到的两个词干算法是 Porter stemmer 和 NLTK 的 Snowball stemmer。虽然我不会详细介绍这两种方法，但我会重点介绍一下，这样您会比我第一次使用它们时知道得更多。
- 波特词干分析器:这个词干算法比较老。它起源于 20 世纪 80 年代，主要关注的是去除单词的常见词尾，以便它们可以被解析为一种常见的形式。它并不复杂，开发也停滞不前。通常，这是一个不错的基本词干分析器，但是不建议将其用于任何生产/复杂的应用程序。相反，它在研究中有自己的位置，是一个很好的基本词干算法，可以保证可重复性。与其他算法相比，这也是一个非常温和的词干算法。
- 雪球词干分析器:这个算法也被称为 Porter2 词干算法。几乎所有人都认为它比波特词干分析器好，甚至连波特词干分析器的发明者也承认这一点。话虽如此，它也比波特斯泰默更具侵略性。添加到雪球词干分析器的很多东西都是因为波特词干分析器的问题。雪球和波特的阻止方式大约有 5%的不同。
- Lancaster stemmer :只是为了好玩，Lancaster stemming 算法是你可以使用的另一种算法。这是最积极的词干算法。但是，如果您在 NLTK 中使用词干分析器，您可以非常容易地将自己的定制规则添加到这个算法中。这是一个很好的选择。围绕这种词干算法的一个抱怨是，它有时过于激进，真的可以将单词转换成奇怪的词干。在使用这个选项之前，请确保它能完成您想要的功能！
词汇化
我们已经讨论了词干，但是事情的另一面呢？词汇化有什么不同？好吧，如果我们认为词干化只是根据单词的外观来猜测在哪里截取单词，那么变元化是一个更加精确的过程。它包括将单词解析成它们的字典形式。其实一个词的一个引理就是它的字典或者规范形式！
因为 lemmatization 在这方面更加细致，所以实际工作起来需要更多一些。对于将一个单词解析为其词条的词条化，它需要知道它的词性。这需要额外的计算语言学能力，如词性标注器。这允许它做更好的决定(像决定“是”和“是”)。
关于引理化需要注意的另一件事是，用一种新语言创建一个引理化器通常比词干提取算法要困难很多倍。因为 lemmatizers 需要更多关于语言结构的知识，所以这是一个比仅仅试图建立一个启发式词干算法更密集的过程。
幸运的是，如果您用英语工作，您可以像使用词干一样通过 NLTK 快速使用词汇化。然而，为了获得最佳结果，您必须将词性标签提供给词条分类器，否则它可能无法将所有单词归入您想要的词条。更重要的是，它是基于 WordNet 数据库(有点像同义词网或辞典)的，所以如果那里没有一个好的链接，那么无论如何你都不会得到正确的词条。
包扎
在我结束本文之前，还有一件事:如果您选择在 NLP 应用程序中使用词汇化或词干化，请务必测试这两种方法的性能。在许多应用程序中，您可能会发现，这两种方法最终都会以一种糟糕的方式影响性能，就像它们有助于提高性能一样。这两种技术实际上都是在考虑召回的情况下设计的，但结果往往会影响精确度。但是如果回忆是你的目标(就像搜索引擎一样)，那也许没问题！
此外，这篇博文主要围绕英语展开。其他语言，即使它们看起来有些相关，在词干化和词汇化方面也有非常不同的结果。一般的概念保持不变，但是具体的实现会有很大的不同。如果你打算用一种完全不同的语言工作，希望这个博客至少在高层次上有所帮助！
如果你喜欢这篇文章，并渴望更多的 NLP 阅读，为什么不看看我写的另一篇关于单词嵌入如何工作以及你可能遇到的不同类型的博客文章。或者，如果你更喜欢句子，为什么不看看我对一篇论文的总结，这篇论文分析了不同的句子嵌入如何影响下游和语言任务！
原主持人:【hunterheidenreich.com】T5
Tensorflow 中用代码实现奇异值分解的逐步反向传播
Photo by Rahul Bhosale on Unsplash
奇异值分解，也被称为线性代数的基本定理，是一个惊人的概念，让我们将一个矩阵分解成三个更小的矩阵。(请点击此处阅读关于四个基本子空间的更深入内容:4 行)。就像特征值分解一样，梯度也可以计算。
就个人而言，这是一个巨大的里程碑，我相信知道这个算法将打开许多大门，当涉及到训练一个深度神经网络 而没有 依靠自动微分时。
请注意，这篇文章是为了我自己的教育目的，如果发现任何错误，请在下面评论。
我认为最好的参考
Paper from this website
上面的论文详细描述了这个过程，讲述了如何进行这种求导。
假设以及基本概念回顾
Image from this website
我要假设的第一件事是，我们将使用一个维数为(m，n)的矩阵，m 将总是大于 n(m≤n)。这很重要，因为当我们执行奇异值分解时，我们可以计算全矩阵，也可以不计算全矩阵。所以当我们把矩阵分解成三部分时，每一部分都有维度…
U(左奇异向量) → (m，n)
S(奇异值，对角矩阵) → (n，n)
V(右奇异向量) → (n，n)
为了给出一个具体的例子，让我们假设我们的原始数据矩阵“数据”具有如下所示的维度。
蓝框 →显示每个矩阵的维度
红框 →比较原始数据和重建数据
现在让我们继续讨论其他基本的线性代数概念，首先我们要讨论正交矩阵。
我已经假设读者已经知道了这个概念，但是让我们看看这是如何在代码中实现的。由于每个奇异向量(左和右)都是各自空间的基向量，所以它们是正交矩阵。
蓝框→ 该性质适用于左右奇异矩阵
红框 →当我们计算全矩阵时，该性质适用于左奇异矩阵。
现在，再次记住我们没有计算全矩阵的事实，一个性质不适用于左奇异向量，然而，当我们计算全矩阵时，我们看到该性质适用于两个方向上的两个奇异向量。
最后，让我们看看逆矩阵==转置性质适用于两个矩阵。(正交矩阵)接下来我们将讨论正交补码。
上面的描述并不能帮助我理解这个概念，所以，下面我附上了两个与这个话题相关的视频。
Video from this website
video from this website
现在让我们看看这些属性在代码中是如何体现的。(注意:我将使用这个 git repo 中的代码来寻找正交补码。)
红框→U 的原始形状和 U 的 perp，当我们在它们之间进行点积时，所有的结果都将接近于零。
蓝框 →计算以下属性为真。
现在请把注意力集中在蓝色的盒子上，有一分钟的时间，我没有解释这个属性，但是我想证明下面的属性是真实的。
我们将在通过 SVD 反向传播时使用这个属性。最后，让我们来看看偏斜矩阵。
Image from this website
非常简单的概念，现在让我们看一下代码，让我们的理解更加完整。
请注意，上述矩阵的对角线值都是零。
步骤 0 执行奇异值分解
从上述示例中，我们探索了一些属性，现在我们将执行 SVD，从原始数据(A)中，我们将获得 U、S 和 V，为了重建原始数据，我们可以简单地执行 U、S 和 V 转置之间的点积。
步骤 1 确定一些属性
从奇异值分解的定义中，我们注意到 U 和 V 都是正交矩阵，因此与自身的点积会产生一个单位矩阵。现在让我们只关注右边的部分，也就是转置(U) @ U。
上面的代码显示了 identity 属性。
当我们对上面的方程求导，我们得到上面的公式，从那里我们注意到一些东西。
当我们将等式的右边移到左边时，符号发生了变化，然后我们注意到 dU^T U 是一个斜矩阵。(类似的论点适用于右奇异向量 V)
最后，利用斜矩阵的性质，我们将 dU 定义如下。(请注意，类似的论点也适用于 V。)
步骤 2 使用正交补码推进属性
我们的原始矩阵 U 的维数为(9000，3)，现在我们要创建一个形状为(9000，8997)的正交补矩阵。如果我们将两个矩阵都附加到轴 1 上，我们会得到一个形状为(9000，9000)的正交矩阵。
红框→U 的正交补矩阵的形状
蓝框→U 与正交补 U 之间的附加矩阵的形状，表示单位矩阵的性质。
然后导数杜灿被展开，看起来像下面这样。
其中 dKu 是形状为(8997，3)的无约束矩阵。有关为什么会发生这种情况的详细信息，请点击此处。
**目前我还不完全理解为什么上述属性成立，但是它确实有意义。在执行 SVD 时，我们没有计算完整的矩阵，但是原始矩阵 A 由奇异值为 s 的奇异向量 U 和 V 中的所有元素组成。因此，当我们通过 SVD 反向传播时，我们也需要考虑它们。之所以需要 U 的正交补矩阵，是因为全矩阵 U 是正交矩阵。
第三步求奇异值分解关于 A 的微分，并按摩方程
现在，如果我们对 SVD 对变量 A 求导，注意，全微分是由对 U，S 和 v 的偏导数得到的。
让我们用 transpose(U)左乘上面的函数，用 V 右乘，得到下面的函数。
步骤 4 利用反对称矩阵的性质
让我们首先把等式的右边改写成上面这样。接下来，我们注意到 dωU 和 dωV 都是反对称矩阵，因此它们的对角线值将为零。使得 dP 的对角线值只与 dS 项有关，这个关系可以写成如下。
现在让我们考虑非对角的情况，首先我要声明一个与单位矩阵相反的项。 其中每一个对角元素都是 0，其他地方都是 1。(我将用 I 来表示这一项，上面有一个横杠。)
注意使用反对称矩阵和对角矩阵的性质，我们可以用公式表示上面的方程。
当我们转置 dP 项时，我们会得到如下结果。(dP^T)
最后，当我们将 dP 右乘 s，左乘 dP^T，并将两项相加，我们会得到如下结果。
如果写得更正式一些，它看起来会像下面这样。
最后，dωU 可通过以下等式求解。
使用类似的逻辑，我们也可以求解 dωV。
步骤 4 求无约束矩阵 dKu
让上面的等式与 u 的正交补码的转置相乘。
红框 →利用 U 和 U 的正交补码之间的点积为零的事实，从而抵消
蓝星 →利用正交矩阵的逆是它的转置这一事实。
让我们一步一步地在代码中看到上述事实。
绿框 →我们将用来消除 U 的正交补的重要性质
上面可以看到使红框为真的属性，此外，请查看绿框属性。
上面可以看到使蓝框为真的属性。
第五步利用最终性质推导偏导数
最后，利用上面看到的性质，我们将得到偏导数。让我们首先收集我们需要解决的所有术语。
现在让我们把上面我们已经解决的所有术语收集起来。
代入所有的项，我们最终得到我们的方程。
这篇博文的代码
对于谷歌实验室，你需要一个谷歌帐户来查看代码，你也不能在谷歌实验室运行只读脚本，所以在你的操场上做一个副本。最后，我永远不会请求允许访问你在 Google Drive 上的文件，仅供参考。编码快乐！
要获取这篇博文的代码，请点击这里。
遗言
最后，我想提一下我知道的另外两篇论文(一篇来自 CVPR 的文章)计算 SVD 的导数。我知道这些文件存在，但是我没有深入研究这些文件。
paper from this website
Paper from this website
Paper from this website
参考
- (2018).Arxiv.org。检索于 2018 年 11 月 19 日，来自https://arxiv.org/pdf/1509.07838.pdf
- (2018).j-towns . github . io . 2018 年 11 月 19 日检索，来自https://j-towns.github.io/papers/svd-derivative.pdf
- (2018).Web.mit.edu。检索于 2018 年 11 月 19 日，来自http://web.mit.edu/18.06/www/Essays/newpaper_ver3.pdf
- (2018).Arxiv.org。检索于 2018 年 11 月 20 日，来自https://arxiv.org/pdf/1509.07838.pdf
- (2018).People.maths.ox.ac.uk 检索 2018 年 11 月 20 日，来自http://people.maths.ox.ac.uk/gilesm/files/NA-08-01.pdf
- (2018).Hal.inria.fr 于 2018 年 11 月 20 日检索，来自https://hal.inria.fr/inria-00072686/document
- Anon，(2018)。[在线]见:https://www . quora . com/What-is-the-difference-between-columns-and-rows【2018 年 11 月 20 日获取】。
- 正交补码|交替坐标系(基)|线性代数|可汗学院。(2018).YouTube。检索于 2018 年 11 月 20 日，来自https://www.youtube.com/watch?v=QOTjdgmNqlg
- 正交补码。(2018).YouTube。检索于 2018 年 11 月 20 日，来自 https://www.youtube.com/watch?v=Kpc5ELrOt5E
- ENH: linalg 助手:matrix Issue # 3039 stats models/stats models 的正交补充。(2018).GitHub。检索于 2018 年 11 月 20 日，来自 https://github.com/statsmodels/statsmodels/issues/3039
- 反对称矩阵。(2018).En.wikipedia.org。检索于 2018 年 11 月 21 日，来自https://en.wikipedia.org/wiki/Skew-symmetric_matrix
- (2018).Math.mit.edu。检索于 2018 年 11 月 21 日，来自http://math . MIT . edu/~ Edelman/publications/geometry _ of _ algorithms . pdf
构建您自己的“迷你 IMDB”数据库的分步指南
如何使用简单的 Python 库和内置功能从 web 中抓取电影信息，并将其存储在本地 SQLite 数据库中。
Photo by Charles Deluvio 🇵🇭🇨🇦 on Unsplash
在学习了几门 Python 入门课程后，初学者常常想知道如何编写一个很酷的 Python 程序，展示该语言的一些高级功能，如 web 抓取或数据库操作。在本文中，我将展示如何使用简单的 Python 库和内置功能来抓取 web 上的电影信息，并将它们存储在本地 SQLite 数据库中，稍后可以使用电影信息查询该数据库进行数据分析。请将此视为构建您自己的迷你 IMDB 数据库的项目！
这种类型的数据工程任务——从网络上收集数据并建立数据库连接——通常是数据分析项目的第一步。在你做任何酷的预测建模之前，你需要掌握这一步。这一步通常是杂乱无章的，也就是说，没有一步到位的公式或一站式商店为你做所有的事情。所以，你必须从网络中提取数据，检查它的结构，并构建你的代码来完美地浏览它。
具体来说，本演示将展示以下功能的用法:
- Python urllib 库
- Web API 服务(带密钥)用于检索数据
- Python json 库
- Python OS 模块
- Python SQLite 库
下面给出了这些的简要描述，
Python urllib 模块
Python 到 web 的网关是通过 urllib 模块完成的。它是一个用于获取 URL(统一资源定位器)的 Python 模块。它以 urlopen 函数的形式提供了一个非常简单的接口。这能够使用各种不同的协议获取 URL。它还提供了一个稍微复杂一点的接口来处理常见情况——比如基本身份验证、cookies、代理等等。这些是由称为处理程序和打开程序的对象提供的。
Web API 服务(带密钥)用于检索数据
Web 抓取通常由外部网站托管的 API 服务来完成。可以把它们想象成存储库或远程数据库，您可以通过自己的小程序发送搜索字符串来查询它们。在这个特定的例子中，我们将从开放电影数据库(OMDB)网站获得帮助，该网站向注册用户提供 API 密钥，用于下载电影信息。因为这是一项免费服务，他们每天有 1000 个请求的限制。请注意，您必须在他们的网站上注册，并获得自己的 API 密钥，以便从您的 Python 程序发出请求。
从这个 API 服务获得的数据以 JSON 文件的形式返回。因此，我们需要将 JSON 文件解析/转换成一个 Python 对象，这样我们就可以轻松地工作了。
Python json 模块
JSON 是一种轻量级的数据交换格式。对人类来说，读和写很容易。机器很容易解析生成。它基于 JavaScript 编程语言，标准 ECMA-262 第三版——1999 年 12 月。JSON 是一种完全独立于语言的文本格式，但是它使用了 C 语言系列的程序员所熟悉的约定，包括 C、C++、C#、Java、JavaScript、Perl、Python 和许多其他语言。这些特性使 JSON 成为理想的数据交换语言。
json 库可以从字符串或文件中解析 JSON 页面。该库将 JSON 解析成 Python 字典或列表。它还可以将 Python 字典或列表转换成 JSON 字符串。这是一个非常有用的模块，学习起来非常简单。这个模块很可能在任何基于 Python 的 web 数据分析程序中使用，因为现在大多数网页在返回数据时使用 JSON 作为主要对象类型。
Python 操作系统模块
该模块提供了一种使用操作系统相关功能的可移植方式。如果你只是想读或写一个文件，参见[open()](https://docs.python.org/3/library/functions.html#open)，如果你想操作路径，参见[os.path](https://docs.python.org/3/library/os.path.html#module-os.path)模块，如果你想在命令行上读取所有文件中的所有行，参见[fileinput](https://docs.python.org/3/library/fileinput.html#module-fileinput)模块。创建临时文件和目录见[tempfile](https://docs.python.org/3/library/tempfile.html#module-tempfile)模块，高级文件和目录处理见[shutil](https://docs.python.org/3/library/shutil.html#module-shutil)模块。在这个演示中，我们将使用操作系统模块方法来检查现有的目录，并操作文件来保存一些数据。
SQLite 和 Python SQLite3
SQLite 是一个 C 库，它提供了一个轻量级的基于磁盘的数据库，不需要单独的服务器进程，并允许使用 SQL 查询语言的非标准变体来访问数据库。一些应用程序可以使用 SQLite 进行内部数据存储。还可以使用 SQLite 构建应用程序原型，然后将代码移植到更大的数据库，如 PostgreSQL 或 Oracle。Python 的 sqlite3 模块提供了符合 DB-API 2.0 规范的 SQL 接口。
程序的主要流程
程序的流程如下所示。请注意 锅炉板块代码在我的 Github 资源库 中有 。喜欢的请下载/叉/星。
Fig: Main flow of the program
基本思想是向外部 API 发送带有用户输入的电影标题的请求。然后，该程序试图下载数据，如果成功，打印出来。
def search_movie(title):
if len(title) < 1 or title==’quit’:
print(“Goodbye now…”)
return Nonetry:
url = serviceurl + urllib.parse.urlencode({‘t’: title})+apikey
print(f’Retrieving the data of “{title}” now… ‘)
uh = urllib.request.urlopen(url)
data = uh.read()
json_data=json.loads(data)
if json_data[‘Response’]==’True’:
print_json(json_data)except urllib.error.URLError as e:
print(f"ERROR: {e.reason}")
例如，JSON 文件如下所示:
Fig: An example JSON file retrieved from the API.
如果程序找到了电影海报的图像文件的链接，它会询问用户是否想下载它。如果用户同意，它会将图像文件下载到本地目录，并以电影标题作为文件名。
# Asks user whether to download the poster of the movie
if json_data['Poster']!='N/A':
poster_yes_no=input ('Poster of this movie can be downloaded. Enter "yes" or "no": ').lower()
if poster_yes_no=='yes':
save_poster(json_data)
接下来，它询问用户是否想在本地数据库中保存一些关于电影的基本信息。如果用户点头，它将创建或插入一个 SQLite 数据库中下载电影信息的子集。
#Asks user whether to save the movie information in a local databasesave_database_yes_no=input ('Save the movie info in a local database? Enter "yes" or "no": ').lower()if save_database_yes_no=='yes':
save_in_database(json_data)
下面是要保存在数据库中的函数定义。
笔记本还包含将现有数据库中的信息保存为 Excel 文件的功能。
关于秘密 API 密匙的一句话
您会注意到程序使用一个秘密的 API 密钥来访问数据。该密钥可以通过访问 OMDB 网站免费获得，每天最多可使用 1000 次。使用秘密(特定于用户的)密钥进行 web 抓取是一种非常常见的做法。我保护个人 API 密匙完整性的方法是在 Jupyter 笔记本的同一个目录下创建一个小 JSON 文件，名为 APIkeys.json 。该文件的内容对将看到我的代码的外部用户是隐藏的。我的 Jupyter 笔记本将这个 JSON 文件作为字典读取，复制对应于电影网站的密钥，并将其附加到由urllib.request方法发送的编码 URL 请求字符串。
with open(‘APIkeys.json’) as f:
keys = json.load(f)
omdbapi = keys[‘OMDBapi’]serviceurl = '[http://www.omdbapi.com/?'](http://www.omdbapi.com/?')
apikey = '&apikey='+omdbapi
摘要
本文通过一个演示 Python 笔记本来说明如何使用免费的 API 服务检索关于电影的基本信息，并将电影海报和下载的信息保存在一个轻量级 SQLite 数据库中。
最重要的是，它演示了 Python 库的简单使用，如 urllib、json 和 sqlite3 ，这些库对于数据分析/ web 数据挖掘任务来说是非常有用(和强大)的工具。
我希望读者可以从提供的笔记本文件中受益，并根据自己的要求和想象来构建它。更多网络数据分析笔记本， 请看我的知识库。
如果您有任何问题或想法要分享，请联系作者在tirthajyoti【AT】Gmail . com。你也可以查看作者的 GitHub 资源库 中其他有趣的 Python、R 或 MATLAB 代码片段和机器学习资源。如果你像我一样对机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。
寻找神经网络的成本函数
一步一步:神经网络背后的数学
Title image: Source
特伦斯·帕尔和杰瑞米·霍华德的论文， 深度学习所需的矩阵演算 ，提供了很多关于深度学习库(如 Tensorflow 或 PyTorch)如何真正工作的见解。如果不理解深度学习背后的数学，我们所做的只是编写几行抽象代码——建立模型，编译它，训练它，评估它——而没有真正学会欣赏支持所有这些功能的所有复杂的错综复杂之处。
这篇(以及接下来的几篇)文章将是我从 Terence 和 Jeremy 的论文中学到的思考。本文将介绍这个问题，我们将在接下来的文章中解决它。我将解释大部分的数学知识，并加入一些我的见解，但要了解更多信息，请查看原始论文。
这些文章(和论文)都假设了高中水平的微积分基础知识(即导数规则和如何应用它们)。如果你想重温的话，可以看看可汗学院的视频。
这就是我们的问题。我们有一个只有一层(为了简单起见)和一个损失函数的神经网络。这一层是一个简单的全连接层，只有一个神经元，许多权重 w₁，w₂，w₃ …，一个偏置 b ，以及一个 ReLU 激活。我们的损失函数是常用的均方误差(MSE)。知道了我们的网络和损失函数，我们如何调整权重和偏差来最小化损失？
为了减少损失，我们使用梯度下降的概念。正如这里的所解释的(如果你不熟悉梯度下降的工作原理，请阅读此处)，梯度下降计算损失函数的斜率，然后根据该斜率将权重和偏差转移到更低的损失。
Image 1: Shifting the weights and biases of to minimize loss
我们需要找到损失函数的斜率。然而，在此之前，让我们定义一下损失函数。MSE 简单地平方每个网络输出和真实标签之间的差，并取平均值。下面是 MSE 方程，其中 C 是我们的损失函数(也称为代价函数)， N 是训练图像的数量， y 是真实标签的向量(y=【目标( x ₁ )，目标(x₂)…目标(【t28)(如果你还没有注意到，粗体字中的变量是向量。)
Image 2: Loss function
我们可以进一步扩展这个等式。网络输出是什么？我们将一个向量输入——姑且称之为x——给我们的全连接层。该层的激活是我们的网络输出。我们的全连接层的激活是什么？向量输入中的每一项都乘以一定的权重。然后，将所有这些产品加在一起，并在此基础上添加一个偏差。最后，该值通过 ReLu 传递，形成全连接层中一个神经元的激活。
Image 3: Fully-connected layer, expanded. The orange circles are the input values, the blue circle is the output value (the prediction, since our network only has 1 layer), and the gray circles are just intermediate values used in the calculation. Each red line represents multiplication by a certain weight, the pink lines represent summing up all the values, and the green line represents addition with a certain bias.
对每个输入值和每个权重的乘积求和，本质上是输入 x 和一个权重向量(姑且称之为 w )之间的向量点积。ReLU 只是一个将任何负值转换为 0 的函数。让我们将其重命名为 max(0，z) 函数，如果 z 为正，则返回 z，如果 z 为负，则返回 0。
综上所述，我们得到了神经元激活的方程式:
激活(x)= max(0，w∙x+b)
现在让我们把它代入损失函数。因为我们使用多个输入进行训练，所以让我们将 X 定义为所有输入的集合:
Image 4: X // Source
由于我们只有一层(有一个神经元)，这个神经元的激活就是我们模型的预测。因此，我们可以用我们的激活 in 代替损失函数中的 o :
Image 5: Loss function with activation substituted in
然后替换激活函数:
Image 6: Loss function
这是我们要求斜率的损失函数。
为了找到斜率，我们必须找到损失函数的导数。然而，不是任何导数，它必须是相对于权重和偏差的偏导数(因为这些是我们正在调整的值)。
查看第 2 部分了解如何计算偏导数！
跳到其他文章:
这里下载原论文。
如果你喜欢这篇文章，别忘了留下一些掌声！如果您有任何问题或建议，请在下面留下您的评论:)
如何求函数的偏导数？
一步一步:神经网络背后的数学
Title image: Source
在第一部分中，我们被给了一个问题:计算这个损失函数的梯度:
Image 1: Loss function
求梯度本质上就是求函数的导数。然而，在我们的例子中，因为有许多我们可以调整的独立变量(所有的权重和偏差)，我们必须找到每个变量的导数。这就是所谓的偏导数，符号是∂.
偏导数:
计算简单函数的偏导数很容易:只需将方程中的其他变量视为常数，然后找到通常的标量导数。以下是一些标量导数规则作为提醒:
Image 2: Scalar derivative rules // Source
考虑函数 f(x，y) = 3x y 中关于 x 的偏导数(即 y 如何随着 x 的变化而变化)。将 y 视为常数，我们可以求出 x 的偏导数:
Image 3: Partial with respect to x
同样，我们可以找到 y 的偏导数:
Image 4: Partial with respect to y
函数 f(x，y) = 3x y 的梯度是一个水平向量，由两个分向量组成:
Image 5: Gradient of f(x,y) // Source
这应该很清楚:因为相对于 x 的偏导数是函数在 x 方向上的梯度，相对于 y 的偏导数是函数在 y 方向上的梯度，所以总梯度是由两个偏导数组成的向量。这个可汗学院的视频提供了一个非常简洁的偏导数的图形解释，如果你想形象化我们正在做的事情。
链规则:
对于像 f(x，y) = 3x y 这样的简单函数，我们只需要知道这些。然而，如果我们想要计算更复杂函数的偏导数——例如那些具有嵌套表达式的函数，如 max(0，w∙X+b)——我们需要能够利用多元链规则，在本文中称为单变量全导数链规则。
单变量链规则
我们先来回顾一下单变量链规则。考虑函数 y=f(g(x))=sin(x)。为了得到这个表达式的导数，我们将外部表达式的导数与内部表达式的导数相乘，或者“将各个部分连接在一起”。换句话说:
Image 6: Single-variable chain rule where u is the intermediate variable for nested subexpressions
对于我们的例子， u=x 和 y=sin(u) 。因此:
Image 7: Derivatives // Source
和
Image 8: Derivative of the whole expression // Source
把单变量链规则想象成 x 经过的操作图是很好的，就像这样:
Image 9: Diagram of chain of operations for y=sin(x²)
当处理多变量链式法则时，将方程可视化为图表的概念将会非常方便。此外，如果您使用 Tensorflow(或 Keras)和 TensorBoard，在您构建模型和编写训练代码时，您可以看到与此类似的操作图。
多变量链式法则
多变量链规则，也称为单变量全导数链规则，如文中所称，是标量链规则的变体。与它的名字所暗示的不同，它可以应用于只有一个变量的表达式。但是，表达式应该有多个中间变量。
为了说明这一点，让我们考虑等式 y=f(x)=x+x 。使用标量附加导数规则，我们可以立即计算导数:
Image 10: Derivative of x+x²
让我们试着用链式法则来做。首先，我们引入中间变量: u₁(x) = x 和 u₂(x，u₁) = x + u₁.如果我们应用单变量链规则，我们得到:
Image 11: Using the single-variable chain rule
很明显，2x≠1+2x，所以这里有问题。让我们画出方程式的图表:
Image 12: Diagram of chain of operations for y = x+x² // // Source
图 12 中的图不再是线性的，所以我们必须考虑图中所有导致最终结果的路径。由于 u₂ 有两个参数，偏导数开始起作用。为了计算这个函数的导数，我们必须计算关于 u₁). u₂(x的 x 的偏导数这里， x 的变化以两种方式反映在 u₂ 中:作为加法的操作数和作为平方运算符的操作数。在符号中，ŷ=(x+δx)+(x+δx)和δy = ŷ-y，其中 ŷ 是调整后的 x. 处的 y 值
因此，为了计算 u₂(x，u₁) 的偏差值，我们需要合计从 x 的变化到 y 的变化的所有可能的贡献。 u₂(x，u₁) 的总导数由下式给出:
Image 13: Derivative of y = x+x² // Source
更简单地说，你把 x 的变化直接对 u₂的影响和 x 的变化通过 u₁对 u₂.的影响加起来我发现通过图表更容易形象化:
Image 14: Graph of y = x+x², with partials included
就是这样！我们得到了正确答案:1+2x。我们现在可以用一个规则来概括这个过程，即多变量链式规则(或单变量全导数链式规则):
Image 15: Multivariable chain rule // Source
如果我们为 x 引入一个别名，如 x=u(n+1)，那么我们可以将公式改写成最终形式，这样看起来更简洁:
Image 16: Multivariable chain rule // Source
仅此而已！复习一下，我们再做一个例子: f(x)=sin(x+x ) 。我们的 3 个中间变量是: u₁(x) = x，u₂(x，u₁)=x+u₁，和 u₃(u₂) = sin(u₂) 。我们可以再次绘制图表:
Image 17: Graph of y = sin(x+x²), with partials included
计算我们的偏角:
Image 18: Partials for the function y = sin(x+x²)
因此 f(x)=sin(x+x ) 的导数为 cos(x+x )(1+2x) 。
这和我们的问题有什么关系？记住，我们需要找到损失函数相对于 w (我们所有权重的向量)和 b (偏差)的偏导数。然而，我们的损失函数并不那么简单——有多个嵌套的子表达式(即多个中间变量)需要我们使用链规则。
Image 19: Loss function
还有一个问题。如你所见，我们的损失函数不仅仅接受标量作为输入，它也接受向量。如何计算向量方程的偏导数，向量链规则是什么样的？
看看第三部就知道了！
如果你还没有，点击这里阅读第 1 部分！
跳到其他文章:
此处下载原文。
如果你喜欢这篇文章，别忘了留下一些掌声！如果您有任何问题或建议，请在下面留下您的评论:)
求向量函数的梯度
一步一步:神经网络背后的数学
Title image: Source
在第一部分中，我们被给了一个问题:计算这个损失函数的梯度:
Image 1: Loss function
为了求梯度，我们必须求函数的导数。在第二部分中，我们学习了如何计算函数对每个变量的偏导数。然而，这个损失函数中的大部分变量都是向量。当神经网络处理大量数据时，能够找到向量变量的偏导数尤其重要。向量和矩阵运算是一种简单的方法来表示有这么多数据的运算。确切地说，你怎样才能找到一个向量函数的梯度呢？
标量函数的梯度
假设我们有一个函数， f(x，y) = 3x y 。我们的偏导数是:
Image 2: Partial derivatives
如果我们把这些分音组织成一个水平向量，我们得到 f(x，y) 的梯度，或者 ∇ f(x，y) :
Image 3: Gradient of f(x,y)
6yx 是 f(x，y) 相对于 x 的变化，而 3x 是 f(x，y) 相对于 y 的变化。
当我们有两个函数时会发生什么？让我们添加另一个函数， g(x，y) = 2x+y⁸ 。偏导数是:
Image 4: Partials for g(x,y)
所以 g(x，y)的梯度是:
Image 5: Gradient of g(x,y)
表示函数
当我们有一个带有多个参数的函数时，用一种更简单的方式来表示它们通常是有用的。我们可以将函数的多个参数组合成一个向量自变量， x ，如下所示:
Image 6: Vector x
因此， f(x，y，z) 会变成 f(x₁,x₂,x₃) 从而变成 f( x )。
我们也可以将多个函数组合成一个向量，就像这样:
Image 7: Vector y
现在， y=f(x) 其中 f(x) 是【f₁( x 、f₂( x 、f₃( x )…fn( x )】的向量
对于我们前面的两个函数的例子， f(x，y)f(x)和 g(x，y)g(x)。此处，向量x=【x₁，x₂】，其中 x₁=x ，以及 x₂=y 。为了进一步简化，我们可以将我们的函数组合起来:[f( x )、g( x )] = [f₁( x )、f₂(x)]=f(x)= y .
Image 8: Equations within vector function y
通常，函数的数量和变量的数量是相同的，因此每个变量都有一个解。
向量函数的梯度
现在有了两个函数，怎么求两个函数的梯度呢？如果我们把它们的梯度组织成一个单一的矩阵，我们就从向量演算进入了矩阵演算。这个矩阵以及具有多个变量的多个函数的梯度的组织被称为雅可比矩阵。
Image 9: The Jacobian
有多种方法来表示雅可比矩阵。这种布局，我们垂直堆叠渐变，被称为分子布局，但其他论文将使用分母布局，它只是对角翻转:
Image 10: Denominator layout of the Jacobian
恒等函数的梯度
我们取恒等式函数， y = f(x) = x ，其中fi(x)= Xi，求其梯度:
Image 11: Identity function
正如我们创建之前的雅可比矩阵一样，我们可以找到每个标量函数的梯度，并将它们垂直堆叠起来，以创建恒等函数的雅可比矩阵:
Image 12: Jacobian of the identity function
既然是恒等函数，f₁( x ) = x₁，f₂( x ) = x₂，以此类推。因此，
Image 13: Jacobian of the identity function
函数对不在函数中的变量的偏导数为零。比如 2x 对 y 的偏导数是 0。换句话说，
Image 14: The partial derivative of a function with respect to a variable that’s not in the function is zero
因此，不在雅可比对角线上的一切都变为零。同时，任何变量对自身的偏导数都是 1。例如， x 相对于 x 的偏导数为 1。因此，雅可比就变成了:
Image 15: Jacobian of the identity function
元素式向量函数组合的梯度
基于元素的二元运算符是连续应用运算符的运算(如加法 w + x 或 w > x ，从两个向量的第一项开始获得第一项输出，然后从两个向量的第二项获得第二项输出……依此类推。
本文用以下符号表示元素式二元运算:
Image 16: Element-wise binary operation with f(x) and g(x)
这里，◯指的是任何元素操作符(比如+)，而不是函数的组合。
那么如何找到两个向量的元素运算的梯度呢？
由于我们有两组函数，我们需要两个雅可比矩阵，一个表示相对于 x 的梯度，一个表示相对于 w 的梯度:
Image 17: Jacobian with respect to w and x
我们需要的大多数算术运算都很简单，所以 f(w) 通常就是向量 w 。换句话说， fi(wi) = wi 。例如，操作 w+x 符合这一类别，因为它可以表示为 f(w)+g(x) ，其中 fi(wi) + gi(xi) = wi +xi。
在这种情况下，两个雅可比矩阵中的每个元素都简化为:
Image 18: Elements in the Jacobian
在对角线上，i=j，所以偏导数存在一个值。然而，离开对角线，i≠j，所以偏导数变为零:
Image 19: Diagonal jacobian
我们可以更简洁地表示为:
Image 20: The Jacobian with respect to w and x
我们试着求函数 w+x 的梯度。我们知道对角线以外的一切都是 0。对角线上相对于 w 和 x 的分数值为:
Image 21: Partials with respect to w and x
所以两个雅可比行列式的对角线都是 1。这看起来很熟悉…这是单位矩阵！
我们用乘法来试试: w*x 。对角线上相对于 w 和 x 的分数值为:
Image 22: Partials with respect to w and x
因此， w*x 相对于 w 的梯度为diag(x)，而 w*x 相对于 x 的梯度为 diag( w )。
用同样的步骤做减法和除法，我们可以总结出:
Image 23: Gradients of common element-wise binary operations
向量和的梯度
深度学习中最常见的运算之一就是求和运算。如何求函数y = sum(x)的梯度？
y = sum()x)也可以表示为:
Image 24: y=sum(x)
因此，梯度可以表示为:
Image 25: Gradient of y=sum(x)
因为函数对不在函数中的变量的偏导数为零，所以可以进一步简化为:
Image 26: Gradient of y=sum(x)
请注意，结果是一个水平向量。
y = sum(xz)的梯度呢？唯一的区别是我们用常数 z 乘以每个偏导数:
Image 27: Gradient of y=sum(xz) with respect to x
虽然这是相对于 x 的导数，但是相对于标量 z 的导数仅仅是一个数字:
Image 28: Gradient of y=sum(xz) with respect to z
链式法则向量函数组合的梯度
在第二部分中，我们学习了多变量链式法则。然而，这只对标量有效。让我们看看如何将它整合到矢量计算中！
让我们取一个向量函数， y = f (x) ，求它的梯度。让我们将该函数定义为:
Image 29: y = f(x)
f₁(x) 和 f₂(x) 都是复合函数。让我们为 f₁(x) 和 f₂(x) 引入中间变量，并重写我们的函数:
Image 30: y = f(g(x))
现在，我们可以使用多变量链式法则来计算矢量 y 的导数。简单计算 f₁(x) 和 f₂(x) 的导数，并将它们一个放在另一个上面:
Image 31: Gradient of y = f(g(x))
瞧啊。我们有梯度。然而，我们已经用标量规则得出了我们的解决方案，仅仅是将数字组合成一个向量。有没有办法表示向量的多变量链式法则？
现在，我们的梯度计算如下:
Image 32: Gradient of y = f(g(x))
注意， f₁(x) 和 f₂(x) 的梯度的第一项都包括 g₁ 对 x 的部分，而 f₁(x) 和 f₂(x) 的梯度的第二项都包括 g₂ 对 x 的部分。这就跟矩阵乘法一样！因此，我们可以将其表示为:
Image 33: Vector representation of the gradient of y = f(g(x))
让我们测试一下向量链规则的新表示:
Image 34: Vector chain rule
我们得到与标量方法相同的答案！如果我们有一个向量参数 x 而不是单个参数 x ，我们只需要稍微改变一下规则就可以得到完整的向量链规则:
Image 35: Vector chain rule
换句话说:
Image 36: Vector chain rule
在我们上面的例子中， f 纯粹是 g 的函数；即 fi 是 gi 而不是 gj 的函数(每个函数 f 恰好匹配 1 个函数 g ) )。在这种情况下，对角线以外的一切都变为零，并且:
Image 37: Special case of vector chain rule
现在我们有了我们开始系列时找到的神经网络梯度的所有部分:
Image 38: Cost function
查看第 4 部分了解如何计算其导数！
如果您还没有，请阅读第 1 和第 2 部分:
大结局请看第四部！
点击下载原文。
如果你喜欢这篇文章，别忘了留下一些掌声！如果您有任何问题或建议，请在下面留下您的评论:)
教程:带随机梯度下降的线性回归
Photo by Lindsay Henwood on Unsplash
在 JavaScript 中实现反向传播
你可以在这里 找到反向传播演示 。
这篇文章应该为我们深入研究深度学习提供了一个良好的开端。让我带你一步一步地计算使用随机梯度下降的线性回归任务。
A short YouTube clip for the backpropagation demo found here
内容
2。 实现 2.1正向传播
2.1.1 初始化权重(一次性)
2.1.2 进给数据
2.1.3 计算ŷ2 . 2 . 1
1 准备
1.1 数据
我们有一些数据:当我们观察自变量 x ₁和 x ₂时，我们也观察因变量(或响应变量) y 。
在我们的数据集中，我们有 6 个例子(或观察)。
**x1 x2 y**
**1)** 4 1 2
**2)** 2 8 -14
**3)** 1 0 1
**4)** 3 2 -1
**5)** 1 4 -7
**6)** 6 7 -8
1.2 模型
下一个要问的问题是:“₁和₂是如何联系在一起的？”
我们认为它们通过以下等式相互联系:
我们今天的工作是找到“最佳”w 和 bb值。
我用过深度学习约定 w 和 b ，分别代表 权重 和 偏差 。但是注意线性回归不是深度学习。
1.3 定义损失函数
假设在本练习结束时，我们已经算出我们的模型是
我们如何知道我们的模型做得好不好？
我们简单地通过一个损失函数比较预测的 ŷ 和观测的 y 。 有很多方法来定义损失函数，但在本文中，我们将其定义为 ŷ 和 y 的平方差。
一般来说 L 越小越好。
1.4 最小化损失功能
因为我们希望 ŷ 和 y 之间的差异很小，所以我们希望努力将其最小化。这是通过随机梯度下降优化完成的。它基本上是使用梯度值迭代更新 w ₁和 w ₂的值，如下式所示:
Fig. 2.0: Computation graph for linear regression model with stochastic gradient descent.
该算法试图通过不断更新来找到正确的权重，记住我们正在寻找最小化损失函数的值。
直觉:随机梯度下降
你是 w 你在一个图上(损失函数)。你现在的值是 w =5。你想移到图中的最低点(最小化损失函数)。
你也知道，用你当前的值，你的梯度是 2。你必须以某种方式利用这个价值继续生活。
根据高中数学，2 意味着你在一个倾斜的斜坡上，你能下来的唯一方法就是向左移动，在这一点上。
如果走 5+2 意味着你要去右边爬上斜坡，那么唯一的方法就是走 5–2，它会把你带到左边，向下。所以梯度下降就是从当前值中减去梯度值。
2.履行
我们的模型的工作流程很简单:前向传播(或前馈或前向传递)和反向传播。
定义:训练 训练简单来说就是定期更新你的权值。
下面是工作流程。单击以跳转到该部分。
— — — —
2.1 正向传播
2.1.1 初始化权重(一次性)
2.1.2 进给数据
2.1.3 计算ŷ2 . 1 . 4计算损耗
2.2 反向传播
2.2.1 计算偏导数
2.2.2 更新权重
— — — — — — — — —
让我们开始吧。
为了跟踪所有的值，我们首先构建一个“计算图”,其中包含了用颜色编码的节点
- 橙色 — 占位符( x ₁、 x ₂和 y )，
- 深绿色 — 重量和偏差( w ₁， w ₂和 b )，
- 浅绿色 — 型号 ( ŷ )连接 w ₁、 w ₂、 b 、 x ₁、 x ₂，以及
- 黄色—损失函数 ( L )连接 ŷ 和 y.
Fig. 2.0: Computation graph for linear regression model with stochastic gradient descent.
对于正向传播，您应该从上到下阅读此图，对于反向传播，您应该从下到上阅读。
注 我采用了“占位符”这个术语，这个术语在tensor flow中用来指代这些“数据变量”。
我也将使用术语“重量”来统称 w 和 b 。
2.1 正向传播
2.1.1 初始化砝码(一次性)
因为梯度下降是关于更新权重的，我们需要它们从一些值开始，称为初始化权重。
这里我们初始化权重和偏差如下:
这些反映在下面图 2.1.1 中的深绿色节点中:
Fig. 2.1.1: Weights initialised (dark green nodes)
有许多初始化权重的方法(0、1、均匀分布、正态分布、截断正态分布等)。)但我们不会在本帖中涉及它们。在本教程中，我们通过使用截尾正态分布和偏差为 0 来初始化权重。
进料数据
接下来，我们将批量大小设置为 1，并输入第一批数据。
批次和批次大小
我们可以将数据集分成大小相等的小组。每组称为一个，由指定数量的样本组成，称为 批量 。如果我们将这两个数字相乘，我们应该可以得到数据中的观察次数。
在这里，我们的数据集由 6 个示例组成，由于我们在本次培训中将批次大小定义为 1，因此我们总共有 6 个批次。
用于输入模型的当前数据批次在下面以粗体显示:
***x1 x2 y**
**1) 4 1 2**
**2)** 2 8 -14
**3)** 1 0 1
**4)** 3 2 -1
**5)** 1 4 -7
**6)** 6 7 -8*
Eqn. 2.1.2: First batch of data fed into model
在图 2.1.2 中，橙色节点是我们输入当前一批数据的地方。
Fig. 2.1.2: Feeding data to model with first batch (orange nodes)
2.1.3 计算 ŷ
现在我们已经有了 x ₁、 x ₂、 w ₁、 w ₂和 b 的值，让我们计算 ŷ.
Eqn. 2.1.3: Compute ŷ
ŷ (=-0.1)的值反映在下面的浅绿色节点*中:*
Fig. 2.1.3: ŷ computed (light green node)
计算损失
我们预测的 ŷ 与给定的 y 数据有多远？我们通过计算前面定义的损失函数来比较它们。
Eqn. 2.1.4: Compute the loss
您可以在计算图的黄色节点中看到该值。
Fig. 2.1.4A: L computed (yellow node)
通常的做法是记录训练期间的损失，以及其他信息，如纪元、批次和花费的时间。在我的演示中，您可以在训练进度面板下看到这一点。
Fig. 2.1.4B: Logging loss and other information
2.2 反向传播
计算偏微分
在我们开始调整权重和偏差 w ₁、 w ₂和 b 的值之前，让我们首先计算所有的偏差值。这些是我们稍后更新权重时需要的。
Fig. 2.2.1: Indicated partial differentials to the relevant edges on the graph
也就是说，我们只计算通向每个 w 和 b 的所有可能路径，因为这些是我们唯一感兴趣更新的变量。从上面的图 2.2.1 中，我们看到有 4 条边被标上了偏导数。
回想一下模型和损失函数的等式:
Model
Loss function
部分差异如下:
L ( 黄色)——ŷ(浅绿色* ) :*
Eqn. 2.2.1A: Partial differential of L w.r.t. ŷ
ŷ ( 浅绿色)——b(深绿色*)😗
Eqn. 2.2.1B: Partial differential of ŷ w.r.t. b
ŷ ( 浅绿色)——w₁(深绿色*)😗
Eqn. 2.2.1C: Partial differential of ŷ w.r.t. w1
ŷ ( 浅绿色)——w₂(深绿色*)😗
Eqn. 2.2.1D: Partial differential of ŷ w.r.t. w2
注意，偏微分的值遵循当前批次中的值。例如，在等式 2 中。2.2.1C， x ₁ = 4。
更新权重
观察下图 2.2.2 中的深绿色节点。我们看到三样东西:
i) b 从 0.000 变化到 0.212
ii) w ₁从-0.017 变化到 0.829
iii) w ₂从-0.048 变化到 0.164
Fig. 2.2.2: Updating the weights and bias (dark green nodes)
还要注意从黄色节点到绿色节点的路径的“方向”。他们从下往上走。
这是随机梯度下降-使用反向传播更新权重，利用各自的梯度值。
先重点更新一下 b 。更新 b 的公式为
Eqn. 2.2.2A: Stochastic gradient descent update for b
在哪里
- b—当前值**
- b’—更新后的值**
- η — 学习率，设置为 0.05
- ∂L/∂b — 梯度，即 L w.r.t. b 的偏微分
为了得到梯度，我们需要使用链式法则将从 L 到 b 的路径相乘:**
Eqn. 2.2.2B: Chain rule for partial differential of L w.r.t. b
我们将需要当前批次值 x 、 y、ŷ 和偏差值，因此我们将它们放在下面以便于参考:
Eqn. 2.2.2C: Partial differentials
Eqn. 2.2.2D: Values from current batch and the predicted ŷ
使用方程中的随机梯度下降方程。2.2.2A 并代入方程中的所有值。2.2.2B-D 为我们提供了:
更新 b 到此为止！唷！我们只剩下更新 w ₁和 w ₂，我们以类似的方式更新它们。
批处理迭代结束
恭喜你。处理第一批就这样！
*****x1 x2 y**
**1)** 4 1 2 ✔
**2)** ** 2 8 -14
3) 1 0 1
4) 3 2 -1
5) 1 4 -7
6) 6 7 -8*****
现在我们需要将上述步骤重复到其他 5 个批次，即实施例 2 至 6。
Iterating through batch 1 to 6 (apologies for the poor GIF quality! )
时代结束
当模型已经遍历所有批次一次时，我们完成 1 个时期。在实践中，我们将纪元扩展到大于 1。
一个 历元 是当我们的设置已经看到了 所有 在我们的数据集中的观察值一次。但是一个纪元几乎永远不足以让损失收敛。实际上，这个数字是手动调整的。
在这一切结束时，你应该得到一个最终的模型，准备好进行推理，比如说:
让我们用伪代码来回顾一下整个工作流程:
***initialise_weights()for i in epochs: for j in batches: #forward propagation
feed_batch_data()
compute_ŷ()
compute_loss() #backpropagation
compute_partial_differentials()
update_weights()***
改善培训
对于随机梯度下降优化问题，一个历元是远远不够的。记住在图 4.1 中，我们的亏损在 4.48。如果我们增加历元的数量，这意味着增加我们更新权重和偏差的次数，我们可以将其收敛到令人满意的低水平。
以下是您可以在培训中改进的地方:
- 将培训扩展到一个以上的时代
- 增加批量
- 改变优化器(见我关于梯度下降优化算法的帖子这里)
- 调整学习率(更改学习率值或使用学习率计划程序)
- 拿出一套火车价值测试装置
关于
我用 JavaScript 构建了一个交互式的可探索的线性回归演示。以下是我使用的库:
- Dagre-D3 (GraphViz + d3.js ),用于呈现图形
- 用于呈现数学符号的 MathJax
- 用于绘制折线图的图表
- jQuery
点击查看互动演示。
您可能还想看看下面的使用 TensorFlow 进行线性回归的一行一行的外行指南，该指南着重于使用 TensorFlow 库对线性回归进行编码。**
*** [## 使用 TensorFlow 进行线性回归的逐行外行指南
线性回归是机器学习之旅的一个良好开端，因为它非常简单明了…
medium.com](https://medium.com/datadriveninvestor/a-line-by-line-laymans-guide-to-linear-regression-using-tensorflow-3c0392aa9e1f)***
参考
*** [## 计算图上的微积分:反向传播——colah 的博客
反向传播是使训练深度模型在计算上易于处理的关键算法。对于现代神经…
colah.github.io](https://colah.github.io/posts/2015-08-Backprop/)
深度学习相关文章
逐行 Word2Vec 实现(关于单词嵌入)
图文并茂:自我关注***
关注我上Twitter@ remykarem 或者LinkedIn。你也可以通过 raimi.bkarim@gmail.com 联系我。欢迎访问我的网站remykarem . github . io。****
Google Dataproc 上的 PySpark 情感分析
一步一步的教程
Photo by Joshua Sortino on Unsplash
我最近有机会通过 Coursera 上的一个专业化课程来体验谷歌云平台；谷歌云平台专业化上的数据工程。总的来说，我通过这些课程学到了很多东西，这是一个在完成作业的同时免费尝试谷歌云平台(GCP)各种服务的好机会。尽管我目前在工作中没有使用 GCP 的任何服务，但如果有机会，我很乐意将我的部分数据工作迁移到 GCP。
然而，这门课程缺少的一点是你自己发挥创造力的空间。这门课的作业与其说是作业，不如说是辅导课。你基本上遵循已经写好的代码。当然，通过尝试阅读每一行代码并详细理解每一行的作用，您仍然可以学到很多东西。尽管如此，如果不把你学到的知识应用到你自己的问题解决中，就很难把这些知识完全变成你的。这也是讲师拉克·拉克什马南在课程结束时的建议。(对 Lak Lakshmanan 大喊，谢谢你们的精彩课程！)
*除了我将附上的简短代码块，你可以在本文末尾找到整个 Git 库的链接。
要求
在 GCP 上创建免费试用账户
所以我决定利用各种 GCP 服务做一些个人迷你项目。幸运的是，如果你还没有尝试过 GCP，谷歌慷慨地提供了一个免费试用，给你 300 美元的信用，你可以使用超过 12 个月。
You can easily start your free trial by visiting https://cloud.google.com/gcp/
我尝试的第一个项目是 Google Dataproc 上的 Spark 情绪分析模型训练。我选择它作为我在 GCP 的第一个项目有几个原因。在我之前的一篇文章中，我已经写了关于 PySpark 情绪分析的文章，这意味着我可以把它作为一个起点，轻松地把它变成一个独立的 Python 程序。另一个原因是我只是想试试 Google Dataproc！我被在 GCP 上运行一个集群的简单和快速迷住了，忍不住在 Coursera 课程之外尝试了一下。
如果您点击了“免费试用 GCP”，并填写了诸如您的计费帐户(即使您设置了计费帐户，除非您升级到付费帐户，否则不会向您收费)等信息，您将被定向到如下所示的页面。
Home screen of GCP web console
在顶部菜单栏，可以看到谷歌云平台旁边的“我的第一个项目”。在 GCP，“项目”是使用 GCP 服务、启用计费等的基础级实体。在第一次登录时，你可以看到谷歌自动为你创建了一个名为“我的第一个项目”的“项目”。点击它来查看当前项目的 ID，复制或记下它，这将在以后使用。通过在 web 控制台主屏幕上点击左侧菜单中的“帐单”,“我的第一个项目”会自动链接到您收到的免费点数。
启用 API
在 GCP，有许多不同的服务；计算引擎、云存储、BigQuery、云 SQL、云 Dataproc 等等。为了在您的项目中使用这些服务，您首先必须启用它们。
将鼠标放在左侧菜单的“APIs & Services”上，然后点击“Library”。对于这个项目，我们将启用三个 API:clouddataproc、计算引擎和云存储。
在 API 库页面中，通过在搜索框中键入名称，逐一搜索上述三个 API。点击进入搜索结果，并通过点击屏幕上的“启用”按钮来启用 API。
当我自己尝试时，我只需要启用 Cloud Dataproc API，因为当我点击它们时，其他两个(计算引擎、云存储)已经启用了。但是如果你不是这样，请启用计算引擎 API，云存储 API。
安装 Google Cloud SDK
如果这是你第一次尝试 GCP，你可能首先要安装谷歌云 SDK，这样你就可以从命令行与 GCP 的许多服务进行交互。你可以从这里找到更多关于如何安装的信息。
Install Google Cloud SDK by following instructions on https://cloud.google.com/sdk/
按照链接中的说明，您将被提示登录(使用您用来开始免费试用的 Google 帐户)，然后选择一个项目和计算区域(项目:选择您从上述步骤中启用 API 的项目如果有多个项目，计算区域:为了减少网络延迟，您可能希望选择一个离您近的区域。您可以从这里查看每个区域的物理位置。).
创建存储桶
因为您已经安装了 Google Cloud SDK，所以您可以从命令行或 web 控制台创建一个 bucket。
Web 控制台
从左侧菜单中点击“存储”，然后你会看到一个类似上面的页面。点击“创建存储桶”
为方便起见，请输入您在“在 GCP 上创建免费试用帐户”阶段结束时检查的项目 ID。您可以只点击“创建”而不改变任何其他细节，或者选择与您的项目相同的位置。
谷歌云 SDK
用您复制的项目 id 替换您的 _project_id，并在您的终端上运行下面一行，将 BUCKET_NAME 变量设置为您的项目 ID，并使其可用于子流程。(您稍后需要运行的 Bash 脚本将利用这一点)
export PROJECT_ID='your_project_id'
然后通过运行 gsutil mb 命令创建一个 bucket，如下所示。
gsutil mb gs://${PROJECT_ID}
以上命令将使用默认设置创建一个 bucket。如果您想在一个特定的区域或多区域中创建一个 bucket，您可以给它-l 选项来指定区域。您可以从这里看到可用的铲斗位置。
#ex1) multi-region europe
gsutil mb -l eu gs://${PROJECT_ID}#ex)2 region europe-west1
gsutil mb -l europe-west1 gs://${PROJECT_ID}
克隆 Git 仓库
现在，通过在终端中运行下面的命令，克隆我上传的 git 存储库。
git clone [https://github.com/tthustla/pyspark_sa_gcp.git](https://github.com/tthustla/pyspark_sa_gcp.git)
准备数据
一旦您克隆了存储库，它将创建一个名为 pyspark_sa_gcp 的文件夹。进入文件夹，检查有什么文件。
cd pyspark_sa_gcp/
ls
您将在目录中看到三个文件:data_prep.sh、pyspark_sa.py、train_test_split.py。为了下载训练数据并为训练做准备，让我们运行 Bash 脚本 data_prep.sh。下面是脚本的内容，我添加了注释来解释每一行的作用。
用于训练的原始数据集是“Sentiment140”，它源于斯坦福大学。该数据集有 160 万条带标签的推文。
50%的数据带有负面标签，另 50%带有正面标签。关于数据集的更多信息可以从链接中找到。http://help.sentiment140.com/for-students/
在上面的 Bash 脚本中，您可以看到它调用了一个 Python 脚本 train_test_split.py。让我们也来看看它做了什么。
现在我们可以运行 Bash 脚本来准备数据。一旦完成，它就会将准备好的数据上传到您之前创建的云存储桶中。上传数据需要 5~6 分钟。
./data_prep.sh
检查上传的数据
Web 控制台
从左侧菜单转到存储，然后单击进入您的存储桶-> pyspark_nlp ->数据。您将看到上传了两个文件。
谷歌云 SDK
或者您也可以通过运行下面的命令从终端检查您的 bucket 的内容。
gsutil ls -r gs://${PROJECT_ID}/**
创建 Google Dataproc 集群
Cloud Dataproc 是一个 Google 云服务，用于运行 Apache Spark 和 Apache Hadoop 集群。我不得不说，它简单易用得可笑，使用 Google Dataproc 只需要几分钟就可以启动一个集群。此外，如果您需要，Google Dataproc 提供了自动缩放，您可以随时调整集群，即使任务正在集群上运行。
Web 控制台
从左侧菜单转到 Dataproc(您必须向下滚动一点。在“大数据”部分下)，然后单击“群集”。点击“创建集群”，然后你会看到如下页面。
给它一个名字(为了方便，我给了项目 ID 作为它的名字)，选择 Region 和 Zone。为了减少延迟，最好将该区域设置为与您的 bucket 区域相同。这里您需要稍微更改一下 worker 节点的默认设置，因为免费试用版只允许您运行最多 8 个内核。群集的默认设置是一个主节点和两个工作节点，每个节点有 4 个 CPU，这将超过 8 个核心的配额。因此，将 worker 节点的设置更改为 2 个 CPU，然后单击底部的 create。经过几分钟的配置后，您将看到创建的集群包含一个主节点(4 个 CPU、15GB 内存、500GB 标准持久性磁盘)和两个工作节点(2 个 CPU、15GB 内存、500GB 标准持久性磁盘)。
谷歌云 SDK
因为我们需要稍微改变一下默认设置，所以我们需要在命令中增加一个参数，但是这很简单。让我们创建一个集群，将其命名为与项目 ID 相同的名称，并将 worker 节点设置为每个有 2 个 CPU。
gcloud dataproc clusters create ${PROJECT_ID} \--project=${PROJECT_ID} \--worker-machine-type='n1-standard-2' \--zone='europe-west1-b'
您可以将该区域更改为靠近您的存储桶区域。
提交 Spark 作业
最后，我们准备在 Google Dataproc 上运行培训。用于培训的 Python 脚本(pyspark_sa.py)包含在您之前克隆的 Git 存储库中。因为我在脚本上做了注释，解释了每一行的作用，所以我就不再赘述代码了。该代码是我在 Jupyter Notebook 中为我的上一篇文章所做的稍微重构的版本。下面是我以前的一些帖子，如果你想了解 PySpark 或 NLP 特征提取的更多细节。
- 使用 PySpark 进行情感分析
- 另一个使用 Python 的 Twitter 情感分析——第 4 部分(计数矢量器，混淆矩阵)
- 另一个使用 Python 的 Twitter 情感分析——第 5 部分(TFIDF 矢量器)
让我们看看 Python 脚本是什么样子的。
由于我在脚本中添加了注释来解释每一行的作用，所以我不会详细介绍代码。但简而言之，上面的脚本将采用三个命令行参数:存储训练和测试数据的云存储位置，存储测试数据预测结果的云存储目录，以及存储训练模型的云存储目录。当被调用时，它将首先对训练数据进行预处理->构建管道->拟合管道->并对测试数据进行预测->打印预测的准确性->将预测结果保存为 CSV ->保存拟合的管道模型->加载保存的模型->再次打印测试数据的准确性(以查看模型是否正确保存)。
Web 控制台
为了通过 web 控制台运行该作业，我们需要首先将 Python 脚本上传到我们的云存储中，以便我们可以指向该作业来读取脚本。让我们通过运行下面的命令来上传脚本。(我假设您仍然在您的终端上的 pyspark_sa_gcp 目录中)
gsutil cp pyspark_sa.py gs://${PROJECT_ID}/pyspark_nlp/
现在点击 web 控制台上的 Dataproc，点击“作业”,然后点击“提交作业”。
从上面的截图替换模糊的文本部分到你的项目 ID，然后点击底部的“提交”。你可以通过点击查看机器的输出。
这项工作在 15 分钟后完成，通过查看输出，看起来集群有点挣扎，但尽管如此，预测看起来很好，模型似乎被正确保存。
谷歌云 SDK
如果您从命令行提交作业，您甚至不需要将脚本上传到云存储。它将能够获取一个本地文件并移动到 Dataproc 集群来执行。(我再次假设您仍然在终端上的 pyspark_sa_gcp 目录中)
gcloud dataproc jobs submit pyspark pyspark_sa.py \--cluster=${PROJECT_ID} \-- gs://${PROJECT_ID}/pyspark_nlp/data/ gs://${PROJECT_ID}/pyspark_nlp/result gs://${PROJECT_ID}/pyspark_nlp/model
集群似乎又有点挣扎，但仍然正确地保存了结果和模型。(我已经尝试在我的付费帐户上用 4 个 CPUs worker 节点提交相同的作业，然后它没有抛出任何警告)
检查结果
去你的桶，然后进入 pyspark_nlp 文件夹。您将看到上述 Spark 作业的结果已保存到“结果”目录(用于预测数据框)和“模型”目录(拟合管道模型)。
最后，不要忘记删除您已经创建的 Dataproc 集群，以确保它不会耗尽您的信用。
通过这篇文章，我讲述了如何在 Google Dataproc 上训练 Spark ML 模型，并保存训练好的模型以备后用。我在这里展示的只是 GCP 能力的一小部分，我鼓励你探索 GCP 上的其他服务并尝试一下。
感谢您的阅读。您可以从下面的链接中找到 Git 脚本库。
https://github.com/tthustla/pyspark_sa_gcp
走出面向特征工程的正则表达式
“woman holding book” by Eliabe Costa on Unsplash
在之前的博客中，我介绍了基于模式的识别方法，它在某些情况下很有帮助。我们有其他方法来解决类似的问题吗？是的，我们也可以使用基于词典的方法。
现在，许多人也提到无词典方法来解决分类问题。如果你有训练数据，你应该选择无词典方法来建立深度学习模型。如果没有训练数据怎么办？您可以使用基于模式的方法(正则表达式)或基于词典的方法来准备初始数据集。
看完这篇文章，你会明白:
- 什么是基于词典的识别？
- 我们如何在特征工程阶段利用词典？
- 谁使用基于词汇的方法？
- 拿走
什么是基于词典的识别？
词汇在不同的语境下有不同的含义。在自然语言处理上下文中，词典是一个预定义的词汇列表。它可以是任何词汇，如位置、名称等。但是它很少跨越不同类别形成。例如，它可以是位置词典、命名词典，但是除非有某种意义，否则不能将不同类别项目混合在一起。
Photo: https://pixabay.com/en/planning-housebuilding-pre-project-3536758/
对于位置，它可以是位置列表，例如香港、东京。我们也可以有一个运河词典，其中包括“波罗的海运河”，“巴拿马运河”。不知何故，我们可以使用正则表达式来识别它，但我们不会这样做，因为它可能会引入很多错误，例如它可能很容易与命名组织混淆。
我们如何在特征工程阶段利用词典？
直言特征
在进行传统的机器学习时，我们必须手动构建大量的特征。在这种情况下，词典确实很有帮助。
根据以前的经验，我必须从文章中提取大洲。代替训练 NER，我可以简单地构建一个预定义的海洋列表，并使用精确匹配来构建特征。由于地球上只有七大洲，所以可以非常快地完成。
当然，也有一定的局限性。如果文章内容涉及旅行，我会有麻烦，因为“欧洲铁路”是一家公司，但它可能会标记为一个大洲。
二元特征
另一个著名的用例与情感分类问题有关。我们可以建立一个积极和消极的情绪词典来对评论的意义进行分类。
例如，“好的”和“漂亮的”可以从积极情感词汇中找到，而“坏的”、“无用的”是消极情感词汇。给定一个预定义的列表，我们不需要建立任何模型，只需要对正面和负面情感词汇的总得分进行求和。
同样，有一些限制，即否定和花费大量时间来建立列表。例如，评论可以是“它不好”。有一个否定词，它可以改变意思相反。对于积极和消极情感词典，建立高覆盖率词典并不容易。
谁使用基于词汇的方法？
有时你可能已经使用了基于词汇的方法，但你可能已经意识到了。下面将展示哪个库使用基于词典的方法来处理任务。
在空间上，它使用基于词典的方法来处理一些异常。
Capture from spaCy source code
Ghosh 等人[1]在 2017 年提出使用情感词典来解决情感分类问题。在预处理阶段，它们执行标准任务，包括归一化和去除。该功能建立在手工词典和预定义词典基础上，是 Senti-WordNet 和意见词典。
以下是部分功能:
- Senti-WordNet 匹配的单词数
- 与意见词典匹配的单词数
- 与英语情感词匹配的单词数
拿走
- 不要认为基于词典的方法是一种肮脏的方法，并努力避免这种方法。在某些情况下，它甚至比其他方法更有效。
- 初期可以采用，建议尽快用另一种方式替代。
- 在大多数情况下，你需要有 一个完整的列表(或者接近完整的列表)，这样它才能像预期的那样工作。
关于我
我是湾区的数据科学家。专注于数据科学、人工智能，尤其是 NLP 和平台相关领域的最新发展。你可以通过媒体博客、 LinkedIn 或 Github 联系我。
参考
[1] Ghosh Souvick、Ghosh Satanu 和 Das Dipankar。“代码混合社交媒体文本中的情感识别”。2017 年 7 月 4 日。https://arxiv.org/pdf/1707.01184.pdf
[2]爱森斯坦·雅各布。“基于词典分类的无监督学习”。2016 年 11 月 21 日。https://arxiv.org/pdf/1611.06933.pdf
[3]科尔奇纳。奥尔加，苏萨·塔西斯，菲利普·C。“Twitter 情感分析:词典方法、机器学习方法及其组合”。2015 年 9 月 18 日。https://arxiv.org/pdf/1507.00955.pdf
Javascript 中的作用域
Photo by sergio souza on Unsplash
如果您正在学习 javascript，或者对输出问题感到困惑，甚至难以理解 javascript 的其他核心概念，那么这篇文章将会有所帮助。
什么是示波器？
范围是运行时代码中某个特定部分的变量、函数或对象的可访问性。
当最小特权的原则应用于编程语言设计时，它们就出现了。
我们为什么要学它呢？
它们为你的代码提供了一定程度的安全性，也就是说，只有在真正需要的时候才使用它们。
界定代码的范围有助于提高效率，跟踪和减少错误。
它还解决了不同作用域中同名变量的命名问题，因此减少了命名空间冲突。
范围的类型有哪些？
- 全球和本地
- 词汇的
- 街区
- 公共和私人
让我们用实例逐一查看它们。
全局范围和局部范围
任何在函数外部声明的变量都属于全局范围，因此可以从代码中的任何地方访问和修改。
函数内部定义的变量在局部范围内。对于该函数的每次调用，它们都有不同的作用域。这意味着同名的变量可以在不同的函数中使用。这是因为这些变量被绑定到它们各自的函数，每个函数都有不同的作用域，并且不能在其他函数中访问。
新函数=新的局部范围——这是规则。
// Gobal
var mouse = "Mouse";function test1() {
// Local
var name = "Cat";
console.log(name);
}function test2() {
// Local
var name = "Dog";
console.log(name);
}test1();
test2();console.log(name);
词汇范围
当一个函数在另一个函数中时，内部函数可以访问外部函数中的作用域，这称为词法作用域，也称为静态作用域，因为它可能只在定义它的代码块中被调用(引用)。
Lexical scope
JavaScript 从最里面的范围开始向外搜索，直到找到它要寻找的变量/对象/函数。
需要记住的重要一点是，词法作用域并不向后工作而不是。也就是说，在上面的例子中，我们不能访问 SocialMedia 函数和 Platform 函数中的注释变量。
块范围
像if和switch条件或者for和while循环和{}不像函数这样的块语句，不会创建新的作用域。block 语句中定义的变量将保留在它们原来所在的范围内。
// Gobal
var name = "Mouse";{
// Local
var name = "Cat";
console.log(name); // Cat
}console.log(name); // Mouse
让我们看看围绕它的一个面试问题(执行上下文、闭包和范围的混合)
for (var i = 0; i < 3; i++) {
setTimeout(function() { console.log(i); }, 1000 + i);
}
每次分配相同的变量值时，上面将输出 3，3，3。
在第一次迭代中，console.log(i)将被添加到堆栈中，事件循环检测到它有延迟，它被发送到事件队列，这种情况又发生了 2 次，最后当事件循环开始一个接一个地挑选它们来执行时，由于最后的 i++的缘故，变量 I 的最终值是 3，并且由于变量的范围是相同的，所以当它返回时，每个变量的值都变成 3。
然而，ECMAScript 6 引入了let和const关键字。这些关键字可以用来代替var关键字，而let和const关键字支持在块语句中声明局部作用域。
如果我们把 var i 改成 let i，现在让我们看看区别。
for (let i = 0; i < 3; i++) {
setTimeout(function() { console.log(i); }, 1000 + i);
}
每当创建一个新的变量范围时，上面的函数将输出 0，1，2。
公共和私有范围
从公共(全局)范围包装函数使它们免受易受攻击的攻击。但是在 JavaScript 中，没有公共或私有范围这种东西。然而，我们可以模仿他们。
(function () {
var test = function () {
// do some stuff here
};
})();
// The parenthesis at the end of the function tells the interpreter to execute it as soon as it reads it without invocation.test(); // Uncaught ReferenceError
称为模块模式的设计模式也可以用来创建这样的功能。
Private and public scopes in javascript
modulePattern 的 return 语句包含我们的公共函数。私有函数只是那些不被返回的函数。不返回函数会使它们在 modulePattern 名称空间之外不可访问。但是我们的公共函数可以访问我们的私有函数，这使得它们对于辅助函数来说非常方便。
下一篇文章将讨论什么是 javascript 上下文和关于作用域的执行上下文。
如果您想被添加到我的电子邮件列表中，请考虑在此输入您的电子邮件地址****关注我的medium阅读更多关于 javascript 的文章，并关注github查看我的疯狂代码。如果有什么不清楚或者你想指出什么，请在下面评论。
你可能也会喜欢我的其他文章
- Javascript 执行上下文和提升
- Javascript —生成器-产出/下一个&异步-等待🤔
- 理解 Javascript‘this’关键字(上下文)。
- 带有映射、归约、过滤的 Javascript 数据结构
- Javascript- Currying VS 部分应用
- Javascript ES6 —可迭代程序和迭代器
- Javascript —代理， Javascript —作用域
如果你喜欢这篇文章，请随意分享并帮助他人找到它！
谢谢！
带动量的随机梯度下降
这是我关于用于训练神经网络和机器学习模型的优化算法系列的第 2 部分。第一部分讲的是随机梯度下降。在这篇文章中，我假设关于神经网络和梯度下降算法的基本知识。如果你对神经网络或者如何训练神经网络一无所知，在阅读这篇文章之前，请随意阅读我的第一篇文章。
在这篇文章中，我将讨论经典 SGD 算法的简单加法，叫做动量法，它几乎总是比随机梯度下降法更好更快。Momentum [1]或 SGD with momentum 是一种有助于在正确方向上加速梯度向量的方法，从而导致更快的收敛。它是最流行的优化算法之一，许多先进的模型都是用它来训练的。在跳到算法的更新方程之前，让我们看看动量功的数学基础。
指数加权平均值
指数加权平均值处理的是数字序列。假设，我们有一些有噪声的序列。对于这个例子，我绘制了余弦函数，并添加了一些高斯噪声。看起来是这样的:
Out sequence.
请注意，尽管这些点看起来非常接近，但它们都没有共享 x 坐标。对于每个点来说，这是一个唯一的数字。这个数字定义了序列中每个点的索引。
我们想对这些数据做的是，不是使用它，而是想要某种“移动”平均值，这将对数据进行“去噪”，并使其更接近原始函数。指数加权平均值可以给我们一个看起来像这样的图片:
momentum — data from exponentially weighed averages.
如你所见，这是一个非常好的结果。我们得到的不是有很多噪音的数据，而是更平滑的线，比我们得到的数据更接近原始函数。指数加权平均值用下面的等式定义了新的序列 V:
序列 V 就是上面标为黄色的那个。 Beta 是另一个超参数，取值从 0 到 1。上面我用了 beta = 0.9。这是一个很好的值，最常用于带动量的 SGD。直觉上，你可以把 beta 想成如下。我们对序列的最后1/(1-β)个点进行近似平均。让我们看看β的选择如何影响我们的新序列 v。
Exponentially weighed averages for different values of beta.
如您所见，beta 值越小，新序列的波动就越大，因为我们对更小数量的样本求平均，因此更接近噪声数据。β值越大，如β= 0.98，我们得到的曲线越平滑，但它会向右偏移一点，因为我们对大量的示例进行了平均(对于β= 0.98约为 50)。 Beta = 0.9 在这两个极端之间提供了一个很好的平衡。
数学部分
这一部分对于在你的项目中使用动量是不必要的，所以可以跳过它。但是它提供了更多关于动量如何工作的直觉。
让我们扩展新序列 v 的三个连续元素的指数加权平均值的定义。
V — New sequence. S — original sequence.
将所有这些结合在一起，我们得到:
然后稍微简化一下:
从这个等式中我们看到，新序列的第个号的值依赖于所有先前的值 1..来自 S 的所有值都被赋予一定的权重。这个权重是 s 的第 (t - i) 个值的betaI的幂乘以 (1- beta) ，因为 beta 小于 1，所以当我们将 beta 取某个正数的幂时，它会变得更小。因此，S 的旧值得到小得多的权重，因此对 v 的当前点的整体值的贡献更小。在某个点上，权重将变得如此之小，以至于我们几乎可以说我们“忘记”了该值，因为它的贡献变得小到无法注意到。当重量变得小于 1 / e 时，这是一个很好的近似值。更大的β值要求更大的功率值小于 1 / e 。这就是为什么β值越大，我们平均的点数就越多。下图显示了与 threshold = 1 / e 相比，较旧的 S 值的权重变小的速度，在 threshold =1/e中，我们通常会“忘记”较旧的值。
最后要注意的是，前几次迭代将提供一个非常糟糕的平均值，因为我们还没有足够的值来平均。解决方法是不使用 V，我们可以使用 V 的偏差修正版本。
其中b =β。t 的值很大时，b 的 t 次方与零没有区别，因此根本不会改变 V 的值。但是对于小 t 值，这个等式会产生稍微好一点的结果。有了动量，人们通常不会费心去实现这一部分，因为学习稳定得相当快。
带动量的 SGD
我们已经定义了一种方法来获得一些序列的“移动”平均值，它随着数据一起变化。我们如何将此应用于训练神经网络？可以平均我们的梯度。我将在 momentum 中定义它是如何实现的，然后继续解释为什么它可能会更好。
我将给出 SGD 和动量的两种定义，它们几乎是写同一个方程的两种不同方式。首先，吴恩达在 coursera 上的深度学习专业课程中是如何定义它的。按照他的解释，我们定义了一个动量，它是我们梯度的移动平均值。然后我们用它来更新网络的权重。可以这样写:
其中 L —是损失函数，三角形物—梯度 w.r.t 权重， alpha —学习率。另一种方法是编写动量更新规则最流行的方法，它不太直观，只是省略了 (1 - beta) 项。
这与第一对等式非常相似，唯一的区别是你需要用 (1 - beta) 因子来衡量学习率。
内斯特罗夫加速梯度
内斯特罗夫 Momentum 是 Momentum 更新的一个略有不同的版本，最近越来越受欢迎。在这个版本中，我们首先看当前动量指向的点，并从该点计算梯度。当你看这幅画时，它变得清晰多了。
Source (Stanford CS231n class)
内斯特罗夫动量可以用下面的公式来定义:
为什么动量起作用
在这一节中，我想谈一点为什么动量在大多数时候会比经典 SGD 更好。
对于随机梯度下降，我们不计算损失函数的精确导数。相反，我们是在小批量的基础上估算的。这意味着我们并不总是朝着最佳方向前进，因为我们的导数是“嘈杂的”。就像我上面的图表一样。因此，指数加权平均值可以为我们提供更好的估计，比我们嘈杂的计算更接近实际的导数。这就是为什么动量理论可能比经典 SGD 更有效的原因之一。
另一个原因在于沟壑。峡谷是这样一个区域，它的表面在一个维度上比在另一个维度上弯曲得更陡。深谷在深度学习的局部极小值附近是常见的，SGD 在导航它们时有困难。SGD 将倾向于在狭窄的峡谷中振荡，因为负梯度将指向陡峭的一侧，而不是沿着峡谷指向最优值。动量有助于加速正确方向的梯度。这表现在下面的图片中:
Left — SGD without momentum, right— SGD with momentum. (Source: Genevieve B. Orr)
结论
我希望这篇文章能给你一些直觉，让你知道 SGD 如何以及为什么有动力。它实际上是深度学习中最流行的优化算法之一，甚至比更高级的算法使用得更频繁。
下面我提供一些参考，在这里你可以学到更多关于深度学习中的优化。
参考
[1]钱宁。关于梯度下降学习算法中的动量项。神经网络:国际神经网络学会官方杂志，12(1):145–151，1999
【2】提炼，为什么动量真的起作用
[3] deeplearning.ai
[4] 鲁德 (2016)。梯度下降优化算法概述。arXiv 预印本 arXiv:1609.04747
[5] Ruder (2017) 深度学习优化 2017 年亮点。
[6] 斯坦福 CS231n 讲义。
【7】fast . ai
随机加权平均——一种获得深度学习最新结果的新方法
更新:你现在可以在我的个人博客上欣赏这篇文章，这里的数学排版要好得多(Medium 不支持数学渲染，尽管有很多请求)。
在这篇文章中，我将讨论两篇有趣的近期论文，它们提供了一种简单的方法，通过使用一种智能的集成方法来提高任何给定神经网络的性能。它们是:
- 损失表面、模式连接和 dnn 的快速组装。铝
- 伊兹迈洛夫等人的“平均权重导致更宽的最优值和更好的泛化能力”。铝
额外的先决条件阅读将使这篇文章的内容更容易理解:
- Vitaly Bushaev 的“提高学习率，改进我们的工作方式”
神经网络的传统集成
传统的集成将几个不同的模型结合起来，并使它们对相同的输入进行预测。然后使用某种平均方法来确定系综的最终预测。它可以是简单的投票、平均或者甚至是基于集合中模型的输入来学习预测正确值或标签的另一个模型。岭回归是一种结合几种预测的特殊方法，被获奖的机器学习实践者使用。
Snapshot Ensemble is created by saving a model each time the learning rate cycle is at the end. Then the saved models are used together during prediction. Source.
当应用于深度学习时，集成可用于组合几个神经网络的预测，以产生一个最终预测。通常，在集成中使用不同架构的神经网络是一个好主意，因为它们可能会在不同的训练样本上出错，因此集成的好处会更大。
Snapshot ensemble uses cyclical learning rates with annealing. Source.
然而，你也可以用相同的架构集合模型，它会给出令人惊讶的好结果。在快照集成论文中提出了一个利用这种方法的非常酷的技巧。作者在训练相同的网络时拍摄权重快照，然后在训练后创建具有相同架构但不同权重的网络集合。这可以提高测试性能，而且这也是一种非常便宜的方法，因为你只需训练一个模型一次，只是不时地节省重量。
更多细节可以参考这篇牛逼的帖子。如果你还没有使用循环学习率，那么你肯定应该使用，因为它已经成为标准的最先进的训练技术，非常简单，计算量不大，并且几乎不需要额外的成本就可以获得显著的收益。
上面所有的例子都是模型空间中的集合，因为它们组合了几个模型，然后使用模型的预测来产生最终的预测。
然而，在我在这篇文章中讨论的论文中，作者提议在权重空间中使用一个小说集合。这种方法通过组合同一网络在不同训练阶段的权重来产生一个集成，然后使用这个具有组合权重的模型来进行预测。这种方法有两个好处:
- 当组合权重时，我们最终仍然得到一个模型，这加快了预测的速度
- 事实证明，这种方法胜过当前最先进的快照集合
让我们看看它是如何工作的。但是首先我们需要了解一些关于损失曲面和广义解的重要事实。
重量空间中的解决方案
第一个重要的见解是，一个经过训练的网络是多维权重空间中的一个点。对于给定的体系结构，每个不同的网络权重组合都会产生一个单独的模型。由于任何给定的架构都有无限多种权重组合，因此会有无限多种解决方案。训练神经网络的目标是找到特定的解决方案(权重空间中的点),该解决方案将在训练和测试数据集上提供损失函数的低值。
在训练过程中，通过改变权值，训练算法改变网络并在权值空间中行进。梯度下降算法在该空间中的损失平面上行进，其中平面高程由损失函数值给出。
窄和宽最优
很难想象和理解多维权重空间的几何形状。同时，理解它是非常重要的，因为随机梯度下降本质上是在训练时遍历这个高维空间中的一个损失面，并试图找到一个好的解——损失面上损失值较低的“点”。众所周知这样的曲面有很多局部最优。但事实证明，并不是所有的都一样好。
辛顿:“要处理 14 维空间中的超平面，想象一个 3 维空间，大声对自己说‘14’。大家都这么干。”(来源)
Narrow and wide optima. Flat minimum will produce similar loss during training and testing. Narrow loss, however, will give very different results during training and testing. In other words, wide minimum is more generalizable than narrow. Source.
一个可以区分好的解决方案和坏的解决方案的度量是它的平坦度。想法是训练数据集和测试数据集将产生相似但不完全相同的损失表面。你可以想象一个测试表面会相对于火车表面移动一点。对于狭窄的解决方案，在测试期间，由于这种偏移，给出低损耗的点可能具有大的损耗。这意味着这种“狭隘”的解决方案不能很好地推广——训练损失低，而测试损失大。另一方面，对于“宽”和扁平的解决方案，这种转变将导致培训和测试损失彼此接近。
我解释了窄解和宽解之间的区别，因为这篇文章的重点是新的方法，它可以产生好的宽解。
快照集成
最初，SGD 将在重量空间进行大的跳跃。然后，随着学习速率由于余弦退火而变得更小，SGD 将收敛到某个局部解，并且算法将通过将模型添加到集成来拍摄模型的“快照”。然后，速率再次被重置为高值，SGD 在收敛到某个不同的局部解之前再次进行大的跳跃。
快照集合方法中的周期长度是 20 到 40 个历元。长学习率周期的想法是能够在权重空间中找到足够不同的模型。如果模型过于相似，那么集合中独立网络的预测将会过于接近，集合的好处将会忽略不计。
快照集合工作得非常好，并且提高了模型性能，但是快速几何集合工作得更好。
快速几何装配(FGE)
快速几何组合与快照组合非常相似，但有一些区别特征。它使用线性分段循环学习率调度代替余弦。其次，FGE 的周期长度要短得多——每个周期只有 2 到 4 个时期。乍一看，短周期是错误的，因为每个周期结束时的模型会彼此靠近，因此将它们组合在一起不会带来任何好处。然而，正如作者所发现的，因为在足够不同的模型之间存在低损耗的连接路径，所以有可能沿着这些路径以小步骤行进，并且沿途遇到的模型将足够不同，从而允许以良好的结果集合它们。因此， FGE 显示出与快照集相比的改进，并且需要更小的步骤来找到模型(这使得训练更快)。
LEFT: Traditional intuition is that good local minima are separated by regions of high loss. This is true if we travel along the lines connecting local minima. MIDDLE and RIGHT: However, there exist paths between local minima, such that loss stays low on these paths. FGE takes snapshots along these paths and creates an ensemble out of the snapshots. Source.
为了从快照集成或 FGE 中受益，需要存储多个模型，然后在对最终预测进行平均之前对所有模型进行预测。因此，对于系综的额外性能，需要付出更高的计算量。所以那里没有免费的午餐。还是有？这就是随机加权平均的新论文的用武之地。
随机加权平均法
随机加权平均 非常接近快速几何集合，但计算损失很小。SWA 可以应用于任何体系结构和数据集，并在所有的体系结构和数据集上都显示出良好的效果。这篇论文表明 SWA 导致了更宽的最小值，我在上面讨论了它的好处。SWA 不是传统意义上的合奏。在训练结束时，你得到一个模型，但它的性能胜过快照集，接近 FGE。
LEFT: W1, W2 and W3 represent 3 independently trained networks, Wswa is the average of them. MIDDLE: Wswa provides superior performance on the test set as compared to SGD. RIGHT: Note that even though Wswa shows worse loss during training, it generalizes better. Source.
SWA 的直觉来自经验观察，即在每个学习率周期结束时，局部最小值倾向于在损失值较低的损失表面区域的边界处累积(点 W1、W2 和 W3 位于上图左面的红色低损失区域的边界处)。通过取几个这样的点的平均值，有可能以更低的损失获得广泛的、可概括的解决方案(上图左图中的 Wswa)。
这是它的工作原理。您只需要两个模型，而不是许多模型的集合:
- 存储模型权重的移动平均值的第一个模型(公式中的 w_swa)。这将是训练结束后用于预测的最终模型。
- 第二个模型(公式中的 w)将遍历权重空间，通过使用循环学习率时间表来探索它。
Stochastic Weight Average weight update equation. Source.
在每个学习率周期结束时，第二个模型的当前权重将用于更新运行平均模型的权重，方法是在旧的运行平均权重和第二个模型的新权重集之间取加权平均值(左图中提供了公式)。按照这种方法，您只需要训练一个模型，并且在训练期间只在内存中存储两个模型。对于预测，您只需要运行平均模型，对其进行预测比使用上述集成快得多，在集成中，您使用许多模型进行预测，然后对结果进行平均。
履行
论文作者提供了他们自己在 PyTorch 中的实现。
此外，SWA 在每个人都应该使用的超棒的 fast.ai 库中实现。如果你还没看过他们的课程，那么跟随链接。
感谢阅读！如果你喜欢，点击下面的按钮在我的网站上订阅更新！这对我意义重大，鼓励我写更多这样的故事。
可以在 Twitter 上 关注我 。下面我们也连线上LinkedIn。
Python 中的股票分析
使用面向对象编程和附加模型探索财务数据
人们很容易被大量的数据和可用于数据科学的免费开源工具冲昏头脑。在花了一点时间在 quandl 金融库和先知建模库之后，我决定尝试一些简单的股票数据探索。几天和 1000 行 Python 代码之后，我完成了一个完整的股票分析和预测工具。虽然我没有足够的信心(或愚蠢)用它来投资个股，但在这个过程中，我学习了大量 Python，本着开源的精神，我想分享我的成果和代码，这样其他人也可以受益。
Now more than ever
本文将展示如何使用 Stocker，这是一个基于 Python 类的股票分析和预测工具(这个名称最初是随意取的，但我后来决定它很好地代表了“股票浏览器”)。我曾几次试图攻克类，这是 Python 中面向对象编程的基础，但是和大多数编程主题一样，当我阅读这些书籍时，它们对我来说从来没有什么意义。只有当我深入一个项目，面对一个我以前没有解决的问题时，这个概念才最终实现，这再一次表明经验胜过理论解释！除了探索 Stocker 之外，我们还将触及一些重要的主题，包括 Python 类和附加模型的基础知识。对于任何想使用 Stocker 的人来说，完整的代码可以在 GitHub 上找到，还有使用文档。Stocker 被设计得易于使用(即使对于那些 Python 新手来说也是如此)，我鼓励任何人去尝试一下。现在，我们来看看 Stocker 的分析能力！
储料器入门
在安装了所需的库之后，我们要做的第一件事就是将 Stocker 类导入到我们的 Python 会话中。我们可以从交互式 Python 会话或 Jupyter 笔记本中使用脚本启动目录来完成这项工作。
from stocker import Stocker
现在我们的 Python 会话中有了 Stocker 类，我们可以用它来创建该类的一个实例。在 Python 中，类的实例被称为对象，创建对象的行为有时被称为实例化或构造。为了创建一个 Stocker 对象，我们需要传入一个有效股票代码 ( 粗体表示输出)。
microsoft = Stocker('MSFT')**MSFT Stocker Initialized. Data covers 1986-03-13 to 2018-01-16.**
现在，我们有了一个包含 Stocker 类所有属性的microsoft对象。Stocker 是建立在 quandl WIKI 数据库上的，该数据库让我们可以访问超过 3000 只美国股票的多年每日价格数据。对于这个例子，我们将坚持使用微软的数据。尽管微软可能被视为开源的对立面，但他们最近做出了一些让我乐观的改变，他们正在拥抱开源社区(包括 Python)。
Python 中的类由两个主要部分组成:属性和方法。不涉及太多细节，属性是与整个类或者与该类的特定实例(对象)相关联的值或数据。方法是包含在类中的函数，可以作用于数据。Stocker 对象的一个属性是特定公司的股票数据，当我们构造它时，这个属性与对象相关联。我们可以访问该属性，并将其赋给另一个变量进行检查:
# Stock is an attribute of the microsoft object
stock_history = microsoft.stock
stock_history.head()
Microsoft Stock Data
Python 类的好处是方法(函数)和它们作用的数据与同一个对象相关联。我们可以使用 Stocker 对象的方法来绘制股票的整个历史。
# A method (function) requires parentheses
microsoft.plot_stock()**Maximum Adj. Close = 89.58 on 2018-01-12.
Minimum Adj. Close = 0.06 on 1986-03-24.
Current Adj. Close = 88.35.**
绘制的默认值是调整后的收盘价，它考虑了股票的分割(当一只股票分割成多只股票时，比如说 2 只，每只新股票的价值是原价的 1/2)。
这是一个非常基本的情节，我们可以从谷歌搜索中找到，但用几行 Python 代码自己完成也有令人满意的地方！plot_stock函数有许多可选参数。默认情况下，该方法绘制整个日期范围的调整后收盘价，但我们可以选择范围、要绘制的统计数据和绘制类型。例如，如果我们想将价格的每日变化与调整后的交易量(股票数量)进行比较，我们可以在函数调用中指定它们。
microsoft.plot_stock(start_date = '2000-01-03', end_date = '2018-01-16', stats = ['Daily Change', 'Adj. Volume'], plot_type='pct')**Maximum Daily Change = 2.08 on 2008-10-13.
Minimum Daily Change = -3.34 on 2017-12-04.
Current Daily Change = -1.75.
Maximum Adj. Volume = 591052200.00 on 2006-04-28.
Minimum Adj. Volume = 7425503.00 on 2017-11-24.
Current Adj. Volume = 35945428.00.**
请注意，y 轴是相对于统计平均值的百分比变化。这种规模是必要的，因为每天的交易量最初是以股票为单位的，范围在数亿股，而每天的价格变化通常是几美元！通过转换为百分比变化，我们可以在相似的范围内查看两个数据集。该图显示，交易的股票数量和每日价格变化之间没有相关性。这是令人惊讶的，因为我们可能预计在价格变化较大的日子里会有更多的股票交易，因为人们急于利用波动。然而，唯一真实的趋势似乎是交易量随着时间的推移而减少。2017 年 12 月 4 日的价格也有显著下降，我们可以尝试将这与关于微软的新闻报道联系起来。快速搜索 12 月 3 日的新闻会得到以下结果:
Not sure about the reliability of these sources Google
当然，似乎没有任何迹象表明微软股票将在第二天出现 10 年来最大的价格下跌！事实上，如果我们根据新闻来玩股票市场，我们可能会被诱惑去买股票，因为与 NFL 的交易(第二个结果)听起来是积极的！
使用plot_stock，我们可以调查任何日期范围内数据中的任何数量，并寻找与现实世界事件的相关性(如果有的话)。现在，我们将转移到 Stocker 更有趣的部分:制造假币！
让我们假设在公司首次公开募股(首次公开募股)时，我们镇定自若地投资了 100 股微软股票。我们现在会有多富有？
microsoft.buy_and_hold(start_date='1986-03-13',
end_date='2018-01-16', nshares=100)**MSFT Total buy and hold profit from 1986-03-13 to 2018-01-16 for 100 shares = $8829.11**
除了让我们感觉更好，使用这些结果将允许我们及时计划我们的旅行，以实现利润最大化。
如果我们感觉过于自信，我们可以试着调整结果来赔钱:
microsoft.buy_and_hold(start_date='1999-01-05',
end_date='2002-01-03', nshares=100)**MSFT Total buy and hold profit from 1999-01-05 to 2002-01-03 for 100 shares = $-56.92**
出人意料的是，在股市上有可能亏钱！
加法模型
加法模型是分析和预测时间序列的强大工具，时间序列是现实世界中最常见的数据类型之一。这个概念很简单:将时间序列表示为不同时间尺度上的模式和总体趋势的组合。我们知道微软股票的长期趋势是稳步上涨，但也可能存在以年或日为基础的模式，例如每周二上涨，了解这一点将有利于经济发展。由脸书开发的 Prophet 是一个很好的库，用于分析每日观察的时间序列(比如股票)。Stocker 在幕后使用 Prophet 为我们完成所有建模工作，因此我们可以使用一个简单的方法调用来创建和检查模型。
model, model_data = microsoft.create_prophet_model()
加性模型消除了数据中的噪声，这就是为什么模型线与观测值不完全一致的原因。Prophet 模型还计算不确定性，这是建模的一个重要部分，因为在处理波动的现实生活过程时，我们永远无法确定我们的预测。我们也可以使用先知模型来预测未来，但目前我们更关心过去的数据。注意，这个方法调用返回了两个对象，一个模型和一些数据，我们将它们赋给了变量。我们现在使用这些变量来绘制时间序列的组成部分。
# model and model_data are from previous method call
model.plot_components(model_data)
plt.show()
过去三年来，总体趋势是明确的增长。似乎还有一个值得注意的年度模式(下图)，价格在 9 月和 10 月触底，在 11 月和 1 月达到峰值。随着时间尺度的减小，数据变得更加嘈杂。在一个典型的月份里，信号比噪音多。如果我们认为可能有一个周模式，我们可以通过更改 Stocker 对象的weekly_seasonality属性将它添加到 prophet 模型中:
print(microsoft.weekly_seasonality)
microsoft.weekly_seasonality = True
print(microsoft.weekly_seasonality)**False
True**
weekly_seasonality的默认值是 False，但是我们更改了该值，在模型中包含了一个周模式。然后，我们再次调用create_prophet_model,并用图形表示结果组件。以下是新模型的每周季节性。
There was no way I could make this graph look good
我们可以忽略周末，因为价格只在一周内变化(实际上，价格在下班后培训期间有少量变化，但不影响我们的分析)。不幸的是，没有一周的趋势可供我们使用，在我们继续建模之前，我们将关闭每周季节性。这种行为是意料之中的:对于股票数据，随着时间尺度的减小，噪声开始淹没信号。日复一日，股票的走势基本上是随机的，只有缩小到年度规模，我们才能看到趋势。希望这能很好地提醒你为什么不玩每日股票游戏！
变革点
当时间序列从增加到减少或从减少到增加(更严格地说，它们位于时间序列比率的变化最大的地方)。这些时间是非常重要的，因为知道一只股票什么时候会达到顶峰或将要起飞可能会带来巨大的经济利益。识别转折点的原因可能会让我们预测股票价值的未来波动。Stocker 对象可以自动为我们找到 10 个最大的变化点。
microsoft.changepoint_date_analysis()**Changepoints sorted by slope rate of change (2nd derivative):
Date Adj. Close delta
48 2015-03-30 38.238066 2.580296
337 2016-05-20 48.886934 2.231580
409 2016-09-01 55.966886 -2.053965
72 2015-05-04 45.034285 -2.040387
313 2016-04-18 54.141111 -1.936257**
转折点往往与股价的波峰和波谷一致。Prophet 只在前 80%的数据中找到变化点，但是尽管如此，这些结果还是很有用的，因为我们可以尝试将它们与现实世界的事件联系起来。我们可以重复之前所做的，在这些日期手动搜索谷歌新闻，但我认为如果斯托克为我们这样做会更好。你可能见过谷歌搜索趋势工具，它可以让你看到任何搜索术语在谷歌搜索中的流行程度。Stocker 可以自动检索我们指定的任何搜索项的数据，并在原始数据上绘制结果。为了找到并绘制搜索词的频率，我们修改了前面的方法调用。
# same method but with a search term
microsoft.changepoint_date_analysis(search = 'Microsoft profit')**Top Related Queries:
query value
0 microsoft non profit 100
1 microsoft office 55
2 apple 30
3 microsoft 365 30
4 microsoft office 365 20
Rising Related Queries:
query value
0 microsoft 365 120
1 microsoft office 365 90
2 microsoft profit 2014 70**
除了绘制相对搜索频率的图表之外，Stocker 还显示了图表日期范围内排名靠前的相关查询和排名靠前的上升查询。在图中，y 轴通过将值除以其最大值而在 0 和 1 之间标准化，从而允许我们比较不同标度的两个变量。从图中可以看出，搜索“微软利润”和微软股票价格之间似乎没有关联。
如果我们发现了相关性，那么还会有因果关系的问题。我们不知道是搜索还是新闻导致了价格的变化，或者是价格的变化导致了搜索。可能会发现一些有用的信息，但也有许多偶然的关联。(关于这种随机关系的幽默，请看的虚假关联。请随意尝试一些不同的术语，看看您是否能发现任何有趣的趋势！
microsoft.changepoint_date_analysis(search = 'Microsoft Office')
看起来 Office 搜索量的下降导致了股价的上涨。也许应该有人让微软知道。
预言
我们只探索了 Stocker 功能的前半部分。后半部分用于预测，或预测未来的股票价格。虽然这可能是徒劳的(或者至少不会有回报)，但在这个过程中仍然有很多东西要学！请继续关注未来关于预测的文章，或者自己开始使用 Stocker 进行预测(查看文档了解详情)。现在，我再给你们看一张图片。
# specify number of days in future to make a prediction
model, future = microsoft.create_prophet_model(days=180)**Predicted Price on 2018-07-15 = $97.67**
尽管 Stocker 的所有功能可能已经公开可用，但创建这个工具的过程是令人愉快的，更重要的是，它教会了我比任何大学课程都多的关于数据科学、Python 和股票市场的知识。我们生活在一个知识民主化的不可思议的时代，任何人都可以在没有正式指导的情况下学习关于编程的知识，甚至是像机器学习这样的艺术领域。如果你有一个项目的想法，但认为你知道得不够多，或者发现以前有人做过，不要让这阻止你。你可能会开发出一个更好的解决方案，即使你没有，你也会比你从未开始时过得更好，知道得更多！
一如既往，我欢迎建设性的批评和反馈。可以在推特上找到我，电话是 @koehrsen_will 。
Python 中的股票市场分析
第 1 部分:通过 Web 抓取获取数据
Staying Invested! What was your gain?
自 2013 年以来，全球股市经历了一轮壮观的牛市。在印度，许多公司增长了 10 倍以上。即使是行业领导者，nifty 50 或印度 50 强公司也增长了两倍以上。2017 年，Nifty 50 的年增长率(或回报率)超过 20%，2018 年的趋势似乎也是如此。人们正在投资共同基金和交易所交易基金来跟随这一趋势。
在这种情况下，我们似乎应该更多地投资股票，但如果你看看新闻，你会发现大多数市场分析师都认为目前的市场投资非常昂贵。那么，我们是相信他们的话，还是自己做一些数据分析来找出答案呢？我们如何在一个被高度高估的市场中找到好公司？这是又一次类似比特币/加密货币泡沫的炒作吗？
在这一系列教程中，我们将使用 python 来找出答案。
在第 1 部分中，我们学习如何获取数据。在第 2 部分中，我们将看看如何进行分析。
在本教程(第 1 部分)中，我们将学习
- 通过请求库在 python 中发出 http 请求。
- 使用 chrome 开发工具来查看数据在页面上的位置。
- 使用 BeautifulSoup 库，当数据无法以结构化形式获得时，从下载的页面中抓取数据。
- 将表等数据解析为 python 2D 数组。
- 抓取功能以字典的形式获取数据(键-值对)。
这里需要的 Jupyter 笔记本是这里是。
设置
beautifulsoup4
fastnumbers
dill
3.启动一个 python 3 jupyter 笔记本并添加以下导入。
**import** numpy **as** np *# linear algebra*
**import** pandas **as** pd *# pandas for dataframe based data processing and CSV file I/O***import** requests *# for http requests*
**from** bs4 **import** BeautifulSoup *# for html parsing and scraping* **import** bs4**from** fastnumbers **import** isfloat
**from** fastnumbers **import** fast_float
**from** multiprocessing.dummy **import** Pool **as** ThreadPool
**import** matplotlib.pyplot **as** plt
**import** seaborn **as** sns
**import** json
**from** tidylib **import** tidy_document *# for tidying incorrect html*
sns.set_style('whitegrid')
%matplotlib inline
**from** IPython.core.interactiveshell **import** InteractiveShell
InteractiveShell.ast_node_interactivity = "all"
现在我们准备好开始了。如果有任何困难，请查看我在 Github 上的 jupyter 笔记本。
我们收集数据时需要的一些实用程序
字符串到浮点的转换
网页中的很多数字都是用逗号和%符号组成的字符串。我们使用 fastnumbers 库中的fast_float函数。
**def** ffloat(string):
**if** string **is** **None**:
**return** np.nan
**if** type(string)==float **or** type(string)==np.float64:
**return** string
**if** type(string)==int **or** type(string)==np.int64:
**return** string
**return** fast_float(string.split(" ")[0].replace(',','').replace('%',''),
default=np.nan)
我们检查输入是否已经是 float/int，然后返回相同的值，否则删除逗号和%,然后转换。
另一个函数来完成字符串列表的转换
**def** ffloat_list(string_list):
**return** list(map(ffloat,string_list))
从字符串中删除多个空格
当从网页中提取文本时，一些字符串在单词之间有多个空格，以保持一致性。
**def** remove_multiple_spaces(string):
**if** type(string)==str:
**return** ' '.join(string.split())
**return** string
用 Python 发出 Http 请求
为此，我们将使用 python 请求库。您需要知道您将请求的页面的 url。
使用方法requests.get发出请求，我们用response.status_code和response.content分别获取 http 状态和页面内容
response **=** requests.get("http://www.example.com/", timeout=240)
response**.**status_code
response**.**content
请注意，requests library 并不在页面上运行 javascript，因此在通过 javascript 加载 html 内容之后获取的任何数据/内容都将不可用。这不是一个问题，因为大多数金融网站通常遵循服务器端脚本，并向客户发送完整的页面。
获取 Json 内容并解析它
要从页面中获取 json 内容，只需做response.json()
url **=** "**https://jsonplaceholder.typicode.com/posts/1**"
response **=** requests.get(url, timeout=240)
response.status_code
response.json()
content **=** page_response.json()
content.keys()
Json Response
为了确保您的请求成功，请务必检查response.status_code。
通过解析和遍历 HTML 抓取数据
我们将使用 beautifulsoup4 库将 html 字符串解析成树状表示。
在 Jupyter 笔记本中呈现 HTML 字符串
**from** **IPython.core.display** **import** HTML
HTML("**<b>Rendered HTML</b>**")
使用 Chrome 检查器(开发工具)获取内容的位置
我们将会看到这个网址:https://www . money control . com/India/stockprice quote/auto-2-3-wheelers/hero moto corp/HHM
这是一家在印度生产摩托车的公司的网页。请查看该页面。
Snapshot of the link
现在，要从页面中获取任何内容，您需要知道内容在 HTML 中的位置。所以首先我们会得到标题(“Hero Motocorp Ltd .”)。让我们用 Chrome inspector 检查页面。要在 mac 上使用 chrome inspector，请使用cmd+option+i，在 windows 和 linux 上使用Control+Shift+I。
Using inspector
打开 chrome inspector ->点击元素(1) ->点击光标框项目(2) ->指向“Hero Motocorp Ltd .”然后点击。
Finding element location
如您所见，公司名称在
标签中。接下来，我们看看如何在笔记本中获取这些内容。
使用 BeautifulSoup4 解析和显示内容
为此，我们需要获得响应，然后使用BeautifulSoup类解析内容。最后，我们从< h1 >标签中获取内容并呈现出来。
response **=** requests.get("[**https://www.moneycontrol.com/india/stockpricequote/auto-2-3-wheelers/heromotocorp/HHM**](https://www.moneycontrol.com/india/stockpricequote/auto-2-3-wheelers/heromotocorp/HHM)", timeout=240)
page_content = **BeautifulSoup**(response.content, "**html.parser**")
HTML(**str**(page_content.find("**h1**")))
通过属性获取 HTML 元素
我们将在 id 为“b_changetext”的
中获取当天的价格变化。为此，您只需将一个attrs对象传递给page_content.find
response = requests.get("[**https://www.moneycontrol.com/india/stockpricequote/auto-2-3-wheelers/heromotocorp/HHM**](https://www.moneycontrol.com/india/stockpricequote/auto-2-3-wheelers/heromotocorp/HHM)", timeout=240)
content = BeautifulSoup(response.content, "**html.parser**")price_div = content.find("**div**",attrs={"**id**":'**b_changetext**'})
HTML(str(price_div))
Output of price getter code
find 的一些其他变体如下
content.find_all("p")
content.find_next("p",attrs={"class":"my-id"})
.find_all查找页面中出现的所有给定规格。.find_next查找下一个事件。一旦你有了元素，你可以做.text来获得它的文本内容(浏览器 DOM 的innerText)。
elem = content.find("p",attrs={"class":"my-id"})
text = elem.text
获取子元素
要找到一个元素(通过上述方法找到的元素)的子元素，你需要对这个元素做.children。这将给你一个可以在循环中使用的 iterable。
list(price_div.children)
getting children of element
正如你在上面看到的,.children给了你 3 个孩子，其中第一个是除了空间什么都没有的元素。我们将创建一个函数来过滤它，只给我们适当的元素。解析后页面上的任何实际元素都由bs4.element.Tag类型表示。我们删除任何只有空格或换行符的字符串，除非它们包含在标签元素中。
**def** get_children(html_content):
**return** [item **for** item **in** html_content.children **if** type(item)==bs4.element.Tag **or** len(str(item).replace("**\n**","").strip())>0]
Get children filter function output
解析表格
到目前为止，我们已经学会了如何从单个元素中找到我们需要的数据。但是桌子呢？每次一个单元格一个单元格地遍历表格来查找必要的信息将会非常麻烦。注意，可以使用标签创建表格，也可以使用其他标签在 html 中创建类似表格的结构，我们将学习解析这两种类型。
因此，我们将创建一个函数，帮助以 2D 数组格式从表中获取表格数据。
首先，我们创建一个表格并显示它。
html = '''
**<table>
<tr>
<td>Month</td>
<td>Price</td>
</tr>
<tr>
<td>July</td>
<td>2</td>
</tr>
<tr>
<td>August</td>
<td>4</td>
</tr>
<tr>
<td>September</td>
<td>3</td>
</tr>
<tr>
<td>October</td>
<td>2</td>
</tr>
</table>**'''HTML(html)
Table to be parsed
在实际实现之前，让我用伪代码解释一下解析过程
Step 1: Initialise final **row_data** as empty list.
Step 2: Get all rows in a list
Step 3: **For** each row in the list of rows
- Initialise **current_row_data** as empty list
- Get a list of cells in the row.
- **For** each cell get its text content
# **if** no text content present skip to next cell
# **else** put the text content into **current_row_data
-** Put **current_row_data** into **row_data** Step 4: return **row_data**
以下 python 函数实现了这些步骤。我们将使用它来解析前面的表。
**def** *get_table_simple*(table,is_table_tag=**True**):
elems = table.find_all('tr') **if** is_table_tag **else** get_children(table)
table_data = list()
**for** row **in** elems:
row_data = list()
row_elems = get_children(row)
**for** elem **in** row_elems:
text = elem.text.strip().replace("**\n**","")
text = remove_multiple_spaces(text)
**if** ***len***(text)==0:
**continue**
row_data.append(text)
table_data.append(row_data)
**return** table_data
Using get_table_simple
让我们看看它是否能解析另一种类型的表。用
而不是标签创建的。
html = '''
<html>
<body>
<div id="table" class="FL" style="width:210px; padding-right:10px">
<div class="PA7 brdb">
<div class="FL gL_10 UC">MARKET CAP (Rs Cr)</div>
<div class="FR gD_12">63,783.84</div>
<div class="CL"></div>
</div>
<div class="PA7 brdb">
<div class="FL gL_10 UC">P/E</div>
<div class="FR gD_12">17.27</div>
<div class="CL"></div>
</div>
<div class="PA7 brdb">
<div class="FL gL_10 UC">BOOK VALUE (Rs)</div>
<div class="FR gD_12">589.29</div>
<div class="CL"></div>
</div>
<div class="PA7 brdb">
<div class="FL gL_10 UC">DIV (%)</div>
<div class="FR gD_12">4750.00%</div>
<div class="CL"></div>
</div>
<div class="PA7 brdb">
<div class="FL gL_10 UC">Market Lot</div>
<div class="FR gD_12">1</div>
<div class="CL"></div>
</div>
<div class="PA7 brdb">
<div class="FL gL_10 UC">INDUSTRY P/E</div>
<div class="FR gD_12">19.99</div>
<div class="CL"></div>
</div>
</div>
</body>
</html>
'''
HTML(html)content = BeautifulSoup(html,"html.parser")
get_table_simple(content.find("div",attrs={"id":"table"}),is_table_tag=**False**)
Parsed 2D table in python
如你所见，它也成功地解析了这个。
把它放在一起
让我们看看页面上我可以获取数据的地方。
data locations
我使用 chrome 开发工具检查了这些区域，并找到了正确的 id。对于下面的两个大框，我使用了我们之前写的get_table_simple函数。分步过程如下
Step 1: Get page content using requests
Step 2: Parse page content using BeautifulSoup
Step 3: Use chrome dev tool to find id of each highlighted block
Step 4: Get Price and yearly low, high.
Step 5: Get the lower two boxes enclosing tag.
Step 6: 1st box is 1st child, parse it as table.
Step 7: 2nd box is 2nd child, parse it as table.
Step 8: Combine the tables into a single dict named **collector**.
Step 9: Populate the final dict **key_val_pairs.**
最后一个函数如下。
Final Scrapping Function
为了使用这个函数，我们将页面 url 传递给它。
get_scrip_info("**https://www.moneycontrol.com/india/stockpricequote/auto-2-3-wheelers/heromotocorp/HHM**")
Final Data from Scraping.
我们下一步能做什么？
- 按 NSE 脚本名做搜索功能查找。(就像苹果是 APPL 一样，印度股票也有简称)
- 获取过去的价格以分析回报
- 处理 html 不正确的页面(没有语法正确的 html 的页面，浏览器会纠正它们，然后呈现，但是抓取它们会很困难)。
- 简单的地图操作并行化，加快抓取速度。
- 使用 dill 或 pickle 库存储抓取数据的快照。
- 使用各种图探索股票数据，如年度回报和价格偏差。
- 比较 Nifty 50、Nifty 100 和 Nifty Mid-cap 50 等指数的相互表现。ETF 跟踪指数，因此如果你投资 ETF，你需要了解指数的表现。
- 以市盈率、市净率等方式选股。
我将在以后的教程中介绍这些内容。
参考
[## 键盘快捷键参考 Web 开发人员工具| Google 开发人员
Chrome DevTools 中所有快捷键的参考。
developers.google.com](https://developers.google.com/web/tools/chrome-devtools/shortcuts) [## 用 Python 进行股票市场数据分析的介绍(第 1 部分)
这篇文章是过时的:这篇文章信息的更新在这里的链接！(我还打赌 WordPress.com…
ntguardian.wordpress.com](https://ntguardian.wordpress.com/2016/09/19/introduction-stock-market-data-python-1/) [## 用于股票的 Python
这是我上一篇文章的延续，这一次我们将做更多的图表来寻找多重…
mapattack.wordpress.com](https://mapattack.wordpress.com/2017/02/14/python-for-stocks-2/)
选股:傻瓜的黄金
投资管理中的数据科学
首先，我想说，我不认为成为一名成功的选股人是不可能的，但历史表明这是不可能的。
数字
选股难吗，如果难为什么？这些是我希望任何从事投资管理职业的人首先要解决的问题。如果你对这个问题的框架感兴趣，在我们进入为什么它很难之前，让我们从一个事实开始:
“历史回报的分布呈现正偏态”
这只是意味着，我们将全球指数(如罗素 3000 指数)令人难以置信的表现归功于少数“极端赢家”，即少数股票。从 1926 年到 2016 年，在 25300 家公司中，只有 1092 家公司对美国股市的上涨负责。从 1980 年到 2014 年，罗素 3000 指数中有 40%的股票提供了负回报，尽管该指数回报率为 2633.12%，股票中值跑输市场-54%。然而，最有趣的是，这些股票中的~7%可能被归类为极端赢家(图 1)。应该指出的是，即使我们排除技术和生物技术以避免网络泡沫造成的扭曲，我们也观察到了同样的情况。这个观察结果，很明显是一个呈现正偏态的分布，是直观的，有两个原因；首先，多头头寸的亏损被限制在 100%，其次，上行回报是无限的。
Figure 1
这对崭露头角的积极管理者有什么意义？
为了说明偏度的影响，我们从一个简单的模型开始。让我们构建一个权重相等的指数，包含五只股票，其回报曲线如图 2 所示。图 2 中的分布很明显具有我们想要的特性:正偏度。我们有一个明显的赢家，股票 E，我们的加权指数回报 18%。让我们假设一个积极的投资组合经理构建了一个包含 1 或 2 只股票的投资组合，因此，有 15 种可能的组合。
Figure 2
这些投资组合有以下可能的回报:
- 十个投资组合收益 10%；他们不会包括我们的明星，股票 e。
- 一个包含一只股票的投资组合将获得 50%的收益，因为它只持有股票 e。
- 两个股票投资组合将获得 30%的收益，其中一个是股票 e。
从我们的基本数字示例来看，由于忽略了股票 e，三分之二的主动管理投资组合的表现低于指数。此外，投资组合经理的中位数仅赚取 10%，平均经理的投资组合回报将等于我们的指数回报。这个基本例子暗示了以下内容:在我们考虑费用和交易成本之前，正偏度阻碍了积极经理的中位数。为什么？
如果主动型经理从指数中随机选择一部分股票，即在选股方面表现不佳，则平均水平的主动型经理的表现很可能会低于指数。
这取决于投资组合的构建
扩展这个简单的数字场景，我们使用蒙特卡罗模型试图更好地理解这一现象。让一只股票的价格，S^i，随着时间的推移，根据:
为了简单起见，我们假设所有股票的波动率恒定，𝛔 = 20%。我们在这里所做的，是模拟一个股票世界，这些股票将展现出我们在历史上看到的相同特征。也就是说，我们正在创造一种分布，确保我们产生少量的极端赢家和输家。假设每只股票的起始价格为 1.00 美元，那么我在时间 T 选择的股票价格由下式给出:
在这个模型中，我们将假设随着时间 T = 5(年)，预期指数回报率为 50%，中值回报率为 10%。因此，指数漂移为 4%，波动率为 13%。为了创建我们的投资组合，让我们运行蒙特卡罗模拟来生成 10，000 个模拟股票回报(利用等式 2)。然后，从这一组 10，000 只股票中随机抽样，我们在每个 1-20 只股票的子投资组合中创建 6000 只股票。对于给定的子投资组合规模，我们将跑赢指数的概率定义为随机抽样投资组合中超过指数回报率 50%的比例。绘制出每个子投资组合的优于和劣于表现的概率，我们得到图 3。
Figure 3
图 3(左)显示了随机选择的规模为 n 的投资组合优于或劣于基准的概率。图 3(右)显示了当我们考虑一个更极端的阈值(70%和 30%)时，优于和劣于表现的概率。很简单，与更大的投资组合相比，更大比例的高度集中的投资组合表现优异的可能性更低，表现不佳的可能性更高。
传统的主动管理者面临着一个固有的劣势。表现明显不佳的风险总是主导指数表现优于大盘的可能性。
怎样才能克服正偏？
抱怨传统的主动型经理很容易，尤其是考虑到他们的历史表现。然而，更有趣的是确定投资组合结构如何克服正偏度现象，这是我们传说中的选股者(宇宙的主人)的逆风。接下来显而易见的是，为什么量化股票产品不应被忽视。
拆除正偏度
我们看到，随着股票数量的增加，偏态效应下降。为了确定克服这种现象所需的股票数量，我们将通过观察主动经理投资组合回报的均值和中值之间的差异来量化偏度的影响。这些投资组合(代表我们假设的经理)是通过随机抽样标准普尔 500 从 1991 年到 2016 年的历史回报构建的。
我们首先假设:
- 我们的积极型经理每年年初都会创建买入并持有的投资组合
在构建投资组合时，我们从我们的标准普尔 500 宇宙中随机挑选(不替换)给定年份的固定数量的股票。我们构建了 5000 个这样的投资组合。我们评估的投资组合规模为:15、25、35、50、75 和 150 只股票。为了简单起见，我们还做了以下假设:
- 从我们所有的股票中选择任何一只股票的概率是相等的
- 我们创造同等权重的投资组合
在进一步讨论之前，让我们考虑一下为什么我们关心均值——中值分布。由于偏斜度的增加，我们在蒙特卡洛模型中向投资组合经理展示了这一点，我们随机生成的投资组合偶尔会包含极端赢家。这将增加平均经理的回报，而中位数经理将保持相对不受影响。
:随着我们增加投资组合中的股票数量，我们将观察到 1991 年至 2016 年投资组合的中值和平均投资组合经理回报率之间的利差更小。
这似乎很直观，因为我们增加了投资组合中的股票数量；我们增加了纳入少数极端赢家之一的可能性。为了清晰起见，我总结了一下这个模型。从 1991 年到 2016 年，从标准普尔 500 中选择了 5000 个引导投资组合。我们对 7 个不同的投资组合进行了这样的操作，每个投资组合都有不同的规模(15 支股票到 150 支股票)。然后，我们计算 1991 年至 2016 年在 bootstrap 程序中创建的投资组合回报的均值和中值之间的平均差异。
在图 1 中，我们展示了这种差异。我们的观察提供了一些量化股票产品(或低风险主动管理风格)背后的直觉。我们看到，随着持股数量的增加，偏斜度的影响/成本显著非线性下降。在此期间，我们的结果表明，对于持有 15 只股票的投资组合经理，偏差约为 70 个基点。对于拥有约 150 只股票的投资组合，这一偏差低于 20 个基点。尽管对大量股票的影响仍然是可测量的，但我们已经大大降低了由均值-中值差测量的偏斜度相关的成本。
Figure 1
为了将这一点与我们上面的发现联系起来，我们考虑了每个子投资组合的超越概率。让我们考虑一个同等权重的标准普尔 500；我们假设这一点是为了与我们同等权重的 bootstrap 投资组合进行公平比较。如果我们绘制一段时间内表现优于同等权重基准的子投资组合的平均数，我们会得到图 2。
Figure 2
我们已经证明，随着我们纳入越来越多的股票，纳入极端赢家的概率会增加，因此，中等积极投资组合经理有更大的概率跑赢他/她的基准。
那么，这与量化股票产品到底有什么关系呢？
为了确定这种现象如何影响基于因素的量化策略，我应用了之前使用的 bootstrap 投资组合模型，但是，在这种情况下，我们不会对选择的任何给定股票应用相同的概率。相反，我们执行以下操作:
- 我们根据阿尔法分数来偏向标准普尔 500 成分的选择
- 指定任何给定成分被选中的概率与其 alpha 分数成比例，即 alpha 分数越高，其被选中的概率越高
我们通过组合三个风险溢价的组成“z 分数”(简单地认为是一个排名)来生成“α分数”:
- 价值:被低估或便宜的股票
- 质量:基础资产负债表的实力和管理能力
- 势头:表现好/差的股票继续表现好/差
具体来说，z 值越高，在给定因素下，该股票相对于同行的排名就越好。因此，通过组合这些 z 分数，我们获得了一个 alpha 分数，其中最高的 alpha 分数表示一只股票相对于它的同行来说最能获得所有三个风险溢价。
此外，在此过程中，我们通过优化器的构建纳入了小盘股偏好，这将我们的投资组合推向相等的权重，以避免股票特定的风险，因此，在此实验中，我们将对 bootstrap 投资组合进行相等的加权，以反映这一点。随机抽样(没有替换)，我们为每个投资组合规模形成 1000 个投资组合。跑赢基准的投资组合比例是通过确定超额收益为正的投资组合比例来计算的。从 1991 年 12 月 31 日到 2016 年 12 月 30 日的跑赢大盘的概率中值如图 3(右)所示。
Figure 3
在图 3(左)中，我们看到偏斜度的“成本”大幅降低，正如我们在之前的实验中所做的那样。然而，最有趣的是，当我们应用回溯测试的 alpha 分数时，对于中等假设风险溢价的投资组合经理来说，跑赢的概率大于跑输的概率。我们观察到，在 150 只股票时，表现优异的概率达到峰值，而在 150 只股票时，表现不佳的概率最低。这并不是说 150 是黄金数；然而，它为我们提供了第一步，以确定一个更优化的投资组合构建方法来对抗正偏度。
结束语
这两篇文章旨在描述和说明历史收益的一个经常被忽视但极其重要的性质，正偏度。
正偏度的含义是，整体指数回报可以由相对较少的股票驱动，这反过来会给集中投资组合的经理带来很大的阻力。
在主动与被动的辩论中，焦点通常集中在费用、技能和交易成本上。从提供的证据来看，偏态也应该包括在这些讨论中。
我们在一定程度上理解了更大投资组合的好处。量化投资产品，如增强型指数或 smart beta，都包含相对较高数量的股票，以抵消这种影响。
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
参考文献
- h . bessembinder(2017 年)。股票表现优于国库券吗？，https://ssrn.com/abstract=2900447.
- 图 1 见https://www . chase . com/content/dam/private banking/en/mobile/documents/eotm/eotm _ 2014 _ 09 _ 02 _ agonyescstasy . pdf
- 为了简洁起见，省略了推导和进一步的解释。如果读者想更好地理解这些价值观，请参见:https://papers.ssrn.com/sol3/papers.cfm?abstract_id=2673262
- 摩根大通。(2014).关注市场，特别版:痛苦与狂喜:集中股票头寸的风险与回报。
- 希顿，J.B .和波尔森，尼克和维特，简·亨德里克。(2017 年 5 月 10 日)。为什么索引有效。https://ssrn.com/abstract=2673262 SSRN有售
- 伊肯伯里、D.L、R.L .肖克利和 K.L .沃马克。(1992).为什么积极的经理经常跑输 S&P500:规模和偏斜的影响，私人投资组合管理杂志，1(1)，13-26。
Python 中的股票预测
学习真正的蟒蛇时制造(和失去)假财富
试图预测股市对数据科学家来说是一个诱人的前景，他们的动机与其说是为了物质利益，不如说是为了挑战。我们看到市场每天的涨跌，想象一定有我们或我们的模型可以学习的模式，以击败那些有商业学位的日内交易者。自然，当我开始使用可加模型进行时间序列预测时，我必须在股票市场的试验场用模拟资金测试该方法。不可避免的是，我加入了那些试图日复一日战胜市场却失败的人的行列。然而，在这个过程中，我学到了大量的 Python，包括面向对象编程、数据操作、建模和可视化。我也发现了为什么我们应该避免在不损失一美元的情况下玩每日股票市场(我只能说玩长线游戏)！
One day vs 30 years: which would you rather put your money on?
当我们在任何任务中，而不仅仅是在数据科学中，没有立即获得成功时，我们有三个选择:
- 调整结果，让它看起来像我们成功了
- 隐藏结果，这样没人会注意到
- 展示我们所有的成果和方法，以便他人(和我们自己)可以学习如何把事情做得更好
虽然第三种选择在个人和社区层面上是最好的选择，但实施起来需要最大的勇气。当我的模型带来可观的利润时，我可以有选择地选择范围，或者我可以扔掉它，假装我从来没有花时间在它上面。这似乎太天真了！我们通过反复失败和学习来进步，而不仅仅是促进我们的成功。而且，为一个困难任务写的 Python 代码，不是白写的 Python 代码！
这篇文章记录了我用 Python 开发的“股票浏览器”工具 Stocker 的预测能力。在之前的文章中，我展示了如何使用 Stocker 进行分析，GitHub 上的完整代码可供任何想要自己使用或为项目做出贡献的人使用。
预测用储料器
Stocker 是一个用于股票探索的 Python 工具。一旦我们安装了所需的库(查看文档),我们就可以在与脚本相同的文件夹中启动一个 Jupyter 笔记本，并导入 Stocker 类:
from stocker import Stocker
现在可以在我们的会话中访问该类。我们通过向 Stocker 类传递任何有效的股票行情自动收录器来构造一个对象( bold 是输出):
amazon = Stocker('AMZN')**AMZN Stocker Initialized. Data covers 1997-05-16 to 2018-01-18.**
就像我们有 20 年的每日亚马逊股票数据要探索一样！Stocker 建立在 Quandl 金融图书馆的基础上，有 3000 多种股票可供使用。我们可以使用plot_stock方法绘制一个简单的股票历史图:
amazon.plot_stock()**Maximum Adj. Close = 1305.20 on 2018-01-12.
Minimum Adj. Close = 1.40 on 1997-05-22.
Current Adj. Close = 1293.32.**
Stocker 的分析功能可用于发现数据中的总体趋势和模式，但我们将专注于预测未来价格。Stocker 中的预测是使用加法模型做出的，该模型将时间序列视为不同时间尺度(如每日、每周和每月)上的总体趋势和季节性的组合。Stocker 使用脸书开发的 prophet 软件包进行附加建模。使用 Stocker 可以在一行中创建模型并做出预测:
# predict days into the future
model, model_data = amazon.create_prophet_model(days=90)**Predicted Price on 2018-04-18 = $1336.98**
请注意，预测中的绿线包含一个置信区间。这代表了模型在预测中的不确定性。在这种情况下，置信区间宽度被设置为 80%，这意味着我们期望这个范围在 80%的时间内包含实际值。置信区间随着时间的推移变得越来越宽，因为估计值随着远离数据而具有更多的不确定性。任何时候我们做预测都必须包括一个置信区间。虽然大多数人倾向于想要一个关于未来的简单答案，但我们的预测必须反映出我们生活在一个不确定的世界中！
任何人都可以进行股票预测:简单地选择一个数字，这就是你的估计(我可能是错的，但我很确定这是华尔街所有人都做的)。为了让我们相信我们的模型，我们需要评估它的准确性。Stocker 中有许多评估模型准确性的方法。
评估预测
为了计算准确度，我们需要一个测试集和一个训练集。我们需要知道测试集的答案——实际的股票价格，因此我们将使用过去一年的历史数据(在我们的例子中是 2017 年)。训练时，我们不让模型看到测试集的答案，所以我们使用测试时间范围(2014-2016)之前三年的数据。监督学习的基本思想是模型从训练集中学习数据中的模式和关系，然后能够正确地为测试数据重现它们。
我们需要量化我们的准确性，因此我们使用测试集的预测和实际值，我们计算指标，包括测试和训练集的平均美元误差、我们正确预测价格变化方向的时间百分比，以及实际价格落在预测的 80%置信区间内的时间百分比。所有这些计算都是由 Stocker 以直观的方式自动完成的:
amazon.evaluate_prediction()**Prediction Range: 2017-01-18 to 2018-01-18.
Predicted price on 2018-01-17 = $814.77.
Actual price on 2018-01-17 = $1295.00.
Average Absolute Error on Training Data = $18.21.
Average Absolute Error on Testing Data = $183.86.
When the model predicted an increase, the price increased 57.66% of the time.
When the model predicted a decrease, the price decreased 44.64% of the time.
The actual value was within the 80% confidence interval 20.00% of the time.**
这些都是糟糕的数据！我们还不如抛硬币呢。如果我们用这笔钱来投资，我们可能会更好地购买一些明智的东西，如彩票。然而，不要放弃这个模型。我们通常认为第一个模型相当糟糕，因为我们使用的是默认设置(称为超参数)。如果我们最初的尝试不成功，我们可以调整这些旋钮来制造更好的模型。在 Prophet 模型中有许多不同的设置需要调整，其中最重要的是 changepoint prior scale，它控制模型在数据趋势变化中所占的权重。
变点优先选择
变点表示时间序列从增加到减少或从缓慢增加到快速增加(反之亦然)。它们出现在时间序列中变化率最大的地方。变点先验比例表示模型中变点的强调程度。这用于控制过拟合与欠拟合(也称为偏差与方差权衡)。
更高的先验创建的模型在变点上具有更大的权重和更灵活的拟合。这可能会导致过度拟合，因为模型会紧密地粘着训练数据，而不能推广到新的测试数据。降低先验会降低模型的灵活性，这会导致相反的问题:拟合不足。当我们的模型没有足够紧密地跟踪训练数据，并且未能学习底层模式时，就会发生这种情况。找出适当的设置来实现正确的平衡更多的是一个工程问题，而不是理论问题，在这里我们必须依靠经验结果。Stocker 类包含两种不同的方法来选择合适的先验:直观的和定量的。我们可以从图解法开始:
# changepoint priors is the list of changepoints to evaluate
amazon.changepoint_prior_analysis(changepoint_priors=[0.001, 0.05, 0.1, 0.2])
在这里，我们根据三年的数据进行训练，然后显示六个月的预测。我们在这里没有量化预测，因为我们只是试图理解变点先验的作用。这张图很好地说明了欠拟合和过拟合！最低的先验，蓝线，没有非常紧密地跟随训练数据，即黑色的观察值。它有点像是在做自己的事情，在数据的大致范围内选择一条路线。相比之下，最高的先验(黄线)尽可能接近地坚持训练观察。变点先验的默认值是 0.05，介于两个极端值之间。
还要注意先验不确定性(阴影区间)的差异。最低先验对训练数据的不确定性最大，但对测试数据的不确定性最小。相反，最高先验在训练数据上具有最小的不确定性，但是在测试数据上具有最大的不确定性。先验越高，它对训练数据就越有信心，因为它紧密地跟随每个观察。然而，当涉及到测试数据时，由于没有任何数据点来锚定，过拟合模型会丢失。由于股票有相当多的可变性，我们可能需要一个比默认模型更灵活的模型，以便该模型可以捕捉尽可能多的模式。
既然我们对先验的影响有了一个概念，我们可以使用一个训练和验证集对不同的值进行数值评估:
amazon.changepoint_prior_validation(start_date='2016-01-04', end_date='2017-01-03', changepoint_priors=[0.001, 0.05, 0.1, 0.2])**Validation Range 2016-01-04 to 2017-01-03.
cps train_err train_range test_err test_range
0.001 44.507495 152.673436 149.443609 153.341861
0.050 11.207666 35.840138 151.735924 141.033870
0.100 10.717128 34.537544 153.260198 166.390896
0.200 9.653979 31.735506 129.227310 342.205583**
在这里，我们必须小心，我们的验证数据和我们的测试数据是不一样的。如果是这种情况，我们将为测试数据创建最佳模型，但这样我们将会过度拟合测试数据，并且我们的模型不能转化为真实世界的数据。总的来说，正如数据科学中通常所做的那样，我们使用三个不同的数据集:训练集(2013-2015)，验证集(2016)，测试集(2017)。
我们用四个度量标准评估了四个先验:训练误差、训练范围(置信区间)、测试误差和测试范围(置信区间)，所有值都用美元表示。正如我们在图中看到的，先验越高，训练误差越低，训练数据的不确定性越低。我们还看到，更高的先验降低了我们的测试误差，支持了我们的直觉，即紧密拟合数据是股票的一个好主意。作为对测试集更高准确性的交换，随着先验的增加，我们在测试数据上获得了更大范围的不确定性。
“储料器优先验证”还显示了说明这些点的两个图表:
Training and Testing Accuracy Curves and Uncertainty for Different Changepoint Prior Scales
由于最高的先验产生最低的测试误差，我们应该尝试将先验增加得更高，看看我们是否能获得更好的性能。我们可以通过向验证方法传递额外的值来改进我们的搜索:
# test more changepoint priors on same validation range
amazon.changepoint_prior_validation(start_date='2016-01-04', end_date='2017-01-03', changepoint_priors=[0.15, 0.2, 0.25,0.4, 0.5, 0.6])
Refined Training and Testing Curves
测试集误差在先验值为 0.5 时最小。我们将适当地设置 Stocker 对象的 changepoint prior 属性。
amazon.changepoint_prior_scale = 0.5
我们可以调整模型的其他设置，例如我们期望看到的模式，或者模型使用的数据的训练年数。寻找最佳组合只需要用许多不同的值重复上述过程。请随意尝试任何设置！
评估精炼模型
既然我们的模型已经优化，我们可以再次评估它:
amazon.evaluate_prediction()**Prediction Range: 2017-01-18 to 2018-01-18.
Predicted price on 2018-01-17 = $1164.10.
Actual price on 2018-01-17 = $1295.00.
Average Absolute Error on Training Data = $10.22.
Average Absolute Error on Testing Data = $101.19.
When the model predicted an increase, the price increased 57.99% of the time.
When the model predicted a decrease, the price decreased 46.25% of the time.
The actual value was within the 80% confidence interval 95.20% of the time.**
这样看起来更好！由此可见模型优化的重要性。使用默认值提供了一个合理的初步猜测，但我们需要确保我们使用的是正确的模型“设置”，就像我们试图通过调整平衡和渐变来优化立体声的声音一样(很抱歉使用了过时的参考)。
玩股票市场
做预测是一项有趣的工作，但真正有趣的是观察这些预测在实际市场中的表现。使用evaluate_prediction方法，我们可以在评估期内使用我们的模型“玩”股票市场。我们将使用我们的模型提供的策略，然后我们可以将其与在整个期间购买和持有股票的简单策略进行比较。
我们策略的规则很简单:
- 模型预测股票每天都会上涨，我们在当天开始时买入股票，在当天结束时卖出。当模型预测价格下降时，我们不买任何股票。
- 如果我们买了股票，价格在一天内上涨，我们就把涨幅乘以我们买的股票数量。
- 如果我们买了股票，价格下跌，我们损失的是下跌的股票数量。
我们在整个评估期间每天都播放这个，在我们的情况下是 2017 年。若要播放，请将份额数添加到方法调用中。斯托克会用数字和图表告诉我们这个策略是如何实施的:
# Going big
amazon.evaluate_prediction(nshares=1000)**You played the stock market in AMZN from 2017-01-18 to 2018-01-18 with 1000 shares.
When the model predicted an increase, the price increased 57.99% of the time.
When the model predicted a decrease, the price decreased 46.25% of the time.
The total profit using the Prophet model = $299580.00.
The Buy and Hold strategy profit = $487520.00.
Thanks for playing the stock market!**
这给我们上了宝贵的一课:买入并持有！虽然按照我们的策略，我们会赚到一大笔钱，但更好的选择是进行长期投资。
我们可以尝试其他的测试期，看看我们的模型策略是否能战胜买入并持有法。我们的策略相当保守，因为当我们预测市场下跌时，我们不参与，所以当股票下跌时，我们可能期望比持有策略做得更好。
Always play with fake money!
我就知道我们的模特能行！然而，我们的模型只有在我们有后知之明选择测试期时才跑赢市场。
未来预测
既然我们对自己有一个像样的模型感到满意，我们可以使用predict_future()方法进行未来预测。
amazon.predict_future(days=10)
amazon.predict_future(days=100)
Predictions for the next 10 and 100 days
该模型总体上看好亚马逊，就像大多数“专业人士”一样此外，随着我们按照预期进行评估，不确定性会越来越大。实际上，如果我们使用这个模型进行积极的交易，我们将每天训练一个新的模型，并对未来最多一天进行预测。
虽然我们可能不会从 Stocker 工具中变得富有，但好处在于开发而不是最终结果！直到我们尝试了，我们才知道我们是否能解决问题，但是尝试过但失败了总比从来没有尝试过好！对于任何有兴趣查看代码或自己使用 Stocker 的人来说，GitHub 上有。
一如既往，我喜欢反馈和建设性的批评。我可以通过推特 @koehrsen_will 联系到。
股票预测—当天交易
在当今世界，随着计算机科学的巨大进步和硅产业的快速发展，股票是人们所依赖的主要资产之一。大多数人，凭借对市场、统计数据和大量“直觉”的充分了解，正在将他们辛苦赚来的钱投资于公司股票。然后我们有被称为“冒险者”的人，他们相信对商业、时事和数学的理解。他们是日内交易的主要参与者(人们可以将其归类为股票市场中风险最高的投资之一，相当于赌博)。
Courtesy: Premier Health Group Inc
现在让我们对将要处理的问题集有一个简单的概念。
日内交易是股票市场交易规范，其归属期为、，通俗地说， 1 天。买家在特定时间窗口开市时买入股票，然后在当天收盘时卖出。我们在这里处理东京一家上市公司的数据集，从 2014 年到 2016 年两年的每日数据。我们将使用一个简单的机器学习模型来:
- 了解我们的数据
- 基于算法进行预测
作为参考，这里是我的 Github 库的链接，其中包含:
- 用于执行分析的 Python 脚本
- csv 格式的测试数据
- csv 格式的训练数据
预测日内股票的 Python 程序。通过创建……为 bmonikraj/股票预测-日内发展做出贡献
github.com](https://github.com/bmonikraj/stock-prediction-intraday)
现在，既然您可以在我的知识库中找到所有的 python 代码，我就不再带您浏览代码库或向您解释相同的内容，以免让您感到厌烦。这个脚本很简单，独立且相当直观，所以很容易理解。我还在任何需要的地方记录了脚本，而且如果你被卡住了，你可以随时在【bmonikraj@gmail.com发送邮件，并期待一天内的回复。
我在印度 NIT Rourkela 的教授曾经说过，“理解数据和问题集与分析数据和问题集所需的统计知识同样重要”。我们需要了解日内交易以及定义我们目标价值行为的各个方面。
因此，我们的数据集由 7 列组成，其中 6 列是特征，1 列是目标。
功能
- 开盘——这是某一天 a 股的开盘价
- 高——这是股票全天触及的最高价格
- 低——这是股票全天下跌的最低价格
- 收盘——这是当天股票的收盘价
- 日期——观察的日期，主要是数据的索引
- 成交量——全天卖出的股票数量
目标
- 股票交易-当天市场上所有股票的价格
现在，由于我们的数据有一个【时间】成分，我们的数据很可能是一个时间序列数据。但是一个数据要成为时间序列数据，它必须有一个【趋势】或【季节性】的因素。为了检查我们的数据集本质上是季节性的还是趋势性的，我们可以执行“ Dickey-Fuller 分析”。如果我们的数据集本质上是季节性的，那么我们可以把它作为“时间序列”数据来分析。
在 Python 中实现 Dickey-fuller 分析时，它需要一个变量，“频率”。频率在数学上定义为
Frequency = (Total time units expected till which data will show repetative patter, in minutes) / (time gap between each observations, in minutes)
现在，在我们的数据集中，我们有基本的日内交易数据。也就是说，我们的数据基于市场的日常行为、市场或行业中的事件、公司管理层的变动、买家的利益、政策以及其他类似的控制因素。因此，我们可以强烈地相信，我们的数据不会显示任何模式超过一天。此外，从数据集可以明显看出，我们的观察频率是一天。所以，我们选择频率为 1。
这是我的数据集的迪克-富勒分析报告
Dickey Fuller analysis
从上图可以清楚地看出，我们的数据在行为上不是季节性的，这意味着我们的数据集不是“时间序列”数据集，因为季节性为 0。
现在，在将季节性从等式中移除后，我们有了一个本质上完全是数字的数据集，它有五个特征，因为“时间”不再是一个需要考虑的特征，因为它不是时间序列数据。
我们可以在这里找到各种功能和目标随时间变化的行为图
Open price of stock
Close price of stock
High price of stock
Low price of stock
Volumes of stock
Total stocks traded
从上面，我们可以看到特征相对于时间的个体行为。我们还可以得到每个特征之间的相互关联图，了解每个特征之间的相互依赖关系。
Correlation matrix for all features and data
从上图中，对角矩阵给出了每列值的直方图，这对我们没有用，因为我们对特征或目标的分布不感兴趣(因为变量的数量很大，并且它们也是相关的)。
关于理解相关矩阵图的一般说明
- 如果总图看起来像一条曲线(线性或非线性)，那么它们在很大程度上是相关的
- 如果图看起来是分散的，那么它们不会像预期的那样相互关联
现在，我们可以从上面的图表中推断出，大部分的特征都是相互依赖相互关联的。“开放”与“高”、“低”和“关闭”高度相关。“交易量”在很大程度上与目标“股票交易”相关。因此，所有的特征对于分析都是重要的。
这个问题现在可以用下面的简单术语来阐述:
- 数据集包含所有数值
- 特征数量=尺寸= 5
- 一个目标
- 目标是“预测的”(数字)
- 火车大小< 1000
From the above list, it is the best option to choose linear regression model for the same because
- It is a problem of prediction , so a regressor must be used
- Since the dimension is quite small and so thus the train size, any complex and sophisticated model, like SVM regressor can overfit the model (你可以试试！)
从 Python 的 scikit-learn 模块实现线性回归后，在测试数据上测试我们的模型后，我们得到【RMSE = 4253929991.85，
该值似乎太高，似乎不合适，但我们不能忘记这样一个事实，即特征的顺序和目标值彼此不相似或不接近。
【T6【股票交易】 ( 10 ) > >中的数值顺序中的数值顺序 (10⁵ ~ 10⁶)
因此，从这种方式来看，考虑到计算均方误差的顺序，RMSE 顺序是合理的。这是实际测试目标和计算测试目标的曲线图。由此，您可以看到偏差有多小，从而了解我们模型的性能。
The deviation in actual test target and calculated test target
将机器学习和算法的知识应用于日常生活场景和更好的决策是这种学术进步的主要目的。毕竟，“数字在决策中起着重要的作用，因为数字从不说谎”。
如果我可以在文章的最后做个总结——“你不需要用剑来剪指甲”
如果您有任何疑问，请联系我，电话:bmonikraj@gmail.com
来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
Stock2Vec —从 ML 到 P/E
希望这篇文章是我通过应用 ML 来了解它的系列文章的第一篇。你可以在这里 找到这篇博文的代码 。
Word2Vec 是一个简单却惊人强大的算法。
它构建了单词向量来表示单词含义。它仅仅通过周围的单词来学习这些意思。然后，您可以使用这些单词向量作为输入，使机器学习算法执行得更好并找到有趣的抽象。
如果我们把 Word2Vec 应用到股市会怎么样？
选择 Stock2Vec 窗口
在 Word2Vec 中，每个单词的窗口都是周围的单词。对于 Stock2Vec 我们应该如何挑选每只股票的周边股票？
股票市场有大量的变量可供选择:价格、成交量、移动平均线等。在和我在金融行业工作的朋友 Yuhi 讨论后，我们选择了市盈率。市盈率代表了市场对公司成长的预期。
希望它能学到点什么！
建筑股票 2Vec
在阅读 Quantopian 的 Zipline 的 API 文档时，我偶然发现了 Quandl Wiki 数据集，其中有 3000 家公司长达 40 年的免费数据。我将价格数据和基本面数据结合起来，这些数据都是从沙拉达尔那里购买的。然后我用 postgres 合并数据。预处理代码是这里是。
我改编了嵌入项目，它是我上周刚完成的 Udacity 深度学习课程的一部分:在 FloydHub 上训练模型，并用 TensorBoard 可视化结果。你可以在这里找到训练代码。
从第一个输出可以清楚地看出，Stock2Vec 学会了将相似的行业组合在一起。
Tickers grouped by their vector similarity after 12 epochs
Stock2Vec 将生物制药公司归为一类:Vivus、Vical、Sarepta、ArQule、BioCryst 和 Siga。医疗公司:麦克森和希尔罗姆。医疗保健:安泰和信诺。服装公司:Gap 和 Guess、VF Corp 和 Wolverine World Wide。零售商:Office Depot 和 Best Buy。银行:太阳银行和 CapitalSource。
酷！！
经过 20 个时期的训练后，这些是用 t-SNE 绘制的嵌入。
如果我们选择一只股票，PNC 银行，我们可以看到最近的邻居。
PNC Nearest Neighbors t-SNE
它们都是银行:富国银行、第一金融公司、高盛、信安金融集团、U.S. Bancorp、JP Morgan、Northrim Bancorp、StanCorp Financial Group、Camden National。
让我们再选一个，WTI——一个石油和天然气探索者。
最近的邻居都是能源公司:切萨皮克能源公司、斯通能源公司、Gastar 勘探公司、登伯里资源公司、Bonanza Creek 能源公司。
接下来的步骤
我正在研究一种新的算法，而不是深入研究 Stock2Vec，因为我想学习各种各样的算法。但是还有很多需要改进和未来研究的地方。
预处理可以调整，不经常出现在同一个窗口的股票可以被删除。训练数据可以具有更高的分辨率，每分钟或 15 分钟。窗口函数可以使用其他变量、移动平均、β等。
有没有发现什么有趣的关系？SNAP 减 FB = MSFT 吗？如果你对这方面的研究感兴趣，我很乐意分享矢量数据。
这个项目很有趣，我学到了很多关于单词嵌入、numpy、TensorFlow 和 TensorBoard 的知识。我对我的下一个项目感到非常兴奋！
如果你在评论中有任何问题或建议，请告诉我，或者随时给我发电子邮件。
— —
感谢 Yuhi 和 Gal 帮助购买基本面数据:)。
出于性能考虑，停止使用 pip 安装 Tensorflow！
停止使用 pip 安装 Tensorflow！用康达代替。如果你不知道 conda 是什么，它是一个跨平台运行的开源包和环境管理系统。所以它可以在 Mac、Windows 和 Linux 上运行。如果您还没有使用 conda，我建议您开始使用，因为它让管理您的数据科学工具变得更加愉快。
这里有两个很大的理由说明为什么你应该用 conda 而不是 pip 来安装 Tensorflow。
更快的 CPU 性能
从版本 1.9.0 开始，conda Tensorflow 软件包利用英特尔数学内核库构建深度神经网络或 MKL-DNN。这个库极大地提高了性能。这里有一张图表可以证明！
Chart taken from https://www.anaconda.com/blog/developer-blog/tensorflow-in-anaconda/
如你所见，与 pip 安装相比，conda 安装的性能可以提供8 倍的速度提升。这对那些仍然频繁使用 CPU 进行训练和推理的人来说是非常好的。作为一名机器学习工程师，我使用我的 CPU 对我的代码进行测试，然后将其推送到支持 GPU 的机器上。这种速度的提高将帮助我更快地迭代。我还尽可能在 CPU 上做大量的推理，因此这将有助于我的模型的性能。
MKL 库不仅提高了 Tensorflow 包的速度，还提高了其他广泛使用的库的速度，如 NumPy、NumpyExr、SciPy 和 Scikit-Learn！从下面的链接看你如何设置。
GPU 版本的安装更简单
conda 安装将自动安装 GPU 支持所需的 CUDA 和 CuDNN 库。pip 安装将要求您手动完成。每个人都喜欢一步到位的过程，尤其是在下载库的时候。
快速启动
所以我希望这两个理由足以让你转而使用康达。如果你确信这是开始的步骤。
pip uninstall tensorflow
如果你还没有安装巨蟒或者迷你巨蟒的话。Miniconda 只是安装 conda 和它的依赖项，而 Anaconda 会为你预装很多包。我更喜欢 Miniconda 入门。安装 conda 后，尝试以下方法。
conda install tensorflow
如果想要 gpu 启用版本，用 tensorflow-gpu 替换 tensorflow。
除了使用 Tensorflow 更快更简单之外，conda 还提供了其他工具集，使其更容易集成到您的工作流程中。我最喜欢的是他们的虚拟环境功能。你可以在这里阅读更多关于 conda 和 tensorflow 的内容。更多关于 MKL 优化这里。希望这有所帮助，一如既往，感谢阅读！
我写了很多这样的帖子！如果你喜欢这个，看看我在 micahelphi.com的其他内容
✍🏽想要更多内容？查看我的博客https://www.michaelphi.com
📺喜欢看基于项目的视频？看看我的 Youtube ！
🥇通过注册我的 电子邮件简讯 ，了解最新的文章和视频！
别嘲笑我了！使用 Python 的模拟库在 PySpark 中进行单元测试
测试。
这是软件开发的基础，也是经常被数据科学家忽视的，但是非常重要。在这篇文章中，我将展示如何使用 Python 的 unittest.mock 库在 PySpark 中进行单元测试。我将从数据科学家的角度来做这件事——对我来说，这意味着我不会深入软件工程的细节。我只提供你需要知道的。
首先，一个来自《一家人》的(半)相关片段:
什么是单元测试？什么是模仿？
单元测试是一种测试代码片段的方法，以确保事情按预期运行。Python 中的 unittest.mock 库允许您用模拟对象替换部分代码，并断言它们是如何被使用的。“模拟”是一个顾名思义的对象——它模拟代码中对象/变量的属性。
最终目标:测试 spark.sql(查询)
在 PySpark 中创建数据帧的一个简单方法是执行以下操作:
df = spark.sql("SELECT * FROM table")
虽然简单，但是要测试。
代码和问题设置
假设我们为一家电子商务服装公司工作，我们的目标是创建一个根据某些条件过滤的产品相似性表，并将其写入 HDFS。
假设我们有以下表格:
1\. Products. Columns: “item_id”, “category_id”.2\. Product_similarity (unfiltered). Columns: “item_id_1”, “item_id_2”, “similarity_score”.
(假设 product_similarity 中的分数在 0 和 1 之间，其中分数越接近 1，项目越相似。如果你感兴趣的话，请看我在相似性度量上的文章。
查看成对的项目及其分数非常简单:
where 子句用于删除将项目与其自身进行比较的行。分数永远是 1。多无聊啊！
但是，如果我们想要创建一个表，向我们显示属于同一类别的项目的相似性，该怎么办呢？如果我们不在乎把鞋子比作围巾，而是想把鞋子比作鞋子，把围巾比作围巾，怎么办？这有点复杂，需要我们连接“products”和“product_similarity”表。
该查询将变成:
我们可能还想获得每种产品的最多 N 个相似商品，因此在这种情况下，我们的查询将变成:
(假设我们用 N = 10)。
现在，如果我们希望选择跨类别比较产品，或者只在类别内比较产品，该怎么办？我们可以通过使用一个名为 same_category 的布尔变量来实现这一点，该变量会产生一个字符串 same_category_q ，该字符串可以被传递到整个查询中(使用)。format() )，如果我们的布尔 same_category 为真，将等于上面的内部连接，如果为假，则为空。该查询将类似于:
让我们说得更清楚一点，将这个逻辑封装在一个返回 same_category_q 的函数中:
到目前为止，一切顺利。我们输出查询 same_category_q ,这样我们可以测试我们的函数，以确保它返回我们想要它返回的内容。
牢记我们的最终目标，我们想写一个数据帧给 HDFS。我们可以通过以下函数来实现这一点:
添加查询的第一部分和一个 main 方法来完成我们的脚本，我们得到:
这里的想法是，我们希望为脚本中的每个函数创建一个函数，一般命名为 test_name_of_function() 。我们想要测试函数的行为是否正常，我们通过到处使用 assert 语句来确保这一点。
Test_make_query，真与假
首先，让我们测试一下 make_query 函数。回想一下 make_query 接受两个输入:一个布尔变量和一些表路径。它将根据布尔值 same_category 为 same_category_q 返回不同的值。我们在这里做的有点像一组 if-then 语句:
1\. If same_category is True, then same_category_q = “INNER JOIN …”2\. If same_category is False, then same_category_q = “” (empty)
我们所做的是模仿 make_query 的参数，并将它们传入，然后测试我们是否得到了想要的输出。由于 test_paths 是一个字典，我们不需要模仿它。测试脚本如下，为了更加清晰，添加了注释。
而且就是这么简单！
测试我们的表创建
接下来，我们需要测试我们的 create_new_table 函数的行为是否正常。通过这个函数，我们看到它做了几件事，有几次机会做一些断言和模拟。注意，每当我们有类似df . write . save . something . another thing的东西时，我们需要模拟每个操作及其输出。
- 该函数以火花为参数。这需要被嘲笑。
- 通过调用spark . SQL(create _ table _ query . format( * some _ args))*创建 created_table。我们要断言 spark.sql() 只被调用一次。我们还需要模拟 spark.sql() 的输出。
- 合并已创建 _ 表。确保用参数 1 调用 coalesce() 。模仿输出。
- 写入合并后的表。我们需要嘲讽。编写，在我们的表上模拟调用它的输出。
- 将合并的表保存到保存路径。确保用正确的参数调用它。
和以前一样，测试脚本如下，为了清楚起见，添加了注释。
最后，把所有的东西一起保存在一个文件夹里。如果你愿意，你可以从它们各自的模块中导入函数，或者把所有的东西都放在一个脚本中。
要测试它，在命令行中导航到您的文件夹( cd 文件夹/working_folder )并调用:
python -m pytest final_test.py.
您应该看到类似这样的内容(请原谅这种格式):
serena@Comp-205:~/workspace$ python -m pytest testing_tutorial.py ============================= test session starts ============================== platform linux -- Python 3.6.4, pytest-3.3.2, py-1.5.2, pluggy-0.6.0 rootdir: /home/serena/workspace/Personal, inifile: plugins: mock-1.10.0 collected 3 items testing_tutorial.py ... [100%] =========================== 3 passed in 0.01 seconds ===========================
就是这样！
这就是了。我希望这有所帮助。当我试图找出如何嘲笑时，我希望我遇到过类似这样的教程。现在继续吧，就像 Stewie 说的，(不要)停止嘲笑我(函数)！
原载于 2018 年 11 月 7 日 serena.mcdonnell.ca。
在你读完这个之前，停止运行面部识别
如今，在视频中使用机器学习驱动的面部识别存在一个非常大的问题。事实上，它可以是一个节目停止。
面部识别可以成为告诉你谁在视频中的强大工具。这对于在我们每天都可以获得的数十亿小时的媒体内容中标记演员、政治家和运动员来说是非常棒的。它也非常适合在安全摄像机镜头中寻找嫌疑人或在旧的家庭照片中定位亲戚。
我们大多数人都不介意花一两秒钟来识别照片中的一些面孔，或者我们不介意在一段视频中找到人所需的处理时间。
但是，如果你把这个乘以成百上千的资产，你会发现大量的时间和资源需要专门用于处理面部识别。
随着今天当前的机器学习即服务(MLaaS)产品，如 Google Vision、Microsoft Azure、IBM Watson 等。您将所有视频资产传递给它们的公共 API 端点，作为回报，您将获得一些元数据，这些元数据是关于谁在某个视频中以及在哪里。元数据可能如下所示:
{
**"faces"**:[
{
**"key"**:"Al Roker",
**"instances"**:[
{
**"start"**:150,
**"end"**:150,
**"start_ms"**:5005,
**"end_ms"**:5005,
**"confidence"**:0.6983038746995329
},
{
**"start"**:480,
**"end"**:660,
**"start_ms"**:16016,
**"end_ms"**:22022,
**"confidence"**:0.6699914024543004
},
{
**"start"**:780,
**"end"**:990,
**"start_ms"**:26026,
**"end_ms"**:33033,
**"confidence"**:0.7077699155373681
}
]
},
{
**"key"**:"Unknown Face 5abc120a9b25d163",
**"instances"**:[
{
**"start"**:60,
**"end"**:60,
**"start_ms"**:2002,
**"end_ms"**:2002
}
]
}
}
因此，人脸识别或名人检测模型在一些带有他出现时间标记的视频片段中找到了阿尔·罗克。
但它也发现了一张未知的脸。如果这被正确地实现到一个 UI 中，那么下一步应该是让看到它的人给那个未知的人加标签。反过来，这应该训练面部识别模型。
对于当前的 MLaaS 产品来说，最后一步本身就是一个挑战，但它实际上会变得更糟。
假设这些数据代表了数百或数千小时的视频(显然在现实生活中会有更多的数据)，假设我已经浏览并教会了它所有未知的面孔是谁。我仍然需要用新训练的面部识别系统重新播放所有视频，以获得训练所有新人的好处。
我们也可以颠倒这个问题。假设我有一张新的嫌疑犯或罪犯的面部照片。我想看看那个人是否出现在我作为执法机构收集的数百万小时的安全镜头或人体摄像机镜头中，，并且已经通过面部识别系统进行了搜索。使用今天的 MLaaS 工具，我必须首先用新面孔训练人脸识别模型，然后通过新训练的模型重新运行所有这些数百万小时的镜头。
这些都是表演的绊脚石，因为每当你有一些新的训练想要利用时，重新运行面部识别是不经济的。
这就是为什么我的公司 Machine Box 最近在我们的面部识别模型 Facebox 中发布了一个叫做 Faceprint 的功能。
这个功能的好处是，你只需要通过 Facebox 运行一次 。处理完之后，你可以追溯应用任何你想要的名人识别训练。你可以不断更新你的模型，用新的人来教它，给它看新的面部照片，你想纠正多少次就纠正多少次，你想纠正多少次就纠正多少次，你永远都不需要重新处理视频来利用所有这些新的知识。
想象一下这意味着什么。您可以继续将新的名人识别模型应用到您的视频中，而无需重新处理它。
这将使你不必被锁定在一个预先训练的名人识别模型中，该模型在处理时可能是不合标准的，或者可能没有你想要包括的所有已知的人。
有了 Faceprint，不再需要等到完美的人脸识别模型出现。
它是如何工作的？
Faceprint 的工作原理是给你一个由 Facebox 检测到的每个人脸的唯一散列。然后你可以把这个散列和你得到的关于这个人是谁的元数据存储在一起。后来，你可以教 Facebox 新的名人，上传一个预先训练好的人脸的状态文件，或者纠正现有的模型。你只需要给它一个 hash(或 Faceprint ),而不是再次通过 Facebox 运行所有视频，作为回报，你将从更新的模型中获得一个标签。你可以在你的整个面部指纹数据库上以令人难以置信的速度运行整个操作(比处理图像本身快得多)。当你加载了一个新的 Facebox 状态文件时，你可能会手动触发该任务，或者当你的用户整天都在标记未知的面孔以确保你的数据库是最新的时，你可能会更频繁地触发该任务。
Facebox 的这一新功能将通过减少您必须做的不断重新处理来为您节省大量的时间和金钱。如你所知，Facebox 在本地运行，因此你不必将视频上传到网络，就可以利用最先进的人脸识别技术。
什么是机器盒子？
Machine Box 将最先进的机器学习功能放入 Docker 容器中，这样像您这样的开发人员就可以轻松地将自然语言处理、面部检测、对象识别等功能融入其中。到您自己的应用程序中。
盒子是为扩展而建造的，所以当你的应用真正起飞时，只需水平地添加更多的盒子，直到无限远甚至更远。哦，它比任何云服务都要便宜(可能更好)……而且你的数据不会离开你的基础设施。
有戏让我们知道你的想法。
逐步停止:为什么逐步选择不好，你应该用什么来代替
Regression image from Wikipedia
这是从我的统计网站:www。StatisticalAnalysisConsulting.com
介绍
在这篇文章中，我讨论了多元线性回归的变量选择方法与一个单一的因变量 y 和一组自变量
根据
特别是，我讨论了各种逐步的方法(定义如下)。我将展示如何在 SAS 中实现它们(PROC GLMSELECT ),并提供如何在 R 和 Python 中实现它们的指导。
逐步方法对于其他类型的回归也是有问题的，但是我们不讨论这些。Frank Harrell (2001)在回归建模
策略中出色地总结了逐步方法的基本问题，可以解释如下:
1。R^2 值偏高
2。F9 统计量不具有所声称的分布。
3。参数估计的标准误差太小。
4。因此，参数估计的置信区间太窄。
5。由于多重比较，p 值太低，并且难以校正。
6。参数估计值偏离 0。
7。共线性问题加剧。
这意味着你的参数估计值可能离零太远；您对这些参数估计的方差估计也不正确；所以置信区间和假设检验会是错的；没有合理的方法来纠正这些问题。
最具毁灭性的是，它允许分析师不去思考。换句话说，对于数据分析师来说，使用逐步方法相当于告诉他或她的老板应该减薪。一个额外的问题是，这些方法可能无法确定适合的变量集，即使这些变量集存在(Miller，2002)。
我详细说明了为什么这些方法很差，并提出了一些更好的替代方法。在本节的剩余部分，我将讨论逐步方法的 SAS 实现。接下来，我表明这些方法违反统计理论；然后，我表明，理论违反有重要的实际后果，在常见的情况下遇到的。在倒数第二节中，我简要讨论了一些更好的选择，包括实现 SAS PROC GLMSELECT(带有指向 R 和 Python 代码的指针)。最后，我总结了我们的结果，提出了建议，并建议进一步阅读。
术语
变量选择方法是一种选择回归模型中使用的一组特定自变量(iv)的方法。这种选择可能是试图找到“最佳”模型，也可能是试图在有太多潜在虚拟设备时限制虚拟设备的数量。有许多常用的方法，我称之为逐步技术。这些包括
。正向选择从未选择变量开始(空模型)。第一步，添加最重要的变量。在随后的每一步中，它都会添加那些不在模型中的最重要的变量，直到没有满足用户设置的标准的变量。
逆向选择从选择的所有变量开始，每一步都删除最不重要的变量，直到没有一个满足标准。
逐步选择在向前和向后之间交替，引入和移除符合进入或移除标准的变量，直到获得一组稳定的变量。
双变量筛选从查看与 DV 的所有双变量关系开始，并包括任何在主模型中有意义的双变量。
SAS 实施
SAS 在 PROC REG 中使用 MODEL 语句上的 selection 选项实现向前、向后和逐步选择。默认标准是 p = 0.5 用于向前选择，p = 0.1 用于向后选择，这两者都用于逐步选择。该标准可以通过 SLENTRY 和 SLSTAY 选项进行调整。
为什么这些方法不起作用:理论
关键的问题是，我们正在将用于一个测试的方法应用到许多测试中。由 PROC GLM 或 PROC REG(或其他程序中的等效程序)生成的 f 检验和所有其他统计数据都基于被检验的单个假设。在逐步回归中，这一假设以难以确定的方式被严重违反。举例来说，如果你掷一枚硬币十次，得到十个正面，那么你很确定有奇怪的事情发生了。你可以精确地量化这种事件发生的可能性有多大，因为在任何一次投掷中正面朝上的概率是 0.5。如果你让 10 个人每人扔 10 次硬币，其中一个得到 10 个头，你就不那么可疑了，但是你仍然可以量化可能性。但是如果你有一群朋友(你没有数他们)投掷硬币几次(他们没有告诉你有多少次)，有人连续得到 10 个头像，你甚至不知道
有多可疑。那是逐步的。
由于违反了假设，以下情况可以证明是正确的 Harrell (2001):
标准误差偏向 0
p 值也偏向 0
参数估计值偏离 0
模型太复杂
这些方法真的行不通:例子
对一项技术的一个测试是，当所有的假设都精确满足时，它是否有效。我们为满足线性回归
1 的所有假设的 a 生成多元数据。e 正态分布，均值为 0，方差为常数。
2。静脉血栓形成与静脉血栓形成的线性关系。
对于我们的第一个例子，我们对 100 名受试者和 50 个独立变量进行了回归分析——都是白噪声。我们逐步使用 SAS 中的默认值，即入门级和停留级 0.15；在前进档，进入水平为 0.50，在后退档，停留水平为 0.10。最终的逐步模型包括 15 个 iv，其中 5 个在 p<0.05 显著。正向选择产生了一个最终模型，在 p < .05 有 29 个 iv，5 个 sig。反向选择产生了 10 个 iv，8 个 sig，p < .05。
当然，这违反了关于每次静脉注射应该有多少受试者的经验法则。因此，对于我们的第二个例子，我们对 1000 名受试者进行了类似的测试。结果并不令人鼓舞:逐步导致 10 个 iv，其中 5 个在 0.05 显著；向前到 28 个 iv，其中 5 个在 0.05 显著，向后到 10 个 iv，其中 8 个在 0.05 显著。这或多或少是我们对这些 p 值的预期，但它并不能让人对这些方法检测信号和噪声的能力充满信心。
通常，当一个人做回归时，至少有一个自变量与因变量确实相关，但还有其他不相关的。对于我们的第三个例子，我们在上面的模型中添加了一个真实的关系。然而，由于测量包含噪声，我们也将噪声添加到模型中，因此“真实”IV 与 DV 的相关性为 0.32。在
这种情况下，有 100 名受试者、50 个“假”静脉注射和一个“真”静脉注射，逐步选择没有选择真的静脉注射，但选择了 14 个假的静脉注射。“向前”和“向后”都包含了真实变量，但“向前”还包含了 23 个其他变量。落后做得更好，包括只有一个错误的 IV。当受试者的数量增加到 1000 时，所有的方法都包括真实变量，但是所有的
也包括大量的虚假变量。
这就是假设没有被违反时会发生的事情。但有时也会有问题。对于我们的第四个例子，我们添加了一个异常值，在有 100 名受试者、50 名假静脉注射和 1 名真静脉注射的例子中，真静脉注射包括在内，但该变量的参数估计值应为 1，为 0.72。有两个异常值(例 5)，参数估计值
减少到 0.44。
逐步方法的替代方法
在这一节中，我将回顾逐步选择的一些替代方法。首先，我讨论的方法不是自动的，而是依靠判断的。然后讨论一些自动化方法。然而，我的观点是，没有一种方法能够以真正自动的方式被合理地应用。我们下面讨论的方法比逐步方法表现得更好，但是它们的使用不能代替实质性的和统计的知识。评估解决问题的不同统计方法(如变量选择)的困难在于，一般来说，评估不应依赖于与特定问题相关的特定问题。然而，在实际解决数据分析问题时，这些特殊性是必不可少的。
一个完整的模型
在研究中似乎经常被忽视的一个选择是在模型中留下不重要的变量。这在某些情况下是有问题的，例如，如果有太多潜在的 iv，或者如果 iv 是共线的。然而，多重回归中并不存在只需要包含重要变量的内在要求。事实上，尽管这些 IVs 并不重要，但有几个原因可能会引起人们的兴趣。
- 包含它们可能会影响其他 iv 的参数。
- 如果理论表明它们将是重要的(理论至少应该表明这一点——或者你为什么把它们列入潜在的 iv 列表？)那么一个小而不显著的结果就有意思了。
- 虽然对 p 值的全面讨论超出了本文的范围，但一般来说，人们最感兴趣的应该是参数估计值的大小，而不是它们的统计意义。
这种方法的问题在于，向回归方程中添加变量会增加预测值的方差(例如，参见 Miller (2002)) —这是为减少预测值的偏差所付出的代价。这种偏差-方差权衡是选择好方法和好模型的核心。
专家知识
另一个经常被忽视的极好的选择是使用实质性的知识来指导变量选择。许多研究者似乎认为统计分析应该指导研究；这种情况很少发生:专家知识应该指导研究。事实上，这种方法不应该被认为是一种替代，而是良好建模的先决条件。
虽然实质性理论的数量因领域而异，但即使是理论最少的领域也必须有一些，否则就没有办法选择变量，无论多么试探性。
模型平均
篇幅不允许全面讨论模型平均，但中心思想是首先开发一组可信的模型，独立于样本数据指定，然后获得每个模型的可信指数。例如，该索引可以基于由下式给出的 Akaike 信息标准权重
其中δI 是有序 AIC 的差，K 是模型的数量。然后，使用以下方法组合这些模型:
其中θ_ I 是来自各个模型的参数估计。详情见伯纳姆&安德森(2002)。
偏最小二乘法
当一个人有太多的变量时，标准的数据简化技术是主成分分析(PCA)，并且一些人推荐 PCA 回归。这包括通过使用 X'X 的最大特征值来减少 iv 的数量。这种方法有两个问题。
主成分可能没有合理的解释
，主成分可能无法很好地预测因变量，即使自变量的其他线性组合可以很好地预测因变量(Miller (2002))。
偏最小二乘法找到与 DV 相关的 iv 的线性组合。看待这个问题的一种方式是注意主成分回归是基于 X'X 的光谱分解，偏最小二乘法是基于 X'Y '的分解。
套索
套索是一类收缩方法中的一种(也许最著名的收缩方法是岭回归)。Trevor Hastie & Friedman (2001)给出的套索参数估计值为:
使遭受
其中
- N 是样本大小
- y_i 是因变量
的值- b_0 是常数，通常通过标准化预测值而参数化为 0
-x _(I j)是预测变量
的值- s 是收缩因子
利比亚
Efron，Hastie，Johnstone & Tibshirani (2004)开发了最小角度回归。它从集中所有变量和缩放协变量开始。最初，所有参数都设置为 0，然后基于与当前残差的相关性添加参数。
交互效度分析
交叉验证是一种重采样方法，类似于 bootstrap 或 jackknife，它采用了另一种模型评估方法。当人们谈论使用保留样本时，这并不是真正的交叉验证。交叉验证通常取数据的 K 个重复样本，每个样本使用(K-1)/K 个数据来构建模型，剩余的 1/K 个数据以某种方式测试模型。这被称为 K 倍交叉验证。对于大小为 N 的样本，留一交叉验证或 LOOCV 有点像折叠结构，在 N 次系统复制中，取 N-1 个数据点来构建模型，并针对剩余的单个数据点测试结果，第 k 个点在第 k 次复制中被丢弃。所以这就是
K 重交叉验证发挥到极致，K=N，另外，随机 K 重交叉验证并没有把数据分割成 K 个子集的分区，而是取 K 个大小为 N*(K-1)/K 的独立样本。
履行
斯堪的纳维亚航空公司
PROC GLMSELECT 是在第 9 版早期引入的，现在是 SAS 的标准配置。GLMSELECT 有很多特性，我不会全部讨论；相反，我集中讨论与刚才讨论的方法相对应的三种方法。
glm select 语句如下:
PROC GLMSELECT <options>;
CLASS variable;
MODEL variable = <effects></options>;
SCORE <DATA = dataset> <OUT = dataset>;
Key options on the GLMSELECT statement include:
• DATA =
• TESTDATA =
• VALDATA =
• PLOTS =
MODEL 语句允许您选择选项，包括:
前进
后退
步进
套索
LAR
还允许您选择 choose 选项:
CHOOSE = criterion 选项根据标准从模型列表中选择
可用的标准有:adjrsq、aic、aicc、bic、cp、cv、press、sbc、VALIDATE
CV 是基于 k 倍 CV 的残差平方和
VALIDATE 是 avg。sq。验证数据错误
停止标准选项停止选择过程。可用的标准有:adjrsq、aic aicc、bic、cp cv、press、sbc、sl、validate。
LASSO 和 LAR 的结果
当应用于上述问题时，用默认选项 LASSO 和 LAR 表现得相当不错。下面是 LASSO 的结果，LAR 的结果几乎相同。
N = 100，50 个 iv，所有噪声。。。未选择
N = 1000，50 个 iv，所有噪声。。。未选择
N = 100，50 个噪声变量，1 个实数。。。未选择
N = 1000，50 个噪声变量，1 个实数。。。仅选择真实值
N = 100，50 个噪声变量，1 个真实值，1 个异常值。。。….param est now . 99
N = 100，50 个噪声变量，1 个真实值，2 个异常值。。。….不包含变量
限制
尽管 Lasso 和 LAR 方法是其他方法的优秀替代方法，但它们不是万灵药。方法仍然做出假设，并且这些假设需要被检查。除了标准的统计假设之外，他们还假设所考虑的模型具有实质性的意义。正如 Weisberg 在他对 Bradley Efron&TiB shirani(2004)的讨论中所指出的，无论是 LAR 还是自动方法的任何其他方法都“没有任何希望解决[模型构建的问题]，因为自动方法本质上不考虑手边问题的上下文”。或者，正如我在各种场合经常说的:
脱离上下文解决统计问题就像蒙着眼睛打拳击一样。
你可能会打中对手的鼻子，或者你可能会在环柱上折断你的手。
其他实施
我是自愿成为 SAS 用户的。然而，R 在几个包中提供 LASSO，包括 glmnet:
fit <- lars(x, y, type="lasso")# summarize the fitsummary(fit)
Python 通过 sklearn 提供套索:
>>> from sklearn import linear_model
>>> clf = linear_model.Lasso(alpha=0.1)
>>> clf.fit([[0,0], [1, 1], [2, 2]], [0, 1, 2])
Lasso(alpha=0.1, copy_X=True, fit_intercept=True, max_iter=1000,
normalize=False, positive=False, precompute=False, random_state=None,
selection='cyclic', tol=0.0001, warm_start=False)
>>> print(clf.coef_)
[ 0.85 0\. ]
>>> print(clf.intercept_)
0.15
总结、建议和进一步阅读
尽管没有任何方法可以替代实质性的和统计学的专业知识，LASSO 和 LAR 提供了比逐步分析法更好的替代方法作为进一步分析的起点。这两种方法都有广泛的选择，允许进行大量的探索，并消除没有实质意义的模型。
对于逐步回归所带来的问题的更多信息，Harrell (2001)提供了一个相对非技术性的介绍，以及关于回归建模的一般性建议。Burnham & Anderson (2002)提供了一个更详细的方法，第一章概述了这个问题，其余章节提供了两个解决这个问题的一般框架(一个基于
信息标准，另一个基于多模型平均)。关于 LASSO 和 LAR 的更多信息，请参见 Hastie & Friedman (2001)。
参考
Bradley Efron，Trevor Hastie，I. J .和 Tibshirani，R. (2004)，“最小角度回归”，统计年鉴 32，407–499。安德森博士(2002)，模型选择和多模型推理，施普林格，纽约。
Harrell，F. E. (2001)，回归建模策略:应用于线性模型、逻辑回归和生存
分析，斯普林格出版社，纽约州。
米勒，A. J. (2002)，回归中的子集选择，查普曼&大厅，伦敦。《统计学习的要素》，纽约斯普林格出版社，2001 年。
在云上存储训练数据
当你建立深度学习模型时，你可能会受益于更多的数据来训练。您可能会耗尽本地计算机上的空间，因此需要想办法在云上存储数据集，然后在训练模型时访问它们。
我最近在一个图像分类项目中遇到了一个障碍，我的笔记本电脑没有足够的存储空间来增加我的训练数据集的大小。做多输出的时候，(2 类以上)，图像识别问题，每类存储 10–100，000 张图像，(尤其是中等+分辨率)，会产生很多 GBs！
在本文中，我将介绍一些帮助我使用云存储的技巧，以便在模型训练期间制定批次。
动机
1gb 存储多少钱？
Example Image
上面的图像是 54 KB 压缩的，(png)，大小为 266x168x3，(分辨率 x RGB 颜色通道)。
因此，您可以用 1 GB 存储 18，518 个这样的图像。
云存储的美妙之处在于，我们可以免费在线存储许多 GB，甚至以相当低的成本存储 TBs，1,000 GBs 而在我们的本地机器上存储几 GB 可能会很成问题/完全不可能。
在训练我的模型时，我如何访问托管在云上的数据？
我想通过这篇文章传达的主要思想是，我的数据集的命名约定如何帮助我从 URL 中检索批量图像。这很重要，因为在训练模型时，我们希望在每次迭代中随机选择一批图像输入到模型中。数据集太大，无法将整个数据集加载到内存中并从中选择随机实例。因此，我使用了一种命名约定，它允许我用索引对批处理进行分区，然后相应地从 bucket URL 获取图像。
您将获得一个指向您的存储桶的 URL，您可以使用随机数生成器将所需的索引附加到 URL 请求中。这将有助于您解析 bucket，以便为训练模型制定这些批处理。
例如，如果您将数据集中的每一项命名为:SHOE_1，SHOE_2，… SHOE_9998，SHOE_9999。您将能够用类似于以下内容的公式表示 URL 获取字符串:
#PSEUDOCODE
i = randomnumber()
fetch_item = url + ‘SHOE_’ + i
new_item = httprequest(fetch_item)batch.append(new_item)
通过对数据集使用一致的命名约定，您可以轻松地解析和提取随机批次进行训练，而无需将数据集加载到内存中。
请查看这篇堆栈溢出文章，了解如何使用 python 访问 s3 文件，如图像:
你的技能值多少钱？使用我们的工资计算器，了解像您这样的开发人员的收入，现在…
stackoverflow.com](https://stackoverflow.com/questions/44043036/how-to-read-image-file-from-s3-bucket-directly-into-memory)
结论
总之，我希望这篇文章能启发你思考，一旦数据集变得太大而无法在本地机器上托管，你打算如何存储数据集。我认为尽快这样做很好，尤其是如果你正在使用 google colab 环境来训练你的模型。这样你就可以很容易地从 google colab 中访问你的数据。请分享您用于在云上托管定制机器学习训练数据集的任何想法或策略。感谢阅读！
CShorten
Connor Shorten 是佛罗里达大西洋大学计算机科学专业的学生。对软件经济学、深度学习和软件工程感兴趣。
在关系数据库中存储推文
Twitter 是一个巨大的平台，每月活跃用户超过 3 亿。由于推文包含的字符数量有限，它们非常适合进行情绪分析，并评估人们对公司或感兴趣的话题的看法。在这篇文章中，我将概述使用 ORM 建立关系 SQL 数据库的步骤，并展示从 Twitter API 提取和存储 tweets 的两种方法。这类任务的用例实际上是无穷无尽的，所以让我们认为我们对披萨有一种不健康的(不止一种方式)痴迷。
“pepperoni pizza” by Vita Marija Murenaite on Unsplash
首先，我们需要访问 Twitter API。在这个链接你可以注册一个应用程序并开始收集推文。API 有许多不同的端点，我们将使用其中的两个免费选项。标准搜索 API 将允许我们收集过去 7 天的推文，不幸的是，这是历史推文的限制，无需支付额外费用，但允许我们做一些探索性的数据分析。实时流 API 允许我们筛选实时推文，并收集任何提到感兴趣的查询词的推文。我们将编写一个“倾听”脚本，收集所有与披萨相关的推文，以满足我们不虔诚的低级欲望。在我们建立数据库之前，让我们看一下可以从 Twitter 上获得的数据。
从标准搜索中收集推文
您可以使用自己选择的方法向 Twitter API 发出请求，但是 Tweepy 无疑是最容易使用的方法之一，并且它是有据可查的。只要看看入门是多么简单！
正如你所看到的，一条 tweet 包含了丰富的信息，这些键中的大部分对应于嵌套的字典和列表。如果你以前没有使用过 Twitter API，我建议你熟悉一下搜索功能，看看你可以应用的不同过滤器。显而易见，一条推文产生的数据是正文的五倍。在这里，一个请求最多产生 100 条 tweet，但是您可以想象我们可以使用一个循环(小心不要超过速率限制)来收集上一周的所有 tweet，从而链接请求。
构建数据库
我们对披萨痴迷的本质是这样的，它超越了关于我们最喜欢的油腻放纵的推特，延伸到了关于它的推特用户。每当我们的模型中有多类以某种方式相关的对象时，这就表明我们可能想要创建一个关系数据库。关系数据库保留模型中实体之间的链接，通常使用外键作为表之间的连接(在 SQL 数据库的情况下)。尽管两个类不需要关系数据库，但是可以想象我们可能想要跟踪不同的比萨饼店或感兴趣的浇头。为了方便数据库的设计和播种，我们将使用一个名为 SQLAlchemy 的对象关系映射器(ORM)。
我们的问题如下:SQL 数据库有包含整数和文本的表，非常适合存储我们的 tweets 和相关的用户数据。但是我们希望用 Python 来做分析，这是一种面向对象的语言，所以我们希望能够与 tweets 和用户作为对象进行交互。SQLAlchemy 提供了一种完全用 Python 代码设计 SQL 数据库架构的简单方法，以简单的方式映射出我们想要的关系。此外，它还允许我们从 Python 中执行 SQL 查询，基本上是为我们翻译代码，这对于我们以后执行分析时从数据库中提取数据非常有用。让我们看一下我们的简单案例:
这段 python 代码建立了我们的 SQL 数据库的模型。Tweet 和 User 类对应于带有列出的列的 SQL 表。用户和 tweet 之间的关系是一对多的，我们的 tweet 应该有一个用户 id，这样它们就可以归属于它们的父类。现在，当我们想要填充这些表时，我们可以简单地创建 tweet 和 user 类的实例，并传递通过 Twitter API 调用获得的属性。
直播推文
现在我们已经建立了数据库，我们可以开始填充它了。请注意，当您第一次建立关系数据库时，确保正确建立所有关系是至关重要的。在这里，我们只需要添加一条 tweet，并确保它有一个用户，反之亦然，但当处理更复杂的系统时，这可能意味着检查许多关系。如果模型的行为不完全如我们所愿，我们可以简单地删除我们的数据库，调整模型文件并重新创建它。
除了几个例外，流式 api 的工作方式与搜索 API 非常相似。我将再次指向文档，但是我们将浏览它。
I can smell the tomato sauce already…
这是 Streamlistener 对象的一般结构。当监听器遇到状态、错误等时，执行不同的功能。还有许多其他类型的函数可以编写，但对于我们的情况，这些就足够了。on_status 的内容允许我们在调用 check_user 函数用传递的属性实例化我们的 tweets 和用户之前提取我们感兴趣的信息。
如你所见，我们正在同时创建我们独特的用户和推文，以确保它们通过用户 id 链接。为了确保我们没有重复的用户，我们首先需要检查用户表，以确保他们不在那里。然后，我们将对象添加到一个会话中，并将它们提交给数据库。这两个简单的代码块组成了一个简单的
当您将所有这些放在一起时，您就有了一个强大的工具来从 Twitter API 中提取推文并将其存储在数据库中，从而保持推文和用户之间的关系。使用 SQLAlchemy，您将能够编写一个查询来返回给定用户的所有 tweets。我希望这是有启发性的，我将在下面留下一些额外的资源。很快，我们将会知道任何人在推特上谈论披萨的一切！
如果你做过任何数据科学或数据分析工作，你可能读过 csv 文件或连接到数据库…
www.dataquest.io](https://www.dataquest.io/blog/streaming-data-python/) [## 发动机配置- SQLAlchemy 1.2 文档
上面的引擎创建了一个为 PostgreSQL 定制的对象，以及一个将建立 DBAPI…
docs.sqlalchemy.org](http://docs.sqlalchemy.org/en/latest/core/engines.html)
其他数据科学爱好者的故事！！
Photo by Rock'n Roll Monkey on Unsplash
“你知道 Rohan，数据科学将会是下一个大事件。作为开始，我将开始学习在线课程。”迈克在完成每周作业时说道。Mike 是我的朋友，我们在读研究生四年级。
迈克是那些让自己在许多技术上保持最新的“技术人员”之一。如果你想了解编程的最新趋势，或者最新的 android 更新，甚至是开创性的 CS 论文，他就是你要找的人！我们的“技术大师”。
我非常肯定他的话，坚信他在不同技术趋势方面的广博知识。但是我从哪里开始呢？
什么是真正的数据科学？好学吗？我应该知道哪些先决条件？问题开始从各个角落向我袭来。但幸运的是，我有谷歌的探索能力。
“那么，迈克，这到底是什么数据科学？到底是谁从中受益？请多告诉我一些。
那是他需要的暗示。他坐直了，调整了一下座位，开始解释数据科学的概念。他的口音浓重，而且声音充满激情。我洗耳恭听。他的潜在声明是“像美国和印度这样的国家将会最大限度地利用它”。
数据总量增长如此之快，以至于我们现在对数据的看法将在未来十年发生根本性的变化。如果你是一名软件工程师或从事任何技术工作，这听起来应该是一个机会。从硬件到网络到数据库技术到表示层，一切都在快速变化，让我们能够更有效地访问数据，让我们更好地生活和工作。
想想你回家的路程，如果你每天都知道最佳路线以避开交通堵塞，你能做些什么。现在想一想，在你需要的时候，你需要什么来为你的通勤获取准确的信息。现在，想想在您的通勤过程中实时变化的数据，以及需要什么技术来实现这一点。如果每次旅行能节省 15 分钟，那值多少钱？对我来说，每月可能值 10 英镑或 10 英镑或 50 英镑。乘以几十亿人(这可能是谷歌花十亿美元收购 Waze 的原因！).每天都有数十亿个不同的决定被做出。
乔纳森·布里尔
世界上有如此多的新手，他们渴望尝试 21 世纪最性感的工作，但却不知道流行的趋势。在正确的时间了解正确的信息将有助于你更好地准备并做出明智的决定(或者你需要有自己的“麦克风”)。这些不同的见解将帮助其他新手进行分析，并做出加入数据科学浪潮的正确决定。
对于那些对数据科学感兴趣的人来说，无论你目前正在从事这项工作，还是希望在未来从事这项工作，这都是为你准备的。在这里，我想把我的分析更多地集中在两个特定的国家，美国和印度。令人惊讶的是，(或者也许不是？)，这两个国家在数据科学领域的可用机会数量上领先。事实上， Glassdoor 已经将“数据科学家”列为美国最好的工作，基于职位空缺数量、薪水和整体工作满意度。
事实上，据skilling****platform Edvancer和 Analytics Magazine India 最近的一项研究显示，印度有近 90，000 个职位空缺，是仅次于美国的第二大基于分析的工作中心。这一数字比上一年猛增了 76%。
他们从哪里来？
从政治角度来看，印美关系可能并不明朗，但在DataScience中，这一点非常明显。这就是为什么我想接受这个特殊方向的挑战。
你听说过 Kaggle 吗？
那天晚上，下课后，迈克喝着咖啡开始了谈话。困惑之余，我向我的“技术大师”寻求进一步的解释。
它是希望在数据科学领域相互学习、分享和竞争的人们的第一个家 。它有一个令人惊叹的社区，这个社区在不断发展，并且随时准备帮助它的成员。
太酷了。因此，Kaggle 可以成为我“数据科学”之旅的第一步。我以为。我的兴趣被充分激起，我问迈克:“他们有什么限制吗？我需要学位才能加入吗？”
趁年轻抓住他们！
过去 3-4 年来，机器学习领域在印度一直有需求，因此人们仍在磨练自己的技能以进入这一领域。同样的趋势本应在 2010 年 Kaggle 成立时在美国出现。美国和印度之间有几年的差距
~Manish Saraswat，HackerEarth 机器学习部门主管
迈克的总结
- 印度的年龄分布从 18 开始，一直到 79 ，而美国有一些人在 80+名单上。
- 有趣的是，印度的年轻一代(18-24 岁)占印度总人口的一半以上。确实令人着迷！
- 美国也有自己的主导人群，大多在 25 岁以上。
我对这场狂欢既震惊又惊讶。我的兴趣被彻底激起，我开始思考。
需要思考的问题
- 印度青少年是如何这么快被这个数据科学领域吸引的？他们是学生吗？这种趋势是“最性感的工作”浪潮的结果，还是他们真的对此充满热情？
- 30 岁以上的印度人相当少。有什么问题吗？
- 数据科学社区中 70 岁以上的高级开发人员呢？他们是如何帮助社区的？
性别
迈克的总结
- 印度和美国都有大量男性科学家，他们比女性科学家更活跃。
- 美国在这方面表现稍好，其女性科学家占劳动力的 22%。
要思考的问题
- 是什么阻止了更多的女性投身于这一领域？社区可以做些什么来增加这些数字？Kaggle 的社区能做些什么来让更多的女性为这个神奇的领域做出贡献呢？
你学了多少？
迈克的总结
- 世界上大约一半的人拥有硕士学位，只有 15%的人拥有博士学位。
- 大约 50%的印度人拥有学士学位，这与这个领域的年轻一代密切相关。
- 在 美国 ，大约一半的社区持有硕士学位。令人惊讶的是，博士学位明显偏高，为 18%。
你的职称能说明问题吗？
我认识很多以“插入头衔”身份工作的人，但他们在日常工作中做的事情与众不同。在数据科学领域存在足够的混乱，人们对同一项工作有不同的定义。
迈克叹息道。
了解这个世界对他们的同龄人所扮演的角色的看法是很有趣的。
我笑了。
迈克总结
- 学生是本次调查中使用最多的头衔。
- 此外还有其他常见的关键词，如数据分析师、数据科学家和软件工程师。
- 印度有 30% 学生比例。(这是意料之中的，不是吗？).紧随其后的是软件工程师和令人垂涎的数据科学家。
- 在美国，他们爱上了新感觉数据科学家。酷！
你是数据科学家吗？
“你认为自己是数据科学家吗？”—这个问题在这里非常有效，因为这个术语本身就很模糊。对于那些自认为是数据科学家的人来说，他们真的是数据科学家吗？另一方面，那些不认为自己是数据科学家，但结果却是真正的数据科学家的可能性有多大？再次回到根本问题——“谁是真正的数据科学家？”
想想你一生中遇到的医生。有研究医生、内科医生、泌尿科医生——这些只是我的大学室友。所有这些医生每天都做不同的事情，如果他们试图做其他人的工作，事情可能不会那么顺利。对我来说，数据科学家也是如此。在数据科学的保护伞下，有如此多的信息和如此多的技能，对于一个人来说，每天做所有的事情是极其困难的。此外，由于从事数据科学工作的人总是会遇到很多事情，人们往往会被他们感兴趣的主题和问题所吸引。这导致我见过的大多数数据科学家做医生做的事情:专门化。在医学和数据科学领域，有少数几个摇滚明星忍者独角兽可以做到这一切。但是，医院只雇佣全能医生和组织只雇佣全能数据科学家是同样站不住脚的。
~亚历克斯·戈卢布·萨斯
迈克的总结
- 调查中比例最高的人是不想回答这个问题/不确定答案的人。这就是我说的。
- 看起来印度人对这个职位更加困惑，因为几乎 25%的人跳过了这个答案。
- 然而，美国人对数据科学家的标签更有信心。
你有多少经验？
迈克的总结
- 看看印度人有 0 到 1 经验的 34% 。还记得我们之前看到的巨大的学生比例吗？
- 另一方面，美国数据科学从业者似乎有更高的工作经验，超过 15 年以上的工作经验。
值得思考的问题
- 有趣的是，有很多人没有任何工作经验。这让我想到了那些懂数据科学却没有工作的人的可能性。还是只有最后一年毕业的学生？
金钱使世界运转
你知道为什么数据科学被称为最性感的工作吗？涉案金额也是背后原因之一。完美的 数据科学家 就像独角兽。他们不存在。退而求其次，你至少应该擅长这些高度专业化的技能。
迈克解释道。
但是，我确实听说印度和美国数据科学家的工资有差别！如果有，为什么？
我无法掩饰我的焦虑。
你没听错吧，洛汗。基于 450 份回复，印度的中位年薪为(75 万卢比) ，是美国【84 万卢比】 可比年收入的零头。计算中考虑了 52 个国家的数据，所有受访者的中位数为 55，441 美元。
如果你看一下 Glassdoor， 印度数据科学家的平均工资，有报道称工资为 30-40 万卢比。这些 【数据科学】 工作是由印度的 IT 服务商店提供的，这些服务商店培训不一定有数学或统计背景的应届毕业生，并教他们一些工具包，他们既不了解底层业务，也不了解他们应用的底层统计模型，导致糟糕的结果。这不是一个苹果与苹果的比较，比较印度人才与他们的西方同行。在美国，这是非常明确的。 数据科学家是指那些从名校毕业，拥有很强的数学、科学或计算机科学背景，并且从第一天起就能实际完成工作的人 。而这里在印度， 任何人做任何与数据有关的事情都是伪装成数据科学家 。最终将会发生的是，将会有一个大规模的修正，其中大部分将不会在真正的数据科学中得到应用，而是在报告生成、数据质量控制和所有那些奇妙的东西中。
我显然对传播给我的知识感到惊讶。非常清楚。
对于许多 IT 数据科学家来说，更多的经验通常意味着更高的薪酬。
入门级数据科学家:每小时 85–85–105 或每年 11 万–11 万–15 万大多数数据科学家都属于这一领域。它们适合于定义明确的项目，并且之前已经在其他业务中尝试过。他们在团队中非常出色，在团队中，一名学者与一名工程师配对，在一名更资深的人的监督下制作工作原型。
数据科学家:每小时 115-115-150 或每年 16.5-16.5-20 万
数据科学家是能够将定义良好的业务需求转化为自己的工作原型的人。他们拥有工程和科学/统计的综合背景，可以独立工作，也可以团队合作。
高级数据科学家:每小时 175–175–275 或每年 22.5 万–22.5 万–30 万
高级数据科学家关注业务需求并定义解决方案，即使需求是模糊的或没有被很好地理解。他们可以构建和执行数据科学实验。他们拥有领导经验，可以指导更多初级数据科学家。即使在很少或没有项目先例的情况下，他们也可以构建一个工作原型。
工业
迈克的总结
- 这些 ML 从业者所从事的行业也非常令人惊讶。
- 在印度和美国，学生都占绝大多数，考虑到最近 DS 的繁荣，这并不奇怪。
对当前角色的体验
迈克的总结
- 在印度，由于学生人数较多，工业经验几乎为零。
- 印度也有很多软件工程师。
- 然而，美国有一群经验丰富的数据科学家。
第 2 部分:EL Clasico 和 ML
那是一个阳光明媚的日子，我们坐在那些美丽的海滩之一，享受着夜晚。那是在我们讨论最后一天的古典音乐比赛的时候。作为一个狂热的 CR7 粉丝，我对他昨天的表现感到兴奋。那些运球，单飞，精准的完成，最后是标志性的庆祝。呜！它让我不寒而栗。这并不是说我讨厌梅西什么的，只是我更喜欢 T21。
我澄清了我的观点。
你知道同样的戏谑也适用于数据科学社区吗？
迈克笑了。
data science 中的什么 CR7 和梅西 ？
是的，关于哪种编程语言是最好的，这是一个永恒的争论。r 或者 Python。
多跟我说说吧！
你的初恋是谁？
你怎么看？
使用的 ML 库
你是做什么的？
在 ML 多少年？
编码多少年？
最常用的 ML 库
来源
https://factordaily.com/data-scientist-kaggle-india/
https://www . businessprocessincubator . com/content/data-scientist-salary-in-India-and-USA/
https://qz . com/India/1297493/India-has-the-number-of-data-analytics-jobs-after-us/
ML 第 0 天简介:骑自行车的故事
我相信我们从我们的经历中学到了最好的东西，当我们分享关于我们经历的故事时，我们可以分享同样的学习。
我喜欢教人东西；我真正喜欢谈论和教授的一个话题是机器学习(ML)。多年来，我教过各种水平的学生 ML。不要相信宣传——学习者不需要任何特定领域的特定背景或领域知识来理解甚至应用 ML 概念解决问题。当然——任何领域的经验都有帮助，但许多潜在的学习者认为，为了开始学习，需要大量的统计数据或数学技能，但事实并非如此。事实上，在这篇文章的剩余部分，我将表明，任何人只需要对我们自己的学习有一个大致的了解，就可以掌握和完全理解整个 ML 过程。
在那些更有经验的人对我大喊大叫之前，请记住，这是为第一天的学习者准备的，目的是提供一个全面的、更容易理解的、不会吓到他们的方法。
那么，让我们开始吧——讲一个简短的故事！
我童年最美好的回忆之一是父亲教我骑新自行车。我想这是我第一次“真正的”艰难经历，因为我父亲没有教我如何骑自行车，而是让我每次尝试时都失败一点，最终摔倒。表面上看，我永远也到不了那里，但慢慢地，我肯定地推断出我做错了什么，这是基于我每次尝试骑自行车时所学到的正确做法。在我的整个经历和实验中，我调整了这些变量中的每一个，直到结果看起来像是需要我自己在我们的死胡同街道上轻快地行驶，并与我最快的朋友一起骑行。
当时我一点也不知道，无论结果是成功还是失败，每一次迭代都代表着一次学习经历，我正在学习如何管理平衡、动力、速度甚至勇气。
最崇高的快乐是理解的快乐。
列奥纳多·达· 芬奇
我们如何学习？
在没有获得所有科学知识的情况下，让我们把学习归结为两件事:某种类型的经历和我们从相同经历中学到的相关技能或任务。
学习骑行(体验)
你是怎么学会骑自行车的？你可能会选择两条路中的一条:
你试图在没有任何帮助的情况下学习；你尝试和失败了无数次，但在无数次擦伤膝盖和瘀伤后，你成功地独自骑了一段距离的自行车…然后又摔了下来。
或者
有人帮你学习。也许一个兄弟姐妹(对于我们这些有哥哥姐姐的人来说，这是非常错误的)或父母要么向你展示如何骑自行车，要么你观察他们如何骑自行车并模仿他们的行为。你仍然尝试和失败了无数次，但在无数次擦伤膝盖和瘀伤后，你成功地独自骑了一段距离的自行车…然后又摔了下来。
这两种方法之间的相似之处很容易被简化为这样一种简单的形式: 一次重复的经历，无论是失败还是成功，都教会了我们:什么该做，什么不该做。
永远不要让正规教育妨碍你的学习。
马克·吐温
结果(学到的技能)
每个过程的结束或结果都是一样的——我们学会了做一些事情——现在做什么？
应用
这是我在课堂上经常告诉学生的一点——现在使用这项新技能(小时候骑自行车),并用它去骑摩托车！嗯——困惑的表情比比皆是。这怎么可能呢？
这是一个简单而又显而易见的答案(记住——人们说学习这种 ML 的东西很难)——只是在你已经学到的东西上增加新的经验和成果。机会是——这一次学习会更快，痛苦(擦伤和瘀伤)会更少，因为骑自行车和骑摩托车有相似的技能，如平衡和动量。
那么，所有这些与 ML 有什么关系呢？
有时候，让 ML 变得困难的并不是学习或者理解这个过程(我会马上讲述这一切)，而是我们正在研究我们自己还没有经历过或者学习过的经验和结果。更简单地说——我们无法理解学习经历，因为在某些时候我们自己没有学到——从字面上来说。
现在——整个 ML 过程——与学习骑自行车有关。
A.预处理
任何成功的分析或 ML 流程都始于良好的数据，而这些数据在使用前往往需要清理甚至转换。你能想象在学习骑自行车的过程中，有一半的步骤被遗漏，甚至是用另一种语言呈现给你吗？为了从经验中全面学习，其中的数据必须没有错误，否则我们无法从经验中全面学习或使用它来学习任何类型的技能——这第一步称为预处理，我们在此过程中纠正错误并清理数据。
B.电子设计自动化(Electronic Design Automation)
还记得我提到的有时候学习 ML 很难吗？如果我请你教我一项你只看过别人做，但自己从未学过的技能，你会教我吗？可能，因为人类是优秀的学习者，但是毫无疑问，你会在这个过程中学习新的东西，而我只会学习一些我需要的东西来完成新的技能。
底线是，当我们之前没有任何学习经验时，我们必须首先对新任务或新技能进行充分的自我教育。在 ML 中，这个尽可能多地学习数据的过程被称为探索性数据分析，简称 EDA。我们使用各种各样的视觉化和工具来帮助我们实现这个目标，但是，现在，只要知道我们为什么这样做——去学习我们不知道的东西。
C.特征选择/特征工程
作为成年人，我们都知道经历是复杂的。部分经历也可能是错综复杂的，重叠的，交叉的，不完整的，甚至是不相关的。在 ML 中，组成体验的部分和片段被称为特征，在高层次上，我们通常只是将特征与结果或学到的技能联系起来。正如我们已经讨论过的，经验在学习过程中经常被重复，但是每次的特征都保持相同的类型。
回到自行车的例子:每次你试图学习骑自行车，你可能每次都改变平衡的量，直到你学会了保持直立的正确量。在每一次重复中，你也学会了改变你的纪念碑，直到你知道需要多少才能让你继续前进，直到你开始自己踩踏板。在这个例子中，平衡和动量都是与结果相关的特征:成功骑行或不成功骑行。
那么——为什么我们需要选择特征？
因为我们最终将在某种类型的流程中使用我们构建的内容，所以我们的 ML 流程必须进行优化，因此我们在 EDA 中内部研究数据，以决定是否可以通过从体验中删除任何不需要的功能来减少问题的规模。这不仅可以加速学习，还可以通过消除 ML 过程可能发现对学习有害的特征来使学习更好(如果有人告诉你错误的骑行方式，想想学骑自行车)。
总的来说，这种减少也有助于优化计算资源。当特征太多而不能手动减少它们的数量时，或者当需要其他更多的、特定的算法方法时，特征工程方法被实施来通常完成类似的目标。
现在，我的数据和要素都准备好了，下一步是什么？
D.系统模型化
记得学骑自行车吗？现在，我们将打包整个过程，包括所有的重复、特征和每次重复的相关结果——所有这些都需要充分再现学习特定技能所需的一切。这个包被称为模型，我们必须将它打包，因为我们需要将它应用于稍后发生的新体验，但不包含任何结果——这些最终将是预测。
但是模型不能只靠自己制造——这就是 ML 发挥作用的地方——我们必须使用适当的 ML 工具(称为学习算法)，并根据我们收集的经验和结果训练它(这是监督机器学习，但还有更多类型)。随着模型的构建，ML 算法将尽最大努力学习体验如何与每个结果相关联——每次重复都会发生这种情况(我们现在可以将重复的体验称为数据中的行)。
模型建立发生在单独的训练和测试阶段，直到达到最佳结果；有许多方法来衡量这一点，它在问题上有很大的不同，但这一点超出了本介绍的范围。现在——只需要理解模型是通过迭代评估的就足够了，如果需要的话，包括使用不同的 ML 工具重新训练模型。在一个最佳模型(请记住，这个模型现在包含了经验如何与每个结果相关的规则)经过训练、测试、评估和接受之后，我们可以在具有相同特征的新数据上使用它来进行预测。
其核心是机器学习，仅此而已。ML 工具只是工具，没有魔法帽。
当然，这个过程还有更多的东西——是的，有，我很快会在这个介绍中添加第二章，进行更深入的探讨，但是初学者可以在这里停下来，简单快速地介绍一下所有这些忙乱是怎么回事。
为数据科学家讲述故事
人工智能项目管理
将数据转化为故事来说服你的听众
Source: https://bit.ly/2uX5enz
《哈佛商业评论》最近发表了一篇关于领先数据科学家实际工作的文章。令人惊讶的是，关键技能是沟通，而不是统计模型的经验。
亚里士多德认为，要说服人们，你需要使用精神气质、理性和情感。精神特质建立了说话者的可信度，而标识诉诸于所使用的推理。然而，如果没有悲怆这种打动观众心灵的方式，这两部电影都毫无用处。当介绍他们的工作时，Homo 数据科学家通常会爱上因果的、数据驱动的推理。这通常是正确的辩论方式。但是为了唤起行动，数据科学家需要讲故事。
这篇文章提出了两个框架来组织演讲，并在情感上与听众建立联系。它会帮助你唤起你想要的行动。负责任地使用。
讲故事的语言
畅销书作家兼科学家尤瓦尔·赫拉利认为，语言是为了讲故事而发明的。与公众意见相反，语言的发明不是为了更有效地协调工作或制定军事计划。自石器时代以来，人类就用故事来安慰彼此，争论问题，并形成社会联盟。
人类是讲故事的动物。—格雷厄姆·斯威夫特，沃特兰
Source: https://amzn.to/2P8zum3
直到今天，人类都不是理性的生物。我们在故事中交谈、思考和梦想。当讨论公共政策选项时，我们会感性地而不是理性地进行推理。当听到一个发生在我们邻居朋友身上的故事时，我们会从这个故事中得出结论，而不是后退一步评估数据。
数据科学家每天都需要简单易懂地向利益相关者解释复杂模型的结果。他们还需要推介项目。无论做哪一件事，讲故事都应该是数据科学家的首选工具。
第一部分解释了 SPSN 框架，以创造一个结果驱动的故事情节。第二部分检查成功框架，使你的故事在情感上尽可能吸引人。
为您的演示文稿创建故事情节
管理顾问们早就知道:你首先要努力创造一个解决方案，然后你需要一个连贯的故事情节来传达这个解决方案。自然，解决这个问题从分析可用数据开始。在这方面，咨询师和数据科学家非常相似。让我们在下一步中利用他们的一些技巧。
数据让人思考，情绪让人行动。安东尼奥·达马西奥
一个常用的组织陈述的框架是情况-问题-解决方案-下一步框架，是 SPSN 的缩写。它在 EY 围绕美联社罗伯特·容的数字化战略实践中得到完善。仅用四张幻灯片，你就能交流任何问题并触及其解决方案。
情景:首先，向你的听众描述一下当前的状态。你试图改变的现状是什么？
问题:接下来，图片问题。这种情况有什么问题？你想解决的痛苦在哪里？
解决方案:提出解决方案。你如何解决这个问题？你如何治愈疼痛？
下一步:你说服了观众。你下一步需要做什么？需要采取哪些措施？
让我们将这个框架应用于一个常见的数据科学目标。你是一家电子商务公司的一员，试图说服你的上司开发一个推荐系统。空白幻灯片可能看起来像这样。
正如你所看到的，SPNS 框架清楚地展示了我们需要的四张幻灯片来说服观众我们的想法。但是仍然缺少一些东西。接下来让我们用成功模型来丰富故事情节。
你故事中的盐
既然你已经创造了原始的故事情节，让我们把它变成一个故事。
奇普和丹·希斯在他们经常被引用的书《粘人》中分析了所有粘人故事的共同点。它们都在某种程度上使用了成功模式的元素。这个模型将帮助你的想法在演示结束后仍能被观众所接受。缩写代表以下内容:
简单:保持简单。数据科学家经常会爱上技术细节。真正专注于你试图传达的最重要的信息。
出乎意料:利用惊喜的元素来获得观众的注意。打破预期模式。
具体:用具体例子。帮助你的听众或读者描绘出你试图解决的情况。
可信:获得可信的资源来支持你的主张。使用数据或外部验证，让你的故事可信。
情感:记住，不是你的数字会让人在意，而是你的人物故事会让人在意。我们希望帮助人们，而不仅仅是降低成本或提高效率。诉诸于恐惧、快乐、惊讶、悲伤和爱恨五种情绪。
故事:每个故事都有一个英雄，一个要克服的障碍和一个幸福的结局。试着用你的观点编一个故事来帮助它坚持下去。
让我们将这些元素添加到空白结构中，为我们的故事增添趣味。
如您所见，我们在故事情节中融入了大部分成功元素。虽然这并不是每个好故事所必需的，但肯定会有所帮助。
第三步，你将为你的演示配上视觉效果。视觉效果越多，要点越少越好。插入贵公司的收入图表并使用公司风格指南。无论你如何进行，你的故事情节现在已经很清楚了。
xPhoto by rawpixel on Unsplash
数据科学家必须有效沟通。您已经看到了如何利用讲故事的力量将数字转化为情感和行动。当你准备下一个演示、帖子或演讲时，请记住这个混合框架。会有回报的。
关键要点:
- 为了说服人们，讲一个故事
- 使用情景-问题-解决方案-后续步骤框架奠定基础
- 整合成功元素，创造一个故事
关闭
亚马逊首席执行官杰夫·贝索斯禁止在高管会议上使用幻灯片。相反，他要求演讲者以叙述的方式写 6 页的备忘录。它可以展示用户、团队成员或媒体如何撰写关于虚拟新产品的故事。杰夫明白讲故事的力量。你知道吗？
附加材料
两种讲故事的结构将帮助你在生活和商业中获得成功
medium.com](https://medium.com/the-mission/how-to-tell-a-persuasive-story-e5ab4689cada) [## 光有数据是不会让你起立鼓掌的
几年前，布琳·布朗博士在 TEDx 休斯顿发表了一个关于“脆弱的力量”的演讲。作为一个…
hbr.org](https://hbr.org/2014/04/data-alone-wont-get-you-a-standing-ovation)
用数据讲故事:商业专家数据可视化指南
对于任何需要使用数据与他人交流的人
所以你想用数据创造更好的故事。此外，您还希望创建更好的数据可视化，从而更好地了解人们，并潜在地获得一些可行的见解。
如果答案是是的，那么继续读下去。
在我的一篇文章中，我在实际工作经验中从数据科学中学到的 5 个教训、沟通技巧和讲故事是我希望在加入实际工作环境之前能够意识到并学到的两个教训之一，因为这两个教训是如此重要——我是认真的。
不久前，我碰巧读了一本书——用数据讲故事:商务人士数据可视化指南——作者是 科尔,用数据讲故事的创始人，也是一位备受追捧的演讲人和作者，他的主题是“用数据有效沟通”。
在对铺天盖地的关于如何用数据提高你的故事讲述的在线资源感到沮丧之后，解释的模糊性和不同方法的普遍性只是让我停滞在同一点上。
为什么是这本书而不是其他的？
感同身受，简单明了。
在阅读这本书的整个过程中，科尔真的教会了我如何有效地与数据沟通— 同理心 — 以及数据可视化的核心和基础— 简单性。
最棒的是，它教会了我如何在不丢失数据中最重要部分的情况下抓住观众的注意力。
好吧，我决定向你展示如何将你的数据转化为吸引你的读者的高影响力的视觉故事的步骤(更详细的说明可以在书中找到),而不是详述我从这本书中学到的经验。
我们开始吧！
1.理解上下文
注重解释性分析(而非探索性分析)和沟通。
对我来说，理解背景就是以商业背景的形式对你的观众的情境需求感同身受。你必须真正站在他们的立场上，看看他们从哪里来，并尽最大努力通过讲故事来回答他们的问题。
在这本书里，你会明白如何将你的数据转化为读者可以消费的信息。下面是它的外观的简要概述:
- 我在和谁沟通？
- 我想让我的观众知道或做什么？
- 我如何利用数据来帮助阐述我的观点？
2.选择有效的视觉效果
如今，在常见的商业环境中，有如此多类型的图表泛滥，但其中只有少数将只适合大多数你的需求。
事实上，在某些情况下，您甚至不需要图形来显示数据，只需简单的文本即可。
因此，选择一个有效的视觉效果就是对你选择的视觉效果进行选择。在商业环境中，一些常用的视觉效果(如 Cole 所建议的)包括简单的文本、表格、热图、点和线图、条形图以及区域。
这里的描述绝不是详尽的，我强烈推荐你参考这本书以获得更多的细节。相信我，你会喜欢的！
3.消除杂乱
对，杂乱。期。
很多时候，我们太喜欢自己创造的视觉效果了，只是意识到(或者没有意识到)在一张图中有如此多的视觉元素占据了空间，却没有增加观众的理解。
人类大脑的精神处理能力是有限的
杂乱只会使视觉更加复杂和难以理解，因此，观众的注意力可能会在我们没有注意到的情况下分散，这只是因为我们处于一种自欺欺人的状态我们的图表就像它本来应该的那样工作。
通过检查每一个视觉元素的需求，你会在书中找到各种实用的方法来逐步消除混乱。
还记得这项工作吗——移情？每一个视觉元素都应该满足观众的需求。
4.在你想要的地方吸引注意力
一旦我们选择了一个有效的视觉效果并去除了所有不必要的混乱，这就是我们需要想出如何吸引观众注意力的地方。
要吸引观众的注意力，就要理解他们是如何看待我们的视觉传达并与之互动的，通常是下意识的。
科尔介绍了一个强大的工具——前注意属性来做到这一点。她解释复杂主题的独特方式是我喜欢这本书的主要原因之一。
5.像设计师一样思考
把你的数据可视化想象成你的产品。
制作你自己的视觉效果——瞧！现在你成了设计师。太好了。我们继续吧。
从不同的角度像一个设计师一样思考，就是要很好地意识到数据可视化如何与你的观众沟通，以及观众如何与你的视觉效果互动。这两点之间的相互作用是一个优秀的数据可视化的基础。
书中讨论了 3 个关键要素，即可及性和审美。此外，书中还教授了更多的策略来让读者接受你的视觉设计。
6.讲故事
最后一步讲故事的部分来了。
想象你刚刚看了一部精彩迷人的电影，故事情节精彩。你被带你踏上难忘旅程的故事所吸引，并最终引起你的情感反应。
几个月甚至一年后，你仍能清晰地记得故事情节。
就我个人而言，我喜欢看电影，因为我相信电影是我们生活的反映，也许是以一种更夸张的叙事方式——但教训是一样的。
用故事从情感上吸引我们的观众，这是事实所不能做到的。
保持简单。
要真实。
不要为自己而沟通——要为你的听众而沟通。**
这个故事不适合你； 这个故事是为他们准备的。
如果你擅长数据可视化，但在讲故事方面有困难。那么这本书是给你的。它教你如何用叙事结构从头到尾构建一个故事。
此外，还有一些有用的技巧可以让你的故事对观众来说更加清晰。
最后的想法
感谢您的阅读。
最终，从数据中获得的见解总是相同的(前提是这些见解是正确的)。
但是使这些见解不同的是从这些见解中得出的影响和可行的计划。这种差异可以归结为你如何通过精彩的故事讲述来传达你的数据见解。
你可以在这里 得到本书 ！
一如既往，如果您有任何问题或意见，请随时在下面留下您的反馈，或者您可以随时通过 LinkedIn 联系我。在那之前，下一篇文章再见！😄
关于作者
Admond Lee 目前是东南亚排名第一的商业银行 API 平台Staq—的联合创始人/首席技术官。
想要获得免费的每周数据科学和创业见解吗？
加入 Admond 的电子邮件简讯——Hustle Hub，每周他都会在那里分享可行的数据科学职业技巧、错误&以及从创建他的初创公司 Staq 中学到的东西。
你可以在 LinkedIn 、 Medium 、 Twitter 、脸书上和他联系。
让每个人都能接触到数据科学。Admond 正在通过先进的社交分析和机器学习，利用可操作的见解帮助公司和数字营销机构实现营销投资回报。
www.admondlee.com](https://www.admondlee.com/)*
Stowers 科学家使用人工智能来揭示蛋白质相互作用网络中的新关系和组织原则
我们在 Stowers 医学研究所的长期合作者上个月刚刚在自然科学报告上发表了一篇题为“扰动蛋白质相互作用网络中拓扑网络模块的识别”的论文。Stowers 也发布了一份新闻稿。这是我们与 Stowers 合作的第三份出版物( PLOS 报纸和 EMBO 报道)。我在之前的博客中写过一些关于这篇论文的内容。
斯托斯的科学家们确定了拓扑网络模块，这些模块由在网络中特定位置发现的具有共享属性的蛋白质组成。生物网络由功能模块组成，然而识别和表征这些模块是困难的。第一作者 Mihaela Sardiu 博士的机场类比非常贴切，“将蛋白质想象成轴辐系统中的机场。该系统在其正常状态下以一种方式工作。但是当一场暴风雪关闭了一个主要的枢纽会发生什么呢？网络的一部分受到影响。网络中某个部分的变化不仅会影响该部分，还会影响周围的部分。”
使用机器智能，作者比较了酿酒酵母中完整的 INO8O 蛋白复合物与破坏的 INO8O 蛋白复合物的分析数据。有趣的是，机器智能不仅捕捉到了复合体内部的结构模块性，还捕捉到了整个网络的模块性，因此命名为拓扑网络模块。此外，作者将机器智能应用于分析先前发表的扰动的人类蛋白质相互作用网络，其中 HDAC 抑制剂 SAHA 用于破坏人类 Sin3 蛋白质相互作用网络，其中机器智能揭示了与 INO8O 网络明显不同形状的网络。
随着更多受干扰的蛋白质相互作用网络变得可用，用像我们这样的高级数学工具分析这些数据集可能会为癌症和其他人类遗传疾病等疾病的研究提供新的见解，在这些疾病中，蛋白质相互作用网络因化疗或固有疾病本身而改变。通过研究蛋白质及其环境，研究人员希望深入了解广泛的生物功能，包括耐药性和导致癌症的突变。
这项工作得到了 Stowers 医学研究所和 NIH 国家普通医学科学研究所的资助。
如果您愿意合作，请通过collaborators@ayasdi.com联系我们。
奇怪的事情:分析和交流数据的五个教训
作为一名统计领域的研究生，我很快意识到，不与数据打交道的人对统计这个词通常会有两种反应:“哦，我讨厌那门课！”和“你一定很喜欢数学！”
几年后，我从这些对话中感觉到，虽然许多人认为统计学和数据科学很重要，但大多数人认为这些技术太过深奥，无法解决他们在自己生活中遇到的问题或好奇心。
我最近尝试了两种方法来打破这种观点:1)使用数据来调查非统计学家可能会感兴趣的问题；2)以吸引人且易于理解的可视化方式呈现数据。
我最近参与的一个项目就是这两种努力的一个很好的例子。在这个项目中，我使用了广受欢迎的科幻节目的公开脚本，试图理解该节目的创作者如何使用情感，以及这种情感如何影响观众的体验。一路上，我学到了一些关于如何有效地获取、分析和交流数据的东西。
1。数据是存在的，但它可能是混乱的
互联网的兴起和用于分析大量数据集的方法的快速增长，往往使得任何问题似乎都可以通过足够的网络搜索和正确的工具来回答。事实往往要复杂一点。我通常发现，虽然很多数据可以在网上免费找到，但你常常不得不做出一些牺牲。
当我着手分析《陌生事物》的剧本时，我设想了一个丰富的数据集，里面有这部剧的所有台词，标有说这些台词的角色和台词发生的时间。我希望看到每个角色的发言时间，每个角色在每集中的个人情绪特征，甚至任何两个角色之间的对话模式。相反，这是我唯一能找到的:
我平静地接受了缺少说话者信息的事实，但仍然决心探究情感是如何在剧集中发展的。幸运的是，统计学找到了方法。我将每集中的单词串成长向量，并根据公开可用的词典为每个单词指定一个情感值。瞧，我有我的时间流的情感。不幸的是，网飞不够善良，无法在对话中说出所有角色的情绪，角色也不够可预测，无法从一种情绪平稳过渡到另一种情绪。这让我有了下一个认识:
2。不要害怕半武断的决定
与精心策划的私有数据集不同，公共数据的使用通常需要分析师在通往结果的道路上做出许多(有时是主观的)决策。有了包括非对话信息(“Joyce 咯咯笑”、“Mike 喘息”)和从单词到单词的快速情绪转换的情节向量，两个这样的决定几乎立即出现。
首先，我包括没有说的单词吗？我认为，是的，像咯咯笑和喘息这样的词包含了相关的信息。第二，我如何平滑轨迹，使它们更容易解释？我决定使用滑动窗口方法(如下图所示)，并选择了 40 个单词的窗口宽度。为什么是 40？嗯，剧集通常有 350 到 400 个词，有一个已知的情感分数，所以使用大约 10%的剧集数据似乎是一个很好的折中方案，介于使用太少数据和出现剧烈波动之间，以及使用太多数据和忽略重要的小规模变化之间。
像这样的决定可能是有风险的，所以根据情况，通常有两个好的选择来处理它们。对于重要的分析，最好尝试几个选项，以确保您的选择不会彻底改变您的结果。如果是这样，这可能是一个信号，表明应该以一种不那么武断的方式做出决定。对于不太重要的分析(比如，一个关于电视节目的周末项目)，最好至少让你的读者知道你的决定。在这两种情况下，提前做出这些决定可以为新的想法和技术打开大门。
在我的帖子中，我成功地提到了我选择的窗口宽度，这成为了与一位读者进行有趣的电话交谈的话题，尽管我忘记了包括我对非对话线索的决定，但另一位细心的读者很好奇，问了。在这两种情况下，读者对这些决定的意识导致了有价值的讨论和对未来研究的想法。
3。丑陋的数字掩盖了有趣的结果
许多统计学家和数据科学家都非常擅长数据可视化，但许多人在分析完成和最终产品创建完成之前，不会花时间让视觉效果变得有吸引力。有了清理过的情绪数据在手，那就是我被误导的方法。
我对数据的第一印象是一个意大利面条图，所有 17 条情感轨迹相互叠加。在仔细观察了每一个之后，我得出结论，它们似乎都在移动，但没有任何明显的模式。我很快按季节给它们涂上颜色，看看这两季是否倾向于显示不同的剧集轨迹，但两季的模式似乎大多是随机的。
幸运的是，在继续之前，我决定即使轨迹本身并没有提供太多信息，读者也可能希望有机会看看它们。因为堆叠的轨迹很难看到，所以我制作了一个动画，一次突出一集。
在看了几集之后，我开始注意到在轨迹上似乎有一些共同的模式。在根据两两相似性创建了剧集网络之后，我对数据应用了基于网络的聚类技术，发现了三组高度可解释的剧集:一组以高音开始，以低音结束，一组围绕中性波动，一组以低音开始，以高音结束。
这成为最有趣的发现之一，如果我没有在分析过程的早期花时间制作一个视觉上吸引人的数据表示，它可能会被错过。虽然快速散点图和直方图有其时间和地点，但通常重要的是要记住，图形越好，就越容易理解数据想要表达的意思。按照这些思路:
4。让你的数据讲述自己的故事(但要小心)
当我着手这个项目时，我设想了一项研究，研究剧集的情感特征如何与它们被批判性接受的方式相关联。我选择使用 AV 俱乐部的评分，因为他们是最知名的发布每集评分的机构。不幸的是，他们当时还没有发布他们的最后两篇评论，这意味着我要等几天才能进行这些测试。在我等待的时候，我制作了一个网络结构的动画，看着剧集来回跳动，并注意到在每集之间网络上似乎有惊人的大跳跃。
相邻情节之间的这种明显不同成为一项分析的灵感，该分析显示相邻情节之间的相似性明显低于你预期的随机发生。这个结果让我推测，改变剧集的情感结构可能是一种让观众参与进来的写作或导演策略。最终，情感轨迹与 AV 俱乐部的评级没有明显的关系，但“让观众着迷于变化的轨迹”的发现很快成为读者的最爱，尽管我在开始分析时并没有想到这个测试。
然而，我把“但是要小心”放在这一节的标题中是有原因的。也就是说，尝试任何仅仅因为其他分析没有结果而看起来有希望的测试从来都不是一个好主意，因为在让数据讲述它们的故事和要求数据讲述不存在的故事之间有一条细微但重要的线。如果数据看起来不像有故事可讲，不要继续挖掘积极的结果。相反，想想你的假设可能有缺陷的地方，并写下你的负面结果。你永远不知道那些负面的结果会对其他人产生什么样的影响。但也许最重要的是:
5。记住你的听众
回顾这个项目，我不得不承认，尽管我有意识地努力让我的作品为广大观众所理解，但我认为我并不成功。虽然这项工作在数据科学家和统计学家中很受欢迎，但非统计领域的密友承认，他们不太能理解我的分析，而且这篇文章通常被认为是相当技术性的。
如果我能再做一次，有些事情我会做得不同。首先，我会花更多的时间来考虑我的作品希望接触到哪些人群，并仔细评估这个群体中的某个人对什么感兴趣，什么不感兴趣(甚至不可读)。第二，虽然不总是可能的，但我会致力于创建一个单独的部分来更详细地描述我的方法，从而在主帖子中腾出空间来进行更多概念性的解释和说明。
总的来说，这个项目是一次奇妙的学习经历，也是一次与程序员、数据科学家和陌生事物爱好者见面和分享想法的好机会。如果在这个过程中，我能够启发更多的非统计学家考虑统计在日常生活中的相关性，或者向数据分析师介绍他们可以用于自己研究的新方法，那么这些时间是非常值得的。
探索项目此处 。
伦敦地层 2017
我上周去了 Strata London，了解了英国数据工程和分析的现状。当然，这只是一个技术会议，所以当你在那里时，这是一种人工现实。但我对此早有准备，我知道科技会议可能会令人失望。以下是我学到的。
深度学习是最新的营销
一些年长的人仍然称它为“人工智能”。对于其他人来说，这是“机器学习”或“ML”。现在看来，营销机器已经把它变成了“深度学习”。
主题演讲中非常关注 ML 和数据科学。今天，ML 的大部分应用仍然集中在识别上:图像识别、语音识别和驾驶识别。这就是为什么全球互联网公司主宰这个领域:需要大量的数据来使 ML 有效。
一位学者的主题演讲表明，当数据科学与人工智能相结合时，我们可以超越图像识别来推断美丽和情感。有趣但仍然只是图像识别。
我很想看看 ML 在哪里被应用得面目全非。麦肯锡报告称，他们遇到了越来越多精通技术的首席执行官，他们有着深刻的理解，并试图找出如何应用它。除此之外，我看不到许多发言人大声疾呼 ML 集成到他们的用户服务中。
AWS 低调出席了会议，但在那里宣传 Apache MXNet 是他们在 AWS 上选择的人工智能框架。谷歌有 TensorFlow，而 AWS 支持 MXNet。TensorFlow 和 MXNet 似乎都专注于性能和规模等非功能性改进。
大数据才刚刚开始
“大数据刚刚起步”
优步
优步从他们的自动驾驶汽车项目中收集传感器数据，以测试他们的汽车在面对真实数据时做出正确的决定。今天每辆车每小时收集 250Gb。因此，对于 1000 辆优步汽车来说，这相当于每天 6,000 Tb。
我怀疑那些拥有自动驾驶汽车项目的组织将成为 hadoop 生态系统技术的领导者。其他人都会是追随者。
鉴于这一切，是时候停止使用“大数据”这个词了，它已经变得毫无意义。
蒂姆·奥莱利做了最好的主题演讲
蒂姆的讲话是会议的亮点。他是一位技术未来学家，思考的事情比其他人超前好几年。尽管这是阶层，他更多地谈到了社会经济影响和技术专家的责任，而不是数据或技术。
Tim 坚持认为包括 ML 在内的自动化应该被用来增加人而不是取代人。自动化应该被用来帮助我们做更多的事情，而不是用更少的人生产同样的东西。这是工业革命的教训，我们比以往任何时候都更富有，预期寿命也更长。
他也向我们挑战。技术是向善的强大推动力，应该用来改善大多数人而不仅仅是少数人的生活体验。这让我想知道我们行业的社交方面是否应该更强？
数据工程和数据科学是不同的领域
Strata 结合了三个不同的数据相关主题:
- 数据工程。这就是 hadoop 和所有支持大规模数据处理的技术。
- 数据科学。这更侧重于数据，而不是技术和生产分析。许多工具供应商在博览会上支持分析，如 Arcadia Data 和 Trifacta。
- ML。这是关于用流行的框架学习算法，让它变得更容易，比如 TensorFlow 和 MXNet。所有这些都需要大量的数据集来学习。
我试图抑制住自己的冲动，不去花时间去了解如何扩展 Kafka/Spark/Cloudera 以应对 n 百万次交易的细节。相反，我想更多地了解高级分析。让我震惊的是，与深度工程讲座相比，科学和 ML 讲座的观众是如此不同。
数据工程仍然是蛮荒的西部
数据工程就是处理大量数据并将其存储在某个地方。这种存储可以是关系存储、NoSQL 数据存储、Hadoop 或文件系统。
处理可以实时、接近实时或分批进行。在 Hadoop 的早期，一切都是关于批处理的。然而，数据流(接近实时)现在越来越受欢迎，以支持更快处理的感知需求。
试图为数据管道选择技术就像一个孩子在糖果店。有太多的选择和太多的细节困扰。由于市场不成熟，技术变化如此之快。甚至[在共同主持人中也有不同的意见](https://www.slideshare.net/mobile/hadooparchbook/architecting-a- nextgeneration-data-platform)。我带走的是，
- 卡夫卡在制作和缓冲方面胜出。
- Spark 在流媒体和查询方面胜出。
数据工程很复杂，而且经常失败
Jesse Anderson 做了一场唯一的数据工程文化讲座。他告诉我们 85%的大数据项目都失败了。根据他的经验，这是因为大多数数据工程团队存在技能和经验差距。他强烈主张专业数据工程师对此进行反击。
我也很有兴趣听 Jesse 谈论与 SQL 或数据仓库相比，大规模数据处理的指数级复杂性。这与我看到的技术景观产生了共鸣。因此，当数据量和处理吞吐量不需要时，技术架构师必须抵制部署大规模数据处理技术的冲动。
2017 年是数据处理的云之年
Hadoop 解决方案在向云迁移的过程中落后于其他解决方案。这通常是出于安全或性能原因。但现在 Cloudera 已经推出了 Altus 我预计云将成为 hadoop 的默认版本。
借助 Cloudera Altus，您可以将数据保存在 AWS 中，例如在 S3，而您的集群是由 Altus 根据定义的数据管道作业自动配置的。之后，它将被取消配置。今天，它只是专注于数据工程，但预计随后将进行分析。
那么 Cloudera 的竞争对手是谁呢？谷歌在 Strata 有很大的影响力，推动他们的云、工具和深度学习。微软在博览会上有一个展位，但并不突出。AWS 基本上不存在。我预计微软 Azure 和 AWS 今年将在各自的会议上大幅提升其大数据 PAAS 服务。
很明显，Hadoop 只是大数据的基础设施。如果组织可以忘记管理服务器，安装 hadoop 并使用 PAAS 数据解决方案管理集群就有更大的成功机会。将数据服务转移到 PAAS，不仅会将数据项目推向更高的价值，还会让市场走向成熟。
想在 Kainos 做数据工程师或者数据科学家？点击这里了解更多信息。
成为成功 Youtube 的策略:广泛的 Youtube 探索性分析(第 1/2 部分)
为 Youtubers 开发数据驱动的策略
你通常花多长时间看 Youtube？你最喜欢的频道是什么？最近什么频道最受欢迎？Youtube 正在成为主要的社交网络平台之一，甚至是一个正在崛起的搜索引擎。用户甚至数字营销人员都明显将注意力从脸书转移到了 Youtube。Youtuber 现在是一颗冉冉升起的新星。他们用自己独特的内容与人们联系在一起。拥有超过数百万的用户，youtube 明星不仅通过观看视频来盈利，还通过开展自己的业务来盈利。
在这个不断变化的潮流中，我制定了一个计划，为 Youtubers 制定策略，并建立一个模型，根据它们的内容预测观看人数。这篇文章将分为两部分。在第一部分，我们将广泛地探索数据。然后在第二部分的中，我们将建立一个带有单词嵌入的预测模型。我使用了来自 Kaggle 的数据，但是用 Youtube API 添加了一些。数据集和完整代码可在 Github 上获得。
Youtube 上最大的频道有哪些？
首先，我查找了拥有最多视频和订户的前 20 个频道。正如您在上面看到的，这两个频道列表互不相同。大多数有大量视频的频道都是电视节目、广播或组织，如今夜秀、Vox、艾伦秀、和网飞。另一方面，那些拥有大量订户的是音乐频道，如艾德·希兰、泰勒·斯威夫特、阿姆、和爱莉安娜·格兰德。
Youtube 上最热门的话题是什么？
这次让我们更深入地探讨话题。共有 16 种主题，我统计了每个主题的视频和频道数量。Youtube 上你最喜欢的话题是哪个？有哪些热门且竞争激烈的话题？
视频和频道号的分布显示出不同的模式。y 轴上的主题顺序是一样的。我按视频数量排列顺序，然后在频道剧情中设置相同，这样就很容易上下查看了。娱乐在两个情节中都是第一位的。音乐，人物&博客，Howto &风格，和科学&科技有大量的渠道。是否可以推断它们是最热门的话题？
我统计了每个主题的喜欢、不喜欢、观点和评论的中位数。y 轴上的主题顺序也是一样的，所以您可以很容易地比较这四个计数。喜欢、不喜欢和评论计数的图表显示了类似的分布。有趣的是， Gaming 是最热门的频道，因为它在之前的剧情中拥有相对较少的频道和视频。
有视频和频道数量的剧情可以告诉你哪个话题有很多竞争对手。一个话题的频道越多，为了获得人们的关注，竞争就越多。另一方面，显示视频或观看次数的图表可以告诉你哪个话题最热门。他们可以告诉你人们的主要兴趣是什么。您还可以找到用户的喜欢和不喜欢的回应水平，每个主题的评论计数。例如，娱乐或人物&博客在视频数量和订阅量排名靠前，但回复率低于预期。
时间响应呢？
响应率也可以从时间段的角度来说。要多久才能成为潮流视频？每个主题的订阅者将有不同的及时性和活跃性，所以我们可以期待在时间分析不同的模式。
左边的图显示了每个主题需要流行的天数。大多数话题有相似的分布，但是新闻&政治和体育时间最短，而节目时间范围最大。右边的图表显示了一天中最流行的视频的用户数量。我们可以很容易地预计，它将需要大量的订户在一天内成为潮流，然而，它的价值范围很广。这可以推断出，订户数量不是观看的绝对因素。
这里方框的大小表示数据的大小。因此在我们的数据中，当天受到关注的节目视频很少，而时尚娱乐或音乐视频很多。这可以通过下面的柱状图更容易地理解。显示了一天中流行的视频数字，这与盒子的大小告诉我们的完全相同。
作为结论，视频的反应率在话题之间是不一样的。我们可以说，喜欢看游戏的人会积极地表达他们的意见和回应。像新闻&政治和体育这样传递最新消息的视频时间很短。迄今为止，娱乐和音乐一直高居榜首。但是请记住。很多人喜欢，很多竞争者。
建议用什么标题才能获得关注？
当我们浏览文本时，我们的感知是有局限的。所以标题的长度和标题的字数是吸引眼球的重要因素。标题长度对视图有影响吗？标题中包含多少单词是合适的？让我们从下面检查答案。
这些视频的标题少于 100 个字符，而浏览量最高的是 30 到 50 个字符。如果我们说一个单词通常有 5 或 6 个字符，这意味着标题中最好有 5 到 10 个单词。这与第二个图一致。字数不到 20，浏览量最高在 7 左右。因此一个 6 到 7 个字的标题可以获得更多的浏览。
标签越多真的意味着浏览量越多吗？
标签当然是一个重要的因素。但是我们应该使用多少标签呢？标签越多带来的浏览量越多真的是这样吗？
如图所示，标签的数量似乎与视图没有直接关系。最高浏览量为 4 次，但从数字上看没有明显的趋势。此外，通过正确的绘图，我们可以看到每个主题有不同的分布。这表明更多的是关于标签中有什么关键字，而不是有多少关键字。
单词 cloud 显示了主题中经常使用的标签。我带来了娱乐、音乐、游戏、喜剧、Howto &风格、和旅游等例子。这些视频的浏览量超过 180 万次，占总浏览量的三分之一。虽然不能说那些观点是因为标签，但至少我们可以推断出人们对什么感兴趣，内容中有什么。
具有数字特征的绘图矩阵
最后，我使用 ggpairs 制作了所有数字变量的绘图矩阵。它有订阅者的数量、浏览次数、喜欢、不喜欢、评论、标题的长度、标题的字数和标签的数量。您可以轻松检查所有对的散点图和相关性。喜欢与浏览量和评论数相关。此绘图矩阵对于在开始更深入的分析之前查看要素之间的整体关系或在构建预测模型之前检查多重共线性非常有用。
结论
让我回顾一下到目前为止我们已经完成的内容。
- 视频数量和订阅用户数量可用于评估热度和竞争力。和话题一起考虑的话，娱乐和音乐最受欢迎。
- 回复率可以从两个方面来考虑。当考虑喜欢、不喜欢和评论的数量时，游戏是高活跃用户最热门的话题。从时间段来看，像新闻&政治和体育等发布最新消息的频道反应最快。
- 标题的措辞很重要，6 到 7 个单词可以获得更多的浏览。
- 说到标签，包含关键词比仅仅有许多标签更重要。因此，需要知道什么是主要问题。
要成为一个成功的 youtuber，拥有成千上万的订阅者显然很重要。然而，制作包含人们真正关心的内容的视频与用户数量一样重要。因此，它需要有能力阅读什么是趋势，人们有什么样的需求。
为了进一步分析，我们可以选择一个特定的主题，并在副主题上工作。它会给我们更详细的信息。使用通道进行时间序列分析也是可能的。研究流行频道的增长模式就是一个很好的例子。这种研究不仅可以用于 youtubers，也可以用于数字营销人员。如果他们通过评论进行进一步的分析，他们可以收回对如何锁定客户的洞察力。
下一步是什么？
下一个故事是关于建立一个模型来预测视图！我将讨论单词嵌入，并建立一个预测视频观看量的模型。
[## 成为成功 Youtube 的策略:广泛的 Youtube 探索性分析(第二部分)
揭开单词嵌入的神秘面纱并拟合模型以预测视图
towardsdatascience.com](/strategies-to-be-a-successful-youtuber-extensive-youtube-exploratory-analysis-part-2-2-6862cd4f40be)
如果你想鼓励一个有抱负的数据科学家，请给一个或两个或三个掌声！我将非常感谢任何反馈，所以请在下面分享您的想法或通过 LinkedIn 联系我。感谢您的阅读，再见👋
成为成功 Youtube 的策略:广泛的 Youtube 探索性分析(第二部分)
关于文字嵌入和预测 Youtube 上的浏览量的初学者指南
这是为 Youtubers 开发数据驱动策略的文章的第二部分。在之前的帖子中，我们对 Youtube 的统计数据进行了深入的数据分析。如果你还没有查看第一部分的话，请花点时间看看成为一名成功的优步者的策略是什么。对于第二部分，正如我之前提到的，我们将基于视频内容预测视图。我也将在简单的英语中揭开单词嵌入的神秘面纱。这个项目的数据集和完整代码可以在我的 Github 上找到。好吧！该机器学习了。
从一键编码到单词嵌入
机器学习算法主要处理数值变量。他们对文字没有概念。就像一个除了哭什么都不知道的婴儿(在这种情况下可能是错误信息)，他们对“苹果”、“狗”或“我”、“我”和“你”没有任何概念。因此，当我们处理文本数据时，当我们要教他们人类语言时，我们必须将数据转换成数字类型。这是贯穿所有自然语言处理的基本概念。
那么我们如何将单词转换成数字形式呢？我们能想到的第一种方法是把它们当作一个二元因素变量。这就是一热编码的由来。我们制作一个包含 1 和许多 0 的稀疏矩阵来表示一个单词在句子中的存在。如果你不熟悉 one-hot-encoding，请查看我之前的帖子。它逐步涵盖了文本挖掘的基础。然而，这种方法的局限性是没有语义信息。它对单词“猫”和“狗”、“是”和“我”都一视同仁。我们想要的不止于此。我们希望机器理解语言的真正含义。那怎么才能把课文的意思教给我们天真的宝宝呢？
欢迎来到世界的向量空间
老实说，我不擅长记名字。每当我有话要说，但找不到合适的词时，我总是这样说，“那是什么？”？“那是什么？”。有趣的是，我从来没有立刻得到确切的单词，而是像在黑暗中一样不断摸索，当我想说“猫鼬”时，我会说类似的话，如“松鼠”或“狐狸”这就是我们大脑的工作方式。相关的单词被紧密地放置在我们的“大脑空间”中。
单词嵌入也以同样的方式工作。让我们想象有一个很大的空白板。这是一个坐标平面，一个向量空间。我们手里有单词卡。这是我们的文本数据，术语。我们将以一种“有意义”的方式将这些卡片贴在板上。怎么会？简单！将语义相似的单词放在一起。
让我们看一个简单的例子。我们有 猫、狗、女王、国王、女人、 和 男人 的字卡。我们可以把群体做成像 猫狗女王国王女人 和男人 这样的群体。还可以有更大的群体，像[ 猫，狗 ]和[ qeen，king，woman，man 。然后我们可以像上面一样把它们放到平面上。
当我们把单词放在坐标平面上时，我们给了它们位置或坐标。本例中， 皇后at(8，2)国王 at (6，4)女子 at (6，1)男子 at (4，3)。你注意到这里有一个窍门吗？ 女王 和 国王 之间的距离与 女人 和 男人 之间的距离相同。这就是单词嵌入的真正威力所在。在向量空间中，单词之间的距离是关键点，语义存在于其中。我们甚至可以计算这类问题:什么是 王——男 + 女？**答案是， 女王 ！
这是一个简单的向量空间，你做的是向量计算。现在，我们正在向机器教授真正的人类语言。他们似乎能理解一些单词的意思。但是还有一个问题。如何才能判定单词之间的相似度？你不能随心所欲地摆放它们。我们需要一个逻辑计算机制，不是吗？
物以类聚，人以群分
计算单词间相似度的一种方法是计算共现次数。一个词 A 伴随一个词 B 出现的频率有多高。如果他们经常一起出现，他们有很高的相似度。如果很少一起出现，则相似度低。喜欢..就像你和你的朋友一样。让我们以这句话为例。
我们要数一数 女王 和 国王 聚在一起的频率或者 女王 和 城堡 出现在邻居家的频率。你觉得 皇后 和 国王 近到可以称之为邻居吗？那么 女王 和 城堡 呢？是的，你用什么标准会不一样。我们称之为窗口函数和窗口大小。
女王 是我们的重点词。在这种情况下，我们只接受焦点单词两边的一个单词。原来是 。于是 女王 就对应于此。
这次让我们把窗户开大一点。我的意思是增加窗口大小。我们会接受两边各两个字。因此 城堡 和 美丽的 也可以成为 女王 的邻居。
上下文窗口将不断切换焦点词，扫描它的邻居。如果我们把结果做成一个矩阵，我们会得到这个矩阵。
这是窗口大小为 2 的共生矩阵。根据矩阵， 城堡 对应【1，1，0，1，1，0，0，0，0】，而 对应【0，1，1，0，1，2，1，1】。我们现在可以知道哪些词经常出现在一起，这意味着上下文相似度很高。
你是在预测还是在计算？
向量化单词意味着给它们在向量空间中一个位置。通过这样做，我们可以将语义嵌入到向量中，并通过距离进行推理。矢量化有两种不同的方法，Word2vec 和 GloVe。
Word2vec 是一个“预测”模型，通过分析一个单词的邻居来确定该单词的含义。Word2vec 的一个例子是连续单词包，或 CBOW。它从周围的上下文单词中预测目标单词。
看一下上图。你能预测蓝色卡片后面的单词是什么吗？CBOW 就是这么运作的。它从当前上下文单词中预测一个单词。
Word2vec 的另一种情况是 skip-gram，预测的方向是相反的。它使用当前单词来预测其上下文单词。什么词可以作为它的邻居？
CBOW 和 Skip-gram 这两个模型由具有损失函数的浅层神经网络来训练。下图是 CBOW 和 Skip-gram 的简图。使用 CBOW 模型，我们输入类似于 learn 、 kids 和 fish 的上下文词，并期望在输出层获得 school 的矢量化值。相反，使用 Skip-gram 我们输入目标单词 学校 并得到输出 学习 、 孩子 和 鱼 。
**
另一方面，GloVe(代表全局向量)是一个“基于计数”的模型。他们使用整个语料库的共现矩阵，并计算一个单词 k 在另一个单词 w 的上下文中出现的频率。例如，我们通过条件概率 P( 校|**|学*** )来统计 学 的上下文中 校出现的频率。这些值将是包含单词间上下文关系的单词嵌入的结果。想象一下，考虑到 GloVe 与“全球”语料库一起工作，结果矩阵会有多大。它将是巨大的，具有高稀疏性。因此，我们需要分解矩阵，得到一个较低的维度。通过 LSA 或 LDA 等方法，我们对其进行因子分解，得到 DTM(文档-术语矩阵)或 TCM(术语共现矩阵)。*
如果您感到困惑，请记住 Word2vec 是一个预测模型，它使用本地上下文窗口，而不是直接使用共现统计数据，而 GloVe 是一个基于计数的模型，具有全局共现统计数据。哪个更好？他们都擅长捕捉语义。您应该有的问题是哪一个将更恰当地表示您的数据。生成的向量显示数据的上下文含义的效果如何。因此，理解每种方法是如何嵌入语义的是至关重要的。对于那些想更深入地研究单词嵌入的人，我会在这篇文章的最后留下一些参考资料。
用 R 嵌入单词
太好了！现在，我们准备将这一惊人的技术应用到我们的 Youtube 数据中。让我们先检查一下我们的数据。
*# Importing data
us = read_csv('us.csv')
head(us)*
**
为了让你更好的理解，我稍微改变了列的顺序。我们的数据集中总共有 40949 个视频和 2207 个不同的频道。所以n在这里表示每个频道的视频总数。首先，我将预处理文本数据(标题、标签和描述)。
*# selecting text columns and combining into one
us_text = us %>%
select(title, tags, description) %>%
mutate(text = paste(title, tags, description))us_text$text = gsub(us_text$text,
pattern = '[^[:alnum:]]', replacement = ' ')
us_text$text = tolower(us_text$text)*
用 text2vec 包嵌入单词的过程如下:
- 使用迭代器创建词汇表，词汇表是所有文档中唯一单词的列表。假设我们正在用训练集中的单词编写一本词典。
- 删减词汇，因为会有很多无关紧要的词。
- 向量化词汇，这是创造一个词的结构
- 使用迭代器和矢量化词汇，制作 DTM。我们也可以应用 Tf-Idf，得到调整后的 DTM。
*# creating an iterator and a vocabulary
it = itoken(iterable = us_text$text,
tokenizer = word_tokenizer)v = create_vocabulary(it, stopwords = stopwords('en')) %>%
prune_vocabulary(doc_proportion_max = .5, term_count_min = 5)vectorizer = vocab_vectorizer(v)
print(v)# casting into dtm with Tf-Idf
dtm = create_dtm(it, vectorizer)
tfidf = TfIdf$new()
dtm_tfidf = fit_transform(dtm, tfidf)dim(dtm_tfidf)*
结果dtm_tfidf有 40949 行和 60966 列。是啊！我们成功了。整个文本数据被标记为 60966 列。你刚刚把单词的真正“含义”教给了机器！
预测视图
将单词 vectors 给前面的模型是完全没问题的。但为了准确起见，我想添加其他功能。有三种特征，时间变量、二进制因子变量和数字计数变量。如下所示，我做了单独的特征工程。
*# feature engineering with time variables
us_time = us_time %>%
select(publish_time) %>%
mutate(year = year(publish_time),
month = month(publish_time),
day = day(publish_time),
hour = hour(publish_time),
wday = wday(publish_time)) %>%
select(-publish_time) %>%
mutate_all(factor)# encoding factor variables into integer
us_factor = us %>%
select(comments_disabled, ratings_disabled,video_error_or_removed) %>%
mutate_all(factor) %>%
mutate_all(as.integer)# preprocessing numeric variables
us_count = us %>%
select(channel_id, n, views, subscribe, len_title, nword_title, n_tags) %>%
group_by(channel_id) %>%
mutate(subscribe = log1p(mean(subscribe))) %>%
ungroup() %>%
select(-channel_id) %>%
mutate(views = log1p(views))*
每个频道的subscribe值不是恒定的，会有微小的波动。这可能是由于从网上抓取数据时的时间差，所以我把它们的平均值。另外，subscribe和views的分布是指数分布，所以我把它们转换成对数分布。我排除了likes、dislikes和comment_counts变量，因为它们发生在人们观看视频之后。因此不适合用它们来预测视图。
*# binding by column
full = cbind(us_time, us_factor, us_count)# splitting data into train and test set
part = sample(x = nrow(full), size = nrow(full)*0.8)tr_te = full %>%
select(-views) %>%
model.matrix(~.-1, .) %>%
cbind(dtm_tfidf)tr = tr_te[part, ]
tr_y = full$views[part]te = tr_te[-part, ]
actual = full$views[-part]*
我把所有预处理过的数据合并成一个。为了确保随机性，我将整个集合进行了洗牌，并将其分为训练集和测试集。接下来，我将它们放入 DMatix 对象中。我使用了 Xgboost 并得到了如下的变量重要性图。哪些变量在预测中发挥了重要作用？
*# putting into two seperate Dmatrixs objects
dtr = xgb.DMatrix(tr, label = tr_y)
dte = xgb.DMatrix(te)# fitting the model
myParam <- list(objective = "reg:linear",
booster = "gbtree",
eval_metric = "rmse",
nthread = 6,
eta = 0.05,
max_depth = 8,
min_child_weight = 5,
subsample = 0.7,
colsample_bytree = 0.7)model_xgb = xgboost(dtr, tr_y, param = myParam,
nrounds = 5000, print_every_n = 100,
early_stopping_rounds = 100)# predicting
pred_xgb = predict(model_xgb, dte)# ploting the importance of the features
xgb.importance(feature_names = names(tr), model = model_xgb) %>%
xgb.plot.importance(top_n = 30)*
订户号码是最关键的特征。频道n的视频数量紧随其后。我们还可以看到month6、month4或month3，分别表示发布于 6 月、4 月和 3 月的视频。我们可以得出这样的结论:用户数量、上传视频的时间、足够的标题长度以及对热点新闻的报道能够带来更多的关注。
结论
如果你想得到一个更精确的模型，每个主题的模型会更好。由于每个主题的用户有不同的模式(就像我们上次看到的那样)，最好将每个主题的数据分开。有各种单词嵌入算法，它们是高级版本或以不同方式执行。因此，选择更好地表示数据的方法可以提高准确性。
我们可以在各种领域使用单词嵌入。它甚至可以应用于非 NLP 数据。在结束这篇笔记之前，我想给你介绍两个有趣的可以启发你的项目。一个是使用 word2vec 进行音乐推荐的 Ramzi Karam 另一个是为学生量身定制数学练习的 Kwyk 。
资源
- Suvro baner JEE对单词嵌入整体步骤的精彩讲解:https://medium . com/explore-artificial-intelligence/word 2 vec-a-baby-step-in-deep-learning-but-a-giant-leap-forward-natural-language-processing-40 Fe 4 e 8602 ba
- 更多关于 word 2 vec:https://blog . acolyer . org/2016/04/21/the-amazing-power-of-word-vectors/
- 关于 GloVe 的更多信息:https://blog . acolyer . org/2016/04/22/GloVe-global-vectors-for-word-representation/
- 还在混淆 Word2Vec 和 GloVe 吗？:https://www.quora.com/How-is-GloVe-different-from-word2vec
- 如何使用 text2vec 包:https://srdas.github.io/MLBook/Text2Vec.html
感谢您的阅读，希望这篇文章对您有所帮助。如果有需要改正的地方，请分享你的见解！你的掌声让一个有抱负的数据科学家在地板上跳舞。👏 👏 👏我总是乐于交谈，所以请随时通过 LinkedIn 联系我。我将带来另一个激动人心的故事。在那之前，机器学习快乐。
数据科学家的战略
Strategic Planning
美国教授军事战略的一个关键方法是根据“战略=目的+方法+手段”的公式，未来的军事领导人利用这一总结来分析过去指挥官的战役。
使用这个公式提供了一种能力，可以看到和分析战略是如何根据目标而变化的。
Art Lykke 在讨论方法和手段的文章中提供了一些军事目标的例子。它们包括“保卫家园”、“收复领土”和“遏制侵略”。举例来说，直观地说，“威慑侵略”可以通过投射一个强大力量的外观而不发射一发实弹来实现，但“恢复领土”将需要入侵目前被敌人占据的地区。
对于数据科学家来说，关注目标和实现目标的手段之间的差异是有益的。与“沟通”一词相比，“可视化”一词在数据科学家(指制作图表的工具——一种沟通方式)的文章中的使用次数，或者“说服”或“说服”等词的使用次数，显示了数据科学家对他们所服务的目的的方式方法的关注。更能说明问题的是像这样的文章，数据科学工具——执行数据科学战略的手段——没有讨论它们可以用来实现的目标。
Frank Harrell 在《回归建模策略》中提供了许多策略，这些策略实际上暗示了两个正交轴——一个衡量从无到优的预测能力，另一个衡量从无到优解释输入的作用的能力。他还建议采取互补策略，为预测和推断创建有效的独立模型。
这种分析提供了低层次的目标(“建立一个即使不能理解也能很好预测的模型”或“建立一个能被理解的模型，即使其他模型能更好地预测”)，但没有考虑更高层次的目标。请注意，哈雷尔的文本提供了充分发展的战略，在提出目标后，他概述了实现这些目标的方法。
这突出了军事战略与数据科学战略具有共同点的另一种方式——人们已经认识到，军事手段经常被用来支持政治目标。这一点在越战结束时美国上校萨默斯和北越上校涂之间的著名对话中得到了鲜明的体现——当萨默斯上校说“你知道，你永远不会在战场上击败我们”时，涂上校反驳说“这是真的，但也无关紧要”。
在设计数据科学的策略时，总是存在这样的危险:一个执行良好的模型，其表现超出了设计者最乐观的预期，完全无法增加销售额或利润，或降低成本，或在任何其他方面对业务目标有意义。
更不可思议的是，数据科学策略最初可能是成功的，但后来却因政治反弹而成为一个沉重的负担，或者因失去用户信心而失败。
在科技领域，脸书是一家冒险经历类似美国越战经历的公司的例子——他们已经实现了“军事”目标，但现在面临政治风险。本周，脸书和马克·扎克伯格出现在新闻中，扎克伯格出现在美国国会面前。
扎克伯格提到开发一个人工智能系统，在 10 年的时间框架内检测仇恨言论。他的目标是赢回脸书用户和其他利益相关者的信任，比如立法者。然而，虽然这一战略具有明确的目标和实现目标的手段，但这些手段并不能完全满足目标——开发技术来筛选仇恨言论本身并不能赢回人们的信任。要做到这一点，脸书将需要一个完整的战略，以确保人们相信他们可以脸书可以保护他们免受仇恨言论——一个沟通或说服策略。
各地的数据科学团队都需要充分了解他们的目标，以便全面制定有效的战略。这通常意味着应用防御策略——一种预测对自身成功的威胁的策略。当然，成功的意义需要更密切的关注和更深入的思考。
将 Twitter 数据流入 MySQL 数据库
鉴于我经常看到数据库语言被列为数据科学工作的要求，我认为今天在 MySQL 上发表一篇文章是个好主意。特别是，我想看看我们如何使用 python 和 API 将数据直接传输到 MySQL 数据库中。我最近为一个个人项目这样做了，我想我应该分享我的代码，并为那些可能不熟悉这些工具的人提供一个入门教程。
我们将使用 Twitter API 来搜索包含特定关键字的推文，并将其直接传输到我们的数据库中。一旦我们做到了这一点，数据将随时可供进一步分析。这项任务需要几样东西:
- Twitter 帐户和 API 凭证
- MySQL 数据库
- Tweepy 和 mysql-connector Python 库
Twitter API
在我们访问 API 之前，您需要设置一个 twitter 应用程序。我不会就此做深入的指导，但简单地说，你需要做以下事情:
- 转到以下网站https://developer.twitter.com/并创建一个帐户。(这一步比以前要复杂一些，包括提供一个简短的概要，说明你打算如何处理这些推文，以及它们的用途。我认为这与新的欧盟隐私法有关。)
- 一旦您验证了您的电子邮件，您就可以登录您的帐户。你应该可以在下面的网页上创建一个新的应用:【https://developer.twitter.com/en/apps
- 填写关于您的应用程序的所有详细信息，然后创建您的访问令牌。
- 记下您的消费者密钥、消费者机密、OAuth 访问令牌和 OAuth 访问令牌机密。这些是连接到 API 所需要的。
想要更完整的教程，我推荐这篇的博文。完成这些步骤后，如果我们编写了正确的代码，我们的应用程序现在就可以连接到 Twitter 流 API 了。接下来，我将完成 MySQL 数据库的设置，这样我们就有了存储所有数据的地方。
MySQL 工作台
有许多不同类型的数据库可以用于这个特定的任务，包括 NoSQL 数据库，如 MongoDB 或 Redis。然而，我选择使用 MySQL，因为我对它更熟悉，而且它仍然是最受欢迎的数据库之一。在开始之前，我们需要安装 MySQL Workbench 和 MySQL server。这里的是一个视频教程，解释如何安装两者，并设置好一切开始收集数据。
一旦你完成了上面的教程，你应该已经建立了一个连接和一个模式/数据库(我的数据库被形象地称为 twitterdb )。在我们设置好 MySQL workbench 并对界面有所熟悉之后，我们最终可以创建一个表来存储我们的 twitter 数据。创建一个表非常简单，我们可以使用 UI 甚至使用查询。使用 UI，我们只需右键单击数据库，然后单击 create a table。然后，我们可以直接输入列名和数据类型。此时，值得考虑我们要存储的数据以及它们将是什么样的数据类型。为了更好地理解我们需要的数据类型，我们应该看一看 TwitterAPI 文档。本质上，我想要写下 tweet 的人的用户名，创建的时间， tweet ， retweet count ，tweet 发起的地点和地点(下面有更多信息)。这相当于 6 列加上主键，我们可以如下定义数据类型:
- 主键:INT(11)
- 用户名:VARCHAR(255)
- created_at: VARCHAR(45)
- 推文:文本
- retweet_count: INT(11)
- 位置:VARCHAR(100)
- 地点:VARCHAR(100)
计算机编程语言
好了，现在我们已经建立了数据库，是时候开始学习 Python 代码了。我们希望代码做几件事:
- 我们想要创建一个允许我们连接到 Twitter API 的类。
- 我们还需要创建一些连接到数据库的代码，并将数据读入正确的列。
我们将使用 Tweepy 库，这将使我们很容易连接到 API 并开始传输数据。在我们开始之前，我们将再次看一些美味的文档。在 Tweepy 文档中，我们可以找到一些真正有用的类和方法的例子，我们需要用它们来与 API 进行交互。下面的代码是一个简单的例子，它允许我们连接到 API 并从我们的时间线打印推文:
import tweepyauth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_token_secret)api = tweepy.API(auth)public_tweets = api.home_timeline()
for tweet in public_tweets:
print(tweet.text)
好吧，希望这很简单。看起来我们只需要设置我们的凭证，访问时间线并循环打印出来。我们想做的有点不一样。我们希望将实时推文传输到我们的数据库中，根据文档，需要做以下三件事:
- 创建一个从 StreamListener 继承的类。
- 从此类实例化一个对象。
- 使用此对象连接到 API。
这似乎很简单。让我们看看我们是如何用 Python 来做这件事的( 完整代码在 文章的最后)。我们需要导入一些库，还需要为数据库设置令牌、密钥和密码。我将所有这些保存在 setting.sh 文件中，该文件使用下面的代码调用，并将令牌和密钥设置为环境变量。
subprocess.call(“./settings.sh”, shell=True)
注意，在我们的导入中，我们需要 mysql-connector 。同样，这里有一些关于这个库如何工作的有用的例子。我们可以在终端(我在 Mac 上)使用 pip 命令安装任何我们没有的库，如下所示。然后，我们应该能够从脚本中导入这些库。
pip install mysql-connector
pip install tweepy
接下来，我们需要设置从 StreamListener 继承的类。我们将给这个班三种方法。这些是类已经实现的方法，我们将覆盖它们。下面的代码实现了这一点。
让我们一步一步地检查一下，以确保一切都很清楚。第一个方法， on_connect() 只是在我们连接到流时通知我们。每当我们的 HTTP 状态代码不是 200 (200 表示一切正常)时， on_error() 方法就会打印一个错误。感兴趣的代码列表:https://en.wikipedia.org/wiki/List_of_HTTP_status_codes
好了，下一个方法， on_data() 稍微复杂一点。为了理解这一点，我们需要对 tweets 的结构有更多的了解。当我们访问 API 时，我们得到一个 JSON 响应(非常类似于 python 字典的结构)。更多信息在这里。
本质上，我们返回的 tweet 对象如下所示:
{ “created_at”:”Thu Apr 06 15:24:15 +0000 2017",
“id”: 850006245121695744,
“id_str”: “850006245121695744”,
“text”: “1/ Today we’re sharing our vision for the future of the Twitter API platform!nhttps://t.co/XweGngmxlP",
“user”: {},
“entities”: {} }
因此，我们有一个 JSON 对象，它包含键、值对(注意，这里没有列出我们将使用的一些属性)。那么，我们实际上想要从中获得什么数据呢？tweet 对象实际上提供了相当多的信息，我建议浏览一下文档，看看您可能对哪些属性感兴趣。对于这个分析，我选择收集用户名、推文创建时间(如果我们随着时间的推移收集推文，这将更有用)、实际推文、推文的国家、位置(更接近本地)以及最后的转发数的数据，这反映在上面的代码中。
最后几行调用了将变量作为参数的 connect() 方法。这段代码全部被包装在一个 try 中，除了语句来捕捉我们可能遇到的任何错误。
好了，你可能已经注意到我们还没有创建 connect()方法，所以让我们创建它。这个方法并不奇怪，它会连接到我们的数据库并输入所有的数据。如前所述，该方法接受在 StreamListener 类的 on_data()方法中创建的变量作为参数，并将它们插入到数据库中同名的列中。要连接到我们的数据库，我们只需使用 connector.connect 方法，并传入我们的数据库信息，这些信息可以从 MySQL workbench 中找到。如果连接成功，就会创建一个游标对象，允许我们执行 SQL 语句。现在我们可以编写查询，并使用 execute 命令将数据插入到我们的 twitterdb 数据库的正确表中。当 is_connected()为 true 时，我们的数据库连接保持打开，并不断地将数据输入数据库，直到我们在终端中终止它(使用 Ctrl+C)。
我们可以创建一个单词列表来过滤流。我是一个高尔夫迷，所以我决定搜索与高尔夫相关的单词。实际上，你可以在这个列表中放入任何你想要的东西。
现在，我们只需要设置我们的脚本，以便在从终端执行文件时调用这些函数。为了访问 API，我们需要将我们的凭证作为参数传递给oauthandler方法和 set_access_token 方法。接下来，我们通过传入经过验证的 api 对象和侦听器来创建流。我们还可以在这里创建要过滤的单词列表。要启动这个流，我们只需在我们的流对象上调用 filter 方法，并将我们的单词列表作为参数传入。我将这个脚本保存为 StreamSQL.py.
如果我们想运行这段代码并开始收集 tweets，我们可以使用终端。这里需要注意的一件重要事情是，我们需要确保我们的 SQL server 已经启动并且正在运行，以便脚本能够正常工作，因此在运行脚本之前仔细检查这一点是值得的。
我们可以直接从存储脚本的文件夹中打开终端，只需输入:
python StreamSQL.py
结论
希望这表明用 MySQL 建立数据管道并不复杂，尤其是在利用 Python 提供的强大库时。SQL 是从事数据科学的一个非常重要的方面，如果你曾经在招聘广告中看到过数据科学家的要求，这一点是非常明显的。尽管这并不涉及对 SQL 或编写复杂查询的深入理解，但我认为能够理解这种任务仍然非常有用。
对于那些有兴趣学习更多 SQL 知识的人，我参加了以下免费的课程，我发现它非常适合练习一些关键概念和理解一些更高级的功能。我向任何对提高 SQL 技能感兴趣的人推荐这本书。在以后的帖子中，我将集中精力提取我们收集的原始数据，清理它并执行一些简单的分析，这将说明我们可以用这种类型的数据做一些有趣的事情。
下次见！！
链接第二部分:https://towardsdatascience . com/building-an-ETL-pipeline-in-python-f 96845089635
加强大会的职业规划
在开始我的职位后，我花了一些时间来反思我在大会的数据科学沉浸式项目中的经历。该计划的教育部分非常出色，为我在当前职位上使用的技能奠定了基础。我可以毫不犹豫地说，课程很有针对性，老师也很有帮助。然而，事后看来，当我写了我的文章，讲述我是如何从该项目的教育部分毕业到职业服务部分(又名 Outcomes) 时，我认为我太乐观了。
不要误解我，GA 的职业服务部门 Outcomes 做了很多正确的事情。我们每周四在项目的教育部分会见 Outcomes，这很有用。他们查看了我的简历，和我一起做了面试准备，帮助该领域的数据科学家讲课，等等。在项目结束时，他们还促成了一场名为“学生聚焦”的招聘会，我们在会上向优步、蓝色实验室和摩根富兰克林咨询公司展示了我们的投资组合。此外，如果不是 Outcomes 指导我定期写作，我可能不会有这个博客，对于以上所述，我很感激。
然而，当我们从这个项目毕业并进入全面求职模式时，我们每周都与蔻驰的 Outcomes 公司进行电话会议。起初，我对入住感到非常兴奋。但是随着时间的推移，我想知道“这对我真的有帮助吗？”考虑到这一点，我提出两个建议，我相信如果大会实施这些建议，将会加强他们的毕业后职业规划:
- 双重责任— 要获得成果支持，你需要每周申请 10 份工作，每月参加 2 次社交活动。我们必须将此输入到谷歌文档中，以便我们的成果职业蔻驰进行审查。
Outcomes 知道我每周都在找工作。但我总是不知道在同一时间段内 Outcomes 对我有什么帮助。
Outcomes 应该使用的责任衡量标准是他们与你联系的雇主数量。简历回顾和面试准备是很好的，但是最快的方法是在一家公司认识某人。Outcomes 应该每周向学生报告这一点，就像学生应该向 Outcomes 报告他们的求职进展一样。
2。拓宽其职业论坛— General Assembly 使用 Slack 与学生交流。我们有自己的 DC-DSI Slack 团队和机会渠道。如果校友/员工正在招聘或知道有人在招聘，他们会发布帖子。这很有用，但下面是 GA 如何让它更上一层楼:
- 在全国范围内扩张——如果出现合适的职位，我愿意留在 DC，但我更愿意搬回洛杉矶。其他学生也在考虑搬到西海岸、纽约和北卡罗来纳州。大会应该为所有全球校友创建一个论坛，这样我们就可以知道所有潜在的工作机会，无论他们在哪里。
- 扩大到雇主——这个论坛也应该向在大会登记的潜在雇主开放。如果他们想发布一个机会，他们需要发布他们的姓名和电子邮件，以便候选人可以直接与他们联系。在进步社区取得成功的模式是威尔斯通工作论坛。大会应该复制这一点，而是使它成为一个只对校友、员工和雇主开放的论坛。
参加任何大会项目的学生都不应该期望一毕业就被安排在 T2 工作。你需要在求职过程中投入和程序本身一样多的血、汗和泪。但通过介绍和更好的就业论坛与雇主建立联系将是一笔巨大的财富。
强类型递归神经网络
我对深度学习原理的探索
“Newton” by William Blake.
这篇文章不代表我自己的想法，因为我很少有毫无根据的想法。这是我在寻找深度学习背后的指导原则时，对他人发表的观点进行的分析和思考。在这篇文章中，我提出了对深度学习原理的需求，然后我解释了强类型递归神经网络的范例。你可以跳过前半部分，但这能激发你展示后半部分的动力。
假设有递归神经网络的基本知识。
数学原理简史
在艾萨克·牛顿爵士出版“《哲学自然数学原理》”之前，人们以两种不同的方式对待科学——或者他们称之为自然哲学。大多数科学研究要么基于演绎原理，要么基于归纳原理。定义将有助于:
演绎法是一种在假设为真理的前提下，从观察中得出结论的方法。
只要前提为真，演绎就是真的，即演绎在我们已知的基础上解释观察结果。这就限制了演绎方法在前提不成立的情况下得出结论。
归纳法是一种通过反复实验和观察来测试新思想和理论的方法。然而，这种方法承认得出的结论可能是错误的。这种方法打开了新思想的研究领域，承认新思想也可能是错误的。
牛顿——在双方的争论中失败了——采取了一种混合的方法来研究自然现象。他首先通过仔细的实验和观察建立了公理，然后他在已经建立的数学原理的基础上，基于演绎将那些公理形式化。这种对观测数据的逐步概括产生了《数学原理》,它给了我们三个运动定律，奠定了万有引力的原理。然后他用平方反比定律从数学上解释了开普勒的椭圆轨道。
“These forces being unknown, philosophers have hitherto attempted the search of Nature in vain; but I hope the principles here laid down will afford some light either to this or some truer method of natural philosophy” — Newton, Principia Preface.
对《原理》的一个有效批评是，牛顿通过自己的数学模型解释了力的定律，但他无法解释力背后的原因。对此，牛顿回答说，他是想解释万有引力的运作，而不是解释万有引力是由什么产生的。承认自己无知，但有一种新的想法，一种看待世界的新方式。它为美国提供了观察世界的新的数学工具和模型，被许多人认为是已经出版的最伟大的科学著作。正是这些源自归纳和演绎方法的结构化原则推动了科学进步，并最终改变了世界。
我们在深度学习中缺乏这些结构化的原则，但这是一个非常新的领域。然而，以目前该领域的进展速度和所做的大量研究来看，寻找深度学习原理还为时不早。
深度学习指导原则的需求
形成深度学习主干的想法结构合理。训练过程的工作机制是很好理解的。神经元、损失函数、矩阵运算和我们部署的架构的数学定义非常明确。但是我们无法解释为什么深度神经网络(DNN)工作得如此之好。有一些模糊的想法在流传，但没有确凿的研究来支持证据。随着我们深入架构，我们开始失去每一层学习的抽象概念，因此术语“黑盒在深度学习研究的媒体报道中很突出。
然而，这并没有阻止该领域的创新。 Carlos E. Perez 在深度学习和炼金术之间进行了类比，在某种意义上，深度学习创新是炮制 DNN 架构、将它们与不同的超参数混合并应用各种成本函数的结果。他写过一篇大胆的帖子，质疑“的必要性，深度学习创新仅仅是因为蛮力吗？”。这表明，大多数研究都是基于演绎的，试图根据我们已知的理论来解释一个模型的工作原理。
凭借我仅有的一点经验，我开始意识到我们并不了解通过这些深层神经网络的信息流。我们不知道当信息通过各种神经网络架构时会发生什么。我们有一个模糊的想法，即隐藏层学习信息的简明表示，但是我们不知道有多少这样的层适合于对信息进行建模以满足我们的需求，并且我们不知道需要哪种层来对该信息进行建模。
很多次我读到一项新的研究，想知道研究人员是如何设计一个特定的模型的。什么思维过程，什么直觉，最重要的，什么数学？答案几乎总是一样的。他们依靠自己的直觉，尝试不同的架构，选择最有效的架构。这自然产生了疑问，有没有更好更简单的模型？有没有可能，也许，我们对通过这些模型的信息流还不够了解，因此我们被我们能设计的东西所限制。
这表明需要一种归纳方法来提出定义信息流数学的新思想，而一篇旨在这样做的论文就是强类型递归神经网络。
强类型递归神经网络
本文的思想来源于物理学和函数式编程。在物理学中，我们有同质性原理来约束不同类型的两个量之间的运算。例如，你不能把 27 牛顿的力加到 35 千克的质量上。
同样，本文探讨了信息也可能是不同种类的想法，并在流经深层神经网络时改变其类型。作者使用了优美的措辞:
“一个范例是物理学家从自然中雕刻出来的测量系统。它规定了表示标准化测量设备读数的单位(例如温度计的开尔文和时钟的秒)以及组合它们的规则。”
在我讨论文件的技术细节之前，我想反映一下这里表达的观点。物理学家观察了这个世界，并为热、力、压力等自然现象设计了一套测量系统。，通过归纳推理。深度思维的戴密斯·哈萨比斯认为信息和能量或物质一样是基本的存在。因此，对于研究人员来说，开拓一种新的信息测量系统，开发一种新的数学来理解通过深度神经网络的信息流是很自然的。这篇论文是朝着这个方向迈出的漂亮的一步。
他们引入强类型准线性代数来表示 DNNs 中的信息流，我用我理解的简单术语解释这些定理。
- 定理 1:一个类型(T)是一个在‘d’维中具有正交基的向量空间。
就像二维欧氏空间中的一个点由两个正交基的组合来表示(x 坐标，和 y 坐标；正交意味着 x 和 y 坐标是彼此独立的)，一个信息可以在称为“类型”的 d 维空间中表示。 - 定理 2:信息可以有多种类型，代表不同的解读。当信息流经深层神经网络的不同部分时，它的类型会发生变化。
- **定理 3:信息可以通过在特定类型中进行一元或二元运算来改变。
这些操作保留了信息的类型。
不允许两个不同类型之间的二元运算。
这类似于通过对特定二维空间中的 x 和 y 分量进行一元或二元运算来改变二维空间中的点的坐标。但是，只允许少数操作。
一元运算:{tanh，relu，sigmoid，标量乘法等。}
二元运算:{+，-，max，min}
我试图通过用一维向量空间进行类比来解释这种类型的范例:
- 定理 4: 一个型变换(T1 → T2) 是通过两个不同型之间的一个矩阵乘法来实现的。
- 定理 5:类型 T1、和类型 T2** 之间的元素乘法导致从类型 T1 到类型 T2 的直接转换。** 这与定理 4 不同，因为 T1 类型与 T2 类型的“矩阵乘法”将产生 T3 类型。但是，类型 T1 与类型 T2 的“元素乘法”将产生类型 T2。
Types of the Information changes as it passes through the Deep Neural Network. This is because of various Matrix Multiplications and Elemenwise Multiplications.
这是基于归纳的推理。这些操作模式是通过观察 rnn 的行为而制定的。他们要带着这个去哪里？
这些定理将深度神经网络分为两类。强类型(类型一致)弱类型(类型不一致)。
如果将这些约束应用于经典架构，如香草 RNNs、LSTMs 和 GRUs，似乎这些 经典网络是 弱类型 ，即它们具有由于添加两种不同类型而产生的类型不一致。让我们以 LSTMs 为例；更新公式为:
在文中，一个数学证明表明这种结构是类型不一致的，为了保持简单性，我省略了数学证明。然而我提供了一个直观的解释。考虑上述定理，输出 h[t]取决于它的前一状态 h[t-1]和输入 x[t]。所以:
- 如果我们假设 h[t-1]是 h 型的。
- 假设输入 x 是 x 类型。
- 假设加权矩阵乘以 h[t-1]和 x[t]，将它们各自的类型改变为允许它们之间二元运算的单个类型 Y。这意味着 h[t]将是 y 类型。
- 现在，h[t]和 h[t-1]表示跨不同时间步长的相同类型的信息。所以，这意味着 Y 型和 h 型是一样的，也就是说，没有类型转换发生。
- 但是，根据定理 4，矩阵乘法将导致类型转换，本质上意味着类型 Y 不能与类型 h 相同。这推翻了我们在(4)中所做的假设。因此，类型 Y 不同于类型 h，这是不一致的，因为“h”应该在所有状态中保持它的类型。
发生这种情况是因为存在递归关系，即当前状态依赖于前一状态。在经典架构中，递归关系也会导致爆炸梯度。因此，受函数式编程的启发，作者介绍了一种设计 RNN 单元的新范式。这带来了更好、更快的架构，也让我看到了电池设计的前景，我开始觉得它的方程看起来很美。
Learnware 和固件的典范
我们不能从 RNNs 中删除递归关系，因为递归定义了 RNNs。但是，我们可以把 RNN 细胞分成两个区块。一个模块进行学习，另一个模块维护递归关系。术语是 Learnware(无状态)和固件(状态相关)。
Abstraction showing the difference between RNN and T-RNN. The paradigm of Learnware and Firmware enables parallel operations, thus making computation much faster.
这个想法很简单，但是很强大。Learnware 将具有学习参数，仅取决于输入。并且固件将采用这些学习到的参数并进行依赖于状态的循环操作来保存该存储器。请注意，学习阶段和递归阶段之间的区别支持学习阶段中的并行性。这使得计算速度更快。
由于没有状态更新返回到 learnware 中，在长时间内不会有任何梯度爆炸，因为学习是在输入上发生的。这也意味着不需要对输入应用非线性来抑制它。他们在论文中用数学方法证明了这一点。基于这个范例，他们设计了一个新的 LSTM 单元块，它是强类型的。他们称之为 T-LSTMs:
看看这些方程。输入门、遗忘命运和输出门从输入数据中学习。单元状态包含必须传递给下一时间步的信息，输出取决于该单元状态和输出门。文中还有进一步的探索和推论，我就不深究了。当我获得丰富的计算资源时，我会亲自尝试这些想法。
总之，以我的理解，强类型 RNNs 的优点是:
- 强类型化信息流似乎比假设所有信息都是同类的更合理。
- Learnware 和固件之间的区别是一个定义性的设计原则，比经典设计更容易理解。它解决了分解渐变的问题，从而消除了对渐变裁剪的需要。
- 借助 Learnware 和固件的强大功能，实现并行处理。
- 由于减少了非线性，计算的复杂性已经降低，并且该论文报道强类型 lstm 比经典 lstm 快大约 1.6 倍。
- 基于元素的状态更新使架构更加稳定。
- 另一个有趣的发现是，强类型体系结构在各种任务中具有较低的训练错误。
强类型指导原则显示出比经典架构稍好的结果，然而，作者说他们没有做足够的实验。虽然后来，qrns出现了，采用了比经典 LSTMs** 快 16 倍的强类型设计的知识。因此，我的结论是，这种限制信息流的想法有些分量，需要进一步探索。**
最后，我将再次强调深度学习原理的必要性。我个人需要它来尝试不同的架构，但我缺乏资源来进行研究实验室所做的大规模实验。我的直觉告诉我，强类型深度学习不会导致人工智能，而是进一步借鉴深度学习和炼金术之间的类比；炼金术被用来实现一个雄心勃勃的目标，即找到长生不老药——就像深度学习试图解决智力问题一样——但相反，我们发现了化学。天啊，结果还不错。
我感谢David Balduzzi，帮助我理解这篇论文背后的思想。**
机器学习项目的结构和自动化工作流程—第 2 部分
H 我！我希望前一部分是有用的。今天，我们将讨论一些其他方面。我们将从预处理数据开始，并执行简单的探索性分析。然后我将向您展示如何创建自动化测试。最后，我们将训练一个模型。请记住，我将此描述为一个过程，而不仅仅是显示最终结果；)
以防你错过，第一部分是这里是。
介绍
首先，我们需要添加一些额外的包。这是今天的完整列表。
**dependencies:** - python=3.5
- numpy
- scipy
- scikit-learn
- jupyter
- requests
- pandas
- seaborn
- click
- openpyxl
- **pip:** - watermark
- pytest
对于探索，我个人更喜欢用 jupyter 笔记本。让我们在目录notebooks/00-initial-exploration.ipynb中创建一个
jupyter notebook
这个00非常重要——它指示了执行的顺序。
笔记本的第一个单元格包含:
%load_ext watermark
%watermark -v -n -m -p numpy,scipy,sklearn,pandas
这将加载水印扩展并打印关于运行平台的详细信息。这对其他人很有用，特别是当他们很难复制你的结果时。我的机器的输出:
Mon May 29 2017CPython 3.5.3
IPython 6.0.0numpy 1.12.1
scipy 0.19.0
sklearn 0.18.1
pandas 0.20.1compiler : MSC v.1900 64 bit (AMD64)
system : Windows
release : 7
machine : AMD64
processor : Intel64 Family 6 Model 69 Stepping 1, GenuineIntel
CPU cores : 4
interpreter: 64bit
探测
在下一个单元格中，我们导入所需的库并存储根目录——这非常有用。
%matplotlib inline
import pandas as pd
import numpy as np
import seaborn as sns
import os
PROJ_ROOT = os.path.abspath(os.path.join(os.pardir))
print(PROJ_ROOT)
稍后，我们想要实际加载并查看数据:
data_fname = os.path.join(PROJ_ROOT, ‘data’, ‘raw’, ‘iris.csv’)
dframe = pd.read_csv(data_fname, header=None)
dframe.head()
输出:
0 1 2 3 4
0 5.1 3.5 1.4 0.2 Iris-setosa
1 4.9 3.0 1.4 0.2 Iris-setosa
2 4.7 3.2 1.3 0.2 Iris-setosa
3 4.6 3.1 1.5 0.2 Iris-setosa
4 5.0 3.6 1.4 0.2 Iris-setosa
我们知道第 4 列包含我们想要预测的标签。由于 iris 是著名的数据集，我们也知道列【0，3】中特征的名称——它们是:萼片长度、萼片宽度、花瓣长度和花瓣宽度。但出于练习目的，让我们假设我们不知道它们，并给出通用名称:
dframe.columns = [‘x0’, ‘x1’, ‘x2’, ‘x3’, ‘y’]
dframe.head()
输出:
x0 x1 x2 x3 y
0 5.1 3.5 1.4 0.2 Iris-setosa
1 4.9 3.0 1.4 0.2 Iris-setosa
2 4.7 3.2 1.3 0.2 Iris-setosa
3 4.6 3.1 1.5 0.2 Iris-setosa
4 5.0 3.6 1.4 0.2 Iris-setosa
现在是施展魔法的时候了:
sns.pairplot(dframe, vars=[‘x0’, ‘x1’, ‘x2’, ‘x3’], hue=’y’)
哇哦。通过使用 seaborn 我们能够绘制所有变量之间的配对分布。这对于直观地检查数据非常有用。而且第一次用的时候印象深刻；)
重构
到目前为止，我们执行了两个基本步骤
- 加载和标记数据
- 外观检验
笔记本对于实验来说很棒，但是对于执行这个过程来说却很差。现在，我们将代码转移到src。此外，我们将通过两个新项目扩展我们的渠道:
- 标签-数据:添加标签(x0，…，y)并将其保存回来
- 探索性-可视化生成绘图并保存它
我们可能会争论我们是否真的需要仅仅通过添加列名来保存回数据。可能不会，但通常我们的第一轮预处理会更复杂。
在文件src/data/preprocess.py中
我们真的需要 read_raw_data 方法吗？只有一行代码。是的，我们需要。您的同事会记住非标准 csv 文件的所有参数吗？请记住，读取数据可能要复杂得多，包括 PCA 之类的东西。在preprocess_data中，我复制了一帧。这是因为我喜欢参数不可变的函数式风格。
为了避免枚举所有特征，这里有一个函数。
另外一个值得一提的是这个 excel 文件。它不会在任何地方使用，但是，我发现它非常有用，可以导出 Excel 文件，以便在需要时手动查看。但是这是完全可选的(考虑到这一点，它也使用一个可选参数)。
为了使其完整，创建包含内容的文件src/data/__init__.py:
**from** .preprocess **import** read_raw_data, read_processed_data, preprocess_data, get_label, get_featues
重构情节
绘图代码要简单得多:
src/visualization/exploratory.py
我将 matplotib 后端设置为agg，因为我发现在我的系统上使用默认的(QtAgg)会导致不正确的渲染。
我们还必须像第一部分一样创建reports/figures/.gitkeep文件。
更新 Makefile
更新依赖关系图的时间。对于绘制代码:
reports/figures/exploratory.png: data/processed/processed.pickle
python src/visualization/exploratory.py $< $@
上次我解释了<@的意思。概括地说，这是第一个先决条件(本例中为data/processed/processed.pickle)。因此，$<表示第一个目标。所以，上述规则相当于:
reports/figures/exploratory.png: data/processed/processed.pickle
python src/visualization/exploratory.py data/processed/processed.pickle reports/figures/exploratory.png
我他妈的为什么要在乎$@和$<？
你可能想知道为什么我使用这个疯狂的符号，而不是仅仅粘贴文件名两次。答案是:因为 make 可以使用泛型规则。
设想如下规律:
%.o : %.cpp
gcc $< -o $@
这将使用gcc将每个*.c文件编译成相应的*.o。我们将在后面使用这个语法。
预处理规则:
data/processed/processed.pickle: data/raw/iris.csv
python src/data/preprocess.py $< $@ --excel data/processed/processed.xlsx
清除规则:
clean:
rm -f data/raw/*.csv
rm -f data/processed/*.pickle
rm -f data/processed/*.xlsx
rm -f reports/figures/*.png
和所有:
all: data/processed/processed.pickle reports/figures/exploratory.png
现在我们可以更新笔记本了！这将为我们提供如下信息:
%load_ext watermark
%watermark -v -n -m -p numpy,scipy,sklearn,pandas
%matplotlib inline
import pandas as pd
import numpy as np
import seaborn as sns
import os
PROJ_ROOT = os.path.abspath(os.path.join(os.pardir))
print(PROJ_ROOT)
import sys
sys.path.append(os.path.join(PROJ_ROOT, ‘src’))
从src导入代码
import sys
sys.path.append(os.path.join(PROJ_ROOT, ‘src’))
from data.preprocess import read_raw_data, preprocess_data
from visualization.exploratory import exploratory_visualization
加载原始数据
data_fname = os.path.join(PROJ_ROOT, ‘data’, ‘raw’, ‘iris.csv’)
raw_data = read_raw_data(data_fname)
raw_data.head()
预处理数据
preprocessed_data = preprocess_data(raw_data)
preprocessed_data.head()
和绘图
exploratory_visualization(preprocessed_data)
重新加载模块
一切都很好，除了一件事。我改变了主意，决定在图上使用核密度估计。将exploratory.py修改为...pairplot(dframe, diag_kind=**’kde’**, vars=[**‘x0’..**后，我重新运行笔记本，没有任何反应。这是因为 jupyter 没有重新加载我的模块。要解决这个问题，请添加
%load_ext autoreload
%autoreload 2
笔记本的开头。它会导致在执行代码时重新加载模块。
测试
自动化测试可以提供很多价值。为机器学习项目设计测试是另一篇文章的主题，所以这里我将只介绍非常基础的内容。
现在，我们将只测试我们关于数据形状的假设。创建文件src/tests/test_data.py
它包含两个简单的测试。首先，检查原始数据是否具有假定的维度。第二个检查是否有 4 个特征和 1 个标签。实际测试是通过使用内置的assert语句来完成的。要运行测试会话，请在项目根目录下打开终端并键入:
pytest src
结果应该是这样的:
=========== test session starts ===========
platform linux -- Python 3.5.2, pytest-3.1.1, py-1.4.34, pluggy-0.4.0
rootdir: /home/xevaquor/code/overcome-the-chaos, inifile:
collected 2 itemssrc/tests/test_data.py ..======== 2 passed in 0.28 seconds =========
我们还应该将测试纳入我们的工作流程:
test: all
pytest src
不要忘记把它标记为。假的，因为它不创建任何文件
.PHONY: all clean test
创建模型
最后，让我们创建一个模型。它可以使用各种库来实现——sk learn、theano、xgboost 等等，所以最好有一个通用的接口。src/models/random_forest.py。
这很简单。我只想提一下保存和加载方法。它们在这里是为了提供一种方便的方法来持久化训练好的模型。每个模型应该自己定义它，因为它有很强的依赖性。
注意:我跳过模型评估。这是一个非常重要的话题，但在这里没有它的位置。
训练模型
在我们的渠道中，我们还需要模特培训。
这个很简单。只需加载预处理数据并将训练好的模型保存到一个文件中。当然，我们必须确保训练模型目录的存在。
mkdir models
touch models/.gitkeep
git add --force models/.gitkeep
并更新 Makefile
all: reports/figures/exploratory.png models/random_forest.modelclean:
rm -f data/raw/*.csv
rm -f data/processed/*.pickle
rm -f data/processed/*.xlsx
rm -f reports/figures/*.png
rm -f models/*.model...models/random_forest.model: data/processed/processed.pickle
python src/models/train_model.py $< $@
自动化测试的示例思想是检查模型是否达到合理的精确度水平。
整个依赖关系图现在看起来如下:
摘要
我们今天做了很多。在接下来的最后一部分，我将向您展示如何部署您的模型。我们将创建一个简单的 web 服务，并使用 docker 使其在线。如果你想阅读一些东西，请在评论中告诉我。
一会儿见:)
结构化深度学习
- 快的
- 不需要领域知识
- 高性能
这个博客将主要关注深度学习的一个不太广为人知的应用领域，结构化数据。
在机器学习/深度学习或任何类型的预测建模任务中，数据先于算法/方法。这就是为什么机器学习在某些任务之前需要大量的特征工程，如图像分类、NLP 和许多其他“不寻常”的数据，这些数据不能直接输入到逻辑回归或随机森林模型中。相反，这些类型的任务通过深度学习可以很好地完成，而不需要任何讨厌和耗时的功能工程。大多数情况下，这些特性需要领域知识、创造力和大量的反复试验。当然，领域专业知识和巧妙的功能工程仍然非常有价值，但我将在这篇文章中提到的技术足以让你在没有任何相关知识的情况下，在 Kaggle 比赛(http://blog . ka ggle . com/2016/01/22/rossmann-store-sales-winners-interview-3-place-cheng-GUI/)中获得前三名。
Fig 1. a cute dog and an angry cat (labeled by me)
由于特征生成的复杂性质和能力(例如 CNN 的卷积层)，深度学习被大量应用于各种图像、文本和音频数据问题。毫无疑问，这些对于人工智能的发展来说是非常重要的问题，并且一定有一个非常好的理由来解释为什么每年这个领域的顶级研究人员都要比上一年更好地对猫、狗和船进行分类。但这些很少是我们在工业上看到的情况。公司使用涉及结构化数据集的数据库，这些领域影响着日常生活。
让我们来定义结构化数据，以便在本文的其余部分更加清晰。在这里，您可以将行视为收集的单个数据点或观察值，将列视为表示每个观察值的单个属性的字段。例如，来自在线零售店的数据可能包含客户销售的行和购买的商品、数量、价格、时间戳等列。
下面我们有在线卖家数据，行是每个独特的销售，列描述了特定的销售。
Fig 2. pandas dataframe an example to structured data
让我们谈谈如何利用神经网络来完成结构化数据任务。实际上，在理论层面上，创建一个具有任何所需架构的全连接网络，然后使用“行”作为输入是非常简单的。在几次点积和反向传播之后，给定损失函数，我们将最终得到一个训练好的网络，然后可以用来进行预测。
尽管这看起来非常简单，但当涉及到结构化数据时，人们更喜欢基于树的方法而不是神经网络是有主要原因的。这可以从算法的角度来理解，通过探索算法实际上是如何看待和处理我们的数据的。
结构化数据和非结构化数据的主要区别在于，对于非结构化数据，即使它“不常见”，我们也经常用单个单元处理单个实体，如像素、体素、音频、雷达反向散射、传感器测量值等等。相反，对于结构化数据，我们经常需要处理两个主要组下的许多不同类型的数据；数字和分类。分类数据需要在训练之前进行处理，因为大多数算法和神经网络还不能直接处理它们。
有各种选项可用于编码变量，如标签/数字编码和一键编码。但是这些技术在记忆和分类级别的真实表示方面是有问题的。前一个属性可能更明显，可以用一个例子来说明。
假设我们将星期几信息作为一列。如果我们对这个变量进行一次性编码或任意标记编码，我们将分别假设等级之间的距离/差异相等且任意。
Fig 3. one-hot encoding and label encoding
但是这两种方法都假设每一对日子之间的差异是相等的，但是实际上我们很容易知道这不是真的，我们的算法也应该如此！
“神经网络的连续性限制了它们对分类变量的适用性。因此，天真地将
神经网络应用于用整数
表示类别变量的结构化数据并不奏效”[1]
树算法不需要对分类变量的连续性的任何假设，因为它们可以根据需要通过分裂来找到状态，但是对于神经网络来说，情况并非如此。实体嵌入来帮忙了。实体嵌入用于将离散值映射到多维空间，其中具有相似函数输出的值彼此更接近。您可能会想到，如果我们在一个国家中嵌入州来解决销售问题，在这个投影空间中，销售方面的类似州会更加接近。
因为我们不想在我们的分类变量的层次之间做任意的假设，我们将在欧几里得空间中学习每一个的更好的表示。该表示将等于独热编码数据和可学习权重的点积。
嵌入在 NLP 中被广泛使用，因为每个单词都被表示为一个向量。两个著名的嵌入例子是 Glove 和 word2vec 。我们可以从图 4 [2]中看到嵌入是多么强大。你可以下载这些向量，并根据你的目标使用它们，这实际上是非常酷的想法。
Fig 4. Word2Vec from tensorflow tutorials
即使嵌入可以以监督或无监督的方式应用于不同的上下文，我们的主要目标是理解如何对分类变量进行这些投影。
实体嵌入
即使实体嵌入有不同的名称，它们与我们在单词嵌入中看到的用例没有太大的不同。毕竟，我们唯一关心的是对我们的分组数据有更高维的向量表示；这可能是单词、星期几、国家和许多你能想象的其他东西。这种从单词嵌入到元(在我们的例子中是分类)数据嵌入的交易使 Yoshua Bengio 等人在 2015 年凭借一种简单的自动化方法赢得了 Kaggle 竞赛(https://www . ka ggle . com/c/pkdd-15-predict-taxi-service-trajectory-I)，这不是获胜解决方案的常见情况。
“为了处理由客户 ID、出租车 ID、日期和时间信息组成的离散元数据，我们通过模型共同学习这些信息的嵌入。这是受神经语言建模方法[2]的启发，其中每个单词都映射到一个固定大小的向量空间(该向量称为单词的嵌入)。”[3]
Fig 5. Taxi Metadata embeddings visualization with t-SNE 2D projections
我们将逐步探索如何在神经网络中学习这些特征。定义一个完全连接的神经网络，分离数值和分类变量。
对于每个分类变量:
- 初始化一个随机嵌入矩阵为 m×d。
m: 分类变量的唯一级别数(星期一，星期二，…)
D: 表示所需的维度，一个可以在 1 和 m-1 之间的超参数(如果为 1，则为标签编码，如果为 m，则为一键编码)
Fig 6. Embedding Matrix
2.然后，对于通过神经网络的每次前向传递，我们从嵌入矩阵中查找给定的级别(例如“dow”的星期一)，这将给我们一个向量 1 x D。
Fig 7, Embedding Vector after lookup
3.将这个 1 x D 向量附加到我们的输入向量(数值向量)上。把这个过程想象成扩充一个矩阵，我们为每个类别添加一个嵌入向量，通过查找每个特定的行来嵌入。
Fig 8. After adding embedding vectors
4.在进行反向传播的同时，我们也以梯度的方式更新这些嵌入向量，这最小化了我们的损失函数。
通常输入不会更新，但是对于嵌入矩阵，我们有一个特例，我们允许我们的梯度一路流回这些映射的特征，从而优化它们。
我们可以认为这是一个过程，它允许我们的分类嵌入在每次迭代中得到更好的表现。
注意:经验法则是保留基数不太高的类别。就像如果一个变量在 90%的观察中有独特的水平，那么它就不是一个非常有预测性的变量，我们很可能会把它去掉。
好消息
我们可以在我们最喜欢的框架(最好是一个动态框架)中很好地实现上述架构，方法是通过查找并在嵌入向量中允许 requires_grad=True 并学习它们。但所有这些步骤和更多步骤都已经在 Fast.ai 中完成了。除了简化结构化深度学习，这个库还提供了许多最先进的功能，如差异学习率、SGDR、循环学习率、学习率查找器等。这些都是我们想要利用的东西。你可以从这些非常酷的博客文章中进一步了解这些话题:
https://medium . com/@ bushaev/improving-the-way-we-work-with-learning-rate-5e 99554 f163 b
学习率(LR)是需要调整的最重要的超参数之一，是更快、更有效地学习的关键
传送进来](http://teleported.in/posts/cyclic-learning-rate/)
用 Fast.ai 走一遍
在这一部分中，我们将看看如何绕过上述所有步骤，建立一个对结构化数据更有效的神经网络。
为此，我们来看看一场活跃的 Kaggle 竞赛https://www . ka ggle . com/c/mercari-price-suggestion-challenge/。在这个挑战中，我们试图预测一个在线卖家出售的物品的价格。这是一个非常适合实体嵌入的例子，因为数据大多是相对较高基数(不太多)的分类数据，没有太多其他数据。
数据:
大约 140 万行
- item_condition_id :项目的条件(基数:5)
- 类别名称:类别名称(基数:1287)
- 品牌名称:品牌名称(基数:4809)
- 运费:运费是否包含在价格中(基数 2)
重要提示:在本例中，我不会使用验证集，因为我已经找到了最佳模型参数，但是您应该始终使用验证集进行超参数调整。
第一步:
将缺失值填充为一个级别，因为缺失本身就是一个重要的信息。
train.category_name = train.category_name.fillna('missing').astype('category')
train.brand_name = train.brand_name.fillna('missing').astype('category')
train.item_condition_id = train.item_condition_id.astype('category')test.category_name = test.category_name.fillna('missing').astype('category')
test.brand_name = test.brand_name.fillna('missing').astype('category')
test.item_condition_id = test.item_condition_id.astype('category')
第二步:
预处理数据，对数字列进行缩放，因为神经网络喜欢标准化数据，或者换句话说，喜欢同等缩放的数据。如果不缩放数据，网络可能会过分强调某个特征，因为它完全是关于点积和梯度的。如果我们通过训练统计来扩展训练和测试，那会更好，但是这不会有太大影响。想想每个像素除以 255，同样的逻辑。
我结合了训练和测试数据，因为我们希望相同级别有相同的编码。
combined_x, combined_y, nas, _ = proc_df(combined, 'price', do_scale=True)
第三步:
创建模型数据对象。Path 是 Fast.ai 存储模型和激活的地方。
path = '../data/'
md = ColumnarModelData.from_data_frame(path, test_idx, combined_x, combined_y, cat_flds=cats, bs= 128
第四步:
决定 D(嵌入的维数)。cat_sz 是每个分类列的元组列表(col_name，cardinality + 1)。
# We said that D (dimension of embedding) is an hyperparameter
# But here is Jeremy Howard's rule of thumb
emb_szs = [(c, min(50, (c+1)//2)) for _,c in cat_sz]# [(6, 3), (1312, 50), (5291, 50), (3, 2)]
第五步:
创建一个学习者，这是 Fast.ai 库的核心对象。
# params: embedding sizes, number of numerical cols, embedding dropout, output, layer sizes, layer dropouts
m = md.get_learner(emb_szs, len(combined_x.columns)-len(cats),
0.04, 1, [1000,500], [0.001,0.01], y_range=y_range)
第六步:
这一部分在我之前提到的其他帖子中有更详细的解释。
充分利用 Fast.ai joy。
我们选择的学习速度是从损失开始增加之前的某个点开始的…
# find best lr
m.lr_find()# find best lr
m.sched.plot()
Fig 9. learning rate loss plot
合适的
we can see that with just 3 epochs we have
lr = 0.0001
m.fit(lr, 3, metrics=[lrmse])
更适合
m.fit(lr, 3, metrics=[lrmse], cycle_len=1)
还有一些…
m.fit(lr, 2, metrics=[lrmse], cycle_len=1)
所以，这些简单而有效的步骤可以让你在几分钟内达到 10%,而不需要任何进一步的努力。如果你真的想力争上游，我建议你利用 item_description 列，使它成为多个分类变量。然后把工作留给实体嵌入，当然不要忘记栈和系综:)
这是我的第一篇博文，希望你喜欢！我必须承认这东西有点上瘾，所以我可能会很快回来…
感谢你为我鼓掌:)
我现在是 USF 的一名研究生，攻读分析硕士学位。我已经应用机器学习 3 年了，目前正在用 Fast.ai 练习深度学习。
领英:https://www.linkedin.com/in/kerem-turgutlu-12906b65/en
参考文献:
[1]郭城，菲利克斯·伯克哈恩(2016 年 4 月 22 日)分类变量的实体嵌入。从 https://arxiv.org/abs/1604.06737 的T2 取回。
[2] TensorFlow 教程:【https://www.tensorflow.org/tutorials/word2vec
【3】yo shua beng io 等人工神经网络应用于出租车目的地预测。检索自https://arxiv.org/pdf/1508.00021.pdf。
构建 ML 项目，使其能够成长
我从事过许多大大小小的数据科学和机器学习项目。从只需要几个笔记本的项目到成长为数万行代码的项目。
我发现，开始一个项目时，假设它会增长，这总是一件好事。
只需要在开始时付出少量额外的努力，就能够保持长期的生产力。
使用 git 管理代码是必须的。管理数据的方法也是必须的，但是什么是最好的方法还没有定论。
在这里，我将展示一个我最近开源的名为 lazydata 的库，它是专门为不断增长的 ML 项目管理数据而构建的。
传统的数据管理方式
如果您正在进行一个机器学习项目，您将不可避免地使用各种版本的数据集(原始的、以各种方式处理的、训练/开发分割的、增强的)，并将尝试不同的模型(基线、不同的参数、架构、算法)。
你还需要将这些内容从你的本地电脑转移到云端，并与你的队友和未来的自己分享。
要管理这种激增的数据和模型文件，传统上有两种选择:手动文件管理和存储它得到的一切。
下表总结了不同的方法及其最大的风险。
Comparison of data management approaches
懒散的数据方式
lazydata 的核心概念是，嗯，懒惰。假设随着项目的发展，你将会产生大量的文件，而你只需要其中的一小部分。
能够回到你几个月前生产的那个模型总是好的。
但是，这并不意味着每个想要查看您的项目的人都需要下载整个历史，他们很可能只想要一小部分。
启用 lazydata 只需几行代码
那么如何使用 lazydata 呢？首先，安装它(这需要 Python 3.5+):
$ pip install lazydata
然后转到您的项目根目录并键入:
$ lazydata init
这将创建一个新的文件lazydata.yml，其中将包含您的跟踪数据文件的列表。
接下来，您可以在代码中使用 lazydata 来跟踪数据文件:
**# my_script.py****from lazydata import track**
import pandas as pddf = pd.read_csv(**track("data/my_big_table.csv")**)print("Data shape:" + df.shape)
当您第一次运行这个脚本时，lazydata 将开始跟踪您的文件。
跟踪包括:
- 在
~/.lazydata中创建文件的副本——这是您的本地缓存，保存您的文件版本，以便您可以在需要时返回并将其推送到云。 - 将数据文件的唯一引用(SHA256)添加到
lazydata.yml。您将这个 yml 文件添加到 git 中，以跟踪您在这个特定提交中拥有的数据文件。这使您能够在以后需要时进行取证，并像跟踪代码一样跟踪您的数据文件。
你完了！如果您更改了数据文件，将会记录一个新的版本，您可以像往常一样继续工作。
若要与您的队友共享您的数据文件，或者只是备份数据文件，请将遥控器添加到您的项目并推送您的文件:
$ lazydata add-remote s3://mybucket
$ lazydata push
一旦你的队友下载了最新的代码，他们也会得到lazydata.yml文件。然后，他们可以使用您设置的 S3 遥控器和 SHA256 唯一引用通过lazydata pull提取文件。
或者，他们可以简单地运行您的脚本来延迟下载丢失的文件:
$ python my_script.py
## lazydata: Downloading tracked file my_big_table.csv ...
## Data shape: (10000,100)
就是这样！现在，您可以将您的 S3 视为所有数据文件的永久存档，而不必担心您的合作者将不得不下载他们不需要的任何文件。
在上面的例子中，我们将 lazydata 应用于数据输入，但是您也可以在数据输出上使用track()，例如在您刚刚保存的模型权重文件上——它以完全相同的方式工作。
这种惰性语义使您能够两全其美:存储所有内容，同时随着项目的增长，保持对数据文件的管理和组织。
要了解更多关于库的信息，请访问 GitHub 页面:
lazy data:Python 项目的可伸缩数据依赖——rstojnic/lazy data
github.com](https://github.com/rstojnic/lazydata)
构建你的机器学习项目的 22 个智慧金块
完成一个机器学习项目很难。这个总结可以帮助你构建你的机器学习项目。
他的帖子研究了 Coursera 深度学习专业化的第三个课程。它给出了关键概念的图形概述，并用一句话概括了每堂课。
为什么是这个总结？我确信所学到的经验教训对所有机器学习从业者都是有帮助的。在阅读完讲座后，我相信读者会从紧凑的讲座摘要和对材料的概述中受益。如果这个帖子激发了你的好奇心，请鼓励注册并亲自探索这个课程。
所以，事不宜迟，让我们进入知识的世界吧。
快速迭代
在其核心，每个机器学习项目都是关于有一个想法，实施，然后评估它。你越早重复这些步骤，你就能越早达到你的目标。这种结构与 Eric Ries 的精益创业精神产生了共鸣，即“建立、衡量和学习”，这在全世界的创业公司、组织和企业中非常流行。
The tools to iterate quickly over new ML ideas
在这个过程的每一点上，你都必须做出重要的决定。你应该收集更多的数据吗？你应该减少偏差或方差吗？你应该如何比较不同的算法？该课程提供了选择最有效的前进步骤的建议。上图总结了这个关键概念，以及对每个迭代步骤的建议。
接下来，您可以在第三个 Coursera 深度学习专业化课程中找到每个讲座视频的一句话摘要。瞧，你的 22 条智慧。
讲座摘要
- 为什么选择 ML 策略——机器学习策略对于快速迭代想法和高效达成项目结果非常有用。
- 正交化-指的是挑选参数进行调整的概念，这些参数仅调整机器学习模型的一个结果，例如，正则化是减少方差的旋钮。
- 单个数字评估指标—选择一个评估指标，例如 f1 分数，立即判断多个模型的性能。
- 满足和优化指标-机器学习模型通常有一个要优化的指标，例如实现最大的准确性，以及应该保持的某些约束，例如在不到 1 秒的时间内计算预测或将模型放入本地内存。在这种情况下，准确性是优化指标，预测时间和内存使用是令人满意的指标。
- 培训/开发/测试集分布——确保开发和测试集来自同一个分布，并且它们准确地代表团队试图优化的目标。
- 开发和测试集的大小——考虑到您的训练集以百万计，对训练集使用尽可能多的数据，对开发和测试集使用 1%/1%的数据。
- 何时改变开发/测试集和度量——如果您发现您的评估度量的等级不再准确地反映您的模型的性能，请考虑重新陈述优化度量，例如，通过添加加权项来严重惩罚您的分类器对真正重要的示例的错误分类。
- 为什么是人类水平的性能？—贝叶斯误差是分类器可以实现的最佳性能，根据定义，它优于人类水平的性能。贝叶斯和人为误差是评估训练数据是否存在偏差的重要指标。
- 可避免的偏差——描述训练集错误和人类水平的表现之间的差距。
- 了解人的水平性能-如果一组专家能够达到 0.7%的错误率，而一个人达到 1%的错误率，则选择 0.7%作为最佳人的水平性能，选择< 0.7%的值作为贝叶斯误差来测试模型性能。
- 超越人类水平的性能-如果你的算法超越人类水平的性能，那么判断可避免的偏差就变得非常困难，因为你通常不知道贝叶斯误差有多小。
- 提高模型性能-评估贝叶斯误差和训练集误差之间的差异，以估计可避免的偏差水平。通过比较训练和偏差设定误差来估计方差。尝试不同的技巧来对抗任何形式的错误。
- 进行错误分析——分析 100 个错误分类的例子，并根据错误分类的原因对它们进行分组。为了改进您的模型，训练您的网络来消除它错误分类某一类型输入的原因可能是有意义的，例如，向它提供更多模糊的图片。
- 清理错误标记的数据——神经网络在处理随机错误分类方面相当稳定，如果您消除了开发集中的错误分类，也消除了测试集中的错误分类。
- 快速构建你的第一个系统，然后迭代——快速原型化第一个版本的分类器，然后按照战略方针迭代改进它。
- 在不同的发行版上进行训练和测试-如果训练集中的数据来自混合数据源，请使用您想要优化的数据创建开发和测试集，例如，如果您想要对手机中的运动鞋图像进行分类，请使用仅包含手机中的运动鞋照片的开发和测试集，但可以随意使用增强的运动鞋 web 图像来训练网络。
- 数据不匹配的偏差和差异—当您的开发和测试集来自不同的数据分布时，创建一个与训练集具有相同数据分布的训练开发集。这一步有助于您检查是否存在方差、偏差或数据不匹配问题。
- 解决数据不匹配的问题——如果您有数据不匹配的问题，请执行手动错误分析，并了解训练集和开发/测试集之间的差异。请注意创建人工训练数据，因为可能会出现这样的情况:您只合成了所有可用噪声的一小部分。
- 迁移学习-如果您有另一个分类器可以受益的较低级别的特征，请使用迁移学习，并切断现有神经网络的最后一层，然后针对新任务训练网络。
- 多任务学习-使用单个神经网络来检测图像中的多个类别，例如自动驾驶汽车的交通灯和行人。同样，当神经网络识别对多种分类任务有帮助的较低级别的特征时，并且如果您具有平均分布的类数据，这也是有用的。
- 什么是端到端深度学习——不是使用许多不同的步骤和手动特征工程来生成预测，而是使用一个神经网络来找出底层模式。
- 是否使用端到端深度学习——端到端深度学习有一些优势，比如让网络自己找出重要的特征，也有一些劣势，比如需要大量的数据，所以它的使用真的必须根据你正在解决的任务或功能的复杂程度来逐个判断。
感谢你阅读这篇文章，我希望它能帮助你回顾你的课程经历。所有功劳属于 deeplearning.ai ，Coursera 和吴恩达。如果我错过了一个重要的话题，请随时在下面的评论区添加。
如果你对 Coursera 深度学习专业化和机器学习的更多更新感兴趣，请查看我之前的两篇 帖子，在 medium 上关注我，如果你有任何其他问题，请随时在 LinkedIn 上给我发消息。
斯图尔特·威茨曼靴子、名牌包和带面具的套装
我最近和一些人聊天，讨论如何为深度学习管道建立多阶段模型。具体的问题是如何将图像中的对象与已知的对象数据库进行相似性比较，以便进行匹配。这个问题与吴恩达在深度学习课程中为面部识别铺设的管道非常相似。他的方法是有两个模型，第一阶段和第二阶段。第一阶段可以是对象检测模型以定位到图像中的面部，然后第二阶段模型可以基于定位的面部进行面部相似性比较。分两个阶段构建管道是有用的，因为它让第二阶段模型处理更少的任意噪声，因此它可以专注于与您关心的任何对象进行比较。
在我的第一篇媒体文章中，我讲述了我是如何为游戏《彩虹六号围攻》构建一个面部识别管道的。然而在这篇文章中，我想建立一个多类图像分割模型，作为第一阶段模型的例子。我的理由是，有时检测对象的边界框是好的，但是在逐像素级别分割图像应该给第二阶段提供更清晰的输入，因为第二阶段模型将很少或没有背景需要处理。
正如标题所暗示的，这篇文章的主题是一个多类图像分割模型，我定制了这个模型来检测衣服。
除了作为引子的对话，我认为这将是一个很好的练习，因为很难找到关于如何做多类图像分割项目的教程。对于这个项目，我将使用 Matterport 的 Mask R-CNN，这是 Mask R-CNN 的 Keras 实现，它执行得很好。将来用原始的 Tensorflow 实现来做可能也不错，但我想尽快完成这个原型。(我说的快速是指我决定在周六晚上 10 点做这件事，收集数据，对其进行注释，并在凌晨 4 点之前对其进行训练，上床睡觉，然后第二天写这篇博客 XD)
掩模 R-CNN 的简要背景
对于许多任务来说，重要的是不仅要知道存在对象以及它在图像中的位置(对象检测)，而且要知道给定图像中的哪些像素对应于该对象(图像分割)。掩模 R-CNN 是对先前的对象检测架构 R-CNN 和更快的 R-CNN 的修改，以服务于此目的。执行图像分割的能力是通过在现有网络架构上添加一个完全卷积的网络分支来实现的。因此，当主分支生成边界框并识别对象的类别时，从主分支获得特征的完全卷积分支生成图像遮罩。
我看到的另一个帖子是来自( here )的，其中我学到了很多关于掩模 R-CNN 和图像分割的知识。最后，如果你真的想看，你可以看看原版的 R-CNN 报道，它值得一读(这里)。
采集数据并标注
虽然我选择了帖子的主题，但我对设计师品牌的衣服了解相对较少。然而，我的一个好朋友喜欢斯图尔特·威茨曼的靴子，所以我想我可以用它来帮助缩小这个项目的图像范围。我在谷歌上做了一些快速搜索，调出了相关图片，收集了大约 130 张模特的图片，其中大部分都穿着斯图尔特·威茨曼的靴子，但我想说，这个数据集是关于那些看起来相当时尚的人的。
对于我的注释，我使用了 VGG 图像注释器，这是一个很好的接口，用于牛津大学的对象检测或图像分割注释。
screenshot of the VGG annotator
对我来说，这里的主要变化是通过使用注释器中的区域属性来确保每个多边形区域都标记有一个类名。我添加了一个名为“name”的字段，稍后我可以在输出 JSON 文件中引用它，这样模型就会知道每个多边形区域的底层类。
在我的三节课中，我使用了靴子(包括鞋子和凉鞋，如下图所示)，包(大多数是不同尺寸的手提包，也有购物袋和一两个背包)，最后，我最麻烦的类别是“顶级”。我最初打算做大便，外套，裤子等。但是那会大大增加这个注释过程，所以我把其中的大部分压缩到一个“顶级”类别，决定不注释裤子。如果我决定建立一个更强大的模型，所有这些都可以调整。
When I remembered that I had included this picture I immediately regretted it because of the amount of annotation. It also shows how my class system is probably not ideal… I have to label a one piece outfit as a “top” but don’t include jeans/pants so the system seems a bit convoluted…
使用 VGG 注释器，我生成了 json 文件，其中包含了模型的所有多边形分割区域以及多边形的相关名称。
代码和培训的修改
这部分实际上对我来说很好，因为它迫使我挖掘 Matterport 代码来尝试并找出如何修改它来实现多类分段。
查看我的 fashion.py 文件中的所有代码，我在这里只展示一些片段。
第一次修改发生在第 46 行。
NUM_CLASSES = 1 + 3 # Background + bag +top +boots
而不是基本的:
NUM_CLASSES = 1 + 1 # Background + single_class
在 load_balloon 函数中的第 70 行(在后面我应该修改了这些函数名，因为它们不是描述性的)
self.add_class("fashion", 1, "top") #adjusted here
self.add_class("fashion", 2, "boots") #adjusted here
self.add_class("fashion", 3, "bag") #adjusted here
我查看了为 coco 数据集生成后端数据集的方式，发现所需的信息是数据集/模型名称，在本例中为“时尚”,然后添加了类别号和相关联的标签映射供模型使用。
因此，现在数据集和模型在物理上能够接受多个类，我必须确保在加载图像时记录类信息。
为此，我插入了几行代码(94–102)来为给定的图像生成到区域多边形的标签映射。
class_names_str = [r['region_attributes']['name'] for r in a['regions'].values()]
class_name_nums = []
for i in class_names_str:
if i == 'top':
class_name_nums.append(1)
if i == 'boots':
class_name_nums.append(2)
if i == 'bag':
class_name_nums.append(3)
这个部分只是从 json 文件的 region_attributes 部分获取给定图像的区域名称，然后遍历它以创建一个输出列表，该列表将字符串转换为与上面的类标签映射相匹配的数字 1、2 和 3。
接下来在第 119 行，我在 add_image 调用中添加了一个新字段，这样我就可以存储给定图像的类列表，然后在脚本稍后生成掩码时提取该列表。
class_list = np.array(class_name_nums)
对我来说，最有趣的部分是认识到 load_mask 函数通过生成一个全 1 的 numpy 数组来处理类标记，其思想是它只是进行单个类分类，这在大多数自定义数据集训练中是常见的。所以我在这里要做的就是引用我附加到 load_mask 函数引用的图像上的 class_lists(第 143 行)。
在这种情况下，return 函数返回一组表示该图像中要分割的 N 个多边形的图像遮罩，加上我的添加，它现在返回一个长度也为 N 的多边形类的数值数组。
class_array = info['class_list']
return mask.astype(np.bool), class_array
一旦这些细节得到解决，我就能够使用 coco challenge 的预训练权重来训练 Mask R-CNN 模型。我让模型在 Nvidia 1080 GPU 上训练了 20 个时期，在那里它调整了图像的大小，使长边为 1024 像素，我通过 GPU 一次输入 2 幅图像，但没有对我可以处理多少图像进行大量实验。
关于建立更强模型的当前结果和想法
鉴于我使用的数据集只有 100 张训练图像，另外还有 20-30 张用于评估，结果实际上相当不错。鉴于这是一个比我在使用 Mask R-CNN 之前完成的单个类自定义分段任务更难的任务，我感到惊喜。
Shows original and the predicted image masks
显然还有很大的提升空间。该模型在外套和服装的边缘等领域仍不确定。很大程度上可能是因为我不一致的标签/在如何处理不是靴子和包的衣服项目上糟糕的职业选择。
如果我要改进这个快速原型，有两个方面需要下大力气。首先是定义我们到底想用这个模型做什么。例如，如果第二阶段模型/多个第一阶段模型能够辨别不同类型的服装，则第一阶段模型实际上可能不需要辨别这些服装。这意味着你可以使用一个单一的分类模型，用一个普通的类别“衣服”或者类似的东西。如果我们反其道而行之，增加更多的粒度，那么从长远来看，这将只需要经过深思熟虑的类。这将意味着我们必须弄清楚如何处理不同的事情，比如一个人穿着外套和衬衫，即使我们只有衬衫的一部分，我们也要给外套和衬衫贴标签吗？还是大多被高筒靴遮挡的裤子？这些都是需要根据手头的任务/问题进行检查的领域。
第二个需要改进的地方是收集更多的图像。这个模型只训练了 100 张图像，模型有很多不确定性，例如它不总是包括外套或其他衣服的边缘。这看起来像是不包括他们的模型，因为鉴于其有限的暴露，它仍然是不确定的。这部分性能应该有所提高。
还没完！提取衣物
正如我在开始时所说的，目标不仅仅是分割图像中的服装，而是将其用作第一阶段的模型，以帮助减少后续模型用作输入的噪声。
Mask R-CNN 模型的输出是具有许多不同数据字段的结果数组。
我发现对此有用的是“ROI ”,它包含对象的边界框坐标，“masks”是每个预测遮罩的二进制数组。
因此，要分离出这些衣服，我所要做的就是使用二进制图像蒙版只显示特定的衣服，然后使用“roi”字段中的边界框来裁剪图像，只显示特定的衣服。结果是一个相当接近的裁剪图像，而不是原来的嘈杂的衣服！我参考了 Brad Sliz 2017 年的一篇帖子,从中获得了如何隔离面具的灵感。
请参见下面的输入阶段:
首先是原图。
接下来生成分段掩码。该模型标识了一个“top”、一个“bag”和两个“boots”类的实例。
predicted image segmentation and classifications
最后，通过使用分割多边形作为遮罩，我们可以隔离衣服。本质上，掩模通过将 RGB 阵列的 3 个维度中的每一个乘以二进制图像掩模来工作。这意味着不在蒙版中的所有区域变为 0，蒙版中的区域保持不变。这是它的原始输出…但是我不喜欢黑色背景。
我很快地拼凑了一些代码，只是将数组中值为 0 的纯黑色替换为值为 255 的白色。然而，这也扰乱了黑色衣服的其他部分的颜色…所以它不太理想，但为了演示的目的，我会调整它。
Brute force changing values of 0 to 255 causes odd outlines and such.
所以现在我们可以生成这些裁剪过的图像，这些图像只分离出衣服，你可以用它来做很多事情！例如，您可以查看在线商店中与用户提交的照片最匹配的商品，或者使用经过清理的图像为一件衣服生成标签，使其可被搜索。这两种方法的想法都是，第二级模型需要处理的输入噪声更少，因此会更好。
如果你去建立一个相似性模型，它没有首先将输入本地化，那么你可以让两个模特穿着相同的上衣，但是如果他们的肤色不同，那么相似性模型将需要能够解释额外的变化。相反，如果你使用像这样的分割模型作为第一阶段，那么模型的肤色并不重要，因为你现在只需要比较上衣。
最终想法
这个快速项目是一个例子，说明如何建立一个自定义的多类图像分割模型，然后展示如何使用该模型来帮助其他模型做得更好。如上所述，我认为根据使用情况，这种类型的模型可以在广泛的情况下有所帮助，在这些情况下，能够定位到图像中的特定对象/区域而不是通过网络提供原始图像通常是有用的。
我也很高兴，因为我以前没有训练过多类分割网络。主要是因为我使用了大多数对象检测/分割模型来为第二阶段网络清理数据，而不是训练它们在粒度级别上进行分类。部分原因是重新训练第二阶段模型并使第一阶段模型保持良好和灵活更容易。例如，一家公司建造了一个人工智能迎宾器，并使用对象检测模型来识别走进大厅的员工，并为他们开门。这在技术上是可行的。但从长远来看，这是不方便的，因为每次你为公司增加新员工(或有人离开)时，你都必须重新培训检测机。但更容易的是让检测器保持一般化，只做面部，在后端，你可以建立一个第二阶段的网络，像一个暹罗网络，它擅长区分人，从第一阶段的对象检测器中提取特征，并将其与你的员工进行匹配。这也解决了如何增加或减少雇员的问题，因为您只需要对您维护的雇员数据集进行适当的修改。
github repo 哪里有培训和测评代码
Scikit-Learn 上决策树和集成的研究
现在科技界最热门的话题之一是机器学习领域。应用范围包括算法金融、图像识别、基因组测序和物联网的最新发展。
考虑到这一点，监督学习算法的一个常见分支包括决策树，以及它们的集成(随机森林和梯度提升树)。在下面的链接中，我分析了 Python 在 Kaggle 的 Titanic 数据集上对这些分类器的 scikit-learn 实现。
链接:https://www . ka ggle . com/creepykoala/titanic/study-of-tree-and-forest-algorithms/notebook
愚蠢的张量流技巧
对一个老(汤姆逊)问题的新看法
谷歌的机器智能库 TensorFlow (TF)，已经成为深度学习的代名词。尽管名字如此，深度学习只涉及几件简单的事情，复杂性来自于将这些简单的事情重复数百万次(具体来说，它是数百万个初等函数的组合)。要“解决”TF 中的一个问题，你需要找到某个函数的最小值。难的是 反推 需要这个庞大函数的导数。这是 TF 的优势所在，因为它消除了算法微分的苦差事，并自动将计算转移到 GPU。这可以让你做出惊人的事情，比如写莎士比亚或者画猫。然而在实践中，该框架可以解决任何可微最小化问题。我想看看我能把这个想法推进到什么程度。
Electrostatic charge configuration for N=625 in equilibrium. Global minima? Probably not.
汤姆逊问题是一个经典的物理学问题，“单位球面上的 N 个正电荷的什么构型使能量最小？”。每对电荷的势能是 1/r ，所以我们试图最小化的函数是所有电荷的成对总和。
看起来很简单，对吧？对于 N 的低值，是。 N=2 将两个电荷放置在球体的两极对立处， N=3 将三个电荷放置在赤道上的同心环中， N=4 给出一个四面体。较大的 N 值，尤其是当 N 为质数时，打破这些好看的几何描述。 N=11 将电荷置于完全打破对称性的配置中——当电荷处于平衡状态时，它们的分布方式是一边比另一边多；它有净偶极矩！
在 TF 中解决这个问题出奇的容易。我们将输入变量设置为在单位球面上进行归一化，计算对称距离矩阵，并提取所有唯一的成对距离。势能是所有这些 1/r 距离的总和，所以我们用它作为目标函数。
运行模型和保存配置需要更多的工作。该项目的细节存储在这个 github repo 中。
我们的模型效果如何？对于 N 的任何值，我们可以在几秒钟内收敛到稳定的解能量最小值，并且我们可以通过降低学习速率在几分钟内将其改进到完全浮点精度。随着 N 变大，我们发现越来越多的解是稳定的(梯度为零)，但不是全局最小值。我们可以将这些解决方案与发布在维基百科上的解决方案进行比较，维基百科列出了 470 种配置。对于 N 的低值，找到的第一个解是已知的最佳解。大约在 N > 30，这一过程会变慢，并且需要更长的时间才能找到已知解。这些“几乎”解在能量上非常接近全局解，但成为未经加工的钻石——这是一种罕见的特殊配置，使其区别于无数其他解决方案。
TensorFlow 在 GPU 上的计算在这里表现令人钦佩。使用大值 N=2000，我的GTX-980 G PU 每秒计算 38 次迭代而我可怜的 8 核 CPU 每秒只能计算 3.6 次迭代。这是令人印象深刻的 10 倍加速！
Minimal energy for N=100 charges, prettified.
即使我们知道这可能不是整体的最小值，视觉化的组态也能说明规则性和明显的对称性。在 python 绘图库 matplotlib 中这样做，真的是把它推到了绝对的极限！虽然 3D 可视化不是我的强项，但我发现你可以通过以正弦和余弦控制的速率旋转相机角度来获得不错的结果。
对我来说，这是一个有趣的项目；这是一个清晰而简单的过程，通过有形的回报可以获得新的知识。这就是低垂的果实的缩影。有多少其他简单的项目可以用算法差异和 GPU 加速来加速？
我们还可以用 TensorFlow 做什么？
留下评论或链接到其他一些愚蠢的 TensorFlow 技巧。
风格分析:中本聪
摘要:
N 自然语言处理工具被应用于中本聪的比特币纸张，将其与众多加密货币相关的纸张进行比较，试图识别未知的中本聪的真实身份。论文分为两个部分；第一部分是对所生成的语言特征和语料库中每个文档的 n 元语法的风格计量分析，该语料库由中本聪研究所列出的相关文献组成，并使用语言特征的机器学习模型来预测中本聪的比特币论文和他的个人电子邮件文本上的一个/多个作者。第二部分是语义相似度分析，使用 spaCy 和 gensim 中的内置函数，根据语义相似度比较语料库中每个文档的内容。这两部分的结果表明语料库中哪些作者在语言和语义上与中本聪相似。
1 个问题陈述
B 对于那些对当前货币体系持怀疑态度的人来说，itcoin 是一种长期存在的点对点数字加密货币，目前的货币体系受到中央银行和商业银行等第三方的严重控制。比特币受到世界的关注不仅仅是因为加密货币本身，还因为比特币背后的一种算法，这种算法被称为区块链。被称为比特币和区块链创始人的中本聪的真实身份一直是比特币社区成员激烈争论的话题。由于中本聪和参与这个比特币项目前期的人只是通过邮件互动，没有人见过他本人，也没有人和他进行过真人互动；因此，他的身份至今不明。出于隐私考虑，中本聪拒绝向公众透露自己的身份，留下了一些评论；其中一篇文章名为“比特币:一个点对点电子现金系统”，描述了比特币如何使用区块链工作，另一篇是 Satoshi 和参与比特币早期阶段的人之间的一些电子邮件往来。
本文试图回答一个关于中本聪的问题，“谁在语言和语义上与中本聪相似？”本文对中本聪研究所、比特币论文和 Satoshi 的电子邮件往来中列出的相关文献进行了风格计量和语义相似性分析，以找出谁在语言和文本上与中本聪相似。风格计量分析是一种语言风格分析，用于根据语言特征暗示一篇文章是否属于某个作者。语义相似性分析是一种用来表明一个文本的内容或意义是否与另一个文本的内容相似的分析。
中本聪的真实身份对比特币社区很重要。众所周知，Satoshi 拥有大约 100 万个比特币，占比特币总供应量的 7%。他对比特币的经济影响最大；如果他决定向市场出售他的一些比特币，市场将通过可能贬值所有现有的比特币来应对这一变化。此外，表明中本聪的真实身份可以为区块链带来许多升级，并可以在金融以外的领域引入区块链的新应用。
2 数据
使用名为 Article 的 python 模块收集数据。使用该模块收集了中本聪研究所仅以 HTML 格式列出的文献。所收集文献的作者在比特币社区中被认为是中本聪的可能候选人，如哈尔·芬尼、伊恩·格里格、尼克·萨伯、蒂莫西·c·梅和戴伟。总共收集了 29 份文件，包括 6 份哈尔·芬尼文本、2 份伊恩·格里格文本、16 份尼克·萨伯文本、2 份蒂莫西·c·梅文本、1 份戴伟文本和 2 份中本聪文本，其中一份是比特币论文，另一份是他与他人的电子邮件交换文本。数据中除中本聪之外的每个作者的文本都被合并到一个文本文件中。训练语料库包含除中本聪之外的每个作者的单个组合文本，而测试语料库包含两个单独的中本聪的文本。
3 方法论
T 词形分析有三个组成部分，语言特征、分类算法和 n 元语法。总共生成了 10 个语言特征，并用于在语料库中作者之间进行比较。这些特性是使用 sent_tokenize 函数和 nltk 模块中内置的停用词生成的。表 1 提供了这些特性的描述。诸如支持向量机、随机森林和高斯朴素贝叶斯的分类算法被用于分类作为训练语料库的作者之一的中本聪的比特币论文和他的电子邮件往来。这些算法是用除中本聪以外的作者的特性训练的，并且都是使用 scikit-learn 模块在 python 中实现的。
此外，使用 nltk 模块产生了语料库中每个文档的 n 元语法，其中 n 是从 1 到 4。每个文档中的标记都使用 nltk 进行了词汇化。WordNetLemmatizer，以防止同一单词由于复数而被计为另一个单词。首先，1-gram，称为 uni-gram，是用和不用停用词生成的。之后，二元模型、三元模型和四元模型被创建、比较和分析，以观察中本聪是否按顺序重复某个单词模式，以及其他作者是否在他们的作品中使用相同的模式。
语义相似性分析是使用 spaCy 中计算语义相似性的内置函数和 python 中实现的 gensim 来完成的。在太空中。similarity()方法用于将一个文档的内容与另一个文档的内容进行比较，并使用 0 到 1 之间的数字来确定相似性，其中 0 表示这两个文档彼此不相关，1 表示这两个文档的内容相同。使用了 spacy.load('en_core_web_lg ')，它由在普通爬行上用 GloVe 和 1.1m 密钥训练的 300 维单词向量和 1.1m 唯一向量(300 维)组成。在 gensim 中，相似性。MatrixSimilarity()用于使用-1 和 1 之间的数字来计算余弦相似度，其中数字越接近 1，两个文档在内容方面就越相似。
4 个结果
根据表 3 中的分类算法，他们都预测 Nick Szabo 与撰写比特币论文的 Satoshi 在语言上相似，Ian Grigg 与交换电子邮件的 Satoshi 在语言上相似。在表 4 中，在 Satoshi 的电子邮件交流中有两个单字，(' would '，31)和(' one '，29)。Hal Finney 用了 28 次 would，Nick Szabo 用了 199 次 one。伊恩·格里格和尼克·萨博常用一个词“契约”。
从 spaCy(表 5)来看，戴伟与比特币论文的相似度最高，哈尔·芬尼与 Satoshi 的电子邮件往来的相似度最高。从 gensim(表 6)来看，Timothy C. May 与比特币论文的相似度最高，Ian Grigg 与 Satoshi 的电子邮件往来的相似度最高。一个不寻常的结果是，Ian Grigg 与 Satoshi 的电子邮件往来的相似性得分为 0.99996(表中四舍五入为 1.0)。
5 结论
根据测试结果，写比特币论文的聪可能不是那个互通电子邮件的聪。中本聪可能不止一个人；中本聪是参与创造比特币和区块链的计算机科学家和密码学家团队的化名。尼克·萨伯(Nick Szabo)和伊恩·格里格(Ian Grigg)分别是比特币论文和电子邮件文本中与中本聪语言相似的两位作者。此外，就语义相似性而言，戴伟和蒂莫西·c·梅是比特币论文的两个潜在候选人。哈尔·芬尼和伊恩·格里格是 Satoshi 电子邮件交流的两个可能的候选人。由于哈尔·芬尼曾通过电子邮件与中本聪互动是众所周知的事实，哈尔·芬尼不应被列入交换电子邮件的聪的可能候选人名单；伊恩·格里格在语言和语义上与中本聪相似。因此，中本聪的可能候选人是尼克·萨博、伊恩·格里格、戴伟和蒂莫西·梅。
6 讨论
中本聪(atoshi Nakamoto)在整篇比特币论文中反复使用了“工作证明”这个短语，尼克·萨伯(Nick Szabo)是训练语料库的唯一一位作者，他在名为 Bit gold 的博客文章中使用了完全相同的短语。它支持了一个理论，即尼克·萨博在语言风格方面非常接近于佐藤。使用 sklearn 上的多维标度、MDS，在二维空间中可视化语料库的每个作者的文档距离。在图 1 中，Ian Grigg 和 Nick Szabo 之间的距离最短，这表明 Ian Grigg 和 Nick Szabo 彼此关系密切，这可能不是巧合。戴伟和蒂莫西·c·梅与尼克·萨博和伊恩·格里格相距甚远，这可能表明，与尼克·萨博和伊恩·格里格相比，戴伟和蒂莫西·c·梅不是中本聪的有力候选人。
7 未来的工作
仅用由 10 个特征组成的 5 个数据点训练的分类算法令人担忧。在理想的数据科学世界中，机器学习模型需要用更大的训练样本进行交叉验证训练。除了 n-grams 的绝对频率之外，还可以将 n-grams 的相对频率添加到研究中。此外，如果可能的话，可以将自称为中本聪的克雷格·史蒂夫·赖特添加为训练语料库的作者之一，因为算法和语义相似性允许将他与当前训练语料库的作者进行比较。看看他是否会超过尼克·萨博和伊恩·格里格，这两个人是中本聪的两个最强有力的候选人，这将是很有趣的。
编辑描述
https://drive . Google . com/file/d/1t 3 itw 4kl-qky 1 zy 3 fpm 1 ytz 799hz lops/view？usp =共享](https://drive.google.com/file/d/1T3ITw4KL-QKy1zY3fpM1yTZ799HZLoPS/view?usp=sharing)
附:我刚刚意识到我不能在这里插入表格，所以我在 Google Drive 上分享了这篇论文。
托词:谁是最好的？
使用残差，经验和评级，看看谁打败了正常
我之前写过游戏次数和每周游戏次数如何与玩家的等级相关。你可以在这里阅读相关内容。数据中有一些噪音，但我的总体假设是正确的:你玩得越多，你就越好。
从排行榜，你可以很容易地看到谁排名第一。截至 2017 年 4 月 1 日，Dane69 以 1797 的评分蝉联冠军。你可以说他/她拥有最好的头衔，这是没有错的。对于这篇文章，我想要一个更加细致入微的外观。我的问题是:
对于他们的经验水平来说，谁是最好的诡计玩家？
为了确定这一点，我使用了一种叫做残差的统计方法。简而言之，残差是实际值与由模型计算的预测值之间的距离。残差用于确定任何模型的拟合优度。更多信息，我喜欢汗学院的残差解释发现这里。
在这篇文章中，我决定使用游戏的等级作为每个玩家的经验等级。例如，我(用户名:Baer)玩了 35 个分级游戏，分级为 1264。为了简单起见，我使用了一个线性模型，这将在下面进一步讨论。
可视化残差
下图类似于我的上一篇文章，但是做了一些美学上的改变来突出残差。
图表上的注释:
- 距离线性模型最远的距离(即每个经验水平的最大残值)用红色表示在上方，蓝色表示在下方。颜色越深，距离越大。
- 线性模型(中间浅蓝色的直线)代表已评价的游戏和预期评价之间的关系。未来的分析将受益于一个更细致的模型。
- 我为 0 以上的红色残差和 0 以下的蓝色残差添加了一个线性模型。看着图的最右边，我们可以看到线性模型最终失败了。大约 75 场比赛后，没有人击败模型(即没有红点)。
- 埃坎是所有球员中正剩余价值最大的。这意味着他/她已经大大超出了他/她的期望值。虽然有更高的评级，但没有一个玩家比 ekan 更远离他们经验水平的期望值。
- Baer(我)刚好在中间。在我的辩护中，我在我的最后一场比赛中由于缺乏互联网连接而自动辞职，并受到了很大的收视率打击。
- 我不想包括谁的名字有最大的低于标准的剩余。为他/她辩护的是，在大约 80 场比赛中，他们评级的期望值非常高。然而，他们的名义评级也是所有球员中最低的。我想他们已经输了很多次了。(我从数据集中删除了一个评分低于 600 的观察值。有人创建了一个帐户来测试他们可以获得多低的评级)。
西蒙·杰克逊博士关于残差的非常容易理解的帖子在这里找到是这篇帖子的一个很好的指南。
结论
没有一个模型是完美的，但它们都可以提供一定的洞察力。同样，我们可以看到经验确实会导致更高的评级。然而，顶部较平的红线表明你可以很快达到上限。蓝线的斜率几乎与模型的斜率相匹配。即使你已经跌到谷底，你也可以变得更好！
尽管如此，一个更灵活的模型可以解释图表右侧实际评分的下降。很明显，在玩了 40 个左右的分级游戏后，线性模型无法解释这种关系。我计划继续学习如何使用更复杂的模型计算残差。
恭喜伊坎！保持胜利(除非我们在同一场比赛中比赛)。
这篇文章的代码可以在我的 GitHub repo 找到这里。
成功的管理不是机器学习的问题…
在春季学期的最后几周，学生们不是唯一期待夏天的人。一个星期二的早上，当我聚精会神地听小组报告时，我不禁想，那天下午我会不会去网球场。上午课间休息时，我接到一个朋友打来的电话，邀请我去玩，我评估了一下天气状况:晴朗、炎热、有风，还有点潮湿。在过去的 14 次我考虑参加比赛时，条件并不完全相同。在其他条件相同的情况下，你能预测那天下午我是否在球场上吗？
Written, Frank and Hall, 2010
成功的管理不是机器学习的问题，而是人们在其工作环境中做出正确决策的问题。探索这种背景可以帮助您了解您所面临的挑战的性质——您是在完美信息的确定性环境中工作，还是在有缺失信息的随机环境中工作？你能假设手头的数据包含期望的结果(监督学习)或不包含(非监督学习)吗？你必须处理哪种数据(定性的、定量的、离散的、连续的、名义的、顺序的… …)？你愿意花多少时间去寻找答案，你期待的答案有多好(置信区间)？业务分析是学习理解要解决的问题的本质，然后使用适当的方法将数据转化为个人和集体的行动。
决策树可用于使用分类或连续数据直观地表示监督学习环境。决策树是使用估计值和概率来改进管理决策的预测模型。当正确使用时(无论是否依赖软件…)，决策树允许管理者利用对问题的观察(用分支表示)得出关于要采取的适当行动的结论(用树叶表示)。在上面的网球问题中，可以使用一个简单的决策树来有效地预测我那天下午的行为。
决策树在减少监督学习环境中行动过程的不确定性方面非常有用。把问题想成“二十问”的游戏。我有一个秘密(在什么情况下我会打网球)——你可以使用数据来制定问题，可以用是或不是来回答(我在什么时候打网球了？).选择每个封闭式问题，尽可能深入了解我的行为(当我打网球时)。问题的排序被称为决策表，每个答案的值就是信息增益。在上面的案例中，两个问题足以预测我的行为，包括今天和未来。
此处提供的数据最初是由 Written、Frank 和 Hall 作为练习提供的。使用具有分类属性(热、温和、凉爽；等等。).决策列表从识别变量(outlook)开始，当已知变量时，将产生最大数量的正确答案。下一步是确定变量，因为 outlook 的值将提供最大的信息增益(湿度)。有了第二个问题(变量)，我们有了答案——是的，那天下午我在打网球，因为天气晴朗而潮湿。
改善管理决策是商业分析研究所的核心和灵魂。在我们位于巴约纳的暑期学校，以及我们在欧洲的大师班，我们让数据科学为您和您的组织服务。该研究所专注于管理者数据科学的五个应用:在数字时代工作、数据驱动的决策、机器学习、社区管理和可视通信。数据驱动的决策会对你未来的工作和职业生涯产生影响。提高做出正确决策的能力只需点击一下鼠标。
Lee Schlenker 是 Pau 商学院的教授，也是 http://baieurope.com 商业分析学院的负责人。 他的 LinkedIn 简介可以在www.linkedin.com/in/leeschlenker.你可以在https://twitter.com/DSign4Analytics关注我们
【我】撰写，即 Frank E .和 Hal，M. (2010)，数据挖掘:实用的机器学习工具和技术，第三版，Elsevier
数独和尽力而为
我们的很多生活，无论是工作生活还是个人生活，都是在做重复的、没有创造性的事情。这些任务中有许多是令人愉快的:它们包括像园艺或烘焙这样的爱好，我们出于难以表达的原因而喜欢这些爱好。但是，它们也包括我们不想做的事情，比如洗衣服或洗碗。
虽然我们不能简单地给机器人编程来完成上面列出的任务，但有很多重复性的任务，尤其是那些不涉及操纵物理对象的任务，我们可以做到。比如像 Wolfram Alpha 这样的科学软件包可以自动求解大部分微分方程，这样人类就不用再手动求解了。
鉴于这些软件包的存在，如果一个数学家根据他用手快速求解微分方程的能力来衡量自己的素质，我们会觉得很奇怪，因为计算机求解微分方程的速度要快得多。只有当他把时间花在数学系，而不是冒险去学习计算机科学时，这才有意义——他可能不知道微分方程可以用计算机求解，因此可能会把手动求解视为对时间的有效利用。
这正是人们解数独谜题时发生的事情。数独是一个基本上重复的任务，可以根据简单的规则用计算机程序解决。数独仍然是世界上最受欢迎的益智游戏之一，而且大多数玩数独的人并不认为这是一项可以用算法来描述的任务，这一事实很好地说明了将活动与生产力相混淆是多么容易， 它应该让我们所有人清醒过来，审视我们工作的哪些方面只是让自己习惯于遵循一套明确规定的规则，并不断提高效率——换句话说，就是做相当于“擅长解决数独”的事情——而我们应该学习如何做相当于让计算机处理这项工作的事情。
为什么我一直在想这个
在过去的几个月里，我一直在完成设计非常好的 Udacity 人工智能纳米学位的项目，该项目通过让你将经典的人工智能技术应用于实际问题并通过自己编码来学习算法，来教授这些技术。
第一个问题是写一个解决数独难题的算法。鉴于这种纳米程度的“经典人工智能”倾向，解决方案是而不是简单地建立一个神经网络，它看到一堆正面和负面的例子，并通过调整其权重来迭代学习如何解决难题，和/或使用强化学习算法，该算法惩罚将数字放在违反规则的地方的代理，并在它正确解决难题时奖励它。不，数独很简单，我们可以“教”计算机如何玩数独，通过明确地告诉它在棋盘上看到的数字该做什么。这是一个有趣的练习——我发现弄清楚你将如何告诉计算机解决数独比自己解决它们更有价值。
下面是解决方案的概要。我会注意到，这个解决方案和 Udacity 解决方案紧跟彼得·诺维格的经典文章解决每一个数独难题。
如何解决每一个数独
首先定义一个数据结构来跟踪棋盘上已经有的数字。这个数据结构还应该跟踪空单元格的所有“候选”数字——也就是说，那些单元格中可能包含的数字。
然后，反复遵循几个步骤来解决这个难题，直到它被解决:
- 第一步:“淘汰”。使用数独规则从空单元格中排除候选数字。例如，如果某一行中有一个 9，则使用此规则从该行的其他单元格中排除 9 作为候选单元格。
- 一旦我们在一个单元格中只剩下一个数字，继续“消除”策略，从棋盘上的其他单元格中消除该数字。据我所知，这在经典人工智能中被称为“约束传播”。
- 如果有必要，使用高级技术来“消除”数字，例如下面描述的“裸体双胞胎”技术:
An illustration of the Naked Twins strategy. Credit Ronald Eddings
理论上，人类可以做到这一切。然而，如果他们遇到了障碍——没有更多的数字可以很容易地从细胞中消除。然后呢？
计算机可以很容易地解决这个问题——不仅仅是通过尝试所有可能的板组合，直到找到一个有效的组合。他们可以简单地做以下事情:假设有两个单元格，单元格 1 和单元格 2，给定所有关于棋盘的信息，我们知道单元格 1 包含 5，单元格 2 包含 6，反之亦然。但是，我们没有信息告诉我们哪个是哪个。在这里，一个人被卡住了，但计算机可以简单地尝试第一种可能性，在单元格 1 中放一个 5，在单元格 2 中放一个 6，然后尝试继续遍历整个棋盘，直到谜题被解决，或者直到它找到一个没有可能值的单元格——如果发生这种情况，它知道它在“岔路口”的最初选择是错误的，6 应该在单元格 1 中，5 应该在单元格 2 中。这可以使用一种称为“深度优先搜索”的经典算法来实现。
事实上，项目的最后一步是让我们的程序解决一个数独游戏，这个游戏既需要搜索来解决，也需要额外的约束，即除了行、列和九个“子块”之外，数字 1-9 不能在每个主对角线上重复:
A diagonal Sudoku that would be extremely difficult for a human to solve. Go ahead, try it.
(理论上，人类也可以做到这一点，但这需要大量的擦除工作，而且擦除工作很麻烦。)
所以，数独完全可以用一种算法来描述——(我的 GitHub 中解决谜题的代码包含在这里的)。那么，人们真的会做这些事情，这真是太不可思议了！毕竟，人们通过各种方式跟踪信息，并采用与上述类似的策略(通常不太复杂)来解决这些问题。
简单地说:许多被认为类似数独的“益智”游戏本质上是算法，但不是全部。例如，单词搜索谜题是算法上的:你可以很容易地给计算机编程，在一个字母网格中搜索一组特定的单词。相比之下，填字游戏是有创造性的，不仅需要了解自然语言的微妙之处，还需要了解填字游戏所处的社会和文化背景。
尽你所能
此外，大部分白领工作将最终被取代——这并不是说这些工作将完全消失，但是将会有一些工具建立起来，例如，以更少的人工方式在 Excel 中进行大量的人工分析，这样我们将需要更少的人来完成同样多的工作。这对整个社会来说当然是一件好事——但从目前正在努力在这些工作中脱颖而出的人们的角度来看，这是一件令人不快的事情。我认为问题的根源是，从事这些工作的大多数人并不认为他们所做的事情是从根本上的算法——他们相当于一遍又一遍地做数独，而有人可能会出现并简单地为你编写一个数独程序。
The problem.
所以，我认为人们把数独之类的东西视为令人愉快的活动，这实际上是个问题。将精神刺激与实际上需要批判性思维、创造力和反思的事情混为一谈，不仅会混淆忙碌和生产力，导致糟糕的时间管理，还会导致糟糕的职业选择，让你寻找“感觉”自己“做了很多工作”的工作，而不是专注于寻找“增加了很多价值”的工作。
这里最直接的教训是:如果你在做这种重复性的工作:走出去(如果你想进入数据科学，参加梅蒂斯的沉浸式项目可能是一个很好的方式)——“机器人”——或者至少知道如何教它们(即编程)的人——正在找你。然而，第一步是要认识到，做相当于“一遍又一遍地做数独”的事情，虽然可能会让你很忙，但实际上并没有什么成效。
更一般地说:不要停止玩数独。总是寻找方法来自动化工作和生活中重复的、有组织的任务。做到这一点，利用你节省下来的时间来培养你的创造性、创新性和更人性化的一面——这是你最终需要做的最有价值和最有回报的工作。
对斯里兰卡政府停车场系统的建议…
在斯里兰卡的城市中，由于车辆数量和车辆尺寸的持续增长，停车是一个更加棘手的问题。停车不仅是斯里兰卡的一个大问题，也是世界各地的一个大问题。我们知道，每天有一辆 百万辆 烧机油。因此，我想在这篇文章中给斯里兰卡 政府 一个建议。这是我在 Medium 的第 11 篇文章。
如今，斯里兰卡城市的停车场有摄像头，他们可以观察车辆数量并计算时间。相机消耗更多的电能，因此我建议用传感器来解决这个问题。在这里我们将看到如何实现这个问题。
这里我想用 蓝牙信标 。蓝牙信标会发射 5 年的蓝牙电波。蓝牙信标是低能耗设备。我们想造一个装置来接收蓝牙电波。该设备将计算蓝牙连接的时间和离信标的距离。在停车场，我们希望为每个信标设置不同的频率，因为我们应该知道汽车的确切位置。为了防止信号干扰，蓝牙信标的蓝牙波将在特定区域受到控制。通过计算至少三个蓝牙信标的距离，可以找到汽车的位置，这就是为什么我们应该使用不同频率的蓝牙信标。通过画三个半径与计算的距离相对应的圆，并使用圆的公共交点(三角测量)，我们建立的设备将找到汽车的位置。下图描述了 三角测量
当汽车要停车时，我们制造的接收蓝牙电波的装置应该与汽车连接。有些停车系统有不同的设施，例如有些停车场有电梯。如果你使用这些设施，而不是传统的，你应该支付额外的停车费。有人不会支付额外的费用，他们只支付停车费。通过三角测量法，没有人能逃避支付额外的设施使用费。停车的人通过 NFC (近场通信)支付。
这里有一个问题，那就是每辆车都应该安装接收蓝牙电波的设备，但是斯里兰卡政府可以安装这个系统。这种更 消耗能源 的问题不仅在斯而且在很多国家都存在。所以那些政府可以像这样改变系统。
感谢您阅读至此。如果你喜欢这篇文章，请分享、评论并发表👏几次(最多 50 次)。。。也许会对某个人有帮助。
关注我的Twitter和 Medium 如果你将来对这些更深入、更翔实的文章感兴趣的话！
用 SQL 汇总数据
SQL 不仅可用于将数据从数据库传输到建模环境。了解有关如何现场分析您的数据以确定最有用的信息的更多信息
在我们之前从真正的数据科学角度对 SQL 进行分析的中，我们探讨了如何使用 SQL 来了解数据集在缺失方面的质量，以了解哪些表和字段值得迁移到建模首选环境中。在这一期中，我们将看到一个经典的工具，用于理解不同变量的基本性质，以及如何在 SQL 中获得这些变量。
约翰·图基重新激活了探索性数据分析的实践，并通过他的同名著作大量推广了这个短语本身。Tukey 提出的最简单也是最有用的工具之一是五个数摘要。考虑到它的有用性，R 使用一个简单的命令就可以从任何数据集——five num()——中获得这个摘要，这个数据集在 base R 中。
这非常简单地由变量的最小值、最大值、中间值、第一个四分位数和第三个四分位数组成。假设最大值和最小值一直是标准的集合，并且不需要使用复杂的统计分布或矩阵代数来准备任何值，那么可以认为这种汇总应该很容易从任何 SQL 实现中获得。
然而，就在 21 世纪初，这实际上还是一个相当繁琐的问题。值得庆幸的是，尽管许多东西，比如流行音乐，从那以后已经明显恶化了(在克林顿执政期间，我达到了有资格开车的年龄，这与流行音乐对我来说听起来最好的时期密切相关)，但从那以后，标准 SQL 和最大的实现都引入了有用的新特性。
ANSI SQL 2003 版中添加的窗口函数提供了一系列有用的选项。其中，PERCENTILE_CONT 和 PERCENTILE_DISC 使得获得完整的五个数摘要集比以前简单得多。
这些函数的基本语法是:
PERCENTILE_DISC(int) WITHIN GROUP (ORDER BY numeric)
OVER (PARTITION BY variable)
当目的是将数据集划分为由数据集中的分类变量定义的子集时，这些函数通常是供某些人使用的。五个数摘要的概念中隐含的意思是，至少在第一遍中，我们希望对整个数据集运行它。为此，我们只需将 OVER 子句留空，例如，“OVER (PARTITION BY variable)”就变成了“OVER()”。
因此，获取任何单个数值变量的第一个四分位数、中值和第三个四分位数的完整查询如下所示:
SELECT DISTINCT
PERCENTILE_DISC(25) WITHIN GROUP (ORDER BY numeric)
OVER () as Q1_Var
, PERCENTILE_DISC(50) WITHIN GROUP (ORDER BY numeric)
OVER () as median_var
, PERCENTILE_DISC(75) WITHIN GROUP (ORDER BY numeric)
OVER () as Q3_var
FROM db.tbl
该查询显然返回三个值—最大值和最小值，缺少五个数字汇总中最基本的一个。但是，由于百分比值不是聚合函数，如果我们简单地将 min(var)和/或 max(var)添加到 Select 语句中，SQL 将抛出语法错误。
相反，我们需要使用一个公共表表达式创建第二个表，该表可以包含标量形式的聚合值，并将这两个表连接在一起。假设我们将单行连接在一起，我们可以做一个完整的笛卡尔连接，并且只期望返回一行。
WITH extreme_table (var_min,var_max)AS (SELECT
min(var)
, max(var)
FROM table) SELECT DISTINCT
var_min
, PERCENTILE_DISC(25) WITHIN GROUP (ORDER BY numeric)
OVER () as Q1_Var
, PERCENTILE_DISC(50) WITHIN GROUP (ORDER BY numeric)
OVER () as median_var
, PERCENTILE_DISC(75) WITHIN GROUP (ORDER BY numeric)
OVER () as Q3_var
, var_maxFROM db.table JOIN extreme_table on 1=1
该查询返回单行的五个值，表示五个数字的汇总。但是，我们在上面提到过，SQL 百分位函数更频繁地与分区变量一起使用，以应用于包含特定分类变量的子集的数据集，对于通常与 Group By 变量一起使用的更多运行的 mill 聚合函数 min()和 max()也是如此。
直觉上，许多分析师也想将五个数字的汇总应用于不同的数据子集。扩展上面的查询，通过在 extreme_table 的 Group By 子句和 select 子句中添加分类变量，并在 category 上连接之前添加 PARTITION 子句，可以直接实现这一点。结果将如下。
WITH extreme_table (var_min,var_max,category)AS(SELECT
min(var)
, max(var)
, category FROM table
GROUP BY category)SELECT DISTINCT
var_min
, PERCENTILE_DISC(25) WITHIN GROUP (ORDER BY numeric)
OVER (PARTITION BY category) as Q1_Var
, PERCENTILE_DISC(50) WITHIN GROUP (ORDER BY numeric)
OVER (PARTITION BY category) as median_var
, PERCENTILE_DISC(75) WITHIN GROUP (ORDER BY numeric)
OVER (PARTITION BY category) as Q3_var
, var_max
, table.categoryFROM db.table JOIN extreme_table on extreme_table.category=table.category
从五个数字汇总中获得的通常分析是一种偏斜感——通过查看中位数在第一和第三四分位数中的位置，以及最小值和最大值与这些四分位数的关系。显然，在数据的分类子集上获得相同的数据是非常有用的，因为它不仅允许您比较数据的位置(中位数),还允许您比较每个类别的分布形状，以了解每个类别如何集中其基础数据。
罗伯特·德格拉夫是《进展中的书’【懒惰的数据科学家】 的作者，可通过 LeanPub 在推特上关注他:https://twitter.com/RobertdeGraaf2
总结灾难中的推文
Map of the Nepal’s second earthquake’s intensity, credit: https://www.washingtonpost.com/graphics/world/nepal-earthquake/
2015 年 4 月 25 日，就在中午之前，尼泊尔经历了一场矩震级 7.8 的地震。地震席卷了加德满都山谷，一系列余震夷平了整个村庄。
地震发生后，来自世界各地的志愿者在指导紧急行动中发挥了重要作用，他们使用卫星图像来确定整个地区基础设施的破坏情况。
然而，尼泊尔地面上的人们也在 twitter 上产生了大量可能对救援行动有用的信息，尽管不那么直接。从 4 月 25 日到 5 月 28 日，有 33610 条推特被尼泊尔人转发。这些推文充满了有用的信息，但 33，610 条推文对于救援行动来说太多了，难以梳理。
这是这个项目的动机:
我能从大量的推文中提取出有用的简短摘要吗？这些摘要可能对地面救援行动有用。
内容:
0.获取推文
- 使用内容词和 tf-idf 分数查找所有有用的推文
- 挑选最好的推文做一个简短的总结
- 结论
0.获取推文
我从“ Twitter 作为生命线:危机相关消息的 NLP 的人类注释 Twitter 语料库”获得我的推文；该项目从危机中提取了数千条推文，并将其分为 8 个不同的类别(例如，“流离失所者和疏散”，或“同情和情感支持”)。
然而，由于救援队无法标记推文，我只使用推文本身的数据集，而不是标签。
Twitter 的政策规定，只能保存推文 id，而不是推文本身——这样，如果用户删除了他们的推文，那么它们就不会存储在其他地方。因此，我不得不使用 twitter 的 API 从这个语料库中获取 tweet 内容。这需要我注册一个应用程序:
I am now an app developer!
然后我用 Twython 下载了这些推文，然后就上路了！
1.提取情景推文
很明显，并不是所有的推文对救援队都同样有用。举个例子，
@Gurmeetramrahim: #MSGHelpEarthquakeVictims Shocked!!!hearing earthquake in Nepal n some parts of India. I pray to GOD to save His child
不包含对救援队有用的信息，尤其是与以下信息相比:
MEA opens 24 hour Control Room for queries regarding the Nepal #Earthquake.
Numbers:
+91 11 2301 2113
+91 11 2301 4104
+91 11 2301 7905
有用的推文被归类为情景推文，可能包含状态更新，或即时有用的信息(如附近医院的号码)。
非情境推文包含(例如)情绪、观点或事件分析。这些并不能立即帮助救援工作。
在我开始总结推文之前，我需要把情景推文和非情景推文分开。我用两种方法做到了这一点:我首先手动分离推文的特征(1.1-内容词)，这些特征有助于推文的有用性。然后，我使用了一个名为 tf-idf (1.2)的文档分析工具来寻找对这个特定事件和这组推文有意义的词。
1.1.实词
在他们 2015 年的论文中。al 确定了在灾难中提供重要信息的三类术语:数字、名词和主要动词。属于这些类别的词被称为实词。我发现这太笼统，无法区分推文，于是自己定义了两个类别:
- 数字(如伤亡人数、重要电话号码)
- 实体(如地点、日期、事件、组织等。)
SpaCy (一个自然语言处理库，自动从文本中分析提取信息)是一个非常有用的识别实词的工具；当 SpaCy 对文本进行标记时，它会向标记添加许多附加信息，例如它是否是实体(如果是，它是什么类型的实体)，它的词性是什么(即它是名词吗？一个动词？一个数字？)，甚至是令牌的情绪。
SpaCy’s awesome entity recognizer
我使用 SpaCy 来标记推文。这意味着将推文分解成它们的组成部分(主要是单词，但也包括标点和数字)，并将这些组成部分转化为符号。例如，
: Over 110 killed in earthquake: Nepal Home Ministry (PTI)
成为
[:, Over, 110, killed, in, earthquake, :, Nepal, Home, Ministry, (, PTI, )]
SpaCy 的强大之处在于这些令牌充满了附加信息；例如，我可以找出所有这些标记的词性:
[u'PUNCT', u'ADP', u'NUM', u'VERB', u'ADP', u'NOUN', u'PUNCT', u'PROPN', u'PROPN', u'PROPN', u'PUNCT', u'PROPN', u'PUNCT']
令牌的另一个非常有用的属性是它的实体类型；SpaCy 可以告诉我Kathmandu是一个城市，或者25 April是一个日期。如果实体类型(token.ent_type_)是:
NORP:国籍、宗教或政治团体FACILITY:建筑、机场、高速公路、桥梁等。ORG:公司、机关、机构等。GPE:国家、城市、州。- 非 GPE 地区，山脉，水体。
EVENT:命名飓风、战役、战争、体育赛事等。- 绝对或相对的日期或时期。
TIME:小于一天的时间。
如果单词的词性(token.pos_)将它们标记为数字，或者如果它们是关键词列表中的一个(例如‘杀死’，‘受伤’，‘伤害’)，我也会包含这些单词。
这种分类大体上允许我开始整理我的推文；情景推文包含的内容词较多，非情景推文包含的内容词较少。举个例子，
@timesofindia: #Earthquake | Helpline numbers of the Indian Embassy in Nepal:\r+9779581107021\r\r+9779851135141'
是一条非常有用的推文，正如所料，提取了许多内容词:
[the, Indian, Embassy, Nepal, 977, 9581107021, 977, 9851135141]
另一方面，
Pray for #Nepal where a powerful earthquake has struck. May the Almighty grant them ease to face this calamity with utmost sÛ_
包含的情景信息很少，从中提取的唯一内容词是[Nepal]。
1.2.tf-idf 分数
实词的一个缺点是它们不能捕捉到关于单词本身的任何信息。例如，对于这场灾难，单词Nepal将是一个强有力的指标，表明一条推文是否是情境性的，但它现在与任何其他内容单词的权重没有任何不同。
可以使用术语频率—逆文档频率 (tf-idf)得分来引入这种加权。
尽管 tf-idf 的名称很长，但其背后的逻辑却很简单:
在文档主体中出现频率相当高的单词可能更重要，但是如果它们出现得太频繁，那么它们就太笼统而没有帮助。
基本上，我想给“尼泊尔”这个词打高分(它应该在许多推文中出现一次)，而不是“the”(它应该在许多推文中出现多次)。
数学上，某个单词 t 的 tf-idf 分数可以描述为
其中 c 是单词 t 在文档中出现的平均次数，N 是文档总数， n 是单词 t 出现的文档数。
Textacy ，一个建立在 SpaCy 之上的库，让我给推文中的单词分配 tf-idf 分数变得超级简单:
WORD:morning -- tf-idf SCORE:6.45446604904
WORD:bishnu -- tf-idf SCORE:8.06390396147
WORD:nagarkot -- tf-idf SCORE:12.2359876248
WORD:search -- tf-idf SCORE:6.35915586923
WORD:kathmandu -- tf-idf SCORE:5.27350744616
现在，如果我只选择有很多内容词的推文，或者甚至只选择有很多 tf-idf 分数高的内容词的推文，我仍然会有太多的推文供救援队实际使用。
我想做的是找到一个简短的推文摘要，但它也包含了尽可能多的 tf-idf 得分最高的词。
2.基于内容词的推文摘要
为了生成对救援队有用的东西，我需要生成一些简短的东西(因此可以快速阅读)。它还需要包含对救援队有用的信息——因此摘要需要充满具有高 tf-idf 分数的内容词。
我可以很容易地将它定义为一个带约束条件的方程:
等式:最大化我的摘要中内容词的总分。
约束 1: 摘要必须短于 150 字。
约束 2: 如果我选择一个内容词出现在我的摘要中，那么我必须选择一些包含该内容词的 tweet 出现在我的摘要中。
约束 3: 如果我选择某条推文放在我的摘要中，那么这条推文中的所有内容词都必须包含在内。
我需要在约束条件下解方程。我求解的变量(一个实词是否在摘要里)是整数。具体来说，选择是二进制的——如果包含该单词，选择 1；如果不包含，选择 0。
这种用整数变量来求解受一些约束的一些方程(最大化内容词的得分)的方法被称为整数线性规划 (ILP)。
使用 ILP，我可以从数学上定义我上面写的最大化
其中 x 和 y 是 1 和 0 的数组，取决于是否选择了 tweet i 和内容词 j ，Score( j )是内容词 j 的 tf-idf 分数。约束条件定义如下
See my jupyter notebook for more info on what these mean
使用 pymathproj 来优化这个 ILP 问题产生了以下总结:
1\. TV: 2 dead, 100 injured in Bangladesh from Nepal quake: DHAKA, Bangladesh (AP) ÛÓ A TV r...
-------------
2\. : Earthquake helpline at the Indian Embassy in Kathmandu-+977 98511 07021, +977 98511 35141
-------------
3\. +91 11 2301 7905om no for Nepal #earthquake +91 11 2301 2113
-------------
4\. Tremors felt in West Bengal after 7.9 Magnitude Earthquake in Nepal
-------------
5\. This mobile App may help these people to predict this powerfull M7.9 earthquake
-------------
6\. 5.00 earthquake occured 31km NNW of Nagarkot, Nepal at 09:30 UTC! #earthquake #Nagarkot
-------------
7\. Earthquake in bihar up punjab haryana delhi ncr and nepal
-------------
8\. : Whole Himalayan region is becoming non stable. Two yrs back Uttrakhand, then Kashmir now Nepal n north east. Even Tibet isÛ_
-------------
9\. WellingtonHere Nepal's Home Ministry Says at Least 71 People Killed in the Earthquake: Nepal'... WellingtonHere
-------------
10\. 934s of major earthquake-s in Nepal:
-------------
11\. Historic Dharahara tower collapses in Kathmandu after quake | Latest News & Updates at Daily...
-------------
12\. Powerful quake near Nepal capital causes widespread damage, avalanche near Everest base camp
将此与随机推文进行比较:
A comparison of the tweets selected by COWTS to a random selection from the database.
肯定有一些噪音，但并不坏！摘要尤其擅长提供位置信息，例如描述震中在哪里以及哪些区域受到地震影响。
3.结论
如果我再次做这个项目，我会使用一个 twitter 特有的 标记器。SpaCy 的 tokenizer 实际上在标记数据方面相当糟糕，因为所有的缩写和 twitter 专用术语。我还会对数据进行更多的清理，因为拼写错误和缩写也可能会损害记号赋予器的性能。
总的来说，用除了单词嵌入之外的方法来比较和量化文本数据是很棒的。此外，这种方法的速度让我相信它可以由救援队实施；特别是，如果使用更小的推文子集(例如，每日推文，而不是覆盖整个事件的推文)，这将非常有用！
3.1 进一步阅读
这个项目涉及实施各种不同的文件；这里有一些很酷的论文，可以进一步探索灾难中的 twitter 摘要:
Twitter 作为生命线:危机相关消息的自然语言处理的人类注释 Twitter 语料库
总结危机场景中的情景推文(本帖实质上实现了本文)
更新—使用 NLTK 的 twitter 标记器
我用 NLTK 代替 spaCy 重复了这个练习。这允许我使用 NLTK 的 twitter 特定标记器对 tweets 进行标记，产生以下摘要(与 spaCy 输出相比):
NDRF: India’s Natural Disaster Response Force
因为内容词的定义不同，所以很难定量地比较这两个输出，但是值得注意的是 NLTK 的实体识别系统(我用的是斯坦福的 NER)明显比 spaCy 的慢。
我(试图)在第 2 部分中使用这些精选的 tweets 建立一个抽象的总结:
现在是 2015 年 5 月，救援队正在努力重建 4 月地震(及其余震)后的尼泊尔。可以…
medium.com](https://medium.com/towards-data-science/summarizing-tweets-in-a-disaster-part-ii-67db021d378d)
总结灾难中的推文(第二部分)
现在是 2015 年 5 月，救援队正在努力重建 4 月地震(及其余震)后的尼泊尔。这些努力能得到 twitter 的帮助吗？
在之前的帖子中，我构建了一个推文摘要器，它收集了 4 月 25 日至 5 月 28 日之间的所有推文，并选择了对救援队最有用的推文摘要:
在危机中使用数据科学帮助救援团队
medium.com](https://medium.com/towards-data-science/summarizing-tweets-in-a-disaster-e6b355a41732)
现在，我想更进一步:不仅仅是选择最好的推文，我能生成我自己的句子，有效地总结推文中所有有用的信息吗？
注:本帖本质上是本文的一个实现；如果你对这个主题感兴趣，它绝对值得一读！
内容:
- 制作文字图表
我已经使用内容文字推文摘要生成了最佳推文的摘要(在之前的帖子中)。我将使用这些推文，并考虑它们包含的所有可能的单词路径(使用单词图)。 - 调查信息含量和语言质量
然后，我将通过定义一些新的指标来选择最佳的单词路径:信息含量和语言质量。 - 生成抽象摘要 最后，我将使用这些最佳单词路径来生成推文的抽象摘要。
我做了两次这个练习，使用了 spaCy 和 NLTK 作为标记器(并使用了它们各自从内容词 tweet 摘要中选择的 tweet)。
1.制作单词图表
为了生成我自己的句子，我将选择最好的推文，并考虑其中包含的所有可能的单词路径。
这到底是什么意思？
为了理解什么是单词路径，我首先要考虑一个单词图。单词图是句子的图形表示，节点表示单词，边表示单词之间的连接。例如，句子“7.9 级地震后加德满都历史性的 dharara 塔倒塌”可以用下面的单词 graph 来表示:
当添加多个句子时，单词图变得强大。比如，我加了一句话:“建于 1832 年的达卡纳尔塔在加德满都地震中倒塌”:
Credit to Rudra et al for this figure. Bigrams rather than words are used at the nodes, but the principle is otherwise the same.
现在，我可以通过这个图表找到与原始输入句子不同的单词路径，例如“1832 年建造的 dharara 塔在加德满都 7.9 级地震后倒塌”。我已经能够从两个输入的句子中提取一些信息，来制作我自己的。
抽象摘要的目标本质上是这样做的:生成我自己的单词路径，以便从 tweets 中分离出最好的信息。
以我自己的推文为例，我可以使用二元模型从它们生成一个单词图，然后我可以用它来生成所有可能的价值路径。许多单词路径会产生无意义的句子，例如
[Nepal quake - Buildings collapse in Delhi for queries regarding tragic Earthquake Rocks Nepal victims']
所以我希望得到有用的字路径，这也有意义。
2。信息量和语言质量
为了获得有用的有意义的单词路径，我将测量两个指标:信息量和语言质量。
2.1.信息量
信息含量实际上意味着这条推文在我拥有的推文语料库中的代表性。幸运的是，有一种简单的方法可以量化这一点。当我为上一篇文章的摘要选择推文时，我生成了一个叫做 tf-idf 术语矩阵的东西。这是一个矩阵，包含了所有推文的所有词汇:
每一列代表一个单词。如果row [i]中的一条 tweet 包含由column [j]表示的单词，那么矩阵元素[i][j]将包含该单词的 tf-idf 得分。否则，它将包含一个 0。
因此，我可以通过计算每一列的平均值来生成一个向量，该向量近似表示推文的主体:
An array of height 1 with a length equal to the total vocabulary size of all the tweets, populated by the column mean of each value for all the tweets.
我可以为每个单词路径生成一个类似的行，并比较这个平均向量和单词路径向量之间的差异。我这样做是为了找到它们的余弦相似度，它测量两个向量之间的余弦角(越小越相似)。
2.2.语言质量
因为许多单词路径是无意义的，所以选择有意义的语法正确的句子很重要。我该怎么做？
一种方法是看看我选择的单词路径中的单词序列出现在“正确英语”中的可能性有多大。我可以通过分析“正确英语”的文本，并测量不同单词序列出现的频率来做到这一点。然后，我可以将它与我的单词路径进行比较；如果一个单词路径充满了频繁出现的单词序列，那么它在语言学上更有可能是正确的，所以我会给它更高的分数。
长度为 n 的单词序列被称为 n-gram，因此这种语言质量的方法被称为 n-gram 语言模型。
The probability being found by a trigram
三元模型(n = 3 时的 n 元模型)计算上面的等式:考虑到在它之前出现的两个单词，单词路径中的下一个单词是它所在的单词的概率是多少，其中该概率与英语语料库进行比较。
幸运的是，有一个名为 kenlm 的工具包，它就是为做这件事而设计的(这里的是一个很棒的帖子，它详细介绍了如何从 n 元语法中提取语言质量)。
使用 kenlm，我使用了当代美国英语语料库(COCA) 作为我的“正确英语”参考，并对单词路径的语言质量进行了评分。
3.生成抽象的摘要
就像在第 1 部分中一样，我使用这些组件生成一个整数线性问题，这个问题是可以解决的。考虑到所有的单词路径，我想选择具有最高信息量分数和最高语言质量的单词路径，这些路径也包含最多的内容单词。
数学上，我可以这样写
其中，LQ 是语言质量，I 是第 i 个单词路径的信息含量，服从以下约束:
- 我的总结必须少于 150 字
- 如果选择了内容词，还必须选择包含该内容词的词路径
- 如果选择了单词路径，则必须选择该单词路径中的所有内容单词。
我也可以用数学来描述它
For more information on exactly how I programmed these, check out the NLTK and spaCy Jupyter notebooks.
然后我使用 pymathprog ，和整数规划模块，来求解这些方程(通过最大化第一个方程，服从第二个三个方程的约束)。
这为空间产生了以下结果:
**spaCY:**
--------------
valanche sweeps everest base camp , 34 minute of major earthquake
--------------
: mea control room no for nepal 25/04/2015 07:13 utc , april 25,nepalquake kathmanduquake
--------------
high alert after 7.9 magnitude earthquake perso _thquake
--------------
earthquake m7.5 strike 89 km nw of 4.5 + 91 11 2301 7905
--------------
thr r safe . apr 25 14:14 at 7.7 richter scale , via
--------------
sad day for the last 1 hour(s ) . associatedpress associated press news
--------------
: whole himalayan region be up and lalitpur make kathmandu 's 19th century nine - witness
--------------
: 09771 4261945/ 4261790 emergency helpline number in 80 year - typical indian
--------------
9779851135141 square afganistan bhutan emb
--------------
building collapse , 400 people kill in kathmandu-+977 98511 07021 , 9851135141
--------------
nepal n north east . kathmandu contact mr. adhikari 00977 - cnn
对于 NLTK:
--------------
: LATEST Nepal's Kantipur TV shows at Ahmedabad from Kathmandu RestlessEarth GeographyNow
--------------
MEA opens 24hr Control Room in Nepal 20 00 29 UTC quake
--------------
: EarthquakeInNepal Helpline Numbers of Lamjung , Purvanchal & Kochi too !
--------------
: Warning India Bangladesh Pakistan Afganistan Bhutan Nepal Earthquake Rocks Nepal BBC
--------------
Dharahara also called Bhimsen Tower , 2 at 09:30 UTC , 9851135141
--------------
( Houston _0998 ) Avalanche Sweeps Everest in Nepal - New York Times
--------------
Kathmandu's Darbar Square after 7.9 magnitude in Tibet Nepalquake Embedded image permalink
--------------
5.00 earthquake Kathmandu Ambulance and 11 2301 2113 011 2301 4104 011 2301 7905
--------------
Update on 4/25 / 2015 06:37 UTC , Katmandu - Fox News
--------------
: 09771 4261945 / 15 @ 9:30 : Nepal AssociatedPress Associated Press news
--------------
Bravo Google You are faster than 300 people within 100km . 9 - France 24
--------------
: Patan Durbar Square after 7.7 quake : 079-2325190 0/902 / 9779851135 141
这些都不太好，比起抽象的摘要，tweet 摘要绝对是捕捉最好的有用 tweet 的更好的方法。有些单词路径确实有意义，但绝大多数没有意义。
4.结论
这是对自然语言处理的一次有趣的入侵。特别是，看到数据科学如何应用于机器学习和神经网络之外，并使用另一种优化方法( ILP )真是太棒了。
探索不同的 NLP 技术也很棒，比如单词图和 n-gram。
我怀疑这种方法失败的原因是因为选择的推文太不一样了；word graph 擅长获取相似的 tweets，然后找到一个单词路径，只从中提取有用的信息。自从我用考茨选择的推文开始，推文就已经是摘要了。
如果我再试一次，我会使用更广泛的推文，尝试并利用这一点。
2017 年与开放和可重复研究相关的活动总结
去年对于 cTuning foundation 和divideti来说是非常紧张的一年——我们继续与 AI、ML 和系统社区密切合作，以自动化实验，同时基于我们的长期愿景提高结果的可重复性和可重用性。
首先，在 ACMCGO 2018和PPoPP 2018年会上，我们有机会应用新的 ACM 工件审查和标记政策(该政策是我们一年前作为新的 ACM 再现性工作组的一部分，基于我们之前的工件评估经验而共同制定的)。好消息是，我们又有了一个创纪录的提交数量:近一半被接受的论文提交了工件进行验证，总数达到 30 个！我们还从 EasyChair 切换到 HotCRP 用于工件提交和评估，因为最后一个在评估期间提供了作者和评审者之间更方便和匿名的通信机制，以持续解决问题！这也促使我们在未来的会议上取消工件评估期间的“技术澄清”会议，因为我们的评审员已经在评估期间与作者进行了沟通！
我们还注意到，我们几年前准备的试图统一 CGO、PPoPP 和 PACT AE 的工件附录模板现在被用于其他会议，包括超级计算(参见这篇SC’17 论文中的工件描述，它将用于 SC’18 的集群竞赛)！作为 ACM 试点项目的一部分，我们计划与集群同事合作，以自动化工件评估并引入工作流框架来将这些工件转换为我们的集体知识格式(参见 SC'16 论文和 CGO'17 文章，工件和工作流以 CK 格式共享)。
最后，我们从过去的 CGO/PPoPP’17 中获得了社区对我们的开放工件评估的非常积极的反馈，我们考虑在未来更多地使用它(参见我们的动机):
- https://github.com/thu-pacman/self-checkpoint/issues/1
- https://git lab . com/Michel-steuwer/CGO _ 2017 _ artifact/issues/1
- https://github . com/SamAinsworth/reproduce-CGO 2017-paper/issues/6
与此同时，我们注意到“可用工件”和“可重用工件”徽章的新策略有几个模糊之处。
在与我们的 ACM 同事协商后，我们更新了http://cTuning.org/ae/reviewing.html的“可用工件”徽章的审核标准:
与本文相关的作者创作的工件只有被放置在公共可访问的档案库中，如芝诺多、菲格舍或得律阿德斯，才能获得 ACM“可用工件”徽章。DOI 将被分配给他们的工件，并且必须在工件附录中提供！作者也可以通过 ACM DL 共享他们的工件——在这种情况下，他们应该联系 AE 主席以获得 DOI(不像上面的库，还没有自动化)。
“工件可重用”徽章的标准变得更加模糊，特别是对于系统研究，在系统研究中，实验工作流经常涉及非常复杂和不断变化的算法/软件/硬件堆栈。许多作者认为，让他们的工件公开一个 ReadME，几个特别的脚本来构建和运行实验，以及一个 Docker 映像就足以获得“工件可重用”的徽章。
每年，我们都看到我们的评估人员承受着各种各样的负担和痛苦，他们要弄清楚如何处理大量临时的、不可移植的、经常失败的脚本、不统一的数据格式和临时验证。这就是为什么我们认为必须使用某种通用的工作流框架，结合跨平台的包管理器和通用的 API，以使工件易于重用、可移植和可定制(参见集体知识、 spack 、 easybuild 等)。).这样的自动化和统一有助于使工件评估在更长的时间内是可持续的，特别是当提交更多工件的时候。
然而，由于我们不想强加我们的观点，并且还没有设法得出令人满意的结论，我们在 CGO/PPoPP’18 的开放工件评估讨论会上开始讨论这些问题。我们还在 CNRS 2017 年的演讲“支持开放和可复制的计算机系统研究:好的、坏的和丑陋的”中描述了其中一些问题和可能的解决方案。
与此同时，我们继续与 ACM 、 Raspberry Pi foundation 和 the community 合作，使用我们的开源集体知识平台改善自动化和实验众包，并通过公共 Python API 和 JSON 元信息将工件和工作流作为可移植、可定制和可重用的组件进行共享。
您可以在我们最近基于 CK 的交互式可复制文章“多目标自动调整和机器学习技术协作研究的集体知识工作流中看到这种“即插即用”工件和工作流的实际例子。它展示了我们的长期教育计划，教导学生如何以协作和可复制的方式，为自我优化的计算机系统进行软件和硬件堆栈的基准测试和共同设计。它通过 GitHub 和 FigShare 将所有工作流、工件和结果共享为可移植、可定制和可重用的 CK 组件，让社区验证、重用、改进和构建它们，同时通过我们的公共 CK 库进行众包实验。此外，我们希望研究人员在反馈指导的编译和自动调优过程中，快速重用和比较特定平台和编译器上常见基准和数据集的共享性能结果，而不是花费大量精力重新构建和重新运行此类实验！
我们也非常高兴能与一流大学联盟(康乃尔、华府、多伦多、EPFL、剑桥)和强大的顾问委员会(http://cKnowledge.org/request)在集体知识平台的基础上组织第一届 ACM 请求锦标赛。这一新颖的竞赛系列专注于在速度、准确性、功耗和成本方面，针对 AI、ML、深度学习和其他新兴工作负载，对整个应用/软件/硬件堆栈进行可重复和 Pareto 高效的共同设计和优化。更重要的是，越来越多的参与者将继续改进通用的和基于 CK 的优化工作流，并共享在从物联网到 HPC 的不同模型、数据集和平台上优化的可移植和可定制的 AI/ML 模块。基准测试结果和获胜的软件/硬件/型号配置将在公共交互式仪表板上显示，并根据特定类别(例如嵌入式与服务器)进行分组。得益于通用的 CK 框架，它们还可以被复制、重用、改进和比较。我们的最终目标是将所有获奖算法和相关工件作为“即插即用”CK 组件与通用 API 共享，让社区立即验证、定制、重用和构建它们，从而消除技术转移差距，实现开放系统/人工智能/人工智能研究！
Collective Knowledge approach to enable efficient and intelligent computer systems
ReQuEST 的第一版将主要作为我们的方法、框架和知识库的测试平台，因此我们决定将提交内容仅限于图像分类的深度学习算法。它将与 ASP los ' 18-ACM 编程语言和操作系统的体系结构支持会议同期举行，这是一个跨计算机体系结构和硬件、编程语言和编译器、操作系统和网络的多学科系统研究的主要论坛。帕累托效率或原始提交的作者将被邀请在相关的 ACM 研讨会上介绍他们的发现。在锦标赛结束时，我们将向我们的顾问委员会提供一份报告，介绍锦标赛的结果、问题、可能的解决方案和后续步骤。
您可以在以下文档中找到有关请求长期愿景的更多详细信息:
- 介绍请求:可再生和高质量系统的开放平台——ML 锦标赛
- 通过开放的合作设计竞赛和集体知识来适应寒武纪的人工智能/软件/硬件爆炸
- 在 ASP los’18上举办的第一届帕累托有效图像分类可再现锦标赛
我们期待在 2018 年与大家合作，实现研究和实验的自动化，提高已发布结果的可重复性，为人工智能和其他新兴工作负载开发高效的系统，加速人工智能/人工智能/系统研究，在人工智能方面取得突破，并使智能系统无处不在！
杂项资源(2017 年)
事件
- SC ' 17的工件评估(使用我们的工件附录模板)
- NIPS 的 17 纸实施挑战
- 用于研究的数字基础设施(2017)
- 亿亿次计算研讨会上的计算再现性(CRE2017)
- 开源超级计算研讨会(OpenSuCo-2017)
- ACM SIGCOMM 2017 再现性研讨会(再现性' 17)
主动权
- ACM 数字图书馆中的工件示例:
- https://dl.acm.org/citation.cfm?doid=2807591.2807619—SC ' 16 纸哪用 集体知识 分享神器
- 【CGO’18 复制包(神器)带链接纸
- *—SC ' 16 纸哪用了* 集体知识 分享神器
- CGO‘18 复制包(神器)
- 开放评论
- ACM 数字图书馆中的人工制品徽章示例
- ACM SIGPLAN 的经验评估清单(测试版)
- 波普尔:实践的可证伪性研究
- 丹麦奥尔胡斯大学推出首个开放科学平台
- OpenNeuro 平台——开放且可复制的科学服务
- 开源软件杂志
- 协同开放计算机科学
- 可再生科学项目
- 用于链接数据的 JSON
- 通用工作流语言，v1.0 ( GitHub )
- 数据科学工作流程:概述和挑战
- 通用工作流语言的自动化工具包装器/转换器
- 在 2017 年 ACM 多媒体系统大会上公开数据集和软件专题
- 下一代测序生物信息学软件的可重复性和综合评估
- code meta 项目
仓库
- 施普林格自然公司的研究数据
- ACM“文物可用”徽章可接受的永久档案:
- 芝诺多
- FigShare
- 得律阿德斯
工具
- 使用集体知识框架的可移植工作流程
- Spack:用于 HPC 的便携式包管理器(我们计划将来连接 CK 和 Spack)
- Scons:一个软件构建工具(我们给 CK 增加了对 Scons 的支持)
- 脸书·巴克(一个快速构建系统)
- 基因组分析工具包 4 (GATK4)作为开源资源加速研究
- NextFlow:一种用于数据驱动计算流水线的 DSL
- LabPal:在电脑上轻松运行实验
- 匿名 Github:一个代理服务器，支持匿名浏览开放科学代码和数据的 Github 库
- 奇点容器
- VC++打包工具
- Google CoLab
- 基准和数据集
- 英国国家高性能计算基准
- Yfcc100m:多媒体研究的新数据
文章
- 关于自动调整和机器学习的交互式和可复制文章示例
- 通过开放的合作设计竞赛和集体知识来适应寒武纪人工智能/软件/硬件爆炸
- 什么是好的博士？作者 Lasse Natvig
- 通过研究透明度应对再现性威胁
- 实证软件工程使用 R
- 机器学习系统中隐藏的技术债务
- 确保计算实验再现性的新方法
- 我为什么要相信你的超级计算研究？
- 通往再现性的艰难道路
- 如何运行实验室进行可重复研究
- 驯服工件再现性的复杂性
- 未来的科学界应该是什么样子？
- Barbagroup 再现性大纲
- 似曾相识:Github 上的代码副本图
- 研究软件项目的可持续性模型指南
- 保持你成功的科学软件存活的 10 种方法
- Linux 基金会发布开放数据许可协议
- 自举博客
- 管理科学
- 真正可复制的科学论文？
- RCE 播客关注科学成果的再现性
- SIAM CSE 17 PP 108 Minisymposterium 上展示的海报:CSE 和数据科学的软件生产力和可持续性
- 我是如何学会停止担忧并热爱科学软件中即将到来的可存档性危机的
- 可复制科学软件:让我们不要有误解
- 对文物和实验的动态监管正在改变数字图书馆的运作方式
- 第一届 IEEE 未来研究监管和研究可重复性研讨会报告 (2016.11)
- CGO/PPoPP 联合工件评估讨论会幻灯片
- 支持开放和可复制的计算机系统研究:好的、坏的和丑陋的
点击查看所有相关资源。
Google Deepmind 对 PixelRNN 的总结
Figure 1: Completion of masked image
简介:
自然图像的分布建模是无监督学习中的一个核心问题，它在图像去模糊、图像压缩、文本到图像的转换等方面都有应用。图 1 显示了如何使用 pixelRNN 模型来完成图像。
变分自动编码器、GANs 和自回归模型是三种可用的图像生成方法。这篇文章关注自回归，特别是 pixelRNN。
为什么是 RNN？
在图像中，通常一个像素依赖于所有先前预测的像素，这导致像素之间产生长程相关性。因为 RNNs 已被证明在具有长范围相关性的时间序列预测中是有效的。因此，RNN 用于生成图像中的像素。
在本文中，像素生成的顺序是由作者确定的——从上到下和从左到右(图 2)。(注意:可以有许多可以预测像素的序列，但是需要预先选择其中的一个。)
Equation 1: Probability of predicting an image
Figure 2
在等式 1 中，p( x )表示预测图像的概率( x )，其等于给定所有先前预测的像素的条件概率 x i 的乘积。
Equation 2
等式 2 表示在给定先前生成的像素的情况下预测像素 x i 的 R、G、B 值的概率。在像素 x i 的预测中，包括先前预测像素的 R、G、B 值。在 x i，G 的预测中，预测值 x i，R 也与先前生成的像素的 R，G，B 值一起被包括。
图像生成中的 LSTM 图层:
LSTM 层以前已经用于图像生成。他们逐个像素地训练图像。考虑到图像数据集中的像素数量，训练 LSTM 需要大量的时间。
隐藏状态(I，j)=隐藏状态(i-1，j)，隐藏状态(I，j-1)，p(i，j)
像素(I，j)的隐藏状态取决于像素(I，j-1)和像素(i-1，j)的隐藏状态。因此，除非计算出先前像素的隐藏状态，否则无法计算像素(I，j)的隐藏状态。因此，在计算隐藏状态时不可能有并行化，因此也不会节省训练时间。
作者引入了两种类型的 LSTM 层来克服上述问题:行 LSTM 和对角 LSTM
排 LSTM:
隐藏状态(I，j) =隐藏状态(i-1，j-1)，隐藏状态(i-1，j+1)，隐藏状态(i-1，j)，p(i，j)
Figure 3: Computing hidden state of red pixel; blue pixels are part of the triangular context
如图 3 所示，一个像素的隐藏状态直接取决于它上面 3 个像素的隐藏状态。这 3 个像素又分别直接依赖于其他 3 个像素。因此，像素的隐藏状态具有三角形上下文(图 3)。这个三角形上下文可以被视为用于预测像素值的“历史”。
如图 3 所示，在红色像素之前预测的几个像素不包括在三角形上下文中。因此，用于计算红色像素值的“历史”不包括所有先前生成的像素。这可以被称为“上下文丢失”。像素的隐藏状态取决于它上面的 3 个像素，而不取决于它所在行中的任何像素。因此，可以并行计算同一行中所有像素的隐藏状态。
因此，行 LSTM 解决了如在 LSTM 中的高训练时间的问题，但是产生了用于计算像素的隐藏状态的不完整“上下文”的问题。
对角线 BLSTM:
Figure 4: Computing hidden state of red pixel; blue pixels are part of the context
对角 BLSTM 的引入是为了解决行 LSTM 中“上下文”不完整的问题。在对角线 BLSTM 中，像素(I，j)的隐藏状态取决于像素(I，j-1)和像素(i-1，j)。由于双向 LSTM 覆盖了前向和后向相关性，所有先前生成的像素都包括在用于预测像素值的“上下文”/“历史”中。
像素 CNN:
行和对角线 LSTM 层覆盖图像中的长程相关性。由于 LSTM 层的复杂性质，学习长程相关性需要计算成本。标准卷积层可以捕捉一个有界感受域，并同时计算所有像素位置的特征。保持图像的空间信息很重要；PixelCNN 中不使用池层。为了避免在像素预测中使用未来上下文(未来像素)，在 PixelCNN 中使用了遮罩。
掩蔽卷积:
Figure 5: Value of pixel xi depend on values of previous pixels
Figure 6: Mask to zero out the future pixel values.
将所有不可用于模型的像素值清零。
像素 x i 只取决于像素 x 1…xI 1，因此我们必须确保它不会访问后续像素:x i+1。。x n^2
作者在论文中使用了两种类型的掩码，即掩码 A 和掩码 b。
面具 B:
Figure 7: Mask B
如前所述，保留空间信息对于精确预测像素值非常重要，因此 PixelCNN 中不使用池层。因此，在网络中不会发生图像的上采样或下采样。因此，在整个网络中，图像必须具有 R、G、B 值，在本文中，掩码 B 用于此目的。
Figure 8: Convolution without using mask B
如图所示，如果在卷积期间不使用掩码 B，则输出特征图中的通道数与输入不同。
Figure 9: Convolution with using mask B
使用屏蔽 B(图 7)，卷积的输出也将 R、G、B 通道作为输入。
盲点问题:
PixelCNN 减少了行 LSTM 和对角线 BLSTM 中所需的计算成本，但是存在盲点问题。盲点问题基本上不包括用于计算像素隐藏状态的上下文/历史中的所有先前像素。我们稍后将深入探讨盲点问题。
使用 PixelRNN 的图像完成:
SegNet 概述:一种用于图像分割的深度卷积编解码器架构
论文发表者:Vijay Badrinarayanan、Alex Kendall、Roberto Cipolla 在 CVPR 第 15 届年会上发表
Some videos I used to play around with SegNet
欲了解更多关于复制这一点的信息，请访问我的回购 这里
TLDR:
- 使用一种新颖的技术来对编码器输出进行上采样，该技术涉及存储池层中使用的最大池索引。这提供了相当好的性能和空间效率
- 仅具有前向连接和不可训练层的 VGG16 用作编码器。这导致参数非常少。
问题
- 语义逐像素标记，即将图像的每个像素标记为属于图像中所示的某个类别(树、道路、天空等)。
Fig 1: Segmentation of a road scene imagess
一些应用包括自动驾驶、场景理解等。直接采用分类网络进行逐像素分割会产生较差的结果，这主要是因为最大池和子采样会降低特征图分辨率，从而降低输出分辨率。即使外推至原始分辨率，也会产生有损图像。
SegNet —挑战
- 在道路场景数据集上训练，因此，类表示宏观对象，因此期望分割是平滑的
- 边界信息对于像道路标记和其他小物体这样的物体是至关重要的。(边界划定
- 主要用例将是嵌入式系统，因此它必须计算高效
SegNet-架构
编码器-解码器对用于为不同分辨率的分类创建特征图。
Fig 2: Nut-shell architecture
编码器
- 13 个 VGG16 Conv 层
- 没有完全连接，这将参数从 134 米减少到 14.7 米
- 良好的初始权重是可用的，因此这些层是不可训练的
Fig 3: Encoder architecture
每个编码器如图 3 所示。新颖性在于二次采样阶段，最大池用于实现图像中小空间位移的平移不变性，将其与二次采样相结合，导致每个像素管理一个更大的输入图像上下文(空间窗口)。这些方法实现了更好的分类精度，但是减小了特征图的大小，这导致了具有模糊边界的有损图像表示，这对于分割目的来说是不理想的。希望输出图像分辨率与输入图像相同，为了实现这一点，SegNet 在其解码器中进行上采样，为此它需要存储一些信息。在子采样之前，需要捕获并存储编码器特征图中的边界信息。为了有效地利用该空间，SegNet 只存储最大汇集索引，即每个汇集窗口中最大特征值的位置是为每个编码器映射存储的。2x2 的每个窗口只需要 2 位，精度略有损失，但是折衷。
优势
- 改进的边界划分
- 参数数量较少
Fig 4: Upsamplig in SegNet
这种形式的上采样可以结合到任何编码器-解码器架构中
解码器
- 对于 13 个编码器中的每一个，都有一个相应的解码器，该解码器使用存储的最大池索引对特征图进行上采样
- 生成更高分辨率的稀疏特征地图
- 稀疏地图通过可训练滤波器组生成密集特征地图
- 最后一个解码器连接到对每个像素进行分类的 softmax 分类器
SegNet 论文将其技术与其他几种解码器进行了比较，如图 5 所示。
Fig 5: Several decoders compared
最初发布于say tosid . github . io。
强化学习中的表格方法综述
强化学习中不同列表方法的比较
更新:学习和练习强化学习的最好方式是去 http://rl-lab.com
介绍
表格方法指的是这样的问题，其中状态和动作空间足够小，以至于近似值函数可以表示为数组和表格。
问题是
强化学习的目的是找到以下方程的解，称为贝尔曼方程:
我们解贝尔曼方程的意思是找到使状态价值函数最大化的最优策略。
由于很难得到解析解，我们使用迭代方法来计算最优策略。最佳状态和动作值函数表示如下:
动态规划
动态规划是一种方法，其中通过将周围状态的值作为输入来计算状态下的每个值(不管这些值是否准确)。一旦计算了一个状态的值，我们就转移到另一个状态，并重复相同的过程(考虑在先前状态中计算的任何新值)。
这个过程重复足够多次，直到每个状态的变化小于我们定义的某个极限。
更多关于 DP 学习的内容可以在文章《强化学习中的动态编程，简易方法》中找到
赞成的意见
DP 是有效的，在大多数情况下，它能在多项式时间内找到最优策略。
DP 保证找到最优策略。
骗局
DP 不适合处理有数百万或更多状态的大问题。
DP 需要转移概率矩阵的知识，然而这对于许多问题来说是不现实的要求。
蒙特卡洛
在蒙特卡罗(MC)中，我们玩游戏的一集，在各种状态中逐一移动，直到结束，记录我们遇到的状态、动作和奖励，然后计算我们经过的每个状态的 V(s)和 Q(s)。我们通过播放更多的剧集来重复这个过程，在每一集之后，我们得到状态、动作和奖励，并且我们对发现的 V(s)和 Q(s)的值进行平均。
MC 预测算法包括播放尽可能多的剧集，并在每集之后计算我们已经经过的状态的值，然后将这些结果与这些状态的当前值进行平均。
保单首次就诊 MC 控制旨在找到最佳保单。它会播放剧集，但会跟踪每个状态下使用的每个动作。这样，就有可能知道什么动作产生了最佳 Q 值。
最后，将具有最大 Q 值的行动添加到最佳策略中。
蒙特卡罗的详细解释可以在文章《强化学习中的蒙特卡罗，简易方法》中找到
赞成的意见
MC 可以用来直接从与环境的交互中学习最优行为。它不需要环境动力学的模型。
MC 可用于模拟或样本模型。
MC 可用于聚焦于一个特别感兴趣的区域，并且被准确地评估，而不必评估状态集的其余部分。
骗局
MC 只适用于偶发(终止)环境。它不适用于没有终止状态的环境。
MC 必须有一个完整的情节，它没有引导，这意味着它没有给出其他状态的估计。
MC 必须等到一集结束才知道回归。对于长时间发作的问题，这将变得太慢。
时间差异
TD 可以看作是 DP 和 MC 方法的融合。它播放剧集但不必等到结尾才知道回报。它根据对其他状态的估计来计算当前状态的值。
TD(0)是指只向前看一步的事实，然后计算当前状态值。
为了找到最优策略，TD 提供了不同的方法，其中之一是 SARSA。
SARSA 包括对状态 S 采取行动 A，注意奖励和下一个状态 S’，然后从状态 S’中选择行动 A’，然后使用所有这些信息更新 Q(S，A)，然后移动到 S’并执行之前选择的行动 A’。
Q-learning 是寻找最优策略的另一种方法。
像 SARSA 一样，它对状态 S 采取行动 A，注意奖励和下一个状态 S’，然后与 SARSA 不同，它选择状态 S’中的最大 Q 值，然后使用所有这些信息来更新 Q(S，A)，然后移动到 S’并执行ε贪婪行动，这不一定导致采取在状态 S’中具有最大 Q 值的行动。
双 Q 学习是一种解决 Q 学习中特定问题的算法，特别是当 Q 学习可以基于一些积极的奖励被诱骗采取坏的行动，而这个行动的预期奖励肯定是负的。
它通过维护两个 Q 值列表来做到这一点，每个列表从另一个列表更新自身。简而言之，它在一个列表中找到最大化 Q 值的动作，但是它不是使用这个 Q 值，而是使用这个动作从另一个列表中获得 Q 值。
要了解更多关于 TD 学习的细节，请查看文章“ TD 在强化学习中，简单的方法”。
关于双 Q 学习的更多细节可以在“双 Q-学习简单方法”中找到
赞成的意见
TD 不需要像 DP 中那样知道转移概率矩阵。
TD 不需要等到剧集结束才知道回报，它增量更新状态值和动作值。
骗局
SARSA 可能会陷入局部最小值。
Q-Learning 在一些随机环境中表现不佳。
参考
算法取自萨顿和巴尔托。强化学习:导论。
知识图嵌入的翻译模型综述
本文旨在对知识图嵌入/知识表示的翻译模型做一个简要的总结。可以从TensorFlow-TransX找到开源 tensor flow 代码。
知识表示的一些背景
通常，我们用一个三元组(头、关系、尾)来表示一个知识。在这里，头和尾是实体。比如，(天空树，地点，东京)。我们可以用独热向量来表示这些知识。但是实体和关系太多，维度太大。并且如果两个实体或关系是接近的，则单热点向量不能捕获相似性。受 Wrod2Vec 模型的启发，我们想用分布式表示来表示实体和关系。
下游任务中的应用
以防万一，如果你不熟悉知识图，我会介绍一些知识图可以做的应用。
链接预测
链路预测通常是指预测一个与另一个给定实体有特定关系的实体的任务，即预测给定(r,t)或给定(h, r)的t，前者表示为(?,r,t)，后者表示为(h,r,?)。例如，(?, DirectorOf,Psycho)是预测电影的导演，而(Venom, DirectorOf,?)相当于预测那个特定的人导演的电影。这本质上是一个知识图完成任务。
推荐系统
推荐系统向用户提供关于他们可能希望购买或检查的项目的建议。在不同的推荐策略中，协同过滤技术取得了显著的成功。然而，并不总是工作得很好，因为用户-项目交互可能非常稀疏。在这种情况下，结合用户-项目交互和用户或项目的辅助信息的混合推荐系统通常可以实现更好的性能。
知识图也被用来提高协同过滤的质量。具体来说，他们使用存储在 KG 中的三种类型的信息，包括结构知识(三重事实)、文本知识(例如，一本书或一部电影的文本摘要)和视觉知识(例如，一本书的封面或一部电影的海报图像)，来导出项目的语义表示。为了对结构知识建模，应用典型的知识图嵌入技术，即 TransR，其学习每个项目的结构表示。对于其他两种类型的信息，堆叠去噪自动编码器和堆叠卷积自动编码器分别用于提取项目的文本表示和视觉表示。
知识图嵌入还有一些应用，比如实体解析、关系抽取、问题回答等。你可以从这篇论文中找到更多信息:知识图嵌入:方法和应用调查(2017)。
迷睡
标题:TranslatingEmbeddings 用于多关系数据建模(2013)
这是翻译模型系列的第一部作品。该模型的基本思想是使首向量和关系向量之和尽可能接近尾向量。这里我们用 L1 或 L2 范数来衡量他们有多接近。
损失函数是负抽样的最大利润。
L(y，y') = max(0，margin -y + y ')
y是阳性样本的分数，y'是阴性样本的分数。最小化这个损失函数分数。两个分数之差和 margin 一样大就够了(我们设置这个值，通常是 1)。
因为我们用距离来表示分数，所以我们在等式上加一个减号，用于知识表示的损失函数是:
d 是:
这是 L1 或 L2 的标准。至于如何得到负样本就是用三元组中的随机实体替换头实体或尾实体。
参见代码:
使用embedding_lookup得到头部、关系、尾部的向量，并计算(头部、关系)和尾部之间的距离。
但是这个模型只能处理一对一的关系，不适合一对多/多对一的关系，比如有两个知识，(skytree, location, tokyo)和(gundam, location, tokyo)。训练后,‘天空树’实体向量将与‘高达’实体向量非常接近。但是他们在现实中并没有这样的相似性。
转运
标题:在 H 超平面上转换嵌入知识图(2014)
TransH 的目标是处理一对多/多对一/多对多的关系，并且不增加模式复杂度和训练难度。
基本思想是将关系解释为超平面上的平移操作。每个关系有两个向量，超平面的范数向量 (Wr)，以及超平面上的平移向量(dr)。
我们将每个头向量(h)和尾向量(t)投影到超平面，并得到新的向量(h⊥和 t⊥).在这个超平面中存在一个关系(d_r ),我们可以像 TransE 模型一样训练它。
分数函数:
如何计算超平面中的投影:
其中 w_r 的范数被限制为 1。
h⊥ 是 h 在超平面中的投影， wrT 是 h 在 wr 中的投影。这意味着我们将头尾向量分解成两部分。
损失函数和训练方法与 TransE 相同。
我们将头/尾向量分解成两部分，并且仅使用一部分(h⊥或 t⊥)来训练模型。这样可以避免模型训练时两个实体(头部或尾部)靠得太近，处理好一对多/多对一/多对多的关系。
代码与 TransE 模型几乎相同。唯一的区别是计算投影向量的步骤。在这一步之前，我们应该将 w_r 归一化为长度 1。
TransR
题目:知识图完成的学习实体和关系嵌入(2015)
TransE 和 trans 模型都假设实体和关系是语义空间中的向量，因此相似的实体在同一个实体空间中会彼此靠近。
然而，每个实体可以有许多方面，不同的关系关注实体的不同方面。比如(location, contains, location)的关系是‘包含’，而(person, born, date)的关系是‘出生’。这两种关系非常不同。
为了解决这个问题，我们让 TransR 在两个不同的空间中建模实体和关系，即实体空间和多重关系空间(特定于关系的实体空间)，并在相应的关系空间中执行翻译，因此命名为 TrandR。
TransR 的基本思想如图 1 所示。对于每个三元组(h，r，t)，实体空间中的实体首先用操作 Mr 作为 hr 和 tr 投影到 r-关系空间中，然后 hr + r ≈ tr。损失函数和训练方法同 TransE。 h 和 t 是实体嵌入， r 是关系嵌入。
特定于关系的投影可以使实际保持关系的头/尾实体(表示为彩色圆)彼此靠近，并且远离那些不保持关系的头/尾实体(表示为彩色三角形)。
得分函数和目标函数与 TransE 相同。
TransR 有一个变种模型，叫做 CTransR，C 的意思是集群。首尾相连的实体通常表现出不同的模式。仅构建单个关系向量来执行从头到尾实体的所有翻译是不够的。比如三联(location, contains, location)有国家-城市、国家-大学、洲-国家等多种模式。为了解决这个问题，CTransR 将不同的头尾实体对聚类成组，并为每个组学习不同的关系向量。
构造 CtransR 的过程是，对于一个特定的关系 r，将训练数据中的所有实体对 (h，t) 聚类成多组，期望每组中的实体对表现出相似的 r 关系。我们使用向量偏移量( h-t )来表示实体对 (h，t) 。我们从 TransE 得到 h 和 t 。之后，我们分别学习每个聚类的独立关系向量 r_c 和每个关系的矩阵 Mr。
当我们创建负样本时，我们只替换头部或尾部，而不替换关系。这样我们就分别得到了正样本和负样本的两个变换矩阵。除了我们先用矩阵变换变换实体向量，然后计算 L2 范数，其余的代码与 TransE 基本相同。
TransD
标题:通过 D 动态映射矩阵嵌入知识图(2015)
TransR 也有其不足之处。
- 首先，头部和尾部使用相同的变换矩阵将它们自己投影到超平面，但是头部和尾部通常是不同的实体，例如，
(Bill Gates, founder, Microsoft)。‘比尔盖茨’是一个人，而‘微软’是一家公司，这是两个不同的范畴。所以应该用不同的方式改造。 - 第二，这个投影与实体和关系有关，但投影矩阵只由关系决定。
- 最后，TransR 的参数个数比 TransE 和 TransH 的大。由于复杂性，TransR/CTransR 很难应用于大规模知识图上。
TransD 使用两个向量来表示每个实体和关系。第一个向量表示实体或关系的含义，另一个向量(称为投影向量)将用于构建映射矩阵。
两个映射矩阵定义如下:
其中映射矩阵由实体和关系定义， I 是单位矩阵。该等式意味着我们使用生成的矩阵(通过 r 和 h 向量)来修改单位矩阵。投射和训练与 TransR 相同。
TransE 是 TransD 的一个特例，当向量的维数满足 m=n 且所有投影向量都设置为零时。
代码结构可能与其他模型类似。我们可以看到每个实体和关系都由两个向量表示。但是该代码没有实现实体空间的维度与关系空间的维度不同的情况。
模型摘要
利润损失适用于所有型号。所有这些模型都是基于 TransE 的，使用头部向量和关系向量的和来预测尾部向量。这些模型的不同之处在于它们使用不同的方式来表示实体/关系向量。
评估结果
这是数据集 FB15k 和 WN18 中各种方法的结果。
你可以找到更多关于数据集和代码的细节， thunlp/KB2E 用 C++实现，TensorFlow 版本， TensorFlow-TransX 。
最后的
每个型号都有自己的招数，这里就不多说了。
正如我在模型总结部分所说。这些模型的基本思想是相同的，都是利用头部向量和关系向量的和来预测尾部向量。向量的和就是信息的积累。但是实体和关系可能比这更复杂。寻找一种更有效的方法来表示知识可能是一个具有挑战性的研究课题。
查看我的其他帖子 中等 同 一分类查看 ！
GitHub:bramble Xu LinkedIn:徐亮 博客:bramble Xu
周日早晨的洞察力:卡西尼号的灭亡和人工智能的兴起
在过去的几周内，发生了两件与整个人工智能叙事相关的事件:卡西尼号坠入土星而号取消了会议注册，时间之长前所未闻。
通常，人工智能叙事围绕着一个因素，然后解释为什么这个领域不能继续下去，因为这个因素不是新的，不再是好的，不是什么……这种叙事是由科技评论推出的，当时它提到人工智能可能会停滞不前,因为“神经网络”已经有三十年或更长的历史了。是的，神经网络已经存在了很长时间，没有人工智能不会停滞不前，因为它实际上取决于几个因素，而不是一个。
这是其中一个因素的故事。
这在很大程度上要归功于太空探索，不，我们不是在谈论令人敬畏的深空 1 号宇宙飞船[1],尽管它很像那艘宇宙飞船，但这个故事也始于 JPL。
当丹·戈尔丁成为美国国家航空航天局局长时，他对新的太空任务施加了一系列的限制，使得整个美国国家航空航天局在设计成本较低的太空任务时更快地整合更新、更好的技术。事实上，卡西尼号被视为任务的未来规避者。从 JPL 网站上讲述的故事中，在“更快、更好、更便宜”的口号下，我们可以读到:
由于没有找到大幅削减成本的方法，JPL 面临着灭亡。美国宇航局的预算将不会支持足够的卡西尼规模的任务，以保持实验室的运作。
在那之前，太空任务中的绝大多数相机都使用 CCD 设备。虽然这项技术提供了高质量的图像，但它很脆弱。首先，它需要冷却以获得良好的信噪比。这种冷却反过来意味着成像仪需要更多的电力来运行，并可能在发射阶段更系统地出现故障。这也是一种基于行的设计，意味着你可能会一次丢失一整行像素。简而言之，它很脆弱，更重要的是，这项技术使传感器变得更重，这是太空探索中的一个大罪。
然后是埃里克·福萨姆。这是你可以在的维基百科条目上读到的内容:
….仪器的目标之一是使星际航天器上的电荷耦合器件(CCD)照相机系统小型化。作为回应，Fossum 发明了一种新的 CMOS 有源像素传感器 (APS)，采用像素内电荷转移片上相机技术，现在只称为 CMOS 图像传感器或 CIS【5】【6】(没有像素内电荷转移的有源像素传感器在更早以前就有描述，由 Noble 于 1968 年提出。作为戈尔丁尽可能将空间技术转移到公共部门的指示的一部分，Fossum 领导了 CMOS APS 的开发以及随后向美国工业的技术转移，包括伊士曼柯达公司、贝尔实验室、国家半导体公司和其他公司。尽管根深蒂固的 CCD 制造商最初持怀疑态度，但 CMOS 图像传感器技术现已用于几乎所有的手机相机、许多医疗应用，如胶囊内窥镜和牙科 x 射线系统、科学成像、汽车安全系统、DSLR 数码相机和许多其他应用。
由于 CMOS 依赖于计算芯片中使用的相同工艺，它的规模很大，变得非常便宜。事实上， 大规模的 图像和视频数据集的创建是由 YouTube、Google、Flickr 和 Yahoo！InstaGram，然后是脸书和大多数其他互联网公司，由于 CMOS 在消费成像领域的到来，首先是在相机领域，然后是在智能手机领域，而变得独一无二:
这些数据集的规模使得能够训练玩具模型之外的非常大的神经网络。基于神经网络和大型数据集的新算法开发将错误率降至这样一个水平，即大型互联网公司很快就可以开始对自 21 世纪初以来在其服务器上收集的数据使用这些技术。
2017 年 9 月 14 日，卡西尼正在下载其最后一张基于 CCD 的图像，NIPS(最知名的 ML/DL/AI 会议之一)的所有注册在会议前三个月售罄:这是一个专家会议闻所未闻的壮举。会议将在离 JPL 不远的长滩举行，不知何故，启动这一切的传感器就诞生在这里。
**
还有一件事: Eric Fossum 正在构建QIS，下一代成像传感器【3】将产生 更多 像素…..
这个故事最初是在 Nuit Blanche 上播出的。
笔记。
[2]如今每个人都在使用的 TRL 标度(第一次用法语翻译是在 Nuit Blanche 号卫星上)就是在那个时候诞生的，这样美国宇航局就可以评估哪些技术可以更快地整合到太空任务中。
[3]查看我们关于 QIS 和压缩传感的讨论。
超级简单的机器学习—多元线性回归第 1 部分
在这篇超长的文章中，我简要描述了多元线性回归的工作原理以及你需要注意的标准。所以给自己找些水和零食，因为这需要一段时间。
大部分的基本概念都包含在我的简单线性回归帖子中，这些帖子可以在 她的 e 中找到。我曾打算在一篇帖子中快速涵盖 MLR，但实在有太多的事情要解决。叹气。
多元线性回归是简单的线性回归，但是有更多的关系(更多的 x。更多前任。哈哈。)
这就像当你的姐姐有了一个婴儿，他曾经是房子里所有噪音的唯一贡献者，但后来她又有了两个，现在这三个都是噪音的贡献者。
成为
A multiple linear regression with 2 more variables, making that 3 babies in total. Too many babies.
多元线性回归解释了一个连续因变量 ( y )和两个或多个自变量 ( x 1， x 2， x 3…等)之间的关系。
请注意，它显示的是连续的因变量。由于 y 是 beta 、 beta 1 x 1、 beta 2 x 2 等之和，因此得到的 y 将是一个数字，一个连续的变量，而不是一个“是”、“否”的答案(分类)。
例如，使用线性回归，我将试图找出产生了多少分贝的噪音，而不是噪音是否有(噪音|无)。
为了找到分类变量(例如“是或“否”、“ 1 或“ 0 ”)，将使用逻辑回归。我下次会谈到这一点。
让我们从数据开始
到处都可以找到测试代码的数据集。
sklearn 有玩具数据集用于不同类型的算法(回归、分类等),非常适合实践。Kaggle 还有现实生活中的数据集。
请注意，在野外，当您遇到数据集时，它将是一个丑陋的 AF。它会有丢失的值、错误的条目、格式错误的列、不相关的变量……甚至在清理之后，可能你的 p 值看起来很糟糕，你的 R 平方太低。你需要选择好的特征，尝试不同的算法，调整你的超参数，添加时间延迟，转换列的数据…
在现实生活中，运行一个模型并不是那么简单，这就是为什么人们做这件事会得到很多报酬，这样他们就可以资助他们的头皮治疗，以从压力引起的脱发中恢复过来。
Exploring a dataset is like surfing along the coast of Cinnabar Island… you’ll find MissingNo(s). badum tss
分类变量>>>连续变量
由于回归方程的性质，你的 x 变量也必须是连续的。因此，你需要把你的分类变量变成连续变量。
连续变量简单来说就是流水号。分类变量是类别。
当你的分类变量在第一次连续出现时，会有点混乱。
例如，如果有一列邮政编码或电话号码会怎么样？
Continuous at first glance, but actually categorical.
每个邮政编码代表一个唯一的地址，每个电话号码只是一个唯一的联系号码。增加/减少这个数字没有任何意义——它们只是没有内在数值的标识符，因此,被认为是分类的。
分类变量也被称为离散或定性变量。有 3 种类型:
- 标称:2 种以上。例如颜色
- 二分的:两种类型，例如是或否
- 顺序:多于两种类型，但有一个等级/顺序，例如低于平均值、平均值、高于平均值
我们该拿他们怎么办？
有几种方法将分类数据转换成可用于回归的连续变量。
标签编码器:
对于二分变量
对于二分变量的简单解决方案是将其转换为二进制——“1”表示“是”,“0”表示“否”,反之亦然。您的标签应该从 0 开始。
名义变量和序数变量稍微麻烦一点。
对于名义变量
假设你有三种不同的颜色:红色、蓝色和灰色。按照上面的概念，你把红色标为 0，蓝色标为 1，灰色标为 2。
这样做的问题是，它意味着灰色比红色和蓝色更高级，蓝色比红色更高级，如果你认为所有三种颜色都具有相同的“价值”，这些颜色中没有一种比另一种更高级。
Reckless labelling can lead to disastrous consequences (The Office S3 E1)
对于序数变量
带标签的“排名”对顺序变量更有效，因为它们确实有排名，并且应该被赋予不同的权重。
当面对不应有不同权重、的标称变量时，首选一个热编码。
一个热编码/创建虚拟变量:
为了不给处于相同竞争环境的类别任何不相等的值，我们使用一个热编码。这是通过创建虚拟变量来实现的，这意味着创建更多的“x”s。这些将是假的/虚拟的变量，因为它们是实际变量的占位符，并且是由您自己创建的。
很简单。对于变量所在的每一层，只需为每一层创建一个新的 x。
easy peasy
等等……格雷呢？
如果你的变量只能是 3 种颜色，那么你只能使用 2 个虚拟变量。灰色成为参照类别，在你的 X (蓝色)和 X (红色)都为 0 的情况下，则默认变量为灰色。
您选择排除哪个变量并将其用作参考类别有关系吗？
不会。但最佳实践是使用最常出现的类别(例如，如果数据集的 70%是灰色的，那么灰色将是参考类别)。
合并级别:
回到邮政编码这一栏，假设您有 500 行客户，它们都有自己唯一的邮政编码。对 500 个不同的邮政编码进行热编码有意义吗？
这将向您的数据集中添加 500 列，使您的模型变得混乱，并使您患上偏头痛。
这也是毫无意义的，因为每个邮政编码都是唯一的。它没有给你的模型增加洞察力，因为你如何使用这样的信息来预测新数据的结果？如果您需要预测居住在邮政编码 323348 的人的收入水平，如果您的数据集中没有这样的邮政编码，您的模型将如何处理呢？它从来没有见过这个邮政编码，也不能告诉你任何关于它的信息。
你所能做的是将转换成你可以用来对未来数据进行分类的东西，比如按照它们的区域对这些邮政编码进行分组(这些数据不在数据集中，但需要来自领域知识或研究)。
what is this, tables for ants?! Apologies for the tiny font.
所以你得到的不是 500 不同的邮政编码，而是 4 个地区，北部、南部、东部或西部(或者根据你想要得到的具体程度，它可以是实际的地区，如后港、义顺、贝多克、果园等。这些是新加坡的地区名称)。
这意味着如果新的数据出现在你需要预测结果的地方，你可以根据新的邮政编码属于哪个区域来预测 y 。
有意义的标签:
有一点要时刻牢记，不要盲目贴标签。
它必须有意义。
例如，在对序数变量(有秩的分类变量)进行编码时，必须确保秩值对应于每个秩的实际显著性(也可以看作是它与因变量的关系)。
例如，如果你正在出售一栋房子，而 y = 价格，而 x 变量之一是公寓所在的楼层，如果楼层随着楼层的升高而涨价，则将楼层编码为整数是有意义的:
Encoding it this way is appropriate to show its relationship with the Y variable (price)
然而，如果该值没有相应地增加，也许一个热编码和合并级别会更合适:
或者
或者如果你不知道这是什么关系:
One hot encode everything!!!! There are packages that can do this for you, don’t worry.
永远确保无论你如何转换你的分类变量，确保你回头看它，问自己“这有意义吗？”
有时没有正确的答案，所以问题就变成了“这样做是否让更有意义？”
可能会变成，“但是什么有意义？”并引出“什么是意义？”变成了“是什么？”然后进入一周的存在主义虚无主义。
底线是:了解你的数据
特征选择
变量过多可能会导致模型变得不准确，尤其是当某些变量对结果没有影响或对其他变量有显著影响时。
Variables that have no significant effect or high collinearity can ruin the model
让我们以三个婴儿的尖叫为例。如果我要对我的回归方程建模，以找出基于这 4 个变量产生的噪音分贝数=婴儿 1、婴儿 2、婴儿 3、灯(开或关)，这将不是一个好的模型。这是因为我的蜘蛛感官告诉我，灯不应该产生噪声，因此灯和噪声之间的任何可能的相关性都是虚假和不准确的。
功能选择的基本步骤:使用您的常识和/或商业感觉
选择要素的另一种方法是使用 p 值。正如我们上一次讨论时，p 值告诉您变量的统计显著性。移除具有高 p 值的变量会导致您的精确度/R 平方增加，甚至其他变量的 p 值也会增加——这是一个好迹象。
这种省略变量的行为是逐步回归的一部分。有三种方法可以做到这一点:
- 正向选择:从 0 开始。反复运行模型，尝试每个变量。找到给出最佳指标的变量(例如 p 值、调整后的 R 平方、SSE、准确度百分比)，并坚持使用它。使用选择的变量再次运行模型，每次尝试剩余变量中的一个，并坚持使用最佳变量。重复该过程，直到添加不再改善模型。
- 逆向淘汰:从所有变量开始。多次尝试模型，每次排除一个变量。当遗漏变量时，移除使模型改进最多的变量。在不移除变量的情况下重复该过程，直到您所判断的指标不再提高。
- 双向淘汰:进行正向选择，但在某些阶段也进行反向淘汰。因此，你可以在一个阶段，你已经添加了 X1，X2，X5 和 X8，然后做消除 X2。这是一个很好的例子。
一些了不起的人创造了 R 和 Python 包，它们自动完成这些过程，根据特定的度量标准(如调整后的 R 平方或 AIC 或 p 值)选择“最佳模型”。这里的 都是我找到的 的一些。
注意:逐步回归是一种快速获得更好评分模型的方法，尤其是在运行简单模型时。它被广泛使用，但是 也被广泛批评 不准确。我一直被教导使用逐步，所以我很想听听你的意见。
逐步回归的替代方法是 LASSO(最小绝对收缩和选择算子)方法，我将在下一次介绍。或者你可以在这里读到它。
相关性和共线性
检查共线性有助于通过与另一个变量有显著关系来消除扭曲数据的变量。
变量之间的相关性描述了两个变量之间的关系。如果它们是极相关，那么它们就是共线。
自相关 发生在一个变量的数据影响到同一个变量的另一个实例(同一列，不同行)时。只有当数据集中很少或没有自相关，并且每个实例相互独立时，线性回归才有效。如果实例是自相关的，那么您的残差不是相互独立的，并且将显示一个模式。这通常发生在时间序列数据集中，所以当我介绍时间序列回归时，我会更详细地介绍。
In stock market data, based on prices at a certain time, you can roughly guess what the prices will be in the future following that, showing the dependancy of the future instance on the previous one.
当回归模型中的两个或多个预测值( x 变量)中度或高度相关时(不同列)，存在多重共线性。当我们的一个预测者能够强有力地预测另一个预测者或者彼此之间有怪异的关系(可能是 x 2 = x 3 或者x2 = 2(x3)+x4)，那么你的回归方程将会变得一团糟。
Multicollinearity: One x variable = Orange colour, Other x variable = number of oranges. They would be highly correlated as the number of oranges affects the orange-ness of the juice. Orange you pleased with this simple analogy?
为什么多重共线性是回归的一个问题？嗯，回归方程是代表预测值和因变量影响的最佳拟合线，而不包括一个预测值对另一个的影响。
预测值之间的高度共线性(相关性为 1.00)将影响您的系数和准确性，以及降低 SSE(误差平方和-您需要通过回归最小化的东西)的能力。
Example of a correlation plot taken from https://www.mathworks.com/help/econ/corrplot.html comparing 5 variables with each other
检测共线性的最简单的方法是用图表示出来，或者查看相关矩阵来检查成对的相关性(两个变量之间的相关性)。
如果你有两个高度相关的变量，你最好的办法就是去掉其中一个。
共线性正在影响你的回归生活的 4 大迹象——你会被第 3 个震惊！
- 当你的系数( bx 中的 b )为负时，但你从常识和商业知识中知道该变量的作用应该是正的。或当系数过小时对于一个应该有更大影响的变量。
- 当你用那个 x 变量运行一个模型，而你不用那个 x 变量运行另一个模型，这些模型的系数完全不同。
- 当每个单独斜坡的t-测试不显著，但总的F-测试显著时。这是因为多重共线性导致一些变量看起来没有用，因此降低了 t-stat，但对总体来看的 F-统计量没有影响。
- 当你的 VIF 偏离图表是 5 或更多
VIF 是什么国家？！
VIF:差异通货膨胀系数
VIF 是从模型中导出的系数的方差被共线性夸大了多少的度量。它有助于检测仅通过目测两两相关图无法发现的多重共线性，甚至可以检测 3 个或更多变量之间的密切关系。
它是通过[所有系数的方差]除以[当一个变量是模型中唯一的变量时，该变量的系数的方差]的比率来计算的。
VIF = 1:预测值和其他变量之间没有相关性
VIF = 4:可疑，需要调查
VIF = 5-10:“休斯顿，我们有一个问题。”调查一下或者放弃这个变量。
[**Finding VIF in Python:**](https://etav.github.io/python/vif_factor_python.html)**from** **statsmodels.stats.outliers_influence** **import** variance_inflation_factory, X = dmatrices('y ~ x1 + x2', dataset, return_type='dataframe')vif_df = pd.Dataframe()
vif_df["vif"] = [variance_inflation_factor(X.values, i) **for** i **in** range(X.shape[1])]vif_df["features"] = X.columns
print(vif_df)[Finding VIF in R](http://minato.sip21c.org/msb/man/VIF.html)
reg <- lm(y ~ x1+x2,x3, data=dataset)
summary(reg)
VIF(lm(x1 ~ x2+x3, data=dataset))
VIF(lm(x2 ~ x1+x3, data=dataset))
VIF(lm(x3 ~ x2+x1, data=dataset))
调整后的 R 平方
我们在上一篇文章中学习了 R 的平方。概括地说，它衡量回归线与实际结果的吻合程度。让我们潜入更深的地方。
它的公式是:
R 平方=解释偏差/总偏差
解释方差 = 回归平方和(SSR) 【不要与 RSS(残差平方和)混淆，RSS 也称为 SSE】
总平方和(SST) = SSR + SSE(误差平方和)
你可以把它看成 SSE 是“无法解释的变异”。记住 SSE 是你的实际值( y )和你的预测值( y-hat )之间的误差
总变差 = SST(总平方和)。每个变量与该变量总体平均值之间的平均平方差(y- ybar)。
SOS.
所以 R 平方基本上是这样的:
现在这一点已经清楚了，让我们来看看调整后的 R 平方。
为什么要调整？
因为您的分子是方差之和，所以添加更多的预测值( x 变量)将总是增加的 R 平方，从而随着预测值的增加而变得不准确。
另一方面，调整的 R 平方，说明了预测器数量的增加。
https://www.graphpad.com/guides/prism/7/curve-fitting/index.htm?reg_interpreting_the_adjusted_r2.htm
- n 指的是数据点的数量(例如数据集中的行数)
- k 指 x 个变量的个数
由于等式的性质，调整后的 R 平方应始终低于或等于 R 平方。
如何评价什么好什么不好？
使用调整后的 R 平方的一个好方法是用不同的变量对模型进行几次迭代(例如进行逐步回归)。你可以看到调整后的 R 平方是如何增加的，当增加更多变量时，可能会在减少之前达到一个最佳点。然后你应该把它保持在那些给你最佳调整 R 平方的变量上。
任何能够显著预测结果变量，从而提高您的准确性的变量，都将导致更高的调整后 R 平方。
那都是乡亲们！暂时如此。
喘口气。祝贺你到达这篇文章的结尾！
Take this cute photo - of a sleeping cat that I pet-sit — as your reward.
下一篇文章将介绍使用 gretl 和 python 的实际建模，以及更多检查准确性的方法。
下次见！
超级简单机器学习—简单线性回归第 1 部分【概念和 R】
在我们开始之前…一句咆哮:
我不擅长统计学。
我可能不应该在网上写这个，它将被永远记录下来，并可能在我职业生涯的某个时候被用来反对我，但我很诚实，也很愚蠢，所以我会说出来:
我对统计一窍不通。
When you’re trying to figure out the volume of a cone, simple formulae and basic trigonometry. What, were you expecting an unrelated meme joke?
我知道你在想什么。
“没关系，每个人都有自己的长处和短处，而数据不是你的强项”
嗯，是的，但是……出于某种原因，我决定从事数据分析工作。
过去很艰难，现在仍然很艰难；我记得在一堂分析课结束后，大家都离开了，我坐在大学教室里，盯着我的笔记本电脑屏幕，试图忍住眼泪，因为我不知道这该死的课是关于什么的。
最终，我确实想出了足够的方法来应付，但是如果我不理解模型，那么和模型打交道就没有任何意义。因此，我做了大量的阅读，一篇接一篇的文章，回顾基本的统计理论，观看教程等等。
我必须说，我非常感激我可以访问万维网，那里的资源是无穷无尽的。这有助于我的教育不依赖于一个为了完成博士学业而不得不教一门课，但没有任何教学技能而只是朗读幻灯片的人。
Meme made from a comic by Allie Brosh. Check out her amazing stuff @ http://hyperboleandahalf.blogspot.sg/
在互联网上，我开始学习概念，用不同的方式解释，最后终于有了‘T4’的时刻。
也就是说，这里是我选择的一些向自己解释基本机器学习模型的方法。对我来说，我学习的最好方法是当我试图向别人解释的时候。
如果我的解释不正确，请随时告诉我。我不会生气的，我保证！
—
简单线性回归
简单线性回归模型是如此简单，以至于许多人认为它不值得被归类为“机器学习”。这很简单，只是统计建模。然而，为了这个系列的目的，我将把它归类为机器学习，因为它是一个时髦词，因此会让我听起来超级酷。
简单的线性回归模型允许你预测事情。多酷啊。基于已知的因素，你可以告诉你所有的朋友，即使某件事没有发生，你也有 87%的把握它会发生。Wooo好神奇
第一步
让我们回到简单的数学。 快克 MAF 。
你如何划清界限？
除了用尺子，哈哈好吧，爸爸的笑话放在一边，如果你想用微积分在图上做，它是
y = ax + b
- y 是结果。就像统计学试卷上的分数。
- x 是变量。喜欢流泪的数量。
- a 是一个有待确定的值。它被称为系数，类似于 x 变化时 y 的变化幅度。
- b 是一个待定的常数。它被称为截距，因为当 x 为 0 时，y=b
简单的线性回归遵循这样一个假设，即利用迄今为止找到的所有数据，你可以画一条线[y = ax + b]来确定这些点的趋势，然后计算出在 x 为任意值时 y 为多少。
看得出来，眼泪越多，考试分数也越高。这是你应该注意到的第一个趋势。
你的任务是:
我)找一个
ii)查找 b
iii)？？
四)利润
It could look something like this
它是如何工作的
回归模型找到最佳拟合线的一种方法是使用最小平方标准(最小误差平方和)。[Actual y] -[Predicted y]是误差，求平方，使差值成为绝对值，然后求和。😄)。
因此，回归模型有时被称为普通最小二乘回归。
在最小化所有讨厌的误差平方和(SSE)后，你会得到一条很好的拟合线，你可以在这条线上进行预测。
“这有什么好奇怪的？”你可能会沮丧地大喊大叫。
这个模型很棒，因为找到最佳拟合线不是一件容易的事情。
简而言之，不要尝试每一条可以想到的线，然后计算误差平方和，一遍又一遍地重复，直到找到最小的一条线，结果却不是最小的，因为你永远不会知道…
别那样做，你这个笨蛋。
This is the moment you admit that the robot is smarter than you
这个模型，以及你喜欢的统计软件，不管是 R、python 还是 gretl，都会为你做所有的事情。你甚至不用去想它背后的数学。
换句话说，简单的线性回归模型找到了在做预测时搞砸最少的那条线。
它为你找到了 a 和 b 的值，所以当你想知道多少眼泪能让你在考试中得 90 分时，你会知道并能朝着那个方向努力。
在 R 中做行为
关于 R 的伟大之处在于，已经有一些包和函数将所有复杂的数学编程到其中，你所要做的就是输入输入。
对于简单的线性回归，您只需要:
型号< - lm(y ~ x，data=your_data_source)
然后你可以做一个
总结(示范)
来看看你的 a(系数)和 b(截距)是什么样子的。
在这里查看这个教程。
注意事项
然而，就像其他不好玩的事情一样，有很多 T2 规则要遵守。
- x 和 y 应该是线性关系。如果在某个时候流了太多的眼泪，导致眼睛疼痛，导致你在纸上做得更差(但愿不会如此)，那么图表将如下所示:
也就是说，你妈妈会打你的屁股，所以把眼泪擦掉，孩子。但这也意味着任何用直线做出的预测都是错误的。
这个时候，转换(我会在另一篇文章中详细阐述)就派上用场了，把皱眉变成一条线。
2.为了使用一个回归模型，你应该有至少 20 个数据点来使它准确。这是为了确保您的样本大小足够大，可以作为预测的基础。
就像我不能确定 chokers 是否会重新成为一种潮流，直到我看到大约 23 个易受影响的青少年(当然，在个别场合，同龄人的压力会扭曲观察结果)穿上它。
These things!!! I don’t understand them!!! You can get one at https://www.fashionnova.com/products/throwback-choker I guess, but I’ll judge you for it
3.实现模型后，检查残差(实际预测的误差)是否是随机的。如果他们在做一些有趣的事情，并显示出清晰的趋势，这意味着你的模型显然没有抓住趋势。
它只有一项任务。一份工作！！
这是一篇非常好的文章，它解释了当一个简单的线性回归做得好或不好时检查你的残差图。
坚持学习！
这仅仅是机器学习的表面(我不知道它是否被认为是机器学习)，如果你对它感兴趣，我建议你多读一些。我遗漏了许多方程和统计摘要，需要查看它们来确定我在这篇文章中没有提到的模型的准确性，所以请记住，这只是线性回归模型的基本思想。
期待第 2 部分，它将解释回归模型背后的数学，你应该注意什么参数，如何在我的新朋友 Python 中编写这些代码，并解释为什么我在这篇文章中给出的例子(眼泪与考试分数)是一个可怕的例子。
链接什么的
其他值得一读的网站:
编辑描述
onlinestatbook.com](http://onlinestatbook.com/2/regression/intro.html) [## 线性回归的假设-统计解决方案
首先，线性回归需要自变量和因变量之间的关系是线性的。这是…
www.statisticssolutions.com](http://www.statisticssolutions.com/assumptions-of-linear-regression/)
通过 R 上的编码学习:
统计学中最常用的技术之一是线性回归，在这种方法中，我们研究潜在的…
www.r-bloggers.com](https://www.r-bloggers.com/simple-linear-regression-2/)
Udemy 有一个非常好的课程，涵盖了 Python & R 上的机器学习，他们解释了每个模型，并为不同的模型编写了代码，包括一个简单的线性回归模型:
[## 机器学习 A-Z:数据科学中的 Python & R 实践
向两位数据科学专家学习用 Python 和 R 创建机器学习算法。包括代码模板。
www.udemy.com](https://www.udemy.com/machinelearning/)
如果你想从一个更统计的角度来看，Coursera 上也有一个约翰·霍普斯金回归模型课程:
关于本课程:线性模型，顾名思义，使用…
www.coursera.org](https://www.coursera.org/learn/regression-models/)
希望这对你有所帮助，或者至少引起你的兴趣！
如果你发现任何错误和误解，请在下面留下评论。
超级简单的机器学习—简单线性回归第 2 部分【数学和 Python】
这是我正在撰写的一系列文章的一部分，涵盖了 ML 算法，以简单轻松的方式进行了解释，以便于理解。 我确实会掩饰更多的技术方面和术语，因为这里的目标是创造一些以最基本的方式推动理解概念的东西，而不是仅仅遵循步骤和盲目地抛出术语。然而，如果我的解释根本不正确，请告诉我。
第 1 部分 对于简单的线性回归可以在这里找到。
现在，您已经从第 1 部分中了解了简单线性回归的基本概念，让我们来看看本质。
在这篇文章中，我将深入一些 Python 编码及其背后的数学知识，并触及数据集的某些特征。
我们开始吧！
奇妙的参数/统计数据以及在哪里可以找到它们
***编辑！！！！！
我想先弄清楚一些术语。
一个朋友告诉我，我之前对参数的定义不正确。
参数是群体的特征(例如所有可能的结果)。很可能无法导出。
统计数据是样本的特征(例如我们可以记录的结果)。统计数据允许您估计参数:“推断统计数据允许您对总体参数进行有根据的猜测”
到目前为止，您应该已经熟悉的特征示例如下:
- 平均值:平均值
- 中位数:中间值
- 方差:每个 x 与平均值 x 之间的平方差的平均值。它描述了数据的分布范围。如果方差很大，你的“低数值”很低，你的“高数值”很高，想象一个弹性带被拉得越来越远，方差相应地增加。方差越低，越“稳定”,因为它收敛于均值。
- 标准差:方差的平方根。基本上找到 x 的分布有多宽，这与方差相同，但是单位的问题。如果你在看一个身高(厘米)的数据集，方差会给你平方厘米，但标准差是它的平方根，会给你一个厘米的答案，这有时更好计算，更适合你的强迫症。
the two different standard deviation formulae
首先弄清楚方差和标准差，因为你会在统计建模中遇到 ALOT。这个解释挺好的……另外还有小狗！
超参数:
值得注意的是，机器学习中有称为超参数的参数，这些参数基本上是您必须决定使用的值，这些值无法从算法中“学习”，但会影响您的模型。
超参数优化/调优是一个完全不同的话题，关于你如何决定你的超参数应该是什么值。我将在下一次解释 K-最近邻分类时谈到这一点。或者你可以在这里阅读。
非常感谢 Michael Chia Wei Aun 澄清了什么是参数！
好吧，那么…回归？
还记得在第 1 部分中，我说过如何绘制不同的线以找到误差平方最小的线，以及 R 和 Python 包如何能帮你解决这个问题吗？
好吧，让我们看看这些包在做什么。
请记住这一点:
y = ax + b
直线方程。
让我们看看寻找最佳拟合线背后的数学原理。
普通最小二乘法背后的等式如下:
Figure 1: ??????
第一个方程是不是很眼熟？那是因为它和我在上面提到的方程完全一样——一条线的方程，只是写法不同
因此，第二个和第三个方程是您需要找到 a 和 b、的方程，这基本上是我们在 R 和 python 包中尝试做的事情。
a 和 b 在线性回归中被称为“β”,并被视为学习参数,因为它们在运行线性回归算法后最终被“学习”。
你可以在这里找到上面的方程式及其背后的数学可以在这里找到*。***
那些公式/公式是怎么回事？
他们试图最小化误差平方和(实际值和预测值的平方差)。如果不确定，请参考第 1 部分您是否注意到了？！).
要做到这一点，a 和 b 的偏导数必须为 0。因为 0 是曲线最小时的拐点。是的是的衍生品。
导数不是我要解释的，但是你可以在这里快速修改一下。
x 和 Y 有比你妈妈更酷的头饰
你会注意到图 1 的第二个和第三个方程，x 和 y 的头上有有趣的东西。
x̄ = x 酒吧
̅y = y 酒吧
除了是一个总屁股打字，酒吧基本上意味着，意味着。所以 x̄指的是 x 的均值
所以(x- x̄)是 x 的值和所有不同 x 值的平均值之差。
这被称为偏差分数，意思是偏离值有多远。
A quick explanation on x- xbar
(xi-x̄)看起来真的很熟悉，不是吗？这是因为它也用于计算方差和标准差。
看看平均值有多有用！这解释了为什么参数/统计如此重要。
另一个需要注意的符号是帽子
ŷ = y 帽
how I remember y-hat: guy with fedora, always assuming, trying to predict things, most likely wrong
这是指预测方程中 y 的预测值。
换句话说，更准确地说，
y = ax + b
应该是
ŷ = ax + b
误差基本上是
真实 Y -预测 Y
可以写成
y - ŷ
这也被称为残差。(** 还记得 第一部分 中关于检查你的残差是随机的，不应该显示出一个模式的那一步吗？)**
总之，因为生活是艰难而复杂的——预测的误差平方和被写成 SSE
但也可以称为:
- 残差平方和
- 残差平方和(SSR)
好了，酷的编码从这里开始
既然我们已经解决了所有这些数学问题，让我们来编写代码吧。
我们将从使用 Python 中的 sklearn 库中的线性回归模块开始。这类似于我在第 1 部分中给出的 R 的一行代码，其中我使用已经预先编码的东西来寻找我的回归线。
我不会在这里讨论 Python 编码，因为我不认为我是合格的 lol，但我尽力在代码本身的#注释中解释了每个步骤。
耶，你完成了建模！
看那条华丽的线。这是不是一个好的线还没有决定(等待第三部分..就等着吧)，不过目前已经决定了这一行有最少的 SSE(或者 RSS，或者 SSR)** 。**
然而，由于我花了大量时间研究 LinearRegression()方法背后的等式，我想证明它实际上是我们刚刚使用的 python 模块背后的数学。
Figure 1 makes a 2nd appearance!
注意:
python 里的权力符号不是“^”，是“”**
两者给出完全相同的结果:
回归方程为 y = 1.37x + 4.27
我们结束了。
希望你现在对简单线性回归的工作原理有了更好的了解:)我当然知道。
这只是线性回归的第一步，但是你可以自己尝试。我用这篇文章作为指南，它被证明是非常全面的，尤其是数学部分。
你可以在 Jupyter 笔记本中设置和编码，或者只使用 Python IDE 。
在下一集，我将会谈到评估模型的准确性，以及如何从中得出预测。
敬请期待！
额外额外！！语境很重要！！
在第一部分中，我举的关于‘流泪’和‘考试分数’的例子事后看来很糟糕。
尽管统计数据可以证明这种相关性，但请永远记住
***相关性不是因果关系 ***
对着镜子念 6 遍，希望相关的鬼魂出现给你祝福~
也许流泪的次数会影响分数，因为我花在学习上的时间越多，哭得越厉害(在这种情况下，更好的方法是建立学习时间与考试分数的模型)，但这都是假设，可能只是巧合。
流泪次数与考试成绩之间的相关性可能是一个重要的因素。
鼓声
这就是商业知识和常识发挥作用的地方，也是防止机器偷走你工作的地方。什么是相关的，什么是不相关的，不仅仅是由程序定义的。特征选择在很大程度上是人类和计算机的工作。
查看泰勒·维根的超级有趣的虚假相关性。
我们已经到了第 2 部分的结尾！谢谢你坚持到现在。请在第 3 部分继续关注，如果发现任何错误，记得告诉我。
超级 SloMo 的乐趣。或者你如何用人工智能制作超赞的 YouTube 视频
想获得灵感？快来加入我的 超级行情快讯 。😎
你有没有想过 YouTubers 或者国家地理是怎么制作那些超级慢动作视频的？它们太酷了，简直就像魔术一样！
过去制作这样的视频非常昂贵。唯一干净利落的方法就是用超高 fps 的相机。
幸运的是，现在不再是这样了！过去几年发生的人工智能爆炸改变了一切。要制作一个史诗般的慢动作视频，你只需要下载一点代码，安装一两个库，剩下的就交给计算机视觉了。
超级慢动作
Super SloMo 是一种新的计算机视觉技术，用于帧间插值。它来自 Nvidia，并在去年的 CVPR 会议上发表。
Super SloMo Optical Flow
简而言之，Super SloMo 试图计算视频中的中间帧。给定 2 帧，我们如何在没有任何进一步信息的情况下准确估计它们之间的帧(如果我们有一个高 fps 的摄像机)。它通过深度卷积神经网络来实现这一点，训练该网络来预测帧之间的光流。
光流是由物体或摄像机的运动引起的图像物体在两个连续帧之间的表观运动模式。通过这种光流，Super SloMo 将知道图像中的每个像素如何从一帧移动到另一帧。一旦它知道了移动路径，它就可以确定如果我们真的有一个中间帧，每个像素会在哪里。一旦你知道所有的像素应该在哪里，你就可以简单地将它们组合起来形成中间帧！
Results from Super SloMo, courtesy of Nvidia
让你的视频慢下来
感谢 AI 社区中开放源代码思想的美丽，这里有一个公开可用的超级 SloMo 实现！这是你如何使用它。
首先克隆存储库
git clone [https://github.com/avinashpaliwal/Super-SloMo.git](https://github.com/avinashpaliwal/Super-SloMo.git)
安装所需的库
pip install torch torchvision
pip install tensorflow-gpu
pip install numpy
pip install matplotlib
sudo apt install ffmpeg
你可以从这里下载预先训练好的模型。将该检查点放在 Super-SloMo 目录中。
要将您的视频从常规转换为慢动作，您只需运行一个小脚本！
python video_to_slomo.py --video=test.mp4 \
--sf=4 \
--checkpoint=SuperSloMo.ckpt \
--fps=25 \
--output=output.mp4
视频参数是输入视频的路径。 sf 控制你想让视频慢下来多少，在这种情况下是 4 倍。关卡是通往预训练模型关卡的路径。 fps 是原始视频的帧率；你可以通过右击视频并进入“属性”找到答案。输出是您希望输出视频的名称。
如果你在一台 Ubuntu 机器上，你可能需要注释掉下面两行，就像我在我的机器上一样:
FILE_ATTRIBUTE_HIDDEN = 0x02ctypes.windll.kernel32.SetFileAttributesW(extractionDir, FILE_ATTRIBUTE_HIDDEN)
自己尝试代码，这很有趣！看看你是否能制作自己的超赞 SloMo 视频。欢迎在下面发布链接，与社区分享您的视频。
Results from Super SloMo, courtesy of Nvidia
喜欢学习？
在 twitter 上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！
增压词向量
一个在你的 NLP 项目中提升快速文本和其他单词向量的简单技术
在过去的几年中，单词向量在创建单词间语义联系的能力方面具有变革性。现在，将这些输入到深度学习模型中进行分类或情感分析等任务已经成为常态。
尽管如此，我一直对基于词频分析的简单能力印象深刻。术语频率逆文档频率 (TF-IDF)可以很容易地向非技术受众解释，结果也很容易解释。
本文探讨了如何将 TF-IDF 与单词向量相结合，从而得到既易于解释又能捕捉语言中存在的微妙语义关系的输出。
虽然互联网上充斥着使用 TF-IDF ( 见此处)和词向量方法(见此处)进行“词袋”分析的例子，但这些几乎总是被视为相互排斥的技术。本文探讨了如何将 TF-IDF 与单词向量相结合，从而得到既易于解释又能捕捉语言中存在的微妙语义关系的输出。使用 fastText 方法创建单词向量，我们还将能够创建一个模型，该模型可以处理词汇表之外的单词，并对拼写错误和打字错误具有鲁棒性。
快速文本单词向量
本文假设读者对单词向量有一定的了解，但是值得一提的是 fastText，以及它与更广为人知的 word2vec 创建单词向量表示的方法有何不同。FastText 由脸书开发，2017 年开源了一个稳定版本。
fastText 和 word2vec 之间最明显的区别是 fastText 使用 n-gram 字符拆分单词。例如，“林肯郡”(英国的一个郡)将被分为:
Lin, inc, nco, col, oln, lns, nsh, shi, hir, ire
其中 n=3。这种方法是对 word2vec 的重大改进，原因有二:
- 推断词汇外单词的能力。例如，上述模型会理解“兰开夏郡”(也是英国的一个县)与林肯郡相关，因为这两个词之间有“shire”(或“shi”、“hir”和“ire”)的重叠。
- 对拼写错误和错别字的鲁棒性。很容易看出，相同的字符级建模也意味着 fastText 足够健壮，可以处理拼写变化。这在分析社交媒体内容时特别有用。
关于 fastText 如何工作的详细回顾可以点击这里查看。
给我看看代码！
本文的其余部分将介绍一个简单的例子，该例子将在一系列文档上训练一个 fastText 模型，将 TF-IDF 应用于这些向量，并使用它来执行进一步的分析。
有问题的文件是公司提交的现代奴隶制声明，以解释它们正在内部和供应链中采取的消除现代奴隶制的步骤。下面的文章展示了在分析之前如何清理这些数据:
清理数据不一定是痛苦的！这篇文章是一个如何使用无监督机器学习的快速例子…
towardsdatascience.com](/clean-your-data-with-unsupervised-machine-learning-8491af733595)
如果你想继续下去，可以在这里找到包含所有代码的 colab 笔记本。
第一步。标记文本并创建短语
我们将使用 spaCy 将每个文档分割成一个单词列表(标记化)。我们还将通过删除停用词、标点符号并使用 Gensim 库转换为小写来清理数据:
#The dataframe is called 'combined' it has a column called 'text' containing the text data for each company#creates a list of documents with a list of words inside:
text = []
for i in combined.text.values:
doc = nlp(remove_stopwords(strip_punctuation(strip_non_alphanum(str(i).lower()))))
tokens = [token.text for token in doc]
text.append(tokens)
然后我们将共同的术语粘在一起。例如，当每个文件都提到现代奴隶制时，将这两个词合并成一个短语“现代 _ 奴隶制”是很有用的。Gensim 库使这变得简单，代码如下:
common_terms = ["of", "with", "without", "and", "or", "the", "a"]
# Create the relevant phrases from the list of sentences:
phrases = Phrases(text, common_terms=common_terms, threshold = 10, min_count=5)
# The Phraser object is used from now on to transform sentences
bigram = Phraser(phrases)
# Applying the Phraser to transform our sentences is simply
tokens = list(bigram[text])
我们现在有一个文档列表，每个文档包含一个单词列表。常用短语已被组合成词。
第二步。训练快速文本模型
这只需要使用 Gensim 库的 fastText 模型的一行代码。您可以设置 n 元大小(“窗口”)以及向量的维度大小(“大小”)。这里，我们创建了 100 维的向量，并使用了 3:
model = FastText(tokens, size=100, window=3, min_count=1, iter=10, sorted_vocab=1)
我们可以使用以下内容来检查模型:
similarities = model.wv.most_similar(restrict_vocab=10000, positive=['contract'])
这将返回:
subcontract 0.9493274688720703
sub_contract 0.9349175095558167
contractual 0.9346154928207397
contracts 0.9312876462936401
contractor 0.9068889617919922
为了展示 fastText 如何处理不在词汇表中的单词，我们可以试着将 contract 拼错为'contract'。从下面，我们可以看到模型没有问题解释这个词，即使它从来没有见过！
contract 0.9389102458953857
contracts 0.9058693051338196
contrary 0.9027011394500732
contractor 0.8995087742805481
contractual 0.885408341884613
第三步。将 TF-IDF 应用于矢量
这一步首先使用 Scikit 为每个文档创建 TF-IDF 信息。然后，它将权重应用于文档中的每个单词向量，然后对整个文档进行平均:
#TF-IDF
text = []
for i in tqdm(tokens):
string = ' '.join(i)
text.append(string)
tf_idf_vect = TfidfVectorizer(stop_words=None)
final_tf_idf = tf_idf_vect.fit_transform(text)
tfidf_feat = tf_idf_vect.get_feature_names()#Applying TF-IDF scores to the model vectorstfidf_sent_vectors = []; # the tfidf-w2v for each sentence/review is stored in this list
row=0;
errors=0
for sent in tqdm(tokens): # for each review/sentence
sent_vec = np.zeros(100) # as word vectors are of zero length
weight_sum =0; # num of words with a valid vector in the sentence/review
for word in sent: # for each word in a review/sentence
try:
vec = model.wv[word]
# obtain the tf_idfidf of a word in a sentence/review
tfidf = final_tf_idf [row, tfidf_feat.index(word)]
sent_vec += (vec * tfidf)
weight_sum += tfidf
except:
errors =+1
pass
sent_vec /= weight_sum
#print(np.isnan(np.sum(sent_vec)))tfidf_sent_vectors.append(sent_vec)
row += 1
print('errors noted: '+str(errors))
现在，我们的语料库中的每个文档都有了超级 TF-IDF 单词向量！是时候测试一下了…
结果
现在我们有了与 TF-IDF 权重相结合的快速文本向量，使用余弦相似性来检测结果就很容易了。下面的代码根据查询字符串找到一个匹配的公司，然后根据它们的 Modern Slavery returns 生成一个最相似的公司列表。
compName = 'Deloitte'query = [combined.loc[combined.Company.str.contains(compName)].iloc[0]['FT_tfidf']]
query = np.array(list(query))
query = np.nan_to_num(query)vectors = np.array(list(combined.FT_tfidf.values))
vectors = np.nan_to_num(vectors)cosine_similarities = pd.Series(cosine_similarity(query, vectors).flatten())for i,j in cosine_similarities.nlargest(10).iteritems():
print(str(i) + '-' + combined.Company.iloc[i] + " " + str(j))
这里的例子是专业服务公司德勤。从下面的结果我们可以看到，最相似的回报来自相关公司(即德勤自己的另一个财政年度的回报，以及 DLA 律师事务所和安永会计师事务所，另一家“四大”会计师事务所):
Deloitte LLP 1.0000000000000002
Deloitte LLP 0.949480726712043
DLA Piper International LLP 0.8635928917765654
Travers Smith LLP 0.8495683187822698
EBSCO International Inc. 0.8405915834557236
Vink UK 0.8356471225683573
Ernst & Young LLP 0.8345225966043321
IFS UK Ltd 0.8288755547154663
First Central Insurance 0.8279939308519769
TalkTalk Telecom Group PLC 0.8260778120395709
希望这篇文章展示了将单词向量与 TF-IDF 技术结合起来可以产生强大的结果，并且也易于解释和说明。在此演练中生成的文档向量现在可以用于文本分类、聚类以及进一步分析(例如，发现公司回报如何随时间或跨行业变化的趋势)。
超收敛——内置正则化的快速训练
你有像我一样在训练大型神经网络时陷入局部极小值的恐惧症吗？等待长时间用大量的 epocs 训练网络，以获得对你的测试数据的良好准确性。
并且仍然得到一个像哑巴一样坐在局部最小值中的模型，以及如何尝试越来越多的正则化方法并再次等待很长时间的开销。
你需要这个家伙一个超级收敛的魔术，节省你的时间，把你从深度学习实践者生活中的问题中拯救出来，如局部最小值，泛化错误，训练数据过度拟合等。
超收敛-
通常，在超收敛方法中，我们试图以大的学习速率学习到一个比传统的低学习速率学习更少的总迭代次数。
Left: getting fast progress in starting, Right: in valley areas very little progress on a large number of epochs
从较小的学习速率开始，在正确的方向上获取梯度，然后我们增加学习速率以快速通过平坦的山谷区域，在平坦区域之后，我们再次使用较低的学习速率来收敛到最佳损失值。这样在更少的时间内找到一个更好的超收敛解。
但是在固定学习率的情况下，我们可能会在开始时迅速减少损失，但是当我们停留在山谷区域时，我们会在大量迭代中取得一些进展，如右图所示。
自动正规化背后有什么魔力-
有几种方法，如辍学，下降连接，噪声与大学习率和批量大小等。超参数这种方法给我们提供了梯度噪声。另一方面，我们可以用我们的神经网络的输入来添加一些正则化，如数据增强或添加噪声，这种正则化提供了梯度多样性。
核心是，我们需要一种既能提供梯度噪声又能提供多样性的方法来训练神经网络模型以获得良好的泛化能力。
下面是实验结果来了解一下——
因此，当我们从较低的学习率开始，但逐渐增加它们，并在训练期间达到较高的学习率时，我们将梯度噪声赋予我们的优化方法，这些方法充当我们模型的正则化器，如图所示，可能我们的训练损失增加了，但我们的验证损失降低了。最后对学习率进行退火处理，得到更平坦、更好的极小点。
这支持了【Wu et al .，2017】的论文，该论文指出宽的、平坦的局部极小值产生比尖锐极小值概括得更好的解。
我们可以利用这一点与数据扩增，以获得梯度经验噪声和多样性。
为什么我使用这种方法而不是其他的正则化方法-
因为我已经很快完成了训练部分，这对我一直都很有效。当我第一次在 FastAI 从【杰瑞米·霍华德】 中了解到这个方法，第二次看了 Sylvain Gugger 的这个博客时，我就对这个方法印象深刻。
为了更好地理解和实际使用，推荐阅读-
有监督、无监督和深度学习
机器学习已经成为，或者仅仅是，人工智能，特别是计算机科学的一个重要分支，所以数据科学家是一个非常受欢迎的职位。今天，每个人都可以使用一些机器学习工具，如 TensorFlow 或其他工具，开始编写代码，并说“Ehy 我编写了具有机器学习功能的 bla bla”，但如果不知道这些算法是如何工作的，就很容易犯下巨大的错误。因此，了解机器学习的基础知识，然后建立其他技能非常重要。
这篇介绍首先要让我记住这一点。
让我们从 be 基础知识开始:机器学习中的第一个概念之一是有监督的，无监督的和深度学习的区别。
监督学习
监督学习是最常见的机器学习形式。使用监督学习，在训练阶段将一组示例(训练集)作为输入提交给系统。每一个输入都标有一个期望的输出值，这样系统就知道输入来的时候输出如何。例如，考虑一些可以分为 N 个不同类别的实验观察。所以我们有一个训练集(一系列对){(x1，y1)，(x2，y2)…..其中是输入，yi 是相应输出的类。通过最小化特定的成本函数来执行训练，该成本函数表示来自输入 xi 和期望输出 yi 的界限。
Supervised learning schema
监督机器学习应用的一个典型例子是垃圾邮件检测器，这个算法是用一些垃圾邮件，而不是垃圾邮件以及它们属于哪个组来训练的。当您将邮件标记为“垃圾邮件”或当您将垃圾邮件文件夹中的邮件标记为“非垃圾邮件”时，此训练过程将继续。
无监督学习
另一方面，无监督学习，由系统提供的训练样本没有用所属类别来标记。因此，系统开发和组织数据，搜索它们之间的共同特征，并根据内部知识进行更改。
Unsupervised learning schema
无监督学习的一个例子是聚类分类:算法试图将相似的东西放在一个簇中，将不相似的东西放在另一个簇中，相似性的概念取决于相似性度量。
深度学习
深度学习(DL)技术代表了机器学习向前迈出的一大步。DL 是基于人类大脑处理信息和学习的方式。它存在于一个由若干级表示组成的机器学习模型中，其中每一级都使用来自前一级的信息进行深度学习。在这个模型中，每一层都对应于大脑皮层的一个不同区域，每一层都以与人脑相同的方式提取更多的信息。
Deep learning schema
参考文献:
- 机器学习在行动——彼得·哈灵顿
- 【TensorFlow 入门— Giancarlo Zaccone
监督与非监督学习
理解两种主要机器学习方法的区别
在机器学习领域，有两种主要类型的任务:监督的和非监督的。这两种类型之间的主要区别在于，监督学习是使用基本事实完成的，或者换句话说，我们事先知道样本的输出值应该是多少。因此，监督学习的目标是学习一个函数，该函数在给定数据样本和期望输出的情况下，最接近数据中可观察到的输入和输出之间的关系。另一方面，无监督学习没有标记输出，因此它的目标是推断一组数据点中存在的自然结构。
监督学习
当我们希望将输入映射到输出标签时，监督学习通常在分类环境中完成；当我们希望将输入映射到连续输出时，监督学习通常在回归环境中完成。监督学习中的常见算法包括逻辑回归、朴素贝叶斯、支持向量机、人工神经网络和随机森林。在回归和分类中，目标是在输入数据中找到特定的关系或结构，使我们能够有效地产生正确的输出数据。请注意,“正确的”输出完全是由训练数据决定的，因此，虽然我们确实有一个我们的模型将假设为正确的基本事实，但这并不是说数据标签在现实世界中总是正确的。嘈杂或不正确的数据标签将明显降低模型的有效性。
当进行监督学习时，主要考虑的是模型复杂性和偏差-方差权衡。请注意，这两者是相互关联的。
模型复杂性指的是您试图学习的函数的复杂性，类似于多项式的次数。模型复杂性的适当级别通常由训练数据的性质决定。如果您有少量的数据，或者如果您的数据没有均匀地分布在不同的可能场景中，那么您应该选择低复杂度的模型。这是因为一个高复杂度的模型如果用在少量的数据点上会过度拟合。过度拟合指的是学习一个非常适合你的训练数据的函数，但不将推广到其他数据点——换句话说，你严格地学习产生你的训练数据，而没有学习导致这个输出的数据中的实际趋势或结构。想象一下试图拟合两点之间的曲线。理论上，你可以使用任何次数的函数，但在实践中，你会吝啬地增加复杂性，并使用线性函数。
偏差-方差权衡也与模型泛化有关。在任何模型中，偏差(恒定误差项)和方差(不同训练集之间的误差变化量)之间都有一个平衡。因此，高偏差和低方差的模型在 20%的时间里都是错误的，而低偏差和高方差的模型在 5%-50%的时间里都是错误的，这取决于用来训练它的数据。请注意，偏差和方差通常彼此反向移动；增加偏差通常会导致较低的方差，反之亦然。在制作模型时，您的具体问题和数据的性质应该允许您在偏差-方差谱的哪个位置做出明智的决定。通常，增加偏差(和减少方差)会导致模型具有相对保证的基线性能水平，这在某些任务中可能是至关重要的。此外，为了生成具有良好泛化能力的模型，模型的方差应与训练数据的大小和复杂性成比例-小而简单的数据集通常应使用低方差模型来学习，而大而复杂的数据集通常需要高方差模型来完全学习数据的结构。
无监督学习
无监督学习中最常见的任务是聚类、表示学习和密度估计。在所有这些情况下，我们希望了解数据的内在结构，而不使用显式提供的标签。一些常见的算法包括 k 均值聚类、主成分分析和自动编码器。由于没有提供标签，所以在大多数无监督学习方法中，没有特定的方法来比较模型性能。
无监督学习的两个常见用例是探索性分析和降维。
无监督学习在探索性分析中非常有用，因为它可以自动识别数据中的结构。例如，如果分析师试图对消费者进行细分，无监督聚类方法将是他们分析的一个很好的起点。在人类不可能或不切实际地提出数据趋势的情况下，无监督学习可以提供最初的见解，然后可以用于测试个人假设。
降维是指使用较少的列或特征来表示数据的方法，可以通过无监督的方法来实现。在表征学习中，我们希望学习个体特征之间的关系，允许我们使用与初始特征相关的潜在特征来表示我们的数据。这种稀疏潜在结构通常使用比我们开始时少得多的特征来表示，因此它可以使进一步的数据处理不那么密集，并且可以消除冗余特征。
TLDR:
3 分钟内监督与非监督学习
机器学习算法一般可以分为两类，有监督的或者无监督的。这是一个二分法的简要概述。
监督学习
监督学习算法获取数据集，并使用其特征来学习与相应标签集的某种关系。这个过程被称为训练，一旦完成，我们希望我们的算法能够很好地预测全新数据的标签，在这些数据中，算法没有真正标签的明确知识。例如，我们可以使用一组常见动物的图像以及它们相应的标签(例如，狗、猫、鸡)来训练一个受监督的算法。该算法将利用图像中的有用特征，如腿的数量或颜色，以找到将图像与其正确标签联系起来的有用模式。在成功训练后，我们可以使用完全训练的算法来尝试预测一组全新的未见过的图像的标签。我们通常通过算法在预测这些新的看不见的图像时的准确性来判断算法的性能。监督学习可以应用于广泛的问题，如垃圾邮件检测或股票价格预测。决策树是监督学习算法的一个例子。
无监督学习
另一方面，无监督学习算法处理没有明确标记的数据。相反，无监督算法试图在数据中找到某种潜在的结构。一些观察结果是否被分组？不同特性之间有没有有趣的关系？哪些特征携带了大部分信息？与监督学习不同，通常不需要训练无监督算法，因为它们可以直接应用于感兴趣的数据。此外，与监督学习相比，评估无监督学习算法的性能有些主观，并且很大程度上取决于任务的具体细节。无监督学习通常用于文本挖掘和降维等任务。 K-means 是非监督学习算法的一个例子。
打破二分法
近年来，出现了许多不太适合监督和非监督标签的范例。半监督学习听起来就像是一种结合了一些标记数据和一些未标记数据的方法。标注通常是一个昂贵且耗时的过程，因此在很多情况下，我们希望使用来自少量已标注数据和大量未标注数据的信息。与这种情况相关的还有主动学习，其中学习算法可以询问用户来标记将添加最多信息的特定观察。一个稍微不同的情况是，我们希望算法从经验中学习。例如，在像国际象棋这样的游戏场景中，我们可能希望通过玩许多游戏并使用每场游戏结果的某种标签来学习算法。在一个非常高的层面上，我们可能希望好的举措会被贴上赢的标签，而坏的举措可能与输相关联。这被称为强化学习，近年来受到了很多关注。大多数机器学习方法在它们可以完成的任务方面都非常狭窄，而元学习关注的是通用性或学会学习。一个例子可能是一种算法，它应该识别图像中的动物，但只对猫和狗进行训练。在这种情况下，一个好的元学习算法将能够识别它尚未见过的全新动物。有很多其他的方法并不完全适合有监督或无监督的学习，但是我希望这篇文章对这个主题有一个有用的介绍。
所有图片均为本人所有。
支持向量机——机器学习算法简介
从零开始的 SVM 模式
介绍
我猜现在你已经习惯了线性回归和 T2 逻辑回归算法。如果没有，我建议你在学习支持向量机之前先看看它们。支持向量机是另一种简单的算法，每个机器学习专家都应该拥有它。支持向量机是许多人的首选，因为它以较少的计算能力产生显著的准确性。支持向量机，缩写为 SVM，可用于回归和分类任务。但是，它被广泛用于分类目标。
什么是支持向量机？
支持向量机算法的目标是在 N 维空间(N-特征的数量)中找到一个超平面，该超平面清楚地分类数据点。
Possible hyperplanes
为了分离这两类数据点，有许多可能的超平面可供选择。我们的目标是找到一个具有最大余量的平面，即两类数据点之间的最大距离。最大化边缘距离提供了一些加强，以便可以更有把握地对未来的数据点进行分类。
超平面和支持向量
Hyperplanes in 2D and 3D feature space
超平面是帮助分类数据点的决策边界。落在超平面任一侧的数据点可以归属于不同的类别。此外，超平面的维数取决于特征的数量。如果输入特征的数量是 2，那么超平面只是一条线。如果输入特征的数量是 3，则超平面变成二维平面。当特征的数量超过 3 时，变得难以想象。
Support Vectors
支持向量是更接近超平面并影响超平面的位置和方向的数据点。使用这些支持向量，我们最大化分类器的余量。删除支持向量将改变超平面的位置。这些是帮助我们建设 SVM 的要点。
大幅度直觉
在逻辑回归中，我们采用线性函数的输出，并使用 sigmoid 函数压缩[0，1]范围内的值。如果挤压值大于阈值(0.5)，我们将其指定为标签 1，否则将其指定为标签 0。在 SVM，我们获取线性函数的输出，如果该输出大于 1，我们将其识别为一个类，如果输出为-1，我们将其识别为另一个类。由于在 SVM 阈值被改变为 1 和-1，我们获得了这个值的加强范围([-1，1])，其作为余量。
成本函数和梯度更新
在 SVM 算法中，我们希望最大化数据点和超平面之间的间隔。有助于最大化裕量的损失函数是铰链损失。
Hinge loss function (function on left can be represented as a function on the right)
如果预测值和实际值符号相同，则成本为 0。如果不是，我们就计算损失值。我们还在代价函数中加入了一个正则化参数。正则化参数的目标是平衡余量最大化和损失。添加正则化参数后，成本函数如下所示。
Loss function for SVM
现在我们有了损失函数，我们对权重求偏导数来求梯度。使用梯度，我们可以更新我们的权重。
Gradients
当没有错误分类时，即我们的模型正确地预测了我们的数据点的类别时，我们只需要根据正则化参数更新梯度。
Gradient Update — No misclassification
当存在错误分类时，即我们的模型在预测我们的数据点的类别时出错，我们将损失与正则化参数一起包括进来以执行梯度更新。
Gradient Update — Misclassification
Python 中的 SVM 实现
我们将用来实现 SVM 算法的数据集是虹膜数据集。可以从这个链接下载。
由于 Iris 数据集有三个类，我们将删除其中一个类。这给我们留下了一个二元类分类问题。
Visualizing data points
另外，有四个特性可供我们使用。我们将只使用两个特征，即萼片长度和花瓣长度。我们把这两个特征画出来。从上图中，你可以推断出可以用一条直线来分隔数据点。
我们提取所需的特征，并将其分成训练和测试数据。90%的数据用于训练，剩下的 10%用于测试。现在让我们使用 numpy 库来构建我们的 SVM 模型。
α(0.0001)是学习率，正则化参数λ被设置为 1/历元。因此，正则化值减少了历元数的增加。
我们现在裁剪权重，因为测试数据只包含 10 个数据点。我们从测试数据中提取特征并预测值。我们获得预测值，并将其与实际值进行比较，打印出我们模型的准确性。
Accuracy of our SVM model
还有另一种简单的方法来实现 SVM 算法。我们可以使用 Scikit 学习库，只需调用相关函数来实现 SVM 模型。代码的行数明显减少太少行。
结论
支持向量机是一种优雅而强大的算法。明智地使用它:)
支持向量机——概述
有多种方法可以用机器学习对数据进行分类。你可以运行一个逻辑回归，使用决策树，或建立一个神经网络来完成这项任务。1963 年，Vladimir Vapnik 和 Alexey Chervonenkis 开发了另一种分类工具，即支持向量机。Vapnik 在 20 世纪 90 年代完善了这种分类方法，并扩展了支持向量机的用途。支持向量机已经成为数据科学家的一个很好的工具。
在这篇博文中，我计划提供一个关于支持向量机的高层次概述。我将谈论支持向量机背后的基本理论，为什么它们是相关的，以及这种分类器的优点和缺点。我还向您展示了一个用 Python 实现 SVM 的快速示例。我还提供了一个资源列表，这些资源有助于理解支持向量机。如果你想理解数学，我鼓励你查阅更多的支持向量机深度指南。这些信息的大部分是从 Tibshirani 的统计学习导论中提炼出来的。
论:
支持向量机试图通过数据集传递一个线性可分的超平面，以便将数据分为两组。这个超平面对于任何维度都是线性分隔符；它可以是直线(2D)、平面(3D)和超平面(4D+)。请看统计学习简介中的这张图表:
我们可以用无限多的超平面来分离红色和蓝色物体。哪个超平面最好？好吧，最好的超平面是最大化边际的超平面。边缘是超平面和几个接近点之间的距离。这些接近点是支持向量，因为它们控制超平面。下图显示了红色和蓝色物体的最佳超平面。
这是最大间隔分类器。它使超平面的边缘最大化。这是最好的超平面，因为它最大程度地减少了泛化误差。如果我们添加新数据，最大间隔分类器是正确分类新数据的最佳超平面。最大间隔分类器是我们的第一个 SVM。但是这个 SVM 要求两个类完全线性分离。情况并非总是如此，因此在 1993 年，Vapnik 开发了他的另一台机器。
下图显示了不完全可分的数据。
在这种情况下，最大间隔分类器将不起作用。Vapnik 开发了一个软余量，允许对数据进行一些错误分类。这被称为软边界分类器或支持向量分类器。它还试图最大限度地扩大两个阶层之间的差距。下图说明了这个 SVM。
支持向量分类器包含一个调整参数，以便控制它将允许多少错误分类。当希望最小化误差时，这个调谐参数是重要的。和所有监督学习一样，有一个偏差-方差权衡。当调整参数(通常表示为 C)较小时，分类器只允许少量的误分类。支持向量分类器将具有低偏差，但是可能不能很好地概括，并且具有高方差。如果我们的调整参数太小，我们可能会过度拟合训练数据。如果 C 很大，则允许的错误分类数会增加。这个分类器可以更好地进行归纳，但是可能会有很大的偏差。当调整参数为零时，不可能有错误分类，并且我们有最大间隔分类器。下图说明了这一点。
如果数据不是线性可分的，则支持向量分类器可能会失败。1992 年，Vapnik 开发了一种处理非线性可分类的方法。这个方法使用内核技巧。我们需要“扩大特征空间，以适应类别之间的非线性边界”(统计学习介绍)。核是量化观察值之间相似性的函数。用于分离非线性数据的常见类型的核是多项式核、径向基核和线性核(与支持向量分类器相同)。简单地说，这些核转换我们的数据，以便通过一个线性超平面，从而对我们的数据进行分类。下面是各种内核类型的一些可视化指南。
【http://svmcompbio.tuebingen.mpg.de/img/poly.png 号
支持向量机的扩展可以用来解决各种其他问题。我们可以使用一对一分类或一对所有分类来建立多个类别的支持向量机。在统计学习简介中可以找到对这些的简要描述。此外，支持向量回归机存在的回归问题。你也可以研究支持向量聚类、SVM 排名、直推式 SVM 等等。
那么，我们应该什么时候使用支持向量机呢？当组被清楚地分开时，支持向量机在分类方面做得很好。当我们的数据非线性分离时，它们也能做得很好。您可以转换数据以线性分离它，或者让 SVM 转换数据并线性分离这两个类。这是使用支持向量机的主要原因之一。您不必自己转换非线性数据。支持向量机的一个缺点是这些函数的黑盒性质。使用核来分离非线性数据使得它们很难(如果不是不可能的话)解释。
下面是一个用 Scikit-Learn 在 Python 中快速实现 SVM 的例子。
在上面的代码中，我用特定的内核函数实例化了 SVM，并使用交叉验证来检查模型的平均准确性。正如您所见，使用 SVM 可以非常简单。
总的来说，支持向量机是针对特定情况的优秀分类器。理解它们将会给你一个替代 GLMs 和决策树的分类方法。一定要看看我下面的引用，尤其是如果你想要更深入的支持向量机的数学解释。如果您有在这些资源中尚未找到答案的问题，请向 Vapnik 发送消息。他目前在脸书人工智能研究所工作。
资源:
加雷斯·詹姆斯、丹妮拉·威滕、特雷弗·哈斯蒂和罗伯特·蒂布拉尼的《统计学习导论》
【https://www.svm-tutorial.com/ 号
Joseph Nelson 和 Matt Speck 在 DC SVM 大会上的演讲
麻省理工学院 6.034 人工智能，2010 秋季课程——导师:帕特里克·温斯顿
支持向量机(直观理解)——第一部分
与逻辑回归和铰链损失的比较
网上关于这个话题的大部分材料都是用数学和很多细节来处理的，人们很容易失去对更广泛概念的理解。这里试图用很少的数学处理来直观地理解 SVM 的大部分细节。唯一的基本假设是，读者已经知道一些数学基础、逻辑回归以及机器学习的基本术语和概念。我计划在 3 个部分中涵盖这个主题"支持向量机(直观理解)"。在第一部分，我们将看看 SVM 的损失函数。
让我们从我们对逻辑回归的理解以及 SVM 与逻辑回归的区别开始。
在逻辑回归中，线 L1 定义了输入空间的概率分布。如果与 L2 线定义的分布相比，平均而言，L1 定义的分布在等级“-1”点较低，在等级“+1”点较高，则称 L1 线优于 L2 线。
SVM 的几个主要观点在概念上不同于逻辑回归—
第一部分:损失函数
第 2 部分:最大边际分类——在非常基本的层面上，在 SVM，如果 L1 的“边际”更大，即 L1 离这两个类别更远，则 L1 线被认为是比 L2 线更好的分类器。
第三部分:使用内核技巧的特征转换
让我们一个一个地看——
损失函数:首先，让我们从损失函数开始
让我们以一个简单的二元分类任务为例。然后，对于给定的输入特征“X”和目标“y”，SVM 算法的目标是为每次观察预测接近目标(“实际 y”)的值(“预测 y”)。来做这件事—
- 我们对一个可以计算“预测 y”的方程感兴趣。该等式取决于输入 x 的一些加权值，可以写成:
'预测 y ' = f(X 的加权值)。
让我们用 w 来表示我们的重量。
- 我们可以通过绘制随机决策边界(又名。这与预测“预测的 y”)的一些随机值是相同的，并且这正是当我们用随机值初始化上述等式中的权重时所发生的。
- 确定成本/损失函数。损失函数的任务是量化“预测 y”和“实际 y”之间的误差。简而言之，这定义了您想要对错误分类的观察进行惩罚的数量。因此，直觉上，“预测的 y”离“实际的 y”越远，惩罚就应该越大，反之亦然。给定我们在特定迭代中产生的总误差量，我们试图通过调整下一次迭代的权重来减少该误差。这种情况一直持续到我们无法再最小化总误差/成本。总误差/成本函数如下:
总误差/成本=迭代中每个观测值所有损失的总和。
4.在所有迭代结束时，我们得到的最终权重形成了我们用于预测未知数据的最终模型。
因此，对于 SVM，使用了一个称为“铰链损失”的损失函数——参考下图(来自维基百科)。
Plot of hinge loss on y-axis and ‘predicted y’ on x-axis.
注意，从上面的图(蓝线)可以看出，当
- “预测的y”≥1 且
- 实际的 y' 和预测的'y '具有相同的符号(意味着‘预测的 y' 预测正确的类)
但当'实际 y '，'预测y '符号相反时，铰链损耗随 y 线性增加(单边误差)。
SVM 使用铰链损失作为逻辑回归，使用逻辑损失函数优化成本函数并得出权重。铰链损失不同于逻辑损失的方式可以从下面的图中理解(来自维基百科——紫色是铰链损失，黄色是逻辑损失函数)。
Plot of various loss functions — Purple is the hinge loss function. Yellow is the logistic loss function.
请注意，黄线逐渐向下弯曲，不像紫色线，紫色线的“预测 y”值≥1 时，损失为 0。通过观察上面的图表，曲线的这种性质揭示了逻辑损耗和铰链损耗之间的一些主要差异
- 请注意，逻辑损失比铰链损失发散得更快。所以，一般来说，它会对异常值更敏感——为什么？因为，假设在我们的数据中有一个异常值，逻辑损失(由于其发散的性质)与异常值的铰链损失相比将非常高。这意味着对我们的权重进行更大的调整。
- 请注意，即使该点被充分自信地分类，逻辑损失也不会变为零——水平轴是“预测 y”值的置信度，如果我们在 x 轴上取值为“1.5”，则相应的逻辑损失(黄线)仍会显示一些损失(从上面的图中接近 0.2，因此对我们的预测仍不太有信心)，而铰链损失为“0”(这意味着没有损失，我们对我们的预测更有信心)。逻辑损失的这种性质可能会导致准确性的轻微下降。
- 逻辑回归有更多的概率解释。
基于对 SVM 铰链损失函数的理解，让我们在成本中加入一个正则项(L2 范数)。正则化项背后的直觉是，如果权重值很高，我们会增加成本损失。因此，在尝试最小化成本的同时，我们不仅调整权重，还尝试最小化权重的值，从而减少对训练数据的过度拟合，并使模型对异常值不那么敏感。
因此，添加正则化项后，总成本函数最终看起来像:
总成本= ||w ||/2 + C(每次观测的所有损失之和)*
其中“C”是控制正则化量的超参数。
根据我们选择的“C”的值，我们可以有一个硬边界分类器和一个软边界分类器。
- 如果 C 选择得足够小，使得总成本中的第二项可以忽略，那么我们称之为硬边界分类器。在这种情况下，我们在每次迭代中只最小化第一项(||w ||/2)，以达到调整后的权重。
- 如果 C 选择得足够大，则第二项不能被忽略，并且我们得到软边缘分类器。
在下一部分，我们将看看到底是什么原因导致 SVM 超平面远离自己(又名。最大化边缘)以便实现最大边缘分类器的概念。我们还将了解保证金的价值。
支持向量机(直观理解)——第二部分
最大差值分类的概念
网上关于这个话题的大部分材料都是用数学和很多细节来处理的，其中一个…
medium.com](https://medium.com/towards-data-science/support-vector-machines-intuitive-understanding-part-1-3fb049df4ba1)
这是关于这个主题的第一部分的延续。如果你愿意，请参考以上部分。
这里我们将讨论 SVM 固有的最大利润分类背后的直觉。问题陈述如下—
理想情况下，我们希望我们的分类线看起来像上图中的粗线。请注意，与虚线相比，粗线离其最近的数据点更远。那么，SVM 是如何做到这一点的呢？
首先，让我们复习一些基础知识来理解这一点。我们知道一个简单的线性方程由 a* x +b* y +c = 0 给出。我们将对 2D 使用这个简单的等式，这可以很容易地扩展到对 n D
一些基本假设—
- 我们将只考虑两个特性 x1，x2
- 一个目标类 y ，对于正类可以取+1，对于负类可以取-1。
- 设 x1i，x2i(对于 i = 1 到 n，组观察值 ) 代表个体' n' 对这些特征中的每一个的个体观察值 x1，x2 。
那么我们可以把我们的简单线性方程改写为 w1 **x1+w2 **x2+w0 = 0——只是代入:a = w1，b = w2，c = w0，x = x1 ，y =x2；其中 w1、w2 和 w0 是我们的优化算法将最终计算出的权重。
然后，对于任何观察说，( x1 i， x2 i) —
- w1 x1i+w2 **x2i+w0+0、** if ( x1 i、 x2 i)位于直线的一侧(当( x1 i、 x2 i)属于 y = +1 目标类时发生)
或
- w1 x1i+w2 **x2i+w0<0，如果( x1 i， x2 i)位于直线的另一侧(当( x1 i， x2 i)属于 y = -1 目标时发生**
将两个等式合并为一个:y**(w1 **x1i+w2 **x2i*+w0)>0，当 y =-1 或+1(仅在两边乘以目标值， y (+1 / -1)时，该等式适用于上述两种情况，因此该等式适用于正负两种分类
从几何学中，我们知道从点( x1 i， x2 i)到直线 w1* x1 +w2*x2+w0 = 0 的垂直距离(姑且称之为' m ')由下式给出
m=(w1 x1i*+w2 * x2i+w0)/**sqrt(w1+w2
请参考下面的链接，了解为什么会这样的简单推导
展示了如何找到一个点到一条线的垂直距离，以及公式的证明。
www.intmath.com](https://www.intmath.com/plane-analytic-geometry/perpendicular-distance-point-line.php)
考虑到归一化权重( w1 + w2 = 1)，我们可以去掉上一个等式中的分母，它简化为以下等式
w1 **x1i+w2 **x2i+w0 =m
通过在任一侧乘以目标值， y (+1 / -1)，该等式可以概括为对正类和负类进行分类。给定这一点，然后下面的内等式，**y (w1 **x1i+w2 **x2i+w0)≥m*，保证对于阴性/阳性目标类，每个观察值( x1 i， x2 i)位于/超出分类线两侧的距离“ m ”。在这里，‘m’被称为边距。
Margin = m
那么现在下一个问题来了，是什么原因导致 SVM 将利润最大化？答案在于优化第一部分中讨论的成本/损失函数。
- 正如我们从第 1 部分的图中注意到的，当“预测的y”≥1 时，铰链损失变为 0。
- 如第 1 部分所示的“预测的 y ”等于 w1* x1 + w2*x2 + w0(输入值的加权平均值，X)。
综合以上，当 w1* x1 + w2x2 + w0 ≥ 1 时，铰链损耗为 0。同样，通过在任一侧将此乘以 y (+1 / -1)的目标值，使得该等式可以概括为分类正类和负类。这样，我们得到:y**(w1 **x1*+w2 * x2+w0)≥1。与之前的等式(粗体)相比，我们可以看到裕量 m 等于 1。根据我们使用的铰链损耗函数，我们可以将这个裕量更改为我们想要的值。优化算法将计算出权重，使得上述等式成立，以便最小化损失函数。
margin value on x-axis vs loss on y-axis
从上面的图中，请注意—
- 对于离分类线相当远的所有点，余量， m 大于 1。所以他们的损失= 0(蓝线)。因此，只有在分类线附近( m ≤1)的点才真正影响权重。
- 对于更远的点( m > 1)，无论如何损失函数是 0，因此当优化算法遇到这样的更远的点时，不对权重进行调整。
- 为此，( m ≤1)的点称为 支持向量 ，因为它们支持/影响分类线。为什么是矢量？—因为任何点都是数据空间中的向量。
这里需要注意的重要一点是，第 1 部分中“预测 y”的概念只不过是边缘值的概念， m. 如果“m”高(=“预测 y”高)，那么该点离分类线更远，因此我们更确信观察值肯定属于所识别的类别。这正是最大间隔分类器背后的概念。
最后，通过控制我们在第 1 部分中讨论的成本函数中的正则化参数“C ”,我们间接操纵每个观察值的裕量‘m’(x1I， x2 i ),从而调整缓冲/松弛量，我们同意，在对数据进行错误分类时。如果“C”选择得更高，那么我们允许更多的缓冲数据被错误分类，反之亦然。我们可以直观地理解这一点，考虑一个让‘C’= 0 的极限情况，这意味着我们不允许任何缓冲。然后，请注意，损失函数只是简化为优化成本=||w ||/2(我们在第 1 部分中讨论了这一点作为硬间隔分类器)，这意味着我们需要取得平衡以减少权重(使上述成本函数最小)，同时实现 1 的间隔(因为我们希望 w1* x1 + w2*x2 + w0 ≥ 1)。组合的这种性质不允许任何错误分类的缓冲，因此被恰当地称为硬边界分类器。
在下一个也是最后一个部分，我们将看看如何使用内核技巧来完成特性转换。
支持向量机(SVM)
简介:
支持向量机可能是最受欢迎和谈论最多的机器学习算法之一。它们在 20 世纪 90 年代开发的时候非常流行，并且仍然是几乎不需要调整的高性能算法的首选方法。在这篇博客中，我们将描绘 SVC 的各种概念。
映射的概念:
1。什么是 SVM？
2。SVM 背后的意识形态。
3。直觉发展。
4。SVM 使用的术语。
5。超平面(决策面)。
⑥。硬保证金 SVM。
7。软利润 SVM。
8。SVM 的损失函数解释。
9。SVM 的双重形式。
10。什么是内核诡计？
11。内核的类型。
12。SVM 的利与弊。
13。为 SVM 准备数据。
14。模型应用
1.什么是 SVM？
被称为 SVM 的支持向量机是一种 监督学习算法 ，可用于支持向量分类(SVC)和支持向量回归(SVR)等分类和回归问题。它用于较小的数据集，因为处理时间太长。在这一集中，我们将关注 SVC。
2.SVM 背后的意识形态:
SVM 是基于寻找一个超平面的想法，该超平面最好地将特征分成不同的域。
3.直觉发展:
考虑以下情况:
有一个跟踪者正在给你发邮件，现在你想设计一个函数(超平面)来明确区分这两种情况，这样无论何时你收到一封跟踪者发来的邮件，它都会被归类为垃圾邮件。下面是绘制超平面的两种情况，你会选择哪一种，为什么？花点时间分析一下情况……
我猜你会选无花果。你想过你为什么要选无花果吗？因为图(a)中的电子邮件是明确分类的，与图(b)相比，你对此更有信心。基本上，SVM 是由提出一个 最优超平面 的想法组成的，它将清楚地分类不同的类(在这种情况下，它们是二元类)。
4.SVM 使用的术语:
离超平面最近的点称为 支持向量点 ，向量离超平面的距离称为 边距 。
这里要发展的基本直觉是，SV 点离超平面越远，在它们各自的区域或类中正确分类这些点的概率就越大。SV 点在确定超平面时非常关键，因为如果向量的位置改变，超平面的位置也会改变。技术上这个超平面也可以称为边缘最大化超平面 。
5.超平面(决策面):
在这篇文章中，我们已经讨论超平面很久了，让我们在继续讨论之前证明它的意义。超平面是用于区分特征的函数。在 2-D 中，用于在特征之间分类的函数是一条线，而用于在 3-D 中分类特征的函数被称为平面，类似地，用于在更高维度中分类点的函数被称为超平面。现在，既然你知道了超平面，让我们回到 SVM。
假设有“m”个维度:
因此,“M”维中超平面的方程可以表示为=
在哪里，
Wi =向量(W0，W1，W2，W3……Wm)
b =有偏项(W0)
X =变量。
6.硬利润 SVM:
现在，
假设 3 个超平面，即(π，π+，π)，使得‘π+’平行于穿过正侧支持向量的‘π’，而‘π’平行于穿过负侧支持向量的‘π’。
每个超平面的方程可以被认为是:
对于点 X1:
解释:当点 X1 时，我们可以说该点位于超平面上，并且方程确定我们的实际输出和超平面方程的乘积为 1，这意味着该点被正确地分类在正域中。
对于 X3 的观点:
解释:当点 X3 时，我们可以说该点远离超平面，并且该方程确定我们的实际输出和超平面方程的乘积大于 1，这意味着该点被正确地分类在正域中。
对于点 X4:
解释:当点 X4 时，我们可以说该点位于负区域中的超平面上，并且该方程确定我们的实际输出和超平面方程的乘积等于 1，这意味着该点被正确地分类在负区域中。
对于点 X6:
解释:当点 X6 时，我们可以说该点远离负区域中的超平面，并且该方程确定我们的实际输出和超平面方程的乘积大于 1，这意味着该点被正确地分类在负区域中。
让我们看看未分类的约束条件:
对于点 X7:
解释:当 Xi = 7 时，点被错误地分类，因为对于点 7，wT + b 将小于 1，这违反了约束。所以我们发现了由于违反约束而导致的错误分类。同样，我们也可以说对于点 Xi = 8。
由此从上面的例子中，我们可以得出，对于任意一点 Xi，
如果易(WTXi +b) ≥ 1:*
那么 Xi 被正确归类
其他:
Xi 被错误归类。
因此，我们可以看到，如果这些点是线性可分的，那么只有我们的超平面能够区分它们，如果引入任何异常值，那么它就不能将它们分开。所以这些类型的 SVM 被称为 作为硬边界的 SVM (因为我们有非常严格的约束来正确地分类每一个数据点)。
7.软利润 SVM:
我们基本上认为数据是线性可分的，这可能不是现实生活中的情况。我们需要更新，以便我们的函数可以跳过一些异常值，并能够对几乎线性可分的点进行分类。为此，我们引入一个新的 松弛变量( ξ)，称为 Xi。
如果我们把ξ it 引入前面的方程，我们可以把它改写为
Introduction of Xi
如果ξi= 0，
这些点可以被认为是正确分类的。
其他:
ξi > 0，错误分类分。
因此，如果ξi> 0，这意味着 Xi(变量)位于不正确的维度，因此我们可以认为ξi 是与 Xi(变量)相关的误差项。平均误差可由下式给出:
average error
因此我们的目标，在数学上可以描述为；
其中ξi = ςi
这种方法被称为软边界技术。
8.SVM 的损失函数解释:
when Zi is ≥ 1 then the loss is 0
when Zi < 1 then loss increases.
因此，可以解释为铰链损耗最大(0，1-Zi)。
9.SVM 的双重形式:
现在，让我们考虑当我们的数据集根本不是线性可分的情况。
基本上，我们可以像在逻辑回归中一样，通过向数据点添加相关的特征，将数据点投影到更高的维度中，从而分离每个数据点。但是有了 SVM，就有了一种强大的方法来完成将数据投射到更高维度的任务。上述公式是 SVMT3 的 原形。另一种方法是对偶形式的 SVM，它使用 拉格朗日乘数 来解决约束优化问题。
注:
如果αi > 0，则 Xi 是支持向量，当αi=0 时，则 Xi 不是支持向量。
观察:
- 为了解决实际问题，我们不需要实际的数据点，而只需要每对向量之间的点积就足够了。
- 为了计算“b”偏差常数，我们只需要点积。
- SVM 对偶形式相对于拉格朗日公式的主要优点是它只依赖于 α 。
10.什么是内核诡计？
即将来到 SVM 最著名的主要部分， 内核绝招 。核是在某些(非常高维)特征空间中计算两个向量 x 和 y 的点积的一种方式，这就是为什么核函数有时被称为“广义点积”。
try reading this equation…
s.t = subjected to
应用核技巧意味着用核函数替换两个向量的点积。
11.内核类型:
- 线性核
- 多项式核
- 径向基函数核(RBF)/高斯核
我们将集中在多项式和高斯核，因为它是最常用的。
多项式内核:
一般来说，多项式核定义为；
b = degree of kernel & a = constant term.
在多项式核中，我们简单地通过增加核的幂来计算点积。
示例:
假设最初 X 空间是二维的
Xa = (a1，a2)
Xb = (b1，b2)
现在，如果我们想将数据映射到更高维度，比如说在六维的 Z 空间中，看起来可能是这样的
为了求解这个对偶 SVM，我们需要(转置)Za ^t 和 Zb 的点积。
方法 1:
传统上，我们会通过以下方式解决这个问题:
这将花费很多时间，因为我们必须在每个数据点上执行点积，然后计算点积，我们可能需要做乘法，想象一下对数千个数据点这样做…
或者我们可以简单地使用
方法二:
使用内核技巧:
在这种方法中，我们可以通过增加幂的值来简单地计算点积。简单不是吗？
径向基函数核(RBF)/高斯核:
高斯 RBF(径向基函数)是另一种流行的核方法，用于 SVM 模型。RBF 核是一个函数，它的值取决于到原点或某个点的距离。高斯核具有以下格式:
||X1 — X2 || = Euclidean distance between X1 & X2
使用原始空间中的距离，我们计算 X1 和 X2 的点积(相似性)。
注:相似度是两点之间的角距离。
参数:
- c:正则化强度的倒数。
行为:随着“c”值的增加，模型变得过拟合。
随着“c”值的减小，模型的拟合度降低。
2.γ:γ(仅用于 RBF 核)
行为:随着“ γ ”值的增加，模型变得过拟合。
随着' γ 的值减小，模型欠拟合。
12.SVM 的利与弊:
优点:
- 在更高维度真的很有效。
- 当特征数多于训练样本数时有效。
- 类可分时的最佳算法
- 超平面仅受支持向量的影响，因此异常值的影响较小。
- SVM 适合极端情况下的二元分类。
缺点:
- 对于较大的数据集，需要大量的时间来处理。
- 在重叠类的情况下性能不佳。
- 适当选择 SVM 的超参数，以获得足够的泛化性能。
- 选择合适的内核函数可能很棘手。
13.为 SVM 准备数据:
1。数值转换:
SVM 假设你的输入是数字的，而不是分类的。所以你可以用一个最常用的"one hot encoding、label-encodingetc"来转换它们。
2。二进制转换:
由于 SVM 只能对二进制数据进行分类，所以您需要使用( 一对一对其余的 方法/ 一对一对一方法 )转换方法将多维数据集转换为二进制形式。
14.模型应用:
由于这个帖子已经太长了，所以我想到把编码部分链接到我的 Github 账号( 这里 )。
参考资料:
导师:
Harshall Lamba，新潘韦尔皮莱工程学院助理教授。
Riot API 的第 2 部分:表层故事。
从我的上一篇文章继续，我已经扩展了我的数据集很多，在修补和清理数据后，我创建了一个 98 场比赛的 CSV，每场比赛包含 10 名球员数据(5 v 5)。
更新*虽然我第一次尝试使用 Riot API 是为了适应一般的 API，但我从玩家 Doublelift 那里获得的数据集太小，无法对其进行任何重要的建模(最近 10 场游戏)。所以下一步是撒下更大的网来合作。结果是一个由 98 场比赛组成的数据集，每场比赛由 10 名球员组成。我没有选择基于一个特定玩家的数据子集，而是收集了 25 个游戏，并在这些游戏中收集了一系列游戏 id，以便将这些数据子集化为玩家数据的匹配项(说起来容易做起来难)。所以我们来分解一下。
980x by 61x
我的目标是得到一个包含 1000 个匹配的数据集，但是我承认只有 980 个。我仍然习惯于速率限制，并一度设置了一个定时器，在每 10 个请求后暂停。我想提到的是，我对将匹配数据分割成由匹配 ID 链接的单独的行有所保留，因为我的意图是使用二进制“赢家”目标将特征拟合到逻辑回归模型中。我不想在特性中执行数据泄漏，所以我必须删除将每一行链接在一起的列。因此，我觉得像“团队”这样的功能必须放弃。
df.drop('Team',inplace=True,axis=1)
df.drop('combatPlayerScore',inplace=True,axis=1)
df.drop('unrealKills',inplace=True,axis=1)
df.drop('firstInhibitorKill',inplace=True,axis=1)
df.drop('Player:',inplace=True,axis=1)# Later on I took out the item features
feat = [c for c in df.columns if not c.startswith("item",0,4)]
df_no_items = df[feat]
我还做了一个 bool 到 int 的转换
df['winner'] = df['winner'].map({True:0,False:1})
df['firstBloodAssist'] = df['firstBloodAssist'].map({False:0,True:1})
df['firstBloodKill'] = df['firstBloodKill'].map({False:0,True:1})
df['firstTowerAssist'] = df['firstTowerAssist'].map({False:0,True:1})
df['firstTowerKill'] = df['firstTowerKill'].map({False:0,True:1})
df['firstInhibitorAssist'] = df['firstInhibitorAssist'].map({True:1,False:0})
现在下一个问题是处理冠军 Id，它是由我想要虚拟的 int 组成的。这是我开发数据的第一个分支。每个数字对应一个特定的 Lol 冠军，每个冠军包含一个类和子类。为了简单起见，我决定把每个冠军的 ID 和它的相关职业(刺客、坦克、战士、法师、射手、支援)分开，并把这些类别虚拟出来。为此，我将主数据帧映射到一个单独的静态字典，该字典由 Champion ID 及其关联的类组成(这可以在 API 的静态数据中找到，不会计入您的总请求限制)。现在我们可以虚拟这些类，并开始绘制数据。
现在，随着类被转换为虚拟类，我们现在可以开始建模了。(放下刺客假人以避开假人陷阱。。。)
我的第一个问题是想看看死亡的分布。在 python 和 seaborn 中，我做了一个简单的直方图。一个相当健康的正左倾分布，这是有道理的。我注意到一些山谷表明，玩家要么不杀任何人，当他们做的时候，大约是 5-8 人。但总的来说，这些数据并不能真正说明问题。让我们深入下去。
进入画面，我们现在可以建立一个叙事，看看谁在做所有的杀戮。从我的观察中，我们可以看到支援和坦克职业与重型[刺客，战士，法师，神射手]之间的良好关系。(你希望你的核心 DPS/Carries 获得击杀，因为它会产生更多的黄金和经验，这应该与胜利相关。简而言之，你不希望你的支援职业从你的核心玩家那里流失可能的资源(然而我们可以在柱状图中间看到一些顽固的坦克和支援，可能是杀贼)
我的下一个问题是查看黄金的平均分布。
在《英雄联盟》中，一个吸引人(取决于你问的是谁)的游戏特色是，你不会因为死亡而受到惩罚，但当你真的死亡时，你会给你的对手一个优势。
快速观察显示，大买家是战士、射手和刺客(他们通常携带武器，需要花费更多来完成更大的物品集)。高收入者似乎是神枪手/战士，因为他们更频繁地占据外侧右侧。我假设拥有一套专注于伤害的技能可以转化为更高的黄金产量。支撑物和坦克位于坚固的中间区域，这暗示着玩家正在相应地适应他们的角色。
有一点让我印象深刻，那就是法师职业在花费和收入上的频率，这表明这个角色在物品购买上比坦克和支援角色更灵活。理想情况下，你不会希望支持者购买高端物品，因为这毫无意义，而且你也不会希望你的核心玩家浪费时间和金钱去建造像病房这样的实用物品。
总的来说，我做了一些表面模型，但还没有像我希望的那样深入研究数据。下周我将探索建模能力，尝试一些逻辑预测。到目前为止，它只是加强概念，稍微深入一点。
关于我的树莓 pi 3 项目，我已经让相机工作。现在我只需要设置好 OpenCV，就可以开始了！神经网络我们来了！！！
视觉工作的惊人方式
…不像卷积神经网络看到的那样。
“我一直坚信，让人工智能工作的唯一方法是用类似于人脑的方式进行计算……”——杰弗里·辛顿
在一位同事分享他遇到的一些关于感知的令人惊讶的事实之前，我对视觉感知的大多数了解都来自于研究应用于不同领域图像的卷积神经网络(CNN)的变体。
CNN 没有模仿所有人类视觉感知系统的属性，也没有模仿(没关系)。研究是要突破今天的界限，有时是看似很小的一步。
颜色感知是一项空间任务
Adelson’s Checker-shadow³. To most viewers, area A appears to be a darker color than area B (top figure) when in fact both areas have identical color (seen clearly in bottom figure)
想想这些阿德尔森的棋盘格影子人物。对于大多数观众来说，区域 A 看起来比区域 B(上图)更暗，而实际上两个区域的颜色相同(下图清晰可见)。下图与上图相同，只是去掉了 B 区周围的方块，而 B 区保持不变。移除 B 区域周围的方块会改变观察者的感知——A&B 区域看起来颜色相同。颜色感知是一项空间任务。改变一个区域的环境可以改变我们对该区域颜色的感知。
色觉是空间任务的另一个例子:
Top figure: Small grey squares are perceived to be colored differently when in fact they are same color. Bottom figure: The added context (spatial information) removes the perception of color difference among small grey squares. (Just to be clear, the small grey squares are indeed identically colored in both top & bottom figures.)⁴
认为人类仅仅从一个区域反射的光来感知一个区域的颜色很有诱惑力，但这是错误的。事实上，我们的感知系统也处理来自该区域周围的光，以确定该区域的颜色。
起初，这似乎令人惊讶。但是考虑到照明的光谱组成在我们生活的环境中变化的事实。从一个小区域反射回来的光总是被照明的变化所混淆。我们的感知系统依赖于对来自邻近区域的光的相对量的理解来忽略照明的变化。因此，即使在变化的光照下，我们也能更准确地感知颜色。这种观察的技术术语是颜色恒常性。
脚注
- 在本小节中，更准确的说法是指一个区域的反射特性而不是一个区域的颜色。
- 颜色恒常性指的是观察到颜色在光照发生较大变化时保持不变。⁵ ⁶
每个人都是色盲
同色异谱是指不同光谱成分的光可以给观察者产生完全相同的外观(看起来是相同的颜色)的现象。⁷
Response curves of the 3 types human cone receptors (denoted S, M, L). Y-axis is response. X-axis is wavelength(nm).⁸
人类眼睛里有三种视锥受体。这三种受体对可见光谱中的短波(S)、中波(M)和长波(L)做出反应。
当光线照射到眼睛时，L、M 和 S 受体分别被长、中和短波长的光子激发。
假设单一波长的光源 x 导致产生与完全相同的 L、M 和 S 响应，另一个光源包括两个波长 y 和 z 。这两种光源看起来是相同的颜色！这种现象叫做同色异谱。
Illustration of a light source of single wavelength x causing identical responses as another light source comprising two wavelengths y & z. Only M & L receptor response curves shown for simplicity. ⁹
更具体地说，同色异谱出现在这种情况下是因为:
M-cone 输出为 x = M-cone 输出为 y + M-cone 输出为 z
和 L-cone 输出为 x = L-cone 输出为 y + L-cone 输出为 z
为了简单起见，省略了 S 受体。此外，为简单起见，仅讨论了 3 种波长。
Different spectra perceived as same color. ⁹
同色异谱在日常生活中的一个例子是衣服在不同的光线下会变色(例如，在商店灯光下与阳光相比颜色不同)。在许多情况下，这是因为衣服被带有⁰.同色异谱特征的染料染色
脚注
- 这个在线实验通过让你调整红色、绿色和蓝色强度来匹配所显示的色块，来确定你对条件配色现象的主观等同点。
- 有些人是四色视者，这意味着他们有 4 种视锥受体，而不是通常的 3 种，这些人比大多数人看到更多的颜色。有些动物，如螳螂虾，拥有 12 种锥状感受器。
咬合印痕
当一个物体在另一个物体后面时，后面的物体被前面的物体遮挡。
From left to right, increasing impression of a white rectangle occluding black objects.¹¹
左图微弱地给观众留下一个白色物体挡住(遮挡)黑色矩形的印象。咬合的印象在中图中加强，在右图中最强。尽管这些图没有明确显示物体相互遮挡，我们还是感觉到了遮挡。这些遮挡的印象是由于我们的感知系统以独特的方式对待物体边界。
感知不是物理现实
Müller-Lyer illusion. Most viewers perceive the top horizontal line as being longer than the bottom horizontal line. Actually, both lines are the same length.
Ebbinghaus illusion or Titchener circles.Most viewers perceive the center circle of the left cluster to be smaller than the center circle of the right cluster. Actually, both center circles are the same size.¹²
上述错觉表明，我们所感知的可能会偏离物理现实。这证明了感知不仅仅是关于进入我们眼睛的视觉阵列(物理光)。感知包括更高层次的过程。
交替感知
考虑以下导致我们的感知在解释之间交替的演示。
Necker’s cube. Most viewers alternate between interpretations of these cubes’ orientations.¹³
Spinning dancer. Center figure: Most viewers flip back and forth between interpretations of the dancer’s spin direction (clockwise or anti-clockwise). Left & right figures have added contours that help the viewer’s perception stabilize on a clockwise and anti-clockwise spin interpretation respectively.¹⁴
当观看这些演示时，注意到你的感知是如何在不同的解释中交替变化的吗？还要注意你如何一次只能持有一种解释(而不是同时感知两种解释)？这些观察表明感知伴随着类似于选择的认知过程。
脚注
多稳态感知和双稳态感知是这种现象的专业术语。
来自上述假设的光线
下面的论证表明，我们的感知偏向于相信光来自上方。
To most viewers, the left sphere appears convex and right sphere appears concave. But the right sphere is merely a 180 degree rotation of the left sphere.
To most viewers, the left crater appears concave and the right crater appears convex. But the right crater is merely the image of the left crater rotated 180 degrees.¹⁵
仅仅通过旋转上面的图像就获得了不同的解释，这是因为我们的感知偏向于光来自上方的信念。这种偏见是由我们适应环境统计规律的感知系统建立起来的。
脚注
更准确地说，这种偏置假设的光线方向是“左上”而不是正上方。这与我们是左撇子还是右撇子无关。⁶
结论
这篇文章中提到的惊喜源于我们的感知系统已经进化到适应我们的环境。进化/适应(类似于机器学习)已经产生了一些怪癖，可以通过研究这些怪癖来更好地理解人类感知并改进感知的现代实现(例如卷积神经网络)。
- 罗杰斯，布莱恩(2017)。观感:一段很短的介绍。牛津大学出版社，2017 年
- https://www . utoronto . ca/news/u-t-computer-scientist-takes-international-prize-grounding-work-ai
- 爱德华·阿德尔森(2005 年)。【方格阴影错觉】
- 来源https://www . ted . com/talks/beau _ lotto _ optical _ imaginations _ show _ how _ we _ see
- 贾德博士(1940 年)。彩色照明下表面颜色的色调饱和度和亮度。 JOSA ， 30 (1)，2–32。
- E.Hering，Grundzuge der Lehre vom Lichtsinn，Graefe-Samischs《第十二届妇女大会手册》(1905 年和 1907 年)。
- 桑顿 W. A. (1998)。同色异谱干扰色彩空间有多强。颜色研究&应用:由国际社会颜色委员会、颜色组织(英国)、加拿大颜色学会、日本颜色科学协会、荷兰颜色研究学会、瑞典颜色中心基金会、澳大利亚颜色学会、法国颜色中心 23(6)，402–407 批准。
- 来源 https://en.wikipedia.org/wiki/Cone_cell
- 改编自http://Jim-stone . staff . shef . AC . uk/psy 305/Lectures _ pdf/L10 _ colour theory _ v4 . pdf
- https://blog.1000bulbs.com/home/what-is-metamerism
- Gillam 和 p . j . Marlow(2014 年)。比较 Kanizsa 正方形和线性边缘对齐的主观轮廓(“纽约泰坦尼克号”图)。感知， 43 (9)，977–988。
- 来源https://www . research gate . net/figure/The-Ebbinghaus-Illusion _ fig 1 _ 310505100
- 洛杉矶内克(1832 年)。“观察在瑞士看到的一些显著的光学现象；以及在观察晶体或几何立体图形时出现的光学现象”。伦敦和爱丁堡哲学杂志和科学杂志。1(5):329–337
- 来源https://imgur.com/gallery/kcaw8OI。最初由网页设计师 Kaya hara Nobuyuki(2003)http://www.procreo.jp/labo.html
- 来源https://en.wikipedia.org/wiki/Crater_illusion
- 马马西安，p .&古彻，R. (2001 年)。照明位置的先验知识。认知， 81 (1)，B1-B9。
Source https://www.deviantart.com/vintagexxrose/art/evil-eye-329099696
理想的工作生活平衡是怎样的？
时间和金钱哪个更重要？
一份工作
每天，全世界有数百万人去找一份叫做工作的工作。前提很简单。给一家公司你的时间、劳动和智力，他们会给你一种叫做钱的东西。然后你可以用这些钱去购买生存所需的东西:食物、住所、动感单车课程等等。
我最近读了一篇文章，说平均每周工作时间是 47 小时。我想起了大三的一堂英语课，老师让全班同学在五份工作中做出选择:
- 每周工作 40 小时，年薪 4 万美元
- 每周工作 50 小时，年薪 5 万美元
- 每周工作 60 小时，年薪 6 万美元
- 每周工作 70 小时，年薪 7 万美元
- 每周工作 80 小时，年薪 8 万美元
尽管我的班级很小——只有 12 个人——但我是唯一一个想每周工作 80 小时，年薪 8 万美元的人。当时，我很困惑——难道我的同学不明白，如果他们赚了更多的钱，他们就可以买更多的东西吗？
从那以后，我意识到赚更多的钱通常是以花更少的时间为代价的。尽管如此，由于相对年轻，现在有了选择，我的一部分仍然倾向于选择第五个选项，因为，说实话，我还能利用空闲时间做什么呢？
但是我想知道其他人是否也有这种感觉。
调查时间到了
所以我发出了一份调查。
我在网上招募了 411 人，女性 260 人，男性 151 人。
我让参与者想象他们正在他们目前居住的城市或城镇开始一份新的工作。他们可以在 5 份他们喜欢但不喜欢的几乎相同的工作中做出选择。我向他们展示了我的英语老师提供的五小时工资选项，并告诉他们，他们选择的工作将是他们在可预见的未来会得到的相同工资。
我首先让参与者选择一份工作，假设他们是单身。为了混淆视听，我让他们选择一份工作，假设他们的丈夫每周工作 50 小时，年薪 6 万美元，但没有孩子(现在或可预见的将来)。
那么大家是怎么想的？
结果如下:
不管婚姻状况如何，大多数人都希望工作时间更短，收入更少。
无论是单身还是已婚，超过四分之三的人表示，他们更愿意每周工作 40 或 50 个小时，年薪 4 万或 5 万美元。很明显，我想把醒着的所有时间都花在工作上的愿望并不是大多数人都有的想法。
如果人们更年轻，他们更愿意工作更长时间。
我把人们分成三个年龄组——20 到 39 岁，40 到 59 岁，60 到 79 岁。最年轻年龄段的人总是愿意比其他两个年龄段的人工作更长时间。在单一情景中，31.1%的 20-39 岁的人选择每周工作 60 小时以上，而 40-59 岁和 60-79 岁的人分别为 19.5%和 11.5%。
当人们结婚后，选择每周工作 60 小时以上的 20-39 岁人群的比例下降到 25.2%。然而，这仍然高于其他两个年龄组。
男性选择工作更长时间。虽然女性的工作偏好在婚后保持不变，但男性的偏好向中间靠拢。
与女性相比，更多的男性更喜欢每周工作 60 小时以上。不管他们是单身(32.4%的男性对 21.3%的女性)还是已婚(29.2%的男性对 18.2%的女性)，情况都是如此。
结婚后，女性的反应略有变化，而最初选择 40 和 80 小时工作周的男性倾向于 50 和 60 小时工作周。很明显，有些人想通过工作来躲避他们的配偶(这是个笑话)。实际上，有些男人可能想多工作，因为他们不想挣得比配偶少，而另一些男人可能只是想在经济上多支持他们的配偶，
我梦想工作与生活的平衡
大多数人都不想像我高中时那样拼命工作。我不知道工作 80 小时是什么感觉。工作几年后，我梦想着减少工作量，即使这意味着减薪。这就是我决定研究工作与生活平衡的原因:它意味着什么，它是否实际存在，以及如何实现它。
你可能喜欢的其他文章
如果你喜欢这篇文章，请访问LateNightFroyo.com，阅读关于爱情、生活等话题的话题。
探索 Python 中客户流失的生存分析
生存分析是指一套统计技术，用于推断、【寿命】、或事件时间序列，而无需观察训练集中每个受试者感兴趣的事件。感兴趣的事件有时被称为受试者的【死亡】，因为这些工具最初被用于在临床试验中分析药物治疗对患者存活率的影响。
同时，客户流失(定义为 c 客户保持的反义词)是许多面向客户的企业渴望最小化的关键成本。没有预测哪些客户会流失的银弹方法(在如何定义客户是否已经流失非订阅产品时，必须小心谨慎)，但是生存分析为探索时间-事件系列提供了有用的工具。
为什么我们不能用 OLS 线性回归呢？
OLS 通过绘制最小化误差平方和的回归线来工作。然而，对于未观察到的数据，误差项是未知的，因此不可能使这些值最小化。
简单地将审查的日期作为所有受试者已知的有效最后一天，或者更糟的是，删除所有被审查的受试者会使我们的结果产生偏差。
Not all deaths have been observed by t1, the time of observation. Image by author.
在上图中，U002 从损失到跟进都经过了审查(例如，可能是由于账户上的一个未解决的技术问题导致客户在数据提取时的状态未知)，而 U003 和 U004 经过了审查，因为它们是当前客户。截止到 t1 ，只有 U001 和 U005 都观察到了出生和死亡。如图所示，删除未观察到的数据会低估客户的寿命，并使我们的结果产生偏差。
生存分析处理事件审查完美无缺。被审查的客户，是死亡没有被观察到的客户。发生这种情况的主要原因是在观察时客户的生命周期尚未结束。(注意:在临床试验中，失访或退出研究的患者也被视为审查对象。)
卡普兰-迈耶曲线
对于每个主体(或顾客，或用户)只能有一个“出生”(注册、激活或签约)和一个“死亡”(不管是否被观察到)的任何问题，第一个也是最好的起点是卡普兰-迈耶曲线。这将允许我们估计一个或多个队列的“生存函数”,这是生存分析中最常用的统计技术之一。
生存分析可以作为一种探索性的工具，用来比较不同群体、不同客户群或不同客户原型之间的客户寿命差异。在 Python 中，我们可以使用 Cam Davidson-Pilon 的生命线库来开始。
以这个 IBM Watson telco 客户演示数据集为例。通过对单条电话线与多条电话线的二元特征进行分段，我们得到以下 Kaplan-Meier 曲线。
Customers with one phone line have a steeper survival curve initially, but by ~4 years 3 months customer lifetime the error bars make the two groups indistinguishable. Image generated using matplotlib by author.
我们可以看到，在只有一条电话线的用户中，有 1/4 的用户在第 25 个月时发生了变化。相比之下，在拥有多条电话线路的用户中，1/4 的用户在 43 个月前流失，相差 18 个月(额外 1.5 年的收入！)
相关性不是因果关系，因此这张图本身不能被认为是“可操作的”。然而，我们可能会看到这一点，并开始怀疑一些可能性，如拥有多条电话线的客户更“固定”，因此比单电话线用户更不容易流失。另一方面，也许更忠诚的客户首先倾向于选择多条电话线。
谁应该得到更多的投资？如果这两个集团的利润相当，那么花更多的钱来让单线电话用户满意可能是值得的，因为他们目前倾向于更快地流失。或者，一个实验性设计可以揭示一些激励措施可以使所有客户、的生命周期翻倍，并且由于多线路用户的生命周期最初往往更长，这种倍增效应实际上会为该细分市场带来更多利润。
如果没有更多的背景，以及可能的实验设计，我们无法确定。
卡普兰-迈耶曲线的利弊
优点:
- 需要最少的功能集。Kaplan-Meier 只需要事件发生的时间(死亡或审查)和出生与事件之间的生命周期。
- 许多时间序列分析很难实现。卡普兰-迈耶只需要所有的事件都发生在感兴趣的同一时间段内
- 自动处理类别不平衡(死亡与审查事件的任何比例都可以)
- 因为它是一种非参数方法，所以很少对数据的基本分布进行假设
缺点:
- 无法估计感兴趣的生存-预测关系差异的大小(无风险比或相对风险)
- 无法在事件发生时间研究中同时考虑每个受试者的多个因素，也无法控制混杂因素
- 假设删截和存活之间是独立的，这意味着在时间【that，那些已经删截的人应该和那些没有删截的人有相同的预后。
- 因为它是一个非参数模型，在底层数据分布已知的问题上，它不如竞争技术有效或准确
现在自己试试吧！
要查看我是如何制作这个卡普兰-迈耶图的，并开始你自己的生存分析，从我的 Github 账户下载 jupyter 笔记本。
Lauren Oldja 是纽约布鲁克林的一名数据科学家。
最快的生存者
Photo Credit: Martyn Goddard
“即使你有最好的产品，如果你是第三个推出你的产品的人，那么你也只是损失了该产品潜在价值的 50%。”—辉瑞副总裁兼总经理 Peter Stevenson
曾经需要几十年的市场变化现在只需几周甚至几个月就能发生。自动化、分析和人工智能(AI)的不可阻挡的崛起正在加速以前所未有的速度开展业务、创造价值、做出决策、满足客户期望，并在竞争对手之前将产品和服务推向市场。很简单，速度决定了你是破坏还是被破坏，因为在这个快节奏的机器时代，不领先就意味着落后。如今，许多标准普尔 500 公司的股东报告中充斥着“速度”、“快”及其同义词，这并非巧合。
10 年前，随着全球化无情地压低单位成本，企业不得不学会以“中国价格”竞争。今天，你的企业需要通过适应“谷歌价格”和“谷歌速度”来做出另一个改变。随着科技企业家利用数字平台并迅速积累数十亿美元的财富，从而挑战传统的商业模式和行业，任何市场的准入门槛都大大降低了。考虑以下几点:
在我们对 500 名 IT 经理的未来工作调查中，报告的第一个问题是他们的业务太慢，无法有效地利用数字化。
一项新的研究证实，许多零售商在创造竞争优势和新收入来源的领域投资过于缓慢，这使他们面临被行动更快、更具创新性的零售企业超越的风险。
数据是新的石油，但公司充斥着数据。如果你的决策周期需要几个月，即使是关键任务项目，你也无法赶上游戏的速度。使用高级分析和机器学习的公司成为前四分之一财务表现者的可能性是前者的两倍，执行有效决策的可能性是后者的三倍。
一些公司已经在速度要求上展开竞争。他们正在转变行业商业模式，挑战现状，采取行动，承担风险，永远改变游戏规则。例子包括:
Reliance Jio 在印度的成功仅用了 170 天就达到了 1 亿用户，相当于每天每秒 7 个用户，迫使竞争对手降低了价格。
对于阿迪达斯，来说，速度要求围绕着“显著缩短上市时间并与客户保持同步。”为了实现这一目标，阿迪达斯正在彻底重塑其商业模式，从产品系列规划到产品创新、采购、供应链、上市和销售。它的目标是到 2020 年，50%的销售额来自重塑后的业务
ANZ 银行正在利用人工智能实现后台自动化，以缩短无担保和个人贷款审批的上市时间。据该银行的首席技术官称，由于自动化程度的提高，已经减少了 1，000 小时的后台活动。
西班牙电信巨头 telefónica正在改变其业务 DNA 以创建一个全数字、数据驱动的身份。该公司在全球范围内彻底改革了其核心业务流程和系统，目标是转向能够对快速变化的业务环境做出反应的实时业务模式。
荷兰银行 ING 已经设立了一个转型“作战室”来全面了解所有项目的状态，并快速解决问题。目标是加速沟通和决策。
更快的上市时间是竞争的需要，这种压力不会很快消失。商业新陈代谢的速度需要提高。当银行意识到与金融科技初创公司对抗毫无意义时，它们就与它们合作。如今，许多大银行正在向初创公司投入数百万美元。
那么，在这个新的、大胆的世界里，组织如何才能加快速度，赢得胜利呢？你不必一下子就想明白。你只需要愿意开始并做出成功所需的组织变革。在一系列较小的任务中取得成功，远比在试图像大爆炸一样解决转型计划时遭遇惨败更令人向往。设定方向，在沙地上画一条线，明白那条线会动。提前花时间为以后的加速做准备没有错。一个企业成功前进的速度取决于它的起步状态，即它对变化的准备程度及其速度容忍度。
一句话:快速应对一切已经成为一项战略要务，未来几年最成功的公司将是那些行动最快的公司。然而，并不是每家公司都能以同样的速度前进，因为在新机器时代，每家公司都有自己的抱负和优先事项。你必须找到你真正的北方，为此你可以参考我们的速度框架，我们开发这个框架是为了帮助领导者找到他们业务的当前速度和他们需要设定的目标来加快步伐。
有这么多的利害关系，公司不能放松油门。
Manish 领导 Cognizant 亚太和中东未来工作中心。作为一名受人尊敬的演说家和思想家，Manish 用他发人深省的研究和咨询技巧引导许多财富 500 强公司走向工作的未来。他住在印度新德里，可以通过 联系到 manish.bahl@cognizant.com|https://www.linkedin.com/in/manishbahl/| @ mbahl
SVM 和内核 SVM
摘要
在本文中，您将了解到 SVM 或支持向量机，这是最流行的人工智能算法之一(它是十大人工智能算法之一)，以及关于内核技巧，它处理非线性和更高维度。我们将触及像超平面、拉格朗日乘数这样的主题，我们将有视觉示例和代码示例(类似于在 KNN 章节中使用的代码示例)来更好地理解这个非常重要的算法。
SVM 解释道
支持向量机是一种监督学习算法，主要用于分类，但也可用于回归。主要思想是基于标记的数据(训练数据),该算法试图找到可用于分类新数据点的最佳超平面。在二维中，超平面是一条简单的直线。
通常学习算法试图学习一个类的最常见的特征(一个类与另一个类的区别)，并且分类是基于那些学习到的代表性特征(因此分类是基于类之间的差异)。SVM 的工作方式正好相反。它找到和类之间最相似的例子。这些将是支持向量。
作为一个例子，让我们考虑两类，苹果和柠檬。
其他算法将学习苹果和柠檬最明显、最有代表性的特征，比如苹果是绿色的、圆形的，而柠檬是黄色的、椭圆形的。
相比之下，SVM 将寻找与柠檬非常相似的苹果，例如黄色椭圆形的苹果。这将是一个支持向量。另一个支持向量将是一个类似于苹果的柠檬(绿色和圆形)。因此其他算法学习差异而 SVM 学习相似性。
如果我们想象一下上面 2D 的例子，我们会得到这样的结果:
当我们从左到右，所有的例子将被归类为苹果，直到我们到达黄色的苹果。从这一点来看，新示例是苹果的置信度下降，而柠檬类的置信度增加。当柠檬类置信度变得大于苹果类置信度时，新示例将被分类为柠檬(介于黄色苹果和绿色柠檬之间)。
基于这些支持向量，该算法试图找到分隔类别的最佳超平面。在 2D，超平面是一条线，所以它看起来像这样:
好的，但是为什么我把蓝色的边界画成上面图片 的样子？我也可以画出这样的界限:
如你所见，我们有无限的可能性来画出决策边界。那么如何才能找到最优的呢？
寻找最优超平面
直觉上，最佳线是远离苹果和柠檬示例的线(具有最大的余量)。为了获得最优解，我们必须以两种方式最大化利润(如果我们有多个类别，那么我们必须考虑每个类别来最大化利润)。
因此，如果我们将上面的图片与下面的图片进行比较，我们可以很容易地观察到，第一个是最优超平面(线)，第二个是次优解，因为边缘要短得多。
因为我们想要最大化考虑到所有类的边距，而不是为每个类使用一个边距，我们使用考虑到所有类的“全局”边距、。该边距看起来像下图中的紫色线:****
这个边距与边界的正交，与支持向量的等距。
那么向量在哪里呢？每个计算(计算距离和最佳超平面)都在矢量空间中进行，因此每个数据点都被视为一个矢量。空间的尺寸由示例的属性数量定义。为了理解背后的数学，请阅读这个简单的向量、超平面和优化的数学描述: SVM 简洁地。
总之，支持向量是定义超平面的位置和边缘的数据点。我们称它们为“支持”向量，因为这些是类的代表性数据点，如果我们移动它们中的一个，位置和/或边距将改变。移动其他数据点不会影响超平面的边缘或位置。
为了进行分类，我们不需要所有的训练数据点(像在 KNN 的情况下)，我们只需要保存支持向量。在最坏的情况下，所有的点都将是支持向量，但这是非常罕见的，如果发生这种情况，那么你应该检查你的模型的错误或缺陷。
所以基本上学习等同于寻找具有最佳余量的超平面，所以这是一个简单的优化问题。
基本步骤
SVM 的基本步骤是:
- 选择两个超平面(在 2D)，这两个超平面将数据分开，它们之间没有点(红线)
- ****最大化他们的距离(边距)
- 平均线(这里是两条红线中间的线)将是决策边界
这很好也很容易，但是找到最佳余量，优化问题不是微不足道的(在 2D 很容易，当我们只有两个属性时，但是如果我们有 N 个维度，N 是一个非常大的数字呢)
为了解决优化问题，我们使用拉格朗日乘数。为了理解这个技巧，你可以阅读下面两篇文章:二元 Langrange 乘数和一个关于 Langrange 乘数为什么工作的简单解释。
到目前为止，我们有线性可分的数据，所以我们可以使用一条线作为类边界。但是如果我们不得不处理非线性数据集呢？
非线性数据集的 SVM
非线性数据的一个例子是:
在这种情况下，我们找不到一条直线来区分苹果和柠檬。那么如何才能解决这个问题呢。我们将使用内核技巧！****
基本思想是，当一个数据集在当前维度上不可分时，添加另一个维度，也许这样数据将是可分的。想一想，上面的例子是在 2D，它是不可分的，但也许在 3D 中苹果和柠檬之间有一个间隙，也许有一个等级差异，所以柠檬在第一层，苹果在第二层。在这种情况下，我们可以很容易地在 level 1 和 level 2 之间绘制一个分离超平面(在 3D 中，超平面是一个平面)。
映射到更高维度
为了解决这个问题，我们不应该只是盲目地增加另一个维度，我们应该转换空间，以便我们有意识地产生这种层次差异。
从 2D 到 3D 的映射
让我们假设我们增加了另一个叫做 X3 的维度。另一个重要的转变是，在新的维度中，使用公式 x1 + x2 来组织点。
如果我们画出由 x + y 公式定义的平面，我们会得到这样的结果:
现在我们必须将苹果和柠檬(只是简单的点)映射到这个新空间。仔细想想，我们做了什么？我们刚刚使用了一个变换，其中我们基于距离添加了级别。如果你在原点，那么这些点将在最低层。当我们远离原点时，这意味着我们正在爬山(从平面的中心向边缘移动)，因此点的高度会更高。现在如果我们考虑原点是中心的柠檬，我们会得到这样的东西:
现在我们可以很容易地将这两个类分开。这些转换被称为内核。常见的核有:多项式核、高斯核、径向基函数(RBF)、拉普拉斯 RBF 核、Sigmoid 核、Anove RBF 核等(参见核函数或更详细的描述机器学习核)。
从 1D 到 2D 的测绘
另一个在 2D 更容易的例子是:
在使用了内核和所有的转换之后，我们将得到:
所以在转换之后，我们可以很容易地用一行代码来划分这两个类。
在现实生活中，我们不会有一条简单的直线，但我们会有很多曲线和高维数。在某些情况下，我们不会有两个超平面来分隔数据，它们之间没有点，所以我们需要一些权衡，对异常值的容忍。幸运的是，SVM 算法有一个所谓的正则化参数来配置权衡并容忍异常值。
调谐参数
正如我们在上一节中看到的，选择正确的内核至关重要，因为如果转换不正确，那么模型的结果会非常糟糕。根据经验，总是检查你是否有线性数据，在这种情况下总是使用线性 SVM** (线性内核)。线性 SVM 是一个参数模型，但 RBF 核 SVM 不是，因此后者的复杂性随着训练集的大小而增长。不仅训练一个 RBF 核 SVM 更昂贵，而且你还必须保持核矩阵在周围，并且投影 到这个“无限的”高维空间中，在预测过程中，数据变成线性可分的也更昂贵。此外，您有更多的超参数来调整，因此模型选择也更加昂贵！最后，对复杂的模型进行过度拟合要容易得多！**
正规化
正则化参数(python 中的称之为 C )告诉 SVM 优化你想要避免多少漏分类每个训练示例。
如果 C 比 高，那么优化会选择更小的超平面，所以训练数据的漏检率会更低。
另一方面，如果 C 比 低，那么的裕量将会大，即使有将会漏分类训练数据的例子。这显示在以下两个图表中:
正如你在图中看到的，当 C 较低时，即使两个苹果被归类为柠檬，边距也较高(因此我们没有太多曲线，直线也没有严格遵循数据点)。当 C 高时，边界充满曲线，并且所有训练数据被正确分类。不要忘记，即使所有的训练数据都被正确分类，这并不意味着增加 C 将总是增加精度(因为过拟合)。
微克
下一个重要参数是伽马。gamma 参数定义了单个训练示例的影响达到的程度。这意味着高伽玛将只考虑靠近可信超平面的点，而低伽玛 将考虑距离较远的点。****
正如您所看到的，减少 Gamma 将导致寻找正确的超平面将考虑距离更远的点，因此将使用越来越多的点(绿线表示在寻找最佳超平面时考虑了哪些点)。
边缘
最后一个参数是余量。我们已经讨论过利润率，更高的利润率产生更好的模型，因此更好的分类(或预测)。页边距应始终最大化。****
使用 Python 的 SVM 示例
在本例中，我们将使用 Social_Networks_Ads.csv 文件，该文件与我们在上一篇文章中使用的文件相同，参见 KNN 使用 Python 的示例。
在这个例子中，我将只写下 SVM 和 KNN 之间的差异，因为我不想在每篇文章中重复我自己！如果你想要完整的解释关于我们如何读取数据集，我们如何解析和分割我们的数据，或者我们如何评估或绘制决策边界，那么请阅读上一章的代码示例 ( KNN )！
因为 sklearn 库是一个写得非常好、非常有用的 Python 库，所以我们没有太多代码需要修改。唯一的区别是我们必须从 sklearn.svm 中导入 SVC 类(在 sklearn 中 SVC = SVM ),而不是从 sklearn.neighbors 中导入 KNeighborsClassifier 类
**# Fitting SVM to the Training set
from sklearn.svm import SVC
classifier = SVC(kernel = 'rbf', C = 0.1, gamma = 0.1)
classifier.fit(X_train, y_train)**
导入 SVC 后，我们可以使用预定义的构造函数创建新模型。这个构造函数有很多参数，但我将只描述最重要的参数，大多数时候你不会用到其他参数。
最重要的参数是:
- 内核:要使用的内核类型。最常见的内核是 rbf (这是默认值)、 poly 或者 sigmoid ，但是你也可以创建自己的内核。
- C: 这是在调整参数部分描述的正则化参数****
- 伽玛:这也在调谐参数一节中描述
- 度数:仅当选择的内核是 poly 时使用并设置 polinom 的度数****
- 概率:这是一个布尔参数，如果为真，那么模型将为每个预测返回属于响应变量的每个类别的概率向量。所以基本上它会给你每个预测的置信度。
- 收缩:这表示您是否想要一个收缩启发式算法用于您的 SVM 优化，该算法用于顺序最小优化。它的默认值是真的，一个如果你没有很好的理由，请不要把这个值改成假的，因为缩小会大大提高你的性能，对于非常小的损失而言精度在大多数情况下。
现在让我们看看运行这段代码的输出。训练集的决策界限如下所示:
正如我们在调谐参数部分所见，因为 C 值很小(0.1)，所以判定边界是平滑的。
现在，如果我们将 C 从 0.1 增加到 100，决策边界中将有更多曲线:
如果我们使用 C=0.1，但现在我们将 Gamma 从 0.1 增加到 10，会发生什么？让我们看看！
这里发生了什么？为什么我们会有这么差的模型？正如你在调整参数部分看到的，高伽玛意味着当计算似是而非的超平面时，我们只考虑靠近的点。现在，因为绿色点的密度仅在所选绿色区域中较高，在该区域中，这些点足够接近似是而非的超平面，所以选择了这些超平面。小心 gamma 参数，因为如果将其设置为非常高的值(什么是“非常高的值”取决于数据点的密度)，这可能会对模型的结果产生非常坏的影响。
对于此示例，C 和 Gamma 的最佳值分别为 1.0 和 1.0。现在，如果我们在测试集上运行我们的模型，我们将得到下图:
而混淆矩阵看起来是这样的:
如你所见，我们只有 3 个假阳性和 4 个假阴性。该模型的准确率为 93% 这是一个非常好的结果，我们获得了比使用 KNN (准确率为 80%)更好的分数。
****注意:精确度不是 ML 中使用的唯一指标，也不是评估模型的最佳指标，因为精确度悖论。为了简单起见，我们使用这个指标，但是稍后，在章节评估人工智能算法的指标中，我们将讨论准确性悖论，并且我将展示该领域中使用的其他非常流行的指标。
结论
在这篇文章中，我们看到了一个非常流行和强大的监督学习算法，支持向量机。我们已经学习了的基本思想，什么是超平面，什么是支持向量以及它们为什么如此重要。我们也看到了许多视觉表现，这有助于我们更好地理解所有的概念。
我们接触的另一个重要话题是内核技巧，它帮助我们解决非线性问题。
为了有一个更好的模型，我们看到了调整算法的技术。在文章的最后，我们有一个用 Python 编写的代码示例，它向我们展示了如何使用 KNN 算法。****
我真的很喜欢咖啡，因为它让我有精力写更多的文章。
如果你喜欢这篇文章，那么你可以请我喝杯咖啡来表达你的欣赏和支持！
作为最后的想法，我想给出一些的优点&缺点和一些流行的用例。
****成为媒介上的作家:https://czakozoltan08.medium.com/membership
赞成的意见
- SVN 可能非常有效，因为它只使用了训练数据的子集，只使用了支持向量
- 在较小的数据集、非线性数据集和高维空间上运行良好
- 在维数大于样本数的情况下非常有效****
- 它可以有高精度，有时甚至可以比神经网络表现得更好
- 不对过度配合非常敏感
骗局
- 当我们有大量数据集时，训练时间很长
- 当数据集有更多的噪声(即目标类别重叠)时，SVM 表现不佳****
流行的使用案例
- 文本分类
- 检测垃圾邮件
- 情感分析
- 基于方面的识别
- 基于方面的识别
- 手写数字识别
参考
- 了解 SVM
- SVM:一个简单的解释
- SVM:理解数学
- SVM 理论
- Udemy:机器学习 A-Z
符号回归和遗传编程
符号回归和遗传编程远未成为主流的机器学习技术。然而，他们绝对值得相当多的关注。这篇文章是一个温和而非正式的介绍。
动机
想象一下，有人让你在不使用矩阵或求和符号的情况下，写下单输出神经网络的正向传递。啊？为了使事情变得简单，你可能会想到最普通的神经网络:具有一个隐藏层的多层感知器。所以在矩阵符号中，它看起来像这样
好的，为了去掉矩阵符号，你需要决定输入和隐藏层的大小。假设有 3 个输入特征和 4 个隐藏节点。所以你的矩阵是:
最后也是最乏味的一步是写出所有的东西，没有任何矩阵和求和符号
尽管这种表述非常不切实际，但它清楚地表明了一件重要的事情:预测只是对输入要素应用基本数学运算的结果。具体来说，这些操作是加法、乘法和合成。换句话说，我们把一堆代表数学运算的符号表达式组合起来，希望得到正确的预测。
这是一个转折。利用神经网络，人们试图找到所有的 w 和 b 的最优值，使得某个损失函数最小化。然而，另一个想法是修复所有的 w 和 b ，只改变符号表达式 iteself！或者换句话说，改变逼近器的函数形式。这正是符号回归的意义所在。改变自然可以有两种形式。您可以添加新的符号表达式(数学运算)或删除一些现有的符号表达式。
但是怎么做呢？
与优化权重不同，对于符号回归，以可以使用梯度下降技术的方式将问题公式化并不是微不足道的。但是，很容易评估单个表达式的性能。那么我们如何想出这种实现低损耗的神奇表达呢？进入遗传编程。
遗传编程(GP)和更臭名昭著的遗传算法(GA)之间的区别在于，GP 将解表示为树，而 GA 表示为字符串。使用树表示的主要原因是能够捕捉解决方案的内在结构。这与我们的应用非常相关，因为每个数学表达式都可以通过树来表示。参见下面的例子
可以基于回归度量(如均方误差或平均绝对误差)为每棵树分配适合度分数。对于 GP，还需要决定如何执行交叉和变异。有几种不同的方法可以做到这一点，但让我们只描述一种简单的方法。
对于突变，最简单的程序是所谓的点突变。树的随机节点被选择和改变。需要注意节点类型，因为一个节点可以表示不同的操作(一元、二元、…)。
交叉使用 2 个具有高适应值的解决方案，并尝试将它们结合起来。标准的方法是从捐献者那里得到一个随机的子树，并把它插入到父树的随机子树中。
gplearn
当然，你可以自己编码所有的东西，但是已经有一些开源包关注这个主题了。我能找到的最好的一个叫做 gplearn 。它最大的优点是它遵循了 scikit-learn API ( fit和transform / predict方法)。
它实现了两个主要的算法:回归和转换。对于回归，适应度函数只是一个度量，如均方误差或平均绝对误差。然而，transformer 通过尝试最大化等于相关性(spearman 或 pearson)的适应度函数，从原始特征中创建新特征。
一旦安装完毕，用户可以通过属性_program检查最佳解决方案。请注意，有多个超参数可以定制演进的所有主要部分。我鼓励你阅读官方文档并熟悉其中的一些，特别是如果你想防止像过度拟合这样的事情发生，或者如果你只是想寻求加速。
脸书度量数据集
为了说明 gplearn 在实践中是如何工作的，让我们从 UCI 机器学习库中取一个名为脸书度量的玩具数据集(链接)。它是根据一个未公开的化妆品品牌脸书·佩奇设计的。参见下面感兴趣的属性。
目标Total Interactions是一个帖子发布后获得的所有赞、分享和评论的总和。我们应用一些预处理，然后训练符号回归器。为了简单起见，只启用默认的二元运算:add、sub、mul、div。20 代之后最合适的解决方案如下。
add(add(mul(Post Hour，Post Month)，sub(payed _ 1.0，Category_3))，add(add(mul(Post Hour，Post Weekday)，div(mul(Post Hour，Post Month)，sub(Category_3，Category_1))，mul(add(Post Weekday，Category_1)，add(Type_Photo，Post Month)))，add(sub(payed _ 1.0，Category_3)，sub(Type_Status，payed _ 1.0)))
显然，这种文本格式对于可视化来说不是最佳的。请参见下面的树形图。
嗯，这到底是什么意思？我如何最大化互动？嗯，这并不重要。符号回归的输出很难理解但是加油，真的很酷！
如果你想看实施细节和与标准回归的比较，请随意查看笔记本这里。
附言（同 postscript）；警官（police sergeant）
我第一次接触符号回归是在 Kaggle ( example_1 和 example_2 )上浏览公共内核的时候。期待一些精心制作的代码片段，当我看到这些可怕的公式设法在官方排行榜上获得非常体面的分数时，我忍不住笑了。
参考
- 约翰·科扎，《基因编程是通过自然选择为计算机编程的一种方式》统计与计算 4，第 2 期(1994):87–112
- (莫罗等人，2016 年)莫罗，s .，丽塔，p .，&瓦拉，B. (2016 年)。预测社交媒体性能指标和评估对品牌建设的影响:一种数据挖掘方法。商业研究杂志，69(9)，3341–3351。
- gplearn 文档
更新:2018 年 7 月 2 日
原载于 2018 年 7 月 2 日jank repl . github . io。
符号拼写与 BK 树:模糊字符串搜索和拼写检查快 100 倍
传统智慧和教科书说 BK 树特别适合拼写纠正和模糊字符串搜索。但这真的成立吗？
在我的博客上关于拼写纠正的评论中，BK-tree 也被认为是一种优秀的模糊搜索数据结构。
所以我决定将 BK-tree 与其他选项进行比较和基准测试。
近似字符串搜索算法
近似字符串搜索允许在字符串列表中查找一个字符串，并根据特定的字符串度量返回那些相近的字符串。
有许多不同的字符串度量，如 Levenshtein 、 Damerau-Levenshtein 、 Hamming distance 、 Jaro-Winkler 和Strike match。
我将比较四种不同的算法，根据 Damerau-Levenshtein 字符串度量在最大编辑距离内查找字符串列表中的一个字符串。
对于拼写校正，可以使用与每个术语相关联的额外的词频来进一步对结果(建议)进行分类和过滤。
还可以实现一种 加权编辑距离 ，给予在键盘布局上彼此接近或发音相似的对以更高的优先级(例如Soundex或其他 语音算法 ，其识别相同发音的不同拼写)。同时还有一个 SymSpell 实现带权重的 Damerau-Levenshtein 编辑距离/keyboard-distance， 这个带权重的编辑距离超出了本文的重点 。它可以作为一个后处理步骤添加到最近似的字符串搜索算法中，只需根据您的偏好对由 Damerau-Levenshtein 编辑距离过滤的初步结果重新进行优先级排序/排序。
所有算法都努力实现相同的目标，以实现较短的查找时间:减少查找和比较(在单词和/或人工生成的候选词之间)，可能进一步减少完整编辑距离计算的数量，最后减少编辑距离计算本身的计算复杂性，同时不损害其准确性。
我想要比较和评测的四种不同算法是:
- 诺维格拼写校正器
- BK 树(布尔夏德-凯勒树)
- SymSpell (对称删除拼写纠正算法)
- LinSpell (线性搜索拼写纠正算法)
莱文斯坦编辑距离变化
所有四种算法都使用 Levenshtein 编辑距离的导数。
有三种不同的 levenshtein 距离:
- Levenshtein 距离:相邻换位(AC- > CA)计为 2 次编辑。三角形不等式确实成立。
- 受限 Damerau-Levenshtein 距离(最优字符串对齐算法):相邻换位计为 1 次编辑，但子字符串不能编辑多次:ed("CA "，" ABC") =3。三角形不等式不成立。
- 真实 Damerau-Levenshtein 距离:相邻的变调算作 1 次编辑，子串可以编辑多次:ed("CA "，" ABC") =2。三角形不等式确实成立。
Norvig 的算法正在使用真实 Damerau-Levenshtein 编辑距离。它可以被修改以使用 Levenshtein 距离。
Xenopax 的 BK 树 实现正在使用 Levenshtein 编辑距离。可以对其进行修改，以使用真实的 Damerau-Levenshtein 编辑距离，而不是受限的 Damerau-Levenshtein 编辑距离，其中 BK 树所需的三角形不等式不成立。
符号正在使用受限的 Damerau-Levenshtein 编辑距离。可以修改它以使用 Levenshtein 距离或真实的 Damerau-Levenshtein 距离。
LinSpell 正在使用限制的 Damerau-Levenshtein 编辑距离。可以修改它以使用 Levenshtein 距离或真实的 Damerau-Levenshtein 距离。
搜索结果的详细程度
在我们的测试中，我们区分了搜索结果的三种详细程度，这将导致不同的查找时间:
0 级:只返回最大编辑距离内编辑距离最小的结果。如果存在多个具有相同编辑距离的结果，则返回具有最高词频的结果。这允许提前终止搜索，例如，如果找到编辑距离=0 的结果。
第一级:返回最大编辑距离内编辑距离最小的所有结果。如果存在多个具有相同编辑距离的结果，则返回所有按词频排序的结果。这允许提前终止搜索，例如，如果找到编辑距离=0 的结果。
二级:返回最大编辑距离内的所有结果，按词频排序。这不允许提前终止搜索。
诺维格拼写矫正器
这个想法是，如果我们人为地从拼写错误的术语中生成最大编辑距离内的所有术语，那么正确的术语一定在其中。我们必须在字典中查找它们，直到找到匹配的为止。因此，生成了 4 种拼写错误类型(插入、删除、替换和相邻转换)的所有可能组合。这是非常昂贵的，例如，对于长度=9 和编辑距离=2 的单词生成 114，324 个候选项。
原来是用 Python 写的。对于基准测试，我使用了来自 Lorenzo Stoakes 的忠实的 C#端口，这是 Peter Norvig 的算法，已经扩展到支持编辑距离 3。
BK 树
BK 树利用了三角形不等式，Levenshtein 编辑距离的一个性质:Levenstein(A，B)+Levenstein(A，C)≥Levenstein(B，C)和 Levenstein(A，B)——leven stein(A，C)≤Levenstein(B，C)。
在索引期间，Levenshtein(根节点，子节点)是预先计算好的。
在查找期间，我们计算 Levenshtein(输入，根节点)。三角形不等式用作过滤器，仅递归地跟随那些预先计算的 Levenstein(根节点，子节点)在范围[Levenstein(输入，根节点)-dmax，Levenstein(输入，根节点)+dmax]内的子节点。
有几个有趣的帖子详细讨论了 BK 树:
- BK 树——一种用于拼写检查的数据结构
- 有趣的数据结构:BK 树
- 有趣的数据结构:BK 树(HN 讨论)
- 该死的酷算法，第一部分:BK 树
- BK-Tree |简介&实现
- 在 Clojure 中实现 BK 树
- BK-tree
我比较了 BK 树的三种 C#实现
- BK-tree 1(tgriffith的 C#实现)
- BK-tree 2(TarasRoshko的 C#实现)
- BK-tree 3(xeno Pax 的 C#实现)
并决定使用 Xenopax (也是从维基百科链接的)中最快的作为基准。
符号拼写算法
SymsSpell 是一种算法，可以在很短的时间内从一个巨大的字符串列表中找到最大编辑距离内的所有字符串。它可以用于拼写纠正和模糊字符串搜索。
SymSpell 从对称删除拼写纠正算法中获得其速度，并通过前缀索引检查其内存需求。
对称删除拼写校正算法 降低了给定 Damerau-Levenshtein 距离的编辑候选生成和字典查找的复杂性。它比删除+转置+替换+插入的标准方法快六个数量级，并且与语言无关。
与其他算法相反，只需要删除，不需要转置+替换+插入。输入术语的转置+替换+插入被转换成字典术语的删除。替换和插入的开销很大，并且依赖于语言:例如，中文有 70，000 个 Unicode 汉字！
速度来自于廉价的只删除编辑候选生成和预计算。在最大编辑距离为 3 的范围内，一个平均 5 个字母的单词有大约300 万个可能的拼写错误，但是 SymSpell 只需要生成 25 个删除来覆盖所有这些错误，在预计算和查找时都是如此。神奇！
前缀索引背后的思想是，附加字符的区分能力随着单词长度而降低。因此，通过将删除候选生成限制到前缀，我们可以节省空间，而不会过多地牺牲过滤器效率。在基准测试中，使用了三种不同的前缀长度 lp=5、lp=6 和 lp=7。它们反映了搜索速度和索引大小之间的不同折衷。更长的前缀长度意味着更高的搜索速度，代价是更大的索引大小。
SymSpell 的 C#源代码在 GitHub 上开源发布。
林拼
这基本上是对单词列表的线性扫描，并计算每个单词的编辑距离(稍作调整)。它旨在作为基准的基线度量。令人惊讶的是，尽管它具有 O(n)的特性，但结果却优于 BK-tree 和 Norvig 的算法。
这有几个原因:
- 不要低估大 O 符号中的常数。仅访问 BK-树中 20%的节点比原子成本仅为 10%的线性搜索更昂贵。
- 因为 Damerau-Levenshtein 计算非常昂贵，所以重要的不是处理的单词的数量，而是我们需要完整的 Damerau-Levenshtein 计算的单词的数量。如果我们可以从计算中预先过滤单词，或者一旦达到某个编辑距离就终止计算，我们就可以加速搜索。
- 如果我们将搜索限制为最佳匹配，我们可以利用提前终止搜索的选项。
- 没有拼写错误的单词是常见的情况。然后可以用 O(1)中的哈希表或 trie 进行查找！如果我们将搜索限制在最佳匹配，我们可以立即终止搜索。
- 如果 Abs(word ),我们不需要计算编辑距离。长度-输入。Length)>最大编辑距离(或目前为止找到的最佳编辑距离，如果我们将搜索限制为最佳匹配)
- 如果我们将搜索限制为最佳匹配，那么一旦达到目前找到的最佳编辑距离，我们就可以终止编辑距离计算。
- 如果我们将搜索限制为最佳匹配，并且我们已经找到了一个编辑距离=1 的匹配，那么如果所讨论的项的计数小于已经找到的匹配的计数，我们就不需要计算编辑距离。
LinSpell 的 C#源代码在 GitHub 上开源发布。
测试设置
为了对的四种近似字符串搜索算法进行基准测试，我们对每种算法进行了 233+2*2 测试
1000 个有随机拼写错误的单词搜索两个字典大小(29159 个单词，500000 个单词)三个最大编辑距离 (2，3，4) 和三个冗长类型 (0，1，2)。对于每个测试，测量总搜索时间。
对于两种字典大小 (29，159 个单词，500，000 个单词)，测量创建字典和辅助数据结构所需的预计算时间及其内存消耗。
对于四种算法中的每一种，已对发现的建议进行了比较，以确保结果的完整性。由算法使用的不同 Levenshtein 变量导致的结果差异已被考虑在内。
测试重点和限制
基准测试将最大编辑距离限制为 4，因为对于自然语言搜索，4 的编辑距离已经接近合理范围，因为误报的数量随着最大编辑距离呈指数增长，精度下降，而召回率仅略有提高。
该基准被限制在 50 万字以内，因为即使是 20 卷的牛津英语词典也只有 171，476 个当前使用的单词和 47，156 个过时的单词。
使用较长字符串或位向量(图像、语音、音频、视频、DNA 序列、指纹等)的模糊搜索超出自然语言搜索，可能需要更长的编辑距离和更大的字典大小，并导致不同的结果。
模糊搜索多个单词(产品/事件数据库)或更大的文本片段(剽窃检查)可能需要复合/分解和超出编辑距离的字符串度量，如匹配以考虑缺失和调换的单词。
这两个应用领域都超出了本文的重点。
测试数据
嘈杂 _ 查询 _en_1000.txt
对于查询，我们使用前 1000 个唯一的单词。来自 Norvig 的文字语料库 big.txt 。
对于每个单词，在范围 0 内的随机编辑次数..选择 Min(word.length/2，4)。对于每个编辑，在单词内的随机位置应用一个随机类型的编辑(删除，插入随机字符，替换为随机字符，切换相邻字符)。编辑后不允许出现长度为< 2 的重复和单词。
frequency _ dictionary _ en _ 30 _ 000 . txt
这些是来自 Norvig 的文本语料库 big.txt 的 29159 个独特的单词，以及它们在该语料库中的频率。
frequency _ dictionary _ en _ 500 _ 000 . txt
这些是来自谷歌图书 Ngram 数据的英语一百万单词列表中最常见的 500，000 个单词，以及它们的频率。
所有三个测试数据文件都在 GitHub 上发布。
如果你想自己重现基准测试结果或者与另一种模糊字符串搜索算法进行比较，你也会在 Github 上找到 基准测试源代码 。
基准测试结果
在当前的基准测试中，我们用一个随机编辑距离 (0...最大编辑距离)。这样可以很好地理解平均 查找时间。
在之前的基准中，我们用固定编辑距离 (=最大编辑距离)来比较单词。这样可以很好地理解最大 查找时间。作为用户体验的衡量标准，平均值有时可能会产生误导。对于编辑距离=3 ，SymSpell 比 Norvig 的算法快 100 万倍。
应用
符号拼写非常快。但是我们真的需要这样的速度吗？为什么？对于单个用户或小编辑距离，其他算法可能就可以了。但是对于搜索引擎和搜索即服务搜索 API 来说，您必须为成千上万的并发用户提供服务，同时仍然保持几毫秒的延迟，并且拼写纠正甚至不是主要的处理任务，而只是查询预处理中的许多组件之一，您需要最快的拼写纠正。
摘要
除了教科书和论坛上流传的历史原因和习惯之外，基准测试无法证实 BK-trees 和 Norvig 算法的广泛使用和推荐背后的任何基本原理。对于 SymSpell 和 LinSpell，有两种可供选择的算法，它们总能提供更好的结果，至少在这个测试的范围内。
- 如果速度很重要，使用符号法术。比 BK-Tree 快 2-3 个数量级，比 Norvig 的算法快 5-6 个数量级。随着字典大小和最大编辑距离的增加，符号拼写查找时间只会适度增加。在所有情况下，它都优于其他三种算法，通常高出几个数量级。这是以更高的内存消耗和预计算时间为代价的。预计算时间仅在程序/服务器启动期间产生一次，或者如果预计算数据被序列化/反序列化，甚至仅在程序开发期间产生一次。
- 如果内存使用很重要，使用 LinSpell。对于相同的内存使用，它比 BK-Tree 快 10 倍。LinSpell 查找时间随着字典的大小线性增长，但几乎与最大编辑距离无关。它几乎总是优于 BK-tree 和 Norvig 的算法。不会导致额外内存消耗和预计算时间。
- 使用 BK 树没有明显的好处。在所有情况下，SymSpell 在速度方面优于它，LinSpell 在内存方面优于它。虽然 BK-tree 比 Norvig 的编辑距离算法> 2 快，但它比 LinSpell 或 SymSpell 慢得多。BK-tree 的性能很大程度上依赖于字典的大小，但是随着最大编辑距离的增加，它的增长是适度的。
- nor vig 的算法没有明显的好处。在所有情况下，它在速度上优于 SymSpell 和 LinSpell，在内存上优于 LinSpell。nor vig 算法的查找时间与字典的大小无关，但随最大编辑距离呈指数增长。
- 始终小心使用 verbose = 2(列举最大编辑距离内的所有建议，而不仅仅是编辑距离最小的建议)。它要慢得多，因为它防止了搜索的提前终止！
更新:
我收到了一封电子邮件，其中表达了对基准测试结果的一些怀疑，并暗示该结果是由于所选 BK-tree 的糟糕的 C#实现，而不是 BK-tree 和 SymSpell 之间的算法差异。我认为我已经非常小心地选择了 C#中最快的 BK-tree 实现来防止这种怀疑。但是不可否认的是，有时确实很难区分算法或其实现对性能的贡献有多大。
我将添加一些客观数据:在字典中搜索期间完成的 Levenshtein 计算的平均次数:
由于 Levenshtein 计算是 BK-tree 和 SymSpell 中搜索的最昂贵的组成部分，在给定大小的字典中搜索期间所需的 Levenshtein 计算的平均数量应该是算法、的真实性能的相当可靠的指标，独立于其实现。
而对于 BK 树，我们需要计算词汇(字典中的单词)的 17%到 61%的 Levenshtein 距离， SymSpell 只需要计算词汇的 0.0042%到 0.016% 的 Levenshtein 距离。这就是为什么 SymSpell 的速度源于算法的设计，而不是实现。
顺便说一下，我还测试了一个将 BK-tree 三角形不等式原理集成到 SymSpell 中的集成，作为进一步减少/过滤所需 Levenshtein 计算数量的附加步骤。性能提升很少，但是由于字典生成期间的 Levenshtein 计算，增加了内存需求和预计算成本。
拼写纠正速度提高 1000 倍
亚毫秒复合感知自动拼写纠正
Source: https://www.flickr.com/photos/theredproject/3968278028
最近我被指向了两个关于拼写纠正的有趣帖子(这里)。他们应用了一种深度学习方法，即现代的魔法石。从 AlphaGo 赢得围棋冠军、 Watson 赢得 Jeopardy 、打击假新闻到用奇点威胁人类，深度学习的普及程度真的很让人着迷。
问题是深度学习多工具是否会在每个领域超越并取代高度专业化的算法和数据结构，如果它们都值得拥有它们的位置，或者如果它们的互补优势结合起来，它们是否会发光。与此同时，最初对深度学习纠正拼写的热情随之而来的是一些幻灭。
他们求助于深度学习的原因是他们认为传统拼写检查的“糟糕透顶”的性能(估计拼写一个短单词需要 ~0.1 秒)。
虽然到目前为止没有披露深度学习方法的纠正性能和内存消耗，但我知道拼写纠正可以比 0.1 秒快得多。
SymSpell ，基于对称删除拼写纠正算法，在一台旧 MacBook Pro 上仅仅用了0.000033 秒(编辑距离 2)0.000180秒(编辑距离 3) 。
不过话说回来，他们的方法能够处理更复杂的表达式，比如“爱在哪里”！
SymSpell 总是期望单个输入项，并且不能纠正插入到单词中的个空格或者两个单词之间缺少的个空格。
我的好奇心被激起，我决定尝试在 SymSpell 上增加一个算法层来处理它。
symspell 化合物
SymSpellCompound 支持多单词输入字符串的复合感知自动拼写纠正。它建立在比 SymSpell 快 100 万倍的拼写纠正算法之上。
1。复合分裂&分解
SymSpell 假设每个输入字符串都是一个单独的术语。SymSpellCompound 支持复合拆分/分解三种情况:
- 错误地在正确的单词中插入空格导致两个不正确的术语
- 错误地省略了两个正确单词之间的空格导致了一个不正确的组合术语
- 多个输入项有/无拼写错误
拆分错误、连接错误、替换错误、换位错误、删除错误和插入错误可以混合在同一个单词中。
2。自动拼写纠正
- 大型文档集合使得手动校正不可行，并且需要无人监督的全自动拼写校正。
- 在单个单词的常规拼写校正中，向用户呈现拼写校正建议。对于长的多单词文本的自动拼写校正，算法本身必须做出有根据的选择。
例子:
工作原理
个人代币
输入字符串被分割成标记。然后使用对称删除拼写校正算法来单独获得每个单词的建议。
组合令牌
此外，检查每个二元模型(连续标记的级联对)的建议，但仅当两个连续标记中的一个不提供建议或最佳建议的编辑距离> 1 时。
如果建议(令牌 1+令牌 2 ),则建议组合令牌优先。编辑距离+1 < suggestion(token1).editDistance+suggestion(token2).editDistance
分割令牌
此外，还会生成一个标记的所有子标记对，但前提是该标记未合并，该标记由多个字符组成，并且该标记的最佳建议的 editDistance >0。
字典生成
词典质量对纠错质量至关重要。为了实现这一点，两个数据源通过交集进行了合并:
Google Books Ngram data ，其提供了代表性的词频，但是包含许多带有拼写错误和怒容的条目——面向拼写检查器的词表，其确保了真实的英语词汇但是不需要词频来对相同编辑距离内的建议进行排序。
性能
0.0002 秒/字
5000 字/秒(2012 Macbook Pro 上的单核)
应用
对于单个用户或小编辑距离，其他算法可能就可以了。但是对于搜索引擎和搜索即服务搜索 API，您必须为数千个并发用户提供服务，同时仍然保持几毫秒的延迟，并且拼写纠正甚至不是主要的处理任务，而只是查询预处理中的许多组件之一，您需要最快的拼写纠正。
- 查询校正(高达 26% 的网络查询包含拼写错误的术语)，
- 聊天机器人(例如使用符号拼写的符号和佛罗伦萨)，
- OCR 后处理，
- 自动校对。
频率字典
词频列表是通过交叉下面提到的两个列表创建的。通过相互过滤，只使用那些同时出现在两个列表中的单词。应用了附加的过滤器，并且结果列表被截断为大约 80，000 个最频繁的单词。
- 谷歌图书 Ngram 数据 (许可):提供代表性词频
- 怒容—面向拼写检查器的单词列表 (许可):确保真正的英语词汇
博客文章:算法、基准、应用
1000 倍快速拼写校正算法
快速近似字符串匹配大数据中的大编辑距离
非常快速的数据清理产品名称、公司名称&街道名称
待办事宜
如果一个拼写错误同时是一个有效单词(例如消息 vs .消息)，那么它当前没有被纠正。
词频可以用于排名，但有时在给定的上下文中，罕见的词可能是正确的。
二元模型概率可以提供上下文，但上下文通常不是来自连续的术语，而是隐藏在文本的更远处。收集和存储滑动窗口内词汇表的所有术语组合的同现概率可能是禁止的。
我们可以求助于语法和句子成分和 语法网 。
我们可以通过利用键盘接近度、语音接近度和作者过去的个人词汇偏好来猜测作者的意图/错误原因。
正确时会出现误报，但未知单词在其他已知单词的 editDistanceMax 内。
将 Jupyter 笔记本图表同步到 Microsoft Word 报表
Photo by J-S Romeo on Unsplash
情况是这样的 :你正在 Jupyter 笔记本上做大数据分析。你有大量的图表，你想对它们进行报告。理想情况下，你可以在 Jupyter 笔记本上创建你的最终报告，它具有所有花哨的降价功能，并且能够将你的代码和报告保存在同一个地方。但问题是:大多数人仍然想要 Word 文档报告，并不关心您的代码、可复制性等。报道时，以最有用的形式向人们提供信息是很重要的。
因此，您有大量的图表和图形想要放入 Word 报告中——您如何保持两者同步呢？如果您的图表稍有变化(例如，更改报告中每个图表的样式)会怎样？您不得不从笔记本中复制和粘贴图表，这是一个手动、耗时且容易出错的过程。
在这篇文章中，我将向你展示我对这个问题的解决方案。它包括以下步骤:
- 用代码将 Jupyter 笔记本上的图表图像保存到你的桌面上。
- 准备您的 Word 文档报告，在报告的适当位置引用您保存在桌面上的图像名称。
- 将图像加载到新版本的 Word 文档中。
将 Jupyter 笔记本中的图表图像保存到桌面
第一步是收集您想要加载到报告中的图像，将它们从 Jupyter 笔记本保存到硬盘上的图像文件中。在这篇文章中，我将使用几个月前我的“让我们刮一个博客”文章中产生的数据和分析，在那里我刮了我最喜欢的博客边际革命并做了一些简单的分析。
该分析使用 matplotlib 生成了一些简单的结果图表。为了将这些图像保存到您的桌面，matplotlib 提供了一个名为 savefig 的有用函数。例如，在该分析中生成的一个图表按作者查看了博客帖子的数量:
以下代码生成此图表，并将其保存到“report_images”文件夹中名为“num_posts_by_author_plot.png”的文件中。
关于这一步的几点建议:
- 确保给你的图片起一个有用的、描述性的名字。这有助于确保在 Word 文档中放置正确的引用。我个人喜欢遵循这样的惯例，即在代码中给绘图图像取与绘图对象相同的名称。
- 您的图像必须有唯一的名称，否则第一个图像将被第二个图像覆盖。
- 为了保持有序，请将图像存储在专门为保存报告图像而设计的单独文件夹中。
对我的其他图表重复类似的代码，我的 report_images 文件夹中只剩下 5 个图表图像:
准备带有图像引用的 Word 文档报告
有一个流行的微软 Word 文档包叫做 python-docx ，它是一个很棒的库，可以用 Python 代码操作 Word 文档。但是，它的 API 不允许您在文档中间插入图像。
我们真正需要的是类似 Jinja2 for Word Docs 的东西:一个可以在文档中指定特殊占位符值，然后自动加载图像的包。嗯，幸运的是确实有这样一个包存在: python-docx-template 。它构建在 python-docx 和 Jinja2 之上，允许您在 Word 文档中使用类似 Jinja2 的语法(参见我的另一篇关于使用 Jinja2 模板创建 PDF 报告的文章)。
要使用 python-docx-template 将图像导入 Word，很简单:只需在 Word 文档中使用常用的 Jinja2 语法{{ image_variable }}。在我的例子中，我有六张图片，我放在一起测试的 Word 模板看起来像这样:
为了让系统工作，您必须在{{ }}中使用与图像名称对齐的变量名(在'之前)。png ')和 Jupyter 笔记本中的绘图变量名。
将图像加载到文档中
最后也是最重要的一步是获取模板中的所有图像。为此，代码大致遵循以下步骤:加载 Word 文档模板，从 image 目录中加载图像作为 InlineImage 对象的 dict，在 Word 文档中呈现图像，并将加载的图像版本保存为新文件名。
下面是执行此操作的代码:
要运行代码，您需要指定 Word 模板文档、将包含图像的新 Word 文档名称以及存储图像的目录。
python load_images.py <template Word Doc Filename> <image-loaded Word Doc filename> <image directory name>
在我的例子中，我使用了以下命令，它接受模板 template.docx ，生成加载了图像的 Word 文档 result.docx ，并从文件夹 report_images 中获取图像:
python load_images.py template.docx result.docx report_images
瞧，加载了图像的 Word 文档看起来像这样:
你可以在 Github 这里找到我用来创建这个指南的代码。
原载于 2018 年 12 月 2 日【www.marknagelberg.com】。你可以在推特上关注我 这里 。要访问我共享的 Anki deck 和 Roam Research notes 知识库，以及关于间隔重复和提高学习效率的技巧和想法的定期更新， 加入“下载马克的大脑”。
概要报告造就更好的放射科医生和算法
我仍然记得我作为放射科医生犯的第一个真正的错误。这是一个很小的错误，几乎不明显，但对病人有很大的影响。这个错误在我犯错的第二天才被发现，尽管如此，也为时已晚...
遗漏的错误
几年前，我在夜班工作的创伤中心报告紧急 CT 扫描。有一些常见的东西，很多 CT 头，一些肾结石的发现，和一些全身外伤的研究。其中会出现来自病房上方的紧急扫描，如术后腹部和 ITU 机构。一切都在以相当快的速度进行着，每次我完成一份报告，一项新的研究就会出现在工作列表中。那天晚上我是高级注册员(培训生)，第二天早上我的顾问会仔细检查一切。
外科病房的一项研究是针对一名因阑尾手术破裂而被送进手术室的年轻男子。显然，他手术后败血症的情况很糟糕，团队很有理由想检查他腹部的状况。我调出了他的入院 CT 检查了一遍。右侧髂窝内有大量游离液体，脂肪滞留，如预期的那样，盲肠附近有壁状聚集。阑尾炎延迟表现的典型表现。然后我打开最近的术后扫描，开始口述。收集物已经过手术处理，只剩下一点点游离液体。伤口看起来很好，没有什么新的东西值得注意。我写完报告，继续下一项研究。单子做好之后(嗯，永远做不完，但是我的班做完了)，我就回家了。
第二天，我一上班，就像往常一样查看了我的电子邮件。第一条消息的标题为“紧急:升级的放射学错误”。我愣了一会儿——我做了什么？我的大脑想不出会是什么。我打开电子邮件，通读了一遍。它很短，但切中要害。不过，对我来说没有意义，一开始没有。我重读了一遍。
“Harvey 医生，昨天您报告了对患者 x 进行的术后 CT 扫描。根据您的报告，患者被连夜送回手术室进行剖腹探查，但由于手术团队无法将他们的发现与您报告的情况联系起来，手术被迫中止。病人现在在重症监护室，接受术后治疗。请联系首席手术顾问，安排时间对该事件进行调查性审查，该事件已上报管理层。”
问题掠过我的脑海。他们为什么把他带回剧院？我说过他的腹部看起来好多了，不是吗？我报告了错误的扫描吗？
我冲进报告办公室，把我昨天报告的扫描结果装了进去。我向下滚动列表，它就在那里。一名顾问甚至对其进行了反复检查和核实。我打开它，又看了一遍图片——但没什么不同，还是我昨天报道的那项研究。我肯定报告了正确的研究。我又看了一遍我的报告。再一次。根据我的发现，我不明白他们为什么决定去剧院。我说过这些收藏品已经不在那里了，周围的自由流体也已经消散了。
实际上，我没有。
这就是我的错误，白纸黑字写得清清楚楚，这是我的疏忽。有时候最难看到的是那些不存在的东西。我想说的是“之前提到的盲肠旁集合没有被看到。”我实际上报道的是“前面提到的盲肠旁集合可见。”
我漏掉了一个单词。“不是”。仅仅在这个基础上，外科医生就认为这个集合仍然存在，是败血症的源头，并把病人带回手术室切除。
一个词。仅仅一句话就给一个极度不适的年轻病人带来了不必要的伤害，让他冒着再次接受大手术的风险。不仅如此，手术团队连夜完成了这项工作，医院为此付出了巨大的代价，这无疑只会给其他病人的治疗增加延误。我感到羞愧。
我回复了邮件，安排了一次会面，并走完了正式审查的流程。我只能道歉。我可以试着把责任归咎于我的自动听写软件漏掉了一个单词，或者是外科医生没有亲自检查图像，或者是我的顾问在核实之前没有彻底阅读报告。然而，完全正确的是，责任在我身上。我应该更仔细地阅读我的报告。令人欣慰的是，病人最终很好，只在重症监护室呆了很短时间。没有对我采取任何行动。他的败血症是由败血症(血液感染)引起的，他对抗生素反应良好。我从错误中吸取了教训，并养成了认真检查口述报告的习惯，尤其是因为它们是由语音识别软件自动处理的。每当我结束一份报告，我仍然回想起那个年轻人和我给他带来的不必要的痛苦。
词语很重要
我犯的第一个严重错误是许多放射学家都知道的。我并不孤单。一项研究显示，高达 33.8%的未经编辑的报告包含此类错误。我们是一个被我们的话语所束缚的职业，我们的话语是我们患者旅程中的法律记录。词语很重要，我们把它们弄对是至关重要的。尽管像语音识别软件这样的技术很有用，但最终的责任还是在我们人类身上。那么，我们如何减少这些错误呢？在一个工作量不断增加、疲惫不堪、筋疲力尽的放射科医生的世界里，也许我们不能指望每个字都被考虑、检查和验证。
我更担心的是最近在图像感知方面推进的人工智能，它依赖于人类口述的报告，为算法提供学习数据。如果人类的自由文本报告已经包含错误，并且自然语言处理试图解析文本并找到意义，那么这些错误只会被转移。更糟糕的是，来自人类的自由文本报告都非常不同——每个放射科医师都以不同的风格，使用不同的描述符进行报告。我之前在关于 CheXnet 研究的博客中报道过这个话题，并解释了你如何不能真正使用源自人类的自由文本作为基础事实来了解胸部 x 光片中的内容。至少没有人类准确。
Image from Modelling Radiological Language with Bidirectional Long Short-Term Memory Networks, Cornugreta et al, 2016.
我不是唯一一个担心这个的人。来自宾夕法尼亚州好时医疗中心的 Huesch 等人最近发表了他们的发现，试图挖掘寻找肺栓塞(肺部动脉中的血凝块)的 CT 扫描文本报告。他们的结论是，自由文本报告“与报告长度和报告术语的广泛可变性相关”。作者继续指出，“这些结果支持对一个完全结构化的报告模板的影响的预期评估，该模板至少具有一些强制性的离散字段，以方便报告的使用和理解”。换句话说，他们建议报告的结构不仅要强制标准化，还要更好地让机器学习理解它们。
这都是关于结构的
二十多年来，人们一直在推动所谓的“结构化报告”。实质上，结构化报告是一个模板，它规定了需要由报告放射科医师填写的某些字段。例如，在胸部 x 光报告中，字段可能包括肺、心脏和骨骼。其目的是创建一个标准化的报告，该报告以相同的格式包含相同数量的有用信息，而不管是哪个放射科医师完成的。
对结构化报告好处的广泛研究令人信服。已经表明，结构化报告绝对"比非结构化报告更加完整和有效"，在清晰度方面具有" T2 "优势，提供了" T4 "增强的感知临床影响，它们" T6 "便于信息提取并受到转诊医生的青睐，并且可以" T8 "改进手术计划。在医疗保健行业金钱为王的美国，结构化报告对于识别账单代码非常有价值。此外，结构化报告已被推荐用于任何涉及放射学报告的研究活动，在诊断准确性研究报告标准 (STARD)声明中有明确规定。简而言之，结构化报告比自由文本报告要好。报告更清晰，更好的解释，包含更多的信息，是机器可读的，你的临床同事喜欢它们。
那么为什么不是所有的放射科医生都使用结构化报告呢？这就是棘手的地方。放射科提供商和供应商在很大程度上没有执行结构化报告。有些解决方案就是在空白处写上几个字，告诉你报告的副标题应该是什么。剩下的部分由你来填写，最终，放射科医生只是在标题下放一份自由文本报告，然后就不管它了。
Sample ‘fill in the blanks’ report from RSNA’s RadReport. These haven’t gone down well with radiologists.
其他结构化报告有太多的部分需要完成，所以最终感觉你在勾选不必要的框，浪费时间回答不相关的问题，减慢你的工作流程。他们不适应，他们是一个尺寸适合所有人，他们会感到束缚和负担。另一个担心是，花在填写结构化报告上的时间是花在而不是看图像上的时间，这是放射科医生不喜欢的！
概要报告
Image courtesy of Smart Radiology
很明显，我们必须减少错误，使医疗数据为人和机器都可以理解。随着放射学标准化词典的兴起，以及将结构化报告集成到 DICOM 格式的工具的出现，我们看到了技术与临床需求的融合，最终可能使结构化报告成为可用的现实，这是通过所谓的“概要报告”实现的。这是直接从输入数据生成机器可读报告的概念。通过这种方式，临床数据在来源处被标记化，附加到您喜欢的任何编码系统(ICD-10、FIHR、SNOMED)，然后在结构化模板内被处理成自由文本报告。与传统的纯文本报告相比，底层编码数据更适合计算分析，从而为精确的大规模放射学数据查询打开了大门。
在 RSNA 2017 上，一家供应商智能报告展示了一个优雅的概要报告解决方案。该软件将数据字段转换成人类可读的自由文本，而不是说教式的打勾。使用语音命令(与领先的放射学语音听写软件 Nuance 链接)，放射科医生只需说话即可导航模板字段，无需点击鼠标。
每个领域都是完全可定制的，因此每个放射科都可以根据需要设置自己的格式，或者选择使用子专业专家为每个临床用例设计的模板。随着放射科医生的工作进展，会显示实时决策支持(如上面关于肺结节测量的示例所示)，确保放射科医生都按照相同的黄金标准工作。“正常”研究可以在几秒钟内以您的科室和转诊临床医生喜欢的格式报告出来。癌症研究尤其受益于详细的标准化，智能报告旨在减少填写此类报告的繁琐。
实际上，该软件从放射科医师提供的数据中创建了自由文本，消除了口述整篇文章的需要。机器学习研究人员的好处是，底层数据已经硬编码，不需要 NLP 筛选。对于那些努力让 NLP 准确一致地工作的人来说，这是个好消息。事实上，它完全否定了 NLP 的必要性。
我们不必再创建我们希望从中获取数据的文档，相反，我们可以从我们的数据中创建清晰、集中的多媒体文档。
对于那些担心失去正常机智报告的细微差别的人，不要担心，你可以随时编辑一个模板来包含你最喜欢的谚语，安全地知道你的报告仍然有足够的结构。您编辑的基础数据点保持不变，但文本是您自己的。更重要的是，你的妙语可以立即翻译成多种语言，甚至有可能从相同的底层结构化数据中创建面向患者的报告，这是我的人工智能在放射学中的五大用例之一。
另一个聪明的功能是，你可以合并人工智能图像感知算法的输出，将相应的文本(根据你的喜好编辑)自动放入报告中。这一技术目前正在荷兰拉德布大学医学中心与 Thirona 成像分析进行测试。还有一个集成的分析套件，所以你可以深入到所有报告的数据中，这是单靠自由文本根本不可能做到的。所有这些数据点都有可能链接到您医院的电子记录中，用于审计、数据分析和机器学习研究。这与当前的热门话题，甚至是医疗技术中更热门的“真实世界数据”业务紧密相关。那些知道如何大规模创造和利用准确的真实世界数据的人正看到巨大的回报；看看今年罗氏以 19 亿美元收购的熨斗就知道了。创建和管理自己的数据湖的价值显而易见。现在，它取决于放射科医生接受它。
摘要
如果我们要开发真正的放射学人工智能系统，那么我们需要数十亿个干净的数据点。自由文本和事后 NLP 数据提取在医学等安全关键环境中并不适用，因此我们需要更智能地生产数据，以供我们的算法进行训练。不仅如此，为了我们的患者，我们应该尽我们所能减少我们自己的错误，为了我们的临床同事和患者，我们应该提供清晰、可操作和可读的报告。
相反，随着人工智能在规模和功能上的增长，概要报告将是这些系统产生输出的唯一方式。我们当然不会训练人工智能系统产生没有底层编码数据点的自由文本块！
概要报告有可能提高护理质量，同时改善我们与同事和患者的互动和交流，并确保每个放射科医生都按照最高标准进行报告。
这只是更聪明的做事方式。
如果你和我一样对放射学人工智能的未来感到兴奋，并想讨论这些想法，请保持联系。我在推特上 @drhughharvey
如果你喜欢这篇文章，点击推荐并分享它会很有帮助。
关于作者:
Harvey 博士是一名委员会认证的放射科医生和临床学者，在英国国民医疗服务体系和欧洲领先的癌症研究机构 ICR 接受过培训，并两次获得年度科学作家奖。他曾在 Babylon Health 工作，领导监管事务团队，在人工智能支持的分诊服务中获得了世界第一的 CE 标记，现在是顾问放射科医生，皇家放射学家学会信息学委员会成员，以及人工智能初创公司的顾问，包括 Algomedica 和 Kheiron Medical。
综合大数据框架和深度学习
Photo from Apache Flink Website
大多数大数据框架软件工程师用 Java 编写，而大多数机器学习，特别是深度学习库的研究人员用 Python 编写。这在双方之间产生了一条有趣的断层线。一方面，我们拥有 Spark、Flink 和 Kafka 等大型数据框架，可以快速高效地处理海量数据集，但缺乏(轻松)训练和加载专门针对大型数据集的高度成功的模型的能力。另一方面，您有强大的框架来轻松实现深层架构，但是，这些框架没有提供将这些模型集成到大规模数据系统的简单方法。弥补这个缺陷并不是一个简单的问题，因为它需要将 Python 中编写的代码转移到 JVM 中。此外，还需要一系列的依赖和预处理。
历史和背景
JVM 上的
追溯到 2005 年 Hadoop 项目的最初形成，大数据框架一直在 Java 虚拟机上生存和发展。当时，Java 和 C++是占主导地位的编程语言之一(特别是在工业界)。因此，Hadoop 将存在于 JVM 上是理所当然的。2009 年，用 Scala 编写的 Apache Spark 出现在伯克利 AMP 实验室。Spark 由于其分布式内存结构，除了提高速度之外，还允许更广泛的计算。大约在同一时间，LinkedIn 出现了 Apache Kafka。Kafka 充当了连接实时数据源的中心框架。此后不久，Flink 在 2010 年作为一种完全基于流的大数据处理方法出现。
其次，Java 中涌现出大量的文件系统和数据库。HDFS、卡珊德拉、Neo4j 都成为了 Java 驱动的大数据文件系统/数据库。ElasticSearch 也主要用 Java 编写，尽管它的 API 允许来自任何语言或命令行的请求。虽然几乎所有的论文都有 Python 库，但是繁重的工作都是用 Java 完成的。
Python 端
与此同时，在这一切进行的同时，机器学习包继续在 Python 中开发。NumPY 是在 90 年代后期建立的，它为后来 Python 中的 DL 开发奠定了基础。尽管现在已被弃用，但 2007 年出现的 Theano 是第一个(2002 年出现的 Lua 中的 Torch)非专有 DL 框架。Theano 是由 MILA 的 Yoshua Bengio 发明的。随着深度学习开始起飞，许多研究人员选择 Python 作为他们的语言。Tensorflow、Keras 和 PyTorch 都迅速成为事实上的深度学习框架。现在很难找到哪个深度学习论文的代码不是用 Python 实现的。
就不能用 API 吗？
一个明显的问题是，为什么不直接使用 API 在 Java 框架和部署的 Python 模型之间进行通信。GraphPipe、Kubeflow 和 TF-Serving 都提供了将模型部署到 API 的方法。API 通常是一个很好的解决方案，特别是对于简单的用例，但是在某些情况下，它们可能会增加延迟。此外，对于流处理，这可能会变得非常复杂。例如，假设您有一个 ML 微服务，它为一个带有 GrahPipe 的模型提供服务。例如，现在从 Flink 调用微服务需要使用 AsyncIO，这可能很难实现。我们现在还必须单独处理 ML 微服务的扩展。此外，在理想情况下，我们可以使用底层数据平台以分布式方式训练模型。这尤其有用，因为这些大数据系统都有易于访问/处理的库来处理数据湖中的数据。然而，在某些情况下，微服务表现很好，因此我们应该总是根据微服务的性能进行基准测试。
持续解决方案
目前，有许多可能的解决方案“正在进行中”，尽管它们都有缺点，有些目前还处于规划阶段。
- PySpark:
Spark 生态系统在整合模型方面取得了重大进展。具体来说， Spark 深度学习旨在让将 DL 模型纳入 Spark 管道变得更加容易。Spark 深度学习 Spark 也投入了大量资源来使其 Python 库 PySpark 获得成功。PySpark 实际上是用 Py4J 编写的，我稍后会讨论这一点。然而，目前没有办法在 Spark 中加载 ONNX 模型。此外，这些技术目前在流设置中不起作用。
2。 阿帕奇光束
Apache Beam 缓慢地继续尝试使其平台与 Python 代码兼容。目前，所有 Python 代码仍处于正式的“测试”阶段。然而，从长远来看，Beam 希望在 Python 中支持 Flink 和 Spark。这肯定会证明是有用的，特别是如果你的公司有一个完整的 Python 堆栈，因为你可以合并 Flink 和其他 Java 技术。
****3。tensor flow Java
Tensorflow 提供了一个 Java 版本的框架，您可以在其中加载 Tensorflow 模型。这对 Tensorflow 很好，但是它不支持其他框架。另外，性能可能不如其他方法好。
****4。【Java 嵌入式 Python (JEP)
Java 嵌入式 Python 或 JEP 允许在 Java 中使用 Python 代码。用户可以调用 Python 方法，并通过实例化的 JEP 类导入 Python 包。这是通过 Java 本地接口 (JNI)完成的，它允许 C 和 C++应用程序调用 JVM 中的应用程序。为了在 Python 中使用 Java，不能从 Python 中启动 JEP。如果您想在 Python 应用程序中使用 Java，这是一个糟糕的选择。在关于预测性维护 D 的演讲中，ongwon Kim 总结说，JEP 通常比使用 TFServing 或 Java Tensorflow API 更快(至少对于 RNN 类型的预测)。
****5。【Py4j(逆))
Py4J 允许在 Python 中使用 Java。Py4J 使用 Java 网关是为了克服与从 Python 调用 Java 相关的问题。这实际上是 PySpark 构建的一个重要部分。从长远来看，为用 Java 编写的框架提供一个有效的 Python 库可能需要以某种方式使用这个框架。
6。 DL4J
Java 深度学习最初是作为 JVM 上 DL 的全面框架。如果您还想完全用 Java 进行模型开发，它仍然是最佳解决方案。但是，它现在也支持将 Keras 模型加载到 Java 中。也许更重要的是，它在 Java 中提供了对各种多维数组的支持(本质上相当于 numpy)。
Java CPPresets 是移植到 Java 的 C/C++包的集合。它也使用 JNI，但主要是直接用于 C++包，而不是 Python。最近，CPPresets 中包含了一个 ONNX 库。使用该库，您可以加载模型并将它们导出为其他格式。然而，目前没有后端，所以没有办法实际运行加载的模型，这显然是有问题的。一个名为 Lantern 的 Scala 库最终可能会为执行模型提供必要的后端，然而这还很遥远。
其他路线
Jython 不再是一个选项，因为它只支持 Python 2.7，不支持 numpy 和许多其他库。
结论
目前，尝试将模型加载到 Java 中有多种选择。然而，不幸的是，目前都没有完成。我目前的建议是，如果要使用 batch Tensorflow，使用 PySpark。流媒体在任何情况下都会更加复杂，因此 DL4J + Keras + Spark 可能是您的最佳选择。如果你需要使用 ONNX，那么 JEP 或者一个 API 是你唯一的选择。目前，我正在整合我的模型不可知预测库，以便与 JEP 一起工作。这应该有望缓解一些与 JEP 有关的繁琐问题。我希望在接下来的几周里有一个使用 JEP 和 Flink 的端到端流示例。
合成数据生成—新数据科学家的必备技能
简要概述为自驱动数据科学项目生成合成数据的方法/包/想法，并深入研究机器学习方法。
介绍
数据是新的石油，说实话，只有少数几个大玩家对这种货币拥有最强的控制力。这个世界的谷歌和 Facebooks 对他们最新的机器学习算法和软件包如此慷慨(他们免费提供这些)，因为算法世界的准入门槛现在相当低。开源已经走过了漫长的道路，从被史蒂夫·鲍尔默等人称为邪恶的 T4 到成为微软不可或缺的一部分。大量开源项目正在推动数据科学、数字分析和机器学习的发展。
站在 2018 年我们可以有把握地说， 算法、编程框架、机器学习包(甚至是如何学习这些技术的教程和课程)都不是稀缺资源而优质数据才是。
对于数据科学和机器学习的初学者来说，这通常会产生一个复杂的问题。几年前，当我开始这条道路的旅程时，我自己也面临着这个问题。
让我也非常清楚地表明，在这篇文章中，我只是在谈论用于学习目的的数据的稀缺性，而不是用于运行任何商业操作。这不是关于如何为你正在开发的酷炫旅行或时尚应用获取优质数据的讨论。这种消费者、社会或行为数据收集有其自身的问题。然而，即使是像访问高质量数据集这样简单的事情，以开始一个人的数据科学/机器学习之旅，最终也不是那么简单。
对自驱动数据科学至关重要
数据科学热销。而且，人们正在转向数据科学。他们正在改变职业，支付新兵训练营和在线 MOOCs 的费用，在 LinkedIn 上建立关系网。但是，一旦他们通过了正规的课程，进入了一个不确定的领域，许多这样的新人就很难保持学习新技能的动力。
解决什么问题？关注哪个 MOOC？参加什么高尔夫球比赛？学什么新 ML 包？在 Github 上展示什么样的项目？需要掌握多少数学技能？
基本上，如何建立一个伟大的数据科学组合？— 根据一篇非常受欢迎的文章，答案是通过做公共工作，例如，为开源做贡献，展示创新思维和对数据建模、辩论、可视化或机器学习算法的原创贡献。
数据科学怎么找工作？了解足够的统计，机器学习，编程等，能够得到一个…
towardsdatascience.com](/how-to-build-a-data-science-portfolio-5f566517c79c)
但可悲的是，往往没有仁慈的指导或导师，往往，一个人必须自我推动。
据说，能够成功穿越这一灰色地带的人已经在自驱动数据科学领域找到了他/她的魔力。那个人会走得很远。但是，为了使这一旅程卓有成效，他(她)必须能够访问高质量的数据集进行实践和学习。
丰富的学习体验可能需要什么样的数据？
想象一下，你正在摆弄一个很酷的机器学习算法，比如 SVM 或深度神经网络。你应该在什么样的数据集上练习它们？如果您是从零开始学习，建议您从简单的小规模数据集开始，您可以在二维空间中绘制这些数据集，以便直观地理解模式，并以直观的方式亲自查看 ML 算法的工作情况。例如，这里有一篇关于各种数据集的优秀文章，你可以在不同的学习水平上尝试。
[## 24 个终极数据科学项目，提升您的知识和技能(可以免费访问)
www.analyticsvidhya.com](https://www.analyticsvidhya.com/blog/2018/05/24-ultimate-data-science-projects-to-boost-your-knowledge-and-skills/)
这是一个很好的开始。但这还不是全部。
当然，你可以更上一层楼，给自己找一个真实的大型数据集来练习算法。
但那仍然是一个固定的数据集，有固定的样本数，固定的模式，固定的正负样本的类分离度(如果我们假设是分类问题)。
你在学习算法的所有复杂之处吗
大概不会。没有一个数据集能够为给定的 ML 算法提供所有这些深刻的见解。但是，要成为一名真正的机器学习专家，这些都是非常重要的见解。
因此，你将需要一个极其丰富和足够大的数据集，它足够适合所有这些实验。
你能做什么？
那么，在这种情况下你能做什么呢？在互联网上搜寻更多的数据集，并希望其中一些能够揭示与特定算法相关的限制和挑战，并帮助你学习？
是的，这是一种可能的方法，但在时间和精力方面可能不是最可行或最佳的方法。好的数据集可能不干净或不容易获得。你可能会花更多的时间去寻找、提取和讨论一个合适的数据集，而不是花更多的时间去理解 ML 算法。
搜索现实生活中的数据集、提取它、运行探索性数据分析，并与它争论以使其为基于机器学习的建模做好适当准备的经历是无价的。我目前正在写一个关于这个主题的课程/书。
但这可以单独教授和练习。然而，在许多情况下，你可能只是想访问一个灵活的数据集(或几个数据集)来“教”你 ML 算法的所有血淋淋的细节。
令人惊讶的是，在许多情况下，这种教学可以用合成数据集来完成。
什么是合成数据集？
顾名思义，非常明显，合成数据集是以编程方式生成的数据的存储库。所以，它没有被任何现实生活中的调查或实验所收集。因此，它的主要目的是足够灵活和丰富，以帮助 ML 从业者用各种分类、回归和聚类算法进行引人入胜的实验。期望的特性是，
- 它可以是数字、二进制或分类(序数或非序数)，
- 特征的数量和数据集的长度应该是任意的
- 优选地，它应该是随机的，并且用户应该能够选择各种各样的统计分布作为该数据的基础，即，潜在的随机过程可以被精确地控制和调整，
- 如果用于分类算法，那么类别分离度应该是可控的，以使学习问题容易或困难，
- 随机噪声可以可控方式插入
- 对于回归问题，一个复杂的非线性生成过程可用于获取数据
虽然在本文中，我们的讨论仅限于更好的 ML 算法的合成数据，但在它有助于解决真实数据集的安全和隐私问题的情况下，它的目的可能是深远的，因为真实数据集不能用于或获取学习目的。例如，想想医疗或军事数据。这里有一篇关于这些方法的精彩总结文章。
在接下来的几节中，我们将展示一些快速生成合成数据集的方法，用于实践统计建模和机器学习。
演示笔记本可以在我的 Github 库 这里找到 。
使用 scikit-learn 方法生成数据
Scikit-learn 是一个了不起的 Python 库，用于经典的机器学习任务(即，如果你不特别关心深度学习)。然而，尽管它的 ML 算法被广泛使用，但它提供的很酷的合成数据生成功能却不太受欢迎。
[## sci kit-learn:Python 中的机器学习
scikit-learn.org](https://scikit-learn.org/stable/)
这里是一个快速纲要，
回归问题生成 : Scikit-learn 的**dataset.make_regression** 函数可以创建任意数量的输入特征、输出目标以及它们之间的信息耦合度可控的随机回归问题。它也可以混合高斯噪声。
Fig: Random regression problem generation using scikit-learn with varying degree of noise.
分类问题生成 :类似于上面的回归函数，**dataset.make_classification**生成一个随机的多类分类问题(数据集)，具有可控的类分离和添加的噪声。如果需要，还可以随机翻转任意百分比的输出符号来创建更难的分类数据集。
Fig: Random classification problem generation using scikit-learn with varying class separation.
聚类问题生成 :生成有趣聚类的函数相当多。最直接的方法是datasets.make_blobs，它可以生成任意数量的簇，并且距离参数是可控的。
Fig: Simple cluster data generation using scikit-learn.
各向异性集群生成:通过使用矩阵乘法的简单转换，您可以生成沿某个轴对齐或各向异性分布的集群。
Fig: Anisoproically aligned cluster data generation using scikit-learn.
同心环簇数据生成 :对于测试基于相似性的聚类算法或高斯混合模型，以特殊形状生成簇是很有用的。我们可以使用**datasets.make_circles**函数来完成。
当然，我们可以在数据中混入一些噪声来测试聚类算法的鲁棒性，
月形聚类数据生成 :我们也可以使用**datasets.make_moons**函数生成用于测试算法的月形聚类数据，噪声可控。
用任意符号表达式生成数据
虽然前面提到的函数从一开始就很棒，用户不容易控制数据生成的底层机制，回归输出也不是输入的决定性函数，它们确实是随机的。虽然这对于许多问题来说可能已经足够了，但人们可能经常需要一种可控的方式来基于明确定义的函数产生这些问题(涉及线性、非线性、理性甚至超越项)。
例如，我们想要评估各种内核化 SVM 分类器在具有越来越复杂分隔符(线性到非线性)的数据集上的功效，或者想要证明线性模型对于由理性或超越函数生成的回归数据集的局限性。使用 scikit-learn 的这些功能很难做到这一点。
此外，用户可能只想输入一个符号表达式作为生成函数(或分类任务的逻辑分隔符)。仅仅使用 scikit-learn 的实用程序很难做到这一点，必须为每个新的实验实例编写自己的函数。
为了解决符号表达式输入的问题，人们可以很容易地利用惊人的 Python 包 SymPy ，它允许理解、渲染和评估符号数学表达式，达到相当高的复杂程度。
在我以前的一篇文章中，我已经详细阐述了如何在 SymPy 库的基础上构建并创建类似于 scikit-learn 中可用的函数，但可以生成具有高度复杂性的符号表达的回归和分类数据集。查看这里的文章和我的 Github 仓库中的实际代码 。
我们描述了如何使用 SymPy，我们可以为多项式(和非线性)回归和…
towardsdatascience.com](/random-regression-and-classification-problem-generation-with-symbolic-expression-a4e190e37b8d)
例如，我们可以将一个符号表达式作为平方项( x )和正弦项(如sin(x)**)的乘积，并从中创建一个随机回归数据集。
Fig: Randomized regression dataset with symbolic expression: x².sin(x)
或者，可以生成基于非线性椭圆分类边界的数据集，用于测试神经网络算法。注意，在下图中，用户如何输入一个符号表达式 m='x1**2-x2**2' 并生成这个数据集。
Fig: Classification samples with non-linear separator.
使用“pydbgen”库生成分类数据
虽然网上有许多高质量的真实数据集可用于尝试很酷的机器学习技术，但从我的个人经验来看，我发现在学习 SQL 时并非如此。
对于数据科学专业知识来说，基本熟悉 SQL 几乎与知道如何用 Python 或 r 编写代码一样重要。但是访问一个足够大的数据库，其中包含真实的分类数据(如姓名、年龄、信用卡、SSN、地址、生日等)。)远不如访问 Kaggle 上专门为机器学习任务设计或管理的玩具数据集常见。
除了数据科学的初学者之外，即使是经验丰富的软件测试人员也会发现拥有一个简单的工具是有用的，在这个工具中，通过几行代码，他们可以生成任意大的数据集，其中包含随机的(伪造的)但有意义的条目。
输入 pydbgen 。在这里看文档。
这是一个轻量级的纯 python 库，用于生成随机有用的条目(如姓名、地址、信用卡号、日期、时间、公司名称、职位、车牌号等)。)并将它们保存在 Pandas dataframe 对象中，或者作为数据库文件中的 SQLite 表，或者保存在 MS Excel 文件中。
[## pydbgen 简介:一个随机数据帧/数据库表生成器
一个轻量级的 Python 包，用于生成随机数据库/数据帧，用于数据科学、学习 SQL、机器…
towardsdatascience.com](/introducing-pydbgen-a-random-dataframe-database-table-generator-b5c7bdc84be5)
你可以阅读上面的文章了解更多细节。这里，我将通过截图展示几个简单的数据生成示例，
Fig: Generate random names using pydbgen library.
生成几个国际电话号码，
Fig: Generate random phone numbers using pydbgen library.
生成一个完整的数据帧，随机输入姓名、地址、SSN 等。，
Fig: Generate full data frame with random entries using pydbgen library.
总结和结论
我们讨论了在进入令人兴奋的数据科学和机器学习世界的旅程中，访问高质量数据集的重要性。通常，缺乏足够灵活和丰富的数据集限制了人们深入研究机器学习或统计建模技术内部工作的能力，并使理解变得肤浅。
在这方面，合成数据集可以提供极大的帮助，并且有一些现成的函数可以尝试这种方法。然而，有时希望能够基于复杂的非线性符号输入生成合成数据，我们讨论了一种这样的方法。
要为计算机视觉和复杂的人工智能模型生成合成数据，请查看这篇文章。
人工智能和计算机视觉的合成数据终极指南什么是合成数据？合成数据是…
www.simerse.com](https://www.simerse.com/synthetic-data/)
此外，我们还讨论了一个令人兴奋的 Python 库，它可以为数据库技能练习和分析任务生成随机的真实数据集。
本文的目标是展示年轻的数据科学家不必因为没有合适的数据集而陷入困境。相反，他们应该寻找和设计自己的编程解决方案，为他们的学习目的创建合成数据。
一路上，他们可能会学到许多新技能，打开新的机会之门。
喜欢这篇文章吗？成为 中等会员 继续 无限制学习 。如果您使用下面的链接， ，我将收取您的一部分会员费，而不会对您产生额外费用 。
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@tirthajyoti/membership)
大会推特的表格分析
当我在大会上学的时候，我写了一个 python cronjob 来收集来自所有大会地点的推文。我想在课程期间写一篇关于它的博客和作品集，但是所有的测试、项目和其他事情都在进行中，事情远离了我。我最近看了一下 cronjob 收集的信息，我在 3 个月的时间里收到了 5340 条推文。我不应该让这个浪费掉，所以下面是我使用 Tableau 对 GA 的 twitter 策略的探索。如果您想与任何可视化交互，请单击可视化下方的链接。
警告/迷你咆哮
在对收集的信息和这些账户上的实际信息进行抽查比较时，我确实注意到一些推文不见了。这大概是我在 MacBook 上设置 cronjob 的一个功能。我不得不设置一个 cronjob 来收集推文，因为 Twitter 限制了在给定时间内可以收集的数据量。Macbooks 在您关闭时会进入睡眠状态，不会执行您的 cronjobs。当我了解到这一点时，我努力让我的 MacBook 在工作安排时保持打开。通常我会建议将 cronjobs 设置在一个服务器上，或者至少是一个您知道会可靠地开启和唤醒的本地服务器上，但是这些是我必须使用的资源，我觉得这些数据对于这个分析来说已经足够好了。
分析
我认为我的博客中列出的最活跃的校园，哪个 GA 校园最活跃？，也将拥有最活跃的社交媒体账户。我错了——墨尔本在这一时期最活跃，其次是波士顿。这有点道理，因为发推特不需要任何成本，但我认为有更多活动的校园会有更多的推特。
随着时间的推移查看推文，你可以看到什么校园在什么时候最活跃。例如，墨尔本在 6 月 8 日有很多活动，原因是看起来他们那天有一个基于推特语言的活动。
BufferApp 是 GA 最喜欢的推文模式。当我在 GayTravel.com 做社交媒体实习生的时候，他们最喜欢的模式是排在第二位的 Tweetdeck。
推文看起来很协调。在清理了自定义网址的推文后，5340 条中有 2339 条(44%)是唯一的。最受欢迎的推文是“雇主(像 GA！)提供丰厚的额外津贴来留住 Y 世代员工:“这段时间有 34 条推文进来。原因是这种联系导致《每日电讯报》发表了一篇报道，强调了在 GA 工作的一些额外津贴。看起来像是在 6 月 3 日和 6 月 16 日有一场通过所有校园推特账号发布这条推文的运动。我不怪 GA 宣传这份好报纸——根据你在 GA 工作第三年的文章，你有为期两周的带薪假期，包括酒店和机票！
大会有几个课类型包括 web 开发，移动开发，UX，数据科学(我毕业的那个)。UX 似乎肯定是通过标签宣传最多的(#UX、#UXDesign、#UXdesign、#ux、# UXDesign)。
就提及次数而言，GA_Denver 被提及次数最多。这并不是因为 GA 的其他校园在推广丹佛校园，而是 GA_Denver 转发了任何提到他们的人。
如果你想知道这些数据是如何收集的，或者你想要这些数据的平面文件，这里有 GitHub 链接。
R 中类似 Tableau 的拖放 GUI 可视化
Tableau 和 Qlik 等自助式数据可视化工具提供了 R 和 Python 等复杂的数据科学语言所不提供的少数几个功能之一，即创建可视化的拖放 GUI。您可以简单地拖放您的维度和度量标准，这种灵活性是如此直观，以至于没有技术经验的高中生也可以构建一个像样的可视化。
如果你是一个 R 用户，并且你一直羡慕他们，这里有一个神奇的工具——esquisse——它就在你的 RStudio 中，帮助你用拖放 GUI 构建 ggplot2 。(顺便说一下，这非常直观，Python 用户也能做到！)
关于 esquisse:
这个新的 R 包esquisse由法国公司 DreamRs 创建并开源，该公司已经开源了多个像这样有用的 R 包。
如文档中所述，
esquisse 允许您通过用 ggplot2 软件包可视化数据来交互式地浏览数据。它允许您绘制条形图、曲线、散点图、直方图，然后导出图表或检索生成图表的代码。
安装&装载
esquisse 在起重机上可用，因此可使用以下代码进行安装:
# From CRAN
install.packages("esquisse")
或者您可以使用以下代码安装 github 上的开发版本。
# with remotes
remotes::install_github("dreamRs/esquisse")
# or with install-github.me service (based on remotes)
source("https://install-github.me/dreamRs/esquisse")
# or with devtools:
devtools::install_github("dreamRs/esquisse")
拖放可视化
正如我们从一开始就知道的，这个软件包 esquisse 帮助我们通过拖放来生成可视化(ggplot2 ),我们将看到如何做同样的事情。
首先，我们将使用 R 包itunesr提取一些应用评论(在本例中，是印度电子零售商 Flipkart 的 iOS 应用)，并尝试使用我们的拖放 GUI 进行可视化。
#loading tidyverse to read inputlibrary(tidyverse)# loading itunesr for retrieving itunes review data that we will use in this analysislibrary(itunesr)#loading the magical esquisse librarylibrary(esquisse)# Flipkart Reviewsreviews <- getReviews(742044692,'in',1)#converting Rating to numeric typereviews$Rating <- as.numeric(reviews$Rating)#let us say we want to see if there's any correlation between rating and review lengthreviews$len <- nchar(reviews$Review)
上面的想法很简单。
- 我们正在加载所需的包
- 使用
itunesr获取数据 - 将变量
Rating转换为数值并计算len中的审核长度的一些数据准备
这样，我们就可以用下面的代码开始我们的拖放之旅了。
#let the magic beginesquisse::esquisser(reviews)
正如您在上面看到的，函数esquisser将我们想要可视化的数据帧作为参数，如果没有提供任何参数，它会将当前 R 环境空间中的数据帧视为选项。如果在当前的 R 环境空间中没有数据帧，那么就提供像diamond这样的内置数据集。
从这一点来说，它将是基于 GUI 的动作，因此我为这篇文章创建了以下视频——解释如何使用拖放 GUI 创建 ggplot2 可视化，并最终复制所创建的绘图的 R 代码。
复制的代码如下:
#copied codeggplot(data = reviews) +
aes(x = len, y = Rating) +
geom_point(color = '#e31a1c') +
labs(title = 'Ratings vs Reviews Length',
x = 'Length of Review',
y = 'Rating associated with Review',
caption = 'Data Source: App Store',
subtitle = 'Flipkart iOS App Reviews') +
theme_linedraw()
这给出了下面的图:
尽管上面的情节并不花哨，但这是一个完整的情节，我的意思是，有右轴标签和细节，如标题、副标题和说明。
我认为这个包肯定会节省很多时间，也为 EDA 期间的分析师提供了更多的可能性。如果你想创建这样的解决方案，你可以从 Datacamp 的用闪亮的课程用 R 构建 Web 应用程序中学到更多。这里使用的完整代码可以在我的 github 上获得。
免费注册接收我的数据科学简讯——人工智能
探索性数据分析表
Photo by Stephen Dawson on Unsplash
任何数据科学项目最重要的一步是进行探索性数据分析(EDA)。根据约翰·图基的说法，
"探索性数据分析是一种态度，一种灵活的状态，一种寻找我们认为不存在的东西以及我们认为存在的东西的意愿"
EDA 是在做机器学习模型之前执行的步骤，它提供了关于数据当前状态的有价值的见解。它可以揭示导致数据的数据管道中的代码错误，也有助于可视化数据中的异常值。
实现 EDA 的方法有很多，最常见的方法是使用 matplotlib、Seaborn 等库。我更喜欢使用 Tableau 来执行 EDA，然后如果需要，使用库来获得任何可视化，这不是作为软件的一部分。在这里，我将带你了解我如何使用 Tableau 进行单变量和双变量分析。Tableau 是一款免费软件，可从这里下载。
单变量分析
单变量分析简单地说就是一次只看一个变量，试图理解它的均值、中值、方差和分布等。可视化分布的最简单方法是使用直方图和箱线图。
直方图和箱线图
在 tableau 中创建直方图非常简单。
- 从左侧窗格的功能列表中拖动一个功能。
- 默认情况下，如果要素是一个测量值(如一组数值)，Tableau 会将值聚合为 sum 或 count。确保取消选中分析选项中的聚合度量，如下所示。
3.从可用的可视化效果中选择直方图。
4.产生如下所示的直方图。如果 x 轴上的变量不是分类变量。Tableau 会自动将它们转换为垃圾箱，这是一个很大的增值。
4.对于箱形图，选择以下选项。
双变量分析
双变量分析涉及对两个变量(通常表示为 X 、 Y )的分析，目的是确定它们之间的经验关系。
Photo by Chris Liverani on Unsplash
散点图
散点图是进行双变量分析和可视化两个变量之间关系的最佳方式。
按照以下步骤在 Tableau 中创建散点图。
- 将 x 变量拖到“列”窗格中。
- 将 y 变量拖到行窗格中。
- 默认情况下，如果要素是一个测量值(如一组数值)，Tableau 会将值聚合为 sum 或 count。确保取消选中分析选项中的聚合度量，如下所示。
4.使用趋势线突出显示数据中有趣的趋势。
将所有内容整合在一起(仪表板)
Photo by Marek Szturc on Unsplash
一旦对数据集中的每个要素执行了上述步骤，您可能会得到大量的表，而将这些表集中到一个视图中的简单方法是使用仪表盘。创建仪表板
- 选择新仪表板
2.只需从左侧的工作表窗格中逐个添加您创建的工作表。
结论
通常 EDA 步骤会被忽略，但这一步是找出最佳模型的最重要步骤之一。EDA 可以显示数据是线性分布还是非线性分布，这可以提供关于哪个模型最适合数据集的宝贵见解。
如有任何反馈或问题，欢迎随时联系我 LinkedIn
加速和高精度处理大数据
Fast Machine Learning
监督模型用于预测业务成果，其中我们已经有了对历史数据集的响应。几个例子是线索转换，正确的广告位置，员工流失和它的许多应用。拥有大型数据集可以带来更高的准确性，从而带来更好的预测和更高的盈利能力或业务成功。但线性模型表现有限，落后于非线性模型，如梯度树提升、随机森林、SVM、深度学习等。我们将讨论梯度树提升算法，因为它给出了最好的结果之一。
梯度推进
梯度树提升是一种预测算法，通过解决无限维优化问题，以决策树的线性组合的形式顺序产生模型。但是训练这些数据需要大量的时间，因为我们需要调整参数来找到准确的模型。有一种方法可以提高训练速度，那就是加速。
With Acceleration and Without Acceleration
内斯特罗夫加速
加速是优化技术中的一个一般概念，我们试图快速达到方程的最小值。内斯特罗夫加速度一般用于加速训练。如果我们对寻找 f(x)的最小值感兴趣，我们使用下面的等式来寻找最小值
其中 w 是步长。
加速梯度推进
我们可以将梯度提升与加速度相结合，其中顺序拟合值知道梯度并被视为权重和。我们使用了两个真实世界的数据集来展示性能:-
数据集的来源-https://archive.ics.uci.edu/ml/datasets.html
犯罪数据集
原始数据集有 1993 个实例和 128 个要素，其中的响应是每个人口的暴力犯罪。31 个变量有 85%缺失，因此从数据集中丢弃。
下面是带加速和不带加速的梯度助推的性能对比。
船舶推进装置的视情维护-数据集
原始数据集有 11934 个实例和 16 个特征，其中压缩机衰变状态系数和涡轮机衰变状态系数是响应。我们使用涡轮机衰变状态系数作为响应。
在这两个例子中，我们假设收缩= 0.01，最大深度= 4，每个节点的最小观察值= 10。
我们可以清楚地看到，迭代次数可以减少到 10 倍，同时保持精度，对于示例 2 甚至更高的精度。
进一步工作
我们可以进一步研究加速梯度增强的性质，同时改变超参数，如收缩和终端节点。已经表明它对收缩不太敏感。
参考文献
[1] G. Biau，B. Cadre 和 L. Rouviere，“加速梯度推进”，arXiv:1803.02042 [stat .2018 年 3 月。
[2] Friedman，Jerome h . Greedy function approximation:一种梯度推进机。安。统计学家。29 (2001 年)，第 5 号，1189-1232。doi:10.1214/aos/1013203451。
[3]内斯特罗夫。一种求解凸规划问题的方法，收敛速度为 o (1/k2)。苏联数学多克拉迪，第 27 卷，372-376 页，1983 年。
解决 Quora 问题数据集
语义相似性基本上是决定两个文档彼此有多相似，评估它对于识别重复帖子、半监督标签、两篇新闻文章是否谈论同一件事以及许多其他应用非常有用。因此，当 Quora 在一月份发布了一个潜在重复问题的数据集时，我非常感兴趣，我决定看看我是否可以快速建立一个合理的方法。TL；大卫:得到有效的东西很容易，但是得到真正有效的东西很难——但是我越来越接近了。
预处理
该文件包含大约 405，000 个问题对，其中大约 150，000 个是重复的，255，000 个是不同的。这种类的不平衡直接意味着，只要在每条记录上返回“distinct ”,就可以获得 63%的准确率，所以我决定平衡这两个类，以确保分类器真正学到了一些东西。我还必须纠正 TSV 格式的一些小问题(本质上，一些问题包含了不该包含的新行，这扰乱了 Python 的 csv 模块)。然后我使用 twokenize.py 对数据进行了标记化，这是 CMU 的 ark-tweet-nlp 标记器的一个端口，其中做了一些修改，增加了对 Python 3 的支持。使用这个标记器没有特别的要求，但是我发现它在 tweets 和大多数你可以在网上找到的其他非正式文本上表现得相当好。
基线
当一个简单的解决方案可以解决问题时，没有必要一头扎进一个复杂的解决方案，所以为了获得一个合理的基线，我决定使用一个标准的单词袋方法，同时使用线性和朴素贝叶斯分类器。scikit-learn 可以轻松处理这种事情，它的训练速度非常快，实际上很难击败——线性模型在自我评估中达到了大约 81%的准确率，这使它达到了我在深度模型中达到的最高水平。
Baseline assessment script.
德拉库拉
我以前写过关于 Dracula 的文章——它是一个字符级的自然语言模型，通过双向 LSTMs 构建更高级别的单词和文档表示。自从我上一次写这篇文章以来，我已经稍微改变了设计，去掉了特别昂贵的字符级 LSTMs，代之以卷积层:这导致了更大的单词级表示，并且看起来比旧方法稍微更准确，至少在 Twitter 词性标注方面。在此基础上需要的唯一修改是 1)同时对两个问题重复该模型，以产生文档级向量，以及 2)最终分类层，其将两者结合起来，以产生重复/不重复答案。我尝试了两种不同的方法来得出最终答案:
- 模型 1 使用标准的 softmax 层，它可以被解释为每个类的概率度量。这种情况下的成本函数是标准平均 softmax 交叉熵。
- 模型 2 将每个文档向量折叠成 128 个条目，然后使用欧几里德距离来比较它们。本来想用余弦距离，但是这个好像训练起来有难度。为了构建成本函数，我反转了标签(因此 1 变成了“不相关”，0 变成了“重复”)，并对预测距离与标签进行了均方误差分析。相似的问题逐渐获得相似的表示，而不相关的问题则没有，同时保持合理的权重。
Pretty messy high-level overview of model 2: two source documents are run through identical Dracula models, and the final document vectors are compared with Euclidean distance.
The core of the model — most of the other code in the repository is just data and IO.
比较
Dracula 的一个问题是，它非常慢，并且需要花费许多小时来运行数据集的一遍，所以为了保持我的性情，我选择报告 50:50 平衡训练的模型的准确性，以及保留的评估和测试集，以及原始文件的一个小样本(我称之为猜测集)，以了解它处理类不平衡的情况。评估集和测试集的区别在于，评估集是在训练 时使用的，以确保模型不会过度拟合训练数据，并让我了解模型是否在学习一些东西；而测试数据在训练期间根本不使用，纯粹代表模型的性能。评估不用于基线训练，但显示模型在 50:50 班级平衡时的表现。猜测集是从原始文件中提取的，具有正确的类别比例，因此它可能包含训练、评估和测试数据，以及新的示例。事情是这样的:
如前所述，基线在自我评估下表现得相当好，但是对于看不见的例子似乎表现得很差。这可能是因为它使用了一个热门词嵌入，这可能意味着它不能很好地概括新的例子。即便如此，67%也不应该被低估，因为它训练起来非常容易和快速——而且通过一些额外的功能工程，它可以很容易地变得更好。模型 1 似乎在看不见的例子上做得更好，但是仍然显示出过度拟合的迹象——我的假设是分类层很难将输入其中的两个文档向量关联起来。模型 2 在最初的试验中表现得特别好:由于每个字符只有 8 个浮点数的嵌入大小，它在看不见的例子上比模型 1 表现得更好，当用更大的嵌入大小重新训练时，它表现得甚至更好。也就是说，它仍然是最有趣的变体——它提供了良好的准确性和快速(相对而言)的训练，而文件大小不到 64 浮点模型的 1%。
将来的
因为我的时间和资源有限，所以我可以做很多超参数优化——特别是改变双向字级 LSTMs 的数量，并试验卷积层的数量和大小。我对谷歌在上周的 TensorFlow 开发峰会上宣布的 Tensorboard 中增加的功能感到兴奋，这些功能基本上允许你为一系列超参数试验绘制有趣的指标，以及他们的新部署选项。我还想扩展训练数据，以纳入更多的重复问题数据集，以及额外的短文档相似性任务。
密码
所有三个模型和基线的代码都在 Github 上:
有关下载模型的说明，请查看 README.md 文件。
Tag2Image 和 Image2Tag —图像和文本的联合表示
对人类来说，解析一个复杂的场景并描述其内容并不是一项复杂的任务。的确，人们可以用几句话迅速概括一个复杂的场景。但是对计算机来说要复杂得多。为了生产能够实现这一点的系统，我们需要结合计算机视觉和自然语言处理领域的最新技术。
作为第一步，我们将了解如何为视觉图像和文本数据生成特征向量。然后描述 CCA 算法，它将帮助我们在一个公共空间中连接构造的特征。最后，在微软 COCO 数据集上呈现两条流水线( Text2Image 和 Image2Text )的结果。
迁移学习
图像特征
卷积神经网络(CNN)可用于从图像中提取特征。在 ImageNet 上预训练的 16 层 VGGNet 就是一个例子。这是 2014 年 ImageNet 挑战赛中最先进的模型。我们只需要移除最后一个完全连接的层，并将 CNN 的其余部分视为数据集的固定特征提取器。这将为每个图像计算 4096-D 向量。
VGG-16 Architecture
标签功能
单词嵌入是一组自然语言处理工具，旨在将单词映射到一个高几何空间。换句话说，单词嵌入功能将文本语料库作为输入，并产生单词向量作为输出，使得任意两个向量之间的距离将捕获两个相关单词之间的部分语义关系。
例如，“学生”和“飞机”是语义不同的词，所以合理的嵌入空间应该将它们表示为相距很远的向量。但是“早餐”和“厨房”是有关联的词，所以需要紧密嵌入。
Word embedding space example
为了实现这种映射，我们可以使用任何最先进的预训练模型:Word2Vec(在谷歌新闻数据集上预训练的 300 维单词向量)或 GLOVE(在带有 1.9M vocab 的普通爬行数据集上预训练的 300 维单词向量)
典型相关分析
现在，我们将给出一个流行的和成功的方法，将视觉和文本特征映射到同一个潜在空间。
Two-view CCA minimizes the distance (equivalently, maximizes the correlation) between images (triangles) and their corresponding tags (circles)
给定 2 组 N 个向量: X 表示图像特征， Y 表示文本特征。分别设它们的协方差σxx 和σYY，设σxy 为互协方差。
线性典型相关分析(CCA)寻找使两个视图的相关性最大化的线性投影对:
CCA 目标可以写成以下优化问题:
设 x 和 y 分别是表示文本和视觉数据的点。为了比较 x 和 y，我们可以使用余弦相似度:
Similarity function
定性结果
在 MS COCO 数据集中，每幅图像由 5 个标题描述。第一步包括通过删除所有停用词来预先拥有这些标题，然后将它们连接起来以获得一个单词包(BoW)。然后，我们使用 TF-IDF 技术对所有嵌入的单词进行加权平均，该技术基于单词在每个字幕中出现的频率对单词进行加权。
Example of an image and its corresponding captions
tag 2 图像
对于这个任务，我们的目标是检索由给定查询文本描述的图像。给定一个查询文本，我们首先将其特征向量投影到 CCA 空间，然后用它从数据库中检索最相似的图像特征。
质疑 1:“一个打网球的人”。
质疑 2: “一个人踩着滑板在空中跳跃”。
我们可以清楚地注意到，检索到的图像与查询图像非常接近。
图像 2 标签
这里，我们的目标是找到一组正确描述查询图像的标签。给定一个查询图像，我们首先将其特征向量投影到 CCA 空间，然后用它来检索最相似的文本特征。
通常，检索到的关键字很好地描述了查询图像。但是，我们可以识别一些错误(红色)。例如，在最后一个例子中，单词“walking”被错误地检索到。我们认为这可能是由于训练集中有许多图像同时包含“人”和“行走”。
结论
典型相关分析可以用来建立多模态检索的管道。给定图像及其标签的数据集，CCA 将它们对应的特征向量映射到相同的潜在空间，在该潜在空间中，可以使用公共相似性度量来执行图像 2 标签和标签 2 图像搜索任务。
请继续关注，如果你喜欢这篇文章，请留下👏！
参考
[1] CCA:一个多视图嵌入空间，用于对互联网图像、标签及其语义进行建模。
使用 Spark 和 HBase 进行大数据处理
在 26 分钟内标记 2600 万份出版物—为代码添加“火花”
我们在的数据工程团队，在过去的两个月里一直在不知疲倦地工作，以减少标记我们整个出版物数据库所需的时间，我非常兴奋地与大家分享这一成果。该数据库拥有多达 2600 万份出版物。我们完成这项工作的最初方法是每天只标记一百万份出版物，这意味着整个数据需要 26 天，这意味着我们的实时产品在更新期间会有这么多天处于停机状态。我们不得不把这个时间缩短到几个小时，甚至缩短到几分钟。我将深入探讨这些方法以及我们是如何解决的。
为什么需要标签？
我们的产品 iPlexus.ai 为用户提供了一个可以找到出版物的界面。专利、临床试验、论文等。与生命科学研究相关。比方说，一位研究“结肠直肠癌”的院士希望看到该领域的最新出版物、专利或临床试验。为了筛选所有关于“结肠直肠癌”的资源，我们必须对我们的出版物数据库进行分类。所以我们想根据内容给我们的出版物添加标签。一个类似的例子是网飞根据类型对电影进行分类。
我们的标记方法
- 创建标记术语的数据库:
一旦我们确定我们必须标记整个数据库，我们称为“领域专家”的优秀团队在数据科学家团队的帮助下开始工作。他们必须找出不同研究领域的所有相关标签，以及我们需要寻找哪些术语来添加这些标签。此外，我们意识到在出版物的内容中可以找到开源的术语数据库，以及与这些术语相对应的标签。结合在一起，他们提出了一个本体论。这个本体充当我们的知识库。在许多其他事情中，它有 620 万个要查找的标签术语和与之对应的标签。
- 标记算法:
接下来，我们必须想出一个有效的标记算法。我们必须找到一种方法来利用这个本体并标记原始数据。在我们的出版物数据库中，我们有“文章标题”和“文章摘要”以及其他条目，如“作者”、“出版日期”、“期刊标题”。决定在“文章标题”和“文章摘要”中搜索标记术语的存在，然后相应地进行标记。标记术语可以是单词或短语，因此需要在“原样”的基础上匹配它们，字母的情况除外。标签术语中不同单词的顺序必须与文章标题和摘要中的顺序相同。此外，要检查整个短语，而不仅仅是短语的一部分。
由于出版物和标签术语这两个数据库非常庞大，我们不能选择遍历这两个数据库，因为复杂度是 O(n*n)。因此，我们选择创建一个术语标记图，其中关键字是我们将在出版物中寻找的术语，值是我们将添加到出版物中的标记。Redis 是一个显而易见的选择，因为它创建了一个内存中的数据库用于更快的查找，复杂度为 O(1)。现在，文章标题和摘要必须分解成与这些关键字相匹配的结构，以便我们可以查找它们的标签。因此，我们决定从标题和摘要中创建 ngrams ，并在 Redis 服务器中寻找这些 ngrams，如果存在的话，获取相应的标签，并相应地标记出版物。一个标签术语中的最大字数是 7，所以我们创建了 7 或更少的 ngrams。这样，复杂度将是 O(n)。
完成它
- 初始方法:Python 代码
接下来，我们的工作是实现这个算法。出版物数据存储在 mongoDB 中。标记术语存储在 Redis 服务器中。我们从编写一个 python 脚本开始，从 mongoDB 中读取发布数据，从这些数据中创建 n gram，从 Redis(如果存在)中提取这些 n gram 的值，并添加一个标签键和标签。当运行在 6 核服务器上，每个内存 8 GB 时，它每天标记大约 100 万个出版物。另一次尝试使用 60 个内核，却发现用了 6 天。
我们必须在最多一小时内完成。因此，一次头脑风暴会议被安排来彻底改变方法以减少时间。然后决定在代码中加入“Spark”。
- 最终方法:Spark/Scala 代码
出版物数据库转移到 HBase 进行分布式存储。实现了将数据从 mongo 写入 HBase 的 python 代码。事实上，spark 本身是用 scala 编写的，我们可以导入 java 的所有库以及它自己的库，所以我们选择用 scala 编写我们的标记算法。Spark 在内存中完成所有处理，比 mapreduce 编码模式快 100 倍。
出版物数据作为 RDD(弹性分布式数据集)从 HBase 提取到 Spark。类似地，从 Redis 服务器获取标记术语。为了更快地查找，我们创建了一个映射，其中关键字是这些标记术语，值是我们要标记的术语。对于出版物，创建少于或等于 7 个单词的 ngrams。这些 ngrams 在我们创建的映射中查找，如果存在，相应地标记值。
结果
怀着热切的希望，代码在一个 16 核服务器上运行，每个服务器有 64 GB RAM，标记整个出版物数据集只需要 26 分钟。我们对结果非常满意。更重要的是，我们的首席执行官在我们通知他的时候宣布了对我们的现场奖励。
基于重要单词标记文档
30 天写作挑战
这是我的 30 天写作挑战 的第三天，我试图在开始建立一个机器学习团队的新工作之前学习数据挖掘技术。昨天，我们深入研究了用于在文本文档中查找重要单词的 tf-idf 算法。现在，我们可以选择一个文档，并挑选出使该文档独特的单词，这将是一个很好的分组相似的文档在一起。可以把它想象成给每个文档建议“标签”,根据文档的内容对它们进行分类。
有很多方法可以解决这个问题，但是我将要工作的行业在不久的将来可能会受到严格的监管。我希望能够证明为什么我们为一个给定的文档建议一个类别，而不是依赖一个像神经网络一样的黑盒。我保证会在以后的文章中讨论神经网络。
有一个叫做贝叶斯分类的过程，它将让我们根据简单的概率来决定如何对事物进行分组。我不记得我是如何知道这种技术的，但我相当肯定贝叶斯定理是教给 16 岁的孩子的。我们应该会没事的…
好吧，我们言过其实了。先用通俗易懂的英语解释一下。
概率很简单。如果一个房间里有 100 个人，其中 55 个是女性，那么那个房间里的人是女性的概率是 55%。
我们把这个写成P(woman) = 55/100 = 55%。
如果房间里有 30 个人戴着一顶帽子，其中 20 个是女性，10 个是男性，那么我们知道，如果他们戴着一顶帽子，那么这个人是女性的概率是 66%。
我们把这个写成P(woman|wearing a hat) = 20/30 = 66%。
对，所以我们想知道，给定文档中的重要单词，文档属于某个类别的概率。然而，首先我们只能计算一个重要单词出现在给定类别的文档中的概率。这就是奇迹发生的地方。
贝叶斯定理让我们从P(evidence|outcome)到
P(outcome|evidence)，其实很简单。
这给了我们P(wearing a hat|woman) = (0.66 * 0.3)/0.55 = 36%。
这就是我们所需要的一切，我们收集已被手动标记的文档，并构建一个模型来预测文档的正确分类。
到目前为止，我们只考虑了基于单一证据的可能性。给定几个证据，找到某件事的概率也很容易。
想象一下，在戴帽子的人中，有 5 个人是高的。我们想知道某人戴着帽子的概率，假设我们知道他们是女性并且很高。
这给了我们P(wearing a hat|woman and tall) = (0.66 * 0.17 * 0.3)/0.55 = 0.06。
希望你能理解。
我们如何将此应用于文档分类应该是显而易见的。我想用一个真实世界的例子，你可能对可能的结果有一个直觉。我们不是要计算某人戴帽子的概率，而是要计算文档属于某个类别的概率。观察结果，比如这个人是女的还是高的，将改为文档是否包含某个单词。
这在一开始似乎是一个相当棘手的概念，但事实证明数学很简单。我们能够利用对现有数据的观察来确定一个项目属于某个类别的概率，给定一些我们知道的信息。
在下一篇文章中，我将看看如何对一个给定文档的输入数据进行规范化，这样我们就可以用同样的方式处理‘摩托车’和‘摩托车’了。
这是我的 30 天写作挑战 中的一个帖子。我是一名软件工程师，试图理解机器学习。我没有博士学位，所以我将用简单的语言和大量的例子来解释事情。
关注我的Twitter查看我的最新帖子。如果你喜欢这篇文章，请点击下面的心形按钮来分享——这将有助于其他人看到它。
标记溢出—在 Stackoverflow 中关联标记
为了从字里行间获得洞察力，您可以根据 StackOverflow 的标签所附加的问题对它们进行关联和分类。
更新:O ' Reilly 的书《Apache Spark 和 Neo4j 上的图形算法》现在可以从 neo4j.com免费下载电子书
更新 : Piotr Migdal 联系了我，提到他在 2015 年已经做了一个类似的项目同名 。我不知道这件事。我们只是在黑客马拉松中随机选择了这个团队名称。
在这篇文章中，我想展示如何使用 Neo4j-Graph-Algorithms 库中的 Jaccard 过程来实现这一点。我们将 StackOverflow 的整个转储导入 Neo4j，运行算法，然后使用 Neo4j 浏览器和大型图形可视化工具 Graphistry 可视化结果。
注意:我更新了服务器网址，所以你可能也需要更新你的网址。
9 月，我们有机会在纽约 StackOverflow 的办公室运行 GraphConnect “时髦词-宾果”GraphHack ，这真的很酷。给我留下深刻印象的是，那里的人们真的采纳了 Joel Spolsky 多年前发表的关于软件公司(可能还有其他公司)更好的办公室布局的文章。许多开放的空间和房间可供讨论，但每个团队成员都有一个私人的六边形玻璃墙办公室，这是一个个性化的思考和工作场所。
Invidual offices at StackOverflow
The “StackExchange-Wall”
对于黑客马拉松，我们选择了项目和团队名称“tag overflow”。
数据模型和导入
StackOverflow 数据模型非常简单，用户发布问题和回答，其中一个被接受。每个问题也用一个或多个标签标记标签。
Simple StackOverflow Graph Model
对于进口，我们:
- 从互联网档案下载了 StackOverflow 转储文件
- 用 7zip 提取的
- 将我们感兴趣的 XML 文件转换成节点和关系的 CSV 文件
- 使用 Neo4j bulk importer 在几分钟内导入数据
- 再过几分钟，创建一些索引和约束
然后 StackOverflow 的 Neo4j 图形数据库就可以使用了。
导入步骤都记录在 GitHub 库中，我们不久前在10M 问题庆典中已经介绍过这个过程。
我们的测试实例目前作为 Neo4j 云实例提供:
- https://demo.neo4jlabs.com
- 数据库“stackoverflow”
- 用户“stackoverflow”
- 密码“stackoverflow”
对于只读用户。
数据探索
我们使用谷歌的 Colab 笔记本在黑客马拉松团队中工作，效果非常好。这就像 Python 笔记本的 Google docs，即你有可定制的共享设置，每个人都可以在自己的电脑上编辑和运行单元格。感谢 Graphistry 的 Leo 提醒我这个非常酷的工具。
我们使用 py2neo 库连接到 Neo4j，py2neo 库建立在 Neo4j Python 驱动程序的基础上，对 Pandas 和 Numpy 有一些很好的支持。要在 4.0 数据库上使用它，需要使用 py2neo 5.x。
graph = Graph("bolt+routing://f6087a21.databases.neo4j.io:7687",
auth=("stackoverflow", "stackoverflow"),
name="stackoverflow", secure=True)
对于数据探索，我们首先运行一个查询，显示我们的图表中每种类型有多少数据。
result = {"label": [], "count": []}
for label in graph.run("CALL db.labels()").to_series():
query = f"MATCH (:`{label}`) RETURN count(*) as count"
count = graph.run(query).to_data_frame().iloc[0]['count']
result["label"].append(label)
result["count"].append(count)
nodes_df = pd.DataFrame(data=result)
nodes_df.sort_values("count")
或者如图表所示:
Entity Count Distribution
今天，我们对用户、问题和答案不感兴趣，只对他们的标签感兴趣。所以我们有 52445 个标签，这相当多，比我预期的多。
当然，它们的使用是一种幂律分布，我们的前 20 个标签的使用比后面的加起来还要多。
tag_usage_query = """
MATCH (t:Tag)
RETURN t.name as tag, size((t)<-[:TAGGED]-()) as deg
ORDER BY deg DESC LIMIT 20
"""tag_usage = graph.run(tag_usage_query).to_data_frame()
并以同样的方式绘制成图表。
Tag Degree Distribution
标签相关性
类似于优先连接网络中的人和其他事物，标签也聚集在一起。通常，你会有一个主类别，比如javascript、ruby或neo4j，然后还有很多相关的标签。有些只在那个主要类别内有效，如cypher是neo4j的一部分，有些来自其他平行区域，如neo4j和javascript。
Correlated Tags to “neo4j”
如果我们对按频率排序的标签ruby进行同现查询。
MATCH (q:Question)-[t:TAGGED]->(tag:Tag {name:$tagName}),
(q)-[:TAGGED]->(other:Tag)
WITH tag,other, count(*) AS freq
ORDER BY freq desc LIMIT 15
RETURN other.name, freq
Tag correlations within the “ruby” tag.
您会发现结果是有意义的，其中许多标签要么是主要的 ruby 项目，要么是库。
我们还可以在 Neo4j 浏览器中将这些关联呈现为虚拟关系，方法是在我们的聚合数据上使用apoc.create.vRelationship函数，用count作为属性来表示SIMILAR关系。
MATCH (q:Question)-[t:TAGGED]->(tag:Tag {name:"ruby"}),
(q)-[:TAGGED]->(other:Tag)
WITH tag,other, count(*) as freqORDER BY freq DESC LIMIT 50
RETURN tag, other,
apoc.create.vRelationship(tag,'SIMILAR',{freq:freq}, other);
Correlation Visualization with Virtual Relationships
接下来，我们想通过观察它们的程度，来看看这些其他标签的使用频率。
MATCH (q:Question)-[t:TAGGED]->(tag:Tag {name:$tagName}),
(q)-[:TAGGED]->(other:Tag)
WITH other, count(*) as freq
RETURN other.name, freq, size((other)<-[:TAGGED]-()) AS degree
ORDER BY freq DESC LIMIT 10
Usage frequencies of correlated tags.
原来rails、arrays、javascript的使用率真的很高。Rails 显示了它的受欢迎程度，其他两个标签也独立于 Ruby 用于其他编程语言问题。
标签相似度
然后我们看了标签的相似度计算，基于它们所附加的问题。
我们从基于两个集合的交集和总大小的 Jaccard 相似度开始:
jaccard(A,B) = ∣A ∩ B∣ / ( ∣A∣ + ∣B∣ - ∣A ∩ B| )jaccard(A,B) = size(intersection(A,B)) /
(size(B) + size(B) - size(intersection(A,B)))
我们可以在 Neo4j 中运行它，或者作为一个函数，比如
RETURN algo.similarity.jaccard([1,2,3], [1,2,4,5]) AS similarity
它返回0.4(即2/(3+4-2))。
或者作为用于更大数据量的过程。在那里，我们将传入一个地图/字典列表，其中每个条目都有一个item值和一个categories列表，例如[{item:1, categories:[1,2,3]},{item:2, categories:[2,3,4]}]。然后，该过程并行计算所有对的交集和相似度。我们可以传递额外的参数，如最小相似度或节点度(相关性)的截止值，详细信息记录在上面链接的文档中。
我们在我们的一小部分数据样本上运行这个程序，以显示它是有效的。
// find 100 tags with more than 50 questions
MATCH (tag:Tag) WHERE size((tag)<-[:TAGGED]-()) > 50
WITH tag LIMIT 100MATCH (q:Question)-[:TAGGED]->(tag)
// find 3M tagged questions for those
WITH * LIMIT 3000000
// create the entry per item (tag) with its categories (questions)
WITH {item:id(tag), categories: collect(id(q))} as entry
WITH collect(entry) as entries// pass the entries to the algorithm, find the top 3 most similar items to each entry
CALL algo.similarity.jaccard.stream(entries, {topK:3})
YIELD item1, item2, count1, count2, intersection, similarity
// return each pair once
WHERE item1 < item2
// return the tag names, intersections and similarities ordered by highest similarityRETURN algo.getNodeById(item1).name AS firstTag,
algo.getNodeById(item2).name AS secondTag,
intersection, similarity
ORDER BY similarity DESC LIMIT 50;
Top3-Similarities between tags.
全球相关性
然后，我们在整个数据集上运行相似性计算，限于具有至少 100 个问题的相关标签，总共 17000 个标签节点，即 2.92 亿次比较(17k)。
// tags with at least 100 questions
MATCH (tag:Tag) WHERE size((tag)<-[:TAGGED]-()) > 100 WITH tag
// get the questions
MATCH (q:Question)-[:TAGGED]->(tag)
// create dict with tag as item and questions as categoriesWITH {item:id(tag), categories: collect(id(q))} as entry
WITH collect(entry) as entries
// run jaccard, write back resultsCALL algo.similarity.jaccard(entries,
{topK:5,similarityCutoff:0.1, write:true})
YIELD nodes, similarityPairs, write, writeRelationshipType, writeProperty, min, max, mean, stdDev,
p25, p50, p75, p90, p95, p99, p999, p100RETURN *;
在我们竞争的共享测试机上运行 13 分钟来计算数据，在专用硬件上会更快。
由于 0.1 的非常高的最小相似性，并且仅写入 5 个最相似的邻居，我们创建了 2864 个SIMILAR关系，然后我们可以使用这些关系在上面运行其他图算法。
outputs of the jaccard similarity procedure.
在可视化中，我们看到我们只创建了“非常紧密”的相似性组，如scheme<->racket或sed<->awk，或者围绕 rdf、hadoop、flash 和 quickbooks 的一些小集群！
因此，我们以较低的相似性截止值 0.01 重新运行了计算，结果总共有 44728 个SIMILAR关系。
我们只保留了每个节点的前 5 位邻居，所以您可能会想到的一些相似之处可能会丢失，因为它们没有被删除。
利用相似关系
现在，我们使用新创建的关系来运行其他算法，例如像最短路径这样简单的算法。即相关标签是如何传递连接的。
MATCH (from:Tag {name:'html'}),(to:Tag {name:'neo4j'})
MATCH path = shortestPath((from)-[:SIMILAR*]-(to))
RETURN [n IN nodes(path) | n.name] as nodes
这就引出了这条路:
["html", "javascript", "json", "jackson", "spring-mvc",
"spring-boot", "spring-data", "spring-data-neo4j", "neo4j"]
或者是“javascript”的第四级邻居。
MATCH path=(:Tag {name:"javascript"})-[:SIMILAR*..4]->()
RETURN path
Neo4j Browser Visualization of “javascript” Neighborhood
除此之外，我们还在我们的推断图上快速运行其他图形算法，并将结果写回我们的数据库。
call algo.pageRank('Tag','SIMILAR');
call algo.labelPropagation('Tag','SIMILAR');
call algo.betweenness('Tag','SIMILAR');
现在我们的标签还带有pagerank、partition、centrality属性，这些属性捕捉了它们在我们的图中的相关性和位置。
match (t:Tag) return t limit 5;(:Tag {partition: 26, centrality: 406233.80006818444, name: ".net", count: 268970, pagerank: 2.532907, wikiPostId: 3607476})
(:Tag {partition: 4, centrality: 2545764.1141965324, name: "html", count: 752349, pagerank: 6.3226235, wikiPostId: 3673182})
(:Tag {partition: 415, centrality: 2731837.0951582957, name: "javascript", count: 1624044, pagerank: 5.2686405, wikiPostId: 3607052})
(:Tag {partition: 415, centrality: 642718.2814995827, name: "css", count: 537685, pagerank: 5.447395500000001, wikiPostId: 3644669})
(:Tag {partition: 204, centrality: 5703506.726861835, name: "php", count: 1200404, pagerank: 5.8298785, wikiPostId: 3607050})
形象化
既然我们的图的节点已经用图度量来丰富了，我们就可以将它们可视化，比如用我们的 NeoVis.js Javascript 库。
例如围绕javascript标签的相似度图。
可视化:图形
幸运的是， Leo Meyerovich ，Graphistry 的首席执行官和创始人，一个基于 GPU 的高性能图形可视化工具包，也在黑客马拉松上。在我们研究相似性的同时，Leo 围绕 Neo4j Python 驱动程序构建了一个小包装器，将节点和关系从一个 Cypher 查询拉到 Graphistry 的数据帧中，并根据需要绑定其列。
现在 Neo4j 连接器已经正确地集成到 Graphistry 中，所以您可以开箱使用它。此外，还有大量的 Jupyter 笔记本演示。
不过，你需要一个图形键，所以 ping Leo。
下面你可以看到图形用户界面和“kubernetes”周围网络的可视化，查询如下:
MATCH p=(t1:Tag {name:'kubernetes'})-[r:SIMILAR*..4]-(t2:Tag)
RETURN p
以下是 python 代码:
GRAPHISTRY = {
'server': 'labs.graphistry.com',
'api': 2,
'key': 'xxxx'
} NEO4J = {
'uri': "bolt+routing://f6087a21.databases.neo4j.io:7687",
'auth': ("stackoverflow", "stackoverflow")
}!pip install pandas
!pip install graphistry[bolt] import pandas as pd
import graphistry
graphistry.__version__graphistry.register(bolt=NEO4J, **GRAPHISTRY)g = graphistry.cypher("""
MATCH p=(t1:Tag {name:'kubernetes'})-[r:SIMILAR*..4]-(t2:Tag)
RETURN p
""",
{})g = g.bind(point_title='name', edge_weight='score')
# point_size='pagerank', point_color='partition',g.plot()
Graphistry Visualization of the K8S neighborhood.
在 graphistry 中，你可以直接用绑定来配置一些可视化设置，见上面的name。其他的更容易通过 UI 控制，通过Add Histogram for …并选择一个属性，然后你可以使用这个分布来给节点和关系着色或调整大小。
摘要
这仅仅触及了图模型、图算法和 StackOverflow 数据可视化的表面。
我希望我激发了你对数据和数据集的兴趣，实例和笔记本是可以公开访问的，所以请尝试一下。我会再写一篇关于你可以在这个数据集上做的有趣的图形查询的文章。
对于流行语——黑客马拉松来说，这绝对是值得的——我们赢得了“最流行语”类别:)非常感谢我的合作者参与讨论，以及与这个很酷的数据集一起工作的乐趣。在这里，你可以读到黑客马拉松中另一个很酷的参赛项目，即空间图形应用。
请让我知道你还想做什么，我肯定有更多的想法。给 devrel@neo4j.com写信或者在这个帖子上留言。
Free download: O’Reilly “Graph Algorithms on Apache Spark and Neo4j”
照顾好你的神经瘤
什么是神经瘤？
这是你自己的智能技术。是湿科技和健康科技。它在你体内。
它有数千亿个神经元，每个神经元与相邻的神经元有大约 10，000 个连接，并调节数十亿个分子。你的神经细胞每时每刻都在发出数以万亿计的脉冲。
它有自己的编辑器:意识，一个紧急的策展人，有时会在周围留意一些事情，但不经常。
与神经瘤相比，意识非常小。然而，它有自己的小无限，被睡眠阻止，更广泛地被它不太了解的神秘开始和结束阻止。
你的神经瘤有自己的探测器，你的身体，插入外部世界，以电化学方式来回传递信号。
在它的一生中，你的神经瘤不断地根据通过你的身体进入的数据流进行自我重塑。它具有深度学习、机器学习、视频分析、大量有趣的内部人工智能(我们在环境中出现的其他自我，海滩你、酒吧你、关系你、工作你，甚至对你们中的许多人来说，一种特定的电话声音，与你的正常声音截然不同)。
它可能还有数以百万计的其他学习类型，编辑们还没有给它们贴上标签。
这是一个自我创作的复杂系统，你可以用你的意识来访问它的一部分，但大多数时候，你们中的大多数人没有足够的勇气去尝试，宁愿向外看，而不是向内看。
但是它需要你的关心。
存在于你头骨中的这个世界有一点硬技术来保护它免受许多物理撞击。
但是，它完全暴露在其环境中的数据流中，并且由于它总是响应，所以一直在根据这些数据流调整自己。
它筛选它们的模式，试图创造意义。它对威胁感到紧张，很容易被触发进入警报状态，有时是恐慌的失控警报状态，在此期间，它会分泌荷尔蒙，试图控制其检测系统的各个部分。
这些激素存在于一个持续的微妙的反馈平衡中，因为它们是它用来告诉发生了什么的方式，也是它用来使行动发生的方式。所以事情可能会出错。
它们也是重塑记忆过程的关键。对信息的反应中涉及的激素越多，神经瘤就越能被重塑以供下次回忆。
所有这些都是无意识的。严格来说，那不是真的，有些是半意识的，也可能是有意识的。所有的部分都是相连的，所以你可以用不同的方式操作它们。
我的意思是，我们可能会(在没有外部刺激的情况下)思考一些事情，而神经瘤会将这个想法作为其数据流的一部分接收到。然后，各种各样的混乱可能会在完全崩溃的恐慌和超过你一天所能处理的更多的快乐之间开始。
这是半意识的版本，你意识到这个想法，然后意识到它给你的感觉，有点意识到你做了什么，但没有太多其他的。
全意识版本是关于有意识地使用你的编辑器来学习如何保护和生长你自己的神经瘤，来监控和发展它的健康。
我想现在够了。一些让你思考和实践的东西。如果你愿意，可以和我谈谈。
迈出下一步:面向中间数据科学的 MOOCs
There are many steps in the journey to Data Science Mastery
一旦你完成了“面向初学者的机器学习”MOOC，你可以去一些地方。
为初学者找到数据科学课程相对容易——事实上，你甚至无法在没有收到 Udemy 垃圾邮件的情况下观看泰勒·斯威夫特的视频。为想更进一步的人找到课程有点困难。我在这里列出了一些目前或即将开始的 MOOCs，它们试图以不同的方式做到这一点。在某些情况下，这意味着重新审视我们已经深入了解过的材料。在其他情况下，这可能意味着向外扩展知识或学习更好的方法来应用现有的知识。
事实上，第一个示例课程将是学习应用知识的新方法。人们常说，数据科学是统计学、计算和业务知识的结合，或者类似的东西，但还没有大量针对数据专业人员的围绕业务知识的材料。埃塞克商学院(ESSEC Business School)开设的 Coursera Strategic Business Insights specialization 课程是填补这一空白的明确尝试。该系列的第一门课程，战略分析的基础，为这一努力定下了基调，专注于你可以将统计应用于更新更先进技术的商业用例。本课程的后续课程是营销分析基础，当这两个课程结合在一起时，您已经涵盖了商业导向的数据科学招聘广告中最常提及的广泛用例。
对于那些对深入研究统计学更感兴趣的人来说，有几个可能的选择。埃因霍温科技大学 Coursera 提供的一个很有前途的项目是改善你的统计推断。本课程以令人惊讶的方式介绍了支撑统计推断的理论，对于那些还没有有幸学习第三年或更高年级统计理论课程的人来说，本课程应该包含许多新材料，对于那些已经学习过的人来说，可能至少包含一些新材料。你也可以通过 Efron 和 Hastie 的新书“计算机时代统计推理”进一步学习，这本书可以免费下载，在与 Eindhoven 推理课程类似的地方开始后，可以更深入地研究应用于机器学习的推理。
埃因霍温课程提到了贝叶斯统计，但并不打算深入调查这一领域的统计推断。幸运的是，有一些课程，比如加州大学圣克鲁斯分校的贝叶斯统计就涉及到统计思想的这个重要领域。有概率和先验的前提条件(懂吗？)在统计推断方面的工作，这有望成为这一领域的实质性讨论。
数据科学家的另一个重要武器是对数据库实践的扎实知识。顾名思义，佐治亚理工学院的数据库系统概念课程从基础开始处理数据库，从数据库体系结构的基础开始，到对数据库构建方式的全面理解，以获得最佳结果。
最后一个产品来自微软，他们以相对较小的块组织了一个大数据专业程序。该计划将带您从大数据的开端到 NoSQL 的高级使用以及分析大数据的相关方法，所有这些都在当前的微软产品套件中。
罗伯特·德格拉夫为 Medium 撰写了许多文章，讲述了他在通过第一基地后遇到的数据科学方面的问题。最近的条目，关于使用质量保证技术在实现后保持稳定的模型是 在这里找到 。
机器学习国际会议的收获
我从 ICML 2018 中学到了什么
作为一名专注于应用机器学习的工程师，我很幸运地参加了今年在瑞典斯德哥尔摩举行的机器学习国际会议(ICML)。以下是我最大的收获。
1.模仿对强化学习有重要的好处
主持人:岳(加州理工)&黄明乐(加州理工)
也被称为“从示范中学习”或“学徒学习”，模仿学习是 ML 研究的一个有前途的领域，因为它通过模仿预先存在的目标行为来帮助学习主体克服在开放世界环境中学习的挑战。例如，迪士尼的研究使用模仿学习来创造面部动画，模仿人们在说各种语言时下巴移动的方式——这是岳和乐与迪士尼合作的项目。
探索的其他应用包括基于人类决策的自动驾驶汽车训练，基于获胜的例子跟踪运动员应该在场上的位置，以及挑选和放置物品以实现目标(想想亚马逊仓库)。
Demo of RL agent “mouthing” German by imitating a human.
模仿学习是引人注目的，因为它使用“成功”的例子来解决其母学科的一些基本挑战，强化学习。毕竟，强化学习的全部目的是训练一个代理人通过在一个环境中采取行动来最大化它收到的累积奖励(想象一只人工智能狗试图通过找出执行哪些技巧来最大化它可以获得的奖励数量)。通过发现预先存在的获胜行为作为目标(从“专家”或“示范者”那里)，模仿学习有助于 a)缩小可能导致奖励的可能行动的范围(没有专家，“行动空间”可能会非常大)和 b)建立行动和奖励之间的直接关联(而不是不确定在给定的情节中哪个行动导致了奖励)。
本次演讲涉及的技术包括行为克隆、直接策略学习和反向 RL。
视频和幻灯片此处。
2.无模型强化学习还没有为现实世界做好准备
演讲者:本杰明·雷希特(加州大学伯克利分校)
无模型强化学习试图通过让代理直接与其环境交互来最大化代理获得的回报，而不是首先建立该环境的明确定义的模型并作为代理与该模型交互。无模型方法之所以吸引人，是因为它们不需要试图建立一个有问题的环境模型的努力和开销。
从表面上看，似乎无模型 RL 将是帮助解决现实世界场景，特别是连续控制问题的一个很好的选择。连续控制问题涉及控制现实世界动态系统的输入以最小化成本(例如，机器人学习移动，自动驾驶汽车在繁忙的道路上导航，以及无人驾驶飞行器学习在半空中稳定)。因为连续控制问题在公式化方面非常类似于 RL 问题，即由状态、动作、转换和回报组成的最小化问题，如果我们能够学会解决这些问题而无需首先模拟复杂的现实世界环境，那不是很好吗？
Image shot by a stable unmanned aerial vehicle.
然而，尽管这看起来很有希望，但让无模型的 RL 代理控制现实世界的系统存在一些基本挑战。正如 Recht 博士在他的教程中令人信服地指出的那样，无模型强化学习只有在高度结构化的封闭环境中才真正有效，例如在模拟和游戏中。一旦一个代理进入真实世界的连续环境，它的性能就会变得非常不稳定，甚至对初始化中最小的扰动和变化都很敏感。性能下降的原因可能是因为封闭环境不能模拟所有真实世界的条件，所以在封闭环境中表现良好的代理可能不太适合预测真实世界中看不见的扰动。
无模型强化学习在现实世界中失败的第二个原因是现实世界不允许太多的实验，这是无模型学习的关键基础，因为赌注要高得多。例如，考虑一个 RL 代理在高速公路上学习控制一辆摩托车:它不允许失败到与模拟中相同的程度，因为重复摧毁摩托车的成本——更不用说有人类参与的情况了——因此代理不能像模拟中一样通过试错来学习。
Humanoid trained to walk in simulation using model-free RL.
考虑到强化学习会议是今年 ICML 最受欢迎的会议之一(以至于会议被开玩笑地称为 ICRL)，Recht 博士建议社区要么专注于基于模型的RL——特别是模型预测控制——要么寻找基本技术来进一步稳定现实环境中的无模型强化学习。Recht 警告说，如果我们继续只在仿真中优化无模型 RL 控制算法，我们就找错了对象。
为了更深入地了解 Recht 博士的工作，我推荐阅读他的简洁但极具教育意义的系列文章“一个局外人的强化学习之旅
视频和幻灯片在这里。
3.人工智能对安全至关重要
主持人:黎明之歌(加州大学伯克利分校)
这个演讲探讨了人工智能和安全交叉领域的挑战和机遇:如果我们要将人工智能研究投入产品，机器学习和安全如何有一个纠缠不清的前进道路。为了展示我们的学习算法有多脆弱，宋博士讨论了攻击深度学习系统的不同技术，特别是视觉系统(有关这方面的例子，请查看我的介绍性工作这里)。另一方面，机器学习也可以用于为不同的软件系统(例如 web 服务和物联网云)创建新的攻击。
关于安全和 ML 的叙述的另一个关键部分是隐私的处理，特别是防止从机器学习模型中提取敏感信息的问题。虽然本质上是介绍性的，但这个演讲是对安全和机器学习之间日益增长的关系的一个很好的看法，它强调了前进中需要注意的一些最重要的问题。
4.ICML 流行的纸主题
我在 ICML 偶然发现了一些有趣的论文，我认为按主题分类会有所帮助。
a)对手
我遇到的最大主题之一是对抗性机器学习，这是一个广泛的领域，利用学习算法之间的竞争来优化产生新样本的生成器。在这个领域中，有两个主要的子领域——一个是基于来自训练集的学习来生成新样本(例如训练生成器以得出特定风格的绘画),另一个是生成旨在欺骗神经网络的对立样本。
Image generated through generative adversarial learning.
论文:
模糊的渐变给人一种虚假的安全感:规避对敌对例子的防御
哪些 gan 的训练方法实际上是一致的？
b)深度学习的新架构
这个主题指的是在向神经网络引入新的架构组件方面的进步，我看到了很多关于这方面的讨论。这项工作从整体上推进了深度学习领域，并为解决不同领域的预测问题提供了新的工具。
论文:
c)将机器学习的进步应用到产品中
与在产品中部署机器学习系统相关的研究。
纸张:
d)强化学习
在状态-行动空间中通过决策解决累积奖励最大化问题的进展。
论文:
e)理论
这里的工作旨在进一步加深我们对机器学习(特别是深度学习)为什么以及如何工作的理论理解。这项工作对于使我们能够不断向前推进模型和网络的部署至关重要，因为它提供了基础知识来对比深度学习社区取得的高度经验性进展。
论文:
f)隐私和公平
随着深度学习在广泛处理人群的上下文中变得适用(例如，医疗保健、贷款申请评估等。)，我们需要切向工具来消除训练数据中存在的历史偏见。同时，我们需要知道隐私信息不能通过敌对攻击从模型中提取出来的方法。这项工作在这些领域取得了进展。
论文:
5.在 ICML 偷听到的
最后，一些有趣而有意义的 ICML 语录:
“一旦我们将其投入生产，所有的机器学习都变成了强化学习。今天，你有这些大公司根据用户反馈定期重新训练模型。那就是强化学习。”
Benjamin Recht 博士，副教授(加州大学伯克利分校)
背景:【Benjamin Recht 博士提倡进行更多的基础研究，以稳定连续现实世界环境中的强化学习代理。他反映，生产中的许多非 RL 模型经常基于反馈进行再培训，实际上使它们成为 RL 系统。
“作为机器学习人员，我们都喜欢写的那一行，即“(acc，loss) = model.evaluate(x_test，y_test)”已经不够了。”
——尼古拉斯·卡里尼，研究科学家(谷歌大脑)
背景: Nicholas Carlini 因其作品“模糊的渐变产生一种虚假的安全感”获得最佳论文奖，他提倡一种更结构化的方法来验证模型，即通过创建方法来识别模型的安全程度。
怎么样了？谢谢你有用的建设性建议和你有价值的深度问题。如果我们有空间来测试我们的估计，我们将阐明我们所学到的内容并更新最终附录！
- ICML 2018 组委会
上下文:对于所有提交给 ICML 大学、需要修改才能被接受的论文，组织者使用经典的 NLP 技术来确定作者在回应批评时使用的最有可能改变结果的单词和短语。这是一个有趣的关键短语的大杂烩，旨在增加作者被 ICML 接受的机会..
结论
超过 5000 名与会者和 600 多篇论文、主题演讲、海报展示以及在六天的紧凑日程中颁发的奖项，今年的 ICML 可谓收获颇丰。除了学术机构，许多公司也蜂拥而至，设立了自己的展位(我在另一篇文章中专门写了谁在那里)。)今年提交给 ICML 的出席人数和新研究的增长不容忽视，这表明机器学习社区比以往任何时候都更加活跃。
对我来说，最重要的非技术性收获是机器学习中基础理论研究和产品开发的持续结合。ML 仍然是一个尚未真正商品化的领域。尽管我们有越来越复杂、先进和易用的工具(TensorFlow、PyTorch、云服务等)。)，真正有影响力的创新仍然主要来自研究。这意味着大公司继续对未知领域进行大量投资，建立研究实验室，顶级学者可以在那里赚取高额薪酬，同时制定自己的工作日程。
我希望明年能看到更多的东西，包括:
- 蒸馏研究，即解决随着社区的发展而增加 研究债务 的研究。看到更多的研究人员愿意全面处理、简化研究，并将研究置于更广阔的背景下，以减少过去十年积累的研究债务，这将是一件好事。**
- 我也希望看到深度学习和强化学习之外的更广泛的优化探索。这只是我的看法，但我相信人工通用智能将不会是一个特定的领域，而是将优化与对大脑的半结构化理解结合起来。我认为，在解决智力问题时，社区应该继续从动物和人类的大脑中寻找灵感。
总而言之，ICML 是一次非凡的经历。我离开会议时充满活力，并受到鼓舞，继续致力于机器学习问题，将我的努力集中在提炼特定的研究领域，以便其他人可以了解哪些问题已经解决，并为解决其他挑战带来灵感。如果你有定量的背景并且对合作感兴趣，在这里评论或者发邮件给我。
Dhruv 是Connected的 ML 软件工程师，这是一家产品开发公司，与客户合作，通过软件驱动的产品来提高影响力。更多故事 此处 。
作者的评论
我想对伊莱·伯恩斯坦(Eli Burnstein)在多次修改中帮助校对和编辑这篇文章表示由衷的感谢。
像往常一样，留下评论并指出你在这里发现的任何错误。我会尽快修复它们！
脚注
- 基于模型的 RL 中的“模型”捕获状态和动作之间的转移概率，并包含一些关于来自这些转移的可能回报的信息。实际上，对转换动态的这种理解允许 RL 问题被简化为在一个环境中规划最优轨迹以最大化整体回报的问题。
- 连续控制问题和 RL 问题之间的相似之处是由于这两个问题的基本公式。大多数强化学习问题被认为是马尔可夫决策过程 (MDPs)。MDP 是一种数学框架，用于模拟决策场景，包括 1)有限的状态集，2)有限的行动集，3)行动导致特定状态的概率，4)由于行动而在状态之间转换后收到的即时奖励(或预期即时奖励)，以及 5)折扣因子。连续控制问题也可以被认为是 MDP，具有上述相同的基本组成部分，因此强化学习技术在该领域也是有效的，这似乎是很自然的。
让 Deep Q Networks 更进一步
又见面了，
今天的话题是…嗯，和上一个一样。Q 学习和深度 Q 网络。上次，我们解释了什么是 Q 学习，以及如何使用贝尔曼方程来寻找 Q 值，从而得出最优策略。后来，我们介绍了深度 Q 网络，以及我们如何让深度神经网络学习近似它们，而不是计算 Q 表的所有值。
深度 Q 网络将环境状态作为输入，并为每个可能的动作输出 Q 值。最大 Q 值决定了代理将执行的操作。代理的训练使用 TD 误差作为损失，TD 误差是下一个状态的最大可能值和 Q 值的当前预测值之间的差(如贝尔曼方程所示)。因此，我们设法使用神经网络来逼近 Q 表。
到目前为止一切顺利。但是当然，也出现了一些问题。这只是科学研究前进的方式。当然，我们已经提出了一些很好的解决方案。
移动 Q 目标
第一个问题是所谓的移动 Q 目标。正如我们所看到的，TD 误差的第一个组成部分(TD 代表时间差)是 Q 目标，它的计算方法是立即奖励加上下一个状态的贴现最大 Q 值。当我们训练我们的代理时，我们根据 TD 误差更新权重。但是相同的权重适用于目标值和预测值。你看到问题了吗？
我们将输出移近目标，但我们也移动了目标。所以，我们最终追逐目标，我们得到一个高度振荡的训练过程。在我们训练网络的时候保持目标不变并不好。DeepMind 正是这么做的。
它不是使用一个神经网络，而是使用两个。是的，你没听错！(好像一个还不够)。
一个作为主要的深度 Q 网络，第二个(称为目标网络)专门且周期性地更新目标的权重。这种技术被称为固定 Q 目标。事实上，权重在大部分训练中是固定的，并且只是偶尔更新一次。
最大化偏差
最大化偏差是深度 Q 网络高估值和动作值(Q)函数的趋势。为什么会这样？我认为，如果由于某种原因，网络高估了某个动作的 Q 值，那么该动作将被选为下一步的首选动作，而同样的高估值将被用作目标值。换句话说，没有办法评估具有最大值的动作实际上是否是最佳动作。这个怎么解决？答案是一个非常有趣的方法，叫做:
双深 Q 网络
为了解决最大化偏差，我们使用两个深度 Q 网络。
- 一方面，DQN 一如既往地负责下一个动作的选择(取值最大的那个)。
- 另一方面，目标网络负责该动作的评估。
诀窍在于，目标值不是由最大 Q 值自动产生的，而是由目标网络产生的。换句话说，我们要求目标网络计算在下一个状态采取行动的目标 Q 值。并且作为副作用，我们还解决了移动目标问题。整洁对吗？一石二鸟。通过将动作选择与目标 Q 值生成分离，我们能够显著降低高估，并且训练更快、更可靠。
你觉得就这样了？抱歉让你失望了。我们将更进一步。现在怎么办？你打算增加第三个神经网络吗？哈哈！！
算是吧。现在谁在笑？
决斗深度 Q 网络
先刷新一下 Q 学习的基础。q 值对应于一个行为对于一个特定的州来说有多好的度量？这就是为什么它是一个动作值函数。度量标准只不过是该州对该行动的预期回报。事实上，q 值可以分解成两部分:状态值函数 V(s)和优势值 A(s，A)。是的，我们只是引入了一个新的功能:
Q(s，a)= V(s)+ A(s，A)
优势函数捕捉的是在给定状态下，一个行为与其他行为相比有多好，而价值函数捕捉的是在这种状态下有多好。决斗 Q 网络背后的整个思想依赖于将 Q 函数表示为值和优势函数的总和。我们简单地用两个网络来学习和的每一部分，然后我们合计它们的输出。
我们这样做有什么收获吗？当然，我们有。代理现在能够评估一个状态，而不关心该状态的每个动作的效果。这意味着决定一个状态好坏的特征不一定与评估一个动作的特征相同。并且它可能根本不需要关心动作。一个州采取的行动完全不会影响环境，这种情况并不少见。那么为什么要考虑它们呢？
- 快速提示:如果您仔细观察图像，您会发现，要合计两个网络的输出，我们并不是简单地将它们相加。这背后的原因是可识别性的问题。如果我们有 Q，我们就找不到 V 和 a，所以我们不能反向传播。相反，我们选择使用平均优势作为基线(减去的项)。
最后但并非最不重要的是，我们有更多的问题要讨论，它必须与优化经验重播。
优先体验重放
你还记得经验回放是指我们时不时地向代理人回放随机的过去经验，以防止他忘记它们。如果你没有，现在你有了。但是有些经历可能比其他经历更有意义。因此，我们应该优先播放它们。为此，我们使用优先级进行采样，而不是随机采样(来自均匀分布)。首先，我们定义 TD 误差的大小(加上一些常数，以避免选择体验的概率为零)。
p = |δ|+ε
中心思想:预测和目标之间的误差越高，就越迫切需要了解它。
为了确保我们不会总是重复同样的经历，我们添加了一些随机性，这样就万事俱备了。此外，对于复杂性的动摇，我们将经验保存在一个叫做 SumTree 的二叉树中。
太多了。很多新的信息，很多新的改进。但是想想我们能把它们结合在一起。我们做到了。
我试图给出该领域最重要的最新成果的总结，并辅以一些直觉思维和数学知识。这就是强化学习对学习如此重要的原因。有如此多的潜力和如此多的增强功能，以至于你不能忽视它将成为人工智能中的大玩家的事实(如果它还不是的话)。但这就是为什么学习和跟上它是如此困难。
我们要做的就是不断学习…
如果你有任何想法、评论、问题或者你只是想了解我的最新内容，请随时与我联系LinkedinTwitterinsta gramGithub或者********
要阅读整个深度强化学习课程，学习所有你需要知道的关于人工智能的知识，去 这里 。
原载于 2018 年 10 月 14 日sergioskar . github . io。
从混乱矩阵中找出混乱
Source: Understanding Confusion Matrix by Sarang Narkhede on Towards Data Science
当我第一次了解混乱矩阵的概念时，我有一种强烈的感觉:混乱。毕竟，它们被称为混淆矩阵。事实上，我确信它们之所以如此命名，是因为它们经常如此令人困惑(不要引用我的话)。但是，当你更深入地研究混淆矩阵的构造时，它实际上并不那么令人困惑。
最重要的是要知道，它完全基于结果。
真、假、正、负
How you should look at a confusion matrix
正/负标签指的是实验的预测结果，而真/假指的是实际结果。因此，如果我预测有人怀孕了，但他们没有，那么这将是一个假阳性，因为实际结果是假的，但预测是阳性的。
错误类型
Types of Errors
混淆矩阵有两类错误:第一类和第二类。
有人教我两种方法来保持第一型和第二型的正直。如果你知道这些年来有谁帮助过你，请在评论中留下他们——我喜欢好的记忆术！
第一种方法是重新写假阴性和假阳性。假阳性是一种 I 型错误，因为假阳性= F 也为真，并且只有一个 F。假阴性是一种 II 型错误，因为假阴性= F 也为 F 也为真，因此有两个 F 使其成为 II 型错误。(莱利·达拉斯的这种方法值得称赞！)
第二种方法是考虑这些单词的意思。误报包含一个否定词(False ),所以它是一类错误。假阴性有两个否定词(假+负)，所以是第二类错误。
混淆度量
从我们的混淆矩阵中，我们可以计算出五个不同的度量标准来衡量我们模型的有效性。
- 准确度(全部正确 /全部)= TP + TN / TP + TN + FP + FN
- 分类错误(全部不正确 /全部)= FP + FN / TP + TN + FP + FN
- 精度(真正/预测正)= TP / TP + FP
- 灵敏度又名召回(真阳性/所有实际阳性)= TP / TP + FN
- 特异性(真阴性/所有实际阴性)=TN / TN + FP
示例
在这一点上，我已经向你抛出了许多单词和公式，所以让我们将我们所学的应用到一个例子中。我通过做例子学得最好，说到矩阵，没有比怀孕更好的例子了。
假设我为塔吉特百货工作，我想根据购物模式发现怀孕的青少年，这样我就可以在他们之前通知他们的父亲。我随机抽取了 500 名女性青少年顾客。在这些青少年中，有 50 人实际上已经怀孕。我预测总共有 100 个怀孕的青少年，其中 45 个真的怀孕了。
我们的任务是双重的: A) 识别 TP、TN、FP、FN，并构建混淆矩阵和 B) 计算准确度、误分类、精确度、灵敏度和特异性
首先，让我们分解我们的问题陈述来回答 a 部分。
我随机抽取了 500 名少女顾客作为样本。在这些青少年中，有 50 人实际上已经怀孕。我预测 100 个怀孕少女，其中 45 个实际怀孕。
我预测了 100 次怀孕，所以我们的“预测怀孕行”应该加起来是 100。我们知道 100 人中有 45 人确实怀孕了，所以我们可以把 45 人放在预测怀孕的实际怀孕点上，也就是真阳性。
45 are indeed pregnant
此外，我的样本中有 50 人实际上已经怀孕。所以我的实际怀孕数应该是 50。因为我们在这一栏中已经有 45 个，我们在预测的而不是实际的怀孕点中放了 5 个，也就是假阴性。
50–45 = 5
我预测了 100 次怀孕，但是只有 45 次真的怀孕了。那么在我预测的所有人中，有多少是我错误预测的呢？答案是 55，这是我的假阳性，因为我错误地预测了阳性结果。
100–45 = 55
最后，我可以通过将 45、55 和 5 相加，然后从 500 个样本中减去，来确定真正否定的数量。这给我们留下了 395 个真正的否定。一旦我们的数字被填入，我们可以通过把我们所有的方块加起来并确保它们加起来是 500 来复查我们自己。
我们也知道 55 或假阳性是我们的 I 型错误，因为我们知道我在总共 100 次预测怀孕中错误地预测了 55 次。我们知道 5 或假阴性是我们的第二类错误，因为我们知道我错误地预测了 50 个实际怀孕的女孩中有 5 个没有怀孕。
接下来，我们可以使用我们的标签混淆矩阵来计算我们的指标。
- 准确度(全部正确 /全部)= TP + TN / TP + TN + FP + FN
(45 + 395) / 500 = 440 / 500 = 0.88 或 88%准确率
2.分类错误(全部不正确 /全部)= FP + FN / TP + TN + FP + FN
(55 + 5) / 500 = 60 / 500 = 0.12 或 12%误分类
你也可以只做 1 —精度，所以:
1–0.88 = 0.12 或 12%误分类
3.精度(真正/预测正)= TP / TP + FP
45 / (45 + 55) = 45 / 100 = 0.45 或 45%精度
4.灵敏度又名召回(真阳性/所有实际阳性)= TP / TP + FN
45 / (45 + 5) = 45 / 50 = 0.90 或 90%灵敏度
5.特异性(真阴性/所有实际阴性)=TN / TN + FP
395 / (395 + 55) = 395 / 450 = 0.88 或 88%特异性
那又怎样？
Our final result
这一切都很好，但我们为什么要在乎呢？
我们之所以关心，是因为混淆矩阵可以帮助我们使用上面计算的指标来评估模型的性能。现在，我们不需要每次都做所有五个，我们只需要选择一个来帮助我们根据最坏的情况评估我们的模型。
在这种情况下，以我们的怀孕为例，假阳性的高发生率是最糟糕的结果。这使得精确度成为我想要关注的指标，它只有 45%，非常糟糕。这意味着我们有 55%的时间错误地预测怀孕，并通知父母不存在的怀孕。我们的模式，简单来说，很烂。
我希望这篇文章让您对混淆矩阵不再感到困惑。如果你有任何简化的问题或方法，请在下面的评论中留下。
1000 家 Crunchbase 创业公司的故事
介绍
受到 100 个企业家的故事的启发，我想利用 Crunchbase 创业公司的数据做类似的事情。
Crunchbase 是一个收集许多初创公司融资信息的网站。这是发现创新公司和了解他们背后的人的绝佳资源。
不幸的是，与其他公共数据源不同，人们必须支付专业会员费才能从 Crunchbase 下载数据。所以我决定在这里下载的数据，这不是最新的；然而，它对我的目的是好的。
与此同时，我创作了这个 Tableau 故事，可以在这里查看。
数据
先做最重要的事情；我们来探究一下 r 中的数据。
该数据集包含三个表:投资、公司和收购。它包括 66，000 多家成立于 1977 年至 2015 年之间的公司。在这 66，000 家公司中，大约有 18，000 家公司后来被收购。
投资
大多数资助金额在 5000 万至 6000 万美元之间。
Figure 1
按公司、类别和地区列出的最高筹资总额。
毫不奇怪，大多数顶级资助的 crunchbase 初创公司都位于美国，尤其是旧金山湾区。我相信你会熟悉这些公司中的一些或全部。
Figure 2
公司筹集的前 20 笔资金总额
Figure 3
按公司类别列出的前 20 名筹资总额
对于一家年轻的生物技术公司来说，这是一个激动人心的时刻，因为该行业的风险投资热潮。
Figure 4
生物技术风险投资排名前 15 位的城市
任何想创办生物技术公司的人都应该密切关注这个列表。
Figure 5
毫不奇怪，剑桥和波士顿应该争夺交易和美元排行榜的榜首。圣地亚哥远远落在第二位。旧金山、南旧金山、门洛帕克、海沃德、红木城和山景城都在湾区的名册上。
1977 年至 2015 年间，这 15 个最大的城市几乎占据了所有生物技术风险投资的一半。
按区域划分的前 15 名筹资总额
Figure 6
北京和上海现在是顶尖的创业中心，尽管这些亚洲城市获得的加速器资金比西欧城市少 10%。
毫不奇怪，随着联想、腾讯、阿里巴巴和百度等企业巨头在北京诞生，北京在 crunchbase 初创企业融资总额方面排名第四。
融资轮次
对那些不熟悉创业和早期投资领域的人来说(引用维基百科):
- 风险投资轮是一种用于风险资本融资的融资轮，初创公司通过它获得投资，通常来自风险资本家和其他机构投资者。获得风险投资是发展新公司和新技术的主要刺激因素之一。
- 私募股权通常是指以有限合伙制组织的投资基金，不公开交易，其投资者通常是大型机构投资者、大学捐赠基金或富裕的个人。
- 债务融资是指公司通过向个人和/或机构投资者出售债券、票据或票据来筹集营运资金或资本支出。
- 上市后是指公司首次公开发行股票后的一段时间，这是它在股权金融市场的首次亮相
- 术语“种子”意味着这是一个非常早期的投资，意味着支持企业直到它能够产生自己的现金，或者直到它准备好进行进一步的投资。
Figure 7
如果你想知道风险投资公司从哪里获得资金，可以看看 Quora 上的这篇文章。
按投资者和地区列出的最高融资额
Figure 8
前 20 名投资者中有 12 名在旧金山湾区。前 20 名投资者中有 3 名在纽约市地区。其余的顶级投资者来自巴尔的摩、中国、莫斯科、日内瓦和新加坡。
采集
对于大多数风险资本家来说，收购是一个重要的衡量标准。他们投资创业公司的钱最终必须回到锅里——最好是高倍数的。
在研究了收购表之后，我发现该表包括了失败的收购:也就是没有发生的计划收购，比如:
- 在奥巴马政府瞄准了将美国最大的制药公司转移到爱尔兰以降低其税收的交易后，辉瑞和 Allergan 终止了他们计划中的 1500 亿美元的合并。
- 美国地方法院裁决以反竞争为由阻止 Anthem-Cigna 合并， Cigna 公司取消了与 Anthem Inc .的 480 亿美元合并协议
- 在司法部计划对 Comcast 和时代华纳有线提起反垄断诉讼以试图阻止它之后， Comcase 宣布将撤回收购时代华纳有线的提议。
- 在法院以反垄断为由阻止交易后，Aetna 放弃了与 Humana 的 370 亿美元的合并计划。
- 迈兰以 260 亿美元收购佩里戈的计划失败了。
记住这一点，让我们研究一下采集数据。
收购价格金额分配
大多数收购金额在 1 亿美元左右(请记住，该数据包括高价值的不成功交易)。
Figure 9
按公司和收购方列出的顶级收购
Figure 10
记住，对于上表来说，№1，9，12，15 都没有发生。
需要多久才能被收购？
在我们的数据集中，绝大多数初创公司都是在成立 10 年内被收购的。
Figure 11
收购数量最多的顶级风投公司
最后，我们绘制了 10 大风投公司的图表(按照通过收购退出的数量排序)。
Figure 12
从 1960 年到 2015 年，思科投资、谷歌风险投资、微软风险投资、IBM 风险投资集团、惠普风险投资和英特尔投资是最活跃的企业风险投资者。雅虎和苹果没有风险投资部门。
甲骨文确实有一个风险投资部门，但它不再投资初创公司了。
EMC Ventures 现在是戴尔技术资本。
方法学
上述分析和 Tableau 中的仪表板基于从这里下载的数据，这些数据收集了 1977 年至 2015 年间成立的全球公司以及 1960 年至 2015 年间的收购信息。公司按行业分类。该图可能不包括在此期间成立和资助的所有公司。如你所见，数据中也有一些偏差。
创建这篇文章的源代码可以在这里找到。我将很高兴收到关于上述任何反馈或问题。
磁带的故事(或:如何让你的数据说简单的英语)
Do you know? (Picture by Ed Monkton)
数据=头疼。听起来熟悉吗？你可能从事销售、运营、客户服务、营销、产品、工程或任何其他工作；每个人都会受伤。
我曾在收入从 0 到 2.5 亿美元的企业中工作过，将等式改为数据=决策……在正确的时间做出正确的决定，朝着正确的方向前进。我学到的一件事是获取数据来说简单的英语。这篇文章只是关于这样做的一种方法——一个已经不再使用但仍然有效的老技巧。这不是一切，但这是一个很好的开始。
在书中，这被称为控制(或“XmR”)图。我称之为“我应该关心”图表。
TL；灾难恢复—告诉您某些事情已经改变的数据
如果现在你的业务/奖金/信誉/【你重视的东西】岌岌可危，因为你对定期跟踪的 KPI 的变化反应一贯缓慢或草率，那么这篇文章对你很重要。
当真正重要的是如果和的 KPI 已经改变了多少时，控制(或“XmR”)图结束了猜谜游戏。它检测每日/每周/每月数据中有意义的变化—销售、投诉、回扣、NPS 等—以便您知道何时做出反应。
在这篇文章的最后，我分享了一个模板，你可以用它来实践。这篇文章是根据上下文写的，以防你认为这句话适用于你，但你想核实一下。它也有高质量的图片。
Should I care? Do you care? Does anybody care? (Picture by Charlie Taylor)
如果疼，说明什么东西坏了
斯坦(真人；化名)在一家快速发展的企业中管理着一个 200 多人的运营团队。他必须确保业务能够吸收用户的指数级增长——产品发货、客户得到支持、人员得到雇佣、流程得到实施、工作实现自动化。
What’s your plan?
斯坦是个优秀的行动负责人。凡事都有计划；每个计划都有 KPI。然而，你不需要通过和迈克·泰森比赛来了解现实>计划。问题是如何预见打击的到来，并逆来顺受——换句话说，何时以及如何调整计划——因为被打脸(或害怕它会发生)是一种痛苦。
斯坦的第一个痛苦是担心生意会停滞不前。由于缺乏吸收增长的能力，营销和销售部门将不得不推迟新库存的到来或新员工的入职。他的第二个痛苦是害怕他看不到自己的深度。奖金、信誉、职业发展——今天的判断失误会让明天的回报受到质疑。
我问了斯坦他的经历。
我需要的不仅仅是漂亮的图表。数据应该回答一个问题，所以我知道要采取行动。当它不这样做时，我用直觉来填补空白。在熟悉的地方没问题，但在不熟悉的地方，这是试错法。当计划没有及时改变时，这可能是一个问题…但我不知道如何更快地发现数据的变化。你知道吗？
Up and Down, Up and Down (Caption from Venga Boys’ 1999 track: “Up and Down”)
金发女孩是一个童话故事
记得那次你改变了计划——不要太早，也不要太晚；不多也不少。刚刚好。你一次又一次地做对了。
不——因为企业是系统。事物通过它们流动(物理材料、数字内容、对话片段)；在某些点上，你有更多的控制权，而在另一些点上，你的控制权则更少；有使事物向不平衡倾斜的反馈回路和维持和谐的回路；而且有延迟。
这就是系统的感觉:
- 我们用完了 ____
- 我们有太多的 __
- 花在 __ 上的钱太多了
- 对 __ 关注不够
- 为什么我们得到了这么多 __
- 下次多拿点 __
引发匆忙和克制的延迟反应和过度反应。草率和反应不足会导致延迟，还会增加一点“以防万一”。
我不是说所有这些都有一个单一的解决方案。事实并非如此:业务可能很复杂，许多因素都会引发这些问题。
我想说的是，更敏锐地发现数据中的信号将有助于你在手枪实际开火时(而不是之前或之后)走出大门，并根据比赛的变化需求调整你的努力。
换句话说，有一种方法可以让你的感官变得敏锐。
Shovel-ready
告诉我一些我不知道的
这里有三件事(如果你都知道，我们一起出去玩吧):
- 在 1924 年，一位电话工程师做了一张图来区分自然变异(即不要反应)并发出有事发生的信号(即 react)，都是用常规的时序图(即。x 轴上的时间，y 轴上的 KPI)
- 有完善的规则来测试是否有事发生；还有一套更简单更实用的规则可以满足大多数情况
- 这些图表和规则不在 Excel 或 Google Sheets 工具栏中
这是控制图，也称为 XmR 图。在网上搜索这两个词，你可能会找到大量枯燥的技术信息。我推荐两个简单明了的信息来源:
做一个控制图，你会得到这样的东西:
Now you see it
- 灰色和彩色点是 KPI 在每个时间点的实际值
- 蓝线是给定时间点 KPI 的平均值；当系统改变时，蓝线移动并显示系统移动了多少
- 蓝色阴影区域是我们预期值下降的区域——即。它反映了系统基于其运行方式的自然变化
- 彩色点是系统性能变化的信号，即。系统脱离了自然变化——向你展示极移何时开始的
没有上下文，我们只会看着灰点，试图理解它们。数字在转化为文字之前毫无意义，而文字是空洞的，除非它们植根于我们可以信任的东西——直觉，在它可靠的情况下；大多数其他情况下的统计。控制图给数据一个你可以信任的声音。
你看着数据，它告诉你:我变了，这是我开始变的时候，这是我变了多少。现在由你来决定是否做出反应，改变计划。
那是什么——你没打算改变计划吗？那是改天的文章...
它可以是任何类型的数据。
- 如果是客户数据(如销售或 NPS)，那就是客户的声音
- 如果是商品数据(如股票)，则是流程的声音
- 如果是软件数据(比如 bug)，那就是代码的声音
- …你明白了
如果你想做一个控制图，可以用 MATLAB 来做。不要尝试在 MATLAB 中做。
这里是我做的一个控制图 Excel 模板；用这个。如果你卡住了，让我知道。如果你认为我犯了一个错误，让我知道。如果你读到这里，心想，嗯——这并没有我想象的那么无聊，请告诉我。
我花了几年时间收集数据来说简单的英语，这只是一个例子。如果这对你有帮助，那么让我知道还有什么是有帮助的，我会分享我所知道的。
PS。如果你喜欢这篇文章，你可能会喜欢我的其他一些关于产品粘性的文章:
DAU/MAU 是排名第一的粘性指标。以下是如何得到它的权利。
blog.usejournal.com](https://blog.usejournal.com/fooled-by-stickiness-a53d241ba463)*
人才获取创新:利用人工智能进行简历筛选
Stay on top of Talent Acquisition’s latest innovations (in 60 seconds or less)!
今日热点:利用人工智能进行简历筛选。
人工智能在招聘中的应用最近成为头条新闻——但它实际上意味着什么呢？我们来看看现实生活中可能改变你筛选、面试和招聘方式的一个应用。
问题: 人工筛选简历是一项繁琐、累人的工作，尤其是收到的简历中有 75% — 88%是不合格的。此外，人工筛选简历往往缺乏标准化，可能会陷入无意识的偏见。
解决方案: 分分钟自动筛选数千份简历的人工智能。
结果: 候选人以近乎完美的准确度被筛选出来，并按照面试优先顺序呈现给招聘经理。这项技术为人才招聘专家节省了大量时间。利用人工智能技术，过去需要数百小时才能完成的事情几乎可以立即完成。
预测: 这项技术将腾出时间，以便人才招聘可以专注于最重要的事情:面试和建立他们最好的团队。这项技术对于大规模招聘尤其有价值。
在 YouTube 上观看此短片下载、订阅或分享！
你在寻找一个 AI 解决方案来自动化简历筛选吗？我们可以帮你找到 (点击这里)
Share on LinkedIn and impress your boss!
Share on twitter and show off to your followers!
原载于 2016 年 11 月 15 日ideal.com。
推特表情符号讲述的故事
《权力的游戏》的视觉舆情分析
本文是我和我的同学吉安娜·甘地 为完成马里兰大学帕克分校 INST 760 课程的作业要求而进行的数据可视化项目的成果。
社交媒体平台由于其提供的表达自由，最近已经成为了解公众情绪的流行来源。为了理解情感、网络、用户参与度等，已经对公开可用的 Twitter 数据进行了大量的文本分析和研究。因为推特是公众表达的真正来源。但是人们多久会考虑分析这些推文中使用的表情符号来理解流行情绪呢？
根据《广告周刊》引用的统计数据，92%的网民使用表情符号。
Twitter 报告称，仅自 2014 年以来，已有超过 1100 亿个表情符号被发布。这些丰富的表情符号是一个未开发的宝藏，可以告诉我们很多故事和见解。
作为《权力的游戏》的粉丝，这个受欢迎的电视节目显然是我表情符号分析的主题选择。我和我的同学决定创建一个可视化工具，从 Twitter 上与# GameOfThrones 标签相关的推文中探索数百万个表情符号。表情云比单词云更有吸引力，有趣，同时提供清晰的图片。
我们收集了过去四季的数据，使用 D3.js(一个 JavaScript 可视化库)构建了一个交互式可视化工具。这个工具给了我们很多有趣的故事，揭示了公众对《权力的游戏》角色的看法。
我们发现了什么？
Interactive visualization: Emoji clouds for Game of thrones characters and relationships
1.总体最高公众情绪表明高参与度
Emoji cloud for overall sentiment — a combination of all GoT characters
对于一个用高分辨率图形制作的龙、雪僵尸和雪龙的节目来说，人们对龙着迷并不奇怪🐉。占主导地位的表情符号😱,😭表示震惊和绝望，而👏 👌和🙌表示用户正在欣赏该节目。所以总体来说，顶级人气表明这部剧非常吸引观众。还有，看起来《冰与火之歌》更火🔥比冰还多。
2.乔恩的死是悲惨和令人心碎的
Top sentiments — Jon Snow
琼恩·雪诺是推特上讨论最多的热门人物，我们有很多情感数据要分析。他的表情云充满了绝望和震惊😭,😱，以及😢我们分析说，主要是在第五季最后一集琼恩·雪诺被刺死的时候。
还有，主宰火🔥表情符号告诉我们琼恩·雪诺的原名和他的坦格利安背景是如何在推特上的粉丝中变得非常受欢迎的。
另一个有趣的发现是，一个角色和完全不相关的表情符号之间的相关性可能经常发生。在琼恩·雪诺的表情云中，我们发现了一个比萨饼🍕由于多种原因而出现，例如达美乐披萨为乔恩最喜欢的披萨做广告，或者人们在推特上说他们正在 GoT 马拉松比赛中吃披萨。
3.粉丝们敬畏艾莉亚，并鼓励她的行动
Emoji cloud — Arya Stark
Arya 的表情云主要是鼓励和力量的表情，比如🙌,👏,💪，以及👌。她的可怕的狼🐺和她的剑针🗡都暗示了她的坚强性格。
4.阿多之死令人悲痛，而乔佛里之死却备受庆祝
阿多和乔佛里的表情云对比显示了粉丝对幻想世界中虚构人物的爱或恨。所有暗示悲伤和心碎的表情符号都用在了与阿多之死有关的推文中，而暗示派对和庆祝的表情符号则用在了与乔佛里之死有关的推文中。
5.人们嘲笑萨姆的痛苦
Emoji cloud — Samwell Tarley
山姆威尔·塔利的表情云有一个独特的表情符号—💩一堆粪便。他在推特上突然成名，因为他在城堡里辛苦工作，被困在清洁便盆、堆放书籍和端汤的平淡无奇的日常工作中。
6.剧透警报通常涉及乔恩和丹妮莉丝
虽然与角色无关，但像“红色警报”这样的表情符号经常在剧透警报的背景下弹出。在所有的表情符号中，警告表情符号只在乔恩和丹妮莉丝的关系中出现，这表明大多数剧透警告都围绕着这一对。
7.眼泪并不总是意味着悲伤。快乐的眼泪也是一种东西！
琼恩和珊莎的关系表现出一张引人注目的支配哭泣的脸😭我们想知道为什么。事实证明，在经历了五个漫长的痛苦季节后，人们在团聚时流下了幸福的泪水。
这种可视化背后的设计过程
我们的目标是创建一个通过表情符号展示公众情绪的数据故事。在创建概念草图之前，我们经历了一系列的头脑风暴会议，并通过亲和力图表进行了分析。然后，我们创建了一个低保真度的功能原型，以接收进一步迭代的反馈。
The data visualization design process
Initial prototype
设计决策
- 点击脸部触发表情云，表情云会重新排列，以显示推文中与该角色一起使用的表情。
- 表情符号根据其出现的位置调整大小。更大的表情符号显示出与角色更强的联系，传达出主流的公众情绪。
- 面孔之间的可点击链接清楚地展现了两个角色之间的联系。链接是互动的，点击它们会重新构建表情云，以显示在一条推文中与两个角色一起使用的表情。
我们实现了我们的设计目标，让 TweetCloud 成为一个简单、迷人和用户友好的讲故事工具。面部和表情符号创造了一个视觉上吸引人的故事，从可视化中可以了解到角色角色的有趣见解。这种设计可以推广到可视化任何其他数据集，如趋势电影或其他电视节目，以捕捉有趣的故事和细节。
驯服 LSTMs:可变大小的小批量和为什么 PyTorch 对你的健康有益
如果你使用过 PyTorch，你可能会感到兴奋，精力增加，甚至想在阳光下走一会儿。你的生活感觉又完整了。也就是说，直到您尝试使用 RNNs 进行可变规模的小批量生产。
并非所有的希望都破灭了。读完这篇文章后，你会回到你和 PyTorch 私奔到日落的幻想中，而你的循环网络达到了你只在 Arxiv 上读到过的新精度。
我们将开发的忍者技能:
- 如何在 PyTorch 中实现每个小批量中序列大小可变的 LSTM。
- PyTorch 中填充序列和填充序列的作用。
- 通过时间屏蔽反向传播的填充令牌。
TL；DR 版本:填充句子，使所有句子长度相同， pack_padded_sequence ，遍历 LSTM，使用 pad_packed_sequence ，展平所有输出并标记，屏蔽填充输出，计算交叉熵。
为什么这很难，为什么我在乎？
速度和性能。
将可变长度的元素一次输入到一个 LSTM 中是一个巨大的技术挑战，PyTorch 等框架已经很大程度上解决了这个问题(Tensorflow 也有一个很好的抽象，但它非常非常复杂)。
此外，文档不清楚，例子太旧。通过对来自多个例子而不是一个例子的梯度有一个更好的估计器，正确地做这将加速训练和增加梯度下降的准确性。
虽然 rnn 很难并行化，因为每一步都依赖于前一步，但我们可以通过使用迷你批处理获得巨大的提升。
序列标签
虽然我不能帮你解决你对贾斯汀比伯的困扰(我不会说)，但我可以帮你对你最喜欢的 JB 歌曲进行词性标注。
这里有一个歌曲句子的例子:“现在说对不起还来得及吗？”(删除了''至''和'？')。
LSTM/GRU model we’re building
数据格式化
虽然您可以进行大量的格式化，但我们不会...为了简单起见，让我们用不同大小的序列制作这一批人为的数据。
*sent_1_x = ['is', 'it', 'too', 'late', 'now', 'say', 'sorry']
sent_1_y = ['VB', 'PRP', 'RB', 'RB', 'RB', 'VB', 'JJ']sent_2_x = ['ooh', 'ooh']
sent_2_y = ['NNP', 'NNP']sent_3_x = ['sorry', 'yeah']
sent_3_y = ['JJ', 'NNP']X = [sent_1_x, sent_2_x, sent_3_x]
Y = [sent_1_y, sent_2_y, sent_3_y]*
当我们将每个句子输入到嵌入层时，每个单词都会映射到一个索引，所以我们需要将它们转换成整数列表。
Indexing an embedding matrix
这里我们将这些句子映射到它们对应的词汇索引
*# map sentences to vocab
vocab = {'<PAD>': 0, 'is': 1, 'it': 2, 'too': 3, 'late': 4, 'now': 5, 'say': 6, 'sorry': 7, 'ooh': 8, 'yeah': 9} # fancy nested list comprehension
X = [[vocab[word] for word in sentence] for sentence in X]# X now looks like:
# [[1, 2, 3, 4, 5, 6, 7], [8, 8], [7, 9]]*
分类标签也是如此(在我们的例子中是 POS 标签)。这些不会被嵌入。
*tags = {'<PAD>': 0, 'VB': 1, 'PRP': 2, 'RB': 3, 'JJ': 4, 'NNP': 5}# fancy nested list comprehension
Y = [[tags[tag] for tag in sentence] for sentence in Y]# Y now looks like:
# [[1, 2, 3, 3, 3, 1, 4], [5, 5], [4, 5]]*
招数 1:通过填充使 mini-batch 中的所有序列具有相同的长度。
盒子里有什么东西，有各种不同的长度？不是我们的小批量！
为了让 PyTorch 完成它的工作，我们需要在填充之前保存每个序列的长度。我们将使用这些信息来掩盖损失函数。
*import numpy as npX = [[0, 1, 2, 3, 4, 5, 6],
[7, 7],
[6, 8]]# get the length of each sentence
X_lengths = [len(sentence) for sentence in X]# create an empty matrix with padding tokens
pad_token = vocab['<PAD>']
longest_sent = max(X_lengths)
batch_size = len(X)
padded_X = np.ones((batch_size, longest_sent)) * pad_token# copy over the actual sequences
for i, x_len in enumerate(X_lengths):
sequence = X[i]
padded_X[i, 0:x_len] = sequence[:x_len]# padded_X looks like:
array([[ 1., 2., 3., 4., 5., 6., 7.],
[ 8., 8., 0., 0., 0., 0., 0.],
[ 7., 9., 0., 0., 0., 0., 0.]])*
我们对标签做同样的事情:
*import numpy as npY = [[1, 2, 3, 3, 3, 1, 4],
[5, 5],
[4, 5]]# get the length of each sentence
Y_lengths = [len(sentence) for sentence in Y]# create an empty matrix with padding tokens
pad_token = tags['<PAD>']
longest_sent = max(Y_lengths)
batch_size = len(Y)
padded_Y = np.ones((batch_size, longest_sent)) * pad_token# copy over the actual sequences
for i, y_len in enumerate(Y_lengths):
sequence = Y[i]
padded_Y[i, 0:y_len] = sequence[:y_len]# padded_Y looks like:
array([[ 1., 2., 3., 3., 3., 1., 4.],
[ 5., 5., 0., 0., 0., 0., 0.],
[ 4., 5., 0., 0., 0., 0., 0.]])*
数据处理汇总:
我们将单词转换成索引序列，并用零填充每个序列，这样一批单词的大小就都一样了。我们的数据现在看起来像:
*# X
array([[ 1., 2., 3., 4., 5., 6., 7.],
[ 8., 8., 0., 0., 0., 0., 0.],
[ 7., 9., 0., 0., 0., 0., 0.]])# Y
array([[ 1., 2., 3., 3., 3., 1., 4.],
[ 5., 5., 0., 0., 0., 0., 0.],
[ 4., 5., 0., 0., 0., 0., 0.]])*
模型
我们将使用 PyTorch 创建一个非常简单的 LSTM 网络。这些层将是:
- 把...嵌入
- LSTM
- 线性的
- Softmax
招数二:如何使用 PyTorch pack_padded_sequence 和 pad_packed_sequence
概括地说，我们现在正在给一个已经填充了每个元素的批次供料。在向前传球中，我们将:
- 嵌入序列
- 使用 pack_padded_sequence 确保 LSTM 看不到填充的项目
- 将打包的批处理运行到 LSTM 中
- 使用 pad_packed_sequence 撤消打包
- 转换 lstm 输出，这样我们就可以馈送到线性层
- 通过 log_softmax 运行
- 将形状转换回来，以便我们以(batch_size，seq_len，nb_tags)结束
技巧 3:屏蔽掉我们不想在损失函数中考虑的网络输出
Mask out those padded activations
最后，我们准备计算损失函数。这里的要点是，我们不想考虑填充元素的网络输出。
直觉预警:考虑这样做的最佳方式是扁平化所有网络输出和标签。然后计算这一序列的损失。
哇，就这么简单。现在，您可以使用小批量更快地训练您的模型，并继续痴迷于 JB(仍然不会告诉，不要担心)。
我知道你现在的感受…
这当然是一个非常简单的 LSTM。你可以做些什么来美化你的模型(不全面):
- 用手套嵌入初始化。
- 使用 GRU 细胞。
- 使用双向机制(别忘了修改 init_hidden)。
- 通过用卷积网络创建编码向量并附加到单词向量，使用字符级特征。
- 添加辍学。
- 增加层数
- …太多了
- 当然，使用 Python 的最佳 hyperparemeter 优化库进行非常彻底的超参数搜索: 试管 (声明:我写了试管)。
总而言之:
这就是在 PyTorch 中通过向 LSTM 提供可变长度的批量输入来恢复理智的方法
- 首先按最大序列对输入进行排序
- 通过填充到批中最大的序列，使所有长度相同
- 使用 pack_padded_sequence 确保 LSTM 看不到填充的项目(脸书团队，你真的应该重命名这个 API)。
- 使用 pad_packed_sequence 撤消步骤 3。
- 将输出和标签展平为一个长向量。
- 屏蔽掉你不想要的输出
- 计算交叉熵。
完整代码:
出租车去冯克豪斯
不要试图把所有的知识都记在脑子里。你的大脑是一个可怕的信息存储媒介。把它放在它该在的地方:在软件里。并学会如何使用它。
我最近在柏林参加一个会议(柏林技术开放航空)。活动在一个叫 Funkhaus 的地方举行，离我在柏林米特的酒店很远。在这种情况下，我通常会打开我的优步应用程序，告诉它我想去哪里，然后优步的软件会给我发送一个司机，然后他会带我去我想去的地方。
可悲的是，优步在柏林是不存在的，因为政客们把他们的灵魂卖给了说客，这些说客扼杀了所有来自外部的创新尝试，却没有提供任何合理的对等物。所以我不得不体验德国传统出租车行业的迷人服务。
我用一个叫做 MyTaxi 的可怕的应用程序叫了一辆出租车，它缺乏让优步如此有用的所有功能。没有内置支付，没有评级，没有乘坐管理。只要大声喊一声“我在这里！”所有出租车，然后有人可能会来，如果你祈祷足够努力。
出乎意料的是，一辆出租车到了，我告诉司机我想去 Funkhaus，他说不知道那是哪里。巨大的建筑，重大的事件，一千或更多的与会者，但出租车司机从来没有听说过。对我来说很奇怪，但是没关系，没问题。我想没有人能知道所有的事情。正如哲学家唐纳德·特朗普曾经说过的，“没人知道这份工作有多难。”但谢天谢地，谷歌的机器知道。
“在谷歌地图上输入‘funk Haus’就可以了。这对我很有效，”我说。出租车司机开始摸索他的智能手机，问我地址。他为什么要地址？柏林有多少个冯克豪斯？但我没问，给了他街名:Nalepastrasse。然后他问我街道号码。“我没有电话号码，只有街道名”，我说。活动组织者只公布了街道名称。有点明显，因为这个地方太大了，几乎是整条街上唯一的东西。他们还不如叫它芬克豪斯街，而不是纳勒帕斯大街。但是没有，出租车司机没有被吓住。他需要一个确切的地址，否则他不能去。他可能想象纳勒帕斯大街会环绕东德，但事实并非如此。也许是德国的东西。
然后，我不骗你，司机拿出一本又大又旧的柏林街道手册，上面有数百页街道名称和街区地图。我的下巴掉到了汽车的地板上。我上一次看到这样的书是在 1997 年左右。我认为这可能是一个恶作剧。有人在和我开玩笑。某个地方肯定有一台照相机。接下来，司机可能会问我是否可以去查理检查站，因为他知道它在哪里。我试图保持友好。我想，下周我就可以上德国电视了。
有几分钟，我带着越来越大的困惑，看着德国出租车司机看似随意地敲着智能手机，翻看满是街道地图的页面。我在这里大方地使用了“司机”这个词，将这个词扩展到包括一个坐在驾驶座上，做了很多敲击和翻转，但没有实际驾驶的人。但是经过五分钟的不开车，我受够了。
“看在上帝的份上，让我带我们去吧，”我说。我手里拿着我的智能手机，启动 Waze，输入“Funkhaus”，点击 Go，然后说，“我们走，一直往前走！”在接下来的 20 分钟里，我把我们带到了纳勒帕斯大街。我想也许我应该向司机收费，而不是反过来，但我决定反对，因为它在德国电视上可能看起来不太好。这是我最大的市场。
到达目的地后，我付了出租车费，司机感谢我告诉他冯克豪斯在哪里。这也许是最令我困惑的。有一个出租车司机，他认为他必须知道所有东西在哪里。但是这在 21 世纪已经没有任何意义了。软件知道所有东西在哪里。他需要做的是学会如何通过智能手机上的导航仪询问软件。对出租车司机来说，这似乎是一项有用的技能。我在完全不知所措的情况下离开了汽车，确保对着电视观众向各个方向微笑。
那个星期，我又两次尝试使用名为 MyTaxi 的灾难软件，每次都有可预见的坏结果。因为它是由一个拒绝接受世界在前进的行业提供的。那么你能期待什么呢？我手机上的支付方式比我衣柜里的内裤还多。但是许多出租车仍然只收现金。还需要我多说吗？
就这样。
不要试图把所有的知识都塞进你的脑袋里。你的大脑是一个可怕的信息存储媒介。把它放在它该在的地方:在软件里。学会怎么用就好了。
我的团队希望在你的工作生活中为你导航，这样你就可以不再把所有事情都放在脑子里。 加入我未来的敏捷实践 。
TD 在强化学习中，最简单的方法
更新:学习和练习 TD 方法的最好方式是去http://rl-lab.com/gridworld-td
假设你正在驾驶装有 GPS 的汽车。在旅程开始时，GPS 会给你一个到达时间的估计值(基于统计数据)，当你开车遇到交通堵塞时(或者没有)，它会改进估计值并给你其他到达时间。
您会注意到，在旅程的每一段，您都会得到一些关于到达时间的估计。
现在假设你的全球定位系统没有给你任何估计，但存储的数据，直到你到达，然后给你一个详细的报告，每段路花了多少时间。这对你有用吗？
答案会是:这取决于你想做什么。
但肯定的是，你会感谢早期的反馈，即使不是很准确。
这就是蒙特卡罗和时态差的区别。
示例中的后一种方法是基于蒙特卡罗的，因为它会等到到达目的地后再计算行程各部分的估计值。而前者是时间差异。
事实上，如果将蒙特卡罗(MC)方法和动态规划(DP)方法结合起来，就得到时间差分(TD)方法。
注意:TD 将被记为 TD(0 ),这意味着它将向前看一步。TD(0)是 TD(n)的特例。
回想一下，在 MC 中，我们播放一整集，直到结束，然后我们计算该集中出现的每个州的折扣奖励。我们做了大量的事件，然后我们平均每个状态的不同值。
在 DP 中，我们随机初始化所有状态，然后根据周围状态的(先前计算的)值迭代计算每个状态的值。我们一直这样做，直到我们注意到任何状态值都没有显著的改善。
政策预测
我们已经看到，在 MC 中，我们播放一集直到结束，然后我们向后移动，给每个状态分配该集的贴现收益 G。但这意味着我们必须等到最后才能知道 G.
的值，然而在 TD(0)中，我们根据下一个状态的 估计值 来更新当前状态。还记得 GPS 的例子吗，在某一点上，GPS 可能会注意到您的速度下降到 10Km/h，因此它会将其到达时间的估计值更新+30 分钟，但这可能是一个非常短暂的减速，几分钟后您会再次加速，GPS 会将其估计值更新-20 分钟。
与 TD(0)相同，V(s)根据以下公式更新:
where α is the step size ∈ ]0,1], 𝛄 is the discount factor
这是一个增量平均计算。查看文章末尾的“增量平均计算”了解详情。
很明显，仅基于一个事件，对 V(s)的估计是不准确的。和你那天的汽车旅行一样！只做一次，你不会很好地估计总时间和每一部分的时间。也许那天你是幸运的，没有交通堵塞，或者相反，你是不幸的，由于车祸你被困在一个不寻常的堵塞中。
但是如果你每天都这样做(多放几集)，你就能每天都精确你的估计。
TD(0)中策略评估的算法(伪代码)如下:
Evaluate_Policy(policy):
randomly_initialize_non_terminal_states_values()Loop number_of_episodes:
let s = start_state() # Play episode until the end
Loop until game_over(): let a = get_action(policy, s, 0.1)
# get action to perform on state s according
# to the given policy 90% of the time, and a
# random action 10% of the time. let (s', r) = make_move(s, a) #make move from s using a and get
#the new state s' and the reward r # incrementally compute the average at V(s). Notice that V(s)
# depends on an estimate of V(s') and not on the return
# G as in MC
let V(s) = V(s) + alpha * [r + gamma * V(s') - V(s)] let s = s' End Loop
End Loop
政策控制
TD(0)中的策略控制有两种实现: SARSA 和 Q-Learning 。
SARSA 是一个 On-Policy 方法，这意味着它根据某个策略来计算 Q 值 ，然后代理遵循该策略。
Q-Learning 是一种 Off-Policy 方法。它包括根据贪婪策略计算 Q 值 ，但是代理不一定遵循贪婪策略。
萨尔萨
像往常一样，当执行动作时，你需要计算动作-状态函数( Q 值 )，因为它将状态和动作映射到估计。
在蒙特卡洛的文章中，我们解释了为什么单独的【V(s)】无助于确定最优政策(计划，或在每个状态下采取的行动)。
因此，假设我们处于状态 s 并且我们想要基于状态 s 和动作来计算 Q 值 ，正如我们之前看到的，TD(0)使用增量平均值来计算任何状态的值。这个平均计算，用下一个状态的值来表示。
既然我们在计算 Q 值 ，那么我们就得到了下一个状态【s’的 Q 值 。然而 Q 需要状态和动作两个参数。
SARSA 解决这个问题的方法是，为了得到 Q 值， 在状态【s’选择一个动作【a’(基于ε贪婪方法)，然后当代理到达【s’时，我们将执行动作【a’。
下图给出了一个 SARSA 示例。
**
Four actions per state: North, South, West, East
在左侧网格中，代理处于状态 s ，它计算向北移动的值(蓝色箭头)，为了能够进行计算，它需要向东移动的 Q 值s’(灰色箭头)。
右边的网格显示当代理移动到状态‘s’时，它遵循策略先前决定的动作，并计算向东(蓝色箭头)动作的 Q 值…
以下是 SARSA 的伪代码:
*SARRA():
#initialization
for each state s in AllNonTerminalStates:
for each action a in Actions(s):
Q(s,a) = random()
for each s in TerminalStates:
Q(s,_) = 0 #Q(s) = 0 for all actions in s Loop number_of_episodes:
let s = start_state() # get action to perform on state s according
# to the given policy 90% of the time, and a
# random action 10% of the time.
let a = get_epsilon_greedy_action(s, 0.1) # Play episode until the end
Loop until game_over(): # make move from s using a and get the new state s'
# and the reward r
let (s', r) = make_move(s, a) # choose action to perform on state s'
# a' will be used executed in the next iteration
# but for the moment it will be used to get Q(s', a')
let a' = get_epsilon_greedy_action(s', 0.1) # incrementally compute the average at Q(s,a)
let Q(s, a) = Q(s, a) + alpha*[r + gamma * Q(s', a') - Q(s, a)] let s = s' # move to the next state
let a = a' # use the same action a' as determined above End Loop
End Loop*
q 学习
Q-learning 与类似，只是在计算【s，a】Q(s，a)【s’，a’时，它使用贪婪策略从下一个状态s’中确定Q(s’，a’。
记住贪婪策略选择给出最高
Q 值 的动作。然而，这一点很重要，它不一定遵循那种贪婪的政策。**
这个形象的打击说明了 Q-Learning 的机理:
左侧网格显示了处于状态 s 的代理在向北行驶时计算 Q 值(蓝色箭头)。为此，它在计算中使用由状态 s(橙色箭头)的贪婪策略确定的 Q 值 。
右边的网格显示代理移动到状态‘s’，但不一定遵循贪婪策略确定的动作(橙色箭头)，而是选择随机动作(蓝色箭头)。
Q-learning 的算法如下:
**QLearning():
#initialization
for each state s in AllNonTerminalStates:
for each action a in Actions(s):
Q(s,a) = random()
for each s in TerminalStates:
Q(s,_) = 0 #Q(s) = 0 for all actions in s Loop number_of_episodes:
let s = start_state() # Play episode until the end
Loop until game_over(): # get action to perform on state s according
# to the given policy 90% of the time, and a
# random action 10% of the time.
let a = get_epsilon_greedy_action(s, 0.1) # make move from s using a and get the new state s'
# and the reward r
let (s', r) = make_move(s, a) # choose the max Q-value (qmax) on state s'
let qmax = get_max_qvalue_on_state(s') # incrementally compute the average at Q(s,a)
let Q(s, a) = Q(s, a) + alpha*[r + gamma * qmax - Q(s, a)] let s = s' # move to the next state End Loop
End Loop**
增量平均计算
这一段说明了增量平均值的计算方法。
平均值的项以既有 A(n+1)又有 A(n)的方式排列。
Incremental Average Computation
请注意，1/(n+1)表示状态值和动作值函数中的α项。
结论
时间差异比动态规划方法更好，因为它不需要环境的模型，也不需要报酬和概率分布。TD 也比蒙特卡罗方法有优势，因为不需要等到一集结束才知道回报，只需要一个时间步。
相关文章
TDA 统治一切:番茄集群
忘了 K-Means 吧！
Credits: Original Paper
你想念应用数学吗？同样，我的目标是推广拓扑数据分析及其提供的多种可能性。前一篇文章提到了机器学习和深度学习，但 TDA 在其中的一个领域找到了用途:集群。
今天，我将尝试给出一些关于 TDA(用于拓扑数据分析)的见解，这是一个快速发展的数学领域…
towardsdatascience.com](/from-tda-to-dl-d06f234f51d)
由 TDA 提供支持的聚类概念已经被引入(不那么)著名的番茄(拓扑模式分析工具)算法，在这篇论文中介绍。与更常见的(scikit-learn 类)聚类算法相比，该算法有两个优点:
- 它给你一个方法来知道你的数据似乎有多少个集群；
- 它为您提供了一种将这些数据收集到不同集合中进行聚类的方法。
我开发了与本文相关的代码作为概念验证，其中肯定有需要改进的地方！不要放弃看一看，我很乐意接受你的批评；) !
Credits: Gaijin et al.
算法演示
出于解释的目的，我将限于二维考虑。核心思想是将 TDA 应用于我们的数据点的密度估计，提取其最大值，从而提取其表观质心。很好，但是怎么做？
为了回到实际的 TDA，你需要建立单纯形树单纯形复形** 的嵌套族，最终基本上是一个对应于密度函数的图、**。
- 首先，计算密度估计并初始化结构；
- 第二，给你数据集的每一个点一个索引；
- 第三，将每个数据点通过它们的索引插入到你的单纯形树中，通过赋予它们相应的密度值作为过滤*值；
- 第四，通过平均过滤值将每个点链接到其邻域图。
您最终得到一个实例化的图，并且您可以通过上层过滤来计算相应的持久性(~ 通过对所获得的过滤值进行递减排序来定义单纯复形的嵌套族，在我的 Github 库中给出了进一步的说明。
(*)概念解释见下文
Density Estimation over a ‘two moons’ Dataset
通过计算这种过滤的持久性图(和持久性条形码),您会得到这样的结果:
gen = ClusterGenerator(structure=’anisotropy’, randomize=45)
clf = ToMaTo(*gen.generate())
_ = clf.estimate_clusters(graph=True)
Obtained Persistence from the upper levels Filtration of the Density Estimate
前面的结果让您对数据有了真正的了解:对角线上有两个元素，对应于具有最大持久性的对象。在这种情况下，持久性表征了已经创建的结构在你的图中难以重叠的程度。基本上是指全局最大值(用于上层过滤)或全局最小值(用于子层过滤)。在我们的例子中，我们只观察到你的数据有两个质心，对应两个密度峰值。现在，您需要将每个数据点链接到这两个质心，以构建不同的聚类。这可以通过一个 UnionFind 结构( disjoint-set 数据结构)来实现，并遵循下面算法中提出的思想。
ToMATo Algorithm
该概念仅基于过滤值的递减顺序。很好的一点是，你只需要一遍所有的数据点。对于每个有序数据点，您有两种可能性:
- 要么它没有具有更高过滤值的邻居，那么它被认为是局部密度最大值；
- 它也没有，您需要查看不同的邻居，合并根以将相同的边链接到其对应的最重权重的根(越接近给定的质心，权重越高)。
为了避免创建多个集群，对于由 tau，给出的过滤值有一个条件，它确保小集群将被链接到更大的集群。python 化后，它给出了以下内容(从一个更大的函数中提取，解释对象方法):
比较每个数据点的不同根/父项后:
gen = ClusterGenerator(structure='moons', randomize=45)
clf = ToMaTo(*gen.generate())
_ = clf.estimate_density(graph=**False**)
clf.estimate_clusters(graph=**False**)
prd = clf.fit_predict(num_clusters=2, graph=**True**)
其他例子
其他例子在我的 Github 资源库 中提供，作为处理各向异性数据的，那个 k-means (最常用的聚类算法之一)有聚类的麻烦(参见 scikit-learn 示例)。
gen = ClusterGenerator(structure='anisotropy', randomize=45)
clf = ToMaTo(*gen.generate())
_ = clf.estimate_density(graph=**False**)
clf.estimate_clusters(graph=**False**)
prd = clf.fit_predict(num_clusters=3, graph=**True**)
(*)一些概念
对于那些对固有理论及其数学形式感兴趣的人来说，这里有一些元素可能会告诉你。
Credits: The Simplex Tree
这个理论有很多可能性，这些结果和深度学习之间的接口目前仍在开发中。许多想法将会出现，这使得这个话题变得非常热门和有趣！敬请期待来稿，想要更多就鼓掌；)！
参考文献
TDD 举例说明
建立一个 ASP.NET 维基来学习 TDD，这是一种使用小测试用例来构建更好软件的技术
我将尝试解释什么是 TDD，以及它如何在开发过程中提供帮助。有很多资源和书籍是这样做的，但我将尝试用一个简单的实际例子来介绍它。这更像是一个“哲学”概述，而不是你能在书中读到的严格定义。反正我也没想走纯理论的路子，而是更实践的方式，让你明白我们日常生活中真正需要的是什么。这种方法的纯粹主义支持者可能会发现这个解释有点不完整(抱歉…)，但我认为这足以开始学习和理解基础知识。
也许你不需要再读一本关于 TDD 的书，只要用清晰简单的文字理解它是什么就行了
这对初学者来说很好，可以激发兴趣，进行深入的探索，然后终生拥抱它。
What is TDD? Test-driven development is a technique to build software using small test cases
什么是 TDD
从维基百科的定义开始:
测试驱动开发(TDD)是一种 软件开发过程，它依赖于一个非常短的开发周期的重复 :需求被转化为非常具体的 测试用例 ，然后软件被改进以通过新的测试，只。这与允许添加未被证明满足需求的软件的软件开发相反。
清楚了吗？TDD 的主要目的是创建一种策略，在这种策略中，测试将驱动开发过程，以便使编码更加高效、多产，减少回归。
先决条件是将一个大任务分解成更小的步骤，并使用单元测试进行开发。这允许您处理一小段代码，使它们工作，然后将许多工作部分集成在一起。
TDD 的好处
将 TDD 引入您的编码体验将会达到一个转折点。以下是一些最重要的优势:
- 关注真正重要的点:你会被要求分解问题，这将有助于你把注意力集中在最重要的事情上。
- 处理更简单的任务:每次处理一个更小的任务可以简化故障排除，加快开发速度。你不会陷入这样的情况:你会写所有的代码，然后有些东西不工作，你不知道为什么。
- 简化集成:当多个工作特性完成时，将所有特性组合在一起将是一件愉快而轻松的任务。在回归的情况下，你会提前知道代码的哪一部分是坏的。
- 免费测试:一旦全部任务完成，大量的单元测试仍然存在，可以作为集成\单元测试来验证代码，避免回归。
TDD 不是什么
TDD 是一种很好的方法，但不是:
- 测试的替换(单元测试、验收测试、UI 测试)
- 一天就能学会的东西
- 为你写代码的东西
- 一个从代码中驱除 bug 圣人
TDD 生命周期
TDD 主要由三个步骤组成:
- 编写单元测试(红色)。
- 让它工作(绿色)。
- 重构。
在示例中，您可以编写单元测试，使用其中的代码来实现该功能，直到它工作为止，然后在需要的地方重构这段代码。
步骤 1，2:让测试工作
public class StripTest
{
[Fact]
public static void StripHTml()
{
string test="<h1>test</h1>";
string expected="test";
string result=StripHTML(test);
Assert.Equal(expected,result);
}
public static string StripHTML(string input)
{
return Regex.Replace(input, "<.*?>", String.Empty);
}
}
步骤 3:重构
public class StripTest
{
[Fact]
public static void StripHTml()
{
string test="<h1>test</h1>";
string expected="test";
string result=HtmlHelper.StripHTML(test);
Assert.Equal(expected,result);
}
}
*//somewhere else*
public static class HtmlHelper
{
public static string StripHTML(string input)
{
return Regex.Replace(input, "<.*?>", String.Empty);
}
}
限制
在许多情况下，很难编写涵盖真实代码使用的单元测试。对于完全符合逻辑的过程来说，这很容易，但是当我们要涉及数据库或 UI 时，编写工作将会增加，并且在许多情况下，可能会超过好处。有一些最佳实践和框架对此有所帮助，但一般来说，并不是应用程序的所有部分都容易使用简单的单元测试来测试。
什么是 BDD？
BDD 是 TDD 的增强，它考虑了单元测试受限的情况。这个扩展将开发者作为一个单元测试，保持 BDD 背后的哲学。您仍然可以将复杂的任务分解成更小的任务，使用用户行为进行测试，并在纯后端任务上利用 TDD 的优势。
TDD 先决条件
在团队中工作时，除了掌握所有相关技术的知识之外，所有的队友都必须了解并接受这一理念。
首先，您的代码必须得到强大的单元测试系统的支持:
- 。网，。NET Core:内置 Visual Studio 或者 Xunit(第二个是我个人，首选)
- Java: JUnit 工作得非常好，我不需要寻找另一种解决方案
- PHP: PHP 单元在所有情况下都为我工作
然后，重要且强制的是:拥有一个允许在测试期间模仿或重现正确行为的架构。我说的是一个 ORM，它可以在测试期间在内存或本地数据库上工作，但也可以使用服务或存储库模式。使用阿迪框架(内置。NET core，Autofac 或其他什么…)也有帮助。
最后但同样重要的是:一个做得好的构建过程，集成到一个持续的集成流程中，除了正确的配置之外，还要定义在集成期间在其上运行哪些单元测试是有意义的，以及哪些单元测试只是在本地运行。
这个例子
让我们试着在一个真实的例子中把我们学到的关于 TDD 的东西付诸实践。我想用这种方法创建一个维基。我指的是一个简单的 wiki，用户可以在这里登录、编写减价页面并发布。听起来很复杂？
那非常容易。多亏了 TDD 和管理小任务，我很快完成了所有的微特征，最后我把已经工作的部分组装起来。
首先，我会将“长期”任务分解成更小的后续活动。每个子部分将使用小单元测试来开发。我会把重点放在维基页面上。
步骤 1:实体到 DTO 的映射
从这里开始听起来不太好。实体到 DTO 的映射是一件非常原始的事情，很难抑制我们想要从最酷的部分开始的编码本能。无论如何，这是第一个，自动一致的功能。映射两个类只需要这两个类的定义，仅此而已。无论数据库连接，网络错误等等。我们只需要创建两个类(d to 和实体)，然后进行映射。最后，测试将是一段代码，它将检查实体中的字段是否被复制到 d to。轻松点。
让我们总结一下步骤:
- 写实体。
- 写维基页面 DTO。
- 编写将实体映射到 DTO 的代码。
*// Database entity*
public class WikiPageEntity
{
[DatabaseGenerated(DatabaseGeneratedOption.Identity)]
public Guid Id { get; set; }
public int Version { get; set; }
public string Slug { get; set; }
public string Body { get; set; }
public string Title { get; set; }
}
*// DTO model in BLL*
namespace WikiCore.Lib.DTO
{
public class WikiPageDTO
{
public string Title { get; set; }
public string BodyMarkDown { get; set; }
public string BodyHtml { get; set; }
public int Version { get; set; }
public string Slug { get; set; }
}
}
*// From unit test, code omitted for brevity*
public void EntityToDTO()
{
WikiPageEntity source = new WikiPageEntity()
{
Title = "title",
Slug = "titleslug",
Version =1
};
var result = Mapper.Map<wikipagedto>(source);
Assert.Equal("title", result.Title);
Assert.Equal(1, result.Version);
}
*// From Mapping configuration, code omitted for brevity*
public MappingProfile()
{
CreateMap<wikipageentity, wikipagedto="">().ReverseMap();
}
步骤 2:降价到 HTML 转换
第二步是制作一个将markdown转换成 HTML 的方法。这将是一个非常简单的方法，它将接受一个 markdown 字符串，并检查它的转换是否与预期的 HTML 匹配。
*//Before refactoring public class MarkdownTest*
{
[Fact]
public void ConvertMarkDown()
{
var options = new MarkdownOptions
{
AutoHyperlink = true,
AutoNewLines = true,
LinkEmails = true,
QuoteSingleLine = true,
StrictBoldItalic = true
};
Markdown mark = new Markdown(options);
var testo = mark.Transform("#testo");
Assert.Equal("<h1>testo</h1>", testo);
}
*// after refactoring ( method moved to helper )*
[Fact]
public void ConvertMarkDownHelper()
{
Assert.Equal("<h1>testo</h1>", MarkdownHelper.ConvertToHtml("#testo"));
}
*// From markdown helper*
public static class MarkdownHelper
{
static MarkdownOptions options;
static Markdown converter;
static MarkdownHelper()
{
options = new MarkdownOptions
{
AutoHyperlink = true,
AutoNewLines = true,
LinkEmails = true,
QuoteSingleLine = true,
StrictBoldItalic = true
};
converter = new Markdown(options);
}
public static string ConvertToHtml(string input)
{
Markdown mark = new Markdown(options);
return mark.Transform(input);
}
}
步骤 3:用降价增强映射
干得好！我们有从 markdown 生成 HTML 的方法和将实体翻译成 DTP 的映射器。下一步？把所有的放在一起！
下一段代码包含 HTML 字段计算的映射:
*// mapped profile changed*
public class MappingProfile : Profile
{
public MappingProfile()
{
SlugHelper helper = new SlugHelper();
CreateMap<wikipageentity, wikipagedto="">()
.ForMember(dest => dest.BodyMarkDown, (expr) => expr.MapFrom<string>(x => x.Body))
.ForMember(dest => dest.BodyHtml,
(expr) => expr.MapFrom<string>(x => MarkdownHelper.ConvertToHtml(x.Body)))
.ReverseMap();
CreateMap<wikipagebo,wikipageentity>()
.ForMember(dest => dest.Body, (expr) => expr.MapFrom<string>(x => x.BodyMarkDown))
.ForMember(dest => dest.Slug,
(expr) => expr.MapFrom<string>(x => helper.GenerateSlug(x.Title)));
}
}
*// From unit test, code omitted for brevity*
public void EntityToDTO()
{
WikiPageEntity source = new WikiPageEntity()
{
Body = "# prova h1",
Title = "title",
Slug = "titleslug",
Version =1
};
var result = Mapper.Map<wikipagedto>(source);
Assert.Equal("title", result.Title);
Assert.Equal(1, result.Version);
Assert.Equal("<h1>prova h1</h1>", result.BodyHtml);
}
步骤 4:设置数据库迁移
另一步是整合数据库。要记住的一件重要的事情是，我们只需要测试一件事情…而数据库访问是一件复杂的事情。对数据库的第一个要求是结构。所以，检查的第一步是确保这个思想实体框架的迁移。
要执行的步骤:
- 运行
Add-Migration脚本。 - 创建一个在内存中工作的单元测试来测试它。
[Fact]
public void MigrateInMemory()
{
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseInMemoryDatabase();
using (var db = new DatabaseContext(optionsBuilder.Options))
{
db.Database.Migrate();
}
*// No error assert migration was OK*
}
步骤 5:实体积垢
在我们设置好迁移之后，我们可以假设数据结构一切正常。让我们从证明 CRUD 特性的单元测试开始。
步骤:
- 编写一个 CRUD 测试。
- 测试一下。
[Fact]
public void CrudInMemory()
{
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseInMemoryDatabase();
using (var db = new DatabaseContext(optionsBuilder.Options))
{
db.Database.Migrate();
db.WikiPages.Add(new Lib.DAL.Model.WikiPageEntity()
{
Title = "title",
Body = "#h1",
Slug = "slug"
});
db.SaveChanges();
var count=db.WikiPages.Where(x => x.Slug == "slug").Count();
Assert.Equal(1, count);
*// update, delete steps omitted for brevity*
}
}
步骤 6:测试服务
在我们的架构中，服务层将提供业务逻辑的抽象。在这个简单的例子中，我们的服务将包装插入或更新特性，在保存后返回一个 DTO。
这个单元测试的步骤:
- 用业务逻辑创建服务。
- 测试一下
[Fact]
public void TestSave()
{
var optionsBuilder = new DbContextOptionsBuilder<DatabaseContext>();
optionsBuilder.UseInMemoryDatabase();
using (var db = new DatabaseContext(optionsBuilder.Options))
{
db.Database.Migrate();
db.SaveChanges();
*//this recreate same behaviour of asp.net MVC usage*
DatabaseWikiPageService service = new DatabaseWikiPageService(db, Mapper.Instance);
service.Save(new Lib.BLL.BO.WikiPageBO()
{
BodyMarkDown="#h1",
Title="prova prova"
});
var item = service.GetPage("prova-prova");
Assert.NotNull(item);
}
}
步骤 7:在用户界面上继续
一旦使用单元测试测试 UI 变得复杂，我就从纯粹的 TDD 方法切换到一个更有弹性的测试版本，并参与到这个过程中。这有助于将所有工作分成多个步骤来完成 UI。因此，我没有编写所有代码然后测试它，而是将问题分解成多个子活动，然后逐一测试:
编辑
- 准备表单，并测试它。
- 准备模型，测试从表单提交的内容填充后端模型。
- 集成服务以保存数据，测试数据。
视图
- 准备模型，传递给视图，测试它。
- 将模型与服务集成，以获得真实数据。测试一下。
列表
- 准备视图模型，传递假数据到 UI，测试它。
- 集成服务，测试它。
每个微特征都可以快速实现并易于测试。这将促进完整的实现。
结论
TDD 是一种驱动测试支持的开发过程的方法。
这有助于在许多方面编码，但要求所有的队友都有一些基础知识。一旦完成了这一步，您将处理一个更简单的任务和许多可以重用的测试。
这个过程将有助于避免回归，并更快地达到目标，如果在开发的同时努力编写单元测试也是如此。
此外，如果您的应用程序由于复杂性而难以测试，您可以保持同样的理念执行一些手动步骤。
觉得这篇文章有用？在 Medium 上关注我(丹尼尔·丰塔尼)，看看我下面最受欢迎的文章！请👏这篇文章分享一下吧！
- Docker 到底是什么？
- 【Kubernetes 到底是什么？
- 如何使用 Kubernetes 部署 web 应用程序
资源
- 完整的 git 源代码https://github.com/zeppaman/wiki.asp.net.core
- 原文发表于 2018 年 11 月 17 日www.codeproject.com。
- 关于 TDDhttps://en.wikipedia.org/wiki/Test-driven_development维基百科告诉了什么
教一个变分自动编码器(VAE)画 MNIST 字符
These characters have not been written by a human — we taught a neural network how to do this!
要查看完整的 VAE 代码，请参考我的 github 。
自动编码器是一种神经网络，可用于学习输入数据的有效编码。给定一些输入，网络首先应用一系列变换，将输入数据映射到低维空间。网络的这一部分被称为编码器。
然后，网络使用编码数据尝试重新创建输入。网络的这部分就是解码器。使用编码器，我们可以压缩网络能够理解的数据类型。然而，自动编码器很少用于此目的，因为通常存在更有效的手工算法(如 jpg -compression)。
相反，自动编码器被反复应用于执行去噪任务。编码器接收被噪声篡改的图片，并学习如何重建原始图像。
什么是变分自动编码器？
然而，自动编码器还有更有趣的应用。
一个这样的应用叫做变分自动编码器。使用可变自动编码器，不仅可以压缩数据，还可以生成自动编码器以前见过的新对象类型。
使用一个通用的自动编码器，我们对网络产生的编码一无所知。我们可以比较不同的编码对象，但是我们不太可能理解发生了什么。这意味着我们将不能使用我们的解码器来创建新的对象。我们只是不知道输入应该是什么样子。
使用变分自动编码器，我们采取相反的方法。我们不会去猜测潜在向量的分布。我们只是告诉我们的网络我们希望这个分布看起来像什么。
通常，我们将约束网络产生具有遵循单位正态分布的条目的潜在向量。然后，当试图生成数据时，我们可以简单地从该分布中采样一些值，将它们提供给解码器，解码器将返回给我们全新的对象，这些对象看起来就像我们的网络已经被训练过的对象。
让我们看看如何使用 Python 和 Tensorflow 来实现这一点。我们将教我们的网络如何画出 MNIST 人物。
第一步—加载培训数据
首先，我们执行一些基本的导入。Tensorflow 有一个方便的功能，让我们可以轻松地访问 MNIST 数据集。
定义我们的输入和输出数据
MNIST 图像的尺寸为 28 * 28 像素，具有一个颜色通道。我们的输入X_in将是一批 MNIST 字符。网络将学习重新构建它们，并在占位符Y中输出它们，占位符具有相同的尺寸。
Y_flat将在以后计算损失时使用。keep_prob将在申请退学作为正规化手段时使用。在训练期间，它的值将为 0.8。当生成新数据时，我们不会应用 dropout，因此值将为 1。
函数lrelu正在被定义，因为 Tensorflow 不幸没有提出预定义的泄漏 ReLU。
定义编码器
因为我们的输入是图像，所以对它们应用一些卷积变换是最合理的。最值得注意的是，我们在编码器中创建了两个向量，因为编码器应该创建遵循高斯分布的对象:
- 均值向量
- 标准差的向量
稍后，您将看到我们如何“强制”编码器确保它真正创建遵循正态分布的值。将被馈送到解码器的返回值是 z 值。在计算损失时，我们将需要分布的平均值和标准差。
定义解码器
解码器不关心输入值是否是从我们定义的特定分布中采样的。它将简单地尝试重建输入图像。为此，我们使用一系列转置卷积。
现在，我们将两部分连接在一起:
计算损失并实施高斯潜在分布
为了计算图像重建损失，我们简单地使用平方差(这可能导致图像有时看起来有点模糊)。这种损失与 Kullback-Leibler 散度相结合，确保我们的潜在值将从正态分布中取样。关于这个话题的更多信息，请看看 Jaan Altosaar 关于 VAEs 的文章。
训练网络
现在，我们终于可以训练我们的 VAE 了！
每走 200 步，我们就会看一看当前的重建是什么样子。在处理了大约 2000 个批次后，大多数重建看起来是合理的。
生成新数据
最棒的部分是我们现在能够创造新的角色。为此，我们简单地从一个单位正态分布中抽取值，并将它们馈送给我们的解码器。大多数创造出来的角色看起来就像是人类写的一样。
Some of the automatically created characters.
结论
这是 VAEs 应用的一个相对简单的例子。但是想想什么是可能的！神经网络可以学习作曲。他们可以自动为书籍、游戏等制作插图。凭借一点创造力，VAEs 将为一些令人敬畏的项目开辟空间。
[## Felix mohr/使用 Python 进行深度学习
在 GitHub 上创建一个帐户，为深度学习 Python 开发做贡献。
github.com](https://github.com/FelixMohr/Deep-learning-with-Python/blob/master/VAE.ipynb)
教汽车驾驶——高速公路路径规划
Car Driving On Highway
这是 Udacity 自动驾驶汽车工程师纳米学位 第三学期的第一个项目。你可以在github上找到与这个项目相关的所有代码。你也可以阅读我以前项目的帖子:
- 项目一—项目一: 利用计算机视觉检测车道线
- 术语 1 —项目 2: 利用深度学习的交通标志分类
- 期限 1 —项目 3: 利用深度学习进行转向角度预测
- 术语 1 —项目 4: 使用计算机视觉的高级车道检测
- 术语 1 —项目 5: 利用机器学习和计算机视觉进行车辆检测
规划一条既安全又高效的路径是自主车辆开发中最困难的问题之一。事实上，这一步被称为路径规划，仍然是一个活跃的研究领域。路径规划之所以是一项如此复杂的任务，是因为它涉及到自动驾驶车辆的所有组件，从低级执行器、融合以创建世界“快照”的传感器，以及定位和预测模块，以准确了解我们在哪里，以及我们世界中的不同实体(其他车辆、人类、动物等)在接下来的几秒钟内更有可能采取什么行动。另一个显而易见的组件是轨迹生成器，它可以计算规划者要评估的候选轨迹。
在这篇文章中，我们将重点描述我们如何实现一个 C++高速公路路径规划器，它能够使用加加速度最小化技术在模拟器中生成安全有效的轨迹。该项目的制约因素如下:
- 任何时候都不与其他车辆发生碰撞
- 最高时速 50 英里(约 80 KMH)
- 最大加速度 10 米/秒
- 最大加加速度为 10 米/秒
- 车辆不能处于车道之间超过 3 秒钟
- 车辆不能出高速公路三车道
- 车辆不能在高速公路上逆向行驶
我们在完成这个项目时遇到了很多麻烦，下面的 gif 显示了我们早期的一些约束违反
Rough Start
首先，让我们仔细看看路径规划中涉及的不同层次。
自动驾驶汽车中的功能层
Layers involved in path planning — from Udacity
如前所述，路径规划需要自动驾驶汽车不同层的合作。上图概述了在给定的自动驾驶系统中，这些组件可能如何分层:
- 运动控制: 负责移动小车并尽可能接近地跟随参考轨迹。该层以最快的时间尺度运行
- 传感器融合: 负责融合传感器输出(如雷达+激光雷达)。
- 定位: 负责尽可能精确地了解我们的车辆在地图上的位置，以及其他实体(如其他汽车)相对于我们的车辆的位置
- 预测: 负责识别用传感器检测到的实体的性质(又名感知)以及基于汽车当前轨迹、其他车辆的轨迹和场景中的其他元素(如交通灯)预测场景中近期的变化。这一层的一个重要任务是预测碰撞。
- 行为: 协调层，接受来自较低层的所有信息，并决定未来状态以及要采用的轨迹
- 轨迹: 负责计算给定一组约束条件下的轨迹(如速度、距离、车道、加加速度等)。)
轨迹生成有许多方法，在这个项目中，我们选择在 Frenet 坐标系中计算轨迹。
理解传感器融合数据
模拟器中的车辆配备了一系列传感器，这些传感器的输出经过融合，可以产生更精确的测量结果。大多数从事第 4 级自动驾驶的公司都在他们的传感器套件中使用了雷达、激光雷达和摄像头。拥有多种不同类型的传感器至关重要，因为每种传感器都有各自的优势和劣势。此外，拥有同一传感器的多个实例对于减少给定传感器中的硬件故障也很重要。
在我们的例子中，模拟器从其传感器融合模块提供以下信息:
- 我们车辆的位置、速度和方向
- 传感器范围内其他车辆的位置和速度(我们可以用一点三角学计算方位——见反正切)
- 要执行的先前提交轨迹的剩余部分
有了这些信息，我们就能计算出本车与所有其他车辆的距离。我们进一步采取这许多步骤，并试图根据我们车辆的轨迹和其他车辆的推断轨迹来预测碰撞。我们在稍后定义的成本函数中利用这些信息。
轨迹生成
弗雷内坐标系
我们经常使用传统的笛卡尔坐标系来表示平面上的给定点 (x，y) ，这实际上是模拟器中用于识别道路上的汽车的默认系统。然而，在现实世界中，道路并不总是笔直的，因此人类执行的“简单”操作(如识别汽车在哪个车道上)很难用笛卡尔系统复制给计算机。下图说明了我们在传统的 (X，Y) 坐标系中面临的问题:
Curvy road in a Cartesian system (taken from Udacity lesson)
如果我们的坐标系支持道路的曲率，那么在这个新的坐标系中，我们的汽车前进并停留在车道内的轨迹将显示为一条直线，如下所示，这不是更容易吗？
Trajectories in Frenet (left) and normal Cartesian (right) coordinate systems
这正是 Frenet 坐标系所提供的:在这样一个系统中，我们将我们的平面分成纵向的轴和横向的轴，分别表示为 S 和 D. 如何获得这样一个系统背后的数学是相当复杂的，所以我们不会在本文中全部展示出来。但是你可以想象穿过道路中心的曲线决定了 S 轴，并指示我们在道路上走了多远。 D 轴映射到汽车的横向位移。下图显示了该系统在弯道上的表现:
Curvy Road Captured In Frenet Coordinates — from Udacity
冲击最小化
加加速度定义为加速度随时间的变化率。同时，加速度被定义为速度随时间的变化率。基本上加加速度和加速度分别是加速度和速度的导数。作为乘客，车辆中加速度的突然变化导致高的颠簸，最终使乘坐不舒适。因此，在规划轨迹时，最大限度地降低加加速度至关重要。
事实证明，通过扩展运动学方程来计算给定我们的当前位置 s_0、当前速度 s_0_v、和当前加速度 s_0_a. 的轨迹，对于给定的时间帧 T (例如 1 秒)、，计算一维的加加速度最小轨迹是相对容易的，我们可以表示为:
- 期望的最终位置(在时间 t ) s_f
- 期望最终速度 s_f_v
- 期望最终加速度 s_f_a
使用达到加加速度二阶导数的五次多项式(即 5 次)。关于起始值的等式如下:
Jerk Minimizing Trajectory equations — from Udacity
等于符号左侧的值是位置、速度和加速度在时间 t ≤ T 的预计值。在我们的例子中， t 被设置为控制器的更新速率，即 20 毫秒(0.02 秒)。我们可以通过设置适当的边界条件将所有这些插入多项式解算器。在我们的例子中，我们将期望的加速度设置为 0，因为我们希望降低加加速度。不幸的是，这仅设置了 t=T 的最终加速度，当T≦T 时，我们无法控制车辆的加速度。因此，我们需要试验不同的 T 值，以确定选择哪个时间范围来生成平滑的加加速度最小化轨迹。在我们的例子中，我们选择 T = 1.7 秒。另一个问题是，我们有一个完美的控制器，它可以将车辆移动到轨迹中的任何下一点，而不管物理定律如何(例如，可以在 20 毫秒内再移动 1 公里)，因此我们需要对我们提交的轨迹保持高度警惕。
由于我们使用 Frenet 坐标，我们可以分别在 s 和 d 维度中生成一维加加速度最小轨迹。Werling 和 Kammel 的这篇论文是一篇很好的阅读材料，可以让你更熟悉这个话题。
由于模拟器不接受以 Frenet 坐标表示的轨迹，我们从 Frenet 坐标转换回真实世界坐标，以计算映射到给定的 (s，d) Frenet 点的 (x，y) 点。
改进本地化
创造更平滑的轨迹
我们假设赛道已经预先绘制好，并提供有个路点，这些路点沿着中间的黄线延伸，黄线将公路两侧分开。这有助于我们根据最近的路点确定我们的位置。
不幸的是，我们得到的地图航路点非常稀疏，当我们试图从 Frenet 转换回现实世界坐标时，可能会产生非常“有角度”的轨迹。这反过来导致加速度和冲击的突然峰值。由于函数 toRealWorld (s，d)——>(x，y)使用两个路点之间的基本插值来寻找 x 和 y 的最佳近似值，我们总是冒着生成不平滑轨迹的风险。
Lane Change With Coarse Waypoints
我们能做些什么来改善这一点呢？从以前的一些项目中，我们已经看到从多项式中导出的直线趋向于产生非常平滑的轨迹。因此，我们应该采用这种技术，而不是目前使用的基本插值。我们求助于使用通过采用 Frenet 坐标中的位置 s 创建的样条来获得真实世界的坐标 x 、 y ，以及偏移量 dx 和 dy 。然后，我们插入这个公式以获得最接近的真实世界坐标
*x = spline_s_x(s) + d * spline_s_dx(s)
y = spline_s_y(s) + d * spline_s_dy(s)*
现在我们可以看到我们的轨迹变得多么的平滑。
Smooth Driving From Better Waypoints
二维状态机
思考驾驶的最直观的方式之一是，我们人类根据我们的驾驶风格、我们捕捉的外部信息以及我们心目中的目的地，将我们的车辆转换到不同的状态。事实证明，我们可以为机器编写状态，并根据当前状态和我们的自动驾驶汽车堆栈的其他层，指示它们可以移动到哪些状态。
在我们的例子中，我们的有限状态机非常简单，如下所示:
Final State Machine For Path Planning — from Udacity
最常见的状态将是保持车道，但每当我们希望改变车道时，汽车将首先转换到准备左/右变道状态，并在确保车道开关安全后，将移动到实际变道状态。我们在变换车道前进入的中间状态类似于车辆在变换车道前打开左/右信号灯(当然，司机也要确保变道是安全的)。
关于我们的状态机的实现，我们从 Frenet 坐标中得到灵感来设计这个方法。我们决定将给定的状态拆分成其纵向和横向组件。这样做的原因是，我们认为它简化了我们在可能变道的高速公路上驾驶的想法。
基本上，横向状态决定了我们可能发现的下一个潜在状态，而代价函数可能选择一个纵向状态而不是另一个。状态机的实现可以在下面的要点中找到:
成本函数
考虑到我们通常会返回多个候选的下一个状态以及它们的轨迹，我们必须找到一种方法来选择要采取的“最佳”行动。这就是成本函数有用的地方。成本函数是必要的，以“教导”车辆我们想要鼓励哪些行为，以及我们通过不同的权重对哪些行为进行较轻或较重的惩罚。
我们所有的成本函数都遵循我们在项目存储库中的文件 cost_functions.h 中定义的接口:
*typedef function<double (const Vehicle&, const vector<Vehicle>&, const Trajectory&, const State&, const double&)> CostFunction;*
这使得添加成本函数变得非常简单(权重是最后一个参数)。我们定义了以下成本函数，其中权重完全可调:
-
【speedCostFunction】:如果我们的车辆行驶缓慢，该功能将对其进行处罚
-
laneChangeCostFunction:该功能总是惩罚变道，因为变道通常比在同一车道上行驶更危险**
-
averageLaneSpeedDiffCostFunction:根据本车道前方车辆的平均速度，对车辆想要进入的车道进行处罚的功能
我们尝试了许多不同的重量配置，但最终决定，由于我们不希望在安全性上妥协，我们将碰撞时间功能的最高重量指定为 10000。其他成本函数的权重变化很大，但我们给了 speedCostFunction 很小的权重，因为高速固然很好，但远不如无碰撞重要。**
决赛成绩
当前路径规划器执行得相当好，使车辆能够围绕轨道行驶多次。然而，它可以通过更多地调整权重和改进一些成本函数来改进。此外，我们相信，通过将一些机器学习纳入我们的预测层，我们可以消除一些可能导致碰撞的边缘情况。我们的规划器的一个有趣的行为是，它能够快速多次改变车道。我们最初认为这是我们最终状态机设计的一个错误，但结果是一个有趣的副作用！**
Smooth Double Lane Change (second time because of red car ahead)
你也可以观看上传到 YouTube 的全程视频:
Video Of Full Lap In Simulator
丰富
当前的路径规划器相对保守，没有针对最高速度进行优化。这意味着虽然速度有时可以高达 48 英里/小时(~77.2 公里/小时)，但它通常会低于这个速度，几乎永远不会达到 50 英里/小时(~80.4 公里/小时)的法定速度限制。这是一个折衷方案，我们现在很乐意接受，但还需要努力让汽车以接近 50 英里/小时的速度行驶。
此外，规划者仅考虑车辆的相邻车道，因此从未“看到”非相邻车道何时会是更好的选择(例如，汽车在车道 1 上，规划者仅评估车道 1 和 2，而最右侧的车道 3 可能是自由的，因此是移动的良好候选车道)。这将需要更复杂的路径评估方法，其中规划者评估所有车道，并最终决定移动到哪个相邻车道，这是基于这样的事实，即一旦车辆到达相邻车道，与相邻车道相邻的车道将成为移动到的可行候选车道。我们对这种方法的另一个担心与安全性有关，因为执行这样一个大胆的动作更加危险和棘手，因为必须覆盖的横向距离以及预测道路上其他车辆行为的难度。
我们应该研究的另一个改进是采用统计技术来更好地预测其他车辆的行为，特别是预测他们何时并入我们的车道，因为这增加了致命碰撞的风险。我们可以从使用朴素贝叶斯开始，但没有足够的时间来专门测试，然后为我们的预测器选择最具区分性的特征。
最后，我们当前的规划器只为给定的可能的下一个状态生成单个轨迹，这意味着我们可能会忽略相同未来状态的更好的轨迹(例如，在给定车道的更远/更后面，或者更左或更右)。我们有这样的每状态多轨迹方案的实现，其假设所有最终的 Frenet 位置 s 和 d (通过计算加加速度最小轨迹获得)遵循高斯分布，对于 G(s)和 G(d)分布分别具有给定的平均值和标准偏差(mean_s，std_s)和(mean_d，std_d)。然而，我们必须为标准偏差选择适当的值，同时平均值将保持固定在最初期望的终点位置 end_s 和 end_d 。
承认
毫无疑问，这是迄今为止我作为无人驾驶汽车 nanodegree 的一部分承担的最困难的项目，涵盖所有三个项目。我不确定我能不能完成它，甚至不知道从哪里开始！
大卫·西尔弗和亚伦·布朗的小视频帮助我开始。因为我选择了加加速度最小化方法来生成轨迹，所以我没有找到太多选择这种技术的学生的博客帖子或参考资料，因为大多数文章都是关于在 David 和 Aaron 的教程中使用样条技术的。但是 Werling 和 Kammel 关于在 Frenet 框架下动态街道场景的最优轨迹生成的论文真的帮助提高了我对这项技术的直觉(尽管我并没有完全理解所有的东西)。
此外，我特别喜欢米蒂在这个项目上的文章，以及其他学生的帖子，并从中受到了启发。最后，我要感谢 Udacity 的所有团队和他们在戴姆勒的合作伙伴，是他们将如此伟大的内容和具有挑战性的项目整合在一起！
感谢你阅读这篇文章。希望你觉得有用。我现在正在建立一个新的创业公司，叫做 EnVsion ！在 EnVsion，我们正在为 UX 的研究人员和产品团队创建一个中央存储库，以从他们的用户采访视频中挖掘见解。当然我们用人工智能来做这个。).
如果你是一名 UX 研究员或产品经理，正忙于从你与用户和客户的视频通话中提取真知灼见，那么 EnVsion 就是你的选择！
使用深度学习教授汽车驾驶-转向角度预测
The car of the past… or the future?
这是 Udacity 自动驾驶汽车工程师纳米学位 第一学期的项目 3。你可以在github上找到与这个项目相关的所有代码。你也可以阅读我以前项目的帖子:
- 项目 1: 利用计算机视觉检测车道线
- 项目二: 交通标志分类使用深度学习
近年来，尤其是自从十年前 Darpa 大挑战大赛取得成功以来，全自动驾驶汽车的发展速度大大加快。许多组件组成了一辆自动驾驶汽车，其中一些最关键的组件是传感器和为其提供动力的人工智能软件。此外，随着计算能力的增加，我们现在能够训练复杂和深度的神经网络，这些网络能够学习视觉和视觉以外的关键细节，并成为汽车的大脑，了解车辆的环境并决定接下来要采取的决定。
在这篇文章中，我们将讲述如何训练深度学习模型来预测方向盘角度，并帮助虚拟汽车在模拟器中自动驾驶。该模型使用 Keras 创建，依靠 Tensorflow 作为后端。
项目设置
作为这个项目的一部分，我们提供了一个用 Unity 编写的模拟器，它有两种模式:
- 训练模式:我们手动驾驶车辆并收集数据
- 自主模式:车辆根据从收集的数据训练的模型自动驾驶
数据记录保存在 csv 文件中，包含图像路径以及方向盘角度、油门和速度。我们只关心这个项目的方向盘角度和图像。
如下图所示，模拟器包含两条轨道。右侧的赛道(赛道 2)比赛道 1 更难，因为它包含斜坡和急转弯。
The Udacity Simulator
这个项目实际上是受 NVIDIA 研究人员的论文“自动驾驶汽车的端到端学习”的启发，NVIDIA 研究人员通过训练卷积神经网络来预测方向盘角度，根据安装在汽车前面的三个摄像头(左、中、右)捕捉的转向角度数据和图像，成功让汽车自动驾驶。经过训练的模型能够仅使用中央摄像头准确驾驶汽车。下图显示了创建这种高效模型的过程。
NVIDIA process for training their CNN based on 3 cameras and steering wheel angle data
与 NVIDIA 不同，他们在现实世界中进行自动驾驶，我们将在模拟器中教会我们的汽车驾驶。然而，同样的原则也应该适用。由于最近报道了模拟在为 Waymo 等公司开发自动驾驶技术中如何发挥关键作用，我们进一步支持了这一说法。
数据集
我们最终使用了 4 个数据集:
- 轨道 1 上的 Udacity 数据集
- 轨道 1 上手动创建的数据集(我们将其命名为标准数据集)
- 另一个手动创建的数据集在赛道 1 上，我们开车接近界限，恢复以教导模型如何避免出界——在现实世界中，这将被称为鲁莽驾驶或酒后驾驶
- 轨道 2 上手动创建的数据集
请注意，在我们所有手动创建的数据集中，我们在两个方向上驱动，以帮助我们的模型一般化。
数据集探索
然而，在分析我们的数据集捕捉到的转向角度时，我们很快意识到我们有一个问题:数据非常不平衡，绝大多数方向盘数据是中性的(即 0)。这意味着，除非我们采取纠正措施，否则我们的模型将偏向直线行驶。
Distribution of steering wheel angles across datasets
然而，请注意，轨道 2 上的数据显示了更多的可变性，有许多急转弯，正如我们对这种轨道的预期。即使在这种情况下，人们仍然强烈倾向于直行。
数据集分割
最后，我们决定创建一个集合训练数据集，由 Udacity 数据集、我们的恢复数据集和来自 track 2 的数据集组成。我们决定使用来自路线 1 的标准数据集作为验证集。
frames = [recovery_csv, udacity_csv, track2_csv]
ensemble_csv = pd.concat(frames)
validation_csv = standard_csv
这帮助我们从近 55K 训练图像和潜在的 44K 验证图像开始。
数据扩充
我们有大量的数据点，但遗憾的是，大多数数据显示汽车以中性方向盘角度行驶，我们的汽车倾向于直线行驶。下面的示例显示了我们的第一个模型，其中没有对训练数据集进行平衡:
first stab at getting the car to drive autonomously…
此外，轨道上也有阴影，可能会使模型陷入混乱。该模型还需要学会正确驾驶，无论汽车是在道路的左侧还是右侧。因此，我们必须找到一种方法来人为地增加和改变我们的图像和转向角度。为此，我们求助于数据增强技术。
摄像机和转向角度校准
首先，我们将转向角校准偏移添加到由左或右摄像机捕获的图像:
- 对于左边的摄像机，我们希望汽车转向右边(正偏移)
- 对于右边的摄像机，我们希望汽车转向左边(负偏移)
st_angle_names = ["Center", "Left", "Right"]
st_angle_calibrations = [0, 0.25, -0.25]
以上值是根据经验选择的。
图像水平翻转
因为我们希望我们的汽车无论在路上的位置如何都能够自动转向，所以我们对一部分图像应用了水平翻转，并自然地反转了原始转向角度:
def fliph_image(img):
"""
Returns a horizontally flipped image
"""
return cv2.flip(img, 1)
Original vs flipped image
变暗图像
由于阴影或其他原因，我们的轨道的某些部分变得更暗，我们还通过将所有 RGB 颜色通道乘以从一个范围内随机选取的标量来使图像的一部分变暗:
def change_image_brightness_rgb(img, s_low=0.2, s_high=0.75):
"""
Changes the image brightness by multiplying all RGB values by the same scalacar in [s_low, s_high).
Returns the brightness adjusted image in RGB format.
"""
img = img.astype(np.float32)
s = np.random.uniform(s_low, s_high)
img[:,:,:] *= s
np.clip(img, 0, 255)
return img.astype(np.uint8)
Original vs darkened image
随机阴影
由于我们有时会有被阴影覆盖的轨迹，我们还必须训练我们的模型来识别它们，并且不被它们吓到。
def add_random_shadow(img, w_low=0.6, w_high=0.85):
"""
Overlays supplied image with a random shadow polygon
The weight range (i.e. darkness) of the shadow can be configured via the interval [w_low, w_high)
"""
cols, rows = (img.shape[0], img.shape[1])
top_y = np.random.random_sample() * rows
bottom_y = np.random.random_sample() * rows
bottom_y_right = bottom_y + np.random.random_sample() * (rows - bottom_y)
top_y_right = top_y + np.random.random_sample() * (rows - top_y)
if np.random.random_sample() <= 0.5:
bottom_y_right = bottom_y - np.random.random_sample() * (bottom_y)
top_y_right = top_y - np.random.random_sample() * (top_y) poly = np.asarray([[ [top_y,0], [bottom_y, cols], [bottom_y_right, cols], [top_y_right,0]]], dtype=np.int32)
mask_weight = np.random.uniform(w_low, w_high)
origin_weight = 1 - mask_weight
mask = np.copy(img).astype(np.int32)
cv2.fillPoly(mask, poly, (0, 0, 0))
#masked_image = cv2.bitwise_and(img, mask)
return cv2.addWeighted(img.astype(np.int32), origin_weight, mask, mask_weight, 0).astype(np.uint8)
Original vs shadowed image
向左/向右/向上/向下移动图像
为了应对大量的中性角，并为数据集提供更多的变化，我们对图像应用随机偏移，并为横向偏移的每个像素的转向角添加给定的偏移。在我们的例子中，我们根据经验决定对每个向左或向右移动的像素加(或减)0.0035。向上/向下移动图像应该使模型相信它是在向上/向下的斜坡上。从实验中，我们相信这些横向移动可能是让汽车正常行驶所需的最重要的增强。
# Read more about it here: http://docs.opencv.org/3.0-beta/doc/py_tutorials/py_imgproc/py_geometric_transformations/py_geometric_transformations.html
def translate_image(img, st_angle, low_x_range, high_x_range, low_y_range, high_y_range, delta_st_angle_per_px):
"""
Shifts the image right, left, up or down.
When performing a lateral shift, a delta proportional to the pixel shifts is added to the current steering angle
"""
rows, cols = (img.shape[0], img.shape[1])
translation_x = np.random.randint(low_x_range, high_x_range)
translation_y = np.random.randint(low_y_range, high_y_range)
st_angle += translation_x * delta_st_angle_per_px translation_matrix = np.float32([[1, 0, translation_x],[0, 1, translation_y]])
img = cv2.warpAffine(img, translation_matrix, (cols, rows))
return img, st_angle
Original vs shifted image
图像增强管道
我们的图像增强功能很简单:每张提供的图像都经过一系列的增强，每一次增强都以 0 到 1 之间的概率 p 发生。增强图像的所有代码都被委托给上述适当的增强器函数。
def augment_image(img, st_angle, p=1.0):
"""
Augment a given image, by applying a series of transformations, with a probability p.
The steering angle may also be modified.
Returns the tuple (augmented_image, new_steering_angle)
"""
aug_img = img
if np.random.random_sample() <= p:
aug_img = fliph_image(aug_img)
st_angle = -st_angle
if np.random.random_sample() <= p:
aug_img = change_image_brightness_rgb(aug_img)
if np.random.random_sample() <= p:
aug_img = add_random_shadow(aug_img, w_low=0.45)
if np.random.random_sample() <= p:
aug_img, st_angle = translate_image(aug_img, st_angle, -60, 61, -20, 21, 0.35/100.0)
return aug_img, st_angle
Keras 图像生成器
由于我们在训练模型时会动态生成新的和增强的图像，因此我们创建了一个 Keras 生成器来生成每批的新图像:
*def generate_images(df, target_dimensions, img_types, st_column, st_angle_calibrations, batch_size=100, shuffle=True,
data_aug_pct=0.8, aug_likelihood=0.5, st_angle_threshold=0.05, neutral_drop_pct=0.25):
"""
Generates images whose paths and steering angle are stored in the supplied dataframe object df
Returns the tuple (batch,steering_angles)
"""
# e.g. 160x320x3 for target_dimensions
batch = np.zeros((batch_size, target_dimensions[0], target_dimensions[1], target_dimensions[2]), dtype=np.float32)
steering_angles = np.zeros(batch_size)
df_len = len(df)
while True:
k = 0
while k < batch_size:
idx = np.random.randint(0, df_len) for img_t, st_calib in zip(img_types, st_angle_calibrations):
if k >= batch_size:
break
row = df.iloc[idx]
st_angle = row[st_column]
# Drop neutral-ish steering angle images with some probability
if abs(st_angle) < st_angle_threshold and np.random.random_sample() <= neutral_drop_pct :
continue
st_angle += st_calib
img_type_path = row[img_t]
img = read_img(img_type_path)
# Resize image
img, st_angle = augment_image(img, st_angle, p=aug_likelihood) if np.random.random_sample() <= data_aug_pct else (img, st_angle)
batch[k] = img
steering_angles[k] = st_angle
k += 1
yield batch, np.clip(steering_angles, -1, 1)*
请注意，我们能够在每批中减少一定比例的中性角度，并保持(即不增加)一定比例的图像。
下图显示了一批图像中的一小部分增强图像:
Some augmented images from a batch
此外，那些增强图像的转向角的伴随直方图显示了更多的平衡:
Distribution of steering angles over batch
模型
我们最初尝试了 VGG 架构的一个变体，层次更少，没有迁移学习，但努力获得令人满意的结果。最终，我们选定了 NVIDIA 白皮书中使用的架构，因为它为我们提供了最佳结果:
NVIDIA CNN Architecture
模型调整
然而，我们对模型做了一些细微的调整:
- 我们裁剪图像的顶部以排除地平线(它在立即确定转向角度时不起作用)
- 我们在模型中将图像的大小调整为 66x200 ，作为早期图层之一，以利用 GPU 的优势
- 我们在每个激活函数后应用批处理标准化以加快收敛
- 第二密集层的输出大小为 200，而不是 100
模型架构
该模型的完整架构如下:
- 输入图像为 160x320(高 x 宽格式)
- 通过移除一半高度(80 像素),图像在顶部被垂直裁剪，从而生成 80x320 的图像
- 裁剪后的图像被归一化，以确保我们的像素分布的平均值为 0
- 使用 Tensorflow 的TF . image . resize _ images将裁剪后的图像调整为 66x200**
- 我们采用一系列 3×5×5 的卷积层，步长为 2×2。每个卷积层之后都有一个批处理标准化操作，以改善收敛性。随着我们深入网络，每层的深度分别为 24、36 和 48
- 我们应用 2 个连续的 3×3 卷积层，深度为 64。每个卷积层之后紧接着是批处理标准化操作
- 我们在这一阶段拉平输入，进入完全连接阶段
- 我们应用了一系列完全连接的层，尺寸逐渐减小:1164、200、50 和 10
- 输出层的大小显然是 1，因为我们只预测一个变量，方向盘角度。
激活和正规化
除了最后一层，所有层使用的激活函数是 ReLU 。我们也尝试了 ELU ，但是用 ReLU + BatchNormalization 得到了更好的结果。我们对输出层使用均方误差激活，因为这是一个回归问题，而不是分类问题。
如前一节所述，我们使用批处理规范化来加速收敛。我们确实尝试了某种程度的辍学，但没有发现任何明显的差异。我们相信，我们在每一批生成新图像并丢弃一些中性角图像有助于减少过度拟合。此外，我们没有对我们的 NVIDIA 网络应用任何 MaxPool 操作(尽管我们尝试了 VGG 启发的操作),因为这需要对架构进行重大改变，因为我们会更早地降低维度。此外，我们没有时间尝试 L2 的正规化，但计划在未来尝试。
培训和结果
我们使用亚当作为优化器来训练模型，学习率为 0.001。经过大量的参数调整和多种模型的实验，我们最终找到了一种能够让我们的虚拟汽车在两条赛道上自动驾驶的模型。
Self-driving around track 1
我们可以看到车辆如何有效地在赛道 2 上驶下陡坡。
Self-driving around track 2
我们还展示了在赛道 2 上自动驾驶时前置摄像头看到的内容。我们可以看到汽车如何试图坚持在车道上行驶，而不是在中间行驶，因为我们自己在数据收集阶段努力只在道路的一侧行驶。这表明该模型确实学会了保持在自己的车道内。
What the car sees on track 2
录像
最重要的是，我甚至为你创建了一个视频蒙太奇，使用 Tron Legacy 的 The Grid 作为背景音乐。尽情享受吧！
Video of behavioural cloning
结论
我们已经表明，使用深度神经网络和大量的数据增强技术来创建可靠地预测车辆方向盘角度的模型是可能的。虽然我们已经取得了令人鼓舞的成果，但我们希望在未来探索以下方面:
- 在模型中考虑速度和油门
- 让汽车以 15-20 英里/小时的速度行驶
- 通过迁移学习实验基于模型的 VGG/ResNets/Inception
- 使用来自使用 Udacity 数据集的人的递归神经网络，就像这篇论文中那样
- 通过 comma.ai 阅读 学习驾驶模拟器 论文并尝试实现他们的模型
- 强化学习实验
可以看出，我们可以探索许多领域来进一步推动这个项目，并获得更有说服力的结果。从这个项目中最重要的一点是数据为王:如果没有所有这些图像和转向角度，以及它们潜在的无限扩展，我们就无法建立一个足够强大的模型。
从个人角度来看，我非常喜欢这个项目，这是迄今为止最难的项目，因为它使我能够获得更多关于超参数调整、数据扩充和数据集平衡以及其他重要概念的实践经验。我觉得我对神经网络架构的直觉也加深了。
承认
我还要感谢我的 Udacity 导师 Dylan，感谢他的支持和合理的建议，也感谢我的同学之前的 Udacity 学生，他们通过博客帖子解释了他们是如何着手这个项目的。我从阅读他们的帖子中受到启发:他们无疑帮助我更好地理解了成功完成这个项目所需的概念。
感谢你阅读这篇文章。希望你觉得有用。我现在正在建立一个新的创业公司，叫做 EnVsion ！在 EnVsion，我们正在为 UX 的研究人员和产品团队创建一个中央存储库，以从他们的用户采访视频中挖掘见解。当然我们用人工智能来做这个。).
如果你是 UX 的研究人员或产品经理，对与用户和客户的视频通话感到不知所措，那么 EnVsion 就是为你准备的！
你也可以关注我的 推特 。
教汽车看东西——使用计算机视觉进行高级车道检测
Lane With Motion Blur (from Pexels)
这是 Udacity 自动驾驶汽车工程师纳米学位 第一学期的项目 4。你可以在github上找到与这个项目相关的所有代码。你也可以阅读我以前项目的帖子:
- 项目 1: 利用计算机视觉检测车道线
- 项目二: 交通标志分类使用深度学习
- 项目三: 转向角度预测利用深度学习
识别道路上的车道是所有人类驾驶员执行的共同任务，以确保他们的车辆在行驶时处于车道限制内，从而确保交通顺畅，并将与附近车道上的其他车辆发生碰撞的可能性降至最低。同样，这也是自动驾驶汽车要完成的一项关键任务。事实证明，使用众所周知的计算机视觉技术来识别道路上的车道标志是可能的。我们将介绍如何使用各种技术来识别和绘制车道内侧，计算车道曲率，甚至估计车辆相对于车道中心的位置。
为了检测并绘制一个呈现汽车当前所在车道形状的多边形，我们构建了一个由以下步骤组成的管道:
- 从一组棋盘图像计算摄像机标定矩阵和畸变系数
- 图像失真消除
- 应用颜色和梯度阈值来聚焦车道线
- 通过透视变换生成鸟瞰图图像
- 使用滑动窗口寻找热点车道线像素
- 拟合二次多项式以识别构成车道的左线和右线
- 车道曲率和偏离车道中心的计算
- 在图像上扭曲和绘制车道边界以及车道曲率信息
我相信一张图胜过千言万语，所以在这里:
Diagram of our Lane Detection Pipeline
相机校准和图像失真消除
我们将采取的第一步是找到校准矩阵，以及用于拍摄道路照片的摄像机的失真系数。这是必要的，因为相机镜头的凸面形状使光线在进入针丨孔丨时发生弯曲，从而导致真实图像失真。因此，现实世界中的直线可能不会再出现在我们的照片上。
为了计算相机的变换矩阵和失真系数，我们使用同一台相机拍摄的一个棋盘在一个平面上的多张照片。OpenCV 有一个方便的方法叫做findchesboardcorners，它将识别黑白方块相交的点，并以这种方式逆向工程扭曲矩阵。下图显示了在样本图像上跟踪的已识别棋盘角:
9x6 corners of chessboard found
我们可以看到角点非常清晰。接下来，我们在从不同角度拍摄的多个棋盘图像上运行我们的棋盘寻找算法，以识别图像和对象点来校准相机。前者指的是我们的 2D 映射中的坐标，而后者表示这些图像点在 3D 空间中的真实坐标(对于我们的棋盘图像，z 轴或深度= 0)。这些映射使我们能够找出如何正确地消除从同一台相机拍摄的图像上的失真。你可以在下图中看到它的有效性:
original vs undistorted chessboard images
我们现在可以扭转所有图像的失真，如下图所示:
sample of original vs undistorted images
阈值处理
我们在这一部分应用颜色和边缘阈值来更好地检测线条，并使其更容易找到最好地描述我们的左右车道的多项式。
我们首先探索我们应该采用哪些颜色空间来增加我们检测车道的机会并促进梯度阈值步骤的任务。
颜色阈值
我们对不同的色彩空间进行了实验，以了解我们应该使用哪种色彩空间和通道来最有效地分离车道线:
from top to bottom: RGB, HLS, HSV, LAB color spaces split in their 3 channels
在 RGB 分量上，我们看到蓝色通道在识别黄线方面最差，而红色通道似乎给出了最好的结果。
对于 HLS 和 HSV，色调通道产生极其嘈杂的输出，而 HLS 的饱和通道似乎给出了强有力的结果；比 HSV 的饱和通道要好。相反，HSV 的值通道给出了非常清晰的灰度图像，特别是在黄线上，比 HLS 的亮度通道好得多。
最后，实验室的 A 通道表现不佳，而 B 通道擅长识别黄线。但是，在识别黄线和白线时发光的是亮度通道(没有双关的意思)。
在这个阶段，我们面临着各种有利有弊的选择。我们的目标是在给定的颜色通道上找到合适的阈值来突出车道的黄线和白线。实际上，有许多方法可以实现这一结果，但我们选择使用 HLS，因为我们已经知道如何从项目 1:简单车道检测中设置黄色和白色车道线的阈值。
下面的代码显示了我们如何对 HLS 上的白色和黄色(我们的车道颜色)进行阈值处理，并生成二进制图像:
def compute_hls_white_yellow_binary(rgb_img):
"""
Returns a binary thresholded image produced retaining only white and yellow elements on the picture
The provided image should be in RGB format
"""
hls_img = to_hls(rgb_img)
# Compute a binary thresholded image where yellow is isolated from HLS components
img_hls_yellow_bin = np.zeros_like(hls_img[:,:,0])
img_hls_yellow_bin[((hls_img[:,:,0] >= 15) & (hls_img[:,:,0] <= 35))
& ((hls_img[:,:,1] >= 30) & (hls_img[:,:,1] <= 204))
& ((hls_img[:,:,2] >= 115) & (hls_img[:,:,2] <= 255))
] = 1
# Compute a binary thresholded image where white is isolated from HLS components
img_hls_white_bin = np.zeros_like(hls_img[:,:,0])
img_hls_white_bin[((hls_img[:,:,0] >= 0) & (hls_img[:,:,0] <= 255))
& ((hls_img[:,:,1] >= 200) & (hls_img[:,:,1] <= 255))
& ((hls_img[:,:,2] >= 0) & (hls_img[:,:,2] <= 255))
] = 1
# Now combine both
img_hls_white_yellow_bin = np.zeros_like(hls_img[:,:,0])
img_hls_white_yellow_bin[(img_hls_yellow_bin == 1) | (img_hls_white_bin == 1)] = 1
return img_hls_white_yellow_bin
结果如下所示:
undistorted vs HLS binary color image (filtering for yellow and white)
正如你在上面看到的，我们的 HLS 颜色阈值在图像上取得了很好的效果。阈值处理与前面黄线上的树的阴影有点冲突。我们认为梯度阈值在这种情况下会有所帮助。
梯度阈值
我们使用 Sobel 算子来识别梯度，即图像中颜色强度的变化。较高的值表示强烈的梯度，因此颜色变化剧烈。
我们决定使用实验室的 L 通道作为单通道图像，作为以下 sobel 函数的输入。
我们试验了许多参数和不同的 Sobel 操作(所有这些都可以在这个 Jupyter 笔记本上看到)，得出了这个最终结果:
Results of multiple sobel operations
我们从底部选择第二个图像作为我们的最佳结果。请注意，在我们选择的图像上，我们应用了 15x15 像素的内核，从而有效地平滑了像素，产生了更清晰的二进制图像。
结合两者
我们自然地将彩色和 Sobel 阈值化的二值图像结合起来，并得到以下结果:
combined color and gradient thresholded images in (R)GB and binary formats
在左边的图像中，所有的绿色像素被我们的 Sobel 阈值化保留，而蓝色像素被我们的 HLS 颜色阈值化识别。结果非常令人鼓舞，似乎我们已经找到了正确的参数，以稳健的方式检测车道。接下来，我们对我们的图像进行透视变换，并生成车道的鸟瞰图。
透视变换
我们现在需要在 2D 图像中定义一个梯形区域，该区域将通过透视变换转换为鸟瞰图，如下所示:
trapezoid of lane on road
然后，我们定义 4 个额外的点，它们形成一个矩形，映射到我们的源梯形中的像素:
dst_pts = np.array([[200, bottom_px], [200, 0], [1000, 0], [1000, bottom_px]], np.float32)
透视变换产生以下类型的图像:
bird’s eye view on both straight and curved lanes
把所有的放在一起
我们可以看到，我们的透视变换保持直线笔直，这是一个必需的健全性检查。然而，曲线在上面的例子中并不完美，但是它们也不会给我们的算法带来无法克服的问题。
现在，我们可以将阈值处理应用于鸟瞰图图像:
test images with perspective transform, color and gradient thresholds applied
柱状图
然后，我们在图像的下半部分计算 y 方向上的二进制阈值图像的直方图，以识别像素强度最高的 x 位置:
Left: birds eye view binary representation of lane. Right: histogram of pixel intensities of the image
寻找线条并绘制车道区域
推拉窗
因为我们现在知道了最有可能产生车道线的像素的起始 x 位置(从图像的底部开始)，我们运行了一个滑动窗口搜索，试图“捕获”我们车道线的像素坐标。
从那时起，我们通过 numpy 的 polyfit 简单地计算一个二次多项式，找到最适合左右车道线的曲线系数。
我们改进算法的一种方法是保存先前为帧 t-1 计算的系数，并尝试从这些系数中找到我们的车道像素。然而，当我们没有找到足够的车道线像素(少于总非零像素的 85%)时，我们恢复到滑动窗口搜索，以帮助提高我们在车道周围拟合更好曲线的机会。
车道曲率
我们还通过计算与车道线相切的最小圆的半径来计算车道曲率，在直线车道上，半径会很大。我们必须通过定义适当的像素高度与车道长度以及像素宽度与车道宽度的比率，将像素空间转换为米(也称为真实世界单位):
# Height ratio: 32 meters / 720 px
self.ym_per_px = self.real_world_lane_size_meters[0] / self.img_dimensions[0]# Width ratio: 3.7 meters / 800 px
self.xm_per_px = self.real_world_lane_size_meters[1] / self.lane_width_px
我试图通过参考来自这个资源的数据，在我的鸟瞰图像上手动估计道路的长度:每次汽车行驶都超过 40 英尺(约 12.2 米)。在我的样本图像上，鸟瞰图似乎覆盖了大约 32 米。宽度保持在 3.7 米，符合美国高速公路标准。你可以通过下面的链接找到更多关于曲率半径的数学基础的信息。
我们还通过偏移车道左右线的起始(即底部)坐标的平均值，减去中点作为偏移量，并乘以车道的像素与真实世界宽度的比率，来计算汽车与车道中心的距离。
取消绘制车道区域
最后，我们用绿色绘制车道的内侧，并取消扭曲图像，从而从鸟瞰图移动到原始的未失真图像。此外，我们用我们的车道检测算法的小图像覆盖这个大图像，以便一帧一帧地更好地感受正在发生的事情。我们还添加了关于车道曲率和车辆中心位置的文本信息:
Sample result of the output of detected lanes
决赛成绩
下面的 gif 显示了我们为项目视频构建了一个强大的车道检测管道:
Lane detection gif
此外，我在 Youtube 上上传了一个视频，我在项目视频上画了车道，并添加了额外的信息，如车道曲率近似值。背景音乐是弗林的儿子(显然来自Tron:Legacy😎).尽情享受吧！
Video of lanes detected on project video
结论
这是一个令人兴奋但困难的项目，感觉与我们之前的两个深度学习项目非常不同。我们已经介绍了如何执行相机校准、颜色和梯度阈值，以及透视变换和滑动窗口来识别车道线！滑动窗口代码最初特别难理解，但是经过长时间的调试和评论(都在我的笔记本上)，我终于理解了每一行！
我们认为该项目可以进行许多改进，例如:
- 尝试 LAB 和 YUV 色彩空间，以确定我们是否可以产生更好的色彩阈值
- 使用卷积而不是滑动窗口来识别热点像素
- 产生先前帧的行系数的指数移动平均值，并在我们的像素检测失败时使用它
- 更好地检测“捕获”的像素中的异常(例如，一些完全离线的非零像素)并剔除它们
- 应用本项目未涵盖的其他相关计算机视觉技术
此外，我们需要建立一个更强大的渠道来成功完成这个项目中的两个挑战视频。
像往常一样，我要感谢我的导师迪伦的建议和支持，以及我在 Udacity 的同事，以前和现在的同事，他们整理了很多优秀的文章，激励了我。
感谢你阅读这篇文章。希望你觉得有用。我现在正在创建一个名为env sion的新公司！在 EnVsion，我们正在为 UX 的研究人员和产品团队创建一个中央存储库，以从他们的用户采访视频中挖掘见解。当然我们用人工智能来做这个。).**
如果你是一名 UX 的研究人员或产品经理，对与用户和客户的视频通话感到不知所措，那么 EnVsion 就是为你准备的！
你也可以关注我的 推特 。
教汽车看东西——使用机器学习和计算机视觉进行车辆检测
这是 Udacity 自动驾驶汽车工程师纳米学位 第一学期的期末项目。你可以在github上找到与这个项目相关的所有代码。你也可以阅读我以前项目的帖子:
- 项目 1: 利用计算机视觉检测车道线
- 项目二: 交通标志分类使用深度学习
- 项目三: 转向角度预测利用深度学习
- 项目 4: 利用计算机视觉进行高级车道检测
当我们开车时，我们不断关注我们的环境，因为这关系到我们和其他许多人的安全。我们特别注意潜在障碍物的位置，无论是其他汽车、行人还是路上的物体。同样，随着我们开发为自动驾驶汽车提供动力所必需的智能和传感器，这种汽车也能检测障碍物是至关重要的，因为这可以加强汽车对环境的理解。最重要的一种 ostacles 是检测道路上的其他车辆，因为它们很可能是我们车道或邻近车道上最大的物体，因此构成了潜在的危险。
从传统的计算机视觉技术到深度学习技术，在整个文献中已经开发了许多障碍检测技术。在本练习中，我们通过采用一种称为梯度方向直方图(HOG) 的传统计算机视觉技术，结合一种称为支持向量机(SVM) 的机器学习算法，来构建一个车辆检测器。
资料组
Udacity 慷慨地提供了一个具有以下特征的平衡数据集:
- 约 9K 的车辆图像
- 非车辆的~ 9K 图像
- 所有图像都是 64x64
数据集来自 GTI 车辆图像数据库、 KITTI Vision 基准套件，以及从项目视频本身提取的例子。后者要大得多，没有用于这个项目。然而，这在未来将是一个很好的补充，特别是当我们计划使用深度学习建立一个分类器时。您可以从下面的数据集中看到一个图像示例:
Sample of vehicles and non-vehicles from dataset
我们可以清楚地看到车辆和非车辆图像。非车辆图像往往是道路的其他元素，如沥青、路标或路面。区别非常明显。大多数图像也将车辆显示在中央，但方向不同，这很好。此外，还有各种各样的汽车类型和颜色，以及照明条件。
探索特性
方向梯度直方图(HOG)
Navneet Dalal 和 Bill Triggs 在他们的论文《人类检测的方向梯度直方图中展示了令人印象深刻的结果后，使用 HOG 进行检测受到了欢迎。Satya Mallick 在这篇文章中很好地解释了这个算法，对于那些想要更好地掌握 HOG 的人来说。
我们首先在 RGB 图像上探索了 HOG 算法中以下值的不同配置:
- 方位数量(用 o 表示)
- 每个单元格的像素(用 px/c 表示)
每个块的单元最初固定为 2(用 c/bk 表示)。下图显示了在 RGB 格式的样本车辆图像上获得的结果:
Results of different configurations for HOG
从纯粹的观察来看，它看起来像一个猪配置:
- 11 个方向
- 每个单元格 14 个像素
- 每个区块 2 个单元
产生车辆最独特的坡度。我们还没有对每个模块的不同单元进行实验，所以现在让我们来尝试一下。
HOG results with different cells per block
对于人眼来说，我们在视觉上没有注意到明显的差异。理想情况下，我们希望减少特征空间以加快计算速度。我们现在决定每块 3 个细胞。
色彩空间
我们现在必须为我们的配置探索最合适的颜色空间，因为看起来我们在 3 个 RGB 通道上的 HOG 特征太相似了，因此感觉我们没有生成具有足够变化的特征。
我们在众多色彩空间中生成以下输出:
HOG image across all channels in different color spaces
对于某些颜色通道，很难解释 HOG 的结果。有趣的是，YUV、YCrCb 和 LAB 中的第一个颜色通道似乎足以捕捉我们正在寻找的渐变。在 HSV 和 HLS 中，HOG 分别在值和亮度通道上捕捉车辆的最重要特征。
为了证实我们的假设，让我们尝试一个不同的车辆图像:
Same HOG settings but on a different image
休斯顿，我们这里有一个问题 …在如上图这样的暗图像上，我们可以观察到携带最多光信息的信道上的 HOG 产生了不好的结果。因此，我们必须考虑所有的颜色通道，以捕捉最多的特征。最后，我们的配置如下:
- ycr CB 色彩空间的所有通道
- 11的拱起方向
- 每 14 个单元的 HOG 像素
- 每块猪细胞 2 个
我们还将添加颜色信息来增强我们的功能集。为此，我们只需使用 32 个箱生成所有颜色通道的直方图，如下所示:
def color_histogram(img, nbins=32, bins_range=(0, 256)):
"""
Returns the histograms of the color image across all channels, as a concatenanted feature vector
"""
# Compute the histogram of the color channels separately
channel1_hist = np.histogram(img[:,:,0], bins=nbins, range=bins_range)
channel2_hist = np.histogram(img[:,:,1], bins=nbins, range=bins_range)
channel3_hist = np.histogram(img[:,:,2], bins=nbins, range=bins_range) # Concatenate the histograms into a single feature vector and return it
return np.concatenate((channel1_hist[0], channel2_hist[0], channel3_hist[0]))
分类者
分类器负责将我们提交的图像分为车辆或非车辆类别。为此，我们必须采取以下步骤:
- 从数据集中加载我们的图像
- 提取我们想要的特征
- 使这些特征正常化
- 分割用于训练和测试的数据集
- 使用适当的参数构建分类器
- 在训练数据上训练分类器
正如上一节所讨论的，我们决定只保留一个特征:在 YCrCb 图像的 Y 通道上计算的 HOG 特征向量。
我们随机分割数据集，留下 20%用于测试。此外，我们通过使用一个sk learn . preprocessing . standard scalernormalizer 来缩放数据。
我们没有足够的时间对许多分类器进行实验，所以选择使用支持向量机 (SVMs)，因为它们通常与 HOG 结合用于对象检测问题。此外，我们使用了带有内核的 SVC，因为它提供了最好的精度，但是比线性 SVC 慢。我们接受了这种折衷，因为当我们在一系列图像上测试时，使用 rbf 核的 SVC 的检测更强。
使用 GridSearchCV 函数获得了核类型(线性或 rbf )、 C ( 1，100，1000，1000 )和伽马 ( 自动，0.01，0.1，1 )中的理想参数。最佳配置实现了超过 99%的准确度，并具有以下参数:
- 内核 = rbf
- C = 100
- 伽玛 =自动
推拉窗
我们创建了多个维度的滑动窗口，范围从 64x64 到 256x256 像素，以针对分类器测试图像的部分，并仅保留正面预测。我们通常从屏幕底部滑动较大的窗口，因为这将对应于车辆出现最大的位置。较小的窗口会在屏幕上滑得更高。此外，我们能够配置小区重叠，并且当前已经将它设置为 1 以获得最大覆盖(即，每 14 像素*比例重叠，其中比例 1 的最小窗口是 64x64)。我们停止尝试检测 y 方向上任何低于 350 像素的车辆(即屏幕上图像的较高部分)。下图显示了单元格重叠设置为 4 的重叠滑动窗口示例:
Sliding windows of different sizes with cell overlap = 4
热图和阈值
分类器有时会误分类图像中实际上不是车辆的部分。为了避免突出显示视频中的车辆，我们利用我们通过多尺寸滑动窗口创建的冗余，并计算我们的分类器在图像的给定部分的所有窗口中预测车辆的次数。我们首先使用scipy . ndimage . measurements'label函数来标记具有重叠窗口的对象。然后，我们通过确定我们检测到的对象能够适合的最小边界框来提取每个标签的位置。我们只保留图像中检测到的阈值被设置为特定值的部分。通过实验，我们发现阈值 4 足以在项目视频上获得稳定的结果。下图说明了热图和阈值处理的工作原理:
Detected vehicles with heatmaps and thresholding
第一个迷你热图代表来自分类器的原始原始检测，而第二个显示阈值区域，其中红色的强度随着重叠窗口数量的增加而增加。右边最后一个小图像显示了我们的分类器预测到车辆的所有窗口。在这个例子中，我们实际上使用了线性 SVC ，它比 rbf SVC 更容易预测错误。
帧聚合
为了进一步加强我们的管道，我们决定每隔 n 帧平滑所有检测到的窗口。为此，我们累积帧( n-1)f+1* 到 nf* 之间的所有检测到的窗口，其中 n 是表示我们所在的帧的组的正标量。我们已经创建了以下封装检测到的对象的类:
class DetectedObject:
"""
The DetectedObject class encapsulates information about an object identified by our detector
"""
def __init__(self, bounding_box, img_patch, frame_nb):
self.bounding_box = bounding_box
self.img_patch = img_patch
self.frame_nb = frame_nb
self.centroid = (int((bounding_box[0][0] + bounding_box[1][0]) / 2), int((bounding_box[0][1] + bounding_box[1][1]) / 2))
self.similar_objects = []
...
每当我们在组中的当前帧或下一帧上检测到新的对象时，我们检查我们过去是否检测到类似的对象，如果是，我们附加类似的对象，从而增加该对象在多个帧上的计数。在帧 nf* 处，我们仅保留具有超过 m 个检测计数的检测到的对象(及其相关联的边界框)，从而在流水线中实现某种类型的双重过滤(第一次过滤是关于重叠边界框的数量的阈值)。
在下面的 gif 上，你可以看到当我们有一个单一的边界框覆盖两辆汽车时和当每辆汽车都有自己的边界框时之间有一瞬间:帧聚合逻辑必须等到两个窗口出现足够的次数后才显示它们:
gif of vehicle detection with frame sampling
决赛成绩
下面的视频链接显示了对车辆的成功检测。由于这是第一学期的最后一个项目，我刚刚让使用 Tron Legacy 的 OST 的音轨片尾标题作为背景音乐——没有什么比这更合适的了😎。像往常一样享受吧！
Video montage of vehicle detection
丰富
这是一个棘手的项目，特别是对于那些选择更传统的计算机视觉和机器学习方法而不是深度学习的人来说。以下步骤相当耗时:
- 确定最合适的特征(HOG、图像颜色直方图等)
- 探索 HOG 参数+色彩空间的组合
- 应用网格搜索寻找最合适的分类器
此外，在我们的渠道中，我们还面临以下问题:
- 确定滑动窗口和重叠的正确位置
- 为重叠检测识别合适的阈值
- 采用合适的帧采样率
- 在多个帧中找到足够好的最小检测计数
- 聚集重叠检测的组合窗口维度
对于不是车辆但被分类器检测到的对象，流水线将失败，并且在足够多的重叠窗口上出现这种错误检测以突破所配置的阈值，并且在每组的最小数量的帧上始终如此。绘制的边界框并不总是完全适合车辆，并且每隔 n 帧重画一次，因此造成缺乏平滑度的印象。此外，与每 n 个帧进行批量聚合相反，可以通过使用 n 个帧的滚动窗口来改进帧聚合。
最后一个问题是我们的流水线太慢。我们不应该在整个屏幕上滑动窗口，只需要查看屏幕的一部分:例如，将来我们可以使用决策树来识别感兴趣的区域。我们还可以考虑减少滑动窗口的数量，以及采用像 LinearSVC 这样的更快的分类器来加速检测(但准确性也会显著下降)。尽管如此，这种车辆检测管道不太可能实时工作。
在未来，将采用深度学习方法，例如使用更快的 R-CNN 或 YOLO 架构，因为这些架构现在是检测问题的最先进技术，并且可以实时运行。然而，这是一个有价值的练习，可以更好地理解传统的机器学习技术，并在特征选择上建立直觉。此外，像 HOG 这样的技术的美丽和简单给我留下了深刻的印象，它仍然能够产生可靠的结果。
感谢
我要再次感谢我的导师迪伦，感谢他在这一学期对我的支持和建议。我也非常感谢 Udacity 设立了这样一个令人兴奋和具有挑战性的纳米学位，有着伟大的项目和优秀的材料。
我们站在巨人的肩膀上，因此我感谢人工智能、计算机视觉等领域的所有研究人员和爱好者，感谢他们通过论文和代码所做的工作和分享。没有这些资源，我就无法“借用”他们的想法和技术，并成功完成这个项目。
第一学期已经结束了🎉🎉。我将于 2018 年 1 月开始第二学期，与此同时，我将致力于深化我刚刚起步的人工智能技能，并恢复兼职项目的工作。感谢阅读，敬请关注！
感谢你阅读这篇文章。希望你觉得有用。我现在正在建立一个新的创业公司，叫做 EnVsion ！在 EnVsion，我们正在为 UX 的研究人员和产品团队创建一个中央存储库，以从他们的用户采访视频中挖掘见解。当然我们用人工智能来做这个。).
如果你是一名 UX 研究员或产品经理，对与用户和客户的视频通话感到不知所措，那么 EnVsion 就是为你准备的！
你也可以关注我的 推特 。
在大会上讲授数据科学:第 1 周
本周，我开始向学生传授将他们转变为数据科学家的技能和技术，这些数据科学家是初创公司和大公司的宝贵团队成员，正在从根本上改变世界对数据的看法。
在旧金山，General Assembly (GA)将于 2017 年 1 月 30 日开始他们的第五期 数据科学沉浸式 课程。我将成为两位数据科学讲师之一，将我们的专业知识和行业经验带入课堂和课程。
我的行业经验包括为 Wine.com 和 NASA 构建可扩展的数据产品。对于 Wine.com，我使用 Spark 的机器学习库构建了一个推荐系统。这个系统根据每个用户对葡萄酒的喜好为他们提供个性化的推荐。在山景城的 NASA 中心，我为地理空间图像建立了一个可扩展的特征提取 ETL 管道。这个项目在他们内部的超级计算机昴宿星上运行。
这些项目和其他项目可以在我的 GitHub 欢迎页面找到。
我们的学生是工作专业人士，他们渴望改变和新的挑战，并强烈希望利用数据科学工具包来改善企业和人们的生活。他们的学术背景从数学、工程到商业都有。他们每个人都带来了独特的优势、工作经验和观点，这将交叉授粉的想法，并导致丰富的学习环境。
我的一些学生的个人兴趣包括萨尔萨和摇摆舞，以及交叉健身和踢拳。我的生活方式还包括各种形式的体育锻炼，比如跳探戈和奥运会举重。我几乎还不了解我的学生，但我们已经建立了关系，这将使接下来的 3 个月对每个人来说都是有趣而难忘的经历。
An inclusive culture for an inclusive community.
GA 不仅投资于学生的成果，也投资于教师。我对教师在培训和反馈方面获得的支持程度印象深刻。GA 培养主动学习和成长的教育思维方式，这种方式将继续为学生和教师带来成功的结果。
通过整合数据科学家的行业经验，GA 确保学生尽可能接受最新和行业相关的培训。在过去的两周，我一直在通过 GA 的讲师培训电路(ITC)工作，并帮助建立该课程的数据科学课程。
在那段时间里，我开始了解 GA 的学生——不仅仅是通过 DSI 项目，还有其他项目。当学生从事他们的项目，创造数据驱动的产品和解决方案时，有一种明显的兴奋感、协作和创新思维。
如果您对 GA 的 DSI 计划或我在数据科学领域的工作有任何疑问，请随时联系我。
此外，我们正在寻找客座演讲人走进教室，与学生分享他们所学的数据科学技能和技术如何解决现实世界的问题。如果你感兴趣，请告诉我！
在大会上讲授数据科学:第 4 周
砂砾。这就是我如何在每个工作日的早上 5:30 醒来，走进举重房，摇着水壶的铃铛，看着奥林匹克解除我眼中的睡意。
勇气是在为期 12 周的课程中学习数据科学基础知识所需要的，我的学生很快就发现了这一点。
第 2–3 周
我和我的教学团队教授了计算机科学、线性代数、统计学、概率等几门大学课程，并在两周半的时间里将它们的核心概念提炼出来。日复一日地频繁转移话题会让学生们有点迷失方向——如果你愿意的话，可以说是教育上的鞭打。当学生学习提到的低水平基础知识时，可能会有点迷失方向，因为他们正在学习看似孤立的技能和技术。对于他们来说，在课程中看到并应用这些技能和技术，利用机器学习和大数据综合创建令人惊叹的数据产品并优化业务运营还为时过早。
耐心点，年轻的杰迪们，基于系统的解决方案将会及时出现，因为现在你们将在光剑训练期间被盲目折叠，同时躲避盘旋在机器人周围的冲击波。
Those Web Development kids and their graffiti (shakes fist furiously in air).
第四周
第 4 周和第 3 周的末尾向学生介绍了机器学习的奇妙世界。是的，ML，计算机科学中的一个令人敬畏的领域，让你告诉你的朋友，你在与人工智能打交道——尽管是人工智能的一个狭窄子集。对于那些在斯坦福大学或加州大学伯克利分校等传统大学上过机器学习入门课程的人，或者在 GA 等训练营学习过 ML 的人，你会知道 ML 的教学首先是介绍线性回归和逻辑回归。你在传统大学通常得不到的是一个小班，有多名教师，致力于通过个性化的关注和定期的反馈来帮助学生取得成功。
我就是从那里进来的！是的，我很高兴通过机器学习及其所有许多方面来指导 GA 的下一批行业就绪数据科学家。下周—推进机器学习！
行业发言人
教学团队和我接触行业数据科学家，目的是让他们向学生介绍他们的工作。在第 3 周，我们有一位前 GA 学生讲述了他如何使用机器学习和 cleaver 合并开源数据集为他的太阳能公司节省了数万美元。
下周，MyFitnessPal 的一位数据科学家将讲述他围绕用户行为的 A/B 测试所做的工作。这些讲座帮助学生弥合他们在课堂上学到的知识与如何利用这些技能和技术解决现实世界的问题并为他们未来的创业创造巨大影响之间的差距。
我向我的学生脱帽致敬，他们不仅挺过了课程的难关，还迅速提高了技能和信心。看到他们在短短 4 周内取得如此大的进步，真是令人惊讶。行业就绪型数据科学家即将到来！
关于作者
Alexander 毕业于加州大学伯克利分校，获得物理学学士学位，毕业于 T2 大学，获得数据科学硕士学位。他热衷于应用数据科学来解决医疗保健、清洁能源和环境领域的挑战性问题。
在大会上讲授数据科学:第 5 周
A healthy mind is complemented by a healthy body.
本周，学生们开始思考他们想要为他们的顶点项目构建什么样的数据产品。GA 还为社区举办了一次晚宴，并邀请难民参加。这提醒了我为什么要成为一名数据科学家。
难民晚餐
We are a community of problem solvers and innovators with a vision for social progress. We are the counter-culture to our county’s current shift toward isolationism.
GA 为学生、教师和难民举办了一次内部晚宴。我遇到了几个有着惊人故事的人。战前，逃离叙利亚美好生活的人们。人们从一个国家跳到另一个国家——中东、亚洲、欧洲——寻求庇护，却遭到拒绝。二十多岁的年轻男女，要养家糊口的老男人——像你我这样的人。他们勇敢地在一个宣扬包容但实际上需要家庭工作经验的行业找工作。这提醒了我，出生在加利福尼亚的美国人是多么幸运。这也提醒了我为什么决定成为一名数据科学家。
2014 年春天从加州大学伯克利分校毕业后不久，我了解了数据科学和机器学习。ML 和大数据是所有技术创新背后的生命血液——这是行动所在，也是我关注的焦点。我读到了关于网飞的推荐系统、优步的优化司机服务以及其他令人难以置信的数据驱动产品的故事，这些产品让人类的生活变得更加便利。尽管数据科学的技术和技能满足了我的求知欲，但这个角色似乎没有多少人情味。 我看到的大多是对数据科学作为另一种企业工具的颂扬。我认为数据科学可能不适合我。
气候变化给人类带来了生存威胁。30 年前的今天，也就是昨天，我们需要转向清洁、可持续的能源。数据科学与太阳能等替代能源相结合，向世界展示了切断石油供应的市场化解决方案。正是教育、清洁能源、医疗保健以及建设一个环境可持续发展的社会方面的挑战，激励着我去解决难题。正是解决这些难题促使我成为一名数据科学家。
我不需要成为逃离人间地狱的难民，也能体会到我出生在这片叫做加利福尼亚的土地上是多么幸运。但与他们交谈提醒我，伴随着巨大的特权而来的是巨大的责任。
顶点项目
我的学生多种多样，他们的专业兴趣也是如此。他们对构建用于教育、清洁能源、招聘、金融等领域的智能工具感兴趣。
一名学生希望围绕分解能耗读数并确定哪些家用电器正在使用能源及其数量的想法开发一款产品。通过自动化这一过程，该工具可以识别各个来源的能源使用和浪费。这将帮助家庭、工厂和企业通过简单地将机器学习智能注入他们的能源网格来节省大量的资金。
另一个学生想为在线教育开发工具。在线课程已经大规模兴起，他希望帮助捕捉有助于学习成果和改善学习体验的趋势和隐藏模式。像这样的工具将有助于获得更多的在线学习者，降低辍学率，增加用户保留率。
这是一个为期 12 周的课程，我们现在才进行到第 5 周。学生们仍在集思广益，研究想法。观察这些想法如何演变并具体化为数据产品将是一件有趣的事情。
Meanwhile at the water cooler — an inspiration and reminder of what can be achieved with grit, vision, and a sense of purpose.
关于作者
Alexander 毕业于加州大学伯克利分校，获得物理学学士学位，毕业于大学，获得数据科学硕士学位。他目前是 General Assembly 的数据科学讲师。他热衷于应用数据科学来解决医疗保健、清洁能源和环境领域的挑战性问题。
教学数据科学坏了
我们教授数据科学的方式被打破了。事实上，即使是这句话也让我觉得很慷慨。在大多数情况下，我不确定我们是否尝试过。
我说的数据科学这个术语并没有什么过于浮夸的意思。在这种情况下，我使用“数据科学”来表示获取大量数据(超过 excel 可以轻松打开的数量)、创建图表、生成摘要，以及对数据所要表达的内容得出某种有意义的结论的能力。
在我看来，人们在学习数据科学时大致分为两种情况。一，应该懂数据科学而不懂的人。二是想学习数据科学但不知道如何学习的人。
案例一:应该了解数据科学的人
我应该懂数据科学。我在威斯康星主修统计学。但是我离开时对 R 几乎一无所知，尽管我学了很多应用课程。在很大程度上，我的应用课程包括解释其他人从统计程序中得出的结果。教授会给我们看一个截图，圈一个数字，我们必须告诉他，这是解释的方差百分比或类似的东西。
有时我们会使用 R，但我们会使用别人写的代码，最多改变几个数字或变量名。或者我们会在一堂课上看着教授输入 R。但是从来没有人让我坐下来解释什么是向量，如何写一个循环，或者如何使用 lapply 来代替循环。
很容易得出这样的结论:我接受了统计学教育，但没有学习某个特定的软件，所以现在我要做的就是自学 R，我会很好。但我觉得没那么简单。前几天我实现了一个算法。为了独立完成这个任务，我必须知道如何将数据读入 R，以一种有用的方式格式化它，将它汇总到一个表中，实现并使用文档来确切地知道我得到了什么输出。
弄清楚如何完成这项深刻而复杂的任务需要建立如此多的联系，以至于很难将解释输出截图这一反事实的任务描述为学习。
当我们教授统计学而没有以有意义的方式教授数据科学时，我们错过了一个机会。如果我们同时教授这两个科目，所有的统计概念和数据科学工具将以一种允许学生认真学习的方式连接起来。他们可以获得细致入微的理解，这将转化为独立工作的最终目标。此外，利用数据科学解决统计问题的能力在就业市场上很有价值。
我有时认为学生应该在六年级开始学习统计学之前学习 R(或者 Python 或者任何你想学的语言)。对于这个建议，我大多都有疯狂的想法，但我真的相信它。那么他们的统计学教育就可以建立在教授均值的基础上？向学生展示如何模拟数字向量。问他们如何总结这些数字。温和地教导他们中庸的直觉。或者给他们反复展示不同 x 的平均值。他们能解决这个难题吗？我们为什么要采取中庸之道？我们能不能模拟一堆不同的 x 向量，看看均值是怎么变化的？
想象一下，通过这种教育，学生将对统计学和数据科学有多么深刻的理解。
案例二:想学数据科学的人
我正在教授 Stata 入门课程，所以我一直收到想学习数据科学但不知道如何学习的人的电子邮件。例如，他们可能主修生物学，现在在一家医院担任研究员，并希望在未来申请计算生物学研究生课程。
第一个障碍是弄清楚学什么。他们应该学 R 还是 Python 还是 Stata 还是 SPSS？还不清楚。不同的人会有不同的答案。对于那些忙碌而不积极的人来说，他们需要学习数据科学，他们的旅程可能会在这里结束。
即使有人确切地知道他们想学什么，也没有很好的资源。有些人会推荐一两本书，这不是一个可怕的想法，但不可避免的是，典型的学生将会在知识上达到一些他们无法逾越的小差距。由于没有人寻求帮助，他们会无意中发现 stackoverflow，这将使它看起来不可思议的复杂，他们会在一段时间内停止转动，变得沮丧。在某个时候，他们脑海中的那个小小的声音会说“你不适合这个…”然后他们会告诉自己，他们真的不需要学习数据科学，因为如果他们知道生物学，他们总是可以与其他知道数据科学的人一起工作。这很可悲，因为事情本不应该是这样的。
也没有很棒的建议。很多人会建议学生通过尝试一个项目来学习。我觉得有点空虚。如果你什么都不知道，开始一个项目是一项不可能的艰巨任务。我很理解这个建议的来源——教育者知道学习需要学生在过程中积极主动，而项目是积极主动的最好方式。
问题是，学习实际上归结为学生既需要积极主动，又需要充分的指导。大多数解决方案都在这些方向上犯了错误。告诉一个新手开始一个项目，这是不够的。在一个大学课堂上，你看到有人在输入代码，但却不够活跃。找到完美的平衡非常困难。我无法想象世界上有多少地方能做到平衡。上个季度，我有幸参加了斯坦福大学的数据挑战实验室，它每个季度都在迭代，变得越来越好。比尔·贝尔曼带头冲锋，哈雷·威克姆远程协助教学。这些课程是令人难以置信的学习环境，但不幸的是，它们少之又少。
我现在看到了这个问题:在斯坦福大学，到处都有研究生在努力拼凑自己的数据科学教育。我不知道该怎么办。作为开始，我在上个季度写了一篇关于研究生数据科学教育问题的粗略的单页文章。下面我就分享一下。
我也觉得学生只是需要入门。大部分资源走得太深，太快，很难上手。Youtube 可能是一个强大的工具，但我认为大多数 R 视频对于典型的新手来说太快了。
作为对此的回应，我开始了一个兼职项目，在那里我制作非常基本的 R/Rstudio/Tidyverse 视频，提供在 R 中进行数据科学的基本工具。我将在 www.teachingr.com发布我制作的视频。
关于研究生院数据科学的一页纸
对于许多领域的研究生来说，数据科学技能对于有效地进行高质量的研究至关重要。
不幸的是，大多数学生没有获得这些技能的正式途径。许多学生在整个研究生院期间效率低下，从未真正成为一名熟练的数据科学家，其他人完全凭自己的意愿变得熟练，而其他人可能因为缺乏数据科学技能而全部失败。
这是一个已知的问题，有许多努力来解决它。然而，在我看来，由于各种原因，大多数这些努力都是无效的:
基于演讲的教学。学生需要做什么来学习
不要提供学生可以自己使用的资源
提供代码块，不要强迫学生打字…学生不理解单独的代码块
不要教授实际的编程逻辑
关注太多的语言
使数据科学和入门看起来比实际更难，而且对大多数学生来说，难以接近
不要有对每个人都有价值的明确目标
课程缺乏结构，过于简短，效果不佳
教师没有做好充分的准备，也没有使用高质量的教学方法。相反，他们会漫谈想到什么
知识的诅咒:导师对不知道是什么感觉没有同理心和理解
教员对如何做事没有足够的说明
讲师对与会者的回应过于积极——就一个人的问题离题 30 分钟
但是也没那么难啊！我怀疑，在一个设计良好的环境中，一个学生既活跃又有足够的指导，他可以在 2 到 3 周内取得巨大的进步。这里有一些原则:
向学生宣传深度参与的重要性。承诺实际结果。
选择一种语言(我建议 R ),并专注于此
从编码逻辑开始，以获得坚实的基础
提供入门书籍之类的资源
以小组形式开展基于活动的学习
要求学生在课外阅读/接触新材料
给学生高质量的练习，从非常容易的脚手架到专家
我怀疑，至少在教育研究生院，研究生的生产力与基线数据科学技能高度相关。我怀疑，为研究生和博士后提供基线数据科学方面的高质量培训可以将单个学生的研究生产率提高 2 倍，这在像教育研究生院这样数据科学技能稀缺的地方尤其如此。证明数据科学技能和生产力之间的这种相关性将是有趣的，并且可能促使在研究生培训中更优先考虑早期数据科学教育
教机器说话和即兴演奏布鲁斯爵士乐
对于本周的文章，我想重点关注长短期记忆 (LSTM)模型的例子，因为它们是我在深度学习中遇到的最优雅的概念之一。他们还为谷歌翻译提供动力，帮助优步预测极端事件期间的需求，让亚马逊回声听起来像真人，教机器人外科医生打结，甚至谱写新的布鲁斯爵士乐。
挑战:我的狗有四只…
假设我让你猜句子“我的狗有四条腿……”中的下一个作品，你可能会说“腿”。在这种情况下，最后一个单词的上下文在紧邻的前一个单词内。除了知道句子的主语是“狗”，你不需要任何上下文。递归神经网络 (RNNs) 特别擅长做这类预测，当上下文和预测之间的差距很小时。
但是如果我说的不是上面的，而是:
“我有一只叫查理的狗。查理喜欢在我出去的时候追棍子，追猫，吃我的鞋子。查理有四个…”
你也会猜“腿”。但那只是因为你记得的相关上下文，即“查理”是我的“狗”。相关的上下文并不是紧接在前面的单词的一部分，而是在故事的开头。对于这类问题——当上下文和预测之间的差距很大时——rnn 很快就会崩溃。这就是长短期记忆模型的用武之地。
你的记忆是做什么的？
想想你自己的记忆。它有效地做了三件事:
- 记录新信息(输入门)—“我回到家，把钥匙放在烤箱旁边”
- 忘记一些信息(忘记门)–忘记钥匙在烤箱旁边
- 向前传递剩余信息(输出门)–我回到家，把钥匙放在某个地方
LSTMs 使用上述三个函数来为它试图预测的事物提供上下文。然后，它每次接受一小组单词(例如，“我有一只狗……”)，以(a)预测下一个单词(“叫查理”)和(b)记住句子的上下文(“狗”)。然后，当它需要预测句子后半部分的下一个单词(“查理有四个……”)时，它依靠记忆通知它我们在这里谈论的是一只狗，因此可能的答案是“腿”。
LSTMs 已经被证明在长时间内保持相关的上下文信息是非常有效的。
A memory cell. It takes as an input 1) new information + 2) outputted memory from an earlier cell. It then forgets some of its information. Finally, it outputs 1) a prediction + 2) the input into the next memory cell. Source: deeplearning.net
给机器人类语言
如果你在 Mac / iOS 上阅读这篇文章，试试这个:突出显示这一段，然后进入编辑- >语音- >开始朗读** (OSX) 或点击朗读 (iOS)。**
或者，这里有一个你会听到的例子:
A basic text-to-speech (not using LSTMs). Notice how it sounds monotone and not like a human. Source
虽然你能理解字面意思，但它听起来显然不像人类。它是单调的，声音不像人类那样掌握同样的语调。在高层次上，您可以将人类语言视为以下内容的组合:
- 你说的话
- 你使用的音高
- 你发音的节奏
(1)很容易做到，因为通常不是上下文相关的。警告是一个异义词(两个单词拼写相同，但发音和含义不同，如“我们必须擦亮波兰家具”或“请关上你靠近的门”)。
但是(2)和(3)(音高/节奏)是高度语境化的，基于你试图传达的内容(想象一下如果小马丁·路德·金的“我有一个梦想”演讲被苹果单调的 Safari 阅读器阅读)。高级语言语音系统，如百度的或亚马逊的Polly(Alexa 背后的声音)通过对人类声音的音高和节奏进行编码来解决这一问题，并应用 LSTMs 不仅预测下一个单词，还预测下一个单词的音高和节奏。
这里有一个使用不同的 TTS 系统阅读的两个英语句子的例子。你会注意到第三个——谷歌的 WaveNet ，它使用 lst ms——听起来更像人类。
用 LSTMs 创作蓝调爵士乐
Eck 和 Schmidhüber 将 LSTMs 应用于音乐创作，通过随机选择符合布鲁斯风格音乐形式的旋律来训练他们的模型。具体来说，他们训练他们的 LSTM 学习如何生成新的旋律结构，以“适应”和弦结构。这是第一次使用神经网络来捕捉音乐中的全局音乐结构(即歌曲早期部分的上下文记忆)，而不是局部音乐结构(就像 RNNs 能够做的那样)。
这是一个示例输出。虽然它不是 B. B. King，但它非常好，并且显示了我们离用 LSTMs 生成高级爵士乐有多近。
教授数据科学过程
The cyclical process of data science (source).
教授机器学习的课程已经存在了几十年，甚至更近的技术学科(深度学习或大数据架构)都有几乎标准的课程大纲和线性化的故事情节。另一方面，对数据科学过程的教学支持一直难以捉摸，尽管过程的大纲自 90 年代就已经存在。理解这一过程不仅需要机器学习的广泛技术背景，还需要企业管理的基本概念。在之前的一篇文章中，我已经详细阐述了由这些复杂性引发的数据科学转型的组织困难；在这里，我将分享我教授数据科学过程的经验。
The data science ecosystem. Data scientists “B” is in key position in formalizing the business problem and designing the data science workflow.
围绕工作流构建
最近，我有机会在大约 100 名来自巴黎综合理工学院的顶尖工科学生身上尝试一些实验性的教学技巧。课程的中心概念是数据科学工作流程。
- 设计工作流，其元素，要优化的分数，将工作流连接到业务数据科学家端。
- 优化工作流程，将其连接到技术数据科学家端。
这两者都不能在基于幻灯片的讲座中使用线性化叙述来教授。我用我们的平台围绕我们的坡道概念建造了这个球场。为了学习工作流优化，学生们参与了五个斜坡，旨在挑战他们不同的科学工作流和不同的数据科学问题。为了学习工作流设计，我讲述了几个数据驱动的业务案例，给学生提供了一个需要回答具体问题的线性指南，并要求他们在小组项目中构建业务案例和数据科学工作流。我使用 RAMP starting 工具包作为样本:限制无限的设计空间有助于学生构建项目。
使用坡道作为教学支持
RAMP 最初是为一个协作原型工具设计的，该工具可以有效利用数据科学家的时间来解决领域科学或业务问题的数据分析部分。然后，我们很快意识到，这对培训数据科学家新手同样有价值。我们需要改变的主要设计特征是完全的开放性。为了能够根据个人表现给学生打分，我们需要关闭排行榜。在封闭阶段，学生们看到彼此的分数，但看不到彼此的代码。我们使用分数的上限线性函数来给他们评分。这个通常持续 1-2 周的封闭阶段之后是一个“经典”的开放阶段，在这个阶段中，我们根据学生的活动和他们创造多样性的能力以及提高他们自己的封闭阶段分数来给他们打分。
学生们的集体表演堪称壮观。在所有五个斜坡中，他们不仅超过了基线，还超过了我们组织的测试工作流的单日 hackaton 分数，通常有 30-50 名顶级数据科学家和领域科学家参与。
Score vs submission timestamp of the first classroom RAMP. Blue and red circles represent submissions in the closed and open phases, respectively. The pink curve is the current best score and the green curve is the performance of the best model blend. The top 10% of the students outperformed both the data science researchers (single day hackaton) and the best deep neural nets, even in the closed phase. They then outperformed state-of-the-art automatic model blending when combining each other’s solutions in the open phase.
我也很高兴地看到，在开放阶段新手/普通学生通过学习和重用封闭阶段来自前 10-20%学生的解决方案赶上了前 11 名。另一个惊喜是直接盲目抄袭非常罕见:学生们真诚地试图改进彼此的代码。
Score distributions in classroom RAMPs. The blue and red histograms represent submissions in the closed and open phases, respectively (the darker histogram is the overlap). The histograms indicate that novice/average students catch up to the top 10% in the open phase by profiting from the open code.
我们将分析这些丰富的结果，并在领域科学(第一个例子见本文)数据科学和管理科学中撰写论文。这份技术报告包含了更多的细节，这里有我的幻灯片来自最近关于数据科学过程的 DALI 研讨会。
使用业务案例进行工作流设计教学
正如我在之前的文章中解释的那样，非 IT 公司启动数据科学项目的主要障碍不是缺乏准备充分的数据，不是基础设施，甚至不是缺乏训练有素的数据科学家，而是缺乏定义良好的数据驱动的业务案例。更糟糕的是:这个问题通常是在对数据湖、Hadoop 服务器和数据科学团队进行初始投资之后才发现的。一个准备充分的数据(流程)科学家，如果能够尽早进入这一过渡阶段并彻底改变项目，甚至可以为一家中型公司节省数百万美元。
为了培养学生胜任这一角色，我在课程开始时对模型预测性维护案例进行了深入讨论。每个人在他们的项目中需要回答的标准化问题帮助学生从广泛描述的业务案例走向明确定义的预测分数、误差测量和数据收集策略。
- 我们想要预测什么，我们如何衡量预测的质量？
- 更好的预测将如何改进选定的 KPI？
- 你想有决策支持，一个完全自动化的系统，还是只想知道哪些因素是重要的？代理将如何使用该系统？
- 定量预测应该是什么？
- 我们如何(使用什么分数)衡量成功？(可能不对称的)预测误差如何转化为成本或降低的 KPI？
- 我们需要什么数据来开发一个预测器？
- 我们需要做哪些工作来收集这些数据？
- 给定数据源和预测目标，工作流和工作流元素是什么？
- 该模型需要多长时间重新培训一次？
我进一步组织了他们的项目，让他们按照他们遇到的五个斜坡制作一个启动工具包。每个起始套件包含
- 一个数据集，
- 填充设计工作流的示例工作流元素，
- 实现工作流的单元测试，可用于测试工作流元素，以及
- Jupyter 笔记本，描述科学或商业问题(回答上述问题)，读取、操作、探索和可视化数据，解释数据分析工作流，并提供和解释每个工作流元素的初始工作解决方案。
该课程包含大量问答，讨论其他业务案例(包括成功和失败的案例)，并解释各种可能的工作流和工作流元素。
A time series forecasting workflow for predicting El Nino.
A multi-criteria workflow for classifying and quantifying chemotherapy drugs for noninvasive quality control.
由于学生可以自由选择任何可用的数据集，数据收集基本上不成问题。工作流相对简单，所以几乎所有的团队都交付了工作启动工具包。另一方面，很多时候，学生们陷入了试图为“好的”数据集寻找商业案例的陷阱。大约一半的团队至少试图设计一个有意义的商业案例。前 3 名团队(共 22 个)交付了顶级产品:
- 一个制造过程控制产品，使用精确校准的维护成本、生产成本、满意度成本和利润，计算出误报和漏报的不对称成本。团队在几个基线上显示了改进(不检查、检查所有、随机检查)。
- 一款卖给大型多人在线游戏的产品。目标是预测玩家是人类还是机器人。当机器人与他们自己的线下业务竞争时，这些游戏会赔钱，这些业务通过自动收集游戏中的角色和功能并在黑市上出售来出售真钱。该团队通过考虑不对称分类错误，制定了商业案例。
- 一种可以卖给出租车公司或优步的产品，预测每小时和曼哈顿地区的出租车需求。该团队通过估计可用乘坐次数乘以每次乘坐的利润，将预测转化为价值。
如果你喜欢你读的东西，在中、 LinkedIn 、& Twitter 上关注我。
Python Pandas 金融数据集技术分析库
[Image[1] (Image courtesy: https://unsplash.com)]
在过去的几个月里，我一直在研究一些金融时间序列，如预测比特币价格或号人物、两个适马投资或 G-Research 提出的不同挑战。也就是说，我们已经决定基于 Pandas 库用 python 开发一个技术分析库。您可以在以下位置找到该库:
ta——Python 中的技术分析库
github.com](https://github.com/bukosabino/ta)
这个新的库面向从典型的金融数据集进行“特征工程”，这些数据集通常包括诸如“时间戳”、“开盘”、“高”、“低”、“收盘”和“成交量”等列。该库将由希望使用 Python 数据科学技术堆栈(Pandas、Scikit-Learn、XGBoost、LightGBM、Keras、TensorFlow 等)解决机器学习问题的数据科学人员使用。
目前，这些工具在预测几乎任何事情上都取得了很好的效果，但是当它们被用来面对金融问题时，就不能正常工作了。它们不能正常工作，因为数据集中的行仅包含关于特定时间段(例如 6 小时或一天)的信息，这不足以使用当前模型生成良好的预测。为了改进预测，我们需要向数据集提供更多信息(要素),因为当提供更多信息时，当前模型会获得更好的结果。
技术分析的重点是提供过去的新信息来预测价格的走向。通过增加不同变量(“数量”、“波动性”、“趋势”、“势头”等)的不同指标产生的信息，我们可以提高原始数据集的质量。
现在，我们将详细解释两个例子:
布林线用于分析特定时期内资产价格的波动性。有 3 个波段，中间波段(MB)是最近 n 个周期的价格平均值，上波段(UB)和下波段(LB)等于中间波段，但加上和减去 x 倍标准差。正在使用的正常参数是 n = 20 个周期，x = 2。所以:
MB =总和(n 个最后收盘值)/ n
UB = MB + (X *标准偏差)
LB = MB — (X *标准偏差)
Bollinger Bands example [Image[2] (Own image generated with Matplotlib)]
在库中，收盘价变量被转换为 5 个新特性。除了 3 个布林线，我们还生成了另外 2 个指标，当收盘值高于上布林线或低于下布林线时，这两个指标会显示出来。因此，这两个特征将为 0，除非收盘值超出这些范围，否则将为 1。
如果我们看一下图 2，当收盘波(蓝色)超过上波段或下波段时，价格会发生突然变化，通常在高于上波段时卖出，在低于下波段时买入是一个好主意。
均线收敛背离是一个关注指数移动平均线(EMA)的交易指标。为了计算它，我们使用:
MACD =均线(n1，收盘)—均线(n2，收盘)
MACD 信号=均线(n3，MACD)
MACD _ 差异= MACD—MACD _ 信号
变量的典型值是 n1=12，n2=26，n3=9，但是根据你的交易风格和目标，库中也可以有其他的值。
MACD example [Image[3] (Own image generated with Matplotlib)]
理论告诉我们，当 MACD 曲线(蓝色)小于 MACD 信号(橙色)时，或者当 MACD 差(绿色曲线代表 MACD 信号和 MACD 曲线之间的差)的值小于 0 时，价格趋势将是熊市。反之，则表示涨价。
这时，图书馆已经实施了 32 项指标:
卷
- 积累/分配指数
- 平衡量(OBV)
- 平衡体积平均值(OBV 平均值)
- 柴金资金流(CMF)
- 力指数
- 便于移动(EMV 选举观察团)
- 量价趋势(VPT)
- 负体积指数
波动性
- 平均真实距离
- 布林线(BB)
- 凯尔特纳海峡
- 唐奇安海峡(DC)
趋势
- 移动平均收敛发散(MACD)
- 平均定向运动指数
- 涡流指示器(六)
- 特里克斯(Trix)
- 质量指数
- 商品频道指数(CCI)
- 去趋势价格振荡器(DPO)
- KST 振荡器(KST)
- 一目岛
动力
- 货币流通指数
- 相对强度指数
- 真实强度指数
- 终极振荡器(UO)
- 随机振荡器
- 威廉姆斯%R (WR)
- 超棒振荡器(AO)
其他人
- 每日退货
- 累积回报
这些指标产生了 58 个特征。开发人员可以设置许多输入参数，如窗口的大小，不同的常数或智能自动填充方法中生成的 NaN 值。
我们已经将该库的第一个稳定版本上传到 GitHub，可以使用“pip”安装。该库正在继续开发，所以我们将包括更多的指标，功能，文档等。请让我们知道任何评论，贡献或反馈。
ta——Python 中的技术分析库
github.com](https://github.com/bukosabino/ta)
此外，我是一名软件自由职业者，专注于数据科学，使用 Python 工具，如 Pandas、Scikit-Learn、Zipline 或 Catalyst。如果你需要与本库相关的东西，技术分析，Algo 交易，机器学习等，请随时联系我。**
机器学习中的技术债务
或者如何用火箭筒打自己的脚。
我们许多人都不喜欢技术债务，但一般来说，这并不是一件坏事。技术债务是一种工具，当我们需要满足一些发布截止日期或解除同事的封锁时，它是合理的。然而，技术债务的问题与金融债务的问题是一样的——当偿还债务的时候，我们归还的比开始时多。这是因为技术债务具有复合效应。
有经验的团队知道什么时候应该支持堆积如山的债务，但是机器学习中的技术债务堆积得非常快。 你可以在一个工作日内创造几个月的债务，即使是最有经验的团队也会错过债务如此巨大的时刻，以至于他们推迟半年，这通常足以扼杀一个快节奏的项目。
这里有三篇探讨这个问题的精彩论文:
机器学习:技术债的高息信用卡 NIPS'14
机器学习系统中隐藏的技术债 NIPS'15
你的 ML 测试分数是多少？NIPS’16
这些论文分类并展示了几十种机器学习反模式，它们会慢慢潜入您的基础设施，成为一颗定时炸弹。在这里，我只讨论三种让我在夜里吓出一身冷汗的反模式，其余的留给读者。
反馈回路
当 ML 模型的输出被间接反馈到它自己的输入中时，反馈循环就发生了。听起来像是很容易避免的事情，但实际上并不可行。反馈回路有多种变化，NIPS 的论文给出了一个很好的例子，但我将给出一个更真实的例子。
例子
假设你的公司有一个购物网站。一个后端团队提出了一个推荐系统，它根据客户的个人资料和过去的购买历史来决定是否显示一个带有报价的弹出通知。很自然，你想根据之前点击或忽略的弹出通知来训练你的推荐系统，这还不是一个反馈循环。当点击通知的比例一周比一周慢慢增加时，您启动了这个功能并欣喜不已。你用人工智能改善其过去性能的能力来解释这种增长:)但你不知道的是，前端团队实现了一个固定的阈值，如果推荐报价的可信度低于 50%，它会隐藏弹出通知，因为显然，他们不想向客户显示潜在的坏报价。随着时间的推移，以前在 50–60%置信度范围内的建议现在用< 50%置信度进行推断，只留下 50–100%范围内最有效的建议。这是一个反馈循环——您的度量在增长，但是系统的质量没有提高。士气:你不仅要 利用ML 系统，还要允许它 探索——摆脱固定的门槛。
在小公司中，控制反馈循环相对容易，但是在大公司中，几十个团队在几十个复杂的系统上工作，这些系统通过管道相互连接，一些反馈循环很可能会被遗漏。
如果您注意到一些指标随着时间慢慢上升，甚至在没有启动时，也能感觉到反馈循环。找到并修复循环是一个非常困难的问题，因为它涉及到跨团队的努力。
校正级联
当 ML 模型没有学习到您希望它学习的东西，并且您最终在 ML 模型的输出上应用了一个修补程序时，就会发生校正级联。随着修补程序的堆积，你最终会在 ML 模型的顶部有一层厚厚的试探法，这被称为校正级联。即使在没有时间压力的情况下，修正级联也是非常诱人的。很容易对 ML 系统的输出应用过滤器，以便处理 ML 不想学习的一些罕见的特殊情况。
校正级联将您的 ML 模型在从整个系统的整体指标进行训练时试图优化的指标去相关。随着这一层变得越来越厚，你不再知道 ML 模型的什么变化会改进你向你的老板展示的最终度量，并且你最终不能交付新的改进。
垃圾特征
垃圾特性是指在你的 ML 系统中没有任何用处的特性，你无法摆脱它们。有三种类型的垃圾特征:
捆绑特性 有时，当我们有一组新特性时，你会一起评估它们，如果发现有益，就提交整个捆绑包。不幸的是，捆绑包中只有一些功能是有用的，而其他功能正在拖累它。
ε-特性 有时添加一个特性是很诱人的，即使质量增加很少。然而，如果基础数据有一点漂移，这些特征可能会在一周内变得中性或负面。
随着时间的推移，我们向项目中添加新的特性，并且不再重新评估它们。几个月后，其中一些功能可能会变得完全无用或被新功能取代。
在复杂的 ML 系统中，有效清除垃圾特征的唯一方法是尝试一次修剪一个。也就是说，您一次删除一个特性，训练 ML 系统，并使用您的度量标准评估它。如果系统需要 1 天来训练，我们一次最多可以运行 5 次训练，我们有 500 个功能，那么修剪所有功能将需要 100 天。不幸的是，特征可能会相互作用，这意味着您必须尝试修剪所有可能的特征子集，这成为一个指数级的难题。
凭借我们的力量
在你的机器学习基础设施中拥有这三种反模式可能会毁掉整个项目。
有了反馈循环，你的度量将不能反映系统的真实质量，你的 ML 模型将学习利用这些反馈循环，而不是学习有用的东西。此外，随着时间的推移，您的模型可能会被工程团队无意中塑造成更多地利用这些循环。
校正级联将放松在 ML 模型上直接测量的指标和作为整体的系统之间的相关性。您将最终处于这样一种情况，对 ML 模型的积极改进会对整个系统的度量产生随机的影响。
有了垃圾特征，你甚至不知道你的数百个特征中的哪一个实际上携带了有用的信息，并且删除它们的代价太大了。每天，您通常监控的指标会随机上升或下降，因为一些垃圾特性会随机出现。不，正规化只会有一点点帮助。
您最终得到的项目中，度量标准随机上下跳动，不能反映实际的质量，并且您不能改进它们。唯一的出路就是从头开始重写整个项目。这时你就知道了——你用火箭筒打中了自己的脚。
基于电子邮件网络的见解的技术概述
unsplash.com
组织网络分析和沟通内容分析系列文章
这是第 1 部分文章的后续，其中我们提到了一些我们想要解决的关键难点。
在这里，我们深入探讨两个最有趣的观点:
- 内部继任计划
- 如果员工离职怎么办
内部继任规划
内部候选人被提拔为接班人是常有的事。内部晋升往往基于与离职领导和周围影响群体的绩效和社会关系，而没有数据驱动的分析。今天的系统在继任规划方面做得并不理想，因为它们有偏见，没有考虑到数据驱动的网络和关系(ONA)。
在我们的方法中，除了领导者-继任者沟通，我们还关注间接涉及其他因素和混杂因素的整体社会状态。我们借用了脸书提出的社会分散的概念。除其他外，该条指出:
一个人的网络邻居——与他或她有联系的一群人——已经被证明在广泛的环境中具有重要的影响，包括社会支持和职业机会。
“包括社会支持和职业机会”这句话是探讨继任规划方面的重要基础，此外还有共同的朋友交流范式。这种方法的缺点是不容易对外部候选人进行这种分析，因为离职的领导者在另一个通信领域，因此几乎不可能进行基于电子邮件网络的分析。
我们的实施可以向即将离任的领导者推荐几个潜在的内部继任者。
这是通过了解继任者的网络是否也在与领导者的网络通信来实现的。可以推断，高度分散是成功的内部继任规划的良好基础。这意味着继任者的网络与领导者的网络高度互联。显然，即将离任的领导人在确定继任者时会考虑其他因素，也许不是很数据驱动，而是基于直觉。我们的方法实际上是一个推荐器，而不是绝对匹配。
然而，如果继任者得到提升，她很可能会在组织中留下一个角色空缺。因此，我们更进了一步，我们提供了更进一步的接班人。下图更详细地解释了这个概念。
为了实现这一点，我们使用了基于电子邮件网络的“发件人”和“收件人”字段，不涉及任何内容(在稍后阶段，我们将利用时间戳来解决关系衰退)。该数据集包含 8000 名员工和 25 万封电子邮件。在技术和算法方面，我们使用了 Python 包，如: NetworkX 、熊猫、 NumPy 。以下代码片段是内部继任计划算法实施的关键部分:
df = pd.DataFrame(data, columns = ['Sender','Recipient'])
G = nx.from_pandas_edgelist(df, source = 'Sender', target = 'Recipient', create_using = nx.DiGraph())
dis = nx.dispersion(G, normalized = True)
对于我们的观众，我们实现了一个 3D 网络可视化，如下所示。但是，产品实现是基于 API 即服务的。
(注意姓名不代表我们的员工)
如果员工离职怎么办
一旦员工不再担任相同的角色，了解沟通风险是企业运营的关键。这一特性对直线经理特别有用，他们需要在整个变革过程中保持正常的沟通和劳动力。高中间中心性意味着更高的员工替换成本。如果一个员工有很高的关系网，并作为沟通的桥梁，介绍一个新的候选人担任这样的角色需要花费时间和金钱。
中间中心性被定义为节点“I”需要节点“k”(其中心性正在被测量)以通过最短路径到达节点“j”的时间份额。我们实现的研究基础来自研究论文中心性和网络流。
该算法的核心实现片段如下所示:
def betweenness_centrality_chunks(l, n):
l_c = iter(l)
while 1:
x = tuple(itertools.islice(l_c, n))
if not x:
return
yield x
def _betweenness_centrality_map(G_normalized_weight_sources_tuple):
return nx.betweenness_centrality_source(*G_normalized_weight_sources_tuple)
def betweenness_centrality_parallel(G, processes=None):
p = Pool(processes=processes)
node_divisor = len(p._pool)
node_chunks = list(betweenness_centrality_chunks(G.nodes(), int(G.order() / node_divisor)))
num_chunks = len(node_chunks)
bt_sc = p.map(_betweenness_centrality_map,
zip([G] * num_chunks,
[True] * num_chunks,
[None] * num_chunks,
node_chunks))
bt_c = bt_sc[0]
for bt in bt_sc[1:]:
for n in bt:
bt_c[n] += bt[n]
return bt_c
btwn_cent = betweenness_centrality_parallel(G)
同样，对于展示案例，我们已经实现了 3D 网络可视化。
有许多与员工离职概率相关的实现，如风险逃离、员工流失等。这些方法大多基于机器学习和对类似情况的分析，例如 k-means 聚类。我们的方法与众不同，因为它使用 ONA 指标来得出与实际员工更相关的结论，而不是从其他案例中学习。更好的方法是将 ONA 和机器学习的指标进行加权组合，我们正在研究这种方法。
大多数公司通过书面的官方流程来解决这些问题。这不会让这些公司为未来做好准备，因为流程是静态的，很难更新，不容易获得，也不能动态地反映不断变化的事件。我们想通过引入动态方法来改变这种情况。这种方法不依赖于书面文件，而是依赖于当前的信息流、背景、趋势、沟通和实际的员工数据——基本上是一种 VUCA 反应。
我们的进一步发展进入机器学习、异常检测和时间序列分析的方向。
本文是 ONA @豪夫系列文章的一部分
- 如何使用企业电子邮件分析来揭示隐藏的明星并确保机会均等(第一部分
- 电子邮件网络见解技术概述( 第二部分 )
- 深入探讨基于电子邮件网络的推荐(第 3 部分)
- 如何利用趋势发现隐藏的明星，并致力于一个完美的项目？人物分析会让你成为明星
- 如何实现基于电子邮件内容的分析(第 5 部分)
技术工作流程:为可达性分析构建交通场景
逐步文档
在的前一篇文章中，我记录了我使用一系列工具来衡量各种交通方式下的工作可达性。我最终使用了传送带的分析工具。然而，即使有了这个专门的软件，我的分析也需要大量的数据争论来构建未来的场景。
问题是
即使是最好的软件工具似乎也是为大城市设计的——像纽约和旧金山这样的地方，那里的道路或多或少都是固定的，所以规划增长通常意味着关注城市交通系统的变化。几个可达性分析工具使得用户可以很容易地开发和比较交通场景。能够在其他环境中利用这些工具是一个巨大的优势。但较小的城市有额外的需求，这些工具不容易解决。
在像本德这样的地方，增长规划主要集中在新的基础设施上:建设新的道路、自行车和行人设施。我考虑过的辅助工具都没有内置的添加或修改道路的功能；用户只能在当前道路网络*上运行场景。此外,(在我看来)没有基于道路交通压力的水平来评估自行车网络的功能，以便了解骑自行车的平均人的连通性。为了将可访问性分析整合到我们的过程中，我们需要能够处理这些类型的场景。
*注意:这不适用于更技术性的、自己动手的工具(即任何在 Github 上以代码形式存在的、不能通过用户友好的 GUI 访问的东西)。这些可能很棒，但是对于大多数在城市工作的城市规划者来说是不可用的(更不用说小城市了)。
解决方案
使用多种工具的组合，可以准备用于评估的自定义道路和自行车网络。这篇文章记录了我为了将分析应用于我们的特定需求而使用的工作流程。这种方法本质上是关于使用 OpenStreetMap (OSM)数据构建场景，因此它也适用于使用 OSM 数据作为输入的其他规划工具(这相当常见，尤其是对于开源工具)。
这篇文章记录了 Bend 的工作流程——部分供我们内部参考，也可能对其他人有用。
更广泛的要点
除了技术工作流程本身，该流程还强调了几点:
- 好的地图合并工具将为这样的项目带来真正的好处。手动操作不同格式的数据集需要花费大量的时间和精力。
- 如果情景规划工具能够让用户模拟未来状态的道路变化，那么它们对较小的城市更有用。输送机的分析工具允许用户输入 OSM 数据的自定义 PBF 文件，这就是为什么我们能够使用我们的目的的工具。不过，这仍然很难，并且需要大量关于处理 OSM 数据的技术知识。如果有一个使用户能够修改道路网络的功能，小城市可能会更好地利用分析等工具——类似于对场景进行本地更改的 iD 编辑器界面。
- 在 OSM 拥有一个 LTS 标签将为当前状态的 LTS 数据提供一个栖身之所，这将实现更好的分析，并可以避免像我这样的人在未来不得不经历复杂的手动数据过程(或者，该过程可能必须使用一次来获取数据，但随后将可供其他人使用)。
事不宜迟…以下是我使用的工作流程:
1.准确的 OSM 基线数据
许多此类工具使用 OpenStreetMap (OSM)作为本地道路网的输入数据。我想检查 OSM 对于我所在地区的准确性，并绘制出任何缺失的道路。
了解 OSM 以及如何编辑它的一个很好的方式是 learnosm.org 的。对于那些刚到 OSM 的人，我不建议对你所在城市的道路网进行大的改变(比如删除或移动现有的要素)——它可能已经足够接近现状了……而且很容易损坏东西。不过，添加缺失的道路可能会有所帮助。
我使用热门任务管理器将网格划分成合理的块(“任务”)。对于每个任务，我使用 JOSM (带有 shapefile 插件)将城市的 GIS 数据与 OSM 和卫星图像进行比较，并添加任何缺失的路径、道路等。我把它标记为“完成”，然后继续下一个任务。虽然我肯定有一个更技术性的、GIS 式的方法来做这种比较，但这个城市足够小，我可以很快完成。
The HOT Tasking Manager makes it easy to systematically map, validate, or update an area of interest
Comparing county roads data (fuschia, yellow) to OSM data (grey)
OSM 对大部分弯道都非常准确；我只找到了少数尚未绘制的新道路，其中包含了详细的小巷和便道。不过，我加了很多人行道。这些对于像当地社区学院这样的地区来说尤其重要，它坐落在一大片土地上，那里有许多纵横交错的小径(又名“社交小径”)。虽然不是官方路线，但这是许多人进入大学的现实途径。如果不追踪这些进入 OSM 的路径，行人可及性将会非常低(尤其是如果您使用的工具使用基于质心的方法来定位宗地、街区或区域内的工作)。
Adding footpaths (dashed lime green lines) in JOSM, especially for really large parcels
系统地检查整个城市意味着我对当地 OSM 数据的准确性非常有信心。但是花了很多时间(会议期间 8 小时以上的多任务处理)却没有多少改变。如果我再做一次，我仍然会手动查看数据，但我将只关注检查 OSM 最近开发的区域和拥有大片土地的区域。
我保存了我的更改并上传到 OSM。输送机的分析工具要求 OSM 数据以 PBF 格式提供，这只是 OSM 数据的压缩版本。有几种方法可以达到这个目的:
- 保存在 JOSM 的更改，并转换为 PBF 格式(更多信息如下。未来的场景需要这种方法，所以您最好熟悉它。)
- 等待更改到达服务器，并通过传输分析用户界面下载
- 等待更改到达服务器，并从热导出工具下载 PBF 格式
2.“基线”场景中还有什么？
这是添加其他项目或链接的时候了，这些项目或链接目前还不存在，但是会成为基线分析的一部分。
对本德来说，这意味着在大片未开发的土地上进行新的开发。我在模拟一个 20 年的场景，其中有相当大的人口增长和向新区域的扩张，这些区域刚刚被添加到本德的城市增长边界中。新的家园和工作岗位将位于这些地区，当地的街道将被修建。规划这些街道的确切走向将作为局部区域规划过程的一部分。与此同时，我需要在扩展区域中添加一些本地街道，以便允许模型中的“人”从扩展区域连接到城市，反之亦然。为了做到这一点，我使用 JOSM 绘制了扩展区域的道路，并将它们标记为highway=residential。这些道路并不是特别真实或精确，我也不会在地图上将它们显示为“潜在道路”，但它们确实可以作为数据输入。
Adding placeholder local roads for currently-unbuilt areas that are projected to develop housing
在 JOSM，我把这些保存为一个单独的文件baseline_roads.osm。我复制了几份用于场景。这个数据不应该上传到 OSM ，因为“虚拟道路”实际上并不存在。
3。转换成 PBF 格式
传送带公司的分析要求 OSM 数据采用一种叫做 PBF 的压缩格式。为此，我安装了 osmium 作为命令行工具，导航到带有.osm文件的目录，并使用
osmium cat <baseline_roads.osm> -o <baseline_roads.pbf>进行转换
这个 PBF 文件现在可以用于可访问性分析了。
4.准备其他数据输入，测试工具
其他输入包括公开可用的 GTFS 数据，人口和就业的土地使用数据，以及分析区域的边界。
对于土地使用数据:由于该建模侧重于 2040 年的情景，我没有使用可通过 Conveyal 接口访问的矿脉普查数据。相反，我上传了一个包含未来各州人口和就业预测的地块 shapefile。在 GIS 中，我对这些数据进行了分解，使其仅包含人口和就业字段，并确保其在 WGS84 中进行了投影。
我在这里遇到了一个小障碍，因为数据包含一些非常非常小的宗地(小于 0.00001 英亩)，必须先从 shapefile 中删除这些宗地，然后工具才会接受它们作为输入。
Some of these teeny parcels needed to be deleted.
使用这些输入和基线 OSM 数据，我建立了一个超出我的兴趣范围的分析区域。我运行了分析工具，以确保这些数据是可行的，并且该工具按预期工作。
Inspecting point-based accessibility for cars and pedestrians
分析区域:然后，我通过上传本德市城市范围的 shapefile，加上扩展区域和预计未来人口增长和就业的其他区域，对结果进行约束。我检查了结果，以确保它们有意义，然后转向场景。
Inspecting regional results for cars. The gist: the average person in a car can reach all jobs in half an hour (or less). This is what I would expect to see.
Inspecting regional results for bikes. The gist: the average person on a bike could access about 60% of future jobs in half an hour. This doesn’t account for the level of traffic stress of the roads. This result seems pretty reasonable based on local conditions; seems like everything is working properly.
5.构建道路场景
这部分不是很复杂，但是很快。根据我拥有的数据格式，构建新道路场景的最简单方法是:
- 将基线 OSM 文件的副本保存为
scenarioA_roads.osm，并在 JOSM 打开它。 - 使用我为潜在的新道路准备的 Shapefile，确保它在 WGS84 投影中，将它作为一个单独的图层加载到 JOSM(使用 shapefile 插件)
- 交替查看两个不同的图层，并根据它们的位置和我的描述追踪新的道路(这会影响道路是否应该标记为
highway=residential或highway=secondary等)。我还标记了潜在的项目(例如scenario=A)来跟踪它们——数据将保留在我的本地机器上，所以我不担心用非标准的标记弄乱数据。 - 将文件保存在 JOSM 本地。不要将更改上传到 OSM。
- 使用第 3 节中的过程转换到 PBF(见上一节)
- 对任何其他场景重复此过程
然后，道路场景就可以载入分析并运行了。
Example: Tracing a new road into JOSM.
6.自行车网络:局限于低压力路线(很多兔子洞和麻烦)
对于骑自行车的普通人来说，并不是所有的道路都是安全舒适的。为了模拟普通人的可达性，根据 ODOT 的分类系统，我将分析仅限于模拟 LTS 1 号或 LTS 2 号公路。我用这个低压力网络为自行车开发了不同的场景。
我们已经有了 Bend 道路交通压力水平的内部 GIS 数据。这一信息还有另一个来源； PeopleForBikes 使用 OpenStreetMap 数据生成美国 500 多个城市道路的 LTS 估计值。这些数据可以从他们的网站上免费下载(旁注:如果 LTS 能作为 OSM 的一个标签被添加进去，那就太好了，这样这些信息就更容易获得了)。这不如基于当地详细信息的数据准确，质量取决于当地 OSM 数据的完整性；此外，它可能不遵循构成新 LTS 协议的特定分类标准，等等(在我们的案例中，我们使用了 ODOT 的指导方针)。也就是说，这些数据是一个非常好的开始，其背后的方法在网站上有非常好的记录，所以你可以告诉为什么事情会以这种方式分类。我将本德市的 LTS 数据与 PeopleForBikes 的 LTS 数据进行了比较，结果基本相当接近——见下文。在某些情况下，城市数据更准确或更新。在其他情况下(比如高速公路入口和出口)，PeopleforBikes 的方法会产生更真实的(高压力)结果。
This map shows both LTS datasets on the same map. Zoom in to see the different datasets side-by-side. High-stress roads are shown in shades of red; low-stress roads are shown in shades of blue. City data are represented by darker and bolder lines than PeopleforBikes data. Matching data looks like two parallel lines of the same-ish colour; mismatching data will have a red line parallel to a blue line.
这是我遇到障碍的地方。我至少有两种不同格式的不同数据集。我的城市 GIS 数据不可选择路线，也没有在之前步骤中创建的“虚拟”道路。我的 OSM 数据没有 LTS 属性。
Why is this so hard?
首先，我试图变得老练
合并来自不同机构/来源、不同格式的数据，对世界各地的城市来说都是一个挑战。为了避免手动过程，我尝试了几个地图合并工具:hootenny和 SharedStreets 。SharedStreets 并没有不符合我当时的需求(但我对未来寄予厚望)。Hootenanny 目前正在被 NGA 使用，看起来是为 OSM 和 GIS 合并而设计的，所以我充满希望。我设置了一个本地版本的 Hootenanny，并尝试加载我的数据集。我在这里遇到了很多障碍，并认为这可能只是一个巨大的兔子洞(我的截止日期很紧)，所以我现在放弃了这一努力。
我还尝试在 GIS 中混合我的数据集，转换成 OSM 格式，并加载到 JOSM。这涉及到重复的功能。我在 JOSM 检查了这些，看到了不应该存在的路径之间杂乱无章的连接。我将结果作为输入数据进行分析，只是为了看看会发生什么，结果真的很奇怪。这个过程是一个“不”。
实际效果:
最后，我不得不使用手动且相当繁琐的方法:
- 在 GIS 中，仅制作高应力道路的 shape file(LTS 3 或 4)
- 创建基线 OSM 数据(
baseline_bike.osm)的副本，并在 JOSM 打开 - 将高应力形状文件作为图层加载到 JOSM 中(使用 JOSM 形状文件插件)
- 交替查看这两层。找出任何高应力的路段(路线),并从
baseline_bike.osm文件中删除。几个小技巧可能会让这变得更容易——尝试过滤你的视图，只考虑高速公路和主干道highway=primary、highway=secondary等。其中大部分可能是高压力的，可以删除。接下来，过滤显示所有的道路和路径(highway=*，但没有其他功能。 - 将 JOSM 文件保存在本地。不要将更改上传到 OSM。
- 转换为 PBF 使用锇命令行工具(见第 3 节)
现在可以输入到分析中了。
为了创建新的场景，我使用了baseline_bike.osm文件作为基础，并在场景项目列表中包含的任何新的或修改的道路和自行车设施中进行跟踪——这与第 5 节的过程相同。我将这些标记为highway=residential，以确保它们被认为是可供自行车使用的街道。
在分析中，我把这些设定为新的区域。由于道路网络仅包括可供普通骑自行车者使用的道路，因此只能从自行车的角度进行分析。我没有使用这些数据对其他模式进行分析。
7.自行车网络:开发书立
我还分析了如果整个网络(所有合理的设施)是低压力的，自行车的可达性。这篇文章解释了为什么，以及它如何有助于围绕城市的自行车网络形成对话。
为此，我使用汽车场景输入(baseline_roads.pbf、scenarioA_roads.pbf等)来分析自行车的就业可达性。这产生的结果比只有低压力的自行车场景的结果高两倍。这表明自行车的壁垒将就业机会减少了一半。它还有助于隔离场景项目的潜在影响——在一个联系更紧密、压力更小的网络中，新的联系会产生更大的影响。
TED 演讲分析—面向初学者的 EDA
Google — TED Talks
Ted 演讲是一个了不起的创举。很多人，你通过他们的工作和成就了解他们，但从来不知道他们的奋斗，他们对生活的看法，但通过 Ted 演讲，你可以了解所有这些。很多杂志也刊登采访，但是听他们的故事和他们自己的观点是完全不同的。很多时候，人们建议我应该听听 Ted 演讲，就像有一次我的一个朋友建议我听听马尔科姆·格拉德威尔。
我一直相信人们的选择，相信我认识的人，坦率地说，我甚至不喜欢一些 ted 演讲。这让我想到，我想成为一名数据科学家，也许我应该更多地依赖数据，从更多的人口中获得观点。
介绍
为了实现分析数据的愿望，我从 Kaggle 下载了 Ted 演讲数据。在本帖中，我们将使用这个数据集，并尝试找出 ted 演讲中的顶级演讲者，以及关于什么时候 Ted 演讲进行得最多的一些想法。
在我们开始代码和探索部分之前，作为初学者，理解 EDA 是什么以及它为什么重要是非常重要的。
EDA(探索性数据分析)-
维基百科定义
在统计学中，探索性数据分析 ( EDA )是一种分析数据集以总结其主要特征的方法，通常采用可视化方法。探索性数据分析是由约翰·图基倡导的，目的是鼓励统计学家探索数据，并可能提出可能导致新的数据收集和实验的假设。
EDA 有助于鸟瞰数据，我们可以尝试理解它。在数据分析中，它是第一步，是在我们应用任何统计技术之前实现的。人们使用一些特定的统计技术，如直方图或箱线图，但 EDA 不是一套技术或程序，也不限于一两种图或技术。EDA 是关于理解数据的，在开始对数据建模之前获得关于数据的见解是很重要的。
让我们举一个非常简单的现实生活中的例子，当你去购物时，在购买任何东西之前，你会在商店里闲逛，探索哪些东西最适合你或者哪些更便宜。价格、品牌、布料质量、尺寸等等，这些都是特点或特征，如果你不去探索这些特征，你可能最终会买一些你不喜欢的东西。
希望这有意义。让我们开始探索我们的数据。该数据集包含截至 2017 年 9 月 21 日上传到 TED.com 官方网站的所有 TED 演讲音频视频记录的信息。所有谈话，包括观点数量，评论数量，描述，发言者和标题。
ted_data = pd.read_csv("ted_main.csv")
ted_data.head()
Ted Dataset Snapshot
从快照中我们可以看到，日期是 Unix 时间戳格式，name 列包含 name + title。看起来是时候清理数据了。
数据准备:清理和格式化
在数据项目管道中，这一步占用了数据科学家的大部分时间。因此，在开始我们的数据分析和探索之前，让我们试着找出我们的数据集是否需要一些清理和格式化。
从寻找任何丢失的值开始-
# Let's have a look how many values are missing.
ted_data.isnull().sum()
Missing value analysis
我们很幸运，没有丢失值(可以忽略扬声器职业，只有 6 个丢失)。让我们看看数据集结构的内部
#identify Object/Categorical values and Continuous values
ted_data.dtypes
Structure of dataset
这里的 name 列不包含任何数据分析所需的值。所以，我们将放弃这个专栏—
#Drop the name column
ted_data = ted_data.drop(['name'], axis = 1)
ted_data.columns
Ted Talk Column Data
我们还需要转换日期列值，以便在进一步的分析中更好地理解数据。日期列包含 Unix 时间戳格式的值，我们将把它转换成日期时间格式。
from datetime import datetime
def convert(x):
return pd.to_datetime(x,unit='s')ted_data['film_date'] = ted_data['film_date'].apply(convert)
ted_data['published_date'] = ted_data['published_date'].apply(convert)
ted_data.head()
Formatted Data
一些列包含字典和列表格式的数据。我们还不会查看这些列。但是我们还不会查看这些专栏，因为我们的目标是找出最受欢迎的演讲者，以及什么时候演讲发表得最多。
数据探索
1。热门演讲人
数据集中有一个持续时间列。让我们找出谁比其他演讲者讲的时间更长。
#Lets see who talked a lot - top 20
import seaborn as sns
ax = sns.barplot(x="duration", y="main_speaker", data=ted_data.sort_values('duration', ascending=False)[:20])
Speaker vs duration — who talked the most
以上情节表明，道格拉斯·亚当斯谈了很长时间。很多人不喜欢看较长的视频，除非它非常有趣。让我们看看这个演讲者有多少观点。
#Let's see which video got the most views
ax = sns.barplot(x="views", y="main_speaker", data=ted_data.sort_values('views', ascending=False)[:20])
Speaker vs views
在上面的图中，我们可以看到道格拉斯·亚当不在这里，但是很多名字都在这里。视图和时长有关系吗？有可能，我们来看看。
首先，我们将检查数据的分布，然后查看视图和持续时间是否相关/相关。
#let's see the distribution of views
sns.distplot(ted_data[ted_data['views'] < 0.4e7]['views'])#let's see the distribution of duration
sns.distplot(ted_data[ted_data['duration'] < 0.4e7]['duration'])
Views data distribution
Duration data distribution
我们来看看它们有没有关联？
ax = sns.jointplot(x='views', y='duration', data=ted_data)
View v/s duration
看来我们错了。与长短和持续时间没有关系。看看 p 值，相当低。
有评论栏，最受欢迎的视频可能会得到更多的讨论。但是在找到热门演讲人和他/她的视频之前，我们先看看评论和观点有没有关系？
sns.jointplot(x='views', y='comments', data=ted_data)
Views vs Comments
看上面的情节和 p 值，说明观点和评论有很强的关系。流行的视频往往有更多的讨论。
现在我们知道评论和观点使得 ted 演讲上的任何视频都很受欢迎。所以，让我们来看看谁是最受欢迎的演讲者。
ted_data[['title', 'main_speaker','views', 'comments', 'duration']].sort_values('comments', ascending=False).head(10)
Top 10 speaker(According to discussion on their talk)
看来我要去看理查德·道金斯的无神论演讲了。
2。月—脱口秀主持人最多的
现在我们想知道哪个月举办的 Ted 演讲最多。我们有 film_date 专栏，但我们没有每月组织一次讲座。我们可以很容易地获得这些信息，只需计算电影日期月份的条目数。
talk_month = pd.DataFrame(ted_data['film_date'].map(lambda x: x.month).value_counts()).reset_index()
talk_month.columns = ['month', 'talks']
talk_month.head()
Number of talks organized by months
不是很好，是吗？让我们将数据可视化。
sns.barplot(x='month', y='talks', data=talk_month)
Number of Ted talks in each month
看起来二月是举办 ted 演讲的最佳月份。所以，明年二月，我会准备好倾听人们的心声。虽然，我们可以根据年份进一步划分数据，但在这篇文章中我们不会涉及太多细节。
总结
正如我们从这篇文章中看到的，数据科学家甚至可以在应用复杂的机器学习算法之前对数据做些什么。EDA 是数据科学项目管道的重要组成部分，也是我认为最复杂和耗时的部分。在对数据做出决定之前，应该花时间去理解和探索数据。很多公司有时会问一些关于数据的问题，他们问的不是结果或最终产品，而是洞察力，或者我应该说是数据的故事。
参考
给我讲个故事:关于模型可解释性的思考
最近，我的思考围绕着感觉像是机器学习的一些最大的元对话:学习一个普遍智能的演员的潜力和局限性，算法公平性的细微差别和真正的规范挑战，以及现在，模型对人类来说是可解释和可理解的意味着什么。
随着思想市场被越来越多的---复杂架构充斥，似乎在所有这些层的重压下摇摇欲坠，呼吁可解释机器学习的声音越来越大。NIPS 在过去两年里主办了一个关于这个主题的研讨会，DARPA 正在资助一个可解释的人工智能项目，欧洲许多国家都在争先恐后地应对欧盟的新要求，即模型做出的任何“重大决定”都必须向用户解释。
Oh no! I think that heatmap of pixel importances is in the shape of a Grim
我发现这些争论通常分为三大类。
- 对模型稳定性的担心，以及检查脆弱或不正确的概括的愿望:这种心态主要是担心，在缺乏对模型决策进行反思的能力的情况下，它可能会以最终不适当的方式拾取模式。这方面的一个常见例子是一个模型，该模型了解到哮喘患者的死亡率较低，因为医院的政策是总是将这些患者紧急送入重症监护。当模型被用在关键场景中时，这种检查为什么模型知道它拥有什么的“原因”的能力是至关重要的。事实也是如此，因为这种模型经常由熟练的专业人员实施，他们对部署一个他们认为无法担保的系统感到不舒服。
- 希望可以从这些模型中提炼出新的知识:以给人类新的概念洞察力的方式:这主要是你从应用科学中使用机器学习的人那里听到的观点。在这里，可解释性被视为一种强大的附加值，因为如果我们可以将这些机器抽象转化为人类有意义的概念，我们就可以将这些概念编织到我们现有的知识网中，并使用它来推动更多的研究。
- 一种对我们所做的决定进行逻辑论证的权利感:这种感觉有点难以解释，但确实有一些情感上的显著性。这与关于机器偏见的争论有关，的确，许多从这个角度争论的人担心黑盒内的模型以我们社会认定不恰当的方式使用信息。但是，我认为这里有一个更广泛的公平概念:一个人应该能够在做出决定时要求理由的信念——贷款，缓刑听证会。当有人给你理由的时候，你可以抓住这些理由，潜在地反驳它们。当一个模型给了你一个不可接受的、不透明的决定时，我可以理解当你不能“为自己辩护”(如果有正当理由的话)反对所使用的逻辑时，你会有一种专制的感觉
为什么复杂性会降低可解释性？
冒着听起来迂腐的风险，为什么 ResNet 是不可解释的？它缺少什么根本素质？这个系统是一个完全确定的系统，一旦训练完毕，你就可以写出方程，将模型中的每一个量与其他量联系起来。我觉得这里根本缺失的一块，跟模型的缺点关系不大，跟人类认知的缺点关系更大。当我们“思考”时，我们需要有意义的概念作为思考的单位，我们通常需要抽象和概括这些概念——有些压缩——以便它们易于处理。给某人一个叙述化的散文解释与给他们三个充满重量的矩阵会导致非常不同层次的可解释性，因为我们不可能一次将这些矩阵中包含的信息保存在我们的大脑中。这激发了我认为可解释性中的一个关键思想:复杂模型的可解释表示几乎总是它的压缩表示。
这一概念，即概念在真正的可解释性中的必要性，提供了一个视角来解释为什么我们经常发现深度学习模型特别难“搜索”。当然，这部分归因于模型本身的架构。但我也认为，问题的一部分是深度学习在历史上对非常原始的输入数据最有效。作为对比，当您将经济普查数据作为输入要素时，根据定义，每个要素都代表一个对人类有意义的概念，因为因果链的方向是正在计算的要素，因为人类认为计算它是有意义和有价值的。对于非常原始的输入数据，您会遇到单个输入变量(在本例中为像素值)与概念不相关的问题；无论模型在多大程度上使用了更高层次的抽象，它们都是完全习得的抽象，而不是由人类输入系统的。每当有人执行神经元或层可视化时，你都会看到这种对意义的争夺，我们不可避免地试图附加人类概念——这一个是寻找眼睛，这一个是建筑物等——即使在某种程度上，我们知道期望机器抽象巧妙地嫁接到人类思想上有点被误导了。
有哪几种可解释性？
当阅读一篇旨在解决模型可解释性问题的论文——LIME、Shapley 值、神经元可视化等——时，我发现将其分为几类是很有用的
特性属性与内部逻辑:对我来说，最有意义的区别是试图给特性赋值的方法和试图阐明模型实际内部工作的方法。沙普利值和石灰是前者的例子。他们的主要目标是将模型的行为投射回一组输入要素(或人类创建的替代输入要素)，以某种方式为那些在模型的所有曲折过程中具有更大影响的要素分配更多权重。相比之下，层模板可视化等方法属于后一类:试图理解模型在达到最终答案的过程中创建的中间抽象。虽然在某种意义上他们都在追求“可解释性”，但我认为更广泛地为这些不同的可解释性子目标采用某种清晰的名称是有价值的。
通过模拟获得的知识与通过内省获得的知识:第二个更微妙的区别与给定的可解释性方法的目标无关，而是它用来得出答案的技术。基于模拟的知识意味着，我们通过生成某种形式的模拟数据，捕捉模型在这些数据点上的表现，并将其作为您的理解，来获得对模型的理解。这与上述轴的方向略有不同，因为 LIME(在本地模拟数据样本，也使用本地内核)和神经元可视化(在数字上优化像素，以将内部状态推至高激活值)都属于这个等式的“模拟”侧。相比之下，通过内省获得的知识来自于获取模型的固定方面，并使用它们来获得知识，而不必进行这种模拟。第二种类型的一些示例是线性模型中的基本特征重要性(其中线性和固定项数意味着您可以通过分析计算 FI)，以及随机森林总体中的基尼系数减少特征重要性，因为这两者都只是训练模型的属性。不过，总的来说，我认为后一类方法不太适用于更复杂的模型，因此大多数较新的论文属于前一类。
构建一个我们并不完全理解的系统的想法——暗示着可能无法完全控制——基本上是傲慢的同义词，这是最近对复杂模型的建模者经常提出的指控。而且，虽然这种对人类可以理解的解释的渴望偶尔会从技术角度感到沮丧和勒德派风格，但我确实认为有令人信服的原因——最突出的是关于采用信任和测试内部表示的脆弱性——为什么这仍然是一个富有成效的研究领域。我的一个抱怨是，我认为我们把一系列期望的目标和潜在的动机混为一谈，这使得我们在这个问题上的讨论更加模糊不清。
区分人工智能和人类#1:人类 VS 人形机器人
ALife 2018 conference, © Lana Sinapayen
在一个视频中，人们认为一个人实际上是一个超现实的机器人，受此启发，我决定写一篇关于如何识别人形机器人的文章。这里有几个小技巧！
在花了这么多时间研究 Alter Android 和各种超现实机器人之后，我对你面对的是一个机器人而不是一个人的迹象略知一二。上面的视频是一个人类。这是机器人圣坛，由石黑浩实验室建造，由我的博士实验室 T2 池上实验室编程。
我们还远远不能制造出真正像人类一样的机器人；目前的技术还没有先进到足以愚弄一个 6 岁的孩子，让他认为机器人实际上是一个人。有趣的是，目前存在的动作最流畅、最无缝的机器人看起来一点也不像人类:它们要么是制造你的汽车的工厂机器人，要么是著名但非常像机器人的波士顿动力公司的生物。如果你认为一个机器人看起来像人类，它很可能是人类。在寻找下一个“非凡机器人”视频吗？这里有 6 点需要记住。
1.不要相信图片，找视频。看看机器人的皮肤，尤其是脖子。机器人皮肤扭曲不良，做 flappy 包。
2.注意关节。在上面的视频中，女子整个手臂都在摆动，而不仅仅是肘部以下的部分。机器人真正一次移动一个关节的能力暴露了他们。
3.寻找未完成的动作。她开始半眨眼。机器人的动作缓慢而谨慎。他们在光速下不会眨眼。
4.眼皮。机器人的眼睑通常是硬塑料。它们需要滑入眼睛的顶部。你总会在那里看到一条深深的线。
5.反射运动。她把注意力集中在摄影师以外的东西上。她有很多不自觉的眼跳。
6.最后，寻找完美。没有机器人能如此好地聚焦在它们面前的物体上。没有人能笑出美丽的笑容(即使是假笑)。
回到圣坛。再看一遍那个视频:Alter 有柔软的眼睑，但是看看他脖子的皮肤，他的手腕和肘部的运动。当然，Alter 是为了展示它的框架和机械部件而建造的……但是当你看到任何一个石黑实验室机器人时，请记住这个建议。
区分人工智能和人类#2:照片与 GAN 生成的图像
如果你错过了这个系列的第一集，人类对机器人在这里。
受生成性对抗网络(GAN)的推动，一年前我在推特上发了一条关于区分相机拍摄的图片和生成的图片的帖子。这里是该线程的更新版本。我的一些建议仍然适用。谁知道会持续多久？趁热吃吧。
自第一篇 GAN 论文发表以来的几年中，已经有了许多进展，导致了越来越好的“假”图像。GANs 是在成千上万张真实图片上训练的神经网络，目的是产生完全虚构但看起来像真实图片的图像。
不完全是人类。
我们的贝恩斯特别擅长识别人脸，这是你最有机会发现一个甘的类别。请记住，下一次播放紧张的音乐时，你必须选择哪个是你最好的朋友，哪个是邪恶的替身。
寻找透视问题:眼睛看向不同的方向，眼睛向前看，但脸转向一侧，或者在这种情况下，毕加索对称性:我们不应该看到那个人的左耳…
化妆的女性有时更容易发现对称问题。只有一只眼睛画了眼影，眉毛的形状也各不相同……当然，下面的女性有更紧迫的问题，但她们也有非常原始的妆容——一只熊猫眼，一条缺失的眉毛，不同颜色的眼睑↓
即使是最新的 GANs 仍然很难处理这些问题。
可疑的模糊。
旧的网络往往在帧的四个角有强烈的失真，导致奇怪的模糊世界。对于较新的网络来说，这不是问题，但模糊性以不同的方式表现出来:GANs 最典型的特征，即从一个图像平滑地变换到另一个图像的能力，也是它们的弱点。
暂停在上面 gif 的任何地方。你能说出脸和头发从哪里开始，到哪里结束吗？通常他们只是融入到另一个人的头发或脸上。跟随物体的轮廓，检查是否一切都像它应该的那样清晰，如果部分没有融入其他部分。
有时是…一些不同的东西。
Oh no
外星剧本。
詹妮尔·谢恩说对了，甘斯不会写。他们得到了文字在标签上，数字在钟面上的概念，但有些东西不太对。下面的图片来自与上面相同的论文。
The price of gas will drive you nuts
My favorite brand of not-quite-round golf balls.
无关的一切。
甘斯不会数数。最多两个就可以了:两只眼睛，两只手…除此之外，所有的赌注都取消了！
这个帖子很棒，我邀请你阅读每一条推文。
高分辨率图像。
这一点源于一个非常基本的事实:在计算机上运行 GAN 算法是一件痛苦的事情。它们需要特定的硬件，并且需要几天时间在数据集上进行训练。他们天生贪吃计算时间和资源，因此通常被训练生成小的、低分辨率的图像。如果图像小而模糊，也更容易蒙骗人眼。如果你觉得活泼，常见的尺寸从 64x64 到 256x256 像素不等；有时更多一点。
— —
我希望你对识别假货感觉好些——在大多数情况下，photoshop 仍然比 GANs 更令人担忧。但是甘更有趣！这只蜘蛛同意了。
区分人工智能和人类#3:文本和幽默
如果你错过了这个系列的前几个装置，在这里了解一下人类和机器人的区别和照片和生成的图像。
在本帖中，我们攻击自动生成输出的最古老的形式之一:文本。对许多人工智能研究人员来说，给计算机编程以生成类似人类的文本是一个圣杯，这不仅是因为图灵测试，还因为围绕语言存在的神秘性。包括科学家在内的许多人都喜欢用近乎宗教的术语来看待语言——在你所选择的上帝的创造物中，语言会让人类“凌驾”于其他生物之上，这是一种神秘而神奇的东西，让我们变得特别(因此更优越，这是逻辑)。想象一下，如果你能创造一个会说话的机器人，你会变成什么样！
无论你是在寻找让你比你的宠物狗更好的东西，还是对语言本身感兴趣，文本生成算法都是无尽的乐趣。目前没有算法可以理解人类的话(不，甚至谷歌机器翻译。尤其不是谷歌机器翻译！).目前没有算法有足够的真实世界的经验来知道字母“椅子”应该是什么。最好的语言处理算法是那些可以计算诸如“R 完成 CHAI 序列而不是 O 完成相同序列的可能性有多大？在法语文本中，CHAISE 翻译的字母 CHAIR 的频率是多少？”。这是一个非常不同的过程，当你读到“椅子”这个词时，你会立即想到椅子是什么样子，以及它是如何使用的。
知道算法不理解意义是你需要辨别一段文本是由机器人还是由人类生成的最重要的事情。人类可能会犯错误，但它们是人类的错误:句法、语法……计算机错误是意义上的错误。这正是它们如此有趣的原因。让我们转向我最喜欢的神经网络幽默来源:詹妮尔·谢恩。
詹妮尔·谢恩用她能找到的任何有趣的数据来训练网络。以下是生成的 cookie 配方的示例:
我觉得很精彩！也是剖析典型神经网络错误的绝佳例子。
- 重复:这里使用的特定模型具有短暂的记忆。这意味着它不跟踪它以前写的超过几个单词或几行的东西。它会经常重复自己。毕竟，如果它知道“一杯糖”在食谱中出现的概率很高，并且记忆短暂，它就没有办法理解食谱中没有 6 杯糖，也没有办法跟踪它已经写了多少杯。它还会忘记在食谱中使用所有这些杯子。
- 忘记标点符号:网络可能很难学习跨越长时间尺度的关系。例如，括号需要在打开后的某个地方关闭。这比短期规则难学多了，比如“一个大写字母紧跟在句号之后！”所以最后你会看到永久的左括号、引号等等。
- 混淆的标点符号:在普通文本中，大写字母出现在句号之后，但有时也会出现在句子中间:地名或人名。有时候大写字母在名字中间！但是网络无法理解普通单词和名字之间的区别。都是字母。所以它会随机放置大写字母，因为从统计上来说，你时不时需要一个大写字母…
- 最明显的迹象表明你正在和一个网络打交道。大多数时候，一个训练有素的网络会使用现有的单词。但是，接受过字母训练的网络对“单词”没有很好的概念。是一组字母，周围有两个空格吗？好吧，那“Mapkamares”怎么样？我看不错！一些网络从一开始就接受完整单词的训练。给他们一个单词列表，以及只包含这些单词的文本。这些网络无法组成随机的单词，但它们仍然会在意义和标点符号上挣扎。
这里还有两个来自我自己的机器人的例子。第一个是纽约餐馆菜单的培训:
注意重复、随机大写和左括号。巧克力片肉汁和外套。
第二个是我在自己的推特档案上训练的机器人:
文字还可以，但是意思就是有点太奇怪了，不像真的。与这个“我强迫了一个机器人…”迷因相比。
这可能是人类的幽默，但不是神经网络幽默。剧情太一致，意思太平实，大写太对，语法太完美。幽默来自对意义的高度理解。很难像机器人一样写作，正是因为机器人远非人类。
完全披露:我对这种喜剧有两个理由。首先，人类以一种不明显虚假的方式伪装成机器人伤害了我的研究领域。大多数人根本不知道这些是人类写的，也不知道有什么先进的算法可以产生这种类似人类的幽默。他们告诉我，“你见过这个机器人吗？太搞笑了！”或者“我不确定这是不是真的，你怎么看？”任何混淆计算机能做什么和不能做什么的东西对我的领域来说都是一种威胁。人们提高了他们的期望，并将算法视为银弹，一个可以在眨眼之间做任何事情的魔盒。当有人真的制造出一个具有人类幽默的机器人时，谁会理解其中的含义呢？当外行人期望高水平的输出在我们的能力范围之内时，谁来解释为什么最先进的输出看起来像是乱码垃圾？第二个问题:如果你说“这是我写的”时，你的喜剧并不好笑，如果整个机器人的事情是人们发笑的唯一原因，也许它一开始就没那么好笑。
让我们来看一个更难的例子:
这让我哭笑不得，当它第一次出现。然而，这个场景的时间线是不是有点太一致了，标点符号是不是太好了？
Botnik 工作室有一种不同的生成文本的方法。是的，在某个地方涉及到了算法，但它是一个人写的文本。电脑只是提出建议，就像你手机的自动更正功能；但最终，是人来决定写什么。你可以在https://botnik.org/apps/试试(可惜经常宕机)。
那么，我怎么知道其中涉及到一个算法呢？可能需要一些训练来确定你的判断，但是如果你发现自己不断地问“我错过了什么吗？”，想知道为什么事情会发生，或者必须使用大量的想象力来使场景工作，这是一个很好的机会，你正在阅读算法的散文。这就是神经网络幽默的核心:当文字实事求是地在你的脑海中创造出一个极其荒谬的场景时，当大多数喜剧作品不是由文本而是由你的大脑生成的图像完成时，这就是你知道你有一个神经网络来感谢这些笑声的时候。
我给你留下三个链接供你欣赏。遇见 inspirobot 及其励志名言:
Inspirobot 在美国生活中亮相。
看一部科幻电影，其中每个人都尽了最大努力来遵循机器人编写的场景:
并在 J anelle Shane 的博客上找到真正的神经网络幽默的无穷乐趣。
用数据讲故事是新的商业智慧
每隔几个月，我就会把它转寄过去，作为一名导师，与“女性无限”的一群了不起的女性一起工作。如果你不熟悉这个组织，你应该去看看(【https://www.women-unlimited.com】T2)我很幸运地成为了“领导”项目的毕业生，它对我今天的领导技能产生了重大影响。
上周，我们像往常一样讨论了商业头脑。我喜欢这一点，因为我知道确保我们辅导的女性能够陈述清晰的业务案例并有效地使用业务语言是多么重要。他们还需要能够回答棘手的问题，并获得在工作中取得成功所需的资金和赞助。
这次会议真的让我思考商业敏锐度的技巧以及它是如何在这些年里发展的。
我曾经认为，如果我能有效地阅读资产负债表，我会成为一名更好的女商人。我真的认为那些为我们的业务构建和管理这些的财务人员是不可思议的。(好吧，我仍然有点认为他们是)。
但是今天，事情发生了变化。资产负债表只是数据点，除非你能围绕这些数据讲述一个故事，让它变得生动，给它一个视角——这只不过是报告数字而已。
对于大多数公司来说，财务团队对业务有很大的影响力，为什么呢？他们有关于这个行业的所有数据。
但他们真的会吗？
收入并不总是说明全部情况，在那次会议上，我真的受到了打击。我相信今天最有商业头脑的是那些能拿数据(比如营收)、能搜索其他数据点 并讲故事的人。
是的，编制资产负债表的人当然非常聪明，但他们能站起来讲一个关于公司整体健康和前景的故事吗？他们能谈论增长和采用吗？也许，如果他们拥有用数据讲故事的神奇技能。
另一个有趣的事实是我的朋友大卫·麦吉森在 CDO 峰会上谈到的一个趋势。这是他实际上正在跟踪的一个趋势。几位首席数据和数字官将被任命为首席执行官，并在他们的公司中担任最高职位。事实上，每年都越来越多。仔细想想这是个有趣的趋势。这些角色取决于他们用数据讲述故事的能力，很明显，这对于那些高层领导来说是非常重要的。
我相信，CDO 们正在让首席财务官们为了钱去争第一。
这些新领导者的秘密武器很简单——利用#数据和#分析。他们所做的一切都是由数据驱动的，结果是用数据衡量和验证的。一切都是关于数据和分析，并利用这些来讲述故事、交流和真正了解他们的客户。
你可能会问自己——除了收入，还有哪些数据点真正重要？好吧，让我们稍微探索一下…..
对于许多以客户为中心和数据驱动的公司来说，NPS 正迅速成为一个关键数据点。事实上，NPS 可以讲述一个比资产负债表更具前瞻性的故事。对于 IBM Analytics 的我们来说，它以我们从未预见到的方式改变了我们。我们每天都更加了解客户的挑战和成功。是的，我说每天。我们每天都做出反应，更快地解决问题，获得惊人的反馈，更快地取悦客户。NPS 以一种资产负债表永远做不到的方式影响了我们如何制造产品、支持产品、走向市场和与客户打交道。
“积极使用”是另一个有趣的衡量标准。如果你的目标是让你的产品对客户来说是必不可少的，那就用他们使用你的产品的多少来衡量。想想脸书，他们的目标是用户数量以及我们每个人在脸书上花费的时间。他们所做的一切都是为了实现这些目标——包括那些令人疯狂上瘾的游戏，迫使你登录才能玩(还记得黑手党战争和那个疯狂的农场游戏吗？).不用说，它奏效了，现在大多数人都把时间花在了脸书身上。现在，如果脸书仅仅关注收入，他们可能不会达到这个目标。我相信如果你有一个积极使用的好基线，你监控它，发展它，真正倾听它告诉你什么-那么收入就会随之而来。
嘿，我们生活在“大数据时代”,我们不缺乏数据，如果你想成功，就使用这些数据，让它对你说话，告诉你公司内部的故事，告诉你的股东和风投。我们的董事长在这方面做得非常出色，她是如何领导 IBM 转型的。我认为这是一项重要的领导技能。
是的，对我来说，用数据讲故事是新的商业智慧，他们说“讲故事的人统治世界。我相信他们！
你怎么想呢?
临时表与变量表— SQL 数据准备
Image by Markus Spiske on unsplash.com
数据科学的很大一部分是数据准备，确保我们使用的数字是有效的，格式是正确的，并且能够有效地准备和访问。我花了大量时间在 SQL 上，从许多来源收集数据，并将它们从堆积的表中汇集到可访问的数据立方体中，这些立方体是自动准备的，具有引用完整性，并且在几秒钟而不是几小时内运行！我遇到和读到的一个概念是临时表和变量表。我认为总结我发现的一些要点是值得的，希望对你们有些人有帮助！
作为一名商业智能顾问，我的主要工作是与公司合作，继承他们现有的程序/视图/工作，然后对其进行逆向工程，以改善处理时间、数据准确性和故障率。有时小的变化可以带来巨大的好处，所以理解 SQL 的一些核心概念是如何真正工作的是非常宝贵的，即使你的重点是高级分析和机器学习。
继续吧！
如果你花了很多时间使用 SQL 和阅读其他人的代码(如果你自己没有使用过的话),那么临时表和变量表是名称前面分别带有#和@符号的表。这两个选项都允许您像存储存在于任何一个数据库中的永久表一样存储数据。下面列出了每种方法的一个例子。
-- This is a variable tabledeclare @VariableTable as table([ID] int,[Name] varchar(100),[Description] varchar(500))-- and this is a temporary tableCREATE TABLE #TemporaryTable([ID] int,[Name] varchar(100),[Description] varchar(500))
现在我们有了两个表，insert 语句可以用来填充这两个表。
INSERT INTO @VariableTableSELECT [ID], [Name], [Description]FROM [PermanentTable]INSERT INTO #TemporaryTableSELECT [ID], [Name], [Description]FROM [PermanentTable]
到目前为止，它们都很容易创建和填充。现在是有趣的部分了…它们有什么不同。
坚持
首先，变量表只存在于正在运行的批处理中，一旦查询执行完毕，数据就消失了。然而，临时表是“持久的”,这意味着在运行查询后，您可以检查表中的数据。这在调试复杂过程时非常有用，因为您可以运行查询，如果它没有返回您期望的结果，您可以查看任何/所有临时表中的数据，看看哪里出错了。
数据量
可变表仅设计用于保存少量数据。另一天的概念涉及执行计划，例如，存储过程用来优化查询的性能。SQL 中的执行计划假设一个变量表有一行数据，而它们通常用于存储数万行数据。这可能导致低效的计划和不必要的长时间运行。
分度
就其本身而言，临时表和变量表对于各种任务(插入、更新和删除等)具有不同的性能水平，但是一个关键的性能差异是向临时表添加索引的能力。这对于变量表是不可能的，这意味着任何时候你从变量表中访问数据，它都存在于一个“堆”中。
索引的工作方式就像你在图书馆遇到的索引一样。你的选择(除了问图书管理员)是走到最近的书架前，开始阅读书名，直到你找到你要找的书，或者你可以使用目录。目录会给你一个与书的位置相对应的号码，这样你就可以走到一个特定的书架，并且(希望)在找到你要找的书之前只浏览几本书。SQL 以同样的方式运行，如果数据存在于一个堆中，SQL 将简单地从数据的顶部开始运行，直到找到相应的记录。如果有索引，它将跳转到您所在的行所在的数据部分，这大大减少了它需要读取的行数。下面是对[ID]列的简单索引的示例。
--example index statement
create index idx_temp on #TemporaryTable ([ID])
索引是一个巨大的主题，非常值得花时间去研究。它们带来了额外的开销，但是根据我的经验，从表中选择数据的好处要大得多。
对于感兴趣的人来说，一些有用的主题包括堆和聚集表、表扫描和查找以及聚集和非聚集索引。对这些有一个坚实的理解将极大地提高您的数据库的性能！
我更喜欢哪个
尽管变量表有它的好处，特别是对于少量的数据，我通常坚持使用临时表，因为我发现它们更有用。持久性差异意味着当您完成时应该‘丢弃’(删除)表，这与变量表相比是一个额外的步骤。在这一点上，我仍然喜欢花额外的时间来准备我的代码，因为我知道最后的过程会更有效。
当我开发一个新的过程时，有时我会忘记在重新运行之前删除临时表，这会导致执行失败。如前所述，需要先删除该表，然后才能重新创建它。通常，我会在临时表上方添加一条语句，该语句会删除该表(如果它存在)并重新创建它。这省去了执行失败的麻烦，但保留了其他好处。下面是这个“check”语句和“drop”语句的例子。
--Example 'check' statement
IF OBJECT_ID('tempdb..#TemporaryTable') IS NOT NULL DROP TABLE #TemporaryTable--Example 'drop' statement
drop table #TemporaryTable
希望这是有用的。这绝不是详尽无遗的，我相信你们中的许多人会有更多的细节来补充这个话题。我期待着阅读您的回复！
基于递归神经网络的温度预测
试图预测未来一直是男人的遐想。当我们看到达伦·阿罗诺夫斯基导演的电影《圆周率》中的数学家伙陷入混乱时，这似乎是一个非常糟糕的主意；也就是说，直到递归神经网络来拯救。
Max analyzing the stock market
值得庆幸的是，与股票市场相反，季节性气候条件遵循一种自然模式。这里我们讨论一个可能解决 Max 问题的潜在工具；或者可能没有，因为它没有提供关于数字圆周率的神圣属性的线索，这是一个在电影中从未得到充分解释的谜。
传统的神经网络受到消失梯度问题的困扰；也就是说，灵敏度随时间呈指数衰减。对于从连续的时间相关数据中收集重要性来说，这是个坏消息。为了解决这个问题，你可以使用 LTSM，或 GRU，或类似的神经网络衍生工具，利用长期的依赖关系来保持头脑中的大画面。
每小时记录 14 个不同的量(包括气温、气压和湿度)。原始数据可以追溯到 2003 年，但我们为这次比赛使用了一个子集，从 2009 年到 2016 年(含)。这本质上是一个多变量回归分析，因此变量之间的相关性很重要，为此我使用 Seaborn 来制作一个热图，以便简单地可视化。似乎大多数都是高度负相关或正相关，这使得预测模型有效。
Correlation heat map
然后，数据被分割成 24 小时窗口，然后根据预先指定的日期和时间进行解析，以创建训练和测试集。后来，标签的大小变得有点短，所以我将开头连接到结尾，以匹配训练集的大小，因为温度是及时的，这种方法匹配自然会发生的事情。我们必须记住将变量调整到 0 和 1 之间，以便它们一致地适合回归模型。需要从 2D 到 3D 的矢量整形，因为循环网络想要知道它工作的时间范围，在这种情况下是 24 小时。
我决定在最后的神经网络架构中使用 3 个卷积层，然后是 3 个 GRU 单元，然后是一个密集层。GRU 是一种时间敏感架构，使用更新门和复位门。决定应该输出什么信息的两个向量。他们可以被训练保留很久以前的信息，而不会随着时间的推移而稀释。更新门决定保留多少过去，重置门决定遗忘多少过去。
GRU cell
这种架构从头到尾都有 0.25 的压降，因为我发现否则它会由于捕捉的细节量而很快过度拟合。最终密集(分类)层的激活函数必须是“线性”函数，因为这本质上是复杂的线性回归。
在编译和运行模型之后，模型是如何随着时间的推移而改进的:
Loss over time
它相对较快地收敛到大约 0.02。总的来说，这是一次相当成功的实验。
试图预测未来是个好主意吗？似乎没有对黄金比例的神圣理解，或者其他超自然的洞察力，预测永远不会是 100%，特别是对于像股票市场这样的人造系统，尽管马克斯可能不同意。值得庆幸的是，自然是比较一致的。出于实用目的，这个模型对于捕捉天气模式中的异常、捕捉黑天鹅事件(如极端天气事件)非常有用。
人工智能在金融科技中的十大应用
几周前，我作为 Swish 的机器学习负责人，参加了 Fintech 论坛(蒙特利尔)。
在两场讲座和精彩的讨论之间，我举办了一场研讨会，讨论人工智能在金融科技行业的应用。
如果你参加了研讨会并想要更多，下面是一个更长的版本，有例子和技术解释。如果你没有机会参加这个研讨会，这个分析将为你提供你应该知道的关于金融行业人工智能的一切。
Fintech？
金融业以极大的兴趣关注着技术进步。摩根大通等大银行是区块链等颠覆性技术的早期采用者。
人工智能(AI)是一种范式转换技术，它正在无缝改变我们的生活、移动、互动和购物方式。金融也不例外，行业才刚刚开始见顶的冰山一角。
金融科技(Fin-tech)是对金融行业尖端技术使用案例的称呼。
在本文中，我们将介绍人工智能的十个应用，以及这项技术的一个细分领域，即金融科技中的机器学习。
个人金融和保险人工智能
#1.数字金融蔻驰/顾问
交易型机器人是人工智能中最受欢迎的用例之一，可能是因为应用的范围如此广泛——跨越所有行业，在几个层面上。
在金融领域，交易机器人可以用来为用户提供金融辅导/建议服务。
把它们想象成帮助用户管理财务计划、储蓄和消费的数字助手。这种服务增加了用户参与度，并改善了用户对他们正在交互的金融产品的整体体验。
数字助理可以使用自然语言处理 (NLP)来构建，这是一种机器学习模型，可以处理人类语言格式的数据。可以添加产品推荐模型层，允许助理基于算法和人类用户之间发生的交易来推荐产品/服务。
Sun Life 已经部署了这种应用程序的一个例子，它创建了一个虚拟助理 Ella T1，通过允许用户掌握自己的保险计划来帮助他们获得福利和养老金。该助理根据用户数据向用户发送提醒，如“健康福利即将到期”或“您的孩子将很快失去福利”
数字助理还可以用于其他与金融相关的场景:股息管理、定期寿险续期、交易限额临近或支票兑现通知。
#2.交易搜索和可视化
聊天机器人也可以用于银行业，专注于搜索任务。
管理人员向 bot 提供对用户交易数据(银行交易)的访问，它使用 NLP 来检测用户发送的请求的含义(搜索查询)。请求可能涉及余额查询、消费习惯、一般账户信息等等。然后，机器人处理请求并显示结果。
美国银行使用这样一个机器人(名为艾丽卡)作为他们客户群的数字金融助理。人工智能机器人很快被采用——三个月内有一百万用户。
该机器人提供用户友好的交易搜索，使用户能够在他们的历史数据中搜索与特定商家的特定交易，避免他们在每个银行对账单中查找这些交易的麻烦。该机器人还计算信用和债务总额，这是一项用户必须自己在计算器上完成的任务。
#3.客户风险概况
银行和保险公司工作的一个关键部分是根据客户的风险评分对他们进行分析。
人工智能是一个很好的工具，因为它可以根据客户的风险状况从低到高自动对客户进行分类。
在分类工作的基础上，顾问可以决定为每个风险状况关联金融产品，并以自动化的方式向客户提供这些产品(产品推荐)。
对于此用例，分类模型，如 XGBoost 或人工神经网络 (ANN)根据历史客户数据和顾问提供的预标记数据进行训练，这消除了数据引起的偏差。
#4.核保、定价和信用风险评估
保险公司提供承保服务，主要是贷款和投资。
人工智能驱动的模型可以对客户的信用风险进行即时评估，然后让顾问制定最适合的报价。
将 AI 用于承保服务提高了提案的效率，并改善了客户体验，因为它加快了此类操作的流程和周转时间。
加拿大金融服务集团宏利是该国第一家将人工智能用于承保服务的公司，这使得“许多加拿大人可以更快地购买基本人寿保险，这是解决加拿大‘保障缺口’的关键。”
保险公司使用一种特定的 AI，人工智能决策算法 (AIDA)，该算法根据以前的承保方法&支出进行训练，可以有不同的分类过程，如大额损失支出或价格。
这种方法的应用不限于保险业；它也可以用于贷款的信用评分。
#5.自动化索赔流程
众所周知，保险业按照一个标准流程运作:客户购买保险，并为此付费。如果客户遇到问题(健康保险中的疾病、汽车保险中的车祸、房屋保险中的水损坏)，她需要通过提交索赔来激活她的保险范围。这个过程通常是漫长而复杂的。
事务型机器人可以将用户体验转化为更愉快的过程。
随着图像识别、欺诈检测和支出预测的增强，整个用户之旅得到了升级-更少的摩擦、更少的公司成本、更少的运营任务(呼叫、背景调查)以及更少的错误。整个过程花费的时间更少，对客户和保险公司员工来说都是无缝体验。
机器人所做的是负责整个周期:它以对话的形式一步一步地引导客户完成整个过程。
Swishbot, a transactional bot we built from scratch, can be used by an insurer for their customers
它要求视频或照片的损害，并上传到数据库。它包含处理索赔所需的所有信息。然后，该机器人可以通过欺诈检测方法运行应用程序，寻找异常和不符合要求的数据。
然后进入调整模型，提供一系列的支出值。一旦设置好所有数据，就可以出于审计目的进行人工干预。机器人可以在这一点上计算和建议支出金额，基于支出预测模型，它已经被训练。
这个应用程序是一个三合一的机器学习解决方案，有可能缓解行业中的一个高痛点。
这是纽约一家保险初创公司 Lemonade 的使命。在他们网站的主页上，他们要求用户“忘记你对保险的了解”，明确宣布他们通过使用人工智能给该行业带来的颠覆。该公司自 2015 年成立以来已筹集 1.8 亿美元。
To be able to start fresh, one has to forget
在 这篇分析 中阅读更多关于 AI 在保险行业的应用。
跨行业
#6.合同分析器
在金融行业，合同分析是一项重复性的内部任务。经理和顾问可以将这一日常任务委托给机器学习模型。
光学字符识别 (OCR)可用于数字化硬拷贝文件。然后，具有分层业务逻辑的 NLP 模型可以高速解释、记录和修正合同。
业务逻辑是一种条件格式，类似于 Microsoft Excel 中的格式。可以将公式添加到模型中，例如“如果选中了此框，则此框应该为空。”该模型可以在现有合同上进行训练，并学习如何处理这些内容。
在这种情况下，由于合同的重复性，模型结果的准确性非常高。
JP 摩根已经利用了这种人工智能应用的力量，仅在几秒钟内就将员工的工作量从 360，000 小时(每年)中解放出来。
这些解决方案支持与合同相关的分析，而总部位于区块链的智能合同(smart contracts)正在被更广泛地采用，它是对合同管理的一种范式转换升级。
#7.流失预测
流失率是所有行业和企业的关键 KPI。公司需要留住客户，要做到这一点，预测即将到来的客户流失对采取预防措施非常有帮助。
AI 可以通过提供一份显示出考虑取消保单迹象的优先客户名单来支持经理完成这一使命。然后，经理可以相应地处理这个列表:提供更高程度的服务或改进的产品。
在这种情况下，模型是基于客户行为数据的流失效应的解释变量。Explainer 变量可以是报表被下载的次数、用户阅读账户政策的发生、对时事通讯和邮件的退订以及流失行为的其他指标。通过处理消费者数据，银行可以通过采用他们的产品和定价来更好地为他们服务。
所使用的模型是一个分类模型，该模型根据已经取消其保单的客户和在考虑离开该机构后仍然保留的其他客户的历史数据进行训练。
一篇关于银行业客户流失预测的研究论文显示了消费者研究相对于大众营销在这一特定行业中的重要性:
大众营销方法不能在今天多样化的消费者业务中取得成功。客户价值分析和客户流失预测将有助于营销计划瞄准更具体的客户群体。
#8.算法交易——你永远不会看到的最先进的 ML。
算法交易的大多数应用都是在投资银行或对冲基金的闭门造车中进行的。
交易通常是为了快速分析数据和做出决策。机器学习算法擅长分析数据，无论其大小和密度如何。
唯一的先决条件是有足够的数据来训练模型，这是交易所拥有的丰富数据(市场数据，当前的和历史的)。
该算法检测通常难以被人类发现的模式，它比人类交易者反应更快，并且它可以根据从数据中获得的洞察力自动执行交易。
这种模型可以被寻求基于快速价格运动的短期交易的做市商使用。这种操作是时间敏感的，模型提供了所需的速度。
这方面的一个例子是交易个股与标准普尔 500 指数的价格变动，这是一个已知的领先指标(即股票跟随指数)。该算法从指数中提取价格变动，并预测个股的相应变动(例如:苹果)。然后立即买入(或卖出)股票，并在预测水平下限价单，希望股票达到该价格。
#9.增强的研究工具
在投资金融领域，很大一部分时间花在了研究上。新的机器学习模型增加了给定交易想法的可用数据。
情绪分析可用于对公司和管理者的尽职调查。它允许分析师浏览大量文本数据(如新闻或金融评论)的语气/情绪。它还能让你深入了解经理如何反映他们的公司业绩。
卫星图像识别可以让研究人员洞察许多实时数据点。例如，特定位置的停车场交通(例如，零售店)或海洋中的货船交通。从这些数据中，模型和分析师可以获得业务洞察力，如在上述零售商的特定商店购物的频率、运输流量、路线等。
先进的 NLP 技术可以帮助研究人员快速分析公司的财务报告。抽出公司最感兴趣的关键话题。
其他数据科学技术也可以格式化和标准化财务报表。
#10.估价模型
估价模型通常是投资和银行业务的一般应用。
该模型可以使用资产周围的数据点和历史实例快速计算资产的估值。这些数据点是人类用来评估资产的(例如:一幅画的创作者)，但是模型通过使用历史数据来学习将哪些权重分配给每个数据点。
该模型传统上用于房地产领域，可以根据以前的销售交易对算法进行训练。对于金融公司，它可以使用财务分析数据点、市场倍数、经济指标、增长预测；都是为了预测公司/资产的价值。
此类模型被投资银行团队用作内部工具。
这是人工智能在金融科技领域的应用综述。这项技术每天都在发展，而且这个列表还会继续扩大。目前，采用人工智能的金融公司将改善其运营、营销、销售、客户体验、收入和交易质量。
如果你想阅读更多关于我从事的机器学习和人工智能项目的信息，可以看看Swish Labs的故事。
作者科尔宾·哈德森，原载于【www.swishlabs.com】T21
