原文：TowardsDataScience Blog

协议：CC BY-NC-SA 4.0

随机森林特征选择

原文：https://towardsdatascience.com/feature-selection-with-random-forest-3e1979b3a2dc?source=collection_archive---------27-----------------------

让我们看看如何使用随机森林进行特征选择

史蒂文·卡梅纳在 Unsplash 上拍摄的照片

特征选择一直是机器学习中的一大难题。根据我的经验，我可以说这是数据科学项目中最重要的一部分，因为它帮助我们降低数据集的维度，去除无用的变量。幸运的是，有一些模型可以帮助我们计算特性的重要性，这有助于我们忽略不太有用的特性。随机森林就是这样一个模型。

什么是随机森林？

随机森林是一个监督模型，实现了决策树和 bagging 方法。其思想是根据一个称为“引导”的过程对训练数据集进行重新采样。每个样本都包含原始列的一个随机子集，用于拟合决策树。模型的数量和列的数量是要优化的超参数。

最后，将树的预测混合在一起，计算平均值(用于回归)或使用软投票(用于分类)。

bagging 的思想是，通过平均单个决策树的输出，根据偏差-方差权衡，标准误差减小，模型的方差也减小。这就是为什么兰登森林在最近几年变得非常有名。

随机森林如何计算特征重要性？

随机森林的每棵树可以根据其增加叶子纯度的能力来计算特征的重要性。这是一个关于分类和回归树(CART)如何工作的话题。叶子纯度的增量越高，该特征的重要性越高。对每棵树都这样做，然后在所有树中平均，最后归一化为 1。因此，由随机森林计算的重要性分数之和是 1。

使用递归特征消除的特征选择

一旦我们知道了每个特征的重要性，我们就使用一个叫做递归特征消除的过程来执行特征选择。在本文中，我将讨论利用 k-fold 交叉验证的版本。

想法是拟合模型，然后移除不太相关的特征，并计算 CV 中某些性能指标的平均值。然后，我们删除倒数第二个重要特征，再次拟合模型，并计算平均性能。我们一直这样做，直到没有特征剩下。最大化 CV 性能的特性集是我们必须使用的特性集。请注意，整个过程需要对超参数使用相同的值。

Python 中使用随机森林的特征选择

既然理论已经很清楚了，那我们就用 sklearn 在 Python 中应用一下吧。对于本例，我将使用波士顿数据集，这是一个回归数据集。

让我们首先导入我们需要的所有对象，即我们的数据集、随机森林回归器和将使用 CV 执行 RFE 的对象。最后，matplotlib 用于可视化我们的结果。

import numpy as np from sklearn.datasets 
import load_boston from sklearn.ensemble 
import RandomForestRegressor from sklearn.model_selection 
import train_test_split from sklearn.feature_selection 
import RFECV import matplotlib.pyplot as plt

首先，让我们加载数据集。

X,y = load_boston(return_X_y=True) 
features = load_boston()['feature_names']

现在我们可以把它分成训练和测试。

X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.33, random_state=42)

现在我们可以拟合我们的随机森林回归量。在实际项目中，我们必须优化超参数的值。对于这个例子，我将使用默认值。我将只设置随机状态，以使结果可重复。

rf = RandomForestRegressor(random_state=0) 
rf.fit(X_train,y_train)

拟合回归变量后，特征的重要性存储在估计器实例的 feature_importances_ 属性中。

例如，让我们画一个条形图，按照从最重要到不太重要的顺序排列特性。我们必须创建一个元组列表。元组的第一个元素是特征名，第二个元素是重要性。然后，我们根据重要性值对列表进行排序，并绘制一个水平条形图。

f_i = list(zip(features,rf.feature_importances_)) 
f_i.sort(key = lambda x : x[1]) plt.barh([x[0] for x in f_i],[x[1] for x in f_i]) 
plt.show()

作者图片

正如我们所看到的，LSTAT 特性是最重要的，其次是 RM、DIS 和其他特性。水平条形图是表示特性重要性的非常有用的图表。

现在，让我们根据交叉验证的 RFE，使用特征重要性来选择最佳特征集。对于本例，我们试图优化的指标是负均方误差。我们将使用 5 个折叠进行交叉验证，这是一个非常好的值。

rfe = RFECV(rf,cv=5,scoring="neg_mean_squared_error") 
rfe.fit(X_train,y_train)

整套功能包括:

所选功能包括:

selected_features = np.array(features)[rfe.get_support()]

正如我们所看到的，RFE 忽略了不太相关的特性(CHAS)。

结论

随机森林对于回归和分类都是一个非常强大的模型。它还可以给出它自己对特征重要性的解释，这可以被绘制并用于根据例如递归特征消除过程来选择信息最丰富的特征集。正确使用，特性重要性可以给我们很好的和容易理解的可交付物(条形图)和有效的优化(特性选择)。这就是为什么我认为特征重要性是每个机器学习项目的必要组成部分。

www.yourdatateacher.com上 教授机器学习和数据科学的数据科学家吉安卢卡·马拉托。

原载于 2021 年 10 月 11 日 https://www.yourdatateacher.comhttps://www.yourdatateacher.com/2021/10/11/feature-selection-with-random-forest/。

特征存储:机器学习的数据平台

原文：https://towardsdatascience.com/feature-store-data-platform-for-machine-learning-455122c48229?source=collection_archive---------10-----------------------

最先进的开源和自主开发的功能商店，可大规模生成、管理和提供功能

图片提供: unsplash 上的 dlanor_s

特征数据(或简称为特征)对于机器学习 (ML)模型做出的准确预测至关重要。特征存储最近成为 ML 堆栈的重要组成部分，它通常支持以下任务作为 ML 工作流的一部分:

1. 自动化特征计算，例如回填、UDF
2. 管理功能元数据，例如沿袭、版本
3. 跨不同团队共享和重用功能
4. 离线、实时或按需提供或提取功能
5. 监控功能从生成到服务的整个生命周期

对于“最先进的”特征商店的调查，https://www.featurestore.org/https://www.featurestore.org/整合并比较了主要的类似“特征商店”的系统。如上所述，许多科技公司由于其独特的数据架构和业务需求，已经在内部建立了自己的功能商店。例如，优步的业务是为用户提供低延迟服务。对于 Airbnb 来说，个性化推荐是让旅行者在他们的平台上预订住宿的关键。

在这样的组织中，跨不同业务单位的多个 ML 数据团队可能独立地操作相同的 ML 工作流，因此有必要整合工作并提供一个功能存储来标准化和管理功能的整个生命周期并为所有团队服务。

将上述想法反馈到 ML 社区，为一般 ML 用例建立一个标准的、开箱即用的特性库听起来很有希望，可能从小规模的简单用例开始。

**下面，我将简要介绍两家科技公司的主要特色商店:优步和 Airbnb ，以及一家开源特色商店: 盛宴 **。最后分享一下我个人对通用 ML 平台的想法。

Airbnb: Zipline

Airbnb 至少在 4 年前建立了他们的特色商店，名为 Ziplin。最近的一次演讲来自于 Spark AI 2020 ，以下是我的心得:

(Airbnb 的许多功能都是从“滑动窗口”操作中产生的。请参阅以下示例功能(过去 30 天内对一家餐厅的平均评分)。

rating_features = GroupBy(
    sources=EventSource(
        event_stream="restaurant_check_in_stream",
        event_log_table="core_data.restaurant_check_ins",
        query=Query(
            select=Select(
                restaurant="id_restaurant",
                rating="CAST(rating as Double) - 2.5",
            )
        )
    )
    keys=["restaurant"],
    aggregations=Aggregations(
        avg_rating=Aggregation(
            documentation="Avg rating for this restaurant",
            operation=AVG,
            inputColumn="rating",
            **windows=[Window(length=30, timeUnit=TimeUnit.DAYS)]**
        )
    )
)

(2)为了有效地支持滑动窗口操作，他们提出了一个算子的性质，称为“可逆性”。

Reversible: (a + b) - a = b

有些运算符具有上述性质，例如，和，平均，【AVG】，，计数。当在滑动窗口中计算时，他们不需要为整个窗口进行计算，相反，由于“可逆性”属性，他们只是丢弃窗口之外的内容，并向窗口添加新的内容。

滑动窗口示例

有些运算符不具有“可逆性”属性，如 Min ， Max 。当在滑动窗口中计算这种算子时，在滑动窗口内的数据上建立一个二叉树，这样当旧数据滑出和新数据进入时，二叉树被调整，并且它的根总是 Min 、 Max 等的答案。

图片来源:https://www.youtube.com/watch?v=LjcKCm0G_OY的滑索演示

例如，4 曾经是窗口中的最大值。当 4 滑出时，将从 1 中选择根，3，2 和 3 将是新的根。

通过利用树结构，时间复杂度从 O(N)降低到 O(NlogN ),空间复杂度从 2N 降低到 N

优步:米开朗基罗调色板

早期，优步开始建立他们的特色商店，叫做米开朗基罗调色板。最近的演讲是在这里，我的收获是:

(1) 80%的 ML 工作负荷是特征工程，例如，发现好的特征、大规模地提供特征、特征对等性(训练/服务偏斜)、实时特征、特征可观察性。

(2)以下抽象使得特征有组织、可重用、高效:

• 实体:优步的一个业务单位，如顺风车、司机、优步 Eats
• 特性组:一组常用的特性
• 特征 : ML 就绪数据点
• 连接键:用于连接用户标识、餐厅标识等功能的键。这允许在现有特征的基础上创建新特征。

(3)三大类特征

• 批量特征(通过火花):例如 sum_orders_1week，avg_order_size_30day
• 近实时特征(通过卡夫卡、弗林克):例如眼球 _ 印象 _ 5 _ 分钟
• RPC 特征(来自外部 API、第三方的信号):例如 geohash

(4)特征质量监控:特征管道断裂、特征数据缺失、漂移和不一致是常见的。已经实施了以下方法来解决这些问题:

图片来源:https://vimeo.com/477753622的优步特色工程展示

盛宴:开源特性商店

GoJek/Google 在 2019 年初发布了盛宴，它是围绕 Google 云服务而构建的:大查询(离线)和大表(在线)和 Redis (低延迟)，使用 Beam 进行特征工程。

图片来源:盛宴建筑https://feast.dev/post/a-state-of-feast/

从目前的 Feast 架构来看，它的重点是特性存储、服务和注册。这里是一篇很棒的文章，介绍什么是盛宴，当前的挑战是什么，下一个是什么。

我的想法

对于通用 ML 数据平台，以下是我的 3 点个人想法:

(1)最有价值和最具挑战性的问题之一是从原始数据到高质量、ML 友好特性的数据转换。解决这个问题高度依赖于 ML 工程师的领域知识，并由业务用例驱动。换句话说，一个独立的 ML 数据平台如果不服务于特定的业务场景、用例，不与优秀的 ML 工程师团队无缝协作，那么它就是无效的。

(2)在技术方面，ML 数据平台需要支持下面的各种主流基础设施，无论它们是开源的还是商业的，是在内部运行还是在云上运行。关于平台 API，它必须支持流行的编程语言，比如 Python。出于安全考虑，it 必须提供企业级授权和身份认证，以便为北美和欧洲等监管严格的地区的客户提供服务。对于数据隐私，it 部门必须完全遵守当地政策，绝不妥协。

(3)在规模方面，随着 ML 数据平台外部产品用户和内部用户的快速增长，在业务用例和技术栈上应该高度规模化。仅举几个例子，

• 提供一个通用和灵活的接口，让 ML 工程师能够容易和准确地描述任何类型的特征
• 每天优化数千个新功能的上线
• 跨不同的领域有效且高效地应用不断变化的隐私策略
• 管理异构基础架构，将新出现的基础架构添加到设备群中，并顺利淘汰旧的基础架构。

功能商店需要一个 HTAP 数据库

原文：https://towardsdatascience.com/feature-stores-need-an-htap-database-f4fae96c9e0e?source=collection_archive---------31-----------------------

图片经由 Cybrain /Adobe Stock 在 Zer0 到 5ive 的许可下

特征存储是用于训练和服务机器学习模型的组织和管理的特征的集合。使它们保持最新、服务于特征向量以及创建训练数据集需要结合事务性(OLTP)和分析性(OLAP)数据库处理。这种混合工作负载数据库被称为混合事务分析处理的 HTAP。

最有用的要素存储包含数据管道，这些管道通过与源数据节奏相匹配的批处理或实时处理来持续保持其要素最新。因为这些特征总是最新的，所以它们提供了用于推理的特征向量的理想来源。特征向量甚至可以从特征库中实时传递。完整的特征存储保存特征值的历史，并使用它来创建时间准确的训练数据集。

生产中的特征存储保持特征值最新，使 ML 模型能够快速进入生产。通常，功能是基于共同的上下文(即客户、产品、位置)和数据节奏进行分组的。为每个组提供适当节奏的数据管道使功能保持最新。有了现成的精选特征，许多推理引擎无需任何额外的努力就可以访问它们。

功能存储数据流

在上图中，我们用橙色表示低延迟/高并发处理，这通常是 OLTP 数据库的特征。我们用蓝色表示大规模并行处理数据库引擎(通常称为 OLAP)中的高容量数据处理。让我们来看看为什么我们需要两者来最大限度地运行一个特性库。

批量数据流水线定期发生(通常一天或一周一次)。它们通过提取、加载、清理、聚合和以其他方式将数据管理成可用的特征来处理大量的源数据。建立 RFM 客户档案是一个常见的例子。客户活动用于计算多个类别和多个移动时间窗口(可能包括过去 24 小时、上周、上月和去年)的近期、频率和货币指标。为大量客户和交易转换这些数据通常需要并行处理，随着业务增长导致数据量增加，这种并行处理可以扩展。

训练数据集是通过扫描和连接具有感兴趣的特征和事件历史的大型数据集而创建的。这些联接跨越多个不同的特征组，并将每个训练案例与对应于每个事件时间的特征值准确地绑定在一起。这就产生了最适合 MPP/OLAP 处理的复杂连接条件。

另一方面，需要实时数据管道来驱动 ML 模型，用于实时地直接对最终用户交互做出反应。一个例子是产品推荐引擎或下一个最佳行动模型，其中用户活动直接影响推理使用的特征值。在这种情况下，特征的源需要通过流或直接数据库插入或更新操作实时连接到特征存储。在处理这些消息/事务时，它们会及时生成新的特征值，以便后续的推理读取它们。这种操作通常一次只影响少量的行，但有可能产生非常高的并发性。

在许多情况下，用户交互可能涉及多个功能集。重要的是，当为了推断而读取时，所有的特征值都与用户最近的动作一致。这推动了对数据库引擎中保证这种一致性的 ACID 属性的需求。这些高并发、低延迟的工作负载最好由 OLTP 数据库引擎来处理，这些引擎可以随着用户和业务活动的增长而扩展。

很少有数据库同时支持这两种工作负载并提供水平可伸缩性。随着特征存储成为具有实时解决方案的机器学习平台中的标准实现模式，将需要这种规模的 HTAP 数据库。所以现在，商用拼接机就是这样一个数据库引擎，提供符合 ACID 的 OLTP 和 OLAP 引擎，它们可以独立伸缩。 Splice Machine 的特征库及其数据库内模型部署提供了一个完美的组合，可直接在特征库上提供实时和批量推理。

特色商店——什么、为什么、在哪里以及如何？

原文：https://towardsdatascience.com/feature-stores-what-why-where-and-how-17cd960c394c?source=collection_archive---------18-----------------------

“功能商店”这个术语最近已经流传很久了。这篇文章试图阐明这个话题。

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

这篇文章正被移到我的 子栈发布 。这里 可以免费阅读文章 。这篇文章将于 2022 年 7 月 18 日被删除。

但是在我们去特色商店之前，

什么是特性？

特征是作为模型输入的独立属性。考虑模型

y = f(x)

这里 x 是你的输入向量， y 是你的输出向量， f 是你的模型。 x 中的每一列都是您的型号的特征。机器学习模型从特征中学习，并在训练期间更新其参数，以便能够对输出做出良好的预测。

现在，

什么是功能商店？

我是在参加 apply() 的时候被介绍到特色店的。简而言之，要素存储是存储要素的数据存储。听起来很直接，对吗？那么，为什么不直接创建一个 SQL 或 BigTable 数据库并完成它呢？是什么让特色店如此特别？嗯，实现是它的特别之处。因此，让我们看看为什么我们需要功能商店来理解这一点。

为什么选择特色商店？

为了理解我们为什么需要特征存储，我们需要知道机器学习生命周期的不同阶段是什么。下面列出了它们。

本文其余部分已移至出版物 机器学习—科学、工程和 Ops 。这里 可以免费阅读整篇文章 。

特性 101:特性集分析简介

原文：https://towardsdatascience.com/features-101-an-introduction-to-analyzing-feature-sets-92e19d09ebd2?source=collection_archive---------22-----------------------

关于如何更好地使用和理解功能的小指南

(src =https://pix abay . com/插图/统计-图形-图表-数据-3411473/ )

介绍

在极其复杂的数据科学世界中，有许多情况需要对数据进行分析。对任何数据科学家来说，分析数据都是绝对必要的技能。数据也需要以多种方式进行分析，而不仅仅是分析师可能采用的传统方式。这是熟悉数据如何工作，更重要的是统计和人工智能如何工作的重要垫脚石。

分析特征，尤其是第一次，可能是一项相当艰巨的任务。不要担心，因为最终这将成为容易的部分——它类似于一个新木匠。他可能会用他的黄铜锤敲几个钉子，毁掉他的第一把锤子，但他会有另一次机会，下次会用正确的锤子。我的观点是，即使这可能是压倒性的，我鼓励任何有抱负的读者坚持下去，因为它会变得更容易！事不宜迟，让我们深入了解一些特性。此外，您可以在这个笔记本中查看本文的代码:

https://github.com/emmettgb/Emmetts-DS-NoteBooks/blob/master/Julia/Analyzing Features.ipynb

特征类型

对于这个项目，我将使用 VegaDatasets.jl 中的“cars”数据集。

using VegaDatasets
data = dataset("cars")

现在，我们可以使用 DataFrames.jl 模块将该数据集包装成数据帧类型:

using DataFrames
df = DataFrame(data)show(df)

(图片由作者提供)

在我们开始研究这些特性之前，让我们先考虑一下我们拥有的不同类型的特性。意识到我们实际上正在使用什么类型的功能，以及关于这些功能的细节将有助于我们的机器学习。这是因为特性对模型有很大的影响，并且预处理可能会在模型使用之前发生。

绝对的

第一类特征是分类特征。分类要素是描述数据的某种分组方面的要素。例如，假设我们去一家经销店，我们要求一辆轿车，轿车是汽车的一种分类。这是汽车分类维度的一个例子。分类特征可以出现在几乎任何数据类型中，并且有一些方法可以尝试确定一个特征是否实际上是分类的，这些方法中的一种，可能是最有价值的，我们将很快使用。

二项式(布尔型，真或假)

二项式，二进制，布尔型，不管你想叫它们什么，它们通常用真和假，或者 1 和 0 来表示。

连续的

连续特征是具有某种定量值的特征。这些只能是某种抽象的数字数据类型，所以如果它不是某种数字，这是一个非常简单的方法来排除值不能是连续的。

其他的

每当特征不符合这些规范中的任何一个时，它们通常是标签。标签对于分析、日期确定和诸如此类的事情可能是有用的——但通常只能让人们更好地理解项目中可能实际使用的功能。然而，另一件要注意的事情是，我们有时可以将其中一些特性处理成其他类型的特性。例如，如果我们有一个日期，我们可以把它变成一年，并把这一年作为一个特征。这在技术上也被认为是特征工程，所以通过这样做，你听起来会比实际上更酷。

我们的特色

既然我们已经很好地掌握了不同类型的要素及其用于表示的内容，现在我们可以从上面的数据中查看这些要素，并尝试找出哪些要素是哪些要素。第一个特征

是“名字”名字很明显是一个标签，顾名思义(看到我在那里做了什么？)接下来，让我们跳过气缸。这可以作为一种测验来测试您的要素分析技能。那是什么类型的特征？保留这个答案，因为接下来让我们看看每加仑英里数。这是很多数字，它们的值波动很大。如果我们不确定，我们可以将集合类型投射到这个列上，看看与整个数据数组相比，集合中有多少观察值。马力和排量也属于同一范畴，因为它们显然符合我们对连续值的描述。

然而，我们还有一个特征要研究——圆柱体。如果你认为这个特征是连续的，那么对不起，但你实际上是不正确的！尽管是数字，但确实代表了实际的气缸数量，请记住，我们在这里讨论的是汽车。我们正在比较不同的方面，如排量和马力，所以在这种情况下，气缸数可能是三个数字之一，4，6 和 8。让我们将 set 类型转换为这个特性，看看会发生什么:

Set(df[!, :Cylinders])

(图片由作者提供)

我感到惊讶的是，他们设法在如此多种多样的发动机中进行了少得可怜的 4000 次观察。这实际上并不是最优的。如果我们用较少的专业知识来处理这个问题，我们可能会把它误认为是一个连续的特征。这是有问题的，因为我们可能会不小心降低模型的准确性。更糟糕的是，如果这是我们的目标，我们可能对这个应用程序使用了错误类型的模型。这就是为什么批判性地思考这些特性并通过屏幕上的数字尽可能地理解它们是如此重要。

性能

假设我们现在可以确定我们可能希望在我们的功能中搜索什么，知道如何处理它们，我们现在可以了解每种类型的功能的属性。当涉及到分类特征时，通常您会希望查看

• 设置
• max-key(出现次数最多的类别)
• 数据类型

说到连续功能，您会想看看

• 意思是
• 差异
• 标准偏差

当然，人们可能还想看到这两者的其他方面，但这些只是一些建议。这些当然是学习更多特定特性的良好开端。

结论

恭喜你！你正式成为功能专家了！特征是数据科学的一个非常重要的方面，这可能有点令人生畏，但是采用这样一种简单、有条不紊且经过深思熟虑的方法可以使这类事情变得容易得多。我希望这篇文章对您的数据科学之旅有所帮助！非常感谢您的阅读！

用于预处理文本数据的 FeatureUnion、ColumnTransformer 和 Pipeline

原文：https://towardsdatascience.com/featureunion-columntransformer-pipeline-for-preprocessing-text-data-9dcb233dbcb6?source=collection_archive---------24-----------------------

了解如何在 NLP 项目中应用这些工具

假设您已经使用矢量器(例如TfidfVectorizer、CountVectorizer)将文本数据预处理成矩阵，作为模型的准备。您可能会想到，导出其他特征(比如文档的长度)也可能对您的模型有用。虽然有许多可能的方法来组合这些预处理步骤，但是利用FeatureUnion、ColumnTransformer和/或Pipeline可能是完成该任务的最佳方法之一。在本帖中，我们将通过几个例子来了解如何应用这些令人敬畏的工具(主要关注FeatureUnion)。

杰瑞米·托马斯在 Unsplash 上的照片

虽然没有必要，但在阅读本文之前，对以下主题有所了解可能会有所帮助。
◻️TfidfVectorizert16】◻️Pipeline、ColumnTransformer和FeatureUnion

在这篇文章中，我们不会详细解释这些概念，因为它们会在下面两篇文章中解释。

🔗 TF-IDF 解说🔗 管道、列变压器和特性联合解释

相反，我们将直接进入他们的文本预处理应用程序！

0.设置和数据🔧

让我们从导入必要的库开始，并在餐馆评论上创建一个最小的可用玩具数据集:

保持较小的数据集将有助于更好地理解该过程，并更专注于实际 sklearn 工具的实际应用。

1.并联变压器

1.1.不带Pipeline

假设我们预处理的目标是对文本进行矢量化，并从文本中提取两个特征。更准确地说，我们希望做到以下几点:

◻️ ️Vectorise *“文档”*列带TfidfVectorizer ◻️️添加显示文本长度的功能带CharacterCounter
◻️️添加显示文本中字母数字标记数量的功能带TokenCounter

CharacterCounter和TokenCounter是我们将要创建的定制变形金刚。我们不能在单个Pipeline中顺序地链接这三个，因为TfidfVectorizer只将文本列作为输入，并输出一个没有原始文本列的稀疏矩阵。FeatureUnion 是这种情况下的完美工具。由于FeatureUnion 的行为就好像它创建了输入数据的副本，我们可以用并行转换器设计这样的预处理流程:

作者图片

每个流都接受相同的输入:X[‘document’]，输出被连接起来。为了简洁明了，我们从这里开始将这些流称为流 A 、流 B 和流 C 。现在，让我们将流程翻译成代码:

Tada！我们已经使用FeatureUnion对数据进行了预处理。

1.2.用Pipeline

让我们用Pipeline来扩展我们之前的例子。这一次，我们将使用缩放器扩展流 B 和流 C 。换句话说，下面总结了我们的目标:

◻️️用TfidfVectorizer 向量化*‘文档’*列◻️️用CharacterCounter添加显示文本长度的特征，然后用MinMaxScaler缩放
◻️️用TokenCounter添加显示文本中字母数字标记数量的特征，然后用MinMaxScaler缩放

使用Pipeline，预处理流程可以总结如下:

作者图片

管道给了我们灵活性，我们可以用更多的转换器来扩展任何流。虽然在本例中，两个流 B & C 使用相同的定标器，但它们不必相同，因为它们彼此独立。所以现在代码变成了:

正如我们所看到的，FeatureUnion帮助我们保持预处理步骤有组织，并编写干净的代码。

2.顺序变压器

现在让我们看看从 1.1 节获得相同输出的另一种方法。我们可以不添加并联变压器，而是将流 B 和流 C 合并，并在Pipeline中按如下顺序放置:

作者图片

为了让这个流程工作，我们需要调整我们的定制转换器，为它们创建一个名为counter_pipe的管道，并更新preprocessor:

我们可以用不同的方式设计预处理流程，同时仍然得到相同的结果。在这个特殊的例子中，我更喜欢 1.1 节中的方法。与这种替代方法相比。一般来说，这取决于用例以及个人偏好。

📍**练习:**尝试扩展上面的代码，从第 1.2 节获得相同的输出。

3.带列变压器

最后，这个例子是我最喜欢的，也是本帖中所有例子中最令人兴奋的一个。我们将利用所有三种工具:FeatureUnion、ColumnTransformer和Pipeline，其中每一种工具都发挥着独特的作用，并相互补充。

实际上，数据包含文本和非文本列的情况并不少见。例如，文字评论也可能伴随着星级评论。在这种情况下，我们将研究如何对所有信息进行预处理，这样我们就不会丢弃潜在的有价值的信息。让我们用一些数字特征来扩展数据集。

现在我们预处理的目标是:

◻️️用TfidfVectorizer 向量化*‘文档’列◻️️用CharacterCounter
添加显示文本长度的功能◻️️用TokenCounter
添加显示文本中字母数字标记数量的功能◻️️用‘has _ tipped’和‘rating’*列使用SimpleImputer中值，然后用MinMaxScaler缩放它们

现在预处理流程可以如下所示:

作者图片

使用ColumnTransformer，我们将数据集分成两个流。左侧流有一个带两个变压器的Pipeline。右边的流与我们在第 2 节中看到的FeatureUnion相同。使用我们在上一节中定义的转换器，我们可以这样定义新的流:

瞧啊。希望这展示了一个FeatureUnion, ColumnTransformer，Pipeline如何和谐工作的实际用例。

4.结束语

熟练运用FeatureUnion,``ColumnTransformer``Pipeline是数据科学家的一项有用技能。有了这些工具，预处理过程可以保持整洁有序。例如，对所有例子来说，预处理看不见的数据都是轻而易举的事情，可以用一行代码完成:preprocessor.transform(new_data)。下面显示了第 3 部分的示例:

这看起来不是很优雅很专业吗？

我希望您喜欢学习如何以不同的方式应用这些工具！希望它对你当前或下一个 NLP 项目有用。

照片由杰佩·霍夫·詹森在 Unsplash 拍摄

您想访问更多这样的内容吗？媒体会员可以无限制地访问媒体上的任何文章。如果您使用 我的推荐链接 ，成为会员，您的一部分会费将直接用于支持我。

感谢您阅读我的文章。这里是我的另一个可能感兴趣的帖子: Pipeline，ColumnTransformer 和 FeatureUnion 解释。
我所有博客的精简列表来自 here:️ 我的数据科学文章目录

再见🏃 💨

使用 Google 的 T5 文本到文本转换器来特征化文本

原文：https://towardsdatascience.com/featurizing-text-with-googles-t5-text-to-text-transformer-a4855f49d8bd?source=collection_archive---------42-----------------------

如何扩展特征工具 原语-函数 从表格文本列自动创建特征。

图片由 谷歌 *提供。*文本到文本框架图。每个任务都使用文本作为模型的输入，模型被训练生成一些目标文本。这允许相同的模型、损失函数和超参数跨越不同的任务集，包括翻译(绿色)、语言可接受性(红色)、句子相似性(黄色)和文档摘要(蓝色)。参见 用统一的文本到文本转换器探索迁移学习的极限

原载于 2021 年 3 月 29 日 https://blog.ccganalytics.com**的 。

在本文中，我们将演示如何使用 Google 的 T5 文本到文本转换器来特征化表格数据中的文本。您可以使用这个库中的 Jupyter 笔记本继续学习。

当试图在机器学习管道中利用真实世界的数据时，经常会遇到书面文本，例如，在预测房地产估值时，有许多数字特征，例如:

• “卧室数量”
• “浴室数量”
• “平方英尺的面积”
• “纬度”
• “经度”
• &等等…

但是也有大量的文字，比如在 Zillow 网站上的房地产列表描述中。这些文本数据可能包含许多有价值的信息，这些信息在其他情况下不会被考虑在内，例如:

• 提及开放式厨房/平面图
• 提到花岗岩柜台
• 提及硬木地板
• 提及不锈钢器具
• 提及最近的装修
• &等等…

然而，令人惊讶的是，许多 AutoML 工具完全忽略了这些信息，因为流行的表格算法(如 XGBoost)不能直接使用书面文本。

这就是功能工具 原始函数 的用武之地。Featuretools 旨在为不同类型的数据(包括文本)自动创建功能，然后这些功能可以被表格形式的机器学习模型使用。

在本文中，我们展示了如何扩展 nlp-primitives 库以用于 Google 最先进的 T5 文本到文本转换器模型，在这样做的过程中，我们创建了最重要的 nlp 原语特性，这反过来又提高了 Alteryx 博客自动特征工程的自然语言处理中展示的准确性。

关于 T5

对于任何不熟悉 T5 的读者来说，T5 模型是在谷歌的论文中提出的，题为用统一的文本到文本转换器探索迁移学习的极限，作者是*科林·拉弗尔、诺姆·沙泽尔、、凯瑟琳·李、·纳朗、迈克尔·马特纳、周燕琪、和彼得·刘。*以下是摘要:

迁移学习已经成为自然语言处理(NLP)中的一种强大技术，在迁移学习中，模型首先在数据丰富的任务上进行预训练，然后在下游任务上进行微调。迁移学习的有效性已经产生了各种各样的途径、方法和实践。在本文中，我们通过引入一个统一的框架，将每一个语言问题转换成文本到文本的格式，来探索自然语言处理中迁移学习技术的前景。我们的系统研究比较了几十个语言理解任务的预训练目标、架构、未标记数据集、迁移方法和其他因素。通过将我们的探索与 scale 和我们新的“庞大干净的爬行语料库”相结合，我们在涵盖摘要、问题回答、文本分类等许多基准上实现了最先进的结果。为了促进 NLP 迁移学习的未来工作，我们发布了我们的数据集、预训练模型和代码。

一个机器学习演示，使用拥抱脸 T5 来表征文本

罗纳德·里根在 1985 年《变形金刚》英国年会上遇见擎天柱。在 NLP 的背景下——Hugging Face Transformers 是一个自然语言处理库，一个 hub 现在对所有 ML 模型开放，支持库有 Flair 、 Asteroid 、 ESPnet 、 Pyannote 等等。

为了扩展用于 T5 的 NLP 原语库，我们将构建两个定制的TransformPrimitive类。出于实验目的，我们测试了两种方法:

• 微调抱紧面 T5-底座
• 一个现成的拥抱脸 T5 模型为情绪分析预先调整

首先，让我们加载基本模型。

from simpletransformers.t5 import T5Modelmodel_args = {
    "max_seq_length": 196,
    "train_batch_size": 8,
    "eval_batch_size": 8,
    "num_train_epochs": 1,
    "evaluate_during_training": True,
    "evaluate_during_training_steps": 15000,
    "evaluate_during_training_verbose": True,
    "use_multiprocessing": False,
    "fp16": False,
    "save_steps": -1,
    "save_eval_checkpoints": False,
    "save_model_every_epoch": False,
    "reprocess_input_data": True,
    "overwrite_output_dir": True,
    "wandb_project": None,
}model = T5Model("t5", "t5-base", args=model_args)

其次，让我们加载预调好的模型。

model_pretuned_sentiment = T5Model('t5',
                                   'mrm8488/t5-base-finetuned-imdb-sentiment',
                                   use_cuda=True)
model_pretuned_sentiment.args

为了微调t5-base模型，我们需要重新组织和格式化用于训练的数据。

图片作者。原始 Kaggle 数据集

从 Kaggle 数据集中，我们将把review_text列映射到一个名为input_text的新列，并且我们将把review_rating列映射到一个名为target_text的新列，这意味着review_rating是我们试图预测的。这些变化符合用于微调 t5 的 Simpletransformers 库接口，其中主要的额外需求是指定一个“前缀”，这意味着有助于多任务训练(注意:在本例中，我们关注的是单个任务，因此前缀是不必要的，但是为了便于使用，我们还是要定义它)。

dft5 = df[['review_text','review_rating']
].rename({
'review_text':'input_text',
'review_rating':'target_text'
},axis=1)dft5['prefix'] = ['t5-encode' for x in range(len(dft5))]dft5['target_text'] = dft5['target_text'].astype(str)dft5

输出。图片作者。

本例中的目标文本是消费者对给定餐馆的评分。我们可以通过以下方式轻松地微调此任务的 T5 模型:

from sklearn.model_selection import train_test_splittrain_df, eval_df = train_test_split(dft5)model.train_model(train_df, eval_data=eval_df)

接下来，我们加载预调好的拥抱脸模型。

from sklearn.model_selection import train_test_splittrain_df, eval_df = train_test_split(dft5)model.train_model(train_df, eval_data=eval_df)

让我们测试这两个模型，以更好地了解它们将预测什么。

test = ['Great drinks and food', list(np.array(model.predict(test)).astype(float))
 'Good food &amp; beer',Generating outputs: 0%| | 0/1 [00:00<?, ?it/s] Generating outputs: 100%|██████████| 1/1 [00:00<00:00, 3.17it/s] Generating outputs: 100%|██████████| 1/1 [00:00<00:00, 3.16it/s] Decoding outputs: 0%| | 0/3 [00:00<?, ?it/s] Decoding outputs: 33%|███▎ | 1/3 [00:00<00:01, 1.14it/s] Decoding outputs: 100%|██████████| 3/3 [00:00<00:00, 3.43it/s] Out[14]: [4.0, 4.0, 4.0] 
 'Pretty good beers']

我们可以看到，微调后的模型输出了一个review_rankings【4.0，4.0，4.0】的列表，这是试图预测我们问题的最终答案。

接下来，我们用预先调好的拥抱脸模型做一个测试预测。

test = ['Great drinks and food', 
     'Good food & beer', 
     'Pretty good beers']list(np.where(np.array(model_pretuned_sentiment.predict(test))=='positive', 1.0, 0.0)) Generating outputs:   0%|          | 0/1 [00:00<?, ?it/s] Generating outputs: 100%|██████████| 1/1 [00:00<00:00,  7.57it/s] Generating outputs: 100%|██████████| 1/1 [00:00<00:00,  7.56it/s]  Decoding outputs:   0%|          | 0/3 [00:00<?, ?it/s] Decoding outputs:  33%|███▎      | 1/3 [00:00<00:01,  1.17it/s] Decoding outputs: 100%|██████████| 3/3 [00:00<00:00,  3.50it/s] Out[15]: [1.0, 1.0, 1.0]

请注意，预调优的模型输出一系列布尔真/假值，这些值指示语句是positive还是negative——我们将这些值转换为浮点值，以便更好地与表格建模集成。在这种情况下，所有值都为真，因此输出变为[1.0，1.0，1.0]。

现在我们已经加载了 T5 的两个版本，我们可以构建TransformPrimitive类，它将集成 NLP 原语和 Featuretools 库。

from featuretools.primitives.base import TransformPrimitive
from featuretools.variable_types import Numeric, Text class T5Encoder(TransformPrimitive):

    name = "t5_encoder"
    input_types = [Text]
    return_type = Numeric
    default_value = 0

    def __init__(self, model=model):
      self.model = model def get_function(self): def t5_encoder(x):
            model.args.use_multiprocessing = True
            return list(np.array(model.predict(x.tolist())).astype(float))
        return t5_encoder

上面的代码创建了一个名为T5Encoder的新类，它将使用经过 微调的 T5 模型，下面的代码创建了一个名为T5SentimentEncoder的新类，它将使用经过 预调的 T5 模型。

class T5SentimentEncoder(TransformPrimitive):

    name = "t5_sentiment_encoder"
    input_types = [Text]
    return_type = Numeric
    default_value = 0

    def __init__(self, model=model_pretuned_sentiment):
      self.model = model def get_function(self): def t5_sentiment_encoder(x):
            model.args.use_multiprocessing = True
            return list(np.where(np.array(model_pretuned_sentiment.predict(x.tolist()))=='positive',1.0,0.0))
        return t5_sentiment_encoder

Featuretools 现在将知道如何使用 T5 来特征化文本列，它甚至会使用 T5 输出来计算聚合，或者对其执行操作，例如从其他特性中减去该值。定义了这些新类后，我们只需将它们与默认类一起以所需的 Featuretools 格式进行汇总，这将使它们可用于自动化特征工程。

trans = [
           T5Encoder,
           T5SentimentEncoder,
           DiversityScore,
           LSA,
           MeanCharactersPerWord,
           PartOfSpeechCount,
           PolarityScore, 
           PunctuationCount,
           StopwordCount,
           TitleWordCount,
           UniversalSentenceEncoder,
           UpperCaseCount
        ]ignore = {'restaurants': ['rating'],
          'reviews': ['review_rating']}drop_contains = ['(reviews.UNIVERSAL']features = ft.dfs(entityset=es,
                  target_entity='reviews',
                  trans_primitives=trans,
                  verbose=True,
                  features_only=True,
                  ignore_variables=ignore,
                  drop_contains=drop_contains,
                  max_depth=4)

正如你在下面的输出中看到的，Featuretools 库非常强大！事实上，除了这里展示的 T5 特性，它还使用指定的所有其他 NLP 原语创建了数百个特性，非常酷！

feature_matrix = ft.calculate_feature_matrix(features=features,
                                             entityset=es,
                                             verbose=True)features

• <feature: t5_encoder=“”></feature:>
• <feature: t5_sentiment_encoder=“”></feature:>
• <feature: restaurants.max=“”></feature:>
• <feature: restaurants.max=“”></feature:>
• <feature: restaurants.mean=“”></feature:>
• <feature: restaurants.mean=“”></feature:>
• <feature: restaurants.min=“”></feature:>
• <feature: restaurants.min=“”></feature:>
• <feature: restaurants.skew=“”></feature:>
• <feature: restaurants.skew=“”></feature:>
• <feature: restaurants.std=“”></feature:>
• <feature: restaurants.std=“”></feature:>
• <feature: restaurants.sum=“”></feature:>
• <feature: restaurants.sum=“”></feature:>

机器学习

现在，我们使用包括新创建的 T5 原语的特征矩阵来创建和测试来自 sklearn 的各种机器学习模型。

提醒一下，我们将比较 T5 增强的准确性和 Alteryx 博客中展示的自动化特征工程的自然语言处理的准确性。

使用逻辑回归:

请注意，上面的 0.64 逻辑回归分数显示了对 Featuretools 原生逻辑回归分数(0.63)的改进。

使用随机森林分类器:

请注意，上面的 T5 增强的 0.65 随机森林分类器分数显示了对 Featuretools 原生随机森林分类器分数(0.64)的改进。

随机森林分类器特征重要性

我们可以使用 sklearn 随机森林分类器特征重要性将改进的分数归因于新的 T5 基元。

随机森林要素重要性。作者图片

从上表中我们可以看出，随机森林模型的最高特征重要性是新创建的特征

T5 _ 情操 _ 编码器(评论 _ 标题)！

随机森林分类器特征重要性，图片由作者提供

关键要点

1. **T5 模型是一个健壮、灵活的文本到文本转换器，它可以增强几乎任何 nlp 任务的结果，包括那些 NLP 原语库在处理文本数据时处理的结果。**额外的准确性，虽然在这里是微不足道的，但几乎肯定可以通过实现情感分析之外的额外拥抱面部预调整模型来提高。此外，在这个例子中，我们的微调 T5 版本只在review_text数据上进行训练，而不是在review_title数据上进行训练，这似乎与 Featuretools 创建的功能不一致——这意味着所有创建的功能似乎只使用review_title数据作为微调模型的输入，因此其性能更差。纠正这个问题很可能意味着更好的整体性能。
2. 使用拥抱面部变形器和简单变形器库，扩展 Featuretools 框架很简单。通过加入一些额外的代码行，准确性提高了，而代码的复杂度保持不变。

最后的想法

大多数企业都有大量的表格数据，其中大部分数据都是书面文本格式的。CCG 是一家数据和分析公司，帮助组织变得更加洞察驱动。我们通过行业特定的解决方案解决复杂的挑战并加速增长。我们的数据科学团队使企业能够获得更大的可见性并做出明智的决策，从而获得竞争优势。我们的战略产品旨在加快价值实现，改善业务成果，并围绕可信见解的共同观点团结团队。请联系我们，帮助您构建下一个定制的 NLP 解决方案…

原载于 2021 年 3 月 29 日【https://blog.ccganalytics.com】。

CCG 是一家数据和分析公司，通过行业特定的解决方案，帮助组织变得更加洞察驱动，解决复杂的挑战并加速增长。我们让客户能够更好地了解他们的业务，做出明智的决策，从而获得竞争优势。我们的 战略产品 旨在加快价值实现、改善业务成果，并围绕可信见解的共同观点团结团队。

二月版:数据科学有趣的一面

原文：https://towardsdatascience.com/february-edition-the-fun-side-of-data-science-4178e4d324ab?source=collection_archive---------41-----------------------

月刊

提醒你去做你喜欢的项目

照片由安娜·施韦茨从派克斯拍摄

数据科学让你发现你周围的世界。如果你有一台笔记本电脑、无线网络和一个想法，它的工具和概念将使你能够回答你感兴趣的问题。你有没有想过在所有的朋友中谁最受欢迎？你对音乐的品味是否无聊？或者你是否能预知灵异事件？数据科学帮助你找到答案。当你研究一个对你来说很重要的主题或数据集，你对它充满热情，你自称是这方面的专家，这会带来很多快乐。

围绕数据科学的大部分对话似乎都集中在工作上，这是可以理解的。成为或成为一名数据科学家通常意味着你想成为或正在专业地从事这项工作，解决业务问题，并拥有“数据科学家”或类似的头衔。

然而，当你专注于转行、获得新工作或晋升的职业目标时，你可能会忽略是什么让数据科学如此令人愉快。这可能会变成一件苦差事。你可能只会把它与学习的压力和职业发展的压力联系在一起。尤其是在像这样充满挑战和不确定的时期——大多数休闲活动都受到限制或停止——休息一下，对自己有耐心，试着花时间在你喜欢的事情上是很重要的。

下面的帖子可以提醒你数据科学项目是多么有趣。这些例子可以启发你的下一个副业。它不一定要教你一项新技能。你不需要拯救世界。你可以享受你创造新事物的能力，去回答你关心的问题，去探索你周围的世界。

《走向数据科学》的编辑助理朱莉娅·尼库尔斯基

NLP on The Office 系列

由克里斯托夫·拉贝 — 17 分钟阅读

利用文本挖掘技术，如标记化、tf-idf 和情感分析来分析电视连续剧的脚本。

人工智能如何帮助我赢得对抗鸽子的战争

到 Tatiana Sennikova — 5 分钟读取

建筑概述和为什么你可能需要一个鸽子火绒

梵高用深梦卷积网络作画

由迭戈·萨利纳斯——4 分钟阅读

用 Tensorflow Deep Dream 进行计算机视觉的深度学习

漫威宇宙探索性网络分析

通过托马兹·布拉坦尼克 — 15 分钟读取

在图形数据科学库中引入新的 k-最近邻算法

利用无监督学习生成 Spotify 播放列表

通过卡勒姆·巴拉德 — 6 分钟读取

人工智能能区分愚蠢的朋克和混蛋吗？

用 Python 把照片变成漫画

通过 Tazki Anida Asrul — 4 分钟读取

你可以通过在 Python 中实现机器学习算法来给一张照片赋予卡通效果。

使用社区检测算法理解《权力的游戏》世界

基思·麦纽提 — 7 分钟阅读

社区检测算法非常准确，而且非常容易使用

谁是漫威电影中最重要的人物？

由迈克尔·陶伯格 — 7 分钟阅读

MCU 的数据分析(或者为什么钢铁侠可能值得他的百万身价)

新播客

• 海伦·托纳— 人工智能的战略和安全含义
• 欧文·埃文斯— 预测人工智能的未来
• 华金·基诺内罗·坎德拉— 脸书负责人艾
• Silvia Milano — 推荐系统的伦理问题

我们也感谢最近加入我们的所有伟大的新作家塞拉·斯坦顿、马克斯·埃利希、阿尔韦托·罗梅罗、埃布鲁·库岑、纳西娅·恩塔拉、曼努埃尔·乌尔塔多、亚历克斯·鲍威尔、宜兴关、塔加特·邦汉姆、克洛伊·摩根、 https://medium.com/u/1e1a852762e2?source=post_page-----4178e4d324ab-------------------------------- 何塞·曼努埃尔·纳波尔·杜阿尔特，钱丹·杜吉娅，凯蒂·莫里斯·克拉沃，KK·严(博士)，罗比·盖根，阿尤什·库马尔，布鲁诺·席尔瓦，保罗·沃什，图，法布里奇奥·迪·瓜尔德 我们邀请你看看他们的简介，看看他们的工作。

通过基于距离的聚类进行联合学习

原文：https://towardsdatascience.com/federated-learning-through-distance-based-clustering-5b09c3700b3c?source=collection_archive---------20-----------------------

隐私没得商量

作者照片

你有没有想象过你的手机键盘是如何预测下一个关键词笔画的？

单词的工作/预测由部署在您的手机上的 ML 算法给出，并根据您的本地数据进行训练。由于它是对你的数据进行训练，你现在可能会有一个问题，我的隐私没有丢失吗？

答案是否定的。这些科技公司使用 联合学习 来解决隐私问题，因为没有数据被发送到主模型。相反，ML 模型将部署在您的设备上，并根据可用的数据进行训练，然后返回模型参数而不是数据。让我们深入了解它的工作原理，在本文中，我们提出了一种新的方法来对相似的设备进行聚类，以提高模型的性能。

内容列表:

1. 介绍
2. 联合学习
3. 我们的框架
4. 使聚集
5. 培训阶段
6. 结果和比较
7. 结论

F 深度学习(FL)是一种系统架构，它利用手机等分布式网络来增强 AI 模型性能，同时对其所有者保密个人数据。本文提出了一种对传统 FL 设计的新颖补充，它利用集群将相似的设备分组，并在训练期间增强彼此的协作。

1.简介:

联合学习是一种范例，其中建立了一个分布式设备系统来协作训练模型。传统的联合学习涉及具有包含模型权重的中央服务器，该中央服务器具有通过偶尔将权重发送回服务器来帮助训练该模型的设备。当权重被发送回服务器时，所有设备都有均等的机会使用称为联合平均的过程来更新主/服务器模型( FedAvg )。用简单的术语来说，它可以被认为是一组值的平均值。

如果你不熟悉几个术语，不要惊慌。我们将从头开始学习它们。

一旦应用了 FedAvg，就用它来更新集中式模型，然后将更新后的权重广播给网络中的所有设备。
传统方法的问题在于，它严重依赖于所有设备都将以类似方式学习的假设。然而，现实地说，设备将使用不同的数据集进行操作，每个数据集代表由 f1 表示的整个模型的子集。

因此，平均设备重量不太可能是最佳方法，因为它忽略了设备间不平衡数据引起的偏差。因此，在我们的实践中，我们以不同的方式看待问题。我们看到，除了只有中央模型，我们还可以引入聚类的概念，表示表现出相似学习行为的不同设备的组。通过进行这种聚类，我们认为在聚类级别上应用的算法(如 FedAvg)应该强调对其中的设备最重要的权重更新。

在本文中，我们将看到一个三阶段实验来探索我们的聚类方法。以下是我们所做工作的总结:

第一阶段:

1. 跨多个设备分割目标数据集
2. 使用传统的外语学习方法训练所有设备

• 第二阶段:

1. 基于阶段 2 之后的设备权重，我们运行两种聚类算法。聚类算法输出一个聚类列表，每个
   聚类都有一个属于它的设备 id 列表。每个群集通过平均所有设备的权重来计算自己的权重。
2. 进一步训练设备，但不是将它们的重量报告回中央服务器，而是仅将它们报告给它们的集群。因此，这实际上创建了多个传统的 FL 网络，其中每个网络代表一个集群以及属于该集群的设备子集。

第三阶段:

1. 我们计算阶段 2 完成后生成的权重的多个排列，然后使用它来评估应用聚类后模型的改进。

2.联合学习:

机器学习算法，尤其是深度学习算法，需要大数据集才能有效训练。在现实世界中，数据在隐私限制下分布在多个组织中。此外，有许多部门的数据不能在内部共享，如政府、金融、医院和研究实验室，由于数据法规和政策的原因，内部协作是不可能的。然而，如果这些实体能够在保持其数据匿名的同时进行合作，我们就可以将我们的模型暴露给丰富多样的数据集。

为了适应这些限制，需要一种无需交换用户数据的协作学习解决方案。该解决方案是通过结合联邦和机器学习提出的，它被称为联邦学习(FL)。在一般的机器学习中，数据存在于单个设备或数据中心，这些算法使用这些数据并在其上建立模型。

然而，如果你看看下面的图片，在 FL 中，服务器将模型发送到其网络中的各个设备，并根据每个设备的数据进行训练。训练完成后，仅返回模型参数，而数据保留在拥有它的设备上。因此，服务器聚合所有客户端的结果，并使用 FedAvg 执行聚合。

有机会使用模型参数来确定模型行为。因此，可以计算安全聚合来克服这个问题，其中从客户端获得的模型参数被加密，而服务器模型只能解密聚合。以下是外语培训过程的概述。

传统 FL:作者照片

一次外语训练通常要进行四个步骤。

1. 第一步，在集中式服务器上选择机器学习模型。
2. 接下来，这个模型被传播到所有的网络设备(在上图中，是 4 个设备)。
3. 每个设备在第三步中开始训练模型，并开始具有反映其数据的唯一权重。
4. 最后，在步骤 4 中，它们将自己的权重发送回服务器，在服务器中进行联合平均，然后将结果广播给所有设备。这四步算一轮 FL 训练。

我们在我们的项目中使用了 TensorFlow Federated ，这是一个允许分散数据计算的机器学习框架。这个开源框架将使用户能够研究和构建基于 FL 架构的模型。

3.我们的框架:

我们的框架已经建立，以比较提出的多阶段模型和一个香草 FL 模型。因此，这两个模型是我们研究框架的两个组成部分。这两种型号都被配置为运行在 E epochs 上，并且在其网络中包含 100 个设备。网络中的每个设备包括数据集的随机分布。

数据集:

对于数据集，使用 10 重交叉验证，指标是召回率和准确度。

em NIST:
tensor flow em NIST 可以被视为 MNIST 数据集，其中有 10 个类别标签(0–9)。它包含 60，000 个训练样本和 10，000 个测试样本。Tensorflow federated 提供了将数据集分发到多个客户端的方法，在此实现中，它用于在客户端之间拆分数据集。这可以在下图中看到，其中数据分布在多个客户端上。从图中我们可以看出数据分布不均匀(不平衡)。Tensorflow federated 允许我们将数据分成等量(平衡的)。在我们的研究中，我们根据训练后获得的数据分布和权重，使用不平衡数据对设备进行聚类。

数据在客户端的分布图片由 Google FL 提供

4.聚类:

我们提出的模型的基本部分是设备的https://en.wikipedia.org/wiki/Cluster_analysis群集。集群可以被认为是组合相似的设备。它允许设备从来自具有相似学习特征的设备的附加协作层中受益。例如，假设 EMNIST 数据集正被用于训练，并且两个设备可能具有大量学习识别数字 5 类别标签的经验。通过分享他们的体重，他们可以理想地帮助彼此以更快的速度学习。聚类发生在我们模型的第二阶段，并且在第二和第三阶段进行的训练中起着重要作用。在我们的研究中，我们测试了两种聚类方法。

1. K-Means 聚类:
   K-Means 算法( scikit learn，2020 )是一种为一组特定输入点创建聚类的成熟方法。该算法采用这些输入点，并且输入整数 K. K 表示要形成的聚类的数量。

算法:

在给定的算法 1 中，让 X 表示输入点的集合。

K 均值聚类算法:Ibrahim Helmy

关键特征:

这种聚类方法有几个重要的特征。第一个与设备可以包含在其中的集群数量有关。使用 K-means 聚类，一个设备一次只能是一个聚类的一部分。另一个关键特征是聚类的数量，K 变量，一个预定义的整数。这意味着集群的数量不能动态增加或减少。该整数必须是一个微调的超参数，根据所使用的数据集
和设备数量，该参数最好是一个不同的值。

更新设备重量:

在模型训练期间，群集中的每个设备在特定点接收更新。对于这种群集方法，每个设备的权重被设置为共享其群集的每个设备的所有权重的平均值。

2. 基于距离的动态聚类

第二种聚类方法是基于动态距离的聚类方法。对于这种方法，我们执行多个操作来获得最终的聚类列表。首先，所有设备之间的欧几里德距离是根据它们的权重计算的
。其次，确定阈值。该阈值用作集群中包含的两个不同设备之间的最大距离。一旦选择了该值，算法就开始聚类过程。在我们的研究中，阈值被设置为所有聚类权重的平均值。算法 2 对此进行了更详细的描述。

基于动态距离的聚类算法:作者 Ibrahim Helmy

示例:

让我们把这个 Python 字典看作一个设备和所有其他设备的地图，这些设备都在先前定义的阈值距离之内。python 字典中的键是“:”前面的值，值是后面的元素。关于下面的例子，

“1”是一个键，“[9，10]”是它的值。
{0: []，1: [9，10]，2: [9]，3: []，4: []，5: [9]，6: []，7: []，8: []，9: [1，2，5]，10: [1]}
在这里的例子中，字典的关键字是设备 id，值是距离设备最多阈值距离的设备的设备 id 列表。使用算法 2，聚类的结果列表将如下:
[[5，9]，[9，1]，[10，1]，[2，9]，[0]，[3]，[4]，[6]，[7]，[8]]

关键特征:

如前面给出的示例所示，与 K-Means 聚类不同，结果显示单个设备可以是多个聚类的一部分。这是一个独特的属性，它将允许一个设备与共享多个学习特征的其他设备协作，而不会受到它们彼此
不相似的限制。**

还需要注意的是，尽管允许一个设备成为多个集群的一部分，但是该方法的算法不允许子集。甚至未能成为组集群的一部分的设备形成它们自己的集群。

更新设备权重:

由于使用这种方法，单个设备可以是多个集群的一部分，因此设备权重是单独计算的，而不是在集群中计算的。每个设备的权重被更新为其所属的每个集群的所有权重平均值的平均值。使用上述示例中的集群列表，设备 9 的更新如下:

设备 9 新权重= Avg( Avg([5，9])，Avg([9，1])，Avg([2，9]))

5.培训阶段:

阶段 1 —初始化

第一阶段:穆斯塔法·卡特吉拍摄的照片

这个阶段是为了初始化我们的实验。

它由传统的 FL 模型组成，其中 N 个设备在“e”个时期内进行训练，并通过 FedAvg 在集中式 FL 模型上进行协作。在训练期间，集中式 FL 模型也将向所有设备广播重量更新。在“e”时代完成后，每个设备将具有唯一的权重，该权重来自与其他设备的协作，并且非常适合该设备的数据集。我们跟踪第 2 阶段的单个设备重量，并评估该模型的总体性能。

第 2 阶段——集群培训:

第二阶段:穆斯塔法·卡特吉的照片

在这一阶段，我们将介绍我们对集群培训的贡献。

使用来自阶段 2 的单个设备权重，我们使用 K-means 和基于距离的聚类对它们进行聚类。对于每种聚类算法，我们得到一组不同的设备聚类。

然后，我们将每个设备群集视为其自己的 FL 模型，其中群集的中心模型使用群集的平均设备权重进行初始化。之后，我们为每个集群的“e”时期训练设备，这最终导致更新的中央集群权重。

因此，群集鼓励在阶段 1 中进行类似训练的设备严格协作。这与传统的 FL 训练相比是有利的，在传统的 FL 训练中，不相关的设备相互影响，这可能损害它们各自数据集的性能。

第 3 阶段—评估:

在这一步中，我们通过评估从阶段 2 中探索的聚类方法得出的最终权重来评估我们的聚类方法的有效性。

• 我们以三种不同的方式评估新的权重:
• 所有权重的平均值在通用测试集上的表现如何？
• 所有权重的加权平均值在通用测试集上的表现如何？
  -每个聚类权重使用其达到的最高精度进行加权
  -如果我们通过取其权重和所有聚类的平均值之间的平均值来更新每个聚类权重，那么每个聚类是否仍然保留
  其专业性，但也通过受益于其他聚类来获得更好的泛化能力？
  -该评估使用每个集群设备的测试集。

6.结果和比较

评估指标:

用于评估的指标是准确度和精确度。TFF 的联邦学习 API 层提供了可以直接在张量流模型中使用的高级接口。然而，它只返回一个精度分数，并且使用这个 API 层不可能获得精度值。为了得到召回分数，TFF 的联邦核心 API 层可以作为构建 FL 的基础。它提供了一组低级接口，因为它允许用户通过改变函数式编程环境来执行计算。

为全局模型分割一个测试集，并且跨每个客户端分布唯一的测试集。对全局模型和局部更新模型的评估是用它们独特的测试集来执行的。对测试集执行以下评估，并记录结果:

客户端和全局模型的准确性(第 1 阶段)
；聚类平均值更新后的全局模型的准确性(第 3 阶段)
；加权聚类平均值更新后的全局模型的准确性(第 3 阶段)
；聚类平均值更新后的客户端的准确性(第 3 阶段)
还报告了具有 K 均值和基于动态距离的聚类的模型的结果。

与之前的作品形成对比:

实验中使用的分层聚类技术具有不同的因素，如聚类前的通信回合数、不同的非 iid 设置、距离度量，如 L1、L2、余弦距离。

记录参与的客户数量、通信回合、客户的测试准确度以及达到目标测试准确度的客户的百分比。要注意的是，没有报告聚类步骤之后的全局模型的性能。

以下是本文呈现的新颖之处:

• 聚类技术—使用 K 均值和动态距离聚类。
• 所有客户都参与学习过程。
• 聚类后，局部模型没有用当前全局状态初始化。相反，用于聚类的权重同样用于进一步的基于聚类的训练。
• 聚类是独立训练的，没有对全局模型的任何反馈。
• 第 3 阶段在本文中介绍，其中全局模型以两种不同的方式更新—聚类平均和加权聚类平均。客户端使用其所属的集群和所有其他
  集群的平均权重进行更新。

中央服务器和客户端使用卷积神经网络在 EMNIST 数据集上进行训练。数据被分发给 100 个具有非 iid 设置的客户端。阶段 1 执行 20 个时期，随后是阶段 2 聚类训练 20 个时期。SGD optimizer 的学习率为 0.1。

在所提出的方法中，欧几里德距离用于计算相似性，并且计算设备到设备的距离。因此，L2 和单一连锁结果被认为是一个公平的比较。由于报告了客户的最高测试准确度和达到该准确度的客户的百分比，因此也报告了所提议的方法。表 1 描述了 L2 距离、单个链接设置的结果。以下是从实施建议的方法中观察到的结果。

图表作者:Rajitha Muthukrishnan

图由 Rajitha Muthukrishnan 绘制

7.结论:

观察了联邦学习中的培训过程的概述，并提供了基线学习如何工作以及它与具有两个数据集的多阶段方法的比较。后者取得了比基线 FL 更好的结果，因为聚类允许相似的设备相互训练。

同样，相同的设备形成集群，影响其性能的无关设备被分离。因为单个设备可以是多个集群的一部分，所以它比传统的集群方法产生了更好的结果，在传统的集群方法中，一个设备可以是单个集群的一部分。在没有对全局模型的任何反馈的情况下独立地训练聚类产生了更好的结果。FL 是一个热门的研究课题，用置信区间或由此衍生的其他方法扩展聚类方法将是一个强有力的研究方向。

这篇文章是基于与 Ibrahim Helmy 、 Mostafa Katerji 和 Rajitha Muthukrishnan 一起进行的研究。

感谢阅读到最后。如有错误或建议，欢迎不吝赐教。

如果你想联系我，请通过 LinkedIn 联系我。

参考资料:

****https://www.tensorflow.org/federated https://ai.googleblog.com/2017/04/federated-learning-collaborative.html ****

联合学习:你的数据与你同在

原文：https://towardsdatascience.com/federated-learning-your-data-stays-with-you-fc1d49b35ec4?source=collection_archive---------22-----------------------

通过联合学习，我们可以在不共享用户数据的情况下，以另一种方式提高集中式机器学习模型的性能。

约翰·萨尔维诺在 Unsplash 上拍摄的照片

这是 21 世纪，“数据是新的黄金”。随着新技术的出现，更高的计算能力，当然还有大量的数据，人工智能获得了很大的发展势头，全球人工智能(AI)市场预计将从 2021 年的 583 亿美元增长到 2026 年的 3096 亿美元，根据 MarketsandMarkets 的预测，预测期内的复合年增长率(CAGR)为 39.7%。

虽然人工智能给我们的日常生活带来了很多舒适，但我们甚至没有意识到这一点，也存在一些挑战。数据隐私就是其中之一。应用程序收集你的数据(当然不会卖给第三方应用程序，是吗？)为您提供更个性化的推荐和结果(以及广告😐).

那么问题来了，数据离开你的手机了吗？

答案是肯定的。例如，当您授权任何应用程序访问您的位置信息时，它会收集您的位置数据。现在取决于应用程序，他们希望他们的人工智能算法如何使用它。有两种选择:

1. 在服务器上:机器学习/深度学习模型部署在服务器上，在服务器上，它根据从数十亿部智能手机接收的数据训练模型。
2. On-device:ML/DL 模型部署在手机上，用户数据用于训练和改进模型以获得更好的推荐。

两者各有利弊。在服务器上进行培训需要大量的存储空间来存储数据，并需要世界一流的安全性来保护他们免受数据泄露的影响。而设备上训练是在有限的数据量上训练的，并且模型性能受到损害。

解决方案:在分散数据上训练集中模型。嘣！！！！

好的，让我解释一下。

为了获得更好的用户体验，一家公司将希望来自数十亿部智能手机的数据在服务器中的一个集中模型上进行训练。但为此，数据必须离开智能手机。但是我们不想那样，对吗？相反，如果在进行训练的所有设备中都存在集中式模型的副本，那么我们已经解决了性能问题。现在，我们不得不将来自每部智能手机的所有结果整合到一个单一的结果中。现在，训练结果(我们机器学习工程师称之为:【权重】显然可以发送到服务器，在那里进行合并。现在，权重被高度加密，密钥取决于设备上的模型。

哦耶！！！

并且为了进一步改善用户隐私，使用安全聚合协议，该协议使得服务器能够组合加密结果，仅通过添加零和掩码来解密该聚合。要了解更多相关信息，请参考这篇文章。

最后，总重量被发送回设备上的模型，我们现在有一个新的改进的模型更新。

每一个新的开始都会带来新的挑战。相信新挑战的美丽，它们会帮助我们成长。

让我们来讨论一下挑战。

1. 有些数据是特定用户专用的。这将降低整个模型的性能。我们不希望模型记住来自特定用户的稀有数据。

解决方案:a)通过设计一种机制来控制单个用户对整体结果的贡献量。b)通过向更具体的数据添加噪声。这也被称为差分隐私。我发现这篇文章挺直观的。

2.现在我们有了从汇总结果中形成的新模型。但是，在推出更新之前，我们如何才能看到模型在新数据上的表现呢？

解决方法:简单！我们可以应用我们都知道的相同的训练验证分割概念。相反，在这里我们将用户作为我们的实验！！！！听起来很有趣，嗯？我们将用户分为训练和验证。在智能手机用户中，我们有一小部分人会验证这个结果。其余的将训练模型。因此，该模型在实时数据上进行了测试。

3.简单的平均聚合适用于所有算法吗？让我们用两个例子来解释这一点:

a)我们就拿正态贝叶斯(openCV) 来说。平均向量和协方差矩阵受每类样本数量的影响很大。现在，假设我们有两部智能手机和一个二进制分类问题，其中A 类和b 类

用户 1:

图片作者:包含三个 A 类样本和一个 B 类样本

用户 2:

图片作者:包含 3 个 B 类样本和 1 个 a 类样本。

其中 x ki ( j )表示训练样本中属于类别 k 的第 j- 个样本的第 i- 个特征属性的值，最后的n-维(共 n 个特征属性)类别 k ’ μk’ 的均值向量估计为:

因此，平均向量的值很大程度上受每类样本数量的影响。所以用户 1 的平均向量 μA(1) 具有类别 A 的 75%影响，而 *μA(2)具有 25%影响。那么当我们通过取平均值 1/2(*μA(1)+μA(2))来合并它们时，我们能够保留特定于类的信息吗？

b)对于像 SVM 这样的算法，其权重只不过是依赖于数据集中样本数量的支持向量，我们可以有一个对于所有结果大小不变的权重矩阵吗？我们可能需要专门针对机器学习任务的聚合算法。

4.隐私和准确性之间的权衡:

有时为了增加用户数据的隐私，会添加一些噪声，导致数据偏离其实际行为，从而导致一些准确性下降。

结论:

联合学习可以解决很多与用户隐私相关的问题，同时提高模型性能以获得更好的推荐。这是一个相当新的领域，更多的研究可以解决我们称之为协作学习所面临的许多挑战。

参考资料:

https://ai.googleblog.com/2017/04/federated-learning-collaborative.html https://arxiv.org/abs/1610.05492 https://www.tensorflow.org/federated

前馈神经网络——如何在 Python 中成功构建它们

原文：https://towardsdatascience.com/feed-forward-neural-networks-how-to-successfully-build-them-in-python-74503409d99a?source=collection_archive---------2-----------------------

神经网络

使用真实数据的 Python 示例对神经网络进行了详细的图形说明

前馈神经网络。图片由作者提供。

简介

神经网络已经成为过去几年的中心话题。虽然它们最初看起来令人生畏，但我向你保证，你不需要博士学位就能理解它们是如何工作的。

在本文中，我将带您了解基本神经网络背后的主要思想，也称为前馈神经网络或多层感知器(MLPs)，并向您展示如何使用 Tensorflow 和 Keras 库在 Python 中构建它们。

内容

• 前馈神经网络在机器学习领域中的地位
• 直观解释前馈神经网络如何工作
  -网络结构和术语
  -参数和激活函数
  -损失函数、优化器和训练
• 如何建立和训练你自己的前馈神经网络的 Python 例子

前馈神经网络在机器学习领域中的地位

机器学习是一个巨大且不断扩展的空间，每天都有新的算法开发出来。我试图通过在下面的交互式图表中对一些最常用的算法进行分类，来给这个世界带来结构。**点击不同类别，放大并展示更多内容。**👇

虽然这种分类并不完美，但它让我们大致了解了不同部分是如何组合在一起的，并且希望它还能促进您的数据科学学习之旅。

我将神经网络放在一个独特的类别中，认识到它们对机器学习的独特方法。然而，重要的是要记住，神经网络最常用于使用带标签的训练数据来解决分类和回归问题。因此，另一种方法是将它们置于机器学习的监督分支之下。

机器学习算法分类。由作者创建的互动图表。

如果你喜欢数据科学和机器学习 ，请 订阅 每当我发表一个新的故事，你都会收到一封电子邮件。

直观解释前馈神经网络如何工作

结构和术语

首先，让我们熟悉一下神经网络的基本结构。

前馈(FF)神经网络的基本结构。图片由作者提供。

• 输入层 —包含一个或多个输入节点。例如，假设您想预测明天是否会下雨，并根据湿度和风速这两个变量做出决定。在这种情况下，第一个输入是湿度值，第二个输入是风速值。
• 隐藏层——这一层包含隐藏节点，每个节点包含一个激活函数(稍后将详细介绍)。注意，具有多个隐藏层的神经网络被称为深度神经网络。
• 输出层 —包含一个或多个输出节点。按照上面相同的天气预测示例，您可以选择只有一个输出节点生成降雨概率(其中> 0.5 表示明天有雨，而≤0.5 表示明天无雨)。或者，您可以有两个输出节点，一个用于降雨，另一个用于无雨。注意，您可以对输出节点和隐藏节点使用不同的激活函数。
• 连接 —连接不同节点的线称为连接。这些包含内核(权重)和偏差，这些参数在神经网络的训练过程中得到优化。

参数和激活功能

让我们仔细看看核(权重)和偏差，以了解它们的作用。为简单起见，我们创建一个基本的神经网络，它有一个输入节点、两个隐藏节点和一个输出节点(1–2–1)。

在前馈(FF)神经网络中如何应用权重和偏差的详细视图。图片由作者提供。

• 内核(权重) — 用于缩放输入和隐藏节点值。每个连接通常具有不同的重量。
• 偏差 —用于在通过激活功能之前调整缩放值。
• 激活函数 —将激活函数视为神经网络用来创建定制曲线以拟合训练数据的标准曲线(构建模块)。通过网络传递不同的输入值会选择标准曲线的不同部分，然后将这些部分组合成最终的定制曲线。

有很多激活功能可供选择，最常用的有 Softplus 、 ReLU 、 Sigmoid 。以下是神经网络中六种常用激活函数的形状和方程:

激活功能。图片由作者提供。

我们现在已经熟悉了核(权重)、偏差和激活函数，让我们使用相同的神经网络根据今天的湿度计算明天下雨的概率。

注意，我已经训练好了这个神经网络*(见下面 Python 部分)*。因此，我们已经知道了核(权重)和偏差的值。下图显示了 FF 神经网络如何获取输入值并产生答案(输出值)的逐步过程。

前馈(FF)神经网络执行的示例计算。图片由作者提供。

正如你所看到的，上面的神经网络告诉我们，今天 50%的湿度意味着明天有 33%的可能性下雨。

损失函数、优化器和训练

训练神经网络涉及一个被称为反向传播的复杂过程。我不会一步一步地解释反向传播是如何工作的，因为这是一个足够大的主题，值得单独写一篇文章。

相反，让我简要地向您介绍损失函数和优化器，并总结当我们“训练”一个神经网络时会发生什么。

• 损失 —代表真实值/标签和预测值/标签之间的误差“大小”。训练神经网络的目标是使这种损失最小化。损失越小，真实数据和预测数据之间的匹配越接近。有很多损失函数可供选择，最常见的有二进制交叉熵、分类交叉熵、均方误差。
• 优化器——是在反向传播中使用的算法。优化器的目标是找到最佳的核(权重)和偏差集，以最小化损失。优化器通常使用梯度下降方法，这允许他们迭代地找到权重和偏差的“最佳”可能配置。最常用的有 SGD 、 ADAM 、 RMSProp 。

训练神经网络基本上是通过训练数据来拟合自定义曲线，直到它尽可能地逼近该曲线。下图说明了特定情况下定制曲线的外观。该示例包含一组数据，随着输入值的增加，这些数据似乎在 0 和 1 之间翻转。

将曲线拟合到训练数据。图片由作者提供。

一般来说，激活函数的广泛选择加上我们希望添加尽可能多的隐藏节点的能力(假设我们有足够的计算能力)意味着神经网络可以创建任何形状的曲线来拟合数据。

然而，拥有这种极大的灵活性有时可能会导致数据过度拟合。因此，在使用模型进行预测之前，我们必须始终确保在测试/验证集上验证模型。

总结我们所学的

前馈神经网络接受一个或多个输入值，并在通过激活函数传递结果之前，使用核(权重)和偏差来应用变换。最后，我们得到一个输出(预测)，这是通过训练优化的复杂转换集的结果。

我们通过训练数据拟合定制曲线来训练神经网络，以损失最小化为指导，并通过参数(核和偏差)优化来实现。

用 Python 构建和训练前馈神经网络

现在让我们找点乐子，建立我们自己的神经网络。我们将使用澳大利亚历史天气数据来训练一个神经网络，预测明天是否会下雨。

设置

我们需要以下数据和库:

• 来自 Kaggle 的澳大利亚天气数据(许可:知识共享，数据原始来源:澳大利亚联邦气象局)。
• 用于数据操作的熊猫和 Numpy
• Plotly 用于数据可视化
• 神经网络的 Tensorflow/Keras
• Scikit-learn 库用于将数据拆分成训练-测试样本，以及用于一些基本的模型评估

让我们导入所有的库:

上面的代码打印了本例中使用的包版本:

Tensorflow/Keras: 2.7.0
pandas: 1.3.4
numpy: 1.21.4
sklearn: 1.0.1
plotly: 5.4.0

接下来，我们下载并获取澳大利亚的天气数据(来源: Kaggle )。我们也做一些简单的数据操作，并为我们的模型导出新的变量。

这是数据的样子:

一段经过修改的 Kaggle 的澳大利亚天气数据。图片由作者提供。

神经网络

现在我们训练和评估我们的前馈(FF)神经网络。我对下面的代码做了大量的注释，以便让您清楚地理解每个部分的作用。因此，我不会在文章正文中重复同样的内容。

使用一个输入(湿度 3pm)

简而言之，我们是用今天下午 3 点的湿度来预测明天会不会下雨。我们的神经网络具有本文前面分析过的简单结构(1–2–1):一个输入节点、两个隐藏节点和一个输出节点。

有几点需要注意:

• 下面的代码执行两次验证，一次是对 X_train 数据的一部分(参见步骤 5 中的 validation_split ),另一次是对步骤 2 中创建的测试样本。当然，没有必要做两次，所以可以随意使用任何一种方法来验证您的模型。
• 数据是不平衡的(晴天比雨天多)，所以我在步骤 5 中调整了 classes_weight。

训练前馈(FF)神经网络。Gif 图片由作者提供。

上述代码为我们的 1–2–1 神经网络打印了以下摘要和评估指标:

1–2–1 前馈(FF)神经网络性能。图片由作者提供。

请注意，这个模型的权重和偏差与本文前面的计算示例中的不同。这是因为 神经网络训练使用了优化器算法内的随机(random)方法。因此，每次重新训练时，您的模型都会有所不同。

现在让我们在图表上绘制预测曲线。

单输入神经网络生成的预测曲线。图片作者作者。

使用两个输入(风速和湿度 3pm)

让我们看看当我们使用两个输入(风速和湿度 3pm)来训练具有 2–2–1 结构的神经网络时，网络和预测是如何变化的。

通过训练一个具有 17 个输入和不同数量的隐藏节点的模型，您可以随时进行试验。

结果是:

2–2–1 前馈(FF)神经网络模型性能。图片由作者提供。

由于我们使用了两个输入，我们仍然可以可视化预测。但是，这一次我们需要一个 3D 图表来完成:

由具有两个输入的神经网络产生的弯曲预测曲面。图片由作者提供。

结论

神经网络并不像一开始看起来那么可怕。我真诚地希望你喜欢阅读这篇文章，并获得一些新的知识。

请使用本文提供的代码来构建您自己的神经网络。另外，你可以在我的 GitHub 库中找到完整的 Jupyter 笔记本。

在我努力让我的文章对读者更有用的时候，如果你能让我知道是什么驱使你阅读这篇文章，以及它是否给了你想要的答案，我将不胜感激。如果不是，缺少什么？

干杯！👏
T21【索尔·多比拉斯

如果你已经花光了这个月的学习预算，下次请记得我。 我的个性化链接加盟媒介是:

https://solclover.com/membership

您可能感兴趣的其他文章:

反馈校准方法

原文：https://towardsdatascience.com/feedback-alignment-methods-7e6c41446e36?source=collection_archive---------14-----------------------

思想和理论

生物驱动的反向传播替代方案

由 Robina Weermeijer 在 Unsplash 上拍摄的照片

反向传播的简单、高效、高精度和收敛速度，使其成为训练神经网络的实际算法。然而，有证据表明，这种算法不能由人脑在生物学上实现[1]。其中一个主要原因是反向传播需要前向和后向路径中的突触对称。由于突触在大脑中是单向的，前馈和反馈连接在物理上必须是不同的。这就是所谓的重量运输问题。

为了克服这一限制，最近对学习算法的研究通过研究更具生物学意义的算法，专注于神经科学和机器学习之间的交叉。其中一个主要的方法被称为反馈校准，它采用不同的前向和反馈突触权重。

不同学习算法的比较:反向传播、FA 和 DFA——作者图片

除了提供更具生物合理性的训练方案之外，已经表明对齐方法可以提高深度学习模型对抗敌对攻击的鲁棒性。最后，对反馈对准的额外兴趣还受到它们允许前向和反馈权重在专用集成电路(ASICs)中本地存在的能力的驱动，这最终允许节省时间和能量。

在这篇文章中，我将描述主要的反馈校准方法，并展示一个比较它们的准确性和鲁棒性与反向传播的基准。

反馈校准方法介绍

反向传播在生物学上是不合理的

使用反向传播的 N 层神经网络的训练在前向传递和后向传递之间交替，前向传递用于执行推理和计算误差信号，后向传递用于发送误差信号和更新权重。

我们可以观察下面的权重更新规则:

反向传播权重更新规则

层 i 的权重更新需要前向权重矩阵 *W_(i+1)的知识。*那个在生物学上是不可信的，因为它要求神经元互相发送大量的突触权重来执行反向传递。

重量运输问题——图片由伊恩·泰勒在 Unsplash 上拍摄

反馈校准算法避免了重量转移问题

反馈对准算法提出在后向传递中替换前向权重矩阵 W 信息，消除了传输权重的需要。不同方法之间的差异包括如何计算后向传递以及如何构建后向权重矩阵 B 。

反馈校准(FA): 权重更新的计算方式与反向传播相同，但反向权重矩阵是随机矩阵[2]。将 B 初始化为与 W 具有相同的分布和数量级有助于提高网络训练的收敛性。下面的公式描述了 FA 的权重更新规则:

一致符号一致反馈(uSF): 这种权重更新方法类似于 FA，但是它通过假设单位幅度的突触权重来传输前向矩阵的符号[3]。因此， B 矩阵为:

分批随机幅度符号一致反馈(brSF): 该方法不是为第 i 层的后向权重假设一个单位幅度，而是在每次更新后重新绘制它们的幅度|R _ I|,使得:

固定随机幅度符号一致反馈(frSF): 这是 brSF 方法的变体，其中权重的幅度|R _ I|不是在每次更新后重新绘制，而是在训练开始时固定和初始化。

直接反馈校准(DFA) :虽然 FA 中的权重更新是跨层递归计算的，但是可以通过直接将最后一层的损耗导数 𝛿z_N 向后推至所有层来预测误差传播【4】。这将导致以下更新:

其中 B_i 是一个适当形状的固定随机矩阵(即 layer_i 的输入维数×layer _ N的输出维数)。

算法基准

在本节中，我将解释在反馈校准算法【5】的准确性和鲁棒性基准测试中进行的实验。我们使用了 BioTorch 开源框架来进行基准测试。

我们使用 Xavier uniform 初始化我们的层的前向和后向权重，W 和 T2。使用这种方差保持初始化允许我们将权重保持在相同的数量级，并且改进了不对称条件下的训练。对于 uSF 方法，我们通过 Xavier 初始化的标准偏差来缩放权重的符号。

我们的实验表明，根据优化器的选择，模型的分类准确性存在显著差异，特别是对于 FA 和 DFA，即使在调整了它们各自的学习速率之后。为此，我们展示了 SGD 和 Adam 优化器的实验结果。

MNIST &时尚 MNIST

我们通过在 MNIST 和时尚 MNIST 数据集上对 LeNet 的所有对齐方法进行基准测试来开始我们的实证研究。用设置动量为 0.9 的 SGD 优化器和 10^(−3).的权重衰减来训练网络我们训练了 100 个时期，在第 50 个和第 75 个时期将初始学习率降低了 2 倍。

MNIST 和时尚 MNIST LeNET 网络的最大错误率(%)

我们观察到 FA 和 DFA 的性能接近 BP，并且符号一致性方法在 MNIST 上匹配 BP 性能。如果我们增加数据集的难度(时尚 MNIST)，反向传播和其他方法之间的性能差距，特别是那些不使用符号一致反馈的方法，也会增加。

CIFAR-10

为了将对齐方法的应用扩展到更深层次的架构和更具挑战性的任务，我们在 CIFAR-10 中对 ResNet-20 和 ResNet-56 进行了基准测试。使用 SGD 优化器的网络以 0.9 的动量和 10^(−4 的权重衰减来训练)。使用 Adam 的网络用相同的权重衰减和等于[0.9，0.999]的 betas 参数来训练。我们以 128 的批量进行 250 个时期的训练，在第 100、150 和 200 个时期将初始学习率降低 10 倍。我们使用网格搜索来选择每种方法的最佳学习率。

在 FA 和 DFA 方法的两种网络配置中，Adam 使用的自适应参数独立优化器都优于 SGD，如下所示。这些方法是反向通道中的不对称性较大的方法。

使用 SGD 和 Adam 训练的每个方法的 ResNet-20 和 ResNet-56 的 CIFAR-10 中的前 1 名错误(%)

Adam 带来的显著改进是可以预期的，因为它保持了基于从 RMSProp 继承的梯度的二阶矩的平均值而调整的每个参数的学习率。因此，它在噪声梯度下产生更好的性能。为了证实这一观察，我们为 SGD 和 Adam 优化器绘制了 DFA 方法的后向-前向范数权重比。

在 CIFAR-10 上为 SGD 和 Adam 训练 ResNet56 时，方法 FA 和 DFA 的权重比

可以观察到，SGD 已经驱动网络的第一层的范数权重比非常接近 0，这意味着前向权重矩阵 W_i 被更新以达到比后向权重矩阵 B_i 中的值大得多的值。这是由于在 DFA 方法中误差从最后一层到每一层的直接误差投影，从而避开了使用链规则计算的梯度的小范数。

同样的观察结果不适用于 FA 方法，其中第一层的权重范数比不为零，如下所示。然而，我们看到，与 SGD 相比，Adam 实现了更小的前后重量排列角度。

用带 SGD (a)和 Adam (b)的 FA 训练的 ResNet-20 的矩阵排列(左)和重量比(右)

ImageNet

最后，我们在 ImageNet 上对所有训练 ResNet-18 网络的方法进行了基准测试。我们使用 256 的批量大小，并使用初始学习率为 0.1 的 SGD 训练 75 个时期。调度器在第 20、40 和 60 个时期将学习速率降低 10 倍。我们使用 10^(−4 的重量衰减)和 0.9 的动量。对于 DFA，我们使用初始学习率为 0.001 的 Adam。我们的结果可以在下图中看到:

用所有反馈校准方法训练的 ResNet-18 网络的前 1 名 ImageNet 验证误差(%)

我们可以观察到，就性能而言，没有一种比对方法可以与反向传播相比。虽然符号一致反馈方法在精度上更接近，但是仍然有小的差距。对于 FA 和 DFA 方法，差距要大得多，这意味着在训练过程中反馈权重不能与反向权重对齐。

结论

反馈比对算法是一种比反向传播更具生物合理性的替代方法，因为它们避免了重量转移问题。在整个基准测试中，我们已经看到，尽管它们的性能与 MNIST 和 CIFAR-10 相当，但它们无法扩展到 ImageNet 之类的困难任务。然而，在使用 ASICs 的应用中，它们的应用可以有助于降低成本，因为反馈和反向权重是独立的。此外，这些方法的研究仍然很重要，因为在神经科学的帮助下，有助于我们揭示和了解更多关于人类大脑学习过程的信息。

感谢阅读，希望你喜欢这篇文章，并学到一些新东西！

参考

[1]蒂莫西·P·莉莉卡普、亚当·桑托罗、卢克·马里斯、科林·J·阿克曼和杰弗里·辛顿，反向传播和大脑 (2020 年)，《自然评论神经科学》。

[2] Timothy P Lillicrap，Daniel Cownden，Douglas B Tweed 和 Colin J Akerman，随机突触反馈权重支持深度学习的误差反向传播 (2016)，自然通讯。

[3]李倩·廖、乔尔·雷博和托马索·波吉奥，权重对称在反向传播中有多重要？ (2016)，《AAAI 人工智能会议论文集》。

[4]Arild nkland，直接反馈对齐提供深度神经网络中的学习 (2016)，神经信息处理系统。

[5] Sanfiz，Albert Jiménez 和 Mohamed Akrout，对反馈对齐算法的准确性和鲁棒性进行基准测试 (2021)， arXiv 预印本 arXiv:2108.13446 。

脸书人工智能反馈变压器

原文：https://towardsdatascience.com/feedback-transformers-from-facebook-ai-221c5dd09e3f?source=collection_archive---------34-----------------------

解决具有反馈记忆的变压器的一些限制

保罗·库科在 Unsplash 上的照片

在自然语言处理时代，Transformer 架构的增强已经成为革命的核心，突破正以前所未有的速度发生。本文展示了反馈变换器的概念，它克服了传统变换器架构以及递归神经网络的缺点，使较浅的模型具有更快的解码速度、更少的内存以及所需的计算，最重要的是，可以利用来自所有先前层的所有计算信息，而不像仅解码变换器那样为了并行训练而牺牲很多信息。

在进入反馈存储器的杂草之前，让我们修改变压器架构！

自然语言处理中的转换器架构旨在解决序列到序列的任务，同时轻松处理长范围依赖。这个模型完全依靠对 自我关注 来计算其输入和输出的表示，而不使用序列对齐的 RNNs 或卷积。

让我们在此一窥其架构，更深层次地钻研其推荐访问论文 关注你所需要的 ！

图 1:变压器架构综合视图

RNNs 和变压器架构的局限性

在 RNN 和变压器架构的情况下，不是所有计算的信息都被使用，尽管在技术上，人们可以利用它，但是为了并行训练，做出了牺牲。然而，新颖的反馈变换器架构使用具有相对更强性能的浅层模型来揭示从所有先前表示到所有未来表示的信息。

递归神经网络及其局限性

图 2:对 RNN 建筑及其缺点的直观研究

在 RNN 的情况下，所有信息仅在顶部和右侧方向流动，因此有大量信息丢失。此外，为了与其他信息相结合，这些信息通常需要经过多次计算。

变压器及其局限性

Transformer 体系结构有许多局限性，例如它不能有效跟踪长序列以及处理分层输入。这种架构的一些最重要的限制是:

(A)对更高级别陈述的有限访问

(B)如果频繁更新，变压器无法长时间保持内部状态

图 3:变压器及其缺点的直观研究

引入带反馈存储器的变压器

为了克服变压器结构的局限性，引入了反馈记忆的概念。正如我们可以在图 3 中分析的，每个隐藏的表示都有许多箭头(即连接),这种数量的注意力连接可以引爆任何系统。为了克服这一点，反馈记忆将特定时间步长的所有信息混合到一个记忆表示中。随后的层不再关注先前层的单独表示，现在只关注单一的记忆表示。

图 4:(左)反馈转换器将所有层的隐藏表示合并成一个向量，并存储在内存中。(右)反馈和变压器的区别。t 表示时间步长，l 表示层。

将信息存储到相应的存储器表示中的显著好处在于使用了总体更少的存储器以及更少的计算，因为这种方法共享了注意机制的密钥和值计算，从而由于存储器共享而进一步导致 GPU 存储器使用的减少。

图 5:解释变压器和反馈变压器中下一层表示的计算差异

反馈变压器架构的优势

以下是将反馈存储器引入变压器架构对性能提升的主要贡献:

1. 能够用小而浅的模型实现更好的性能

图 6:wmt 14 En-De 上的机器翻译，测试集 BLEU 和不同解码器深度的解码速度(每秒字数)。

根据图 6 的检查结果，可以得出结论，随着解码速度的提高，由于较浅的网络，即架构中的层数较少，与反馈变压器相比，变压器的性能下降更多。

2。与变形金刚 相比，反馈变形金刚收敛以在强化学习中达到更高的平均回报

图 Gridworld 中的迷宫导航。显示反馈变压器与标准变压器的平均奖励比较。

强化学习任务通常需要长时间的记忆来最佳地解决任务。从图 7 可以诊断出，与变压器架构相比，反馈变压器收敛以在任何训练步骤达到更高的回报。

结论

尽管在训练和推理时间期间使用了相当少的存储器，但是与具有更小和更浅模型的相同大小的变换器架构相比，反馈变换器以更快的解码速度实现了更强的性能。保留远程信息流以及立即访问可用的更高表示信息是具有反馈记忆的变压器的一些主要贡献。

参考资料:

[1]范，安吉拉，等，“解决变压器的一些限制与反馈记忆。”arXiv 预印本 arXiv:2002.09402 (2020)。

[2]瓦斯瓦尼、阿希什等人，“你所需要的只是关注。” arXiv 预印本 arXiv:1706.03762 (2017)。

【3】扬尼克·基尔彻的《反馈变压器》。

希望你能像我写这篇文章一样喜欢阅读这篇文章！

如果你觉得这些内容有意义，可以看看我的其他文章 这里 。

喂野兽:深度学习训练的数据加载路径

原文：https://towardsdatascience.com/feeding-the-beast-understanding-and-optimizing-the-data-loading-path-for-training-deep-learning-f896548dca89?source=collection_archive---------6-----------------------

通过了解和调整从磁盘到 GPU 内存的数据加载，优化您的深度学习培训流程

大卫·拉扎罗在 Unsplash 上拍摄的照片

深度学习实验速度对于按时交付高质量的解决方案非常重要。

数据加载路径——即将训练样本从存储中获取到 GPU 中是一个经常被忽视的领域，尽管它对实验速度有着重大影响。

在这篇文章中，我将介绍数据加载路径的组件，如何形式化它们的性能目标，以及如何设计满足这些性能目标的解决方案。

逆向工作—从 GPU 到存储

基本原理—让 GPU 保持忙碌

购买/租赁 GPU 非常昂贵。因此，在培训期间，您希望确保他们处于 100%的利用率，处理这些矩阵并更新权重。

GPU 在小批量中的工作效率最高，即通过将网络运算符表示为多维张量，同时将它们应用于大量训练示例。从纯计算效率的角度来看，批量越大越好(主要限制是 GPU 内存)

为了保持 GPU 的高利用率，我们需要确保在小批量(向前+向后传递)的训练步骤结束时，下一个小批量将准备好传输到 GPU 的内存中。

GPU 利用率下降表明数据加载太慢。作者图片

数据加载性能要求(针对单个 GPU)

定义:

n =小批量
t=小批量 GPU 处理时间

在典型的训练制度中，这些值在整个训练过程中是固定的。

目标:

99%的小批量应在秒或更短时间内加载 n 个实例。
简单测量的上限可以是:

• 最大延迟 (单例)≤ t
• 最小吞吐量 (例/秒)≥n/t****

什么影响 n 和 t？

首先也是最重要的， n 是一个超参数，你需要调优它，让你的网络真正收敛，学习你希望它学习的东西。

通常，如果训练数据量很小，您会选择较小的批量(例如 16/32)，如果训练数据量很大，则选择较大的值。

选择正确的批量大小可以使网络更快地收敛。作者图片

t 是 GPU 需要在小批量上执行的计算量(FLOPs)** 的函数；这取决于 GPU 型号、网络复杂性和 n.**

最后， n 受到可用 GPU 内存数量的限制。存储器需要保存整个小批量的网络状态。

网络状态的内存占用随着批处理的大小而线性增长，因为它包含反向传播所需的每个训练示例的激活和功能

迷茫？让我们看一些例子。

Resnet 50 上的 Imagenet

Resnet 架构。来源:kaggle.com

• 数据表示— 224X224X3，双精度(32 位)
• 单个示例的计算— 4 GFLOPs (约 40 亿次浮点运算)
• GPU 型号— V100，16 GB。能够进行 7 TFLOPS (每秒约 7 万亿次浮点运算)****
• GPU 内存中单个示例状态的大小:103 MB
• 内存中模型参数的大小:98MB(约 2500 万个可训练参数)

分析:

• V100 应该能够每秒处理 7 TFLOPs。
  结果应该是每秒处理 7 TFLOPS/4GFLOPs = 1750 个实例
  注:NVIDIA 公布的数字是 1457 ，可能是由于从 CPU 获取实例到 GPU 内存的开销。
• 内存大小为n128 = 103 mbx 128+98MB = 12.97 GB。
  这意味着 n =256 不适合 GPU 内存。**
• 结果: n=128，t = 128/1457 = 0.087s

接下来，为了在带有 Resnet 50 网络的 V100 上训练 imagenet，我们要求我们的数据加载为我们提供以下内容:

t =单个图像的最大延迟≤87 毫秒

n/t =每秒约 1457 张图像的读取吞吐量

rest net 152 上的 Imagenet

为了让您了解改变网络架构对性能的影响，下面是用 Resnet 152 重复的相同实验:

• 内存中单个示例的大小:219 MB(是 Resnet 50 的两倍)
• 内存中模型参数的大小:209 MB(约 5000 万个可训练参数)
• 单个示例处理成本= 8 GFLOPs
• n= 64(64 * 219 MB = 13.8 GB)
• t = 0.087s(总计~每批计算量相同)

t =单个图像的最大延迟≤87 毫秒

n/t =每秒约 730 张图像的读取吞吐量

因此，一个“小”的架构变化会导致数据加载性能需求的巨大变化。

猜测数据加载需求的经验法则

小数据

为了充分利用每个训练示例，您需要较小的 n 值。

在这种情况下:

• t 会很短(几十毫秒)
• n 会小(如 16/32)
• 吞吐量( n/t )仍然可以很高

大数据

****如果您有大量数据，您通常会使用容量更大的网络，并针对更多时期对其进行训练。这种情况下，你要一个大 n 。你的网络可以接受而不会混淆，再加上，否则，训练将永远进行下去。

当你想要一个高 n 的时候，你面临着一个问题 GPU 内存中每个例子的大小都会很大(高复杂度网络)——这就限制了 n (并延长了 t )。****

为了解决这个问题，常见的解决方案是:

• 使用分布式训练，使用多个 GPU(同一台机器/集群)处理整个大批量
• 减少网络的内存占用(例如混合精度)

因此:

• t 可以相对放松(比如说 2 秒)
• n 可以很大(比如说 1024)

分解数据加载过程

由于 GPU 本身必须忙于学习，一个显而易见的选择是使用 CPU 加载和准备数据——CPU 反正连接到每台机器，除此之外几乎没有任何事情可做。

当前一批正在 GPU 上处理时，使用 CPU 工作线程加载小批。作者图片

为 GPU 准备小批量包括以下步骤:

1. 决定需要加载哪些示例(通常使用数据集的混排)
2. 从存储(IO)加载示例
3. 转换，如预处理或扩充(CPU)
4. 将它们存储在 RAM (CPU)中
5. 将张量传输到 GPU 内存(CPU)

使用并行性实现吞吐量 大量的 I/O、每个示例的中高延迟以及拥有许多空闲内核的强大机器表明，在数据加载中使用并行性是明智的。

为了进一步卸载并降低对延迟峰值的敏感性，如果我们有空闲的工作人员，就有机会急切地从下一个批次的中加载示例(确保不要破坏 RAM……)**

我们现在将更深入地研究数据加载的主要部分，从 CPU 对示例的处理向后追溯到从存储中读取数据的实际 IO。

在这篇文章中，我们不会讨论将数据从 RAM 移动到 GPU (5)的步骤，尽管这也很重要，并且有多种优化，如 PCIe、NVLink、固定内存等。

阶段 3 —从原始输入示例到训练示例

GPU 期望为它的小批量接收张量。
然而，通常我们从存储器中加载的不是张量，而是数据的其他二进制表示，例如. jpg 文件。

在简单的情况下，将原始输入示例转换为定型示例就像将. jpg 解码为像素一样简单。在其他情况下，我们会进行各种变换(例如下采样)和增强。

转换甚至可以包括原始输入示例和训练示例之间的多对多关系。天空是极限，但当然，所有这些都花费了我们在 CPU 上的时间。

还有一个需要考虑的内存占用，特别是如果您不能在数据仍处于压缩形式时对其进行缩减采样，但我们现在将把这个问题放在一边。

来源:相册项目(麻省理工学院许可)

如果您的处理量很大，您可以通过提前批量处理，并将处理过的示例存储在磁盘上来进行优化，从而减少 CPU，甚至减少磁盘上的文件大小。

阶段 2 —从存储中加载示例

在大多数情况下，I/O 是数据加载的最大成本。
一般情况下我们需要注意的存储参数有:

• 以 GB 为单位的存储总大小=基于我们的训练集大小
• 读取 IOPS = n/t(假设 CPU 处理时间可以忽略不计)
• 块大小(=磁盘上的典型示例大小，以 MB 为单位，表示为 es)
• 读取带宽(MB/s) = es * n/t

注意:如果我们考虑使用共享存储进行多个并发实验:

• 对于训练数据的总大小(以 GB 为单位)-对您计划训练的所有数据集使用联合
• 从您计划的训练负荷中选择一个具有挑战性的组合 t，n，es
• *使用 n = #并发实验 典型批量

示例——四个 v100 训练图像网络和 Resnet 50

• 总数据集大小 = ~150 GB
• n = 1284 = 512*
• t = 0.087
• es = 469x387 像素 jpg，说 64 KB 。

结果:

• IOPS = 512/0.087 = 5885
• 块大小 = 64 KB
• 读取带宽 = 367 MB/s

这些要求适合现代 SSD 存储设备。
为了在旋转的磁盘上实现类似的性能，我们需要同时将负载分散到大约 45 个磁盘上。

现代旋转磁盘的 IOPS 和块大小。来源:wikipedia.com

当你是一名研究人员，在几十 GB 的稳定数据集上训练网络时，本地 SSD 驱动器是你的朋友。它们并不昂贵，您可以在合理的时间内获得它们的数据，并且您可以获得很好的性能，而无需过多考虑 I/O。

随着您的培训操作扩展存储

当您有一个由 15 名工程师和研究人员组成的团队，在一个训练集群上同时运行数十个实验，并且每月利用数 TB 的训练数据时，会发生什么？

在训练之前将数据集复制到连接的存储设备(例如本地磁盘或块设备)实际上不是一个选项。

• 要么是数据太大，要么是复制时间太长
• 如果您在集群上进行培训，您需要能够轻松地“移动”机器，而使用附加存储则无法做到这一点。

较大的 DL 培训操作需要远程存储解决方案，该解决方案通过使用来自培训机器的 API 来“安装”或访问。

典型的解决方案包括结合 HDD 和 SSD 的横向扩展 NAS 存储。这些解决方案以高吞吐量提供并行读取，并且在许多情况下，延迟是可接受的。

来源: AWS 文档 ( 许可证)

体面的 NFS 可以处理更大的文件和宽松的延迟

让我们来看看一个理论上的 DL 商店的储物需求:

• 5tb 到 10 TB 的数据(仅活动使用的数据)
• 5-10 个同时进行的实验
• 每个实验的 GPU 数量= 4
• n = 单个 GPU= 64
• es = 500K
• t = 2s(重网)

这将需要:

• IOPS—640–1280
• 读取带宽 — 600 MB/s — 1.28 GB/s

在云上，这种类型的性能可以通过 NFS 存储产品实现，例如 GCP 文件存储 或AWS EFS。****

小输入/短延迟是一个代价高昂的问题

存储有一个众所周知的问题，叫做“小文件问题”。本质上，这意味着进行快速随机访问和返回小块是昂贵的。

这里有一个例子:

• 5tb 到 10 TB 的数据(仅活动使用的数据)
• 5-10 个同时进行的实验
• 每个实验的 GPU 数量= 4
• n = 单个 GPU= 256
• es=64K
• t= 0.2s

这将需要:

• IOPS = 25600–51200
• 读取带宽= 1.6–3.2 GB/秒

在标准 NFS 解决方案中，非常快速地加载许多小文件是有问题的——您要么需要将数据分布在大量驱动器上，要么使用昂贵的 SSD 阵列和其他高端解决方案

了解工作负载特征

从存储的角度来看，用于培训的数据加载有一组非常独特的特征:

• 单个“原始输入示例”的大小可能会因数据的形态而有很大的不同，从每个原始输入示例几十 K 到几 MB 不等。
• 数据被“批量”读取、处理和写入，然后被多次读取
• 对于延迟峰值，读取稍微宽松一些，更关心吞吐量
• 数据是“随机”访问的，因为小批量会打乱每个小批量中包含的示例
• 一旦读取了单个数据示例数据，几乎可以保证它会在相对较短的时间框架(每个时期)内被反复读取

这些可以用来以创造性的方式优化存储。

利用负载特征优化存储

要优化存储解决方案，请考虑使用以下部分或全部方法:

首先-使用紧凑的表示格式，这将尽可能减小单个示例的大小。如果数据将在一秒钟后被向下采样，则不需要支持高带宽！

第二，您可以使用本地的部分缓存解决方案(例如 SSD)，利用未来时代的缓存命中保证。如果您能够以这种方式随机缓存 20%的数据集(惰性)，那么您可以轻松获得加速。

最后—尝试从非常短的延迟/许多随机 IOPS 转向更长的延迟和顺序读取。

坦率地说，应该避免上面讨论的极端情况(非常短的延迟，许多小的随机 IOPS)—例如，通过使用较弱的 GPU，或者通过在不同的培训工作之间共享 GPU。

但是，即使对于更温和的情况——如果我们可以在磁盘上批量处理例子，会怎么样呢？我们将依次读取 1 个较大的文件，而不是读取个小文件并进行多次寻道？**

这是一个吸引人的想法；挑战在于支持每个时期的随机洗牌——但事实证明，如果你足够努力，这是可以解决的…

在不久的将来，我会试着在另一篇文章中讨论这些问题。

摘要

保持 GPU 的充分利用需要了解和优化数据加载路径-从磁盘到 GPU 内存。

这样做的细节取决于各种参数，如数据的大小，以及您拥有的计算资源和您正在训练的网络。

在这篇文章中，我试图介绍数据加载流程和优化的基础知识，并提供一些解决方案。

请继续关注下一期文章，它将关注存储优化技术。

感到沮丧和不知所措？管理数据科学中具有挑战性的学习过程的九个技巧

原文：https://towardsdatascience.com/feeling-frustrated-and-overwhelmed-1bbdec5c68eb?source=collection_archive---------18-----------------------

数据科学讨论

根据我的个人经验，我提出了九个策略来开始在数据科学的广阔世界中前进，而不会被它所压制。

克里斯托夫·奥特在 Unsplash 上拍摄的照片

正如我们所知，数据科学家的工作需要很多技能，包括统计和数学概念、可视化技能和编程知识。对于一个初学者来说，所有这些要求都可能是一个障碍。事实上，人们可能会想甚至没有迈出第一步就离开。

在这篇文章中，我描述了我的经历，以及我是如何开始在数据科学的巨大丛林中迈出第一步的。基本上，通过遵循九个简单的步骤，并有很大的耐心，你可以成为一名(好的)数据科学家。

乌代·米塔尔在 Unsplash 上拍摄的照片

在开始数据科学家的旅程之前

在我们进入数据科学的世界，然后将我将描述的技巧付诸实践之前，还有一场更大的战斗要打。

第一场真正的战斗是对抗焦虑。是的，因为有太多的工作要做，你可能会认为你必须马上以最好的方式做每一件事。

事实上，这是我对数据科学的第一次影响:我想知道如何做每件事，甚至在开始之前。

在开展数据科学家的工作时，我个人对以下情况感到焦虑:

• 数据集太复杂而无法分析 —尽管应用了许多预处理技术等，但数据集仍然庞大而复杂；
• 一个训练时间太长的机器学习算法——等待结果让人伤脑筋；
• 即将到来的截止日期和仍然部分的结果；
• 一段不工作的代码——花费数小时试图让代码工作或找到一个问题的解决方案令人沮丧，可悲的是没有成功；
• 要学习的概念太多(尤其是关于统计和数学)，而学习的时间太少。

如果你在其他情况下经历过开始数据科学家之旅时的焦虑， 欢迎评论本文 。我很乐意用其他焦虑情况来更新之前的列表。

照片由 Francesco Dondi 在 Unsplash 上拍摄

九大秘诀

然后我就想，这种情况不能再继续下去了。我停下来思考了一下，最终我总结出了九条建议，并付诸实践，开始了数据科学家的旅程。

1 保持冷静！

开始学习过程的第一个方法是保持冷静。理论上这似乎是显而易见的，但实际上，也许这是最难应用的东西。

保持冷静是强者的美德。它需要强大的自制力，无尽的耐心和极大的节制。
保持冷静的关键，比如在学习一个复杂的统计概念之前，就是从情境中退出。只考虑现在，想象你的一生都在学习。

Ravi Pinisetti 在 Unsplash 上拍摄的照片

2 阅读和学习

成为一名优秀的数据科学家的另一个重要方面是对所涉及的主题有很好的了解。确定如何进行数据清理、分析等的唯一方法。，就是学习。

没有别的选择:我必须学习。

我不能不先发动引擎就开车离开。数据科学家的工作也是如此。如果我首先没有一些理论知识，我是无法训练出一个模型的。

学习技巧可以有所不同:你可以拿一本手册来学习，你可以阅读关于它的文章等等。就我个人而言，我更喜欢阅读有趣的文章和测试示例，因为只有通过实践才能学到东西。

从我的经验来看，在一门学科的知识上取得进步的唯一方法是留出时间来学习，不管是每天一小时还是每周一小时。重要的是这个时间是存在的。当然，花在学习上的时间不是浪费时间，相反，它有助于快速进步。

照片由 Aaron Burden 在 Unsplash

3 寻求帮助

在电脑上工作时，我们经常忘记我们并不孤单。很多时候我花了很多时间在谷歌上搜索解决方案，有时成功，有时不成功。

事实上，其他人可能已经准备好了解决问题的方法，这对我们来说似乎是不可克服的。

随着时间的推移，我了解到有许多数据科学家社区，他们非常愿意在困难的时候帮助我。

例如，在 Quora 、 Stackoverflow 、 Reddit 、 Linkedin 以及所有社交网络上都有数据科学社区。随便问！

照片由 Hannah Busing 在 Unsplash 上拍摄

4 组织工作

为了消除焦虑，另一个基本要素是工作的组织。

随着时间的推移，我明白了一张纸比云上的一千份文件更有价值，因为它能让我接触(并用眼睛聚焦)所有要做的事情。

基本上，我拿了一本旧日记，开始逐月记下所有要做的事情。我认为每一项数据科学任务都是需要做和学习的事情。我用黄色突出显示了每个已完成的任务。看到日记渐渐变黄，多么令人满意！

由于有了议程，我对各种主题的知识逐渐增加，因为一切都在掌控之中，组织今天和明天要做的工作变得更容易了。

埃斯特扬森斯在 Unsplash 拍摄的照片

测量我的力量

经常被做这么多事情的热情淹没，开始了太多的数据科学活动或项目，最终陷入了不成功的焦虑。

从这些经历中，我学会了衡量自己的力量，在工作量和我实际能做的事情以及我可用的时间之间找到平衡。

这与是否具备启动新数据科学项目或新业务的技能无关。相反，这是一个衡量自己实力的问题，以避免仓促行事和重新陷入失败。

由马修·查萨拉在 Unsplash 上拍摄的照片

不要对自己期望太高

与上一点密切相关的是不要对自己期望过高。说实话，我有时发现自己对自己的要求超出了我当时所能给予的。

生活中有些时候你表现得更好，有些时候你进展得更慢。重要的是永远不要停下来。尽管如此，即使一会儿，你走得更慢。

例如，如果我的技能没有超越 Excel，我就不能期望做出漂亮的 Mike Bostock 可视化！

铁木尔·罗马诺夫在 Unsplash 上的照片

7 优化时间

数据科学家职业生涯的另一个重要步骤是优化时间。数据科学家工作流程中的一些任务需要很长时间，例如训练模型。在这种情况下，不建议每五分钟检查一次任务是否完成。在等待的过程中，我决定用不同的方式来安排时间，正如我在这篇题为如何在等待数据分析输出的时候度过时间的文章中所解释的那样。

另外，我意识到有多种技术可以加速代码，这样所有操作都加快了速度。在这篇文章中，我描述了三个技巧来加速和优化你的 python。

由阿格巴洛斯在 Unsplash 上拍摄的照片

8 休息一下

在某些情况下，避免沮丧的最简单方法就是休息一下。

一杯咖啡、一次散步或深呼吸可以帮助你从另一个角度看待现实。

在很多情况下，我发现自己解决问题的方法只是想一会儿别的事情，然后带着清晰的头脑回到这个问题上。以我的经验来看，获得一段不起作用的代码的最好方法是拔掉电源插头一会儿，从电脑前站起来，哪怕只是看看窗外。回到电脑前，问题突然变小了，挫败感消失了，问题也消失了。

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

9 接受现实的本来面目

如果真的无法开始数据科学家的职业生涯怎么办？？还有最后一次机会。这是关于接受现实。

我什么意思？我举个例子。

让我们想象一下，我们试图研究机器学习算法背后的概念，却什么也没有理解。我们再想象一下，你努力学习 Python，却连 Hello World 这句话都不会写！

好吧，有什么办法呢？绝望？肯定不是。不值得。

我将尝试关注数据科学的另一个方面，可能是数据可视化和数据收集。数据科学如此广阔，每个人都有适合自己的东西。

找不到任何适合自己的数据科学领域怎么办？我知道这不是适合我的职业，最好去找其他的职业。

托拜厄斯·比约克内斯在 Unsplash 上的照片

摘要

在本文中，我分享了我的个人经验，即管理数据科学中具有挑战性的学习过程的九个技巧。

如果你在阅读方面已经走了这么远，这意味着你有时也会考虑放弃数据科学家的职业。我希望通过实践这九个技巧，你也能成为一名优秀的数据科学家。

如果你想分享你的经验，欢迎在评论中写下。我很乐意回答你！

如果你已经走了这么远来阅读，对我来说今天已经很多了。谢谢！你可以在这篇文章中读到更多关于我的信息。

你愿意支持我的研究吗？

你可以每月订阅几美元，解锁无限的文章——点击这里。

相关文章

https://medium.com/geekculture/is-the-semantic-web-really-dead-7113cfd1f573

一个额外的提示

实际上，还有最后一个，也是第十个建议，我可以建议你付诸实践，开始你的数据科学家之旅:

既然你不可能知道所有的事情，那么最好的办法就是对数据科学这个广阔的领域有一个大概的了解，但是然后只关注一个很小的领域。

从托莱多的 OSM 数据中提取绿色区域

原文：https://towardsdatascience.com/fetching-green-areas-from-osm-data-a6ff835c40dc?source=collection_archive---------18-----------------------

如何使用 OSMnx 以几何图形的形式检索公园

图片由作者提供。OSM 数据托莱多市中心(建筑、道路、公园)

我在赫尔辛基大学的自动化 GIS 课程中担任研究助理的经历非常棒。我支持学生的任务，提供 GIS 流程自动化方面的提示。我很高兴看到地理学家是如何用 python 脚本接管地理空间分析的。这些课结束了，但学到的东西还在。我想保留的一个类是由 Geoff Boeing 创建的 python 库 OSMnx 的用法。多亏了这个图书馆，从世界各地的城市获取街道网络成为可能。此外，还可以获取其他元素，如本编码实践所示。我在这里展示了一个关于如何绘制绿色区域和街道网络的简短教程。

如果你有兴趣从 OSM 找到更多的几何物体，你可以仔细查看 OSM 维基上的建筑标签。您可以使用标签来检索咖啡馆、市场、停车场等。另一个有用的网站是 OSM 域名，在那里你可以找到你想要从 OSMnx 中检索数据的地方的名称。因此，不要怀疑测试它与您想要的城市，不要忘记分享您的地图。我会很高兴看到你的作品。我在这种情况下是托莱多。

找到此回购中的材料:获取 OSM

编码实践

首先，您将导入库

**import** osmnx **as** ox
**import** matplotlib.pyplot **as** plt

然后你从 OSM 命名中指定位置并想象这个区域。

**# Specify the name that is used to seach for the data**
place_name = “ Toledo, Castile-La Mancha, Spain”**# Fetch OSM street network from the location**
graph = ox.graph_from_place(place_name)**# Plot the streets**
fig, ax = ox.plot_graph(graph)

由作者想象。托莱多的曲线图

将边(街道网络)放入地理数据框架

**# Retrieve nodes and edges**
nodes, edges = ox.graph_to_gdfs(graph)

将地名(Toledo)放入地理数据框架

**# Get place boundary related to the place name as a geodataframe**
area = ox.geocode_to_gdf(place_name)area.plot();

图片由作者提供。托莱多行政单位

获取带有标签和地名的建筑物几何图形作为地理数据框

**# List key-value pairs for tags**
tags = {‘building’: True}buildings = ox.geometries_from_place(place_name, tags)

绿色区域/公园的标签很棘手，但希望你能在 OSM 维基中找到你需要的所有对象。现在，让我们把绿色区域作为地理数据框架

**# List key-value pairs for tags**
tags = {‘leisure’: ‘park’, ‘landuse’: ‘grass’}**# Get the data**
parks = ox.geometries_from_place(place_name, tags)parks.plot(color="green");

现在我们一起来出图。在整个地区。

fig, ax = plt.subplots(figsize=(12,8))**# Plot the footprint**
area.plot(ax=ax, facecolor=’black’, zorder=0)**# Plot street edges**
edges.plot(ax=ax, linewidth=0.5, edgecolor=’dimgray’, zorder=1)**# Plot buildings**
buildings.plot(ax=ax, facecolor=’silver’, alpha=0.7, zorder=2)**# Plot parks
parks.plot(ax=ax, color=’green’, alpha=0.7, markersize=10, zorder=3)**plt.tight_layout()
plt.axis(‘off’)

图片由作者提供。获取 OSM 数据的托莱多

由于我们注意到区域太大，所以我们将 xlim 和 ylim 指定到市中心，以便以更好的方式可视化 OSM 数据。只需在此之前添加到单元格的末尾

plt.xlim((-4.05, -4.01))
plt.ylim((39.89, 39.85))

图片由作者提供。获取 OSM 数据的托莱多市中心

您可以保存地理数据框，并根据自己的喜好和设计创建地图。主要有:edges、area、parks和buildings

结论

OSMnx 确实可以方便地获取街道网络。它的特别之处在于，您可以在分析中包含大量的几何对象选项。像医院、公园、市场、咖啡馆、餐馆或不同种类的建筑。OSM 维基会给你线索。我希望这是有用的。学习好；)

使用 Python 获取手机号码详细信息

原文：https://towardsdatascience.com/fetching-mobile-number-details-using-python-79077c2ae4f0?source=collection_archive---------12-----------------------

使用电话号码检索手机号码详情

照片由奎诺·阿尔在 Unsplash 上拍摄

Python 是一种非常丰富的语言，因为它提供了大量的库。它包含多种功能，有助于解决现实生活中的业务问题。今天我们将讨论这样一个库。

Phonenumbers 是一个开源 Python 库，用于访问电话号码的信息。它还有助于验证电话号码、解析电话号码等。

在这篇文章中，我们将探索电话号码及其功能。

让我们开始吧…

安装所需的库

我们将从使用 pip 安装来安装 Phonenumbers 开始。下面给出的命令将使用 pip 安装 Phonenumbers。

pip install phonenumbers

导入所需的库

在这一步中，我们将导入访问电话号码信息所需的所有库。

import phonenumbers
from phonenumbers import carrier, geocoder, timezone

访问关于电话号码的信息

现在，我们将访问我们想要的任何电话号码的信息，我们需要传递国家代码，后跟电话号码，它将显示该号码的详细信息。

mobileNo=input("Mobile no. with country code:")
mobileNo=phonenumbers.parse(mobileNo)
print(timezone.time_zones_for_number(mobileNo))
print(carrier.name_for_number(mobileNo,"en"))
print(geocoder.description_for_number(mobileNo,"en"))
print("Valid Mobile Number:",phonenumbers.is_valid_number(mobileNo))
print("Checking possibility of Number:",phonenumbers.is_possible_number(mobileNo))

信息(来源:作者)

在这里，您可以看到与我们提供的号码相关的信息是如何显示的。同样的，你也可以针对不同的手机号码进行查看。

接下来，让我们看看如何从文本中解析电话号码，以及如何格式化它。下面给出的代码将执行这些操作。

text = "Call me at 1800-202-2022 if it's before 9:30, or on 703-4800500 after 10am."
for match in phonenumbers.PhoneNumberMatcher(text, "US"):
    print(match)
x = phonenumbers.parse("+442083661177", None)
phonenumbers.format_number(x, phonenumbers.PhoneNumberFormat.NATIONAL)

解析(来源:作者)

尝试用不同的文本和数字来解析数据和格式化电话号码。您可以在任何实际项目或问题中轻松实现这一点。在回复部分让我知道你对这个库的看法。

本文是与皮尤什·英加尔合作完成的。

在你走之前

感谢 的阅读！如果你想与我取得联系，请随时通过 hmix13@gmail.com 联系我或我的 LinkedIn 个人资料 。可以查看我的Github简介针对不同的数据科学项目和包教程。还有，随意探索 我的简介 ，阅读我写过的与数据科学相关的不同文章。

Python 中的斐波那契回撤

原文：https://towardsdatascience.com/fibonacci-retracements-in-python-470eb33b6362?source=collection_archive---------10-----------------------

让我们看看如何用 Python 计算这个强大的技术指标

斐波那契回撤的例子。作者图片

量化交易者总是根据技术指标和高级图表寻找交易机会。交易者寻找的最好的指标之一是价格可能反弹的关键水平。其中一些水平是斐波纳契回撤。让我们看看它们是如何工作的。

什么是斐波那契回撤？

斐波纳契回撤是根据两次摆动计算的特殊关键水平，即反转点。斐波那契回撤背后的想法是根据预先定义的分数，在这两个波动之间的价格范围内创建一些关键水平。最重要的分数是 0.618，与黄金分割比(1.618…)有关。这就是为什么它们被称为斐波那契回撤。其他比值为 0.5，0.236，0.382，0.786。

这里有一个斐波纳契回撤的例子:

斐波那契回撤的例子。图片作者。

第一秋千与第二秋千相连。由于第二次摆动高于第一次，因此趋势看涨。然后，从第二次摆动开始，我们根据我们想要使用的分数的需要画尽可能多的水平线。我们只需减去幅度乘以目标分数。如果趋势是看跌的，我们就要加上这样一个分数。第一个摆幅总是与 1 分数相关，第二个摆幅与 0 分数相关。

它们是如何使用的？

因为它们是关键水平，所以它们可以用于，例如，均值回复策略。从上图可以看出，价格已经反弹到 0.618 水平附近。因此，我们的想法是在水平附近寻找反转模式，以便尝试利用反转。

斐波纳契回撤在交易者中非常受欢迎，为了提高回报/风险比，在很宽的时间范围内使用这个工具非常重要。显然，这个工具不能单独使用，但是我们需要建立一个完整的策略，例如，利用多时间框架分析。

现在让我们看看如何使用 Python 计算斐波那契级数。下面的代码可以在我这里的 GitHub 储存库中找到:https://GitHub . com/gianlucamalato/machine learning/blob/master/Fibonacci _ retracements . ipynb

Python 中的示例

我们先安装 yfinance 库

!pip install yfinance

然后，让我们导入将要使用的库。

import yfinance
import pandas as pdimport matplotlib.pyplot as plt

现在，对于这个例子，让我们导入黄金(GLD)从 2020 年 7 月 1 日到 2021 年 3 月 1 日的每日数据。

name = "GLD"ticker = yfinance.Ticker(name)
df = ticker.history(interval="1d",start="2020-07-01",end="2021-03-01")

现在我们要计算最高和最低的摆动。这些波动将通过第二根蜡烛线的指数来识别。

highest_swing = -1
lowest_swing = -1for i in range(1,df.shape[0]-1):
  if df['High'][i] > df['High'][i-1] and df['High'][i] > df['High'][i+1] and (highest_swing == -1 or df['High'][i] > df['High'][highest_swing]):
    highest_swing = iif df['Low'][i] < df['Low'][i-1] and df['Low'][i] < df['Low'][i+1] and (lowest_swing == -1 or df['Low'][i] < df['Low'][lowest_swing]):
    lowest_swing = i

现在让我们创建一个列表，其中包含与要显示的级别和颜色相关的分数。最后，我们可以计算等级本身。

如果最高的振幅紧挨着最低的振幅，我们有一个上升趋势，否则，我们有一个下降趋势。这有助于在正确的方向上绘制标高。

ratios = [0,0.236, 0.382, 0.5 , 0.618, 0.786,1]
colors = ["black","r","g","b","cyan","magenta","yellow"]
levels = []max_level = df['High'][highest_swing]
min_level = df['Low'][lowest_swing]for ratio in ratios:
  if highest_swing > lowest_swing: # Uptrend
    levels.append(max_level - (max_level-min_level)*ratio)
  else: # Downtrend
    levels.append(min_level + (max_level-min_level)*ratio)

现在我们有了绘制价格和斐波纳契回撤线图的所有要素。

plt.rcParams['figure.figsize'] = [12, 7]plt.rc('font', size=14)plt.plot(df['Close'])
start_date = df.index[min(highest_swing,lowest_swing)]
end_date = df.index[max(highest_swing,lowest_swing)]
for i in range(len(levels)):plt.hlines(levels[i],start_date, end_date,label="{:.1f}%".format(ratios[i]*100),colors=colors[i], linestyles="dashed")plt.legend()
plt.show()

作者图片

正如我们所看到的，趋势是看跌的(100%水平高于 0%水平)，在价格反弹之前，61.8%水平已经被触及两次。

结论

斐波纳契回撤对于量化交易者来说是非常有用的工具。它们很容易阅读和计算，是交易者策略中非常有用的工具。再次强调，首先测试你的策略并引入更多的规则是很重要的，例如，基于多时间段的分析。

Gianluca Malato 是意大利数据科学家和小说作家。他是数据科学、机器学习和数据分析在线学校【YourDataTeacher.com】的创始人。

参考

[1]吉安卢卡·马拉托。风险/回报比:超越神话的真相。https://medium . com/the-trading-scientist/risk-reward-ratio-the-truth-beyond-the-myth-22a 00 c 258 b 83

来自《走向数据科学》编辑的提示: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们并不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。

国际足联终极团队机器学习项目

原文：https://towardsdatascience.com/fifa-ultimate-team-rating-prediction-machine-learning-project-3a02767fcb38?source=collection_archive---------18-----------------------

一个端到端的 ML 项目，预测一个球员在国际足联终极队的评级

古列尔莫·巴西尔在 Unsplash 上拍摄的照片

这个项目遵循 ML 顾问 Aurélien Géron 在机器学习端到端指南中概述的原则/步骤。

介绍

什么是机器学习？

机器学习(ML)是人工智能(AI)的一个子集，它使用计算机算法在大型数据集中寻找模式，而无需显式编程。ML 赋予计算机自我学习和改进的能力，以便它能够从数据中产生最佳模型。如今，许多应用程序都使用 ML，例如:

• 产品推荐
• 垃圾邮件检测器
• 恶意软件检测
• 人脸识别

这个项目是关于什么的？

从我记事起，我就一直在玩国际足联的游戏。我喜欢能够作为我最喜欢的足球运动员和球队踢球。虽然现在的游戏因为大部分是付费赢而名声不好，但我仍然发现自己很享受 FIFA 终极团队(FUT)和竞争性多人游戏的战利品。话虽如此，我一直想知道开发者如何决定玩家评级，然后我问自己，“机器也能做到吗？”。电子艺界(EA)的开发团队很可能使用 ML 模型来决定玩家评级，但这并没有阻止我建立自己的模型。这个项目是我试图创建一个 ML 模型，可以预测任何球员的总体评分。

我用 Google Colabs 来完成这个项目。

我们使用的是哪种数据？

我在 Kaggle 上找到了一个关于国际足联比赛的大型数据集。数据集由 FIFA 15 至 FIFA 20 的数据组成。我们将使用数据集中最新的国际足联游戏，即 FIFA 20。数据集可以从 Kaggle 下载。数据集由 18，278 行和 104 列组成。这些列包含诸如玩家姓名、年龄、身高、体重、国籍等特征。因为我们试图预测总体评分，所以我们只需要关注与总体评分相关的特性，但我们稍后会谈到这一点。

如何入门？

1.定义问题

任何 ML 工程师应该做的第一件事就是定义问题。对于这个项目，我们面临的问题是准确预测玩家评分，而不必硬编码算法，因此建立一个可行的 ML 模型应该是我们的最终目标。在 FIFA 20 中，一个球员的总得分是由每个球员属性的得分来定义的，例如速度、射门、传球、运球和许多其他属性。我们试图根据球员的进攻和防守属性来预测整体得分。数据已经带有标记的训练示例，这意味着我们正在处理一个监督学习问题。这也是一个典型的回归任务，因为我们的任务是预测一个值。更具体地说，这是一个多元回归问题，因为模型将使用多个特征来进行预测。

2.选择绩效评估

既然我们已经定义了问题，我们需要选择一个性能度量。我喜欢用均方根误差(RMSE)。这是回归问题的首选性能度量。RMSE 是衡量模型表现好坏的一个标准。它给出了一个系统在预测中有多大误差的概念。RMSE 是关于最佳拟合线的残差(预测误差)的计算。公式如下所示:

为了更多地了解 RMSE 及其运作方式，我推荐阅读这篇文章。

现在我们准备开始编码了！！！

3.导入库

我们需要做的第一件事是导入最常见的数据科学库，如 numpy 、 scipy 和 pandas 。我们还需要导入 matplotlib 和 seaborn 以便我们可以绘制图表来帮助我们可视化数据。

# Common imports
import numpy as np
import pandas as pd
import os
import seaborn as sns
from scipy import stats
import missingno as msno# To plot pretty figures
%matplotlib inline
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib import style
sns.set(style='ticks', color_codes=True)
sns.set(style='darkgrid')
import plotly.express as px# Ignore useless warnings (see SciPy issue #5998)import warnings
warnings.filterwarnings(action="ignore", message="^internal gelsd")
warnings.filterwarnings('always')
warnings.filterwarnings('ignore')

4.下载并浏览数据

我将数据集保存到我的 GitHub 存储库中，这样我可以更容易地下载数据集，而不必在我的机器上搜索它。如果数据不断变化，拥有在线下载数据的功能真的很有用。它还省去了必须在多台机器上安装数据集的麻烦。

import urllib.requestDOWNLOAD_ROOT = "https://raw.githubusercontent.com/jpzambranoleon/ML_Projects/master/"TRAIN_PATH = os.path.join("datasets", "players_20")
TRAIN_URL = DOWNLOAD_ROOT + "datasets/players_20.csv"def fetch_train_data(train_url=TRAIN_URL, train_path=TRAIN_PATH):
  os.makedirs(train_path, exist_ok=True)
  csv_path = os.path.join(train_path, "players_20.csv")
  urllib.request.urlretrieve(train_url, csv_path)

fetch_train_data() 函数用于获取数据集。

fetch_train_data()

数据集被下载并保存在文件夹数据集和玩家 _20 下的 Google Colabs 的文件部分。现在剩下要做的就是将数据加载到 pandas 数据框架中。幸运的是，我们可以创建一个函数来返回 pandas DataFrame 对象。

import pandas as pddef load_train_data(train_path=TRAIN_PATH):
  csv_path = os.path.join(train_path, "players_20.csv")
  return pd.read_csv(csv_path)

我将 load_train_data() 函数调用到 player_data 变量中，将数据帧保存到一个变量中，以使事情变得更简单。DataFrame 的 head() 方法用于查看数据的前五行。

player_data = load_train_data()
player_data.head()

显示前 5 行。

我使用了 shape 方法来返回一个表示数据帧维度的元组。通过使用 shape 方法，我们可以看到数据集中有多少行和列。

player_data.shape**(18278, 104)**

正如我们从元组中看到的，数据集有 18，278 行和 104 列。我们不需要使用所有的列，所以最好截断数据帧，只包含目标列和玩家统计数据列。有 34 个球员统计栏，所以我们需要选择它们。

#player stat features
columns = ['overall','attacking_crossing', 'attacking_finishing', 'attacking_heading_accuracy', 'attacking_short_passing', 'attacking_volleys', 'skill_dribbling', 'skill_curve', 'skill_fk_accuracy', 'skill_long_passing', 'skill_ball_control', 'movement_acceleration', 'movement_sprint_speed', 'movement_agility', 'movement_reactions', 'movement_balance', 'power_shot_power', 'power_jumping', 'power_stamina', 'power_strength', 'power_long_shots', 'mentality_aggression', 'mentality_interceptions', 'mentality_positioning', 'mentality_vision', 'mentality_penalties', 'mentality_composure', 'defending_marking', 'defending_standing_tackle', 'defending_sliding_tackle', 'goalkeeping_diving', 'goalkeeping_handling', 'goalkeeping_kicking', 'goalkeeping_positioning', 'goalkeeping_reflexes']player_df = player_data[columns]player_df.head()

显示新数据框中的前 5 行。

我在新的数据帧上使用了 info() 方法来快速描述数据。

player_df.info()

我们可以从数据中看到，数据帧中有 18，278 个非空值，这意味着我们不必担心丢失值。

为了获得数据的统计描述，我们可以使用 describe() 方法。

player_df.describe()

为了更好的测量，让我们再次使用 shape 方法来查看新数据帧的维度。

player_df.shape**(18278, 35)**

感受数据的另一个好方法是绘制每个数字属性的直方图。要绘制每个属性的直方图，只需在 DataFrame 上调用 hist() 方法。 hist() 方法需要 matplotlib 库。您可以为每个直方图指定仓的数量，也可以指定图形的大小。我选择了 40 个箱子和(27，17)的尺寸，但是这完全取决于你。直方图很有用，因为它们显示了具有给定值范围(x 轴)的实例(y 轴)的数量。

player_df.hist(bins=40, figsize=(27,17))
plt.show()

从图中可以看出，每个直方图的取值范围是 0 到 100。这很好地表明了每个属性都具有相同的比例，这意味着我们不必进行任何要素比例变换。

为了更好地实践，我喜欢完全确定数据中没有丢失的值，所以我使用了 isna()。any() 方法返回关于数据是否有缺失值的 True 或 False 语句。

player_df.isna().any()

正如我们从输出中看到的，每个属性的返回值都是 False，这意味着没有丢失值。我们准备继续！！！

5.将数据分成训练集和测试集

探索完数据后，我们需要做的下一件事是将数据分成训练集和测试集。我们可以自己拆分数据，或者创建一个函数来完成这项工作。幸运的是，Scikit-Learn 有一个很酷的功能，可以将数据集分成训练集和测试集。 train_test_split() 函数可以很容易地将数据拆分成我们需要的集合。我设置 test_size=0.2 ，这样 20%的数据存储在测试集中。另外 80%的数据存储在训练集中。训练集应该有更多的数据，因为它是模型学习的对象。测试集将是我们用来验证模型的集。

from sklearn.model_selection import train_test_splittrain_set, test_set = train_test_split(player_df, test_size=0.2, random_state=42)print("Length of training data:", len(train_set))
print("Length of testing data:", len(test_set))
print("Length of total data:", len(player_df))**Length of training data: 14622 
Length of testing data: 3656 
Length of total data: 18278**

6.寻找相关性

您可以使用 corr() 方法计算每对属性之间的标准相关系数。查看每个属性之间的所有相关性会占用太多时间，所以让我们只查看每个属性与整体值的相关程度。

fifa_df = train_set.copy()corr_matrix = fifa_df.corr()corr_matrix['overall'].sort_values(ascending=False)

相关系数范围从-1 到 1。当相关系数接近 1 时，说明有很强的正相关性；例如，当运动反应上升时，整体倾向于上升。当相关系数接近-1 时，意味着存在强负相关(即与强正相关相反)。

为了可视化属性之间的相关性，我们可以使用 pandas scatter_matrix() 函数。该函数将每个数值属性与其他数值属性进行对比。让我们来看看前五个有希望的属性，因为有 35 个数字属性。

from pandas.plotting import scatter_matrixattributes = [‘overall’, ‘movement_reactions’, ‘mentality_composure’, ‘power_shot_power’, ‘mentality_vision’]scatter_matrix(fifa_df[attributes], figsize=(15,12))plt.show()

强相关关系往往是线性的，因此总体预测最有希望的属性是运动反应。从图中我们可以看出，运动反应和整体有很强的线性关系。

让我们仔细看看相关性散点图。

fifa_df.plot(kind=’scatter’, x=’movement_reactions’, y=’overall’, alpha=0.1, color=’red’)plt.show()

相关性确实很强；你可以清楚地看到一个上升趋势。

现在，是时候为 ML 算法准备数据了。

7.为 ML 算法准备数据

我将训练集和测试集分成独立的功能集和目标集。数据帧 y_train 和 y_test 包含目标值(目标值为整体)，而 X_train 和 X_test 包含特征值(与目标值相关的所有其他属性)。

y_train = train_set['overall']
X_train = train_set.drop('overall', axis=1)
y_test = test_set['overall']
X_test = test_set.drop('overall', axis=1)

8.选择并训练一个模型

让我们首先使用 Scikit-Learn 的 LinearRegression() 函数训练一个线性回归模型:

from sklearn.linear_model import LinearRegressionlin_reg = LinearRegression()
lin_reg.fit(X_train, y_train)

让我们使用 Scikit-Learn 的 mean_square_error() 函数测量整个训练集上回归模型的 RMSE:

from sklearn.metrics import mean_squared_errory_predictions = lin_reg.predict(X_train)
lin_mse = mean_squared_error(y_train, y_predictions)
lin_rmse = np.sqrt(lin_mse)
lin_rmse**2.493574884183225**

分数还不错！！！似乎线性回归模型可以做到这一点。从散布矩阵中我们可以看出，并不是每个属性都有线性关系。对于非线性关系，我们需要一个更强大的模型，所以让我们训练一个决策树回归模型。这是一个强大的模型，能够发现数据中复杂的非线性关系。让我们使用 Scikit-Learn 的 DecisionTreeRegressor() 函数:

from sklearn.tree import DecisionTreeRegressortree_reg = DecisionTreeRegressor()
atree_reg.fit(X_train, y_train)

让我们再次测量模型的 RMSE:

y_predictions = tree_reg.predict(X_train)
tree_mse = mean_squared_error(y_train, y_predictions)
tree_rmse = np.sqrt(tree_mse)
tree_rmse**0.0**

什么？！0.0 的 RMSE！！！这是一个完美的模型吗？

实际上，可能是这个模型严重地过度拟合了数据。这就是为什么在每一个 ML 项目中，执行模型验证是很重要的，但是我们将在后面讨论。

现在，让我们只训练我们的最终模型，这是一个随机森林回归模型。

我们可以使用 Scikit-Learn 的 RandomForestRegressor() 函数训练一个随机森林回归模型:

from sklearn.ensemble import RandomForestRegressorforest_reg = RandomForestRegressor()
forest_reg.fit(X_train, y_train)

让我们看看这个模型的 RMSE:

y_predictions = forest_reg.predict(X_train)
forest_mse = mean_squared_error(y_train, y_predictions)
forest_rmse = np.sqrt(forest_mse)
forest_rmse**0.4774070457668509**

这是一个比我们的线性回归模型更好的分数，但不如我们的决策树模型。同样，这可能是我们的决策树模型严重过度拟合数据，这就是为什么我们总是需要在选择最佳模型之前验证每个模型。验证模型准确性的一个简单方法是使用 Scikit-Learn 的 K-fold 交叉验证功能。交叉验证将训练集随机分为 10 个不同的子集，称为折叠，然后它训练和评估模型 10 次，每次选择不同的折叠进行评估，并在 9 个折叠上进行训练。结果是一个包含 10 个评估分数的数组。在选择最佳模型之前，我们需要看一下平均验证分数。

让我们看看线性回归模型的交叉验证分数:

from sklearn.model_selection import cross_val_scorescores = cross_val_score(lin_reg, X_train, y_train,scoring='neg_mean_squared_error', cv=10)lin_reg_scores = np.sqrt(-scores)def display_scores(scores):
  print("Scores:", scores)
  print("Mean:", scores.mean())
  print("Standard Deviation:", scores.std())display_scores(lin_reg_scores)**Scores: [2.48985397 2.509888   2.50910312 2.4642167  2.46189444 2.51445854  2.48370267 2.4734443  2.48382446 2.59475861] 
Mean: 2.4985144826450054 
Standard Deviation: 0.03662607159427437**

现在让我们看看决策树模型的交叉验证分数:

scores = cross_val_score(tree_reg, X_train, y_train,scoring='neg_mean_squared_error', cv=10)tree_scores = np.sqrt(-scores)display_scores(tree_scores)**Scores: [2.03976196 2.10100389 2.24933491 2.18751588 2.13289653 2.1158318  2.10529916 2.08391009 2.30935171 2.15395796] 
Mean: 2.147886387907302 
Standard Deviation: 0.07682311253910523**

现在这是一个比第一个更可信的分数。它仍然优于我们的线性回归模型，但让我们看看我们的随机森林模型的交叉验证分数:

scores = cross_val_score(forest_reg, X_train, y_train,scoring='neg_mean_squared_error', cv=10)forest_scores = np.sqrt(-scores)display_scores(forest_scores)**Scores: [1.29156727 1.24883845 1.2625419  1.288613   1.22436926 1.30612055  1.25621857 1.24755531 1.30399247 1.28656714] 
Mean: 1.2716383911151843 
Standard Deviation: 0.026074298378757566**

哇！！！这可能是我们见过的最好成绩。随机森林看起来很有前途。这是我们将在项目中使用的模型。

9.微调模型

既然我们已经选择了我们的模型，我们需要微调它。微调要求我们手动调整超参数，直到找到超参数值的最佳组合。微调是非常繁琐的工作，如果数据集很大，可能需要很长时间。你可能甚至没有时间去探索许多组合。Scikit-Learn 提供了一个更简单的选项，而不是手动完成所有事情。

您应该使用 Scikit-Learn 的 GridSearchCV 来搜索您，而不是手动摆弄超参数。你需要做的就是告诉它你想让它试验哪些超参数，试验什么，它会用交叉验证来评估超参数值的所有可能组合。下面的代码提供了我用来试验的参数。

from sklearn.model_selection import GridSearchCVparam_grid = [{'n_estimators': [3, 10, 30], 'max_features': [2, 4, 6, 8]},{'bootstrap': [False], 'n_estimators': [3,10], 'max_features': [2,3,4]},]forest_reg = RandomForestRegressor() grid_search = GridSearchCV(forest_reg, param_grid, cv=5,scoring='neg_mean_squared_error',return_train_score=True) grid_search.fit(X_train, y_train)

训练完成后，你可以得到如下参数的最佳组合:

grid_search.best_params_**{'max_features': 8, 'n_estimators': 30}**

你也可以直接得到最佳估计量:

grid_search.best_estimator_**RandomForestRegressor(bootstrap=True, ccp_alpha=0.0, criterion='mse', max_depth=None, max_features=8, max_leaf_nodes=None, max_samples=None, min_impurity_decrease=0.0,                 min_impurity_split=None, min_samples_leaf=1,                     min_samples_split=2, min_weight_fraction_leaf=0.0,                       n_estimators=30, n_jobs=None, oob_score=False,                       random_state=None, verbose=0, warm_start=False)**

当然，您可以用任何超参数值进行实验，但是我认为目前这样就可以了。

10.在测试集上评估模型

在调整了训练集上的模型之后，终于到了在测试集上评估最终模型的时候了。这个过程非常相似，但是这一次我们需要指定最终模型的最佳估计量。同样，我们需要测量最终模型的性能。完成这项工作的代码如下:

final_model = grid_search.best_estimator_
final_predictions = final_model.predict(X_test)
final_mse = mean_squared_error(y_test, final_predictions)
final_rmse = np.sqrt(final_mse)
final_rmse**1.135337798136083**

这个分数是我们迄今为止看到的最好的，更不用说它还被用于模型以前没有见过的数据。老实说，我没想到模型会做得这么好，但我们不能假设 RMSE 永远是某个值。我们想知道这个估计有多精确。为此，您可以使用 scipy.stats.t.interval() 计算泛化错误的 95%置信区间:

confidence = 0.95squared_errors = (final_predictions - y_test)**2np.sqrt(stats.t.interval(confidence, len(squared_errors)-1,loc=squared_errors.mean(),
scale=stats.sem(squared_errors)))**array([1.10181563, 1.16789818])**

我们可以看到 RMSE 将在 1.10 和 1.17 之间

95%的时候。

我们已经基本上完成了这个模型，但是出于好奇，我们想看看预测和实际目标有什么不同。为此，只需从测试集中选择五个实例，并在最终模型上使用 predict() 方法:

some_data = X_test.iloc[:5]
some_label = y_test.iloc[:5]print("Predictions:", final_model.predict(some_data))
print("Labels:", list(some_label))**Predictions: [64.2    73.8     68.76666667 68.13333333 63.4     ] 
Labels: [64, 74, 69, 68, 63]**

预测相当准确。我很惊讶模型表现得这么好。我对结果非常满意。

结论

这个项目告诉我们，我们可以建立一个 ML 模型来预测一个球员的总体 FUT 评级。这个项目制作起来很有趣，我从中学到了很多。我对 ML 及其提供的所有可能性充满热情。我很高兴能在这个领域探索更多，并在这个过程中学习一切。我希望你喜欢这篇文章，也许有一天你可以开始自己的 ML 项目！！！