概述

在第一部分中，我开始构建一个用于月度预算应用程序的数据库。我们讨论了 MongoDB 的安装，以及一些语法差异。安装后，我们创建了一个数据库，这是我们的第一个集合，还创建了一个文档放在这个杂货集合中。

在第二部分中，我们讨论了更多关于集合的选项，比如大小限制和验证。了解了上限之后，我们创建了一个样本集合来进行测试，以及测试数据。我们还讨论了如何一次插入多个文档。在此之后，剩余的集合被添加:娱乐，公用事业，租金，保险和紧急情况。我们还向每个集合添加了文档，然后验证它们都在我们的收据数据库中。

继续

现在我们已经完成了 Mongo 数据库和集合，我们可以继续我们的 API 了。为此，我们将使用 FastAPI。区别在于我们如何介绍我们的产品系列。对于我使用 MySQL 的典型表，我通常使用 sqlalchemy 创建一个数据库对象。然而，在 sqlalchemy 中，我们使用 ORM(对象关系映射器)工具，这在 MongoDB 中是无法使用的。Mongo 使用 NoSQL，它不会以同样的方式工作。因此，我们将使用名为 PyMongo 的 Python 发行版。因此，设置将与我们之前创建 FastAPIs 的方式不同。

安装 pymongo

为了让我们开始，我们需要安装 API 所需要的东西。已经安装了 FastAPI，但是我们使用新的 PyMongo 发行版来运行我们的代码。要安装，请运行:

sudo pip3 install pymongo

现在，我们准备开始设置我们的端点。

设置杂货端点

首先，我们将创建一个名为 storage.py 的文件来保存要调用的函数。回想一下，我们将需要为 API 使用 async 和 await。要启动这个文件，我们需要导入 pymongo 发行版:

import pymongo

接下来，我们将建立连接。为此，我们需要创建一个基于 Mongo 的客户机，使用包含数据库和 MongoDB 特定端口的主机。接下来，我们将选择数据库:

client = pymongo.MongoClient(“localhost”, 27017)
db = client.Receipts

在此之后，我们可以创建我们的异步函数来获取食品杂货文档。与 sqlalchemy 非常相似，将在列表中返回结果。但是，ObjectID 是 MongoDB 中的默认主键集，它不能迭代。如果我们想把它附加到一个列表中，这是一个大问题。为了解决这个问题，我们可以将值重置为一个字符串，这样我们就只有 GUID 值了。这将需要在 select 中所有项目的 for 循环中完成，在 Mongo 中这将是一个“find”。更正 ObjectID 后，将其附加到我们创建的列表中。接下来，关闭数据库连接。最后，返回列表。

async def get_groceries():
     GroceryList = [] for item in db.Grocery.find():
          item[“_id”] = str(item[“_id”])
          GroceryList.append(item) client.close()
     return GroceryList

设置好函数后，我们现在可以设置端点了。首先，创建 app.py 文件。接下来，我们将使用几个导入。请注意，我们可能还没有全部用到，但将来会用到。

from fastapi import FastAPI
from typing import List
from pydantic import BaseModelimport storage

接下来，设置 FastAPI 的基础:

app = FastAPI (
     title = “Receipts API”,
     description = “View receipts”,
     version = “1.0”
)

现在，我们只需要创建端点。为此，设置异步函数来获取杂货收据。然后，设置一个变量，该变量将等待我们在存储文件中设置的结果。最后，返回该变量。

@app.get(“/receiptsapi/v1/grocery”)
async def GetGrocery():
     groceries = await storage.get_groceries()
     return groceries

为了测试，我们将使用 uvicorn 来运行应用程序。如果你还不知道，uvicorn 是一个 ASGI(异步服务器网关接口)服务器实现，它允许我们创建自己的 Python 框架。如果尚未安装，请使用:

sudo pip3 install uvicorn

安装完成后，我们就可以运行 python 应用程序了。我做的有点不同，像这样:

uvicorn app:app –-reload –-host <HOSTNAME> --port <PORTNUMBER>

请注意，端口号可以是您想要的任何值，但是主机名应该包含您的应用程序，在我的例子中是我的 Ubuntu IP 地址。现在，我们已经准备好进行测试，并且应该对我们创建的每个端点进行测试。

杂货端点输出。

设置紧急端点

在第一部分中已经做好了准备，我们可以直接开始编写端点代码了。它将遵循与杂货店端点相同的格式，只是使用不同的描述性名称。首先，处理 storage.py 文件:

async def get_emergencies():
     EmergencyList = [] for item in db.Emergency.find():
          item[“_id”] = str(item[“_id”])
          EmergencyList.append(item) client.close()
     return EmergencyList

接下来，在 app.py 文件上创建端点:

@app.get(“/receiptsapi/v1/emergency”)
async def GetEmergency():
     emergencies = await storage.get_emergencies()
     return emergencies

现在你要做的就是测试:

紧急端点输出。

设置娱乐端点

现在，我们可以设置下一个端点。为此，我们将遵循相同的步骤。首先，设置 storage.py 文件:

async def get_entertainment():
     EntertainmentList = [] for item in db.Entertainment.find():
          item[“_id”] = str(item[“_id”])
          EntertainmentList.append(item) client.close()
     return EntertainmentList

接下来，app.py 文件端点:

@app.get(“/receiptsapi/v1/entertainment”)
async def GetEntertainment():
     entertainment = await storage.get_entertainment()
     return entertainment

现在测试:

娱乐端点输出。

设置保险端点

我知道这越来越重复，但坚持我，我们就快到了。像前面一样从 storage.py 文件开始:

async def get_insurance():
     InsuranceList = [] for item in db.Insurance.find():
          item[“_id”] = str(item[“_id”])
          InsuranceList.append(item) client.close()
     return InsuranceList

接下来，app.py 文件中的端点:

@app.get(“/receiptsapi/v1/insurance”)
async def GetInsurance():
     insurance = await storage.get_insurance()
     return insurance

返回给邮递员进行测试:

保险端点输出。

设置租金端点

首先，storage.py 文件需要编码:

async def get_rent():
     RentList = [] for item in db.Rent.find():
          item[“_id”] = str(item[“_id”])
          RentList.append(item) client.close()
     return RentList

接下来，对 app.py 端点做一点工作:

@app.get(“/receiptsapi/v1/rent”)
async def GetRent():
     rent = await storage.get_rent()
     return rent

现在添加到测试:

租用端点输出。

设置应用端点

好吧，最后一个。将以下内容添加到 storage.py 文件中:

async def get_utilities():
     UtilityList = [] for item in db.Utility.find():
          item[“_id”] = str(item[“_id”])
          UtilityList.append(item) client.close()
     return UtilityList

现在是 app.py 文件中的最后一个变化:

@app.get(“/receiptsapi/v1/utility”)
async def GetUtility():
     utilities = await storage.get_utilities()
     return utilities

最后，最后一个邮递员测试:

实用程序端点输出。

回想一下，我们还可以看看我们的 Swagger 文档:

Swagger 文档。

通过 Swagger 测试端点。

结论

虽然这可能是重复的，但是我们能够为月度预算应用程序创建一个 API。因为 MongoDB 使用 NoSQL，所以我们无法使用常规的 sqlalchemy。这是因为，对于 sqlalchemy，我们使用 ORM 工具，它是专门为关系数据库设计的。正如我们在第一部分中了解到的，NoSQL 没有使用关系模型。

我们可以通过使用 pymongo 来解决这个问题，py mongo 允许我们读取集合。尽管编码非常相似，但我们创建了不同的端点来读取每个集合。

随着端点的创建，我们能够查看集合中的文档。接下来，我们可以进行插入、更新和删除。在那之前，干杯！

参考文献

T3【https://www.uvicorn.org/】T5

https://pymongo.readthedocs.io/en/stable/

https://docs . MongoDB . com/manual/reference/method/db . create user/

https://real python . com/introduction-to-MongoDB-and-python/# MongoDB

https://github.com/dcrosta/professor/issues/13

MongoDB

原文：https://towardsdatascience.com/mongodb-92370a2641ad?source=collection_archive---------29-----------------------

从安装到实现:第 6 部分

马库斯·温克勒在 Unsplash 上的照片

前情提要

在第五部分中，我们学习了如何使用一些不同的 Mongo 命令更新文档。我们还讨论过，由于嵌入了文档，更新起来会有点困难，因为细节可能会被覆盖。在更新时，我们了解到我们可以更新每个字段，或者我们可以只更新特定的字段。当我们讨论了几种不同的更新方法后，我们决定花一点时间来考虑如何更新我们的 FastAPI 部分。

这次在 MongoDB 上

花了一点时间，我决定如何更新我们的文件。请记住，这只是我的解决方案，它可能不是唯一的解决方案，也不是最好的解决方案。这只是为了记录我在学习过程中决定要做的事情，所以请在评论中分享你的想法。

因为嵌入的文件，我们必须小心。然而，在查看一个前端应用程序时，我决定更新所有段，并简单地发送整个 JSON 对象进行更新。当显示时，用户可以决定是否需要更新该字段，或者是否用相同的数据替换它。发送整个对象不仅可以动态地更新文档，还可以提供嵌入的文档。

现在，为了让这个更新按照我想要的方式工作，就像 INSERT 一样，我们正在使用我们设置的类。因此，如果文档缺少任何字段，比如带有可选优惠券或礼券卡的杂货文档，它们将被添加并设置为 null。不理想，但也没什么关系。我们总是可以在我们的前端代码中加入不显示任何空值的逻辑，但是拥有它们实际上对我们有利。它将允许用户添加那些他们以前没有的字段，没有太大的困难。因此，不再拖延，让我们进入代码。

设置杂货更新端点

回想一下，我们有一个 app.py 文件和一个 storage.py 文件。app 文件包含 FastAPI 调用，而存储文件处理函数和我们的 MongoDB。

为了创建我们的更新端点，我们首先需要创建函数。首先，让我们来看看我们的存储文件。在 Mongo 中更新时，我们使用了 update 函数。第一个参数包含一个类似于 SQL WHERE 子句的语句，在该语句中，我们首先选择要更新的文档。如果留空，它将更新所有。第二个参数有“$set”指令，类似于 SQL SET 语句。但是，因为字段也将包含在 JSON 对象中，所以我们可以简单地发送整个对象，而不需要声明每个字段及其值。这有助于我们抓住整个物体。

也就是说，当我用 Postman 测试时，我不发送 id 主键以确保它不会被意外更新。当我们在代码中发送对象时，我们需要做的就是确保用户不能编辑我们的 ObjectID，这将解决我们的问题。出于测试的目的，我们可以将它从通过 Postman 发送的对象中去掉。

此外，我们允许一个 upsert，这意味着如果由于某种原因 ID 匹配不上，它将插入该文档。一旦我们有了前端，我们的代码就不需要这个了，但是万一用户忘记刷新页面或者有东西被缓存了，我们需要确保数据不会就这么消失了。了解了所有这些，下面是我们将添加到存储文件中的函数:

@app.put(“/receiptsapi/v1/grocery/{id}”)
async def UpdateGrocery(grocery: Grocery, id: str):
     groceries = await storage.update_groceries(grocery.dict(), id)
     return groceries

既然我们已经设置了代码，我们就可以选择更新哪个文档了。我选择了以下内容:

选定的杂货店记录。

这正是我们将要复制到 Postman 主体中的内容，但是没有 ObjectID。所以我们来做个改变。我们可以改变我们的总金额，也可以改变我们的嵌入式文档列表中的项目数。现在只需发送 PUT 并确保 URL 中的 ID 是正确的。

PUT 请求响应。

我们收到了很好的回应，但为了确保万无一失，让我们回去看看收集。

更新了杂货店记录。

看起来我们的收藏更新没有任何问题。唯一需要注意的问题是添加了“优惠券”和“礼品卡”字段，但这也不是问题，因为现在用户有机会添加这些字段。我们可以去下一个终点了。

设置紧急更新端点

首先，让我们转到 storage.py 文件。我们的函数看起来与 update _ goals 函数几乎相同，只是变量名称不同。您可能还记得，这个集合中没有嵌入的文档，但是我们的调用看起来是一样的。这就是为什么我选择这条路线进行更新；我们正在使用更动态的更新。

async def update_emergencies(emergency, emergencyId):
     try:
          db.Emergency.update_one({“_id”: ObjectId(emergencyId)}, {“$set”: emergency}, upsert=True)
          return {“response”: “User Updated: %s” % emergencyId}
     except Exception as e:
          client.close()
          raise HTTPException(status_code = 404, detail = e)

接下来，我们可以添加到 app.py 文件并设置我们的端点。同样，除了名称变化之外，它看起来与杂货店端点相同，但是我们所有的端点都是相同的，只有很少的变化。

@app.put(“/receiptsapi/v1/emergency/{id}”)
async def UpdateEmergency(emergency: Emergency, id: str):
     emergencies = await storage.update_emergencies(emergency.dict(), id)
     return emergencies

现在，我们查看当前的紧急情况，以选择哪些将被更新。

选定的紧急记录。

我选择了这份文件。在原因中，我们还可以补充说，较高的价格是由于该日期是一个假期。这样，将来我们可以回忆起为什么定价会超出我们的预算。因此，让我们将 ObjectID 放入 URL，使用 PUT 调用我们的端点，然后查看文档是否被正确更新:

PUT 请求响应。

更新了紧急记录。

设置娱乐更新端点

现在我相信你已经明白了。首先，转到存储文件来设置函数:

async def update_entertainment(entertainment, entertainmentId):
     try:
          db.Entertainment.update_one({"_id": ObjectId(entertainmentId)}, {"$set": entertainment}, upsert=True)
          return {"response": "User Updated: %s" % entertainmentId}
     except Exception as e:
          client.close()
          raise HTTPException(status_code = 404, detail = e)

接下来，转到应用程序文件来设置端点:

@app.put("/receiptsapi/v1/entertainment/{id}")
async def UpdateEntertainment(entertainment: Entertainment, id: str):
     entertainment = await
storage.update_entertainment(entertainment.dict(), id)
     return entertainment

现在查看集合并选择一个要更新的文档:

精选娱乐唱片。

在 Postman 中，设置 URL，包括 ObjectID，然后在正文中围绕您想要的内容进行更改。例如，让我们使用礼品卡进行交易。礼品卡可以吃掉全部金额，所以我们的总数将是零。运行后，仔细检查更新的文档。

PUT 请求响应。

更新娱乐记录。

设置保险更新端点

首先，在存储文件中设置更新功能:

async def update_insurance(insurance, insuranceId):
     try:
          db.Insurance.update_one({"_id": ObjectId(insuranceId)}, {"$set": insurance}, upsert=True)
          return {"response": "User Updated: %s" % insuranceId}
     except Exception as e:
          client.close()
          raise HTTPException(status_code = 404, detail = e)

现在转到应用程序文件来创建端点:

@app.put("/receiptsapi/v1/insurance/{id}")
async def UpdateInsurance(insurance: Insurance, id: str):
     insurance = await storage.update_insurance(insurance.dict(), id)
     return insurance

接下来，选择要更新的文档。

选定的保险记录。

对于这次更新，我将使用 Geico，而不是 Progressive，只是为了表明如果犯了一个简单的错误，它可以被纠正。你知道该怎么做。邮递员的时间到了。

PUT 请求响应。

更新了保险记录。

设置租金更新端点

首先，我们将函数添加到存储文件中:

async def update_rent(rent, rentId):
     try:
          db.Rent.update_one({“_id”: ObjectId(rentId)}, {“$set”: rent}, upsert=True)
          return {“response”: “User Updated: %s” % rentId}
     except Exception as e:
          client.close()
          raise HTTPException(status_code = 404, detail = e)

接下来，将更新端点添加到应用程序文件:

@app.put("/receiptsapi/v1/rent/{id}")
async def UpdateRent(rent: Rent, id: str):
     rent = await storage.update_rent(rent.dict(), id)
     return rent

最后，选择您想要更新的文档，将更改放入 Postman，并监视发生了什么。

选定的租金记录。

PUT 请求响应。

更新的租金记录。

设置实用程序更新端点

在我们的测试中，让我们改变一下。但是首先，我们必须添加我们的代码。最后一个。首先，将函数添加到存储文件中:

async def update_utility(utility, utilityId):
     try:
          db.Utility.update_one({"_id": ObjectId(utilityId)}, {"$set": utility}, upsert=True)
          return {"response": "User Updated: %s" % utilityId}
     except Exception as e:
          client.close()
          raise HTTPException(status_code = 404, detail = e)

接下来，我们将端点添加到应用程序文件中:

@app.put("/receiptsapi/v1/utility/{id}")
async def UpdateUtility(utility: Utility, id: str):
     utilities = await storage.update_utility(utility.dict(), id)
     return utilities

之后，选择要更新的记录:

选定的公用事业记录。

所以在 Postman 中，我们将只发送一个字符的 ID。例如，结尾的“d”将改为“f”。因为“upsert ”,它应该会添加一个新的记录，但是让我们测试一下。对于我们的更新，我们应该将总数、创建日期更改为最近的日期，将事务日期更改为下个月。记住，它应该更新整个记录，但是我们的 ID 只差一个字符。

现在，当您检查时，响应显示“用户已更新”，但我们希望如此，因为这是我们在成功时发送的消息。但是，请再次检查集合:

更新了效用记录。

如您所见,“upsert”允许将记录添加到数据库中。如果您不想要该特性，只需将“upsert”设置为 False，当在集合中找不到该 ID 时，很可能会返回一个错误。但就我的目的而言，我希望保留该功能。

结论

在 MongoDB/FastApi 项目的这一部分，我们为每个集合创建了更新端点。我们讨论了“upsert”选项的作用，以及我为什么选择在这个项目中使用它。

至于 Mongo 和 FastApi 编码，那是我们收据跟踪项目的最后一部分。剩下唯一要做的就是给我们的项目一个前端 app。我希望通过使用 pymongo 库，您对 MongoDB 有了更多的了解，甚至对 FastApi 也有了一些了解。我确实从这次经历中吸取了教训。为了了解更多，我正在考虑扩展到 React 的前端，因为我的经验仍然有限。它应该继续是一个有趣的项目。下次见，干杯！

用我的 每周简讯 免费阅读我的所有文章，谢谢！

想阅读介质上的所有文章？成为中等 成员 今天！

查看我最近的文章:

https://python.plainenglish.io/organizing-my-pictures-with-mysql-and-python-ca5dee8fe02f https://medium.com/codex/all-along-ive-been-using-a-sql-antipattern-50f9a6232f89 https://python.plainenglish.io/creating-a-basic-photoshop-app-with-python-c24181a09f69 https://python.plainenglish.io/the-lazy-way-of-using-python-to-search-wikipedia-fce2a7260390 https://python.plainenglish.io/building-an-old-school-text-based-game-with-python-efcc33d25a42

参考资料:

https://docs.mongodb.com/manual/reference/method/db.collection.update/ https://kb.objectrocket.com/mongo-db/how-to-update-a-mongodb-document-in-python-356

云中的 MongoDB:2021 年的三种解决方案

原文：https://towardsdatascience.com/mongodb-in-the-cloud-three-solutions-for-2021-ee87c4ef4ef?source=collection_archive---------29-----------------------

MongoDB Atlas、AWS DocumentDB、Azure Cosmos DB 的定价和兼容性概述。

作者:爱德华·克鲁格和道格拉斯·富兰克林。

照片由约尔·温克勒在 Unsplash 上拍摄

本文将调查 MongoDB 的 MongoDB Atlas 、AWS Amazon DocumentDB 和 Azure Cosmos DB 提供的成本和功能。我们假设我们不是在谈论超大规模的企业解决方案。我们正在寻找一个更典型的应用程序。

与此相关的一个原因是，MongoDB 公司决定在今年晚些时候终止 mLab 服务。这是为了将用户转移到该公司较新的平台 MongoDB Atlas。然而，今天有许多 MongoDB 的云提供商。我们将讨论 MongoDB Atlas、Azure Cosmos DB 和 AWS DocumentDB。

什么是 MongoDB？

MongoDB 是一个面向文档的数据库，它将数据存储为 BSON 对象或文档组成的*集合。*这些文档可以作为 JSON 的文档进行检索。这意味着您可以不使用 RDBMS 中的列和行结构来存储记录。

MongoDB 云数据库是内容管理、产品目录、地理空间数据应用程序以及任何具有快速变化的数据需求的项目的绝佳解决方案。

云提供商

有许多可用的 MongoDB 云解决方案。开发团队或公司最终决定采用什么解决方案，很可能取决于特性、价格以及与您现有架构的集成。

这里讨论的所有选项都是托管云服务。这意味着现代数据库中所需的所有数据库管理和安全任务都将由服务提供商来处理。忽略这些解决方案的共同点，让我们分解一些差异。

MongoDB 地图集

MongoDB 成立于 2007 年，面临着获得更多用户和赚更多钱的压力。该公司在 2016 年建立了 Atlas，在 2018 年以 6800 万美元收购了 mLab，然后在 2020 年底弃用了 mLab。

MongoDB Atlas 是 MongoDB 公司提供的解决方案。因此，MongoDB Atlas 是最完整的 MongoDB 解决方案。使用 MongoDB Atlas，您将可以访问所有的 MongoDB 特性和方法，包括 map-reduce 。此外，您将能够运行4.4 版、4.0 版或 3.6 版 API。

亚多拉斯数据库的另一个好处是，你可以灵活地使用其他云服务提供商(AWS、Azure 和 GCP)。我们可以很容易地将我们的应用程序转换成运行在 GCP MongoDB Atlas 上的应用程序。

**MongoDB Atlas 确实有一个免费层。**然而，如果您需要更强大的计算能力，10GB 存储、2GB ram 和 1 个 vCPU 的价格约为每月 57 美元。

有关设置 MongoDB Atlas 或迁移到 MongoDB Atlas 的更多信息，请查看本文。

天蓝色宇宙数据库

Azure Cosmos DB 是微软针对文档数据库的 Azure 解决方案。Azure Cosmos DB 使用*ru 或资源单位，*使得定价比其他云平台稍微不透明。但是，您可以使用 RU 计算器来转换成美元并估计成本。

这里有一个 Azure DB 月度成本计算器。

Azure 确实有一个免费层，授予帐户中的前 400 RU/s 和 5 GB 存储空间。

Azure Cosmos DB free tier 让您可以轻松开始、开发和测试您的应用程序，甚至免费运行小型生产工作负载。免费层拥有普通 Azure Cosmos DB 帐户的所有好处和功能。 Cosmos DB 使用 MongoDB v3.6 API，不支持 map-reduce。

在你的免费积分用完之后， Cosmos DB 费用比竞争对手低。对于使用最少的 1.5 GB ram 的 10GB 数据，每月大约需要 25 美元。

此外，Azure 现在提供了一个无服务器选项。这对于使用不一致或使用率低的应用程序非常有用，如内部业务应用程序或概念证明。在无服务器模式下使用 Azure Cosmos DB 没有最低费用。Azure Cosmos DB server less只对数据库操作消耗的 ru 和数据消耗的存储进行计费。这可以大幅降低不常访问或不定期访问的应用程序的成本。

也就是说，对于常规的数据加载，无服务器不是一个好的解决方案。无服务器确实提供了自动扩展；然而，成本可能很高。

关于设置 Azure Cosmos DB 或迁移到 Cosmos DB 的更多信息，请查看本文。

AWS 文档 b

亚马逊网络服务解决方案是亚马逊文档数据库。 **AWS DocumentDB 没有空闲层。**目前最便宜的实例是 db t3.medium ，它有 10GB 的存储空间，配有 4GB RAM 和 2 个 vCPUs，价格大约是每月 60 美元。请注意，这大约是 Azure 和 Atlas 提供的 RAM 的两倍。

有了 AWS DocumentDB，您可以选择使用 v3.6 或 v4.o API 。该平台缺少 Atlas 中可用的地图缩小功能。供应商锁定是 AWS 需要记住的另一件事。如果您的公司已经在其他云提供商上使用 AWS 服务，这个解决方案可以很好地协同工作。

供应商锁定并非不可避免，但这是额外的工作和费用。例如，要在 Heroku 应用程序中使用 AWS DocumentDB，您需要获得 Heroku enterprise，这很贵。

Amazon DocumentDB 是一项仅限 VPC 的服务，不支持公共端点。因此，您不能从 AWS 之外的环境直接连接到 Amazon DocumentDB 集群。但是，您可以使用 SSH 隧道从 AWS 外部的机器进行连接。

结论

团队需要考虑功能、定价和现有架构，以选择最佳的云 MongoDB 解决方案。有些决定会很容易；比如需要 map-reduce，选择 MongoDB Atlas。如果你打算做一个低使用率的应用，使用 Azure Cosmos Serverless 来节省成本。

对于可预测的负载，Azure serverless 可能很粗糙。人们经常选择无服务器选项，因为它们非常容易扩展。这个问题是大规模无服务器扩展的成本会高得出乎意料。但是，如果每一次扩展都意味着额外的收入，那么可变成本就对应于可变收入。例如，考虑一个黑色星期五的网上商店。无法通过自动扩展来容纳额外的流量对于收入损失来说是一场灾难。

如果你的应用是托管在 Heroku(不是企业)上，选择 MongoDB Atlas 或者 Azure Cosmos。使用 MongoDB Atlas，您可以选择任何您喜欢的云提供商，并使用最新的 MongoDB API 功能。这种灵活性是 Amazon Document DB 或 Azure Cosmos DB 所不具备的。这些选项将您锁定在各自的云供应商，同时运行旧版本的 DB API。

如果您的公司有一些使用 AWS 的现有项目，或者您喜欢该平台，AWS DocumentDB 可能是一个很好的解决方案。请记住与其他云服务的兼容性问题。

AWS Amazon Document DB 和 Azure Cosmons 支持创建应用程序所需的大部分功能。我们注意到唯一缺少的特性是 map-reduce 方法。所以如果你是用 MongoDB 来使用这个特性，Document DB 或者 Cosmos 对你来说可能不是一个好的解决方案；Atlas 将更好地满足您的需求。

用 TensorBoard 监控 BERT 模型训练

原文：https://towardsdatascience.com/monitor-bert-model-training-with-tensorboard-2f4c42b373ea?source=collection_archive---------11-----------------------

梯度流量和更新率

https://unsplash.com/@tobiastu

在的上一篇文章中，我们解释了 BERT 模型的所有构建组件。现在，我们将在 TensorBoard 中训练监控训练过程的模型，查看梯度流、更新参数比率、损失和评估指标。

为什么我们希望监控梯度流量和更新率，而不是简单地查看损失和评估指标？当我们开始对大量数据进行模型训练时，我们可能会在意识到之前运行许多次迭代，查看模型没有训练的损失和评估指标。在这里，查看梯度的大小和更新率，我们可以立即发现有问题，这为我们节省了时间和金钱。

数据准备

我们将使用来自 sklearn 的【T20 个新闻组数据集(许可证:公共域/来源:http://qwone.com/~jason/20Newsgroups/)在这个例子中有 4 个类别: alt .无神论、 talk.religion.misc 、 comp.graphics 和 sci.space. 我们用来自变形金刚的bertokenizer对数据进行标记化

categories = ['alt.atheism', 'talk.religion.misc', 'comp.graphics', 'sci.space']newsgroups_train = fetch_20newsgroups(subset='train', categories=categories)
newsgroups_test = fetch_20newsgroups(subset='test', categories=categories)X_train = pd.DataFrame(newsgroups_train['data'])
y_train = pd.Series(newsgroups_train['target'])X_test = pd.DataFrame(newsgroups_test['data'])
y_test = pd.Series(newsgroups_test['target'])BATCH_SIZE = 16max_length = 256
config = BertConfig.from_pretrained("bert-base-uncased")
config.num_labels = len(y_train.unique())
config.max_position_embeddings = max_lengthtrain_encodings = tokenizer(X_train[0].tolist(), truncation=True, padding=True, max_length=max_length)
test_encodings = tokenizer(X_test[0].tolist(), truncation=True, padding=True, max_length=max_length)class BertDataset(Dataset):def __init__(self, encodings, labels):
 self.encodings = encodings
 self.labels = labelsdef __getitem__(self, idx):
 item = {key: torch.tensor(val[idx]).to(device) for key, val in 
self.encodings.items()}
 item[‘labels’] = torch.tensor(self.labels[idx]).to(device)
 return itemdef __len__(self):
 return len(self.labels)train_dataset = BertDataset(train_encodings, y_train)
test_dataset = BertDataset(test_encodings, y_test)train_dataset_loader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
test_dataset_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE)for d in train_dataset_loader:
    print(d)
    break# output : 
{'input_ids': tensor([[ 101, 2013, 1024,  ...,    0,    0,    0],
         [ 101, 2013, 1024,  ..., 1064, 1028,  102],
         [ 101, 2013, 1024,  ...,    0,    0,    0],
         ...,
         [ 101, 2013, 1024,  ..., 2620, 1011,  102],
         [ 101, 2013, 1024,  ..., 1012, 4012,  102],
         [ 101, 2013, 1024,  ..., 3849, 2053,  102]], device='cuda:0'),
 'token_type_ids': tensor([[0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         ...,
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0],
         [0, 0, 0,  ..., 0, 0, 0]], device='cuda:0'),
 'attention_mask': tensor([[1, 1, 1,  ..., 0, 0, 0],
         [1, 1, 1,  ..., 1, 1, 1],
         [1, 1, 1,  ..., 0, 0, 0],
         ...,
         [1, 1, 1,  ..., 1, 1, 1],
         [1, 1, 1,  ..., 1, 1, 1],
         [1, 1, 1,  ..., 1, 1, 1]], device='cuda:0'),
 'labels': tensor([3, 0, 2, 1, 0, 2, 2, 1, 1, 0, 1, 3, 3, 0, 2, 1], device='cuda:0')}

张量板的使用

TensorBoard 允许我们编写和保存不同类型的数据，包括图像和标量，以供将来分析。首先让我们用 pip 安装 tensorboard:

pip 安装张量板

要写入 TensorBoard，我们将使用来自torch . utils . tensor board的 SummaryWriter

from torch.utils.tensorboard import SummaryWriter# SummaryWriter takes log directory as argument
writer = SummaryWriter(‘tensorboard/runs/bert_experiment_1’)

为了编写标量，我们使用:

writer.add_scalar(‘loss/train’, loss, counter_train)

需要变量 counter_train 来知道向 TensorBoard 写入内容的步数。
要写一个图像，我们将使用以下内容:

writer.add_figure(“gradients”, myfig, global_step=counter_train, close=True, walltime=None)

模特培训

现在让我们看看我们的训练函数

out_every 变量控制写入 TensorBoard 的频率，以步数衡量。我们还可以使用 step_eval 变量，比在每个时期之后更频繁地进行评估。梯度流量和更新比率数字分别从 plot_grad_flow 和 plot_ratios 函数返回。

我们传递模型的参数，为了更好的可视化，我们可以决定用 skip_prob 参数跳过一些层。我们写下每层梯度的平均值、最大值和标准偏差，忽略偏差层，因为它们不太有趣。如果你也想显示 bias 的渐变，你可以删除第 17 行的部分。我们还显示了每层中零梯度的百分比。需要强调的是，由于 BERT 使用 GeLU 而不是 ReLU 激活函数，这最后一个图可能不太有用，但如果您使用的是 ReLU 的不同模型，该模型存在死亡神经元问题，显示零梯度的百分比实际上是有帮助的。

plot_ratios 函数显示每个参数的更新/参数比率，这是一个标准化测量，因为更新除以参数值，并有助于了解您的神经网络如何学习。作为一个粗略的启发，这个值应该在 1e-3 左右，如果低于这个值，学习率可能太低，否则太高。此外，您可以通过 skip_prob 参数减少显示的图层。

在模型训练期间，您可以使用以下命令启动 TensorBoard:

tensorboard --samples_per_plugin images=100 --logdir bert_experiment_1

否则，您可以创建一个*。bat* 文件(在 Windows 上)以便更快地启动。创建一个新文件，例如run _ tensor boardwith*。bat* 扩展并复制粘贴以下命令，相应修改 path_to_anaconda_env，path_to_saved_results 和 env_name 。然后点击文件启动 TensorBoard。

cmd /k “cd path_to_anaconda_env\Scripts & activate env_name & cd path_to_saved_results\tensorboard\runs & tensorboard — samples_per_plugin images=100 — logdir bert_experiment_1”

定义samples _ per _ plugin images = 100我们显示这个任务中的所有图像，否则默认情况下 TensorBoard 只会显示其中的一部分。

结果

监控这些情节，我们可以很快发现事情是否如预期发展。例如，如果许多图层的渐变为零，您可能会遇到渐变消失的问题。同样，如果比率非常低或非常高，您可能希望立即深入了解，而不是等到训练结束或训练的几个时期。

例如，通过下面的配置查看 240 步的比率和梯度，我们可以看到情况看起来很好，我们的训练进行得很好——我们可以期待最终的好结果。

EPOCHS = 5
optimizer = AdamW(model.parameters(), lr=3e-5, correct_bias=False)
total_steps = len(train_dataset_loader) * EPOCHS
scheduler = get_linear_schedule_with_warmup(
                   optimizer,
                   num_warmup_steps= 0.7 * total_steps,
                   num_training_steps=total_steps
                                            )

比率更新，作者图片

渐变流，按作者排列的图像

事实上，最终结果是:

训练/测试准确性，图片由作者提供

而如果我们将计划设置更改为:

scheduler = get_linear_schedule_with_warmup(
 optimizer,
 num_warmup_steps= 0.1 * total_steps,
 num_training_steps=total_steps
 )

我们从图中注意到，在第 180 步，模型没有学习，我们可以停止训练以进一步研究。在这种情况下，将 num_warmup_steps 设置为 0.1 * total_steps 使得学习率降低，并且在训练开始后不久变得非常小，并且我们最终得到消失的梯度，该梯度不会传播回网络的第一层，从而有效地停止了学习过程。

比率更新，作者图片

渐变流，按作者排列的图像

训练/测试准确性，图片由作者提供

你可以在的这个 GitHub repo 中找到完整的代码，自己尝试一下。

结论

在阅读完这篇文章和之前的文章之后，你应该拥有所有的工具，并且理解如何在你的项目中训练 Bert 模型！我在这里描述的是一些你想在培训期间监控的东西，但 TensorBoard 提供了其他功能，如嵌入投影仪，你可以使用它来探索你的嵌入层，以及更多你可以在这里找到的功能。

参考

https://cs231n.github.io/neural-networks-3/

使用 Amazon SageMaker 功能商店和 AWS Glue DataBrew 监控 ML 功能

原文：https://towardsdatascience.com/monitor-ml-features-using-amazon-sagemaker-feature-store-and-aws-glue-databrew-c530abcc479a?source=collection_archive---------21-----------------------

阿诺·劳尔、伊万·卡塔纳和马克·罗伊联合发文

功能推动机器学习(ML)预测，这些预测对业务越来越重要，并嵌入到运营流程中。在从事不同项目的数据科学团队之间共享可重用特性时，特性质量和准确性至关重要。由于现实世界的变化或测量方法的变化，生产要素数据分布可能会随着时间的推移而偏离基线要素数据集。特征漂移表示给定特征的值的分布不再与过去存在的分布一致。当特征漂移时，在这些特征上训练的所有模型的精度都降低。例如，鉴于零售店客流量和餐馆访问量的变化，基于疫情之前数据的需求预测模型表现不佳。通过使用数据分析和收集相关统计数据，您可以监控特征漂移，从而保持对模型质量的控制，并采取调整特征变换等措施来解决数据质量问题，甚至引入新特征来保持或提高模型的准确性。

照片由 Julentto 摄影在 Unsplash 上拍摄

如今，公司正在建立特征库，以便在训练和实时推理期间为 ML 特征提供中央存储库，从而保持特征的一致性。数据科学团队可以将功能共享到中央存储库中，促进重用并消除返工。特性存储还提供了跨团队的一组统一的特性定义，使人们更容易一起工作。然而，利益相关者对驱动最大似然预测的特征的状态几乎没有可见性。在最好的情况下，他们构建并维护自己的基础设施和工具来监控特性质量，以尝试展现这些洞察力。如果没有适当的功能监控，跨团队和业务单元的功能可重用性的愿景将遥不可及。团队不信任已发布的特性，因为用户不能欣赏特性的质量。因此，在构建定制监控的工具上实现了大量的投资，这花费了核心 ML 工作的时间和精力。

探索现有要素以供重用的数据科学家需要轻松访问要素数据剖面和统计数据。特征漂移检测识别模型再训练和特征处理改进的机会。

在这篇文章中，我们概述了如何使用亚马逊 SageMaker 功能商店和 AWS Glue DataBrew 实现功能监控解决方案。如果你是功能商店的新手，你可能想在开始这篇文章之前回顾一下了解亚马逊 SageMaker 功能商店的关键功能以获得更多的背景知识。

架构概述

以下架构使用 DataBrew 进行特性分析，使用 Amazon 简单存储服务 (S3)将一段时间内的特性分析数据存储为 JSON 文件，以便使用笔记本电脑或商业智能(BI)仪表板进行分析和可视化。

使用 AWS Glue DataBrew 进行特征监控(图片由作者提供)

Feature Store 是专门为 ML 功能管理构建的解决方案，可帮助数据科学团队跨团队和模型重用 ML 功能，以低延迟为大规模模型预测提供功能，并更快速有效地培训和部署新模型。

DataBrew 是一个可视化的数据准备工具，可以帮助您清理和规范化数据，而无需编写代码。DataBrew 还允许您指定在运行分析作业时为数据集自动生成哪些数据质量统计数据。这允许您自定义数据配置文件统计数据，例如根据数据集的性质和大小确定异常值和相关性，并创建仅包含满足您需求的统计数据的自定义数据配置文件概述。

将要素存储和数据构建结合使用时，您可以监控现有要素存储上的 ML 要素，查看要素数据随时间的分布，以及所有 ML 要素的要素数据质量，从而获得更高质量的 ML 模型。

在本文中，我们提供了两种配置 DataBrew 的方法:第一种是直接使用控制台，第二种是以编程方式。在较高层次上，您可以创建一个 DataBrew 数据集，该数据集连接到在 AWS 粘合数据目录中定义的要素组表，然后配置 DataBrew 配置文件作业以生成要素统计数据。然后，您可以使用 DataBrew 控制台仪表板来可视化特性统计数据、它们的分布以及其他自动生成的信息，以便更好地了解特性。

先决条件

在开始本教程之前，请确保您的 AWS 身份和访问管理 (IAM) SageMaker 执行角色包含创建解决方案所需资源的权限。这包括访问亚马逊 S3、亚马逊雅典娜、 AWS Glue 和 DataBrew 操作。

在这篇文章中，我们使用了来自使用 Faker Python 库合成生成的客户列表的合成杂货订单。你可以按照这个模块自己试试。对于每个客户，笔记本电脑会生成 1-10 个订单，每个订单中都会有购买的产品。目标是说明如何使用功能存储进行功能管理，以及如何使用 DataBrew 来监控这些功能。下面是使用亚马逊 SageMaker Studio 控制台定义功能组的截图。

特征组定义(图片由作者提供)

功能存储在您的帐户中使用 S3 存储桶来存储离线数据。您可以针对亚马逊 S3 的离线数据存储使用类似 Athena 的查询引擎来分析要素数据或在单个查询中连接多个要素组。Feature Store 会在创建功能组的过程中自动为功能组构建一个数据目录，然后您可以使用 Athena 甚至像 Presto 这样的开源工具使用这个目录来访问和查询离线存储中的数据。

使用 DataBrew 控制台生成统计数据

在本节中，我们将详细介绍如何使用 DataBrew 控制台直接监控离线功能组。我们首先需要使用CREATE TABLE AS SELECT(CTAS)从离线特性存储中将特性组表的快照创建到 Athena 中来自查询结果的新表中。关于 Athena 查询的更多示例，请参见带有 Athena 和 AWS Glue 的查询特征库。我们创建的快照只包含最新的特性组记录，没有任何已删除的记录，并将其作为 DataBrew 提供的分析功能的输入。这个快照很重要，因为离线存储包含整个功能历史。特征轮廓必须集中在给定时间点的特征上。同样，特征漂移检测只有在比较一系列特征轮廓时才有意义。

要为离线功能存储的快照创建 DataBrew 数据集，请完成以下步骤:

1. 在 DataBrew 控制台的导航窗格中，选择数据集。
2. 选择连接新数据集。
3. 选择存储离线功能商店快照的 AWS Glue 表(对于本文，fscw-orders-07–13–17–38–1626198069-ctas-temp)。
4. 选择创建数据集。

重复这些步骤，为离线要素存储中的其他要素组创建数据集。

数据集创建(图片由作者提供)

1. 在 DataBrew 控制台上，选择数据集。
2. 选择您之前创建的数据集之一(fscw-orders-07–13–17–38–1626198069-ctas-temp)。
3. 选择运行数据配置文件。
4. 选择创建轮廓作业。
5. 在配置文件作业的配置中，选择要存储配置文件作业输出的亚马逊 S3 位置。
6. 在数据配置细节中，选择您想要生成的所有数据质量统计。
7. 在权限下，对于角色名称，选择您的 IAM 角色具有访问数据的 DataBrew 权限。
8. 选择创建并运行任务。

数据集页面有以下选项卡帮助您浏览数据:

• 数据集预览 —包含关于数据集源的信息
• 数据概要概述 —包含数据集级别的概要统计
• 列统计 —包含列级别的详细统计
• 数据沿袭 —包含带有数据流的可视化图表

让我们更详细地看一下每个选项卡。

数据集预览选项卡显示数据集的信息、位置和创建日期，以及数据集整体结构的概述。

数据集预览(图片由作者提供)

Data profile overview 选项卡包含数据集的统计和体积的图形数据配置文件。它包括总行数、缺失像元的百分比、重复行以及显示要素之间关系的关联矩阵。

数据集简介概述(图片由作者提供)

数据集概要概述-列摘要(作者提供的图片)

在列统计数据选项卡上，您可以找到关于数据集中每一列的详细统计数据，例如值分布、标准偏差、前几个不同的值以及其他数据洞察。

列统计(图片由作者提供)

所有质量结果的列表也可以作为 JSON 报告文件在您的 S3 存储区中获得。从 DataBrew profile job details 页面，我们还可以下载生成的报告，格式为 JSON、PNG 或 PDF 文件。

以编程方式监控功能

您可以使用 AWS APIs 自动执行上一节中描述的创建 DataBrew 概要分析数据和统计信息的所有步骤。在这一节中，我们将介绍可以在 Studio 中运行的 Jupyter 笔记本中实现的功能。

第一个函数*feature_monitoring_prep*准备 DataBrew 用来运行分析作业的数据集。该函数执行以下步骤:

• 使用 CTAS 根据查询结果将离线要素存储中的要素组表快照创建到 Athena 的新表中。快照表仅包含最新的要素组记录，不包含已删除的记录。
• 创建并运行一个 AWS Glue crawler 来抓取快照表。需要首先对该表进行爬网，以便在创建 DataBrew 数据集时该表可用作数据源。
• 通过将 DataBrew 数据集连接到前面步骤中创建的 AWS Glue 表来创建它。
• 配置 DataBrew 配置文件作业。

下面是一个示例代码片段，展示了我们如何使用一些输入参数(如要素组名称、S3 桶和存储结果的键)来调用此函数:

*response_brew_prep = feature_monitoring_utils.feature_monitoring_prep( orders_feature_group_name, results_bucket, results_key )*

现在，功能监控的准备步骤已经完成，我们可以调用下一个函数*feature_monitoring_run*，运行 DataBrew profile 作业，评估数据集并创建统计数据。您可以在不同的时间间隔连续运行该功能多次，以生成单独的相应报告。在这种情况下，它会自动重新创建用作 DataBrew 数据集输入的快照表。

*response_brew_job = feature_monitoring_utils.feature_monitoring_run( orders_feature_group_name )*

该函数仅将特性组名称作为输入参数，并返回由 DataBrew 配置文件作业生成的 JSON 报告的 S3 位置，以及包含报告可视化的 DataBrew 控制台的 URL。您可以选择笔记本中显示的链接，在新的浏览器选项卡中打开 DataBrew 控制台，以查看质量统计可视化。

作为该功能的一部分，DataBrew 控制台的 URL 和亚马逊 S3 中 DataBrew JSON 报告文件的位置都作为标签添加到功能组中。这允许您访问特征组以发现和检索质量统计报告的位置。同样，您可以随时将配置文件 URL 标记值直接复制并粘贴到您的 web 浏览器中，以在 DataBrew 控制台上显示报告。

要素组标签(图片由作者提供)

本笔记本根据 DataBrew 质量统计生成的报告，提供了一些功能和趋势的可视化示例。

附加功能consolidate_monitor_reports扫描包含 DataBrew 质量统计 JSON 报告文件的 S3 文件夹位置，并将这些文件合并成一个单独的 pandas DataFrame。该数据帧还被导出为平面 CSV 文件，以便由其他可视化或 BI 工具(如 Amazon QuickSight )进行进一步分析。将所有报告合并到一个地方的目的是帮助检测特征的质量统计的变化。

consolidate_monitor_reports函数将功能组名称、存储合并结果的 S3 存储桶和文件夹以及用于选择最新报告子集的开始日期作为输入。它返回整合的 DataFrame 对象和生成的 CSV 文件的 S3 位置。

*response_consolid = feature_monitoring_utils.consolidate_monitor_reports( orders_feature_group_name, results_bucket, consolidated_results_key, start_date )*

以下屏幕截图显示了整合数据框架的示例视图。这是对purchase_amount特性名称的提取，包含了从 DataBrew JSON 报告中收集的所有质量统计数据。我们可以观察到熵或标准差的值随着时间而变化。

特征统计数据框架(图片由作者提供)

可视化随时间推移的要素漂移

在笔记本中，我们还提供了一个示例可视化功能plot_profiling_data，以便轻松显示特定功能随时间的变化。该函数将全局数据帧、要监控的特征和特定的统计数据(如熵、平均值或标准偏差)作为输入。您还可以使用自己喜欢的 Python 库创建自己的可视化。

下面是一个简单的曲线图，显示了purchase_amount特性的entropy随时间的变化:

*feature_monitoring_utils.plot_profiling_data( analysis_data, feature_name = 'purchase_amount', ['entropy'] )*

特征的熵随时间漂移(图片由作者提供)

现在我们显示了purchase_amount特性的多个质量统计(entropy和standardDeviation)随时间的演变:

*feature_monitoring_utils.plot_profiling_data( analysis_data, feature_name = 'purchase_amount', ['entropy', 'standardDeviation'], multiple_plots = True )*

要素的多重统计随时间漂移，多重绘图(图片由作者提供)

如果我们想比较同一张图上具有两个不同比例的purchase_amount特征的两个统计值(entropy和standardDeviation)随时间的演变，我们在调用*plot_profiling_data*函数时使用*multiple_plots = False*。

要素的多重统计随时间漂移(图片由作者提供)

通过这种方法，您还可以创建一个管道或工作流解决方案，以完全自动化对现有功能库的功能监控。除了查看功能统计数据和创建显示您的功能如何随时间变化的仪表板之外，您还可以使用其他 AWS 服务来扩展解决方案，以配置警报和阈值，从而关注超出可接受范围的功能。这样，功能组的所有者可以采取措施，如调整功能转换以解决数据质量问题，甚至引入新功能。模型利益相关者可以得到关于大的特征漂移或违反约束的警告，并且可以重新训练他们的模型以获得更精确的预测。

要探索完整的代码示例，并在您自己的帐户中试用，请参见 GitHub repo 。

结论

Feature Store 提供专门构建的功能管理解决方案，帮助组织跨业务部门和数据科学团队扩展 ML 开发。在这篇文章中，我们解释了如何使用 DataBrew 在现有的特性存储上启用特性监控。将功能存储和数据构建结合使用时，可以查看功能统计数据，还可以创建仪表板来显示功能随时间的变化情况。通过提供对数据组成和质量的深入了解，在团队之间推动更多的功能重用，从而帮助建立信任，这将产生更高的模型准确性和更快的上市时间。试一试吧，在评论中告诉我们你的想法。

云本地架构中的监控和可观察性

原文：https://towardsdatascience.com/monitoring-and-observability-in-cloud-native-architectures-54e68e52b103?source=collection_archive---------34-----------------------

为什么监控对于云原生应用程序至关重要？有哪些工具可以完成这项工作？

图片由皮克斯拜的康斯坦丁·科洛索夫拍摄

想象一下被囚禁在一个没有窗户、没有日历和挂钟的牢房里。此外，你没有访客，你唯一的同伴是一个不喜欢闲聊的警卫。我知道这是一个非常黑暗的场景，但是请原谅我。

你有一个目标:找出季节(例如，夏天或秋天)以及外面是白天还是晚上。你怎么能这样做？你可以观察警卫的行为，他穿什么，吃什么食物，他晒黑了吗？如果他戴着太阳镜，那么也许现在是夏天，外面阳光明媚。如果他穿着外套，那么也许我们正处于隆冬。这就是我们所说的黑箱监控。

历史上，我们使用黑盒监控来推断问题的原因。我们有磁盘错误吗？我们是否观察到 CPU 使用率的峰值？但是试图通过监控系统的间接数据来提高应用程序的性能并不是理想的方法。我们可以做得更好！让我们打开一扇窗，要求我们应得的电话。

这个故事介绍了我们现在可以用来监控云原生应用程序性能的工具，以及如何将它们安装在 Kubernetes 集群中。在另一个故事中，我们将看到如何正确地使用它们来构建一个仪表板，它可以揭示我们的宠物项目内部正在发生的事情。

Learning Rate 是一份时事通讯，面向那些对 AI 和 MLOps 世界感到好奇的人。你会在每周五收到我关于最新人工智能新闻和文章的更新和想法。订阅这里！

监控与可观察性

在本文中，我们关心的是工程师方面的情况。因此，当错误发生时，开发人员需要正确的反馈，以便他们知道应该修复什么。他们可以通过正确的监控和观察工具来实现。但是有什么区别呢？

我们监控系统并观察应用

监视

在监控中，我们关注的是系统本身。例如，在云环境中，系统很可能是一个 Kubernetes 集群。然而，监控不会告诉我们应用程序内部发生了什么。它会给出诸如内存可用性低之类的指标，但它不会帮助我们查明问题的原因。

可观察性

在可观察性中，我们可以直接进入我们的应用程序，观察它的各种过程和功能。我们可以看到服务如何执行以及它们如何交互。然后，我们可以揭示几个问题或发现优化，使我们的应用程序性能更好。

根据经验，请记住:我们监控系统并观察应用。你还会听到人们使用术语可观测性来对这两个概念进行分组(即监控和可观测性)。

可观察性工具

专家们常用的堆栈可观测性包括普罗米修斯、格拉夫纳和耶格。

Prometheus 是领先的开源监控解决方案。它是由 SoundCloud 在 2012 年创建的，属于云本地计算基金会(CNCF)。Prometheus 收集系统信息，有一个时间序列数据库和自己的查询语言，称为 PromQL。此外，普罗米修斯有自己的内置警报工具。

优步在 2015 年创造了耶格，它也属于 CNCF。与 Prometheus 不同，Jaeger 收集应用程序信息，并提供分布式跟踪系统。

Grafana 是一个可视化平台，允许您构建直观的仪表板。它支持时序数据库，因此经常与 Prometheus 捆绑在一起。而且，你可以用插件来扩展 Grafana。

装置

要使用这些工具，我们需要将它们安装在 Kubernetes 集群中。因此，首先，要生成一个 Kubernetes 实例，我们可以使用 K3s 。要安装 K3s，请执行以下命令:

curl -sfL https://get.k3s.io | sh -
# Check for Ready node, takes maybe 30 seconds
k3s kubectl get node

接下来，我们将使用头盔安装普罗米修斯和格拉夫纳。所以，让我们安装头盔:

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

为了在我们的应用程序和可观察性堆栈之间创建一些分离，我们可以创建一个新的名称空间。姑且称之为监控:

kubectl create namespace monitoring

我们现在准备安装普罗米修斯。执行以下命令:

helm repo add prometheus-community [https:*//prometheus-community.github.io/helm-charts*](https://prometheus-community.github.io/helm-charts)helm repo add stable [https:*//charts.helm.sh/stable*](https://charts.helm.sh/stable)helm repo updatehelm install prometheus prometheus-community/kube-prometheus-stack --namespace monitoring --kubeconfig /etc/rancher/k3s/k3s.yaml

要验证您的安装，运行kubectl get pods -n monitoring。您应该会看到 6 个豆荚即将准备就绪。您现在可以运行端口转发命令来查看 Grafana 仪表板:

kubectl port-forward prometheus-grafana-5855d975d8-495bn --address 0.0.0.0 3000:3000 -n monitoring

导航到127.0.0.1:3000；用户名为admin，默认密码为prom-operator。

欢迎来到 Grafana——作者图片

最后，让我们在集群中安装 Jaeger。我们将使用官方 Jaeger GitHub 仓库中的文件。为了安装 Jaeger，我们将创建一个新的可观察性名称空间:

kubectl create namespace observability

然后，运行以下命令:

kubectl create -f [https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing.io_jaegers_crd.yaml](https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/crds/jaegertracing.io_jaegers_crd.yaml)kubectl create -n observability -f [https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml](https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/service_account.yaml)kubectl create -n observability -f [https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml](https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role.yaml)kubectl create -n observability -f [https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml](https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/role_binding.yaml)kubectl create -n observability -f [https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/operator.yaml](https://raw.githubusercontent.com/jaegertracing/jaeger-operator/master/deploy/operator.yaml)

就是这样！现在您已经有了一个安装了行业标准可观察性工具的 Kubernetes 集群。

序

在这个故事中，我们看到了什么是黑盒监控，以及它与白盒监控的对比。我们看到了什么是可观察性和监控，它们的区别，以及它们带来了什么。

最后，我们看到了如何创建一个 Kubernetes 集群并安装 Prometheus、Jaeger 和 Grafana，它们是用于监视和观察的行业标准工具。

在后面的故事中，我们将看到如何正确地使用它们来构建一个仪表板，它可以揭示我们的宠物项目内部正在发生的事情。

关于作者

我的名字是迪米特里斯·波罗普洛斯，我是一名为阿里克托工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲央行、经合组织和宜家等主要客户设计和实施过人工智能和软件解决方案。

如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据操作的帖子，请关注我的 Medium 、 LinkedIn 或 Twitter 上的 @james2pl 。

所表达的观点仅代表我个人，并不代表我的雇主的观点或意见。

监控和重新训练你的机器学习模型

原文：https://towardsdatascience.com/monitoring-and-retraining-your-machine-learning-models-f385b596b285?source=collection_archive---------16-----------------------

实践教程

有了谷歌数据工作室、lakeFS 和远大前程

由内森·杜姆劳在 Unsplash 上拍摄的照片

像生活中的一切一样，机器学习模型会变得陈旧。在一个不断变化、非稳定数据的世界中，每个人都需要偶尔回到学校并循环利用自己，你的模型也不例外。

嗯，我们知道重新训练我们的模型是重要的，但是我们应该什么时候做呢？如果我们做得太频繁，我们最终会浪费宝贵的时间和精力，但是很少做肯定会影响我们预测的质量。不幸的是，没有放之四海而皆准的答案。应该仔细评估每个案例，以确定陈旧性的影响。

在这篇文章中，我想分享我在一个个人项目中监控和再培训的方法:一个假新闻检测器 web 应用程序。我绝不是这方面的专家，所以如果你有任何建议或考虑，请随时联系。

应用程序

我们简单的 web 应用程序基本上是一个假新闻检测器:用户能够输入一篇新闻文章的 URL，系统将输出它的预测结果:它是假的还是真的。

作者 Gif

对于每个输入，系统将预测结果和附加元数据记录在位于 GCP 的 BigQuery 表中。这些数据将用于监控我们模型的性能，并在需要时对其进行重新训练。

本文分为两部分:监控和再培训。

首先，我将讲述我如何使用 BigQuery 的预测日志来建立一个 Google Data Studio 仪表板，以便有一些更新的图表和指标来评估我的文本分类模型的健康状况。

在再培训部分，我将展示我是如何处理数据版本化来管理每个再培训实验的数据和模型工件，同时保持数据质量。为此，我使用了lakeFS远大前程W&B等工具。本部分讨论的所有内容都可以在项目的资源库 中找到。****

监视

让我们先来看看model_predictions表的模式:

• ****标题(字符串):新的标题。
• ****内容(字符串):新的文本内容。
• ****模型(字符串):生成预测的模型的名称。
• ****预测(字符串):模型的预测—“真”或“假”。
• 置信度(FLOAT): 模型预测的置信度。从 0 到 1。
• ****url(字符串):新的 url。
• ****预测日期(日期时间):进行预测的日期和时间。
• ground_truth (STRING): 以 NULL 开始，在一个标注过程中可以更改为“真”或“假”。
• coverage (FLOAT): 新闻中出现在模型词汇中的单词的百分比。
• ****word_count(整数):新闻的字数。

这些字段都是在我们的应用程序为预测的在线请求提供服务时计算的。如果你有兴趣知道这些指标最初是如何计算的，你可以看看项目的资源库中的app.py。

从这些字段中，我们可以使用 Google Data Studio 设置一个在线仪表板，以持续监控我们预测模型的一些指标:

作者图片

Data Studio 有一个非常直观的界面。在这个例子中，我们只使用了一个数据源，即 BigQuery 中的model prediction表。因此，从一个空白的仪表板，我们可以通过简单地点击顶部的添加数据按钮，然后选择 BigQuery 选项来添加数据源。

我选择不显示与ground_truth相关的图表，因为如果近期没有重新训练模型的意图，这个字段可能经常为空。但是如果不断地做标记，一个混淆矩阵将会是我们仪表板的一个很好的补充。

在这个例子中，由于我没有大量的记录，我们不应该从这些数字中得出任何统计结论。希望在未来，随着更多的每日预测，这些图表将提供更多的信息。尽管如此，让我们逐一讨论这些指标:

记录

这仅仅是应用程序到目前为止提供的预测数量。要创建它，请转到在顶部添加图表并选择记分卡。选择您的表作为数据源，选择记录计数作为指标。

有标签的

这是已手动标记的记录的百分比。这对下一步的再培训很重要。没有地面真相，你不能重新训练你的模型。

像记录一样，这也是一个记分卡。但是对于这一个，您必须创建一个新的计算字段，方法是单击记分卡的数据选项卡底部的添加字段:

作者截图

然后，选择新创建的字段作为您的指标，就像前面的一样。

当前模型

上一个预测模型的名称。假设我们只有一个应用程序，并且一次只能有一个模型。

这个指标实际上是一个表图，而不是一个记分卡。作为维度，选择model和prediction_date，然后将每页行数设置为 1，然后将prediction_date按降序排序。然后你应该在样式标签中隐藏所有可能的东西。

预言

真实/虚假预测的百分比。

****要创建它，请转到添加图表→饼图。选择prediction作为尺寸，选择记录 _ 计数作为公制，就可以了。

预测指标

****该图显示了每周两个值的平均值:confidence和coverage 。由此，我们应该能够看到模型对其预测的信心水平发生了不寻常的变化，以及有多少新闻出现在经过训练的模型的词汇中。如果coverage有下降的趋势，并且低于预定的阈值，可能是时候重新训练它了。

这是一个时间序列。在尺寸字段，在小日历图标处，您应该可以设置周期。我选择了 ISO 年周。作为度量，选择confidence作为第一个度量， AVG 作为度量的聚合。然后，进入添加公制并在样式选项卡对coverage.进行同样的操作，您可以将两个系列从线条更改为条并设置它们的颜色。

字数统计频率

该图表根据每个预测类别，按字数对记录进行分组。即使我们需要更多的数据来真正掌握字数分布，但似乎假新闻通常比真新闻短。

另一个奇怪的细节是，有 5 个字数在 0-100 之间的假预测。对于一条新闻来说，这似乎有点低，这促使我进一步调查。我最终发现，这些记录是从同一个网站提取的，它们都有一个解析错误。内容不是真正的新闻，而是一条错误消息。这很重要，我们应该确保这些类型的记录永远不会被吸收到我们的训练测试数据集中。

这是我在数据工作室制作直方图的最接近的一次。要创建一个，请转到图表→条形图，并在数据选项卡的底部添加一个新字段。在公式字段中，输入:

FLOOR(word_count/100)*100

对于每条记录，字数会除以 100，然后将结果的最大整数值乘以 100。这将把记录放入数百个容器中。我将该字段命名为wc_bin。您可以使用它作为尺寸，和记录计数作为度量。您还应该将排序设置为上升，并选择wc_bin。

****要将直方图分成假的和真的，你可以去添加一个过滤器，排序正下方的，并插入一个过滤器，如下所示:

作者截图

对下一个类别做相反的事情。

再训练

好了，现在我们有了一个检查模型健康状况的方法。如果有什么异常，我们可以开始标记一些记录，并查看一些重要的分类指标，如精度、召回率和 F 值。如果你对结果不满意，我们应该开始重新训练模型。****

概观

下图是我为这个项目设置的再培训流程的概述:

作者图片

我们有我们的基础数据**，我们用来训练我们的第一个预测模型的原始数据集。此外，该应用程序还不断向我们提供在线预测的数据。因此，为了重新训练模型，我们可以提取这些数据并做一些简单的预处理，如删除重复的新闻。验证我们的数据并确保它符合我们对数据形状和分布的一些假设也是非常重要的。然后，我们继续连接两个数据源，最终重新训练模型。在替换旧模型之前，我们必须用测试集来评估新训练的模型，以确保其质量。**

每次我们希望重新训练模型时，我们都遵循这些步骤。但是如果我们在将来发现有问题，我们如何调试我们的模型呢？要做到这一点，除了模型的性能结果和生成它的代码之外，我们还需要一种有序的方式来存储我们的模型和数据工件。

使用 LakeFS 进行数据版本控制

管理 ML 应用程序中的数据管道不是一件容易的事情。不像传统的软件开发，GIT 已经成为代码版本化的标准，数据版本化仍然处于早期阶段，没有一个“确定的”方法。

我决定将每个再训练过程视为一个单独的实验，并将每个实验的工件存储在一个单独的分支中。这与我们习惯的代码版本化有点不同，因为在这种情况下，我不期望将分支合并回主干。它们是短命的分支，目的是根据不同的再训练实验对我们的工件——数据集和模型——进行版本控制。

尽管有许多提供数据版本控制功能的 MLOps 工具，例如 MLflow 和 W & B ，但是我选择将数据版本控制作为基础设施，通过在我的对象存储上启用类似 Git 的操作。为此，我决定试用最近发布的 lakeFS ，它使我能够在我现有的 S3 对象存储之上添加类似 Git 的引擎。这样，我的项目数据版本控制能力独立于我将来可能添加或替换的任何工具。

预备步骤—部署 lakeFS

您可以在这里找到设置 lakeFS 环境的说明。

我基本上不得不:

1. 在 AWS RDS 上创建 PostgreSQL 数据库
2. 为我的存储库配置一个 S3 存储桶

• 对于策略的主体，我创建了一个用户并为其创建了访问密钥。我还将使用这个用户向 AWS 认证 lakeFS。你可以在这里阅读更多关于的内容，在这里阅读更多关于的内容。

3.安装 lakeFS

• 我选择通过 Docker 安装它，命令如下:

docker run --name lakefs -p 8000:8000
-e LAKEFS_DATABASE_CONNECTION_STRING="<postgres-connection-str>"
-e LAKEFS_AUTH_ENCRYPT_SECRET_KEY="<lakefs-secret-key>"
-e LAKEFS_BLOCKSTORE_TYPE="s3"
-e LAKEFS_GATEWAYS_S3_DOMAIN_NAME="s3.local.lakefs.io"
-e LAKEFS_BLOCKSTORE_S3_CREDENTIALS_ACCESS_SECRET_KEY="<s3-secret-key>"
-e LAKEFS_BLOCKSTORE_S3_CREDENTIALS_ACCESS_KEY_ID="<s3-access-key>" -e LAKEFS_BLOCKSTORE_S3_REGION="<s3-region>" treeverse/lakefs:latest run

其中postgres-connection-str是您在创建 PostgreSQL DB 时获得的连接字符串，lakefs-secret-key是任意随机生成的字符串(别忘了)，s3-secret-key和s3-access-key是您之前为 AWS 用户创建的密钥对，s3-region是您创建的 bucket 的区域。

4.设置

在 localhost:8000 中，在设置了新的管理员用户并创建了存储库之后，您应该能够看到您的存储库列表:

作者截图

再培训过程

现在我们已经设置好了一切，我们需要将流程图转化为一系列步骤并实现它。我们基本上需要:

• 从在线预测中获取数据( BigQuery )
• 清理并断言数据质量(巨大的期望)
• 从 master ( lakeFS )创建新的分支
• 将在线预测上传到新分支( lakeFS )
• 从主支行( lakeFS )获取基础数据
• 将在线预测连接到基础数据，并拆分为训练测试数据集
• 将列车测试拆分上传至分支( lakeFS )
• 用更新的数据集训练模型
• 记录实验/结果( W & B
• 上传模型和词汇到分支( lakeFS )
• 将更改提交到分支( lakeFS )

数据结构

至于我们的数据结构，我们将把我们的原始数据集以及从 web 应用的在线预测中提取的数据定义为external数据。一旦外部来源被组合并分成适当的训练测试集，文件夹interim将保存我们的数据。模型文件也将存储在它们自己的文件夹中。

作者图片

从生产中获取数据

首先，我们需要从 BigQuery 表中获取新数据。为了使用 Python APIs 访问 BigQuery，我需要 JSON 格式的 GCP 凭证。创建项目后，您可以按照本 Google 文档中“创建服务帐户”的说明下载您的凭证。

然后，安装google-cloud-bigquery,设置一个指示凭证位置的环境变量，并启动 BigQuery 客户机，这样就可以查询表了。在这种情况下，sunny-emissary-293912是我的项目的名称，fakenewsdeploy是我的数据集的名称，model_predictions是我的表的名称。

清洁和维护质量

我们应该始终确保存储数据的质量。一个很好的方法就是使用工具https://greatexpectations.io/。在我做了一些非常简单的清理之后，比如删除重复的新闻和字数少的新闻，我们可以对我们的数据做一些基本的假设。****

在这个例子中，如果我们的数据通过了一些验证，我们将继续我们的再训练。ground_truth应该只假设Fake或Real值，url值应该是唯一的，并且每个样本应该有一个非空的content.。此外，我们假设必须调查过低的coverage，因为它可能是解析错误的迹象，或者可能是另一种语言的内容。最后，word_count应该高于 100，正如我们在本文的监控部分所讨论的。

然后我们可以生成一个expectation_suite，它给我们一个 JSON 文件，显示我们的数据通过的验证。我们还应该确保存储这些信息以供将来参考(这将在序列中完成)。

我们只是带着巨大的期望触及了表面。查看他们的网站以了解更多功能。

创建新分支

既然我们信任我们的数据，我们可以将它存储在一个新创建的分支中。在这个项目的 建模/评估的前期，我用 W & B 来跟踪我的实验。我会在再训练过程中继续使用它，和 lakeFS 一起使用。这样，实验标识符就是 wandb 的运行名，为了创建分支，我将使用相同的名称:

****这里要指出两件事。在第 3 行，在开始运行时，您会看到我配置了一个阈值。这是一个很好的 W&B 功能，我可以设置一个阈值，在培训期间进行监控。在这种情况下，如果被训练模型的 **F1-Score** 低于 **0.9** ，W & B 会发邮件通知我。我们将在训练代码中看到它的其余部分。****

这里的另一个重要问题是我如何在我的 lakeFS 存储库中进行操作。这可以用几种不同的方式来完成，但是我选择使用 Python 客户端。我创建了一个lakefs_connector类来将 API 包装成更适合我的应用程序的函数。该类的实现显示在本文的末尾。

将在线预测上传至分行

让我们继续上传online_predictions.csv到我们的分支。我们还将把my_expectation_file.json保存到 wandb 运行中。

现在，我们可以在任何需要的时候访问我们的期望文件，并确保在这个特定的运行中数据的状态符合我们的假设:

作者截图

合并数据和拆分

我们的基础数据由两个文件组成:True.csv和Fake.csv，这两个文件都已经上传到我们的主分支机构。让我们将来自online_predictions.csv的数据添加到我们的基础数据中，然后将它分成训练测试数据集:

训练模型并上传工件

最后一系列步骤是最终训练模型，并将我们的工件上传到存储库的分支:

我们将上传训练测试分割以及我们的模型文件——实际的joblib模型和用于我们的矢量器的词汇(它也用于计算我们的coverage字段)。

f1_score是训练过程中计算出的 F1 分数。由于我们之前设置了阈值 0.9，如果本次运行的分数低于该值，将向配置的目标发送警报。对我来说，是我的电子邮件:

作者截图

提交更改

现在，剩下要做的就是将我们的更改提交到我们的分支中:

我们会根据再训练实验将数据分开，就像这样:

作者截图

由于运行名称是唯一的，我们可以很容易地将数据与我们在 W&B 的实验仪表板上的再培训结果进行匹配:

作者截图

lakeFS 连接器

在上面的代码片段中，我们对我们的存储库进行了一些操作，比如创建分支、下载和上传对象，以及提交更改。为此，我使用 bravado 来生成一个动态客户端，如这里的所示。这样，我们可以通过 Python 命令访问所有 lakeFS 的 API。

通过实例化lakefs_conn类，我们创建了一个 lakeFS 客户机，并通过对象的方法执行所需的存储库操作:

下一步是什么

我想与你分享我对监测我的模型的性能和再培训，但这真的是一个漫长过程的第一步。随着时间的推移，额外的数据使我们能够有更多的见解，我们最终会发现更好的方法来监控我们的应用程序。

例如，在未来，我们可以绘制多个重新训练模型的性能，并随着时间的推移对它们进行比较，以更准确地评估时间对我们预测的影响。或者，给定足够的基本事实信息，我们可以在仪表板中添加精度和召回率等指标。

至于再培训部分，还有很多可以改善的地方。随着我们对数据分布的了解越来越多，我们可以在断言阶段增加额外的期望。为自动提交前验证增加挂钩也是一个自然的发展。在撰写本文时，lakeFS 还不支持 Webhooks，但在最新版本(0.33)中已经有了。

暂时就这样吧！如果您有任何反馈或问题，请随时联系我们！

感谢您的阅读！

参考

• 机器学习的连续交付
• 数据版本
• 确保数据湖环境中的数据质量
• ML 测试分数:衡量 ML 生产准备情况和技术债务削减的指标
• 为什么数据版本控制作为基础设施很重要
• lakeFS —文档
• 远大前程—文档
• 权重和偏差—文档

使用远大前程和 Allure 构建的无服务器监控数据湖中的数据质量

原文：https://towardsdatascience.com/monitoring-data-quality-in-a-data-lake-using-great-expectations-and-allure-built-serverless-47fa1791af6a?source=collection_archive---------10-----------------------

图片来自 freepik

人工智能、机器学习和大数据产业正在快速增长。它们不再仅仅是炒作，所有这三个行业都已经成熟到能够帮助各种组织推动增长并交付切实成果的程度。在这种情况下，相关解决方案的质量，尤其是支持这些解决方案的数据质量变得至关重要。

在 Provectus ，我们明白人工智能的数据质量至关重要。为此，我们使用各种服务进行数据质量监控，这些服务可以帮助我们识别和跟踪数据趋势、检测数据变化等等。所有这些服务都有助于识别风险和防止支出。软件测试背后的理论暗示着你越早发现错误并修复它，花费的钱就越少。在 AI 和 ML 的例子中，研究清楚地表明好的数据比模型中的系数更有用。

作者图片

今天的 AI 现实是，单纯做数据管道已经不够了。处理您的 ML 模型和数据更类似于一个标准的 IT 例程，包括它的所有过程。那么，如何有效地大规模评估数据质量呢？

我们已经有了一些使用两个开源数据质量保证框架的经验:Deequ 和 Great Expectations，但是大部分是在本地，而不是在云中。本文提供了一些关于使用 Great Expectations 来监控 AWS 云中的数据质量的观点。

为什么是远大前程？

Great Expectations (GE)是一个基于 Python 的开源数据质量框架。GE 使工程师能够编写测试、审查报告和评估数据质量。这是一个可插拔的工具，意味着你可以很容易地添加新的期望和定制最终报告。GE 可以很容易地与诸如 Airflow 之类的 ETL 集成，并且它有 AWS 支持。后者对于 AWS 首要咨询合作伙伴 Provectus 非常重要，因为我们现在正在努力将 Pandas profiling 添加到我们的数据质量监控工具组合中。Pandas 是分析数据和为 GE 自动生成简单测试套件的完美工具。

为什么是《倾城》？

Allure 框架是用于测试和报告的经典 IT 工具。对于经理和非技术专业人员来说，这是一个很好的选择，因为与严格的技术通用电气相比，它允许他们以更舒适的方式处理数据。在这个实现中，我们通过从 GE 到 Allure 的自写适配器来使用 Allure 和 GE 报告。

解决方案架构

一开始，我们基于以下架构参考构建了一个 POC。

作者图片

在实施中，我们用在我们以前的一个项目(NDA 下的客户)。我们依赖于基于气流的解决方案，也依赖于我们与 GE 共同制定的数据质量保证战略。然而，在这种情况下，我们需要收集大量的数据来构建它，并提供一个用户友好的仪表板，使 C 级员工能够处理数据。从这个角度来看，数据的质量再次显得至关重要。

我们的第一步是选择正确的数据集，并联系数据所有者，以了解我们到底需要在其中签入什么。然后，我们编写了几个本地测试套件:一个是技术套件，提供关于列中 null 值和空值的技术细节，另一个是研究业务和操作问题。之后，GE config 被改为 AWS(亚马逊 S3)集成，数据上传到它的存储器。为了实现卓越运营，我们对 Lambda 使用了 docker 图像和 ECR。我们对其进行了测试，并开始研究将其集成到现有数据管道的最佳方式。我们决定在 AWS Lambda 中使用 Step 函数作为 ETL。

这是最终的解决方案。

作者图片

解决方案概述

1. 使用 AWS Lambda 和 AWS Glue 从数据源检索数据
2. 同时，对每个数据集运行 AWS Lambda 和 Pandas Profiling 以及 GE 测试套件，并将每个数据集作为静态 S3 网站进行存储/服务
3. 在 AWS Lambda 中，将 GE 结果转换为 Allure 结果，并存储在亚马逊 S3 中
4. 在 AWS Lambda 中，根据 Allure 结果生成 Allure 报告，在亚马逊 S3 中存储和提供
5. 通过使用 AWS，Lambda 向 Slack 通道发送报告
6. 结果被推送到亚马逊 DynamoDB(你也可以使用亚马逊 S3 来降低成本)
7. 使用 Amazon Athena 从 Amazon DynamoDB 抓取数据
8. 使用 Amazon Quicksight 提取数据

步进功能:

作者图片

请记住，我们不希望(或需要)停止通常的数据工程步骤的实现，但是我们可以通过使用无服务器将所有堆栈部署到 Cloudformation。

数据质量保证堆栈的实现

**** —敏感信息*

要在 AWS 上实施 GE，您需要:

1. 更改 ge 配置(great_expectation.yml)数据源、源和 data_docs

datasources:
  pandas_s3:
    class_name: PandasDatasource
    batch_kwargs_generators:
      pandas_s3_generator:
        class_name: S3GlobReaderBatchKwargsGenerator
        bucket: ***
        assets:
          your_first_data_asset_name:
            prefix: ***/ regex_filter: .* module_name: great_expectations.datasource
    data_asset_type:
      class_name: PandasDataset
      module_name: great_expectations.datasetexpectations_S3_store:
    class_name: ExpectationsStore
    store_backend:
      class_name: TupleS3StoreBackend
      bucket: '***'
      prefix: '***/great_expectations/expectations/'

  validations_S3_store:
    class_name: ValidationsStore
    store_backend:
      class_name: TupleS3StoreBackend
      bucket: '***'
      prefix: '***/great_expectations/uncommitted/validations/'

  evaluation_parameter_store:class_name: EvaluationParameterStore

expectations_store_name: expectations_S3_store
validations_store_name: validations_S3_store
evaluation_parameter_store_name: evaluation_parameter_storedata_docs_sites:s3_site:
    class_name: SiteBuilder
    show_how_to_buttons: false
    store_backend:
      class_name: TupleS3StoreBackend
      bucket: ***
    site_index_builder:
      class_name: DefaultSiteIndexBuilder
      renderer:
        module_name: custom_data_docs.renderers.custom_table_renderer
        class_name: CustomTableRenderer
      show_cta_footer: true

2.创建测试套件并编写测试；记得更改必要文件的路径

# ### Column Expectation(s)

# #### `id`

# In[ ]:

batch.expect_column_values_to_match_regex(column='id',
                                          regex="^\d+$")

# #### `lastNameFirstName`

# In[ ]:
batch.expect_column_values_to_match_regex(column='lastNameFirstName',
                                          regex="([a-zA-Z .-]){2,30}[,]+[ ]+([a-zA-Z .-]){2,30}$")

# #### `customTeam`

# In[ ]:

# In[ ]:

batch.expect_column_values_to_match_regex(column='customTeam',
                                          regex="^[a-zA-Z -]+$")

3.如果你想使用 AWS Lambda，把你的代码包装成 lambda_handler 或者

def handler(event, link):
    context = DataContext(os.path.join(BASE_DIR, 'great_expectations'))

    expectation_suite_name = "***"
    suite = context.get_expectation_suite(expectation_suite_name)
    suite.expectations = []

    batch_kwargs = {'data_asset_name': '***', 'datasource': 'pandas_s3', 'path': 's3a://***/'+event[0],'link':link}
    batch = context.get_batch(batch_kwargs, suite)
    batch.head()

4.创建 requirements.txt 和 dockerfile

importlib-metadata==2.0
great-expectations==0.13.19
s3fs==2021.6.0
python-dateutil==2.8.1
botocore==1.20.49
boto3==1.17.1
aiobotocore==1.3.0
requests==2.25.1
decorator==4.4.2
pyarrow==2
fastparquet
awslambdaric
awswrangler
pandas_profilingFROM python:3.6-stretch
RUN apt-get update \
 && apt-get upgrade -y \
 && apt-get install -y
RUN apt-get install -y python3-dev
RUN apt-get install -y python3-pip
RUN pip3 install --upgrade cython
RUN pip3 install setuptools_scm
ADD ./requirements.txt ./
COPY  edit_bamboo_hr_technic.py ./
COPY edit_bamboo_hr.py ./
COPY test_pandas_profiler.py ./
COPY bamboohr_report_data_test.py ./
COPY great_expectations /great_expectations
RUN pip3 install  -r requirements.txt
ENTRYPOINT ["/usr/local/bin/python", "-m", "awslambdaric"]
CMD ["bamboohr_report_data_test.handler"]

1. 在亚马逊 S3，使用静态网站选项。如果你想增加更多的安全性，实现 Amazon CloudFront
2. 使用无服务器工具部署到 Cloudformation。首先，您需要“docker-compose build”，然后是“sls deploy”。如果您希望 GE 有一个单一的 Lambda，您需要创建一个 ECR 存储库，并按照指令推送您的 docker 映像。之后，创建一个 AWS Lambda 映像并选择它。

通用电气报告门户:

作者图片

通用电气报告:

作者图片

对于 Pandas Profiling，您可以使用以下代码:

def profile_data(event, runs):
    file_path = event[0]
    s3 = boto3.resource("s3")
    bucket = s3.Bucket('***')
    df = wr.s3.read_parquet(path='s3://***/')
    profile = ProfileReport(df, title="Pandas Profiling Report",    minimal=True)
    report = profile.to_html()
    bucket.put_object(Key='***', ContentType='text/html')

我们在同一个 Lambda 上部署 GE 和 Pandas Profiling，以削减成本和简化流程。

熊猫概况报告:

作者图片

诱惑力:

1. Pre:您需要将 GE json 结果映射到 Allure json 结果
2. 创建 docker 文件和需求文本
3. 创建 sh 脚本并使用 Python 脚本与 Allure 交互，因为 Allure 需要 Java

FOLDER=$1
rm -r /tmp/result
rm -r /tmp/allure-report
aws s3 sync s3://***/allure/"$FOLDER"/result /tmp/result
allure-2.14.0/bin/allure generate /tmp/result --clean -o tmp/allure-report
aws s3 sync /tmp/allure-report s3://***/allure/"$FOLDER"/allure-report

4.部署它

《诱惑》报道:

作者图片

作者图片

我们还在 Gitlab 问题之间进行了整合，以便在测试运行后更容易创建问题。

作者图片

亚马逊雅典娜和亚马逊 DynamoDB:

要存储数据，请使用数据透视表，要抓取数据，请使用 Amazon Athena。

为了将数据推送到存储，我们可以使用 Amazon DynamoDD(或 Amazon SS)。

1. 访问亚马逊 DynamoDB
2. 创建表格
3. 去和 Amazon DynamoDB 在同一地区的 Amazon Athena
4. 连接一个新的数据源(即选择一个已创建的 DynamoDB 表)
5. 在查询编辑器中测试连接

作者图片

快速观察:

1. 去亚马逊 Quicksight
2. 选择数据集，转到新数据集
3. 选择亚马逊雅典娜
4. 选择您的工作组和数据源名称

作者图片

5.创建数据源

6.进行新的分析

在现有的实现中，我们使用两种类型的图表

1. bug 趋势线——每个日期每个选定源的失败测试百分比，您可以通过过滤器来选择

作者图片

2.套件和源状态栏

作者图片

3.这也是一个数据透视表，您可以单击 raw 打开报告菜单并查看每个数据 qa 结果

作者图片

Slack bot 发送一个通知，其中包含每个管道的链接

作者图片

结论

本文演示了如何使用 StepFunctions、Lambda、GE、Allure 和 Pandas Profiling 在 AWS 上的数据管道中构建和实现一种数据质量方法。它解释了这些工具和服务的内容和方式，并提供了一种使用它们来确保数据质量、简化管道调试和降低成本的可靠方法，而不会增加数据管道的架构复杂性。

要了解更多关于 Provectus 数据质量保证实践的信息，请访问 网页 :

满怀期望的数据质量保证和 Kubeflow 管道
我们的 pip 包用于将 ge 结果映射到 Allure 结果

使用弹性 APM 监控 Python 应用程序

原文：https://towardsdatascience.com/monitoring-flask-fastapi-python-applications-with-elastic-apm-33237a39d7b6?source=collection_archive---------11-----------------------

编程；编排

Flask、FastAPI 和 Python 应用程序监控指南

卢克·切瑟在 Unsplash 上拍摄的照片

什么是弹性 APM？

弹性 APM 是建立在弹性堆栈上的应用性能监控系统。通过收集有关传入请求、数据库查询、缓存调用、外部 HTTP 请求等响应时间的详细性能信息，它允许您实时监控软件服务和应用程序。这使得快速查明和修复性能问题变得很容易。

Elastic APM 还自动收集未处理的错误和异常。错误主要基于堆栈跟踪进行分组，因此您可以在新错误出现时识别它们，并留意特定错误发生的次数。

-弹性

本文由三部分组成:

1. 监控烧瓶/烧瓶-RESTPlus 应用
2. 监控 FastAPI 应用程序
3. 监控 Python 应用程序

监控烧瓶/烧瓶-RESTPlus 应用

装置

弹性 APM 内置烧瓶支架。因为 Flask-RESTPlus 和 Flask-RESTful 是 Flask 的扩展，所以相同的步骤适用于 Flask-RESTPlus 和 Flask-RESTful。

使用 pip 安装弹性 APM 代理:

pip install elastic-apm[flask]

履行

让我们首先导入所需的包:

from flask import Flask

from elasticapm.contrib.flask import ElasticAPM
import elasticapm

现在，让我们创建一个 Flask 实例，这将是我们的 WSGI 应用程序。

app = Flask(__name__)

我们可以通过使用环境变量或应用程序代码本身来初始化 APM 代理。在本文中，我们将在代码中初始化 APM 代理。

要创建一个弹性 APM 代理的实例，我们需要以下参数:

server_url →弹性 APM 的 URL

service_name →应用名称

environment →应用运行的环境，例如开发、质量保证或生产

server_url = 'http://localhost:8200'
service_name = 'DemoFlask'
environment = 'dev'

接下来，我们将初始化 APM 代理。
我们需要传递 Flask 实例app作为初始化 APM 代理的第一个参数，以及我们上面定义的参数。

apm = ElasticAPM(app, server_url=server_url, 
      service_name=service_name, environment=environment)

我们的 APM 代理现在准备好了。

现在，让我们打开 Kibana(例如 http://localhost:5601/)来查看记录的数据。

打开 Kibana 仪表板并转到 APM 选项卡。你可以看到我们的服务DemoFlask列在那里。

单击服务名并转到 Metrics，在这里可以跟踪 CPU 和内存的使用情况。

在 transactions 选项卡中，您可以看到与您的应用程序收到的每个请求相关的可视化内容，例如事务持续时间和每分钟的请求数。

您还可以查看所有端点的列表及其平均持续时间。

单击交易以查看交易的更多详细信息。

您还可以通过使用标签来添加关于交易的附加信息。

elasticapm.label(platform='DemoPlatform')

为了给所有事务添加默认标签，我们可以使用 Flask 的app.before_request decorator。

@app.before_request
def apm_log():
    elasticapm.label(platform = 'DemoPlatform',                     
                     application = 'DemoApplication')

标签的信息将在事务的跟踪样本的元数据选项卡中可见。

注意，默认情况下，只有当应用程序在调试模式下是 而不是 时，才会记录事务和错误数据。

示例代码可以在 参考资料 部分提到的链接中找到。

监控 FastAPI 应用程序

要使用 Elastic APM 正确地监控 FastAPI/Starlette 应用程序，您需要使用 Python 3.7+

装置

使用 pip 安装弹性 APM 代理:

pip install elastic-apm

履行

首先，让我们导入所需的包:

import uvicorn
from fastapi import FastAPI
from elasticapm.contrib.starlette import make_apm_client, ElasticAPM

接下来，我们将使用SERVICE_NAME、SERVER_URL和ENVIRONMENT创建一个 APM 客户端。此外，我们将使用GLOBAL_LABELS同时指定全局标签。

apm_config = {
 'SERVICE_NAME': 'DemoFastAPI',
 'SERVER_URL': 'http://localhost:8200',
 'ENVIRONMENT': 'dev',
 'GLOBAL_LABELS': 'platform=DemoPlatform, application=DemoApplication'
}
apm = make_apm_client(apm_config)

现在，让我们初始化弹性 APM 代理。

app = FastAPI()
app.add_middleware(ElasticAPM, client=apm)

FastAPI 应用程序现在准备好将日志发送到弹性服务器。

示例代码可以在 参考资料 部分提到的链接中找到。

监控 Python 应用程序

我们可以创建一个弹性 APM 客户端来监控不使用框架的 Python 应用程序(例如 Flask、Django 或 FastAPI)。这些应用的一个例子可以是可调度代码。

装置

使用 pip 安装弹性 APM 代理:

pip install elastic-apm

履行

首先，我们将创建一个弹性 APM 客户端

from elasticapm import Client
import elasticapm
client = Client(
    {'SERVICE_NAME': 'DemoPython',
     'SERVER_URL': 'http://localhost:8200',
     'ENVIRONMENT': 'dev'}
)

对于 Flask 和 FastAPI 这样的框架，Elastic APM 会自动检测应用程序，并开始和结束事务。

然而，对于不使用这种框架的 Python 应用程序，我们需要手动检测应用程序，并开始和结束事务。

自动检测您的应用程序以捕获 HTTP 请求、数据库查询等。，添加下面一行

elasticapm.instrumentation.control.instrument()

要开始一个事务，使用begin_transaction方法，将适当的事务类型作为参数。

举个例子，

client.begin_transaction('schedule')

要完成一个事务，使用 end_transaction 方法，该方法有两个参数，即。交易名称和结果。

举个例子，

client.end_transaction('demo-transaction', 'success')

可以在 资源 部分提到的链接中找到用于监控 Python 应用程序的示例代码。

资源

这篇文章的所有代码片段都可以在我的 GitHub 页面上找到。

参考

• https://www . elastic . co/guide/en/APM/agent/python/current/configuration . html
• https://www . elastic . co/guide/en/APM/agent/python/current/flask-support . html
• https://www . elastic . co/guide/en/APM/get-started/7.4/metadata . html
• https://www . elastic . co/guide/en/APM/agent/python/current/starlette-support . html

让我们连接

领英:https://www.linkedin.com/in/jimit105/GitHub:https://github.com/jimit105推特:https://twitter.com/jimit105

监控生产中的机器学习模型

原文：https://towardsdatascience.com/monitoring-machine-learning-models-in-production-how-to-track-data-quality-and-integrity-391435c8a299?source=collection_archive---------8-----------------------

如何跟踪数据质量和完整性

图片作者。

俗话说:垃圾进来就是垃圾出去。输入数据质量是机器学习系统最重要的组成部分。无论您是否有即时反馈回路，您的模型监控总是从这里开始。

数据会出什么问题？

人们会遇到两种类型的数据问题。简单来说:
1)数据本身出了问题；或者
2)数据因为环境而改变。

让我们从第一类开始。光是它就有很多。

头号数据处理问题

机器学习应用程序通常依赖上游系统来提供输入。最常见的情况是生产模型没有收到数据。或者，它接收损坏的或有限的数据，这都是由于一些管道问题。

我们举个营销的例子。

一家银行的数据科学团队开发了一个强大的机器学习系统，以个性化每月发送给客户的促销信息。

该系统使用来自内部客户数据库的数据、来自网上银行和移动应用程序的点击流日志以及呼叫中心日志。此外，营销团队手动维护一个电子表格，在其中添加本月的促销选项。

所有数据流被合并并存储在数据仓库中。当模型运行时，它会计算关节表顶部的必要特征。然后，该模型根据接受的可能性对每个客户的报价进行排名，并输出结果。

*促销个性化用例的简化管道丛林。(*图片由作者提供)。

此管道使用多个数据源。并且，不同的功能所有者维护它们中的每一个。相当多的机会来搞乱它！

以下是将要发生的令人不快的事情的不完整列表:

• **错误的来源。**管道指向旧版本的市场营销表，或者存在未解决的版本冲突。
• **失去通路。**有人将表格移动到新位置，但没有更新权限。
• **错误的 SQL。**或者不是 SQL。无论你用什么来查询你的数据。这些连接和选择在第一次出现复杂情况之前可能工作得很好。比如说，一个来自不同时区的用户在“明天”做了一个动作？该查询可能不成立。
• 基础设施更新。你得到了一个新版本的数据库和一些自动化的大扫除。空格替换为下划线，所有列名小写。一切看起来都很好，直到您的模型想要将其常规特征计算为“上月收入/总收入”。带有硬编码的列标题。哎哟！
• **断特征码。**我敢说，数据科学的代码往往不是生产级的。在极端情况下，它可能会失败。例如，培训中的促销折扣从未超过 50%。然后，营销部门推出一个“免费”报价，并第一次键入 100%。一些依赖的特性代码突然变得没有意义，并返回负数。

当数据处理出错时，模型代码就会崩溃。至少，你会很快了解这个问题。但是如果您的 Python 代码有一些*“Try…Except”*子句，它可能会在不正确和不完整的输入上执行。后果都是你的。

我们看的宣传片例子有批量推断。没那么戏剧化。你有犯错的空间。如果您及时发现了管道问题，您可以简单地重复模型运行。

在高负载流模型中，数据处理问题成倍增加(想想电子商务、游戏或银行交易)。

#2 数据模式变化

在其他情况下，数据处理工作得很好。但是数据源会发生有效的变化。不管是什么原因，新的数据格式、类型和模式对模型来说很少是好消息。

除此之外，变更的作者通常没有意识到影响。或者，那里甚至存在某种模型。

让我们回到宣传片的例子。

一天，呼叫中心的运营团队决定整理 CRM，丰富他们在每次客户来电后收集的信息。

他们可能会引入更好、更细化的类别，根据问题类型对来电进行分类。他们还会询问每个客户他们首选的通信渠道，并开始在一个新的字段中记录。既然我们在这里:让我们重命名和改变字段的顺序，使它对新用户更直观。

现在，看起来很整洁！

图片作者。

但对模型来说并非如此。

用专业术语来说，这一切都意味着失去信号。

除非明确告知，否则模型不会将新类别与旧类别相匹配，也不会处理额外的功能。如果没有数据完整性检查，它将基于它知道如何处理的部分输入生成响应。

任何与目录打交道的人都知道这种痛苦。

比如在需求预测或者电商推荐方面。通常，你会有一些基于类别类型的复杂特性。比如，“笔记本电脑”或“手机”在“电子产品”中那是昂贵的。让我们把它做成一个特色。“手机壳”在“配件”里这有点“便宜”我们也会用到它。

然后，有人重新整理了目录。现在，“手机”和“手机壳”都在“手机”下面。一个完全不同的类别，有不同的解释。该模型将需要重新学习，或者等到有人解释发生了什么。

这里没有魔法。如果目录更新经常发生，你最好把它考虑到模型设计中。否则，培训业务用户并跟踪突然的变化。

是的，现实世界的机器学习可能就是这么脆弱。(图片来源: Pixabay )

更多例子:

• 原始业务系统中的更新导致测量单位(将摄氏温度改为华氏温度)或日期格式(日/月/YY 或月/日/YY？)
• 应用程序中的新产品功能增加了模型从未训练过的遥测技术。
• 有新的第三方数据提供者或 API，或宣布的格式变化。

**具有讽刺意味的是，领域专家可以将这种变化视为运营改进。**例如，一种新的传感器可以让您以毫秒级的速度捕捉高粒度数据。好多了！但是该模型是针对聚合进行训练的，并期望以通常的方式计算它们。

**缺乏清晰的数据所有权和文档使其更加困难。**可能没有简单的方法来跟踪或知道向谁通知组织内部即将到来的数据更新。数据质量监控成为捕捉变化的唯一方式。

#3 源位置的数据丢失

数据不仅会改变。它也可能由于源头上的一些故障而丢失。

有时你的管道可能会无处可去。(图片鸣谢:Unsplash)。

**例如，由于日志记录中的错误，您丢失了应用点击流数据。**物理传感器坏了，温度不再可知。外部 API 不可用等等。我们希望尽早发现这些问题，因为它们通常意味着未来再培训数据的不可逆转的损失。

这种中断可能只影响数据的一个子集。例如，一个地理位置或特定操作系统中的用户。这使得检测更加困难。除非另一个(适当监控！)系统依赖于相同的数据源，所以故障可能不会被注意到。

更糟糕的是，一个被破坏的数据源可能仍然提供数据。例如，损坏的温度传感器将返回上一次测量的恒定值。这很难发现，除非你跟踪“不寻常”的数字和模式。

与物理故障一样，我们不能总是立即解决问题。但是及时发现有助于快速评估损害。如果需要，我们可以更新、替换或暂停模型。

#4 破碎的上游模型

在更复杂的设置中，您有几个相互依赖的模型。一个模型的输出是另一个模型的输入。

这也意味着:一个模型的坏预测是另一个模型的坏特征。

拿一个内容或产品推荐引擎来说。

它可能首先预测某个产品或物品的受欢迎程度。然后，考虑到估计的流行度，它向不同的用户做出推荐。

这些将是独立的模型，基本上是相互连接的。一旦该商品被推荐给用户，它更有可能被点击，从而更有可能被拳头模型视为“受欢迎”。

一个更高科技的例子:汽车路线导航系统。

首先，你的系统构建可能的路线。然后，一个模型预测他们每个人的预期到达时间。接下来，另一个模型对选项进行排序，并决定最佳路线。这在某种程度上影响了实际的交通堵塞。一旦汽车沿着建议的路线行驶，这就产生了一种新的路况。

图片作者。

物流、路线和交付中的其他模型经常面临同样的问题。

这些相互关联的系统有一个明显的风险:如果其中一个模型出了问题，你会得到一个相互关联的问题循环。

监控数据质量和完整性

正如我们所见，机器学习模型的输入数据可能会出错。

我们希望这些事情永远不要发生，但是让我们现实一点。所以，我们的目标是及时赶上他们。

打破复杂系统的简单事物。 (图片来源: Unsplash )。

**通常，数据可靠性和一致性属于数据工程范畴。**您甚至可以在数据库级别拥有一些检查或监控系统。还有什么需要关注的吗？

**问题是，对于机器学习系统，我们不关心整体数据质量。**我们希望跟踪给定模型使用的特定数据子集。有时是专一的。仓库中 99%的数据是正确的并不重要；我们想检查一下我们的作品。

特征处理代码也是一个需要监控的独立移动部分。这需要定制设置。

因此，在数据质量和完整性方面，MLOps 符合 DataOps。我们最好仔细检查一下。

有一些与数据相关的东西需要注意:

#1 型号电话

要回答的第一个问题是这个模型是否有效。为此，看看模型响应的数量。这是添加到软件监控之上的一个基本但有用的检查。

为什么？服务本身可能是可操作的，但不是模型。或者，您可能比计划的更频繁地依赖于回退机制，如业务规则。

如果你的模型经常被使用，这就没那么有用了。但是如果有一个“正常”的使用模式，这是一个很好的检查。例如，你的模型部署在电子商务网站上，或者每天都有新的销售数据。你就知道会有什么样的消费。

查看模型调用的数量是发现问题的简单方法。

在这里，模特打电话的次数一夜之间变为零。也许服务中断了？

**根据模型环境，您可能想要分别检查请求和响应。**模型是否未被询问(例如，因为推荐小部件崩溃)或未能回答(例如，模型超时，我们不得不使用静态推荐)？答案会指出应该从哪里开始调试。

现在，我们来看看数据。

#2 数据模式

正如我们上面解释的，数据模式可能会改变。不管是因为不好的做法还是出于好意；我们想检测它。

我们的目标是了解特性何时被删除、添加或更改。

最直接的方法是执行逐个特征的检查和调查:

**1/如果特性集保持不变。**对于表格数据:有多少列？有没有什么东西不见了，或者有什么新的东西？

2/如果特征数据类型匹配。我们在某个地方得到了分类值而不是数值吗？例如，在给定的列中，我们有从 1 到 10 的数字特征。现在，当我们查询它时，我们看到类似“低”、“中”和“高”的值我们应该能抓到这个。

模式验证错误。(图片由作者提供)。

最后，您需要一个快速的摘要视图，来查看传入的数据集是否符合预期。

#3 缺失数据

我们还想检测任何丢失的数据。

**通常，会有一些可接受的缺失值。**我们不想对每个空条目都做出反应。但是我们希望比较缺失数据的水平是否保持在“正常”范围内，包括整个数据集和单个要素。是否丢失了任何关键功能？

**记住这一点很重要，因为缺失值可能有多种形式。**有时它们是空的，有时它们是“未知的”或“999”。如果您对缺少的功能进行简单的检查，您可能会错过其他功能。最好扫描缺失数据的标准表达式，如“N/A”、“NaN”、“undefined”等。偶尔用自己的眼睛进行审计也不是一个坏主意。

**如果你的特征数量有限，你可以将它们全部显示在一个图中。**我们就是这样做的，对缺失值的份额进行颜色编码:

图片作者。

**您还可以设置数据验证阈值，以定义何时暂停模型或使用回退。**例如，如果缺少太多特征。当然，“太多”的定义取决于您的用例以及模型的错误成本。

一个有用的建议是挑出你的关键驱动因素。您可以根据模型特征重要性或 SHAPley 值来实现。或者，将这两种方法与你的领域知识结合起来。

这个想法是建立不同的监控策略。你总是需要你的关键特性来运行模型。有了辅助手段，缺席就不是一个阻碍。你只需要做个记录，然后和数据所有者一起调查。

#4 特征值

数据摆在那里，不代表就是正确的。

例子:

• 在 excel 处理出错后,“年龄”列的值从 0.18 到 0.8，而不是 18 到 80。
• 一个物理传感器坏了，显示一周的某个恒定值。
• 有人在功能计算过程中掉了一个负号，您会看到负的销售数字。

在所有情况下，模型都是有效的，数据是可用的——但是被破坏了。

要检测到这一点，您需要监控特性的统计数据和分布。

我们使用明显库(图片由作者提供)比较了训练和生产中的特征分布。

**1/特征值范围。**对于数字特性，检查数值是否在合理范围内。对于分类属性，定义一个可能值的列表，并留意新奇的事物。

如何做到这一点？

• 通过查看训练分布，您可以直接定义您的期望值(最小-最大范围，或给定列的可能值)。
• 或者，依靠常识:我们知道“年龄”或“室外温度”的可能值。
• 如果有更多的上下文，您可以让领域专家来定义特定输入的“正常”。

它还有助于声明何时明确允许空值。

**2/关键特征统计。**对于数值特征，可以看平均值、均值、最小最大比、分位数。

后者将有助于捕捉像这种传感器损坏的情况。形式上，它保持在范围内，但测量完全是静态的:

图片作者。

**对于分类输入，您可以检查它们的频率。**例如，如果你处理文本，对应的可能是词汇的%。

目标是监控实时数据集的合规性并验证输入端的数据。通过这种方式，您可以在出现范围违规、异常值或统计数据变化时进行捕捉。

#5 特征处理

另一个要考虑的方面是在哪里运行您的数据有效性检查。

**当数据出错时，首先要问的是为什么。**在理想世界中，我们希望一发现错误就定位错误。断裂的连接或功能代码可能是一个原因。在这种情况下，源数据很好，但是在转换为模型特征的过程中会发生一些事情。

有时，为管道中的每一步分别验证输入和输出是有意义的。这样，我们可以更快地找到问题并进行调试。

例如，我们预测一家移动运营商的客户流失。

营销数据来自一个来源。购买日志与不断变化的产品计划相结合。然后，您将使用日志与关于技术连接质量的外部数据合并。特征转换需要几个步骤。

图片作者。

当然，您可以简单地验证上一次计算的输出。但是如果你注意到一些特性没有意义，你就不得不返回每一步。如果管道很复杂，单独检查可能会为您节省一些检测工作。

总结

数据质量监控是生产机器学习系统的第一道防线。通过查看数据，您可以在许多问题影响实际模型性能之前发现它们。

你可以，也应该对每个型号都这样做。这是一个基本的健康检查，类似于延迟或内存监控。它对于人类和机器生成的输入都是必不可少的。每一种都有自己的错误类型。数据监控还有助于揭示被放弃的或不可靠的数据源。

当然，数据问题不止于此。在下一篇文章中，我们将深入挖掘数据和概念漂移。

最初发表于T5【https://evidentlyai.com】。

在 appeally AI，我们构建开源工具来分析和监控机器学习模型。在 Github 中查看我们的 数据漂移检测工具 。

想留在圈子里？ 报名 获取我们的更新和产品消息，或者加入上Twitter和Linkedin获取更多关于生产机器学习的内容，或者加入我们的 不和谐社区 进行聊天和连线。

水下无人驾驶飞机的监控

原文：https://towardsdatascience.com/monitoring-of-an-underwater-drone-3c5c8a6d1a21?source=collection_archive---------46-----------------------

使用 Kafka 和 whylogs 监控流数据

克里斯·利维拉尼在 Unsplash 上的照片

数据在做出明智决策中的重要性现在已被几乎所有应用普遍认同。这也促进了对工具的需求，使我们能够以明智和有效的方式利用这些数据。

在本文中，我想分享一种方法，通过记录流数据的统计配置文件来设置监控仪表板，从而利用流数据。为此，我将使用水下遥控潜水器( ROV )作为用例。更具体地说，我们将监测来自最新的 OpenROV(现在的 Sofar )的 OpenROV v2.8 的故障，这是一种低成本的远程机器人水下无人机。为了增强我们的故障检测能力，我们将使用一个回归模型，通过 SKLearn 平台进行训练，对我们的车辆行为进行建模。这样，我们的监控仪表板将服务于两个目的:监控回归模型的性能和质量问题，以及(主要)监控车辆本身的健康状况。由于故意破坏 ROV 会很麻烦，我们将在我们的数据中手动注入一些传感器故障，并希望能够通过使用我们的仪表板来检测这些故障。

作为选择的数据记录平台，我们将使用 whylogs ，这是一个来自 WhyLabs 的开源库，旨在监控来自 ML/AI 应用程序的数据。Whylogs 为记录的记录计算近似的统计数据，这意味着它是具有大量数据的管道的合适选择。尽管这个例子使用了最少量的信息，但是知道所选择的工具考虑到了未来可能的扩展还是很好的。

由于我们要处理实时数据的连续流，我们需要选择一个合适的事件流平台。从这个意义上说，在这个项目中使用 Kafka 似乎是一个自然的选择，也是一个熟悉这个工具的好机会。这样，我们可以通过使用发布/订阅模式，将遥测信息的发送从模型预测和日志记录过程中分离出来。

你可以在这个项目的 jupyter 笔记本中了解这里讨论的一切。在项目的资源库中，您还会发现贯穿本文的各个 Python 脚本和所需文件。

目录

1. 概述
2. 我们以 结束
3. 故障注入
4. 开发应用程序
   ∘设置 Kafka ∘创建 Kafka 客户端 ∘遥测生产者 ∘预测生产者
5. 监控仪表盘
   ∘会话 0 —恒定增益故障
   ∘会话 1 —卡在(零)
   ∘会话 2 —卡在(最大值)
6. 结论

概观

让我们仔细看看我们的实验。

作者图片

ROV 以在线方式将其遥测信息发送到遥测主题中。这些信息只是 JSON 对象的集合，其中每个对象代表不同特征的一个采样点，例如车辆的角位置、电流、电压等。考虑到在这种情况下，信息已经收集完毕，我们将简单地通过 Python 脚本发送 JSON 内容，模拟 ROV 的实时操作。鉴于我们的目标是检查我们是否能够监控和验证一些常见传感器故障的存在，我们需要在将数据发送到遥测主题之前，在数据集中手动注入一些故障。传感器故障将在下一节详细解释。

下一个组件是预测生成器，它使用遥测主题，以便通过训练好的回归模型生成预测，并将结果传输到单独的预测主题中。在这个用例中，回归模型使用遥测信息来预测一个特定特征的下一个时间步长— GYROZ ，这是 ROV 在偏航方向的角速度(潜水器转弯的速度)。回归模型是一个线性最小二乘回归模型，具有 L2 正则化和多项式基函数，使用 SKLearn 库在大约 24 小时的 ROV 操作中进行训练。

接下来的两个组件将持续监听遥测和预测主题，以建立我们数据的统计资料，这些资料将用于记录会话的后续人工检查阶段，以便有望检测到 ROV 操作期间可能出现的异常。在这种情况下，如果采样点距离上一个采样点超过 5 分钟，则认为新的操作会话已经开始，对于每个会话，我们将数据聚合为 1 分钟一批的数据。由于我们的采样频率为 5 Hz ，因此每批大约有 300 个采样点。

最后，我们需要一种简单的方法来可视化统计结果。我决定将最相关的绘图类型集中在一个 iPython 小部件中。这样，我们只需使用 jupyter 笔记本就可以检查 whylogs 摘要的当前状态。

我们最终会得到什么

不要在整篇文章中建立结论，让我们从展示我们将如何监控我们的 ROV 操作和模型预测开始。一旦我们的所有流程都在发送和记录来自 ROV 操作的信息，最后一个组件就是监控仪表板本身，我们希望在这里集中所有必要的信息，以评估潜水器的行为。

考虑到最终目标是检测不同种类的故障，我实现了一个带有可定制参数的监控仪表板，因此我们可以从 whylogs 中选择正确的图表来检测不同的情况。在这个仪表板中，我们基本上可以选择要选择的参数:

• 要检查的单个操作会话。
• 我们希望检查的遥测信息，如速度、位置、电机输入、CPU 使用率等。
• 线性回归模型的预测，此处用于检查我们的 ROV 的行为是否与我们在标称条件下的预期有很大不同。

作者图片

我们将在文章的结尾更详细地讨论这些结果，但最终的结论是，通过调整我们仪表板的正确参数，我们肯定能够检测到由我们车辆中的感官故障引起的异常情况。因为这里的重点不是开发完美的回归模型，我们的预测本身不足以检测某些情况下的错误。然而，通过结合来自我们的预测和输入特征可视化的见解，我们可以对我们检查的每个操作会话中发生的事情有所了解。

故障注入

在这个实验中，我们将使用来自 4 个不同操作会话的数据，每个会话的持续时间从 4 到 9 分钟不等。在每个会话中，大约在一半时间注入一个持续时间为 5s 的 GYROZ 传感器故障。你可以看看 JSON 文件，已经注入了错误，在项目的资源库中，在 rov_data 文件夹下。

在下图中，注入的故障类型用橙色表示，应用于样本正弦信号。在会话 0 中，注入一个恒定增益故障，其中真实值因乘以一个恒定因子而失真，如 a) 所示。固定故障在会话 1 和会话 2 中均被模拟，不同之处在于其“固定”的值——而在会话 1 中，GYROZ 值固定在值 0，如 b) 所示，会话 2 的固定值为 5.56，这与 ROV 陀螺仪传感器的最大范围有关。最后，在会话 3 中注入一个漂移传感器故障，如 c) 所示。该故障模拟的情况是，相对于故障开始时，随着时间的增加，实际值发生失真。

作者图片

除了这些传感器故障，会话 3 中还应用了**丢失**错误，模拟水下机器人长时间停止发送信息的情况。与之前的故障不同，该故障不仅影响 **GYROZ** 值，还影响车辆传输的整套特征。这是通过在会话 3 运行结束时从我们的数据集中手动删除一些连续的数据点来模拟的。

开发应用程序

现在我们已经有了用例的概述，让我们继续实际实现应用程序。接下来的几个部分将涵盖向我们在 Kafka 的主题发送/读取信息所需的代码，使用我们的回归模型进行预测，并使用 whylogs 记录我们的统计数据。

建立卡夫卡

一旦容器启动，您可以使用以下命令进入kafka-tools命令行界面:

docker exec -it kafka /bin/sh

并检查可用的主题，只是为了确保它的工作:

kafka-topics --list --bootstrap-server localhost:9092

创造卡夫卡式的客户

在接下来的 Python 脚本中，我们将不得不创建大量的 Kafka 消费者和生产者。让我们定义两个简单的函数来创建客户端，这样我们可以在将来重用它们:

在这两种情况下，客户端都被告知应该联系的地址，以便引导初始群集元数据。此外，由于我们正在生成/消费 JSON 格式的值，我们需要用vaue_serializer / value_deserializer参数为它指定正确的处理方式。

在这个项目中，消费者被设置为总是从主题的开头开始，以确保每次运行都将记录整个内容。为此，在开始之前，我们首先必须手动将分区分配给我们想要的主题。

关于 whylogs 与 Kafka 集成的更多信息，你可以参考这个教程笔记本和 WhyLabs 上的这个博客帖子。

遥测生产者

现在我们已经运行了 Kafka，我们可以开始将 ROV 数据发送到我们的遥测主题。首先，我们需要创建一个 Kafka Producer 客户端，它将记录发布到我们的集群，并读取 rov_data 文件夹中的 JSON 编码文件，以创建一个字典列表:

正如我们所看到的，我们的采样点由一系列特征组成:

• mtarg1，mtarg2，mtarg3 :向 3 个螺旋桨中的每一个发送输入指令。
• 侧倾、俯仰、偏航:车辆绕 X、Y、Z 轴的角度位置。
• LACCX，LACCY，LACCZ: 车辆绕 X，Y，Z 轴的角加速度。
• GYROX，GYROY，GYROZ: 车辆绕 X，Y，Z 轴的角速度。
• SC1I，SC2I，SC3I: 每个螺旋桨的电流读数。
• BT1I，BT2I: 电动每个电池组的电流读数。
• *vout、iout 和 CPU usage:*ROV 的 BeagleBone 微型计算机的电压、电流和 CPU 使用率。

我们现在可以在我们的主题中发布我们的数据点:

如果您愿意，在发送信息之前，最好通过在kafka-tools输入以下命令来创建带有适当分区/复制的 Kafka 主题:

kafka-topics --create --bootstrap-server localhost:9092 --replication-factor 1 --partitions 1 --topic telemetry-rov

但是您不必这样做，因为如果主题不存在，它会自动创建一个主题。

在这个例子中，维护记录的顺序非常重要，所以我们调用了一个producer.flush()来确保只有在前一个请求已经被提交时才发出新的请求。

预测生产者

有了遥测数据，我们就能够开始用回归模型进行预测。鉴于我们正在对 GYROZ 进行一步预测，我们只需要等待一个时间步就可以得到我们的地面真相。通过计算上一个时间步的预测值和当前实际值之间的差值，我们定义了所谓的残差。这个想法是，水下机器人的潜在异常会产生更高的残差，因为我们的预测会比通常的实际值更远。

和前面一样，我们创建了消费者客户端(从遥测主题读取)和生产者客户端(发布到我们的预测主题)。我们还必须加载我们的 SKLearn 模型，用 joblib: 持久化

在我们的 main 函数中，脚本将持续从主题中获取数据，并计算每个时间步长读取的残差。如果 10 秒钟过去了还没有收到新的记录，我们会输出一个警告来通知用户。

一旦我们有了当前和先前时间步长的数据，就可以计算残差:

为了进行预测，我们还需要加载在模型训练过程中安装的最小-最大定标器(BL_x.pickle和BL_y.pickle)，这样我们就可以对预测和逆变换的特征进行变换，以输出未缩放的残差。

为了保持遥测和预测主题之间的一致性，我们希望存储每个时间戳的残差，即使计算它是不可能的。因此，对于第一个采样点，或者当两个采样点在时间上相距太远时，残差被记录为一个nan值。

遥测记录器

一旦适当地设置了两个 Kafka 生成器，我们就可以开始用 whylogs 记录我们的会话配置文件了。记录从遥测主题轮询，并分成单独的会话。如果下一个采样点与上一个采样点相隔超过 5 分钟，则当前会话将被结束并记录，然后再开始下一个会话。当超过 10 秒钟没有新信息时，我们也认为当前会话已经结束，并记录结果。

预测记录器

我们的预测题目也是这样。这里的不同之处在于，我们不仅要记录剩余要素，还要进行一些转换，以便创建和记录附加要素。

即使对于车辆的标称条件，我们也可能在残值中有峰值，导致高比率的误报。为了减少这种情况，我们根据不同的时间框架计算残差的移动平均值。在本例中，除了未改变的残差，我们还将记录最后 5 、 10 和 15 时间步长( 1 、 2 和 3 秒)的移动平均值:

如果，对于给定的滑动窗口，我们有nan值，或者我们没有足够的记录来计算移动平均值，那么对于给定的时间戳，nan被记录。

会话记录器

每当记录器结束一个会话时，就会调用log_session()函数，该函数负责初始化一个日志记录会话，并记录给定会话的每个记录。

为此，让我们将数据组织成一个 Pandas 数据帧，将我们的时间戳列转换成 datetime 对象，然后使用df.groupby将数据帧分成一批，每批 1 分钟。通过这种方式，每个操作阶段都将记录水下机器人每分钟活动的统计数据。key和freq参数分别告诉我们分组的列和分组的频率。

将数据适当地分成批后，我们现在可以为每批数据调用session.logger()，传递dataset_timestamp来标记每个窗口的开始，并继续记录每批数据。

监控仪表板

在这个阶段，我们让我们的消费者监听发送的任何新记录，并将它们记录到我们的 whylogs 输出文件夹中，根据配置文件 .whylogs.yaml ，这个文件夹就是 whylogs-output 文件夹。剩下要做的是使用生成的统计数据来检查操作会话，寻找注入故障的迹象。

Whylogs 为我们提供了许多探索日志统计属性的方法。在这个例子中，我将把自己限制在内置的绘图上，这为我们提供了一种直观检查特性的方法，比如特性分布、缺失值和数据类型。

尽管要监控的主要遥测特征是 **GYROZ，**但有一种简单的方法来检查所有其余特征的曲线将是有用的。至于剩余特征，我们可能想要检查不同移动平均线的图。考虑到这些选项中的任何一个，我们都有 3 或 4 种可能感兴趣的图，将所有这些选项集中到一个交互式监控仪表板中会很有趣，用户可以在其中选择他感兴趣的特定图。在这个项目中，这是以一个 **iPython 小部件的形式完成的。**

python -m pip install ipywidgets

并启用小部件扩展:

jupyter nbextension enable --py widgetsnbextension

会话 0 —恒定增益故障

现在，让我们看一些输出示例。通过选择第一个会话，我们将看到 ROV 操作的日期和时间，以及遥测和残差图的不同选择:

作者图片

该会话有一个恒定增益传感器故障。从上图来看，单独评估 GYROZ 分布是困难的，因为不同的驾驶模式会导致不同的分布，这是正常的。不变的残值也不是很清楚。但是通过应用 3s 的移动平均线，我们肯定开始看到一些异常行为的迹象。在这种情况下，仅监控车辆的传感信息不足以检测故障。

会话 1 —停留在(零)

让我们继续我们的第二个例子，会话 1:

作者图片

在此阶段，注入了一个固定 0 故障。不幸的是，在这种情况下，遥测和残差分布都没有多大帮助。回归模型不够敏感，不足以捕捉故障。然而，数据类型图产生了一个有趣的结果。该特性的值通常是一个浮点数，但是 whylogs 将一系列恰好为 0 的值推断为一个整数序列，使其与众不同。

会话 2 —固定不变(最大)

第三个例子也是固定值，但固定在传感器的最大范围:

作者图片

这个很容易发现，因为最大值确实高于通常的分布。遥测和残差分布图都认为在 21:13 附近有异常。

第 3 部分—漂移和损失

为了避免重复，我不会显示漂移传感器故障的分布图，因为这种情况下产生的图与会话 0 非常相似。然而，应用于残差的缺失值图告诉我们一些关于注入损耗误差的信息:

作者图片

每当我们没有有效的先前时间步长时，残差就用nan值记录。因此，预计第一个会话的采样点会有缺失值。但是，当它们出现在运行的中间时，这是两个采样点之间经过了一段延长的时间( > 0.5s )的标志，表明出现了损失错误。尽管我们没有直接监控丢失错误，但我们可以在运行结束时看到它的存在，大约在 09:14 。

结论

在本文中，我想通过在一个特定的用例中应用它们来探索数据流和监控的可用工具:水下无人机的故障检测。尽管 MLOps 生态系统正在快速发展，但我觉得在生产中监控 ML 应用程序的解决方案仍然很少。这就是为什么像 whylogs 这样的开源工具是 ML 从业者工具集的一个非常受欢迎的补充。

在这个项目中，我们的回归模型远非完美，在许多情况下，预测本身不足以捕捉我们注入的故障条件。然而，通过设置一个简单的监控仪表板，我们能够通过同时查看输入和输出图来获得更广泛的视图，此外，我们还能够从许多不同的图中选择不同的特性。对于这个项目，在仪表板中只包含来自 whylogs 的内置图就足够了，但是我们可以通过包含每个完整会话的可用摘要的单独选项卡来添加更多信息。

至于应用程序本身，也有很大的扩展空间。在这个例子中，出于演示的目的，我们在本地使用了 Kafka，但是我确信对于一个生产环境，事情会变得更加复杂。也许在未来，我们可以让整队的遥控潜水器被自动监控故障！

暂时就这样吧！感谢您的阅读，如果您有任何问题或建议，请随时联系我们！

在看恐怖电影时分析你身体的葡萄糖反应

可穿戴设备将会继续存在。像 Fitbit 这样的设备现在拥有大约 3000 万活跃用户，比这个星球上活跃的软件开发者还多，而且在久而久之越来越受欢迎。

来自 Pexels 的 Cottonbro 摄影

可穿戴设备有各种形状和尺寸，可以执行各种功能。我有幸测试了 T4 Veri T5 公司的一种新设备，它能提供实时血糖数据。这让我想到:除了监测糖尿病等疾病，我们还能通过跟踪血糖水平获得什么好处？

但首先，这里有一些关于血糖监测设备的基础知识。是的，它确实有一根针。不，不是不方便。是的，它确实需要每 15 天更换一次，是的，它很舒服，也很容易使用。

你可能想知道为什么有人会在手臂上插一个针头传感器，但话说回来，这比记录你六年来的饮食习惯要少得多。(实际上，在可穿戴设备出现之前，有一些有趣的研究调查了有多少人在记录他们的习惯。)

了解葡萄糖和身体的胰岛素反应

理解这些数据需要相当多的知识。如果你对此感兴趣，我鼓励你做更多的研究。在这里，我将更多地关注数据是如何设计的，以及它如何作为一种数据集的例子，这种数据集可以促进对个体的更好的医学理解，并创造出“精确病人”，正如史蒂文·查拉普博士曾经称他们为“精确病人”。

这里你可以看到 Veri app UI 显示了我某个典型早晨的数据(这个数据其实是真实的)。如果你的第一反应是想知道工程单位 mg/dL 是什么，那就随便玩转换器吧。TLDR 版本设定为 70 毫克/分升约为 3.9 毫摩尔/升，100 毫克/分升约为 5.6 毫摩尔/升

图片由 Veri app 作者提供

根据梅奥诊所的说法，血糖水平低于 200mg/dl 属于正常范围，低于 100 mg/dl 属于正常空腹范围。

我从数据本身学到了什么？

我收到的数据实际上是相当重复的。我在想我可能会进行的各种食品工程实验，但无论我吃什么，我的代谢反应都是相似的，我的葡萄糖水平以一种非常可预测的方式波动——当我吃东西时，它们上升，当我禁食时，它们缓慢下降。但是，我还是得到了一些有价值的观察结果:

锻炼导致我的血糖水平出现有趣的波动。左侧的“峰值”实际上来自禁食期间的剧烈运动，而不是进食。

禁食期间的血糖变化让我对通过酮症分解脂肪如何影响我的血糖水平有了一些了解。了解酮症等功能背后的理论是一回事，但没有什么比看到自己血糖数据的起伏更重要的了。

图片由 Veri app 作者提供

对葡萄糖的营养影响是我最期待测量的，但正如你在左边的图表中看到的，它显示了当我在下午 6 点后吃东西(“适当的食物”)和晚上 8 点后再吃东西(精制糖)时，吃“适当的食物”实际上对葡萄糖水平的影响比锻炼小(尽管那些美味的精制糖确实导致了最大的峰值)。

你还能试验什么？

给我印象最深的是我的数据的重复性。当然，这完全取决于所讨论的人，并且在某人开始具有较大葡萄糖水平差异的情况下，该数据的效用将会高得多。然而，这让我想起了一个有趣的问题:我还能把这些数据和什么结合起来呢？

在我们最近与 Jim Guszcza 的讨论中，他指出，可穿戴设备可以通过向开发者开放数据来成倍增加其创造的价值，然后开发者可以将这些数据整合到新的应用中。这个案例也不例外。如果我能像看恐怖电影一样监控我的葡萄糖对外部压力的反应会怎么样？有影响吗？弄清楚会很有趣。其他生命体征呢，比如体温？我们能从由我们的综合健康数据组成的数据集中收集到什么？

开放平台放大价值

如果将行为数据、来自不同传感器的数据以及活动、媒体消费和营养数据结合起来，您会看到用例的数量增加了几个数量级。我确信有一个最佳间歇禁食时间表的用例，甚至可能有一个不同类型电影的理想小吃的用例。

你能想到什么类型的用例？让我们知道。

摆弄 Alexa 程序

原文：https://towardsdatascience.com/monkeying-around-with-alexa-routines-3f3f95795922?source=collection_archive---------13-----------------------

最后一种编程调用 Alexa 例程的方法

如果您正在寻找一种在代码中调用 Alexa 例程的方法，您已经找到了合适的文章。我将向你展示如何使用免费的 Alexa 应用程序语音猴，在任何程序和你的 Alexa 之间架起一座桥梁。

你为什么要这么做？

可能有大量有创意的用例，但我想到了两件事:

1. 在代码中与支持 Alexa 的智能设备进行交互
2. 在你的代码中使用你的 Alexa 作为某种语音提示系统

*这种方法最好的一点是它是语言不可知的。*一旦你设置好了，就只需要一个 GET 请求来调用你的 Alexa 程序。

Alexa 已经可以控制这台空调了…如果我能用树莓 Pi 或者无服务器功能之类的东西控制 Alexa 岂不是很酷？(图片由作者提供)

我的问题背景

当我在寻找用 Python 程序控制我的 Alexa 空调的方法时，我遇到了语音猴子。

我的“智能”空调应该将房间保持在一定的温度，但根据我的经验，它要么太冷，要么太热。我可以通过简单地与 Alexa 交谈来打开/关闭我的空调并设置温度——这使得调整事情更容易——但我与 Alexa 交谈的次数有点太多了。为什么不让程序替我做呢？

我有一个备用的 Raspberry Pi 来运行我的程序，连接到 DHT11 温度传感器来监控温度——我的计划是监控当前温度，并根据需要打开或关闭我的空调，以保持更可预测的温度。

似乎可行——但有一件事让这个计划有点困难。

如何通过树莓 Pi 与我的 AC 进行交互？

是的，也许我可以用电线把我的树莓皮接到我的交流电上，但是我真的没有摆弄物理电子设备的背景。我的 AC 带有一个遥控器——也许我可以用一个带有红外发射器的 Raspberry Pi 来重放来自 AC 遥控器的命令？这是可行的，但是记录和定义这些按钮的工作量很大。

您可以通过带有 Raspberry Pi 和红外增强器的红外遥控器来控制任何可控制的设备。我以前用上图的设置做过，但是设置、记录所有按钮的红外输出以及找到一个红外发射器可以清晰地看到你想要控制的设备的地方需要很多工作——这实际上是最后的手段。(图片由作者提供)

我的结论？我的 AC 是一款智能设备，内置了某种智能家居接口，最好利用这一点。制造商已经为我们做了大量工作来创建 Alexa 界面，所以我们就用它吧。

**但是我们如何与这款智能设备的 Alexa 界面互动呢？**目前还没有真正官方支持的 Alexa 方式来做到这一点。

浏览几年前的一些论坛，我看到一个建议，写一个程序来执行文本到语音转换，并将语音记录发送到 Alexa API。它可以让你调用任何你想要的 Alexa 命令，但这有点不方便，因为你需要一种方法来自动刷新你的亚马逊 cookies(根据我的经验，我每次都需要填写验证码)。

另一个建议甚至更笨拙——使用两个相邻的 Alexa 设备，并使用这个主动提供的 Alexa 文本到语音转换项目，让第一个 Alexa 设备说出你给它的任何命令，第二个 Alexa 设备实际上执行命令。这将是可行的——但它确实需要一个额外的 Alexa 设备，而且让这些东西一直互相说话肯定会很烦人。更不用说它可能会有点慢，而且不可靠(在命令过程中考虑像背景聊天这样的事情可能会把事情弄糟)。

如果你想在几年前做类似的事情，这将是你不得不忍受的地狱。

谢天谢地，我发现了一个更近的建议，使用语音猴子作为一个 API 来暴露你的 Alexa 例程，与其他选择相比，这似乎是显而易见的。

Alexa 例程是 Alexa 的一个功能，让你在你的 Alexa 生态系统中做类似 IFTTT(如果这个，那么那个)的事情。使用 Alexa 例程，您可以为一系列命令创建自己的快捷方式，这些命令可以链接到自定义触发器。

Alexa 例程可以让你为任何你想要的触发器串起一系列的 Alexa 命令。这是我从 Reddit 上重新创建的一个，我觉得很有趣。(图片由作者提供)

简单来说，它是如何工作的:语音猴子让你创造猴子，他们称之为“虚拟智能家庭门铃”

你可以把每只猴子想象成它自己独特的虚拟按钮(显示为 Alexa 支持的智能设备)，可以通过向分配给猴子的 URL 发送 GET 请求来按下它。通过 Alexa 例程，你可以使用猴子作为 Alexa 例程的触发器(它可以调用你的 Alexa 支持的几乎任何功能)。很酷吧？

你可以看到我创造的猴子。每只猴子都被分配了一个唯一的 URL，我可以通过发送 GET 请求来触发它。Voice Monkey 为您提供了一个很好的触发测试来测试您的创作，还提供了一个游乐场部分，它提供了一个 UI 来定制您的 GET 请求。(图片由作者提供)

在你的 Alexa 程序中设置你的猴子为“当”触发器。这个 Alexa 例程现在可以通过 GET 请求调用。(图片由作者提供)

使用语音猴进行设置

设置起来相当容易。下面是语音猴快速入门指南提供的一些说明。

1.你首先需要使用 Alexa 应用程序启用语音猴子技能并链接你的亚马逊账户。

2.使用您用于链接技能的同一个亚马逊帐户登录到语音猴。

3.完成设置，然后转到“管理猴子”生成您的第一只猴子。

4.在 Alexa 应用中创建一个新的例程，以你的猴子为触发器(“当这发生时”>“智能家居”>“你的猴子名”)。

5.访问仪表板的游乐场部分，测试你的新猴子。

6.(可选)-要发布公告，您必须打开语音猴技能，作为您的例行程序中的最后一个动作。

一旦你完成了这个设置，你应该准备好启动你的猴子了！

尝试你的第一个请求

使用以下 URL 中的自定义值替换MY_ACCESS_TOKEN、MY_SECRET_TOKEN和MY_MONKEY_NAME，并尝试从浏览器导航到该 URL。

[https://api.voicemonkey.io/trigger?access_token=MY_ACCESS_TOKEN&secret_token=MY_SECRET_TOKEN&monkey=MY_MONKEY_NAME&announcement=hello%20world](https://api.voicemonkey.io/trigger?access_token=MY_ACCESS_TOKEN&secret_token=MY_SECRET_TOKEN&monkey=MY_MONKEY_NAME&announcement=hello%20world)

你应该看到你的猴子被触发了。如果你在你的 Alexa 例程中添加了语音猴子技能作为最后一个动作，你应该会听到 Alexa 说“你好，世界”。

现在，如果您想让您的程序向这个 URL 发送 GET 请求并进行自定义通知，您可以在 URL 中的announcement参数中填入您喜欢的任何内容——只需确保使用编码 URL 中空格字符的%20进行分隔。

例如在 Python 中

import requestsdef format_url(s):
    return s.split().join('%20')url = '[https://api.voicemonkey.io/trigger?access_token=MY_ACCESS_TOKEN&secret_token=MY_SECRET_TOKEN&monkey=MY_MONKEY_NAME&announcement=](https://api.voicemonkey.io/trigger?access_token=MY_ACCESS_TOKEN&secret_token=MY_SECRET_TOKEN&monkey=MY_MONKEY_NAME&announcement=hello%20world){}'temp = 72 # This might change--we want to Alexa to announce itannouncement = format_url(f'Temperature is {str(temp)}')
requests.get(url.format(announcement))

结论

既然你已经听说过语音猴子，如果你想玩一些与你的定制程序挂钩的 Alexa 例程，就去试试吧。

在撰写本文时，Voice Monkey 对多达 300 只猴子完全免费。这是 300 个独特的 Alexa 例程，你可以通过语音猴 API 暴露。

提醒一句:虽然 Voice Monkey 现在是免费的，但它是一项需要提供商付费运营的服务。

根据文件

语音猴子是免费的，而在测试阶段，我们计划让它尽可能长时间免费。

我们很乐意永久免费提供这项服务，但幕后存在基础设施和维护成本。

我们将尽可能保持免费，如果需求给成本带来太大压力，如果我们引入定价结构，我们会让你知道。

不管未来的价格结构如何，现在都可以免费试用和修改！

请注意，我不以任何方式隶属于语音猴，不能保证任何可靠性，他们的服务正常运行时间。这不是一个付费广告，我只是在展示我个人使用案例中喜欢使用的一项服务。

自动驾驶中使用变压器的单目 BEV 感知

原文：https://towardsdatascience.com/monocular-bev-perception-with-transformers-in-autonomous-driving-c41e4a893944?source=collection_archive---------0-----------------------

截至 2021 年末的学术文献和行业实践回顾

更新:

• 添加 DETR3D，2021/11/07
• 添加 STSU，将图像转换成地图，2021/12/27

量产级自动驾驶需要可扩展的世界三维推理。随着自动驾驶汽车和其他交通代理在道路上移动，大多数时候推理不需要考虑高度，这使得鸟瞰图(BEV)成为一种足够的表示。

传统自动驾驶堆栈的极度简化架构(图片由作者提供)

上图说明了一个传统的自动驾驶栈(为了简单起见，这里省略了本地化等很多方面)。在此图中，圆圈代表功能模块，并根据它们所在的空间进行颜色编码。绿色模块发生在 2D，蓝色模块发生在 BEV。只有相机感知发生在 2D 空间，或者更准确地说，在获得机载相机图像的透视空间 e。它依赖于传感器融合和大量手工制作的规则来将 2D 检测提升到 3D，可选地借助于来自雷达或激光雷达的 3D 测量。

这里我说传统至少有两个原因。首先，相机感知仍然发生在透视空间中(与最近的单目 3D 物体检测趋势相反，可以在这里找到对其的回顾)。第二，来自多模态传感器的结果以后期融合的方式进行融合(与早期融合相反，早期融合中传感器数据被送入神经网络进行数据驱动的关联和几何推理)。

BEV 感知是相机感知的未来

该图暗示，对于唯一的异常值(摄像机感知)来说，转向 BEV 将是非常有益的。首先，直接在 BEV 中执行相机感知可以直接与来自雷达或激光雷达等其他设备的感知结果相结合，因为它们已经在 BEV 中表示和使用。BEV 空间中的感知结果也容易被下游组件使用，例如预测和规划。第二，单纯依靠手工制作的规则将 2D 观测提升到 3D 是不可扩展的。BEV 表示有助于过渡到早期融合管道，使融合过程完全由数据驱动。最后，在只有视觉的系统中(没有雷达或激光雷达)，在 BEV 中执行感知任务几乎成为强制，因为在传感器融合中没有其他 3D 提示可用于执行这种视图转换。

一年前的 2020 年末，我写了一篇评论博文，总结了学术界关于单眼 BEV 感知的论文。该领域研究如何将单目图像提升到 BEV 空间进行感知任务。从那以后，我一直在更新我读过的更多的文章，以保持这篇博文的更新和相关性。这个领域的范围已经从语义分割稳步扩展到全景分割、对象检测，甚至其他下游任务，如预测或规划。

在过去的一年里，单眼 BEV 感知出现了三种方法。

• IPM: 这是基于平地假设的简单基线。Cam2BEV 也许不是第一部这样做的作品，但却是最近的相关作品。它使用 IPM 来执行特征变换，并使用 CNN 来校正不在 2D 路面上的 3D 对象的失真。
• Lift-splat :利用单深度估计提升至 3D，并在 BEV 上进行 splat。这股潮流是由Lift-Splat-shot发起的，后续还有 BEV-Seg 、 CaDDN 、 FIERY 等诸多作品。
• MLP :使用 MLP 为视图转换建模。这一行是由 VPN 发起，渔网，以及HDP mapnet跟进。
• 变形金刚:使用基于注意力的变形金刚来模拟视图变换。或者更具体地说，基于交叉关注的变压器模块。这一趋势开始显示出最初的牵引力，因为自 2020 年年中以来，至少到目前为止，截至 2021 年底，《变形金刚》席卷了计算机视觉领域。

在这篇评论性的博文中，我将关注最后一个趋势——使用变形金刚进行视图转换。

几乎具有讽刺意味的是，许多文献中的论文，有些是在 CV 中的变形金刚兴起之前，有些是在最近的这波浪潮中，将它们的专用视图转换模块称为“视图变形金刚”。这使得在文献中寻找那些确实使用注意模块进行观点转换的人变得更加困难。

为了避免混淆，在这篇博文的后面，我将使用大写的变形金刚来指代基于注意力的架构。也就是说，使用变形金刚通过提升图像到 BEV 来执行视图转换似乎是一个很好的双关语。

使用变压器查看变换

变形金刚的一般架构已经在许多其他博客中进行了广泛的解释(例如著名的插图变形金刚)，因此我们在此不再赘述。由于全局注意机制，变形金刚更适合执行视图变换的工作。目标域中的每个位置到源域中的任何位置具有相同的距离，克服了 CNN 中卷积层的局部受限感受野。

交叉关注与自我关注

《变形金刚》中交叉注意力和自我注意力的运用(来源)

变压器中有两种关注机制，编码器中的自关注和解码器中的交叉关注**。它们之间的主要区别是查询 Q。在自我注意中，Q、K、V 输入是相同的，而在交叉注意中，Q 与 K 和 V 在不同的域中。**

正如我之前的博客中所详述的，关注模块的输出形状与查询 q 相同，就此而言，自我关注可以被视为原始特征域中的特征助推器，而交叉关注则可以被视为跨域生成器。

****交叉注意的想法其实是最初的注意机制，甚至早于变形金刚的创造。注意机制在 ICLR 2015 年的论文“通过联合学习对齐和翻译的神经机器翻译”中首次提到。原始 NeurIPS 2017 Transformer 论文“注意力是你所需要的全部”的更具创新性的贡献实际上是用自我注意力模块取代了双向 RNN 编码器。这也许是为什么许多人在提到交叉注意力时仍然更喜欢注意力这个词而不是变形金刚的原因。更多精彩的叙述请见这里。

交叉注意力是你所需要的

《变形金刚》在 CV 中的许多最新进展实际上只是利用了自我关注机制，比如被大量引用的 ViT ( 一幅图像值 16x16 个字:变形金刚在比例上的图像识别，ICLR 2021)或者 Swin Transformer ( 使用移位窗口的分级视觉变形金刚，Arxiv 2021/03)。它们作为主干特征提取器的增强。然而，考虑到在大规模生产车辆上典型的资源有限的嵌入式系统中部署通用变压器架构的困难，自我关注相对于得到良好支持的 CNN 的增量好处可能难以证明。在我们看到一些突破性的自我关注超过 CNN 之前，专注于 CNN 的行业应用(如量产自动驾驶)将是一个明智的选择。

另一方面，交叉注意有更充分的理由。将交叉注意力应用于计算机视觉的一项开创性研究是 DETR ( 用变形金刚进行端到端的物体检测，ECCV 2020)。DETR 最具创新性的部分之一是基于称为对象查询的固定数量槽的交叉注意力解码器。不同于原始的 Transformer 文件，其中每个查询被一个接一个地(自动回归地)馈送到解码器，这些查询被并行地(同时地)馈送到 DETR 解码器。查询的内容也是学习的，并且除了查询的数量之外，不必在训练之前指定。这些查询可以被视为一个空白的、预先分配的模板，用于保存对象检测结果，而交叉注意解码器负责填补空白。

DETR 的交叉注意力解码器部分可以看作是一个跨域生成器(来源)

这引发了使用交叉注意解码器进行视图转换的想法。输入视图被馈入特征编码器(基于自我关注或基于 CNN)，编码后的特征作为 K 和 v，目标视图格式的查询 Q 可以被学习，只需要被光栅化为模板。Q 的值可以与网络的其余部分一起学习。

DETR 架构可适用于 BEV 转型(图片由作者提供)

在接下来的会议中，我们将回顾一些最相关的工作，并且我们还将深入探讨由 Andrej Karpathy 在特斯拉 AI 日 (08/20/2021)分享的变压器在特斯拉 FSD 中的使用。

PYVA (CVPR 2021)

PYVA ( 专注地投影您的视图:通过交叉视图变换进行单目道路场景布局估计，CVPR 2021)是第一个明确提到交叉注意力解码器可用于视图变换以将图像特征提升到 BEV 空间的项目。与早期的单目 BEV 感知工作类似，PYVA 对转换后的 BEV 特征执行道路布局和车辆分割。

PYVA 的架构使用了 MLP 和交叉关注(来源)

PYVA 首先使用 MLP 将透视空间中的图像特征 X 提升到(所要求的)BEV 空间中的 X’。第二 MLP 将 X’映射回图像空间 X”，并使用 X 和 X”之间的循环一致性损失来确保该映射过程保留尽可能多的相关信息。

PYVA 使用的 Transformer 是一个交叉注意模块，查询 Q 要映射到 BEV 空间中的 BEV 特征 X’，V 和 K 都是透视空间中的输入 X(如果忽略透视空间中 X 和 X”的区别)。

注意，在 BEV 空间中没有对 X '的显式监管，而是由 BEV 空间中的下游任务损失隐式监管。

在 PYVA 中，似乎是 MLP 做了视图转换的繁重工作，而交叉注意用于增强 BEV 中被提升的特征。然而，由于对 BEV 空间中生成的查询没有明确的监督，从技术上来说，很难将这两个组件的贡献分开。对此进行消融研究将有助于澄清这一点。

整洁(ICCV 2021)

NEAT ( 端到端自动驾驶的神经注意力场，ICCV 2021)在使用基于 MLP 的迭代注意力将图像特征提升到 BEV 空间之前，使用变压器来增强图像特征空间中的特征。本文的目标是可解释的、高性能的、端到端的自动驾驶，但我们在这里将只关注可解释的中间 BEV 表示的生成。

整洁的建筑(来源)

编码器模块中使用的转换器基于自我关注。作者还承认“变压器可以从我们的编码器中移除，而不会改变输出维度，但我们将它包括在内，因为它根据我们的消融研究提供了改进”。正如我们上面所讨论的，配备自我关注模块的编码器可以被视为一个美化的主干，这不是本研究的重点。

最有趣的部分发生在神经注意力场(NEAT)模块。对于给定的输出位置(x，y)，使用 MLP 将输出位置和图像特征作为输入，生成与输入特征图像具有相同空间维度的注意图。注意力图然后用于点积原始图像特征，以生成给定输出位置的目标 BEV 特征。如果我们遍历所有可能的 BEV 网格位置，那么我们可以将 NEAT 模块的输出平铺到一个 BEV 特征图**。**

交叉注意模块 vs 神经注意场模块(图片由作者提供)

这个简洁的模块非常类似于交叉注意机制。主要区别在于 Q 和 K 之间的相似性度量步骤被 MLP 代替。这里我们忽略了其他一些小细节，例如 Softmax 运算，以及值 v 的线性投影。从数学上讲，我们有以下 MLP、交叉注意力和整洁的公式。

MLP、交叉注意力和整洁的区别(改编自来源)

符号约定遵循我之前关于 MLP 和变形金刚的区别的博文。简而言之，很明显，NEAT 保持了交叉注意机制的数据依赖性，但它不再具有交叉注意的排列不变性。

为了清楚地与交叉注意机制进行比较，在上面的讨论中省略了一个细节。在 NEAT 的实现中，MLP 的输入不是完全成熟的图像特征 c，而是不具有任何空间范围的全局汇集的 c_i。采用迭代注意。作者认为，把比 c_i 维数高得多的图象特征 c 送入 MLP 要复杂得多。也许 MLP 的一次通过不足以补偿空间内容的损失，因此需要多次通过。本文没有提供这种设计选择的消融研究。

解码器部分还使用 MLP 来生成所查询位置(x，y)的期望语义含义。如果我们将净输出平铺到 BEV 特征图中，以特定位置的特征和位置坐标作为输入的 MLP 相当于 BEV 特征图上的 1x1 卷积，其中(x，y)连接到特征图。这个操作和 CoordConv (NeurIPS 2018)非常相似。这是利用 BEV 特征图进行下游 BEV 感知任务的相当标准的做法。我们甚至可以超越 1x1 卷积，通过堆叠的 3x3 卷积进一步提高性能，以增加 BEV 空间中的感受域。

总之，NEAT 使用交叉注意力的变体(MLP 来代替相似性度量)来将相机图像提升到 BEV 空间。

STSU (ICCV 2021)

STSU ( 车载图像结构化鸟瞰交通场景理解，ICCV 2021)采用稀疏查询进行目标检测，沿袭了 DETR 的做法。STSU 不仅能检测动态物体，还能检测静态道路布局。这是同一作者的 BEV 特征拼接的后续工作，在我的另一个博客中评论了一篇关于 BEV 语义分割的论文。

STSU 的建筑(来源)

STSU 使用两组查询向量，一组用于中心线，一组用于对象。最有趣的是它对结构化道路布局的预测。车道分支包括几个预测头。

• 检测头预测由某个查询向量编码的通道是否存在。
• 控制头预测 R 贝塞尔曲线控制点的位置。
• 关联头预测用于聚类的嵌入向量。
• 关联分类器接受 2 个嵌入向量，并判断中心线对是否关联。

贝塞尔曲线非常适合中心线，因为它允许我们用固定数量的 2D 点来建模任意长度的曲线。

在 LSTR ( 利用变压器进行端到端车道形状预测，WACV 2011)中也使用了用于车道预测的变压器，其仍然在图像空间中。结构化的道路布局预测也可以在 HDMapNet (一个在线高清地图构建与评估框架，CVPR 2021 工作坊)中找到，没有使用变形金刚。

DETR3D (CoRL 2021)

DETR3D 、T21(通过 3D 到 2D 查询从多视图图像进行 3D 对象检测，CoRL 2021)也使用稀疏查询进行对象检测，遵循 DETR 的实践。类似于 STSU，但 DETR3D 侧重于动态对象。查询在 BEV 空间中，并且它们使得 DETR3D 能够直接在 BEV 空间中操纵预测，而不是对图像特征进行密集变换。

DETR3D 的架构(来源)

BEV 感知优于 mono3D 的一个优势在于相机重叠区域，在该区域中，物体更有可能被相机视野剪切。Mono3D 方法必须基于来自每个摄像机视点的有限信息来预测每个摄像机中的裁剪对象，并依赖全局 NMS 来抑制冗余框。DETR3D 专门评估了图像边界(约占整个数据集的 9%)处的这种裁剪对象，并发现 DETR3D 比 mono3D 方法有显著的改进。这在特斯拉 AI 日也有报道。

多凸轮预测优于单凸轮结果(来源)

DETR3D 使用了几个技巧来提高性能。首先是对象查询的迭代优化。本质上，预测 BEV 中的 bbox 中心被重新投射回具有摄像机变换矩阵(内部和外部)的图像，并且多摄像机图像特征被采样和集成以改进查询。这个过程可以重复多次(本文中为 6 次)以提高性能。

第二个技巧是使用预训练的 mono3D 网络主干来提高性能。对于基于变形金刚的 BEV 感知网络来说，初始化似乎非常重要。

将图像转换成地图(2021/10，Arxiv)

将图像转换成贴图注意到，无论图像像素的深度如何，图像(图像列)中的垂直扫描线与穿过 BEV 贴图中摄像机位置的极线之间都存在 1–1 的对应关系。这类似于 OFT (BMVC 2019) 和 PyrOccNet (CVPR 2020) 的想法，沿着投射回 3D 空间的光线在像素位置涂抹特征。

在列方向使用轴向交叉注意力转换器和在行方向使用卷积大大节省了计算。

特斯拉的方法

在 2021 年的特斯拉 AI 日，特斯拉揭示了为特斯拉 FSD 提供动力的神经网络的许多复杂的内部工作原理。最有趣的构建模块之一是一个被称为“图像到 BEV 转换+多相机融合”的模块。这个模块的中心是一个转换器模块，或者更具体地说，是一个交叉关注模块。

特斯拉的 FSD 架构(来源)

你初始化一个你想要的输出空间大小的栅格，你用输出空间中的正弦和余弦的位置编码来平铺它，然后这些用 MLP 编码成一组查询向量，然后所有的图像和它们的特征也发出它们自己的键和值**，然后查询键和值馈入多头自我注意(作者注:这实际上是交叉注意)。**

— Andrej Karpathy，2021 年特斯拉人工智能日，来源

虽然 Andrej 提到他们使用了多头自我注意，但他描述的显然是一种交叉注意机制，他幻灯片中右边的图表也指向了最初变形金刚论文中的交叉注意块。

这个视图转换中最有趣的部分是 BEV 空间中的查询。它由 BEV 空间中的栅格生成(空白、预分配的模板，如在 DETR)，并与位置编码(PE)连接。还有一个上下文概要**，使用位置编码平铺显示。该图没有显示如何生成上下文摘要并与位置编码一起使用的细节，但我认为有一个全局池，它折叠透视空间中的所有空间信息，以及一个平铺操作，它将这个 1x1 张量平铺在预定义的 BEV 网格上。**

使用交叉注意力转换器的图像到 BEV 转换的构建块和张量形状(图片由作者提供)

在上图中，我根据我的理解，列出了视图转换模块中更详细的块(圆圈)和相应的张量及其形状(正方形)。BEV 空间中的张量颜色编码为蓝色，核心交叉注意模块颜色编码为红色。希望这能帮助学术界感兴趣的读者在这个方向上更深入地挖掘。

关于变形金刚 vs MLP 的最后一句话

**

(将图像提升到 BEV 空间)是数据相关的，很难对此组件进行固定的转换，因此为了解决这个问题，我们使用转换器来表示这个空间。—安德烈·卡帕西，2021 年特斯拉人工智能日

Andrej 还提到视图转换问题依赖于数据，他们选择了转换器。关于交叉注意在张量整形中的详细用法及其与 MLP 的区别，在我之前的博客中有详细介绍，有一些数学细节和具体图解。它还强调了为什么变压器的张量整形是数据依赖的，而 MLP 不是。

外卖食品

• 变形金刚在学术界和工业界越来越受欢迎，用于视图转换。
• 正如在我之前的博客中所讨论的，尽管《变形金刚》的数据依赖性使其更具表现力，但这也使其难以训练，MLP 的盈亏平衡点可能需要大量的数据、GPU 和工程努力。
• 在大规模生产的自动驾驶汽车中，在资源有限的嵌入式系统中部署变压器也可能是一个重大挑战。特别是，当前的神经网络加速器或 GPU 针对卷积神经网络(例如，3x3 卷积)进行了高度优化。

承认

我和一谷进行了几轮讨论，他目前正在澳门大学做博士研究。我们的讨论促使我重新审视单眼 BEV 感知领域的最新趋势。

参考

• 整洁:端到端自动驾驶的神经注意场，ICCV 2021

• PYVA :用心投射你的视角:通过交叉视角变换的单目道路场景布局估计，CVPR 2021

• 特斯拉人工智能日于 2021 年 8 月 20 日在 Youtube 上直播

• CaDDN :用于单目 3D 物体检测的分类深度分布网络，CVPR 2021 口述

• :从周围单目摄像机鸟瞰未来实例预测，ICCV 2021

• BEV-Seg :利用几何和语义点云进行鸟瞰语义分割，CVPR 2020 研讨会

• 高清地图网:在线高清地图构建与评估框架，CVPR 2021 研讨会

• DETR :用变形金刚进行端到端的物体检测，ECCV 2020

• 注意力是你所需要的全部，NeurIPS 2017

• 联合学习对齐和翻译的神经机器翻译，ICLR 2015

• ViT :一张图像抵得上 16x16 字:大规模图像识别的变形金刚，ICLR 2021

• Swin 变换器:使用移位窗口的分级视觉变换器，Arxiv 2021/03

• CoordConv: 卷积神经网络的一个耐人寻味的失败和 CoordConv 解决方案，NeurIPS 2018

• STSU :车载图像结构化鸟瞰交通场景理解，ICCV 2021

• DETR3D :通过 3D 到 2D 查询从多视图图像中检测 3D 对象，CoRL 2021

• 将图像翻译成地图 ，Arxiv 2021/10**

Python 中一元和多元函数的蒙特卡罗积分

原文：https://towardsdatascience.com/monte-carlo-integration-in-python-over-univariate-and-multivariate-functions-12615dd252fa?source=collection_archive---------9-----------------------

实践教程

如何用蒙特卡罗方法近似积分复变函数

由杰斯温·托马斯在 Unsplash 上拍摄的照片

蒙特卡罗积分是一种基本的蒙特卡罗方法，用于数值估计函数 f(x) 的积分。我们将在这里讨论这个理论以及 Python 中的例子。

理论

假设我们要求解域 D 上 f(x) 的积分。

在单变量函数(即具有一个变量)的情况下，域只是一维的，积分是从 a 到 b 。

我们可以重新排列一些项，将上面的等式表示为:

换句话说，积分等价于求 g(x) 的期望值，这里我们已经定义了 g(x)=f(x)/p(x) 在一个定义域上。我们可以通过从域中采样xN 次来近似这一点，这意味着，

如果我们从均匀分布中取样，假设函数是一元的，这意味着抽取任何给定的 x 的概率就是 p(x)=1/(b-a) 。如果我们将其代入上述近似表达式，我们会看到，

这实际上是在区间 a 到 b 上计算 f(x) 的平均值，并乘以区间的长度。换句话说，我们正在寻找一个矩形的面积，宽度=区间宽度，高度=预期值 f(x) 。

这也适用于任何尺寸。在一元函数的情况下，定义域只是一条线(即 b-a )。对于二元函数，定义域就是面积。一般来说，

这意味着我们可以通过将区域体积乘以区域上函数的期望值来近似积分。

示例|单变量

例如，在 Python 中，我们可以执行以下操作来近似从-2 到 2 的 f(x)=x 的积分。

我们得到以下结果，

其中蒙特卡罗近似非常接近解析解。从视觉上看， f(x)=x 从-2 到 2 的积分如下图蓝色所示。近似值是用红色突出显示的矩形。

用红色显示 f(x)的近似值。作者图片

示例|多元

我们也可以对多元函数进行积分。程序和以前一样。然而，我们现在需要在一个更高维的域上采样，而不是在一条线上采样(从 a 到 b )。为简单起见，我们将说明一个多元函数在一个域上的积分，对于每个变量有相同的 a 和 b 。这意味着在具有两个变量(x1 和 x2)的函数中，定义域是正方形的；对于三个变量的函数，立方体形状。

结果呢

示例|其他域上的多元积分

在其上执行积分的域可能更复杂，并且难以从中采样和计算其体积。例如，我们可以在圆形区域而不是方形区域上对二元函数进行积分。尽管如此，想法是相同的——对于均匀采样，我们希望在整个区域内进行采样，并通过区域体积和区域内函数期望值的乘积来近似积分。

让我们使用相同的二元函数 f(x)=10-x1 -x2 并在单位圆上积分。精确地在单位圆上均匀采样比只在正方形区域(覆盖单位圆)上采样更难。由此，我们可以 1)将域的面积计算为采样正方形的面积与域内采样点的比例的乘积，2)将期望值计算为域内采样点的平均值 f(x) 。下面是采样的可视化(单位圆内的采样点以绿色显示)，

采样时单位圆内的数据点以绿色显示(区域)。作者图片

在 Python 中，这看起来像，

结果是，

作为最后一个例子，我们也可以对多元概率分布进行积分。让我们在单位圆上积分下面的多元正态分布，

在哪里

我们用 Python 定义这些，并执行蒙特卡罗积分，

作为确认，我们使用能够在椭球(包括圆)上积分多元正态分布的pmvnEll函数。

library(shotGroups)
pmvnEll(r=1, sigma=rbind(c(1,0.8,0.5), c(0.8,1,0.8), c(0.5,0.8,1)),
        mu=c(0,0.5,1), e=diag(3), x0=c(0,0,0))

由于结果彼此非常匹配，

附加注释

显然，提供的例子很简单，有些例子有针对特定情况的分析解决方案和/或 Python/R 包。但是它们有助于理解蒙特卡罗积分背后的机制。显然，所描述的蒙特卡罗方法很容易推广到没有封闭形式解的更复杂的函数。此外，还有许多更优化的抽样方法(如分层抽样、重要性抽样等)，如果有兴趣，我们鼓励读者深入阅读这些主题。

额外资源

https://www . scratchpapixel . com/lessons/mathematics-physics-for-computer-graphics/Monte-Carlo-methods-in-practice/Monte-Carlo-integration

https://towards data science . com/Monte-Carlo-integration-in-python-a71a 209d 277 e

原载于 2021 年 1 月 13 日https://boyangzhao . github . io。

蒙特卡洛马尔可夫链(MCMC)，解释说

原文：https://towardsdatascience.com/monte-carlo-markov-chain-mcmc-explained-94e3a6c8de11?source=collection_archive---------0-----------------------

理解使用随机性估计复杂实体背后的魔力

来源:图片由来自 Pixabay 的埃里克·斯坦拍摄

MCMC 是贝叶斯统计中最重要和最流行的概念之一，尤其是在进行推理时。

从更大的角度来看，有时在高维空间中估计推理在计算上可能变得不可行，在这种情况下，我们求助于对其进行近似——或者通过使用 采样方法 (其中之一是 MCMC )或者用 参数化分布 ( 变分推理)对其进行近似。

在本帖中，我们将通过举例来剖析和理解 MCMC 的组件来讨论它。在这篇文章的后面，我们将会看到一个融合了这个概念的算法， Metropolis-Hasting 算法。

事不宜迟，让我们开始吧！

注:标有“附加内容”的小节可以跳过，不会影响对概念的总体理解。

采样

抽样是一种通过将人口的一个子集纳入研究来近似估计整个人口的某些特征的方法。

采样有各种各样的用例—

• 它可以用来近似一个棘手的总和或积分。
• 它可以用于在估计易处理但昂贵的和或积分时提供显著的加速。
• 在某些情况下，如密度估计，它可以简单地用于近似概率分布，然后估算缺失数据。

少数抽样技术— 祖先抽样、逆变换抽样、拒绝抽样、重要性抽样、蒙特卡罗抽样、MCMC 抽样。

在这篇文章中，我们只关注 MCMC 方法，其他方法将在另一篇文章中讨论。

介绍

MCMC 方法是使用马尔可夫链来执行蒙特卡罗估计的一系列算法。

这个名字给了我们一个提示，那就是它由两部分组成——
蒙特卡洛和马尔可夫链。让我们分别地和以它们的组合形式来理解它们。

蒙特卡罗抽样

(直觉上)

蒙特卡洛法得名于摩纳哥的蒙特卡洛赌场。

这是一种从概率分布中取样并使用这些样本来逼近所需数量的技术。换句话说，它使用随机性来估计某个确定性的感兴趣的量。

示例:如果要求我们计算下图中给定曲线的曲线下面积，可能需要对复杂的解析公式进行积分。
然而，使用蒙特卡罗方法，我们将在矩形中随机生成红点
(点越多越准确)，并计算落在曲线下的点与落在整个矩形中的点的比率——该比率将为我们提供面积，给定矩形的面积。

(图片由作者提供)-蒙特卡洛法估算曲线下的面积

基本上，如果计算某个量具有复杂的分析结构，我们可以简单地执行模拟来生成大量样本，并使用它们来近似该量。这些工作假设渐近地遵循中心极限定理。

它在风险分析、可靠性分析等方面有许多其他用例。

(数学上)

假设我们有期望值要估计，这可能是一个非常复杂的积分，甚至难以估计——使用蒙特卡罗方法，我们通过对样本求平均值来近似这些量。

要计算的原始期望值

通过刺激 f(x)的大样本产生的近似期望

计算大量样本的平均值可以减少标准误差，并为我们提供一个相当准确的近似值。

这种方法有一个局限性，因为它假设很容易从一个概率分布中抽样，然而这样做并不总是可能的。有时，我们甚至不能从分布中取样。在这种情况下，我们利用马尔可夫链从一个棘手的概率分布中有效地进行采样。”

马尔可夫链

在进入 马氏链 之前，让我们先看一下定义它的有用性质——

马尔可夫性质:

椭圆形中的实体是状态

从上面的图像中，考虑一个由 4 个状态组成的系统—

下雨或洗车导致地面潮湿接着*【地面潮湿】导致【打滑】。*

马尔可夫性质只是做了一个假设——从一个状态跳到下一个状态的概率只取决于当前状态而不取决于导致这个当前状态的先前状态的序列。

如果我们要计算某人滑倒的概率，知道地面是否潮湿就提供了足够的证据来估计它。我们不需要知道导致它的状态(“下雨”或“洗车”)。

数学上来说:

截断分布的马尔可夫性质

从数学方程中可以明显看出，马尔可夫性质假设可能会节省我们大量的计算。

事后看来，如果一个过程展现出 马尔可夫性质 ，那么它就被称为
马尔可夫链。

现在我们已经看到了马尔可夫链，让我们来讨论使它如此令人满意的性质— 平稳分布。

平稳分布:

假设，我们有一个很少状态的过程，并且我们有一个固定的状态间转移概率 (Q) 。
我们从时间步 i 的所有状态上的一些随机概率分布( Sᵢ )
开始，为了估计下一个时间步 i+1 的所有状态上的概率分布，我们将其乘以转移概率 Q 。

如果我们继续这样做，过一会儿 S 在与矩阵 Q 相乘时停止变化，这就是我们说它已经达到了 平稳分布。

已达到稳定分布

让我们看一个例子——

在这个例子中，我们有 3 个州(X₁、X₂、X₃)

状态之间的转移概率( T

如果我们处于状态 S₂ ，留在 S₂ 的概率是 0.1，
转换到状态 S₁ 的概率是 0，转换到状态 S₃ 的概率是 0.9(从矩阵的第二行可以明显看出)。

让我们从向量 Sᵢ 的某个随机值开始(向量显示在任何特定时间步处于每个状态的概率)，我们可以看到向量如何总计为 1。

应用后 Sᵢ₊₁ = Sᵢ*Q

如果我们继续按时间步长移动，最终我们会到达静止状态，

稳定分布

现在最需要知道的是，这个平稳分布不依赖于初始状态，你可以尝试不同的初始状态 Sᵢ 。

import numpy as npQ = np.matrix([[0,1,0],[0,0.1,0.9],[0.6,0.4,0]])
S_initial = np.matrix([[0.3, 0.4 , 0.3]])
epsilon = 1while epsilon > 10e-8:
    S_next = np.dot(S_initial, Q)
    epsilon = np.sqrt(np.sum(np.square(S_next - S_initial)))
    S_initial = S_nextprint(S_initial)

平稳分布表示在任何给定时间处于任何状态的概率。

直观地说马尔可夫链可以被认为是在链上行走，给定特定步骤的状态，我们可以通过查看下一步的“状态概率分布”来决定下一个状态。

好了，现在我们已经看到了马氏链和蒙特卡洛，让我们把我们的重点放在这些美丽的组合形式，即 mcmc。

临时演员—

任何好奇并想了解为什么马尔可夫链收敛于平稳分布的人都可以参考下图——

来源:@book{Goodfellow-et-al-2016，title=，作者= ，出版商=，注= { \ URL { http://www . Deep Learning book . org } }，年份={2016}}

马尔可夫链蒙特卡罗(MCMC)

MCMC 可以用来从任何概率分布中抽样。大多数情况下，我们用它来从难以处理的后验分布中进行抽样，以达到推断的目的。

使用 Bayes 估计后验概率有时会很困难，在大多数情况下，我们可以找到可能性 x 先验的函数形式。然而，计算边缘化概率 P(B)在计算上可能是昂贵的，尤其是当它是连续分布时。

(图片由作者提供)具有离散边际概率的贝叶斯定理

这里的技巧是完全避免计算归一化常数。

该算法的总体思路是从一些随机概率分布开始，逐渐向期望的概率分布移动。

听起来很简单，但是我们怎么做呢？

启动一个状态随机概率分布的马尔可夫链，在链中逐渐向稳定分布收敛，应用一些条件(详细资产负债表)确保该稳定分布类似于期望的概率分布。

因此，在达到平稳分布时，我们已经逼近后验概率分布。

详细的资产负债表状况

概率 p(A)表示在 A 的概率，概率 T(A → B)表示从 A 移动到 B 的概率。

概率 p(B)代表在 B 的概率，概率 T(B → A)代表从 B 移动到 A 的概率。

每条边代表从 A 到 B 或者 B 到 A 的概率流
如果条件满足，那么它保证稳态近似代表后验分布。

尽管 MCMC 本身很复杂，但它们提供了很大的灵活性。它为我们提供了高效的高维采样。它可以用来解决大状态空间的问题。

限制 — MCMC 在逼近多模态概率分布时表现不佳。

临时演员—

存在用于训练或评估具有难以处理的归一化常数(也称为配分函数)的模型的技术。他们很少在算法中使用 MCMC 进行采样。

例如— 对比散度(CD) 对于训练像受限玻尔兹曼机这样的非结构化图形模型很有用。

Metropolis —加速算法

假设我们从分布 p(x) = f(x) / Z 中采样，其中 Z 是难以处理的归一化常数。

我们的目标是以这样一种方式从 p(x)中抽样，即只利用分子而避免估计分母。

(求婚概率)

我们先来看一下提议概率(g) 。
给定一个样本，它建议我们用马尔可夫链中的下一个潜在样本。
(如何决定是接受还是拒绝潜在样本，我们将在下一节中看到)。

(图片由作者拍摄)—提案分发

假设 g(X₂ | X₁) =正态(x₁σ)
***(***它可能是任何分布，为简单起见我们选择了正态分布 )

保持 X₁均值，我们做一个正态分布。然后我们从这个分布中抽取 X₂
作为样本。

我们重复同样的步骤对 X₃进行采样，保持 X₂为平均值。

(主算法)

让我们从详细的资产负债表条件开始这个算法。

详细的资产负债表

从 X₁过渡到 X₂的可能性可以被视为一个两步走的过程，考虑到我们在 X₁州—

第一步是用一些
的提议概率 g 做出 X₂的提议(上一节讨论过)。

第二步是接受新状态 X₂用某种
接受概率

将转移概率代入方程…

用 f(x)/Z 代替 p(x)，两边的 Z 被抵消，我们得到…

重新构建等式会导致

替代速记符号

最后，我们得到接受概率 A****

接受概率

总结一下—

• 我们从一个随机状态开始。
• 基于提议概率(g ),我们随机选择一个新的状态。
• 计算提议的新状态的接受概率(A)。
• 掷硬币，正面着地的概率等于接受概率，如果硬币正面着地，接受样品，否则拒绝。
• 重复这个过程一段时间。

我们保持长时间的采样，并丢弃最初的几个样本，因为链还没有达到其静止状态(这个时期被称为
预烧期)。

(图片由作者拍摄)

限制:

• 在近似多模态分布时，由于链被卡住，得到有偏差的样本，因此对所需量的估计不太准确。
• 当样本空间是高维时，Metropolis-Hasting 变得非常慢。(另一个惊人的 MCMC 方法哈密顿蒙特卡罗克服了这些缺点，将在另一篇文章中讨论)。

结论:

对 MCMC 方法的讨论到此结束。更多关于类似讨论的帖子将被关注。

这绝不是一个容易理解的概念，因为它是概念的融合，而这些概念隐藏在数学背后。

如果你一路走来，那么恭喜你！！万事如意！！

参考:

1. 深度学习作者伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库尔维尔。
2. ritvikmath 创作的《大都会-加速》

蒙特卡罗方法解释

原文：https://towardsdatascience.com/monte-carlo-method-explained-8635edf2cf58?source=collection_archive---------8-----------------------

理解蒙特卡罗方法以及如何用 Python 实现它

https://unsplash.com/photos/tV3Hh38eoSg

在本帖中，我将向你介绍、解释和实施蒙特卡罗方法。这种模拟方法是我最喜欢的方法之一，因为它简单，但它是一种解决复杂问题的精炼方法。它是由波兰数学家 Stanislaw Ulam 在 20 世纪 40 年代发明的。它是以摩纳哥的一个赌博城镇命名的，因为随机原则模仿了轮盘赌游戏。蒙特卡洛模拟是一个非常常见的概念，用于量化各种领域的风险，如股票价格、销售预测、预测建模等。

蒙特卡罗方法是如何工作的？

蒙特卡罗模拟是一种模拟统计系统的方法。该方法使用定义系统中的随机性来发展和近似量，而不需要解析地求解该系统。这种方法的主要概念是，运动系统中的一个点最终将以均匀和随机的方式访问该系统运动的空间的所有部分。这就是所谓的遍历性。

图片由作者提供

该模型通过使用问题领域中的一系列值而不是特定的输入来进行预测。这种方法利用概率分布(正态、高斯、均匀等。)对于任何具有不确定性的变量。根据指定的试验次数，在一个域中使用随机值的过程会重复多次。一般来说，试验次数越多，结果收敛到某个值的可能性就越大。通常用于长期预测建模的时间序列分析。一旦所有的模拟都完成了，你就会有一系列可能的结果，以及每个结果发生的相关概率。

例子

在解释这种方法的许多方式中，解释蒙特卡罗模拟最常见的例子是所谓的布丰针实验，以近似 π 的值。实验如下，我们随机将 N 根尺寸为 L 的针落在一张纸上，这张纸被长度为 2L 的平行条分割。

布丰的针实验——作者提供

随机落下这些针后，确定接触纸张分割线的针数和落下的针总数(N)。

**π ≈ N / number of needles crossed line****Note :** 1) A large amount of needles must be dropped to have a close approximation of π.
2) This formulation strictly works because we initially stated that the distance between the lines was 2 * L (where L is the length of the needle)

关于这背后的数学原理，你可以在这里找到，你也可以在这里免费运行这个实验。

谨慎一点，这个例子只是为了解释蒙特卡罗方法。蒙特卡罗方法可以用于许多不同的情况，但并不总是建议。尽管这种方法可行，但实际上这是蒙特卡罗方法的一个糟糕的用例。还有许多其他方法可以近似π的值，其中大多数方法的计算效率要高得多。

您应该使用这种方法的情况是，当您需要估计结果存在高度不确定性时。由于股票市场的随机性和不确定性，这种方法通常用于金融行业的股票预测。由于这些限制，像这样的模型是受欢迎的，并且通常比基于普通回归的方法执行得更好。在不确定的情况下，这种方法非常有效。

算法

1. 识别自变量和因变量，并定义它们可能的输入域。
2. 确定概率分布以在该域上随机生成输入
3. 根据随机生成的输入计算问题的输出
4. 将实验重复 N 次，然后汇总结果

在进行这个实验时，计算方差和标准差是常见的做法。一般来说，方差越小越好

优点和缺点

我将概述使用这种方法的一些最显著的优点和缺点。

优势

• 估计不确定性的强有力方法
• 给定正确的边界，该模型可以测量问题的参数空间
• 简单而直观，这种方法很容易理解

劣势

• 计算效率低——当有大量变量受限于不同的约束时，使用这种方法需要大量的时间和计算来逼近一个解
• 如果不良参数和约束输入到模型中，那么不良结果将作为输出给出

Python 实现

摘要

总之，本文概述了蒙特卡罗模拟是一种模拟统计系统的方法。他们利用一个确定的系统中的随机性来发展和近似数量，而不需要解析地解决它。当存在高度不确定性时，最好使用这种方法。虽然它的计算效率很低，但理解起来非常直观，可以调查问题的约束条件的大样本，并可以有效地近似不确定性。由于这些原因，它通常用于金融行业。

资源

• 【https://en.wikipedia.org/wiki/Ergodic_hypothesis
• https://mathworld.wolfram.com/BuffonsNeedleProblem.html
• https://James Howard . us/2019/09/07/Monte-Carlo-simulation-优缺点/

如果你喜欢这本书，那么看看我的其他作品。

https://medium.com/nerd-for-tech/markov-chain-explained-210581d7a4a9 https://medium.com/nerd-for-tech/k-nearest-neighbours-explained-7c49853633b6

Python 中的蒙特卡罗定价

原文：https://towardsdatascience.com/monte-carlo-pricing-in-python-eafc29e3b6c9?source=collection_archive---------5-----------------------

证券定价概念与代码指南

来自派克斯的卡斯特利什摄影

介绍

本科量化金融课程的大部分时间花在不同证券的定价上。最初，重点在于货币的时间价值，以及年金和永久年金的分析。之后，重点转移到学习、分析和定价股票衍生品，包括远期、期货、期权和互换。一旦为衍生品定价奠定了基础，剩下的课程就是研究并成为市场部门或证券类型的专家。在这篇文章中，我的目标是分解决定市场上所有这些证券的公平价格的潜在主题。事不宜迟，让我们开始吧…

金钱的时间价值

随着时间的推移，金钱的价值会有所不同。那具体是什么意思？如果有人让你选择今天收到 100 美元，或者一年后收到 100 美元，你会选择哪一个？自然，大多数人更希望尽快(今天)收到 100 美元。直观上，这可以解释为理解货币的时间价值。随着现金流在未来越来越远，它的价值就越低。同样的概念可以延伸到比较不同时间点的现金流值。凭直觉，我们更愿意从今天起一年后收到 100 美元，而不是两年后。从数学上来说，货币价值暂时差异的罪魁祸首是无风险利率。越早收到钱，就能越早获得利息。这就是在不同时间比较不同金额的方法——即找到现金流的现值,然后进行比较。考虑以下互斥的选择:

假设年无风险利率为 1%。

选项 A:

• 今天收到 100 美元

选项 B:

• 一年后收到 102 美元

你应该选择哪个？

为了确定收到哪一个现金流，我们可以以无风险利率贴现 102 美元，以找到 102 美元在今天的中的价值。

今天收到 100 美元的现值

• 100/(1.01)⁰ = $100

从今天起一年后收到 102 美元的现值

• 102/(1.01)¹ = $101

以今天的美元计算，选择 A 值100 美元而选择 B 值101 美元。由于选项 B 具有更高的现值，这意味着选项 B 今天比选项 A 更值钱。这似乎是一个简单的概念，但特别是在评估更复杂的证券时，记住这种时间价值差异变得至关重要。

证券定价

一般来说，任何证券的市场价格应该代表该证券产生的所有未来现金流的现值。考虑以下投资工具:

安全 A

• 在第 1 年末支付 100 美元
• 在第二年末支付 100 美元
• 在第 3 年末支付 100 美元

你愿意为安全支付多少钱？好了，现在我们知道钱在不同的时间点有不同的价值，我们可以用一个合适的无风险利率来贴现每个现金流在当前时间点的价值，以确定证券的价格。假设年无风险收益率为 1%，我们可以将每笔付款贴现到现在。

以今天的美元计算的第一年付款

• 100/(1.01) = 99.01

以今天的美元计算的第二年付款

• 100/(1.01)² = 98.03

以今天的美元计算的第三年付款

• 100/(1.01)³ = 97.06

未来现金流量的现值之和

• 97.06 美元+98.03 美元+99.01 美元=294.10 美元

所以今天证券 A 的合适值是 $294.10 。我们可以推广这一概念，找到任何证券的公允价值，不管它们的回报结构有多独特或奇特。在本文的后面，我们将分析具有独特收益结构的衍生品。然而，使用这种未来现金流现值的概念，我们可以找到今天所述证券的适当价格(更具体地说，今天未来现金流的预期现值)。为了做到这一点，我们需要一种方法来模拟基础资产的随机运动。

几何布朗运动

在我们能够对其价值取决于基础权益的衍生证券的价格建模之前，我们需要对基础权益建模。几何布朗运动是一种随机过程，可用于生成标的股票可能遵循的样本路径。换句话说，我们可以用几何布朗运动来模拟股票价格。

几何布朗运动

• Yt —时间 t 的股价
• dYt —股票价格随时间的变化 t
• μ —漂移项
• σ —波动项
• dt —随时间变化
• 小波变换 —布朗运动

几何布朗运动似乎有许多组成部分，但本质上有三个组成部分:回报(dYt/Yt)、预期回报(μdt)和对回报的冲击(σdWt)。我们可以使用下面的代码非常容易地在 Python 中模拟几何布朗运动。

当使用几何布朗运动对股票建模时，我们只需要提供几个参数:股票在时间段 T 的初始股价、漂移(预期收益)、股票在时间段 T 的波动率、时间步长 dt 的长度以及我们产生到 T 的总时间。在上面的代码中，我们使用了以下参数集…

• 初始价格 — 100
• 漂移 — 8%(预期收益)
• 波动率 — 10%(预期震荡回归)
• 时间步长(dt) — 1/365(每日)
• 总时间(T) — 1(一年)

如果使用几何布朗运动来生成真实股票的样本路径，有几种方法可以找到漂移和波动。一般来说，我使用我正在生成的时间段的平均历史回报，波动率我使用隐含波动率(参见什么是隐含波动率？)为一个 at 货币期权。运行上面的代码后，我们最终生成了 100 个样本路径，可以使用 matplotlib 绘制这些路径。

几何布朗运动生成的样本路径

既然我们有了生成标的资产样本路径的方法，我们就可以讨论衍生品定价了。

布莱克-斯科尔斯定价法

• 没有交易成本
• 连续交易
• 对数正态分布股票收益

在实践中，当交易成本存在时，这些假设立即被违反，交易只能离散地进行，并且股票回报根据经验显示它们不是对数正态分布的。我的研究重点是通过数学修改将布莱克-斯科尔斯方程中的交易成本和离散交易等一般市场条件考虑在内(如果感兴趣，请参见一般市场条件下的期权定价和复制)。然而，布莱克-斯科尔斯价格提供了一个基线，我们可以对照蒙特卡洛价格进行检查。布莱克-斯科尔斯方程如下…

• St—t 时刻的股价
• X —期权的执行价格
• σ —波动项
• φ—累积正态分布函数
• B(t，T) —连续贴现因子
• T —到期时间
• t —当前时间点

如果上面的等式不是很清楚，不要担心 Python 中的实现更容易理解(如果你希望看到更多没有完整推导的数学解释，请参见风险中性投资组合管理)。

12.368267463784072 # Price of the European call option by BS Model

蒙特卡洛定价

我们现在有了开始蒙特卡洛定价所需的一切。回想一下今天证券的价值应该如何代表该证券产生的所有未来现金流。在金融衍生品的例子中，我们不知道它们现金流的未来价值。然而，我们知道可能的结果。知道了可能的结果，我们就可以找到所有未来现金流的预期现值。请允许我用一个例子来详细说明…

在欧式看涨期权的情况下，它要么在货币内(行使)到期，要么在货币外(什么也不做)到期。让我们用 Python 建立一个这个收益结构的模型。

现在，我们可以在代码中使用这个收益模型来生成潜在的股票路径，以找到每个样本路径末端的期权价值。然后我们就可以把价值折现到现在(记住钱的时间价值！)，并对所有值进行平均，以找到期权产生的未来现金流的预期现值。

16.31698913180365 # Monte Carlo Price of the European Call Option

考虑到我们生成的路径(和任意参数集)的样本大小，我们非常接近 Black-Scholes 价格！值得注意的是，这两种价格都不正确，它们只是告诉我们不同的东西。理解每个价格的是如何产生的将有助于解释。

同样的过程也可以用来给任何收益不确定的证券定价。让我们来看一个更奇特的选择…

向上和向外屏障选项

• 类似于欧式看涨期权的执行价格和收益
• 不能再行使期权的障碍水平

对于向上和向外障碍期权，如果障碍水平被触发，期权是否到期并不重要——它变得不可执行。我们可以再次用 Python 很容易地模拟这个收益结构。

这种障碍期权与欧式期权(在实施中)的唯一区别是，障碍期权要求观察每个价格点，以确定障碍是否被突破。

9.08694137422691 # Monte Carlo Price of Up and Out Barrier Option

这是向上和向外障碍期权的蒙特卡洛价格。从逻辑上讲，这是有意义的，因为对欧式期权的额外约束(障碍水平)不会增加收益，或增加收益潜力(实际上阻碍了它)。因此，正如蒙特卡洛价格所示，我们应该为这一选择支付更少的费用。这种定价方法的美妙之处在于能够为客户开发出完全符合他们需求的奇特产品。虽然这可能是一个粗略的例子，如果客户希望通过购买看涨期权对冲他们在股票头寸中的风险，但他们不相信基础资产会超过某个点，我们可以根据他们的情况为上涨和下跌障碍期权定价，并降低他们的对冲成本。

来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

蒙特卡罗模拟和 Python 变种

原文：https://towardsdatascience.com/monte-carlo-simulation-and-variants-with-python-43e3e7c59e1f?source=collection_archive---------1-----------------------

蒙特卡洛模拟指南，必须了解 Python 实现的统计抽样技术

图片来源:帕维尔·丹尼柳克

蒙特卡洛模拟基于重复随机抽样。蒙特卡洛的基本概念是使用随机性来解决原则上可能是确定性的问题。蒙特卡罗模拟是在不知道真实的潜在人口分布的情况下对人口进行推断的最流行的技术之一。这种取样技术变得很方便，尤其是当人们没有足够的时间从原始人群中重复取样时。蒙特卡罗模拟的应用范围从解决理论物理问题到预测金融投资趋势。

蒙特卡罗有 3 个主要用途:估计参数或统计测量，检查估计的性质，近似积分

这篇文章是关于蒙特卡罗程序的 3 种用法和 3 种蒙特卡罗变体，统计抽样技术，它们可以用来产生独立的随机样本。本文将涵盖以下主题:

**- Introduction to Monte Carlo Simulation
- MC Parameter Estimation
- MC Examining the Estimate Properties
- MC Integrals Approximation
- Importance Sampling
- Rejection Sampling
- Inverse Transform Sampling**

蒙特卡罗模拟游戏攻略

蒙特卡洛模拟最初是为了解决 布丰针问题 而发明的，其中 *π，pi，*可以通过将针落在由平行等距条带组成的地板上来估算。蒙特卡洛模拟的现代版本是由斯坦尼斯拉夫·乌拉姆发明的，他在核武器项目工作期间发明了现代版本的 马尔可夫链蒙特卡洛 技术，而约翰·冯·诺依曼编写了一台特殊的计算机来执行蒙特卡洛计算。冯·诺依曼还以他的著名方法而闻名，他通过扔两次不公平的硬币，忽略不同的{正面，反面}和{反面，正面}选项，使不公平的骰子变得公平。

乌兰提出的基于一系列真正随机的 T2 数的方法非常慢，但是冯·诺依曼开发了一种计算 T4 伪随机数的方法，比乌兰的方法快得多。这种方法的名字来自摩纳哥的蒙特卡洛赌场，乌兰的叔叔会从亲戚那里借钱去赌博。

冯·诺依曼也因他著名的方法而闻名，他通过投掷两次不公平的硬币，忽略不同的 HT 和 TH 选项，使不公平的骰子变得公平。

蒙特卡罗背后的想法是，随着我们使用更多的样本，我们的答案应该越来越准确。

蒙特卡罗估计

蒙特卡罗使用大数定律(LLN)通过模拟值得出总体参数的估计值。LLN 陈述:假设 X1，X2，。。。，Xn 都是具有相同基础分布的独立随机变量，也称为独立同分布或 i.i.d .，其中所有 X 都具有相同的均值 μ 和标准差 σ 。随着样本量的增加，所有 X 的平均值等于均值μ的概率等于 1。LLN 可以总结如下:

因此，蒙特卡罗估计背后的思想是，当我们多次获得一个参数的估计值时，假设 M = 10000 次，那么这些估计值的平均值将形成该参数的蒙特卡罗无偏估计值。

蒙特卡罗估计:Python 实现

假设我们想要估计两个变量(一对自变量和因变量)之间的因果关系，并且我们对截距α和斜率β的可能值有所了解。

我们能做的是从正态分布中随机抽样，以生成误差项、因变量和自变量的值。然后我们就可以估计β的系数，beta_hat，重复这个过程 M = 10000 次。然后通过 LLN，这 10000 个 beta _ hats 的样本均值将是真实 beta 的无偏估计。那就是:

用蒙特卡罗方法检验估计性质

蒙特卡罗模拟是检验估计量性质的有力工具。当检查线性回归估计的属性时，这可能不是很有用，因为大多数统计软件包已经提供了检查估计的方法。然而，在使用 Monet Carlo 估计的其他情况下，估计可能是找出估计量是否无偏、有效、和一致的唯一方法。

估计值是无偏的吗？

估计量的偏差是其期望值和被估计参数的真实值之间的差值，可以表示如下:

当我们声明估计量是无偏的时，我们的意思是偏差等于零，这意味着估计量的期望值等于真实参数值，即:

为了检查估计量是否无偏，我们可以使用上一步中获得的 beta_hats 的蒙特卡罗样本，并绘制这个采样分布。那么，如果这个抽样分布以真实参数值为中心，那么估计量就是无偏的。

从图中我们可以看到，我们使用蒙特卡罗模拟 10000 次迭代得到的β估计的抽样分布是以真实参数β为中心的。所以，beta_hat 的蒙特卡罗估计是无偏的。

图片来源:作者

估算是否一致有效？

如果随着样本量变得非常大，估计量收敛到真实参数，那么这个估计量被称为一致，即:

为了检查估计量是否一致，我们可以使用我们在上一步中获得的 beta_hats 的蒙特卡罗样本，并针对少量和大量的 M 个模拟绘制其采样分布。如果我们看到，随着样本量的增加(蒙特卡罗模拟交互的次数)，抽样分布变得更窄，并且更集中于真实参数值，那么估计值很可能是一致的。

一个参数可以有多个估值器，但是方差最小的那个被称为有效 **。**为了检查估计量是否有效，我们可以使用我们在上一步中获得的 beta_hats 的蒙特卡罗样本，并绘制少量和大量 M 次模拟的抽样分布。如果我们看到抽样分布的宽度随着样本量的增加而变小，那么估计可能是有效的。

假设我们运行 M = 1000 的蒙特卡罗模拟，并获得β的蒙特卡罗估计(左直方图)。此外，我们用 M = 10000 重新运行这个模拟(右直方图)。我们看到，随着 M 从 1000 增加到 10000，beta_hats 的采样分布更加集中在真实参数值周围。所以，beta_hat 的蒙特卡罗估计是一致的。我们看到，随着 M 从 1000 增加到 10000，beta_hat 的采样分布宽度减小。所以，beta_hat 的蒙特卡罗估计是有效的。

图片来源:作者

用蒙特卡罗方法近似积分

对于已知函数，如正态分布函数，计算积分可能很简单，不需要使用 MC。然而，对于更复杂的函数，计算积分可能非常困难，在这些情况下，使用 MC 可能是计算该积分的唯一方法。

用于逼近积分的 MC 是基于 LLN，其背后的思想是，如果我们可以从给定的分布 P(x)生成随机样本 xi，那么我们可以通过求和而不是积分来估计该分布下函数的期望值。换句话说，我们可以通过确定一个积分的被积函数 h 的平均值 (x) 来求出它的值。正如我们之前看到的，MC 就是基于这个原则。

MC 积分逼近:Python 实现

假设我们想得到概率 Pr[X ≥ 3]，其中 X ~范数(10，2)，可以用下面的积分表示，其中 f(x)是正态分布的 pdf 函数。

然后使用蒙特卡罗模拟，通过计算这个量 10000 次并取这些值的平均值，就可以得到这个积分。

重要抽样

重要抽样是使蒙特卡罗模拟收敛得更快的方法之一。此外，与传统的蒙特卡罗方法相比，重要性抽样的方差也更低。它用于根据目标分布 g(x)估计某个 h(x)函数的期望值，同时可以访问某个 f(x)函数。想法是使用一些提议的分布 f(x)从样本中抽取样本，并使用重要性权重 w = g(x)/f(x)，以减轻高估或低估目标分布 g(x)的影响。

重要性采样:Python 实现

假设我们想估计服从指数分布的随机变量 X 的期望值。因此，我们的目标分布是指数分布，g(x) = Exp(1)，h(x) = exp(-X + cos(X))。

对于重要性抽样，我们需要选择一个尽可能接近目标分布的方案分布，因此我们选择 f(x) = Exp(2)。假设指数函数的 pdf 是 exp(-λ* x)，那么我们有:

其中 f(x)是我们可以从中采样的建议分布，h(x)是需要估计期望值的函数，g(x)是我们不能从中采样的目标分布，w(x)是重要性权重。那么 h(x)的期望值可以表示如下:

然后利用 LLN，我们可以把这种期望表达如下:

下图显示了 h(x)、目标分布 g(x)和提案分布 f(x)图。正如我们所看到的，提案分布与目标分布非常接近。f(x)用于随机抽取 1000 个观察点，每次计算表达式 g(x)/f(x)*h(x)，即计算重要性权重并与 h(x)相乘。然后，取这些值的平均值，得到 1.52，这是我们要找的期望值。

图像来源:作者

拒绝采样

剔除采样通常用于从非正态目标分布生成独立样本。这种蒙特卡罗采样变体背后的思想是，如果我们想从目标非标准化分布 P(x)生成随机样本，那么我们可以使用一些提议分布 Q(x)】和一个归一化 常数 c，使得 cQ(x)是一些辅助分布 P×(X)的上界，其中 P(x)=(P×(X)/c 得出一个样本列表，从该列表中可接受的值将形成来自目标 P(X)分布的独立样本。

1: 选择一个接近目标分布 P(X)的建议函数 Q(X)

2: 选择归一化常数 c，使得 P×(x)≤cQ(x)

3: 选择辅助分布 P×(X)s . t . P(X)= P×(X)/c

4: 从 Q(X)生成随机样本 X

5: 从 Unif(0，cQ(x))生成随机样本 u

6: 重复步骤 1、2 M 次(如 10000 次)

7: 如果 u≤P×(x)，则接受 x，否则拒绝

图像来源:作者

剔除取样的重要要求:

• 要从中取样的方案分布 Q(x)(均匀或高斯)
• 归一化常数 c，使得 c*Q(x)
• 辅助分布 P*(x)
• 可以从提案分发中获取样本

拒绝采样:Python 实现

假设我们想从正态分布的混合中生成独立样本，我们希望其分布类似于 p×(x)= N(30，10) + N(80，20)。我们可以访问正态分布和均匀分布进行采样，以生成这些目标样本。我们可以使用建议函数 Q(x) = N(50，30)，归一化常数 c = max(P*(x)/Q(x))。

然后，我们按照前面描述的步骤生成样本，其中很大一部分样本被拒绝，而一些样本被接受。以下直方图显示了一组可接受的样本，这些样本是来自混合正态分布的独立样本，同时只能访问正态和均匀随机生成器。

图像来源:作者

剔除采样的效率非常低，因为它会剔除大量样本点，从而导致计算时间非常长。

逆变换采样

与剔除采样一样，逆变换采样是一种生成独立样本的方法，但与剔除采样不同，逆变换采样的效率是 100%。逆变换采样背后的思想是使用我们无法从中采样的目标群体分布的逆累积分布函数并使用我们可以容易地从中采样的随机生成器，从目标群体中生成独立的随机样本。

1: 来自 Unif(0，1)的样本值 u

2: 利用目标分布的逆 CDF 函数，得到值为 u 的逆 CDF 对应的 x 值

3: 重复步骤 1 和 2 M 次(如 10000 次)

4: 收集这些遵循期望分布的 x 值

对 ITS 的重要要求:

• 从 Unif(0，1)访问采样
• 了解目标分布 PDF/CDF
• 能够确定目标分布的逆 CDF

逆变换采样:Python 实现

假设我们希望从λ等于 1 的指数分布中生成独立样本，而我们只能从均匀分布中采样。因此，我们可以如下确定指数分布的逆 CDF:

然后，我们从 Unif(0，1)中随机采样，并使用这个值 u 来确定 x，使用目标分布的定义逆 CDF，即-log(1-u)。一旦这个过程重复 M = 10000 次，存储的样本就是来自目标分布的独立样本。下面的直方图显示了这些样本。

图片来源:作者

与拒绝采样不同，逆变换树是 100%有效的。

关于选择建议分布的说明

• 如果建议分布看起来非常像目标分布，蒙特卡罗变体的计算效率将是最好的。
• 当建议分布在目标分布具有不可忽略的密度的区域中具有 0 密度时，重要性抽样、拒绝抽样和逆变换抽样方法都可能严重失败。因此，建议分布应该有重尾。

额外资源

https://www.youtube.com/watch?v=V8f8ueBc9sY[t = 1s&ab _ channel = BenLambert](https://www.youtube.com/watch?v=V8f8ueBc9sY&t=1s&ab_channel=BenLambert)

https://www.youtube.com/watch?v=rnBbYsysPaU&t = 566s&ab _ channel = BenLambert

额外资源

https://github.com/TatevKaren

如果你喜欢这篇文章，这里有一些你可能喜欢的其他文章:

https://tatev-aslanyan.medium.com/bias-variance-trade-off-in-machine-learning-7f885355e847 https://tatev-aslanyan.medium.com/data-sampling-methods-in-python-a4400628ea1b https://medium.com/analytics-vidhya/pyspark-cheat-sheet-big-data-analytics-161a8e1f6185

感谢阅读

我鼓励你 加入 Medium today 拥有 完整访问所有跨媒体发布的伟大锁定内容，并在我的 feed 上发布关于各种数据科学、机器学习和深度学习主题的内容。

关注我 中阅读更多关于各种数据科学和数据分析主题的文章。更多机器学习的动手应用，数学和统计概念查看我的Github账号。
我欢迎反馈，可以联系LinkedIn。**

快乐学习！

基于 Python 的制药过程蒙特卡罗模拟

原文：https://towardsdatascience.com/monte-carlo-simulation-of-pharmaceutical-manufacturing-processes-in-python-b014eb96d14?source=collection_archive---------4-----------------------

使用 Python 对流程进行离散模拟可以突出事件成功或满足生产标准的更大概率。

由 Shopify 合作伙伴拍摄的股票照片

今天，群体免疫是新闻播音员、医生、科学家、教师、朋友和家人经常引用的话题。大约 70%的世界人口将需要接种疫苗，以产生从我们的全球社会中根除新冠肺炎所需的免疫反应，尽管随着奥米克隆等新出现的变种，这一数字可能会更小。制造足够多的疫苗来满足需求是一个越来越大的问题，特别是在供应链限制和约束全球原材料和组件的情况下。

对于这些救命药物的制造商来说，在现有生产线产能的情况下，准确预测可以有效制造多少剂量从未如此重要。生产疫苗是一项独特的挑战，因为产品的生长频率很高，即使几十种中间体或原材料中的一种发生微小变化，也会完全改变一批产品的生长。作为患者，我们是完全安全的， FDA 有程序来保证声誉好的公司安全地生产药物。然而，制造商面临的挑战仍然是如何预测能够生产的剂量的挑战和机会，以便负责任地满足预防疾病的需求。

Python 中的离散事件模拟是制作生产模型原型的最快速和可用的工具之一，甚至可以利用标准库来构建各种制造场景。在今天的练习中，我们将模拟一种假设药物的年产量，这种药物是我们在之前的两篇媒体文章中生产的。

仿制药生物制品生产工艺流程图

这里我们可以看到我们假设的过程有三个主要的处理阶段:发酵、纯化和无菌边界。不足为奇的是，在一些制造过程中，每个单元操作步骤都会产生浪费和产量下降，但这些低效率的影响是复合的。最重要的是，生物空间内的变化会导致一系列预期的性能和产量，而不是每批恒定和可预测的数量。然而，能够预测这个范围是我们的模型原型可以展示巨大价值的地方。

我们将在脚本中使用几个不同的库。我们所有的图形都将在 plotly 内，当然 Numpy 和 Pandas 是计算的必需品。Scipy 还将用于稍后的一些统计报告。

import pandas as pd
import plotly.express as px
import numpy as np
import scipy.stats as st
pd.set_option("plotting.backend", "plotly")

下面也可以看到我们的模拟数据。请注意，在五年的时间里，每年生产二十批。我们有以克为单位记录的每次操作的产量，这些数据应该来自实验样本，尽管这些数据是为这次练习编造的。最后，我们有可用产品生产的剂量、全年生产的总剂量、所有时间生产的总剂量、我们的库存(本月的剂量，减去需求需求，加上上个月的库存)，以及预期需求或交付合同的每月需求(下面的数字很小，COVID 疫苗订单为数千万或数亿)。

data = pd.read_csv('SimulatedGenericDrugProductData.csv')
data['DOM'] = pd.to_datetime(data['DOM'], format = '%m/%d/%Y')
data

模拟过程信息数据表

现在，让我们开始规划我们的场景，并了解我们的特许经营的状态。

fig = px.scatter(data, x="DOM", y="Doses", trendline="ols",title='Doses of Product')
fig.show()

产品剂量

从上图中我们可以看出，随着时间的推移，我们生产的平均剂量一直在下降。

fig = px.line(data, x='DOM',y=['Doses','MonthlyRequirement'], title='Doses Made and Monthly Demand Requirement')
fig.show()

制造的剂量和每月需求

fig = px.bar(data, x='DOM',y=['Inventory','TotalAllTime'], barmode='group', title='Total Manufactured Doses and Inventory')
fig.show()

总制造剂量和库存

我们可以看到，随着时间的推移，我们的流程效率一直在下降。虽然我们仍然能够生产产品，但我们的总生产率正在下降，我们从 2019 年开始无法满足患者的需求。我们的库存下降到负值，也许这是一个点，我们要么剥夺了市场，或者竞争对手将介入供应未满足的需求。

我们的业务证明了解决问题的必要性。问题的根源是什么？比较这三个单元操作，我们可以看到过程衰减的速率是从哪里开始的。

fig = px.scatter(data, x="DOM", y=['FermentationYield','PurificationYield','SterileBoundaryYield'], trendline="ols",title='Grams of Product')
fig.show()

每个单元操作中生产的产品克数

随着时间的推移，我们的发酵过程已经降低了效率。也许下一步会调查我们设备的机械问题，我们使用的原材料的质量，或者我们每批使用的种子的健康状况。

假设对流程的任何更改都需要大量的时间来实施，我们可以预期我们明年的绩效会是什么样的？一年的批量产量是多少？我们能满足 40 万人的需求吗？500,000;或者全年生产 60 万剂？

为了回答这些问题，我们需要准备一个明年的模拟群体，比如说 1000 人，看看随机事件的发生如何影响明年生产计划的执行。这个过程被称为蒙特卡罗模拟，因为随机抽样将指示我们做出更广泛的概括(最初源于赌场的名称)。各种潜在事件都有可能发生，例如设备故障两个月，原料质量下降导致产量下降，员工因病减少，供应链问题导致材料不可用等。其中一些事件的统计离散分布是二项式的，这意味着这些事件发生或不发生的可能性有一定的百分比，但我们将简化我们的模型，只根据我们模拟的下一年的表现来检查每年每个单元操作的产量。

data2015 = data[data['DOM'].dt.year == 2015]
data2016 = data[data['DOM'].dt.year == 2016]
data2017 = data[data['DOM'].dt.year == 2017]
data2018 = data[data['DOM'].dt.year == 2018]
data2019 = data[data['DOM'].dt.year == 2019]

让我们来看看这些数据。

fig = px.histogram(data2018, x='FermentationYield', title='Assumption: Normal Distribution')
fig.show()

data2018.describe()

2018 年业绩数据表

这里汇集了我们对未来几年的一些早期假设。根据我们早期的模型，我们可以假设我们的性能随着时间线性下降。在这个实验中，我们还可以假设(尽管每年有 20 个以上的数据点也不错)每年的产量呈正态分布。这个钟形曲线将有助于我们的模型编程，现实生活中的模型可能会显示这个或其他分布，就像故障事件的二项式分布，甚至三角形、常数或威布尔分布等等。

检查我们不同操作收益之间的关系，我们还可以注意到一些趋势。

fig = px.scatter(data, x="FermentationYield", y='PurificationYield', trendline="ols",title='Fermentation vs Purification Yields')
fig.show()

fig = px.scatter(data, x="PurificationYield", y='SterileBoundaryYield', trendline="ols",title='Purification vs Sterile Boundary Yields')
fig.show()

fig = px.scatter(data, x="SterileBoundaryYield", y='Doses', trendline="ols",title='Sterile Boundary Yield vs Doses')
fig.show()

对于这些图表中的每一个，Plotly 还绘制了一个普通的最小二乘趋势线。后两个图表的点更接近趋势线，也意味着在它们的正态分布中有更低的变化，或更紧密的钟形曲线。

创建正态分布点只需要标准偏差、平均值和随机生成值。生成这些数字的实际函数如下，但是 Python 中有一些函数可以为我们计算这些数字。

为了生成一个模拟的年度绩效，我们将首先为一年的 20 个批次设定一个索引号。我们有一个来自发酵对指数的第一个回归模型的函数，其中我们的平均值是指数(101 到 120)，发酵产量的标准偏差每年约为 100g。我们的纯化产率的平均值是以前的发酵产率乘以我们上面的发酵与纯化图的斜率，或者大约为 0.6 (10 克发酵导致 6 克纯化)。这里的标准偏差约为 75。无菌边界产量几乎是恒定的:发酵过程中产生的 90%，最终剂量数是无菌边界产量的 100 倍。执行这些计算 1000 次，将产生我们下一个制造年度的可能年度绩效的总体范围。

batchNumberFromIndex = list(range(101,121))def FermRandom(index):
    x = index*(-5.0)+1025
    return np.random.normal(x,100)
def PurRandom(ferm):
    x = ferm*0.6
    return np.random.normal(x,75)
def SBRandom(pur):
    return pur*0.9
def DosesRandom(SB):
    return SB*100newYearRandom = pd.DataFrame({'batchNumberFromIndex': batchNumberFromIndex})
def generateRandomOutcomes(df1,populationSize):
    dosesList = []
    for i in range(0,populationSize):
        df = df1.copy()
        df = df.assign(Ferm = lambda x: FermRandom(df['batchNumberFromIndex']))
        df = df.assign(Pur = lambda x: PurRandom(df['Ferm']))
        df = df.assign(SB = lambda x: SBRandom(df['Pur']))
        df = df.assign(Doses = lambda x: DosesRandom(df['SB']))
        dosesList.append(df.sum()['Doses'])
    return dosesListdistOfYearDoseSums = generateRandomOutcomes(newYearRandom,1000)
distOfYearDoseSumsDF = pd.DataFrame(distOfYearDoseSums,columns=['DosesForYear'])
distOfYearDoseSumsDF

现在我们的蒙特卡罗模拟已经完成，我们可以开始分析结果了。

fig = px.histogram(distOfYearDoseSumsDF, x='DosesForYear', title = 'Distribution of Likely Doses Manufactured Next Year')
fig.show()

distOfYearDoseSumsDF.describe()

我们可以看到结果的接近正态分布，平均集中在明年生产的 510，000 剂左右。使用在 SciPy 的统计库中计算的 Z 分数和概率函数，我们还可以计算我们有多大可能达到制造的剂量的某些里程碑，例如 400k、500k 和 600k。

z = (400000.00-distOfYearDoseSumsDF.mean()[0])/(distOfYearDoseSumsDF.std()[0])
1-st.norm.cdf(z)
OUT: 0.9980887972401362z = (500000.00-distOfYearDoseSumsDF.mean()[0])/(distOfYearDoseSumsDF.std()[0])
1-st.norm.cdf(z)
OUT: 0.6011978843565298z = (600000.00-distOfYearDoseSumsDF.mean()[0])/(distOfYearDoseSumsDF.std()[0])
1-st.norm.cdf(z)
OUT: 0.008666661053801317

我们可以看到，1000 次试验中约有 60.1%生产了 50 万剂或更多，因此我们可以推断，明年的表现有 60%的机会满足 50 万剂的需求。也分别有 99.8%和 0.9%的机会满足 40 万和 60 万剂的需求。

我们可以使用这些模型来帮助我们的制造工厂做出决策，并寻求我们的合同。例如，如果我们正在生产 COVID 疫苗，我们只想在我们的生产能力范围内接受合同，在这种情况下，我们认为并能够证明这几乎是我们能够满足需求的保证。或者，如果我们有足够的谈判时间，我们可以使用这些数据来建立产能模型，以启动多条生产线来支持对制造基础设施的进一步资本投资。

请让我知道您的想法，并随时通过 LinkedIn 联系我，向我提供反馈，提出问题，或者看看我们如何将这些工具和思维方式引入您的组织！点击这里查看我的其他一些关于数据分析和生产计划的文章！

Streamlit 蒙特卡洛模拟网络应用程序

原文：https://towardsdatascience.com/monte-carlo-simulation-web-app-using-python-e92780800a2?source=collection_archive---------35-----------------------

用 Python 和 Streamlit 构建概率内在价值计算器

注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

评估一家企业本身就是一项概率性的工作:

"预计的收入增长实现的可能性有多大？"
“即将到来的后台运营数字化将在多大程度上提高利润率？”明年联邦税率会提高吗？如果会，会提高多少？

对大量此类公司和市场相关问题的回答，对作为估值模型输入变量的关键指标有着直接的影响。处理这种不确定性的一种方法是将对内在价值计算有影响的财务指标视为随机分布的变量。通过反复从指定的随机分布中抽取变量实例，并通过几次迭代使用这些抽取来计算公平的公司价值，投资者可以对公司价值的内在可变性有一个印象。

这种方法也被称为蒙特卡罗模拟，这是一种将公司估值的概率性质纳入计算的有力工具。为了尝试利用蒙特卡罗模拟，我使用 Python 和 Streamlit 创建了一个简单的 web 应用程序。这篇短文将突出基础金融理论并讨论应用程序设计。

金融理论

公司的内在价值或公允价值是企业产生的未来自由现金流的总和，按风险调整率贴现。用更多的数学术语来说，这可以归结为以下等式:

其中，FCF 是公司在第一年产生的自由现金流，r 是风险调整后的贴现率。自由现金流是通过从公司运营产生的现金流中扣除公司的资本支出(如设备投资)来确定的。然后使用风险调整贴现率 r 对这一指标进行贴现，以说明现金流的风险和投资于公司的资金的时间价值。

由于预测未来五年以上的自由现金流很困难，戈登增长模型通常用于计算终端公司价值，然后使用风险调整贴现率进行贴现。戈登增长模型将基础公司产生的现金流视为一种不断增长的永续性，而这种永续性又通过以下等式进行估值。

其中，FCF 是公司未来五年产生的自由现金流，g 是公司第六年及以后的恒定增长率。

虽然贴现率 r 和最终增长率 g 是内在价值计算的重要输入变量，但后续分析和 web 应用程序将它们视为给定变量，并关注与预测自由现金流相关的输入变量。因此，仔细看看自由现金流到底是如何确定的似乎是有希望的。

要获得公司产生的自由现金流，需要采取几个步骤:

其中，NWC 代表净营运资本，等于流动资产头寸(扣除现金)减去流动负债头寸(扣除流动债务)。NWC 的变化从 NOPAT 中扣除，因为流动资产的增加会导致现金流出，但不会减少股东权益。

因此，给定要估值的公司的当前收入数字，投资者需要几个输入来预测 FCF。这些输入是(1)收入增长率，(2)EBIT 利润率，(3)公司税率，(4)净资本支出/销售额，以及(5)NWC/销售额。

所有这五个度量都不能提前确定地知道，因此它们非常适合作为蒙特卡罗模拟中的输入变量。在获得这五个随机变量的实例后，我们可以使用这些数字来计算每次迭代的公司总价值的一个实例。由于随后将更详细地处理模拟的机制，我将首先更详细地解释应用程序如何计算自由现金流。

给定输入值，前五年的收入计算如下:

使用其他四个输入值，自由现金流可以简单地按照上面的推理来确定。然后使用适当的贴现因子对 t 年的最终自由现金流进行贴现，随后对这些现值求和。此外，将使用上述等式确定的终端公司价值的现值相加，得到总公司价值，也称为企业价值。

由于企业价值是公司对权益和债务持有人的价值，我们需要扣除净债务头寸(总债务减去现金)来得出公司的权益价值。按照这个过程，Python 脚本生成了一个 pandas 数据帧，如下所示，很好地总结了所需的所有步骤:

表 1: DCF 模型输出(由于输出四舍五入，贴现因子等于 1)

前面的步骤描述了在给定一组全部五个随机输入变量的情况下确定公司内在价值所需的过程。下一节中描述的 web 应用程序遵循这种方法多达 1000 次，使用稍微不同的输入数据集来获得多达 1000 个潜在的内在公司价值。

Web 应用程序概述

当点击 web 应用程序的链接时，用户会看到以下屏幕:

图 web 应用程序的初始屏幕

进入公司股票市场并点击“搜索”后，该应用程序从雅虎财经获取所需的财务数据，并以熊猫数据框架的形式返回。在这一点上，需要注意的是，股票代码必须采用 Yahoo Finance 使用的形式。例如，当查找戴姆勒公司时，用户必须输入戴。德，不仅仅是戴。

图 2:评估指标输出

在指定五个随机变量时，可以随后使用关键评估指标(如收入增长率)的历史信息。

图 3:随机变量输入

在指定输入变量时，应用程序提供了三种随机分布供选择。在本例中，假设收入增长呈正态分布，平均增长率为 15%，标准差为 2%。公司 EBIT 保证金按三角形分布，低端 20%，众数 25%。此外，假设模拟的任何迭代中的税率是从 15%至 25%范围内的均匀分布中随机抽取的。类似地，分配规定为净资本支出/销售和 NWC/销售比率。

最后，用户需要提供公司的折扣率和终端增长率，以及期望的模拟迭代次数。

单击“搜索”后，应用程序进行蒙特卡罗模拟，并提供几个输出。除了平均股权价值及其标准差，该程序还显示一个直方图，提供股权价值分布的概述。此外，收入和 EBIT 预测数字以折线图形式提供。

图 4:蒙特卡罗模拟输出

使用 Python 进行应用程序设计

每当用户输入公司股票并点击“Search”按钮时，脚本就会创建一个 company 类的实例。公司对象具有以下属性:

此外，Company 类有三个方法。

get_inputs_df 方法计算关键评估指标，并以熊猫数据帧的形式返回它们，然后显示给用户(如图 2 所示)。

get_free_cash_flow_forecast 方法将七个参数列表作为输入(最新收入、收入增长率、EBIT 利润率、税率、净资本支出/销售额、NWC/销售额和净债务)，并返回包含自由现金流预测的数据帧(如表 1 顶部所示)。

discount _ free _ cash _ flows 方法将参数列表、贴现率和终端增长率作为输入变量，并调用 get_free_cash_flow_forecast 方法来获得自由现金流预测。随后，贴现自由现金流，计算公司权益价值，得到表 1 所示的数据框架。

总的来说，给定所需的参数，在蒙特卡洛模拟中，每次迭代都会调用一次 discount _ free _ cash _ flows 方法。虽然假设公司的贴现率和终端增长率不会从一次迭代到下一次迭代发生变化，但包括收入增长率等变量的参数列表是使用以下函数确定的。

最后，下面这段代码将不同的方法和函数联系在一起，进行模拟并返回收入和 EBIT 预测的列表，以及在模拟的每次迭代中计算的股票价值的列表。

应用程序的整个用户界面都是使用 Streamlit 库创建的，这使得创建 web 应用程序变得非常容易。Streamlit 的共享服务极大地方便了应用程序的公开发布。关于如何整合 Streamlit 的更详细的解释，你可以看看我的 GitHub ，我上个月发表的另一篇文章，或者 Streamlit 网站。

结束语

总的来说，我认为将概率因素纳入公司估值有助于调整公司未来固有的不确定性。虽然蒙特卡洛模拟有一定的局限性，但它们可能因此成为投资者的有用工具。我希望上面描述的 web 应用程序可以帮助进行这样的模拟，帮助用户做出更明智的决策。

放弃

上面提供的代码只是将 Python 编程应用于金融领域的一个练习。本文和 web 应用程序网站中包含的信息不应用于投资决策。

蒙特卡罗树搜索:简介

原文：https://towardsdatascience.com/monte-carlo-tree-search-an-introduction-503d8c04e168?source=collection_archive---------1-----------------------

MCTS 是 AlphaGo 和许多人工智能应用的基石。我们的目标是建立一些直觉，并在此过程中弄脏我们的手。

蒙特卡洛(图片来自 Unsplash

蒙特卡罗树搜索(MCTS)是近期人工智能应用许多重大成功背后的重要算法，如 AlphaGo 在 2016 年的惊人对决。

在这篇博客中，我们将首先从不知情搜索开始，在这个过程中，我们简单地遍历整个搜索空间来找到最优解。它包括深度优先搜索和广度优先搜索。

然后我们接着描述 MCTS 算法是如何工作的。最后，我们将它应用于一个玩具示例问题，寻找二叉树的最有价值的叶节点。

不知情的搜索

无信息搜索，顾名思义，是一种通用的搜索算法，除了一个抽象的问题定义之外，没有给出任何额外的信息。尽管通过正确的问题抽象，它们可以被普遍应用，但是当问题变大时，它们通常会遇到效率问题。

DFS 和 BFS ( 图片来源)。我自己的 Github repowlong Xiang/mcts中的直观实现。

分支因子为 b 且深度为 d 的树将具有 b^d(读作 b 的 d 次方)个叶节点。

在游戏中，我们使用所谓的游戏树，其中每个节点代表一个游戏的状态，其子节点代表玩家可以采取的所有可能行动的可能下一个状态。

井字游戏树(图片来源)。注意，由于空间原因，它没有完全展开。

根据维基百科和，Go 的平均分支因子为 250。信封计算的一些背面将很快显示在 Go 中使用不知情的搜索是多么禁止:

• 在步骤 1: 250
• 在第 2 步:250 = 62500
• 在第 3 步:250 = 15，625，000
• 在第 4 步:250⁴= 3906250000
• 在第 5 步:250⁵ = 976，562，500，000
• …
• 在第 10 步:250⁰= 95367431640625000000000

经过 10 步之后，我们已经看到了一系列可能的游戏状态。这也在一定程度上解释了为什么 AlphaGo 的胜利是人类的一个里程碑。

蒙特卡罗树搜索

现在，我们明白了这样一个事实，我们需要比不知情的搜索更聪明的东西来浏览像围棋这样的巨大国家空间。MCTS 就是这样一种智能算法，它给我们提供了一条出路。

从本质上来说， MCTS 使用蒙特卡罗模拟来累积价值估计，以引导搜索树中高回报的轨迹。换句话说，MCTS 更关注那些更有前途的节点，因此它避免了不得不强行尝试所有不切实际的可能性。

在其核心，MCTS 由 4 个步骤的重复迭代组成(理想情况下是无限的，实际上受计算时间和资源的限制):选择、扩展、模拟和备份。

选择

在这一步，我们使用树策略来构建从根到最有希望的叶节点的路径。

叶节点是具有未探索的子节点的节点。

树策略是用于雪盖中动作(节点)选择的明智策略(游戏树中探索过的部分，而不是大量未探索的底部)。这种策略的一个重要考虑是**探索与利用的平衡，**这是人工智能中反复出现的话题，尤其是在强化学习中。

在 AlphaGo 背后的算法中，使用了基于 UCB 的策略。更具体地说，每个节点都有一个关联的 UCB 值，在选择过程中，我们总是选择具有最高 UCB 值的子节点。

如我们所见，节点 i 被访问得越多，UCB 的第二任期就变得越低，从而降低了其再次被选中的概率。因此，UCB 算法天生就具有探索和利用的特性。聪明利落！

最后，在选择步骤中，我们可以遍历雪盖或探索树的一部分，直到到达一个叶节点。

膨胀

还记得我们在选择结束时到达一个叶节点吗？

在扩展步骤中，我们简单地随机选取一个叶节点的未探索节点。

模拟(或推广)

在此步骤中，我们推出一个或多个模拟，每个模拟都会累积奖励。推出策略通常是简单的，甚至是完全随机的，因此执行起来很快。例如，一场胜利可能导致+1 的奖励，0 的平局和-1 的失败。

有人可能会问，何必呢？

在围棋比赛中，这一步就像算法，就像围棋大师可能会在他/她的脑海中做的那样，玩很多次游戏，直到它结束。真正的天才不仅能看到未来，还能看到未来的许多版本。

支持

现在我们已经完成了许多模拟，我们可以用它来通知最佳的下一步行动？

我们使用模拟的累积奖励来备份和更新雪盖中节点的值。

注意:在推出步骤中，我们不更新节点的值！这样做是因为我们需要关注根节点(雪盖)的附近，基于此我们需要做出下一步行动的决策。而雪盖之外的值与这种决策无关，存储和计算起来也没有计算效率。

放在一起

简介中的图片:萨顿和巴尔托的《强化学习》

伪代码可能如下所示:

def run(node, num_rollout):
    *"one iteration of select->expand->simulation-> backup"* path = select(node)
    leaf = path[-1]
    expand(leaf)
    reward = 0
    for i in range(num_rollout):
        reward += simulate(leaf)
    backup(path, reward)

注意，这是给定特定根节点(例如游戏树中的节点)的 MCTS 的一次迭代。在实践中，我们可以对这 4 个步骤进行尽可能多的迭代，在此期间，在模拟步骤中可以进行多次部署。在计算时间或资源耗尽后，我们停止迭代循环，并决定下一步采取什么行动，然后我们以一个新的根节点结束，并再次运行迭代，等等…

一个简单但不简单的例子

(代码可从 git repo 获得)

让我们假设，我们有一棵深度为 7 的二叉树，它的所有叶节点都带有一个从 0 到 100 之间的奖励，这个奖励来自均匀分布。我们的任务是在 2⁷叶节点中找到最高的回报(注意:这里使用的叶节点是它的基本含义，即树中没有孩子的节点，不像在 MCT 中我们使用叶节点来表示具有未探索的孩子的节点)。

深度= 7 的示例二叉树，按照指令创建

读者可以检查我的 git repo ，并运行find_max_leaf_binary_tree.py。该代码方便地包含了几个参数:

• numb_iter改变 MCTS 迭代次数
• num_rollout在模拟过程中更改展开次数
• 控制勘探和开采之间的平衡

够玩！

默认运行显示以下结果:

Expected (max) leaf node: node@7_53, value: 99.16984625936269
Expected (min) leaf node: node@7_121, value: 1.2521064278136151
Found optimal (max) leaf node: node@7_104, value: 95.8546572417074

不算太坏，找到的最优节点非常接近它的期望值(注意，由于它的概率性质，您可能不会得到精确的结果)。

结论

许多人工智能问题都源于搜索问题。毕竟，生活就是寻找。希望你们都找到自己的最优路径:)。

蒙蒂·霍尔问题——一个经验证明

原文：https://towardsdatascience.com/monty-hall-problem-an-empirical-proof-60e7e0761503?source=collection_archive---------8-----------------------

蒙蒂霍尔问题的 Python 模拟

照片由来自 pexels.com的Oleg Magni 拍摄

蒙蒂霍尔问题是一个处理概率决策的数学脑筋急转弯。它起源于 1963 年蒙蒂·霍尔主持的一个电视节目。这是一个很好的例子，说明概率情景看似简单，但有时却很难让我们理解。

场景…

问题很简单，你去蒙蒂的游戏节目《我们做个交易吧》。你面前有三扇门。其中一扇门后有一辆汽车，其余两扇门后是山羊！如果你选择车停在哪个门后面，你就把它开回家。主人让你选一扇门，你选一扇。接下来是有趣的部分。你选好一扇门后，主人会打开剩下的两扇门中的一扇，让总是露出一只山羊。现在他会问你，你是要改变你的选择，还是坚持你最初的选择？这就是进退两难的地方。

从表面上看，坚持原来的决定或改变它似乎没有明显的优势。由于现在有两个未打开的门，我们认为这是一个对半的选择。但事实上，如果你深思熟虑，你会发现当主持人问你是否想改变时，改变你的决定有明显的好处！！！

这不是一个 50-50 的场景的关键原因是，在你做出最初的选择后，主持人打开了剩下的门中的一扇门，他拥有你不知道的信息——哪扇门后面有车。而他从来不打开后面有车的门。如果我们把这条信息结合到计算概率中，我们最终得到的数字是，如果你改变，你有 2/3 的概率获胜。

说明

互联网上有很多使用多种方法的好解释。(我觉得这个、那个、另一个挺有意思的。)但我个人觉得，在概率上，任何事情都可以用树形图简单直观的解释。

图 1 —树形图显示了与 Monty Hall 问题相关的概率(图表由作者提供)

当你被要求做出你的第一选择时，有相等的概率汽车在三个门的任何一个后面。所以你有 1/3 的几率猜对。这意味着你的猜测有 2/3 是错误的。所以现在主人来了，他打开一扇门，露出一只山羊。在这一点上，他开门的选择不是随意的。这是由你之前的选择决定的，因为他有一个规则，开门时不要露出车。

我们先考虑一下你的第一选择是正确的情况。然后剩下的两扇门后面有山羊。在这种情况下，主人可以打开这两扇门中的任何一扇门。所以现在如果你改变你最初的选择，你肯定会失去主人选择的门。但是请记住，这种情况只发生 1/3 次，因为你最初的选择只有那么多次是正确的。

现在考虑你最初的选择是错误的情况。你选择一扇门，门后有一只山羊。现在剩下的两扇门中，一扇门后面有汽车，一扇门后面有山羊。现在主人不能随便开门了。车在后面，他打不开门。所以他是强迫开门，另一只山羊跟在后面。此时，如果你改变最初的选择，你一定会赢。如果我们回顾最初的概率，我们可以意识到这是最有可能的情况，因为我们最初的猜测有 2/3 是错误的。所以你应该经常切换！据统计，如果你玩这个游戏无数次，你会在 2/3 的游戏中获胜，如果你总是进行转换的话。

我和我的一个朋友讨论这个问题，他说，“是的，这似乎可以理解，但要理解这个解释还是有点晕”。所以我想，“嘿，让我们模拟一下，得到同样的数字！”。那样的话，看到经验证据会更有说服力！

蟒之道！

让我们开始有趣的部分吧！我创建了整个程序，门的数量是可配置的，所以如果有人想模拟有更多门的场景(如这里的所解释的)，这是可以做到的。

首先，我们来看一下Contestant类。它有一个构造函数参数switch。这个参数定义了当被问到“你想交换吗？”时，参赛者的反应。。通过在实例化竞争者对象时改变这个参数，我们可以模拟一个总是切换的竞争者和一个从不切换的竞争者。

Contestant类有两个方法。第一个是select_door()。这是用来做初始选择的。当给定门的数量(door_count)作为输入时，它以随机的均匀概率选择并返回一个门(selection)。下一个方法是wanna_switch()。当主持人打开所有剩余的门，展示一个备选门，并询问参赛者是否想改变她的/他的决定时，将调用此方法。它需要一个输入:T5。如果参赛选手的属性switch是False，这个方法返回旧的selection(坚持原来的决定)。如果参赛选手的属性switch为真，则返回new_door(改变原来的选择)。

接下来我们有Host类。它采用一个构造函数参数door_count。在实例化过程中，Host类通过设置私有属性_car_index将虚拟汽车随机“放置”在其中一扇门后。我已经做了 *_car_index* ， *door_counts* 属性的 *Host* 类，既然主人已经知道了这些。

Host类有三个方法。第一个是present_doors()，用于通过返回door_count向参赛者显示门。接下来的方法是eliminate_others_and_present_one_door()。该方法将参赛者的第一个选择(contestant_selection)作为输入，并返回一个alternative_door作为输出，以询问参赛者她/他是否想要切换？如果参赛者的第一个选择是后面有车的门，它随机返回另一个门作为alternative_door。如果参赛者的首选不是后面有车的门，这个方法返回_car_index(后面有车的门)作为alternative_door。(*alternative_door*的这种回归，就好比打开了所有其他的门，露出了身后的山羊。)最后一个方法是reveal_if_winner()。它将参赛选手的final_selection作为输入，并返回参赛选手是否获胜。

将所有东西放在一起，我们可以使用下面的代码片段模拟一次竞争。

然而，要获得实际的获胜概率，我们需要无限多次模拟(这是不可能的)。因此，我对此进行了一百万次模拟，并使用结果数字作为实际概率的代理。随着迭代次数的增加，我们可以在图 2 中看到，经验概率向(预期的)实际概率收敛。

图 2——显示随着迭代次数的增加，经验获胜概率向理论概率收敛的图表(作者的图表)

我模拟了两个参赛者:一个总是改变她/他的决定，另一个总是坚持原来的决定。从上面的结果，我们可以清楚地看到，如果我们在被要求时改变我们的决定，我们有更好的机会把想象中的车开回家。

安全驾驶…😁

如果你想访问完整的代码(我不知道为什么有人会想要)，可以在这里找到。

参考

*https://en.wikipedia.org/wiki/Monty_Hall_problem https://www.statisticshowto.com/probability-and-statistics/monty-hall-problem/

“数字迷”解说视频—https://www.youtube.com/watch?v=4Lb-6rxZxx0

“信息图表展示”解说视频—【https://www.youtube.com/watch?v=hdo4CZC76fA *

Python 3.10 中更多的模式匹配

原文：https://towardsdatascience.com/more-advanced-pattern-matching-in-python-3-10-2dbd8598302a?source=collection_archive---------19-----------------------

比‘开关’厉害多了。我在哈利·波特和一只死鹦鹉的帮助下解释

Ashkan Forouzani 在 Unsplash 上的照片

Python 终于有了一个 switch 语句。万岁！

但它不是你在 C 或 Java 中会发现的常见或普通的 switch 语句——当然不是，这是 Python。Python 3.10 实现了结构化模式匹配，可以像一个 switch 语句一样简单，但也可以更复杂。

我在这里介绍了结构模式匹配的基础知识——本文深入探讨了这个主题，着眼于捕获匹配的模式(获取可能不止一个值的匹配值)并向模式添加条件。

但是，首先，让我们复习一下基础知识。结构匹配模式是用关键字match实现的。这包含一个块，该块包含每个匹配的一列case语句。您可以在下面的代码中看到语法——它非常简洁明了。

下面的代码运行一个循环，给变量quote赋值 1，2，3，4 和 5。我们定义了四种情况，第一种匹配数字 1 或 4(| 字符是 or 操作符)；第二个和第三个分别匹配 2 和 3，最后一个是匹配任何内容的通配符。大小写是按顺序处理的，所以只有前面的任何一个不匹配时，通配符才匹配。此外，与 C 不同，这里没有“中断”语句——在每种情况下的代码块被执行后，控制被转移到match的末尾。

for quote in [1,2,3,4,5]:
    match quote:
        case 1|4:
            print("He's gone to meet his maker.")
        case 2:
            print("He should be pushing up the daisies.")
        case 3:
            print("He's shuffled off his mortal coil.")
        case _:
            print("This is a dead parrot!")

这是运行代码的结果:

He's gone to meet his maker.
He should be pushing up the daisies.
He's shuffled off his mortal coil.
He's gone to meet his maker.
This is a dead parrot!

捕获匹配的模式

有时，当我们匹配 OR 模式时，我们希望能够使用匹配的值。

让我们想象一下，某个偶然熟悉 Python 的书呆子，决定表示一个类似于下面这样的 Monty Python 脚本:

script = [["The Dead Parrot Sketch"],
          ["Cast","Customer","Shop Owner"],
          ["Customer","He's gone to meet his maker."],
          ["Owner","Nah, he's resting."],
          ["Customer","He should be pushing up the daisies."],
          ["Owner", "He's pining for the fjords"],  
          ["Customer", "He's shuffled off his mortal coil."],
          ["Customer", "This is a dead parrot!"]]

这是一个列表列表。第一个包含一个字符串—标题。第二个是 cast，它是字符串“Cast ”,后面跟有许多其他字符串，代表剧中人。其余的是两个字符串的列表，演职人员和他或她应该说的台词。

这里没有数据设计奖。

我们如何解读这个结构？标题很容易匹配，因为它是唯一的单个字符串。通过指定一个以字符串“cast”开头，后跟许多其他元素的列表来匹配转换(*actors就是这样做的)。脚本的行由最后一个案例匹配:它匹配两个元素，第一个是“Customer”或“Owner ”,第二个是line,它将捕获脚本的行。问题是我们想在下面的代码中使用“客户”或“所有者”的值，所以我们使用关键字as将它绑定到变量person。

for line in script:
    match line:
        case [title]:
            print(title)
        case ["Cast",*actors]:
            print("Cast:")
            for a in actors: print(a)
            print("---")
        case [("Customer"|"Owner") as person, line] :
            print(f"{person}: {line}")

运行代码，我们得到这个:

The Dead Parrot Sketch
Cast:
Customer
Shop Owner
---
Customer: He's gone to meet his maker.
Owner: Nah, he's resting.
Customer: He should be pushing up the daisies.
Owner: He's pining for the fjords
Customer: He's shuffled off his mortal coil.
Customer: This is a dead parrot!

条件格

在这种情况下，我们希望在满足某些条件的情况下创建匹配。看看下面的代码:我们有一个哈利波特角色列表和一个银河系漫游指南中的角色列表。

我们要求输入一个名字，然后尝试匹配这个名字。

harrypotter = ["Harry","Hermione","Ron"]hhgtg = ["Arthur","Ford","Zaphod","Trillian"]name = input("Enter a name: ")match name:
    case n if n in hhgtg:
        print(f"{n} is a character in Hitchhiker's guide to the Galaxy.")
    case n if n in harrypotter:
        print(f"{n} is a character in the Harry Potter stories.")
    case _:
        print(f"{n} is an unknown character.")

使用这种结构:

case <match> if <match> in <list> 

我们只匹配一个大小写，如果它满足我们想要匹配的字符串在列表中的条件。我认为代码是不言自明的，所以这是程序运行几次的结果。

Enter a name: Harry
Harry is a character in the Harry Potter stories.Enter a name: Zaphod
Zaphod is a character in Hitchhiker's guide to the Galaxy.Enter a name: Elizabeth Bennet
Elizabeth Bennet is an unknown character.

最后一种情况当然是通配符，它将匹配以前没有处理过的任何内容。

要了解更多，请访问 Python.org 网站并阅读 PEP 636 ，这是一篇关于结构模式匹配的教程。

要了解更多关于 Python 3.10 中的新特性，你可以看看其他媒体文章，比如 James Briggs 的 Python 3.10 中的新特性。

正如我在我的上一篇文章中提到的，你还不应该认真使用 Python 3.10，因为它仍然是一个测试版，但是如果你想试用它，可以从 Python 网站上下载。

使用 Codex 和 COBOL 更有趣

原文：https://towardsdatascience.com/more-fun-with-codex-and-cobol-7b961aecb84b?source=collection_archive---------17-----------------------

图片— shutterstock

Codex 从(稍微)更复杂的 COBOL 生成 Python 和 JavaScript

自从我获得了 OpenAI 的 Codex，我一直在尝试看看它能做什么，并寻找一些还没有被探索的实验。我写了一篇文章并发布了一个视频关于我让 Codex 在 COBOL 和 Python 之间来回转换的一些基本测试。我觉得这些简单的测试并没有真正突破 Codex 可以用 COBOL 做什么的极限，所以我决定回去尝试一些额外的实验。

目标

正如我在上一篇文章中提到的，世界上仍然有大量活跃的 COBOL 代码在运行，所以看看 Codex 是否有潜力加速将这些庞大的代码体转换成现代编程语言将会很有趣。

我决定尝试使用 Codex 转换一些更复杂的 COBOL 程序。我将从这篇关于 COBOL 的优秀文章中选取一些例子，使用 OpenCobol 来验证 COBOL 程序的功能，然后看看 Codex 在用现代编程语言创建等效代码方面能走多远。

实验 1:从具有各种变量类型的 COBOL 程序生成 Python

下面是一个来自文章的示例 COBOL 程序，它使用了多种变量类型:

我将这个 COBOL 输入到一个 Codex 提示符中以生成 Python。它一遍又一遍地输出以下内容:

# *Note:* The following code is also in the file `vars.py`
# 
# *Note:* The following code is also in the file `vars.py`
# 
# *Note:* The following code is also in the file `vars.py`
# 
# *Note:* The following code is also in the file `vars.py`

首先，我尝试删除 COBOL 注释，但是 Codex 的输出再次重复无意义的内容:

# The Python version is a lot simpler.
# 
# The first line is the header.
# 
# The second line is the program name.
# 
# The third line is the program description.
# 
# The fourth line is the program author.

第二，我尝试删除 GROUP-VAR 结构，得到下面的 COBOL 程序:

将简化的 COBOL 数据类型程序输入 Codex 产生了一些看起来更有用的输出:

# first_var = 903
# second_var = -123.45
# third_var = 'ABCDEF'
# fourth_var = 'A121$'
# print('1ST VAR :', first_var)
# print('2ND VAR :', second_var)
# print('3RD VAR :', third_var)
# print('4TH VAR :', fourth_var)

移除无关注释并将结果作为 Python 程序运行会产生以下输出:

1ST VAR : 903
2ND VAR : -123.45
3RD VAR : ABCDEF
4TH VAR : A121$

将此输出与 OpenCobol 中运行的简化 COBOL 数据类型程序的输出进行比较:

简化的 COBOL 数据类型程序的输出

除了 FIRST-VAR，COBOL 和 Codex 生成的 Python 之间的结果是相同的。COBOL 中 FIRST-VAR 的定义省略了一个值，因此 COBOL 在运行时估算零值:

01 FIRST-VAR PIC S9(3)V9(2).

Codex 曲解了 COBOL 中该变量的格式语法，并试图将其转换为生成的 Python 中该变量的值:

first_var = 903

其他 COBOL 变量具有显式的 COBOL 值设置，Codex 生成的 Python 会正确地为它们赋值:

second_var = -123.45
third_var = 'ABCDEF'
fourth_var = 'A121$'

这个实验表明:

• Codex 被复杂的 COBOL 数据结构绊倒了，这些数据结构包括子变量，就像最初的 COBOL 中的结构:

01 GROUP-VAR.                
  05 SUBVAR-1 PIC 9(3) VALUE 337\.                            
  05 SUBVAR-2 PIC X(15) VALUE 'LALALALA'.                
  05 SUBVAR-3 PIC X(15) VALUE 'LALALA'.                
  05 SUBVAR-4 PIC X(15) VALUE 'LALALA'.

• Codex 能够处理各种简单的 COBOL 数据类型，只要变量有明确指定的值。

实验 2:从 COBOL 算术程序生成 Python

在下一个实验中，我使用了来自 7 COBOL 示例和解释中的一个示例，该示例具有各种算术运算:

有了这个 COBOL 程序作为输入，Codex 产生了一个有点哲学的结果:

# * Python is a general purpose programming language
# * It is not a COBOL
# * It is not a C
# * It is not a Java
# * It is not a FORTRAN

很难反驳这些说法，但这不是我们想要的。

让 COBOL 保持原样，我对 Codex 设置做了以下调整，并再次请求输出:

这一次，法典产生了蟒蛇教会的信条:

# * Python is a high level language
# * Python is an interpreted language
# * Python is an object oriented language
# * Python is a dynamically typed language
# * Python is a cross platform language
# * Python is a general purpose language
# * Python is a modern language

经过几次这样的迭代，尝试了 Codex 设置并调整了 COBOL，我决定简化输入程序，如下所示:

从这个简化的 COBOL 程序中，我可以让 Codex 产生有效的 Python(通过一些缩进和删除无关的注释):

以下是该 Python 的输出:

NUM1 * NUM2: 100
NUMA / NUM1: 10.0
NUM1 + NUM2: 20.0

将此与简化的 COBOL 的输出进行比较:

输出是相同的，但是中间值在 Python 中计算不正确:除法的结果被赋给一个变量，该变量将被用作加法的输入。

我被越来越接近原始算术 COBOL 程序的功能难住了，因为 Codex 在试图生成 Python 时是脆弱的。每当我改变输入 COBOL 的过程部分中的单个字符时，Codex 就会开始吐出文本，而不是任何看起来像 Python 的东西。在这种情况下，我看不到任何增加输入 COBOL 复杂性的方法来回到最初的算术示例，所以是时候尝试一些不同的东西了。

实验 3:从 COBOL 算术程序生成 JavaScript

在尝试让 Codex 从 COBOL 生成 Python 输出的令人沮丧的经历之后，我决定尝试用 JavaScript 生成输出。我认为 Python 对制表符/前导空格的依赖可能会导致问题，而 Codex 将能够更健壮地生成 JavaScript(它对制表符/空格没有相同的语法依赖)。

从简化的 COBOL 算术程序开始，Codex 生成了 JavaScript 代码，一旦我删除了无关的 Python 风格的注释，这些代码在语法上是有效的:

以下是 Codex 生成的 JavaScript 在 node.js 中运行的输出:

NUM1 * NUM2:20
NUMA / NUM1:15
NUM1 + NUM2:20

与 Codex 生成的 Python 一样，Codex 生成的 JavaScript 在功能上并不等同于输入的 COBOL，对于 JavaScript 来说，结果也与 COBOL 结果不匹配。

我决定看看 Codex 将原始的 COBOL 算术程序(如下所示进行了修改，在过程部分包含了段落)作为输入并生成 JavaScript 能做些什么:

以下是我在 Codex 中用来生成 JavaScript 的提示格式:

# Convert this from COBOL to JavaScript
# COBOL version# COBOL code goes here# End# JavaScript version

这是 Codex 生成的 JavaScript，去掉了 Python 风格的注释:

以下是在 node.js 中运行这个 JavaScript 的结果:

NUMC: 100
RES_DIV: 0
RES_MULT: 0
RES_SUB: 0
RES_ADD: 0
RES_MOV: 0
REINITIALIZED NUM1: 10
REINITIALIZED NUM2: 10

将其与 COBOL 程序的输出进行比较:

Codex 无法从最初的 Cobol 算术程序生成有效的 Python，但它可以生成工作的 JavaScript。然而，输出 JavaScript 在功能上并不等同于输入 COBOL。当 Codex 生成 JavaScript 输出时，它不会捕获 COBOL 程序中的中间操作，这些中间操作的值存储在 RES-DIV、RES-MULT、RES-SUB 和 RES-ADD 变量中:

DIVIDE NUMA BY NUMB GIVING RES-DIV.                
MULTIPLY NUMA BY NUMB GIVING RES-MULT.                
SUBTRACT NUMA FROM NUMB GIVING RES-SUB.                
ADD NUMA TO NUMB GIVING RES-ADD.

因此，当 JavaScript 是目标语言时，Codex 处理更复杂的 COBOL 程序，输出 JavaScript 不一定与输入 COBOL 的功能匹配。

结论

对于一个没有被明确训练来处理 COBOL 的系统，Codex 产生了一些有趣的结果，但它绝不是完美的，正如本文中的实验所示:

• 从 COBOL 到 Python : Codex 很容易出错，而且只有当 COBOL 的输入非常简单时，它才能生成任何类似 Python 的东西。否则，Codex 将默认吐出文本，而不是 Python。
• 从 COBOL 到 JavaScript : Codex 比 Python 更容易生成 JavaScript。除了本文描述的例子之外，我还在 COBOL 上练习了 Codex，当 JavaScript 是目标语言时，Codex 一致地生成代码。当 Python 是目标时，Codex 生成类似多次重复的无韵诗:“上面 COBOL 代码的 Python 版本在下面。”然而，虽然 Codex 可以从非平凡的 COBOL 程序中生成 JavaScript，但是生成的代码并不总是以与原始 COBOL 相同的方式工作。

我希望有机会更多地尝试将 Codex 从 COBOL 翻译成 JavaScript。本文中描述的实验并没有探索 Codex 在这方面的局限性，我想知道这些局限性是什么。

本文中描述的代码示例:

• 实验 1 的 Python 输出:https://github . com/ryanmark 1867/codex _ experience/blob/main/variables _ example . py
• 实验 2 的 Python 输出:https://github . com/ryanmark 1867/codex _ experience/blob/main/算术 _ simpled _ codex _ output . py
• 简化的 COBOL 算术程序:https://github . com/ryanmark 1867/codex _ experiment/blob/main/算术 _simplified.cbl
• 实验三的 JavaScript 输出(简化的 COBOL 输入):https://github . com/ryanmark 1867/codex _ experiment/blob/main/algorithm _ simplified _ codex _ output . py
• 实验三的 JavaScript 输出(全 COBOL 输入):https://github . com/ryanmark 1867/codex _ experiment/blob/main/算术 _example_codex_output.js

更多的方法意味着更好的代码

原文：https://towardsdatascience.com/more-methods-means-better-code-1d3b237f6cf2?source=collection_archive---------20-----------------------

如何使用提取技术来编写更好的代码？

(https://pixabay.com/images/id-1873831/

介绍

C 计算机编程可能非常复杂，并且很容易对计算机编程产生误解。这些误解会给你可能正在构建的软件带来很多问题。例如，一些函数经常重复代码，浪费了包内的空间，却没有完成多少工作。另一个常见的陷阱是非常长的、非结构化的代码，由于其长度和复杂性而难以阅读。这使得除了你自己，几乎任何人都无法接近代码，并且如果你打算和别人一起工作，会产生很多问题。

在编写软件时，避免使用方法是一件很糟糕的事情。的确，方法调用会让你的软件变慢。然而，方法调用对性能的影响是如此之小，以至于在大多数情况下都是微不足道的。避免使用方法调用只会对性能有一点点的提升，同时会使你的软件无法阅读并且不断重复。

命名您的代码

使用方法调用进行重构时，最重要的事情是给代码命名。这是一个很好的练习，对于程序员来说也是一个很好的实践。使用这种技术，我们可以将方法、模块或类型分成更小的部分，然后找到不同代码命名部分之间的相关性。命名代码后，我们就可以决定使用什么方法来使代码变得更好。考虑下面的函数，这是我为了将字典转换成 HTML5 表而编写的函数。

function _head(lookup::Dict, count::Int64 = 5; style::String = "classic")
    thead = "<thead><tr>"    
tbody = "<tbody>"
    [thead = string(thead, "<th>", string(name), "</th>") for name in keys(lookup)]
    thead = string(thead, "</thead>")
    cols = values(lookup)
    features = [push!(val) for val in cols]
    for i in 1:length(features[1])
        obs = [row[i] for row in features]
        tbody = string(tbody, "<tr>")
        [tbody = string(tbody, "<td>", observ, "</td>")
 for observ in obs]
        tbody = string(tbody, "</tr>")
    end
    tbody = string(tbody, "</tbody>")
    compisition = string(_css,"<table class = \"", style, "\">",     thead, tbody,"</table>")
    display("text/html", compisition)
end

这是一个算法的 Julia 版本，我也是用 Python 写的。如果您想了解我是如何编写 Python 等价物的，您可以在这里查看我写的关于它的文章:

虽然这个函数并不太长，也没有写得很糟糕，但是很难看一眼就决定如何改进。使用命名方法，我们可以识别代码库的较小部分，并一部分一部分地工作，而不会被整个函数淹没。让我们把这个函数分成几个确定的部分，它们在算法中有不同的用途。第一部分代码我称之为“参数和变量初始化部分”这通常适用于大多数方法，因为这是相当常见的编程技术。这部分代码创建了一些需要在函数的其余部分引用的变量，还包括方法别名的定义及其参数:

function _head(lookup::Dict, count::Int64 = 5; style::String = "classic")
    thead = "<thead><tr>"    
tbody = "<tbody>"

虽然我们在这里没有太多的重构工作可以做，但是获取这部分代码并理解它本身确实可以帮助我们理解代码的其他部分。代码的下一部分将列名连接到 thead 标记内的一行中，因此我们可以将这部分称为 header 部分:

[thead = string(thead, "<th>", string(name), "</th>") for name in keys(lookup)]
thead = string(thead, "</thead>")

这段代码在工作方面也没有什么需要改进的地方，因为这里的代码非常简洁，易于理解。幸运的是，理解了函数的参数和变量初始化部分，我们也可以更好地理解函数这一部分的代码，因为这一部分的结尾只是函数头初始化的逆过程。现在让我们看看下一部分，它是为我们的表体生成 HTML5 的，我们将把它命名为 body 部分:

cols = values(lookup)
    features = [push!(val) for val in cols]
    for i in 1:length(features[1])
        obs = [row[i] for row in features]
        tbody = string(tbody, "<tr>")
        [tbody = string(tbody, "<td>", observ, "</td>")
 for observ in obs]
        tbody = string(tbody, "</tr>")
    end
    tbody = string(tbody, "</tbody>")

这段代码比其他函数要广泛得多，而且肯定会有一些非常显著的变化。从新的角度来看这段代码，我们看到除了在参数和初始化部分声明的成员之外，所有的成员都是在这个部分中创建的。现在这已经不在代码中了，很容易看出前两行可以很容易地重构为一行代码:

cols = values(lookup)
    features = [push!(val) for val in cols]

变成了:

features = [push!(val) for val in values(lookup)]

观察它下面的迭代循环，我们还可以看到循环中有一个迭代循环:

for i in 1:length(features[1])
        obs = [row[i] for row in features]
        tbody = string(tbody, "<tr>")
        [tbody = string(tbody, "<td>", observ, "</td>")
 for observ in obs]
        tbody = string(tbody, "</tr>")
    end
    tbody = string(tbody, "</tbody>")

当然，为了将数据放入行中并填充行，这些循环是必要的，因为这个循环填充每一行的值，而不仅仅是一行。然而，当涉及到我们函数的这一部分时，用于清理这些方法的下一项技术肯定会派上用场。但是现在，让我们继续这个函数的结论，我称之为“完成并返回”函数的这一部分体现了我们之前在函数中所做的所有工作，并以一个返回来结束函数:

 compisition = string(_css,"<table class = \"", style, "\">",     thead, tbody,"</table>")
    display("text/html", compisition)
end

对于这部分功能，我们也没有太多可以改进的地方，这是完全可以接受的。

提取，血统

现在我们已经命名了函数的各个部分，接下来我们来讨论一个好的方法应该是什么样子。任何方法都要考虑的最重要的部分是 IO、输入和输出。根据我们命名的部分，这将是“参数和初始化”和“完成和返回”部分。函数的这些部分不能移动，它们是函数的主干。如果我们试图将参数移动到一个不同的函数中，请考虑我们将参数提供到一个不同的函数中——违背了目的。返回也是如此，成员变量需要在这个函数的作用域内声明，以便由函数使用或由函数返回，所以它们也属于这里。

记住这一点，对于提取技术，我们真的需要看看函数的其他命名部分，它们是:

• 头

[thead = string(thead, "<th>", string(name), "</th>") for name in keys(lookup)]
thead = string(thead, "</thead>")

• 主体(带有我们稍微修改过的代码)

 features = [push!(val) for val in values(lookup)]
    for i in 1:length(features[1])
        obs = [row[i] for row in features]
        tbody = string(tbody, "<tr>")
        [tbody = string(tbody, "<td>", observ, "</td>")
 for observ in obs]
        tbody = string(tbody, "</tr>")
    end
    tbody = string(tbody, "</tbody>")

函数的这两个部分当然可以是独立的函数。为了评估一个部分是否可能是它自己的函数，我们需要考虑这些部分的输入和输出——作为参数和返回，就像它们在新方法中一样。对于 thead 示例，我们需要传递 lookup 的键，或者 lookup 字典本身，并且我们可以期待 thead 字符串作为返回返回。至于 tbody 示例，我们需要将我们的特性作为参数传递，我们可以期待 tbody 字符串的返回。

鉴于头部相当短，只有两行代码，我们不太可能选择提取它。这里的代码意图非常清楚，在我们的方法中没有占用过多的空间，所以我们当然可以保留它。也就是说，有平等的机会提取它，这样做只是一个偏好的问题。另一方面，主体部分运行多达 9 行代码。客观地说，除了这一部分，我们方法的其余部分只有 8 行代码。这意味着仅这一部分就比我们整个函数的其余部分都要大！考虑到这一点，这当然是一个提取的候选人！现在让我们通过编写一个全新的函数来提取它:

function body(values)
    features = [push!(val) for val in values]
    for i in 1:length(features[1])
        obs = [row[i] for row in features]
        tbody = string(tbody, "<tr>")
        [tbody = string(tbody, "<td>", observ, "</td>")
 for observ in obs]
        tbody = string(tbody, "</tr>")
    end
    return(string(tbody, "</tbody>"))
endfunction _head(lookup::Dict, count::Int64 = 5; style::String = "classic")
    thead = "<thead><tr>"    
tbody = "<tbody>"
    [thead = string(thead, "<th>", string(name), "</th>") for name in keys(lookup)]
    thead = string(thead, "</thead>")
    tbody = body(values(lookup) compisition = string(_css,"<table class = \"", style, "\">",     thead, tbody,"</table>")
    display("text/html", compisition)
end

结论

许多程序员偏离了将他们的代码分成不同方法的做法。然而，这可能会产生许多可读性方面的问题，并且通常会使代码不那么简洁和易于使用。使用本文介绍的命名和提取技术，您可以保持代码的组织性和可读性，并使其他人更容易使用您的软件。我希望这篇文章能给你提供信息，也许能帮助你成为一名更好的程序员。非常感谢您的阅读！

事情并不象初看到的那样简单

原文：https://towardsdatascience.com/more-than-meets-the-eye-image-transformations-using-homography-and-texture-metrics-in-python-db03427c5091?source=collection_archive---------45-----------------------

Python 中使用单应性和纹理度量的图像变换

照片由 Cookie 在 Unsplash 上的 Pom 拍摄

在我以前的文章中，我讨论了图像处理的不同方法。其中一些是图像清理甚至物体检测。在这篇文章中，我们将更多地讨论图像的变换和特征生成，即:单应性和纹理度量。

单应

单应性可以进行的变换包括旋转、平移、缩放，甚至倾斜。这可以通过映射两个平面投影之间的坐标来实现。

这方面的一个例子是我们的文档扫描仪应用程序，其中纸张被转换为可读的视角。让我们以下面的代码为例来尝试一下:

作者图片

为了生成卡片的俯视图，我们必须计算单应矩阵。这是通过获得卡片角的坐标，以及卡片将被投影到自顶向下视图的坐标来实现的。

#import libraries
from skimage.io import imread, imshow
import matplotlib.pyplot as plt
import numpy as np#load the card
cards = imread('medium/cards.jpg')#initialize source and destination coordinates
src = np.array([319, 134,
                273, 61,
                133, 103,
                162, 188,
]).reshape((4, 2))dst = np.array([203, 37,
                314, 36,
                314, 181,
                203, 182,
]).reshape((4, 2))

对于我们希望图像呈现的投影类型，有不同类型的变换。因为我们希望保留卡片形状的线条，所以我们将使用投影类型的变换。不同的类型可以在这里找到供你参考。

#transform image point of view
from skimage import transform
tform = transform.estimate_transform('projective', src, dst)
tf_img = transform.warp(cards, tform.inverse)
fig, ax = plt.subplots()
ax.imshow(tf_img)
_ = ax.set_title('projective transformation')

作者图片

纹理度量

由于一些图像在本质上非常敏感，颜色信息可能在多个区域不一致，因此可以考虑另一种方法来表征我们的图像。纹理是这种替代形式，其中考虑了强度值的空间排列。

样本纹理度量可以通过使用熵作为度量来完成。熵的好处是它可以检测灰度中强度值的变化。给定下面的代码，我们可以看到熵在起作用

import matplotlib.pyplot as plt
import numpy as npfrom skimage import data
from skimage.util import img_as_ubyte
from skimage.filters.rank import entropy
from skimage.morphology import diskimage = img_as_ubyte(data.brick())fig, (ax0, ax1) = plt.subplots(ncols=2, figsize=(12, 4),
                               sharex=True, sharey=True)img0 = ax0.imshow(image, cmap=plt.cm.gray)
ax0.set_title("Image")
ax0.axis("off")
fig.colorbar(img0, ax=ax0)img1 = ax1.imshow(entropy(image, disk(5)), cmap='gray')
ax1.set_title("Entropy")
ax1.axis("off")
fig.colorbar(img1, ax=ax1)fig.tight_layout()plt.show()

作者图片

这就是你可以用单应性和纹理度量做的样本输出。

对我的工作感兴趣？你可以在我的个人资料中看到更多的故事

https://nico-aguila.medium.com/

不仅仅是文字——你的表情符号表达了很多

原文：https://towardsdatascience.com/more-than-words-your-emoji-says-a-lot-96f4ec21af23?source=collection_archive---------32-----------------------

三个表情符号解释器 Python 包的简要概述。

照片由多明戈·阿尔瓦雷斯 E 在 Unsplash 拍摄

几年前，我需要从 Twitter 数据流中检索 tweets，以完成关于在线说服分类的论文。正如任何第一个大规模研究项目所预期的那样，任何可能出错的事情都会出错。我在检索 8GB 的推文后发现的一个问题是，在所有编码之间的某个地方，所有东西都不可读，并且包含奇怪的符号和类似胡言乱语的字符——我怀疑一个可能的原因是表情符号。

这件事让我开始探索各种解释表情符号的 python 包。

表情符号

第一个包是emoji,它通过简单安装检索表情名称，反之亦然，如下例所示:

包文档截图https://pypi.org/project/emoji/

这是您可能想要与语言模型结合的包。你可以替换句子中的表情符号，并根据自己的喜好使用 NLP 模型。当使用 n-grams 时，将表情符号解释放在句子中的原始位置很重要，你可以通过标记化来做到这一点。

以下是从包文档中截取的截图代码，方便您使用:

>> import emoji
>> print(emoji.emojize('Python is :thumbs_up:'))
Python is 👍
>> print(emoji.emojize('Python is :thumbsup:', use_aliases=True))
Python is 👍
>> print(emoji.demojize('Python is 👍'))
Python is :thumbs_up:
>>> print(emoji.emojize("Python is fun :red_heart:"))
Python is fun ❤
>>> print(emoji.emojize("Python is fun :red_heart:",variant="emoji_type"))
Python is fun ❤️ #red heart, not black heart
>>> print(emoji.is_emoji("👍"))
True

emoji包很棒。它还支持除英语之外的其他语言，但如果你在一条推文或一个句子中有多个表情符号，该怎么办？在这种情况下，你可能会考虑为你原来句子中的所有表情符号创建一个字典，供以后使用。为此，更好的选择可能是demoji方案。它有一个选项，可以检索文本中出现的所有表情符号的字典。就我而言，这正是我所需要的，这样我就不会在处理数据时丢失信息。

德莫吉

demoji这个包的用法如下:

包文档截图https://pypi.org/project/demoji/

这个包demoji.findall()创建了一个表情符号的字典和它们与原文分开的解释。如果你想在语言模型中使用这个包，你需要使用demoji.replace()-它将取代表情符号。

另一个选项是demoji.replace_with_desc()，它用描述代码替换字符串中的表情符号。

为了方便您的使用，下面是从包文档中截取的截图代码:

>>> tweet = """\
... #startspreadingthenews yankees win great start by 🎅🏾 going 5strong innings with 5k’s🔥 🐂
... solo homerun 🌋🌋 with 2 solo homeruns and👹 3run homerun… 🤡 🚣🏼 👨🏽‍⚖️ with rbi’s … 🔥🔥
... 🇲🇽 and 🇳🇮 to close the game🔥🔥!!!….
... WHAT A GAME!!..
... """
>>> demoji.findall(tweet)
{
    "🔥": "fire",
    "🌋": "volcano",
    "👨🏽\u200d⚖️": "man judge: medium skin tone",
    "🎅🏾": "Santa Claus: medium-dark skin tone",
    "🇲🇽": "flag: Mexico",
    "👹": "ogre",
    "🤡": "clown face",
    "🇳🇮": "flag: Nicaragua",
    "🚣🏼": "person rowing boat: medium-light skin tone",
    "🐂": "ox",
}

DeepMoji

最后，在搜索适合我需求的包时，我找到了这个令人惊叹的 python 包deepmoji.顾名思义，这是一个基于深度学习的包，它检索了 N 个最相似的意思表情符号。

这个令人难以置信的软件包提供了一个全新的方法来分析数据，找到文本和作者之间的相似意义。

下面是一个基于 PyTorch 版本 torchMoji 实现 DeepMoji 包的简单教程:

我搜索了为特定任务解释表情符号的包，但它们有其他用途。你可能想考虑一个分析你的朋友或家人 WhatsApp 群组的项目:每个人都发送哪种表情符号？也许用 DeepMoji 对使用表情符号意义相近的成员进行分类？可能性是无限的。欢迎你在下面的评论中告诉我这些包可能对其他项目有用。有没有其他你喜欢的解释表情符号的 python 包？

强屈折语言的形态分析

原文：https://towardsdatascience.com/morphological-analysis-in-strongly-inflected-languages-623e2cc8a443?source=collection_archive---------29-----------------------

在数据科学中，如何有效地为具有丰富形态句法复杂性的非英语语言建立语言模型

托马斯·凯利在 Unsplash 上的照片

关键词 :自然语言处理、半监督训练、数据科学、命名实体识别、词性标注、语言模型、词法分析、词法分析、单词嵌入、文本分类

词法分析、NER(命名实体识别)和词性(词性)标注在 NLU(自然语言理解)中起着重要的作用，并且在强屈折(融合)的外语中可能变得特别困难，例如捷克语、德语、阿拉伯语或汉语，而一个单词可能有许多变体和后缀，这取决于其语法上下文(例如:捷克语名称:Jan — Honza — Honzík、Honzíkovi、Honzovi……)。因此，如果不将一个单词转换成其适当的引理形式，我们很难考虑任何文本分类，例如，将主格名词转换成其关于 NLG(自然语言生成)的假设语言情况。

我想到的一个外语通用方法的例子可能是使用 ULMFiT(一种基于迁移学习的方法)，在维基百科等大型文本语料库上进行训练，在目标语料库上进行微调，并使用它来编码您的文档。这可能会产生一个基本的分类模型，而当前的 FastAi 库实现 sentencecode 来将单词分割成标记(从而产生更小的词汇)使这项工作变得更加容易。当这可能花费时间和资源时，为 NER 标记数据和训练用于词性标记的语言模型是昂贵的。例如，如果没有这些步骤，我们将无法构建基于意图的聊天机器人。

这正是布拉格查尔斯大学数学和物理学院形式和应用语言学研究所作为开源软件发布的 MorphoDiTa 工具(形态学词典和标记器)的用处。它的特点是词汇识别和单词及语义标记(名、姓、公司、俚语、粗俗术语、位置、子位置、大小写等)，既可以作为独立的库使用，也可以通过 REST API 作为 web 服务使用。目前，它公开提供捷克语、斯洛伐克语和英语，但阿拉伯语也在开发中，该模型基本上可以为任何语言定制——只要有足够的标签数据。让我们从用户的角度简单了解一下它是如何工作的…

邮递员|作者的印刷屏幕

上面我们看到的是 Postman 中 API 的 JSON 响应。具体来说，我们用给定的参数调用分析方法。你能注意到的是，每个记号都有它的引理和标签。文档中描述了标记标志(参见参考资料)。例如，你可以看到单词“Jedeme”(“我们要去”)有它的词条“jet”(“去”)，它是一个动词(POS)，现在或未来形式(subPOS)。此外，还有 lemma 结构，当我们用 Python 迭代 json 文件时，这一点很明显，如下图所示。

VS 代码|作者打印屏幕

例如，你可以看到动词“jet”(“go”)有它的基本形式，并且有一个注释；单词“s”(“with”)有很多可能的缩写，用“:B”表示，这是一个撒克逊的外国风格的术语，用“，t”表示；并且还可以看到给定名称的文字形式(lemma("；y”)“Honza”就是“Jan”。

您可以在我的 GitHub repo 上看到完整的代码，并通过点击此处亲自体验一下。

如上面的简单例子所示，当您需要处理一门外语的丰富的形态句法复杂性时，MorphoDiTa 提供了一个有价值的工具。有了它，您可以轻松地将令牌转换为词条，然后在 NLU/NLP 部分中使用 FastText(它在生成词向量时会考虑 n 元语法)将这些词条进一步转换为语言模型。在基于意图的聊天机器人的情况下，这在理论上也可以作为一个实体提取器用于填充你的槽，因为所有这些信息都是需要的(例如语言格——与格:可能是接收东西的人、姓名、公司、时间、地点等)。)已经是形态分析的一部分。此外，您还可以在创建单词向量时使用这些信息作为特征，从而为包括英语在内的任何语言生成比没有词法分析丰富更准确的单词分类和预测模型。

如果没有 MorphoDiTa，非英语国家(占世界大多数)中与 NLP 相关的任何工作都将变得相当复杂，并且将处于研究领域的边缘，甚至是简单的开发和数据科学任务。
词法分析甚至可以为英语语言带来优于现有 NLP 库的好处。

参考文献:

• https://arxiv.org/pdf/1810.10222.pdf
• https://aclanthology.org/C12-1015.pdf
• https://aclanthology.org/P14-5003.pdf
• https://aclanthology.org/E09-1087.pdf
• https://ufal.mff.cuni.cz/morphodita
• https://github.com/ufal/morphodita
• https://lindat.mff.cuni.cz/repository/xmlui/handle/11234/1-1836
• https://ufal.mff.cuni.cz/pdt2.0/doc/manuals/en/m-layer/html/ch02.html

大多数业务经理不关心你可能学过的复杂算法

原文：https://towardsdatascience.com/most-business-managers-dont-care-about-fancy-algorithms-you-might-have-discovered-6ef7761310fa?source=collection_archive---------37-----------------------

数据科学的主要作者说。以下是他们在雇用数据科学家时实际寻找的东西。

Unsplash.com上的 Lucrezia Carnelos 的照片

你可能会惊讶地听到，大多数雇用数据科学家的商业领袖实际上并不关心你可能读过或学过的花哨的统计/ML 算法。当然，基于有抱负的数据希望者的意见，你必须在你的技术工具包下有复杂的、最先进的算法，这似乎是反直觉的。

但业内资深人士却不这么看。我在加州硅谷担任数据科学家才三年，但我对商业问题的复杂算法解决方案越来越怀疑和犹豫。以下是造成这种情况的基本原因，也是这些商业领袖在聘用数据科学家时所寻求的。

1.商业领袖“根本不关心复杂的算法”。

这种说法实际上直接来自的《傻瓜数据科学》(第二版)。作者莉莲·皮尔森写道:

“大多数业务经理和组织领导都不关心编码和复杂的统计算法。另一方面，他们对寻找通过提高销售率和减少低效来增加业务利润的新方法非常感兴趣。

虚拟数据科学

Lilian 谈到了我认为当今数据科学中最被误解的部分:它的实际目的。我遇到的许多有抱负的数据科学家对学习复杂的技术和算法更感兴趣，而不是理解这些算法如何被用来影响公司的底线。

我对 TradeRev(现在在 Acerta)ML 技术主管的 TDS 采访说明了一切。他在数据和软件工程领域拥有超过 15 年的行业经验，他告诉我:

“数据科学家通常关心模型、Jupyter 笔记本和超参数……但你需要考虑业务环境，机器学习如何适应业务。

[例如]考虑业务环境——ML 如何适应业务。ML 是商业的一部分，就像推荐系统一样。推荐系统不是业务，而是业务的一部分。"

如果你是一个经验丰富的行业老手，这种关于在技术冷静之前优先考虑业务环境的观点应该是很自然的。你知道，归根结底，重要的是业务，而不是算法。

但是作为一名有抱负的数据科学家，你可能会对这样的说法感到震惊。我见过太多的有志之士，他们花了无数的时间学习在权威期刊上发表的所有最新和最复杂的算法，希望学习算法所花的时间/金钱与工作成就直接相关。

不难看出为什么。机器/深度学习算法被神秘和敬畏所笼罩，市场上学习这些算法的过多课程似乎验证了它们在就业市场上的重要性，如果不是整个工作的话。

但诚实的事实是，在商业环境中，如果一家公司不能从这些算法中赚钱，它们就会被视为毫无意义的投资。很多时候，像深度强化学习这样的利基算法无法为一般的商业目的货币化，从而产生可观的收入。

以 Spotify(之前在 DoorDash 工作)的高级数据科学家 Jeffrey Li 为例，我在 TDS 采访过他。听听他对与求职面试体验相关的业务影响的看法:

根据我从评分带回家的经验，我在市场上看到的大多数数据科学家的最大陷阱或最大弱点是能够将机器学习模型与商业影响联系起来。所以很多非常非常聪明的人建立了这个非常复杂的五层神经网络，它能做出很好的预测，得分很高。

但是，当我们深入研究特定模型的业务影响时，他们通常很难回答这个问题。最终，我们需要机器学习对业务产生影响。这非常重要。

2.在私营公司，复杂性意味着风险。

在现实行业生活中，复杂性扼杀 ML 项目还有一个更具体的原因，那就是风险。脸书著名增长黑客、社交资本首席执行官查马斯·帕利哈帕蒂亚(Chamath Palihapatiya)认为，对硅谷科技公司的投资可以归结为以下两个方面:

作者图片

资本轻/密集是指生产一个产品需要多少资源和时间。显而易见/不显而易见指的是制造这种产品的商业案例有多显而易见。

许多成功的科技公司在考虑如何投入时间和资源开发产品或功能时，都遵循类似的原则。在数据科学的例子中，如果一个 ML 算法惊人的强大，但是没有明显的商业案例，没有企业或产品经理会批准这个项目。这就摒弃了数据科学家数月来一直致力于的模型，让他们永远生活在本地笔记本电脑中，只为收集灰尘。

大多数业务经理和组织领导不关心编码和复杂的统计算法。另一方面，他们对寻找通过提高销售率和减少低效来增加商业利润的新方法非常感兴趣。

资本要求也是如此。如果你不在一家资本过剩的公司，那么这家公司会对资源分配非常严格和有意识。现在，Covid 经济的情况更是如此，在这里，曾经自由的投资支出已经被资源保守主义所抵消。

但是在资本问题上还有另外一个例子。解决问题的算法越复杂，它给公司的技术生态系统带来的潜在风险就越大。风险越大，业务经理(尤其是没有数据背景的经理)就越不兴奋，因为如果部署的模型出现问题，他们必须直接承担部分责任。相信我。事情总是会出错。

例如，我们的 ML 技术主管 Amit 指出了一个在模型生产后可能出错的主要问题。他说，“现场数据可能与训练/测试数据有不同的分布”，这是一种你训练模型的数据和你在现实生活中收到的数据完全不同的情况，不管出于什么原因。有人称之为*特性漂移，*这是生产级数据科学家必须经常面对的一个常见问题。

💔-strategies-to-successfully-switch-to-a-thriving-data-science-career-5cf0cbe1f010>

另一个在模型生产中经常出现的问题是“模型错误，你的预测是错误的。”一般来说，随着技术解决方案变得越来越复杂和具有挑战性，更多的 bug 自然会堆积起来。

这些问题不会扼杀一个复杂的 ML 项目。关键是，如果在最初的项目范围确定期间没有正确评估风险，并且如果有更简单、资本更少(更精简)的解决方案可以产生更高的收入，经理们会选择后一种方法。

3.以下是在数据科学面试中这一切是如何进行的。

听听 Amit 和 Jeffrey 的经验丰富的想法，很明显，在数据科学行业，无论是应用周期还是更长的时间，不将新奇性置于适用性之上是一个常见的比喻。因此，简单的解决方法是反其道而行之。也就是说，寻找资本轻、业务明显的数据解决方案。

这里有一个例子。假设你被要求为一个带回家的访谈项目做一个异常检测预测任务。不要只是展示像 Prophet 这样的最先进的算法，而是要问一个问题，从工程和产品的角度来看，解决这个问题的最简单的方法是什么？

这可能意味着利用简单 IQR 或滚动平均作为阈值来创建异常指标。然后，您可以进一步使用中心极限定理，看看更多的统计方法如何改变异常检测的输出。

建立这种心态是至关重要的，因为它允许你从多个角度看问题，而不仅仅是从数据的角度。如果你对这种技能不熟悉，培养你的商业敏锐度的一个好方法是通读数据科学产品问题和产品设计问题。这可能看起来超出了数据学习的范围，但它将成为您的数据之旅中的基本要素。

每个人都应该知道的最常见的数据建模面试问题

原文：https://towardsdatascience.com/most-common-data-modelling-interview-questions-4055adf79229?source=collection_archive---------6-----------------------

了解 SQL、NoSQL、关系数据库等的基础知识…

图片由 Unsplash 上的新数据服务提供

本文将讨论一些在面试中最常被问到的关于数据建模的基本问题。在您的数据科学之旅中掌握数据建模是非常有益的，对于初学者来说，一开始可能会不知所措，但通过实践，它可以产生巨大的回报。

什么是数据建模？

简单地说，为家庭账单创建电子表格的行为就是数据建模。

定义:“…组织数据元素以及它们如何相互关联的抽象概念…”

数据建模可以很容易地转化为数据库建模，因为这是基本的最终状态。对于任何参与准备、分析和处理数据的人来说，这是一项重要的技能。正如你所猜测的，这肯定是一个迭代过程。数据工程师、数据科学家、软件工程师、开发人员等..不断重组、重构和优化数据模型，以满足组织的需求。

现在回到最初的问题，那么如果数据建模是组织数据元素和定义关系的行为，为什么不能像我们的家庭示例一样，在 Excel 中创建和存储所有内容呢？

Excel 电子表格中可以存储的数据量有很多限制。因此，数据库有助于将元素组织成表格——行和列等。基本操作(如大规模读写)是无法用 Excel 表完成的，因此最好使用数据库来处理大多数业务功能。

作者图片

数据模型的三种类型是什么？

三种类型的数据模型:

• 概念数据模型 —这关注于所讨论的数据的非常高级的用户视图(实体映射)。
• 物理数据模型 —这是模式(表的集合)描述数据如何物理存储在数据库中的地方。
• 逻辑数据模型 —该模型位于概念模型和数据模型之间，允许数据的逻辑表示脱离物理存储而存在。

鸣谢:斯里·普拉卡什，来源:https://www.pinterest.co.uk/pin/218917231859820120/

作者图片

数据建模有什么好处？

数据建模使开发人员、数据架构师、业务分析师和其他利益相关者更容易查看和理解数据库或数据仓库中数据之间的关系。简单来说:

• 减少软件和数据库开发中的错误。
• 提高整个企业中文档和系统设计的一致性。
• 提高应用程序和数据库性能。
• 简化整个组织的数据映射过程。
• 改善开发人员和商业智能团队之间的沟通。
• 在概念、逻辑和物理层面简化和加速数据库设计过程。

什么是关系模型？

该模型将数据组织到一个或多个由列和行组成的表中，用唯一的键标识每一行。

什么是关系数据库？

它是基于数据关系模型的数字数据库，用于维护关系数据库的软件系统是关系数据库管理系统(RDBMS)。

常见的关系数据库类型: Oracle、Teradata、Mysql、PostgreSQL、Sqlite

使用关系数据库的优势是什么？

一旦数据被转换为行和列格式，数据就被标准化了，可以用 SQL 查询。

• 灵活地添加表，改变表，添加和删除数据。
• 数据完整性是使用关系数据库的基础。
• 数据以表格格式系统地存储和建模。
• 如果你有一个较小的数据量(不是大数据)，你可以使用一个简单的关系数据库。
• ACID 事务:这允许满足数据库事务的一组属性，以通过保持数据完整性来保证有效性，即使在出现错误、断电的情况下也是如此。

什么是主键？

主键是唯一标识关系数据库管理系统表中每一行的一列或一组列。

什么是外键？

外键是在两个表之间创建关系的列。外键的目的是维护数据完整性，并允许在一个实体的两个不同实例之间导航。

主要差异

作者图片

什么是正常化？

规范化 是为了减少数据冗余和增加数据完整性，按照一系列范式构建关系数据库的过程。

什么是反规格化？

反规范化 是通过添加数据的冗余副本，以损失一些写性能为代价，试图提高数据库的读性能的过程。简而言之，这意味着拥有数据的重复拷贝，这看起来像是一个不自然的过程，但是必须在读取量大的工作负载中执行该过程，以提高性能。

OLAP 和 OLTP 有什么区别？

数据库被设计为将结构化数据存储为可以使用 SQL 查询读取的表。数据必须遵循严格的模式，这允许(DBMS)极大地协同优化数据存储和处理。

也就是说，它们将磁盘文件中数据和索引的内部布局与其高度优化的查询处理查询紧密分离，从而为存储的数据提供非常快速的计算，并为所有读/写操作提供强大的事务 ACID 保证。

数据库上的 SQL 工作负载可以分为两类:

• 在线事务处理(OLTP): 这些通常是高并发、低延迟的简单查询，一次读取或更新几条记录:就像银行账户事务一样
• 在线分析处理(OLAP): 这些工作负载类似于定期报告，是典型的复杂查询(涉及聚集和连接)，需要对许多记录进行高吞吐量扫描。

作者图片

星型与雪花型模式比较

作者图片

列出不同之处

作者图片

何时不使用关系数据库？

• 拥有大量数据
• 需要能够存储不同的数据类型格式
• 需要高吞吐量—快速读取
• 需要灵活的模式
• 需要高可用性:表示系统始终运行，没有停机时间
• 需要横向可扩展性

什么是 NoSql？

作者图片

SQL 与无 SQL

作者图片

NoSQL 数据库的类型

NoSQL 数据库主要分为四类:

1)键值

2)基于列

3)基于图形

4)基于文档。

以上指定的数据库没有一个能更好地解决所有问题。根据产品需求选择数据库总是最好的。

Key-Value: 这些数据库在一个简单的数据模型上工作，这个模型有一对惟一的键和一个与之相关联的值。这种类型的数据库运行高效，并显示出高度的可伸缩性，例如:在缓存 web 应用和会话管理中。

一些例子:Redis、Memcached

**基于文档:**这些数据库以文档格式存储半结构化数据及其描述。它们非常类似于键/值数据库。它们基于键/值存储数据，类似于键-值数据库，唯一的区别是值以 XML、JSON、BSON 的形式存储。这些主要用于移动应用数据处理和内容管理。

作者图片

一些例子:MongoDB、Terrastore、RavenDB

**基于列:**这些数据库以列而不是行来组织数据。这些行有许多与特定行相关联的列。列族包含我们可以一起访问的一组相关数据，这意味着它们可以比其他传统数据库更快地查询大型数据集。这些主要用于欺诈检测推荐引擎和目录。

作者图片

一些例子:Cassandra，Hbase，Hypertable，Amazon DynamoDB

**图形存储:**这些数据库将数据组织成节点和显示节点之间连接的边。这些用于映射关系，例如映射客户关系或预订管理系统。

与表松散连接的传统关系数据库相比，图数据库本质上是多关系的。遍历关系尤其重要，因为它们已经被捕获到数据库中，不需要计算它们。它们主要用于社交网络、物流和空间数据。

作者图片

一些例子:Neo4J，Dgraph，Amazon Neptune，OrientDB

17)什么是 CAP 定理？

CAP 定理证明了任何分布式系统都不能同时保证 C、A 和 P。换句话说，它表明分布式系统不可能提供三分之二以上的保证。

1. 一致性:即使在一个操作执行之后，数据也应该保持一致。例如，在更新数据库之后，我们运行的所有查询应该产生相同的结果。
2. **可用性:**数据库不应该有任何停机时间，它应该始终可用并且响应迅速。
3. **分区容忍度:**即使服务器之间的通信不稳定，系统也应该继续运行。

来源:https://www.xenonstack.com/blog/nosql-databases/

如果你想更多地了解 NoSQL，我强烈推荐这个关于这个话题的写得很好的博客:https://www.xenonstack.com/blog/nosql-databases/

感谢阅读！

恭喜你！你坚持到了最后。我希望这些关于数据建模的问题对您有所帮助和启发。如果你已经知道所有这些，我很高兴刷新你的记忆和技能。我会不时更新这个列表，提出更多的问题。谢谢:)

更多阅读:

最重要的随机数 Python 模块，永远在你身边

原文：https://towardsdatascience.com/most-important-random-number-python-modules-to-keep-always-by-your-side-ef99a4ae624b?source=collection_archive---------29-----------------------

随机生成的数字的指数、正态和泊松分布函数的直方图，使用第三节中的 Python 代码创建。在所有地块中，使用了 5000 个随机产生的数字大小的样本。作者出于教育目的创作的图形。

介绍

在数据科学、统计建模、机器学习和绘图中，由于多种原因，人们经常需要生成随机数据进行模拟。有许多编程语言可以用来生成随机数和数据，在本文中，我想特别关注 Python 编程语言。在本文中，我将向您展示哪些是可以帮助用户生成随机数据的最重要的 Python 库和模块。

这篇文章背后的原因是因为我观察到，在大多数教学材料、关于 Python 和数据科学的书籍中，他们只是彻底地提到了随机数生成函数，而没有专门的一节来介绍它们。显然，在本文中，我将选择这些库和模块中最重要的一些，我认为它们通常在数据科学中最常用，因此，我的选择并不完整，因为我不会讨论现有随机数模块的全部范围。像往常一样，在本文中，我假设读者了解基本的 Python 和它的一些库。

I .不安全的随机数模块

Python 和许多其他程序中的随机数生成实际上并不是完全“随机”的，而是具有确定性的成分。为此，这些生成的数字被称为伪随机数。下面，当我写一个“随机数”时，你应该明白我指的是伪随机数。Python 和其他程序生成伪随机数的原因是，需要使用一个初始值来开始随机数生成序列，这个初始值通常被称为种子数。

基本的 Python 发行版都有一个名为 random 的默认模块，负责随机数的生成。这是生成具有不同分布函数的不同随机数时要调用的核心模块。然而，这个模块不能生成用于加密的安全随机数，这就是为什么它被称为不安全随机数模块。密码生成的随机数通常用于生成安全令牌、密码等。

1。random . seed(a =无，版本=2)

该子模块用于修复和初始化随机数发生器。Python 中的种子号用于在没有运行多线程的情况下复制相同的随机数序列。例如，如果我将种子值设置为特定的数字、字符串等。如果使用相同的调用函数以相同的顺序调用，使用与我相同的种子号的另一个用户将获得相同的随机数序列。

random.seed() 模块的第一个参数 a 是种子的值，第二个参数是要使用的 Python 版本，其中 version=2 是默认版本。对于 Python 以上的版本，种子值 a 可以是[int](https://docs.python.org/3/library/functions.html#int)、[float](https://docs.python.org/3/library/functions.html#float)、[str](https://docs.python.org/3/library/stdtypes.html#str)、[bytes](https://docs.python.org/3/library/stdtypes.html#bytes)或[bytearray](https://docs.python.org/3/library/stdtypes.html#bytearray)。例如，在本文中，我将使用种子值 1，即 a=1 来生成随机数。首先，我使用以下 Python 代码:

[In]: **import** random 
[In]: random.seed(a = 1)

在上面的代码中，种子从 a=1 的值开始，但是可以使用任何值。如果你在你的计算机中设置了相同的种子值，你应该在下面生成和我一样的数字序列。

2. random.randint(a，b)

该子模块生成区间[a，b]中的随机整数，包括区间极值。如果我选择，a = 0，b = 10，我得到例如:

[In]: random.randint(a = 0, b = 10)
[Out]: 2

3.random.randrange ( 开始，停止=无，步进=1 )

该子模块在半开区间[a，b]内生成整数，默认步长为 1。这个函数与 *random.randint()，*相同，如果我们用 b+1 代替 b，或者等价地， random.randint(a，b) 和 *random.randrange(a，b+1)如果在random . seed(a = 1)**之后立即被分别调用，它们将给出相同的随机数。*例如，如果我在第 2 节的代码之后运行下面的代码，我会得到:

[In]: random.randrange(start = 0, stop = 11)
[Out]: 9

如您所见，结果与前面的代码不同，因为它们是按顺序执行的。但是，如果您独立执行这些代码，您会得到相同的结果。

4.随机选择(序列)

该子模块使用户可以从给定的序列列表中选择一个随机数。例如，假设我有一个列表，l = [1，4。，8，9.6，30]，然后运行下面的代码:

[In]: l = [1, 4., 8, 9.6, 30]
[In]: random.choice(list)
[Out]: 1

在上面的例子中，我使用了一个数字列表，但是序列可以是字符串、元组、范围等。

5.随机. random()

这个子模块在半开区间[0，1]产生一个随机数(浮点)。如果我在前面的代码之后依次运行下面的代码，我会得到:

[In]: random.random()
[Out]: 0.2550690257394217

6.随机高斯(μ，σ)

该子模块为用户提供了从随机数的高斯分布中生成随机数的可能性，其中均值=μ，标准差=σ。例如，如果我选择平均值 = 0 ，并且∑= 1，我得到:

[In]: random.gauss(mu = 0, sigma = 1)
[Out]: -1.0921732151041414

7.随机指数变量

的这个子模块根据指数概率分布函数生成随机数，其表达式如下

指数概率分布函数在物理学、生物学、水文学等不同的科学领域都是非常重要的。例如，在物理学中，放射性粒子衰变分布近似遵循函数(1)。参数𝜆称为速率参数，它是一个大于零的正数。对于给定的随机变量 X ，其期望值为 E (X) = 1/𝜆 ，方差为 Var(X) = 1/𝜆。所以遵循指数概率分布函数的随机变量 X 的均值为 *= 1/𝜆，*其中𝜆必须不为零。

例如，为了生成服从分布(1)且 *= 2 的随机数，*我运行以下 Python 代码:

[Int]: random.expovariate(lambda = 1/2)
[Out]: 2.108767728131761

8.随机均匀(a，b)

该子模块在区间[a，b]中生成均匀分布的浮点数，包括极值 a，但是极值 b 可能包括也可能不包括，这取决于舍入。例如，为了从区间[0，10]中的均匀分布生成一个随机数，我在上面第 7 点中的代码之后运行下面的代码(请注意代码的顺序，以生成与这里给出的输出相同的输出):

[In]: random.uniform(a = 0, b = 10)
[Out]: 7.887233511355132

我上面描述的八个随机数模块有一个核心模块，Python 的 random 模块。然而，Python 中有一些基本上基于上述随机模块的库，允许用户执行快速有效的数值计算。在这些图书馆中，有一个是 T21 图书馆。NumPy 有很多随机数模块，可以用来生成数字和数组。为了简化符号，首先我导入 NumPy:

[In]: **import** numpy **as** np
[In]: np.random.seed(a = 2)

在导入 NumPy 之后，我还导入了 random.seed()模块来设置 NumPy 生成器的种子。这个模块是第 1 点中 random.seed()的 NumPy 等价物。为了简单起见，我选择种子的值等于 2。下面讨论 NumPy 最重要的随机数子模块。

9.np.random.rand(d0，d1，…，dn)

NumPy 的这个子模块在半开区间[0，1]内生成随机数和填充有个均匀分布的个随机数的不同形状的数组。如果没有给这个子模块一个参数，它将返回一个区间为[0，1]的随机数。如果给定一个参数，则返回一维 NumPy 数组。如果给定多个参数，将返回一个多维数组。以下 Python 代码使这些概念更加清晰:

[In]: np.random.rand()
[Out]: 0.43599490214200376[In]: np.random.rand(d0 = 3)
[Out]: array([0.02592623, 0.54966248, 0.43532239])[In]: np.random(d0 = 3, d1 = 2)
[Out]: array([[0.4203678 , 0.33033482],
       [0.20464863, 0.61927097],
       [0.29965467, 0.26682728]])

**NP . rand()**模块与NP . random()模块有相似之处，我不在本文中介绍。

10.randn(d0，d1，…，dn)

NumPy 的这个子模块允许用户从均值为零且标准差等于 1 的正态分布中生成一个或多个随机数据样本。元组(d0，d1，…，dn)必须是正整数，它的存在是可选的。元组的大小表示返回数组的维数。如果没有给函数 **np.random.randn()，**赋值，那么它的输出就是一个来自正态分布的随机浮点数。如果只有一个数字作为参数给出，则输出是一个浮点一维 NumPy 数组，其分量等于给定的参数值。如果给定了多个数字作为参数，该函数将返回一个具有特定维度和组件的浮点多维数组。下面的例子让事情变得更清楚:

[Int]: np.random.randn()
[Out]: 0.5514540445464243[In]: np.random.randn(d0 = 4)
[Out]: array([ 2.29220801,  0.04153939, -1.11792545,  0.53905832])[In]: np.random.randn(d0 = 3, d1 = 3)
[Out]: array([[-0.5961597 , -0.0191305 ,  1.17500122],
       [-0.74787095,  0.00902525, -0.87810789],
       [-0.15643417,  0.25657045, -0.98877905]])

NumPy 模块NP . random . standard _ normal()与 **np.random.rand()，**非常相似，唯一的区别是前者以一个整数或一组整数作为参数。

11.np.random.randint(low，high = None，size = None，dtype = 'I ')

NumPy 的这个子模块在半开区间[低，高]从离散的均匀概率分布函数生成随机整数。在 high = None 的情况下，该子模块生成区间[0，low 内的整数。大小通常是一个整数或整数元组，它指定输出 ndarray 或整数的大小。以下示例有助于更好地理解该子模块:

[In]: np.random.randint(low = 3, high = None, size = 4)
[Out]: array([2, 0, 2, 1])[In]: np.random.randint(low = 3, high = 10, size = 4)
[Out]: array([9, 3, 5, 8])[In]: np.random.randint(low = 0, high = 10, size = (2, 2))
[Out]: array([[9, 8],
       [7, 1]])

12.np.random.exponential(scale = 1，size = None)

NumPy 的这个子模块从指数概率分布函数(1)生成样本。比例参数等于 1/𝜆，，其默认值等于 1。size 指定从分布(1)中生成的数字样本的大小。这里有一些具体的例子:

[In]: np.random.exponential(scale = 2, size = 1)
[Out]: array([1.89881464])[In]: np.random.exponential(scale = 2)
[Out]: 9.388438956222803[In]: np.random.exponential(scale = 3, size = (2, 2))
[Out]: array([[0.38174426, 0.48249559],
       [5.73733106, 2.13714827]])[In]: np.random.exponential(scale = 3, size = (1, 2, 2))
[Out]: array([[[ 0.73490213, 15.00188906],
        [ 1.13631244,  0.89818388]]])

13.np.random.binomial(n，p，size = None)

NumPy 的这个子模块从二项式分布函数生成标量数和数组。这里我假设读者知道这种在统计学中非常重要的分布函数。自变量 n 是试验次数，p 是每次试验成功的概率。概率 p 在区间[0，1]内，试验次数 n 是大于或等于零的正数。size 指定输出数组的维度。以下示例有助于理解该子模块:

[In]: np.random.binomial(n = 1, p = 1/2, size = None)
[Out]: 1[In]: np.random.binomial(n = 10, p = 1/3, size = (2, 2, 2))
[Out]: array([[[3, 3],
        [2, 5]],

       [[5, 6],
        [5, 3]]])[In]: np.random.binomial(n = 0, p = 0.4, size = 3)
[Out]: array([0, 0, 0])[In]: np.random.binomial(n = (1, 2, 4), p = (0.1, 0.5, 0.4), size = 3)
[Out]: array([0, 2, 2])

14.np.random.poisson(lam = 1.0，size = None)

NumPy 的这个子模块根据泊松概率分布函数生成标量数和数组。即使在这里，我也假设读者知道这个分布、它的参数和它的性质。第一个参数是 k 个事件应该发生的区间 𝜆 。参数 𝜆 可以是标量，也可以是类似数组的标量。size 可以是 None，也可以是指定输出多维数组形状的 tuple。这些示例有助于理解该子模块:

[In]: np.random.poisson(lam = 2, size = None)
[Out]: 4[In]: np.random.poisson(lam = 2, size = 4)
[Out]: array([4, 3, 1, 2])[In]: np.random.poisson(lam = (1, 3, 4), size = (3, 3))
[Out]: array([[0, 6, 7],
       [3, 5, 9],
       [3, 2, 4]])

二。安全随机数模块

第二节中讨论的所有模块都不是生成随机数和随机数数组的安全模块。Python 为用户提供了通过 secrets Python 模块生成安全随机数和字节的可能性。这个模块为加密、密码、令牌等创建随机数和字节。在本文中，我不会讨论这个模块，读者可以在上面的链接中找到更多信息。

三。绘制随机数据

上面描述的随机模块对于在许多情况下创建模拟图非常有用。它们可用于检查特定概率分布函数的行为，可用于将实际数据分布与众所周知的概率分布(如泊松、正态、伯努利分布等)进行比较。在下面的 Python 代码中，我使用了上面解释的一些随机数模块来创建本文顶部显示的图形。Python 代码是:

[In]: **import** numpy **as** np
[In]: **import** matplotlib.pyplot **as** plt 
[In]: import **seaborn** as **sns**
[In]: sns.set(style="whitegrid")
[In]: np.random.seed(10)[In]: fig, axs=plt.subplots(1, 3, figsize=(15, 6))
axs[0].hist(np.random.exponential(scale = 1, size = 10000), color = "r")
axs[0].set_title("Exponentially distributed random numbers")
axs[1].hist(np.random.randn(10000), color = "m") 
axs[1].set_title("Normally distributed random numbers")
axs[2].hist(np.random.poisson(lam = 5, size = 10000), color = "k")
axs[2].set_title("Poisson distributed random numbers")

四。结论

在本文中，我讨论了 Python 中最重要的随机数模块。正如我在开始时提到的，我的列表并不完整，因为还有其他模块，但我试图尽可能不偏不倚地列出我的列表，它由那些通常在数据科学中最常用的模块组成。

如果想要简单的随机数用于一般目的，那么内置的 Python 模块 random 就足够了。如果想要创建随机数和填充随机数的数组，那么 NumPy random 模块可能是最好的选择。可以使用这个模块进行模拟，并创建模拟图，如第三节所示。

如果你喜欢我的文章，请与你可能对这个话题感兴趣的朋友分享，并在你的研究中引用/参考我的文章。不要忘记订阅将来会发布的其他相关主题。

最流行的共指消解框架

原文：https://towardsdatascience.com/most-popular-coreference-resolution-frameworks-574ba8a8cc2d?source=collection_archive---------9-----------------------

最好的共指消解模型是什么？选一个看什么？

作者 玛尔塔·马朗考斯卡 和 帕韦·米耶尼克祖克 。

照片由玛丽·赫林拍摄

快速回顾一下

这是我们上一篇 共指消解 介绍的后续文章。如果你正在寻找一个有例子支持的好的理论背景，我们推荐它。反过来，本文涵盖了最流行的共指消解库，同时展示了它们的优缺点。

简单回顾一下——共指消解(CR)是一项具有挑战性的自然语言处理(NLP)任务。它的目的是将指同一现实世界实体的表达组合在一起，以获得不那么模糊的文本。它在文本理解、问题回答和摘要等任务中很有用。

通过示例进行共指消解

通过使用共指消解，我们希望得到一个明确的句子——一个不需要任何额外上下文就能理解的句子。预期的结果显示在下面的简单示例中(而将 CR 应用到文本的详细过程显示在前面的简介文章中):

步骤 1 —选择一个句子来分析或嵌入并检测歧义词(提及)

步骤 2-将检测到的范围与剩余句子中的其他提及/真实单词实体进行分组

步骤 3-用最有意义的真实世界实体解决相互引用

第四步——获得一个明确的句子

研究动机

在 NLP 系统中，共指消解通常只是整个项目的一部分。像大多数人一样，我们也更喜欢利用经过充分测试的现成解决方案，这些解决方案只需要一些微调，而不需要从头开始编写任何东西。

有许多关于共指消解的有价值的研究论文。然而，并不是所有的都有简单明了的实现。

我们的目标是找到一个生产就绪的开源库，它可以很容易地整合到我们的项目中。

顶级图书馆

有许多关于 CR 的开源项目，但在对当前最先进的解决方案进行全面研究后，到目前为止，最突出的两个库是 Huggingface NeuralCoref 和 AllenNLP。

拥抱脸

我们不会进入详细的实现，但 Huggingface 的neural corf使用神经网络解决了相互引用，并且基于一个优秀的 spaCy 库，任何关注 NLP 的人都应该烂熟于心。

该库有一个简单易懂的自述文件，涵盖了基本用法。但是我们发现这个库最大的优点是它允许简单的访问底层空间结构并在其上扩展。spaCy 将句子解析成文档、跨度和标记。Huggingface 的 NeuralCoref 为它们增加了更多的特性，例如，给定的区间是否有任何共同引用，或者一个令牌是否在任何簇中，等等。

此外，该库有多个可配置的参数，例如算法应该如何贪婪地行动。然而，经过大量测试后，我们发现默认参数在大多数情况下效果最好。

还有一个演示可以标记所有有意义的跨度，并显示网络的输出——其中提到指的是哪个。它也给出了关于分配分数的信息，以及每个提及对是如何相似的。

这个演示对于简短的文本来说效果很好，但是由于输出显示在一行中，如果查询变得太大，就不容易阅读了。

不幸的是，还有一个更重要的问题。在撰写本文时，演示比代码中的实现效果更好。我们已经测试了许多参数和底层模型，但我们无法获得与演示完全相同的结果。

社区在其 Github 的多篇文章中进一步证实了这一点，关于如何获得与演示页面上相同的模型，回答非常模糊和不准确——通常归结为“您必须试验不同的参数和模型，看看什么最适合您”。

艾伦 LP

艾伦人工智能研究所(简称 AI2)可能是自然语言处理领域最著名的研究小组。他们是 ELMo 等模型的发明者。他们的项目名为 AllenNLP，是一个开源库，用于为各种 NLP 任务建立深度学习模型。

这是一个巨大的库，有许多基于 PyTorch 构建的模型，其中一个是我们使用的预先训练的共指消解模型，它基于这篇论文。

同样，AllenNLP 也有一个演示。它非常清晰易懂，尤其是在输出方面。它的结构是多行的，可读性很好。然而，与 Huggingface 不同，相似性细节在这里是模糊的，即使从代码中也不容易访问。

然而，AllenNLP 共指消解并不是没有问题。当你第一次执行他们的 Python 代码时，结果非常混乱，很难知道如何理解它们。

AllenNLP 倾向于找到更好的聚类，然而，它经常解析它们，导致无意义的句子。

然而，正如我们在后面提到的，我们已经应用了一些技术来解决这个库及其使用中的大多数问题。

详细比较

就像库一样，有许多不同的数据集是为共指消解而设计的。一些值得一提的是 OntoNotes 和 PreCo 数据集。但最符合我们需求并获得商业使用许可的是 GAP dataset，它是由谷歌开发的，于 2018 年发布。

该数据集由近 9000 对有标签的歧义代词和先行词组成。由于 pairs 是从维基百科中取样的，它们提供了现实世界文本所带来的不同挑战的广泛覆盖面。数据集可以在 Github 上下载。

我们已经在整个 GAP 数据集上运行了几次测试，但真正给我们带来最大收获的是手动检查每一对并精确分析中间聚类以及获得的结果。

下面是数据集中的一个例子，其中包含关于热狗历史的信息。

从现在起，我们将 Huggingface NeuralCoref 实现称为“Huggingface ”,将 Allen Institute 提供的实现称为“AllenNLP”。

原句

提及通过 Huggingface 找到的对

提及由 AllenNLP 找到的配对

最常见的 CR 问题

提及通过 Huggingface 获得的集群

提及 AllenNLP 收购的集群

非常长的跨度

很难说获得长跨距是否是一种优势。一方面，长跨度捕捉到了上下文，并告诉我们更多关于我们正在寻找的真实世界的实体。另一方面，它们通常包含太多的信息。

例如，第一个 AllenNLP 聚类由一个很长的提及来表示:费尔特曼的一个波兰裔美国雇员，名叫内森·汉德沃克。我们可能不想用如此广泛的表达来替换每个代词，尤其是在嵌套跨度的情况下:

相反，Huggingface 只会用单词 Handwerker 替换第一组中的所有提及。在这种情况下，我们将失去 Handwerker 的姓名、国籍以及与 Feltman 关系的信息。

嵌套共指提及

在 GAP 示例中，我们看到嵌套的跨度—一个(或多个)提及在另一个提及的范围内:

根据 CR 解析策略，嵌套跨度中的提及可以被替换或不被替换，但这完全取决于个人偏好——通常很难说哪种方法最适合数据。这可以从下面的例子中看出，对于每一个例子，不同的策略似乎是最合适的:

不正确的语法形式

缩写是浓缩的表达形式，通常通过使用撇号获得，例如:

AllenNLP 将某些缩写视为一个整体，用不正确的语法形式替换其他提及:

在这种情况下，Huggingface 通过始终采用名词短语的基本形式来避免这个问题。然而，这也可能导致不正确的句子:

这是因为所有格形容词和代词的出现——当一个集群是由主语和所有格组成的时候。

不幸的是，这两个库都存在这个问题。然而，AllenNLP 检测到几个 POS(词性)标签，并试图在某些情况下处理这个问题(尽管并不总是获得预期的效果)。

查找冗余 CR 群集

例如，不需要的聚类是所讨论的文本片段中的第二个拥抱脸聚类。将的前雇主替换为的前雇主并不能提供任何额外的信息。类似地，当一个集群不包含任何名词短语或仅由代词组成时，很可能是不必要的。这些类型的聚类可能导致语法错误的句子，如下例所示。

下传检测

我们之前已经全面描述了回指和下指的问题，后一个问题特别棘手，因为它更难捕捉，并且经常导致错误的提及替换。

Huggingface 在 cataphora 检测方面存在问题，而 AllenNLP 总是将聚类中的第一个区间视为代表性区间。

利弊

为了方便起见，我们还构建了一个两个库的主要优缺点的表格，这是我们在与它们合作的过程中发现的。

拥抱脸

✔演示提供有价值的信息
✔易于使用
✔与 spaCy 兼容

✘ 演示的工作方式不同于 Python 代码😞 ✘ 不处理下指
✘ 经常发现冗余簇

AllenNLP

✔非常清晰的演示
✔检测所有格
✔检测下指

✘代码使用起来不直观
✘经常生成太长的簇
✘有时会错误地处理所有格
✘原始地解决共指经常导致语法不正确的句子

我们还发现有趣的是，Huggingface 通常定位更少的集群，因此替代提及的频率更低。相比之下，AllenNLP 似乎更“积极”地替换提及对，因为它发现了更多的聚类。

摘要

在本文中，我们讨论了最著名的共指消解库，以及我们使用它们的经验。我们也展示了它们的优势，并指出了它们带来的问题。

在本系列的下一篇也是最后一篇文章中，我们将展示我们是如何成功实现它们的。我们将展示如何在某种程度上把它们结合成一个解决方案，通过取长补短，利用对方的优势来解决问题。

如果你想使用这些库中的任何一个，我们还提供了两个更详细的笔记本，你可以在我们的 NeuroSYS GitHub 上找到。

更多类似的文章请看一下 神经系统博客 。

第三部分— 如何建立有效的共指消解模型

参考

[1]: 聊天机器人最先进的神经共指消解 — Thomas Wolf (2017)

[2]:—Kenton Lee，Luheng He，，Luke Zettlemoyer (2017)

MATLAB 中基于运动的目标检测与跟踪

原文：https://towardsdatascience.com/motion-based-object-detection-and-tracking-in-matlab-5713f08362ff?source=collection_archive---------26-----------------------

基于运动的多目标跟踪算法在悬停无人机视频中的实现

作者图片

检测和跟踪全运动视频中的对象具有重要的应用，例如交通监控、安全和视频监控等。尽管它有各种各样的用途，但是由于它的复杂性，大多数人倾向于回避做任何计算机视觉工作，而没有意识到有许多库和软件包可以使实现变得简单。

这里介绍的是一个简单易懂的指南，用于理解和实现 Matlab 的基于运动的多对象跟踪算法，以便您可以在自己的视频中检测和跟踪移动对象。该算法在一个视频上进行测试，其中一个场景是从一架悬停的无人机上拍摄和记录的。

基于运动的多目标跟踪算法

我们将使用 Mathworks 的 Matlab 代码，可在这里获得。

在后面的讨论中，有几个术语是很重要的，下图说明了每一个术语。

相关术语以及它们对应于每个帧的哪个部分。作者图片

上面显示的术语也在这里定义:

• 物体识别号或物体 id 用于区分不同的物体。
• 物体包围盒是包围被检测物体的盒子
• 帧 X 轴是每帧中沿水平线的像素坐标轴
• 帧 Y 轴是每帧中沿垂直线的像素坐标轴
• 物体质心由 x 像素坐标和 y 像素坐标组成，用于定义物体在空间和时间上的中心
• 帧数是一个物体可见的帧数，知道每秒钟的摄像机帧数可以让这个参数测量一个物体在场景中的时间

与实现深度学习和大量训练数据来检测对象的流行检测算法不同，Matlab 基于运动的算法仅使用运动。通过首先减去两个帧的背景来检测对象，并且如果两个帧之间的差包含足够多的相连像素，则对象被识别。利用简单的卡尔曼滤波器预测每个探测到的物体的路径，如果沿着预测的轨迹探测到后续物体，则将其指定为相同的物体。

下图显示了一个普通视频截图的示例，旁边是用于检测和跟踪对象的减去的背景空间。

视频截图左边显示正常视频，右边显示运动检测和跟踪。减影背景图像中的变化是白色，而无变化是黑色。作者图片

获取机载视频数据

我用 DJI 的 Mavic Mini 无人机拍摄了自己和兄弟姐妹及朋友一起散步的场景。下面的照片展示了我们拍摄的场景和使用的设备。无人机一直在盘旋，因为如果相机超过一定的移动量，算法就不会工作。

显示测试现场的图片，演员走过现场，使用无人机和摄像机，以及无人机的遥控器。作者图片

我们都以正常的速度沿着场景的水平或垂直轴直线行走，除了两条轨迹以明显更慢或更快的速度倾斜，以便稍后测试跟踪算法。在获得大约 12 分钟的视频后，从无人机上检索数据，以输入到检测和跟踪算法中。

检测和跟踪的对象

尽管使用了悬停无人机的抖动镜头，检测和跟踪算法工作良好，如下面最繁忙的 15 秒剪辑所示，有 5 个不同的对象。

一个 15 秒的剪辑，展示了 5 个对象的检测和跟踪。作者图片

如前所述，为了显示对象检测和跟踪算法的简单应用，如上所示，两条路径偏离了正常模式。让我们来看看一些输出数据，以尝试在不必手动分析 12 分钟视频的情况下找到异常路径。输出数据包括对象 id、对象的 x 和 y 质心以及对象出现的帧。

在整个 12 分钟的视频中，总共检测和跟踪了 192 个物体，尽管需要注意的是，由于无人机的移动，其中一些可能是重复的或错误的识别。首先，我们可以将轨迹绘制到背景上，以查看每个被跟踪的对象经过的地方，下图显示了所有轨迹的绘制。

12 分钟视频中记录的所有 192 首曲目的图表。作者图片

虽然不是很清楚，在上面的图像中，我们可以看到两条对角线，代表偏离轨道。如果我们画出每个轨迹出现的时间，我们应该能够很容易地检测出较长和较短的异常轨迹。下图显示了所有曲目中每个曲目的持续时间。

所有音轨的音轨时长图。作者图片

使用上面的图，我们注意到慢速和快速异常磁道的异常磁道 id 分别为 1 和 22。现在，我们可以裁剪视频，仅显示异常轨道 1 和 22 出现的时间，如下所示。

快速和慢速异常轨迹的剪辑。那首慢歌以双倍速度播放。作者图片

使用输出轨迹数据，我们能够快速识别异常轨迹。过滤以仅显示异常剪辑比手动检查 12 分钟的视频以获得 30 秒的异常镜头要快得多。

摘要

随着所有库或算法的不断改进并向公众发布，实现对象检测和跟踪变得越来越容易。值得注意的是，有几种不同的工作流用于检测和跟踪对象，每种工作流都有其优点和缺点。这里提出的基于运动的方法对于诸如这里提出的具有运动目标的情况可能工作得很好，但是静止目标的检测和跟踪将需要不同的方法。

在这里给出的简单应用中，输出对象检测和跟踪数据用于从总共 192 个对象中识别两个异常轨迹。虽然只有一个 12 分钟的视频被用来识别总计 30 秒的特征，但这种方法可以用于从数小时的视频中识别小的异常行为。

在 ML 中快速移动而不打破东西

原文：https://towardsdatascience.com/move-fast-without-breaking-things-in-ml-c070bfca2705?source=collection_archive---------16-----------------------

行业笔记

许多公司都认识到，将一个在研究实验室中有效的模型投入生产，说起来容易做起来难。

作者图片

由 Doordash 的 ML 工程师 Bob Nugman 和 Arize AI 的 and Aparna Dhinakaran 撰写。在这篇文章中，Bob 和 Aparna 讨论了可靠性工程对于 ML 计划的重要性。

机器学习正迅速成为新兴产品和技术的关键因素。这使得该领域迅速成熟，因为它试图将构建 ML 模型的过程从艺术转变为工程实践。换句话说，许多公司正在认识到，将一个在研究实验室中有效的模型投入生产，说起来容易做起来难。

ML 从业者在将模型部署到生产环境中时面临的一个特殊挑战是确保他们的用户获得可靠的体验。想象一下，现在是凌晨 3 点，你被一个疯狂的电话吵醒。你跳进一个会议，首席技术官在线上，问问题。在新推出的市场中，购买数量突然下降，导致每分钟都有大量收入损失。社交媒体突然充斥着令人讨厌的用户报告。时间不多了。你的团队正在努力，但还不清楚从哪里开始。一款车型在生产中开始失败了吗？随着行业试图将机器学习转化为工程实践，我们需要开始讨论解决这个 ML 可靠性问题。

工程的一个重要部分是确保我们产品的可靠性，那些包含机器学习的产品也不例外。在一天结束时，你的用户不会给你一个通行证，因为你在你的产品中使用了最新最棒的机器学习模型。他们只是希望事情能顺利进行。

为了框定我们关于 ML 中可靠性的讨论，让我们首先来看看软件工程领域在发布可靠软件方面学到了什么。

软件可靠性

为什么

事实上，任何现代技术企业都需要强大的可靠性工程项目。这种计划的范围和形式将取决于业务的性质，选择将涉及复杂性、速度、成本等方面的权衡。

一个特别重要的权衡是在速度(“快速移动”)和可靠性(“不打破东西”)之间。有些领域，如欺诈检测，两者都需要。

将 ML 加入其中会使事情变得更加有趣。

考虑设定 99.95%的可用性目标。这为我们提供了每周 5 分钟的停机预算。绝大多数停机(根据我们的经验，超过 90%)都是由人工引入的代码和/或配置更改引发的。这现在也越来越多地包括对生产 ML 模型和数据管道的改变。

对生产系统的代码和配置进行变更几乎是连续不断的，每一次变更都有可能导致停机事件。类似地，随着对 ML 依赖的增加，对 ML 系统的高速生产交付的需求也在增加，同样存在着引入倒退或中断的风险。

如果我们要实现这个目标，那么每周只允许一次事故，那么挑战就变成了在五分钟内检测并完全缓解一次事故。怎么会？

需要有一个系统的可靠性计划。

可靠性的三大支柱

一个成功的可靠性计划应具备以下要素。每一个都将在下面详细介绍。

作者图片

• 可观察性:检测、探索和理解回归的能力
• 变更管理:工具和实践确保每一个引入的变更(代码、配置、业务规则、基础设施等)都是可发现的、可观察的、逐步推出的、可缓解的、可恢复的。
• 事故响应:当(不是如果)事故发生时，预先存在的计划和能力已经到位，以首先减轻然后恢复事故的影响。事故响应流程包括事故后阶段的启动，包括无过失事后验尸，其结果反馈到所有三大支柱的改进中。

这三个支柱对整个工程过程、技术堆栈以及组织的文化施加压力。

让我们来探讨一下它们的目标和一些特性。

可观察性

成功的可观测性解决方案将使我们能够:

• 快速检测回归
• 告知快速有效缓解的途径。
• 一旦问题得到缓解，告知问题的原因，以便可以全面分析、理解和解决问题，通常通过事后分析过程。

为了提高效率，可观察性工具和实践需要在整个组织中标准化，同时能够灵活地满足每个团队的需求。一个可观察性团队应该制定最佳实践并实现工具，以使开发人员能够以最小的努力一致地满足他们的可观察性需求。

变革管理

如上所述，大多数停机都是由代码和配置的众多更改之一触发的。变更管理系统的目标是确保以集中、系统的方式引入变更，支持我们的可靠性目标。

与可观察性类似，变更管理(代码、配置、基础架构、ML 模型等)应该在整个组织内标准化，同时适应团队之间的不同需求。最好由专门的所有者来管理变更工具和实践。

事故响应

尽管我们做了最好的准备，真正*难以想象的事情还是会发生。*在那个时候，响应不应该看起来像是头脑风暴、解决问题等工程活动。它应该看起来像一个事件响应，有一个预定义的结构，排练过的角色，尖锐的专业工具，和一个操作的命令。

重要的是，其他两个支柱，即变化的可观察性和管理，对于建立成功的事件响应能力至关重要。

机器学习中的可靠性

现在，我们已经了解了可靠性在软件工程的广阔世界中意味着什么，让我们利用我们的知识来理解 ML Ops 领域需要解决什么问题，以帮助公司部署具有机器学习组件的可靠应用程序。

要做到这一点，让我们回到我们之前讨论过的关于你的 CTO 深夜来电的故事。为了提供更多的背景信息，让我们假设为您的电子商务公司对您的搜索结果进行排名的模型正在返回奇怪的结果，并且正在严重影响客户转化率。让我们一步一步来看这里发生的事情。

甚至在你被邀请与你的首席技术官一起参加电话会议之前，对问题的第一步反应就已经发生了。问题已被发现，相关人士已被提醒。这可能是度量监控系统的结果，该系统负责确保重要的业务度量不会偏离轨道。

接下来使用你的 ML 可观察性工具，我们马上会谈到更多，你能够确定问题发生在你的搜索模型中，因为使用你返回的前 n 个链接的用户比例已经显著下降。

了解了这一点之后，你需要依靠你的模型管理系统，要么回滚到你之前的搜索排名模型，要么部署一个简单的模型，让你在此期间保持领先。这种缓解是阻止您的公司每分钟损失(同样多)金钱的原因，因为每一秒钟都是为用户提供不正确产品的关键。

现在事情又开始工作了，您需要回顾您的模型可观察性工具，以理解您的模型发生了什么。这里有许多可能出错的地方，其中一些可能会影响您的缓解策略，因此快速开始了解出错的原因非常重要。

最后，一旦您发现了问题的根本原因，您就必须想出一个解决方案，从修复数据源、重新训练您的模型，到重新设计一个新的模型架构。

现在，让我们更深入地了解这些在生产产品中实现 ML 可靠性的因素。

可观察性

作者图片

使任何系统可靠的关键因素是内省系统内部工作的能力。就像机械师需要在汽车引擎盖下观察你的引擎是否运转顺畅一样，ML 工程师需要能够在他们的模型引擎盖下观察，以了解他们的模型在生产中是如何整流罩的。虽然这似乎是显而易见的，但许多公司在部署机器学习时都是盲目的。通过综合性能指标来衡量模型的性能是不可观察的。

思考 ML 可观察性的最佳方式是，你的团队如何有效地检测到你的模型性能的问题，对问题进行缓解以止血，确定回归的根本原因，并对问题进行补救或解决。值得注意的是，有能力检测问题并不构成对 ML 系统的完全可观察性。如果没有自省的能力来找到根本原因或权衡各种因素的总和，任何解决方案都将是某种形式的猜测。

为了更好地说明您的工具应该寻找什么样的东西，我们首先需要了解哪些东西可能出错？

那么什么会出错呢？

你应该观察什么实际上取决于什么会出错。

使用 ML 模型时，有许多不同的模型故障模式和生产挑战，每种模式都需要您观察系统中的附加信息。

作者图片

首先，战斗的第一步是检测问题的发生。这通常是通过测量模型性能指标来完成的，如运行精度、RMSE、f1 等。一个问题是这并不像听起来那么简单。在理想情况下，在模型做出决策后，您很快就知道了模型预测的基本事实，从而很容易确定模型在生产中的表现。举个例子，预测用户可能会点击哪个广告。在模型做出决定后，你几乎马上就能得到一个关于你表现如何的结果。用户要么点击了它，要么没有点击！

ML 的许多应用程序没有这种实时基础事实的奢侈，在这种情况下，可以使用代理性能度量，如相关的业务度量。除了模型性能指标之外，您可能希望监控服务健康指标，如预测延迟，以确保您的服务为您的用户提供良好的体验。

一旦通过监控模型性能或服务健康度量检测到回归，您需要更多的信息来理解您的模型可能会发生什么。有助于事件响应的一些重要注意事项:

服务:

• 模型预测的延迟和面向用户的延迟
• 服务停机时间(非常类似于软件)

数据:

• 培训中前所未见的生产新价值
• 数据中的噪声或缺失值会对模型消费的特性产生很大的影响。

型号:

• 模型正在执行的底层任务可能会在一夜之间发生缓慢或快速的变化！
• 你的模型可能会以一种非设计的方式产生偏差(你的用户的一些意想不到的子集会得到可测量的不同结果吗)
• 您的模型可能在某些数据子集上表现特别差(需要存储和理解您的模型错误)

对于这些潜在的生产挑战中的每一个，你的 ML 可观察性工具集应该使你的团队能够检测回归并深入研究它们，以最好地理解它们为什么会发生以及你能做些什么。

我们可以整天谈论 ML 可观察性，所以让我们继续讨论如何最好地管理生产中模型的发布更新。

变革管理

每次你把新的变化推向生产，你都冒着把你的用户引入到你的团队没有预见和防范的问题中的风险。

事实上，假设你的搜索模型在你假设的电子商务平台上因为一个新模型的推出而倒退了。现在，您的业务度量发现出了问题，并且您的可观察性工具确定了搜索模型，那么我们该怎么做呢？我们之前提到了缓解和补救之间的区别。在这种情况下，由于我们正在迅速损失公司的资金，最好的办法可能是尽快止血(缓解问题)。

我们可能有的一个选择是恢复到我们以前部署的模型。或者，我们可以发布我们的幼稚模型，这种模型可能没有那么好的性能，但始终工作得很好。在我们的例子中，这可能只是显示从弹性搜索返回的精确结果。

为了更好地防止这些潜在的问题迅速而显著地发生在你的产品的用户身上，ML 系统应该遵循与软件部署相似的展示过程。

与通常使用静态测试用例来测试软件以确保代码不会回归任何行为一样，ML 系统也应该在部署前进行静态验证测试。例如，如果你正在提供自动驾驶服务，通过一些标准化的确定性模拟器路线运行你的新模型可能会让你发现一些明显的回归。

虽然静态验证对于提高运输产品的质量非常重要，但它无法替代您在生产中对模型的了解。让我们来讨论一下如何从您的生产模型中获得这些经验，而不会有全面停机或降低所有用户体验的风险。

您可能希望首先将您的模型发布给一部分用户，以便在所有用户察觉到问题之前及早发现问题。这种技术通常被称为金丝雀部署。

如果通过 ML 监控系统检测到问题，随着您逐步推出您的更改，您应该能够轻松快速地恢复到之前的模型版本及其相应的软件版本。

另一个密切相关的话题是影子部署的想法。在影子部署中，你可以在新模型发货之前，将现有模型在生产中看到的输入信息输入到新模型中。因此，当您的用户仍在体验现有模型提供的预测和用户体验时，您可以开始衡量您的新模型的表现，并做出任何必要的更改，以使其为黄金时间做好准备。

影子部署的另一个好处是，您可以在影子部署中对多个候选模型进行实验，并选择一个能够在当前生产数据上表现最佳的模型。

现在我们已经有了一些技术来帮助我们提高部署的质量，让我们来讨论一下当您在将生产模型部署到生产中之后发现它有问题时，您可以做些什么。

事故响应

好的，我们在生产中发现了模型的一个问题，我们应该怎么做？这在很大程度上取决于您的模型应用程序，但这里我们将讨论一些关于如何在短期内处理问题(缓解)并朝着真正的修复(补救)努力的一般策略。

减轻

首先，就像软件一样，您可以回滚到以前的模型版本和相应的软件/配置。如果您推广了一个通过验证过程的坏模型，这种缓解策略可能会对您有所帮助；但是，这并不总能解决您的问题。可能您的输入数据分布或模型的底层任务已经发生了变化，使得旧模型在生产中也不是一个好的选择。

在某些情况下，另一个可行的策略是部署模型的简单版本。这可能通常比更复杂的模型性能低，但在面对输入和预期输出分布的变化时，它可能会做得更好。该模型不需要机器学习，可以只是一个简单的基于启发式的模型。这种策略可以帮助您在返工更复杂、但性能更好的模型时赢得时间。

补救

这给我们带来了解决由生产中的 ML 模型引起的事件的最常见的建议:只需重新培训它！这个建议很常见，因为它涵盖了模型的许多潜在故障模式。如果输入数据发生了变化或基础任务发生了变化，对较新的生产数据进行重新培训也许能够解决您的问题。随着时间的推移，世界在变化，你的模型可能需要定期重新培训以保持相关性。

作者图片

再培训策略可能包含一整篇技术文章，所以让我们跳到节略版。重新训练模型时，您有一些选择:

您可以选择对数据的某些子集进行上采样，这可能会修复与某类数据的非预期偏差或表现不佳有关的问题。

如果你认为你的输入/输出分布的转变会持续下去，你也可以对更新的生产数据进行采样，以建立新的训练集。

如果您认为这种分布变化是暂时的，并且可能是季节性的，那么您可以根据此季节性期间的数据来训练新版本的模型并部署它，或者求助于工程特征来帮助您的模型理解它试图近似的函数中的季节性指标。

您的模型的性能可能会下降，这是因为引入了一个新类别的示例，这是它在培训中没有见过的。如果这类例子非常不同，你可能需要一个全新的模型来处理这些特殊的例子。训练一个单独的模型并采用一个更高级别的模型来确定对一个特定的例子使用哪个模型的过程通常被称为联合。

我们将在这里讨论的最后一个选项是重新开始。如果再培训没有帮助恢复性能，并且您的旧模型也无法完成工作，那么任务可能已经发生了足够大的变化，需要以下一些内容:新的模型架构、新的功能、新的数据处理步骤。

结论

软件世界花了几年时间才支持我们上面概述的可靠性框架。有了可观察性、变更管理和事件响应这三个支柱，我们可以将可靠性收益从软件领域转化到 ML 应用领域。现在由 ML Ops 空间来提供我们迫切需要的工具，以使 ML 应用程序可靠。

超越事实，了解你的维度

原文：https://towardsdatascience.com/move-over-facts-know-your-dimensions-e1489862f9a0?source=collection_archive---------7-----------------------

数据仓库中的维度类型

照片由西格蒙德在 Unsplash 拍摄

度量，度量，度量！如今，我们希望捕捉应用程序中的每一次点击、每一次滚动和每一个事件，并在其上运行作业。众所周知(事实:P )这些指标是黄金(或者我应该说石油？)但是你有没有想过失败者，这些指标所指的维度？

本文将带您回到数据仓库的基础，并回顾数据仓库中不同类型的维度。如果您已经熟悉什么是尺寸，您可以跳到下一部分。

让我先谈谈维度是什么，那么维度是什么？

维度是我们观察、测量和体验世界的方式。在数据领域，这可以转化为维度，即我们衡量数据和回答业务查询的实体。维度是衡量标准的方式。例如:指标如何与地理相关？

可视化和理解维度的最简单方法是它们在星型模式中的位置:

定义完维度后，让我们继续下一节，讨论维度的不同类型。

维度的类型

根据尺寸变化的频率，可将其分为三种类型:

**静态尺寸:**不随时间变化的尺寸。这些维度非常容易实现。例如，用户的出生日期。

缓变尺寸(SCD): 尺寸随着时间推移缓慢改变 或能够改变的尺寸。实现 SCD 有多种方法，这取决于您希望如何处理发生的变化。

例如，假设用户在 21 年 2 月 24 日从印度搬到了美国，我们希望在维护为

设计 SCD 的各种方法有:

• SCD — Type 0: 发生变化时，保留原来的值。更新的维度表:

• SCD — Type I: 发生变化时，覆盖原始值。更新的维度表:

• SCD — Type II: 发生变化时，增加新的一行。当您想要维护尺寸变更的历史记录时，请使用类型 II 尺寸设计。更新的维度表:

• SCD — Type III: 当发生变化时，增加一个新列。更新的维度表:

• SCD — Type IV: 当发生变化时，覆盖并维护一个单独的历史表。

**快速变化尺寸:随时间变化 或能快速变化的尺寸。例如，用户的体重。快速变化的维度通常被实现为垃圾维度，如下所述。

上面介绍了基于更改频率的维度分类，还有其他基于维度存储方式和其他一些因素的维度分类。其中一些定义如下:

**退化维度:**作为事实表的一部分存储而不是存储在单独的表中的维度。将维度存储为退化维度的决定取决于几个因素，如查询性能考虑。例如，用户的名字可以存储为事实表的一部分。

**符合尺寸:**这些尺寸无论在哪里被引用都具有相同的含义。例如，日历维度表。

**垃圾维度:**这可以解释为一个杂项表，可以维护该表以将不相关的属性存储在一起，并且当不希望将事实表中的太多外键维护到太多维度表时，可以使用单个外键来引用该表。这些通常被实现来处理快速变化或快速变化的维度。

**推断维度:**这些是维度表类型，用于在维度表中的引用可用之前加载事实表的情况下，处理后期数据。在这种情况下，为了尊重引用完整性，可以在事实表可以推断的维度表中创建一个所有维度属性都为空的新记录。当维度数据可用时，可以更新该新行。

嗯，三分钟内的信息太多了！希望这有助于澄清数据仓库中的一些维度类型。

下次见，
JD

远离 R

原文：https://towardsdatascience.com/moving-away-from-r%C2%B2-4a89b1c70393?source=collection_archive---------20-----------------------

使用它的危险以及如何改进你的分析。

作者造成的不良形象

介绍

r 是一个众所周知的模型指标，每个数据分析师都有它的工具箱，但尽管它很流行，数据分析师倾向于谈论和使用这一指标的方式与统计界对它的看法不匹配。在这篇文章中，我希望用简单的图表和语言来解释 R 的一些误用，以及我们如何使用更适用的度量来改进我们的分析。

这篇文章很大程度上受到了 科斯马·沙立子博士的讲稿 的启发。我的意图是将一些难以理解的统计数据转换成一个更加直观和外行的解释。

行动纲要

一些积极使用 R 的人可能想知道这有什么大不了的。以下是一个简短的总结，如果你不同意以下至少一点，也许值得继续读下去。

使用 R 的好理由:

1. 我想看看我的数据有多嘈杂。

使用 R 的错误理由:

1. 我想知道我的模型在预测方面有多好。(不好，用均方差代替)
2. 我想知道我的自变量是否显著。(不好，使用 p 值)
3. 我想知道我的线性模型在统计上是否显著(不好，使用 f 检验，但是也要确保检查你的假设)
4. 我想知道我的因变量有多少是由我的自变量解释的(不好…有点……)

还感兴趣吗？太好了，继续读下去！

背景

按作者分类的图表

非常简要地回顾一下 R

r 是一个常用于评估线性回归模型的指标。在上图中，我们可以看到红点(预测值)与黑点(实际值)的差异。这两种颜色之间的黑线叫做余数。但是如果我们想想出一些方法来看看我们的残差有多大呢？插入 R。

r 是自变量解释的因变量方差的比例。用不太正式的术语来说，它是一个介于 0 和 1 之间的值，用来描述我们的模型与数据的吻合程度。在许多数据分析领域，R 还充当了比较和评估模型的指标，0 表示非常差的模型，接近 1 的值表示良好的模型。我们用残差平方和(RSS)除以总平方和(TSS ),然后从 1 中减去该分数。

信号和噪音

信号和噪声是数据世界的阴阳两极。信号是指我们试图检测的数据中的一些真相，而噪声是掩盖我们信号的无意义信息。为了把这个比喻带入 21 世纪，你可以把 signal 想象成你想要找到的最喜欢的 Spotify 播放列表，把 noise 想象成那些总是被推销的垃圾播客。在本文中，我将频繁使用这些术语，以便让来自非统计背景的人更容易理解诸如标准差和真实系数值之类的概念。

r:噪声的度量单位

作为数据科学家，我们希望检测数据中的信号。我们开发模型和复杂的分析来做这件事，然后我们评估我们所做的，以确定我们是否做得很好。这就是为什么用 R 来衡量我们信号的强度(或有效性)是如此错误的原因——因为 R 在很大程度上衡量的是我们数据中的噪声。

回想一下，在我们对 R 的简短讨论中，我们说过，自变量解释的是因变量方差的比例。这应该会给我们带来一些危险信号，因为根据定义，我们意识到，随着因变量方差(噪声)的增加，我们能够解释的部分就越少，即使我们保持信号不变。

这可能还没有意义，所以让我们想象一下在保持信号不变的情况下增加噪声是什么样子。

操纵 R

在本例中，我们将创建一些数据。我们要做的是定义我们的信号是什么，引入不同水平的噪声，并观察 R 如何反应。

我们的信号:X 的真实系数等于 1.2

噪声:平均值为 0 且标准差增加的数字的随机相加。

为此，我们将使用以下代码来生成数据。

x1 <- seq(1,10,length.out = 500) 
y1 <- 2 + 1.2*x1 + rnorm(500,0,sd = 1) 

对于 x1，计算机将生成 500 个 1 到 10 之间的数字。对于 y1，我们要取这个数，乘以我们的真实系数(1.2)，加上 2，然后加上一个随机分布在 500 左右的随机数，平均值为 0，标准差为 1。

我们将创建 4 个图表和线性回归，以查看我们的结果如何随着标准差的增加而变化。重要的是要认识到，在每一种情况下，我们的信号(真实系数为 1.2)将保持不变，但我们会有不同水平的噪声(长期来看平均值为 0)。

如果 R 测量我们的信号或它的强度，它应该保持大致相等。如果它测量我们数据中的噪声，那么当我们增加模型中的噪声(保持信号不变)时，R 应该直线下降。那么会发生什么呢？

按作者分类的图表

你看看那个。我们每次回归的信号是 1.2，每次回归都在 1.2 左右。但是请注意，每次我们增加噪音时，我们的 R 似乎都受到了影响。

这就是为什么 R 可以成为一个破坏性的模型评估者。由于它甚至没有试图测量信号，淡化低 R 的模型会导致我们忽略我们在数据中准确识别信号的时间。

r 和解释:一个解释

早些时候我告诉过你，R 是由自变量解释的因变量方差的比例，但是现在，亲爱的读者，我必须承认这也比看起来更复杂。

当我们经常说一个词的时候，我们可能会欺骗自己认为我们理解了它，但它值得我们注意真正检查“解释”在这里的意思。我担心的是，许多人认为这个模糊的词意味着“原因”。最后，我们应该证明 R 不可能告诉我们 X 导致 Y，或者在两者之间有某种因果联系。

这个简单的实验实际上很容易做。让我们取一些 X，它实际上对 Y 有一些因果影响(和前面的代码一样)。那么，如果 R 确实度量了某种因果联系，并且我们知道 X 是导致 Y 的原因，那么用 Y 解释的 X 的变化的 R 应该低于用 X 解释的 Y 的变化的 R。

让我们进行这个实验，看看我们的 R 有什么不同。

x2 <- seq(1,10,length.out = 500)     
y2 <- 2 + 1.2*x2 + rnorm(500,0,sd = 3)
summary(lm(x2~y2))$r.squared
summary(lm(y2~x2))$r.squared

我们代码的输出

我们知道，Y 对 X 没有因果影响，然而，如果我们相信 R 向我们展示了某种因果联系，那么这里的 R 应该是不同的，但它们不是，所以我们必须拒绝任何概念，即 R 可以证明我们的因变量和自变量之间的某种因果联系。

实际上，我认为大多数数据分析师会拒绝说 R 告诉我们 Y 有多少是由 X 引起的，但我确实认为许多人相信这一点。那些通常很少关心方差的人，却惊人地关心有多少方差是由某个变量“解释”的。

所有这些的含义

一旦你理解了 R 和噪声之间的关系，当分析师主要基于 R 值来提升或贬低一个模型时，你会忍不住退缩。正如我们刚刚看到的，R 不能告诉我们数据中的信号，它本身是一个非常有限的指标。

事实上，很难找到一个令人信服的理由来给 R 以它应该得到的关注。这篇文章已经太长了，但是我认为，很多时候沉迷于 R 是一个很坏的习惯，因为它通常会鼓励新人疯狂地过度适应(你的模型可以解释的噪声越多，R 就越好)，忽略其他更重要的线性回归模型指标，一旦他们遇到真实世界的数据及其混乱，他们就会失败。

我确实认为 R 在边缘情况下仍然有用，但是几乎每个分析都可以通过使用另一个更适用的度量来改进。它的简单性对任何数据科学的新手来说都是有吸引力的，但是为了更好地掌握统计和数据科学，认识到它的缺点并使用更好的技术是很重要的。

这篇文章是一个白痴数据分析师写的，他极大地简化了提到的统计数据。错误是可能的，但是 R 应该被更谨慎地使用的主要观点仍然存在(至少我希望如此。我知道什么？我只是一个免责消息)。

超越批处理与流

原文：https://towardsdatascience.com/moving-beyond-batch-vs-streaming-continuous-datasets-e00713797929?source=collection_archive---------35-----------------------

连续数据集:通过两种生态系统的可访问性

来源:Pixabay

我的世界观很大程度上受我的产品和业务背景的影响，它让我以量化公司或产品价值的统计数据来思考这个世界。随着时间的推移发生了什么？现在发生了什么事？

世界各地的 FAANGs 都明白这一点，并提供量身定制的产品来提供这一价值。当我登录 Google AdWords 时，我不仅可以看到我的活动目前的运行情况，还可以看到它在一段时间内的表现。两者缺一不可，这将是一个不完整的观点。

谷歌分析、脸书和亚马逊拥有看似毫不费力的实时报告。网飞和苹果的反应式界面会根据我的浏览行为和指示的偏好进行更新，为我提供我可能感兴趣的产品和关于我互动方式的当前视图。如果没有基于实时洞察的即时调整，我的用户身份和与这些服务的关系就不会一样。

奇怪的是，当我们使用大多数其他商业工具时，我们的体验会受到影响。你能想到你使用的 B2B 系统没有几天或至少几个小时的报告延迟吗？

回想一下你上一次访问公司的人力资源系统是什么时候。与等待系统更新相比，打电话给他们确认确实做出了改变通常更容易。

B2C 也是如此。向保险公司索赔需要多长时间？你可能认为只有老派、行动缓慢的企业才会有这个问题，但事实并非如此。我们中的大多数人都曾在这样的组织中工作过:每个季度结束后，至少要花一个月的时间来最终确定销售目标。尽管《哈佛商业评论》调查的 83%的企业认为“在最佳时间将数据转化为可操作的洞察力的能力”很重要，但只有 22%的企业表示他们能够成功做到这一点。

但是人们越来越期待反应式的体验。提供这些功能的产品表现明显更好。几乎所有的福布斯未来 50 强都属于这一类别，这并不是巧合，因此 IDC 称到 2025 年 30%的数据将是实时的。

那么，是什么让今天的 FAANGs 和明天的预计科技巨头提供这些类型的体验，而不是其他人呢？很可能是因为他们拥有庞大的技术团队，可以绕过当前数据管道的限制。管道分为两类，每一类都有自己的优点和缺点。A16Z 在他们最近的帖子中详细讨论了这些范例。

来源:作者创作

批处理系统组织大规模数据集，以便最终用户可以就这些数据集提出问题并快速获得答案。每次发出查询时，这些答案的计算都涉及到对围绕其提问的整个数据集的处理。批处理系统通常用于分析用例，具有特定的优点和缺点:

慢:问题只能问历史，不能问现在发生的事情。批处理系统通常有一天的延迟，但是有可能将这个时间范围降低到几个小时。

**昂贵:**因为每次提出一个问题都会处理整个世界，所以账单会随着数据集的大小和发出的查询数量而迅速增加。

**灵活:**它们易于使用，可以快速询问特定问题或试验新的用例。

流系统查看“事件”并在事件发生时处理每个事件。它们通常用于操作目的，如监控、机器学习或构建反应式体验。

**快速:**有可能在事件发生的几毫秒内获得洞察力或采取行动。

**昂贵且不方便:**用例需要定制开发，构建它们需要一个相当大的工程团队，既要让它们启动并运行，又要维护它们。

**历史很少:**流媒体系统通常只处理最近的数据，而不处理历史信息。

你们中的一些人会说“但是 Kafka 最近使用云存储添加了无限保留，所以我可以在那里卸载我所有的历史，并从我的流媒体系统中获取历史”。你是对的，但有一个相当大的警告——为了实际使用历史数据，你需要通过卡夫卡读回那些数据。雪花不能通过设计直接查询它，任何其他批处理系统也不能，所以如果你想使用一个流系统来查看历史数据，每次提出一个问题，你都需要通过你的代理将数据返回，这有点像用一根吸管连接两个消防水管。这些查询将花费难以忍受的长时间来返回任何有用的信息。雪上加霜的是，这些代理正是您的生产系统所使用的代理。如果你超负荷工作，你会危及生产本身，这是不可取的。

这只是两个世界之间巨大差异的一个例子，不仅仅是在互操作性方面，还有最终用户的类型(分析师与工程师)。大多数大型企业在不同的用例中同时使用批处理和流处理，最终拥有两个完全不同的系统，这两个系统应该是一致的，但很少会这样。

打击一个能够从数据集而不是技术的角度思考的人。

我们知道定制管道可以做到这一点，因为科技巨头支持这种功能。一个显而易见的方法是协调系统间的查询。例如，我可以构建两个独立的管道，在我的分析系统中查询超过一天的数据，在我的流系统中查询最近的数据。这已经作为一个 Lambda 架构得到普及，但是有几个原因导致它不能很好地工作。

首先，光是实施就要花费数百万美元，而且极其耗时，当我想要创建新的数据流和报告视图时，发展成本可能也一样高。当我在系统间查询时，我可能总是会被不一致性所困扰。因此，虽然可能，但这种方法只适用于大型企业，而且效率肯定不高。

即使我想通了所有这些，也几乎不可能获得跨两个系统进行重复数据删除的准确答案，从而限制了此类设置中数据的效用。

对于大多数公司和应用程序来说，这是第二个问题。

仔细看看这个问题，我们只是看到了真正问题的症状:我们正在拼凑点解决方案，试图解决一个整体的业务数据问题。我们有帮助我们移动和处理数据的技术解决方案，但它们的互操作性很差，我们仍然需要协调全面解决方案所需的所有技术基础设施。这是有道理的，因为尽管批量数据处理已经取得了很大进展，但我们还只是处于真正实时连续物化的最早期阶段。所有现有的框架在可以发出的查询类型(例如，窗口)方面都有有意义的限制，这阻止了它们真正像批量分析那样被使用。从功能上来说，这意味着你可以连接和比较最近的数据，但是如果你想做任何超出这个范围的事情，祝你好运。

听起来很像三振出局。

连续数据集:呼唤新范式

到了紧要关头，我们都有一个单一的底层数据集，尽管它可能由来自不同位置的多个信号组成。技术迫使我们将基于基础架构的“批处理”和“流式”视图捆绑在一起，并将其视为相同数据的根本不同的副本。当工程师想要构建一个新的用例时，他们需要协调这些副本。当他们创建依赖于低延迟流数据的服务时，他们必须从批处理环境中手动回填细节。这有着至关重要的连锁效应，当制定新的数据驱动的用例、发展或将它们集成到您的堆栈中时，这会限制或至少增加潜在使用模式的复杂性。

迄今为止，流媒体系统一直是围墙花园。静态数据存储在基于技术的专有格式和位置中，只能通过向流系统请求该数据来读取。您的数据永远不应该被锁定在访问层之后，而是以您的用户(了解批处理系统)可以直接访问的格式存储。如果是这样的话，我们可以有一个服务于低延迟流用例的单一数据表示，同时仍然可以被广泛使用的批量分析工具生态系统查询。

格式不是唯一不应该受制于技术和供应商的东西。您的数据应该存储在一个便宜、可访问且灵活的位置。对于这些要求，实际上只有一个选项—云存储—几乎是为任务定制设计的。这听起来有些愚蠢和过时，但大多数流媒体系统仍然在本地存储数据，并迫使用户担心当他们的磁盘填满时该怎么办。

我们应该能够清楚地表达我们关心的数据集，并确信技术将允许访问历史和非常低延迟的更新，这些更新是可访问的，并由云存储支持:连续数据集，尽管仅此还不够。为了满足我们的业务需求，连续数据集需要其他特定属性:

1. **数据目录。**存放数据并易于搜索的单一位置。太多的企业依赖分散在工具中的分散数据。通过在企业内创建一个全局命名空间，数据目录可以包含每一条有权限的可用信息，以确保正确的用户可以访问。
2. **可审计性。**改变某样东西的价值不应该看起来像是覆盖它，而是记录它的新价值。我们应该总是能够回到过去，看到任何数据集的完整历史。
3. **无限变换。**这很难，但我们需要廉价地创建新的衍生数据集的能力，通过连接、扩充或转换上游数据集，这些数据集始终保持最新和完整。这些转换不能受制于今天的流窗口或回看限制，这些限制迫使用户为特定查询改变工具。
4. 秤。即使是数据仓库也有局限性。工作流不应该根据规模需求来强制选择技术。
5. **互通性。**这些数据集应该与团队使用的任何工具一起工作。雪花，蜂房，数据库，SaaS 工具等应该很容易插入，并与历史和当前信息保持同步。

河口流是第一个考虑连续数据集的系统，有助于为每个人提供与 FAANG 一样的优质用户体验和业务洞察。

从数据库思维模式转向数据湖思维模式

原文：https://towardsdatascience.com/moving-from-a-database-mindset-to-a-data-lake-mindset-d93ffae7caca?source=collection_archive---------15-----------------------

使用数据湖时的三种范式转变

图片作者:乔尔·安巴斯

使用数据库和数据湖之间有几个关键的概念差异。
在这篇文章中，让我们找出一些乍一看可能并不直观的区别，尤其是对于具有强大关系数据库背景的人来说。

该服务器是一次性的。数据在云中。

解耦存储和计算:这是谈论数据湖的经典案例。

在传统数据库系统(以及最初基于 Hadoop 的数据湖)中，存储与计算服务器紧密耦合。服务器或者内置存储，或者直接连接到存储。

在现代基于云的数据湖架构中，数据存储和计算是独立的。数据保存在云对象存储中(例如:AWS S3，Azure 存储)，通常是像 parquet 这样的开放格式，计算服务器是无状态的，它们可以在任何需要的时候启动/关闭。

存储和计算的分离实现了:

• 降低计算成本:服务器在必要时运行。不使用时，可以关闭它们，从而降低计算成本。
• 可扩展性:您不必为峰值使用量购买硬件。服务器/CPU/内存的数量可以根据当前的使用情况动态增加/减少。
• 沙箱:多个计算服务器/集群可以同时读取相同的数据。这允许您有多个团队，在不同的集群中，并行工作，读取相同的数据，而不会相互影响。

原始数据才是王道！精选的数据是从。

在数据库范例中，来自源系统的数据被转换并加载到数据库表中后，就不再有用了。在数据湖范式中，原始数据作为真实的来源保存，最终永远保存，因为它是真正的资产。

然而，原始数据通常不适合企业用户使用，因此需要经过一个处理过程来提高质量、提供结构并简化使用。经过筛选的数据最终会被存储起来，供数据科学团队、数据仓库、报告系统和业务用户使用。

数据湖策展(来源:作者图片)

典型的数据湖消费者只看到经过策划的数据，因此他们对策划的数据比对生成它的原始数据更看重。

然而，数据湖的真正资产是原始数据(以及监管管道)，在某种意义上，监管数据类似于可以随时刷新的物化视图。

关键要点

• 可以随时从原始数据中重新创建。
• 可以通过改进的固化过程重新创建。
• 我们可以有多个精选视图，每个视图用于一个特定的分析。

今天做出的模式决策不会约束未来的需求

通常，信息需求会发生变化，需要分析一些最初不是从源/操作系统收集的信息。

在一个典型的场景中，如果原始的原始数据没有被存储，历史数据将永远丢失。

然而，在数据湖体系结构中，今天做出的不将字段加载到管理模式上的决定可以在以后撤销，因为所有详细信息都安全地存储在数据湖的原始区域中，并且历史管理数据可以用附加字段重新创建。

策划模式演变(图片由作者提供)

关键要点

• 如果您现在不需要，就不要花太多时间去创建一个通用的“一刀切”的管理模式。
• 迭代地创建一个管理模式，从添加您现在需要的字段开始。
• 当需要其他字段时，将它们添加到监管流程中并重新处理。

最后的想法

数据湖不是数据库的替代品，每种工具都有其优点和弱点。

对于 OLTP 来说，使用数据湖可能和使用数据库来存储万亿字节的非结构化数据一样糟糕。

我希望这篇文章有助于揭示两个系统之间的一些关键设计差异。

从熊猫到星火

原文：https://towardsdatascience.com/moving-from-pandas-to-spark-7b0b7d956adb?source=collection_archive---------13-----------------------

当您的数据集开始变大时，迁移到 Spark 可以提高速度并节省时间。

大多数数据科学工作流都是从熊猫开始的。Pandas 是一个很棒的库，可以让你做各种各样的转换，可以处理不同种类的数据，比如 CSV 或 JSONs 等。我喜欢熊猫——我在上面制作了一个名为“为什么熊猫是新的 Excel”的播客。我仍然认为熊猫是数据科学家武库中的一个令人敬畏的图书馆。然而，当你正在处理的数据集变得太大时，熊猫就会开始耗尽内存。正是在这里，火花进入画面。

Spark 对于大型数据集来说是很棒的❤️ [ 来源

我以问答的形式写这篇博文，带着你可能会有的问题，我刚开始写的时候也有。

Q1。什么是火花？

Spark 是一个处理海量数据集的框架。它允许您以分布式方式处理大数据文件。它让几个工人运转起来，这些工人处理你的大数据集，所有这些都由一个驱动节点来编排。该框架的分布式特性使您可以将其扩展到数 TB 的数据。你不再被任何一台机器的内存所限制。Spark 生态系统现在已经发展得如此之快，以至于您不需要担心任何工作流程编排，并且可以开箱即用，性能卓越。

星火生态系统参考

Q2。什么时候应该搬出熊猫，认真考虑用 Spark？

这取决于你机器的内存。我想说大于 10GB 的数据集对熊猫来说太大了，Spark 在这里变得非常有益。假设您的数据集中有 10 列，每个单元格有 100 个字符，因此大约有 100 个字节，并且大多数字符都是 ASCII 码，可以用 1 个字节进行编码，那么 10M 行将是您应该想到 Spark 的地方。

Q3。Spark 做什么都比熊猫好吗？

不要！对于初学者来说，学习熊猫肯定要容易得多。Spark 可能更难，但有了最新的 API，您可以使用数据帧处理大量数据，这些数据帧几乎和熊猫数据帧一样容易处理。

此外，直到最近，Spark 还不太支持可视化。你只能对数据子集进行可视化。最近，当 Databricks 宣布他们将在 Spark 中对可视化提供原生支持时，情况发生了变化(我仍在等待看到这一点)。但在这种技术成熟之前，Spark 至少在虚拟世界里不会完全取代熊猫。您总是可以通过df.toPandas()将 Spark 数据帧转换成 Pandas，然后运行可视化或 Pandas 代码。

Q4。Spark 设置起来很吓人。我该怎么办？

Spark 可以通过 PySpark 或 Scala(或 R 或 SQL)在 Python 中进行交互。我写了一篇关于在本地或定制服务器上开始使用 PySpark 的博客——人们评论说开始使用 PySpark 有多难。我认为在尝试运行 Spark 时，您可以直接使用托管云解决方案。

我推荐两种开始使用 Spark 的方法:
1。Databricks —这是一个完全托管的服务，为您管理 AWS / Azure / GCP 中的 Spark 集群。他们有可以运行的笔记本，与 Jupyter 笔记本非常相似。
2。亚马逊 EMR 和 Zeppelin 笔记本 —这是由 AWS 提供的半托管服务。您需要托管一个 Spark EMR 端点，然后运行 Zeppelin 笔记本与之交互。其他云提供商也有类似的服务，我在这里不包括他们。

Databricks 是托管 Spark 集群的一种流行方式[ImageSourcewith CClicense

Q5。Databricks 和 EMR 哪个好？

在花了几个小时试图了解两者的利弊之后，有一些考虑:

1. EMR 完全由亚马逊管理，你不需要离开 AWS 生态系统。
   b)如果您有 devops 专业知识或有 devops 人员帮助您，EMR 可能是一个更便宜的选择——您需要知道如何在完成后上下旋转实例。也就是说，EMR 可能不稳定，你可能需要花几个小时调试。Databricks Spark 要稳定得多。
   c)使用 Databricks 很容易安排作业——您可以非常轻松地安排笔记本电脑在一天或一周的特定时间运行。它们还提供了一个到 Ganglia UI 中指标的接口。
   d)对于 Spark 作业而言，Databricks 作业可能比 EMR 作业贵 30–40%。但是考虑到灵活性和稳定性以及强大的客户支持，我认为他们是值得的。Databricks 在 Spark 中以交互方式运行笔记本电脑的收费是 6-7 倍，所以请注意这一点。鉴于 30/60/120 分钟的活动后，你可以拒绝实例，从而节省成本，我仍然认为他们可以整体更便宜。

鉴于这几点，我想说如果这是你的第一个 Spark 项目，你应该选择 Databricks，但是如果你有大量的 DevOps 专业知识，你可以尝试 EMR 或者在你自己的机器上运行 Spark。如果你不介意公开分享你的工作，你可以免费试用 Databricks 社区版或者用他们的企业版做 14 天的试用。

Q6。PySpark 和熊猫相比有多相似或不同？

我觉得这值得有自己的博客。星火计划的贡献者安德鲁·雷的这个演讲应该可以回答你的一些问题。
主要相似之处有:

1. Spark 数据帧与熊猫数据帧非常相似。
2. PySpark 的 groupby、aggregations、selection 等变换都和熊猫很像。与熊猫相比，PySpark 稍微难一点，有一点学习曲线——但感觉相似。

主要区别是:

1. Spark 允许你用 SQL 和 Python**查询数据帧，我觉得这真的很棒。有时，用 SQL 编写一些逻辑可能比用 Pandas/PySpark 记住确切的 API 更容易，您可以这样做，也可以互换工作。
2. 火花数据帧是不可变的。不允许切片，覆盖数据等。
   c)Spark※懒评。它构建了一个所有转换的图表，然后当你实际提供一个动作，比如collect或show或take时，它会懒洋洋地评估它们。转换可以是宽的(查看所有节点上的全部数据，因此orderBy或groupBy)或窄的(查看每个节点中的单个数据，因此contains或filter)。与窄转换相比，进行几个宽转换会慢一些。与熊猫相比，你需要更加注意你正在使用的广泛转换！**

Spark 中的窄与宽转换。大范围转换速度较慢[图片由作者提供]

Q7。还有什么其他优势可以火花吗？

Spark 不仅提供数据帧(rdd 上的高级抽象)，还通过 MLLib 提供优秀的流数据和分布式机器学习 API。因此，如果你想对流数据进行转换，或者想在大型数据集上进行机器学习，Spark 可能会对你有用。

Q8。有 Spark 的数据管道架构的例子吗？

是的，这里有一个 ETL 管道，原始数据从数据湖(S3)处理，并在 Spark 中转换，加载回 S3，然后加载到像雪花或红移这样的数据仓库，然后驱动像 Tableau 或 Looker 这样的 BI 工具。

BI 工具的大型数据处理 ETL 管道示例[图片由作者提供]

在 Amazon SageMaker 中执行 ML 的示例管道

您也可以首先从仓库内不同的来源收集数据，然后使用 Spark 转换这些大型数据集，将它们加载到 S3 的 Parquet 文件中，然后从 SageMaker 读取它们，以防您更喜欢使用 SageMaker 而不是 Spark 的 MLLib。SageMaker 的一个额外优势是，它让您可以轻松部署，并通过 Lambda 函数触发模型，而 Lambda 函数又通过 API Gateway 中的 REST 端点连接到世界。我已经写了一篇关于这个架构的博文。另外学习 SparkJules Damji 的书学习 Spark 真的很棒。

这就完成了从熊猫到星火的博文。我们讨论了一些相似点和不同点，开始使用 Spark 的最佳方式，以及一些利用 Spark 的常见架构。

如有任何问题或意见，请通过 LinkedIn 联系我！

资源:
1。Jules Damji 讲述 Spark 如何工作的幕后故事。
2。朱尔斯·丹吉的《学习的火花》一书。
3。比较熊猫句法和安德鲁·雷的 PySpark talk 。

MPIRE for Python:多重处理非常简单

原文：https://towardsdatascience.com/mpire-for-python-multiprocessing-is-really-easy-d2ae7999a3e9?source=collection_archive---------1-----------------------

MPIRE 简介，这是一个速度极快且最用户友好的 Python 多处理库

Jarek Jordan 在 Unsplash 上的照片

Python 是一种流行的编程语言，原因有几个。最重要的是，它易于设置和学习，因此开发速度快。然而，一个主要的缺点是 Python 的执行速度。与许多其他流行的编程语言相比，Python 在速度方面排在最后。幸运的是，通过用 C 编写许多性能关键的库并添加 Python 包装器(例如 NumPy)，速度问题已经大大缓解了。这些解决方案运行良好，它们可以利用多线程进行并行计算。当您自己的代码降低了您的速度，并且您想要并行化纯 Python 代码时，事情就变得棘手了。

通过多线程，单个进程的多个线程被同时执行。用 C/C++编写的库可以毫无问题地利用多线程。Python 不能利用多线程，因为臭名昭著的全局解释器锁(GIL)。我不会去解释它是做什么的，为什么它还在这里，因为有很多关于这个话题的其他优秀的博客帖子。这里要记住的是，由于这个 GIL，Python 不能像其他语言一样利用多线程处理 CPU 密集型任务。(注意:对于 I/O 密集型任务和其他释放 GIL 的任务，多线程可以很好地工作。)

因此，Python 程序员经常需要依赖多重处理，新的进程同时产生和执行。通过产生新的进程，我们有效地避开了 GIL。然而，为了在这些进程之间进行通信，我们需要使用管道或队列。这些通信原语不仅降低了多重处理的速度，而且如果你不是很有经验的话，它们也很难使用。

有许多 Python 库提供了多处理能力，并且不需要编写所有样板代码来处理进程和进程间通信。例如，有multiprocessing.Pool 和concurrent.futures.ProcessPoolExecutor类，它们都可以在 Python 标准库中找到。此外，还有 Joblib 等第三方包，以及 Dask 和 Ray 等分布式计算包。后一类还提供了跨几台机器的计算。然而，在我 7 年的 Python 程序员生涯中，单台机器上的多处理通常就足够了，建立一个工人集群的额外成本得不偿失。

然而，即使有这么多图书馆，没有一个能让我满意。大多数都有一个陡峭的学习曲线，因为它们引入了一个全新的关于multiprocessing.Pool的编程语法，提供了很差的错误处理，或者根本没有提供我正在寻找的所有功能。因此，四年前，我创建了一个新的包，它可以完成所有这些功能，甚至更多。它已经在 Slimmer AI 的几十个项目中使用，经过几次迭代的反馈和在生产环境中的暴露，它已经成为今天的成熟包。它现在是 Slimmer AI 的首选多处理库，最近，我们在 GitHub 和 PyPI 上公开了它。文档可在这里获得。

在这篇博文中，我将介绍我们的多处理库 MPIRE(多处理真的很简单),并将它与现有的库在功能、易用性和速度方面进行比较。除了普通的串行处理，我对 MPIRE 进行基准测试的库有multiprocessing.Pool、concurrent.futures.ProcessPoolExecutor、、(一个multiprocessing.Pool的包装器)、Joblib、Dask 和 Ray。在这篇文章的剩余部分，我将用ProcessPoolExecutor来指代concurrent.futures.ProcessPoolExecutor。

MPIRE 概述

MPIRE 构建在流行的multiprocessing 标准库之上，大部分遵循相同的语法，这使得它非常容易学习。mpire.WorkerPool级类似于multiprocessing.Pool级，但是增加了更多的特性和配置选项。MPIRE 的主要特点是:

• 比其他多处理库执行速度更快
• 直观的 Pythonic 语法
• 优雅且用户友好的异常处理
• 通过一组工作人员轻松使用写入时复制共享对象
• 每个工作者可以有自己的状态，并且通过方便的工作者初始化和退出功能，可以容易地操纵该状态
• 进度条支持使用 tqdm
• 仪表板支架
• Worker insights 可让您深入了解多处理效率
• 子进程可以被固定到特定的或一系列的 CPU 上
• 多种进程启动方法可用，包括:fork、forkserver、spawn 和 threading(是的，threading)
• 可选地利用 dill 作为通过多进程的序列化后端，支持在 iPython 和 Jupyter 笔记本中并行化更多外来对象、lambdas 和函数

对于这篇博文来说，浏览所有特性太多了。因此，我将重点放在几乎每个多处理任务的相关特性上。请参考文档了解更多关于 MPIRE 的其他特性。

让我们看几个例子，并将 MPIRE 与其他库进行比较。

例 1。句法

假设我们有一个耗时的函数:

我们想调用 100 次并并行化:

Joblib 和 Ray 相对于multiprocessing.Pool引入了全新的语法。这意味着需要更多的时间来学习如何充分和优化地利用这些库。相比之下，MPIRE 的语法非常接近multiprocessing.Pool。

在没有多处理的情况下运行这个函数大约需要 100 秒，而所有经过测试的多处理库大约需要 20 秒。这是因为它们都被配置为创建 5 个流程，从而并行处理 5 个任务。在启动子进程和进程间通信时会有一些小的开销，但是在这种情况下预期会有 5 倍的加速。

示例 2:进度条

让我们添加一个进度条，让事情变得更有趣一点。当然，当你运行一个长任务时，你想知道任务的状态和完成的时间。我们将建立在前一个例子的基础上，利用tqdm作为进度条库。

在multiprocessing.Pool的情况下，如果我们想要显示实时进度信息，我们必须使用imap，一个返回生成器的map的惰性版本。尽管 Ray 有一个仪表板，但是在那里找不到进度信息。ProcessPoolExecutor和雷都引入了许多样板代码来实现进度条这样的琐碎工作。然而，雷在这里拿了蛋糕。当使用 MPIRE 时，我们可以简单地设置progress_bar标志，我们就完成了。

示例 3:异常处理

尽管您可能很有经验，但每个人都会偶尔引入 bug。在多处理上下文中调试异常并不总是容易的。然而，多重处理库至少可以使调试变得更容易。让我们看下面这个简单的例子:

现在，这个函数到处都在叫ZeroDivisionError ，这里只是为了说明。让我们看看不同的库将如何处理以下数据:

光线(上)、Joblib(中)、MPIRE(下)的错误输出。图片作者。

对于大多数库，我们可以确切地看到哪一行导致了错误，即return (x * y) / z。然而 Joblib 和 Ray 只表示发生在some_function的第 3 行。即使雷召唤出一个RayTaskError(ZeroDivisionError)，它仍然可以作为普通ZeroDivisionError被抓，所以那里不用担心。然而，这些回溯之间的主要区别在于，MPIRE 显示传递给导致错误的函数的参数。这使得调试更加容易。唯一做这件事的其他图书馆是 Dask。

MPIRE 包含更多的特性，其中一些将在接下来的基准测试部分展示。

基准

基准测试运行在一台具有 20 个内核的 Linux 机器上，禁用了超线程，内存为 200GB(对于这些基准测试来说已经足够了)。对于每项任务，使用不同数量的流程/工人进行实验，结果在 5 次运行中取平均值。各个库和基准测试的计时是一致的，所以为了使图形不那么混乱，省略了误差线。所有基准代码都可以在这里找到。查看[requirements.txt](https://github.com/sybrenjansen/multiprocessing_benchmarks/blob/main/requirements.txt) 文件，了解需要安装哪些依赖项。

基准 1:数字数据

该基准使用不同的图像过滤器处理图像。每个滤镜的图像保持不变。因此，能够以某种方式将图像发送给每个进程的库具有明显的优势。这在multiprocessing.Pool中是不可能的，因为你需要求助于multiprocessing.Process 并且自己处理所有的通信和启动/加入过程。不理想。对于 MPIRE，代码如下所示:

就这么简单。该映像作为一个写时复制共享对象传递给每个进程，这意味着数据没有被复制，但底层内存被重用。只有当进程改变图像数据时，才会制作副本。在我们的例子中，这种情况不会发生，所以我们是安全的，处理将会很快。

计时结果如下图所示:

数值计算基准测试结果平均超过 5 次运行。图片作者。

multiprocessing.Pool和ProcessPoolExecutor明显表现不佳，我们认为为他们使用 4 名以上的工人没有额外的好处。每次发送图像显然会导致大量开销。另一方面，随着工作人员数量的增加，其他库的计算时间确实持续减少。当使用 4 个或更少的工人时，Joblib 和 Ray 都比 Dask 和 MPIRE 慢一点，但之后它们会赶上来。最终，Joblib 和 MPIRE 胜出，尽管差距很小。

在这个基准测试中，Joblib 利用其 NumPy 内存映射特性来加速重复共享相同的图像对象。禁用此项会显著增加 Joblib 的总时间。所以重要的是要记住，当你在一个不是 NumPy 数组的对象上做简单的计算时，Joblib 不会那么快。

基准 2:有状态计算

在第二个基准中，每个工作者跟踪自己的状态，并且应该在新任务到来时更新它。正如在原始 Ray post 中一样，任务是处理文本文档并跟踪单词前缀计数——最多 3 个字符。每当某个前缀出现 3 次以上时，一旦处理完所有文档，就应该返回该前缀。

执行流前缀计数的简单类如下所示:

注意:StreamingPrefixCount 的这个实现类似于来自原始 Ray post 的，并不保证返回所有文档的正确前缀。然而，这在这种情况下并不重要，因为这个基准只是用来说明有状态计算。

对于 Ray 来说，Actor 功能运行良好。人们可以使用ActorPool 来很好地分配工作量:

对于 MPIRE，我们可以利用 https://slimmer-ai.github.io/mpire/usage/workerpool/worker_state.html [worker_state](https://slimmer-ai.github.io/mpire/usage/workerpool/worker_state.html)和[worker_exit](https://slimmer-ai.github.io/mpire/usage/map/worker_init_exit.html)功能。在这种情况下，我们还可以利用写入时拷贝:

与其他库相比，样板代码的数量有限。与 Ray 一样，还有一个额外的好处，即负载会自动在工作人员之间进行平衡。

multiprocessing.Pool、ProcessPoolExecutor和 Joblib 对 worker 状态没有支持，需要依赖 Python Manager对象。使用Manager对象的缺点是它们存在于独立的服务器进程中，任何状态变化都必须通过代理传递给它们。因此，这些库的性能受到了很大的影响，与串行处理相比，性能更差。

5 次运行的平均有状态计算基准测试结果。图片作者。

串行处理的时间在这里有一点波动，尽管它只能利用一个工作线程。对于这个基准测试，每个工作者都有自己的状态，并保持本地前缀计数。为了使比较公平串行处理还利用了多个StreamingPrefixCount 对象，等于工人的数量。

从结果来看，Dask 在速度上显然很难赶上 Ray 和 MPIRE。如果 Dask 要修复他们的Actor 实现，可能会不相上下。雷和姆皮尔的表现差不多。虽然，MPIRE 一直比它快一点点，但差距很小。

基准 3:昂贵的初始化

在该基准中，神经网络模型用于预测图像数据集上的标签。(注:为了简单起见，反复使用同一个数据集进行预测。)加载这个模型只需要几秒钟。但是如果每项任务都需要这样做，那么时间会很快增加。虽然这个基准看起来与前面的例子相似，但是这个基准不需要跟踪工作状态的变化。

对于下面的代码片段，假设我们有一个Model 类，它在创建时加载到模型和数据集中。对于multiprocessing.Pool，代码如下所示:

对于 MPIRE，我们再次利用[worker_state](https://slimmer-ai.github.io/mpire/usage/workerpool/worker_state.html)。这一次，我们还使用了[worker_init](https://slimmer-ai.github.io/mpire/usage/map/worker_init_exit.html)功能:

我们可以在这里再次利用写时复制，但是 Tensorflow 模型在这样做的时候并不好用。然而，使用worker_init功能也一样快。注意，我们将keep_alive设置为True。默认情况下，MPIRE 会在一次map调用后关闭工作线程，以减少内存需求。由于 MPIRE 启动和停止工作线程的速度非常快，而 Python 可能非常需要内存(它倾向于将分配的内存保持在备用状态)，这通常是所希望的行为。然而，在这种情况下，我们不希望每次运行都重新加载模型，所以我们保留了工作线程。方便的是，当退出上下文管理器时，它们会自动关闭。

昂贵的初始化基准测试结果平均超过 5 次运行。图片作者。

Joblib 和 Dask 一开始都表现不错，但很快被 Ray 和 MPIRE 超越。multiprocessing.Pool和ProcessPoolExecutor似乎在最后赶上了，但是你必须意识到，如果加载模型的时间增加，它们之间的差异——以及像 Ray 和 MPIRE 这样的库——也会增加。

总体基准性能

当将基准计时标准化到 0–1 的范围并取平均值时，我们看到以下趋势:

平均归一化基准结果。图片作者。

所有多处理库都可以超越单核性能，这是关键所在。Joblib 明显优于multiprocessing.Pool和ProcessPoolExecutor，反过来 Dask 也击败了 Joblib，因为它有存储状态的能力。MPIRE 和 Ray 的性能甚至比 Dask 还要好，是首选。

虽然 Ray 和 MPIRE 的速度差不多，但是当您只能在一台计算机上使用时，MPIRE 的易用性使其成为更有趣的库。

摘要

这篇博客文章介绍了 MPIRE，这是一个用于 Python 的多处理库，它易于使用，包含许多特性，并且在速度方面一直胜过所有其他的多处理库。

MPIRE 不仅具有直观的 Pythonic 语法，还具有本机进度条支持和用户友好的异常回溯。后者将减少您的调试时间，并让您的注意力集中在重要的地方:尽可能快速地执行您的工作。

如果你发现 MPIRE 是一个对你自己的工作有价值的多重处理工具，我很乐意听到你的意见。我希望它为你提供效率收益，就像它为我们在 Slimmer AI 提供的一样。

mpl finance——matplolib 相对不为人知的用于绘制金融数据的库

照片由 Yiorgos Ntrahas 在 Unsplash 上拍摄

包括快速创建图表的方法，如烛台，连科，或点和图

众所周知，matplotlib是非常通用的，可以用来创建几乎任何你想要的图表。这可能不是最简单或最漂亮的，但在 StackOverflow 上看了足够多的问题后，它很可能最终会很好地解决。

我知道在纯粹的matplotlib中创建像蜡烛图这样的金融图表是可能的，但这不是最愉快的体验，有更简单的方法来使用库，如plotly或altair(我在的另一篇文章中介绍了这一点)。然而，直到最近我才发现matplotlib有一个单独的库/模块专门用于金融策划。它叫做mplfinance，在这篇文章中，我将展示它的一些漂亮而独特的特性。

设置

设置相当标准。首先，我们导入库。

然后，我们下载股票价格来处理——对于本文，我们使用 2020 年下半年的苹果股票价格。如果你对下载股票价格的更多细节感兴趣，你可以看看我的另一篇文章。

OHLC 海图

mplfinance提供了几种有助于分析资产价格模式的图表。第一个，也是库中默认的一个，是 OHLC 图表。我们可以简单地使用plot函数来创建它:

mpf.plot(df["2020-12-01":])

其中df是一个包含 OHLC 数据的pandas数据帧和一个DatetimeIndex。我们将数据限制到上个月，只是为了清楚地看到该图元素的形状。

作者图片

这种解读与蜡烛图非常相似。左边的横线表示开盘价，右边的横线表示收盘价。垂直线代表价格的波动性，我们可以从两个极端读取高/低价格。

在这一点上，值得一提的是mplfinance提供了一种在一个图表上堆叠多层信息的简单方法。例如，假设我们想将最高价和最低价作为线添加到先前创建的绘图中。我们可以使用make_addplot函数轻松做到这一点，如下所示。我们首先定义附加行，然后将它们作为额外的参数传递给绘图函数。

运行该代码会生成下面的图像，该图像仅确认垂直线的极值对应于给定日期的最高价和最低价。

作者图片

自然，这是一个简化的例子。在更复杂的情况下，我们可能会对添加一些技术指标感兴趣，例如，布林线或简单的移动平均线。我们将很快回到后一个问题。我们也可以使用相同的功能来创建符号，显示我们进入/退出位置。你可以在这里找到一个很好的例子。

蜡烛图

下一个可用的图表类型是烛台图表。用mplfinance生成它们就像给plot函数添加一个额外的参数一样简单。

mpf.plot(df["2020-12-01":], type="candle")

作者图片

当你看着蜡烛和日期时，很明显有一些遗漏的日期。这自然是因为市场在周末和一些特殊的日子是关闭的。如果你想考虑这一点，你可以给plot函数提供一个额外的参数:

mpf.plot(df["2020-12-01":], type="candle", show_nontrading=True)

作者图片

让我们给情节添加更多的信息。首先，我们可以向plot函数传递一个方便的参数—— mav ——它会自动添加我们想要的任何简单的移动平均线。对于这个情节，我们来取 10 天和 20 天的 MAs。其次，我们还可以添加交易量。

mpf.plot(df, type="candle", mav=(10, 20), volume=True)

作者图片

伦科图表

老实说，mplfinance是我第一次看到以下两种剧情，因为它们不像《OHLC》和《烛台排行榜》那样受欢迎。第一种被称为伦科图表，它是利用价格变动构建的，不像大多数图表那样考虑标准化的时间间隔。

在实践中，它的意思是，当价格移动一个特定的量时，一个新的块被创建，每个后续的块与前一个块成 45 度角添加，或者在它的上面或者在它的下面。

Renko 图表最常见的用途是从价格序列中过滤噪声，并帮助识别价格趋势。这是因为所有小于指定方框大小的价格变动都被过滤掉了。

我们可以通过在使用plot函数时简单地指定type参数来创建 Renko 图表。

mpf.plot(df,type="renko")

作者图片

我们也可以根据自己的喜好修改砖块的大小。在下面的代码片段中，我们将其设置为 2。

mpf.plot(df, type="renko", renko_params=dict(brick_size=2))

作者图片

点数图

库中可用的最后一种绘图类型是点数图。与伦科图表类似，它没有考虑时间的流逝。P&F 图使用堆叠的 X 和 O 柱，每个符号代表一个特定的价格变动(由盒子大小决定，我们可以根据自己的喜好调整)。

x 代表价格上升一定的量，而 O 代表下降。我们需要的最后一条信息是创建不同符号的新列的条件(O 跟在 X 后面，反之亦然*)。为了创建一个新的列，价格必须按照冲销金额进行更改，该金额通常设置为盒子大小的三倍(在mplfinance中，默认值为 1)。*

*mpf.plot(df, type="pnf")*

作者图片

我们可以很容易地将这张 P&F 图与第一张伦科图进行比较，以发现完全相同的模式。

添加风格和一般美化

使用mplfinance创建的情节对于一句俏皮话来说已经很好看了，所以肯定是在纯粹的matplotlib中不会经常发生的事情。然而，我们可以使用 plot 函数中更多的选项来使我们的绘图更加漂亮。

对于下一个情节，我们改变比例的数字，添加一个标题，选择紧凑的布局和应用一种风格。我们使用币安风格，这使得情节类似于流行的加密交换。

作者图片

就我个人而言，我认为对于我们必须编写的额外代码来说，这是一个很大的改进。如果您想知道库中有哪些样式，可以使用以下命令查看所有样式:

*mpf.available_styles()*

最后，我们还可以轻松地将图形保存到本地文件中。为此，我们只需向plot函数的savefig参数提供文件名。代码将如下所示。

外卖食品

• mplfinance是matplotlib投资组合中的一个库，专门用于绘制资产价格数据
• API 非常容易使用，我们经常可以用一行程序创建漂亮的图表
• 该库提供了一些不常见的绘图类型，如 Renko 图或点和图形图

您可以在我的 GitHub 上找到本文使用的代码。此外，欢迎任何建设性的反馈。我也很好奇你是否听说过 Renko/Point 和 Figure 图表，甚至可能在实践中使用过它们。你可以在推特或评论中联系我。

如果你有兴趣学习如何使用 Python 进行量化金融，你可能想看看 Quantra ( 免责声明:一个附属链接)，它提供了关于这个主题的各种不同的课程。

来自《走向数据科学》编辑的注释: 虽然我们允许独立作者根据我们的 规则和指南 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

如果您喜欢这篇文章，您可能还会对以下内容感兴趣:

*</9-useful-pandas-methods-you-probably-have-not-heard-about-28ff6c0bceee> [## quantra——学习量化金融的 Python 编码平台

towardsdatascience.com](/quantra-a-python-coding-platform-to-learn-quantitative-finance-8e5e88c89120)*

“MRMR”准确地解释了你希望别人如何向你解释

原文：https://towardsdatascience.com/mrmr-explained-exactly-how-you-wished-someone-explained-to-you-9cf4ed27458b?source=collection_archive---------1-----------------------

想要改进您的功能选择吗？“最大相关性-最小冗余度”(又名 MRMR)是优步的机器学习平台使用的一种算法，用于寻找“最小最优”的特征子集。

[作者图]

MRMR(最大相关度-最小冗余度的首字母缩写)是一种特征选择算法，在优步工程师于 2019 年发表这篇论文后获得了新的流行:

截图来自:来源。

作者展示了他们如何通过MRMR在各种营销应用中实现自动特征选择，其中包括:

• 用户获取，
• 交叉销售/追加销售，
• 用户流失和重新激活。

然而，MRMR 并不是最近才被发现的。这是由两位伯克利的研究人员在 2005 年发表的论文中首次提出的:

截图来自:来源

作者声称，在成千上万的基因中，选择其中的几个(例如 50 个)就足以实现这项任务(预测疾病)的最高准确度。所以关键是:我们如何找到这 50 个幸运儿？这正是 MRMR 最初设计的目的。

从这两个例子中，很明显MRMR有多灵活，这可以在完全不同的领域证明是有用的，从市场营销到基因组学。

在这篇文章中，我们将看到 MRMR 是如何工作的，以及它与其他流行的特征选择算法(如博鲁塔)有何不同(如果你想了解更多关于博鲁塔的信息，我已经写了一篇专门的帖子:博鲁塔准确地解释了你希望别人如何向你解释)

最小最优与所有相关

特征选择算法可以大致分为两类:

• 极小最优(如MRMR)；
• 全相关(如博鲁塔)。

特征选择就像玩飞镖…[作者图]

最小最优方法寻求识别一小组特征，这些特征— 放在一起具有最大可能的预测能力。另一方面，全相关算法被设计成选择所有特征，这些特征分别和具有任何预测能力。

因此，如果特征 A 和特征 B 都是相关的，但是它们带来或多或少相同的信息，那么全相关方法将选择它们两个，而最小最优方法将只选择其中一个并丢弃另一个。

这似乎是一个细微的区别，但在实践中却有很大的不同。想象一个场景，我们有一万个特征。你用 Boruta 你发现其中的 5000 个和目标变量有某种关系。但是五千仍然是一个难以管理的功能数量。

在丁和彭的例子中，你可以用一个小得多的模型，例如 50 个特征，达到同样的(或者更高的)精度。但是，如何选择它们呢？从 Boruta 拿前 50 的特性是行不通的。事实上，它们中的许多可能彼此高度相关:它们不会添加太多信息。

开发 MRMR 就是为了解决这个问题。

“K 个最佳特征并不是 K 个最佳特征”

我们举个玩具的例子。假设我们的任务是预测一些人的收入，知道他们(或他们的亲属)的一些特征。我们处理这些特性:

玩具数据集。[作者图]

让我们假设我们知道变量之间的因果关系(这是我们在现实生活中不经常拥有的特权，但是它对理解 MRMR 背后的逻辑很有用)。

变量之间的因果联系[作者提供的图表]

知道了因果网络将使特征选择变得简单得可笑:我们将选择{ 年龄、智商、身高 }，因为这些是唯一与目标变量有直接因果关系的特征。添加任何其他元素都会带来不必要的噪音。

然而，这些特征并不一定是对目标变量具有最强预测价值的特征。总结如下:

"最好的 K 个特征并不是 K 个最好的特征."(改编自 T. M .封面)。

这是什么意思？

例如，以母亲的智商为例:它与收入没有直接联系，但与智商有联系，而后者又与收入有很大联系。所以，如果你测试一下，你会发现妈妈的智商和收入之间有相当强的关系。但是既然我们的模型中已经有了智商，保留母亲的智商就没有意义了。

K 最佳特性与 K 最佳特性，K = 3。每个特征都与它与收入关系的“强度”(F-统计量)相关联。[作者图]

一般来说，这意味着只关注每个特征和目标变量之间的关联是不够的。

我们希望找到 K 个最佳特征，而不是 K 个最佳特征！

这正是 Boruta 的问题所在:它为每个特性提供了单独的评估。事实上，在我们的例子中，Boruta 会选择所有 7 个特征，因为它们都与收入有一定的统计相关性。

这在我们没有太多功能的情况下是有意义的。但是，在实际应用中，经常会发生这样的情况:

• 我们不知道特征和目标变量之间的因果关系；
• 我们有太多的特征；
• 特征中有高度的冗余。

在这些情况下，可能是像博鲁塔这样的全相关算法太“放纵”了，而 MRMR 能够移除不必要的特征。

变量之间的因果联系[作者提供的图表]

所以，现在的问题是:MRMR 是如何工作的？

在 MRMR 的引擎盖下

使用 MRMR 时，你基本上只需要做一个选择:决定你想要保留的特性的数量。我们将称这个数字为 K。在我们的例子中，我们将取 K =3。

在实际应用中，人们可以根据领域知识或其他约束来选择 K ，例如模型容量、机器内存或可用时间。

MRMR 迭代地工作。在每一次迭代中，它(根据规则)识别最佳特性，并将其添加到所选特性的篮子中。一旦一个特性被放进桶里，它就再也出不来了。

在我们的例子中，这些是我们在每次迭代结束时得到的结果:

K = 3 时的 MRMR 过程[图由作者提供]

在每次迭代中，决定选择“最佳”特征的规则是什么——即第一步的智商，第二步的年龄和第三步的身高？这是 MRMR 的核心。

**“最大相关性-最小冗余度”之所以这样叫是因为——**在每次迭代中——我们希望选择与目标变量具有最大相关性的特征，以及与先前迭代中已经选择的特征具有最小冗余度的特征。

实际上，在每次迭代 i 时，为每个待评估的特征计算分数( f ):

一级方程式赛车。MRMR 概观[作者图]

迭代 i 中的最佳特征是得分最高的特征。就这么简单。

现在唯一的问题是如何计算分子和分母。基于这一决定，优步论文的作者们识别出了 MRMR 的许多变体，如中旬、 MIQ 、 FCD 、 FCQ 、 FRQ 、 RFCQ 和 RFRQ 。然而:

由于 FCQ 非常简单和快速，并且通常比其他算法运行得更好，所以我将把重点放在这个变体上(顺便说一下，扩展到其他变体很简单)。

特征 f 在第 i 次迭代(分子)的相关性计算为特征和目标变量之间的 F 统计量(此处为进一步了解 F 测试)。冗余度(分母)被计算为该特征和在先前迭代中选择的所有特征之间的平均(皮尔逊)相关性。所以，公式变成了:

方程式 2。MRMR 公式(FCQ 变体)[作者提供图片]

其中 i 是第 i 次迭代， f 是被评估的特征， F 是 F 统计量， corr 是皮尔逊相关。请注意，相关性是以绝对值表示的。事实上，如果两个特征具有 0.9 或 0.9 的相关性，这没有什么区别:在这两种情况下，它们都是高度冗余的。

为了让事情变得更清楚，假设我们处于第三次迭代。这是之前发生的事情:

• IQ 已在第一次迭代时选择；
• 年龄在第二次迭代时被选中。

接下来我们应该选择哪个功能？

计算每个特征的分数只需要 F 统计量和相关性:

第 3 次迭代中发生的情况的图示。[作者图]

如上所述，下一个最佳特征是得分最高的特征，在本例中是高度*。*

从头开始的 Python 实现

我们上面描述的迭代过程很容易在 Python 中实现:

MRMR 的 Python 实现(FCQ 变体)[作者代码]

这个实现非常容易理解。然而，这是次优的。你能找出原因吗？

在上面的代码中，我们计算了很多我们永远不会用到的相关性。事实上，在第 6 行，我们正在处理所有可能的特征对。这意味着 F * ( F - 1) / 2 对。对于 F = 10，000，这将意味着5000 万次关联！

通过只处理我们在每次迭代中需要的特征对，我们可以节省更多的时间，即计算“进行中”的相关性。这可以节省我们很多时间。

毕竟，在每次迭代时，我们只需要计算前一次迭代选择的特征与所有从未选择的特征之间的所有相关性，并将它们存储在一个相关矩阵中。这意味着:

• 第一次迭代:不需要关联。事实上，还没有选择任何特征:选择具有最高分数(即最高 F 统计量)的特征就足够了。
• 第二次迭代: F - 需要 1 个相关性。
• 第三次迭代: F - 需要 2 个相关性。
• …
• K 次迭代: F - K + 需要 1 次相关。

*现在，做数学很容易:这个过程需要计算少于 F ** ( K - 1)的相关性。如果 F =1 万， K =50，这就得出一个合理得多的数字:小于 50 万的关联。

这个改进的版本看起来像这样:

MRMR 的一个更快的 Python 实现(FCQ 变体)[作者代码]

除了第 11 行和第 21–23 行之外，这几乎等同于上一个版本。

给我一个“pip 安装”

*pip install mrmr_selection*

这是如何在熊猫数据框架上使用它的一个片段:

*from mrmr import mrmr_classif
from sklearn.datasets import make_classification

# create some data
X, y = make_classification(n_samples = 1000, n_features = 50, n_informative = 10, n_redundant = 40)
X = pd.DataFrame(X)
y = pd.Series(y)

# use mrmr classification
selected_features = mrmr_classif(X, y, K = 10)*

结论

我们已经看到了为什么 MRMR 在许多实际问题中是一个有用的特征选择步骤:因为它试图找到一小组与目标变量相关并且彼此几乎没有冗余的特征。

MRMR 的价值不仅在于它是有效的(正如优步的论文所证明的)，还在于它的简单性使得它可以在任何管道中快速而容易地实现。

感谢您的阅读！我希望这篇文章对你有用。

我感谢反馈和建设性的批评。如果你想谈论这篇文章或其他相关话题，你可以发短信给我我的 Linkedin 联系人。

MS-DAYOLO:用于跨域目标检测的多尺度域自适应 YOLO

原文：https://towardsdatascience.com/ms-dayolo-multiscale-domain-adaptive-yolo-for-cross-domain-object-detection-d7912a9de975?source=collection_archive---------28-----------------------

提高检测器对畴变的鲁棒性

当测试数据的分布与训练数据的分布不同时，会发生域转移问题，导致目标检测模型的性能下降。例如，对象检测器是针对在晴朗天气和有利天气下捕获的图像数据进行训练的，但它适用于测试阶段的恶劣天气场景，包括灰尘、雨或雾。虽然已经提出了许多先进的对象检测方法，包括 R-CNN 网络家族(R-CNN，Fast R-CNN，Faster R-CNN，Cascade R-CNN)或 YOLO 系列(YOLOv1-v4)，但研究人员只专注于在基准数据集上的性能，如 COCO，VOC，WAYMO，Cityscapes 等。其中包括干净图像数据和对象检测中的域移动。近年来，这个主题被更广泛地研究，有时它被称为术语领域适应。在这篇文章的剩余部分，我将回顾一个新的多尺度域自适应 YOLO (MS-DAYOLO)框架，用于跨域对象检测。

戴约洛女士

MS- DAYOLO 的建筑(图片见诸报端[ 来源)

MS-DAYOLO 的架构如上图所示。一般来说，MS-DAYOLO 是基于 YOLOv4 开发的，它几乎采用了 YOLOv4 的主要组件。主要区别在于，有一个域自适应网络(DAN ),它连接到主干上，以鼓励主干学习域不变特征。具体来说，如上图所示，DAN 连接到主干中的特征地图 F1、F2 和 F3。作者已经考虑利用特征图 F1、F2 和 F3，因为这些特征被直接馈送到检测器的颈部，从而它们携带了输入图像的主要信息，这可能有利于训练 DAN。

域自适应网络(丹)

为了避免获得实时对象检测器中最重要的计算，DAN 仅在训练期间被集成到主干中。DAN 的任务是预测输入图像是否在源域(完成训练的域)或目标域(没有训练模型的新的域)。

DAN 被优化以最小化域分类损失 L_dc ，其被计算为以下二元交叉熵损失函数:

其中 i 为训练图像的索引， t_i 为领域标号( t_i = 1:源领域， t_i = 0:目标领域)， p(x，y) 为特征图位置 (x，y) 处的预测领域概率。

另一方面训练骨干最大化 L_dc 学习不变特征。也就是说，为了使对象检测器对域的变化具有鲁棒性，应该鼓励检测器学习输入图像中的显著内容(或显著对象),即使图像是在任何条件下捕获的。如果这一过程操作得当，可以提高检测机的性能和稳健性。

丹被优化为最小化 L_dc ，而骨干被训练为最大化 L_dc ，这导致了联合最小值-最大值问题。

总损失

总损失函数公式如下:

其中 L_det 是检测损耗，而 λ 是用于平衡总损耗的负标量。 λ 的负值可以解释为解决前段提到的联合最小-最大问题。换句话说， λ 负责控制 DAN 对整个网络性能的影响。关于 λ 的进一步详细解释可以在论文中找到。

结果

表 1 显示了 Cityscapes 数据集上不同适应配置的定量结果。表中， P 、 R 、 C 、 M 和 B 是代表人、骑手、汽车、摩托车和自行车的类别名称。通过对 DAN 采用所有三个特征映射 F1、F2 和 F3，已经实现了最佳性能。

表 Cityscapes 数据集的定量结果(论文中的表格[ 来源 ])

表 2 显示了在 BDD100K 和 INIT 数据集上验证 YOLOv4 和 MS-DAYOLO 时的性能比较。

表 BDD100K 和 INIT 数据集的定量结果(论文中的表格[ 来源 ])

使用 YOLOv4 和 MS-DAYOLO 对雾状图像数据进行目视检测的结果如下图所示:

视觉检测结果:(a)清晰图像上的 YOLOv4，(b)模糊图像上的 YOLOv4，(c)模糊图像上的 MS-DAYOLO。(论文中的图像[ 来源 ])

结论

在这篇文章中，我简要回顾了一种新的多尺度域自适应 YOLO (MS-DAYOLO)框架，用于跨域对象检测。正如论文中提到的，MS-DAYOLO 是第一个提出考虑改进 YOLO 模型来处理畴变问题的工作。在自动驾驶应用的各种测试场景下，MS-DAYOLO 已被证明优于最初的 YOLOv4。

欢迎读者访问我的脸书粉丝页面，这是一个分享关于机器学习的事情的页面:深入机器学习。我发布的关于物体检测的其他值得注意的帖子包括:

• 约洛夫 4–5D 评论
• 达克拉斯
• EFPN
• 数据增强
• 雾霾数据合成

感谢您抽出时间！

利兹大学数据科学硕士:我的经历(2018/19)

原文：https://towardsdatascience.com/msc-data-science-at-leeds-my-experience-2018-19-926e007989b7?source=collection_archive---------31-----------------------

我的数据科学硕士的全面崩溃。

介绍

硕士压力大，费用高。我已经在这里讨论了我认为数据科学硕士学位是否值得。这一次，我想谈谈我在利兹大学的数据科学硕士学位会很有帮助。

难怪有人问我，我的数据科学硕士是什么样的。一些人想知道是否值得攻读数据科学硕士学位。其他人特别想知道更多关于利兹大学提供的课程。

我会试着在不太无聊的情况下尽可能深入。以下是我将要讲述的内容:

• **申请流程:**这是我申请流程的一个非常笼统的概述，因为我记不太清了。
• **课程结构:**我在利兹一年的整体结构。
• **模块结构:**不同学校的模块结构不同。
• **我最喜欢的模块:**我最喜欢的模块。
• **我的学位论文:**学位论文过程和我的经历。
• **评分:**利兹如何以我的成绩单为例计算硕士研究生的成绩。
• **利兹数据科学协会:**一个伟大的协会，提供基于团队的数据科学项目供参与。

现在，我充分意识到，并不是每个阅读这篇文章的人都打算去利兹大学学习。即使你对这门课程不感兴趣，希望你仍能从我在英国攻读数据科学硕士的经历中学到一些东西。

同样值得注意的是，数据科学硕士是一个相对较新的事物。因此，如果全国数据科学硕士的课程结构和模块选择与我学生时代相比发生了显著变化，我不会感到惊讶。

应用进程

由 Kelly Sikkema 在 Unsplash 上拍摄的照片

入学要求

在你申请之前，大多数数据科学硕士希望你有某种数学或计算背景。至少，大多数大学希望你至少有一个 2:1(荣誉)的学位。如果你是一名国际学生，那么有一个额外的语言要求，即雅思总分 6.5 分，所有部分都不低于 6.0 分。

我见过一些没有多少数学背景的学生，他们几乎没有任何计算机知识。他们还是通过了申请，所以要求可能没那么严格。这当然取决于大学，因为我想象一些大学(如牛津和剑桥)比其他大学严格得多。

应用和成本

我在 2018 年 6 月左右开始申请，我记得申请过程相当简单。要申请，我必须点击官方课程页面上的申请按钮创建一个帐户。然后我记得填写了一堆关于我自己的基本信息。

申请中最耗时的部分是写我的个人陈述。我记得我只是写了我的现状和为什么我想学习数据科学。有趣的是，我的一些留学生朋友说他们甚至不需要写个人陈述。正因为如此，我不确定这个要求有多一致。

几周后，大学通过电子邮件和信件回复了我，并无条件录取。他们解释了基本的课程细节和学费，并指导如何接受提议。当时的学费是 10000，因为我是校友，所以打了 1000 的折扣。如果你是国际学生，学费会贵得多(如今高达 25，000 多英镑)。

接受报价后，他们给我发了一封接受邮件和信。不久之后，我收到了两本小册子，里面有更多关于大学校园和我的提议的信息。

课程结构

万花筒在 Unsplash 上拍摄的照片

时间线概述

一般来说，英国高等教育的学年大约在九月或十月开始。考试通常在一月和六月举行。

如果你在读硕士课程，那么你就要用这个夏天剩下的时间来写论文。你通常在八月或九月左右完全完成，之后你将等待毕业。

信用

在利兹大学，每个模块完成后都有一定的学分。这些课程通常从 10 到 15 学分不等，有些课程相当于 20 学分。唯一的例外是价值 60 学分的论文。

这门课程有必修和选修单元。为了让我通过考试，我的模块必须总计达到 180 或 185 学分。

我还需要通过至少 135 学分的“5M 级”模块。这些模块只有硕士生才能修。然而，5M 级模块也有“3 级”版本，适用于来自不同课程的最后一年本科生。这意味着硕士生和本科生一起分享大部分课程。

参加 5M 级别课程的学生有额外的课程来覆盖更深入的内容。因此，期末考试有额外的问题，完全是让 500 万学生回答的。

模块

第一学期有必修的计算机科学模块，第二学期有数学模块。在选修课方面，选择的模块主要包括数学和计算机科学。我记得有一些地理和商业模块，但这些选择较少。事实上，我所有的模块不是数学就是计算机科学。

每学期之前，每个人都必须在设定的时间范围内登录选择他们的选修模块。我必须从三个列表中选择:A、B 和 c。

要求是从列表 A 和 B 中选择至少 30 学分的模块，从这些列表中总共选择至少 60 学分。一旦完成，我们可以从列表 c 中选择更多。

请记住，5M 级模块的 135 学分规则适用于全年。为了平衡我的工作量，我试图将这些模块尽可能均匀地分布在两个学期中。

由于这种结构，由于时间表冲突，不可能总是注册某些模块。有人告诉我们，如果我们能补上错过的课，还是有可能报名的。在这些情况下，方案主管也需要批准。

论文

名单:选择论文题目的正式程序要到第二学期才开始。然而，我们在第一学期就意识到要提前计划我们的选择。

第二学期之前也没有正式的名单。就我所能记得的，我相信他们在第二学期开始和中期的某个时候公布了名单。如果没有感兴趣的题目，我们也可以向论文协调员建议我们自己的题目。然后他们会试图找到合适的主管来配合你的主题。

这个列表相当大，大约有 50 个主题。虽然这门课严格来说是在数学学院下，但是这个列表包含了数学和计算机科学的主题。也有来自商业和心理学的话题。

**主题:**每个主题都包含一个描述、目标，有时还包含一个资格要求。在有需求的情况下，我们需要有合适的技能或者已经学习了某些模块。

他们也可以分配一个以上的学生。根据我的经验，最受欢迎的通常是与机器学习有关的计算机科学话题(炒作是真实的)。例如，有一个涉及 Airbnb 数据，我知道很多学生申请只是因为这个名字(我对此感到内疚)。

同样重要的是，我们与其他课程的硕士生分享了一些话题。例如，计算机科学导师可能会优先考虑计算机科学的学生，而不是这门课的学生。我个人曾试图申请计算机科学学院的大型机器学习课题(如 Airbnb 的课题),但都没有成功。

选择截止日期:最终提交的截止日期是三月底。我们必须选择三个偏好，并将其发送给协调员。如果他们不批准任何一个，那么我们必须选择另一个。

正如你所看到的，提前考虑你的论文将涉及的内容是非常有用的。这样做将有助于在第一和第二学期选择模块。

模块结构

由 Dom Fou 在 Unsplash 上拍摄的照片

根据学校的不同，模块的结构可能会有很大的不同。由于我只修了数学和计算机科学模块，所以我只能对这两个模块进行评论。

数学:数学模块可能非常激烈，尤其是 5 米级的。对于评分，大部分权重是期末考试，通常占 80%。其余的由分散在整个学期的课程组成。根据教授的不同，我们每周或每两周收到一份作业。

每份作业通常由一系列问题组成。这些通常是像证明，“证明这是真的”和计算问题。对于一些模块，我们不得不做一个更重要的统计项目。

在我看来，数学模块给人的感觉更加死板，缺乏创造力。如果你熟悉数学，那么这可能并不奇怪。此外，如果你有其他大项目要做，每周或每两周一次的课程可能会让你不知所措。我认为重考的好处是，即使你弄乱了一些功课，你总体上仍然可以做得很好。

计算机科学:这些模块在期末考试中的权重通常低于数学模块。因此，通常更重视课程，有些课程的权重高达 40%。从我的经验来看，大多数计算机科学模块都有大约两份作业。这些通常在你如何对待他们方面提供了相当大的灵活性。大多数教授只关心你解决了问题，并且它有效。

与数学模块相比，还有更多的实验室会议来帮助完成课程。随着对课程的重视，我想这是有道理的。计算机科学模块的另一个关键区别是，你可以带自己的笔记参加考试。这来自一个数学学位，感觉很神奇。这绝对有助于我不再像记忆数学模块那样感到记忆公式的压力。

我最喜欢的模块

由 Unsplash 上的 Matese Fields 拍摄

我觉得提供一些关于我最喜欢的模块的见解可能会有所帮助，因为你们可能也在学习相同的模块。显然，从那时起事情可能已经改变了，所以请记住这一点。我做的大部分模块都是 5M 级的。如果你想看我做的每个模块，你可以跳到评分部分。

由于我过去是一名分析师，我选择了那些我认为在当时有用的模块。我还尝试挑选了一些我认为在我作为数据科学家工作时可能有用的信息。虽然很诱人，但是最好避免选择看起来简单的模块。毕竟硕士学位并不便宜，所以你不妨充分利用它。

机器学习(5M 级计算机科学)

这个模块总体上是对机器学习的一个很好的介绍。这位教授对这个话题充满热情，真诚地想帮助学生。我们讨论了决策树、卷积神经网络和强化学习等算法。可能会涉及到相当多的数学知识，我们应该把这些内容牢记在心。因此，线性代数的先验知识对这个模块非常有用，尤其是在学习神经网络的时候。

机器学习非常受欢迎。它是如此受欢迎，以至于第一次讲座没有足够的空间来容纳所有的学生。有些人甚至不得不坐在地板上！

几周后，随着人们转向这个模块，班级变得更大了。如今，我只能想象它会比以前更受欢迎。

第一次机器学习讲座。教授没想到会有这么多学生！

期末考试占 80%的权重，其余的是课程作业。课程之一是使用 Keras 实现一个神经网络架构。教授给了我们一个模板，让我们在上面工作，第一次训练神经网络非常酷。

第二个课程是使用强化学习训练一个人工智能玩游戏。这个很难，需要和很多其他学生一起合作。

我要说的是，尽管有难度，这个模块中的课程作业是最有趣、最令人愉快的。尝试用代码实现数学理论并看到它的工作是很好的。

统计学习(5M 级数学)

我想把统计学习看作机器学习的统计方法。统计学习和机器学习都侧重于使用过去的数据来训练模型进行预测。

不同之处在于，统计学习没有从“算法”的角度来处理这个问题。相反，我们学习统计建模和在数学层面评估模型性能的重要性。

令人惊讶的是，该模块对考试和课程的重视程度相当。也就是说，考试和课程各占 50%的权重。这对于一个数学模块来说是很不寻常的，但这一次数学考试压力小了也不错。

在我看来，统计学习很好地补充了机器学习。在模型方面，我们学习了基础知识:线性回归、逻辑回归和带有 boosting 和 bagging 的决策树。然后很大一部分集中在评估这些模型，并知道如何统计选择最好的模型。

教授也很棒，他很好地解释了概念。即使没有统计学背景的人也会发现这个模块是可行的，因为它集中在统计建模的基础上。如果你对机器学习很认真，并且想拥有数据建模的统计学基础，那么我会推荐你学习这个模块。

数据挖掘和文本分析(5 级计算机科学)

本模块重点介绍对文本数据使用机器学习算法。随着对图像数据使用机器学习的大肆宣传，我觉得知道如何处理文本数据也很重要。虽然涉及到一些数学，但与机器学习等模块相比，这是最少的。

我们学会了如何使用一种叫做 Weka 的工具。自从我毕业后，我还没见过或听说过有人使用这个工具，所以我怀疑它对你的简历有多大用处。基本上，它是一个允许你挑选机器学习算法应用于文本数据的工具。我们将它用于我们的课程作业，它有助于在高层次上了解如何应用这些算法。然而，感觉我只是在挑选魔法药水，看看哪种效果最好，而不需要了解一切。

尽管如此，我还是觉得讲座材料很有趣。我们学习了如何对自然语言和文本分析建模。我们还学习了机器翻译、信息检索、聊天机器人和文本分类。

这位教授很奇怪，但讲课笔记很不错。期末考试占 60%的权重，其余的是课程作业。总的来说，我认为这个模块相对简单。这感觉像是一个“不太严重”的问题，但它仍然是有用的。它为我自己处理文本数据提供了足够好的基础。鉴于文本数据无处不在，这绝对是一件好事。

我的论文

尼克·莫里森在 Unsplash 上拍摄的照片

我不会过多地谈论我的论文是关于什么的，因为我不认为有人会觉得它有趣(如果你感兴趣，你可以在这里阅读)。相反，我会解释这个过程和我所经历的。注意，我的论文是在数学学院下完成的。

主管会议

正如我之前在课程结构部分提到的，我在三月底提交了我的偏好后，就拿到了我的最终题目。从那时起，我试着稍微准备一下论文，但是直到我第一次和我的导师见面时才开始。我说“导师”是因为我有两个导师:一个在论文的前半部分，另一个在论文的后半部分。

第一次见面发生在我五月/六月考试之后。我认为这是我写论文的正式开始。从那以后，我每周都和我的主管开会。这些非常重要，因为主管让我保持在正轨上。

为了充分利用这些会议，我必须向他们展示我一直在做的工作。我花了大部分会议时间来处理我的问题。有时我偏离了论文的主要目标，导师总是确保让我知道。他们会通过阅读我到那时为止所写的东西，然后在上面写笔记，让我知道要修改什么。

不是每个会议都有用，但大多数会议都有用。他们还确保我做了正确的事情来打动外部考官，这非常有帮助。

口头介绍

论文的最终提交时间大约在八月底。之后，我们不得不准备一个持续了大约一个小时的口头报告。演示持续了大约 30 分钟，剩下的时间是提问。

观众包括我的导师和论文协调员。他们问的大多数问题都相对简单，但有些问题有点尴尬。不过总的来说，感觉比预期的要容易。可能是因为我已经花了几个月的时间写作，并凭记忆知道了大部分内容。

分级(研究生授课)

利兹大学的所有学位都有一个评分标准。基本上，你的成绩是通过对你的单元分数进行加权平均，然后除以 10 计算出来的。

举个例子，如果你的加权平均分是 75，那么你的最终得分是 7.5。请注意，用于计算加权平均值的权重是您的模块的学分。因此，在学分较高的模块中表现良好将对你的期末成绩产生更大的影响。

您的最终奖励取决于您的最终得分属于哪个范围。这些是:

• **失败:**小于 5.0
• **过关:**5.0–5.9
• **优点:**6.0–6.9
• **区别:**大于 7.0

0.1 的任意范围适用于所有边界线。例如，如果你的最终分数是 6.93，那么你仍然可以得到一个优异的成绩。

这种不及格、及格、优秀和优秀的评分系统是英国研究生教育最常见的。在利兹，他们将加权平均值除以 10，但我认为大多数其他大学不会介意。如果我们忽略这一点，那么我看过的每所大学都有基本相同的界限。

这里有一个计算器，你可以从利兹大学网站下载。

最后，对于那些好奇的人，我已经扫描了我的成绩单，并在下面放了一个计算器的截图。

我的所有模块，包括他们的分数，水平和学分。

分数计算器与我的模块结果。

利兹数据科学学会

利兹大学为学生提供了一个很好的数据科学社团。他们提供以团队为基础的项目，学生可以参加以获得额外的经验。例如，我参加了全国 Hiscox 数据挑战赛，从大学中选出的团队参与解决一个数据科学问题。利兹数据科学协会组建了这个团队，并允许我们代表学校。

这给我的简历带来了奇迹，结果，我出现在 Tableau 的世代数据博客上。我在采访中被问到这个项目，对于没有太多经验的人来说，这是一个很好的起点。

作为一名学生，很容易忘记数据科学是一个非常基于项目的领域。我认为有一个数据科学协会参加对任何大学来说都是非常有价值的。它会对你的数据科学求职产生巨大影响，尤其是作为一名应届毕业生。当你在寻找合适的硕士课程时，一定要在这方面做些研究。

结论

这里有相当多的信息需要消化。希望这是有用的，特别是如果你想在利兹学习同样的课程。总的来说，我对这门课程的体验是相当积极的。虽然肯定有一些我不喜欢的模块和我不喜欢的教授，但我在短时间内学到了很多东西。

无论你是未来的学生还是校友，请联系我，让我知道你的想法。听到别人为什么决定攻读数据科学硕士学位的故事总是很有趣！

原载于 2021 年 7 月 7 日【https://leonlok.co.uk】。

使用 PettingZoo 的 13 行代码中的多智能体深度强化学习

原文：https://towardsdatascience.com/multi-agent-deep-reinforcement-learning-in-15-lines-of-code-using-pettingzoo-e0b963c0820b?source=collection_archive---------0-----------------------

初学者多智能体深度强化学习教程

免责声明

本教程提供了使用多代理强化学习的简单介绍，假设有一点机器学习的经验和 Python 的知识。

强化学习简介

强化源于使用机器学习来优化控制环境中的代理。它通过学习一个策略，一个函数来工作，该函数将从其环境中获得的一个观察映射到一个动作。策略函数是典型的深度神经网络，这就产生了“深度强化学习”的名称

强化学习的目标是学习一个最优策略，一个在行动时从环境中获得最大期望回报的策略。奖励是一个单一的无量纲的值，在一个行动之后立即由环境返回。整个过程可以想象成这样:

版权所有贾斯汀·特里 2021

这种强化学习的范式包含了各种各样令人难以置信的场景，比如电脑游戏中的一个角色(例如，Atari，奖励是分数的变化)，在城市里运送食物的机器人(代理人成功完成一次旅行会得到积极的奖励，花费太长时间会受到惩罚)，或者交易股票的机器人(奖励是获得的金钱)。

多智能体强化学习

学习玩多人游戏代表了我们一生中人工智能的许多最深远的成就。这些成就包括学习玩围棋、 DOTA 2 和星际争霸 2 到超人的性能水平。不出所料，使用强化学习来控制多个智能体被称为多智能体强化学习。一般来说，这与单个代理强化学习是一样的，每个代理都试图学习自己的策略来优化自己的回报。对所有代理使用中央策略是可能的，但是多个代理必须与中央服务器通信来计算它们的动作(这在大多数真实世界场景中是有问题的)，所以在实践中使用了分散的多代理强化学习。这可以想象如下:

版权所有贾斯汀·特里 2021

多智能体深度强化学习，我们今天要做的，同样只是使用深度神经网络来表示多智能体强化学习中的学习策略。

宠物动物园和活塞球

Gym 是 OpenAI 开发的一个著名的强化学习库，它为环境提供了一个标准的 API，这样就可以很容易地用不同的强化学习代码库来学习它们，并且对于相同的学习代码库，可以很容易地尝试不同的环境。 PettingZoo 是一个更新的库，它就像一个多代理版本的 Gym。它的基本 API 用法如下:

from pettingzoo.butterfly import pistonball_v5
env = pistonball_v5.env()
env.reset()
for agent in env.agent_iter():
    observation, reward, done, info = env.last()
    action = policy(observation, agent)
    env.step(action)

我们今天要学习的环境是 Pistonball ，一个来自 PettingZoo 的合作环境:

在其中，每个活塞都是一个代理，可以由一个策略单独控制。观察活塞上方和旁边的空间，例如:

策略返回的动作是提升或降低活塞的量(从-4 到 4 个像素)。目标是让活塞学会如何协同工作，尽快把球滚到左边墙。如果球向右移动，每个活塞代理都获得负奖励，如果球向左移动，则获得正奖励，并且在每个时间步长都获得少量负奖励，以激励尽可能快地向左移动。

在强化学习中，有大量的技术可以学习单个代理环境。这些是多智能体强化学习算法的基础。最简单和最流行的方法是在所有代理之间共享一个策略网络，这样所有代理使用相同的功能来选择一个动作。每个代理可以使用任何单个代理方法来训练这个共享网络。这通常被称为参数共享。这就是我们今天要用的方法，用 PPO 单代理方法(像这样的连续控制任务的最好方法之一)。

代码

首先我们从进口开始:

from stable_baselines3.ppo import CnnPolicyfrom stable_baselines3 import PPOfrom pettingzoo.butterfly import pistonball_v5import supersuit as ss

我们已经讨论过了，但是让我们来谈谈稳定基线。几年前，OpenAI 发布了“基线”存储库，其中包括大多数主要深度强化学习算法的实现。这个存储库变成了稳定的基线库，旨在供强化学习的初学者和实践者轻松使用来学习健身房环境。其中的 CnnPolicy 只是稳定基线包含的深度卷积神经网络对象，它自动调整神经网络的输入和输出层的大小，以适应环境的观察和动作空间。SuperSuit 是一个为健身房和宠物动物园环境提供预处理功能的包，我们将在下面看到。环境和包装器被版本化，以确保在学术研究中精确地再现比较。

首先，我们初始化 PettingZoo 环境:

env = pistonball_v5.parallel_env(n_pistons=20, time_penalty=-0.1, continuous=True, random_drop=True, random_rotate=True, ball_mass=0.75, ball_friction=0.3, ball_elasticity=1.5, max_cycles=125)

这些参数中的每一个都以不同的方式控制着环境如何运行，并在这里进行了记录。这里我们需要使用的另一种 parallel_env 模式在这里有记录。

我们要处理的第一个问题是环境的观测是全彩色图像。我们不需要颜色信息，由于 3 个颜色通道，神经网络处理的计算成本是灰度图像的 3 倍。我们可以通过用超级套装包裹环境来解决这个问题(记得我们在上面把它作为 ss 导入)，如下所示:

env = ss.color_reduction_v0(env, mode=’B’)

请注意，B 标志实际上采用图像的蓝色通道，而不是将所有通道都转换为灰度，以节省处理时间，因为在训练期间会进行成千上万次。在此之后，观察结果将是这样的:

尽管对每个活塞的观察都是灰度的，但图像仍然非常大，包含的信息比我们需要的更多。让我们把它们缩小。84x84 在强化学习中是一个流行的大小，因为它在 DeepMind 的一篇著名论文中使用过。用超级套装解决这个问题看起来像这样:

env = ss.resize_v0(env, x_size=84, y_size=84)

在此之后，观察结果将类似如下:

我们要做的最后一件重要的事情在开始时有点奇怪。因为球在运动，我们想给政策网络一个简单的方法来观察它运动和加速的速度。最简单的方法是将过去的几帧叠加在一起，作为每次观测的通道。将 3 叠加在一起，可以给出足够的信息来计算加速度，但 4 更标准。这是你如何用超级套装做到的:

env = ss.frame_stack_v1(env, 3)

接下来，我们需要稍微转换一下环境 API，这将导致稳定的基线在多代理环境上进行策略网络的参数共享(而不是像普通的那样学习单代理环境)。这方面的细节已经超出了本教程的范围，但是对于那些想知道更多的人来说，在这里记录了。

env = ss.pettingzoo_env_to_vec_env_v1(env)

最后，我们需要将环境设置为并行运行自身的多个版本。一次多次在环境中玩耍可以使学习更快，这对 PPOs 的学习表现很重要。SuperSuit 提供了许多方法来做到这一点，我们想在这里使用的是这个:

env = ss.concat_vec_envs_v1(env, 8, num_cpus=4, base_class=’stable_baselines3’)

8 是指我们复制环境的次数，num _ cpus 是运行这些环境的 CPU 核心数。这些是超参数，你可以随意使用它们。根据我们的经验，每个线程运行两个以上的环境会变得很慢，所以请记住这一点。

最后，我们可以开始一些实际的学习。这可以通过稳定的基线和三行代码轻松实现:

model = PPO(CnnPolicy, env, verbose=3, gamma=0.95, n_steps=256, ent_coef=0.0905168, learning_rate=0.00062211, vf_coef=0.042202, max_grad_norm=0.9, gae_lambda=0.99, n_epochs=5, clip_range=0.3, batch_size=256)model.learn(total_timesteps=2000000)model.save(“policy”)

使用现代 8 核 CPU 和 1080Ti，培训将需要大约 2 个小时(像所有深度学习一样，这是相当密集的 GPU)。如果你没有 GPU，用 T4 的 GPU 在谷歌云平台上训练这个应该不到 2 美元。

看着我们的算法玩游戏

一旦我们训练并保存了这个模型，我们就可以加载我们的策略并观看它的运行。首先，让我们重新实例化环境，这次使用普通的 API:

env = pistonball_v5.env()
env = ss.color_reduction_v0(env, mode=’B’)
env = ss.resize_v0(env, x_size=84, y_size=84)
env = ss.frame_stack_v1(env, 3)

然后，让我们加载策略

model = PPO.load(“policy”)

我们可以使用策略将其呈现在您的桌面上，如下所示:

env.reset()
for agent in env.agent_iter():
   obs, reward, done, info = env.last()
   act = model.predict(obs, deterministic=True)[0] if not done else None
   env.step(act)
   env.render()

这应该会产生类似这样的 gif:

请注意，这实际上比开头显示的 gif 更好。这是因为开始的 gif 是用一个手工制作的策略生成的，这里是这里是，而这个是实际学习到的

这篇教程的完整代码可以在这里找到。如果你觉得这个教程有用，可以考虑主演相关的项目(宠物动物园、超级套装和稳定基线 3)。

多臂强盗:带 Python 代码的 Thompson 采样算法

原文：https://towardsdatascience.com/multi-armed-bandits-thompson-sampling-algorithm-fea205cf31df?source=collection_archive---------4-----------------------

了解汤普森采样(贝叶斯土匪)算法。

丹尼斯·简斯在 Unsplash 拍摄的照片

介绍

在这一系列的帖子中，我们尝试了不同的 bandit 算法来优化我们的电影之夜——更具体地说，我们如何选择电影和餐馆来送餐！

对于新人来说，土匪这个名字来自老丨虎丨机(被称为独臂土匪)。你可以把它想成每次和它互动(拉它胳膊)都能奖励你(或者不奖励你)的东西。目标是，给定一群给出不同奖励的强盗，尽可能快地找出给出最高奖励的强盗。当我们开始玩游戏并不断收集关于每个强盗的数据时，强盗算法会帮助我们在利用迄今为止给我们最高奖励的强盗和探索其他强盗之间进行选择。

https://medium.com/analytics-vidhya/multi-armed-bandits-part-1-epsilon-greedy-algorithm-with-python-code-534b9e2abc9

你和你的朋友一直在使用 bandit 算法来优化每周电影之夜选择哪家餐馆和哪部电影。到目前为止，你已经尝试了不同的强盗算法，如ε贪婪、乐观初始值和置信上限 (UCB)。您已经发现 UCB1 调整的算法在伯努利和普通奖励方面都比其他算法稍好，并且已经在过去几个月中使用了它。

尽管你的电影之夜因 UCB1-Tuned 做出的选择而进展顺利，但你错过了尝试新算法的兴奋感。

“你听说过汤普森抽样吗？”你的朋友问。

兴奋的你拿起手机开始阅读。

该算法

汤普森抽样，也称为贝叶斯土匪，是多武装土匪问题的贝叶斯方法。基本思想是把每个强盗的平均报酬𝛍视为一个随机变量，并使用我们目前收集的数据来计算它的分布。然后，在每一步，我们将从每个强盗的平均奖励分布中抽取一个点，并选择其样本值最高的一个。我们随后从选中的强盗那里得到奖励，并更新它的平均奖励分布。

我听到你问我们如何计算/更新分布？贝叶斯强盗这个名字可能已经泄露了，但是我们将使用贝叶斯定理。

Bayes Theorem
 P(A|B) = P(B|A) P(A) / P(B)where
 A, B: events in sample space
 P(A|B): conditional probability of A given B
 P(B|A): conditional probability of B given A
 P(A): probability of A
 P(B): probability of B

以上定义是针对离散变量，对于连续变量是针对概率密度函数定义的。

在我们的例子中，对于每一个土匪，我们想计算他们的 P( 𝛍 |数据)，也就是说，给定我们到目前为止收集的数据，𝛍的不同值的可能性有多大。

P( 𝛍 | data ) = P(data | 𝛍) P(𝛍) / P(data)
              ∝ P(data | 𝛍) P(𝛍)
    posterior ∝ likelihood x prior

具有许多数据点的土匪将具有狭窄的分布，因此我们采样的数据点将有很高的机会接近真实平均值。然而，拥有很少数据点的盗匪将会有一个广泛的分布，给高值一个被选择的好机会。这种机制平衡了探索和开发。

图 1:更新单个伯努利强盗的平均奖励分布，奖励概率为 0.8。平均回报遵循贝塔(成功+ 1，失败+ 1)分布，假设贝塔(1，1)先验和二项式可能性。作者制作的动画。

现在，计算 P( 𝛍 |数据)是棘手的，除非可能性和先验是 共轭先验 。这意味着，当我们结合似然性和先验时，我们得到的后验分布与先验分布来自同一个家族。这很方便，原因有二:

• 我们可以避免计算后验概率的麻烦，因为它有一个封闭的表达式。
• 我们可以使用步骤 i-1 的后验概率作为步骤 i 的先验概率。这使得从 P( 𝛍 |直到步骤 i-1 的数据)到 P( 𝛍 |直到步骤 i 的数据)变得容易，并确保我们只使用共轭先验。

伯努利奖励

在这篇文章的其余部分，我们将假设一个强盗给𝛍的概率是 1，否则是 0，即

ith bandit rewards ~ Bernoulli(prob = 𝛍_i)

现在我们需要为𝛍.选择一个先验分布由于𝛍是成功的概率，它只能取 0 到 1 之间的值。因此，我们需要一个支持[0，1]的分布。一种这样的分布是具有参数a和b的贝塔分布。在我们收集任何数据之前，𝛍的所有值都是同样可能的，因此[0，1]上的统一先验是有意义的。选择a = 1和b = 1给了我们这样的机会。

接下来，我们需要选择一个可能性，最好是β分布是共轭先验的可能性。二项式分布满足这一点，它对我们的用例也有意义，因为它用成功概率p(这是我们试图估计的𝛍)模拟了从N试验(我们玩强盗的次数)中获得k成功的概率(强盗奖励的总和)。

If
  Prior is 𝛍 ~ Beta(𝛼, 𝛽)
  Likelihood is k | 𝛍 ~ Binomial(N, 𝛍)
Then
  Posterior is 𝛍 ~ Beta(𝛼 + successes, 𝛽 + failures)
Where
  N = successes + failures

这是一个简单的更新规则，如果强盗的奖励是 1，我们增加它的a，如果是 0，我们增加它的b。

图 2:使用 Thompson 抽样的实验，四个强盗获得奖励的概率(0.6，0.7，0.8，0.9)等于 1。我们可以看到，随着我们为每个土匪收集更多的数据，分布变得越来越窄。作者的动画。

给我看看代码

在之前的文章中，我们已经定义了你将在这里看到的基类，但是为了完整起见，我们再次将它们包括在内。

下面的代码定义了代表强盗的类BernoulliBandit，代表代理的基类Agent和跟踪奖励的助手类BanditRewardsLog。

现在，剩下的唯一事情就是子类化Agent类并实现 Thompson 采样。

…我们完成了！现在，让我们看看它如何与以前帖子中的算法相比较，即ε贪婪、乐观初始值和置信上限 (UCB)。

实验

我们将使用下面的代码来比较不同的算法。

首先，我们来定义一下我们的土匪。

probs = [0.6, 0.7, 0.8, 0.9]
bernoulli_bandits = [BernoulliBandit(p) for p in probs]

在这之后，我们可以简单地运行

compare_agents(
  get_agents(), 
  bernoulli_bandits, 
  iterations=500, 
  show_plot=True,
)

这给了我们以下。

Tota 每个代理的累积奖励。图片由作者提供。

嗯…不是很清楚，但是好像 Epsilon-Greedy 和 Bayesian 土匪有类似的表现。为了找到最好的一个，让我们重复上面的实验，并计算每个算法得到最佳结果的次数。

wins = run_comparison(bernoulli_bandits)
for g, w in zip(get_agents(), wins):
    print(g, w)

我的结果是 Epsilon-Greedy 为 397，UCB1 为 0，UCB1-Tuned 为 220，Thompson Sampling 为 383。看起来 Thompson 采样和 Epsilon-Greedy 是我们特定设置的赢家。UCB1-Tuned 获得第三名有点令人惊讶，因为在之前的实验中，它的表现超过了ε-Greedy 算法。这可能是由于 Thompson Sampling 窃取了它的一些成果，但这需要更多的调查。

结论

在这篇文章中，我们研究了汤普森采样算法是如何工作的，并为伯努利强盗实现了它。然后，我们将它与其他多臂强盗算法进行比较，发现它的性能与 Epsilon-Greedy 差不多。

成为 Medium的会员，获得所有故事的全部权限。你的会员费直接支持你读的作家。

出自同一作者。

https://medium.com/analytics-vidhya/calculating-using-monte-carlo-simulations-337cff638ac5

参考

[1]汤普森采样教程。(未注明)。检索于 2021 年 9 月 25 日，来自https://web.stanford.edu/~bvr/pubs/TS_Tutorial.pdf.

多臂强盗:带 Python 代码的置信上限算法

原文：https://towardsdatascience.com/multi-armed-bandits-upper-confidence-bound-algorithms-with-python-code-a977728f0e2d?source=collection_archive---------7-----------------------

实践教程

了解不同的置信上限 bandit 算法(UCB1、UCB1-Tuned、UCB1-Normal)。为所有实验提供的 Python 代码。

由丹尼斯·简斯在 Unsplash 上拍摄的照片

介绍

在这一系列的帖子中，我们尝试了不同的 bandit 算法来优化我们的电影之夜——更具体地说，我们如何选择电影和餐馆来送餐！

对于新来的人来说，bandit 这个名字来自吃角子老丨虎丨机(被称为独臂强盗)。你可以把它想成每次和它互动(拉它胳膊)都能奖励你(或者不奖励你)的东西。目标是，给定一群给出不同奖励的强盗，尽可能快地找出给出最高奖励的强盗。当我们开始玩游戏并不断收集关于每个强盗的数据时，强盗算法会帮助我们在利用迄今为止给我们最高奖励的强盗和探索其他强盗之间进行选择。

在我们的故事中，我们使用餐馆而不是强盗，我们的回报是食物的满足感！:)

https://medium.com/analytics-vidhya/multi-armed-bandits-part-1-epsilon-greedy-algorithm-with-python-code-534b9e2abc9 https://medium.com/swlh/multi-armed-bandits-optimistic-initial-values-algorithm-with-python-code-3970e611b5ab

你和你的朋友已经有一段时间没有使用 bandit 算法来优化你的电影之夜了。到目前为止，你一直在使用 Epsilon-Greedy (与𝛆=1/#actions 一起)来帮助寻找最好的餐馆，而你的朋友一直固执地使用乐观初始值算法来挑选电影导演(即使你的模拟已经表明它可能不适合你的用例)。

当你在互联网上消磨时间，因为封锁而被困在里面时，你会遇到一些基于置信上限 (UCB)的强盗算法。你兴奋地发现有可能改进对最佳餐馆的搜索，并更有效地解决剥削-探索的困境，你开始阅读，期待着下一个电影之夜。

他们中有谁会比ε-Greedy 更好吗？让我们来了解一下！

算法

这个想法是利用我们目前收集的数据，用概率论得出每个土匪平均报酬的上限。我们就把这个上界叫做土匪的上置信 指标，就像原论文 **里一样。**与置信区间一样，如果我们没有大量数据，样本均值的边界会很宽。在每一步，我们选择具有最高上置信指数的强盗，获得奖励并随后更新其指数。

这听起来有点类似于乐观初始值算法吧？提出这个指数似乎比仅仅选择一个乐观的初始值更复杂，但是实现仍然相对简单(我发誓)。实际上，它们使用起来更简单，因为它们没有任何需要我们选择的参数！

一般来说，每个 bandit 的置信上限指数具有以下形式。

Bandit Upper Confidence Index = X_sample_mean + Cwhere
 X_sample_mean:  sample mean for rewards so far
 C > 0:          size of one sided confidence interval

随着我们为强盗收集更多的数据，它应该减少，这是有意义的，因为我们变得更加确定平均奖励的可能值。没有被充分探索的强盗会有一个更大的C，这将导致我们选择他们进行探索。

在伪代码中:

Choose n # number of iterationsInitialisation step. # for UCB1 & UCB1-Tuned we play each bandit oncefor i = 1 to n do:
  current_bandit = pick bandit with greatest upper confidence index
  reward = current_bandit.pull_arm()    Update upper confidence index for current_bandit

好的……我们知道如何计算样本均值，但是我们如何计算C？嗯，看情况吧！

在原始论文中提出了几个 UCB 算法，每个算法对C都有不同的定义。 UCB1 和 UCB1-Tuned 设计用于奖励为 0 或 1，即来自伯努利分布的奖励(参见本文)。如果你的回报来自正态分布，有另一个算法，叫做UCB-正态，就是为此设计的。你可以使用 UCB1 获得其他发行版的奖励，但是据说性能没有那么好(我们将测试这一点)。

UCB1

UCB1 的 bandit 置信指数上限等于

Bandit Upper Confidence Index = Sample Mean + √(2logN / n)where 
  N = total rounds (e.g. number of movie nights so far)
  n = number of times we've played the bandit (
    e.g. number of times we've ordered from a restaurant
  ).

使用 UCB1 与四个获得奖励的概率等于 1 的强盗(0.6，0.7，0.8，0.9)进行实验。我们可以看到上置信指数是如何变化的，每个强盗玩了多少次，以及我们对每一步的样本均值的估计。作者的动画。

它是使用 切尔诺夫-赫夫丁界限 推导出来的，即

P( Sample Mean + t ≤ True Mean) ≤ exp(-2nt²) for t > 0

其中n是我们迄今为止从特定的土匪那里收集的数据点的数量。这意味着，样本均值的误差大于t的概率随着n的增加而降低。

为了推导上限，我们首先设置右侧等于b，并求解t。

Let 
 b = exp(-2nt²).Then
 logb = -2nt² <=> t = √(-logb / (2n))Choose(this is a heuristic)b = (1 / N⁴)Then
 t = √(2logN / n)

在上面，n是我们玩特定强盗的次数，N是我们玩的总次数(回合数或电影夜数，如果你喜欢的话)。你可以把b看成一个超参数。

We know 
 P( Sample Mean + t ≤ True Mean) ≤ exp(-2nt²) for t > 0Substitute for t
 P( Sample Mean + √(2logN / n) ≤ True Mean) ≤ 1 / N⁴**Define**
  **Upper Confidence Index = Sample Mean + √(2logN / n)****Hence 
  C = √(2logN / n)**

从上面我们可以推断出，真实平均值大于置信指数上限的概率小于 1/n⁴——随着回合数N的增加，这收敛到 0。因此，使用它作为上限是有意义的。

有一点需要注意的是比例logN / n。随着回合数N和我们玩强盗的次数n之间的差距增加，界限也增加。

保持 N 不变，增加 N，我们可以看到，当我们玩不涉及强盗的回合时，C 增加。图片由作者提供。

保持 N / n 比不变，我们可以看到，随着 N 和 N 都增加，界限减小。这是因为作者在 N. Image 上的对数。

UC B1-调谐

对于 UCB1-Tuned，我们用以下内容替换C

C = √( (logN / n) x min(1/4, V(n)) )where V(n) is an upper confidence bound on the variance of the bandit, i.e.V(n) = Σ(x_i² / n) - (Σ x_i / n)² + √(2log(N) / n) and x_i are the rewards we got from the bandit so far.

在原始论文(见第 4 节)中，UCB1 调优的在每个实验中都优于 UCB1。

实验使用 UCB1-Tuned 与四个土匪的概率(0.6，0.7，0.8，0.9)获得奖励等于 1。我们可以看到上置信指数是如何变化的，每个强盗玩了多少次，以及我们对每一步的样本均值的估计。作者的动画。

UC B1-正常

对于 UCB1-Normal，C基于样本方差，与前两种算法不同，它是为正态分布的奖励而设计的。

C = √( 16 SV(n) log(N - 1) / n )where the sample variance is
  SV(n) = ( Σ x_i² - n (Σ x_i / n)² ) / (n - 1)

x_i are the rewards we got from the bandit so far

UCB1-Normal 通常没有初始化步骤。相反，在每一轮N中，它会检查是否有一个土匪的出牌次数少于8logN的上限，然后就打那个土匪，而不是看上面的信心指数。然而，为了计算C，我们需要n至少为 2，这样我们就不会被零除。因此，我们将每个强盗玩两次作为初始化步骤。

在每一个强盗被玩了将近 50 次之前，我们不会在大多数回合中使用较高的信心指数来选择强盗。

使用 UCB1-Normal 对五个土匪进行实验，奖励均值为(2，5，7，9，11)，标准差为 2.5。作者的动画。

给我看看代码

唷…那是很多界限。这些代码中的一部分已经在以前的帖子中出现过，但是为了完整起见，我还是将它包含在这里。首先，我们需要一些类来代表强盗，一个用于伯努利奖励，一个用于普通奖励。

接下来，我们将为代理定义一些基类(以及一个助手类来跟踪奖励——如果您已经阅读过上一篇文章的话,BanditRewardsLog已经被修改为跟踪奖励平方的总和)。

我们仍然需要定义ε贪婪代理的类，因为我们将使用它来进行比较，以及 UCB 代理。它们将从Agent类继承，并且需要实现take_action，因为它是一个抽象方法。

我们现在有了强盗和特工的所有必要职业。娱乐时间到了！

算法战场

我们将直接把所有的 UCB 算法和ε贪婪算法投入战场。我们将考虑两种情况，一种奖励来自伯努利分布，另一种奖励来自正态分布。

我们将利用以下实用函数。

*def* compare_agents(
    *agents*: List[Agent], 
    *bandits*: List[Bandit], 
    *iterations*: int,
    *show_plot*=*True*,
):
    *for* agent *in agents*:
        logger.info("Running for agent = %s", agent)
        agent.bandits = *bandits
        if* isinstance(agent, ucb.UCBAgent):
            agent.initialise()

        N = *iterations* - agent.rewards_log.total_actions
        agent.take_actions(N)
        *if show_plot*:
            cumulative_rewards = np.cumsum(
                agent.rewards_log.all_rewards,
            )
            plt.plot(cumulative_rewards, label=str(agent))

    *if show_plot*:
        plt.xlabel("iteration")
        plt.ylabel("total rewards")
        plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))
        plt.show() def get_agents():
    agents = [
        EpsilonGreedyAgent(),
        ucb.UCB1Agent(),
        ucb.UCB1TunedAgent(),
        ucb.UCB1NormalAgent(),
    ]
    return agents def run_comparison_ucb(bandits):
    win_count = [0, 0, 0, 0]

    for _ in range(1000):
        agents = get_agents()
        iterations = 1000
        compare_agents(agents, bandits, iterations, show_plot=False)

        rewards = [
            agent.rewards_log.total_rewards 
            for agent in agents
        ]
        win_count[np.argmax(rewards)] += 1

    return win_count

愿最好的算法胜出！

伯努利奖励

我们来定义一下我们的土匪和特工。

probs = [0.6, 0.7, 0.8, 0.9]
bernoulli_bandits = [BernoulliBandit(p) for p in probs]
agents = get_agents()

那么我们可以简单地做

compare_agents(agents, bernoulli_bandits, 1000, show_plot=True)

每个代理的总累积奖励。图片由作者提供。

看起来 Epsilon-Greedy 和 UCB1-Tuned 比其他两个做得更好，但它很接近。我们将重复这个实验 1000 次，并记录下哪个代理得到了最多的奖励。

run_comparison_ucb(bernoulli_bandits)

我的结果是 Epsilon-Greedy 497 胜，UC B1 3 胜，UC B1-Tuned 500 胜，UC B1-Normal 0 胜。看起来选择 Epsilon-Greedy 或 UCB1-Tuned 是正确的选择。

正常奖励

我们重复了同样的实验，但这次是对按照正态分布给予奖励的强盗。

means = [3, 5, 7, 9]
normal_bandits = [Bandit(m=m, sigma=1) for m in means]

每个代理的总累积奖励。图片由作者提供。

令人惊讶的是，最差的一个好像是 UC B1——正常……丢人。不清楚哪一个是其他三个中最好的，所以我们将重复实验很多次，并记录哪个代理获得了最多的奖励。

我为 Epsilon-Greedy 赢得了 156 场胜利，为 UCB1 赢得了 364 场胜利，为 UCB1-Tuned 赢得了 480 场胜利，为 UCB1-Normal 赢得了 0 场胜利。

结论

在这篇文章中，我们研究了置信上限 bandit 算法是如何工作的，用 Python 对它们进行了编码，并将它们与其他算法以及 Epsilon-Greedy(与𝛆=1/#actions).)算法进行了比较

我们发现 UCB1-Tuned 在伯努利和普通奖励方面表现最佳，尽管它不是为普通奖励设计的。其中最差的是 UC B1——到目前为止还算正常——这可能是它不如其他产品受欢迎的原因。

参考

https://eminik355.medium.com/subscribe

成为 Medium会员，获得全部故事权限。你的会员费直接支持你读的作家。

更多来自同一作者。

https://medium.com/analytics-vidhya/calculating-using-monte-carlo-simulations-337cff638ac5 https://medium.com/analytics-vidhya/multi-armed-bandits-part-1-epsilon-greedy-algorithm-with-python-code-534b9e2abc9 https://medium.com/swlh/multi-armed-bandits-optimistic-initial-values-algorithm-with-python-code-3970e611b5ab

根据胸部 x 射线对各种胸部状况进行多类别分类

原文：https://towardsdatascience.com/multi-category-classification-of-various-chest-conditions-from-chest-x-rays-1d6428522997?source=collection_archive---------12-----------------------

使用 fast.ai 和 NIH CXR 数据集将 x 射线分类为各种胸部疾病

描述几种情况的胸部 x 光图像。图片作者。

简介

随着医疗需求呈指数级增长，对快速诊断疾病的需求空前高涨。正如新冠肺炎疫情所表明的，检测、诊断和识别症状是防止疾病进一步传播的第一道防线。然而，这些诊断工具仅占全球医疗支出的 2%，尽管它影响了超过 70%的临床决策。

根据皇家放射科医师学会在 2018 年发布的报告，英国只有“2%的放射科能够在合同时间内满足他们的成像报告要求。”在美国，预计到 2032 年将会短缺近 122，000 名医生。

图片由国家癌症研究所的 Unsplash 提供

这是来自发达国家的消息。低收入国家和高收入国家之间的差距是巨大的:后者的放射技师比前者多近 100 倍。例如，在非洲，传染病造成超过 2 . 27 亿年的健康寿命损失。缺乏对此类传染病的快速、准确的诊断导致大量不必要的生命损失。

将涵盖哪些内容:

1. 确定问题范围——识别医学成像中的不同情况
2. 利用 fast.ai 给我们一个多类别分类器
3. 准备数据
4. 训练模特
5. 创建交互式图形用户界面，根据真实数据测试模型
6. 限制
7. 学习要点

医学成像中不同条件的识别👨‍⚕

对肺的损害是无法逆转的。然而，早期发现和治疗严重的胸部疾病对于防止任何传染病进一步传播是至关重要的。通过识别指示某些疾病的指示性条件(例如，在胸部 x 射线中)，具有快速、准确预测的医疗专业人员将能够对患者进行分类，并以更有针对性和更有效的方式执行后续步骤。

由于诊断这种疾病的紧迫性，再加上严重的人力短缺(尤其是在发展中国家)，这种导致无数人丧生，有时是不必要的。

这就是人工智能——特别是深度学习——可以在防止这些生命消失方面发挥关键作用的地方。

严重胸闷多分类器— fast.ai

为了部分缓解诊断人力的缺乏，我们可以使用计算机视觉模型，在寻求进一步的医疗帮助之前，为医生和内科医生提供患者的初步分类。

最大限度地减少操作计算机系统中的挫折和麻烦的理想目标是创建一个端到端的应用程序，医生可以快速准确地获得预测。

为此，我们可以利用 fast.ai 库来帮助我们对多类别条件进行分类——这意味着给定一幅具有多种条件的图像，该模型能够预测每种条件出现的相对可能性。

数据🔂

我们正在使用 NIH 胸部 x 光数据集的一个更小的‘样本’版本来训练我们的模型。数据从最初的 112，000 张缩减到 5606 张。但是，该数据集保留了与其父数据集相同的结构和各种类别中图像的相对分布(例如，两个数据集中约 54%的 x 射线都有“无发现”标签)。因此，这保留了原始数据集的偏差。

为了从 kaggle 获取数据集，我们利用:

然后将包含数据集的压缩文件下载到 Google Colab 实例(我们在这个项目中使用的主要平台)。)

数据处理

由于该示例最初是以 zip 文件的形式下载的，我们必须将其解压缩:

! unzip sample.zip

为了从较高层面概述数据在下载的文件夹中的结构，我们可以仔细看看云存储中的内容:

图像的文件结构，嵌套在/sample/images 下，按作者排序。

如您所见，这些图像嵌套在/sample/images 下，还有一个“sample_labels.csv ”,其中存储了不同图像的标签。

然后，我们可以通过读取 csv 文件创建一个数据帧以及数据集。

df = pd.read_csv(path/f"sample_labels.csv")
dsets = dblock.datasets(df)

完成这一步后，我们必须在将标签与相应的图像匹配之前，将索引到 csv 文件中以提取标签。

我们可以通过构造助手函数来做到这一点，我们可以在我们的数据块中使用这些函数。 fast.ai 文档提供了数据块可以接受的参数列表:

作者图片

创建我们的数据块，作者图像

我们的块是 ImageBlocks(基本上是告诉模型我们正在处理自变量的图像)，以及因变量的 MultiCategoryBlocks 告诉模型一个图像可以有几个类别。这防止了模型仅识别一个类别，而实际上它应该检测胸部 x 光中的多个问题。

在这种情况下，我们必须定义自变量和因变量的标签—自变量是图像，因变量是“查找标签”。对于图像，我们必须从。csv 文件。对于因变量，我们必须使用简单的正则表达式提取标签。

这封装在下面显示的 get_x 和 get_y 函数中:

然后，我们必须使用函数 RandomSplitter()将数据分成训练集和验证集。

然后，我们必须使用 aug_transforms 将所有图像转换为相同的大小。

我们使用。数据加载器(df)，其中 df 是包含 csv 文件所需值的数据帧。

在训练模型之前，我们最后看一下图像，看看它们的格式是否正确:

作者图片

训练模型🚄

训练多分类模型。作者图片

阐述阈值的概念:

在将 sigmoid 应用于我们的激活后(你可以在此处阅读 sigmoid 用于的内容),我们遇到了一个问题——我们不能简单地选择被预测为具有最高激活的类别(因为可以将不同的类别分配给一张照片)。相反，我们必须通过选取阈值来决定哪些标签不对应于图像。高于阈值的每个值都将被通过(即该标签将被附加到图像上)，而低于阈值的每个值都不会被通过。

选择阈值至关重要 —选择过低的阈值将影响模型的整体准确性，因为我们将无法选择正确标记的对象，这意味着如果注册了激活度相当低的标签，它将被错误地添加到图像上的多个标签之一。另一方面，选择过高的阈值意味着我们的模型只会在非常有把握的时候附加标签，因此再次降低了准确性。

我们可以使用一个方便的函数，通过绘制图表并检查对应于最高精度的点来选择阈值:

作者图片

然后，我们选择一个基本学习速率(可以使用学习速率探测器进一步优化)和 freeze_epochs(迁移学习的一个实例)来修改神经网络的后面几层，而不改变前面几层，从而减少模型训练时间。

这个模型花了大约 19 到 20 分钟来训练，并且返回了大约 92.8% 的准确度。

理想情况下，我们希望简单地调用 learn.predict()来给出最高的诊断可能性。然而，在测试模型时，我意识到标签的对应值超过 0.5 的情况非常罕见(这似乎是标签必须等于的默认值，才能出现在预测中)。因此，在向用户显示之前，我编写了几行代码来编译所有与相应标签匹配的预测。

然后，这将返回一个与发生的相关概率相匹配的胸部状况列表。

作者图片

然后，用户可以对预测进行排序，并对模型预测的条件进行排名。他或她还可以设置一个任意值，以查看哪些条件返回的概率大于设置值。

创建一个 GUI 来根据真实世界的数据✍️测试模型

下一步是根据真实世界的数据测试该模型，看看该模型是否能够根据从互联网上获得的胸部 x 光片来检测胸部状况。

作者图片

在这个场景中，我上传了一张标记为“渗透”的图片。这是通过创建一个简单的用户按钮来完成的，用户可以在这里上传文件。

btn_upload = widgets.FileUpload()btn_upload

然后我们称之为预测:

img = PILImage.create(btn_upload.data[-1])list_preds(img)

让我们看看模型返回什么:

作者图片

因为从业者希望看到不同条件的不同概率，所以增加了一行代码来根据模型的置信度进行排序。

作者图片

它以最大的概率返回“没有发现”，其次是“渗透”和“渗出”。因此，渗透被列为第二个预测，这证明了这个模型实际上可以用来解释数据，在监督医生的监督下。

在一天结束时，这个工具可能最适合于加速放射科医生或医生处理诊断成像的过程。

要查看我原来的谷歌 Colab 笔记本，请随意查看这里的！

⛑的局限性

尽管如此，在完成这个简短的项目后，我仍然遇到了一些限制:

1. 虽然创建一个令人愉快的 UI 的目标没有完全实现，但是仍然创建了一个图形用户界面，用户可以在其中上传胸部 x 射线的图像以获得他们的预测。要采取的进一步措施可能是使用 streamlit 或 bindr 将这个模型推送到网络上。
2. 数据的固有偏差(其结构使得其具有超过大多数的“无发现”)—可能已经基于医生接收到的内容进行了结构化，但是这仅仅意味着模型将会有偏差，以预测对于所预测的大多数图像来说“无发现”
3. 目前不能正确地分割和识别胸部 x 射线的哪些部分代表什么情况，具有这种功能或者绘制边界框以向医生突出显示情况将进一步减少用于诊断严重胸部情况的时间。

学习要点💡

在整个过程中，我收集了一些智慧的金块。

图片由un splashPiron Guillaume拍摄

这个过程让我瞥见了知道深度学习和计算机视觉在医学领域的各种应用。人工智能在医学上的应用有着惊人的潜力。根据 Mihaela van der Schaar 的说法，当我们在医学中使用人工智能时，我们只是“触及了可能的表面”。我们还没有充分利用人工智能的可能性，使医疗保健生态系统更加强大和有效，我对这一领域将出现的突破感到非常兴奋。这些是我感兴趣的医疗保健和人工智能交叉领域的一些研究:

1. confidence care:个性化乳腺癌筛查的临床决策支持系统
2. 改进自主乳房 x 光诊断
3. 利用深度神经网络对皮肤癌进行皮肤科医生级别的分类

关于如何使用人工智能来重塑医疗保健的未来，请查看 van der Schaar 的这篇深度文章:https://www . vanderschaar-lab . com/revolution izing-health care-an-invitation-to-clinical-professionals-everywhere/

毫无疑问，在医疗保健领域全面采用人工智能会遇到一些阻力(可能是因为医生和计算机之间的不良历史)，但我已经开始相信人工智能永远无法完全取代医生(至少在不久的将来)。

在我看来，人工智能更像是一种工具，我们可以利用它来做出更准确、更快速的预测。用巴斯蒂安·特龙自己的话来说:“认知革命将允许计算机扩大人类思维的能力……正如机器使人类肌肉强大一千倍，机器将使人类大脑强大一千倍。”因此，人工智能只会增强医生的职业，而不会完全取代它。(这里有一篇很棒的文章知道 AI 会在多大程度上取代医生)。Maxfield 和 van der Schaar 提出了类似的观点:“如果医疗保健没有(1)以人为本和(2)完全以人为本，就没有可行的愿景。这不是非此即彼的问题。人类和人工智能/机器学习各有独特的优势，必须结合起来……而不是单独应用。”

个人认为，让数据更具可读性和可解释性是值得花时间去做的事情。由 fast.ai 中的开箱即用方法返回的原始预测不会给(理论上的)用户任何他或她在看什么的想法。今年在探索了 UI 和 UX 之后，我将它付诸实践，扩充了结果，现在它对数据的概率进行了排序，与左边条件的预测相匹配。

结论

通过这个项目，我学到了很多东西——从启动我的第一个多类别分类项目，到探索医学成像和人工智能之间的交叉——尽管最初再次掌握 Python 有些困难，但我还是设法弄明白了！

通过获得对利用人工智能的细微差别(老实说，挑战)的更深入的见解，我开始意识到在现实世界中部署一个准确的模型并不简单——有太多的原因可以解释为什么事情会变得可怕(或者正确！).了解用例，以及行业需要什么，仍然是最重要的。这个项目只是一个开始；探索 AI 能给世界带来的积极影响，我太炒作了。

随时联系我这里！！

使用焦点损失和光照 GBM 的多类分类

原文：https://towardsdatascience.com/multi-class-classification-using-focal-loss-and-lightgbm-a6a6dec28872?source=collection_archive---------5-----------------------

在多类分类器中引入聚焦损失有几种方法。这是其中之一。

动机

许多现实世界的分类问题具有不平衡的类别分布。当数据严重不平衡时，分类算法倾向于预测多数类。有几种方法可以缓解阶级不平衡。

一种方法是分配与类别频率成反比的样本权重。另一种方法是使用过采样/欠采样技术。为少数类生成人工样本的常用技术是合成少数过采样技术(SMOTE)和自适应合成(ADASYN)，这两种技术都包含在 imblearn Python 库中。

最近，提出了使用聚焦损失目标函数。该技术被宗-林逸等人用于二元分类。

在这篇文章中，我将演示如何将焦点损失合并到 LightGBM 分类器中进行多类分类。该代码可在 GitHub 上获得。

二元分类

对于二元分类问题(标签 0/1 ),焦点损失函数定义如下:

等式 1 聚焦损失函数

其中 pₜ 是真实标签的函数。对于二元分类，该函数定义为:

等式 2 类别概率

其中 pₜ是通过将 sigmoid 函数应用于原始边距而获得的 z:

等式 3 用于将原始边距 z 转换成类别概率 p 的 Sigmoid 函数

聚焦损失可以被解释为二元交叉熵函数乘以调制因子(1- pₜ )^ γ ，这减少了易于分类的样本的贡献。加权因子 aₜ 平衡调制因子。引用作者的话:“当γ = 2 时，与 CE 相比，pt = 0.9 的示例的损耗低 100 倍，pt ≈ 0.968 的示例的损耗低 1000 倍”。减少容易分类的例子的损失允许训练更多地集中在难以分类的例子上”。

多类分类

在多类分类器中引入聚焦损失有几种方法。形式上，调制和加权因子应该应用于分类交叉熵。这种方法要求提供多级损失的一阶和二阶导数作为原始利润 z 。

另一种方法是使用一个对其余的(OvR)，其中为每个类 C 训练一个二元分类器。来自类别 C 的数据被视为正值，所有其他数据被视为负值。在这篇文章中，使用了 OvR 方法，采用了 Halford 开发的二元分类器。

下面显示的 OneVsRestLightGBMWithCustomizedLoss 类封装了这种方法:

此类重新实现 sklearn.multiclass 命名空间的 OneVsRestClassifier 类。重新实现最初的 OneVsRestClassifier 类的动机是能够向 fit 方法转发附加参数。这有助于传递评估集(eval_set)以提前停止，从而减少计算时间并避免过拟合。

此外，该类使用通用的 LightGBM 训练 API，在处理原始利润 z 和定制损失函数时，需要使用该 API 来获得有意义的结果(有关更多详细信息，请参见[ 2 )。如果没有这些约束，就有可能实现更一般的类，不仅接受任何损失函数，还接受任何实现 Scikit Learn 模型接口的模型。

该类的其他方法是 Scikit 学习模型接口的一部分:fit、predict 和 predict_proba。在 predict 和 predict_proba 方法中，基本估计量返回原始毛利 z 。请注意，当使用定制的损失函数时，LightGBM 会返回原始边距 z 。使用 sigmoid 函数从边距计算类别概率，如等式所示。3.

一个例子

让我们首先创建一个包含 3 个类的人工不平衡数据集，其中 1%的样本属于第一类，1%属于第二类，98%属于第三类。通常，数据集分为训练集和测试集:

为了使实验简单，放弃了早期停止。训练后产生的混淆矩阵如下所示:

图 1 使用标准 LightGBM 分类器的测试集上的混淆矩阵

对于第一个实验，在测试集上获得了 0.990 的准确度和 0.676 的召回值。使用具有焦点损失的 OneVsRestLightGBMWithCustomizedLoss 分类器重复相同的实验。

从上面的代码可以看出，损失函数可以在分类器之外配置，并且可以注入到类构造函数中。通过向 fit 方法提供一个包含 eval_set 的字典，可以启用提前停止，如上面的注释行所示。对于第二个实验，产生的混淆矩阵如下所示:

图 2 使用 LightGBM 和定制的多类焦损失类(OneVsRestLightGBMWithCustomizedLoss)的测试集上的混淆矩阵

在这种情况下，获得了 0.995 的准确度和 0.838 的召回值，比使用默认对数损失的第一个实验有所改进。这一结果在混淆矩阵中也很明显，其中类别 0 的假阳性和类别 1 的假阴性显著减少。

结论

在这篇文章中，我演示了一种在多类分类器中合并焦点损失的方法，使用的是一个对其余部分(OvR)的方法。

不需要使用聚焦损失目标函数、样品重量平衡或人工添加新样品来减少不平衡。在人工生成的多类不平衡数据集上，焦点损失的使用增加了召回值，并消除了少数类中的一些假阳性和假阴性。

该方法的有效性必须通过探索真实世界的数据集来确认，其中噪声和非信息特征预期会影响分类结果。

[1]林，T. Y .，戈亚尔，p .，吉尔希克，r .，何，k .，&多拉尔，P. (2017)。密集物体探测的聚焦损失。IEEE 计算机视觉国际会议论文集(第 2980–2988 页)。

变压器的多级分类

原文：https://towardsdatascience.com/multi-class-classification-with-transformers-6cf7b59a033a?source=collection_archive---------6-----------------------

用 BERT 进行预处理、训练和预测

作者图片

T 转换器被描述为深度学习的第四大支柱[1]，与卷积和递归神经网络类似。

然而，从自然语言处理的角度来看——变形金刚远不止这些。自 2017 年推出以来，它们已经主导了大多数 NLP 基准，并继续每天给人留下深刻印象。

问题是，变形金刚太酷了。有了像 HuggingFace 的变形金刚这样的库，用它们来构建不可思议的解决方案已经变得太容易了。

那么，有什么不爱呢？令人难以置信的性能与极致的易用性。

在本文中，我们将从头到尾使用 transformers 构建一个多类分类模型。

预处理

我们将使用烂番茄电影评论数据集。这里，我们给出了从 0 到 4 的五个输出标签。每个标签代表一个情感类别。

烂番茄数据集标记和衡量从消极到积极的情绪。

这里我们将简单介绍几个预处理步骤(完整的笔记本链接在本节末尾)。

总的来说，我们有六个预处理步骤:

• 使用语句 Id 删除“段”重复。

• 初始化空数组以存储标记化的文本。

• 一个热点编码的情绪。

• 使用我们的输入构建一个tf.data.Dataset对象，并标记张量。然后转换成我们模型的正确格式。

• 批处理和打乱我们的数据。

• 90–10 分为培训和验证数据。

所有这些步骤结合起来创建了这个预处理脚本和这个输入管道脚本。

建造和训练

现在我们有了正确格式的数据，我们可以设置模型并开始训练。

构建模型

首先，我们需要初始化预训练的 BERT 模型，如下所示:

我们将使用典型的tf.keras层围绕 BERT 构建一个框架。这个框架有几个部分:

• 两个输入层(一个用于输入 id，另一个用于注意屏蔽)。
• 用于减少过度拟合的可能性并提高泛化能力的后 BERT 丢弃层。
• Max pooling layer 将 BERT 输出的 3D 张量转换为 2D 张量。
• 最终输出激活使用 softmax，这样我们就可以得到我们的获奖类预测。

所有这些都写成了:

然后，我们初始化新的model，并将输入/输出层提供给初始化函数。一旦完成，我们可以冻结 BERT 层来加速训练(以可能的性能下降为代价)。这里，我们将注释掉图层冻结线。

我们冻结 BERT 参数的原因是它们有很多，更新这些权重会显著增加训练时间。

因为 BERT 是预先训练过的，进一步训练的潜在性能提高是很小的，因此不值得额外的训练时间。

培养

现在我们已经建立了模型架构，我们可以初始化我们的训练参数并开始训练。

首先，我们用合适的训练参数编译模型。

这里，我们使用一个带有加权衰减的 Adam 优化器。对于我们的损失和准确性，我们分别使用分类交叉熵和分类准确性。

我们在这里使用分类度量是因为我们的一次性编码多类输出标签是分类的。

现在，我们从model.fit开始训练:

仅仅几个时期后，我们应该得到接近 75%的准确度。最后，我们可以使用以下方法保存我们的模型:

(全训脚本)。

做预测

我们已经预处理了数据，构建、训练并保存了模型。现在，我们可以开始用它做一些预测。

如果您在单个笔记本或脚本中跟随，您不需要这样做——但是正如我向您展示了如何保存模型，我们也将加载它:

准备输入数据

我们希望从像"hello world"这样简单的字符串中做出预测。为此，我们需要添加一些处理步骤，将一个简单的字符串转换成正确的格式，以便我们的模型使用和预测。

为此，我们将使用一个名为prep_data的函数。该函数将获取一个字符串，使用一个BertTokenizer对其进行标记，并将这些标记张量作为一个字典返回，该字典包含'input_ids'和'attention_mask'键-值对:

预言；预测；预告

一旦我们的输入字符串被格式化为正确的 dictionary-tensors 格式，我们就可以将它们传递给我们的model.predict方法——该方法将返回每个输出标签的概率的 Numpy 数组:

(满载和预测脚本)。

这就是我们完整的多类分类变压器模型演练，从开始到结束！

我希望你喜欢这篇文章。如果您有任何问题或建议，请通过 Twitter 或在下面的评论中告诉我。如果你对更多类似的内容感兴趣，我也会在 YouTube 上发布。

感谢阅读！

参考

[1] J. Wang，变形金刚构成深度学习的第四支柱 (2021)，方舟研究

🤖带变压器的 NLP 课程

*所有图片均由作者提供，除非另有说明

TensorFlow 2 中的多 GPU 和自定义训练循环

原文：https://towardsdatascience.com/multi-gpus-and-custom-training-loops-in-tensorflow-2-15b4b86b53bd?source=collection_archive---------13-----------------------

如何使用 tf.distribute.MirroredStrategy 在多个 GPU 上训练自定义训练循环模型的简明示例。

使用tf.distribute.MirroredStrategy在 2 个 GPU 上进行分布式训练【图片由作者提供】

TensorFlow 提供了许多关于如何执行分布式训练的优秀教程，尽管这些示例中的大多数严重依赖于 Keras API，这可能会限制想要实现更复杂模型和训练过程的用户。本教程提供了如何在 TensorFlow 2.4 中将tf.distribute.MirroredStategy与自定义训练循环一起使用的简明示例。为此，我们改编了由 Keras 和 TensorFlow 编写的 CycleGAN [1]教程，并支持多 GPU 训练。

请记住，尽管本指南不是关于 CycleGAN 本身的，但与大多数关于该主题的现有教程相比，CycleGAN 由于其(相对)复杂的损耗计算和培训程序而被用作示例。

本教程中使用的完整代码可在 github.com/bryanlimy/tf2-cyclegan获得。

摘要

一般来说，TensorFlow 2 中任何现有的自定义训练循环代码都可以通过 6 个步骤转换为与[tf.distribute.Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)一起工作:

1. 初始化tf.distribute.MirroredStrategy
2. 分发tf.data.Dataset
3. 每个副本的损失计算和聚合
4. 用tf.distribute.MirroredStrategy初始化模型、优化器和检查点
5. 将计算分配给每个副本
6. 聚合返回值和指标

包装要求

本教程需要以下 Python 包:

tqdm==4.61.0
yapf==0.31.0
matplotlib==3.4.2
tensorflow==2.4.1
tensorflow_addons==0.13.0
tensorflow_datasets==4.3.0

此外，还需要 CUDA、cuDNN 和 NCCL。有关 TensorFlow 中 GPU 支持的更多信息，请参见tensorflow.org/install/gpu。如果您使用的是conda虚拟环境，您可以使用以下命令安装上述库:

conda install -c nvidia *cudatoolkit*=11.0 *cudnn* nccl

您可以使用命令nvidia-smi来检查系统中可用的 GPU 数量。例如，我使用的系统配有 8 个 Nvidia GeForce 2080Ti GPUs:

nvidia-smi输出【图片作者】

初始化tf.distribute.MirroredStrategy

我们首先导入所需的包:

然后我们可以初始化tf.distribute.Strategy:

请注意，当devices=None时，TensorFlow 将自动检测所有可用设备。我更喜欢在每次运行开始时手动设置环境变量CUDA_VISIBLE_DEVICES，而不是以编程方式设置devices参数。请注意，nvidia-smi中的 GPU ID 不一定与CUDA_VISIBLE_DEVICES的编号相关。

使用 3 个 GPU(即CUDA_VISIBLE_DEVICES=0,1,2)运行上述代码片段将会打印出以下内容:

Number of devices: 3

数据集设置

在为分布式培训构建tf.data.Dataset时，记住以下几点很重要:

• 使用tf.data.Dataset.zip压缩前，确保所有数据集具有相同数量的样本。horse2zebra数据集由奇数匹马和斑马图像组成，因此我们必须调用下面的tf.data.Dataset.take。
• 用GLOBAL_BATCH_SIZE而不是BATCH_SIZE批处理每个数据集。
• tf.data.Dataset.cache和tf.data.Dataset.prefetch数据集，以确保在不停止计算的情况下向 GPU 提供足够的数据量。
• 可以查看 TensorFlow 的 tf.data API 关于更好性能的优秀教程。我还打算写一篇关于tf.data的教程，包括高效写作和阅读TFRecords，敬请关注。

在构建数据集之后，我们可以通过简单地调用strategy.experimental_distribute_dataset方法来分发它们。请注意，我们没有分发plot_ds,因为我们将在单个设备上执行推理。

构建生成器和鉴别器

发生器和鉴别器的架构与 Keras 教程中的模型相同。

每样本损失计算

tf.losses和tf.keras.losses中的损失函数默认返回给定批次的平均损失。用分布式训练计算的平均损失应该是相对于全局批量大小，而不是每个复制品。因此，我将定义自己的损失计算，其中函数返回每个样本的损失。例如，如果标签张量具有形状(32, 256, 256, 3)，那么返回的平均损失具有形状(32,)。还需要一个额外的步骤来计算整体批次平均损失。

为分布式训练编写损失函数时要记住的事情:

• 验证损失函数的形状。
• 如果使用[tf.keras.losses](https://www.tensorflow.org/api_docs/python/tf/keras/losses)中的损失函数，损失减少必须是NONE或SUM中的一个。
• 请注意，tf.losses和tf.keras.losses中的一些函数，如[tf.losses.mean_squared_error](https://www.tensorflow.org/api_docs/python/tf/keras/losses/MSE)和[tf.losses.binary_crossentropy](https://www.tensorflow.org/api_docs/python/tf/keras/losses/binary_crossentropy)，会减少输出的最后一个维度，因此我们必须扩展标签和预测的最后一个维度，以确保在每样本减少之前正确的输出形状。请参考下面的功能BCE。

然后，我们可以定义 CycleGAN 中使用的损失函数。我添加了一个助手函数reduce_mean，它返回全局平均损失。您也可以使用[tf.nn.compute_average_loss](https://www.tensorflow.org/api_docs/python/tf/nn/compute_average_loss)来执行相同的操作。

初始化模型、优化器和检查点

我们现在可以在tf.strategy.MirroredStrategy范围内初始化我们的模型、优化器和tf.train.Checkpoint。

下面的内容与分布式培训教程无关，但是为了让生活更简单，我添加了Summary类，用于简单的 TensorBoard 日志记录和一个绘制图像周期的辅助函数。这里我们创建一个目录OUTPUT_DIR='runs/'来存储模型检查点和 TensorBoard 摘要。

定制培训和测试步骤

这里的train_step函数与张量流教程中的函数非常相似，除了它返回一个张量字典。利用分布式训练，每个复制品将单独调用train_step。

train_step的输出示例:

{'loss_G/loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.99999964>, 'loss_G/cycle': <tf.Tensor: shape=(), dtype=float32, numpy=5.1983647>, 'loss_G/identity': <tf.Tensor: shape=(), dtype=float32, numpy=2.5991883>, 'loss_G/total': <tf.Tensor: shape=(), dtype=float32, numpy=8.797552>, 'loss_F/loss': <tf.Tensor: shape=(), dtype=float32, numpy=1.0>, 'loss_F/cycle': <tf.Tensor: shape=(), dtype=float32, numpy=3.6904013>, 'loss_F/identity': <tf.Tensor: shape=(), dtype=float32, numpy=1.8451972>, 'loss_F/total': <tf.Tensor: shape=(), dtype=float32, numpy=6.5355983>, 'loss_X/loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.49949202>, 'loss_Y/loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.49720365>}

然后我们调用strategy.run将计算分布到所有副本上，每个副本计算并从train_step返回相应的结果。由于我们的train_step函数返回一个张量字典，因此，strategy.run的返回值将成为一个张量字典。我添加了一个助手函数reduce_dict，它简单地迭代字典中的每一项，并对每个键的所有值求和。

分发计算时要记住的事情:

• 我们可以在tf.function内外迭代数据集。
• 由于每个副本的结果都与全局批量大小有关，因此我们用strategy.reduce计算SUM而不是MEAN。
• 检查从train_step返回的值(或您计划分配计算的任何函数)。例如，如果您的函数返回一个张量，那么从strategy.run返回的值将是一个张量字典。

3 个 GPU 上strategy.run(train_step, args=(x, y))的输出示例(即CUDA_VISIBLE_DEVICES=0,1,2):

{'loss_G/loss': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>
}, 'loss_G/cycle': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=1.2934016>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=1.4167924>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=1.2807639>
}, 'loss_G/identity': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.6467091>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.70838636>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.6403792>
}, 'loss_G/total': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=2.2734442>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=2.458512>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=2.2544765>
}, 'loss_F/loss': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.33333334>
}, 'loss_F/cycle': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.6893108>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=1.1769139>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=1.5197902>
}, 'loss_F/identity': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.34465796>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.58845943>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.75989777>
}, 'loss_F/total': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=1.3673022>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=2.0987067>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=2.6130214>
}, 'loss_X/loss': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.16675813>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.16679758>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.16684371>
}, 'loss_Y/loss': PerReplica:{
  0: <tf.Tensor: shape=(), dtype=float32, numpy=0.16681099>,
  1: <tf.Tensor: shape=(), dtype=float32, numpy=0.1668036>,
  2: <tf.Tensor: shape=(), dtype=float32, numpy=0.16669472>
}}

reduce_dict输出示例:

{'loss_G/loss': <tf.Tensor: shape=(), dtype=float32, numpy=1.0>, 'loss_G/cycle': <tf.Tensor: shape=(), dtype=float32, numpy=3.990958>, 'loss_G/identity': <tf.Tensor: shape=(), dtype=float32, numpy=1.9954746>, 'loss_G/total': <tf.Tensor: shape=(), dtype=float32, numpy=6.986433>, 'loss_F/loss': <tf.Tensor: shape=(), dtype=float32, numpy=1.0>, 'loss_F/cycle': <tf.Tensor: shape=(), dtype=float32, numpy=3.386015>, 'loss_F/identity': <tf.Tensor: shape=(), dtype=float32, numpy=1.6930151>, 'loss_F/total': <tf.Tensor: shape=(), dtype=float32, numpy=6.07903>, 'loss_X/loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.5003994>, 'loss_Y/loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.5003093>}

测试步骤遵循相同的程序。

训练循环

剩下的工作就是以与任何典型的定制训练循环相同的方式构建训练和测试循环。我们保存一个检查点，每 10 个时期在 TensorBoard 上绘制 5 个样本。请注意，在恢复检查点时，必须在策略范围内调用checkpoint.read。

一个时期后打印语句示例:

Epoch 001/200
Train: 100%|██████████████████████| 178/178 [12:29<00:00,  4.21s/it]
Test: 100%|█████████████████████████| 20/20 [00:24<00:00,  1.22s/it]
MAE(X, F(G(X))): 0.2599  MAE(X, F(X)): 0.2823
MAE(Y, G(F(Y))): 0.2492  MAE(Y, G(Y)): 0.2793
Elapse: 773.84s

1 个 GPU 对比 3 个 GPU 的结果

为了验证我们可以在分布计算后获得类似的结果，我在 1 个 GPU 和 3 个 GPU 上用相同的超参数训练了 2 个模型。一般来说，我们可以用更大的批量来使用更大的学习速率，尽管为了简单起见，我将所有的学习速率都保持在2e-4。平均而言，1 个 GPU 完成一个纪元需要大约 325 秒，而 3 个 GPU 需要大约 167 秒。使用多个 GPU 时，分析输入管道和训练过程以确保适当的加速非常重要，分布式训练的开销可能会超过并行化的优势。

下面的图和图像显示了 200 个时期后发生器和鉴别器的训练统计和结果。

上图:发生器和鉴别器的训练(实线)和测试(虚线)损失|下图:测试集上的循环和同一性平均绝对误差[图片由作者提供]

x → G(x) → F(G(x))样本[图片由作者提供]

y → F(y) → G(F(y))样本[图片由作者提供]

我们有了它，一个关于如何通过tf.distribute.MirroredStrategy将多 GPU 训练与 TensorFlow 2 中的自定义训练循环集成的端到端示例。

TensorFlow 和 Keras 中有关分布式培训的其他参考资料

• TensorFlow - 使用 TensorFlow 进行分布式训练
• TensorFlow - 带 Keras 的分布式训练
• TensorFlow - 用 tf.distribute.Strategy 定制训练
• Keras - 多 GPU 和分布式培训

参考

[1]朱，严军，等.“利用循环一致对抗网络进行不成对的映象对映象翻译”IEEE 计算机视觉国际会议论文集。2017.

使用电子表格在 fast.ai 中进行多标签分类

原文：https://towardsdatascience.com/multi-label-classification-in-fastai-using-spreadsheets-25ae570c8ff9?source=collection_archive---------17-----------------------

识别单个图像中的多个实体

Philippe Bout 在 Unsplash 上的照片(人/椅子/桌子)

目录

1. 简介
2. 数据集
3. 型号、激活功能和损耗
4. 模型评估
5. 结论
6. 参考文献

介绍

很多时候，我们会遇到这样的图像，其中包含我们想要识别的多个感兴趣的对象。例如，在下图中，我们可以看到我们有一把椅子和一台电视显示器。

图片由 Vinayak 提供

为了解决上述问题，我们需要能够检测给定图像中的多个类别/标签。这就是多标签分类。给定一幅图像，将其分为多个类别/标签/种类。

由于fastai是围绕Pytorch的一个非常方便的包装器，从代码的角度来看，我们需要做的改变很少，但是解决这个问题背后的逻辑会有些不同。我们不能仅仅使用我们常规的softmax激活和cross-entropy loss功能；此外，这里的评估位比单标签分类问题要复杂得多。我们将在下面的章节中详细讨论每一点。让我们首先从数据集开始。

资料组

我们将在这个任务中使用PASCAL_2007数据集。这是一个总共包含 20 个标签的数据集，注意一个图像可以有多个标签！

只需使用 fastai 的untar_data将数据集下载到您的磁盘。它将存储在您的主目录/根目录下一个名为.fastai的特殊目录中

from fastai.vision.all import *
path = untar_data(URLs.PASCAL_2007)

如果我们从训练数据集的标签视点查看统计信息，我们将获得以下内容。

图片由 Vinayak 提供

从上图中我们可以看到,“人”是训练数据集中出现频率很高的类别，其他类别也或多或少地出现了。因此，我们的数据集中存在不平衡。

另一个值得注意的有趣的事情是标签计数的总和与数据点的数量不同。在单标签中，这曾经是正确的，因为每个图像有一个且只有一个标签，但是在多标签分类器的情况下，由于每个数据点不一定只有一个对象，值得注意的是标签可以多于图像的数量。这将导致我们改变构建分类器的策略，而不是单一标签分类。

在这个数据集中，我们以数据帧的形式给出标签，而不是像 Imagenet 那样以文件夹结构给出。因此，我们必须从数据帧中读取每个条目，并定义 getter 方法来检索输入和输出的值。此外，使用数据帧中名为is_valid的列来定义分割。我们将定义一个自定义函数，为数据集中的所有点分别提供分割，即训练和验证集的索引。

在代码中，如下所示

现在，我们可以定义一个数据加载器，一旦我们有了三个主要任务的合适的 getters，即获取因变量和自变量，以及如何将它们分成训练和验证文件。与单标签分类任务不同，对于这个任务，我们将不得不使用MultiCategoryBlock来读取我们的因变量作为一个热码编码向量。其余的负载保持不变。我们可以如下加载数据

• 我们的自变量是一个图像，因此ImageBlock作为输入，后跟一个MultiCategoryBlock用于一次性编码和加载因变量。
• 上面定义了我们的拆分器，它从我们的数据帧中取出is_valid列，并基于该布尔变量来分隔训练和验证条目
• get_x函数读取列fname中的文件名，并将基本路径附加到要加载的文件中
• get_y函数从 dataframe 中读取列labels,由于我们的标签是空格分隔的，所以它使用空格分隔符分割标签字符串。
• item_tfms和batch_tfms:我们使用 fastai 的presizing技巧来避免有损图像裁剪(如填充边框等)。)和标准增强方法，然后使用imagenet_stats进行标准化，因为我们将使用预训练的resnet50进行分类任务。

现在，如果我们看一个批次的例子，我们可以观察到以下情况。看看我们如何在这些例子的图像中有多个标签。

图片由 Vinayak 提供

模型和激活函数

虽然使用 fast.ai API 定义模型和损失非常简单，但我们应该暂停一下，看看损失函数和模型，尤其是详细的损失函数。

我们将对模型头部做一些改动。我们不会像以前一样使用 softmax，而是使用 sigmoid 激活。

图片由 Vinayak 提供

softmax 所做的是将来自最终分类线性图层的逻辑值转换为总和 1。这对于多标签分类来说意味着，当我们遇到具有多个标签的例子时，我们会遭受很高的损失。例如，考虑下面的场景

图片由 Vinayak 提供

我们看到，在这个假设的例子中，数据点实际上属于类别 1 和 4，但我们的 softmax 最多只能将这两个类别的概率分数推至 0.5，而将其余两个类别的概率分数推至 0，但也不会比这更好。这是因为概率总和必须始终为 1。想象一下，如果这是一个三类的例子，那么 softmax 可以做的最好的事情就是将三个概率分数推至 0.33，将剩余的 1 个概率分数推至 0。

现在，让我们看看乙状结肠激活。

图片由 Vinayak 提供

现在，我们看到激活函数并不关心其他标签是什么。与 softmax 不同，它只关注相关标签的 logit。

这些逻辑都是解耦的，它们之间不会像 softmax 那样相互影响。

这就是为什么在上图中，你可以看到类别 1 和 3 的 Sigmoid 激活概率可以攀升到接近 1，而另外两个可以独立地接近 0。

现在，你可以更好地理解为什么我们不能使用softmax activation function而是需要一个单独的sigmoid activation function来解决这个问题。

既然我们已经改变了激活函数，我们应该重新考虑我们对损失函数的选择。

对于单标签分类，我们使用如下定义的交叉熵损失函数

图片由 Vinayak 提供

其中 ti 是真实值，pi 是标签的预测概率

如果我们继续将这个损失函数应用于我们的 sigmoid 激活输出，我们就有麻烦了。我们将不会惩罚任何事实标签为 0 的东西。对于上面的同一个示例，如果我们计算 CE 损失，我们会看到如下图

图片由 Vinayak 提供

另一方面，二元交叉熵定义如下

图片由 Vinayak 提供

其中 ti 是真实值，pi 是标签的预测概率

这真的很有趣。它确保了无论标签是什么(0/1 ),总会有一些损失来惩罚模型的错误预测。永远不会是零。当地面真实值为 1 时，损失为-log(p ),当地面真实值为 0 时，损失为 log(1-p)。这对于模型通过分类器头中的不同神经元针对它们的错误预测单独惩罚模型是非常有用的。

在上图中，我们可以看到，即使地面真实标签为 0，我们也可以获得这些神经元的有限损失值，以及单标签分类中使用的普通交叉熵损失。

对于模型，我们仍然可以继续使用我们的 imagenet 预训练主干，并从迁移学习开始。

为什么即使任务不同，模型也是一样的——单标签而不是多标签分类？

虽然最终我们必须预测每个输出的多个标签，但是我们仍然可以利用预先训练的相同过滤器来识别人、动物、物体等。这是大型 imagenet 数据集的一部分。已经智能地学习了这 1000 个类的预训练主干具有过滤器，可以检测人脸、猫毛、狗尾巴等。PASCAL_2007 数据集中也有类似的类。因此，以此为起点来利用我们已经拥有的资源是有意义的！

因此，我们现在可以定义一个fastai learner来进行培训。内容如下:

learn = cnn_learner(dls, resnet50, metrics=partial(accuracy_multi, thresh=0.5))

在这里，我们更改了指标，使用 accuracy_multi 代替了原来的 accuracy。我们将在模型评估中详细讨论这一点，但除此之外，我们还没有从我们做单标签分类时开始做任何改变，是吗？

事实上，fastai 选择 BCE loss 是因为我们已经在 dls 中指定，我们的因变量是一个多类别块。我们可以明确地指定它，但我们至少需要知道它。

然后，训练和 lr_find 以及其他内容保持不变，如下面的代码片段所示。

图片由 Vinayak 提供

模型评估

这是最重要的部分，因为这与多标签分类有很大不同。

首先，什么是精度 _ 多？

如果是多标签分类，我们的目标是one-hot encoded。同样，我们得到的输出与目标的形状相同，但它们是逻辑的。所以我们对这些应用 sigmoid 激活，并得到概率。

在单标签分类中，我们只比较一个数据点的一个标签，如果它匹配，我们的结果是准确的，否则就不是。但是，对于多标签分类，对于每个数据点，我们预测一个向量，输出也是一个向量。所以我们需要比较这些向量，而不是每个数据点的单个标量。因为我们必须比较多个值，然后取这些比较的平均值；因此得名accuracy_multi。下表将对此进行更好的总结。

图片由 Vinayak 提供

预测- >出席/缺席概率

正如我们在上面的例子中看到的，我们假设预测是一个二进制字段，但是神经网络本身并不能为每个类/标签提供一个离散值。它给了我们一个浮点数组，我们需要将它转换成一个概率分布，然后转换成一个离散值，代表一个类/标签的存在/不存在。

第一部分很简单，我们已经介绍过，即从神经网络输出的逻辑值到概率分布，只涉及对各个类别的概率值应用 sigmoid 激活。

对于下一部分，即将概率转换成离散值；我们必须设定阈值。这意味着我们选择一个概率值，并以此为支点，将连续概率转换成离散分布。下面的例子将更好地解释这一现象。

图片由 Vinayak 提供

如图所示，我们首先获取网络输出，并应用 sigmoid 激活，从而获得概率。接下来，我们任意挑选 5 个阈值[0.1, 0.3, 0.5, 0.7, 0.9]。现在，我们要做的是将这些概率与阈值进行比较。当probability > threshold时，我们将其标记为真，否则标记为假。然后取预测值的平均值，就可以得到该数据点的精确度。

在单标签分类中，单个数据点的精度可以是 0 或 1，而在多标签分类中，精度可以是 0 和 1 之间的连续值，包括 0 和 1。

现在，既然我们在讨论阈值，那么在评估过程中找出最佳阈值就变得很重要。此外，目前我们对所有类别/标签使用相同的阈值。我们可以分别调整每个类的阈值，以得出每个类的最佳分数，然后使用这些阈值来获得整个数据集的多精度。让我们看看如何做到这一点。

全局阈值

我们上面所做的在某种意义上可以称为Global Thresholding,我们对所有的类使用一个阈值，比较每个数据点的精确度，得出一个比较精确度和阈值的图，并选择一个给出最好精确度的。

下面是我们如何用代码实现它

图片由 Vinayak 提供

上述函数为我们提供了最佳精度点和发生该点的阈值，该阈值可以简单地保存为模型的人工制品，并且在推断过程中，当我们想要获得单个标签的预测时，我们可以将它们的概率与该阈值进行比较，并获得离散结果来表示某个类别的存在/不存在。

然而，我们可以做得更好。

类别/标签级别阈值

实际上，准确性并不总是最好的评估标准。例如，假设世界上只有 1%的人是富人，预测每个人都是穷人会让你 99%准确，但这真的好吗？

不是吧？当您创建一个分类器时，如果存在严重的类不平衡，您会希望您的性能在所有类中都很好，而不仅仅是在数据集中占主导地位的一两个类。准确性不能告诉我们这样的信息。在这里，有其他度量，如Precision、Recall/TPR、FPR、f1-score等。变得非常有用。这篇文章并不打算深入研究这些指标，但让我们粗略地看一下，我将在最后提供良好的资源来深入研究每一个指标。

图片由 Vinayak 提供(混淆矩阵)

• Precision:这个量基本上告诉你所有那些被预测为某种类型的例子，实际上有多少是那种类型的。如果我们看看上面的混淆矩阵，我们可以将精度定义为

图片由 Vinayak 提供

• Recall/TPR:这个数量基本上指定分类器正确识别了多少个特定类别的样本。也简称为True Positive Rate或 TPR。它是由

图片由 Vinayak 提供

• 当我们定义一个分类器时，我们希望这两个值尽可能的高，最好是 1，但是它们之间有一种反比关系。因此，我们定义了一个度量标准，它找到了两者的最佳平衡点。这是 f1 分数，原则上是召回率和精确度之间的调和平均值，定义如下

图片由 Vinayak 提供

• FPR:假阳性率是被错误分类的阴性样本的数量。它是由

图片由 Vinayak 提供

对分类器的评估可以从几个方面进行。对一些人来说,accuracy仍然是评估的黄金标准；对于其他一些人来说，f1-score可能是确保分类器跨多个类别性能的重要数字。在许多情况下，ROC或接收器操作特性图可用于计算分类器性能。我们将使用所有三种技术评估我们的模型，以获得给定特定标准的最佳性能模型。

下面是我们用来训练模型的PASCAL_2007数据集的bus类别的 ROC 图

图片由 Vinayak 提供

X 轴表示 FPR，Y 轴表示召回/TPR。我们需要确定在不增加 FPR 的情况下 TPR 尽可能高的点。我们可以通过找到最接近(0, 1)点的点来解决这个问题，即 FPR 为 0 而 TPR 为 1。这显示在带有红点的曲线中。对于一个完美的分类器，我们应该有一个单位矩形类型的图，但实际上在大多数情况下，这两类的分布从来没有完全区分。

1.从 fastai 学习者那里获得预测和目标

2.分离出每个标签的预测和目标。fastai 预测的形状为“N_EXAMPLES x N_CLASSES ”,因此将它们分成 N _ CLASSES 个长度为“N_EXAMPLES”的向量。对目标也进行类似的操作。

3.选择一系列阈值，并评估每个类别/标签的所有示例的指标精度、召回率、fpr、f1-得分，并构建 ROC-AUC 曲线。

4.在您改变阈值的所有点中，选择最接近的点、最佳准确度和最佳 f1 得分点。记录您获得这些指标最佳值的每个点的阈值。

5.使用从 4 中获得的每个类别的记录阈值，将概率分布转换为离散分布，并找到多标签分类器的总体精度。

如果我们要进行比较，对于每个类别，使用 bestAccuracy 策略的单个类别/标签的阈值调整使我们在准确性上比全局阈值略有提高，这也使我们在默认阈值 0.5 上有所提高，默认阈值 0.5 通常用于所有分类问题。

图片由 Vinayak 提供

结论

1. 多标签分类器(MLC)可以用多个类别/标签标记给定的数据点。
2. MLC 中使用的激活是sigmoid而不是softmax。
3. 用于 MLC 的损失函数是BinaryCrossEntropy而不是CrossEntropy。
4. 一个好的阈值可以在获得更好/更差的 MLC 精度方面产生显著的差异。
5. 在模型评估过程中，准确性可能不是黄金标准，回忆/精度/f1 分数等指标将非常有用，尤其是在训练模型时存在类别不平衡的情况下。

我希望你喜欢阅读这篇博文！我很高兴在推特上与你联系。如果你有任何意见/建议/想法，欢迎在下面评论或在 Twitter 上联系我。

如果你喜欢你所读的，请随意查看我在这里的其他帖子。

参考

1. wandb fastbook sessions 链接
2. 在帖子中创建的应用程序的 Github 代码
3. 对评估指标的良好解释

使用 PyTorch + HuggingFace 的 Transformers 和 W&B 进行跟踪的多标签情感分类

原文：https://towardsdatascience.com/multi-label-emotion-classification-with-pytorch-huggingfaces-transformers-and-w-b-for-tracking-a060d817923?source=collection_archive---------6-----------------------

实践教程

把拥抱脸和 W&B 的力量加入到你的 PyTorch 代码中！

腾雅特在 Unsplash 上的照片

介绍

自然语言处理(NLP)正在以前所未有的速度在工业 4.0 中大步前进，并以一种闪烁的速度前进。它被广泛用于将非结构化文本处理成各种商业案例的有意义的知识。它已经被用于多种任务，如分类、主题建模、文本生成、问答、推荐等。一种很少被提及的特殊分类是多标签分类。

多标签文本分类涉及预测给定文本的多个可能标签，不像多类分类，其仅具有来自“N”个可能类的单个输出，其中 N > 2。多标签文本分类是许多 ML 库中很少涉及的主题，对于某些任务，如日志度量等，您需要自己编写大部分代码。您还需要了解某些变通方法，以获得一些有意义的结果。

二元对多类对多标签分类。作者图片

我想做这个项目的一个关键原因是让我自己熟悉Weights and bias(W&B)库，这个库和 HuggingFace 库一起在我的技术 Twitter 上引起了热议。在 PyTorch 中使用多标签分类及其与 W & B 的集成方面，我没有找到很多好的参考资料。因此，我想整理一篇文章以方便参考。不要担心，我会在我们进行的过程中讨论什么是 W & B，你会很幸运地知道，有了这个令人敬畏的图书馆，我们的生活变得多么方便！在本文中，我们将讨论以下内容:

1. 与…一起工作🤗用于加载数据集的数据集库
2. 使用构建经典 PyTorch 训练器🤗变形金刚图书馆的 SqueezeBERT 模型
3. 用 PyTorch 集成 W&B 库
4. 用🧹w & b 扫描执行超参数扫描

所以，不要浪费任何时间，让我们开始吧！

数据集使用🤗数据集

HuggingFace 的网站有一个几乎所有类型的 NLP 任务的巨大数据集集合！它还允许用户通过使用 Streamlit 制作的内置数据集可视化工具来可视化数据集的某些方面。在浏览数据集列表时，一个特殊的多标签分类引起了我的注意:https://huggingface.co/datasets/go_emotions。其摘要指出:

GoEmotions 数据集包含 58k 条精心策划的 Reddit 评论，标记为 27 种情感类别或中性。包括原始数据以及具有预定义训练/val/测试分割的数据集的较小简化版本。

在他们的可视化工具上浏览了这个数据集中的几个例子后，我意识到这是一个极其重要的数据集，因为很难找到超过 5-6 种情绪的情绪分类器数据集。但是在这里，我们有 27 种情绪被分配，有非常罕见和接近的情绪，如失望、不赞成、悲伤、悔恨、悲伤等。在典型的数据集中，检测如此接近的情绪通常是困难的。这让我明白这是一个非常好的数据集，可以在许多涉及文本分析的应用程序中扩展使用。

数据集中的情感标签列表。作者图片

权重和偏差介绍(W&B)

日志度量一直是许多数据科学家和 AI/ML 爱好者头疼的问题。编写计算指标、存储指标和绘制图表的代码是一项非常普通的任务。此外，当您在一个专业的环境中工作时，您不希望您的客户或团队领导浏览整个代码来找到那些图。因此，您必须截取屏幕截图，然后准备一份单独的报告或演示文稿来分享您的结果。想象一下你花在所有这些步骤上的时间。

值得庆幸的是，有人听到了我们的抱怨和咆哮，并决定建立一个库，使所有这些自动化，并在组织我们的代码、数据、指标和运行方面走得更远，比我们组织我们的卧室更好👀。欢迎，重量和偏见(W&B)🙌。

W&B 允许我们使用几行代码实时监控我们的数据、代码、超参数、指标和培训。它提供了一个直观的仪表板，并与 PyTorch、Tensorflow、fast.ai、Keras、JAX 等流行的库集成。它允许我们以更有组织的方式找到最好的模型，而不是使用打印语句和手工记录。首先，你需要在他们的网站上注册一个账户，然后你的项目跟踪就可以在你的账户上使用了！

好了，理论讲够了，我们来编码吧！

这是你对吗？来源:男高音

现在，让我们用编码来弄脏我们的手。我使用 PyTorch 是因为它简单易懂，并且能够从头开始构建东西，这让我感觉更舒服。我已经在 Google Colab 上编码了整个东西，所以我只需要做一些额外的安装。但是，如果您在本地运行它，请注意下面的导入，您的系统中可能没有安装这些导入。然而，我强烈建议你使用 Google Colab，因为它允许你在网络上进行深度学习实验，而无需在笔记本电脑上加载任何负载。

从这一点开始，这篇文章可能会有点长，因为我将同时讨论 W & B 和多标签分类。所以，在我们踏上这个奇妙的旅程时，请耐心等待！🙈

全部代码在我的资源库 这里 都有。

1.安装依赖项⏬

我们可以使用以下命令在 Google Colab 中进行必要的安装:

!pip3 install datasets transformers -q

!pip3 install wandb --upgrade

现在，我们可以使用以下方式登录我们的 wandb 帐户:

import wandb

wandb.login()

系统会提示您单击一个链接，复制您的授权令牌并将其粘贴到文本框中，以将您的项目与您的 WandB 帐户连接起来。

2.必要的进口🚀

3.播种一切可复制性！🌱

播种是一个非常重要的概念，我经常在许多中等代码教程中发现缺失。我发现帮助读者重现和匹配结果是一个重要的实践。所以，让我们播种一切吧！

4.定义超参数扫描🧹的扫描配置

为了执行超参数调整，我们从定义的列表中尝试不同的配置，然后尝试在我们的主训练循环中运行它们，并手动记录每个组合的结果，以找到最佳的超参数集。告别这种中世纪(就 AI 进步而言)的做法，用超参数横扫🧹做同样的事情！我们将定义一组我们想要使用的超参数，并设置它们可能的值。我们还定义了我们想要最大化或最小化的指标。

最后，我们定义了一个扫描 ID，它将使用不同的超参数组合对训练函数进行扫描。

5.从加载数据集🤗数据集和一次性编码

train.head()输出。作者图片

我们可以看到数据集有与每个样本相关联的文本、id 和标签。然而，为了将数据输入到我们的模型中，我们需要执行一次热编码，它有一个非常常见的代码:

6.定义 PyTorch 数据集

我们没有在类中定义记号赋予器，而是将其作为参数传递，以便于使用不同的记号赋予器进行实验。我们按照定义 PyTorch 数据集类的标准方式来定义 GoEmotionsDataset 类，以指示如何加载和处理数据集。

在我们的例子中，我们获取输入文本，将其标记化，然后返回通过标记化获得的标记 id 和注意掩码。令牌 id 只是模型的输入序列的数字表示，而注意掩码用于指示模型应该注意哪些段。

7.使用神经网络定义分类器模型。组件

这里，我们将 dropout probability (do_prob)作为一个超参数，将由 W&B 处理。其余的代码非常标准:用所需的架构初始化模型，并定义向前传递。

8.定义返回数据集、数据加载器和模型的函数

对于我们的超参数跟踪和 W&B 的集成，重要的是我们大量使用函数编程来确保我们成功地跨函数传递所有对象，并且它们都可以从我们稍后将定义的主训练器函数中调用。

在这里，我们首先定义我们的 SqueezeBERT 记号化器(与 bert-uncased 相比非常快，性能几乎相似),然后定义 3 个函数来返回数据集、数据加载器和我们的模型。所有这些都遵循标准 PyTorch 管道。同样，将它们定义为函数的主要动机是使我们能够方便地传递我们的超参数，而不是将它们硬编码在模型定义本身中。

9.定义要记录的优化程序、调度程序、损失函数和度量

优化器功能:

调度程序功能:

损失函数或准则:

对于损失函数，我们选择了具有 Logits 损失的二元交叉熵(BCE)。BCE 将每个预测概率与实际类输出进行比较，实际类输出可以是 0 或 1 。然后，它根据与期望值的距离计算惩罚概率的分数。这意味着离实际值有多近或多远。当与 Sigmoid 层结合时，会在 PyTorch 中产生 BCEWithLogitsLoss()。也可以使用 MultiLabelSoftMarginLoss()来解决多标签问题。

具有 Logits 损失函数的 BCE

要记录的度量:

[ROC-AUC](https://www.scikit-yb.org/en/latest/api/classifier/rocauc.html#:~:text=A%20ROCAUC%20(Receiver%20Operating%20Characteristic,the%20classifier's%20sensitivity%20and%20specificity.) 评分是衡量我们多类分类性能的好方法。但是，通过对每个目标分别应用它，可以将其推广到多标签场景。然而，这对于我们的大脑来说太多了，因此，我们可以简单地使用微 AUC。PyTorch 中用于这种多标签分类的一个巧妙技巧是使用 ravel()函数展开目标和标签，然后我们应用 micro AUC 函数。

10.定义培训和验证步骤功能

我再次从 Abhishek Thakur 的知识库中提取了这些代码片段，并根据我的问题陈述对它们进行了修改:

11.定义培训师职能⭐️

为了将所有内容整合在一起，我们现在将定义执行培训的培训师职能。在我们的分类器模型中，我们将使用 SqueezeBERT 作为 BERT 层。这个教练功能也是 W&B 魔法发生的地方！

你在这里观察到一些新的东西吗？是的，旺德贝线！您可以看到，我们在开始时使用了上下文管理器和 with wandb.init() 语句来初始化运行。训练功能的每次执行是一次运行。我们将扫描配置传递给训练器函数，该函数用于设置不同的超参数，如 batch_size、dropout、epochs 等。另一个基于 wandb 的行是 wandb.watch() ，它用于观察模型的梯度，以及它们如何随着训练而演变。这有助于尽可能提供更多的可解释性。

wandb 的下一次出现在 wandb.log() 中，它帮助我们记录相关参数，我们希望看到这些参数随着训练的进行而变化。在我们的案例中，我们记录了时期、训练和验证损失以及 AUC 分数。最后，为了开始不同超参数组合的扫描，我们将调用wandb.agent()，在这里我们传递配置和训练器函数的 sweep_id。我们还传递 count=6，以限制我们想要执行的运行次数。这仅在进行随机搜索而非网格搜索时使用。一旦训练开始，你可以在 W & B 宏伟的仪表盘中实时监控训练！🤌🏻

跳上你的 W&B 仪表板，看看神奇的展开！

W&B 仪表板的概述。作者图片

在这里，您可以看到扫掠中的每个管路都有一个唯一的名称，您可以轻松地对其进行重命名或删除。您还会注意到参数对于我们正在监控的指标的重要性(此处为 AUC 得分)。这是一个极其重要的特征，因为它告诉我们哪些超参数对我们的分数影响最大。在我们的例子中，我们可以看到辍学对 AUC 分数有很大的影响。当我们想要设置最佳超参数设置时，这是一条需要注意的关键信息。当我们向下滚动时，我们看到了扫描图，它显示了每个超参数组合如何产生特定的 AUC 分数。这是 W&B 在 Sweeps 中提供的我特别喜欢的图表类型！

扫描图表。太酷了！作者图片

这里，图表清楚地向我显示了产生最佳 AUC 分数的组合(黄色图)。如果你渴望用老派的方式查看数据，你还可以得到一个不错的表格格式！

扫地台。作者图片

除此之外，我们还获得了我们记录的度量的图表，并获得了所有不同运行的比较图。您甚至可以关闭某些运行的可视化，以比较其余的期望运行！

其他度量图。作者图片

**如果您已经被 4-5 行 wandb 所能做的事情弄得不知所措，请耐心等待，因为我将向您展示更多内容！还记得 **wandb.watch(型号)那条线吗？你认为我们为什么要观察这个模型？嗯，你可以去每次跑步，看看在训练中模型的梯度是什么样的！这对模型可解释性和可解释性研究人员来说极其重要！

模型梯度演化。作者图片

但就这样了吗？再说一次，不！您甚至可以使用 W&B 观察系统指标，它显示各种图表，如内存使用情况、CPU/GPU 使用情况、温度、磁盘使用情况等。

系统指标图。作者图片

如果你认为这些是你能绘制的唯一的库驱动图，你就错了。您可以混合匹配您记录的任何参数，然后轻松地绘制它们，以查看它们的比较。您可以根据需要灵活地制作图表，甚至使用 W&B 生成报告！然而，与团队共享它需要团队的 W & B。

它还记录它在训练脚本中看到的所有输出，以及通过版本控制记录代码和数据集。不仅如此，它还根据训练脚本自己生成一个 requirements.txt 文件。所以，现在你甚至不需要 pip 冻结，你可以直接下载这个文件，并与他人分享！

作者在黑白图像中自动生成的文件

wandb 库不断增加越来越多的特性，如表格等。因为这篇文章已经太长了，所以我把它留到以后讨论。因此，长话短说，训练信息现在在 W&B 的仪表板上有一个漂亮的庇护所，这将使我们能够随时复制实验。这样，我们现在可以使用最佳超参数组合来训练模型，然后使用派生的模型进行推理。从我的训练中，我能够得到一个非常好的模型，AUC 分数为 0.9459。使用该模型测试非常稳健的 AUC 分数，其中 27/28 个类别的标签式 AUC 分数大于 0.8！对于如此复杂的数据集来说，这的确是一个非常令人印象深刻的分类器。

标签式 AUC-ROC 评分。作者图片

结论

来源:男高音

唷，我们终于可以结束了！本教程展示了如何在多标签数据集上应用 SqueezeBERT，该数据集包含超过 50K 条评论和 28 个类。使用 PyTorch 和变形金刚库。我们还能够通过 wandb 库实时监控我们的培训。在公开您的项目后，您还可以通过共享“公开”项目链接与他人共享您的整个仪表板！这是我的仪表盘链接。在未来，我们可以使用 Streamlit 部署这个多标签情感分类器，并在此基础上构建一个 web 服务！

的全部代码可以在我的资源库 这里 中找到。

感谢您的耐心让我们走到这一步！如果你想了解更多关于 wandb 库和 HuggingFace 库的信息，我已经把它们链接到下面了，看看吧！

**https://wandb.ai https://docs.wandb.com https://huggingface.co https://www.youtube.com/c/AbhishekThakurAbhi

我看得出你是个有文化的人，能走到这一步！我很高兴你能走到这一步！别忘了关注我更多这样的 ML 相关文章！查看我的网站，关注我的 LinkedIn 、 GitHub 和 Instagram ！✨**

AWS Sagemaker | MLOPS | Pytorch 中的多模型部署

原文：https://towardsdatascience.com/multi-model-deployment-in-aws-sagemaker-mlops-pytorch-baf0fa08be42?source=collection_archive---------12-----------------------

如果你曾经部署过一个计算繁重的人工智能模型，你可能知道它的部署价格。不一定是 AI 模型；它可以是在生产中全天候运行的任何模型。

solébikes 在 Unsplash 上拍摄的照片

我生产的 pytorch 型号很少，不管我使用什么平台，随着时间的推移，它都非常昂贵。所以我决定降低模型部署的成本。我发现 AWS sagemaker 有一个多模型部署选项。然而，这些文档并不是非常友好，而且经常令人困惑。所以我决定在这篇文章中多解释一些。

如果您正在通读这篇文章，我假设您知道 AWS sagemaker，并且能够在平台中部署模型。如果没有，请参考这篇文章来详细了解一下。

设置时需要的东西

1. 具有 sagemaker 访问权限的 AWS 帐户
2. ECR 码头集装箱入口
3. Sagemaker 笔记本或本地 jupyter 笔记本环境

多模型如何工作？

当您使用 sagemaker 部署单个模型时，它将启动一个实例，启动一个 docker 容器，从 S3 桶中加载模型的 tar 文件，最后从创建的代码中创建一个端点。

1. 当一个模型被调用时，它将请求路由到部署的端点后面的实例。
2. 每个多模型实例包含处理所有请求的容器。传入的请求被路由到容器。
3. 当请求到达容器时，它将模型下载到该实例上的容器内存中。
4. 如果内存不足以容纳多个模型，它将卸载第一个或未使用的模型。

对于每个模型类型和库，多模型的底层 docker 容器和模型是不同的。关键是当有多个模型时，它会根据端点请求将模型加载到容器内存中。

不同类型的多模型部署:

1. 使用预制集装箱
2. 自定义集装箱相似输入
3. 带有其他类型输入的定制容器——这通常不包含在 AWS 文档中。

使用预制容器—不复杂

只有当您有一个已经由 AWS 预构建的容器时，这种类型的方法才有帮助。这个链接包含可以在 sagemaker 中使用的容器列表。AWS 基于 xgboost 模型打造了一款笔记本。此链接详细介绍了所使用的代码。

1. 从 sagemaker 中检索现有容器
2. 准备和培训每个模型

3.使用 sagemaker 内置调用创建多数据模型端点。

点 S3 数据和训练好的模型

部署多个模型

4.最后，下面是从 API 调用中调用模型的代码。

优点/缺点:

1. 除了数据准备和模型训练，多模型部署更加简单。
2. 如果你仔细看看代码，你会发现我们是在用不同的名字部署相同类型的模型。这在大多数情况下是没有用的。
3. 相似类型的输入被传递给不同的模型进行预测。如果你想节约成本，一般情况下是不会的。
4. 容器已经预制好了。所以我们不能对它做任何定制。

自定义容器类似输入处理

上一节提到的方法对我们大多数人都不起作用。Sagemaker 提供了一个定制容器的选项。这是你可以定制的容器列表。在这种方法中，您可以部署多个模型，并根据需要定制容器。

然而，它不像前一个那样直截了当。它需要一些码头集装箱的工作。在幕后，sagemaker 使用开源工具多模型服务器。让我带你经历每一步。

作为第一步，我们需要有一个创建定制容器的模型和理由。很多时候，容器中构建的包不够用，会和其他包冲突。

1. 创建一个包含所需包的 docker 文件

2.如果你注意到，有一个 python 入口点。这个入口点启动多模型服务器流程，该流程被包装在 sagemaker 中。

3.下一步，将多个模型上传到 S3 存储桶中，并作为常规流程创建端点。

如果您看到这个代码，您可能已经注意到模型是用 mxnet 创建的。这并不是非常流行，而且需要对 python 文件进行不同的更改。

从我的经验来看，我尝试过这种方法，部署模型有点乱。

优点/缺点:

1. 上面提到的例子是在 mxnet 上。PyTorch/TensorFlow 没有很好的例子。
2. 它仍然可以处理相似类型的输入。例如，您不能为另一个模型传递文本和图像。
3. 当我们试图部署多个模型时，这个过程有点混乱。

具有不同输入处理的自定义容器

由于提到的两个选项都有一些缺点，我决定为我的项目做一点不同的选择。我不得不部署微调的 GPT-2 和巴特-大-cnn 模型。对于这个例子，我将使用预先训练的模型作为例子。

这两个预先训练的模型都可以作为拥抱脸模型管道的一部分。下面是我为简化和部署多个模型所遵循的步骤。

1. 在这里，我们正在更新 sagemaker 的预构建容器，并根据我们的需要定制容器。

在第一行中，我们从 sagemaker 导入现有的容器。然后我们向它添加所需的包并对其进行定制。最后，我们将向 docker 容器添加一个入口点。

2.将所需的模型上传到 S3 存储桶。在这里，我们必须将这两个模型合并到 model.tar.gz 文件中。

3.现在，我们需要 app.py，来自 docker 容器的主入口点。它基本上是一个 flask API。

如果你看到上面的截图，我们使用两种不同的拥抱面部管道，创建不同的模型。为了调用模型，我们需要指定模型类型。在函数 run_model 中，我们会提到使用哪个模型。这里流程提到了模型类型。

4.其余的代码将不会花哨或任何不同。我们必须在大型服务器上部署这个模型。我使用 ml.c5.2xlarge 在一台服务器上部署这两种模型。当我们调用模型时，我们需要指定模型类型和输入。

准备端点的输入

汇总模型的输出

从上面的截图可以看出，我们可以通过在端点中传递模型类型(流程)来调用不同的模型。

优点/缺点:

1. 我们可以为不同的模型传递不同类型的输入。输入不再限制我们。
2. 模型操作过程是干净的，可以很容易地开发和维护。
3. 部署这两种型号可以节省大量资金。

获取代码

请订阅我的 简讯 获取我的文章和其他更新的免费工作代码。

通过 Heroku 和 HTML 实现“多页”应用

原文：https://towardsdatascience.com/multi-page-apps-done-right-via-heroku-4537cd196f2?source=collection_archive---------24-----------------------

多梅尼科·洛亚在 Unsplash 上拍摄的照片

比方说，你想建立一个有多个不同页面的 Heroku web 应用程序——也许你有一些不同的可视化效果，你想让人们能够与之交互，但这并不完全适合一个页面。但是，当你在 Dash 或其他软件中构建一个普通的多页面应用程序时，你可能会发现你使用了比你真正需要的更多的内存，并且整个界面可能没有你想要的那么漂亮。

所以这篇文章会帮你解决两个相关的问题。首先，Heroku 自由层帐户在内存和内存块大小上有一些非常实际的限制，这可能会阻止你的应用程序一次做太多事情。第二，在 Dash 或 Flask 中使用 Python 代码设计应用程序可能有点痛苦。毕竟，这些工具必须同时完成应用程序和的实际工作。他们倾向于关注第一项任务，而让第二项任务变得更加棘手或混乱。

我将带大家了解的解决方案是托管多个独立的 Heroku 应用程序(不要担心，这不会让你付出任何额外的代价),并使用 HTML 在几个相连的网页上访问它们。这使我们能够削减内存和 slug 大小的要求，因为我们可以在我们不同的应用程序之间分割这些。这也意味着我们可以使用 HTML 和 CSS 的所有工具来流畅轻松地设计我们的应用程序。要查看这个解决方案的运行情况，您可以在philosophydata.com查看我的实现。

要跟进，你需要(1)一个功能正常的 Heroku 应用，(2)愿意学习一些超级基础的 HTML，(3)一个 Github 账户。

这个过程有三个核心步骤。创建你的网站。在您的网站中显示您的应用程序
3。托管你的网站

所以事不宜迟，我们开始吧！

1。创建您的网站

这可能是最恐怖的一步。你刚刚建立了一个完整的应用程序，你真的需要建立一个网站吗？你可能甚至不知道任何 HTML 或 CSS——这将是一场噩梦！

别害怕，我的朋友。这会花费你更多的时间，但这比尝试在 Dash 中设计你的应用要容易得多，它给你一个学习新技能的机会，并且它会给你带来更多完美的结果。

这样做的关键是找到一个你喜欢的现有 HTML 模板，并简单地根据你的需要修改它。你可以在 templated.co找到一个很棒的模板库。

这可能是你的应用程序

一旦你找到一个你喜欢的，只需下载带有模板的文件夹。如果你打开它，你会发现一些 HTML 页面，一个保存相关 CSS 和 Javascript 的 assets 文件夹(所有东西都已经为移动设备进行了样式化和优化，没有必要强调)，以及一个保存图片等的文件夹。

此时，你只需要在空白处填入你喜欢的信息。打开 index.html 文件，将标题更改为您喜欢的标题，并给标签添加新标签。

您的可能看起来略有不同，但这些是您想要更改的部分

好了，现在你已经修改了标题和标签。要更改登录页面图像，您需要进入 style.css 文件(有时也称为 main.css)并找到它引用当前横幅图像的位置。用你选择的图像替换它，你就可以开始了。

以下是 5 分钟修改代码中一些单词的结果:

像冰一样凉。哇！

你可能想用更具描述性的标题重新标记一些 html 文件，一般来说只是浏览和添加新的页面，弄乱图像，诸如此类的事情。要在进行过程中查看更改，请在浏览器中打开 HTML 文件并刷新页面。有很多尝试和错误，但设计是有趣的！

我把实验留给你，但是如果你遇到任何困难，请随时联系我。现在让我们来看看好东西:在网页中设置你的应用程序。

2.通过 HTML 显示您的应用

如果你已经在 Heroku 上托管了你的应用，那么你也有了一个链接。从这里开始，通过 HTML 将应用程序的结果显示为页面中的页面是一件简单的事情。

以下是 HTML 的外观:

<iframe src=”YOUR HEROKU URL", width=100%, height=500></iframe>

你当然可以根据自己的需要调整宽度和高度。点击此处深入了解 iframe。

结果将是这样的:

HTML & CSS 设置标签和标题，但是搜索栏和按钮是 Heroku 应用程序

请注意，Heroku 应用程序本身根本不需要任何样式。但是它看起来仍然非常干净和清晰，因为 CSS，一种为设计风格而设计的语言*，正在做所有的工作。*

此时另一个很酷的技巧是多次显示同一个应用程序，按列或行排列。这意味着一个相对简单的应用程序可以在一个页面上多次使用，从而可以对输出进行比较。

这里有一个例子。首先是 HTML:

# adjusting the width makes these display as three columns, with some space between them<iframe src=”https://w2v-data.herokuapp.com/", width=300, height=450, scrolling=’no’></iframe><iframe src=”https://w2v-data.herokuapp.com/", width=300, height=450, scrolling=’no’></iframe><iframe src=”https://w2v-data.herokuapp.com/", width=300, height=450, scrolling=’no’></iframe>

然后结果是:

该应用程序返回指定作者和单词的单词向量相似性结果；有三个栏目，你可以比较三个不同的作者。

现在您的工具箱中已经有了这个工具，您可以在任意多个选项卡上使用它。这不应该占用你的应用程序的内存，因为每个应用程序都托管在一个单独的 dyno 上，而一个常规的多页面应用程序必须在一个 dyno 上保存所有的应用程序。我的实现能够托管 4 个不同的应用程序，有时在一个网页上可以托管三倍，同时永远不会突破 Heroku 50%的内存限制。使用通常的多页面方法，我很难加载多个应用程序。

现在我们有了一个漂亮的网站。让我们看看如何让全世界都知道这个。

3.托管您的网站

有许多托管服务，但有一个简单的是 Github Pages。每个 Github 帐户都可以免费托管一个网页。

要设置它，首先创建一个名为 .github.io 的 repo。

git clone [https://github.com/*username*/*username*.github.io](https://github.com/username/username.github.io)

现在你有你的网站回购，你可以复制所有你一直在工作的文件，添加它们，并提交更改。

Github 会看到你创建了一个格式为 .github.io 的 repo，并会自动寻找一个 index.html 文件作为网站托管。这很像 Github 让你用自己的用户名创建一个 repo 来为你的页面设置一个 readme。

一旦你建立了回购，你基本上就完成了！干得好！如果你想添加最后一层润色，你可以为你的站点设置一个自定义域名，这样 URL 就不会指向 github.io 名称。这很容易做到，一旦你买了你想要的域名，你就可以按照这里的步骤来设置它。

现在你有了一个漂亮的多页面应用程序，具有出色的造型和低内存使用。精彩！

让我知道这是否有帮助，或者如果你遇到任何困难，我很乐意帮忙。关于我自己的 Github 网站是如何建立的，查看这里的回购。

使用机器学习和自然语言处理的多页文档分类

原文：https://towardsdatascience.com/multi-page-document-classification-using-machine-learning-and-nlp-ba6151405c03?source=collection_archive---------0-----------------------

一种对具有不同变化形状、文本和页面大小的文档进行分类的方法。

来源:https://unsplash.com/photos/5cFwQ-WMcJU

本文描述了一种新颖的多页文档分类解决方案，它利用高级机器学习和文本分析来解决抵押贷款行业的一个主要挑战。

摘要

即使在今天的技术时代，大部分业务都是使用文档完成的，涉及的文书工作数量会因行业而异。这些行业中的许多需要通过扫描文档图像 ( 通常包含不可选择的文本)来获得关键索引字段的信息，以操作他们的日常任务。

为了实现这一点，第一个主要任务是索引不同类型的文档，这有助于从各种复杂的文档中提取信息和元数据。这篇博文将展示如何利用高级机器学习和 NLP 技术来解决这个难题的主要部分，正式名称为文档分类。

介绍

在抵押贷款行业，不同的公司执行数千人的抵押贷款审核。

每个单独的审计都是针对各种文件进行的，这些文件作为一个捆绑包提交，称为贷款包。一个包是扫描页面的组合，可以从**(100–400 ~)页变化。包内有多个子组件，可能由(1–30 ~)页组成。这些子组件被称为文档或文档类别**。下表直观地说明了这一点。

第二行代表一个包，数字显示该包中存在的有序页面。第三行显示包中不同种类文档的出现。

背景和问题陈述

传统上，在评估贷款审计时，文档分类是人工工作的主要部分之一**。**抵押贷款公司大多将这项工作外包给第三方 BPO 公司，这些公司通过使用手动或部分自动化的分类技术(即规则引擎、模板匹配)来执行这项任务。当前实现所面临的根本问题是业务流程外包( BPO )人员必须手动查找和分类包中存在的文档。

尽管很少有第三方公司使用关键字搜索、正则表达式等来实现某种程度的自动化。这种解决方案的准确性和鲁棒性是有问题的，并且它们的人工工作量减少仍然不令人满意。 关键字搜索和正则表达式 意味着这些解决方案需要考虑所呈现的每个新文档或文档变体，并且还需要为此添加规则。这本身就变成了手工操作，只能实现部分自动化。系统仍有可能将文档类标识为“ Doc A ”，但实际上它是“ Doc B ”，因为两者中存在共同的规则。此外，身份识别也没有确定性。通常情况下，仍然需要手动验证。

有几百种文档类型，BPO 人员需要有一个“ 的知识库，知道某个文档是什么样子，同一文档有哪些不同的变体？”， 以便对文档进行分类。最重要的是，如果人工工作太多，人为错误往往会增加。

目标

文档分类解决方案应该能够显著减少人工工作量。它应该在最少人工干预的情况下实现更高水平的准确性和自动化

我们将在这一系列博客中讨论的解决方法不仅限于抵押贷款行业，它可以应用于任何需要扫描文档图像并对此类文档进行分类的地方。几个可能的行业有 金融机构、学术界、研究机构、零售店

文件的特点

为了做一个解决方案管道，第一步就是要知道什么是数据，它的不同特征是什么。由于我们一直在抵押贷款领域工作，我们将定义我们在抵押贷款行业中处理的数据的特征。

在一个*包中，*有许多类型的页面，但是一般来说，这些可以分为三种类型:

结构化| 一致的表单和模板

例如:调查、问卷、测试、索赔表

非结构化| 文本化，无格式和表格

例如:合同、信件、文章、笔记

半结构| 以上两者的杂交，可能有部分结构

例如:发票、采购订单、账单、eob

就文件而言，以下是在数据中观察到的特征。

• 包裹中的文件顺序不一致。例如，在一个包文档**“A”可能在文档“B”**之后，而在另一个包文档中则相反
• 同一个文档类有许多变体。一个文档类可以有不同的外观变化，例如，一个**文档类“A”**页面模板/格式可能因美国不同的州而异。在抵押贷款领域，这些表示相同的信息，但在格式和内容上有所不同。换句话说，如果“猫”是一个文件，不同品种的猫就是“变种”。
• 文件类型有不同种类的扫描变形，即噪声、2D 和 3D 旋转、扫描质量差、页面方向，这些会扰乱这些文件的 OCR。

解决方法

在这一节中，我们将抽象地解释我们的解决方案管道是如何工作的，以及每个组件或模块是如何组合在一起产生一个端到端的管道的。下面是解决方案的流程图。

解决方案|流程图

既然目标是识别包内的文档，我们就必须识别 一个文档内的什么样的特征，使它不同于另一个？ 。在我们的例子中，我们认为文档中的文本是关键，因为直觉上我们人类也是这样做的。下一个挑战是找出文档在包中的位置。在多页文档的情况下，边界页(开始、结束)最有意义。因为使用这些页面，可以识别一系列文档。

机器学习课程

在机器学习方面，我们把这个问题当成了**分类问题。**我们决定在这里标识出 每个文档的第一页和最后一页 。我们将我们的 机器学习类 (ML 类)分为三种类型:

• 首页类:这些类是每个文档类的首页，负责标识文档的开始。
• 末页类:这些类是每个文档类的末页，负责标识文档的结尾。这些类仅适用于包含多页样本的文档类。
• Other Class: 这个类是一个单独的类，包含所有文档类的中间页面，合并成一个类。拥有这个类有助于后面阶段的管道，它减少了文档的中间页面被分类为同一文档的第一页或最后一页的情况，这在直觉上是可能的，因为在所有页面(如页眉、页脚和模板)之间可能存在相似性。这允许模型学习更健壮的特征。

下图展示了这些不同类型的 ML 类在包和文档方面的表现

这里 A、B 是文档 A、B 的第一个页面类。此外，A-last、B-last 是相同文档的最后一个页面类。任何文档类的所有中间页面都被视为另一个类

机器学习引擎

一旦定义了 ML 类，下一步就是准备用于训练机器学习引擎的数据集(数据准备部分将在接下来的章节中详细讨论)。下图解释了机器学习引擎的内部工作原理，是解决方案管道的一个更技术性的视图。

端到端分类周期。

让我们一步一步地描述解决方案的不同阶段。

第一步

• 包(pdf 格式)被分割成单独的页面(图像)

第二步

• 通过从图像中提取文本并生成文本文件的 OCR (光学字符识别)**、**处理各个页面。我们使用了最先进的 OCR 引擎来生成我们案例中的文本。有许多免费的在线 OCR 产品可以在这个步骤中使用。

第三步

• 对应于每个页面的文本然后被传递到机器学习引擎，在那里文本矢量器(Doc2Vec) 生成其特征向量表示，本质上是一个浮点列表。

第四步

• 然后将特征向量传递给分类器(逻辑回归)。分类器然后预测每个特征向量的类别。这些基本上是我们之前讨论过的 ML 类别之一(第一、最后或其他

此外，分类器返回所有 ML 类(图表最右边的部分)**的置信度得分。**例如让(D1，D2..)是 ML 类，那么对于单个页面，结果可能如下所示。

后加工

一旦整个包被处理，我们使用结果/预测来识别文档的边界。结果包含包中所有页面的预测类和预测的置信度得分。请参见下表

下面是使用来自机器学习引擎的输出来识别文档边界的简单算法和步骤。

文档范围识别|后处理算法

解决方案详情(深度挖掘 TL；博士)

数据准备

致力于开发一个端到端的文档分类管道。第一步，也可以说是最重要的一步是数据准备，因为解决方案和它使用的数据一样好。我们用于实验的数据是来自抵押贷款领域的文档。我们采用的策略可以以类似的方式应用于任何形式的文档数据集。以下是执行的步骤。

定义:文档样本 *是一个特定文档的实例。通常它是一个(****pdf)***文件，只包含该文档的页面。

第一步

• 第一步是决定，包中的哪些文档要被识别和分类？。理想情况下，应该选择包中存在的所有文档。一旦决定了文档类，我们就进入提取部分。在我们的例子中，我们决定分类(44)文档类。

第二步

• 为了获得数据集，我们收集了数百个包的 pdf，并从这些包中手动提取所选文档。一旦文档在包中被识别，该文档的页面被分离并以 pdf 文件的形式连接在一起。例如，如果我们在包的第 4 页到第 10 页发现了“ Doc A ”。我们将提取 6 页(第 4-10 页)并将其合并成一个 6 页的 pdf。这个 6 页的 pdf 构成了一个文档样本。为特定文档类别提取的所有样本都放在单独的文件夹中。下图显示了文件夹结构。我们为每个文档类收集了 300 多个文档样本。每个文档类都有一个惟一的标识符，我们称之为" DocumentIdentifierID "

第三步

• 下一步是应用 OCR 和从文档样本中的所有页面提取文本。OCR 遍历所有文件夹并生成 excel 文件，其中包含摘录文本和一些元数据。下面显示了 excel 文件的格式，每行代表一页

带有示例行的数据集表。

贷款号，文件名: 这些都是唯一的样本(pdf)标识符。表格中有两个(绿色、黄色)样本。

文档标识符 ID，文档名: 代表这些样本所属的文档类。

页数: 一个特定样本中的总页数。(两个样本都有 2 页)

页码: 是样本内每一页的有序页码。

***IsLastPage:***如果为 1，则表示该页面是该特定样本的最后一页。

页面文本: 是从特定页面的 OCR 返回的文本。

数据转换

一旦数据以上述格式生成，下一步就是转换它。在转换阶段，数据被转换/处理成对训练机器学习模型至关重要的格式。以下是应用于数据集的转换。

步骤 1 | 生成 ML 类

• 转换的第一步是生成第一页、最后一页和其他页面类。为此，使用了页码和页面列值。下面显示了所用逻辑的条件表示。

• 此外，下表代表各列。注意黄色栏，其中 6853 表示第一个页面类，6853-最后一个表示最后一个页面类，而中间页面被视为其他类

步骤 2 | 数据分割用于训练和测试管道

• 一旦步骤 1 完成，从那时起我们只需要两列“页面文本和“ ML 类”来创建培训管道。其他列用于测试评估。
• 下一步是拆分用于训练和测试管道的数据，数据的拆分方式是 80% 用于训练， 20% 用于测试。数据也是随机打乱的，但每一类都是分层的。更多信息请点击链接。

第三步| 数据清理和转换

• 包含每个页面的 OCR 文本的“页面文本”列被清理，该过程应用于训练和测试。以下是执行的过程。

1. 大小写修正:所有文字转换成大写或小写。
2. 非字母数字字符的正则表达式:删除所有非字母数字的字符。
3. 单词标记化:所有单词都被标记化，这意味着一个页面文本字符串成为单词列表
4. 停用词移除:停用词是在英语中过于常见的词，可能对单个文档的分类没有帮助。例如像“这个”、“是”、“一个”这样的词。这些词也可以是特定领域的。它可以用来删除许多不同文档中常见的冗余单词。即就金融或抵押而言,“价格”一词可出现在许多文件中。

下表显示了转换前后的情况

培训渠道

在前面的**机器学习引擎部分，**我们抽象地讨论了机器学习引擎的内部工作原理。两个主要组成部分是。

1. **文本矢量器:**在我们的例子中，我们使用了 Doc2Vec
2. **分类器模型:**使用逻辑回归器进行分类。

文本矢量器(Doc2Vec)

自从自然语言处理 (NLP)开始以来，就有了将文本转换成机器可以理解的东西的需求。这意味着，将文本信息转换成有意义的表示，通常称为数字向量(或数组)。研究界一直在开发不同的方法来完成这项任务。在我们的研发中，我们尝试了不同的技术，发现 Doc2Vec 是所有技术中最好的。

Doc2Vec 基于 Word2Vec 模型。Word2Vec 模型是一个预测向量空间模型。为了理解 Word2Vec，让我们从向量空间模型开始。

***向量空间模型(VSM):***将单词嵌入到连续的向量空间中，其中语义相似的单词被映射到附近的点

VSM 的两种做法:

2. 预测方法: 根据学习到的小而密的嵌入向量(例如 Skip-Gram，CBOW)从其邻居预测一个单词。Word2Vec 和 Doc2Vec 就属于这一类机型

Word2Vec 型号

这是一个计算高效的预测模型，用于从原始文本中学习单词嵌入。 Word2Vec 可使用以下两种模型创建:

1. Skip-Gram :围绕当前单词(目标单词)创建一个滑动窗口。然后使用当前单词来预测所有周围的单词(上下文单词)。(例如从“垫子”预测“猫坐在”)
2. 连续词袋 ( CBOW ):在当前词(目标词)周围创建一个滑动窗口。然后从周围的单词(上下文单词)中预测当前单词。(如从“猫坐在”上预测“垫子”)

更多详情，请阅读这篇文章。它详细解释了它的不同方面。

Doc2Vec 型号

**这种文本矢量化技术在科研论文 句子和文档的分布式表示 **中有所介绍。此外，进一步的技术细节可在这里找到。

定义||it是一种从变长文本块中学习 定长特征向量表示 的 无监督算法 。然后，这些向量可以在任何机器学习分类器中使用，以预测类别标签。**

它类似于 Word2Vec 模型，只是它使用每个文本文件中的所有单词在一个矩阵中创建一个唯一的列(称为段落矩阵*)。然后，将训练单层 NN，如在 Skip-Gram 模型中看到的，其中输入数据都是当前单词的周围单词以及当前段落列，以预测当前单词。其余与 Skip-Gram 或 CBOW 模型相同。***

Doc2Vec |分布式单词包|来源:句子和文档的分布式表示

Doc2Vec 模型的优点:

• 在情感分析任务上，Doc2Vec 取得了新的最先进的结果，优于复杂的方法，在错误率方面产生了超过 16% 的相对改善。
• 在文本分类任务上，Doc2Vec 令人信服地击败了词袋模型，给出了大约 30% 的相对提升。

分类器模型(逻辑回归)

一旦文本被转换成矢量格式。机器学习分类器已经准备好学习不同文档类型的向量中存在的模式，并识别正确的区别。因为有许多分类技术可以在这里使用，我们尝试了最好的分类技术并评估了它们的结果。即随机森林、SVM、多层感知器和逻辑回归器。为获得最佳结果，每个分类器尝试了许多不同的参数。逻辑回归器被发现是所有这些模型中最好的。

培训程序

• 一旦数据被转换。首先，我们在训练分割上训练 Doc2Vec 模型(如数据转换一节中所讨论的)。-
• 训练完 Doc2Vec 模型后。训练数据再次通过它，但是这一次不训练模型，而是我们推断训练样本的向量。最后一步是将这些向量和实际的 ML 类标签传递给分类模型(逻辑回归)。
• 一旦根据训练数据对模型进行了训练，这两个模型都被保存到磁盘上，以便可以将它们加载到内存中，用于测试和最终的生产部署。下图显示了该协作方案的基本流程。

测试和评估管道

一旦训练了管道(包括 Doc2Vec 模型和分类器)，下面的流程图显示了如何使用它来预测测试数据分割的文档类。****

转换后的测试数据通过经过训练的 Doc2Vec 模型，在这里提取并推断出测试数据中所有页面的矢量表示。然后通过分类器对这些向量进行分类，该分类器返回所有 ML 类别的预测类别和置信度得分。

对于机器学习引擎的详细评估，我们根据结果生成一个 excel 文件。下表显示了测试阶段生成的列和信息。

测试阶段生成的评估 excel 文件。

页面文本、文件名、页码: 这些 都是我们在数据准备阶段就有的相同的列，这些只是从源数据集中照原样取来的。

***ground，pred 😗** ground 显示该页面的实际 ML 类，而 pred 显示 ML 引擎预测的 ML 类。

已训练类列 :此部分中的列表示模型被训练的 ML 类以及这些类的置信度得分。

***MaxProb，Range 😗** MaxProb 显示“已训练的类”部分中任何列达到的最大置信度得分。参见红色文本，范围显示 MaxProb 落入的范围。

目前有三个等级的结果评估。

1. 累积误差评价指标
2. 混淆矩阵
3. 班级水平置信度分数分析

累积误差评估度量

该评估计算两个指标，准确性和F1-分数*。更多细节请看这个博客。这些让我们对管道的优点有了一个抽象的认识。分数可以在(1-100)之间。其中较高的数字表示管道在文档分类方面的好坏。在我们的实验中，我们得到了下面的准确度和 f1 值。***

混淆矩阵

混淆矩阵是一个表格，通常用于描述一个分类模型(或“分类器”)对一组真实值已知的测试数据的性能。

本质上，它更容易理解:

• 哪些班级表现不好？
• 个别班级的准确率分数是多少？
• 哪些阶层互相混淆？

下图代表了我们测试后生成的混淆矩阵。这是一个嵌入链接，所以点击查看混淆矩阵。

混淆矩阵图

*****X 轴(真实标签)**和 *Y 轴(预测标签)上的值代表我们训练的文档类别。单元格内的数字显示属于左边和底部的类的测试数据集的百分比。

****对角线上的值代表预测类别正确的数据百分比。百分比越高越好。即，如果 0.99，则意味着该特定类别的 99%的测试数据被正确预测。所有其他单元格显示错误的预测，百分比显示某个类被另一个类混淆的程度。

可以看出，该模型能够以超过 90% 的准确度正确地分类大多数 ML 类别。

类别级置信度得分分析

虽然混淆矩阵给出了关于类混淆的细节，但是它不代表预测的置信度分数。也就是说

• “在对一个文档类进行预测时，模型的可信度如何？”

需要什么？

在理想情况下，模型在预测正确的 ML 类时应该具有高置信度，而在预测错误的 ML 类时应该具有低置信度。但是这不是严格的行为，并且取决于许多因素，即特定类的性能、文档类之间的实际领域相似性等。为了评估这种行为是否存在以及置信度得分是否可以作为真实预测的有用指标，我们设计了一种额外的评估方法。

接近

因为任务是减少人工工作，所以决定只选择具有高置信度的预测。这样错误的预测就不会发生(因为那些人不会有很高的信心)。其余的文档和页面将由 BPO 手动验证。

阈值

在该步骤中，计算类别的置信度得分并定义阈值，阈值是一个百分比，即 80%，75% ，其中基于以下条件确定。

• 什么是置信分值，其中，错误的预测是无关紧要的数字，而正确的预测是较高的数字。换句话说，这是关于 找到甜蜜点。

下图显示了真阳性(蓝线)和假阳性(红线)。

X 轴显示了 ML 类， Y 轴显示了特定类的测试数据的百分比，其被真阳性或假阳性所覆盖。

***例如:在 ML 类 **1330 的情况下，**真实预测几乎覆盖了该类的整个测试数据集的 70%。这意味着 ML 引擎能够正确预测 70% 的数据，置信度得分大于 *90%。此外，假阳性仅占测试数据集的 1%，这意味着只有 1% 的测试数据被预测为错误，置信度高于 90%。