TowardsDataScience 博客中文翻译 2019（五百一十三）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

Polynote 的第一手体验——数据工程师的最佳笔记本

原文：https://towardsdatascience.com/trying-polynote-from-netflix-a-better-notebook-for-data-engineers-5107277ff2e5?source=collection_archive---------21-----------------------

网飞最近宣布了 Polynote ，这对致力于 Spark 和 Scala 的数据工程师来说很有希望。有许多很棒的特性，包括

• Scala 的交互式自动完成和参数提示
• 将 Maven 存储库中的依赖项配置为笔记本级别的设置
• Scala 和 Python 代码在同一个笔记本中，变量在它们之间共享(也称为多语言)

让我们用 Spark 中一个经典的字数统计例子来试试 Polynote。在这个例子中，我们读取了来自网飞的 Polynote medium post 的文本，并用它用 python matlablib 绘制了一个字数统计条形图。代码可以在这里找到

装置

按照它的指南，安装过程非常简单。另外，我还安装了 matplotlib

pip3 install matplotlib

如果你打算尝试它的多语言特性(例如 Scala 和 Python 之间的共享变量)，你需要再包含一个环境变量:

export PYSPARK_ALLOW_INSECURE_GATEWAY=1

如果没有，您将会看到:

编辑经验

使用笔记本级别的“配置和依赖项”设置，可以很容易地配置从 maven 存储库中提取依赖项。让我们包含请求——Scala使用 HTTP get 从网飞的博客获取我们的文本。

数据工程师终于有了一种简单的方法，通过一个集中的 maven 资源库，向笔记本用户共享他们用 Scala 或 Java 编写的代码！

自动完成功能适用于从 maven 资源库中提取的库:

然而，lambda 函数的自动完成似乎还不能工作:

火花集成

在这个字数统计示例中，我们从 HTTP 获取文本，将其标记化，并保留所有长度超过 4 个字符的标记。

Spark 也可以通过“配置和依赖”设置轻松配置:

一个小问题是，spark 配置设置中至少需要一个项目，Spark 才能工作，这一点并不明显。

切换到 Python

现在，我们切换到 python，使用 panda 和 matplotlib 绘制条形图，只取前十个单词。

它神奇地起作用。但是，在使用 python 代码运行 cell 时，有时会弹出此异常:

当这种情况发生时，接口停止工作，唯一的解决方法是终止 Polynote 进程并重新运行它。

好了

Polynote 是我迄今为止试过的最好的 Spark 和 Scala 笔记本。有一些小故障，但我相信他们会在任何时间拉平。

我很高兴看到它如何在现实生活中发挥作用。例如，与 Kerberozied 化的 spark 集群集成，并以集群模式而不是独立模式运行 spark。也许在下一篇博客中会有更多的内容。

感谢阅读，编码快乐！

seq2seq 教程的调整版本

原文：https://towardsdatascience.com/tuned-version-of-seq2seq-tutorial-ddb64db46e2a?source=collection_archive---------7-----------------------

这是我对 seq2seq 教程的更新。这个帖子的代码可以在这里找到。本次更新的目的是教育:获得关于 seq2seq 模型的更深入的见解，并实现深度学习(和 pytorch)的一些最佳实践。非常感谢 fastai 的灵感。特别有用的是 nn 教程和 fastai github repo。代码用 python 3.7.1 编写(也在 python 3.6 上测试过)，使用 pytorch 版本 1.0.1.post2。

我应用的更改:

• 代码重构:分离数据管理和模型训练的类
• 单独的验证数据集。这提供了比训练数据更真实的模型性能图。训练损失/准确度将总是小于/高于验证集。如果没有验证集，您如何知道自己没有过度拟合？
• 标记化是多重编码
• 使用预训练单词向量的可能性
• 增加了老师强行
• pytorch 版本 1 的小代码更新。

现在让我们快速介绍一下 seq2seq，然后查看更新。

seq2seq 快速介绍

seq2eq 模型的介绍可以在原版教程中看到。在这里，我将给出非常简要的概述。Seq2seq 模型是由两个递归神经网络 (RNNs)组成的模型。其中一个将输入序列编码成上下文向量，另一个将其解码成输出序列(例如一种语言的句子到另一种语言的句子)。

Seq2seq scheme. Source

使用 seq2seq 的积极方面是任意长度的输入序列可以被“翻译”成任意长度的输出序列。从一种语言翻译成另一种语言通常比翻译单个单词更困难。输出序列可能比输入序列长或短。即使大小匹配，单词的顺序也可能不匹配。

seq2seq 学习的两个比较重要的概念是注意和老师强制。注意力帮助解码器“注意”输入序列的不同部分。这通常会提高模型性能，因为更细微的学习是可能的(仅使用编码的上下文向量会给学习所有细微差别带来沉重的负担)。我鼓励你去查阅原始的教程和谷歌来了解更多的细节。我将在下面的帖子中分享其中的一些。

数据管理

Pytorch 是一个很好的处理神经网络的库。但是它没有一种简便的方法来处理 sequence2sequence 数据集。这也是为什么我写了几个助手类用于数据管理的原因。逻辑很简单:Vocab处理词汇(记号和它们相应的数字 id),SeqData处理单边序列(例如英语句子),Seq2SeqDataset处理具有相应序列的序列(例如英语句子和它们的法语翻译),并使我的数据集符合 pytorch Dataset类。Seq2SeqDataManager是一个处理整体训练和验证序列创建和管理的类。这可以从下面的方案中看出。

这些课程完全是定制的。一个例外是继承自 torch Dataset类的Seq2SeqDataset。它必须实现方法__len__(提供数据集的大小)和__getitem__(支持整数索引)。与 pytroch Dataset类兼容有助于我们稍后实现数据加载器。原始教程没有使用 pytorch 类进行数据管理。

有时输入/输出序列可能很长，这可能会使他们难以学习。这就是为什么Seq2SeqDataset和Seq2SeqDataManager可以选择过滤出符合长度标准的序列。Seq2SeqDataManager发动机罩下的所有处理:

MIN_LENGTH = 3 #min nr of tokens in sequence so that 
#sequence is kept (otherwise removed) 
MAX_LENGTH = 15 #max nr of tokens in sequence so that 
#sequence is kept (otherwise removed)
MIN_COUNT = 3 #min count of token occurences so that it is not 
#transformed to <unk> tokendata_manager = Seq2SeqDataManager.create_from_txt('data/eng-fra_sub.txt','en', 'en', min_freq=MIN_COUNT, min_ntoks=MIN_LENGTH,                                           max_ntoks=MAX_LENGTH, switch_pair=True)

批处理，数据加载器

数据加载器有助于训练，它们从训练/验证数据中抽取样本，并将其转换成一批。批处理是一组用于训练/验证的序列。更清晰的解释见下图。

Process of turning batch of input sequence to training/validation tensor

从输入序列(句子)中，我们得到记号，并从中得到记号数字 id。然后，我们从最长到最短的序列对令牌进行排序，并用填充 id 填充较短的序列(在示例 0 中)。这是在数字化序列被转换成 pytorch 张量之后完成的。当前示例中的批量大小为 3(我们有 3 个序列/句子)。为了训练，我们转置张量(改变轴 0 和 1 的顺序)。在我们每行有一个序列之前，在转置之后，我们在一行中有每个序列的第一令牌 id。

标记化和数值化在初始数据准备期间完成。使用数据加载器将一批数据转换成张量并进行转置。DataLoader是一个 torch 类，帮助迭代序列。创建一个很简单，这是我的示例中的示例:

train_dataloader = DataLoader(self.train_seq2seq,
    batch_size=self.train_batch_size, 
    collate_fn=self._collate_fn)

这就是遵从 torch Dataset有用的地方:我们可以将它作为输入提供给DataLoader。第二个参数显示了我们每次运行需要多少个序列，而collate_fn是我们的自定义函数，用于将序列转换为转置填充张量。在我们的示例中，函数执行以下操作:

#this is a bit simplified from the one in github example
#[https://github.com/RRisto/seq2seq/blob/master/seq2seq/data/data_manager.py](https://github.com/RRisto/seq2seq/blob/master/seq2seq/data/data_manager.py)
def _collate_fn(self, data:list):
        #data is list of sequences (each list element is a list of 
        #input and corresponding output token ids, example:
        #[[[1, 2, 3, 4],[1, 3, 5]],
        #[[1, 2, 3, 4],[1, 3, 5]]] #sort sequences from longest to smallest using input 
        #sequence lengths
        data.sort(key=lambda x: len(x[0]), reverse=True) 

        #zip into separate input, output sequences
        input_seq, target_seq = zip(*data)

        #turn into tensors, pad and transpose and calc seq lengths
        input_tens, input_lens = self._to_padded_tensor(input_seq)
        target_tens, target_lens = self._to_padded_tensor(target_seq) return input_tens, input_lens, target_tens, target_lens

要获得数据加载器，我们可以使用Seq2SeqDataManager并查看第一批训练:

train_dataloader, valid_dataloader = data_manager.get_dataloaders() #lets see one batch from training data
next(iter(train_dataloader))

最后一行代码应产生类似于以下内容的输出:

(tensor([[ 25, 135,  25,  95,  41,   0,   0,   0,  96, 117],
         [  0, 163,   0,  29,   5,   5,   4,   5,   5,   5],
         [  5,   5,   5,   5,   3,   3,   3,   3,   3,   3],
         [  3,   3,   3,   3,   1,   1,   1,   1,   1,   1]]),
 tensor([4, 4, 4, 4, 3, 3, 3, 3, 3, 3]),
 tensor([[  0, 162,  74,  74,  14,  65,   0,  74,  48,  48],
         [  7,   7,   7,   7,   4,   7,   4,   7,   7,   7],
         [  3,   3,   3,   3,   3,   3,   3,   3,   3,   3]]),
 tensor([3, 3, 3, 3, 3, 3, 3, 3, 3, 3]))

第一个张量是输入张量(转置，由我们的collate_fn产生)，第二个是输入序列长度的张量，第三个输出张量和第四个输出序列长度的张量。

如您所见，我定制了数据处理部分，但是对于模型的数据输入，我使用了 pytorch 类。定制 pytorch 类非常方便(pytorch 文档非常有用)。这避免了从头开始编写所有内容(和一些调试),并且只定制 pytorch 中没有的内容。

学习者

为了管理编码器和解码器的初始化和训练，我创建了[Seq2SeqLearner](https://github.com/RRisto/seq2seq/blob/master/seq2seq/model/seq2seq_learner.py)类。基本上这个类初始化我们的 seq2seq 模型。创建很简单，您需要 data_manager 并指示隐藏层大小:

hidden_size=300
learner=Seq2seqLearner(data_manager,hidden_size)

在最初的教程中，事情有点松散(不是在函数/类中)，这使得处理它们更容易出错。[Seq2SeqLearner](https://github.com/RRisto/seq2seq/blob/master/seq2seq/model/seq2seq_learner.py)是火炬nn.Module的子类。这继承了它的一些方法。我们可以看到我们模型的架构:

learner

产出:

Seq2seqLearner(
  (encoder): EncoderRNN(
    (embedding): Embedding(285, 300, padding_idx=1)
    (gru): GRU(300, 300, num_layers=2, dropout=0.1, bidirectional=True)
  )
  (decoder): LuongAttnDecoderRNN(
    (embedding): Embedding(269, 300, padding_idx=1)
    (embedding_dropout): Dropout(p=0.1)
    (gru): GRU(300, 300, num_layers=2, dropout=0.1)
    (concat): Linear(in_features=600, out_features=300, bias=True)
    (out): Linear(in_features=300, out_features=269, bias=True)
    (attn): Attn()
  )
)

拥有学习者类有助于将所有培训、验证和预测相关代码集中在一起。[Seq2SeqLearner](https://github.com/RRisto/seq2seq/blob/master/seq2seq/model/seq2seq_learner.py)中最重要的方法是 fit(训练/验证编码器，解码器用户给定的历元数)，forward(训练/评估编码器/解码器在一个历元中的单个批次)，predict(使用编码器，解码器对新序列预测输出)。

验证集

当我们训练模型时，验证集的有用性变得很明显。

#initialize learner
hidden_size=300
learner=Seq2seqLearner(data_manager,hidden_size)batch_size=100
learning_rate=0.001
learner.fit(2,learning_rate, show_attention_every=5, show_attention_idxs=[0])

我们可以看到训练产生了这样的东西:

0:0:25.0 (1 50.0%) loss train: 3.712 loss valid: 3.179
0:0:25.3 (2 100.0%) loss train: 2.491 loss valid: 3.152

这是一个具有 2 个纪元的玩具示例，但是我们已经可以看到训练损失显著减少，而验证损失几乎没有变化。原始示例使用数据中的随机文本来显示模型输出。这还不错，在我的例子中也是这样做的，但这并不能概括我们在更广泛/量化的范围内做得如何。培训损失下降得非常快，但是验证损失趋于缓慢下降，并在某个点饱和。这个点显示了我们开始过度拟合的地方。始终使用验证集！

令牌化是多核的

我还更新了令牌化，以利用多核的优势(如果您的计算机有多个内核的话)。这样做的函数在标记化模块中:

def proc_all_mp(self, strings:list, ncpus:int=None):
        #get number of cpus, make sure it is not 0
        ncpus = ncpus or num_cpus() // 2
        if ncpus == 0:
            ncpus = 1
        #apply function proc_all (basically turns string 
        #into tokens of words) to a list of strings so that strings
        # list is partitioned by number of cores 
        #each gets roughly equal size
        with ThreadPoolExecutor(ncpus) as e:
            return sum(e.map(self.proc_all, \ 
                   partition_by_cores(strings, ncpus)), [])

功能partition_by_cores和partition也很简单:

def partition_by_cores(a, ncpus):    
    sz=(len(a) // ncpus) or 1 #if ncpus is more than len(a) 
    return partition(a, sz)def partition(a, sz):    
     """splits iterables a in equal parts of size sz"""
     return [a[i:i + sz] for i in range(0, len(a), sz)]

这利用了多核计算机的优势。在序列列表较长的情况下，多核处理有助于节省时间。这部分纯属抄袭 fastai 库。

预先训练的单词向量

改进模型的一种方法是初始化嵌入，不是用零或随机浮点，而是用预训练的字向量。这应该已经编码了一些关于不同单词之间关系的信息。例如，facebook 收集了这些在这里找到的。使用data_manager加载它们:

#first one is for input sequence, second output
data_manager.load_ft_vectors('data/wiki.en.vec', 'data/wiki.fr.vec')

保留当前词汇所需的向量。之后，初始化模型和训练。一个重要的注意事项:hidden_size和单词向量的长度必须匹配(例如，我希望每个单词向量的长度为 300)！

hidden_size=300 
learner=Seq2seqLearner(data_manager,hidden_size)

也可以使用自定义单词向量，从技术上讲，它们必须是字典:

hidden_size = 2 
#silly vectors with length of two and only with two tokens
x_silly_wordvector = {'this':[-0.3,0.2],'is':[0.1,0.5]}
y_silly_wordvector = {'le':[-0.4,0.2],'cat':[0.6,0.5]}learner = Seq2seqLearner(data_manager,hidden_size,
    emb_vecs_x = x_silly_wordvector, 
    emb_vecs_y = y_silly_wordvector)

尝试它们，它们使训练更快(使用更少的时期，你应该得到类似或更好的结果，因为没有预先训练的单词向量)。

在教师的强迫和关注下进行培训

原例说了几个关于老师强制的话，但没有实现(除了变量teacher_forcing_ratio被初始化但没用过)。我通过添加几行代码解决了这个问题:

if random.random() < self.teacher_forcing_ratio: 
                    #next input istaken from target
                    decoder_input = target_batches[t]                else: 
                    #next input is taken from decoder prediction
                    decoder_input = decoder_output.data.max(1)[1]

这随机选择将什么作为下一次预测的输入提供给解码器:

• 先前解码器输出或
• 以前的实际目标(如果高于阈值)

下图描述了为什么这很重要。

Example of teacher forcing

在模型训练期间，解码器一次给出一个输出(在图中为一个令牌)。这意味着前一个输出会影响下一个输出。解码器可能会给出错误的猜测(在图形中，真实的令牌应该是“猫”，但解码器预测的是“狗”)。这反过来可能会导致其他不可预测的输出完全错误(标记为“？”)例如)令牌。教师强制确保我们偶尔不使用解码器先前的输出作为下一个预测的输入，而是使用真实的目标值。这可能有助于模型更快地收敛。现在我们准备训练模型。

训练本身很简单:

batch_size=100
learning_rate=0.001
learner.fit(2,learning_rate, show_attention_every=5, show_attention_idxs=[0])

通常你希望有尽可能大的批量来满足你的记忆。要使用 cuda(或特定设备),只需将其设置为 fit:

learner.fit(2,learning_rate, show_attention_every=5, show_attention_idxs=[0], **device='cuda'**)

在培训过程中，您将会看到所指示的验证批次序列的注意事项show_attention_idxs=[0]指示索引为 0 的验证批次序列(第一个序列)注意事项会在每 5 个时期(show_attention_every=5)后显示。

Example decoder attention

解码器注意力只是一个应用于输入以获得输出的权重矩阵(张量)。从左图中，我们可以看到在每次输出预测中，解码器关注的是输入序列的哪一部分。例如，在输出标记“I”的情况下，注意力集中在输入标记“je”上。

训练后，学习者可以用来进行预测:

learner.predict('Je suis sûr.', device='cpu')

这可能会给出类似的输出:

i <unk> . <eos>

请注意，在训练过程中，我们为每个序列添加了一个字符串结束标记“”(以便解码器知道它何时到达了末尾)。我们可以使用我们想要的任何设备(默认为 cpu)进行预测，学习者被转换为在运行中使用该设备。

失败，棘手的部分

棘手的部分是储蓄。这是我想通过使用torch.save来使用nn.Module全部力量的地方，但是发现我的使用 spacy 的记号赋予器有酸洗的问题。相反，保存分两步完成:

• 保存数据 _ 管理器
• 保存学习者状态字典(点击阅读更多关于保存状态字典的信息)

data_manager.save('example_data_manager.pth')
torch.save(learner.state_dict(), 'example_state_dict.pth')

加载以相同的顺序完成，但多了一个步骤:

• 加载数据 _ 管理器
• 初始化学员对象
• 向学员添加保存的状态字典

data_manager_new=Seq2SeqDataManager.load('example_data_manager.pth')
model=Seq2seqLearner(data_manager_new,hidden_size) 
model.load_state_dict(torch.load('example_state_dict.pth'))

在场景后面，data_manager 在保存期间将 tokenizer 设置为None，并在加载期间重新初始化它们。我知道，这不是最有说服力的解决方案，但我不想浪费时间，因为它毕竟只是一个教程。

摘要

这是对原始教程的温和更新。我希望你能从这篇文章中学到一些东西。为了更好地理解 seq2seq 模型，请深入研究教程代码。更好的是尝试做出改变。我希望我在以下几点上说服了你:

• 官方的例子可能有缺陷，要持怀疑态度。努力改善他们！
• 在 pytorch 的情况下，尽可能多地使用原始的类和方法，您不必从头开始编写所有的东西(尽管出于学习的目的，这并不是一个坏主意)
• Seq2seq 型号很酷:)

祝你更新我的例子愉快。

在命运大令上调整多任务 Pytorch 网络

原文：https://towardsdatascience.com/tuning-a-multi-task-fate-grand-order-trained-pytorch-network-152cfda2e086?source=collection_archive---------16-----------------------

在之前的帖子中，我在 Keras ( here )中做了一些多任务学习，在完成那篇帖子后，我想在 Pytorch 中做一个多任务学习的后续帖子。这主要是因为我认为在另一个框架中构建它对我来说是一个很好的练习，然而在这篇文章中，我将讲述我如何在构建模型后做了一些额外的调整，这是我在构建基于 Keras 的模型时没有经历的。

我还将这个模型作为我在另一系列帖子中建立的面部相似度管道的一部分(第一部分和第二部分)。

简单回顾一下，多任务模型是指单个模型通过优化来解决一系列通常相关的问题。从机械上来说，这是通过将来自模型管道的某个核心部分的输出馈送到一系列输出“头”来完成的，这些输出“头”的损耗可以被评分和组合，通常通过相加，然后网络可以根据总损耗来调整其权重。

我注意到，在培训这些人的时候，集中精力提高单个任务的难度有点大，因为用于优化的损失函数是通过将各个损失函数相加而创建的。然而，通过对 Pytorch 网络的一些早期实验，我发现传统的调优策略相当有效。

我使用的基本调整策略是吴恩达在他的在线讲座中概述的策略，其中大多数机器学习算法都在方差和偏差之间进行权衡，但对于神经网络来说，情况并非如此。有了神经网络，这种权衡就不那么令人担心了，因为我们可以使用不同的机制来解决这两个问题。在网络欠拟合的情况下，您可以增加额外的计算能力，在网络过拟合的情况下，您可以应用正则化，如丢弃或批量归一化。通过平衡这两种机制的应用，您可以调整您的网络。

在这篇文章中，所有的艺术图片都用最后一批标准化 pytorch 模型的输出进行了说明。

Gender: Female, Region: Europe, Fighting Style: melee, Alignment: LG, Main Colors: [‘Silver’, ‘Gold’, ‘Blue’]. Two characters, both are from Europe, use melee weapons, are LG in alignment and the colors seem pretty good.

数据集和管道

Gender: Female, Region: Asia, Fighting Style: melee, Alignment: CG, Main Colors: [‘Red’, ‘Black’, ‘White’]. This character is European and has a Chaotic Neutral alignment but figured I should include to show that the model puts out alignments besides LG and NE

这个项目的数据集与我之前的基于 Keras 的多任务学习帖子相同，它由手机游戏《命运大令》(FGO)中大约 400 个角色的图像组成。数据集由大约 40 个不同的字符和 26 个不同的标签组成，以创建多标签样式的数据集。

这些类别包括角色的性别，他们来自的地区，战斗风格，图像的主要颜色，以及角色排列(合法的好，真正的中立，混乱的邪恶，等等)。要了解更多细节，请查看之前的帖子。

我必须做的另一个真正的修改是定制 Pytorch 数据集类，它接受一系列列表并输出图像和模型的 5 个目标向量。Pytorch 使得获取数据集类并根据需要修改它变得很容易。通常只需编写自己的 init、getitem 和 len 函数。我的大部分修改来自 getitem 部分，在那里我指定了如何读入图像并从目标列表列表中获取相应的目标，我戏称其为“列表之王”。

I like the colored code vs the grey code snippets you can add into the blog post

Gender: Female, Region: Europe, Fighting Style: melee, Alignment: NE, Main Colors: [‘Silver’, ‘Gold’, ‘Purple’]. Similar to the Keras model it looks like it has learned about the relationship between color and character alignment in the sense characters with evil alignments tend to be drawn with darker colors in FGO.

构建基本 Pytorch 模型

对于这一个，我的第一步是从一个非常基本的模型开始。我首先用 Resnet50 作为主干构建了一个模型，将它的输出送入 5 个输出头。

在 Pytorch 中构建定制网络非常简单，只需初始化需要在 init 部分优化的层和内容。然后，在 forward 部分定义数据如何流经模型。对于这个用例，我真正要做的是初始化核心模型(resnet50 ),然后将输出输入到我创建的 5 个 heads，y2o，y3o，y4o，y5o)中的每一个。这些是模型的输出，而不是你通常看到的标准的单一输出。

first model with just a Resnet50 and 5 output heads

要查看训练循环，请随意查看笔记本(此处)。很大程度上只是我在修改标准 Pytorch 网络。然而有趣的是损失函数是如何计算的。我原以为这样做起来会更复杂……但实际上非常简单……基本上我只是计算每个头部的损失(损失 0、损失 1、损失 2、损失 3、损失 4 ),将它们加在一起，然后用于反向传播。

loss0 = criterion[0](outputs[0], torch.max(gen.float(), 1)[1])
loss1 = criterion[1](outputs[1], torch.max(reg.float(), 1)[1])
loss2 = criterion[2](outputs[2], torch.max(fight.float(), 1)[1])
loss3 = criterion[3](outputs[3], torch.max(ali.float(), 1)[1])
loss4 = criterion[4](outputs[4], color.float())loss = loss0 + loss1 + loss2 + loss3 + loss4
loss.backward()

我用 Adam 优化器对这个基本模型进行了 50 个时期的训练，学习率为 0.0001，随着时间的推移而衰减，并保存了具有最佳验证损失的模型。请参见下面所有 5 项任务的得分。

val gender_Acc: 0.9390
region_acc: 0.6707
fighting_acc: 0.8537
alignment_acc: 0.7439
color_acc: 0.8384

总体不可怕，但也不伟大。然而，总的来说，它确实比我之前的文章《VGG 的 Keras》要好。

基本 Pytorch 模型通常优于 Keras 模型。这是有意义的，因为 Keras 模型使用 VGG19 模型作为冻结权重的主干，而这一轮的 Resnet 正在数据集上进行微调。

Gender: Male, Region: Middle East, Fighting Style: magic, Alignment: LG, Main Colors: [‘White’, ‘Blue’, ‘Purple’]. This one was good to see in the Pytorch model… because the Keras one would always label this character as “Female”. so this is another are where the new Pytorch models are well performing.

这是一个不错的开始，但我认为我可以提高所有车型的性能。基本上我认为 Pytorch 模型仍然不适合。作为回应，我添加了两个更密集的大小为 256 的图层，并将其输入到模型中。以下代码片段进行了修改。基本上只是增加了两层尺寸为 256 的 x1 和 x2。

Added two layers x1 and x2 for extra firepower

在训练这个新模型之后，与我构建的基本 Keras 和 Pytorch 模型相比，训练和验证准确性有所提高，总体性能更好。

一方面，我们可以称之为一天，但我在这里注意到的另一件事是，虽然模型整体表现更好，但它现在过度适应训练集。请参见下面第二款产品的得分。

 Training
gender_Acc: 0.9877
region_acc: 0.9417
fighting_acc: 0.9509
alignment_acc: 0.7577
color_acc: 0.8723Validation
gender_Acc: 0.9390
region_acc: 0.9146
fighting_acc: 0.8537
alignment_acc: 0.7439
color_acc: 0.8506

现在它是过度拟合，我想我可以添加一些正则化来尝试和抵消它。这需要一些修补，但我发现在这种情况下，相对高水平的批处理规范化是有用的。在这次运行中，我最终使用 2e-1。

added bn1 and bn2 to act as regularization

在这第三轮之后，增加了批量标准化的模型显示，在排列上比以前的最佳准确度增加了大约 10 个百分点，我认为这是最难的类别，在战斗风格上增加了 5 个百分点。而在性别和肤色上有所下降。它与给定字符的起源区域相关联。所以总的来说，我会说这部分有混合的成功，但确实有助于一个困难的类别。

Training
gender_Acc: 0.9816
region_acc: 0.9540
fighting_acc:  0.9632
alignment_acc: 0.8926
color_acc: 0.8129Validation
gender_Acc: 0.9146
region_acc: 0.9146
fighting_acc: 0.9024
alignment_acc: 0.8537
color_acc: 0.7912

需要注意的是，虽然我添加了批处理规范来尝试和减少过度拟合，但训练和验证之间的差距与以前类似…然而，模型的预测似乎比以前概括得更好，这也是添加正则化的目标结果之一。

Gender: Female, Region: Middle East, Fighting Style: ranged, Alignment: NE, Main Colors: [‘Blue’, ‘Gold’, ‘Black’]. Character has a LG alignment and don’t quite see the blue here, but the rest of the details are pretty good.

结论和总结

我认为这个简单的调优过程是一个很好的指标，表明您在普通网络上使用的策略仍然可以应用于多任务模型。这其中的一个困难是，很难针对多任务模型中的特定缺陷，现在我只是针对更大的总体问题(所有节点的过度拟合和欠拟合)。在这些头上添加额外的层和节点是一个选项，但随后会成为您需要调整的额外的超参数。

因此，最终的两个模型表现得相当相似，基础更深的网络在颜色和性别方面表现得更好，在区域方面打成平手，而批量标准化模型在战斗风格和对齐方面表现得更好。

这就提出了选择什么模式的问题。你可以计算 Fbeta 之类的东西来处理它，尝试在所有不同的任务中做出一个组合的度量。如果你的目标是拥有一个单一的最佳模型，那么拥有这个单一的度量标准是有意义的。

如果你对使用多个模型持开放态度，另一个选择是采用表现良好的模型，并集合它们进行预测。这将允许您利用每个不同模型的性能更好的区域。我认为这在这种情况下是可行的，即一个模型在比对类别上表现更好，而第二个模型在多个不同类别上表现更好，差距较小。

在另一种情况下，你有一个较低的执行任务，在这种情况下，颜色不太好，你可能会成功地将专门的模型添加到整体中，以尝试和提高这些领域的性能。

Gender: Female, Region: Europe, Fighting Style: magic, Alignment: LG, Main Colors: [‘Blue’, ‘White’, ‘Silver’]. 15th anniversary photo for the character, only thing wrong with the predicted outputs I would say is the fighting style… there is a sword stuck in the ground but the model says she uses magic

收听纽约的音乐街区

原文：https://towardsdatascience.com/tuning-in-to-nycs-music-neighborhoods-efb7ae77a4cd?source=collection_archive---------17-----------------------

K-Means 通过音乐档案聚类邻居

摘要

机器学习允许创建能够识别多维数据集中的模式的计算模型。这个项目旨在利用 Foursquare 的“Places API”和一种叫做“k-means clustering”的机器学习算法来识别具有类似“音乐档案”的“纽约市”社区。

介绍

背景

音乐是一种艺术形式，已经并将永远深深地嵌入城市、社区和更广泛的人群的文化活动中。音乐是一种交流和表达的方式，有时甚至是抗议的方式，它有能力和平地将大量志同道合的人聚集在一起，影响流行文化，用一首令人难忘的歌词催眠你，让你在淋浴时潜意识地连续几周唱歌，即使在有意识地对自己这样做感到失望之后……我跑题了……

问题

城市在某种程度上是由音乐实体组成的，如唱片店、乐器供应商、音乐厅、圆形剧场等等，它们不仅满足当地居民的音乐需求，也满足来自世界各地的游客的需求。对于较大的城市，音乐实体可以分散开来，从而形成一个随着时间的推移而发展和变化的时尚利基社区生态系统。这种生态系统通常由寻找酷音乐场景的人通过自然生活体验(流浪/浪荡)或以互联网评论、评论和与现实生活中的人交谈的形式推荐来了解。

这个项目旨在量化一个大都市纽约市的社区的“音乐档案”,以识别相似音乐场景的集群。

利益相关者

不同的团体可能对能够基于可用音乐商店的类型来量化邻域相似性的模型感兴趣。这种模型将能够通知那些喜欢住在音乐发生的地方的租房者和购房者，他们的下一个家就在合适的位置。未来的音乐场所初创企业可以利用该模型来识别缺乏现场音乐场所的社区，并确保他们投资于一个未饱和的地区。未来的音乐零售商，如唱片和乐器销售商，同样可以利用这种模式来确保他们开展的业务中竞争对他们有利。

方法学

数据源

*NYU 空间数据仓库:*我使用 NYU 空间数据仓库托管的“2014 年纽约市街区名称”数据集作为街区名称和相关位置质心的基础[0]。下图显示了此信息的一个示例:

DataFrame created from NYU’s ‘2014 New York City Neighborhood Names’

Foursquare—‘Places API’:我将使用 four square 的‘Places API’来获取与‘场馆’(four square 定义的)相关的数据，这些数据被归类为与音乐有某种关联[1]。值得注意的是，Foursquare 将“地点”定义为一个人们可以去或签到的地方，并且“地点”不一定是音乐地点，而是可以是任何机构，如餐馆或零售商店。每个 Foursquare“地点”被分配一个“类别”，每个“类别”与一个特定的“类别 ID”相关联。右图显示了 Foursquare 提供的“categoryID”值，该值将用于获取纽约市内与音乐相关的场所:

Foursquare Music-Related Venue CategoryIDs

资料检索

*街区名称&位置质心数据:*由 NYU 空间数据仓库托管的“2014 年纽约市街区名称”数据集可轻松下载为 JSON 文件并导入 Jupyter 笔记本:

Importing the newyork_data.json fie

然后，将与每个邻域相关的“区”、“邻域”、“纬度”和“经度”值从 JSON 转换为 Pandas 数据框架，作为分析的基础。

Creating a DataFrame out of the JSON data

Foursquare 音乐相关场地数据 : 如本报告数据来源部分所述，Foursquare 拥有众多的“场地类别，用于标识各类场地。对“API . four square . com/v2/ventures/search？”的“get”请求提供类别 ID 的端点将返回该类别的地点。下面的示例代码向 Foursquare 发送一个“get”请求，请求一个属于“音乐商店”类别的场所(categoryID = ’ 4 BF 58 DD 8d 48988 D1 Fe 941735 '):

Example Foursquare Places API Request

通过递归地发送“get”请求到前面提到的端点，确保结果特定于具有音乐相关“类别 id”的场所，创建了与每个纽约市街区相关的音乐相关场所的初步数据集。对于每个邻域，我们可以在一个“get”请求中包含所有选定的类别 id，方法是将它们作为逗号分隔值传递。下面显示了一个创建所需 url 的函数和一个示例:

Dynamically creating API request URLs

下面的函数递归地向 Foursquare 发送一个“get”请求，请求所有与音乐相关的地点。在遍历 NYU 数据集中的每个邻域时，该函数将每个与音乐相关的地点条目附加到一个列表中，并且在遍历每个邻域后，创建所有结果的数据帧。对于数据集中的每个条目，包括邻居名称和位置，以及地点名称、位置和类别。

Recursively retrieving music-related venues for each New York City neighborhood

最终的初步场馆数据框架包括从 Foursquare 中抽取的 9，442 个场馆:

9,442 venues were pulled from Foursquare

由于我对超出 Foursquare 的 API 速率限制有一些问题，在获得初步数据集后，将一个副本保存到 csv，以便将来的开发不需要从 Foursquare 重新请求信息。

Write data to csv

Sample of csv file

探索性数据分析

下面的一系列图片旨在捕捉我探索从 Foursquare 检索的数据的过程，以更好地了解在我的请求期间实际上是什么样的场地。在一个完美的世界中，每个条目都与音乐相关，并且位于纽约市，但是这需要被验证。以下问题说明了如何对初步场馆数据进行预处理，如本报告的数据预处理部分所示。

问题:场馆位于哪些州？

回答:从 API 请求中提取的大多数条目都包含一个等于“纽约”或“NY”的“州”参数某些条目包含等于“CA”、“MA”和“NJ”的“state”参数，需要删除。

Showing the Venue State counts

问:参赛作品属于哪个场馆类别？

答:这个数据集中有 149 个独特的场馆类别。有些类别与音乐无关，这是因为使用了 Foursquare 定义的更高级别的“场地类别”。与音乐无关的类别将被删除。

Showing the Venue Category counts

问题:有多少场馆没有填写“城市”参数？

答:下图显示有不少场馆没有填写“城市”参数。起初，我认为这不会是一个问题，因为我仍然有一个与每个条目相关联的纬度和经度。经过进一步分析，确定没有“城市”参数的条目不再是活跃的机构，因此将被删除。

Showing venues that do not have a Venue City parameter

问题:数据集中有空值吗？

回答:没有。

Checking for null values in the data

问题:检索到多少个独特场馆？

答:初步数据集中，唯一场馆名称比条目总数少。这意味着存在与多个邻近区域相关联的场所，这是由于 API 请求中半径被设置为 1000 米而导致查询重叠的结果。这是可以接受的，因为场地在邻近区域质心的步行距离内，可以影响邻近区域的场景。

Checking for duplicate Venue Names

数据预处理

数据清理

根据上面探索性数据分析部分中列出的答案清理初步数据集。首先，位于“纽约”或“NY”以外的州的场馆被移除。“地点州”等于“纽约”的条目被更改为“纽约”

Removing venues not in New York state

Foursquare 返回的没有“场馆城市”并给予“不适用”待遇的条目也被删除:

Removing venues with no Venue City parameter

基于包括在初步数据集中的独特场所类别，创建了音乐相关场所类别的列表。这个列表用于过滤掉混入我们请求中的与音乐无关的条目。

Removing venues that are not music-related

下图显示了 ny _ music _ venues 数据帧中的条目总数和唯一条目数。如前所述，一些场馆被分配给多个街区，因为场馆位于街区质心位置的 1000 米以内。

Checking for duplicate venues

一键编码场馆类别

为了使用 Foursquare 的类别值来找到基于音乐场所的相似邻居，使用 Pandas 的“get_dummies”功能创建了每个条目的一个热编码表示。结果是纽约市音乐相关场所的数据框架，其中条目场所类别由匹配场所类别列中的值 1 表示，如下所示:

One-Hot-Encoding categorical variables

数据可视化

使用 one hot encoded DataFrame 确定了纽约市每个场馆类别和街区的场馆数量:

Total amount of venues of each category in each neighborhood

使用上面显示的场馆数量的数据框架，为选定的场馆类别创建了水平条形图，以帮助可视化每个特定场馆最多的前 25 个社区。使用以下循环和 matplotlib:

Code for recursively plotting top neighborhoods with venues of particular category

拥有最多“音乐厅”的社区

拥有最多“音乐场所”的社区

拥有最多“夜总会”的社区

“爵士俱乐部”最多的街区

“钢琴酒吧”最多的街区

特征生成

纽约市音乐相关场所的编码数据集随后被用于量化每个街区的音乐概况。对于每个场馆类别，计算了场馆在每个社区的分布百分比。然后，该信息将用于使 K-Means 聚类算法适合数据，以努力确定相似音乐场所简档的邻域。

首先，确定每个类别的场馆总数:

Creating a dictionary of venue category and total count

最后，根据场馆类别，计算每个街区的场馆相对于数据集中场馆总数的百分比。很明显，Astoria 的“Lounge”列中显示的值表示位于 Astoria 的休息室在数据集中所占的百分比。

Percentage of entities of particular venue in a particular neighborhood

根据上述内容，创建了一个数据框架，显示每个街区的前五大音乐场所类别:

Showing the top five venue categories per neighborhood

结果

集群建模

Scikit-learn 的 K-Means 聚类用于根据音乐场所百分比确定相似的邻域。下图显示了正在缩放的数据和正在创建的 K 均值模型:

Clustering neighborhood venue data

一个新的数据框架是通过合并邻居位置数据和聚类标签和顶级场馆类别创建的。

Merging neighborhood location and cluster data

集群可视化

以下代码通过基于分类标签对每个邻域点进行着色，使用 follow 来可视化相似音乐配置文件的邻域:

Code to generate a folium leaflet map with neighborhoods colored by cluster

Map of New York City showing clusters

聚类评估

下面的代码遍历并打印每个分类的结果:

Code to iterate through and print each cluster

由此产生的集群可以在本文档附录的集群部分看到。每个聚类显示一个邻域列表及其各自的顶级场馆类别。我们可以将得到的聚类与数据可视化部分中的条形图进行比较，并根据与音乐相关的场地计数来判断聚类是否正确地对邻近区域进行了分组。

有趣的是，一些集群非常小，有时只包含一个邻居，并且似乎已经确定了一个利基音乐简档。这方面的例子有:

集群 1 —康尼岛—音乐节(康尼岛音乐节)

第二组团——林肯广场——歌剧院(大都会歌剧院)

诸如集群 4 和集群 7 的其他集群非常大，并且看起来是具有诸如音乐场所、夜总会、摇滚俱乐部、休息室等各种现场音乐类型场所的分组邻居。

集群 9、11、12、13 和 14 的集群间第一大场馆类别都是相同的；爵士俱乐部、录音室、摇滚俱乐部、爵士俱乐部和钢琴俱乐部。有趣的是，集群 9 和集群 12 都主要对爵士乐感兴趣，但由于它们的其他顶级场所类别不同，这意味着不同的音乐概况，所以它们被不同地分组。

结论

机器学习和聚类算法可以应用于多维数据集，以发现数据中的相似性和模式。使用高质量场地位置数据，可以生成具有相似音乐简档或任何简档的邻居的聚类。关于高质量有一个前言，因为分析模型的好坏取决于对它们的输入(垃圾输入，垃圾输出)。幸运的是，Foursquare 提供了一个强大的“位置 API”服务，虽然(正如我们所看到的)并不完美(没有什么是完美的)，但可以在类似的研究和模型制作中加以利用。

这个项目并没有完成，可以用不同的方式进行扩展。Foursquare 的 API 可以被进一步询问，以检索和考虑纽约市更多与音乐相关的场所。可以获得音乐相关场所的新数据集，并可能与从 Foursquare 检索到的数据集合并。DBSCAN 聚类算法在保持密集聚类和忽略异常值方面更好，可以实现该算法并与 KMeans 进行比较。该聚类模型可以成为推荐系统的基础，该推荐系统旨在向用户提供相似音乐档案的邻居。

我期待着在未来继续探索和利用音乐相关的数据集。

GitHub 项目:https://github.com/cascio/IBM_Data_Science_Capstone

个人领英:https://linkedIN.com/in/mscascio

个人网站:https://cascio.co

推特:【https://twitter.com/MCasiyo

参考

[0] — 2014 纽约市街区名称— NYU 空间数据仓库

[1]—‘Places API’文档— Foursquare

附录

簇

群集 0:

群组 1:

第二组:

第三组:

第 4 组:

第 5 组:

第 6 组:

第 7 组:

第 8 组:

第 9 组:

第 10 组:

第 11 组:

第 12 组:

第 13 组:

第 14 组:

带 JAX 的涡轮增压 SVD

原文：https://towardsdatascience.com/turbocharging-svd-with-jax-749ae12f93af?source=collection_archive---------22-----------------------

在之前的文章中，我写了两种常用的降维方法的基本原理，奇异值分解(SVD)和主成分分析(PCA)。我还用 numpy 解释了他们的关系。快速回顾一下，一个以 0 为中心的矩阵 X (n 个样本× m 个特征)的奇异值(∑))，等于其特征值的平方根(λ)，使得使用 SVD 计算 PCA 成为可能，这通常更高效。

在这篇文章中，我将探索一些 SVD 算法，并用 Python 对平方稠密矩阵( X ， n×n )进行基准测试。我还有一个非常令人兴奋的发现:最近开发的由 XLA 编译器支持的 JAX 库能够显著加速 SVD 计算。我们开始吧！

SVD 怎么算？

*奇异值分解是探索性数据分析和机器学习中一种常见的基本技术，但我们实际上如何计算出左右酉矩阵( U ， V )和奇异值呢？通过我远非详尽的文献综述，至少有四种算法可以求解稠密矩阵的完全奇异值分解。甚至更多的算法可用于稀疏矩阵的截断/缩减 SVD，为了效率，其仅计算最大的 k 奇异值。在本帖中，我将重点介绍密集矩阵和完整的 SVD 算法:

1. 分治法(GESDD) :两阶段算法。它首先通过 Householder 反射将输入矩阵简化为双对角形式，然后将双对角矩阵分成更小的矩阵，以计算奇异值和酉矩阵 U 和 v。最后，整个输入矩阵的奇异值就是更小的子矩阵的奇异值。在这里可以看到这个算法更深入的讲解。这种算法在概念上类似于 MapReduce ，其中大块数据被分成多个块进行并行处理，每个块的结果可以使用简单的函数进行聚合，例如求和和连接。
2. 通用矩形方法(GESVD) :也是一种两阶段算法，其中第一步与 GESDD 相同。第二步可以使用迭代 QR 分解得到奇异值。更多数学细节可在这里获得。

这两种算法都在用 Fortran 编写的经典线性代数库 LAPACK 中实现。分治法被证明比一般的矩形法快得多，但是占用更多的内存。

Python 中的 SVD 实现

Scipy 和 Numpy 都包含在各自的线性代数子模块下计算 SVD 的方法:

• numpy.linalg.svd :“使用 LAPACK 例程` _gesdd '执行分解”。但通过查看这个函数的源代码，似乎 numpy 是通过一些用 c 编写的调用宏来调用 LAPACK 的，这样设计的目的很可能是为了规避构建 numpy 时对一个 Fortran 编译器的要求。
• scipy.linalg.svd :提供更多参数，如overwrite_a、check_finite，为 svd 计算提供潜在的加速。它还有一个参数lapack_driver，用于在 LAPACK 中的 GESDD 和 GESVD 算法之间进行选择。
• scipy . sparse . Lina LG . svds:执行截断 SVD，计算稀疏矩阵的最大 k 奇异向量。虽然这个函数也能够计算完整的 SVD，但是它的效率比 scipy.linalg.svd 低得多。

您可能想知道为什么在 numpy 和 scipy 中都有linalg.svd的实现。np.linalg.svd和scipy.linalg.svd有什么区别？我在 scipy 的 FAQ 中找到了这个问题的答案:scipy.linalg是使用 f2py 对 Fortran LAPACK 更完整的包装，而 numpy 则试图独立于 LAPACK。

Timings for numpy/scipy SVD methods as a function of matrix size n

为了比较不同 SVD 实现的速度，我建立了一个非常简单的基准，通过改变大小为 n 的方阵的大小来测量 numpy 和 scipy 中 SVD 实现的执行时间。如上图所示，scipy ( scipy_svd)和 numpy ( np_svd)中的分治法(GESDD)比 QR 分解法(GESVD)快一个数量级以上(scipy_gesvd)。scipy.linalg.svd 也比它的 numpy 版本快得多，这可能是因为它与 LAPACK 的通信效率更高。

JAX 和 XLA

让我们绕一小段路到 JAX，这是谷歌最近开发的开源库，旨在加速线性代数计算。 JAX 是一个“非官方”的谷歌项目，配备了亲笔签名的和 XLA 编译器，汇集在一起进行高性能机器学习研究。XLA(加速线性代数)是 Tensorflow 背后的编译器，用于在不改变源代码的情况下加速模型计算。它的工作原理是将多个简单操作“融合”到一个内核中。JAX 在 jit (实时)函数中实现了 XLA 编译器，以允许显式编译 Python 函数。下面是 JAX 简单用法的快速浏览，展示了如何用 jit 编译器加速原始 Python 函数。

JAX 的另一个显著特点是，XLA 编译的代码会被自动缓存，如果重复运行可以重用，以进一步加快进程。这在教程中有演示。

此外，JAX 还在子模块jax.numpy和jax.scipy下提供了 XLA 加速器支持的 numpy 和 scipy 函数，尽管目前并不支持所有的 numpy/scipy 函数。幸运的是，linalg.svd对于 numpy 和 scipy 都已经在 JAX 实现了。

密集矩阵的奇异值分解函数基准测试

随着 JAX 加速 numpy 和 scipy，我可以比较他们的表现与他们的香草同行。我使用了与之前相同的计时函数来获得以下结果。

First attempt in timing JAX powered SVD implementations

乍一看，这看起来很惊人:JAX 驱动的 numpy 和 scipy 都大大超过了 SVD 的简单的 numpy 和 scipy 实现。但是，这看起来好得令人难以置信:JAX 驱动的奇异值分解怎么可能快四个数量级，并且几乎有一个O*【1】的复杂度呢？在检查了我的计时功能后，我发现 JAX 可能已经找到了一种方法，通过缓存以前运行的结果来作弊。为了防止 JAX 这样做，我编写了另一个计时函数，在每次试验中生成一个全新的随机密集矩阵，从而得到下面这个更真实的结果。*

Timings of SVD methods with and without JAX acceleration as a function of matrix size n

上图显示，numpy ( jnp_svd)中 JAX 支持的 SVD 函数在速度上明显优于所有其他计数器，而 JAX 支持的 scipy 实现(jsp_svd)与其普通的 scipy 对应物没有任何差异。值得更多地研究实现，找出原因。这可能与 scipy 和 numpy 与 LAPACK 交互的不同方法有关，这可能会影响它们被 XLA 编译器进一步优化的能力。

还有必要提一下，所有的基准测试结果都是从 CPU 运行时生成的。我还试图通过 Google Colab 在单个 GPU 和单个 TPU 运行时上运行它们。而且看起来 GPU 并没有促进jax.numpy的加速，而 TPU 从 CPU 产生几乎相同的结果。这些观察结果也需要进一步研究。

但是从所有这些基准测试结果中得到的好消息是，您可以通过切换到jax.numpy 来轻松加速您的机器学习工作流，而无需进行重大的代码更改！

以上所有基准测试的 Jupyter 笔记本都可以在这里找到:https://gist . github . com/Wang 10/d6f 43 db 76 ca 260516d 149d 92 b 8834 bf9

参考

• SciPy 中的奇异值分解
• Python 中的稀疏 SVDs】
• 为什么既有 numpy.linalg 又有 scipy.linalg？有什么区别
• 数学 2071:实验室#9:奇异值分解
• 分治特征值算法
• SVD 的 LAPACK 文档

将亚马逊 S3 变成时空数据库！

原文：https://towardsdatascience.com/turn-amazon-s3-into-a-spatio-temporal-database-40f1a210e943?source=collection_archive---------14-----------------------

好吧，充满希望这个标题，S3 到底有什么可能？事实证明，相当多。事实上，这篇文章描述了如何使用 S3 搜索 n 维。

用于存储的 S3

S3 是亚马逊几乎无限的存储产品。您可以在 S3 存储桶中存储任何大小的文件，这些文件将被冗余地存储在一个区域内多个设施的多个设备上。对于您希望频繁交互的文件，标准存储成本约为每月每 GB 3c(US)。如果您将数据标记为存储在 S3 冰川，则费用为每月每 GB 0.4c，如果需要，您可以在几个小时内将其恢复到标准状态。

我把世界表面的一大块区域的船只运动数据存储在 S3，并配置旧数据自动转移到冰川。一天可能有多达 2700 万条记录，逗号分隔值(CSV)格式占用 2.4GB。事实上，我将原始数据(AIS NMEA)存储在 S3，Java Lambda 触发器创建了一个 CSV 版本。

随机访问 S3

我喜欢云服务的一点是发现成本和功能方面的最佳点，我想知道我是否可以快速廉价地查询 S3 的数据集。

原来 S3 的文件是可以随意获取的。我可以使用 Range HTTP 请求头指定一个字节范围，这就是将返回的全部内容(没有延迟损失)。

随机访问支持索引查找。如果我通过使用索引知道了我的记录在文件中的大致位置，那么我就可以只抓取文件的那一部分并提取我想要的信息。

GIS 系统如何执行空间查询？

2 维、3 维或更多维的窗口查询是在相同维数的框内搜索数据。例如，如果我有整个美国的时空数据，那么窗口查询可能是在特定的一天午餐时间查找芝加哥特定郊区的记录。

Fig 1. A spatio-temporal window query (researchgate.net)

GIS 系统如何对 2D 空间和时空数据进行窗口查询？

空间查询通常用 R 树来完成，R 树是一种相当复杂的数据结构。搜索平面文件中表示的树结构可能意味着在遍历树时进行多次随机访问读取。更重要的是，读取在本质上是串行的，因为在完成前一次读取之前，我不知道下一次读取的位置。更多的离散串行读取意味着更多的延迟，尤其是当我在 S3 读取平面文件时，每次读取都会遇到延迟。

将 3 维或更多维映射到希尔伯特曲线

在 3 维或更多维时，一种流行的索引技术是使用空间填充曲线将多维区域映射到一维。空间填充曲线的一个很好的选择是希尔伯特曲线。将您的 3D 域分割成 1024x1024x1024 个单元的规则网格，然后由一条摆动线组成的希尔伯特曲线将访问所有 1m 个点。

作为一个插曲，这里有几个 2D 的例子，这条曲线被称为希尔伯特曲线。

Fig 2. 2D Hilbert Curve, 4 bits

Fig 3. 2D Hilbert Curve, 8 bits

这是希尔伯特曲线的三维动画:

希尔伯特曲线有一些很好的局部性属性，因为它没有大的跳跃，曲线上的下一个值只有一个单位之遥。这意味着，如果两个点具有彼此接近的索引，那么它们在几何上也将彼此接近。不保证相反的情况。

稀疏索引

现在，所有数据点都映射到一个维度，我可以在该维度中对它们进行排序，然后使用简单的一维数据库索引查找技术。当您索引数据库表中的列时，您最终能够在每个表中找到与该列中的值相对应的精确行。但是，索引中的条目可以与表中的行一样多。如果你使用所谓的稀疏索引，那么你有一些行的位置，但是你可能需要在它们之后做一些额外的阅读来找到其他的。一个稀疏索引可以比一个完整索引小得多，比如说是一个完整索引大小的 0.1%。

我在这里拐弯抹角，所以让我们进入正题。如果我将我的 2，700 万条记录(2.4GB 的 CSV 文件)按照 Hilbert 索引的升序值(10 位，100 万个点)进行排序，然后创建一个小的稀疏索引文件(440K)，我就能够通过对数据的随机访问进行快速窗口查询。我甚至可以并行地进行搜索，因为我预先知道我的记录(大约)在哪里。理想情况下，我想到的查询在空间和时间上都很小，尽管我发现不受时间限制的查询也可以很好地工作。

一个图书馆来帮忙

在将搜索框转换成希尔伯特曲线上的范围(如果范围太多，可能会将其变粗)以及从那里访问索引所指向的字节范围方面，这里有一些棘手的问题需要处理。幸运的是，这些问题由一个名为sparse-Hilbert-index的 java 库来处理，这个库是我在 GitHub 上完成并发布的。

让我们试一个例子。我的 CSV 输入数据如下所示:

mmsi,messageId,time,lat,lon,speedKnots,heading,course,navigationStatus,rateOfTurn,source,specialManoevreIndicator,timeSecondsOnly,isUsingRAIM,class
4124607775,18,1543283257000,-66.97455333333333,33.95234833333333,8.7,67.3,67,,,NORAIS2,,35,N,N,
4124607775,18,1543283257000,-66.97455333333333,33.95234833333333,8.7,67.3,67,,,NORAIS2,,35,N,N,
538006789,1,1543283259000,-39.57300333333333,33.18371833333333,12.7,85.1,84,UNDER_WAY_USING_ENGINE,-13,NORAIS2,0,39,Y,N,A
...

我通过运行这段代码创建一个排序的数据文件和一个 Hilbert 索引(感谢 commons-csv ):

Viewing search statistics

13 分钟后，在 i5 笔记本电脑上完成了 2700 万条 CSV 记录的排序，并创建了索引文件。

然后，我将input-sorted.csv (2.4GB)和input-sorted.csv.idx部署到一个 S3 桶，并尝试查询如下所示的数据。首先我会数一个小时悉尼地区的记录数。我将使事情变得更简单，并假设数据在一个公共可访问的桶中，因此我不需要进行身份验证(但只有当您的数据不敏感时才这样做)。

加载索引文件(如果需要，可以在本地缓存):

执行搜索:

加载索引文件(440K)花费了 500 毫秒。

上面的搜索在169 毫秒中通过不太灵活的企业互联网连接找到了 2389 条记录。读取了 3347 条记录(命中率为 0.71)。稀疏索引导致了一定程度的浪费，但是我们当然不需要在服务器上安装 GIS 系统！

有趣的是，如果我们查询整个时间维度(24 小时)的悉尼(澳大利亚)地区的数据集，那么性能仍然是合理的:6720 毫秒返回 36940 条记录，命中率为 0.55。(部分)读取了 37 个块(由索引条目指向的 S3 对象的部分)，第一个字节的平均时间 (TTFB)为 114 毫秒(因此我们的互联网连接的延迟导致了 4200 毫秒的运行时间)。靠近 S3(比如 EC2 或 Lambda)可以节省大量时间，但我们的另一个锦囊妙计是从 S3 同时读取。

使用并发！

在上面的搜索命令中，您会看到concurrency参数被设置为 1。我发现，对于 S3 的这个数据集，通过普通互联网连接的最佳数字是 8；也就是说，同时检索、解析、过滤和合并 8 个组块。耗时 6720ms 的查询(主要是因为无约束的时间维度)现在耗时 839ms ！

从 AWS 搜索

我也从 EC2 (t2.large)进行了测试，正如预期的那样，第一个字节的时间减少到了大约 50 毫秒。有了并发性，全天查询减少到了 380 毫秒。随着延迟的下降，我认为寻道时间开始发挥更大的作用，并发级别的最佳点似乎是大约 4。

流式 API

用于从搜索中检索记录的 api 通过 RxJava 库提供流功能。

其他格式

请记住，CSV 不是存储和检索数据的最有效方法。更有针对性的二进制格式可能会使您的查询速度快很多倍。

调谐

稀疏索引中的条目数量对命中率有很大的影响(命中率是一种衡量您为了找到所请求的内容而读取了多少记录的指标)。如果您可以在本地缓存索引文件，或者将它们放在速度更快的存储器上，那么您可以在每个索引文件中使用更多的条目。实验是必由之路。为不同大小的同一个文件创建多个索引，看看哪一个最适合您的查询模式。

一般来说，如果您的查询是定制的，这样它们就不会返回很多记录，那么您的响应时间应该是上面提到的顺序。使用不受约束的维度进行搜索(就像前面查询中的时间)可能会有效，但是我建议只使用一个不受约束的维度。

查看搜索统计数据

当您执行搜索时，您可以指定withStats选项来查看有关搜索的各种指标:

index
.search(bounds)
.withStats()
.concurrency(1)
.url(url)
.last()
.forEach(System.out::println);

生产:

WithStats [elapsedMs=169, recordsFound=2389, recordsRead=3347, hitRatio=0.7138, bytesRead=392261, timeToFirstByteMsTotal=94, timeToFirstByteMsAverage=94.0000, chunksRead=1]

二维呢？

我已经运行了一个 3 维的例子，但是稀疏的希尔伯特指数对于 2 维也同样适用。因此，S3 也可以成为您的 2D 空间数据库。

不仅仅是 S3

注意，Azure Blob 存储和 Google 云存储也通过 HTTP Range 头提供随机访问。你可以使用这些存储选项以及稀疏希尔伯特索引 T2 库。

雅典娜呢？

这个问题问得好！特别是当 AWS 在 S3 桶中提供 CSV 文件(和其他格式)的 Athena 时，它可以在 1.5 秒内完成 2GB CSV 文件的完整扫描！

当你考虑到与全扫描相比，在大量数据上运行许多索引搜索的成本时，稀疏希尔伯特索引方法可能会更有吸引力。Athena 的成本很低(为查询而扫描的数据为 5 美元/TB)，但在一定规模下可能会变得非常重要。在某些情况下，进行大量全扫描搜索所产生的功耗也可能在伦理上具有挑战性(也很难计算)。我认为在大文件搜索方面很难与 Athena 竞争，但可能有一些边缘情况有利于稀疏希尔伯特索引！

火上浇油的是，Athena 支持 Parquet 格式，这种格式可以被索引，这样每个页面都有 min-max 统计数据。如果您对您想要查询的字段进行排序(在我们的例子中，我们将添加一个计算的 Hilbert 索引列),那么 Athena 可以在理论上自己进行索引查找(未经测试)。Athena 仍然需要查看每个页面的统计数据(默认情况下为 1Mb ),所以理论上它不如精确知道要搜索哪些页面的稀疏希尔伯特索引有效。请注意截至 2019 年 6 月，Athena不支持索引拼花格式以实现更快的访问( 1 )。当支持到来时，它将是值得尝试的！

带回家

• 从平面文件或存储服务(如 S3)中进行高效的空间、时空甚至 n 维查询是可能的！
• 转到 稀疏希尔伯特指数 获取该用例的易用库支持
• 评估雅典娜也为您的查询需求

使用 Tkinter，将您以前的 Python 项目变成令人敬畏的工具

原文：https://towardsdatascience.com/turn-your-previous-python-projects-into-awesome-tools-with-tkinter-2e61f2241e29?source=collection_archive---------2-----------------------

Because building your own tools is… sexy?! (photo credit: Todd Quackenbush)

笔记本很无聊！

所以你在 Jupyter 笔记本上写了你的第一个脚本，每次你想使用这个脚本的时候，你疯狂地运行每个单元格。不太实用吧？当然，你可以安装一些扩展和一些小部件，我甚至看到一篇文章，有人创建了一个在笔记本中实时更新的仪表板。但是，如果你能创建自己的程序，只需点击一下鼠标就能启动，这不是更酷吗？作为一个附带项目，我决定制作一些关于我文章中代码的视频，所以我很乐意听到你关于格式、持续时间和任何其他反馈的意见！谢谢！

您将能够建立简单的模板，可以把您的旧的和未来的脚本变成个性化的工具！

一个**，**图形用户界面也称为 GUI，是一种用户界面形式，允许用户通过图形图标与电子设备进行交互。这是一个普通人称为“应用程序”的花哨术语。除非您是从命令行阅读这篇文章(这实际上有点奇怪……)，否则您现在很可能正在使用 GUI。

我喜欢 Jupyter 笔记本，因为它们易于使用，并让您在单独的单元格中构建代码。对于任何初学 Python 和编程的人来说，这无疑是最好的切入点，但是如果你真的想从事数据科学，你还需要更多的东西。笔记本完成后，说“完成”并转移到另一个项目是很容易的，但是如果你给他们自己的界面呢？如果代码不太复杂并且结构良好，你甚至可以为每个脚本使用一个简单的模板，就像我在本文中分享的那个。

有一段时间，当我想从事任何 Python 项目时，我都坚持使用 Jupyter 笔记本。我努力去理解工作背后的框架。py 文件，但最终，它点击了！这件事发生在我搜索 Tkinter 资源的时候，所以你大概能感觉到我的意思…今天不会使用 Jupyter 笔记本了！我们将使用。py 文件和一个 IDE。

我的文章是为非 IT 人士而写的，所以如果你是这种情况，**不必惊慌！**在整个代码过程中，我会一直陪着你，并尽力回答评论中的每一个问题

您可以利用这个 Tkinter 项目做些什么:

• 创建用户界面来运行您的脚本
• 要求用户在文本字段中输入一些内容，并将其用作变量
• 单击运行代码特定部分的按钮
• 要求用户选择一个文件以使用文件对话框提示
• 奖励:不再与 Jupyter 独家合作！

对于这个项目，我将使用我以前的文章作为我们的应用程序使用的脚本的来源。这是一个从 Kayak 检查航班价格并编译结果的基本脚本。它有一些硬编码的输入，但正如我提到的，我们希望我们的体验更像一个正常的程序，所以我不得不稍微调整一下。我在我制作的作为文章补充的视频中解释了它。我强烈建议你看一看，因为为了简洁起见，一些细节必须从文章中删除！

在继续之前，您需要几样东西:

• 代码编辑器:我将使用 Spyder，它并不完美，但已经足够好了。如果你不确定这是什么意思，试试看你是否安装了 IDLE 。它预装了 Python，所以您在这里应该没问题。趣闻:IDLE 是用 Tkinter 造的！
• 包:显然你需要安装Tkinter包。有很多在线资源可以帮助你做到这一点。但是如果你想掌握它，我会在最后留下几本推荐的书。
• 模块:您需要将之前的 FlightScraper 脚本更新为。我分享的 py 文件 这里 。把它放在你将要处理的文件夹中。

每个程序都从一个窗口开始

Tkinter 一开始可能看起来很奇怪，很难理解，这就是为什么我会一个块一个块地构建代码，试图解释我们正在创建什么，以及它如何在应用程序中显示。假设您已经安装了所有东西，只需为项目创建一个文件夹，并创建一个扩展名为. py 的文件。

每个 Tkinter 应用程序都需要这样构建。我们称这个为 tk。Tk() 来创建应用程序窗口，然后我们构建我们的应用程序，在用 window.mainloop() 来“编译”所有东西之前，在我们想要的地方放置小部件(框架、按钮、标签等)。我不会详细介绍 Tkinter 是如何工作的，但如果你想了解什么是循环和构建一个应用程序的基本结构，请查看他们的资源。

在这一点上，我们讨论我们将需要的小部件可能更好。顺便说一下，小部件是 Tkinter 的元素(如按钮、标签、框架、条目等)。我只使用几个，如果你掌握了这些基本知识，你就可以很容易地自己去测试其他人了。

• 框架:我们的应用程序将被分成三个框架堆叠在一起。顶部框架将用于放置我们的标题，而底部将显示我们的应用程序按钮。中间的框架将由另外两个框架组成(是的，您可以将一个小部件放在另一个小部件中！)
• 网格:我将使用网格作为定义应用程序布局的一种方式。如果你喜欢冒险，可以试试 Place，它可以让你用屏幕上特定的 x，y 坐标来设置位置。在我看来，网格是最容易理解和使用的，所以我们将使用它并打包。
• Pack :它也是一个布局管理器，真的很好理解……每次使用。pack()它会将小部件堆叠在之前打包的小部件下面。
• 标签:简单地说，它们是文本框。我们将在页眉和输入框旁边使用它。
• 条目:它是一个小部件，让用户编写某种输入，比如城市和日期。
• 按钮:我真的需要解释什么是按钮吗？！玩笑归玩笑，在按钮部件中有一个名为命令的参数，它告诉按钮当它被按下时运行什么功能。

现在你知道了配料，让我们来看看食谱

所以让我们直接进入主题。下面是前三帧和标题的代码。我用网格法把它们放在 app 里。您可能已经注意到了，标题在顶部(第 0 行第 0 列)，中心在中心(1，0)，底部框架在中心框架的下面(2，0)。我添加了一些参数，比如边框宽度和pady(y 轴填充)，让它看起来更漂亮。当我们创建框架时，我们需要告诉 Tkinter 它们属于哪个窗口，我们通过将 window 变量(我们的主窗口)作为框架的主窗口来定义它。这里的关键点是，参数 master 用于每个小部件中，它定义了小部件的放置位置。

我们还在标题中放置了一个标签，因此在标签小部件中传递了 frame_header 。每个小部件的流程都是一样的。你用你想要的小部件创建一个变量，告诉 Tkinter 它属于哪里，然后把它放在应用里。由于 frame_header 将只包含标题标签，我们将其放在位置 0，0。摆弄标签参数来理解你的格式选项！这个是关于 Tkinter 以及如何使用这些小部件的非常好的资源，并附有例子。

记住上面的代码必须放在 window.mainloop()之前，否则程序不会运行

这是一个好主意，节省一些时间和挫折以后总是测试你在做什么。你可能认为你把所有的东西都放在了最合适的位置，但是当你运行这个文件的时候，这简直是疯了。它发生了！所以我们需要不时地运行这个文件，看看小部件是如何显示的。这是没有办法的。如果你来自 Jupyter 笔记本，先不要惊慌。您正在使用的编辑器可能有运行文件的方法(希望是 Python 文件！).在 Spyder 中，您可以在编辑器中直接使用 F5，控制台将运行代码。事实上，大多数 IDE 都有相同的快捷方式(F5)来运行文件。就是这么简单…如果你有我给你看的代码，和最后的main loop()，在你运行它之后，应该会弹出一个窗口。恭喜你，这是你第一个 GUI 的开始！

它看起来还不太像，但我们会到达那里。如果你注意代码，我说我放了三个框架，但是只有标题出现了…是的，那是我和 Tkinter 的第一次斗争。我没有意识到框架只有在有某种元素的情况下才会出现。咄…！所以接下来我们将处理其余的帧。您可以关闭应用程序窗口，并根据需要多次运行该文件。

检查之前先打包

让我们在中心框架内再添加两个框架， frame_main_1 和 frame_main_2 。同时，让我们也为这些帧添加标签。我想有一个输入框的每一个标签。我们接下来会处理这个问题。

标签的逻辑和框架一样。我们告诉 Tkinter 标签属于帧 1 和帧 2，以及它们将显示什么文本。拥有 GUI 的目的是让用户更流畅地与程序交互，所以我们需要决定我们希望用户给我们什么输入。如果您还记得另一篇文章中的代码，我们需要一些字符串来构建我们的 url，所以本质上，我们期待来自用户的字符串。标签下面的线就是这样。

我们将四个变量定义为 StringVar() 。很难用简单的术语来解释，但是可以把这种变量想象成**，当程序运行**时，Tkinter 能够跟踪的对象。然后，您可以创建当这些变量发生特定事件时要执行的操作。他们还是一串，但属于不同的品种！

我不得不在最后一行加上*。pack()* 因为否则，如果我们再次运行程序，什么也不会显示。请随意删除最后几行，然后再次运行程序。它将显示与之前完全相同的框，只有标题。我在这一点上告诉你，因为这些线不会停留在这个位置，因为我们需要在打包所有东西之前添加更多的部件(和一些功能)。文章最后一段应该有完整代码的链接！

if you run it now, it’s clear we’re getting there

等等，还有功能？！

我故意把函数留到后面，但是它们必须放在 import 语句下面的某个地方和 widgets 部分之前。这里有四个函数，其中两个是我们的条目表单所需要的(使城市条目中的字母大写，并将长度限制为 3 个字符)。我们还将有两个按钮，一个运行机器人，另一个退出应用程序。 run_app 函数将在后面介绍。

我们希望用户输入什么？简单…我们希望他们键入城市(出发和到达)，以及旅行日期(出发和返回)。有了这个，机器人就可以做自己的事了。第三个视频涵盖这部分！

我将需要函数 caps_from 和 caps_to ，因为我们需要在输入框中使用它们的 bind 方法。什么*。bind()* 的作用是等待小部件中的事件发生，并运行一个序列/函数。在这种情况下，小部件是输入框，事件是按键释放，函数将限制字符长度并将字母转换为大写。非常简单，我觉得这是你的保留曲目的一个很好的技巧！

如果您要一段一段地进行，只需将 tkinter_app3.py 中之前的 pack() 语句替换为这个代码片段中的整个代码 tkinter_app5.py.

you can only type 3 letters, and it converts them to upper case as you type

按钮在哪里？！

是的，是时候让按钮显示在应用程序中了。我们已经处理了退出应用程序的功能。这个命令叫做“destroy ”,听起来超级毛骨悚然和恐怖，但它就是这么做的:它破坏了窗户！所以，我们的 close_app 函数就是一行， window.destroy() 。我们之前创建的 run_app 函数将简单地在控制台中打印“run ”,所以如果我们收到一个文本说“run ”,我们将知道它正在工作。

这一部分可以直接放在最后一个代码片段的下面， mainloop() 将负责正确的执行。所以你可以打包小部件，然后再创建几个，打包在下面。重要的是跟踪你正在使用的订单。否则，更复杂的脚本会变得混乱。

按钮小部件很容易与参数“command=”中的函数进行映射。注意我是如何将一个指向 run_app 函数，另一个指向 close_app 。哦，这些按钮的主人是底部框架。

瞧啊！界面完整。它看起来很粗糙，校准可能会更好(至少可以这么说)，但嘿…这是你的应用程序，所以继续改进它吧！

finally, something that looks like an actual tool!

这应该给了你为你的脚本构建简单应用的基础，但我们仍然需要将这个项目链接到我们的 Flight Scraper 脚本，并重做 run_app 函数，用“开始”按钮激活它。下面是 run_app 函数最终的样子。该功能使用方法。get() 在条目上，它将使用 Flight_bot()启动我们的 Bot。然后，它将用户输入传递给作为机器人一部分的函数 start_kayak 。你应该能从上一篇文章中认出它的名字。

请注意:为了启动机器人，您需要在初始导入中导入它！！查看第四个视频

我是这样做的:将上一篇文章中的脚本(在 jupyter 笔记本中)改编成一个名为 flight_scraper_bot.py 的 py 文件，并将其放在与我们正在处理的文件夹相同的文件夹中。从那里，我们可以导入它并在我们的程序中使用它。这个 py 文件可以在这里找到。我们需要添加到 tkinter 文件中的行是:from Flight _ scraper _ Bot import Flight _ Bot

这已经包含在我们脚本的最终版本和编译版本中，我把它放在这里供您抓取。这比在整篇文章中复制和粘贴多个片段要容易得多。不客气！

我在视频中对它进行了更详细的介绍，所以如果你需要帮助，一定要看看它们。就像我在开始提到的，你的评论对帮助我提高文章和视频的质量非常重要，所以请随时发送你的反馈和问题！

这本 的书 有我需要知道的一切，无论何时我正在与一个特定的小部件作斗争。如果你想掌握 Tkinter，我相信它可以帮助你。如果你对网页抓取部分感兴趣，这是我用来学习 Selenium 和其他人的 书 。(如果您使用此链接，我会收取少量费用，无需您支付额外费用。我确实需要很多咖啡来写这些文章！)**

it’s funny because it’s true…

感谢您的阅读！如果你喜欢这篇文章，我邀请你看看我的其他故事。我主要感兴趣的是数据科学、 区块链 和数字货币、技术，以及其他一些类似 摄影 ！

如果你想取得联系，可以在这里联系我或者直接回复以下文章。

将数据愿景转化为数据行动计划

原文：https://towardsdatascience.com/turning-a-data-vision-into-a-data-action-plan-820976c22a4f?source=collection_archive---------28-----------------------

好吧，假设你最近被聘用或调任一个职位，负责将你的公司转变为一个更加数据驱动的公司。本文将介绍如何将您的数据愿景转化为数据行动计划。这样，你就有了一个指导框架，将你的愿景和战略以及最后的战术步骤联系起来。顺便说一句，这些想法大部分来自我个人的经验，我发现这些想法很管用。

从为什么到如何和什么

为什么是数据愿景。愿景为战略目标奠定基础。这里有几个数据愿景的例子。“5 年内，80%的销售额将来自数字销售。”另一个例子，“我们一半以上的管理工作将有自动化流程，这将消除手动耗时的任务。”

请记住，在开发数据目标的过程中，将它们分散到多个业务部门是很有帮助的。数据转换影响到公司的多个部门，并且不是单独完成的。换句话说，不要让所有的 KPI(关键绩效指标)都是财务的。除了财务指标之外，还要检查与转型相关的其他因素，如客户满意度、节省的时间、减少的错误等。

寻找开始数据转换的地方

根据你的企业规模，这可能比其他人更容易。我们将从大公司的角度来讨论，因为小公司只需要较少的步骤。任何做过任何形式的组织管理的人都知道，这需要很多时间。我记得我与一位前财富 500 强高管的对话曾告诉我，“我们的公司就像浴缸里的战舰。转向需要时间。”开始的一个方法是选择公司中你认为会产生显著影响的部分。在大多数情况下，这恰好与销售、营销或避免巨额成本有关。

请记住，技术支持业务

人是感性的。在丹尼尔·卡内曼的书中，思维，快和慢陈述了思维有两个系统[1]。系统一更快更感性。系统二缓慢、复杂，而且耗费脑力。大多数人在系统一中思考。当人们被激情激怒时(系统一)，他们往往会变得过分热情，有时会失控。在数据转换的情况下，与其他选择相比，数据领导者有时会沉迷于多种技术的潜力，而没有为业务实现任何实质性的价值。

技术意味着提高业务效率，从而为市场或客户带来更高的价值。一个可以使用的实用方法是敏捷方法。敏捷宣言是一个可以应用于任何项目的软件开发框架，它关注于创造价值而不是庞大的计划[2]。在商业中，价值可以定义为更多的销售、自动化程度的提高、风险的降低等等。一个功能性的原型比仍在开发中的完美系统好一百倍。

建立有回报的预算

在制定数据转换计划时，幸运的是，大部分成本都很容易估算，而且可信度很高。你知道你需要购买多少技术，员工工资，培训费用等等。

另一方面，收益的不确定性更大。例如，我参与的一个项目是用人工智能模型开发一个改进的信用风险管理。一个主要问题是数据质量差。一旦数据质量提高，它不仅有助于信用模型，也有助于其他风险经理评估他们的手动决策，该模型的援助。类似地，对于看不见的事件，组织也有改变的成本或接受的成本。人们的改变需要时间，这一点必须在预算项目的预期持续时间中考虑进去。

结论

在实现数据转换的过程中，数据远景充当了一个目标，从中可以推导出策略和具体的操作步骤。与所有其他目标一样，数据愿景必须支持一个期望的目标，包括具体的、可衡量的任务以及最终期限。为了获得更高的初步成功机会，从公司中对收入或利润有重大影响的部分开始。

一旦最初的项目成功了，你就可以更容易地将愿景应用到业务的其他部分。在转型的过程中，请记住所应用的技术是为了支持业务。不要为了追求新技术而追求新技术。你的项目在改善业务方面有一个关键的价值。就预算规划和估算回报而言，成本很容易估算，而收益是多方面的，有时是不可预见的。这是一件好事，这是数据科学为什么会存在的一个例子。

最后一个实用的注意事项是，当与决策者和关键利益相关者谈论过程改进时，一定要记住解释改进如何帮助他们的角色。大多数人倾向于认为 AI 会抢走他们的工作。事实上，我们正在让他们的角色变得更轻松，这样他们就可以专注于更重要的任务，从而改善他们的生活并使业务受益。

免责声明:本文陈述的所有内容均为我个人观点，不代表任何雇主。此外，这篇文章包含附属链接。

来源

[1] D .卡尼曼，思考，快与慢 (2013)，法勒，斯特劳斯和吉鲁

[2] W. Cunningham，敏捷软件开发宣言(2001)，https://agilemanifesto.org/

借助英特尔 Movidius NCS2，将 Raspberry Pi 3B+变成强大的对象识别边缘服务器

原文：https://towardsdatascience.com/turning-a-raspberry-pi-3b-into-an-object-recognition-server-with-intel-movidius-ncs2-8dcfebebb2d6?source=collection_archive---------9-----------------------

我们通过部署 MobileNet-SSD 架构，使用英特尔 OpenVINO 平台，将 raspberry PI 3B+变成一个对象识别服务器。

The Intel NCS2 attached to a Raspberry Pi Model 3B+, the hardware used in this tutorial

在这一部分中，我们将在英特尔神经计算棒中使用一个易于编译的神经网络，以便它能够接收 Base64 编码的图像，并将它们转换为边界框预测。此外，还将提供一个向 PI 发送摄像机输入的前端示例。请不要忘记查看由 Mattio Varile 撰写的关于如何部署和测试模型的精彩 w 评论。

• 预训练和编译的模型将在附件中提供。
• 为自定义数据集训练和编译模型以及前端的更多细节将是另一个故事的一部分，敬请关注！

System diagram visualizing the flow of information via numbers. Click here for the draw.io diagram: https://drive.google.com/file/d/17yTw1YnhjOJh_EjIYLqGVYuYjnB8pKyl/view?usp=sharing

0。要求

• 1。准备树莓酱
• 1.1。安装 NOOBS 镜像
• 1.2。安装最新的英特尔 OpenVINO 软件
• 1.3。在神经计算棒上部署对象检测
• 3。运行服务器并设置开机自动启动
• 4。使用示例 GUI 部署我们的服务器
• 5。结论和展望

更新 1，2019 年 5 月 29 日:现在包括系统图，
更新 2，2019 年 8 月 5 日:pybase64 因未使用而从要求中删除

0.要求

• 树莓派，最好是 3B+型，但其他型号也可以https://www.raspberrypi.org/products
• 英特尔 NCS 2https://software.intel.com/en-us/neural-compute-stick

可选择的

• 一些 USB 摄像头
• 一些其他的计算机来运行前端

1.准备树莓酱

1.1.安装 NOOBS 映像

在 FAT32 格式的微型 SD 卡上刷新 NOOBS 图像。https://www.raspberrypi.org/downloads/

正常启动 USB 镜像，设置账户密码，连接互联网等…

确保同时安装 python3、pip3 和 wget

sudo apt-get update
sudo apt-get install python3-picamera python3-pip wget

1.2.安装最新的英特尔 OpenVINO 软件

下载 OpenVINO 工具包

cd ~/Downloads && wget [https://download.01.org/opencv/2019/openvinotoolkit/l_openvino_toolkit_raspbi_p_2019.1.094.tgz](https://download.01.org/opencv/2019/openvinotoolkit/l_openvino_toolkit_raspbi_p_2019.1.094.tgz)

我建议遵循以下指南，直到(不包括)“构建和运行对象检测示例”一节。

[## 为 Raspbian*操作系统安装 OpenVINO 工具包——open vino 工具包

open vino toolkit 以前被称为英特尔计算机视觉软件开发套件。这些步骤适用于 32 位 Raspbian* 9 操作系统…

docs.openvinotoolkit.org](https://docs.openvinotoolkit.org/latest/_docs_install_guides_installing_openvino_raspbian.html)

成功完成所有操作后，当您打开一个新的终端时，您应该会看到以下输出:

1.3.在神经计算棒上部署对象检测

我们将使用 flask 服务器来接收用于预测的编码图像。你可以在下面的 github 库【https://github.com/AlexeyGy/NCS2-server 找到所有的代码

a)首先在您的主文件夹中创建一个名为 detection_server 的新文件夹。

mkdir ~/detection_server && cd detection_server

b)用以下内容创建一个 requirements.txt 文件。该文件包含所需的包。

• flask 是网络服务器，flask-cors 是传递 cors 头的包装器(跨站点脚本需要)，更多关于它的在这里
• 注意 OpenCV (cv2)不在这个包列表中，因为这个包是在步骤 1.2 中与 OpenVINO 一起安装的。这是因为 OpenVINO 提供了自己的 cv2 风格，包括对 CNN 架构的支持。

flask-cors
flask

现在快跑

pip3 install -r requirements.txt

自动安装软件包。

c)设置服务器启动脚本，创建一个名为 RUN 的文件。嘘

d)下载预训练的 MobileNet-SSD 架构中间表示文件，该文件可以区分螺钉和 rawl 钉。请继续关注本教程的第二部分，我们将讨论培训。

mkdir models && cd models && wget [https://github.com/AlexeyGy/NCS2-server/raw/master/models/no_bn.bin](https://github.com/AlexeyGy/NCS2-server/raw/master/models/no_bn.bin) && wget [https://github.com/AlexeyGy/NCS2-server/raw/master/models/labelmap.prototxt](https://github.com/AlexeyGy/NCS2-server/raw/master/models/labelmap.prototxt) && wget [https://raw.githubusercontent.com/AlexeyGy/NCS2-server/master/models/no_bn.xml](https://raw.githubusercontent.com/AlexeyGy/NCS2-server/master/models/no_bn.xml)

您可以看到该架构包含三个文件，一个包含可能标签的 labelmap，一个包含冻结网络权重的. bin 文件和一个包含网络拓扑的. xml 文件。更多信息可以在这里找到。

Intel IR model. Image courtesy of Intel https://software.intel.com/sites/default/files/managed/ed/e9/inference-engine-700w-300h.png

e)现在让我们创建实际的服务器，使用以下内容创建文件 server.py。下面将提供关于各个功能的更多细节。

• 在第 12 行，我们使用英特尔 OpenVino cv2.dnn.readNet 函数读取提供的模型文件
• 第 14 行为我们的计算设置了一个更好的运行目标
• 第 17- 19 行包含了我们的 flask 服务器的一些标准配置，
• 第 23 行使用 flask-cors 包装器来设置 cors 头，更多信息在这里
• 第 25–29 行是可选的，它们为所有不包含正确格式的 jpg 或 png 图像的输入数据设置了一个过滤器
• 第 31 行为我们的 flask 服务器设置了默认路由，我们接受包含图像的 POST 请求
• 除了传递给服务器 s.t .的图像之外，第 37 行还允许我们接受一个阈值。所有低于阈值的预测都不会返回
• 第 43 行返回预测结果的 JSON
• 第 46–50 行中的函数执行实际的图像处理，我们稍后将进入相应的 util_mobilnet.py 文件。以下是对其功能的高级概述
  —首先执行特定于 Mobilenet-SSD 架构的预处理和缩放步骤
  —然后网络进行推理(第 48-49 行)
  —最后执行后处理步骤，包括阈值过滤

f)最后，让我们创建并查看 util_mobilnet.py 文件

• 第 5 行配置了 mobilnet 需要的尺寸，因为它是在 300x300 的正方形图像上训练的，我们将它设置为我们的尺寸
• read_labels 函数逐行读取 labelmap 文件来定义支持的类
• 第 21 行中的预处理函数处理传入图像的颜色和尺寸，mobilnet 需要任意的转换来正确处理图像
• 第 32 行中的后处理函数检查所有预测，并过滤掉低于阈值的预测，此外，不返回背景预测

3.运行服务器并设置启动时自动启动

为了最小化 raspberry PI 上的资源使用，我们想要建立一个客户端服务器应用程序，其中 flask 服务器接收图片并返回边界框预测。

我发现自动启动烧瓶的最佳方法是 a)将烧瓶启动添加到。b)使用自动登录将系统设置为自动启动到 cli。

a)至于将这些行添加到。bashrc 文件，确保将“Downloads”文件夹设置为您下载 OpenVINO 工具包的文件夹

b)在终端中运行以下行

sudo raspi-config

您将看到以下屏幕，您应该在其中选择选项 3 引导选项/ 1 桌面 CLI / 2 控制台自动登录

select the options as per screenshots

现在，启动后，你会看到树莓会在端口 5000 上自动启动 flask 服务器，恭喜！

4.使用示例 GUI 部署我们的服务器

以下步骤应该在另一台机器上执行，但是如果您选择在 Raspberry 上运行 GUI，它们也可以在 Raspberry 上执行(这会导致性能降低)。

克隆库https://github.com/AlexeyGy/NCS2-frontend

git clone [https://github.com/AlexeyGy/NCS2-frontend](https://github.com/AlexeyGy/NCS2-frontend)

只需运行运行。SH 文件来运行一个简单的 python 服务器。你可以通过 localhost:8000 访问它，但是在你看到任何图像之前，你可能需要让它访问你的相机。

permission request

服务器会将网络摄像头图片发布到地址 http://192.168.0.2:5000/ ，如果您使用的不是您的 raspberry，请确保将其定制到您的 raspberry 的地址。

我会写另一篇文章，介绍 JavaScript 前端如何确保边界框绘图只有在收到来自我们的 raspberry 服务器的新响应时才会刷新。

给定的示例 GUI 来自 FIR 的一个试点演示器，我们用它来演示智能合同平台的可能用例。在以后的文章中会有更多的介绍。

您可以通过浏览器的 JavaScript 控制台调试设置。

5.结论和展望

这是前端和后端一起运行的整个系统的 gif 图:

螺丝和罗尔塞的检测示例

如果在两台机器上运行，运行的系统能够传送 60fps 的视频，检测时大约 8 fps。用户体验不会受到影响，因为预测是由 JavaScript 前端以异步方式显示的。我发现太多的检测帧会导致糟糕的用户体验，因为检测更新得太快了！

随着边缘计算的到来，像谷歌这样的其他竞争对手也加入了这场竞赛，我们将迎来神经计算棒的一些令人兴奋的未来用例。

请继续关注培训和前端设计部分。

资源

• Mattio Varile 撰写的关于如何部署和测试模型的文章
• 英特尔神经计算棒官方教程
• 更多关于 Movidius on Raspberry inc .的信息性能测量作者Adrian rose Brock

将数据转化为可操作的见解

原文：https://towardsdatascience.com/turning-data-into-actionable-insights-c246969fa4c?source=collection_archive---------14-----------------------

Credit: Alaa Khamis

数据和见解

洞察力是新的黄金，而不是数据，因为数据没有价值，除非这些数据转化为重要的可操作的洞察力。这些见解可用于支持决策，并有助于改进设计和制造流程。机器学习算法可以用来完成不同的应用数据挖掘任务。这些任务可以是描述性分析、预测性分析、诊断性分析和规定性分析。描述性数据分析提供对过去和现在的洞察，而预测性分析预测未来。诊断分析提供根本原因分析，说明性分析就可能的结果及其预期影响提出建议。

数据分析

描述性数据分析提供了对数据及其性质的更好理解，并识别数据中的模式或关系。这些描述性模型回答了以下问题:

• 发生了什么事？
• 现在发生了什么？
• 某个变量的趋势是什么？
• 变量之间有什么关系？
• 一个项目相对于其他项目或基准项目的表现如何？

预测模型对数据的未来值进行预测，并预测新的特性，而不是像描述性分析那样只是探索数据属性。这些模型回答了以下问题:

• 会发生什么？
• 什么时候会发生？
• 会在哪里发生？

诊断分析提供根本原因分析来回答以下问题:

• 为什么会这样？
• 为什么会这样？

最后但并非最不重要的一点是，规范模型侧重于决策支持。这个决策支持或推荐引擎回答以下问题。

• 从预测模型中获得的预测会如何影响其他一切？
• 需要做出什么样的主动决策/行动？
• 我们如何从预测/建议中受益？
• 最好的行动是什么？
• 采取这一行动的最佳时机是什么？
• 这一行动会产生什么影响？

以预测性维护为例

预测性维护是一种预防性维护方法，它依赖于对实际机器状况、运行效率和运行状况的其他指标的定期监控和分析，以检测早期问题，最大限度地减少计划外停机的次数和成本，并防止关键设备发生灾难性故障。根据麦肯锡的数据，到 2025 年，预测性维护将帮助公司节省 6300 亿美元。幸运的是，机电设备不会毫无征兆地损坏。故障发生前几个月，可以发现最小的振动。故障前几周，明显的噪声开始出现。在机器升温前几天和故障前几分钟，它开始冒烟。

Data Analytics | Credit Alaa Khamis

在这种情况下，描述性分析可以洞察机器的当前状况。而预测模型可以执行健康评估并预测任何初期问题或可能的故障或异常。诊断分析提供根本原因分析，最后，说明性分析模型可以处理由描述性分析模块生成的关于机器当前状态的信息、来自预测性分析模块的健康评估以及任何其他可用的先验知识。然后，它会针对主动行动或维护计划提出及时的建议/决策，以降低任何可能的风险。使用这些推荐的决策和由说明性分析模型生成的预期影响信息，用户可以考虑最高优先级的维护需求来主动规划维护，或者可以创建工作订单并向指定的技术人员发送关于所需维护的消息，以便保持生产力并减少停机时间和维护支出。

数据汇总、可视化、聚类、数据关联和序列发现是描述性分析中的常见任务。而预测分析使用分类、回归和时间序列分析来提供信息，如异常预测、故障风险评分、故障前时间或剩余使用寿命估计和/或退化趋势。诊断分析使用事件和因果因素分析、变化分析、障碍分析、故障树分析和自然语言处理等技术来解释可能的故障原因。规定性分析采用来自机器学习、算法推理、优化和自然语言处理的不同人工智能技术来提供建议，以减轻机器中任何可能的风险。

在当前弱/窄的 AI 浪潮中，分类和回归是最常见的成熟和使用的 ML 技术。强/一般人工智能浪潮将使更复杂的 ML 技术成熟，以处理更多依赖于认知数据收集和准备、聚类、数据关联和时间序列分析的数据，包括序列发现、趋势/周期性/季节性、相似性分析和存档、流式和实时数据中的异常检测。

将数据转化为声音

原文：https://towardsdatascience.com/turning-data-into-sound-4854a35b3504?source=collection_archive---------8-----------------------

听起来是个好主意！

Photo by Spencer Imbrock on Unsplash

我在西蒙·罗杰斯的帖子的启发下，介绍了 TwoTone ，一个将数据表示为声音的工具，我创建了我的第一个数据“发音”(也就是数据的音乐表示)。这让我特别感兴趣，因为我只梦想创造令人瞠目结舌的可视化效果，但从未想过我可以将数据转换成另一种格式，尤其是声音。这篇文章涵盖了双音以及如何使用它的基础知识。

什么是发音？

发音是指使用声音来表示数据，通常是为了补充或取代传统的可视化。尽管它已经存在了相当长的时间(1908 年首次使用)，但它还没有像可视化一样被探索——这使得它成为想要尝试新事物(和酷)的人的绝佳选择。

什么是 TwoTone？

TwoTone 由数据化技术在谷歌新闻倡议的支持下构建，是一个进行发音的工具。它既是一个网络应用程序(在你的浏览器上运行)，也是一个命令行应用程序(在你的电脑上运行)，允许没有任何音乐或技术背景的用户从他们的数据集创建声音，以便更好地理解它们！

有了上面的特性，对于想打入数据科学领域而没有太多背景知识的人来说，它是一个非常棒的工具！这很容易上手。

数据如何转化为音频？

为了将数值转换成音频，TwoTone 使用**音阶，**由此较高的值对应于较高的音高。你可以在这里阅读更多关于它的信息。事不宜迟，让我们开始使用双色调吧！

如何使用 TwoTone？

在这篇文章中，我将使用 TwoTone 的更加用户友好和易用的网络应用。

前往 app.twotone.io 开始吧！您不需要帐户，但您肯定需要数据集—您可以选择自己的帐户，也可以使用任何可用的默认帐户。点击“开始”按钮后，系统会提示您选择“数据源”

TwoTone accepts any form of tabular data with the above specifications

我将使用数据集“美国历史收入、公共债务和 GDP”，这是 TwoTone 作为样本提供的数据集之一。也可以选择添加自己的数据(确保符合要求)。

在您按下“选择”后，您将获得一个门户网站的迷你导览(请不要跳过)。随着巡演的突出显示，一个音频轨道是自动为您生成的！你说完了吗？号码

重要的一点是，TwoTone 仅支持每个音轨一个数据源，这对于音阶来说有直观的意义。但是，您可以添加多个“轨道”来添加更多的数据！

很明显，你可以用数据做更多的事情，为什么要降低要求呢？让我们探索一些有趣的特性:

1:不同的乐器

Photo by John Matychuk on Unsplash

是的，你没听错。您可以选择用不同的工具来表示您的数据！弹出打开音轨的乐器下拉菜单，您可以查看以下菜单:

Different instruments supported by TwoTone

没错！您可以在 12 种不同的乐器中“声音化”您的数据！选择您最喜爱的乐器，然后按下播放按钮，聆听您的数据。

2:多首曲目——成为 DJ

Photo by Skullector R on Unsplash

是的，你也可以通过混音成为 DJ。点击右下方的“+”图标添加另一个音轨，并选择“音阶”(我们稍后会谈到另一个选项)。Tada！还会自动为您创建另一个音频轨道。现在，你可以改变数据源或乐器来改变这个轨道的声音，并尝试混合！

PS:不一定要停在两条轨道上。

3:带旁白的讲故事

Photo by Jason Leung on Unsplash

添加另一个轨道时还记得另一个选项吗？那是旁白！您可以通过在曲目之间或期间进行叙述，将自己的声音添加到数据中，并制作成一个美丽的故事。通过这种方式，您可以用数据讲述一个“故事”,并从多个受众的数据中获得见解和意义。

完成后，您可以导出音频(右下角)并将其下载到您的计算机上！这是我第一次发音！

如果你制作了一个发音，请通过回复这个故事或发送给我来与我分享！我总是对用数据(和发音)讲故事感兴趣。

将 Lending Club 的最差贷款变成投资黄金

原文：https://towardsdatascience.com/turning-lending-clubs-worst-loans-into-investment-gold-475ec97f58ee?source=collection_archive---------15-----------------------

So shiny…

我们使用机器学习从 Lending Club 最垃圾的贷款中挖掘利润

这是我完成的一个机器学习项目的文字记录。在这篇文章中，我希望:

• 描述一下我预测贷款违约的算法。
• 使用该算法构建一个获得高于平均回报率的清洁贷款投资组合。
• 介绍并解释 ROC 曲线、精确度和召回率。

你可以在我的 GitHub 上找到我用来运行分析的 代码。

L ending Club 是最初的 P2P 贷款公司之一，也是金融科技的宠儿(尽管不再是了)，是一项有趣的业务。他们通过把想借钱的人和愿意借钱的人联系起来来赚钱。Lending Club 通过筛选出风险最高的借款人，并使用其专有算法为所有通过筛选的贷款申请人分配一个等级(和利率)，从而为这一过程增加价值。

我们今天对它们感兴趣，因为它们提供了目前很少有其他投资资产提供的东西——丰厚的利率。对于那些关注金融趋势的人来说，你们知道自 2008 年金融危机以来，美联储(美国中央银行)已经将收益率推至并维持在历史低位。请查看下面的图表:

The One Year Treasury Bill Rate is Pretty Low These Days

这种低利率货币政策的最终结果是整个风险范围内的收益率下降**(收益率是利率的另一种说法)**。从抵押贷款利率到高收益债券(向负债水平相对于收入较高的公司发放的贷款)的利率，所有收益率都被压缩至历史低点，因为投资经理会购买任何能够为他们带来可观回报的东西。

如果你有兴趣投资一些能给你固定利率的东西，这是你的选择菜单(见下图)。在通胀和美国国债勉强跑赢通胀后，你的银行账户为你赢得了负回报。将风险曲线进一步延伸到各种类型的公司债也没有多大帮助。但是那边是什么？

Inflation Adjusted Yields for Various Investment Assets

粉色条真的跳出来对吧？“Lending Club High Yield”是 Lending Club 的 D、E、F 和 G 评级贷款收益率的加权平均值(其中 A 最高，G 最低)。这些垃圾贷款(金融业对风险贷款的说法)比它们的高评级(A、B 和 C)同行提供了更高的收益率。A、B 和 C 级贷款的平均收益率比垃圾贷款的收益率低大约 12%！

问题是

那么有什么问题呢？问题是这些垃圾贷款的违约率极高。

我看到大约 28%的垃圾贷款违约了！(我的数据集是 2015 年由 Lending Club 发起的每 36 个月的贷款)

下图显示了这一巨大的违约率是如何影响我们本以为会获得的 15%的收益率的。违约让我们的通胀调整收益率从 15%下降到仅仅 2%！2%的回报包括收回的部分——在借款人违约后从借款人那里提取的欠款。

After Defaults, Lending Club Junk Loans Yield Very Little (All Yields are Inflation Adjusted)

但是还是有希望的！

并非一切都没了。如果我们能够建立一个分类模型，可靠地预测哪些贷款将成为坏账，那么我们就可以将投资集中在我们的模型认为最不可能违约的垃圾贷款上。首先让我们后退一步，回答这个问题，“什么是分类模型？”

分类是机器学习算法的一个流行目标——我们想知道一个观察值属于哪一类(也称为组)。对观察结果进行精确分组的能力对于各种业务应用程序非常有用，比如预测某个特定用户是否会购买某个产品，或者预测某笔贷款是否会违约。

如果上面的段落听起来很熟悉，那是因为我几乎一字不差地引用了之前的博客文章。在那篇文章中，我写了大量关于随机森林分类器的内容——我们现在将使用该算法将每笔贷款分类为可能违约或不可能违约。

*如果你想更深入地了解随机森林是如何工作的，请阅读那个帖子。但是这里是 TLDR — **随机森林分类器是许多不相关的决策树的集合。*树木之间的低相关性产生了多样化效应，使得森林的预测平均优于任何单个树木的预测，并对样本外数据具有鲁棒性。

随机森林算法采用以下两种技巧来减少树之间的相关性—【bagging】(引导聚合)和特征随机性(查看我在随机森林上的帖子了解更多) 。

特征选择

*我用来构建模型的贷款数据和特征来自 Lending Club 的网站。我下载了。包含 2015 年承保的所有 36 个月贷款数据的 csv 文件。如果你在没有使用我的代码的情况下玩他们的数据，**一定要仔细清理以免数据泄露。*例如，其中一列代表贷款的收款状态——这是我们在发放贷款时肯定无法获得的数据。

正如贷款数据所预期的那样，大多数特征都与借款人的个人和财务特征有关:

• 房屋所有权状况
• 婚姻状况
• 收入
• 债务收入比
• 信用卡贷款
• 贷款特征(利率和本金金额)

因为我有大约 20，000 个观察值，所以我使用了 158 个特性(包括一些自定义特性——ping me 或查看我的代码,如果你想知道细节的话),并且依赖于适当地调整我的随机森林来保护我免于过度适应。

使用 ROC 曲线的模型选择

尽管我让它看起来像随机森林和我注定要在一起，我也考虑过其他模式。下面的 ROC 曲线显示了这些其他模型如何与我们心爱的随机森林(以及随机猜测，45 度虚线)相比较。

ROC Curves for the Various Classification Models I Tried (Validation Data)

等等，你说什么是 ROC 曲线？我很高兴你这么问，因为我写了一整篇关于它们的博文！

万一你不想读那篇文章(真让人难过！)，这是一个略短的版本 ROC 曲线告诉我们，我们的模型在收益(真阳性率)和成本(假阳性率)之间的权衡有多好。让我们根据我们当前的业务问题来定义这些意味着什么。

The Confusion Matrix

• ***真阳性率，也称为召回率，是真阳性与实际违约的比率。*在我们的混淆矩阵(左侧)中，它是绿色方框除以绿色和黄色方框之和。它告诉我们用我们的模型正确分类的实际违约的百分比。
• ***误报率是误报与实际无违约的比率。*在我们的矩阵中，它是红色方框除以红色和蓝色方框之和。它告诉我们被我们错误归类为违约的干净贷款的百分比。

关键是要认识到虽然我们想要一个漂亮的大数字在绿盒子里——增加真阳性也是以牺牲红盒子里更大的数字为代价的(更多的假阳性)。

让我们看看为什么会出现这种情况。对于每一笔贷款，我们的随机森林模型都给出了违约概率。但是什么构成了默认预测呢？25%的预测概率？50%呢？或者我们想额外确定 75%？答案是视情况而定。

决定一个观察值是否属于正类的概率截止值是一个我们可以选择的超参数。

这意味着我们的模型的性能实际上是动态的，并根据我们选择的概率截止值而变化。如果我们选择一个非常高的截止概率，如 95%，那么我们的模型将只把一小部分贷款归类为可能违约(红色和绿色框中的值都很低)。但另一方面，我们的模型只捕获了实际违约的一小部分——或者换句话说，我们的真实正利率很低(黄色框中的值比绿色框中的值大得多)。

如果我们选择一个非常低的截止概率，例如 5%，就会出现相反的情况。在这种情况下，我们的模型会将许多贷款归类为可能违约(红色和绿色框中的大额贷款)。由于我们最终预测大多数贷款将会违约，因此我们能够捕捉到绝大多数的实际违约(高真实正利率)。但结果是，红框中的值也非常大，因此我们背负着很高的假阳性率。

How a ROC Curve is Generated

回到 ROC 曲线

哇，这是一个比预期更长的题外话。我们终于准备好复习如何阅读 ROC 曲线了。

左边的图表显示了 ROC 曲线上的每条线是如何绘制的。对于一个给定的模型和截断概率(比如截断概率为 99%的随机森林)，我们通过其真阳性率和假阳性率将其绘制在 ROC 曲线上。在我们对所有截止概率做了这些之后，我们在 ROC 曲线上画出一条线。

但这实际上意味着什么呢？

右边的每一步都代表着截断概率的降低——伴随着假阳性的增加。因此，我们需要一个模型，对于每一个额外的假阳性(产生的成本),该模型能够获得尽可能多的真阳性。

这就是为什么模型越呈现驼峰形状，其性能就越好。曲线下面积最大的模型是驼峰最大的模型，因此也是最好的模型。

咻终于解释完了！回到上面的 ROC 曲线，我们发现 AUC 为 0.61 的随机森林是我们的最佳模型。其他一些有趣的事情需要注意:

• 名为“Lending Club Grade”的模型是一个以 Lending Club 自己的贷款等级(也包括子等级)为特征的逻辑回归。虽然他们的成绩显示出一些预测能力，我的模型优于他们的这个事实暗示着他们，不管是有意还是无意，没有从他们的数据中提取出所有可用的信号。

Average Interest Rate and Investor Return for Lending Club Loans (2007 to Q1/2019)

• 雪上加霜的是， Lending Club 的高风险贷款表现不如它们的安全贷款，这是现代投资组合理论的信徒所厌恶的(左图)。这里的含义是，Lending Club 可能不会向风险较高的借款人收取足够高的利率。我的预感是，达到收入目标的压力正迫使他们收取更低的利率，以吸引更多的借款人。
• 朴素贝叶斯分类器产生的结果与随机猜测的结果相同。在某个时候，我会写这个模型，但我对它的糟糕表现感到惊讶。

为什么是随机森林？

最后，我想详细解释一下为什么我最终选择了随机森林。仅仅说其 ROC 曲线的 AUC 最高是不够的，即曲线下面积(逻辑回归的 AUC 几乎一样高)。作为数据科学家(即使在我们刚刚起步的时候)，我们应该寻求理解每个模型的利弊。以及这些利弊如何根据我们正在分析的数据类型和我们试图实现的目标而变化。

***我选择了随机森林，因为我的所有特征与目标变量的相关性都很低。*因此，我觉得从数据中提取一些信号的最佳机会是使用一种算法，这种算法可以捕捉我的特征和目标之间更微妙的非线性关系。我还担心过度拟合，因为我有很多特征——来自金融，我最糟糕的噩梦总是打开一个模型，看到它以惊人的方式爆炸，第二次我把它暴露给真正的样本数据。随机森林提供了决策树捕获非线性关系的能力，以及它自己对样本外数据的独特鲁棒性。

特征重要性

scikit-learn 中的随机森林实现有一个方便的“feature_importances_”属性。如果我们检查一下我们的模型，我们会发现三个最重要的特征是:

1. 贷款利率(很明显，利率越高，月供越高，借款人违约的可能性越大)
2. 贷款金额(与以前相似)
3. 债务收入比(负债越多，违约的可能性越大)

精确度和召回率

好了，我们现在有了模型，所以终于到了构建投资组合的时候了。也是时候回答我们之前提出的问题了，“在决定是否将贷款归类为可能违约时，我们应该使用什么样的概率截止值？”

让我们定义两个关键术语:

Precision: 当我们的模型将一笔贷款归类为可能违约时，它实际违约的概率是多少？

强调精确度的模型具有高概率截止值，并且会导致更多的假阴性。

***回想一下:*在所有实际违约的贷款中，我们的模型标记了多少可能违约的贷款？

一个强调回忆的模型有一个低的概率截止值，会导致更多的假阳性。

分类中一个关键但又被忽视的部分是决定是优先考虑精确度还是召回率。这与其说是一个数据科学问题，不如说是一个商业问题，它要求我们对我们的目标有一个清晰的认识，以及假阳性的成本与假阴性的成本相比如何。

我强烈主张召回。请记住，我们的目标是找到一套我们可以放心投资的干净贷款。假阴性(我们预测没有违约，但贷款违约)会让我们付出真金白银的代价，而假阳性(预测违约，但贷款没有违约)只是一种机会成本——因此，即使贷款看起来有点不可靠，我们也应该扔掉它。总会有更多的贷款可供选择，所以在决定是否投资我们辛苦赚来的钱时，我们应该非常谨慎。

让我们用一个概率截止值 20%。

最后，投资结果

我有一个秘密要坦白——在我们分析的开始，我隐藏了大约 6500 笔贷款，这样我们现在可以用它们来执行真正的样本外测试。让我们看看我们做得怎么样。

*在我们测试的 6500 笔贷款中，有 28%违约。但是在我们的模型归类为安全(不太可能违约)的大约 450 笔贷款中，**只有 15%违约。*我们能够将违约频率降低近 50%！

这很酷，但当我们将其转化为回报时，情况会是怎样呢？Lending Club 建议投资者购买并持有至少 100 笔贷款的投资组合(以实现多样化)。因此，让我们使用蒙特卡罗模拟，从整个测试集中随机选择 100 笔贷款，并从我们的干净集(由我们的模型挑选的贷款)中反复选择 100 笔贷款(我们将运行 5000 次模拟)，看看我们做得如何。

Return Comparison — Model Picked Loans vs. All Loans

当我们只投资于我们的模型所选择的贷款时，我们成功地将获得的回报从整个测试集的 6%提高到了 12%!胜利！

结论

看起来我们能够成功预测哪些贷款更有可能违约，避免它们，并最终获得显著更高的回报。

我们还了解了更多关于随机森林的知识，如何解释 ROC 曲线，以及精度和召回因素如何影响我们模型的概率截止值。

如果你喜欢这个，请看看我的其他帖子(下面的链接)。干杯！

链接

更多来自数据科学上的真知:

了解随机森林如何工作

了解逻辑回归如何工作

我的数据科学训练营经历

更多来自贵府的真才实学:

股票比现金有超额回报吗？

下一次股市低迷可能会是什么样子

把你的手机摄像头变成一个物体探测器(靠你自己！)

原文：https://towardsdatascience.com/turning-your-mobile-phone-camera-into-an-object-detector-on-your-own-1428055b8e01?source=collection_archive---------20-----------------------

是时候释放你相机的潜能了！

如果更多人只需几行代码就能把手机摄像头变成物体探测器，会怎么样？写这个故事是为了给大家的生活注入乐趣！这可能是开始学习 JavaScript 和反应的一个很好的方法！

这个故事假设了 JavaScript、npm 和 React 的简单基础知识。嗯，可能真的很容易实现，只要按照步骤！如果你需要任何帮助，请在下面给我留言。

安装和初始准备

为了安装 npm，安装 Node.js ，npm 就会随之而来。然后，启动“命令提示符(cmd)”，指向要安装 React 应用程序的目录，并输入以下命令:

npx create-react-app obj-detector
cd obj-detector
npm install @tensorflow/tfjs @tensorflow-models/coco-ssd

该命令将创建一个新的 React 应用程序和一个名为“obj-detector”的新目录。然后它将安装 tensorflow.js 和 COCO-SSD(也称为上下文中的公共对象和单次多框检测)。

代码

进入 obj-detector/src/ 目录，打开这个文件 App.js 。用以下代码替换所有内容:

接下来，用以下代码替换 App.css 中的所有内容:

.app-position {
  position: fixed;
  margin: auto;
}

仅此而已，真的！是时候部署应用程序了。

部署

回到控制台，当您在目录 obj-detector 中时，输入以下命令来部署应用程序:

npm start

过一会儿，你应该能在你的浏览器上看到一个指向 http://localhost :3000 的页面。允许使用您的网络摄像头，并花时间玩您的物体检测器！请注意，用于检测的文件相对较大，因此需要一段时间才能开始工作。

等等，你不是说我们可以用手机吗？

是的，当然。然而，还有几个步骤要做。

首先，下载这个软件 Ngrok 并按照页面上的前 3 步来设置软件。接下来，在保持运行 npm start 的现有命令提示符的同时，启动另一个命令提示符并输入以下内容:

# Run the code on cmd while in the directory that has ngrok.exe
ngrok http 3000

You should see this after running the code

接下来，使用你的手机，在你的浏览器中访问 https URL(在我的情况下，是https://5ca 86203 . ngrok . io)，像往常一样，给浏览器访问你的相机的权限，等待探测器加载。是时候在你的手机上玩你自制的物体探测器了！

或者，你可以通过这里的访问它，我在 Heroku 上部署它。如果您担心图像的存储，您可以放心，相机不会存储任何图像。(因为是在免费账号上而且我也没有那么大的存储磁盘空间来存储那么多数据！)

Screenshot taken from my iPad. That’s what it can detect!

这就是目前实现的全部内容。如果实施有任何问题，请给我留言。干杯！

一个接一个的项目，我着迷于事物如何使用收集的数据和建立在其上的模型工作，并通过部署模型来解决现实生活中的问题。目前，我在计算机视觉和深入思考我们如何感知世界方面投入了大量时间，希望将其转化为计算机视觉的发展。你可以通过我的 LinkedIn 联系我。

自动性能图创建教程

原文：https://towardsdatascience.com/tutorial-automatically-creating-a-performance-map-of-a-heat-pump-water-heater-7035c7f208b0?source=collection_archive---------24-----------------------

您可以学习在真实世界场景中自动分析实验室数据

许多寻求学习如何用 Python 编程的人要求实际的例子，在那里他们可以通过解决现实世界的问题来学习 Python。它为这个过程提供了更多的背景和意义。

别再看了。这是教程中第一篇这样做的文章。本教程将教你 Python 编程，给出确切的代码，多元回归等数据科学概念，如何自动化整个过程，并通过解决一个常见的工程问题来实现。

我们将解决的工程问题是创建一个性能图，预测热泵热水器的性能，作为周围条件的函数。如果那句话里的专业术语对你没有任何意义，也不用担心。接下来的几节将回答你的问题。

本教程将教你几个重要的概念，例如:

• "性能图"和"热泵热水器"的定义、
• 如何编写自动化科学数据分析的 Python 代码，
• 如何分割数据文件、自动分析测试、检查那些结果是否有错误、验证、记录一个简单的仿真模型，以及
• 多元回归。

但是首先要做的是。让我们确保你理解上面的术语，因为它们是遵循教程的关键。

什么是热泵？

热泵本质上是一种在两个位置之间传递热量的装置。维基百科上的定义是“热泵是一种将热能从热源转移到所谓的散热器的装置。”热泵的一个例子是美国家庭中常见的家用空调。这些设备将热量从热源(在这种情况下是建筑物的内部)传递到散热器(建筑物的外部)。

“热泵是一种将热能从热源转移到所谓的散热器的装置。”—维基百科

但是热泵是怎么做到的呢？它是如何将热量从冷空间转移到热空间的？通过热力学的“魔力”。图 1 提供了热泵一般功能的示意图。

Figure 1: Schematic of a Heat Pump

制冷剂沿箭头方向流过图 1 中列出的所有设备。制冷剂是设计用于在特定条件下升高/降低温度的传热流体，在热泵中非常有用。

图 1 所示的四个设备都使制冷剂通过不同的过程，驱动热泵。当制冷剂通过系统时，会经历以下过程:

• 压缩机:压缩机基本上就是一个泵。制冷剂以气体形式进入压缩机，在压缩机中被泵压至更高的压力。当它被泵到更高的压力时，制冷剂变热，导致温度非常高的气体通过冷凝器。
• 冷凝器:冷凝器是连接制冷剂和散热器的热交换器。由于此时制冷剂的温度非常高，它会将热量散失给散热装置进行冷却。在我们的空调例子中，散热器是外部空气(是的，制冷剂比热空气更热！).制冷剂通过冷凝器时冷凝，形成高压中温液体。
• 膨胀阀:膨胀阀是将制冷剂导入另一侧的低压环境和条件，使制冷剂膨胀的阀门。随着它的膨胀，它会进一步冷却。这产生了一个低温流体，因为它通过蒸发器。
• 蒸发器:蒸发器是另一个热交换器，这次连接热源。以空调为例，这是室内的低温条件。由于液体非常冷，它会从室内带走热量，从而提高制冷剂的温度。当它变热时，制冷剂膨胀，导致压缩机产生冷气体。

因此循环重新开始。

设备传递的热量取决于冷凝器和蒸发器的传热速率。正如那些研究过热传递的人所知道的，这些点的热传递速率是由冷凝器和蒸发器周围的空气温度决定的。

在那个描述中有三种不同类型的能量转移。泵消耗电力以确保制冷剂通过循环。热量从制冷剂传递到冷凝器中的散热器。热量从热源传递到蒸发器中的制冷剂。设备传递的热量取决于冷凝器和蒸发器的传热速率。正如那些研究过热传递的人所知道的，这些点的热传递速率是由冷凝器和蒸发器周围的空气温度决定的。

这就产生了术语“性能系数”。性能系数表示相对于泵消耗的能量，从热源传递到散热器的热量。通常超过一个。不过，它对热源和散热器的温度非常敏感。随着这些温度越来越接近制冷剂温度，传递的热量越来越少，因此在不改变所需泵送能量的情况下降低了热泵的性能。

现在我们了解了热泵，下一个要探索的概念是热泵热水器(HPWH)。

什么是热泵热水器？

热泵热水器是一种用于加热水的热泵。他们使用一个大的储水箱，通常有 55 到 80 加仑，储存热水以备不时之需。热泵将周围空气(热源)中的热量传递给储存在水箱中的水(散热器)。图 2 显示了热泵热水器的示意图。

Figure 2: Schematic of a Heat Pump Water Heater

请注意，热泵的四个部分与图 1 中列出的部分相同。唯一真正的区别是冷凝器位于热水储水箱内。这样，热制冷剂将热量传递给水箱中的水。同时，蒸发器将周围空间的热量转移给制冷剂。这样，它将热量从空间中的空气传递到水中。

什么是性能图？

在介绍热泵一节中，我们提到性能系数取决于冷凝器和蒸发器周围的温度。这意味着性能系数将随着周围温度的变化而变化。这些温度会改变。室外温度不是全天恒定的。空调运行时，室内温度会发生变化。

人们可以想象一个曲线图或函数来描述两个温度变化时的性能系数。

这是一张性能图。性能图是在影响设备的条件发生变化时识别设备性能的一种方式。这是一个多变量方程，表示器件性能与这些条件的函数关系。

在科学和工程领域，创建性能图是一项常见的工作。这方面的一个例子是建筑能源模拟。预测新建筑的能源消耗，并设计新的方法来减少建筑能源消耗在美国是一个很大的领域。这些人使用模拟模型来预测建筑的性能。这些模拟模型需要预测安装在建筑物中的设备所消耗的能量。由于热泵用于建筑，这些模型需要预测热泵的性能。这些热泵的性能是由这些模型预测的，使用的是，你猜对了，性能图。

接下来是什么？

这篇文章介绍了理解和遵循教程所需的背景概念。接下来的教程将教你获取一组描述 HPWH 在不同条件下的性能的实验室测试数据并生成性能图所需的步骤。它将教你编写自动完成这项工作所需的 Python 代码。它将让您有机会在现实世界的例子中学习这些有用的技能。

如果你只是通读文章，本教程将会很有用。您将能够理解这些概念，您将看到所有工作都完成了，并且您将看到自己完成这些工作所需的 Python 脚本。然而，它真正有用的地方是，如果你能够编写代码，生成结果，并自己检查答案。为此，我创建了一个配套数据集。如果你下载了数据集，你就能跟上，确保你做的每件事都是正确的，并尽可能多的学习。

可以在这里找到配套数据集。

该数据集包含伪造的结果，模拟您可能从实验室获得的结果。它包含来自三个实验的准数据，展示了热泵热水器随着空间和水温变化的性能。

第一项任务，也是本教程的第一步，是将数据集分割成独立的文件，每个文件提供一次测试的结果。那篇文章很快就会发表。

教程目录

这是一系列文章的一部分，教你自动分析实验室数据和绘制热泵热水器性能图所需的所有技巧。本系列的其他文章可以通过以下链接找到:

分割数据集

自动分析实验室测试数据

检查分析的实验室数据是否有错误

如何编写检查数据质量的脚本

如何在 Python 中自动生成回归

使用置信区间和引导的教程

原文：https://towardsdatascience.com/tutorial-for-using-confidence-intervals-bootstrapping-860ba716aef3?source=collection_archive---------16-----------------------

验证假设检验的另一种方式

Photo by Lisa Fotios

在本教程中，我将尝试展示如何使用 bootstrapping 和置信区间来帮助突出样本分布之间的统计显著差异。

First 5 Rows of albums_data

首先，假设我们有一个名为 albums_data 的数据集，其中包含专辑评论者的姓名、他们给每张专辑的评分以及每张专辑所属的流派。由于一些专辑有多个流派，这些流派是使用虚拟录制的(换句话说，每个流派都有自己的栏)。如果我们想问这个问题“评论者 X 和评论者 Y 在他们如何评论特定流派的专辑方面有统计学差异吗？”我们可以用自举和置信区间来回答这个问题。

马克和斯蒂芬

首先 ，我们需要定义我们要问的问题。让我们假设我们想知道两个评论家，马克和斯蒂芬，在他们如何给电子专辑评分方面是否有统计学上的显著差异。为了回答这个问题，我们创建了两个假设，称为零假设和备择假设。我们的零将永远是没有差别的场景。这是我们的两个假设:

零假设:“Mark 的电子分数和 Stephen 的电子分数之间没有统计上的显著差异。”

替代假设:“Mark 的电子分数和 Stephen 的电子分数之间存在统计上的显著差异。”

Filtering the albums_data to only electronic albums.

其次 ，我们需要过滤我们的 albums_data 只包含属于电子流派的专辑。

Creating two separate datasets for both reviewers.

第三个 ，我们需要为我们想要比较的两个评论者创建两个单独的数据集。我们这样做是为了在引导公式中具体引用每个样本。我们需要的两个数据集是 Mark 和 Stephen 的。

我们差不多准备好出发了！但是，在我们开始之前，让我们先来看看 Mark 和 Stephen 的电子分数的当前分布情况:

Current electronic score distribution, pre-bootstrapping.

正如我们在上面看到的，马克和斯蒂芬的分数有很多重叠。我们还可以看到，斯蒂芬的分布比马克的分布略偏左。然而，我们从图表中看不到的是这两个样本之间是否存在统计上的显著差异。换句话说，我们不能仅仅通过看上面的图表来拒绝或接受我们的零假设。

什么是引导

好了，快休息。我知道我已经读了一半教程，还没有对什么是自举给出一个合适的解释。设置很重要，但是让我快速解释一下引导背后的想法。我们知道我们想要回答的问题是，我们的零假设或替代假设是否正确。任何假设检验的目的都是为了回答整个群体的问题，而不仅仅是为了我们现有的数据。

大多数时候，我们只能处理人口数据的样本。因此，我们需要最大限度地利用我们的样本。为此，我们从样本数据中抽取重复的小样本，计算每个样本的平均值，并创建这些平均值的新分布。如果我们做 10，000 个迷你样本，我们在这个新的分布中将有 10，000 个均值。我们对两个样本都这样做(在上面的例子中，我们对 Mark 和 Stephen 都这样做)。

这是明确的解释。如果这对于你来说是一个新的概念，我保证随着教程的进行，它会变得更有意义。

回到马克和斯蒂芬

因此，正如我们刚刚在上一节中了解到的，我们在自举中的第一步是从我们的数据集中提取一些小样本，并计算每个样本的平均值。我们分别为马克和斯蒂芬做这件事。

下面是创建这些方法列表的代码。为了快速浏览正在发生的事情，我们创建了 10**4(也就是 10，000)个方法列表。每个列表在数据集中选择 100 个随机评论分数来计算平均值。我们这样做是为了马克和斯蒂芬。最终输出是两个列表( sample_mark_elec_means 和sample _ Stephen _ elec _ means*)，每个列表包含 10，000 个均值。*

信不信由你，就自举复杂性而言，差不多就是这样了。然而，在当前的列表格式中，它不是特别有用。让我们在图表上查看这些分布:

**

哇！这比我们之前制作的图表更能说明问题。请记住，这里唯一的不同是，这个图表使用了我们从引导工作中获得的 10，000 个随机生成的表示。上图是所有实际分数的分布。

虽然看起来这些分布非常不同，但我们实际上不能说是否有统计上的显著差异。你看到分布中有重叠的地方了吗？我们需要知道每个样本的置信区间是否重叠。如果它们确实与重叠，我们接受我们的零假设，并得出结论:在马克和斯蒂芬的电子分数之间没有统计上的显著差异。

置信区间

好了，关键时刻到了。马克和斯蒂芬的电子成绩在统计上有显著差异吗？首先，我们需要确定我们的假设是单尾的还是双尾的。

单尾:单尾检验要求样本之间的差异在特定方向。例如，如果我们的替代假设是“马克的电子分数在统计上显著地 比斯蒂芬的电子分数 高”，那么我们将使用单尾测试。

双尾:双尾检验是假设中不需要方向差异的情况。我们的另一个假设是“Mark 的电子分数和 Stephen 的电子分数之间存在统计学上的显著差异”，这并没有指定任何一个样本需要高于(或低于)另一个样本。它只要求在的任一方向有差异。

Two-Tailed Test. Distribution sans 2.5% on each end for 95% Confidence Interval.

所以我们知道我们有一个双尾检验。但是当谈到置信区间时，这意味着什么呢？嗯，澄清什么是置信区间可能很重要。置信区间是我们在接受或拒绝我们的零假设时希望有多自信。如果我们希望 95%确信马克和斯蒂芬的电子分数之间存在差异，我们将有 5%的置信区间。然而，正如我们刚刚在上面学到的，我们有一个双尾检验。这意味着这 5%将被分成样本分布的两个尾部(2.5%在左尾部，2.5%在右尾部，马克和斯蒂芬都是如此)。这个范围也可以写成:2.5%-97.5%之间 (97.5%就是 100%减去 2.5%) 。本质上，这只是切断了马克和斯蒂芬分布的末端，如上图所示。

Calculating the 2.5% and 97.5% confidence interval cutoffs for both samples.

Results from the above code.

现在我们想知道，马克和斯蒂芬的分布(两端各有 2.5%截断 )在我们的 bootstrap 图中重叠吗？这是一个快速而容易回答的问题。我们需要做的就是找出马克和斯蒂芬的 2.5%和 97.5%的值。幸运的是，Python 库 numpy 为我们找到了这些百分比的值。正如我们在输出中看到的，马克的 2.5%和 97.5%临界值在 7.13 和 7.61 之间，而斯蒂芬的临界值在 6.65 和 7.11 之间。

我们问自己的问题是:“这些分布在两端没有 2.5%的情况下重叠吗？”。我们可以看到 7.11 小于 7.13，这意味着两个分布之间没有重叠。换句话说，我们可以拒绝我们的零假设并以 95%的置信度得出结论，马克和斯蒂芬的电子分数之间存在统计学上的显著差异。

太多了。我希望这篇教程对你有用。记住，这是一个双尾测试。如果它是单尾的(假设一个样本高于另一个样本)，我们将把的全部 5%放入一个尾。我们把它放在哪个尾部，取决于我们假设哪个样本比另一个大。

摘要

我想最后一次快速浏览一下这个过程。首先，我们确定想要回答什么问题，并创建适当的无效假设和替代假设。其次，我们为想要比较的两个样本创建两个数据集。第三，我们为每个样本创建我们的自举均值列表。第四，我们可视化的自举平均分布。第五，我们计算置信区间(双尾模型每端 2.5%，单尾模型特定端 5%)。最后，我们比较置信区间并寻找任何重叠。如果没有重叠，我们可以拒绝零假设，接受另一个假设。如果不是，我们接受我们的零假设。

教程:从假设到网络搜集分析

原文：https://towardsdatascience.com/tutorial-from-the-hypothesis-to-the-analysis-with-web-scraping-98ac3c774bd?source=collection_archive---------14-----------------------

一个真正的数据科学项目的教程，收集所需的数据，清理，转换并最终分析它

通常人们有一些有趣的想法来分析，然后发现没有免费的数据来回答这个问题。获取所需数据的一种有趣方式是网络搜集。互联网上有大量的数据，但这些数据无法以结构化的方式进行分析。通常，教程以读取数据开始，以保存数据结束。在本教程中，我想走一条不同的道路。我想带你踏上一个真实世界的数据科学项目之旅。我们从我们的想法开始:我们收集、清理和转换数据，并用收集到的数据集回答我们的问题。更详细的分析不刮部分可以在这里找到。

这个想法和我们的假设

近日，2018/2019 赛季全国及国际比赛以足球落幕。传统上，在夏季休赛期，转会窗口打开，俱乐部在市场上争夺最好的球员。令人吃惊的是，同样的俱乐部一次又一次地为他们的球星花费创纪录的金额。仅皇马就在埃登·阿扎尔投资了 1.35 亿英镑。因此，我想探究的问题是，球队的价值和运动上的成功有多大的关联。未来几年除了巴萨和皇马还会有其他冠军吗？其他联赛呢？我的假设是，更高的团队价值也会带来更高的成功。所以我有了一个有趣分析的想法，但是没有数据。然而，我知道网上有球队价值的数据库。所以先来点数据吧！

我们需要一些数据——通过网络搜集收集的数据

网页抓取有不同的软件包。两个最著名的图书馆当然是 Scrapy 和 BeautifulSoup。Scrapy 是一个建立在异步网络库上的强大框架，这使得它非常有性能。它还具有许多功能来避免典型的刮擦问题。这些包括例如重定向、重试请求、避免服务器过载等。然而，由于复杂性，Scrapy 的学习曲线也明显高于 BeautifulSoup。这个库主要用于解析和提取 HTML 中的数据。在抓取时出现的所有异常和问题都必须由程序员来识别，并在编码中加以考虑。然而，这样做的好处是，用户实际上必须在这里处理问题，并从头开始学习网络抓取。因此，我们将在这里使用 BeautifulSoup。

数据库

所需数据可在 transfermarkt.com[1]上找到。例如，在图 1 中，您可以看到 2018/2019 赛季德国德甲联赛的阵容值。在同一页上，你会发现一个当前赛季的结果表:排名，净胜球和积分。如果我们不厌其烦地搜集数据，我们应该提取出所有我们需要的信息用于进一步的分析。

Figure 1: The red-marked area contains the required information

说到 web 抓取，我们通常对页面的某个部分感兴趣，我们希望有选择地从中提取信息。在我们的例子中，我们首先要提取两个表的内容(图 1)。为了做到这一点，我们需要识别包含元素的 HTML 标签。每个浏览器都提供了识别 HTML 标签的可能性。在这个例子中，我使用的是谷歌浏览器(图 2)。首先，右键单击包含必要数据的区域。然后你点击Inspect，它会在右边打开一个菜单。如果您将鼠标移动到菜单中的每一行，站点就会突出显示与 HTML 代码相关的区域(图 3)。

**

Figure 2: Inspecting the region of interest with your browser / Figure 3: The HTML-Code of the are of interest

所以第一个表在 HTML 元素table中，类名为items。其中，有元素thead、tfood和tbody，它们又包含进一步的元素。基本内容在tbody中找到，它包含表中每行的tr元素。第一步我们不需要更多的信息。因此，我们首先导入所需的模块:

*import pandas as pd
import numpy as np
import requests
from bs4 import BeautifulSoupimport warnings
warnings.filterwarnings('ignore')*

然后，我们将 URL 赋给一个变量，并设置一个用来模拟真实用户的头。否则，一些页面会直接阻止请求。我们将使用模块requests调用 URL 并加载内容。然后我们将使用BeautifulSoup解析requests对象的内容，以提取我们需要的内容:

*url = 'https://www.transfermarkt.com/bundesliga/startseite/wettbewerb/L1/plus/?saison_id=2018'
headers = {"User-Agent":"Mozilla/5.0"}
response = requests.get(url, headers=headers, verify=False)
soup = BeautifulSoup(response.text, 'html.parser')*

soup元素现在包含了解析后的页面。从soup元素中，我们能够提取所需的表格:

*table = soup.find('table', {'class' : 'items'})*

现在，我们可以将表中的每一行保存在一个列表中:

*row = table.findAll('tr')*

通过键入len(row)，我们发现总共有 20 个元素。德甲 18 支球队，页眉页脚。我们应该找到拜仁慕尼黑:

Figure 4: Bayern Munich

现在我们有了第一个俱乐部的数据。在图 4 中红色标记的区域，我们有名字，球队的规模，平均年龄，外国人的数量，总市值和平均市值。但是我们如何将数据转换成合理的形式来分析它呢？为此，我们首先必须删除所有带有后缀.text的 HTML 代码。Row[2].text让我们的信息更具可读性:

*'\nBayern Munich Bayern Munich 3224,715835,55 Mill. €26,11 Mill. €835,55 Mill. €26,11 Mill. €'*

这看起来好多了，但是现在我们在一个变量中有了所有的信息。因此，我们将带有findAll['td']的行按列划分，这样我们可以寻址每个单元格并保存它。现在，类似于这些行，我们也可以寻址单个列或组合两者:

*In:
row[2].findAll('td')[1].text
row[2].findAll('td')[3].text
row[2].findAll('td')[4].text
row[2].findAll('td')[5].text
row[2].findAll('td')[6].text
row[2].findAll('td')[7].textOut:
'Bayern Munich '
'32'
'24,7'
'15'
'835,55 Mill. €'
'26,11 Mill. €'*

现在我们有了用循环读取整个表的所有东西:

我们能够从列表中创建一个数据框架。我们总是跳过第一行，因为我们已经刮去了我们不需要的标题。

更动态地抓取数据

当然，我们不会大费周章只读取一个表。我们将在七年的时间里读出排名前十的联赛。这样我们就有了一个可靠的数据库来进行计算。首先，我们为每个联盟创建一个字典，其中存储了每个赛季的数据:

然后我们用每个联盟的 URL 创建一个列表。你还记得 2018/2019 赛季的拜仁网址吗？

*[https://www.transfermarkt.com/bundesliga/startseite/wettbewerb/L1/plus/?saison_id=2018'](https://www.transfermarkt.com/bundesliga/startseite/wettbewerb/L1/plus/?saison_id=2018')*

在列表中，我们只存放:

*[https://www.transfermarkt.com/bundesliga/startseite/wettbewerb/L1/plus/?saison_id=](https://www.transfermarkt.com/bundesliga/startseite/wettbewerb/L1/plus/?saison_id=)*

我们用一个循环来添加年份。这样，我们可以为我们的项目编写一个灵活的脚本。十大联赛的完整列表如下:

现在我们需要一个嵌套循环。最外层的循环遍历带有联盟 URL 的列表，内层循环遍历 2012 年到 2018 年:

数据转换

这样一来，我们每个联赛从 2012 年到 2018 年每个赛季都有十本字典。首先，我们将合并每个联盟的所有赛季，然后将所有联盟合并到一个数据集。问题是，如果我们最终将所有数据组合在一起，为什么我们不直接将所有数据收集到一个数据集中。如果没有一年或一个联赛的数据，我已经将try和except块包含在刮削部分以避免错误。因此，我们仍然获得最大可能的数据量和数据质量。首先，我们连接每个联赛的每个赛季，将各自的国家存放在单独的数据集中，然后合并所有联赛:

让我们来看看三个精选的俱乐部:

*df_final.loc[df_final['Team'] == 'Bayern Munich']
df_final.loc[df_final['Team'] == 'KV Oostende']
df_final.loc[df_final['Team'] == 'Real Madrid']*

Figure 5: String values ​​that still need to be converted

到目前为止，数据看起来不错，但是我们没有数字，尽管在Total value和Average value有字符串。在图 5 中，我们看到了添加工厂。€。€和比尔。每个牢房里都有€。在将列转换为 float 之前，我们必须移除这些。在 Age 列中，分隔符仍然是逗号，而不是点。我们还必须清理这个列:

然后我们可以将所有列转换为 float:

为了安全起见，我们将数据集保存一次:

*df_final.to_pickle(“…path\\df_final.pkl”)
df_final.to_excel(“…path\\df_final.xlsx”)*

我们终于可以回答我们的问题了

在搜集和清理数据之后，我们有了一个干净的数据集来检验我们的假设。首先，让我们用下面的代码来看看平均团队值的演变:

我们看到球队的平均价值不断增加。球队在所有联赛中投资，所以总的来说，在他们的球队中投资更多。现在，让我们来看看这两个变量相互关联的程度:

df_final.corr()['Total Value']['Points']

相关系数是0.664，这意味着我们有很强的正相关性。这种相关性并没有说明任何因果关系。我们假设更高的团队价值也导致更大的运动成功。我们将做一个回归，看看球队价值观对得分的影响有多大:

调整后的 R 为 0.569。这意味着队值解释了点的方差的 56.9%。结果具有统计学意义，每增加 100 万欧元，得分平均增加 0.2029 分。

结论

在这篇文章中，我们首先提出了一个假设，然后在网上确定了一个数据库。我们研究了网络抓取的基础知识，并基于一个特定的问题开发了一个脚本，通过它我们可以有目的地读取网站的数据。然后，我们准备和清理数据，为我们的分析奠定基础。使用基本的统计方法，我们检查了我们的假设。
团队价值和运动成功之间的相关性非常显著。此外，球队价值对得分的影响非常大。
更详细的分析可以在这里找到。

Github:

archiv:
https://github.com/bd317/tutorial_scraping
教程第一步:
https://github . com/BD 317/Tutorial _ scraping/blob/master/Soccer _ Scrape _ Tutorial _ Part _ 1% 20(1)。ipynb
完整脚本:
https://github . com/BD 317/Tutorial _ scraping/blob/master/Soccer _ Scrape _ Tutorial _ Part _ 2 . ipynb

来源:

[1]https://www.transfermarkt.com
【2】https://www . uefa . com/memberassociations/uefarankings/country/#/yr/2019

如果您喜欢中级数据科学，并且还没有注册，请随时使用我的推荐链接加入社区。

教程:使用 Python 和 Heroku 的 Google Vision API

原文：https://towardsdatascience.com/tutorial-google-vision-api-with-python-and-heroku-3b8d3ff5f6ef?source=collection_archive---------5-----------------------

了解如何使用 Google Vision API

Image by author

正如我们之前了解到的，谷歌视觉人工智能可以分为两个部分， AutoML 视觉和视觉 API 。对于 Vision API 参考，这里是以前的帖子，讨论 Vision API 可以做什么，如何创建 API 键，然后用 curl 查询它。

[## ML Study Jam — Vision API

使用云视觉 API 检测图像中的标签、人脸和地标

towardsdatascience.com](/ml-study-jam-detect-labels-faces-and-landmarks-in-images-with-the-cloud-vision-api-a80e89feb66f)

今天，我们将学习如何在 Python 中使用它。然后我们可以在将来的项目中使用它。

在我们开始之前，我想和你分享一下官方教程。

[## 通过 Python 使用 Vision API

谷歌云视觉 API 允许开发人员轻松地将视觉检测功能集成到应用程序中…

codelabs.developers.google.com](https://codelabs.developers.google.com/codelabs/cloud-vision-api-python/index.html?index=…%2F…index#0)

在接下来的段落中有一个快速教程，但是如果你想在阅读之后了解更多的细节，你仍然可以从 Google Codelabs 中学习。太好了，现在我们开始吧。

步骤概述

1. 建立一个 Vision API 项目。
2. 启用 Vision API。
3. 验证 API 请求并下载keyFile.json。
4. 用keyFile.json设置GOOGLE_APPLICATION_CREDENTIALS。
5. 安装谷歌客户端视觉 API 客户端库。
6. 编写 Python 代码来查询 Vision API。
7. 将代码推至 Heroku 。

第一步。建立一个 Vision API 项目。

1. 登录到谷歌云平台控制台并创建一个新项目。

2.命名项目并点击创建按钮。

3.点击主动云壳。

4.然后底部会出现一个控制台外壳。
运行$ gcloud auth list以确认您已通过身份验证。并运行$ gcloud config list project确认项目 id。

第二步。启用 Vision API。

运行命令行$ gcloud services enable vision.googleapis.com

第三步。验证 API 请求并下载keyFile.json.

根据 Google Codelabs 教程，我们需要创建一个服务帐户和一个访问 Vision API 的密钥。

为了向 Vision API 发出请求，您需要使用一个服务帐户。一个服务帐户是一个属于你的项目的帐户，它被 Google 客户端 Python 库用来发出 Vision API 请求。

单击下面的链接，并按照Setting up authentication GCP 控制台的步骤操作。

[## Vision API 客户端库|云 Vision API 文档| Google 云

本页显示了如何开始使用 Cloud Vision API 的云客户端库。阅读有关客户端的更多信息…

cloud.google.com](https://cloud.google.com/vision/docs/libraries#client-libraries-usage-python)

1. 转到创建服务帐户密钥页面
2. 从服务账户列表中，选择新服务账户。
3. 在服务帐户名称字段中，输入一个名称。
4. 不要从角色列表中选择值。访问此服务不需要任何角色。

如果所有设置都设置正确，用户界面将如下所示:

5.点击创建。将出现一条注释，警告此服务帐户没有角色。

6.点击创建无角色。一个 JSON 文件，包含你下载到你电脑上的密钥。

第四步。用keyFile.json设置GOOGLE_APPLICATION_CREDENTIALS

将 JSON 文件重命名为keyFile.json。然后用文件设置GOOGLE_APPLICATION_CREDENTIALS。

export GOOGLE_APPLICATION_CREDENTIALS=~/Desktop/keyFile.json

第五步。安装谷歌客户端视觉 API 客户端库。

1. 运行pip freeze | grep google-cloud-vision来检查库是否已经安装。

2.如果您没有设置环境，请运行pip install --upgrade google-cloud-vision。

第六步。编写 Python 代码来查询 Vision API。

将以下代码复制并保存为 Python 文件。

运行 Python 文件来测试是否正确设置了所有环境设置。

/usr/local/opt/python/bin/python3.7 [path/to/your/filename.py]

我们上传了两位巨星的照片，并使用 Vision API 中的人脸检测来获取他们的人脸边界和情感。

输入数据:

images from WikiMedia and Pinterest

以下是输出:

=========================================================File: {pic}Face surprised: VERY_UNLIKELYFace bounds: (207,54),(632,54),(632,547),(207,547)=========================================================File: {pic}Face surprised: LIKELYFace bounds: (16,38),(323,38),(323,394),(16,394)

恭喜你！这意味着我们已经成功查询了 Vision API。尝试官方教程中的其他 Vision APIs。

[## 教程|云视觉 API 文档|谷歌云

无论您的企业是刚刚踏上数字化转型之旅，还是已经走上数字化转型之路，谷歌云的解决方案…

cloud.google.com](https://cloud.google.com/vision/docs/tutorials)

第七步。将代码推至 Heroku 。

注:根据Mandar Vaze的建议，我们不应该将个人 ***keyFile.json*** 上传到公共空间。如果您对安全问题有所顾虑，请参考 本帖 寻求解决方案。

如果你还是不太了解 Heroku，请先看看之前的帖子。

[## 教程:使用 Python 和 Heroku 的 LINE Bot

从头开始，建立你的线机器人

medium.com](https://medium.com/better-programming/line-bot-with-python-and-heroku-tutorial-e8c296f3816f)

在第 6 步中，该项目在本地运行良好，但我们需要将其构建为应用程序或 web 使用的在线服务。

1. 下面是代码示例，请下载并在下面的步骤中学习如何在线推送。

https://github . com/mutant 0113/Google _ Vision _ API _ sample/blob/master/medium-Google-Vision-API . zip

2.将你自己的谷歌服务账号keyFile.json添加到文件夹medium-google-vision-api/config/

3.创建一个新的 Heroku 项目。

heroku login
heroku create [your/project/name] --buildpack heroku/python

4.链接项目并将代码推送到主分支。

cd [path/to/your/local/project/download/from/step1]
heroku git:remote -a [your/project/name]
git push heroku master

5.将GOOGLE_APPLICATION_CREDENTIALS和keyFile.json设定在 Heroku 上。

heroku config:set GOOGLE_APPLICATION_CREDENTIALS='config/keyFile.json'

6.确保至少有一个应用程序实例正在运行。

heroku ps:scale web=1

7.打开 Heroku 网站

heroku open

如果一切都设置正确，您应该会看到网站的内容像图片一样。

8.您可以在 hello/views.py 和 hello/vision_api.py 中编辑代码

今天到此为止。我们现在可以开始使用 Google Vision API 编写代码了。希望这篇文章能帮助你更多地了解 Google Vision API。

如有任何问题或建议，欢迎在本文下方留言评论。再见。

参考

云愿景 API 定价

[## 定价|云愿景 API 文档|谷歌云

云视觉 API 提供了一组用于分析图像的功能。在这些情况下，我们让您只需支付…

cloud.google.com](https://cloud.google.com/vision/pricing)

我们的 Heroku 代码基于官方样本代码。

[## 使用 Python 开始使用 Heroku

本教程将让你在几分钟内部署一个 Python 应用程序(一个简单的 Django 应用程序)。再坚持几分钟…

devcenter.heroku.com](https://devcenter.heroku.com/articles/getting-started-with-python)

Node.js 版本的另一个教程。

[## 如何在 Heroku for Node.js App 上认证谷歌云服务

在这篇文章中，我将讨论如何授权各种谷歌云服务，如数据存储、云存储…

medium.com](https://medium.com/@naz_islam/how-to-authenticate-google-cloud-services-on-heroku-for-node-js-app-dda9f4eda798)