TowardsDataScience 博客中文翻译 2020（七十九）

原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

车床快速入门:面向对象建模语言

原文：https://towardsdatascience.com/a-swift-introduction-to-lathe-oop-ml-for-julia-8208bcbb4fc8?source=collection_archive---------61-----------------------

车床机器学习库使用介绍。

(图片由作者提供)

介绍

在 Julia 生态系统中，有许多针对数据科学学科的包。有用于分布、推理和贝叶斯统计、数据可视化甚至深度学习的包。虽然这些包中的许多都是很棒的解决方案，并且分别工作得很好，但是还有一个更新的、更具包容性的解决方案，它在 Julia 语言中提供了类似 Sklearn 的语法，这通常有助于编写更多的函数代码。

车床。jl 是一个统计，预测建模，数据处理和深度学习库，所有这些都浓缩到一个单一的包中，您可以通过 Pkg 添加。与机器学习的其他 Julian 解决方案相比，Lathe.jl 的一个优势是，Lathe 利用 Julia 的调度类型来创建具有子调度方法的类型。这对于像模型这样的东西非常有用，在这种情况下，您可能希望有一个在拟合或预测之前执行一些逻辑的初始化函数。此外，使用包含在给定类型中的类型和数据的能力，而不是为了使用给定的方法而需要提供它们，对于机器学习来说也是非常有价值的。

笔记本

入门指南

为了开始用车床处理算法，你首先需要安装它。虽然这很简单，但重要的是要确保你使用的是正确的分支和版本的车床。要添加最新版本的车床，可以这样做

using Pkg;Pkg.add("Lathe")

你体内的朱莉娅·REPL。

(图片由作者提供)

这将给你车床版本 0.1.1“黄油球。”只要您使用的是车床“Butterball”的版本，本教程应该适用于所有涉及的代码。如果您想先睹为快，也可以添加不稳定分支:

julia>]
pkg> add Lathe#Unstable

您还可以为 0.1.0 以上的每个特定版本添加分支:

add Lathe#Butterball
add Lathe#0.1.0
add Lathe#0.1.1
add Lathe#0.1.2

您还需要添加 DataFrames.jl。它不仅是这台车床唯一的依赖项，而且还与车床中的许多函数相关联，这些函数将采用数据帧类型。

add DataFrames

现在你应该可以导入车床了:

using Lathe

关于使用任何 Julia 包，我能给出的一些很好的建议是熟悉如何使用？()方法来浏览文档。大多数软件包使用 Documenter.jl 来创建它们的文档，这些文档通常是通过 Juliahub 生成的(这真的很酷)，所以经常会有一些文档，你可以很容易地在你的 REPL 或笔记本中访问它们。如果你想了解更多关于用 doc-strings 和 Documenter.jl 创建自动化文档的知识，我写了一个完整的教程，你可以在这里查看:

[## 如何用 Documenter.jl 自动化 Julia 文档

没有文档，软件是没有用的，所以用 Documenter.jl 把文档的痛苦去掉吧

towardsdatascience.com](/how-to-automate-julia-documentation-with-documenter-jl-21a44d4a188f)

每当我们运行我们的。()方法放在车床模块上，我们得到这样的回报:

(图片由作者提供)

让我们先来看看 Lathe.stats，它是 Lathe.jl 包含的统计库。我们将在下面的代码中直接使用它:

using Lathe: stats

现在我们将调用我们的？()方法在上面:

(图片由作者提供)

作为回报，我们得到了这个库中所有可用函数的详细列表。今天，我们将忽略统计库，直接进入预处理，但是如果您需要的话，统计数据总是存在的。

数据

为了开始使用车床，我们当然需要一些数据来支持它。用于基本示例的一个很好的格式是逗号分隔值，我们需要 CSV.jl 包来读取它。如果您的计算机上没有该包，您可以使用以下命令获取它:

pkg> add CSV

在本例中，我将使用一些汽车数据训练一个模型，这些数据包含欧洲汽车的信息，如里程、价格和转售价值。

using CSV
df = CSV.read("car data.csv")

该数据有两个可能相关联的特征，并且用线性回归来探索是有趣的，那就是汽车的销售价格和它的制造年份。让我们从删除所有我们不需要的特性开始。为此，我们可以创建一个全新的数据框，或者删除我们不需要的要素。我更喜欢后者。

using DataFrames
df = DataFrame(:Year => df[:Year], :Price => df[:Selling_Price])

为了检查缺少的值，我们将运行一个快速 for 循环来检查值是否缺少:

for year in df[:Year]
    if year == Missing
        println("missing")
    end
end
for price in df[:Price]
    if price == Missing
        println("missing")
    end
end

幸运的是，这个数据没有值，所以我们将继续把数据分成测试和训练集。为此，我们将使用车床:

(图片由作者提供)

我们正在寻找的方法是 TrainTestSplit()。要找到关于函数的更多信息，我们可以使用？()方法上也是如此:

(图片由作者提供)

这不是最好的文档，但是它确实给了我们一个概念，我们需要为这个函数提供什么参数。有趣的是，这个函数使用 Julia 的 dispatch，所以我们也可以直接调用 dispatch 函数，就像这样:

train, test = preprocess._dfTrainTestSplit(df, .75)

(图片由作者提供)

现在，我们将把它放入新的数组中，用于训练值和测试值:

trainX = train[:Price]
trainY = train[:Year]
testX = test[:Price]
testY = test[:Year]

建模

最后，我们可以从 Lathe.models 获取 LinearRegression。如果您使用的是更新版本的 Lathe，您可能需要调用 SimpleLinearRegression。

?(models.LinearRegression)

(图片由作者提供)

如您所见，我们需要为 y 和 x 提供一个一维数组，并将调用 predict 函数来返回一个预测值。我们可以像在 Julia 甚至 Python 中创建类型一样拟合模型:

model = models.LinearRegression(trainX, trainY)

现在我们可以在没有测试数据的情况下调用这个模型。

yhat = model.predict(testX)

(图片由作者提供)

因为年份是整数，所以我将遍历这些值，并将它们四舍五入为最接近的整数:

yhat = [year = Int64(round(year)) for year in yhat]

(图片由作者提供)

注意:

如果您使用的是车床 1.2 +，那么在直接调用模块时，您将能够调用所有函数作为导出。或者，您可以调用作为由车床导出的模块的子模块的函数。

为了验证我们的模型，我们可以使用来自 Lathe.stats 的平均绝对误差指标:

using Lathe.stats: mae
println(mae(yhat, testY))

我认为这是非常准确的！如果我们真的需要，我们也可以使用来自 Lathe.preprocess 的规格化器。对于这个例子，我打算迭代最小可行产品，但是 MAE 为 0 意味着模型在这个测试中是完美的，所以我真的没有任何改进可以做，除非我着手建立一个验证集并进一步提高模型的准确性——并冒过度拟合的风险。

结论

车床是一个伟大的上升和未来的工具，我非常兴奋。虽然肯定还有很多工作要做，但我认为它对 Julia 语言的影响是相当大的。有了类似 Sklearn 的语法，以及非常容易理解的函数和类型，我认为它可以为许多 Python 用户搭建一座桥梁，这些用户不太习惯于将参数放入一个结构并将它们作为参数传递，以使方法适合模型类型和数据。

Julia 中元编程的快速介绍

原文：https://towardsdatascience.com/a-swift-introduction-to-metaprogramming-in-julia-5eef529f5a8a?source=collection_archive---------68-----------------------

在 Julia 中使用 Julia 的元包进行编程的基础。

(茱莉亚 logo src = http://julialang.org)

笔记本

介绍

Julia 语言因其许多相对有用的特性而备受推崇。然而，我认为在 Julia 语言中经常被忽略的一个特性是 Julia 的元编程能力。元编程是一种编程方式，其中一个程序使用另一个程序作为其数据。当我说程序时，我指的是可以在该语言中运行的任何可执行代码，而不是单独的语言或应用程序。

元编程非常有用。有些事情你可以用代码作为数据来做，而这些事情在编程语言中是无法做到的。我想从我的文件夹中给大家带来一个很好的例子是 Hone.jl. Hone.jl 使用元标记，这些元标记只是包含代码的字符串，可以随后连接和修改这些字符串以形成图和绘图。如果不使用这些元标记，有些事情是不可能实现的，那就是扩展 Hone 的能力。如果你想了解更多关于如何编写 Hone 扩展的知识，你可以看看这篇文章:

[## 我是如何在 Julia 中编写第一个 Hone 扩展的

在 Julia 中创建和使用我的绘图库的扩展。

towardsdatascience.com](/how-i-programmed-the-first-hone-extension-in-julia-edf7813d0e1b)

幸运的是，Julia 中的元编程很容易上手。朱莉娅的元是很容易掌握和学习的东西之一，但要掌握起来要困难得多。使用元编程的一个很大的缺点是，它会使调试变得特别困难，因为您的代码都包含在表达式中，一个小错误，比如省略一个逗号，就会使您的代码无法运行。这是因为在线上读取错误返回比解析错误要容易得多。

表达式类型

为了在 Julia 中有效地进行元编程，你需要很快习惯的一件事是一种新的类型。让我给你介绍一下:

:Expr

表达式类型是一种旨在存储可评估的已解析元代码的类型。为了进行基本的字符串到表达式的转换，您需要熟悉 Base.Meta 中的 parse()方法。

using Base.Meta: parse

让我们试着在一个字符串上使用它:

请注意，我们的输出现在变成了一个符号。这个符号在某种程度上可以被看作是我之前谈到的应用程序。这是一个运行该符号内部代码的表达式。或者，我们也可以创建一个我们自己的符号来执行这个运算。

正如您所看到的，这两个都是表达式，一个是解析的，另一个是使用内部带有语法的符号创建的。这实际上是存储在符号数据类型中的代码。

表达式的属性

Expr 类型实际上有一些您可能没有想到的有趣属性。真正酷的是，它们允许我们剖析数据/代码的内容，并对它们有更多的了解。我想给你看的第一个财产是人头。Expr 类型包含两种主要的数据类型，头数据和参数数据。head 用于界定要传递的是哪种表达式。在这个例子以及大多数例子中，我们使用:call 类型。这不是一个实际的数据类型，只是一个存储在 Expr 结构中的符号。

接下来我们有参数。Args 是我们的数据包含的所有参数。这些争论可以分为两类。他们要么是

操作

其中包括方法和操作数。这些将用符号数据类型来表示。事实上，这些是你的元表达式的元部分。然而，如果没有数据，这些操作是没有用的，所以除了操作之外，我们还有

数据。

我们可以通过打印所有参数的类型来可视化这一点。

这基本上就是解析器为我们做的事情。解析器将需要执行的功能和数据相互分离。之后，它会把所有东西按正确的顺序排列，这样它就可以被正确地评估。另一件应该提到的事情是从字符串类型到表达式类型的转换。

解析和评估

既然我们理解了 parse()的作用，以及它如何将字符串转换成表达式类型，我们现在可以开始创建一些表达式，然后用 eval()对其求值:

data_code = "mean([5,10,15,20])"
expression = parse(data_code)
mu = eval(expression)

这是相对基本的，但也有一些事情你应该注意。首先，如果你所有的数据都在一个字符串中，你如何使用字符串数据类型？不幸的是，在 Julia 中没有办法像在 Python 中那样在字符串内部分隔字符串，所以我们需要使用正则表达式。仔细想想，正则表达式本身也是元程序；所以我们真的是在兜圈子。在 Julia 中获取字符串而无需创建字符串的最简单方法是使用一个符号:

symb = :hello_world
a_string = string("\"",string(symb),"\"")

正则表达式\ "用于在字符串中分隔引号。

这真的就是全部了！

元编程是一个强大的工具，我相信有时会被忽略。我认为茱莉亚的处理方式是最完美的处理方式。虽然它肯定不是这门语言的重点，但是它的实现非常好，使用起来也非常简单。Julia 有很强的元编程能力，我已经享受了很长时间了！

一种表格检测、单元格识别和文本提取算法，用于将图像中的表格转换为 excel 文件

原文：https://towardsdatascience.com/a-table-detection-cell-recognition-and-text-extraction-algorithm-to-convert-tables-to-excel-files-902edcf289ec?source=collection_archive---------0-----------------------

如何使用 OpenCV 和 pytesseract 将表格截图转换成可编辑的数据

来源:pixabay

假设您在文章、pdf 或图像中有一个表格，并希望将其转换为 excel 表格或数据框架，以便能够对其进行编辑。特别是在机器学习的预处理领域，这种算法将非常有助于将许多图像和表格转换为可编辑的数据。如果您的数据存在于基于文本的 pdf 文件中，已经有一些免费的解决方案。最受欢迎的是表格式，卡梅洛特/神剑，你可以在https://tabula.technology/，https://camelot-py.readthedocs.io/en/master/，https://excalibur-py.readthedocs.io/en/master/下找到。

但是，如果您的 PDF 是基于图像的，或者您在网上找到一篇带有表格的文章，该怎么办？为什么不直接截图转换成 excel 表呢？因为基于图像的数据(jpg、png、基于图像的 pdf 等)似乎没有免费或开源软件。)的想法是开发一个通用的解决方案，将表格转换成可编辑的 excel 文件。

但是现在已经足够了，让我们看看它是如何工作的。

入门指南

**该算法由三部分组成:**第一部分是使用打开 CV 的表格检测和单元格识别，第二部分是将单元格彻底分配到适当的行和列，第三部分是使用 pytesseract 通过光学字符识别(OCR)提取每个分配的单元格。

和大多数表格识别算法一样，这种算法是基于表格的行结构的。清晰和可检测的线条对于正确识别细胞是必要的。具有虚线、间隙和孔洞的表格导致较差的识别，并且没有检测到仅部分被线包围的单元。如果您的某些文档出现断行，请务必阅读本文并修复断行:单击此处。

首先，我们需要输入数据，在我的例子中是 png 格式的截图。目标是拥有一个具有相同表格结构的数据框架和 excel 文件，其中每个单元格都可以编辑并用于进一步分析。

用于进一步表格识别和提取的输入数据。

让我们导入必要的库。

关于图书馆的更多信息:
cv2—https://opencv.org/宇宙魔方—https://pypi.org/project/pytesseract/

**import** cv2
**import** numpy as np
**import** pandas as pd
**import** matplotlib.pyplot as plt
**import** csvtry:
    **from** PIL **import** Image
except ImportError:
    **import** Image
**import** pytesseract

第一步是从正确的路径读入文件，使用阈值将输入图像转换为二进制图像，并将其反转以获得黑色背景、白色线条和字体。

**#read your file** file=r'/Users/YOURPATH/testcv.png'
img = cv2.imread(file,0)
img.shape**#thresholding the image to a binary image** thresh,img_bin = cv2.threshold(img,128,255,cv2.THRESH_BINARY |cv2.THRESH_OTSU)**#inverting the image** img_bin = 255-img_bin
cv2.imwrite('/Users/YOURPATH/cv_inverted.png',img_bin)**#Plotting the image to see the output**
plotting = plt.imshow(img_bin,cmap='gray')
plt.show()

二进制反转图像。

[## 请继续关注马里乌斯·哈克的新文章

请继续关注 Marius Hucker 的新文章。如果您还没有注册，您将创建一个中型帐户…

medium.com](https://medium.com/subscribe/@hucker.marius)

下一步是定义一个内核来检测矩形框，然后是表格结构。首先，我们定义核的长度，然后沿着垂直和水平核检测所有的垂直线和水平线。

**# Length(width) of kernel as 100th of total width**
kernel_len = np.array(img).shape[1]//100**# Defining a vertical kernel to detect all vertical lines of image** ver_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (1, kernel_len))**# Defining a horizontal kernel to detect all horizontal lines of image** hor_kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (kernel_len, 1))**# A kernel of 2x2** kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 2))

下一步是垂直线的检测。

**#Use vertical kernel to detect and save the vertical lines in a jpg**
image_1 = cv2.erode(img_bin, ver_kernel, iterations=3)
vertical_lines = cv2.dilate(image_1, ver_kernel, iterations=3)
cv2.imwrite("/Users/YOURPATH/vertical.jpg",vertical_lines)**#Plot the generated image**
plotting = plt.imshow(image_1,cmap='gray')
plt.show()

提取的垂直线。

现在所有的水平线都一样。

**#Use horizontal kernel to detect and save the horizontal lines in a jpg**
image_2 = cv2.erode(img_bin, hor_kernel, iterations=3)
horizontal_lines = cv2.dilate(image_2, hor_kernel, iterations=3)
cv2.imwrite("/Users/YOURPATH/horizontal.jpg",horizontal_lines)**#Plot the generated image**
plotting = plt.imshow(image_2,cmap='gray')
plt.show()

提取的水平线。

我们通过用 0.5 对水平线和垂直线进行加权，将它们组合成第三幅图像。目的是得到一个清晰的表格结构来检测每个细胞。

**# Combine horizontal and vertical lines in a new third image, with both having same weight.** img_vh = cv2.addWeighted(vertical_lines, 0.5, horizontal_lines, 0.5, 0.0)**#Eroding and thesholding the image**
img_vh = cv2.erode(~img_vh, kernel, iterations=2)
thresh, img_vh = cv2.threshold(img_vh,128,255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
cv2.imwrite("/Users/YOURPATH/img_vh.jpg", img_vh)bitxor = cv2.bitwise_xor(img,img_vh)
bitnot = cv2.bitwise_not(bitxor)**#Plotting the generated image**
plotting = plt.imshow(bitnot,cmap='gray')
plt.show()

提取的不包含文本的表格结构。

有了表格结构后，我们使用 findContours 函数来检测轮廓。这有助于我们检索每个盒子的准确坐标。

**# Detect contours for following box detection** contours, hierarchy = cv2.findContours(img_vh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

以下函数是获取轮廓序列并从上到下对其进行排序所必需的(https://www . pyimagesearch . com/2015/04/20/sorting-contours-using-python-and-opencv/)。

def sort_contours(cnts, method="left-to-right"): **# initialize the reverse flag and sort index** reverse = False
    i = 0 **# handle if we need to sort in reverse**
    if method == "right-to-left" or method == "bottom-to-top":
    reverse = True **# handle if we are sorting against the y-coordinate rather than
    # the x-coordinate of the bounding box** if method == "top-to-bottom" or method == "bottom-to-top":
    i = 1 **# construct the list of bounding boxes and sort them from top to
    # bottom** boundingBoxes = [cv2.boundingRect(c) for c in cnts]
    (cnts, boundingBoxes) = zip(*sorted(zip(cnts, boundingBoxes),
    key=lambda b:b[1][i], reverse=reverse)) **# return the list of sorted contours and bounding boxe**s
    return (cnts, boundingBoxes) **# Sort all the contours by top to bottom.** contours, boundingBoxes = sort_contours(contours, method=”top-to-bottom”)

如何检索单元格的位置

需要进一步的步骤来定义每个单元的正确位置，这意味着正确的列和行。首先，我们需要检索每个单元格的高度，并将其存储在列表 heights 中。然后我们从高处取平均值。

**#Creating a list of heights for all detected boxes**
heights = [boundingBoxes[i][3] for i in range(len(boundingBoxes))]**#Get mean of heights**
mean = np.mean(heights)

接下来，我们检索每个轮廓的位置、宽度和高度，并将其存储在盒子列表中。然后我们在所有的盒子周围画出矩形，并绘制图像。在我的例子中，我只对宽度小于 1000 像素、高度小于 500 像素的盒子这样做，以忽略可能没有单元格的矩形，例如整个表格。这两个值取决于你的图像大小，所以如果你的图像变小或变大，你需要调整两者。

**#Create list box to store all boxes in** 
box = []**# Get position (x,y), width and height for every contour and show the contour on image**
for c in contours:
    x, y, w, h = cv2.boundingRect(c) if (w<1000 and h<500):
        image = cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),2)
        box.append([x,y,w,h])plotting = plt.imshow(image,cmap=’gray’)
plt.show()

由检测到的轮廓/方框包围的每个单元。

现在我们有了每个单元格，它的位置、高度和宽度，我们需要在表格中得到正确的位置。因此，我们需要知道它位于哪一行哪一列。只要一个盒子的差异不超过它自己的(高度+平均值/2 ),这个盒子就在同一行。一旦高度差高于当前值(高度+平均值/2)，我们就知道新的一行开始了。列在逻辑上从左到右排列。

**#Creating two lists to define row and column in which cell is located** row=[]
column=[]
j=0**#Sorting the boxes to their respective row and column**for i in range(len(box)): if(i==0):
        column.append(box[i])
        previous=box[i] else:
        if(box[i][1]<=previous[1]+mean/2):
            column.append(box[i])
            previous=box[i] if(i==len(box)-1):
                row.append(column) else:
            row.append(column)
            column=[]
            previous = box[i]
            column.append(box[i])print(column)
print(row)

接下来，我们计算最大列数(意味着单元格),以了解我们最终的数据框架/表格将有多少列。

**#calculating maximum number of cells**countcol = 0
for i in range(len(row)):
    countcol = len(row[i])
    if countcol > countcol:
        countcol = countcol

拥有最大数量的单元格后，我们将每列的中点存储在一个列表中，创建一个数组并对值进行排序。

**#Retrieving the center of each column**center = [int(row[i][j][0]+row[i][j][2]/2) for j in range(len(row[i])) if row[0]]center=np.array(center)
center.sort()

此时，我们有了所有的框和它们的值，但是正如您可能在您的行列表的输出中看到的，这些值并不总是按照正确的顺序排序。这就是我们下一步要做的，关于到列中心的距离。我们存储在列表最终框中的正确顺序。

**#Regarding the distance to the columns center, the boxes are arranged in respective order**finalboxes = []for i in range(len(row)):
    lis=[]
    for k in range(countcol):
        lis.append([])
    for j in range(len(row[i])):
        diff = abs(center-(row[i][j][0]+row[i][j][2]/4))
        minimum = min(diff)
        indexing = list(diff).index(minimum)
        lis[indexing].append(row[i][j])
    finalboxes.append(lis)

让我们提取值

在下一步中，我们将使用我们的列表终结框。我们取每一个基于图像的盒子，通过扩张和腐蚀来为光学字符识别做准备，并让 pytesseract 识别包含的字符串。循环遍历每个单元格，并将值存储在外部列表中。

**#from every single image-based cell/box the strings are extracted via pytesseract and stored in a list**outer=[]
for i in range(len(finalboxes)):
    for j in range(len(finalboxes[i])):
        inner=’’
        if(len(finalboxes[i][j])==0):
            outer.append(' ') else:
            for k in range(len(finalboxes[i][j])):
                y,x,w,h = finalboxes[i][j][k][0],finalboxes[i][j][k][1], finalboxes[i][j][k][2],finalboxes[i][j][k][3]
                finalimg = bitnot[x:x+h, y:y+w]
                kernel = cv2.getStructuringElement(cv2.MORPH_RECT, (2, 1))
                border = cv2.copyMakeBorder(finalimg,2,2,2,2,   cv2.BORDER_CONSTANT,value=[255,255])
                resizing = cv2.resize(border, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
                dilation = cv2.dilate(resizing, kernel,iterations=1)
                erosion = cv2.erode(dilation, kernel,iterations=1)

                out = pytesseract.image_to_string(erosion)
                if(len(out)==0):
                    out = pytesseract.image_to_string(erosion, config='--psm 3')
                inner = inner +" "+ out outer.append(inner)

最后一步是将列表转换成数据帧，并将其存储到 excel 文件中。

**#Creating a dataframe of the generated OCR list** arr = np.array(outer)
dataframe = pd.DataFrame(arr.reshape(len(row),countcol))
print(dataframe)
data = dataframe.style.set_properties(align="left")**#Converting it in a excel-file** data.to_excel(“/Users/YOURPATH/output.xlsx”)

终端中的最终数据帧。

包含所有单元格的最终 excel 文件。

**就是这样！**您的表格现在应该存储在数据帧和 excel 文件中，可用于自然语言处理、通过统计进行进一步分析或仅用于编辑。这适用于结构清晰简单的表格。如果你的表格有一个非常特殊的结构，在某种意义上说，许多单元格被组合在一起，单元格的大小变化很大，或者使用了许多颜色，那么这个算法可能必须被采用。此外，OCR 在识别计算机字体方面近乎完美。但是，如果您有包含手写输入的表格，结果可能会有所不同。

如果你把它用在你自己的桌子上，让我知道它是如何工作的。

[## 请继续关注马里乌斯·哈克的新文章

请继续关注 Marius Hucker 的新文章。如果您还没有注册，您将创建一个中型帐户…

medium.com](https://medium.com/subscribe/@hucker.marius)

你喜欢这个故事？

支持我和我在这里的工作

亦读:

如何修复表格识别中的断线

Python 系列的触觉指南

原文：https://towardsdatascience.com/a-tactile-guide-to-python-collections-final-4a25039deea9?source=collection_archive---------9-----------------------

由 Unsplash 上的 chuttersnap 拍摄

Python 是一种功能强大的编程语言，具有动态语义，由被称为“python 之禅”的 19 条原则指导。这些原则列举如下:

谓美丽胜过丑陋。
显性比隐性好。简单比复杂好。
复杂总比复杂好。
扁平比嵌套好。
稀不如密。
可读性很重要。特例不足以特殊到违反规则。
虽然实用性胜过纯粹性。错误永远不会悄无声息地过去。
除非明确消音。
面对暧昧，拒绝猜测的诱惑。应该有一种——最好只有一种——显而易见的方法来做这件事。虽然这种方式一开始可能并不明显，除非你是荷兰人。
现在总比没有好。
虽然永远也不会比现在好。如果实现很难解释，这是个坏主意。
如果实现起来容易解释，这也许是个好主意。名称空间是一个非常棒的想法——让我们多做一些吧！”

如果我们不想违背 python 的原则，我们必须适当地充分存储我们的数据。Python 提供了一些内置的容器来帮助存储我们的数据，如列表、元组、集合、字典等。已经开发了几个模块，它们提供附加的数据结构来存储数据集合。Python 集合模块就是这样一个模块，它的目的是改进内置容器的功能。坚持 python 说“… 很难解释，这是个坏主意”的禅，我会进一步解释什么是模块。

模块化编程指的是将一个庞大、笨拙的编程任务分解成单独的、更小的、更易于管理的子任务或模块的过程。然后可以将各个模块拼凑在一起，创建一个更大的应用程序。

照片由弗兰拍摄。开退溅

模块化代码的一些优势包括:

1. 简单
2. 可维护性
3. 复用性

模块是包含 Python 定义和语句的文件，有助于实现一组函数。模块可以定义函数、类和变量。文件名是模块名加上后缀.py。而包是堆叠在一起的相关模块的集合。它们也被称为图书馆。

Python 模块和 Python 包，两种便于模块化编程的机制。

收集模块

collections 模块提供了内置容器数据类型的替代方法，如 list、tuple 和 dict。在本文中，我们考虑 python 集合模块中六(6)种常用的数据结构。它们如下:

1. 命名元组
2. 双端队列
3. 计数器
4. 有序直接
5. 默认字典
6. 链式地图

回想起来，内置容器的概要如下。

• List 是一个有序的、异构的、可变的 python 容器。它是用“[]”创建的。
• Tuple 非常类似于一个列表，但有一个主要区别——它是不可变的。我们用括号“()”创建一个元组。
• 集合也类似于列表，只是它是无序的。它可以存储异构数据，并且是可变的。我们通过用花括号“{}”将数据括起来来创建一个集合。
• Dictionary 是一个无序的、异构的、可变的 python 容器。它与一个密钥对值相关联。它只能通过它的键进行索引。

1. named tuple:‘named tuple’生成一个类似于元组的类，但是有命名条目。namedtuple 返回一个元组，其中包含元组中每个位置(索引)的名称，而不是一个数字。普通元组的一个最大问题是，你必须记住元组对象的每个字段的索引。

namedtuple 的代码段

2.**dequee:**dequee 是一个为插入和删除项目而优化的列表。我们可以把一个“队列”想象成一个列表，我们通常关心的是处理列表的末尾。

deque 的代码段

3.计数器:计数器是一个非常有用的对象。它对一些 iterable 中的元素进行计数，并返回一个类似字典的结构，其中包含每个元素的计数。

4.**order dict:**Python 字典没有自然的顺序，但是有时候让字典条目的属性通过排序来访问是很有用的。“OrderedDict”与“Dict”完全一样，但它会记住键的插入顺序。

5.字典的一个常见范例是处理丢失键的情况。defaultdict 的工作方式与 python 字典完全一样，只是当您试图访问一个不存在的键时，它不会抛出 KeyError。相反，它使用创建 defaultdict 时作为参数传递的数据类型的元素来初始化键。数据类型称为 default_factory。

6. ChainMap: 这是用来合并几个字典，它返回一个字典列表。

我希望这篇文章能让你体会到 python 集合的重要性和应用，以便你能更频繁地使用它。感谢阅读。

由凯利·西克玛在 Unsplash 上拍摄

一个关于巨人、机器学习药丸和汽车工业的故事

原文：https://towardsdatascience.com/a-tale-about-a-giant-a-machine-learning-pill-and-the-automotive-industry-1b339550dbad?source=collection_archive---------30-----------------------

汽车中的人工智能

关于人工智能对世界上最重要的行业之一的影响的童话三部曲的大结局。

从前，有一个巨人。一个巨大而强大的巨人，每个人都知道这个巨人。然后，一位友好的仙女给了巨人一颗神奇的机器学习药丸。药丸承诺让巨人变得更加强大，但也给他带来了剧烈的疼痛。巨人吞下了药丸，成长的烦恼开始了。

来源

这是这个关于机器学习对汽车行业影响的三部曲的最后一部。为了更好地说明复杂性和挑战，这个关于巨人和机器学习药丸的故事补充了主要观点。这些见解基于我在汽车行业的工作经验以及与来自世界各地的汽车专家的长期对话。三部曲分为以下几个部分:重要性(一)、机遇(二)、汽车行业在实现机器学习的超越性技术方面的挑战(三)。

这部分阐述了机器学习对汽车行业的挑战。成长的烦恼发生在以下几个部分:数据、基础设施、算法。让我们看看怎么做。

数据

汽车行业坐拥未来最宝贵的资源之一——数据。一辆配备现代传感器的汽车每天可以产生 4-10tb 的数据。最大的数据生产者是相机和激光雷达传感器。摄像机观察环境以检测物体或车道标志。激光雷达传感器有助于获得与其他物体的精确距离。机器学习有助于解释输入的数据。

让我们客观地看待产生的大量数据。如果你的智能手机有 256 GB 的存储空间，10 TB 的数据相当于 40 部智能手机每天的使用量。数据是机器学习的关键因素，教会算法学习什么。因此，访问大量数据是构建智能系统的先决条件。但这种过多的数据给汽车行业的存储、过滤和分析带来了新的挑战。

竞争对手，或者说小巨人，明白数据的价值。他们竞相收集公路上行驶的数百万英里。2019 年，电动汽车制造商特斯拉收集了超过 20 亿英里的数据。自动驾驶汽车公司 Waymo 在 2018 年 10 月已经超过了 1000 万英里大关。此外，这些公司已经在模拟中驾驶数十亿英里。Elon Musk 声称特斯拉目前收集了所有收集的汽车数据的 99.5% 。今天有超过 50 万辆配备摄像头的特斯拉汽车在行驶。然而，曲棍球棒曲线在收集英里是最令人印象深刻的。小巨人拥有创建成功的机器学习算法的原材料。

来源

然而，价值并不在于纯粹的记录数据量。训练机器学习算法需要多样化的数据集。在红灯前站几个小时记录数据会产生大量数据，但价值有限。关键是收集智能数据。角落案例数据尤其有价值，例如，一个孩子在追球时突然穿过街道。在这些情况下，您需要 100%确定算法运行正确。

为了测试非正统的情况，Waymo 首席执行官约翰·克拉夫茨克(John Krafcik)公开描述了他们如何测试不寻常的场景。据说约翰装扮成芝麻街里的大鸟，看看汽车是否会停下来！让一只大鸟穿过街道肯定是汽车以前没有见过的情况，但它仍然应该停下来。

理解了处理数据的挑战之后，让我们继续讨论让机器学习工作所必需的基础设施。

基础设施

具有智能功能的汽车需要先进的传感器来感知环境。根据 Udacity 的估计，制造一辆研究车可能要花费 25 万美元以上。为卡车配备足够的传感器以实现自动驾驶功能需要花费数百万美元。

最昂贵的传感器是顶级激光雷达，大约 12 万美元。一旦激光雷达传感器大规模生产，成本预计将大幅下降。Waymo 出售其自主开发的激光雷达传感器 Honeycomb，，他们声称这可以降低 90%的成本。大多数汽车公司都同意，激光雷达是安全高级驾驶功能所必需的。特斯拉省略了传感器，著名的称之为【拐杖】。

一个主要的突破点是量产汽车制造商的成本敏感性。大众或丰田等公司的新车利润率只有 5%左右。所以，如果你花 25.000 美元买了一辆车，公司只有 500 美元的利润。插入新的传感器会立即降低企业的盈利能力。将传感器成本降低到仍然能够实现人工智能驱动功能的水平仍然是一个挑战。

此外，考虑下图。它没有显示一个不断演变的组织结构图。的。gif 展示了自 20 世纪 70 年代以来现代汽车电子架构的演变。如您所见，架构变得越来越复杂，越来越难以维护。

即使该架构使用了与 Kubernetes 协调的微服务，它仍然非常复杂。请记住，汽车从来都不是纯粹的软件产品，它们与关键硬件相互作用。这使得收集数据和集成机器学习算法成为一项复杂的挑战。

让我们看看在机器学习的帮助下使巨人成长的最后一块拼图。

算法

在汽车功能中包含机器学习算法带来了新的挑战。传统的编程被认为是安全的，因为它的确定性地工作。机器学习被认为是不安全的，因为它的操作是概率性的。

想想声称神经网络可以根据一个人的脸来检测他是否是罪犯的研究。除了这项研究的道德和伦理风险，它被证明是完全错误的。

研究人员以不同的方式从罪犯和非罪犯那里收集输入数据。他们从政府颁发的罪犯身份证上获取面部图像。另一方面，他们从一个公共网站上获取非罪犯的面部图像。现在，谁会愿意把自己的身份证照片放在个人资料上呢？我在护照照片上看起来确实像个罪犯！本质上，该算法学会了区分政府 ID 和你的 LinkedIn 个人资料图片，而不是区分罪犯和非罪犯。

另一个值得警惕的例子来自加州大学欧文分校。一名学生训练了一个神经网络来区分哈士奇和狼。这个学生很高兴在这个任务中达到了 94%的准确率。然后教授问学生，他怎么能确定网络学到了它应该学的东西？分析数据后，该小组发现了关键的区别点。大多数哈士奇图片的背景是雪，而狼图片的背景是没有雪的。本质上，算法并没有学会区分哈士奇和狼，而是在后台区分“下雪”和“没下雪”。

这些例子表明，理解算法学习什么对开发安全函数很重要。功能开发人员必须确保他们的算法在驾驶车辆绕过人类时能够按预期工作。该行业需要对输入数据进行清晰的检查，以及测试和批准基于机器学习的功能的清晰流程。

结局(三)

通过这个童话，我希望你能更好地理解汽车巨头实施机器学习的当前机遇和挑战。这种机器学习药丸可以让巨人变得如此强大，但也会带来剧烈的疼痛。

谢谢你跟随巨人的旅程！然而，这个故事远未结束。巨人需要你来帮助它处理成长的烦恼。鉴于这个行业的重要性，我希望你能考虑加入这个巨人的故事。加入巨人，帮助它处理痛苦，这是最激动人心的时刻。

如果你喜欢这个故事，你可以在这里重读童话三部曲。第一部分讨论了汽车工业的重要性，第二部分解释了未来的机遇。

这个故事是在数据节 2019 上呈现的。点击此处查看本次演讲的视频。如果你想听更多关于商业、项目管理和数据科学的交集，在 Medium 、 LinkedIn 或 Twitter 上关注 me。

一个关于巨人、机器学习药丸和汽车工业的故事

原文：https://towardsdatascience.com/a-tale-about-a-giant-a-machine-learning-pill-and-the-automotive-industry-7c74b2bcb09c?source=collection_archive---------23-----------------------

汽车中的人工智能

关于人工智能对世界上最重要的行业之一的影响的童话三部曲的第二个故事。

从前，有一个巨人。一个巨大而强大的巨人，每个人都知道这个巨人。人们为巨人工作，为自己和他人创造巨大的财富。然后，巨人从一个友好的仙女那里收到了一颗神奇的机器学习药丸，承诺让巨人变得更加强大。

来源

这是这个关于机器学习对汽车行业影响的三部曲的第二部。为了更好地说明在老牌汽车制造商中使用机器学习的复杂性和挑战，这个关于巨人和神奇药丸的故事补充了主要观点。这些见解基于我在汽车行业的工作经验以及与来自世界各地的汽车专家的长期对话。三部曲分为以下几个部分:重要性(一)、汽车行业在实现机器学习这一超越性技术方面的机遇(二)、挑战(三)。

第二部分详细阐述了机器学习药丸可以给巨人带来的机会。它承诺让这个巨人变得更大更强大。让我们看看怎么做。

自动驾驶

今天，汽车由人类驾驶，从一个地方到达另一个地方。机器学习是一项关键技术，可以让人们或货物自动驾驶到目标目的地。这就是所谓的自动驾驶(AD)。

来源

AD 允许创建多种应用程序。机器人轴立即浮现在脑海中，它在城市环境中运送人们。谷歌子公司 Waymo 被视为未来城市交通的领跑者。2019 年，该公司开始在亚利桑那州凤凰城测试其自动驾驶出租车服务，车辆中没有安全驾驶员。

然而，AD 要大得多，不仅允许人类自主地从 A 地运输到 B 地，还允许货物运输。汽车制造商大众承认，物流行业对自动驾驶的需求最为迫切。因此，它将大众汽车自主有限公司从其商用车子公司中剥离出来。在物流业务中，三个主要的成本构成是车辆价格、汽油和工资。降低薪资成本最能提高物流行业的盈利能力。

来源

AD 技术还支持其他用例，如斯堪尼亚的 自主运输设备、采矿卡车、拖拉机或任何其他工作车辆。重型设备制造商 John Deere 已经研发半自动拖拉机 20 年了。在一些农田需要一整天犁一条线的地方，自动拖拉机有望带来巨大的好处。

斯堪尼亚自主采矿卡车概念

自动驾驶车辆承诺打破车辆的神奇产品三角。产品三角形表明，你应该致力于在短时间内，以高质量和低成本创造任何产品。你可以沿着神奇的产品三角排列任何产品。当今汽车的产品三角如下。

汽车可以在短时间内把人或货物从 A 地送到 B 地，成本低，质量合理。AD 提供了将每种产品的能力扩展到可以想象的最大限度的机会。

打车公司优步估计，无人驾驶汽车可以将每英里费用从 T2 的 2.86 美元降低到仅 0.35 美元。这种几乎 90%的成本降低提高了产品三角的成本能力。AD 通过让司机有时间在车内阅读、睡觉或工作，潜在地提高了乘坐的质量。当卡车可以自主移动时，卡车司机所需的休息时间也可以减少到最低限度。AD 扩展了移动车辆的所有产品功能，从而为客户满意度和公司发展提供了巨大的机会。

鉴于人们对广告的极度兴奋，消费者期待着无人驾驶汽车的到来。主要汽车制造商宣布了自主打车服务的雄心勃勃的开始日期，从而加剧了这种兴奋。电动汽车制造商特斯拉宣布其计划在 2019 年年底推出自动驾驶班车服务。这一切似乎都很容易，到处都有关于自动驾驶汽车的精彩玩具视频。此外，在线学习平台 Udacity 从 2011 年开始提供自动驾驶汽车工程师纳米学位。创业公司如此接近解决 AD 的故事比比皆是，就像下面这个。

谷歌正在研究自动驾驶汽车，他们似乎也在努力。人们在驾驶汽车方面如此糟糕，以至于计算机不必那么好就能好得多。— 马克·安德森，风险投资家于 a16z ， NYT 2011

硅谷著名企业家、 comma ai 创始人乔治·霍兹，在 2016 年底差点提供自动驾驶功能。乔治入侵了一辆 Acure 汽车，给它配备了一部智能手机，让它的摄像头透过挡风玻璃对准前方的道路。然后他突然打方向盘、加速和刹车信号来操纵汽车。点击此处查看open pilot 发布视频。Comma.ai 开始以 999 美元的价格出售广告硬件，外加每月订阅费。在第三部分，你会听到这个故事是如何展开的。

来源

不管这些雄心勃勃的声明，许多汽车制造商已经推迟了将广告投放市场的时间表。机器学习是帮助这家巨头创造变革性新产品的关键促成因素。让我们调查一下机器学习药丸如何帮助这个巨人带来另一个基石产品。

个人助理

让我们假设有一天自动驾驶能力无处不在。那么是什么将一辆车与另一辆区分开来呢？越来越多的关注将转向室内用户体验。

如今，汽车驾驶舱是手动操作的。按钮和旋钮让驾驶员无法选择操纵汽车设置。想提高汽车温度？打开空调，向右转动两个轮子以提高目标温度，并增大风扇。四个步骤，为了一个目的。机器学习使汽车能够预测用户需求，并立即满足基于语音的请求。

机器学习是实现汽车个人助理的关键技术。这个助手可以学习司机喜欢的温度，并自动调整汽车的设置。用户通过语音与汽车互动，省略了按钮和旋钮。

据 Samsung Next 报道，风险投资者对投资平台感兴趣。正如、 Greylock Partners 的风险投资人 Sarah Guo 在 2018 人工智能前沿大会期间提到的，互联网平台催生了谷歌或脸书这样的独角兽。移动作为下一个平台推动了像 Lyft 或 AirBnB 这样的公司达到独角兽的估值。自动驾驶汽车会成为下一个平台，推动独角兽游戏、娱乐或 VR/AR 初创企业的崛起吗？

机器学习为汽车公司提供了巨大的新产品机会。个人助理和自动驾驶只是机器学习使之成为可能的少数面向客户的应用。在智能生产、RPA 和营销领域存在更多机会。

回到故事。现在，这位巨人明白了这种神奇的机器学习药丸是如何让它变得更大更强的。但是巨人仍然在思考经历这些成长的烦恼是否值得。毕竟，它是世界上最强大的巨人之一，不怕任何人。然后，在远处的地平线上，巨人发现了一个小巨人。走近小巨人，巨人意识到它一直在享用机器学习药丸。小巨人还不会走路，但很明显，一旦它长到最大力气，它就能轻而易举地打败巨人。接下来我们来检查一下小巨人。

竞争对手

以下两张图表值得你高度关注。下图显示了六家移动公司的公司估值。Waymo 目前的估值最高，为1050 亿美元。特斯拉的股票一直不稳定，仅在过去的两个月里，公司价值在 2020 年 1 月就翻了一番，达到约 810 亿美元。像 Waymo、优步或特斯拉这样的公司代表了这个小巨人。这个巨人的代表是大众、宝马或戴姆勒这样的汽车巨头。

Waymo 的估值超过了所有其他公司的估值。在获得一美元收入之前，它的价值已经高于宝马和戴姆勒的总和。 Waymo 的技术非常依赖机器学习来创造世界上最安全的司机。优步和泰斯拉的估值也受到他们努力将广告变成现实的推动。优步创始人特拉维斯·卡兰尼克称自动驾驶汽车是优步未来最重要的技术。特斯拉著名的自动驾驶功能完全依靠机器学习来检测物体，并使汽车保持在车道上。

相比之下，下图显示了每家公司达到预期估值所需的员工数量。2018 年，Waymo 勉强跨过了 1000 名员工的大关。另一个极端是，大众汽车目前在全球雇佣了超过 66 万名员工。你可以看到这个小巨人比巨人需要更少的员工来创造惊人的市场估值。

现在，让我们不要不公平。汽车制造商今天生产有形的价值。他们每年销售数千万辆汽车。如果自动驾驶汽车技术没有得到验证，投资者将会损失很多钱，但也仅此而已。但是如果它被证实了呢？

又怕又急，巨人吞下了苦涩的机器学习药丸。

结局(二)

这篇文章展示了通过机器学习药丸可以实现的变革机会。虽然巨人仍然对服用这种药丸犹豫不决，但其他一直在享用这些机器学习药丸的小巨人看到他们的力量爆炸了。

接下来会发生什么，当巨人吞下药丸，对它的身体造成严重压力？继续在这里(即将于 1 月 19 日)阅读在这个成熟的行业中实现机器学习的挑战和副作用。重读三部曲开篇这里。

这个故事是在数据节 2019 上呈现的。点击此处查看本次演讲的视频。如果你想听更多关于商业、项目管理和数据科学的交集，在 Medium 、 LinkedIn 或 Twitter 上关注 me。

一个关于巨人、机器学习药丸和汽车工业的故事

原文：https://towardsdatascience.com/a-tale-about-a-giant-a-machine-learning-pill-and-the-automotive-industry-part-i-299a9ad5653f?source=collection_archive---------35-----------------------

汽车中的人工智能

打开童话三部曲，讲述人工智能对世界上最重要的行业之一的影响。

从前，有一个巨人。一个巨大而强大的巨人，每个人都知道这个巨人。它有一种相当特殊的气味，对环境有害，但那是另一回事了。世界各地的人们热爱这个巨人，顺从地为它工作。

来源

一天，一个仙女飞向巨人。仙女给了巨人一颗药丸，并说:“这颗机器学习药丸是来自一个很远很远的地方的强大魔术师创造的。它会给你巨大的力量，但是要小心，它也会给你带来严重的痛苦。".

图片由 Pixabay 上的 Oberholster Venita 拍摄

这是这个关于机器学习对汽车行业影响的三部曲的第一部。为了更好地说明在老牌汽车制造商中使用机器学习的复杂性和挑战，这个关于巨人和神奇药丸的故事补充了主要观点。这些见解基于我在汽车行业的工作经验以及与来自世界各地的汽车专家的长期对话。该三部曲分为以下几个部分:汽车行业在实施机器学习的卓越技术方面的重要性(I)、机遇(II)和挑战(III)。

让我们在第一部分集中讨论为什么这个童话的主角是一个巨人而不是一只乌龟或小马。虽然汽车行业可能面临严峻的挑战，但你为什么要在乎呢？让我们看看汽车行业的经济、社会和未来影响。

汽车工业的经济影响

汽车行业是世界上最重要的行业之一。为了证明这一点，让我们来看看对世界 GDP 贡献最大的四个国家中的两个，美国和德国，以及汽车行业在其中的重要性。

来源

下图显示了按行业分组的上市公司的市值。市值表明市场认为某个公司或行业有多大价值。它的计算方法是将当前股票价格乘以发行在外的股票数量。例如，美国大型汽车制造商通用汽车的股票在2019 年 12 月 30 日今天的价格是 36.56 美元。该公司有 14.3 亿股流通股。因此，通用汽车的市场价值为 36.56 美元* 1.43 亿美元= 52.28 亿美元。

来源

如果你把美国所有汽车行业公司的市值加起来，你会得到 8000 亿美元的行业估值。如上图所示，汽车工业比航空业或烟草业更重要。软件业的价值远远高于所有其他行业。对汽车行业未来发展方向的暗示？尽管如此，图表显示了汽车行业对世界最大经济体的重要性。

接下来，让我们考虑一下汽车行业对世界第四大经济体德国的重要性。

来源

德国拥有全球汽车公司，如大众、宝马、戴姆勒、大陆或博世。他们的总市值超过了 2000 亿€，略微超过了化学工业的头把交椅。德国经济的主要驱动力是汽车。

在理解了汽车工业的经济影响之后，让我们更个人化地评价一下汽车工业对全球就业的社会影响。

汽车工业的社会影响

根据国际汽车制造商组织的数据，全球汽车行业雇佣了超过 900 万人在 T2 工作。此外，汽车行业创造了一个相邻企业的生态系统。汽车经销商、保险公司或洗车店依赖于汽车工业的持续运转。如果算上在汽车相邻企业工作的人，超过 5000 万人间接受雇于汽车行业。这相当于 60 个工作成年人中有 1 个。

来源

如果我们比较德国的数据，我们会发现类似的分布。德国汽车工业协会估计超过 80 万人直接受雇于汽车工业，近 200 万人间接受雇于汽车工业。在德国，依赖汽车行业的成年人中有 1/50 的比例更为极端。

来源

在了解了汽车行业对你或你邻居的薪水有多重要之后，让我们来看看汽车行业的现状和未来预测。

汽车工业的前景

来源

根据丰业银行 2019 年的报告，过去 5 年来，全球汽车销量一直持平。自 1990 年以来，汽车行业取得了巨大的增长，汽车销量在 15 年内翻了一番。然而，这种增长停滞不前，尤其是富裕市场的需求停滞不前，正如下面的按地区分列的大众汽车销量信息图所示。一些希望在于南美等新兴市场需求的上升，但尚不清楚它们是否能弥补现有市场的增长不足。为了扩大业务和市值，汽车公司可以做些什么？

来源

另一方面，全球对移动解决方案的需求预计将在未来十年内激增。 Statista 估计对打车、公共交通或航班等服务的需求将继续增长。对于一些客户来说，共享移动解决方案而非所有权将变得更具吸引力。抓住这个机会，一些汽车公司开始将自己重新定位为移动提供商。例如，宝马的企业使命是“塑造明天的个人高级流动性”，而不是生产汽车。

来源

总而言之，目前全球汽车销售停滞不前，而对移动性的需求却在增加。汽车行业在寻找发展和繁荣的机会方面面临着严峻的挑战。机器学习药丸能延长巨人的寿命并帮助它成长为新的力量吗？

结局(一)

第一部分向您展示了汽车行业有多重要，以及您为什么应该关注它。汽车巨头就在我们身边，影响着许多人的生活。

继续下一集(将于 1 月 12 日播出)，阅读机器学习药丸对巨人的影响。最后一部分(将于 1 月 19 日发布)详细阐述了在这个成熟的行业中实施机器学习的挑战和副作用。

这个故事是在数据节 2019 上呈现的。点击这里可以找到这个演讲的视频。如果你想了解更多关于商业、项目管理和数据科学的交集，在 Medium 、 LinkedIn 或 Twitter 上关注我。

TF Lite 中模型量化的故事

原文：https://towardsdatascience.com/a-tale-of-model-quantization-in-tf-lite-aebe09f255ca?source=collection_archive---------29-----------------------

生产中的机器学习

模型优化策略和量化技术，帮助在资源受限的环境中部署机器学习模型。

在此与结果仪表板互动。

最新的机器学习模型通常体积庞大，这使得它们在资源受限的环境中部署时效率低下，如移动电话、树莓 pi、微控制器等。即使您认为您可以通过在云上托管您的模型并使用 API 来提供结果来解决这个问题，也要考虑到互联网带宽可能并不总是很高，或者数据不能离开特定设备的受限环境。

我们需要一套工具来无缝过渡到设备上的机器学习。在这篇报道中，我将向你展示 TensorFlow Lite (TF Lite) 如何在这种情况下大放异彩。我们将讨论 TensorFlow 支持的模型优化策略和量化技术。

查看 GitHub 上的代码 →

感谢 Arun 、 Khanh 和 Pulkit (谷歌)为这篇报道分享了非常有用的技巧。

不同量化实验之间的性能概述(此处可用

概观

在本文中，我们将涵盖以下主题

• 对设备上机器学习的需求
• TensorFlow 支持的模型优化策略
• 量化技术
• 执行量化时需要记住的事项

对设备上机器学习的需求

在他们的演讲tensor flow Lite:ML for mobile and IoT devices(TF Dev Summit ’ 20)中，Tim Davis 和 T.J. Alumbaugh 强调了以下几点:

• 更低的延迟&紧密互动:在许多关键应用中，你可能希望预测的延迟为零，例如无人驾驶汽车。您可能还需要保持系统的所有内部交互非常紧凑，这样就不会引入额外的延迟。
• 网络连接:正如我之前提到的，当你依赖云托管模式时，你实际上是将你的应用程序限制在一定的网络带宽水平上，而这可能并不总是能够实现的。
• 隐私保护:对隐私有硬性要求，例如，数据不能离开设备。

为了使大型 ML 模型能够部署在小型设备上，我们需要对它们进行优化，例如，将 1.9GB 的模型放入 2GB 的应用程序中。为了帮助 ML 开发者和移动应用开发者，TensorFlow 团队提出了两个解决方案:

• TensorFlow Lite
• TensorFlow 模型优化工具包

TensorFlow 支持的模型优化策略

通过 TensorFlow Lite 和模型优化工具包，TensorFlow 目前支持以下模型优化策略-

• 量化你可以使用不同的低精度格式来减小模型的大小。
• 修剪在这里，您可以丢弃模型中对模型预测意义不大的参数。

在本文中，我们将重点讨论量子化。

量化技术

通常，我们的机器学习模型以float32精度格式运行。所有模型参数都以这种精度格式存储，这通常会导致模型更重。模型的重量与模型进行预测的速度直接相关。因此，你可能会自然而然地想到，如果我们能降低模型运行的精度，我们就能减少预测时间。这就是量化的作用——它将精度降低到更低的形式，如 float16、int8 等，来表示模型的参数。

量子化可以以两种方式应用于一个模型

• 训练后量化在训练后应用于模型*。*
• 量化感知训练通常对模型进行训练，以补偿量化可能带来的精度损失。当您降低模型参数的精度时，可能会导致信息丢失，您可能会看到模型的精度有所降低。在这些情况下，感知量化的训练会非常有帮助。

我们将在这份报告中看到这两种味道。我们开始吧！

实验设置

我们在这份报告中做的所有实验都是在 Colab 上进行的。我使用 flowers 数据集进行实验，并微调了一个预先训练好的 MobileNetV2 网络。这是定义网络架构的代码-

对网络进行 10 个时期的训练，批次大小为 32。

正常微调下的性能

运行页面可用此处

所有这些文件都可以在这里找到

我们看到网络运行良好，达到 35.6 MB。

量化微调后的模型

当你在tf.keras中训练好一个模型后，量化部分只是几行代码的事情。所以，你可以这样做-

首先将您的模型加载到一个TFLiteConverter转换器类中，然后指定一个优化策略，最后，您要求 TFLite 使用优化策略转换您的模型。序列化转换后的 TF Lite 文件非常简单

这种量化形式也被称为训练后动态范围量化。它将模型的权重量化到 8 位精度。在这里你可以找到关于这个和其他训练后量化方案的更多细节。

关于为转换设置配置选项的说明

TF Lite 允许我们在转换模型时指定许多不同的配置。我们在前面提到的代码中看到过一次这样的配置，其中我们指定了优化策略。

除了tf.lite.Optimize.DEFAULT，还有另外两个政策可供选择- tf.lite.Optimize.OPTIMIZE_FOR_SIZE & tf.lite.Optimize.OPTIMIZE_FOR_LATENCY。从名称中可以看出，基于策略的选择，TF Lite 会相应地尝试优化模型。

我们可以指定其他事情，比如-

• target_spec
• representative_dataset

点击了解更多关于TFLiteConverter类的信息。值得注意的是，这些不同的配置选项允许我们在模型的预测速度和准确性之间保持平衡。在这里，你可以找到 TF Lite 中不同训练后量化方案的一些权衡。

下面我们可以看到这个转换模型的一些有用的统计数据。

餐桌可用此处

我们看到模型的规模大幅缩小，但这是以准确性为代价的。理想情况下，我们不希望转换后的模型精度损失这么大。这表明，我们需要探索其他量化方案，以进一步提高转换模型的准确性。

具有相同模型的量化感知训练(QAT)

这里一个好的第一个方法是训练你的模型，让它学会补偿可能由量化引起的信息损失。通过量子化感知训练，我们可以做到这一点。为了以量化感知的方式训练我们的网络，我们只需添加以下代码行-

现在，你可以像训练一个tf.keras模型一样训练qat_model。在这里你可以找到 QAT 的全面报道。

下面，我们可以看到这个量化感知模型比我们之前的模型稍好一些。

运行可用的这里

QAT 与非 QAT 模型的简要比较

就模型大小而言，QAT 模型与非 QAT 模型相似:

请记住，这些文件可以在任何运行的“文件”选项卡下找到

但是在模型训练时间方面，我们看到 QAT 模型需要更多的时间。这是因为在 QAT 过程中，模型中引入了伪量化节点来补偿信息损失，这使得 QAT 模型需要更多的时间来收敛。

在优化收敛时间的情况下，记住这一点很重要。如果你的训练模型需要很长的训练时间，那么引入 QAT 会进一步增加这个时间。

量化 QAT 模型与我们在上一节中看到的完全相同(我们将使用相同的量化配置)。

现在让我们比较量化版本的 QAT 模型的性能。

模型训练时间的比较

评估量化的 QAT 模型

在下表中，我们看到量化版本的 QAT 模型确实比以前的模型表现得更好。

此处可用的表为

我们清楚地看到，用 QAT 训练的模型没有引起任何精度下降。在下一节中，我们将把两个模型的参数都保持为浮点数，看看我们能在多大程度上推动模型大小和准确性之间的权衡。

量化为浮动模型

为了将我们的模型量化到浮点精度，我们只需要丢弃这条线— converter.optimizations = [tf.lite.Optimize.DEFAULT]。如果你想利用 GPU 代理，这个策略尤其有用。注意， float16 量化在 TensorFlow Lite 中也是支持的。在下表中，我们可以看到使用该方案量化的模型的大小和精度。

此处可用的表为

虽然这些型号的尺寸有所增加，但我们看到这些型号的原始性能仍然很高。注意，不建议使用这种方案转换 QAT 模型，因为在 QAT 期间，插入的伪量化运算具有int精度。因此，当我们使用这种方案量化 QAT 模型时，转换后的模型可能会出现不一致。

此外，硬件加速器，如边缘 TPU USB 加速器，将不支持浮动模型。

探索其他量化方案和总结思路

还有其他训练后量化技术可用，如全整数量化、浮点量化等。这是你可以了解他们更多的地方。请记住，全整数量化方案可能并不总是与 QAT 模型兼容。

有许多 SoTA 预训练的 TF Lite 模型可供开发人员在其应用中使用，它们可以在以下位置找到:

• https://www.tensorflow.org/lite/guide/hosted_models
• https://tfhub.dev/s?deployment-format=lite&publisher = tensor flow&q = lite

对于希望在应用程序中集成机器学习的移动开发人员来说，TF Lite 中有许多示例应用程序值得一试。TensorFlow Lite 还为嵌入式系统和微控制器提供工具，您可以从这里了解更多信息。

如果您想重现此分析的结果，您可以–

查看 GitHub 上的代码→

双城记！(用数据讲故事)

原文：https://towardsdatascience.com/a-tale-of-two-cities-e693c15b3ddb?source=collection_archive---------34-----------------------

基于 Foursquare 数据和机器学习的城市对比分析

关键词:数据科学、机器学习、Python、网络抓取、Foursquare

图片来源:【https://www.sussexscenes.co.uk/view-shard-london/

【https://br.pinterest.com/pin/92816442292506979/

这篇文章涵盖了在 IBM 数据科学专业 课程中用于最终顶点项目的方法和分析。详细的报告、代码和结果可以在 Github 上找到，并在文章末尾有链接。

1。简介

当谈到伦敦和巴黎时，选择一个城市总是一个艰难的决定，因为这两个城市都是真正的全球化、多元文化和国际化城市，位于两个欧洲国家的中心。除了作为欧洲两个最重要的外交中心，它们还是金融、商业、科学、时尚、艺术、文化和美食的主要中心。伦敦(英国首都)和巴黎(法国首都)都有着丰富的历史，是欧洲游客最多、最受欢迎的两个城市。伦敦是英国最大的城市，位于英格兰东南部的泰晤士河畔。另一方面，巴黎位于国家的中北部。与伦敦相似，这座城市也坐落在一条通常被称为塞纳河的河边。

我们的目标是对这两个城市进行比较，看看它们有多相似或不相似。这种技术使用户能够根据当地提供的便利设施或服务来确定城市中的类似社区，从而有助于了解当地的活动，不同活动的中心是什么，市民如何体验城市，以及他们如何利用城市资源。

什么样的客户会从这样的分析中受益？

1. 具有可转移技能的潜在求职者可能希望在特定的城市寻找工作，这些城市在工资、社会福利，甚至在适合外籍人士的文化方面，为他们的资格和经验提供最合适的匹配。
2. 此外，在新城市购买或租赁房屋的人可能想要寻找该城市中与他们所知的其他城市相似的位置的推荐。
3. 类似地，一家希望将其地点扩展到其他城市的大公司可能会从这种分析中受益。
4. 许多市内城市规划计算也可能受益于模拟一个城市与其他城市的关系。

2。数据准备

为了解决手头的问题，数据提取如下进行:

网络抓取: 城市数据是使用请求和 BeautifulSoup 库从各自的维基百科页面【1】【2】中提取的。

*## URL to extract City neighbourhood information*
urlL = "https://en.wikipedia.org/wiki/List_of_London_boroughs"
urlP = "https://en.wikipedia.org/wiki/Arrondissements_of_Paris"
pageLondon = urllib.request.urlopen(urlL)
pageParis = urllib.request.urlopen(urlP)wikitablesL = read_html(urlL,  attrs={"class":"wikitable"})
print ("Extracted **{num}** wikitables from London Wikipedia".format(num=len(wikitablesL)))
wikitablesP = read_html(urlP,  attrs={"class":"wikitable"})
print ("Extracted **{num}** wikitables from Paris Wikipedia".format(num=len(wikitablesP)))dfP = wikitablesP[0]
dfL0 = wikitablesL[0]
dfL1 = wikitablesL[1]*## Request & response* 
s = requests.Session()
responseL = s.get(urlL,timeout=10)

对提取的数据执行进一步的数据清理，以便存储关于其邻近地区、其相应的坐标、面积和人口以及相应的区编号的相关信息。

**def** scrapeLondonTable(table):
    c1=[]
    c2=[]
    c3=[]
    c4=[]
    c5=[]
    c6=[]
    c7=[]
    c8=[]
    c9=[]
    c10=[]
    c11=[]

    **for** row **in** table.findAll("tr"):
        cellsL = row.findAll('td')
        **if** len(cellsL)==10: *#Only extract table body not heading*
            c1.append(cellsL[0].find('a').text)
            c2.append(cellsL[1].find(text=**True**))   
            c3.append(cellsL[2].find(text=**True**))
            c4.append(cellsL[3].find(text=**True**))
            c5.append(cellsL[4].find(text=**True**))
            c6.append(cellsL[5].find(text=**True**))
            c7.append(cellsL[6].find(text=**True**))
            c8.append(cellsL[7].find(text=**True**))
            c9.append(cellsL[8].find('span',{'class': 'geo'}))
            c10.append(cellsL[9].find(text=**True**))
    *# create a dictionary*
    d = dict([(x,0) **for** x **in** headerL])
    *# append dictionary with corresponding data list*
    d['Borough'] = c1
    d['Inner']= c2
    d['Status']=c3
    d['Local authority']=c4
    d['Political control']=c5
    d['Headquarters']=c6
    d['Area (sq mi)']=c7
    d['Population (2013 est)[1]']=c8
    d['Co-ordinates']=c9
    d[' Nr. in map']=c10
    *# convert dict to DataFrame*
    dfL_table = pd.DataFrame(d)
    *## convert Area units to kms^2*
    *#dfL["Area"] = 2.59 * (pd.to_numeric(dfL["Area"]))*
    Latitude = []
    Longitude = []
    **for** i **in** range(len(dfL_table)):
        locationSplit = dfL_table['Co-ordinates'].iloc[i].getText().split("; ") 
        Latitude.append(locationSplit[0])
        Longitude.append(locationSplit[1])
    dfL_table['Latitude'] = Latitude
    dfL_table['Longitude'] = Longitude
    dfL_table.drop(['Inner','Status','Local authority','Political control','Headquarters','Co-ordinates'],axis=1,inplace=**True**)
    dfL = dfL_table.rename(columns={'Area (sq mi)': 'Area', 'Population (2013 est)[1]': 'Population',' Nr. in map':'District Number'})
    dfL['District Number']  = dfL['District Number'].astype(int)
    **for** i **in** range(len(dfL)):
        dfL['Area'].iloc[i] = float(re.findall(r'[\d\.\d]+', dfL['Area'].iloc[i])[0])
        dfL['Population'].iloc[i] = int(dfL['Population'].iloc[i].replace(',',''))
    **return** dfL

在必要的数据清理之后，我们获得了以下用于研究的数据框架:

伦敦市区列表。

巴黎市的区列表(1-4 区合并为 1 区)。

Foursquare 位置数据: Foursquare 是一个社交位置服务，允许用户探索周围的世界。Foursquare API 提供了基于位置的体验，包含关于地点、用户、照片和签到的各种信息。我们利用 Foursquare 数据来提取所有被研究社区的基于地点的信息。对 API 的调用返回一个 JSON 文件，我们需要将它转换成数据帧。然后，位置数据被用来在每个街区寻找顶级和独特的场地。我决定在方圆 1 公里内的每个街区挑选 100 个最受欢迎的景点。

3.探索性数据分析

城市数据

维基百科的数据为我们提供了各个城市中每个行政区的坐标、面积和人口信息。人们可以利用这一信息来绘制一张城市地图，根据人口密度标出每个行政区。 Geocoder 和“leave map库用于活页地图上的数据可视化，根据人口密度标记行政区。密度越高，标记的半径越大。

基于人口密度的伦敦(左)和巴黎(右)地图。(注:伦敦地图上的标记已按 1/1000 的比例缩小，巴黎地图上的标记已按 1/2000 的比例放大)。

场馆数据

Foursquare 的位置数据给出了每个区 1 公里半径内的地点列表信息。这是了解街区特征的合理距离。

## Extracting Foursquare venue data
LIMIT = 100 *# limit of number of venues returned by Foursquare API*
radius = 1000 *# define radius*

**def** getNearbyVenues(names, latitudes, longitudes, radius=500):

    venues_list=[]
    **for** name, lat, lng **in** zip(names, latitudes, longitudes):
        print(name)

        *# create the API request URL*
        url = 'https://api.foursquare.com/v2/venues/explore?&client_id=**{}**&client_secret=**{}**&v=**{}**&ll=**{}**,**{}**&radius=**{}**&limit=**{}**'.format(
            CLIENT_ID, 
            CLIENT_SECRET, 
            VERSION, 
            lat, 
            lng, 
            radius, 
            LIMIT)

        *# make the GET request*
        results = requests.get(url).json()["response"]['groups'][0]['items']

        *# return only relevant information for each nearby venue*
        venues_list.append([(
            name, 
            lat, 
            lng, 
            v['venue']['name'], 
            v['venue']['location']['lat'], 
            v['venue']['location']['lng'],  
            v['venue']['categories'][0]['name']) **for** v **in** results])

    nearby_venues = pd.DataFrame([item **for** venue_list **in** venues_list **for** item **in** venue_list])
    nearby_venues.columns = ['Borough', 
                  'Borough Latitude', 
                  'Borough Longitude', 
                  'Venue', 
                  'Venue Latitude', 
                  'Venue Longitude', 
                  'Venue Category']

    **return**(nearby_venues)print("Getting venues inside the following Boroughs of London:")
London_venues = getNearbyVenues(names=tableL['Borough'],
                                   latitudes=tableL['Latitude'],
                                   longitudes=tableL['Longitude']
                                  )

伦敦总共有大约 219 个独特的场馆类别，巴黎有 180 个。我用这些信息在一个条形图上显示了伦敦市中心和巴黎市中心区的一些最常见的场馆。

*## Picking major districts inside inner London and inner Paris respectively*
districtsL = ['City of London','Westminster','Kensington and Chelsea','Hammersmith and Fulham', 'Wandsworth']
districtsP = ['Louvre, Bourse, Temple, Hôtel-de-Ville', 'Panthéon', 'Luxembourg', 'Palais-Bourbon', 'Élysée']

**def** nearbyvenues_count(venues_df, district):
    venues_count = venues_df
    venues_count = venues_count.rename(columns={'Venue Category': 'Category'})
    venues_count = venues_count.groupby(['Borough']).Category.value_counts().to_frame("Counts")
    fig, ax = plt.subplots(1,1,figsize=(20, 7)) 
    fig.subplots_adjust(left=0.115, right=0.88)
    venues_plot =  venues_count['Counts'].loc[district][:10].head(10) 
    pos = np.arange(len(venues_plot))
    ax.set_title(district,size=20)
    freqchart = ax.barh(pos, venues_plot,align='center',height=0.5,tick_label=venues_plot.index)

    **return** freqchart

伦敦内城区(上图)和巴黎内城区(下图)最常见的比赛场地。

虽然伦敦市中心最常见的场所在咖啡馆/咖啡店、酒吧、果汁吧或酒店之间，但在巴黎市中心或主要地区的行政区，最常见的场所大多是法国或意大利餐馆以及酒店。

为了以更全面的方式探索场馆数据并进一步用于分析，foursquare 场馆数据被安排到 pandas 数据框架中，如下所示:

• 首先，为每个场馆类别创建一个带有熊猫和一个热编码的数据框
• 使用熊猫组通过方法在区列获得每个一个热门编码场馆类别的平均值
• 使用场地类别均值获取每个城市的基于场地的数据框，给出每个行政区十个最常见的场地

## Categorizing venues into pandas
*# one hot encoding*
London_onehot = pd.get_dummies(London_venues[['Venue Category']], prefix="", prefix_sep="")

*# add neighborhood column back to dataframe*
London_onehot['Borough'] = London_venues['Borough'] 

*# move neighborhood column to the first column*
fixed_columns = [London_onehot.columns[-1]] + list(London_onehot.columns[:-1])
London_onehot = London_onehot[fixed_columns]
London_onehot.head()
London_grouped = London_onehot.groupby('Borough').mean().reset_index()**def** return_most_common_venues(row, num_top_venues):
    row_categories = row.iloc[1:]
    row_categories_sorted = row_categories.sort_values(ascending=**False**)
    **return** row_categories_sorted.index.values[0:num_top_venues]num_top_venues = 10
indicators = ['st', 'nd', 'rd']

*# create columns according to number of top venues*
columns = ['Borough']
**for** ind **in** np.arange(num_top_venues):
    **try**:
        columns.append('**{}{}** Most Common Venue'.format(ind+1, indicators[ind]))
    **except**:
        columns.append('**{}**th Most Common Venue'.format(ind+1))

*# create a new dataframe for London*
Londonboroughs_venues_sorted = pd.DataFrame(columns=columns)
Londonboroughs_venues_sorted['Borough'] = London_grouped['Borough']**for** ind **in** np.arange(London_grouped.shape[0]):
    Londonboroughs_venues_sorted.iloc[ind, 1:] = return_most_common_venues(London_grouped.iloc[ind, :], num_top_venues)

Londonboroughs_venues_sorted.head(10)

伦敦(左)和巴黎(右)的熊猫数据框中排列的 Foursquare 场馆数据部分。

然后，使用“”k-means”将提供每个区最常见的场地数据的信息用于对街区进行分类。

4。聚集街区

我使用’ k-means '算法进行了聚类分析，以便根据场地类别提供的相似性将相似的街区分类成簇。为了获得一些理解，我决定对将要使用的聚类数(k)进行一些研究，如下所示:

肘形法:我尝试使用肘形法确定伦敦聚类分析的有效聚类数(k)，并在 k = 6 附近看到一个小扭结(虽然不清楚也不尖锐)。肘形法对不同的 k 值使用组内误差平方和(WSS ),并且可以选择 WSS 开始减小的 k 值，并且可以被视为 WSS 对 k 图中的肘形。然而，对于 Paris 数据，没有明显看到扭结，因此我试图查看每个 k 值的聚类的剪影得分。剪影值衡量一个点与其自己的聚类(内聚)相比与其他聚类(分离)的相似程度。k = 2 左右的值给出了轮廓分数的全局最大值。尽管从这些研究中可以看出，我们没有明确的聚类数据，但为了我们的分析目的，我决定将伦敦街区分为 6 组聚类，将巴黎街区分为 2 组聚类。这可能是有益的，看看一个更详细的分析，以优化 k 在未来的此类研究。

5。结果讨论

为了解决手头的业务问题，我们考虑了伦敦内外的 33 个区和巴黎内的 16 个区。虽然这些社区中的每一个都可能是独一无二的，但其中一些在提供的便利设施方面可能更相似。执行聚类分析以找到那些相似的邻域。值得注意的一点是，从伦敦维基中提取的数据给出了伦敦内外各区的信息，因此将郊区也考虑在内。而巴黎维基提供的数据只给出了巴黎市内各区的信息，不包括巴黎周围大部分人口居住的郊区的信息。因此，这项研究中进行的分析需要更多的信息，以便在平等的基础上比较这些城市。

从解释性分析中得出的一些推论如下:

• 巴黎市中心的大部分地区比伦敦市中心的类似地区人口更稠密。伦敦 33 个区中有 9 个区的人口密度超过 1 万，而巴黎 16 个区中只有 3 个区的人口密度低于 1 万，4 个街区的人口密度超过 3 万。
• 在地图上，密集的行政区更多地集中在伦敦的内部区域，而不是外部区域，对于巴黎来说，最密集的行政区位于塞纳河以北。
• 对 Foursquare 场所数据的初步研究显示，咖啡店、咖啡馆、酒吧和果汁吧是伦敦市中心五个主要行政区最常见的场所。类似地，法国餐馆、意大利餐馆和酒店是在内巴黎五个主要行政区最常见的场所。

此外，对基于地点的数据的机器学习分析揭示了伦敦的大部分区可以被分组到一个聚类中。在这些区最常见的场所总是咖啡店、咖啡馆、酒吧、旅馆或餐馆，然后是某种服装、便利店或药店。巴黎总共被分为两个独立的区域。虽然两个集群中最常见的场所总是法国餐厅，但第一个集群中有大量的意大利餐厅、酒店和咖啡馆，第二个集群中有其他美食餐厅、酒吧、小酒馆、服装店或超市。

在这两个城市中，最常见的场所类型大多是餐馆、咖啡馆、酒店、酒吧、服装店或公园。这在某种程度上凸显了伦敦和巴黎在提供服务方面的相似性。

人们可以进一步使用场馆数据来比较城市，这是一种更全面的方式，人们也可以探索不同层次的空间聚合，即网格、街区和城市整体。当从场馆的角度来描述一个城市时，空间聚集的水平可能是一个重要的因素。

使用不同级别的空间聚合可以回答的一些问题可能是:

• 场馆类别在一个街区内是如何分布的，也就是说，这个街区是居住区还是商业区？
• 哪个城市的各种便利设施(酒吧、餐馆、公园、大学、图书馆、购物中心等)的数量最多？)

6。结论

总之，使用 Foursquare 基于场馆的数据分析城市，可以对每个街区的场馆类型有一个总体的了解，并呈现城市的一些关键特征，但是数据水平不足以提供城市间比较的全面分析。对于潜在的感兴趣的人(求职者或决定搬到两个城市之一的人)或更大的客户，如商业公司或城市规划者，需要做更详细的分析，增加诸如租金、工资、交通、生活成本、增长率、经济等特征。

capstone 项目提供了一个深入了解现实生活中数据科学项目如何工作以及构建数据科学方法的所有步骤的媒介。这里详细讨论了从理解业务问题、数据理解到数据准备和模型构建的所有步骤。还提到了目前分析的许多缺点和改进分析的进一步方法。这是理解和解决手头业务问题的初步尝试。然而，这个项目在现实生活中仍然有巨大的扩展潜力。

参考

[1] 伦敦维基百科

[2] 巴黎百科

关于我:

我是一名物理学家，几年来一直在分析粒子物理数据。在过去的几年里，我在卡尔斯鲁厄、日内瓦、圣保罗和芝加哥之间工作，目前居住在巴黎。尽管这样的数据分析将是设计一种方法来比较任何城市的垫脚石，但比较伦敦和巴黎是出于个人对这些城市的热爱。❤

你可以在 Linkedin 上找到更多关于我的信息。

链接到项目概要和代码。

"此刻做得最好会让你在下一刻处于最好的位置."保持安全和健康。

两种框架的故事

原文：https://towardsdatascience.com/a-tale-of-two-frameworks-985fa7fcec?source=collection_archive---------9-----------------------

Tensorflow 和 Pytorch:终于并肩了。

如果你像我一样，你在每个项目中都有一个最喜欢的框架。对我来说，这是 Tensorflow，特别是因为他们在 tf2.0 中更好地集成了 Keras。但每次 PyTorch 中发布另一个功能时，另一边的草看起来会更绿一些。所以本教程是为那些对一个框架有很强理解，对另一个有好奇心的人准备的。

在本教程中，我将带您浏览两个框架中的相同示例，包括一些最佳实践的并排比较，例如:

1. 数据生成器应对大数据集
2. 从头开始创建模型
3. 设置一个损失函数和优化器和
4. 带张量板测井和检查点T21 的训练循环
5. 通过微调预训练模型 改善结果
6. 评估你的一个测试集的模型

克里斯·亚瑟·柯林斯在 Unsplash 上拍摄的照片

资料组

我将使用一个熟悉的数据集，Cats v Dogs，因为本指南不是要解决一个棘手的问题(您可能已经想到了自己的问题)，而是要创建一个您可以轻松适应的通用、最小的示例。不过，最主要的是，我使用这个数据集是因为如果我要花大量时间看图片，我宁愿它们是可爱的动物。如果你想完全跟随，从这里下载数据。

我的数据集存储在包含我的训练脚本(“文件夹”)的文件夹的子目录(“数据”)中，其结构如下:

folder/
├── data/
    ├── test/
        ├──1.jpg
        ├──...
    └── train/
        ├──cat.0.jpg
        ├──dog.0.jpg
        ├──...

设置数据生成器

我的数据集不是很大(25，000 个相当小的图像，其中我只使用 1000 个作为最小的例子)，所以我可以将它们全部加载到内存中。但是数据集太大而无法加载到内存中变得越来越常见，因此拥有一个能够处理这些情况的管道非常重要。数据生成器是一个很好的选项，它允许您实时生成数据，批量运行预处理和扩充，并将其直接输入到模型中。这可以在训练期间带来巨大的效率，因为它允许在 GPU 正在运行训练的 CPU 上准备数据。

张量流数据生成器

对于我的 **Tensorflow 数据生成器，**我将从 tf 中继承。 keras 。实用工具。序列，这样我就可以利用多处理这样的额外好处。你会注意到我在这段代码中调用了一个函数‘augment ’,你可以在这里找到那个的代码，或者创建你自己的函数，其中输入是一个图像，输出是那个图像的放大版本，大小固定(im_size ),范围在-1 和 1 之间。

我们将重要信息作为参数，例如包含数据的目录(data_dir)、批量大小、图像将被重新缩放的大小(为此，它们将具有相同的高度和宽度)、要使用的图像数量(将此设置为小于图像总数的数字有助于测试网络和调试)，以及数据是否应该在每个时期被打乱。

该类需要一些方法才能正常工作:

• init 是初始化方法，在类被实例化时调用。在这里，它定位我们的图像名称，把它们放在一个列表中，并洗牌。
• on_epoch_end 在每个 epoch 结束时触发，这里只是对数据进行洗牌。
• 每次训练循环从生成器请求新数据时，索引将从 0 递增到由 len 定义的上限。最佳实践是将该上限值设置为每个时期中的批次数量，以便每个时期可以看到每个图像一次。
• getitem 在每次请求数据时被调用，它获取前面提到的索引，基于该索引获得图像名称的 batch_size 列表，并获取它们。

该类中的另外两个方法不是严格必需的:

• __get_data 是一个私有方法，由 getitem 调用以获取图像并对其进行扩充。您可以将代码放在 getitem 中，但是这种布局使代码更加模块化。
• load_val 一次性加载所有验证图像。这与使用数据生成器处理大型数据集的目的背道而驰，但不幸的是，我将使用的一种训练方法(“fit”)不接受生成器作为验证数据集，希望在未来的版本中可以解决这个问题。

然后，在训练脚本中创建一个生成器实例，并读入所有验证图像，这是一件非常简单的事情。

PyTorch 数据生成器

PyTorch 数据生成器与 Tensorflow 生成器非常相似。然而在这种情况下，传承自的火炬。 utils 。数据。数据集允许我们使用多重处理，类似于上一节中 tf.keras.utils.Sequence 的继承。还有很多其他的相似之处，我们使用了增强功能，我们也使用了类似的参数，包括批量大小、图像大小、图像数量和随机播放。

生成器包含三种相同的方法:

• init 是初始化方法，这里是打乱图像文件名(它已经被传递了)，并设置增强参数。
• len 的操作方式与上述相同
• getitem 读取一幅图像并放大。注意，这个生成器与前面的生成器的一个关键区别是，这里的生成器只生成一个图像，而 label - PyTorch 管理图像的批处理。

这里需要注意的一件重要事情是，如果 mobilenet 中的模型类型是应用于图像的归一化，这是因为我们将用于“mobilenet”的网络是一个预先训练的 torchvision 模型，它是使用在这种情况下归一化的图像训练的。因此，在使用这个模型时，我们需要以同样的方式进行归一化。

在培训管道中创建 PyTorch 生成器需要一些额外的工作。首先，我们设置一些参数，包括用于并行加载数据的线程数量。然后我们实例化该类，并将其传递给 DataLoader 类，该类也接受我们设置的参数。我们为验证创建第二个生成器，传递验证标志以确保图像不会被放大。

创建简单的模型

现在让我们看看创建一个简单的 CNN 是什么样子的。在这两个框架中，我将设置一个具有 4 个卷积层的 CNN，由最大池分隔，然后是 50%的下降，然后是两个线性层。我们在这里不是为了表演，只是为了演示。

这两个框架都允许你从头开始创建你需要的层，这意味着你有相当多的可定制性。然而，除非你有一个非常好的理由想要创建你自己的定制层，否则我鼓励你省去麻烦，使用两个框架都提供的用户友好的包装器。

张量流简单模型

Tensorflow 最近正确集成了 Keras，这是一种非常受欢迎的包装器，可以简化深度神经网络的创建和训练。这就是在 Tensorflow Keras 中创建我们的简单 CNN 的样子。

使用顺序模型类型将一堆层组合在一起。层在序列内堆叠的顺序表示层在网络中的顺序。与我们将在 PyTorch 中看到的不同，所有的层，包括那些没有可训练参数的层(比如 MaxPooling 和 activation 函数)都包含在模型中。这是因为这个函数既声明了模型的结构，又定义了向前(和向后)传递的数据流。

PyTorch 简单模型

在 PyTorch 中，模型被定义为从 nn 继承的类。模块，包含图层的 init 和定义数据如何通过网络的 forward()方法，并返回网络的输出。

请记住，任何具有需要训练的参数的层(如卷积层)都需要在 init 中注册。没有可训练参数(如最大池和激活函数)的层可以在 init 或 forward()中注册。

这可能比我们在 Tensorflow 中连接网络的方式要复杂一点，但是层和连接的分离为 PyTorch 提供了相当大的灵活性，这在 Tensorflow 中是不容易实现的。

定义损失函数和优化器

损失函数将模型的输出与目标值进行比较，并估计它们之间的差距。您使用的损失函数将取决于您的应用，我使用的是二元交叉熵和 Logit 损失，因为我正在训练一个二元分类器。“logit 损失”部分是因为我的模型的输出具有线性激活函数，这在 DL 框架术语中意味着我的损失函数的输入是“logit”，该术语用于分类输出在通过 sigmoid 或 softmax 层之前。使用交叉熵计算 sigmoid/softmax 的计算效率更高，具有 logit 丢失层的 BCE 就是这样做的。

优化器用于更新模型的参数，以减少损失。有很多优化器可供选择，但我使用的是亚当。

张量流损失函数和优化器

在 Tensorflow 中，有和没有 logit 损失的二元交叉熵是通过相同的函数定义的。

PyTorch 损失函数和优化器

在 PyTorch 中，有 logit 损失的二元交叉熵是一个独立于没有 logit 损失的函数。此外，优化器将模型参数和学习率作为输入。因此，如果您没有训练所有的参数(即，如果您正在微调模型)，那么请确保只传入您正在训练的参数。

训练循环(带记录)

最后，我们得到了好东西，训练我们的网络。我们还将在训练循环中添加两个独立的函数，一个用于将训练过程记录到 Tensorboard，另一个用于模型检查点。

Tensorboard 用于记录模型在训练过程中的损耗和精度。您还可以添加其他功能，如记录图像(如果您正在训练图像生成器，这将非常方便)和直方图(非常适合跟踪梯度)。

Tensorboard 提供了一个很好的方法来检查训练的结果，并比较不同的模型。

模型检查点在训练期间定期(默认为每个时期)将模型或权重保存在所选文件夹中。如果验证精度大于当前检查点，我们将只覆盖每一步的权重。

你可以(也应该)添加许多其他功能，比如学习率计划和提前停止。

Tensorflow 训练循环(选项 1)

在 Tensorflow 中，有多种训练网络的方法。第一种是最简单的，它利用 Keras 的“fit”方法，使用您的数据生成器作为训练数据输入(请注意，在 Tensorflow 2.0 之前，您必须使用“fit_generator”将生成器作为输入，但这在最近的版本中已被否决)。不幸的是，验证数据不能作为生成器传入。

在调用“fit”之前，我们需要用优化器和 loss 编译我们的模型。我们还为多重处理设置了一些参数，以加速训练循环。这里要注意的另一件事是回调的使用，这就是我们如何定义 Tensorboard 和前面提到的模型检查点行为。

在没有 GPU 的 MacBook Pro 上，该训练代码应用于 850 个猫/狗训练图像，其中有 150 个验证图像，给出了以下结果:

Tensorflow 训练循环(选项 2)

或者，我们可以更明确地定义训练循环。具体来说，我们定义了一个 for 循环，它遍历所有的历元，然后是另一个批量遍历数据集的循环。首先，我们定义了许多度量标准(训练/验证准确性和损失),它们在训练和测试步骤功能中得到更新。

然后我们定义训练和验证函数。在 train 函数中，我们打开一个 GradientTape()范围，在其中我们调用模型来运行正向传递并计算损失。然后，我们检索梯度，并使用优化器根据梯度更新权重。验证函数的不同之处在于，我们仅通过模型运行数据来计算损失和准确性，并记录两者。

这里需要注意的一点是在训练和测试步骤函数上面使用了 tf.function 装饰符。默认情况下，Tensorflow 2.0 以后以渴望模式运行，这对于逐行执行和调试非常有用，但会导致函数执行速度变慢。这个装饰器将 python 函数转换成静态张量流图，这样运行速度更快。

我们还需要手动设置 Tensorboard 日志记录，并检查验证准确性，以监控何时保存模型权重。

在没有 GPU 的 MacBook Pro 上，该训练代码应用于 850 个猫/狗训练图像，其中有 150 个验证图像，给出了以下结果:

PyTorch 训练循环

Pytorch 循环遵循与 tensorflow 循环相同的逻辑，要注意的主要区别之一是向后传递是如何非常优雅和直观地运行的，方法是在丢失时调用 backward 方法，参数是通过在优化器上调用 step 方法来更新的。值得注意的是，在验证步骤中使用了 no_grad 范围，它会将模型参数中的所有“requires_grad”标志临时设置为 False。

还要注意“model.train()”和“model.eval()”的使用，它们用于在包含具有不同训练和评估行为(如批处理规范化)的模块的模型的模式之间切换。

在没有 GPU 的 MacBook Pro 上，该训练代码应用于 850 个猫/狗训练图像，其中有 150 个验证图像，给出了以下结果:

与张量流相比，这显然是每个历元更长的时间。尽管在数据加载器中设置了 num_workers 参数，但在执行过程中监控我的 CPU 内核的使用情况显示，与 Tensorflow 实现相比，它们没有得到充分利用。这是 Pytorch 目前已知的问题，如果您知道修复方法，请发表评论！

使用预先训练的模型改善结果

Tensorflow 和 PyTorch 作为深度学习框架的一个重要方面是能够利用内置的预训练模型。这两个框架都包括许多在 ImageNet 上预先训练的最流行的模型，供您免费使用。更好的是，很容易开始使用这些网络，并用更适合您的问题的东西替换分类图层。

Tensorflow 预训练模型

在 Tensorflow 中使用预训练模型的一个特别简单的方法是通过 Keras 应用，这是带有预训练权重的固定架构。请注意，这不是使用预训练模型的唯一方式，但可能是最简单的方式。如果你选择的模特没有在这里列出，你可以去 TFHub 或者 TF 模特园看看。

在没有 GPU 的 MacBook Pro 上，该训练代码应用于 850 个猫/狗训练图像，其中有 150 个验证图像，给出了以下结果:

这比简单模型好多了！请注意，训练时间比简单模型短，因为实际训练的参数数量较少(即使整个模型大得多)。

PyTorch 预训练模型

与 Keras 应用程序相当的 Pytorch 是 Torchvision。火炬视觉预训练网络要求其输入以特定方式标准化，详情见此处。如前所述，我在数据扩充阶段对图像进行了归一化处理。

我们不想训练网络的特征提取阶段，因此在用我们自己的(可训练的)线性层替换第二分类层之前，我们为所有层关闭网络的‘requires _ grad’标志。我们只将这一层传递给优化器。

在没有 GPU 的 MacBook Pro 上，该训练代码应用于 850 个猫/狗训练图像，其中有 150 个验证图像，给出了以下结果:

模型评估

这是一个漫长的阅读，但我们几乎在那里，我们只需要评估模型。以下代码假设您已经创建了模型布局，因此只需要从文件中加载权重。

张量流模型评估

在预定义模型结构上使用的张量流方法“load_weights”加载并应用在所选检查点文件中找到的模型的训练参数。下面的代码从测试集中抓取一批图像，并在模型中运行它们。

Pytorch 模型评估

Pytorch 函数’ load_state_dict ‘应用在所选检查点文件中找到的’ model '参数的状态。下面的代码从测试集中抓取一批图像，并在模型中运行它们。

摘要

我希望本教程能让你更好地理解你喜欢的框架的对应部分的用法。这两个框架都已经发展到这样一个程度，即它们既易于初学者使用，又在需要时高度可定制。要查看完整代码，请查看 GitHub 上的代码。

双城记

原文：https://towardsdatascience.com/a-tale-of-two-towns-model-thinking-for-fighting-covid-cb2c16ca6ef8?source=collection_archive---------59-----------------------

由 Unsplash 上的融合医学动画拍摄的照片

抗击新冠肺炎的模型思维

编者按: 走向数据科学 是一份以数据科学和机器学习研究为主的中型刊物。我们不是健康专家或流行病学家，本文的观点不应被解释为专业建议。想了解更多关于疫情冠状病毒的信息，可以点击 这里 。

随着世界各地的城市和国家寻求在开放经济和将感染控制在可控水平之间找到正确的平衡，模型思维的应用可以帮助城市管理者更有信心地做出这些决定。

传统模型:严格但有限的决策支持

疫情最著名的模型将人群分为四大类:易感人群、已感染人群和已康复或死亡人群。然后根据新出现的数据对这些区间的相互作用进行建模和校准，然后用于预测感染。让我们称这些模型为 SIRD 模型。虽然这些是流行病学的优雅模型，但它们不适合在真实场景中评估影响和做出决策。关键缺点如下:

1. 关注流行病学部分，而非行为/影响部分:此类模型假设跨这些区间的传播参数相似。然而，传播可能因社会经济条件和工作性质而异，主要是因为这些因素影响采取预防措施的能力，如社会距离和在家工作。举例来说，送餐员必须在外面工作，同时与几个不同的陌生人打交道，优步的司机也是如此。然而，一名 IT 专业人员或大多数白领员工能够承受严格限制与人的身体接触。
2. 作为平滑且通常固定的参数的传播 : SIRD 模型假设传染病的传播可以通过平滑曲线来建模。这在直觉上是没有帮助的，因为传导主要是一条不规则的曲线(比如说在封锁期间更平坦，但在开放经济期间更陡峭)。
3. 依赖于确诊病例的模型校准:对于像 Covid 这样的疾病，其检测具有很大的不确定性(围绕是否有一次感染以及何时可以检测到)，并且已经通过不同的检测方案得到满足(最初强调检测国际旅行者，后来转向基于医疗保健准备情况和预期的社区传播的更广泛的检测)，确诊病例可能不会有益地用于了解该疾病迄今为止是如何传播的。

由于每个城市都有不同比例的行为群体(比如白领和蓝领工人)，一直在试验不同的控制措施和测试模式，纯 SIRD 模型无法回答如下问题:

1. 哪些控制措施将允许无害的相互作用，但防止可能导致疾病传播增加的相互作用？
2. 对弱势群体有什么影响，国家提供什么支持可以减轻这种影响(例如，国有保险、公共部门床位的可用性、药品定价等)。)?
3. 鉴于目前的事态(比如严格的封锁，然后是宽松的封锁)，感染情况如何，政策措施将如何影响感染？
4. 确保每个城市都包含 Covid 并采取措施防止新浪潮的最终策略和阶段是什么？

给 SIRD 模型增加助推器

为了解决其中的一些缺点，提出了一些对香草 SIRD 模型的改进，以获得更好的决策话语。我还选择利用一些可用的数据点(这些数据点仍然非常非常有限或者很难找到)为德里创建一个代表性的模型。以下是建议的增强措施:

1. 模拟社会经济区:城市(德里)被分为白城和蓝城。BlueTown 代表人口密集、通常无规划的居住区，大多数居民从事需要体力劳动的活动，社会经济地位相对较低。WhiteTown 代表人口密度较低的地区，居民从事可以在家中进行的工作(在家工作)，具有相对较好的社会经济地位。传播模型既有细分市场内的(比如拥挤的贫民窟中使用社区设施的邻居)，也有跨细分市场的(比如一个来自 BlueTown 的披萨外卖男孩感染了 WhiteTown 的居民，后者已经点了餐)。虽然这是一个抽象概念，但其目的是在一个真实的模型中模拟相关的社会经济部分，也许不仅仅是这两个部分。
2. 纳入已采取的控制措施:该模型将截至日期的总持续时间视为一组间隔，其中传播与已采取的措施和观察到的影响相关联。举例来说，在严格的锁定期间，传输速度直观上会变慢，但一旦解锁，传输速度就会再次激增。对于我的玩具模型，具有不同检测的 4 个清晰间隔由关键事件分开建模——第一种情况检测、完全锁定、绿色区域的初始开放以及具有一些放松的延长锁定
3. 传播系数的经验计算:虽然传播率的评估仍然存在很大的不确定性，但我们可以做出一些简单的假设来简化这一点。我们可以假设，随着人均接触次数的减少(如在锁定场景中)，传播确实变慢了，并且在打开时再次移回。我们还可以假设检测率(每次感染的病例数)根据检测标准而变化。最后，使用一组职业的相互作用来估计白镇、蓝镇内部和之间的传播。

虽然很难对模型进行清晰的校准(由于渐近情况以及检测和报告中的延迟)，但通过上述经验估计将模型调整到合理的限度。下图说明了结果输出。虽然由于校准挑战，这些数字没有对齐，但输出反映了相对于具有平滑传输假设的德里 SIRD 模型的建模灵活性-例如，在经典 SIRD 模型中很难发现 6 月显示的陡度。此外，开放的可怕影响(以及在各个部门内)可以更好地从这一练习中收集，这可以创造必要的话语，说明在开放时可以做些什么来防止这种上升，以及这种措施是否足够，损害是否可以接受。

德里的松散校准模型(直到 2020 年 6 月 23 日)

创造可供选择的世界

扩展现状，看看它会把我们引向何方，然后考虑通过模拟两个场景对两个虚构的城镇进行影响评估。在第一种情况下，假设封锁后的传播率将继续(6 月份暗中观察到的传播率仍然低于疫情开始时的传播率，当时人们的认识甚至更低)。这表明明年二月会达到高峰。在另一种情况下，如果我们假设封锁前的传播率，我们会在 8 月看到高峰。还可以看到，对 BlueTown 的影响比对 WhiteTown 的影响大得多，预计是因为那里估计的高传输速率。结果绘制如下。

场景 1:根据观察到的 6 月趋势控制传输

场景 2:遵循预锁定趋势的传输

虽然该模型侧重于模拟对两个社会经济部分的影响，但必要时也可以确定对决策有用的多个部分——例如模拟热点地区的店主，然后模拟他们的传输参数。此外，关于受感染人员的指示可以帮助准备跨区域的医疗资源分配。因此，所有关键决策都可以通过模拟备选方案和评估相对影响来决定。

城市管理者的外卖

**好的模型有助于决策，即使他们的预测是错误的。**它有一个特定的决策者——城市管理者，他们希望做出决定抗击疫情，它的核心是定制化，以帮助做出相关的政策决策，从全面封锁、医疗准备、服务许可到甚至开放边境。因此，城市管理者需要依赖代表他们的城市及其事务的模型，并使决策能够跨越他们所面临的决策

该模型还需要在传统流行病学模型的范式中注入各种数据来源，对我来说，这在这样的危机中是必要的。城市管理者需要利用他们拥有的所有数据，而不是依赖清教徒式的传统数据,因为他们做出的任何决定都会影响生活、生计和经济。在这种情况下，这意味着不仅考虑官方报告的数字，所有州可用数据，如第一次报告的可能病例症状(在医院)以及死亡，都被用来调整检测中的滞后。

最后，虽然随着我们对疾病、死亡率和渐近人群的理解不断发展，像这样的修改模型仍可能产生不准确的数字，但具有这种社会经济或细分市场的味道可以让我们更有意识地做出决策，同时了解各个细分市场的相对影响。这可以为更有针对性的干预提供信息

总的来说，当管理者在政治、社会和情感压力中挣扎的时候，他们不应该忘记一个好的决策只有一个定义特征，那就是它是有意识地做出的。

帽子提示:

1. https://timesofindia . India times . com/city/Delhi/Half-of-Delhis-population-lives-in-sludges/articleshow/16664224 . CMS
2. https://www . science direct . com/science/article/pii/s 0307904 x 11005191
3. https://www.ncbi.nlm.nih.gov/pmc/articles/PMC7190554/
4. https://science . the wire . in/the-sciences/basic-reproductive-ratio-value-India-estimate/
5. https://assets . 2030 vision . com/files/resources/2030 vision-full-report . pdf？416997c759
6. https://www . lewuathe . com/新冠肺炎-dynamics-with-sir-model . html
7. https://www.thehindu.com/coronavirus/

体验 ACL2020: 6 个新数据集和基准

原文：https://towardsdatascience.com/a-taste-of-acl2020-6-new-datasets-benchmarks-4f5584f3f0ba?source=collection_archive---------34-----------------------

计算语言学协会今年的会议挤满了 700 多份出版物。为了让你更容易地浏览，这里有一个新的刷新数据集和语言任务基准的论文选择。

周在 Unsplash 上的照片

数据集和基准是自然语言理解进展的核心(NLU) :在排行榜驱动的研究中，进展受到我们评估的质量的上限。虽然机器学习的数据集曾经持续很久——即 MNIST 在推出十多年后才达到人类的表现——但最新的自然语言理解基准变得过时的速度比我们预期的还要快，这凸显了找到更好的基准的重要性。

关于这个主题的论文数量之多令人震惊，因此在 Zeta-Alpha 上，我们精选了 ACL2020 上最有趣的作品，这些作品将影响如何衡量该领域的进展。

1。对抗性 NLI:自然语言理解的新基准

在这篇论文中——已经引起了+20 次引用——作者雄辩地说明了为什么静态 NLU 基准很快就过时了并且模型经常利用在数据收集阶段检测不到的虚假统计模式。

他们引入了自然语言推理的数据集(NLI)，其中给定了前提和本质，人们应该确定它们是必然的，矛盾的还是中性的。问题是，他们还引入了一个框架，根据来自训练模型的反馈对数据集进行迭代，并且人类在循环中引入了对立的例子；目的是在模型失败的地方创建数据集。如下图所示，注释的圆包括:

• 注释数据集并在其上训练模型。
• 让注释者在给定的上下文中编写新的对抗性假设，并在训练好的模型上测试它们。
• 如果模型成功，我们将新样本添加到训练集中。
• 当模型失败并且另一个人同意注释时，我们将他们添加到开发、测试或训练集中。

对抗性人在回路数据收集图。来源:对抗性的 NLI:自然语言理解的新基准

作者将这一过程称为 HAMLET ( 人和模型在回路中启用的培训)，在论文中，他们展示了 3 轮数据集的创建，其中注释者受到激励，提出模型将失败的假设。这导致的数据集越来越具有挑战性，并且作为副作用，他们在 MNLI 数据集的一些变体上达到了最先进的水平。虽然他们推测，由于其收集方式，该基准不会很快饱和，但他们强调，即使如此，仍可以增加新的回合来克服这一点。

动态数据集的主要不便之处在于标准化的困难，这使得不同作品的比较成为可能。虽然对抗性的人在回路中并不是一个新的想法，但这个干净的实例有可能成为未来迭代的灵感，并可能克服标准化的障碍，在不久的将来，动态数据集将成为规范。

2。橡皮擦:评估合理化 NLP 模型的基准

本文介绍了一个由 7 个任务组成的成熟的语言基准，这些任务不仅包括标签，而且受 GLUE 基准成功的启发，还有人类注释的“基本原理”。这些任务包括:证据推理、 BoolQ (布尔 QA)影评、发烧(事实提取验证) MultiRC (阅读理解)常识解释(CoS-E)E-SNLI(语言蕴涵)人情约定。

作者提出了一个精确-召回曲线度量下的区域，用于评估模型和人类注释推理的符合性，但是他们知道这种评估很难客观地进行，这就是为什么他们明确地呼吁在这个方向上进行更多的研究。

这个被提议的基准测试是迈向一个更具解释力的语言模型综合评估的宏伟愿景的第一步。

擦除基准中的任务示例。来源: ERASER:评估合理化 NLP 模型的基准

3。GoEmotions:一个细粒度情感的数据集

情感分析长期以来一直是 NLP 中的一项基本任务，但一些最广泛使用的数据集(如具有二元积极/消极情感的 SST2)正在超越人类表现，对于衡量有意义的进展来说已经过时。

GoEmotions 是一个数据集，由来自流行英语 subreddit 评论的 58k 个人工注释样本组成，它非常细粒度，有 27 个情感标签(或中性标签)。数据收集过程坚持高标准，进行全面的人工审查、长度过滤、情感平衡、子编辑平衡以及屏蔽专有名称和宗教术语。伯特模型的早期基线测试表明，还有很大的改进空间，当前最先进的 NLU 模型未能在这一程度上理解情绪，使其成为一个具有挑战性的新情绪基准。

GoEmotions 数据集的类统计数据，以及情绪相关性的热图及其对粗糙情绪(积极、消极和模糊)的聚类。来源: GoEmotions:一个细粒度情感的数据集

这种类型的数据集在这个时代非常有价值，可以帮助我们理解互联网上复杂的大规模社会动态。

类似地，也是在 ACL2020 上， iSarcasm:一个有意讽刺的数据集，是一个专注于有意讽刺和感知讽刺之间的区别的数据集，这样我们就可以克服当前模型只检测更明显形式的偏见。该数据集规模较小，只有 4.4k 个样本，也强调了该主题作为理解社交媒体背景下的社交互动的一种手段的重要性。

4。SCDE:含有高质量考试干扰项的句子完形填空数据集

句子完形填空任务包括从一组候选词中填充句子大小的空白。类似的句子级任务经常被用作语言模型预训练的自我监督(即 BERT 的下一句预测)；然而，这项任务通常过于简单，因为它可以依赖虚假的句子模式，因为自我监督的候选句子不够有挑战性。

在这项工作中，他们引入了干扰句，这是由英语教师设计的人类策划的句子，这些句子需要语言的非本地语篇层面才能成功完成任务。目前的模型只能达到 72%的准确率，而人类可以达到 87%左右，这表明还有相当大的改进空间。

5。死亡杀死了猫或者:BabelPic，一个非具体概念的多模态数据集

人类不会孤立地学习语言，那么我们应该期待机器会这样做吗？多模态机器学习探索了利用不同模式的数据，如视觉和语言，来制作更好的世界模型的想法。

“[……]语言理解系统应该能够对描绘隐退和悔恨的图像进行分类，而不仅仅是猫、狗和桥。”

在对大多数当前多模态视觉和语言数据集进行这种挑衅性的描述后，这项工作建立了关注非具体概念的数据集，作为扩大多模态语义理解覆盖范围的一步。该数据集是通过结合 WordNet 和 BabelNet 词汇知识库建立的。

巴贝皮克的非混凝土样本。来源:死亡杀死了猫或:BabelPic，一个非具体概念的多模态数据集

经过许多过滤技巧、试探法和手动验证后，最终的“黄金”数据集具有 2.7k 同义词集(同义词集)和 15k 匹配图像，以及由视觉语言模型通过使用 WordNet 中的自然语言定义生成的具有 10k 同义词集的扩展“白银”集。

6。R4C:评估 RC 系统的基准，以便为正确的原因获得正确的答案

同样，正如对抗性的 NLI 指出的，许多阅读理解任务依赖于现有数据集中的注释工件和其他偏见，使得任务的完成不需要任何理解。为了减轻这一点，井上直也等人。艾尔提出了一个任务，不仅要求在阅读理解任务中找到正确答案，而且还要求提供足够的支持事实**。**

包括基本原理的问答示例，其中示例来自 HotpotQA⁶.来源: R4C:一个评估 RC 系统的基准，为了正确的理由得到正确的答案 & HotpotQA⁴

得到的带注释的数据集是总共 7.1k 个训练样本和 6.6k 个开发样本，它们是从 HotpotQA⁴数据集采样的，其中每个答案的理由都包含在注释中。这项任务的评估包括对答案打分和评估“基本原理与地面事实的一致性”的正确性。

虽然这绝不是今年 ACL 中首次亮相的数据集和基准的全面列表**，但它是一个有代表性的样本，显示了会议是如何挤满了贡献。在 @zetavector 的团队将会关注会议，并从我们的 twitter feed 中报告见解，所以请不要错过任何事情！**

参考

1. 自然语言推理数据中的标注工件。Suchin Gururangan，Swabha Swayamdipta et。al 2017。
2. WordNet:一个英语词汇数据库。乔治·米勒 1995。
3. BabelNet:一个广覆盖多语言语义网络的自动构建、评估和应用。RobertoNavigli，Simone Paolo Ponzetto，2012 年。
4. HOTPOTQA:一个多样化的、可解释的多跳问答数据集。杨，彭琪，张赛正等。al 2018。

使用张量流数据集和张量板的张量流建模管道

原文：https://towardsdatascience.com/a-tensorflow-modeling-pipeline-using-tensorflow-datasets-and-tensorboard-2152bb7f1023?source=collection_archive---------41-----------------------

介绍

在完成由泰勒·埃利奥特·贝蒂荣(TEB)教授的名为面向开发人员的深度学习的高信息量 AICamp 在线课程时，我对为机器学习模型构建者(像我这样的学生)创建一种更结构化的方法产生了兴趣，以理解和评估各种模型，并观察它们在应用于新数据集时的表现。因为这个特殊的类关注 TensorFlow (TF ),所以我开始研究 TF 组件来构建一个工具集，使这种类型的建模评估更加有效。在这样做的过程中，我了解了两个非常有用的组件， TensorFlow 数据集 (TFDS)和 TensorBoard (TB)，这篇博文讨论了它们在这项任务中的应用。参见参考文献部分链接到 AICamp，TEB 和其他有用的资源，包括由 Neptune.ai 提供的全面的 TensorBoard 教程

目标

虽然术语“管道”在数据科学上下文中可能有多种含义，但我在这里使用它来表示一个建模管道或一组编程组件，它们可以从加载数据、应用预先确定的模型和记录性能结果中自动完成端到端建模。目标是建立大量的建模测试，并为每个测试自动运行管道。一旦模型经过训练，每个测试结果都可以很容易地与其他结果进行比较。总之，目标是为模型测试建立一个有效的、有组织的和系统的机制。

建模管道的逻辑流程

这种方法如图 1 所示。管道由三个步骤组成:

1. **数据:**加载并处理一个数据集，
2. **分析:**建立预定义模型并应用于该数据集，
3. **结果:**为每个数据集-模型测试捕获关键指标，以便以后进行系统的比较。

任何研究甚至涉足深度学习神经网络的分析师可能都经历过看似无限的建模选择。任何数量的许多层类型，每种类型都有许多配置选项，可以相互连接，一旦堆叠，就可以使用多个优化例程和许多超参数来训练模型。还有数据的问题，因为可能需要将有前途的模型应用于新的数据集，以观察它们在看不见的数据上的性能，或者为进一步的模型迭代获得基础。

对于这个应用程序，我专门处理图像分类数据和模型。TFDS 包括音频、图像、对象检测、结构化、摘要、文本、翻译和视频数据，深度学习模型可以专门针对这些问题构建。虽然这里展示的现成代码需要一些修改和测试才能应用到其他集合，但是它的基本框架仍然是有帮助的。

张量流

本文中的代码总结在表 1 中，基于 TensorFlow 2.0(2019 年 9 月发布的产品)和两个组件 tensor flow 数据集和 TensorBoard。Keras 是一个与 TensorFlow 交互的高级 API，现在与 TF 2.x 深度集成，这里使用的许多工具都依赖于 Keras 组件。

建模管道中使用的关键 TensorFlow 组件

编码

事实证明，构建预期的建模管道需要相当多的编码。虽然可以更简单地部署这些 TF 模块的简单或直接的应用程序，但是在健壮的管道中使用它们需要一些定制的包装和实现组件来编排它们的使用，在该管道中数据和模型都被期望以编程方式改变。我把我的代码放在一个共享的 Google Colab 笔记本 (TF_Modeling_Pipeline)中，所有人都可以访问。然而，我应该注意到，我使用 Colab Pro(一种订阅服务)，并在 GPU 设备上运行该笔记本。

虽然这个笔记本包含了很多代码，但我试图干净地组织和完整地记录这些工作，使其更易于浏览。此外，我在整个文档中添加了大量参考链接，以识别来源并提供对更多信息的快速访问。

调用 TensorFlow、TensorFlow 数据集和 TensorBoard 模块的关键自定义包装器

如前所述，这里的目标是构建一个自动化的管道。考虑到这个目标，我使用了几个定制的包装器来处理数据加载和处理、模型构建和训练以及结果记录过程。这些在图 2 中描述，并在表 2 中讨论。

调用 TensorFlow、TensorFlow 数据集和 TensorBoard 模块的关键自定义包装器

试验

为了演示这个管道，我设置了以下测试，其中数据集名称可以在 TFDS 目录中找到。

测试配置，检查应用于两个数据集的两个模型

回顾建立这些演示测试的思维过程，举例说明了这种管道方法的好处。在将 Tyler Bettilyon 的类和 TF 示例模型(TBConvTest)应用于 MNIST 数据集并发现良好结果后，我想看看它在彩色图像数据集上的性能。我最终选择了疟疾数据。正如你从 TFDS 目录链接或数据集信息类中看到的，TFDS 数据集带有参考资料。

事实证明，这些材料非常有价值，因为 TBConvTest 模型在疟疾数据集上的早期测试结果不佳。这让我想到了 Sivaramakrishnan Rajaraman 等人的工作以及这篇论文和 GitHub 资源库。在那里，我能够找到关于他们对这些疟疾图像数据进行分类的方法的有用资源，vgg 16 测试模型相当于他们的一个模型。

数据

图 3 和图 4 中的训练数据图像示例保存在日志中，可以通过 TB 的图像特性获得(参见建模管道代码中的步骤 5)。

MNIST 图像示例

疟疾图像示例

模型

图 5 和图 6 中的模型图是由 TB 回调创建的，并且在 TB 的 graphs 特性中可用(参见建模管道代码中的步骤 7)。

TBConvTest 模型

vgg 16 测试型号

结果

这些测试的所有结果都存储在 TensorBoard 中，可以通过运行 TF_Modeling_Pipeline Colab 笔记本重新创建。作为概述，图 7 中的屏幕截图显示了 TB 仪表板。如您所见，有几个功能，其中一些我们已经讨论过，可以通过标题菜单访问。在这幅图中，我们正在查看标量下每个建模测试的关键准确性指标。

TB 仪表板和标量显示每次测试的预测准确性

从注释(我添加的)中，我们可以快速比较模型并进行一些观察。首先，test_1 和 test_2 之间明显的性能差异清楚地表明，TBConvTest 模型没有扩展到疟疾数据集。由于疟疾测试是一个二元分类，50%的准确率并不比猜测更好，并且该模型没有提供解释能力。其次，通过在疟疾数据集(test_3)上使用 VGG16Test 模型，我们可以看到增量改进。第三，通过查看每个时期(x 轴)的准确率，我们可以快速了解所有模型随着训练的改进。考虑到 Rajaraman 等人训练了至少 100 个时期，检查 test_3 的缓慢精度增长率并想知道额外训练的益处如何或何时显现是有趣的。

查看我们定制的指标“混淆矩阵”也很有帮助。假设我们的 TB 配置(参见建模管道代码中的步骤 7)在 IMAGES 选项卡中可用。该视图是在 10 个时期之后，但是顶部滑块允许用户浏览每个时期之后的混淆矩阵变化。从这个归一化矩阵中，我们注意到未感染类的准确率为 80%,而被感染类的准确率仅为 57%,这可以提供对其他模型变化和该模型的适当使用的洞察。

10 个时期后测试 3 的混淆矩阵

结论

建立一个半自动的、有组织的和有方法的管道来测试机器学习模型，并在多个数据集上验证它们的性能，这对建模者来说是一个有用的工具。TensorFlow 数据集和 TensorBoard 是 TensorFlow 2.x 开发套件中的两个组件，可提供大量管道功能，并可作为此类 TensorFlow 管道的基础。然而，为了实现自动化的好处，它们应该被包装在定制的编程组件中，这些组件提供有效构建深度学习模型所需的效率和可见性。

参考

• 如果你想了解更多关于 AICamp 或深度学习课程导师泰勒·埃利奥特·贝蒂莱恩(TEB)的信息，请访问他们这里: AICamp 和 Teb 的实验室。
• 关于全面的冲浪板教程，请看 Neptune.ai 的深潜。

博客

• 在 TensorFlow 1 & 2 中使用 TensorBoard 的基础知识:塞巴斯蒂安·蒂勒非常有用的总结
• 面向专家的 TensorFlow 2 快速入门
• 如何从头开始创建 TensorFlow 2 模型——一个“无用”的例子
• 如何使用 Keras 的 TensorBoard】
• tf。为 Keras 用户解释的 GradientTape】
• 如何在 TensorFlow 中使用数据集和迭代器
• 用 TensorFlow 2 迁移学习

张量流

• TensorFlow 2.x
• Keras
• tf.data.Dataset
• 张量流数据集
• 张量板

管道代码

物体探测效率的彻底崩溃

原文：https://towardsdatascience.com/a-thorough-breakdown-of-efficientdet-for-object-detection-dc6a15788b73?source=collection_archive---------8-----------------------

在这篇文章中，我们深入探讨了用于物体检测的 EfficientDet 的结构，重点是模型的动机、设计和架构。我们还在博客上发布了 物体探测效率分析 。

最近，Google Brain 团队发布了他们的 EfficientDet 对象检测模型目标是将架构决策具体化为一个可扩展的框架，该框架可以轻松应用于对象检测的其他用例。该论文的结论是 EfficientDet 在基准数据集上的表现优于类似规模的模型。在 Roboflow，我们发现基本的 EfficientDet 模型可以推广到托管在我们平台上的自定义数据集。(关于实现 EfficientDet 的深入教程，请参见这篇关于如何训练 EfficientDet 的博文和这篇关于如何训练 EfficientDet 的 Colab 笔记本。)

在这篇博客文章中，我们探讨了在形成最终 EfficientDet 模型时所做决策背后的基本原理，EfficientDet 如何工作，以及 EfficientDet 与 YOLOv3、fast R-CNN 和 MobileNet 等流行的对象检测模型相比如何。约洛夫 4 的说明和约洛夫 5 的>的说明

探索激发 EfficientDet 创作的理论基础。图片来源和引用论文

The founder of Mosaic Augmentation, Glen Jocher has released a new YOLO training framework titled YOLOv5\. You may also want to see our post on [YOLOv5 vs YOLOv4](https://blog.roboflow.ai/yolov5-improvements-and-evaluation/) This post will explain some of the pros of the new YOLOv5 framework, and help illuminate breakthroughs that have happened since the EfficientDet publication.[YOLOv5 Breakdown](https://blog.roboflow.ai/yolov5-improvements-and-evaluation/)

深度学习效率面临的挑战

在探索该模型之前，这里有一些阻碍图像检测系统部署到现实生活用例中的关键领域。

1. 数据收集 —借助模型架构和预训练检查点，EfficientDet 减少了推广到新领域所需的数据量。
2. 模型设计和超参数化 —一旦收集了数据，机器学习工程师需要仔细设置模型设计并调整许多超参数。
3. 训练时间 —在收集的数据集上训练模型所需的时间。在 EfficientDet 论文中，这是以 FLOPS(每秒浮点运算次数)来衡量的。
4. 内存占用 —一旦模型被训练，当被调用进行推理时，需要多少内存来存储模型权重？
5. 推理时间 —当模型被调用时，它能足够快地执行预测以用于生产设置吗？

图像特征和 CNN

训练对象检测模型的第一步是将图像的像素转换成可以通过神经网络输入的特征。通过使用卷积神经网络从图像中创建可学习的特征，计算机视觉领域取得了重大进展。卷积神经网络以不同的粒度级别混合和汇集图像特征，允许模型在学习手头的图像检测任务时选择可能的组合。然而，一段时间以来，卷积神经网络(ConvNet)创建特征的确切方式一直是研究社区感兴趣的领域。ConvNet 版本包括 ResNet、NASNet、YoloV3、Inception、DenseNet 等，每一个版本都试图通过缩放 ConvNet 模型大小和调整 ConvNet 设计来提高图像检测性能。这些 ConvNet 模型是以可扩展的方式提供的，因此如果资源允许，程序员可以部署更大的模型来提高性能。

效率网:动机和设计

最近，谷歌大脑团队发布了他们自己的 ConvNet 模型，名为 EfficientNet。 EfficientNet 构成了 EfficientDet 架构的主干，因此在继续介绍 EfficientDet 的贡献之前，我们将介绍它的设计。EfficientNet 着手研究 ConvNet 架构的扩展过程。有很多方法——事实证明💭-您可以向 ConvNet 添加更多参数。

引用论文

你可以使每一层更宽，你可以使层数更深，你可以以更高的分辨率输入图像，或者你可以将这些改进结合起来。你可以想象，对机器学习研究人员来说，探索所有这些可能性可能会非常乏味。EfficientNet 开始定义一个自动程序来扩展 ConvNet 模型架构。本文试图在给定深度、宽度和分辨率的自由范围内优化下游性能，同时保持在目标存储器和目标触发器的限制范围内。他们发现，他们的扩展方法改进了以前的 ConvNets 的优化及其高效的网络架构。

高效网络、扩展和评估

创建一种新的模型缩放技术是向前迈出的一大步，作者通过创建一种新的 ConvNet 架构将他们的发现向前推进了一步，从而将他们的最新成果推向了更高的水平。通过神经结构搜索发现新的模型结构。在给定一定数量的 FLOPS 的情况下，神经架构搜索可优化精度，并创建一个名为 EfficientNet-B0 的基线 ConvNet。使用扩展搜索，EfficientNet-B0 将扩展到 EfficientNet-B1。从 EfficientNet-B0 到 EfficientNet-B1 的缩放功能被保存并应用于通过 EfficientNet-B7 的后续缩放，因为额外的搜索变得极其昂贵。

新的高效网络系列在 ImageNet 排行榜上进行评估，这是一项图像分类任务。注意:自从 EfficientNet 最初发布以来，已经有了一些改进，包括从优化分辨率差异以及将 EfficientNet 部署为教师和学生。

引用论文

相当甜蜜！EfficientNet 看起来是一个很好的基础。它可以有效地随模型大小扩展，性能优于其他 ConvNet 主干网。

到目前为止，我们已经介绍了 EfficientDet 网络的以下部分:

引用论文

引入效率检测

现在，我们将讨论 EfficientDet 的贡献，它试图回答以下问题:我们应该如何准确地将 ConvNets 的功能结合起来用于对象检测？一旦我们开发了这个组合过程，我们应该如何扩展我们模型的架构呢？

特征融合

特征融合寻求组合给定图像在不同分辨率下的表示。通常，融合使用 ConvNet 的最后几个要素图层，但确切的神经架构可能会有所不同。

引用论文

在上图中，FPN 是一种自上而下融合要素的基本方法。PA net 允许特征融合从较小的分辨率到较大的分辨率来回流动。NAS-FPN 是一种通过神经架构搜索发现的特征融合技术，它看起来肯定不像人们可能想到的第一个设计。EfficientDet 论文使用“直觉”(可能还有许多许多开发集)来编辑 NAS-FPN 的结构，以确定双向功能金字塔网络 BiFPN。EfficientDet 模型将这些 BiFPN 块堆叠在一起。在模型缩放过程中，块的数量是不同的。此外，作者假设某些特征和特征通道对最终预测的贡献可能不同，因此他们在通道的开头添加了一组可学习的权重。

效率检测模型缩放

先前关于图像检测的模型缩放的工作通常独立地缩放网络的部分。例如，ResNet 仅扩展主干网络的规模。但是还没有探索联合标度函数。这种方法非常类似于为创建 EfficientNet 而进行的联合扩展工作。

作者设置了一个缩放问题来改变主干网络、BiFPN 网络、类/箱网络和输入分辨率的大小。主干网络通过 EfficientNet-B0 到 EfficientNet-B6 的预训练检查点直接扩展。BiFPN 网络的宽度和深度随着 BiFPN 堆叠的数量而变化。

EfficientDet 模型评估和讨论

EfficientDet 模型在 COCO(上下文中的公共对象)数据集上进行评估，该数据集包含大约 170 个图像类和跨越 100，000 个图像的注释。COCO 被认为是对象检测的通用挑战。如果模型在这个一般领域表现良好，它很可能在更具体的任务上表现得很好。在许多约束条件下，EfficientDet 优于以前的对象检测模型。下面，我们来看看该模型的性能与 FLOPS 的关系。

引用论文

在这里，我们可以看到，在类似的约束条件下，该模型相对于其他模型族表现得相当好。作者还对 Pascal VOC 上的语义切分模型进行了评估。他们发现他们在那里也达到了艺术水平。嘿，为什么不呢？

简单来说，EfficientDet 为什么有用？

从实现细节上退一步，想想 EfficientDet 的开源检查点对计算机视觉工程师来说意味着什么是相当不可思议的。efficient net 的预训练检查点结晶了所有的发现和谷歌大脑的研究人员在建立一个 ConvNet 时放置的自动化，以及ImageNet 上的图像分类可以提供的所有监督。功能融合进一步利用了 EfficientNet 检查点**，并且架构的所有组件都得到了有效扩展**。最后，这些模型权重在 COCO 上进行预训练，COCO 是一个通用的图像检测数据集。作为一个用户，除了提供模型的数据类型之外，没有什么决策需要考虑。

很好的分解——我如何使用 EfficientDet？

在 Roboflow 上，我们已经在这篇关于如何训练 EfficientDet 的博文和这本关于如何训练 EfficientDet 的 Colab 笔记本上提供了一个教程。通过 Roboflow，您可以输入带有注释的数据集，只需将新的数据下载链接输入到我们的示例中，就可以得到一些结果。然后，在训练之后，笔记本将训练好的重量导出，以便部署到应用程序中！

使用我们的 Colab 笔记本中的 efficientDet 进行推理

Roboflow 是免费使用的，您可以托管和转换多达 1000 张图像。保持联系！

如果您对 EfficientDet 有一些很棒的成果，并想与我们分享，请给我们写信🎣！

一千个小玩意:我对 R Tidyverse 的看法

原文：https://towardsdatascience.com/a-thousand-gadgets-my-thoughts-on-the-r-tidyverse-2441d8504433?source=collection_archive---------13-----------------------

照片由马可·韦尔奇， CC 2.0

现在有一种 R 的主要方言，被大声宣扬，而且显然方兴未艾:Tidyverse，由 RStudio 颁布，主要是一个人 Hadley Wickham 的努力。我们应该采用它吗？学生该不该学？有 R 方言是个好主意吗？

作为一个在学术和专业领域广泛使用 R 的人——从科学研究和模拟建模到定制可视化和预测建模——我对此有一些强烈的看法，并且现在教一门 R 课程。

大体上，我对这种“整洁”的时尚持怀疑态度:它不适合我。

我不是没有同情心

很容易同情 tidyverse 最初的动力和动机:让 R 变得更容易，特别是对于非程序员。

Base R 并不容易:它是一种语言的混血儿，有许多不一致之处，是在“数据科学”成为职业之前设计的。在过去糟糕的日子里，我的许多 R 工作既痛苦又乏味，从将数据帧拼成不同的形状，到在它们之上连接和聚合。通常更容易的方法是将数据放入本地 SQL 数据库，对其进行处理，然后将其传输回 R. Ugh。我也看到很多人非常努力地学习 R，尤其是当他们是编程新手的时候——尽管 R 的核心市场是科学家和统计学家，而不是专业程序员。

所以这很糟糕，我们需要有所改变。

但是让我们客观地看待这些困难。任何人的第一门编程语言都会很难，尤其是当他们试图同时探索机器学习的时候——让一只乌龟在屏幕上移动可能天生就更容易。在研究生院，学习的人经常被强迫学习，而不是因为他们决定对编程本身感兴趣。让我们也考虑一下，仅仅因为我们需要某些东西去改变，并不意味着 R 的新方言是唯一的答案；事实上，它仍然不是(见下文)。

批评零分

这是我对 tidyverse 的第一次不好的感觉。这是一次翻拍 R 的尝试，基本上是按照哈德利·韦翰的形象。我的意思是，以一种对一个人有意义的方式完全改变 R 的界面。现在我被告知哈德利是一个非常好的人，相当谦虚，但我们不能忽视这个目标中的傲慢。为什么要由一个人来决定我们的编码风格，尤其是在开源语言中，不管他的意图有多好？也很难不把这看作是 RStudio 对整个 R 生态系统的土地掠夺——都是为了他们的利益。

现在，我是一个多疑的人，怀疑人群和狂热者——tidyverse 似乎有很多这样的人——所以你可以半信半疑地接受这第零个批评:它根本没有提到 tidy verse 的有用性,或者它的单个包装的有用性。所以我们继续吧。

批评一

比喻:你(数据科学家)是一个有抱负的厨师，试图将原料变成食物。tidyverse 试图让烹饪变得更简单，给你一个拥有三到四个 T2 千件 T3 小器具的厨房。每个小工具只做一件事，而且非常容易使用——基本上不需要什么技能。

开始做汤时，你把胡萝卜放进洗菜机；然后你把它们移到剥皮机上；然后进入去头机；然后放进切丝机。最后，你的胡萝卜就可以放进锅里了。可能也有一个该死的机器。如果你想要一个不同的切法，比如说，或者磨碎胡萝卜，你会使用完全不同的小工具。

换句话说，tidyverse 中的每一步都很简单，但是有很多步骤——也就是说，有很多功能。您必须了解每一种方法的作用、名称、参数、假设和局限性。从审美的角度来看，我讨厌这种方式。我喜欢紧凑、简洁的语法，无论我去哪里都一样。我喜欢简单、概括的解决方案——用概括的工具——而不是巴洛克式的解决方案；不管它们有多容易使用。

批评二

不过，这不仅仅是个人编码偏好的问题。tidyverse 似乎被设计成允许非程序员在根本没有学习过编程的情况下用 R 将命令串在一起。您可以过滤()和变异()数据帧，而无需学习如何索引数组；而无需部署环路；无需编写匿名函数。人们很容易编写冗长、杂乱的代码脚本，将一千个众多的函数链接在一起，却丝毫不知道它们内部到底发生了什么。

公平地说，早在 tidyverse 之前，我们就有科学家程序员的意大利面条式代码了。我没有资格说 tidyverse 在这方面真的有帮助还是有伤害。但是，当我们避免用编程语言编程时，当我们试图简化操作，因此不需要理解 R 时，我很怀疑。毕竟，这是 R 存在和我们使用它的原因:我们从实际编写代码中获得灵活性和能力。如果我们需要的是一些重塑工具的最简单的接口，也许 R 不是合适的平台？毕竟，他们为此制作图形用户界面。

批评三

我讨厌管子。它们在 unix 命令行中有意义，但在 R 中没有意义——尤其是对于难看的%>%符号。当我浏览一个函数时，我想知道有什么数据被传入其中——而不仅仅是有什么东西传入。我希望对象的名字和它们的参数是显式的，这样我就不必每次浏览时都要重新记住整个步骤序列。

让我们记住，代码是为人类编写的:编写长序列的命令是忘记正在发生的事情和犯错误的秘诀。这也是调试困难的原因，因为中间步骤是隐藏的，并且没有命名。

您真正需要知道的是，在包开发中不推荐使用管道。

但是我们能做什么呢？

如果这些问题是不采用 tidyverse 的好理由，那么应该做些什么呢？我在开头说过 tidyverse 解决了一些令人难以置信的恼人问题，这些问题需要解决。的确如此。但是这并不是采用整个 she bang——或者随之而来的编码风格的理由。例如，我使用 stringr，它是“韵文”的一个成员，对此我并不觉得有什么不好。但是我越是怀疑我的基本方法论。因此，让我们抛开管道和“tibbles”，以及我们需要一千个小函数而不是用我们选择的语言的构建模块自己编程的感觉。

对于数据帧的争论，我们在数据表中有一个非常明确的替代方案。它的功能和样式是对 base R 中括号符号的适度扩展，对于 SQL 用户来说也是高度合乎逻辑的。它也有其奇怪之处，可能更像是一个高级特性——但这样更好:先学习 base R，准备好了再学习 data.table。Data.table 不会试图降低 R，也不会试图避免编码。它给了你一把价值 1000 美元的厨师刀，而不是满厨房的小玩意，并希望你好好使用它——以免你切掉自己的指尖。

这只是风格的问题吗？是的。但是风格很重要。你可以从你的代码中删除所有的空白，这就是“风格”，但是没有人会感谢你的决定。代码也不仅仅是给人们看的，它也是给人们写的时候用来推理的。你的代码风格告诉我们你是如何思考的；它也会限制你的思维:如果你的整个世界是一系列管道和黑盒(tidverse 方式),那么有很多问题你无法解决——或者只能通过脆弱的 Rube Goldberg 装置来解决。

学习索引。学习控制结构。学习这门语言的基础知识，并用它来编写自己的工具。这就是你开始编程的原因，不是吗？

所以，放下螺旋器，拿起你的削皮刀，开始练习吧。

Jasper McChesney 是一名高级数据分析师，拥有自然科学和数据可视化方面的背景。他曾在非营利组织、人力资源和高等教育部门工作过。他目前在麻省大学教授 R 课程，在 Udemy 上: 所以你需要学习 R 。

基于不平衡 Twitter 数据集的 SVM 三级情感分类

原文：https://towardsdatascience.com/a-three-level-sentiment-classification-task-using-svm-with-an-imbalanced-twitter-dataset-ab88dcd1fb13?source=collection_archive---------33-----------------------

从现场反应推文到 2016 年第一次电视直播的共和党辩论，中国人正在学习情绪分类

由在 Unsplash 上高清拍摄的历史

作为一名新闻迷，我喜欢看到政治如何在社交媒体上获得如此情绪化的回应，并想知道这种轶事般的激情感是否可以转化为机器学习分类。我发现了一个针对 2016 年第一次共和党总统辩论的推文数据集( h ere )，并希望创建一个三级情感分类器，可以从推文文本中解释情感。这篇文章是我整理的一套方法和技术的一部分，现在我将只关注一个方面；不起眼的支持向量机。作为次要任务，我注意到数据集严重不平衡，所以想尝试对少数类进行增采样，以提高分类器在所有标签中的有用性(这有望帮助分类器在所有类别中得到改进)。

数据探索和清理

谁能想到 Twitter 如此负面？作者图片

从数据集细分的原始数据中，我们立即看到了推文传播的问题。负面推文很普遍，是中性和正面推文总和的两倍多。这可能会对分类器在实践中的表现产生影响。(最有可能的是，如果像这样训练，分类器会很好地理解负面推文，但不会有太多识别其他任何东西的练习！)

“清理”数据的第一步是将所有字母转换成小写，然后从推文中删除标点符号、数字、网址和用户名。

使用“NLTK”停用词语料库从推文中删除停用词，并从推文中提取空白，每个词都被标记化，以便表示被视为停用词的单独数据块。

重复的推文随后被删除。在其他预处理步骤之后，我们决定删除重复的内容，因为 Twitter 的本质是由“转发”组成的，回复其他用户或评论的用户名可能会有完全相同的内容。这剩下总共 9836 条独特的推文准备分类。阴性:5692，中性:2521，阳性:1623。数据集被分成 80%用于训练，20%用于测试

矢量化— TF/IDF

出于对文本进行大多数数学建模的目的，以及出于该实验的目的，实施了不同的“矢量化”过程。

文本内容在没有被转换成数字以供机器学习算法读取的情况下，不能单独被改变和强制到数学空间中。

这就是为什么在本项目中，出于监督方法的目的，使用不同类型的矢量化将定性数据转换为定量数据，以便进行数学处理。这些向量成为模型的嵌入特征。

术语频率/逆文档频率(TF/IDF)

这是用于支持向量机模型的矢量化技术。TF/IDF 在训练数据上使用了一种单字方法，该方法将每个单词作为一个术语。“术语频率”是指某个单词在文本中出现的频率，“逆文档频率”是指降低在所有文本中出现频率最高的单词的重要性。

这用于产生在给定文档中频繁出现但不一定在所有文档中出现的单词。

数据平衡和采样技术

随机过采样、合成少数过采样和真实世界不平衡方法形式的数据平衡都被利用和比较。

采样技术

考虑数据平衡问题和协议是至关重要的，因为每一项行动都应减少偏差和提高真实性能，但也要尝试和减少过度拟合，并对模型的潜力有更细致的表示。考虑上采样技术很重要，因为它可以使模型更容易地勾勒出其决策边界。决定不使用欠采样技术，因为在这种情况下，由于数据集最初非常小，并且由于预处理措施和训练分割而进一步减少，所以感觉这对于提高性能没有什么作用。

没有采样

班级可能会不平衡，因为模型正在接受训练，以准确了解推文在现实生活中的表现。如果认为模型在之前没有进行上采样的情况下可能表现不佳，那就太天真了。如果给定领域中的数据天生严重不平衡，那么对不平衡数据的训练可以产生最佳输出。

随机过采样

随机过采样是从两个少数类中提取重复样本并将其添加到训练集中的过程。样本是从训练集中的少数类中随机选择的，然后被复制并添加到训练集中，在那里它们有可能被再次选择。

因为重复是精确的，并且重复的例子有可能出现多次，所以存在用这种方法过度拟合少数类的风险，并且对于实现这种技术的模型来说，数据的一般化增加了。

为了这个实验的目的，少数类都被上采样到与多数负类相同的值，因此在应用上采样之后，每个类有 5，692 个样本。

合成少数过采样技术 SMOTE

研究人员；舒拉、鲍耶、霍尔和凯格尔迈尔在他们的论文中创建了这种上采样技术，该论文以题为“SMOTE:合成少数过采样技术”的技术命名( 看这里！

SMOTE 是另一种有用的上采样方法。与从少数类创建数据点的精确副本的随机过采样相反，SMOTE 使用一种类型的数据扩充来“合成”全新且独特的示例。通过在特征空间中选择彼此接近的实例，并在这些实例之间创建边界，以及在沿着该边界的某个点创建新样本，来实现 SMOTE。这种方法往往是有效的，因为新的合成推文更接近特征空间中的其他示例，因此它们的极性可能比随机上采样的示例更接近，并且因为它们与随机过采样中的示例不完全相同，所以过拟合的可能性降低了。

估价

实验评估指标各不相同，通常取决于所执行任务的性质。一些常用于分析程序分析的评估指标包括但不限于:准确度、精确度、召回率、均方误差、损失函数分析、曲线下面积、F1 分数。不同领域中的不同模型将导致每个指标的不同结果，必须确定合适的模型，并且必须满足必要的评估标准。

精度

准确性是分类任务中最常测量的评估度量之一，并且最常被定义为正确分类的标签的数量与总预测数量的比例。

F1-得分

“F1 分数”、“F 分数”或“F 度量”是用于评估基于自然语言的任务的常见度量。它通常被认为是“精确度和召回率的调和平均值”，或者传达了精确度和召回率之间的平衡。

F-Measure 表达了精确度和召回率之间的平衡。由于准确性仅给出了模型正确结果的百分比，但并未显示出模型在寻找真正的正面结果方面的熟练程度，因此根据需要，这两种方法都有优点。

接收机工作特性(ROC)

ROC 是显示分类模型在其真阳性率(TPR)和假阳性率(FPR)方面的性能的图表。TPR 定义为模型输出的真阳性总数除以真阳性数加上假阴性总数。

曲线下面积(AUC)

AUC 统计是 ROC 曲线下的维度空间的度量。该图给出了所有潜在分类阈值的模型性能的综合得分。
对此的一种解释是，该模型将一个正的随机例子置于比一个随机负的例子更高的位置。AUC 总是介于 0 和 1 之间的数字。

ROC 度量是有用的，因为它对数据中的先验类别概率或类别流行度以及 AUC 具有不变性。这对于这项研究很重要，因为这些阶层是严重不平等的。负面类别的大量存在表明模型随机正确分类正面推文的概率增加了。

结果

以下是从支持向量机获得的结果，该支持向量机利用各种过采样技术对少数类训练有词频率/逆文档频率向量。

下图显示了根据不平衡训练数据训练的支持向量机模型的结果。此处模型的总体准确率为 60%，但从这种方法的精确度、召回率和 f1 分数来看，我们可以看到该模型在对较小的类别进行分类时表现不佳。该模型理解负类，但未能从较小的类学到很多，这从中性类和正类相当低的 18%和 19%的“f1”中可以清楚地看出。

作者图片

从下面显示的 ROC 曲线和 AUC 中，我们看到了模型性能的更全面的观点。除了中性组的 AUC 比其他组低 1%之外，所有三组的真实阳性率几乎相同。即使该模型具有 60%真阳性率的总体准确度，该模型的总体分类能力也不是特别明显。

从所示的混淆矩阵中，我们看到了 SVM 模型的实际预测值。该模型清楚地显示了其在对负面类别进行分类时的最佳性能。

这个班有 1086 个正确的预测。然而，我们只看到 37 个负类的正确预测，比这里正确预测的 10%略少。中性类有 55 个正确的预测，比这里的负类略有改进。有趣的是，这个模型错误地将一条推文标记为负面的情况比其他任何类别都多。显示了该模型如何严重依赖于负面类别来影响其决策。

作者图片

作者图片

支持向量机 TF/IDF 随机过采样类

下面显示的分类报告显示了应用随机过采样技术对少数类进行上采样时 SVM TF/IDF 模型的结果。值得注意的是，这种方法的总体准确性与具有不平衡类别的相同方法没有不同，但是模型在正确分类较小类别方面的性能确实略有提高，如负面类别上改进的 f1 分数所示。

作者图片

下图显示了采用随机过采样的 SVM 模型的 ROC 曲线和 AUC 图。该模型在所有类别中的真实阳性率在所有类别中至少提高了 4%。该模型不仅通过增加少数民族类别的样本来改进其对否定类别的分类，而且该模型在所有类别中都有相当大的改进。该模型仍然最擅长发现负类，但是当呈现更多样化的训练示例时，它也没有丢失任何这种知识。

作者图片

下图显示了 SVM ROS 模型的混淆矩阵。值得注意的是，当与不平衡数据集相比时，分类器在正确分类负面类别方面稍差(分别为 1086 对 977)，但其正确分类正面类别的能力几乎加倍(37 对 70)。中性类的正确预测数量显著增加(从 55 到 140)。还需要指出的是，错误分类的负面例子的总数显著减少。

作者图片

支持向量机 TF/IDF SMOTE

下图显示了应用 SMOTE 上采样技术的 SVM-TF/IDF 的分类报告。该模型的总体准确性保持在 60%的静态水平，但是，与不平衡方法而不是随机向上采样方法相比，我们确实看到两个少数类的 f1 得分有所提高。

作者图片

下图显示了 SMOTE SVM 的 ROC 曲线和 AUC 数。通过比较下面的两个图表和指标可以清楚地看出，与 ROS 方法相比，真正的正数明显下降。当与不平衡方法相比时，这种方法仅略微有所改进。当与没有上采样相比时，负类的分类具有 2%的改进，并且通常该模型对任何类的分类能力降低 1%到 2%。

作者图片

最后，下图显示了带 SMOTE 的 SVM 的混淆矩阵。负面类别仍然是分类器正确识别的标签，但有趣的是，当使用这种技术时，中性类别的正确预测与 ROS 相比下降了几乎一半(72 对 140)。与 ROS 相比，这里的分类器使用这种技术也将推文错误分类为负面的。在这种情况下，分类器严重依赖于否定类标签，而不是使它做出的预测范围多样化。同样值得注意的是，这个模型不仅比 ROS 模型对阳性类别的错误分类更多，而且对这个标签的总预测也少得多。

作者图片

评估和结论

当在不平衡的训练数据上训练时，支持向量机发现很难做出正确的分类。不使用参数调整技术和简单的线性方法也可能导致问题。

SVM 对不平衡的数据很敏感，对自然平衡的类工作得最好。这可能导致性能下降。这也解释了为什么不平衡的实验产生了不太有用的结果。

就一般意义上的总体精度而言，所有三种上采样技术给出了相同的精度度量，但是直观上清楚的是，最好的性能始终是标记负类。

参考分类器的“F1-Measure ”,随机上采样模型给出了最好的结果。但是，必须记住，随机过采样数据会精确地重新创建实例，这有可能导致过度拟合。

在 GitHub repo 这里 上可以找到 Jupyter 笔记本以及伴随该报告的所有 python 代码！😃

爱尔兰都柏林自由数据科学家艾伦·科因撰写的报告和代码

让你的老板了解人工智能的三步秘诀

原文：https://towardsdatascience.com/a-three-step-recipe-for-educating-your-boss-about-ai-3f21eec33b7f?source=collection_archive---------63-----------------------

你的经理认为人工智能只是一台输入数据并自动产生输出的机器吗？你的任务是让人工智能在你的组织中发挥作用吗？那么这篇文章是给你的。

林赛·亨伍德在 Unsplash 上的照片

我不得不对你说实话，你最好长期做好你的工作。希望你对自己工作的公司充满热情，对 AI 感到兴奋。如果你真的想投资，那么这里有一个三步秘诀，让你的老板了解你，让你的生活更轻松。

我在之前写过关于许多公司在采用人工智能时面临的问题。我谈到的一个关键方面是人工智能素养。对我来说，人工智能素养是对人工智能是什么的理解和如何在组织中成功采用人工智能的结合。让我们诚实地面对自己，我们可能还没有达到最大程度。

没有什么比在一个期望不切实际的环境中工作更令人沮丧的了，在这样一个环境中，没有完成工作所需的资源，你不得不面对会议上和顾问们精心编造的故事。

不幸的是，改变人们的想法不会在一夜之间发生。没有一个演示能让你的老板明白其中的诀窍。你需要带着他踏上你自己的旅程。循序渐进。

第一步

帮助他们理解什么是人工智能

你的老板可能正处于一种尴尬的境地，他问你人工智能到底是什么已经太晚了。或者他只是没有时间讨论这个话题，或者还不知道他们的定义可能不正确。

那么你如何帮助他们理解呢？在你的会议中，你可以提到这样一个事实，即许多人有不同的理解，你也听说过在其他公司他们对人工智能的定义。你也想这么做。定义人工智能的含义，并让主题返回几次。给他们提供其他公司 AI 解决方案的例子。

当他们开始向别人解释这个定义时，你就知道是时候进行下一步了。

第二步

帮助他们发现人工智能在您的组织中有哪些不同的可能性

你有可能被赋予这项任务，因为如今每个公司都在“做人工智能”。现在你已经有了明确的定义，指导你的老板找到正确的用例就容易多了。教育他们如何识别可能性(提示:在那里做出许多决策，并提供大量数据)。他们需要开始看到可能性。一旦他们这样做了，就会产生你在项目中工作所需要的“拉力”。这是进入第三步的信号。

第三步

帮助他们了解如何让你的第一个项目取得成功

你可能知道将你的第一个项目投入生产是很困难的，有太多的事情需要你从技术上去发现。然后，我们甚至还没有触及采用人工智能解决方案所需的文化变革。

可能有不同的方法。我喜欢用特斯拉做例子。在跑车出现之前，没有工厂，他们必须建造工厂。在他们能够适应其他车型之前，他们需要学习如何制造汽车。他们从向一小群客户销售少量汽车开始，并可以在过程中学习。现在，Model 3 已经为更多的用户做好了准备。

如前所述，人不会一夜之间改变，也不会一夜之间学会。这是关于在一段较长的时间内填鸭式地灌输正确的信息。在更大的公司里，你可能需要几年时间才能达到目标。在中型公司，你可能会比这更快。如果你要开自己的公司…太好了！然后就可以自我教育了。

关于我:我是一名分析顾问，也是当地一所商学院“人工智能管理”研究的主任。我的使命是让数据科学家(再次)开心，并帮助组织利用人工智能创造商业价值。 在这里报名我的快讯。

整洁的预言家

原文：https://towardsdatascience.com/a-tidy-prophet-5a23382d59e3?source=collection_archive---------41-----------------------

由 Unsplash 上的 Viva Luna 工作室拍摄的照片

在许多没有显式循环的情况下进行预测

对于任何分析师/数据科学家来说，一个常见的问题是采用分析管道，然后在多个数据集上使用它。正如所料，R 有几种方法来处理这个问题——显式循环、*应用函数和 purrr。Purrr 是新来者(特别是对于我们这些在 RStudio 出现之前就已经了解 R 的人来说)，但因为它承载了 tidyverse 背后所有深思熟虑的、富有表现力的设计，所以它可能是最强大的。

脸书的 prophet 是一个越来越流行的时间序列建模包，有 R 和 python APIs。它建立在概率编程语言 stan 的基础上，速度很快，擅长用相对较少的分析师工作量对高频率(daily plus)数据做出相当好的预测。实现 prophet“大规模预测”的承诺需要拟合多个模型，这使得它成为展示 purrr 优势的一个很好的例子。

我们将使用 google trends 每日数据进行搜索，将流行饮食与蔓越莓酱结合起来，看看 tidyverse 和 prophet 如何在几行代码中结合起来，预测尽可能多的时间序列。

蔓越莓不仅仅是用来喝的！

对于那些不熟悉的人来说， google trends 是一款用户可以输入搜索词并获得使用这些词的搜索历史的产品。可以并排放置多达五个搜索词，所有搜索词都按相同的因子缩放(我相信是屏幕上的最大值)，以查看搜索活动的时间轨迹。在这种情况下，我找到了五个关于蔓越莓酱的相关搜索。

谷歌趋势:keto 超过旧石器时代两年运行在重要的蔓越莓酱搜索量！

我们在每年的美国感恩节附近都会看到一个强劲的峰值(注意，趋势数据是针对美国搜索而提取的)，这与我们的直觉相匹配，并为我们提供了一组有趣的时间序列来建模。

为了将我们的重点紧紧放在结合 purrr 和 prophet 上，我已经手动将下载的数据重新调整为长格式。我还将日期列重命名为 ds，趋势卷列名设置为 y，以符合 prophet 包的要求。文件的顶部看起来像这样:

方便成形的输入数据是你如何知道这是一个教程！

为了设置我们的示例，我们需要导入。csv 文件作为我们的训练数据，并创建一个数据框架，以传递到拟合的先知模型进行预测(在代码中称为未来)。

现在，我们的表格中的数据基本上是按照。csv 文件。但是从 Hadley Wickham T1 的意义上来说，这并不十分整洁，因为对于我们的目的来说，每个搜索词(即表中的列的每个值案例、趋势数据)都是一个单独的案例或分析项目。

请记住，我们的目标是将第一个案例的数据传递给 prophet()，然后将下一个案例的数据传递给 prophet()，直到处理完所有案例。

分析大量案例的简洁方法是将给定案例所需的所有数据打包到表的一个单元格中，这样表的每一行都包含标识符、函数参数和分析单个案例所需的数据。nest()函数用于从我们现在拥有的普通平面 tibble 转换为具有嵌套列的 tibble。它是嵌套的，因为新列的每个元素都是一个 TiB ble——我们在 tibbles 中得到 tibbles，就像嵌套的洋娃娃一样。嵌套的 tibble 在每个案例中只有一行(对我们来说是 5 行),而不会丢失原始表中的任何数据(本例中有 1300 行)。

整洁怎么样？

第 7 行创建了嵌套的时间序列数据。使用默认参数调用 nest()意味着所有非分组列都嵌套到一个名为 data 的新列中。在第 14 行，我们还使用一个显式规范将未来数据案例嵌套到一个名为 future 的列中，其中嵌套的列名为 future。

现在我们可以在所有这些案例上训练我们的先知了！但是首先我们应该为 prophet()调用准备一个额外的输入。如果你记得上面的图表数据，我们可能需要包括感恩节的假日效应。prophet 包为此提供了两个选项，但是传入一个定义假日的 data.frame 与 purrr 一起使用效果更好。

第 12 行最后做了本文承诺的事情，用一行代码在每种情况下拟合一个先知模型。我们使用了*map 系列函数的最基本版本；map()有两个必需的参数:一个列表和一个函数名(不带括号！).map()所做的是遍历列表，依次获取每个成员，并将其作为函数的第一个参数传递给函数。每次调用函数的返回值都保存在一个列表中，map()调用返回所有函数返回的列表。在所有情况下都具有单个值的函数的附加参数(即，不是根据正在处理的数据列表的成员而变化的值)可以通过调用函数名后面的 map()来传递。在我们的例子中，holidays=turkeyDayUSA 论证了这一点。

我们要传递的列表在哪里？map()的第一个参数是数据。回想一下，这是我们用 nest()调用生成的 nestedData 中的列名。在 R 中，data.frame(以及 tibble，tidyverse 的等价物)的每一列都是一个列表。也就是说数据是一个列表。因为 map() 也输出一个列表，这个输出可以用来创建一个 tibble 的列。mutate()函数在这里为我们处理这个问题，但是我们也可以很容易地用nestedResults$model=map(data,prophet,holidays=turkeyDayUSA)直接添加列。模型列表的每个成员都是类先知(具有复杂结构)的对象这个小细节根本不会困扰 R，也不应该困扰我们。

坦白地说，所有这些都很难想象，所以我建议您运行代码(来自 github repo )，然后使用 nestedData 表。你觉得 nestedData$data[[1]]是什么？或者nestedData$data[[1]][1，:？

12 号线只是一个开始。因为一旦我们理解了 map()的工作方式和嵌套列的工作方式，我们就可以画一条线 19。这里我们展示了 pmap()，它只是对 map 的一个通用调用，允许从列表中提取任意数量的(可选的)命名参数并传递给函数。我们还利用了这样一个事实，即在单个 mutate()调用中，我们可以创建变量，然后在下一个要创建的变量中使用它们来为第 12 行中的模型创建预测和绘图。是的，我们可以很容易地在一个 mutate()调用中包含第 12 行的模型拟合。

我将把从 nestedResults 中提取情节的练习留给读者(提示:像访问常规列一样访问列名，然后记住它是一个列表！).

预言家预测 keto 蔓越莓酱去年达到顶峰

我希望这篇文章有助于解释 purrr 包的函数式编程工具。与其他 tidy 工具一样，*map 函数简化并阐明了一项常见任务的编码。在这种情况下，该任务在多个案例上运行一组步骤。更简单和更清晰的代码意味着更少的时间调试和检查搜索 stackoverflow 和更多的时间尝试花哨的模型和向关键的利益相关者展示结果——这对任何人来说都是一个胜利。

本文引用的完整代码和附带的源数据文件可以在github上找到。

从 a 到 Z:使用此规则集的主数据可视化

原文：https://towardsdatascience.com/a-to-z-master-data-visualization-with-this-ruleset-73a22c29716?source=collection_archive---------77-----------------------

图片由 Free-Photos 来自 Pixabay

简介:

无论您是尝试进入数据分析还是数据科学领域，无论您是产品经理、销售主管还是任何希望了解其业务的人，能够以有意义的方式利用数据都是关键。无论你使用的是 Tableau、Domo、PowerBI 等数据可视化软件。或者你用的是 R，Python 等语言。有各种各样的原则和概念可以帮助你开始。

您分析的目的:

首先，请记住，任何分析都应该有一定的目的。看着图表，很容易问自己:“我为什么要看这个？”或者“我应该在这里得到什么？”。归结为一个非常简单的原则，我们希望了解给定变量的性质&该变量可能与其他变量有什么关系。

需要牢记的关键事项:

维度，数据类型

维度:

这里我们讨论的是 3D 中 Ds 的数量。所以当你在二维空间玩超级马里奥的时候，你有一个 x 轴和一个 Y 轴。我们大多数人都见过许多二维图表和图形。思考这个问题的方法是，“在一个给定的可视化中，我想要包含多少个变量？”。作为这里的一般规则；少往往就是多。

数据类型:

字段是否为数值型；年龄、体重等。绝对的；性别，发色等。或者时间；某事发生的日期、月份或日期。一旦你理解了这一点，并对某些变量之间的关系有了一些假设，你就可以开始规划你可能使用的可视化类型。

语言和数据集:

所有的可视化都将使用 R 中的 ggplot2 包，使用各种样本数据集，包括 iris、mtcars、mpg 和 economics。我不会在这里包括太多的 r 代码，因为我希望这是广泛适用的，但如果你想要这些代码，请在下面评论或联系。

跳跃中:

在我们实际进行任何可视化之前，我们还需要做其他事情来理解数据，但是我们将直接进入可视化，以便具体了解可视化的规则。

我们将按照数据类型和维度，从一个维度开始，讨论各种选项和规则。

维度数量:1

数据类型:数字

数据集:mtcars 包含在 base R 中的样本数据集给出了汽车上的各种数据点

目的:了解分布和汇总统计

图表:直方图和箱线图

当试图孤立地理解一个数字变量时，你首先要理解它的分布。为此，您将使用一个简单的直方图来告诉您每个值出现了多少次。我们想了解的第一个变量是马力。

我们在这里看到的是，马力向右倾斜，或者说峰值右侧的尾部比左侧的尾部延伸得更远。如果你想一想一辆汽车的典型马力，大多数将小于 250，但肯定仍有汽车被制造来推动这一极限，尽管少得多。

这是同一变量 hp 的盒状图、盒状图和须状图。箱线图对于可视化给定变量的大量汇总统计数据非常有用。图末端的水平线代表最大值和最小值。黑色水平线是中间值。中位数所在的方框表示 IQR 或四分位数范围(将数据分成四个偶数四分位数，IQR 表示第一个四分位数和第三个四分位数之间的范围)。

这里我们看到一个每加仑英里数的直方图，我们看到一个稍微右偏的分布。它也几乎呈现双峰。双峰是指实际上有两个峰值。一种解释是，我们重叠了燃气汽车和电动汽车的分布，所以我们假设燃气汽车的平均 mpg 在 15-20 之间，而电动汽车的平均 mpg 在 30-35 之间，那么如果有足够的量，我们可以在分布中看到两个峰值。

我们现在关注 qsec。汽车性能指标。这是汽车行驶一英里所需的时间。我们在这里看到的是一个非常标准的正态分布。

维度数量:1

数据类型:分类

数据集:mpg 包含在 base R 中的样本数据集给出了汽车上的各种数据点

目的:理解比例

图表:条形图和饼图

当试图孤立地理解单个分类变量时，您要考虑的主要问题是一个给定术语出现了多少次。

现在让我们来看看 mpg 数据集中的变速器和等级变量。为此，我们将创建一个条形图，X 轴上是分类变量，Y 轴上是出现次数。

在这里，您可以了解到哪些传播是经常发生的，而哪些传播似乎稍微少见一些。通常你不需要包括颜色，只是为了让事情更清楚一点。

类似地，我们可以看到按类别绘制的事件计数。我们可以看到，与 SUV 或紧凑型车相比，2 座车和小型货车的出现频率要低得多。这个条形图可以像饼图一样容易地显示出来。饼图有时比条形图更难描绘给定切片的体积，因为任何给定切片都有不同的角度，可能在饼图的不同侧，等等。

如上所述，这是一个类变量的饼状图。

此外，我们可以使用条形图来绘制分类变量的其他聚合。例如，每辆车平均每加仑跑多少英里，但我们会在后面讨论。

好了，现在我们已经单独研究了数字变量和分类变量；让我们将绘制的维度数量增加到两个，并查看一些不同的组合。

维度数量:2

数据类型:数字

数据集:Iris & mpg 包含在 base R 中的样本数据集给出了三种鸢尾的各种数据点以及它们的一些测量值

目的:理解两个变量之间的关系

图表:散点图

每当试图理解两个数值变量之间的关系时，散点图是最佳实践。

在这里，我们试图观察萼片的长度(Y 轴)和宽度(X 轴)之间的关系(对于植物解剖，只需运行快速谷歌搜索…😃 )

我还查看了这两个变量的相关性(衡量两个变量如何相关或一起移动，1 表示移动完全同步，-1 表示它们完全相反，5 或-.5 是良好的关系，3 或-.3 可能是弱关系，任何低于这一水平的都是弱关系或随机关系)，发现它是-.11，表明没有真正的关系。虽然看起来这两个变量是不相关的；考虑变量之间关系的许多潜在层面是很重要的。

这个我以后再讲，现在先来先睹为快。虽然在前面的图中，我们看到宽度和长度似乎不相关，但尽可能多地包括潜在的视角是很重要的。看着和之前一样的剧情，我们准备给它再增加一个维度；物种。我们将用颜色来显示物种。

一旦我们添加了第三维，我们可以看到，在物种的长度和宽度之间有一个清晰的线性关系。

下面我已经包括了按物种分组时的相关性，我们可以看到在高端的相关性为 0.74，在低端的相关性为 0.46，这仍然是相当可观的。

现在让我们回到评估两个数值变量。在这里，我们看到的是城市英里数和公路英里数。这里，散点图以线性方式向右上方移动，表明两者之间存在正相关关系。这两个变量的相关系数为 0.96。

如果你是统计学新手，需要记住一些事情。即使这些东西一起移动。并不一定意味着一个是另一个的原因。这只能说明他们有血缘关系。

为了继续评估二维数据的其他组合，让我们考虑如何分析两个分类变量之间的关系。

维度数量:2

数据类型:分类

数据集:mpg 包含在 base R 中的样本数据集

目的:理解两个变量之间的关系

图表:表格、热图、条形图

在开始可视化之前，我将在一个表格中展示两个分类变量，因为两个分类维度的可视化代表了我们在表格中会发现的内容。

下表来自 mpg 数据集；我们正在考虑汽车的级别，以及汽车是四轮驱动、前轮驱动还是后轮驱动。

在这里，我们可以看到属于任何给定分类变量组合的记录的频率

一眼就能看出 SUV，4 轮驱动是最常见的。你可以添加的另一层是把每个单元格看作整体的一个百分比。

关于道具桌还有更多内容要做，但是我们将把它留到下一次。

从这里开始，我们要想象我们在道具桌上看到的东西。

将这个表格可视化的一个很好的方法是使用热图。看看下面的图表。在任一轴上，您可以看到分类变量，热图的颜色由出现次数表示。

正如我们在原始表格中看到的，SUV，4 轮驱动是最常见的，中型前轮驱动次之，紧凑型前轮驱动第三。

热图在准确测量数量方面存在一些困难。我们有一个图例，根据你使用的软件，你可以很容易地把它作为工具提示。

另一个选项是返回到条形图，其中一个分类变量在 x 轴上，数值变量(计数)在 y 轴上，第二个分类变量在颜色维度上表示。

在这里，我们可以再次看到哪种组合是最频繁出现的，从而使我们达到类似的目的。

下一个绘图选项非常相似，但是除了用颜色表示第三维，我们还可以使用刻面。分面是一种技术，它允许您为分类变量的每个级别提供自己的绘图。看看下面。

正如这里提到的，我们可以看到一个与之前非常相似的情节，但是每个职业等级都有自己的情节。

在这一点上，我们已经看到了各种图表非常相似的结果。你要考虑的是一个给定的情节在多大程度上传达了你的信息或产生了必要的洞察力，它是否过于复杂，它是否占用了太多的空间，潜在的利益相关者会在多大的屏幕上看到你的图表，等等。

现在我们开始绘制多维度的图。

维度数量:3–5

数据类型:数字和分类

数据集:mpg 包含在 base R 中的样本数据集

目的:了解多个变量之间的关系

图表:散点图

在这里，我们看到的是与之前相同的图，只做了一处修改。为了包括“发动机排量”的第三维度，我们现在改变点的大小以对应发动机排量。正如我们所见，它似乎与较高的城市和公路里程数成反比。

现在，添加维度的另一个选项是颜色。

我现在用颜色来表示发动机排量，而不是用尺寸。

在下面，我添加了一个我们两者都做的额外的情节，这使得它更容易被看到。

需要记住的一点是，我们可以引入第四个数字维度，而不是用颜色和大小来表示发动机排量。

这里我已经换出了 cyl 来填充尺寸维度；这似乎也与公路和城市 mpg 成反比。

我们在这里可以介绍的几个其他选项可以是使用颜色来引入分类变量或根据分类变量来分面。

在这里，您可以看到现在按类分面的示例图，这使我们可以看到这些数字变量在分类变量的不同级别上如何相互关联。

在我们总结之前，最后要考虑的是我们是否有一个表示时间的变量的二维数据。时间的一个重要经验是使用折线图。

维度数量:2

数据类型:数字和时间

数据集:经济学；包含在 base R 中的样本数据集

目的:理解时间和数字变量之间的关系

图表:线条

我们将要研究的数据来自经济学样本数据集，代表了过去 50 年左右的失业率。

当绘制具有时间维度的数据集时，我们试图识别给定数值变量中的趋势，以了解趋势以及给定活动是否可能与该运动一致。把你的时间维度放在 X 轴上，把你测量的数值变量放在 Y 轴上。

即使在这里，还有很多事情可以做，但我将把它留到下次再做。

外卖:

• 一维
• 数字:直方图，盒状图
• 分类:表格、条形图、饼图
• 二维
• 数字/数字:散点图
• 数字/分类:条形图
• 分类/分类:条形图、表格
• 三维
• 数字/数字/数字:大小/颜色散点图
• 数值/数值/分类:带颜色/面的散点图
• 数字/分类/分类:带颜色/面的条形图
• 4+维度
• 在 x 和 y 轴上使用不同的数据类型和变量的组合，以及颜色、填充、大小、刻面等。

使用数据可视化可以做很多事情&这仅仅是开始。希望这能帮助你开始！

如果有帮助，请将您自己添加到我的电子邮件列表中；另外，如果您喜欢代码示例、附加信息等，请务必告诉我。

来看看我在 datasciencelessons.com 的其他帖子吧&祝数据科学快乐！