使用计算机视觉通过网络摄像头进行实时视频素描
实施计算机视觉模型，创建实时网络摄像头视频的实时视频草图。源代码用 python 编写，模型基于 OpenCV。
计算机视觉 指的是 计算机科学 的一个领域，专注于使计算机能够像人脑一样看到、识别和处理图像。它是 人工智能 的一个分支，允许计算机从一组图像中提取有用的特征，对它们执行所需的操作并生成输出。
图 1:计算机视觉 来源
本文旨在实现一个计算机视觉模型，该模型生成一个网络摄像头的实时镜头的现场视频草图。该项目的完整源代码可在我的 Github repo 上获得。
安装所需的软件包
通过在命令提示符下运行以下命令，使用 pip 安装项目所需的所有软件包:
pip install opencv-python
pip install keras
pip install numpy
pip install matplotlib
实施模型
我们将把实现过程分为两部分。
第一部分包括定义一个函数，该函数将视频的单个帧作为输入，并生成一个草图图像帧作为输出。执行此操作的 Python 代码如下:
**import** **keras**
**import** **cv2**
**import** **numpy** **as** **np**
**import** **matplotlib
import** **cv2**
**import** **numpy** **as** **np**
*# Our sketch generating function*
**def** sketch(image):
*# Convert image to grayscale*
img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
*# Clean up image using Guassian Blur*
img_gray_blur = cv2.GaussianBlur(img_gray, (5,5), 0)
*# Extract edges*
canny_edges = cv2.Canny(img_gray_blur, 30, 60)
*# Do an invert binarize the image*
ret, mask = cv2.threshold(canny_edges, 240, 255, cv2.THRESH_BINARY_INV)
**return** mask
首先，我们将视频的彩色图像帧转换成灰度。然后，我们使用 OpenCV 的 GaussianBlur() 函数清理图像。最后，为了生成帧的草图，我们提取了 canny 边缘并在边缘上进行反转二值化操作。
第二部分包括将上述草图函数递归应用于网络摄像机视频的所有帧。执行此操作的 Python 代码如下:
cap = cv2.VideoCapture(0)
cap2 = cv2.VideoCapture(1)
**while** **True**:
ret, frame = cap.read()
ret1, frame1 = cap2.read()
cv2.imshow('Original', (frame))
cv2.imshow('Our Live Sketcher', sketch(frame))
**if** cv2.waitKey(1) == 13: *#13 is the Enter Key*
**break**
*# Release camera and close windows*
cap.release()
cap2.release()
cv2.destroyAllWindows()
如上面的代码片段所示，初始化两个 VideoCapture 对象:一个用于显示网络摄像机镜头，另一个用于显示实时视频草图。创建一个循环，当有人按下回车键时循环就会中断。在循环内部，获取两个 VideoCapture 对象的帧。将原始框架传递给草图函数，并显示原始框架和草图框架，直到循环中断。
结果和结论
图 2:最终输出
上图显示了模型的最终结果。我们可以看到，该模型成功地生成了网络摄像头视频的现场视频草图。
请注意，视频性能因您的网络摄像头而异。为了提高性能，您可能希望在代码中使用 canny_edges 30、60 和二进制化 240 值。更改它们，使其适合您的网络摄像头。
此外，我鼓励本文的读者自己尝试代码，以提高模型的精度。
如果你觉得这篇文章有用，请随意与他人分享。非常感谢您的阅读。
请随时在其他平台上与我联系:
github—https://github.com/kaushikjadhav01
LinkedIn—https://www.linkedin.com/in/kaushikjadhav01/
源代码
整个项目的源代码可以在我的Github repo**上找到。**随意用于教育目的。
使用带有 ImageZMQ 的多部智能手机进行实时视频流传输
将您的旧智能手机回收到实时视频流网络中！
介绍
最近，我一直在钻研计算机视觉。我对活体对象检测和对象跟踪特别感兴趣。然而，我意识到我需要我自己的现场视频流来测试我的项目。
第一个问题是，我没有任何外部网络摄像头可用。我有一台内置网络摄像头的笔记本电脑，但由于其尺寸和功耗的原因，将笔记本电脑设置为仅使用网络摄像头并不太实际。然而，我确实有相当多的备用智能手机，我不再使用了。
第二个问题是，我还需要一些东西，允许我通过网络将帧发送到远程服务器，那里有足够的处理能力来对每个视频流运行机器学习算法。这是一个重要的问题。我的笔记本电脑远远不够强大，无法在多个流上运行 YOLO 和深度排序之类的东西。
我可以用我的旧智能手机建立一个简单的相机网络吗？
起初，我使用 IP camera 应用程序和 OpenCV 成功地从一台设备通过网络传输视频。然而，当我尝试从多台设备上流式传输时，事情很快变得一团糟。还有性能问题，因为我没有异步处理帧。
在与 OpenCV 斗争了一段时间后，我偶然发现了一个由杰夫·巴斯为 Python 开发的惊人的库，名为 ImageZMQ 。它允许你用几行代码创建一个视频流网络！它被设计成运行在覆盆子馅饼上，但是我没有任何可用的。相反，我用我的笔记本电脑处理并通过网络发送智能手机上的帧。ImageZMQ 还显著提高了我的流性能。
如果你想开始研究计算机视觉，或者想回收你的旧智能手机来建立一个监控系统，我会说这是一个很好的起点。
为什么选择 ImageZMQ？
顾名思义，ImageZMQ 使用名为 ZeroMQ 的无代理异步消息传递库。
当涉及到实时视频流时，我们理想地想要尽可能低的延迟。异步处理允许我们实现更好的帧速率和延迟。对于较大的摄像机网络来说尤其如此。
也是无经纪的。这意味着运行的进程更少，并消除了代理瓶颈的可能性。这对于实时视频流尤为重要，因为我们需要高吞吐量和低延迟性能。
网络结构
Adrian Rosebrock 发表了一篇精彩文章，深入介绍了如何使用配有 Pi 摄像头模块的 Raspberry Pis 建立一个带运动检测的监控网络。这对我来说是多余的，正如我之前所说的，我没有这些可用的。
相反，我使用了一些旧的智能手机，每部手机上都安装了 IP 摄像头应用程序。我把智能手机传到我的笔记本电脑上，在那里它们通过网络被重定向到一个中央服务器。如果你碰巧有一些覆盆子酱，那么我建议你先看阿德里安指南，而不是我的。
要做到这一点，我们需要设置多个客户机和一个服务器，作为中央处理中心。我们还需要在每部智能手机上安装一个 IP 摄像头应用程序。需要说明的是，我所有的智能手机都使用 Android 操作系统。如果你也在使用 Android，那么 Google Play 商店里有很多 IP 摄像头。就我个人而言，我一直在使用 IP 网络摄像头 ，它提供了一些有用的视频设置。但我相信其他 IP 摄像头应用程序的工作方式也大致相同。
继续之前，请确保 Python 环境中安装了以下库:
**imutils**，**opencv-python**，**socket**，- 当然还有
**imagezmq**。
为了防止这些库出现任何问题，我使用 Python 3.6。我建议使用与我相同或更高版本的 Python。
服务器端
设置服务器来接收输入帧非常简单。如果您有使用 OpenCV 的经验，它应该看起来很熟悉。
图像中心
首先，我们需要导入 OpenCV 和 ImageZMQ。注意，当我们安装opencv-python时，我们将其导入为cv2。然后，我们需要使用 ImageZMQ 的ImageHub创建一个图像处理中心，它将接收和处理来自每个流的传入帧，这可以在一行中完成。
import cv2
import imagezmqimage_hub = imagezmq.ImageHub()
ImageHub()有两个额外的参数，您可以在其中使用。第一个参数是open_port，默认情况下在端口 5555 接受任何传入的 TCP 流量。第二个参数是REQ_REP，代表请求-回复，默认为True。这是一种 ZeroMQ 模式，在发送下一帧之前，客户端发送的每一帧都必须等待服务器的回复。如果我们将此设置为False，那么模式将改为发布-订阅模式。
对于我们的场景，我们希望有一台服务器来处理多个客户端发送给它的视频帧。发布-订阅模式要求每个客户机本身也是一个服务器，主处理中心订阅这些服务器中的每一个。这需要预先知道每个流的地址，所以这不是我们想要做的最实际的事情。因此，我们保留默认值并保持不变。
然而，Jeff 已经很好地解释了使用发布-订阅模式的好处。如果您有兴趣学习更多关于 ZeroMQ 模式的知识，那么我建议您阅读一下。
显示帧
下一步是创建一个循环，从每个流中提取每一帧，并相应地显示它们。这可以通过使用 while 循环和 OpenCV 的imshow()方法来完成，如下所示。
while True:
cam_id, frame = image_hub.recv_image()
cv2.imshow(cam_id, frame)
cv2.waitKey(1)
image_hub.send_reply(b'OK')
我们使用recv_image()对输入流进行解包，以获得每个视频流的帧以及每个摄像机设备的名称。
为了显示每个摄像机的帧，我们使用cv2.imshow()。最好的部分是，这种方法将自动分离和显示每个视频流的帧！然后我们需要cv2.waitKey(1)来允许每一帧在 1ms 后刷新。
最后，由于我们使用的是请求-回复模式，我们需要向客户端发送一条 OK 消息，让他们知道服务器已经成功接收并处理了该帧。然后，客户端将知道继续向服务器发送帧。
客户端
每个客户端的代码也非常简单。我们需要知道的唯一事情是，要向服务器发送帧，我们需要用正确的流路径和服务器地址配置每个客户端。
设置流
对于客户端，我们需要从 imutils 导入 ImageZMQ、socket 和VideoStream()方法。然后，我们使用VideoStream()从我们的相机捕捉帧。我们本可以使用 OpenCV 的VideoCapture() 来代替，但是 imutil 的VideoStream()将picamera模块与 OpenCV 结合起来，万一我们将来决定使用 Raspberry Pis，这是一个很好的选择。
from imutils.video import VideoStream
import imagezmq
import socket# change this to your stream address
path = "rtsp://192.168.1.70:8080//h264_ulaw.sdp"cap = VideoStream(path)
path应该是一个来自你的 IP 摄像头应用程序的链接。你可以通过打开智能手机上的应用程序很容易地找到这一点。
请注意，如果您通过路由器进行流式传输，地址可能会改变。你需要在路由器内给设备一个静态 IP 地址，否则如果你再次运行代码，它会中断你的数据流。
然后，我们需要使用 ImageZMQ 创建一个图像发送器，并为我们的相机命名。我们现在可以开始了。
# change this to your server address
sender = imagezmq.ImageSender(connect_to='tcp://localhost:5555')
cam_id = socket.gethostname()stream = cap.start()
ImageSender()也有REQ_REP参数，但是如前所述，我们将其保留为True的默认值。我们只需要指定将帧发送到的服务器地址。在本例中，我在端口 5555 使用了 localhost，因为我是从同一台机器上流式传输的。例如，如果我们将数据流传输到云中的一个服务器，那么我们将用该机器的 IP 地址替换 localhost。这是假设服务器通过打开正确的端口(默认情况下是端口 5555)来允许流量。
我们还使用socket.gethostname()来获取我们正在传输的设备的名称。如果我们使用 Raspberry Pis，那么这是一种自动获取每个设备名称的简单方法。如果您只有几个设备，那么您可以手动将cam_id更改为简单的数字。
发送帧
为了发送帧，我们再次需要一个循环，从视频流中读取帧，然后使用前面的ImageSender()发送它们。
while True:
frame = stream.read()
sender.send_image(cam_id, frame)
…我们完成了！现在我们需要做的就是为每个设备创建一个客户端脚本，并确保为每个设备正确配置了path和cam_id变量。
把所有东西放在一起
一旦每个设备都准备好自己的客户端脚本和 IP 摄像机运行，确保流路径和服务器地址是正确的，然后启动服务器。只有服务器启动并运行后，设备才能开始发送帧。运行每个客户端，你应该能够看到每个单独的视频流出现在服务器端！
体验数据文化第 2 部分
数据驱动的文化可以让你的企业脱颖而出，成为领跑者
约翰·T 在 Unsplash 上拍摄的照片
本文详细介绍了数据文化的五大支柱。此外，我用数据货币化来结束这篇文章，这样，一旦你投身于数据驱动的文化努力，你就可以将其融入你的业务。在本系列的第 1 部分中，我们讨论了什么是数据文化，如何让你的员工和企业生活在这样的文化中？数据驱动和数据文化如何帮助您的企业成为领跑者？
数据驱动型企业的 5 大支柱:
一个数据驱动的组织必须显示以下属性，并基于以下 5 个支柱构建其数据文化:
- 所有决策都基于数据
- 不成为他们过去成功的受害者
- 基于协作智能重新设计他们的战略
- 构建数据文化
- 数据货币化
在下文中，我将详细介绍这五个支柱中的每一个。
1.所有决策都基于数据
对于每一个决策，每一个机会，组织都将其关注点从直觉转向数据驱动的决策。历史起伏、个人智慧和数据驱动的组织不再依赖他们的累积经验，而是转向基于数据和见解的决策和风险承担。这种基于数据的人类经验的转变，一种基于人工智能的业务运营方法提供了竞争优势，并使公司成为商业 4.0。
2.不成为他们过去成功的受害者
当试图利用数据进行创新和转型时，公司最大的障碍是“我们一直都是这样做的”文化。加比·博科
摆脱这种“过去以特定方式做事的传统”方法及其市场地位的企业，在其运营中利用数据和人工智能，创造新的机会和决策，他们可以利用和发展数据文化。人工智能和数据改变了商业模式，使用户有更多的选择。他们会选择在便利性、成本、服务方面最适合他们的公司。在一个数据驱动的组织中，领导者开始通过他们的行动来激发灵感，并将他们的决策建立在直觉的基础上。
3.基于协作智能重新设计他们的战略
那些重新设计和修改他们的策略以利用人类和机器的力量的人，因为未来是基于协作智能的。有些方面人类更好，有些方面机器更好。
4.构建数据文化
为了在数据和人工智能时代蓬勃发展，您需要建立缺失的环节，使您的企业能够充分转型并利用数据和人工智能提供的潜力。缺少的环节是在整个组织中创建、推广和传播数据文化。让数据成为每个商业环境中的一等公民。企业投入了大量资金来变得更加数据驱动，但只有一小部分能够成功实现预期目标[1]。
要从您的数据中获取价值，仅有技术是不够的，还需要改变个人的思维模式、态度和方法，这就需要将数据嵌入到您和您的员工所做的一切中。
建立数据文化意味着让每一个员工都能够通过利用手边的数据来实现他们的目标。它围绕着挑战想法、提出问题、请求和提供数据来支持你的想法。人们走到一起，为了一个共同的使命而团结起来，用数据发展组织。
在数据文化中，当更多的人能够提出问题并得到答案时，每个人都会受益；一个组织的整体效率可以提升。
为了成功地建立和实践数据文化，您需要在整个企业中建立以下支柱。
a.信任
要在您的组织中建立信任基线，您需要授权您的员工，为数据使用设定明确的预期，鼓励共享数据和透明度，并建立对数据的信任。要做到这一点，您需要有适当的治理，以支持良好治理、受保护和广泛的数据访问，并建立对数据的信心。创建单一的事实来源，打破团队之间的孤岛，在企业内部建立高度的协作和信任。如前所述，这些将导致在您的组织中共享见解。
b.承诺
您的企业需要将数据视为战略资产和优先事项。领导层需要对数据行为建模，而不仅仅是赞助它。行政领导必须承诺通过收集数据并利用数据来改善业务，从而从数据和见解中获益。这种承诺应该体现在组织结构和日常运营中。作为一家企业，你必须指派一名高管(例如，CDO 首席数据官)负责使用组织的数据，并将分析项目映射到业务目标。
简而言之，为了在数据和人工智能方面取得成功，建立和维护以数据为中心的文化非常重要，IBM SVP 罗布·托马斯在下文中强调了创建数据文化的重要性[3]。
使用人工智能的真正成功取决于一个组织采用以数据为中心的文化的能力
c.心态
改变整个组织鼓励数据胜过直觉、等级和经验的思维模式。努力确保整个企业的每个人都认同这种心态；这将创造一个开放讨论、健康辩论和思想催生创新和增长的环境。人们应该用数据挑战想法，进行实验，快速失败。数据应被视为个人成长和发展的体现，因为它使人们准备好挑战或被他人挑战基于数据的假设。
d.才能
在招聘、发展和留住人才时，优先考虑数据和人工智能技能。确保你的所有员工对人工智能和数据有基本的了解，不管他们的工作职能是什么。即使您可以部署最好的技术和流程，如果您的员工不知道如何处理数据，这也是没有用的；人们需要意识到并使用这些数据和见解。根据你的内部专长和业务，可能需要不同的策略，但一定要考虑重新培训你的员工，等等。
e.共享
一旦人们分享了目的，就很容易分享剩下的许多东西。在数据文化中，解决问题涉及多个团队和不同的业务单元，需要来自不同系统的数据和来自不同团队的领域专业知识。一旦你的团队开始分享目标——使用数据使他们的组织变得更好，他们就可以用数据放大他们的成功。因此，共享在数据文化中发挥着巨大的作用；团队可以分享最佳实践，发展社区意识，学习彼此的经验，并实现其他用例。
除了这些支柱，如果你想寻找建立这种数据文化的步骤，看看 HBR 的一篇文章，其中详细介绍了建立数据驱动文化的十个步骤[4]。
5.数据货币化
将数据转化为赚钱机会的技术。它是利用数据增加企业收入的过程，可能有多种形式。它是关于从你的数据和分析努力中产生可衡量的商业优势。表现优异且发展迅速的公司已经采用了数据货币化，并越来越多地将其作为其战略的重要组成部分[5]。实施正确的数据货币化战略后，您将完全有能力磨练自己的竞争优势。如果没有这些，你就有可能丢掉那些可以推进你的业务的关键见解。
a.直接货币化。
它包括向第三方出售对你数据的直接访问权——你可以出售原始形式的数据，也可以出售见解。常见的例子可能是潜在业务前景的联系列表或影响买方行业和业务的发现。
b.间接货币化
一、基于数据的优化
它包括分析数据以揭示可以提高组织绩效的见解。数据可以制定策略，如何接近客户并了解他们的反应，以推动您的销售。数据还可以突出显示在哪里以及如何节省成本、避免风险和简化流程。
二世。数据驱动的商业模式。
它专注于利用数据来发现新的商业可能性。你可以将分析和人工智能安装到你的产品或服务中，为你和你的客户带来优势。客户从直接访问使用统计数据和其他由其产品使用产生的数据中获益。它可以作为增值服务或新服务提供，以培养客户忠诚度。最终，你可以更好地了解你的产品是如何被使用的。
Part of this article was originally published on [AI Time Journal](https://www.aitimejournal.com/@chan.naseeb/living-a-data-driven-culture)
参考文献:
- https://www . McKinsey . com/business-functions/McKinsey-analytics/our-insights/breaking-away-the-secrets-to-scaling-analytics #
- https://blogs . Microsoft . com/blog/2014/04/15/a-data-culture-for-every one/
- https://www.ibm.com/blogs/think/2017/11/a-culture-of-data/
- https://HBR . org/2020/02/10-创建数据驱动文化的步骤
- https://www . McKinsey . com/business-functions/McKinsey-analytics/our-insights/fuering-growth-through-data-monetization
边缘生活和计算
联邦学习简介
保护隐私的需要
对隐私的需求从未像现在这样迫切——在这个时代，数据的价值被比作石油，并被视为个人最重要的资产。个人生成的数据类型从看似无害的细节(如零售偏好)到高度敏感的信息(如医疗记录),甚至是可能并已经影响全国大选的政治观点[1]。
对于这种提高数据安全性的呼吁，一个可能的答案是开发保护隐私的机器学习，也称为联邦学习，这种答案越来越受欢迎。在高层次上，联邦学习是一种机器学习方法，它以协作方式训练模型，旨在通过使用差异隐私和分散数据来防止数据泄漏。因此，联合学习允许个人数据保持匿名，同时帮助建立强大的模型[2]。
最简单地说，联合学习不是将你的数据发送给第三方，而是将模型带到你的数据中，同时加密每一步。
机器学习的未来是协作
隐私不是联邦学习用来解决的唯一问题；它还消除了目前阻碍我们建立更精确模型的障碍。其中一个问题是，没有一个中央数据源来提取训练这些模型所需的所有数据。一系列数据类型——通常分布在各个机构——将被要求训练一个描绘整体图景的模型。例如，为了捕捉个人的财务状况并提供洞察力，必须根据在多家银行和信贷服务、在线零售行为和支付习惯中发现的数据来训练模型。更为复杂的是，同一公司不同部门之间的数据传输可能会面临管理或隐私相关的问题。
联合学习为每个人都拥有不同拼图的各方带来了合作训练模型的机会，这些模型比基于单一数据源训练的模型更准确。
引擎盖下的联邦学习
高层次的联合学习可以用三个步骤来描述:
- 共享的全局机器学习模型根据可用数据进行训练，并部署在分散的平台上。
- 该模型被下载到边缘设备上，该设备可以是智能手机、笔记本电脑或其他智能设备，然后该设备使用其包含的数据更新该模型。
- 更新(例如计算出的梯度)被加密并发送回服务器，在服务器中，来自多个设备的更新被平均并用于改进主共享模型。
- 共享模型然后由边缘设备下载，有益于模型的数据贡献者和管理者。
这些步骤确保每个数据源的偏差都被考虑在内，并准确地说明问题的全貌。例如，根据来自世界各地卫生机构的心脏病数据训练一个联合模型可以消除根据一个国家的国内数据训练的模型中发现的种族和性别偏见[3]。
联合学习的组成部分一览
我创建了一个图表来说明在非常高的层次上组成联合学习的各种元素:
有三点构成了联邦学习的基础:隐私、数据结构和模型类型。随着新的研究不断改变景观，增加复杂性，增加深度，这些点进一步分支。
-
隐私 —隐私是联合学习最重要的方面。无论数据的提供者是公司还是个人，隐私保护都会促进协作中的信任，保护敏感数据，并确保个人的合法权利。
-
数据结构 —联合学习根据模型训练的数据结构进行分类。有三种类型的数据结构类别:水平联合学习、垂直联合学习和迁移学习(在以后的文章中会有更多介绍)。这些结构描述了数据是如何组织的，特别是数据集是否共享相同的特征空间，或者它们是否共享相同的样本。这两个描述分别指横向和纵向学习。
-
模型类型 —简单来说就是被训练的模型是神经网络还是统计学习模型。这将取决于数据类型、数据量和期望的预测结果。
联邦学习数据结构图[4]。
未来方向
虽然联合学习可能成为涉及跨多个设备的大量数据的问题的解决方案，但一些障碍仍然存在。
- 资源瓶颈— 这些问题包括连接的物联网设备在一轮培训中电池寿命不同的情况，这可能会导致一些设备退出。通信差异(如设备连接到 wifi、3G 或 4G 网络的能力)会影响网络。最后，网络上不同设备的硬件规格(如内存和 CPU)可能有所不同。
- 数据差异— 每台设备上的数据在质量、数量和一致性方面都会有所不同。例如，如果为面部识别收集图像数据，那么图片中的照明、面部的多样性以及贡献的数据量将影响本地训练的模型。这些局部模型在质量上会有很大差异，最终会影响全局模型的整体质量和准确性。
参考
- https://www . nytimes . com/2018/04/04/us/politics/Cambridge-analytic a-smoke-fallout . html
- 联合学习:没有集中训练数据的协作机器学习。Google AI 博客，Brendan McMahan 和 Daniel Ramage，2017 年 4 月 6 日。https://ai . Google blog . com/2017/04/federated-learning-collaborative . html
- Carnethon，M. R .，Pu，j .，Howard，g .，Albert，M. A .，Anderson，C. A. M .，… Yancy，C. W. (2017)。非裔美国人的心血管健康:美国心脏协会的科学声明。循环，136(21)。https://doi.org/10.1161/cir.0000000000000534
- 杨强，，，陈，童永新。2019.联邦机器学习:概念和应用。ACM Trans 智能。系统。Technol.10，2，第 12 条(2019 年 2 月)，19 页。https://doi.org/0000001.0000001
一卷一卷地生活
资料来源:Pexels
概率思维如何帮助避免病毒性歇斯底里
采取行动的压力很大
由于未来两周西班牙处于封锁状态，以控制新冠肺炎病毒的传播，我在家里的时间太多了，这让我有很多时间想象各种世界末日的场景。每次我的想法出错，我都觉得我应该采取两种行动之一:
- 陷入大规模的歇斯底里，立即逃离西班牙，留下一切。
- 作为一名数据科学的学生，退一步，遵循数据驱动的方法来采取行动。
对于莎士比亚的《哈姆雷特》的读者来说，这个动作很简单。他写道，
“决心的本色被苍白的思想蒙上了一层阴影；和企业的伟大音高和时刻，在这方面，他们的电流变歪了，失去了行动的名字。”
由于我不理解莎士比亚试图表达的一半内容，我将继续向你解释我的第二种方法，即等到我获得更多信息时——有些人可能称之为贝叶斯方法。
回答我:哪一种疾病更危险，是每 10，000 个病例中有 1，500 人死亡的疾病，还是每 100 个病例中有 20 人死亡的疾病？
如果你说的是前者，那么你就陷入了一个经典的分母忽略陷阱，这种偏见在《快速思考&慢速思考】(丹尼尔·卡内曼和阿莫斯·特拉弗斯基)中有所描述。如果你用百分比来思考，这是很难的，因为你不得不强迫自己去计算，你会意识到第一种情况只会杀死 15%的时间，而后者会杀死 20%的时间。我愿意接受多出来的 5%的生存机会！
问题不仅在于我们避免计算，还在于我们在处理大数时有很多困难。比如 100 万秒是 11.5 天，但是 10 亿秒是 31.5 年！这种明显的差异让你吃惊了吗？如果是的话，你正遭受另一位著名的认知科学家道格拉斯·霍夫斯塔德所描述的“数字麻木”。
很明显，有些偏见会影响我的判断。更重要的是，当我们处于恐慌或恐惧状态时，这些偏见可能对我们影响最大。正如《真实》的作者、研究非洲疫情二十年的学者汉斯·罗斯林指出的，“当我们的头脑被恐惧占据时，就没有事实的空间了”。
概率方法提供了一些缓解
每当我们遇到像现在这样的不确定时期，它都会提醒我们自己唐纳德·拉姆斯菲尔德的一句话:
我对那些说某事还没发生的报道很感兴趣，因为正如我们所知，有已知的已知；有些事情我们知道我们知道。我们也知道有已知的未知；也就是说，我们知道有些事情我们不知道。但也有未知的未知——那些我们不知道自己不知道的。如果纵观我们国家和其他自由国家的历史，后一类往往是困难的。
那么，从新冠肺炎的角度来看，有哪些已知的知识呢？例如，我们知道(截至撰写本报告之日)，全球共有 150，182 例阳性病例，其中 5，627 例死亡。
有哪些已知的未知？我们知道感染的人越多，病毒传播的速度就越快，但我们不知道实际上有多少人已经被感染。根据一些报告，大约 80%的病例仅表现出轻微症状，鉴于大多数国家的检测是一个瓶颈，我们不知道有多少人实际上受到影响而没有进行检测。
最后，什么是未知的未知？在接下来的几天里，一种全新的毒株会不会发展起来，重新启动一个全新的疫情？我们不知道。世界上所有的国家都会永远关闭边境吗？我们不知道。
考虑到这一背景，约翰·梅纳德·凯恩斯(John Maynard Keynes)可以提供一个视角，“当我的信息发生变化时，我会改变我的想法。你是做什么的？”。这类似于遵循贝叶斯方法，所以让我们这样做:
我要做一个严峻的假设:根据我们现在所知道的，如果我感染新冠肺炎病毒，死亡的可能性有多大？为了开始寻找答案，让我们提醒自己贝叶斯定理。
来源:维基共享资源
因此，我们试图找到的是新冠肺炎收缩时死亡的后验概率。为了实现这一目标，我们需要两样东西:
a)感染病毒的概率(先验概率):一些专家认为，大约 60-70%的世界人口最终会在某个时候感染病毒，所以这是我们的先验概率。
b)无法存活的概率(给定收缩):全世界的平均死亡率(迄今为止，根据现有数据)约为 3%(迄今为止 5，627 / 150，182 例)，因此无法存活的概率为 3%，存活的概率为 97%。
基本上，我们有:
- P(A =缔约新冠肺炎)= 70%
- p(B/A =给定新冠肺炎的死亡率)= 3%
- P (B =总生存概率)=给定新冠肺炎的死亡率+给定没有新冠肺炎的存活率(30%没有收缩* 0.01%死亡率=在我的年龄，我在任何一天偶然死亡的几率)
将这些数字放入公式中，我们得到 2.1%的后验概率，其工作原理如下:
70%*3% / (70%*3% + 30% * 0.01%) = 2.1%
如果 a)感染病毒的可能性增加，这可能会发生，如果我们决定忽略所有的预防措施，这就是为什么洗手如此重要，或者 b)死亡的可能性增加，这就是为什么我们必须避免感染，以免医疗系统不堪重负。
没有行动也是行动
对我来说，如果我默认一个基于概率的方法，几率仍然偏向于没有重大事件发生。就我们现在的处境而言，用风险大师彼得·伯恩斯坦(Peter L. Bernstein)的话来说(摘自他的《对抗众神》(Against the Gods)，追随哈姆雷特是错误的策略，因为:
“一旦我们采取行动，我们就失去了等待新信息出现的选择。结果，不演戏也有价值。结果越不确定，拖延的价值就越大……犹豫不决的人已经走了一半的路”。
请，让我们都试着遵循预防措施，照顾那些需要帮助的人，学会一次一卷地生活！
在 AWS Lambda 上加载大型空间模型
使用 spaCy 和 AWS Lambda 的无服务器 NLP
保罗·塞尚/来自维基媒体的公共领域
spaCy 是一个有用的工具，它允许我们执行许多自然语言处理任务。当将 spaCy 集成到现有的应用程序中时，使用 AWS Lambda 和 API Gateway 将其作为 API 提供会很方便。然而，由于 Lambda 的限制，很难部署大型模型。
在本文中，我将向您展示如何使用最近发布的特性部署 spaCy，以便在 AWS Lambda 上挂载弹性文件系统(EFS)。通过使用这个特性，我们可以将一个大尺寸的模型存储到 EFS，并从 Lambda 函数中加载它。具体来说，可以加载比 Lambda 的/tmp (512MB)中可用空间更大的数据。
整体架构如下。Lambda 在 Lambda 层上加载 spaCy 包。EFS 商店的空间模型。Lambda 然后从 EFS 加载模型。为了实现冗余，四个子网位于两个不同的可用性区域。
要求:
- 码头工人
- AWS CLI
创建 VPC 和子网
首先，我们必须配置可以到达 EFS 山目标的 VPC。在这里，我们创建了一个 VPC、一个 internet 网关、两个 NAT 网关和四个子网(两个公有，两个私有)。
在 VPC 控制台中，我选择创建 VPC 并设置一个名称标签和 IPv4 CIDR 块，如下所示:
在下一步中，我将创建一个 internet 网关，通过以下设置从 VPC 连接 Internet。之后，我将它附加到创建的 VPC 上。
在下一步中，我使用以下设置创建了四个子网( public-spacy-1、public-spacy-2、private-spacy-1、private-spacy-2 )。注意 public-spacy-1 和 private-spacy-1 具有相同的可用区域。
然后，我创建了两个 NAT 网关，并将其连接到公共子网，以便从私有子网中的 lambda 函数访问互联网。我给 NAT 网关起了名字: NAT 空间 1 和 NAT 空间 2 。
最后，我创建路由表。对于公共子网，我添加一个目的地 0.0.0.0/0 和一个目标互联网网关来访问互联网。对于私有子网，我为 private-spacy-1 添加了目的地 0.0.0.0/0 和目标 NAT spaCy 1 ，为 private-spacy-2 添加了 NAT spaCy 2 。
创建弹性文件系统
在 EFS 控制台中，我选择创建文件系统并确保默认的 VPC 及其子网被选中。对于所有子网，我使用一个安全组，它允许网络访问 VPC 中的其他资源。为了简单起见，我设置了一个允许所有流量的安全组。
下一步，我给文件系统一个名称标签，并选择下一步。
然后，我选择添加接入点。我用1001表示User ID, Group ID, Owner User ID and Owner Group ID，用750表示权限。另外，我限制了对/models路径的访问。
EFS 的创作完成了。让我们进入下一步。
将空间发布到 Lambda 图层
下一步，我们将空间发布为 Lambda 图层。我们必须做到以下几点:
- 安装空间
- 将其压缩为 Zip 文件
- 将文件发布到 Lambda 层
为了简单起见，我准备了以下 shell 脚本:
你只需要像sh publish_spacy_as_lambda_layer.sh一样执行它。
创建 Lambda 函数
接下来，我们创建一个 Lambda 函数。在 Lambda 控制台中，创建一个函数并选择 Python 3.7 作为运行时。对于权限，选择一个附加了策略AWSLambdaVPCAccessExecutionRole和AmazonElasticFileSystemClientReadWriteAccess的角色。
创建函数后，我们设置 VPC 配置。这里，我们需要指定与我们为 EFS 装载点指定的相同的安全组和 VPC，并选择专用子网。
然后，我们选择**添加文件系统。**我们选择之前已经创建的 ESF 和接入点。这里，我们将/mnt/models设置为本地挂载点。这是安装接入点的路径，对应于 EFS 中的/models目录。
在图层部分，我们选择添加一个图层来添加空间。
在函数编辑器中，复制并粘贴以下代码。
最后，我们应该增加内存分配和超时值。如果内存分配不够大，将会出现以下错误。
{
"errorType": "Runtime.ExitError",
"errorMessage": "RequestId: Error: Runtime exited with error: signal: killed"
}
作为测试，当我用数据{"text": "He works at Google."}测试时，会返回如下响应。
[
{
"text": "Google",
"label": "ORG",
"start": 12,
"end": 18
}
]
参考
用 Presto 在 S3 加载和查询 CSV 文件
如何在 S3 用 Presto 加载和查询 CSV 文件
在大数据领域，这是一项如此简单而常见的任务，我想人们肯定已经做过一千次了，所以当一位客户问我这个问题时，我直接上网，试图找到一些好的例子与客户分享。你猜怎么着？我找不到！所以我决定自己写一个。
使用 Presto 和 S3 的典型数据 ETL 流程如下所示:
- 上传 CSV 文件到 S3。
- 把 S3 的 CSV 文件加载到 Presto。
- (可选)转换为 Parquet 或 ORC 中的分析优化格式。
- 对 Parquet 或 ORC 表运行复杂的查询。
在这篇博客中，我使用了纽约市 2018 黄色出租车旅行数据集。数据集有 1.12 亿行，每行 17 列，采用 CSV 格式。总大小为 9.8GB。
以下是一些示例数据:
head -n 3 tlc_yellow_trips_2018.csvVendorID,tpep_pickup_datetime,tpep_dropoff_datetime,passenger_count,trip_distance,RatecodeID,store_and_fwd_flag,PULocationID,DOLocationID,payment_type,fare_amount,extra,mta_tax,tip_amount,tolls_amount,improvement_surcharge,total_amount
2,05/19/2018 11:51:48 PM,05/20/2018 12:07:31 AM,1,2.01,1,N,48,158,2,11.5,0.5,0.5,0,0,0.3,12.8
1,05/19/2018 11:22:53 PM,05/19/2018 11:35:14 PM,1,1.3,1,N,142,164,2,9,0.5,0.5,0,0,0.3,10.3
1,05/19/2018 11:37:02 PM,05/19/2018 11:52:41 PM,1,2.2,1,N,164,114,1,11,0.5,0.5,3.05,0,0.3,15.35
我假设你已经完成了一个基本的普雷斯托和 S3 设置。您还需要在 Presto 中设置 Hive 目录，以便它查询 S3 的数据。如果你还没有，请看看我的博客与 Kubernetes 和 S3-部署。
上传 CSV 文件到 S3
在 S3 创建一个目录来存储 CSV 文件。我们可以使用任何 S3 客户端来创建 S3 目录，这里我简单地使用了hdfs命令，因为它在 Hive Metastore 节点上是可用的，是上述博客中 Hive 目录设置的一部分。
从配置单元 Metastore 节点运行以下命令。更改存储桶名称以匹配您的环境。注意，我将s3a://指定为目录路径模式，以便hdfs命令在 S3 而不是 HDFS 上创建目录。
hdfs dfs -mkdir -p s3a://deephub/warehouse/nyc_text.db/tlc_yellow_trips_2018
将 CSV 文件上传到我们刚刚创建的目录下的 S3。任何 S3 客户端都可以工作，我使用 s5cmd ，一个非常快的 S3 客户端，上传 CSV 文件到我的 S3 目录。这里我使用 FlashBlade S3，所以我将endpoint-url指定给我的 FlashBlade 数据 VIP。
s5cmd --endpoint-url=[http://192.168.170.12:80](http://192.168.170.12:80) cp tlc_yellow_trips_2018.csv s3://deephub/warehouse/nyc_text.db/tlc_yellow_trips_2018/tlc_yellow_trips_2018.csv
将 CSV 文件加载到 Presto
为了在 S3 查询数据，我需要在 Presto 中创建一个表，并将其模式和位置映射到 CSV 文件。
启动 Presto CLI:
presto-cli --server <coordinate_node:port> --catalog hive
使用 Presto CLI 为文本数据创建新的模式。
presto> CREATE SCHEMA nyc_text WITH (LOCATION = 's3a://deephub/warehouse/nyc_text.db');
为 CSV 数据创建外部表。您可以在一个模式下创建多个表。注意事项:
- CSV 格式的表格目前只支持
VARCHAR数据类型。 - 我将
skip_header_line_count = 1设置为 table 属性，以便跳过 CSV 文件中的第一行标题。如果您的 CSV 文件不包含标题，请删除此属性。 - Presto 的 CSV 格式支持需要
metastore-site.xmlHive Metastore 配置文件中的metastore.storage.schema.reader.impl=org.apache.hadoop.hive.metastore.SerDeStorageSchemaReader。
presto> CREATE TABLE hive.nyc_text.tlc_yellow_trips_2018 (
vendorid VARCHAR,
tpep_pickup_datetime VARCHAR,
tpep_dropoff_datetime VARCHAR,
passenger_count VARCHAR,
trip_distance VARCHAR,
ratecodeid VARCHAR,
store_and_fwd_flag VARCHAR,
pulocationid VARCHAR,
dolocationid VARCHAR,
payment_type VARCHAR,
fare_amount VARCHAR,
extra VARCHAR,
mta_tax VARCHAR,
tip_amount VARCHAR,
tolls_amount VARCHAR,
improvement_surcharge VARCHAR,
total_amount VARCHAR)
WITH (FORMAT = 'CSV',
skip_header_line_count = 1,
EXTERNAL_LOCATION = 's3a://deephub/warehouse/nyc_text.db/tlc_yellow_trips_2018')
;
现在我可以查询 CSV 数据了。
presto> SELECT * FROM nyc_text.tlc_yellow_trips_2018 LIMIT 10;
此时，我可以将 Tableau 连接到并可视化 Presto 表中的数据。但由于 CSV 格式表只支持VARCHAR数据类型，可能会暴露对 Tableau 的限制。如果是这种情况，请将 CSV 转换为拼花或 ORC 格式(见下文)。拼花或 ORC 表通常比文本/CSV 表具有更好的性能。
(可选)将 CSV 转换为拼花格式
这是一个可选的任务，但是如果数据将被多次查询，则建议使用任务。通过在 Parquet 或 ORC 中将文本数据转换为分析优化格式，它不仅提高了查询性能，还减少了服务器和存储资源消耗。
Presto 适用于可以在 SQL 中完成的简单转换。对于那些使用 SQL 无法轻松完成的复杂业务逻辑(例如，需要 Java/Python 编程)，最好使用 Apache Spark。在这个例子中，我只是将文本转换成 Parquet 格式，而没有引入任何复杂的业务逻辑，所以我将使用 Presto 进行转换。
在 Presto 中管理数据的一个常见做法是对原始文本(CSV/TSV)表和优化的(Parquet/ORC)表使用不同的模式。所以我将为镶木地板桌子创建一个新的模式nyc_parq。
为新模式创建一个 S3 目录。更改存储桶名称以匹配您的环境。
hdfs dfs -mkdir -p s3a://deephub/warehouse/nyc_parq.db
在 Presto CLI 中创建nyc_parq模式。
presto> CREATE SCHEMA nyc_parq WITH (LOCATION = 's3a://deephub/warehouse/nyc_parq.db');
创建镶木地板表，将 CSV 数据转换为镶木地板格式。您可以更改SELECT原因来添加简单的业务和转换逻辑。
presto> CREATE TABLE hive.nyc_parq.tlc_yellow_trips_2018
COMMENT '2018 Newyork City taxi data'
WITH (FORMAT = 'PARQUET')
AS
SELECT
cast(vendorid as INTEGER) as vendorid,
date_parse(tpep_pickup_datetime, '%m/%d/%Y %h:%i:%s %p') as tpep_pickup_datetime,
date_parse(tpep_dropoff_datetime, '%m/%d/%Y %h:%i:%s %p') as tpep_dropoff_datetime,
cast(passenger_count as SMALLINT) as passenger_count,
cast(trip_distance as DECIMAL(8, 2)) as trip_distance,
cast(ratecodeid as INTEGER) as ratecodeid,
cast(store_and_fwd_flag as CHAR(1)) as store_and_fwd_flag,
cast(pulocationid as INTEGER) as pulocationid,
cast(dolocationid as INTEGER) as dolocationid,
cast(payment_type as SMALLINT) as payment_type,
cast(fare_amount as DECIMAL(8, 2)) as fare_amount,
cast(extra as DECIMAL(8, 2)) as extra,
cast(mta_tax as DECIMAL(8, 2)) as mta_tax,
cast(tip_amount as DECIMAL(8, 2)) as tip_amount,
cast(tolls_amount as DECIMAL(8, 2)) as tolls_amount,
cast(improvement_surcharge as DECIMAL(8, 2)) as improvement_surcharge,
cast(total_amount as DECIMAL(8, 2)) as total_amount
FROM hive.nyc_text.tlc_yellow_trips_2018
;
根据数据大小，此转换可能需要一些时间。一旦完成，我就可以查询拼花地板数据。
presto> SELECT * FROM nyc_parq.tlc_yellow_trips_2018 LIMIT 10;
确认拼花桌的模式。注意此表中的列具有所需的类型。
presto> describe nyc_parq.tlc_yellow_trips_2018;
Column | Type | Extra | Comment
-----------------------+--------------+-------+---------
vendorid | integer | |
tpep_pickup_datetime | timestamp | |
tpep_dropoff_datetime | timestamp | |
passenger_count | smallint | |
trip_distance | decimal(8,2) | |
ratecodeid | integer | |
store_and_fwd_flag | char(1) | |
pulocationid | integer | |
dolocationid | integer | |
payment_type | smallint | |
fare_amount | decimal(8,2) | |
extra | decimal(8,2) | |
mta_tax | decimal(8,2) | |
tip_amount | decimal(8,2) | |
tolls_amount | decimal(8,2) | |
improvement_surcharge | decimal(8,2) | |
total_amount | decimal(8,2) | |
(17 rows)
最后，我配置我的分析应用程序/ Tableau 来使用优化的nyc_parq模式和拼花表。
高级主题
随着数据变得越来越大(例如超过 TB)，以对查询性能最佳的方式组织数据变得越来越重要。使用拼花地板或 ORC 共振峰是一种优化，还有其他优化，例如:
- 谓词下推。
- 分区表。
- 拼花地板和 ORC 中的数据排序。
- 加入战略和基于成本的优化。
这些主题不是 Presto 特定的，它们适用于大多数存储和查询引擎，包括 S3 和 Presto。这些话题的细节超出了本博客的范围。请继续关注我的博客。
使用亚马逊 SageMaker 和雪花构建流失预测模型
亨特·哈里特在 Unsplash 上的照片
一个展示如何使用 Sagemaker 从 Snowflake 中的销售和客户数据预测客户流失的设置。
雪花已经成为最受欢迎的数据仓库之一，可以用来构建您的分析堆栈。雪花的一个好处是，您可以轻松地将其与 BI 工具或托管机器学习模型等其他云服务相连接，以从您的数据中获得更好的洞察力。
亚马逊 SageMaker 是一项完全托管的服务，帮助公司在 AWS 上训练和部署机器学习模型。SageMaker 通过发送带有需要预测的数据的 HTTP 请求，使公司很容易根据模型进行预测。
在本文中，我们将展示如何使用存储在雪花中的关于客户和销售的历史数据，通过 SageMaker 来预测哪些客户会流失。通过分析这些预测的结果，你可以找到减少客户流失和预测未来业务表现的方法。
以下是我们的分解方式:
- 理解数据
- 设置我们的数据库并将数据加载到雪花中
- 设置 SageMaker，然后构建、培训和部署我们的 SageMaker 模型
- 在我们的模型上运行批量预测，并将数据发送回雪花进行分析
看一看数据
我们使用的数据集由移动运营商的历史记录信息组成，记录了最终用户和继续使用该服务的用户。这些数据是公开的，可以在加州大学欧文分校的机器学习数据集库中找到。
你可以从这里下载数据集。按照本教程，你应该解压缩下载的 zip 文件夹。
数据片段。最后一栏提到客户是否搅动。
这些数据描述了每个客户白天和晚上的语音邮件、消息、本地和国际电话的服务计划和使用统计。这种数据可能是您的业务在不同系统中孤立的，但是可以使用 ETL 进行集成。最后一栏提到客户是否搅动。稍后，我们将看到以这种方式构造的数据如何有助于训练机器学习模型。
这是一个相对较小的数据集，包含 3，333 条客户记录和描述每个客户资料的 21 个属性。最后一个称为 Churn 的属性是我们的目标属性。我们的目标是训练一个 ML 模型来预测目标属性。目标属性有两个值 True 或 False，因此这是一个二元分类任务。
将数据集加载到雪花
首先，登录到您的雪花 UI 并切换到工作表选项卡。
这些是我们准备数据库将采取的步骤。
- 为数据库&仓库创建角色&权限
切换到帐户管理员角色。该角色拥有创建新角色的权限。创建一个名为 sagemaker_role 的角色。我们将使用此角色授予该项目的资源所有权限。我们还允许 sysadmin 角色拥有所有 sagemaker_role 特权。
2。创建一个仓库，为查询数据库提供计算资源
仓库被配置为在不使用时自动挂起，这样可以节省成本。我们还将仓库的所有特权授予 sagemaker_role。
3。创建一个数据库来存储我们的数据集
我们切换到 sysadmin 角色，因为它拥有创建数据库对象的权限。我们创建数据库，然后将默认公共模式上的所有特权授予 sagemaker_role。
4。创建客户流失表来加载我们的数据
我们首先将工作表的上下文设置为 ml_workshop 公共模式，并使用我们的 sagemaker_wh 仓库。我们还将表上的所有特权授予 sagemaker_role。
然后我们用上面定义的数据类型创建我们的表。
5。为我们的数据集创建一个文件格式
我们正在处理结构化的、逗号分隔的数据。我们从 S3 下载的文件没有标题。
6。将数据加载到表格
要将数据加载到 web UI 上的表中，我们必须使用加载数据向导，因为 web UI 上的工作表不支持某些雪花命令。要加载数据，切换到 databases 选项卡，单击 ml_workshop 数据库，然后单击 customer_churn 表。然后单击 load table 按钮，按照向导进行操作。确保使用正确的仓库和文件格式。
您的数据应该被加载。
现在，您可以在工作表上进行一些快速分析。尝试以下查询，为有语音邮件计划的客户获取各州的平均语音邮件消息。
7。为外部服务创建一个新用户以连接到雪花
在这里，我们创建一个名为 sagemaker 的新用户，并提供一个密码。记下密码，因为以后会用到它。Amazon Sagemaker 稍后将使用该用户连接到 Snowflake。我们将 sagemaker_role 及其所有特权授予 sagemaker 用户。
8。为来自 Amazon Sagemaker 的预测创建一个结果表
9。为 Amazon Sagemaker 的结果文件创建一个内部阶段
内部阶段将用于稍后在实验室中加载 Sagemaker 的预测结果。
第一部分到此结束。在下一部分中，我们将设置 Amazon SageMaker 来构建和部署模型。
在 AWS SageMaker 上部署客户流失预测模型
要开始使用 AWS SageMaker，我们需要在 AWS 上设置所有的依赖资源。其中包括 S3 存储桶、角色和权限以及 AWS Sagemaker 笔记本实例。S3 是一个数据湖。S3 存储桶可以被认为是云中的文件系统，允许您存储任何类型的文件。AWS Sagemaker 笔记本可以被视为一个编辑器和环境，允许我们编写代码来分析数据和训练模型。
我们将使用 cloudformation 模板部署我们需要的所有 AWS 资源。这是一个用 json 或 yaml 编写的文件，它包含关于我们想要部署的所有 AWS 资源以及这些资源的配置的信息。
首先，登录你的 AWS 账户，切换到 AWS Cloudformation 服务。然后转到堆栈并创建堆栈。我们将上传一个模板文件。下载这个模板文件并从你的电脑上传为 yaml 文件。然后单击下一步，键入堆栈的名称和笔记本实例的名称。笔记本实例类型描述了 AWS 将为您的笔记本部署的服务器的大小。对于本教程，ml.t2.medium 就足够了，不应该花费您超过几美元。然后在向导中单击下一步，直到您可以确认堆栈创建。
我不会在这里详细讨论如何编写 cloudformation 模板。只需知道，您也可以通过在 AWS 控制台中分别访问 S3 和 AWS SageMaker 资源并按照向导进行操作来部署这些资源。
堆栈现在需要一些时间来部署所需的资源。完成后，您应该会在 stack events 选项卡中看到类似这样的内容。
在“输出”选项卡中，您应该会看到您的 S3 存储段名称。把它抄下来，因为我们以后会用到它。
切换到 Amazon SageMaker 服务并转到笔记本实例。您应该看到您的笔记本名称，单击“操作”下的“打开 Jupyter”以打开笔记本环境。点击 new，conda_python3 notebook，用 python3 环境打开一个笔记本。
接下来，我们将编写 python 代码来查询来自雪花数据仓库的数据，为训练和测试做准备，并训练一个分类模型。
- 导入所需库
在 bucket 变量中，将占位符替换为您之前复制的 bucket 的名称。
2。创建到雪花的连接
现在，我们使用雪花连接器库创建一个到雪花帐户的连接，这样我们就可以查询所需的数据。为了创建连接
3。从雪花中查询数据
4。准备建模数据
我们略过了对选择训练属性的解释，因为本文的目的是展示构建模型的更高层次的过程。
我们删除了 phone 列，因为它有太多没有实际用途的独特值。此外，我们将区号转换为字符串，以将其转换为分类属性。接下来，我们看看属性之间的相关性。如果一对属性是高度相关的，我们从对中删除其中一个属性。
最后，我们通过将表转换为虚拟表，将每个属性从分类属性转换为数字属性。
5。将数据分为训练集、测试集和验证集
分割数据有助于我们避免过度拟合模型，并允许我们在尚未看到的验证数据上测试模型的准确性。
然后，我们将数据保存在笔记本的本地目录中，然后将数据上传到 S3。稍后，Sagemaker 模型将为数据寻找 S3 路径。
6。训练模型
既然我们已经准备好了数据，我们可以选择一个模型。在本教程中，我们将使用像 XGBoost 这样的梯度提升树算法来模拟这个问题。
这就是亚马逊 Sagemaker 的真正价值所在。它为各种模型提供容器，这些模型可用于训练模型，然后将模型作为端点托管，作为进行实时预测的端点。然后，可以通过 HTTP 请求向端点提供数据，以进行预测。
下面是我们为 xgboost 初始化容器的方法
然后，我们通过将 sagemaker 输入对象引用到我们保存培训和验证文件的 S3 位置来准备我们的 csv 数据输入。
接下来，我们准备我们的评估器，它将调用模型容器来适应训练数据。我们指定了一个输出模型的 S3 输出路径。并且，我们给出了模型的超参数。查看此处了解 xgboost 超参数。
7。使用我们的模型预测原始数据的变动
如前所述，Sagemaker 的模型端点通过接收同步 HTTP 请求来工作。但这次我们打算使用 Sagemaker batch transform，这是一种理想的方法，因为它可以从 S3 获取大量数据，而且更具成本效益。
首先，我们准备原始数据，并将其保存到 S3。
然后我们称之为批量转换作业。由于作业异步运行，我们将等待作业完成后再继续。转换作业会将输出保存到 s3uri_batch_output。
然后，我们将从 s3 加载输出数据，并存储在笔记本中，以便我们可以将它发送回雪花。
8。将结果写入雪花
现在，我们使用雪花连接器将结果文件从 notebook 实例加载到我们之前在雪花中创建的 ml_results 阶段。
仅此而已。我们和 sagemaker 玩完了。
回到雪花
首先，我们将数据从 ml_results 阶段复制到 ml_results 表中。
让我们对我们的结果做一些分析
根据 sagemaker 模型的预测，以下查询返回客户流失可能性最高的地理位置。
如果你想清理你的资源以避免成本。运行以下命令:
在 AWS 上，您首先必须删除您的 S3 存储桶。在 S3 控制台上，选择您的存储桶，然后单击删除。然后回到 cloudformation，选择你的栈，点击 delete。
就这样……
客户流失分析和客户流失预测是众所周知的关键技术，有助于企业了解哪些是好的，哪些是不好的。不幸的是，企业并不总是有合适的数据基础设施来做好这种分析。在这里，我们向您展示了一个非常简单的设置，您可以在这里以低成本结合一些强大的云技术，让您的数据发挥作用，推动您的业务向前发展。
通过 waterfront analytics 联系我们，了解我们如何帮助您的企业。
将文件更快地加载到 BigQuery 中
针对摄取的 CSV、GZIP、AVRO 和拼花文件类型进行基准测试
oogle 云平台的 BigQuery 是一个用于分析的托管大规模数据仓库。它支持 JSON、CSV、PARQUET、OCR 和 AVRO 文件格式来导入表格。这些文件类型各有利弊，我已经谈过为什么我更喜欢这里的数据科学工作流的拼花。但是还有一个问题:
哪个文件扩展名能让我们最快地加载到 BigQuery 中？
让我们希望我们的文件加载速度会比拍摄这张照片的速度更快……—照片由安德斯·吉尔登在 Unsplash 上拍摄
要获得所有媒体文章的完整访问权限，包括我的文章，请考虑在此订阅。
实验
由于 AVRO 压缩数据的方式，它推荐快速摄取时间，但是现在谁会相信文档呢？我想亲眼看看哪种文件格式会胜出。
我很少使用 OCR，我在工作中主要使用 Python，这意味着我可以轻松地编写 CSV 和带压缩的拼花文件，所以我决定测试的文件类型列表是:
- CSV —完全没有压缩的逗号分隔文件
- CSV。GZIP——同上，但压缩了 GZIP。
- PARQUET——一种柱状存储格式，压缩速度很快，熊猫本身就支持这种格式。
- AVRO——GCP 推荐用于快速加载的二进制格式。
对于上述每种格式，我进行了 3 次实验:
- 导入小文件(5k 行)
- 导入大文件(50k 行)
- 导入大量较大的文件(20x50k 行)
为了模拟一个更真实的例子，我为列创建了一些不同的数据类型，以查看 BigQuery 如何处理它们。我使用了浮点数、整数、日期时间、高熵的长字符串和低熵的短字符串(每种数据类型有 50 列)。
创建数据
这是我想象中的数据挖掘工作——照片由张秀坤·万尼在 Unsplash 上拍摄
我总是更喜欢不需要你从互联网上获取数据的脚本，因为谁知道这些数据什么时候会消失，所以我决定使用sklearn.datasets模块来生成许多随机浮动列(250 个)并将它们转换成字符串、时间等。让我们开始吧:
随意窃取上面的内容，用它来生成其他你喜欢的数据集。
既然有了一个方便的小函数，那就来做一些文件吧。在撰写本文时，除了 AVRO 之外，我将在所有地方使用pandas,在pandas没有官方的 AVRO 支持😥。
我在这里通过重复小数据集在技术上作弊，但这就是生活…
现在，如果我的数学是正确的，我们应该有 8 个文件准备好发送到云。
比较文件大小
在我们开始将文件上传到 Google 云存储并将它们接收到 BigQuery 之前，让我们快速查看一下它们的大小。这将影响你在 GCS 中的上传时间和存储成本(但不是在 BigQuery 中！).我知道这听起来并不重要，但它确实很重要，所以我懒得告诉你这些——是的，我现在读了很多苏斯博士的书😃。
这些是漂亮的酒吧🍫：
这里需要注意一些重要的事情:
- 如果你还在使用拨号调制解调器或者你的宽带速度慢得像蜗牛，不要使用 CSV…
- 当谈到小文件时，看看 GZIP 和所有其他人相比是多么的小。
- 正如在 5k 行文件上看到的，PARQUET 的开销最大，但是当有重复数据时，它会逐列压缩表，因此存储重复值变得非常便宜。对于较大的文件，可以考虑使用拼花地板。
准备 GCP 环境
为快速加载做好准备——照片由 Gabriel Alenius 在 Unsplash 上拍摄
下一步是创建一个存储桶，我们可以上传我们珍贵的小文件。
将 GCS bucket 和 BigQuery 实例设置在同一个区域非常重要——否则，BigQuery 将拒绝加载文件。我还为我的表设置了一个超时，因为我容易忘记事情，也不太热衷于为谷歌保存我的随机值表付费😆。
锤击 BigQuery
让我们回顾一下:
- generated☑随机文件
- 储水桶创造了☑
- 大查询数据集已初始化☑
- 上传到 gcs 的文件
现在，我们只需将文件导入 BigQuery，看看谁会胜出。嗯，差不多了。问题是，由于网络流量和 BigQuery 执行的其他任务，文件摄取时间可能会有微小的变化，所以让我们将每个文件上传几次，看看它们平均起来如何，而不是只比较每个文件的一次摄取。Python 的功能提供了帮助:
在这里，我将文件复制到一个新位置(可选地，复制多次),然后创建repeat多个 BigQuery 表。这里需要注意的一个技巧是负载是异步的，所以首先我触发作业，然后用job.result()等待结果。
由于所有文件都有不同的格式，我们还需要创建一些不同的JobConfig,以便 BigQuery 知道如何处理它们。
让我们开始锤打🔨先处理小文件的 BigQuery:
结果并不令人惊讶。AVRO 名列前茅，而其他人都差不多，我猜是因为开销的原因，镶木地板落后了？
AVRO 速度很快。
我还用大文件重复了这个实验——代码在我的 GitHub 上。以下是大文件(50k 行)的结果:
拼花地板在这里做得更好，但远没有 AVRO 快。
为了让它更有趣，我重复了上面的步骤，但是每种文件类型有 20 个文件来模拟一些更大的工作负载。
从上面可以看出，对于较小的表格，文件格式并不重要。但是随着文件变得越来越大，您应该考虑使用内置压缩的格式。在实际工作负载中加载压缩的 GZIP 文件将比未压缩的 CSV 文件快得多，我假设这主要是由于文件的大小。
AVRO 加载时间确实令人印象深刻，几乎是 CSV 文件速度的两倍。
PARQUET 做得也不差，在大文件方面排在第二位。
烦恼😖
在进行这个实验时，我遇到了几件令我烦恼的事情。我在这里抱怨这些。
首先，为什么 BigQuery 和 Storage Python SDKs 不一致？要删除一个数据集，您可以使用client.delete_dataset，但是要删除一个存储桶，您必须使用blob.delete:
其次，当我为每种格式加载 10x 文件时，PARQUET 比其他任何格式都慢很多。奇怪的是，它比 20 倍拼花文件还慢。如果有人知道为什么(或者如果你在我的代码中发现了一个 bug)请在评论中告诉我。
加载 10x 文件产生奇怪的拼花结果
结论
AVRO 是最快的！如果需要尽快将文件加载到 BigQuery 中，可以使用 AVRO。但是，如果您在 GCP 之外生成文件(或者如果您需要在 GCS 上保存文件的副本)，请考虑使用 PARQUET，因为它的文件大小要小得多，加载速度也相对较快。
以上所有代码可在 GitHub 这里 获得。
关于我写的更多 BigQuery，请查看我的文章《为什么我更喜欢拼花而不是 CSV:
使用 Python 将拼花和 CSV 文件导入 GCP BigQuery
towardsdatascience.com](/loading-files-into-bigquery-6de1ff63df35)
或者如果你想尝试一下，看看这篇关于如何用 BigQuery 免费计算斐波那契数的文章:
在 BigQuery 中使用用户定义的 JavaScript 函数来计算 Fibonacci
towardsdatascience.com](/fibonacci-series-with-user-defined-functions-in-bigquery-f72e3e360ce6)
如何对实时管道进行负载测试？
借助 JMeter 对基于流水线的实时 AWS kine sis API 进行负载测试
所以，我在做一个实时管道，在设置好之后，我的下一步是它的负载测试，因为我还没有危险到可以马上生产它！
为我们在生产中遇到的问题默哀一分钟。
好了，一分钟结束了。回到用例，我期望我的管道平均每秒 100 条记录。此外，我想找到我的管道的阈值:在断裂之前它可以承受多少负载。
我用于负载测试的工具是，JMeter。我在作为测试人员的实习期间学会了如何使用 JMeter，作为一名大数据工程师，我能够再次应用所学的技能，这真是太神奇了。的确，知识从来不会浪费。
在更高的层次上，我的管道通过 API 接受输入，因此我的负载测试减少到 API 的负载，下面是我在简单步骤中所做的:
步骤 1:下载并安装 JMeter
目前我用的是 Windows 机(不要评判好吗？这都是因为这种 COVID 的情况，我无法访问我的笔记本电脑)。那么，下面是如何在我的 Windows 上进行设置的:
-安装& setup Java(如果还没有安装的话)
-从下载 JMeter 到这里
-解压
-运行解压后的文件夹> bin > jmeter.bat
-瞧，GUI 将被启动。
启动后的 JMeter GUI
步骤 2:创建一个测试计划
- 通过点击 File > New 创建一个新的测试计划
- 右键单击测试计划>添加>线程(用户) >线程组
步骤 3:添加应用程序接口详细信息
- 右键单击线程组>添加>采样器> HTTP 请求
- 在“HTTP 请求”选项卡中，指定协议、服务器名称、HTTP 请求、端点和请求正文。如果需要，添加任何其他详细信息。它应该看起来像这样:
- 您还可以探索像 HTTP header manager、HTTP Request Defaults 这样的采样器，如果它适合您的用例的话。它们非常简单明了。
步骤 4:添加监听器
- 为了查看和记录负载测试的结果，我们需要添加一个侦听器。
- 右键单击线程组>添加>监听器>查看表中的结果
- 如果需要更多详细信息以及进行详细调试，可以类似地添加查看结果树侦听器。与 API 失败的情况一样，详细的响应对于调试非常有用。
步骤 5:设置负载测试指标
- 只需点击即可进入线程组选项卡。
- 添加线程属性，因为我希望在无限长的持续时间内(直到我停止测试)有 100/s 的负载，所以我做了这样的事情:
步骤 5:运行测试
- 按顶部的播放按钮运行测试。
- 如果设置成功，您将开始在 listeners:View Results Table/View Results Tree 中看到 API 响应。
- 如果没有，您可以通过工具栏中的选项>日志查看器来启用 JMeter 日志。日志显示在右下角。
- 这样，您就可以在系统上生成所需的测试负载。
需要注意的事项:
- 在从您的机器开始负载测试之前，请确保您可以访问 API。
- 大多数参数都是不言自明的，请参考文档以了解更多信息或各种用例。
- 尽管它对我的用例来说工作得很好，但是通常不推荐通过 GUI 进行负载测试。因此，如果您正在处理更高的负载，请参考非 GUI 模式下 JMeter 使用的文档。
测试愉快！！
Ciao。
在 QGIS 中加载 3D 城市模型
利用 QGIS 开发 CityJSON 三维城市模型。
德文·艾弗里在 Unsplash 上的照片
在地理空间数据科学中，三维数据模型最近在研究和可视化项目中发挥了重要作用。QGIS 是每个 GIS 极客都知道的最流行的免费开源跨平台桌面 GIS 应用软件之一。从 QGIS 的 3.0 版本开始，单独的界面负责点云和数字高程模型的 3D 数据可视化。它被称为 3D 地图视图，可从视图快捷菜单中访问。
然而，建筑物或城市模型在 3D GIS 项目中可视化的通常方式是通过挤压建筑物覆盖区。这将导致细节级别为-1。2020 年，用于在 QGIS 中加载 CityJSON 3D 城市模型的 QGIS 插件已经开发完成[1]。因此，可以在更高的细节层次上可视化建筑模型。本文将通过一些例子介绍如何使用这个插件来加载 CityJSON 3D 城市模型。
CityGML 和 CityJSON
在 3D 数据世界中，3D 城市模型已经用于许多应用领域，例如 3D 地籍、设施管理和应急响应。用于 3D 城市模型的最流行的数据模式之一是 OGC 城市 GML，其是用于描述 3D 地理空间使能的城市模型的全球数据模型；由 OGC(开放地理空间联盟)开发。然而，它是基于 GML 编码的，具有复杂的性质和较差的互操作性。出于这个原因，CityJSON 一直被开发为一种易于使用的 JavaScript 对象表示法(JSON)编码，用于使用 CityGML 2.0 数据模型的 3D 城市模型。
您可以查看这篇文章以了解可用的开源 CityGML 数据集。
从 CityGML = >到 CityJSON
任何 CityGML 数据集都可以使用 **citygml 工具转换成 CityJSON 格式。**它是一个命令行实用程序，捆绑了几个处理 CityGML 文件的操作。(检查此连杆)
然后，您可以使用以下命令转换您的 CityGML 数据:
**$ citygml-tools to-cityjson /path/to/your/CityGML.gml**
正在 QGIS 中加载 CityJSON
安装 QGIS 和 CityJSON 加载器插件。
你可以从这里下载并安装最新版本的 QGIS。然后打开插件窗口( Plugins = >管理安装插件)，找到 CityJSON 加载器。
QGIS 软件中的插件窗口。(作者)
加载并可视化 CityJSON
安装 CityJSON 加载程序后，您可以使用它来加载 CityJSON 文件。可以在矢量菜单下找到(Vector =>city JSON Loader =>Load city JSON…)。
QGIS 软件中的 CityJSON 加载器插件窗口。(作者)
例如，您可以尝试 CityJSON 格式的海牙 3D 城市模型的这个数据集。加载 CityJSON 之前，请检查元数据中的 EPSG 代码，并设置项目坐标参考系统(CRS)以匹配数据集的 EPSG 代码，从而确保正确加载数据集。
您可以从 QGIS 窗口的右下角设置项目 CRS，如下图所示。
在 QGIS 软件中设置项目 CRS。(作者)
将 CityJSON 加载到 QGIS 项目后，您可以通过打开新的 3D 地图视图(View =>New 3D Map View[Ctrl+Alt+m])以 3D 方式对其进行可视化。下图是海牙 CityJSON 模型的一个例子。[~2.9 Mb]。
在 QGIS 软件中可视化的海牙城市 JSON 模型。(作者)
下一步？
在探索了 3D 城市模型之后，将 3D 城市模型用于现实世界的项目有很多可能性；举个例子，
- 使用 3D 城市模型构建 3D 网络地图应用
- 探索更多开源 3D 城市模型。
- 使用 QGIS & QuickOSM 从 OSM 下载开源数据。
- 或者说，你为什么不试着在 Unity3D 里把它和你的游戏项目融合起来呢？
- 而且，多得多！
结论
这篇短文介绍了 CityJSON3D 城市模型的轻量级 3D 城市模型编码，展示了如何在开源 GIS 桌面软件 QGIS 中可视化这些数据模型。我希望你喜欢这篇文章，并发现它对你的日常工作或项目有用。如果您有任何问题或意见，请随时给我留言。
关于我&查看我所有的博客内容:链接
安全健康和健康！💪
感谢您的阅读。📚
参考
[1] Stelios Vitalis，Ken Arroyo Ohori，Jan tien Stoter:CityJSON in QGIS:开发一个开源插件https://doi.org/10.1111/tgis.12657(2020)。
在 Python 中加载和保存图像
使用 PIL、OpenCV 和 Matplotib 加载和保存图像的简单方法
先决条件:
安装 PIL、OpenCV 和 matplotlib 库。
在新窗口中使用 PIL 加载图像
Show()在新窗口中加载图像
**from PIL import Image
img_PIL = Image.open(r'\dogs-v-cats\dog.1.jpg')
img_PIL.show()**
使用 PIL 内嵌加载图像
display()加载图像内嵌
**from IPython.display import display
from PIL import Image
img_PIL = Image.open(r'\dogs-v-cats\dog.1.jpg')
display(img_PIL)**
使用 PIL 保存图像
您可以使用 PIL 的***【save()***将 JPEG 图像保存为类似 PNG 的不同格式
**img_PIL.save(r'\dogs-v-cats\dog.1.png')**
使用 OpenCV 加载图像
**import cv2
image_cv2= cv2.imread(r'\dogs-v-cats\dog.1.png')
cv2.imshow("Dog Image using OpenCV", image_cv2)
cv2.waitKey(0)
cv2.destroyAllWindows()**
imread()读取图像。
第一个参数是包含图像的路径。第二个参数是一个标志，它告诉我们应该如何读取图像。标志参数的选项是
- cv2。IMREAD_COLOR 或 1:这是默认值，将加载彩色图像
- cv2。im read _ gray 或 0:将加载灰度图像
- cv2。IMREAD_UNCHANGED 或-1:加载图像，包括 alpha 通道。
imshow()在窗口中显示图像
第一个参数是窗口名称，第二个参数是图像。
waitKey()是一个键盘绑定函数。
如果您指定一个非 0 的数值，那么它将为任何键盘事件等待指定的毫秒数。如果你按任何键，那么程序将继续。如果将值指定为 0，那么它将无限期等待
destroyAllWindows()将销毁所有创建的窗口。
要销毁特定的窗口，可以使用***destroy window()***将窗口名传递给它
**import cv2**
**image_cv2= cv2.imread(r'\dogs-v-cats\dog.1.png')
cv2.imshow("Dog Image using OpenCV", image_cv2)**
**cv2.waitKey(6000)
cv2.destroyWindow("Dog Image using OpenCV")**
使用 OpenCV 保存图像
**result=cv2.imwrite(r'\dogs-v-cats\dog.100.png’, image_cv2)
if result==True:
print(“File saved successfully”)
else:
print(“Error in saving file”)**
imwrite()将图像文件保存到指定路径 。第一个参数是要保存文件的路径，第二个参数是要保存的图像。
使用 matplotlib 加载图像
**import matplotlib.pyplot as plt
import matplotlib.image as mpimg
%matplotlib inline****image_mp= mpimg.imread(r'\dogs-v-cats\dog.1.jpg')
imgplot=plt.imshow(image_mp)
plt.plot()**
matplotlib 的 imread()将指定路径的图像文件读入数组。 第二个参数是可选的，指定文件的格式，如“JPEG”或“PNG”。默认值为“PNG”。’
matplotlib 的 imshow()将数据数组显示为图像
您也可以使用 plt.show() 来显示图像
**import matplotlib.pyplot as plt
import matplotlib.image as mpimg
%matplotlib inline
image_mp= mpimg.imread(r'\dogs-v-cats\dog.1.jpg’, “JPG”)
imgplot=plt.imshow(image_mp)
plt.show()**
使用 matplotlib 保存图像文件
**plt.savefig(r'\dogs-v-cats\dog.2.png')**
savefig()将当前图保存到指定文件
结论:
Python 有几个库，如 OpenCV、PIL 和 matplotlib，可以用来加载和保存图像。在下一篇文章中，您将学习不同的图像处理技术，如旋转图像、去除图像噪声、裁剪图像、将 RGB 图像转换为灰度图像、增加图像的清晰度。
参考资料:
[## 图像入门— OpenCV-Python 教程 1 文档
cv2.waitKey()是一个键盘绑定函数。它的参数是以毫秒为单位的时间。该功能等待…
opencv-python-tutro als . readthedocs . io](https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_gui/py_image_display/py_image_display.html) [## 模板匹配— OpenCV-Python 教程 1 文档
在这一章中，你将学习使用模板匹配在图像中查找对象，你将看到这些函数…
opencv-python-tutro als . readthedocs . io](https://opencv-python-tutroals.readthedocs.io/en/latest/py_tutorials/py_imgproc/py_template_matching/py_template_matching.html)
将二进制数据加载到 NumPy/Pandas
如何有效地加载您的数据并返回分析！
图片由皮克斯拜的 Gerd Altmann 提供
在现实世界中，数据并不总是打包在整洁、易于加载的文件中。有时，您的数据会以晦涩的二进制或不规则结构的文本格式存在，并且在没有任何高效的基于 Python 的加载器的情况下到达您的家门口。对于少量的数据，使用简单的原生 Python 组装一个定制加载器通常很容易。但是对于更大的数据，纯 Python 解决方案可能会变得慢得令人无法接受，此时，是时候投资构建更快的东西了。
在本文中，我将向您展示如何使用内置函数、C-API 和 Cython 的组合来快速、轻松地为 NumPy/Pandas 组装您自己的超快速定制数据加载器。首先，我们将回顾一个常用于存储二进制数据的通用结构，然后编写代码来加载一些样本数据。在这一过程中，我们将简要介绍 C-API 和 Python 缓冲协议，以便您理解所有部分是如何工作的。这里有很多，但是不要担心——这些都非常简单，我们将确保代码中最重要的部分是通用的和可重用的。你也可以带着工作笔记本来这里。当我们完成后，您将能够轻松地将代码调整到您特定的数据格式，并继续进行分析！
二进制数据格式
出于我们的目的，二进制数据文件只不过是一个大的字节数组，它编码了一系列数据元素，如整数、浮点数或字符数组。虽然二进制编码有多种格式，但一种常见的格式是由一系列背靠背存储的单个“记录”组成的。在每个记录中，第一个字节通常编码指定记录长度(以字节为单位)的标题，以及允许用户解码数据的其他标识信息。
通常，文件中会有多种记录类型，所有记录类型都有一个通用的标题格式。例如，来自汽车计算机的二进制数据可能有一种记录类型用于驾驶员控制，如制动踏板和方向盘位置，另一种记录类型用于记录发动机统计数据，如油耗和温度。
为了加载二进制数据，您需要参考二进制格式的文档，以准确了解字节如何编码数据。出于演示的目的，我们将使用如下所示的示例数据:
作者图片
在下一节中，我们将看到如何处理数据只包含单一记录类型的简单情况
加载具有单一记录类型的二进制数据
假设我们有一些具有上面给出的记录布局的数据，其中所有记录都有一个相同的 9 字节消息体:
- 前 4 个字节编码一个 32 位整数
- 接下来的 5 个字节编码一个字符数组
我们将首先把我们的数据加载到一个 NumPy 数组中，完成后，只需一行代码就可以创建一个 Pandas 数据帧。
这里唯一棘手的部分是 NumPy 数组只能保存单一类型的数据，而我们的数据同时包含整数和字符数组。幸运的是，numpy 允许我们用多个子组件定义结构化类型。所以我们要做的是构造一个 NumPy 数据类型，它与我们的二进制记录具有相同的结构。如果您想读取 NumPy dtype 文档，您可以在这里做操作，但是指定 dtype 真的非常简单。下面是一个与我们的示例二进制数据格式相匹配的 dtype:
定义了我们的 dtype 后，我们可以继续用几行代码加载数据:
就是这样！再简单不过了，对吧？需要注意的一点是，我们的数据中的 name 列保存的是类型为bytes的对象。我们可能更愿意使用字符串，所以让我们使用 Series.str.decode()方法来完成从bytes到str对象的转换:
在上面的代码片段中，我们首先将二进制文件加载到一个字节数组中，然后用函数[np.frombuffer](https://numpy.org/doc/stable/reference/generated/numpy.frombuffer.html)创建了一个 NumPy 数组。或者，您可以通过使用函数[np.fromfile](https://numpy.org/doc/stable/reference/generated/numpy.fromfile.html)将这两个步骤结合起来，但是手动挖掘您的二进制数据并四处查看有时会很有用。如果你需要一个关于如何在 Python 中操作和查看字节数据的快速入门或复习，看看这个笔记本，我把它作为本文的快速教程参考。
多记录类型的二进制数据怎么办？
像上面那样加载数据非常容易，但不幸的是二进制数据通常没有这么好的结构。通常有许多不同的记录类型混合在一个文件中，我们需要一种方法将它们加载到一个或多个数据帧中。
这里的挑战是 NumPy 只知道如何加载以“简单”格式存储的二进制数据，其中数据存在于由背靠背堆叠的相同记录组成的连续内存块中。在上面的例子中，我们的数据只有一个固定长度的记录类型，这使得加载非常容易。
一般来说，为了将二进制数据加载到 NumPy，我们需要将它分成一个或多个同构数组，如下所示:
作者图片
完成上述分割的一种方法是编写一些预处理代码(选择您想要的任何语言)来将二进制数据分割成一个或多个文件。如果你走这条路，那么你可以简单地做你的预处理，然后像我们上面做的那样加载单独的文件。这种方法的缺点是，预处理会在磁盘上创建数据的多个副本，这不是很优雅，而且可能会很麻烦。
因此，我们将展示如何在 Cython 中设置内存数组，每个数组对应我们感兴趣的记录类型，并高效地用二进制记录填充它们，而不是写出单独的文件。然后，我们将通过使用 Python C-API 中的缓冲协议向 NumPy 公开这些数组。我们可以在原生 Python 中完成所有这些工作，但是我们将使用 Cython，因为我们希望我们的解决方案很快(二进制文件有时相当大)。
Python C-API 和缓冲协议
Python C-API 是 Python 低级实现的入口。它允许程序员用 C/C++编写的代码来扩展 Python，也允许你将 Python 嵌入到其他编程语言中。不过，我们不需要了解太多关于 C-API 的知识。我们所需要的是对缓冲协议的高度理解。
缓冲协议在 C-API 级别运行，定义了 Python 对象访问和共享彼此内存的方式。当我们在一个实现缓冲协议的对象上调用np.frombuffer时，NumPy 进入 C-API 并向该对象请求其内部内存的视图。如果成功，NumPy 将继续使用共享数据建立一个阵列。请注意，这里没有进行复制！在调用np.frombuffer之后，原始的缓冲区对象和 NumPy 数组共享同一个底层内存。该流程的简化版本如下所示:
作者图片
我们不直接使用 C-API，而是通过 Cython 与 C-API 进行交互，因为这比直接用 C/C++编写代码容易得多。正如您将看到的，从 Cython 实现缓冲协议也非常容易。
执行缓冲协议
Cython 是 Python 的扩展，是 Python 和 C/C++的结合。从 Cython 编译的代码通常比原生 Python 运行得快得多，并使您能够使用 C/C++库中的函数和类。我们不会在本文中介绍 Cython，但有许多介绍性教程——例如这里的和这里的。
幸运的是，实现 Cython 的缓冲协议非常容易。我们需要做的就是实现两个方法 getbuffer 和 releasebuffer。在幕后，Cython 对这些进行了一些特殊的处理，以便它们能够正确地绑定到 C-API 中的对象，但我们不需要担心这一点。我们需要做的就是实现这两个方法，在我们的例子中它们都很简单。他们是这样做的:
*getbuffer(self，Py_buffer ，int) 任何想要查看内存的消费者对象都会调用这个方法。它有两个参数:一个位标志的整数，一个指向 Py_buffer 类型的对象的指针，这是一个简单的 C 结构，包含我们需要填充的字段。这些标志表示消费者期望的数据格式的详细信息。在我们的例子中，我们只支持最简单的类型，即存储在连续内存块中的一维数据。因此，我们在 getbuffer 中所要做的就是检查这些标志是否指示了一个简单的缓冲区，然后在 Py_buffer 结构中填充一些不言自明的字段(参见下面的代码)。
releasebuffer(self，Py_buffer *)_ _ release buffer _ _ 的作用是允许引用计数，这样我们的代码就知道什么时候可以释放和/或重新分配 Py _ buffer 结构中的内存。然而，NumPy 并不尊重这一点，并期望缓冲区即使在调用 releasebuffer 之后也能保持它们的数据。所以在我们的例子中，我们实际上不需要做任何事情。
在 Jupyter 笔记本上使用 Cython 最简单的方法是首先加载 Cython，如下所示。您可能需要先 pip 安装 Cython。像往常一样，考虑使用虚拟环境。
接下来，在一个单独的单元格中输入 Cython 代码，以 IPython magic %%cython -cplus.开始。这里我们定义了一个类SimplestBuffer，它实现了缓冲协议，也可以在 Python 中使用。这个类是一个通用的可重用容器，它只保存二进制数据，并允许通过缓冲协议进行访问，以便 NumPy 可以共享数据。
有了我们闪亮的新类SimplestBuffer，我们可以像这样重做我们先前的例子:
如果你已经走到这一步，恭喜你！所有艰苦的工作都完成了。我们已经学习了如何将结构化的二进制数据加载到 NumPy 中，还使用 Cython 创建了一个可以通过np.frombuffer有效访问的数据容器。
加载具有多种记录类型的二进制数据
作为我们的最后一项任务，我们将使用 Cython 构建一个快速的数据解析函数fan_bytes,它专用于我们的二进制数据格式。该函数将输入的二进制数据作为一个字节数组和两个额外的SimplestBuffer对象。它使用一些简单的 C 指针算法来遍历我们的二进制文件，并根据 msg_type 的值将记录扇出到一个或另一个SimplestBuffer对象。如果文件中有任何 msg_type 不等于 1 或 2 的记录，这些记录将被跳过。注意，我们还在这个单元格中重复了 SimplestBuffer 定义，以便 Cython 可以找到它。
对于下一个例子，我已经设置了一些样本二进制数据，其中包含我们之前加载的相同记录，另外还有一些新记录，它们使用相同的头，但是消息体由四个 32 位整数组成。要查看新代码的运行情况，您可以这样做:
所以这就是进步！！！此时，我们已经成功地将包含混合记录类型的二进制文件加载到两个数据帧中，每个数据帧对应一种记录类型。
一些小的扩展
上面的代码是一个完整的工作示例，但是有一些改进可能是一个好主意。
首先，我们应该提高 SimplestBuffer 的内存安全性，这样当 NumPy 或 Pandas 共享内存时，底层内存就不会被重新分配。
其次，我们应该允许在缓冲区上预先分配内存，并允许直接从文件中读取字节。但是请注意，C++ vector 在重新分配内存方面已经相当高效了，对于从文件中读取，在处理之前将所有二进制数据读入一个中间缓冲区通常比在文件系统上进行许多小的读取更快。然而，这两个特性都很容易实现，并且可以加速。
最后，从 Cython 生成可加载的模块，而不是将所有的 Cython 放入 Jupyter 笔记本中，这通常是有用的。
为了节省空间，我们不会在这里展示这些改进的代码，但是看看前面提到的笔记本，上面有所有例子和扩展的完整代码。
结束语
我希望你已经发现这个笔记本很有用，它可以帮助你加载二进制数据并返回分析！！！但是在结束之前，我想再补充几句。
评估速度:我们在这里没有做任何基准测试，但是在我的测试中，我发现使用上述方法加载二进制数据和从二进制文件中加载等价的数据帧一样快，有时甚至更快！然而，一个不太快的地方是使用pd.Series.str.decode(‘utf-8’)将字节数组转换成字符串。根据我的经验，这种转换通常是加载二进制数据最慢的部分。因此，您可能希望将部分或全部字符数据保留为字节数组，而不是转换为原生字符串对象。
可变记录长度:在这里的例子中，我们的记录类型都有固定的长度。但是在野外，二进制记录通常具有可变长度，这是因为记录中存在可变长度的字符数组或重复组。为了处理这种类型的记录，您必须将字符数组截断到某个固定长度，并找到一种方法来处理任何重复的组。上面的通用工具是你真正需要的，所以要意识到这是你可能不得不处理的事情，在你的情况下，想出适合你的解决方案是没有问题的。
不规则结构的文本数据:在本文中，我们主要关注二进制数据，但是我想指出的是，如果您有大量的不规则结构的文本数据，您可以使用这里演示的相同技术来有效地处理和加载您的数据。同样，只要找出一个作为数据帧的最终结构，然后编写一些 Cython 将文本文件解析到一个或多个缓冲区中，就像我们上面做的那样。
感谢您的阅读，如果您有任何意见或建议，请告诉我。
使用 PolyBase 将 CSV 数据加载到 Azure Synapse Analytics
理解大数据
使用 PolyBase 将 CSV 数据从 ADLS Gen2 导入 Azure Synapse Analytics 的分步指南
Azure Synapse Analytics SQL pool 支持各种数据加载方法。加载数据的最快和最具伸缩性的方法是通过 PolyBase。PolyBase 是一种数据虚拟化技术，可以通过 T-SQL 语言访问存储在 Hadoop 或 Azure 数据湖存储中的外部数据。
PolyBase 将数据加载范式从 ETL 转移到 ELT。数据首先被加载到临时表中，然后是转换步骤，最后被加载到生产表中。
在本文中，我们使用 PolyBase 将一个 CSV 文件从 Azure Data Lake Storage Gen2 帐户加载到 Azure Synapse Analytics 数据仓库。我们将查看执行加载过程的详细步骤。
注意: Microsoft Azure 是一项付费服务，遵循本文可能会给你或你的组织带来财务责任。
在继续阅读本文之前，请阅读我们的使用条款:https://dhyanintech . medium . com/disclaimer-disclosure-disclosure-terms-of-use-fb3 BF BD 1e 0e 5
先决条件
- 有效的 Microsoft Azure 订阅
- 带有 CSV 文件的 Azure 数据湖存储第二代帐户
- Azure Synapse 分析数据仓库
要使用 PolyBase，您需要在加载之前在 SQL 池中定义外部表。PolyBase 使用外部表来定义和访问来自 Azure 存储的数据。外部表包含表模式，并指向存储在 SQL 池外部的数据。定义外部表包括指定三个对象:数据源、文本文件的格式和表定义。
外部表是不保存在物理磁盘上的内存表。可以像查询任何其他表一样查询外部表。
外部数据源
外部数据源对象提供连接到外部数据源本身所需的连接信息，在我们的例子中，外部数据源是 ADLS 帐户。让我们从收集 URL 和访问密钥开始。登录到 Azure 门户，并导航到您的存储帐户。点击访问键，将键和存储帐户名复制到记事本。
Azure 存储帐户:访问密钥(图片由作者提供)
创建导入数据库
下一步是创建数据库范围的凭据，以保护 ADLS 帐户的凭据。如果数据库主密钥尚不存在，则创建一个数据库主密钥，然后使用该主密钥加密名为 ADLS 凭证的数据库范围凭证。
数据库主密钥用于加密数据库中存在的证书和密钥的私钥。
数据库范围的凭据包含连接到外部资源所需的身份验证信息。
您可以在 SSMS 或您选择的工具或 Azure 门户中 Synapse 实例的常见任务部分的**查询编辑器(预览)**中运行以下 T-SQL 语句。相应地替换存储帐户名称、存储帐户密钥和密码。
-- Create a database master key if one does not already exist, using your own password. This key will be used to encrypt the credential secret in next step.
CREATE MASTER KEY ENCRYPTION BY PASSWORD = 'Pa$$word123' ;CREATE DATABASE SCOPED CREDENTIAL ADLS_Credential
WITH
-- IDENTITY = '<storage_account_name>' ,
-- SECRET = '<storage_account_key>'IDENTITY = 'dlspolybasestorage' ,
SECRET = 'zN9S8mggblYX/sEiz5DVRmcZWjPw65A393bzD9T5rQjo+LnI5GAGrjdLvt4iqK5YEWMSMqV82IsVm3Bww6uw=='
;
关注我们的文章，了解如何连接和访问来自 SSMS 的 Azure Synapse Analytics:
[## 在 Azure Databricks 中连接和访问 Azure Synapse Analytics 的凭据安全方式
关于如何设置 SQL Server 防火墙和使用 PySpark 中的秘密作用域从数据块连接的指南。
medium.com](https://medium.com/swlh/a-credential-safe-way-to-connect-and-access-azure-synapse-analytics-in-azure-databricks-1b008839590a) 
Azure Synapse 分析:查询编辑器(图片由作者提供)
进一步阅读数据库主密钥和数据库范围凭证:
[## 创建主密钥(Transact-SQL) - SQL Server
适用于:SQL Server(所有支持的版本)Azure SQL 数据库 Azure SQL 托管实例 Azure Synapse Analytics…
docs.microsoft.com](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-master-key-transact-sql) [## 创建数据库范围的凭据(Transact-SQL) - SQL Server
适用于:SQL Server(所有支持的版本)Azure SQL 数据库 Azure SQL 托管实例 Azure Synapse Analytics…
docs.microsoft.com](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-database-scoped-credential-transact-sql)
创建外部数据源连接
使用数据库范围的凭据创建名为 AzureStorage 的外部数据源。位置 URL 指向 ADLS Gen2 帐户中名为 csvstore 的容器。Hadoop 类型用于基于 Hadoop 和基于 Azure Blob 存储的外部源。修改位置以引用您的存储帐户和容器。
-- Note this example uses a ADLS Gen2 secured endpoint (abfss)
CREATE EXTERNAL DATA SOURCE AzureStorage
WITH
( LOCATION = 'abfss://[csvstore@dlspolybasestorage.dfs.core.windows.net](mailto:csvstore@dlspolybasestorage.dfs.core.windows.net)' ,
CREDENTIAL = ADLS_Credential ,
TYPE = HADOOP
);
关于创建外部数据源的进一步阅读:
[## 创建外部数据源(Transact-SQL) - SQL Server
使用 SQL Server、SQL 数据库、Azure Synapse Analytics 或 Analytics…创建用于查询的外部数据源
docs.microsoft.com](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-external-data-source-transact-sql?view=azure-sqldw-latest&tabs=dedicated)
外部文件格式
外部文件格式对象包含如何构造文件中的数据，并定义如何定义行以及使用什么列分隔符。运行以下查询来定义名为 csvFile 的外部文件格式。在这个练习中，我们使用一个可用的 CSV 文件这里。这个文件有 4，167 个数据行和一个标题行。
FORMAT_TYPE 向 PolyBase 表明文本文件的格式是 DelimitedText。FIELD_TERMINATOR 指定列分隔符。STRING_DELIMITER 指定字符串类型数据的字段终止符。FIRST_ROW 指定在 PolyBase 加载期间首先读取的行号。如果该值设置为 2，则在加载数据时会跳过标题行。USE_TYPE_DEFAULT 指定如何处理缺少的值；FALSE 表示将所有缺失值存储为 NULL。编码指定外部文件的编码。
-- Create an external file format for DELIMITED (CSV/TSV) files.
CREATE EXTERNAL FILE FORMAT csvFile
WITH (
FORMAT_TYPE = DELIMITEDTEXT,
FORMAT_OPTIONS (
FIELD_TERMINATOR = ',',
STRING_DELIMITER = '"',
FIRST_ROW = 2,
USE_TYPE_DEFAULT = FALSE,
ENCODING = 'UTF8' )
);
关于创建外部文件格式的进一步阅读:
[## 创建外部文件格式(Transact-SQL) - SQL Server
适用于:SQL Server 2016 (13.x)及更高版本 Azure SQL 托管实例 Azure Synapse Analytics 并行数据仓库…
docs.microsoft.com](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-external-file-format-transact-sql?view=azure-sqldw-latest&tabs=delimited)
外部表格
外部表对象使用外部数据源和外部文件格式对象来定义 Azure Synapse Analytics 中的外部表结构。然后，您可以使用外部表作为将数据加载到数据仓库的基础。
创建一个名为 dbo 的外部表。FIPSLOOKUP_EXT 带有对应于您的 CSV 文件的列定义。使用 WITH 子句调用我们在前面的步骤中创建的外部数据源定义(AzureStorage)和外部文件格式(csvFile)。该位置表示要加载的文件位于数据源的根文件夹中。
-- Create a temp table to hold the imported data
CREATE EXTERNAL TABLE dbo.FIPSLOOKUP_EXT (
UID INT NOT NULL,
iso2 VARCHAR(2) NULL,
iso3 VARCHAR(3) NULL,
code3 INT NULL,
FIPS INT NULL,
Admin2 VARCHAR(255) NULL,
provincestate VARCHAR(255) NULL,
countryregion VARCHAR(255) NULL,
latitude DECIMAL(12,9) NULL,
longitude DECIMAL(12,9) NULL,
combined_key VARCHAR(255) NULL,
population INT NULL
)
WITH (
LOCATION='../',
DATA_SOURCE=AzureStorage,
FILE_FORMAT=csvFile
);
运行查询并刷新 SSMS 的对象浏览器。此时，我们可以看到我们到目前为止创建的所有三个外部对象。
SSMS:外部物体(作者图片)
让我们运行一个快速选择查询来查看外部表中的数据，并测试我们的外部对象。
SSMS:数据来自外部表格(图片由作者提供)
关于创建外部表的进一步阅读:
[## 创建外部表(Transact-SQL) - SQL Server
创建一个外部表。这篇文章提供了语法，参数，备注，权限和例子
docs.microsoft.com](https://docs.microsoft.com/en-us/sql/t-sql/statements/create-external-table-transact-sql?view=azure-sqldw-latest)
加载目标表
我们正确地建立了我们的聚合库；然而，数据还没有物理地存储在我们的数据仓库中。数据仍然只存在于 ADLS 的账户中。我们需要将这些数据加载到一个物理表中，以物理方式保存在我们的数据仓库中。
在 Azure Synapse Analytics 中创建物理表。该表将使用循环表结构在所有列上定义聚集列存储索引，因为循环表结构是用于装载数据的最佳表结构。
-- Load the data from Azure Data Lake Store Gen2 to Azure Synapse Analytics data warehouse
CREATE TABLE dbo.FIPSLOOKUP
WITH (
CLUSTERED COLUMNSTORE INDEX,
DISTRIBUTION = ROUND_ROBIN
)
AS
SELECT * FROM dbo.FIPSLOOKUP_EXT;
SSMS:从外部表创建物理表(图片由作者提供)
让我们快速检查一下装载到物理表中的行数。加载的总行数是 4，167，这意味着在加载过程中没有丢弃任何行。
SSMS:来自物理表的数据(图片由作者提供)
就这些了，伙计们。您已经使用 PolyBase 成功地将 CSV 文件加载到 Azure Synapse Analytics 数据仓库中。如果需要转换或清理刚刚加载的数据，最好的方法是在从外部表到物理表的加载过程中引入清理和转换查询。这就是我们前面讨论的 PolyBase 所实现的 ETL 到 ELT 的范式转换。
结论
我们使用 PolyBase 将 CSV 数据加载到我们的 Azure Synapse 分析数据仓库中。我们创建了三个外部对象，并将存储在 ADLS Gen2 帐户中的文件加载到物理数据表中。
喜欢这个帖子？与 Dhyan 联系
让我们做朋友吧！你可以在 LinkedIn 上找到我或者在 Medium 上加入我。
为深度学习模型加载自定义图像数据集:第 1 部分
将自定义图像数据集加载到深度学习模型的不同技术的简单指南。
在本文中，您将学习如何从自定义数据中加载和创建图像训练和测试数据集，作为深度学习模型的输入。您将学习使用加载数据集。
- 开CV2开
- PIL
这里使用的数据集是来自 Kaggle 的英特尔图像分类。
英特尔图像分类数据集已经分为训练、测试和 Val，我们将仅使用训练数据集来了解如何使用不同的库加载数据集。
为深度学习模型加载自定义数据集的典型步骤
- 打开图像文件。文件的格式可以是 JPEG、PNG、BMP 等。
- 调整图像大小以匹配深度学习模型的输入层的输入大小。
- 将图像像素转换为浮点数据类型。
- 将图像归一化，使像素值从 0 到 255 在 0 和 1 之间缩小。
- 深度学习模型的图像数据应该是 numpy 数组或者张量对象。
自定义图像数据的文件夹结构
每个类别都是一个文件夹，包含该特定类别的图像。
使用 CV2 加载图像数据
导入所需的库
**import pandas as pd
import numpy as np
import os
import tensorflow as tf
import cv2
from tensorflow import keras
from tensorflow.keras import layers, Dense, Input, InputLayer, Flatten
from tensorflow.keras.models import Sequential, Model
from matplotlib import pyplot as plt
import matplotlib.image as mpimg**
**%matplotlib inline**
从其中一个文件夹中随机打印五张图像
**plt.figure(figsize=(20,20))****test_folder=r'CV\Intel_Images\seg_train\seg_train\forest'
for i in range(5):
file = random.choice(os.listdir(img_folder))
image_path= os.path.join(img_folder, file)
img=mpimg.imread(image_path)
ax=plt.subplot(1,5,i+1)
ax.title.set_text(file)
plt.imshow(img)**
设置加载数据集的图像尺寸和源文件夹
**IMG_WIDTH=200
IMG_HEIGHT=200
img_folder=r'CV\Intel_Images\seg_train\seg_train\'**
从文件夹中的图像创建图像数据和标签
在下面的函数中
- 源文件夹是包含不同类的图像的输入参数。
- 从文件夹中读取图像文件，并将其转换为正确的颜色格式。
- 根据模型所需的输入尺寸调整图像的大小
- 将图像转换为数据类型为 float32 的 Numpy 数组
- 归一化图像数组，使值在 0 和 1 之间从 0 到 255 缩小，以获得类似的数据分布，这有助于加快收敛。
**def create_dataset(img_folder):
img_data_array=[]
class_name=[]
for dir1 in os.listdir(img_folder):
for file in os.listdir(os.path.join(img_folder, dir1)):
image_path= os.path.join(img_folder, dir1, file)
image= cv2.imread( image_path, cv2.COLOR_BGR2RGB)
image=cv2.resize(image, (IMG_HEIGHT, IMG_WIDTH),interpolation = cv2.INTER_AREA)
image=np.array(image)
image = image.astype('float32')
image /= 255
img_data_array.append(image)
class_name.append(dir1)
return img_data_array, class_name**# extract the image array and class name
**img_data, class_name =create_dataset(r'CV\Intel_Images\seg_train\seg_train')**
将文本标签转换成数字代码
为类的所有唯一值创建一个字典
**target_dict={k: v for v, k in enumerate(np.unique(class_name))}
target_dict**
根据字典将 class_names 转换成它们各自的数值
**target_val= [target_dict[class_name[i]] for i in range(len(class_name))]**
创建一个简单的深度学习模型并编译它
**model=tf.keras.Sequential(
[
tf.keras.layers.InputLayer(input_shape=(IMG_HEIGHT,IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(filters=32, kernel_size=3, strides=(2, 2), activation='relu'),
tf.keras.layers.Conv2D(filters=64, kernel_size=3, strides=(2, 2), activation='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(6)
])****encoder.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy', metrics=['accuracy'])**
我们最终拟合数据集来训练模型。我们可以使用 Numpy 数组作为输入
**history = model.fit(x=np.array(img_data, np.float32), y=np.array(list(map(int,target_val)), np.float32), epochs=5)**
我们也可以使用 tf.cast() 将输入数据转换成张量来训练模型
**history = model.fit(x=tf.cast(np.array(img_data), tf.float64), y=tf.cast(list(map(int,target_val)),tf.int32), epochs=5)**
我们将通过使用不同的库加载图像数据集来使用相同的模型进行进一步的训练
使用 PIL 加载图像数据
添加附加库以使用 PIL 加载影像数据集
**from PIL import Image**
使用 PIL 从文件夹中的图像创建图像数据和标签
在下面的函数中
- 源文件夹是包含不同类的图像的输入参数。
- 使用 PIL 打开文件夹中的图像文件。
- 根据模型所需的输入尺寸调整图像的大小
- 将图像转换为数据类型为 float32 的 Numpy 数组
- 归一化图像阵列以加快收敛速度。
**def create_dataset_PIL(img_folder):
img_data_array=[]
class_name=[]
for dir1 in os.listdir(img_folder):
for file in os.listdir(os.path.join(img_folder, dir1)):
image_path= os.path.join(img_folder, dir1, file)
image= np.array(Image.open(image_path))
image= np.resize(image,(IMG_HEIGHT,IMG_WIDTH,3))
image = image.astype('float32')
image /= 255
img_data_array.append(image)
class_name.append(dir1)
return img_data_array , class_name
PIL_img_data, class_name=create_dataset_PIL(img_folder)**
将文本标签转换成数字代码
下面是我们用于 CV2 的相同代码
**target_dict={k: v for v, k in enumerate(np.unique(class_name))}
target_val= [target_dict[class_name[i]] for i in range(len(class_name))]**
创建和编译一个简单的深度学习模型
**model=tf.keras.Sequential(
[
tf.keras.layers.InputLayer(input_shape=(IMG_HEIGHT,IMG_WIDTH, 3)),
tf.keras.layers.Conv2D(filters=32, kernel_size=3, strides=(2, 2), activation='relu'),
tf.keras.layers.Conv2D(filters=64, kernel_size=3, strides=(2, 2), activation='relu'),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(6)
])****encoder.compile(optimizer='rmsprop', loss='sparse_categorical_crossentropy', metrics=['accuracy'])**
我们最终拟合数据集来训练模型。我们可以使用 Numpy 数组作为输入
**history = model.fit(x=np.array(PIL_img_data, np.float32), y=np.array(list(map(int,target_val)), np.float32), epochs=5)**
我们也可以使用 tf.cast() 将输入数据转换成张量来训练模型
**history = model.fit(x=tf.cast(np.array(PIL_img_data), tf.float64), y=tf.cast(list(map(int,target_val)),tf.int32), epochs=5)**
除了几个步骤之外，使用 CV2 和 PIL 加载数据集的过程是相同的。
现在，这将帮助您使用 CV2 和 PIL 库加载数据集。
使用 CV2 和 PIL 加载数据集的代码在此可用。
在下一篇文章中，我们将使用。
- Tensorflow 核心包括 tf.data
将文件加载到 BigQuery
使用 Python 将拼花和 CSV 文件导入 GCP BigQuery
Google 云平台的 BigQuery 能够将多种文件类型摄取到表格中。在本教程中，我将展示它可以处理什么类型的文件，以及为什么您应该尽可能使用 Parquet。
要获得所有媒体文章的完整访问权限，包括我的文章，请考虑在此订阅。
如何加载文件
肯定比这容易。图片来源: pxfuel
首先，我们需要一个包含这些表的数据集:
上面的代码片段将创建一个名为files的数据集。以下是对所用参数的解释:
location设置数据集中表的位置。请注意，不同地点之间可能会收取转让费。最佳实践是尽可能将存储桶和 BigQuery 表放在同一个区域。这里我用europe-west2(伦敦)表示地区位置。您也可以使用多区域位置，如EU或US。点击查看选项。default_table_expiration设置新创建的表格过期的秒数。如果您只想让表存在一段时间，或者您担心会忘记删除它们，这是非常有用的。我把它设置为 2 小时。description是对数据集用途的简短易读的描述。
我将从云外壳运行代码，因为这样最方便——我强烈建议您也从那里尝试一下。
一旦它运行，我们可以从用户界面确认所有设置都设置正确:
新数据集信息面板的屏幕截图
现在我们有一个数据集要填充，让我们使用 Python ( sklearn)为我们创建一些数据，并将其保存为一个逗号分隔的文件。
这是一个非常简单的数据集，所以我们实际上可以使用 BigQuery 的autodetect特性来计算它的模式。下面是如何使用bq从命令行完成这项工作:
如果由于某种原因无法找到files数据集，您可以将您的项目名称指定为表名称的一部分，或者您可以将默认项目设置为您之前使用的项目:
gcloud config set core/project YOUR_PROJECT_NAME
让我们看看如何通过 Python 的gcloud SDK 实现这一点:
注意，在这里，我们将文件直接从本地存储上传到 BigQuery，但是建议首先将您的文件复制到 GCS (Google Cloud Storage ),然后从那里加载文件。查看[load_table_from_uri](https://googleapis.dev/python/bigquery/latest/generated/google.cloud.bigquery.client.Client.html#google.cloud.bigquery.client.Client.load_table_from_uri)如何做到这一点。
什么样的文件可以加载到 BigQuery 中？
谈到文件格式，我们确实有选择。图片来源: pxfuel
谈到文件类型，BigQuery 确实支持一些选项:
- Avro
- 镶木地板
- 光学字符识别
- 战斗支援车
- JSON(换行分隔)
但他们并非生而平等…
请注意，在上面的文件中，所有内容都是数字，这使得 BigQuery 很容易检测列类型。但是当你开始加载字符串、日期、时间、浮点数、整数和混合字段时，生活就变得复杂了，BigQuery 的模式autodetect特性也就消失了。然后，您需要自己指定模式，这很快就会变得繁琐而混乱，因为 Numpy 数据类型与 BigQuery 之间没有一对一的映射。在这种情况下，Avro 和 Parquet 格式更有用。它们存储关于列的元数据，BigQuery 可以使用这些信息来确定列的类型！
Avro 是 BigQuery 的推荐文件类型，因为它的压缩格式允许快速并行上传，但 Python 中对 Avro 的支持有些有限，所以我更喜欢使用 Parquet。
让我们制作一个更大的数据集
为了演示autodetect会失败的地方，让我们再添加几行和一个时髦的列，除了最后的 2 个浮点数，它到处都有缺失值。
这里的 upload_csv 是一个封装了我们之前所做的步骤的函数。检查源代码。
这种工作方式没有错误。但是它做了我们想要它做的吗？让我们检查一下数据类型:
这为我们提供了以下信息:
看看最后一排！😱
我们心爱的花车变成了琴弦！
拼花地板拯救世界
CSV 格式比较乱。对于应该如何引用字符串，应该使用什么分隔符，是否有标题，没有明确的指导，我们甚至没有触及跨多个文件的数据集。
另一方面，拼花文件携带关于列的元数据。他们知道每一列应该是什么类型，所以当您将它加载到 BigQuery 时，不再需要猜测。更好的是，parquet 文件通常是按列压缩的，所以你的分类列存储起来会便宜很多！试试吧！
让我们看看如何将相同的dataframe作为一个 parquet 文件上传到 BigQuery:
这更简单——注意，我们不再需要跳过标题或猜测模式——最棒的是它带有压缩功能。我们的文件大小从 1.8MB 变成了 59KB(我们必须注意，这主要是因为许多重复的值，但仍然非常令人印象深刻)！
我们的列类型现在是正确的:
彩车回来了！🎉
摘要
我们展示了 BigQuery 如何接收 CSV 和 Parquet 文件，以及 CSV 如何导致复杂性。**如果你觉得上面的例子在现实生活中不会发生，那就再想想吧！**当您有数千个列分布在数千个大型文件中时，BigQuery 检测到错误列类型的可能性非常高——同样，当您需要为它编写模式时，数千个列也没有用…
所以下一次当您希望将一个大文件加载到 BigQuery 中时，可以请求 Parquet！
要获得 BigQuery 的更多乐趣，请查看这篇文章，在这篇文章中，我展示了如何使用 UDF 找到斐波那契数列。
上面用到的所有代码都可以在 GitHub 上找到。
在 Pandas 中加载大型数据集
有效地使用分块和 SQL 来读取 pandas 中的大数据集
熊猫的图书馆是数据科学生态系统的重要成员。然而，它无法分析大于内存的数据集，这使得它对于大数据来说有点棘手。考虑这样一种情况，当我们想只使用熊猫来分析一个大数据集时。我们会遇到什么样的问题？例如，我们来看一个包含 3GB 数据的文件，该文件总结了 2016 年 3 月的黄色出租车出行数据。为了进行任何种类的分析，我们必须将它输入到内存中。我们很容易使用 pandas 的read_csv()函数来执行如下读取操作:
import pandas as pd
df = pd.read_csv('yellow_tripdata_2016-03.csv')
当我运行单元/文件时，我的系统抛出以下内存错误。(内存错误取决于您使用的系统容量)。
作者图片
有其他选择吗？
在批评熊猫之前，重要的是要明白熊猫并不总是每项任务的合适工具。熊猫缺乏多处理支持，其他库更擅长处理大数据。一个这样的选择是 Dask，它提供了一个类似熊猫的 API 来处理比内存大的数据集。即使是 pandas 的文档也明确提到了大数据:
不用熊猫值得考虑。熊猫并不是所有情况下的合适工具。
然而，在本文中，我们将研究一种叫做分块的方法，通过这种方法，你可以在 pandas 中加载内存不足的数据集。这种方法有时可以提供一种健康的方式来管理熊猫的内存不足问题，但可能并不总是有效，我们将在本章的后面看到这一点。本质上，我们将研究在 python 中导入大型数据集的两种方法:
- 使用带有 chunksize 的
pd.read_csv() - 使用 SQL 和 pandas
💡分块:将数据集细分成更小的部分
作者图片
在使用示例之前，让我们试着理解我们所说的工作分块是什么意思。根据维基百科，
分块 指的是通过使用特定情况的知识来聚合相关的内存分配请求，从而提高性能的策略。
换句话说，我们可以分成更小的部分或块，而不是一次读取内存中的所有数据。在 CSV 文件的情况下，这意味着在给定的时间点只将几行加载到内存中。
Pandas 的read_csv()函数带有一个块大小 参数 来控制块的大小。让我们看看它的实际效果。我们将使用本文前面使用的确切数据集，但不是一次性加载所有数据集，而是将它分成几个部分进行加载。
✴️使用 pd.read_csv()和 chunksize
为了启用分块，我们将在开始时声明块的大小。然后使用带有 chunksize 参数的read_csv(),返回一个我们可以迭代的对象。
chunk_size=50000
batch_no=1for chunk in pd.read_csv('yellow_tripdata_2016-02.csv',chunksize=chunk_size):
chunk.to_csv('chunk'+str(batch_no)+'.csv',index=False)
batch_no+=1
我们选择 50，000 的块大小，这意味着一次只能导入 50，000 行数据。下面是一个视频，展示了主 CSV 文件如何拆分成多个文件。
作者提供的视频
将单个块文件导入 pandas 数据帧:
我们现在有多个数据块，每个数据块都可以作为熊猫数据帧轻松加载。
df1 = pd.read_csv('chunk1.csv')
df1.head()
它就像一个魔咒！。不再有内存错误。让我们快速查看一下这个块的内存使用情况:
df1.info()
作者图片
🔴提醒一句
分块创建数据的各种子集。因此，当您正在执行的操作不需要或只需要块之间的最小协调时，它会工作得很好。这是一个重要的考虑。使用组块的另一个缺点是有些操作像 [groupby](https://pandas.pydata.org/pandas-docs/stable/user_guide/scale.html)做组块要难得多。在这种情况下，最好使用替代库。
✴️Using SQL 和熊猫读取大数据文件
(参见参考文献)
作者图片
另一种方法是从块中构建一个 SQLite 数据库，然后使用 SQL 查询提取所需的数据。SQLite 是一个基于 SQL 语言的关系数据库管理系统，但是针对小型环境进行了优化。它可以使用名为 sqlite3 的 Python 模块与 Python 集成。如果您想了解更多关于在 python 中使用 Sqlite 的信息，可以参考我写的一篇关于这个主题的文章:
[## 使用 SQLite 在 Python 中进行数据库编程
如果你渴望成为一名数据科学家，你将会处理大量的数据。大部分数据驻留在…
medium.com](https://medium.com/analytics-vidhya/programming-with-databases-in-python-using-sqlite-4cecbef51ab9)
SQLAlchemy 是 Python SQL 工具包和对象关系映射器，为应用程序开发人员提供了 SQL 的全部功能和灵活性。它用于构建一个从原始数据创建数据库的引擎，在我们的例子中，原始数据是一个很大的 CSV 文件。
对于本文，我们将遵循以下步骤:
导入必要的库
import sqlite3
from sqlalchemy import create_engine
创建到数据库的连接器
我们将要创建的数据库命名为csv_database.
csv_database = create_engine('sqlite:///csv_database.db')
通过分块从 CSV 文件创建数据库
这个过程类似于我们在本文前面看到的。该循环读取由 chunksize 指定的成组数据集。
chunk_size=50000
batch_no=1for chunk in pd.read_csv('yellow_tripdata_2016-02.csv',chunksize=chunk_size,iterator=True):
chunk.to_sql('chunk_sql',csv_database, if_exists='append')
batch_no+=1
print('index: {}'.format(batch_no))
请注意，我们使用了函数。chunk.to_sql instead of chunk.to_csv 因为我们正在将数据写入数据库，也就是说csv_database.，chunk_sql是给块的任意名称。
通过查询 SQL 数据库构建熊猫数据框架
数据库已创建。我们现在可以很容易地查询它，只提取我们需要的那些列；例如，我们可以只提取乘客数量少于5并且出行距离大于10的那些行。pandas.read_sql_query将 SQL 查询读入数据帧。
我们现在有了一个数据框架，它非常适合我们的记忆，可以用于进一步的分析。
结论
就数据分析而言，Pandas 是一个方便且功能多样的库。然而，在处理大数据时，它遇到了几个瓶颈。在本文中，我们看到了分块和 SQL 如何为分析大于系统内存的数据集提供一些安慰。然而，这种替代方案不是“一刀切”的解决方案，使用为处理大数据而创建的库将是更好的选择。
参考
基于 Berka 数据集的贷款违约预测
使用真实银行数据的端到端机器学习项目
肖恩·波洛克在 Unsplash 上的照片
目录
简介
关于数据集
导入数据集到数据库
连接 Python 到 MySQL 数据库
特征提取
特征转换
建模
结论与未来方向
关于我
注:如果你对本帖以外的细节感兴趣，Berka 数据集、所有代码和笔记本都可以在我的 GitHub 页面找到。
这篇文章只是构建贷款违约预测模型的实践。如果你对这个话题感兴趣，并且想看一些我为一个客户完成的更深入的工作，使用优化利用这样的贷款违约预测模型把他们的损失变成利润，请在这里看我的另一篇文章:贷款违约预测利润最大化。
介绍
对于银行来说，在只有少量信息的情况下，预测客户违约的可能性始终是一个有趣且具有挑战性的问题。在当今时代，银行的数据科学团队使用机器学习来构建预测模型。他们使用的数据集很可能是专有的，通常是通过日常业务在内部收集的。换句话说，如果我们想从事这样的金融项目，我们可以使用的真实数据集并不多。幸运的是，有一个例外:Berka 数据集。
关于数据集
Berka 数据集，或 PKDD’99 金融数据集，是一个来自捷克银行的真实匿名金融信息集合，用于 PKDD’99 探索挑战。数据集可以从我的 GitHub 页面访问。
在数据集中，8 个原始文件包括 8 个表:
- 户口 (4500 对象档案户口。ASC) —每个记录描述一个帐户的静态特征。
- 客户端(文件客户端中的 5369 个对象。ASC) —每个记录描述一个客户的特征。
- 处分 (5369 档案中的对象 DISP。ASC) —每个记录将客户与账户联系在一起，即这种关系描述了客户操作账户的权利。
- 永久顺序(文件顺序中的 6471 个对象。ASC) —每个记录描述一个支付指令的特征。
- 交易(文件 TRANS 中的 1056320 对象。ASC)——每条记录描述一个账户上的一笔交易。
- 贷款(档案贷款中的 682 对象。ASC) —每个记录描述了一个给定账户的贷款。
- 信用卡(档案卡中的 892 个对象。ASC)——每条记录描述了一个账户发行的信用卡。
- 人口统计数据(档案区 77 个对象。ASC) —每个记录描述一个地区的人口统计特征。
来自关系数据集存储库的表关系
- 每个账户都具有“账户”关系中给出的静态特征(如创建日期、分行地址)和“永久订单”和“交易”关系中给出的动态特征(如借记或贷记的付款、余额)。
- 关系“客户”描述可以操纵账户的人的特征。
- 一个客户可以有多个账户，多个客户可以用一个账户操作；客户和账户在关系“处置”中联系在一起。
- 关系“贷款”和“信用卡”描述了银行向客户提供的一些服务。
- 一个账户可以发行多张信用卡。
- 一个账户最多只能发放一笔贷款。
- 关系“人口统计数据”提供了一些关于地区的公开信息(如失业率)；由此可以推断出关于客户端的附加信息。
将数据集导入数据库
这是一个可选步骤，因为原始文件仅包含分隔符分隔的值，因此可以使用 pandas 直接导入到数据框中。
在这里，我编写了 SQL 查询来将原始数据文件导入 MySQL 数据库，以便对数据进行简单快速的数据操作(例如，选择、连接和聚合函数)。
上面的代码片段展示了如何创建银行数据库和导入账户表。它包括三个步骤:
- 创建和使用数据库
- 创建表格
- 将数据加载到表中
如果你熟悉 MySQL 和数据库系统，前两步应该没有任何问题。对于“加载数据”步骤，您需要确保已经在 MySQL 中启用了LOCAL_INFILE。详细说明可以从这个线程中找到。
通过对每个表重复步骤 2 和步骤 3，所有数据都可以导入到数据库中。
将 Python 连接到 MySQL 数据库
同样，如果您选择使用 Pandas 将数据直接导入 Python，这一步是可选的。但是，如果您已经创建了数据库，并通过一些 SQL 数据操作熟悉了数据集，那么下一步就是将准备好的表转移到 Python 中，并在那里执行数据分析。一种方法是使用 Python 的 MySQL 连接器来执行 Python 中的 SQL 查询，并使用结果生成 Pandas 数据帧。以下是我的方法:
修改数据库信息(如主机、数据库、用户、密码)后，我们可以启动一个连接实例，执行查询并将其转换为 Pandas 数据帧:
尽管这是一个可选的步骤，但是与直接将文件导入到 Pandas DataFrames 相比，它在速度、便利性和实验目的方面都是有利的。不像其他 ML 项目只给了我们一个csv文件(1 个表)，这个数据集相当复杂，在表的连接之间隐藏了很多有用的信息，所以这也是我为什么要先介绍加载数据到数据库的方式的另一个原因。
现在，数据在 MySQL 服务器中，我们已经将它连接到 Python，这样我们就可以顺利地访问数据框中的数据。接下来的步骤是从表中提取特征，转换变量，将它们加载到一个数组中，并训练机器学习模型。
特征抽出
由于预测贷款违约是一个二元分类问题，我们首先需要知道每个类中有多少个实例。通过查看Loan表中的status变量，有 4 个不同的值:A、B、C 和 d
- 合同完成了，没有问题。
- 合同结束了，贷款还没付。
- c:运行合同，到目前为止还可以。
- d:执行合同，客户负债。
根据来自数据集描述的定义，我们可以将它们分成二元类:好的(A 或 C)和坏的(B 或 D)。有 606 笔贷款属于“良好”类，其中 76 笔属于“不良”类。
定义了两个不同的类后，我们可以查看变量并绘制直方图，看看它们是否对应于不同的分布。
下面显示的贷款金额是一个很好的例子，可以看出这两个类别之间的差异。尽管两者都是右偏的，但它仍然显示出一个有趣的模式，即金额较高的贷款往往会违约。
贷款金额直方图(好与坏)
提取特征时，它们不必是表中提供的现有变量。相反，我们总是可以发挥创造力，想出一些现成的解决方案来创建我们自己的功能。例如，当连接Loan表和Account表时，我们可以同时获得贷款发放日期和帐户创建日期。我们可能想知道创建帐户和申请贷款之间的时间间隔是否起了作用，因此简单的减法会给我们一个新的变量，该变量由同一帐户上两个此类活动之间的天数组成。直方图如下所示，其中可以看到一个明显的趋势，即在创建银行账户后立即申请贷款的人往往会违约。
账户创建和贷款发放之间的天数直方图
通过重复试验现有特性和创建的特性的过程，我最终准备了一个包含 18 个特性列和 1 个标签列的表。所选功能包括:
- 金额:贷款金额
- 期限:贷款期限
- 付款:贷款付款
- days_between:帐户创建和贷款发放之间的天数
- 频率:发布报表的频率
- average_order_amount:帐户发出的永久订单的平均金额
- average_trans_amount:账户交易的平均金额
- average_trans_balance:帐户进行交易后的平均余额
- 账户交易号
- card_type:与帐户关联的信用卡类型
- n _ 居民:户口所在地区的居民人数
- average_salary:客户所在地区的平均工资
- 平均失业率:计算地区的平均失业率
- 企业家比率:账户所在地区每 1000 名居民中的企业家人数
- average_crime_rate:帐户所在地区的平均犯罪率
- owner_gender:帐户所有者的性别
- owner_age:帐户所有者的年龄
- same_district:一个布尔值，表示所有者是否拥有与帐户相同的地区信息
特征转换
特征提取出来放入大表后，就要对数据进行转换，使之有机地馈入机器学习模型。在我们的例子中，我们有两种类型的特征。一种是数值，比如amount、duration、n_trans。另一种是分类的，比如card_type和owners_gender。
我们的数据集非常干净，没有任何缺失值，所以我们可以跳过插补，直接对数值进行缩放。从scikit-learn开始有几个定标器选项，如StandardScaler、MinMaxScaler和RobustScaler。在这里，我使用MinMaxScaler在 0 和 1 之间重新调整数值。另一方面，处理分类变量的典型策略是使用OneHotEncoder将特性转换成二进制0和1值。
下面的代码代表了功能转换的步骤:
用列变换器进行特征变换
建模
训练机器学习模型的第一件事是分割训练集和测试集。这在我们的数据集中很棘手，因为它是不平衡的:好贷款几乎是坏贷款的 10 倍。分层分割在这里是一个好的选择，因为它保留了训练集和测试集中类之间的比率。
分层列车测试分裂
对于二元分类任务，有很多很好的机器学习模型。这里，随机森林模型因为其良好的性能和快速原型制作能力而被用在这个项目中。拟合初始RandomForrestClassifier模型，并使用三种不同的度量来表示模型性能:准确性、 F1 得分和 ROC AUC 。
值得注意的是，对于这个不平衡的数据集，精确度是不够的。如果我们纯粹通过准确性来微调模型，那么它将倾向于预测贷款为“好贷款”。F1 得分是精确度和召回率之间的调和平均值，ROC AUC 是 ROC 曲线下的面积。这两个是评估不平衡数据的模型性能的更好的指标。
下面的代码显示了如何对训练集应用五重分层交叉验证，并计算每个分数的平均值:
初始模型的模型性能
Acc: 0.8973
F1: 0.1620
ROC AUC: 0.7253
很清楚的看到准确率很高，差不多 0.9，但是 F1 的分数因为召回率低所以很低。模型有微调和争取更好性能的空间，方法之一是网格搜索。通过为RandomForestClassifier的超参数(如n_estimators``max_depth``min_samples_split``min_samples_leaf)赋予不同的值，它将遍历超参数的组合，并输出在我们感兴趣的分数上表现最好的一个。代码片段如下所示:
使用 GridSearchCV 进行微调
用最佳参数改装模型，我们可以看看模型在整个列车组和试验组的性能:
Performance on Train Set:Acc: 0.9706
F1: 0.8478
ROC AUC: 0.9952Performance on Test Set:Acc: 0.8927
F1: 0.2667
ROC AUC: 0.6957
在训练集上的表现非常好:超过 2/3 的不良贷款和所有的良好贷款都被正确分类，并且三个性能指标都在 0.84 以上。另一方面，当该模型用于测试集时，结果并不令人满意:大多数不良贷款被标记为“好”，F1 值仅为 0.267。有证据表明涉及到过度拟合，因此应该在这种迭代过程中投入更多的精力，以便获得更好的模型性能。
随着模型的建立，我们现在可以根据它们的重要性对特性进行排序。预测能力最强的五大特征是:
- 平均交易余额
- 平均交易金额
- 贷款金额
- 平均工资
- 账户创建和贷款申请之间的天数
这没什么好惊讶的，因为对于其中的许多情况，我们已经看到了可能与贷款违约有关的异常行为，例如账户创建和贷款申请之间的贷款金额和天。
结论和未来方向
在这篇文章中，我介绍了银行应用程序中端到端机器学习模型的整个流程，贷款违约预测，以及真实世界的银行数据集 Berka。我描述了 Berka 数据集和每个表之间的关系。演示了如何将数据集导入 MySQL 数据库，然后连接到 Python 并将处理后的记录转换为 Pandas DataFrame 的步骤和代码。特征被提取并转换成一个数组，准备输入到机器学习模型中。最后一步，我使用数据拟合了一个随机森林模型，评估了模型性能，并生成了在预测贷款违约中起作用的前 5 个特征的列表。
这个机器学习管道只是可以与 Berka 数据集一起使用的一个应用程序的轻轻一碰。它可以更深入，因为在表之间错综复杂的关系中隐藏着更多有用的信息；它还可以更广泛，因为它可以扩展到其他应用程序，如信用卡和客户的交易行为。但如果只关注这一贷款违约预测，未来可能会有三个方向进一步下降:
- 提取更多特征:由于时间限制，无法对数据集进行透彻的学习和深入的理解。数据集中仍有许多未使用的功能，许多信息还没有被银行业的知识完全消化。
- 尝试其他模型:只有随机森林模型被使用，但有许多好的模型，如逻辑回归、XGBoost、SVM，甚至神经网络。还可以通过对超参数进行更精细的调整或使用集合方法(如打包、提升和叠加)来进一步改进模型。
- 处理不平衡数据:需要注意的是，违约贷款仅占总贷款的 10%左右，因此在训练过程中，模型更倾向于预测负面结果而非正面结果。我们已经使用了 F1 评分和 ROC AUC，而不仅仅是准确性。然而，性能仍然没有达到应有的水平。为了解决这个问题，将来可以使用其他方法，如收集或重采样更多数据。
同样，这篇文章只是从头开始构建贷款违约预测模型的实践。如果你对这个话题感兴趣，并且想看一些我为一个客户完成的更深入的工作，使用这种贷款违约预测模型，使用优化将他们的损失转化为利润，请在这里看我的另一篇文章:贷款违约预测利润最大化。
感谢您的阅读！如果你喜欢这篇文章，请关注我的频道和/或 成为我今天的推荐会员 (非常感谢🙏).我会继续写下去，分享我关于数据科学的想法和项目。如果你有任何问题，请随时联系我。
阅读周(Joe)徐(以及媒体上成千上万的其他作家)的每一个故事。您的会员费直接支持…
zhouxu-ds.medium.com](https://zhouxu-ds.medium.com/membership)
关于我
我是赛诺菲的数据科学家。我拥抱技术，每天都在学习新技能。欢迎您通过媒体博客、 LinkedIn 或 GitHub 联系我。我的观点是我自己的，而不是我雇主的观点。
请看我的其他文章:
- 利润最大化的贷款违约预测
- 利用空气质量传感器数据进行时间序列模式识别
- 使用 Python 和 Flask-RESTful 为机器学习模型构建 REST API
- 理解分类问题中的 Sigmoid、Logistic、Softmax 函数和交叉熵损失(对数损失)
- 使用 Elasticsearch (AWS OpenSearch)进行实时类型预测搜索
我能比 LendingClub 更好地对贷款进行评级吗？
将我的神经网络与企业基准对比
纽约公共图书馆在 Unsplash 拍摄的照片
介绍
如果你错过了，我建立了一个神经网络来预测贷款风险使用来自 LendingClub 的公共数据集。然后我构建了一个公共 API 来服务模型的预测。那很好，但是…我的模型有多好？
今天我将对它进行测试，将它与发放这些贷款的机构的风险模型进行对比。没错，LendingClub 在数据集中包括了他们自己计算的贷款等级(和子等级)，因此本世纪(或至少本周)最激动人心的风险建模对决的所有部分都已就绪。愿最好的算法胜出！
(1110171, 70)
5 rows × 70 columns
顺便说一下，这篇文章改编自一个 Jupyter 笔记本，所以如果你想在你自己的笔记本上跟随，继续前进，在 Kaggle 上叉我的！
基本规则
这将是一场公平的战斗——我的模型不会使用 LendingClub 在计算贷款等级时无法访问的任何数据(包括等级本身)。
我将按时间顺序对数据集进行排序(使用issue_d列，即发放贷款的月份和年份),并将它分成两部分。前 80%我将用于训练我的竞争模型，我将比较后 20%的表现。
The test set contains 222,035 loans.
在测试集的早期，我的模型可能有一点信息优势，因为我接受了一些贷款的培训，这些贷款在 LendingClub 对这些贷款进行评级时可能还没有结束。另一方面，LendingClub 可能在测试集的后期具有轻微的信息优势，因为他们在测试集的早期就已经知道一些贷款的结果。
顺便说一句，我不得不称赞迈克尔·伍伦(Michael Wurm)提出的将我的模型的表现与 LendingClub 的贷款等级进行比较的想法，但我的方法相当不同。我不是在试图模拟一个投资组合的表现；我只是在评估我对简单风险的预测有多好。
测试度量
测试:谁能挑选出最好的 A 级贷款，根据我上一个笔记本中的独立变量来判断，即预期借款人将偿还的预期贷款回报的一部分(我将其设计为fraction_recovered)。
LendingClub 先拿盘子。我会从测试集中收集他们所有的 A 级贷款，统计一下，算出他们的平均值fraction_recovered。这个平均值将是我的模型必须超越的指标。
然后，我将使用我在上一个笔记本中选定的相同的管道和参数在训练集上训练我的模型。一旦对它进行了训练，我将使用它在测试集上进行预测，然后收集与 LendingClub 的 A 级贷款数量相等的顶级预测数量。最后，我将计算这个子集上fraction_recovered的平均值，这样我们就有了赢家！
轮到 LendingClub 了
LendingClub gave 38,779 loans in the test set an A grade.Average `fraction_recovered` on LendingClub's grade A loans:
0.96021
这个比例相当高。我有点紧张。
轮到我了
首先，我将从我以前的笔记本中复制我的run_pipeline函数:
现在是关键时刻了:
Epoch 1/100
6939/6939 - 11s - loss: 0.0245
Epoch 2/100
6939/6939 - 11s - loss: 0.0204
Epoch 3/100
6939/6939 - 11s - loss: 0.0203
Epoch 4/100
6939/6939 - 12s - loss: 0.0202
Epoch 5/100
6939/6939 - 11s - loss: 0.0202
Epoch 6/100
6939/6939 - 11s - loss: 0.0202
Epoch 7/100
6939/6939 - 11s - loss: 0.0201
Epoch 8/100
6939/6939 - 11s - loss: 0.0201
Epoch 9/100
6939/6939 - 13s - loss: 0.0201
Epoch 10/100
6939/6939 - 11s - loss: 0.0201
Epoch 11/100
6939/6939 - 11s - loss: 0.0201
Epoch 12/100
6939/6939 - 11s - loss: 0.0201
Epoch 13/100
6939/6939 - 11s - loss: 0.0201
Epoch 14/100
6939/6939 - 11s - loss: 0.0201
Epoch 15/100
6939/6939 - 11s - loss: 0.0201
Epoch 16/100
6939/6939 - 11s - loss: 0.0201
Epoch 17/100
6939/6939 - 11s - loss: 0.0201
Epoch 18/100
6939/6939 - 11s - loss: 0.0201
Epoch 19/100
6939/6939 - 11s - loss: 0.0201
Epoch 20/100
6939/6939 - 11s - loss: 0.0201
Epoch 21/100
6939/6939 - 11s - loss: 0.0201
Epoch 22/100
6939/6939 - 11s - loss: 0.0201
Epoch 23/100
6939/6939 - 11s - loss: 0.0200
Epoch 24/100
6939/6939 - 11s - loss: 0.0200
Epoch 25/100
6939/6939 - 11s - loss: 0.0200
Epoch 26/100
6939/6939 - 11s - loss: 0.0200
Epoch 27/100
6939/6939 - 11s - loss: 0.0200
Epoch 28/100
6939/6939 - 11s - loss: 0.0200
Epoch 29/100
6939/6939 - 11s - loss: 0.0200
Epoch 30/100
6939/6939 - 11s - loss: 0.0200
Epoch 31/100
6939/6939 - 12s - loss: 0.0200
Epoch 32/100
6939/6939 - 11s - loss: 0.0200
Epoch 33/100
6939/6939 - 11s - loss: 0.0200
Epoch 34/100
6939/6939 - 11s - loss: 0.0200
Epoch 35/100
6939/6939 - 11s - loss: 0.0200
Epoch 36/100
6939/6939 - 12s - loss: 0.0200
Epoch 37/100
6939/6939 - 13s - loss: 0.0200
Epoch 38/100
6939/6939 - 12s - loss: 0.0200
Epoch 39/100
6939/6939 - 11s - loss: 0.0200
Epoch 40/100
6939/6939 - 11s - loss: 0.0200
Epoch 41/100
6939/6939 - 11s - loss: 0.0200
Epoch 42/100
6939/6939 - 11s - loss: 0.0200
Epoch 43/100
6939/6939 - 11s - loss: 0.0200
Epoch 44/100
6939/6939 - 11s - loss: 0.0200
Epoch 45/100
6939/6939 - 11s - loss: 0.0200
Epoch 46/100
6939/6939 - 11s - loss: 0.0200
Epoch 47/100
6939/6939 - 12s - loss: 0.0200
Epoch 48/100
6939/6939 - 11s - loss: 0.0200
Epoch 49/100
6939/6939 - 11s - loss: 0.0200
Epoch 50/100
6939/6939 - 11s - loss: 0.0200
Epoch 51/100
6939/6939 - 11s - loss: 0.0200
Epoch 52/100
6939/6939 - 11s - loss: 0.0200
Epoch 53/100
6939/6939 - 11s - loss: 0.0200
Epoch 54/100
6939/6939 - 11s - loss: 0.0200
Epoch 55/100
6939/6939 - 11s - loss: 0.0200
Epoch 56/100
6939/6939 - 11s - loss: 0.0200
Epoch 57/100
6939/6939 - 11s - loss: 0.0200
Epoch 58/100
6939/6939 - 12s - loss: 0.0200
Epoch 59/100
6939/6939 - 11s - loss: 0.0200
Epoch 60/100
6939/6939 - 11s - loss: 0.0200
Epoch 61/100
6939/6939 - 11s - loss: 0.0200
Epoch 62/100
6939/6939 - 11s - loss: 0.0200
Epoch 63/100
6939/6939 - 11s - loss: 0.0200
Epoch 64/100
6939/6939 - 11s - loss: 0.0200
Epoch 65/100
6939/6939 - 13s - loss: 0.0200
Epoch 66/100
6939/6939 - 13s - loss: 0.0200
Epoch 67/100
6939/6939 - 11s - loss: 0.0200
Epoch 68/100
6939/6939 - 11s - loss: 0.0200
Epoch 69/100
6939/6939 - 12s - loss: 0.0200
Epoch 70/100
6939/6939 - 11s - loss: 0.0200
Epoch 71/100
6939/6939 - 11s - loss: 0.0200
Epoch 72/100
6939/6939 - 11s - loss: 0.0200
Epoch 73/100
6939/6939 - 11s - loss: 0.0200
Epoch 74/100
6939/6939 - 12s - loss: 0.0200
Epoch 75/100
6939/6939 - 11s - loss: 0.0200
Epoch 76/100
6939/6939 - 11s - loss: 0.0200
Epoch 77/100
6939/6939 - 11s - loss: 0.0200
Epoch 78/100
6939/6939 - 12s - loss: 0.0200
Epoch 79/100
6939/6939 - 12s - loss: 0.0200
Epoch 80/100
6939/6939 - 11s - loss: 0.0200
Epoch 81/100
6939/6939 - 11s - loss: 0.0200
Epoch 82/100
6939/6939 - 11s - loss: 0.0200
Epoch 83/100
6939/6939 - 11s - loss: 0.0200
Epoch 84/100
6939/6939 - 11s - loss: 0.0200
Epoch 85/100
6939/6939 - 13s - loss: 0.0200
Epoch 86/100
6939/6939 - 11s - loss: 0.0200
Epoch 87/100
6939/6939 - 11s - loss: 0.0200
Epoch 88/100
6939/6939 - 11s - loss: 0.0200
Epoch 89/100
6939/6939 - 11s - loss: 0.0200
Epoch 90/100
6939/6939 - 12s - loss: 0.0200
Epoch 91/100
6939/6939 - 11s - loss: 0.0200
Epoch 92/100
6939/6939 - 11s - loss: 0.0200
Epoch 93/100
6939/6939 - 13s - loss: 0.0200
Epoch 94/100
6939/6939 - 11s - loss: 0.0200
Epoch 95/100
6939/6939 - 11s - loss: 0.0200
Epoch 96/100
6939/6939 - 11s - loss: 0.0200
Epoch 97/100
6939/6939 - 11s - loss: 0.0200
Epoch 98/100
6939/6939 - 11s - loss: 0.0200
Epoch 99/100
6939/6939 - 11s - loss: 0.0200
Epoch 100/100
6939/6939 - 12s - loss: 0.0200Average `fraction_recovered` on Ty's grade A loans:
0.96108
胜利！
唷，好险！我的胜利可能太小，没有统计学意义，但嘿，看到我能跟上 LendingClub 最优秀和最聪明的人，这很酷。
进一步阅读
我现在真正想知道的是每个贷款俱乐部等级和子等级对应的估计风险的量化范围，但看起来是专有的。有没有人知道贷款等级一般是不是和学术类的字母等级一样对应一定的百分比范围？如果没有，有没有更好的基准来评估我的模型的性能？请留下您的回复，加入我们的讨论吧！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
