KDNuggets-博客中文翻译-十七-

KDNuggets 博客中文翻译（十七）

原文：KDNuggets

协议：CC BY-NC-SA 4.0

解释正态分布的 68-95-99.7 规则

原文：www.kdnuggets.com/2018/07/explaining-68-95-99-7-rule-normal-distribution.html

评论

作者 Michael Galarnyk，数据科学家

68% 的数据在一标准差内，95% 的数据在两标准差内，99.7% 的数据在三标准差内

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你所在组织的 IT

---

正态分布通常与68-95-99.7 规则相关，如上图所示。68% 的数据在均值（μ）的一标准差（σ）内，95% 的数据在均值（μ）两标准差（σ）内，99.7% 的数据在均值（μ）三标准差（σ）内。

本文解释了这些数字是如何得出的，希望它们能对你未来的工作更具解释性。如常所述，用于推导这些结果（包括图表）的代码可以在我的github上找到。接下来，我们开始吧！

概率密度函数

要理解百分比的来源，了解概率密度函数（PDF）是非常重要的。PDF 用于指定随机变量落在特定值范围内的概率，而不是取某个特定值。这个概率由该变量的 PDF 在该范围内的积分给出——也就是说，它由密度函数下方但在水平轴之上以及范围的最低值和最高值之间的面积给出。这个定义可能不太容易理解，因此让我们通过绘制正态分布的概率密度函数来澄清这一点。下面的方程是正态分布的概率密度函数

正态分布的 PDF

我们通过假设均值（μ）为 0 和标准差（σ）为 1 来简化问题。

正态分布的 PDF

既然函数更简单了，我们来绘制这个范围从-3 到 3 的函数图像。

# Import all libraries for the rest of the blog post
from scipy.integrate import quad
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-3, 3, num = 100)
constant = 1.0 / np.sqrt(2*np.pi)
pdf_normal_distribution = constant * np.exp((-x**2) / 2.0)
fig, ax = plt.subplots(figsize=(10, 5));
ax.plot(x, pdf_normal_distribution);
ax.set_ylim(0);
ax.set_title('Normal Distribution', size = 20);
ax.set_ylabel('Probability Density', size = 20);

上述图形并未显示事件的概率，而是它们的概率密度。要获取特定范围内事件的概率，我们需要进行积分。假设我们想找到一个随机数据点落在均值 1 个标准差范围内的概率，我们需要从-1 积分到 1。这可以通过 SciPy 完成。

# Make a PDF for the normal distribution a function
def normalProbabilityDensity(x):
    constant = 1.0 / np.sqrt(2*np.pi)
    return(constant * np.exp((-x**2) / 2.0) )
# Integrate PDF from -1 to 1
result, _ = quad(normalProbabilityDensity, -1, 1, limit = 1000)
print(result)

积分正态分布的 PDF 代码（左）和积分的可视化（右）。

68%的数据落在均值（μ）1 个标准差（σ）以内。

如果你想找到一个随机数据点落在均值的 2 个标准差范围内的概率，你需要从-2 积分到 2。

积分正态分布的 PDF 代码（左）和积分的可视化（右）。

95%的数据落在均值（μ）2 个标准差（σ）以内。

如果你想找到一个随机数据点落在均值的 3 个标准差范围内的概率，你需要从-3 积分到 3。

积分正态分布的 PDF 代码（左）和积分的可视化（右）。

99.7%的数据落在均值（μ）3 个标准差（σ）以内。

需要注意的是，对于任何 PDF，曲线下的面积必须为 1（从函数范围内抽取任何数字的概率总是 1）。

你还会发现，观察值也可能偏离均值 4、5 甚至更多个标准差，但如果你有正态或接近正态分布，这种情况是非常罕见的。

未来的教程将涵盖如何将这些知识应用于箱型图和置信区间，但这将留到以后。如果你对教程有任何问题或想法，可以在下方评论或通过Twitter与我联系。

简历：Michael Galarnyk 是一名数据科学家和企业培训师。他目前在斯克里普斯转化研究所工作。你可以在 Twitter (twitter.com/GalarnykMichael)，Medium (medium.com/@GalarnykMichael) 和 GitHub (github.com/mGalarnyk) 找到他。

原文。经许可转载。

相关内容：

• Jupyter Notebook for Beginners: A Tutorial

• Why Data Scientists Love Gaussian

• 描述性统计：数据科学的强大矮子

更多相关内容

• 正态分布综合指南

• 停止学习数据科学以寻找目标，并通过寻找目标来……

• 一个 90 亿美元的人工智能失败案例分析

• 学习数据科学统计学的顶级资源

• 成功数据科学家的 5 个特征

• 是什么让 Python 成为初创公司理想的编程语言

解释“黑箱”机器学习模型：SHAP 的实际应用

原文：www.kdnuggets.com/2020/05/explaining-blackbox-machine-learning-models-practical-application-shap.html

评论

由Norman Niemer，首席数据科学家

动机

GBM 模型经过实际测试证明是强大的模型，但由于缺乏可解释性而受到影响。通常，数据科学家会查看变量重要性图，但它们不足以解释模型的工作原理。为了最大限度地提高模型用户的接受度，使用 SHAP 值来回答常见的可解释性问题，并建立对模型的信任。

在这篇文章中，我们将对一个简单的数据集训练一个 GBM 模型，并学习如何解释模型的工作原理。这里的目标不是解释数学如何运作，而是向非技术用户解释输入变量如何与输出变量相关，以及如何进行预测。

我们使用的数据集是ISLR提供的广告数据集，你可以在d6t github上获取所用的代码。

设置

# processing
import d6tflow, d6tpipe

import pandas as pd
import numpy as np
import pathlib

# viz
import seaborn as sns
import plotly.express as px
import matplotlib.pyplot as plt
import matplotlib

# modeling
import statsmodels.api as sm
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error
from sklearn.inspection import plot_partial_dependence
from sklearn.model_selection import cross_validate
import lightgbm
import shap

首先，构建高效的数据科学工作流程

如在数据科学家常犯的 10 个编码错误中解释的，为了构建一个高效的数据科学工作流程，我们将使用文件管理器d6tpipe和工作流管理器d6tflow。

api = d6tpipe.APIClient()
pipe = d6tpipe.Pipe(api, 'intro-stat-learning')
pipe.pull()

# preprocessing workflow

class TaskProcessRawData(d6tflow.tasks.TaskPqPandas):

    def run(self):
        df = pd.read_csv(pipe.dirpath/'Advertising.csv', usecols=[1,2,3,4])
        self.save(df)

@d6tflow.requires(TaskProcessRawData)
class TaskFeatures(d6tflow.tasks.TaskPqPandas):

    def run(self):
        df = self.inputLoad()
        df['target']=df['sales']
        df['radio']=-df['radio'] # force negative relationship
        df['tv_radio']=df['TV']*df['radio'] # interaction effect
        self.save(df)

print('preprocessing workflow:')
d6tflow.preview([TaskFeatures()]) 

preprocessing workflow:

└─--[TaskFeatures-{} (COMPLETE)]
   └─--[TaskProcessRawData-{} (COMPLETE)] 

其次，构建模型前不要没有直觉关于它应该做什么

如在数据科学家常犯的 10 个统计错误中解释的，你需要形成对模型应如何工作的经济直觉。

广告数据集展示了销售额与电视、广播和报纸广告支出的关系。通过查看散点图，我们可以看出电视和广播是有效的营销渠道，因为销售额与这些渠道的支出密切相关。但请注意，广播有负面影响，而电视有正面影响（注意我们强制了广播的负相关关系）。报纸似乎只有边际影响。最后，电视和广播之间似乎存在交互效应。

df_train = TaskFeatures().outputLoad()
cfg_col_X = ['TV', 'radio', 'newspaper'] # base features
cfg_col_X_interact =  cfg_col_X+['tv_radio'] # includes interaction variable
cfg_col_Y = 'target'
df_trainX, df_trainY = df_train[cfg_col_X], df_train[cfg_col_Y]

dfp = df_train.melt(id_vars=cfg_col_Y,value_vars=cfg_col_X)
sns.lmplot(x="value", y="target", col="variable", data=dfp, sharex=False);

现在训练一个“黑箱”机器学习模型

GBM 模型经过实际测试证明是强大的模型，但由于缺乏可解释性而受到影响。让我们训练模型，看看如何解释它。我们将使用LightGBM。

m_lgbm = lightgbm.LGBMRegressor()
m_lgbm.fit(df_trainX,df_trainY)

为什么变量重要性图不起作用

正如其名，变量重要性图告诉你输入和输出变量之间关系的强度。但为了信任一个模型，用户通常希望了解更多：影响是正向还是负向，是线性的还是非线性的？是否存在有效或无效的情况？他们希望看到模型是否符合他们的经济直觉。

在我们的例子中，重要性图没有显示出我们确定的报纸支出与负相关关系。这可能会让模型用户感到困惑，他们可能仅凭这一图表不会信任模型。

lightgbm.plot_importance(m_lgbm); 

用 SHAP 解释模型

SHAP 使你能够看到每个输入对输出变量的方向性影响，这为模型用户提供了关于模型工作原理的重要直觉。

如你所见，模型确实显示了电视支出较高时销售额较高，而收音机支出较高时销售额较低。这与我们的直觉一致，并使模型用户相信你的模型是正确的。

explainer = shap.TreeExplainer(m_lgbm, df_trainX)
shap_values = explainer.shap_values(df_trainX)

shap.summary_plot(shap_values, df_trainX, plot_size=(12,6))

你也可以在散点图中调查“拟合”值，以更详细地可视化输入和输出变量之间的关系。这对于更复杂的关系和理解互动效应非常有用。

在这种情况下，关系是线性的，并且电视和收音机之间存在互动（你可以通过运行 OLS 并包含tv_radio变量来确认）。

for col in cfg_col_X:
    shap.dependence_plot(col, shap_values, df_trainX)

那么部分依赖图呢？

这些方法也有效。它们的优点在于其输出与实际目标变量的尺度一致。这不同于 Shapley 值，它展示了相对于平均预测的边际影响。

matplotlib.rcParams['figure.figsize'] = (12,6)
plot_partial_dependence(m_lgbm, df_trainX, range(df_trainX.shape[1])) 

解释最新的预测

这是实践中常遇到的另一个问题：你已经训练了模型，并使用最新数据进行预测。模型用户不仅想知道预测值，还想知道为什么你的模型做出这个预测。SHAP 可以解释单个预测，并解释每个输入变量如何影响总体预测。

在这里，我们可以看到最新的预测值是[13.18]。电视提高了预测值，而收音机降低了预测值。报纸的影响几乎可以忽略。这与我们的预期一致。

shap.force_plot(explainer.expected_value, shap_values[-1,:], df_trainX.iloc[-1,:],matplotlib=True)

哪里可以了解更多？

理解 SHAP

• github.com/slundberg/shap

• christophm.github.io/interpretable-ml-book/shap.html

构建高效的数据科学工作流

• github.com/d6t/d6t-python/blob/master/blogs/effective-datasci-workflows.rst

• github.com/d6t/d6tflow-template

使用 Databolt 加速数据科学

• github.com/d6t/d6t-python

• www.databolt.tech/

简介: 诺曼·尼默 是一家大型资产管理公司的首席数据科学家，他提供数据驱动的投资见解。他拥有哥伦比亚大学的金融工程硕士学位以及伦敦 Cass 商学院的银行与金融学士学位。

原始。经授权转载。

相关:

• 数据科学家常犯的 10 大编码错误

• 数据科学家常犯的 10 大统计错误

• 你的机器学习代码可能糟糕的 4 个原因

---

我们的 3 大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你在 IT 方面的组织

---

更多相关话题

• SHAP: 在 Python 中解释任何机器学习模型

• 使用 SHAP 值解释机器学习模型

• 解释可解释的 AI 用于对话

• 扩散与去噪: 解释文本到图像生成 AI

• Feature Store 峰会 2023: 实用策略部署 ML…

• 数据科学的基础数学: 特征向量及其在 PCA 中的应用

解释可解释的对话 AI

原文：www.kdnuggets.com/2022/10/explaining-explainable-ai-conversations.html

在短短的二三十年内，人工智能（AI）已从科幻小说的页面走向现代社会的基石技术之一。机器学习（ML）的成功催生了几乎无法计数的新 AI 应用，从自主机器和生物特征识别到预测分析和聊天机器人。

近年来，人工智能的一个新兴应用是对话智能（CI）。虽然自动聊天机器人和虚拟助手关注的是人机互动，但 CI 旨在更详细地探索人际互动。从人类对话中监测和提取数据，包括语气、情感和背景，其潜力似乎是无限的。

例如，呼叫中心互动的数据可以生成并记录，从说话者比例和客户满意度到通话摘要和行动点，全部自动归档。这将大幅减少呼叫中心处理中的繁文缛节，为客服代表提供更多与客户交谈的时间。而且，生成的数据甚至可以用于制定员工培训计划，并识别和奖励出色的工作表现。

但仍然缺少一些东西——信任。以这种方式部署人工智能极其有用，但目前仍然需要企业的信任。

我们信任人工智能吗？

作为企业，也作为整个社会，我们在人工智能系统上投入了大量信任。社交媒体公司如 Twitter 现在使用基于 AI 的算法来打击仇恨言论，保障用户在线安全。全球的医疗服务提供者越来越多地利用 AI，从能够进行患者分类的聊天机器人到可以帮助病理学家进行更准确诊断的算法。英国政府最近采用了一种名为“Connect”的 AI 工具来帮助解析税务记录和检测欺诈行为。甚至还有利用 AI 改善执法效果的例子，如使用面部识别、群体监控和步态分析等工具来识别嫌疑犯。

我们为了一个更高效、连接和无缝的世界而做出这个信任的飞跃。这个世界建立在“大数据”之上，我们需要 AI 来帮助我们管理数据流并将其用到实处。在宏观层面和个体企业中，这都是如此。但尽管我们对 AI 技术的依赖越来越大，我们对其内部工作却知之甚少。随着数据量的增加，以及 AI 做出判断的路径变得更加复杂，我们作为人类已经失去了理解和追溯这些路径的能力。我们所剩下的是一个几乎无法解释的“黑箱”。

这就引出了一个问题：如果我们无法理解这些决策是如何做出的，我们怎么能信任基于 AI 的决策？这对于希望确保系统正常运行、符合正确的监管标准或最大化效率的企业来说，越来越成为一种挫折。考虑一下亚马逊的招聘团队，他们在意识到自己的秘密 AI 招聘工具存在性别偏见后不得不放弃了该工具。他们以为自己找到了招聘的“圣杯”——一个能够扫描数百份简历并挑选出前几名进行审核的工具，节省了大量工作时间。通过重复和强化，AI 竟然说服自己男性候选人比女性候选人更可取。如果团队盲目信任 AI——虽然时间非常短暂——公司的后果将会是毁灭性的。

在商业挫折和对过度信任 AI 的担忧方面，CI 的新兴领域是一个理想的例证。

对话智能如何获得信任？

人际互动的世界多年来一直是 AI 创新的热土。使用自然语言处理（NLP）创建聊天机器人或将语音转录为文本是一回事，但从对话中得出意义和理解则完全是另一回事。这就是对话智能（CI）所做的。它超越了确定性的“A 到 B”结果，旨在分析对话中不那么明确的方面，如语调、情感和意义。

如果在呼叫中心使用 CI，例如，它可能用于确定接听员的效果、客户的情绪状态，或提供带有行动要点的自动通话摘要。这些是复杂且主观的互动，不一定有对错之分。如果呼叫中心打算利用 CI 来简化互动、培训代理并更新客户记录，它需要对基础 AI 的有效性有信心。这就是可解释 AI 或“XAI”发挥作用的地方。

每个企业都是不同的，对于系统应学习和预测的内容有不同的定义。解决方案必须提供相对于使用系统的人类行为者的预测的完整视图，以便他们可以持续批准或拒绝系统所做的预测。与其采用一个黑箱式的深度学习系统来执行任务，不如采用一个模块化的系统，其中对系统预测的每个方面都有完全的透明度和控制。例如，可以使用确定性可编程系统来跟踪通话情绪、寻找话题、生成摘要、检测特定方面（如支持通话中的问题类型或客户反馈通话中的请求）等，而不是一个单一的深度学习系统来完成所有这些任务。通过创建这样的模块化架构，整体对话智能解决方案将建立为可追溯和确定的。

揭开面纱

当人工智能处理过程简单且确定时，对这些过程的信任从未成为问题。现在，这些过程变得更加复杂和不透明，如上述 CI 示例所示，信任已经成为希望投资人工智能的企业的关键。在他仍然相关的十年前的论文中，Mariarosaria Taddeo 提到这被称为“电子信任”——人类如何信任计算机化的过程，以及我们在多大程度上允许人工智能代理参与这种关系。

可解释人工智能（XAI）是机器学习中的一个新兴领域，旨在使这些人工智能代理完全透明且更易于解释。美国的国防高级研究计划局（DARPA）是追求 XAI 解决方案的领先组织之一。DARPA 认为，人工智能系统的潜力被其无法向人类用户解释其行为的能力严重阻碍。换句话说，组织对人工智能缺乏信任阻碍了他们探索人工智能和机器学习所能提供的全部可能性。

目标是创建一套机器学习技术，能够生成可解释的模型，使人类用户能够理解和管理下一代人工智能解决方案。这些机器学习系统将能够解释其推理，识别自身的优势和不足，并传达它们如何从输入的数据中“学习”。对于 DARPA 来说，这是一种推动其所称的第三代人工智能系统的努力，届时机器将能够理解其操作的上下文和环境。

为了充分实现人工智能的潜力，我们需要从“0”和“1”中迈出一步，引入更多主观分析。技术已经存在，我们只需要更多的信任理由。

Surbhi Rathore 是 Symbl.ai 的首席执行官兼联合创始人。Symbl 正在实现她对一个可编程平台的愿景，该平台使开发者和企业能够在其产品和工作流程中大规模地监控、操作和遵守语音、视频对话，而无需建立内部的数据科学专业知识。

更多相关话题

• 扩散与去噪：解释文本到图像的生成式 AI

• 最先进的深度学习技术下的可解释预测和即时预测

• 可解释的 AI：揭秘模型决策的 10 个 Python 库

• 弥合人类理解与机器学习之间的差距：…

Python 中的探索性数据分析

原文：www.kdnuggets.com/2017/07/exploratory-data-analysis-python.html

作者：Chloe Mawer 和 Jonathan Whitmore，硅谷数据科学。

今年早些时候，我们写了关于探索性数据分析的价值的文章以及你为何应关心。在那篇文章中，我们从很高的层面介绍了探索性数据分析（EDA）是什么，以及数据科学家和业务利益相关者为何应该将其视为其分析项目成功的关键。然而，那篇文章可能让你想知道：我该如何自己进行 EDA？

上个月，我的同事高级数据科学家 Jonathan Whitmore 和我在PyCon上教授了一门名为Python 中的探索性数据分析的教程——你可以在这里观看。在这篇文章中，我们将总结教程的目标和内容，然后提供跟随的指示，以便你开始发展自己的 EDA 技能。

教程目标

本教程的目标是帮助参与者：

1. 通过在各种探索阶段提出问题并指出需要注意的事项，培养 EDA 的思维方式

2. 学习如何有效调用一些基本的 EDA 方法，以便理解数据集并为更高级的分析做好准备。这些基本方法包括：

   • 切片和切分

   • 计算汇总统计数据

   • 数值和分类数据的基本绘图

   • 基于地图的地理空间数据基本可视化

   • 使用 Jupyter Notebook 小部件进行交互式探索

我们将 EDA 视为一棵树：每次进行 EDA 时，你都会执行一系列基本步骤（树的主干），但在每个步骤中，观察会引导你探索其他方向（树枝），提出你想解答的问题或需要检验的假设。

你追寻的树枝将取决于你觉得有趣或相关的内容。因此，你在跟随本教程进行实际探索时将是你自己的。我们没有答案或结论，认为你应该对数据集得出什么结论。我们的目标仅仅是帮助你使探索尽可能有效，并让你享受选择跟随哪些分支的乐趣。

教程大纲

演讲包括以下内容：

1. 探索性数据分析简介：我总结了 EDA 的动机以及我们在教程中深入探讨的一般策略。

2. Jupyter Notebooks 入门：我们的教程涉及通过一系列 Jupyter Notebooks 进行操作，因此 Jonathan 对那些从未见过它们的人做了一个快速介绍。我们甚至从一位参与者那里学到了一项新技巧！

3. Redcard 数据集的探索性分析：Jonathan 进行了一项关于数据集的探索性分析，该数据集来源于一篇有趣的论文，该论文在《自然》上发布，并附有评论。论文的核心问题在标题中有所反映：“许多分析师，一个数据集：如何透明地展示分析选择的变化如何影响结果”。作者招募了约 30 个分析团队，每个团队都被赋予了相同的研究问题：“足球裁判是否更可能对深色肤色的球员出示红牌，而不是浅色肤色的球员？”并提供了相同的数据。数据集来自 2012-13 年欧洲足球（足球）职业联赛中的球员。包括球员的年龄、身高、体重、位置、肤色评级等数据。然后比较各团队的结果，查看不同的数据查看方式如何得出不同的统计结论。丰富的数据集提供了充足的机会来进行探索性数据分析。从决定层级领域位置，到身高或体重的分位数。我们展示了几种有用的库，包括标准库如 pandas，以及较少见的库如missingno、pandas-profiling和pivottablejs。

4. AQUASTAT 数据集的探索性分析：在这一部分，我将对粮农组织（FAO）的 AQUASTAT 数据集进行探索。这些数据集提供了关于水资源可用性和使用情况的指标，以及自 1952 年起每五年报告的各国其他人口统计数据。该数据集通常被称为面板数据或纵向数据，因为它是针对相同主题（在此案例中为国家）重复收集的数据。我们讨论了将其作为面板数据进行探索的方法，以及仅关注数据横截面（在各国收集的单一时间段的数据）的方法。这些数据也是地理空间的，因为每个观测值都对应一个地理定位区域。我们展示了如何在 Python 中在地图上查看非常基本的数据，但地理空间分析是一个深奥的领域，我们在查看这个数据集时只是触及了它的表面。我们推荐PySAL 教程作为 Python 中地理空间分析的入门介绍。

在家跟随学习

为了充分利用本教程，我们建议你实际操作我们开发的 Jupyter notebooks。你可以通过以下两种方式之一来完成：

1. 在云端通过 Microsoft Azure notebooks：设置一个账户，然后克隆 这个库。克隆此库将允许你在线打开、编辑和运行每一个 Jupyter notebook，无需担心设置 Jupyter notebooks 和 Python 环境。此服务是免费的，你的 notebooks 可以保存以备将来使用，没有任何限制。需要了解的唯一事项是，虽然 notebooks 会被无限期保存，但在工作会话结束后，数据或其他非 notebook 文件不会被保存。数据可以导入并分析，但任何 notebook 外的结果必须在离开之前下载。

2. 在本地计算机上：克隆 github 仓库 并根据 README 中的说明设置你的 Python 环境。

在家跟随教程，你可以随时暂停。我们在三小时的教程中讲解了大量材料（并且需要应对一些技术问题，这些问题在 65+人使用不同操作系统和各种公司防火墙的实践教程中不可避免！）。为了充分利用内容，我们建议你在教程中暂停，当有建议尝试某些分析时，亲自进行尝试。

EDA 的可能性是无穷的，即使对于单个数据集。你可能希望以不同的方式查看数据，我们欢迎你通过 github 仓库中的拉取请求提交你自己对一个或两个数据集的 EDA notebooks。我们将提供反馈并批准 PR，使你的方法可以与其他开发 EDA 技能的人分享。

Chloe Mawer 背景为地球物理学和水文学，擅长利用数据进行预测并提供有价值的见解。她在学术研究和工程方面的经验使她能够解决新问题并创造实用有效的解决方案。

Jonathan Whitmore 是 SVDS 的数据科学家。在完成天体物理学的博士后职位后，Jonathan 成为计算和天文学方面的受欢迎演讲者。他对将机器学习和统计技术应用于行业问题感到兴奋，并开发了新颖的数据分析技术。

原文。经许可转载。

相关：

• 探索性数据分析的价值

• Jupyter 生态系统导航简要指南

• 数据科学的 Jupyter Notebook 最佳实践

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

更多相关内容

• 掌握 SQL、Python、数据清理、数据处理与探索性数据分析的指南合集

• 用于非结构化数据的探索性数据分析技术

• 数据科学家探索性数据分析的必备指南

• 掌握探索性数据分析的 7 个步骤

• 5 个用于地理空间数据分析的 Python 包

• 最佳 Python 课程：分析总结

类别数据分析

原文：www.kdnuggets.com/2020/07/exploratory-data-analysis-steroids.html

评论

作者 Diego Lopez Yse，数据科学家

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你所在的组织的 IT

---

机器学习讨论通常集中在算法及其性能上：如何提高模型准确性或减少错误率、在特征工程方面表现出色或微调超参数。但在任何事情之前有一个概念：探索性数据分析，或称 EDA。

EDA 是在我们开始使用任何模型之前对数据进行理解。 这完全有道理，对吧？如果我们还不了解我们的数据，我们将使用什么模型呢？

在机器学习模型出现之前，就有了 EDA

这是数据科学中的一个核心方面，有时会被忽视。你所做的任何事情的第一步都应该是了解你的数据：理解它，与之熟悉。你试图从数据中得到什么答案？你使用了哪些变量，它们是什么意思？从统计的角度来看它是什么样的？数据格式是否正确？是否有缺失值？是否有重复值？异常值呢？

随着数据量的增加，这个概念变得更加重要：想象一下尝试解析成千上万或数百万条记录并理解它们。接下来，我想分享我的 Python 方法，以最有效的方式回答这些问题。

描述数据集

对于这篇文章，我使用了世界银行的经济数据集，描述了一些全球关键因素，如 GDP、人口水平、面积等。你可以在这里找到数据集和完整代码。

首先，我们需要导入一些库：

import pandas as pd
import numpy as np
import seaborn as sns
import xlrd

Pandas、Numpy 和 Seaborn 在任何 EDA 练习中都是关键的。由于我们使用的是 Excel 文件作为数据源，因此“xlrd”包仅在我们的示例中需要。

现在，让我们导入数据集：

df = pd.read_excel(“wbdata.xlsx”)

看一下数据：

df.head()

df.describe()

数据集中数值变量的一些基本统计信息。

df.shape

查看数据集结构的一种快速方法：215 行和 10 列。

df.dtypes

检查变量类型：除了国家名称是字符串，其余都是浮点数。有关如何更改变量类型的教程，请访问这里。

df.info()

在这里我们看到一些变量有空值（例如，“人口”变量有 1 行缺失值，“面积”有 2 行，等等）。我们将看到如何处理这些空值。

缺失值

缺失值可能由不同原因引起，如数据输入错误或记录不完整。这非常常见，并可能对从数据中得出的结论产生重大影响。

我们已经看到这个数据集有几个缺失值，但让我们看看如何测试任何数据集。你可能想问的第一个问题是：是否有缺失值？

print(df.isnull().values.any())

接下来，你可能想检查它们有多少：

print(df.isnull().sum().sum())

现在，让我们回顾一下这些缺失值的总结

print(df.isnull().sum())

你看到什么熟悉的东西吗？这就是.info() 函数的另一面。处理缺失值有不同的策略，没有一种通用的方法。对于这个例子，我们将丢弃这些缺失值，因为进行填补没有意义：

df1 = df.copy()df1.dropna(inplace=True)

我们回顾一下新数据集：

df1.info()

188 条记录仍然存在，没有空值。现在我们准备继续前进。

你可以在这里找到处理缺失值的其他方法。

可视化

让我们用 Seaborn 可视化新的数据集：

sns.pairplot(df1)

这样你可以快速识别异常值、聚类和变量之间明显的相关性。

让我们结合“gdp”和“人口”变量：

sns.scatterplot(x='gdp.cap', y='population', data=df1, hue='population')

你看到右上角的两个明显的异常值了吗？有两个国家的总人口水平与其他数据有极端的差异。你可以通过单独分析“人口”变量来验证这个观察结果：

sns.kdeplot(df1[‘population’], shade=True, color=’orangered’)

检测异常值的另一种方法是绘制箱线图：

df1.plot(kind=’box’, subplots=True, layout=(3,3), sharex=False, sharey=False, figsize=(20, 20), color=’deeppink’)

你还可以展示这些变量的密度图并分析它们的偏态：

df1.plot(kind=’density’, subplots=True, layout=(3,3), sharex=False, figsize=(20, 20))

查看这个链接获取额外的 Seaborn 样式提示。

在这个例子中，我故意没有处理异常值，但有多种方法可以处理它们。你可以在这里找到一些异常值识别和处理的例子。

相关性

相关变量将节省你大量的分析时间，而且这是在对数据进行任何假设之前的必要步骤。相关性仅计算数值变量，因此了解数据集中的变量类型非常重要。

你可以在这里找到其他非数值变量的系数。

mask = np.tril(df1.corr())
sns.heatmap(df1.corr(), fmt=’.1g’, annot = True, cmap= ‘cool’, mask=mask)

我已遮蔽了左下角的值，以避免重复并提供更清晰的视图。右侧的值刻度也提供了一个快速参考指南，用于极端值：你可以轻松发现变量之间的高相关性和低相关性（例如，“国民收入”与“购买力”具有高度正相关性）

在这里找到更多自定义相关矩阵的方法。

最后的思考

探索性数据分析对理解任何数据集至关重要。在这里，你可以提供见解并做出发现。这里是你将知识付诸实践的地方。

但探索性数据分析需要大量的准备工作，因为现实世界中的数据很少是干净和同质的。人们常说，80%的数据科学家的宝贵时间都花在寻找、清理和组织数据上，剩下的 20%才用于实际分析。

与此同时，完美是善的敌人，你需要在有限的时间内推动你的见解。为分析准备数据是不可避免的，而你如何做将决定你的探索性数据分析的质量。

对这些话题感兴趣？在Linkedin或Twitter上关注我

简历：Diego Lopez Yse是一位拥有不同领域（资本市场、生物技术、软件、咨询、政府、农业）国际背景的经验丰富的专业人士。始终是团队成员。擅长商业管理、分析、金融、风险、项目管理和商业运营。拥有数据科学和企业金融硕士学位。

原文。已获得许可转载。

相关：

• 如何准备你的数据

• 数据科学项目准备的奇妙四步

• 时间复杂度：如何衡量算法的效率

更多相关主题

• 停止学习数据科学以寻找目标，并寻找目标以…

• 数据科学学习统计的顶级资源

• 成功数据科学家的 5 个特征

• 每个数据科学家都应该知道的三个 R 库（即使你使用 Python）

• 一个 90 亿美元的 AI 失败案例分析

• 是什么使 Python 成为初创公司的理想编程语言

探索性数据分析技术针对非结构化数据

原文：www.kdnuggets.com/2023/05/exploratory-data-analysis-techniques-unstructured-data.html

作者提供的图片

探索性数据分析是机器学习开发生命周期中至关重要的阶段之一，在进行任何实际数据分析项目时，这个阶段几乎占据了整个项目时间的 50-60%。因为我们需要处理的原始数据必须在应用机器学习算法之前进行处理，以获得最佳性能。此步骤必须包括以下内容：

1. 这涉及更好地分析和总结数据集，以理解其潜在的模式、关系和趋势。

2. 这使分析师能够识别重要的数据特征，检测异常值或离群点，并确定预测未来结果的最合适建模技术。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你组织的 IT 部门

---

让我们通过一个故事来理解 EDA 在数据分析中的重要性。

通过一个故事理解 EDA 的重要性

从前，一家小公司刚刚在市场上开展业务。该公司拥有一组对其角色充满热情的专业人员，他们以一种能使整个公司获利的方式工作。随着公司在员工或产品用户方面的增长，管理团队意识到他们需要帮助来理解用户或客户对公司提供的产品或服务的需求和行为。

为了克服这个问题，他们开始招聘一些技术专业人员。最终，他们找到了一位数据分析师来更好地理解客户数据。该分析师能够从数据中找到重要信息或洞察。他们雇佣的分析师在类似类型的技术或项目中有很好的实际操作经验，主要工作于探索性数据分析。

因此，对于这个问题，他们开始以伦理的方式通过网络抓取从多个 API 收集数据，包括公司网站、社交媒体账号、论坛等。在数据收集之后，他们开始清理和处理数据，以便能够从中发现一些见解。他们使用了统计技术，如假设检验和商业智能工具，来探索数据并使用模式识别技术揭示隐藏的模式。

在创建了数据管道后，他们观察到公司客户最感兴趣的是购买环保和可持续的产品。基于这些见解，公司管理层推出了环保和可持续产品。因此，基于这些更新，新产品受到客户的欢迎，公司收入也开始增长。管理层开始意识到探索性数据分析的重要性，并雇佣了更多的数据分析师。

因此，在这篇文章中，受上述故事的启发，我们将了解数据管道中探索性数据分析阶段的不同技术，并使用这一过程中的流行工具，通过这些工具你可以为你的公司发现价值连城的见解。本文为初学者和经验丰富的数据分析师提供了 EDA 及其在数据科学中重要性的全面概述。

实施的不同技术

为了理解 EDA 中使用的每种技术，我们将通过一个数据集并使用 Python 数据科学库（如 NumPy、Pandas、Matplotlib 等）来实现它。

我们将在分析中使用的数据集是 Titanic 数据集，可以从这里下载。我们将使用 train.csv 进行模型训练。

1. 导入必要的库和依赖项

在实施之前，首先让我们导入将要使用的不同 EDA 技术所需的库，包括

1. 用于矩阵操作的 NumPy，

2. 用于数据分析的 Pandas，和

3. 用于数据可视化的 Matplotlib 和 Seaborn。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sb

2. 加载和分析数据集

在导入所有必要的库之后，我们将使用 Pandas 数据框加载 Titanic 数据集。然后，我们可以开始执行不同的数据预处理技术，以准备数据进行进一步建模和概括。

passenger_data = pd.read_csv('titanic.csv')
passenger_data.head(5)

输出：

图 1 | 图片来源：作者

3. 获取统计摘要

以下分析提供了数据中所有数值列的统计信息。我们可以从这个函数中获得的统计信息有：

1. 计数，

2. 平均值和中位数

3. 标准差

4. 最小值和最大值

5. 不同四分位数值

passenger_data.describe()

输出：

图 2 | 图片来源：作者

通过解释上述输出，我们可以看到共有 891 名乘客，平均生存率为 38%。年龄列的最小值和最大值在 0.42 到 80 之间，平均年龄约为 30 岁。此外，至少 50%的乘客没有兄弟姐妹/配偶，至少 75%的乘客没有父母/孩子，票价列的值变化很大。

让我们尝试通过从头编写代码来计算生存率。

4. 计算乘客的总体生存率

为了计算总体生存率，我们首先选择“Survived”列，检查值为 1 的行，然后计算所有这些行的数量。最后，为了找到百分比，我们将其除以总行数并打印出来。

survived_data = passenger_data[passenger_data['Survived'] == 1]
survived = survived_data.count().values[1]
survival_percent = (survived/891) * 100
print('The percentage of survived people in training data are {}'.format(survival_percent))

输出：

The percentage of survived people in training data are 38.38383838383838

5. 按性别和“Pclass”列计算生存率

现在，我们需要使用一个聚合操作符来查找不同列的生存率，我们将使用“gender”和“Pclass”列，然后应用均值函数来找到并打印出来。

survival_rate = passenger_data[['Pclass', 'Sex','Survived']].groupby(['Pclass', 'Sex'], as_index = False).mean().sort_values('Survived', ascending = False)
print(survival_rate)

输出：

 Pclass     Sex  Survived
0       1  female  0.968085
2       2  female  0.921053
4       3  female  0.500000
1       1    male  0.368852
3       2    male  0.157407
5       3    male  0.135447

6. 将 Passenger Id、Survived 和 Pclass 的数据类型更改为字符串

由于某些列的数据类型不同，我们将所有这些列转换为固定的数据类型，即字符串。

Cols = [ 'PassengerId', 'Survived', 'Pclass' ]
for index in Cols:
     passenger_data[index] = passenger_data[index].astype(str)
passenger_data.dtypes

7. 数据集中的重复行

在进行数据建模时，如果存在重复行，我们的性能可能会降低。因此，建议始终删除重复行。

passenger_data.loc[passenger_data.duplicated(), :]

8. 创建直方图以检查数据分布

为了找出基于该列可能值的生存列分布，以便检查类别偏差，如果存在任何问题，我们可以应用如过采样、欠采样、SMOTE 等技术来克服这些问题。

sb.set_style("white")
g = sb.FacetGrid(data = train[train['Age'].notna()], col = 'Survived')
g.map(plt.hist, "Age");

输出：

图 3 | 作者提供的图片

现在，如果我们比较上述两个分布，那么建议使用相对频率而不是绝对频率，通过使用累计密度函数等。由于我们以 Age 列为例，绝对频率的直方图显示 20-30 岁年龄组的受害者明显多于幸存者。

9. 绘制按生存情况的年龄缺失值百分比

在这里，我们创建了饼图来找出按生存值划分的缺失值百分比，然后查看分区情况。

dt0 = train['Age'][train['Survived']=='0']
dt1 = train['Age'][train['Survived']=='1']
plt.figure(figsize = [15, 5])

plt.subplot(1, 2, 1)
age_na_pie(dt0)
plt.title('Survived: No');

plt.subplot(1, 2, 2)
age_na_pie(dt1)
plt.title('Survived: Yes');

输出：

图 4 | 作者提供的图片

饼图显示，年龄缺失的乘客更可能成为受害者。

10. 查找每列的缺失值数量

passenger_data.isnull().sum()

从输出中，我们观察到“Cabin”列有最多的缺失值，因此我们将从分析中删除该列。

11. 每列的空值百分比

passenger_data.isna().sum()/passenger_data.shape[0]

在年龄列中，大约 20%的数据缺失，Cabin 列中的数据缺失率约为 77%，Embarked 列中的数据缺失率为 0.2%。我们的目标是在建模之前处理缺失数据。

12. 从数据集中删除“Cabin”列

删除 Cabin 列，因为它有许多缺失值。

drop_column = passenger_data.drop(labels = ['Cabin'], axis = 1)
print(drop_column)

为了处理“年龄”列，首先，我们将检查年龄列的数据类型，并将其转换为整数数据类型，然后用年龄列的中位数填补所有缺失值。

datatype = passenger_data.info('Age')
fill_values = passenger_data['Age'].fillna(int(passenger_data['Age'].median()),inplace=True)
print(fill_values)

经过这些步骤，我们的数据集在缺失值、异常值等方面看起来很好。现在，如果我们应用机器学习算法来发现数据集中的模式，然后在测试数据上进行测试，模型的表现将比没有进行预处理和探索性数据分析或数据清洗的数据要好。

从 EDA 中获得的总结性见解

下面是幸存者的特征与受害者的比较。

1. 幸存者可能有父母或子女陪伴；与其他人相比，他们的票价更贵。

2. 儿童比所有年龄组的受害者更有可能幸存。

3. 年龄缺失的乘客不太可能成为幸存者。

4. 拥有更高 pclass（SES）的乘客更有可能幸存。

5. 女性比男性更有可能幸存。

6. Cherbourg 的乘客比 Queenstown 和 Southampton 的乘客有更高的生存机会。

你可以在这里找到完整代码的 Colab 笔记本 - Colab Notebook。

结论

这结束了我们的讨论。当然，探索性数据分析（EDA）中还有许多技术超出了我在这里所覆盖的内容，这取决于我们在问题陈述中使用的数据集。总之，了解你的数据，在用它来训练模型之前进行 EDA 是有益的。这种技术在任何数据科学项目中都起着至关重要的作用，使我们的简单模型在项目中表现更好。因此，每位有志成为数据科学家、数据分析师、机器学习工程师和分析经理的人都需要充分掌握这些技术。

直到那时，请继续阅读和学习。如果有任何问题或建议，请随时通过 Linkedin 与我联系。

Aryan Garg 是一名电气工程专业的本科生，目前在本科学习的最后一年。他对网页开发和机器学习领域感兴趣。他已经追求了这个兴趣，并渴望在这些方向上进一步发展。

更多相关话题

• 掌握 SQL、Python、数据清洗、数据整理和探索性数据分析的指南集合

• 数据科学家探索性数据分析的必备指南

• 掌握探索性数据分析的 7 个步骤

• 非结构化数据：2022 年分析的必备条件

• 通过 LLMs 将非结构化数据转化为结构化数据

• 将非结构化数据转化为结构化洞察的 5 种方法

轻松在笔记本电脑上探索 LLMs

原文：www.kdnuggets.com/2023/04/explore-llms-easily-laptop-openplayground.html

图片由编辑提供

大型语言模型（LLM）是一个深度学习语言模型，旨在理解、解释和生成自然语言；它通常由数百万到数十亿个神经网络参数组成，并通过自我监督进行训练。著名的 LLM 包括 GPT-4、BERT 和 LLAMA。

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

访问 LLM 有时比较棘手，因为我们必须遵守环境要求和规格，这成为学习 LLM 的门槛。幸运的是，我们可以使用一个名为 openplayground 的 Python 包，在我们的笔记本电脑上高效地实验各种 LLM。

什么是 openplayground，我们如何从中受益？让我们进一步探索。

探索 openplayground

Python 包 openplaygorund 自我介绍为一个可以在笔记本电脑上运行的 LLM 游乐场，它们说得对。它是一个我们可以实验模型、调整参数、进行模型比较，并通过友好的用户界面追踪日志历史的游乐场。它们还使用来自多个实体的著名 LLM，如 OpenAI、HuggingFace 等。

我们如何开始使用 openplaygorund？让我们从安装软件包开始。

pip install openplayground

然后在终端中运行以下命令。

openplayground run

在终端中，你将获得以下信息。

图片由作者提供

openplayground 正在运行，你必须访问本地主机以使用游乐场用户界面。

图片由作者提供

在用户界面中，你会看到三个部分：Playground、Compare 和 Settings。我们首先去 Settings 选项卡，因为在提供必要信息之前我们无法进行工作。

当你打开设置时，会有一个“提供者”部分供你选择。对于本文示例，我们将使用来自 OpenAI 的提供者。点击 OpenAI 并提供 API 密钥，以便所有模型都可以在 openplayground 中访问，如下图所示。

图片来源：作者

启用你想要的模型，然后返回到 Playground 标签页。当你已经选择了一个模型时，右侧会有额外的参数可以调整。

图片来源：作者

这些参数使我们可以轻松地探索和实验 LLM 模型的结果。让我们尝试一个简单的提示：“给我创建一个关于公主和魔法王国的短篇故事。”

图片来源：作者

生成的文本会显示为绿色。如果启用“显示概率”，你可以获取令牌生成的概率（如果模型允许）。例如，‘text-DaVinci-03’ 模型可以显示这些概率。让我们再次提交提示，并查看结果。

图片来源：作者

将鼠标悬停在令牌上会显示令牌出现的概率有多高。此外，还有关于前 5 个令牌的信息，这些令牌可能成为生成的文本。

进入“比较”标签页，我们可以比较使用相同参数生成的各种 LLM 模型文本。让我们尝试使用与之前示例相同的提示。

图片来源：作者

“比较”标签提供了生成文本的两个或更多不同 LLM 模型的信息。信息包括令牌、模型生成文本的速度、所花时间和字符数。

尝试使用来自多个提供商的各种模型进行实验，以便从使用 openplayground 中获得更多价值。

结论

大型语言模型（LLM）是一个能够理解、解释和生成文本的模型。通过 openplayground，我们可以拥有一个简单的用户界面来探索和实验多个 LLM。

Cornellius Yudha Wijaya 是一位数据科学助理经理和数据撰写者。在全职工作于 Allianz Indonesia 的同时，他喜欢通过社交媒体和写作媒体分享 Python 和数据技巧。

更多相关主题

• 轻松将 LLM 集成到你的 Scikit-learn 工作流中，使用 Scikit-LLM

• 在你的笔记本电脑上使用 LLM 的 5 种方法

• 使用 DuckDB 和…将您的笔记本电脑转变为个人分析引擎

• 无需编码即可轻松从网站抓取图像

• 开放助手：探索开放与协作的可能性

• 为何单独使用 LLM 无法满足您公司的预测需求

探索生物信息学与机器学习的世界

原文：www.kdnuggets.com/2019/09/explore-world-bioinformatics-machine-learning.html

评论

生物信息学是一个利用计算从生物数据中提取知识的研究领域。它包括数据的收集、存储、检索、处理和建模，以便通过算法和软件的开发进行分析、可视化或预测。

我们可以用更简单的方式来引用“生物信息学涉及用于理解和处理生物数据的计算和数学方法。”

这是一个跨学科领域，开发新的计算方法来分析生物数据并进行生物发现。例如，基因组学和遗传学中的两个典型任务是对一个生物体的完整 DNA 序列进行测序和注释。在神经科学中，神经影像学技术，如计算机断层扫描（CT）、正电子发射断层扫描（PET）、功能性磁共振成像（fMRI）和扩散张量成像（DTI），用于研究活体大脑并理解神经系统的内部机制。

机器学习在生物学和神经影像数据中的应用为生物医学工程开辟了新的前沿：提高我们对复杂疾病如癌症或神经退行性和精神障碍的理解。这一领域的进展最终可以导致自动诊断工具和精准医疗的发展，精准医疗包括根据个体的变异性、生活方式和环境，制定定制化的医疗方案。

在机器学习算法出现之前，生物信息学算法必须手动编程，这对于诸如蛋白质结构预测等问题而言，极其困难。

蛋白质序列的三维结构

机器学习技术，如深度学习，使得算法能够利用自动特征学习，这意味着仅根据数据集，算法就可以学习如何将多个特征组合成更抽象的特征集，从而进行进一步的学习。这种对输入数据进行多层次学习模式的方式，使得这些系统在训练大型数据集时可以做出相当复杂的预测。近年来，可用生物数据集的规模和数量急剧增加，使生物信息学研究人员能够利用这些机器学习算法。

机器学习已应用于六个生物学领域：基因组学、蛋白质组学、微阵列、系统生物学、中风诊断和文本挖掘。

基因组学

这是一个跨学科的生物学领域，专注于基因组的结构、功能、演化、绘图和编辑。基因组是一个生物体完整的 DNA 集合，包括所有基因。对能够自动确定给定 DNA 序列中蛋白质编码基因位置的机器学习系统的需求越来越大，这一问题在计算生物学中被称为基因预测。要了解更多基因组学信息，请点击这里。

基因组

蛋白质组学

蛋白质组学是对蛋白质组的大规模研究。蛋白质组是指在一个生物体、系统或生物学背景下产生的蛋白质集合。

蛋白质组

蛋白质，由氨基酸链组成，其功能大部分来自于蛋白质折叠，在此过程中它们形成了三维结构。这种结构由多个折叠层组成，包括一级结构（即氨基酸的平坦链）、二级结构（α螺旋和β折叠）、三级结构和四级结构。

蛋白质二级结构预测是这一子领域的主要关注点，因为进一步的蛋白质折叠（三级和四级结构）是基于二级结构来确定的。解决蛋白质的真实结构是一个极其昂贵且耗时的过程，因此需要能够通过直接分析氨基酸序列来准确预测蛋白质结构的系统。在机器学习之前，研究人员需要手动进行这种预测。

目前最先进的二级结构预测使用一种称为 DeepCNF（深度卷积神经场）的系统，该系统依赖于人工神经网络的机器学习模型，以在将蛋白质序列中的氨基酸分类为三种结构类别（螺旋、折叠或线圈）时达到约 84%的准确率。

微阵列

微阵列，一种实验室芯片，用于自动收集大量生物材料的数据。机器学习可以帮助分析这些数据，并已应用于表达模式识别、分类和基因网络引导。

这项技术对于监测基因组内基因的表达尤其有用，帮助基于哪些基因被表达来诊断不同类型的癌症。在这一领域的主要问题之一是根据收集的数据识别哪些基因被表达。

DNA-微阵列芯片

机器学习为解决这一问题提供了潜在的解决方案，因为可以使用各种分类方法进行识别。最常用的方法有径向基函数网络、深度学习、贝叶斯分类、决策树和随机森林。

系统生物学

系统生物学专注于研究系统中简单生物组件复杂相互作用所产生的涌现行为。这些组件可以包括 DNA、RNA、蛋白质和代谢物等分子。

系统生物学

机器学习已经被用于帮助建模这些复杂的生物系统相互作用，涉及的领域包括基因网络、信号转导网络和代谢途径。概率图模型，一种用于确定不同变量之间结构的机器学习技术，是建模基因网络的最常用方法之一。此外，机器学习还被应用于系统生物学问题，例如使用一种称为马尔可夫链优化的技术识别转录因子结合位点。基于自然进化过程的机器学习技术——遗传算法，已被用于建模基因网络和调控结构。

中风诊断

用于分析神经影像学数据的机器学习方法被用于帮助诊断中风。三维卷积神经网络（CNN）和支持向量机（SVM）方法常常被使用。

文本挖掘

可用生物出版物的增加导致了在所有来源中搜索和汇编与给定主题相关的所有信息难度增加的问题。这项任务被称为知识提取。这对于生物数据收集是必要的，这些数据随后可以输入机器学习算法，以生成新的生物学知识。机器学习可以使用诸如自然语言处理（NLP）等技术来完成这项知识提取任务，从数据库中的人类生成的报告中提取有用的信息。

该技术已被应用于寻找新药物靶点，因为这项任务需要检查存储在生物数据库和期刊中的信息。蛋白质数据库中的蛋白质注释通常不能反映每种蛋白质的完整已知知识集，因此必须从生物医学文献中提取额外的信息。机器学习已被应用于基因和蛋白质功能的自动注释、蛋白质亚细胞定位的确定、DNA 表达阵列的分析、大规模蛋白质相互作用分析和分子相互作用分析。

现在让我们在生物信息学数据集中实现支持向量机（SVM）算法，看看它是如何工作的。

利用支持向量机（SVM）进行基因表达监测的癌症分子分类

尽管癌症分类在过去 30 年中有所改进，但仍然没有一种通用的方法来识别新的癌症类别（类别发现）或将肿瘤分配到已知类别（类别预测）。该数据集来自 Golub 等人在 1999 年发表的概念验证研究。该研究展示了如何通过基因表达监测（通过 DNA 微阵列）对新病例进行分类，从而提供了一种通用的方法来识别新的癌症类别并将肿瘤分配到已知类别。

目标是使用 SVM 算法对急性髓系白血病（AML）和急性淋巴细胞白血病（ALL）的患者进行分类。

数据集可以从Kaggle下载。

让我们开始编码：

从加载三个基本的 python 库开始：

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

加载数据集：

Train_Data = pd.read_csv("/.../bioinformatics/data_set_ALL_AML_train.csv")
Test_Data = pd.read_csv("/.../bioinformatics/data_set_ALL_AML_independent.csv")
labels = pd.read_csv("/.../bioinformatics/actual.csv", index_col = 'patient')Train_Data.head()

训练数据

Test_Data.head()

测试数据

关于数据集：

1. 每一行代表一个不同的基因。

2. 第 1 列和第 2 列是关于该基因的描述。

3. 每个编号的列是标签数据中的一个患者。

4. 每个患者有 7129 个基因表达值——即每个患者每个基因都有一个值。

5. 训练数据包含第 1 到第 38 位患者的基因表达值。

6. 测试数据包含第 39 到第 72 位患者的基因表达值。

现在检查两个数据集中是否有空值（这些数据集中没有空值）。

print(Train_Data.isna().sum().max())
print(Test_Data.isna().sum().max())

现在从训练数据和测试数据中删除列‘call’，因为它没有任何统计相关性。

cols = [col for col in Test_Data.columns if 'call' in col]
test = Test_Data.drop(cols, 1)
cols = [col for col in Train_Data.columns if 'call' in col]
train = Train_Data.drop(cols, 1)

现在将所有数据集连接起来并转置最终的连接数据。

patients = [str(i) for i in range(1, 73, 1)]
df_all = pd.concat([train, test], axis = 1)[patients]
df_all = df_All.T

df_all

转置后，行已转换为列（7129 列/特征）。

现在将 patient 列转换为数值，并创建虚拟变量（将类别转换为数值），因为‘cancer’是一个具有 2 个类别（ALL，AML）的分类列。

df_all["patient"] = pd.to_numeric(patients)
labels["cancer"]= pd.get_dummies(Actual.cancer, drop_first=True)

现在在patient列上连接数据框df_all和labels。

Data = pd.merge(df_all, labels, on="patient")
Data.head()

数据

我们的下一步是创建两个变量X（自变量矩阵）和y（因变量向量）。

X, y = Data.drop(columns=["cancer"]), Data["cancer"]

接下来，我们将 75%的数据分为训练集，将 25%的数据分为测试集。test_size变量是我们实际指定测试集比例的地方。

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test =  train_test_split(X,y,test_size = 0.25, random_state= 0)

下一步是规范化数据，因为如果我们仔细查看数据，自变量的值范围差异很大。因此，当自变量的值差异很大时，我们使用特征缩放以确保所有值保持在可比范围内。

from sklearn.preprocessing import StandardScaler
sc_X = StandardScaler()
X_train = sc_X.fit_transform(X_train)
X_test = sc_X.transform(X_test)

我们正在处理的列/特征数量非常庞大。我们有 72 行和 7129 列。基本上，我们需要减少特征的数量（降维）以去除维度诅咒的可能性。

为了减少维度/特征的数量，我们将使用最流行的降维算法，即PCA（主成分分析）。

为了执行 PCA，我们必须选择我们希望数据中包含的特征/维度数量。

from sklearn.decomposition import PCA
pca = PCA() 
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)
total=sum(pca.explained_variance_)
k=0
current_variance=0
while current_variance/total < 0.90:
    current_variance += pca.explained_variance_[k]
    k=k+1

上述代码给出了k=38。

现在我们选择 k=38，并对我们的自变量应用 PCA。

from sklearn.decomposition import PCA
pca = PCA(n_components = 38)
X_train = pca.fit_transform(X_train)
X_test = pca.transform(X_test)cum_sum = pca.explained_variance_ratio_.cumsum()
cum_sum = cum_sum*100
plt.bar(range(38), cum_sum)
plt.ylabel("Cumulative Explained Variance")
plt.xlabel("Principal Components")
plt.title("Around 90% of variance is explained by the First 38 columns ")

注意：- PCA 可能会导致在没有或低特征相关性的 数据集上模型性能下降，或者不符合线性假设。

下一步是将我们的数据适配到支持向量机（SVM）算法中，但在此之前我们将进行超参数优化。

超参数优化或调整是选择学习算法的最佳超参数集的问题。超参数是用于控制学习过程的参数值。相比之下，其他参数的值是通过学习得到的。

我们将使用来自 sklearn 的 GridSearchCV 来选择最佳的超参数。

from sklearn.model_selection import GridSearchCV
from sklearn.svm import SVCparameters = [{'C': [1, 10, 100, 1000], 'kernel': ['linear']},
              {'C': [1, 10, 100, 1000], 'kernel': ['rbf'], 'gamma': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]}]search = GridSearchCV(SVC(), parameters, n_jobs=-1, verbose=1)
search.fit(X_train, y_train)

现在检查我们 SVM 算法的最佳参数。

best_parameters = search.best_estimator_

最佳超参数

现在让我们训练我们的 SVM 分类模型。

model = SVC(C=1, cache_size=200, class_weight=None, coef0=0.0,
    decision_function_shape='ovr', degree=3, gamma='auto_deprecated',
    kernel='linear', max_iter=-1, probability=False, random_state=None,
    shrinking=True, tol=0.001, verbose=False)

model.fit(X_train, y_train)

是时候做一些预测了：

y_pred=model.predict(X_test)

评估模型性能：

from sklearn.metrics import accuracy_score, confusion_matrixfrom sklearn import metrics
print('Accuracy Score:',round(accuracy_score(y_test, y_pred),2))
#confusion matrix
cm = confusion_matrix(y_test, y_pred)Output: 
Accuracy Score: 0.67

混淆矩阵并使用热图进行可视化。

class_names=[1,2,3]
fig, ax = plt.subplots()from sklearn.metrics import confusion_matrix
import seaborn as snscm = confusion_matrix(y_test, y_pred)class_names=['ALL', 'AML']
fig, ax = plt.subplots()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names)
plt.yticks(tick_marks, class_names)
sns.heatmap(pd.DataFrame(cm), annot=True, cmap="viridis" ,fmt='g')
ax.xaxis.set_label_position("top")
plt.tight_layout()
plt.title('Confusion matrix', y=1.1)
plt.ylabel('Actual label')
plt.xlabel('Predicted label')

混淆矩阵的热图

好吧，这个例子表明，如果你只是预测每个患者都有 AML，你的正确率会比错误率高。

因此，我们的 SVM 分类模型以 67%的准确率预测了癌症患者，这显然不是很好。你可以尝试不同的分类器，如随机森林、K-NN、梯度提升、xgboost 等，并比较每个模型的准确率。

结论

在这篇文章中，我们展示了如何使用分类机器学习算法来预测患者的癌症。

我认为，要让机器学习真正蓬勃发展，关键在于更好的生物信息学数据。目前健康和生物信息学数据的统计能力相当差。它们通常要么信号较差（基因组学），要么噪声/偏差较高（电子健康记录），要么样本量较小。

好了，这就是本文的全部内容。我希望大家喜欢阅读，请在评论区分享您的建议/观点/问题。

你也可以通过LinkedIn联系我，提出任何问题。

图片来源

感谢阅读！！！

个人简介: Nagesh Singh Chauhan 是一名数据科学爱好者，对大数据、Python、机器学习感兴趣。

原文。经许可转载。

相关内容：

• 友好的支持向量机介绍

• 使用 K-最近邻分类心脏病

• 使用 K-Means 聚类进行图像分割简介

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升您的数据分析技能。

3. Google IT 支持专业证书 - 支持您的组织 IT 工作。

---

更多相关内容

• 成为出色数据科学家所需的 5 项关键技能

• 每个初学者数据科学家应该掌握的 6 种预测模型

• 2021 年最佳 ETL 工具

• 停止学习数据科学以寻找目标，并通过寻找目标来……

• 学习数据科学统计的最佳资源

• 成功数据科学家的 5 个特征

探索蛮力 K-最近邻算法

原文：www.kdnuggets.com/2020/10/exploring-brute-force-nearest-neighbors-algorithm.html

评论

Murugan Yuvaraaj，Praxis 商学院

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 在 IT 方面支持你的组织

---

你发现这两个图之间有什么不同吗？

两者都显示了 K 值在 1 到 10 之间的分类问题的准确率。

两个图都使用了 KNN 分类模型，采用了 'Brute-force' 算法和 'Euclidean' 距离度量在相同数据集上。那么为什么两个图之间的准确率会有所不同呢？

在回答那个问题之前，让我带你浏览一下 KNN 算法的伪代码。

希望大家都对 k 最近邻算法有所了解。如果没有，你可以在 www.analyticsvidhya.com/blog/2018/03/introduction-k-neighbours-algorithm-clustering/ 阅读其基础知识。

我们可以通过以下步骤实现 KNN 模型：

1. 加载数据

2. 初始化 k 的值

3. 为了获得预测的类别，从 1 遍历到所有训练数据点的总数。

4. 计算测试数据和每行训练数据之间的距离。这里我们将使用欧几里得距离作为我们的距离度量，因为它是最流行的方法。还可以使用其他度量方法，如切比雪夫、余弦等。

5. 根据距离值按升序排序计算得到的距离

6. 从排序数组中获取前 k 行

7. 获取这些行中最频繁的类别

8. 返回预测的类别

对于我们的分析，让我们只关注第 7 步，获取这些行中最频繁的类别。

在获取前 k 行之后，我们从这些行中挑选出最频繁的类别（众数）。这存在一个小问题。

在奇数 k 邻居的情况下，列表中总会有一个多数类别。因此，奇数 k 邻居不会出现问题。

那么对于偶数 k 邻居数量以及两个或更多类别获得相同多数的情况怎么办呢？

KNN 算法也可以为数据集提供高准确率，即使对于偶数 k 邻居。它并不局限于仅使用奇数 k 邻居来获取多数类别。

例如：

如果 k = 4，并且我们列表中有类别 A = 2 和类别 B = 2。在这种情况下，算法将选择位于前 K 行的类别，而不是查看距离度量。

为了解决这个问题，我们在算法中使用了距离 - 模式 - 距离作为偶数 K 个邻居的标准。

我们的算法与暴力搜索算法的工作方式相同，但对于偶数 K 邻居，它所带来的差异是巨大的。

我们的算法做的事情很简单。它从距离度量中取出前 K 行。在奇数 K 值的情况下，它取大多数类别。对于偶数 K 行，选择大多数类别。如果有两个或更多类别具有大多数，则这两个或更多主要类别的距离将再次进入距离度量循环，检查哪个类别的距离度量最低，并将该类别选择为主要类别。

让我们来看一个如何工作的示例。

我们的分析使用了企鹅数据集。

暴力搜索算法：

在这里我们设置了 k = 4。

类别‘Chinstrap’和‘Adelie’的模式为 2。在根据模式排列 K 个邻居后，暴力搜索选择了第一个类别，而不是选择距离度量中最小距离的类别。

这影响了当 k 值为偶数时暴力搜索算法的准确性。

我们的模型：

我们的模型能够在偶数邻居情况下提高准确性。

结果：

我比较了我们的模型与暴力搜索的准确性，结果如下。

K	暴力搜索	我们的模型
1	0.805	0.805
2	0.746	0.805
3	0.761	0.761
4	0.746	0.791
5	0.776	0.776
6	0.716	0.791
7	0.746	0.746
8	0.686	0.746
9	0.746	0.746
10	0.701	0.776

我还比较了结果与kd 树和球树算法，结果相似。

GitHub 链接: github.com/myuvarajmp/Exploring_KNN_Algorithm

感谢您的时间，并且请对我的反馈宽容，因为这是我的第一篇文章。

个人简介: Murugan Yuvaraaj 是印度班加罗尔 Praxis 商学院的学生。

相关内容：

• 初学者指南：R 中的 K-最近邻算法，从零到英雄

• K 最近邻算法的介绍及示例

• 使用 K-最近邻算法分类心脏病

更多相关内容

• 从理论到实践：构建 k-最近邻分类器

• 分类的最近邻

• Scikit-learn 中的 K 最近邻

• 40% 的劳动力将在 3 年内受到 AI 的影响

• 数据库优化：探索 SQL 中的索引

• 探索 AI/DL 的最新趋势：从元宇宙到量子计算

探索使用 Python 的数据清理技术

原文：www.kdnuggets.com/2023/04/exploring-data-cleaning-techniques-python.html

图片来源：freepik.com

在实际的数据科学项目中，用于分析的数据可能包含多个缺陷，例如缺失数据、冗余数据、数据条目格式不正确、数据中的异常值等。数据清理指的是将原始数据进行预处理和转换，以便将其呈现为适合进一步分析的形式，例如描述性分析（数据可视化）或处方分析（模型构建）。必须使用干净、准确、可靠的数据进行后续分析，因为“坏数据导致糟糕的预测模型”。

---

我们的三大课程推荐

1. Google Cybersecurity Certificate - 快速进入网络安全职业生涯。

2. Google Data Analytics Professional Certificate - 提升您的数据分析能力

3. Google IT Support Professional Certificate - 支持您的组织的 IT

---

Python 中的多个库，包括 pandas 和 numpy，可用于数据清理和转换。这些库提供了广泛的方法和功能来执行任务，包括处理缺失值、消除异常值，以及将数据转换为模型友好的格式。此外，消除冗余特征或将高度相关的特征组合成一个特征可能会导致维度减少。使用特征较少的数据集训练模型将提高模型的计算效率。此外，使用特征较少的数据集构建的模型更容易解释，并且具有更好的预测能力。

在本文中，我们将探索 Python 中用于清理、处理和转换数据的各种工具和技术。我们将使用下面展示的data.cvs 数据集演示数据清理技术：

data.csv 展示了多种缺陷，例如重复数据、NaN 等。数据由作者创建。

Python 数据清理库

在 Python 中，可以使用一系列库和工具，包括 pandas 和 NumPy，来清理数据。例如，pandas 中的 dropna()、drop_duplicates() 和 fillna() 函数分别可用于处理缺失数据、删除缺失数据和删除重复行。scikit-learn 工具包提供了处理离群值的工具（例如 SimpleImputer 类）和将数据转换为模型可以使用的格式的工具，例如用于标准化数值数据的 StandardScaler 类和用于归一化数据的 MinMaxScaler。

在本文中，我们将探讨在 Python 中可以使用的各种数据清理技术，以便为机器学习模型准备和预处理数据。

处理缺失数据

处理缺失数据是数据集中最重要的缺陷之一。Python 的 pandas 包提供了几种处理缺失数据的方法，包括dropna()和fillna()。dropna() 方法用于消除任何具有缺失值的列或行。例如，下面的代码将消除所有至少有一个缺失值的行：

import pandas as pd

data = pd.read_csv('data.csv')

data = data.dropna()

fillna() 函数可用于用特定值或方法填充缺失值。例如，以下代码将用数据中的平均年龄填充 'age' 列中的缺失值：

import pandas as pd

data = pd.read_csv('data.csv')

data['age'].fillna(data['age'].mean(), inplace=True)

处理离群值

处理离群值是典型的数据清理活动。那些与其余数据差异较大的值被视为离群值。这些因素需要小心处理，因为它们对模型的性能有显著影响。在 Python 的 scikit-learn 工具包中，RobustScaler 类用于处理离群值。通过删除中位数并根据四分位范围来缩放数据，可以使用该类来对数据进行缩放。

from sklearn.preprocessing import RobustScaler

data = pd.read_csv('data.csv')

scaler = RobustScaler()

data = scaler.fit_transform(data)

编码分类变量

另一个常见的数据清理任务是将数据转换为模型可以使用的格式。例如，在分类数据可以用于模型之前，必须将其转换为数值数据。pandas 包中的 get_dummies() 方法允许将类别数据转换为数值数据。在下面的示例中，类别特征‘Department’被转换为数值数据：

import pandas as pd

data = pd.read_csv('data.csv')

data = pd.get_dummies(data, columns=['Department'])

删除重复数据

在数据清理过程中，还必须消除重复数据。要从 Python DataFrame 中删除重复的行，可以使用 pandas 包提供的drop_duplicates() 方法。例如，下面的代码将消除数据中的所有冗余行：

import pandas as pd

data = pd.read_csv('data.csv')

data = data.drop_duplicates()

特征工程

特征选择和特征工程是数据清理的关键组成部分。选择数据集中仅相关特征的过程称为特征选择，而从现有特征中构建新特征的过程称为特征工程。下面的代码演示了特征工程的过程：

import pandas as pd
from sklearn.preprocessing import StandardScaler

# read the data into a pandas dataframe
df = pd.read_excel("data.csv")

# create a feature matrix and target vector
X = df.drop(["Employee ID", "Date of Joining"], axis=1)
y = df["Salary"]

# scale the numerical features
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X[["Age", "Experience"]])

# concatenate the scaled features with the categorical features
gender_dummies = pd.get_dummies(X["Gender"], prefix="Gender")
X_processed = pd.concat(
    [gender_dummies, pd.DataFrame(X_scaled, columns=["Age", "Experience"])],
    axis=1,
)

print(X_processed)

在上述代码中，我们首先通过删除'员工编号'和'入职日期'列来创建特征矩阵 (X)，然后创建一个包含'薪资'列的目标向量 (y)。接着，我们使用 scikit-learn 的 StandardScaler() 函数对数值特征'年龄'和'经验'进行缩放。

接下来，我们为分类列'性别'创建虚拟变量，并将其与缩放后的数值特征连接起来，创建最终处理后的特征矩阵 (X_processed)。

请注意，所使用的具体特征提取技术将取决于数据以及分析的具体要求。同时，在应用任何机器学习模型之前，重要的是将数据拆分为训练集和测试集，以避免过拟合。

结论

总之，数据清洗是机器学习过程中的一个重要阶段，因为它确保用于分析（描述性或规定性）的数据质量高。准备和预处理数据的重要方法包括转换数据格式、删除重复数据、处理缺失数据、异常值检测、特征工程和特征选择。Pandas、NumPy 和 scikit-learn 只是特征工程和数据清洗众多库和工具中的一部分。

本杰明·O·塔约 是一名物理学家、数据科学教育者和作家，同时也是 DataScienceHub 的创始人。此前，本杰明曾在中央俄克拉荷马大学、大峡谷大学和匹兹堡州立大学教授工程学和物理学。

更多相关内容

• 掌握数据清洗和预处理技术的 7 个步骤

• 在 Python 的 itertools 中探索无限迭代器

• 使用 Python 探索 OpenAI API

• 探索 Python 中的自然排序

• 导航数据革命：探索数据科学和机器学习中的蓬勃趋势

• 优化数据存储：探索 SQL 中的数据类型和标准化

使用直方图探索数据分布

原文：www.kdnuggets.com/2023/05/exploring-data-distributions-histograms.html

图片来自 Bing 图像生成器

直方图是一种数据可视化工具，在数据科学和统计学中广泛用于探索数据的分布。要创建直方图，首先将感兴趣的特征值分组到区间中，然后统计每个区间内的数据条目总数，这些数值表示计数。直方图是数据值（自变量）和计数（因变量）的图示。通常，被绘制的特征表示水平轴，而计数表示垂直轴。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升您的数据分析技能

3. Google IT 支持专业证书 - 支持您的组织在 IT 方面

---

使用直方图探索男性和女性身高数据分布

为了说明如何使用直方图探索数据分布，我们将使用 heights 数据集。该数据集包含男性和女性的身高数据。

# import necessary libraries 
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

# obtain dataset
df = pd.read_csv('https://raw.githubusercontent.com/bot13956/Bayes_theorem/master/heights.csv')

# display head of dataset
pd.head() 

heights 数据集的头部信息显示了男性和女性的身高（以英寸为单位）。图片由作者提供。

所有身高的直方图

我们可以使用以下代码绘制所有身高的分布。

sns.histplot(data = df, x="height")

plt.show()

直方图显示了数据集中所有身高的分布。图片由作者提供。

显示男性和女性身高类别的直方图

由于数据集是分类的，我们可以生成如下所示的男性和女性身高分布的直方图。

sns.histplot(data=df, x="height", hue="sex")

plt.show()

显示男性和女性身高分布的直方图。图片由作者提供。

男性和女性身高的独立直方图

我们可以绘制男性和女性身高的独立直方图，如下所示。

sns.histplot(data = df[df.sex=='Male']['height'], color='blue')

plt.show()

显示男性身高分布的直方图。图片由作者提供。

sns.histplot(data = df[df.sex=='Female']['height'], color='orange')

plt.show()

显示女性身高分布的直方图。图片由作者提供。

带有核密度估计图的直方图

可以添加核密度估计（KDE）图以平滑直方图，并估计数据的概率分布。

sns.histplot(data = df, x = 'height', KDE = 'True')

plt.show()

带有 KDE 图的全部身高数据直方图。图片由作者提供。

sns.histplot(data=df, x="height", hue="sex", KDE = 'True')

plt.show()

带有核密度估计图的男性和女性身高分布直方图。图片由作者提供。

显然，我们从上图中可以观察到，身高数据是双峰的，分别对应男性和女性类别。

摘要

总结来说，我们回顾了使用直方图探索数据分布的方法。使用身高数据集，我们展示了为数据集中的每个类别生成直方图的重要性。我们还展示了如何使用核密度估计图（KDE）平滑直方图，以产生近似的连续分布曲线。

本杰明·O·泰约 是一位物理学家、数据科学教育者和作家，同时也是 DataScienceHub 的所有者。此前，本杰明曾在中央俄克拉荷马大学、大峡谷大学和匹兹堡州立大学教授工程学和物理学。

更多相关内容

• 使用 Seaborn 创建美丽的直方图

• 事情并非总是正常的：一些“其他”分布

• 优化数据存储：探索 SQL 中的数据类型和规范化

• 探索数据网格：数据架构中的范式转变

• 导航数据革命：探索数据科学和机器学习中的蓬勃趋势

• 使用 Python 探索数据清洗技术

探索数据网格：数据架构的范式转变

原文：www.kdnuggets.com/exploring-data-mesh-a-paradigm-shift-in-data-architecture

图片由作者提供

随着技术、组织和业务需求的变化，数据架构在过去十年左右发生了演变。但这种演变是否足够显著？大多数组织通常采用集中式数据架构。这种架构设计上将数据整合在一个单一的框架下，通常由专门的数据团队进行管理。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT

---

虽然集中式数据架构在确保安全性和更好治理方面有效，但在可扩展性、灵活性和可访问性等方面存在局限性。

引入数据网格，这一概念（几乎）类似于软件架构中的微服务。数据网格旨在去中心化数据管理，正如微服务专注于去中心化应用组件一样。它将数据所有权和责任分配给特定领域的团队，承认数据是一个战略资产，最好在源头进行管理。

在本文中，我们将探讨数据网格、其关键原则、需要考虑的因素以及与数据网格架构采用相关的挑战。

什么是数据网格？

数据网格的概念最早由扎马克·德赫加尼提出，见于文章《"如何从单体数据湖过渡到分布式数据网格"》，该文章概述了数据网格背后的原则和概念。这篇文章以及数据社区中的后续讨论在普及数据网格架构方面发挥了重要作用。

数据网格是一种现代的数据架构和管理方法，与传统的集中式数据模型不同。它引入了一种去中心化的结构来组织、分配和利用组织的数据资产。

在数据网格中，数据所有权和责任在特定领域的团队或数据产品团队之间分配，使他们能够在各自的领域内自主管理数据。

这种去中心化的方法旨在解决集中式数据模型相关的局限性，例如可扩展性挑战、数据孤岛和响应变化数据需求的速度缓慢。通过赋予领域特定团队独立管理数据的权力，数据网格在组织内推广了数据自主性、灵活性和责任感的文化。它还提高了对各种数据源的高效处理，同时保持对数据质量和相关性的关注。

数据网格架构中的关键原则

数据网格架构建立在一系列旨在解决数据在组织内及跨组织扩展和管理挑战的原则上。这些原则为去中心化和更具可扩展性的数据管理方法提供了基础。

图片来源：作者

面向领域的所有权

在数据网格中，数据所有权是去中心化并分布在组织内的各个领域或业务单元之间。每个领域对其特定专业或功能领域内生成和使用的数据负责。这一原则承认领域专家最适合理解和管理其各自领域内的数据。

面向领域的所有权改善了数据质量和准确性，因为那些离数据源最近的人对其背景有深刻理解，并能确保其完整性。这也促进了对数据的所有权和责任感，鼓励领域团队维持高水平的数据标准。

数据作为产品

数据在数据网格中被视为一种产品，而非业务操作的副产品。每个领域负责交付定义明确的数据产品，这些产品经过设计、打包，并提供给组织内的其他领域使用。这些数据产品具有清晰的定义、访问机制和服务级别协议（SLA）。

将数据视为产品鼓励数据生产者专注于向消费者提供高质量和有价值的数据。它还确保数据产品的设计考虑到用户需求，使数据对更广泛的利益相关者更加可访问和可用。

自助数据基础设施

数据网格促进了自助数据基础设施的发展，使数据消费者（如数据分析师、数据科学家、业务用户）能够独立访问和处理数据。这种基础设施包括数据目录、数据发现机制和数据处理管道，使消费者能够找到、理解和利用数据，而无需过多依赖集中式数据工程团队。

自助数据基础设施减少了瓶颈并加快了数据访问，赋予更多用户操作数据的能力。它在组织内实现了数据民主化，使数据更加可访问，并加速了洞察和决策的过程。

联邦计算治理

为了在去中心化的数据架构中维护数据质量、安全性和合规性，数据网格采用了联邦计算治理。每个领域定义并执行其自身的治理政策，针对其数据的具体需求进行调整。虽然可能存在全球标准和指南，但各个领域有自主权来管理其数据资产。

这平衡了全球数据标准的需求与各个领域所需的灵活性。它允许各领域根据其独特的数据挑战调整治理实践，同时确保数据保持安全、合规和高质量。

因此，这四个关键数据网格原则共同旨在通过促进以下方面来解决大组织在数据操作扩展中的挑战：

• 去中心化，

• 数据产品思维，

• 自助服务，和

• 有效的治理。

通过实施这些原则，组织可以释放数据资产的全部潜力，改善领域团队之间的协作，使数据成为所有利益相关者更有价值且更可获取的资源。

实施数据网格？以下是需要考虑的因素

向数据网格过渡通常涉及组织内部的重大文化转变。数据网格鼓励协作、共享所有权和数据产品思维，使数据实践与组织不断发展的文化和价值观更紧密地对齐。以下是组织在实施数据网格时可能考虑的一些因素。

业务目标与战略

任何数据架构的重大转变都应与组织的更广泛业务目标和战略目标对齐。

实施数据网格应被视为战略性推动者，提升组织有效利用数据的能力，以实现其整体目标和目标。

现有基础设施

组织在评估数据网格的可行性时，必须评估和考虑当前的数据基础设施和投资。

向数据网格过渡可能需要对现有技术栈和基础设施进行调整，因此将这些方面与新方法对齐至关重要。

数据复杂性与规模

当组织面临日益增长的数据复杂性和规模时，必须考虑替代的数据管理方法。数据网格提供了可扩展性和适应性，尤其是在处理日益复杂和大规模的数据环境时。

因此，当数据的体积、种类或速度使得中心化管理变得困难，或当不同业务单位或领域的数据需求各异时，数据网格是一个不错的选择。

数据治理与合规性

维护数据质量、隐私、安全性和合规性是数据管理中的一个挑战性方面，特别是在去中心化的环境中。

数据网格策略必须有效应对这些复杂性，确保数据治理实践和监管要求得到满足。

数据可访问性和所有权

在拥有分布式数据源和多样化领域的组织中，传统的集中式数据管理可能不够充分。实施数据网格将数据所有权与领域特定团队对齐，使他们能够对自己的数据负责，这在这种环境中尤其有价值。

此外，为了促进整个组织的数据驱动决策，至关重要的是使数据更易于访问。数据网格使数据访问民主化，允许更广泛的用户访问和利用数据，从而改善各部门或团队的决策。

采用数据网格架构中的挑战

从集中式数据架构迁移到数据网格并非没有挑战。在本节中，我们将深入探讨其中的一些挑战，从治理到监控。

数据治理

在数据网格中，数据治理变得更加复杂，因为数据分布在多个领域和团队中。确保这些领域中的数据质量、隐私、安全性和合规性标准的一致性可能会面临挑战：

• 确定数据所有权和数据治理任务的责任，例如定义数据模式和访问控制，当多个团队参与时可能会面临挑战。

• 开发和执行与数据网格去中心化特性相符的数据治理政策和实践需要精心规划。

数据发现

在去中心化的数据网格中，发现和访问数据可能会很有挑战性。确保数据得到适当的编目、标记和记录对于促进数据发现至关重要。一些策略包括：

• 实施有效的元数据管理实践，为数据集提供上下文和描述，使用户更容易理解可用的数据资源。

• 开发和维护数据目录或元数据仓库，允许用户高效地搜索和查找相关数据集。

数据所有权

在数据网格中，为每个数据领域和数据产品提供清晰一致的数据所有权和责任定义至关重要。确定谁负责维护、更新和策划数据可能会很困难，尤其是当涉及多个利益相关者时。组织可以通过以下方式解决这一挑战：

• 确保数据所有者拥有必要的权力和资源，以有效管理其数据领域。

• 建立解决与数据所有权和责任相关的冲突或争议的机制。

监控与可观测性

在数据网格中，监控数据管道和数据产品的健康状况、性能和可靠性可能会很复杂。一些策略包括：

• 实施强大的监控和可观测性工具及实践，以跟踪不同领域的数据质量、延迟和使用情况。

• 开发警报和报告机制以快速识别和解决可能影响数据可用性或可靠性的问题。

我们已经突出了数据网格实施中的一些挑战。这些更像是组织在过渡到去中心化的数据网格架构时应该注意的检查点。

结论

数据网格（Data Mesh）因此是数据架构的范式转变，提供了对集中式模型挑战的解决方案。我们讨论了分散数据所有权、推动数据产品思维和实现自助访问的好处。然而，成功实施需要仔细考虑文化和技术因素，并采取积极的数据治理方法。

Bala Priya C** 是一位来自印度的开发者和技术作家。她喜欢在数学、编程、数据科学和内容创作的交叉点上工作。她的兴趣和专长领域包括 DevOps、数据科学和自然语言处理。她喜欢阅读、写作、编程和喝咖啡！目前，她正在通过编写教程、使用指南、观点文章等与开发者社区分享她的知识。Bala 还制作引人入胜的资源概述和编码教程。**

更多相关主题

• 数据网格及其分布式数据架构

• KDnuggets™ 新闻 22:n07，2 月 16 日：如何为机器学习学习数学…

• 数据网格架构：重新构想数据管理

• KDnuggets 新闻，5 月 18 日：5 个免费机器学习平台…

• 思想图谱：大型语言模型中的一种新范式用于复杂问题解决

• 如何使用 Apache Kafka 构建可扩展的数据架构

探索 Google 最新 AI 工具：初学者指南

原文：www.kdnuggets.com/exploring-googles-latest-ai-tools-a-beginners-guide

图片来源：作者

人工智能已经成为近年来发展最快的领域之一。这些新技术将永远改变世界，为我们提供了一个重要的选择：

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织进行 IT 工作

---

拥抱人工智能来优化我们的工作流程，或完全忽视它。

如果你正在阅读这篇文章，我很确定你属于第一类：你想利用 AI 来提升日常任务。

然而，存在一个重大问题。主要公司正努力通过向市场推出各种不同的应用来区分自己。这使得了解所有现有的选项变得困难。

本文旨在介绍 Google 的顶级 AI 应用，并指导你如何开始使用它们。

Google Gemini

Gemini 是一个先进的大型语言模型（LLM），是 OpenAI 的 GPT 模型的直接竞争对手，免费供所有人使用！

Gemini 主界面的截图

它集成了 Google 在 AI 领域的广泛研究，提供更准确、上下文感知的回应，使其在聊天机器人、虚拟助手和其他语言基础的 AI 解决方案中极为有效。使 Gemini 成为市场上最佳 LLM 之一的几个关键特征包括：

• 免费使用：无需支付。

• 多模态能力：能够处理图像和文档。

• 用户友好界面：易于使用。

开始使用

要开始使用 Google 的 Gemini，你只需要一个 Google 账户。你可以直接前往 Gemini 的主界面，今天就开始与其聊天吧。

Google 云

一组在 Google 基础设施上运行的云计算服务。它提供多种服务，包括计算、存储、分析和机器学习。可用于构建、训练和部署 AI 模型及解决方案。

其主要 AI 服务包括：

• AutoML：为具备基础机器学习知识的用户设计，配备即用型 API。其主要工具包括 AutoML Vision 或 AutoML Natural Language 等。

• Vertex AI：一个管理平台，简化了 ML 生命周期，从数据准备到模型部署和监控。

• 自然语言 API：一个直观的工具，用于处理自然语言，支持情感分析、实体识别和语法分析。

入门指南

要开始使用，只需一个 Google Cloud 账户。如果你是新用户，你将获得 300 美元的免费试用积分，期限为 90 天。

账户创建后，你可以通过 Google Cloud Console 访问这些工具。

TensorFlow

TensorFlow 是一个开源框架，用于从零开始创建和训练 ML 模型。它兼容多种编程语言，如 Python 和 Java。

TensorFlow 的主要功能包括：

• 综合生态系统：TensorFlow 提供了支持整个 ML 项目生命周期的工具：模型构建、训练和部署。

• 社区：它是一个使用广泛的工具，拥有丰富的文档和活跃的社区。

• 跨平台：使用 TensorFlow Lite，模型可以部署在各种设备上，从智能手机到物联网设备。

入门指南

使用 pip 安装 TensorFlow：

pip install tensorflow

然后你可以探索 TensorFlow 网站上提供的各种教程。

Google 实验

这是一个 AI 项目和实验的集合。它提供了一种互动方式来探索 AI 的能力，许多项目可供直接互动。它使用了 Google 的硬件组件和软件工具。

主要功能包括：

• 教育工具：大多数项目设计为以互动和有趣的方式教授基本的 AI 和 ML 概念。

• 互动演示：你可以与 AI 模型互动，查看它们如何响应不同的输入。

入门指南

访问 Google 实验以探索可用的项目。许多实验包括代码和说明，适合对技术细节感兴趣的人。

AI Hub

Google AI Hub 是一个你可以分享和部署 ML 模型和管道的平台。其主要目标是促进用户和企业之间的协作，利用预构建的模型和解决方案。

其主要功能包括：

• 预训练模型：访问由 Google 和其他用户预训练的模型库。

• 协作：与社区分享你的模型和解决方案，并发现其他用户的模型。

• 与 Google Cloud 的集成：与其他 Google Cloud 服务无缝集成，用于部署和监控。

入门指南

AI Hub 是 Google Cloud 的一部分，因此你需要一个 Google Cloud 账户才能访问。

浏览 AI Hub 寻找符合你需求的模型和解决方案。

总结

Google 提供了多种工具，帮助你开始 AI 和机器学习之旅。通过探索并利用这些工具，你可以优化工作流程、提升日常任务，并在这个快速发展的领域中保持领先！

Josep Ferrer是来自巴塞罗那的分析工程师。他毕业于物理工程专业，目前从事于应用于人类移动的数据科学领域。他还是一名兼职内容创作者，专注于数据科学和技术。Josep 涵盖了 AI 领域不断爆炸的应用。

更多相关主题

• 探索 Zephyr 7B：最新大型语言模型的全面指南

• 探索最新的 AI/DL 趋势：从元宇宙到量子计算

• 以数据为中心的 AI：你需要了解的最新研究

• 发现计算机视觉的世界：介绍 MLM 的最新…

• 生成式 AI 游乐场：Camel-5b 和 Open LLaMA 3B 上的 LLMs

• 生成式 AI 游乐场：文本到图像的稳定扩散与…

探索 Python 中 itertools 的无限迭代器

原文：www.kdnuggets.com/exploring-infinite-iterators-in-python-itertools

作者提供的图像

介绍

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

如其名称所示，无限迭代器是一种特殊类型的迭代器，可以无限生成值。与像列表、元组和字典这样的内置迭代器最终会结束不同，无限迭代器可以产生源源不断的值流。这些迭代器有时也被称为无限生成器或序列。它们在模拟、生成序列、处理实时数据等问题的解决中有广泛应用。

Python 的 Itertools 库提供了三种内置的无限迭代器。

• Count

• Cycle

• Repeat

1. Count

count() 函数生成从指定值和步长开始的无限数字。count 迭代器的语法如下：

itertools.count(start=0, step=1)

它有两个可选参数：“start”和“stop”，默认值分别为 0 和 1。“Start”表示计数的初始值，而“step”表示用于增加计数的增量。

让我们通过一个例子来分析这个函数。如果你需要生成一个步长为 3 的数字序列，就像 3 的乘法表一样，你可以使用以下代码：

from itertools import count

counter = count(3,3)

print("The table of 3 is:")
for i in range(10):
  print(f"3 x {i+1} = {next(counter)}")

输出

The table of 3 is: 
3 x 1 = 3 
3 x 2 = 6 
3 x 3 = 9 
3 x 4 = 12 
3 x 5 = 15 
3 x 6 = 18 
3 x 7 = 21 
3 x 8 = 24 
3 x 9 = 27 
3 x 10 = 30

2. Cycle

cycle() 函数创建一个迭代器，并无限重复传递的容器中的所有项。以下是 cycle 迭代器的语法：

itertools.cycle(iterable)

这里的“iterable”参数可以是 Python 中的任何可迭代数据结构，如列表、元组、集合等。考虑一个交通灯控制系统的例子，该系统不断循环显示不同的灯光。在不同颜色的灯光之间循环时不执行其他动作。我们将使用 5 秒的等待时间来显示结果。

from itertools import cycle
import time

lights = ["red", "green", "yellow"]
cycle_iterator = cycle(lights)

while True:
  print(f"Current light is: {next(cycle_iterator)}")
  time.sleep(5)

输出

Current light is: red 
Current light is: green 
Current light is: yellow 
Current light is: red 
Current light is: green 
Current light is: yellow

你将在大约 25 秒后看到这个输出。

3. Repeat

repeat() 函数生成指定数量的无限序列。当你需要无限生成单个值时，它非常有用。repeat 迭代器的语法如下：

itertools.repeat(value, times=inf)

我们这里有两个参数：“value”是你想要无限生成的数字，而“times”是一个可选参数，用于指定你想要生成该数字的次数。“times”的默认值是无限，意味着除非你明确指定有限的数字，否则它将不断打印。例如，如果你需要生成数字“9”三次，可以使用以下代码：

from itertools import repeat

iterator = repeat(9, 3)

for value in iterator:
    print(value)

输出

9
9 
9

结论

这些无限迭代器在我们需要处理数据流的场景中非常有用。“count”、“cycle”和“repeat”迭代器使我们能够更高效、优雅地解决问题。尽管使用它们需要谨慎，因为它们可能导致无限循环，但如果用得当，它们可以成为解决编程问题的宝贵资源。希望你喜欢这篇文章，如果你有任何分享，欢迎在下面的评论框中提出建议。

Kanwal Mehreen** Kanwal 是一名机器学习工程师和技术作家，对数据科学及 AI 与医学的交汇处有着深厚的热情。她共同编著了电子书《利用 ChatGPT 最大化生产力》。作为 2022 年 APAC 区的 Google Generation Scholar，她倡导多样性和学术卓越。她还被认可为 Teradata 多样性技术学者、Mitacs Globalink 研究学者以及 Harvard WeCode 学者。Kanwal 是变革的热情倡导者，创办了 FEMCodes 以赋能 STEM 领域的女性。

更多相关话题

• 理解 Python 中的可迭代对象与迭代器

• 你可能不知道的 4 个 Python Itertools 过滤函数

• 流式 LLM 介绍：无限长度输入的 LLMs

• 使用 Python 探索数据清理技术

• 使用 Python 探索 OpenAI API

• 在 Python 中探索自然排序

探索 AI/DL 的最新趋势：从元宇宙到量子计算

原文：www.kdnuggets.com/2023/07/exploring-latest-trends-aidl-metaverse-quantum-computing.html

图片由编辑提供

人工智能（AI）领域在不断发展，几种新兴趋势正在塑造这个领域，有潜力对各个行业和日常生活产生重大影响。最近的 AI 突破的推动力之一是深度学习（DL），也称为人工神经网络（ANNs）。深度学习在自然语言处理（NLP）、计算机视觉、强化学习和生成对抗网络（GANs）等领域显示了显著的进展。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持组织的 IT 需求

---

使深度学习（DL）更加迷人的是它与神经科学的紧密联系。研究人员常常从人脑的复杂性和功能中汲取洞察，以开发深度学习技术和架构。例如，卷积神经网络（CNNs）、激活函数和人工神经网络（ANNs）中的人工神经元都受到人脑生物神经元的结构和行为的启发。

尽管 AI/DL 和神经科学已经产生了显著影响，但还有一个领域拥有更大的变革潜力——量子计算。量子计算有潜力彻底改变计算能力，并在包括 AI 在内的多个领域解锁前所未有的进展。其进行复杂计算和同时处理大量数据的能力开启了新的可能性前沿。

深度学习

现代人工神经网络（ANNs）因其复杂的结构而获得了 "深度学习" 的称号。这些网络是一种机器学习模型，灵感来源于人脑的结构和功能。由多个相互连接的神经元层组成，ANNs 在数据流经网络时进行处理和转换。"深度" 一词指的是网络的深度，这由其结构中的隐藏层数量决定。传统的 ANNs 通常只有几个隐藏层，使其相对较浅。相比之下，深度学习模型可以具有数十层甚至数百层隐藏层，使其深度显著增加。这种增加的深度使得深度学习模型能够捕捉数据中的复杂模式和层次特征，从而在前沿机器学习任务中表现出色。

深度学习的一个显著应用是图像到文本和文本到图像生成。这些任务依赖于诸如生成对抗网络（GANs）或 变分自编码器（VAEs） 这样的深度学习技术，从庞大的数据集中学习文本与图像之间的复杂关系。这些模型在多个领域找到应用，包括计算机图形学、艺术、广告、时尚、娱乐、虚拟现实、游戏体验、数据可视化和讲故事。

VAE 算法的架构

尽管取得了显著进展，深度学习仍面临许多挑战和限制。主要的障碍在于计算资源和能源效率。深度学习模型通常需要大量的计算资源，如强大的 GPU（图形处理单元）或专用硬件，以高效地执行预测。这种对广泛计算基础设施的依赖可能限制了资源不足的研究人员或组织对深度学习的访问。此外，训练和运行深度学习模型可能会消耗大量的能源。随着模型规模每年不断增长，能源效率问题变得越来越重要。

大型模型

除了围绕大型语言模型和视觉模型的技术考虑外，全球范围内的政府带来了一个意想不到的挑战。这些治理机构正在推动对 AI 模型的监管，并要求模型拥有者，包括 ChatGPT 等平台，解释其模型的内部工作原理。然而，像 OpenAI、微软或谷歌这样的主要实体，甚至 AI 科学界，都没有对这些问题给出具体的答案。他们承认对这些模型有一般性的了解，但无法准确指出为何模型会提供某种特定的回应。最近的事件，例如 ChatGPT 在意大利被禁用和埃隆·马斯克指控微软未经授权使用 Twitter 数据，都只是更大问题的开始。显然，主要 IT 公司之间正在酝酿一场新斗争，涉及谁可以声称拥有“最大模型”和 哪些数据可以用于这些模型。

在一篇名为《AI 时代已经来临》的最新博客文章中，微软联合创始人比尔·盖茨称赞了 ChatGPT 和相关的 AI 进展为“革命性”。盖茨强调了需要“革命性”解决方案来应对当前面临的挑战。因此，这促使人们重新评估诸如“版权”、“大学考试”以及甚至对“学习”本质的哲学探讨等概念。

神经科学

在他最近的书籍《千脑理论》中，J. Hawkins 提出了一个关于人脑如何处理信息和产生智能行为的新颖且不断发展的观点。千脑理论认为，大脑像是一个由成千上万个独立的迷你大脑组成的网络，每个迷你大脑负责同时处理感觉输入和产生运动输出。根据这一理论，新皮层，即大脑外层与高级认知功能相关的部分，由众多功能上独立的柱状结构组成，这些柱状结构可以类比为迷你大脑。

该理论建议，新皮层中的每个柱状结构学习并建模来自周围环境的感觉输入，并对未来的感觉输入做出预测。这些预测随后与实际的感觉输入进行比较，任何差异都会被用来更新柱状结构中的内部模型。这个不断的预测和比较过程形成了新皮层处理信息和产生智能行为的基础。

根据千脑理论，各种感觉输入（如视觉、听觉和触觉）在独立的列中处理。这些列的输出随后被结合起来，以创建对世界的统一感知。这种非凡的能力使大脑能够整合来自不同感觉通道的信息，并形成对周围环境的连贯表征。

千脑理论中的一个关键概念是“稀疏表示”。这一概念突出了人脑中只有一部分神经元在任何给定时间是活跃的或发射的，而其余神经元则相对不活跃或静默。稀疏编码通过减少冗余或不必要的神经活动，使大脑能够高效地处理和编码信息。稀疏表示的一个重要好处是其能够实现大脑中的选择性更新。在这个过程中，只有活跃的神经元或神经通路会在响应新信息或经历时被更新或修改。

这种选择性更新机制使大脑能够通过将资源集中在最相关的信息或任务上，而不是同时更新所有神经元，从而高效地适应和学习。神经元的选择性更新在神经可塑性中发挥了关键作用，神经可塑性指的是大脑通过学习和经验改变和适应的能力。它使大脑能够根据持续的认知和行为需求来完善其表征和连接，同时节省能源和计算资源。

Numenta 理论的实际应用已显而易见。例如，最近与 Intel 的合作已经在自然语言处理和计算机视觉等各种使用案例中带来了显著的性能提升。得益于这一合作，客户可以实现性能提高从 10 倍到 100 倍以上。

元宇宙

尽管许多人将注意力集中在大型语言模型上，Meta 采取了一种独特的方法。在一篇标题为"从人类活动和模拟互动的视频中学习的机器人"的博客文章中，Meta AI 团队强调了一个名为“莫拉维克悖论”的有趣概念。根据这一论点，AI 中最具挑战性的问题围绕感知运动技能，而非抽象思维或推理。为了支持这一观点，该团队宣布了在通用体现在 AI 代理领域的两个重大进展。

1. 首先，他们引入了人工视觉皮层，称为 VC-1。这一突破性的感知模型是第一个提供广泛感知运动技能、环境和具身支持的模型。

2. 此外，Meta 团队开发了一种名为自适应（感知运动）技能协调（ASC）的创新方法。这种方法在机器人移动操控的严苛任务中达到了近乎完美的表现，成功率高达 98%。它涉及到导航到一个物体、拾取物体、移动到另一个位置、放置物体并重复这些动作——所有这些都在物理环境中完成。

Meta 的这些进展标志着从对大型语言模型的主要关注转变。通过优先考虑感知运动技能和具身人工智能，它们促进了能够以更全面、更细致的方式与世界互动的智能体的发展。

尽管基于统计方法，ChatGPT 模型获得了大量的炒作和不成比例的公众关注。相比之下，Meta 最近的突破代表了实质性的科学进展。这些成就为虚拟现实（VR）和机器人技术领域的革命性扩展奠定了基础。我们强烈推荐阅读完整文章，以获得见解，并为即将到来的人工智能创新浪潮做好准备，因为这将以显著的方式塑造这些领域的未来。

机器人技术

目前，领域中有两款显著的机器人是Atlas和Spot (robodog)，这两款机器人均可在网上轻松购买。这些机器人代表了工程学上的显著成就，但它们的能力仍受到缺乏先进“智能”的限制。这正是 Meta 人工视觉皮层发挥作用的地方，可能会带来突破性的改变。通过将机器人技术与人工智能结合，它有可能彻底改变许多行业和领域，包括制造业、医疗保健、运输、农业和娱乐等。Meta 人工视觉皮层有望增强这些机器人的能力，并为机器人技术领域的前所未有的进步铺平道路。

波士顿动力的 Atlas 和 Spot 机器人

人类的新接口：脑-计算机/脑-脑接口

尽管可能会担心被人工智能超越，但人脑具有现代人工智能所缺乏的关键优势：神经可塑性。神经可塑性，也称为脑可塑性，指的是大脑在结构和功能上对经验、学习和环境变化的惊人适应能力。然而，尽管有这种优势，人脑仍然缺乏与其他人脑或人工智能系统的先进通信方法。为了克服这些限制，开发新的脑接口是必要的。

由于传统的沟通方式，如视觉、听觉或打字，速度有限，难以与现代人工智能模型竞争。为了解决这个问题，正在探索基于直接脑神经网络电活动的新接口。进入现代脑机接口（BCIs）的领域，这些前沿技术实现了大脑与外部设备或系统之间的直接通信和互动，绕过了传统的外围神经系统路径。BCIs 的应用领域包括神经假体、神经康复、沟通、残疾人士控制、认知增强和神经科学研究。此外，BCIs 最近也涉足了虚拟现实娱乐领域，例如'Galea'等设备，可能成为我们日常现实的一部分。

另一个有趣的例子是Kernel Flow，这是一种能够从大脑皮层捕获脑电图（EEG）和全头覆盖的类似功能性磁共振成像（fMRI）数据的设备。凭借这些能力，我们有可能最终直接从梦境中创造虚拟世界。

与非侵入性的 BCIs 如'Galea'和'Kernel'相比，Neuralink由埃隆·马斯克创办，采用了不同的方法，推广侵入式脑植入。一些人称其为“与外界的插口”，提供比任何现代非侵入式 BCIs 更广泛的通信渠道。侵入式 BCIs 的另一个重要优势是潜在的双向通信。想象一个未来，信息无需通过我们的眼睛或耳朵，而是可以直接传递到我们的大脑皮层。

布莱恩·约翰逊（左）Kernel Flow

量子计算

如果神经科学和人脑尚不够吸引人，还有一个令人费解的话题可以探索：量子计算机。这些非凡的机器有可能在某些计算任务中超越经典计算机。利用量子叠加和纠缠——现代物理学的前沿——量子计算机可以执行并行计算，更高效地解决特定问题。包括大数因式分解、解决复杂优化问题、模拟量子系统，以及量子传输这一未来概念。这些进展有望彻底改变加密学、药物发现、材料科学和金融建模等领域。要体验量子编程，你可以访问 www.quantumplayground.net 并 在几分钟内编写你的第一个量子脚本。

尽管未来本质上是不确定的，但有一点是明确的：人类未来的轨迹将由个人、社区、机构和政府的选择和行动所塑造。我们必须共同努力，追求积极的变革，解决紧迫的全球问题，促进包容性和可持续性，并共同努力创造一个更美好的未来。

Ihar Rubanau 是 Sigma Software Group 的高级数据科学家

相关话题

• 量子计算解析：对数据科学和 AI 的影响

• 人工智能与元宇宙

• 探索 Zephyr 7B：最新大型语言模型的综合指南

• 探索谷歌最新的 AI 工具：初学者指南

• 数据革命导航：探索数据科学和机器学习中的蓬勃趋势

• 在你的数据科学旅程中取得量子飞跃

探索 Python 中的自然排序

原文：www.kdnuggets.com/exploring-natural-sorting-in-python

作者提供的图片

什么是自然排序，我们为什么需要它？

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

在处理 Python 可迭代对象如列表时，排序是一项常见操作。要对列表进行排序，可以使用列表方法 sort() 来就地排序，或使用 sorted() 函数返回排序后的列表。

sorted() 函数在处理数字或包含字母的字符串列表时效果很好。但是，对于包含字母数字字符的字符串，如文件名、目录名、版本号等情况呢？sorted() 函数执行的是字典序排序。

看这个简单的例子：

# List of filenames
filenames = ["file10.txt", "file2.txt", "file1.txt"]

sorted_filenames = sorted(filenames)
print(sorted_filenames)

你将得到如下输出：

Output >>> ['file1.txt', 'file10.txt', 'file2.txt'] 

好吧，'file10.txt' 出现在 'file2.txt' 之前，不是我们所期望的直观排序顺序。这是因为 sorted() 函数使用字符的 ASCII 值进行排序，而不是数字值。引入自然排序。

自然排序是一种排序技术，它以反映元素自然顺序的方式对元素进行排列，特别是对于字母数字数据。与字典序排序不同，自然排序会解释字符串中的数字值，并据此进行排列，从而得到更有意义和符合预期的序列。

在本教程中，我们将使用 Python 库 natsort 探索自然排序。

入门

要开始使用，你可以通过 pip 安装 natsort 库：

$ pip3 install natsort

最佳实践是，在项目中使用虚拟环境安装所需的软件包。由于 natsort 需要 Python 3.7 或更高版本，请确保使用的是最新的 Python 版本，最好是 Python 3.11 或更高版本。要了解如何管理不同的 Python 版本，请阅读 Python 版本太多了？Pyenv 来拯救你。

自然排序基础示例

我们将从自然排序有用的简单用例开始：

• 排序文件名：在处理包含数字的文件名时，自然排序确保文件按自然直观的顺序排列。

• 版本排序：自然排序也有助于对版本号字符串进行排序，确保版本根据其数字值而非 ASCII 值进行排序。这可能不会反映所需的版本顺序。

现在让我们继续编写这些示例代码。

排序文件名

现在我们已经安装了 natsort 库，可以将其导入到我们的 Python 脚本中，使用该库提供的不同函数。

让我们重新回顾排序文件名的第一个例子（就是我们在教程开始时看到的那个），其中字典序排序的结果并不是我们想要的。

现在让我们使用natsorted()函数对相同的列表进行排序，如下所示：

import natsort

# List of filenames
filenames = ["file10.txt", "file2.txt", "file1.txt"]

# Sort filenames naturally
sorted_filenames = natsort.natsorted(filenames)
print(sorted_filenames)

在这个例子中，来自 natsort 库的natsorted()函数被用来自然地排序文件名列表。结果是文件名按预期的数字顺序排列：

Output >>> ['file1.txt', 'file2.txt', 'file10.txt']

排序版本号

让我们再来看一个类似的例子，我们有表示版本的字符串：

import natsort

# List of version numbers
versions = ["v-1.10", "v-1.2", "v-1.5"]

# Sort versions naturally
sorted_versions = natsort.natsorted(versions)

print(sorted_versions) 

在这里，natsorted()函数被应用于自然地排序版本号列表。结果排序列表保持了版本的正确数字顺序：

Output >>> ['v-1.2', 'v-1.5', 'v-1.10']

使用键自定义排序

使用内置的sorted()函数时，你可能已经使用了key参数进行自定义。同样，sorted()函数也接受可选的key参数，你可以用它来根据特定的标准进行排序。

让我们举一个例子：我们有file_data，它是一个元组列表。元组中的第一个元素（索引 0 处）是文件名，第二个元素（索引 1 处）是文件大小。

假设我们想按文件大小升序排序。因此，我们将key参数设置为lambda x: x[1]，这样就使用了索引 1 处的文件大小作为排序键：

import natsort

# List of tuples containing filename and size
file_data = [
("data_20230101_080000.csv", 100),
("data_20221231_235959.csv", 150),
("data_20230201_120000.csv", 120),
("data_20230115_093000.csv", 80)
]

# Sort file data based on file size
sorted_file_data = natsort.natsorted(file_data, key=lambda x:x[1])

# Print sorted file data
for filename, size in sorted_file_data:
    print(filename, size) 

以下是输出结果：

data_20230115_093000.csv 80
data_20230101_080000.csv 100
data_20230201_120000.csv 120
data_20221231_235959.csv 150

不区分大小写的字符串排序

自然排序还有另一个有用的场景，就是当你需要对字符串进行不区分大小写的排序时。基于 ASCII 值的字典序排序将不会给出期望的结果。

为了进行不区分大小写的排序，我们可以将alg设置为natsort.ns.IGNORECASE，这将在排序时忽略大小写。alg键控制natsorted()使用的算法：

import natsort

# List of strings with mixed case
words = ["apple", "Banana", "cat", "Dog", "Elephant"]

# Sort words naturally with case-insensitivity
sorted_words = natsort.natsorted(words, alg=natsort.ns.IGNORECASE)

print(sorted_words)

在这里，包含混合大小写的单词列表被自然地按不区分大小写的方式排序：

Output >>> ['apple', 'Banana', 'cat', 'Dog', 'Elephant']

总结

就这样！在本教程中，我们回顾了字典序排序的局限性以及自然排序如何成为处理字母数字字符串的良好替代方案。你可以在GitHub上找到所有代码。

我们从简单的例子开始，也了解了如何基于自定义键排序以及在 Python 中处理不区分大小写的排序。接下来，你可以探索natsort 库的其他功能。在另一个 Python 教程中再见。直到那时，继续编程！

Bala Priya C**** 是来自印度的开发者和技术写作人员。她喜欢在数学、编程、数据科学和内容创作的交汇点工作。她的兴趣和专长领域包括 DevOps、数据科学和自然语言处理。她喜欢阅读、写作、编码和咖啡！目前，她正在通过编写教程、使用指南、意见文章等与开发者社区分享她的知识。Bala 还创建了引人入胜的资源概述和编码教程。

更多相关话题

• 用 Python 探索数据清理技术

• 探索 Python itertools 中的无限迭代器

• 用 Python 探索 OpenAI API

• 25 本免费书籍掌握 SQL、Python、数据科学、机器学习……

• 探索思维树提示：AI 如何通过搜索学习推理……

• 探索 GPT-4 的力量和局限性

探索神经网络

原文：www.kdnuggets.com/exploring-neural-networks

想象一下，一台机器像人脑一样思考、学习和适应，并发现数据中的隐藏模式。

这项技术，神经网络（NN），算法在模拟认知。稍后我们将深入探讨神经网络是什么以及它们如何运作。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织进行 IT 支持

---

在这篇文章中，我将向你解释神经网络（NN）的基本方面——结构、类型、实际应用和定义操作的关键术语。

什么是神经网络？

来源: vitalflux.com

称为神经网络（NN）的算法试图在数据中寻找关系，模拟人脑的操作以“学习”数据。

神经网络可以与深度学习和机器学习相结合。因此，首先解释这些术语将是有益的。让我们开始吧。

神经网络与深度学习与机器学习

神经网络构成了深度学习的基础，深度学习是机器学习的一个子集。虽然机器学习模型从数据中学习并进行预测，但深度学习更深入，可以处理大量数据，识别复杂模式。

如果你想了解更多关于机器学习算法的信息，可以阅读这篇文章。

此外，这些神经网络已经成为许多领域的核心部分，作为众多现代技术的支柱，这些应用范围从面部识别到自然语言处理，我们将在后续部分中看到。

让我们探索神经网络在提升日常生活中发挥重要作用的一些常见领域。

神经网络的类型

现实世界的应用丰富了对神经网络的理解，凭借准确、高效的解决方案革新了各行业的传统方法。

让我们突显一些神经网络推动创新和改变日常体验的有趣例子，包括神经网络类型。

作者提供的图片

人工神经网络（ANN）：

人工神经网络（ANN）的架构受到人脑生物神经网络的启发。网络由相互连接的层组成，包括输入层、隐藏层和输出层。每一层包含多个神经元，这些神经元与相邻层的每个神经元相连。

随着数据在网络中流动，每个连接应用一个权重，每个神经元应用一个激活函数，如 ReLU、Sigmoid 或 Tanh。这些函数引入非线性，使网络能够从错误中学习并做出复杂决策。

在训练过程中，使用称为反向传播的技术来调整这些权重。这种技术使用梯度下降来最小化预定义的损失函数，旨在使网络的预测尽可能准确。

ANN 使用案例

客户流失预测

人工神经网络分析用户行为、购买历史和与客服的互动等多个特征，以预测客户离开服务的可能性。

人工神经网络可以建模这些特征之间的复杂关系，提供细致的视角，对于准确预测客户流失至关重要。

销售预测

人工神经网络利用历史销售数据和其他变量，如营销支出、季节性和经济指标，来预测未来销售。

他们从错误中学习并调整变量之间复杂的非线性关系的能力使他们非常适合这个任务。

垃圾邮件过滤

人工神经网络分析邮件的内容、上下文和其他特征，以将其分类为垃圾邮件或非垃圾邮件。

他们可以学习识别新的垃圾邮件模式，并随着时间的推移进行调整，这使他们在过滤不需要的消息时非常有效。

CNN（卷积神经网络）：

卷积神经网络（CNNs）专门用于涉及空间层次结构的任务，如图像识别。网络使用称为卷积层的专用层，将一系列滤波器应用于输入图像，生成一组特征图。

这些特征图随后通过池化层，减少其维度，使网络在计算上更高效。最后，一个或多个全连接层进行分类。

训练过程涉及反向传播，类似于人工神经网络（ANNs），但调整以保持特征的空间层次结构。

CNN 使用案例

图像分类

卷积神经网络应用一系列滤波器和池化层来自动识别图像中的层次模式。

他们减少维度并关注重要特征的能力使他们在图像分类中既高效又准确。

对象检测

卷积神经网络不仅分类，还通过绘制边界框来定位图像中的对象。

该架构设计用于识别空间层次结构，使其能够在单个图像中识别多个对象。

图像分割

卷积神经网络可以将标签分配给图像中的每个像素，将其分类为属于特定对象或背景。

网络的粒度像素级理解使其非常适合于医疗成像等需要精确分割的任务。

RNN（循环神经网络）：

循环神经网络（RNNs）的不同之处在于它们具有内部循环或递归结构，使它们能够存储信息。这使得它们非常适合处理序列数据，因为每个神经元可以利用其内部状态记住序列中前一个时间步的信息。

在处理数据时，网络会考虑当前和之前的输入，从而形成一种短期记忆。然而，RNNs 可能会遇到梯度消失和爆炸等问题，这使得学习数据中的长期依赖关系变得困难。

为了解决这些问题，开发了更高级的版本，如长短期记忆（LSTM）和门控递归单元（GRU）网络。

RNN 使用案例

语音转文本

RNNs 接受音频序列作为输入，产生文本序列作为输出，考虑到口语语言中的时间依赖关系。

RNNs 的递归性质使其能够考虑音频输入的序列，使其擅长理解人类语音中的上下文和细微差别。

机器翻译

RNNs 将一个语言的序列转换为另一个语言的序列，考虑整个输入序列以产生准确的输出序列。

序列到序列学习能力保持语言之间的上下文，使翻译更准确且具有上下文相关性。

情感分析

RNNs 分析文本序列以识别和提取观点和情感。

RNNs 中的记忆特性有助于捕捉文本序列中的情感积累，使其适合用于情感分析任务。

结论

展望未来，前景承诺神经网络的持续进步和特殊应用场景。随着算法的发展，以处理更复杂的数据，它们将在医疗、交通、金融等领域解锁新的可能性。

要学习神经网络，做一个实际项目非常有效。从面部识别到疾病预测，它们正在重塑我们的生活和工作方式。

在本文中，我们回顾了其基本原理、面部检测和识别等实际例子，以及更多内容。

感谢阅读！

Nate Rosidi 是一名数据科学家和产品战略专家。他还是一名兼职教授，教授分析学，并且是StrataScratch的创始人，该平台帮助数据科学家准备来自顶级公司的真实面试问题。他可以通过Twitter: StrataScratch或LinkedIn与他联系。

更多相关话题

• 在神经网络之前尝试的 10 个简单方法

• 使用 PyTorch 进行可解释的神经网络

• 深度神经网络并未引导我们迈向 AGI

• 可解释的预测与现状预测：前沿深度学习方法

• 使用卷积神经网络（CNNs）进行图像分类

• 关于可信图神经网络的全面调研：隐私、鲁棒性、公平性、可解释性

探索 GPT-4 的能力和局限性

原文：www.kdnuggets.com/2023/07/exploring-power-limitations-gpt4.html

作者提供的图片

曾经好奇过更新更先进的 GPT-4 与其前身 ChatGPT 3.5 的比较吗？

GPT-4 有什么独特之处？它的局限在哪里？

随着我们深入探讨语言模型的局限性及其潜在应用，理解这些细微差别至关重要。

在这段人工智能领域的探索旅程中，我们将突出 ChatGPT 4 的独特功能、其创新插件及其如何革新我们解决数据科学领域技术问题的方式。

从解决统计和概率的复杂性，到应对复杂的建模问题和 Python、SQL 或 R 的编程查询，我们将探讨 GPT-4 在数据科学中的各种助力方式。

所以，系好安全带，跟随我们踏上这段探索之旅，剖析 GPT-4 及其如何重塑我们对数据科学的理解！

ChatGPT 3.5 和 ChatGPT 4

GPT-3.5，也被称为 ChatGPT，是由 OpenAI 于 2022 年 11 月公开的。

它迅速在全球范围内流行，甚至在某些时候由于超出服务器容量而导致 OpenAI 推出了付费版 ChatGPT Plus 以应对需求。

GPT-4 于 3 月 14 日发布，相较于 GPT-3.5 有了显著升级。

它具有先进的推理能力，即使它可以从数据中生成意义而非文本（如图片），目前的 ChatGPT+ 版本仍然仅支持文本输出。

GPT-4 的问题解决能力比 GPT-3.5 更为准确。

目前，ChatGPT+ 的付费版每月费用为 $20，但它有一定的限制，比如每 3 小时最多 25 条消息。

此外，微软的搜索引擎 Bing 也在运行定制版的 GPT-4。

欲了解更多信息，请查看 OpenAI 网站上关于 GPT-4 的官方博客文章。

ChatGPT 插件

来源: chat.openai.com/

OpenAI 于 3 月 23 日推出了 ChatGPT 的新功能——插件。

这些工具旨在增强语言模型的能力，使其能够获取最新信息并执行计算。

这些插件的推出是逐步进行的，以评估它们的实际使用、影响以及潜在的安全和对齐问题。

各种公司，包括 KAYAK、Klarna、Milo、Shopify、Slack、Speak、Wolfram、Zapier 等，已经开发了初步的一套插件。

这些插件提供了广泛的功能，例如旅行规划、杂货订购、计算访问和实时数据检索。

OpenAI 还提供了两个插件：网页浏览器 和 代码解释器。

虽然网页浏览器允许你通过 GPT 模型的能力访问网络，但代码解释器将帮助你通过简单的提示来处理和分析数据。

其中一些插件，如 Noteable 和 Wolfram，在数据科学中尤其有用。

这些插件旨在增加 ChatGPT 的实用性。

GPT-4 能否用于回答数据科学中的技术问题？

我们可以将数据科学问题分为非编码和编码面试问题。

通过测试 ChatGPT-4 在这些方面的能力，我们将更好地理解 ChatGPT-4 如何用于回答数据科学中的技术问题。

让我们从非编码问题开始。

非编码问题

在这里，我们将把非编码问题分为统计、概率和建模。

图片由作者提供

统计学

统计学对数据科学至关重要，包括数据收集、分析、解释、展示和组织。

GPT-4 能够回答有关统计概念的问题，提供对复杂统计原理的全面理解。

以这种方式使用 GPT-4 可以提高对统计理论的理解，并帮助数据科学家从数据中提取有意义的洞察。

这里是我们将用来测试 Chat 能力的 统计问题。我们将使用 Wolfram 插件，它在计算时帮助用户。

此外，使用 ChatGPT-4 及其插件时有一个重要的注意事项：它们可能很好，但并不完美，所以一定要始终双重检查输出，因为它可能是错误的。

提示：为什么均方误差（MSE）常被用作线性回归的损失函数？

（使用 Wolfram 插件，提供公式）

ChatGPT：MSE 的公式是：

其中：

• 是观察数

• 是实际值和

• 是预测值。

以下是 MSE 常被使用的原因：

1. 可微性：MSE 是一个光滑且可微的函数。这一点很重要，因为优化算法，如梯度下降，依赖于函数的导数来寻找最小值。

2. 对异常值的敏感性：均方误差中的平方项给予较大误差更高的权重。这意味着模型对异常值更敏感，会试图最小化较大的误差。

3. 可解释性：均方误差易于解释，因为它表示预测值与实际值之间的平均平方差。较低的均方误差表示模型与数据的拟合更好。

4. 凸性：均方误差（MSE）导致了一个凸损失函数的地形。凸问题有一个唯一的全局最小值，使得使用优化算法解决这些问题更容易。

5. 与 OLS 的一致性：在线性回归中，最小化均方误差等同于最小化普通最小二乘法（OLS）中的残差，OLS 是估计线性回归模型参数的标准方法。

作者注：尽管均方误差有这些优点，但它并不是每个回归问题的最佳选择。根据数据和问题的具体特征，其他损失函数可能更为合适。

控制

ChatGPT 的回答详细且正确。

概率

概率在数据科学中至关重要，因为它为做出数据预测和理解不确定性提供了结构。它可以详细说明这些概念，解释数学计算和特定事件的可能性背后的逻辑。

这帮助数据科学家构建模型并做出基于概率推理的智能决策。

这是概率问题 ChatGPT 会尝试解决的。

问题：你和朋友玩一个游戏，掷两个公平的六面骰子。如果两个骰子的总和是 7 或 11，你就赢了；否则，你的朋友赢。你第一次掷骰子的获胜概率是多少？

ChatGPT：要确定第一次掷骰子的获胜概率，我们需要计算有利结果（获胜结果）的数量，并将其除以所有可能结果的总数。

在这种情况下，每个骰子有 6 种可能的结果，因为它们是公平的六面骰子。因此，掷两个骰子的所有可能结果的总数是：6 × 6 = 36

要在第一次掷骰子时获胜，两个骰子的总和必须是 7 或 11。我们可以如下计算有利结果的数量：

1. 总和为 7：有 6 种方式可以实现这一结果：(1, 6)、(2, 5)、(3, 4)、(4, 3)、(5, 2)和(6, 1)。

2. 总和为 11：有 2 种方式可以实现这一结果：(5, 6) 和 (6, 5)。

因此，总共有 6 + 2 = 8 种有利结果。

现在，我们可以通过将有利结果的数量除以所有可能结果的总数来计算第一次掷骰子的获胜概率：

第一次掷骰子的获胜概率 = 有利结果的数量 / 可能结果的总数 = 8 / 22 = 2 / 9 = 0.222

因此，你第一次掷骰子的胜率大约是 0.222 或 22.2%。

控制

输出是正确的，与平台上的解决方案匹配。

建模

建模是形成系统数学描述以分析和预测行为的过程。

它可以帮助数据科学家理解概念、假设、实现和结果的解释。这将导致对数据的预测和理解的改进。

这里是我们将要测试的 建模问题。

提示 : K-means 算法是如何工作的？

ChatGPT : K-means 算法是一种迭代聚类算法，旨在将给定的数据集划分为 K 个簇，其中 K 是用户定义的参数。

它的工作原理如下：

1. 初始化：从数据集中随机选择 K 个数据点作为簇的初始质心（代表点）。

2. 分配：根据距离度量（通常是欧几里得距离）将每个数据点分配给最近的质心。此步骤形成 K 个簇。

3. 更新：通过取分配给每个簇的所有数据点的均值来重新计算簇的质心。此步骤旨在找到更好的质心，以代表每个簇的中心。

4. 迭代：重复分配和更新步骤，直到收敛。收敛发生在质心停止显著变化或达到最大迭代次数时。

5. 输出：算法返回最终的 K 个簇，其中每个数据点属于最近的质心所在的簇。

K-means 算法旨在最小化簇内平方距离的总和，也称为惯性或总簇内方差。它假设簇是球形的，并具有相等的方差。然而，根据质心的初始化，算法可能会收敛到次优解。

为了提高 K-means 的性能，可以应用各种技术，例如使用多个初始化、执行更智能的质心初始化方法（如 K-means++），或使用肘部法来确定 K 的最佳值。

需要注意的是，K-means 对初始质心的选择敏感，可能在处理包含非线性或不规则形状簇的数据集时遇到困难。在这种情况下，像 DBSCAN 或高斯混合模型（GMM）等替代聚类算法可能更合适。

控制

ChatGPT 的回答详细且正确。

编码问题

编码对数据科学家来说是必需的。它包括使用 Python 进行数据处理和机器学习，使用 SQL 进行数据库处理，以及使用 R 进行统计计算。GPT-4 可以协助解决编码问题。

图片由作者提供

让我们在编码问题上测试 ChatGPT-4，从 Python 开始。

Python

Python 在数据科学社区中是一种受欢迎的语言，因为它的用户友好性和强大的库，如 pandas、numpy 和 scikit-learn。

GPT-4 可以协助调试 Python 代码、推荐最佳编码实践，甚至为特定任务生成代码片段。

现在让我们用以下问题来尝试一下。

问题 1

这是我将输入到 ChatGPT-4 的 问题。

提示：

我的数据集名称是 airbnb_search_details，以下是更多信息；

未命名: 0:int64

id:int64

price:float64

property_type: object

room_type: object

amenities:object

accommodates:int64

bathrooms:int64

bed_type:object

cancellation_policy:object

cleaning_fee:bool

city:object

host_identity_verified:object

host_response_rate:object

host_since:datetime64[ns]

neighbourhood:object

number_of_reviews:int64

review_scores_rating:float64

zipcode:int64

bedrooms:int64

beds:int64

问题是：找出所有卧室数量等于浴室数量的住宿搜索。确保预期输出类型为数据框。

作者备注： 要将数据集输入到 Chat 中，只需像下面示例一样从平台上复制它。

ChatGPT： 要找出所有卧室数量等于浴室数量的住宿搜索，你可以使用以下 Python 代码：

import pandas as pd
# Assuming 'airbnb_search_details' is the DataFrame containing your dataset
# Replace 'airbnb_search_details' with the actual name of your DataFrame if different
# Filter the DataFrame based on the condition: number of bedrooms == number of bathrooms
result = airbnb_search_details[airbnb_search_details['bedrooms'] == airbnb_search_details['bathrooms']]
# Display the resulting DataFrame
print(result) 

控制

实际上，ChatGPT 的大部分回答都正确，除了最后一行。没有必要使用 print 函数打印结果数据框，因此当代码更新如下时，解决方案是有效的。

import pandas as pd
# Assuming 'airbnb_search_details' is the DataFrame containing your dataset
# Replace 'airbnb_search_details' with the actual name of your DataFrame if different
# Filter the DataFrame based on the condition: number of bedrooms == number of bathrooms
result = airbnb_search_details[airbnb_search_details['bedrooms'] == airbnb_search_details['bathrooms']]
# Display the resulting DataFrame
result

问题 2

这是我将输入到 ChatGPT-4 的 问题。

我将基本上复制并粘贴我提示中的所有信息。

提示：

给定一个整数数组 nums 和一个整数 val，在 nums 中就地移除所有 val 的出现。元素的顺序可能会改变。然后返回 nums 中不等于 val 的元素个数。

考虑到 nums 中不等于 val 的元素个数为 k，要被接受，你需要做以下事情：

更改数组 nums，使得 nums 的前 k 个元素包含不等于 val 的元素。剩余的 nums 元素以及 nums 的大小都不重要。

返回 k。

自定义评判器：

法官将用以下代码测试你的解决方案：

int[] nums = [...]; // 输入数组

int val = ...; // 要移除的值

int[] expectedNums = [...]; // 预期的正确长度答案。

// 它已排序且没有值等于 val。

int k = removeElement(nums, val); // 调用你的实现

assert k == expectedNums.length;

sort(nums, 0, k); // 对 nums 的前 k 个元素进行排序

for (int i = 0; i < actualLength; i++) {

assert nums[i] == expectedNums[i];

}

如果所有断言通过，那么你的解决方案将被接受。

示例 1:

输入: nums = [3,2,2,3], val = 3

输出: 2, nums = [2,2,,]

解释: 你的函数应该返回 k = 2，nums 的前两个元素为 2。

无论你在返回的 k 之后留下什么（因此它们是下划线）都无所谓。

示例 2:

输入: nums = [0,1,2,2,3,0,4,2], val = 2

输出: 5, nums = [0,1,4,0,3,,,_]

解释: 你的函数应该返回 k = 5，nums 的前五个元素包含 0, 0, 1, 3 和 4。

注意这五个元素可以以任何顺序返回。

无论你在返回的 k 之后留下什么（因此它们是下划线）都无所谓。

限制条件:

0 <= nums.length <= 100

0 <= nums[i] <= 50

0 <= val <= 100

解决方案格式；

class Solution:

def removeElement(self, nums: List[int], val: int) -> int:

ChatGPT: 这是用 Python 实现的解决方案：

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        k = 0  # Counter for elements not equal to val

        # Iterate through the array
        for i in range(len(nums)):
            if nums[i] != val:
                nums[k] = nums[i]  # Move the element to the kth position
                k += 1

        return k 

解决方案使用双指针方法原地修改 nums 数组，并计算不等于 val 的元素数量。变量 k 用于跟踪下一个非 val 元素应该放置的位置。

算法遍历数组，每当遇到一个不等于 val 的元素时，它就被移动到第 k 个位置，并且 k 增加。最后，k 表示不等于 val 的元素的数量。

你可以使用提供的自定义判题代码测试解决方案，以验证它是否对给定示例产生预期的输出并通过断言。

控制

代码工作正常，无需任何更新。

SQL

SQL 对于处理数据库至关重要。GPT-4 可以帮助制定 SQL 查询、提升数据库效率，并掌握复杂的 SQL 概念。

问题 1

这是我们将尝试解决的 SQL 问题。

提示 : 问题如下：在最近的广告活动之后，营销部门希望根据每种产品的总销售量对其工作进行分类。

你需要计算每种产品的总销售量，并根据以下标准对广告表现进行分类：

优秀: 30+

满意: 20 - 29

不满意: 10 - 19

差: 1 - 9

你的输出应该包含产品 ID、按降序排列的总销售量以及其分类的广告表现。

我的数据集名称是 marketing_campaign，以下是数据类型。

marketing_campaign

user_id: int

created_at: datetime

product_id: int

quantity: int

price: int

这是期望的输出：

product_id total_sold ad_performance

105 41 杰出

102 29 满意

114 23 满意

118 22 满意

120 21 满意

使用 MySQL 解决此问题。

ChatGPT：要使用 MySQL 解决此任务，您可以编写一个查询来计算每个产品的总销售单位，并根据给定的标准对广告效果进行分类。

以下是查询：

SELECT
    product_id,
    SUM(quantity) AS total_sold,
    CASE
        WHEN SUM(quantity) >= 30 THEN 'Outstanding'
        WHEN SUM(quantity) BETWEEN 20 AND 29 THEN 'Satisfactory'
        WHEN SUM(quantity) BETWEEN 10 AND 19 THEN 'Unsatisfactory'
        WHEN SUM(quantity) BETWEEN 1 AND 9 THEN 'Poor'
    END AS ad_performance
FROM
    marketing_campaign
GROUP BY
    product_id
ORDER BY
    total_sold DESC; 

在这个查询中，我们选择 product_id，计算数量的总和作为 total_sold，并使用 CASE 语句根据 total_sold 的值对广告效果进行分类。查询按 product_id 分组，按 total_sold 降序排列，并提供所需的输出。

确保将“marketing_campaign”替换为数据库中表的实际名称。

运行此查询将为您提供包含 product_id、total_sold 和 ad_performance 的预期结果，根据标准进行分类。

控制

代码运行完美，无需任何更新。

问题 2

这里是 第二个 SQL 问题 来自 LeetCode。

提示 : 表：Sales

+-------------+-------+

列名	类型

+-------------+-------+

sale_id	int
product_id	int
year	int
quantity	int
price	int

+-------------+-------+

(sale_id, year) 是该表的主键。product_id 是 Product 表的外键。

该表的每一行显示了某一年中 product_id 产品的销售情况。请注意价格是每单位的。

表：Product

+--------------+---------+

列名	类型

+--------------+---------+

product_id	int
product_name	varchar

+--------------+---------+

product_id 是该表的主键。

该表的每一行表示每个产品的产品名称。

编写一个 SQL 查询，选择每个销售的产品的产品 id、年份、数量和价格的第一个年份。

返回结果表可以按任何顺序。

查询结果格式如下例所示。

示例 1：

输入：

销售表：

+---------+------------+------+----------+-------+

sale_id	product_id	year	quantity	price

+---------+------------+------+----------+-------+

1	100	2008	10	5000
2	100	2009	12	5000
7	200	2011	15	9000

+---------+------------+------+----------+-------+

产品表：

+------------+--------------+

product_id	product_name

+------------+--------------+

100	诺基亚
200	苹果
300	三星

+------------+--------------+

输出：

+------------+------------+----------+-------+

product_id	first_year	quantity	price

+------------+------------+----------+-------+

100	2008	10	5000
200	2011	15	9000

+------------+------------+----------+-------+

ChatGPT： 要选择每个产品销售的第一年的产品 ID、年份、数量和价格，你可以使用以下 SQL 查询：

SELECT s.product_id, s.year AS first_year, s.quantity, s.price
FROM Sales s
JOIN (
    SELECT product_id, MIN(year) AS first_year
    FROM Sales
    GROUP BY product_id
) t ON s.product_id = t.product_id AND s.year = t.first_year
ORDER BY s.product_id; 

解释：

1. 子查询（SELECT product_id, MIN(year) AS first_year FROM Sales GROUP BY product_id）使用 MIN() 函数选择每个产品的最小年份，并按 product_id 分组结果。

2. 主查询将 Sales 表与子查询连接，基于匹配的 product_id 和 year 列，以检索每个产品的第一年的销售记录。

3. 从 Sales 表中返回所选列，包括 product_id、年份（作为 first_year）、数量和价格，匹配记录。

4. 结果按 product_id 升序排列。

查询将返回每个产品销售的第一年的产品 ID、年份、数量和价格，如示例输出所示。

控制

代码正常工作，无需更新。

R

R 是一种专为统计评估和数据可视化而构建的语言。GPT-4 可以支持理解 R 语言的细微差别、调试 R 代码以及使用各种 R 包进行数据分析。

问题

这是编码 问题。

提示：

问题是：对于每个客人评论者，根据客人给主机的最高评分找到评论者最喜欢的主机的国籍。输出客人的用户 ID 以及他们最喜欢的主机的国籍。如果有多个来自同一国家的最喜欢的主机，只列出该国家一次（去除重复）。

from_user 和 to_user 列都是用户 ID。

预期输出如下：

from_user 国籍

0 卢森堡

1 巴西

2 澳大利亚

3 澳大利亚

4 巴西

数据框如下：

airbnb_reviews

from_user:int64

to_user:int64

from_type: object

to_type: object

review_score:int64

airbnb_hosts

host_id: int64

nationality: object

gender: object

age:int64

使用 R 解决这个问题。

提示：

使用 [column_name] 选择数据框中的特定列，然后选择值等于 '==' 的行。

使用 .groupby(column_name) 按指定列对数据框进行分组，然后使用 max() 获取每组的最高分数。

对原始数据框和分组数据框执行内连接，以使用 pd.merge(dataframe1, dataframe2, on = common_table_keys) 获取分组数据框的相应属性/详细信息。

对结果数据框和 airbnb_hosts 执行内连接。

使用 [[ column_name/s ]] 选择数据框中的指定列，然后使用 drop_duplicates(column_name) 获取指定列中的唯一值。

ChatGPT: 要使用 R 解决此任务，你可以按照以下步骤进行：

1. 从 'airbnb_reviews' 数据框中选择必要的列，并过滤出 'from_type' 为 'guest' 的行。

2. 按 'from_user' 对过滤后的数据框进行分组，并使用 max() 函数获取每位客人的最高评价分数。

3. 在原始数据框和分组数据框之间执行内连接，基于 'from_user' 和 'review_score' 列，以获取每位客人的最高评价分数对应的行。

4. 在结果数据框和 'airbnb_hosts' 数据框之间执行另一个内连接，基于 'to_user' 和 'host_id' 列，以获取喜爱的主机的国籍。

5. 从最终连接的数据框中选择 'from_user' 和 'nationality' 列。

6. 使用 distinct() 函数根据 'nationality' 列删除重复行。

这是实现此功能的代码：

# Select necessary columns from airbnb_reviews and filter rows where from_type is 'guest'
filtered_reviews <- airbnb_reviews[airbnb_reviews$from_type == 'guest', c('from_user', 'to_user', 'review_score')]

# Group by from_user and get the maximum review score for each guest
max_scores <- aggregate(review_score ~ from_user, filtered_reviews, max)

# Perform inner join to get the rows with the maximum review score for each guest
joined_df <- merge(filtered_reviews, max_scores, by = c('from_user', 'review_score'))

# Perform inner join with airbnb_hosts to get the nationality of the favorite host
final_df <- merge(joined_df, airbnb_hosts, by.x = 'to_user', by.y = 'host_id')

# Select the necessary columns from the final joined dataframe
result <- final_df[, c('from_user', 'nationality')]

# Remove duplicate rows based on nationality
distinct_result <- distinct(result, .keep_all = TRUE)

# Print the final result
distinct_result

运行此代码将会得到预期的输出，其中包含 'from_user'（客人 ID）和他们喜爱主机的相应 'nationality'。

控制

代码运行正常，无需任何更新。

奖金：使用 ChatGPT 进行数据项目

我们将测试 ChatGPT 的数据项目 已在 Uber 的数据科学职位招聘过程中作为家庭作业使用过。

总的来说，有两种不同的情况；

情况 1：这将是一个繁忙的星期六，道路上需要比上周更多的车辆。为了让司机上线，我们正在评估以下两种奖励选项的成本：

• 选项 1：每位在线时间达到 8 小时、接受 90% 请求、完成 10 次行程且评分为 4.7 或更高的司机，奖励 $50；

• 选项 2：所有完成 12 次行程且评分为 4.7 或更高的司机，每次行程奖励 $4。

情况 2：一名出租车司机目前每天的收入为 $200（不包括费用），每周工作六天，休息三周，费用如下：

• 油费 - 每周 $200

• 保险 - 每月 $400

• 车辆租赁（按周计算）- $500

司机在休息周不需要支付油费和租赁费用。

ChatGPT 文件上传器

现在，要进行数据项目，我们需要 ChatGPT 文件上传器 Chrome 扩展。它将允许你将文件上传到 ChatGPT。

如果你已经有一个代码解释器插件，则无需此操作——只需使用该插件上传文件。

欲了解更多信息，请观看这个 视频。

在设置文件上传扩展后，让我们尝试解决这个数据项目。

打开 ChatGPT 并点击此扩展的按钮。

你将看到如下所示的提交按钮。

来源: chat.openai.com/

现在，让我们先通过使用我们的数据集文件并点击“提交文件”按钮来喂给 ChatGPT 数据集。

来源: chat.openai.com/

加载数据集后，ChatGPT 将提示数据集。

来源: chat.openai.com/

现在，这里是你应该用来解决此数据项目的提示。

提示： 根据操作情境和提供的数据集，使用 Python 回答以下问题

任务

情境 1：将会有一个大型的星期六，需要比上周更多的车辆上路。为了让司机上线，我们正在评估以下两种奖金选项的成本：

选项 1：每位司机在线至少 8 小时，接受 90% 的请求，完成 10 次行程，并且在此时间段内评分为 4.7 或更高，奖金为 $50；

选项 2：每次行程 $4，适用于所有完成 12 次行程且评分为 4.7 或更高的司机。

使用提供的数据集和给定的情境 1，回答以下问题：

选项 1 的总奖金支付额是多少？

选项 2 的总奖金支付额是多少？

有多少司机符合选项 1 的奖金条件但不符合选项 2？

在线的司机中，有多少百分比完成了少于 10 次行程，接受率低于 90%，并且评分为 4.7 或更高？

情境 2：一位出租车司机目前每天的收入为 200 美元（扣除费用前），每周工作六天，休息三周，拥有以下费用：

油费 - 每周 $200

保险 - 每月 $400

车辆租金（按周计算）- $500

司机在休息周期间不支付油费和租金费用。

现在，假设同一位司机购买了 Town Car 并与 Uber 合作。如果这样，他的油费将增加 5%，保险费用将减少 20%，并且不再租车。然而，他需要购买一辆车。司机仍将每年休息三周。

在情境 2 下，回答以下问题：

如果出租车司机不与 Uber 合作，每年赚多少钱（扣除费用后）？

你正在说服上述司机购买一辆 Town Car 并与 Uber 合作。假设新车价格为 40,000 美元，司机的总收入每周需要增加多少才能在第 1 年内完全支付车辆费用并维持与之前相同的年度利润率？

ChatGPT：

为了进行这些计算，我们首先需要加载和预处理数据集。我们将使用 Python 的 pandas 库来加载 CSV 文件并解析所需的列。

不幸的是，作为一个基于文本的模型，我无法直接执行代码。但我可以提供给你用于回答问题的 Python 代码：

这是你需要的代码，以回答场景 1 的问题：

import pandas as pd

# Load dataset
data = pd.read_csv('dataset_2.csv')

# Convert 'Accept Rate' from string percentage to float
data['Accept Rate'] = data['Accept Rate'].str.rstrip('%').astype('float') / 100.0

# Calculate bonus under both options
data['Option 1 Bonus'] = ((data['Supply Hours'] >= 8) & (data['Accept Rate'] >= 0.9) & 
                          (data['Trips Completed'] >= 10) & (data['Rating'] >= 4.7)) * 50
data['Option 2 Bonus'] = ((data['Trips Completed'] >= 12) & (data['Rating'] >= 4.7)) * data['Trips Completed'] * 4

# Compute total payout for each option
total_payout_option1 = data['Option 1 Bonus'].sum()
total_payout_option2 = data['Option 2 Bonus'].sum()

# Compute number of drivers who qualify under Option 1 but not Option 2
num_option1_only = ((data['Option 1 Bonus'] > 0) & (data['Option 2 Bonus'] == 0)).sum()

# Compute percentage of drivers who complete less than 10 trips, had an acceptance rate of less than 90% and had a rating of 4.7 or higher
percent_undesirable_drivers = ((data['Trips Completed'] < 10) & (data['Accept Rate'] < 0.9) & (data['Rating'] >= 4.7)).mean() * 100

print('Total bonus payout for Option 1: $', total_payout_option1)
print('Total bonus payout for Option 2: $', total_payout_option2)
print('Number of drivers who qualify under Option 1 but not Option 2: ', num_option1_only)
print('Percentage of drivers who complete less than 10 trips, had an acceptance rate of less than 90%, and had a rating of 4.7 or higher: ', percent_undesirable_drivers) 

这是你需要的代码，以回答场景 2 的问题：

# Calculate the taxi driver's yearly income and expenses
daily_income = 200
weekly_income = daily_income * 6  # Working 6 days a week
yearly_income = weekly_income * 52  # Working all year
yearly_expenses = (200 * 49) + (400 * 12) + (500 * 49)  # No expenses on off weeks
yearly_net = yearly_income - yearly_expenses

# Calculate the new expenses and net income if the driver partners with Uber
new_yearly_expenses = (200 * 1.05 * 49) + (400 * 0.8 * 12)  # 5% increase in gas, 20% decrease in insurance
new_yearly_net = yearly_income - new_yearly_expenses - 40000  # Subtract car cost

# Calculate the increase in gross fares necessary to maintain the same profit margin
additional_income_required = yearly_net - new_yearly_net
additional_income_required_weekly = additional_income_required / 52

print('Taxi driver yearly net income: $', yearly_net)
print('Required increase in weekly gross fares: $', additional_income_required_weekly)

你可以将 read_csv 函数中的文件路径替换为你实际的数据集 _2.csv 文件路径，然后在你的本地 Python 环境中运行这些代码片段。

控制

第一个场景的输出完全正确（前 4 个问题），但是，第二个场景的输出是不正确的。

例如，它计算了司机工作 52 周（一整年）；然而，司机休了 3 周假。

这就是为什么你需要对 ChatGPT 进行的计算保持谨慎，并检查其遵循的步骤，以确保结果的正确性。

经过几次尝试，这里是输出正确结果的代码，这个结果是 ChatGPT 提供的。

# Weeks off per year
weeks_off = 3

# Total weeks per year
total_weeks_per_year = 52

# Weeks of work per year
working_weeks = total_weeks_per_year - weeks_off

# Total months per year
total_months_per_year = 12

# Expenses
gas_per_week = 200
insurance_per_month = 400
vehicle_rent_per_week = 500

# Revenue
fare_per_day = 200 
work_days_per_week = 6
total_revenue = fare_per_day * work_days_per_week * working_weeks

# Total Expenses
total_expenses = (gas_per_week + vehicle_rent_per_week) * working_weeks + insurance_per_month * total_months_per_year

# Net Income
net_income = total_revenue - total_expenses

print("Net Income per year: $", net_income)

# For Question 6:

# Expenses changes
new_gas_per_week = gas_per_week * 1.05  # 5% increase
new_insurance_per_month = insurance_per_month * 0.8  # 20% decrease
car_cost = 40000

# New Total Expenses
new_total_expenses = car_cost + (new_gas_per_week * working_weeks) + (new_insurance_per_month * total_months_per_year)

# To maintain the same net income, the new revenue should be:
new_total_revenue = new_total_expenses + net_income

# This translates to a required increase in weekly fares:
additional_fare_per_week = (new_total_revenue - total_revenue) / working_weeks

print("Required increase in weekly fares: $", additional_fare_per_week)

结语

这次探索揭示了 GPT-4 在数据科学领域的创新应用和固有局限性。

无论是处理复杂的统计和概率问题，建模问题，还是解答编码查询，GPT-4 都展示了令人期待的能力。

然而，重要的是要记住，尽管 GPT-4 提供了一个有价值的工具，但人工监督和理解仍然至关重要，尤其是在数学计算方面，以确保质量结果。

这次探索只是 GPT-4 旅程的开始，因为进一步的进展和改进始终在前方。OpenAI 的 CEO Sam Altman 表示，在未来的模型（GPT-5）中，OpenAI 计划解决不准确计算的问题以及提示数量的限制。

继续保持好奇，保持探索，并记住，AI 潜力的唯一限制是我们为它设定的限制。

Nate Rosidi 是一名数据科学家和产品策略专家。他还是一名兼职教授，教授分析学，并且是StrataScratch的创始人，该平台帮助数据科学家为面试做好准备，提供来自顶级公司的真实面试问题。你可以通过Twitter: StrataScratch或LinkedIn与他联系。

更多相关话题

• 预测未来事件：AI 和 ML 的能力与局限

• AI 与数据分析师的对比：影响分析未来的 6 大限制

• 释放 AI 的力量 - KDnuggets 和 Machine 的特别发布

• 解锁健康经济学和结果研究中数字的力量

• 利用数据的力量的 3 个步骤

• 为有效的 Tableau 和 Power BI 仪表板准备数据

探索 Python 基础

原文：www.kdnuggets.com/2019/01/exploring-python-basics.html

赞助帖子。

面对现实吧。学习计算机编程唯一的方法就是实践。不管你是想提升技能以准备下一次面试，还是仅仅完成一些个人项目，编程都是一个很棒的工具。Python 对初学者尤其是一个很好的工具，它也是一个会随着你成长的语言。通过利用 Python 的大量框架和工具包，你可以将其用于从网页开发到数据科学的各种任务。掌握 Python 基础，你几乎可以在编程世界的任何地方前进！

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你所在的组织的 IT 需求

---

探索 Python 基础 是来自多本 Manning 图书的章节集合，融合在一起，带你全面了解 Python。由Naomi Ceder精心挑选，她是 Python 教育峰会的创始人，这些章节将带你了解编程基础、Python 的特性和语法、使用 Raspberry Pi 编程，甚至使用 Python 建模数据以创建准确的预测！完成后，你将真正欣赏 Python，准备好继续你的这段有用语言之旅。

获取 探索 Python 基础 书籍。

更多相关话题

• Python 基础：语法、数据类型和控制结构

• 基础知识回顾 第 1 周：Python 编程与数据科学基础

• 如何通过 ChatGPT 学习 Python 基础

• 掌握数据科学中的 Python：超越基础

• 使用 Python 探索数据清理技术

• 在 Python 的 itertools 中探索无限迭代器

探索递归神经网络

原文：www.kdnuggets.com/2017/12/exploring-recurrent-neural-networks.html

评论

由 Packtpub 提供。

在本教程中，选自 《Theano 深度学习实战》 由 Dan Van Boxel 编写，我们将探索递归神经网络。我们将从基础知识开始，然后通过一个激励性的天气建模问题来研究 RNNs。我们还将在 TensorFlow 中实现并训练一个 RNN。

在一个典型的模型中，你有一些 X 输入特征和一些 Y 输出你想要预测。我们通常认为不同的训练样本是独立的观测值。因此，数据点一的特征不应该影响数据点二的预测。但如果我们的数据点是相关的呢？最常见的例子是每个数据点，Xt，表示在时间t收集的特征。自然地，我们可以假设时间 t 和 t+1 的特征对时间 t+1 的预测都很重要。换句话说，历史是重要的。

现在，在建模时，你可以简单地包含两倍的输入特征，将前一个时间步骤的特征添加到当前特征中，并计算两倍的输入权重。但是，如果你要花费所有精力来构建一个神经网络来计算变换特征，那么最好在当前时间步骤网络中使用来自前一个时间步骤的中间特征。

RNNs 正是如此。考虑你的输入，Xt，如往常一样，但添加一些状态，St-1，来自前一个时间步骤，作为额外特征。现在你可以像往常一样计算权重来预测Yt，并生成一个新的内部状态，St，以便在下一个时间步骤中使用。对于第一个时间步骤，通常使用默认或零初始状态。经典的 RNNs 就是这么简单，但今天文献中有更先进的结构，如门控递归单元和长短期记忆电路。这些超出了本教程的范围，但遵循相同的原则，并通常适用于相同类型的问题。

权重建模

你可能会想，我们如何计算所有这些对前一时间步骤的依赖权重。计算梯度确实涉及回溯时间计算，但不用担心，TensorFlow 处理繁琐的部分，让我们可以进行建模：

# read in data
filename = 'weather.npz'
data = np.load(filename)
daily = data['daily']
weekly = data['weekly']

num_weeks = len(weekly)
dates = np.array([datetime.datetime.strptime(str(int(d)),
        '%Y%m%d') for d in weekly[:,0]])

要使用 RNNs，我们需要一个具有时间组件的数据建模问题。

字体分类问题在这里并不适用。所以，让我们来看一些天气数据。weather.npz 文件是来自美国某城市几十年的天气站数据的集合。daily 数组包含了每一天的测量数据。数据有六列，从日期开始。接下来是降水量，测量当天的降雨量（单位为英寸）。之后是两列关于雪的数据——第一列是地面上当前的积雪量，第二列是当天的降雪量，单位仍然是英寸。最后，我们还有一些温度信息，包括每日的最高温度和最低温度，单位为华氏度。

我们将使用的 weekly 数组是每日信息的每周总结。我们会使用中间的日期来表示一周，然后，我们会汇总该周的所有降雨量。然而，对于雪，我们将对地上的雪进行平均，因为将某一天的雪加到第二天仍然在地上的雪上是没有意义的。不过，降雪量我们会按周总和计算，就像雨一样。最后，我们将分别计算一周的最高温度和最低温度的平均值。现在你已经掌握了数据集，我们该怎么做呢？一个有趣的基于时间的建模问题是尝试预测某一周的季节，利用其天气信息和前几周的历史。

在北半球，在美国，6 月至 8 月的月份较暖，而 12 月至 2 月的月份则较冷，中间有过渡期。春季通常较为多雨，冬季则常常包括降雪。虽然一周的天气可能变化多端，但一段时间的天气历史应能提供一些预测能力。

理解 RNN

首先，让我们从压缩的 NumPy 数组中读取数据。weather.npz 文件恰好也包括每日数据，如果你想探索你自己的模型的话；np.load 会将两个数组读入一个字典，并将 weekly 设置为我们关注的数据；num_weeks 自然是我们拥有的数据点数量，在这里，有几几十年的信息：

num_weeks = len(weekly)

为了格式化这些周，我们使用一个 Python datetime.datetime 对象来读取以年、月、日格式存储的字符串：

dates = np.array([datetime.datetime.strptime(str(int(d)),
        '%Y%m%d') for d in weekly[:,0]])

我们可以利用每周的日期来分配其季节。对于这个模型，因为我们关注的是天气数据，我们使用气象季节而非常见的天文季节。幸运的是，这可以通过 Python 函数轻松实现。提取 datetime 对象中的月份，我们可以直接计算出这个季节。春季，季节零，是 3 月至 5 月，夏季是 6 月至 8 月，秋季是 9 月至 11 月，最后冬季是 12 月至 2 月。以下是一个简单的函数，它只是评估月份并实现这一点：

def assign_season(date):
  ''' Assign season based on meteorological season.
      Spring - from Mar 1 to May 31
      Summer - from Jun 1 to Aug 31
      Autumn - from Sep 1 to Nov 30
      Winter - from Dec 1 to Feb 28 (Feb 29 in a leap year)
  '''
  month = date.month
  # spring = 0
  if 3 <= month < 6:
     season = 0
  # summer = 1
  elif 6 <= month < 9:
    season = 1
  # autumn = 2
  elif 9 <= month < 12:
    season = 2
  # winter = 3
  elif month == 12 or month < 3:
    season = 3
  return season

请注意我们有四个季节和五个输入变量，并且，假设我们有 11 个历史状态值：

# There are 4 seasons
num_classes = 4

# and 5 variables
num_inputs = 5

# And a state of 11 numbers
state_size = 11

现在你准备计算标签了：

labels = np.zeros([num_weeks,num_classes])

# read and convert to one-hot

for i,d in enumerate(dates):

labels[i,assign_season(d)] = 1

我们直接以独热格式进行此操作，通过创建一个全零数组，并在分配季节的位置放置一个 1。

很酷！你刚刚用几个命令总结了几十年的时间。

由于这些输入特征测量的是非常不同的事物，即降雨、雪和温度，并且量纲也不同，我们应当注意将它们统一到相同的尺度。在下面的代码中，我们获取输入特征，当然跳过日期列，并减去平均值以将所有特征中心化到零：

# extract and scale training data

train = weekly[:,1:]

train = train - np.average(train,axis=0)

train = train / train.std(axis=0)

然后，我们通过除以标准差来缩放每个特征。这考虑到温度范围大约从 0 到 100，而降雨量仅在 0 到 10 之间变化。数据准备做得很好！虽然这不是总是有趣，但它是机器学习和 TensorFlow 的关键部分。

现在让我们跳到 TensorFlow 模型中：

# These will be inputs

x = tf.placeholder("float", [None, num_inputs])

# TF likes a funky input to RNN

x_ = tf.reshape(x, [1, num_weeks, num_inputs])

我们像往常一样使用占位符变量输入数据，但你会看到整个数据集被重新塑造成一个大张量。这是因为我们技术上拥有一个长而连续的观察序列。y_ 变量只是我们的输出：

y_ = tf.placeholder("float", [None,num_classes])

我们将为每个季节的每周计算一个概率。

cell 变量是递归神经网络的关键：

cell = tf.nn.rnn_cell.BasicRNNCell(state_size)

这告诉 TensorFlow 当前时间步如何依赖于之前的时间步。在这种情况下，我们将使用一个基本的 RNN 单元。因此，我们每次只回顾一周。假设它有 11 个状态值。你可以随意尝试更多的异国情调的单元和不同的状态大小。

为了利用这个单元，我们将使用 tf.nn.dynamic_rnn：

outputs, states = tf.nn.dynamic_rnn(cell,x_,

dtype=tf.nn.dtypes.float32, initial_state=None)

这智能地处理了递归，而不是简单地将所有时间步展开为一个巨大的计算图。由于我们在一个序列中有数千个观察值，这对于获得合理的速度至关重要。单元之后，我们指定输入 x_，然后设置 dtype 使用 32 位浮点数存储小数，然后是空的 initial_state。我们使用这些输出构建一个简单的模型。从这一点开始，模型几乎和你从任何神经网络中预期的一样：

我们将 RNN 单元的输出、一些权重相乘，并加上一个偏置，以获得每周每个类别的得分：

W1 = tf.Variable(tf.truncated_normal([state_size,num_classes],
        stddev=1./math.sqrt(num_inputs)))

b1 = tf.Variable(tf.constant(0.1,shape=[num_classes]))

# reshape the output for traditional usage
h1 = tf.reshape(outputs,[-1,state_size])

我们的分类交叉熵损失函数和训练优化器对你来说应该非常熟悉：

# Climb on cross-entropy
cross_entropy = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y + 1e-50, y_))

# How we train
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)

# Define accuracy
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))
accuracy=tf.reduce_mean(tf.cast(correct_prediction, "float"))

很棒的 TensorFlow 模型设置！要训练这个模型，我们将使用一个熟悉的循环：

# Actually train
epochs = 100
train_acc = np.zeros(epochs//10)

for i in tqdm(range(epochs), ascii=True):
    if i % 10 == 0:

   # Record summary data, and the accuracy
     # Check accuracy on train set 
     A = accuracy.eval(feed_dict={x: train, y_: labels})
     train_acc[i//10] = A

   train_step.run(feed_dict={x: train, y_: labels})

由于这是一个虚拟问题，我们不必过于担心模型的准确性。这里的目标只是查看 RNN 的工作原理。你可以看到它的运行方式就像任何 TensorFlow 模型一样：

如果你查看准确率，你会发现它做得很好；远远超过 25% 的随机猜测，但仍然有很多需要学习的地方。

我们希望您喜欢这段摘录自 动手深度学习与 TensorFlow。如果您想了解更多，请访问 packtpub.com。

相关：

• 使用递归神经网络（LSTM）进行时间序列预测的指南

• 深入了解递归网络：序列到词袋模型

• 掌握 Keras 深度学习的 7 个步骤

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升您的数据分析技能

3. Google IT 支持专业证书 - 支持您的组织的 IT

---

更多相关主题

• 探索神经网络

• 在使用神经网络之前尝试的 10 件简单事

• 用 PyTorch 可解释的神经网络

• 深度神经网络并未引领我们走向 AGI

• 最先进的深度学习可解释预测和现在预测

• 卷积神经网络（CNNs）的图像分类

使用 Python 探索 OpenAI API

原文：www.kdnuggets.com/exploring-the-openai-api-with-python

图片由 Ideogram.ai 生成

谁没有听说过 OpenAI？这个人工智能研究实验室因其著名产品 ChatGPT 改变了世界。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速入门网络安全职业。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织 IT 工作

---

它确实改变了 AI 实施的格局，现在许多公司急于成为下一个大热门。

尽管竞争激烈，OpenAI 仍然是满足任何生成式 AI 业务需求的首选公司，因为它拥有最佳的模型之一并提供持续的支持。该公司提供了许多最先进的生成式 AI 模型，具备各种任务能力：图像生成、文本转语音等等。

OpenAI 提供的所有模型都可以通过 API 调用获得。只需简单的 Python 代码，你就可以使用这些模型。

在这篇文章中，我们将探索如何使用 Python 操作 OpenAI API 以及你可以完成的各种任务。希望你从这篇文章中学到很多东西。

OpenAI API 设置

要跟随这篇文章，你需要准备一些东西。

你最重要的需求是来自 OpenAI 的 API 密钥，因为没有密钥你无法访问 OpenAI 模型。要获取访问权限，你必须注册一个 OpenAI 账户并在账户页面申请 API 密钥。收到密钥后，请将其保存到一个你能记住的地方，因为它不会再次出现在 OpenAI 界面中。

接下来你需要做的就是购买预付费信用卡以使用 OpenAI API。最近，OpenAI 宣布了关于他们的账单工作方式的变化。我们不再是在月末付款，而是需要购买用于 API 调用的预付费信用。你可以访问OpenAI 定价页面来估算你需要的信用额度。你也可以查看他们的模型页面以了解你需要哪个模型。

最后，你需要在你的环境中安装 OpenAI Python 包。你可以使用以下代码来完成这一操作。

pip install openai

然后，你需要使用下面的代码设置你的 OpenAI 密钥环境变量。

import os

os.environ['OPENAI_API_KEY'] = 'YOUR API KEY'

一切就绪后，让我们开始使用 Python 探索 OpenAI 模型的 API。

OpenAI API 文本生成

OpenAI API 的明星是他们的文本生成模型。这些大型语言模型系列可以根据称为提示的文本输入生成文本输出。提示基本上是我们对模型期望的指令，例如文本分析、生成文档草稿等。

让我们开始执行一个简单的文本生成 API 调用。我们将使用 OpenAI 的 GPT-3.5-Turbo 模型作为基础模型。它不是最先进的模型，但通常最便宜的模型足以执行文本相关任务。

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

1. “释放预测分析的力量，以驱动数据驱动的决策！”

2. “深入数据海洋，揭示有价值的见解。”

3. “通过先进算法将原始数据转化为可操作的智能。”

文本生成模型的 API 调用使用 API 端点 chat.completions 来根据我们的提示创建文本响应。

文本生成有两个必需的参数：模型和消息。

对于模型，你可以查看相关模型页面上可以使用的模型列表。

关于消息，我们传递一个包含两个对的字典：角色和内容。角色键指定了对话模型中的角色发送者。有 3 种不同的角色：系统、用户和助手。

使用消息中的角色，我们可以帮助设置模型行为，并提供一个模型应该如何回答我们提示的示例。

让我们通过角色助手扩展前面的代码示例，以指导我们的模型。此外，我们还会探索一些文本生成模型的参数，以改善其结果。

completion = client.chat.completions.create(
    model="gpt-3.5-turbo",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Generate me 3 jargons that I can use for my Social Media content as a Data Scientist content creator."},
        {"role": "assistant", "content": "Sure, here are three jargons: Data Wrangling is the key, Predictive Analytics is the future, and Feature Engineering help your model."},
        {"role": "user", "content": "Great, can you also provide me with 3 content ideas based on these jargons?"}
    ],
    max_tokens=150,
    temperature=0.7,
    top_p=1,
    frequency_penalty=0
)

print(completion.choices[0].message.content)

当然！以下是基于提供的术语的三个内容创意：

1. “释放数据处理的力量：数据科学家的逐步指南” - 创建一篇博客文章或视频教程，展示在现实数据科学项目中数据处理的最佳实践和工具。

2. “预测分析的未来：数据科学中的趋势与创新” - 写一篇思想领导文章，讨论预测分析中出现的新兴趋势和技术，以及它们如何塑造数据科学的未来。”

3. “掌握特征工程：提升模型性能的技术” - 开发一张信息图或社交媒体系列，突出不同的特征工程技术及其对提高机器学习模型准确性和效率的影响。

生成的输出遵循我们提供给模型的示例。如果我们有特定的风格或结果想让模型遵循，使用角色助手是很有用的。

关于参数，这里是我们使用的每个参数的简单解释：

• max_tokens：此参数设置模型可以生成的最大词数。

• temperature: 此参数控制模型输出的不可预测性。较高的温度会导致输出更加多样化和富有想象力。可接受的范围是从 0 到无穷大，虽然 2 以上的值不常见。

• top_p: 也称为核采样，此参数帮助确定模型从中抽取输出的概率分布子集。例如，top_p 值为 0.1 意味着模型仅考虑概率分布的前 10% 进行采样。其值范围从 0 到 1，值越高，输出多样性越大。

• frequency_penalty: 对模型输出中重复的标记进行惩罚。惩罚值范围从 -2 到 2，其中正值会减少标记的重复，负值则会鼓励重复的单词使用。值为 0 表示没有对重复进行惩罚。

最后，你可以使用以下代码将模型输出更改为 JSON 格式。

completion = client.chat.completions.create(
  model="gpt-3.5-turbo",
  response_format={ "type": "json_object" },
  messages=[
    {"role": "system", "content": "You are a helpful assistant designed to output JSON.."},
    {"role": "user", "content": "Generate me 3 Jargons that I can use for my Social Media content as a Data Scientist content creator"}
  ]
)

print(completion.choices[0].message.content)

{

"术语": [

"利用预测分析解锁有价值的洞察",

"深入研究先进机器学习算法的复杂性",

"利用大数据的力量推动数据驱动决策"

]

}

结果是 JSON 格式，并符合我们输入到模型中的提示。

要查看完整的 文本生成 API 文档，请访问他们的专用页面。

OpenAI 图像生成

OpenAI 模型对于文本生成用例非常有用，也可以调用 API 进行图像生成。

使用 DALL·E 模型，我们可以根据请求生成图像。执行此操作的简单方法是使用以下代码。

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.generate(
  model="dall-e-3",
  prompt="White Piano on the Beach",
  size="1792x1024",
  quality="hd",
  n=1,
)

image_url = response.data[0].url
Image(url=image_url)

使用 DALL·E 3 生成的图像

对于参数，以下是解释：

• model: 要使用的图像生成模型。目前，API 仅支持 DALL·E 3 和 DALL·E 2 模型。

• prompt: 这是模型将根据其生成图像的文本描述。

• size: 确定生成图像的分辨率。对于 DALL·E 3 模型，有三种选择（1024x1024、1024x1792 或 1792x1024）。

• quality: 此参数影响生成图像的质量。如果需要计算时间，“标准”比“高清”更快。

• n: 指定根据提示生成图像的数量。DALL·E 3 一次只能生成一张图像。DALL·E 2 一次最多可以生成 10 张图像。

也可以从现有图像生成变体图像，但这仅在使用 DALL·E 2 模型时可用。API 也只接受小于 4 MB 的方形 PNG 图像。

from openai import OpenAI
from IPython.display import Image

client = OpenAI()

response = client.images.create_variation(
  image=open("white_piano_ori.png", "rb"),
  n=2,
  size="1024x1024"
)

image_url = response.data[0].url

Image(url=image_url)

由于使用的是较旧的模型，生成的图像可能不如 DALL·E 3 生成的图像那么好。

OpenAI 视觉

OpenAI 是一家领先的公司，提供能够理解图像输入的模型。这个模型被称为 Vision 模型，有时被称为 GPT-4V。该模型能够回答我们提供的图像所提出的问题。

让我们尝试使用 Vision 模型 API。在这个示例中，我会使用我们从 DALL·E 3 模型生成的白色钢琴图像并将其存储到本地。此外，我还会创建一个函数，该函数接受图像路径并返回图像描述文本。别忘了将 api_key 变量更改为你的 API 密钥。

from openai import OpenAI
import base64
import requests
def provide_image_description(img_path):

    client = OpenAI()

    api_key = 'YOUR-API-KEY'
    # Function to encode the image
    def encode_image(image_path):
      with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode('utf-8')

    # Path to your image
    image_path = img_path

    # Getting the base64 string
    base64_image = encode_image(image_path)

    headers = {
      "Content-Type": "application/json",
      "Authorization": f"Bearer {api_key}"
    }

    payload = {
      "model": "gpt-4-vision-preview",
      "messages": [
        {
          "role": "user",
          "content": [
            {
              "type": "text",
              "text": """Can you describe this image? """
            },
            {
              "type": "image_url",
              "image_url": {
                "url": f"data:image/jpeg;base64,{base64_image}"
              }
            }
          ]
        }
      ],
      "max_tokens": 300
    }

    response = requests.post("https://api.openai.com/v1/chat/completions", headers=headers, json=payload)

    return response.json()['choices'][0]['message']['content']

这张图像展示了一架置于宁静海滩环境中的大钢琴。钢琴是白色的，表明其表面通常与优雅相关。乐器正位于海岸线的边缘，温柔的海浪轻轻拂过沙滩，形成的泡沫刚刚碰触到钢琴及其配套凳子的底部。海滩的环境暗示着一种宁静和孤立的感觉，天空湛蓝，远处有蓬松的云朵，平静的大海延展到地平线。钢琴周围的沙滩上散落着许多大小不一的贝壳，突显了环境的自然美和宁静氛围。在自然海滩环境中摆放经典音乐乐器的对比创造了一种超现实和视觉上富有诗意的构图。

你可以调整上述字典中的文本值以符合你的 Vision 模型要求。

OpenAI 音频生成

OpenAI 还提供了一个基于 Text-to-Speech 模型生成音频的模型。使用起来非常简单，但语音叙述风格有限。此外，该模型支持多种语言，你可以在他们的 语言支持页面 查看。

要生成音频，你可以使用下面的代码。

from openai import OpenAI
client = OpenAI()

speech_file_path = "speech.mp3"
response = client.audio.speech.create(
  model="tts-1",
  voice="alloy",
  input="I love data science and machine learning"
)

response.stream_to_file(speech_file_path)

你应该能在你的目录中看到音频文件。尝试播放它，看看它是否符合你的标准。

目前，你只能为 Text-to-Speech 模型使用几个参数：

• model: 要使用的 Text-to-Speech 模型。仅有两个模型可用（tts-1 或 tts-1-hd），其中 tts-1 优化速度，tts-1-hd 优化质量。

• voice: 要使用的声音风格，其中所有声音都优化为英语。选择包括 alloy、echo、fable、onyx、nova 和 shimmer。

• response_format: 音频格式文件。目前，支持的格式包括 mp3、opus、aac、flac、wav 和 pcm。

• speed: 生成音频的速度。你可以选择 0.25 到 4 之间的值。

• input: 创建音频的文本。目前，模型仅支持最多 4096 个字符。

OpenAI 语音转文字

OpenAI 提供了转录和翻译音频数据的模型。使用 whispers 模型，我们可以将支持的语言的音频转录为文本文件，并将其翻译成英文。

让我们尝试对之前生成的音频文件进行简单的转录。

from openai import OpenAI
client = OpenAI()

audio_file= open("speech.mp3", "rb")
transcription = client.audio.transcriptions.create(
  model="whisper-1",
  file=audio_file
)

print(transcription.text)

我热爱数据科学和机器学习。

还可以将音频文件翻译成英文。目前尚无模型支持翻译成其他语言。

from openai import OpenAI
client = OpenAI()

audio_file = open("speech.mp3", "rb")
translate = client.audio.translations.create(
  model="whisper-1",
  file=audio_file
)

结论

我们已经深入了解了 OpenAI 提供的几种模型服务，包括文本生成、图像生成、音频生成、视觉和文本转语音模型。每种模型都有其 API 参数和规范，你需要在使用之前学习。

Cornellius Yudha Wijaya 是一名数据科学助理经理和数据撰稿人。在全职工作于安联印度尼西亚期间，他喜欢通过社交媒体和写作媒体分享 Python 和数据技巧。Cornellius 涉及各种人工智能和机器学习话题。

更多相关主题

• 免费 ChatGPT 课程：使用 OpenAI API 编写 5 个项目

• OpenAI 的 Whisper API 用于转录和翻译

• OpenAI API 入门：易于跟随的起始指南

• 使用噪声标记数据微调 OpenAI 语言模型

• OpenAI 的新 ChatGPT 和 Whisper API

• 使用 OpenAI GPT 模型的最佳实践

探索小数据场景下的迁移学习潜力

原文：www.kdnuggets.com/exploring-the-potential-of-transfer-learning-in-small-data-scenarios

编辑提供的图像 | 迁移学习流程来自 Skyengine.ai

说到 机器学习，在数据需求旺盛的情况下，并不是每个人都有机会随时访问大量数据集来进行学习——这时 迁移学习 就会派上用场，尤其是在你面临有限数据或获取更多数据成本过高的情况下。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你组织的 IT 工作

---

本文将深入探讨迁移学习的魔力，展示它如何巧妙地利用已经从大量数据集中学习过的模型来显著提升你自己的机器学习项目，即使你的数据量较少。

我将处理在数据稀缺环境中工作的挑战，展望未来可能的情景，并庆祝迁移学习在各种不同领域中的多样性和有效性。

什么是迁移学习？

迁移学习是一种 机器学习技术，它将为一个任务开发的模型重新用于第二个相关任务，并进一步发展。

从本质上讲，这种方法的核心在于这样一个理念：在解决一个问题时获得的知识可以帮助解决另一个类似的问题。

例如，一个训练用于识别图像中物体的模型 可以被调整用来识别照片中的特定类型的动物，利用其对形状、纹理和模式的先前知识。

它积极加速训练过程，同时显著减少所需的数据量。在小数据场景下，这尤其有利，因为它绕过了实现高模型准确度所需的大量数据集的传统需求。

利用预训练模型可以让从业者绕过许多与模型开发常见相关的初始障碍，如特征选择和模型架构设计。

预训练模型是迁移学习的支柱

预训练模型是迁移学习的真正基础，这些模型通常由研究机构或科技巨头在大规模数据集上开发和训练，并提供给公众使用。

预训练模型的多功能性令人惊叹，应用范围从图像和语音识别到自然语言处理。采用这些模型来处理新任务可以大幅缩短开发时间和所需资源。

例如，在 ImageNet 数据库上训练的模型，该数据库包含数百万个标记图像，跨越数千个类别，为各种图像识别任务提供了丰富的特征集。

这些模型对新、小数据集的适应性突显了它们的价值，使得在没有大量计算资源的情况下提取复杂特征成为可能。

小数据环境中的潜在挑战

在有限数据的情况下工作面临独特的挑战——主要问题是过拟合，模型过于充分地学习了训练数据，包括其噪声和异常值，导致在未见数据上的表现较差。

迁移学习通过使用在多样化数据集上预训练的模型来降低这种风险，从而增强了泛化能力。

然而，迁移学习的有效性依赖于预训练模型与新任务的相关性。如果涉及的任务差异过大，那么迁移学习的好处可能无法充分显现。

此外，用小数据集对预训练模型进行微调需要小心调整参数，以避免丧失模型已经获得的宝贵知识。

除了这些障碍外，数据在压缩过程中也可能受到威胁。这甚至适用于一些非常简单的操作，比如你想要压缩 PDF 文件，但幸运的是，这些情况可以通过准确的调整来避免。

在机器学习的背景下，即使在进行存储或传输压缩时，确保数据的完整性和质量对于开发可靠模型至关重要。

转移学习依赖于预训练模型，进一步突出了数据资源管理的必要性，以防信息丢失，确保每一条数据在训练和应用阶段都得到充分利用。

保持已学特征与适应新任务之间的平衡是一个微妙的过程，需要对模型和手头数据有深入的理解。

转移学习的未来方向

转移学习的前景不断扩展，研究不断突破可能性的界限。

一个令人兴奋的方向是开发更通用的模型，这些模型可以应用于更广泛的任务，只需进行最小调整。

另一个探索领域是改进跨领域知识转移的算法，提升转移学习的灵活性。

目前对自动化选择和微调预训练模型以应对特定任务的兴趣日益增加，这可能进一步降低了利用先进机器学习技术的门槛。

这些进展有望使转移学习变得更加可及和有效，为数据稀缺或难以收集的领域的应用开辟新的可能性。

提供跨不同领域的适应性

转移学习的美在于其适应性，可以应用于各种不同领域。

从医疗保健中，它可以在有限的患者数据下帮助诊断疾病，到机器人技术中，它加速了新任务的学习而无需广泛的训练，其潜在应用广泛。

在自然语言处理领域，转移学习已经在相对较小的数据集上取得了显著进展。

这种适应性不仅展示了转移学习的效率，还突显了它使先进机器学习技术普及的潜力，使得较小的组织和研究人员能够进行以前由于数据限制而无法触及的项目。

即使是一个Django 平台，你也可以利用转移学习来提升你的应用能力，无需从头开始。

转移学习超越了特定编程语言或框架的界限，使得可以将先进的机器学习模型应用于在多种环境中开发的项目。

资源优化的重要性

迁移学习不仅仅是克服数据稀缺; 它也是机器学习中效率和资源优化的一个证明。

通过建立在预训练模型的知识基础上，研究人员和开发者可以以更少的计算能力和时间取得显著成果。

这种效率在资源有限的场景中尤其重要，无论是数据、计算能力，还是两者兼有。

由于43%的所有网站使用 WordPress 作为其 CMS，这为专注于例如网页抓取或比较不同类型内容的上下文和语言差异的 ML 模型提供了良好的测试平台。

这突显了迁移学习在实际应用中的实际好处，在这些应用中，访问大规模的领域特定数据可能会受到限制。迁移学习还鼓励重用现有模型，通过减少从零开始进行高能耗训练的需求，符合可持续实践。

这种方法示范了战略性资源使用如何带来机器学习的重大进展，使复杂的模型更加可及和环保。

迁移学习适合你的模型吗？

在我们结束对迁移学习的探索时，显然这种技术正在显著改变我们所知的机器学习，特别是对于那些面临数据资源有限的项目。

迁移学习允许有效利用预训练模型，使得无论是小规模还是大规模的项目都能取得显著成果，而不需要大量的数据集或计算资源。

展望未来，迁移学习的潜力广泛而多样，使机器学习项目变得更可行且资源消耗更少的前景不仅令人期待，而且已经在成为现实。

向更可及和高效的机器学习实践的转变有可能在从医疗保健到环境保护的众多领域激发创新。

迁移学习正在使机器学习民主化，将先进的技术提供给比以往更广泛的受众。

Nahla Davies是一位软件开发人员和技术作家。在全职从事技术写作之前，她曾管理——包括其他引人注目的工作——担任一家 Inc. 5000 体验品牌组织的首席程序员，该组织的客户包括三星、时代华纳、Netflix 和索尼。

相关主题更多内容

• SQL 中的 Group By 和 Partition By 场景：何时以及如何结合数据

• 克服现实世界场景中的数据不平衡挑战

• 揭示 CTGAN 的潜力：利用生成 AI 生成合成数据

• 挖掘 2023 年数据产品的潜力

• 通过这个免费的 DevOps 速成课程释放你的潜力

• 超越 Numpy 和 Pandas：释放鲜为人知的 Python 库的潜力

探索 Zephyr 7B：最新大型语言模型的全面指南

原文：www.kdnuggets.com/exploring-the-zephyr-7b-a-comprehensive-guide-to-the-latest-large-language-model

图片由 Google DeepMind 提供

2023 年是大型语言模型和开源的年份。许多初创公司和公司开源了他们的模型和权重，以对抗像 ChatGPT 和 Claude 这样的专有 LLM。2023 年的一些重要公司和模型（开源）包括：

• Meta (LLama, LLamav2)

• TII（Falcon 7B, 40B, 180B）

• Mistral（Mistral 7B, Mixtral8x7B）

---

我们的三大课程推荐

1. Google Cybersecurity Certificate - 快速进入网络安全职业生涯。

2. Google Data Analytics Professional Certificate - 提升您的数据分析技能

3. Google IT Support Professional Certificate - 支持您的组织的 IT

---

然而，7B 模型相对容易且便宜部署，但无法与 70B 等更大模型媲美。最强的开源竞争者是 Mistral 7B，它会超越许多更大的模型。

来自 Mistral.ai 的 Mistral-7B 比较

然而，这些小模型对自然提示的响应仍然不佳，需要良好的提示工程。

介绍

Zephyr 7B 是由 HuggingFace H4（Helpful, Honest, Harmless, Huggy）团队创建的模型，其主要目标是创建一个对齐用户意图的小型语言模型，并超越甚至更大规模的模型。

Zephyr 是 Mistral-7B 的对齐版本，主要通过蒸馏技术创建，并在学术和对话基准测试中与 70B 模型相当。

Zephyr-7B 性能比较 | 来源：Zephyr 论文

主要特性

Zephyr 卓越表现的原因在于 H4 团队使用的这四项关键技术。

1. Self-Instruct 数据创建与 DSFT（蒸馏监督微调）

2. 反馈收集

3. DSFT 模型的 DDPO（精炼直接偏好优化）

自我指导数据创建与 DSFT

传统上，监督微调（SFT）是在大型语言模型上通过高质量的指令完成对进行的。这些数据的构建成本高昂，并且需要人工监督（Chung et al., 2022；Sanh et al., 2021）。

这里一个有趣的方法是使用教师模型（已训练的大型语言模型）来生成指令和响应。这种精炼技术首次用于 Alpaca（Taori et al., 2023），证明了小模型可以通过精炼监督微调超越更大的模型。

自我指导管道 | 来源：自我指导论文

H4 团队使用 Zephyr 构建了高质量的监督（指令，完成）数据集，这些数据集用于进行 DSFT。（在生成的指令/完成上训练模型是一种精炼形式，称为 DSFT：精炼监督微调。）

反馈收集

大型语言模型通常通过来自人类反馈的强化学习（RLHF）进行对齐。Zephyr 则使用来自更优教师模型（如 GPT-4）的反馈来对齐模型的兴趣，采用了 Ultra Feedback 的方法。

UltraFeedback 构建过程 | 来源：UltraFeedback 论文

它的工作原理是，每个来自 SFT 的监督提示会传递给 4 个模型（Claude、LLama、Falcon 等），每个模型对单一提示的响应都通过 GPT-4 进行评分。现在我们有一个数据集，其中包括输入（x）、最高评分的完成（yw）以及一个随机提示，表示为低评分的完成（yl），即我们有一个三元组（x, yw, yl）。

偏好优化

最后一阶段的目标是最大化模型对 yw（最高评分的完成）相对于 yl（低评分的完成）的偏好。这是通过DPO（直接偏好优化）来完成的。使用 DPO 比使用纯 RLHF 更简单，直观上它比 RLHF 表现更好。在这种情况下，该方法被称为dDPO，因为它使用了由教师模型生成的精炼数据集。

Zephyr 论文

整体算法看起来大致如下：

这些步骤可以转化为以下几个步骤：

1. 计算 dSFT 模型 (仅前向) 中 (x, yw) 和 (x, yl) 的概率。

2. 计算 dDPO 模型中 (x, yw) 和 (x, yl) 的概率。

3. 计算公式 1 并反向传播以进行更新。重复

训练细节

Zephyr 使用的基础模型是 Mistral-7B，该模型在发布时是最先进的开源模型。他们使用了 TRL 库进行微调和对齐。为了优化和加速训练并充分利用 GPU，使用了 Deep-Speed Zero 3 和 Flash-Attention 2。模型使用 AdamW 优化器进行训练，并未使用权重衰减。所有实验都在 16 个 A100 上运行，使用 bfloat16 精度，通常需要 2-4 小时完成。有关 Zephyr 训练过程的详细信息，请参阅 原始论文。

结果

Zephyr 团队结合了训练大型语言模型的最佳技术，并且凭借仅 7B 参数的模型达到了 40B 模型的性能，并且在聊天模型中达到了 70B 的水平。

Zephyr 与其他 LLM 的比较 | 来源：Zephyr 论文

Zephyr 与其他 LLM 的比较 | 来源：Zephyr 论文

使用

Zephyr 模型在 Hugging Face 上公开提供，可以像使用其他语言模型一样使用。

import torch
from transformers import pipeline

pipe = pipeline("text-generation",
                model="HuggingFaceH4/zephyr-7b-alpha",  # can also use the beta model
                torch_dtype=torch.bfloat16,
                device_map="auto")

# We use the tokenizer's chat template to format each message - see https://huggingface.co/docs/transformers/main/en/chat_templating
messages = [
   {
       "role": "system",
       "content": "You are a friendly chatbot who always responds in the style of a pirate",
   },
   {"role": "user", "content": "How many helicopters can a human eat in one sitting?"},
]
prompt = pipe.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
outputs = pipe(prompt, max_new_tokens=256, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)
print(outputs[0]["generated_text"])

输出：

<|system|>
You are a friendly chatbot who always responds in the style of a pirate.
<|user|>
How many helicopters can a human eat in one sitting?
<|assistant|>
Ah, me hearty matey! But yer question be a puzzler! A human cannot eat a helicopter in one sitting, as helicopters are not edible. They be made of metal, plastic, and other materials, not food! 

结论

Zephyr-7B 是一个小型模型，展示了从大型语言模型蒸馏到小型模型的力量。结果模型 ZEPHYR-7B 基于 MISTRAL-7B，设定了 7B 参数聊天模型的新最先进水平，甚至在 MT-Bench 上超越了 LLAMA2-CHAT-70B。

参考文献

1. Zephyr: 直接蒸馏的 LM 对齐 (arxiv.org/abs/2310.16944)

2. HuggingFace Zephyr 博客 (huggingface.co/blog/Isamu136/understanding-zephyr)

3. Self Instruct: arxiv.org/abs/2212.10560

4. UltraFeedback: arxiv.org/abs/2310.01377

Ahmad Anis**** 是一位充满热情的机器学习工程师和研究员，目前在 redbuffer.ai 工作。除了日常工作外，Ahmad 积极参与机器学习社区。他担任 Cohere for AI 的地区负责人，该组织致力于开放科学，并且是 AWS 社区建设者。Ahmad 还活跃于 Stackoverflow，拥有 2300+ 点。他对许多著名的开源项目做出了贡献，包括 OpenAI 的 Shap-E。

更多相关主题

• 探索谷歌最新的 AI 工具：初学者指南

• 掌握大型语言模型的全面资源列表

• 探索 AI/DL 的最新趋势：从元宇宙到量子计算

• 终极开源大型语言模型生态系统

• 掌握大型语言模型微调的 7 个步骤

• NExT-GPT 介绍：任意到任意的多模态大型语言模型

探索思维树提示：人工智能如何通过搜索学习推理

原文：www.kdnuggets.com/2023/07/exploring-tree-of-thought-prompting-ai-learn-reason-through-search.html

图片由作者使用 Midjourney 创建

重点

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的快车道。

2. Google 数据分析专业证书 - 提升您的数据分析技能

3. Google IT 支持专业证书 - 支持您的组织的 IT

---

• 一篇新论文提出了一个“思维树”框架，以实现更深思熟虑的问题解决

• 将推理过程表示为对可能的“思维”树的搜索

• 使用 LLM 自身生成和评估这些思维

• 使用经典的搜索算法来指导探索

介绍

最近，像 GPT-3 这样的语言模型在数学推理和常识知识等领域展示了令人印象深刻的能力。然而，它们的基本文本生成方法——从左到右、逐个单词——可能限制了战略规划和探索。论文显示，这种方法显著提高了 LLM 在解决数学难题和创造性写作等挑战中的能力。

讨论

最近一篇论文，思维树：使用大型语言模型进行深思熟虑的问题解决 — 由 Shunyu Yao、Dian Yu、Jeffrey Zhao、Izhak Shafran、Thomas L. Griffiths、Yuan Cao 和 Karthik Narasimhan 共同提出 — 提出了一个名为“思维树”（ToT）的新框架，用于提升大型语言模型（LLMs），如 GPT-3 和 GPT-4 的问题解决能力。目前，LLMs 在生成文本时局限于从左到右的单词级别决策，这在需要更多战略规划和探索的任务中可能显得不足。

ToT 将问题解决过程表示为对树的搜索，其中每个节点是一个“思维”——一个表示中间推理步骤的连贯文本块。这使得 LLM 可以探索多个推理路径并评估不同思维在解决问题中的进展。具体来说，这一框架涉及：

1. 根据任务结构将问题分解为连贯的思维步骤。

2. 使用 LLM 在每一步生成多个思维候选，无论是独立生成还是基于先前思维的序列条件生成。

3. 让大语言模型（LLM）通过价值评估提示来评估不同状态（部分解决方案）的前景，这些提示评估到目前为止的进展。

4. 使用经典的搜索算法，如广度优先搜索或深度优先搜索，通过树结构，利用 LLM 的价值估计来指导探索和剪枝。

这种有意的搜索方法允许 LLM 进行前瞻性思考、回溯，并在需要时做出更具全球性的选择。这个模块化框架与模型无关，可以根据问题结构灵活调整其组件，如思维规模、生成、评估和搜索。

作者在三个新任务上演示了 ToT——24 点游戏、创意写作和迷你填字游戏。在所有情况下，ToT 显著提升了 GPT-4 在问题解决中的表现，相比于标准提示基线。例如，在 24 点游戏中，成功率从使用链式思维提示的 4%提高到使用 ToT 的 74%。

总体而言，ToT 提供了一种将经典 AI 中的符号规划和搜索方法与现代 LLM 结合的方式。其基于语言的思维和审议的可解释性也为更好的人类对齐提供了机会。作者将其提出作为开发更通用问题解决能力的一个令人兴奋的新方向。

研究问答

“思维树”方法与其他结合符号规划或搜索与神经模型的方法（如 NeuroLogic 解码或 LLM+P 框架）相比如何？

ToT 框架的不同之处在于，它使用 LLM 自身在搜索过程中提供启发式指导，而不是依赖于单独的经典规划器（LLM+P）或硬编码的启发式方法（NeuroLogic）。基于语言的思维表示也比符号规划语言更灵活。然而，ToT 尚未达到 LLM+P 所展示的 LLM 与规划器组件之间的紧密集成和双向通信水平。

“思维树”方法是否可以应用于自然语言任务，如对话或故事生成，而不仅仅是受限的推理任务？

尽管目前的论文重点是推理任务，但将可能的继续表示为可以审议的思维的通用框架似乎也适用于不那么受限的生成问题。对于对话，思维可以是候选的下一步发言，而对于故事，它们可以是情节点或角色动作。关键挑战将是定义连贯的思维步骤并开发有效的评估提示。

这项研究的创新之处在哪里？

关键的创新在于将语言模型推断框架设定为思维树上的搜索，而不仅仅是从左到右的标记生成。这允许更有意识的规划、探索替代方案和全局前瞻/回溯。将思维表示为连贯的语义单位也比之前的搜索方法更具创新性。

这项研究的更广泛影响是什么？

这项研究可能显著提升 LLM 的解决问题和推理能力，使其能够应用于更复杂的现实世界任务，如编码、数据分析、机器人技术等。同时，它还使模型决策更加可解释。将经典搜索方法与神经模型的结合是一个令人兴奋的方向。

这项研究在呈现过程中是否存在潜在的问题或遗漏？

探索的任务仍然相对简单。是否能将这一方法扩展到更开放的问题尚未可知。搜索过程可能比标准采样需要更高的计算成本。修剪次优分支的启发式方法目前仍不完美。

从这项研究中，接下来的逻辑研究步骤是什么？

重要的下一步是探索 ToT 在更复杂的规划和决策任务中的应用，将其与外部知识检索集成，并研究变体是否可以通过元学习或强化学习以更高效的样本方式进行学习，而不是仅依赖于预训练的 LLM。分析思维规模、搜索预算和性能之间的相互作用也是一个未解的问题。

重点总结

• Tree of Thoughts 范式展示了如何将经典搜索技术与现代神经网络模型相结合。

• 允许 LLM 探索不同的推理路径使得它们的决策过程更具可解释性。

• 这一研究方向可能增强 LLM 在复杂现实世界规划和分析任务中的适用性。

• 关键的下一步是将这一方法扩展到更少约束的问题，提高搜索效率，并研究如何学习这些技能。

• 总体来说，Tree of Thoughts 的深思熟虑和语义推理为人工智能代理提供了一种令人兴奋的新能力。

Matthew Mayo (@mattmayo13) 是数据科学家，也是 KDnuggets 的总编辑，KDnuggets 是一个开创性的在线数据科学和机器学习资源。他的兴趣领域包括自然语言处理、算法设计和优化、无监督学习、神经网络以及机器学习的自动化方法。Matthew 拥有计算机科学硕士学位和数据挖掘研究生文凭。可以通过 editor1 at kdnuggets[dot]com 与他联系。

更多相关内容

• 自动化思维链：AI 如何自我提示进行推理

• 揭示大语言模型中的思维链提示的力量

• 构建视觉搜索引擎 - 第二部分：搜索引擎

• 使用 Python 进行网格搜索和随机搜索的超参数调优

• 通过 Uplimit 的机器学习搜索课程提升你的搜索引擎技能！

• 用 Python 和 Scikit-learn 简化决策树的可解释性

探索无监督学习指标

原文：www.kdnuggets.com/2023/04/exploring-unsupervised-learning-metrics.html

图片由 rawpixel 提供，来源于 Freepik

无监督学习是机器学习的一个分支，其中模型从可用数据中学习模式，而不是提供实际标签。我们让算法自己得出答案。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织 IT 工作

---

在无监督学习中，有两种主要技术：聚类和降维。聚类技术使用算法学习模式以分割数据。而降维技术则试图减少特征数量，同时尽可能保留实际信息。

一个用于聚类的示例算法是 K-Means，用于降维的算法是 PCA。这些是无监督学习中使用最多的算法。然而，我们很少讨论评估无监督学习的指标。尽管它很有用，我们仍然需要评估结果以了解输出是否准确。

本文将讨论用于评估无监督机器学习算法的指标，并分为两个部分：聚类算法指标和降维指标。让我们深入了解。

聚类算法指标

我们不会详细讨论聚类算法，因为这不是本文的重点。相反，我们将重点关注用于评估的指标示例以及如何评估结果。

本文将使用 Kaggle 的葡萄酒数据集 作为数据集示例。首先读取数据，然后使用 K-Means 算法对数据进行分段。

import pandas as pd
from sklearn.cluster import KMeans
df = pd.read_csv('wine-clustering.csv')

kmeans = KMeans(n_clusters=4, random_state=0)
kmeans.fit(df)

我将集群数量初始化为 4，这意味着我们将数据分成 4 个集群。这是正确的集群数量吗？还是有更合适的集群数量？通常，我们可以使用称为肘部法则的技术来找到适当的集群数量。让我在下面展示代码。

wcss = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters=k, random_state=0)
    kmeans.fit(df)
    wcss.append(kmeans.inertia_)

# Plot the elbow method
plt.plot(range(1, 11), wcss, marker='o')
plt.xlabel('Number of Clusters (k)')
plt.ylabel('WCSS')
plt.title('Elbow Method')
plt.show()

在肘部法中，我们使用 WCSS 或簇内平方和来计算数据点与各自簇的质心之间的平方距离之和，针对不同的 k（簇）。最佳的 k 值预计是 WCSS 减少最多的值，或者上图中的肘部，即 2。

但是，我们可以扩展肘部法来使用其他指标来找到最佳的 k 值。如何让算法自动找到簇的数量而不依赖于质心呢？是的，我们也可以使用类似的指标来评估它们。

作为备注，我们可以假设一个簇的质心是数据均值，即使我们没有使用 K-Means 算法。因此，任何不依赖于质心的算法在进行数据分割时，仍然可以使用依赖于质心的任何指标进行评估。

轮廓系数

轮廓系数是一种聚类技术，用于衡量簇内数据与其他簇数据的相似性。轮廓系数是一个从 -1 到 1 的数值表示。值为 1 表示每个簇与其他簇完全不同，而值为 -1 表示所有数据都被分配到了错误的簇中。值为 0 表示数据中没有有意义的簇。

我们可以使用以下代码来计算轮廓系数。

# Calculate Silhouette Coefficient
from sklearn.metrics import silhouette_score

sil_coeff = silhouette_score(df.drop("labels", axis=1), df["labels"])
print("Silhouette Coefficient:", round(sil_coeff, 3))

轮廓系数：0.562

我们可以看到，以上的分割具有正的轮廓系数，这意味着各个簇之间有一定的分离度，尽管仍然会发生一些重叠。

Calinski-Harabasz 指数

Calinski-Harabasz 指数或方差比准则是一个用于评估簇质量的指标，通过测量簇间离散度与簇内离散度的比率来评估。基本上，我们测量了簇之间的数据平方距离总和与簇内部的数据距离的差异。

Calinski-Harabasz 指数的分数越高越好，这意味着簇之间的分离度越好。然而，分数没有上限，这意味着这个指标更适合用于评估不同的 k 值，而不是直接解释结果。

让我们使用 Python 代码来计算 Calinski-Harabasz 指数分数。

# Calculate Calinski-Harabasz Index
from sklearn.metrics import calinski_harabasz_score

ch_index = calinski_harabasz_score(df.drop('labels', axis=1), df['labels'])
print("Calinski-Harabasz Index:", round(ch_index, 3))

Calinski-Harabasz 指数：708.087

对 Calinski-Harabasz 指数的另一个考虑是该指数对簇的数量非常敏感。更多的簇可能会导致更高的分数。因此，最好将其他指标与 Calinski-Harabasz 指数一起使用，以验证结果。

Davies-Bouldin 指数

Davies-Bouldin 指数是一种聚类评估指标，通过计算每个簇与其最相似簇之间的平均相似性来测量。这个比率计算簇内距离与簇间距离的比值。这意味着簇之间越远且分散越少，会导致更好的分数。

与之前的指标相比，戴维斯-鲍尔丁指数旨在尽可能降低得分。得分越低，每个聚类的分离度越高。让我们使用 Python 示例来计算这个得分。

# Calculate Davies-Bouldin Index
from sklearn.metrics import davies_bouldin_score

dbi = davies_bouldin_score(df.drop('labels', axis=1), df['labels'])
print("Davies-Bouldin Index:", round(dbi, 3))

戴维斯-鲍尔丁指数：0.544

我们不能仅凭上述得分来判断其好坏，因为类似于之前的指标，我们仍然需要使用各种指标来支持结果评估。

降维指标

与聚类不同，降维的目标是减少特征数量，同时尽可能保留原始信息。因此，许多降维评估指标都关注信息保留。让我们使用 PCA 来减少维度，并看看这些指标的效果。

from sklearn.decomposition import PCA
from sklearn.preprocessing import StandardScaler

#Scaled the data
scaler = StandardScaler()
df_scaled = scaler.fit_transform(df)

pca = PCA()
pca.fit(df_scaled)

在上述示例中，我们对数据进行了主成分分析（PCA），但尚未减少特征的数量。相反，我们希望使用累计解释方差来评估降维和方差之间的权衡。这是一个常见的降维指标，用于查看在每次减少特征时信息的保留情况。

#Calculate Cumulative Explained Variance
cev = np.cumsum(pca.explained_variance_ratio_)

plt.plot(range(1, len(cev) + 1), cev, marker='o')
plt.xlabel('Number of PC')
plt.ylabel('CEV')
plt.title('CEV vs. Number of PC')
plt.grid()

从上述图表中，我们可以看到保留的主成分数量与解释方差的关系。作为经验法则，我们通常选择保留约 90-95%的主成分进行降维，因此如果遵循上述图表，大约 14 个特征会减少到 8 个。

让我们查看其他指标以验证我们的降维效果。

可信度

可信度是对降维技术质量的衡量指标。这个指标衡量的是降维后数据的最近邻保持了多少原始数据的特征。

基本上，这个指标试图查看降维技术在保持原始数据的局部结构方面做得如何。

可信度指标范围从 0 到 1，其中值越接近 1，表示在降维数据点附近的邻居在原始维度中也大多接近。

让我们使用 Python 代码计算可信度指标。

from sklearn.manifold import trustworthiness

# Calculate Trustworthiness. Tweak the number of neighbors depends on the dataset size.
tw = trustworthiness(df_scaled, df_pca, n_neighbors=5)
print("Trustworthiness:", round(tw, 3))

可信度：0.87

萨蒙映射

萨蒙映射是一种非线性降维技术，旨在在降维过程中保留高维度的成对距离。其目标是使用萨蒙应力函数来计算原始数据和降维空间之间的成对距离。

萨蒙应力函数的得分越低越好，因为它表示成对保留情况越好。让我们尝试使用 Python 代码示例。

首先，我们需要安装一个额外的萨蒙映射包。

pip install sammon-mapping

然后我们将使用以下代码计算萨蒙的应力。

# Calculate Sammon's Stress
from sammon import sammon

pca_res, sammon_st = sammon.sammon(np.array(df))

print("Sammon's Stress:", round(sammon_st, 5))

萨蒙应力：1e-05

结果显示了一个较低的萨蒙得分，这意味着数据的保留情况良好。

结论

无监督学习是机器学习的一个分支，它尝试从数据中学习模式。与监督学习相比，输出评估可能不会有太多讨论。本文中，我们尝试学习一些无监督学习指标，包括：

1. 簇内平方和

2. 轮廓系数

3. Calinski-Harabasz 指数

4. Davies-Bouldin 指数

5. 累积解释方差

6. 可信度

7. Sammon 映射

Cornellius Yudha Wijaya 是一位数据科学助理经理和数据撰稿人。在全职工作于 Allianz Indonesia 的同时，他喜欢通过社交媒体和写作媒体分享 Python 和数据技巧。

相关主题更多内容

• 无监督分离表示学习在类别不平衡数据集中的应用

• 使用 scikit-learn 进行聚类：无监督学习教程

• 揭示无监督学习

• 无监督学习实践：K 均值聚类

• 机器学习评估指标：理论与概述

• 分类问题的更多性能评估指标

如何扩展 scikit-learn 并为你的机器学习工作流程带来理智

原文：www.kdnuggets.com/2019/10/extend-scikit-learn-bring-sanity-machine-learning-workflow.html

评论

由 Déborah Mesquita，数据科学家

我们通常听到（并且说）机器学习只是统计学的商业名称。这可能是真的，但如果我们使用计算机构建模型，那么机器学习实际上包括统计学 和 软件工程。

想要做出伟大的产品：像你这样的优秀工程师一样做机器学习，而不是像你不具备的伟大机器学习专家一样 - 《机器学习规则：ML 工程的最佳实践》 [1]

统计学和软件工程的结合给软件工程领域带来了新的挑战。微软研究人员指出，在 ML 领域开发应用程序与先前的软件应用领域有根本的不同 2。

当你不在大公司工作或刚刚入门这个领域时，学习和应用软件工程最佳实践是困难的，因为找到这些信息并不容易。幸运的是，开源项目可以是一个很好的知识来源，并帮助我们解决从比我们有更多经验的人那里学习的需求。我最喜欢的 ML 库之一（也是知识来源）是 Scikit-learn。

这个项目在提供易用接口的同时也提供了稳固的实现，是进入 ML 领域的绝佳起点，也是行业中使用的工具。使用 scikit-learn 工具，甚至阅读维护者在 Github 上的问题讨论中的回答，是学习的好方法。Scikit 拥有来自行业和学术界的大量贡献者，因此这些人所做的贡献其知识会被“嵌入”到库中。scikit-learn 项目的一个经验法则是用户代码不应绑定于 scikit-learn —— 这是一个库，而不是一个框架 3。这使得扩展 scikit 功能以适应我们的需求变得容易。

今天我们将学习如何构建一个自定义转换器，并学习如何使用它来构建管道。这样，我们的代码变得易于维护和重用，这是软件工程最佳实践的两个方面。

scikit-learn API

如果你对 scikit-learn 熟悉，你可能知道如何使用估算器和转换器等对象，但把它们的定义正式化是有益的，这样我们可以在其基础上进行构建。基本 API 包含三个接口（一个类可以实现多个接口）：

• 估算器 - 基础对象，实现 fit() 方法

• 预测器 - 进行预测的接口，实现 predict() 方法

• transformer - 数据转换接口，实现了 transform() 方法

Scikit-learn 提供了许多开箱即用的转换器和预测器，但我们经常需要以不同的方式转换数据。使用转换器接口构建自定义转换器使我们的代码更具可维护性，我们还可以将新的转换器与其他 scikit 对象（如 Pipeline 和 RandomSearchCV 或 GridSearchCV）一起使用。我们来看看如何做到这一点。所有代码可以在这里找到。

构建自定义转换器

有两种类型的转换器：无状态转换器和有状态转换器。无状态转换器独立对待样本，而有状态转换器依赖于之前的数据。如果我们需要有状态的转换器，则在 fit() 方法中保存状态。无状态和有状态转换器都应返回自身。

大多数自定义转换器的示例使用 numpy 数组，所以我们尝试一些不同的，构建一个使用 spaCy 模型的转换器。我们的目标是创建一个文档分类模型。我们想知道词形还原和去除停用词是否能提高模型的性能。RandomSearchCV 和 GridSearchCV 非常适合用来实验不同的参数是否能提高模型性能。

当我们创建一个继承自 BaseEstimator 类的转换器类时，我们会自动获得 getparameters() 和 setparameters() 方法，这使得我们可以在搜索中使用新的转换器以找到最佳参数值。但为此我们需要遵循一些规则 4：

• init() 接受的关键字参数的名称应对应实例上的属性。

• 所有参数都应该具有敏感的默认值，这样用户可以简单地调用 EstimatorName() 实例化一个估计器。

• 验证应在参数被使用的地方进行；这意味着init()上不应有任何逻辑（即使是输入验证也不行）。

我们需要的参数是 spaCy 语言模型、词形还原和去除停用词。

使用 scikit-learn 管道

在机器学习中，许多任务可以表示为数据的序列或组合转换 3。管道提供了我们预处理步骤的清晰概览，将一系列估计器转化为一个单一的估计器。使用管道也是确保在训练、交叉验证或做出预测时始终执行完全相同步骤的一种方式。

管道的每个步骤都应实现 transform() 方法。为了创建模型，我们将使用新的转换器、TfidfVectorizer 和 RandomForestClassifier。这些步骤将转化为管道步骤。这些步骤被定义为元组，其中第一个元素是步骤的名称，第二个元素是估计器对象本身。

这样，我们可以使用管道对象来调用 fit()和 predict()方法，例如 textpipeline.fit(train, labels)和 textclf.predict(data)。我们可以使用管道最后一步实现的所有方法，因此我们还可以调用 textclf.predict_proba(data)来获取 RandomForestClassifier 的概率得分。

使用 GridSearchCV 寻找最佳参数

使用 GridSearchCV，我们可以在可能值的网格上进行详尽的最佳参数搜索（RandomizedSearchCV 是非详尽的替代方案）。为此，我们定义一个参数字典，其中键应该是name_of_pipeline_step__parameter_name，值应该是我们想尝试的参数值的列表。

RandomizedSearchCV 也是一个估算器，因此我们可以使用创建 RandomizedSearchCV 对象时使用的估算器的所有方法（scikit API 确实非常一致）。

主要内容

机器学习面临着软件工程领域不熟悉的挑战。构建实验是我们工作流程的一个重要部分，而使用凌乱的代码通常不会有好的结果。当我们扩展 scikit-learn 并使用这些组件来编写实验时，我们使得维护代码库的任务变得更容易，为我们日常工作带来理智。

参考文献

[1] developers.google.com/machine-learning/guides/rules-of-ml

2 www.microsoft.com/en-us/research/uploads/prod/2019/03/amershi-icse-2019*Software*Engineering*for*Machine_Learning.pdf

3 arxiv.org/pdf/1309.0238.pdf

4 scikit-learn.org/stable/developers/contributing.html#apis-of-scikit-learn-objects

简介：Déborah Mesquita (linkedin.com/in/deborahmesquita)是一个热爱写作的数据科学家。她喜欢认为自己是一个多才多艺的数据科学家，但事实是她还需要学习很多统计学知识。

相关内容：

• 将 sklearn 训练速度提高 100 倍

• 使用 Optimus 进行数据科学，第一部分：简介

• 使用 d6tflow 构建可扩展深度学习管道的 5 步指南

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业的捷径。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

了解更多相关话题

• Web LLM: 将 LLM 聊天机器人带到浏览器

• 通过 Scikit-learn 管道简化你的机器学习工作流程

• 7 个 GPT 助力提升你的数据科学工作流程

• 轻松将 LLM 集成到你的 Scikit-learn 工作流程中，使用 Scikit-LLM

• 5 门 Google MLOps 课程，提升你的 ML 工作流程

• RAPIDS cuDF 加速你的下一个数据科学工作流程

使用 BERT 的抽取式摘要

原文：www.kdnuggets.com/extractive-summarization-with-llm-using-bert

图片由编辑提供

引言

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升您的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持您组织的 IT

---

在当今快节奏的世界中，我们被大量信息轰炸。我们越来越习惯于在更短的时间内接收更多信息，当需要阅读大量文档或书籍时，这会导致沮丧。此时，抽取式摘要就发挥了作用。这个过程从文章、片段或页面中提取关键句子，为我们提供其最重要点的快照。

对于任何需要在不逐字阅读每一个单词的情况下理解大型文档的人来说，这是一项颠覆性的改变。

在这篇文章中，我们将深入探讨抽取式摘要的基础和应用。我们将审视大型语言模型，特别是 BERT （双向编码器表示模型）在提升这一过程中的作用。文章还将包括一个关于使用 BERT 进行抽取式摘要的实践教程，展示其在将大量文本浓缩为信息摘要中的实用性。

理解抽取式摘要

抽取式摘要是自然语言处理（NLP）和文本分析领域的一个重要技术。通过这种方法，从原始文本中精心选择关键句子或短语，并将其组合成简洁且信息丰富的摘要。这涉及仔细筛选文本，以识别所选内容中最关键的元素和中心思想或论点。

抽取式摘要涉及从原始文本中提取句子，保持原文的措辞和结构，而不改变或改写。这样，摘要保持了源材料的语气和内容。这种方法在准确性和保留作者原意的情况下极为有用。

它有许多不同的用途，比如总结新闻文章、学术论文或冗长的报告。该过程有效地传达了原始内容的信息，而不会出现可能的偏见或重新解释，这些情况可能在改述中发生。

提取性总结如何使用 LLM？

1. 文本解析

这一步骤涉及将文本分解为其基本元素，主要是句子和短语。目标是识别算法随后将评估以纳入摘要的基本单位（在此上下文中为句子），类似于剖析文本以理解其结构和各个组成部分。

例如，该模型将通过将四句段落拆分为以下四句组件来分析它。

1. 吉萨金字塔，建于古埃及，巍峨屹立了千年。

2. 它们被建作为法老的墓。

3. 大金字塔是最著名的。

4. 这些结构象征着建筑智慧。

2. 特征提取

在这一阶段，算法分析每个句子，以识别可能指示其对整体文本重要性的特征或“特征”。常见的特征包括关键词和短语的频率和重复使用、句子的长度、它们在文本中的位置及其含义，以及文本主要主题的特定关键词或短语的存在。

以下是 LLM 如何对第一个句子“吉萨金字塔，建于古埃及，巍峨屹立了千年”进行特征提取的示例。

属性	文本
频率	“吉萨金字塔”，“古埃及”，“千年”
句子长度	中等
位置在文本中	引言，设置主题
特定关键词	“吉萨金字塔”，“古埃及”

3. 句子评分

每个句子根据其内容分配一个得分。这个得分反映了句子在整个文本中的重要性。得分较高的句子被认为在整体文本中更有分量或相关性。

简而言之，该过程对每个句子的潜在重要性进行评分，以总结整个文本。

句子得分	句子	解释
9	吉萨金字塔，建于古埃及，巍峨屹立了千年。	这是引言句，设置了主题和背景，包含了诸如“吉萨金字塔”和“古埃及”这样的关键词。
8	它们被建作为法老的墓。	这句话提供了关于金字塔的关键历史信息，可能表明它们在理解其目的和重要性方面的意义。
3	大金字塔是最著名的。	尽管这句话提供了关于大金字塔的具体信息，但在总结金字塔总体重要性的广泛背景下，它被认为不那么关键。
7	这些结构象征着建筑智慧。	这个总结陈述捕捉了金字塔的整体重要性。

4. 选择和聚合

最后阶段涉及选择得分最高的句子并将其编入总结。经过精心处理，这确保了总结保持连贯，并且全面代表了原文的主要思想和主题。

要创建有效的总结，算法必须平衡包括简洁的重要句子，避免冗余，并确保所选的句子提供对整个原文的清晰和全面的概述。

• 建于古埃及的吉萨金字塔雄伟地矗立了数千年。它们是作为法老的陵墓而建造的。这些结构象征着建筑才华。

这个例子非常基础，从总共 4 个句子中提取了 3 个句子以获得最佳的整体总结。多读一个句子也无妨，但当文本更长时会怎样呢？假设是 3 段文字呢？

如何使用 BERT LLMs 运行抽取式总结

步骤 1：安装和导入必要的包

我们将利用预训练的 BERT 模型。然而，我们不会使用任何 BERT 模型，而是专注于 BERT Extractive Summarizer。这个特定的模型已经为抽取式总结的专业任务进行了精细调优。

!pip install bert-extractive-summarizer
from summarizer import Summarizer

步骤 2：引入总结函数

从 Python 的 summarizer 中导入的 Summarizer()函数是一个抽取式文本总结工具。它使用 BERT 模型来分析和提取较大文本中的关键句子。该函数旨在保留最重要的信息，提供原始内容的精简版本。它通常用于高效地总结冗长的文档。

model = Summarizer()

步骤 3：导入我们的文本

在这里，我们将导入任何我们想要测试模型的文本。为了测试我们的抽取式总结模型，我们使用 ChatGPT 3.5 生成了以下文本，提示是：“提供一个关于 GPU 历史及其今日应用的 3 段总结。”

text = "The history of Graphics Processing Units (GPUs) dates back to the early 1980s when companies like IBM and Texas Instruments developed specialized graphics accelerators for rendering images and improving overall graphical performance. However, it was not until the late 1990s and early 2000s that GPUs gained prominence with the advent of 3D gaming and multimedia applications. NVIDIA's GeForce 256, released in 1999, is often considered the first GPU, as it integrated both 2D and 3D acceleration on a single chip. ATI (later acquired by AMD) also played a significant role in the development of GPUs during this period. The parallel architecture of GPUs, with thousands of cores, allows them to handle multiple computations simultaneously, making them well-suited for tasks that require massive parallelism. Today, GPUs have evolved far beyond their original graphics-centric purpose, now widely used for parallel processing tasks in various fields, such as scientific simulations, artificial intelligence, and machine learning.  Industries like finance, healthcare, and automotive engineering leverage GPUs for complex data analysis, medical imaging, and autonomous vehicle development, showcasing their versatility beyond traditional graphical applications. With advancements in technology, modern GPUs continue to push the boundaries of computational power, enabling breakthroughs in diverse fields through parallel computing. GPUs also remain integral to the gaming industry, providing immersive and realistic graphics for video games where high-performance GPUs enhance visual experiences and support demanding game graphics. As technology progresses, GPUs are expected to play an even more critical role in shaping the future of computing." 

步骤 4：执行抽取式总结

最后，我们将执行我们的总结函数。该函数需要两个输入：要总结的文本和所需的总结句子数量。处理后，它将生成一个抽取式总结，我们将显示出来。

# Specifying the number of sentences in the summary
summary = model(text, num_sentences=4) 
print(summary)

抽取式总结输出：

图形处理单元（GPU）的历史可以追溯到 1980 年代初期，当时像 IBM 和德州仪器这样的公司开发了专用的图形加速器，用于渲染图像和提高整体图形性能。NVIDIA 的 GeForce 256，发布于 1999 年，常被认为是第一款 GPU，因为它将 2D 和 3D 加速集成在一个芯片上。如今，GPU 已经远远超出了其最初的图形中心用途，现在广泛用于各种领域的并行处理任务，如科学模拟、人工智能和机器学习。随着技术的发展，GPU 预计将在塑造计算未来中发挥更为关键的作用。

我们的模型从大量文本中提取了 4 个最重要的句子来生成这个摘要！

使用 LLM 进行提取式总结的挑战

1. 上下文理解的局限性

   1. 虽然 LLM 在处理和生成语言方面表现出色，但它们对上下文的理解，尤其是在较长文本中的理解，仍然有限。LLM 可能会遗漏细微的差别或未能识别文本中的关键方面，导致总结不够准确或相关。语言模型越先进，总结的质量就越好。

2. 训练数据中的偏差

   1. 大型语言模型（LLM）从包括互联网在内的各种来源编译的大量数据集中学习。这些数据集可能包含偏差，模型可能无意中学习并在总结中复制这些偏差，导致扭曲或不公平的表现。

3. 处理专业或技术语言

   1. 虽然 LLM 通常在各种普通文本上进行训练，但它们可能无法准确捕捉到法律、医学或其他高度专业领域的专业或技术语言。这可以通过提供更多专业和技术文本来缓解。缺乏对专业术语的训练可能会影响这些领域中总结的质量。

结论

显然，提取式总结不仅仅是一个方便的工具；在我们每天被大量文本淹没的信息时代，它变得越来越必要。通过利用像 BERT 这样的技术，我们可以看到复杂的文本如何被提炼成易于理解的摘要，从而节省时间，并帮助我们更好地理解被总结的文本。

无论是用于学术研究、商业洞察，还是仅仅为了在技术先进的世界中保持信息更新，提取式总结都是在我们被信息海洋包围的世界中导航的实用方式。随着自然语言处理技术的不断发展，像提取式总结这样的工具将变得更加重要，帮助我们快速找到并理解在每分钟都很关键的世界中最重要的信息。

原文。经许可转载。

Kevin Vu 负责管理 Exxact Corp 博客，并与许多才华横溢的作者合作，这些作者撰写关于深度学习不同方面的内容。

了解更多主题

• 使用 BERT 对长文本文档进行分类

• 文本摘要方法概述

• 开始使用自动化文本摘要

• 使用 GPT-3 进行摘要

• 文本摘要开发：使用 GPT-3.5 的 Python 教程

• 通过密度链提示解锁 GPT-4 摘要

Facebook 利用贝叶斯优化在机器学习模型中进行更好的实验

原文：www.kdnuggets.com/2020/08/facebook-bayesian-optimization-better-experiments-machine-learning.html

评论

来源：www.persado.com/2016/06/machine-learning-trumps-a-b-split-testing/

我最近开始了一份新的关注人工智能教育的通讯。《TheSequence》是一份无废话（即没有炒作，没有新闻等）的 AI 专注通讯，阅读时间为 5 分钟。目标是让你了解最新的机器学习项目、研究论文和概念。请通过以下方式订阅试试：

超参数优化是机器学习应用生命周期中的一个关键方面。尽管诸如网格搜索之类的方法在优化特定孤立模型的超参数方面极为有效，但它们很难在大规模模型和实验的排列中进行扩展。像 Facebook 这样的公司运营着数千个并发的机器学习模型，这些模型需要不断地进行调整。为此，Facebook 工程团队需要定期进行 A/B 测试，以确定合适的超参数配置。这些测试中的数据难以收集，并且通常是孤立进行的，最终导致计算成本极高。在这一领域最具创新性的方法之一来自 Facebook 的一个 AI 研究团队，他们发表了一篇基于贝叶斯优化的方法来自适应设计 A/B 测试轮次的论文，该方法基于之前测试的结果。

为什么选择贝叶斯优化？

贝叶斯优化是一种强大的方法，用于解决涉及昂贵函数评估的黑箱优化问题。最近，贝叶斯优化已发展成为优化机器学习模型中的超参数的重要技术。概念上，贝叶斯优化从评估少量随机选择的函数值开始，并将高斯过程（GP）回归模型拟合到结果中。GP 后验提供了每一点的函数值估计以及该估计的不确定性。GP 在贝叶斯优化中表现良好，因为它提供了出色的不确定性估计，并且在理论上易于处理。它提供了一个估计，说明在线度量如何随着感兴趣的参数变化。

让我们设想一个环境，其中我们对机器学习模型进行随机和定期的实验。在这种情况下，贝叶斯优化可以用来构建参数与在线结果之间关系的统计模型，并使用该模型来决定运行哪些实验。这个概念在下图中得到了很好的说明，其中每个数据标记对应于该参数值的 A/B 测试结果。我们可以使用 GP 来决定下一个测试哪个参数，通过在探索（高不确定性）与利用（良好的模型估计）之间取得平衡来完成。这是通过计算一个获取函数来完成的，该函数估计运行任何给定参数值实验的价值。

来源：projecteuclid.org/download/pdfview_1/euclid.ba/1533866666

在应用于超参数优化时，贝叶斯优化的基本目标是确定特定超参数配置的实验价值。从概念上讲，贝叶斯优化对于孤立模型非常有效，但在运行随机实验的场景中，其价值主张面临挑战。根本挑战与观察中引入的噪声有关。

噪声与贝叶斯优化

机器学习系统中的随机实验引入了高水平的观察噪声。此外，许多特定实验的约束本身也可以视为噪声数据，这可能会影响实验结果。假设我们试图评估给定观察x的函数f(x)的值。由于观察噪声，我们不仅对值f(x)有不确定性，而且对当前最佳观察x及其值f(x)也存在不确定性。

通常，贝叶斯优化模型使用启发式方法来处理噪声观察，但这些方法在噪声水平较高时表现很差。为了解决这个问题，Facebook 团队提出了一个巧妙的答案：为什么不把噪声作为观察的一部分呢？

想象一下，如果我们观察到的不是f(x)的期望，而是yi = f(xi) + €i，其中€i是观察噪声。从数学上讲，GP 在处理带噪声的观察时与处理无噪声数据的方式类似。虽然数学细节较多，但在他们的研究论文中，Facebook 团队展示了这种类型的近似非常适合蒙特卡洛优化，这种优化方法能准确估计正确的观察结果。

带噪声数据的贝叶斯优化实践

Facebook 团队在几个现实世界的场景中测试了他们的研究，规模达到 Facebook 级别。第一个场景是优化 Facebook 排名系统的 6 个参数。第二个例子是优化 7 个与 CPU 使用相关的数字编译器标志，这些标志用于他们的 HipHop 虚拟机（HHVM）。在第二个实验中，前 30 次迭代是随机生成的。此时，噪声数据下的贝叶斯优化方法能够识别出 CPU 时间作为需要评估的超参数配置，并开始运行不同的实验以优化其值。结果在下图中清晰地展示出来。

来源：projecteuclid.org/download/pdfview_1/euclid.ba/1533866666

噪声数据下的贝叶斯优化等技术在大规模机器学习算法中极具威力。虽然我们在优化方法上做了大量工作，但大多数方法仍然高度理论化。很高兴看到 Facebook 推动了这个新兴领域的边界。

原始文章。经许可转载。

相关：

• 学习贝叶斯统计的必备资源

• Uber 的 Ludwig 是一个用于低代码机器学习的开源框架

• Facebook 开源 Blender，最大规模的开放领域聊天机器人

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织 IT

---

更多相关内容

• LinkedIn 如何使用机器学习来排序你的动态

• KDnuggets 新闻，11 月 16 日：LinkedIn 如何使用机器学习 •…

• 机器学习实验的版本控制与追踪

• 用于深度学习实验的 Hydra 配置

• 顶级编程语言及其应用

• KDnuggets™ 新闻 22:n04, 1 月 26 日: 高收入的副业…

Facebook 为 Torch 开源的深度学习模块

原文：www.kdnuggets.com/2015/02/facebook-open-source-deep-learning-torch.html

如果你是 Torch 用户，并且对大规模深度学习感兴趣，你可能已经尝试过 Facebook 人工智能研究院发布的深度学习模块。他们为 Torch 优化的深度学习模块，fbcunn，正在广泛讨论中。

这些模块比 Torch 中的默认模块要快得多，使我们的研究项目加速，因为它们允许我们在更短的时间内训练更大的神经网络。

Torch 是一个为 Lua 编程语言设计的深度学习库，广泛应用于谷歌、脸书和 IBM 等科技公司。最近发布的版本包含了训练卷积神经网络和其他深度学习模型的工具。

• 允许用户在多个 GPU 上并行训练的容器

• 一个优化的查找表，常用于词嵌入和神经语言模型。

• Hierarchical SoftMax 模块，用于加速训练极大量的类别。现在对 100 万个类别进行分类是一种实际可行的策略。

• Cross-map pooling，常用于某些类型的视觉和文本模型。

• 基于论文 的 1-bit SGD 的 GPU 实现，由 Frank Seide 等人提出。

• 一个显著更快的 Temporal Convolution 层（比 Torch 的 cunn 实现快 1.5 倍到 10 倍）。

这些发布的模块中最重要的是一个基于 FFT 的快速卷积层，运行在 NVIDIA GPU 上。他们声称，他们的 FFT 基于卷积层的代码比其他任何公开代码都要快，用于训练流行架构时，他们的实验表明，比 NVIDIA 的 CuDNN 快多达 23.5。当内核大小变大时，速度提升更加显著（从 55 开始）。

该代码基于NYU 研究人员发布的算法，在傅里叶域中执行卷积作为乘积。他们提出先对每组矩阵进行傅里叶变换，然后进行成对卷积作为乘积。由于特征图的规模很大，使用 FFT 加速了训练。

Facebook 人工智能研究院 (FAIR) 成立于 2013 年 12 月，由 Yann LeCun 领导。查看 FAIR 发布的深度学习模块。

相关：

• CuDNN – 一个新的深度学习库

• KDnuggets 独家：与深度学习专家、Facebook AI 实验室主任 Yann LeCun 的访谈

• 深度学习 – 学习和理解的重要资源

更多相关内容

• 使用 Tableau 创建高效的组合数据源

• 用于高级数据科学项目的前 16 个技术数据源

• 前 18 名数据科学 Facebook 群组

• 开放助理：探索开放和协作的可能性…

• 介绍 Objectiv：开源产品分析基础设施

• DeepMind 的 AlphaTensor 首个开源实现

如何失败于人工智能：9 种创意方式让你的 AI 创业公司走向失败

原文：www.kdnuggets.com/2017/05/fail-artificial-intelligence-creative-ways.html

评论

作者：弗朗切斯科·加达莱塔，Abe。

由 startupcfos.in 提供

---

我们的前三名课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的快车道。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织在 IT 领域

---

大多数企业家和数据科学家会告诉你如何利用人工智能（AI）和机器学习取得成功，但很少有人谈论如何失败于这些技术。尽管技术极其强大——且被过度宣传——但有很多种方式可以使 AI 项目失败。

本文总结了九种创意方式，几乎可以将任何 AI 创业公司推向破产。我专注于数据科学和机器学习创业公司，但关于应该避免的教训也可以轻松地应用于其他行业。

#1 削减研发支出以节省资金

人工智能需要大量投资于前沿研究、实验、先进算法和计算基础设施。任何希望开发有用 AI 技术的 AI 创业公司都必须在这些领域投入大量资金用于研究和开发（R&D）。

尽管削减这一领域的开支可能很有诱惑力，但削减研发成本将迅速铺平失败的道路。

#2 在技术泡沫中运作

技术与其创建时的社会环境密切相关。技术从来不是自我维持的。

人工智能在计算机科学历史上曾多次失败，这不仅由于技术问题——这些问题可以解决并且确实已经解决——也因为当时社会对其缺乏需求和兴趣。

应该吸取的教训是，人工智能技术不能脱离使其成为必需的社会环境（如医疗保健、疾病研究和金融）而孤立地构建。

一项新技术只有在其支持者引起兴趣并从将成为其最终用户或客户的人那里获得资源时才会成功。在工程化技术本身之前，愿景者和企业家应该首先“工程化”人们，说服他们放下疑虑，接受颠覆性想法的新颖性和实用性。

在泡沫中运作，忽视社会当前需求，是走向失败的必经之路。

#3 将技术置于商业战略之上

仅靠技术是不足以取得成功的，无论技术多么强大或变革性。归根结底，技术初创公司仍然是一个商业体，需要坚实的商业策略才能成功。

任何一个没有明确目标市场识别、销售生成和有效分配资源策略的初创公司，只将重点放在其技术资产上的，注定会失败（并且很快）。

#4 缺乏清晰的愿景

对于任何技术公司来说，快速建立明确的愿景至关重要。这对于 AI 公司尤其重要，因为技术在许多不同的行业（从金融到医疗）都有应用。

这个愿景应该尽早并经常地传达给员工，以确保每个人都对公司的使命和发展路线图有一致的理解。除了这个长期愿景之外，明确的短期目标和任务也是至关重要的。

目标支离破碎和多样化几乎总是失败的前兆。

#5 在未解决商业需求的情况下进行开发

AI 公司也是软件公司。为了自身目的而编写的软件，如果不能满足任何商业需求，是不会卖出去的。

无用的软件，无论开发成本多么低廉，最终都会非常昂贵，因为没有回报。如果它对潜在客户没有任何价值，那么开发它就浪费时间和资源，最终对你的公司没有任何价值。

为了 AI 而开发 AI 是一种……走向失败的好方法。

#6 培养“我们是最好的”态度

自信对于保持高开发标准至关重要，但如果放任不管，可能会带来问题。过于膨胀的自信往往会陷入产品设计的最大陷阱之一：傲慢。

这种态度在初创公司中很常见。假设他们自己的产品是最好的，这样的组织往往会将所有开发都放在内部进行，即使是那些可以轻松外包的任务。这不仅浪费了宝贵的时间和资源，还阻碍了团队专注于核心业务。

以过于自信的态度推进只会让你快速走向失败。

#7 陷入无休止的开发循环

这对软件公司（尤其是 AI 公司）尤为适用。

在软件设计中，快速开发和更快发布是很重要的，即使产品不完美。为什么？因为在封闭环境中开发的软件没有任何好处；它需要在现实世界中，面对真实用户和真实问题。通过提前和频繁发布，你可以收集有用的数据，了解什么有效，什么无效，并迭代出最佳版本的产品。

快速进入市场的好处超过了弊端。冒险向竞争对手公开功能是为了获得用户的即时（且频繁的）反馈所需付出的代价。

持续处于一个无休止的设计-开发-设计循环中，会导致错失市场机会和信息。这是一条通向失败的确定途径。

#8 假设你的客户像开发者一样

对用户而言，软件是一种体验。而开发者则将软件视为工具。产品设计应围绕客户进行，而不是开发者（除非开发者就是客户）。

认为客户和开发者一样是典型的初创公司文化，并对科技公司有害。

开发者往往关注产品的技术方面，优先考虑功能而非形式。不幸的是，他们通常忽视设计和用户体验。任何人工智能产品要想成功并广泛采用，必须既具备功能性又设计良好，以便于使用。

开发一个仅仅满足开发者愿景和需求的人工智能产品会导致在实际市场中未满足的需求。简而言之，就是失败。

#9 假设人工智能的炒作足以成功

这不是人工智能第一次受到大量炒作。第一次是在 80 年代，当时教授们声称计算机很快会取代人类（显然这并没有发生）。但现在人工智能再次受到高度炒作，这次似乎有所不同。持续五年的炒作而没有减缓迹象，这不仅仅是炒作，而是稳定的趋势。

然而，单凭炒作是不足以让技术成功的。人工智能开发者必须付诸实践，构建真正能够兑现炒作的产品。

认为一个人工智能初创公司会因为其核心业务的炒作而成功，这是迈向失败的第一步。

结论

要建立一个成功的人工智能初创公司，首先你需要了解如何失败。这意味着要面对并纠正你的错误假设、不匹配的优先级和不明确的策略。

预测并避免失败的路径，为你的公司提供成功的最佳机会。

简介：弗朗切斯科·加达莱塔 (@worldofpiggy) 主要撰写关于机器学习和深度学习的内容，并且是 Abe 的首席数据官。

原文。经许可转载。

相关：

• 如何在数据初创公司完成工作

• 大数据、数据科学、分析项目失败的主要原因

• 什么是人工智能？智能的成分

更多相关内容

• 如何使用 GPT 通过 Hugging Face 生成创意内容…

• 通过 ChatGPT 和 AI 赚钱的 3 种方法

• 12 个建议：从数据分析师到创业公司联合创始人

• 在 ChatGPT 时代建立深科技创业公司的 10 个障碍

• 免费人工智能与深度学习速成课程

• 2022 年最热门的人工智能技能

一步一步做：生成真实的合成客户数据集

原文：www.kdnuggets.com/2022/01/fake-realistic-synthetic-customer-datasets-projects.html

图片由 mcmurryjulie 在 Pixabay 提供

能够在项目中创建和使用合成数据已经成为数据科学家的必备技能。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织在 IT 方面

---

我之前写过关于使用 Python 库Faker来创建自己的合成数据集。为了避免重复那篇文章的内容，让我们将此视为生成合成数据系列的第二篇。这次，让我们生成一些虚假的客户订单数据。

如果你对 Faker 一无所知，不知道它是如何使用的或可以做什么，我建议你首先查看之前的文章。

计划

计划是合成一组缩小版的表，这些表将在实际业务场景的客户订单系统中使用。

除了购买项目之外，我们还要考虑这种情况下需要什么。

• 客户 - 不出意外的是，如果你要建立一个跟踪客户订单的系统，你需要客户。

• 信用卡 - 客户需要支付账单，在我们简化的场景中，他们只能通过信用卡支付。

• 订单 - 一个订单将包括一个客户、一笔费用和一个信用卡用于支付。

这是我们需要的数据，所以这就是我们要生成的数据。在完成这一过程后，你可能会发现使其更稳健、更详细、更贴近现实的方法，你应该能够自行完成。

导入和辅助函数

让我们开始吧。首先，进行导入。

from faker import Faker
import faker.providers.credit_card
import pandas as pd

import random
from random import randint

接下来，让我们编写几个稍后会用到的辅助函数。

def random_n_digits(n):
    range_start = 10**(n-1)
    range_end = (10**n)-1
    return randint(range_start, range_end)

def unique_rand(rands, n):
    new_int = random_n_digits(n)
    if new_int not in rands:
        rands.append(new_int)
    else:
        unique_rand(rands, n)
    return new_int, rands

def generate_cost():
    cost = ''
    digits = randint(1, 4)
    cost += str(random_n_digits(digits))
    cost += '.' + str(random_n_digits(2))
    return cost

第一个函数，random_n_digits，将用于生成长度为 n 的随机整数。参考 这个 StackOverflow 答案，请参见下面的示例：

def random_n_digits(n):
    range_start = 10**(n-1)
    range_end = (10**n)-1
    return randint(range_start, range_end)

print(random_n_digits(3))
print(random_n_digits(5))
print(random_n_digits(10))

745
98435
7629340561

这将对诸如客户和订单编号等标识符非常有用。

接下来的函数，unique_rand()，将用于确保生成的标识符在我们的系统中是唯一的。它简单地接受一个整数列表和一个表示新整数长度的整数，使用前面的函数创建一个这个长度的新整数，将这个新整数与唯一列表进行比较，如果这个新整数也唯一，它就会被添加到列表中。

最终函数的实用性通过其名称**generate_cost()**来体现。要生成一个费用，该函数随机生成一个介于 1 到 4 之间的整数，这将成为我们生成的费用的美元位数的字符串长度。然后使用 random_n_digits() 生成该长度的整数。之后，重复这个过程生成一个 2 位整数，这将成为费用的小数部分，位于小数点的右侧。将这两个部分组合在一起并返回。

现在让我们继续伪造吧。

不用担心，连 Elaine 都在伪造。

创建客户

这样，我们来生成客户。我们的 10,000 位客户将包括以下属性：

• 客户 ID (cust_id) - 使用上述辅助函数生成

• 客户姓名 (name) - 使用 Faker 生成；use_weighting=True 表示尝试使生成值的频率匹配真实世界的频率（“Lisa”将比“Braelynn”更频繁地生成）；locales 表示生成名字的来源

• 客户地址 (address) - 使用 Faker 生成

• 客户电话号码 (phone_number) - 使用 Faker 生成

• 客户出生日期 (dob) - 使用 Faker 生成

• 客户备注文本字段 (note) - 使用 Faker 生成

代码还会将生成的唯一客户 ID (cust_ids) 作为列表存储，以便将新生成的 ID 与现有的进行比较，确保唯一性。之后，将用于存储客户数据的字典传递到新的 Pandas DataFrame 中，最终存储到 CSV 文件中。

fake = Faker(['en_US', 'en_UK', 'it_IT', 'de_DE', 'fr_FR'], use_weighting=True)

customers = {}
cust_ids = []

for i in range(0, 10000):
    customers[i]={}
    customers[i]['cust_id'], cust_ids = unique_rand(cust_ids, 8)
    customers[i]['name'] = fake.name()
    customers[i]['address'] = fake.address().replace('\n', ', ')
    customers[i]['phone_number'] = fake.phone_number()
    customers[i]['dob'] = fake.date()
    customers[i]['note'] = fake.text().replace('\n', ' ')

customer_df = pd.DataFrame(customers).T
print(customer_df)

customer_df.to_csv('customer_data.csv', index=False)

       cust_id                 name  \
0     52287029            Jay Brown   
1     85688731    Frédérique Martel   
2     95499535      Georges Leclerc   
3     28715621  Christian Carpenter   
4     94472217       Lorraine Watts   
...        ...                  ...   
9995  70168635       Léon Couturier   
9996  10483280       Vincent Nelson   
9997  41868059           Gert Klapp   
9998  28049517    Simonetta Garrone   
9999  26781527      Alessio Camanni   

                                                address       phone_number  \
0     Flat 9, Hart islands, East Elliotchester, DY6N...       0117 4960802   
1             boulevard Chevalier, 93506 BourgeoisBourg  625.665.4731x5846   
2                    43 Poole way, Taylorstad, KW45 0FT         0780881522   
3     Rotonda Olivetti 99, Sandro salentino, 48332 L...      (00960) 04254   
4              Jolanda-Seifert-Allee 113, 91518 Koblenz    +39 353 5623602   
...                                                 ...                ...   
9995  Strada Molesini 3 Appartamento 32, Ariasso ven...   +44(0)1214960433   
9996                         Trubring 86, 28785 Ansbach  +33 5 61 32 08 79   
9997  Strada Casarin 01 Piano 8, Settimo Giovanni ne...    +39 695 7780253   
9998        Marga-Trubin-Straße 2/4, 13495 Feuchtwangen     (07310) 491854   
9999  avenue Susanne Berthelot, 70292 Poirier-sur-Ra...       0114 4960083   

             dob                                               note  
0     2004-08-20  Interroger dormir but remercier atteindre juge...  
1     2009-07-08  Semblable tout désert dominer lutte. Quart mêm...  
2     2021-04-17  Occaecati occaecati temporibus a asperiores di...  
3     1999-05-03  Rem itaque maxime dolor eum omnis. Eligendi qu...  
4     1997-06-02  Doloremque ut illo sunt. Modi non autem conseq...  
...          ...                                                ...  
9995  1981-06-06  Language state white receive soon. Usually tru...  
9996  2020-01-03  Similique quasi eos pariatur consequatur liber...  
9997  2018-10-13  Voluptatum exercitationem omnis rem. Beatae al...  
9998  1983-02-09  Treat vote poor church area discuss carry argu...  
9999  1987-02-06  Go remember center toward real food section. S...  

[10000 rows x 6 columns]

创建信用卡

客户需要一种支付订单的方法，因此我们给他们所有人都配备信用卡。

实际上，为了简化，我们将生成信用卡而不分配给任何特定客户。相反，我们将仅仅将客户和卡片匹配用于订单。你可以稍加创新，修改此方法将卡片分配给客户，并确保订单使用正确的卡片支付。我将把这留给有兴趣的读者作为练习。

下面你将发现唯一的信用卡号码是使用与唯一客户 ID 相同的辅助函数和基本方法生成的。信用卡号码人为地较短，但你可以按需增加长度。其余数据使用 Faker 生成。数据随后被输入到 Pandas DataFrame 中，并保存为 CSV 文件以备后用。

credit_cards = {}
cc_ids = []

for i in range(0, 10000):
    credit_cards[i]={}
    credit_cards[i]['cc_id'], cc_ids = unique_rand(cc_ids, 5)
    credit_cards[i]['type'] = fake.credit_card_provider()
    credit_cards[i]['number'] = fake.credit_card_number()
    credit_cards[i]['ccv'] = fake.credit_card_security_code()
    credit_cards[i]['expire'] = fake.credit_card_expire()

credit_cards_df = pd.DataFrame(credit_cards).T
print(credit_cards_df)

credit_cards_df.to_csv('credit_card_data.csv', index=False)

      cc_id           type            number  ccv expire
0     33257   JCB 16 digit   213177754612892  121  11/24
1     86707  VISA 16 digit  6573538482942722  042  11/31
2     96668  VISA 16 digit  4780281393619055  671  01/23
3     73749  VISA 16 digit  3520725757002891  319  04/28
4     26342  VISA 13 digit    30141856563149  495  10/29
...     ...            ...               ...  ...    ...
9995  14141  VISA 13 digit     4617204802844  640  04/27
9996  35599        Maestro      639006455203  384  12/21
9997  46479  VISA 16 digit      503885514391  587  08/24
9998  78536  VISA 19 digit     4789890563459  057  07/22
9999  84649     Mastercard  3590096870674031  874  04/31

[10000 rows x 5 columns]

创建订单

现在我们来赚点钱吧。

订单将以与之前的客户 ID 和信用卡号码相同的方式保持唯一。我们将随机链接一个客户和一个信用卡到一个订单中，并使用之前介绍的第三个辅助函数生成一个随机费用。

在已成为常见管道的过程中，我们创建了一个字典的 Pandas DataFrame，并将数据保存为 CSV 文件。

orders = {}
order_ids = []

for i in range(0, 1000):
    orders[i]={}
    orders[i]['order_id'], order_ids = unique_rand(order_ids, 10)
    orders[i]['cust_id'] = random.choice(cust_ids)
    orders[i]['cc_id'] = random.choice(cc_ids)
    orders[i]['cost'] = generate_cost()

orders_df = pd.DataFrame(orders).T
print(orders_df)

orders_df.to_csv('orders.csv', index=False)

       order_id   cust_id  cc_id     cost
0    9526379779  21484387  95840  6471.85
1    6999189530  90073074  75578     5.31
2    6124881941  84882923  13358   962.21
3    7476579071  91911770  22301    60.82
4    4102308607  60614412  28339  8086.96
..          ...       ...    ...      ...
995  2021016579  42107923  24863  4165.62
996  9279206414  49397693  45436     1.27
997  3378899620  40173623  96470    32.64
998  2222207181  73076539  40697  9701.29
999  1040242247  17749465  66052     9.63

[1000 rows x 4 columns]

结果是你应该拥有三个 CSV 文件，这些文件构成了对实际业务流程的真实世界模拟。

现在你打算怎么处理这些合成数据？发挥你的创造力。你可以做一些研究，学习一些新技术或概念，或者进行一个项目。一些更具体的想法包括：使用 Python 将这些数据创建成 SQL 数据库，然后练习你的 SQL 技能；执行一个数据探索项目；以有趣的方式可视化一些合成数据；看看你能想出什么样的数据预处理方法，例如将客户姓名拆分为名和姓，验证每个客户是否有信用卡，确保小孩无法进行购买。

记住：继续伪装下去。

Matthew Mayo （@mattmayo13）是一名数据科学家，并且是 KDnuggets 的主编，这是一个开创性的在线数据科学和机器学习资源。他的兴趣包括自然语言处理、算法设计与优化、无监督学习、神经网络以及机器学习的自动化方法。Matthew 拥有计算机科学硕士学位和数据挖掘研究生文凭。他可以通过 editor1 at kdnuggets[dot]com 与他联系。

更多相关话题

• 使用稳定扩散生成超现实面孔的 3 种方法

• 你需要合成数据的 5 个理由

• 检测假数据科学家的 20 个问题（含答案）：ChatGPT…

• 检测假数据科学家的 20 个问题（含答案）：ChatGPT…

• 如何利用合成数据克服机器学习模型训练中的数据短缺

• 如何生成合成表格数据集

Falcon LLM: 开源 LLM 新霸主

原文：www.kdnuggets.com/2023/06/falcon-llm-new-king-llms.html

图片由编辑提供

我们看到每周都有大量语言模型（LLMs）问世，更多的聊天机器人供我们使用。然而，确定哪个是最好的，了解每个模型的进展以及哪个最有用，可能会很困难。

---

我们的前三课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升您的数据分析技能

3. Google IT 支持专业证书 - 支持您的组织进行 IT 工作

---

HuggingFace 拥有一个开放的 LLM 排行榜，跟踪、评估和排名正在发布的 LLM。它们使用独特的框架来测试生成性语言模型在不同评估任务上的表现。

最近，LLaMA（大型语言模型 Meta AI）曾位居排行榜首位，但近期被新预训练的 LLM - Falcon 40B 取代。

图片由 HuggingFace 开放 LLM 排行榜 提供

关于技术创新研究所

Falcon LLM 由 技术创新研究所（TII）创立并开发，TII 是阿布扎比政府高级技术研究委员会的一部分。该政府机构监管阿联酋的技术研究，科学家、研究人员和工程师的团队专注于提供变革性技术和科学发现。

什么是 Falcon 40B？

Falcon-40B 是一个具有 40B 参数的基础 LLM，训练数据为一万亿个标记。Falcon 40B 是一个自回归解码器模型。自回归解码器模型意味着该模型被训练来预测序列中给定先前标记后的下一个标记。GPT 模型是一个很好的例子。

Falcon 的架构在仅使用 75% 的训练计算预算的情况下，已显著超越 GPT-3，并且在推理时仅需要 ? 的计算量。

数据质量在规模化方面是技术创新研究所团队的重要关注点，因为我们知道 LLM 对训练数据的质量非常敏感。该团队建立了一个数据管道，扩展到数万个 CPU 核心以进行快速处理，并能够通过广泛的过滤和去重从网络中提取高质量内容。

他们还有一个较小的版本：Falcon-7B，具有 7B 参数，训练于 1500B 个 token。此外，还有一个Falcon-40B-Instruct和Falcon-7B-Instruct模型可供使用，如果你在寻找一个现成的聊天模型。

Falcon 40B 可以做什么？

与其他 LLM 类似，Falcon 40B 可以：

• 生成创意内容

• 解决复杂问题

• 客户服务操作

• 虚拟助手

• 语言翻译

• 情感分析。

• 减少和自动化“重复性”工作。

• 帮助阿联酋公司提高效率

Falcon 40B 是如何训练的？

由于训练了 1 万亿个 token，它在 AWS 上需要 384 个 GPU，耗时超过两个月。训练于 1000B 个 token 的RefinedWeb，这是 TII 构建的大型英语网页数据集。

预训练数据包括来自网络的公共数据集，使用了CommonCrawl。团队经过了严格的过滤阶段，以去除机器生成的文本和成人内容，并进行了去重，从而组装了一个近五万亿 token 的预训练数据集。

基于 CommonCrawl 构建的 RefinedWeb 数据集显示，使用此数据集训练的模型比使用策划数据集训练的模型表现更好。RefinedWeb 也是多模态友好的。

一旦准备好，Falcon 就通过了如 EAI Harness、HELM 和 BigBench 等开源基准测试的验证。

Falcon LLM 是开源的

他们已将Falcon LLM 开源给公众，使 Falcon 40B 和 7B 对研究人员和开发人员更加可及，因为它基于 Apache License Version 2.0 发布。

曾经仅用于研究和商业用途的 LLM，现在已成为开源，以满足全球对 AI 包容性访问的需求。它现在在商业使用中不再受版税限制，因为阿联酋致力于改变 AI 中的挑战和边界，并在未来发挥重要作用。

旨在培养一个合作、创新和知识共享的 AI 生态系统，Apache 2.0 确保了安全和安全的开源软件。

如何使用 Falcon-7B Instruct LLM

如果你想尝试一个更简单的 Falcon-40B 版本，适合处理通用指令风格的聊天机器人，你可以使用 Falcon-7B。

那么让我们开始吧…

如果你还没有，请安装以下软件包：

!pip install transformers
!pip install einops
!pip install accelerate
!pip install xformers

一旦您安装了这些包，您可以继续运行Falcon 7-B Instruct提供的代码。

from transformers import AutoTokenizer, AutoModelForCausalLM
import transformers
import torch

model = "tiiuae/falcon-7b-instruct"

tokenizer = AutoTokenizer.from_pretrained(model)
pipeline = transformers.pipeline(
    "text-generation",
    model=model,
    tokenizer=tokenizer,
    torch_dtype=torch.bfloat16,
    trust_remote_code=True,
    device_map="auto",
)
sequences = pipeline(
   "Girafatron is obsessed with giraffes, the most glorious animal on the face of this Earth. Giraftron believes all other animals are irrelevant when compared to the glorious majesty of the giraffe.\nDaniel: Hello, Girafatron!\nGirafatron:",
    max_length=200,
    do_sample=True,
    top_k=10,
    num_return_sequences=1,
    eos_token_id=tokenizer.eos_token_id,
)
for seq in sequences:
    print(f"Result: {seq['generated_text']}")

总结

作为最好的开源模型，Falcon 已经接过 LLaMAs 的王冠，人们对其强大的优化架构、具有独特许可的开源性质以及提供 40B 和 7B 参数两种尺寸感到惊讶。

你尝试过了吗？如果尝试过，请在评论中告诉我们你的想法。

尼莎·阿娅 是一位数据科学家、自由技术作家以及 KDnuggets 的社区经理。她特别感兴趣于提供数据科学职业建议或教程以及基于数据科学的理论知识。她还希望探索人工智能如何/可以如何有助于人类寿命的延续。作为一个热心学习者，她寻求拓宽自己的技术知识和写作技能，同时帮助指导他人。

更多相关主题

• 系好安全带：Falcon 180B 来了！

• Streaming-LLM 介绍：适用于无限长度输入的 LLM

• 轻松将 LLMs 集成到您的 Scikit-learn 工作流程中，使用 Scikit-LLM

• Web LLM：将 LLM 聊天机器人带到浏览器

• Mistral 7B-V0.2：用…微调 Mistral 的新开源 LLM

• 介绍 MPT-7B：一种新的开源 LLM

数据科学项目准备的神奇四侠

原文：www.kdnuggets.com/2019/07/fantastic-four-data-science-project-preparation.html

评论

经典漫画形式中，数据科学项目准备的神奇四侠最初通过在数据复仇者...集合！文章中的客串介绍。因此，如果你恰好有那篇文章，请保存好。它将来无疑会有一定的价值。

---

我们的前 3 个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 工作

---

继续前进...

在漫威漫画中，神奇四侠是一个由四人组成的集体，成员们在一次太空飞行中接触到宇宙射线后获得了超能力。里德·理查兹即神奇先生可以以非人类的方式拉伸、重塑和扭曲他的身体，是团队的领导者。苏珊·斯托姆即隐形女是里德·理查兹的妻子，拥有变得隐形的能力。约翰尼·斯托姆即人火焰是苏·斯托姆的弟弟，掌握火焰的能力，使他可以将身体吞没在火焰中，还具备飞行的力量。班·格里姆即石头人是里德·理查兹的最好的朋友，宇宙射线将他变成了一个具有超人力量的岩石般的怪物。

正如你所见——这与大多数超级英雄一样——这确实是一场家庭盛事。

就我们的目的而言，数据科学的神奇四侠包括在处理每个项目时的这些关键方面：

1. 理解问题领域和提出的问题

2. 调查数据

3. 根据需要清理、准备和转换数据

4. 从一个明确定义的框架内解决问题

正如漫威的神奇四侠致力于帮助他人，我们的四位成员帮助数据科学家以成功为目标来处理他们的项目。

让我们更详细地看看在处理每个新的数据科学项目时应该牢记的四件神奇的事物。

1. 理解问题领域和提出的问题

数据科学项目准备的第一件神奇的事是理解问题领域。拥有足够的领域知识对成功至关重要。

来源于数据科学的无限宝石：

到底什么构成了足够的领域知识？这是相对的。你是在进行某款普通约会应用的浅层描述性分析？还是在为一个专注于某些冷门证券投资策略的组织进行深入的金融预测分析项目？执行第一个任务所需的“约会”领域知识可能微不足道，但对第二个任务有用的洞察肯定需要扎实的金融理解。

除了依赖于上下文的最低水平专业知识外，你还需要了解所提出的问题。这与理解领域不同。你可能是个真正的金融系统专家，但如果你对项目中提出的问题没有把握——这些问题直接催化了你如何整体开展项目——结果充其量会平平无奇，最糟则完全无用。

将这两个理解结合起来——对领域的了解和对问题的了解——在制定下一步行动时应提供宝贵的洞察，例如：

• 我们想知道什么？

• 从数据中可以回答哪些问题，而哪些不能？

• 我们还需要知道什么，以找出我们想要知道的内容？

2. 调查数据

调查数据基本上归结为对给定项目的数据进行熟悉。探索性数据分析（EDA）是一种获取这种熟悉的方法，通常专注于从统计和视觉上总结数据集。

来源于探索性数据分析的价值：

从高层次来看，EDA 是使用视觉和定量方法来理解和总结数据集的实践，而不对其内容做出任何假设。在进入机器学习或统计建模之前，这是一个关键步骤，因为它提供了开发适当模型所需的背景，并正确解读其结果。

随着能够轻松实现强大机器学习算法的工具的兴起，跳过 EDA 可能变得很诱人。虽然人们利用这些算法是可以理解的，但简单地将数据输入黑箱并不总是一个好主意——我们一再观察到 EDA 对所有类型的数据科学问题提供的关键价值。

3. 根据需要清理、准备和转换数据

你了解领域。你知道要问的问题。你掌握了数据中的内容，以及这些内容如何映射到你想回答的问题的能力上。

现在是时候开始实际操作了，对吧？不那么快……首先，数据需要被整理、预处理、准备或以其他方式精细化，以便在预测建模或你希望进行的其他数据科学任务中有用。

来源于 7 Steps to Mastering Data Preparation for Machine Learning with Python：

我会说，在“将数据从一种‘原始’形式映射到另一种...”的背景下，“识别数据中不完整、不正确、不准确或无关的部分，然后替换、修改或删除脏数据或粗糙数据”，以及“训练统计模型”，是我认为数据准备应涵盖的，或者说是“从数据源获取到模型构建之前的一切”。

一旦数据被转化为有用的形式，就该开始实际操作了。

4. 从一个明确的框架内进行问题解决

在明确的框架内继续进行问题解决是最佳计划。

这不仅仅是关于任何单一或特定的框架；而是要确保你心中有一个合理的程序化方法，该方法是标准化、可靠且可衡量的。广为人知的正式框架示例包括知识发现数据库（KDD）过程、跨行业数据挖掘标准过程（CRISP-DM），以及 Joe Blitzstein 和 Hanspeter Pfister 的数据科学过程。你可以在 这里 阅读更多关于这些方法的信息。

一个不那么正式的方法是 Aurélien Géron 的 机器学习项目检查表，在他的书《使用 Scikit-Learn 和 TensorFlow 的动手机器学习》中进行了概述。还有两个方法是 Yufeng Guo 的 7 步机器学习和 Francois Chollet 的机器学习通用工作流，来自他的书《用 Python 深度学习》。你可以在 这里 阅读更多关于这两种方法的信息。

我在上述帖子中还概述了机器学习的简化框架，即机器学习过程的 5 个主要领域：

1. 数据收集和准备：包括从选择数据来源到数据清理和准备好进行特征选择/工程的整个过程。

2. 特征选择和特征工程：这包括从数据清理后到被输入到机器学习模型中的所有数据更改。

3. 选择机器学习算法和训练我们的第一个模型：获得一个“优于基线”的结果，并希望在此基础上进行改进。

4. 评估我们的模型：这包括度量的选择以及实际评估；虽然看起来是比其他步骤小的步骤，但对我们的最终结果至关重要。

5. 模型调整、正则化和超参数调优：在这里，我们反复从“足够好”的模型迭代到最佳效果。

那么，你应该使用哪个框架？真的有重要的区别吗？[...] 这个简化的框架是否提供了实际的好处？只要基础内容得到覆盖，并且框架重叠部分的任务得到处理，遵循 [任何一个] 模型的结果将等同于 [任何] 其他模型。你的视角或经验水平可能会对其中一个表现出偏好。

正如你可能猜到的，这实际上更多是关于探讨合理的机器学习过程 应该 是什么样的，而不是决定或对比特定框架。

所以这是我们数据科学项目准备的“神奇四侠”。我们的版本可能无法与像毁灭博士或吞星这样的超级恶棍作战，但它们在我们的分析项目成功中扮演了关键角色。希望准备的重要性已经得到强化。

文中提及的所有漫画人物和使用的图像，均为 Marvel Comics 的唯一专有财产。

相关：

• 数据复仇者……集结！

• 数据科学的无限宝石

• 机器学习难题，解析

更多相关话题

• 停止学习数据科学以找到目标，并找到目标来……

• 学习数据科学的顶级统计资源

• 成功数据科学家的 5 个特征

• 每个数据科学家都应该知道的三种 R 库（即使你使用 Python）

• 一个 90 亿美元的人工智能失败，解析

• 是什么让 Python 成为初创公司的理想编程语言

使用 FLAML + Ray Tune 进行快速 AutoML

原文：www.kdnuggets.com/2021/09/fast-automl-flaml-ray-tune.html

评论

由吴庆云、王驰、安东尼·鲍姆、理查德·廖和迈克尔·加拉尼克

FLAML是微软研究院推出的轻量级 Python 库，利用前沿算法以高效和经济的方式寻找准确的机器学习模型，这些算法旨在节省资源并易于并行化。FLAML 还可以利用Ray Tune进行分布式超参数调优，将这些 AutoML 方法扩展到集群中。

本博客重点介绍：

• 对经济高效 AutoML 方法的需求

• 经济高效的 AutoML 与 FLAML

• 如何用 Ray Tune 扩展 FLAML 的优化算法

对经济高效 AutoML 方法的需求

众所周知，AutoML 是一项资源和时间消耗大的操作，因为它涉及通过试错找到性能良好的超参数配置。由于可能的配置值空间通常非常大，因此需要一种经济高效的 AutoML 方法来更有效地进行搜索。

AutoML 中超参数搜索的高资源和时间消耗归结为以下两个因素：

1. 需要大量候选超参数配置（试验）来找到性能良好的配置

2. 每个超参数的高‘评估’成本，因为评估涉及使用给定的训练数据训练和验证机器学习模型。

为了解决这两个因素，微软研究人员开发了FLAML（快速轻量级 AutoML）。

什么是 FLAML？

FLAML 是一个新发布的库，包含最先进的超参数优化算法。FLAML 利用搜索空间的结构，同时优化成本和模型性能。它包含微软研究院开发的两种新方法：

• 成本节俭优化（CFO）

• BlendSearch

成本节俭优化（CFO）是一种以成本感知方式进行搜索过程的方法。搜索方法从低成本初始点开始，逐渐向高成本区域移动，同时优化给定的目标（如模型损失或准确率）。

Blendsearch 是 CFO 的扩展，结合了 CFO 的节俭性和贝叶斯优化的探索能力。像 CFO 一样，BlendSearch 需要一个低成本的初始点作为输入（如果存在），并从那里开始搜索。然而，与 CFO 不同的是，BlendSearch 不会等待局部搜索完全收敛后再尝试新的起始点。

FLAML 中的经济 HPO 方法灵感来源于两个关键见解：

1. 许多机器学习算法有超参数会导致训练成本的大幅变化。例如，10 棵树的 XGBoost 模型比 1000 棵树的模型训练速度要快得多。

2. 参数的“成本”通常是‘连续且一致的’——评估树=10 的成本低于评估树=100，而评估树=100 的成本又低于评估树=500。

这些见解一起提供了关于成本空间中超参数的有用结构信息。这些方法，即 CFO 和 BlendSearch，能够有效利用这些见解来减少沿途产生的成本，而不会影响到达最优解的收敛。

FLAML 有效吗？

在最新的AutoML 基准中，FLAML能够在 62%以上的任务中，仅使用 10%的计算资源，实现与最先进 AutoML 解决方案相同或更好的性能。

FLAML 的性能归功于其经济优化方法。新的 HPO 方法（CFO、BlendSearch）利用搜索空间的结构来选择优化的搜索顺序，以兼顾良好的性能和低成本。这在预算限制下可以显著提高搜索效率。

图 1 显示了从 FLAML 和最先进的超参数调整库Optuna中获得的典型结果，用于调整 9 维超参数的 LightGBM。你可以看到 FLAML 在更短的时间内能够获得更好的解决方案。

图 1. 在classification dataset上调整 LightGBM 的验证损失（1-auc）曲线。线条和阴影区域显示了 10 次运行中验证损失的均值和标准差。该图中的结果是从使用 1 个 CPU 而不进行并行计算的实验中获得的（图像由作者提供）。

以下代码示例展示了如何用仅几行代码开始使用 FLAML（假设训练数据集已经提供并保存为X_train、y_train）。任务是在 60 秒的时间预算内调整 LightGBM 模型的超参数。

**from** flaml **import** AutoML
automl = AutoML()
automl.fit(X_train=X_train, y_train=y_train, time_budget=60, estimator_list=['lgbm'])

''' retrieve best model and best configuration found'''
print('Best ML model:', automl.model)
print('Best hyperparameter config:', automl.best_config)

在这个示例中，我们在 LightGBM 的默认搜索空间上进行搜索，该搜索空间已经在 FLAML 中提供。FLAML 提供了丰富的定制选项，涉及到关注的任务，例如学习器类、搜索空间、评估指标等。

一个演示示例

现在我们使用一个示例来展示 CFO 在调整 XGBoost 的两个超参数（树的数量和叶子的数量）时的成本节约行为。

'''create an XGBoost learner class with a customized search space'''
**from** flaml.model **import** XGBoostSklearnEstimator
**from** flaml **import** tune

**class** **MyXGB**(XGBoostSklearnEstimator):
​​    '''XGBoostSklearnEstimator with a customized search space'''
    @classmethod
    **def** **search_space**(cls, data_size, **params):
        upper = min(2**15, int(data_size))
        **return** {
            'n_estimators': {
                'domain': tune.lograndint(lower=4, upper=upper),
                'low_cost_init_value': 4,
            },
            'max_leaves': {
                'domain': tune.lograndint(lower=4, upper=upper),
                'low_cost_init_value': 4,
            },
        }

'''Use CFO in FLAML to tune XGBoost'''
**from** flaml **import** AutoML
automl = AutoML()
automl.add_learner(learner_name='my_xgboost', learner_class=MyXGB)
automl.fit(X_train=X_train, y_train=y_train, time_budget=15, estimator_list=['my_xgboost'], hpo_method='cfo')

CFO 和 BlendSearch 的工作原理

以下两个 GIF 分别展示了 CFO 在损失和评估成本（即评估时间）空间中的搜索轨迹。CFO 从一个低成本的初始点（通过low_cost_init_value在搜索空间中指定）开始，并根据其随机化的局部搜索策略执行局部更新。采用这种策略，CFO 可以快速向低损失区域移动，显示出良好的收敛特性。此外，CFO 倾向于避免探索高成本区域，直到必要时才会进行。这种搜索策略通过一个可证明的收敛速率和期望的有界成本进一步得到支持。

图 2 展示了 CFO 在调整 XGBoost 的叶子数和树数时的表现。两个热力图显示了所有配置的损失和成本分布。黑点是 CFO 评估的点，黑点通过线连接表示评估时产生更好损失表现的点（图像由作者提供）。

BlendSearch 进一步将 CFO 使用的局部搜索策略与全局搜索结合。它利用 CFO 的节俭性和全局搜索方法（如贝叶斯优化）的空间探索能力。具体来说，BlendSearch 维护一个全局搜索模型，并根据全局模型提出的超参数配置逐渐创建局部搜索线程。它根据实时性能和成本优先考虑全局搜索线程和多个局部搜索线程。这可以进一步提高 CFO 在复杂搜索空间任务中的效率，例如包含多个不连续子空间的搜索空间。

FLAML 与贝叶斯优化性能

图 3 展示了 FLAML 中经济型 HPO 方法（在此图中 CFO 标记为LS）与用于调整具有 11 个超参数的 XGBoost 的贝叶斯优化（BO）方法的典型行为。

从图 3(a)中，我们观察到 BO 提出的配置的评估时间可能非常长。当总资源有限时，例如 1 个 cpu 小时（或更少），BO 无法给出令人满意的结果（图 3(b)）。

FLAML 的 CFO（标记为 LS）和 BlendSearch 在快速找到良好配置方面具有明显优势：它们能够集中于评估时间较短的配置，同时导航于表现良好的配置，即低损失。

图 3. (a) 是不同方法提出的超参数配置的散点图，x 轴和 y 轴分别为评估时间和损失。超参数配置的评估时间是指在训练数据上训练机器学习模型并在验证数据集上验证其性能所花费的时间。损失是验证损失。 (b) 展示了不同方法在墙钟时间上的最佳损失。 (image source)

如何通过 Ray Tune 的分布式调优扩展 CFO 和 BlendSearch

为了加速超参数优化，你可能需要并行化你的超参数搜索。例如，BlendSearch 能够在并行设置中良好运行：它利用多个搜索线程，这些线程可以独立执行而性能不会明显下降。这种理想的属性在现有优化算法（如贝叶斯优化）中并不总是成立。

为了实现并行化，FLAML 与 Ray Tune 集成。Ray Tune 是一个 Python 库，通过允许你利用最前沿的优化算法来加速超参数调优。Ray Tune 还允许你将超参数搜索从你的笔记本电脑扩展到集群，而无需更改代码。你可以在 FLAML 中使用 Ray Tune，或在 Ray Tune 中运行 FLAML 的超参数搜索方法以并行化你的搜索。以下代码示例展示了前一种用法，只需通过配置 n_concurrent_trials 参数即可实现。

'''Use BlendSearch for hyperparameter search, and Ray Tune for parallelizing concurrent trials (when n_concurrent_trials > 1) in FLAML to tune XGBoost'''
**from** flaml **import** AutoML
automl = AutoML()
automl.add_learner(learner_name='my_xgboost', learner_class=MyXGB)
automl.fit(X_train=X_train, y_train=y_train, time_budget=15, estimator_list=['my_xgboost'], hpo_method='bs', n_concurrent_trials=8)

Logo 来源 (XGBoost、FLAML、Ray Tune)

下面的代码展示了后者用法，即如何在 Ray Tune 中使用 BlendSearch 的端到端示例。

**from** ray **import** tune 
**from** flaml **import** CFO, BlendSearch
**import** time

**def** **training_func**(config):
    '''evaluate a hyperparameter configuration'''
    # we use a toy example with 2 hyperparameters
    metric = (round(config['x'])-85000)**2 - config['x']/config['y']

    # usually the evaluation takes a non-neglible cost
    # and the cost could be related to certain hyperparameters
    # in this example, we assume it's proportional to x
    time.sleep(config['x']/100000)
    # use tune.report to report the metric to optimize    
    tune.report(metric=metric) 

# provide the search space
search_space = {
        'x': tune.lograndint(lower=1, upper=100000),
        'y': tune.randint(lower=1, upper=100000)
    }

# provide the low cost partial config
low_cost_partial_config={'x':1}

# set up BlendSearch
blendsearch = BlendSearch(
    metric="metric", mode="min",
    space=search_space,
    low_cost_partial_config=low_cost_partial_config)

blendsearch.set_search_properties(config={"time_budget_s": 60})

analysis = tune.run(
    training_func,    # the function to evaluate a config
    config=search_space,
    metric='metric',    # the name of the metric used for optimization
    mode='min',         # the optimization mode, 'min' or 'max'
    num_samples=-1,    # the maximal number of configs to try, -1 means infinite
    time_budget_s=60,   # the time budget in seconds
    local_dir='logs/',  # the local directory to store logs
    search_alg=blendsearch  # or cfo
    )

print(analysis.best_trial.last_result)  # the best trial's result
print(analysis.best_config)  # the best config

其他关键的 Ray Tune 功能包括：

• 自动集成实验跟踪工具，如 Tensorboard 和 Weights/Biases

• 支持 GPU

• 提前停止

• 一个 scikit-learn API 以便轻松集成 XGBoost、LightGBM、Scikit-Learn 等。

基准测试结果

我们进行了一项实验，以检查 BlendSearch 在高度并行化设置中与 Optuna（使用多变量 TPE 采样器）和随机搜索的对比。我们使用了来自 AutoML Benchmark 的 12 个数据集的子集。每次优化运行使用 16 个并行试验进行 20 分钟，采用 3 折交叉验证，使用 ROC-AUC（针对多类数据集的加权一对多）。这些运行重复三次，使用不同的随机种子。重现代码可以在 这里 找到。

图片由作者提供

BlendSearch 在 12 个数据集中的 6 个上实现了最佳交叉验证得分。此外，BlendSearch 相比随机搜索平均提高了 2.52%，而 Optuna 则为 1.96%。值得注意的是，BlendSearch 使用了单变量的 Optuna-TPE 作为全局搜索器——使用多变量 TPE 很可能进一步提高得分。

图片由作者提供

此外，由于其节省成本的方式，BlendSearch 平均在相同时间限制内评估的试验次数是其他搜索器的两倍。这表明，随着时间预算的增加，BlendSearch 与其他算法之间的差距将会扩大。

结论

FLAML 是一个新发布的库，包含了 最先进的 超参数优化算法，利用搜索空间的结构同时优化成本和模型性能。FLAML 还可以利用 Ray Tune 进行分布式超参数调优，以在集群中扩展这些经济高效的 AutoML 方法。

有关 FLAML 的更多信息，请参见 GitHub 仓库 和 项目页面。如果你想及时了解 Ray 的一切，请考虑 关注 @raydistributed 的 Twitter 并 订阅新闻通讯。

原文。转载已获许可。

相关：

• TPOT 机器学习管道优化

• 二分类自动机器学习

• Hugging Face AutoNLP 概述及示例项目

---

我们的前三课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你所在组织的 IT

---

更多相关话题

• 如何微调 ChatGPT 3.5 Turbo

• 如何使用 Hugging Face AutoTrain 微调 LLMs

• 如何使用 Hugging Face Transformers 对 BERT 进行情感分析的微调

• BERT 在稀疏化条件下能达到多快？

• 通过快速克里金（FKR）加速机器学习

• 如何让 Python 代码运行得惊人迅速

BERT在稀疏性下能有多快？

原文：www.kdnuggets.com/2022/04/fast-bert-go-sparsity.html

这里有一个小秘密

如果你想分析 19 个稀疏 BERT 模型的推理速度，你只需一个 YAML 文件和 16GB 的 RAM 即可。剧透警告：

… 它们在 CPU 上运行。

… 而且它们超级快！

Neural Magic 最新的DeepSparse库中的功能是 DeepSparse Server！本文的目的是展示如何无缝服务多达 19 个稀疏 BERT 模型，以及稀疏性对模型性能的影响。简要背景，稀疏化是指在训练好的深度学习模型中去除冗余信息，从而得到一个更快、更小的模型。对于本次演示，我们将使用各种 BERT 模型并加载它们进行推理，以展示准确性与速度之间的权衡。

DeepSparse Server 建立在我们的 DeepSparse Engine 和流行的 FastAPI 网络框架之上，允许任何人在 CPU 上以 GPU 级别的速度部署稀疏模型！通过 DeepSparse Engine，我们可以集成到流行的深度学习库中（如 Hugging Face、Ultralytics），使你能够使用 ONNX 部署稀疏模型。

如前所述，运行模型所需的所有配置只需要一个 YAML 文件和少量内存（多亏了稀疏性）。要快速开始服务四个在问答任务上训练的 BERT 模型，这就是配置 YAML 文件的样子：

config.yaml

如果你想大规模加载所有 19 个 Neural Magic 稀疏 BERT 模型：配置文件将是这样的??：

为了方便使用，我们在 Streamlit 上构建了一个演示，以便任何人都可以演示服务器和用于 NLP 问答任务的模型。为了同时测试 19 个模型，该应用程序在 Google Cloud Platform 上的虚拟机上进行了测试。

为了让你了解我在测试中使用的计算方法，这里是一些详细信息：

Specs:
  - Cloud Vendor: Google Cloud Platform
  - Instance:     c2-standard-4
  - CPU Type:     Intel Cascade Lake
  - Num of vCPUs: four
  - RAM:          16GB

请记住，在相同的计算约束下，裸金属机器实际上会表现得更快。然而，由于模型已经非常快，我觉得通过虚拟化展示它们的速度是可以的。

我们不仅强烈鼓励你在虚拟机上运行相同的测试来基准测试性能，还因为你需要足够的 RAM 来加载所有 19 个 BERT，否则你会遇到这个??：

如果你希望在本地机器上快速启动而无需担心内存不足的问题，你应该尝试只加载几个模型到内存中。以下代码将演示如何使用 4 个模型来完成这个操作（尽管大多数稀疏模型非常轻便，你也可以根据需要添加更多）。

使用 SparseServer.UI 入门

我们将应用程序分成了独立的服务器和客户端目录。服务器目录包含用于加载模型的 YAML 文件，而客户端目录则包含 Streamlit 应用的逻辑：

~sparseserver-ui/
         |__client/
            |__app.py
            |__pipelineclient.py
            |__samples.py
            |__settings.py     
         |__server/
            |__big-config.yaml
            |__config.yaml
         |__requirements.txt
         |__README.md

1. 克隆 DeepSparse 仓库：

>>> git clone [`github.com/neuralmagic/deepsparse.git`](https://github.com/neuralmagic/deepsparse.git)

2. 安装 DeepSparse 服务器和 Streamlit：

>>> cd deepsparse/examples/sparseserver-ui>>> pip install -r requirements.txt

在运行服务器之前，你可以在我们的启动 CLI 命令中配置host和port参数。如果你选择使用默认设置，它将会在localhost上运行服务器，并使用端口5543。有关 CLI 参数的更多信息，请运行：

>>> deepsparse.server --help

3. 运行 DeepSparse 服务器：

好的！现在是时候服务config.yaml中定义的所有模型了。这个 YAML 文件将从 Neural Magic 的SparseZoo下载四个模型??。

>>> deepsparse.server --config_file server/config.yaml

下载模型并且服务器运行后，打开第二个终端来测试客户端。

如果你在第一次运行服务器时修改了host和port配置，请在pipelineclient.py模块中也相应调整这些变量。

4. 运行 Streamlit 客户端：

>>> streamlit run client/app.py --browser.serverAddress="localhost"

就这样！点击终端中的 URL，你就可以开始与演示进行交互了。你可以从列表中选择示例，或者添加你自己的上下文和问题。

未来，我们将扩展 NLP 任务的范围，不仅仅局限于问答，以便你能在稀疏性上获得更广泛的性能。

完整代码：查看SparseServer.UI…

…并且不要忘记给 DeepSparse 仓库一个 GitHub ⭐！

Ricky Costa 专注于Neural Magic的用户界面。

原文。经许可转载。

---

我们的三大推荐课程

1. 谷歌网络安全证书 - 快速开启网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织进行 IT 管理

---

更多相关内容

• 使用 HuggingFace 对 BERT 进行推文分类的微调

• 使用 BERT 对长文本进行分类

• 8 篇改变了 NLP 领域的创新性 BERT 知识蒸馏论文

• 比较自然语言处理技术：RNN、Transformers、BERT

• 使用 BERT 进行抽取式总结

• 如何使用 Hugging Face Transformers 对 BERT 进行情感分析的微调

快速有效地审计机器学习的公平性

原文：www.kdnuggets.com/2023/01/fast-effective-way-audit-ml-fairness.html

Ruth Bader Ginsburg 对我们法院中潜在偏见难以揭示的看法 (1)

介绍

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业的快车道。

2. 谷歌数据分析专业证书 - 提升您的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持您的组织进行 IT 工作

---

恶名昭彰的 RBG 说得对。在我们的法律系统中，很难触及潜在的偏见。然而，与最高法院不同，我们数据科学家拥有新的开源工具包，可以轻松审计我们的机器学习模型的偏见和公平性。如果 Waylan Jennings 和 Willie Nelson 今天能重新来过，我想他们著名的二重唱可能会是这样：

♪妈妈们，不要让你们的孩子长大后成为最高法院法官♪

♪让他们成为分析师和数据科学家之类的人吧♪

♪没有 Python 库能使法律更公平♪

♪所以成为数据科学家比在外面做法官要容易♪ (2)

Aequitas 公平性和偏见工具包（3）是这些 Python 库的一个例子。我决定使用最受欢迎的数据集之一对其进行测试。你可能已经对 泰坦尼克号 数据很熟悉，这些数据用于 Kaggle 初学者教程。这个挑战是预测泰坦尼克号乘客的生存情况。我使用这些数据构建了一个简单的随机森林分类器模型，并将其输入到 Aequitas 工具包中。

仅仅添加了九行额外代码后，我准备查看我的初始模型对儿童是否公平。我对结果感到震惊。我的初始模型讨厌儿童。 它在预测成年人会生存时相当准确。但在预测儿童会生存时错误的可能性是成人的 2.9 倍。在数据科学的统计术语中，儿童的假阳性率是成人的 2.9 倍。这是一个显著的公平性差距。更糟的是，我的初始模型在预测生存时还对女性和低社会经济阶层的乘客不利。

文章概要

你知道你的机器学习模型是否公平吗？如果不知道，你应该了解！本文将演示如何使用开源工具包 Aequitas 轻松审计任何监督学习模型的公平性。我们还将讨论改进模型公平性这一更具挑战性的任务。

本项目使用 Python 编码，并在 Google Colaboratory 上进行。完整的代码库可以在我的Titanic-Fairness GitHub 页面上找到。以下是高级别的工作流程：

分析工作流程

步骤 1：格式化输入数据

让我们从最后开始。一旦模型构建工作完成，我们就需要将输入数据框格式化为 Aequitas 工具包所需的格式。输入数据框必须包含标记为‘score’和‘label_value’的列，以及至少一个用于衡量公平性的属性。下面是我们格式化后随机森林模型的输入表格。

初步泰坦尼克生存机器学习模型格式化为 Aequitas 输入数据

我们模型的‘score’列中的预测是二元的，表示生存（1）或未生存（0）。‘score’值也可以是介于 0 和 1 之间的概率，如逻辑回归模型。在这种情况下，必须定义阈值，如配置文档中所述。

我们使用原始数据集中的‘age’来创建一个分类属性，将每个乘客分为‘Adult’或‘Child’。Aequitas 也接受连续数据。如果我们提供‘age’作为连续变量（如原始数据集中所示），则 Aequitas 会自动根据四分位数将其转换为四个类别。

步骤 2：定义模型公平性

定义公平性是困难的。公平性和偏见的度量标准有很多种。此外，视角通常取决于其来源的子群体。我们如何决定关注什么？Aequitas 团队提供了一个公平性决策树可以帮助解决这个问题。它围绕理解相关干预措施的辅助性或惩罚性影响建立。Fairlearn 是另一个工具包。Fairlearn 文档提供了执行公平性评估的优秀框架。

公平性依赖于用例的具体情况。因此，我们需要为 Kaggle Titanic 数据集定义一个虚构的用例。为此，请暂时脱离现实，回到过去，设想在 1873 年大西洋号、1909 年共和国号和 1912 年泰坦尼克号沉没之后，白星航运公司咨询了我们。我们需要建立一个模型来预测在未来海上发生重大灾难时的生存情况。我们将为每个潜在乘客提供预测，HMHS Britannic是公司的第三艘也是最后一艘奥林匹克级蒸汽船。

1914 年的大西洋明信片（4）

思考我们虚构的案例示例，当我们错误预测某个潜在乘客的生存情况时，我们的模型是惩罚性的。如果大西洋号在海上发生事故，他们可能会过度自信。这种模型错误是一种假阳性。

现在让我们考虑乘客的人口统计数据。我们的数据集包括性别、年龄和社会经济等级的标签。我们将评估每个组的公平性。但首先以儿童作为我们的主要公平性目标。

现在我们需要将我们的目标转化为与 Aequitas 兼容的术语。我们可以将模型公平性目标定义为最小化儿童与成人（参考组）之间的假阳性率（fpr）差异。差异仅仅是儿童假阳性率与参考组的比例。我们还将定义一个政策容忍度，即不同组之间的差异不超过 30%。

第 3 步：使用 Aequitas 工具包

最终我们回到起点。要开始审计，我们需要安装 Aequitas，导入必要的库，并初始化 Aequitas 类。以下是执行这些操作的 Python 代码：

安装 Aequitas 并初始化

Group( )类用于保存每个子组的混淆矩阵计算和相关指标，例如每个子组的假阳性计数、真阳性计数、组大小等。而 Bias( )类用于保存组间差异计算，例如儿童的假阳性率与参考组（成人）的假阳性率的比例。

接下来，我们指定要审计‘Age_Level’属性，并使用‘Adult’作为参考组。这是一个 Python 字典，可能包含多个条目。

指定‘Age_Level’作为评估公平性的属性

要指定的最后两项是我们希望可视化的指标和我们对差异的容忍度。我们对假阳性率（fpr）感兴趣。容忍度作为可视化中的参考值使用。

指定公平性指标和容忍度

现在我们使用先前格式化的输入数据框（dfAequitas）调用 get_crosstabs()方法，并将属性列设置为我们定义的 attributes_to_audit 列表。第二行使用 get_disparity_predefined_groups()方法创建我们的偏见数据框（bdf）。第三行使用 Aequitas 图（ap）绘制差异指标。

Aequitas 差异可视化与光标悬停

立刻我们看到儿童子组的指标在红色区域，超出了我们 30%的差异容忍度。只需六行代码进行设置/配置，再加三行代码创建图表，我们就能清晰地看到我们的模型如何与公平性目标对比。点击该组会显示测试数据中有 36 名儿童的假阳性率（fpr）为 17%。这比参考组高 2.88 倍。参考组的弹出窗口显示 187 名成人的假阳性率为 6%。

步骤 4：减轻模型偏见

改善模型公平性可能比识别模型偏见更具挑战性。但关于这一主题的严肃研究正在不断增加。以下是一个表格，改编自 Aequitas 文档，总结了如何改善模型公平性。

改编自 Aequitas 文档（5,6）

在改进输入数据时，一个常见的错误是认为如果模型没有年龄、种族、性别或其他人口统计数据，它就不会有偏见。这是一种谬论。‘无知中没有公平。一个人口统计盲模型仍然可能歧视。’（7）在移除模型中的敏感属性时，不要忽视其影响。这将使审计公平性的能力受到限制，并可能加重偏见。

有一些工具包可以帮助减轻机器学习模型中的偏见。两个最著名的工具包是 IBM 的AI Fairness 360和微软的Fairlearn。这些都是健壮且文档齐全的开源工具包。在使用时，要注意模型性能的权衡。

对于我们的示例，我们将通过在模型选择中使用公平性指标来缓解偏见。因此，我们在寻求公平性的过程中构建了几个分类模型。下表总结了每个候选模型的指标。请记住，我们的初始模型是随机森林分类模型。

儿童与成年人分类模型公平性指标

这是满足我们公平性目标的 30%阈值 XGBoost 模型的 Aequitas 图。

30%阈值的 XGBoost 模型满足了我们的公平性目标

成功了吗？这一组儿童已经脱离了红色阴影区域。但这真的是最好的模型吗？让我们比较两个 XGBoost 模型。这些模型都预测从 0 到 100%的生存连续概率。然后使用阈值将概率转换为生存的 1 或不生存的 0。默认值是 50%。当我们将阈值降低到 30%时，模型预测更多乘客将幸存。例如，一个生存概率为 35%的乘客符合新的阈值，预测结果现在为‘生存’。这也会产生更多的假阳性错误。在我们的测试数据中，将阈值移到 30%会在包含成年人较大的参考组中增加 13 个假阳性，在儿童组中仅增加 1 个假阳性。这使得它们接近平衡。

因此，30%的 XGBoost 模型以不太理想的方式达到了我们的公平性目标。我们没有提高受保护组的模型表现，而是降低了参考组的表现，以实现容忍范围内的平衡。这并不是一个理想的解决方案，但它代表了现实世界用例中的困难权衡。

附加部分 - 更多 Aequitas 可视化示例

差异容忍度图只是内置 Aequitas 可视化的一个示例。本节将演示其他选项。以下所有数据都与我们的初始随机森林模型相关。生成每个示例的代码也包含在我的 Titanic-Fairness GitHub 页面上。

第一个示例是所有属性的假阳性率差异的树图。

所有属性假阳性率差异的树图

每个组的相对大小由面积提供。颜色越深，差异越大。棕色表示假阳性率高于参考组，青色表示低于参考组。参考组自动选择为最大的人口组。因此，上述图表从左到右的解释为：

• 儿童的假阳性率远高于成年人，

• 上层乘客的假阳性率远低于下层乘客，以及

• 女性的假阳性率远高于男性。

更简洁地说，树状图表明我们的初始模型对儿童、低收入乘客和女性不公平。下一个图显示了类似的信息，但以更传统的柱状图形式展示。然而，在这个例子中，我们看到的是绝对假阳性率，而不是与参考组的差异（或比例）。

跨所有属性的假阳性率绝对值柱状图

这个柱状图指出了一个大问题，即女性的假阳性率为 42%。我们可以为以下任何指标生成类似的柱状图：

• 预测正组率差异 (pprev)，

• 预测正率差异 (ppr)，

• 假发现率 (fdr)，

• 假漏率 (for)，

• 假阳性率 (fpr)，以及

• 假阴性率 (fnr)。

最后，还有一些方法可以打印图表中使用的原始数据。下面是初始随机森林模型中每组的基本计数示例。

按组别的混淆矩阵原始计数表

如上所述，有 3 名儿童被错误预测为生还者，共有 18 名被预测生还者。3 除以 18 得到 17%的假阳性率。下表提供了这些指标的百分比。在下表中，请注意儿童的假阳性率为 17%，这是预期的。

按组别的混淆矩阵百分比表示表

儿童的假阳性率与成人的比率为 2.88，计算方法是将 0.167 除以 0.0579。这是儿童相对于参考组的差异。Aequitas 提供了一种直接打印所有差异值的方法。

按组别的混淆矩阵原始计数表

结论

公平性在机器学习中的重要性在公共政策或信用决策领域中是不言而喻的。即使不从事这些领域，将公平性审计纳入基础机器学习工作流程也是有意义的。例如，了解你的模型是否对你的最大、最盈利或最长时间的客户不利可能是有用的。公平性审计很容易进行，并将提供你模型表现过度或不足的领域的见解。

最后的建议：公平审计也应纳入尽职调查工作中。如果收购一家拥有机器学习模型的公司，则执行公平审计。所需的只是包含这些模型预测和属性标签的测试数据。这有助于理解模型可能对特定群体产生歧视的风险，这可能导致法律问题或声誉损害。

参考

1. Waylon Jennings & Willie Nelson 的原歌词恶搞

2. Britannic 明信片图像来自公共领域网站 wikimedia，最初由 Frederic Logghe 在 ibiblio.org 上发布。链接: commons.wikimedia.org/wiki/File:Britannic_postcard.jpg

3. Pedro Saleiro, Benedict Kuester, Loren Hinkson, Jesse London, Abby Stevens, Ari Anisfeld, Kit T. Rodolfa, Rayid Ghani，‘Aequitas：一个偏见和公平性审计工具包’ 链接: arxiv.org/abs/1811.05577

4. Britannic 明信片图像来自公共领域网站 wikimedia，最初由 Frederic Logghe 在 ibiblio.org 上发布。链接: commons.wikimedia.org/wiki/File:Britannic_postcard.jpg

5. Muhammad Bilal Zafar, Isabel Valera, Manuel Gomez Rodriguez, Krishna P. Gummadi，‘公平性约束：公平分类的机制’ 链接: proceedings.mlr.press/v54/zafar17a/zafar17a.pdf

6. Hardt, Moritz 和 Price, Eric 以及 Srebro, Nathan，‘监督学习中的机会平等’ 链接: arxiv.org/abs/1610.02413

7. Rayid Ghani, Kit T Rodolfa, Pedro Saleiro，‘处理 AI/ML/数据科学系统中的偏见和公平性’ 幻灯片 65。链接: dssg.github.io/aequitas/examples/compas_demo.html#Putting-Aequitas-to-the-task

Matt Semrad 是一位拥有 20 多年经验的分析领导者，专注于在高速增长的技术公司中建立组织能力。

更多相关话题

• 关于值得信赖的图神经网络的全面调查：…

• 机器学习项目的简单快速数据流

• BERT 在稀疏性下能多快？

• 通过快速克里金法 (FKR) 加速机器学习

• 如何让 Python 代码运行得飞快

• 提升你的 Python 技能，使用《数据科学快速 Python》！

使用 CatBoost 进行快速梯度提升

原文：www.kdnuggets.com/2020/10/fast-gradient-boosting-catboost.html

评论

在梯度提升中，预测是通过一组弱学习器进行的。与为每个样本创建决策树的随机森林不同，梯度提升中树是一个接一个地创建的。模型中的前一棵树不会被更改。前一棵树的结果用于改进下一棵树。在本文中，我们将更详细地了解一种称为 CatBoost 的梯度提升库。

来源

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

CatBoost 是由 Yandex 开发的深度梯度提升库。它使用无感知决策树来生成平衡树。在树的每一层中，使用相同的特征来进行左右分裂。

来源

与经典树相比，无感知树在 CPU 上的实现更高效，且更容易拟合。

处理分类特征

机器学习中处理分类变量的常见方法是独热编码和标签编码。CatBoost 允许你使用分类特征而无需预处理。

使用 CatBoost 时，我们不应使用独热编码，因为这会影响训练速度以及预测质量。相反，我们只需使用 cat_features 参数来指定分类特征。

使用 CatBoost 的优点

下面是考虑使用 CatBoost 的几个理由：

• CatBoost 允许在多个 GPU 上进行数据训练。

• 使用默认参数可以获得很好的结果，从而减少了参数调整所需的时间。

• 由于过拟合减少，精度得到提高。

• 使用 CatBoost 的模型应用程序进行快速预测。

• 训练好的 CatBoost 模型可以导出到 Core ML 以进行设备端推断（iOS）。

• 可以内部处理缺失值。

• 可以用于回归和分类问题。

训练参数

让我们来看看 CatBoost 中的常见参数：

• loss_function 别名 objective — 用于训练的指标。这些是回归指标，例如回归的均方根误差和分类的对数损失。

• eval_metric — 用于检测过拟合的指标。

• iterations — 要构建的最大树数量，默认为 1000。别名有 num_boost_round、n_estimators 和 num_trees。

• learning_rate 别名 eta — 确定模型学习速度的学习率。默认值通常为 0.03。

• random_seed 别名 random_state — 用于训练的随机种子。

• l2_leaf_reg 别名 reg_lambda — 成本函数 L2 正则化项的系数。默认值为 3.0。

• bootstrap_type — 确定对象权重的抽样方法，例如贝叶斯（Bayesian）、伯努利（Bernoulli）、MVS 和泊松（Poisson）。

• depth — 树的深度。

• grow_policy — 决定贪婪搜索算法的应用方式。可以是 SymmetricTree、Depthwise 或 Lossguide。SymmetricTree 是默认值。在 SymmetricTree 中，树按层构建，直到达到指定深度。在每一步中，上一棵树的叶子按照相同条件进行分裂。选择 Depthwise 时，树一步步构建，直到达到指定深度。在每一步中，最后一棵树层的所有非终端叶子都进行分裂。叶子按照最优损失改进条件进行分裂。在 Lossguide 中，树逐步构建叶子，直到达到指定数量。在每一步中，最佳损失改进的非终端叶子被分裂。

• min_data_in_leaf 别名 min_child_samples — 叶子中最小的训练样本数。该参数仅与 Lossguide 和 Depthwise 增长策略一起使用。

• max_leaves 别名 num_leaves — 该参数仅与 Lossguide 策略一起使用，决定树中的叶子数量。

• ignored_features — 指示在训练过程中应忽略的特征。

• nan_mode — 处理缺失值的方法。选项有 Forbidden、Min 和 Max。默认值为 Min。使用 Forbidden 时，缺失值的存在会导致错误。使用 Min 时，缺失值被视为该特征的最小值。在 Max 中，缺失值被视为该特征的最大值。

• leaf_estimation_method — 用于计算叶子值的方法。在分类中，使用 10 次 Newton 迭代。回归问题使用分位数或 MAE 损失则使用一次 Exact 迭代。多分类使用一次 Newton 迭代。

• leaf_estimation_backtracking — 在梯度下降过程中使用的回溯类型。默认值是 AnyImprovement。AnyImprovement 减少下降步长，直到损失函数值小于上次迭代中的值。Armijo 减少下降步长，直到满足 Armijo 条件。

• boosting_type — 提升方案。可以是 plain，用于经典的梯度提升方案，或者 ordered，它在较小的数据集上提供更好的质量。

• score_function — 用于选择树构建过程中下一个分裂的 评分类型。Cosine 是默认选项。其他可用选项包括 L2、NewtonL2 和 NewtonCosine。

• early_stopping_rounds — 当设置为 True 时，将过拟合检测器类型设置为 Iter 并在达到最佳指标时停止训练。

• classes_count — 多分类问题中的类别数。

• task_type — 指示你是使用 CPU 还是 GPU。CPU 是默认选项。

• devices — 用于训练的 GPU 设备的 ID。

• cat_features — 包含分类列的数组。

• text_features — 用于声明分类问题中的文本列。

回归示例

CatBoost 在实现中使用了 scikit-learn 标准。让我们看看如何使用它进行回归分析。

第一步——像往常一样——是导入回归器并实例化它。

from catboost import CatBoostRegressor
cat = CatBoostRegressor()

在拟合模型时，CatBoost 还允许我们通过设置 plot=true 进行可视化：

cat.fit(X_train,y_train,verbose=False, plot=True)

它还允许你执行交叉验证并可视化过程：

同样，你也可以执行网格搜索并进行可视化：

我们还可以使用 CatBoost 绘制树。这里的图是第一棵树的绘图。正如你从树中看到的，每一层的叶子都在相同条件下进行分裂——例如 297，值 >0.5。

cat.plot_tree(tree_idx=0)

CatBoost 还为我们提供了一个包含所有模型参数的字典。我们可以通过遍历字典来打印它们。

for key,value in cat.get_all_params().items():
 print(‘{}, {}’.format(key,value))

最终想法

在这篇文章中，我们探讨了 CatBoost 的优缺点及其主要训练参数。然后，我们通过 scikit-learn 完成了一个简单的回归实现。希望这能为你提供足够的信息，以便你可以进一步探索该库。

CatBoost - 最先进的开源梯度提升库，支持类别特征

CatBoost 是一种决策树上的梯度提升算法。它由 Yandex 的研究人员和工程师开发...

Python 数据科学训练营

学习 Python 数据科学、NumPy、Pandas、Matplotlib、Seaborn、Scikit-learn、Dask、LightGBM、XGBoost、CatBoost 等等…

简介：Derrick Mwiti 是数据分析师、作家和导师。他致力于在每个任务中提供出色的成果，并且是 Lapid Leaders Africa 的导师。

原文。经许可转载。

相关：

• LightGBM：高效的梯度提升决策树

• 理解梯度提升机

• 在 Google Colaboratory 上使用免费 GPU 掌握快速梯度提升

相关主题

• CatBoost ML 为您的数据带来的 5 大优势，让数据更“喵”

• 提升机器学习算法：概述

• 掌握季节性和提升商业结果的终极指南

• BERT 在稀疏性下能有多快？

• 通过快速克里金（FKR）加速机器学习

• 如何让 Python 代码运行得非常快

使用 Pomegranate 进行快速而直观的统计建模

原文：www.kdnuggets.com/2020/12/fast-intuitive-statistical-modeling-pomegranate.html

评论

什么是 Pomegranate？

首先，它是一种美味的水果。

图像来源：Pixabay（可商用）

但对于喜爱水果的数据科学家来说，还有双重的惊喜！

这也是一个 Python 包，实现了从单一概率分布到如 贝叶斯网络 和 隐马尔可夫模型 等组合模型的快速灵活的概率模型。

这个包的核心思想是 所有概率模型都可以视为一个概率分布。 这意味着它们都为样本提供概率估计，并且可以根据样本及其相关权重进行更新/拟合。这个认识的主要后果是，实施的类可以比其他常见包提供的类更灵活地堆叠和链式连接。

与 Scipy 或 Numpy 有何不同？

这是个公平的问题。然而，你会发现 Pomegranate 包中的实现类非常直观，尽管它们涵盖了广泛的统计建模方面，但接口却很统一。

• 常见分布

• 马尔可夫链

• 贝叶斯网络

• 隐马尔可夫模型

• 贝叶斯分类器

这就像将多个 Python 库中的有用方法结合在一起，拥有一个统一而直观的 API。

让我们看看这个巧妙的小包的一些酷炫用法。

概率分布

让我们用 NormalDistribution 类来初始化。

生成几个样本，

现在，我们可以轻松检查一个样本数据点（或它们的数组）属于此分布的概率。

数据拟合

这就是更有趣的地方。用数据样本进行拟合非常简单和快速。

如上所初始化，我们可以检查 n1 对象的参数（均值和标准差）。我们期望它们为 5.0 和 2.0。

现在，让我们通过向高斯分布中添加随机噪声来创建一些合成数据。

图像由作者生成

我们可以将这组新数据拟合到 n1 对象中，然后检查估计的参数。

呼！看来 n1 已经更新了其估计的均值和标准差参数以匹配输入数据。直方图的峰值接近于图中的 4.0，这也正是估计的均值所显示的。

从数据样本直接创建分布

我们展示了如何将数据拟合到分布类。或者，可以直接从数据创建对象，

原生支持绘图（直方图）

使用 plot() 方法在分布类上绘图很简单，该方法还支持 Matplotlib 直方图方法的所有关键字。我们通过绘制 Beta 分布对象来进行说明。

作者生成的图像

离散分布

这就更有趣了。你可以传递一个字典，其中键可以是任何对象，值是相应的概率，而不是将参数传递给已知的统计分布（例如正态分布或贝塔分布）。

这是一些霍格沃茨角色的插图。注意，当我们尝试计算‘海格’的概率时，我们得到一个平坦的零，因为分布对‘海格’对象没有任何有限的概率。

将数据拟合到离散分布

通过将数据拟合到离散分布对象，我们可以做更有趣的事情。这是一个虚构的 DNA 核酸序列的例子。通常，这种类型的序列数据以字符串形式存在，我们可以用简单的代码读取数据并计算序列中四种核酸的概率。

一个简单的 DNA 序列匹配应用

我们可以用极其简单（且天真的）几行代码编写一个 DNA 序列匹配应用。假设** 序列中核酸的频率/概率相似的越接近**。有些随意，我们选择计算这种距离度量的均方根距离。

你可以查看 Jupyter notebook 获取帮助函数和确切的代码，但这里是一个示例输出。

高斯混合模型

Pomegranate 使处理来自多个高斯分布的数据变得简单。

让我们创建一些合成数据，

作者生成的图像

和往常一样，我们可以用一行代码直接从数据创建模型。当我们打印模型的估计参数时，我们观察到它捕捉了真实情况（生成器分布的参数）相当准确。

一旦模型通过数据样本生成后，我们可以轻松计算概率并绘制图表。代码在 Notebook中，下面是说明性的图表——左侧显示了一个单一的高斯分布，右侧显示了混合模型。

由作者生成的图像

马尔可夫链

我们可以轻松地使用 Pomegranate 建模一个简单的马尔可夫链，并计算任何给定序列的概率。

对于这个示例，我们将使用典型的雨天-阴天-晴天的例子。以下是转换概率表，

由作者生成的图像

我们还知道，平均而言，有 20%的雨天，50%的晴天和 30%的阴天。我们在 MarkovChain 类中编码了离散分布和转换矩阵，

现在，我们可以使用这个对象计算任何给定序列的概率。例如，如果你查看上面的表格，你可以相信像“阴天-雨天-阴天”这样的序列具有较高的可能性，而像“雨天-晴天-雨天-晴天”这样的序列不太可能出现。我们可以通过精确的概率计算来确认这一点（我们取对数来处理小概率数值），

数据拟合到 GMM 类

我们编写了一个小函数来生成随机的雨天-阴天-晴天序列，并将其输入到 GMM 类中。

首先，我们为 14 天的观察数据提供——“雨天-晴天-雨天-晴天-雨天-晴天-雨天-雨天-晴天-晴天-晴天-雨天-晴天-阴天”。为我们计算了概率转换表。

如果我们生成一个 10 年的随机序列，即 3650 天，那么我们得到以下表格。由于我们的随机生成器是均匀的，根据马尔可夫链的特性，转换概率将假设约 0.333 的极限值。

隐马尔可夫模型

使用 Pomegranate 中的 HMM 类，你可以做很多酷的事情。这里，我们只是展示了一个小示例，通过 HMM 预测检测长字符串中子序列的高密度出现。

假设我们记录了《哈利·波特》小说中四个角色的名字，它们在一章中一个接一个地出现，我们对检测哈利和邓布利多一起出现的部分感兴趣。然而，由于他们可能会交谈并在这些部分提到罗恩或海格的名字，因此子序列并不干净，即不严格包含哈利和邓布利多的名字。

图片拼贴由作者从 Wikimedia Commons 和 Pixabay 图片创建

以下代码初始化了一个均匀概率分布，一个偏斜概率分布，两个具有名称的状态，以及一个包含这些状态的 HMM 模型。

然后，我们需要添加状态转移概率，并“烘焙”模型以最终确定内部结构。请注意高自环概率，即状态倾向于以高概率停留在当前状态。

现在，我们有一个观测序列，我们将其作为参数传递给 HMM 模型的predict方法。转移和发射概率将被计算，并且会预测出一系列 1 和 0，我们可以注意到 0 的岛屿，表示包含“哈利-邓布利多”出现的部分。

总结

在本文中，我们介绍了一个快速且直观的统计建模库 Pomegranate，并展示了一些有趣的使用示例。更多教程可以在这里找到。本文中的示例也受到这些教程的启发。

Pomegranate 的 GitHub 仓库教程

该库提供了来自各种统计领域的实用类——一般分布、马尔可夫链、高斯混合模型、贝叶斯网络——具有统一的 API，可以快速实例化观察到的数据，并用于参数估计、概率计算和预测建模。

你可以查看作者的GitHub仓库，获取机器学习和数据科学方面的代码、想法和资源。如果你和我一样，对人工智能/机器学习/数据科学充满热情，请随时在 LinkedIn 上添加我或在 Twitter 上关注我。

Tirthajyoti Sarkar - 高级首席工程师 - 半导体、人工智能、机器学习

通过写作使数据科学/机器学习概念易于理解

原文。经许可转载。

相关内容：

• 数据分布概述

• 概率分布之前

• 比较机器学习模型：统计显著性与实际显著性

更多相关内容

• 支持向量机：一种直观的方法

• 协同过滤的直观解释

• 机器学习项目的简单快速数据流处理

• 快速有效的机器学习公平性审计方法

• BERT 在稀疏性下的最快速度是多少？

• 通过快速克里金法（FKR）加速机器学习

FastAPI 教程：用 Python 在几分钟内构建 API

原文：www.kdnuggets.com/fastapi-tutorial-build-apis-with-python-in-minutes

图片来源：作者

FastAPI 是一个流行的用于构建 Python API 的 Web 框架。它非常简单易学，并受到开发者的喜爱。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速开启网络安全职业生涯

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 工作

---

FastAPI 利用了 Python 的类型提示，并基于 Pydantic。这使得定义数据模型和请求/响应模式变得简单。框架会自动根据这些模式验证请求数据，从而减少潜在错误。它还原生支持异步端点，使得构建能够高效处理 I/O 绑定操作的高性能 API 更为简便。

本教程将教你如何使用 FastAPI 构建你的第一个 API。从设置开发环境到为一个简单的机器学习应用构建 API，本教程将带你完成所有步骤：定义数据模型、API 端点、处理请求等。通过本教程，你将对如何使用 FastAPI 快速高效地构建 API 有一个良好的理解。那么，让我们开始吧。

第一步：设置环境

FastAPI 需要 Python 3.7 或更高版本。所以请确保你安装了最新版本的 Python。在项目目录中，创建并激活一个专门的虚拟环境：

$ python3 -m venv v1
$ source v1/bin/activate 

上述激活虚拟环境的命令适用于 Linux 或 MacOS。如果你是 Windows 用户，查看文档来创建和激活虚拟环境。

接下来，安装所需的包。你可以使用 pip 安装 FastAPI 和 uvicorn：

$ pip3 install fastapi uvicorn 

这将安装 FastAPI 及所有必需的依赖项以及 uvicorn，这是一种我们将用来运行和测试构建的 API 的服务器。由于我们将使用 scikit-learn 构建一个简单的机器学习模型，也请在你的项目环境中安装它：

$ pip3 install scikit-learn

安装完成后，我们可以开始编码了！你可以在GitHub上找到代码。

第 2 步：创建一个 FastAPI 应用

在项目目录中创建一个 main.py 文件。第一步是像下面这样创建一个 FastAPI 应用实例：

# Create a FastAPI app
# Root endpoint returns the app description

from fastapi import FastAPI

app = FastAPI() 

Iris 数据集是你在开始数据科学时使用的玩具数据集之一。它包含 150 条数据记录，4 个特征和一个目标标签（鸢尾花的种类）。为了简单起见，让我们创建一个 API 来预测鸢尾花的种类。

在接下来的步骤中，我们将构建一个逻辑回归模型并创建一个用于预测的 API 端点。完成模型构建和/predict/ API 端点定义后，你应该能够向 API 发送包含输入特征的 POST 请求，并接收到预测的种类作为响应。

Iris 预测 API | 作者提供的图片

为了更有帮助，我们还定义一个根端点，它返回我们正在构建的应用的描述。为此，我们定义get_app_description函数，并使用@app装饰器创建根端点，如下所示：

# Define a function to return a description of the app
def get_app_description():
	return (
    	"Welcome to the Iris Species Prediction API!"
    	"This API allows you to predict the species of an iris flower based on its sepal and petal measurements."
    	"Use the '/predict/' endpoint with a POST request to make predictions."
    	"Example usage: POST to '/predict/' with JSON data containing sepal_length, sepal_width, petal_length, and petal_width."
	)

# Define the root endpoint to return the app description
@app.get("/")
async def root():
	return {"message": get_app_description()} 

向根端点发送 GET 请求会返回描述信息。

第 3 步：构建逻辑回归分类器

到目前为止，我们已经实例化了一个 FastAPI 应用，并定义了根端点。现在是时候进行以下操作：

• 构建一个机器学习模型。我们将使用逻辑回归分类器。如果你想了解更多关于逻辑回归的知识，请阅读《构建预测模型：Python 中的逻辑回归》。

• 定义一个预测函数，该函数接收输入特征，并使用机器学习模型来预测种类（setosa、versicolor 或 virginica）。

逻辑回归分类器 | 作者提供的图片

我们从 scikit-learn 中构建了一个简单的逻辑回归分类器，并定义了如图所示的predict_species函数：

# Build a logistic regression classifier
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression

# Load the Iris dataset
iris = load_iris()
X, y = iris.data, iris.target

# Train a logistic regression model
model = LogisticRegression()
model.fit(X, y)

# Define a function to predict the species
def predict_species(sepal_length, sepal_width, petal_length, petal_width):
	features = [[sepal_length, sepal_width, petal_length, petal_width]]
	prediction = model.predict(features)
	return iris.target_names[prediction[0]] 

第 4 步：定义 Pydantic 模型以输入数据

接下来，我们应该对 POST 请求中发送的数据进行建模。这里的输入特征是花萼和花瓣的长度及宽度——都是浮点值。为了建模，我们创建了一个继承自 Pydantic BaseModel类的IrisData类，如下所示：

# Define the Pydantic model for your input data
from pydantic import BaseModel

class IrisData(BaseModel):
	sepal_length: float
	sepal_width: float
	petal_length: float
	petal_width: float 

如果你需要一个关于使用 Pydantic 进行数据建模和验证的快速教程，请阅读《Pydantic 教程：Python 中的数据验证变得超级简单》。

第 5 步：创建 API 端点

现在我们已经构建了分类器，并定义好了predict_species函数，我们可以为预测创建 API 端点。如前所述，我们可以使用@app装饰器来定义接受 POST 请求并返回预测种类的/predict/端点：

# Create API endpoint
@app.post("/predict/")
async def predict_species_api(iris_data: IrisData):
	species = predict_species(iris_data.sepal_length, iris_data.sepal_width, iris_data.petal_length, iris_data.petal_width)
	return {"species": species} 

现在是运行应用的时候了！

第 6 步：运行应用

你可以使用以下命令运行应用：

$ uvicorn main:app --reload

这里main是模块的名称，app是 FastAPI 实例。--reload标志确保如果源代码有任何更改，应用会重新加载。

运行命令后，你应该会看到类似的 INFO 消息：

INFO: 	Will watch for changes in these directories: ['/home/balapriya/fastapi-tutorial']
INFO: 	Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: 	Started reloader process [11243] using WatchFiles
INFO: 	Started server process [11245]
INFO: 	Waiting for application startup.
INFO: 	Application startup complete.
…
… 

如果你访问“http://127.0.0.1:8000”（本地主机），你应该能看到应用程序描述：

应用程序运行在本地主机

步骤 7：测试 API

现在，你可以向 /predict/ 端点发送 POST 请求，提供有效的萼片和花瓣测量值，并获取预测的物种。你可以使用类似 cURL 的命令行工具。以下是一个示例：

curl -X 'POST' \
  'http://localhost:8000/predict/' \
  -H 'Content-Type: application/json' \
  -d '{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2
}' 

对于此示例请求，预期的输出是：

{"species":"setosa"}

总结

在本教程中，我们详细讲解了如何使用 FastAPI 构建一个简单分类模型的 API。我们涵盖了请求中使用的输入数据建模、定义 API 端点、运行应用程序以及查询 API 的步骤。

作为练习，拿一个现有的机器学习模型，并使用 FastAPI 在其上构建一个 API。祝编程愉快！

Bala Priya C**** 是来自印度的开发者和技术作家。她喜欢在数学、编程、数据科学和内容创作的交叉点工作。她的兴趣和专长领域包括 DevOps、数据科学和自然语言处理。她喜欢阅读、写作、编程和咖啡！目前，她正致力于通过编写教程、操作指南、评论文章等来学习并与开发者社区分享知识。Bala 还创建了引人入胜的资源概述和编码教程。

更多相关主题

• 在 5 分钟内使用 Python 构建网页抓取器

• 在 5 分钟内使用 Python 构建文本转语音转换器

• 在 5 分钟内构建机器学习网页应用

• 使用 Hugging Face 和 Gradio 在 5 分钟内构建 AI 聊天机器人

• KDnuggets 新闻 2022 年 3 月 9 日：5 分钟内构建机器学习网页应用

• OpenAI 的新 ChatGPT 和 Whisper API

fastcore: 一款被低估的 Python 库

原文：www.kdnuggets.com/2020/10/fastcore-underrated-python-library.html

评论

由 Hamel Husain 撰写，GitHub 的首席机器学习工程师

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你所在组织的 IT

---

背景

最近我开始了一段提高 Python 技能的旅程：我想学习高级模式、习语和技术。我从阅读关于高级 Python 的书籍开始，但信息似乎没有在没有实际应用的情况下记住。我还希望在学习过程中能够向专家提问——这是一个很难找到的安排！这时我想到：如果我能找到一个有相当先进 Python 代码的开源项目，并为其编写文档和测试，会怎么样？我打赌这样做会迫使我深入学习所有内容，而且维护者会欣赏我的工作，并愿意回答我的问题。

这正是我在过去一个月所做的！我很高兴地报告，这已经成为我经历过的最有效的学习体验。我发现编写文档迫使我不仅深入理解代码的功能，还要理解 代码为何以这种方式工作的，以及在编写测试时探索边界情况。最重要的是，当我遇到困难时，我能够提问，维护者愿意花额外的时间，因为他们知道他们的指导服务于使他们的代码更易于访问！事实证明，我选择的库，fastcore 是我遇到过的一些最迷人的 Python 代码，因为它的目的和目标非常独特。

对于新手，fastcore 是一个许多 fast.ai 项目构建在其上的库。最重要的是，fastcore 扩展了 Python 编程语言，致力于消除样板代码并为常见任务添加有用功能。在这篇博客文章中，我将重点介绍 fastcore 提供的一些我最喜欢的工具，而不是分享我对 Python 的学习。我的目标是引起你对这个库的兴趣，并希望激励你在完成阅读后查看文档以了解更多！

为什么 fastcore 很有趣

1. 在不离开 Python 的情况下接触其他语言的思想： 我一直听说学习其他语言对成为更好的程序员有好处。从实用的角度来看，我发现很难学习其他语言，因为我在工作中无法使用它们。fastcore 扩展了 Python，包含了如 Julia、Ruby 和 Haskell 等语言中的模式。现在我理解了这些工具，我有动力去学习其他语言。

1. 你获得了一套新的实用工具：fastcore 包含了可以帮助你编写更简洁且富有表现力的代码的工具，或许还能解决新的问题。

2. 了解更多关于 Python 编程语言的信息： 由于 fastcore 扩展了 Python 编程语言，过程中会暴露出许多高级概念。对有动力的人来说，这是一个了解 Python 内部工作原理的好方法。

对 fastcore 进行快速浏览

这里有一些使用 fastcore 立即引起我注意的功能。

使 **kwargs 透明

每当我看到一个函数有参数**kwargs**时，我都会有些不安。这是因为这意味着 API 是模糊的，我必须阅读源代码才能弄清楚有效的参数是什么。请看下面的例子：

def baz(a, b=2, c =3, d=4): return a + b + c

def foo(c, a, **kwargs):
    return c + baz(a, **kwargs)

inspect.signature(foo) 

<Signature (c, a, **kwargs)>

如果不读源代码，我可能很难知道 foo 还接受额外的参数 b 和 d。我们可以通过 delegates 来解决这个问题：

def baz(a, b=2, c =3, d=4): return a + b + c

@delegates(baz) # this decorator will pass down keyword arguments from baz
def foo(c, a, **kwargs):
    return c + baz(a, **kwargs)

inspect.signature(foo) 

<Signature (c, a, b=2, d=4)>

你可以自定义这个装饰器的行为。例如，你可以在传递参数的同时保留 **kwargs，从而实现双赢：

@delegates(baz, keep=True)
def foo(c, a, **kwargs):
    return c + baz(a, **kwargs)

inspect.signature(foo) 

<Signature (c, a, b=2, d=4, **kwargs)>

你也可以排除参数。例如，我们从委托中排除参数 d：

def basefoo(a, b=2, c =3, d=4): pass

@delegates(basefoo, but= ['d']) # exclude `d`
def foo(c, a, **kwargs): pass

inspect.signature(foo) 

<Signature (c, a, b=2)>

你也可以在类之间委托：

class BaseFoo:
    def __init__(self, e, c=2): pass

@delegates()# since no argument was passsed here we delegate to the superclass
class Foo(BaseFoo):
    def __init__(self, a, b=1, **kwargs): super().__init__(**kwargs)

inspect.signature(Foo) 

<Signature (a, b=1, c=2)>

欲了解更多信息，请阅读委托文档。

避免在设置实例属性时出现样板代码

你是否曾经想过是否可以避免在__init__中设置属性时的样板代码？

class Test:
    def __init__(self, a, b ,c): 
        self.a, self.b, self.c = a, b, c 

哎呀！这真是痛苦。看看所有重复的变量名。当定义类时，我真的需要这样重复吗？不再需要了！请查看store_attr：

class Test:
    def __init__(self, a, b, c): 
        store_attr()

t = Test(5,4,3)
assert t.b == 4 

你也可以排除某些属性：

class Test:
    def __init__(self, a, b, c): 
        store_attr(but=['c'])

t = Test(5,4,3)
assert t.b == 4
assert not hasattr(t, 'c') 

还有很多其他方法可以自定义和使用store_attr，比我在这里提到的要多。查看文档以获取更多细节。

附言：你可能会认为 Python 的数据类也可以避免这种样板代码。虽然在某些情况下是这样，但store_attr更为灵活。^(1)

1. 例如，store_attr 不依赖于继承，这意味着你在使用自己的类时不会被多重继承困住。此外，与数据类不同，store_attr 不要求 Python 3.7 或更高版本。此外，你可以在对象生命周期中的任何时间点和类中的任何位置使用 store_attr，以自定义变量存储的行为和时机。↩

避免子类化样板代码

*我讨厌 Python 中与子类化相关的__super__().__init__()样板代码。例如：

class ParentClass:
    def __init__(self): self.some_attr = 'hello'

class ChildClass(ParentClass):
    def __init__(self):
        super().__init__()

cc = ChildClass()
assert cc.some_attr == 'hello' # only accessible b/c you used super 

我们可以通过使用元类PrePostInitMeta来避免这种样板代码。我们定义了一个名为NewParent的新类，它是ParentClass的一个包装器：

class NewParent(ParentClass, metaclass=PrePostInitMeta):
    def __pre_init__(self, *args, **kwargs): super().__init__()

class ChildClass(NewParent):
    def __init__(self):pass

sc = ChildClass()
assert sc.some_attr == 'hello' 

类型调度

*类型调度，或多重调度，允许你根据接收到的输入类型改变函数的行为。这是一些编程语言（如 Julia）的一个突出特性。例如，这是一个概念示例，展示了多重调度在 Julia 中的工作原理，根据 x 和 y 的输入类型返回不同的值：

collide_with(x::Asteroid, y::Asteroid) = ... 
# deal with asteroid hitting asteroid

collide_with(x::Asteroid, y::Spaceship) = ... 
# deal with asteroid hitting spaceship

collide_with(x::Spaceship, y::Asteroid) = ... 
# deal with spaceship hitting asteroid

collide_with(x::Spaceship, y::Spaceship) = ... 
# deal with spaceship hitting spaceship 

类型调度在数据科学中尤其有用，你可以允许不同的输入类型（即 Numpy 数组和 Pandas 数据帧）传递给处理数据的函数。类型调度允许你为执行类似任务的函数提供一个通用 API。

不幸的是，Python 默认不支持这一功能。幸运的是，有@typedispatch装饰器可以帮助解决这个问题。这个装饰器依赖于类型提示来将输入路由到正确的函数版本：

@typedispatch
def f(x:str, y:str): return f'{x}{y}'

@typedispatch
def f(x:np.ndarray): return x.sum()

@typedispatch
def f(x:int, y:int): return x+y 

下面是一个演示函数f的类型调度的示例：

f('Hello ', 'World!') 

'Hello World!'

f(2,3) 

5

f(np.array([5,5,5,5])) 

20

这个功能有一些限制，还有其他使用这种功能的方法，你可以在这里阅读。在学习类型调度的过程中，我还发现了一个名为multipledispatch的 Python 库，由Mathhew Rocklin（Dask 的创建者）制作。

在使用这个功能后，我现在有动力学习像 Julia 这样的语言，以发现我可能错过了哪些其他范式。

functools.partial 的更好版本

functools.partial 是一个很棒的工具，它通过创建其他函数的函数来设置默认值。以这个过滤列表只包含值 >= val 的函数为例：

test_input = [1,2,3,4,5,6]
def f(arr, val): 
    "Filter a list to remove any values that are less than val."
    return [x for x in arr if x >= val]

f(test_input, 3) 

[3, 4, 5, 6]

你可以使用 partial 创建一个新函数，将默认值设置为 5：

filter5 = partial(f, val=5)
filter5(test_input) 

[5, 6]

partial 的一个问题是它会删除原始文档字符串并用通用文档字符串替换：

filter5.__doc__ 

'partial(func, *args, **keywords) - new function with partial application\n    of the given arguments and keywords.\n'

fastcore.utils.partialler 解决了这个问题，并确保文档字符串被保留，使得新的 API 透明：

filter5 = partialler(f, val=5)
filter5.__doc__ 

'Filter a list to remove any values that are less than val.'

函数的组合

在函数式编程语言中，广泛使用的一种技术是函数组合，通过将一系列函数链在一起以实现某种结果。这在应用各种数据转换时特别有用。考虑一个玩具示例，其中我有三个函数：（1）移除列表中小于 5 的元素（来自之前的部分）（2）将 2 添加到每个数字（3）将所有数字相加：

def add(arr, val): return [x + val for x in arr]
def arrsum(arr): return sum(arr)

# See the previous section on partialler
add2 = partialler(add, val=2)

transform = compose(filter5, add2, arrsum)
transform([1,2,3,4,5,6]) 

15

但这为什么有用？你可能会想，我可以用以下方式实现相同的功能：

arrsum(add2(filter5([1,2,3,4,5,6]))) 

你没有错！然而，组合为你提供了一个方便的接口，以防你想做以下事情：

def fit(x, transforms:list):
    "fit a model after performing transformations"
    x = compose(*transforms)(x)
    y = [np.mean(x)] * len(x) # its a dumb model.  Don't judge me
    return y

# filters out elements < 5, adds 2, then predicts the mean
fit(x=[1,2,3,4,5,6], transforms=[filter5, add2]) 

[7.5, 7.5]

欲了解更多关于 compose 的信息，请阅读 文档。

更有用的 __repr__

在 python 中，__repr__ 帮助你获取有关对象的信息以进行日志记录和调试。以下是当你定义一个新类时默认得到的内容。（注意：我们使用了之前讨论过的store_attr）

class Test:
    def __init__(self, a, b=2, c=3): store_attr() # `store_attr` was discussed previously

Test(1) 

<__main__.Test at 0x7ffcd766cee0>

我们可以使用 basic_repr 快速提供一个更合理的默认值：

class Test:
    def __init__(self, a, b=2, c=3): store_attr() 
    __repr__ = basic_repr('a,b,c')

Test(2) 

Test(a=2, b=2, c=3)

使用装饰器的猴子补丁

使用装饰器进行猴子补丁是很方便的，尤其是在你想修补你导入的外部库时。我们可以使用来自fastcore.foundation的装饰器 @patch以及类型提示：

class MyClass(int): pass  

@patch
def func(self:MyClass, a): return self+a

mc = MyClass(3) 

现在，MyClass 有一个名为 func 的额外方法：

mc.func(10) 

13

还不信服吗？我将在下一节中向你展示这种修补的另一个例子。

更好的 pathlib.Path

当你看到pathlib.path的这些扩展时，你不会再使用普通的 pathlib 了！pathlib 添加了许多额外的方法，例如：

• Path.readlines：等同于 with open('somefile', 'r') as f: f.readlines()

• Path.read：等同于 with open('somefile', 'r') as f: f.read()

• Path.save：将文件保存为 pickle

• Path.load：加载 pickle 文件

• Path.ls：以列表形式显示路径的内容。

• 等等。

更多信息请阅读这里。这是 ls 的演示：

from fastcore.utils import *
from pathlib import Path
p = Path('.')
p.ls() # you don't get this with vanilla Pathlib.Path!! 

(#7) [Path('2020-09-01-fastcore.ipynb'),Path('README.md'),Path('fastcore_imgs'),Path('2020-02-20-test.ipynb'),Path('.ipynb_checkpoints'),Path('2020-02-21-introducing-fastpages.ipynb'),Path('my_icons')]

等等！这到底是怎么回事？我们刚刚导入了pathlib.Path - 为什么我们会得到这个新功能？这是因为我们导入了fastcore.utils模块，该模块通过之前讨论的@patch装饰器修补了这个模块。为了说明@patch装饰器的用处，我现在将向Path添加另一个方法：

@patch
def fun(self:Path): return "This is fun!"

p.fun() 

'This is fun!'

这很神奇，对吧？我知道！这就是我写它的原因！

创建 lambda 的一种更简洁的方法

Self，用大写 S，是创建调用对象方法的 lambda 的一种更简洁的方式。例如，让我们创建一个 lambda 来计算 Numpy 数组的和：

arr=np.array([5,4,3,2,1])
f = lambda a: a.sum()
assert f(arr) == 15 

你可以以相同的方式使用Self：

f = Self.sum()
assert f(arr) == 15 

让我们创建一个 lambda 来进行 Pandas 数据框的分组和最大值计算：

import pandas as pd
df=pd.DataFrame({'Some Column': ['a', 'a', 'b', 'b', ], 
                 'Another Column': [5, 7, 50, 70]})

f = Self.groupby('Some Column').mean()
f(df) 

	另一列
一些列
---	---
a	6
b	60

阅读更多关于Self的内容，请查看文档。

笔记本函数

这些方法简单却实用，并允许你知道代码是否在 Jupyter Notebook、Colab 或 Ipython Shell 中执行：

from fastcore.imports import in_notebook, in_colab, in_ipython
in_notebook(), in_colab(), in_ipython() 

(True, False, True)

如果你在代码中显示某些类型的可视化、进度条或动画，可能会根据环境修改或切换，这非常有用。

替代列表的完美选择

你可能对 Python 的list很满意。这种情况有时候你并不知道自己需要更好的列表，直到有人向你展示了一个。介绍L，一个像列表的对象，具有许多额外的好处。

我可以用L 来描述最好的方式就是假装list和numpy有一个漂亮的宝宝：

定义一个列表（查看显示列表长度的漂亮__repr__！）

L(1,2,3) 

(#3) [1,2,3]

打乱一个列表：

p = L.range(20).shuffle()
p 

(#20) [8,7,5,12,14,16,2,15,19,6...]

索引到一个列表：

p[2,4,6] 

(#3) [5,14,2]

L 有合理的默认值，例如向列表中添加一个元素：

1 + L(2,3,4) 

(#4) [1,2,3,4]

L 还有更多内容可供探索。阅读文档以了解更多。

但等等 … 还有更多！

我还想展示更多关于 fastcore 的内容，但这些内容不可能合理地适合一篇博客文章。以下是一些我在这篇博客中没有演示的最喜欢的东西：

工具

工具 部分包含许多快捷方式，用于执行常见任务或提供额外的接口，超出标准 Python 提供的功能。

• mk_class：快速向类添加一堆属性

• wrap_class：使用简单的装饰器向类添加新方法

• groupby：类似于 Scala 的 groupby

• merge：合并字典

• fasttuple：增强版元组

• Infinite Lists：用于填充和测试

• chunked：用于批处理和组织事物

多进程

多进程部分 通过提供如以下特性扩展了 Python 的多进程库：

• 进度条

• 能够暂停以减轻与外部服务的竞争条件

• 在每个工作线程中批量处理事物，例如：如果你需要在块中执行一个向量化操作

函数式编程

函数式编程部分 是我最喜欢的库部分。

• maps：一个同时组合函数的映射

• mapped：一个更强大的 map

• using_attr：组合一个操作属性的函数

转换

转换 是一个用于创建数据转换及相关管道的工具集合。这些转换工具建立在本文讨论的许多构建块之上。

进一步阅读

*需要注意的是，你应该先阅读 文档主页 ，然后阅读 测试 部分，以便全面理解文档。

• fastcore 文档网站。

• fastcore GitHub 仓库。

• 关于 委派 的博文。

不好意思打广告：fastpages

这篇博文完全是在 Jupyter Notebook 中编写的，GitHub 自动将其转换为博文！听起来有趣吗？ 查看 fastpages。

个人简介：Hamel Husain 是 GitHub 的高级机器学习工程师。

原创。经许可转载。

相关：

• 数据科学遇上 Devops：使用 Jupyter、Git 和 Kubernetes 的 MLOps

• 如何使用机器学习在 GitHub 上自动化任务以获取乐趣和利润

• 自动化机器学习——加速数据科学家生产力的范式转变

进一步阅读

• 使用管道编写干净的 Python 代码

• 建立一个强大的数据团队

• 是什么让 Python 成为初创企业理想的编程语言

• 每个数据科学家都应该知道的三个 R 库（即使你使用 Python）

• 停止学习数据科学以寻找目标，并通过寻找目标来…

• 一个 90 亿美元的人工智能失败，进行了审查

系好安全带：Falcon 180B 到来了！

原文：www.kdnuggets.com/fasten-your-seatbelt-falcon-180b-is-here

图片来自作者

几个月前，我们了解到 Falcon LLM，这是由 技术创新研究所（TII）创立的，该公司是阿布扎比政府先进技术研究委员会的一部分。几个月后，他们变得更大、更强——字面上的意义，更大。

Falcon 180B: 你需要了解的一切

Falcon 180B 是最大且公开可用的语言模型，拥有 1800 亿个参数。没错，你没看错——1800 亿。它在 TII 的 RefinedWeb 数据集上进行了 3.5 万亿标记的训练。这代表了对一个开放模型进行的最长单周期预训练。

但我们这里关注的不仅仅是模型的规模，还包括其背后的力量和潜力。在大语言模型（LLMs）领域，Falcon 180B 正在创造新的标准。

目前可用的模型：

• Falcon 180B

• Falcon 180B Chat

Falcon-180B 基础模型是一个因果解码器模型。我建议使用该模型对自己的数据进行进一步的细化训练。

Falcon-180B-Chat 模型与基础版本有相似之处，但通过使用 Ultrachat、Platypus 和 Airoboros 指令（对话）数据集进行细化调整，进一步提升了能力。

训练

Falcon 180B 在其前身 Falcon 40B 的基础上进行了扩展，新增了多查询注意力机制以提高可扩展性。该模型在 Amazon SageMaker 上使用了 4096 个 GPU，并在 3.5 万亿个标记上进行了训练。这大约需要 7,000,000 GPU 小时。这意味着 Falcon 180B 比如 Llama 2 等大语言模型快 2.5 倍，并且训练所用计算资源是其 4 倍。

哇，真是太多了。

数据

Falcon 180B 使用的数据集主要来自 RefinedWeb，占比达 85%，此外还在一系列精心策划的数据（如技术论文、对话和一些代码元素）上进行了训练。

基准测试

你们都想知道的部分——Falcon 180B 在竞争对手中表现如何？

到目前为止（2023 年 9 月），Falcon 180B 是公开发布的最佳大语言模型。它在 MMLU 上的表现超过了 Llama 2 70B 和 OpenAI 的 GPT-3.5。它通常介于 GPT 3.5 和 GPT 4 之间。

图片来自 HuggingFace Falcon 180B

Falcon 180B 在 Hugging Face 排行榜上排名 68.74，使其成为最高分的公开发布的预训练大语言模型，超过了 Meta 的 LLaMA 2，后者的得分为 67.35。

如何使用 Falcon 180B？

对于开发者和自然语言处理（NLP）爱好者，Falcon 180B 在 Hugging Face 生态系统中可用，开始于 Transformers 版本 4.33。

然而，正如你可以想象的，由于模型的体积，你需要考虑硬件要求。为了更好地了解硬件要求，HuggingFace 进行了不同使用案例所需的模型运行测试，如下图所示：

图片由 HuggingFace Falcon 180B 提供

如果你想测试一下并尝试一下，可以通过点击这个链接尝试 Falcon 180B 的演示：Falcon 180B 演示。

Falcon 180B 与 ChatGPT

该模型有一些严苛的硬件要求，并不是所有人都能轻易获得。然而，根据其他人对 Falcon 180B 和 ChatGPT 的测试结果，ChatGPT 在回答相同问题时胜出。

在代码生成方面表现良好，但在文本提取和总结方面仍需提升。

总结一下

如果你有机会尝试过它，请告诉我们你与其他 LLMs 的比较结果。Falcon 180B 作为目前 Hugging Face 模型中心最大的公开模型，是否值得所有的宣传？

好吧，看来它确实如此，因为它已经在开放访问模型的排行榜上名列前茅，并且对像 PaLM-2 这样的模型构成了威胁。我们迟早会知道结果。

尼莎·阿雅 是一位数据科学家、自由技术作家，以及 KDnuggets 的编辑和社区经理。她特别关注提供数据科学职业建议或教程及理论知识。尼莎涵盖了广泛的主题，并希望探索人工智能如何有助于人类寿命的延续。作为一个热衷学习者，尼莎寻求拓宽她的技术知识和写作技能，同时帮助指导他人。

更多相关主题

• Falcon LLM：开源 LLM 的新王者

• 想用你的数据技能解决全球问题？这里是…

• 我每天使用 ChatGPT 5 个月。这里是一些隐藏的宝石…

• 这里是我使用的 AI 工具及我的技能来赚取 $10,000 的方法…

• 无法找到数据科学职位？这里是原因

• 数据科学被高估了，原因如下

使用 NumPy 和 Pandas 在更大图上的更快机器学习

原文：www.kdnuggets.com/2020/05/faster-machine-learning-larger-graphs-numpy-pandas.html

评论

作者：Huon Wilson，CSIRO Data61

图片来源：Hassan Amra 于 Unsplash

本周，StellarGraph 发布了一个新版本的开源图机器学习库。最令人兴奋的特性之一是 StellarGraph 1.0 引入了一种新的图数据结构——使用 NumPy 和 Pandas 构建——这使得内存使用显著降低，构建时间也大大缩短。

想象一下，一个来自 Reddit 的图，拥有超过 20 万个节点和 1100 万条边，使用之前版本的库的图数据结构时需要近 7GB 的内存，构建时间也长达 2.5 分钟。

在新 StellarGraph 类的最小形式中，相同的 Reddit 图现在大约使用 174MB 的内存。这甚至不是经典的‘内存与时间’平衡：新形式的构建时间仅为 0.9 秒。

即，新版 StellarGraph 类在存储上比旧版 StellarGraph 小 40 倍，构建速度则比旧版快数百倍。

在本文中，我们将探讨如何通过仔细关注对图机器学习最有效的方案——在这种情况下，将 StellarGraph 的图数据结构从基于 NetworkX 替换为基于 NumPy 和 Pandas 的结构——从而在 StellarGraph 类中实现显著的性能提升。

更高一层

StellarGraph 库是一个开源、用户友好的图机器学习库。一个 图 是一组节点及其之间的边，其中边表示节点之间的某种连接或关系。

库中的核心抽象是 StellarGraph 类，这是一个图数据结构，用于管理所有关于图或图组的信息，以用于机器学习。

以前版本的 StellarGraph 类依赖于 NetworkX，因为其便捷灵活的 API 和使用嵌套字典构建的特性，允许快速有效地开发许多图机器学习算法。

然而，这种灵活性意味着它没有针对图机器学习进行优化：NetworkX 的权衡与机器学习所需的最佳权衡不同，其中最显著的是存储图所需的内存量。

因此，在 1.0 版本之前的更新中，基于 NetworkX 的图数据结构被用一个基于 NumPy 和 Pandas 的新数据结构所替代。

它是如何工作的？

新的 StellarGraph 类有三个关键部分：

• 高效的边存储

• 保持节点特征以便快速索引

• 支持任意节点 ID。

高效的边存储

新的 StellarGraph 类使用 NumPy 数组存储大部分数据。

NumPy 数组可以由单一块内存组成，值内联存储。Python 列表存储指向其他 Python 对象的指针，每个指针都有额外的元数据开销，大大增加了与 NumPy 相比的成本。

这些数组 将数据连续存储在内存中，以至于一个四字节整数的数组（如 numpy.int32 类型）每个元素仅需四个字节。这与同样整数的 Python 列表不同，后者每个元素需要十倍的内存，即每个元素 43 个字节。

图的边在概念上是源节点 ID 和目标节点 ID 的对，表示两个节点之间的连接。在新的 StellarGraph 类中，边被存储为 NumPy 数组，其中包含源节点和目标节点，采用“结构化数组”的样式。

这解释了 Reddit 图形内存使用减少的一个重要原因。边信息可以在内存中连续存储，不会有 Python 对象的开销。通过本地使用 NumPy，我们还可以轻松利用由SciPy 库提供的高效的 稀疏矩阵 和 图算法。

保持节点特征以便快速索引

NumPy 数组也用于节点特征。StellarGraph 针对机器学习进行了优化，这通常意味着处理“特征”向量或编码每个实体信息的数字列表。任何 StellarGraph 图形可以有多种类型的节点，每种类型的每个节点都有不同数量的特征。

左侧的图有两种节点类型；“白色背景”和“黑色背景”，每种类型还有一些特征向量。这些被转换为右侧的 2D NumPy 数组，匹配节点的顺序。

新的 StellarGraph 类通过为每种节点类型拥有一个大型矩形 2D NumPy 数组来存储节点特征：对于特定的节点类型，数组的第一行表示该类型第一个节点的特征，第二行表示第二个节点的特征，以此类推。

这种编码方式非常节省内存，因为数字特征可以全部布局而不会有来自 Python 对象的开销，就像边缘一样。它也很快，因为关于数组中给定位置节点特征的查询可以通过从数组中切片来回答，这在 NumPy 库中是通过原生 C 代码实现的。

对任意节点 ID 的支持

查询这个数据结构需要一些技巧。它在存储方面非常出色，但实际上获取节点的特征需要知道它的位置；无论它是该类型的第一个、第二个还是第几百个节点。

一种方法是要求所有节点 ID 都是从 0 开始的顺序整数，因此所有具有三个节点的图的 ID 为 0、1、2。然而，这使得该库在实际数据集中（其中 ID 可能是 UUIDs、随机值或其他非平凡编码）使用起来困难。在异构图中，情况变得更加复杂，因为有多种节点类型。

节点可以使用任何 ID 值进行键控，通过使用 pandas.Index 作为到数字 ID 或 ilocs 的转换层。这些 ilocs 然后可以在上述 NumPy 数组中使用。

因此，新 StellarGraph 类的关键部分是使用 pandas.Index 类型在方便的和传统的节点 ID 之间提供转换，以便任何节点 ID 值都可以使用，类的用户无需考虑自己进行转换或管理。

Pandas Index 类型被用作高效的时间和内存字典，将 ID 映射到顺序整数（StellarGraph 和 Pandas 都称之为“ilocs”，即整数位置）。它利用了 Pandas 优化的 C 和 Cython 原生代码。

这些 ilocs 用作上述边缘存储的一部分。ilocs 是小整数，因此 NumPy 数组的连续布局确保我们的边缘始终高效存储。许多 StellarGraph 的算法直接使用这些 ilocs，因此不会因为“花哨”的 ID 而产生额外开销。

这里还有一些额外的细节。例如，节点实际上在索引中是全局编号的，而不是按类型编号，因此上述图中的 A → 2，B → 3，…，但大多数这些细节对用户是隐藏的。

总结来说 —

StellarGraph 易于安装和使用，因为它建立在巨人的肩膀上。通过使用 NumPy 和 Pandas，我们获得了优化的本地代码的大部分好处，而不必自己编写底层代码——这需要仔细优化，并且可能导致严重的内存损坏错误——也无需担心为每个平台精心分发。

新版 StellarGraph 类在 1.0 版本中通过仔细选择移动部件和专注于仅所需的图机器学习，使用 NumPy 和 Pandas 来减少内存使用和提高速度。基于现有库为我们提供了本地代码的好处而没有问题。

要开始使用图机器学习与新版 StellarGraph 类，首先在 StellarGraph 库中pip install stellargraph，然后使用StellarGraph(nodes, edges) 创建一个新的优化图对象。可以查看 所有细节的演示。

这项工作涉及了来自Andrew Docherty、Geoff Jarrad、Huon Wilson* 以及 Kieran Ricardo 的重要贡献、研究和代码。我们正在基于这个优化基础进行更多改进，这些改进应该会进一步提升内存使用和速度，例如#718。*

这项工作得到 CSIRO Data61 的支持，这是澳大利亚领先的数字研究网络。

简介： Huon Wilson 是一名软件工程师，具有扎实的数学和统计学背景，拥有在编译器等低级系统编程领域的丰富经验，精通 C++、C 以及更为独特的 Rust 等语言。在更高层面，他有 R 和 Python 中的数值编程经验，以及大多数语言范式和许多其他软件工程领域的经验。

原文 已获授权转载。

相关：

• 图神经网络模型校准以获得可信预测

• 可扩展图机器学习：我们能攀登的高山？

• 图神经网络与用户体验：一段未曾探索的恋情

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速开启网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你组织的 IT 需求

---

了解更多相关话题

• 数据可视化中的 SQL：如何为图表和图形准备数据

• 超越管道：图表作为 Scikit-Learn 的元估计器

• 图表：理解数据的自然方式

• 通过参与比赛将机器学习的学习速度提高 4 倍

• 7 种方法让 ChatGPT 帮助你更快更好地编程

• 如何优化 SQL 查询以加快数据检索速度

我最喜欢的令人震惊的机器学习/人工智能突破

原文：www.kdnuggets.com/2019/03/favorite-ml-ai-breakthroughs.html

评论

由 Jerry Chi，SmartNews 数据科学经理。

与其他领域相比，机器学习/人工智能如今似乎有着更高频率的超级有趣的发展。那些让你说“哇”甚至“多么美好的时代！”（正如 Two Minute Papers 的创作者常说）

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速开启网络安全职业生涯

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织在 IT 方面

---

免责声明：我并没有使用“令人震惊”或“突破”的严格定义；这只是一个随意的列表……我可能会使用不那么严格的术语来使这篇文章更易读

从看似无用的信息中获得惊人准确的估算

透墙人体姿态估计

麻省理工学院研究人员的网站/视频，2018

我们可以仅通过 Wifi 信号的扰动准确估计墙另一边的人是站着、坐着还是走动。

从视频中测量材料的物理属性

文章/视频由麻省理工学院研究人员提供，2015

研究人员首次在 2014 年 演示了他们可以从视频（没有音频）中的薯片袋的振动中重现人类的声音。这一部分没有使用机器学习。在 2015 年，他们使用机器学习展示了你可以仅从视频中（在某些情况下，仅通过空气的普通流动引起的振动就足够）估计材料的刚度、弹性、单位面积重量等。

从键盘旁边的智能手机中估计按键次数

论文，2015

研究人员展示了使用一个放置在键盘旁边的普通智能手机录音，能够以94%准确率估计每个按键。与之前使用多个麦克风环绕键盘的监督深度学习方法不同，这篇论文实际上使用了一种相对简单的机器学习技术（K-means 聚类）和无监督学习。

生成模型

逼真的面孔生成、风格混合和插值

论文/视频 由 NVIDIA 研究人员提供，2018 年

研究人员将一种新架构与大量 GPU 结合，创造出了极其逼真的人工面孔，这些面孔是其他面孔之间的插值或一种面孔“风格”应用到另一面孔上的结果。这项工作建立在生成对抗网络（GANs）之前的研究基础上。GANs 于 2014 年发明，自那时以来研究爆炸性增长。GANs 的基本概念是两个神经网络相互对抗（例如，一个将图像分类为“真实”或“虚假”，另一个神经网络生成图像以试图“欺骗”第一个神经网络，将虚假图像错误地分类为真实……因此第二个神经网络是第一个的“对手”）。

一般来说，有很多关于对抗性机器学习的惊人研究，这种研究已经有十多年历史了。它对网络安全等领域有许多令人不安的影响。但我离题了。

教授机器绘画

Google Brain 的博客文章，2017 年

两幅图像之间的插值

我的熟人David Ha at Google Brain使用生成对抗递归神经网络（RNN）制作了基于矢量的图形（我把这看作是自动化的 Adobe Illustrator）。

将优秀的舞蹈动作转移到舞蹈水平差的人身上

网站/视频 由 UC Berkeley 研究人员提供，2018 年

想象一下“自动调音器”用于舞蹈。通过姿态估计和生成对抗训练，研究人员能够制作任何真实人物（“目标”人物）舞蹈的虚假视频，并且舞技非常高超。所需的输入仅有：

• 一段优秀舞者跳舞的短视频

• 目标人物跳舞的几分钟视频（通常舞技很差，因为大多数人舞蹈不好）

我还看到 NVIDIA 的 CEO Jensen Huang 展示了一段（使用此技术制作的）他像迈克尔·杰克逊一样跳舞的视频。我很高兴我参加了 GPU 技术大会，哈哈。

强化学习

世界模型 — AI 在自己的梦境中学习

谷歌大脑网站，2018

人类实际上并不真正知道或考虑我们生活的世界的所有细节。我们的行为是基于我们脑中的世界抽象。例如，如果我骑自行车，我不会考虑自行车的齿轮/螺母/螺栓；我只是对车轮、座位和把手的大致位置以及如何与它们互动有一个粗略的感知。为什么不对人工智能采用类似的方法呢？

这种“世界模型”方法（再次由 David Ha 等人创建）允许“代理”（例如控制赛车游戏中汽车的人工智能）创建一个世界/环境的生成模型，这是实际环境的简化/抽象。因此，你可以把世界模型看作是存在于人工智能脑中的一个梦境。然后，人工智能可以在这个“梦境”中通过强化学习进行训练，以实现更好的表现。因此，这种方法实际上是将生成式机器学习与强化学习结合在一起。通过这样做，研究人员在某些视频游戏任务中达到了最先进的性能。

[更新 2019/2/15] 基于上述“世界模型”方法，谷歌刚刚公布了PlaNet：深度规划网络用于强化学习，其数据效率比以往方法提高了 5000%。

AlphaStar——击败顶级职业选手的 Starcraft II 人工智能

博客文章，DeepMind（谷歌）制作的电子竞技视频，2019 年

我们距离李世石与 DeepMind 的 AlphaGo 之间的历史围棋比赛已经过去很远，那只是三年前的 2016 年（看看Netflix 纪录片，让一些人感动落泪）。那时，AlphaZero 在 2017 年在围棋方面超越了 AlphaGo（并在国际象棋、将棋等方面超越了任何其他算法），尽管没有使用任何来自人类比赛的训练数据。但 2019 年的 AlphaStar 则更加惊人。

自 1998 年以来作为一个 StarCraft 粉丝，我能体会到“……需要平衡短期和长期目标，并适应意外情况……带来了巨大的挑战。”这是一个真正困难且复杂的游戏，需要在多个层面上理解才能玩得好。对 Starcraft 算法的研究自 2009 年以来一直在进行。

AlphaStar 实质上使用了监督学习（来自人类比赛）和强化学习（对抗自我）相结合的方法来实现其结果。

人类训练机器人

用单个人类演示来教导机器任务

NVIDIA 研究人员的文章 / 视频，2018 年

我能想到三种典型的方法来教机器人做某件事，但这些方法都需要大量时间/劳动：

• 手动编程每种情况的机器人关节旋转等

• 让机器人多次尝试任务（强化学习）

• 向机器人演示任务很多次

通常，深度学习的一大批评是，生产使计算机表现良好的数百万个示例（数据）是非常昂贵的。但越来越多的方法可以避免依赖这种昂贵的数据。

研究人员找到了一个方法，让机器人手臂能够成功执行一个任务（例如“拾起块状物并将其堆叠成以下顺序：红色块、蓝色块、橙色块”），基于单一视频中的单一人类演示（一个真实的人的手移动这些块），即使视频是从不同的角度拍摄的。这个算法实际上生成了一个人类可读的任务描述，这对故障排除非常有帮助。该算法依赖于姿态估计的对象检测、合成训练数据生成和模拟到现实的迁移。

无监督机器翻译

Facebook AI Research 的博客文章，2018 年

通常，你需要大量翻译文档的训练数据集（例如，联合国会议的专业翻译）才能很好地进行机器翻译（即监督学习）。当然，许多主题和语言对没有高质量、充足的训练数据。在这篇论文中，研究人员展示了使用无监督学习（即不使用翻译数据，仅使用每种语言中无关的文本语料库）是可能达到最先进的监督学习方法的翻译质量。哇。

基本思想是，在任何语言中，某些词汇/概念往往会紧密出现（例如“毛茸茸的”和“猫”）。他们描述这个现象为“不同语言中的词嵌入共享类似的邻域结构。” 我的意思是，好的，我明白这个概念，但令人惊叹的是，使用这种方法他们能够在没有翻译数据集的情况下达到如此高的翻译质量。

结束

我希望这篇文章让你对机器学习/人工智能的发展更加兴奋，即使你之前已经很兴奋。也许我会在一年后写另一篇类似的文章。请随时在这里留下任何想法/评论，或通过电子邮件联系我，地址是 jerrychi123 [at] gmail.com。

这是多么美好的时代啊！ =D

个人简介： Jerry Chi 在数据科学、机器学习、数据工程和数字行业战略方面有丰富经验。

原文。经许可转载。

资源：

• 在线和基于网络：分析、数据挖掘、数据科学、机器学习教育

• 分析、数据科学、数据挖掘和机器学习的软件

相关内容：

• 以低成本获取标注数据来训练你的模型

• 你的机器学习代码可能很糟糕的四个原因

• 使用 NumPy 和图像分类实现人工神经网络

更多相关内容

• 停止学习数据科学以寻找目标，并寻找目标以……

• 学习数据科学统计的顶级资源

• 一项 90 亿美元的人工智能失败案例分析

• 成功的数据科学家的五个特征

• 是什么让 Python 成为初创公司理想的编程语言

• 每个数据科学家都应该了解的三个 R 库（即使你使用 Python）

AIG 和 Zurich 关于保险中的机器学习

原文：www.kdnuggets.com/2016/06/fcbi-aig-zurich-machine-learning-insurance.html

作者：Emma Sheard，Insurance Nexus。

保险行业一直将分析和洞察作为关键的竞争优势，并且近年来在分析能力的提升上取得了显著进展。然而，分析能力预计将迎来巨大的飞跃。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的快车道。

2. Google 数据分析专业证书 - 提升你的数据分析水平

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

机器学习和人工智能有潜力彻底改变整个保险组织，但保险公司在哪里以及如何实际应用机器学习？这值得吗？

Insurance Nexus 最近与 AIG 和 Zurich Insurance 的保险高管进行了交谈，以了解这一点。

现在查看完整白皮书，！

George Argesanu（AIG 全球分析主管）和 Monika Schulze（Zurich 全球营销主管）提供了独家的见解：

• 在保险背景下定义机器学习和人工智能

• AIG 和 Zurich 如何计划在近期使用机器学习

• 机器学习在保险行业中的潜在应用

• 机器学习的期望结果是什么：成功的表现是什么？

• 未来日益增长的分析能力将如何影响整个行业？

在此处访问完整白皮书：1.fc-bi.com/LP=12421

Emma Sheard 是 Insurance Nexus（FC Business Intelligence 的一个部门）的战略主管。你可以通过 +44 (0) 207 422 4349 或 esheard@fc-bi.com 联系她。

Insurance Nexus 是 FC Business Intelligence Ltd 的一部分。FC Business Intelligence Ltd 是一家在英格兰和威尔士注册的公司。注册号 04388971，地址：伦敦时尚街 7-9 号，E1 6PX，英国。Insurance Nexus 是保险高管的核心中心。通过深入的行业分析、针对性的研究、细分事件和优质内容，我们为行业提供了一个网络交流、讨论、学习和塑造保险行业未来的平台。

更多相关主题

• KDnuggets 新闻，12 月 14 日：3 门免费的机器学习课程

• 每个机器学习工程师应该掌握的 5 项机器学习技能

• 学习数据科学、机器学习和深度学习的扎实计划

• 人工智能、分析、机器学习、数据科学、深度学习的最新发展与预测

• 突破数据障碍：零样本、单样本和少样本学习如何改变机器学习

• 联邦学习：协作机器学习及教程

使用 fast.ai 进行快速日期特征工程

原文：www.kdnuggets.com/2018/03/feature-engineering-dates-fastai.html

评论

正如你所了解的，简单的日期字段是潜在的数据宝库。虽然乍一看，日期只是时间线上的一个特定点，但了解这个点相对于其他点的位置可以为数据集生成各种洞察。例如，可以从日期字段中提取出大量简单的问题：

• 那是一个周末吗？

• 那天是星期几？

• 日期是否在一个季度末？

• 那天是节假日吗？

• 那天是否有奥运会？

你从日期中想要什么取决于你在做什么。拥有包含一些上述不那么固有的问题的外部资源（“那天是否有奥运会？”——根据你的项目，可能是一个完全有效的问题）肯定是必要的，但即使是解决更基础的问题也可能极为有用。

对日期进行简单的特征工程可以不费吹灰之力地处理这些任务。当我最近坐下来编写一个通用的、可重用的函数来做这件事时，我很快意识到Jeremy Howard已经在他的 fast.ai 库中处理了这个问题。

如果你不知道，fast.ai 库是一个流行机器学习库的补充包装集合，旨在消除编写自己的函数来处理机器学习工作流中的一些重复任务的必要性。

在 fast.ai 中确实存在这样一个函数，它在后台利用 Pandas 来自动化一些简单的日期相关特征工程。

让我们来看看。但首先，让我们获取一些简单的数据进行测试。有关数据和如何在下面的代码中收集数据的更多信息，请参阅数据科学的红利——金融数据分析的温和介绍。此外，理应说明，这假设你已经安装了 fast.ai 库。

import datetime
import pandas as pd
from pandas_datareader import data
from fastai.structured import add_datepart

# Set source and rate of interest
source = 'fred'
rate = 'DEXCAUS'

# Date range is 2016
start = datetime.datetime(2016, 1, 1)
end = datetime.datetime(2016, 12, 31)
cadusd = data.DataReader(rate, source, start, end)

# Write it to a CSV 
cadusd.to_csv('cadusd.csv')

# Read the CSV back in (there is a peculiarity accounting for this)
cadusd = pd.read_csv('cadusd.csv')

# Set datetime precision to 'day'
cadusd['DATE'] = cadusd['DATE'].astype('datetime64[D]')

cadusd['DEXCAUS'].plot(kind='line', grid=True, title='CAD to USD Conversion Rates, 2016')
cadusd.head()

为了让我们了解将要使用的 fast.ai 函数的代码有多么简单，下面是当前版本的源代码：

def add_datepart(df, fldname, drop=True):
    fld = df[fldname]
    if not np.issubdtype(fld.dtype, np.datetime64):
        df[fldname] = fld = pd.to_datetime(fld, infer_datetime_format=True)
    targ_pre = re.sub('[Dd]ate$', '', fldname)
    for n in ('Year', 'Month', 'Week', 'Day', 'Dayofweek', 'Dayofyear',
            'Is_month_end', 'Is_month_start', 'Is_quarter_end', 'Is_quarter_start', 'Is_year_end', 'Is_year_start'):
        df[targ_pre+n] = getattr(fld.dt,n.lower())
    df[targ_pre+'Elapsed'] = fld.astype(np.int64) // 10**9
    if drop: df.drop(fldname, axis=1, inplace=True)

Howard 在许多地方表示，他编写 fast.ai 包装器的目标是用尽可能少的代码创建有用的函数，使其简洁、易读并集中于目标。

对函数的简单调用会展开 DATE 字段：

add_datepart(cadusd, 'DATE')

唯一可能的附加参数是'drop'，当设置为 True 时，会从数据框中删除原始日期列。

这是部分结果：

特征的完整列表：

由于没有机器学习算法能够查看一个日期时间对象并自动推断上述内容，这样简单的步骤提供了对数据集进行自动洞察的可能性。在不需要思考的情况下，现在各种日期元数据都触手可及，例如这一天是否是年初、季度初或月初，并且通过进一步简单的推断，是否是周末、是否在三月、是哪一年等等。

这种基本的特征工程应该在我看来表明两个具体的事情：

1. 对时间序列数据进行特征工程不应感到畏惧

2. 你可能想看看 fast.ai 库

相关：

• 时间序列基础知识——三步流程

• 深度特征合成：自动特征工程如何运作

• 时间序列数据的自动特征工程

---

我们的前三名课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业道路

2. 谷歌数据分析专业证书 - 提升你的数据分析水平

3. 谷歌 IT 支持专业证书 - 支持你的组织进行 IT 工作

---

更多相关主题

• 特征存储峰会 2022：关于特征工程的免费会议

• 使用 RAPIDS cuDF 利用 GPU 进行特征工程

• 寻找合适的注释人员的快速指南

• 学习 SAS 的快速数据科学技巧和窍门

• 7 个 Pandas 绘图函数以快速数据可视化

• Voronoi 图的快速概述

日期时间变量的特征工程用于数据科学和机器学习

原文：www.kdnuggets.com/2021/04/feature-engineering-datetime-variables-data-science-machine-learning.html

评论

作者 Samarth Agrawal，丰田数据科学家

日期时间变量的特征工程。图像由作者提供。

介绍

---

我们的前三名课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道

2. 谷歌数据分析专业证书 - 提升你的数据分析水平

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 需求

---

日期时间字段需要特征工程来将它们从数据转变为可供机器学习模型使用的有洞察力的信息。本文分为 3 部分和一个额外的奖励部分，我们将使用内置的 pandas 和 NumPy 函数以及我们的函数来提取有用的特征。

• 第一部分 — 提取日期/时间组件

• 第二部分 — 创建布尔标志

• 第三部分 — 计算日期/时间差异

• 奖励 — 使用fast_ml两行代码进行特征工程

背景

每当我处理与电子商务相关的数据时，数据集总是以某种方式包含日期时间列。

• 用户注册日期时间

• 用户登录日期时间

• 交易日期时间

• 争议交易日期时间

• …以及更多

起初，这个日期字段只给我们一个时间线上的特定点。但这些日期时间字段是潜在的数据宝藏。如果“正确使用”，这些字段非常强大，能够揭示模式。

作为数据科学家，你的工作是提供洞察，为此，你需要提出正确的问题。例如：

• 问题 1 — 你通常在什么时候看到最多的购物车被创建？

• 问题 2 — 你通常在什么时候看到最多的购物车被放弃？

• 问题 3 — 你看到最多的欺诈交易发生在什么时候？

• 问题 4 — 什么时候用户订阅最多？

• 问题 5 — 某些物品最常在什么时候购买？

• 问题 6 — 用户在注册后多少天/小时内进行第一次订单？

• 问题 7 — 客户在多少天不活动后不会再返回你的网站？

• …等等

现在，为了回答这些问题，你需要回到数据中去工程化这些日期时间字段。然后就可以发现大量的模式。

本文的第一部分将提供特征工程步骤，以回答类似于第 1、2 和 3 问题的问题

• 答案 1 — 什么时候您看到最多的购物车被创建？每月的第一周

• 答案 2 — 您什么时候看到最多的购物车被遗弃？星期三-下午

• 答案 3 — 什么时候您看到最多的欺诈交易？星期五-深夜

本文的第二部分将提供特征工程步骤，以回答类似于第 4 和第 5 问题的问题

• 答案 4 — 什么时候最多用户订阅？在年初

• 答案 5 — 某些物品最常在何时购买？在月初

本文的第三部分将提供特征工程步骤，以回答类似于第 6 和第 7 问题的问题

• 答案 6 — 注册后经过多少天/小时用户会下第一个订单？在 2 小时内

• 答案 7 — 在经过多少天的不活动后，客户会永远不再访问您的网站？经过 14 天的不活动

我使用了一个电子商务数据的例子，在这个例子中，我个人发现了许多用例，但提取信息的范围并不限于此。我们将在本文中看到，通过提出正确的问题，即进行正确的特征工程，如何学到的一些行为在各种问题的多个行业中证明了其有用性。

开始吧

加载数据集

import pandas as pddf = pd.read_csv('/kaggle/input/loan-data/loan.csv', 
                 parse_dates = ['date_issued', 'date_last_payment'])

Pandas 提供了一种非常简单但功能强大的方法来处理与 DateTime 相关的变量，通过将其解析为日期。您可以将所有与日期时间相关的变量作为列表传递给参数 parse_dates。

假设您一开始不知道 DateTime 变量，并且在调查数据后发现一些变量是日期时间。因此，pandas 提供了另一个有用的函数 to_datetime 来将数据类型转换为 DateTime，而不是重新加载数据。

df['date_issued'] = pd.to_datetime(df['date_issued'], 
                                   errors = 'coerce')

第一部分。提取日期/时间组件

如上例所示，我们可以从给定的日期时间变量中提取日期时间部分的组件（year，quarter，month，day，day_of_week，day_of_year，week_of_year，time，hour，minute，second，day_part）。下面的列表提供了使用 pandas 内置函数可以提取的多个这样的组件。

语法：

我们可以使用 .dt 访问器提取所有这些组件。在这里阅读有关日期访问器的更多信息

从日期时间变量 issued_date 中提取的组件。图片由作者提供

下面是图像中显示的代码。所有其他组件也可以以类似的方式提取

#1
df[‘date_issued:year’] = df[‘date_issued’].dt.year#2
df[‘date_issued:month’] = df[‘date_issued’].dt.month#3
df[‘date_issued:day_of_week’] = df[‘date_issued’].dt.day_of_week#4
df[‘date_issued:week_of_year’] = df[‘date_issued’].dt.week_of_year#5
df[‘date_issued:hour’] = df[‘date_issued’].dt.hour

注意：

• 对于星期一：day_of_week = 0，

• 星期二：day_of_week=1，

• …

• 星期天：day_of_week=6

创建日部分：

#day_part function
def day_part(hour):
    if hour in [4,5]:
        return "dawn"
    elif hour in [6,7]:
        return "early morning"
    elif hour in [8,9,10]:
        return "late morning"
    elif hour in [11,12,13]:
        return "noon"
    elif hour in [14,15,16]:
        return "afternoon"
    elif hour in [17, 18,19]:
        return "evening"
    elif hour in [20, 21, 22]:
        return "night"
    elif hour in [23,24,1,2,3]:
        return "midnight"

#Run function with apply method
df['date_issued:day_part'] = df['date_issued:hour'].apply(day_part)df.head()

为日期时间变量 issued_date 创建日部分。图片由作者提供

第二部分。创建布尔标志

如上例所示，我们可以从给定的日期时间变量中提取许多布尔标志（is_month_start、is_month_end、is_quarter_start、is_quarter_end、is_year_start、is_year_end、is_weekend）。下面的列表提供了几种可以使用 pandas 内置函数提取的组件，以及通过创建一些我们自己的函数来实现。

语法：

再次，我们可以使用 .dt 访问器提取许多布尔标志。

从 datetime 变量 issued_date 中提取的布尔标志。图像由作者提供。

#1
df['date_issued:is_year_start'] = df['date_issued'].dt.is_year_start#2
df['date_issued:is_quarter_start'] = df['date_issued'].dt.is_quarter_start#3
df['date_issued:is_month_start'] = df['date_issued'].dt.is_month_start#4
df['date_issued:is_month_end'] = df['date_issued'].dt.is_month_end

创建周末标志：

为 datetime 变量 issued_date 创建周末标志。图像由作者提供。

如果我们查看日历，会看到 2013 年 10 月 26 日是一个星期六——周末。

df['date_issued:is_weekend'] = np.where(df['date_issued:day_of_week'].isin([5,6]), 1,0)

第三部分：计算日期/时间差异

你提出的问题/分析通常会相对于另一个参考点。例如，

1. 用户在注册后多少天/小时内下了第一个订单？registration_date & first_order_date

2. 客户的投诉在多少天/小时内得到解决？complain_date & resolution_date

3. 从今天起，客户最近一次从你的网站上订购是什么时候？today & last_order_date

4. …等

在我们的示例数据集中，我们有两个列 date_last_payment 和 date_issued。让我们看看当我们仅仅计算这两个列的差异时会发生什么。

在 pandas 中计算时间差异。图像由作者提供。

Pandas 默认提供以‘天’为单位的差异。注意 dtype: timedelta64[ns]。

从 numpy 文档：

“因为 NumPy 在其核心没有物理量系统，timedelta64 数据类型被创建来补充 datetime64”

现在，如果我们只想要数字部分而不是整个字符串 947 days，我们可以使用 .dt 访问器做到这一点。

使用 .dt 访问器在 pandas 中计算时间差异。图像由作者提供。

不幸的是，我们不能以类似的方式获取月份。

使用 .dt 访问器在 pandas 中计算时间差异是不具扩展性的。图像由作者提供。

在这里，NumPy 的 timedelta64 非常有用。

语法：

为了获取发放贷款日期和最后支付日期之间的月份数，我们将编写如下代码：

使用 NumPy timedelta64 在 pandas 中计算时间差异。图像由作者提供。

(df['date_last_payment'] - df['date_issued'])/np.timedelta64(1, 'M')

timedelta64 可以接受以下参数来计算两个日期之间的差异：

• ‘D’ → 代表天数

• ‘W’ → 代表周

• ‘M’ → 代表月份

• ‘Y’ → 代表年份

• ‘h’ → 代表小时

额外提示！

你可以使用 fast_ml 创建所有这些日期时间特征

首先，安装 fast_ml 包

!pip install fast_ml — upgrade

然后，从 feature_engineering 模块导入工程日期时间特征的方法

from fast_ml.feature_engineering import FeatureEngineering_DateTime

现在，这与 sklearn 的其他变换器、预处理器的工作方式完全相同。

• 实例化

• 适配

• 转换

#Instantiate
dt_fe = FeatureEngineering_DateTime()#Fit
dt_fe.fit(df, datetime_variables=['date_issued'], 
          prefix = 'date_issued:')#Transform
df = dt_fe.transform(df)
df.head()

使用 Fast_ml 进行日期时间变量的特征工程。图片来源：作者。

屏幕截图中并未显示所有列。让我们只查看数据集的列。

df.columns---Output---
Index(['customer_id', 'disbursed_amount', 'interest', 'market', 'employment', 'time_employed', 'householder', 'income', 'date_issued', 'target', 'loan_purpose', 'number_open_accounts', 'date_last_payment', 'number_credit_lines_12',(Notice from here ------->)
'date_issued:year', 'date_issued:quarter', 'date_issued:month', 'date_issued:day', 'date_issued:day_of_week', 'date_issued:day_of_year', 'date_issued:weekofyear', 'date_issued:is_month_end', 'date_issued:is_month_start', 'date_issued:is_quarter_end', 'date_issued:is_quarter_start', 'date_issued:is_year_end', 'date_issued:is_year_start', 'date_issued:time', 'date_issued:hour', 'date_issued:minute', 'date_issued:second', 'date_issued:is_weekend', 'date_issued:day_part'],
dtype='object')

感谢阅读！！

• 如果你喜欢这个，请在 medium 上关注我 follow me on medium。

• 你的点赞是我写作的巨大鼓励，并帮助我写得更好。

• 有兴趣合作吗？让我们在 Linkedin 上联系。

• 请随时写下你的想法/建议/反馈。

• Kaggle 链接

• Fast_ml 链接

Notebook 可以在以下位置获得，包含完整功能的代码：

日期时间变量的特征工程

探索并运行 Kaggle Notebooks 中的机器学习代码 | 使用数据来自 loan_data](https://www.kaggle.com/nextbigwhat/feature-engineering-of-datetime-variables?scriptVersionId=61041780)

简介：Samarth Agrawal 是丰田的数据科学家，同时也是数据科学从业者和传播者。

原文。已获许可重新发布。

相关：

• 使用 fast.ai 进行快速特征工程

• 数值数据的特征工程

• 数据科学 101：归一化、标准化与正则化

相关主题

• 特征存储峰会 2022：关于特征工程的免费会议

• 机器学习中特征工程的实用方法

• 构建一个可处理的多变量特征工程管道

• 使用 RAPIDS cuDF 利用 GPU 进行特征工程

• 特征工程入门

• 机器学习中的替代特征选择方法

初学者特征工程

原文：www.kdnuggets.com/feature-engineering-for-beginners

图片由作者创建

介绍

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织 IT 需求

---

特征工程是机器学习管道中最重要的方面之一。它是创建和修改特征或变量以提高模型性能的实践。设计良好的特征可以将弱模型转变为强模型，通过特征工程，模型可以变得更强大和准确。特征工程充当数据集和模型之间的桥梁，提供模型有效解决问题所需的一切。

这是为新数据科学家、数据工程师和机器学习从业者准备的指南。本文的目标是传达基本的特征工程概念，并提供一套可以应用于实际场景的技术工具箱。我的目标是，通过本文，你将掌握足够的特征工程知识，以便能够将其应用于自己的数据集，从而全面准备好开始创建强大的机器学习模型。

了解特征

特征是我们观察到的现象的可测量特性。它们是构成数据的细节元素，模型根据这些元素进行预测。特征的例子可以包括年龄、收入、时间戳、经度、值，以及几乎任何可以以某种形式进行测量或表示的事物。

特征类型有很多种，主要包括：

• 数值特征：连续或离散的数值类型（例如，年龄、工资）

• 类别特征：表示类别的定性值（例如，性别、鞋码类型）

• 文本特征：单词或单词字符串（例如，“this”或“that”或“even this”）

• 时间序列特征：按时间顺序排列的数据（例如，股票价格）

特征在机器学习中至关重要，因为它们直接影响模型的预测能力。构造良好的特征能提高模型性能，而糟糕的特征则使得模型更难产生强有力的预测。特征选择和特征工程是机器学习过程中用于准备数据以供学习算法使用的预处理步骤。

特征选择和特征工程之间有区别，尽管它们各自都至关重要：

• 特征选择：从所有可用特征的集合中筛选出重要特征，从而减少维度并提高模型性能

• 特征工程：创建新特征并随之改变现有特征，以帮助模型表现得更好

通过仅选择最重要的特征，特征选择有助于保留数据中的信号，而特征工程则创建新的特征，以更好地建模结果。

特征工程中的基本技术

尽管我们可以使用多种基本特征工程技术，但我们将逐步介绍一些更重要且使用广泛的技术。

处理缺失值

数据集通常包含缺失信息。这可能会对模型的性能产生不利影响，因此，实施处理缺失数据的策略非常重要。常见的几种解决方法如下：

• 均值/中位数填补：用列的均值或中位数填补数据集中的缺失区域

• 众数填补：用同一列中最常见的条目填补数据集中的缺失位置

• 插值法：用周围数据点的值填补缺失的数据

这些填补方法应根据数据的性质以及方法可能对最终模型产生的效果来应用。

处理缺失信息对于保持数据集的完整性至关重要。以下是一个示例 Python 代码片段，演示了使用 pandas 库的各种数据填补方法。

import pandas as pd
from sklearn.impute import SimpleImputer

# Sample DataFrame
data = {'age': [25, 30, np.nan, 35, 40], 'salary': [50000, 60000, 55000, np.nan, 65000]}
df = pd.DataFrame(data)

# Fill in missing ages using the mean
mean_imputer = SimpleImputer(strategy='mean')
df['age'] = mean_imputer.fit_transform(df[['age']])

# Fill in the missing salaries using the median
median_imputer = SimpleImputer(strategy='median')
df['salary'] = median_imputer.fit_transform(df[['salary']])

print(df)

分类变量编码

记住，大多数机器学习算法最好（或仅能）处理数值数据，因此，分类变量通常必须映射到数值，以便这些算法能够更好地解读它们。最常见的编码方案如下：

• 独热编码：为每个类别生成单独的列

• 标签编码：为每个类别分配一个整数

• 目标编码：通过各类别的个别结果变量平均值对类别进行编码

对分类数据进行编码是许多机器学习模型理解数据的基础。正确的编码方法是根据具体情况选择的，包括使用的算法和数据集。

以下是一个使用pandas和scikit-learn元素对分类特征进行编码的示例 Python 脚本。

import pandas as pd
from sklearn.preprocessing import OneHotEncoder, LabelEncoder

# Sample DataFrame
data = {'color': ['red', 'blue', 'green', 'blue', 'red']}
df = pd.DataFrame(data)

# Implementing one-hot encoding
one_hot_encoder = OneHotEncoder()
one_hot_encoding = one_hot_encoder.fit_transform(df[['color']]).toarray()
df_one_hot = pd.DataFrame(one_hot_encoding, columns=one_hot_encoder.get_feature_names_out(['color']))

# Implementing label encoding
label_encoder = LabelEncoder()
df['color_label'] = label_encoder.fit_transform(df['color'])

print(df)
print(df_one_hot)

数据缩放和归一化

为了许多机器学习方法的良好表现，必须对数据进行缩放和归一化。有几种数据缩放和归一化的方法，例如：

• 标准化：将数据转换为均值为 0 和标准差为 1

• Min-Max 缩放：将数据缩放到一个固定范围，如 [0, 1]

• 鲁棒缩放：通过中位数和四分位数范围分别迭代缩放高值和低值

数据的缩放和归一化对确保特征贡献的公平性至关重要。这些方法使不同特征值对模型的贡献保持一致。

以下是一个使用scikit-learn的实现，展示了如何完成经过缩放和归一化的数据。

import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Sample DataFrame
data = {'age': [25, 30, 35, 40, 45], 'salary': [50000, 60000, 55000, 65000, 70000]}
df = pd.DataFrame(data)

# Standardize data
scaler_standard = StandardScaler()
df['age_standard'] = scaler_standard.fit_transform(df[['age']])

# Min-Max Scaling
scaler_minmax = MinMaxScaler()
df['salary_minmax'] = scaler_minmax.fit_transform(df[['salary']])

# Robust Scaling
scaler_robust = RobustScaler()
df['salary_robust'] = scaler_robust.fit_transform(df[['salary']])

print(df)

上述基本技术及其对应的示例代码为处理缺失数据、编码分类变量，以及使用强大的 Python 工具pandas和scikit-learn进行数据缩放和归一化提供了实用的解决方案。这些技术可以集成到你自己的特征工程过程中，以提升你的机器学习模型。

高级特征工程技术

现在我们将关注更高级的特征工程技术，并包含一些实现这些概念的 Python 示例代码。

特征创建

通过特征创建，生成或修改新特征以打造性能更好的模型。一些创建新特征的技术包括：

• 多项式特征：利用现有特征创建更高阶特征，以捕捉更复杂的关系

• 交互项：通过组合多个特征生成的特征，用于捕捉它们之间的交互作用

• 特定领域的特征生成：根据特定问题领域的复杂性设计的特征

创建具有调整意义的新特征可以大大提高模型性能。下一个脚本展示了如何利用特征工程将数据中的潜在关系揭示出来。

import pandas as pd
import numpy as np

# Sample DataFrame
data = {'x1': [1, 2, 3, 4, 5], 'x2': [10, 20, 30, 40, 50]}
df = pd.DataFrame(data)

# Polynomial Features
df['x1_squared'] = df['x1'] ** 2
df['x1_x2_interaction'] = df['x1'] * df['x2']

print(df)

降维

为了简化模型并提高其性能，减少模型特征的数量可能会有所帮助。实现这一目标的降维技术包括：

• PCA（主成分分析）：将预测变量转换为由线性独立模型特征组成的新特征集

• t-SNE（t-分布随机邻域嵌入）：用于可视化的降维

• LDA（线性判别分析）：寻找有效的模型特征组合，以解构不同的类别

为了缩小数据集的规模并保持其相关性，维度减少技术将有所帮助。这些技术旨在解决与数据相关的高维问题，如过拟合和计算需求。

接下来展示的是使用scikit-learn实现的数据缩减演示。

import pandas as pd
from sklearn.decomposition import PCA

# Sample DataFrame
data = {'feature1': [2.5, 0.5, 2.2, 1.9, 3.1], 'feature2': [2.4, 0.7, 2.9, 2.2, 3.0]}
df = pd.DataFrame(data)

# Use PCA for Dimensionality Reduction
pca = PCA(n_components=1)
df_pca = pca.fit_transform(df)
df_pca = pd.DataFrame(df_pca, columns=['principal_component'])

print(df_pca)

时间序列特征工程

对于基于时间的数据集，必须使用特定的特征工程技术，例如：

• 滞后特征：使用先前的数据点来推导模型预测特征

• 滚动统计：在数据窗口中计算数据统计量，如滚动均值

• 季节性分解：将数据划分为信号、趋势和随机噪声类别

与直接模型拟合相比，时间序列模型需要不同的增强。这些方法遵循时间依赖性和模式，使预测模型更加精确。

接下来还将展示使用pandas应用的时间序列特征增强演示。

import pandas as pd
import numpy as np

# Sample DataFrame
date_rng = pd.date_range(start='1/1/2022', end='1/10/2022', freq='D')
data = {'date': date_rng, 'value': [100, 110, 105, 115, 120, 125, 130, 135, 140, 145]}
df = pd.DataFrame(data)
df.set_index('date', inplace=True)

# Lag Features
df['value_lag1'] = df['value'].shift(1)

# Rolling Statistics
df['value_rolling_mean'] = df['value'].rolling(window=3).mean()

print(df)

上述示例展示了通过使用pandas和scikit-learn的先进特征工程技术的实际应用。通过应用这些方法，你可以提高模型的预测能力。

实用技巧和最佳实践

在进行特征工程过程中，有一些简单但重要的技巧需要记住。

• 迭代：特征工程是一个试错过程，每次迭代都会变得更好。测试不同的特征工程想法，以找到最佳的特征集。

• 领域知识：在创建特征时，利用那些对主题了解深入的专家的知识。有时，领域特定的知识能够捕捉到微妙的关系。

• 特征的验证和理解：通过了解哪些特征对模型最重要，你可以做出重要决策。确定特征重要性的工具包括：

  • SHAP（Shapley 加性解释）：帮助量化每个特征在预测中的贡献

  • LIME（局部可解释模型无关解释）：以简单的语言展示模型预测的含义

为了获得既良好又简单易懂的结果，复杂性和可解释性的最佳混合是必要的。

结论

本简短指南涵盖了基本的特征工程概念，以及基础和高级技术、实用建议和最佳实践。涵盖了许多人认为最重要的特征工程实践——处理缺失信息、类别数据编码、数据标准化和新特征创建。

特征工程是一个随着执行而不断改进的实践，我希望你能从中获得一些提升数据科学技能的经验。我鼓励你将这些技术应用到自己的工作中，并从你的经验中学习。

请记住，虽然具体的百分比因人而异，但任何机器学习项目的大部分时间都花在数据准备和预处理阶段。特征工程是这个漫长阶段的一部分，因此应该以其应有的重要性来看待。学习将特征工程视为建模过程中的一个辅助手段，应能让新手更容易理解。

祝工程愉快！

Matthew Mayo (@mattmayo13) 拥有计算机科学硕士学位和数据挖掘研究生文凭。作为KDnuggets与Statology的主编，以及Machine Learning Mastery的贡献编辑，Matthew 的目标是让复杂的数据科学概念变得易于理解。他的职业兴趣包括自然语言处理、语言模型、机器学习算法和探索新兴的人工智能。他致力于在数据科学社区中普及知识。Matthew 从 6 岁开始编程。

更多相关内容

• 2022 年特征存储峰会：关于特征工程的免费会议

• 为多变量时间序列构建可处理的特征工程管道

• 使用 RAPIDS cuDF 在特征工程中利用 GPU

• 机器学习中特征工程的实用方法

• 初学者免费数据工程课程

• 实时 AI 与机器学习的特征存储

特征工程如何帮助你在 Kaggle 竞赛中表现出色 – 第一部分

原文：www.kdnuggets.com/2017/06/feature-engineering-help-kaggle-competition-1.html

作者：Gabriel Moreira, CI&T.

现在是 2017 年 1 月 18 日午夜，Outbrain 点击预测机器学习竞赛刚刚结束。这是三个月半的加班工作。当我滚动浏览排行榜页面时，我发现我的名字排在第 19 位，这在近 1000 名参赛者中位于前 2%。对于我决定认真投入的第一场 Kaggle 竞赛来说，这已经很不错了！

我能够取得好成绩的原因之一是因为 Google Cloud Platform (GCP) 让我的工作变得更轻松，让我可以专注于数据。现在，我将带你走过我的旅程！

挑战

Kaggle 竞赛由 Outbrain 赞助，Outbrain 每月在数千个网站上提供 2500 亿条个性化推荐，将相关内容与读者匹配。在这场竞赛中，“Kagglers” 被挑战预测用户点击的广告和其他形式的赞助内容。

Outbrain 维护着一个出版商和广告商的网络。例如，在下图中，付费内容（广告）展示在 CNN（出版商）的新闻页面上。

来自 Outbrain 点击预测竞赛。

在这场竞赛中，参赛者被要求根据预测的点击可能性准确排名推荐内容。CTR（点击率）预测对于电子商务和广告等行业非常相关，因为用户转化的微小改进可能会带来显著的利润增长，同时提供更好的用户体验。

数据集和基础设施

其中一个竞赛挑战是处理庞大的数据集：20 亿页面浏览量和大约 1700 万条点击记录，来自 7 亿唯一用户，涉及 560 个网站。数据集中包含了从 2016 年 6 月 14 日到 2016 年 6 月 28 日期间，在多个出版网站上观察到的用户页面浏览量和点击量样本。

考虑到这是一个大型关系数据库，有些表格无法“在内存中”加载，Apache Spark 非常适合数据探索和快速分布式预处理。Google Cloud Platform (GCP) 提供了我所需的主要存储和分布式处理组件。

使用 Google Cloud Dataproc 管理服务部署 Spark 集群非常容易。我发现一个由 1 个主节点和 8 个 “n1-highmem-4” 实例类型（约 4 个 CPU 核心和 16 GB RAM）组成的集群能够在大约一个小时内处理所有竞赛数据，包括连接大表、转换特征和存储向量。

我的主要开发环境是 Jupyter notebooks，这是一个非常高效的 Python 接口。这个 GCP 教程描述了如何在 Dataproc 主节点中轻松设置 Jupyter，使 PySpark 库可供使用。

Dataproc Spark 集群使用 Google Cloud Storage（GCS）作为分布式文件系统，而不是默认的 HDFS。作为一种托管存储，它使得在实例之间传输和存储大型文件变得简单。Spark 作业可以直接从 GCS 使用数据进行分布式处理。

我还使用了一些机器学习框架（FTRL、FFM、GBM 等），这些框架在并行化计算上工作——而不是分布式计算——需要大量的 CPU 核心和 RAM 以处理大数据集。在 Google Compute Engine (GCE) 上部署的 ‘n1-highmem-32’ 实例（32 个 CPU 和 256 GB RAM）使得在不到一个小时内运行作业成为可能。由于它们的处理非常 I/O 密集，我为实例附加了一个 SSD 硬盘，以避免瓶颈。

在 这篇文章系列的第二部分 中，我将更多地讨论这些机器学习模型。

第一个方法

竞赛评估指标是 MAP@12（12 的平均精度均值），它衡量广告排名的质量。换句话说，这个指标评估模型是否对实际点击的广告进行了良好的排名。

常识认为广告的平均受欢迎程度可能是新点击的一个良好预测因素。因此，主要的思路是按照广告的点击率（#clicks / #views）对用户展示的广告进行排序。

在以下的 Python 代码片段中，我展示了如何使用 PySpark 基于训练集（click_trains.csv）计算广告点击率（CTR）。这个 CSV 文件包含超过 8700 万行，并存储在 GCS 上。完整的脚本在一个有 8 个工作节点的 Dataproc Spark 集群中运行时间不到 30 秒。

将训练数据（click_train.csv）加载到 Spark DataFrame 中并获取行数。获取不同广告的数量。

在下一个代码片段中，我定义了一个新的 DataFrame，通过 ad_id 分组并聚合点击数的总和和观看数的计数。CTR 的处理是通过一个名为 ctr_udf 的 UDF（用户定义函数）完成的。代码片段的输出是一个包含 10 个 ad_ids 及其各自 #clicks、#views 和 CTR 的样本表格。

计算广告的平均 CTR。

为了提高 CTR 的置信度，我们可以只考虑浏览次数超过五次的广告。使用collectAsMap()操作，将分布式集合转换为内存中的查找字典，其中键是 ad_id，值是相应的平均 CTR。

这是大多数竞争者提交的基线，即使没有任何机器学习算法，也能给你 MAP@12 的0.637。作为参考，官方基线竞赛基于按广告 ID 排名（类似随机方法），MAP@12 为0.485。因此，这种初步方法在点击预测中实际上做得很好。

数据分析

像往常一样，在应用任何机器学习技术之前，分析数据并制定关于哪些特征和算法对于解决问题有用的假设是非常重要的。我实现了一个 EDA（探索性数据分析），使用 PySpark 揭示了最大的 数据集（page_views.csv ~ 100 GB）。

我的EDA Kernel，展示了如何使用 Python、Spark SQL 和 Jupyter notebooks 在 Dataproc 中分析竞争中最大的 数据集，已与其他竞争者分享，并成为第二个最受投票的贡献（金牌）。根据我的 Kernel 评论，看来许多 Kagglers 正在考虑尝试 Google Dataproc 和 Spark 用于机器学习竞赛。

我的分析帮助我弄清楚了如何从数据集中提取价值，通过将其与训练数据和测试数据（events.csv）结合。例如，在下图所示的累积图中，我们可以看到 65%的用户只有一次页面浏览，77%的用户最多有两次浏览，89%的用户最多有五次浏览。

用户最多拥有 N 次页面浏览的累积百分比。

这是一个典型的“冷启动”场景，我们对大多数用户几乎一无所知，需要预测他们会点击哪些推荐内容。

一般来说，传统的推荐系统技术如协同过滤和基于内容的过滤在这种情况下会失败。因此，我的策略是采用能够利用用户事件和推荐的赞助内容的上下文信息的机器学习算法。

特征工程

特征工程指的是选择或创建适用于机器学习模型的正确特征的关键步骤。通常，根据数据的复杂性，这可能占总工作量的 80%。

在下图中，我展示了竞争的原始数据模型，按数据类型对特征进行着色。

Outbrain 点击预测大型关系型数据库。

所有的分类字段最初都被表示为整数。根据机器学习算法的不同，作为序数值表示的 id 可能会让模型认为某个类别比另一个类别更重要。例如，如果阿根廷的 id 是 1，巴西的 id 是 2，算法可能会推断出巴西的代表性是阿根廷的两倍。为了解决这个问题，常用的方法是像独热编码（OHE）这样的技术，其中每个分类字段都被转换为一个稀疏向量。在稀疏向量中，所有位置的值均为零，只有对应于 id 值的位置有非零值。

另一种处理具有大量唯一值的分类特征的流行技术是特征哈希，它使用哈希函数将类别映射到固定长度的向量。与 OHE 相比，这种方法提供了更低的稀疏度和更高的压缩率，并且对新出现和稀有的分类值（例如之前未见过的用户代理）处理得很好。它也可能在将多个特征映射到相同的向量位置时导致一些冲突，但机器学习算法通常足够健壮，能够处理这些冲突。我在我的方法中使用了这两种技术。

我还对数值标量特征使用了‘分箱’。一些特征非常嘈杂，我们最好通过这种转换减少次要观测误差或差异的影响。例如，我将事件‘小时’分箱为早晨、中午、下午、晚上等，因为我的假设是，如果在上午 10 点或 11 点观察，用户行为不会有太大不同。

对于长尾分布的变量，比如user_views_count，大多数用户只有一个页面浏览记录，而很少有高浏览量的用户。应用诸如 log(1 + #views)这样的转换对平滑分布是有用的。一个有 1,000 次页面浏览的用户可能与一个有 500 次浏览的用户差异不大，他们在这个上下文中都是相似的离群点。

标准化和归一化对于大多数使用优化技术如梯度下降的机器学习算法也很重要。一般来说，只有基于决策树的模型能够处理不同尺度和方差的原始数值特征。

我使用的主要特征工程技术的更详细介绍可以在这份幻灯片中找到。

根据我从 EDA 中获得的见解和假设，我成功地为我的机器学习模型创建和转换了特征，除了原始的竞赛数据中提供的特征。以下是其中的一些特征。

用户画像

• user_has_already_viewed_doc - 对于推荐给用户的每一条内容，验证用户是否之前已经访问过该页面。

• user_views_count - 热衷阅读的用户与其他用户行为有何不同？让我们添加这个特征，让机器学习模型来猜测。

• user_views_categories, user_views_topics, user_views_entities - 基于用户之前查看过的文档的类别、主题和实体的用户画像向量（按置信度和 TF-IDF 加权），用于在基于内容的过滤方法中建模用户偏好。

• user_avg_views_of_distinct_docs - 比率(#user_distinct_docs_views / #user_views)，表示用户重新阅读之前访问过的页面的频率。

广告与文档

• doc_ad_days_since_published, doc_event_days_since_published - 自广告文档在特定用户访问中发布以来经过的天数。一般假设是新内容对用户更相关。但是，如果你在阅读一篇旧文章，你可能对其他旧文章感兴趣。

• doc_avg_views_by_distinct_users_cf - 广告文档被不同用户的平均页面浏览次数。这是一个人们通常会返回的网页吗？

• ad_views_count, doc_views_count - 一个文档或广告有多受欢迎？

事件

• event_local_hour (binned), event_weekend — 事件时间戳为 UTC-4，因此我处理了事件地理位置以获取时区并调整用户的本地时间。时间段被分为早晨、下午、正午、傍晚、夜晚。还包含了一个指示是否为周末的标志。假设时间会影响用户阅读的内容类型。

• event_country, event_country_state - 字段event_geolocation被解析以提取用户在页面访问中的国家和州。

• ad_id, doc_event_id, doc_ad_id, ad_advertiser, … — 所有原始类别字段都进行了独热编码以供模型使用，生成了大约 126,000 个特征。

平均点击率

• avg_ctr_ad_id, avg_ctr_publisher_id, avg_ctr_advertiser_id, avg_ctr_campain_id, avg_ctr_entity_id_country … - 给定某些类别组合和 CTR 置信度的平均点击率(#clicks / #views)（详细信息请参见Part II帖子）。例如：P(click | category01, category02)。

基于内容的相似性

这些特征使用了TF-IDF技术来构建用户和着陆页面的画像向量，分别建模用户偏好和上下文。使用余弦相似度来比较画像与候选广告文档的相似性，这是一种非常流行的信息检索方法，基于两个向量之间的角度，忽略其大小。

• user_doc_ad_sim_categories, user_doc_ad_sim_topics, user_doc_ad_sim_entities - 用户画像与广告文档画像向量（TF-IDF）之间的余弦相似度。

• doc_event_doc_ad_sim_categories, doc_event_doc_ad_sim_topics, doc_event_doc_ad_sim_entities - 事件文档（着陆页上下文）与广告文档概况向量（TF-IDF）之间的余弦相似度。

我们基于一些关于影响用户点击赞助内容决策的假设生成了特征。现在数据已准备好用于一些机器学习模型！

下一步…

在第二部分的系列文章中，我将介绍交叉验证策略、实施的机器学习模型以及‘集成’技术，帮助你在比赛排行榜中冲刺到前 2%。

请继续关注！

个人简介：加布里埃尔·莫雷拉 是一位热衷于用数据解决问题的科学家。他是 Instituto Tecnológico de Aeronáutica - ITA 的博士生，研究推荐系统和深度学习。目前，他是 CI&T 的首席数据科学家，领导团队利用机器学习解决客户在大规模和非结构化数据中的挑战性问题。

原文。已获授权转载。

相关：

• 如何在你的第一次 Kaggle 比赛中排名前 10%

• 在深度学习中，架构工程是新的特征工程

• 机器学习速成课程：第一部分

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道。

2. 谷歌数据分析专业证书 - 提升你的数据分析能力

3. 谷歌 IT 支持专业证书 - 支持组织的 IT

---

更多相关内容

• 特征存储峰会 2022：关于特征工程的免费会议

• 数据科学项目，帮助你解决实际问题

• 5 种稀有的数据科学技能，帮助你获得就业机会

• 生成型 AI 如何帮助你改进数据可视化图表

• 免费 Python 资源助你成为专家

• 等级系统如何帮助预测 AI 成本

特征工程如何帮助你在 Kaggle 竞赛中表现出色 - 第三部分

原文：www.kdnuggets.com/2017/07/feature-engineering-help-kaggle-competition-3.html

作者：Gabriel Moreira，CI&T。

在第一部分和第二部分中，我介绍了Outbrain 点击预测机器学习竞赛以及我应对挑战的初步任务。我展示了用于探索性数据分析、特征工程、交叉验证策略和基本统计与机器学习的基线预测模型的主要技术。

在这一系列的最后一篇文章中，我描述了如何使用更强大的机器学习算法解决点击预测问题，以及将我推上排行榜第 19 位（前 2%）的集成技术。

正则化跟随者

预测点击率（CTR）的一个流行方法是使用正则化跟随者（FTRL）优化器的逻辑回归，这种方法已被谷歌用于生产环境中，每天预测数十亿次事件，使用相应的大特征空间。

这是一个线性模型，具有懒惰的系数（权重）表示方式，并且与 L1 正则化结合使用时，会导致非常稀疏的系数向量。这种稀疏性特征缩减了内存使用，使得对于具有数十亿维度的特征向量具有良好的可扩展性，因为每个实例通常只有几百个非零值。FTRL 通过从磁盘或网络中流式传输示例来提供对大数据集的高效训练——每个训练示例只需处理一次（在线学习）。

我尝试了两种不同的 FTRL 实现，分别在Kaggler和Vowpal Wabbit（VW）框架中可用。

对于 CTR 预测，理解特征之间的交互是非常重要的。例如，来自“Nike”广告商的广告的平均转化率可能会有所不同，这取决于显示广告的出版商（例如 ESPN vs. Vogue）。

我考虑了所有分类特征来训练Kaggler的 FTRL 模型。特征交互选项被启用，这意味着对于所有可能的两个特征组合，特征值被相乘并哈希（阅读关于特征哈希的内容，请参见第一篇文章），形成一个 2²⁸维度的稀疏特征向量。这是我最慢的模型，训练时间超过了 12 小时。但我的 LB 分数跃升至 0.67659，这是方法 #6的结果。

我还在VW上尝试了 FTRL，这是一个在 CPU 和内存资源使用方面非常快速和高效的框架。输入数据再次为分类特征，并添加了一些选定的数值分箱特征（阅读关于特征分箱的内容，请参见第一篇文章）。我的最佳模型在两小时内训练完成，并在方法 #7中获得了 0.67512 的 LB 分数。虽然准确率稍低，但比之前的模型快得多。

在第二个 FTRL 模型上使用 VW 时，我利用 VW 的超参数配置了仅一部分特征（命名空间）的交互（特征配对）。在这种情况下，交互仅配对了分类特征和一些选定的数值特征（没有分箱转换）。这一变化使得在方法 #8中取得了更好的结果：0.67697。

所有这三个 FTRL 模型都被集成到我的最终提交中，具体内容将在接下来的部分中描述。

领域感知因式分解机

一个最近的因式分解机变体，领域感知因式分解机 (FFM) 在 2014 年的两个 CTR 预测竞赛中取得了胜利。FFM 尝试通过学习每个特征交互对的潜在因子来建模特征交互。该算法以LibFFM框架的形式提供，并被许多竞争者使用。LibFFM 对大数据集的并行处理和内存使用非常高效。

在方法 #9中，我使用了分类特征，并将配对交互哈希到 700,000 维度。我的最佳模型仅用 37 分钟训练完成，并且成为了我的最佳单一模型，LB 分数为0.67932。

在方法 #10中，输入数据除了分类特征外，还包含了一些选定的数值分箱特征。训练数据增加到 214 分钟，LB 分数为0.67841。

对于方法 #11，我尝试训练一个 FFM 模型，仅考虑训练集中最后 30%的事件，假设在最后几天的训练可以提高对测试集未来两天（50%）的预测。LB 得分为0.6736，提高了这两天的准确性，但降低了测试集中之前事件的准确性。

在机器学习项目中，某些有前景的方法最终可能会失败。这发生在一些 FFM 模型上。我尝试将学习从 GBDT 模型转移到带有叶子编码的 FFM 模型，这是一种在 Criteo 竞赛中获胜的方法。然而，FFM 模型的准确性下降，可能是因为 GBDT 模型在这个上下文中不够准确，增加了更多的噪声而非信号。

另一个不成功的方法是训练独立的 FFM 模型，针对测试集中事件更多的地理区域，比如一些国家（美国 ~ 80%，加拿大 ~ 5%，英国 ~ 5%，澳大利亚 ~ 2%，其他 ~ 8%）和美国州（加州 ~ 10%，德州 ~ 7%，佛罗里达 ~ 5%，纽约 ~ 5%）。为了生成预测，每个测试集事件被发送到专门针对这些地区的模型。专门针对美国的模型在预测该地区的点击时表现良好，但在其他地区准确性较低。因此，使用全球范围的 FFM 模型表现更好。

我在最终的集成中使用了三种选择的 FFM 方法，接下来我将展示。

集成方法

集成方法是将不同模型的预测结果结合起来，以提高准确性和泛化能力。模型预测的相关性越小，集成的准确性可能越好。集成的主要思想是，单个模型不仅受信号影响，还受随机噪声的影响。通过结合多个模型的预测，可以取消大量噪声，从而提高模型的泛化能力，如下所示。

来自竞赛不要过拟合

一种简单而有效的集成方法是通过平均合并模型预测。对于这次竞赛，我测试了许多加权平均类型，如算术、几何、调和和排序平均等。

我能找到的最佳方法是使用加权算术平均的logit（sigmoidal logistic 的逆）预测 CTR（概率），如公式 1 所示。它考虑了三种选择的 FFM 模型（方法 #9、#10 和 #11）以及一个 FTRL 模型（方法 #6）的预测。这种平均方法使我在方法 #12中得到了0.68418的 LB 得分，比我最好的单一模型（方法 #10，得分为 0.67932）有了显著提升。

方程 1 — 通过模型预测的 logit 加权平均进行集成

那时，比赛提交截止日期仅剩几天。我选择在剩余时间里使用学习排序模型进行集成，以合并最佳模型的预测。

该模型是一个GBDT，具有 100 棵树，并使用XGBoost的排名目标。这个集成模型考虑了最佳的 3 个 FFM 模型和 3 个 FTRL 模型的预测以及 15 个精选的工程数值特征（如用户浏览次数、用户偏好相似性和按类别的平均点击率）。

该集成层仅使用验证集数据进行训练（如第二篇文章中所述），在一种称为Blending的设置中。这样做的原因是，如果训练集的预测也被集成模型考虑，它会优先考虑过拟合的模型，从而降低其对测试集的泛化能力。在最后一天的比赛中，方法 #13 给了我最佳的公共 LB 得分（0.68688）。比赛结束后，我的私人 LB 得分被揭示（0.68716），让我在最终排行榜上保持在第 19 位，如下图所示。

Kaggle 的 Outbrain 点击预测最终排行榜

我没有跟踪确切的提交日期，但下图展示了我在比赛期间 LB 得分的演变情况。可以看出，第一次提交时得分有很大的跃升，但之后的改进变得更加困难，这在机器学习项目中是很常见的。

我在比赛期间的方法的 LB 得分

结论

我从这次比赛中学到的一些东西包括：

1. 良好的交叉验证策略对于竞争至关重要。

2. 应该花费大量时间进行特征工程。在数据集上添加新特征往往需要更多的努力和时间。

3. 哈希是稀疏数据的必备方法。实际上，在简单性和效率方面，它的表现优于独热编码（OHE）。

4. OHE 类别特征对于决策树集成并不理想。根据竞争对手分享的经验，树集成使用原始类别值（id）并且树木足够多时表现更好，因为这将减少特征向量的维度，提高随机特征集包含更多预测特征的机会。

5. 测试许多不同的框架对学习很有帮助，但通常需要大量时间来将数据转换为所需格式、阅读文档和调整超参数。

6. 阅读关于主要技术（FTRL 和 FFM）的科学论文对于调整超参数非常重要。

7. 研究论坛帖子、公共 Kernel（共享代码）以及竞争者分享的过去解决方案是学习的好方法，对比赛至关重要。每个人都应该有所回馈！

8. 基于平均的集成方法大大提高了准确性，与机器学习模型融合提升了标准，堆叠是必须的。我没有时间探索堆叠，但根据其他竞争者的说法，使用固定折叠上的外部折叠预测增加了用于集成训练的可用数据（完整训练集），并提高了最终集成的准确性。

9. 不应在比赛最后时刻才生成提交文件！

Kaggle 就像是前沿机器学习的大学，对于那些决定接受挑战并从过程中和同伴中学习的人来说。这是一次非常有趣的经历，能够与世界级数据科学家竞争和学习。

谷歌云平台在这个过程中是一个很棒的合作伙伴，提供了所有必要的工具来克服大数据和分布式计算的难关，而我的注意力和努力则集中在登顶山峰上。

个人简介： 加布里埃尔·莫雷拉 是一位热衷于利用数据解决问题的科学家。他是航空技术学院（Instituto Tecnológico de Aeronáutica - ITA）的博士生，研究推荐系统和深度学习。目前，他是 CI&T 的首席数据科学家，领导团队利用机器学习解决客户的挑战性问题，处理大规模和非结构化数据。

原文。经许可转载。

相关：

• 特征工程如何帮助你在 Kaggle 比赛中表现出色 – 第一部分

• 特征工程如何帮助你在 Kaggle 比赛中表现出色 – 第二部分

• 独家：对杰里米·霍华德关于深度学习、Kaggle、数据科学等的采访

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持组织的 IT 需求

---

相关阅读

• 特征存储峰会 2022：关于特征工程的免费会议

• 数据科学项目，帮助你解决实际问题

• 5 种稀有的数据科学技能，能帮助你找到工作

• 生成式人工智能如何帮助你改进数据可视化图表

• 免费 Python 资源，帮助你成为专家

• 等级系统如何帮助预测 AI 成本

数值数据的特征工程

原文：www.kdnuggets.com/2020/09/feature-engineering-numerical-data.html

评论

数值数据几乎是一个福音。为什么说几乎呢？因为它已经是机器学习模型可以处理的格式。然而，如果我们将其翻译成易于理解的术语，仅仅因为一本博士级教材是用英语写的——我会说、读和写英语——并不意味着我能够充分理解这本教材以得出有用的见解。使教材对我有用的，应该是它以一种考虑到我心理模型假设的方式总结最重要的信息，比如“数学是一种神话”（顺便说一下，我现在已经不再这样看待了，因为我真的开始享受数学了）。同样，一个好的特征应该能够代表数据的显著方面，并且符合机器学习模型所做的假设。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的轨道。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT 部门

---

特征工程是从原始数据中提取特征并将其转换为机器学习模型可以处理的格式的过程。通常需要进行转换以降低建模难度并提升模型结果。因此，工程化数值数据的技术是数据科学家（机器学习工程师也一样）必须掌握的基本工具。

“数据就像是机器学习的原油，这意味着它必须被提炼成特征——预测变量——才能对训练模型有用。” — Will Koehrsen

在追求精通的过程中，重要的是要注意，仅仅知道一个机制如何工作以及它能做什么是不够的。精通意味着知道某事如何完成，对基本原理有直觉，并具备在面对挑战时快速选择正确工具的神经连接。这不会仅仅通过阅读这篇文章来获得，而是通过有意识的练习来实现，本文将为你提供这些技术背后的直觉，以便你理解如何以及何时应用它们。

“数据中的特征将直接影响你使用的预测模型以及你能取得的结果。” — 杰森·布朗利

注意：你可以在我的 Github 页面 找到用于本文的代码。

可能会有数据收集到一个特征上，这个特征是累积的，因此具有无限的上限。这种类型的连续数据的例子可能是一个跟踪系统，监控我所有博客帖子每日收到的访问次数。这种数据容易吸引异常值，因为可能会有一些不可预测的事件影响我文章的总流量。例如，有一天，人们可能决定他们想进行数据分析，因此我关于 有效数据可视化 的文章当天可能会出现激增。换句话说，当数据可以快速且大量收集时，那么它很可能包含一些需要工程处理的极端值。

处理这种情况的一些方法包括：

量化

这种方法通过将数据值分组到区间中来包含数据的尺度。因此，量化将连续值映射到离散值，从概念上讲，可以将其视为有序的区间序列。为了实现这一点，我们必须考虑创建区间的宽度，这些解决方案分为两类：固定宽度区间或自适应区间。

注意：这对线性模型特别有用。在基于树的模型中，这并不有用，因为基于树的模型会自行进行分割。

在固定宽度的情况下，值被自动或自定义设计为将数据分割成离散的区间——这些区间也可以是线性缩放或指数缩放的。一个常见的例子是将人的年龄按十年间隔分区，例如区间 1 包含 0–9 岁，区间 2 包含 10–19 岁，等等。

注意，如果值跨越了很大的数值范围，那么一个更好的方法可能是将值分组为常数的幂，例如 10 的幂：0–9、10–99、100–999、1000–9999。注意分箱宽度呈指数增长，因此在 1000–9999 的情况下，分箱宽度为 O(10000)，而 0–9 为 O(10)。取计数的对数以将计数映射到数据的分箱中。

import numpy as np 

#15 random integers from the "discrete uniform" distribution
ages = np.random.randint(0, 100, 15)

#evenly spaced bins
ages_binned = np.floor_divide(ages, 10)

print(f"Ages: {ages} \nAges Binned: {ages_binned} \n")
>>> Ages: [97 56 43 73 89 68 67 15 18 36  4 97 72 20 35]
Ages Binned: [9 5 4 7 8 6 6 1 1 3 0 9 7 2 3]

#numbers spanning several magnitudes
views = [300, 5936, 2, 350, 10000, 743, 2854, 9113, 25, 20000, 160, 683, 7245, 224]

#map count -> exponential width bins
views_exponential_bins = np.floor(np.log10(views))

print(f"Views: {views} \nViews Binned: {views_exponential_bins}")
>>> Views: [300, 5936, 2, 350, 10000, 743, 2854, 9113, 25, 20000, 160, 683, 7245, 224]
Views Binned: [2\. 3\. 0\. 2\. 4\. 2\. 3\. 3\. 1\. 4\. 2\. 2\. 3\. 2.]

当计数之间存在较大间隙时，自适应分箱更合适。当计数值之间存在较大差距时，一些固定宽度的分箱可能会为空。

要进行自适应分箱，我们可以利用数据的分位数——将数据划分为相等部分的值，例如中位数。

import pandas as pd

#map the counts to quantiles (adaptive binning)
views_adaptive_bin = pd.qcut(views, 5, labels=False)

print(f"Adaptive bins: {views_adaptive_bin}")
>>> Adaptive bins: [1 3 0 1 4 2 3 4 0 4 0 2 3 1]

幂变换

我们已经看到一个例子：对数变换是方差稳定变换家族的一部分，这些变换被称为幂变换。维基百科将幂变换描述为“用于稳定方差，使数据更接近正态分布，提高变量之间的皮尔逊相关系数等关联测量的有效性，并用于其他数据稳定化过程的技术。”

为什么我们要将数据转换为符合正态分布？这是个好问题！你可能希望使用参数模型——一种对数据做出假设的模型——而不是非参数模型。当数据呈正态分布时，参数模型非常强大。然而，在某些情况下，我们的数据可能需要一些帮助，以展现正态分布的美丽钟形曲线。例如，数据可能存在偏斜，因此我们应用幂变换以帮助特征看起来更像高斯分布。

下面的代码利用了数据科学框架，如 pandas、scipy 和 numpy，来演示幂变换，并使用 Plotly.py 框架进行交互式图表的可视化。使用的数据集是House Prices: Advanced regression techniques来自 Kaggle，你可以轻松下载（点击此处访问数据）。

import numpy as np
import pandas as pd
from scipy import stats
import plotly.graph_objects as go
from plotly.subplots import make_subplots

df = pd.read_csv("../data/raw/train.csv")

# applying various transformations
x_log = np.log(df["GrLivArea"].copy()) # log 
x_square_root = np.sqrt(df["GrLivArea"].copy()) # square root x_boxcox, _ = stats.boxcox(df["GrLivArea"].copy()) # boxcox
x = df["GrLivArea"].copy() # original data

# creating the figures
fig = make_subplots(rows=2, cols=2,
                    horizontal_spacing=0.125,
                    vertical_spacing=0.125,
                    subplot_titles=("Original Data",
                                    "Log Transformation",
                                    "Square root transformation",
                                    "Boxcox Transformation")
                    )

# drawing the plots
fig.add_traces([
                go.Histogram(x=x,
                             hoverinfo="x",
                             showlegend=False),
                go.Histogram(x=x_log,
                             hoverinfo="x",
                             showlegend=False),
                go.Histogram(x=x_square_root,
                             hoverinfo="x",
                             showlegend=False),
                go.Histogram(x=x_boxcox,
                             hoverinfo="x",
                             showlegend=False),
               ],
               rows=[1, 1, 2, 2],
               cols=[1, 2, 1, 2]
)

fig.update_layout(
    title=dict(
               text="GrLivArea with various Power Transforms",
               font=dict(
                         family="Arial",
                         size=20)),
    showlegend=False,
    width=800,
    height=500)

fig.show() # display figure

图 1：可视化原始数据和各种幂变换。

注意：Box-Cox 变换仅在数据为非负数时有效

“这些中哪个最好？你无法事先知道。你必须尝试它们并评估结果，以实现你的算法和性能指标。” — 杰森·布朗利

特征缩放

顾名思义，特征缩放（也称为特征归一化）涉及到改变特征的尺度。当数据集中各特征的尺度差异很大时，敏感于输入特征尺度的模型（如线性回归、逻辑回归、神经网络）将会受到影响。确保特征在相似的尺度内是至关重要的。而像树模型（如决策树、随机森林、梯度提升）这样的模型不关心尺度。

缩放特征的常见方法包括最小-最大缩放、标准化和 L²归一化。以下是简要介绍及其在 Python 中的实现。

最小-最大缩放 - 特征被缩放到一个固定范围（通常在 0 到 1 之间），这意味着我们将减少标准差，从而抑制异常值对特征的影响。其中 x 是实例的个体值（如，个人 1，特征 2），max(x)，min(x)是特征的最大值和最小值 — 见图 2。有关更多信息，请参见sklearn 文档。

图 2：最小-最大缩放的公式。

标准化 - 特征值将被重新缩放，以符合正态分布的性质，其中均值为 0，标准差为 1。为此，我们从特征实例值中减去特征的均值（在所有实例上计算），然后除以方差 — 见图 3。有关标准化，请参阅sklearn 文档。

图 3：标准化的公式。

L² 归一化 - 该技术将原始特征值除以 l²范数（也称为欧几里得距离）— 图 4 中的第二个公式。L²范数取所有实例中特征集值的平方和。有关 L²范数，请参阅 sklearn 的文档（注意，还可以通过将 norm 参数设置为"l1"来进行 L¹归一化）。

图 4：L² 归一化的公式。

特征缩放效果的可视化将更好地展示发生了什么。为此，我使用了可以从 sklearn 数据集中导入的葡萄酒数据集。

import pandas as pd
from sklearn.datasets import load_wine
from sklearn.preprocessing import StandardScaler, MinMaxScaler, Normalizer
import plotly.graph_objects as go

wine_json= load_wine() # load in dataset

df = pd.DataFrame(data=wine_json["data"], columns=wine_json["feature_names"]) # create pandas dataframe

df["Target"] = wine_json["target"] # created new column and added target labels

# standardization
std_scaler = StandardScaler().fit(df[["alcohol", "malic_acid"]])
df_std = std_scaler.transform(df[["alcohol", "malic_acid"]])

# minmax scaling
minmax_scaler = MinMaxScaler().fit(df[["alcohol", "malic_acid"]])
df_minmax = minmax_scaler.transform(df[["alcohol", "malic_acid"]])

# l2 normalization
l2norm = Normalizer().fit(df[["alcohol", "malic_acid"]])
df_l2norm = l2norm.transform(df[["alcohol", "malic_acid"]])

# creating traces
trace1 = go.Scatter(x= df_std[:, 0],
                    y= df_std[:, 1],
                    mode= "markers",
                    name= "Standardized Scale")

trace2 = go.Scatter(x= df_minmax[:, 0],
                    y= df_minmax[:, 1],
                    mode= "markers",
                    name= "MinMax Scale")

trace3 = go.Scatter(x= df_l2norm[:, 0],
                    y= df_l2norm[:, 1],
                    mode= "markers",
                    name= "L2 Norm Scale")

trace4 = go.Scatter(x= df["alcohol"],
                    y= df["malic_acid"],
                    mode= "markers",
                    name= "Original Scale")

layout = go.Layout(
         title= "Effects of Feature scaling",
         xaxis=dict(title= "Alcohol"),
         yaxis=dict(title= "Malic Acid")
         )

data = [trace1, trace2, trace3, trace4]
fig = go.Figure(data=data, layout=layout)
fig.show()

图 5：原始特征和各种缩放实现的图示。

特征交互

我们可以通过使用特征之间的配对交互的乘积来创建逻辑与函数。在基于树的模型中，这些交互是隐式发生的，但在假设特征独立的模型中，我们可以显式地声明特征之间的交互，以提高模型的输出。

设想一个简单的线性模型，该模型使用输入特征的线性组合来预测输出 y：

图 6：线性模型的公式。

我们可以扩展线性模型以捕捉特征之间发生的交互。

图 7：扩展线性模型。

注意：线性函数的使用代价较高，线性模型的配对交互的评分和训练复杂度从 O(n) 增加到 O(n²)。然而，你可以进行特征提取来克服这个问题（特征提取超出了本文的范围，但我将在未来的文章中讨论）。

让我们在 Python 中编写代码，我将利用 scikit-learn 的PolynomialFeatures类，你可以在文档中阅读更多内容：

import numpy as np
from sklearn.preprocessing import PolynomialFeatures

# creating dummy dataset
X = np.arange(10).reshape(5, 2)
X.shape
>>> (5, 2)

# interactions between features only
interactions = PolynomialFeatures(interaction_only=True)
X_interactions= interactions.fit_transform(X)
X_interactions.shape
>>> (5, 4)

# polynomial features 
polynomial = PolynomialFeatures(5)
X_poly = polynomial.fit_transform(X)
X_poly.shape
>>> (5, 6)

这篇文章深受书籍《机器学习特征工程：数据科学家的原则与技术》的启发，我强烈推荐阅读。尽管该书于 2016 年出版，但即便是没有数学背景的人也能从中获得非常有用的信息和清晰的解释。

结论

就这样。在这篇文章中，我们讨论了处理数值特征的技术，如量化、幂变换、特征缩放以及交互特征（这些技术可以应用于各种数据类型）。这绝不是特征工程的全部内容，我们每天都可以学到更多。特征工程是一门艺术，需要练习，所以现在你有了直觉，就可以开始实践了。

原文。转载已获许可。

简历： Kurtis Pykes 是 Codehouse 的机器学习工程实习生。他热衷于利用机器学习和数据科学的力量来帮助人们变得更高效和有效。

相关：

• SQL 和 Python 中的特征工程：混合方法

• 数据转换：标准化与归一化

• 高级特征工程和预处理的 4 个技巧

了解更多相关主题

• 2022 特征商店峰会：关于特征工程的免费会议

• 为多变量时间序列构建可处理的特征工程管道

• 使用 RAPIDS cuDF 在特征工程中利用 GPU

• 机器学习中特征工程的实用方法

• 初学者的特征工程

• 特征选择：科学与艺术的交汇点

SQL 和 Python 中的特征工程：一种混合方法

原文：www.kdnuggets.com/2020/07/feature-engineering-sql-python-hybrid-approach.html

评论

由 Shaw Lu，Coupang 的数据科学家

我很早就学会了 SQL，对 Pandas 真实模拟 SQL 的方式感到非常好奇。传统上，SQL 主要用于分析师，他们将数据处理成有信息的报告，而 Python 则用于数据科学家，他们利用数据构建（并过拟合）模型。虽然这两者在功能上几乎等价，但我认为两者都是数据科学家高效工作的关键。从我使用 Pandas 的经验来看，我注意到以下几点：

• 在探索不同特征时，我最终会得到许多 CSV 文件。

• 当我在一个大型数据框上进行汇总时，Jupyter 内核会直接崩溃。

• 我在内核中有多个名称混乱（且很长）的数据框。

• 我的特征工程代码看起来很丑，而且分散在许多单元格中。

---

我们的前 3 名课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织 IT

---

当我开始直接在 SQL 中进行 特征工程 时，这些问题自然得到了解决。因此，在这篇文章中，我将通过处理家庭作业挑战数据集分享一些我最喜欢的技巧。如果你对 SQL 有一点了解，现在是时候好好利用它了。

安装 MySQL

首先，你需要一个 SQL 服务器。我在这篇文章中使用的是 MySQL。你可以通过安装本地桌面服务器，如 MAMP、WAMP 或 XAMPP 来获取 MySQL 服务器。网上有许多教程，值得一试。

在设置服务器后，请确保准备好三个项目：用户名、密码、端口号。通过终端输入以下命令进行登录（这里我们使用用户名“root”，密码 1234567）。

mysql -uroot -p1234567

然后在 MySQL 控制台中创建一个名为“Shutterfly”的数据库（你可以根据需要命名）。这两个表将被加载到这个数据库中。

create database Shutterfly;

安装 sqlalchemy

你需要 Pandas 和 sqlalchemy 来在 Python 中使用 SQL。我敢打赌你已经有 Pandas 了。然后通过激活你想要的环境来启动 Jupyter notebook，并输入：

pip install sqlalchemy

sqlalchemy 模块还需要MySQLdb和mysqlclient模块。根据你的操作系统，这些可以使用不同的命令进行安装。

将数据集加载到 MySQL 服务器

在这个示例中，我们将从两个CSV 文件中加载数据，并直接在 MySQL 中进行特征工程。为了加载数据集，我们需要使用用户名、密码、端口号和数据库名称实例化一个engine对象。将创建两个表：Online 和 Order。每个表上都会创建一个自然索引。

在 MySQL 控制台中，你可以验证表是否已创建。

拆分数据集

这可能看起来有些违背直觉，因为我们还没有构建任何特征。但实际上这是非常简洁的，因为我们需要做的就是按索引拆分数据集。根据设计，我还包含了我们尝试预测的标签（事件 2）。在加载特征时，我们只需将索引与特征表连接起来即可。

在 MySQL 控制台中，你可以验证训练集和测试集是否已创建。

特征工程

这是一个繁重的工作。我直接在 Sublime Text 中编写 SQL 代码，并通过将代码粘贴到 MySQL 控制台中来调试。由于该数据集是事件日志，我们必须避免将未来的信息泄漏到每个数据点中。你可以想象，每个特征都需要在历史数据中进行聚合！

连接表是最慢的操作，因此我们希望从每次连接中获得尽可能多的特征。在这个数据集中，我实现了四种类型的连接，生成了四组特征。具体细节并不重要，但你可以在这里找到我所有的 SQL 片段。每个片段创建一个表。索引被保留，并且必须与训练集和测试集中的响应变量正确匹配。每个片段的结构如下：

要生成特征表，打开一个新的终端，导航到包含 SQL 文件的文件夹，并输入以下命令和密码。第一个片段创建了一些必要的索引，以加速连接操作。接下来的四个片段创建了四个特征表。没有索引，连接操作将花费很长时间。有了索引，连接操作大约需要 20 分钟（在本地机器上还不错）。

mysql < add_index.sql -uroot -p1234567
mysql < feature_group_1.sql -uroot -p1234567
mysql < feature_group_2.sql -uroot -p1234567
mysql < feature_group_3.sql -uroot -p1234567
mysql < feature_group_4.sql -uroot -p1234567

现在你应该在数据库中拥有以下表。请注意，衍生特征与原始事件日志分开存储，这有助于防止混淆和灾难。

加载特征

在这里，我写了一个从 MySQL 服务器提取数据的实用程序函数。

• 该函数以表名“trn_set”（训练集）或“tst_set”（测试集）作为输入，如果你只想获取数据的子集，还可以选择limit子句。

• 唯一列以及大部分缺失值的列被删除。

• 日期列被映射为月份，以帮助捕捉季节性效应。

• 注意特征表如何依次连接。这实际上是高效的，因为我们总是按一对一的映射连接索引。

最后，让我们看看 5 个训练示例及其特征。

现在你有了一个定义良好的数据集和特征集。你可以调整每个特征的规模和缺失值，以适应你模型的需求。

对于基于树的方法，这些方法对特征缩放不变，我们可以直接应用模型，简单地专注于调整参数！查看一个普通的梯度提升机示例这里。

很高兴看到所有有用的特性都已被工程化，除了类别特性。我们的努力得到了回报！另外，event2 中最具预测性的特征是观察到的 null 值数量。这是一个说明性的案例我们不能用中位数或平均值替换 null 值，因为它们的缺失与响应变量相关联！

总结

正如你所见，我们没有中间的 CSV 文件，我们的笔记本中的命名空间非常干净，而且我们的特征工程代码减少到了几个简单的 SQL 语句。在以下两种情况下，SQL 方法的效率更高：

• 如果你的数据集部署在云端，你可能可以运行分布式查询。大多数 SQL 服务器今天支持分布式查询。在 Pandas 中，你需要一个叫做Dask DataFrame的扩展。

• 如果你能实时获取数据，你可以创建 SQL 视图而不是表格。这样，每次在 Python 中提取数据时，你的数据将始终是最新的。

这种方法的一个基本限制是你必须能够在 Python 中直接连接到你的 SQL 服务器。如果这不可能，你可能需要将查询结果下载为 CSV 文件并在 Python 中加载它。

我希望你觉得这篇文章有帮助。尽管我没有提倡某种方法优于另一种，但了解每种方法的优点和限制是必要的，并且在我们的工具箱中准备好这两种方法。这样我们就可以在约束条件下应用最有效的方法。

个人简介：Shaw Lu 是 Coupang 的数据科学家。他是一位工程学毕业生，寻求利用数据科学来指导业务管理、供应链优化、增长营销和运营研究。Toward Data Science 的官方作者。

原文。经允许转载。

相关：

• 4 个高级特征工程和预处理技巧

• 以艰难的方式学习 SQL

• 掌握中级机器学习的 7 个步骤——2019 版

更多相关话题

• 每个数据科学家都应了解的三大 R 库（即使你使用 Python）

• 是什么让 Python 成为初创公司理想的编程语言

• 停止学习数据科学以寻找目的，寻找目的以…

• 一项 90 亿美元的人工智能失败，经过审视

• 学习数据科学统计的顶级资源

• 成功的数据科学家具备的 5 个特征

使用 Scikit-Learn 进行特征排名和递归特征消除

原文：www.kdnuggets.com/2020/10/feature-ranking-recursive-feature-elimination-scikit-learn.html

评论

照片由 Element5 Digital 提供，来源于 Unsplash

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升您的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持您组织的 IT 部门

---

特征选择是任何机器学习应用中的重要任务。当数据包含许多特征时，这一点尤为重要。最佳特征数量也会提高模型的准确性。通过特征重要性或特征排名可以获得最重要的特征和最佳特征数量。在本文中，我们将探讨特征排名。

递归特征消除

递归特征消除所需的第一个项目是估计器；例如，线性模型或决策树模型。

这些模型具有线性模型的系数和决策树模型中的特征重要性。在选择最佳特征数量时，估计器经过训练，特征通过系数或特征重要性被选中。最不重要的特征会被移除。这个过程会递归重复，直到获得最佳特征数量。

在 Sklearn 中的应用

Scikit-learn 使得通过 sklearn.feature_selection.**RFE** 类实现递归特征消除成为可能。该类接受以下参数：

• estimator — 一个机器学习估计器，可以通过 coef_ 或 feature_importances_ 属性提供特征重要性。

• n_features_to_select — 要选择的特征数量。如果未指定，则选择 half。

• step — 一个整数，表示每次迭代中要移除的特征数量，或介于 0 和 1 之间的数字，表示每次迭代中要移除的特征百分比。

一旦拟合完成，可以获得以下属性：

• ranking_ — 特征的排名。

• n_features_ — 已选择的特征数量。

• support_ — 一个数组，指示特征是否被选中。

应用

如前所述，我们需要使用一个提供feature_importance_s属性或coeff_属性的估算器。让我们通过一个快速示例来演示。数据集中有 13 个特征——我们将致力于获取最佳特征数量。

import pandas as pddf = pd.read_csv(‘heart.csv’)df.head()

让我们获取X和y特征。

X = df.drop([‘target’],axis=1)
y = df[‘target’]

我们将其拆分为测试集和训练集，以准备建模：

from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y,random_state=0)

让我们先做几个导入：

• Pipeline — 因为我们将进行一些交叉验证。为了避免数据泄露，这是一种最佳实践。

• RepeatedStratifiedKFold — 用于重复分层交叉验证。

• cross_val_score — 用于评估交叉验证中的得分。

• GradientBoostingClassifier — 我们将使用的估算器。

• numpy — 以便我们可以计算得分的均值。

from sklearn.pipeline import Pipeline
from sklearn.model_selection import RepeatedStratifiedKFold
from sklearn.model_selection import cross_val_score
from sklearn.feature_selection import RFE
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier

第一步是创建一个RFE类的实例，并指定估算器和您希望选择的特征数量。在这个例子中，我们选择 6 个特征：

rfe = RFE(estimator=GradientBoostingClassifier(), n_features_to_select=6)

接下来，我们创建一个我们希望使用的模型实例：

model = GradientBoostingClassifier()

我们将使用Pipeline来转换数据。在Pipeline中，我们指定rfe作为特征选择步骤，并指定在下一步骤中将使用的模型。

然后我们指定一个RepeatedStratifiedKFold，它有 10 个拆分和 5 次重复。分层 K 折确保每个折叠中每个类的样本数量得到良好平衡。RepeatedStratifiedKFold将分层 K 折重复指定次数，每次重复时随机化不同。

pipe = Pipeline([(‘Feature Selection’, rfe), (‘Model’, model)])
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=5, random_state=36851234)
n_scores = cross_val_score(pipe, X_train, y_train, scoring=’accuracy’, cv=cv, n_jobs=-1)
np.mean(n_scores)

下一步是将这个管道拟合到数据集中。

pipe.fit(X_train, y_train)

完成这些步骤后，我们可以检查支持度和排名。支持度表示特征是否被选择。

rfe.support_
array([ True, False,  True, False,  True, False, False,  True, False,True, False,  True,  True])

我们可以将其放入数据框中，并检查结果。

pd.DataFrame(rfe.support_,index=X.columns,columns=[‘Rank’])

我们还可以检查相对排名。

rf_df = pd.DataFrame(rfe.ranking_,index=X.columns,columns=[‘Rank’]).sort_values(by=’Rank’,ascending=True)rf_df.head()

自动特征选择

如果我们能够自动选择特征，而不是手动配置特征数量，那将非常好。这可以通过递归特征消除和交叉验证来实现。这是通过sklearn.feature_selection.RFECV类完成的。该类接受以下参数：

• estimator — 类似于RFE类。

• min_features_to_select — 要选择的最小特征数量。

• cv— 交叉验证拆分策略。

返回的属性包括：

• n_features_ — 通过交叉验证选择的最佳特征数量。

• support_ — 包含特征选择信息的数组。

• ranking_ — 特征的排名。

• grid_scores_ — 从交叉验证中获得的分数。

第一步是导入类并创建其实例。

from sklearn.feature_selection import RFECVrfecv = RFECV(estimator=GradientBoostingClassifier())

下一步是指定管道和 cv。在这个管道中，我们使用刚创建的rfecv。

pipeline = Pipeline([(‘Feature Selection’, rfecv), (‘Model’, model)])
cv = RepeatedStratifiedKFold(n_splits=10, n_repeats=5, random_state=36851234)
n_scores = cross_val_score(pipeline, X_train, y_train, scoring=’accuracy’, cv=cv, n_jobs=-1)
np.mean(n_scores)

让我们拟合管道，然后获取最佳特征数量。

pipeline.fit(X_train,y_train)

最优特征数量可以通过n_features_属性获得。

print(“Optimal number of features : %d” % rfecv.n_features_)Optimal number of features : 7

排名和支持可以像上次一样获得。

rfecv.support_rfecv_df = pd.DataFrame(rfecv.ranking_,index=X.columns,columns=[‘Rank’]).sort_values(by=’Rank’,ascending=True)
rfecv_df.head()

利用grid_scores_我们可以绘制显示交叉验证得分的图表。

import matplotlib.pyplot as plt
plt.figure(figsize=(12,6))
plt.xlabel(“Number of features selected”)
plt.ylabel(“Cross validation score (nb of correct classifications)”)
plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_)
plt.show()

特征数量与准确率的图示

最后的思考

在回归问题中应用这一过程是相同的。只需确保使用回归指标而不是准确率。希望这篇文章能为你选择机器学习问题的最优特征数量提供一些见解。

mwitiderrick/Feature-Ranking-with-Recursive-Feature-Elimination

特征排名与递归特征消除 - mwitiderrick/Feature-Ranking-with-Recursive-Feature-Elimination

简介: Derrick Mwiti 是一名数据分析师、作家和导师。他致力于在每项任务中交付优异的成果，并且是 Lapid Leaders Africa 的导师。

原文。经许可转载。

相关：

• 我如何将机器学习模型的准确率从 80%持续提升到 90%以上

• LightGBM：一种高效的梯度提升决策树

• 使用 CatBoost 的快速梯度提升

更多相关主题

• 2022 年特征商店峰会：免费的特征工程会议

• 特征选择：科学与艺术的交汇点

• 机器学习中的替代特征选择方法

• 构建可处理的多变量特征工程管道

• 实时 AI 和机器学习的特征商店

• 机器学习模型的高级特征选择技术

使用遗传算法和 Python 进行特征减少

原文：www.kdnuggets.com/2019/03/feature-reduction-genetic-algorithm-python.html

评论

介绍

在某些情况下，使用原始数据训练机器学习算法可能不是最佳选择。当算法使用原始数据进行训练时，它必须自行进行特征挖掘，以检测不同的群体。但这需要大量的数据才能自动进行特征挖掘。对于小型数据集，建议数据科学家自行进行特征挖掘，并仅告诉机器学习算法使用哪些特征集。

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你组织的 IT 工作

---

使用的特征集必须能代表数据样本，因此我们必须仔细选择最佳特征。数据科学家建议使用一些基于以往经验看来对表示数据样本有帮助的特征。一些特征可能在表示样本时证明了它们的鲁棒性，而其他特征则可能不行。

可能会有一些特征会影响训练模型的结果，要么通过降低分类问题的准确性，要么通过增加回归问题的误差。例如，特征向量中可能存在噪声元素，因此这些元素应被移除。特征向量中也可能包含两个或更多相关的元素，使用其中一个元素将代替其他元素。为了去除这些类型的元素，有两个有用的步骤，即特征选择和特征减少。本教程重点讲解特征减少。

假设有 3 个特征 F1、F2 和 F3，每个特征有 3 个特征元素。因此，特征向量的长度为 3x3=9。特征选择只选择特定类型的特征，并排除其他特征。例如，只选择 F1 和 F3 并去除 F3。此时，特征向量的长度从 9 减少为 6。在特征缩减中，可能会排除每个特征的特定元素。例如，这一步可能会去除 F3 的第一个和第三个元素，同时保留第二个元素。因此，特征向量的长度从 9 减少为 7。

在开始本教程之前，值得一提的是，它是我在 LinkedIn 个人资料中发布的 2 个之前教程的扩展。

第一个教程的标题是“使用 NumPy 实现人工神经网络并对 Fruits360 图像数据集进行分类”。它开始时从 Fruits360 数据集的 4 个类别中提取长度为 360 的特征向量。接着，使用 NumPy 从头构建一个人工神经网络（ANN）来对数据集进行分类。此教程可在此处找到：www.linkedin.com/pulse/artificial-neural-network-implementation-using-numpy-fruits360-gad。其 GitHub 项目可在此处找到：github.com/ahmedfgad/NumPyANN。

第二个教程的标题是“使用遗传算法优化人工神经网络”。该教程构建并使用遗传算法来优化 ANN 参数，以提高分类准确率。此教程可在此处找到：www.linkedin.com/pulse/artificial-neural-networks-optimization-using-genetic-ahmed-gad。其 GitHub 项目也可以在此处找到：github.com/ahmedfgad/NeuralGenetic。

本教程讨论了如何使用遗传算法（GA）来缩减从 Fruits360 数据集中提取的长度为 360 的特征向量。本教程首先讨论需要遵循的步骤。然后，使用 Python 实现这些步骤，主要利用 NumPy 和 Sklearn。

本教程的实现可以在我的 GitHub 页面找到，链接如下：github.com/ahmedfgad/FeatureReductionGenetic。

遗传算法从一个初始种群开始，该种群由多个染色体（即解）组成，每个染色体都有一系列基因。通过适应度函数，遗传算法选择最佳解作为父代，用于创建新种群。新种群中的新解通过对父代应用两种操作来生成：交叉和变异。在将遗传算法应用于特定问题时，我们需要确定基因的表示、合适的适应度函数以及如何应用交叉和变异。让我们看看这些是如何工作的。

关于遗传算法的更多信息

你可以从我准备的以下资源中了解更多关于遗传算法的信息：

• 遗传算法优化简介

  • www.linkedin.com/pulse/introduction-optimization-genetic-algorithm-ahmed-gad/

  • /2018/03/introduction-optimization-with-genetic-algorithm.html

  • towardsdatascience.com/introduction-to-optimization-with-genetic-algorithm-2f5001d9964b

• 遗传算法（GA）优化 - 步骤示例

  • www.slideshare.net/AhmedGadFCIT/genetic-algorithm-ga-optimization-stepbystep-example

• 遗传算法在 Python 中的实现

  • www.linkedin.com/pulse/genetic-algorithm-implementation-python-ahmed-gad/

  • /2018/07/genetic-algorithm-implementation-python.html

  • towardsdatascience.com/genetic-algorithm-implementation-in-python-5ab67bb124a6

  • github.com/ahmedfgad/GeneticAlgorithmPython

我在 2018 年还写了一本书，其中一个章节讲述了遗传算法。这本书的标题是《使用深度学习和卷积神经网络的实际计算机视觉应用》，可以在这里的 Springer 上找到www.springer.com/us/book/9781484241660。

染色体表示

遗传算法中的基因是染色体的构建块。首先，我们需要确定染色体中包含哪些基因。为此，考虑到每个可能影响结果的属性应视为一个基因。由于我们的任务目标是选择最佳的特征元素集合，因此每个特征元素可能会影响结果，因此每个特征元素都被视为一个基因。染色体将由所有基因（即所有特征元素）组成。因为有 360 个特征元素，所以将有 360 个基因。现在清楚的一点是染色体的长度是 360。

确定了所选基因之后，接下来是确定基因的表示方式。有不同的表示方法，如十进制、二进制、浮点、字符串等。我们的目标是知道基因（即特征元素）是否在减少的特征集合中被选择。因此，分配给基因的值应反映其是否被选择。根据这个描述，很明显每个基因有 2 个可能的值。一个值表示基因被选择，另一个值表示基因未被选择。因此，二进制表示是最佳选择。当基因值为 1 时，它将被选择到减少的特征集合中。当值为 0 时，则会被忽略。

总结一下，染色体将由 360 个以二进制表示的基因组成。根据下图，特征向量与染色体之间存在一对一的映射关系。即染色体中的第一个基因与特征向量中的第一个元素相关联。当该基因的值为 1 时，这意味着特征向量中的第一个元素被选择。

适应度函数

通过了解如何创建染色体，可以轻松地使用 NumPy 随机初始化初始种群。初始化后，选择父代。遗传算法基于达尔文的理论“适者生存”。即从当前种群中选择最佳解进行配对，以产生更好的解。通过保留好的解并淘汰坏的解，我们可以达到最优或次优解。

选择父代的标准是与每个解（即染色体）相关的适应度值。适应度值越高，解越好。适应度值是通过适应度函数计算得出的。那么，在我们的任务中，最佳的函数是什么呢？我们任务的目标是创建一个减少的特征向量，以提高分类准确率。因此，判断一个解是否好的标准是分类准确率。因此，适应度函数将返回一个指定每个解的分类准确率的数字。准确率越高，解越好。

为了返回分类准确率，必须有一个机器学习模型通过每个解返回的特征元素进行训练。我们将使用支持向量分类器（SVC）。

数据集被分为训练样本和测试样本。根据训练数据，SVC 将使用每个解在种群中选择的特征元素进行训练。训练完成后，将根据测试数据进行测试。

根据每个解的适应度值，我们可以选择其中最好的作为父代。这些父代被放在配对池中，以生成将成为下一代新种群成员的后代。这些后代是通过对选择的父代应用交叉和突变操作来创建的。接下来，我们将配置这些操作。

交叉和突变

根据适应度函数，我们可以在当前种群中筛选出最佳的解，这些解被称为父代。遗传算法假设将两个好的解配对会产生第三个更好的解。配对意味着从两个父代中交换一些基因。基因通过交叉操作进行交换。此操作可以通过不同方式应用。本教程使用单点交叉，其中一个点将染色体分开。点之前的基因来自一个解，点之后的基因来自另一个解。

仅仅通过应用交叉操作，所有基因都来自先前的父代。新的后代中没有引入新的基因。如果所有父代中存在坏基因，那么这个基因将被传递给后代。因此，应用突变操作以引入新的基因。对于基因的二进制表示，突变是通过翻转一些随机选择的基因的值来实现的。如果基因值是 1，则将其变为 0，反之亦然。

在生成后代后，我们可以创建下一代的新种群。这个种群包括了之前的父代以及后代。

目前，所有步骤都已讨论完毕。接下来是用 Python 实现这些步骤。请注意，我之前写了一篇标题为《Python 中的遗传算法实现》的教程，用于在 Python 中实现遗传算法，我将修改它的代码以适应我们的问题。最好先阅读一下。

Python 实现

项目组织成两个文件。一个文件名为“GA.py”，其中包含遗传算法步骤的实现函数。另一个文件是主要文件，它只导入这个文件并在一个循环中调用其函数，该循环遍历各代。

主文件开始时会读取从 Fruits360 数据集中提取的特征，如下代码所示。这些特征被返回到data_inputs变量中。关于如何提取这些特征的详细信息，可以在教程开始时提到的两个教程中找到。文件还读取了与样本关联的类别标签，存储在data_outputs变量中。

一些样本被选为训练，其索引存储在train_indices变量中。类似地，测试样本的索引存储在test_indices变量中。

import numpy

import GA

import pickle

import matplotlib.pyplot

f = open("dataset_features.pkl", "rb")

data_inputs = pickle.load(f)

f.close()

f = open("outputs.pkl", "rb")

data_outputs = pickle.load(f)

f.close()

num_samples = data_inputs.shape[0]

num_feature_elements = data_inputs.shape[1]

train_indices = numpy.arange(1, num_samples, 4)

test_indices = numpy.arange(0, num_samples, 4)

print("Number of training samples: ", train_indices.shape[0])

print("Number of test samples: ", test_indices.shape[0])

"""

Genetic algorithm parameters:

    Population size

    Mating pool size

    Number of mutations
"""

sol_per_pop = 8 # Population size.

num_parents_mating = 4 # Number of parents inside the mating pool.

num_mutations = 3 # Number of elements to mutate.

# Defining the population shape.
pop_shape = (sol_per_pop, num_feature_elements)

# Creating the initial population.
new_population = numpy.random.randint(low=0, high=2, size=pop_shape)
print(new_population.shape)

best_outputs = []
num_generations = 100

它初始化了遗传算法的所有参数。这包括每代种群中的解数量，根据sol_per_pop变量设置为 8，后代数量，根据num_parents_mating变量设置为 4，以及突变数量，根据num_mutations变量设置为 3。之后，它在一个名为new_population的变量中随机创建初始种群。

有一个名为best_outputs的空列表，用于存储每次生成后的最佳结果。这有助于在完成所有代之后可视化遗传算法的进展。num_generations变量设置了代的数量为 100。请注意，你可以更改这些参数，这可能会带来更好的结果。

了解更多此主题

• 遗传算法关键术语解释

• 使用遗传算法优化基因

• 数据科学中的降维技术

• Feature Store Summit 2022: 一场关于特征工程的免费会议

• Python 中的遗传编程：背包问题

• 理解和实现 Python 中的遗传算法

特征选择：超越特征重要性？

原文：www.kdnuggets.com/2019/10/feature-selection-beyond-feature-importance.html

评论

由 Dor Amir，数据科学经理，Guesty

在机器学习中，特征选择是选择对预测最有用的特征的过程。虽然听起来简单，但它是创建新机器学习模型中最复杂的问题之一。

在这篇文章中，我将与你分享一些在我最近主持的项目中研究过的方法，项目在 Fiverr。

你将了解到我尝试的基本方法以及更复杂的方法，这种方法取得了最佳结果——去除了超过 60%的特征，同时保持准确性并为我们的模型实现了更高的稳定性。我还会分享我们对这一算法的改进。

为什么特征选择如此重要？

如果你构建了一个机器学习模型，你会知道识别哪些特征重要、哪些只是噪声是多么困难。

去除噪声特征将有助于节省内存、降低计算成本并提高模型的准确性。

此外，通过去除特征，你将有助于避免模型的过拟合。

有时候，你有一个在业务上有意义的特征，但这并不意味着这个特征会帮助你的预测。

你需要记住，特征在一个算法中（比如决策树）可能是有用的，而在另一个算法中（如回归模型）可能会被低估——并不是所有特征都是一样的 😃

无关或部分相关的特征可能会对模型性能产生负面影响。特征选择和数据清洗应该是设计模型的第一步，也是最重要的一步。

特征选择方法：

尽管有很多特征选择技术，如向后消除法、套索回归。在这篇文章中，我将分享我发现的三种最有用的特征选择方法，每种方法都有其优点。

“All But X”

“All But X”这个名字是在 Fiverr 给这个技术起的。这个技术简单但有用。

1. 你在迭代中运行训练和评估

2. 在每次迭代中，你去除一个特征。

   如果你有大量的特征，你可以去除一“组”特征——在 Fiverr，我们通常将特征聚合在不同的时间段，比如 30 天点击、60 天点击等。这是一组特征。

3. 检查你的评估指标与基线的对比。

这种技术的目标是查看一组特征中的哪些不影响评估，或者是否甚至去除这些特征可以改善评估。

“所有 X”图表显示完整流程——在运行所有迭代后，我们进行比较以检查哪个特征没有影响模型的准确性。

这个方法的问题在于，通过一次移除一个特征，你无法得到特征间相互作用的效果（非线性效果）。也许特征 X 和特征 Y 的组合在制造噪音，而不仅仅是特征 X。

特征重要性 + 随机特征

我们尝试的另一种方法是使用大多数机器学习模型 API 提供的特征重要性。

我们所做的，不仅仅是从特征重要性中取前 N 个特征。我们向数据中添加了 3 个随机特征：

1. 二元随机特征（0 或 1）

2. 0 到 1 之间均匀分布的随机特征

3. 整数随机特征

在特征重要性列表中，我们仅保留那些比随机特征重要的特征。

重要的是使用不同分布的随机特征，因为每种分布可能会有不同的效果。

在决策树中，模型“更偏爱”连续特征（因为分裂的原因），所以这些特征通常会位于层级的较高位置。这就是为什么你需要将每个特征与其等量分布的随机特征进行比较的原因。

Boruta

Boruta 是一种特征排名和选择算法，开发于华沙大学。这个算法基于随机森林，但也可以用于 XGBoost 和其他树算法。

在 Fiverr，我对 XGBoost 排序和分类模型使用了这个算法，并进行了一些改进，我会简要说明。

这个算法是我上面提到的两种方法的结合。

1. 为数据集中的每个特征创建一个“影子”特征，具有相同的特征值，但仅在行之间进行洗牌。

2. 在循环中运行，直到满足其中一个停止条件：

   2.1. 我们不再移除任何特征。

   2.2. 我们移除了足够的特征——我们可以说我们要移除 60%的特征。

   2.3. 我们运行了 N 次迭代——我们限制了迭代次数以避免陷入无限循环。

3. 运行 X 次迭代——我们使用了 5 次，以消除模型的随机性。

   3.1. 用常规特征和影子特征训练模型。

   3.2. 保存每个特征的平均特征重要性分数。

   3.3 移除所有比其影子特征低的特征。

Boruta 伪代码

Boruta 流程图，从创建影子特征——训练——比较——移除特征并重新开始。

Boruta 2.0

这是本文的最佳部分，我们对 Boruta 的改进。

我们用“简化版”的原始模型运行了 Boruta。通过取样数据和更少的树（我们使用了 XGBoost），我们提高了原始 Boruta 的运行时间，而不降低准确性。

另一个改进是，我们使用之前提到的随机特征运行了算法。这是一个好的合理性检查或停止条件，以确保我们已经从数据集中移除了所有随机特征。

尽管有了改善，我们没有看到模型准确性的变化，但我们观察到了运行时间的改善。通过移除一些特征，我们将特征数量从 200 多个减少到了不到 70 个。我们还观察到了模型在树的数量和不同训练阶段的稳定性。

我们还观察到了训练集和验证集之间的损失距离有所改善。

改进和 Boruta 的优点在于，你正在运行自己的模型。在这种情况下，发现的问题特征对你的模型有问题，而不是其他算法。

总结

在这篇文章中，你看到了 3 种不同的特征选择技术以及如何构建有效的预测模型。你看到了我们对 Boruta 的实现、运行时间的改善以及添加随机特征以帮助进行合理性检查。

通过这些改进，我们的模型运行速度大大提高，稳定性增强，准确性保持在原有水平，同时特征数量仅为原来的 35%。

选择最适合你的技术。请记住，特征选择可以帮助提高准确性、稳定性和运行时间，并避免过拟合。更重要的是，特征减少后调试和解释性变得更容易。

简介： Dor Amir 是 Guesty 的数据科学经理。

原文。经许可转载。

相关：

• 特征提取指南

• Python 中的随机搜索特征选择

• 揭开黑箱：如何利用可解释的机器学习

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织进行 IT 工作

---

更多相关话题

• 超越猜测：利用贝叶斯统计进行有效的…

• 特征选择：科学与艺术的交汇

• 机器学习中的替代特征选择方法

• 机器学习模型的高级特征选择技术

• 庆祝对数据隐私重要性的认识

• 机器学习不像你的大脑 第六部分：精确突触权重的重要性

特征选择 – 你想知道的一切

原文：www.kdnuggets.com/2021/06/feature-selection-overview.html

评论

作者 Danny Butvinik，NICE Actimize 的首席数据科学家

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析水平

3. Google IT 支持专业证书 - 在 IT 方面支持你的组织

---

来源：TnT 木工。

特征选择作为一种降维技术，旨在通过去除无关、冗余或噪声特征，从原始特征中选择一个相关特征的小子集。特征选择通常可以带来更好的学习性能、更高的学习准确性、更低的计算成本和更好的模型可解释性。本文重点介绍了特征选择过程，并提供了从数据和算法角度对特征选择类型、方法和技术的全面结构化概述。

图 1：特征选择的高级分类。

这篇文章考虑了特征选择过程。这个问题很重要，因为数据集中大量的特征数量， comparable to 或高于样本数量，会导致模型过拟合，从而在验证数据集上结果不佳。此外，从具有许多特征的数据集中构建模型计算上更为繁重。

强相关特征对于最优特征子集始终是必要的，它不能被移除而不影响原始条件目标分布。

特征选择的目的是最大化相关性并最小化冗余。

特征选择方法可以用于数据预处理，以实现高效的数据减少。这对于找到准确的数据模型非常有用。由于对最优特征子集进行穷举搜索在大多数情况下不可行，因此文献中提出了许多搜索策略。特征选择的通常应用包括分类、聚类和回归任务。

什么是特征选择

所有机器学习工作流都依赖于特征工程，其中包括特征提取和特征选择，这些是现代机器学习管道的基本构建块。尽管特征提取和特征选择过程有一些重叠，但这些术语通常被错误地等同起来。特征提取是利用领域知识从原始数据中提取新的变量，使机器学习算法能够正常工作。特征选择过程则基于选择最一致、最相关和不冗余的特征。

特征选择技术的目标包括：

• 简化模型，使研究人员/用户更容易解释

• 更短的训练时间

• 避免维度诅咒

• 通过减少过拟合（正式地说，是减少方差）来增强泛化能力

由于研究人员可以使用大量已开发的分析方法，数据集大小缩减现在变得更加重要，同时平均数据集的大小在特征和样本数量上都在不断增长。

图 2：表格数据中特征选择和数据大小缩减的说明。

什么使一些特征表示优于其他表示？

不论特征表示的技术方法如何，有一个共同的问题困扰着大多数机器学习工作流中的数据科学家：是什么使一些特征表示优于其他表示？

这可能是一个疯狂的问题，因为现代机器学习问题使用了数十万甚至百万个特征，而这些特征对于领域专家来说几乎无法解释。

虽然对我们目标问题没有简单的答案，但我们可以遵循一些通用原则。一般来说，特征表示中有三个关键的期望属性：

• 潜在因子的解缠

• 易于建模

• 与正则化策略配合良好

从根本上讲，良好的表示包括与观察数据的潜在原因相对应的特征。更具体地说，本论文将表示的质量与不同特征和方向对应于潜在数据集中不同原因的结构相关联，以便表示能够将一种原因与另一种原因区分开来。

另一个良好表示的领先指标是建模的简洁性。对于给定的机器学习问题/数据集，我们可以找到许多将潜在因子分开的表示，但这些表示可能非常难以建模。

有监督特征选择方法

有监督的特征选择方法根据与学习模型的交互分为四类，如过滤器、包装器、混合方法和嵌入方法。

图 3：有监督特征选择方法和技术的扩展分类。

过滤方法

在过滤方法中，特征是基于统计测量选择的。它独立于学习算法，并且需要较少的计算时间。信息增益、卡方检验、费舍尔得分、相关系数和方差阈值是一些用于了解特征重要性的统计测量方法。

过滤方法使用选择的度量来识别无关的属性，并从模型中过滤掉冗余的列。它提供了隔离选定度量以丰富模型的选项。列按照特征分数的计算结果进行排名。

包裹方法

包裹方法将特征集的选择视为一个搜索问题，其中不同的组合被准备、评估，并与其他组合进行比较。使用预测模型来评估特征组合，并分配模型性能分数。

包裹方法的性能依赖于分类器。最佳特征子集是基于分类器的结果选择的。

混合方法

创建混合特征选择方法的过程取决于你选择的组合方式。主要的优先事项是选择你要使用的方法，然后按照这些方法的流程进行。这里的思路是首先使用这些排名方法生成特征排名列表，然后使用该列表中的前 k 个特征来执行包裹方法。通过这种方式，我们可以使用这些基于过滤的排名方法来减少数据集的特征空间，从而提高包裹方法的时间复杂度。

嵌入方法

在嵌入技术中，特征选择算法作为学习算法的一部分进行集成。最典型的嵌入技术是决策树算法。决策树算法在树生长过程的每个递归步骤中选择一个特征，并将样本集划分为更小的子集。

无监督特征选择方法

由于可用标签的稀缺，无监督特征选择（UFS）方法在高维数据分析中被广泛采用。然而，大多数现有的 UFS 方法主要关注于特征在维持数据结构中的重要性，而忽略了特征之间的冗余。此外，确定合适的特征数量也是一个挑战。

无监督特征选择方法根据与学习模型的交互被分类为四种类型，如过滤、包裹和混合方法。

图 4：无监督特征选择方法和技术的扩展分类。

过滤方法

基于筛选方法的无监督特征选择方法可以分为单变量和多变量两类。单变量方法，即基于排名的无监督特征选择方法，使用某些标准来评估每个特征，以获得特征的有序排名列表，然后根据这个顺序选择最终的特征子集。这些方法可以有效地识别和去除不相关的特征，但由于不考虑特征间可能的依赖关系，它们无法去除冗余特征。另一方面，多变量筛选方法联合评估特征的相关性，而不是逐一评估。多变量方法可以处理冗余和不相关的特征。因此，在许多情况下，使用多变量方法选择的特征子集所达到的学习算法准确性优于使用单变量方法的准确性。

包装方法论

基于包装方法的无监督特征选择方法可以分为三个大类。

根据特征搜索策略：顺序、受生物启发的和迭代的。在顺序方法论中，特征是逐步添加或移除的。基于顺序搜索的方法容易实现且快速。

另一方面，生物启发的方法论试图在搜索过程中引入随机性，旨在逃避局部最优。

迭代方法将无监督特征选择问题视为估计问题，从而避免了组合搜索。

包装方法通过特定的聚类算法的结果来评估特征子集。根据这种方法开发的技术的特点是寻找能改善所使用的聚类算法结果的特征子集。然而，包装方法的主要缺点是通常具有较高的计算成本，并且限于与特定的聚类算法一起使用。

混合方法论

混合方法试图利用筛选和包装两种方法的优点，试图在效率（计算工作量）和有效性（使用所选特征时在相关目标任务中的质量）之间取得良好的平衡。

为了利用筛选和包装方法，混合方法包括一个筛选阶段，在此阶段，通过应用基于数据固有属性的度量来对特征进行排名或选择。而在包装阶段，评估某些特征子集，通过特定的聚类算法找到最佳子集。我们可以区分两种类型的混合方法：基于排名的方法和不基于特征排名的方法。

特征选择算法的特点

特征选择算法的目的是根据相关性的定义识别相关特征。然而，机器学习中的相关性概念尚未在共同协议下被严格定义。相关性的主要定义是相对于目标的相关性。

文献中有几种考虑因素用于描述特征选择算法。考虑到这些因素，可以将这种描述视为假设空间中的搜索问题，如下所示：

• 搜索组织：探索假设空间的一般策略。

• 后继生成：提出当前假设的可能变体（后继候选）的机制。

• 评估度量：用于评估后继候选的函数，允许比较不同的假设以指导搜索过程。

图 5：特征选择算法的描述。

金融犯罪领域的特征表示

NICE Actimize 在数据科学和机器学习领域的研究包括特征选择和特征表示。在诸如欺诈检测等应用领域，这些任务由于数据的多样性、高维度、稀疏性和混合类型变得更加复杂。

在没有依赖领域知识的情况下，从高维数据中选择正确的特征集以引导准确的分类模型是一个艰巨的计算挑战。

不幸的是，在数据挖掘和金融犯罪领域，一些数据由长数组特征描述。使用暴力破解方法穷举尝试所有可能的特征组合似乎永无止境，随机优化可能是一个解决方案。

因此，金融数据的时间和上下文特定性质需要领域专业知识来正确地工程化特征，同时最小化潜在的信息丢失。此外，金融犯罪领域没有行业标准的度量标准。这使得特征提取和特征选择的过程极为困难，尤其是在为机器学习模型定义目标函数时。

金融犯罪特征空间向量不能被投影到几何平面上，因为它们不会保持任何基本逻辑。问题是，如何定义两个金融交易（两个高维混合类型向量）之间的距离？

我邀请你接受这个挑战并思考：

1. 如何定义具有不同基数的两个稀疏异构特征向量（或张量）之间的适当度量？

2. 什么机制可以保证验证有效特征，其中有效特征是具有重要性并且能表示领域逻辑的特征？

参考文献

1. Jovic 等，(2015) 《特征选择方法及其应用综述》

2. Dadaneh 等人（2016）使用蚁群优化的无监督概率特征选择。

3. Mohana（2016）特征选择稳定性测量的调查

4. Chandrashekar（2014）特征选择方法的调查

5. Kamkar 等人（2015）利用特征关系实现稳定的特征选择。

6. Guo (2018) 依赖引导的无监督特征选择。

7. Zhou 等人（2015）稳定的特征选择算法。

8. Yu（2004）通过相关性和冗余分析进行高效特征选择

9. Fernandez 等人（2020）无监督特征选择方法的综述

10. Li 等人（2017）特征选择及其应用的最新进展

11. Zhao 和 Huan Liu（2007）监督和无监督学习的光谱特征选择

相关：

• 这项数据可视化是有效特征选择的第一步

• 为何自动特征选择存在风险

• 在 Scikit-Learn 中使用递归特征消除进行特征排序

更多相关话题

• 关于机器学习你想知道的一切

• KDnuggets 新闻，9 月 14 日：免费数据科学 Python 课程 •…

• StarCoder: 你一直想要的编码助手

• 机器学习中的替代特征选择方法

• 机器学习模型的高级特征选择技术

• 特征选择：科学与艺术的结合

Python 中的随机搜索特征选择

原文：www.kdnuggets.com/2019/08/feature-selection-random-search-python.html

评论

由吉安卢卡·马拉托，数据科学家、小说作者和软件开发者。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业的快车道

2. 谷歌数据分析专业证书 - 提升你的数据分析水平

3. 谷歌 IT 支持专业证书 - 支持你的组织在 IT 方面

---

特征选择一直是机器学习中的一项重要任务。根据我的经验，我可以肯定地说，特征选择比模型选择更为重要。

特征选择与多重共线性

我已经写了一篇关于特征选择的文章。这是一种无监督的方式来测量二分类模型中特征的重要性，使用了皮尔逊卡方检验和相关系数。

一般来说，无监督的方法通常足以用于简单的特征选择。然而，每个模型都有自己独特的方式来“思考”特征以及处理特征与目标变量的相关性。此外，有些模型不太关心多重共线性（即特征之间的相关性），而有些模型在发生这种情况时会显示出非常大的问题（例如线性模型）。

尽管可以通过模型引入的一些相关性指标来排序特征（例如，对线性回归系数执行的 t 检验的 p 值），但仅仅选择最相关的变量可能还不够。想象一下一个特征，它等于另一个特征，只是乘以二。这些特征之间的线性相关性为 1，这种简单的乘法不会影响与目标变量的相关性，因此如果我们只选择最相关的变量，我们将得到原始特征和被乘以二的特征。这会导致多重共线性，这对我们的模型可能非常危险。

这就是为什么我们必须引入某种方法来更好地选择特征。

随机搜索

随机搜索是数据科学家工具箱中的一个非常有用的工具。这是一种非常简单的技术，通常用于交叉验证和超参数优化等场景。

这非常简单。如果你有一个多维网格并且想在这个网格上寻找一个最大化（或最小化）某个目标函数的点，随机搜索的工作原理如下：

1. 在网格上取一个随机点并测量目标函数值。

2. 如果该值优于迄今为止取得的最佳值，则将该点保存在内存中。

3. 重复一个预定义的次数。

就这样。只需生成随机点并寻找最佳点。

这是一种找到全局最小值（或最大值）的好方法吗？当然不是。我们所寻找的点只有一个（如果我们运气好的话），在一个非常大的空间中，而且我们只有有限的迭代次数。在一个N点网格中获取该单个点的概率是1/N。

那么，为什么随机搜索如此常用？因为我们并不真正想要最大化我们的性能指标；我们想要一个好的、合理高的值，它不是最高的值，以避免过拟合。

这就是为什么随机搜索有效，并且可以用于特征选择的原因。

如何使用随机搜索进行特征选择

随机搜索可以用于特征选择，效果相当好。类似于随机搜索的一个例子是随机森林模型，它对每棵树进行特征的随机选择。

这个想法很简单：随机选择特征，通过k 折交叉验证来测量模型性能，并重复多次。给出最佳性能的特征组合就是我们所寻找的。

更准确地说，以下是需要遵循的步骤：

1. 生成一个随机整数N，范围在 1 到特征数量之间。

2. 生成一个随机的N整数序列，范围在 0 到N-1之间，且不重复。这个序列表示我们的特征数组。请记住，Python 数组是从 0 开始的。

3. 在这些特征上训练模型，并使用 k 折交叉验证进行交叉验证，保存某些性能指标的平均值。

4. 从第 1 点开始重复，次数可以随意。

5. 最后，获取根据所选择的性能指标提供最佳性能的特征数组。

Python 中的一个实际示例

对于这个示例，我将使用乳腺癌数据集，它包含在sklearn模块中。我们的模型将是逻辑回归，并且我们将使用准确率作为性能指标进行 5 折交叉验证。

首先，我们必须导入必要的模块。

import sklearn.datasets
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import cross_val_score
import numpy as np

然后我们可以导入乳腺癌数据并将其拆分为输入和目标。

dataset= sklearn.datasets.load_breast_cancer()
data = dataset.data
target = dataset.target

现在，我们可以创建一个逻辑回归对象。

lr = LogisticRegression()

然后，我们可以在 k 折交叉验证中测量所有特征的平均准确率。

# Model accuracy using all the features
np.mean(cross_val_score(lr,data,target,cv=5,scoring="accuracy"))
# 0.9509041939207385

这是 95%。我们要记住这一点。

现在，我们可以实现一个例如 300 次迭代的随机搜索。

result = []

# Number of iterations
N_search = 300

# Random seed initialization
np.random.seed(1)

for i in range(N_search):
    # Generate a random number of features
    N_columns =  list(np.random.choice(range(data.shape[1]),1)+1)

    # Given the number of features, generate features without replacement
    columns = list(np.random.choice(range(data.shape[1]), N_columns, replace=False))

    # Perform k-fold cross validation
    scores = cross_val_score(lr,data[:,columns], target, cv=5, scoring="accuracy")

    # Store the result
    result.append({'columns':columns,'performance':np.mean(scores)})

# Sort the result array in descending order for performance measure
result.sort(key=lambda x : -x['performance'])

在循环和排序函数结束时，result列表的第一个元素就是我们所寻找的对象。

我们可以使用这个值来计算该特征子集的新性能指标。

np.mean(cross_val_score(lr, data[:,result[0][‘columns’]], target, cv=5, scoring=”accuracy”))
# 0.9526741054251634

如你所见，准确率有所提高。

结论

随机搜索可以成为执行特征选择的强大工具。它并不是用来解释某些特征为何比其他特征更有用（与递归特征消除等其他特征选择程序相对），但它可以作为一个有用的工具，以更少的时间获得良好的结果。

原文。经许可转载。

相关：

• 特征提取的搭车指南

• 前向特征选择：Python 中的实际示例

• 多目标优化特征选择

相关主题

• 使用网格搜索和随机搜索进行超参数调优的 Python 实践

• 特征选择：科学与艺术的交汇

• 机器学习中的替代特征选择方法

• 机器学习模型的高级特征选择技术

• 通过 Uplimit 的机器学习课程提升你的搜索引擎技能！

• 构建视觉搜索引擎 - 第二部分：搜索引擎

特征选择：科学与艺术的交汇点

原文：www.kdnuggets.com/2021/12/feature-selection-science-meets-art.html

由 Mahbubul Alam，数据科学家、经济学家和定量研究员

图片由 David Clode 提供，来源于 Unsplash

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织进行 IT 管理

---

有人说特征选择和工程是数据科学项目中最重要的部分。在许多情况下，不是复杂的算法，而是特征选择在模型性能中起到了决定性作用。

特征过少可能导致模型欠拟合。例如，如果你想预测房价，仅知道卧室数量和楼层面积是不够的。你忽略了买家关心的许多重要变量，例如位置、学区、房产年龄等。

你也可以从另一个角度出发，选择 100 个不同的特征来描述每一个细节，例如物业上的树木名称。与其增加更多信息，这些特征却会增加噪声和复杂性。许多选择的特征可能根本不相关。此外，特征过多还会增加训练模型的计算成本。

那么，要构建一个好的预测模型，应该选择多少特征，如何决定保留哪些特征、丢弃哪些特征以及添加哪些新特征？这是在机器学习项目中管理所谓的偏差-方差权衡时的重要考虑因素。

这也是“科学”与“艺术”相遇的地方。

本文的目的是揭示特征选择技术，并进行一些简单的实现。我在下面描述的技术应该在回归和分类问题中同样有效。无监督分类（例如聚类）可能有点棘手，所以我会单独讨论。

启发式方法

我们在数据科学中不常谈论启发式方法，但它实际上是相当相关的。我们来看一下定义（来源：Wikipedia）：

启发式或启发式技术….采用了一种不保证最优、完美或理性的实用方法，但仍足以达到即时的短期目标或近似值。

如果基于直觉进行特征选择，这个定义同样适用。仅通过观察数据集，你会有一种直觉，感觉某些特征是强预测因子，而其他一些与依赖变量无关，你会觉得可以安全地去除它们。

如果你不确定，可以进一步检查特征与依赖变量之间的相关性。

数据集中有太多特征时，仅凭这些启发式方法——直觉和相关性——就可以完成大部分选择合适特征的工作。

例如，假设你的公司正在为不同渠道（电视、广播、报纸）分配广告预算。你想预测哪个渠道作为广告平台最有效，以及预期的回报是什么。

在你建立模型之前，你查看了历史数据，并发现了不同平台上的广告费用与相应销售收入之间的关系。

双变量散点图显示了不同平台上的销售和广告支出之间的关系（图源：作者；数据源：ISLR，许可证：GLP 2，公共领域）。

基于散点图，你认为哪些特征最能解释广告收入？显然，报纸广告对结果没有显著影响，因此你可能想从模型中去除它。

自动化特征选择

接下来我们将介绍自动化特征选择技术。大多数这些技术都集成在sklearn模块中，因此你只需用几行代码就能实现特征选择，格式也很标准。

作为演示，我将使用‘iris’数据集（来源：Kaggle/UCI 机器学习，许可证：CC0 公共领域）。这是一个简单的数据集，只有 5 列，不过你会掌握关键点。

让我们从seaborn库加载数据集。

# import seaborn library
**import seaborn as sns**# load iris dataset
**iris = sns.load_dataset('iris')
iris.head(5)**

# separate features (X) from the target (y) variable
**X = iris.drop('species', axis=1)
y = iris['species']**

在数据集中，“species”是我们想预测的目标，其余的 4 列是预测变量。让我们以编程方式确认特征的数量：

# number of predictors in the current dataset
**X.shape[1]**>> 4

现在我们来实现一些特征选择技术。

1) 基于卡方的技术

基于卡方的技术根据一些评分选择用户定义的特征数量（k）。这些评分通过计算 X（独立）和 y（依赖）变量之间的卡方统计量来确定。

sklearn有内置的卡方特征选择方法。你需要做的就是确定要保留多少个特征（例如，对于鸢尾花数据集，k=3）。

# import modules **from sklearn.feature_selection import SelectKBest, chi2**# select K best features
**X_best = SelectKBest(chi2, k=3).fit_transform(X,y)** 

现在让我们确认我们从 4 个特征中选择了 3 个最佳特征。

# number of best features
**X_best.shape[1]**>> 3

对于大量特征，你可以指定希望保留或丢弃的特征百分比。这与上述方法类似。假设我们希望保留 75%的特征，丢弃剩余的 25%。

# keep 75% top features 
**X_top = SelectPercentile(chi2, percentile = 75).fit_transform(X,y)**# number of best features
**X_top.shape[1]**>> 3

2) 基于杂质的特征选择

基于树的算法（例如随机森林分类器）具有内置的feature_importances_属性。

决策树会使用减少杂质的特征来划分数据（杂质的度量标准为基尼杂质或信息增益）。这意味着，找到最佳特征是算法解决分类问题的关键部分。我们可以通过feature_importances_属性来访问最佳特征。

首先让我们将“鸢尾花”数据集拟合到具有 200 个估计器的随机森林分类器上。

# import model
**from sklearn.ensemble import RandomForestClassifier**# instantiate model
**model = RandomForestClassifier(n_estimators=200, random_state=0)**# fit model
**model.fit(X,y)**

现在让我们通过属性调用来访问特征的重要性。

# importance of features in the model
**importances = model.feature_importances_****print(importances)**>> array([0.0975945 , 0.02960937, 0.43589795, 0.43689817])

上述输出显示了每个特征在减少每个节点/分裂的杂质方面的重要性。

由于随机森林分类器有许多估计器（例如，上述 200 棵决策树），我们可以计算相对重要性的估计值及其置信区间。让我们将其可视化。

# calculate standard deviation of feature importances 
**std = np.std([i.feature_importances_ for i in model.estimators_], axis=0)**# visualization**feat_with_importance  = pd.Series(importances, X.columns)****fig, ax = plt.subplots()
feat_with_importance.plot.bar(yerr=std, ax=ax)
ax.set_title("Feature importances")
ax.set_ylabel("Mean decrease in impurity")
fig.tight_layout()**

图：特征在杂质度量中的重要性（来源：作者）

现在我们知道了每个特征的重要性，我们可以手动（或通过视觉）确定要保留哪些特征，删除哪些特征。

另外，我们可以利用 Scikit-Learn 的元转换器SelectFromModel来为我们完成这项工作。

# import the transformer
**from sklearn.feature_selection import SelectFromModel**# instantiate and select features
**selector = SelectFromModel(estimator = model, prefit=True)
X_new = selector.transform(X)
X_new.shape[1]**>> 2

3) 正则化

正则化是机器学习中的一个重要概念，用于减少过拟合（详见：通过正则化避免过拟合）。如果特征过多，正则化可以控制它们的影响，方法是缩小特征系数（称为 L2 正则化/岭回归）或将某些特征系数设为零（称为 L1 正则化/LASSO 回归）。

一些线性模型具有内置的 L1 正则化作为超参数来惩罚特征。这些特征可以通过元转换器SelectFromModel来消除。

让我们实现LinearSVC算法，超参数为penalty = ‘l1’。然后我们将使用SelectFromModel来移除一些特征。

# implement algorithm
**from sklearn.svm import LinearSVC
model = LinearSVC(penalty= 'l1', C = 0.002, dual=False)
model.fit(X,y)**# select features using the meta transformer
**selector = SelectFromModel(estimator = model, prefit=True)
X_new = selector.transform(X)
X_new.shape[1]**>> 2# names of selected features
**feature_names = np.array(X.columns)
feature_names[selector.get_support()]**>> array(['sepal_length', 'petal_length'], dtype=object)

4) 顺序选择

顺序特征选择是一种古老的统计技术。在这种情况下，你一个接一个地将特征添加到模型中（或从模型中移除），检查模型性能，然后启发式地选择要保留的特征。

顺序选择有两种变体。前向选择技术从零特征开始，然后添加一个最小化误差的特征；然后再添加另一个特征，以此类推。后向选择则在相反的方向上工作。模型从所有特征开始并计算误差；然后它会删除一个进一步最小化误差的特征，以此类推，直到剩下所需数量的特征。

Scikit-Learn 模块有SequentialFeatureSelector元变换器来简化操作。请注意，它适用于sklearnv0.24 或更高版本。

# import transformer class
**from sklearn.feature_selection import SequentialFeatureSelector**# instantiate model
**model = RandomForestClassifier(n_estimators=200, random_state=0)**# select features
**selector = SequentialFeatureSelector(estimator=model, n_features_to_select=3, direction='backward')
selector.fit_transform(X,y).shape[1]**>> 3# names of features selected
**feature_names = np.array(X.columns)
feature_names[selector.get_support()]**>> array(['sepal_width', 'petal_length', 'petal_width'], dtype=object)

替代技术……

除了我刚才描述的技术，还有一些其他方法可以尝试。其中一些方法并不是专门为特征选择设计的，但如果你深入挖掘，你会发现它们可以被创造性地应用于特征选择。

• Beta 系数：你在进行线性回归后得到的系数（Beta 系数）显示了因变量对每个特征的相对敏感性。从这里你可以选择具有高系数值的特征。

• p 值：如果你在经典统计软件包（例如statsmodels）中实现回归，你会发现模型输出包括每个特征的 p 值（查看此内容）。p 值测试的是系数是否恰好为零的原假设。因此，你可以排除那些与高 p 值相关的特征。

• 方差膨胀因子（VIF）：VIF 通常用于检测数据集中的多重共线性。统计学家通常会删除具有高 VIF 的变量，以满足线性回归的关键假设。

• 赤池信息量准则（AIC/BIC）：通常 AIC 和 BIC 用于比较两个模型之间的性能。但你可以利用它们进行特征选择，例如选择某些特征以获得在 AIC/BIC 度量下更好的模型质量。

• 主成分分析（PCA）：如果你知道 PCA 是什么，你猜对了。它不完全是特征选择技术，但 PCA 的降维特性可以用于这一效果，而不是完全消除特征。

• 以及其他许多： 有相当多的其他特征选择类，这些类随sklearn模块一起提供，查看文档。最近也在一篇科学论文中提出了一种基于聚类的算法。费舍尔评分（Fisher’s Score）也是另一种可用的技术。

聚类怎么样？

聚类是一种无监督的机器学习算法，这意味着你将数据输入到聚类算法中，算法会根据某些“属性”来确定如何将数据分成不同的簇。这些属性实际上来自于特征。

聚类是否需要特征选择？当然需要。没有合适的特征，聚类可能会毫无用处。假设你想要对客户进行细分，以便销售高端、中端和低端产品。这意味着你隐含地使用了客户收入作为一个因素。你还可以将教育因素考虑进去。他们的年龄和工作经验呢？当然。但随着特征数量的增加，算法可能会对你想要达到的目标感到困惑，因此输出结果可能不会完全符合你的期望。

也就是说，数据科学家在运行聚类算法时并不是在孤立的环境中进行，他们通常有一个假设或问题在心中。因此，特征必须对应于这个需求。

摘要

数据科学家非常重视特征选择，因为它对模型性能有很大影响。对于低维数据集，启发式方法和直觉效果很好，但对于高维数据，有自动化技术可以完成这项工作。最有用的技术包括卡方检验和基于杂质的算法以及正则化和序列特征选择。此外，还有其他替代技术，如回归中的贝塔系数、p 值、VIF、AIC/BIC 和降维。

在这篇文章的标题中，我提到“科学遇见艺术”。这是因为特征选择没有对错之分。我们可以使用科学工具，但最终，可能是由数据科学家做出的主观决策。

感谢阅读。欢迎 订阅 以接收我即将发布的文章，或通过 Twitter 或 LinkedIn 与我联系。

简历：Mahbubul Alam 拥有超过 8 年的数据科学工作经验，主要应用于政策和商业决策，并与政府和非政府组织的利益相关者密切合作，帮助通过数据驱动的解决方案做出更好的决策。Mab 对统计建模和数据科学的各个方面充满热情——从调查设计和数据收集到构建先进的预测模型。Mab 还教授/指导了一门数据科学和商业分析课程，专为早期到中期职业分析师、团队负责人以及转型为数据科学的 IT 专业人员或在其组织内构建数据科学能力的人员设计。

原文。经许可转载。

相关：

• 警惕自动特征选择 — 卡方独立性检验示例

• 特征选择 – 你想了解的一切

• 从头开始：ML 可解释性的排列特征重要性

更多相关内容

• 机器学习中的替代特征选择方法

• 机器学习模型的高级特征选择技术

• 特征存储峰会 2022：关于特征工程的免费会议

• 检索增强生成：信息检索与文本生成的结合

• 线性回归模型选择：平衡简洁性与复杂性

• 确保 LLMs 的可靠少量样本提示选择

特征存储作为机器学习的基础

原文：www.kdnuggets.com/2021/02/feature-store-foundation-machine-learning.html

评论

由 German Osin，Provectus 的高级解决方案架构师。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你在 IT 领域的组织

---

图像由 Yurchanka Siarhei 提供，来源于 shutterstock。

人工智能和机器学习已达到一个转折点。在 2020 年，各种规模的组织开始将他们的机器学习项目从实验阶段发展到工业规模的生产阶段。在这个过程中，他们意识到自己在特征定义和提取上浪费了大量时间和精力。

特征存储是机器学习栈和任何强大数据基础设施的一个基本组件，因为它使得特征工程和管理变得高效。它还允许特征的简单重用、公司内部的特征标准化，以及离线和在线模型之间的特征一致性。一个集中的、可扩展的特征存储可以使组织更快地创新，并在大规模上推动机器学习过程。

Provectus 的团队已经构建了多个特征存储，我们希望分享我们的经验和经验教训。在这篇文章中，我们将探讨特征存储如何帮助消除返工，并在团队之间强制执行从源头到模型的数据可追溯性。我们将深入了解构建可扩展特征存储的具体细节，并讨论如何在实时和训练特征之间实现一致性，以及如何通过时间旅行改善数据的可重复性。

什么是特征存储？

特征存储是机器学习特征的数据管理层。机器学习特征是被观察现象的可测量属性，如原始词汇、像素、传感器值、数据存储中的数据行、CSV 文件中的字段、聚合（最小值、最大值、总和、均值）或衍生表示（嵌入或聚类）。

从业务角度来看，特征存储提供了两个主要好处：

1. 通过降低每个模型的成本，从特征工程中获得更好的投资回报率，这促进了特征的协作、共享和重用。

2. 通过提高 ML 工程师的生产力，加快新模型的市场投放时间。这使组织能够将存储实现和特征服务 API 从 ML 工程师中解耦，解放他们去专注于模型，而不是延迟问题，从而更高效地进行在线服务。

一些使用场景不需要集中式、可扩展的特征存储。特征存储适用于那些模型需要有状态、不断变化的系统表示的项目。这些使用场景的例子包括需求预测、个性化和推荐引擎、动态定价优化、供应链优化、物流和运输优化、欺诈检测以及预测性维护。

特征存储的概念

标准化的特征存储具有围绕它的一些关键概念。这些概念包括：

1. 在线特征存储。在线应用程序查找一个特征向量，该向量被发送到 ML 模型进行预测。

2. ML 特定元数据。支持特征的发现和重用。

3. ML 特定 API 和 SDK。用于获取训练特征集和在线访问的高级操作。

4. 物化版本化数据集。维护用于训练 ML 模型的特征集的版本。

图片来源：作者。

上述所有概念都在图像中表示。分析数据从数据湖中获取，并通过特征工程管道推送，输出结果存储在特征存储中。从那里，ML 工程师可以发现特征，使用它们来训练新模型，然后重用这些特征进行服务。

这四个概念得到了多个产品的支持。市场上的领导者包括 Feast、Tecton、Hopsworks 和 AWS SageMaker 特征存储。我们将重点关注开源产品：Feast 和 Hopsworks。

#1 Feast

Feast 是一个 ML 服务，帮助团队弥合数据与机器学习模型之间的差距。它允许团队在生产环境中注册、摄取、服务和监控特征。

该服务处于积极开发阶段，但已在 GoJek、Farfetch、Postmates 和 Zulily 中经过实际测试。它可以与 Kubeflow 集成，并且得到 Kubeflow 强大社区的支持。

截至 2020 年，Feast 仅支持 GCP。它在基础设施上要求较高，缺乏可组合性，也不提供数据版本控制。请注意，公司计划在 2021 年的路线图中解决这些挑战。从 2020 年 11 月起，Feast 作为 Tecton 的开源版本 发布。

图片来源：作者。

#2 Hopsworks

Hopsworks是一个用于开发和操作 AI 应用的企业平台。它使团队能够快速高效地管理机器学习特性。Hopsworks 背后的团队是特性存储的倡导者，他们提供了许多优秀的教育内容。

Hopsworks 特性存储可以与大多数 Python 库进行集成，用于数据摄取和训练。它还支持具有时间旅行功能的离线存储。最重要的是，它支持 AWS、GCP、Azure 和本地部署。

使 Hopsworks 使用起来具有挑战性的原因在于其对 HopsML 基础设施的高度依赖。此外，Hopsworks 在线存储可能无法满足所有的延迟要求。

图片来源于作者。

现代数据平台的挑战

在研究构建特性存储的具体细节之前，必须考虑现代数据平台的挑战。特性存储不能孤立于其他数据和机器学习基础设施之外进行审视。

传统的标准数据湖架构如下所示：

图片来源于作者。

这种高级架构包含了数据源、数据摄取、数据处理、数据持久化、数据查询以及消费者组件。虽然它在大多数任务中表现良好，但并不理想。

数据访问和发现性 可能会成为一个问题。数据分散在多个数据源和服务中。这曾经有助于保护数据，但现在仅增加了新的复杂性，并造成数据孤岛。这种架构需要管理 AWS IAM 角色、Amazon S3 策略、API 网关和数据库权限的繁琐过程。在多账户设置中，这个问题变得更加复杂。因此，工程师对数据的存在以及实际可以访问的数据感到困惑，因为元数据默认情况下是不可发现的。这导致由于数据访问问题，数据和机器学习的投资受到限制。

单体数据团队是另一个需要考虑的问题。由于数据和机器学习团队非常专业化，他们往往需要在脱离上下文的情况下工作。缺乏所有权和领域背景会导致数据生产者和数据消费者之间出现数据孤岛，使得一个积压的数据团队很难跟上业务需求。在这种情况下，数据和机器学习工程会受到复杂依赖的困扰，无法同步操作。在这种情况下，任何快速的端到端实验都是不可能的。

机器学习实验基础设施 是未知领域。传统架构缺乏实验组件，这不仅导致数据发现和数据访问问题，还使得维护数据集、ML 流水线、ML 环境和离线实验的可重复性变得更加复杂。尽管 Amazon SageMaker 和 Kubeflow 在这方面取得了一些进展，但可重复性仍然是一个问题。生产实验框架不成熟，无法完全依赖。因此，从数据到生产 ML 推送一个端到端实验可能需要三到六个月。

在生产中扩展 ML 是复杂的，需要大量的时间和精力。虽然机器学习主要讨论的是离线活动（如数据收集、处理、模型训练、结果评估等），但实际应用中模型的使用和服务方式才是关键。使用传统架构时，无法以统一和一致的方式在模型服务期间访问特征，也无法在多个训练流水线和 ML 应用之间重用特征。ML 应用的监控和维护也更加复杂。因此，从 1 到 100 个生产模型的扩展所需的时间和成本呈指数增长，这限制了组织按预期速度创新的能力。

新兴的架构转变

为了解决这些挑战，出现了几种架构转变：

1. 从数据湖到 Hudi/Delta 湖。数据湖不仅仅是 Amazon S3 中的一个文件夹。它是一个功能丰富、完全托管的数据摄取、增量处理和服务的层，具有 ACID 事务和时间点查询。

2. 从数据湖到数据网格。数据领域、数据管道、元数据和 API 的所有权正在从集中式团队转移到产品团队。另一个有影响的好处是将数据视为完整的产品而不是没人关心的副产品。

3. 从数据湖到数据基础设施平台。如果数据的所有权是分散的，平台组件必须统一并打包成一个可重用的数据平台。

4. 从端点保护到全球数据治理。作为向集中式数据平台转变的一部分，组织正在从端点保护转向全球数据治理，这是一个更高级别的控制计划，用于管理跨可用数据源的安全性和数据访问政策。

5. 从元数据存储到全球数据目录。像 Hive 元数据存储这样的元数据存储无法聚合多个数据源。行业需要一个全球数据目录，以支持数据发现、数据血缘和版本控制的用户体验。

6. 特征库。特征库是 ML 堆栈中新兴的组件，通过为 ML 特征添加独立的数据管理层，实现了 ML 实验和操作的扩展。

所有这些转换都是并行进行的，应该从整体上考虑。你不能在设计功能存储时，却拥有独立的数据目录来处理功能和其他数据应用。在构建功能存储时，你必须依赖数据版本控制功能，这可以轻松成为其他并行项目的一部分。

在继续之前，简要介绍一下驱动上述从离散 ML 作业到 MLOps 转变的四个主要组成部分，以提供功能存储重要性的更广泛背景。

#1 Delta/Hudi 数据湖

ACID 数据湖支持管理的摄取、ML 训练的高效数据集版本控制、廉价的“删除”以实现 GDPR/CCPA 合规，以及用于数据摄取的“更新”。它们还提供审计日志来跟踪数据集的变化和 ACID 事务，同时通过模式强制执行数据质量。Delta 和 Hudi 数据湖将流处理引入大数据，比传统的批处理更高效地提供新鲜数据。

#2 全球数据治理

由于在用户级别管理 AWS IAM 角色、Amazon S3 策略、API 网关和数据库权限不再是标准，公司应该使用全公司范围的数据治理结构来：

1. 通过你已有的数据加速隐私操作。 自动化业务流程、数据映射以及隐私工作流中的 PI 发现和分类。

2. 在中央位置实现政策操作。 管理隐私政策以确保政策在整个企业中得到有效管理。定义和记录工作流、可追溯性视图和业务流程登记簿。

3. 在多个法规中实现合规性。 使用以隐私为设计和构建的可以轻松扩展以支持新法规的平台。

#3 全球数据目录

虽然这里没有单一的市场领导者，但 Marquez、Amundsen、Apache Atlas、Collibra、Alation 和 Data Hub 值得一提。

全球数据目录对于回答以下问题非常有用：这些数据存在吗？它在哪里？这些数据的真实来源是什么？我是否有访问权限？谁是所有者？这些数据的用户是谁？是否有现有的资产可以重复使用？我可以信任这些数据吗？基本上，它充当了一种元数据存储的角色。

#4 可重复的机器学习管道

最终的组成部分是可重复的机器学习管道用于实验。

作者提供的图片。

上图表示了 MLOps 和可重复实验管道的架构。它以四个输入开始：ML 模型代码、ML 管道代码、基础设施即代码和版本化数据集。版本化数据集——你的机器学习管道的输入——应该来自功能存储。

现代数据基础设施

现在让我们来看一下现代数据基础设施。

作者提供的图片。

我们对原始数据进行批处理，对事件数据进行流处理。我们将处理后的成果存储在冷存储中用于业务报告，并在近实时、增量更新的热索引中用于我们的 API。相同的数据可以在这两种场景中使用，为了保持一致性，我们使用不同的 pub/sub 系统。

这是数据平台的传统架构。其目标是提供冷存储和热存储之间的一致性，并允许通过数据目录、数据质量和全球安全进行发现，同时在其基础上实现细粒度控制。

图片来源：作者。

如果我们查看功能存储设计，我们将看到功能和基础设施组件几乎与数据平台中的内容完全相同。在这种情况下，功能存储不是一个带来另一个摄取系统、存储、目录和质量门控的独立孤岛。它充当数据平台与 ML 工具之间的轻量级 API。它可以很好地与数据基础设施中已完成的内容集成。它应该是可组合和轻量的，并且没有偏向的设计。

图片来源：作者。

当你开始设计和构建数据基础设施时，请考虑迄今为止的以下“经验教训”：

1. 在投资功能存储之前，从设计一个一致的 ACID 数据湖开始。

2. 现有开源产品的价值并不足以支持对集成及其带来的依赖的投资。

3. 功能存储不是一种新的基础设施和数据存储解决方案，而是一个集成到现有数据基础设施中的轻量级 API 和 SDK。

4. 数据目录、数据治理和数据质量组件是整个数据基础设施的横向组件，包括功能存储。

5. 目前没有成熟的开源或云解决方案用于全球数据目录和数据质量监控。

参考架构

图片来源：作者。

这张图展示了我们为客户使用的参考架构。它展示了我们选择使用的服务，但你不应被我们的选择所限制。这里的想法是，你必须根据数据工作负载和业务需求选择冷存储和热存储。

对于热存储，你可以选择 DynamoDB、Cassandra、Hbase 或传统的 RDBMS，如 Mysql、PostgreSQL，甚至 Redis。重要的是你的热存储应该是可组合、可插拔的，并与数据基础设施战略相一致。

对于冷存储，Apache Hudi 和 Delta Lake 是我们的最爱。它们提供如时间旅行、增量摄取和物化视图等功能。

图表中有一些空白区域，我们希望尽快填补。例如，到目前为止，数据目录领域尚无市场领先者。数据质量工具也处于早期阶段。目前，你可以选择 Great Expectations 或 Apache Deequ，这些都是很好的工具，但它们未提供完整解决方案。

图像由作者提供。

在上图中，问号占据了你可以从开源社区构建的解决方案、内部自行构建的解决方案或与云服务提供商（例如 AWS 最新的 Amazon SageMaker 机器学习特征存储）合作的空间。

继续推进特征存储

尽管特征存储仍处于早期阶段，但那些不仅仅在实验而是积极将机器学习项目投入生产的组织已经意识到需要一个集中式存储库来存储、更新、检索和共享特征。

在本文中，我们展示了如何设计和构建这样的存储库。尽管这里的一些观点有争议，并且欢迎社区反馈，但很明显：

1. 你的现有数据基础设施应覆盖至少 90% 的特征存储需求，包括流式摄取、一致性、数据目录和版本控制，以实现预期效果。

2. 构建一个轻量级的特征存储 API 以与现有的内部存储解决方案集成是有意义的。

3. 你应该与社区和云供应商合作，以保持与标准和最新生态系统的兼容性。

4. 随着市场的成熟，你应该准备迁移到托管服务或开源替代方案。

原文。经许可转载。

相关内容：

• 特征存储与数据仓库

• 机器学习堆栈中的关键缺失部分

• 特征提取的搭车指南

更多相关话题

• 特征存储峰会 2022：关于特征工程的免费会议

• 特征存储峰会 2023：部署 ML 的实用策略…

• 机器学习元数据存储

• 基础模型是什么？它们如何工作？

• Segment Anything Model: 图像分割的基础模型

• 生产环境机器学习的元数据存储！

特征存储——如何避免感觉每天都是土拨鼠日

原文：www.kdnuggets.com/2021/05/feature-stores-how-avoid-feeling-every-day-is-groundhog-day.html

评论

由Monte Zweben，Splice Machine 首席执行官。

数据科学家的工作遵循一个周期：登录、清理数据、定义特征、测试和构建模型，并确保模型运行顺畅。听起来足够简单，但周期中的所有部分并不相同：数据准备占据了任何数据科学家80%的时间。无论你在做什么项目，大多数日子里你都在清理数据并将原始数据转换成机器学习模型可以理解的特征。单调的数据准备工作将小时混合在一起，使每一天的工作感觉与之前的一天相同。

为什么你不能更有效地完成这一繁琐的过程？

你可以通过特征存储来实现。一个特征存储是一个可共享的特征库，用于自动化数据输入、跟踪和治理到机器学习模型中。特征存储计算和存储特征，使它们可以在公司内部注册、发现、使用和共享。特征存储确保特征始终为预测保持最新，并以一致的方式维护每个特征值的历史，以便模型可以无缝地进行训练和再训练。

那么，这将如何为你节省时间呢？很高兴你问了。

重用特征和 ETL 管道

首先，特征存储允许你为每个创建的模型重用特征和数据管道。无需再等待数据工程师定制的 ETL 管道，也不需要从以前的模型中复制、粘贴和调整特征定义——只需搜索、查找并使用你想要的特征。

一致的模型监控

此外，特征存储允许你确保生成特征的代码与已部署模型所见的代码相同。由于特征存储使用相同的管道来获取特征和训练集，它们会自动保持一致。这使得评估和训练模型变得简单，特别是在规模较大时，你开始失去对不同训练集存储位置和更新时间的追踪。

例如，在训练时每周汇总开始于周日，而在部署时开始于周一，这样的做法会导致不一致性。使汇总在两个情况下都在同一天开始，可以更容易地识别模型或特征漂移。此外，如果出现问题，重新训练模型也会更简单，因为可以参考单一位置的真实数据点。

避免数据泄露

从历史值创建训练集本身就是复杂的，但当你构建一个需要定期重新训练的模型时，检索不同的时间序列特征集会更加麻烦。编写复杂的 SQL 时间连接是一项繁重的工作，通常超出了大多数数据科学家的技能范围。很容易出现错误，可能会影响模型的效果。

特征存储记录特征被观察到的时间，以及何时被添加到特征存储中，因此你可以在任何时间点识别特征的值。通过记录这些时间戳，特征存储系统自动实现了构建训练集时的时点准确性。这使得在准确数据上训练模型变得非常容易，并且可以自动重新训练模型而无需担心数据泄露。

很多人认为数据科学家大部分时间都在测试和构建模型，但模型的运行离不开对数据的处理。特征存储系统跟踪每个数据管道、特征以及所有相关的元数据，使得构建模型所需的各个部分都可以重用、轻松共享，并完全透明以供审查。通过确保每项任务只需完成一次，你可以节省时间和精力，专注于其他项目。特征存储系统是效率的明智选择；如果你想了解它们对整个业务规模的影响，你可以阅读我的博客文章，"你需要一个特征存储系统吗？"

个人简介： Monte Zweben 是 Splice Machine 的联合创始人兼首席执行官，Splice Machine 是一家实时 AI 公司。作为一位技术行业资深人士，Monte 的早期职业生涯在 NASA 艾姆斯研究中心担任人工智能部门副主任期间，他因在航天飞机项目中的贡献获得了著名的太空行动奖。Monte 随后转向创业领域，创办了业内领先的 Blue Martini 和 Red Pepper Software 初创公司。Monte 曾在《哈佛商业评论》、各种计算机科学期刊和会议论文集中发表文章。他曾担任 Rocket Fuel Inc. 的主席，并在卡内基梅隆大学计算机科学学院的院长咨询委员会任职。

相关：

• 特征存储作为机器学习的基础

• 特征存储与数据仓库

• 机器学习栈中的一个关键缺失部分

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

更多相关主题

• 实时 AI 和机器学习中的特征存储

• 特征存储峰会 2022：关于特征工程的免费会议

• 避免这 5 个 AI 初学者常犯的错误

• 我每天使用 ChatGPT 5 个月，这里有一些隐藏的宝藏…

• 你应该避免数据科学职业的 5 个主要理由

• 新手数据科学家应避免的错误

实时 AI 和机器学习的特征存储

原文：www.kdnuggets.com/2022/03/feature-stores-realtime-ai-machine-learning.html

实时 AI/ML 用例 如欺诈预防和推荐系统正在上升，特征存储在成功部署这些系统到生产环境中扮演了关键角色。根据流行的开源特征存储 Feast，用户在其 社区 Slack 中最常问的问题之一是：Feast 的可扩展性/性能如何？这是因为实时 AI/ML 的特征存储最重要的特性是从在线存储到机器学习模型的特征服务速度，以便进行在线预测或评分。成功的特征存储可以满足严格的延迟要求（以毫秒为单位），一致地（考虑 p99），以及大规模（每秒高达 100K 查询，甚至每秒数百万查询，以及 GB 到 TB 级别的数据集），同时保持低的总体拥有成本和高精度。

正如我们将在这篇文章中看到的，在线特征存储的选择以及特征存储的架构在确定其性能和成本效益方面起着重要作用。因此，通常公司在选择在线特征存储之前，会进行详细的基准测试，以查看哪种架构或在线特征存储最具性能和成本效益。在这篇文章中，我们将回顾由成功部署实时 AI/ML 用例的公司构建的 DIY 特征存储的架构和基准测试，以及开源和商业特征存储。让我们开始吧。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织进行 IT 管理

---

1. 开源 Feast

首先，我们来看看基准测试数据，然后是 Feast 开源特性存储的数据架构。Feast 最近进行了一项基准测试，以比较使用不同在线存储（Redis 与 Google Cloud DataStore 与 AWS DynamoDB）时的特性服务延迟，并比较使用不同机制提取特性时的速度（例如，Java gRPC 服务器、Python HTTP 服务器、lambda 函数等）。你可以在这篇博客文章中找到完整的基准设置及其结果，但结论是 Feast 发现使用Java gRPC 服务器和Redis作为在线存储时表现最为出色。

来源：视频

在上图中，你可以看到一个例子，展示了流行的在线抵押贷款公司 Better.com 如何使用开源的 Feast 特性存储来实施他们的潜在客户评分排名系统，如 Vitaly Sergey，Better.com 的高级软件工程师所展示的那样：特性从离线存储（S3、Snowflake 和 Redshift）被物化到在线存储（Redis）。此外，特性还从流数据源（Kafka 主题）被摄取到在线存储中。Feast 最近增加了对流数据源的支持（除了批处理数据源），目前仅支持 Redis。支持流数据源对实时 AI/ML 用例非常重要，因为这些用例依赖于最新的实时数据。例如，在 Better 的潜在客户评分用例中，新潜在客户在一天内不断被摄取，特性来自许多不同的来源，并且用于评分的实体（潜在客户）和特性会不断更新，潜在客户会被排名和重新排名。每当有新的潜在客户时，它会被模型摄取和评分，同时被摄取到在线存储中，因为我们可能希望在不久后重新排名。对于 Better.com，潜在客户在 48 小时后过期，这在 Redis 在线存储中通过简单地将 TTL（生存时间）设置为 48 小时来实现，以便在 48 小时后使实体（潜在客户）和关联特征向量过期。因此，特性存储会自动清理自己，没有过期的实体或特性占用宝贵的在线存储空间。

Feast 的另一个有趣实现是用于 Microsoft Azure Feature Store。你可以查看它的 架构，它运行在针对低延迟实时 AI/ML 用例优化的 Azure 云上，支持批量和流式数据源，并且集成到 Azure 数据和 AI 生态系统中。特性从批量数据源（Azure Synapse Serverless SQL、Azure Storage / ADLS）和流式数据源（Azure Event Hub）中摄取到在线存储中。如果你已经部署在 Azure 上或对 Azure 生态系统熟悉，那么这个特性存储可能是适合你的。对于在线存储，它使用 Azure Cache for Redis，并且通过 Azure Redis 的企业级方案，它包括主动地理复制，以创建全球分布的缓存，具有高达 99.999% 的可用性。此外，通过使用企业级 Flash 层，可以通过在分层内存架构中运行 Redis 实现进一步的成本降低，该架构使用内存（DRAM）和 Flash 存储（NVMe 或 SSD）来存储数据。

2. Wix DIY 特性存储 - MLOps 平台的基石

以下是实现实时 AI/ML 用例的另一种特性存储架构。它是流行网站建设平台 Wix 的特性存储架构。特性存储用于实时用例，如推荐、流失与高端预测、排名和垃圾邮件分类器，被认为是其 MLOps 平台的基石。Wix 服务于超过 2 亿注册用户，其中只有一小部分是任何时间点的活跃用户。这对特性存储的实现方式产生了重大影响。让我们来看一下。以下信息基于 Ran Romano 在 Wix 负责 ML 工程时所做的 TechTalk 演讲。Wix 特性存储中存储的数据中超过 90% 是点击流，ML 模型根据网站或用户触发。Ran 解释说，对于实时用例，延迟是一个大问题，并且对于一些生产用例，他们需要在毫秒内提取特征向量。

来源：视频

原始数据存储在 AWS 的 S3 存储桶中的 Parquet 文件里，并按业务单元（例如‘编辑器’、‘餐馆’、‘预订’等）和日期进行分区。这是 Wix 数据平台的一部分，早于 Wix ML Platform 存在多年。在一个每日构建的批处理过程中（使用 Spark SQL，耗时从几分钟到几小时），所有用户历史特征从 S3 中提取，经过透视和按用户聚合后，导入到离线存储（Apache Hbase）。这提供了更快速的‘用户’历史查找。一旦系统检测到用户当前处于活动状态，将触发‘预热’过程，并将该用户的特征加载到在线存储（Redis）中，因为在线存储比离线存储小，只保存活动用户的历史。此‘预热’过程可能需要几秒钟。最后，在线特征存储中的特征会使用直接来自用户每个事件的实时数据（使用 Apache Storm）持续更新。

这种架构的写入与读取的比率低于 Feast 架构，在物化和在线存储方面非常高效，因为它仅在在线存储中存储活动用户的特征，而不是所有用户的特征。而且，由于在 Wix 活跃用户只是所有注册用户的一小部分，这代表了巨大的节省。然而，这也有代价。虽然从在线存储中检索特征非常快，通常在毫秒级别，但前提是这些特征已经存在于在线存储中。由于竞争条件，有些用户的特征可能因预热过程需要几秒钟，无法快速加载相关特征，从而导致该用户的评分或预测失败。这是可以接受的，只要用例不是关键流程的一部分或任务关键用例，例如批准交易或防止欺诈。这种架构也非常特定于 Wix，其中任何时间只有一小部分用户是活跃用户。

3. 商业特征存储 Tecton

现在让我们来看一下商业企业特征存储 Tecton 的架构。如下面的图所示，除了批处理数据源和流数据源外，Tecton 还支持‘开箱即用’的实时数据源，也称为‘实时特征’或‘实时’转换。实时特征是只能在推理请求时计算的特征，例如怀疑交易的大小与最后一次交易的大小之间的差异。因此，如果在上面提到的 Better.com 的开源 Feast 的情况下，Better.com 自行开发了对实时特征的支持，那么在 Tecton 特征存储中，这种实现更为简单，因为它已经被特征存储原生支持。

与 Feast 和 Wix 功能存储类似，Tecton 也在注册表中定义特性，从而使离线和在线存储的逻辑定义只定义一次，显著减少了训练与服务的不一致性，以确保 ML 模型在生产中的高准确度。

来源: 博客文章

关于离线存储、在线存储和基准测试：对于离线功能存储，Tecton 支持 S3；对于在线存储，Tecton 现在为客户提供了在 DynamoDB 和 Redis Enterprise Cloud 之间的选择。在最近的演讲中，Tecton CTO Kevin Stumpf 提供了如何选择在线功能存储的建议，基于公司最近进行的基准测试。除了基准测试延迟和吞吐量外，Tecton 还基准测试了成本。为什么这很重要？对于高吞吐量或低延迟用例，在线存储的成本可能是整个 MLOps 平台总拥有成本中的一个大而重要的部分，因此任何节省的成本都可能是可观的。

Tecton 基准测试的核心结论是，对于 Tecton 用户典型的高吞吐量用例，Redis Enterprise比 DynamoDB 快 3 倍，同时价格便宜 14 倍。

那么问题在哪呢？例如，如果你只有一个用例，并且它没有高或稳定的吞吐量，也没有严格的延迟要求，那么你可以选择 DynamoDB。你可以在这里找到详细信息和Tecton 基准测试的结果。

4. Lightricks 使用商业功能存储 Qwak

下面是另一个功能存储架构示例，这是Lightricks基于商业功能存储Qwak使用的。Lightricks 是一家开发视频和图像编辑移动应用的独角兽公司，特别以其自拍编辑应用 Facetune 而闻名。它使用功能存储来支持其推荐系统。

来源: AIGuild 视频

如上图所示，类似于 Tecton，Qwak 功能存储也支持即插即用的三种特性来源——批处理、流处理和实时特性。

值得注意的是，Qwak 特征存储中，特征的物化直接来自原始数据源，适用于离线存储（使用 S3 上的 Parquet 文件）和在线存储（使用 Redis）。这与 Wix、Feast 或 Tecton 的特征存储示例不同，这些示例中物化到在线存储是从离线存储到在线存储进行的批处理源。为什么这很重要？这种做法的优势在于，不仅特征的转换逻辑在训练和服务流程中是一致的（如 Feast、Wix 和 Tecton 的特征存储），而且实际的转换或特征计算也以统一的方式进行，进一步减少了训练与服务的不一致性。直接从原始数据建立统一的数据管道，有可能在生产过程中确保更高的准确性。你可以在此演示文稿中找到更多关于 Qwak 的 特征存储架构和组件 的信息。

摘要

在这篇文章中，我们回顾了多个实时 AI/ML 特征存储的基准和架构的关键亮点。第一个是开源 Feast，第二个是 DIY Wix 特征存储，第三个是 Tecton，第四个是 Qwak。我们还回顾了这些公司进行的一些基准测试，以了解哪个在线存储性能最佳且成本最有效，以及使用哪种机制或特征服务器从在线存储中提取特征。我们看到，根据架构、支持的特征类型和选择的组件，特征存储的性能和成本存在显著差异。

娜瓦·莱维 是 Redis 的数据科学和 MLOps 开发者倡导者。她的职业生涯始于 IDF 的研发部门，后来有幸在云计算、大数据以及深度学习/机器学习/人工智能技术初兴之际与这些领域合作并推广。娜瓦还是 MassChallenge 加速器的导师，以及 LerGO——一个基于云的教育科技企业的创始人。在闲暇时，她喜欢骑自行车、四球杂技以及阅读奇幻和科幻书籍。

更多相关主题

• 2022 年特征存储峰会：关于特征工程的免费会议

• 机器学习中的替代特征选择方法

• 机器学习模型的高级特征选择技术

• 机器学习中的特征工程实用方法

• 特征选择：科学与艺术的结合

• 构建一个可操作的多变量时间序列特征工程流程

联邦学习：协作机器学习及如何入门教程

原文：www.kdnuggets.com/2021/12/federated-learning-collaborative-machine-learning-tutorial-get-started.html

联邦学习：实验室和实际应用中的隐私、安全性和数据主权（附教程）

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能。

3. Google IT 支持专业证书 - 为你的组织提供 IT 支持。

---

联邦学习，也称为协作学习，允许在保持数据分布在生成数据的设备上的情况下进行大规模的模型训练。敏感数据保留在数据所有者处，训练过程仅通过模型更新让集中训练协调器看到每个客户端的贡献。

联邦学习本身并不能保证隐私（稍后我们将讨论如何破解和修复联邦学习系统中的隐私问题），但它使隐私成为可能。

联邦学习的应用场景：

• 移动电话键盘的下一个词预测（例如 McMahan 等人 2017， Hard 等人 2019）

• 健康研究（例如 Kaissis* 等人* 2020， Sadilek 等人 2021）

• 自动驾驶汽车（例如 Zeng* 等人* 2021， OpenMined 博客文章）

• “智能家居”系统（例如 Matchi* 等人* 2019， Wu* 等人* 2020）

• … 以及其他任何机器学习预测可能有用的地方，但个人宁愿在选择时不放弃他们的个人数据。这几乎涵盖了所有在个体分辨率下进行预测的场景。

随着公众和政策制定者对数据经济的认识不断提高，对隐私保护机器学习的需求也在上升。因此，数据实践受到越来越多的审视，对尊重隐私的工具，如联邦学习的研究也越来越活跃。理想情况下，联邦学习旨在保护个人和机构的隐私，同时在因商业秘密、私人健康信息或数据泄露风险增加而通常不可能的情况下，使数据相关方之间的合作成为可能。

像欧盟的通用数据保护条例或加州消费者隐私法案（以及其他法规）这样的政府规章使得像联邦学习这样的隐私保护策略成为企业保持合法运营的有用工具。同时，在保持模型性能和效率的同时实现所需的隐私和安全程度，仍然面临着许多技术挑战。

最后，从普通数据提供者（如很可能的你，亲爱的读者）的日常角度来看，至少在理论上，有一种方法可以在你的私人健康和财务数据与跟踪你在线上所做的所有其他事情的数据经纪人混杂的生态系统之间架起一道屏障，这种生态系统通常缺乏道德基础和安全能力，真是令人欣慰。

如果这些问题引起了你的兴趣，那么继续阅读，了解联邦学习的复杂性以及它在敏感数据上的机器学习中能做些什么。

联邦学习概述

联邦学习旨在从多个数据源训练一个单一模型，前提是数据保持在源头，不被数据源（即节点、客户端或工作者）或协调训练的中央服务器（如果存在的话）交换。

在典型的联邦学习方案中，中央服务器将模型参数发送到一组节点（也称为客户端或工作者）。这些节点在本地数据上对初始模型进行若干次更新，并将新训练的权重发送回中央服务器，中央服务器对新的模型参数进行平均（通常考虑到每个节点上进行的训练量）。在这种情况下，任何一个节点上的数据都不会被中央服务器或其他节点直接看到，额外的技术，如安全聚合，能够进一步增强隐私。

在这个框架内有许多变体。例如，本文主要关注由中央服务器管理的联邦学习方案，该服务器协调多个相同类型设备的训练，每个设备训练自己的本地数据并将结果上传到中央服务器。这是McMahan 等人在 2017 年描述的基本方案。然而，也可以去掉集中控制的训练，在某些情况下，这可能是值得的。当单个节点分担中央管理的角色时，这就变成了去中心化的联邦学习，这是一种吸引人的方法，用于在特权医疗数据上训练协作模型。

虽然一个典型的联邦学习场景可能涉及到一群移动电话，例如，所有电话具有大致相似的计算能力并训练相同的模型架构，但一些方案，例如 Diao et al. 2021提出的HeteroFL，允许在具有截然不同通信和计算能力的各种设备上训练单个推理模型，甚至可以训练具有不同架构和参数数量的本地模型，然后将训练好的参数汇聚到一个全局推理模型中。

联邦学习的主要优势源于数据保持在生成它的设备上，例如，一个训练数据集通常比正在训练的模型大得多，发送后者而不是前者可以节省带宽。这些优势中最重要的是隐私的可能性，但仅凭模型参数更新仍然可能推测出私人数据集的内容。

McMahan et al. 2017 年使用的简单示例来解释漏洞是一个使用“词袋”输入向量训练的语言模型，其中每个输入向量特定对应于大型词汇表中的单个单词。每个非零梯度更新对于相应的单词会给窃听者提供关于该单词在私人数据集中存在（或缺失）的线索。更复杂的攻击也已被证明。因此，联邦学习中可以融入各种隐私增强技术，从安全聚合更新到使用全同态加密进行训练。我们将在下一节简要讨论联邦学习中最突出的隐私威胁及其缓解措施。

联邦学习的持续起源故事

数据隐私的州级监管是一个新兴的政策领域，大约在个人数据收集和分析的全球经济大部分发展之后的 10 到 20 年才获得了动量。最突出的个人数据监管是 2016 年颁布的欧洲通用数据保护条例，更常被称为 GDPR。

可能会让人感到惊讶的是，鉴于美国类似的保护措施限制公司监视和数据收集仍处于萌芽阶段或缺失，但美国白宫在 2012 年发布了一份详细的报告，概述了类似的原则（pdf），包括聚焦收集、数据安全和透明度、对收集数据的控制，以及对收集数据用于一个目的而不会用于无关目的的期望。

加州消费者隐私法在 2018 年跟随欧盟的 GDPR 成为法律。作为一项州法律，加州消费者隐私法的地理范围相较于 GDPR 显著有限，尽管该法案有类似的目标，但对个人信息的定义略为狭窄。联邦学习是一种可以用来给隐私带来机会的机器学习工具。

联邦学习这一术语在 McMahan et al. 2017 年的一篇论文中首次提出，用于描述在分散数据上训练模型。作者根据上述 2012 年白宫关于消费者数据隐私的报告，为他们的系统设计策略进行了框架构建。他们提出了联邦学习的两个主要应用场景：图像分类，以及用于语音识别或下一个词/短语预测的语言模型。

不久之后，分布式训练相关的潜在攻击面就被展示出来了。Phong et al. 2017 和 Bhowmick et al. 2018等人的研究表明，即使仅访问来自联邦学习客户端的梯度更新或部分训练模型，也可以推断出描述私有数据的一些细节。有关隐私问题及其缓解的总结可以在inpher.io 的这篇博客文章中找到。

联邦学习在隐私、有效性和效率之间的平衡涉及广泛的范围。服务器与客户端之间（或仅在去中心化客户端之间）的通信可以在传输和静态状态下加密，但还有一种更强大的选项，即数据和模型在训练期间也保持加密。同态加密可以用于对加密数据进行计算，因此（理想情况下）只有持有密钥的利益相关者才能解密结果。像 OpenMined 的PySyft、微软的SEAL或TensorFlow Encrypted这样的库提供了可应用于联邦学习系统的加密深度学习工具。

关于联邦学习的讨论到此为止，接下来我们将在教程部分设置一个简单的联邦学习演示。

联邦 ML 教程：使用 Flower 库在鸢尾花数据集上进行联邦学习

如果你在运行此教程代码时遇到任何问题，并希望查看一个有效的示例，可以尝试通过浏览器运行这个 mybinder 链接并按照readme中的说明启动联邦学习演示。

现在我们对使用联邦学习的场景和原因有了了解，让我们实际看看如何操作。

可供选择的联邦学习库有很多，从更主流的Tensorflow Federated（在 GitHub 上有超过 1700 个星标）到流行且注重隐私的PySyft，再到面向研究的FedJAX。表 1 包含了流行联邦学习库的参考列表。

名称	仓库	许可证/星标	重点
TF Federated	github.com/tensorflow/federated	Apache 2.0/ 1.7k	研发
FedJAX	github.com/google/fedjax	Apache 2.0 / 130	研究
Flower	github.com/adap/flower	Apache 2.0 / 529	可用性
FedML	github.com/FedML-AI/FedML	Apache 2.0 / 839	研究
PySyft	github.com/openmined/pysyft	Apache 2.0 / 7.7k	隐私 / 研发
IBM federated-learning-lib	github.com/IBM/federated-learning-lib	Custom / 244	企业

***表 1: *联邦学习的库。

对于我们的教程，我们将使用 Flower 库。我们选择这个库部分是因为它以一种易于理解的方式展示了基本的联邦学习概念，并且它是框架不可知的，部分原因是我们将使用包含在 SciKit-Learn 中的“iris”数据集（名称也匹配）。

由于 Flower 对用于构建模型的深度学习工具包是不可知的（他们在文档中提供了 TensorFlow、 PyTorch、 MXNet 和 SciKit-Learn 的示例），我们将使用 PyTorch。从高层次来看，我们需要设置一个服务器和一个客户端，后者我们将用不同的训练数据集调用两次。设置服务器无疑是手头任务中最简单的，因此我们将从这里开始。

要设置我们的服务器，我们需要做的只是定义一个评估策略，并将其传递给 Flower 中的默认配置服务器。但首先，让我们确保我们已经设置了一个虚拟环境，其中包含所有我们需要的依赖项。在 Unix 命令行中：

virtualenv flower_env python==python3
source flower_env/bin/activate
pip install flwr==0.17.0

# I'm running this example on a laptop (no gpu)
# so I am installing the cpu only version of PyTorch
# follow the instructions at https://pytorch.org/get-started/locally/
# if you want the gpu option

pip install torch==1.9.1+cpu torchvision==0.10.1+cpu \
    -f https://download.pytorch.org/whl/torch_stable.html

pip install scikit-learn==0.24.0

在我们的虚拟环境启动并运行后，我们可以编写一个模块来启动一个 Flower 服务器以处理联邦学习。在下面的代码中，我们包含了 argparse，以便在从命令行调用服务器模块时更容易尝试不同的训练轮数。我们还定义了一个生成评估函数的函数，这是我们对 Flower 服务器默认配置策略的唯一补充。

我们的服务器模块文件的内容：

import argparse

import flwr as fl
import torch

from pt_client import get_data, PTMLPClient

def get_eval_fn(model):

# This `evaluate` function will be called after every round
def evaluate(parameters: fl.common.Weights):

loss, _, accuracy_dict = model.evaluate(parameters)

return loss, accuracy_dict

return evaluate
if __name__ == "__main__":

parser = argparse.ArgumentParser()
parser.add_argument("-r", "--rounds", type=int, default=3,\
        help="number of rounds to train")

args = parser.parse_args()

torch.random.manual_seed(42)

model = PTMLPClient(split="val")

strategy = fl.server.strategy.FedAvg( \
        eval_fn=get_eval_fn(model),\
        )

fl.server.start_server("[::]:8080", strategy=strategy, \
            config={"num_rounds": args.rounds})

注意上面代码中调用的PTMLPClient。这是服务器模块用来定义评估函数的，同时这个类也是用于训练的模型类，并且还充当联邦学习客户端。接下来我们将定义PTMLPClient，它从 Flower 的NumPyClient类和你在使用 PyTorch 时已经熟悉的torch.nn.Module类中子类化。

NumPyClient类处理与服务器的通信，并要求我们实现抽象函数set_parameters、get_parameters、fit和evaluate。torch.nn.Module类为我们提供了 PyTorch 模型的所有便捷功能，主要是使用 PyTorch Adam 优化器进行训练的能力。我们的PTMLPClient类将略超过 100 行代码，所以我们将逐一讲解每个类函数，从__init__开始。

请注意，我们从两个祖先类中继承。继承自nn.Module意味着我们必须确保通过 super 命令调用__init__，但如果你忘记这样做，Python 会立即提醒你。除此之外，我们初始化了三个密集层作为矩阵（torch.tensor数据类型），并将一些关于训练拆分和模型维度的信息存储为类变量。

class PTMLPClient(fl.client.NumPyClient, nn.Module):

    def __init__(self, dim_in=4, dim_h=32, \
            num_classes=3, lr=3e-4, split="alice"):

        super(PTMLPClient, self).__init__()

        self.dim_in = dim_in
        self.dim_h = dim_h
        self.num_classes = num_classes
        self.split = split

        self.w_xh = nn.Parameter(torch.tensor(\
            torch.randn(self.dim_in, self.dim_h) \
            / np.sqrt(self.dim_in * self.dim_h))\
            )
        self.w_hh = nn.Parameter(torch.tensor(\
            torch.randn(self.dim_h, self.dim_h) \
            / np.sqrt(self.dim_h * self.dim_h))\
            )
        self.w_hy = nn.Parameter(torch.tensor(\
            torch.randn(self.dim_h, self.num_classes) \
            / np.sqrt(self.dim_h * self.num_classes))\
            )

        self.lr = lr

接下来，我们将定义PTMLPClient类的get_parameters和set_parameters函数。这些函数将所有模型参数连接为一个扁平化的 numpy 数组，这是 Flower 的 NumPyClient 类预期返回和接收的数据类型。这适应了联邦学习方案，因为服务器将初始参数发送到每个客户端（使用set_parameters），并期望返回一组部分训练的权重（来自get_parameters）。这种模式每轮出现一次。我们还在set_parameters中初始化优化器和损失函数。

 def get_parameters(self):

        my_parameters = np.append(\
            self.w_xh.reshape(-1).detach().numpy(), \
            self.w_hh.reshape(-1).detach().numpy() \
            )
        my_parameters = np.append(\
        my_parameters, \
            self.w_hy.reshape(-1).detach().numpy() \
            )

        return my_parameters

    def set_parameters(self, parameters):

        parameters = np.array(parameters)

        total_params = reduce(lambda a,b: a*b,\
            np.array(parameters).shape)
        expected_params = self.dim_in * self.dim_h \
            + self.dim_h**2 \
            + self.dim_h * self.num_classes

        assert total_params == expected_params, \
            f"expected {expected_params} params," \
            f" got {total_params} params"

        start = 0
        stop = self.dim_in * self.dim_h
        self.w_xh = nn.Parameter(torch.tensor(\
                parameters[start:stop])\
                .reshape(self.dim_in, self.dim_h).float() \
                )

        start = stop
        stop += self.dim_h**2
        self.w_hh = nn.Parameter(torch.tensor(\
                parameters[start:stop])\
                .reshape(self.dim_h, self.dim_h).float() \
                )

        start = stop
        stop += self.dim_h * self.num_classes
        self.w_hy = nn.Parameter(torch.tensor(\
                parameters[start:stop])\
                .reshape(self.dim_h, self.num_classes).float()\
                )

        self.act = torch.relu

        self.optimizer = torch.optim.Adam(self.parameters())
        self.loss_fn = nn.CrossEntropyLoss()

接下来，我们将定义前向传播和一个用于获取损失标量的便捷函数。

 def forward(self, x):
        x = self.act(torch.matmul(x, self.w_xh))
        x = self.act(torch.matmul(x, self.w_hh))
        x = torch.matmul(x, self.w_hy)

        return x

    def get_loss(self, x, y):

        prediction = self.forward(x)
        loss = self.loss_fn(prediction, y)

        return loss

我们客户端所需的最后几个函数是fit和evaluate。在每一轮中，每个客户端都会用 fit 方法提供的参数初始化其参数，然后进行几轮训练（在这种情况下默认是 10 轮）。evaluate函数还会在计算训练数据验证拆分上的损失和准确性之前设置其参数。

 def fit(self, parameters, config=None, epochs=10):

        self.set_parameters(parameters)

        x, y = get_data(split=self.split)
        x, y = torch.tensor(x).float(), torch.tensor(y).long()

        self.train()
        for ii in range(epochs):
            self.optimizer.zero_grad()
            loss = self.get_loss(x, y)

            loss.backward()
            self.optimizer.step()

        loss, _, accuracy_dict = self.evaluate(self.get_parameters())

        return self.get_parameters(), len(y), \
                {"loss": loss, "accuracy": \
                accuracy_dict["accuracy"]}

    def evaluate(self, parameters, config=None):

        self.set_parameters(parameters)

        val_x, val_y = get_data(split="val")
        val_x = torch.tensor(val_x).float()
        val_y = torch.tensor(val_y).long()

        self.eval()

        prediction = self.forward(val_x)

        loss = self.loss_fn(prediction, val_y).detach().numpy()

        prediction_class = np.argmax(\
            prediction.detach().numpy(), axis=-1)
        accuracy = sklearn.metrics.accuracy_score(\
            val_y.numpy(), prediction_class)

        return float(loss), len(val_y), \
            {"accuracy":float(accuracy)}

我们客户端类中的fit和evaluate都调用了一个名为 get_data 的函数，它只是 SciKit-Learn 鸢尾花数据集的一个包装器。它还将数据拆分为训练集和验证集，并进一步将训练数据集拆分成两个部分（我们称之为‘alice’和‘bob’），以模拟具有各自数据的客户端的联邦学习。

def get_data(split="all"):

    x, y = sklearn.datasets.load_iris(return_X_y=True)

    np.random.seed(42); np.random.shuffle(x)
    np.random.seed(42); np.random.shuffle(y)

    val_split = int(0.2 * x.shape[0])
    train_split = (x.shape[0] - val_split) // 2

    eval_x, eval_y = x[:val_split], y[:val_split]

    alice_x, alice_y = x[val_split:val_split + train_split], \
    y[val_split:val_split + train_split]
    bob_x, bob_y = x[val_split + train_split:], \
    y[val_split + train_split:]

    train_x, train_y = x[val_split:], y[val_split:]

    if split == "all":
        return train_x, train_y
    elif split == "alice":
        return alice_x, alice_y
    elif split == "bob":
        return bob_x, bob_y
    elif split == "val":
        return eval_x, eval_y
    else:
        print("error: split not recognized.")
        return None

现在我们只需在文件底部填充一个if __name__ == "__main__":方法，以便我们可以从命令行运行我们的客户端代码作为模块。

if __name__ == "__main__":

    parser = argparse.ArgumentParser()

    parser.add_argument("-s", "--split", type=str, default="alice",\
    help="The training split to use, options are 'alice', 'bob', or 'all'")

    args = parser.parse_args()

    torch.random.manual_seed(42)

    fl.client.start_numpy_client("localhost:8080", \
        client=PTMLPClient(split=args.split))

最后，确保在客户端模块的顶部导入所有需要的内容。

import argparse
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.metrics
import torch
import torch.nn as nn
from functools import reduce
import flwr as fl

这就是我们需要实现的全部内容，以运行带有 Flower 的联邦训练演示！

要开始联邦训练运行，首先在自己的命令行终端中启动服务器。我们将服务器保存为 pt_server.py，将客户端模块保存为 pt_client.py，均位于我们正在工作的目录的根目录，因此为了启动服务器并指示其进行 40 轮联邦学习，我们使用了以下命令。

python -m pt_server -r 40

接下来，打开一个新的终端以启动第一个使用“alice”训练集的客户端：

python -m pt_client -s alice

... 再打开一个终端以进行下一个使用“bob”训练集的客户端。

python -m pt_client -s bob

如果一切顺利，你应该会看到训练启动并且终端中显示出信息滚动。

在我们的手中，这个演示在 20 轮训练中达到了 96%以上的准确率。训练过程中的损失和准确率曲线如下：

就这样！现在你可以在你的联邦学习简历上添加“Flower library”。

展望联邦学习的未来

现代世界的一个随意观察者可能会被说服相信“隐私不复存在”。这些声明主要针对互联网（这些声明自至少 1999 年就已存在），但随着智能家居设备和好奇的家庭机器人迅速普及，合理的隐私预期，即使在你自己的家中，也可能面临灾难性的侵蚀。

注意谁在做这些声明，你会发现许多人对你数据的轻松盗取有既得经济利益，或者可能依赖于那些有此利益的人。这种“无隐私”的失败主义态度不仅是错误的，而且可能是危险的：隐私的丧失使个人和群体可以被微妙地操控，以至于他们可能没有注意到或承认，而知道自己被监视的人 行为会有所不同。

简历：Kevin Vu 管理 Exxact Corp 博客，并与许多撰写关于深度学习不同方面的才华横溢的作者合作。

原文。经许可转载。

更多相关主题

• 如何用医疗数据实施联邦学习项目

• 协同过滤的直观解释

• 开放助理：探索开放和协作的可能性……

• 7 个适合初学者的 ChatGPT 项目

• 10 门免费必修的数据科学课程

• 为何提升数据可视化技能很重要（以及如何入门）

联邦学习：简介

原文：www.kdnuggets.com/2020/04/federated-learning-introduction.html

评论

机器学习能力的进步带来了重大的数据隐私问题。尤其是在用从用户与设备（如智能手机）交互中获得的数据来训练机器学习模型时，这一点尤为明显。

所以最大的问题是，我们如何在不共享个人可识别数据的情况下训练和改进这些设备上的机器学习模型？这是我们在探讨一种被称为联邦学习的技术时所要回答的问题。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速迈向网络安全职业

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT 需求

---

集中式机器学习

传统的机器学习模型训练过程涉及将数据上传到服务器并使用这些数据训练模型。只要数据隐私不是问题，这种训练方式就很有效。

然而，当涉及到训练包含个人可识别数据的机器学习模型时（例如在设备上，或在如医疗保健等对数据特别敏感的行业中），这种方法就变得不适用了。

在集中式服务器上训练模型也意味着你需要巨大的存储空间，以及一流的安全性以避免数据泄露。但想象一下，如果你能够使用存储在用户设备上的本地数据来训练模型……

去中心化数据上的机器学习

引入：联邦学习。

联邦学习是一种模型训练技术，使得设备能够通过共享模型进行协作学习。共享模型首先在服务器上使用代理数据进行训练。然后，每个设备下载模型，并使用来自设备的联邦数据来改进模型。

设备使用本地可用的数据训练模型。对模型所做的更改会被总结为更新，然后发送到云端。训练数据和个体更新都保留在设备上。为了确保这些更新更快地上传，模型使用随机旋转和量化进行压缩。当设备将其特定的模型发送到服务器时，这些模型会被平均以获得一个综合模型。这个过程会重复多次，直到获得高质量的模型。

source

与中心化机器学习相比，联邦学习有几个特定的优势：

• 确保隐私，因为数据保持在用户的设备上。

• 更低的延迟，因为更新后的模型可以在用户的设备上进行预测。

• 更智能的模型，由于协作训练过程。

• 降低能耗，因为模型是在用户的设备上进行训练的。

为了确保应用程序的用户体验不受影响，模型训练在用户设备连接到空闲 WiFi、处于空闲状态且连接到电源时进行。

TensorFlow Federated

TensorFlow 通过利用其自己的框架来实现联邦学习。

TensorFlow Federated (TFF) 是一个用于在去中心化数据上进行机器学习和其他计算的开源框架。

TFF 有两层：Federated Learning (FL) API 和 Federated Core (FC) API。Federated Learning (FL) API 允许开发者将联邦训练和评估应用到现有的 TensorFlow 模型中。

Federated Core (FC) API 是联邦学习的核心基础。它是用于在强类型功能编程环境中编写联邦算法的低级接口系统，结合了分布式通信操作。

联邦学习的一个示例应用是 Google 的 Gboard 键盘。

Federated Learning for Mobile Keyboard Prediction

我们使用一种名为联邦的分布式设备学习框架训练递归神经网络语言模型……

在这种情况下，使用去中心化的设备数据集训练递归神经网络语言模型。其目标是在智能手机键盘上预测下一个词。

source

使用联邦平均算法在客户端设备上训练模型被证明比使用随机梯度下降的服务器训练效果更好。该算法在服务器上用于结合来自客户端的更新并生成新的全球模型。

在这种情况下，使用联邦学习使下一个词预测准确率提高了 24%。Gboard 体验的其他改进包括增强的表情符号和 GIF 预测。这意味着用户在使用 Gboard 时现在能看到更相关的表情符号和 GIF。

我希望这能激发你对联邦学习的兴趣，以及它在推动新的设备训练、应用个性化和增强数据隐私方面的潜力。

如果是这样，请查看下面的资源以了解更多信息：

Federated Learning: Strategies for Improving Communication Efficiency

联邦学习是一种机器学习设置，其目标是训练一个高质量的集中模型，同时…

TensorFlow Federated

系统的核心是用于简洁表达新颖联邦算法的一组低级接口…

联邦学习：无需集中训练数据的协作机器学习

标准机器学习方法要求将训练数据集中到一台机器或数据中心。而…

迈向规模化联邦学习：系统设计

联邦学习是一种分布式机器学习方法，它使得在大规模语料上进行模型训练成为可能…

个人简介： 德里克·穆伊提 是数据分析师、作家和导师。他致力于在每项任务中取得出色结果，并且是 Lapid Leaders Africa 的导师。

原文。转载经许可。

相关内容：

• 研究指南：机器学习模型的高级损失函数

• 分析 GDPR 罚款 – 谁是最大的违规者？

• 深度学习深度估计研究指南

更多相关话题

• 联邦学习：协作机器学习教程…

• 如何使用医疗数据实施联邦学习项目

• 回到基础第 3 周：机器学习简介

• KDnuggets 新闻，4 月 27 日：关于 Papers With Code 的简要介绍；…

• 统计学习导论，Python 版：免费书籍

• 深度学习库简介：PyTorch 和 Lightning AI

使用元学习的少样本图像分类

原文：www.kdnuggets.com/2020/03/few-shot-image-classification-meta-learning.html

评论

作者：Etienne Bennequin，Sicara 数据科学家

你并不总是有足够的图像来训练深度神经网络。这里是如何教你的模型从少量例子中快速学习的方法。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

为什么我们关心少样本学习？

1980 年，福岛邦彦 开发了第一个卷积神经网络。从那时起，随着计算能力的提升和机器学习社区的巨大努力，深度学习算法在计算机视觉相关任务上的表现不断提高。2015 年，微软的 Kaiming He 及其团队报告称，他们的模型在 ImageNet 图像分类上表现优于人类。此时，可以说计算机在利用数十亿张图像解决特定任务方面已经超越了我们。太棒了！

然而，如果你不是 Google 或 Facebook，你通常无法构建一个包含那么多图像的数据集。当你从事计算机视觉工作时，有时需要用每个标签仅有的一到两个例子来分类图像。在这方面，人类依然无可匹敌。给一个婴儿看一张大象的照片，他们以后将永远不会错过识别大象。如果你用你的 Resnet50 做同样的事情，你可能会对结果感到失望。这种从少量例子中学习的问题被称为少样本学习。

近年来，少样本学习问题在研究界引起了广泛关注，许多优雅的解决方案也应运而生。目前最受欢迎的解决方案使用的是元学习，或者用三句话总结：学习如何学习。如果你想了解它是什么以及它如何应用于少样本图像分类，请继续阅读。

少样本图像分类任务

首先，我们需要定义 N-way K-shot 图像分类任务。给定：

1. 一个由 N 个标签组成的支持集，对于每个标签，有 K 个标记图像；

2. 一个由 Q 个查询图像组成的查询集；

任务是将查询图像分类到 N 个类别中的一个，给定 N×K 张支持集中的图像。当 K 很小（通常 K<10）时，我们称之为“少样本图像分类”（在 K=1 的情况下称为“一样本分类”）。

少样本分类任务示例：给定支持集中每个 N=3 类别的 K=2 个实例，我们希望将查询集中的 Q=4 只狗标记为拉布拉多犬、圣伯纳犬或斗牛犬。即使你从未见过任何斗牛犬、圣伯纳犬或拉布拉多犬，这对你来说也会很简单。但要用 AI 解决这个问题，我们将需要一些元学习。

元学习范式

在 1998 年，Thrun & Pratt指出，给定一个任务，算法在任务上表现出“如果其性能随着经验的积累而提高”，则该算法正在“学习”；而对于一组任务，算法在“每个任务的性能随着经验和任务数量的增加而提高”时，则称该算法在“学习学习”。我们将最后一种称为元学习算法。它不是学习如何解决特定的任务，而是不断学习解决许多任务。每当它学习一个新任务时，它在学习新任务的能力上会变得更强：它学会了学习。

从形式上来说，如果我们想要解决一个任务 T，元学习算法是在一批训练任务{Tᵢ}上进行训练的。算法从解决这些任务的尝试中获得的训练经验被用来解决最终任务 T。

例如，考虑上图所示的任务 T。该任务包括使用来自 3x2=6 张标记图像的信息，将图像标记为拉布拉多犬、圣伯纳犬或斗牛犬。一个训练任务 Tᵢ可能是将图像标记为拳师犬、拉布拉多贵宾犬或罗威纳犬，使用来自 3x2=6 张标记图像的信息。元训练过程是一系列这些任务 Tᵢ，每次使用不同的犬种。我们期望元学习模型“随着经验和任务数量的增加”变得更好。最后，我们在任务 T 上评估模型。

我们在拉布拉多犬、圣伯纳犬和斗牛犬上评估元学习模型，但我们只在其他犬种上进行训练。

那么我们怎么做呢？假设你想解决任务 T（涉及拉布拉多犬、圣伯纳犬和斗牛犬）。那么你将需要一个包含大量不同品种犬的元训练数据集。例如，你可以使用斯坦福犬数据集，该数据集包含从 ImageNet 中提取的超过 2 万只犬。我们将这个数据集称为 D。请注意，D 不需要包含任何拉布拉多犬、圣伯纳犬或斗牛犬，过程仍然能够进行。

从 D 中我们抽取批次的集（见下文）。每一集对应一个 N-way K-shot 分类任务 Tᵢ，这类似于 T（通常我们使用相同的 N 和 K）。在模型解决批次中的每一集后（即标记了每个查询集的图像），它的参数会被更新。这通常通过反向传播在查询集上的分类不准确性得到的损失来完成。

这样，模型可以在任务之间学习，以准确解决新的、未见过的少样本分类任务。标准的学习分类算法将学习一个映射image→label，而元学习算法通常学习一个映射support-set→c(.)，其中c是一个映射query→label。

元学习算法

现在我们知道算法进行元训练是什么意思，仍然有一个谜团：元学习模型如何解决少样本分类任务？当然，解决方案不止一个。在这里，作为真正的酷孩子，我们将专注于最流行的解决方案。

度量学习

度量学习的基本思想是学习数据点（如图像）之间的距离函数。它在解决少样本分类任务中已被证明非常有用：度量学习算法通过将查询图像与标记图像进行比较来分类查询图像，而不是在支持集（少量标记图像）上进行微调。

查询（右侧）与每个支持集图像进行比较。其标签取决于哪些图像最接近。

当然，你不能逐像素比较图像，所以你要做的是在相关的特征空间中比较图像。为了明确，让我们详细说明度量学习算法如何解决少样本分类任务（定义为标记示例的支持集和我们想要分类的图像的查询集）：

1. 我们从所有支持集和查询集图像中提取嵌入（通常使用卷积神经网络）。现在，我们在少样本分类任务中需要考虑的每个图像都由一个 1 维向量表示。

2. 每个查询的分类取决于它与支持集图像的距离。距离函数和分类策略都有许多可能的设计选择。一个例子是欧几里得距离和 k-最近邻。

3. 在元训练期间，在每一集的末尾，CNN 的参数通过反向传播从查询集（通常是交叉熵损失）分类错误中得到的损失进行更新。

每年发布几个度量学习算法来解决少样本图像分类的两个原因是：

1. 它们在经验上效果很好；

2. 唯一的限制是你的想象力。有许多方法可以提取特征，还有更多的方法可以比较这些特征。我们现在将介绍一些现有的解决方案。

匹配网络算法。特征提取器对于支持集图像（左）和查询图像（底部）是不同的。查询的嵌入与支持集中的每个图像进行余弦相似度比较。然后通过 softmax 进行分类。图来自 Vinyals et al.

匹配网络（见上文）是首个使用元学习的度量学习算法。在这种方法中，我们不会以相同的方式提取支持图像和查询图像的特征。Oriol Vinyals 及其来自 Google DeepMind 的团队想到使用 LSTM 网络 使所有图像在特征提取过程中相互作用。他们称之为 全上下文嵌入，因为你允许网络在知道不仅是要嵌入的图像，还包括支持集中的所有其他图像的情况下找到最合适的嵌入。这使得他们的模型比所有图像通过简单的 CNN 时表现更好，但也需要更多时间和更大的 GPU。

在更近期的工作中，我们不再将查询图像与支持集中的每个图像进行比较。来自多伦多大学的研究人员提出了 原型网络。在他们的度量学习算法中，在从图像中提取特征后，我们为每个类别计算一个 prototype。为此，他们使用了该类别中每个图像的嵌入的均值。（但你可以想象有成千上万种方法来计算这些嵌入。这个函数只需要是可微的，以便进行反向传播。）一旦计算出原型，就使用欧几里得距离对查询进行分类（见下文）。

在原型网络中，我们将查询 X 标记为最接近的 prototype 的标签。

尽管其简单性，原型网络仍然取得了最先进的成果。后来开发了更复杂的度量学习架构，如 一种表示距离函数的神经网络 （而不是欧几里得距离）。这稍微提高了准确性，但我认为直到今天，原型思想仍然是少样本图像分类领域度量学习算法中最有价值的思想（如果你不同意，请留下愤怒的评论）。

模型无关元学习

我们将以 模型无关元学习 （MAML）结束这次回顾，目前这是最优雅和最有前途的元学习算法之一。它基本上是最纯粹形式的元学习，具有 两个层次的神经网络反向传播。

该算法的核心思想是训练一个神经网络，使其能够快速适应新的分类任务，只需少量样本。我在下面提供了 MAML 如何在一次元训练（即在从 D 中采样的少量样本分类任务 Tᵢ上）中工作的可视化。假设你有一个用????参数化的神经网络 M：

MAML 模型的元训练步骤，用????参数化。

1. 创建 M 的副本（这里称为 f）并用????初始化它（图中，????₀=????）。

2. 快速在支持集上微调 f（仅需少量梯度下降）。

3. 在查询集上应用微调后的 f。

4. 将分类错误所产生的损失反向传播整个过程，并更新????。

然后，在下一个阶段，我们创建更新后的模型 M 的副本，运行新的少样本分类任务，依此类推。

在元训练过程中，MAML 学习初始化参数，使模型能够快速高效地适应新少样本任务及新的未见过的类别。

公平地说，MAML 目前在流行的少样本图像分类基准测试中表现不如度量学习算法。由于存在两个训练层次，因此训练起来非常困难，超参数搜索更加复杂。此外，元反向传播需要计算梯度的梯度，因此你必须使用近似方法才能在标准 GPU 上训练。由于这些原因，你可能会更愿意在家庭或工作项目中使用度量学习算法。

但 Model Agnostic Meta-Learning 之所以如此令人兴奋，是因为它是模型无关的。这意味着它可以虚拟地应用于任何神经网络，适用于任何任务。掌握 MAML 意味着能够训练任何神经网络，使其能够快速适应新任务，并且只需少量样本。MAML 的作者 Chelsea Finn 和 Sergey Levine 将其应用于监督式少样本分类、监督式回归和强化学习。但凭借想象力和努力工作，你可以用它将任何神经网络转变为少样本高效神经网络！

这就是对元学习激动人心世界的简要介绍。最近，少样本学习在计算机视觉研究中引起了广泛关注，因此该领域发展非常迅速（如果你在 2020 年阅读这篇文章，我建议你寻找更近期的信息来源）。谁知道在接下来的几年里，神经网络在从一次瞥见中学习视觉概念方面会有多强大？

感谢 Antoine Toubhans、Emna Kamoun、Raphaël Meudec、Hugo Lime、Bastien Ponchon、Nicolas Jean 和 Laurent Montier。

个人简介：Etienne Bennequin（@bennequin）是 Sicara 的数据科学家。

原文。经许可转载。

相关：

• TensorFlow 2.0 教程：优化训练时间性能

• Keras Tuner 的超参数调优实践

• 元学习的少样本图像分类

相关主题

• 使用卷积神经网络（CNNs）进行图像分类

• 使用 Tensorflow 训练图像分类模型指南

• 更多分类问题的性能评估指标

• PyCaret 二分类介绍

• 使用 HuggingFace 对 BERT 进行推特分类微调

• 分类的机器学习算法

利用 FICO Xpress Insight 快速部署 Python 模型

原文：www.kdnuggets.com/2020/08/fico-xpress-insight-python-deployment.html

赞助文章。

在 Gartner 进行的一项研究中，他们发现尽管 AI 和 ML 项目有所进展，大多数分析项目失败的主要原因还是由于无法以业务的速度部署模型。其他几项研究指出，商业用户在分析解决方案开发生命周期中的缺乏参与是核心问题。根据我个人在客户决策过程中利用分析的经验，我观察到类似的模式，并可以证明这些研究的发现。从收集数据中创造业务价值的最大障碍，确实是能够在整个组织中实施分析。

实施分析是一个三重问题。它需要引入（1）业务团队（问题所有者）和（2）数据科学团队（分析主题专家或模型构建者），以及最重要的（3）可以促进这两者之间协作的技术。解决方案开发者在分析项目早期以敏捷方式创建具有丰富可视化的交互式用户界面（应用程序），而不是依赖 IT 在模型开发完成后构建用户界面（应用程序），是形成业务和数据科学团队之间协作的关键。启用这种协作并利用业务团队的实时反馈，还将有助于最终解决方案的采用，同时确保模型得到验证并达到预期。Xpress Insight 旨在减轻 IT 的负担，满足其关键需求，同时赋予业务用户决策和变更管理的所有权。以下是 FICO Xpress Insight 实际客户部署的一些示例：

• 在 4 小时内构建初步原型

• 在 1 个月内与业务用户迭代 57 个应用版本

• 拥有 290+全球活跃用户的协作应用

• 在一个部署的应用程序中每月探索 1,300+商业场景

• 2,500+数据元素输入到每个商业场景中

• 37 种决策逻辑变体已考虑

• 在 9 个月内构建并产品化了 12 个银行优化应用

• 将场景运行时间从 4 天减少到 30 分钟。

数据科学家和运营研究人员现在可以通过拖放功能将他们的 Python 模型部署到 FICO Xpress Insight 中的用户友好、互动性强且可扩展的应用程序中。这些模型可以是任何类型的——统计回归、预测、基于机器学习的、数学规划等——并利用任何优化求解器。用户还可以利用 Python 包生态系统，探索数据，执行和比较模型及其性能。Xpress Insight 是一个可扩展的部署平台，帮助组织以业务的速度构建业务应用程序。它通过将高度复杂的分析或优化模型转化为简单的点击应用程序，来促进数据科学家与业务用户之间的协作，从而帮助做出实际的业务决策。与其让每位数据科学家重复构建最终用户应用程序的常见组件的过程，不如使用 Insight，它在一个可重复的框架中包含了所有核心构建模块，可以与其他数据科学团队成员共享，从而减少开发时间。

FICO Xpress Insight 将以多种方式帮助数据科学团队和业务利益相关者：

• 促进业务用户与数据科学团队之间的协作。

• 帮助数据科学团队通过拖放功能快速构建可扩展的应用程序，无需任何 html/JavaScript 或网页开发知识。

• 使业务用户能够查看最终用户应用程序的早期版本，并提供有关解决方案设计和开发的反馈。

• 帮助数据科学团队使业务用户能够运行模型、执行模拟、比较场景并可视化结果，无需软件足迹。

• 通过内置的用户管理和场景管理减少开发工作量。

• 提供内置的执行负载均衡，数据科学团队可以利用它，而无需额外的开发时间。

• Xpress Insight 与 IT 无关，不受数据限制的影响，且可用于本地安装和云安装。

FICO Xpress Insight 的最新版本引入了 Insight Python 模型部署能力，数据科学家可以利用这一能力轻松部署他们的 Python 模型，只需对代码进行最小的更改。Python 模型部署过程如图 1 所示。

图 1. 使用 FICO Xpress Insight 进行 Python 模型部署 - 工作流

Xpress Insight 允许数据科学家在构建模型时暴露其模型数据和参数。模型数据和参数可以在 Insight 视图中进行编辑，最终用户可以加载默认数据，改变模型数据和参数的值以进行场景分析——所有这些都不会更改原始数据。详细来说，优化或分析模型定义了一组输入实体，以接收场景数据，以及一组结果实体，用于填充优化/分析解决方案。解决方案是代表优化过程确定的决策的值集或分析模型建议的值以及从这些值综合的其他数据。在 FICO Xpress Insight 应用程序中，场景包含模型的输入数据和结果。业务用户可以修改/调整/微调这些分析模型的输入参数，以运行假设分析，并在多个场景之间运行、克隆和比较假设分析，如图 2 所示。

图 2. FICO Xpress Insight 中的场景生命周期

总结来说，FICO Xpress Insight 在开发和部署过程中促进了协作，将业务用户与数据科学团队紧密联系，使业务用户能够快速评估、理解并建立对解决方案的信任，这些解决方案与他们对工作的思考方式相辅相成。

如果你有兴趣了解更多关于 FICO Xpress Insight Python 功能的信息，请访问FICO 优化社区小组。

数据科学家需要采取的 5 个步骤来使用 Insight 部署他们的 Python 模型的快速教程可以在这里找到。

你可以在这里查看 FICO Xpress Insight 的演示。

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 需求

---

更多相关内容

• 从数据收集到模型部署：数据科学项目的 6 个阶段…

• 排名前 7 的模型部署和服务工具

• 机器学习算法的完整端到端部署到…

• 回归基础第 4 周：高级主题和部署

• Segment Anything Model: 图像分割的基础模型

• 可解释 AI：解密模型决策的 10 个 Python 库

使用人工智能进行深度伪造应用的欺诈监控

原文：www.kdnuggets.com/2023/05/fighting-ai-ai-fraud-monitoring-deepfake-applications.html

图片由 Tima Miroshnichenko 提供

深度伪造在数据科学社区中已经讨论了好几年。早在 2020 年，MIT 科技评论 认为深度伪造 达到了其“主流应用的临界点”。

数据确实支持了这一点。华尔街日报 报道称，2018 年在线发现的深度伪造视频不到 10,000 个。现在这些数字已经达到了数百万，并且有很多实际案例表明，深度伪造被用来混淆和误导，以及进行金融欺诈。

Deepfake 技术为网络犯罪分子提供了许多复杂的选项。

它们远远超出了将名人形象插入到“不可错过”的比特币优惠宣传材料中的能力，后者——当然——证明是一个骗局。特别是深度伪造视频，已经成为诈骗犯的关注对象。它们为他们提供了一种通过自动化身份验证和 KYC 检查的方式，并且证明了其恐怖的有效性。

2022 年 5 月，The Verge 报道称，“活体检测”被银行和其他机构用来帮助验证用户身份，但深度伪造技术可以轻易欺骗这些检测。相关研究发现，90%的身份验证系统存在漏洞。

那么答案是什么呢？我们是否正进入一个网络犯罪分子可以轻易利用深度伪造技术来智取金融机构安全措施的时代？这些企业是否必须放弃自动化系统，回归人工检查？

简单的答案是“可能不会”。正如罪犯可以利用 人工智能的进步 一样，目标公司也可以。现在，让我们来看看脆弱的企业如何用人工智能来对抗人工智能。

深度伪造技术是如何工作的？

深度伪造是使用一系列人工智能技术生成的，例如：

• 生成对抗网络（GANs）

• 编码器/解码器对

• 一阶运动模型

从表面上看，这些技术可能听起来像是机器学习领域的专属，具有高门槛和需要专业技术知识的特点。然而，像人工智能的其他元素一样，随着时间的推移，它们变得更加易于获取。

低成本、现成的工具现在允许非技术用户创建深度伪造，就像任何人都可以注册 OpenAI 并测试 ChatGPT 的能力一样。

早在 2020 年，世界经济论坛报告称，制作一个“最先进”的深度伪造视频的成本低于 30,000 美元。但在 2023 年，沃顿商学院教授伊桑·莫利克通过一条病毒式的 Twitter 帖子透露，他在不到六分钟的时间内制作了一个深度伪造视频，展示了他自己进行讲座的过程。

莫利克的总花费为 10.99 美元。他使用了一项名为 ElevenLabs 的服务来几乎完美地模仿他的声音，费用为 5 美元。另一项名为 D-ID 的服务，每月 5.99 美元，仅凭脚本和一张照片生成了视频。他甚至使用了 ChatGPT 来创建脚本本身。

当深度伪造技术首次出现时，主要关注点是伪造的政治视频（以及伪造的色情内容）。自那时以来，世界上已经出现了：

• BuzzFeedVideos 制作了一段深度伪造的公共服务公告，“出演”巴拉克·奥巴马，由演员乔丹·皮尔假扮。

• 一段深度伪造的 YouTube 视频声称展示了特朗普讲述关于驯鹿的故事。

• 一段在《周六夜现场》上播放的深度伪造视频，显示希拉里·克林顿，实际上她是由一位演员扮演的。

虽然这些例子展示了深度伪造的“趣味”侧面，并可能提供了一些关于技术能力的现实感受，但诈骗者没有浪费时间，已经将其用于恶意目的。

现实生活中使用深度伪造技术实施诈骗的例子很多。

深度伪造诈骗造成的损失从数十万到数百万不等。2021 年，一起 AI 声音克隆诈骗用于安排价值 3500 万美元的虚假银行转账。这是一笔巨大的财务收益，甚至不需要使用视频。

AI 输出的质量，特别是视频，可能差异巨大。有些视频对人类来说显然是伪造的。但是，如前所述，过去银行和金融科技等自动化系统已经证明容易受骗。

随着 AI 能力的不断提升，平衡可能会进一步倾斜。最近的进展是“反取证”的应用，其中在深度伪造中添加“目标隐形噪声”，试图欺骗检测机制。

那么可以做些什么呢？

用 AI 对抗 AI：检测深度伪造诈骗

正如诈骗者寻求利用最新的 AI 技术谋取经济利益一样，科技公司等企业也在努力寻找利用技术抓捕罪犯的方法。

以下是一些公司利用 AI 来对抗 AI 的例子：

2022 年底，英特尔推出了一款名为 FakeCatcher 的基于 AI 的工具。凭借英特尔报告的 96% 的可靠性率，该工具使用了一种称为光电容积描记法（PPG）的技术。

该技术利用了在人工生成的视频中不存在的东西：血液流动。经过合法视频训练，其深度学习算法测量血管吸收或反射的光线，血液在体内移动时会改变颜色。

FakeCatcher 作为英特尔负责任 AI 项目的一部分，被描述为“全球首个实时深度伪造检测器，能够在毫秒内返回结果。”这是一项创新技术，寻找视频中显示的人是否真正为人类。它寻找的是“正确”的东西，而不是分析数据来突出“错误”的东西。这就是它指示伪造可能性的方式。

与此同时，布法罗大学（UB）的计算机科学家们一直在开发他们自己的深度伪造检测技术。它利用了那些热衷于 PC 游戏的玩家知道需要巨大处理能力来模拟的东西：光线。

UB 宣称其 AI 工具对伪造照片的有效性达到 94%，该工具观察被摄者眼睛中的光线反射。角膜的表面像镜子一样反射光线，生成“反射模式”。

科学家的研究题为“利用不一致的角膜镜面高光揭示 GAN 生成的面孔”，指出“GAN 合成的面孔可以通过两只眼睛之间的不一致角膜镜面高光被揭示出来”。

这表明，人工智能系统模拟真实高光将是“非平凡”的。PC 玩家通常投资最新的光线追踪显卡，以体验逼真的光效，他们会本能地认识到这里的挑战。

人工智能基础的欺诈检测挑战

也许最大的欺诈检测挑战是欺诈者与试图阻止他们的人员之间无休止的“猫捉老鼠”游戏。很有可能，在如上所述的公告之后，人们已经在致力于开发能够绕过和击败这种检测机制的技术。

存在这样的机制是一回事，但在业务使用的解决方案中常规集成这些机制则是另一回事。之前我们提到的统计数据表明，90% 的解决方案可以“轻易被欺骗”。很可能至少一些金融机构仍在使用这样的系统。

明智的 欺诈监控 策略要求公司在检测深度伪造本身之外有所作为。在欺诈者进入系统参与基于视频的身份验证或 KYC 过程之前，可以做很多工作。早期过程中的预防措施也可能涉及人工智能和机器学习的元素。

例如，机器学习可以用于实时欺诈监控和创建规则集。这些规则集可以查看历史欺诈事件，检测人类可能容易忽视的模式。被认为高风险的交易可以被直接拒绝，或者在甚至达到可能需要身份验证的阶段之前进行人工审查——因此，欺诈者利用深度伪造技术的机会就会减少。

系统越早检测到网络犯罪分子越好。这样他们实施犯罪的机会就更少，企业在进一步检查上的支出也会减少。基于视频的身份验证检查成本高，即使没有加入检测深度伪造的人工智能技术。

如果能在欺诈者达到那一步之前识别出他们，利用数字足迹等技术，将有更多资源用于优化对更多边缘案件的检查。

人工智能在欺诈检测中的未来

机器学习的本质应该决定随着时间的推移，它在检测异常和打击欺诈方面会变得更好。人工智能驱动的系统可以从新的模式中学习，并有可能在过程的早期阶段筛选出欺诈交易。

就深度伪造而言，上述例子提供了特别的希望。科学家们已经找到了一种使用光反射检测绝大多数深度伪造的方法。这类发展代表了欺诈预防的重大进展，也是对网络犯罪分子的重大障碍。

理论上，部署这种检测技术要比欺诈者找到规避它的方法容易得多——例如，复制光的行为，速度快且规模大。这场“猫捉老鼠”的游戏似乎将永无休止，但大科技公司和大金融公司拥有资源和雄厚的资金——至少在理论上——可以保持领先一步。

Jimmy Fong 是 SEON 的首席商务官，他带来了深厚的反欺诈经验，协助各地的反欺诈团队。

相关话题

• 数据科学如何促进欺诈预防

• 前 7 名扩散基础应用及演示

• LangChain 101：构建你自己的 GPT 驱动应用

• 构建生成式 AI 应用程序的最佳 Python 工具备忘单

• 计算机视觉的 5 个应用

• 现实世界中 NLP 应用的范围：一种不同的…

用 AI 对抗新冠病毒：通过深度学习和计算机视觉改进检测

原文：www.kdnuggets.com/2020/04/fighting-coronavirus-ai-improving-testing-deep-learning-computer-vision.html

评论

由 Ayoosh Kathuria，印度拉杰普拉斯科技学院，德里

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你所在组织的 IT

---

上述引述来自于《搏击俱乐部》这本书，该书也被改编成了一部由布拉德·皮特、爱德华·诺顿和海伦娜·伯翰·卡特主演的电影。我在 1996 年书出版时才一岁。主角泰勒·德顿谈到，当代一代人正面临危机，因为他们没有经历过一种具有划时代意义的事件，将他们的生活分为“之前”和“之后”。在某种程度上，对于像我这样的千禧一代也是如此，直到新冠病毒大流行袭来。

现在我必须澄清。并不是说过去几十年中没有经济崩溃（例如津巴布韦、委内瑞拉）。我也不否认世界的某些地方经历了毁灭性的疫情（SARS、埃博拉等）。但几乎所有这些疫情都局限于某些地区，其他地区可以提供援助。新冠病毒对整个世界造成的破坏——无论是过度负担的医疗系统、数百万人被封锁、儿童缺课，还是经济遭受重大打击——都在很大程度上是前所未有的。

这里有一个由约翰霍普金斯大学提供的实时仪表盘，跟踪全球的病例。在文章发布时，全球病例已经接近 900,000 例。

尽管泰勒·德顿倡导一种业余搏击俱乐部，让人们互殴以应对存在主义的愤怒，但 AI 和数据科学的进步让我们中的许多人处于帮助人类击败新冠病毒的前沿。当然，后者选项更好，因为前者与社交距离的概念不太相符。

这个系列讲了什么？

与我之前做过的系列（包括  GauGAN、 从零实现 YOLO、 边界框的数据增强，等）不同的是，这个系列的发展更加开放。关于 AI 如何用于应对冠状病毒的研究仍在进行中。目前，公共领域中的 COVID-19 医学数据（例如患者的 CT 扫描）少得可怜。当然，医学数据由于隐私问题可能需要时间才能公开。

尽管如此，我们看到一些领域出现了关于如何利用 AI 应对冠状病毒的研究。这些包括：

1. 使用基于计算机视觉的深度学习作为工具，帮助诊断患者的肺部 CT 扫描中的 COVID-19。

2. 尝试使用基于深度学习的蛋白质折叠解决方案来开发治疗方法。

3. 使用自然语言处理从大量关于 COVID-19 的文献中提取有意义的见解。

4. 使用计算机视觉辅助的监控来观察人群，并例如执行社交距离措施。

医学影像一直是计算机视觉研究中的热门话题。

这个系列的想法是探索这些研究领域，并且如果可能的话，提供一些示例，以便在数据可用时你可以开始朝着解决方案努力。

本文中我们将涵盖的内容

在这篇文章中，我将讨论：

1. 测试在应对疫情中的重要性。

2. 当前检测工具面临的挑战。

3. 几篇新论文概述了如何利用深度学习从 CT 扫描中诊断 COVID-19。

4. 如何解读深度学习诊断系统的结果及一些注意事项。

首先，免责声明……

在进一步讨论之前，让我说一下我不是医学或放射学专业人员。我的经验在于机器学习、深度学习和计算机科学。我写的内容来自于我对医学影像的有限研究，如果我写错了什么，而你恰好是专业人士，请在下方评论区告诉我，以便我可以纠正。

测试。测试。测试。

这些是来自世界卫生组织（WHO）的人。在他们的一次新闻发布会上，中间的那位说他对各国的首要建议是“测试，测试，测试”尽可能多地检测人员，并且如果可能的话，检测每一个有症状的人，不论其旅行或接触历史。

说到冠状病毒，检测变得非常重要，因为你可能在 5 到 14 天内不会出现症状（这称为潜伏期）。在这段时间里，如果你没有隔离自己，你会将病毒传播给你接触到的人。

RT-PCR 检测

目前用于检测 COVID-19 患者的金标准是逆转录聚合酶链反应测试，或称 RT-PCR。这涉及从一个人的鼻子或喉咙中取样，然后送到机器中检查是否存在病毒。然而，RT-PCR 方法也有其缺陷。

• 这些棉签样本需要被送到 RT-PCR 机器所在的检测中心。如果时间过长，病毒可能会死亡，感染者的样本可能会变为阴性。

• 它们很昂贵。

• 已观察到 RT-PCR 测试的敏感性较低，即假阴性的可能性较高。这就是为什么政府通常会做多次测试以确认结果。

• 它们也会产生很多假阳性。这是个问题，因为你可能会不必要地给健康系统带来负担，接纳那些实际上并没有病毒的人。

如果你仍然不相信，取样可能需要将棉签插入你的鼻子深处，感觉像是触碰到了大脑。人们就是这样描述的。不是开玩笑的。

如果这还不能激励你想出更好的检测方法，那么没有什么能做到这一点了。

CT 扫描

对武汉医院收集的数据的研究显示，在感染者中，CT 扫描在 COVID-19 诊断中的敏感性远高于 RT-PCR。根据在Radiology上发表的对 1014 名 COVID-19 患者进行的t 这项研究，RT-PCR 只能检测到 601/1014（59%）的阳性，而 CT 扫描则检测到 888/1014（88%）的阳性。

“结果显示，601 名患者（59%）的 RT-PCR 结果为阳性，而 888 名患者（88%）的胸部 CT 扫描结果为阳性。基于 RT-PCR 结果，胸部 CT 在提示 COVID-19 方面的敏感性为 97%。在 RT-PCR 结果为阴性的患者中，75%（413 名患者中的 308 名）胸部 CT 检查结果为阳性。其中，48%被认为是高度可能的病例，33%为可能的病例。通过分析连续的 RT-PCR 测试和 CT 扫描，从初始阴性到阳性 RT-PCR 结果的间隔为 4 到 8 天。”

这项研究报告称，CT 扫描的敏感性约为 97%，而 RT-PCR 的敏感性约为 71%。

根据这些发现，我们有理由相信，使用 CT 扫描进行诊断可能会有益。然而，即使有了 CT 扫描，你仍然需要一位合格的放射科医生来确认 COVID-19 的存在。不幸的是，放射科医生数量有限，特别是当病例激增时，他们可能会非常忙碌。

COVID-19 的特征

这是一名健康患者的 CT 扫描图像。

一些肺结节是正常的

现在我们考虑一个因 COVID-19 引起的肺炎患者的 CT 扫描。

注意左侧箭头标记的“玻璃样”密度。我们可以看到左肺的周边有几个这样的密度。

通常，肺炎会导致肺部液体积聚，表现为肺部的密度。有关应用深度学习诊断 COVID-19 的 CT 扫描文献确实指出了与其他类型肺炎相比，COVID-19 肺部 CT 扫描中发现的一些独特特征，这些特征源于不同的原因。

一篇题为深度学习系统筛查冠状病毒病 2019 肺炎的论文列出了三种这样的特征：

“…玻璃样外观，沿胸膜分布明显，并且通常一个病例中有多个独立的感染灶。”

1. 第一个意思是肺部的密度看起来像玻璃样。

2. 第二个意思是这些密度大多数出现在肺部边缘。

3. 第三个意思是我们可以有多个这样的密度簇。

在上面的肺部 CT 扫描图像中可以观察到这三种特征。

如果你想了解更多关于 COVID-19 患者 CT 扫描特征的信息，这里有一篇精彩的文章。

使用深度学习检测冠状病毒

近年来，计算机视觉在医学成像领域用于诊断各种疾病的应用激增。例如，斯坦福大学的CheXNet用于诊断肺部 X 光片中的肺炎，从视网膜图像预测心血管风险因素，以及皮肤癌分类。

类似地，最近发表了一些研究论文，这些论文基本上采用 CT 扫描并试图预测该人是否感染了 COVID-19。要保持最新信息，你可以随时查阅 Google Scholar。

CT 扫描数据

CT 扫描（或计算机断层扫描）是通过一台扫描器围绕你的身体进行，创建你器官的三维模型。这是一个 CT 扫描仪工作原理的演示。

因此，你的数据在这种情况下将会是...

1. 三维体积，需要使用三维卷积网络。

2. 多个横截面切片，可以使用二维神经网络。

提取感兴趣区域（ROI）

所有这些方法都涉及一定的数据预处理，以从 CT 扫描中提取感兴趣区域作为第一步。一旦这些 ROIs 被提取，它们就会被送到深度神经网络中，以将病例分类为 COVID-19 或其他类别，如细菌性肺炎、病毒性肺炎、无感染等（“其他”类别在不同论文中有所不同）。

这是来自论文深度学习系统筛查新冠肺炎的一个例子，它处理 CT 扫描的 2-D 切片。

第三张图中围绕弥漫性不透明度的小边界框是 RoI 的一个例子。

论文首先使用图像预处理方法对肺部进行分割。然后使用基于 VNET20 的分割模型 VNET-IR-RPN17 提取感兴趣区域。该模型本身是为了从肺结核中提取 ROI 而训练的，但发现它对 COVID-19 的使用案例也效果很好。

然后每个 RoI 被送入分类模型，我们得到类别概率。可能会有一个或多个 RoI，给出多个概率。这些概率然后通过一种称为Noisy-or-Bayesian的函数结合起来。更多细节可以在上面链接的论文中找到。

论文还利用了一个事实，即新冠病毒的透明度通常出现在肺部边缘，这一信息在后期阶段作为输入传递给网络。关于如何准确计算这个距离的细节可以在论文中找到。

分类网络的架构。

网络架构受到 ResNet 的启发，在最终分类层上使用局部注意力。

深度学习系统筛查新冠肺炎

使用 3-D 信息

在另一篇题为新冠病毒（COVID-19）大流行的快速 AI 开发周期：使用深度学习 CT 图像分析进行自动检测和患者监测的初步结果的论文中，作者使用了3-D U-Net 架构来从扫描中提取肺部（与 VNET20 模型的功能相同）。

然后这些肺部裁剪图被神经网络分类。整个肺部被传递到分类网络，与之前的工作不同，之前的工作是在分类前从肺部提取了 ROI。作者接着使用Grad-CAM技术创建肺部的“热图”。

红色区域显示了与 COVID-19 最强相关的肺部区域，而蓝色区域显示了不重要的区域。

为了分类每个患者，使用了 CT 扫描的多个切片。每个切片用于计算类别概率。如果大多数切片的最高类别概率为 COVID-19，则患者被分类为 COVID-19 阳性。（换句话说，每个切片都算作一次投票）。

除了分类二维肺部切片外，作者还使用了一种现成的软件，RADLogics，它检测三维肺部体积中的结节和小阴影。然后，将软件的补丁和早期阶段的热图结合起来，创建三维可视化。

红色的补丁对应于分类系统挑选的点，而绿色的点是软件挑选的点。

补丁的体积随后用于创建一个“Corona Score”。

冠状病毒（COVID-19）大流行的快速 AI 开发周期：使用深度学习 CT 图像分析的自动检测和患者监测的初步结果

CovNet

在最近由北美放射学学会发布的一篇论文中，人工智能在胸部 CT 中区分 COVID-19 和社区获得性肺炎，提出了一种称为 CovNet 的架构，旨在处理同一 CT 扫描的多个二维切片。

特征向量是从每个切片中提取的。然后，这些多个特征向量被最大池化以获得一个单一的特征向量。这个特征向量随后被输入到全连接层，以将病例分类为 COVID-19、社区获得性肺炎或非肺炎。

结果评估

在评估任何冠状病毒诊断方法的结果时，仅仅有准确率是不够的。这是因为我们测试的所有人中，只有少数人会感染病毒。世界上几乎没有国家的阳性率超过 20%（阳性病例占所有测试的比例）。在这种情况下，假设我们开发了一个只将所有结果都标记为阴性的解决方案。从准确率的角度来看，该解决方案的准确率仍然是 80%，尽管它是一个完全无用的分类器。

因此，我们需要关注其他指标，如：

敏感性，或真正阳性率。这是实际阳性样本数与总阳性样本数的比例，简单来说，就是我们正确分类为阳性的冠状病毒感染患者的数量。敏感性过低意味着有许多感染病毒的人被我们的算法分类为阴性。这是一个特别令人担忧的缺陷，因为它可能导致许多感染者回家并传播病毒。

特异性，即真正负例率。这是指真正负例与负样本总数的比例，简而言之，就是我们正确分类为负的非感染者的数量。特异性过低意味着我们会错误地告诉许多没有病毒的人他们实际上有病毒。虽然这不如低敏感性那样令人担忧，但如果系统中的假阳性过多，可能会给健康系统带来不必要的压力。

人们还使用精确度（我们诊断为阳性的所有患者中，实际上有多少人患有该疾病；这对于衡量我们测试的资源性很有用）和F1 得分（结合了精确度和敏感性）等指标。

ROC 曲线下面积 是衡量我们的分类器分离两个类别能力的指标。通常所有情况都由分类器给出一个概率，然后我们使用阈值来确定结果。理想情况下，我们希望所有正例的分数远高于阈值，而负例的分数远低于阈值。为什么？因为如果一个例子接近阈值，很难对预测充满信心。

例如，假设我们使用 0.5 的阈值。假设分类器为一个案例分配了 0.9 的概率。我们可以自信地说这个案例是阳性。然而，考虑另一个案例为 0.52。我们不能以相同的信心说这个例子是阳性。可以想象，如果输入略有变化，我们可能会得到 0.48 的分数，而我们会将这个例子称为阴性。

AUROC 是敏感性与假阳性率（1 - 特异性）之间的图形。它仅能计算二分类问题，因此当我们有n个类别时，我们必须制作n个"单一类别"对"所有其他类别"的 AUC 曲线。

论文中的 1 对全体 AOC 曲线 人工智能区分 COVID-19 与社区获得性肺炎在胸部 CT 上的表现

ROC 曲线下面积的范围从 0 到 1，其中 1 表示完美的分类器，0.5（表示曲线跟随直线 y=x）表示一个与抛硬币（随机机会）一样好的分类器。低于 0.5 的面积意味着你的分类器更差，错误预测的频率更高。

如果你想深入了解为什么 AUROC 有效，这里有一个不错的资源：

理解 AUC - ROC 曲线

但有一个警告...

在结束本文之前，我想指出一些我们在将深度学习工具应用于医学用例时面临的挑战。

关于 COVID-19，在这篇文章中我们主要讨论了如何通过 CT 扫描检测该疾病。但说实话，你不能仅通过 CT 扫描真正检测到肺炎。这是因为肺炎是一种所谓的“临床诊断”。放射科医生不仅仅通过查看 CT 扫描来判断患者是否感染了 COVID-19。他们还可能查看血液检查、临床历史、附加症状等来得出结论。这是因为不同原因引起的肺炎在 CT 扫描中可能会呈现出截然不同的特征。当一篇论文报告 CT 扫描比 RT-PCR 具有更好的敏感性时，这实际上意味着医生结合 CT 扫描与其他症状和特征来诊断患者的一种方法。

虽然这并不影响使用深度学习来诊断 COVID-19 的有效性，但当 CheXNet 发布时，我们必须警惕那些花哨的头条新闻。

放射科医生是否应该担心他们的工作？最新消息：我们现在可以比放射科医生更好地从胸部 X 光片中诊断肺炎。t.co/CjqbzSqwTx

— Andrew Ng (@AndrewYNg) 2017 年 11 月 15 日

不，放射科医生并不会消失。然而，这些深度学习工具将会在面对大量病例时（如在冠状病毒爆发期间）以及时间至关重要时，缓解他们的工作负担。

结论

这部分内容就到这里了。在下一部分，我们将创建一个分类器来识别肺部 X 光片是否为 COVID-19 或其他感染。目前还没有针对 COVID-19 的开放源代码 CT 扫描数据集，因此我们暂时将使用 X 光扫描。（我们在上述讨论的论文中使用的数据尚未公开）。

个人简介：Ayoosh Kathuria 是德里印德拉普拉斯信息技术学院的研究助理。

原文。经授权转载。

相关：

• 数据科学家最好的免费流行病学课程

• 确保你的 AI/机器学习系统在 COVID-19 期间存活的 4 个步骤

• 数据科学如何用于理解 COVID-19

更多相关话题

• 利用 AI 对抗 AI：深度伪造应用的欺诈监测

• 关于数据管理及其重要性的 6 件事…

• 计算机视觉中的 TensorFlow - 轻松实现迁移学习

• KDnuggets 新闻 2022 年 3 月 9 日：在 5 分钟内构建一个机器学习 Web 应用程序…

• 假设检验与 A/B 测试

• 探索计算机视觉的世界：介绍 MLM 最新…

深度学习中的过拟合问题

原文：www.kdnuggets.com/2019/12/fighting-overfitting-deep-learning.html

评论

由 ActiveWizards 提供

问题

在训练模型时，我们希望根据选择的指标获得最佳结果。同时，我们还希望在新数据上保持类似的结果。残酷的现实是，我们无法获得 100%的准确性。即使我们做到了，结果仍然难免有错误。测试情况太少，难以发现它们。你可能会问，这有什么关系？

错误有两种类型：可减少的和不可减少的。不可减少的错误是由于数据不足产生的。例如，除了类型、时长、演员之外，人们的心情和观看电影时的氛围也会影响评分。但我们无法预测未来人的心情。另一个原因是数据质量。

我们的目标是减少可减少的错误，这些错误又分为偏差和方差。

偏差

偏差出现在我们试图用简单模型描述复杂过程时，结果产生了错误。例如，用线性函数描述非线性互动是不可行的。

方差

方差描述了预测的稳健性，即当数据变化时预测会变化多少。理想情况下，数据有小的变化时，预测也会有轻微的变化。

偏差和方差对预测的影响

这些错误是相互关联的，导致一个减少时另一个增加。这个问题被称为偏差-方差权衡。

模型越复杂（灵活），对目标变量的方差解释得越好，偏差就越小。但是，尽管如此，模型越复杂，对训练数据的适应性越强，方差也会增加。在某个时点，模型将开始寻找在新数据上不会重复的随机模式，从而降低模型的泛化能力，并增加测试数据上的错误。

有一张图描述了偏差-方差权衡。红线是损失函数（例如 MSE - 均方误差）。蓝线是偏差，橙线是方差。正如你所见，最佳解决方案会出现在这些线交点的某处。

错误函数的分解

你也可以认识到，当损失开始增加的时刻就是模型过拟合的时刻。

结果是：我们需要控制错误，以防止不仅仅是过拟合，还包括欠拟合。

我们如何解决这个问题？

正则化是一种技术，用于避免学习更复杂或灵活的模型，以降低过拟合的风险。

注：

问题是，在训练数据中表现最佳的模型不能保证在测试数据中也是最佳的。因此，我们可以通过交叉验证选择超参数。

正则化

或者，换句话说：

成本函数 = 损失 + 正则化项

损失函数通常是一个在数据点、预测和标签上定义的函数，并衡量惩罚。成本函数通常更为一般。它可能是训练集上的损失函数的总和加上一些模型复杂性惩罚（正则化项）****。

通常，过拟合的模型具有不同符号的大权重。这样，它们在总和上互相抵消，得到结果。改善评分的方法是减少权重。

每个神经元可以表示为

其中 f 是激活函数，w 是权重，X 是数据。

系数向量的“长度”可以通过向量的范数来描述。为了控制我们将减少系数的长度（惩罚模型的复杂性，从而防止其过拟合或过度调整数据），我们将通过将其乘以 λ 来加权范数。选择 λ 没有分析方法，因此可以通过网格搜索来选择。

L2 范数（L2 正则化，岭回归）

如果损失是 MSE，那么具有 L2 范数的成本函数可以通过解析方法求解。

你可以看到，我们只是添加了一个乘以 λ 的单位矩阵（岭），以获得一个非奇异矩阵，并增加问题的收敛性。

通过添加单位矩阵，将多重共线性的 XTX 矩阵转换为非奇异矩阵。

换句话说，我们需要最小化成本函数，因此我们最小化损失和向量的速率（在这种情况下，这是权重平方的总和）。因此，权重会更接近零。

让我们计算：

w^T 是权重的向量行。

正则化之前：

数据的微小变化

正则化后，我们将在测试数据上得到相同的结果，

但，数据的微小变化会导致结果的微小变化。

示例

from keras import regularizers
...
lambda = 0.01
model.add(Dense(64, input_dim=64,
                kernel_regularizer=regularizers.l2(lambda)))

L1 范数（L1 正则化，Lasso）

L1 范数意味着我们使用权重的绝对值而不是平方值。没有解析方法来解决这个问题。

这种回归将一些权重置为零。在我们尝试压缩模型时，它非常有用。

示例

from keras import regularizers
...
lambda = 0.01 
model.add(Dense(64, input_dim=64,
                kernel_regularizer=regularizers.l1(lambda)))

我们来看一个有两个参数（B1 和 B2）的简单损失函数，并绘制一个三维图。

在三维空间中的梯度下降与等高线表示 | 来源

正如你所看到的，损失函数可能在不同参数下具有相同的值。我们将其投影到参数表面上，其中同一曲线上的每一点具有相同的函数值。这条线称为等高线。

设 Lambda = 1。L2 正则化对于两个参数的函数是 B12 + B22，这在图上形成一个圆。L1 正则化是 |B1| + |B2|，这在图上形成一个菱形。

L1 和 L2 范数与不同的成本函数 | 来源

现在，让我们绘制不同的损失函数以及蓝色菱形（L1）和黑色圆圈（L2）正则化项（Lambda = 1）。实际情况是，成本函数在红色圆圈与黑色正则化曲线（L2）的交点处达到最小值，而在蓝色菱形与等高线交点处达到最小值（L1）。

Dropout（随机失活）

想象一个简单的网络。例如，黑客马拉松中的开发团队。团队中有经验丰富或更聪明的开发者，他们承担了整个开发的主要工作，而其他人只做一些小帮助。如果这种情况持续下去，经验丰富的开发者会变得更有经验，而其他人则很难得到训练。神经元也是如此。

全连接网络

但想象一下，在每次产品开发迭代中，我们随机断开一些开发者的连接。那么其余的开发者不得不更加投入，大家学习得更好。

随机丢失节点的网络

可能会发生什么问题？如果你关闭了太多的神经元，那么剩下的神经元可能无法应对它们的工作，结果只会变得更糟。

这也可以被看作是机器学习中的一种集成技术。记住，强学习者的集成比单一模型表现更好，因为它们能捕捉更多的随机性，且不容易过拟合。但是，弱学习者的集成比原始模型更容易过拟合。

因此，dropout 只在大型神经网络中使用。

示例

from keras.layers.core import Dropout
…
percent_of_dropped_neurons = 0.25
model = Sequential([
   Dense(32, activation='relu', input_shape=(10,)),
   Dropout(percent_of_dropped_neurons)
   Dense(32, activation='relu',),
   Dense(1, activation='linear')
])

数据增强

减少过拟合的最简单方法是增加训练数据的规模。在机器学习中，由于成本高昂，增加数据量是困难的。

那么，图像处理呢？在这种情况下，有几种方法可以增加训练数据的规模——旋转图像、翻转、缩放、平移等。我们还可以添加没有目标类的图像，以教会网络如何区分目标与噪声。

示例

from keras.preprocessing.image import ImageDataGenerator
datagen = ImageDataGenerator(
       rotation_range=40,
       width_shift_range=0.2,
       height_shift_range=0.2,
       shear_range=0.2,
       zoom_range=0.2,
       horizontal_flip=True,
       fill_mode='nearest')
img = load_img('983794168.jpg')    # load image from file system
x = img_to_array(img)              # turn image to array and reshape
x = x.reshape((1,) + x.shape)
i = 0
# the .flow() command below generates batches of randomly transformed images
# and saves the results to the `test_data_augmentation` directory
for batch in datagen.flow(x, batch_size=1,
                         save_to_dir='test_data_augmentation', save_prefix='data', save_format='jpeg'):
   i += 1
   if i > 20:
       break   # generate 20 images and stop after

原始图像：

增强图像：

提前停止

提前停止是一种交叉验证策略，其中我们将训练集的一部分作为验证集。当我们看到验证集上的性能变差时，我们会立即停止模型的训练。

示例

from keras.callbacks import EarlyStopping

es = EarlyStopping(monitor='val_loss', mode='min')

这就是我们所需的最简单形式的提前停止。当选定的性能测量指标不再改善时，训练将停止。要发现训练在哪个时期停止，可以将“verbose”参数设置为 1。

通常，第一次没有进一步改善的迹象可能不是停止训练的最佳时机。这是因为模型可能会在改善之前进入一个没有改进的平稳期，甚至可能稍微变得更差。

我们可以通过在触发器中添加一个延迟来考虑这一点，以便我们希望看到没有改进的纪元数。这可以通过设置“patience”参数来完成。

es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=50)

精确的耐心值将在模型和问题之间有所不同。

默认情况下，性能测量指标的任何变化，无论多么微小，都将被视为改善。你可能需要考虑一个特定的增量，例如均方误差的 1 单位或准确率的 1%。这可以通过“min_delta”参数指定。

es = EarlyStopping(monitor='val_accuracy', mode='max', min_delta=1)

EarlyStopping 回调可以与其他回调一起应用，例如 tensorboard。

model.fit(
X_train,
y_train, 
epochs=2000, 
batch_size=32, 
validation_data=(X_val, y_val), 
callbacks=[get_tensorboard_callback('baseline_pca(45)_log', True), es])

了解更多信息：这里

也可以附加 Tensorboard 并手动监控变化。每 5 分钟，模型将保存到日志目录中，因此你可以随时检查更好的版本。

神经网络架构

众所周知，深度为 2 的足够大的网络已经可以在[0,1]d 上以任意精度逼近任何连续目标函数（Cybenko,1989；Hornik, 1991）。另一方面，较深的网络通常比浅层网络表现更好，这一点早已显而易见。

最近的分析表明，“深度——即使增加 1——对于标准前馈神经网络的价值可能是宽度的指数倍”。

你可以认为每一层新层提取了一个新的特征，从而增加了非线性。

记住，增加深度意味着你的模型更复杂，优化函数可能无法找到最佳的权重集。

想象一下，你有一个具有 2 层隐藏层的神经网络，每层 5 个神经元。高度 = 2，宽度 = 5。让我们在每层添加一个神经元并计算连接数：（5+1）（5+1）= 36 个连接。现在，让我们在原始网络中添加一层并计算连接数：55*5 = 125 个连接。因此，每层将显著增加连接数和执行时间。

但与此同时，这也会增加过拟合的机会。

非常宽的神经网络擅长记忆数据，因此你不应该构建非常宽的网络。尽量构建尽可能小的网络来解决问题。记住，网络越大越复杂，过拟合的机会就越高。

你可以在这里找到更多信息。

迁移学习

为什么我们总是从头开始？我们可以利用预训练模型的权重并仅对其进行优化。问题是我们没有一个在我们数据上预训练的模型。但我们可以使用在大量数据上预训练的网络。然后，我们用相对较小的数据来微调预训练的模型。常见做法是冻结除最后几层以外的所有层。

迁移学习的主要优点是它缓解了训练数据不足的问题。正如你所记得的，这是导致过拟合的原因之一。

迁移学习只有在深度学习中如果模型在第一个任务中学到的特征是通用的才有效。使用预训练模型进行图像处理（这里）和文本处理非常流行，例如google word2vec。

另一个好处是迁移学习可以提高生产力并减少训练时间：

衡量函数

批量归一化

批量归一化不仅可以作为正则化器，还可以通过增加学习率来减少训练时间。问题是，在训练过程中，每一层的分布都会发生变化。因此，我们需要减少学习率，这会减慢梯度下降优化的速度。但是，如果我们对每个训练小批量应用归一化，我们可以增加学习率并更快地找到最小值。

示例

from keras.layers.normalization import BatchNormalization
...
model = Sequential([
   Dense(32, activation='relu', input_shape=(10,)),
   BatchNormalization(),
   Dense(32, activation='relu'),
   Dense(1, activation='linear')
])

其他

还有一些其他不太流行的深度神经网络防止过拟合的方法。它们并不一定有效。如果你已经尝试过所有其他方法并且想尝试其他东西，你可以在这里阅读更多内容：小批量大小，权重噪声。

结论

过拟合出现在我们拥有过于复杂的模型时。我们的模型开始识别噪声或随机关系，这些关系在新数据中不会再出现。

这种情况的一个特点是神经元中存在不同符号的大权重。一个直接解决方案是 L1 和 L2 正则化，可以分别应用于每一层。

另一种方法是对大型神经网络应用 dropout，或者通过数据增强等方法增加数据量。你也可以配置早停回调，以检测模型何时开始过拟合。

此外，尽量构建尽可能小的神经网络。谨慎选择深度和宽度。

不要忘记，你总是可以使用预训练模型来提高模型生产力。至少，你可以应用批量归一化来提高学习速率并同时减少过拟合。

这些方法的不同组合将给你一个结果，并帮助你解决任务。

ActiveWizards 是一个专注于数据项目（大数据、数据科学、机器学习、数据可视化）的数据科学家和工程师团队。核心专长领域包括数据科学（研究、机器学习算法、可视化和工程）、数据可视化（d3.js、Tableau 等）、大数据工程（Hadoop、Spark、Kafka、Cassandra、HBase、MongoDB 等）和数据密集型 Web 应用开发（RESTful API、Flask、Django、Meteor）。

原文。经授权转载。

相关：

• 开启深度学习革命

• 使用更少数据进行图像分类的深度学习

• 2019 年热门深度学习课程

---

我们的前 3 个课程推荐

1. Google 网络安全证书 - 快速开启网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持您的组织的 IT

---

更多相关话题

• 用 AI 对抗 AI：深伪应用的欺诈监测

• 如何避免过拟合

• KDnuggets 新闻，8 月 24 日：在 Python 中实现 DBSCAN • 如何…

• 学习数据科学、机器学习和深度学习的可靠计划

• 人工智能、分析、机器学习、数据科学、深度学习……

• 15 本免费机器学习和深度学习书籍

如何用 Python 过滤数据

原文：www.kdnuggets.com/2022/02/filter-data-python.html

图片由 Sid Balachandran 提供，来自 Unsplash

介绍

尽管数据科学家可以利用 SQL，但坦率地说，用 Python 操作来处理 pandas 数据框可能会更简单（或者，作为补充）。我个人喜欢将这两种语言结合使用来构建我的数据。在某些情况下，当你已经有了从 SQL 查询得到的数据框后，使用操作会更高效。例如，你可能会查询所有必要的列，然后读取你的数据框，再应用相应的操作来整理数据，然后再将其导入到数据科学模型中。话虽如此，我们来深入了解一些简单的操作，可能会让你的日常工作变得更轻松。

小于/大于

对于所有这些用例，我将有一个假设的 pandas 数据框。

以下操作是“小于”，你可以写下你的数据框别名，在这个例子中就是 df。你可以插入我放置的‘column_1’处的列名。我分配了一个新的数据框，命名为 df_less_than_20，这样我只有列值小于 20 的记录/行。

df_less_than_20 = df[df['column_1'] < 20]

同样的概念可以应用于“大于”：

df_more_than_20 = df[df['column_1'] > 20]

尽管这些操作很简单，但它们仍然有用，当结合使用时，效果会更好——正如我们下面将看到的那样。

另一种看待这个特性的方式是像 SQL 中的 WHERE 子句一样。

与/或

现在我们有了上述语句，我们可以对数据应用进一步的过滤。

我们可以使用两者之一，或 & 或 | 操作。

为了澄清：

• AND = &

• OR = |

我知道 AND 操作，但 OR 实际上是我最近发现的一个操作，它非常有用，特别是在你的模型运行后，用于准确性和错误分析的筛选数据。当然，你也可以在过程的前一步使用这个操作。

现在，我们可以以以下方式使用这两者中的任意一个或两个：

df[(df['column_1'] >= -100) & (df['column_1'] <= 1000)]

上述内容表示，给我值在负 100 到正 100 之间的数据。

下一步是使用 OR 操作，找到所有负值的行：

df[(df['column_1'] < 0) | (df['column_1'] >= -100) & (df['column_1'] <= 100)]

我们也可以去掉中间子句，创建以下代码片段：

df[(df['column_1'] < 0) | (df['column_1'] <= 100)]

然而，我们可以用过滤另一列其他值的内容替换其中一个子句。

df[(df['column_1'] < 0) | (df['column_2'] <= 50)]

等于/不等于

最后，我们还有另一种方法来通过选择具有特定值或没有特定值的行来过滤数据。

这两种操作如下：

• DOES EQUAL: ==

• DOES NOT EQUAL: !=

这里有一些例子：

df[df['column_1'] == 100]
df[df['column_2'] == 50]
df[df['column_3'] == 'blue']
df[df['column_3'] != 'blue']
df[(df['column_3'] != 'red' ) | (df['column_200'] <= 8.60)]

总结

总结一下，我们看到我们可以将上述讨论的几个操作结合起来，以创建一个过滤的数据集或 pandas 数据框。最终，这种编码方式可能对一些数据科学家来说更容易，他们更喜欢在 Python 中工作而不是 SQL。

这些操作本身的总结如下：

• 较小/较大： < >

• 和/或： & |

• 等于/不等于： == !=

感谢阅读！希望你喜欢这篇文章并觉得有用。

参考资料

[1] 图片由 Sid Balachandran 提供，来源于 Unsplash，(2019)

Matthew Przybyla (Medium) 是位于德克萨斯州 Favor Delivery 的高级数据科学家。他拥有南方卫理公会大学的数据科学硕士学位。他喜欢撰写有关数据科学领域的趋势话题和教程，从新算法到关于数据科学家日常工作经验的建议。Matt 喜欢突出数据科学的商业方面，而不仅仅是技术方面。欢迎通过 LinkedIn 联系 Matt。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全领域的职业。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT 需求

---

更多相关主题

• 4 个你可能不知道的 Python Itertools 过滤函数

• 通过《数据科学快速 Python》提升你的 Python 技能！

• 优化 Python 代码性能：深入了解 Python 分析器

• Python Enum：如何在 Python 中构建枚举

• 掌握 SQL、Python、数据清理、数据… 的指南合集

• 2020 年数据科学、数据可视化与机器学习的 38 个顶级 Python 库

财务数据分析 – 数据处理 1：贷款资格预测

原文：www.kdnuggets.com/2018/09/financial-data-analysis-loan-eligibility-prediction.html

评论

作者 Sabber Ahamed，计算地球物理学家和机器学习爱好者

介绍

金融机构/公司已经使用预测分析有一段时间了。最近，由于计算资源的可用性以及在机器学习领域的巨大研究，使得更好的数据分析以及更好的预测成为可能。在这系列文章中，我将解释如何创建一个预测贷款模型，识别那些更有可能被拒绝的申请人。通过一步步的过程，我展示了如何处理原始数据、清理不必要的部分、选择相关特征、进行探索性数据分析，并最终建立模型。

作为一个例子，我使用了 Lending Club 贷款数据集。Lending Club 是全球最大的在线市场，连接借款人和投资者。借贷的一个不可避免的结果是借款人违约。这个教程的目的是创建一个预测模型，以识别那些相对来说风险较大的贷款申请人。为此，我将整个系列分为以下四部分：

• 数据处理-1：在这第一部分，我展示了如何清理和移除不必要的特征。数据处理是非常耗时的，但更好的数据将产生更好的模型。因此，需要进行仔细且非常详细的检查，以准备更好的数据。我展示了如何识别常量特征、重复特征、重复行以及具有大量缺失值的特征。

• 数据处理-2：在这一部分，我手动检查了从第一部分中选择的每一个特征。这是最耗时的部分，但为了得到更好的模型是值得的。

• 探索性数据分析：在这一部分，我对第一部分和第二部分中选择的特征进行了探索性数据分析（EDA）。良好的 EDA 对于更好地了解领域是必需的。我们需要花费一些时间来找出特征之间的关系。

• 创建模型：最后，在这最后但并非最末部分中，我创建了模型。创建模型也不是一件容易的事。这也是一个迭代的过程。我展示了如何从一个简单的模型开始，然后逐步增加复杂性以获得更好的性能。

好的，让我们开始第一部分：数据处理、清洗和特征选择。

数据处理-1

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings("ignore")

在这个项目中，我使用了三年的数据集（2014 年、2015 年和 2017 年（第一至第三季度）），并存储在五个不同的 CSV 文件中。首先让我们读取这些文件：

df1 = pd.read_csv(‘./data/2017Q1.csv’, skiprows=[0])
df2 = pd.read_csv(‘./data/2017Q2.csv’, skiprows=[0])
df3 = pd.read_csv(‘./data/2017Q3.csv’, skiprows=[0])
df4 = pd.read_csv(‘./data/2014.csv’, skiprows=[0])
df5 = pd.read_csv(‘./data/2015.csv’, skiprows=[0])

由于数据存储在不同的文件中，我们必须确保每个文件中的特征数量相同。我们可以使用以下代码片段来检查：

columns = np.dstack((list(df1.columns), list(df2.columns), list(df3.columns), list(df4.columns), list(df5.columns)))
coldf = pd.DataFrame(columns[0])

上述代码不言而喻，我们首先提取列名，然后使用 Numpy 的 dstack 对象将它们堆叠在一起。如果你查看 Github 上的 Jupyter-notebook，你会看到它们是相同的。这对我们来说是好的。我们可以继续下一步。现在是检查数据形状的时候了：

df = pd.concat([df1, df2, df3, df4, df5])
df.shape

(981665, 151)

我们看到大约有一百万个样本，每个样本包含 151 个特征，包括目标变量。让我们查看特征名称以熟悉数据。了解领域，尤其是特征与目标变量的关系的细节是至关重要的。要彻底了解并不容易，所以需要花费几天或一周的时间来熟悉数据，然后再深入分析。让我们查看特征名称：

print(list(df.columns))

['id', 'member_id', 'loan_amnt', 'funded_amnt', 'funded_amnt_inv', 'term', 'int_rate', 'installment', 'grade', 'sub_grade', 'emp_title', 'emp_length', 'home_ownership', 'annual_inc', 'verification_status', 'issue_d', 'loan_status', 'pymnt_plan', 'url', 'desc', 'purpose', 'title', 'zip_code', 'addr_state', 'dti', 'delinq_2yrs', 'earliest_cr_line', 'fico_range_low', 'fico_range_high', 'inq_last_6mths', 'mths_since_last_delinq', 'mths_since_last_record', 'open_acc', 'pub_rec', 'revol_bal', 'revol_util', 'total_acc', 'initial_list_status', 'out_prncp', 'out_prncp_inv', 'total_pymnt', 'total_pymnt_inv', 'total_rec_prncp', 'total_rec_int', 'total_rec_late_fee', 'recoveries', 'collection_recovery_fee', 'last_pymnt_d', 'last_pymnt_amnt', 'next_pymnt_d', 'last_credit_pull_d', 'last_fico_range_high', 'last_fico_range_low', 'collections_12_mths_ex_med', 'mths_since_last_major_derog', 'policy_code', 'application_type', 'annual_inc_joint', 'dti_joint', 'verification_status_joint', 'acc_now_delinq', 'tot_coll_amt', 'tot_cur_bal', 'open_acc_6m', 'open_act_il', 'open_il_12m', 'open_il_24m', 'mths_since_rcnt_il', 'total_bal_il', 'il_util', 'open_rv_12m', 'open_rv_24m', 'max_bal_bc', 'all_util', 'total_rev_hi_lim', 'inq_fi', 'total_cu_tl', 'inq_last_12m', 'acc_open_past_24mths', 'avg_cur_bal', 'bc_open_to_buy', 'bc_util', 'chargeoff_within_12_mths', 'delinq_amnt', 'mo_sin_old_il_acct', 'mo_sin_old_rev_tl_op', 'mo_sin_rcnt_rev_tl_op', 'mo_sin_rcnt_tl', 'mort_acc', 'mths_since_recent_bc', 'mths_since_recent_bc_dlq', 'mths_since_recent_inq', 'mths_since_recent_revol_delinq', 'num_accts_ever_120_pd', 'num_actv_bc_tl', 'num_actv_rev_tl', 'num_bc_sats', 'num_bc_tl', 'num_il_tl', 'num_op_rev_tl', 'num_rev_accts', 'num_rev_tl_bal_gt_0', 'num_sats', 'num_tl_120dpd_2m', 'num_tl_30dpd', 'num_tl_90g_dpd_24m', 'num_tl_op_past_12m', 'pct_tl_nvr_dlq', 'percent_bc_gt_75', 'pub_rec_bankruptcies', 'tax_liens', 'tot_hi_cred_lim', 'total_bal_ex_mort', 'total_bc_limit', 'total_il_high_credit_limit', 'revol_bal_joint', 'sec_app_fico_range_low', 'sec_app_fico_range_high', 'sec_app_earliest_cr_line', 'sec_app_inq_last_6mths', 'sec_app_mort_acc', 'sec_app_open_acc', 'sec_app_revol_util', 'sec_app_open_act_il', 'sec_app_num_rev_accts', 'sec_app_chargeoff_within_12_mths', 'sec_app_collections_12_mths_ex_med', 'sec_app_mths_since_last_major_derog', 'hardship_flag', 'hardship_type', 'hardship_reason', 'hardship_status', 'deferral_term', 'hardship_amount', 'hardship_start_date', 'hardship_end_date', 'payment_plan_start_date', 'hardship_length', 'hardship_dpd', 'hardship_loan_status', 'orig_projected_additional_accrued_interest', 'hardship_payoff_balance_amount', 'hardship_last_payment_amount', 'disbursement_method', 'debt_settlement_flag', 'debt_settlement_flag_date', 'settlement_status', 'settlement_date', 'settlement_amount', 'settlement_percentage', 'settlement_term']

看着这些特征，可能一开始会感到害怕。但我们会逐一处理每个特征，然后选择相关特征。让我们从目标特征“loan_status”开始。

df.loan_status.value_counts()

Current               500937
Fully Paid            358629
Charged Off            99099
Late (31-120 days)     13203
In Grace Period         6337
Late (16-30 days)       3414
Default                   36
Name: loan_status, dtype: int64

我们看到有七种贷款状态。然而，在本教程中，我们对两个类别感兴趣：1）全额偿还：那些已经还清贷款并支付利息的人，2）呆账：那些无法偿还贷款并最终被呆账处理的人。因此，我们选择这两个类别的数据集：

df = df.loc[(df['loan_status'].isin(['Fully Paid', 'Charged Off']))]

df.shape
(457728, 151)

看着形状，我们看到现在的数据点比原始数据少了一半，但特征数量相同。在进行手动处理和清理之前，让我们先做一些一般的数据处理步骤：

• 移除与 >85% 缺失值相关的特征

• 移除常量特征

• 移除重复的特征

• 移除重复的行

• 移除高度共线的特征（在第三部分 EDA 中）

好的，让我们开始典型的数据处理：

1. 移除与 90% 缺失值相关的特征： 在下面的代码中，我首先使用 pandas 的内置方法 isnull() 查找与缺失值相关的行。然后，我对它们进行求和以获取每个特征的计数。最后，我按缺失值的数量对特征进行排序，并创建一个数据框以便进一步分析。

在上述结果中，我们看到有 53 个特征缺失了 400000 个值。我使用 pandas 的 drop 方法移除这 53 个特征。注意在此函数中我将“inplace”选项设置为“True”，这会在不返回任何内容的情况下从原始数据框df中删除这些特征。

2. 移除常量特征：在这一步，我们移除具有单一唯一值的特征。一个与单一唯一值相关的特征无法帮助模型进行良好的泛化，因为它的方差为零。基于树的模型无法利用这些特征，因为模型无法对这些特征进行拆分。识别具有单一唯一值的特征相对简单：

在上面的代码中，我创建了一个“find_constant_features”函数来识别常量特征。该函数逐个检查每个特征，看看是否具有少于两个唯一值。如果是，这些特征会被添加到常量特征列表中。我们还可以通过查看方差或标准差来找出常量特征。如果特征的方差或标准差为零，我们可以确定该特征具有单一唯一值。打印语句显示五个特征具有单一唯一值，因此我们使用“inplace”选项为 true 移除了它们。

3. 移除重复特征：重复特征是指在多个特征中具有相同值的特征，不论名称是否相同。为了找出这些重复特征，我借用了以下代码，这些代码来自于这个stackoverflow 链接：

我们只看到一个似乎重复的特征。我不会立即移除该特征，而是等到我们在下一部分进行 EDA 时再处理。

4. 移除重复行：在这一步，我们移除所有重复的行。我使用 pandas 内置的“drop_duplicates(inplace= True)”方法来执行此操作：

df.drop_duplicates(inplace= True)

上述四个处理步骤是任何数据科学项目中需要做的基本步骤。让我们看看经过这些步骤后的数据形状：

df.shape

(457728, 93)

我们发现经过上述步骤后，我们有 93 个特征。

在这个教程的next part中，我将逐一检查每个特征，然后进行清理，必要时将其移除。同时，如果你对这一部分有任何问题，请随时在下方写下你的评论。你可以联系我：

Email: sabbers@gmail.com
LinkedIn: https://www.linkedin.com/in/sabber-ahamed/
Github: https://github.com/msahamed
Medium: https://medium.com/@sabber/

个人简介: Sabber Ahamed 是 xoolooloo.com 的创始人，计算地球物理学家及机器学习爱好者。

原文。经许可转载。

相关：

• 命令行上的文本挖掘

• 三种技术提升不平衡数据集上的机器学习模型性能

• 文本分类与嵌入可视化，使用 LSTM、CNN 和预训练词向量

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持组织的 IT 需求

---

更多相关主题

• 机器学习模型可解释性如何加速金融服务领域的人工智能采纳

• 烂番茄电影评分预测的数据科学项目：…

• 烂番茄电影评分预测的数据科学项目：…

• 使用 BQML 进行多变量时间序列预测

• OLAP 与 OLTP：数据处理系统的比较分析

• 自然语言处理任务的数据表示

如何找到最佳的数据科学远程工作

原文：www.kdnuggets.com/2022/12/find-best-data-science-remote-jobs.html

图片来源 | Canva Pro

为什么你应该申请远程数据科学工作？

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 需求

---

远程工作提供了良好的工作与生活平衡和学习多种技能的机会。你可以享受你一直梦想的自由。此外，远程数据科学工作提供了丰厚的薪水和有竞争力的福利。对技术工作者的需求很高，因此你不需要费力就能找到最佳的工作。根据美国劳工统计局的数据，计算机和信息研究科学家的职位数量将增加 20%。

这些工作的教育要求并不高，但拥有数据科学、计算机科学、统计学或相关领域的学士学位是理想的。获得硕士或博士学位会增加被聘用的机会。没有正式学位的候选人也可以申请，只要他们能展示出能够从事专业数据科学项目的技能。

我拥有电信工程学士学位和技术管理硕士学位，这与数据科学大相径庭，那我怎么获得我的第一个远程工作呢？我学习了必要的技能，参加了多个课程，并获得了专业认证。在数据科学领域，你的技能和经验比教育背景更为重要。

图片来源：master1305

什么是数据科学远程工作？

你可以申请数据分析师、数据科学家、数据工程师、机器学习工程师、MLOps 工程师、数据库管理员、商业智能（BI）开发人员和数据架构师。这些远程数据职位要求你具备：

• 最佳的互联网连接

• 能够使用多种沟通和生产力工具

• 能够独立工作并按时完成任务

• 理解技术术语和商业用例

• 根据优先级从一个任务切换到另一个任务的能力

• 能够使用现代数据堆栈理解和解决数据科学问题

列表很长，但我们涵盖了最重要的技能。

起初，我只知道一两件事，主要与技术知识相关，随着时间的推移，我习惯了现代工具，如Slack、Monday、Zoom、Google Calendar和Docs，以及VS Code扩展。除了生产力工具，你还将学习管理云应用程序、使用 SQL 检索数据、创建数据分析报告，并了解从数据摄取到生产的整个数据生态系统。

在日常工作中，你会被分配一个或多个任务，到一天结束时，你需要提供成功和失败的总结。大多数时候，你都是独自工作，并且在一天或一周后通过 Zoom 与团队见面。你的经理不会对你进行微观管理，你将拥有自由，同时也会节省旅行的时间和费用。

图片来源：rawpixel.com

5 种需求量大的数据科学远程工作

在本节中，我们将涵盖五个需求量大的数据科学领域，并简要描述其工作角色。平均工资和顶级公司信息提取自 Indeed 于 2022 年 5 月 25 日。

数据科学家

• 平均远程工资： $102,365 /年

• 提供远程工作的顶级公司： Selby Jennings、Airbnb、eBay 和 Apple

远程数据科学家使用统计学和技术工具解决业务问题。数据科学家必须具有使用 SQL 访问数据、使用 Python 或 R 进行数据分析和构建预测模型的经验。这个职位灵活，通常取决于公司的要求。有时你可能需要进行数据工程、机器学习和网页开发任务。

业务分析师

• 平均远程工资： $90,510 /年

• 提供远程工作的顶级公司： Uline、Twitter 和 Wells Fargo

业务分析师与利益相关者密切合作，寻找业务问题的解决方案。他们使用商业智能工具（Power BI、Tableau）进行研究和分析。在少数情况下，公司希望你拥有网页抓取、数据清理、SQL、仪表盘、网页应用程序的经验，并理解业务术语（KPIs、ROI）。

数据分析师

• 平均远程工资： $65,319 /年

• 提供远程工作的顶级公司： Citizens、Meta 和 USAA

数据分析需求量大，你需要对统计学和分析工具有基本了解。你的工作包括对各种数据源进行分析、创建报告、传达关键信息以及创建预测模型。

机器学习工程师

• 平均远程工资： $111,385 /年

• 提供远程工作的顶级公司： eBay、Snap 和 Capital One

这是科技行业中最具吸引力的工作之一，一些公司提供超过$300K 的薪资和福利。你将测试、训练、构建和部署机器学习模型。你还需要创建机器学习管道并自动化部署系统。你的工作将对公司的增长产生直接影响。

数据工程师

• 平均远程工资：$115,602 /年

• 提供远程工作的顶级公司：Netflix、Meta 和 LinkedIn

数据工程师通过构建和维护数据管道每年可以赚取高达$300K 的薪资。你将创建和管理数据库，创建 ETL/ELT 管道，进行分布式计算，自动化管道，并监控数据完整性。整个数据团队依赖于你提供准确且干净的数据集。

图片由rawpixel.com提供

在哪里可以找到远程数据科学工作？

你可以在工作板、公司网站、社交媒体和数据科学社区找到全职远程工作。远程工作还允许你获得兼职或自由职业工作，这些工作的报酬相同。在这一部分，我们将了解寻找全职和自由职业工作的平台。

全职工作

你可以在工作板上创建个人资料并搜索全职工作，如Glassdoor、ZipRecruiter、CodeRemote、LinkedIn和Indeed。你还可以加入 Facebook、LinkedIn、Discord 和 Slack 上的数据科学社区，以提高更快找到工作的机会。

有一些隐藏的宝石，如DataCamp Jobs，可以帮助数据专业人士找到最佳工作。它不会向你展示随机工作，而是挑选几个量身定制的工作。你只需创建一个账户并填写你的偏好，不久后，你将开始收到来自 Discord、Greenbox Capital、通用汽车等顶级公司的工作邀请。

自由职业工作

你可以在Upwork、AngelList、Kolabtree和Fiverr上找到自由职业工作。此外，你还可以通过将职位类型更改为兼职、合同或临时，在工作板上找到合同自由职业工作。

类似地，我们有一个名为Toptal的自由职业隐藏宝石。该平台只招聘顶尖的 3%自由职业人才，标准更高。它还要求你在数据科学领域有 2 年以上的经验。对于经验丰富的数据专业人士来说，这个平台是提供高薪、有福利和灵活工作合同的避风港。

图片来源：stefamerpik

最后的想法

在申请远程工作或自由职业之前，请确保你具备所需的技能和经验。

要学习更多技能，你可以参加在线课程和教程，阅读书籍，启动个人项目，进行研究。

要获得更多经验，你可以参加 Kaggle 竞赛，参与开源项目，为非政府组织工作，申请实习和学徒工作，以及临时职位。

如果你对数据科学职业有疑问，请在评论中问我。

祝你找到下一个远程工作的好运。

Abid Ali Awan（@1abidaliawan）是一位认证的数据科学专业人士，热衷于构建机器学习模型。目前，他专注于内容创作，并撰写有关机器学习和数据科学技术的技术博客。Abid 拥有技术管理硕士学位和电信工程学士学位。他的愿景是利用图神经网络构建一个人工智能产品，帮助那些面临心理健康问题的学生。

原文。经许可转载。

更多相关内容

• 停止学习数据科学以寻找目标，并寻找目标去……

• 数据科学中的远程工作：优缺点

• 如何找到适合注释的合适人选

• 在不标记的情况下在图像中找到一张图片

• 如何建立一个模型来找到用户旅程中最有影响力的路径

• 如何在 Python 中找到集合差异

找到你的完美职业匹配：数据世界中职位的快速指南

原文：www.kdnuggets.com/2020/04/find-perfect-fit-data-job-roles-guide.html

评论

由 Alon Mei-raz 提供，数据与洞察副总裁，Hapoalim 银行

箭头矢量图由 macrovector 创建 - www.freepik.com

---

我们的前三名课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

几周前，我带着我的狗散步时偶遇了我的邻居。她有统计学背景，问我关于数据世界中不同职位的情况，试图找出她下一步的职业发展方向。在我概述了每个职位的各种职责后，我看到她相当困惑。她说：“我完全没想到这个领域如此细分。”而她并不是唯一一个这样的人。

在过去的几年里，数据相关职位被认为是就业市场上最热门的职位。需求持续迅速增长，并且预计不会很快改变。虽然每个人都想加入这个充满魅力的领域，但首先了解各种角色和职责是至关重要的。在这份快速指南中，我会尽力通过明确不同职位的精髓来消除困惑。

那么，让我们开始吧。

数据分析师

数据分析师的主要责任是识别重要的业务问题，然后处理和利用数据，以帮助组织做出更为明智的数据驱动决策。

这个角色需要广泛的技能，从收集大量数据并组织它以获得见解。数据分析师必须具备分析和技术能力，并且应该熟悉 ETL 工具、数据可视化以及诸如 R、Python、SQL、SAS 等语言/技术。

业务分析师

虽然这个角色不像列表中的其他角色那样技术性强，但业务分析师在数据世界中扮演着重要角色，作为技术人员与业务/管理方面之间的桥梁。他们必须对其特定行业（例如：医疗保健、保险、金融）及业务流程有深入了解。

由于业务分析师是业务方面和管理层之间的中介，他们需要能够生成报告，具备良好的数据可视化技能，并显然是顶尖的沟通者。

数据工程师

数据工程师是团队中的“建设者”。有人称他们为数据领域的 DevOps。我见过不同的公司对这个角色的定义各不相同，但在我看来，数据工程师奠定了其他角色，如数据科学家和数据分析师，能够成功完成工作的基础。为了实现这一点，数据工程师被赋予了构建和维护组织大数据生态系统的重要责任，同时确保它的稳健和顺利运行。

数据工程师需要对数据系统非常熟悉，例如：Hadoop、Hive、MongoDB、MySQL 等。他们还应具备数据流工具、ETL 工具和数据建模的实际经验。

数据科学家

嗯，我本来想把这个放到最后，因为显然这是最受欢迎的职位——不仅在数据领域，而且在技术社区中也如此。不过，我确实相信这个列表上的所有角色之间的协作显著地促进了组织的成功。也就是说，我认为它吸引这么多专业人士的原因在于，数据科学本质上是编程、统计和商业知识三个关键领域的交汇点。它还涉及大量的创造力，因为数据科学家从一个业务问题开始，需要找到最佳路径来回答这个问题，使用各种先进技术，比如预测分析。他们致力于进行研究，以观察那些没有通过深入的数据分析无法发现的模式、联系和数据行为，然后能够认识到如何利用这些来为他们所工作的组织带来利益。

数据科学家应被期望在统计学和数学方面是专家，当然在编程语言方面，如 Python、R、Scala 也是如此。

机器学习工程师

这是另一个需求量大的角色，和数据工程/数据科学有一定的重叠。

机器学习工程师负责弥合数据科学家和技术之间的差距，以便将数据科学家的成果带到生产或组织服务中。他们通过构建数据管道、将模型迁移到生产环境、公开 API、训练模型和执行 A/B 测试来实现这一点。

机器学习工程师需要对各种机器学习库（例如：Tensorflow、NLTK）有深入的了解，具备编程经验以及对 SQL、Rest API 和其他补充技术有扎实的知识。

BI 开发员

尽管过去几年大部分关注点转向了人工智能，但我们不能忘记商业智能的重要性。人工智能和商业智能对于现代组织的成功和决策制定都是关键。

BI 开发人员通常负责开发和维护 BI 界面：数据可视化和仪表板、报告和查询工具。在所需技能方面，以下是一些对 BI 开发人员有用的技能：SQL、深入理解 OLAP 和 ETL，以及 BI 系统的经验：Power BI、Qlik Sense 或其他。

数据库管理员（DBA）

这个角色是名单中的资深者。数据库管理员在设置和维护数据库方面扮演着关键角色。作为组织数据库健康的负责人，数据库管理员基本上负责公司的重要资产之一。数据库管理员的活动包括：管理数据库访问（授予/撤销等）、计划和归档备份例程（和恢复）、计划和执行安装与升级、监控数据库并优化其性能。

数据库管理员显然需要精通他们负责的数据库。

ETL 开发人员

简而言之，ETL 开发人员负责将数据从源数据库转移到目标数据库的过程，包括监控和测试过程的性能，并在需要时修复。在大规模系统中，这一过程非常频繁，因此至关重要。

ETL 开发人员必须具备以下经验：ETL 工具（流行的有：Talend、Informatica、Datastage）、SQL、脚本语言和建模工具。

数据架构师

我认为这个角色和随后的角色充当团队的粘合剂。数据架构师基本上是技术粘合剂，负责所有架构活动。这包括创建蓝图和设计文档，以指定数据库流程和集成点，评估和批准工程师部署和使用的适当工具。数据架构师还应该充当“守门人”，确保组织的数据愿景得到执行，显然需要必要的安全措施。

在我看来，数据架构师必须是全能型人才。这意味着在数据技术和最佳实践方面具有深入的知识，并保持最新的进展。

数据产品负责人

数据产品负责人负责领导组织的数据战略，并监督产品组合在利用数据和对齐愿景方面的情况。

首先，数据产品负责人就是一个产品负责人。一般来说，产品负责人定义路线图，与内部和外部利益相关者合作，确保项目的进展，并充当“项目的粘合剂”。在所有这些活动的基础上，数据产品负责人还负责确保组织最大化数据的价值，以实现最佳的业务成果。在某些情况下，这意味着通过展示利用数据的好处来影响高级管理层，同时确保数据在公司内部得到广泛执行和接受。

总结

数据人才不再仅仅被科技公司猎头。如今，大多数公司已经理解数据的力量及其对组织发展的重要性。请记住，公司可能在对上述不同角色的定义和范围上有所不同。

如前所述，尽管每个人可能都听说过数据科学家的角色，但数据领域还有许多其他角色。每个角色都有其特定的挑战和所需的技能。如果你想在数据领域找到一份工作，确保你对各种角色及其差异有充分的了解，这些差异有时可能很微妙，甚至会重叠。

那你还在等什么呢？

个人简介：Alon Mei-raz 是以色列领先银行的副总裁数据与洞察，负责所有数据平台和团队，这些团队为超过 200 万客户提供支持。Alon 在 HPE、Sun Microsystems 及其他市场领先公司担任过各种技术领导和高级管理职位超过 15 年，在移动性、机器学习和聊天机器人领域拥有广泛的经验。

相关：

• 大数据和数据科学的 5 条职业路径，解释说明

• 成功数据科学职业的建议

• 4 种数据科学家的现实职业选择

更多相关话题

• 快速指南：如何找到适合标注的优秀人才

• 停止学习数据科学以寻找目标，寻找目标去……

• 通过自定义指令调整 ChatGPT 以满足您的需求

• 揭开选择完美机器学习算法的秘密！

• KDnuggets™新闻 22:n03，1 月 19 日：深入探讨 13 个数据……

• 深入探讨 13 种数据科学家角色及其职责

在图像中找到未标记的图片

原文：www.kdnuggets.com/2022/09/find-picture-image-without-marking.html

作者提供的图片 | 编辑者编辑

我们经常看到图像中的图片：例如，漫画将几张图片合并成一张。如果你有一个娱乐应用程序，用户在其中发布迷因，就像我们的 iFunny，你会经常遇到这种情况。神经网络已经能够找到动物、人或其他物体，但如果我们需要在图像中找到另一张图片怎么办？让我们更详细地了解我们的算法，以便你可以在 Google Colaboratory 中使用一个笔记本进行测试，甚至在你的项目中实现它。

---

我们的前三大课程推荐

1. Google Cybersecurity Certificate - 快速进入网络安全领域

2. Google Data Analytics Professional Certificate - 提升你的数据分析技能

3. Google IT Support Professional Certificate - 支持你的组织 IT 需求

---

所以，迷因。许多迷因由图片及其标题组成，前者作为语言笑话的背景：

一张迷因可能包含多个带有文字的图片：

一种流行的迷因类型是社交网络帖子截图，例如来自 Twitter。图片在其中占据了相对较小的区域。

最初，寻找图片的任务出现在我们发送推送通知的时候。在 Android 全面页面推送消息出现之前，这些消息中的所有图片都非常小。文字难以阅读（那用户需要它干嘛？），通知图片中的所有对象几乎没有信息量。它们也不够吸引人。

我们决定押注于迷因中的图片。为了增强视觉效果，我们制作了一个算法，可以裁剪图片周围的所有框架，无论上面显示了什么。

让我们通过几个例子来看看算法的实际效果

以下是算法如何处理黑色背景和应用程序水印的方式：

在以下示例中，尽管它们之间有一条大线，但算法并未将这些图像分开。

该方法也适用于占据整个图像约 50%面积的大型竖直文本。

然而，算法未能识别应用水印（仍需改进）。

算法在处理以下示例时表现出色，即使目标图像在整个表情包中所占比例相对较小。算法还修剪了侧边的白色边框。

在下一个示例中，图像中同时有两个背景（白色和黑色），但算法成功处理了这一情况。然而，它保留了侧边的白色边框。

最后一个例子特别有趣，因为图像本身包含许多线条。但即便如此，也未能困扰我们的算法。上边界比我们期望的稍大，但对于如此困难的情况来说，这是一个很好的结果！

请回忆一下，这些结果是在没有标记的情况下取得的。

算法

跳过代码中无关紧要的部分。你可以在算法的完整实现中找到并运行这些部分。在这篇文章中，我们将重点关注主要思想。

以这张小狗的图片为例。

它在顶部有文本和一条白色背景的小条纹，以及底部的应用水印。

为了仅获取小狗的图片，我们需要去除上下两个水平矩形。基本思路是使用霍夫变换识别图像中的所有直线，然后选择那些与白色或黑色单色区域相邻的直线，我们将这些区域视为背景。

第 1 步。将图像转换为灰度图像

图像处理的第一步是将其转换为单色格式。有很多方法可以实现这一点，但我更喜欢获取Lab颜色空间中的 L 通道（亮度）。这种方法在大多数情况下被证明是最好的。不过，你可以尝试其他方法，比如HSV颜色空间中的 V 通道（值）。

为了消除图像中产生不必要线条的强对比度差异，我们对生成的黑白图像应用高斯滤波器。

img_gray = cv2.cvtColor(img, cv2.COLOR_RGB2LAB)[:, :, 0]

img_blur = cv2.GaussianBlur(img_gray, (9, 9), 0)

这里我们使用了 OpenCV 库中的函数。除了图像外，cv2.GaussianBlur 函数接受高斯内核大小（宽度，高度）和 X 轴上的标准差（默认情况下，Y 轴为 0）。当使用 0 作为标准差时，它会根据内核的大小进行计算。我们使用的参数基于主观经验。

这是我们目前得到的结果。

你可以从scikit-image库中找到并使用类似的方法，但要小心，因为它们在结果和输入参数上有所不同。skimage.color.rgb2lab函数的亮度通道结果在[0,100]范围内，高斯滤波器skimage.filters.gaussian对内核参数更为敏感，这会影响最终结果。

第 2 步。检测边缘

霍夫变换是我们算法的基础，只能处理由背景和边缘组成、值为 0 和 1 的二值图像。

我们使用边缘检测算法来创建二值图像。简而言之，该算法计算像素坐标的强度函数的梯度，并找到其局部最大值，这些区域被定义为所需的边缘。

变换结果

我们使用来自scikit-image库的 Feature 模块中的 Canny 函数来执行变换。你可以在 OpenCV 库中找到类似的函数，但它的实现包括一个 5x5 的高斯滤波器平滑，这使得控制情况有点困难。

img_canny = feature.canny(img_blur) * 1

第 3 步：Hough 变换

现在我们需要在找到的所有线条中检测直线。Hough 的直线变换在这方面表现出色。算法在原点的给定距离 ? 处和 X 轴的某个角度 ? 绘制一条直线，如下所示。

对于每条这样的线，它计算位于绘制直线上的二值图像的亮像素数量。这个过程会对选定范围内的所有 ? 和 ? 值重复进行。结果是 (?, ?) 坐标系中的强度图。因此，当绘制的直线与图像中的线条重合时，结果图中的极大值将会出现。

右图中是对左侧图中两条黑线的 Hough 变换的示意图。

在我们的算法中，我们使用这个来自 scikit-image 的实现，因为它更易于配置。此外，这个库提供了一个方便的方法来选择最类似于直线的局部极大值。OpenCV 的实现没有类似的功能。

tested_angles = np.linspace(-1.6, 1.6, 410)
h, theta, d = transform.hough_line(img_canny, theta=tested_angles)
_, angles, dists = transform.hough_line_peaks(h, theta, d)

变换输出了找到的线条的角度和距离。绘制这些线条比我们习惯的直线要复杂一些，因此这里有一个额外的代码片段。

plt.figure(figsize=(10, 10))
plt.imshow(img_gray, cmap="gray")

x = np.array((0, img_gray.shape[1]))
ys = []
for angle, dist in zip(angles, dists):    
    y0, y1 = (dist - x * np.cos(angle)) / np.sin(angle)
    y = int(np.mean([y0, y1]))
    ys += [y]
    plt.plot(x, [y, y])

ys = np.array(ys)
plt.axis("off");

计算得到的距离是斜边，而直线在 y 轴上的位置是直角边，因此我们将距离值除以所得角度的正弦值。

运行此代码后，你将看到以下内容：

我们的算法找到了所有必要的线条！应用水印的边界也被检测到。

第 4 步：直线分类

最后，我们需要确定哪一条是底部线，哪一条是顶部线，同时去除不必要的线条，例如黑条上方的那一条。

最终结果

为了解决这个问题，我们添加了对找到的线条上下区域的检查。由于我们处理的是表情包及其字幕，我们期望图像外的背景是白色的，而文字是黑色的。或者反过来：黑色背景和白色文字。

因此，我们的算法基于检查分离区域中白色和黑色像素的百分比。

props = {
    "white_limit": 230,
    "black_limit": 35,
    "percent_limit": 0.8
}

areas_h = []
for y in ys:
  percent_up = np.sum((img[:y] > props['white_limit']) + (img[:y] < props['black_limit'])) / (y * img.shape[1] * 3)
  percent_down = np.sum((img[y:] > props['white_limit']) + (img[y:] < props['black_limit'])) / ((img.shape[0] - y) * img.shape[1] * 3)
  areas_h += [-1 * (percent_up > props['percent_limit']) + (percent_down > props['percent_limit']) * 1]

在这种方法中，我们使用了 3 个变量：

• white_limit 是定义白色的下限。所有值在(230; 256)范围内的像素将被视为白色。

• black_limit 是定义黑色的上限。所有值在(0; 35)范围内的像素将被视为黑色。

• percent_limit 是将区域视为带有文本的背景时白色/黑色像素的最小百分比。

此外，比较在每个颜色通道中独立进行，这是一种通用的条件，允许你正确处理稀有的例外情况。

接下来的几行代码选择了上限中的最低线和下限中的最高线。我们还添加了一个关于所选区域大小的条件。如果结果的垂直线裁剪掉了图像高度的超过 60%，我们将其视为错误，并返回原始图像的顶部或底部边框。这个参数是基于对表情包图像占用区域的假设来选择的。

cut_threshold = 0.6
y0 = np.max(ys[areas_h == -1])
if y0 > cut_threshold * img.shape[0]:
    y0 = 0
y1 = np.min(ys[areas_h == 1])
if y1 < (1 - cut_threshold) * img.shape[0]:
    y1 = img.shape[0]

最终算法，你可以在这里的 Functions 部分找到，还包括了寻找和调整垂直边框的功能，让你能够去除图像两侧的边框。

接下来是什么？

为了改善结果，你需要学习如何测量质量，而这需要标记。如果你想创建一个训练数据集，我们的算法将使你的手动标记更容易，从而使你能更快地收集到所需数量的样本。

为了使我们的方法适用于更多情况，你可以将算法中的背景色检查替换为单色检查。这样，无论背景色是什么，方法都可以使用。

亚罗斯拉夫·穆尔扎耶夫是 Funcorp 的数据科学家。

更多相关内容

• 停止学习数据科学以寻找目标并寻找目标…

• 如何在没有任何工作经验的情况下获得你的第一份数据科学工作

• Python 字符串匹配无复杂 RegEx 语法

• 如何像老板一样进行 MLOps：无泪的机器学习指南

• 如何找到最佳的数据科学远程工作

• 快速指南：如何找到合适的标注人才

如何在 Python 中找到集合差集

原文：www.kdnuggets.com/2023/03/find-set-difference-python.html

作者提供的图片

在 Python 中，集合是内置的数据结构，存储的是无序的、不重复的和不可变的元素集合。你可以对 Python 集合执行集合论中的常见操作，如并集、交集和集合差集。

---

我们的三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织 IT

---

本教程将教你如何在 Python 中计算集合差集。你将学习如何使用内置集合方法 difference() 和 - 运算符来找到集合差集，以及如何在过程中调试常见错误。

让我们开始吧。

什么是集合差集？

在计算 Python 集合的差集之前，让我们快速回顾一下集合差集操作。

给定两个集合 A 和 B，我们可以定义如下：

• A - B:（读作 A 差 B）是指存在于集合 A 中但不在集合 B 中的所有元素的集合。

• B - A:（读作 B 差 A）是指存在于集合 B 中但不在集合 A 中的所有元素的集合。

集合差集 不是 交换律操作。因此，A - B 不同于 B - A，除非集合 A 和 B 是相等的，即 A 和 B 包含相同的元素。

我们可以从下面的简单示例中看到这一点：

作者提供的图片

在这个示例中：

• 集合 A:

• 集合 B:

因此，A - B 是 {1,2,7}，是仅存在于 A 中的元素集合。而 B - A 是 {21,10}，是仅存在于 B 中的元素集合。

使用 difference() 方法进行集合差集

让我们定义 fruits 和 to_eat，这是两个包含字符串作为单独元素的 Python 集合。

作者提供的图片

fruits = {"apples","oranges","berries","cherries"}
to_eat = {"apples","cereals","berries","bread"}

现在要找到 fruits - to_eat，让我们在 fruits 集合上调用 difference() 方法，将 to_eat 作为参数：

print(fruits.difference(to_eat))
Output >> {'cherries', 'oranges'}

同样，要找到 to_eat - fruits，让我们在 to_eat 集合上调用 difference() 方法，如下所示：

print(to_eat.difference(fruits))
Output >> {'cereals', 'bread'}

使用差集运算符 (-) 进行集合差集

我们也可以使用 差集运算符 (-) 来找到集合差集。

让我们回到相同的例子：对于集合fruits和to_eat，使用差集运算符(-)执行等效操作并返回相同结果：

print(fruits - to_eat)
Output >> {'cherries', 'oranges'}

print(to_eat - fruits)
Output >> {'cereals', 'bread'}

调试常见的集合差集错误

在我们迄今为止编写的示例中，我们计算了两个 Python 集合之间的差集。但没有强调difference()方法如何与差集运算符不同。

你可以在任何有效的集合对象上调用difference()方法。但是，你可以传入一个或多个集合或其他 Python 可迭代对象。以下是一个示例。

让我们定义set1、list1、list2和list3：

set1 = {1,2,3,4,5}
list1 = [2,4,6]
list2 = [3,6,9]
list3 = [10,11]

现在我们可以在set1上调用difference()方法，并在方法调用中传入list1、list2和list3。

print(set1.difference(list1,list2,list3))
Output >> {1, 5}

在这种情况下，difference方法返回集合中仅存在于set1而不在list1、list2和list3中的元素{1,5}。

但是，如果你尝试使用差集运算符，你会遇到TypeError异常。因为-是一个二元运算符，它操作于两个操作数，所以我们先将三个列表连接起来，然后尝试计算集合差集：

>>> set1 - (list1 + list2 + list3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'set' and 'list'</module></stdin>

如上所示，与difference()方法不同，-运算符仅适用于 Python 集合。因此，你必须在计算差集之前将其他可迭代对象转换为 Python 集合，如下所示：

print(set1 - set(list1 + list2 + list3))
Output >> {1, 5}

结论

让我们快速回顾一下在本教程中学到的内容。要找到集合差集，我们可以使用 Python 集合上的difference()方法或-运算符。虽然difference()方法作用于集合并接受一个或多个 Python 可迭代对象作为参数，而-运算符仅允许在两个 Python 集合之间执行集合差集操作。如果你想学习 Python，可以查看这个免费资源列表。

Bala Priya C 是一位技术作家，喜欢创作长篇内容。她的兴趣领域包括数学、编程和数据科学。她通过编写教程、操作指南等与开发者社区分享她的学习成果。

更多相关话题

• 停止学习数据科学，找到目标，寻找目标来…

• 初级与高级数据科学家薪资：有什么区别？

• 如何找到最佳的数据科学远程职位

• 数据分析师与数据科学家有什么区别？

• 快速指南：找到合适的标注人才

• NLP、NLU 和 NLG：有什么区别？全面指南

寻找最佳 IDE 软件

原文：www.kdnuggets.com/2022/05/finding-best-ide-software.html

Pakata Goh 通过 Unsplash

开发人员需要一个 IDE - 集成开发环境。它们提供了开发人员进行软件测试和编写所需的基本工具。

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业。

2. 谷歌数据分析专业证书 - 提升你的数据分析水平

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT

---

你能想象一个开发人员需要单独选择、使用和管理工具会有多么困难吗？这非常困难且耗时。IDE 通过一个单一的框架整合了所有这些工具，帮助开发人员更快、更有效地工作。

让我们深入探讨一下什么是 IDE。

什么是 IDE？

集成开发环境（IDE）是用于帮助软件开发的工具。它们的设计旨在通过提供实现编程目标所需的组件来提高开发人员的生产力。

IDE 的主要功能包括：

• 文本编辑器是它们的主要功能

• 一个编译器可以将你的代码转换为计算机可读的语言。

• 一个解释器可以在不需要先编译的情况下执行代码

• 构建或制作集成以自动化流程。

• 一个调试器可以扫描你的代码中的错误，以便轻松解决。

• 语法高亮器可以区分代码的各个部分，如属性、标签、属性等。

• 图形用户界面（GUI）是用户互动的部分，如按钮、菜单等。

我应该使用哪个 IDE？

在决定何时开始使用某样东西时，总是要考虑你需要它做什么，它是否能帮助你实现目标。

就 IDE 而言，它们有不同的功能。从格式到颜色代码；你可能偏好某个 IDE，而你的员工可能偏好另一个。

到头来，你需要选择一个你觉得使用起来舒适并且能够实现目标的 IDE。

然而，为了帮助你做出决定，请考虑以下功能：

1. 编程语言 - 你正在考虑的 IDE 是否支持你使用的编程语言

2. 源代码库 - 一些 IDE 包含其他 IDE 不提供的特定脚本。

3. 自定义文本编辑器 - 你是否希望能够编辑 GUI？

4. 集成和插件 - 例如，你是否想将你的工作与 GitHub 集成？

5. 错误和报告 - 你是否需要一个能检测错误并为你报告的 IDE？

6. 单元测试 - 你是否想添加模拟对象来改善你的工作流程？

7. 完成你的代码 - 如果一个 IDE 能智能地完成你的代码，会不会更好？对于一些 IDE 来说，这是可能的。

8. 组织你的工作 - 将你的项目、文件和脚本组织成层级图是否能改善你的工作流程？

5 款流行 IDE 列表

Visual Studio

Visual Studio IDE 是迄今为止最受欢迎和最好的开发者 IDE。它足够智能，能够从你的代码中学习，以完成你的代码。

Visual Studio 因用于网站、应用程序和游戏开发而闻名。常用的编程语言包括 Python 和 C++。

PyCharm

PyCharm 被誉为最佳的 Python IDE。然而，它也提供了一个支持其他编程语言的高级版本。

PyCharm 能够在你编写代码时检查错误，并智能地完成你的代码。它会检查代码的质量，以确保其效率足够高。

RubyMine

如名称所示，RubyMine 专注于编程语言 Ruby 和 Ruby on Rails 框架。然而，它也可以与 JavaScript、CSS 等一起使用。

RubyMine 具有语法高亮功能，可以突出显示代码中的错误，并能完成你的代码。它还具有高级搜索功能，你可以搜索任何类、文件或符号。

Eclipse

Eclipse 是最受欢迎的 IDE 之一，是一个开源的社区驱动 IDE，主要用于 Javascript 程序员，但也支持 HTML、CSS 等。谷歌、Netflix 和 Facebook 等大型公司都使用过 Eclipse。

Eclipse 的界面是其如此受欢迎的原因，具有拖放功能等。你还可以使用静态分析来帮助分析代码，并具有调试功能。

PhpStorm

PhpStorm 专注于 PHP，这是一种用于 Web 开发的脚本语言。然而，它也支持 HTML、CSS、JavaScript 等前端编程语言。

由于其前端专注，PhpStorm 还包括创建网站的软件，例如 WordPress 等。

PhpStorm 易于使用，能智能地完成你的代码，帮助调试等。

结论

这些只是几个可用的热门 IDE，但如果您查看了这个短名单后，觉得没有一个适合您；还有很多其他的选择。

不断尝试不同的 IDE，直到找到您觉得最舒适和最具生产力的那一个。

Nisha Arya 是一位数据科学家和自由技术作家。她特别关注提供数据科学职业建议或教程，以及围绕数据科学的理论知识。她还希望探索人工智能在延长人类寿命方面的不同方式。作为一个热衷学习者，她寻求拓宽她的技术知识和写作技能，同时帮助指导他人。

更多相关主题

• 软件开发者与软件工程师

• 软件错误和权衡：Tomasz Lelek 的新书…

• 开发者准备好的软件堆栈上的设备内 AI

• 决策树软件完全指南

• AI 和开源软件：一出生就分离？

• 如何让大型语言模型与您的软件兼容…

如何使用 spaCy 3 微调 BERT Transformer

原文：www.kdnuggets.com/2021/06/fine-tune-bert-transformer-spacy.html

评论

作者：Walid Amamou，UBIAI 创始人

图片由Alina Grubnyak提供，拍摄于Unsplash

自从 Vaswani 等人发表了开创性论文“Attention is all you need”之后，Transformer 模型已成为目前 NLP 技术中的领先技术。其应用范围从命名实体识别（NER）、文本分类、问答系统到文本生成，这项惊人的技术的应用几乎是无限的。

更具体来说，BERT（Bidirectional Encoder Representations from Transformers）以一种新颖的方式利用了 transformer 架构。例如，BERT 通过随机掩蔽的词分析句子的两侧来进行预测。除了预测掩蔽的词外，BERT 通过在第一个句子开头添加分类标记[CLS]来预测句子序列，并尝试通过在两个句子之间添加分隔标记[SEP]来预测第二个句子是否跟随第一个句子。

BERT 架构

在本教程中，我将向你展示如何微调 BERT 模型以预测软件职位描述中的技能、学历、学历专业和经验等实体。如果你有兴趣进一步提取实体之间的关系，请阅读我们的文章了解如何使用 transformers 进行联合实体和关系提取。

微调 transformers 需要强大的 GPU 和并行处理能力。为此我们使用 Google Colab，因为它提供了免费的带 GPU 的服务器。

在本教程中，我们将使用新发布的spaCy 3 库来微调我们的 transformer。以下是如何在 spaCy 3 上微调 BERT 模型的逐步指南。

数据标注：

要使用 spaCy 3 微调 BERT，我们需要提供符合 spaCy 3 JSON 格式的训练和开发数据（请见这里），这些数据将被转换为.spacy 二进制文件。我们将提供以 IOB 格式保存的 TSV 文件中的数据，然后转换为 spaCy JSON 格式。

我仅为训练数据集标注了 120 份职位描述，标注了如技能、学历、学历专业和经验等实体，开发数据集则标注了约 70 份职位描述。

在本教程中，我使用了UBIAI注释工具，因为它具备诸如以下的广泛功能：

• ML 自动注释

• 字典、正则表达式和规则基础的自动注释

• 团队协作以共享注释任务

• 直接注释导出为 IOB 格式

使用 UBIAI 中的正则表达式功能，我已经预注释了所有符合模式“\d.+.”的经验提及，例如“5 + years of experience in C++”。然后我上传了一个包含所有软件语言的 csv 字典并分配了实体技能。预注释节省了大量时间，并将帮助你减少手动注释。

UBIAI 注释界面

有关 UBIAI 注释工具的更多信息，请访问 文档 页面以及我之前的文章“介绍 UBIAI：用于 NLP 应用的易用文本注释”。

导出的注释将如下所示：

MS B-DIPLOMA
in O
electrical B-DIPLOMA_MAJOR
engineering I-DIPLOMA_MAJOR
or O
computer B-DIPLOMA_MAJOR
engineering I-DIPLOMA_MAJOR
. O
5+ B-EXPERIENCE
years I-EXPERIENCE
of I-EXPERIENCE
industry I-EXPERIENCE
experience I-EXPERIENCE
. I-EXPERIENCE
Familiar O
with O
storage B-SKILLS
server I-SKILLS
architectures I-SKILLS
with O
HDD B-SKILLS

为了从 IOB 转换为 JSON（请参见文档 这里），我们使用 spaCy 3 命令：

!python -m spacy convert drive/MyDrive/train_set_bert.tsv ./ -t json -n 1 -c iob
!python -m spacy convert drive/MyDrive/dev_set_bert.tsv ./ -t json -n 1 -c iob

转换为 spaCy 3 JSON 后，我们需要使用此命令将训练和开发 JSON 文件转换为 .spacy 二进制文件（请更新文件路径为自己的路径）：

!python -m spacy convert drive/MyDrive/train_set_bert.json ./ -t spacy!python -m spacy convert drive/MyDrive/dev_set_bert.json ./ -t spacy

模型训练：

• 打开一个新的 Google Colab 项目，并确保在笔记本设置中选择 GPU 作为硬件加速器。

• 为了加快训练过程，我们需要在 GPU 上运行并行处理。为此，我们安装 NVIDIA 9.2 cuda 库：

!wget [`developer.nvidia.com/compute/cuda/9.2/Prod/local_installers/cuda-repo-ubuntu1604-9-2-local_9.2.88-1_amd64`](https://developer.nvidia.com/compute/cuda/9.2/Prod/local_installers/cuda-repo-ubuntu1604-9-2-local_9.2.88-1_amd64) -O cuda-repo-ubuntu1604–9–2-local_9.2.88–1_amd64.deb!dpkg -i cuda-repo-ubuntu1604–9–2-local_9.2.88–1_amd64.deb!apt-key add /var/cuda-repo-9–2-local/7fa2af80.pub!apt-get update!apt-get install cuda-9.2

要检查是否安装了正确的 cuda 编译器，请运行：!nvcc --version

• 安装 spacy 库和 spacy transformer 流水线：

pip install -U spacy
!python -m spacy download en_core_web_trf

• 接下来，我们安装为 cuda 9.2 配置的 pytorch 机器学习库：

pip install torch==1.7.1+cu92 torchvision==0.8.2+cu92 torchaudio==0.7.2 -f https://download.pytorch.org/whl/torch_stable.html

• 安装 pytorch 后，我们需要安装为 cuda 9.2 调整的 spacy transformers，并按如下更改 CUDA_PATH 和 LD_LIBRARY_PATH。最后，安装 cupy 库，它是 GPU 上的 numpy 库：

!pip install -U spacy[cuda92,transformers]
!export CUDA_PATH=”/usr/local/cuda-9.2"
!export LD_LIBRARY_PATH=$CUDA_PATH/lib64:$LD_LIBRARY_PATH
!pip install cupy

• SpaCy 3 使用一个包含所有模型训练组件的配置文件 config.cfg 来训练模型。在 spaCy 训练页面上，你可以选择模型的语言（本教程中的英语）、组件（NER）和硬件（GPU），并下载配置文件模板。

用于训练的 Spacy 3 配置文件。 来源

我们需要做的唯一事情是填写训练和开发 .spacy 文件的路径。完成后，我们将文件上传到 Google Colab。

• 现在我们需要用 BERT 模型所需的其余参数自动填充配置文件；你只需运行此命令：

!python -m spacy init fill-config drive/MyDrive/config.cfg drive/MyDrive/config_spacy.cfg

我建议调试你的配置文件，以防出现错误：

!python -m spacy debug data drive/MyDrive/config.cfg

• 我们终于准备好训练 BERT 模型了！只需运行此命令，训练应该会开始：

!python -m spacy train -g 0 drive/MyDrive/config.cfg — output ./

附注：如果遇到错误 cupy_backends.cuda.api.driver.CUDADriverError: CUDA_ERROR_INVALID_PTX: PTX JIT 编译失败，只需卸载 cupy 并重新安装即可解决问题。

如果一切正常，你应该开始看到模型的评分和损失正在更新：

在 google colab 上进行 BERT 训练

在训练结束时，模型将保存在 model-best 文件夹下。模型评分位于 model-best 文件夹内的 meta.json 文件中：

“performance”:{
“ents_per_type”:{
“DIPLOMA”:{
“p”:0.5584415584,
“r”:0.6417910448,
“f”:0.5972222222
},
“SKILLS”:{
“p”:0.6796805679,
“r”:0.6742957746,
“f”:0.6769774635
},
“DIPLOMA_MAJOR”:{
“p”:0.8666666667,
“r”:0.7844827586,
“f”:0.8235294118
},
“EXPERIENCE”:{
“p”:0.4831460674,
“r”:0.3233082707,
“f”:0.3873873874
}
},
“ents_f”:0.661754386,
“ents_p”:0.6745350501,
“ents_r”:0.6494490358,
“transformer_loss”:1408.9692438675,
“ner_loss”:1269.1254348834
}

由于训练数据集有限，评分远低于生产模型水平，但值得检查其在示例职位描述上的表现。

使用变换器进行实体提取

要在示例文本上测试模型，我们需要加载模型并在文本上运行：

nlp = spacy.load(“./model-best”)

text = [
'''Qualifications
- A thorough understanding of C# and .NET Core
- Knowledge of good database design and usage
- An understanding of NoSQL principles
- Excellent problem solving and critical thinking skills
- Curious about new technologies
- Experience building cloud hosted, scalable web services
- Azure experience is a plus
Requirements
- Bachelor's degree in Computer Science or related field
(Equivalent experience can substitute for earned educational qualifications)
- Minimum 4 years experience with C# and .NET
- Minimum 4 years overall experience in developing commercial software
'''
]

for doc in nlp.pipe(text, disable=["tagger", "parser"]):
    print([(ent.text, ent.label_) for ent in doc.ents])

以下是从我们的示例职位描述中提取的实体：

[
("C", "SKILLS"),
("#", "SKILLS"),
(".NET Core", "SKILLS"),
("database design", "SKILLS"),
("usage", "SKILLS"),
("NoSQL", "SKILLS"),
("problem solving", "SKILLS"),
("critical thinking", "SKILLS"),
("Azure", "SKILLS"),
("Bachelor", "DIPLOMA"),
("'s", "DIPLOMA"),
("Computer Science", "DIPLOMA_MAJOR"),
("4 years experience with C# and .NET\n-", "EXPERIENCE"),
("4 years overall experience in developing commercial software\n\n", "EXPERIENCE")
]

仅使用 120 个训练文档就已经非常令人印象深刻！我们能够正确提取大部分技能、文凭、文凭专业和经验。

通过更多的训练数据，模型肯定会进一步提高并产生更高的评分。

结论：

只需几行代码，我们就成功地训练了一个功能齐全的 NER 变换器模型，感谢出色的 spaCy 3 库。请尝试在你的用例中使用，并分享你的结果。注意，你可以使用 UBIAI 注释工具来标记数据，我们提供免费 14 天试用。

一如既往，如果你有任何意见，请在下面留言或发送邮件至 admin@ubiai.tools！

简历：Walid Amamou 是 UBIAI 的创始人，UBIAI 是一个用于 NLP 应用的注释工具，他拥有物理学博士学位。

原文。经授权转载。

相关：

• 如何通过 API 创建和部署简单的情感分析应用

• 如何将变换器应用于任何长度的文本

• 自然语言处理研究和应用的新资源

---

我们的前 3 个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

更多相关主题

• 如何使用 Hugging Face AutoTrain 微调 Mistral AI 7B LLM

• 开始使用 spaCy 进行 NLP

• 使用 spaCy 进行自然语言处理

• 使用 HuggingFace 微调 BERT 以进行推文分类

• 使用 BERT 分类长文本文档

• BERT 在稀疏性下的速度有多快？

如何微调机器学习模型以提高预测准确性

原文：www.kdnuggets.com/2019/01/fine-tune-machine-learning-models-forecasting.html

评论

微调机器学习预测模型是提高预测结果准确性的关键步骤。最近，我写了许多文章，解释了机器学习的工作原理以及如何丰富和分解特征集，以提高机器学习模型的准确性。

这篇文章详细介绍了：

1. 使用评分指标检索模型性能的估计

2. 查找和诊断机器学习算法的常见问题

3. 微调机器学习模型的参数

请阅读 FinTechExplained

免责声明.*

步骤 1：了解什么是微调机器学习模型

有时，我们需要探索模型参数如何提高我们机器学习模型的预测准确性。

微调机器学习模型是一项复杂的技术任务。它可能变成一项耗时的工作。在这篇文章中，我将介绍一些我们可以遵循的方法，以在更短的时间内获得准确的结果。

我经常被问到，当特征稳定且特征集被分解时，可以使用哪些技术来调整预测模型。一旦尝试了所有方法，我们应该寻求微调我们的机器学习模型。

调整机器学习模型就像旋转电视开关和旋钮，直到你获得更清晰的信号

该图表说明了参数如何相互依赖。

• X 训练数据——自变量的训练数据，也称为特征

• X 测试数据——自变量的测试数据

• Y 训练数据——依赖变量的训练数据

• Y 测试数据——依赖变量的测试数据

例如，如果你根据温度和湿度预测瀑布的水量，那么水量表示为 Y（依赖变量），温度和湿度为 X（自变量或特征）。X 的训练数据称为 X 训练数据，你可以用来训练你的模型。

超参数是可以作为模型输入参数的模型参数。

步骤 2：了解基础知识

在微调你的预测模型之前，了解机器学习的基本概念非常重要。

如果你是机器学习的新手，请看看这篇文章：

8 分钟了解机器学习

改进我们输入模型的数据通常比微调模型参数更容易。如果你想提高预测模型的准确性，请首先丰富特征集中的数据。

如果你输入的数据质量差，那么模型将产生差的结果。

请查看这篇文章，突出常见的技术，以丰富特征：

处理数据以提高机器学习模型准确性

如果你不确定你的模型是否是问题的最适合模型，可以查看这篇文章。它评审了大多数常见的机器学习模型算法：

机器学习算法比较

第 3 步：找到你的评分指标

最重要的前提是决定你将用来评分预测模型准确性的指标。

这些评分指标可能包括 R 平方、调整后的 R 平方、混淆矩阵、F1、召回率、方差等。

阅读这篇文章以了解每个数据科学家应该知道的最重要的数学测量。这些测量以易于理解的方式解释：

每个数据科学家必须知道的数学测量

from sklearn.metrics contains a large number of scoring metrics

第 4 步：获取准确的预测评分

一旦你准备好了训练集，丰富了其特征，缩放了数据，分解了特征集，决定了评分指标并在训练数据上训练了你的模型，你就应该在未见过的数据上测试模型的准确性。未见过的数据被称为“测试数据”。

你可以利用交叉验证来评估模型在未见数据上的表现。这被称为模型的泛化误差。

交叉验证

有两种常见的交叉验证方法

留出交叉验证

在同一数据集上训练模型并评分准确性并不是明智的机器学习实践。用不同模型参数值在未见测试集上测试模型是一种更优的方法。

将数据集划分为三部分是一种良好的实践：

1. 训练集

2. 验证集

3. 测试集

在训练集（60%的数据）上训练模型，然后在验证集（20%的数据）上进行模型选择（调整参数），一旦准备好，就在测试集（20%的数据）上测试模型。

根据机器学习模型的需求和数据的可用性来创建训练、验证和测试数据集的比例。

K 折交叉验证

K 折交叉验证比使用留出交叉验证机制更优。其工作方式是将数据划分为 k 个折（部分）。k-1 个折用于训练模型，最后一个折用于测试模型。

这个机制会重复 k 次。此外，每次都可以使用一些性能指标来评估和评分性能。然后报告性能指标的平均值。StratifiedKFold 保留了类别比例。

选择 8–12 个折叠

from sklearn.cross_validation import cross_val_score 
scores = cross_val_score(estimator=pipe_lr, X=X_train, y=Y_train, cv=12, n_jobs=)
mean_scores = scores.mean()

n_jobs 参数控制用于执行交叉验证的 CPU 数量。

第 5 步：使用验证曲线诊断最佳参数值

一旦确定了准确的预测评分，找出模型所需的所有参数。然后你可以使用验证曲线来探索这些参数值如何提高预测模型的准确性。

在调整参数之前，我们需要诊断并找出模型是否存在欠拟合或过拟合问题。

参数数量较多的模型往往容易过拟合。我们可以使用验证曲线来解决机器学习中的过拟合和欠拟合问题。

这些参数也称为超参数

照片来源：Dominik Scythe 在 Unsplash

验证曲线用于传递一系列模型参数值。它逐一更改模型参数的值，然后可以将准确性值绘制在模型参数值上，以评估模型的准确性。

例如，如果你的模型接受名为“树木数量”的参数，那么你可以通过传入 10 个不同的参数值来测试模型。你可以使用验证曲线报告每个参数值上的准确性以评估准确性。最后取返回最高准确性的分数，这样就能在可接受的时间内得到所需的结果。

Sci-kit learn 提供了验证曲线模块：

from sklearn.learning_curve import validation_curve
number_of_trees= [1,2,3,4,5,6,7,99,1000]
train_scores, test_scores = validation_curve(estimator=, … X=X_train,y=Y_train, param_range=number_of_trees, …)

第 6 步：使用网格搜索优化超参数组合

一旦我们获得了各个模型参数的最佳值，就可以使用网格搜索来获得模型的超参数值组合，从而使我们得到最高的准确性。

网格搜索会评估所有可能的参数值组合。

网格搜索是全面的，并使用穷举法来评估最准确的值。因此，它是计算密集型的任务。

使用 sci-kit learn 的 GridSearchCV 执行网格搜索

from sklearn.grid_search import GridSearchCV

第 7 步：持续调整参数以进一步提高准确性

关键在于一旦有更多数据可用，就要始终增强训练集。

始终在模型未见过的更丰富的测试数据上测试你的预测模型。

始终确保为任务选择正确的模型和参数值。

一旦数据可用，就应尽快提供更多数据，并持续测试模型的准确性，以便进一步优化性能和准确性。

总结

本文探讨了如何：

1. 使用评分指标来检索模型性能的估计值

2. 查找并诊断机器学习算法中的常见问题

3. 微调机器学习模型的参数，以进一步提高准确性

希望这对你有帮助。

原文。已获许可转载。

资源：

• 在线和基于网络的：分析、数据挖掘、数据科学、机器学习教育

• 分析、数据科学、数据挖掘和机器学习的软件

相关：

• 使用 Python 进行时间序列分析和预测的端到端项目

• 数据科学预测未来

• 利用机器学习进行销售预测

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

更多相关主题

• 如何微调 ChatGPT 3.5 Turbo

• 如何使用 Hugging Face AutoTrain 微调 LLMs

• 如何使用 Hugging Face Transformers 微调 BERT 以进行情感分析

• 天高任鸟飞：了解 JetBlue 如何利用 Monte Carlo 和 Snowflake…

• 提高机器学习模型的 7 种方法

• 理解分类指标：评估模型的指南

在 Google Colab 上免费微调 LLAMAv2 与 QLora

原文：www.kdnuggets.com/fine-tuning-llamav2-with-qlora-on-google-colab-for-free

使用 ideogram.ai 生成，提示为：“一张 LLAMA 的照片，横幅上写着‘QLora’，3D 渲染，野生动物摄影”

直到最近，在 Google Colab 上使用单个 GPU 免费微调一个 7B 模型曾是一个梦想。2023 年 5 月 23 日，Tim Dettmers 及其团队提交了一篇关于微调量化大语言模型的革命性论文[1]。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速入门网络安全职业

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持您的组织 IT 需求

---

量化模型是将其权重的数据类型降至比训练时使用的数据类型更低的模型。例如，如果你在 32 位浮点数上训练一个模型，然后将这些权重转换为较低的数据类型，如 16/8/4 位浮点数，而对模型性能的影响最小或没有影响。

来源 2

我们这里不会多谈量化的理论，你可以参考 Hugging-Face 的优秀博客文章2以及 Tim Dettmers 本人的优秀 YouTube 视频4以了解基础理论。

简而言之，可以说 QLora 的意思是：

使用低秩适配矩阵（LoRA）微调量化大语言模型5

让我们直接进入代码：

数据准备

重要的是要理解，大语言模型旨在接受指令，这一点在 2021 年 ACL 论文6中首次介绍。其核心思想很简单，我们给语言模型一个指令，它会遵循指令并执行该任务。因此，我们要微调的模型所需的数据集应为指令格式，如果不是，我们可以转换它。

一种常见的格式是指令格式。我们将使用 Alpaca Prompt 模板7。

Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.

### Instruction:
{instruction}

### Input:
{input}

### Response:
{response}

我们将使用SNLI 数据集，这是一个包含 2 个句子及其之间关系的数据集，关系可能是矛盾、蕴含或中立。我们将利用它通过 LLAMAv2 生成句子的矛盾。我们可以简单地使用 pandas 加载此数据集。

import pandas as pd

df = pd.read_csv('snli_1.0_train_matched.csv')
df['gold_label'].value_counts().plot(kind='barh')

标签分布

我们可以在这里看到一些随机的矛盾示例。

df[df['gold_label'] == 'contradiction'].sample(10)[['sentence1', 'sentence2']]

来自 SNLI 的矛盾示例

现在我们可以创建一个小函数，只处理矛盾的句子并将数据集转换为 instruct 格式。

def convert_to_format(row):
    sentence1 = row['sentence1']
    sentence2 = row['sentence2']ccccc
    prompt = """Below is an instruction that describes a task paired with input that provides further context. Write a response that appropriately completes the request."""
    instruction = """Given the following sentence, your job is to generate the negation for it in the json format"""
    input = str(sentence1)
    response = f"""```json

{{'orignal_sentence': '{sentence1}', 'generated_negation': '{sentence2}'}}

```py
"""
    if len(input.strip()) == 0:  #  prompt + 2 new lines + ###instruction + new line + input + new line + ###response
        text = prompt + "\n\n### Instruction:\n" + instruction + "\n### Response:\n" + response
    else:
        text = prompt + "\n\n### Instruction:\n" + instruction + "\n### Input:\n" + input + "\n" + "\n### Response:\n" + response

    # we need 4 columns for auto train, instruction, input, output, text
    return pd.Series([instruction, input, response, text])

new_df = df[df['gold_label'] == 'contradiction'][['sentence1', 'sentence2']].apply(convert_to_format, axis=1)
new_df.columns = ['instruction', 'input', 'output', 'text']

new_df.to_csv('snli_instruct.csv', index=False)

这是一个示例数据点：

"Below is an instruction that describes a task paired with input that provides further context. Write a response that appropriately completes the request.

### Instruction:
Given the following sentence, your job is to generate the negation for it in the json format
### Input:
A couple playing with a little boy on the beach.

### Response:
```json

{'orignal_sentence': '一对夫妇在海滩上和一个小男孩玩耍。', 'generated_negation': '一对夫妇在海滩上看着一个小女孩自己玩耍。'}

```py

现在我们有了正确格式的数据集，开始微调吧。在开始之前，让我们安装必要的软件包。我们将使用 accelerate、peft（参数高效微调），结合 Hugging Face 的 Bits 和 bytes 以及 transformers。

!pip install -q accelerate==0.21.0 peft==0.4.0 bitsandbytes==0.40.2 transformers==4.31.0 trl==0.4.7

import os
import torch
from datasets import load_dataset
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    BitsAndBytesConfig,
    HfArgumentParser,
    TrainingArguments,
    pipeline,
    logging,
)
from peft import LoraConfig, PeftModel
from trl import SFTTrainer

你可以将格式化的数据集上传到云端并在 Colab 中加载它。

from google.colab import drive
import pandas as pd

drive.mount('/content/drive')

df = pd.read_csv('/content/drive/MyDrive/snli_instruct.csv')

你可以使用 from_pandas 方法轻松地将其转换为 Hugging Face 数据集格式，这将有助于训练模型。

from datasets import Dataset

dataset = Dataset.from_pandas(df)

我们将使用由 abhishek/llama-2–7b-hf-small-shards 提供的已量化 LLamav2 模型。在这里定义一些超参数和变量：

# The model that you want to train from the Hugging Face hub
model_name = "abhishek/llama-2-7b-hf-small-shards"

# Fine-tuned model name
new_model = "llama-2-contradictor"

################################################################################
# QLoRA parameters
################################################################################

# LoRA attention dimension
lora_r = 64

# Alpha parameter for LoRA scaling
lora_alpha = 16

# Dropout probability for LoRA layers
lora_dropout = 0.1

################################################################################
# bitsandbytes parameters
################################################################################

# Activate 4-bit precision base model loading
use_4bit = True

# Compute dtype for 4-bit base models
bnb_4bit_compute_dtype = "float16"

# Quantization type (fp4 or nf4)
bnb_4bit_quant_type = "nf4"

# Activate nested quantization for 4-bit base models (double quantization)
use_nested_quant = False

################################################################################
# TrainingArguments parameters
################################################################################

# Output directory where the model predictions and checkpoints will be stored
output_dir = "./results"

# Number of training epochs
num_train_epochs = 1

# Enable fp16/bf16 training (set bf16 to True with an A100)
fp16 = False
bf16 = False

# Batch size per GPU for training
per_device_train_batch_size = 4

# Batch size per GPU for evaluation
per_device_eval_batch_size = 4

# Number of update steps to accumulate the gradients for
gradient_accumulation_steps = 1

# Enable gradient checkpointing
gradient_checkpointing = True

# Maximum gradient normal (gradient clipping)
max_grad_norm = 0.3

# Initial learning rate (AdamW optimizer)
learning_rate = 1e-5

# Weight decay to apply to all layers except bias/LayerNorm weights
weight_decay = 0.001

# Optimizer to use
optim = "paged_adamw_32bit"

# Learning rate schedule
lr_scheduler_type = "cosine"

# Number of training steps (overrides num_train_epochs)
max_steps = -1

# Ratio of steps for a linear warmup (from 0 to learning rate)
warmup_ratio = 0.03

# Group sequences into batches with same length
# Saves memory and speeds up training considerably
group_by_length = True

# Save checkpoint every X updates steps
save_steps = 0

# Log every X updates steps
logging_steps = 100

################################################################################
# SFT parameters
################################################################################

# Maximum sequence length to use
max_seq_length = None

# Pack multiple short examples in the same input sequence to increase efficiency
packing = False

# Load the entire model on the GPU 0
device_map = {"": 0}

其中大多数是相当直观的超参数，具有这些默认值。你可以随时参考文档获取更多详细信息。

我们现在可以简单地使用 BitsAndBytesConfig 类来创建 4 位微调的配置。

compute_dtype = getattr(torch, bnb_4bit_compute_dtype)

bnb_config = BitsAndBytesConfig(
    load_in_4bit=use_4bit,
    bnb_4bit_quant_type=bnb_4bit_quant_type,
    bnb_4bit_compute_dtype=compute_dtype,
    bnb_4bit_use_double_quant=use_nested_quant,
)

现在我们可以加载带有 4 位 BitsAndBytesConfig 和 tokenizer 的基础模型进行微调。

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map=device_map
)
model.config.use_cache = False
model.config.pretraining_tp = 1

我们现在可以创建 LoRA 配置并设置训练参数。

# Load LoRA configuration
peft_config = LoraConfig(
    lora_alpha=lora_alpha,
    lora_dropout=lora_dropout,
    r=lora_r,
    bias="none",
    task_type="CAUSAL_LM",
)

# Set training parameters
training_arguments = TrainingArguments(
    output_dir=output_dir,
    num_train_epochs=num_train_epochs,
    per_device_train_batch_size=per_device_train_batch_size,
    gradient_accumulation_steps=gradient_accumulation_steps,
    optim=optim,
    save_steps=save_steps,
    logging_steps=logging_steps,
    learning_rate=learning_rate,
    weight_decay=weight_decay,
    fp16=fp16,
    bf16=bf16,
    max_grad_norm=max_grad_norm,
    max_steps=max_steps,
    warmup_ratio=warmup_ratio,
    group_by_length=group_by_length,
    lr_scheduler_type=lr_scheduler_type,
    report_to="tensorboard"
)

现在我们可以简单地使用由 HuggingFace 提供的 trl 中的 SFTTrainer 开始训练。

# Set supervised fine-tuning parameters
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    peft_config=peft_config,
    dataset_text_field="text",  # this is the text column in dataset 
    max_seq_length=max_seq_length,
    tokenizer=tokenizer,
    args=training_arguments,
    packing=packing,
)

# Train model
trainer.train()

# Save trained model
trainer.model.save_pretrained(new_model)

这将开始训练你上述设置的周期数。一旦模型训练完成，确保将其保存在云端，以便你可以再次加载它（因为你需要在 Colab 中重启会话）。你可以通过 zip 和 mv 命令将模型存储在云端。

!zip -r llama-contradictor.zip results llama-contradictor
!mv llama-contradictor.zip /content/drive/MyDrive

现在当你重启 Colab 会话时，可以将其移回到你的会话中。

!unzip /content/drive/MyDrive/llama-contradictor.zip -d .

你需要重新加载基础模型，并将其与微调后的 LoRA 矩阵合并。这可以使用 merge_and_unload() 函数来完成。

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token
tokenizer.padding_side = "right"

base_model = AutoModelForCausalLM.from_pretrained(
    "abhishek/llama-2-7b-hf-small-shards",
    low_cpu_mem_usage=True,
    return_dict=True,
    torch_dtype=torch.float16,
    device_map={"": 0},
)

model = PeftModel.from_pretrained(base_model, '/content/llama-contradictor')
model = model.merge_and_unload()
pipe = pipeline(task="text-generation", model=model, tokenizer=tokenizer, max_length=200)

推理

你可以通过将输入传递到我们上述定义的相同提示模板中来测试你的模型。

prompt_template = """### Instruction:
Given the following sentence, your job is to generate the negation for it in the json format
### Input:
{}

### Response:
"""

sentence = "The weather forecast predicts a sunny day with a high temperature around 30 degrees Celsius, perfect for a day at the beach with friends and family."

input_sentence = prompt_template.format(sentence.strip())

result = pipe(input_sentence)
print(result)

输出

### Instruction:
Given the following sentence, your job is to generate the negation for it in the json format
### Input:
The weather forecast predicts a sunny day with a high temperature around 30 degrees Celsius, perfect for a day at the beach with friends and family.

### Response:
```json

{

"sentence": "天气预报预测天气晴朗，气温高达 30 摄氏度，非常适合与朋友和家人一起去海滩度过一天。",

"negation": "天气预报预测降雨，气温低至 10 摄氏度，不适合与朋友和家人一起去海滩度过一天。"

}

```py

过滤有用的输出

由于令牌限制，模型可能在生成响应后仍会继续预测。在这种情况下，你需要添加一个后处理函数来过滤我们需要的 JSON 部分。可以使用简单的正则表达式来完成。

import re
import json

def format_results(s):
  pattern = r'```json\n(.*?)\n```py'

  # Find all occurrences of JSON objects in the string
  json_matches = re.findall(pattern, s, re.DOTALL)
  if not json_matches:
    # try to find 2nd pattern
    pattern = r'\{.*?"sentence":.*?"negation":.*?\}'
    json_matches = re.findall(pattern, s)

  # Return the first JSON object found, or None if no match is found
  return json.loads(json_matches[0]) if json_matches else None

这样会给你所需的输出，而不是模型重复随机输出的令牌。

摘要

在这篇博客中，你学习了 QLora 的基础知识，如何在 Colab 上使用 QLora 微调 LLama v2 模型，Instruction Tuning，以及一个可以用来进一步指导微调模型的 Alpaca 数据集样本模板。

参考文献

[1]: QLoRA：高效微调量化 LLM，2023 年 5 月 23 日，Tim Dettmers 等人

[8]: Colab Notebook 由@maximelabonne colab.research.google.com/drive/1PEQyJO1-f6j0S_XJ8DV50NkpzasXkrzd?usp=sharing

Ahmad Anis是一位热情的机器学习工程师和研究员，目前在redbuffer.ai工作。除了本职工作外，Ahmad 还积极参与机器学习社区。他担任了 Cohere for AI 的区域负责人，这是一个致力于开放科学的非营利组织，同时还是 AWS 社区建设者。Ahmad 是 Stackoverflow 的活跃贡献者，拥有 2300 多积分。他为许多著名的开源项目做出了贡献，包括 OpenAI 的 Shap-E。

更多相关话题

• 在 Google Colab 上免费运行 Mixtral 8x7b

• 用 HuggingFace 微调 BERT 以进行推文分类

• 用噪声标签数据微调 OpenAI 语言模型

• PEFT 概述：最先进的参数高效微调

• 掌握大型语言模型微调的 7 个步骤

• Mistral 7B-V0.2：用 Hugging Face 微调 Mistral 的新开源 LLM…

微调变换器模型以进行发票识别

原文：www.kdnuggets.com/2021/06/fine-tuning-transformer-model-invoice-recognition.html

评论

作者 Walid Amamou，UBIAI 创始人

发票识别

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升您的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持您的组织 IT 部门

---

介绍

基于我最近关于如何为 NLP 应用标注 PDF 和扫描图像的教程，我们将尝试对最近发布的微软Layout LM 模型进行微调，使用包含法语和英语发票的自定义标注数据集。虽然之前的教程集中于使用公开的FUNSD 数据集来微调模型，但这里我们将展示从标注和预处理到训练和推断的整个过程。

LayoutLM 模型

LayoutLM 模型基于 BERT 架构，但增加了两种额外的输入嵌入。第一个是 2-D 位置嵌入，用于表示文档中令牌的相对位置，第二个是用于文档中扫描令牌图像的图像嵌入。该模型在多个下游任务中取得了新的最先进结果，包括表单理解（从 70.72 提升到 79.27）、收据理解（从 94.02 提升到 95.24）和文档图像分类（从 93.07 提升到 94.42）。欲了解更多信息，请参阅原始文章。

幸运的是，该模型已开源并在 huggingface 库中提供。感谢微软！

对于本教程，我们将直接从 huggingface 库中克隆模型，并在我们自己的数据集上进行微调。但首先，我们需要创建训练数据。

发票标注

使用UBIAI 文本注释工具，我已经注释了大约 50 份个人发票。我感兴趣的是提取实体的键和值；例如在以下文本“Date: 06/12/2021”中，我们会将“Date”标注为 DATE_ID，将“06/12/2021”标注为 DATE。提取键和值将帮助我们将数值与其属性关联起来。以下是所有已标注的实体：

DATE_ID, DATE, INVOICE_ID, INVOICE_NUMBER, SELLER_ID, SELLER, MONTANT_HT_ID, MONTANT_HT, TVA_ID, TVA, TTC_ID, TTC

这里有一些实体定义：

MONTANT_HT：税前总价

TTC：含税总价

TVA：税额

以下是使用UBIAI的标注发票示例：

在 UBIAI 中的发票注释

注释完成后，我们直接从 UBIAI 以正确格式导出训练和测试文件，无需任何预处理步骤。导出将包括每个训练和测试数据集的三个文件以及一个名为 labels.txt 的文本文件，包含所有标签：

Train/Test.txt

2018 O
Sous-total O
en O
EUR O
3,20 O
€ O
TVA S-TVA_ID
(0%) O
0,00 € S-TVA
Total B-TTC_ID
en I-TTC_ID
EUR E-TTC_ID
3,20 S-TTC
€ O
Services O
soumis O
au O
mécanisme O
d'autoliquidation O
- O

Train/Test_box.txt（包含每个 token 的边界框）：

€ 912 457 920 466
Services 80 486 133 495
soumis 136 487 182 495
au 185 488 200 495
mécanisme 204 486 276 495
d'autoliquidation 279 486 381 497
- 383 490 388 492

Train/Test_image.txt（包含边界框、文档大小和名称）：

€ 912 425 920 434 1653 2339 image1.jpg
TVA 500 441 526 449 1653 2339 image1.jpg
(0%) 529 441 557 451 1653 2339 image1.jpg
0,00 € 882 441 920 451 1653 2339 image1.jpg
Total 500 457 531 466 1653 2339 image1.jpg
en 534 459 549 466 1653 2339 image1.jpg
EUR 553 457 578 466 1653 2339 image1.jpg
3,20 882 457 911 467 1653 2339 image1.jpg
€ 912 457 920 466 1653 2339 image1.jpg
Services 80 486 133 495 1653 2339 image1.jpg
soumis 136 487 182 495 1653 2339 image1.jpg
au 185 488 200 495 1653 2339 image1.jpg
mécanisme 204 486 276 495 1653 2339 image1.jpg
d'autoliquidation 279 486 381 497 1653 2339 image1.jpg
- 383 490 388 492 1653 2339 image1.jpg

labels.txt：

B-DATE_ID
B-INVOICE_ID
B-INVOICE_NUMBER
B-MONTANT_HT
B-MONTANT_HT_ID
B-SELLER
B-TTC
B-DATE
B-TTC_ID
B-TVA
B-TVA_ID
E-DATE_ID
E-DATE
E-INVOICE_ID
E-INVOICE_NUMBER
E-MONTANT_HT
E-MONTANT_HT_ID
E-SELLER
E-TTC
E-TTC_ID
E-TVA
E-TVA_ID
I-DATE_ID
I-DATE
I-SELLER
I-INVOICE_ID
I-MONTANT_HT_ID
I-TTC
I-TTC_ID
I-TVA_ID
O
S-DATE_ID
S-DATE
S-INVOICE_ID
S-INVOICE_NUMBER
S-MONTANT_HT_ID
S-MONTANT_HT
S-SELLER
S-TTC
S-TTC_ID
S-TVA
S-TVA_ID

微调 LayoutLM 模型：

在这里，我们使用带 GPU 的 google colab 来微调模型。下面的代码基于原始 LayoutLM 论文和本教程。

首先，安装 layoutLM 包……

! rm -r unilm
! git clone -b remove_torch_save https://github.com/NielsRogge/unilm.git
! cd unilm/layoutlm
! pip install unilm/layoutlm

…以及从中下载模型的 transformer 包：

! rm -r transformers
! git clone https://github.com/huggingface/transformers.git
! cd transformers
! pip install ./transformers

接下来，创建一个包含 labels.txt 中唯一标签的列表：

from torch.nn import CrossEntropyLoss
def get_labels(path):
    with open(path, "r") as f:
        labels = f.read().splitlines()
    if "O" not in labels:
        labels = ["O"] + labels
    return labels
labels = get_labels("./labels.txt")
num_labels = len(labels)
label_map = {i: label for i, label in enumerate(labels)}
pad_token_label_id = CrossEntropyLoss().ignore_index

然后，创建一个 pytorch 数据集和数据加载器：

from transformers import LayoutLMTokenizer
from layoutlm.data.funsd import FunsdDataset, InputFeatures
from torch.utils.data import DataLoader, RandomSampler, SequentialSampler
args = {'local_rank': -1,
        'overwrite_cache': True,
        'data_dir': '/content/data',
        'model_name_or_path':'microsoft/layoutlm-base-uncased',
        'max_seq_length': 512,
        'model_type': 'layoutlm',}
# class to turn the keys of a dict into attributes
class AttrDict(dict):
    def __init__(self, *args, **kwargs):
        super(AttrDict, self).__init__(*args, **kwargs)
        self.__dict__ = self
args = AttrDict(args)
tokenizer = LayoutLMTokenizer.from_pretrained("microsoft/layoutlm-base-uncased")
# the LayoutLM authors already defined a specific FunsdDataset, so we are going to use this here
train_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode="train")
train_sampler = RandomSampler(train_dataset)
train_dataloader = DataLoader(train_dataset,
                              sampler=train_sampler,
                              batch_size=2)
eval_dataset = FunsdDataset(args, tokenizer, labels, pad_token_label_id, mode="test")
eval_sampler = SequentialSampler(eval_dataset)
eval_dataloader = DataLoader(eval_dataset,
                             sampler=eval_sampler,
                            batch_size=2)
batch = next(iter(train_dataloader))
input_ids = batch[0][0]
tokenizer.decode(input_ids)

从 huggingface 加载模型。这将根据数据集进行微调。

from transformers import LayoutLMForTokenClassification
import torch
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = LayoutLMForTokenClassification.from_pretrained("microsoft/layoutlm-base-uncased", num_labels=num_labels)
model.to(device)

最后，开始训练：

rom transformers import AdamW
from tqdm import tqdm
optimizer = AdamW(model.parameters(), lr=5e-5)
global_step = 0
num_train_epochs = 50
t_total = len(train_dataloader) * num_train_epochs # total number of training steps
#put the model in training mode
model.train()
for epoch in range(num_train_epochs):
  for batch in tqdm(train_dataloader, desc="Training"):
      input_ids = batch[0].to(device)
      bbox = batch[4].to(device)
      attention_mask = batch[1].to(device)
      token_type_ids = batch[2].to(device)
      labels = batch[3].to(device)
# forward pass
      outputs = model(input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids,
                      labels=labels)
      loss = outputs.loss
# print loss every 100 steps
      if global_step % 100 == 0:
        print(f"Loss after {global_step} steps: {loss.item()}")
# backward pass to get the gradients 
      loss.backward()
#print("Gradients on classification head:")
      #print(model.classifier.weight.grad[6,:].sum())
# update
      optimizer.step()
      optimizer.zero_grad()
      global_step += 1

你应该能看到训练进度和损失的实时更新。

Layout LM 训练中

训练后，使用以下函数评估模型性能：

mport numpy as np
from seqeval.metrics import (
    classification_report,
    f1_score,
    precision_score,
    recall_score,
)
eval_loss = 0.0
nb_eval_steps = 0
preds = None
out_label_ids = None
# put model in evaluation mode
model.eval()
for batch in tqdm(eval_dataloader, desc="Evaluating"):
    with torch.no_grad():
        input_ids = batch[0].to(device)
        bbox = batch[4].to(device)
        attention_mask = batch[1].to(device)
        token_type_ids = batch[2].to(device)
        labels = batch[3].to(device)
# forward pass
        outputs = model(input_ids=input_ids, bbox=bbox, attention_mask=attention_mask, token_type_ids=token_type_ids,
                        labels=labels)
        # get the loss and logits
        tmp_eval_loss = outputs.loss
        logits = outputs.logits
eval_loss += tmp_eval_loss.item()
        nb_eval_steps += 1
# compute the predictions
        if preds is None:
            preds = logits.detach().cpu().numpy()
            out_label_ids = labels.detach().cpu().numpy()
        else:
            preds = np.append(preds, logits.detach().cpu().numpy(), axis=0)
            out_label_ids = np.append(
                out_label_ids, labels.detach().cpu().numpy(), axis=0
            )
# compute average evaluation loss
eval_loss = eval_loss / nb_eval_steps
preds = np.argmax(preds, axis=2)
out_label_list = [[] for _ in range(out_label_ids.shape[0])]
preds_list = [[] for _ in range(out_label_ids.shape[0])]
for i in range(out_label_ids.shape[0]):
    for j in range(out_label_ids.shape[1]):
        if out_label_ids[i, j] != pad_token_label_id:
            out_label_list[i].append(label_map[out_label_ids[i][j]])
            preds_list[i].append(label_map[preds[i][j]])
results = {
    "loss": eval_loss,
    "precision": precision_score(out_label_list, preds_list),
    "recall": recall_score(out_label_list, preds_list),
    "f1": f1_score(out_label_list, preds_list),
}

仅使用 50 份文档，我们获得了以下分数：

训练后的评估得分

通过更多的注释，我们肯定能获得更高的分数。

最后，保存模型以备将来预测：

PATH='./drive/MyDrive/trained_layoutlm/layoutlm_UBIAI.pt'
torch.save(model.state_dict(), PATH)

推断：

现在进入有趣的部分，我们来上传发票，进行 OCR 处理，并提取相关实体。此次测试使用的发票不在训练集或测试集中。为了从发票中解析文本，我们使用开源的 Tesseract 包。让我们来安装这个包：

!sudo apt install tesseract-ocr
!pip install pytesseract

在运行预测之前，我们需要从图像中解析文本，并将标记和边界框预处理成特征。为此，我创建了一个预处理的 python 文件 layoutLM_preprocess.py，这将使图像的预处理更容易：

mport sys
sys.path.insert(1, './drive/MyDrive/UBIAI_layoutlm')
from layoutlm_preprocess import *
image_path='./content/invoice_test.jpg'
image, words, boxes, actual_boxes = preprocess(image_path)

接下来，加载模型并获取单词预测及其边界框：

model_path='./drive/MyDrive/trained_layoutlm/layoutlm_UBIAI.pt'
model=model_load(model_path,num_labels)
word_level_predictions, final_boxes=convert_to_features(image, words, boxes, actual_boxes, model)

最后，展示包含预测实体和边界框的图像：

draw = ImageDraw.Draw(image)
font = ImageFont.load_default()
def iob_to_label(label):
  if label != 'O':
    return label[2:]
  else:
    return ""
label2color = {'data_id':'green','date':'green','invoice_id':'blue','invoice_number':'blue','montant_ht_id':'black','montant_ht':'black','seller_id':'red','seller':'red', 'ttc_id':'grey','ttc':'grey','':'violet', 'tva_id':'orange','tva':'orange'}
for prediction, box in zip(word_level_predictions, final_boxes):
    predicted_label = iob_to_label(label_map[prediction]).lower()
    draw.rectangle(box, outline=label2color[predicted_label])
    draw.text((box[0] + 10, box[1] - 10), text=predicted_label, fill=label2color[predicted_label], font=font)

image

如此：

使用 LayoutLM 进行发票实体提取

该模型能够正确提取卖家、发票号、日期和 TTC，但在将 TTC 标签分配给购买的物品时出现了错误。考虑到标注文档数量（仅 50 份）较少，结果令人印象深刻，非常有前景！随着标注发票数量的增加，我们将能够达到更高的 F 分数和更准确的预测。

结论：

总体而言，LayoutLM 模型的结果非常有前景，展示了 transformers 在分析半结构化文本中的实用性。该模型可以在任何其他半结构化文档上进行微调，例如驾驶执照、合同、政府文件、财务文件等。

如果你有任何问题，请在下方提问或通过邮件发送至 admin@ubiai.tools。

如果你喜欢这篇文章，请点赞、喜欢并分享！

简介： Walid Amamou 是 UBIAI 的创始人，UBIAI 是一个用于 NLP 应用的标注工具，并拥有物理学博士学位。

相关：

• 使用 BERT 构建用于职位搜索的知识图谱

• 如何用 spaCy 3 微调 BERT Transformer

• 学习实用 NLP 的最佳方法？

更多相关内容

• RAG 与微调：哪个是提升 LLM 应用的最佳工具？

• 如何从零开始构建和训练 Transformer 模型…

• 图像识别与自然语言处理的迁移学习

• 语音识别指标的演变

• 5 个需求高但未获得足够认可的 IT 职位

• LSTM 的复兴：扩展 LSTM 模型挑战 Transformer 的优势…

使用 HuggingFace 微调 BERT 进行推文分类

原文：www.kdnuggets.com/2022/01/finetuning-bert-tweets-classification-ft-hugging-face.html

双向编码器表示模型（BERT）是由谷歌开发的基于变换器的最先进模型。它可以进行预训练，然后针对特定任务进行微调。我们将在本文中看到微调的实际操作。

我们将对 BERT 进行分类任务的微调。任务是对与 COVID 相关的推文进行情感分类。

在这里，我们使用 HuggingFace 库来微调模型。HuggingFace 使整个过程从文本预处理到训练变得简单。

BERT

BERT 在 BooksCorpus 数据集和英文维基百科上进行了预训练。它在十一项自然语言处理任务上获得了最先进的结果。

BERT 在两个任务上同时进行训练

• 掩蔽语言建模（MLM）——15%的标记被掩蔽，训练以预测掩蔽的单词

• 下一句预测（NSP）——给定两个句子 A 和 B，预测 B 是否跟在 A 后面

BERT 旨在通过在所有层中共同条件化左右上下文，从未标记的文本中预训练深度双向表示。

结果是，预训练的 BERT 模型只需通过一个额外的输出层就可以微调，创建适用于广泛任务的最先进模型，例如问答和语言推理，而无需对任务特定的架构进行 substantial modifications。

数据集

我们使用的是Kaggle上提供的 Coronavirus 推文 NLP——文本分类数据集。

数据集有两个文件：Corona_NLP_test.csv（4 万条记录）和 Corona_NLP_test.csv（4 千条记录）。

这些是训练数据的前五条记录：

如你所见，我们的数据中有 5 个特征：UserName，ScreenName Location，TweetAt，OriginalTweet，Sentiment，但我们只对其中的 2 个感兴趣，即OriginalTweet包含实际推文，Sentiment是我们推文的标签。

这些推文被分为 5 类——‘中性’，‘积极’，‘极端负面’，‘负面’，‘极端积极’。因此，标签的数量是 5。

数据加载与预处理

我们将使用 HuggingFace 库进行这个项目。我们需要安装两个模块：

pip install transformerspip install datasets

• 变换器：HuggingFace 对变换器的实现。我们可以下载各种预训练模型

• 数据集：加载数据集，同时也可以下载 HuggingFace hub 上提供的不同数据集

from datasets import load_dataset

在这里，我们使用来自 datasets 库的load_dataset。load_dataset可以用来从 HuggingFace hub 下载数据集，或者加载我们自定义的数据集。

我们将数据类型指定为 CSV，将文件名作为字典传递给data_files。我们将训练和测试文件加载到数据集变量中。

如果我们打印dataset变量，这里是输出结果：

预处理数据

我们将保持简单，只做两个预处理步骤，即分词和将标签转换为整数。

HuggingFaceAutoTokenizer负责分词部分。我们可以下载与我们模型（即 BERT）对应的分词器。

BERT 分词器会自动将句子转换为 BERT 模型所期望的形式，包括 tokens、numbers 和 attention_masks。

例如：这是一个通过分词器处理的示例句子

>> tokenizer("Attention is all you need")output:
{
'input_ids': [101, 1335, 5208, 2116, 1110, 1155, 1128, 1444, 102], 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0], 
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]
}

现在作为预处理步骤的一部分，我们将执行两个步骤：

• 将情感转换为整数

• 对推文进行分词

我们将使用map函数，它类似于 pandas 数据框的 apply 函数。它将函数作为参数，并应用于整个数据集。

在上述代码中，我们定义了一种将标签转换为整数的方法，并对推文进行了分词，同时删除了不需要的列。

现在我们已经为训练部分做好了准备。

训练

有两种方法来训练数据，我们可以自己编写训练循环，也可以使用 HuggingFace 库中的 trainer。

在这种情况下，我们将使用来自库的 trainer。要使用 trainer，首先需要定义训练参数，例如名称、num_epochs、batch_size 等等。

现在让我们下载 BERT 模型，使用 AutoModelForSequenceClassification 类，非常简单。

下载的分类模型也需要一个num_labels参数，即我们数据中的类别数量。BERT 模型的末尾附加了一个线性层，以使输出等于类别数量。

(classifier): Linear(in_features=768, out_features=5, bias=True)

上述线性层会自动添加为最后一层。由于 BERT 输出大小为 768，我们的数据有 5 个类别，因此添加了一个线性层，in_features=768 和 out_features=5。

在开始训练之前，我们将把训练数据拆分为训练集和评估集。我们有 40k 的训练数据和 1k 的评估数据。

如果我们使用 HuggingFace trainer，则需要导入模块Trainer并传递模型、数据集和训练参数。

就这样，我们现在准备开始训练。我们需要在 trainer 上调用train方法，训练将开始。

trainer.train()

训练将进行 3 个周期，这可以通过训练参数进行调整。

一旦训练完成，我们可以运行trainer.evaluate()来检查准确率，但在此之前，我们需要导入指标。

datasets 库提供了广泛的指标。我们在这里使用准确率。我们的数据通过训练仅 3 个周期获得了 83% 的准确率。

准确性可以通过多训练一段时间或进一步的数据预处理来提高，例如从推文中删除提及和不必要的杂乱，但这些可以留到其他时间再做。

感谢阅读。

• 我的 LinkedIn

• Colab 笔记本

• HuggingFace

Rajan Choudhary 是 Mcafee 的 QA 工程师，拥有 2 年以上的经验。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析水平

3. Google IT 支持专业证书 - 支持你所在组织的 IT

---

更多相关话题

• RAG 与微调：哪种工具最能提升你的 LLM 应用？

• 使用 HuggingFace Pipelines 和 Streamlit 回答问题

• 使用 HuggingFace Transformers 的简单 NLP Pipelines

• 一个简单实现的端到端 HuggingFace 项目

• HuggingFace 推出了免费的深度强化学习课程

• 使用 BERT 分类长文本文档

微调 OpenAI 语言模型使用噪声标签数据

原文：www.kdnuggets.com/2023/04/finetuning-openai-language-models-noisily-labeled-data.html

作者：Chris Mauck, Jonas Mueller

本文展示了数据中心 AI 工具如何改进微调的大型语言模型（LLM；也称为 基础 模型）。这些工具优化数据集本身，而不是改变模型架构/超参数 — 在改进的数据集上运行完全相同的微调代码可以将测试集性能提升 37%，这是在此处研究的礼貌分类任务中实现的。我们通过相同的数据中心 AI 过程，在通过 OpenAI API 进行微调的三种最先进的 LLM 模型中获得了类似的准确度提升：Davinci、Ada 和 Curie。这些模型是支撑 GPT-3/ChatGPT 的基础 LLM 的变体。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业道路。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT

---

上图展示了针对文本的三类礼貌分类测试准确度，这些测试是使用相同的 LLM 微调代码（通过 OpenAI API 适配 Davinci）在三种不同数据集上运行的结果：（1）由人工注释员标记的原始数据集，（2）该数据集的自动筛选版本，我们通过自信学习移除了自动估计为标记错误的样本，（3）原始数据的清理版本，我们手动修正了被估计为标记错误的样本（而不是过滤这些样本）。

背景

标记数据推动了企业中的 AI/ML，但现实世界的数据集已被发现含有 7-50%的标注错误。标注不完美的文本数据阻碍了机器学习模型在意图识别、实体识别和序列生成等任务中的训练（和评估）。虽然预训练的 LLM 拥有大量的世界知识，但其性能受到噪声训练数据的负面影响（正如 OpenAI 所指出的）。在这里，我们展示了数据中心技术，以减轻标签噪声的影响，而无需更改与模型架构、超参数或训练相关的任何代码。因此，这些数据质量改进技术即使对于未来的高级 LLM 如 GPT-10 也应适用。

为什么微调？

LLM 在对互联网上的大部分文本进行预训练后，获得了强大的生成和区分能力。然而，确保 LLM 在特定业务用例中产生可靠输出通常需要在标记了所需输出的实际领域数据上进行额外训练。这种领域特定的训练被称为微调 LLM，可以通过OpenAI 提供的 API进行。数据标注过程中的不完美不可避免地在这种领域特定的训练数据中引入标签错误，这对 LLM 的适当微调和评估构成了挑战。

为什么数据中心的人工智能？

以下是OpenAI 的引用关于他们训练最先进 AI 系统策略的内容：

"由于训练数据塑造了任何学习模型的能力，数据过滤是限制不良模型能力的强大工具。"

"我们优先过滤掉所有不良数据，而不是保留所有良好数据。这是因为我们可以在以后用更多的数据来微调我们的模型以教授它新知识，但让模型忘记它已经学到的东西要困难得多。"

显然，数据集质量是一个至关重要的考虑因素。一些组织如 OpenAI 手动处理数据中的问题，以生成最好的模型，但这需要大量的工作！数据中心人工智能是一门新兴的算法科学，旨在检测数据问题，因此你可以通过自动化更轻松地系统性改进你的数据集。

在这些实验中，我们的 LLM 是 OpenAI 的 Davinci 模型，这是他们最强大的 GPT-3 模型，ChatGPT 基于此模型。

概述

在这里，我们考虑了斯坦福礼貌数据集的一个三类变体，其中的文本短语被标记为：不礼貌、中性或礼貌。这些标签由人工评分员标注，其中一些标签的质量自然较低。

本文介绍以下步骤：

• 使用原始数据通过 OpenAI API 微调不同的最先进 LLM：Davinci、Ada 和 Curie。

• 在具有高质量标签的测试集上建立每个微调模型的基线准确率（通过共识和多位人工标注者对每个测试样本的高一致性确定）。

• 使用 Confident Learning 算法自动识别数百个标签错误的样本。

• 从数据集中删除自动标记的标签问题数据，然后在自动筛选的数据集上微调完全相同的 LLM。这个简单的步骤将 Davinci 模型预测的错误减少 8%!

• 引入一种无代码解决方案，以高效修正数据集中标签错误，然后在修正后的数据集上微调完全相同的 LLM。这将 Davinci 模型预测的错误减少 37%!

通过这些相同的过程，Ada 和 Curie 模型也取得了类似的改进——在所有情况下，模型和微调代码都没有改变！

这里有一个notebook，你可以运行它以重现本文中演示的结果，并理解实现每一步的代码。

礼貌数据集

你可以在这里下载训练集和测试集：train test

我们的训练数据集有 1916 个样本，每个样本由一个人工标注者标记，因此其中一些可能不可靠。测试数据集有 480 个样本，每个样本由五位标注者标记，我们使用他们的共识标签作为对真实礼貌的高质量近似（将测试准确率与这些共识标签进行比较）。为了确保公平比较，该测试数据集在实验过程中保持不变（所有标签清理/数据集修改仅在训练集中进行）。我们将这些 CSV 文件重新格式化为 OpenAI 微调 API 所需的 jsonl 文件类型。

微调并评估 LLM

这是我们如何微调 Davinci LLM 以进行 3 类分类并评估其测试准确率的代码示例：

!openai api fine_tunes.create -t "train_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci 
--suffix "baseline"

>>> Created fine-tune: ft-9800F2gcVNzyMdTLKcMqAtJ5

一旦任务完成，我们查询 fine_tunes.results 端点，以查看在原始训练数据集上微调该 LLM 时所达到的测试准确率。

!openai api fine_tunes.results -i ft-9800F2gcVNzyMdTLKcMqAtJ5 > baseline.csv

df = pd.read_csv('baseline.csv')
baseline_acc = df.iloc[-1]['classification/accuracy']

>>> Fine-tuning Accuracy: 0.6312500238418579

我们的基线 Davinci LLM 在使用可能有噪声标签的原始训练数据进行微调时，测试准确率为 63%。即使是最先进的 LLM，如 Davinci 模型，对于这个分类任务的表现也平平，是因为数据标签存在噪声吗？

自动查找标签问题

Confident Learning 是一种最近开发的算法套件，用于估计分类数据集中哪些数据被错误标记。这些算法需要样本外预测的类别概率，并应用一种新颖的校准形式，以确定何时信任模型而不是数据中的给定标签。

为了获得这些预测概率，我们：

1. 使用 OpenAI API 从 Davinci 模型中计算所有训练样本的嵌入。你可以在这里下载嵌入。

2. 在原始数据的嵌入和标签上拟合一个逻辑回归模型。我们使用 10 倍交叉验证，这使我们能够为训练数据集中的每个样本生成样本外预测的类别概率。

# Get embeddings from OpenAI.
from openai.embeddings_utils import get_embedding

embedding_model = "text-similarity-davinci-001"
train["embedding"] = train.prompt.apply(lambda x: get_embedding(x, engine=embedding_model))
embeddings = train["embedding"].values

# Get out-of-sample predicted class probabilities via cross-validation.
from sklearn.linear_model import LogisticRegression

model = LogisticRegression()
labels = train["completion"].values
pred_probs = cross_val_predict(estimator=model, X=embeddings, y=labels, 		                   cv=10, method="predict_proba")

cleanlab 包提供了 Confident Learning 的开源 Python 实现。只需一行代码，我们就可以使用模型预测概率运行 Confident Learning，以估计训练数据集中哪些样本存在标签问题。

from cleanlab.filter import find_label_issues

# Get indices of examples estimated to have label issues:
issue_idx = find_label_issues(labels, pred_probs,
            return_indices_ranked_by='self_confidence')  # sort indices by likelihood of label error 

让我们查看一下数据集中自动识别的一些标签问题。这是一个明显错误标记的例子：

• 短语：我有时间时会查看 getLogEntries。你介意把我加为提交者吗？

• 标签：不礼貌

像这样的标签错误可能是我们看到模型结果不佳的原因。

说明：自动识别的一些主要错误。

注意： find_label_issues 能够仅根据样本外 pred_probs 确定哪些给定的 标签 可能是错误的。

过滤标签问题并微调更强健的 LLM

现在我们有了潜在错误标记样本的索引（通过自动技术识别），让我们从训练数据集中移除这 471 个样本。在过滤后的数据集上微调完全相同的 Davinci LLM 实现了 66% 的测试准确率（在我们原始的 Davinci LLM 达到 63% 准确率的同一测试数据上）。我们通过使用 更少 但 更高质量 的训练数据将模型的错误率降低了 8%！

# Remove data flagged with potential label error. 
train_cl = train.drop(issue_idx).reset_index(drop=True)
format_data(train_cl, "train_cl.jsonl")

# Train a more robust classifier with less erroneous data.
!openai api fine_tunes.create -t "train_cl_prepared.jsonl" -v "test_prepared.jsonl" --compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "dropped"

# Evaluate model on test data.
!openai api fine_tunes.results -i ft-InhTRQGu11gIDlVJUt0LYbEx > autofiltered.csv
df = pd.read_csv('autofiltered.csv')
dropped_acc = df.iloc[-1]['classification/accuracy']

>>> 0.6604166626930237

修正标签错误

与其通过过滤自动修正自动检测到的标签问题，更聪明（但更复杂）的方法是手动修正标签问题。这同时移除一个噪声数据点并添加一个准确的数据点，但手动进行这些修正是繁琐的。我们使用 Cleanlab Studio 这一企业数据修正界面来手动完成此操作。

在用更合适的标签替换了我们发现的坏标签后，我们在手动修正的数据集上对完全相同的 Davinci LLM 进行了微调。得到的模型在相同的测试数据集上达到了 77% 的准确率，这比我们原始版本的模型减少了 37% 的错误。

# Load in and format data with the manually fixed labels.
train_studio = pd.read_csv('train_corrected.csv')
format_data(train_studio, "train_corrected.jsonl")

# Train a more robust classifier with the fixed data.
!openai api fine_tunes.create -t "train_corrected_prepared.jsonl" -v "test_prepared.jsonl" 
--compute_classification_metrics --classification_n_classes 3 -m davinci --suffix "corrected"

# Evaluate model on test data.
!openai api fine_tunes.results -i ft-MQbaduYd8UGD2EWBmfpoQpkQ > corrected .csv
df = pd.read_csv('corrected.csv')
corrected_acc = df.iloc[-1]['classification/accuracy']
>>> 0.7729166746139526

注意：在整个过程中，我们从未更改任何与模型架构/超参数、训练或数据预处理相关的代码！ 所有改进严格来源于提高训练数据的质量，这为模型方面的额外优化留下了空间。

评估其他 LLM

我们对 OpenAI 提供的另外两个最近的 LLM 模型 Ada 和 Curie 进行了相同的实验。得到的改进结果看起来与 Davinci 模型取得的类似。

结论

数据中心的 AI 是处理噪声数据的强大范式，通过 AI/自动化技术而不是繁琐的手动工作。现在有工具可以帮助你高效地发现和修复数据及标签问题，从而改进任何机器学习模型（不仅仅是 LLM），适用于大多数类型的数据（不仅仅是文本，还有图像、音频、表格数据等）。这些工具利用任何机器学习模型来诊断/修复数据中的问题，然后改进数据以适用于其他机器学习模型。这些工具将随着未来机器学习模型如 GPT-10 的进步而持续适用，并且在与更准确的模型一起使用时，将更好地识别问题！

实践数据中心 AI 以通过 AI/自动化系统地优化数据。这使你可以利用你独特的领域知识，而不是修复一般数据问题，如标签错误。

Chris Mauck 是 Cleanlab 的数据科学家。

更多相关话题

• RAG 与微调：哪个是提升您的 LLM 应用程序的最佳工具？

• 使用 OpenAI 构建 AI 产品：CoRise 的免费课程

• OpenAI 介绍 Superalignment

• 使用 OpenAI GPT 模型的最佳实践

• OpenAI API 初学者指南：您的易于遵循的入门指南

• 使用 Python 探索 OpenAI API

机器学习资源的全面列表：开放课程、教科书、教程、备忘单等

原文：www.kdnuggets.com/2018/12/finlayson-machine-learning-resources.html

评论

由Sam Finlayson，哈佛-麻省理工学院医学博士生。

原文。经许可转载。

以下是原始内容的快照，会随着时间的推移而更新

这是一个不特别系统的尝试，旨在整理我最喜欢的统计学和机器学习资源。这并不是全面的，实际上还缺少我最喜欢的大多数解释资源。相反，这只是一些我多次使用的资源，希望能够集中在一个地方。组织方式如下：

• 开放课程和教科书：涵盖一个相当broad的主题，通常比较全面，需要几周到几个月的时间从头到尾完成。

• 教程、概述和（单独）讲义：对一个specific的主题解释得非常清楚，通常需要几分钟到几小时（或最多几天）完成。

• 备忘单：提供结构化的信息，通常能在几秒钟内访问。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

最后，我添加了一个部分，包含了a 些杂项网站的链接，这些网站通常会产生优秀的内容。

上述内容中，第二部分既最不完整，也是我最兴奋的部分。我希望用它来捕捉我在网上阅读过的难题最佳解释，以便在我不可避免地忘记时，能更容易地重新学习。（在理想的世界里，Chris Olah和/或distill.pub会为一切写文章，但在此期间，我必须从其他地方收集零碎的资料。）

如果你发现了这个列表并有建议让我添加（特别是中间部分！），请随时联系我！但我只打算发布我已经阅读过的内容，因此它可能会在我的待读列表中待一段时间才会出现在这里。当然，这个网页的来源是在 github 上，所以你也可以直接获取它。 |

开放课程和教科书

我试图将此列表限制为那些可以在线合法免费访问的内容。

基础

文件	描述
机器学习数学书	Faisal 和 Ong 的机器学习数学书，available on github。
Boyd 应用线性代数	Boyd 和 Vandenberghe 的应用线性代数免费书籍（网站）。
Fast.ai 计算线性代数	Rachel Thomas 整理了这本关于计算线性代数的优秀在线教科书，并附有YouTube 视频。
MIT 6.041 Intro Probability	John Tsitsiklis 等人整理了一些很棒的资源。他们经典的 MIT 概率入门课程已在OCW上归档，并且也在 edX 上提供（第一部分、第二部分）。教科书也非常优秀。
Joe Blitzstein 的 Stat110	Joe Blitzstein 的本科概率课程与 6.041 的内容高度重叠。像 6.041 一样，它也有很棒的教科书、youtube视频和edx课程。它也稍微更有趣一点。
MathematicalMonk	这个家伙真棒。有大约 250 个关于机器学习、概率和信息理论的 YouTube 教程。这些播放列表的优点在于任何单独的视频都可以进入第二部分！
Tim Roughgarden 的算法讲义和算法照亮	Tim Roughgarden 是我见过的最自然的老师之一，幸运的是，他决定将大量算法资源公开。第一个链接是来自许多课程的 PDF 讲义 – 对于数据导向的学习者，他的 CS 168 课程既易于访问又非常棒。他的算法 2 课程（CS 261）的录像可以在这里找到（pdf 讲义在第一个链接中）。第二个链接是他新教材的页面，但该页面还链接到他 Coursera 版 CS 161（算法 1）的所有 YouTube 视频。

统计学

文件	描述
观察理论	这是一本在线视觉教材，提供了一些很酷的互动展示，用于介绍概率/统计概念。我最喜欢的是推断可视化。
拉塞尔·波德拉克（Russell Poldracks）的21 世纪统计思维	这似乎是一本相当出色（虽然相当基础）的教材，适用于一个季度的统计学入门课程（斯坦福的统计 60）。尽管假设较少，但涉及了很多精彩的主题。
现代生物学统计学	这本在线教材由苏珊·霍尔姆斯（Susan Holmes）和沃尔夫冈·休伯（Wolfgang Huber）编写，提供了对现代数据科学中与计算生物学家相关部分的一个简明易懂的介绍。它也恰好是一个排版的艺术品，由bookdown创建。
统计重思	讲座录像在youtube上与这本评价很高的入门教材配套。
赫尔南和罗宾斯的因果推断书	这本关于因果推断的长期待出版教材（从流行病学的角度），草稿在网页上频繁更新。

经典机器学习

文件	描述
比 ishop 的模式识别与机器学习	这是一本经典的机器学习教材，现在终于在网上（合法）免费发布。
CS 229 讲义	安德鲁·吴（Andrew Ng）的经典讲义，来自他令人惊叹的研究生级别机器学习入门课程：CS229。
ESL 和 ISL 来自 Hastie 等人	从世界级统计学教授那里获得的经典机器学习入门（ISL）和高级（ESL）讲解。关于 ISL 的幻灯片和视频可以在 这里 获取。
CS 228 PGM 笔记	来自斯坦福大学的优秀概率图模型课程笔记。PDF 导出效果不佳，因此仅提供网站链接。
Blei Foundations of Graphical Models Course	2016 年 David Blei 提供的图形模型基础课程笔记。

深度学习

文件	描述
Roger Grosse 的 CSC231 笔记	来自 Roger Grosse 的 CSC 231 完整网站在这里。可能是我从任何大学找到的最佳深度学习入门课程。笔记和幻灯片都非常出色。
Fast.Ai	Jeremy Howard 和 Rachel Thomas 的精彩入门讲座和笔记。此外，Hiromi Suenaga 发布了整个系列的优秀且独立的笔记，并提供了指向视频的时间戳链接：FastAI DL Part 1、FastAI DL Part 2 和 FastAI ML。
CS231N 视觉深度学习	Andrej Karpathy 的惊人笔记，讲座也在 YouTube 上。
CS224 深度学习在 NLP 中 2017	来自斯坦福大学 CS224 的深度学习在 NLP 中的精彩课程笔记。GitHub 仓库 这里
CMU CS 11-747	来自 CMU 的 Graham Neubig 提供的深度学习在 NLP 中的精彩课程。在 YouTube 上有很棒的讲座视频 这里
深度学习书籍	Ian Goodfellow、Yoshua Bengio 和 Aaron Courville 的这本教科书可能是我们最接近深度学习标准教科书的资料。

强化学习

文件	描述
Sutton 和 Barto 开放 RL 书	实际上是 RL 的标准入门书籍，尽管教科书现在才即将出版！
伯克利深度强化学习	伯克利大学的 RL 课程，由该领域的顶级专家讲授，讲座已上传到 YouTube。

优化

文件	描述
Boyd 凸优化书籍	Boyd 和 Vandenberghe 合著的著名且免费提供的教科书，附有幻灯片和 YouTube 视频。更高级的后续课程在这里
NYU 基于优化的数据分析 2016 和 2017	NYU 2016 网站 和 2017 网站 上关于基于优化的数据分析的极佳课程笔记。

教程、概述和（个人）讲义

这一部分充其量也只是初步的，但这是我制作此页面的真正动机。包括基本上任何在 distill.pub 上的内容、好的博客或中等帖子等。深度学习在这里似乎是一个很好的切入点，但我还没有做更多的深入研究。

基础知识

文件	描述
CS 229 线性代数笔记	来自斯坦福大学机器学习课程的线性代数参考资料。
深度学习的矩阵微积分 (pdf 版本在此)	Parr/Howard 提供的深度学习矩阵微积分的非常好的概述。可以在arxiv上引用。

概率与统计

文件	描述
Seeing Theory 频率推断	这是对频率推断基本思想的非常美丽的视觉展示，来自 Seeing Theory 教科书。我非常喜欢它。
Hernan 选择偏倚	Hernan 等人通过 DAG 对选择偏倚的很好的总结。

经典机器学习/数据科学 NOS

文件	描述
Roughgarden SVD 讲义	来自Tim Roughgarden 的 CS168 课程在斯坦福大学对 SVD 的非常精彩的展示。
Roughgarden PCA 讲义	来自Tim Roughgarden 的 CS168 课程在斯坦福大学对 PCA 的非常精彩的展示。

贝叶斯机器学习

文件	描述
Blei 指数分布/变分推断	我特别喜欢的 Blei 的2011 概率建模课程的一些课程笔记。
Blei 变分推断综述	David Blei 提供的变分推断概述，可在arxiv上找到

深度学习

文件	描述
对抗样本/鲁棒 ML 第一部分, 第二部分, 和 第三部分	Madry 实验室是鲁棒深度学习研究领域的顶尖研究小组之一。他们在博客上整理了对这些主题的极佳介绍。希望他们能继续发布…
Distill 注意力机制	对注意力机制及其（早期）变体的惊人清晰的展示
Distill 构建可解释性	我见过的最酷的神经网络内部可视化
Distill 特征可视化	一贯的主题：如果只有 distill.pub，就读它。
Chris Olah 理解 LSTMs	Chris Olah 是他的领域的专家，这里提供了 LSTMs 和 GRUs 的极佳概述。
联邦学习简介	Andrew Trask 等人提供的联邦学习和 PySyft 简介，使用 PyTorch。

自然语言处理

文件	描述
Chris Olah 关于词嵌入	Chris Olah 解释词嵌入及相关内容。
注释版 Transformer	哈佛的 Sasha Rush 创建了“Attention is All You Need”的逐行注释，也作为一个工作笔记本。教育上的卓越，能够每年为几篇论文做这样的工作将会非常棒。
Goldberg 的 NLP 神经网络入门	Yoav Goldberg 提供的深度学习在 NLP 中的概述，下载链接。
Neubig 的 NLP 神经网络教程	Graham Neubig 提供的深度学习在 NLP 中的概述。下载链接，并与他的课程和视频很好地配对。

强化学习

文件	描述
Karpathy 的像素 Pong	Andrej Karpathy 在教学方面有真正的天赋。这是一个自足的深度强化学习解释，足以理解一个基础的 Atari 代理。
Weng 对强化学习的深入了解	一篇很好的博客文章，涵盖了强化学习的基础知识
OpenAI 的强化学习简介	OpenAI 新的“深度强化学习入门”网站的入门教程

信息论

文件	描述
Chris Olah 视觉信息理论	一如既往，Chris Olah 提供了一个在文字和图像方面都很出色的演示。目的是可视化信息理论的关键概念。
基于最大熵原理推导概率分布	这感觉有点自我宣传，但我写这篇文章是为了更好地理解如何利用信息论从基本原理推导常见的概率分布。
推导多变量高斯分布的信息熵	另一篇我写的博客文章，旨在尝试理解信息论和统计学。

优化

文件	描述
Ruder 梯度下降概述 (PDF 在这里)	梯度下降算法的优秀概述。
Bottou 大规模优化	Bottou、Curtis 和 Nocedal 的优化笔记。下载自arxiv。

速查表

数学

文件	描述
概率速查表	概率速查表，来自威廉·陈的github
CS 229 TA 速查表 2018	2018 年斯坦福机器学习课程的 TA 速查表，Github 仓库在这里。
CS 理论速查表	CS 理论速查表，最初访问这里

编程

文件	描述
R dplyr 速查表	Hadley 的出色数据处理包 dplyr 的速查表。来自RStudio
R ggplot2 速查表	Hadley 的出色绘图包 ggplot2 的速查表。来自RStudio
SQL 连接备忘单	经典 SQL 连接的图形描述以及示例代码。
Python pandas 备忘单	Python 数据处理包 pandas 的备忘单。下载自 这里。
Python numpy 备忘单	Python 数值包 numpy 的备忘单。下载自 Datacamp。
Python keras 备忘单	Python 神经网络包 keras 的备忘单。下载自 Datacamp。
Python scikit-learn 备忘单	Python 机器学习包 scikit-learn 的备忘单。下载自 Datacamp。
Python seaborn 教程	Python 绘图系统 seaborn 的教程。尚未找到很棒的 matplotlib 教程。
图形设计备忘单	可爱的小图形设计备忘单，下载自 这里。

杂项网站

文件	描述
Chris Olah 的博客	这里的内容几乎都是珍贵的。我非常感激他在这些帖子上投入的时间。
distill.pub	Distill 在超级博客和研究期刊之间导航，填补了一个非常有趣的空白。希望我们能有更多这样的出版物。
Pytorch 教程	Pytorch 开发者发布的教程非常棒。很容易理解为什么社区在快速增长。
Sebastian Ruder 的博客	Sebastian 提供了很多非常好的解释，比如我上面链接的关于梯度下降方法的解释。他还维护了一个 跟踪 NLP 基准进展的网站。
ShortScience	这个网站包含机器学习、计算机科学和生物学论文的公共总结/讨论。
伯克利人工智能研究（BAIR）博客	BAIR 产生了大量优秀的研究，并利用这个博客发布其论文的更易懂的展示。
Off the Convex Path	机器学习和优化的优质博客。
Ferenc Huszár 的博客	相当受欢迎的博客，包含了很多对机器学习的探讨和思考，作者有着严谨的数学视角。
Thibaut Lienart 的博客	这个网站有一些关于数学和优化的笔记，看起来很有趣。

简介：Sam Finlayson 是哈佛/麻省理工学院的 MD-PhD 学生，目前从事医学中的机器学习工作。

资源：

• 在线和基于网络的：分析、数据挖掘、数据科学、机器学习教育

• 用于分析、数据科学、数据挖掘和机器学习的软件

相关：

• 深度学习性能备忘单

• 深度学习备忘单

• 机器学习备忘单

更多相关话题

• 掌握大型语言模型的全面资源列表

• 教科书就是你所需的一切：一种革命性的 AI 培训方法

• 最全面的 Kaggle 解决方案和创意列表

• 如何入门 SQL - 免费学习资源列表

• 7 个超级备忘单，你需要掌握机器学习面试

• KDnuggets™ 新闻 22:n06，2 月 9 日：数据科学编程…

2023 年上半年：数据科学和人工智能发展

原文：www.kdnuggets.com/2023/07/first-half-2023-data-science-ai-developments.html

图片来源：塔拉·温斯特德

2023 年上半年发生了很多事情。数据科学和人工智能领域有了显著进展。进展如此之快，以至于我们很难跟上。我们可以肯定地说，2023 年上半年显示了我们未曾预料到的快速进步。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 需求

---

所以，与其谈论我们如何被这些创新所吸引，不如直接讨论它们。

自然语言处理

我将从最显而易见的开始。自然语言处理（NLP）。这是一个在黑暗中逐步建立的领域，并在 2023 年变得炙手可热。

这些进展在 OpenAI 的 ChatGPT 中得到了验证，它引起了世界的轰动。自今年初正式发布以来，ChatGPT 从 GPT-4 发展到现在我们期待的 GPT-5。它们发布了插件，以改善人们的日常生活，并优化 data scientists 和机器学习工程师的工作流程。

我们都知道，在 ChatGPT 发布之后，谷歌发布了 Bard AI，它在个人、企业等领域取得了成功。Bard AI 与 ChatGPT 竞争最佳聊天机器人位置，提供类似的服务，如提升机器学习工程师的工作。

在这些聊天机器人发布的过程中，我们看到大型语言模型（LLM）突然出现。大型模型系统组织（LMSYS Org）是由加州大学伯克利分校的学生和教职工创立的一个开放研究组织，创建了 ChatBot Arena——一个 LLM 基准测试平台，旨在通过开放数据集、模型、系统和评估工具的共同开发，使模型对每个人都更加可及。

AutoML

现在人们已经习惯了聊天机器人为他们回答问题，使他们的工作和个人生活变得更加轻松——那么数据分析师和机器学习专家呢？

他们一直在使用 AutoML——这是一个强大的工具，专为数据科学家和机器学习工程师等数据专业人士设计，用于自动化数据预处理、超参数调优，并执行诸如特征工程等复杂任务。随着数据科学和 AI 的进步，自然我们看到了对数据和 AI 专家的高需求。然而，由于进展速度迅猛，我们也看到这些 AI 专业人士的短缺。因此，找到方法以自动化的方式探索、分析和预测数据，将提高许多公司的成功率。

它不仅能为数据专家节省时间，还能让组织有更多时间去扩展和在其他任务上进行更多创新。

生成式 AI

如果你见证了聊天机器人的爆发，你会看到“生成式 AI”这个词汇不断被提及。生成式 AI 能够根据用户提示生成文本、图像或其他形式的媒体。就像上述进展一样，生成式 AI 正在帮助各行各业完成任务，使他们的生活更轻松。

生成式 AI 能够生成新内容，替代重复任务，处理定制数据，并几乎生成你想要的任何东西。如果你对生成式 AI 还不熟悉，你会想了解 Stable Diffusion——这是生成式 AI 的基础。如果你是数据科学家或数据分析师，你可能听说过 PandasAI——这是一种生成式 AI Python 库，如果没有，它是一个开源工具包，将生成式 AI 功能集成到 Pandas 中，以简化数据分析。

但随着这些生成式 AI 工具和软件的发布，在生成式 AI 时代，数据科学家是否仍然需要？

深度学习

深度学习继续蓬勃发展。随着数据科学和人工智能的最新进展，越来越多的时间和精力被投入到行业研究中。作为机器学习的一个子集，涉及算法和人工神经网络，它在图像分类、物体检测和面部识别等任务中得到广泛应用。

随着我们经历第四次工业革命，深度学习算法正在让我们像人类一样从数据中学习。我们看到越来越多的自动驾驶汽车上路，欺诈检测工具、虚拟助手、医疗预测建模等也在不断增加。

2023 年已经证明了深度学习在自动化过程、机器人技术、区块链和各种其他技术中的应用。

边缘计算

看到这些变化，你可能会觉得这些计算机相当疲惫吧？为了适应人工智能和数据科学的进步，公司需要能够支持这些进步的计算机和系统。边缘计算将计算和数据存储更接近数据源。在使用这些先进模型时，边缘计算提供了实时数据处理，并允许所有设备之间的顺畅通信。

例如，当大型语言模型每两秒发布一次时，很明显，组织需要像边缘计算这样的有效系统才能成功。谷歌今年发布了 TPU v4——这些计算资源能够满足机器学习和人工智能的高计算需求。

由于这些进展，我们看到越来越多的组织从云计算转向边缘计算，以适应当前和未来的需求。

伦理人工智能和数据科学

发生了很多事情，而且在短时间内发生的。对于像政府这样的组织来说，跟上这些变化变得非常困难。来自世界各地的政府都在提出‘这些人工智能应用如何影响经济和社会，意味着什么？’的问题。

人们对这些人工智能和数据科学应用的偏见和歧视、隐私、透明度和安全性感到担忧。那么，人工智能和数据科学的伦理方面是什么，我们应该对未来有怎样的期待？

我们已经有了欧洲人工智能法案推动一个将人工智能系统分为四个风险领域的框架。OpenAI 的首席执行官萨姆·奥特曼作证了对新技术的担忧和可能的陷阱，在 6 月 16 日的美国参议院委员会上。尽管短时间内发生了许多进展，但仍有很多人感到担忧。在接下来的 6 个月里，我们可以期待更多法律的通过以及相关法规和框架的建立。

总结

如果你在过去 6 个月没有跟进人工智能和数据科学，希望这篇文章为你提供了对最近发生的事件的快速概述。接下来 6 个月，这些进展如何被采纳，同时确保这些技术的负责任和道德使用，将会很有趣。

Nisha Arya 是一位数据科学家、自由职业技术作家以及 KDnuggets 的社区经理。她特别感兴趣于提供数据科学职业建议或教程以及数据科学的理论知识。她还希望探索人工智能在延续人类寿命方面的不同益处。她是一位热衷学习者，寻求拓宽自己的技术知识和写作技能，同时帮助指导他人。

更多相关主题

• 人工智能、分析、机器学习、数据科学、深度学习…

• 2021 年数据科学与分析行业主要发展及关键…

• 2021 年的主要发展和 2022 年的关键趋势：人工智能、数据科学…

• 2022 年数据科学、机器学习、人工智能和分析的关键发展

• 使用 TensorFlow 和 Keras 构建和训练你的第一个神经网络

• 2023 年你必须阅读的 5 本免费数据科学书籍

如何在没有任何工作经验的情况下获得你的第一份数据科学工作

原文：www.kdnuggets.com/2021/02/first-job-data-science-without-work-experience.html

无论你是新毕业的学生，正在寻求职业转变的人，还是像上面那只猫一样，数据科学领域都充满了几乎满足现代员工所有要求的工作。 从事数据科学工作为你提供了工作保障、高薪和晋升空间，还可以让你在全球任何地方工作。 基本上，对于那些感兴趣的人来说，数据科学工作是不容错过的选择。

然而，在令人畏惧的求职过程中，我们中的许多人会遇到类似这样的情况：

图片来源于 9GAG

是的，这看起来非常熟悉。

我自己也遇到过很多情况，公司常常要求 22 岁之前拥有 20 年的工作经验，我理解当你是新毕业生、寻求职业转变的人，甚至是一只猫时，找工作时的挫折感。

但这并不意味着你应该灰心丧气。虽然许多数据科学职位需要工作经验，但仍有很多方法可以创造自己的工作经验，使你成为这些职业的合格候选人。

你所需要的只是一点创造力、坚韧和毅力。

这不仅仅是关于你知道什么，而是关于你认识谁和谁认识你。

在类似加拿大的国家，拥有某种形式的大学学历已成为常态（2016 年，54%的加拿大人年龄在 25 到 64 岁之间拥有大学或学院认证），现在不再是关于你知道什么了。相反，是关于你认识谁和谁认识你。

谷歌一下“人脉的重要性”，你会看到所有主要玩家（《福布斯》，《赫芬顿邮报》，《Indeed》等）关于为什么人脉是你职业生涯中最重要的事情之一的文章。 《福布斯》说得最好：

“人脉不仅仅是信息交换的过程，还能作为建立长期互惠关系的途径。” — 比安卡·米勒·科尔，福布斯

虽然建立人脉是获得如何在特定职业中取得成功的内部知识的绝佳方式，但它也可以作为一种互惠的关系，在未来的发展中发挥作用。

我通过与一位大学同学保持联系获得了第一份技术工作。我们因被分到一起进行为期四个月的实习而相识。毕业后，我们保持了联系。快两年后，我收到了一条消息，说他们工作的公司有意聘请我做一些工作。感谢保持这段关系，我在没有工作经验的情况下，通过同事的推荐成功获得了毕业后的第一份工作。

换句话说，在大学期间结识一些人、参加社交活动并实际与那里的人交谈，以及让自己被招聘人员知道是很重要的。

成为一名作家并贡献于个人博客或主要出版物

数据科学家天生是讲故事的高手，他们能够将庞大的数据集转化为引人入胜的可视化图表，以讲述故事给大众。因此，雄心勃勃的数据科学家应该写作以展示他们的沟通能力，这也是非常合乎逻辑的。

许多数据科学家都宣传了创建博客或在像 Medium 这样的平台上写作的好处。尽管许多人这样说，但写作的好处不仅仅是让你成为一个更快乐、更少压力的人——写作还会帮助你的数据科学职业。

正如我之前提到的，讲故事和全面的沟通能力是数据科学家的基本技能，这些技能在实践中会不断提高。例如，通过向公众解释你的数据分析结果，你开始用任何人都能理解和欣赏的简单术语来思考数据。正如理查德·费曼曾说过，“我无法将其简化到大学一年级水平。这意味着我们真的不了解它。” 写作不仅会让你成为更好的沟通者，还会让你对数据科学概念有更深入的理解，从而成为更好的数据科学家。

然而，写作的好处不仅仅是这些。

作为未来的数据科学家，你所写的文章成为你专业档案的一部分，并向招聘人员展示你对特定概念的理解。不仅如此，他们还能看到你能够建立起一群信任和重视你工作的追随者，而且还能看到你愿意贡献知识来推动其他数据科学家的生活和职业。此外，在付费网站上发布作品告诉招聘人员，人们非常重视你的知识，你实际上是因此而获得报酬的。

这里有几个资源可以激励你写作：

为什么数据科学家应该写书，以及我为什么这样做。

知识就在那儿。

数据科学写作的实用建议

一些有用的提示，帮助你开始撰写关于数据科学项目的内容

成为一名自由数据科学家，并建立自己的咨询业务

Marines 说得好：即兴发挥，适应，克服。

不要再与困难作斗争，顺其自然，创办自己的数据科学咨询公司吧。

我知道，当你发了上百份简历却只收到拒信和沉默时，那是多么令人沮丧。所以，如果没有人雇用你，就雇佣自己吧！

自由职业无疑是赚钱时最可怕的事情之一，显然并不是每个人都适合。然而，这是一种公平的替代方式，不必日复一日地在墙上撞头，等待潜在雇主的回应（或者没有回应）。

如果你有技能和自信，为什么不接一些自由职业的客户呢？这是双赢的局面。你可以获得实际经验，而不必经历招聘过程的痛苦（不过要注意，自由职业也可能会有相同的痛苦和折磨，因此并不是每个人都适合）。雇佣自己最大的好处是，如果你最终因为获得了积累的实际经验而得到一个理想公司的工作机会，你可以随时离开自由职业。

谁知道呢？也许你会真的喜欢自由职业生活。在我看来，如果你无法以传统方式找到工作，这个冒险是值得的。

进行自己的项目，以展示你的才能

如果你问我“数据科学”的定义，我会总结为一个专注于解决问题和收集信息的跨学科领域。因此，雇主不愿雇用那些没有解决过问题或无法从数据集中得出结论的人是很有道理的。

通过创建自己的项目，你向雇主展示了数据科学家在工作中成功所需的天生好奇心和动力。不仅如此，许多技术公司要求查看你的项目组合，以便在雇用你之前看到你的工作质量。

现在找到免费数据集来构建项目比以往任何时候都容易。觉得我在开玩笑？上次我查看时，Kaggle 上有 67,862 个数据集可供任何人使用。这真是大量的数据。

此外，快速搜索一下，你会发现成百上千篇文章，提供了各种数据科学项目的灵感。以下是一些可以帮助你入门的项目。

我计划在 2021 年完成的 7 个数据科学项目

我计划如何利用这些项目在年底前提升我的数据科学技能。

12 个圣诞节 12 天数据科学项目

相关且有价值的数据科学项目，你可以在一天之内完成！

12 个适合初学者和专家的数据科学项目创意

“你完成了多少个数据科学项目？”

获取数据科学项目创意指南

如何提出自学、作品集或商业创意。这些创意来自于一个有着过多创意的人。

实习、志愿服务或做无偿工作来获得宝贵的行业经验

有时候，获得必要工作经验的最佳方式就是免费工作。没有人喜欢无偿工作，但在一个通常要求你在 22 岁之前有 20 年工作经验的世界里，免费工作常常是你求职成功的通行证。

实习、志愿服务或做无偿工作，是获得许多公司所寻找的必要工作经验的三种最佳方式。这些“工作”不仅让你能够使用真实世界的数据获得实际经验，而且还向招聘经理展示了你是一个通过艰苦努力获得工作经验的团队合作者。此外，你可能会有机会创造对许多人和社区产生积极影响的有意义的解决方案。如果你所工作的公司愿意在你的 LinkedIn 个人资料上给予你一个极好的评价或推荐信，那就更好了！

最后的思考

对于任何进入新领域的人，无论是刚毕业的学生、寻求职业转变的人，还是学会打字的猫，缺乏工作经验可能都是一个令人畏惧的难题。

然而，只要你愿意接受，外面有大量的机会可以让你获得工作经验。运气往往青睐勇敢者，这对于那些希望在新领域获得成功的人来说尤为真实。

通过稍微发挥一点创造力、毅力和韧性（也许还需要一些耐心），你将很快走上找到那份梦寐以求的数据科学工作的道路。

麦迪逊·亨特 是一名地球科学本科生，软件开发研究生。麦迪逊撰写有关数据科学、环境和 STEM 的随笔。

原文。已获许可转载。

更多相关话题

• NExT-GPT 介绍：任何到任何的多模态大语言模型

• 获得第一个数据科学职位的 7 个步骤

• 5 个免费认证帮助你获得第一个开发者职位

• 在参加任何免费的数据科学课程之前请阅读此文

• SHAP：在 Python 中解释任何机器学习模型

• 在不标记的情况下找到图像中的图片

你已经创建了你的第一个线性回归模型。你验证了这些假设吗？

原文：www.kdnuggets.com/2017/11/first-linear-regression-assumptions.html

评论

由 Sudipto Dasgupta，Flipkart 提供。

随着数据科学时代的到来，学习和应用算法的兴趣增加了，不仅仅是业务分析师或数据科学家，还有一些核心工作可能不是数据处理或模型构建的其他专业人士。如果有人理解这些出色技术的何时、为什么以及如何应用，这无疑是一个好兆头。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

线性回归模型在某些假设下有效，这些假设包括：

1. Y（因变量）和 X（自变量）之间的线性关系。如果你的散点图显示出曲线关系，请记住，高次多项式（2 次及以上）可能更适合建模数据。比较模型、统计数据，并决定哪个模型最好地解释了你的数据。

2. 多重共线性 – 没有多重共线性。为了确保线性回归模型的有效性，VIF（方差膨胀因子）不应过高。多少算过高呢？通常，VIF 为 5 被用作阈值。有些人甚至使用 2.5。你可以自行研究这个问题，但几乎总是 VIF 达到 10 就过高了。高 VIF 表明存在多重共线性，即自变量之间的高相关性。你可以通过移除一个或多个相关的自变量并重新运行模型来测试你的模型。你也可以使用其他降维技术，如 PCA（主成分分析）。

3. 同方差性 – Homo 意为相似，而 scedasticity 意为误差项的分布。因此，同方差性意味着误差项的分布是相似的（即随机的）。如果误差项中存在任何非随机行为，如下图中的残差与拟合图，则模型被认为存在称为异方差性的病症。这也可以通过 ncv 测试等方法检测到。使用 Box-Cox 等方法对变量进行变换，或者尝试完全不同的变量可以解决模型中的这个问题。

4. 残差正态性 - 误差项也称为残差。这是 DV(y) 的观测值与预测值 (ŷ) 之间的差异。误差项是阻碍我们实现完美预测的因素。请记住，在计算标准差时，我们使用 {x-x̄}，而在卡方检验中，我们使用 {观测值-期望值} 进行计算。残差分析是多种统计方法的一个组成部分，包括 LR。LR 的假设是残差必须独立且随机分布，均值为零，这在技术上意味着残差应该通过正态性测试。这可以通过提取残差并进行正态性测试（如 Anderson-Darling 测试或 Shapiro 测试）来验证，或者通过分位数图或概率图进行图形化验证。非随机行为的存在表明模型需要某些调整。离群值可能是罪魁祸首，或者需要更高阶项。在某些情况下，转换也可能有所帮助。

5. 自相关 - 不应存在。在前一点中，我提到过残差必须独立且正态分布。当残差的独立性被破坏时，我们可以看到如下模式，或在残差与顺序图中出现周期性趋势。这也可以通过对数据应用 Durbin-Watson 测试来检测。解决方案也有多种类型，如使用不同的模型或转换某些变量。

简单线性回归，顾名思义，容易理解和应用。我在项目中发现，线性回归在建模数据方面表现良好。因此，线性回归仍然是最常用的数据建模算法之一，这并不令人惊讶。

个人简介：Sudipto Dasgupta 目前在 Flipkart India Pvt. Ltd. 担任流程设计专家，该公司是印度最大的电子商务组织。他在软件、市场研究、教育和供应链等领域拥有超过 15 年的业务分析经验。他是一位经验丰富的六西格玛大师黑带和项目管理专业人士（PMP），拥有数学和统计学的教育背景。他对数据科学有着积极的兴趣。

相关：

• 初学者的十大机器学习算法

• 使用 R 学习广义线性模型（GLM）

• 回归分析真的属于机器学习吗？

更多相关内容

• XGBoost 的假设是什么？

• DataLang: 一种面向数据科学家的新编程语言… 创建…

• 我在 3 天内创建了一个 AI 应用

• 线性回归模型选择：平衡简易性与复杂性

• 为什么你应该使用线性回归模型而不是… 的 3 个理由

• 线性回归与逻辑回归的比较

首个机器学习价值链全景

原文：www.kdnuggets.com/2022/10/first-ml-value-chain-landscape-sequence.html

来源：TheSequence

TheSequence 是一个与 DeepMind、OpenAI、Google Brain 以及更多公司合作的机器学习社区。机器学习和人工智能的世界发展如此迅速，专业人士和有志专业人士很难跟上所有的变化。TheSequence 的目标是让对该领域感兴趣的人无需阅读白皮书和花费大量时间研究，便能更聪明地了解人工智能。

他们还提供其他知识更新，如果你想了解更多，请点击此链接。

首个机器学习链全景

2022 年 10 月 12 日，TheSequence 发布了首个机器学习链全景，由数据科学家塑造。这源于 TheSequence 希望创建一个能够涵盖整个机器学习价值链的新全景，这是一个全面但非常有价值的项目。

该项目分为两个部分：

1. 准备和使用现有研究

2. 涉及社区成员来评估和重塑价值链

典型机器学习过程的 6 个阶段包括：

1. 数据收集

2. 数据处理

3. 数据标注

4. 机器学习模型训练和评估

5. 机器学习模型部署

6. 模型监控

TheSequence 联合创始人 Ksenia Se 说：

“我们都认为机器学习领域有问题，但我们没有完全意识到它的割裂程度。似乎许多机器学习从业者要么面临困难，要么根本无法实现目标。这并不是因为代码差或数据嘈杂，而是因为软件不兼容和链中的策略不佳，而链通常从一开始就形成。”

从下图来看，TheSequence 制作的机器学习价值链全景告诉我们，不幸的是，目前没有一个市场解决方案覆盖链中的所有六个阶段。

涵盖至少 5 个阶段的供应商包括 H2O、Dataiku、Clear ML、Vertex AI、Scale AI、Toloka AI 和 Abacus.AI。

点击放大

该全景揭示了：

大约 50%的数据处理和模型监控是困难的

这通常从生产的早期阶段开始，挑战会持续到后期部署。机器学习项目成功的重要方面还包括数据收集和数据标注的有效性。

开发阶段优化不良

一个根本性挑战是开发阶段的优化不足，这在后续阶段反映得很明显。因此，模型的监控是价值链景观中一个被高度避免的阶段。

数据处理挑战

数据处理从来不是一项简单的任务，它是一个非常分散的领域，伴随着各种挑战。许多人渴望找到一种易于使用、配置和扩展的流程，但迄今为止还没有找到。

自由流动的更好不同阶段

在你做的任何事情中，当一个阶段的效率可以用于下一个阶段时，这当然是很好的。然而，如果不同阶段之间没有互动或兼容性 - 这将导致机器学习项目的完成率低下。市场上有很多软件工具不幸地不兼容，而且技术解决方案越来越复杂，不同背景的专业人士合作的难度也随之增加。

能够覆盖整个价值链

如上图所示，没有供应商能够覆盖整个价值链，尽管有些非常接近。然而，目前没有可灵活适应每个机器学习阶段要求的通用环境。

Ksenia 说：

“我想补充一下，自从发布了这个景观图以来，我们看到社区对此产生了极大的兴趣。机器学习行业发展非常迅速，跟上所有在机器学习价值链不同部分工作的初创公司非常困难。我们计划定期更新这个景观图。”

想了解更多？

如果你想保持对机器学习、人工智能和数据科学世界动态的了解 - 确保点击这个链接订阅 TheSequence。

Nisha Arya 是一名数据科学家和自由职业技术作家。她特别感兴趣于提供数据科学职业建议或教程和理论知识。她还希望探索人工智能如何/可以促进人类寿命的不同方式。她是一个热衷学习者，寻求拓宽她的技术知识和写作技能，同时帮助指导他人。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析能力

3. 谷歌 IT 支持专业证书 - 支持你的组织 IT 需求

---

更多相关主题

• 如何通过 AIOps 管理复杂的 IT 环境

• 8 篇创新的 BERT 知识蒸馏论文如何改变了…

• AI 驱动世界中的数据工程格局

• 数据格局的演变

• 工作的未来：人工智能如何改变职业格局

• 关于人工智能监管格局的一切

DeepMind 的 AlphaTensor 首次开源实现

原文：www.kdnuggets.com/2023/03/first-open-source-implementation-deepmind-alphatensor.html

照片由DeepMind提供，来源于Unsplash

矩阵乘法是一种在许多系统中使用的基础操作，从神经网络到科学计算例程。寻找高效且可证明正确的矩阵乘法算法可以对加快计算速度和提高效率产生巨大影响，但这是一项非常具有挑战性的任务。可能的算法空间非常庞大，而传统的算法发现方法，如人工设计的启发式方法或组合搜索，往往不够理想。

---

我们的三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升您的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持您的组织的 IT 需求

---

DeepMind最近提出的基于 AI 的自动化搜索解决方案远超人类直觉。该解决方案由一个称为 AlphaTensor 的深度强化学习代理组成，建立在AlphaZero之上。这个代理被训练来玩一个单人游戏 TensorGame，目标是发现计算高效的矩阵乘法算法。

AlphaTensor 特别擅长处理大矩阵，通过将大型矩阵乘法分解为较小的乘法。此外，一旦针对特定硬件设备进行微调，AlphaTensor 可以实现矩阵乘法的最先进性能。

AlphaTensor 在加速深度学习计算方面具有巨大的潜力。在深度学习中，许多耗时的操作可以映射为矩阵乘法。通过使用 AlphaTensor 优化这些操作，可以显著提高深度学习模型的整体性能。

最近，OpenAlphaTensor，AlphaTensor 的首个开源实现发布了，这可能会彻底改变深度学习模型的计算能力。

矩阵乘法张量

对于矩阵乘法优化的非专家来说，理解如何将诸如矩阵乘法这样的操作映射到三维张量中可能并不直观。我将尝试用简单的语言和示例来解释。

让我们考虑乘积 C = A*B，为了简单起见，假设 A 和 B 都是大小为 N 的方阵。乘法操作可以映射到形状为(N², N², N²)的 3D 张量中。第一个张量维度表示展平的矩阵 A，第二个维度表示展平的矩阵 B，第三个维度表示展平的矩阵 C。

张量的每个条目只有二进制值（要么是 1，要么是 0）。请注意，张量表示乘法操作，因此它与矩阵 A 和 B 的值无关。

张量的每个条目对应于操作的系数。例如，要计算 C[1,1]，需要同时乘以 A[1,1]和 B[1,1]。因此，张量条目[0,0,0]，即 A[1,1]、B[1,1]和 C[1,1]，的值将为 1。相反，要计算 C[1,1]，A[2,1]是不需要的。因此，张量行 T[N+1, :, 0]将仅包含零。

下图展示了 N=2 时张量的一个例子。

图片来源于 DeepMind 的论文，该论文发表在Nature上

如上图（b）和（c）所示，可以使用 3D 张量的分解实现计算乘积的算法。更具体地说，下面的算法可以用于将张量分解（矩阵 U、V、W）转换为矩阵乘法算法。

用于计算矩阵乘积 C=AB 的 Meta 算法参数在 DeepMind 的论文中介绍

TensorGame

找到高效的矩阵乘法算法是极具挑战性的，因为即使对于小规模的矩阵乘法，考虑的算法数量也远远大于宇宙中的原子数。

DeepMind 将这个问题转化为单人游戏，并称之为 TensorGame。在这个游戏中，玩家选择如何组合矩阵的不同条目以进行乘法运算。根据实现正确乘法结果所需的操作次数来分配分数。当达到零张量或已进行最大移动次数时，游戏结束。最终的分解结果基于残差秩的估计以及某些优化标准，如渐近时间复杂度或实际运行时间。

TensorGame 中的初始位置对应于在某个随机基底上表示的矩阵乘法张量。

在游戏的每一步 t，玩家写下三个向量 ，这些向量指定了秩-1 张量 。通过减去玩家选择的向量来更新游戏状态：

其中 是矩阵乘法张量。

如果游戏在 p 步中结束，这意味着矩阵乘法张量 可以分解为 p 个秩-1 张量 ，即它至少具有秩 p。

TensorGame 可以被解释为一种秩分解算法，AlphaTensor 可以被视为一种估计张量秩的算法。

AlphaTensor 架构

到目前为止，我们了解了 TensorGame，并澄清了其解决方案如何被视为矩阵乘法算法。现在让我们探讨 AlphaTensor 的主要概念，这是用于游戏的算法。

AlphaTensor 架构基本上是一个编码器-解码器 Transformer 架构，其中：

• 编码器以游戏状态 为输入，以及模型采取的 n 个之前的动作（通常 n=7），和当前动作的时间索引 t。信息被堆叠在一个形状为 (n+1, N², N², N²) 的张量中。这个张量随后被重塑并通过三个线性层转换成形状为 (N², N², c) 的张量，其中 c 是模型的内部维度。

• 解码器以自回归方式从编码器给出的嵌入向量生成 n_steps 动作。每个动作对应于三元组的一个标记 ，这些三元组表示分解游戏张量（即降低其秩）的其中一个三元组。

模型通过交替进行反向传播和模型行动进行训练。模型行动用于生成数据，然后用于训练模型。在实践中，模型是通过合成生成的数据和模型在行动过程中生成的数据的混合进行训练的。行动步骤是通过对矩阵操作对应的 3D 张量进行 n_actors 游戏来完成的。每个演员要么在标准基底上进行游戏，要么在替代基底上进行游戏（基底变化以给定的概率应用）。然后收集结果，并可以与合成数据一起用于训练步骤。

动作步骤基于 AlphaZero 的蒙特卡洛树搜索（MCTS），经过修改以支持大型动作空间。简而言之，在选择动作之前，从模型输出中探索 n_sims 条路径，最大未来探索步数为 5 步。然后，模型生成的概率会根据生成的路径进行调整。接着选择具有最有前景的未来路径的动作以继续游戏。

在训练模型时，奖励实际上是负奖励（惩罚）。其绝对值随着解决游戏所需的每一步而增加。如果模型需要 m 步才能解决一个 TensorGame，那么与该游戏相关的奖励是 r=-m。如果模型在 max_rank 步数内无法解决 TensorGame，则通过估计剩余张量的秩来计算奖励。秩估计为组成张量的矩阵的秩之和。这个估计是张量真实秩的上界。

在微调模型时，终态的惩罚奖励还应考虑模型所产生的算法的延迟。奖励公式变为 rt'=rt+λbt，其中 rt 是之前描述的奖励方案，bt 是基准奖励（仅在终态为非零），λ是用户指定的系数。

从 DeepMind 的论文中提取的 AlphaTensor 发现的针对 GPU 和 TPU 优化的算法的加速比（%）。加速比是相对于相同硬件上的标准（例如 GPU 上的 cuBLAS）矩阵乘法进行测量的，并与Strassen 平方算法进行比较。来源：DeepMind。

深 Mind 的 AlphaTensor 开源实现

我最近发布了OpenAlphaTensor，这是 AlphaTensor 的第一个开源实现。在这一部分，我将详细介绍实现过程。正如我们之前讨论的，AlphaTensor 的架构非常简单，基于一个标准的带有编码器-解码器架构的 transformer。AlphaTensor 中最有趣的组件是编码器部分的第一层和动作采样的方式。

让我们从第一个编码层开始。

# x.size = (N, T, S, S, S)
# scalars.size = (N, s)
batch_size = x.shape[0]
S = x.shape[-1]
T = x.shape[1]
x1 = x.permute(0, 2, 3, 4, 1).reshape(batch_size, S, S, S * T)
x2 = x.permute(0, 4, 2, 3, 1).reshape(batch_size, S, S, S * T)
x3 = x.permute(0, 3, 4, 2, 1).reshape(batch_size, S, S, S * T)
input_list = [x1, x2, x3]
for i in range(3):
    temp = self.linears_1i.reshape(batch_size, S, S, 1)
    input_list[i] = torch.cat([input_list[i], temp], dim=-1)
    input_list[i] = self.linears_2i
x1, x2, x3 = input_list

在上面的代码片段中，我们展示了输入张量如何分解为三个张量，然后将这些张量用作 transformer 层的查询、键和值输入。

1. 在表示展平矩阵 (A, B, C) 的三个张量维度中，输入张量沿每个维度展平，同时与表示先前动作的维度一起。在这种方式下，在每个展平的输入张量副本中，所选维度是最后 T-1 个值和实际值的聚合，对于所选维度的所有 S 个值，其中 S=N²。从哲学上讲，就好像对于每个维度，我们专注于在该维度中先前动作发生的情况。

2. 标量被映射到三个不同的维度为 S² 的空间中，然后重新形状以与先前点获得的张量连接。概念上，标量被映射到维度为 S² 的嵌入空间，然后将嵌入的信息分块成 S 个向量并堆叠在一起，类似于文本被标记化时的情况。

3. 标量标记与重新结构化的输入张量连接在一起，然后作为输入提供给线性层，以将标量+通道历史关注信息映射到模型的内部维度中。

这三步可以解释为一种方法，既向模型提供关于标量的信息（如在 TensorGame 时间步中），又关注每个通道的先前动作。

关于动作产生的方式，值得注意的是 AlphaTensor 输出的三元组 u, v, w 旨在降低张量秩。这三个向量的大小为 S，由于它们被连接在一起，模型必须产生一个大小为 3*S 的向量。AlphaTensor 使用 RL 算法进行训练，因此所有可能的动作必须以概率形式表达在一个枚举空间中，即模型对不同的动作生成一个概率。这意味着 3S 空间中的每个向量都应该映射到一个不同的动作。这导致了一个大小为 |F|^(3S) 的动作空间，其中 |F| 是 u、v、w 元素可以取的不同值的数量。通常，这些值限制在 (-2, -1, 0, 1, 2)，结果是 5 个元素的基数。

这里出现了一个重大挑战：为了生成大小为 5 的矩阵乘法的动作概率，我们需要 5⁷⁵ * 4 字节的内存，这意味着大约 10⁴⁴ GB 的内存。显然，我们无法管理如此大的动作空间。

我们如何解决这个问题？为了减少动作概率的内存占用，我们可以将三元组拆分成更小的块，“标记化”它们，并将这些块作为生成的标记输入到变换器架构中，即这些标记以自回归方式作为输入提供给解码器。在上面的例子中，我们可以将三元组拆分成 15 个块，将内存消耗减少到 15 * 5^(75/15) * 4，即 187.5 KB。

def _eval_forward(self, e: torch.Tensor):
    bs = e.shape[0]
    future_g = (
        torch.zeros((bs, self.n_samples, self.n_steps)).long().to(e.device)
    )
    ps = torch.ones((bs, self.n_samples)).to(e.device)
    e = e.unsqueeze(1).repeat(1, self.n_samples, 1, 1)

    future_g = future_g.view(-1, self.n_steps)
    ps = ps.view(-1)
    e = e.view(-1, e.shape[-2], e.shape[-1])
    for i in range(self.n_steps):
        o_s, z_s = self.core(future_g[:, : i + 1], e)
        future_g[:, i], p_i = sample_from_logits(o_s[:, i])
        ps *= p_i
    future_g = future_g.view(bs, self.n_samples, self.n_steps)
    ps = ps.view(bs, self.n_samples)
    return (
        future_g,
        ps,
        z_s[:, 0].view(bs, self.n_samples, *z_s.shape[2:]).mean(1),
    )

上面展示了生成完整动作的代码片段。在代码中，self.core 包含解码层，而张量 e 表示编码层的输出。Zero 可以被视为 NLP 模型中的标记，而表示 n_steps 块的 n_steps 动作是逐步生成的。

模型返回三个量：

1. 生成的动作

2. 与完整动作相关的概率

3. 生成第一个动作（第一个块）的 logits，这将用于计算模型值。

值得花几句话说明 n_samples 参数。该参数用于行动步骤，允许模型生成不同版本的三元组，这些三元组将用于探索蒙特卡罗树搜索算法中的动作空间。n_samples 个不同的动作是根据模型生成的策略进行抽样的。

行动步骤

整个算法中最棘手的部分可能是用于解决 TensorGame 的行动步骤。该算法在 AlphaTensor 论文中没有深入解释，因为它基于几篇 DeepMind 的先前论文，这些论文只是被引用并作为已知。在这里，我将重建所有缺失的部分，并逐步解释我们的实现。

我们可以将行动步骤组织为三个不同的组件：

• 蒙特卡罗树搜索

• 游戏模拟

• 改进的策略计算

让我们逐一分析它们。

蒙特卡罗树搜索（MCTS）

蒙特卡罗树搜索（MCTS）是一种广泛使用的人工智能技术，主要用于游戏，特别是棋盘游戏和视频游戏。该算法创建一个游戏树，模拟潜在的移动和结果，并使用随机抽样来评估每个动作的预期奖励。然后，算法反复选择预期奖励最高的动作，并模拟结果直到达到终止状态或指定的停止条件。这些模拟用于估算每个动作的获胜概率，并指导决策过程。MCTS 已被证明在可能的动作和结果数量庞大的复杂游戏中有效，并且已被成功应用于游戏 AI 系统，如 AlphaGo。

在 AlphaTensor 中，使用了原始 MCTS 的修改版本。特别是，与从整个动作空间随机选择动作不同，该动作是从模型直接生成的子集（通过前面提到的 n_samples）中选择的。然后在改进的策略计算步骤中应用对策略升级的修正。

在我们的实现中，我们决定将关于蒙特卡洛树的所有信息保存在一个字典中，该字典的键是 TensorGame 状态的哈希版本，值是与状态本身相关的信息。每个蒙特卡洛步骤从一个节点开始，并模拟n_sim个迷你游戏，探索未来 5 步的范围。如果节点在先前的模拟中已经被探索过，则n_sim会根据之前的探索次数进行调整。每个节点的访问次数存储在N_s_a张量中，因为该张量包含每个节点子动作的访问次数（在模型抽样的动作中）。

def monte_carlo_tree_search(
    model: torch.nn.Module,
    state: torch.Tensor,
    n_sim: int,
    t_time: int,
    n_steps: int,
    game_tree: Dict,
    state_dict: Dict,
):
"""Runs the monte carlo tree search algorithm.

    Args:
        model (torch.nn.Module): The model to use for the simulation.
        state (torch.Tensor): The initial state.
        n_sim (int): The number of simulations to run.
        t_time (int): The current time step.
        n_steps (int): The maximum number of steps to simulate.
        game_tree (Dict): The game tree.
        state_dict (Dict): The dictionary containing the states.
    """
    state_hash = to_hash(extract_present_state(state))
    if state_hash in state_dict:
        with torch.no_grad():
            N_s_a = state_dict[state_hash][3]
            n_sim -= int(N_s_a.sum())
            n_sim = max(n_sim, 0)

    for _ in range(n_sim):
        simulate_game(model, state, t_time, n_steps, game_tree, state_dict)
    # return next state
    possible_states_dict, _, repetitions, N_s_a, q_values, _ = state_dict[
        state_hash
    ]
    possible_states = _recompose_possible_states(possible_states_dict)
    next_state_idx = select_future_state(
        possible_states, q_values, N_s_a, repetitions, return_idx=True
    )
    next_state = possible_states[next_state_idx]
    return next_state

上面的代码展示了我们对算法的实现。为了代码的简洁性，策略修正是在simulate_game函数中完成的。

游戏模拟

simulate_game函数负责探索由代表 TensorGame 某一特定状态的节点组成的树。当遇到叶子节点时，它还会运行模型，并将所有节点信息存储在state_dict字典中。让我们深入了解它的实现：

@torch.no_grad()
def simulate_game(
    model,
    state: torch.Tensor,
    t_time: int,
    max_steps: int,
    game_tree: Dict,
    states_dict: Dict,
    horizon: int = 5,
):
"""Simulates a game from a given state.

  Args:
      model: The model to use for the simulation.
      state (torch.Tensor): The initial state.
      t_time (int): The current time step.
      max_steps (int): The maximum number of steps to simulate.
      game_tree (Dict): The game tree.
      states_dict (Dict): The states dictionary.
      horizon (int): The horizon to use for the simulation.
  """
  idx = t_time
  max_steps = min(max_steps, t_time + horizon)
  state_hash = to_hash(extract_present_state(state))
  trajectory = []
  # selection
  while state_hash in game_tree:
      (
          possible_states_dict,
          old_idx_to_new_idx,
          repetition_map,
          N_s_a,
          q_values,
          actions,
      ) = states_dict[state_hash]
      possible_states = _recompose_possible_states(possible_states_dict)
      state_idx = select_future_state(
          possible_states, q_values, N_s_a, repetition_map, return_idx=True
      )
      trajectory.append((state_hash, state_idx))  # state_hash, action_idx
      future_state = extract_present_state(possible_states[state_idx])
      state = possible_states[state_idx]
      state_hash = to_hash(future_state)
      idx += 1

  # expansion
  if idx <= max_steps:
      trajectory.append((state_hash, None))
      if not game_is_finished(extract_present_state(state)):
          state = state.to(model.device)
          scalars = get_scalars(state, idx).to(state.device)
          actions, probs, q_values = model(state, scalars)
          (
              possible_states,
              cloned_idx_to_idx,
              repetitions,
              not_dupl_indexes,
          ) = extract_children_states_from_actions(
              state,
              actions,
          )
          not_dupl_actions = actions[:, not_dupl_indexes].to("cpu")
          not_dupl_q_values = torch.zeros(not_dupl_actions.shape[:-1]).to(
              "cpu"
          )
          N_s_a = torch.zeros_like(not_dupl_q_values).to("cpu")
          present_state = extract_present_state(state)
          states_dict[to_hash(present_state)] = (
              _reduce_memory_consumption_before_storing(possible_states),
              cloned_idx_to_idx,
              repetitions,
              N_s_a,
              not_dupl_q_values,
              not_dupl_actions,
          )
          game_tree[to_hash(present_state)] = [
              to_hash(extract_present_state(fut_state))
              for fut_state in possible_states
          ]
          leaf_q_value = q_values
  else:
      leaf_q_value = -int(torch.linalg.matrix_rank(state).sum())
  # backup
  backward_pass(trajectory, states_dict, leaf_q_value=leaf_q_value)

每次模拟被分成三部分：

• 选择

• 扩展

• 备份

在选择部分，模拟在已生成的树节点上运行，使用以下函数选择下一个节点：

def select_future_state(
    possible_states: List[torch.Tensor],
    q_values: torch.Tensor,
    N_s_a: torch.Tensor,
    repetitions: Dict[int, list],
    c_1: float = 1.25,
    c_2: float = 19652,
    return_idx: bool = False,
) -> torch.Tensor:
"""Select the future state maximizing the upper confidence bound."""
# q_values (1, K, 1)
    pi = torch.tensor(
        [
            len(repetitions[i])
            for i in range(len(possible_states))
            if i in repetitions
        ]
    ).to(q_values.device)
    ucb = q_values.reshape(-1) + pi * torch.sqrt(
        torch.sum(N_s_a) / (1 + N_s_a)
    ) * (c_1 + torch.log((torch.sum(N_s_a) + c_2 + 1) / c_2))
    if return_idx:
        return ucb.argmax()
    return possible_states[ucb.argmax()]

实际上，最大化 ucb 函数的动作：

对于给定状态选择的。这里 Q 表示模型生成的 Q 值，π表示基于模型策略抽样的动作上的随机分布。N(s, a)表示从节点 s 到动作 a 的节点访问次数。

一旦选择阶段达到叶子节点，如果模拟没有达到终止条件（无论是最大探索，即未来范围，还是游戏结束），则使用模型选择n_samples个替代节点（它们将在后续迭代中成为叶子节点）。这称为扩展阶段，因为新节点被添加到树中。然后，在当前模拟中不再探索更多节点，但叶子 q_value 会被传递到下一模拟步骤：备份。

备份是每次模拟的最终阶段。在备份过程中，如果叶子节点是终止状态，则计算最终奖励；否则使用叶子 q 值作为估计奖励。然后将奖励在模拟轨迹上反向传播，更新状态的 q_values 并更新访问计数器 N(s, a)。在下面的代码片段中，我们展示了奖励反向传播的代码。

def backward_pass(trajectory, states_dict, leaf_q_value: torch.Tensor):
"""Backward pass of the montecarlo algorithm"""
reward = 0
    for idx, (state, action_idx) in enumerate(reversed(trajectory)):
        if action_idx is None:  # leaf node
            reward += leaf_q_value
        else:
            (
                _,
                old_idx_to_new_idx,
                _,
                N_s_a,
                q_values,
                _,
            ) = states_dict[state]
            if isinstance(reward, torch.Tensor):
                reward = reward.to(q_values.device)
            action_idx = int(action_idx)
            if action_idx in old_idx_to_new_idx:
                not_dupl_index = old_idx_to_new_idx[int(action_idx)]
            else:
                not_dupl_index = action_idx
            reward -= 1
            q_values[:, not_dupl_index] = (
                N_s_a[:, not_dupl_index] * q_values[:, not_dupl_index] + reward
            ) / (N_s_a[:, not_dupl_index] + 1)
            N_s_a[:, not_dupl_index] += 1

改进的策略计算

一旦所有模拟运行完毕，并且 MCTS 提供了对近期未来的有趣快照，就该更新与预测节点相关联的策略并返回这些节点，以便在训练过程中使用。改进的策略，遵循Hubert et al中描述的方法，用于管理大型动作空间。实际上，对于小型搜索空间，在 MCTS 过程中，可以从动作空间中随机采样一个动作并评估其影响。在更大动作空间中采用类似的方法会导致所有轨迹在不同路径上分歧，并且需要无限量的轨迹来获取有意义的统计数据，然后更新策略。由于我们这里使用的是采样-MCTS 来避免分散，即 n_samples 动作根据模型策略进行采样，然后 MCTS 在探索树时只选择采样的一个动作，因此在计算最终更新策略时需要考虑样本修正，以便在训练模型时使用。

实际上，改进的策略计算如下

其中

def compute_improved_policy(
    state_dict: Dict,
    states: List[str],
    model_n_steps: int,
    model_n_logits: int,
    N_bar: int,
):
    """Compute the improved policy given the state_dict, the list of states.
    The improved policy is computed as (N_s_a / N_s_a.sum())^(1/tau) where tau
    is (log(N_s_a.sum()) / log(N_bar)) if N_s_a.sum() > N_bar else 1.
    """
    policies = torch.zeros(len(states), model_n_steps, model_n_logits)
    N_bar = torch.tensor(N_bar)
    for idx, state in enumerate(states):
        N_s_a = state_dict[state][3]
        actions = state_dict[state][5]
        if N_s_a.sum() > N_bar:
            tau = (torch.log(N_s_a.sum()) / torch.log(N_bar)).item()
        else:
            tau = 1
	 N_s_a = N_s_a ** (1 / tau)
        improved_policy = N_s_a / N_s_a.sum()
        for sample_id in range(actions.shape[1]):
            action_ids = actions[0, sample_id]
            for step_id, action_id in enumerate(action_ids):
                policies[idx, step_id, action_id] += improved_policy[
                    0, sample_id
                ]
    return policies

请注意，在我们的实现中，计算完来自 N_s_a 张量的策略后，我们必须将其映射回原始的动作张量。事实上，N_s_a 只考虑了模型采样的动作，而最终的策略必须包含未探索动作的概率。

与 ChatGPT 训练算法的区别

AlphaTensor 是 DeepMind 最新的 AlphaGo/AlphaZero 系列人工智能方法中的成员。这些方法基于蒙特卡罗树搜索（MCTS）算法，DeepMind 已经对其进行了改进和增强，以应对越来越复杂的任务。另一种引起广泛关注的 AI 系统，OpenAI 的 ChatGPT，其表现非常出色，采用了不同的方法，即带有人类反馈的强化学习（RLHF）。

RLHF 是一种微调技术，用于调整语言模型以遵循一组书面指令。它使用人类偏好作为奖励信号来微调模型，从而使语言模型的行为与特定人群的声明偏好对齐，而不是某种更广泛的“人类价值观”。

相比之下，MCTS 是一种基于树的搜索算法，用于确定游戏中的最佳动作。它模拟潜在的动作，并根据这些动作的结果更新每个动作的值，从而指导最佳动作的选择。

RLHF 收集来自人工编写的演示和人工标记的 AI 模型之间的比较的数据，并训练一个奖励模型来预测特定人群的偏好。然后，奖励模型用于微调 AI 模型。另一方面，MCTS 则使用模拟和评估来确定最佳决策。

尽管它们是不同的方法，RLHF 和 MCTS 也有相似之处。两者都是人工智能技术，采用决策制定和问题解决的方法，并且都使用试错法来探索不同的选项，并基于现有信息做出决策。它们也是迭代过程，随着更多信息和经验的积累而不断改进。

在 RLHF 和 MCTS 之间的选择取决于手头的任务。当没有明确的度量标准来评估模型性能时，RLHF 是理想的选择，而 MCTS 在游戏类任务中表现有效，其中知识和对未来的探索为模型提供了显著的优势。

AlphaTensor 训练的代码优化

实现 AlphaTensor 训练算法需要在训练速度和内存消耗之间找到完美的平衡。如模型部分所示，仅考虑行动标记化就能节省大量内存，但过于激进的行动空间减少可能会导致准确性下降和性能变慢。后者发生的原因是所有标记都由模型解码器以自回归方式顺序生成。因此，一旦行动空间上的 softmax 不再成为瓶颈，推理时间就会随着每个行动的标记数量线性增长。

在设置 AlphaTensor 训练时，主要的困难在于处理行动过程。如果张量没有以正确的格式存储，MCTS 可能会导致无法控制的内存使用增长。另一方面，如果每次模拟中存储的张量数量减少得过多，MCTS 可能会花费无限时间重新计算所需的状态。

让我们以游戏模拟步骤为例，其中游戏通过观察可能的未来场景来进行探索。对于每个状态，如果我们不保存模型生成的动作，而只决定保存用于从策略中采样动作的随机种子，那么每次我们探索一个树节点时，都必须重新计算策略，然后再采样动作。显然，我们决定存储采样的动作以节省时间，并避免在 MCTS 探索并行化的情况下管理不同进程之间的模型共享。然而，仅仅保存动作还不足以获得足够高效的执行步骤。实际上，将 n_steps 动作转换为(u, v, w)三元组、缩减游戏张量状态并从 n_samples 动作中创建新的 3D 张量的时间很容易成为整个训练的瓶颈。其次，我们不想为每个采样动作存储所有可能的未来状态，因为这会对算法使用的内存产生巨大影响。假设我们设置 n_samples=32，n=7，N=5，并且记住 N 是我们想要缩减的方阵积的大小，而 n 是模型记住的前一个动作的数量。在这种情况下，每个状态张量的形式为(8, 25, 25, 25)，乘以 32 会导致每个图节点需要 3282525254 字节。现在，考虑到每次扩展阶段的模拟都会生成一个新节点（且 n_sim=200），我们会得到仅第一个 MCTS 节点的最终内存消耗为 200328252525*4 = 3.2GB。在最坏的情况下，在探索 acting max_rank 节点（其中 max_rank=150）时，这将导致总内存消耗为 150 * 3.2GB = 480GB 的 RAM 内存（或如果所有张量都存储在 GPU 上，则为 GPU 内存）。我们在拥有 128GB RAM 和 48GB GPU 内存的工作站上运行训练，因此我们必须减少内存消耗。

由于我们不想增加执行时间，我们采用了一种优化方法，利用了生成的状态张量中的冗余。实际上，这些张量具有 n-1 个共同的前动作，这些动作可以被存储一次，而不是为每个存储的张量重复存储。这导致内存减少了 2/7~28%，意味着在最坏情况下可以存储 137GB。此时，通过简单地修剪树的未使用部分（例如未选择的轨迹）并将张量存储在 CPU 内存中，我们能够在训练过程中避免任何内存错误。

下一步

随着 OpenAlphaTensor 现在成为开源，许多令人兴奋的进一步发展途径正在打开。

一个自然的进展是对 OpenAlphaTensor 在目标硬件设备上的微调。这预计将带来非常有竞争力的计算性能。我将在 GitHub 上发布更多关于 OpenAlphaTensor 在各种硬件上表现的内容。在撰写本文时，OpenAlphaTensor 正在进行训练。

另一个重要的进展是支持远程编译，使用户能够为边缘设备构建优化的算法。这可以通过将 OpenAlphaTensor 模型存储在服务器上来实现，而矩阵乘法算法则在不同的硬件上进行评估。

扩展对不同编译器的支持以计算基于延迟的奖励修正可能也很重要。不同的编译器可能会在给定的硬件上导致不同的优化算法。例如，DeepMind 的论文显示，使用 JAX 和 XLA 编译器在 TPU 和 Nvidia GPU 上取得了很有前景的结果。使用 Nvidia 上的 NCCL 或 CPUs 上的 LLVM 来评估这种情况将会很有趣。

最后，将模型和训练算法扩展以支持更大的矩阵尺寸仍然是一个主要的开放挑战。目前，OpenAlphaTensor 支持的最大矩阵尺寸为 5，但可以通过将较大的矩阵乘法拆分为多个尺寸小于 5 的小矩阵来应用。这种方法是次优的，直接对对应于完整矩阵乘法的大张量进行归约理论上可能会取得更好的结果。

Diego Fiori 是 Nebuly AI 的首席技术官，该公司致力于将 AI 优化纳入每个开发者的工具包中。

更多相关内容

• 闭源 VS 开源图像注释

• 深入了解 DeepMind 在利用深度学习推动数学发展的新努力

• DeepMind 的 AlphaCode 会取代程序员吗？

• 通过集成 Jupyter 和 KNIME 缩短实现时间

• 宣布 PyCaret 3.0：开源、低代码的 Python 机器学习

• 使用开源工具生成合成时间序列数据

我作为数据科学家的前六个月

原文：www.kdnuggets.com/2021/12/first-six-months-data-scientist.html

评论

由 Amanda Christine West，数据科学家和作家

由 Nigel Tadyanehondo 拍摄于 Unsplash

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业轨道。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

数据科学很酷，但我不认为 2000 年代或更早的人有谁梦想着长大后从事这份工作。对我来说，我最初想成为一名兽医，然后是公园管理员、狗训导师、作家，最后是经济学家。我仍然有点希望能像一些孩子梦想成为律师-医生-宇航员（或者律师-医生-美人鱼，不过我们还是现实一点，美人鱼太迷人了，学法律这样枯燥的东西不太可能）。

当然，目标会随着时间的推移而改变，我于 5 月在弗吉尼亚大学获得了数据科学硕士学位。毕业几个月后，我找到了第一份全职的数据科学家职位。我非常兴奋能够运用我的技能并向新同事证明自己。在过去的 135 天里，我也觉得自己大约有 426 次陷入困境。

这是我从课堂跳入数据科学领域以来学到的技术和非技术课程的简要清单。作为免责声明，这当然只是我的个人经验，每个人的经历会有所不同。

1. 你将使用不到 <20% 的学校里学到的工具 ✂️

我非常喜欢用 R 编程。甚至在面试时我选择了用 R 进行编码。然而，在工作中，我使用 Python 和终端（在 VS Code 中）的比例占到了 95%，SQL 大约 5%，而 R 自开始以来完全没有用过。因此，我在 R 上上的课程（大约是课程的一半）对我来说变得极其无用，而 Python 上的课程则变得更加有用。许多作业，如网页抓取、自然语言处理、Apache Spark 或 Tableau，我都没有用到过。这只是常见的情况，因为很难预测你将来在工作中具体会做什么。

如果你非常致力于特定语言的编码，我建议你提前向招聘人员询问团队使用的语言。即使你“理论上”可以用你选择的语言编码，但如果团队使用其他语言，那么代码审查和集成会变得更加困难。对我来说，我确实喜欢在 Python 上提高技能，但如果使用的是 Scala 这样的其他语言，我觉得我可能不会那么喜欢。

2. AWS（& 云服务）是王者 🤷‍♂️🤷‍♀️

我开始时与 AWS 的关系仅限于一个坚定的握手，但现在我每天都在使用它。AWS 也因提供了成千上万种服务而臭名昭著，这让人很难知道在特定任务中需要哪种服务。更糟糕的是，在 AWS 中搜索如何做某事时，通常会指向 5 种服务，这些服务的名称听起来基本相同。

为了应对这一点，我一直在使用 ExamPro随意学习 AWS 云从业员认证。要学的东西实在太多了，但随着学习的深入，我发现自己能够建立联系，了解一些将来可能对工作有用的服务。最终我也会参加考试，希望这也能成为简历上的一个亮点。我不认为我会成为 AWS 的专家，但如果能成为一个相对称职的 AWS 骑士，我也能接受。

AWS 被我加冕。GIF 来自 GIPHY

Google Cloud 和 Azure 等服务也很受欢迎，但如果你不确定可能使用哪一个，我还是会诚实地推荐 AWS；TechJury.net 发现 AWS 在 2020 年的新企业云采用中占据了 76%的份额。尽管如此，大多数公司在某种程度上都使用云服务，了解它们的基本工作原理和提供的服务是很好的。

3. 理解硬件对于有效排除软件故障至关重要 🤓🔧

在学校里，我们经常会被给出干净的、玩具般的示例，以便集中解决特定的高级问题。在数据科学团队较小的公司，你往往需要自己处理真实、混乱、丑陋的数据。如果是大数据，试图将其调整以在你的管道中运行，就像试图把一头犀牛塞进你母亲的旧舞会礼服一样。

理解你的计算机在后台做了什么会带来很大的不同。对于那些处理困难的数据，我使用如 watch -d -n 0.5 nvidia-smi 和 htop 等命令来跟踪 GPU/CPU 使用率和内存，以及 df -h 来监控给定目录中文件的大小，以防我空间超出。我还使用 tmux 会话以同时打开多个终端窗口，并在通过 ssh 连接到远程计算机时保持工作不断线。最后，当我找到一个有效的解决方案时，我仍然会在线寻找更好的O(n)复杂度的替代方案，这可以在处理大数据集时节省从几分钟到几天的处理时间。

这些只是我对付那些测试我计算机极限的数据的一些方法——我很想听听你自己的小窍门！

4. 搜索一切，随时随地 ????

作为一个刚刚入门的数据科学新手，学习曲线是持续而无情的。你将被要求做的任务往往会让你感到完全意料之外，这意味着你需要在当下拼命找出解决方案，并解决那些你甚至不知道存在的错误。你会每天学习如何应对最随机的复杂问题，虽然你可能不会再进行 A → C → Q 的映射，但你会在编程方面变得更好，每次迭代后代码库也会变得更有意义。

总的来说，“数据科学家”、“问题解决者”和“专业谷歌搜索者”基本上是一样的。至少对我来说，我感觉在第一份工作中学到的东西不比在大学时少，这让我有点惊讶（毕竟，我在付钱让人教我这些东西）。

使用流行的数据科学编程语言的公司很棒，因为这些使用频繁的语言也恰好有最好的 Stack Overflow 文章（这些文章在无数次情况下救了我）。

5. 你的坏习惯不会在学校结束时突然消失 ????

这并非特指数据科学，但我在学校时给自己施加了很大压力，并且没有像同龄人那样经常放松（虽然我住在兄弟会街区，所以这也可能是原因之一 ????）。我会在期中考试前整周（有时整月——微积分很难）都在学习，几乎不离开房间，除了打印更多的练习题或补充咖啡。在非期中周，我会推自己学习到很晚，然后把自己弄醒，穿上运动裤、凉鞋和旧的套头衫，赶到当天的 8 点或 9 点课。从我没能出去的次数来看，我很惊讶我没有在毕业典礼上看起来像个瘦弱、苍白的吸血鬼吓到大家。

我一直以为一旦拿到学位，我就会像正常人一样生活；首先，我每天早晨都会睡满 8 小时以上（哈哈）。我会写日记、读书、冥想、锻炼，可能在时钟打到 7:30 之前就会吃上 acai-kombucha-avocado 碗。而且，因为我爱编程，工作也不会感觉像工作，因此我的生活将永远精彩——完结。

是的，所以……那件事没有发生。

虽然工作确实增加了一些结构，但我有个坏消息；如果你在大学里是个工作狂，你可能在工作后也会是个工作狂……如果你远程工作（像我一样）并且不需要经常开摄像头，那么运动裤、破旧的运动衫和睡过的头发也是可以的。所以基本上是大学生活……没有朋友或在你窗外播放的Mr. Brightside。

GIF 来源于 GIPHY

本质上，你可能会有一点额外的可支配收入，但当你工作到凌晨 1 点，除了“我觉得我快修好这个 bug 了！”没有其他理由时，可能会感觉像是在生活在黄昏地带。第二天醒来几分钟前赶上会议，然后又重复一遍循环。对自己好一点——倦怠很糟糕，平衡是关键，这是我仍在学习的事情。

6. 健康生活同时改变世界 ????

我不认同那些认为数据科学将在 10 年内消失的悲观者，因为公司总是希望通过信息来增加利润——即数据——以及需要有人定量分析这些数据——即数据科学家（或工程师，或分析师，名字并不重要）。在我的工作中，我已经能够直接影响重大项目，并通过我的数据科学取得积极的成果，这些项目将在我离开后许多年仍将继续存在。

我也非常关注财务，并希望努力达到一个可以启动自己项目或提前退休的点。通过数据科学，做有影响力的事情并且财务状况良好并不是典型的权衡；你可以两者兼得。再加上编程的乐趣，数据科学确实是完美的三重奏。

结论 ❄️

显然我有点偏颇，但我很高兴成为一名数据科学家，并且仍然相信我所经历的不足感和自我怀疑是值得的，为了更大的目标。对于那些在大学里的，你们对成为专业人士最担心什么？对于那些现在已经工作的，你们在过渡过程中最大的文化冲击是什么？

一如既往，感谢阅读！如果你们原谅我，我要去做兼职工作，为一些寄居蟹的机器学习算法提供咨询……

由 Naja Bertolt Jensen 提供的照片，发布于 Unsplash

简介: Amanda Christine West 是一位数据科学家和作家，居住在科罗拉多州博尔德。她于 2021 年 5 月获得弗吉尼亚大学的数据科学硕士学位。在数据科学领域，Amanda 最感兴趣的是数据可视化、自然语言处理、机器学习以及以既激动人心又易于新受众理解的方式传达技术概念。

原文。转载经许可。

相关:

• 数据科学家和数据分析师的区别是什么？

• 停止学习数据科学以寻找目的，并寻找目的以学习数据科学

• 数据科学家做什么？

相关话题

• 我的数据科学六个月成功故事

• 我如何在 2 个月内获得 4 个数据科学职位并使收入翻倍…

• 我如何在 18 个月内通过数据科学将收入提高三倍

• 过去 12 个月必读的 NLP 论文

• 我每天使用 ChatGPT 五个月。这些是一些隐藏的宝石…

• 在不到 6 个月的时间内成为商业智能分析师

数据科学项目的第一步

原文：www.kdnuggets.com/2020/07/first-steps-data-science-project.html

评论

由 Favio Vazquez，Closter 首席执行官。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的快车道。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

数据科学应该以一种能够使决策遵循系统化过程的方式来实施。为了实现这一点，我们需要一个计划和方法论来完成数据科学项目。可悲的是，大多数数据科学项目失败的原因是参与的人没有清楚地理解他们需要做什么，或者对公司最重要的事项没有明确认识。你的解决方案需要与公司或其部门的目标和宗旨相一致。

在这篇文章中，我将讨论数据科学项目的第一步以及如何在工作中实现良好的性能和结果。这是对整个数据科学项目的初步介绍，我将在后续的文章中进一步讨论。

但首先，我会给你讲一个小故事，讲述数据科学在公司中的发展（在一个常见的场景中）。事情是这样发生的：

1. 你手中有大量的数据，这些数据是你几个月或几年来积累的，有人说：“我们有很多数据，我们得对它做点什么。”

   

2. 公司决定创建新的领域，以开始思考如何利用数据做出决策。新的员工被聘请来从事这些新创建的领域。

   

3. 商业问题正在转变为数据科学问题，你希望利用数据来解决这些问题。公司聘请了“数据科学家”和数据收集与分析人员。必须有人来优先排序这些问题，然后将其传递给团队。

   

4. 随着数据科学实践的开展，你开始使用数据来解决问题，运用机器学习、统计分析等技术。数据科学部门有很多使用案例，每个人都想参与这一革命。

   

正如你所见，这个过程源于需求，但情况并非总是如此。有些公司从数据科学的思维方式开始，因此这个过程可能会有所不同。

首先，我们需要定义数据科学项目的第一步：

业务理解

任何数据科学项目的一个关键步骤是获取公司的背景和项目背景。这里的背景是指公司如何运行项目、公司的建立情况、竞争对手、部门数量、各部门的不同目标和目的，以及如何衡量成功或失败。

对于一个项目来说，过程是相同的。你需要了解上述所有内容以及期望，了解每个人的角色和职责，项目如何融入运行它的部门，参与的人数以及对你的期望。

数据收集和摄取

数据收集是系统地收集和测量变量信息的过程，这些信息可以回答研究问题、检验假设和评估结果。

在数据领域有多种工作方式和角色，但它们的共同点在于都使用数据。当解决业务问题时，你希望拥有最佳的数据。

数据收集需要一个过程。它不仅仅是从无处获得数据，我们必须一致地进行数据收集，这不是随机的，我们需要规划它，而且还需要工程师、数据架构师、DataOps 以及其他人，而不仅仅是数据科学家。

当你处理一个新的数据集时，最困难的事情之一就是发现最重要的特征来预测你的目标，以及找到可以改善你对数据和模型理解的新信息来源。

大量的数据在等待着你，它们准备好被使用，这就是所谓的开放数据。开放数据的理念是，它是免费的，容易获取，并且可以以方便的格式下载，例如 CSV 或逗号分隔值，这是一种常见的电子表格数据格式。

探索性数据分析和数据准备

在收集数据后，你需要理解和分析数据。数据分析和准备过程是你可以检查前面的步骤是否完成正确，或者你可能需要重新考虑业务案例，或者你可能需要更多的数据或不同的数据。

在这里，你将应用大量的统计分析和代数概念，以充分利用你的数据。分析数据有很多免费的优秀工具，比如 SQL、Python 或 R，或者你也可以使用 Excel，或者如果条件允许，可以使用 Tableau、PowerBI 和 Explorium 等平台。

你需要记住，数据科学不仅仅是关于软件、编程或从不同数据库读取数据。数据科学是关于解决问题的。一个类比是，物理学不是关于微积分、移动物体或代数，而是关于研究自然、理解自然和建模自然。

此外，数据科学是一个迭代过程。不断地迭代，反复思考业务流程和需求，大量实验，倾听数据的反馈，理解并鼓励业务团队理解数据的意见必须始终包含在产品讨论中，找到解决问题的关键路径，然后围绕完成它并进一步推进来组织团队，让模型解决问题，当然，使用我们的专业知识来帮助它们，但不偏袒它们。

数据科学从数据到价值，但我们需要一个良好的起点。如果你对业务背景了解不深，即使你是机器学习专家，也无法解决问题。如果你没有按照系统化的流程收集数据，以获得最佳的信息来源并利用已有的数据，实现目标是不可能的，最后，如果你没有花时间分析和准备数据，就无法验证最后的步骤并提出识别问题的驱动因素的假设。

有很多地方可以找到这类数据，但有时收集起来可能会很复杂。幸运的是，我们有像 Explorium 这样的工具，使一切变得简单 - 了解更多关于 Explorium 的信息。

相关：

• 数据科学的 8 个基本统计概念

• 商业智能中数据集成方法的初学者指南

• 新手和初级数据科学家的建议

更多相关话题

• 停止学习数据科学以寻找目的，找到目的再…

• 学习数据科学统计的顶级资源

• 成功数据科学家的 5 个特征

• 每位数据科学家都应了解的三个 R 语言库（即使你使用 Python）

• 一个 $9B 人工智能失败的分析

• 什么让 Python 成为初创企业理想的编程语言

谁适合领导数据科学？

原文：www.kdnuggets.com/2021/02/fit-lead-data-science.html

评论

作者：Polly Mitchell-Guthrie，Kinaxis 副总裁，行业拓展与思想领导。

---

我们的前三课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT 需求

---

如果一位数据科学主管拥有超过 10 年的分析团队领导经验，她的团队获得了奖项，积极参与会议演讲，并且拥有顶级项目的工业工程博士学位，你会聘用她吗？当然！但如果她没有深度学习、Kubernetes 和 Tensorflow 等工具/技术的实际操作经验，这会让你犹豫吗？不应该，但这个职位要求在许多高级数据科学领导职位的招聘广告中依然存在，所以让我来解释一下谁适合领导团队，以及为什么对最新工具的经验不应成为首要条件。

几个月前，我与我刚刚描述的那位专业同事交谈，因为她在为一家在分析和数据科学方面竞争激烈的财富 100 公司领导团队多年后正在市场上寻求新机会。她感叹说，许多职位描述要求对最新工具有“实践”经验。我一直看到所需的技能与许多职位招聘广告要求之间的差距，因此我在 LinkedIn 上写了关于这件事的文章。这篇文章引发了广泛的讨论，所以我决定对其进行扩展评论。

我将再次向人力资源部门和招聘数据科学领导者的公司提出请求：如果你希望最大化数据科学团队的成果，请聘用那些擅长领导团队并在数据科学中取得成果的人。停止坚持要求对最新工具和技术有多年的实践经验，这些人在被聘用后可能不会亲自使用这些工具。相反，重视他们实际需要的技能，这些技能对团队的成功比对 GPT-3 的熟练程度更为关键。

虽然你不希望有人脱离实际，但你确实希望有人知道如何构建业务问题，帮助数据科学家将业务问题抽象成他们可以建模的技术结构，指导他们向业务领导解释结果，考虑可用性和部署，并发展职业生涯。我把数据科学所需的技能视为凳子的腿。编程经验、定量严谨性、商业头脑和人际交往技能都是必不可少的，但凳子需要一段时间才能平衡。初级数据科学家是团队的一部分，所以你可以容忍他的凳子有些摇晃，因为其他人可以弥补他较弱的领域。你的领导者的凳子需要平衡，但这种平衡是技能随着时间的发展而形成的稳定性结果。

这种平衡通过我多年前与另一位前同事安妮·特杰普的交流得到了很好的说明。她将数据科学家的发展与冻酸奶相提并论。她认为，人们从一组优势开始，就像最初添加到杯子中的冻酸奶旋涡一样。对于大多数初级数据科学家来说，首先发展的是编程和定量严谨性，这些他们在大学或通过在线课程和实践中学习。尽管研究显示对沟通和人际交往技能的兴趣在数据科学家的广告中占据主导地位，但学术项目仍然在这些领域的课程设置上有所不足。

随着时间的推移，安妮可能会增加“…创造力（我称之为自信），这提升了建模，然后是业务，这进一步改善了建模和创造力，然后是沟通，这进一步改善了建模、创造力、业务和编程，但最终选择专注于沟通、业务、编程和/或建模——没有哪个维度可以在没有其他维度的情况下在分析中被可信地完成。除了当他们什么都不知道或对每个领域都略知一二时，各维度的强项在任何特定时间点上都不会平衡——这两种情况都不是很有效——谁会想要一层冻酸奶？人们的发展是不均衡的，所有技能的培养需要时间，即便你发展了这些技能，你也可能选择不主动保留所有的技能。” 就像数据科学家通过经验不断丰富她的技能集一样，额外的冻酸奶风味也被添加进去。

当数据科学家在职业生涯中进入更高级的领导角色时，她需要发展她的支柱，专注于商业洞察力和人际交往技能。当她达到总监级别或更高时，她可能已经多年没有亲自编写代码了，也不应该编写。她将忙于领导，这意味着她深入了解公司的业务，吸引、留住和培养人才，识别数据科学能带来最大价值的领域，确保数据科学从实验室成功转向生产，并将这一价值转化给非技术领导者。即使她错过了亲手编程，她也没有时间跟上最新的工具，因为她有太多其他的事务要处理。

然而，这里有一个最近的高级副总裁数据科学的职位描述：“精通 R、SQL 和 Python，包括 Tensorflow、Keras 和 XGBoost 库。” 此人还被期望领导一个“由数据科学家组成的大团队”，以“提升公司的盈利能力，改善客户体验，提升衡量和管理风险的能力……提取有价值的商业洞察，将这些洞察转化为实际的好处，并向执行团队传达结果……与各部门的业务领域专家合作，以理解问题和目标。”

斜体部分是我的补充，因为我的观点是，这些斜体的动词是我期望高级领导者做的事情，而不是编写代码。领导者需要理解 Tensorflow、Keras 和 XGBoost 的商业价值、技术优势和局限性，但她不需要亲自获得这些知识。在高级领导层，她至少在这些工具出现后的过去 5-6 年中不断晋升，已经不再是亲自编写代码的那一类人了。

聘用大学应届生的价值在于，他们确实具备这些经验，特别是在深度学习等最新算法的量化严谨性和编程工具（如 GPT-3）方面。然而，虽然工具会不断变化，但近期毕业生不会深入掌握的内容是那种持久的商业洞察力和人际交往技能，这些是执行诸如翻译、沟通、协作和理解等能力所必需的。

这些技能是通过学习经验、听取业务用户关于他们问题的抱怨以及将这些症状转化为恰当框架的商业问题而获得的。初级数据科学家可能会直接着手解决问题的初步版本，并使用他们所知道的最复杂的数学方法来寻找解决方案。随着时间的推移，他们将改善正确抽象问题和选择正确方法（不总是最新的方法）来解决问题的能力，但如果由已经学习过这些经验的人引导，他们会更快达到目标。经验让我学到了很多，比如终于成功向认为 OR 意味着手术室的医疗领导解释运筹学，或者因为我们在规划部署时没有及时涉及 IT 部门而导致团队模型停滞不前。

数据科学计划失败是由于领导力，而不是因为领导者在过去一年中没有向他们的 GitHub 仓库添加内容。咨询公司 麦肯锡的 10 个失败原因列表 都涉及我强调的那些动词——缺乏明确愿景、对商业价值的理解不足、翻译差距、角色模糊、团队隔离等。太多的数据科学项目失败了，所以让我们通过聘用适合领导数据科学团队的领导者来设定成功的条件，而不是为他们编程。

简介： Polly Mitchell-Guthrie (@PollyMGuthrie) 是 Kinaxis 的行业推广和思想领导力副总裁，该公司致力于帮助人们做出自信的供应链决策。她曾担任北卡罗来纳大学医疗系统分析咨询服务主任，并在 SAS 担任多个职务。她非常参与 INFORMS，这是分析和运筹学领域的领先专业组织。

相关：

• 机器学习的最大遗漏：商业领导力

• 数据科学家的四项工作

• 了解雇主对 2020 年数据科学家角色的期望

更多相关话题

• 根据定制指令调整 ChatGPT 以适应您的需求

• 深度神经网络不会引导我们走向 AGI

• 停止学习数据科学以寻找目的，并找到目的来…

• 数据科学最低要求：您需要了解的 10 项基本技能…

• 数据科学定义幽默：一些古怪的名言…

• 5 个数据科学项目，学习 5 项关键的数据科学技能

数据科学中的五种认知偏差（以及如何避免它们）

原文：www.kdnuggets.com/2020/06/five-cognitive-biases-data-science.html

评论

重新训练你的思维。图片由 John Hain 提供，来源于 Pixabay。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你组织的 IT

---

最近，我在阅读 Rolf Dobell 的《清晰思考的艺术》时，开始以全新的方式思考认知偏差。我意识到某些认知偏差是多么根深蒂固。实际上，我们经常没有意识到我们的思维受到这些偏差的影响。对数据科学家来说，这些偏差确实会改变我们处理数据的方式和日常决策，通常并非有利。

数据科学尽管我们处理的所有事实看似客观，但其过程却出奇地主观。

作为数据科学家，我们的工作是解读事实。然而，在进行这种分析时，我们必须做出主观的决策。因此，即使我们处理的是硬数据和事实，数据科学也具有强烈的解释成分。

因此，我们数据科学家需要非常小心，因为所有人都容易受到认知偏差的影响。我们也不例外。事实上，我见过许多数据科学家基于先入为主的信念、有限的数据或不理性的偏好做出决策的情况。

在这篇文章中，我想指出五种最常见的认知偏差类型。 我还提供了一些建议，帮助数据科学家避免这些偏差，并做出更好的、更加理性的决策。

1. 幸存者偏差

来源。

在第二次世界大战期间，非营利研究组织海军分析中心的研究人员面临一个问题。他们需要加强战斗机在最薄弱部位的防护。为了实现这一目标，他们转向数据。他们检查了每一架从战斗任务中归来的飞机，并记录了子弹击中飞机的位置。基于这些信息，他们建议在这些具体的部位加强飞机的防护。

你认为这种方法有问题吗？

问题当然在于，他们只看了返回的飞机，而没有看未返回的飞机。当然，被击落的飞机的数据几乎肯定会对确定飞机在哪里可能发生致命损伤更有用，因为那些飞机遭受了灾难性的损坏。

研究团队受到了幸存者偏差的影响：他们仅仅查看了可用的数据，而没有分析更大的情况。这是一种选择性偏差，我们根据一些任意的标准隐式地筛选数据，然后试图理解它，而没有意识到或承认我们正在处理的是不完整的数据。

让我们思考一下这如何适用于我们的数据科学工作。假设你开始处理一个数据集。你已经创建了特征，并在建模任务中达到了不错的准确度。但也许你应该问自己，这是否是你能达到的最佳结果。你是否尝试过寻找更多的数据？也许将天气预报数据添加到你在 ARIMA 模型中使用的常规销售变量中，可以帮助你更好地预测销售。或者，也许一些关于节假日的特征可以告诉你的模型，为什么你的买家在感恩节或圣诞节期间会有特定的行为。

克服建议： 一种减轻这种偏见的方法是以严谨、科学的方式思考手头的问题，然后头脑风暴寻找任何可以帮助解决问题的数据（而不是仅仅从数据开始）。这些方法看起来可能类似，但第二种方法会限制你的视野，因为你不知道你的工作中缺少什么。通过使用第一种方法，你会知道哪些数据你没有获得，最终会把这些因素考虑进你的结论中。

2. 沉没成本谬误

来源：Pixabay。

我们都曾见过沉没成本谬误的实际情况，无论是因为已经付钱而坚持看那部糟糕的电影，还是因为已经读了一半而完成那本糟糕的书。每个人都有过这种情况，他们为了挽回已经投入的时间而浪费了更多的时间。

沉没成本，也称为回顾成本，是指已经发生的成本，通过任何额外的行动都无法回收。沉没成本谬误指的是人们倾向于根据已投入的成本做决策，这种倾向会导致更多的投资，但不会带来任何回报。

有时候，尽管很困难，最好的办法就是放手。

这在数据科学项目中经常发生。一个项目可能运行超过两年而没有结果，但研究人员继续进行，因为已经投入了大量的时间、金钱和精力。或者数据科学家可能全心捍卫她的项目，因为她已经投入了很多，但却没有意识到继续投入工作不会从长远来看对她或公司有帮助，最好还是放弃这个项目。

克服建议：避免这种认知偏差的一种方法是关注未来的收益和成本，而不是已经丧失的过去成本。你需要养成忽视之前成本信息的习惯，尽管这很困难。当然，对于我们数据科学家来说，完全忽视数据从来都不容易。就我个人而言，我发现一种有条理的方法在这种情况下效果最好。我会拿出纸笔，远离所有干扰，尝试列出完成项目所需的所有额外成本以及未来可能获得的收益。如果任务的成本部分看起来过于显著，那么是时候放手了。

3. 虚假因果关系

来源。

作为数据科学家，我们总是在寻找模式。这种倾向意味着有时我们甚至会发现不存在的模式。我们的脑子被训练得如此之好，以至于我们甚至会把混乱解释成可以理解的东西。

因为我们的训练让我们去寻找模式，所以记住一个简单的格言至关重要：相关性不代表因果关系。这五个词就像数据科学工具箱中的锤子，没有它你无法完成任何事情。两个变量一起变化并不一定意味着一个变量导致了另一个变量的变化。

这个原则通过大量有趣的例子得到了生动的展示。例如，

• 通过查看消防部门的数据，你会发现，派遣更多的消防员去灭火，最终对财产造成的损害也会更多。因此，你可能会推断更多的消防员造成了更多的损害。

• 在另一个著名的例子中，一位学者在调查 1980 年代纽约市犯罪原因时发现，严重犯罪的数量与街头小贩销售的冰淇淋数量之间存在强烈的相关性。但是，我们应该得出结论说吃冰淇淋会促使人们犯罪吗？既然这毫无意义，我们显然应该怀疑有一个未被观察到的变量同时影响了这两者。在夏天，犯罪率最高，这也是冰淇淋销量最多的时候。冰淇淋销售不会导致犯罪，犯罪也不会增加冰淇淋销售。

在这两种情况下，过于表面地查看数据会导致错误的假设。

应对建议：作为数据科学家，我们在展示发现时需要注意这种偏差。通常，变量看似有因果关系，但在仔细检查后可能并非如此。我们还应该特别小心在创建模型变量时避免这种错误。在每一个步骤中，重要的是要问自己，我们的自变量是否只是与因变量相关。

4. 可得性偏差

你是否曾经说过类似“我知道[插入一个泛泛的说法]因为[插入一个单一的例子]”的话。例如，有人可能会说，“你不能通过喝啤酒变胖，因为鲍勃喝了很多啤酒，而他很瘦。”如果你这样说过，那你就受到了可得性偏差的影响。你试图用有限的数据来解释世界。

人们自然倾向于根据已经获得的信息或经常听到的事情来做决策，而不去考虑可能有用的替代方案。结果是，我们将自己限制在一个非常具体的信息子集内。

在数据科学领域，这种情况经常发生。数据科学家往往获取和处理那些容易获得的数据，而不是寻找那些更难获取但可能更有用的数据。我们使用那些我们理解且以整洁的包裹形式提供的模型，而不是那些更适合当前问题但更难得到的模型。

应对建议：克服数据科学中的可得性偏差的一种方法是拓宽我们的视野。承诺终身学习。阅读。大量阅读。阅读各种内容。然后再多读些。结识新朋友。在工作或在线论坛中与其他数据科学家讨论你的工作。对你可能需要在方法中做出的变更保持开放态度。通过接触新的信息和观点，你可以确保自己更不容易使用不完整的信息。

5. 确认偏差

有句老话说，如果你足够折磨数据，它会承认一切。通过足够的工作，你可以扭曲数据，让它说出你想让它说的话。

我们每个人都有一些信念，这没问题。这是人类的一部分。然而，问题在于当我们让这些信念无意中影响了我们形成假设的方式时。

我们可以在日常生活中看到这种倾向。我们经常以使新信息与我们自己的信念兼容的方式解读新信息。 我们在最符合我们信念的网站上阅读新闻。我们与像我们一样、持有类似观点的人交谈。我们不想得到令人不安的证据，因为那可能会导致我们改变世界观，而这可能是我们害怕做的。

例如，我在项目的成本效益分析阶段看到过确认偏差的实际应用。我看到有人固守确认他们假设的数据，同时忽视所有矛盾的证据。显然，这样做可能会对项目的收益部分产生负面影响。

克服建议： 一种对抗这种偏见的方法是批判性地审视你所有的信念，并尝试找到每一个理论的不安证据。我的意思是积极寻找证据，去那些你通常不会去的地方，和那些你通常不会交谈的人交谈，保持开放的心态。

结论

在信息过载的时代，我们被如此大量的数据包围，我们的大脑拼命试图从噪音中找出意义。

有时候，能够根据有限的信息对世界做出一些理解是很有用的。事实上，我们在做大多数决定时并不会多加思考，而是凭直觉行事。我们日常行动的大多数潜在危害都很小。然而，让我们的偏见影响我们的工作可能会使我们陷入不幸的境地。如果我们做出了一个关键的决定并发现其结果是错误的，我们可能会损失金钱或信誉。

了解我们的大脑如何工作将帮助我们避免这些错误。

原文。经授权转载。

相关：

• 你并不那么聪明：认知偏差正在确保这一点

• 数据科学家需要了解的 4 个认知偏差关键点

• 机器公平性：如何评估 AI 系统的公平性并缓解任何观察到的不公平问题

更多相关主题

• 数据科学家的认知偏差指南：免费电子书

• 停止学习数据科学以找到目标，并找到目标去…

• 学习数据科学统计的最佳资源

• 成功数据科学家的 5 个特征

• 每位数据科学家都应了解的三个 R 库（即使你使用 Python）

• 一个 $9B 人工智能失败的调查

数据科学的五个命令行工具

原文：www.kdnuggets.com/2019/07/five-command-line-tools-data-science.html

评论

由 Rebecca Vickery，数据科学家

图片由 Toa Heftiba 提供，来源于 Unsplash

---

我们的前三名课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业的快车道。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织在 IT 方面

---

数据科学中最令人沮丧的方面之一是不断在不同工具之间切换。你可能在 Jupyter Notebook 中编辑代码，同时需要在命令行中安装一个新工具，或者在 IDE 中编辑一个函数，同时进行相同的任务。有时，找到在同一软件中完成更多工作的方式是很好的。

在接下来的帖子中，我将列出一些我发现的在命令行上进行数据科学的最佳工具。事实证明，有很多任务可以通过简单的终端命令完成，比我最初想到的要多，我想在这里分享其中的一些。

cURL

这是一个通过包括 HTTP 在内的各种协议从任何服务器获取数据的有用工具。

我将提供几个获取公开数据集的使用案例。 UCI 机器学习库 是获取机器学习项目数据集的优秀资源。我将使用一个简单的 curl 命令下载一个来自台湾新竹市血液转输中心的数据集。如果我们简单地运行 curl [url]，在我们的例子中就是 curl [archive.ics.uci.edu/ml/machine-learning-databases/blood-transfusion/transfusion.data](https://archive.ics.uci.edu/ml/machine-learning-databases/blood-transfusion/transfusion.data?source=post_page---------------------------)，这将把数据打印到终端。

添加一些额外的参数将使用指定的文件名下载并保存数据。文件现在将保存在你当前的工作目录中。

curl -o data_dl.csv https://archive.ics.uci.edu/ml/machine-learning-databases/blood-transfusion/transfusion.data

获取数据科学项目数据的另一种常见方法是通过 API。这个工具还支持GET和POST请求以与 API 进行交互。运行以下命令将从OpenWeatherMap API 获取单条记录并保存为名为weather.json的 JSON 文件。有关 cURL 的更全面教程，请参见 Zaiste 的这篇优秀文章。

curl -o weather.json -X GET \'https://api.openweathermap.org/data/2.5/weather?lat=37.3565982&lon=-121.9689848&units=imperial&appid=fd4698c940c6d1da602a70ac34f0b147' \-H 'Postman-Token: dcf3c17f-ef3f-4711-85e1-c2d928e1ea1a' \-H 'cache-control: no-cache'

csvkit

csvkit 是一组用于处理 CSV 文件的命令行工具。它可以执行的任务可以分为三个领域：输入、处理和输出。让我们看看一个快速的现实世界示例，说明如何使用它。

首先让我们使用 pip 安装这个工具。

pip install csvkit

作为这个示例的目的，我将使用通过上面的 curl 命令从 UCI 机器学习库创建的相同 CSV 文件。

首先，让我们使用csvclean确保我们的 CSV 文件格式正确。这个函数将自动修复常见的 CSV 错误并移除任何坏行。这个函数的一个有用方面是，它会自动输出一个新的清理版本的 CSV 文件，以便保留原始数据。新文件始终遵循以下命名规则[filename]_out.csv。如果你希望覆盖原始文件，可以添加可选的-n参数。

csvclean data_dl.csv

在我拥有的示例文件中，没有错误，但这可以是进一步减少处理 CSV 文件时错误的非常有用的方法。

现在假设我们想快速检查文件。我们可以使用csvcut和csvgrep来完成这项工作。

首先让我们打印出列名。

csvcut -n data_dl_out.csv | cut -c6-Recency (months)Frequency (times)Monetary (c.c. blood)Time (months)whether he/she donated blood in March 2007

现在我们来确定目标列whether he/she donated blood in March 2007中有多少个类别。

csvcut -c "whether he/she donated blood in March 2007" data_dl_out.csv | sed 1d | sort | uniq01

csvgrep函数允许你基于正则表达式匹配来过滤 CSV 文件。

我们使用这个函数提取仅匹配类别 1 的行。

csvgrep -c "whether he/she donated blood in March 2007" -m 1 data_dl_out.csv

你还可以使用csvkit通过csvstat函数执行简单的数据分析。

只需运行csvstat data_dl_out.csv即可将整个文件的描述性统计信息打印到命令行。你也可以只请求一个统计信息的结果，使用可选命令。

csvstat --mean data_dl_out.csv1\. a: 373.52\. Recency (months): 9.5073\. Frequency (times): 5.5154\. Monetary (c.c. blood): 1,378.6765\. Time (months): 34.2826\. whether he/she donated blood in March 2007: None

IPython

IPython 提供了从 shell 访问增强的交互式 python。实际上，这意味着你可以从命令行完成大多数在 Jupyter Notebook 中可以做的事情。

如果你尚未在终端中安装它，你可以按照这些步骤进行安装。

要启动 IPython，只需在命令行中输入ipython。现在你已经进入了交互式 shell。在这里，你可以导入已安装的 Python 库，我发现这个工具在命令行上快速数据分析中最为有用。

让我们对已使用的数据集执行一些基本任务。首先，我将导入 pandas，读取文件并检查前几行数据。

import pandas as pddata = pd.read_csv('data_dl_out.csv')data.head()

文件列名较长，所以接下来我将使用 pandas 重命名这些列，然后将结果数据框导出到新的 CSV 文件中以供以后使用。

data = data.rename(columns={'Recency (months)': 'recency',
             'Frequency (times)': 'frequency',
             'Monetary (c.c. blood)': 'volumne',
             'Time (months)': 'time',
             'whether he/she donated blood in March 2007': 'target'})data.to_csv('data_clean.csv')

作为最后一个练习，让我们使用 pandas 的corr()函数检查特征与目标变量之间的相关性。

corr_matrix = data.corr()
corr_matrix['target'].sort_values(ascending=False)

要退出 IPython，只需输入exit。

csvsql

有时你可能还希望通过 SQL 查询从数据库获取数据集。csvsql 工具，它也是 csvkit 工具的一部分，支持在数据库上直接查询、写入和创建表。它还支持对 CSV 文件的 SQL 查询。让我们对清理过的数据集运行一个示例查询。

csvsql --query  "select frequency, count(*) as rows from data_clean where target = 1 group by frequency order by 2 desc" data_clean.csv

SciKit-Learn 实验室

是的，你可以在命令行上执行机器学习！虽然有一些工具可以做到这一点，但 SciKit-Learn 实验室可能是最易于访问的。让我们使用我们的血液捐赠数据集构建一个模型。

SciKit-Learn 实验室依赖于将正确的文件放置在一致命名的目录中。所以首先我们将创建一个名为train的目录，并将数据文件复制、移动并重命名为features.csv。

mkdir train
cp data_clean.csv train/features.csv

接下来，我们需要创建一个名为predict-donations.cfg的配置文件，并将其放置在我们的data目录中。

[General]
experiment_name = Blood_Donations
task = cross_validate[Input]
train_directory = train
featuresets = [["features.csv"]]
learners = ["RandomForestClassifier", "DecisionTreeClassifier", "SVC", "MultinomialNB"]
label_col = target[Tuning]
grid_search = false
objective = accuracy[Output]
log = output
results = output
predictions = output

然后我们只需运行这个命令run_experiment -l predict-donations.cfg。

这会自动运行实验并创建一个包含结果的输出文件夹。

我们可以运行 SQL 查询来总结Blood_Donations_summary.tsv文件中的结果。

cd output< Blood_Donations_summary.tsv csvsql --query "SELECT learner_name, accuracy FROM stdin "\
> "WHERE fold = 'average' ORDER BY accuracy DESC" | csvlook

还有许多其他对数据科学有用的命令行工具，但我想在这里突出那些我在工作中发现有用的工具。对于命令行上的数据科学的全面了解，我发现《Data Science at the Command Line》一书非常有用，该书可以在在线免费获取。

个人简介：Rebecca Vickery 通过自学学习数据科学。数据科学家 @ Holiday Extras。alGo 的联合创始人。

原文。经许可转载。

相关：

• 数据科学家的 12 个必备命令行工具

• 命令行数据科学：数据探索

• Python 中的探索性数据分析

更多相关主题

• 数据科学的 5 个额外命令行工具

• 命令行数据科学：免费电子书

• ChatGPT CLI：将你的命令行界面转变为 ChatGPT

• 通过这个 GitHub 库掌握命令行的艺术

• 用 Python 在 7 个简单步骤中构建命令行应用程序

• KDnuggets™ 新闻 22:n03, 1 月 19 日：深入了解 13 个数据…

五个酷炫的 Python 数据科学库

原文：www.kdnuggets.com/2020/04/five-cool-python-libraries-data-science.html

评论

作者 Dhilip Subramanian，数据科学家和人工智能爱好者

对大多数数据科学家来说，Python 是最好的朋友。库使他们的生活变得更简单。我在从事 NLP 项目时遇到了五个酷炫的 Python 数据科学库。这对我帮助很大，我希望在这篇文章中分享这些库。

---

我们的前三大课程推荐

1. Google Cybersecurity Certificate - 快速进入网络安全职业的快车道。

2. Google Data Analytics Professional Certificate - 提升您的数据分析技能

3. Google IT Support Professional Certificate - 支持您的组织进行 IT 支持

---

1. Numerizer

一个令人惊叹的库，用于将文本数字转换为整数和浮点数。对 NLP 项目非常有用。有关更多详细信息，请查看 PyPI 和这个 github 仓库。

安装

!pip install numerizer

示例

#importing numerize library
from numerizer import numerize#examplesprint(numerize(‘Eight fifty million’))
print(numerize(‘one two three’))
print(numerize(‘Fifteen hundred’))
print(numerize(‘Three hundred and Forty five’))
print(numerize(‘Six and one quarter’))
print(numerize(‘Jack is having fifty million’))
print(numerize(‘Three hundred billion’))

输出

2. Missingo

在现实世界的数据集中发现缺失值是很常见的。我们需要在插补之前理解这些缺失值。Missingo 提供了一种快速且有用的方式来可视化缺失值。

安装

!pip install missingno

使用

# importing necessary libraries
import pandas as pd 
import missingno as mi
# reading the dummy dataset
data = pd.read_excel(“dummy.xlsx”)
# checking missing values
data.isnull().sum() 

虚拟数据集包含 11 行和 4 列。缺失值出现在 Min、Temp 和 city 变量中。我们可以使用条形图和矩阵进行可视化。它还支持热图、树状图。有关更多细节，请查看这个 Github 仓库。

 #Visualizing using missingno
print(“Visualizing missing value using bar graph”)
mi.bar(data, figsize = (10,5))
print(“Visualizing missing value using matrix”)
mi.matrix(data, figsize = (10,5)) 

输出

我们可以从上面的条形图和矩阵中看到 temp、min 和 city 的缺失值。

3. Faker

我们可能会遇到需要生成一些测试数据或在分析中使用一些虚拟数据的情况。获取虚拟数据的一种方法是使用 Faker 库。当您需要时，它会非常快速地为您生成虚拟数据。

安装

 !pip install faker

示例

 **# Generating fake email**
print (fake.email()) 
**# Generating fake country name**
print(fake.country()) 
**# Generating fake name**
print(fake.name()) 
**# Generating fake text**
print(fake.text()) 
**# Generating fake lat and lon**
print(fake.latitude(), fake.longitude())
**# Generating fake url**
print(fake.url()) 
**# Generating fake profile**
print(fake.profile())
**# Generating random number**
print(fake.random_number()) 

输出

它为各种类别生成虚拟数据，请查看此链接以获取更多 详细信息。

4. EMOT

收集和分析表情符号以及表情符号可以提供有用的见解，尤其是在情感分析中。表情符号 是一种足够小的图像，可以插入文本中以表达情感或思想。表情符号 是使用仅限键盘字符（如字母、数字和标点符号）表示人脸表情的方式。

emot 帮助我们将表情符号和表情符号转换为文字。有关此库的更多详细信息，请查看这个 Github 仓库。它包含了一个好的表情符号和表情符号及其对应单词的集合。

安装

!pip install emot

使用

 **#Importing libraries**
import re
from emot.emo_unicode import UNICODE_EMO, EMOTICONS**# Function for converting emojis into word**
def convert_emojis(text):
    for emot in UNICODE_EMO:
        text = text.replace(emot, "_".join(UNICODE_EMO[emot].replace(",","").replace(":","").split()))
    return text**# Example**
text1 = "Hilarious ????. The feeling of making a sale ????, The feeling of actually fulfilling orders ????"
convert_emojis(text1) 

输出

‘Hilarious **face_with_tears_of_joy**. The feeling of making a sale **smiling_face_with_sunglasses**, The feeling of actually fulfilling orders **unamused_face**’

表情符号转换为文字形式

使用

**# Function for converting emoticons into word**
def convert_emoticons(text):
    for emot in EMOTICONS:
        text = re.sub(u'('+emot+')', "_".join(EMOTICONS[emot].replace(",","").split()), text)
    return text**# Example**
text = "Hello :-) :-)"
convert_emoticons(text) 

输出

'Hello **Happy_face_smiley** **Happy_face_smiley'**

5. Chartify

Chartify 是一个可视化库，旨在尽可能简化数据科学家创建图表的过程。与其他工具相比，它具有用户友好的语法和一致的数据格式。创建美观且快速的图表所需时间更少。这是由 Spotify 实验室开发的。

在这里，我只展示了柱状图。有关更多细节和图表，请查看这个 文档 和 笔记本

安装

!pip install chartify

使用

# importing necessary libraryimport numpy as np
import pandas as pd
import chartify
#loading example dataset from chartify
data = chartify.examples.example_data()
data.head()

# Calculating total quanity for each fruits
quantity_by_fruit = (data.groupby(‘fruit’)[‘quantity’].sum().reset_index())
ch = chartify.Chart(blank_labels=True, x_axis_type=’categorical’)
ch.set_title(“Vertical bar plot”)
ch.set_subtitle(“Automatically sorts by value counts.”)
ch.plot.bar(
 data_frame=quantity_by_fruit,
 categorical_columns=’fruit’,
 numeric_column=’quantity’)
ch.show()

输出

你可以通过点击图表右上角的保存图标来保存图表。

感谢阅读。如果你有任何补充，请随时留言！

简介： Dhilip Subramanian 是一名机械工程师，已完成分析学硕士学位。他拥有 9 年的经验，专注于数据相关的各个领域，包括 IT、营销、银行、能源和制造业。他对自然语言处理和机器学习充满热情。他是 SAS 社区 的贡献者，并喜欢在 Medium 平台上撰写有关数据科学各个方面的技术文章。

原文。经许可转载。

相关：

• 宣布 PyCaret 1.0.0

• 停止伤害你的 Pandas!

• 深度学习的四大最佳 Jupyter Notebook 环境

更多相关主题

• 每个数据科学家都应该知道的三个 R 库（即使你使用 Python）

• 成为一名伟大的数据科学家所需的五项关键技能

• 每个初学者数据科学家都应该掌握的六种预测模型

• 2021 年最佳 ETL 工具

• 停止学习数据科学，寻找目标，再找到目标去……

• 使用管道编写干净的 Python 代码

5 个你不能再忽视的深度学习项目

原文：www.kdnuggets.com/2016/07/five-deep-learning-projects-cant-overlook.html

深度学习库和框架 如 Theano、Keras、Caffe 和 TensorFlow 近年来获得了巨大的流行。事实上，谷歌的 TensorFlow 是 Github 上星标最多的机器学习仓库。数量差距很大。尽管 TensorFlow 出现的时间还不到 6 个月，但它已经占据了如此巨大的市场份额，以至于可以说它已经成为了许多经验丰富的神经网络专家和新手的默认深度学习库。

显然，这不是唯一需要考虑的库。还有许多其他库，其中一些在上面提到过。但还有许多更小的项目，从完全重新实现的库，到建立在现有深度学习项目之上的高级构建模块，以适应特定的利基市场。以下你可以找到这些项目类型的混合，它们因各种原因而被提及，这些原因是在在线时间中遇到的。

也许你会在这份不能再忽视的 5 个深度学习项目列表中找到满足你需求的东西。项目的排序没有特别的顺序，但我喜欢给事物编号，所以我就这样做了。

1. Leaf

Leaf 是一个神经网络框架，在其 Github 仓库 README 中描述为：

开放机器智能框架（GPU/CPU）

有些 有趣的是，Leaf 是一个相对较新的项目，但已经获得了超过 4000 个仓库星标，它是用 Rust 编写的。Rust 自身只有大约 6 年的历史，开发由 Mozilla 赞助。对于不熟悉 Rust 的人来说，它是一个系统编程语言，与 C 和 C++ 有相似之处，自我描述为：

Rust 是一种系统编程语言，运行速度极快，防止段错误，并保证线程安全。

一本书，Leaf Machine Learning for Hackers，可以在线免费获得，很可能是那些想尝试 Leaf 的人不错的首选。我猜测即使 Leaf 声称和定量支持其比其他类似框架更快（见上图），它也不会从 Rust 生态系统外获得大量转化。然而，Rust 用户的数量持续增长，毫无疑问其中一些人会对构建神经网络感兴趣。知道他们有一个高质量的本地框架可以用于这个目标是很好的。

2. tiny-cnn

来自 tiny-cnn 的 GitHub 仓库：

tiny-cnn 是一个用 C++11 实现的深度学习库。它适合在计算资源有限的环境、嵌入式系统和 IoT 设备上进行深度学习。

tiny-cnn 在没有 GPU 的情况下运行相对较快；在 CPU 上训练 13 分钟，MNIST 数据集的准确率达到了 98.8%。它的使用也很简单。由于它是一个仅包含头文件的库，你只需包含 tiny_cnn.h 头文件并编写你的 C++ 代码，无需安装其他东西。tiny-cnn 支持多种网络架构、激活函数和优化算法。

这里有一个构建多层感知器的快速示例：

#include "tiny_cnn/tiny_cnn.h"
using namespace tiny_cnn;
using namespace tiny_cnn::activation;

void construct_mlp() {
    auto mynet = make_mlp<tan_h>({ 32 * 32, 300, 10 });

    assert(mynet.in_data_size() == 32 * 32);
    assert(mynet.out_data_size() == 10);
}

查看 文档，以及 这个项目，它使用 tiny-cnn 实现了一个 Android 上的卷积神经网络。如果你决定在 C++ 中实现神经网络，这个值得一看。

3. Layered

Layered 的作者是独立的机器学习研究员 Danijar Hafner，他最近向 KDnuggets 贡献了一篇文章 "Introduction to Recurrent Networks in TensorFlow"。

Layered 是：

前馈神经网络的干净实现。

Hafner 用 Python 3 编写了 Layered，作为一种“干净和模块化的前馈神经网络实现”。他表示，自己启动了这个项目，以便更好地理解深度学习概念，并推荐如果你对深入了解深度神经网络的实际功能感兴趣的话，也这样做。

下面是一个在 Layered 中实现简单神经网络的示例：

from layered.network import Network
from layered.activation import Identity, Relu, Softmax

num_inputs = 784
num_outputs = 10

network = Network([
    Layer(num_inputs, Identity),
    Layer(700, Relu),
    Layer(500, Relu),
    Layer(300, Relu),
    Layer(num_outputs, Softmax),
])

该项目目前支持身份、修正器、sigmoid 和 softmax 激活函数，以及平方误差和交叉熵损失函数。因此，如果你想查看一个从头开始实现神经网络功能的无废话代码，Layered 将是一个很好的起点。这个项目的实际有效性和积极开发的状态也是值得更多关注的原因。

Hafner 还提供了许多关于实用的 TensorFlow 深度学习教程，我建议你去看看。

4. Brain

我最近分享了一些相关的 Javascript 机器学习库，其中包括了 3 个神经网络库（总共 5 个）。Brain 本可以出现在这个列表中，但为了提供一些多样性，它被单独添加在这里。

Brain 是一个用 Javascript 编写的神经网络库，适用于浏览器或 Node。该项目正在积极开发中，源于一个较早的、不够成熟的 同名项目。

这是一个使用 Brain 近似异或（XOR）函数的示例：

var net = new brain.NeuralNetwork();

net.train([{input: [0, 0], output: [0]},
{input: [0, 1], output: [1]},
{input: [1, 0], output: [1]},
{input: [1, 1], output: [0]}]);

var output = net.run([1, 0]); // [0.987]

Brain 支持隐藏层，默认使用一个（除非另有说明）。训练一个网络很简单（如上所示），选项可以轻松设置并作为哈希传递：

net.train(data, {
  errorThresh: 0.005,  // error threshold to reach
  iterations: 20000,   // maximum training iterations
  log: true,           // console.log() progress periodically
  logPeriod: 10,       // number of iterations between logging
  learningRate: 0.3    // learning rate
})

Train 还会返回一个包含训练结果的哈希。网络可以通过 JSON 序列化。

如果你是一个希望实现神经网络的 Javascript 开发者，Brain 可能是你需要的库。你还可以查看上述文章，其中包含一些通用的机器学习库以及一些额外的神经网络库。

5. neon

由 Nervana 开发的快速、可扩展、易于使用的基于 Python 的深度学习框架。

neon 无疑是最快的： “为了快速迭代和模型探索，neon 在深度学习库中具有最快的性能。” 如果你还不熟悉这个库，这绝对是值得一看的理由。

neon 由Nervana Systems开发，支持卷积、RNN、LSTM、GRUs 等。neon 还有许多其他优点：它有一个很棒的工作流概述，文档非常详尽，并且有一些有用的教程。

你还可以查看来自 neon 深度学习聚会的多个Jupyter notebook 版本，这很不错。如果训练神经网络的速度对你很重要，并且你在 Python 生态系统中，可以查看 neon。

相关：

• 5 个你不能再忽视的机器学习项目

• 5 个你不能再忽视的机器学习项目

• Javascript 的顶级机器学习库

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

更多关于此主题的信息

• 数据科学项目，帮助你解决现实世界问题

• 9 个职业证书可以让你获得学位…如果…

• 如何使用机器学习自动标记数据

• 7 个你不能错过的机器学习算法

• 2024 年你可以参加的 5 个顶级机器学习课程

• 2022 年通过构建 15 个神经网络项目学习深度学习

5 个你不能再忽视的机器学习项目，四月

原文：www.kdnuggets.com/2017/04/five-machine-learning-projects-cant-overlook-april.html

是时候再次呈现 "5 个你不能再忽视的机器学习项目" —— 这个谦虚的任务旨在将一些强大的鲜为人知的机器学习项目展示给更多人 —— 这次是针对 2017 年四月。之前的列表包括了通用的和专门的机器学习与深度学习库，以及辅助支持、数据清洗和自动化工具。

本次我们展示了 5 个你可能还未听说的机器学习相关项目，包括来自不同生态系统和编程语言的项目。你可能会发现，即使你对这些特定工具没有需求，检查它们的广泛实现细节或特定代码也可能帮助你生成一些自己的想法。与上一次一样，除了那些在我花时间在线时引起我注意的项目外，没有正式的纳入标准，项目必须有 Github 仓库。是的，这很主观，但没有任何定性的方法能使这个任务变得有意义。

不再赘述，以下是：你应该考虑查看的另外 5 个机器学习项目。它们没有特定顺序，但编号是为了让它们看起来有序，这主要是为了缓解我对未编号列表的焦虑。

1. Scikit-plot

Scikit-plot 是一个非艺术性数据科学家深刻认识到可视化是数据科学过程中的关键组成部分之一的结果，而不仅仅是一个附加的想法。

我第一次通过作者在 Reddit 上的帖子遇到 Scikit-plot，并几乎立即开始使用它。该项目旨在为 Scikit-learn 用户提供一系列标准且有用的图表，毫无麻烦，因为我们都对使用这些图表感兴趣。库中包含的图表示例包括：

• 肘部图

• 特征重要性图

• PCA 投影图

• ROC 曲线

• 轮廓图

该库有 2 个 API，其中一个与 Scikit-learn 的集成非常紧密，以便控制对其 API 的调用（工厂 API）。另一个 API 更为传统（函数 API），但根据你的需求任选其一即可。

在这里找到快速入门指南，了解你需要的一切以开始使用这个有前景的小库。

2. scikit-feature

scikit-feature 是一个由亚利桑那州立大学数据挖掘与机器学习实验室开发的开源特征选择库，使用 Python 语言。它建立在广泛使用的机器学习包 scikit-learn 和两个科学计算包 Numpy 及 Scipy 的基础上。scikit-feature 包含大约 40 种流行的特征选择算法，包括传统特征选择算法以及一些结构性和流式特征选择算法。

尽管所有特征选择方法都有一个共同的目标，即识别冗余和无关的特征，但存在许多算法来处理这些相关问题——这是一个活跃的研究领域。在这方面，scikit-feature 既适用于实际的特征选择，也适用于特征选择算法的研究。该项目有一个由 ASU 托管的 网站，最初是在 MATLAB 中构思的，但后来移植到了 Python 生态系统。可以在 这里 找到 scikit-feature 支持的算法列表。

数据科学家 Rubens Zimbres 最近如此生动地 表达了（强调部分）：

经过一些经验，使用堆叠神经网络、并行神经网络、不对称配置、简单神经网络、多层、丢弃、激活函数等，有一个结论：没有什么能比好的特征选择更重要。

3. Smile

Smile（统计机器智能与学习引擎）是一个快速且全面的机器学习系统。凭借先进的数据结构和算法，Smile 提供了最先进的性能。

Smile 涵盖了机器学习的各个方面，包括分类、回归、聚类、关联规则挖掘、特征选择、流形学习、多维缩放、遗传算法、缺失值填补、高效最近邻搜索等。

现在，Smile 似乎成为了在 Java 和 Scala 世界中工作的人们的首选通用机器学习库——可以说是 JVM 上的 Scikit-learn。该项目拥有一个非常全面的 教程网站，不仅涵盖了 Smile 的操作，还作为机器学习算法的一种优质介绍。

如果你在 JVM 上进行机器学习，Smile 绝对值得一看。我实际上很难相信你在那个生态系统中工作却不知道这个项目。

4. Gensim

Gensim 是一个用于主题建模、文档索引和大规模语料库相似性检索的 Python 库。目标用户是自然语言处理（NLP）和信息检索（IR）社区。

Gensim 具有多功能且旨在完备性，它实现了“[e]fficient multicore implementations of popular algorithms, such as online Latent Semantic Analysis (LSA/LSI/SVD), Latent Dirichlet Allocation (LDA), Random Projections (RP), Hierarchical Dirichlet Process (HDP) or word2vec deep learning.”

Gensim 的文档可以在 这里 找到。你可以在 KDnuggets 上找到去年的 Gensim 初学者主题建模教程（由 Gensim 的开发者撰写）这里。

5. Sonnet

从 Sonnet 开源的博客公告中可以看到：

自 2015 年 11 月首次发布以来，围绕 TensorFlow 迅速发展了一个多样化的高级库生态系统，使得常见任务可以更快地完成。Sonnet 与这些现有的神经网络库有许多相似之处，但也有一些专门针对我们研究需求的特性。随我们的《学习学习》论文发布的代码包含了 Sonnet 的初步版本，其他即将发布的代码将基于我们今天发布的完整库。

DeepMind 已经开源了它的高级 TensorFlow 库，尽管该组织承认它类似于其他类似的库，但它实现了他们所需的功能，特别是：

循环神经网络的状态通常最好表示为异构张量的集合，将这些表示为平面列表可能容易出错。Sonnet 提供了处理这些任意层次结构的工具[.]

希望这篇文章让你对一些你以前不知道的库或一些你没有意识到自己想要的功能有了新的认识。

相关：

• 5 个你不能再忽视的机器学习项目，1 月

• 5 个你不能再忽视的机器学习项目

• 5 个你不能再忽视的机器学习项目

---

我们的前 3 个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业轨道

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你所在组织的 IT 部门

---

更多此主题的信息

• 每个数据科学家都应该了解的三个 R 语言库（即使你使用 Python）

• 停止学习数据科学以寻找目标，并通过寻找目标来…

• 学习数据科学统计的顶级资源

• 一项 90 亿美元的 AI 失败，详细分析

• 构建一个坚实的数据团队

• 使用管道编写干净的 Python 代码

5 个你不能再忽视的机器学习项目，1 月

原文：www.kdnuggets.com/2017/01/five-machine-learning-projects-cant-overlook-january.html

"5 个你不能再忽视的机器学习项目"的前几篇文章揭示了许多鲜为人知的机器学习项目，包括通用和专用的机器学习库以及深度学习库，还有辅助支持、数据清理和自动化工具。经过一段时间的停歇，我们认为这个话题值得再次关注。

本文将展示 5 个你可能尚未听说过的机器学习项目，包括来自多个不同生态系统和编程语言的项目。即使你对这些特定工具没有需求，检查它们的广泛实现细节或具体代码也可能帮助你产生一些自己的想法。与之前的版本一样，除了我在网上花时间时发现的有趣项目外，没有其他正式的纳入标准，所有项目都有 GitHub 仓库。确实是主观的。

不再废话，这里是它们：你应该考虑查看的另外 5 个机器学习项目。它们没有特定的顺序排列，但为了方便起见，标了编号，因为编号让我有一种内心的平静，这种平静我至今仍不完全理解。

1. Hyperopt-sklearn

Hyperopt-sklearn 是基于 Hyperopt 的模型选择工具，用于 scikit-learn 项目中的机器学习算法。直接来自该项目的 文档：

为你的数据找到合适的分类器可能很困难。一旦你选择了一个分类器，调整所有参数以获得最佳结果是繁琐且耗时的。即使在你辛苦工作之后，你可能一开始就选择了错误的分类器。Hyperopt-sklearn 提供了一个解决方案。

Hyperopt-sklearn 使用多种搜索算法，可以搜索所有（支持的）分类器或仅在给定分类器的参数空间内搜索，并支持如 PCA、TfidfVectorizer、Normalizer 和 OneHotEncoder 等多种预处理步骤。

它有效吗？

下表展示了在 20 个新闻组数据集上，使用 scikit-learn 默认参数和 hyperopt-sklearn 优化参数的分类器获得的 F1 分数。hyperopt-sklearn 的结果来自于一次运行中的 25 次评估。

Hyperopt-sklearn 需要非常少的额外代码就能运行，并且有一些方便的 快速启动代码 来帮助入门。

2. Dlib

Dlib 是一个通用工具包，用于在 C++ 中创建机器学习和数据分析应用程序。也就是说，它是用 C++ 编写的。不过不用担心，它也有一个 Python API。

来自 官方网站：

Dlib 是一个现代 C++ 工具包，包含机器学习算法和工具，用于在 C++ 中创建复杂的软件以解决实际问题。它被广泛应用于工业和学术界，涵盖包括机器人技术、嵌入式设备、手机以及大型高性能计算环境等多个领域。

文档达到标准，API 解释得很好，项目还附带一个 简明介绍。此外，还有一个 博客，概述了一些使用该库的有趣项目。Dlib 也不是新项目；它自 2002 年以来一直在开发。

鉴于它提供的广泛算法，我很感兴趣看到与 scikit-learn 的执行时间对比。有兴趣吗？有人吗？

3. NN++

继续使用 C++，NN++ 是一个小巧且易于使用的神经网络实现。无需安装，只需下载并 #include。

来自其代码库：

一个简短、自包含且易于使用的 C++ 神经网络实现。它包括神经网络实现和一个用于基本线性代数操作的 Matrix 类。这个项目主要用于学习目的，但在 MNIST 数据集上的初步测试结果显示出一些潜力。

它的文档比较稀疏，但对附带的 Matrix 类的使用有一些额外的解释。一些代码片段解释了如何设置和查询神经网络。代码很简洁，因此对于那些希望了解简单神经网络的内部机制或希望从其他语言直接迁移到 C++ 实现网络的人来说，这个项目是一个不错的选择。

4. LightGBM

LightGBM 是微软实现的梯度提升树算法。来自代码库的描述：

一个快速、分布式、高性能的梯度提升 (GBDT, GBRT, GBM 或 MART) 框架，基于决策树算法，用于排名、分类以及许多其他机器学习任务。它属于微软的 DMTK (github.com/microsoft/dmtk) 项目。

LightGBM 使用 C++ 和 Python 编写，提供了 快速入门指南、并行学习指南 和质量 功能概述。

但它的表现如何？

实验 在公共数据集上显示，LightGBM 在效率和准确性方面可以超越其他现有的提升框架，并且显著降低了内存消耗。此外， 实验 显示，LightGBM 可以通过在特定设置下使用多台机器进行训练，实现线性加速。

LightGBM 和微软分布式机器学习工具包的其他组件一样，具有许多看似值得关注的特性。

5. Sklearn-pandas

到目前为止，这些项目都是通用的机器学习工具包或特定算法的实现。这个项目稍有不同，它在机器学习任务中扮演支持角色。

Sklearn-pandas 是一个积极开发的模块，它“提供了一个 Scikit-Learn 的机器学习方法和 pandas 风格的数据框之间的桥梁。”

更多来自仓库的信息：

特别是，它提供：

1. 一种将 DataFrame 列映射到转换的方法，这些转换随后重新组合成特征。
3. 为旧版 scikit-learn 提供的兼容性适配层，用于交叉验证一个以 pandas DataFrame 为输入的管道。这仅在 scikit-learn<0.16.0 时需要（详细信息见 #11）。该功能已被弃用，并可能在 skearn-pandas==2.0 中删除。

实际使用中，它的作用是将列映射到转换。以下是 Gitub 仓库中的一段代码示例：

array([[ 1\.  ,  0\.  ,  0\.  ,  0.21],
       [ 0\.  ,  1\.  ,  0\.  ,  1.88],
       [ 0\.  ,  1\.  ,  0\.  , -0.63],
       [ 0\.  ,  0\.  ,  1\.  , -0.63],
       [ 1\.  ,  0\.  ,  0\.  , -1.46],
       [ 0\.  ,  1\.  ,  0\.  , -0.63],
       [ 1\.  ,  0\.  ,  0\.  ,  1.04],
       [ 0\.  ,  0\.  ,  1\.  ,  0.21]])

请注意，前三列是 LabelBinarizer 的输出（分别对应 cat、dog 和 fish），第四列是子女数量的标准化值。通常，列的顺序按照构造 DataFrameMapper 时给定的顺序排列。

希望你在这些项目中找到了感兴趣的内容。祝你机器学习愉快！

相关：

• 5 个你不能再忽视的机器学习项目

• 5 个你不能再忽视的机器学习项目

• 5 个你不能再忽视的深度学习项目

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业的捷径

2. 谷歌数据分析专业证书 - 提升你的数据分析水平

3. 谷歌 IT 支持专业证书 - 支持你的组织进行 IT 方面的工作

---

更多相关主题

• 成为一名优秀数据科学家所需的 5 个关键技能

• 每个初学者数据科学家都应掌握的 6 个预测模型

• 2021 年最佳 ETL 工具

• 每个数据科学家都应该知道的三个 R 库（即使你使用 Python）

• 停止学习数据科学以寻找目标，并通过寻找目标来……

• 学习数据科学统计的最佳资源

5 个你不能再忽视的机器学习项目，五月

原文：www.kdnuggets.com/2017/05/five-machine-learning-projects-cant-overlook-may.html

更多被忽视的机器学习和/或与机器学习相关的项目？听起来很棒！

这次我们就不做冗长的介绍了，直接说这些项目的选择没有其他标准，除了它们随着时间的推移引起了我的注意；实际上，任何客观的标准都不适用于这种情况。唯一的要求是这些项目是开源的，并且有 Github 仓库。

所以它们来了：再多五个……你知道接下来的事情。你也许还记得，它们的编号不是因为相对顺序的需要，而是因为我的治疗师建议这是应对我对非编号列表的恐惧的最佳方法。

1. pandas-profiling

“从 pandas DataFrame 对象创建 HTML 配置报告”，因为 pandas 的 describe() 函数有点不足。来自仓库自述文件：

对于每一列，以下统计数据（如果与列类型相关）会以交互式 HTML 报告的形式呈现：

• 基本信息： 类型、唯一值、缺失值
• 分位数统计数据 如最小值、Q1、中位数、Q3、最大值、范围、四分位数范围
• 描述性统计数据 如均值、众数、标准差、总和、中位数绝对偏差、变异系数、峰度、偏度
• 最频繁的值
• 直方图

pandas-profiling 易于安装且使用简单，它可能是任何 Python 爱好者数据探索工具箱中的有用补充。可以在 这里 找到一个使用 Jupyter notebook 的简单示例。或者，输出可以被导出到 HTML 文件以供保存。

对于那些定期在 Python 生态系统中处理和探索数据并寻求一些快速且简便总结的人来说，绝对值得考虑。

2. Gym

你听说过 OpenAI 的 Gym……但它是什么？

OpenAI Gym 是一个用于开发和比较强化学习算法的工具包。 这是 gym 的开源库，它让您可以访问不断增长的各种环境。

如果你对强化学习很认真，你已经知道了。但如果没有：

gym 不对您的代理结构做任何假设，并且与任何数值计算库兼容，例如 TensorFlow 或 Theano。您可以通过 Python 代码使用它，并且很快可以从其他语言中使用。

OpenAI 提供了算法框架。它具有可扩展性和灵活性，可以玩简单的 Flash 和 Atari 游戏到棋盘游戏等各种游戏。了解更多关于 Gym 的信息这里。它的文档在这里，FAQ在这里。你还可以阅读一篇白皮书，在这里。

3. autosklearn-zeroconf

如果你不知道——实际上，为什么会知道呢？——我是自动化机器学习的粉丝（AutoML）。这是一个展示巨大未来潜力的机器学习（和数据科学）领域，并且今天已经开始见效。像 TPOT 和 auto-sklearn 这样的项目是入门的好地方，也是自动化自动化的首要步骤之一（尽管 AutoML 已经存在很长时间了）。

Paypal 的 autosklearn-zeroconf 是这个领域的另一个项目（实际上是基于前面提到的 auto-sklearn）：

autosklearn-zeroconf 是一个完全自动化的二分类器，基于 AutoML 挑战赛获胜者 auto-sklearn。给它一个已知结果（标签）的数据集，它会调整大规模并行的数据科学机器学习管道。因此，你将获得新数据的预测结果列表和一个估计的预测精度。

虽然我还没有玩过这个项目，但我计划在不久的将来进行尝试并分享我的发现。与此同时，我对听听任何人的看法感兴趣——除了它看起来是我们都想尝试的东西。

4. Dora

多拉。探险者。对吗？

直接来自 Github 的 readme：

Dora 是一个旨在自动化探索性数据分析中痛苦部分的 Python 库。

该库包含用于数据清洗、特征选择与提取、可视化、数据分割以进行模型验证和数据转换版本控制的便利功能。

该库使用并旨在成为常见 Python 数据分析工具（如 pandas、scikit-learn 和 matplotlib）的有用补充。

使用起来也很简单。尽管它涵盖了大量的数据准备工作，但其数据转换的版本控制看起来特别新颖。查看 Dora 在repo 的 readme中易于跟随的示例代码。

5. BigDL

来自 Intel 的另一个深度学习框架，针对 Apache Spark 的分布式优化。从 readme 中：

BigDL 是一个针对 Apache Spark 的分布式深度学习库；使用 BigDL，用户可以将他们的深度学习应用程序作为标准 Spark 程序编写，这些程序可以直接在现有的 Spark 或 Hadoop 集群上运行。

• 丰富的深度学习支持
• 极高的性能
• 高效的扩展能力

需要一些理由来说明为什么你可能会选择 BigDL 而不是众多现有的深度学习库吗？这个主题的演示文稿幻灯片可能会有所帮助：

查看 快速入门指南 以获得简要概述。API 指南可以在 这里 找到。

相关：

• 你不能再忽视的 5 个机器学习项目，4 月

• 你不能再忽视的 5 个机器学习项目，1 月

• 你不能再忽视的 5 个机器学习项目

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你组织的 IT 需求

---

更多相关话题

• 可以帮助你解决实际问题的数据科学项目

• 9 个职业证书可以带你进入学位...如果...

• 如何使用机器学习自动标记数据

• 你不能错过的 7 种机器学习算法

• 2024 年你可以参加的 5 个顶级机器学习课程

• 2024 年你不能错过的 5 个 AI 播客

5 个你不能再忽视的机器学习项目

原文：www.kdnuggets.com/2016/05/five-machine-learning-projects-cant-overlook.html

一般来说，流行的机器学习项目之所以流行，是因为它们提供了广泛的所需服务，或者它们是第一个（或可能是最好的）为用户提供某个特定专业服务的项目。这些流行的项目包括 Scikit-learn、TensorFlow、Theano、MXNet（也许？）、Weka（以前）等等。根据你所工作的特定生态系统和你的机器学习目标，你认为流行的项目可能会有所不同；然而，它们都有一个共同点，那就是它们为大量用户提供服务。

不过，确实存在各种规模较小的机器学习项目正在被人们构建和使用：管道、包装器、高级 API、清理工具等等。它们提供了专业和灵活的服务，通常面向较少的用户，因各种原因而异。这篇文章将介绍 5 个这样的较小项目，以便读者熟悉。

我并不是建议你去尝试所有（或任何）这些项目；如果你有某些特定需求，而恰好在这个列表中找到一个对应的工具，那么尽管试试。真正的价值在于查看这些项目提供了什么、它们是如何实现的，以及其他人是如何构建以适应他们的生态系统的。你可能会得到一些关于自己项目的好主意。但最好的情况是：这里的某些项目完美地满足了需求，感谢这些开发者的工作，你解决了一个问题。

对于这些项目没有真实的标准，我很抱歉地报告。这些仅仅是我在过去几个月中注意到的一些有趣项目的集合，觉得足够有前景而分享给读者。此外，请注意，我对 Python 生态系统非常投入，因此这些工具也相应地被发现。我对 R、C++ 或任何其他特定环境所提供的项目没有任何偏见（未来可能会发现并分享这些项目）；不过，这个列表是基于我在互联网漫游时寻找有用工具的结果，比较泛泛地汇总而成。

所以，这里是：5 个你绝对应该查看的机器学习项目，顺序不重要（但按顺序编号，因为我喜欢编号）：

1. Deepy

Deepy 是一个基于 Theano 的可扩展深度学习框架。它为 LSTM、批量归一化和自编码器等组件提供了一个干净的高层接口。Deepy 显然旨在简洁，其文档和示例也旨在如此。它还有一个姊妹项目，使用 Deepy 实现了深度递归注意力作家（DRAW）生成模型。

作为 Deepy 简洁性和干净性的一个例子，这里是项目 GitHub 上一个包含 dropout 的多层模型示例：

# A multi-layer model with dropout for MNIST task.
from deepy import *

model = NeuralClassifier(input_dim=28*28)
model.stack(Dense(256, 'relu'),
            Dropout(0.2),
            Dense(256, 'relu'),
            Dropout(0.2),
            Dense(10, 'linear'),
            Softmax())

trainer = MomentumTrainer(model)

annealer = LearningRateAnnealer(trainer)

mnist = MiniBatches(MnistDataset(), batch_size=20)

trainer.run(mnist, controllers=[annealer])

</br class="blank" />

你可能已经听说过 Deepy；截至撰写本文时，它的 GitHub 仓库已有 305 个星标，被分叉了 51 次。该项目是高层次深度学习 API 和包装器的一个不错示例，这些 API 和包装器正变得越来越普及（或似乎如此）。Deepy 的作者是 Raphael Shu。

2. MLxtend

Sebastian Raschka 汇集了 MLxtend，他迅速指出这是一项正在进行中的工作，但也试图覆盖许多不同的功能。MLxtend 是一个用于机器学习任务的有用工具和扩展的集合。

Sebastian 共享了以下内容，关于项目的起源及其目标：

本质上，这只是与机器学习和数据科学相关的有用工具和参考实现的集合。我为什么会想到这个？有几个原因：

1. 实现了一些我在其他地方找不到的算法（例如，序列特征选择算法，多数投票分类器，堆叠估计器，绘制决策区域，...）
3. 教学目的的实现（逻辑回归，softmax 回归，多层感知机，PCA，核 PCA...）；这些实现侧重于代码可读性，而非纯粹效率
5. 便捷的包装器：tensorflow softmax 回归和多层感知机，pandas 数据框的列标准化

这基本上是一个常用的通用机器学习函数库，Sebastian 编写并频繁使用。此外，Sebastian 非常喜欢编码，并认为如果他将这个“动物园”（如他所称）提供给他人，他可能会保持代码比平时“整洁”。

许多实现的函数与 scikit-learn 的 API 相似，但未来添加的功能不一定会受此限制。主要信息：Sebastian 承诺还有更多的内容即将推出……所以请继续关注。Sebastian 可能玩弄的任何特性或新算法都有很大机会被打包到 MLxtend 中。

3. datacleaner

datacleaner 是研究员Randal Olson的作品，他还负责了出色的 TPOT 机器学习管道项目。Olson 将 Data Cleaner 称为“一个自动清理数据集并为分析做好准备的 Python 工具。”他迅速声明这不是魔法，但也指出了它能做的事情：

datacleaner 的功能是节省你在数据已经以 pandas DataFrames 能够处理的格式中进行编码和清理的时间。

datacleaner 仍在开发中，但目前能够处理以下常规（且耗时的）数据清理操作：可选地删除具有缺失值的行；按列将缺失值替换为众数或中位数；用数值等效物编码非数值变量。Randal 告诉我们他正在寻找贡献者，特别是那些对 datacleaner 可以以自动化方式执行的数据清理操作有更多想法的人。

Randal 对细节的关注是任何阅读过他的博客或 Github 仓库的人都知道的，这个项目的简明文档也不例外。我最近一直在使用 datacleaner，到目前为止它兑现了承诺。

4. auto-sklearn

auto-sklearn 是为 Scikit-learn 环境提供的自动化机器学习工具。

auto-sklearn 使机器学习用户无需选择算法和调整超参数。它利用了贝叶斯优化、元学习和集成构建的最新优势。通过阅读这篇在NIPS 2015上发布的论文，了解更多关于 auto-sklearn 背后的技术。

其文档相当详尽，并且该仓库包含了几个简洁的示例。我承认我还没有使用过，但许多人已经使用过；它在 Github 上收获了近 400 个星标。鉴于我对 Scikit-learn 的偏爱，我想我将在不久的将来尝试这个。

auto-sklearn 主要由弗莱堡大学的自动化算法设计机器学习小组开发。

5. 深度挖掘

Deep Mining 是一个机器学习管道自动调整器，由 MIT CSAIL 实验室的Sebastien Dubois带来。来自仓库的说明：

这个软件会迭代而智能地测试一些超参数集，以尽可能快地找到最佳的超参数组合，从而实现管道能提供的最佳分类准确性。

深度挖掘（Deep Mining）似乎不是一个广为人知的项目，鉴于其相对少量的仓库星标；然而，鉴于它源于 CSAIL，并且在过去一个月内有开发活动，值得将其与其他类似的自动化管道工具进行基准测试。它提供了一些示例，使用起来似乎也很直接。

关于使用的方法：

文件夹 GCP-HPO 包含了所有实现高斯 Copula 过程（GCP）和基于此的超参数优化（HPO）技术的代码。高斯 Copula 过程可以看作是高斯过程的改进版本，它不对边际分布假设高斯先验，而是基于更复杂的先验。这项新技术被证明在超参数优化中优于基于 GP 的方法，而 GP 本身已经远远优于随机搜索。

一篇关于 GCP 方法的论文即将发布。

相关：

• GitHub 上的十大机器学习项目

• TPOT：一个用于自动化数据科学的 Python 工具

• 十大 IPython Notebook 数据科学和机器学习教程

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

更多相关话题

• 可以帮助你解决实际问题的数据科学项目

• 9 个可以让你获得学位的职业证书… 如果…

• 如何利用机器学习自动标记数据

• 7 个你不能错过的机器学习算法

• 2024 年你可以参加的五大顶级机器学习课程

• 2024 年你不能错过的前 5 个 AI 播客

5 个你不能再忽视的机器学习项目

原文：www.kdnuggets.com/2016/06/five-more-machine-learning-projects-cant-overlook.html

上个月的文章 "5 个你不能再忽视的机器学习项目" 受到了广泛好评，内容涉及 Python 生态系统中的 5 个鲜为人知的机器学习项目，包括深度学习库、辅助支持、数据清理和自动化工具。因此，我们认为有必要做一个后续文章，这次将范围扩展到更多领域。

本文将展示 5 个你可能尚未听说的机器学习项目。然而，这次这些项目将涵盖多个不同的生态系统和编程语言，而不仅仅专注于 Python 工具。即使你对这些特定工具没有需求，检查它们的广泛实现细节或特定代码可能会帮助你产生一些自己的想法。像之前的版本一样，除了那些在网上时间中引起我注意的项目之外，没有正式的选择标准，并且这些项目都有 Github 仓库。这是主观的，确实如此。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业道路。

2. Google 数据分析专业证书 - 提升你的数据分析能力

3. Google IT 支持专业证书 - 支持你的组织的 IT 需求

---

这里是：5 个你应该考虑查看的机器学习项目。它们的顺序没有特定要求，但为了方便起见，进行了编号，因为编号本身就是重点。

1. Rusty Machine

Rusty Machine 是Rust中的机器学习库。Rust 本身只有约 6 年的历史，开发由 Mozilla 资助。对于不熟悉 Rust 的人，它是一种与 C 和 C++ 相似的系统语言，自我描述为：

Rust 是一种系统编程语言，运行速度极快，防止段错误，并保证线程安全。

Rusty Machine 正在积极开发，目前支持多种学习技术，包括线性回归、逻辑回归、K-均值聚类、神经网络、支持向量机等。该项目相对较新，目前将交叉验证和数据处理等功能留给用户。该项目还拥有完善的文档。

支持的数据结构，如向量和矩阵，都是内置的。Rusty Machine 提供了每个支持的模型的训练和预测功能，作为模型的通用接口。如果你是一个寻找通用机器学习库的 Rust 用户，下载 Rusty Machine并试用一下。

2. scikit-image

scikit-image 是 SciPy 中的 Python 图像处理库。scikit-image 本身是否属于机器学习？好吧，请记住这是一个机器学习项目的列表（没有什么实际上说它们 必须 执行机器学习），并回忆一下之前的文章也包括了支持项目，如数据处理和准备工具。scikit-image 也属于这个类别。该项目包含了许多图像处理算法，如点检测、滤波器、特征选择和形态学。

这篇来自 y-hat 的文章 对 scikit-image 的图像处理进行了很好的概述。该文章还认识到图像处理在机器学习中的重要性：

强调重要特征和稀释噪声特征是良好特征设计的核心。在机器视觉的背景下，这意味着图像预处理扮演了重要角色。在从图像中提取特征之前，能够增强图像，使得对机器学习任务重要的方面突出，非常有用。

这是一个使用 scikit-image 过滤图像的快速示例：

from skimage import data, io, filters

image = data.coins() # or any NumPy array!
edges = filters.sobel(image)
io.imshow(edges)
io.show()

如果你有兴趣使用 scikit-image 进行图像处理任务，我建议参考项目文档和y-hat 文章作为好的起点。

3. NLP Compromise

NLP Compromise 是用 Javascript 编写的，可以在浏览器中进行自然语言处理。它拥有一个完整文档的 API，正在积极开发，并且有一个正在进行的 wiki，承诺提供一些额外的有用信息。

NLP Compromise 非常容易安装和使用。以下是一组简短的示例：

let nlp = require('nlp_compromise'); // or nlp = window.nlp_compromise

nlp.noun('dinosaur').pluralize();
// 'dinosaurs'

nlp.verb('speak').conjugate();
// { past: 'spoke',
//   infinitive: 'speak',
//   gerund: 'speaking',
//   actor: 'speaker',
//   present: 'speaks',
//   future: 'will speak',
//   perfect: 'have spoken',
//   pluperfect: 'had spoken',
//   future_perfect: 'will have spoken'
// }

nlp.statement('She sells seashells').negate().text()
// "She doesn't sell seashells"

nlp.sentence('I fed the dog').replace('the [Noun]', 'the cat').text()
// 'I fed the cat'

nlp.text('Tony Hawk did a kickflip').people();
// [ Person { text: 'Tony Hawk' ..} ]

nlp.noun('vacuum').article();
// 'a'

nlp.person('Tony Hawk').pronoun();
// 'he'

该项目的 GitHub 仓库获得了大量的 stars（接近 6,000），它被 一些下游项目 采用也让人放心。浏览器中的 NLP 可能再也不会变得更简单或更轻量级。

4. Datatest

这很有趣。Datatest 是基于测试驱动的数据处理，在 Python 中。

来自项目文档：

Datatest 扩展了标准库的 unittest 包，提供了用于断言数据正确性的测试工具。

Datatest 有 详细的文档，也许最好的了解方法是 查看示例。

import datatest

def setUpModule():
    global subjectData
    subjectData = datatest.CsvSource('users.csv')

class TestUserData(datatest.DataTestCase):
    def test_columns(self):
        self.assertDataColumns(required={'user_id', 'active'})

    def test_user_id(self):
        def must_be_digit(x):  # <- Helper function.
            return str(x).isdigit()
        self.assertDataSet('user_id', required=must_be_digit)

    def test_active(self):
        self.assertDataSet('active', required={'Y', 'N'})

if __name__ == '__main__':
    datatest.main()

你可以查看 这里所有可用的断言方法列表。

Datatest 是一种不同的数据处理和准备方式。不过，由于你可能会花费大量时间在这个任务上，也许值得尝试一下新的方法。

5. GoLearn

在我们收集的非 Python 机器学习库和/或框架中，GoLearn 是一个通用的机器学习库，适用于 Go。

这是 GoLearn 对自己的描述：

GoLearn 是一个“内置电池”的 Go 机器学习库。简洁性与可定制性是我们的目标。我们正在积极开发中，欢迎用户提出意见。

对于考虑拓展的 Python 用户以及希望转向机器学习的 Go 用户来说，有一个好消息：GoLearn 实现了熟悉的 Scikit-learn Fit/Predict 接口，支持快速的估算器测试和切换。它还允许平滑过渡，并使得专注于 Go 的用户可以利用所有的 Scikit-learn 教程材料，而无需重新创建基础的实际机器学习概念指令。

GoLearn 是一个足够成熟的项目，它提供了交叉验证和训练/测试拆分的辅助函数，而相对较新的 Rusty Machine 尚未实现这些功能。你是想在 Go 中进行一些机器学习，还是寻找一个借口来尝试 Go 语言？GoLearn 可能正是你所需要的。

相关：

• 5 个你不能忽视的机器学习项目

• Javascript 顶级机器学习库

• 10 必备的数据科学技能（更新）

更多相关话题

• 可以帮助你解决实际问题的数据科学项目

• 为什么越来越多的开发者在机器学习项目中使用 Python？

• 9 个专业证书可以帮助你获得学位……如果……

• 如何使用机器学习自动标记数据

• 你不能错过的 7 种机器学习算法

• 2024 年你可以参加的 5 个顶级机器学习课程

有效数据科学经理的五个迹象

原文：www.kdnuggets.com/2022/06/five-signs-effective-data-science-manager.html

由 pikisuperstar 创建的生产力矢量

时代迅速变化，如今的职位名称和职责并不完全取决于经验年限。只要你理解业务目标并将其与团队的期望和兴趣对齐，你可以在任何年龄领导数据科学团队。

---

我们的前三大课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析能力

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT 需求

---

我在下面列出了从业务和团队领导两个角度来看，一个有效的数据科学经理的特征。

机会主义

我们都应该在职业生涯的某个阶段听说过推拉模型。这个推拉概念的一个类比是，你是否一直在等待有人把工作推给你。

或者，你是否足够机会主义，能够理解业务问题，并主动将高影响的工作拉到自己手中。

你是否是一个先锋，帮助业务理解机器学习解决方案如何以及在何处提供帮助，还是仅仅作为一种装饰品？

业务与机器学习指标

使你的利益相关者对机器学习有足够的认知，将使你在职业生涯中走得更远。这表明你能够从长远考虑，并且能够弥合高准确度模型与那些带来实际业务价值的模型之间的差距。让我们诚实地面对，机器学习模型的构建过程是时间和资源密集型的，需要清楚理解机会规模和机器学习模型的影响。

在向领导展示提案时，你应该清楚地列出假设、使用机器学习的利弊、模型的脆弱性等。这可以减轻业务高管的巨大负担，为数据科学团队带来协同效应和信任。

满足团队的期望

如果你已经说服管理层接受了你解决方案的价值主张，但数据科学经理的任务还包括感知团队的脉搏。虽然有一种看法认为数据科学团队整天都在使用最先进的前沿模型，但现实中还包括为重复任务构建自动化工作流程，进行 4 个月的概念验证却只看到其被废弃，模型监控和维护，解释模型预测等。

关键是你需要识别并调整团队成员的兴趣 - 有些可能来自核心研究背景，能够思考创新解决方案，而其他人可能对成为全栈数据科学家，即全能型人才感兴趣。

始终记住，团队中某个成员看来像是一项负担的工作（可能是因为他们已经做了很长时间，并渴望接受新的挑战），可能对其他人来说是一个学习和提升技能的好机会。

这全关乎于找到那种常被低估的技能，即了解你的团队。不要与团队保持机械化或交易性的关系，仅仅传达任务而不融入他们的工作期望。

维持团队士气

说实话 - 你无法让团队长时间从事他们不感兴趣的任务。但你仍然需要完成这个任务。一个好的数据科学经理会注意到所有团队成员的兴趣，并能够真实地解释现实情况。但是，现实是什么呢？

管理层理解并计划个人的发展和成长蓝图，其中业务目标与团队的目标和兴趣相一致。但目前我们需要完成一个业务交付任务，并且在下一个机会出现时，团队的对齐情况会根据他们在一对一沟通中提出的要求进行调整。

你需要对团队的承诺保持完全的忠诚，因为你正在与行业中的优秀人才合作。你只能通过让他们明白当前任务的成功完成将使他们离自己感兴趣的领域更近一步来吸引他们。

请注意，我们并不生活在一个理想的世界，因此很可能无法一次性满足整个团队的期望。你在明确而清晰地呼唤的约束条件下工作 - 业务优先。那么，你会怎么做呢？

这就是同理领导力概念的来源。你对团队期望的意识和愿意帮助他们实现这些期望的能力已经证明了你的管理技能。朝着正确方向的努力会被团队充分认可。那些尚未得到自己份额的人也理解，只要有合适的时间和机会，经理将会为他们定位并使他们实现目标。

你提倡什么：竞争还是个人成长？

个人而言，我不喜欢在团队内部提倡竞争，并以健康竞争的名义包装这种激励。我更愿意尊重每个人的独特性，并挖掘他们的潜力。

要求一条鱼爬树，我能得到什么额外的好处？

是的，每个人都应该足够灵活，以便快速学习和交付。但是，这种交付很可能来自他们感兴趣的领域，而不是强迫他们走别人的路。一个好的数据科学经理对团队的学习曲线负责，并推广一些缓冲时间，让他们探索自己感兴趣的工作。哦，但你可能会认为你感兴趣的领域不一定能找到业务成果。

这就是管理的优点所在——你激励他们花 15-20%的时间探索新的算法，学习像编程语言这样的新技能等。实质上，是给他们翅膀，去思考超越纯商业背景的边界。

摘要

虽然我们都希望有一本规则手册可以让所有管理者从第一天起就成功，但不幸的是，并没有这样的手册。

每个人都有自己的管理风格，并应该坚持自己轻松自然的方式。你不能在管理团队时长时间伪装自己。因此，最好做真实的自己，并做到一个有效的经理应该做的事情——在保持团队积极的同时实现业务成果。

Vidhi Chugh 是一位获奖的 AI/ML 创新领导者和 AI 伦理学家。她在数据科学、产品和研究的交汇处工作，以提供业务价值和洞察力。她是数据驱动科学的倡导者，并在数据治理领域是一位领先专家，致力于构建可信赖的 AI 解决方案。

更多相关话题

• KDnuggets™ 新闻 22:n03，1 月 19 日：深入探讨 13 个数据…

• 五步成为数据科学专业人士

• 你应该知道的五大 SQL 窗口函数，适用于数据科学面试

• 在 Pandas 中进行条件过滤的五种方法

• 为有效的 Tableau 和 Power BI 仪表板准备数据

• 数据可视化最佳实践与有效沟通的资源

如何修复不平衡的数据集

原文：www.kdnuggets.com/2019/05/fix-unbalanced-dataset.html

评论

由 Will Badr, 亚马逊网络服务。

---

我们的前三大课程推荐

1. Google 网络安全证书 - 快速进入网络安全职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你组织的 IT

---

分类 是最常见的机器学习问题之一。处理任何分类问题的最佳方法是从分析和探索数据集开始，我们称之为 探索性数据分析（EDA）。这个过程的唯一目的是尽可能多地生成关于数据的见解和信息。它也用于发现数据集中可能存在的任何问题。分类数据集中常见的问题之一是 类别不平衡 问题。

什么是数据不平衡？

数据不平衡通常反映数据集中类别的分布不均。例如，在信用卡欺诈检测数据集中，大多数信用卡交易不是欺诈交易，只有少数交易是欺诈交易。这导致欺诈与非欺诈类别之间的比例接近 50:1。本文中，我将使用 Kaggle 上的信用卡欺诈交易数据集，可以从 这里 下载。

首先，让我们绘制类别分布图以查看不平衡情况。

正如你所见，非欺诈交易远远超过了欺诈交易。如果我们训练一个二元分类模型而不解决这个问题，模型将完全偏向非欺诈交易。这也影响特征之间的相关性，稍后我会展示如何以及为何如此。

现在，让我们介绍一些解决类别不平衡问题的技术。完整代码的笔记本可以在 这里 找到

1- 重新采样（过采样和欠采样）：

这听起来直观易懂。欠采样 是一种从多数类别中随机删除一些观测值以匹配少数类别数量的过程。下面的代码展示了一种简单的方法：

对多数类进行欠采样

在对数据集进行欠采样后，我再次绘制它，显示了相等数量的类：

平衡数据集（欠采样）

第二种重新采样技术称为过采样。这个过程比欠采样稍微复杂一些。它是生成合成数据的过程，试图随机生成来自少数类观察的属性样本。用于过采样数据集的方法有很多。最常见的技术称为SMOTE（合成少数类过采样技术）。简单来说，它查看少数类数据点的特征空间，并考虑其k最近邻。

来源: imbalanced-learn.readthedocs.io/en/stable/over_sampling.html

要在 Python 中实现这一点，我使用了一个名为 imbalanced-learn** 或 imblearn 的库。**下面的代码展示了如何实现 SMOTE。

记住我之前提到过不平衡数据如何影响特征相关性吗？让我展示一下处理不平衡类前后的相关性。

在重新采样之前：

下面的代码绘制了所有特征之间的相关性矩阵。

# Sample figsize in inches
fig, ax = plt.subplots(figsize=(20,10))         
# Imbalanced DataFrame Correlation
corr = credit_df.corr()
sns.heatmap(corr, cmap='YlGnBu', annot_kws={'size':30}, ax=ax)
ax.set_title("Imbalanced Correlation Matrix", fontsize=14)
plt.show()

重新采样之后：

注意，现在特征相关性更为明显。在解决不平衡问题之前，大多数特征没有显示出任何相关性，这肯定会影响模型的性能。由于特征相关性确实很重要对整体模型的表现，因此修正不平衡问题很重要，因为这也会影响机器学习模型的性能。

2- 集成方法（采样器集成）：

在机器学习中，集成方法使用多个学习算法和技术，以获得比任何单一学习算法所能实现的更好的性能。（是的，就像民主投票系统一样）。使用集成分类器时，袋装方法变得非常流行，它通过在不同的随机选择的数据子集上构建多个估计器来工作。在 scikit-learn 库中，有一个名为 BaggingClassifier 的集成分类器。然而，这个分类器不允许平衡每个数据子集。因此，当在不平衡数据集上训练时，这个分类器会偏向于多数类，从而创建一个有偏的模型。

为了解决这个问题，我们可以使用 BalancedBaggingClassifier 来自 imblearn 库。它允许在训练每个集成估算器之前对数据集的每个子集进行重采样。因此，BalancedBaggingClassifier 除了与 scikit-learn 的 BaggingClassifier 相同的参数外，还具有两个其他参数，sampling_strategy 和 replacement，这些参数控制随机采样器的行为。以下是一些代码示例：

使用集成采样器训练不平衡数据集

这样，您可以训练一个分类器，该分类器将处理不平衡问题，而无需在训练之前手动欠采样或过采样。

总结一下，每个人都应该知道，基于不平衡数据集构建的机器学习模型的整体性能将受到其预测稀有和少数点能力的限制。识别和解决这些点的不平衡问题对于生成模型的质量和性能至关重要。

原文。经许可转载。

个人简介: Will Badr 是一位经验丰富的高级技术账户经理，在信息技术和服务行业有着丰富的工作经验。他专注于人工智能和机器学习领域，并推动创新文化。

资源:

• 在线和基于网络的：分析、数据挖掘、数据科学、机器学习教育

• 用于分析、数据科学、数据挖掘和机器学习的软件

相关内容:

• 数据清理的顶级 R 包

• 为意外情况做好准备

• 以低成本获取标记数据以训练您的模型

更多相关话题

• 10 个最常见的数据质量问题及其解决方案

• 如何在机器学习中从庞大的数据集中正确选择样本

• 为您的数据集选择正确的聚类算法

• 如何为机器学习创建数据集

• 如何生成合成表格数据集

• 无监督解缠代表学习在类别不平衡数据集中的应用…

修复 CRISP-DM 中的部署和迭代问题

原文：www.kdnuggets.com/2017/02/fixing-deployment-iteration-problems-crisp-dm.html

评论

这是三篇文章中的最后一篇。第一篇概述了 CRISP-DM 使用中的四个问题及解决方法，第二篇讨论了 为 CRISP-DM 带来业务清晰度。这篇文章讨论了分析工作完成后分析如何被部署和管理的两个相关问题。关注业务决策过程有助于解决这两个问题。在 CRISP-DM 中，这涉及到部署阶段和迭代循环的变更，如图 1 所示。

---

我们的前三个课程推荐

1. 谷歌网络安全证书 - 快速进入网络安全职业生涯。

2. 谷歌数据分析专业证书 - 提升你的数据分析技能

3. 谷歌 IT 支持专业证书 - 支持你的组织的 IT

---

图 1：CRISP-DM 中的部署和管理活动。

令人沮丧的是，许多本来可以帮助业务的分析模型实际上并未发挥作用。许多分析模型被开发出来但并未在合理的时间框架内（或者根本没有）被部署和使用。正如最近国际分析学院网络研讨会的调查结果所示，60%的项目未能在“几个月”内对其分析结果采取行动。其他调查和研究结果表明，对于许多这些分析，几个月变成了几年，而且许多分析根本没有被部署。希望开发有影响力的分析的团队需要将将其分析部署到生产环境中，并将其与业务环境集成，作为项目中的关键步骤。这就是 CRISP-DM 中的部署阶段的作用。成功部署涉及多个因素。

团队必须选择合适的分析交付选项。分析的风格（例如是视觉的还是数值的，是固定的还是交互的）必须与意图的决策风格匹配。嵌入在网站中的自动决策需要不同于由呼叫中心代表做出的手动决策。必须用于移动工作人员的分析与支持桌面工作人员的分析有所不同，依此类推。决策模型揭示了组织的影响，并展示了谁的行为需要改变，以及系统或流程需要围绕分析决策进行重新编码。

分析团队还必须记住，决策需要将分析模型与决策逻辑结合起来，以使其可操作。决策模型展示了如何做到这一点，建模决策的非分析元素，以及展示分析如何被决策所使用。例如，处理索赔的决策模型可能包括欺诈预测，以及审计、法规和基于政策的排除。

最后，还有项目的组织变革部分。改变人们做决策的方式，或改变系统为他们做决策的程度，几乎总是复杂的。决策模型提供了一个框架，用于理解谁在何时何地做出哪些决策。它还将这种决策过程与新的和现有的业务指标联系起来。这提供了对必要组织变革的清晰画面。

成功的分析团队不会认为项目完成，直到业务看到改善——生产分析只是一个中间点，而非最终目标。

解决方案：规划分析演变

政策和法规会发生变化。市场和竞争者会做出反应。今天的好决策可能明天就不再适用。随着数据变化，分析也会过时，必须监控并保持最新。一个已部署却未监控和未更改的分析模型，可能会变得效果下降，甚至可能变得有害。

分析团队需要识别可能导致分析模型效果下降的业务和环境因素。他们必须定义需要捕获的数据，以显示分析是否有效，并确定何时因这些原因效果下降。他们还应考虑机器学习和自适应分析技术是否适合不断完善模型，以及业务可能对这些模型要求什么样的边界或警报条件。如果需要手动更新，那么这些更新的时间表或触发条件也需要定义。应该制定清晰的计划来逐步改进每一个已部署的分析模型。

决策模型展示了决策的结构。这一结构可以用于确定应跟踪哪些中间结果和业务成果。结合有关模型及其行为的数据，这允许对分析模型及其影响的业务决策进行持续监控和改进。

决策模型还清楚地显示了哪些外部业务影响因素对决策制定至关重要，以便可以监测这些因素的变化。例如，新的或变更的法规可能会影响决策的约束条件，从而削弱分析的有效性，除非进行相应的调整。

成功的分析团队专注于不断发展的大规模分析组合，而不是个别手工制作的一次性模型

要了解一家全球信息技术领袖如何使用决策建模，请查看这份来自国际分析研究所的领先实践简报。

简介：詹姆斯·泰勒 是如何使用分析技术构建决策管理系统的领先专家，这些系统帮助公司改善决策制定并发展具有敏捷性、分析性和适应性的业务。他为各类公司提供战略咨询，与各个行业的客户合作，推动决策建模、分析及其他决策技术的应用。

相关：

• 基于标准的预测分析部署

• 为 CRISP-DM 带来业务清晰度

• 使用 CRISP-DM 的四个问题及解决方法

更多相关主题

• 数据协作失败的地方（以及修复的 4 个技巧）

• 理解 Python 的迭代和成员资格：contains 和 iter 魔法方法指南

• 回到基础 第 4 周：高级主题和部署

• 7 大模型部署和服务工具

• 机器学习算法的完整端到端部署到…

• 从数据收集到模型部署：数据科学项目的 6 个阶段

使用 Python 和 Heroku 创建并部署你的第一个 Flask 应用程序

原文：www.kdnuggets.com/2020/09/flask-app-using-python-heroku.html

评论

由 Divy Shah，数据科学家。

---

我们的前三个课程推荐

1. Google 网络安全证书 - 快速进入网络安全领域的职业生涯。

2. Google 数据分析专业证书 - 提升你的数据分析技能

3. Google IT 支持专业证书 - 支持你的组织的 IT

---

前提条件

• Python

• Flask

• Git

• Heroku CLI

安装

安装 Python 后，安装列出的其他框架和库。你可以使用以下命令轻松安装 flask。

pip install Flask
#pip install 

定义你的 Web 应用程序的结构

static
    |_main.css
template
    |_display.html
app.py
trending.py
requirements.txt

静态目录包含你的 CSS 文件，而模板目录包含 HTML 文件，用于渲染。

你可以为逻辑和其他操作创建一个单独的 .py 文件，或者在同一个 app.py 文件中编写代码。我建议创建一个单独的文件，这样会减少混淆。

第一步：

创建你的 app.py 文件

我使用了 waitress 服务，因为使用这个库意味着它是一个生产级别的纯 Python WSGI 服务器，性能非常可接受。它没有其他依赖，只依赖于 Python 标准库中的依赖项。

安装 waitress

pip install waitress

app.py

import requests
from flask import Flask, render_template, redirect, url_for, request
from datetime import datetime, timedelta
import time
import json
import os
from trending import get_trending

app = Flask(__name__)

@app.route('/')

def trending():
   info = get_trending()
   render_template('display.html', info=info['data'])
   return res

if __name__ == "__main__":
     app.debug = False
     port = int(os.environ.get('PORT', 33507))
     waitress.serve(app, port=port)

如上所示，我们使用了 **GET ** 方法从服务器发送数据。

还有其他几种方法可用，包括：

**POST: **用于将用户/form-data 发送到服务器，并且不缓存传输的数据。

HEAD: 类似于 GET，但不同之处在于它用于没有响应体的情况。

**PUT: **用于用上传的内容替换当前资源。

DELETE: 用于删除 URL 中提供的目标资源。

第二步：

创建 trending.py 文件，该文件基本上包含你的业务逻辑。创建后，将主函数导入到 app.py 文件中。

from trending import get_trending

下面是我的 trending.py 文件的样子：

trending.py

收集数据后，我们可以使用 HTML 文件来呈现输出。

输出数据将在 HTML 页面上显示。

第三步：

创建一个 HTML 文件来呈现你从响应对象中收集的数据。

下面是我的 display.html 文件的样子：

display.html

你几乎完成了编码部分，现在是时候部署我们的第一个 flask 应用了。

在部署应用之前，首先检查本地的 flask 应用。

部署步骤

1. 使用 CLI 登录到你的 Heroku 账户

你可以通过在终端中输入以下命令进行登录：

heroku login

2. 在 Heroku 上创建一个网页应用

你可以使用以下命令在 Heroku 上创建一个新应用：

heroku create < your_app_name >

3. 在相同的项目目录中创建 requirements.txt 文件

要生成 requirements.txt 文件，你可以使用以下命令：

pip freeze > requirements.txt

4. 创建一个 Procfile

Procfile 是所有 Heroku 应用所需的进程文件。Procfile 指定了应用在启动时执行的命令。

点击这里 以阅读更多有关 Procfile 的信息

在 Procfile 中输入以下内容：

web: gunicorn app:app

这里，app 是你主要的 (.py) 文件的名称。在我的例子中，它是 app.py。

如果你还没有安装 gunicorn 网页服务器，请使用以下命令安装：

pip install gunicorn

注意：你必须创建一个没有任何文件扩展名的 Procfile。

5. 创建 runtime.txt 以指定运行时的 Python 版本

在创建runtime.txt之后，添加你的构建 Python 版本，如下所示：

python-3.8.1

现在，我们一切就绪！

6. 初始化一个空的 git 仓库并推送代码

git init

接下来，使用以下步骤提交你的最终代码：

git add .
git commit -m "My first commit"
git push heroku master

你的应用现在已经上线，你可以使用生成的 URL 查看你的网页应用。

请查看我的演示网页应用：trending-shows.herokuapp.com/

原文。经许可转载。

简介： Divy Shah 对利用数据科学和机器学习算法解决现实生活和金融科技行业的问题充满热情，且总是渴望学习和探索新的数据科学算法和框架。

相关：

• 使用 Flask 部署机器学习模型

• 构建并部署你的第一个机器学习网页应用

• 如何使用 Flask 在 5 分钟内为机器学习模型构建 API

更多相关话题

• 用 Heroku 部署机器学习网页应用

• 将 Streamlit WebApp 部署到 Heroku 使用 DAGsHub

• 在 Heroku 云上部署深度学习网页应用的技巧与窍门

• 从零到英雄：用 PyTorch 创建你的第一个 ML 模型

• 用 Python 构建一个命令行应用的 7 个简单步骤

• 使用 Python 和 Dash 创建仪表板