TowardsDataScience-博客中文翻译-2022-三-
TowardsDataScience 博客中文翻译 2022（三）
原文：TowardsDataScience
协议：CC BY-NC-SA 4.0
Matplotlib 中更好的绘图的 4 个快速技巧
原文：https://towardsdatascience.com/4-quick-tricks-for-better-plots-in-matplotlib-1efd82acd780
轻松添加箭头、多轴、渐变填充等
当我们开始用 matplotlib 之类的工具学习数据可视化方法时，为了便于编码，我们通常从最简单的图开始。然而，当我们开始与他人分享我们的可视化时，定制我们的情节以精心制作我们的信息并使一切更具视觉吸引力是很重要的。
我们可以插入几行代码，使我们的情节更具功能性，并帮助数据向我们的观众讲述一个故事，而不是创建复杂的代码并花费数小时来使情节看起来“恰到好处”。
这里有 4 个快速提示，可以为基本 matplotlib 折线图和条形图增加重点、功能和视觉吸引力:
1.用颜色强调条形图
我们的目标是制作能够讲述一个故事的独立情节，无论你是否在那里展示幻灯片。在分享图表之前，你应该思考“我想让我的观众从中得出什么结论？”和“我真的希望他们注意到数据的哪一部分？”为了帮助实现这一点，我们可以使用列表来定制条形图中的大量可调参数。什么是color='blue'可以变成color=['blue', 'red', ...],每个条目指示如何处理我们图中的每个条。
例如，一个简单的条形图看起来像这样:
然而，如果我们想引起对第三个条的注意(例如)，我们可以通过将color、edgecolor和linewidth输入更改为列表来实现:
2.用箭头强调线图
线形图很难突出重点。对于线图，最简单的通常是最好的——添加一个指向特定数据点的箭头是吸引观众眼球的好方法。虽然 matplotlib 有一个特定的箭头函数，但是要让箭头“恰到好处”地显示出来却非常不灵活，而且非常具有挑战性。更简单快捷的方法是使用注释功能。在这里，我们得到了许多非常直观的功能。我们的两个主要变量xytext和xy分别告诉箭头从哪里开始和从哪里结束。xytext也是放置文本的箭头末端，我们应该选择给箭头加标签(但我们不是必须这样！).
我们可以使用arrowprops=dict()来调整箭头属性，其中我们可以使用标准键，如color、linewidth等等。那会让你得到简单的直线，但是事情会变得更有趣。我们可以用arrowstyle(此处完整列出)调整箭头的形状，也可以偏离直线箭头路径。connectionstyle有三种主要口味
arc3-以弧度设置曲率的弯曲路径(rad)。玩正负rad值，把你的曲线从凹变成凸。在直线连接的折线图中，给箭头路径增加一点曲率肯定有助于引起注意。angle—以指定角度绘制的线段(angleA、angleB)。这个方法足够聪明，可以让你选择的任何角度在你的文本和xy坐标之间建立联系。bar-尽管整个箭头可以基于一个共同的角度，但线段之间保持 90 度弯曲。通过在这里玩fraction，我们改变了转弯相对于端点的位置。在下面的代码中尝试负值，看看会发生什么！
考虑到你可以创建大量不同种类的箭头，最好试验一下这些参数来得到你想要的。这里有一个例子，6 个不同的箭头应用于我们的绘图，以帮助可视化什么是可能的。
3.添加辅助 Y 轴
将多列数据叠加在一个图上可以得出它们之间关系的结论。但是，两列在相同的数值范围内操作的情况很少见，这会导致其中一行在轴附近徘徊时出现缩放问题。为了构建一个辅助 y 轴，我们使用twinx()函数创建一个共享相同 x 轴的辅助 y 轴。该次轴将自动定位在最右侧，并根据输入到该ax项目的数据自动缩放。重要的是使用color来帮助我们的观众理解哪个情节与每个轴相关联。为了更好地理解这一点，可以使用我们刚刚学过的技巧来添加箭头。
旁注:添加一个辅助 y 轴也可以很容易地在本地熊猫中完成，使用secondary_y = True属性，产生几乎相同的结果。如果你好奇的话，这里的代码是这里是，结果图是这里是。
4.添加填充颜色
我们还可以通过填充线条下方的区域来增加线条图的重点和总体视觉吸引力。这是一个使用fill_between()函数的快速加法，在这里我们指出我们希望它填充的 x 范围，以及我们希望填充的两条“线”。在这种情况下，我们想要填充数据和图形底部之间的空间(在这种情况下 y=0)。用plt.axis()设置绘图区域以匹配您的数据也是一个好主意，否则颜色不会继续填充您的数据范围之外，在您的绘图中留下难看的白色区域。
定义和不定义绘图区以匹配数据的线形图填充-按作者排列的图像
我们可以把极限推得更远一点——把我们的填充变成颜色渐变。在这种情况下，我们必须发挥创造力。对于添加渐变来说是很棒的，但是传统上它是在我们的整个绘图区域添加渐变。为了克服这一点，我们用imshow()添加一个渐变，然后用fill_between()将上面的都涂成白色。imshow()起步有点棘手，我在之前的一篇文章中对此进行了更深入的探讨，链接此处。然而，简单的版本让我们设置我们在 X 中使用的颜色图的范围——这里我们选择使用带有[[0.8, 0.8],[0,0]]的cm.Blues颜色图底部 80%的垂直颜色渐变。(类似的水平梯度可以这样实现:X=[[0,0.8][0,0.8]])。
我们还设置了imshow()填充的extent，有效地设置了渐变图像填充的边界框。我们可以手动设置这些值，或者对我们的数据序列使用min()和max()函数。这些可以简单地增加以进一步向下扩展绘图区域。最后，我们在fill_between()函数中设置绘图区域的上限，因为我们现在从我们的数据到绘图的顶部(这里定义为df.b.max()+0.5)。
额外学分
根据我们所学的内容，我们现在可以将我们的方法结合起来，使用一个次轴连接两个线图，同时还可以添加填充并用箭头标注重要的点。
结论
通过对代码进行一些快速调整，我们可以为 matplotlib 图增加重点和视觉吸引力。强调的情节让我们的数据自己说话，能瞬间带动别人关注我们 认为值得关注的 数据点。幸运的是，我们只用几行代码就可以达到这个目标！
像往常一样，整个代码走查笔记本可以从我的 github 中找到。如果你觉得这个有用，请跟我来！ 欢呼声此起彼伏，快乐的编码声此起彼伏。
作者生成的所有图像
自动化 EDA 报告的 4 R 库
原文：https://towardsdatascience.com/4-r-libraries-for-automated-eda-report-a42f139c5b6b
介绍几种不需要大量编码的有效自动化 EDA 报告
安德烈·本兹在 Unsplash 上拍摄的照片
介绍
在我的文章中分享了一些非常酷的有效 EDA 库之后，3 个你可能错过的有效 EDA Python 库几周前，我想和你分享一些更酷的项目，比如这些不过，这次在 r .希望这些库能对您有所帮助。**
现在，让我们开始吧！
数据集
在本文中，我将使用来自 R、 企鹅的公共数据集 来自palmerpenguins包的数据。
*****## Install & load data.table**install.packages("palmerpenguins")
library(palmerpenguins)
df = penguins***
以下是该数据集的快照:
图 1:数据集——作者图片
数据来源: 瓦斯科姆，m .等人，2017。mwaskom/seaborn:v 0 . 8 . 1(2017 年 9 月)，芝诺多。可在:https://doi.org/10.5281/zenodo.883859.以 BSD-3 许可证发布。
数据浏览器包
DataExplorer 只需一行代码，就能通过自动化 EDA 快速获得数据集的概况。
****## Install package**
install.packages("DataExplorer")**## Import library**
library(DataExplorer)**## Create report**
create_report(df)**
图 2:作者的 DataExplorer 包— GIF
基本上，该软件包将总结理解数据所需的所有信息，包括:
- 数据结构、变量类型等。(
plot_str(),introduce(),plot_intro()) - 缺失值轮廓-缺失数据的百分比，每个要素缺失行的绘图(
plot_missing(),set_missing()) - 直方图中数值变量的分布和柱状图形式的分类变量的频率(
plot_bar(),plot_histogram(),update_columns(data,"column_name", as.factor)) - 变量之间的相关性分析(
plot_correlation(na.omit(data)) - 检验偏离特定概率分布的 QQ plot(
plot_qq()) - 一个热编码(
dummify())
如果您想单独调查上述信息，但不想自动创建完整的报告，数据浏览器为您提供不同的相应功能。如上所述，你可以在括号内引用一些函数，并在这里找到更多细节。
SmartEDA 包
另一个我认为已经成功完成基本 EDA 关键职责的自动化 EDA 包是 SmartEDA 。与 DataExplorer 不同，此包不包含任何用于修改现有变量的函数。相反，SmartEDA 专注于使用可视化和描述性统计来提供数据理解。
要在 SmartEDA 中创建自动报告，我们只需要一行简单的代码，如下所示:
****## Install package**
install.packages("ExPanDaR") **## Import library**
library(ExPanDaR)**## Create report** ExPanD(df)**
图 3:按作者展开报告 GIF
如您所见，总体而言，该报告与 DataExplorer 包非常相似。它包括数据集摘要的基本信息，例如变量类型、数据框大小、描述性统计数据、缺失值或不同变量的分布。 SmartEDA 的一个 DataExplore 没有显示的特性是目标变量和其他变量之间的相关性。
此外，该软件包还支持通过提供列联表和平行坐标图的相关数据来发现数据，从而实现多变量可视化。有关报告中每个组件如何工作的更多信息，您可以通过此链接阅读更多信息。
DataMaid 包
DataMaid 可以生成 PDF、DOCX 或 HTML 格式的报告。简而言之，具有检查和汇总结构的 DataMaid 报告简单明了，如图 4 所示。所有的问题都在报告中逐一进行了总结。因此，很容易定义数据质量问题，并了解下一步如何进行数据清理。
****## Install package**
install.packages("dataMaid")**## Import library**
library(dataMaid)**## Create report**
makeDataReport(df, output = "html", replace = TRUE)**
图 4: DataMAid 报告——作者 GIF
Dlookr 包
从视觉上看，最后一个是我最喜欢的创建报告的包。它支持不同的分析，如数据诊断和探索性数据分析。
正如您在图 5 中看到的，诊断报告有助于通知变量类型以及缺失值和唯一值的计数。此外，还会识别重复项和异常值。还显示了剔除异常值前后的曲线图，以便于数据可视化。
另一方面，图 6 中的 EDA 报告显示了单变量、双变量和多变量分析统计数据。请注意，报告中给出的每个摘要也可以手动完成。
****## Install package**
install.packages('dlookr')**## Load library** library(dlookr)**## Create diagnostic report**
diagnose_web_report(df, output_format = "html")**## Create EDA report** eda_web_report(df,output_format = "html")**
图 5:诊断报告——作者的 GIF
图 6:描述性分析——作者 GIF
结论
以上是我对自动化 EDA 报告包的一些建议。总的来说，它们有些相似，因为它们提供了一个大画面，并帮助我们掌握对数据集的总体理解。根据不同的用途，可以选择合适的包来应用。例如， SmartEDA 包有一种显示多元关系的方法——平行坐标图。同时， DataMaid 是检测数据错误的优秀工具。检查和汇总功能结果格式允许适当地处理问题。
如果你有任何令人兴奋的有效 EDA 库，请与我分享任何令人兴奋的有效 EDA 库。感谢阅读。
参考
Staniak，m .，& Biecek，P. (2019 年)。自动化探索性数据分析的 R 包前景。《R 日报》， 11 (2)，347 页。https://doi.org/10.32614/rj-2019-033
来自 Python 的 Inventor 的 4 个改进代码的简单技巧
原文：https://towardsdatascience.com/4-simple-tips-from-pythons-inventor-to-improve-your-code-5429297505a9
利用该语言最博学的专家之一提供的易于实施的课程
活动发起人在 Unsplash 上的照片
您可能不知道，Python 安装附带了一首美妙而有用的诗，而且是免费的。要访问它，你需要做的就是在终端中键入import this。然后，您会看到以下内容:
“Python 的禅”，作者蒂姆·彼得斯
漂亮总比难看好。
显性比隐性好。简单比复杂好。
复杂总比复杂好。
扁平比嵌套好。
稀不如密。
可读性很重要。特例不足以特殊到违反规则。
虽然实用性胜过纯粹性。错误永远不会悄无声息地过去。
除非明确消音。
面对暧昧，拒绝猜测的诱惑。应该有一种——最好只有一种——显而易见的方法来做这件事。除非你是荷兰人，否则这种方式一开始可能并不明显。
现在总比没有好。
虽然永远也不会比现在*好。如果实现很难解释，这是个坏主意。
如果实现起来容易解释，这也许是个好主意。名称空间是一个非常棒的想法——让我们多做一些吧！"
这首诗的作者是 Tim Peters，他是一位著名的软件工程师，也是 Python 编程语言发展的主要贡献者之一。尽管这是一种既有趣又幽默的语言怪癖，但这首诗也有一些很好的建议。
我们来看看能学到什么。
请让你的代码易于阅读
可读性很重要。
以下是 Python 中完全有效的代码块；它实现了它的目标，运行时没有任何错误:
x = 'All Too Well'
if x == 'All Too Well': print("Taylor Swift rocks")
else:
print("You need to re-evaluate your life choices.")
事实证明，只要您与空格和制表符保持一致，Python 的解释器并不真正关心您将代码间隔开多宽或多均匀。
但你知道谁在乎吗？三个非常重要的人，如果你选择编写风格不正确的代码，他们都会讨厌你:
- 你的老师/导师:这些人必须要么给你的代码打分，要么审查你的代码，他们不会因为不得不多盯着看几分钟来找出从哪里开始而感到兴奋。
- 你的同事:他们需要构建你的代码。如果你不必要地让他们的生活变得更加艰难，他们不会喜欢你。
- 你未来的自己:你很可能会发现自己在未来几天拿出自己的代码，重新开始工作。在那一点上，你真的会痛恨过去的自己写了一堆乱七八糟的东西，而不是清晰、干净和可维护的代码。
这么多人讨厌你的生活不是一种有趣的生活，所以编写符合 Python 详细且写得很好的风格指南【1】的代码确实对你更有利。确保你的缩进匹配，你的变量名合理，并添加一些适当的注释来引导读者:
my_favorite_song = 'All Too Well'# This block of code ensures the my_favorite_song variable has
# the correct value.
if my_favorite_song == 'All Too Well':
print("Taylor Swift rocks")
else:
print("You need to re-evaluate your life choices.")
你的导师、同事和未来的自己都会感谢你。
当你这么做的时候，把它变漂亮
漂亮总比难看好。
这里有一个重要的问题需要回答:什么是美丽的代码？
这要看上下文。Python 是一种为可读性和简单性而设计的语言，因此最简单的代码(仍然容易理解)也是最漂亮和优雅的，这是显而易见的。
有许多相关的例子，但我最喜欢的一个是新程序员中常见的冗余构造。它包括返回True或False,这取决于我们感兴趣的变量的值。请考虑以下情况:
# This code returns whether or not my code is beautifuldef my_function(is_code_beautiful):
if is_code_beautiful == True:
return True
else:
return False
原则上，这段代码没有任何问题。事实上，对于新的程序员来说，它可以说是一个有效的教学工具，因为它提供了思考条件语句实际上要做什么的方法。
然而，它可以用一种更简单(也更漂亮)的方式来写。由于变量本身已经是一个布尔值(真或假)，我们可以用下面的代码达到同样的效果:
# This code returns whether or not my code is beautifuldef my_function(is_code_beautiful):
return is_code_beautiful
简单。优雅。蟒蛇皮。
太美了。
复杂不就是复杂吗？
号码
复杂总比复杂好。
很多人把复杂和复杂这两个词互换使用，那么我们就从两者的区别说起吧。它们在口语中可能有相似的含义，但在编程上下文中却不相同。
复杂的代码可能很难理解，但通常是出于必要，因为底层算法本身很复杂(没有人编写过比从头开始编写算法更简单的代码)。复杂的代码是不必要的复杂，特别是因为有一种更简单的方法来实现相同的解决方案。
让我们看一个例子。假设我们有以下深度嵌套的列表:
data = [[[0, 255, 255], [45, 0, 0]], [[0, 0, 0], [100, 100, 100]]]
顺便提一句，您可能认为嵌套如此之深的列表没有实际用途，但事实上这就是图像在 Python 中的存储方式——作为像素行，其中每个像素是由红、绿、蓝(RGB)值组成的 3 元素列表。
在我目前担任助教的课程中的一个项目中，学生们必须编写一个操作程序，通过颠倒所有行中像素的顺序来水平翻转照片。
当我为这个项目做准备时，这是我最初想到的解决方案:
for row in data:
for i in range(len(row) // 2):
temp = row[i]
row[i] = row[len(row) - 1 - i]
row[len(row) - 1 - i] = temp
起初，我认为这是一个非常漂亮的反转列表的解决方案。也就是说，直到我的教授指出我可以这样做:
for row in new_pixel_data:
row.reverse()
这种差异令人震惊。
有人可能会说第二种解决方案在原理上仍然很复杂，因为反转列表是一项相当复杂的任务。然而，非常明显的是，与我的第一个手动解决方案相比，它要简单得多，因此也更容易理解。
请注意，您的代码是否复杂很大程度上取决于上下文。在上面的例子中，我的初始代码很复杂，因为有更干净的代码可以达到同样的目的。如果没有反转 Python 列表的简单方法，那么我的代码会很好(如果仍然复杂的话),仅仅是因为它是最好的选择。
一个很好的经验法则是:在你编写超级复杂的代码之前，检查一下是否有人已经做了一些工作来使你的生活变得更容易。
检查错误！
错误永远不会无声无息地过去。
除非明确消音。
有趣的是，这是一个在编程入门课上经常被忽略的话题。我自己的第一门编程课程只是简单地提到了捕捉错误，从未明确地教授如何去做。这是一项重要的技能，主要是因为它能让你的程序在出错时给用户更多的细节(或者甚至保持程序平稳运行)。
在 Python 中处理错误最简单的方法是通过 try-except 块。您像平常一样在try中编写代码，如果有错误，代码开始运行except块:
>>> try:
... print(x)
... except:
... print("You never defined your variable.")
...
You never defined your variable.
您还可以捕捉特定的错误:
>>> try:
... 1/0
... except ZeroDivisionError:
... print("Can't divide by 0; sorry m8")
...
Can't divide by 0; sorry m8
捕捉错误使您能够在程序中断时继续运行。例如，下面的代码因ZeroDivisionError而失败，因此我们也不会计算循环中后面的表达式:
>>> for i in range(3):
... print(1/i)
...
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero
但是如果您添加一个 try-except 块，您会得到更好的结果:
>>> for i in range(3):
... try:
... print(1/i)
... except ZeroDivisionError:
... print("Can't divide by 0; sorry m8")
...
Can't divide by 0; sorry m8
1.0
0.5
感觉很好，不是吗？
总结和最终想法
这是给你的 Pythonic 提示表:
- 可读性计数。清晰地格式化和组织你的代码。
- 漂亮总比难看好。避免多余的解决方案。
- 复杂比复杂好。如果你的代码必须是复杂的，那没问题，但是如果它是不必要的复杂，那就不好了。
- 错误永远不会悄无声息地过去。学会处理错误——这值得你花时间！
就这样，我祝你在 Pythonic 的冒险中好运。
想擅长 Python？ 获取独家，免费获取我简单易懂的攻略 。想在介质上无限阅读故事？用我下面的推荐链接注册！
https://murtaza5152-ali.medium.com/?source=entity_driven_subscription-607fa603b7ce---------------------------------------
我叫穆尔塔扎·阿里，是华盛顿大学研究人机交互的博士生。我喜欢写关于教育、编程、生活以及偶尔的随想。
参考
[1]https://peps.python.org/pep-0008/
供应链描述性分析的 4 种智能可视化
原文：https://towardsdatascience.com/4-smart-visualizations-for-supply-chain-descriptive-analytics-fda4dfc2829a
使用 Python 构建可视化，提供关键供应链指标的可见性
(图片由作者提供)
供应链分析可以定义为一套工具和技术，您的组织应该使用这些工具和技术从数据中获得供应链运营洞察。
在之前的一篇文章中，我定义了回答不同类型运营问题的四种供应链分析。
供应链分析的 4 个问题—(图片由作者提供)
它从建立描述性分析的基础开始，以监控现在和分析过去。
在这篇文章中，我将分享四种用于描述性分析的 python 智能可视化，它们提供了理解供应链的关键见解。
💌新文章直接免费放入你的收件箱:时事通讯
如果你更喜欢看，查看我的 Youtube 教程！
供应链网络
供应链可以定义为一个为向客户提供服务和商品而构建的流程和库存地点网络。
供应链网络—(图片由作者提供)
网络优化的主要驱动因素是制造地点的位置和流程的优化。
供应链流程
**❓ QUESTION 1**
Which factory is producing for Market XYZ?
你想通过画出生产区和市场之间的流动来了解你的网络的效率。
📊 **CHART 1**
Sankey Chart
在这张图表中，您可以看到所有不同的流程。左边是生产设施，右边是市场。
生产流程桑基图——(图片由作者提供)
**💡 INSIGHTS** - India is the biggest country for production output- Japan market demand is mainly supplied locally- USA and Germany do not have local production facilities📈 **DATA**
You need to prepare a DataFrame with three columns:
- Source: the production facility name
- Target: the market supplied
- Units: the number of items flowing
📚 **LIBRARY**
You can use pySankey
更多详情可以在我的GitHub 资源库 中找到源代码，以及本视频中的详细教程。
电力网设计
供应链网络优化充分利用数据分析，找到工厂和配送中心的最佳组合，以最低成本生产和交付产品。
**❓ QUESTION 2**
Which factories should I open to get an optimal network?
如果您的需求不稳定，您可以运行不同场景的模拟，并要求您的模型(基于线性规划)为每个场景提供最佳解决方案。
动画剧情不同场景——(图片由作者提供)
解决方案基本上是一组列出所有潜在位置的布尔决策变量:如果您打开位置 0 否则它们的值为 1。
📊 **CHART 2**
Boolean Plot
在此图表中，您可以看到 50 种不同场景的结果:
- x 轴:场景的名称
- y 轴:与设施相关的决策变量(深蓝色:开放，白色:关闭)
供应链网络解决方案的布尔图——(图片由作者提供)
**💡 INSIGHTS** - Initial solution with (Indian, Brazil and Japan High + India Low) is repeated in more than 5 five scenarios- Some extreme scenarios need only two factories in India
📈 **DATA**
You need to prepare a DataFrame with the output of your optimization model (vectors with boolean parameters).
📚 **LIBRARY**
You can use matplotlib.pyplot.pcolor
更多详情可以在我的GitHub 资源库 中找到源代码，以及本视频中的详细教程。
产品轮换
在供应链管理中，产品细分是指将具有相似物流特征(如轮换)的产品分组的活动。
帕累托图
对产品进行分类非常重要，这样才能将精力分配到库存管理、优化仓库运营或设计货架布局上。
帕累托图 &产品轮换—(图片由作者提供)
**❓ QUESTION 3**
How many references make 80% of my total turnover?
这种方法的基础是帕累托原则，也称为 80-20 法则。
大多数时候，你的少数产品(通常在 20%左右)创造了你的大部分出口量(通常在 80%左右)。
📊 **CHART 3**
Pareto Chart
该图可以显示您的产品轮换与帕累托定律的对比情况:
- x 轴:投资组合的参考百分比(%SKU)
- y 轴:它们所代表的出站量的百分比(%框数)
在这个特殊的例子中，你可以很快看到你的投资组合不到总投资的 20%,却贡献了 80%的对外交易量。
排列图——(图片由作者提供)
**💡 INSIGHTS** - Very high rotations (top 5%) make more than 60% of the volume- 20% of the portofolio represent 84% of the outbound volume📈 **DATA**
You need to prepare a DataFrame with the outbound volume of each SKU, their contribution in the total volume and then calculate a cumulative sum.📚 **LIBRARY**
You can use matplotlib.pyplot for a simple plot.
更多详情，可以在我的GitHub 资源库 和中找到源代码，详细教程见本视频。
需求可变性的 ABC 分析
帕累托图回答了这个问题:推动你大部分销售的参考是什么？
需求可变性
然而，如果你想知道如何将你的努力分配给库存管理，你需要包括另一个参数:需求可变性。
需求分布的两个不同例子—(图片由作者提供)
事实上，如果一个产品有稳定的需求，它需要的关注和优化会比一个需求非常不稳定的产品少。
因此，您希望在产品分类中结合销售分布和需求可变性。
- 平均销售额:
- 标准偏差:
- 变异系数:CV = σ/
对于 CV 值高的 SKU，您可能会面临不稳定的客户需求，这将导致工作量高峰、预测复杂性和缺货。
Plot CV = f(%Sales) 为了了解哪些产品会带来计划和分销方面的挑战，我们将计算每个参考的销售年度分布的变异系数。
CV = f(%销售额)对于爱好 SKU —(图片由作者提供)
A 类产品(红色):前 5%
- CV>1 的项目:高资源分配以管理其库存，因为它们代表了需求非常不稳定的大部分收入
B 类产品(绿色):15%以下
- CV <1: you can manage them with generic rules
- Items with CV> 1 的项目:分配适度的努力和资源以最小化缺货
C 级产品(蓝色):80%剩余慢速跑步者
- 为这些跑得慢的人分配最少的努力和资源
物流绩效
您的分销网络的表现可以用一句话来概括
您是否完全按时交付您的最终客户？
这是通过分析、运营审查和持续改进计划推动绩效管理的核心问题。
装运跟踪
供应链描述性分析使用分销链中不同系统生成的数据来跟踪货物经过的每个步骤的时间戳。
在战术层面上，您拥有跟踪最近创建的订单状态的分销计划团队。
**❓ QUESTION 4**
Where are my shipments?
从订单创建到商店交付，您的货件经历了不同的步骤:
商店送货示例—(图片由作者提供)
对于每一步，您的系统会在流程开始和结束时记录时间戳。
📊 **CHART 3**
Stacked Bar Plot
装运状态的堆积条形图—(图片由作者提供)
在时间 t，此图表显示了按当前状态划分的装运:
- x 轴:订单按订单创建日期分组
- y 轴:装运数量
- 图例:您的货件从订单创建到商店交付的当前状态
**💡 INSIGHTS** - 100% of the orders created before 05th May are delivered
- A majority of the shipments created the 8th are blocked in the clearance📈 **DATA**
You need to prepare a DataFrame by grouping orders by creation date and current status and count them.📚 **LIBRARY**
You can use matplotlib.pyplot for a bar plot selecting stacked=true
更多详情可以在我的GitHub 资源库 中找到源代码。
结论
关注我的媒体，获取更多与数据分析和供应链管理相关的文章。
物流绩效管理
这些非常简单的图表可以为供应链设计、优化和监控提供非常有价值的见解。
连接不同的系统后，您可以详细了解补货订单创建和商店交付之间的每个步骤。
带有时间戳的端到端分发流程—(图片由作者提供)
- 订单接收时间:订单在 WMS接收并准备入库时的时间戳
- 仓库操作 : 拣货，装箱，出货 由 WMS 跟踪
- 运输:订单从出货到交货的跟踪
- 门店收货:当门店团队正在接收ERP 中的出货时的时间戳
在订单创建过程中，计划员会添加一个要求交付日期，该日期可用于计算每个流程的目标时间。
这可用于计算可用于管理物流绩效的全部准时(OTIF) KPI
- 构建视觉效果来衡量每个流程的 OTIF 和交付周期
- 进行延迟交付的根本原因分析，以确定流程故障
- 实施持续改进计划来解决这些问题
欲知详情，
https://www.samirsaci.com/logistic-performance-management-using-data-analytics/
关于我
让我们连接上 Linkedin 和 Twitter ，我是一名供应链工程师，正在使用数据分析来改善物流运营和降低成本。
如果你对数据分析和供应链感兴趣，可以看看我的网站
https://samirsaci.com
4 个 SQL 过滤概念，改善您的数据争论游戏
原文：https://towardsdatascience.com/4-sql-filtering-concepts-to-improve-your-data-wrangling-game-91284393356c
让我们了解一些常见的 SQL 过滤技巧，数据科学家可以用它们来加快查询速度
照片由贾费尔·尼扎米@unsplash.com 拍摄
作为数据科学家，我们大多数人习惯于使用 pandas (在 Python 上)或 dplyr (在 R 上)来过滤表格。事实上，在两个库中，以及在我们用来编写算法的语言环境中，都有一些更方便的争论操作。
但是，如果您的数据源位于某个数据库中(并且您可能使用一些 SQL 接口来访问它)，那么使用 SQL 代码并在服务器端执行这些操作，一些过滤器和表操作会更有效。
过滤表格是使用 SQL 时最常见的操作之一。从表面上看，它们似乎很简单，你只要加上一个子句就行了。但是..过滤器不只是看起来那么简单，而且会很快变得复杂。
学习如何应用不同的过滤方法并利用带有IN、AND、OR、优先级和通配符的WHERE子句将极大地改进您的 SQL 游戏。在本帖中，我们将探索在从表中过滤行时可以应用的那些额外的技巧。在这篇文章结束时，你应该能够理解大多数 SQL 查询中最复杂的 WHERE 语句。
我将使用一个包含学校学生数据的示例表——该表完全是虚构的，所有姓名和信息都是虚构的。我正在一个sandbox数据库中创建这个表:
create table sandbox.students (
student_id integer auto_increment primary key,
student_full_name varchar(30),
favorite_classes varchar(150),
student_age integer,
birth_date date,
degree varchar(30)
);
insert into sandbox.students (
student_full_name, favorite_classes, student_age, birth_date, degree
) values ('John Smith', 'Mathematics, Political Science, Biology', 23, '1999-03-01', 'Engineering'),
('Amy Smith', 'History, Political Science, Biology', 23, '1999-03-01', 'History'),
('Joe Adams', 'History, Mathematics', 23, '1999-06-01', 'History'),
('Joe Williams', 'Biology, Chemistry', 22, '2000-03-01', 'Chemistry'),
('Anne Williams', 'Mathematics, Arts', 22, '2000-03-16', 'Mathematics'),
('May Taylor', 'History, Geography', 22, '2000-05-19', 'History'),
('Zoe Brown', 'Physical Education, History', 21, '2001-02-18', 'Physical Education'),
('Jennifer Davies', 'Biology, Chemistry', 21, '2001-03-19', 'Chemistry'),
('Robert Jones', 'Chemistry, Biology, Mathematics', 21, '2001-06-02', 'Chemistry');
我们的学生表包含 9 名大学生的数据——虽然样本很少，但这应该足以理解我们将探讨的过滤概念之间的主要差异。
让我们改进我们的 SQL 游戏！
和/或
这两个子句之间的区别——AND、OR——在过滤器中非常重要，并且考虑到了其他编程语言中常用的逻辑操作。
想象一下，从我们的学生表中，我们想要对“化学”专业的所有学生进行分组。使用标准的WHERE子句很容易做到，比如:
select * from sandbox.students
where degree = 'Chemistry'
这将输出所有的化学学生，在本例中为 3:
返回数据-化学专业学生-作者图片
但是，如果我们只是想对 21 岁的化学系学生进行分组呢？我们可以用一个AND子句做到这一点:
select * from sandbox.students
where degree = 'Chemistry' AND student_age = 21;
返回数据—21 岁的化学专业学生—图片由作者提供
AND子句使我们能够选择两个条件并且只选择与两个条件完全匹配的行。在这种情况下，我们只选择degree = 'Chemistry' 和 student_age = 21 —这两个条件都必须与输出集中要返回的行相匹配。
很自然，一个问题出现了。如果我们只想匹配其中一个条件呢？这意味着我们希望选择匹配第一个条件或第二个条件的行——这在 SQL 中也非常简单，使用OR子句:
select * from sandbox.students
where degree = 'Chemistry' OR student_age = 21;
返回数据—化学或 21 岁学生—作者图片
请注意，我们在这个结果中有 4 名学生，这是因为我们选择了有degree = 'Chemistry' 或 student_age = 21的学生。在这种情况下，学生只能匹配WHERE子句中的一个条件。
这就是为什么我们有一个体育生在那里，那个学生 21 岁，只符合那个条件。
这是 SQL 过滤器中最简单有效的概念之一。然而，您会注意到，当您开始使用多个AND和OR子句时，事情会变得相当混乱。这就是过滤优先级进入画面的地方。
运算符优先级
SQL 允许在同一个WHERE中组合多个AND和OR条件。这真的很酷，但是也增加了我们查询的复杂性。
幸运的是，通过学习过滤优先级，我们能够浏览更复杂的过滤器背后的逻辑。运算符优先逻辑模仿了我们从数学方程中了解到的内容，例如，想象以下 SQL 查询与我们的学生表:
select * from sandbox.students
where degree = 'Chemistry' OR student_age = 23 AND favorite_classes = 'History, Mathematics';
这个查询的输出是什么？
如果您直接阅读该查询，您认为 SQL 会选择所有拥有化学学位或 23 岁但同时他们最喜欢的课程是历史和数学的学生吗？
哇，这句话真让人费解。让我们把它拆开。
极其重要— AND优先于OR！这意味着与AND相关的子句将作为一个子句连接在一起，因此我们正在搜索:
- 23 岁的学生最喜欢的课是“历史、数学”；
由于AND这两个子句是同时处理的，我们姑且把这个子句称为 1 。
好的，那么degree = 'Chemistry'会从哪里进入画面呢？这个子句是我们在搜索中包含的另一个子句:
- 每个有
degree = 'Chemistry'的学生
姑且称之为第二条款。
继续，我们正在搜索所有符合条款 1 OR条款 2 的学生。这意味着一个不是 23 岁的学生，如果他最喜欢的学位是化学，那么在我们的查询中仍然可以选择他最喜欢的课程是历史和数学。
返回数据-喜欢历史和数学的化学系学生+ 23 岁-图片由作者提供
底线是，SQL 过滤的第一条戒律是:AND优先于OR。第二条戒律是，我们可以使用括号来覆盖这些规则，就像我们在数学方程中所做的那样:
select * from sandbox.students
where (degree = 'Chemistry' OR student_age = 23) AND favorite_classes = 'History, Mathematics';
在这种情况下，操作略有不同— 条款 1 将是:
- 拥有化学学位或 23 岁的学生。
而第二条是:
- 喜欢历史和数学课的学生。
在这种情况下，我们希望:“每个有历史和数学课的学生，无论是化学还是 23 岁。在这种情况下，只有一个学生符合条件:
返回数据-喜欢历史和数学的 23 岁或化学专业的学生-图片由作者提供
注意一个括号是如何改变整个查询结果的！运算符优先级非常重要，会完全改变返回数据的结果。总之:
AND优先于OR- 括号改变了优先级，并人为地为括号内的代码创建了一个优先级。
不错！让我们继续另一个概念，用多个OR条件减少我们代码的重要部分。
在/不在
IN和NOT IN操作符是编写需要同时匹配多个元素的条件的非常酷的方式。例如，假设我要求您从表中筛选出以下学生:“乔·亚当斯”、“约翰·史密斯”和“艾米·亚当斯”。
知道了OR条件，您可以立即编写以下查询:
select * from sandbox.students
where student_full_name = 'Joe Adams' or student_full_name = 'John Smith' or student_full_name = 'Amy Smith';
返回数据-约翰·史密斯、艾米·史密斯或乔·亚当斯-作者图片
这似乎是一个合理的结果，但是..假设你想从 20 个名字中挑选一个？真的要把OR条件写 20 遍吗？我觉得不是！
幸运的是，我们有IN操作员来帮助我们！
select * from sandbox.students
where student_full_name IN ('Joe Adams','John Smith','Amy Smith');
IN操作符作为一个多重OR条件，但是以一种更优雅的方式编写。在IN内部，我们可以添加多个元素进行匹配，而无需多次重复"or student_full_name ="。
NOT IN的工作方式完全相同，但它不包括括号内的元素:
select * from sandbox.students
where student_full_name NOT IN ('Joe Adams','John Smith','Amy Smith');
这将选择所有学生，除了在IN子句中的学生:
返回数据-约翰·史密斯、艾米·史密斯或乔·亚当斯-作者图片
IN子句非常酷和方便——我们可以用它来避免编写非常长的 SQL 语句。
通配符
我们最后的 SQL 过滤概念是通配符。通配符对于基于“子集”条件过滤非常有用。
例如，假设我们希望选择姓氏为“Smith”的所有学生—当然，我们可以拆分列来实现这一点，但是，如果我们知道如何应用通配符，这将是不需要的额外代码。
通配符以三个不同的元素为中心:
LIKE条款；%人物；_字符；
从我们的示例开始—选择姓氏为“Smith”的所有学生:
select * from sandbox.students
where student_full_name LIKE '%Smith';
在这个通配符选择中，%的作用是“不管 Smith 之前是什么”。将这个查询转换成一个句子，我们选择“全名以“Smith”结尾的每一行，不管前面是什么”。
返回数据-所有姓“Smith”的学生-图片由作者提供
如果我们想从表中选择所有的“Joe ”,该怎么办？那很简单！我们只是将通配符%放在我们正在搜索的元素的末尾:
select * from sandbox.students
where student_full_name LIKE 'Joe%';
返回数据-名字为“Joe”的所有学生-作者图片
酷！所以%总是以这种方式工作——它使得我们的查询不知道我们正在搜索的字符串之前或之后是什么。我们也可以使用双面%:
select * from sandbox.students
where student_full_name LIKE '%am%';
返回数据-姓名中带有“am”的所有学生-按作者分类的图片
最后一个查询将搜索姓名中包含“am”的所有学生。 Am y Smith，Joe Ad am s，Joe Willi am s，Anne Willi am s，双面%不关心我们同时搜索的字符串之前或之后的内容。
最后，我们来检查一下_人物:
select * from sandbox.students
where student_full_name LIKE '_o%';
_明确指出了我们搜索特定字母或字符串的位置。例如，这里我们搜索第二个位置包含“o”的所有名称，这将产生:
返回数据-姓名第二个字母为“o”的所有学生-作者图片
所有这些学生的第二个字母都是“o”。如果我们只想要名字的第三个字母有“e”的学生呢？有了_这个角色也很容易！
select * from sandbox.students
where student_full_name LIKE '__e%';
因为我们现在想要“名字”的第三个位置——我们添加了两个下划线:__。该查询产生:
返回数据-姓名第三个字母为“e”的所有学生-作者图片
通配符是非常酷的过滤元素！掌握通配符将简化您的查询，并使它们真正高效。
我们完事了。感谢你花时间阅读这篇文章。SQL 是一种非常酷的语言，可以为我们的数据争论游戏打气。
作为一名数据科学家，很有可能最终会使用存储在数据库中的数据——掌握其中一些概念将会提高您的生产率和代码效率。
我在Udemy上开设了一门关于从零开始学习 SQL 的课程，我在其中深入探讨了这些概念以及更多内容——这门课程适合绝对的初学者，我希望你能在我身边！
SQL 绝对初学者 —图片由作者提供
https://ivopbernardo.medium.com/membership
评估模型性能的 4 步程序
原文：https://towardsdatascience.com/4-step-routine-to-assess-your-model-performance-ed5b3eb6ccd2
回到基础
Kolleen Gladden 在 Unsplash 上拍摄的照片
我们怎么能说“这个模型概括得很好”，“那个算法执行得很好”，或者简单地说“那个很好”？
在这篇文章中，我们正在研究机器学习中广泛使用的方法和指标，以分析分类模型的性能。
你可能会问:只为了分类？
在回归的情况下，评估更简单，因为它通常只涉及计算平均损失函数，如均方误差(MSE)。该指标表明曲线与数据的拟合程度，并让我们比较不同回归模型之间的性能。
相比之下，分类模型的情况要复杂一些，但是下面的例程可以帮助我们系统地评估和比较模型的性能:
- 计算混淆矩阵
- 计算精度并召回
- 看精度或成本敏感精度
- 评估 ROC 曲线下的面积
混淆矩阵
混淆矩阵是一个表格，显示了每个类别的正确和错误预测的数量。假设我们有一个计算机视觉算法，它将体育图片作为输入，并预测正在播放的内容。例如，我们可以有篮球、棒球和足球类，混淆矩阵如下所示:
体育类别混淆矩阵示例(作者图片)
在多类别分类的情况下，可以单独分析每个类别，但让我们将所有篮球示例视为正面而其他类别视为负面(我可能会有偏见，因为这是我最喜欢的运动)。我们可以观察到，在 14 个篮球示例中，该模型只正确分类了 2 个。换句话说，我们只有 2 个真阳性(TP = 2) 和 12 个假阴性(FN = 12) 。该模型给出了 4 个假阳性(FP = 4) : 3 个实际上是棒球，1 个例子是足球而不是篮球。并且该模型给出了 21 个(5 + 2 + 4 + 10) 真阴性(TN = 21)。
这个练习可以针对每个类别进行，并且对于快速可视化我们的算法的性能特别有用。在我们的例子中，我们可以注意到该算法非常擅长识别足球，但很难区分篮球和棒球。
该模型倾向于错误地预测棒球而不是篮球。太可惜了！在这种情况下，我们可以决定向我们的数据集中添加更多篮球图片的示例，并重新训练该模型。
精确&召回
精确度和召回率可能是评估一个模型最常用的两个比率。精度是所有肯定预测中正确的肯定预测的比例:
对于我们的篮球例子，我们有 2 个正确的预测(TP = 2)和 4 个不正确的肯定预测(FP = 4)。因此精度是 1/3。
召回率是算法能够从数据集中的所有正例中检测到的正例的比例:
对于篮球的例子，我们有 12 个错误的否定，这给了我们只有 1/7 的召回率。
在实践中，你通常会得到很好的精确度或很好的回忆，但不可能同时得到两者。我们通常可以调整超参数，以召回为代价最大化精确度，或者以精确度为代价最大化召回。
精度&对成本敏感的精度
准确度给出了正确分类的例子在所有分类的例子中的比例:
准确度是算法能够做出正确预测的程度的指示。使用这种度量的一个缺点是所有的错误都被认为是一样的。
有时，我们有比其他课程更重要的课程，我们需要不同地惩罚错误。例如，如果我们有一个算法将电子邮件分类为垃圾邮件和非垃圾邮件。误报是指当你的收件箱收到垃圾邮件时，误报是指你朋友的邮件进入了垃圾邮件文件夹。在这种情况下，我会认为假阳性比假阴性更令人讨厌。
处理这个问题的一种方法是通过用两种不同的权重(C1 和 C2)对两种类型的误差(FP 和 FN)进行加权来计算成本敏感的精度。
对于我们的电子邮件示例，如果我们想认为一个错误较少的模型比另一个错误相同但错误较多的模型更准确，我们可以设置 C1 > C2。
ROC 曲线下的面积
受试者工作特性(ROC)曲线是一种评估分类技术性能的直观方法。此方法仅适用于输出置信度的分类算法。例如，我们可以计算神经网络、逻辑回归或决策树的 ROC 曲线。
要绘制 ROC 曲线，我们需要两个指标:
- 真阳性率(TPR)被定义为(与回忆完全一样)正确预测的阳性样本的比例:
- 假阳性率(FPR)被定义为错误预测的阴性样本的比例:
如果我们以输出介于 0 和 1 之间的置信水平的逻辑回归分类器为例。我们可以选择阈值，在该阈值以上，我们认为预测是肯定的，例如 0.5。
为了绘制 ROC 曲线，我们将离散化所有可能阈值的区间(例如:[0，0.1，0.2，0.3，0.4，0.5，0.6，0.7，0.8，0.9，1])，并计算每个水平的 TPR 和 FPR。然后，我们可以计算曲线下面积(AUC ),如下图所示:
作者图片
阈值“1”不会给出任何肯定的预测(FPR=0 和 TPR=0)，阈值“0”只会带来肯定的预测(FPR=1 和 TPR=1)。中间的一切都取决于型号。
完美的分类器将给出 1 曲线下的面积，而随机分类器将给出 0.5 的面积(如右侧的图)。AUC 越大，性能越好，并且通常可以通过选择给出接近 1 的 TPR 和接近 0 的 FPR 的阈值来找到好的分类器。
最后的话
混淆矩阵是分析和比较分类算法性能的良好起点。该矩阵有助于了解我们的分类器是否有一些模式或明显的错误。但是这种方法也有它的局限性，重要的是要考虑其他关键指标，如精确度、召回率和准确度。
然而，在我们讨论的四种方法中，ROC 曲线下面积可能是最有效的技术。ROC 曲线捕获分类的不止一个方面(真阳性率和假阳性率)，并且该曲线相对容易理解和直观快速分析。
好奇想了解更多关于 Anthony 的工作和项目吗？在媒体、 LinkedIn 、 Twitter 上关注他。
需要技术写手？将您的请求发送到https://amigo CCI . io。
利用大脑进行数据可视化的 4 个步骤
原文：https://towardsdatascience.com/4-steps-to-leverage-the-brain-for-your-data-visualisations-6b02c2baafc4
数据可视化
预先注意的属性以及为什么你必须使用它们
作者创建的图片|使用了来自canva.com的免费内容许可元素
作为数据爱好者，我们需要制作可视化产品来适应所有利益相关者。让我们用一点科学来得出我们可视化的结论。我们每天都会接收大量的数据，但是我们的大脑能够通过过滤掉我们所看到的大部分内容，以惊人的速度处理这些数据。我们通过一个叫做前注意处理的过程做到这一点，这是当我们无意识地和自动地注意到我们环境中的某些视觉刺激时。这一切发生得如此之快，以至于我们甚至没有意识到我们正在这样做。这就是为什么某些视觉元素可以如此容易地抓住我们的注意力。这些视觉元素被称为 前注意属性 ，它们包括大小、颜色和在页面上的位置等。
我们的记忆类型
要理解这是为什么，我们必须首先解释记忆是如何工作的。
标志性记忆
你有没有过这样的经历:用眼角看到一样东西，当你转头去看的时候，它不见了？那是你的大脑超速运转，快速有效地处理信息。这种能力被称为形象记忆，它是我们作为一个物种早期的残余，当时捕食者一直是一种威胁。我们的大脑已经进化到能够非常迅速地感知环境的微小变化，这帮助我们生存下来。今天，我们可以用同样的能力来创造有效的视觉交流，抓住人们的注意力并与他们保持联系。所以下次你看到稍纵即逝的东西，不要担心，这只是你的大脑在做它的工作。
短期记忆
任何心理学家都会告诉你，短期记忆是出了名的不可靠。事实上，最近的研究表明，在任何给定的时间，人们在短期记忆中只能保留大约四块视觉信息。这意味着，如果我们试图在一张图中塞进太多的信息，我们的观众很可能会不知所措，并放弃试图破译它。因此，为了避免让我们的观众的短期记忆超载，我们需要注意在每个图表中包含多少信息。当有疑问时，少就是多。
长期记忆
还记得那次你忘了你演示的数据可视化吗？然后你不得不用你在网上找到的随机饼图即兴发挥？我们都经历过。好消息是，有一个科学理由，数据可视化比纯语言数据更有可能帮助我们回忆信息。这都与长期记忆有关。长期记忆是视觉记忆和言语记忆的总和，两者作用不同。语言记忆是通过神经网络获得的，在神经网络中，路径对于识别或回忆变得很重要。另一方面，视觉记忆有专门的结构。这对我们的数据可视化意味着，通过结合视觉和语言，我们为自己的成功做好了准备
这是什么意思？
我们可以利用图标记忆、短时记忆和长时记忆与前注意属性的组合来创建既有粘性又有信息的数据可视化。图标记忆是这样一种记忆，它让我们只需要一些线索就能回忆起一幅图像。例如，可口可乐的标志是一个很容易识别的图像。短期记忆更多的是关于记忆模式，而不是回忆一幅图像。例如，如果我们看到数据可视化使用对比色来突出重要的数据点，我们很可能会记住这种模式，并能够将其应用于其他数据集。长期记忆使我们能够长时间回忆起信息，包括视觉和语言。我们可以用前注意属性来优化这一点。
我们为什么想要这个？
使用前注意属性主要有两种方式:引导注意力和创造视觉层次。
引导注意力:
预先注意属性可以用来引导你的观众的注意力到你希望他们关注的地方。例如，如果你想让你的观众把注意力集中在某个数据点上，你可以让那个数据点的尺寸更大或者颜色更饱和。
创建视觉层次结构:
前注意属性也可以用来创建元素的可视化层次结构。这意味着有些元素会比其他元素更重要，会首先吸引我们的注意力。例如，如果您想让读者先阅读某段文本，您可以将该文本放大或靠近页面中央。
前注意属性——4 个步骤
对于这一点，为了更好地解释特性，最好向您展示。
1.尺寸:
元素的大小是最重要的预先注意属性之一。尺寸较大的元素会比尺寸较小的元素更容易吸引我们的注意力。相对大小表示相对重要性。在创建视觉传达时，请记住这一点。如果你要展示多个具有同等重要性的物品，那么让它们的尺寸都一样。或者，如果只有一个真正重要的部分，用大来表示:让它变得明显！
我们来做个快速练习，数数下面写了多少次大这个词。
要计数的大小单词的图片—由作者创建
对于真正尝试过的人来说，正确答案是 33。或者是 34…现在我怀疑自己…这很难做到！
用 size 的前注意属性再试一次。
要计算的大小单词的图片—由作者创建的图像
容易多了，对吧？现在我确定是 33 岁。有了它，我们能够:
- a)请注意“大”这个词
- b)创建一个层次结构，大是更重要的词。
2.颜色:
颜色是另一个重要的前注意属性。饱和度较高、较亮的颜色会比饱和度较低、较暗的颜色更容易吸引我们的注意力。
尽管如此，不要对色彩着迷！
注意，当使用太多的颜色时，我们会失去原有的价值。它就变成了一道彩虹:
热图示例 1:作者生成的图像和数据
上面是一个有着广泛光谱的热图，在上面的例子中，它在正确的上下文中几乎没有问题。例如，它显示代表温暖程度的颜色；红色是最热的，蓝色是最冷的。因为颜色是有序的，所以会更好。但是想象一下，你有一张随机排列的不同颜色的热图，这对眼睛来说就不那么容易了。所以做一些更微妙的事情，像下面这样:
热图示例 2:作者生成的图像和数据
如上所述，简单大方是最好的方法。
确保颜色一致
当你有一系列充满数据可视化的幻灯片时，确保每一页都有相同的颜色代表相同的东西。例如，在您的第一个图表中，红色代表订单退货，但在下一张幻灯片中，您选择了绿色。观众将不得不重新连接他们的大脑来联想这个；精神疲劳是真实存在的！保持颜色一致。
想起色彩的基调
许多颜色代表一些东西。在大多数社会中，红色意味着坏，绿色意味着好。橙色/红色表示热，蓝色表示冷。如果观众可以很容易地将这些颜色与他们从以前的经验中已经知道的联系起来，这将导致观众立即更好地理解。
3.页面上的位置:
元素在页面上的位置也很重要。靠近页面中心的元素比靠近页面边缘的元素更容易吸引我们的注意力。但是有更多的科学依据，所以让我们来评估一下:
空格
空白是你的朋友，不要害怕留下很多空白。空白导致简单。这使得大脑更容易在页面上的元素之间得出结论。杂乱是你的敌人，让事情尽可能简单！
之字形法则
在当今的大多数社会中，我们从左到右阅读页面。自然地，当看数据可视化时，我们的眼睛仍然遵循之字形模式。如果在演示时，你先告诉观众看页面的底部，然后再看顶部，这是非常尴尬的。对大多数人来说这是不自然的。将作品展示给你的观众，按照从上到下，从左到右的顺序进行。
之字形原则:由作者生成的图像
黄金螺旋
黄金螺旋是一个数学概念，可以应用于数据可视化，以使它们更和谐，更具视觉吸引力。螺旋是从圆心的一点开始，然后围绕它画一系列同心圆而生成的。每个圆圈比前一个稍大，形成一个螺旋形状。通过确保将最重要的数据点放置在可视化的中心，将不太重要的数据点放置在远离中心的位置，可以将相同的原理应用于数据可视化。这将创建一个更具视觉吸引力的数据可视化，使人们更容易理解。
下面是黄金螺旋的描述。
黄金螺旋——摄于 freepik.com
你可以把最重要的观想/订书钉作为焦点。一个人的眼睛会自然地移向那里，使观想更加吸引人。有关这方面的更多信息，请参见以下内容:
https://medium.com/inside-design/a-guide-to-the-golden-ratio-for-designers-b727ce1739ca
4.其他前注意属性
预先注意的属性不仅仅局限于大小、颜色和位置，你可以添加许多更多的特征来帮助你的可视化。这可能意味着箭头，趋势线，参考线等。在下面的例子中，我在图表中添加了一条参考线来显示重要性和背景。
示例:改进图表
现在我们已经概述了所有的功能和步骤。让我们使用一个示例图表，并通过引入前注意属性来改进它。
前思想
请记住，我们的目标是:
- 引导观众去理解什么是重要的
- 创建一个视觉层次。
不要忘记在实现属性之前，记住以下关于内存的内容:
- 图标记忆:一定要用视觉刺激来触发这种记忆
- 短期记忆:少即是多！整理和简化
- 长期记忆:结合视觉和语言，创造模式
这个例子
下面是一个形象化的例子，告诉我们一个关于全球超市产品退货率的故事。
一些背景:
- 作为分析师，我们希望向利益相关者展示哪一类产品的退货率较高(客户在购买后会退回产品)。
- 公司指南说，任何大于 4.5%的百分比都被归类为高回报率的子类别。
空白超市图表示例—作者生成的图表和数据
正如你从上面看到的，这是我们需要告诉观众超市退货情况的所有信息。如果你不知道发生了什么，不要担心，这应该代表一种糟糕的观想。这里有几个问题:
- 文本大小没有区别——因此没有视觉层次，也没有提示告诉我往哪里看；我不知道先看什么。
- 这些标题看起来不够重要，我无法理解。
- 颜色是灰色的，这对我的视觉效果没有任何帮助。
- 这张图表太乱了。难以破译
- 我必须努力寻找回报率高于 4.5%的类别。对于我来说，没有明确的界限或线来快速找出哪个棒线高于 4.5%
- 我不知道为什么底部的两个图表只显示了类别“标签”和“表”的前 5 个返回产品，是因为这两个类别的返回最高吗？在这一点上，我没有线索，除非我适当地研究这一页。
改进
让我们将前注意属性的概念应用到这个图表中。
改进的前注意属性图表——图表和数据由作者生成
在各种预先注意属性改进之后，图表现在在绘制层次结构和关注需要关注的领域方面更加清晰。请参见下文，重点介绍各种特性和改进。
- 页面上的位置:空白；有了更多的空白，图表看起来更容易，结论也更容易得出
- 页面上的位置:黄金螺旋；如果你回头看看黄金螺旋，我把信息中最重要的部分(主要回报百分比图)放在了左下角，覆盖了屏幕的大部分。观众会很自然地将他们的目光转向这个信息中最重要的部分。
- 页面上的位置:之字形规则；从信息量的角度来说，一个观众会先看标题，看图表，看右侧的信息，只有看完主绿/红图表才能理解。我们讲述了它是什么、主要信息和进一步的细节(例如，返回次数最多的前 5 种产品)
- 尺寸；我们在这里使用大小来区分信息的重要性，并把观众吸引到最重要的元素上。每个图表的大小突出了哪个图表是最重要的。一些文本标题有较大的文本来描述信息的重要部分。如果观众选择寻找更多的细节，标题的较小部分只是更多的信息。
- 颜色:图表颜色；前面我提到了色调以及它们所代表的含义。在这种情况下，红色代表不好，用于区分回报率高于 4.5%的类别。观众可以立即看到这两个类别是他们关注的焦点。
- 其他特征:参考线；现在有一条红色参考线，让观众知道 4.5%在哪里，哪个类别超过了这个百分比。
- 颜色:红色文本；我还使用红色文本来突出从图表中得出的重要结论/特征，以使观众更容易理解。
总之:我使用了前注意功能来关注信息的某些部分，并从观众那里引出一个故事。立刻，用一个加粗的标题，我们告诉观众这个页面是什么。然后，从主图表中，他们可以清楚地看到类别“标签”和“表格”的销售具有 4.5%以上的“高回报率”。从这里，他们可以看到这些类别中排名前 5 位的产品，这些产品恰好是 Avery 0522 和 Barrick 的咖啡桌。
一锤定音
正确使用时，前注意属性可以成为数据可视化的有力工具。通过理解人们是如何看待的，并利用这些知识为你创造优势，你可以创造出更有效、更容易让你的观众理解的视觉效果。下一次观想时，不要忘记记忆的类型和属性；尺寸、颜色、位置以及其他有助于得出结论的信息。我们让观众不用想太多！
如果你喜欢这篇文章，请留下掌声和关注支持！
或者，如果您有兴趣加入 Medium 社区，这里有一个推荐链接:
https://medium.com/@adrian.causby15/membership [## 通过我的推荐链接加入 Medium-Adrian caus by
medium.com](https://medium.com/@adrian.causby15/membership)
参考书目
我在数据可视化方面实践的许多原则来自这本被强烈推荐的书:“用数据讲故事；Cole Nussbaumer Knaflic 的《商业专业人员数据可视化指南》
在为您的公司选择合适的数据堆栈之前，您必须知道的 4 个步骤
原文：https://towardsdatascience.com/4-steps-you-must-know-before-choosing-the-right-data-stack-for-your-company-723bfde7aea2
选择和组装贵公司首个数据堆栈的逐步流程
约翰·施诺布里奇在 Unsplash 上的照片
背景
为您的公司选择初始数据堆栈并非易事。数据工具市场每年都变得越来越拥挤，数百种不同的产品和服务很容易让人迷失。
在我担任 Wix 和 Explorium 的首席数据工程师期间，我接触了许多描述公司如何升级其旧数据堆栈或迁移到新数据堆栈的过程的专业资源。另一方面，关于初始堆栈的文章和帖子很难找到。这可能与许多初始堆栈不是由数据工程师选择或作为结构化过程完成的事实有关。
阅读完本文后，您将有一套为您的公司选择合适的堆栈的基本规则。
步骤 1:收集利益相关者的需求和预算
- 访谈(又名，了解你的用户):从采访你组织内的潜在消费者开始，从数据平台了解他们的需求和期望。消费者可能是只与您的 BI 工具交互的业务利益相关者，可能是直接查询数据的分析师，也可能是将数据导入您的平台的软件工程师。
- 将业务需求转化为技术规格:一旦你理解了他们的需求，你的工作就是将它们转化为实际的技术规格。一些最常见的后端/管道规格是数据新鲜度、数量、准确性、可用性和查询性能。对于前端，您可能会考虑仪表板加载时间、自助服务能力和权限管理。
- 制定后勤计划(预算、时间表、资源):这是就平台预算达成一致的时候了。随着使用量的增加，SaaS 数据产品可能会变得昂贵，成本可能会在你的最终决定中发挥重要作用。还建议了解你的依赖者是谁(DevOps、It、法律等。)并确保他们的时间线与你的同步。
步骤 2:起草初始堆栈布局
- 选择组件 最困难的任务之一是选择你的堆栈将要基于的组件(查询引擎、ETL 工具、仪表板工具等。).根据:
a. 您的利益相关者的需求
b. 维护每个组件的团队和他们的知识——例如，他们知道如何编码吗？他们能够部署和维护自托管服务吗？
c. 你自己的知识和眼光 - 创建一个具体的需求列表 为每个组件生成一个所需特性的列表，并按优先级对其进行排序，将重要的特性与可有可无的特性区分开来。在大多数情况下，这一步不会显著缩小你的搜索范围。除非您的涉众已经有了处理数据的经验，否则您可能会得到一个非常通用的特性列表，每个组件的大多数供应商都提供了这些特性。
- 确定优先机制 确保你对每个需求进行了优先排序，并相应地对每个特性的权重进行评分。每个类别中的大多数工具都具有相同的基本特性，其中一些工具提供了独特的功能或集成。你的优先次序将帮助你以后决定是否值得为一个特定的工具支付额外的费用。
第三步:确定市场领导者
集中搜索的最有效方法之一是学习类似组织的经验。找几个和你处于相似阶段(甚至领先 1-2 步)的公司，了解他们选择了哪些产品以及为什么。一些公司通过博客、会议或主题演讲公开分享这些数据，而其他公司则需要你直接接触。
这一过程将帮助您了解谁是您所在市场的主要供应商。我建议考虑市场领导者，主要有两个原因:
- 市场领导者通常有更大的社区和更多的在线信息。不管你的问题是什么，别人可能已经解决了。
- 当你使用的技术处于上升阶段(因为新员工希望获得相关经验)或主流阶段(新员工具备相关知识和经验)时，招聘会更容易。
市场领导者通常是更昂贵的选择。通过查看类似的公司，你更有可能找到那些仍然符合你预算的公司。
第四步:创建你的候选名单并做出最终决定
现在是总结的时候了。对于每个组件，选择 2-3 个符合您的必备要求并被认定为市场领导者的最终候选人。创建一个它们之间的比较表，并包括每一个成本的粗略估计。
如果您觉得所有产品都与您相似，可以考虑申请一个演示帐户或 POC。
通过问正确的问题来帮助他们帮助你——在某些情况下，你需要的功能可以在测试程序中获得，或者即将在不久的将来开发出来。不要被需求之外的特性所诱惑。
在做出最终决定之前，请考虑以下几个方面:
- 组件集成 确保你选择的不同供应商彼此兼容。一些供应商提供多个组件甚至整个堆栈。这可能有助于集成和降低成本，但也会让您陷入供应商锁定。
- 避免供应商锁定 确保你的数据以开源格式保存在你的云存储中。不要让供应商拥有您的数据，并始终保留迁移(部分或全部)到另一个供应商的选项。另一方面，对于仪表板，仍然没有广泛支持的开放格式。这使得仪表板迁移需要手动操作且成本高昂。
- 考虑你公司现有的供应商
如果你的公司与数据供应商有现有的合同(云供应商是一个典型的例子，因为他们都提供完整的数据堆栈)，考虑检查他们。这可能会加快你的过程(因为合同已经建立)并给你一个更好的价格。
最后的建议
请记住，此堆栈只是您的基线。它不会是完美的，随着你公司的发展，它可能不再是一个封闭的解决方案。不要过度设计它，也不要陷入无休止的决策循环。开始行动，收集教训和反馈，你将用于不可避免的重新设计。下一次会更容易。
将熊猫扩展到大型数据集的 4 种技术
原文：https://towardsdatascience.com/4-techniques-for-scaling-pandas-to-large-datasets-acf8805d30eb
提高效率的技巧
S. Tsuchiya 在 Unsplash 上拍摄的照片
Pandas 是数据科学生态系统中最常用的工具之一。它通过提供大量具有易于理解的语法的函数，使得操纵和分析表格数据变得非常容易。
虽然 Pandas 在数据分析和操作方面处于领先地位，但当数据变得非常大时，它的性能开始下降。
是什么让熊猫跑得更慢
主要原因是 Pandas 做内存分析，所以如果数据集大于内存，使用 Pandas 就变得非常困难，或者不可能。
此外，即使数据集有足够的内存，使用 Pandas 也是一个挑战，因为一些操作会产生中间副本。为了对熊猫有流畅的体验，数据集应该相对小于内存。
既然我们在谈论性能，就不可避免地提到熊猫使用单个 CPU 核心来执行操作。在非常大的数据集上，这使得 Pandas 比提供分布式计算的工具要慢。
在本文中，我们将介绍 4 种技术，它们有助于 Pandas 在处理非常大的数据集时更加高效。
值得注意的是，对于 Dask、Vaex、Modin 和 Datatable 等非常大的数据集，还有其他工具和库是更好的选择。
我们不会在本文中讨论这些工具。相反，我们的重点是如何让熊猫更适用，表现更好。
1.你真的需要所有的数据集吗？
数据是数据科学中最有价值的资产，因此我们倾向于收集尽可能多的数据。然而，我们并不需要所有任务的所有数据。
数据集可能包含冗余的列，或者对于特定的任务，我们可能只需要几列。
与其读取整个数据集，然后过滤所需的列，不如只读取我们需要的列。
让我们首先生成一个数据集。下面的代码片段创建了一个有 51 列和 1000 万行的 Pandas DataFrame。50 列用 0 到 10 之间的随机整数填充，另一列包含 A、B、C 和 d 的字符串值。我的计算机花了大约 1 分钟来生成这个数据集。
import pandas as pd
import numpy as np
df = pd.DataFrame(np.random.randint(0, 100, size=(10000000, 50)))
df = df.rename(columns={i:f"x_{i}" for i in range(50)})
df["category"] = ["A", "B", "C", "D"] * 2500000
df 的前 5 行(图片由作者提供)
该数据帧的内存使用量约为 4 GB。
np.round(df.memory_usage().sum() / 10**9, 2)
# output
4.08
在现实生活中，我们可能有比这个大得多的数据集，但这足以证明我们的情况。
我想做一个简单的过滤操作，并衡量它需要多长时间。
%time df[df["category"]=="A"]
# output
CPU times: user 519 ms, sys: 911 ms, total: 1.43 s
Wall time: 2.43 s
大概花了半秒钟。我们还可以测量根据一列或多列中的值对行进行排序需要多长时间。
%time df.sort_values(by=["x_0", "x_1"])
# output
CPU times: user 2.84 s, sys: 1.19 s, total: 4.03 s
Wall time: 4.52 s
按 x_0 和 x_1 列对行进行排序用了 2.84 秒。
让我们将这个数据帧保存为 CSV 文件。
df.to_csv("very_large_dataset.csv", index=False)
考虑这样一种情况，我们只需要这个数据集中的前 10 列。我们可以使用 read_csv 函数的 usecols 参数选择要读取的列列表。
cols = ["category", "x_0", "x_1", "x_2", "x_3", "x_4", "x_5", "x_6", "x_7", "x_8"]
df = pd.read_csv("very_large_dataset.csv", usecols=cols)
df.head()
df 的前 5 行(图片由作者提供)
内存使用量从 4 GB 下降到 0.8 GB。
np.round(df.memory_usage().sum() / 10**9, 2)
# output
0.8
让我们进行与整个数据集相同的过滤操作。
%time df[df["category"]=="A"]
# output
CPU times: user 389 ms, sys: 147 ms, total: 535 ms
Wall time: 629 ms
耗时 389 毫秒，这意味着与处理整个数据集相比，速度快了 25%。排序操作的速度增益更大。
%time df.sort_values(by=["x_0", "x_1"])
# output
CPU times: user 919 ms, sys: 298 ms, total: 1.22 s
Wall time: 1.33 s
耗时 919 毫秒，这意味着与整个数据集的 2.84 秒相比，速度快了 67%。
仅仅节省 1 秒钟可能看起来不是一个显著的改进，但是当你对一个典型的数据清理或数据分析任务进行大量操作时，它会累加起来。更重要的一点是，内存使用量从 4.8 GB 降至 0.8 GB。
2.分类数据的更有效的数据类型
DataFrame 中的每一列都有一种数据类型。有效地选择数据类型可能会减少内存消耗，从而有助于将 Pandas 扩展到更大的数据集。
如果我们有一个基数较低的分类特性，那么使用 category 数据类型而不是 object 或 string 可以节省大量内存。
低基数意味着与值的总数相比，不同的值非常少。例如，我们的数据框架中的 category 列只有 4 个不同的值，而总共有 1000 万个值。
df["category"].unique()
# output
array(['A', 'B', 'C', 'D'], dtype=object)
len(df["category"])
# output
10000000
它当前以对象数据类型存储。让我们检查一下它的内存使用情况。
df["category"].dtypes
# output
dtype('O')
np.round(df["category"].memory_usage() / 10**6, 2)
# output
80.0
类别列的内存使用量是 80 MB。让我们将它的数据类型改为 category，并再次检查内存使用情况。
df["category"] = df["category"].astype("category")
np.round(df["category"].memory_usage() / 10**6, 2)
# output
10.0
它从 80 MB 降到了 10 MB，这意味着内存使用量减少了 87.5%。
3.向下转换数字列
数字列的数据类型可能会导致不必要的内存使用。例如，Pandas 中默认的整数数据类型是“int64”，它可以存储介于-9，223，372，036，854，775，808 和 9，223，372，036，854，775，807 之间的数字。在大多数情况下，我们不需要如此大范围的整数值。
我们可以将整数列向下转换为 int16 或 int8，以减少内存使用。更实际的方法是使用 to_numeric 函数，它可以为我们进行适当的向下转换。
让我们首先检查一个整数列的内存消耗。
df["x_0"].dtypes
# output
dtype('int64')
np.round(df["x_0"].memory_usage() / 10**6, 2)
# output
80.0
是 80 MB。让我们向下转换该列的数据类型，并再次检查内存使用情况。
df["x_0"] = pd.to_numeric(df["x_0"], downcast="unsigned")
df["x_0"].dtypes
# output
dtype('uint8')
np.round(df["x_0"].memory_usage() / 10**6, 2)
# output
10.0
新的数据类型是无符号整数 8，这导致 10 MB 的内存使用量。这也意味着内存使用减少了 87.5%。
我们可以在任何数字列上这样做，无论是整型还是浮点型。在使用 float 的情况下，我们可以将向下转换参数的值设置为“float”。
4.对稀疏数据使用特殊的数据结构
我们可以使用稀疏对象来有效地存储稀疏数据。假设我们有主要包含零的数字列。通过将这些列转换为稀疏数据类型，可以大大减少内存消耗。
它不一定是“大部分为零”。它可以是 NaN 或任何其他值。稀疏对象可以被视为被“压缩”，其中任何匹配特定值(0、NaN 或任何其他值)的数据都被忽略。压缩后的值实际上并不存储在数组中。
让我们看一个例子来说明这个情况。
df_new = df[["x_6", "x_7", "x_8"]].replace(
{2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0}
)
df_new["x_6"].value_counts()
# output
0 8999426
1 1000574
Name: x_6, dtype: int64
上面的数据帧(df_new)包含 3 列，主要由零组成(大约。90%).其他值为 1。让我们检查每一列的数据类型和内存消耗。
df_new.dtypes
# output
x_6 int64
x_7 int64
x_8 int64
dtype: object
np.round(df_new.memory_usage() / 10**6, 2)
# output
Index 0.0
x_6 80.0
x_7 80.0
x_8 80.0
数据类型是 int64，每列消耗 80 MB 内存。如果我们将数据类型转换为 unsigned int8，每列将占用 10 MB 的内存。
df_new = df_new.astype("uint8")
np.round(df_new.memory_usage() / 10**6, 2)
# output
Index 0.0
x_6 10.0
x_7 10.0
x_8 10.0
让我们使用稀疏数据类型来进一步提高内存使用率。
sdf = df_new.astype(pd.SparseDtype("uint8", 0))
np.round(sdf.memory_usage() / 10**6, 2)
# output
Index 0.00
x_6 5.00
x_7 4.99
x_8 5.00
它降到了 5 MB，这也是一个显著的改进。
结论
我们已经介绍了 4 种不同的技术，使熊猫更适合处理大型数据集。重要的是要注意，有其他的选择，但如果你想继续与熊猫合作，你可以使用这些技术来提高效率。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅https://sonery.medium.com/subscribe如果你想在我发表新文章时收到电子邮件。
感谢您的阅读。如果您有任何反馈，请告诉我。
处理时间序列数据中缺失值的 4 种技术
原文：https://towardsdatascience.com/4-techniques-to-handle-missing-values-in-time-series-data-c3568589b5a8
时间序列分析基本指南
图片来自 Pixabay 的 Willi Heidelbach
真实世界的数据通常包含缺失值。包括时间序列数据在内的所有类型的数据集都存在缺失值的问题。丢失值的原因可能是数据损坏或无法在任何给定时间记录数据。
在我以前的一篇文章中，我讨论了处理非时序数据集缺失值的 7 种不同技术:
</7-ways-to-handle-missing-values-in-machine-learning-1a6326adf79e>
时间序列模型使用完整的数据，因此需要在建模或实际时间序列分析之前估算缺失值。时间序列数据集中缺失的值可以使用两种广泛的技术来处理:
- 删除缺少值的记录
- 估算缺失的信息
然而，丢弃丢失的值不是一个合适的解决方案，因为我们可能会丢失相邻观测值的相关性。估计或估算缺失值是处理缺失值的一个很好的方法。
开始使用:
在本文中，我们将讨论 4 种可用于估算时间序列数据集中缺失值的技术:
**1) Last Observation Carried Forward (LOCF)
2) Next Observation Carried Backward (NOCB)
3) Rolling Statistics
4) Interpolation**
样本数据包含 50 天内收集的温度数据，其中有 5 个值随机缺失。
(图片由作者提供)，样本数据集随时间变化的快照
1)最后一次观察结转:
LOCF 是一个简单而优雅的技巧，它将之前没有丢失的值结转或复制，并用丢失的值替换。
**df[‘Forward_Fill’] = df[‘AvgTemperature’].ffill()**
[**ffill()**](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.ffill.html)功能来自熊猫。DataFrame 函数可用于用以前的值估算缺失的值。
(图片由作者提供)，向前插补
2)下一次向后观测:
NOCB 是另一种简单的技术，它复制下一个没有丢失的值，并用前面丢失的值替换。
**df[‘Backward_Fill’] = df[‘AvgTemperature’].bfill()**
[**bfill()**](https://www.geeksforgeeks.org/python-pandas-dataframe-bfill/)大熊猫的功能。DataFrame 函数可用于用以前的值估算缺失的值。
(图片由作者提供)，反向插补
3)滚动统计:
统计技术可用于通过聚合先前的非缺失值来估算缺失值。滚动统计技术可以是:
a)简单移动平均线:
**df[‘SMA’] = df['*AvgTemperature*'].rolling(window=5).mean()**
b)加权移动平均:
***df[‘WMA’] =* data*['AvgTemperature']*.rolling(window=5).apply(lambda x: x[::-1].cumsum().sum() * 2 / n / (n + 1))**
c)指数(加权)移动平均:
**df['EWA] = df['AvgTemperature'].ewm(halflife=4).mean()**
4)插值:
插值技术通过假设数据点范围内的关系来估计缺失值。在滚动统计技术中，只有以前的值被认为是估算缺失值，插值技术使用过去和未来的已知数据点进行估计。
我们有各种插值方法:
- 线性:假设数据点范围呈线性关系
- 样条:估计使整体曲率最小化的值，从而获得通过输入点的平滑曲面。
- 时间:通过更多地关注附近的点而不是远处的点来估计缺失值。
还有各种其他插值技术可用于估算缺失值。所有这些都假设相邻的数据点是相似的，但事实并非总是如此。
**df[‘Interpolate_Spline’]= df[‘AvgTemperature’].interpolate(option=’spline’)**
熊猫。DataFrame 软件包提供使用插值技术估算缺失值。插值实现中的选项参数采用算法('样条'、'线性'、'时间'、'二次'等等)。
结论:
在本文中，我们讨论了处理和估算时间序列数据集中缺失值的各种技术。熊猫。DataFrame 实现了大多数插补技术。
上面讨论的所有算法都假定相邻的数据点是相似的，但事实并非总是如此。有一些先进的插补技术不遵循这一假设。
参考资料:
[1]熊猫文献:https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.html
感谢您的阅读
作为一名早期职业数据专家，我希望知道的 4 件事
原文：https://towardsdatascience.com/4-things-i-wish-i-had-known-as-an-early-career-data-professional-9b97cd9d4bcc
对任何处于数据专业人员职业生涯早期或考虑做出改变的人，有四条主动提供的建议
我很幸运在我的职业生涯中四处走动，并有幸与一些真正伟大的人一起工作。我在这个过程中学到了一些东西，我认为这些东西对任何处于职业生涯早期的数据科学家、分析师或数据工程师都有帮助。
扎克·杜兰特在 Unsplash 上的照片
当你毕业时，学习并没有结束
高中毕业，本科毕业，研究生毕业，博士毕业，训练营毕业，认证毕业，或者其他什么，都应该带着一定的自豪感和成就感。然而，我们太容易被这种感觉所缠绕，决定在已经获得的知识上滑行。数据科学是一个变化迅速的领域。学位和课程提供了一个很好的学习基础，但是这个领域每天都有新的进步。在感兴趣的数据科学领域找到一些好的信息来源，然后用它们来保持你的技能新鲜。当出现特别有趣的消息时，深入研究，努力学习在你的工具箱里放另一个“工具”的技巧。
技术技能不是一切
我也称之为“不要做一个混蛋”的教训。如上所述，你需要继续学习才能在事业上取得成功。然而，那些成功并快速晋升的人，并不单纯关注技术技能。无论职位、头衔或级别如何，没有人愿意与这样的人一起工作:不顾时间表和预算，专注于为每种情况构建最佳解决方案的人，或者让别人对他们创造的东西感到糟糕的人，因为他们太专注于“技术上的正确”
即使你不是一个混蛋，也很容易将培训和认证视为晋升和加薪的主要工具，而完全忽略了关系建设是为下一步做好准备的必要标志。技术技能对于确保你不会在不了解自己需要做什么的情况下进入指导他人的角色非常重要，但技术技能不是让你成为伟大专业人士的唯一因素。
一些读到这里的人可能会对自己说，“如果你想成为一名经理，这很好，但我将在余生中成为一名出色的个人贡献者。”我会反驳说，人际关系对那些走 IC 路线的人来说仍然很重要，相信我，观点会随着时间而改变。[1]
对你的职业积极主动
通过指导和管理，我遇到了两种类型的人，一种是等待下一次机会的人，另一种是出去寻找自己想做的事的人。我的小样本观察发现，那些已经对自己的下一个角色做了标记的人，最终都找到了自己非常满意的职位。
思考工作中的下一步是什么是很自然的。问题是，大多数新星专业人士都申请了领导力发展项目，或者有人给了他们一个机会。在某些时候，你需要把自己放在职业生涯的驾驶座上。在担任了几个角色之后，知道下一步的好选择就变得容易多了。允许别人把你推到一个角色，可能不会产生一份最适合你的工作。
最好的方法是利用你已经获得的知识，开始和你职业生涯中信任的人交流，分享你下一步想做的事情。委婉地告诉你与谁分享这些信息，以及你如何分享，但要找到合适的人来帮助你，这是你需要的，会给你的职业生涯带来奇迹。
关于这一点，另一件值得一提的事情是求职公告板如何在寻找你的下一个机会中发挥作用。求职网上有很多好工作，但这也有点冒险。根据一页纸的工作描述和与经理和同事的 30 分钟谈话，很难辨别一份工作的实际情况。找到一个能带来快乐的角色的更有效的方法是与他人交谈，了解他们现在或未来有什么机会。
如果你不确定你想做什么，蒂姆·厄本有一个很好的练习。这将极大地有助于回答一些关于你自己和你下一步想做什么的深层问题。
https://waitbutwhy.com/2018/04/picking-career.html
关于这个话题，我要说的最后一件事是，如果你对目前的工作不满意，如果你只是想“做些不同的事情”，那么你也不太可能对下一份工作满意努力思考你想要走向什么，而不是你想要远离什么。
领导力不是来自你的头衔
在我大学的一次暑期实习中，一位经理问我:“你在这里的这段时间里，做了哪些展现领导力的事情？”我天真地回答，“我只是个实习生，怎么能展示领导力呢？”然后，他让我明白，领导力不一定纯粹来自职位权力。对他人的影响力和组织能力是适用于任何工作的领导特质。幸运的是，这是我很早就学到的东西，但开始展示你已经准备好领导别人永远不会太晚。
不要等到有人给你一个头衔中带有“领导”、“高级”或“经理”的职位时，才开始展示领导特质。如果你没有展现出这些特征，那么你很可能永远也不会实现这些目标。我想到的几个特质是:组织和影响他人，对自己知道或不知道的事情保持脆弱和诚实，对他人的工作和想法给予他们应得的信任。
包扎
终身学习、关注“软技能”、积极主动的职业规划和领导主动性只是我在职业生涯中学到的一些东西，我希望我能早点知道。我希望分享这篇文章能帮助你在职业生涯中迈出下一步，成为你一直希望成为的数据专家。
[1]如果您想阅读一些不是专门针对数据科学但仍然非常有帮助的观点，我发现这两篇文章非常有帮助:
https://hbr.org/2021/02/promotions-arent-just-about-your-skills-theyre-about-your-relationships https://hbr.org/2007/01/how-leaders-create-and-use-networks
对时间序列应用交叉验证时要做的 4 件事
原文：https://towardsdatascience.com/4-things-to-do-when-applying-cross-validation-with-time-series-c6a5674ebf3a
获得更好的预测性能估计的一些实用建议
照片由思想目录在 Unsplash 上拍摄
这篇文章是关于使用交叉验证评估预测模型的。您将学习一些应用时间序列交叉验证的良好实践。
交叉验证入门
你不应该使用相同的数据来训练和测试一个模型。
这是为什么呢？
一个模型学习尽可能多的模式。一些模式抓住了过去和未来观察之间的真实关系。但是，该模型也学习训练集中的固有噪声。在未来的观测中不能很好概括的侥幸模式。
因此，在相同的数据上训练和测试模型会产生乐观的结果。我们从 1931 年就知道了(！！)【1】。
图 1:过度拟合训练数据的预测模型的示例应用。预测(蓝色)与训练数据(黑色)非常匹配，但与验证数据(红色)不匹配。图片作者。
交叉验证就是为了解决这个问题而开发的。
交叉验证是多次拆分数据的过程。在每次拆分时，部分数据用于训练模型(训练集)。剩下的部分(验证集)用于评估模型的性能。
交叉验证背后的想法是复制一个现实的场景。训练数据充当可用于创建模型的数据。验证集充当您在部署该模型后会遇到的数据。
最终，交叉验证的目标是提供一个可靠的性能评估。评估模型在部署后的表现。
时间序列的交叉验证
k 倍交叉验证
有许多方法可以对数据集进行交叉验证。K-fold 交叉验证是最流行的方法之一。它的工作原理是将数据随机分成 K 份。每个折叠包含相同数量的观察值。然后，每个文件夹被迭代地用于验证。最后，将模型在所有折叠中的性能进行平均，以估计其性能。如果你测试几个模型，你选择一个平均性能最好的。
下图说明了 5 重交叉验证的分割标准。
图 1: K 倍交叉验证(K=5)数据分区。图片作者。
K-fold 交叉验证可以以不同的方式扩展。
- 您可以多次重复该过程，以获得更可靠的结果。这被称为重复 K 倍交叉验证；
- 分层 K 折叠交叉验证确保每个折叠保持原始类别分布；
- 您可以使用组 K 折叠交叉验证来跨不同折叠拆分不同的组。
k 倍交叉验证之所以有吸引力，有两个主要原因。一个是它的简单分裂启发式。另一个是它的数据效率。在某些时候，所有可用的观察结果都用于训练和测试。
为什么 K 重交叉验证不适用于时间序列
交叉验证是在假设观察是独立的情况下进行的。但是，对于时间序列来说，这是不正确的。
时间序列是有序序列。每个观察都多少取决于之前发生的事情。这种依赖性通过诸如自相关的统计来量化。
实用建议
那么，我们应该如何评估预测模型呢？
这个故事的其余部分提供了四个实用的建议来做到这一点。
1.保留时间顺序
保持观察值的顺序是获得可靠估计值的关键。可以说，这是对时间序列应用交叉验证的黄金法则。
如果你打乱观察会发生什么？该模型从未来中学习过去未曾暴露的细微差别。这导致了乐观的估计。
2.在培训和验证之间制造差距
训练集和验证集通常是连续的(见图 2)。因此，验证集的初始部分与训练集的最后部分高度相关。
因此，删除验证集附近的训练观察值是个好主意。这增加了培训和验证之间的独立性。这个过程也称为清洗。
图 2:连续的训练/验证分割(上图)和有间隙的训练/验证分割(下图)。图片作者。
3.创建几个拆分
对所有类型的数据(包括时间序列)进行多次分割通常是一种好的做法。
由于所选原点的特殊性，单个分割可能会有偏差。许多分割将涵盖时间序列的不同部分。例如，不同趋势或季节性模式。
然而，如果你的时间序列很大(比如说，成千上万次观察)，那么多次分割就不那么重要了。
时间序列
那么，哪种方法遵循这些准则呢？
一个例子是 TimeSeriesSplits，scikit-learn 中提供的一个方法。这种方法有不同的名称。这些方法包括时序交叉验证、前推验证或块中的前序验证。
这个想法是将时间序列分割成 K 个连续的块。然后，每个块用于首先测试一个模型，然后重新训练它。
这里有一个图表可以帮助你想象这个过程。
图 3:时间序列分成 5 个部分。图片作者。
现在，训练集和验证集之间存在差距:
图 5:时间序列分成 5 个部分，在训练和验证之间有一个间隔。图片作者。
TimeSeriesSplits 实现与其他 scikit-learn 函数兼容，例如 GridSearchCV。下面是一个优化随机森林的示例:
多个时间序列或组
由马雷克·斯图津斯基在 Unsplash 上拍摄的照片
4.将每个时间序列放在不同的文件夹中
有时你不得不处理许多时间序列，而不仅仅是一个。例如，不同零售产品的每日销售额。每个产品代表一个时间序列。
通常，数据集中的时间序列在某种程度上是相互关联的。因此，您可能希望将每个系列保存在特定文件夹中，以防止信息泄漏。这导致训练集和验证集之间更大的独立性。
在这些情况下可以使用 GroupTimeSeriesSplit 方法。
外卖
在本文中，您了解了在对时间序列应用交叉验证时要考虑的四个方面。
- 保持观察的时间顺序；
- 在培训和验证之间制造差距；
- 制造许多裂缝或褶皱；
- 对于有许多时间序列的数据集，将每个时间序列放在不同的文件夹中。
感谢阅读，下一个故事再见！
进一步阅读
[1]拉尔森，S. C. (1931 年)。多重相关系数的收缩。伊迪克。心理学。, 22:45–55.
[2]阿洛、西尔万和阿兰·塞利塞。“模型选择交叉验证程序的调查。”统计调查4(2010):40–79。
更好地理解 Matplotlib 需要知道的 4 件事
原文：https://towardsdatascience.com/4-things-to-know-to-have-a-better-understanding-of-matplotlib-a84ed54b3b2c
熟悉一个原始的 Python 数据可视化库
托尔加·乌尔坎在 Unsplash 上拍摄的照片
Matplotlib 是我在数据科学之旅中了解的第一批工具之一。我惊讶于它如何允许定制数据可视化的几乎每一个小部分。
另一方面，它的语法似乎很复杂，很难理解。我知道我可以做一些事情，但需要一段时间来找出如何去做。一旦我了解了 Matplotlib 的结构和情节是如何创建的，我就觉得使用它更舒服了。
在本文中，我们将学习四件事，帮助您更好地理解 Matplotlib。
1.图形和轴
由于 Python 是一种面向对象的编程语言，所以我们在 Matplotlib 图上看到的一切都是具有类型的对象就不足为奇了。
图形和轴是主要的对象类型，是绘图的基础。它们也被称为复合对象类型。需要注意的是，Axes 不是 Axis 的复数形式。因此，轴对象与 x 轴或 y 轴没有任何关系。
图形可以被认为是容纳所有东西的最外层容器。所有其他对象在该容器中保持活动状态。一个图形可以有一个或多个轴对象。事实上，我们需要一个 Axes 对象来绘制一些东西。
可以使用 matplotlib.pyplot 接口的 Figure 方法创建图形。
import matplotlib.pyplot as pltplt.figure()
plt.show()**# output**
<Figure size 432x288 with 0 Axes>
我们已经创建了一个默认大小的人物对象。因为它没有任何轴对象，所以没有显示任何内容。
让我们也给 Figure 对象添加一个轴，看看它看起来怎么样。我们还将使用 figsize 参数来自定义人物对象的大小。
fig = plt.figure(figsize=(8,5))
ax1 = fig.add_axes([0.1, 0.1, 0.6, 0.3])
plt.show()
(图片由作者提供)
add_axes 方法中使用的参数定义了 axes 对象的位置和大小。
2.有些事情可以是含蓄的
在前面的例子中，我们使用 add_axes 方法向一个图形对象添加一个轴。您不必在每次需要添加轴时都这样做。事实上，您很少会看到使用 add_axes 方法。
像创建一个图形对象或添加一个轴这样的事情有时是显而易见的。不要让这个迷惑你。例如，在下面的例子中，我们将创建一个 DataFrame 的 price 列的直方图。
plt.hist(df["Price"])
plt.show()
(图片由作者提供)
我们刚刚使用 hist 函数创建了上面的直方图。我们不必显式创建图形和轴，因为一旦调用绘图功能(如 hist，plot ),这些会自动完成。
当然，我们可以先创造一个人物，然后才是情节。假设我们想要更改该直方图的图形大小:
plt.figure(figsize=(8,4))
plt.hist(df["Price"])
plt.show()
(图片由作者提供)
3.图形和轴上的标签
没有标题和轴标签的图是没有用的。我们应该在不增加阅读难度的前提下，尽可能地增加情节的信息量。但是，标题和标签是必备的。
在 Matplotlib 中，可以使用不同的方法为图形和轴对象添加标题和标签。
在处理 Figure 对象时，我们可以使用 title、xlabel 和 ylabel 方法。
# create a Figure
plt.figure(figsize=(8,4))plt.hist(df["Price"])plt.title("Histogram of Price", fontsize=15)
plt.xlabel("Value", fontsize=14)
plt.ylabel("Frequency", fontsize=14)plt.show()
(图片由作者提供)
当处理 Axes 对象时，相应的方法是 set_ti
# create a Figure with an Axes
fig, ax = plt.subplots(figsize=(8,4))ax.hist(df["Price"])ax.set_title("Histogram of Price", fontsize=15)
ax.set_xlabel("Value", fontsize=14)
ax.set_ylabel("Frequency", fontsize=14)plt.show()
(图片由作者提供)
尽管我们使用不同的方法添加标题和标签，但输出是相同的。因为我们做了一个只有一个轴的图形。我们可以在一个有多个轴的图形上观察到不同。我们将在下一节讨论这个问题。
4.多轴图形
一个图形对象可以包含多个轴对象。我们可以使用支线剧情功能来安排图上的布局。例如，下面的代码片段创建了一个图形，其中 2 个 Axes 对象作为行放置。
fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(8,5))plt.show()
(图片由作者提供)
它是空的，因为我们没有绘制任何内容。让我们绘制直方图，并设置图形和轴对象的标题。
fig, (ax1, ax2) = plt.subplots(nrows=2, figsize=(8,5))# figure title
fig.suptitle("Histogram of Price and SalesQty", fontsize=15)# plot on the first Axes
ax1.hist(df["Price"])
ax1.set_title("Price", fontsize=14)# plot on the second Axes
ax2.hist(df["SalesQty"])
ax2.set_title("SalesQty", fontsize=14)# adjust the spacing between subplots
fig.tight_layout(pad=1)plt.show()
(图片由作者提供)
当处理带有支线剧情的人物时，我们使用 suptitle 方法给整个人物添加一个标题(不是 title 方法)。
与 Seaborn 和 Plotly 等其他流行的替代库相比，Matplotlib 是一个低级库。因此，我们应该编写更多的代码来创建数据可视化，这样做的好处是可以完全控制我们绘制的内容。
了解图的结构以及 Matplotlib 如何处理这些定制是充分利用这个惊人的库的必要步骤。
我们在本文中介绍的内容将帮助您更好地理解 Matplotlib 的工作原理。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅https://sonery.medium.com/subscribe如果你想在我发表新文章时收到电子邮件。
感谢您的阅读。如果您有任何反馈，请告诉我。
更有效地使用 Python 熊猫的 4 个技巧
原文：https://towardsdatascience.com/4-tips-for-using-python-pandas-more-efficiently-8dd9a850b979
简单而实用的指南
照片由西蒙孙在 Unsplash
Pandas 是一个非常实用的功能库，用于数据分析和操作任务。自 2019 年以来，我一直在使用熊猫，它一直能够为我的任务提供解决方案。
在使用熊猫大约 3 年后，我意识到我一开始并没有非常有效地使用它。在某些情况下，我解决某个特定问题的方法比最优解要长。我也没有非常有效和准确地使用一些功能。
我仍然能够完成任务。然而，当我发现更好更实用的做事方法时，我的整个工作流程都得到了改善。
在这篇文章中，我将分享 4 个小贴士，帮助你充分利用熊猫。让我们从创建示例中使用的样本数据帧开始。
import numpy as np
import pandas as pddf = pd.DataFrame({
"Team": ["A","A","B","B","B",np.nan,np.nan,"C"],
"Player": [
"John","Jane","Ashley","Emily","Matt","Jenny","Max","Alex"
],
"Score": [81, 84, np.nan, 91, np.nan, 86, 94, 89]
})df
df(作者图片)
我们有一个 3 列 8 行的数据框架，在 team 和 score 列中有一些缺失值。
1.具有空值的 value_counts 函数
value_counts 函数是最常用的 Pandas 函数之一。它计算一列中每个不同值的出现次数。默认情况下，它不考虑空值(即缺失值)。这可能会产生误导，尤其是当我们处理大文件的时候。
df["Team"].value_counts()**# output**
B 3
A 2
C 1
Name: Team, dtype: int64
team 列中有空值，但是我们在 value_counts 函数的输出中看不到它们。我们可以通过使用 dropna 参数让它计算空值，如下所示。
df["Team"].value_counts(dropna=False)**# output**
B 3
A 2
NaN 2
C 1
Name: Team, dtype: int64
现在输出更准确了。
2.使用其他列填充缺失值
现实生活中的数据集通常包含无法忽略的缺失值。我们需要正确处理它们，以产生准确可靠的输出。
我们有不同的选项来填充缺失的值。最佳方案取决于数据和任务的特征。例如，我们可以使用列平均值来填充缺失的值。处理时间序列数据时，上一个或下一个值可能是更好的选择。
另一种选择是使用其他列中的数据。在我们的数据框架中，我们可以使用球员列来填充球队列中缺少的值。我将向您展示完成这项任务的两种不同技术。第一种方法是使用 loc 方法手动选择缺失的值。
df.loc[df["Team"].isna()==True, "Team"] = df["Player"]
左侧选择“团队”列中缺少的值。右侧将 player 列中的值分配给这些值。
第二种是直接使用 fillna 函数。
df["Team"].fillna(df["Player"], inplace=True)df
df(作者图片)
3.使用 Python 字典
Dictionary 是 Python 内置的数据结构。它对于数据分析和处理中的各种任务来说非常方便。我们也可以将它们与熊猫功能一起使用，使它们更有用。
例如，replace 函数用于替换列或数据帧中的值。假设我们有一个包含每个球员的球队数据的球队字典。
teams = {
"John":"A",
"Jane":"A",
"Ashley":"B",
"Emily":"B",
"Matt":"B",
"Jenny":"C",
"Max":"C",
"Alex":"C"
}
我们可以使用这个字典将球队列中的球员姓名替换为他们的球队名称。
df["Team"] = df["Team"].replace(teams)df
df(作者图片)
我们也可以这样做:
df["Team"] = df["Team"].replace("Jenny","C")
df["Team"] = df["Team"].replace("Max","C")
这肯定不如用字典方便。此外，我们可能需要替换几个值。在这种情况下，使用字典只用一行代码就可以完成任务，而不是编写几行代码。
您可以用 Python 字典增强其他一些 Pandas 函数。这里有一篇我写的关于这个话题的更详细的文章。
</4-python-pandas-functions-that-serve-better-with-dictionaries-bbfcc6c39fa5>
4.缺少值的整数列
分数列中的值是整数，但它们显示为浮点数。原因是该列中缺少值。
整数的默认数据类型不支持空值，因此数据类型被强制转换为浮点型。如果将这些值表示为整数很重要，可以使用可空整数数据类型。
df["Score"] = df["Score"].astype(pd.Int64Dtype())df
df(作者图片)
现在分数显示为整数。
数据清理和操作是任何面向数据的产品的重要组成部分。Pandas 提供了一些功能和方法来加快和简化您的工作流程。为了最大限度地利用熊猫，你应该尝试发现任何功能的全部潜力。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅https://sonery.medium.com/subscribe如果你想在我发表新文章时收到电子邮件。
*https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。*
用 Python 从日期时间中自动提取数据的 4 个工具
原文：https://towardsdatascience.com/4-tools-to-automatically-extract-data-from-datetime-in-python-9ecf44943f89
如何从文本中提取日期时间，从日期时间中提取数据
动机
日期时间功能对于时间序列和预测非常重要。然而，您并不总是有干净的日期时间特性可以使用。
如果能自动从文本中提取 datetime，从 datetime 中提取数据，岂不是很好？
作者图片
在这篇文章中，你将学习 4 种工具来做到这一点。
datefinder:自动查找 Python 字符串中的日期和时间
作者提供的视频
您是否曾经想从非结构化的文本中提取日期和时间，但是发现很难做到？ datefinder 允许你在 Python 字符串中自动查找不同格式的日期和时间。
作者图片
输出:
Date and time: 2021-05-17 09:00:00
Only day: 17
Date and time: 2021-05-18 10:00:00
Only day: 18
要安装 datefinder，请键入:
pip install datefinder
Maya:自动将字符串转化为日期时间
如果要将字符串类型转换为日期时间类型，常见的方法是使用strptime(date_string, format)。但是指定你的 datetime 字符串的结构是相当不方便的，比如%Y-%m-%d %H:%M:%S.%f%z。
datetime.datetime(2016, 12, 16, 18, 23, 45, 423992, tzinfo=datetime.timezone.utc)
maya 帮助您自动将字符串转换为日期时间。你只需要解析字符串，maya 就会计算出你的字符串的结构。
作者图片
datetime.datetime(2016, 12, 16, 18, 23, 45, 423992, tzinfo=<UTC>)
maya 还允许您轻松地将一个时区转换为另一个时区:
datetime.datetime(2016, 12, 16, 12, 23, 45, 423992, tzinfo=<DstTzInfo 'US/Central' CST-1 day, 18:00:00 STD>)
要安装 maya，请键入:
pip install maya
Fastai 的 add_datepart:在一行代码中添加相关的 DateTime 特性
在处理时间序列时，年、月、周、一周中的某一天和一年中的某一天等其他特征对于预测未来事件非常有帮助。
有没有一种方法可以在一行代码中获得所有这些特性？
Fastai 的add_datepart方法可以让你做到这一点。
作者图片
为了了解这种方法是如何工作的，让我们从创建一个简单的数据帧开始。
作者图片
接下来，我们将使用add_datepart向 DataFrame 添加日期特性。
我们将看到以下新列:
这是新数据帧的外观:
要安装 Fastai，请键入:
pip install fastai
Workalendar:用 Python 处理工作日计算
如果您想用 Python 处理日历、假期和工作日相关的计算，请使用 Workalendar 。
作者图片
Workalendar 支持全球近 100 个国家。让我们看看在美国有什么假期。
输出:
在日本度假:
我们还可以使用 Workalendar 来检查特定日期是否是工作日:
False
False
计算两个指定日期之间的工作日:
81
很方便，不是吗？
要安装 Workalendar，请键入:
pip install workalendar
结论
恭喜你！您刚刚学习了如何使用 4 种不同的工具自动提取日期时间及其特征。我希望本文能为您提供从日期时间数据中获取更多信息所需的知识。
随意发挥，并在这里叉这篇文章的源代码:
https://github.com/khuyentran1401/Data-science/blob/master/time_series/extract_date_features.ipynb
我喜欢写一些基本的数据科学概念，并尝试不同的数据科学工具。你可以在 LinkedIn 和 T2 Twitter 上与我联系。
星这个回购如果你想检查我写的所有文章的代码。在 Medium 上关注我，了解我的最新数据科学文章，例如:
💔-tools-to-track-and-visualize-the-execution-of-your-python-code-666a153e435e> [## 3 个跟踪和可视化 Python 代码执行的工具
towardsdatascience.com](/3-tools-to-track-and-visualize-the-execution-of-your-python-code-666a153e435e) [## 使用 dirty_cat 对脏类别进行相似性编码
towardsdatascience.com](/similarity-encoding-for-dirty-categories-using-dirty-cat-d9f0b581a552)
每个数据科学家都应该知道的 4 种 SQL 连接类型:可视化表示
原文：https://towardsdatascience.com/4-types-of-sql-join-any-data-scientists-should-know-hands-on-practice-4a1d119c00ad
创建表和运行所有四种 SQL 连接的完整指南。
卡斯帕·卡米尔·鲁宾在 Unsplash 上的照片
动机
关系数据库试图对现实生活中的实体及其关系进行建模。但是，作为一名数据从业者，在与这些数据库交互时，您将会处理不止一个表。与这些表的有效交互需要对联合语句有更好的理解，因为每个表给出不同的结果。
本文将首先帮助您理解每个**JOIN**条款，然后带您进行实际操作。在此之前，我们将从头开始创建相关的表。
输入数据
为了更好地理解这个过程，我们需要下面两个表:**StudentTable**和**TeachingAssistantTable.**本节的目的是创建这些表，并用一些示例数据填充它们。
创建表格
创建一个表很简单，在我们的数据库中，两个表都是按如下方式创建的。这一部分对于理解本文的其余部分不是强制性的。
→ 学生桌
- 每一行
**StudentTable**将代表单个学生的信息。
创建学生表的 SQL 脚本
→ 助教表
**TeachingAssistantTable**的每一行将代表一个教师的信息。
创建教学助理表的 SQL 脚本
填充表格
现在我们的表已经创建好了，我们最终可以使用 INSERT INTO [table name] VALUES 语句用新数据填充它们。
→ 学生桌
将数据上传到学生表的 SQL 脚本
→ 助教表
下面是这两个表的最终表示。
学生(学生表格)和助教(助教表格)表格(图片由作者提供)
我们为什么要连接表
如果您已经踏上了 SQL 之旅，您可能已经听说过联接，但是我们为什么要使用它们呢？**JOIN**语句是 Oracle、Microsoft SQL、MySQL、PostgreSQL 等关系数据库中的重要子句。它用于创建单个表，该表是两个或多个表的组合，基于这些表之间的一些逻辑关系。
联接有哪些不同的类型？
现在您已经知道了它的用途，让我们来探索一下[X]类型的连接。
1.内部连接
让我们从这个简单的例子开始。我们想知道哪些学生也是老师。换句话说，学生表和教师表中匹配的行在哪里，这意味着它们的交集。我们可以看到我们的两个表都包含 Ibrahim 、 Mamadou 和 Fatim 。
这就是**INNER JOIN**派上用场的地方。它只查看基于在**ON**子句中指定的列的两个表之间的交集。例如，下面的指令根据 Email 列获取所有相交的行。
**SELECT** *
**FROM** StudentTable st
**JOIN** TeachingAssistantTable tat **ON** st.Email = tat.Email;
**SELECT******* 表示从所有表中“获取所有列”。**FROM** StudentTable st创建 st 作为 StudentTable 的别名，这意味着无论何时我们想要使用 TeacherTable，都可以使用st来代替。这同样适用于TeachingAssistantTable tat**JOIN** TeachingAssistantTable tat **ON st.Email = tat.Email**表示仅从两个表中获取具有相同电子邮件的行。
这是我们从前面的 SQL 命令中得到的图形结果。
应用于 StudentTable 和教学辅助表的内部连接(图片由作者提供)
该连接不仅适用于电子邮件中的关键列，还适用于用户决定在**ON**子句中使用的任何列。例如，它可能是:**ON st.Student = tat.Teacher**，这将生成表，其中学生姓名等于教师姓名。
22。左外连接 /左连接
这种类型的连接处理两种类型的表的连接:主表和辅助表。主表是等号左边的表。它是这样工作的:
- 识别在条款的中指定的列。
- 从主表中取出所有行，没有任何区别。
- 基于 on 子句中的列，二级表中与主表不匹配的所有行都被丢弃(替换为 NULL)。
**SELECT** *
**FROM** StudentTable st **LEFT JOIN** TeachingAssistantTable tat
**ON** st.Email = tat.Email;
这是我们从左连接得到的图形结果。
左连接应用于 StudentTable 和教学辅助表(图片由作者提供)
3。右外连接/右外连接
这个连接与上一个非常相似。唯一的区别是，它认为右边的表是主表，左边的表是次表。
**SELECT** *
**FROM** StudentTable st **RIGHT JOIN** TeachingAssistantTable tat
**ON** st.Email = tat.Email;
这是我们从正确的连接中得到的图形结果。
应用于学生表和教学辅助表的右连接(图片由作者提供)
4。全外连接
完全外连接是左连接和右连接的组合。在该语句中，没有丢弃两个表中任何一个表的行的余地，它们都被考虑在内。它的工作原理如下:
- 对原始表执行右外连接，并将结果视为临时表 1。
- 对原始表运行左外连接，并将结果视为临时表 2。
- 连接临时表 1 和 2 作为最终结果。
**SELECT** *
**FROM** StudentTable st **FULL OUTER JOIN** TeachingAssistantTable tat
**ON** st.Email = tat.Email;
应用于 StudentTable 和 TeachingAssistantTable 的完全外部连接(图片由作者提供)
从前面所有的最终结果中，我们注意到我们选择了所有表中的所有列，这为诸如 Email、Student 和 Teacher 等列创建了重复的值。然而，我们可以在**SELECT**子句中指定我们希望在最终结果中出现的列。例如，以下指令返回学生姓名、电子邮件、性别、年龄和学位中的所有列。
**SELECT** st.Student, st.Gender, st.Email, st.Age, tat.Degree
**FROM** StudentTable st **INNER** **JOIN** TeachingAssistantTable tat
**ON** st.Email = tat.Email;
内部联接应用于 StudentTable 和带列选择的教学辅助表(图片由作者提供)
结论
本文介绍了 SQL 中的四种主要连接情况。SQL 的多功能性可以为您提供帮助企业分析数据和做出明智决策的技能。
如果你喜欢阅读我的故事，并希望支持我的写作，考虑成为一个媒体成员解锁无限制访问媒体上的故事。
在 Medium 、 Twitter 和 YouTube 上随意关注我，或者在 LinkedIn 上问好。讨论人工智能、人工智能、数据科学、自然语言处理和人工智能是一种乐趣！
人工智能提高生产力的 4 种方式
原文：https://towardsdatascience.com/4-ways-ai-can-improve-your-productivity-bfa239de5535
帮助您提高写作效率的工具集
凯文·巴加特在 Unsplash 上的照片
使用人工智能或机器学习进行工作，听起来你需要成为一名拥有多年编码经验的高端程序员。但这只是部分正确。有几个无代码工具可以帮助您提高工作效率，并拥有一个易于使用的图形界面。
然而，它们使用专用的机器学习算法来执行任务，这使得它们比其他可比工具好得多。这里有一些我最喜欢的工具，可以帮助你们大多数人节省时间。
文本摘要
每当你需要深入新的主题时，就会有成千上万的有趣的文章或论文可供你阅读。大多数时候，你只有时间去深入阅读两到三篇文章，但是有十篇甚至更多的文章你应该去读完。
所以，下次就让人工智能帮助你决定哪些文本是最重要的，并专注于阅读它们。有几个在线工具，你可以导入你的文本，并获得文本的机器学习摘要。
QuillBot 界面|图片:截图 Quillbot
有几个选项可供您使用。您可以直接粘贴您想要总结的文本，也可以上传一个文本文档来使用这些段落。此外，还有一个将摘要长度从短设置为长的选项。所以，下次不要浪费时间去读每一篇你应该读的文章，让它先被总结。基于此，你可以决定阅读是否有助于解决你的任务。
翻译服务
在全球化的世界中，我们经常面临这样的情况:我们需要用另一种语言写电子邮件、发短信或做演示。但是如果你需要用一种非你母语的语言来写任何一种文本，这可能比仅仅用你的母语来写要花费你更多的时间。
让人工智能在这些情况下通过接管翻译来支持你，这样你就可以专注于内容的质量。这样，你可以用任何你觉得舒服的语言创建一个文本，然后把它翻译成你需要的语言。
DeepL 翻译器界面|图片:截图 DeepL
对于大多数语言和文本来说，这些工具可以给你很好的翻译，几乎不需要修改。
自动化文本创建
在我们开始翻译文本之前，我们首先要写它。在大多数情况下，这是一项非常耗时的任务，即使我们已经对主题有了概念和基本结构。
通常，文本越多越好，无论是产品描述文本还是其他种类的营销描述。对于这个用例，市场上也有不同的工具，可以帮助您增加已经开始的短文本的字数。
Sassbook AI 作家界面|图片:截图 Sassbook
使用这个人工智能工具，你可以开始输入一个大约 20-30 个单词的文本，并从这个初始句子中生成 50 多个单词。这可能是你进一步写作的良好基础，也许只需要一两处修改。
校对
最后但同样重要的是，我们要确保我们的文章或文本在语法和拼写方面是准确无误的。这可能是一项耗时耗力的工作，因为你必须注意每一个单词或检查每一个逗号，如果你不是用母语写作，这就特别复杂。
从这篇文章到目前为止，你可以想象，人工智能是我们的后盾。Grammarly 提供了一个高端的语法、拼写和标点符号检查工具，非常适合英语。
语法|图片:截图语法
这样，你就可以开始写了，并且可以确保所有的错误都被自动标记出来。你可以在图片下方链接的网站上使用这个工具，或者使用大多数互联网浏览器提供的浏览器插件，它会自动检查你写在里面的所有内容。
结论
人工智能和机器学习可以在很多方面支持你的日常写作。有多种工具可以让你在无代码环境中使用人工智能模型的力量。因此，即使没有任何编码或人工智能的知识，你也可以从这个领域取得的巨大进步中受益。
享受使用它们的乐趣！
如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！还有，medium 允许你每月免费阅读 3 篇 。如果你希望有无限制的 访问我的文章和数以千计的精彩文章，不要犹豫，点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$5***获得会员资格**
*https://medium.com/@niklas_lang/what-are-deepfakes-and-how-do-you-recognize-them-f9ab1a143456 https://medium.com/illumination/top-6-big-data-jobs-b5af240e8b44 *
我使用数据科学技能从副业中创收的 4 种方式
原文：https://towardsdatascience.com/4-ways-im-using-data-science-skills-to-generate-income-from-side-hustles-638fffc0bbca
用你的热情建立多种收入来源
在 Unsplash 上由 Garrhet Sampson 拍摄的照片
在过去的几年里，在保持一份朝九晚五的全职工作的同时在线赚钱的流行程度有了相当大的增长，尤其是在疫情时代。一些幸运的少数人已经成功地让他们的团队在达到某个目标后忙于他们的全职工作。一个很好的例子是阿里·阿卜达尔，一个从给医学院学生提供学习建议开始的YouTube，现在是 YouTube 的全职明星，拥有超过 300 万订户和超过 100 万美元的总广告收入。
这是很多人想要开始他们的侧推时所渴望的。然而，对于大多数人来说，这是一个漫长的过程，可能需要几年时间。
在过去的一两年里，我已经利用我的数据科学、岩石物理学和机器学习知识建立了一些额外的收入来源。
在本文中，我将与您分享利用这些技能的四个流，以及它们目前为我带来的好处。这是为了向您展示什么是可能的，并为您提供思路，开始自己的一面，并利用您的数据科学技能和知识。
在媒体上写文章
超级抓拍者在 Unsplash 上的照片
学习新的事物和技能是一个终生的过程，我们永远学不完。许多人喜欢自己学习，把知识留给自己，这很好。但是，如果你真的想巩固你的知识，并找出你所知道的任何潜在的差距，那么分享你所学到的是一个很好的方法。
写文章和博客是一个很好的方式来分享那些你希望 6 个月前就知道的小技巧和窍门。不仅如此，它可以让你建立个人品牌，开始在网络社区中获得一些认可，当然也可以为你写的东西赚钱。
像 Medium 这样的平台使得开始分享你所知道的东西变得很容易。在达到 100 个关注者并发布至少一个故事后，你将能够参加媒体合作伙伴计划，该计划允许你从你的文章的浏览量和阅读量中赚钱。
通过正确的搜索引擎优化，你可以很容易地将你的文章放在谷歌搜索结果的第一页，这可以带来持续的有机流量。假设人们正在搜索这个话题。
自 2021 年 1 月以来，我一直是中型合作伙伴计划的一部分，我在第一个月获得了 3.68 英镑。2021 年，我的发帖时间表与发表的文章数量不一致，从 0 到 4 不等。这导致每月有少量收入(3-100 美元)。
自 2022 年 3 月以来，我一直在稳步增加我在这个平台上分享的内容量(每月 5 至 8 篇文章)，并在 8 月达到了我的最大支出 333.73 美元。
中等合作伙伴计划收入 2022。图片由作者提供。
数据科学领域的一些中型作者一个月可以赚几千美元。例如，的吉姆·克莱德·蒙赫在今年 7 月和 8 月赚了 2000 多美元。如果你想得到启发，可以点击下面的链接查看他的总结:
https://medium.com/illumination/august-2022-stats-and-earnings-report-6cbdf1f7ea52
如果你想尝试在媒体上写作，并想获得所有文章，那么你可以使用 我的链接 这里注册。
开始 YouTube 频道
照片由诺德伍德主题在 Unsplash 上拍摄
为 YouTube 制作内容是一种吸引观众和获得额外收入的流行方式，然而，这并不是最容易的途径，但却是一种有利可图的创收方式。据估计，每天有 720，000 小时的视频内容上传到这个平台。
有了 YouTube，你可以通过多种方式获得收入。其中包括:
- 在视频上播放的广告
- 公司和产品赞助交易
- 在描述中包含附属链接
- 链接到您自己的课程和产品
要获得在您的渠道投放广告的资格，您需要达到特定的里程碑:
- 1000 名订户
- 4000 个观察小时
- 没有社区指导方针罢工
即使你达到了这些里程碑，你的账户也必须接受审查，并经过几个步骤才能开始投放广告。一旦它被审查和批准，你就可以通过谷歌 Adsense 在你的视频中添加广告。
开始时，你可以选择多种内容，包括教育性、娱乐性或提供评论。如果你已经为 Medium 或者你自己的博客写了东西，你可以把你的内容放到 YouTube 上去。在这些文章中，你可以包含你的视频链接，以增加你的频道的流量。
我的 YouTube 体验
我在 2021 年 7 月左右创建了 YouTube，从那以后，我一直在慢慢积累我的观众、浏览量和观看时间。我现在拥有大约 2900 名用户，这远远超出了我最初的预期。
正如你在下面看到的，我仍然没有达到在我的频道上投放广告的资格标准，但是，我离它不远了。从 2021 年 11 月到 2022 年 4 月，我暂停了内容制作，这可能会推迟制作过程。
目前为止我对我的 YouTube 频道的看法。图片由作者提供。
如果你想在 YouTube 上起步，并担心在设备上花费大量金钱，那么不用担心。你很可能会在附近有一个手机形式的摄像头，并且有免费软件(例如 OBS Studio )来记录你的屏幕。
我很幸运地从一台 DSLR 相机开始，它过去是，现在仍然是我摄影的主要相机。从那以后，我逐渐购买了更多的物品，这些物品逐渐改善了我的内容。
要想了解更多关于如何在 YouTube 上起步的信息，我强烈推荐你去看看阿里·阿布达尔关于这个主题的视频:
创造数字产品
直到最近，我才开始深入研究创造和销售数字产品的世界。今年年初，我看到几个 Twitter 账户在推广一款名为 opinion 的软件的模板。
在过去的几年里，我一直热衷于使用 ideal 作为我的一体化工作空间。我用它来记录任务、内容规划、项目管理等等。所以我想我应该试着做一些模板。
使用 idea 构建管理数据科学项目和资源的单一场所。图片由作者提供。
现在，这并没有完全利用我的数据科学技能，但我最近创建的一个模板是数据科学中心。这是一个一体化的仪表板，我可以在其中管理数据科学项目、任务、代码片段等。
整个概念是为了帮助我的数据科学之旅，但是，我重新包装了它，并开始将其作为模板出售，供任何人购买。自从它上市以来，我已经卖出了 4 台。不多，但它在两个月内带来了 51.25 美元的额外收入。
如果你想了解数据科学中心，你可以在下面的文章中找到它的详细信息。
https://medium.com/illumination/using-notion-for-data-science-777bd04870fe
联盟营销
另一个领域，许多人可以通过联盟营销赚大钱。
这是一个通过链接，在你的博客和/或视频描述上推广他人产品的过程。作为回报，当有人点击其中一个链接并购买该产品时，你会获得一小笔佣金。
亚马逊联盟是最受欢迎的，也可能是最大的联盟计划之一。注册是免费的，当你注册后，你就可以获得亚马逊出售的大量产品。
正如你在下面看到的，我通常会在我的 YouTube 描述中包含一些我读过的书籍的链接，并强烈推荐给其他人。
推广 YouTube 视频描述中的附属链接。图片由作者提供。
这并不是我收入的主要来源。我报名参加了英国和美国的课程，由于英国课程缺乏销售，我被取消了。至于美国方面，我总共赚了 7.47 美元。
亚马逊联盟计划结果。图片由作者提供。
当推广你的链接时，重要的是要声明这些链接是附属链接，你可以从中赚取一小笔佣金。我强烈推荐阅读下面的文章来理解在 Medium 上使用联盟链接的一些复杂性。
https://medium.com/feedium/can-you-use-amazon-affiliate-links-in-your-medium-articles-7334f5212046
未来领域
我目前正在探索一些可能有额外收入潜力的领域。其中包括在 python 和数据科学领域创建在线课程和更具针对性的数字产品。
因为总是有一个以上的收入流是首选。这样，如果其中一家倒闭，你仍有其他收入来源带来一些收入。
感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您也可以* 注册我的简讯 免费将更多内容直接发送到您的收件箱。
其次，你可以通过注册成为会员来获得完整的媒介体验，并支持我和成千上万的其他作家。每月只需花费你 5 美元，你就可以接触到所有精彩的媒体文章，也有机会通过写作赚钱。
如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！**
你需要知道的在 Pandas 中加载数据的 4 种方法
原文：https://towardsdatascience.com/4-ways-to-load-data-in-pandas-you-need-to-know-f6a2d6bc9a98
熊猫图书馆的隐藏瑰宝
照片由斯科特·格雷厄姆在 Unsplash 上拍摄
熊猫让领先数据变得简单！我们可以使用pd.read_csv()和pd.read_excel()函数轻松加载 CSV 或 Excel 文件。但是我们可以扩展它们的功能，使加载数据更容易、更直接！
在本指南中，您将学习:
- 如何从剪贴板加载数据，
- 如何一次读取一个工作簿中的所有 Excel 表格，
- 如何在一个目录中加载多个工作簿，以及
- 如何将多个列合并成一个日期列
我们开始吧！
从剪贴板加载数据
如果你正在处理网上或工作中的电子表格中的小数据，你可以使用pd.read_clipboard()函数加载数据。让我们看看这个过程是什么样子的。将下面的文本复制到剪贴板上:
Name Age Score
0 Evan 33 85
1 Kate 34 90
2 Nik 32 85
3 Kyra 35 95
然后运行以下命令，这将输出结构化数据帧:
如何从剪贴板中读取数据帧
很酷，对吧？在下一节中，您将学习如何一次读取一个文件中的所有 Excel 表格。
一次读取所有 Excel 表格
Pandas 提供了一种非常有用的方法，可以一次加载 Excel 工作簿中包含的所有工作表。这可以通过使用pd.read_excel()功能并在sheet_name=None中加载来完成。想跟着去吗？你可以在这里下载数据集。(数据集完全虚构，由作者提供。)
当None用作参数时，Pandas 将加载一个数据帧字典，其中键是表名，数据帧是值。
从那里，我们可以使用pd.concat()函数来传递字典的值。让我们看看这个是什么样子的:
如何将 Excel 文件中的所有工作表读入单个数据框
当我们访问字典的值时，会返回一个类似列表的结构。我们可以将它传递给pd.concat()函数，函数会一个接一个地追加数据帧。
一次加载多个工作簿
在这一节中，您将学习如何使用 Pandas 在一个目录中同时加载多个工作簿。你可以在这里下载文件，并将它们加载到一个文件夹中。(关于数据集的快速说明:它是作者出于虚构的目的而创建的)。
让我们看看我们在上面的代码中做了什么:
- 我们导入熊猫和操作系统库
- 我们将目录加载到一个变量中，
file_path - 然后，我们使用列表理解来创建文件的路径列表
- 然后，我们使用
pd.concat()函数追加所有的数据帧
在下面的最后一节中，您将学习如何从多个专栏中提高阅读日期。
改进多列的阅读日期
Pandas 使得将某些列解析为日期变得很容易。然而，可能让您感到惊讶的是，您可以解析来自不同列的日期组件。
我们的工作表包含月、日和年，它们分布在不同的列中。我们可以将它们组合在一起，作为单个日期时间列来读取。这可以通过传递一个包含要解析的列的列表来实现，比如[['Month', 'Day', 'Year']].
但是，我们可以更进一步，使用下面的代码为列指定一个名称:
通过传入字典，我们可以为结果列指定一个名称。这还会阻止读取单个列，从而使数据帧变得更小。
结论
在这篇文章中，你学到了与熊猫一起工作时阅读数据的四个隐藏的宝石！熊猫提供了大量的功能，很难找到你想要的东西。希望你能学到新的东西！
在生产中搞乱计算机视觉模型的 4 种方法
原文：https://towardsdatascience.com/4-ways-to-mess-up-your-computer-vision-model-in-production-d4e198486928
或者在将图像发送到神经网络之前仔细的图像预处理的重要性
凯文·Ku 在 Unsplash 上的照片
介绍
这篇文章不是关于模型的质量。它甚至与扩展、负载平衡和其他开发无关。这是一个更普遍但有时会被忽略的事情:处理不同种类和不可预测的用户输入。
在训练模型时，数据科学家几乎总是有一个受控的数据环境。这意味着使用已经准备好的数据集，或者有时间和资源来手动收集、合并、清理和检查数据。通过准确地做到这一点，可以提高根据这些数据训练的模型的质量。
想象这个模型足够好，可以部署到生产中。在最好的情况下，仍然可以控制环境(传统的服务器端部署)。但即便如此，用户还是会从各种各样的设备和来源上传图片。在边缘部署的情况下，还有一层复杂性:人们无法控制环境。
在这两种情况下，模型应该立即回答，开发人员没有时间手动检查数据。因此，至关重要的是:
- 即时准备数据
- 尽可能接近训练时预处理
否则，实际生产模型的质量可能会比预期的低得多。发生这种情况是因为人们给数据引入了模型没有预料到的偏差。
真实案例
在接下来的内容中，我将讲述我在我的修图初创公司中从事计算机视觉模型工作时遇到的 4 个问题。
每个都与图像处理相关，然后再传递给算法(主要是神经网络):
- 存储在 EXIF 的方向
- 非标准颜色配置文件
- 图像库的差异
- 调整大小算法
对于每一项，我都会提供一个案例研究，其中包含示例和一段在生产中为我解决该问题的代码。
所有代码示例、数据和环境细节都可以在 GitHub 资源库中找到:https://github.com/vladimir-chernykh/cv-prod-tips
存储在 EXIF 的方向
如今，人们使用手机相机拍摄大多数照片(约 91%，这个数字还在增长)。【来源】。
通常，移动设备以某个预先确定的固定方向存储图像，而不管拍摄照片时真实的相机位置如何。恢复初始方位所需的旋转角度作为元信息存储在 EXIF 中。例如:iPhone 总是横向存储 JPEG 图像。除此之外，在 EXIF 还有一个旋转(和镜像)角度。【信号源 1 、信号源 2 】。
iPhone 12 上作者的照片。方向储存在 EXIF 和 Mac 的“预览”正确处理它。
在移动设备或现代桌面软件上观看这样的图像可能没问题，因为它们可以处理这些 EXIF 信息。但是当 engineer 以编程方式加载图像时，许多库读取原始像素数据并忽略元信息。会导致错误的图像方向。在下面的例子中，我使用了 PIL ，这是用于图像处理的最流行的 Python 库之一。
图像通过代码读取。
向神经网络发送这样的图像可能会产生完全随机的结果。
要解决这个问题，我们需要读取 EXIF 信息，并相应地旋转/镜像图像。
PIL 允许读取 EXIF 元信息并解析它。人们需要知道在哪里寻找方向。令人惊叹的 Exiftool 文档对此有所帮助。存储必要信息的字节是 0x0112。相同的文档提示如何处理每个值，以及如何处理图像以恢复初始方向。
考虑到 EXIF，图像通过代码读取。
这个问题似乎已经解决了，对吗？嗯，还没有。
让我们试试另一张照片。这一次我将使用现代的 HEIF 图像格式，而不是旧的 JPEG(注意，为此需要一个特殊的 PIL 插件)。iPhone 默认以这种格式拍摄 HDR 图片。
iPhone 12 上作者的照片。方向储存在 EXIF 和 Mac 的“预览”正确处理它。
一切看起来都一样。让我们试着以一种天真的方式从代码中读出它，而不去看 EXIF。
图像通过代码读取，不考虑 EXIF。
原始图像方向正确！但是 EXIF 建议应该逆时针旋转 90 度！所以方向恢复代码会失败。
这是 HEIC 中 iPhone 拍摄的一个已知问题。【信号源 1 、信号源 2 、信号源 3 。由于某些不清楚的原因，iPhone 可以正确存储原始像素，但在以这种格式拍照时，仍然在 EXIF 保持传感器方向。
因此，当图像是在 iPhone 上以 HEIC 格式拍摄时，应该修正算法并省略旋转。
考虑到 EXIF，图像通过代码读取。
当然，来自其他设备的图像方向可能会有更多的问题，这段代码可能并不详尽。但是它清楚地显示了一个人在处理用户输入时应该有多小心，即使没有恶意，用户输入也是不可预测的。
非标准颜色配置文件
元信息隐藏了另一个挑战。图片可能被拍摄并存储在不同的色彩空间和色彩配置文件中。
有了色彩空间，就或多或少的清晰了。它定义了用于存储每个像素的图像颜色信息的通道。两种最常见的色彩空间是 RGB (红-绿-蓝)和 CMYK (青-品红-黄-黑)。人们几乎不会错过 CMYK 的图像，因为它们有不同的通道数:RGB 是 4 对 3。因此，将它发送到网络会因为错误的输入通道数而立即中断它。所以这种从 CMYK 到 RGB 的转换很少被遗忘。
颜色配置文件是一件非常棘手的事情。它是输入(摄像机)或输出(显示)设备的特征。它说明了特定于设备的记录或显示颜色的方式。RGB 色彩空间有许多不同的配置文件 : sRGB ， Adobe RGB ，显示 P3 等。每个配置文件都定义了自己将原始 RGB 值映射到人眼感知的真实颜色的方式。
这导致相同的原始 RGB 值可能在不同的图片中暗示不同的颜色。为了解决这个问题，需要仔细地将所有图像的颜色配置文件转换成一个选定的标准。通常，它是 sRGB 配置文件，因为由于历史原因，它是所有 web 的默认颜色配置文件。
iPhone 12 上作者的照片。颜色配置文件是“显示 P3 ”,存储在 EXIF。
在 iPhone 上拍摄的图片通常会显示 P3 颜色配置文件。让我们从代码中读取图像，看看有无颜色配置文件转换的情况。
通过带有(右栏)和不带有(左栏)颜色配置文件信息的代码读取图像。
人们可以看到，用色彩简档转换读取的图像更鲜明，更接近原始图像。根据图片和颜色配置文件的不同，这种差异可能会更大或更小。有些图像甚至可能看起来像没有配置文件转换的棕褐色。
发送到神经网络中的颜色(即像素值)可能会影响最终质量并破坏预测。因此，恰当地与他们合作至关重要。
图像库的差异
正确读取图像极其重要。但同时，一个人应该尽可能快地做它。因为在云计算时代，时间就是金钱。此外，客户不希望等待太久。
这里的最终解决方案是切换到 C/C++。有时，它在生产推理环境中可能完全有意义。但是如果你想留在 Python 的生态系统中，还是有选择的。每个图像库都有自己的功能和速度。
到目前为止，我只使用 PIL 模块。为了便于比较，我将采用另外两个流行的库: OpenCV 和 Scikit-image 。
让我们看看每个库读取不同大小的 JPEG 图像的速度有多快。
该图显示了不同库的读取速度如何取决于图像大小。
对于小图像，几乎没有区别。但是对于大的，OpenCV 比 PIL 和 Scikit-image 快大约 1.5 倍。根据图像内容和格式(JPEG、PNG 等),这种差异可能从 1.4 倍到 2.0 倍不等。).但总的来说，OpenCV 要快得多。
网络上还有其他可靠的基准测试[ 源 1 、源 2 ]给出了大致相同的数字。对于图像写入来说，这种差异可能更加显著:OpenCV 快了 4-10 倍。
一个更常见的操作是调整大小。在将图像发送到神经网络之前，人们几乎总是会调整图像的大小。而这正是 OpenCV 真正闪光的地方。
这里我取了一张 7360x4100 的图片，并把它的尺寸缩小到 1000x1000。OpenCV 比 PIL 快 22 倍，比 Scikit-image 快 755 倍！
选择正确的库可以节省大量的时间。需要注意的是，相同的调整大小算法在不同的实现中可能会产生不同的结果:
这里可以注意到，我对 OpenCV 和 PIL 都使用线性插值进行下采样。原始图像是相同的。但是重新划分的结果是不同的。差异非常显著:每种像素颜色的平均得分为 255 分中的 5 分。
因此，如果在训练和推断期间使用不同的库来调整大小，可能会影响模型质量。所以应该密切关注。
调整大小算法
除了不同库之间的速度差异，即使在同一个库中也有不同的调整大小算法。应该选择哪一个呢？至少，这取决于想要减小图像尺寸(下采样)还是增大图像尺寸(上采样)。
有多种算法来调整图像大小。它们产生的图像质量和速度不同。我将只看这 5 个，它们足够好和快，并且在主流库中得到支持。
下面提供的结果也符合一些准则和例子。【源 1 、源 2 、源 3 。
亚历克斯·克里维克在 Unsplash 上拍摄的照片。应用不同的调整大小算法对同一图像进行下采样。
对于下采样，“面积”算法看起来是最好的(描述幕后发生的事情超出了本文的范围)。它产生的噪音和伪像最少。事实上，它是遵循 OpenCV 指南的下采样的首选。
现在让我们对这个“区域”进行上采样——将下采样图像恢复到原始大小，看看在这种情况下哪种算法效果最好。
Alex Krivec 在 Unsplash 上拍摄的照片。应用不同的调整大小算法来对同一图像进行上采样。
对于上采样，算法产生更一致的结果。然而，“三次”插值看起来最不模糊，最接近原始值(“lanczos”提供了类似的结果，但要慢得多)。
因此，这里的最终结论是对下采样使用“区域”插值，对上采样使用“立方”算法。
请注意，正确的调整大小算法选择在训练期间也很重要，因为它提高了整体图像质量。更重要的是，训练和推理阶段的调整大小算法应该是相同的。否则你已经知道会发生什么。
结论
在这篇文章中，我描述了我在从事计算机视觉工作的这些年中多次遇到的真实案例和问题。如果处理不当，它们中的每一个都可能会显著降低生产中的模型质量(即使训练数量是可以的)。我很乐意在评论中讨论你的案例！
Pandas 操作速度提高 4 倍，代码更改最少
原文：https://towardsdatascience.com/4x-faster-pandas-operations-with-minimal-code-change-bc7079792184
停止等待熊猫行动。将它们并行化。
Pandas 的一个主要限制是在处理大型数据集时速度会很慢，尤其是在运行复杂的操作时。这可能会让需要在工作中处理和分析大型数据集的数据科学家和分析师感到沮丧。
有几种方法可以解决这个问题。一种方法是使用并行处理。
一起运行多个熊猫操作！通过稳定扩散成像。
输入 Pandarallel
Pandarallel 是一个开源 Python 库，支持使用多个 CPU 并行执行 Pandas 操作，从而显著提高了速度。
它建立在流行的 Pandas 库之上，只需要很少的代码修改就可以使用。
声明:我不隶属于 pandarallel。
利用 Pandarallel 实现显著的速度提升
你可以亲眼看看熊猫与熊猫的速度相比有多快。在这里，pandarallel 将工作负载分布在 4 个内核上。
来源: Pandarallel 的文档
更具体地说，从下面的图表中可以明显看出速度的提高。
加速 4 倍。来源: Pandarallel 的文档
Pandarallel 入门
要安装 Pandarallel，您可以使用 pip 软件包管理器:
pip install pandarallel
您可以将包导入 Python 代码并初始化它。
from pandarallel import pandarallel
# Initialize pandarallel
pandarallel.initialize()
完成后，您就可以使用下面提供的函数了。
如何使用 pandarallel 的代码示例
让我们首先创建一个模拟数据框架，其中包含从电子商务网站购买的商品。每行对应于在每个日期购买的一种产品。这些列是:
dateproduct_idquantity
import pandas as pd
import numpy as np
# Generate a dataframe.
df = pd.DataFrame()
# Generate a column of random dates from 2019-01-01 to 2019-12-31
df['date'] = pd.date_range('2019-01-01', '2019-12-31', periods=10000)
# Seed numpy random
np.random.seed(0)
# Generate a column of random product_id from 1 to 5
df['product_id'] = np.random.randint(1, 5, 10000)
# Generate a column of quantity bought from 1 to 100
df['quantity'] = np.random.randint(1, 100, 10000)
这是前五行。
| | date | product_id | quantity |
|---:|:--------------------|-----------:|---------:|
| 0 | 2019-01-01 00:00:00 | 1 | 10 |
| 1 | 2019-01-01 00:52:25 | 4 | 36 |
| 2 | 2019-01-01 01:44:50 | 2 | 79 |
| 3 | 2019-01-01 02:37:15 | 1 | 33 |
| 4 | 2019-01-01 03:29:41 | 4 | 59 |
接下来，让我们使用pandarallel来加快我们的工作流程。为此，让我们初始化我们的 pandarallel。
from pandarallel import pandarallel
# Initialize pandarallel
pandarallel.initialize()
请注意，您有几个初始化 pandarallel 的选项。
# Initialize pandarallel with a progress bar
pandarallel.initialize(progress_bar = True)
# Set the number of workers for parallelization.
# By default, this is the number of cores available.
pandarallel.initialize(nb_workers = 4)
# Initialize pandarallel with all logs printed.
# By default, this is 2 (display all logs), while 0 display n ologs.
pandarallel.initialize(verbose = 2)
使用 parallel_apply 对列应用函数。
让我们从date列中提取月份。例如，一月是 1，二月是 2。为此，我们可以使用parallel_apply函数。
# Group date by month using parallel_apply
df['month'] = df['date'].parallel_apply(lambda x: x.month)
| | date | product_id | quantity | month |
|---:|:--------------------|-----------:|---------:|------:|
| 0 | 2019-01-01 00:00:00 | 1 | 10 | 1 |
| 1 | 2019-01-01 00:52:25 | 4 | 36 | 1 |
| 2 | 2019-01-01 01:44:50 | 2 | 79 | 1 |
| 3 | 2019-01-01 02:37:15 | 1 | 33 | 1 |
| 4 | 2019-01-01 03:29:41 | 4 | 59 | 1 |
我们也可以在parallel_apply中使用一个lambda函数。让我们为每个product_id指定一个价格。然后，我们可以计算每笔交易的revenue。
# Assign a price to each product_id
df['price'] = df['product_id'].parallel_apply(lambda x: 5.59 if x == 1 else 1.29 if x == 2 else 3.49 if x == 3 else 6.99)
# Get the revenue
df['revenue'] = df.parallel_apply(lambda x: x['quantity']* x['price'], axis=1)
| | date |product_id |quantity |month |price |revenue |
|--:|:--------------------|----------:|--------:|-----:|-----:|-------:|
| 0 | 2019-01-01 00:00:00 | 1 | 10 | 1 | 5.59 | 55.9 |
| 1 | 2019-01-01 00:52:25 | 4 | 36 | 1 | 6.99 | 251.64 |
| 2 | 2019-01-01 01:44:50 | 2 | 79 | 1 | 1.29 | 101.91 |
| 3 | 2019-01-01 02:37:15 | 1 | 33 | 1 | 5.59 | 184.47 |
| 4 | 2019-01-01 03:29:41 | 4 | 59 | 1 | 6.99 | 412.41 |
使用 parallel_apply 对组应用函数。
您也可以在应用parallel_apply之前按特定列分组。在下面的例子中，我们可以按特定的月份分组，并获得每个月的总收入。
# Get the sum of revenue for every month
monthly_revenue_df = df.groupby('month').parallel_apply(np.sum)[['revenue']]
更好的是，我们也可以使用parallel_apply 执行滚动求和。
# Generate 3-month rolling revenue by month
monthly_revenue_df['rolling_3_mth_rev'] = monthly_revenue_df['revenue'].rolling(3, min_periods=3).parallel_apply(np.sum)
| month | revenue | rolling_3_mth_rev |
|--------:|----------:|--------------------:|
| 1 | 188268 | nan |
| 2 | 164251 | nan |
| 3 | 176198 | 528717 |
| 4 | 178021 | 518470 |
| 5 | 188940 | 543159 |
使用 parallel_applymap 将函数应用于整个数据帧
如果有一个函数适用于整个数据帧，applymap是理想的函数。例如，要将df的所有元素转换成一个字符串，我们可以使用这个函数。
# Convert every element of df to a string
df.parallel_applymap(lambda x: str(x))
完整的代码
import pandas as pd
import numpy as np
from pandarallel import pandarallel
# Generate a dataframe.
df = pd.DataFrame()
# Generate a column of random dates from 2019-01-01 to 2019-12-31
df['date'] = pd.date_range('2019-01-01', '2019-12-31', periods=10000)
# Seed numpy random
np.random.seed(0)
# Generate a column of random product_id from 1 to 5
df['product_id'] = np.random.randint(1, 5, 10000)
# Generate a column of quantity bought from 1 to 100
df['quantity'] = np.random.randint(1, 100, 10000)
# Initialize pandarallel
pandarallel.initialize()
# Group date by month using parallel_apply
df['month'] = df['date'].parallel_apply(lambda x: x.month)
# Assign a price to each product_id
df['price'] = df['product_id'].parallel_apply(lambda x: 5.59 if x == 1 else 1.29 if x == 2 else 3.49 if x == 3 else 6.99)
# Get the revenue
df['revenue'] = df.parallel_apply(lambda x: x['quantity']* x['price'], axis=1)
# print(df.head().to_markdown())
# Get the sum of revenue for every month
monthly_revenue_df = df.groupby('month').parallel_apply(np.sum)[['revenue']]
# Generate 3-month rolling revenue by month
monthly_revenue_df['rolling_3_mth_rev'] = monthly_revenue_df['revenue'].rolling(3, min_periods=3).parallel_apply(np.sum)
# print(monthly_revenue_df.head().to_markdown())
何时不使用 pandarallel
当数据不适合存储时，我们不应该使用 Pandarallel。在这种情况下，使用spark或pyspark或vaex。
阅读我关于使用 Vaex 每秒处理 90 亿行 的文章。
也就是说，pandarallel 有多种用例可以让数据科学家受益。停止等待您的 pandas 操作，将它们并行化。
和我联系。
我是 Travis Tang，技术领域的数据科学家。我在 Medium 和 LinkedIn 上定期分享数据分析和数据科学的技巧。与我联系，获取更多类似的提示。
HalvingGridSearch 将超参数调谐速度提高了 5-10 倍
原文：https://towardsdatascience.com/5-10x-faster-hyperparameter-tuning-with-halvinggridsearch-1a874c1994d
如何优化机器学习模型的超参数以及如何加速该过程
照片由德鲁·帕特里克·米勒在 Unsplash 上拍摄
什么是超参数调谐？
超参数调整是一种微调机器学习模型的方法。超参数不是在训练过程中专门学习的，但是可以调整以优化模型的性能。以下是我在进行超参数调整时喜欢考虑的一些技巧:
- 超参数调整通常是构建模型时的最后一步，就在最终评估之前。
- 您不会从调整参数中得到明显不同的结果。对模型性能影响最大的是特征选择和模型选择。
- 超参数调整可以帮助模型的一般化，减少过度拟合。****
也就是说，调整您的模型是工作流程中的一个重要步骤。这里有一个快速的视觉效果，可以帮助你理解这个过程。
- ****数据准备:即清理你的数据并为机器学习做准备的过程。
- ****探索性数据分析:这是你应该经常执行的一个步骤。探索新数据集和理解数据分布、相关性等的过程。见这篇文章一步一步的指导。
- 特性工程和选择**:从您的数据中创建新特性(列)并根据它们对模型性能的贡献选择最佳特性的过程。**
- ****模型选择:利用交叉验证来选择基于评估度量的最佳算法。
- Hyper Parameter Tuning :本帖描述的过程。
- ****模型评估:选择正确的性能指标并评估结果。
超参数示例
超参数的一些例子有:
- 在逻辑回归模型中，我应该使用哪个解算器？
- C 或正则化常数的最佳值是什么？
- 应该用什么正则化罚？
- 我的决策树允许的最大深度应该是多少？****
- 我应该在我的随机森林中包含多少棵树？
你自己很难搞清楚其中的大部分内容。好消息是，您可以应用各种技术来搜索最佳的参数集。现在，您已经对它们是什么以及它们如何适应流程有了基本的了解，让我们看看它是如何工作的。
型号选择
为简洁起见，我们将跳过初始清理和功能选择。GitHub 上的这个笔记本里有这个代码。我们将获取特征选择的结果，并创建我们的X和y变量。
X = df[['categories', 'postal_code', 'text_len', 'review_count', 'text_clean']]
y = df['target']
接下来，我们有一个函数允许我们重复地创建一个管道以及一个分类器的实例。
def create_pipe(clf, ngrams=(1,1)):
column_trans = ColumnTransformer(
[('Text', TfidfVectorizer(stop_words='english', ngram_range=ngrams), 'text_clean'),
('Categories', TfidfVectorizer(), 'categories'),
('OHE', OneHotEncoder(dtype='int', handle_unknown='ignore'),['postal_code']),
('Numbers', MinMaxScaler(), ['review_count', 'text_len'])],
remainder='drop')
pipeline = Pipeline([('prep',column_trans),
('over', SMOTE(random_state=42)),
('under', RandomUnderSampler(random_state=42)),
('clf', clf)])
return pipeline
管道包含所有需要的预处理步骤。接下来，我们可以执行经典的交叉验证来找到最佳模型。
models = {'RandForest' : RandomForestClassifier(random_state=42),
'LogReg' : LogisticRegression(random_state=42)
}
for name, model, in models.items():
clf = model
pipeline = create_pipe(clf)
scores = cross_val_score(pipeline,
X,
y,
scoring='f1_macro',
cv=3,
n_jobs=1,
error_score='raise')
print(name, ': Mean f1 Macro: %.3f and Standard Deviation: (%.3f)' % (np.mean(scores), np.std(scores)))
[OUT]
RandForest : Mean f1 Macro: 0.785 and Standard Deviation: (0.003)
LogReg : Mean f1 Macro: 0.854 and Standard Deviation: (0.001)
总的来说，我们可以看到LogisticRegression分类器在这个数据上比RandomForestClassifier表现得更好。如上所述，特征工程、特征选择、模型选择在训练你的模型时会给你最大的收获，所以我们总是从这里开始。
访问管线中的模型参数
我想指出的第一件事是如何在管道中访问模型的参数。通常，当你有一个评估者(模型)实例时，你调用estimator.get_params()，你可以看到它们。管道中的过程是相同的；但是，最终的输出略有不同。
当直接从估算器访问参数时，输出将是一个值，如C。相比之下，在管道中，输出将首先具有您给估算器的名称以及双下划线，最后是类似clf__C的参数名称；知道如何访问参数很重要，因为您需要这些名称来构建参数网格进行搜索。
以下是我的管道的输出，为了简洁起见被截断了。您可以在列表的末尾看到分类器参数，所有这些参数都是当前的默认值。
pipeline.get_params()
{'memory': None,
'steps': [('prep',
ColumnTransformer(transformers=[('Text', TfidfVectorizer(stop_words='english'),
'text_clean'),
('Categories', TfidfVectorizer(), 'categories'),
('OHE',
OneHotEncoder(dtype='int',
handle_unknown='ignore'),
['postal_code']),
('Numbers', MinMaxScaler(),
['review_count', 'text_len'])])),
... truncated for brevity ...
'clf__C': 1.0,
'clf__class_weight': None,
'clf__dual': False,
'clf__fit_intercept': True,
'clf__intercept_scaling': 1,
'clf__l1_ratio': None,
'clf__max_iter': 500,
'clf__multi_class': 'auto',
'clf__n_jobs': None,
'clf__penalty': 'l2',
'clf__random_state': 42,
'clf__solver': 'lbfgs',
'clf__tol': 0.0001,
'clf__verbose': 0,
'clf__warm_start': False}
网格搜索
我们将探索的第一种方法是网格搜索交叉验证 n，它采用了与我们用于模型选择的常规交叉验证相同的逻辑。然而，网格搜索遍历每个参数组合，执行交叉验证，并返回最佳模型。这里的第一步是创建一个参数网格，我们通过为 GridSearch 构建一个字典列表来迭代完成。
parameters = [{'clf__solver' : ['newton-cg', 'lbfgs', 'sag', 'liblinear'],'clf__C' : [.1, 1, 10, 100, 1000], 'prep__Text__ngram_range': [(1, 1), (2, 2), (1, 2)]}]
或者，您可以向列表中添加多个词典。它将独立地遍历每个字典的组合；如果您有一些与其他参数不兼容的参数，这很有用。例如，在LogisticRegression中，某些惩罚值只对某些解算器有效。
parameters = [
{'clf__penalty': ['l1', 'l2'], 'clf__solver' : ['liblinear']},
{'clf__penalty': ['l1', 'none'], 'clf__solver' : ['newton-cg']},
]
现在我们有了参数网格，我们可以首先创建一个基本分类器的实例，并将其传递给管道函数。
clf = LogisticRegression(random_state=42, max_iter=500)
pipeline = create_pipe(clf)
接下来，我们将使用GridSearchCV运行网格搜索。
%time grid = GridSearchCV(pipeline,
parameters,
scoring='f1_macro',
cv=3,
random_state=0).fit(X_train, y_train)
print("Best cross-validation accuracy: {:.3f}".format(grid.best_score_))
print("Test set score: {:.3f}".format(grid.score(X_test, y_test)))
print("Best parameters: {}".format(grid.best_params_))
log_C = grid.best_params_['clf__C']
log_solver = grid.best_params_['clf__solver']
log_ngram = grid.best_params_['prep__Text__ngram_range']
58m 3s
Best cross-validation accuracy: 0.867
Test set score: 0.872
Best parameters: {'clf__C': 100, 'clf__solver': 'newton-cg',
'prep__Text__ngram_range': (1, 2)}
我们的网格搜索用58m 3s来运行，为每一个产生最佳参数。
在查看上面的列表时，您可能会想到的一件事是，在我们的参数网格中有相当多的潜在组合。上例中有4xT3、5xT4、3xT5，合计为4 x 5 x 3 = 60。因为训练我们的模型需要大约一分钟，所以遍历一次网格需要大约一个小时。
****注意:可以用参数n_jobs=-1并行化网格搜索；然而，我没有展示这个例子的相对性能。
接下来，我们来看一个提高整体性能的方法。
减半搜索
然而，有一种方法可以加快网格搜索的速度，并在更短的时间内返回非常相似的结果。这种方法被称为连续减半。它将在过程的早期利用数据的子集来找到一些性能最佳的参数组合，并随着最佳组合的缩小而逐渐增加所使用的数据量。
您可以将GridSearchCV调用与 HalvingGridSearchCV `调用交换，以利用对半网格搜索。就这么简单。让我们用这个新方法重新运行上面的搜索，看看它的表现如何。
%time grid = HalvingGridSearchCV(pipeline,
parameters,
scoring='f1_macro',
cv=3,
random_state=0).fit(X_train, y_train)
print("Best cross-validation accuracy: {:.3f}".format(grid.best_score_))
print("Test set score: {:.3f}".format(grid.score(X_test, y_test)))
print("Best parameters: {}".format(grid.best_params_))
log_C_b = grid.best_params_['clf__C']
log_solver_b = grid.best_params_['clf__solver']
log_ngram_b = grid.best_params_['prep__Text__ngram_range']
14m 28s
Best cross-validation accuracy: 0.867
Test set score: 0.872
Best parameters: {'clf__C': 100, 'clf__solver': 'lbfgs',
'prep__Text__ngram_range': (1, 2)}
相当可观！从一小时缩短到 15 分钟！在某些情况下，我看到它的表现甚至更快。我们也可以看到结果相当相似。这次选择的解决方案是lbfgs对newton-cg。我们现在可以对比一下两者的表现。
评估结果
我们有一个简单的函数，它将采用一个管道，将数据拟合到一个训练和测试集，并使用一个分类报告和一个混淆矩阵评估结果。让我们依次经历未调模型、网格搜索调模型，最后是减半网格搜索调模型。首先是原始模型。
注意:我们这里使用的评估指标是F1-宏**；我们正在寻找平衡精度和召回。**
def fit_and_print(pipeline, name):
pipeline.fit(X_train, y_train)
y_pred = pipeline.predict(X_test)
score = metrics.f1_score(y_test, y_pred, average='macro')
print(metrics.classification_report(y_test, y_pred, digits=3))
ConfusionMatrixDisplay.from_predictions(y_test,
y_pred,
cmap=plt.cm.Greys)
plt.tight_layout()
plt.title(name)
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.tight_layout()
plt.savefig(name + '.png', dpi=300)
plt.show;
clf = LogisticRegression(random_state=42, max_iter=500)
pipeline = create_pipe(clf)
fit_and_print(pipeline, 'Default Parameters')
precision recall f1-score support
0 0.789 0.845 0.816 9545
1 0.925 0.894 0.909 20370
accuracy 0.879 29915
macro avg 0.857 0.869 0.863 29915
weighted avg 0.882 0.879 0.880 29915
作者图片
我们这里的 F1-Macro 分数是0.863。接下来，让我们尝试一下网格搜索调优模型。
clf = LogisticRegression(C=log_C, solver=log_solver, random_state=42, max_iter=500)
pipeline = create_pipe(clf, log_ngram)
fit_and_print(pipeline, 'GridSearch Parameters')
precision recall f1-score support
0 0.839 0.810 0.824 9545
1 0.913 0.927 0.920 20370
accuracy 0.890 29915
macro avg 0.876 0.869 0.872 29915
weighted avg 0.889 0.890 0.889 29915
作者图片
我们这里的 F1-Macro 分数是0.872。我们的调优过程改进了该模式的整体结果，并且我们将 F1 宏分数增加了0.09。接下来，让我们尝试一下减半网格搜索调优模型。
clf = LogisticRegression(C=log_C_b, solver=log_solver_b, random_state=42, max_iter=500)
pipeline = create_pipe(clf, log_ngram_b)
fit_and_print(pipeline, 'HalvingGridSearch Parameters')
precision recall f1-score support
0 0.839 0.811 0.824 9545
1 0.913 0.927 0.920 20370
accuracy 0.890 29915
macro avg 0.876 0.869 0.872 29915
weighted avg 0.889 0.890 0.889 29915
作者图片
最后，我们看到了减半网格搜索模型的结果。F1-宏分数与网格搜索模型相同。我们在不牺牲调优结果的情况下，将调优时间从 60 分钟缩短到 15 分钟。每次使用这些方法时，您的结果可能会有所不同，但这是一种无需花费大量时间就能调优模型的极好方法。
结论
超参数调整是一种在精细执行特征选择和模型选择后调整模型的方法。超参数不是在训练过程中学习到的参数，而是经过调整以提高模型整体性能的参数。我们看到了如何访问管道中的参数，并执行网格搜索来选择最佳参数。最后，您看到了如何利用对半网格搜索方法来减少搜索最佳参数所需的时间。我希望你喜欢这篇文章。快乐模型建筑！
如果你想重新创建它，所有这些代码都可以在 GitHub 上的笔记本中找到。
如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体会员。一个月 5 美元，让你可以无限制地访问成千上万篇文章。如果您使用 【我的链接】 注册，我会为您赚取一小笔佣金，无需额外费用。
5 个 SQL 案例示例，让您轻松使用案例
原文：https://towardsdatascience.com/5-advanced-sql-case-examples-that-will-make-you-use-case-when-easily-1040c1eb8857
数据科学
掌握 SQL CASE-WHEN 语句的实例
照片由斯蒂芬·莫尔特尔在 Unsplash 拍摄
SQL 案例的实际使用案例！
在我之前的文章 5 个高级 SQL 概念 中，您对 SQL 中的**CASE..WHEN**表达式有了一个大致的了解。这个表达式是 SQL 处理 If-else 逻辑的方式。
数据分析从来都不简单。通常，您需要根据几个条件转换提取的数据，以使其适合进一步的分析。这就是**CASE..WHEN..THEN**表达式的应用。
我列举了 5 个CASE..WHEN..THEN表达的实际用例，并附有例子和解释。理解这些例子肯定会让你成为 SQL 中 CASE 的专业用户。
这里是所有用例的快速参考—
**·** [**Two ways to write CASE statement in SQL**](#2577)**·** [**Simple CASE WHEN in SELECT statement**](#3c60) **·** [**Categorize the data using CASE WHEN**](#811d) **·** [**Data Standardization using SQL CASE**](#8f95) **·** [**CASE WHEN with Aggregate Functions**](#8eed) **·** [**CASE Statement in ORDER BY Clause**](#5d22)
📍注意:我使用 MySQL WorkBench & self created 销售数据使用 Faker 创建。可以在我的 Github repo 上 MIT License 下免费获得！
这是一个简单的 9999 x 11 数据集，如下所示。
虚拟销售数据集|作者图片
好了，我们开始吧…
从技术上讲，SQL 中的 CASE 表达式计算 WHEN 子句中提到的条件。如果条件为真，则执行 THEN 子句中提到的代码，如果条件为假，则执行 ELSE 部分中提到的代码。
在开始举例之前，让我们快速刷新一下表达式**CASE..WHEN..THEN**和它的写法。♻️
用 SQL 编写 CASE 语句的两种方法
该语句最常用的形式是在一个CASE表达式下编写多个WHEN..THEN子句。
例如，让我们通过在销售经理列中添加如下条件来创建一个新列— 销售经理姓名首字母。
SELECT Sales_Manager,
Product_Category,
**CASE
WHEN Sales_Manager = 'Pablo' THEN 'P'
WHEN Sales_Manager = 'Kristen' THEN 'K'
ELSE Sales_Manager
END AS Sales_Manager_Initials **
FROM sql_practice.dummy_sales_data_v1;
SQL | Image 中的简单 CASE 语句(按作者)
📍注意:上面代码中的 ELSE 子句是可选的。如果不提及，那么所有 WHEN 子句中条件都为假的地方都会用
NULL填充。
另一种方式，当被测试的条件只在一列上时，就像上面的例子一样，SQL 为您提供了一种简化的方式来编写如下的CASE..WHEN表达式。
SELECT Sales_Manager,
Product_Category,
**CASE Sales_Manager**
WHEN 'Pablo' THEN 'P'
WHEN 'Kristen' THEN 'K'
ELSE Sales_Manager
END AS Sales_Manager_Initials
FROM sql_practice.dummy_sales_data_v1;
因此，您可以得到完全相同的输出，而不用在每个WHEN子句中提到列名。只需编写关键字**CASE**，后跟您想要应用条件的列名。
我没有发现这两种方法之间有任何执行时间或效率相关的差异。因此，采用哪种方法是个人的决定。
现在，既然你已经对如何写 CASE-WHEN 表达式有了深入的了解，让我们进入实际的用例。
SELECT 语句中的简单情况
基于现有列创建新列是最常见的数据转换之一。大多数情况下，您需要在现有列上隐含条件。
正如您在上面的示例中注意到的，您可以有条件地测试单个列中的值，并基于此创建一个新列。但是，WHEN 子句也为您提供了在多列上添加条件的灵活性。✅
例如，假设对于销售经理为 Pablo 且产品类别为办公室的所有订单，您希望在数量中添加 50 。同时，对于销售经理和产品类别的所有其他组合，您希望保持数量列不变。
理想情况下，您需要两列上的条件，分别为— Sales_Manager = ‘Pablo’、Product_Category = ‘Office’。此外，这两个条件必须为真，才能获得新的数量值。因此，您需要使用逻辑 AND 连接这些条件。
SELECT Sales_Manager,
Product_Category,
Quantity,
CASE
**WHEN Sales_Manager = 'Pablo'
AND Product_Category = 'Office'
THEN Quantity+50**
**ELSE Quantity**
END AS New_Quantity
FROM sql_practice.dummy_sales_data_v1;
多列条件|按作者排序的图像
正如您所看到的，WHEN 子句中的两个条件是用关键字 AND 连接的。只有当两个条件都为真时，才会执行 THEN 子句中的代码，即 Quantity+50 ，如上图所示。
这里，ELSE Quantity保持销售经理和产品类别的所有其他组合的数量列不变。
接下来，您通常需要将数据分成不同的类别，以便进一步分析。您可以在数据提取阶段使用 SQL 中的 CASE 表达式来实现这一点。
由于您将使用 if-else 逻辑来将记录分成不同的类别，CASE..WHEN expression 是这个应用程序中的完美工具。
在下列情况下，使用用例对数据进行分类
可以根据其他数字和非数字列将数据分成多个类别。
与将行分组到不同组的 GROUP BY 子句相反，CASE-WHEN 只是创建一个新列，并提到数据集的每一行所属的组名。✅
例如，销售数据中有每个订单的数量。假设您想根据列数量将订单量分类为“高”、“低”或“中”。您可以使用如下 CASE-WHEN 语句—
SELECT OrderID,
Quantity,
**CASE
WHEN Quantity > 65 THEN 'High'
WHEN Quantity < 15 THEN 'Low'
ELSE 'Medium'
END AS Order_Volume **
FROM sql_practice.dummy_sales_data_v1;
使用 Case 语句分类|按作者分类的图像
简单！
您所需要做的就是提及条件，基于这些条件，您希望将数据集行分成不同的组。
您还可以像在前面的示例中一样，在WHEN子句中包含多个条件。当不同表中的列有多个条件时，这种分类也是有效的。
例如，假设您有两个表订单和发货，如下所示。
两个示例表格|作者图片
因为我没有准备好这些表格，所以我用 CTE 创建了如下的表格
WITH Orders AS
(
SELECT OrderID,
Sales_Manager,
Quantity
FROM sql_practice.dummy_sales_data_v1
LIMIT 20
),Shipments AS
(
SELECT OrderID,
Product_Category,
Shipping_Address,
Shipping_Cost
FROM sql_practice.dummy_sales_data_v1
LIMIT 20
)
您可以在此了解更多关于使用</5-advanced-sql-concepts-you-should-know-in-2022-b50efe6c99>的信息。
现在，假设您想根据列数量和运输成本中的值将订单表中的记录分类为“高优先级”、“中优先级”和“低优先级”。****
这可能看起来很复杂，但是用下面的CASE..WHEN表达式就很简单了。
**SELECT O.OrderID,
O.Quantity,
S.Shipping_Cost,
**CASE
WHEN O.Quantity > 50
OR S.Shipping_Cost > 30
THEN 'High Priority'
WHEN O.Quantity < 15
OR S.Shipping_Cost < 10
THEN 'Low Priority'
ELSE 'Medium Priority'
END AS Order_Type**
FROM Orders O
LEFT JOIN Shipments S
ON O.OrderID = S.OrderID**
使用 SQL | Image 中的 CASE 按作者进行数据分类
您需要使用JOIN子句和列别名。剩下的部分也是同样简单的CASE..WHEN表情。在上图中可以看到，创建了一个新列 Order_Type ，其中包含每个 OrderID 的优先级值。
接下来，有时您的数据集包含相同含义的不同值，这使得数据不一致且不一致。
最简单的例子就是——某些数据集中的性别列可以包含' W '、 F '、女'、女'等值，都表示性别为'女'。那为什么我们要用不同的术语来表示同一个意思呢？****
最好将数据集标准化，使其更加一致。
下一个用例将详细演示这一点。
使用 SQL CASE 的数据标准化
数据标准化用于使数据更加一致，即确保每一列都有相同类型的内容和表示单一含义的单一术语或值。
CASE-WHEN 语句对于将不一致或不一致的数据转换成更加结构化和一致的数据非常有用。使用这个 SQL 功能，您总是可以创建一个具有标准化值的新列，并将其用于进一步的分析。
让我们看一个例子。
假设，在该数据集中，您希望获得订单状态为已完成或未完成，即将状态标准化为这两个值。但是，您可以看到“状态”列包含诸如“已交付”、“未交付”、“未发货”和“已发货”等值。****
CASE WHEN 语句可以用在如下的场景中
**SELECT OrderID,
Status,
**CASE
WHEN Status = 'Delivered' THEN 'Completed'
ELSE 'Not Completed'
END as Order_Status **
FROM sql_practice.dummy_sales_data_v1;**
SQL | Image 中的数据标准化用例
如上图所示， Order_Status 只包含两个值。如果状态为交付，则只有订单 _ 状态为完成，其他情况下为未完成。****
嗯，我同意，这是一个很弱的例子，但是一旦你理解了用例，你就可以在复杂的场景中使用它。
此外，没有数据聚合，数据分析是不完整的。在我的上一篇文章中，Python 中你应该知道的 5 个熊猫分组技巧 你读到了如何在 SQL 中使用带有 Group By 的聚合函数。
在数据的条件选择上使用聚合函数怎么样？？
是的，这在 SQL 中是可能的&总有一个“简单的方式”用例。
使用聚合函数时的情况
这是 CASE 语句的复杂用例之一，使用聚合函数有时会很棘手。
所以，我们试着用一个例子来理解一下。
假设，您想要获得每个销售经理处理的订单总数，其中显示了状态已交付和未交付。****
理想情况下，您需要计算属于销售经理和状态组合的订单。但是对于 CASE 语句，您不需要键入每个组合。您可以简单地使用如下的聚合函数COUNT。****
**SELECT Sales_Manager,
**COUNT(CASE WHEN Status = 'Delivered' THEN OrderID ELSE NULL END) AS Delivered_Orders,
COUNT(CASE WHEN Status = 'Not Delivered' THEN OrderID ELSE NULL END) AS NonDelivered_Orders**
FROM sql_practice.dummy_sales_data_v1
GROUP BY Sales_Manager;**
如上所述，您应该在聚合函数中提到CASE..WHEN..THEN。这里，在 Delivered_Orders 一栏中，你正在统计所有订单WHEN 状态为 Delivered 得到如下最终输出。
SQL | Image 中包含聚合函数的事例(按作者)
很简单！
使用另一个聚合函数SUM()也可以得到相同的结果。只有您需要稍微更改 CASE-WHEN 语句，如下所示。
**SELECT Sales_Manager,
**SUM(CASE WHEN Status = 'Delivered' THEN 1 ELSE 0 END) AS Delivered_Orders,
SUM(CASE WHEN Status = 'Not Delivered' THEN 1 ELSE 0 END) AS NonDelivered_Orders **
FROM sql_practice.dummy_sales_data_v1
GROUP BY Sales_Manager;**
在上面的 CASE 语句中，您实际上是基于状态创建了一个中间列(1 & 0的不可见)，并最终对该列的值进行加法运算以获得所需的输出。**
同样，您也可以使用其他聚合函数。
到目前为止，您已经看到了 SELECT 语句中的 CASE 用法。但是，它也可以用在 ORDER BY 子句中。
ORDER BY 子句中的 CASE 语句
在 SQL 中， ORDER BY 子句用于按升序或降序排列输出数据集。在ORDER BY中使用CASE为您提供了更多的灵活性，允许您对数据进行排序，而不仅仅是标准方式。
例如，假设您想将所有‘已交付’订单按单价升序排列(如果它们被运送到英国和交付时间升序排列(如果它们被运送到任何其他国家)。****
使用标准的 ORDER BY 子句，这似乎是一项不可能完成的任务。
但是使用 CASE with ORDER BY，你的生活就轻松多了。💯
让我们使用下面的查询来理解它。
**SELECT OrderID,
Shipping_Address,
UnitPrice,
Delivery_Time
FROM sql_practice.dummy_sales_data_v1
WHERE Status LIKE 'Delivered'
AND Shipping_Address IN ('UK', 'India')
AND Delivery_Time <19
AND UnitPrice BETWEEN 140 AND 150
ORDER BY **CASE
WHEN Shipping_Address = 'UK' THEN UnitPrice
ELSE Delivery_Time
END;****
📍注意:WHERE 子句中提到的条件绝对不是获得结果所必需的。我使用它们只是为了让结果更明显。
正如上面的查询中提到的，您可以使用CASE..WHEN表达式在ORDER BY子句中指定对数据集进行排序的条件，以获得如下输出。
使用 SQL 中的案例按自定义标准排序|按作者排序图像
所以当 Shipping_Address 为 UK 时，所有订单将按升序或单价排列。对于 Shipping_Address 中的任何其他值，所有订单都按 Delivery_Time 的升序排列，如上所示。**
类似地，要获得降序排列的所有记录，只需在上述查询中的 END 关键字后使用关键字— DESC 。
就是这样！🏆
我希望您对 SQL CASE..WHEN..THEN语句及其提供的灵活性有了宝贵的见解。
在现实世界中，数据转换有时很复杂。掌握 SQL 中的 CASE 语句一定会帮助你高效地实现目标。
如果你喜欢阅读这些精彩的故事，并且想支持我成为作家，
💡 成为媒介会员 到无限制访问媒介上的故事和每日有趣的媒介文摘。我会得到你的费用的一小部分，没有额外的费用给你。
****https://medium.com/@17.rsuraj/membership
💡此外， 注册我的电子邮件列表 永远不要错过另一篇关于数据科学指南、技巧和提示、SQL 和 Python 的文章。
感谢您的阅读！****
2022 年你应该知道的 5 个高级 SQL 概念
原文：https://towardsdatascience.com/5-advanced-sql-concepts-you-should-know-in-2022-b50efe6c99
数据科学
立即掌握这些节省时间的高级 SQL 查询
乔恩·泰森在 Unsplash 上的照片
做 SQL 高手！🏆
SQL 或结构化查询语言是任何处理数据的人的必备工具。
随着数据量的增加，对熟练数据专业人员的需求也在增加。仅有高级 SQL 概念的知识是不够的，但是您应该能够在工作中高效地实施它们,这也是数据科学职位的求职面试所需要的！
因此，我在这里列出了 2022 年你应该知道的 5 个高级 SQL 概念及其解释和查询示例。
我把这篇文章写得很短，这样你就可以很快地完成它，掌握那些必须知道的、赢得面试的 SQL 技巧。🏆
您可以使用此索引快速导航到您最喜欢的部分。
**·** [**Common Table Expressions (CTEs)**](#e85d) **·** [**ROW_NUMBER() vs RANK() vs DENSE_RANK()**](#9f01) **·** [**CASE WHEN Statement**](#2f01) **·** [**Extract Data From Date — Time Columns**](#1c8a) **·** [**SELF JOIN**](#3ad5)
📍注意:我使用的是 SQLite DB 浏览器和一个使用 Faker 创建的自己创建的 Dummy_Sales_Data ，你可以在我的 Github repo 上免费获得！
好了，我们开始吧…🚀
公共表表达式(cte)
在处理真实世界的数据时，有时您需要查询另一个查询的结果。实现这一点的简单方法是使用子查询。
然而，随着复杂性的增加，计算子查询变得难以阅读和调试。
这时，cte 开始出现，让你的生活更轻松。cte 使得编写和维护复杂的查询变得容易。✅
例如，考虑以下使用子查询的数据提取
SELECT Sales_Manager, Product_Category, UnitPrice
FROM Dummy_Sales_Data_v1
WHERE Sales_Manager IN (**SELECT DISTINCT Sales_Manager
FROM Dummy_Sales_Data_v1
WHERE Shipping_Address = 'Germany'
AND UnitPrice > 150**)
AND Product_Category IN (**SELECT DISTINCT Product_Category
FROM Dummy_Sales_Data_v1
WHERE Product_Category = 'Healthcare'
AND UnitPrice > 150**)
ORDER BY UnitPrice DESC
这里我只使用了两个子查询，代码简单易懂。
这仍然很难理解，当您在子查询中添加更多的计算或者甚至添加更少的子查询时会怎么样— 复杂性增加 使得代码可读性更差并且难以维护。
现在，让我们看看上面带有 CTE 的子查询的简化版本，如下所示。
WITH SM AS
**(
SELECT DISTINCT Sales_Manager
FROM Dummy_Sales_Data_v1
WHERE Shipping_Address = 'Germany'
AND UnitPrice > 150
)**,PC AS
**(
SELECT DISTINCT Product_Category
FROM Dummy_Sales_Data_v1
WHERE Product_Category = 'Healthcare'
AND UnitPrice > 150
)**SELECT Sales_Manager, Product_Category, UnitPrice
FROM Dummy_Sales_Data_v1
WHERE Product_Category IN (**SELECT Product_Category FROM PC**)
AND Sales_Manager IN (**SELECT Sales_Manager FROM SM**)
ORDER BY UnitPrice DESC
复杂的子查询被分解成要使用的更简单的代码块。
这样，复杂的子查询被重写为两个更容易理解和修改的 cteSM和PC。🎯
上面的两个查询，用了相同的时间执行，产生了如下相同的输出。
CTE vs 子查询|作者图片
cte 本质上允许您从查询结果中创建一个临时表。这提高了代码的可读性和可维护性。✅
真实世界的数据集可能有数百万或数十亿行，占据数千 GB 的存储空间。使用这些表中的数据进行计算，特别是将它们与其他表直接连接，将会非常昂贵。
这类任务的最终解决方案是使用 cte。💯
接下来，让我们看看如何使用窗口函数给数据集中的每一行分配一个整数“等级”。
ROW _ NUMBER()vs RANK()vs DENSE _ RANK()
在处理真实数据集时，另一个常用的概念是记录的排序。公司在不同的场景中使用它，例如—
- 根据销量对畅销品牌进行排名
- 根据订单数量或产生的收入对顶级垂直产品进行排名
- 获得观看次数最高的每种类型的电影名称
ROW_NUMBER、RANK()和DENSE_RANK()主要用于在结果集的上述分区内给每个记录分配连续的整数。
当你在某些记录上有联系时，它们之间的差别是显而易见的。
当结果表中存在重复行时，整数被分配给每条记录的行为和方式会发生变化。✅
让我们来看一个 虚拟销售数据集 的快速示例，按运费降序列出所有产品类别、送货地址。
SELECT Product_Category,
Shipping_Address,
Shipping_Cost,
**ROW_NUMBER()** OVER
(PARTITION BY Product_Category,
Shipping_Address
ORDER BY Shipping_Cost DESC) as RowNumber,
**RANK()** OVER
(PARTITION BY Product_Category,
Shipping_Address
ORDER BY Shipping_Cost DESC) as RankValues,
**DENSE_RANK()** OVER
(PARTITION BY Product_Category,
Shipping_Address
ORDER BY Shipping_Cost DESC) as DenseRankValues
FROM Dummy_Sales_Data_v1
WHERE Product_Category IS NOT NULL
AND Shipping_Address IN ('Germany','India')
AND Status IN ('Delivered')
正如您所看到的，三者的语法是相同的，但是，它会产生如下不同的输出:
ROW_NUMBER()、RANK()和 DENSE_RANK()之间的差异
**RANK()**是根据ORDER BY子句的条件检索已排序的行。如您所见，前两行之间有一个平局，即前两行在 Shipping_Cost 列中有相同的值(在 *ORDER BY* 条款中提到)。
RANK给两行分配相同的整数。但是，它会将重复的行数添加到重复的排名中，以获得下一行的排名。这就是为什么，第三行(用红色标记)，RANK分配等级**3** ( 2 个重复行+ 1 个重复等级)
**DENSE_RANK**类似于RANK，但是它不会跳过任何数字，即使两行之间有平局。这可以在上图的蓝框中看到。
与上面两个不同，**ROW_NUMBER**只是从 1 开始给分区中的每个记录分配序列号。如果它在同一个分区中检测到两个相同的值，它会为这两个值分配不同的等级号。
对于产品类别的下一个分区—发货地址→ 娱乐—印度,通过所有三个函数对进行排序，从 1 重新开始，如下图所示。
不同分区中的行号、等级、密度等级|按作者分类的图像
最终，如果在ORDER BY子句中使用的列中没有重复的值，这些函数将返回相同的输出。💯
接下来，下一个概念将讲述更多关于如何实现条件语句和使用它透视数据。
CASE WHEN 语句
CASE 语句将允许您在 SQL 中实现if-else，因此您可以使用它来有条件地运行查询。
**CASE**语句主要测试**WHEN**子句中提到的条件，并返回**THEN**子句中提到的值。当不满足任何条件时，它将返回**ELSE**子句中提到的值。✅
在处理真实数据项目时，CASE 语句通常用于根据其他列中的值对数据进行分类。它也可以与聚合函数一起使用。
例如，让我们再次使用 虚拟销售数据 根据数量将销售订单分为高、中、低三种数量。
SELECT OrderID,
OrderDate,
Sales_Manager,
Quantity,
**CASE WHEN Quantity > 51 THEN 'High'
WHEN Quantity < 51 THEN 'Low'
ELSE 'Medium'
END AS OrderVolume**
FROM Dummy_Sales_Data_v1
CASE WHEN 语句按作者对 SQL | Image 中的记录进行分类
简单地说，它创建了一个新的列 OrderVolume ，并根据列 Quantity 中的值添加了值“高”、“低”、“中”。
📌您可以包含多个 WHEN..THEN 子句并跳过 ELSE 子句，因为它是可选的。
📌如果您没有提到 ELSE 子句，并且没有满足任何条件，查询将为该特定记录返回**NULL**。
case 语句的另一个常用但鲜为人知的用例是— 数据透视。
数据透视是重新排列结果集中的列和行的过程，以便您可以从不同的角度查看数据。
有时您处理的数据是长格式的(行数>列数)，您需要得到宽格式的数据(列数>行数)。
在这种情况下，CASE 语句非常有用。💯
例如，让我们找出新加坡、英国、肯尼亚和印度的每个销售经理处理了多少订单。
SELECT Sales_Manager,
**COUNT(CASE WHEN Shipping_Address = 'Singapore' THEN OrderID
END) AS Singapore_Orders,
COUNT(CASE WHEN Shipping_Address = 'UK' THEN OrderID
END) AS UK_Orders,
COUNT(CASE WHEN Shipping_Address = 'Kenya' THEN OrderID
END) AS Kenya_Orders,
COUNT(CASE WHEN Shipping_Address = 'India' THEN OrderID
END) AS India_Orders**
FROM Dummy_Sales_Data_v1
GROUP BY Sales_Manager
使用案例..当...的时候..然后，我们为每个送货地址创建单独的列，以获得预期的输出，如下所示。
使用 SQL 中的 CASE 语句按作者透视数据|图像
根据您的用例，您还可以在 case 语句中使用不同的聚合，如 SUM、AVG、MAX、MIN。
接下来，在处理真实世界的数据时，它通常包含日期时间值。因此，了解如何提取日期时间值的不同部分(如月、周、年)非常重要。
从日期-时间列中提取数据
在大多数访谈中，您会被要求按月汇总数据或计算特定月份的特定指标。
当数据集中没有单独的月份列时，您需要从数据中的日期时间变量中提取所需的日期部分。
不同的 SQL 环境有不同的函数来提取日期的各个部分。总的来说，在 MySQL 中你应该知道—
**EXTRACT**(part_of_date FROM date_time_column_name)**YEAR**(date_time_column_name)**MONTH**(date_time_column_name)**MONTHNAME**(date_time_column_name)**DATE_FORMAT**(date_time_column_name)
例如，让我们从 虚拟销售数据集 中找出每个月的订单总量。
SELECT **strftime('%m', OrderDate)** as Month,
SUM(Quantity) as Total_Quantity
from Dummy_Sales_Data_v1
GROUP BY strftime('%m', OrderDate)
如果你也像我一样使用 SQLite DB 浏览器，你必须使用函数**strftime()**来提取日期部分，如下所示。您需要使用strftime()中的**‘%m’** 来提取月份。
按作者从 SQL | Image 中的日期提取月份
下图显示了大多数通常提取的日期部分，以及你应该在**EXTRACT**函数中使用的关键字。
按作者提取 PostgreSQL、MySQL 和 SQLite |图片中的部分日期
在这篇快速阅读中，我解释了几乎所有类型的日期部分提取。看一看它就能对它有一个完整的了解。
https://python.plainenglish.io/5-must-know-sql-functions-for-data-analysis-1f1a6ca53974
最后但同样重要的是，
在现实世界中，您会经常看到数据存储在一个大表中，而不是多个小表中。这时，在处理这些数据集时，自连接就可以解决一些有趣的问题了。
自连接
这些与 SQL 中的其他连接完全相同，唯一的区别是——在SELF JOIN中，您将一个表与其自身连接起来。
记住，这里没有SELF JOIN关键字，所以在连接中涉及的两个表是同一个表的情况下，只需使用**JOIN**。因为两个表名相同，所以在自连接的情况下使用表别名是很重要的。✅
编写一个 SQL 查询，找出收入高于其经理的雇员
——这是*SELF JOIN*中最常被问到的面试问题之一
让我们以此为例，创建如下所示的 Dummy_Employees 数据集。
虚拟员工数据集|作者图片
并尝试使用该查询找出哪些员工处理的订单比他们的经理多，
SELECT t1.EmployeeName, t1.TotalOrders
**FROM Dummy_Employees AS t1
JOIN Dummy_Employees AS t2
ON t1.ManagerID = t2.EmployeeID**
WHERE t1.TotalOrders > t2.TotalOrders
结果集|作者图片
不出所料，员工 Abdul 和 Maria 比他们的经理 Pablo 处理了更多的订单。
在我面对的几乎 80%的面试中，我都会遇到这个问题。所以，这是SELF JOIN的经典用例。
仅此而已！
我希望你很快完成这篇文章，并发现它对提高 SQL 技能很有用。
我在过去 3 年里一直在使用 SQL，我发现这些概念经常成为数据分析师和数据科学家职位的面试问题。这些概念在实际项目中非常有用。
对阅读介质上的无限故事感兴趣？？
💡考虑 成为媒体会员访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡请务必 注册我的电子邮件列表 以免错过另一篇关于数据科学指南、技巧和提示、SQL 和 Python 的文章。
感谢您的阅读！
Python Decorators 的 5 个高级技巧
原文：https://towardsdatascience.com/5-advanced-tips-on-python-decorators-113307d5a92c
你想写出简洁、易读、高效的代码吗？嗯，python decorators 可能会在您的旅程中帮助您。
毛里西奥·穆尼奥斯在 Unsplash 上的照片
在 Fluent Python 的第 7 章中，卢西亚诺·拉马尔霍讨论了装饰器和闭包。它们在基本的 DS 工作中并不常见，但是当您开始编写异步代码来构建生产模型时，它们就成为了一个无价的工具。
事不宜迟，我们开始吧。
1 —什么是室内设计师？
在我们进入技巧之前，让我们先了解一下装饰者是如何工作的。
装饰器是简单的接受一个函数作为输入的函数。从语法上来说，它们通常被描述为“修饰”函数上方的一行中的@my_decorator,例如…
temp = 0def decorator_1(func):
print('Running our function')
return func@decorator_1
def temperature():
return tempprint(temperature())
然而，真正发生的是当我们调用temperature()时，我们只是运行decorator_1(temperature())，如下所示…
temp = 0def decorator_1(func):
print('Running our function')
return funcdef temperature():
return tempdecorator_1(temperature())
好的，所以 decorators 是以另一个函数作为参数的函数。但是我们为什么要这么做呢？
嗯，装修工真的是多才多艺，厉害。它们通常用于异步回调和函数式编程。还可以利用它们在函数中构建类似类的功能，从而减少开发时间和内存消耗。
让我们进入一些提示…
2 —属性装饰者
提示:使用内置的 **@property** 来增强 setter/getter 功能。
最常见的内置装饰器之一是@property。许多 OOP 语言，比如 Java 和 C++，建议使用 getter/setter 范例。这些函数用于确保我们的变量不会返回/被赋予不正确的值。一个例子是要求我们的temp变量大于绝对零度…
我们可以使用@property方法增加很多这种功能，使我们的代码更具可读性和动态性…
注意，为了简洁起见，我们删除了my_setter()中的所有条件逻辑，但是概念是相同的。c.temperature不是比c.my_getter()可读性强很多吗？我当然这么认为。
但在我们继续之前，有一个重要的挑剔之处。在 python 中，没有私有变量这种东西。前缀_表示变量是受保护的，不应该在类外引用。但是，您仍然可以…
c = my_vars(500)
print(c._temp) # 500c._temp = -10000
print(c._temp) # -1000
python 中不存在真正的私有变量，这是一个有趣的设计选择。论点是 OOP 中的私有变量实际上并不是私有的——如果有人想访问它们，他们可以改变源类的代码，使变量成为公共的。
Python 鼓励“负责任的开发”，并允许你从外部访问类中的任何东西。
3 —类方法和静态方法
提示:使用内置的 **@classmethod** 和 **@staticmethod** 来扩充类功能。
这两个装饰者经常被混淆，但是他们的区别非常明显。
@classmethod将类作为参数。它绑定到类本身，而不是类实例。因此，它可以跨所有实例访问或修改该类。@staticmethod不把类作为参数。它绑定到类实例，而不是类本身。因此，它根本不能访问或修改这个类。
让我们看一个例子…
classmethods 最大的用例是它们作为我们类的可选构造函数的能力，这对于多态性非常有用。即使你没有在继承上做什么疯狂的事情，不用 if/else 语句就能实例化类的不同版本也是不错的。
另一方面，静态方法通常用作完全独立于类状态的实用函数。注意，我们的isAdult(age)函数不需要通常的self参数，所以即使它想引用，也不能引用这个类。
4 —快速提示
提示:使用 **@functools.wraps** 保存函数信息。
记住，装饰器只是接受另一个函数作为参数的函数。所以，当我们调用装饰函数时，我们实际上首先调用了装饰器。这个流程覆盖了关于修饰函数的信息，比如__name__和 doc 字段。
为了克服这个问题，我们可以利用另一个装饰者…
没有@wraps装饰器，我们的打印语句的输出如下。
print(f(5)) # 30
print(f.__name__) # 'call_func'
print(f.__doc__) # ''
为了避免覆盖重要的函数信息，一定要使用 **@functools.wraps** 装饰器。
5-创建自定义装饰器
提示:构建你自己的装饰器来扩充你的工作流程，但是要小心。
decorators 中的变量作用域有点奇怪。我们没有时间深入细节，但如果你真的如此专注，这里有一篇 29 分钟的文章。请注意，如果出现以下错误，请仔细阅读 decorator scope:
有了这个免责声明，让我们继续看一些有用的自定义装饰器…
5.1 —基于装饰器的商店功能
下面的代码在函数被调用时将它们附加到一个列表中。
一个潜在的用例是单元测试，就像 pytest 一样。假设我们有快速测试和慢速测试。我们可以给每个函数添加一个@slow或@fast装饰器，然后调用相应列表中的每个值，而不是手动将每个函数分配给一个单独的列表。
5.2 —时间数据查询或模型训练
下面的代码打印了你的函数的运行时间。
如果您正在运行任何类型的数据查询或使用错误日志训练模型，那么估计运行时间真的很有用。仅仅通过一个@time_it装饰器，您就可以获得任何函数的运行时估计。
5.3-对功能输入执行流量控制
以下代码在执行函数之前对函数参数执行条件检查。
这个装饰器对我们所有函数的参数x应用条件逻辑。如果没有装饰器，我们必须将if is not None流控制写入每个函数。
这些只是几个例子。装修工真的很有用！
感谢阅读！我会再写 18 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源和一些有用的资源。
关于 Python 对象的 5 个高级技巧
原文：https://towardsdatascience.com/5-advanced-tips-on-python-objects-689de0f055d6
Python 是一种面向对象的编程语言，但是它的行为很奇怪。如果你来自其他 OOP 语言，这篇文章可能对你有益
由迈克·丹勒在 Unsplash 上拍摄的照片
在《流畅的 Python》的第 8 章中，卢西亚诺·拉马尔霍讨论了 Python 如何在幕后处理对象。这里将定义 python 中变量存储背后的基本概念，并探讨一些相关的注意事项。
事不宜迟，我们开始吧。
1-Python 变量不是盒子
提示:python 变量是值的标签。
在编程 101 中，我们经常被告知变量是存储值的盒子。例如，盒子a存储列表[1,2,3]。然而，在 python 中，情况并非如此。
图 python 变量的图示。蓝色是变量名，红色是值，黑色是存储它们的盒子。图片作者。
在图 1 中，变量名(蓝色)是内存中某个位置的“标签”。注意每个对象可以有多个变量名，如左图所示。内存中的位置(黑色)是“盒子”，而不是名称本身。那些盒子储存数值(红色)。让我们看一个例子。
var_name = 1var_name # 1
id(var_name) # 4443642160
在上面的代码片段中，变量var_name被赋值为1。存储值的“盒子”是内存 id 4443642160。
现在，让我们将另一个变量添加到内存中的相同的位置…
another_var_name = var_nameid(var_name) # 4443642160
var_name # 1
id(var_name) == id(another_var_name) # True
正如我们所看到的，我们有两个引用同一个对象的 python 变量。然而，一旦我们改变了第二个变量，例如通过运行y += 1，我们的内存位置就变成了4443642192，使得对象变得不同。
在 python 中，更直观的概念是将变量名分配给内存中的位置。内存中的那些位置存储值。
2-对象相等
提示:使用 **==** 判断两个变量是否有相等的值，使用 **is** 判断两个变量是否共享内存中的位置。
根据第 1 节中的设置，本节将会很简短。
==确定变量是否有相同的值——这就像 java 中的.equals()函数。然而，如果你真的想确定变量是否是同一个对象，你应该使用 T2 来测试内存 id。
a = 1
b = 1
c = aa == b == c # True
a is c # True
这里有一个有趣的旁注。我们期望a is b评估为False。但是，有时候是True。
令人惊讶的是，为了节省空间，如果对象值相同，python 有时会将变量分配给同一个对象。这节省了内存，因为在我们的例子中，您不需要创建整数1的单独实例——您可以引用同一个对象。
现在只要我们改变这些变量中的任何一个，它就会在内存中找到自己的位置。
3 —拷贝与深层拷贝
提示:如果你不知道自己在做什么，使用 **deepcopy()** 。
如果你和熊猫一起工作过，你可能见过和/或用过df.copy()。使用copy与deepcopy只会在处理复合对象(包含其他对象的对象，如列表或类实例)时对您产生影响。但是对于一些编程范例，复合对象是常见的。
下面是深层拷贝和浅层拷贝的区别
- 深度副本构造一个新的复合对象，然后递归地将在原始对象中找到的对象的副本插入其中。
- 一个 浅拷贝构造一个新的复合对象，然后(尽可能地)将引用插入到原始对象中。
一个例子应该有助于澄清这一点…
Bus类创建一个乘客列表，从而使每个类实例成为一个复合对象。
正如我们所见，bus2是bus1的浅层拷贝，而bus3是深层拷贝。当bus1中的对象改变时，会影响bus2。但是，bus3完全不受影响。
这就是为什么使用deepcopy — 更安全的原因，你将得到一个对象值的全新副本。
4 —功能参数
提示:如果你设置一个空的可变变量作为 python 函数的默认值，要小心。
Python 参数通过共享使用一个名为的系统调用来传递，这意味着传递的值是浅拷贝。
如果你默认传递一个空列表，例如def my_func(x=[]):，然后改变x，你将编辑内置的list()功能，而不是变量x。
书中推荐的方法是通过 case 逻辑在函数的开头指定默认值…
def my_func(x):
if x is None:
x = []
就我个人而言，我认为上述方法有些矫枉过正，对风格也不好，不过这是你的选择。
5 —垃圾收集
提示:python 变量在引用用完时会被“垃圾收集”。
对于我们的最后一个技巧，让我们来谈谈 python 垃圾收集是如何工作的。
每次我们给一个对象赋一个变量名，我们就给它一个引用。所以a=1; b=a意味着存储1的存储单元的引用计数为 2。
现在假设我们将a和b都分配给None，例如a=None; b=None。现在，因为没有变量引用值为1的对象，所以可以对该内存位置进行垃圾收集。
如果参考计数为 0，存储器位置将被擦除，以便重新使用。
很简单，对吧？
现在，为了结束这个话题，让我们也来谈谈关键字del。**del** 是用来删除变量名，而不是对象本身。通过删除变量的名称，它释放了这个名称供以后使用，从而避免了潜在的名称冲突。然而，在后端，如果del导致引用计数为 0，那么对象也将被删除。
感谢阅读！我会再写 16 篇文章，把学术研究带到 DS 行业。查看我的评论，链接到这篇文章的主要来源和一些有用的资源。
使用 Python 字典计数器解决的 5 种算法
原文：https://towardsdatascience.com/5-algorithms-solved-using-python-dictionary-counters-5f68f5740211
通过 Python 字典学习计数对象的三种方法。
照片由像素上的埃尤普·贝伦拍摄
建议的点播课程:
你是否在努力推进自己作为 数据职业 的职业生涯？ 我强烈推荐您查看以下课程:
- 数据工程纳米学位(uda city)→优质课程如果你致力于从事数据工程方面的职业，
- Python 高级编码问题(StrataScratch)→我找到的准备 Python 的最佳平台& SQL 编码面试到此为止！比 LeetCode 更好更便宜。
- 用 Python 练习编码面试题(60+题) → 列表、数组、集合、字典、map()、filter()、reduce()、iterable 对象。
希望你也会发现它们有用！现在欣赏:D 的文章
介绍
尽管在过去的几年里，我每天都在用 Python 编程，无论是在工作场所还是在个人项目中，但是上个月，我决定从头开始重新学习。
我是一名白手起家的数据工程师，意思是我的学习过程大部分是通过起初的点播课程，然后在工作中从事真实的项目而发生的。
有时我不得不在不了解基础知识的情况下学习高级 Python 概念。这意味着我的代码要么不是最有效的，要么需要我做大量的研究来交付一个可靠的解决方案。
例如，字典是 Python 中最有用的数据结构之一。我发现自己一直在使用它们进行映射。它们也是许多 MAANG 面试问题 的核心，以至于前段时间，我已经写了一篇关于如何使用循环迭代 Python 字典的教程。
💔-ways-to-iterate-over-python-dictionaries-using-for-loops-14e789992ce5>
相反，在本文中，我想从这个知识库开始，演示如何使用字典来构建计数器。
计数器通常是一个简单的算法，用于确定某个对象在源数据集中出现的频率 ( 是列表、字典、元组、字符串等……)。计数器可以用许多不同的方式创建(涉及或多或少的类型，并导致或多或少的高效函数)。
在我的学习过程中，我对建造它们充满了热情，所以我想与你分享我的发现。为了做到这一点，在接下来的部分中，我给出了 5 个编码问题的解决方案(从真实的技术面试问题中提取的)，这些问题可以使用 Python 字典计数器来解决。
用字典计数对象
在其最简单的形式中，计数器是一个整数变量，初始赋值为零。每当特定对象出现在输入数据集中时，计数器就会增加 1。
当您需要一次计数几个重复的对象时，Python 字典就派上了用场，因为它的键将存储需要计数的对象，而值将保存实际对象的频率。
过去，我想知道为什么包含计数器的问题在 Python 技术访谈中如此常见，在我看来，原因是计数器经常被用作实现更复杂功能的起点。
“过去，我想知道为什么包括计数器在内的问题在 Python 技术访谈中如此常见，在我看来，原因是计数器通常被用作实现更复杂功能的起点……”
这意味着，有时需要构建一个计数器，因为接下来，算法将需要计算出的频率作为输入。为了理解我所说的，让我们一起来解决下面的编码问题。
问题# 1:统计词频
给定一个从热门电影片名中提取的几个单词的列表，定义一个函数count _ words返回一个字典，其中包括每个单词以及它们在列表中出现的频率。
# Example List
movie_titles = [‘the’, ‘name’,’of’, ‘the’, ‘rose’, ‘the’,’english’, ‘patient’, ‘the’,‘greatest’, ‘showman’, ‘in’, ‘the’, ‘name’, ‘of’, ‘the’, ‘father’]
解决方案# 1:使用字典键值分配
在第一个问题中，输入数据集是一个名为movie_titles的列表，包括几个需要计数的单词。
这里的策略是创建字典word_count，为列表中的每个唯一单词保存一个计数器。这通常是通过使用一个for循环来迭代 iterable 对象中的项目，加上一个特定的策略来构建计数器来实现的。
在本例中，我使用了我定义的普通或开放键-值对赋值，其中在每次迭代中，条件语句检查单词是否已经是字典中的一个键。如果不是，该算法用该单词创建一个新的键，并赋予初始值等于 1。否则，如果该单词已经是字典中的一个键，计数就增加 1。
尽管这可能是技术面试中提供的最简单和最冗长的解决方案，但我认为它应该被认为是完全可以接受的，因为它完成了工作，并表明您能够使用这种数据结构。
解决方案 2:使用默认值为 0 的 dict.get()
用字典计数条目更简洁的方法是使用dict.get()方法，用零作为默认 值。
get()方法将一个键和一个默认值作为参数。如果字典中没有这个键，get()创建这个键并将其与默认值配对。如果没有可用的默认值，则该键将被赋予一个None值。
在你的下一次技术面试中，如果你被要求创建一个计数器，我会强烈推荐你使用这个解决方案，一个关于数据结构的全面知识。
解决方案 3:使用计数器
Python 甚至通过从内置的collections包中导入Counter类，提供了一种更快的方法来计算字典中的对象，这是专门设计来将 iterable 作为参数，以一次性计算和存储几个可哈希对象的频率。
通常， LeetCode 接受使用Counter解决的算法，然而我宁愿在技术面试中避免这种方法，因为通常你不会被允许首先导入任何包。这是有道理的，因为面试官对你的现成的解决方案感兴趣。
问题# 2.1:计算项目总数
basket _ items字典包括了若干项以及它们在购物篮中出现的频率。定义一个函数count _ fruit只统计篮子里水果的总数，不包括其他项目。将总数作为字符串的一部分返回，格式如下→“篮子里有{result}个水果”。**
*# Example Dictionary
basket_items = {‘apricots’: 12, ‘peaches’: 12, ‘glasses’: 3, ‘hotdogs’: 8}
fruits = [‘apricots’, ‘bananas’, ‘peaches’, ‘pears’, ‘plums’]*
解决办法
与第一个问题不同，这里已经为您提供了一个包含频率的字典(basket_items)。唯一需要执行的任务是基于fruits列表中可用项目的条件求和。
在这种情况下，总计数已经存储在result变量中，所以这是一个编码问题，其中字典是生成计数器的输入，而不是它的输出。
问题# 2.2
如果您还想计算购物篮中非水果类商品的总数，该怎么办？定义一个新函数count _ fruit _ non _ fruit，返回一个格式为→的字符串，水果的数量为{fruit_count}。有{non_fruit_count}件非水果商品。
解决办法
这是上述问题的一个微小变化，这里你需要计算两个和(fruit_count和not_fruit_count)而不是一个。这是通过在原始条件语句中添加一个else子句来实现的。
问题# 3:返回单个数字
给定一个 非空 整数数组 *nums* ，每个元素除了一个以外都出现两次。找到那个单身的。
*# Example List
nums = [2,1,1,1,5,5,5,5,5,5,5,5]*
解决办法
这个编码挑战是多步算法的一个例子:
- 首先，使用一个计数器来确定
nums数字列表中物体出现的频率(方法与问题#1 的解决方案#1 相同)； - 然后，计算出的频率用于识别
nums中唯一的非唯一数字。
这在本质上看起来是一个小问题，但是在技术面试中，你经常需要使用普通的 Python 语法来复制像numpy.unique()这样的流行函数的行为。
问题# 4:字符串中的第一个唯一字符
给定一个字符串 *s* ，找出其中第一个不重复的字符，并返回其索引。如果不存在，返回 *-1* 。
*# Example String
s = ‘albatros’*
解决办法
到目前为止，函数的输入都是列表或字典。
相反，在这个编码挑战中，您必须计算字符串中的字符数s(这是通过从collections导入Counter来实现的)，然后返回第一个不重复的字符(count[ch]==1)，这是通过使用enumerate()来标识对应于每个字符的索引来实现的。
问题# 5:多数元素
给定一个大小为 *n* 的数组 *nums* ，返回多数元素。多数元素是出现超过 *⌊n / 2⌋* 次的元素。您可以假设多数元素总是存在于数组中。
*# Example List
nums = [3,3,3,1,1,5,5,5,5,5,5,5,5]*
解决办法
这最后一个编码挑战与问题#3 非常相似，就像那种情况，你会看到一个nums列表中的整数序列，你需要先对它们进行计数，然后验证是否满足条件。
唯一不同的是，这里不需要返回唯一的唯一数字，而是多数元素，或者出现超过*⌊n / 2⌋* 次的元素。
注意如何使用range()迭代器生成一个整数序列i,这两个整数在第一个条件语句中使用，然后检索与count字典中的一个键相关联的特定值。
哦，对了……你可能已经发现了，多数元素是 5，因为它在列表中出现了 8 次共包括 13 个整数 (其中13//2 = 6→请记住***/*****
结论
在本文中，我展示了使用 Python 字典和计数器组合解决的五种算法。你已经了解到有三种不同的方法来构建你可以在技术面试中展示的计数器。
请注意，上面的一些编码挑战是作者对最初出现在 LeetCode 和 Udacity 上的问题的重新解释(参见下面的参考资料)。
一般来说，解决同一个算法有多种方法，所以如果你能找到更有效的解决方案，请在评论中告诉我。
祝你学习顺利！
资源
- Python 的计数器:计算对象的 Python 方式
- Python 编程入门(Udacity)
- LeetCode 问题 136
- LeetCode 问题 169
- LeetCode 问题 387
使用 Python 列表的 5 个基本命令
原文：https://towardsdatascience.com/5-basic-commands-for-working-with-python-lists-3088e57bace6
让您了解 Python 列表的特征以及如何处理它们
格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片
Python 列表用于在单个变量中存储多个项目。它们是预装在 Python 中的总共四种数据结构之一。除了列表，它们还包括元组、集合和字典。
1.定义列表
我们通过将元素写在方括号中来定义一个 Python 列表。我们可以在一个列表中存储不同数据类型的元素。创建列表的第二种方法是调用“list()”函数。为此，元素必须写在双圆括号中。然而，这种书写方式很少使用。
2.查询列表的元素
一个 Python 列表的元素有一个决定每个元素顺序的索引。列表中的单个元素可以通过它们对应的索引来调用。这里当然要注意，我们的电脑从 0 开始计数。所以列表的第一个元素的索引为 0。
使用索引还可以调用列表的最后一个元素，而不知道它的长度以及具体的索引。在负索引的帮助下，我们可以从后面开始调用链表中的对象。使用这种计数方法，我们从 1 开始，而不是从 0 开始。
如果我们不仅想查询列表中的单个元素，还想查询整个范围，我们可以通过指定开始和结束索引来定义它。应该注意，开始索引是输出的一部分，而结束索引不是。
这里值得注意的是，列表范围的查询总是返回一个列表作为结果，即使 Python 列表只有一个元素。
该查询也可以在不指定结束索引的情况下执行。这有两种可能性:
在第一个选项中，方括号包含起始索引，然后是冒号。在我们的示例中，这将返回列表中的第二个元素以及第二个元素之后的所有其他元素，无论后面还有多少个元素，即“Tokyo”、“Montreal”和“Berlin”。
在第二个变体中，方括号首先包含一个冒号，然后是初始索引。在这种情况下，我们从 Python 列表中获取列表第三个元素之前的所有元素，即“纽约”和“东京”。
作为这些类型查询的辅助，可以使用下面的小算法:
- 将光标放在前面(！)的元素定义的数字。
- 如果冒号在数字后面，即在数字的右边，那么结果由一个列表组成，所有元素都在光标的右边。如果冒号在数字的前面，即在数字的左边，那么结果由光标左边的所有元素的列表组成。
对于我们的第一个查询“list_1[1:]”，我们将光标放在第二个元素的前面，即“Tokyo”的前面。因为冒号在 1 的右边，所以我们必须使用结果中光标右边的所有元素。因此，结果由包含元素“东京”、“蒙特利尔”和“柏林”的 Python 列表组成。
3.更改列表项目？
如果我们想改变一个 Python 列表中的单个或多个元素，我们可以像上面描述的那样调用它们，并简单地重新定义它们的值。
同时，我们还可以使用“insert()”方法在列表中的任意位置插入一个元素，而无需更改任何现有条目。以下值的索引将相应地增加 1。如果我们只想将一个元素追加到列表的末尾，我们可以用“append()”方法来实现。
4.从列表中删除元素
当然，我们也可以从一个 Python 列表中删除值，而不是覆盖它们。为此，有“pop()”和“remove()”方法。这两种方法的区别在于“pop()”将索引作为输入,“remove()”将具体的元素作为输入。
5.对列表进行排序
虽然列表中的元素是排序的，但是您可以按字母顺序或数字顺序对它们进行排序。但是，这改变了它们的索引，即列表中的顺序:
Python 列表中的顺序也可以颠倒，即从 Z 到 A 或从大到小排序。为此，您只需要额外的参数“reverse = True”:
然而，只有当 Python 列表由具有统一的数据类型的数据组成时，排序算法才有效。数字和字符串的混合会导致所谓的“类型错误”:
为什么这对数据科学家很重要？
Python 列表对许多数据科学家来说非常重要，因为它们可以用作大量数据操作的初始起点。因为列表可以在一个中存储不同类型的数据，所以它也可以在数据清理之前用于缓存大量数据。
数据科学家的主要优势是允许重复。例如，对于字典或集合来说，这是不可能的。使用 Python 元组，您还可以存储副本，但是元组在定义后不能更改，而列表可以。因此，Python 列表也是处理可能出现重复的数据的最方便的数据结构。
这是你应该带走的东西
- Python 列表可用于在 Python 变量中存储项目集合。
- 该列表是有序的，并使用索引来引用其元素。
- 它能够像 Python 元组一样存储副本。然而，Python 列表可以改变，而元组不能。
- 对于数据科学家来说，这是一个非常有用的工具，因为它可以用于数据清理和操作。
如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！还有，medium 允许你每月免费阅读 3 篇 。如果你希望有无限制的 访问我的文章和数以千计的精彩文章，不要犹豫，点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$5***获得会员资格**
*</6-fundamental-questions-when-working-with-a-pandas-series-1d142b5fba4e> </8-machine-learning-algorithms-everyone-new-to-data-science-should-know-772bd0f1eca1> </4-basic-commands-when-working-with-python-tuples-8edd3787003f> *
使用 Python 集合时的 5 个基本命令
原文：https://towardsdatascience.com/5-basic-commands-when-working-with-python-sets-875f71dcc85b
让您了解 Python 列表的特征以及如何处理它们
萨姆·麦克格在 Unsplash 上拍摄的照片
Python sets 用于在单个变量中存储多个元素。set 主要用于不允许元素多次重复的情况。因此，集合中的元素是唯一的。
1.定义 Python 集
Python 集合是通过在花括号中用逗号分隔各个值来定义的。这些元素也可以有不同的数据类型，但仍然存储在同一个集合中。
作为定义 Python 集合的第二种方法，您也可以使用“set”操作符并将元素写在双圆括号中。然而，这种方法很少使用。
2.查询 Python 集合中的元素
由于集合是无序的，因此顺序是不相关的，正如我们从 Python 列表或字典中所知，单个元素不能通过索引或键进行查询。剩下的唯一可能性是查询特定元素是否出现在集合中。
3.添加元素
现有集合可以通过单个元素进行扩展，甚至可以将整个集合添加到现有集合中。
值得注意的是，值“新元素”在最终集合中只出现一次。因此，如果我们想要向 Python 集合中添加已经存在的值，它们会被忽略。
由于四种数据类型在 Python 中紧密相连，我们也可以连接不同数据类型的变量。例如，列表也可以添加到现有的集合中。列表中的重复元素当然在集合中只考虑一次。
4.删除元素
如果我们想从 Python 集合中删除元素，也有不同的可能性。使用“删除”或“丢弃”命令，我们可以通过指定某个值来删除元素。另一方面，对于“pop ”,我们删除最后添加到集合中的元素。最后是“明确”。此命令删除集合中的所有元素，并留下一个空集合的变量。
5.合并多个集合
当合并多个 Python 集合时，只保留在两个集合中至少出现一次的元素。这发生在所谓的“联合”函数中:
“union”函数会自动创建一个新的对象，除了前面两个对象之外，还会存储一个新的对象。如果不希望这样，也可以显式地将元素添加到现有的 Python 集合中。为此，请使用“更新”功能:
这是你应该带走的东西
- Python Set 是 Python 中预装的四种数据结构之一。
- 它用于在单个变量中存储几个唯一的元素。元素的顺序暂时不重要。
- Python 集合与数学集合相当，因此可以用它执行相同的函数，比如 union。
如果你喜欢我的作品，请在这里订阅https://medium.com/subscribe/@niklas_lang或者查看我的网站* 数据大本营 ！还有，medium 允许你每月免费阅读 3 篇 。如果你希望有无限制的 访问我的文章和数以千计的精彩文章，不要犹豫，点击我的推荐链接:【https://medium.com/@niklas_lang/membership】每月花$5***获得会员资格**
*</6-pandas-dataframe-tasks-anyone-learning-python-should-know-1aadce307d26> </4-basic-commands-when-working-with-python-tuples-8edd3787003f> *
部署数据科学项目前要采用的 5 种最佳实践
原文：https://towardsdatascience.com/5-best-practices-to-adopt-before-deploying-data-science-projects-f8061889d294
如何应用 12 因素应用宣言中的一些想法
照片由 Unsplash 上的 Dstudio Bcn 拍摄
在最近的视频中，涵盖了 DevOps 推出 SaaS 平台的最佳实践， ArjanCodes 简要讨论了 12 因素应用，这是 Heroku 工程团队撰写的关于构建和扩展基于云的应用的宣言。
我对这份文件的内容很感兴趣，所以我立即在谷歌上查找。令人惊讶的是，它引起了我和我作为数据科学家的工作的共鸣。
在这篇文章中，我将首先从软件工程的角度讨论数据科学项目可能会出什么问题。
然后，我将向您展示如何将 12 因素应用宣言中陈述的一些原则应用于数据科学，以缓解一些问题。
如果您是数据科学家或机器学习工程师，这组最佳实践有望帮助您设计更容易投入生产的应用程序。
事不宜迟，我们来看看。
首先，为什么这与数据科学家有关？🤔
“为什么我应该关心 web 开发最佳实践？这不是我的工作。我是一名数据科学家”——我听到你说。
实际情况比这要复杂一些。
如果你是一名在公司工作的数据科学家，你永远不要指望独自工作，摆弄自己的数据集和笔记本，而不与其他团队的任何人互动。
事实是，数据科学应用程序越来越多地嵌入到软件产品中(API、web 应用程序、交互式仪表盘……)，因此，为了将它们投入生产，您(作为一名数据科学家)必须与数据工程师、后端和前端开发人员组成的多学科团队合作。
因此，在为相同的代码库做出贡献的集体努力中，对标准和最佳实践的需求对每个人都变得至关重要，包括数据科学家。
是什么让数据科学家不遵循通用软件最好的 practices❓
鉴于他们的背景和他们正在解决的问题的性质，数据科学家有一种非常具体的方式来组织他们的工作，这种方式可能不同于其他开发人员的工作方式。
这是办公室典型的一天。
- 在与业务利益相关者进行讨论和头脑风暴后，数据科学家致力于将问题转化为计算问题。(如果幸运的话，有一个清晰的指标可以优化)
在这个过程中，他们会提出几个假设，这些假设可以保留，也可以在以后抛弃 - 他们对可用数据进行分析和预处理，并提供算法解决方案来解决问题
- 他们在新数据上应用和测试他们的解决方案，并与团队分享结果。在这一步中，他们调查哪里出错了(例如不正确的预测)，并最终质疑最初的假设。这个过程又回到第一步，形成一个循环(假设审查、分析和模型改进、监测等。)
数据科学循环—作者图片
为了快速迭代这个循环，我们通常使用笔记本，它不过是从浏览器运行的交互式代码单元。
笔记本是将科学计算、降价和可视化结合在一起的有用平台，数据科学家经常用它们来构建复杂的算法。
Jupyter lab —作者修改的 GIF
⚠ ️然而，严重依赖笔记本是一个陷阱，可能会导致非常糟糕的编码实践。
这一点已经讨论了很多(这里的、这里的和这里的)但简单来说，笔记本可能是有害的，因为:
- 它们不容易被复制，也不鼓励任何形式的依赖管理
- 它们很难版本化和协作
- 它们引入了一些坏习惯，比如将配置与代码混合，硬编码值，不使用单元测试，等等。
简而言之，笔记本电脑非常适合数据探索和快速原型制作。然而，一旦你的数据科学项目足够成熟，可以集成到一个产品中，你就需要把它作为一个软件项目来构建并遵循一些标准。
现在让我们来看看 12 因素应用程序中的 5 个最佳实践，它们将帮助您更好地构建项目。
1-对每个应用程序使用版本化的代码库💻
您的数据科学应用程序的代码应该始终在代码库中进行版本控制:不要只是将您的文件和笔记本放在一堆文件夹中。
必须使用版本控制系统(如 Git、Mercurial 或 SVN)来跟踪这个存储库。
将代码存储在版本控制系统中使团队能够协作，解决合并冲突，将代码回滚到以前的版本，并添加持续集成(CI)和持续部署(CD)。
从单个代码库中，我们可以构建不同版本的不同发布，并将它们部署在不同的环境中(部署是应用程序的运行 实例)。
当您开始对代码进行版本控制时，会出现两种常见的反模式:
- 多个应用程序不能有相同的代码库。如果存在多个应用程序，每个应用程序都必须有自己的代码库。
- 每个应用程序只能有一个代码库。如果多个应用程序共享相同的代码库，这就违反了 12 因素。在这种情况下，应该在库中重构相互代码，并将其用作外部依赖项
2-明确声明项目需求并隔离依赖关系🛠️
当构建一个应用程序时，你永远不应该做出隐含的假设，即它的需求之一已经安装在将运行该应用程序的操作系统上:如果你的应用程序使用外部依赖项，你必须显式地声明它们，并将它们添加到你的代码库中。
这使得第一次运行该应用程序的任何人都可以使用正确的版本安装适当的依赖项。
如果使用 Python，依赖关系可以在requirements.txt文件中锁定和跟踪，该文件必须在代码库中进行版本控制。然后，可以使用 Pip 安装它们。其他工具可用，如诗歌和 Pipenv 。
requirements.txt 示例—作者图片
你的应用程序也应该在一个可复制的环境中被打包和隔离。这可以通过使用虚拟环境或容器化的 Docker 映像来实现。
3-将配置与代码分开🔒
现代云应用程序有许多配置设置(API 凭据、URL、数据库名称、端口号等)，这些设置可能会根据应用程序部署的环境(开发、试运行或生产)而变化。
出于隐私原因，这些配置设置应该与代码分开，并且永远不要签入版本控制。
解决这个问题的一种方法是使用配置文件，但更好的替代方法是在部署期间将配置设置作为环境变量注入。通过这样做，部署环境就决定了应该使用哪种配置。
此外，这种方法更加灵活，因为它允许轻松修改环境变量的值，并且不依赖于从外部文件解析设置的特定语言。
一个可用于存储凭证的第三方基于云的工具是 AWS Secrets Manager。
4 —应用应该平稳地依赖第三方服务📦
这个原则的主要思想是你的应用程序不应该区分本地和第三方服务。
这意味着您应该能够切换您的应用程序正在使用的任何第三方服务(数据库、SMTP 服务器、文件系统、消息传递/排队系统、缓存系统)，而无需更改应用程序的核心代码。
实现这一点的方法是只更改配置设置。
这样做的一个好处是，它使维护您的云应用程序变得更加容易，并减少了供应商锁定。例如，如果您希望通过从一个云提供商转移到另一个云提供商来更改存储服务，您只需移除旧资源并插入新资源。
这是在配置级别完成的，因为后台服务与代码是分离的。
后台服务—作者图片
5 —构建、发布、运行⚙️
例如，当您构建一个打包到 Python 库中的数据科学应用程序时，项目的部署过程应该有三个独立的阶段:构建、发布、和运行。
每一个阶段都会产生一个独一无二的藏物。
- 构建阶段获取回购的代码，获取所需的库和资产，并将它们打包成一个可执行包，称为 构建
- 发布阶段结合构建工件，并将其与环境的配置相结合，以产生一个 发布
- 运行阶段在执行环境中启动发布
参考
- 十二因素 Apphttps://12factor.net/
- Peter Hoffmann —使用 Python 的数据科学 12 要素应用—SPs 18:https://youtu.be/TuO_W-tzlqs
- https://medium . com/inspiredbrilliance/12-factor-spark-applications-eccb 78 BDC 371
结论
构建一个机器学习应用程序是一项集体努力，它结合了来自大量软件工程的多个概要文件。
虽然这些世界差异很大，相距甚远，但是存在一组将它们联合在一起的最佳实践。这些原则的流行列表被称为 12 因素应用程序。
虽然这篇文章只涵盖了 12 个中的 5 个，你仍然可以看看剩下的个并了解更多。
我希望这篇文章让您对这些最佳实践有了一个大致的了解。
感谢阅读！
新到中？您可以每月订阅 5 美元，并解锁各种主题的无限文章(技术、设计、创业……)您可以通过点击我的推荐链接来支持我
https://ahmedbesbes.medium.com/membership 
由丽贝卡·约翰逊在 Unsplash 上拍摄的照片
显著提高代码质量的 5 个最佳 Python 实践
原文：https://towardsdatascience.com/5-best-python-practices-to-remarkably-improve-code-quality-30f528162a5e
计算机编程语言
为了成为一名优秀的程序员，从初级阶段开始使用这些实践
cotton bro 拍摄的照片
从最佳实践开始学习 Python 吧！
当我开始使用 Python 时，情况有所不同。像我一样，许多其他人在初级阶段不知不觉中发现了一些糟糕的编码实践。
这些做法可能会让你的工作完成，但从长远来看，它会失败，然后它会变得非常复杂，找到并纠正错误。
从错误和经验中学习，我列出了 5 个最佳实践和要避免的坏实践😉
我把这篇文章写得很短，这样您就可以快速地完成它，并掌握最有用、最省时的 Python 最佳实践。🏆
可以用下面的索引跳转到自己喜欢的部分。
***·** [**Stop importing all using import ***](#adfd) **·** [**Specify the exception in the Try-Except**](#228b) **·** [**Use Dictionary methods**](#1331) **·** [**Use zip() to iterate over multiple lists**](#7eda) **·** [**Open a file using “with”**](#29b4)*
我们开始吧..🚀
*停止使用 import 导入所有内容
为了开始使用 Python 进行各种分析和自动化任务，我们需要从 Python 包中导入函数和类。
初学者遵循的一个最常见的做法是使用**import *** 从包中导入所有内容。
🚩**import ***语句导入所有可能与您定义的函数或您导入的其他库的函数冲突的函数和类。所以总会有函数覆盖或者变量覆盖的风险。
🚩另外，当您使用**import ***时，很难识别从哪个特定的库中导入了什么，从而降低了代码的可读性。
因此，一个好的做法是只从一个包中导入所需的方法/函数，比如**import function_name from package_name**。✔️
例如，从集合库中导入函数计数器
*from collections import Counter*
如果你仍然想从一个包中导入所有的功能，你可以不说import *就这么做。这种用例的一个经典例子是从 pandas 导入所有内容进行数据分析。
❌不好练:from pandas import *
✔️ ️Good 练习:import pandas as pd
然后你就可以使用 pandas 包中带有前缀pd.的所有功能，例如pd.DataFrame()
在 Try-Except 中指定异常
就像每个初学者一样，我曾经有一个坏习惯，就是在 try-except 语句的 except 子句中不提 exception。
例如，在 except 子句中没有提到任何异常并不能让我们了解 except 子句执行时到底发生了什么。
除了作者|图片，没有例外
理想情况下，在a或b中应该有一些错误，但是在 except 子句中没有提到异常让我们不知道发生了什么。
此外，如果不提及异常，我们就无法捕获代码中的特定错误，因此对代码流的控制也很弱。
这可以通过提及下面的例外来转化为良好实践。
except 子句中的异常|作者提供的图像
处理except条款中的NameError给了我们不执行try条款的确切原因。✔️
你可以在这里找到 Python 中的所有异常以及关于如何使用 try 的细节——除了可以在这里找到https://www.freecodecamp.org/news/python-try-and-except-statements-how-to-handle-exceptions-in-python/。**
使用字典方法
你可能知道字典方法 。按键()。值()*** 和 。items() 分别只访问键、值和键-值对。***
如果你不知道，这里有一个简单的例子。
**# Create a dictionary with,
# keys 'A', 'B', 'C', 'D'
# values 1001, 2002, 3003, 4004 respectively
mydict = {'A': 1001,
'B': 2002,
'C': 3003,
'D': 4004}**
从 Python 字典中提取键、值和键值对|按作者排序的图片
如上图所示，key-value对作为元组，可以用.items()提取。
但是，有时使用不正确。例如，为了使用 for 循环显示字典中的键和值，一些编码人员编写，
mydict.keys() |作者图片
在上面的场景中，for 循环中的mydict.keys()是不必要的，print 语句中的mydict[keys]效率较低。🚩
相反，我们可以使用更有效的mydict.items()，如下所示。
mydict.items() |作者图片
这样，我们总能从.items()方法生成的键值元组中解包出键和值。✔️
如果你愿意学习更多关于 Python 中的字典，这里有一个快速阅读。
**https://pub.towardsai.net/python-dictionary-10-practical-methods-you-need-to-know-cbeb1c962bed
使用 zip()遍历多个列表
我在初学者时注意到甚至遵循的一个常见的坏习惯是使用一个索引来迭代多个可迭代对象，比如列表、字典。
❌糟糕的做法看起来像，
遍历列表|按作者排序的图像
看，这并不是完全错误的，因为它产生了我们想要的输出。但是，这不是有效的好做法。
相反，使用可读性更强的**zip()**函数。根据定义，python 中的zip()函数用于将来自多个可迭代对象的元素按元素聚合到一个可迭代的元组中。✔️
zip()函数的这个属性可以在 for 循环中使用，在 Python 中迭代多个 iterables(列表或字典)。
并行遍历多个列表|按作者排序的图片
很简单！
使用“with”打开文件
打开的文件必须在工作完成后立即关闭 —这是最佳实践。
我和其他数百万人一样，使用打开、关闭、读取、写入来处理如下文件，
f = open('new_file.txt', 'w')
f.write('This is first line')
f.close()
这个的问题是，最后一行**f.close()**大部分都忘记了！🚩
然后如果write/read方法抛出异常，文件不会被关闭。
这里最好的选择是使用**with**打开并编辑文件，如下所示。
with open('new_file.txt', 'w') as f:
f.write('This is first line')
这样就不需要独占关闭文件了。一旦你在with语句缩进之外写了新的一行代码，文件会自动关闭。✔️**
希望你很快看完这篇文章，觉得有用。
当这些最佳实践被采用时，它可以节省大量的时间来调试和理解代码。💯
过去 4 年多以来，我一直在使用 Python，并且仍在学习一些好的实践来提高我的代码质量。💪
对阅读介质上的无限故事感兴趣？？
💡考虑 成为媒体会员访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡不要忘记注册我的电子邮件列表 来接收我文章的第一份拷贝。
感谢您的阅读！
数据科学家应该警惕的 5 种偏见和谬误(以及如何避免它们)
原文：https://towardsdatascience.com/5-biases-fallacies-data-scientists-should-beware-of-and-how-to-avoid-them-9b567174d2c1
职业生涯中常见的错误
Photo by 愚木混株 cdd20 on Unsplash
介绍
处理数据最困难的事情之一是处理困扰数据本身以及我们如何解释数据的谬误和偏见。由于存在数百种偏见和谬误，我们大多数人都犯有做出错误结论和创建有偏见模型的错误。
在这篇文章中，我想谈谈所有数据科学家都应该注意的 5 种最常见的偏见和谬误，以及如何实际上避免它们。
说了这么多，让我们开始吧！
请务必 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！
1.新奇偏见
这是什么？
新鲜感偏见是指顾客参与一项新功能或产品是因为它是新的，但不一定是因为他们喜欢它或因为它有价值。例如，如果一个新按钮出现在 YouTube 主页上，最初很可能会有很多点击，因为用户很好奇这个按钮是做什么的。当存在新鲜感偏见时，在开始时，治疗组很可能比对照组获得更多的参与，但这不是真正的效果。
如何解决它
您可以根据客户被分配到治疗组的时间进行群组分析，看看这种影响是否会随着时间的推移而减弱，而不是分析同一时间段(开始和结束时间)的所有客户。如果是的话，那么很可能这个实验存在新奇偏见。
2.数据挖掘
这是什么？
数据挖掘是指错误地进行数据分析，对同一组数据进行许多统计测试，并只报告那些有重大结果的数据。通过在多个统计测试中重复使用相同的数据，增加了测试偶然出现统计显著性的可能性(如果 alpha 为 0.05，则有 5%的可能性出现 1 型错误)。
如何解决它
没有完美的方法来解决这个问题，但最简单的解决方案是进行随机样本外测试，也称为交叉验证。就像验证机器学习模型一样，您会在测试假设之前拆分数据。然后，你可以用前半部分创建假设，用后半部分验证你的假设。
请务必 点击此处订阅 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
3.采摘樱桃
这是什么？
统计学中的挑选是指选择或“挑选”支持你立场的信息，即使有明确的证据与你的立场相矛盾。
当决策者想要推出一项功能或产品时，这种情况非常普遍。他们通常会选择任何看起来积极的见解来支持他们的决策，这违反了统计测试的原则。
如何解决它
在测试你的任何假设之前，无论是产品特性还是其他，决定一到三个核心指标，你将使用它们来确定它是否成功。请注意，我强调您应该在测试您的假设之前决定这些度量标准。
不要仅仅因为你想推进你的议程而移动目标。如果你看到一些有趣的事情，调查它，把它当作一个新的假设，不要基于一个意想不到的变化做出你的决定。
4.汇总指标的危险
图片经许可取自维基媒体
20 世纪 70 年代，统计学家弗朗西斯·安斯科姆(Francis Anscombe)收集了四组具有相同均值、方差和相关性的数据。然而，当你看上面的图表时，很明显它们是完全不同的。这意味着显示仅仅依赖汇总指标的危险性。
如何解决它
养成通过百分位数或十分位数而不是平均值来查看数据的习惯。同样，如果可能的话，试着通过图表(直方图、散点图)来查看你的数据。
4.虚假因果关系
这是什么？
当一个人认为因果关系的存在是因为相关性的存在时，就会产生虚假的因果关系。一个错误的因果关系的例子是，如果我假设我每天早上穿着鞋睡觉都会头疼。事实上，无论何时我喝多了，我都会忘记脱鞋，然后带着宿醉醒来。
如何解决它
为了解决这个问题，永远不要假设相关性意味着因果关系。相反，你需要用控制实验来进一步验证你的假设。
一定要 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！
5.辛普森悖论
这是什么？
辛普森悖论是一种趋势出现在不同的数据子集中，但在子集合并时消失或逆转的现象。
举个例子，伯克利大学在 20 世纪 70 年代被指控性别歧视，因为女性申请者的录取率低于男性。但是，在深入研究之后，他们发现，就单个受试者而言，女性的接受率实际上高于男性。造成这种矛盾的原因是，大部分女性申请者申请的是竞争激烈的学科，而这些学科的男女录取率都要低得多。
如何解决它
将您的所有指标分解成它们的组成元素。例如，如果你在看公司收入，你应该按来源分解收入，并把它与相关成本联系起来。这样，你就降低了对你的业务表现做出错误结论的风险。
感谢阅读！
务必 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
不确定接下来要读什么？我为你挑选了另一篇文章:
还有一个:
特伦斯·申
- 如果您喜欢这个， 订阅我的媒介 获取独家内容！
- 同样，你也可以 关注我上媒
- 跟我上LinkedIn其他内容
成为数据分析领域领导者的 5 本书
原文：https://towardsdatascience.com/5-books-to-grow-as-a-leader-in-data-analytics-e16b31a5925a
埃里克·范·迪克在 Unsplash 上的照片
你是一个正在走向管理岗位的高级分析师，一个新的分析经理，还是一个有经验的？如果是这样，领导技能是成功的关键，这些书将帮助你实现这一目标。
成为领导者是一条漫长的路，读五本书不会改变一切。然而，这些书正在帮助我理解一些支持我走向管理的关键概念，我相信它们能帮助你。
我将在下面展示的书籍选择是以成为一名分析型领导者为导向的，但它们也可能适合其他角色。这个角度的第一个原因是，分析是我的领域；因此，我更明白我们可以面对的挑战。其次，与许多技术领域一样，分析领域的经理过去是高级个人贡献者，这种转变需要适应。
以下是我建议阅读的培养你的领导技能的书籍的主题。我特别推荐读第一本书，因为在我看来，脆弱远非弱点，而是成为伟大领袖的必备技能。
- 理解同情、恐惧和勇气
- 技术领导者的导航指南
- 在新的管理岗位上取得成果
- 建立分析策略
- 固定思维与增长思维
敢于领导—布伦·布朗
作者照片
你曾经遇到过需要进行艰难对话的情况吗？在那里，你害怕冲突并最终避免了的强硬谈话，保留了诚实和富有成效的反馈？那么这本书很可能会启发你，并给出可操作的行动项目。
研究人员和领导力教练布伦·布朗将在本书中指导你寻找内心的勇气，消除我们建立的人为障碍，并能够以最佳状态领导。
笔者将通过调研和亲身经历，探讨如何找到领导的勇气，去除对失败的恐惧，管理好自己的情绪。
如果你想与你的团队建立更深层次的联系，学习如何给予和接受反馈，在工作场所建立信任，失败如何让我们变得勇敢，…
管理者之路——卡米尔·福涅尔
作者照片
您应该安排常规的一对一吗？应该每周一次吗？会不会太多了？它带来了什么？我们肯定会问自己这些相关的问题，谢天谢地我们不是第一个。
如果你正准备开始一个管理职位，这是一本好书。它有你作为一名经理需要学习的所有技巧和诀窍。这是我读过的最好的管理“指南”书；它给出了高层次的方向和具体的建议。
作者正在经历一个技术环境下的所有管理阶段，如何做一个导师，管理一个团队还是管理多个团队。
我强烈推荐根据需要多读几遍这本书。然后，当一个挑战出现时，回到相关的章节，以获得灵感或答案。
一个经理人的成功之路——朱莉·卓
作者照片
您将开始一个新的经理职位；你将领导哪种类型的团队？
- 你正在成长的团队中担任管理职位吗？
- 你会接替离职的经理吗？
- 你正在组建一个新的团队吗？
- 你在管理一个现有的团队吗？
所有这些职位将产生非常不同的挑战。这本书将帮助你了解如何在新工作的旅程中导航。
“伟大的管理者是造就的，不是天生的”
这个概念是本书的开篇，我们从未准备好，我们不是天生的管理者，我们还有一切要学。 Julie Zhuo 撰写了这本现代指南，讲述了作为一名经理意味着什么，如何在团队中建立信任、主持会议、招聘人员……你将能够在轻松清新的写作中了解或重新发现新经理可能面临的陷阱。
作者将利用她自己作为脸书公司年轻经理，直至产品设计副总裁的经历，启发你，给你许多窍门，最终让你成为一个更自信的经理。
在分析上竞争——达文波特、哈里斯
作者照片
今天的商业世界不应该依赖于产品、技术或服务。相反，他们应该在分析上竞争！达文波特教授和哈里斯教授在他们由哈佛商业评论出版社出版的书中论证了这一概念。
在分析方面的竞争提供了一个真正由数据驱动的路线图。你将学习如何创造新的分析策略，如何评估你公司的能力，并引导它在分析领域竞争。
感谢来自不同领域(营销、产品、供应链、人力资源……)和几家公司(谷歌、UPS、迪士尼)的各种例子，这本书将与大多数公司的分析领导者相关。
卫生部——卡罗尔·德韦克博士
作者照片
我们的心态决定了我们如何应对各种情况和挑战，并最终决定了我们如何成长。在这本书里，卡罗尔·德韦克博士讨论了固定思维和成长思维的差异。
简而言之，有固定思维模式的人寻求认可，认为他们的能力是一成不变的。当成长心态的人对发展持开放态度时，将失败视为成长机会。
即使你认为自己有一个成长的心态，也会有你的心态被固定的情况。但是，通过意识到它和理解这个概念，你会改变你的心态，朝着正确的方向成长。
要想成为领导者，你需要尽可能多地使用成长思维；这本书给出了理解行为的所有关键，并让我们走上释放我们全部潜力的道路。
我希望这些书对你和对我一样有帮助。如果您有其他建议，请随时联系我们或添加评论。
如果你喜欢 Medium，请考虑使用我的推荐链接来获得对每篇文章的无限制访问，我将收取你的一部分会员费，不收你任何费用！
https://valentin-mucke-ds.medium.com/membership
免责声明:本帖中有附属链接支持我的写作。如果你通过他们买东西，我可以赚佣金。至于你是否决定买东西，决定权在你。这完全取决于你。
干杯
5 本书帮助你写出更好的代码
原文：https://towardsdatascience.com/5-books-to-help-you-write-better-code-ac0aef64de70
提高代码的质量、可读性和可维护性
达威特在 Unsplash 拍摄的照片
无论你处于职业生涯的哪个阶段，无论你是技术领域的新手，还是刚刚开始学习如何编程，或者你已经在这个领域工作了几年，甚至你已经是这个领域的资深人士，你都需要继续努力和提高的一项技能是代码编写。
编写优秀代码的能力通常比代码所做的事情更有价值。如果你的代码是干净的、组织良好的、易于阅读和理解的，你作为程序员的价值将会非常高。如果你能写代码，你就能轻松地调试、维护和扩展它。
写好代码不仅仅是软件工程师的事；我认为这是技术领域任何人的基本技能，尤其是数据科学家。当然，你写代码和调试代码越多，你就越知道如何写好代码。但是，有时候，你可以通过阅读一本关于什么是好代码以及如何编写好代码的书来加快速度。
书籍是获取信息和学习新技能的重要来源；问题是，外面的书太多了，一个人读不完。但这正是本文的目的。我读了很多关于软件工程和编写代码的书，今天我要讲的 5 本书是我最喜欢的，它们帮助我提高了很多代码编写技能。
书 1:干净的架构软件结构和设计的工匠指南
Robert c . Martin 的 Clean Architecture 是我们列表的一个很好的起点，也是任何有抱负的程序员或数据科学家开始编写更好代码的一个极好的地方。Robert 提供了超过半个世纪的经验，向您展示了做出什么选择，以及为什么它们对代码的成功至关重要。
这本书涵盖了您在日常工作中必然会遇到的许多现实生活场景和应用，如软件设计的基本原则、数据管理以及您可以使用的不同编程范例。不仅如此，特别是对于数据科学家来说，这本书涵盖了关于数据库的最佳实现和网络的高级结构的章节。
第二册:美丽的架构:领先的思想家揭示了软件设计中隐藏的美
接下来是迪奥米迪斯·斯皮涅利和圣乔治·古西奥斯的《美丽的建筑》。这本书的独特之处在于，它不仅仅是作者写出了他们的想法；相反，它是由各种成功的软件工程师和架构师撰写的关于如何构建健壮的、可维护的和干净的代码的文章的集合。
通过阅读这本书，您将了解以数据为中心的应用程序生态系统的基础知识，以及您的系统架构如何影响您的整个系统的性能。您还将了解面向对象和函数式架构编程之间的区别和相似之处，以及使用这两种范例如何影响软件的发展和开发人员的参与。
第 3 册:面向模式的软件架构，第 1 卷，模式系统
尽管软件或技术总体上是一个快节奏的领域，但是好代码的基础并不新鲜，尽管该领域取得了进步，但核心概念仍然保持不变。这本特别的书是一本古老而珍贵的书；面向模式的软件架构写于 1996 年，至今仍然非常适用。
今天使用的大多数成功的软件系统都有相似的模式；这些模式经常被重复，因为它们一次又一次地被证明有效。这本书在不同的抽象层次上阐述了这些模式，以及如何将它们结合起来构建健壮的系统。
第四册:可读代码的艺术
在多年编写代码甚至阅读代码之后，你会开始对写得好的代码有一种欣赏感。它们易于阅读和理解，这意味着它们也更易于扩展和调试。清单上的下一本书也是我最喜欢的书是《可读代码的艺术】。
作者 Dustin Boswell 和 Trevor Foucher 的这本书展示和分析了数百个写得很差的代码的例子，并教你为什么它被认为是写得很差，以及如何改进它。这本书涵盖了各种主题，例如格式化、编写更好的注释、精炼循环和逻辑以降低复杂性、如何组织代码等等。
书 5:设计模式:可重用面向对象软件的元素
今天的最后一本书是另一本古老而珍贵的书，Design Patterns:Elements of Reusable Object-Oriented Software，作者是四人组:Erich Gamma、Richard Helm、Ralph Johnson 和 John Vlissides。那本书中介绍的四种设计模式今天仍然被用来创建可重复的、健壮的代码。
这本书解释了可用于设计软件的不同模式，主要是三种模式类别，创建、结构和行为。然后，您可以选择使用这些模式中的一种或组合来使您的代码更好地基于您的应用程序。
最后的想法
每当我教别人如何编码时，我总是告诉他们，学习编码的基础知识和如何实现算法是容易的部分。学习如何编码的挑战部分是掌握编写干净的、可维护的和可复制的代码的能力。然而，这种技能并不是那么容易教的，你写代码越多，你的代码编写技能就会提高越多。
因为编码是几乎每个技术相关领域的核心，从科学计算到机器学习和人工智能，许多书籍和资源可以帮助你将代码编写技能提升到一个新的水平。
在本文中，我推荐了 5 本我最喜欢的代码架构和结构书籍，它们极大地提高了我的代码编写技能，并教会了我的学生如何编写和识别干净、编写良好的代码。我希望这些书中的一本能帮助你提高代码的质量，并成为你将技能提升到下一个水平的原因。
让非技术用户更好地理解人工智能的 5 本书
原文：https://towardsdatascience.com/5-books-to-understand-ai-for-non-technical-users-6d138f095d1c
一系列解释复杂概念的资源，不考虑读者的技术背景
photo by@ owned photography@ unsplash . com
【免责声明:此帖子包含图书保管处的附属链接】
随着时间的推移，人工智能和数据科学越来越与社会相关。算法仅用于营销或销售目的的日子已经一去不复返了；今天，人工智能正在改变我们互动、通勤甚至驾驶的方式。
对于非技术人员来说，要理解大部分 AI 技术可能有点力不从心。通常，当有人谈到人工智能时，他们往往会用很多技术术语或令人困惑的行话来说话，这使得人们很难理解算法在当今生活中的影响。幸运的是，随着人工智能书籍的激增，有一些资源面向非技术用户，旨在用较低的技术层简单地解释这些概念。
在这篇文章中，我们将看到一些与非技术用户相关的书籍，以了解人工智能在当今世界的影响，以及他们可以从哪里了解该领域的发展方向。
开始吧！
商业数据科学:关于数据挖掘和数据分析思维，你需要知道什么
照片由 @sortino @Unsplash.com 拍摄
Provost & Fawcett 的书是对人工智能和数据科学技术的精彩介绍，是进入该行业的一个很好的方式。这本书提供了一些非技术用户在接触数据科学和人工智能时可能遇到的常见问题的答案:
- 培养一个“模特”是什么意思？
- 人工智能与数据工程和可视化有什么关系？
- 我们可以对哪些最常见的用例应用预测建模？
- 什么是文本挖掘？
这本书是一本非常好的入门书，包含了恰到好处的技术细节。如果您正在寻找一种轻量级的数据科学方法，这将是一个很好的选择！
在书库找到。
人工智能基础:非技术性介绍—汤姆·陶利
图片由 blocks @Unsplash.com 提供
一本很好的入门书，详细介绍了人工智能和数据科学的不同分支，如自然语言处理、计算机视觉或机器人过程自动化。
通过巧妙的图表和易于理解的语言，这本书是对该领域的一个很好的快速介绍，有助于理解当前人工智能趋势的最新水平。
如果你已经对 AI 和通用数据科学有了一些接触和了解，这本书对你来说可能有点基础。然而，尽管很短，它包含了有趣的想法，特别是如果你刚刚开始学习像大数据、神经网络、或深度学习这样的术语。
你可以在书库上找到。
数学毁灭武器:大数据如何增加不平等并威胁民主——凯西·奥尼尔
Markus Spiske @Unsplash.com 照片
当涉及到伦理和道德时，在社会的几个领域部署算法的扩散带来了很大的担忧。人工智能模型可能对公平公正的社会极其有害，因为它们可能会强化一些已经存在于模型数据中的偏见。
凯茜·奥尼尔的书非常简明扼要地讲述了将人工智能模型盲目应用于我们社会各个方面的危险。如果你刚刚开始了解人工智能在我们日常生活中的影响，这本书将为你提供一个深思熟虑的视角，说明应该如何部署机器学习模型，以及为什么你需要小心某些人工智能“神奇”的解决方案。
与大多数技术突破一样，人工智能有能力应用于大多数用例——其中一些可能会让社会变得极其富有成效，而另一些可能会带来极其有害的警告。这本书可能是详细而准确地解决这个问题的最佳资源之一。
你可以在书库上找到。
商业中的人工智能和机器学习:数据驱动技术的实用指南
photo by@ donramxn@ unsplash . com
另一本关于人工智能和机器学习的非技术指南，史蒂夫·芬利的书是一个很好的介绍，几乎没有技术术语，并以非技术的方式接近人工智能。
虽然与 Provost & Fawcett 的书相比，这本书没有那么深刻，也不那么以商业为导向，但它将通过几个深思熟虑的章节对其进行很好的补充，这些章节针对的是你在其他资源中可能看不到的重要问题，例如:
- 预测模型生成的分数代表什么？
- 什么是决策树？
- 什么时候能买到自动驾驶汽车？
这本书将有助于你对过去十年的机器学习有一个很好的非技术性的概述，使用一种深思熟虑的和半时间顺序的方法。
你可以在书库上找到。
如何对统计数据撒谎——达雷尔·赫夫
图片由@ follow EB@ unsplash . com 提供
这是这个列表中最古老的书，在人类开始概念化现代“人工智能”领域之前就已经编辑好了！大多数人工智能算法依赖于统计数据——至少，数据科学家的主要目标是以一种可以推广到其他场景的方式对现实生活现象进行建模，而统计数据是我们目前在这方面的最佳猜测。
达雷尔·赫夫的书是一个开箱即用的建议，它总结了从业者在使用统计数据时可以使用的最常见的技术。虽然与人工智能不完全相关，但它是一个很好的资源，可以帮助你理解为什么人们可以用算法、汇总统计数据或情节来愚弄你。
这是一个很好的阅读，可以理解即使是最伟大的人工智能模型也可能会有极大的偏差和扭曲，以使它们看起来非常准确。虽然主要集中在图和汇总统计，但这本书的原则也适用于数据科学或机器学习项目，因为使用虚假统计愚弄他人的原则在一些项目中反复出现。
在书库上找到。
感谢你花时间阅读这篇文章！
如果你是非技术读者(比如产品或项目经理，市场人员，或者只是一个好奇的人！)，希望这些资源能帮助你更好地理解 AI 一点。特别是当涉及到机器学习模型的非道德部署时，非技术用户能够理解人工智能模型如何工作以及它们如何在输入数据和预测之间建立关系是非常重要的。
当社会处于非技术人员能够理解不准确或有偏见的数据上的训练模型背后的含义的阶段时，我们将真正能够受益于更准确、公平和可靠的人工智能系统——我真的相信这些资源在为那个阶段做出贡献方面做得很好。
有其他推荐补充吗？写在评论里吧！
https://medium.com/membership/@ivopbernardo
使用 Python Map-Reduce 函数解决了 5 个编码问题
原文：https://towardsdatascience.com/5-coding-problems-solved-with-python-map-reduce-functions-c744193193ff
面试 | 算法 | Python 编程
厌倦了使用显式循环？试试 Python 的 map 和 reduce 函数吧。
照片由 Ylanite Koppens 在 Pexels 上拍摄
建议的点播课程
你们很多人联系我要有价值的资源 钉 Python 编码面试 。下面我分享几个 课程/平台 我强烈推荐练习完本帖算法后继续锻炼:
- Python 数据工程纳米学位(uda city)→优质课程如果你致力于从事数据工程的职业，
- Python 高级编码问题(StrataScratch)→我找到的准备 Python 的最佳平台& SQL 编码面试到此为止！比 LeetCode 更好更便宜。
- 用 Python 练习编码面试题(60+题) → 列表、数组、集合、字典、map()、filter()、reduce()、iterable 对象。
还不是中等会员？考虑与我的 推荐链接 签约，以获得 Medium 提供的所有内容，价格低至每月 5 美元！
为什么要用 map()和 reduce()？
你有没有发现自己在想:“如果有一种不使用显式循环的方法来解决这个编码问题会怎么样？如果我可以用一个内衬代替循环，我的解决方案会有多优雅？”**
我知道，对吧？这是我在某个时刻问自己的那种问题，在用一个蛮力解决了几十个算法之后… “一定有更好的办法，”我想。
然后一个顿悟，一个突破…一个真正的游戏改变者:我发现了 Python 的map()和reduce()函数。
我能听到有人说:“你又来了……又一个把函数式编程当灵丹妙药卖的……map()reduce()早就该撤了。还有更好的方法，更大蟒的！”。**
有几分真实，但是我喜欢把map()和reduce()想象成 SQL:它很老了，不再流行了，但是它很管用，所以人们一直在使用它。事实上，** 这些方法在处理可重复项时特别方便，无需编写循环。**
所以请原谅我，在本文中，我将解释这两种方法的优缺点，并与您分享用 **map()** 或 **reduce()**解决的 5 Python 编码问题。我还将提供一个替代解决方案，来说明这种方法对于消除循环是有用的，但不是必不可少的。
但首先，一点理论…
如何使用 Python 的地图( )
引用文档，map() “返回一个迭代器，该迭代器将函数应用于 iterable 的每一项，产生结果”。该函数的语法如下:
****map**(*function*, *iterable*, *...*)**
- 函数参数可以是任何 Python 可调用的，如内置函数、方法、自定义函数** (UDF)、 lambda 函数。**
- 该函数对一个或多个 iterables 应用转换，如字典，列表，元组返回地图对象。
为了更好地理解map()，假设你希望计算 10 个圆的面积。因为公式是 A = π r ，π是已知常数，所以你需要的只是一个半径列表( r ):
**# Compute the area of 10 circles starting from their radius expressed in meters.# Formula --> A = π r²**from math import pi****radius =** [3, 5, 2, 8, 18, 22, 12, 6, 9, 15]# Using lambda function:**list(map(lambda x: pi*(x**2), radius))****Output:** [28.27, 78.53, 12.56, 201.06, 1017.87,1520.53, 452.38, 113.09, 254.46, 706.85]# Alternative - Using UDFdef area_of_circle(r):
return pi*(r**2)**list(map(area_of_circle, radius))****Output:** [28.27, 78.53, 12.56, 201.06, 1017.87,1520.53, 452.38, 113.09, 254.46, 706.85]**
如您所见，调用map()将匿名函数或 UDF 应用于radius中的所有项目，并且(来自 Python 3.x )返回一个迭代器，该迭代器产生每个圆的面积。然而，为了显示输出，你需要在它上面调用list()。
地图的主要优势()
如果有人(特别是在采访时)问你为什么在解决编码问题时选择使用map()，这里有一些原因:
- 由于
map()是用 C 语言编写的，它可以被认为是高度优化的，特别是当它的内部循环与常规 Pythonfor循环比较时。 - 使用
map()，一次评估一个条目(而不是像 for 循环那样在内存中存储完整的 iterable)。这导致了内存消耗的显著减少。这就是为什么map()返回一个迭代器对象而不是另一个可迭代像 list 的主要原因。 map()与 lambda 函数和用户定义的函数配合得很好，这反过来意味着它可以用于对 iterables 应用复杂的转换。
地图的主要缺点( )
同样，面试官可能想知道你是否能想到使用这种方法的缺点。例如:
- 事实上
map()返回一个地图对象也是一个缺点，因为你总是需要在上面调用****list()**才能使用函数的输出，这并不是最性感的语法…** - 很快，Lambda 函数和 UDF 对你的同事来说会变得很难解释。出于这些原因，由
map()提供的功能几乎总是可以被替换为列表理解或生成器表达式，它们被认为更具可读性和 Pythonic 性。
既然你已经理解了如何使用map()，下面的编码挑战将帮助你测试你的能力。
用地图解决的问题
# 1.排序数组的正方形
****Output:**
[4, 9, 9, 49, 121]
[4, 9, 9, 49, 121]**
一个预热编码问题，它准确地显示了何时使用map()是有意义的:一个简单的转换，需要应用于 iterable ( 整数列表 nums)和 t 的每一项，产生相同数量的转换项。
注意，solution_map()不需要调用list()来评估地图对象。这是因为sorted()函数(默认为)返回指定可迭代对象的排序列表。
备选解决方案(solution_lc)显示了如何使用列表理解实现相同的结果。考虑到任务的简单性，可读性方面的改进相当有限。
# 2.反转字符串中的单词
****Output:**
uoY lliw teg doog ta gnivlos gnidoc smelborp
uoY lliw teg doog ta gnivlos gnidoc smelborp**
一个有趣的编码问题，因为您需要找到一种方法来反转输入字符串，保留单词顺序。这意味着您需要首先用s.split()创建一个 iterable，它将输出一个单词列表，然后用x[::-1]反转它们，最后用" ".join()重新创建一个句子。
尽管很有效，但solution_map()看起来有点乱(因为这里 *list()* 必须被调用来访问颠倒的单词)，并且需要一段时间来理解map()内部的内容。
备选解决方案(solution_genx())，使用生成器表达式** ( 的语法类似于列表综合，但使用 *()* 括号)提供了对map()的自然替换。生成器表达式在内存消耗方面和map()一样高效，并且经常使你的代码更具可读性。**
# 3.人数最多的至少是其他人的两倍
****Output:**
3
3**
当我试图自己解决这个编码问题时，使用filter()和map()功能的组合对我来说比使用enumerate()更自然，就像在替代解决方案中一样。
尽管filter()不是本文的主题，但这是另一个非常受欢迎的方法，它是从函数编程中派生出来的，可用于根据条件过滤一个可迭代的对象(在本例中为，目标是用 num != max(nums)从数组中排除最大的整数)，然后在过滤后的列表filter_max()中调用map()。
然而，我不得不承认使用enumerate()导致了一个更干净的解决方案，它允许使用索引，而不必调用三个函数(即filter()、all()和map())，这也使得它非常优雅。
如何使用 Python 的 reduce()
首先，值得一提的是，map()是内置的函数，reduce()需要从functools模块导入。
该函数的语法如下:
****functools**.**reduce**(*function*, *iterable*[, *initializer*])# Note that you can pass a third parameter named **initializer**.
# When provided, reduce() will feed it to the first call of function # as its first argument.**
与map()类似，reduce()接受一个可迭代并对其应用一个函数。然而，reduce()从左到右将函数应用于项目，以便将 iterable 减少为单个值。
因此，
map( )和reduce( )的主要区别在于，前者意在输出与 iterable 中相同数量的项目，而后者将 iterable 中的项目减少到一个值。
使用reduce()最直接的方式是执行聚合，如求和或计数。例如，假设你想计算偶数的数量是一个列表:****
****# Count the number of even numbers present in the values list.values = [13, 8, 12, 57, 13, 81, 10]# Using lambda function:**reduce(lambda x, y: x if y % 2 else x + 1, values, 0)******
上面的 lambda 函数检查每个数字是否能被 2 整除而没有余数，用这种方法测试它是偶数还是奇数。
当余数为零时[if 语句评估为假，因此]计数增加 1(请注意，初始化器已被设置为零，因为变量 *x* 充当计数器)。**
reduce()的主要优势
reduce()功能带来了与map()功能相似的好处，例如:
- 因为
reduce()也是用 C 编写的，所以它的内部迭代器比标准 Python for 循环要快。 - 对于需要多行代码的问题，
reduce()提供更简洁的解决方案并不罕见。正因如此，*reduce()*是面试时的有力工具。**
reduce()的主要缺点
然而，使用该功能的主要缺点是:
reduce()会给代码增加额外的计算时间，因为这个函数直到处理完整个 iterable，才会返回输出，然后无法实现短路评估。reduce()在使用复杂的 UDF 或 lambda 函数时会损害代码的可读性，所以只要有可能，最好选择专用的内置函数。
既然你也知道如何使用reduce()，让我们来练习一下你所学的。
使用 Reduce 解决了问题
# 4.数组乘积的符号
******Output:**
-1
-1****
计算数组中所有值的乘积是用reduce()执行的完美任务，我鼓励你在面试时使用它，因为在这种特定情况下，你实际上需要遍历完整的 iterable 、、，这样短路评估就不适用。****
然而，从 Python 3.8 中，您可以简单地从math包中导入prod函数，以获得相同的结果，并且语法更加易读，如备选解决方案所示。
# 5.两个数组的交集
******Output:**
[3, 3, 5]
[3, 3, 5]****
最后一个编码问题是如何在字典中使用reduce()的例子(特别是在collections.Counter中)。我发现solution_red()相当优雅，因为它避免了显式循环，并且利用了elements()方法返回最终数组。
另一方面，另一种解决方案(solution_ext)确实使用了 for 循环，感觉有点小众，除非你确切地知道你在用extend()做什么。
总结
编写更紧凑和优雅的代码的能力，是面试官和其他开发人员真正欣赏的品质。
编写更紧凑和优雅的代码的能力，是面试官和其他开发人员真正欣赏的品质。
一个优秀的 Python 开发人员是能够以简洁的方式提供智能解决方案的人。效率和速度，在业内确实算数。
为了朝这个方向迈出一步，在本文中，您已经学习了 Python 的map()和recuce()函数是如何工作的，以及如何使用它们来处理 iterables ，而无需编写显式循环。
然后，你也实践了你所学到的，解决了 5 个需要在可迭代上应用转换的编码问题。**
最终，通过不同的解决方案，您明白了有多种(通常甚至更高效的)方法可以替代 for 循环。**
来源
- Python 的 map():无循环处理 Iterables
- Python 的 reduce():从函数式到 Python 式
- 结合实例理解 Python Reduce 函数
- LeetCode 问题 977
- LeetCode 问题 557
- LeetCode 问题 747
- LeetCode 问题 1822
- LeetCode 问题 350
对 P 值的 5 种常见误解
原文：https://towardsdatascience.com/5-common-misinterpretations-of-the-p-value-aacaa6dcfddd
在解释和报告您的结果时避免这些
照片由奎特拉·登特在 Unsplash 上拍摄
令人惊讶的是，我经常看到对 p 值的度量以及从中可以得出的结论的误解。对 p 值的不正确理解会使您对结果的描述不精确。更糟糕的是，它会导致对你的结果的误导，甚至是错误的结论。在本文中，我将讨论对 p 值最常见的 5 种误解，并尝试解释思考 p 值的正确方法。
1。p 值为 0.05 意味着零假设为真的概率为 5%。或者，p 值为 0.05 意味着替代假设有 95%的可能性为真。
这是对假设检验实际检验的内容和 p 值测量的内容的误解。p 值并不衡量零假设为真的概率，事实上，p 值假设零假设为真。
p 值表示您的数据与统计模型的假设(包括零假设)的符合程度。在进行假设检验时，我们不是在建立“真理”,我们检验的是我们能为替代假设找到多少支持，根据结果，我们决定我们认为合理的相信。
作为对 p 值的实际解释< 0.05, one can think “假设零假设为真，我们将得到与我们观察到的结果相似的结果，或者更极端(远离零)，平均不超过 5%的时间”。
2。p 值小于 0.05 表示您发现了您的研究问题的重要科学结果。
人们很容易认为低 p 值意味着你有值得分享的重大成果。虽然它可能具有统计学意义，但影响/关联的大小可能非常小，以至于缺乏任何实际或临床意义。
如果样本很大，即使微小的影响也会产生具有统计意义的结果。例如，你对一种新的减肥药的效果进行了一项大型研究。结果显示 p 值较低，但测试组和安慰剂组之间体重减轻的实际差异仅为 100 克。在这种情况下，即使结果具有统计学意义，质疑减肥药的有效性也是合理的。(卖药丸的公司大概会宣称这种效果已经被科学证明了！)
3。p 值大于 0.05 意味着效果尺寸很小
这与上面的误解有关，误解也是反方向的。p 值大于 0.05 并不意味着效果大小很小。如果数据中有大量噪声，统计测试可能无法检测出显著的影响，甚至是很大的影响。如果样本很小，这种情况尤其常见。
4。p 值大于 0.05 意味着没有关系或影响
在报告 p 值大于 0.05 的结果时，您应该避免使用类似“没有关联”或“没有证据”的短语。除非你的点估计值等于零假设值，否则声称“没有证据”是不正确的。这可能看起来令人困惑，但如果 p 值小于 1，则数据中存在某种关系。您还需要查看点估计值和置信区间，以评估它是否包括重要性的影响大小。
你可能会问，0.05 的临界值是什么，你应该不使用它吗？是的，p 值 0.05 是将 p 值描述为“显著”或“不显著”的常见临界值，您应该使用它。(这个特定的限制及其含义本身就是一个讨论的话题，在这里我只试图解释 p 值实际测量的是什么。)在解释 p 值时，需要记住的重要一点是，当使用“统计显著性”这一术语时，我们讨论的是结果的性质，而不是我们正在研究的总体或效应的性质。
5。p 值为 0.05 意味着有 5%的假阳性风险(I 类错误意味着当空值为真时拒绝空值)。
人们混淆了个别测试的 p 值与测试的显著性水平或 alpha 水平。这也被称为测试的 I 型误差或大小。这度量了 p 值被拒绝的频率(p < 0.05) over 重复测试，假设所有假设和零假设为真。换句话说，它给出了误报的比例。你可以做一个模拟，指定零假设为真。运行模拟 1，000，000 次，如果测试的大小为 0.05，我们预计拒绝空的 50，000 次(测试的 5%)。这与在单独测试中拒绝空值不是一回事。假设零假设成立，如果你拒绝零假设，出错的几率是 100%，而不是 5%。
你可以在本文的中找到关于如何估计显著性水平的更详细的解释。
我意识到很容易误解 p 值的含义。我还可以看到，有人在解释假设检验的更广泛的概念时，可能会以一种易于理解的方式表述 p 值和显著性，但不幸的是，这是不正确的。上面的例子可能看起来是无关紧要的(双关语)细节，但它实际上对科学结果如何呈现以及观众如何理解它们有影响。
我希望这能提醒你在报告结果时注意措辞是多么重要。通常，你可以在新闻中听到一项新的科学研究在某个主题上发现了显著的结果，但实际的效果大小却没有报道。还记得公司卖减肥药的例子吗？他们可能声称他们的减肥药有一种已经被科学证明的效果。嗯，这在技术上是正确的，但我要声明这种说法是严重误导。
我希望这篇文章对你有用。如果您能想到其他对 p 值和统计显著性的常见误解，请在评论中告诉我。
如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你注册使用我的链接，我会赚一小笔佣金。
https://medium.com/@andreagustafsen/membership
你可能错过的 5 个很酷的 Python 库(第 2 部分)
原文：https://towardsdatascience.com/5-cool-libraries-in-python-you-might-have-missed-part-2-72e82a1f2c7c
幸运的是，我找到了这些令人兴奋的库！
照片由思想目录在 Unsplash 上拍摄
介绍
我喜欢阅读新的 Python 包，每当我遇到任何有趣的东西，我都想写下来分享一下。我也曾经有一篇关于这个话题的文章分享，是你可能错过的 5 个有趣的 Python 库 。
几天前，我继续发现了一些更酷的包，我相信这些包在很多情况下都会有帮助。这就是为什么我决定在今天的文章中继续讨论。
现在，让我们看看今天有什么。
Pytrends
我相信你们中的许多人曾经听说过谷歌趋势。这是一个免费的公共平台，可以让你追踪对某个主题或搜索短语的兴趣。那么，我们如何将谷歌趋势整合到 Python 中呢？如何从手动搜索和复制谷歌趋势中节省时间？
好吧，让我们来看看 py Trends——Google Trends 的一个非官方 API，用于从 Google Trends 中提取数据。使用 Pytrends，您可以轻松获取每小时兴趣、地区兴趣、热门趋势搜索以及相关主题或查询的数据。更多信息可在本 文档 中找到。
下面是这个包的一些优秀的 API 方法。
寻找热门搜索
如果我们想知道个人在过去几天里对什么感兴趣，我们可以使用pytrend.trending_searches.简单地找出答案
美国十大热门搜索是:
图 1:美国热门搜索——作者图片
搜索热门历史图表
例如在另一种情况下，我们可以尝试用top_charts属性寻找 2020 年的 Google top chart。
图 2:排行榜—按作者分类的图片
在top_charts属性中，您可以确定您的母语hl、时区tz或地点geo来生成相应的排行榜。
发现主题的区域趋势
例如我挺好奇 《蜘蛛侠:无路可归》 过去 3 个月在各地区的走势。因此，我将借助interest_by_region来了解不同国家的人们的兴趣，如您在下面的代码中所见:
图 3:按地区划分的兴趣—按作者划分的图片
对于 Google Trends，值在 0 到 100 的范围内确定，100 表示最受欢迎的位置，趋势处于顶峰，0 表示所选术语的数据不足的位置。因此，很容易看出这部电影在玻利维亚达到了顶峰。
随着时间的推移寻找兴趣
例如我现在更感兴趣的是从 12 月初到月底跟踪 【蜘蛛侠：英雄无归】 的人气，看看电影什么时候受到的关注最大。我如何使用 Pytrend 查找数据？
用get_historical_interest很简单。在该组件中，您可以指定想要查看的特定时间范围。
图 4:随着时间推移的兴趣——作者图片
嗯，正如你在图 4 中看到的，电影高峰在 2021/12/29 和 2021/12/05。简单吧？
除了 Pytrend 中的这些搜索方法之外，您还可以深入研究更多方法:
- 历史小时兴趣 : 给出 Google Trends 对搜索关键字的历史小时兴趣数据。
- 建议 : 为细化趋势搜索提供了一个额外的建议术语列表。
- 相关查询 : 查了你的短语的用户也查了这些术语。
nb _ 黑色
如果你不确定 Python 的格式，nb_black 允许格式化你的代码。步骤很简单。你要做的就是:
- 安装软件包
- 在笔记本的开头加载软件包，并让软件包为您完成所有格式化工作
!pip install nb_black
%load_ext nb_black
下面的图 5，6 显示了这个包如何自动纠正我的代码格式。
图 5:凌乱的格式——作者图片
图 6:格式正确的图片
数字计算器
该软件包有助于将自然语言数字转换成数字(整数和浮点数)。比如我想把 【二万零一百零五】 翻译成数字，Numerizer用法如下:
应用函数后的结果是 20105。又酷又轻松，对吧？
打开数据集
我们可以使用 OpenDataSets 直接下载一个 Kaggle 数据集。它将创建一个保存数据集的文件夹。数据集保存在解压后的文件下，方便使用。
我们所要做的就是安装软件包，并选择我们想要下载数据集的 URL。如图 7 所示，选择数据“巧克力棒等级”进行下载。运行代码后，解压缩后的数据集立即出现在保存我的笔记本的文件夹中。非常简单方便。
图 7:下载 Kaggle 数据集——作者 GIF
皮阿斯特罗
最后，py astro——一个非常有趣的库来结束本文。如果你是一个对十二生肖感兴趣的人，这个库就是给你玩的。
它为每个星座提供了一个星座。你可以知道那天一个星座的预测，这个星座的幸运数字，幸运时间，幸运颜色，甚至星座的兼容性。
结论
我相信从成千上万的 PyPI 库中选择一个合适的库来执行可能很困难，这就是我写这篇文章的原因。我希望这篇文章和我之前的 5 个你可能错过的有趣的 Python 库 能让你对一些可用的有趣的 Python 库以及如何执行它们有所了解。
我知道他们中的一些人目前似乎没有用，但我相信他们在未来会以某种方式支持你。
感谢您抽出时间阅读。
参考
https://predictivehacks.com/get-google-trends-using-python/ https://pypi.org/project/nb-black/ https://github.com/JovianML/opendatasets
使用 OpenAI GPT-3 的插入文本模式的 5 种创造性方法
原文：https://towardsdatascience.com/5-creative-ways-to-use-openai-gpt-3s-insert-text-mode-7a738088f20e
了解 GPT-3 的插入模式的使用案例
作者图片
OpenAI 最近(2022 年 3 月 15 日)在 GPT-3 的文本生成中推出了编辑和插入模式。虽然 edit &插入模式仍处于测试阶段，但他们已经展示了令人印象深刻的文本填充和编辑功能。
在本教程中，我们将重点介绍 GPT-3 的插入模式以及使用它可以完成的一些创造性任务。简而言之，插入模式可以被视为一种智能填空模式。
如何进入 GPT 3 号游乐场的插入模式？
一旦你进入 GPT-3 游戏场，在右侧面板上，点击模式下的中心向下箭头图标。它调出插入模式，将屏幕分成两列，输入和输出。
作者图片
如何在 GPT 三号游乐场使用插入模式？
要使用插入模式，您只需在左侧框中输入一些开始文本，添加【插入】，然后添加您的结束文本。然后 GPT-3 在右侧自动用它生成的相关输出上下文替换【插入】。在下图中，以绿色突出显示的文本是在【插入】处新生成的文本。
作者图片
虽然上面的用例对于生成给出故事开始和故事结束的情节非常有用，但是一旦我们利用列表格式，就会出现更多有趣的用例，我们将在下一节中看到。
1.填充进度级别
您可以输入任何职业发展的水平，例如下图中一名软件工程师从初级到 CTO 的发展。
GPT-3 将自动用相关标题填充元素列表。类似地，你可以生成从水手到船长的船员等级。
有趣的是，你可以动态地改变等级的数量，GPT-3 会相应地适应。您可以将 CTO 列为第 9 个列表点，它将生成从 2 到 8 的适当级别，从初级软件工程师开始。
图片由作者使用 GPT 3 游乐场
2.生成多面板迷因
另一个有趣的用例是生成多面板迷因。由于 GPT-3 文本插入可以被视为一个智能的填空系统，您可以给定第一个迷因行文本和最后一个迷因行文本，并要求它在两者之间扩展。
迷因取自https://imgflip.com/
上面的迷因也被称为星系大脑象征着右栏大脑的扩展，表明认知能力的提高，而讽刺的是，左栏文本在进化中退化，变得越来越差。
作者图片
在上面的例子中，你可以看到我们在左侧给出了一个提示，只显示了第一行和第四行的迷因文本，并要求智能地填充第二行和第三行的迷因文本。在右边，你可以看到类似于真实模因的输出。
我们正在建造superme . AI，这是一个人工智能热图生成器，我们在这里用 GPT-3 进行实验，为如上所述的多面板迷因生成迷因文本。
3.为任务生成说明
以下用例类似于 OpenAI 文档中显示的生成烘焙指令的用例。
您可以为任何给定的任务生成指令，而无需了解手头任务的任何细节。在下面的例子中，我们正在生成训练一只猫的指令，你可以看到开始文本和结束文本非常普通，在它们之间有【插入】。尽管如此，GPT-3 模型能够为给定的任务生成完全相关的指令。
指令生成对于公司和营销团队创建传单或指令手册非常有用，因为它在心理上也更容易让客户记住和遵循。
作者图片
4.创造通向目标的途径
您可以使用 GPT-3 插入模型来生成通向给定目标的路径。例如，你可以提示 GPT-3 在 Twitter 上创建一条通往 10 万粉丝的途径，只需注册该平台即可。
您还可以尝试将最后一步从 10 万更改为 100 或 1000 名追随者，实现每个目标的途径和策略可能会略有不同，因此 GPT-3 将在大多数情况下相应地适应和产生。
作者图片
5.为博客生成主题大纲
另一个有趣的用例是生成博客主题大纲。同样，在没有真正了解主题的情况下，你可以给出一般性的开头和结尾文本，如引言和结论，并要求 GPT-3 为手头的主题生成相关的副标题。
作者图片
祝 NLP 探索愉快，如果你喜欢它的内容，请随时在 Twitter 上找到我。
如果你想以实用的方式学习 NLP，请查看我的课程自然语言处理实用介绍
面向数据科学家的 5 种数据分布
原文：https://towardsdatascience.com/5-data-distributions-for-data-scientists-97d92d028190
数据分布帮助我们更好地理解随机变量。这篇文章提供了关于 5 个重要数据分布的总结和资源，可以帮助你建立一些统计基础。
照片由 Chris Barbalis @unsplash.com 提供
统计学在塑造现代社会中发挥了巨大的作用，是帮助我们了解周围世界的主要工具之一。自古以来，统计学和数学是对推论和经典概率论做出贡献的两个学科。
来自统计世界的一个主要概念是大多数随机变量被建模成一个可以用参数描述的形状。这就是我们通常所说的数据分布。
数据分布是统计学的基石之一。假设检验和概率理论是从简单的概念发展而来的，即绘制随机变量的多次出现，可视化它的形状，并用它进行一些数学运算。
基本上，分布是随机变量呈现自身的一种方式，它帮助我们理解:
- 随机变量的期望平均值是多少？
- 随机变量的期望分布是多少？
- 值的范围是什么？
在我们开始之前，将连续分布和离散分布分开也很重要。
离散分布模拟可以取一定数量值的随机变量(如掷骰子、年龄等)。)是可数的——通常是整数。连续分布模拟随机变量，这些变量可以取无穷多个值，例如温度、人的体重等，通常用浮点数表示。
在数据科学和分析的背景下，了解要素和目标的数据分布将为您构建模型提供更好的假设(例如，何时线性模型合适或不合适)。此外，了解数据分布将有助于您建模和构建目标变量。
在本帖中，我们将探索一些最常见的数据分布，并使用 Python 模拟几个例子。
正态分布—连续分布
可以说，最著名的数据分布是正态分布。许多不同的现实世界现象都围绕着著名的钟形曲线，例如:
- 特定人群的身高；
- 出生体重；
- 学生的考试成绩；
这些例子真是五花八门。这就是为什么正态分布是一个如此令人印象深刻的概念——它能够模拟从经济学、生物学和社会学等不同研究领域的许多现实世界现象。
正态分布最重要的特征:
- 均值、中值、众数都差不多。
- 标准差决定了分布的扩散；
- 它大致是公制的。
让我用 Python 来举例说明。首先，让我加载几个库，它们将帮助我生成本文中的示例:
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
让我们绘制一个由 7 个随机样本生成的正态分布图，我们将使用 seaborn 的密度图:
np.random.seed(42)
(
sns.kdeplot(np.random.normal(loc = 100, scale = 3, size = 7))
.set(title='Density Plot of Random Normal Distribution')
)
生成的随机“正态分布”—由作者生成的图像
请注意，我们的随机变量倾向于“钟形”曲线——我们有一个小样本，目前，形状仅近似于钟形。当我们处理较小的样本时，这是完全正常的-总体的基本分布可能具有真正的正态分布，但是因为您的样本如此之低，样本模式可能偏离完美的钟形曲线。
经历正态分布的特征:
- 均值——这是分布的峰值，也是大多数例子的落脚点——在我们来自
numpy.random的normal函数中，这由loc参数表示。 - 标准差是分布在平均值周围的预期分布。较低的值意味着值变化较小。该参数由上面函数中的
scale表示。
如果我们增加生成上述数据的样本数量，会发生什么情况？让我们绘制 10.000 均值样本的正态分布图，我们通过改变图中的size参数来改变这一点:
np.random.seed(42)
(
sns.kdeplot(np.random.normal(loc = 100, scale = 3, size = 10000))
.set(title='Density Plot of Random Normal Distribution')
)
生成的随机“正态分布”—由作者生成的图像
酷！我们的随机变量现在是一个完美的钟形曲线。标准差设置了钟形的宽度-标准差越低的正态分布变量最终将具有越细的钟形曲线。
您将在典型数据科学项目的几个特征中找到正态分布:
- 对于线性模型，假设之一是我们的线性模型中的误差应该是正态分布的。如果不是，那么我们可能不应该使用线性模型(比如回归)，或者你需要更多的特性。
- 另一个例子是依靠 p 值测试来推断特征预测目标的能力的模型。P 值只不过是对正态分布效应的概率值的测试。
- 更常见的应用是检查特征的正态性，并应用某种标准偏差范围来排除训练表中的异常值。如果基础变量遵循近似钟形的曲线，那么使用一些统计数据来执行异常值检测可能是个好主意。
大多数正态分布没有很多偏斜，这意味着它们以平均值为中心。但是还有其他一些现象有很长的右尾巴——它太常见了，我们甚至给它起了个名字！让我们看看下一个话题。
如果你想探索正态分布背后的数学，那么正态分布维基百科页面非常好。
对数正态分布—连续分布
另一种连续概率分布，对数正态分布可能看起来与正态分布相似，但它有一些缺点:
- 它向右倾斜，意味着它有一个正的胖尾巴。
- 它只包含正值。
考虑对数正态分布的参数的一种方法是考虑均值和方差的和，虽然不是底层值本身，而是底层变量的对数变换。
举个例子，让我用 Python 来展示这个分布的形状，参数均值 = 3，标准差 = 1:
生成随机的“对数正态分布”—图片由作者生成
同样，我使用numpy来生成对数正态分布:
np.random.seed(42)
(
sns.kdeplot(np.random.lognormal(mean = 3, sigma = 1, size = 1000))
.set(title='Density Plot of Log Normal Distribution')
)
plt.xlim([0,500])
现在，一件很酷的事情是，如果我对生成的数据应用对数(使用np.log),会发生一些有趣的事情:
np.random.seed(42)
(
sns.kdeplot(np.log(np.random.lognormal(mean = 3, sigma = 1, size = 1000)))
.set(title='Density Plot of Transformed Log Normal Distribution')
)
生成转换后的随机“对数正态分布”——图片由作者生成
认得这个吗？其实是正态分布！对数正态分布在现实生活中很常见:
- 大多数包含货币值的变量往往具有对数正态分布，例如顾客在商店的购买量；
- 收入分配；
- 成人体重有服从对数正态分布的趋势；
大多数情况下，不可能有负值的现象和我们可能找到极端正值的地方可以用这种分布来建模。
如果你的模型依赖于纯线性，用log变换来转换这些变量可能会提高它的性能和稳定性。
同样，如果你对对数正态分布背后的数学感兴趣，请访问这个维基百科页面。
伯努利分布——离散分布
伯努利分布是最简单的分布之一。但是不要混淆简单性和重要性——最终，对伯努利分布背后的价值建模可能是一项非常困难的任务。
它包括将一个单一的概率值附加到一个概率为 p，的事件上，只考虑一个单一的“试验”。这些事件有两种结果(是或否，1 或 0，基本上是二分值)。
让我们用 Python 来想象一下——想象我们对 100 名患者进行随机试验，并给他们一种特定的药物。治疗结果可以是治愈(1)或不治愈(0)。每种结果只能发生一次——没有人能被治愈两次。
当然，幸存者可以在以后接受新的治疗，但这超出了伯努利分布的范围——我们进行了实验，得出了以下值:
伯努利试验——治疗示例——图片由作者生成
不幸的是，我们的病人中有 70 人没有治愈，而 30 人治愈了。我们现在可以提取成功的概率:30/(30+70)，得出 30%。伯努利分布通常由这个概率 p 表示——称为成功概率——用 Python 模拟并使用stat='probability':
bernoulli = np.array([0]*70+[1]*30)
sns.histplot(bernoulli, stat='probability').set_title('Bernoulli Trials')
伯努利分布(1-p 对 p)-治疗示例-作者生成的图像
现在，这项研究中的多个个体的数量只是为了实验，它们并不包含分布本身。伯努利分布由一个单一的p(30%)组成，我们将其附加到某种类型的结果上。这个p很难估计，需要进一步测试(特别是对于非确定性事件)。
在现实生活场景中很难得到这个值p——例如，在我们的例子中，我们假设 30%是药物治愈的真实概率，但这个数字可能只是偶然发生的。在现实生活中，情况通常是这样的——我们假设一个值 p ,这是对整个人口的真实值 p 的估计。
公平抛硬币的伯努利试验更容易理解，因为这些值是决定论的(正面和反面各有 50%的机会):
伯努利分布(1-p 对 p)-抛硬币-图片由作者生成
在某些情况下，您有兴趣估计真实生活场景中的这个 p :
- 手术成功的概率；
- 客户在贷款的前 90 天内拖欠债务的概率。
- 客户点击特定广告的概率。
伯努利分布的一个扩展叫做二项式分布——接下来让我们来看看！
二项式分布—离散分布
请记住，我们假设 p的值是 30%——这意味着在我们的伯努利试验中，我们的药物将治愈 100 名患者中的 30 名。二项分布是伯努利分布对于多次试验(或实验)的推广。**
如果这是真的，并且我们最终做了 1000 次类似的试验，我们会期望我们的二项式分布看起来像下面这样:
二项式分布—治疗示例—作者生成的图像
*np.random.seed(42)
(
sns.histplot(np.random.binomial(n = 100, p = 0.3, size = 1000))
.set(title='Histogram of Binomial Distribution of 1000 trials with n=100 and p=30%')
)*
np.random的binomial功能的参数为:
n—试验中的样本数量——在这种情况下，我们考虑一个“样本”一个单独的个体。p—概率的基础值。对于n=1,我们正在讨论伯努利分布的p。size—试验次数。
在某些试验中，我们最终治愈了 25、35 甚至 40 名患者— 这可能是我们挑战伯努利分布假设的一种方式，即我们的 p 为 30%。
但是..如果不是用 100 个人来做每个试验，而是用 1000 个人来做，会发生什么？
二项式分布—治疗示例—作者生成的图像
看那个！认得这个形状吗？一个正态分布！我们所见证的是中心极限定理的展示。
二项式分布是验证你为伯努利试验估算的真实 p 值的好方法。想象一下，对于我们的医学应用示例，真实的二项分布如下:
二项式分布—治疗示例—作者生成的图像
在这种情况下，平均值集中在 320/325 附近——这可能意味着，伯努利中的实际 p 可能是 32%或 32.5%。
查看可汗学院的统计和概率课程部分，获得更多关于二项式的直觉。
泊松分布—离散分布
另一个著名的离散分布是泊松分布。
这种分布模拟了特定事件的发生，但我们不是看试验的次数，而是看时间段，我们没有“成功”的理论上限，即固定的个体。在二项式中，我们有固定的试验次数，而在泊松中，我们有固定的时间间隔。
例如，让我们想象一个叫做“A 队”的足球队。你检查了过去的 10 场比赛，“A 队”进了 25 个球。您将使用一个简单的平均值来估计“A 队”的平均进球数，即 2.5 个进球。
你已经找到了泊松分布的λ参数。这个λ类似于伯努利分布中的 p 。
假设在接下来的 100 场比赛中，A 队平均进 2.5 个球，那么他们的预期进球分布是怎样的？
泊松分布-足球队示例-由作者生成的图像
*np.random.seed(42)
(
sns.histplot(np.random.poisson(lam = 2.5, size = 100))
.set(title='Histogram of Poisson Distribution of 100 games with lambda=2.5')
)*
有了这些数据，我们现在可以直观地看到一个球队在接下来的比赛中能够进任意数量的球的概率:
泊松分布—带有概率的足球队示例—图片由作者生成
酷吧？大致我们可以看到:
- “A 队”在下场比赛中有~33%的几率进 0 或 1 球。
- “A 队”在下一场比赛中有大约 27%的机会准确地打进 2 球。
- “A 队”有~40%的几率在比赛中打进 2 个以上的进球。
。泊松分布包含一个参数:
- **λ，该事件在该时间段内的预期发生次数，用
lam表示。
在我们的例子中有一个小问题——对于使用泊松分布建模的流程，事件必须是独立于的。我们可以说，足球队的状态并非如此，因为一场比赛会影响下一场比赛的士气，进而影响预期目标。即便如此，已经多次测试表明，足球队在一个赛季中的进球往往遵循泊松分布。
倾向于遵循泊松分布的其他现实生活现象:
- 您所在城市每周的网络故障次数；
- 一小时内到达车站的列车数量；
- 商店每周销售的特定产品的数量；
查看泊松分布维基百科页面了解更多详情。
我们完事了。感谢你花时间阅读这篇文章。我希望你喜欢这篇文章，我邀请你检查一下这些发行版背后的数学。看到大量现实生活中的现象都遵循其中一种分布也是非常有趣的。
作为一名数据科学家，您将来很有可能会处理这些分布中的一种，了解它们将有助于您改进统计游戏，并更熟悉生成要素和目标的过程。
我在Udemy建立了一个学习数据科学的训练营，在那里我向学生们介绍统计和算法！这门课程是为初学者量身定做的，我希望你能在我身边。**
数据科学训练营:你成为数据科学家的第一步 —作者图片
*https://ivopbernardo.medium.com/membership *
永远不会过时的 5 项数据科学技能
原文：https://towardsdatascience.com/5-data-science-skills-that-will-never-become-outdated-6c9de1e60d88
意见
趋势来来去去，但数据科学家永远需要这些技能
丹·克里斯蒂安·pădureț在 Unsplash 上拍摄的照片
虽然我们喜欢讨论数据科学的最新趋势和雇主正在寻找的最新技术，但我们并不总是关注你永远需要的技能，无论你是 2022 年还是 2072 年的数据科学家。
随着时间的推移，编程语言会发生变化，机器学习和人工智能的能力也会发生变化。新的工具将被创造出来以产生美丽的视觉效果。数据管道可能变得如此精简，以至于一个人就可以完成数据工程师、分析师和科学家的工作。
然而，尽管数据科学领域可能会发生各种事情，但在可预见的未来，仍有五项技能仍然相关。
1.通过即时学习新技能来保持相关性
数据科学家的价值取决于他们给公司带来的影响。数据科学家能够给公司带来的影响取决于他们在一个快节奏的行业中保持相关性的能力，这个行业总是在寻找下一个最好的东西。
虽然数据科学的某些方面将始终保持与过去 20 年相同的状态，例如 Excel 的使用和统计的重要性，但在这段时间内，新的方面迅速出现。比如西蒙。AI 和显然。人工智能正试图通过开发无代码数据科学能力来彻底改变这个行业。
因此，作为一名数据科学家，你在日常工作中的一项任务就是通过即时学习新技能来保持相关性。这意味着跟上数据科学的最新发展，寻找可以使公司流程现代化的方法，并自学新技能，这将使你在就业市场上成为抢手货。
2.使用基本的数学概念
数学在数据科学中永远不会过时。
虽然一些数据解决方案能够简化分析数据所需的数学要求，但理解产生所需结果的基础数学仍然至关重要。
例如，作为一名无代码数据科学家，您可能不理解统计假设测试的基本知识，因为您知道在适当的位置放置一个特定的模块将会为您做这件事。那么，你怎么知道你得到的结果是否正确呢？
虽然机器学习和人工智能可能会占据数据科学家日常工作的很大一部分，但了解数据科学的基本数学概念将使您能够确保一切都正确完成，并且收到的结果是您所期望的。
因此，根据你的资历或你工作的领域，拥有算术、代数、统计和微积分的基础将永远是时尚。
3.使用谷歌解决问题
一旦你进入科技行业，你会意识到一件事，那就是大多数人不知道他们在做什么，他们完成工作的大部分能力来自谷歌。
不，说真的。问问你认识的任何从事技术工作的人，不管是哪个领域的还是资历高的，他们都会说他们花了一天的大部分时间在谷歌上搜索如何完成一项特定任务的答案。
作为一名数据科学家，一项难以置信的关键技能是能够在谷歌上搜索你的问题并找到相关答案。幸运的是，您可能已经在学习成为数据科学家所需技能的过程中发展了这种技能。然而，谷歌搜索不会就此止步，它可能会贯穿你的整个职业生涯。
因此，知道如何最大限度地使用这个搜索引擎是至关重要的，包括在你的搜索查询中使用“vs”来比较两个事物，使用引号来搜索准确的短语，最重要的是，准确地知道你在寻找什么，以便谷歌可以检索到最相关的结果。
4.问正确的问题
能否提出正确的业务问题将完全决定您的数据分析是否成功。
大多数数据科学家都记得曾经遇到过这样的情况:他们被告知去解决一个特定的业务问题，但却没有问出正确的问题，这使得他们可能会创建出无法产生所需答案的分析。在你根深蒂固地认为问正确的问题是成功分析的成败因素之前，你只需要犯一次错误。
你想放在口袋里的一些关键问题包括:
- “你到底想搞清楚什么？”
- "你会使用什么样的标准 KPI 来帮助你？"
- “你的数据将来自哪里？”
- "你想应用什么样的统计分析技术？"
- “我的分析将如何被使用？”
能够提出正确的问题会增加你分析的价值。
如前所述，虽然一些自动化技术可能会接管您工作的分析部分，但能够提出正确的指导性问题永远不会过时。
5.编写干净的文档
编写好的、干净的文档，为未来的数据科学家提供正确有效地使用您编写的代码所需的信息，这种能力永远不会成为过时的技能。
好的代码文档是一个框架，在这个框架上可以在公司内部完成生成工作。旧代码总是会被传递给新的数据科学家，他们的任务是使用旧代码或者使之现代化。没有好的文档，时间会被浪费，话会说得难听，数据科学家会因为写不出有价值的文档而声名狼藉。
这里的主题是，虽然数据科学的某些方面可能会发生变化，例如编码语言和使用的技术，但有效描述代码功能的能力永远不会过时。
关键要点
- 无论数据科学学科经历多少变化，能够即时学习新技能是一项永远有用的技能。
- 理解基础数学概念将允许您在未来几年进行数据分析，并允许您理解当数据科学任务通过机器学习和人工智能实现自动化时产生的结果。
- 使用谷歌解决问题将永远是数据科学家的一项重要技能，他们需要找到解决问题的方法。
- 能够提出正确的问题将指导您的数据分析的发展，以便您第一次就能获得正确的结果。
- 编写干净的文档永远不会过时，并且将有助于为未来的数据科学家提供他们使用您多年来开发的代码所需的信息。
订阅将我的故事直接发送到您的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将收取少量佣金，无需额外费用):媒体会员
申请前你需要注意的 5 个数据科学初创公司的危险信号
原文：https://towardsdatascience.com/5-data-science-startup-red-flags-you-need-to-be-aware-of-before-applying-a06a039aa87d
创业不全是便装、办公室里的狗和提供午餐
扎卡里·凯米格在 Unsplash 上的照片
作为一名数据科学家，令人兴奋的一部分是有可能为各种公司工作，从那些已经建立良好的公司到那些刚刚起步的公司。
科技创业公司是申请职位的诱人地方，因为我们经常听说这份工作可以带来丰厚的奖金:免费餐、安静的房间、休闲服装、灵活的工作选择、办公室允许带狗等等。
然而，除了上述那种科技创业公司少之又少这一事实之外，在申请这类公司之前，你还需要注意几个危险信号。虽然可以说这些危险信号适用于所有公司，但它们往往是初创公司独有的特征，只有在你为一家公司工作过之后，你才会意识到这一点。
数据科学初创公司需要注意的 5 个危险信号
1.缺乏可信的货币化是由没有可靠的行业记录的人导致的
创业公司通常是由年轻、雄心勃勃的技术人员之间的啤酒餐巾协议发展而来，他们可能已经在该行业工作了一年，或者刚刚从大学毕业，希望为自己创造工作。
正因为如此，数据科学初创公司的第一个危险信号很容易被发现:在足够长的时间内缺乏可信的货币化，以使公司能够由在行业中有着良好业绩记录的人管理。
启动资金是创业公司启动业务所需的一切，随之而来的是要求创业公司在资金耗尽之前变得可验证。没有适当管理的启动资金，你就无法支付办公空间、许可证或专利、工资、营销预算、托管费等等。
然而，仅仅获得启动资金是不够的。你还需要一个有着良好记录的人，确保钱花得恰当，并且总是带着推动公司前进的意图。人们很容易在办公场所和工资上花费数十万美元，却不知道自己实际能从中获得什么。
这意味着，当你申请一家初创公司时，你需要采访你的面试官，以确定这家公司有多少钱，预计会持续多久，谁在运营，以及这些钱预计会怎么花。这是一种非常真实的恐惧，你可能被一家初创公司聘用，但几个月后，当他们由于管理不善或不合理的支出而耗尽资金时，你突然失去了工作。虽然为创业公司工作总是一场赌博，但你在合同期内的工作保障却不应该如此。
幸运的是，数据科学初创公司不应该有那么多开销。很多工作可以在家里完成，当团队想聚在一起时，可以租出会议室。除了工资和潜在的办公空间，唯一的其他成本可能包括软件、服务器和营销。旅行和活动中偶尔会出现成本，尽管这些成本可能会很低，这取决于初创公司瞄准的客户或合作伙伴的类型。
关键是确定每月预算的多少比例花在哪些成本上，以及考虑到公司向前发展的需要，你认为这是否合理。简而言之，当只有 1000 美元用于营销时，每月用于餐饮的几千美元可能是一个危险信号。当你看到每个项目分配了多少时，优先级就说话了。
2.没有明显的市场、方向或客户群
许多年轻的、雄心勃勃的个人将创建创业公司，这样他们就可以把自己标榜为“创始人”，并开始过过去 20 年来一直如此迷人的创业生活。不幸的是，新兴的创业公司在没有明确的市场、方向或客户群的情况下成立，这种情况并不罕见。
对于数据科学初创公司来说，在发展初创公司时，这应该是一个容易做出的决定:为特定领域的客户提供数据科学产品或服务。说起来容易，想出正确答案是另一回事。
初创公司很容易变得分心，或者发现他们曾经认为存在的市场不再存在。例如，一家数据科学初创公司开始时表示，他们的目标市场是需要仪表板解决方案来了解客户及其流程效率的小型企业，这可能会被为金融公司创建定制的全面数据解决方案的想法所动摇。或者，一家数据科学初创公司可能会进入市场，认为他们可以为小企业提供数据报告解决方案，但却发现大多数小企业被竞争对手垄断，或者乐于使用只需 100 美元即可购买的现成解决方案。
因此，在你做面试前的调查时，确定你是否接受公司的销售是至关重要的。这样，你就会知道你将要提供的产品或服务是否有真正的市场。那些声称自己专有的人工智能可以仅使用几个月的数据来解决公司业务问题的创业公司，可能更多的是烟雾和镜子，而不是实质性的结果。
从我的经验来看，专注于一个你知道你的创业公司可以支持的特定领域是至关重要的。一段时间后，你很容易对你听到的关于一个需要数据科学服务的新领域的最新消息感到失望、厌倦或分心。相反，更好的办法是坚持到底，专注于你擅长的领域，从一开始就瞄准一个诱人的利基市场，并建立你作为服务于这个利基市场的公司的声誉。这种专注不仅有助于保持创业的动力，也有助于让投资者满意(上面的第 1 点)，并有助于保持产品或服务的发展朝着正确的方向前进(下面的第 3 点)。
3.关键产品仍处于开发的初始阶段
如果是这种情况，你申请的创业公司可能是一艘正在下沉的船。
由于启动资金带来的严格预算限制，公司必须保持一定的实验、验证和迭代节奏，以保持盈利。即使这意味着创业公司必须在多年的投资和开发后停止生产产品，但总要有一个前进的迹象，而不是停留在一个不会以预期方式表现出来的想法上。
例如，福特和大众在得出“自动驾驶汽车的大规模盈利商业化远超预期”的结论后，刚刚终止了他们开发自动驾驶汽车的合作伙伴关系。虽然这对福特来说是 27 亿美元的损失，但他们意识到最好减少损失，尽管他们已经在这个项目上投资了两年多。
回到创业公司，一个好的数据科学创业公司的标志是在废纸篓中有一个想法的几次迭代，但总是努力让一个想法工作(而不是打死马)。数据科学产品的开发和成功生产并不困难。数据科学初创公司通常会专注于为公司提供仪表盘、报告、人工智能或其他类似的服务。除了为特定行业定制这些服务或产品之外，没有太多的细化空间，也没有特别难开发和提供的服务或产品。因此，很容易就能看出你走进的是一家好的创业公司还是一家有问题的创业公司。
根据经验，我知道无论你工作多努力，花费多少金钱和时间(例如福特和大众)，总是有必要减少损失。是的，这是一个损失，但这让你有机会尝试新的想法，而这些想法可能正是你一直在寻找的。
4.员工的缺乏
我曾经为一家成熟的科技公司工作，这家公司以创业模式运营——换句话说，我们用最少的员工做了最多的工作。这不经意地导致我做了其他七个人的工作，连续工作了 180 天，熬夜到半夜赶最后期限，直到最后一刻才得到我工作所需的反馈。
小型创业公司不一定是危险信号。只有当你注意到每个人都在做至少三个人的工作，却只拿一个人的工资时，这才是危险信号。虽然许多数据科学职能不一定需要一个大团队，但创业公司中的每个人都做了足够的工作来推动公司前进，但不要做得太多，以至于错过最后期限或因过度工作和疲劳而降低工作质量，这一点至关重要。例如，一家数据科学初创公司可能会发现，让几名软件工程师来处理生产方面的事情，可以帮助他们的数据科学家腾出时间来完成更多与数据相关的任务。
由于预算的限制，许多初创公司会试图保留少量员工来保持低成本。然而，他们所冒的风险是耗尽充满活力的员工，创造一个有毒的工作环境，而不是推动公司发挥其全部潜力。是的，刚开始的时候，工资可能会低一些，无法负担所有需要的员工，但随着初创企业的繁荣和自给自足，以后会有回报的。数据科学初创公司最好有一个由数据工程师、数据科学家、业务分析师、软件工程师和营销专家组成的完整团队，而不是由几个人来处理所有这些方面(这些人可能都不太擅长)。
在对话的早期提出人员配备的话题至关重要。了解团队成员的工作量和职责可以帮助您决定团队是人手不足还是保守。
5.“我们是一家人”
出于某种原因，把自己描述为“一个快乐大家庭”的创业公司成为了我们向往的工作场所。我认为这是一个阴谋，在现实中，初创公司在我们的脑海中植入了这样的想法，即我们希望为那些声称他们“更像一个家庭”的公司工作，我们接受了这一点，就像我们接受休闲装、免费午餐、办公室里的狗和团队联络之夜一样。
虽然大多数数据科学初创公司都是关系紧密的企业，员工人数少于大多数科技初创公司，但这并不意味着工作场所需要有“家庭”心态。是的，由于你和较少的人一起工作，你可能会更了解同事的个人生活，但这并不意味着你的职业和个人界限会变得模糊。
如果一家初创公司将其公司文化描述为“像一个家庭”，不要在提交申请时点击“提交”——直接逃之夭夭。
工作场所的家庭文化是一种有害的影响，它会产生一种夸大的忠诚感，这种忠诚感会变得有害，会创造一种员工可以被利用的权力动态，并导致个人和职业界限变得模糊。
说够了。
在数据科学初创公司中，你需要寻找的是一个团队，他们能够专业地合作，重视如何处理琐碎数据问题的新想法，并优先考虑健康的工作和生活平衡。没有这种"家庭"的废话。
最后的想法
根据你的喜好，你可能会觉得上面列出的危险信号是合理的，而不是不申请工作的理由。也就是说，如果你认为这些危险信号是可以处理的，那么理解你可能会遇到的情况通常需要经验。不管你的偏好、要求和信念如何，你都必须在进入所有工作机会的时候，睁大你的眼睛，注意你每天可能会遇到或必须处理的危险信号。许多数据科学家都选择辞职，因此，将你安置在尽可能好的位置对行业的延续和发展至关重要——尽管有危险信号。
订阅让我的故事直接发到你的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将免费向您收取少量佣金):媒体会员
通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠
未来 5 年的 5 大数据科学趋势
原文：https://towardsdatascience.com/5-data-science-trends-in-the-next-5-years-44984c63a772
根据我在不同行业和学科的观察，这是一个评估
前方的旅程。作者图片
这个领域很大，要深入涵盖未来 5 年可能发生的所有事情有点不可能。我预见但不会在这里讨论的重要趋势是数据科学在独特领域的具体应用、在技术堆栈中集成低代码/无代码工具，以及其他狭隘的见解。
这将是一个集中在一般的，广泛的主题变化，我看到在未来五年停留。这不是一个详尽的列表，但它确实涵盖了当前实践中面临的许多问题:
- 更好的命名约定
- 技术行业之外的可持续应用
- 以数据为中心的建模
- 决策科学专业知识
- 数据科学创造者经济
1.更好的命名约定
对于业内许多人来说，数据科学家的头衔一直是一个大问题，主要是因为这个角色需要什么以及公司需要什么的模糊性。虽然我认为工作描述已经变得更加清晰和简洁，但是工作简介才刚刚开始变得正常化。
这一转变非常重要，因为它代表了这门手艺正在走向成熟。最终，我看到这些工作类别被整理出来:
- 数据分析师/产品数据科学家/分析工程师
我认为数据分析师是行业中一个非凡的入门级角色，但正因为如此，它经常被认为是“简单”或“基础”的，而实际上它需要专业知识的深度。我看到高级分析师涉及更多的实验和 A/B 测试知识，可以与产品负责人和 Scrum 团队非常有效地合作。
我假设这个功能将是未来几年最热门的技术工作之一。随着像分析工程师这样的角色开始要求他们应得的尊重，这将是一个人们被赋予创造力、以设计为导向、快速学习和执行的功能，并且适用于任何领域。随着时间的推移，数据科学家的角色将被分割，这将自然而然地随之而来(参见下面的 MLE)。
2.研究科学家
这一个可能是第一个被充实和理解的。通常为博士举办，负责在我们的社会中推动人工智能的边界，主要处理深度学习和强化学习。
3.机器学习工程师
因为这是我工作的地方，所以我有很多想法。我相信今天的传统数据科学家和机器学习工程师将会结合成为机器学习工程师。它更精确地描述了工作职能是什么；大规模构建端到端的机器学习系统。今天，大多数 mle 似乎负责模型的后期制作，而数据科学家处理之前的领域。随着时间的推移，对于长期模型部署的责任移交，这可能会有问题，因此让一个团队进行端到端的监督要有效得多。
随着新工具的出现和 Python/Jupyter 集成到 Excel 的推广，在 Jupyter 中完成的 PoC 工作很可能是分析师(如果涉及建模的 PoC，可能是高级人员)主要做的工作。原因是这部分工艺在快节奏下越来越容易做到。最后一点很重要，因为我并不是说这部分技术很容易，或者分析师的工作很琐碎；这是一个应该被尊重的困难的深层领域。我认为分析师的卓越之处在于速度，如果他们能够以更快的速度在他们使用的工具上运行从指标、EDA、统计测试等范围内的分析，那么随着工具的发展，这自然会开始适合他们(参见 Cassie Kozyrkov 关于数据分析师卓越之处的精彩文章【此处)。
这可能会要求今天的数据科学家根据他们的技能和兴趣选择一个方向，他们更像是分析 DS 还是机器学习 DS？注意我怎么没说一个软件工程 DS。我在这里讨论的所有角色都需要编码。尽管有些人需要更高的编码能力，但是每个人都应该能够写出干净的、可重用的代码。对我来说，这就像告诉某人做科学，而不期望他们遵循科学方法或科学界制定的标准指南。
4.数据工程师
这也是另一个角色，它会一直存在，并且被很好的理解。数据工程师从公司的现有数据源(湖泊、仓库等)中收集数据集。)并且可以主要监督数据流如何进入建模和部署管道。
2.技术行业之外的可持续应用
到目前为止，我们已经看到 AI/ML/DS 主要在消费技术、广告和营销领域被广泛采用。有少数从事深度学习的公司在计算机视觉和 NLP 方面取得了实质性进展，但现实是，并不是所有人都在做深度学习应用。大多数场景都是结构化数据问题，深度学习不是最有效的解决方案。
虽然销售、营销和广告是巨大的行业，但对我来说，机器学习最令人兴奋的应用还在后头。我们可能会看到医疗保健、法律、制造、农业等领域广泛采用人工智能。传统上受到严格监管的行业或主要不是软件行业的行业将会看到一个戏剧性的转变，这样他们就可以大规模使用机器学习。可持续也是这些应用的重要组成部分。仅仅可视化以前甚至没有想到要收集的数据是不够的。我们很可能会看到 ML 解决方案与领域专家在实时或生产环境中并行工作，为那些已经花了一些时间进行技术发展的行业服务。
这是一个胜利，原因有很多，最值得注意的是，这些行业将看到以前不可能实现的更高的效率和创新的解决方案。此外，非技术人员将更容易成为技术人员。他们不需要成为一名机器学习从业者，而是可以成为一名医生，在他们的团队中雇佣一名 MLE 进行合作。每一个可以用数据改进的功能都会在末尾加上一个“+”，这意味着他们在他们所做的基础上拥有 ML 技能。For eg. Lawyer vs Lawyer+:指那些了解并深入研究过法律，现在使用机器学习来放大自己能力的人。
3.以数据为中心的建模
吴恩达很好地说明了这一点:模型是代码和数据的总和。到目前为止，我们一直在模型和超参数上不断迭代，同时保持数据不变。虽然这在学术界产生了巨大的收益和进步，但在行业中，我们将看到一个巨大的转变，即保持模型不变并迭代数据，也许还有超参数。这就是以数据为中心的建模的精髓。
如前所述，大多数问题是结构化数据问题，这意味着它们不处理图像、自由文本或音频。它们处理一些系统中的数据表，比如数据库或云。与此同时，我们也在很大程度上找到了表现最好的模型。随着时间的推移，肯定会有变化，但是将被放入生产环境中的是那些已经过测试、验证并在社区中得到广泛好评的产品。这不可避免地意味着，在大多数情况下，您不会花太多时间在行业建模上(这已经是事实)。
您的大部分时间都集中在获取正确的数据、创建更强大的数据集、智能地进行功能工程以捕获必要的业务影响，而这甚至没有考虑将该模型投入生产的所有项目。尽管建模和数学技能总是有价值的，并且是团队所需要的，但是你不需要一个拥有这些技能的完整团队。您可能有一两个具有深入建模专业知识的人，但是您主要将(并且确实)需要数据专家。这在很大程度上也是今天的情况，但它将增长到目前难以预测的高度。随着社会开始以我们今天不知道的方式记录、收集和存储数据，例如将实时传感器集成到织物、城市基础设施和我们的身体中，未来的数据技能肯定会变得非常专业和困难。
4.决策科学专业知识
令人难以置信的是，有多少人关注数学复杂性的深度，而不是花时间学习业务的来龙去脉以及人们如何做出决策。数据科学是使数据有用的实践，它将很快要求从业者专注于需要采取、改变或停止的实际决策，并以这些术语说话。
我相信，随着时间的推移，理解完整建模管道的人和深刻理解业务的人之间的差距将保持不变或变得更大。对于非技术人员来说，有太多的工具、技术和技能在不断变化。这将需要那些拥有技术技能的人获得强大的销售技能，以成为一个桥梁。
高估数学不会帮助你影响一个关键的决策。最高技能的数据科学家需要理解动机、促成因素、不同的个性以及如何影响当权者。这在今天的从业者社区中是普遍理解的，但是我预测我们将会看到它作为成功的关键教育被包括在所有的训练营和项目中。
5.数据科学创造者经济
作为一名艺术家，我认为有这么多数据科学家有创造艺术和自由职业者的韧劲是不可思议的。无论是写作，独特的激情项目，还是咨询他们的品牌名称，我听说很多数据科学家/MLEs 走的都是这条路线。我认为今天这个功能的自由职业路线可以有很多变化——有些会很好，大多数可能很难，有些会是一天中度过额外时间的有趣方式。
随着时间的推移，我认为这将是孩子们渴望进入的一条真正严肃的职业道路。我们目前正在目睹大学价值的清洗，这本身就值得一个故事，孩子们真的不知道所有债务的意义是什么，如果他们能在几年的专注(对于入门角色)在线学习他们想要和需要的确切技能。对许多人来说，成为一名自由职业的数据科学家可能是一个现实的选择(也是一个有趣的选择)，我预测他将有能力获得我们在当今行业中看到的高薪。
不过，这需要先搞清楚几件事，最重要的是数据隐私和监管问题。一旦公司有了如何与自由工作者打交道的标准，而不是需要整个团队一直配备人员，我认为这可能是初学者和具有高品牌价值的从业者涉足的有效途径。
这些部分中的每一个都可以进行显著扩展，以提供进一步的推理和清晰性，但在高层次上，我认为这些趋势是未来 5 年你可以指望的。如果有任何你想讨论的，想听的或不同意的，请告诉我！
5 个数据相似性指标
原文：https://towardsdatascience.com/5-data-similarity-metrics-f358a560855f
亚历山大·格雷在 Unsplash 上拍摄的照片
理解数据分析和机器学习中的相似性度量:综合指南
前言:本文给出了关于给定主题的信息摘要。它不应被视为原创研究。本文中包含的信息和代码可能受到我过去从各种在线文章、研究论文、书籍和开源代码中读到或看到的东西的影响。
介绍
相似性度量是许多数据分析和机器学习任务中的重要工具，允许我们比较和评估不同数据之间的相似性。有许多不同的度量标准，每种都有优缺点，适合不同的数据类型和任务。
本文将探讨一些最常见的相似性度量标准，并比较它们的优缺点。通过了解这些指标的特点和局限性，我们可以选择最适合我们具体需求的指标，并确保我们结果的准确性和相关性。
- 欧几里德距离
此指标计算 n 维空间中两点之间的直线距离。它通常用于连续的数值数据，易于理解和实现。然而，它可能对异常值敏感，并且不考虑不同特征的相对重要性。
from scipy.spatial import distance
# Calculate Euclidean distance between two points
point1 = [1, 2, 3]
point2 = [4, 5, 6]
# Use the euclidean function from scipy's distance module to calculate the Euclidean distance
euclidean_distance = distance.euclidean(point1, point2)
- 曼哈顿距离
该指标通过考虑两点在每个维度上坐标的绝对差异并求和来计算两点之间的距离。与欧氏距离相比，它对异常值不太敏感，但在某些情况下，它可能无法准确反映点之间的实际距离。
from scipy.spatial import distance
# Calculate Manhattan distance between two points
point1 = [1, 2, 3]
point2 = [4, 5, 6]
# Use the cityblock function from scipy's distance module to calculate the Manhattan distance
manhattan_distance = distance.cityblock(point1, point2)
# Print the result
print("Manhattan Distance between the given two points: " + \
str(manhattan_distance))
- 余弦相似度
该指标通过考虑两个向量的角度来计算它们之间的相似性。它通常用于文本数据，并且不受向量大小变化的影响。但是，它没有考虑不同特性的相对重要性。
from sklearn.metrics.pairwise import cosine_similarity
# Calculate cosine similarity between two vectors
vector1 = [1, 2, 3]
vector2 = [4, 5, 6]
# Use the cosine_similarity function from scikit-learn to calculate the similarity
cosine_sim = cosine_similarity([vector1], [vector2])[0][0]
# Print the result
print("Cosine Similarity between the given two vectors: " + \
str(cosine_sim))Jaccard Similarity
- 雅克卡相似性
此度量通过考虑两个集合的交集和并集的大小来计算它们之间的相似性。它通常用于分类数据，并且不受集合大小变化的影响。但是，它不考虑元素集的顺序或频率。
def jaccard_similarity(list1, list2):
"""
Calculates the Jaccard similarity between two lists.
Parameters:
list1 (list): The first list to compare.
list2 (list): The second list to compare.
Returns:
float: The Jaccard similarity between the two lists.
"""
# Convert the lists to sets for easier comparison
s1 = set(list1)
s2 = set(list2)
# Calculate the Jaccard similarity by taking the length of the intersection of the sets
# and dividing it by the length of the union of the sets
return float(len(s1.intersection(s2)) / len(s1.union(s2)))
# Calculate Jaccard similarity between two sets
set1 = [1, 2, 3]
set2 = [2, 3, 4]
jaccard_sim = jaccard_similarity(set1, set2)
# Print the result
print("Jaccard Similarity between the given two sets: " + \
str(jaccard_sim))
- 皮尔逊相关系数
此指标计算两个变量之间的线性相关性。它通常用于连续的数值数据，并考虑不同特征的相对重要性。然而，它可能无法准确反映非线性关系。
import numpy as np
# Calculate Pearson correlation coefficient between two variables
x = [1, 2, 3, 4]
y = [2, 3, 4, 5]
# Numpy corrcoef function to calculate the Pearson correlation coefficient and p-value
pearson_corr = np.corrcoef(x, y)[0][1]
# Print the result
print("Pearson Correlation between the given two variables: " + \
str(pearson_corr))
现在，我们已经回顾了这些距离度量的基础，让我们考虑一个实际的场景，并应用它们来比较结果。
方案
假设我们有 5 个带有数字属性的商品，我们想要比较这些商品之间的相似性，以便于应用，比如聚类、分类或者推荐。
以下代码使用各种距离度量计算给定产品及其属性的相似性度量，然后在热图中绘制结果以供评估。
import numpy as np
import seaborn as sns
import random
import matplotlib.pyplot as plt
import pprint
def calculate_similarities(products):
"""Calculate the similarity measures between all pairs of products.
Parameters
----------
products : list
A list of dictionaries containing the attributes of the products.
Returns
-------
euclidean_similarities : numpy array
An array containing the Euclidean distance between each pair of products.
manhattan_distances : numpy array
An array containing the Manhattan distance between each pair of products.
cosine_similarities : numpy array
An array containing the cosine similarity between each pair of products.
jaccard_similarities : numpy array
An array containing the Jaccard index between each pair of products.
pearson_similarities : numpy array
An array containing the Pearson correlation coefficient between each pair of products.
"""
# Initialize arrays to store the similarity measures
euclidean_similarities = np.zeros((len(products), len(products)))
manhattan_distances = np.zeros((len(products), len(products)))
cosine_similarities = np.zeros((len(products), len(products)))
jaccard_similarities = np.zeros((len(products), len(products)))
pearson_similarities = np.zeros((len(products), len(products)))
# Calculate all the similarity measures in a single loop
for i in range(len(products)):
for j in range(i+1, len(products)):
p1 = products[i]['attributes']
p2 = products[j]['attributes']
# Calculate Euclidean distance
euclidean_similarities[i][j] = distance.euclidean(p1, p2)
euclidean_similarities[j][i] = euclidean_similarities[i][j]
# Calculate Manhattan distance
manhattan_distances[i][j] = distance.cityblock(p1, p2)
manhattan_distances[j][i] = manhattan_distances[i][j]
# Calculate cosine similarity
cosine_similarities[i][j] = cosine_similarity([p1], [p2])[0][0]
cosine_similarities[j][i] = cosine_similarities[i][j]
# Calculate Jaccard index
jaccard_similarities[i][j] = jaccard_similarity(p1, p2)
jaccard_similarities[j][i] = jaccard_similarities[i][j]
# Calculate Pearson correlation coefficient
pearson_similarities[i][j] = np.corrcoef(p1, p2)[0][1]
pearson_similarities[j][i] = pearson_similarities[i][j]
return euclidean_similarities, manhattan_distances, cosine_similarities, jaccard_similarities, pearson_similarities
def plot_similarities(similarities_list, labels, titles):
"""Plot the given similarities as heatmaps in subplots.
Parameters
----------
similarities_list : list of numpy arrays
A list of arrays containing the similarities between the products.
labels : list
A list of strings containing the labels for the products.
titles : list
A list of strings containing the titles for each plot.
Returns
-------
None
This function does not return any values. It only plots the heatmaps.
"""
# Set up the plot
fig, ax = plt.subplots(nrows=1,
ncols=len(similarities_list), figsize=(6*len(similarities_list), 6/1.680))
for i, similarities in enumerate(similarities_list):
# Plot the heatmap
sns.heatmap(similarities, xticklabels=labels, yticklabels=labels, ax=ax[i])
ax[i].set_title(titles[i])
ax[i].set_xlabel("Product")
ax[i].set_ylabel("Product")
# Show the plot
plt.show()
# Define the products and their attributes
products = [
{'name': 'Product 1', 'attributes': random.sample(range(1, 11), 5)},
{'name': 'Product 2', 'attributes': random.sample(range(1, 11), 5)},
{'name': 'Product 3', 'attributes': random.sample(range(1, 11), 5)},
{'name': 'Product 4', 'attributes': random.sample(range(1, 11), 5)},
{'name': 'Product 5', 'attributes': random.sample(range(1, 11), 5)}
]
pprint.pprint(products)
euclidean_similarities, manhattan_distances, \
cosine_similarities, jaccard_similarities, \
pearson_similarities = calculate_similarities(products)
# Set the labels for the x-axis and y-axis
product_labels = [product['name'] for product in products]
# List of similarity measures and their titles
similarities_list = [euclidean_similarities, cosine_similarities, pearson_similarities,
jaccard_similarities, manhattan_distances]
titles = ["Euclidean Distance", "Cosine Similarity", "Pearson Correlation Coefficient",
"Jaccard Index", "Manhattan Distance"]
# Plot the heatmaps
plot_similarities(similarities_list, product_labels, titles)
正如我们从图表中看到的，每个相似性指标都会生成一个热图，以不同的尺度表示产品之间的不同相似性。虽然每个相似性度量都可以用于根据度量值解释两个产品是否相似，但是在比较不同距离度量的结果时，很难确定相似性的真实度量。
如何修正公制？
在选择相似性度量时，没有单一的“正确”答案，因为不同的度量更适合不同类型的数据和不同的分析目标。但是，有一些因素可以帮助缩小适用于给定情况的可能指标的范围。选择相似性度量标准时要考虑的一些事项包括:
- 数据类型:一些指标更适合连续数据，而另一些则更适合分类或二进制数据。
- 数据的特性:不同的度量对数据的不同方面敏感，比如属性之间的差异大小或者属性之间的角度。考虑数据的哪些特征对您的分析最重要，并选择对这些特征敏感的相似性度量。
- 您分析的目标:不同的指标可以突出显示数据中不同的模式或关系，因此，请考虑您试图从分析中了解什么，并选择一个非常适合此目的的距离指标。
就我个人而言，在选择相似性度量时，我经常使用下面的图表作为起点。
同样，在选择相似性度量时，仔细考虑数据类型和特征以及分析的具体目标也很重要。
本文中使用的所有代码都可以在 Jupyter 笔记本中找到。
感谢阅读。如果你有任何反馈，欢迎评论这篇文章，给我发消息 LinkedIn ，或者给我发邮件
如果你喜欢这篇文章，请阅读我的其他文章
你的组织现在需要停止的 5 种数据 Viz 实践
原文：https://towardsdatascience.com/5-data-viz-practices-your-org-needs-to-stop-now-6d8da8948a97
意见
可视化数据时不要做什么
亚历山大·卡迪科夫在 Unsplash 上的照片
数据可视化是数据专业最能接触到最广泛受众的领域。我和我的一些同行可能喜欢阅读关于数据领域最新和最伟大的论文，但大多数人不会碰那些东西，谁能责怪他们呢！
这就是数据可视化发挥其易于理解的数据洞察力的地方。但这就是问题所在:数据可视化必须让更广泛的受众容易理解。
这就是数据可视化发挥其易于理解的数据洞察力的地方。
虽然这些科学论文中充斥的技术术语可能不是每个人都能理解的，但是一个好的数据可视化几乎每个人都能理解！数据专业人员的工作是确保他们生成高质量的数据可视化。为了做到这一点，有一些数据即违规行为要像瘟疫一样避免。
有一些数据，即违规，以避免像瘟疫。
但是首先，关于数据伦理的一个说明
这些糟糕的数据实践不仅是糟糕的，因为它们使数据洞察的消费变得困难，而且数据伦理也必须被考虑。当我们可视化数据时，我们必须小心不要歪曲或曲解数据。大型商业决策——通常伴随着大笔资金的分配——是基于数据专业人员产生的数据洞察而做出的。这是一项重大责任，不应该掉以轻心。
大型商业决策——通常伴随着大笔资金的分配——是基于数据专业人员产生的数据洞察而做出的。
数据伦理考虑
道德在数据分析中非常重要。分析数据有什么意义？难道不是为了向您的组织甚至更广泛的社区传达结果和见解吗？这需要信任。信任您——数据专业人员，还有很多。
照片由 Cytonn 摄影在 Unsplash 上拍摄
你可能听说过这样一句话“分析只和数据一样好”。我想介绍一下我自己的一句更重要的话:“分析师的能力取决于他们被信任的程度。”好吧，也许不是最吸引人的台词。我可以努力。如果你能想到更吸引人的台词，请留下评论！
"分析师的能力取决于他们被信任的程度."
基本上，没有良好的数据伦理，数据分析是没有价值的。说到数据可视化的诚实，请给自己和你的公司一个高标准。
好吧，让我们进入我的顶级数据 Viz 违规！
数据即违规
请注意，这绝对不是一个详尽的数据清单即违规，不应该被视为一个！有很多很棒的资源可以指导您在可视化数据时不要做什么。许多资源甚至会提供一些心理学来解释为什么一些可视化实践在交流数据见解时没有效果。很酷，对吧？
请继续阅读，收集我多年来遇到的最讨厌的事情和糟糕的数据实践。
请留下您对您所看到的任何不良数据做法的评论！
> 1。从一个非零数字开始绘制图表 这可能比任何数据违规都要多。我一直在政客们提供的数据中看到这一点。就是见不得光。
我觉得这很有趣。Datawrapper 甚至不让我从非零值开始绘制柱形图，以显示一个糟糕的可视化示例。不错！
当你这样做的时候，你通常是想让结果看起来比实际更好。通过放大，你希望音量的起伏看起来像一个巨大的飞跃。
> 2。在饼图中包含太多类别 我经常看到这种情况。人们很难从饼状图中收集信息。不要把大量的类别放在一个饼图中。在一个饼图中使用不超过七个类别是最佳实践。
不要在你的饼图中包含这么多类别！
考虑使用一个“其他”类别来分组一些更小的类别。如果可能的话，尽量使用视觉效果而不是饼状图！
> 3。樱桃采摘时间表 销量比去年增长 200%！是的，但是如果你着眼于一个更长的时间框架，销售额在 5 年内可能只增长了 20%。
如果你去掉数据，改为在 2020 年 1 月开始可视化，这个图表看起来不是很不一样吗？
如果你想的话，中间的大幅下跌可以大大增加你的数字，但你不能这样做。你在操纵你的观众，让他们认为结果比实际要好。
此外，不要在图表上显示一个比周围时间段趋势明显不同的更小的时间段。背景在分析中非常重要。不要这样！
> 4。在一个视觉画面中包含太多的信息 不要在一个视觉画面中包含太多的信息，因为信息过载会让你的观众不知所措。记住，质量重于数量。
数据可视化中的信息过载让我想起了过于复杂的停车标志。照片由贡纳尔·本特松在 Unsplash 拍摄
你的观众应该能够很快理解你的视觉效果想要传达什么，最好是在最初的几秒钟。
> 5。做出糟糕的颜色选择 我在 LinkedIn 上发表了一篇关于数据违规的帖子，关于糟糕的颜色选择的最后一点是由一位数据分析师同事提出的！
颜色选择是数据可视化中的一个重要考虑因素。你应该尽量避免使用太多的颜色或者不搭配的颜色。如果你还没有这样做，你应该确保你选择的调色板是色盲友好的。
我不知道你怎么想，但这让我头晕。
虽然太多的颜色是一个问题，同时，不正确地使用单一的颜色渐变也是要避免的。单一颜色渐变很适合用于热图，但不适用于需要关键字的类别。"嗯……现在哪种蓝色与哪种类别相关联？"不行！
摘要
数据可视化是一种以易于使用的格式交流数据见解的好方法。也就是说，如果数据可视化做得好。
有许多糟糕的数据实践，但这些 5 数据即违规从其他数据中脱颖而出:从非零数字开始绘制图表，包括饼图中太多的类别，精选时间框架，包括视觉中太多的信息，以及做出糟糕的颜色选择。
请务必确保您在分析和展示数据见解时牢记数据伦理！一位非常聪明的人曾经说过“分析师的能力取决于他们被信任的程度。”
直到下一次…
喜欢这些内容吗？关注我在媒体上看到未来的职位！成为中等会员这样你就可以无限阅读文章了。相信我，值得！
如果你对数据专业人员的生活有任何疑问，请随时在 LinkedIn 或 T2 Twitter 上联系我！
https://medium.com/@ChristianWritesData/membership
5 dbt 数据模型帮助您节省宝贵的时间
原文：https://towardsdatascience.com/5-dbt-data-model-hacks-to-save-you-precious-time-b76f410db8c3
添加到您的项目中的最佳开源和付费工具
Artem Maltsev 在 Unsplash 上拍摄的照片
现在，我喜欢写数据模型，不要误解我。这是成为一名分析工程师最有趣的部分之一。然而，写它们有很多繁琐的部分。这不仅仅是您使用 SQL 编码的业务逻辑。您还需要在构建模型之前清理数据，记录数据，验证数据，然后实现数据质量检查。
对于一个数据模型，这可能看起来不多，但当您有大量不同的数据源并继续构建更多的数据模型时，它最终会占用您的大部分时间。特别是，如果您像大多数数据团队一样，等到一切都接近完美时才实施所有这些基本工作。
幸运的是， dbt 使得数据建模变得更加容易。而且，dbt 提供了许多有用的工具，它们可以直接与 dbt 集成，为您省去一些麻烦。如果您不熟悉 dbt (或数据构建工具)，它是一个数据转换工具，允许您编写模块化代码并遵循建模最佳实践。你可以在这里阅读更多关于它的。
这里有一些工具，既有开源的(也有免费的)，也有付费的，我发现它们为我节省了很多时间和精力。不是所有的东西都要由你从头开始建造！外面有一大堆聪明人可能已经帮你做到了。利用这一点。
re_data 数据清理宏
re_data 是我最喜欢的免费开源 dbt 包之一。它非常容易安装并集成到您已经存在的 dbt 项目中。虽然它们有许多令人惊叹的功能，如异常检测和警报，但它们也有预建的 dbt 宏来帮助您过滤和清理数据。
复制
它们有两个不同的过滤器来处理重复值， filter_remove_duplicates 和 filter_get_duplicates。你可以像使用任何其他 dbt 宏一样简单地使用它们，并从中进行选择。它们每个都有三个参数——模型名称、唯一列和记录排序所依据的列。 filter_remove_duplicates 返回一个没有副本的模型， filter_get_duplicates 只返回模型中的副本。
select
user_id,
name
from {{ re_data.filter_remove_duplicates(ref('users'), ['user_id']['created_at desc']) }} duplicates
这两种方法都可以节省您的时间，使您不必为了查找或删除重复项而对列进行聚合和分组。这也使得代码更加简洁。
格式化
re_data 还包含三个不同的数据格式化宏，可以用来清理数据-clean _ additional _ white spaces、 clean_blacklist 和clean _ capital _ words。
clean _ additional _ white spaces将您希望清理的列名作为参数，并删除任何空白。
select
user_id,
{{ re_data.clean_additional_whitespaces('name') }} as name
from {{ ref('users') }}
clean _ capital _ words还接受一个列名，并将字符串中每个单词的第一个字母大写。这是一个很好的选择，可以用在你的网站上显示的用户名甚至产品名上。
最后， clean_blacklist 用于屏蔽个人信息。如果您没有可用的屏蔽策略，这是对雪花的屏蔽策略的一个很好的替代。在这里，您指定希望屏蔽的列、要查找的单词列表或正则表达式，然后指定一个字符串来替换那些出现的内容。
dbt 期望
dbt expectations 是另一个优秀的开源 dbt 包，可以在您的 dbt 项目中使用。它包括根据您的期望测试数据输出的宏，因此得名。在 dbt 项目中已经存在的 dbt 测试的基础上，向您的数据模型添加测试本质上是更高级的测试。
这些宏通常测试特定的用例，当您遇到这些用例时，您可以尝试自己编写。与其花几个小时自己编写这些宏，不如浏览库来找到满足您需要的宏。这里有几个我最喜欢用的。
期望 _ 列 _ 值 _ 目标 _ 类型
该测试允许您检查列的数据类型。当您想确保所有时间戳列都是同一类型，日期实际上是日期，并且您想在计算中使用的任何列都是整数或浮点数时，这就很方便了。
我在诸如 Google sheets 这样容易出现大量人为错误的混乱数据源中最常使用这个测试。这样，我在源头得到通知，而不是我的模型在下游失败。下面是它在我的src.yml文件中的样子:
columns:
- name: campaign_launch_date
description: "The date the campaign was launched"
tests:
- dbt_expectations.expect_column_values_to_be_of_type:
column_type: date
expect _ column _ values _ to _ be _ between
对于 id 引用映射表的列，这个测试非常有用。通常，我们有太多的值，无法在 dbt 的accepted_values测试中包含它们。这是一个很好的捷径，可以防止你因为大量的测试而变得不知所措。
我经常在state_id专栏中使用这个测试。我不想写出数字 1-50，所以我指定一个范围，如下所示:
columns:
- name: state_id
description: "The unique identifier of a state"
tests:
- dbt_expectations.expect_column_values_to_be_between:
min_value: 1 # optional parameter
max_value: 50 # optional parameter
row_condition: "id is not null" # optional parameter
如果您想排除空值或任何其他类型的值，这个测试还可以选择行条件。
数据文件夹
Datafold 是一个强大的工具，可以在实际修改代码之前向您展示代码修改的结果。使用 Github，它运行您以前的代码以及您在 pull 请求中所做的更改，然后比较结果数据集。这允许您在合并代码更改之前看到数据将如何变化。
这对于在实际投入生产之前验证您的代码是否正确以及数据看起来是否符合预期非常有帮助。我们都知道当某样东西停产时会是多么可怕的一场噩梦。您需要返回并找到问题的根源，恢复到旧版本的代码，并重新部署它。当您可以首先使用 Datafold 这样的工具来帮助防止这种情况发生时，为什么还要担心这样做呢？
为了实现 Datafold，您需要三样东西:一个带有两个分支的 Github repo、一个您选择的数据仓库和一些 dbt 模型。这些都可以很容易地与工具集成，以便从中获益。你可以点击了解更多关于设置过程的细节。
作者图片
在这里，您还可以看到关键指标，如不匹配的列、不同的主键、空主键和总的差值。我们希望通过运行查询来手动检查的所有指标！
Datafold 节省了我们作为分析工程师的大量时间，因为它还告诉我们数据集中不匹配的确切行。
作者图片
它向我们显示了受代码更改影响的每个下游表的信息。如果整个表中的不同值是意料之中的，我们可以合并我们的代码而不用担心。不需要手动验证和一堆聚合查询。Datafold 以一种易于查看和深入研究的方式显示关键数据质量指标。
如果你正在寻找一个开源选项，他们也有一个免费的命令行工具和 python 库，名为 data-diff 。这将使用主键比较两个不同数据源中的数据行。它显示了哪些行出现在一个表中而没有出现在另一个表中，以及哪些行的值不匹配。尽管在数据复制发生之前，您无法做到这一点，但在某些用例中，它仍然是一个节省了我大量验证时间的工具。
小脚轮
Castor 是一个自动化的数据目录工具，它通过文档和协作为你的数据栈的所有部分带来透明度。它有助于告诉您组织中的用户某些数据源的位置、它们的质量状态，以及在您有问题时应该联系谁。它与您的 dbt 文档集成，将您已经记录的所有内容直接填充到工具中。
我最喜欢的特性之一是自动填充已经定义的数据列。我无法告诉你我花了多少时间将相同的列定义从一个src.yml文件复制并粘贴到另一个文件。Castor 获取这些定义，并为相同列名的每个实例填充它们，消除了重复的手工工作。是啊！你真的不必跨多个模型定义user_id 50 个不同的时间！
从 dbt 到元数据库的列沿袭(作者图片)
Castor 还为整个现代数据栈中的 dbt 数据模型提供了列级沿袭。这意味着您可以看到从您的数据仓库到您的仪表板的每一列的数据源。这允许您更好地处理数据模型之间的依赖关系，并看到小代码更改的潜在下游影响。我亲自修改了我的基本模型中的列名，以为它不会影响任何东西，结果第二天发现它破坏了整个生产模型。有了列级谱系图，您不必担心这是一个问题。
dbt 新鲜度测试
最后，dbt 有内置的测试，允许您检查源数据和数据模型的新鲜度。当数据集没有按预期更新时，刷新测试有助于提醒您。当在源位置完成时，这将有助于防止下游问题，例如陈旧的数据模型。积极主动地进行这些类型的数据质量检查将节省您调试和修复损坏管道的时间。
要向 dbt 项目添加一个新鲜度测试，只需在src.yml文件中的源代码或模型名称下添加一个freshness块。然后包括两个字段:warn_after和error_after。warn_after指的是一个源或模型在向你发出警告之前没有新数据的时间段。这个不会让测试失败。error_after指源或模型在失败前没有新数据的时间段。这个会让无法通过你的测试。
sources:
- name: users
freshness:
warn_after:
count: 3
period: day
error_after:
count: 5
period: day
请记住，您可以选择minute、hour或day作为您的时间段。就我个人而言，我的数据管道通常每天只运行一次，所以day时期对我来说最有意义。
结论
dbt 是一个强大的工具，可以无缝地进行数据转换。更好的是，它与其他强大的工具相集成，可以帮助您节省数据清理、验证代码更改、记录数据源和调试数据管道等任务的时间。总之，这套工具将帮助你成为一名高效而全面的分析工程师来编写高质量的代码。
欲了解更多关于分析工程和现代数据堆栈工具的信息，请订阅我的每周简讯。
看看我的第一本电子书，分析工程基础知识，一本全方位的分析工程入门指南。
要学习的 5 个 dbt 建模技巧
原文：https://towardsdatascience.com/5-dbt-modelling-tricks-to-learn-2d4928cc7433
充分利用 dbt(以及快速介绍)
由凯文·Ku在 Unsplash 上拍摄的照片
作为“现代数据堆栈”的一部分，dbt 是一个最近广受欢迎的工具。这是一个非常棒的工具，它支持直接在 SQL 中执行数据转换，使分析师和分析工程师能够专注于将业务逻辑转换为模型，而不是数据工程师倾向于关注的管道、编排和读/写细微差别。
它还支持 jinja 模板语言，正如我们将在下面看到的，当创建我们的数据模型时，它产生了一大堆额外的选项。在本文中，我们将重点关注 dbt 特性，这些特性可用于简化和增强我们的数据建模项目，创建可用于整个项目的有用且可重复的逻辑。
刚接触 dbt？
如果您正在阅读这篇文章，那么您可能已经使用过或者至少听说过某种形式的 dbt，但是如果您是使用 dbt 的新手，我建议您首先回顾并理解他们常见的最佳实践。这些并不是 dbt 建模的全部，但是遵循这些将有助于您的项目结构，并减少未来重构的需要。
我会特别考虑:
- 文件夹管理 —这定义了文件树和数据库中数据模型的最终结构。您想要“dim”和“fact”文件前缀吗？基于模式或产品领域的文件夹？
- SQL 和样式指南—为构成模型的 SQL 创建一个约定(大小写、跳转、连接等)。)，以及 dbt 模型(如何使用 cte 和子查询)。如果对自动化这些检查感兴趣，你可以看看使用类似于 sqlfluff 的东西。
- 模型引用 —为了使 dbt 能够完成它的工作，您应该使用
{{ ref() }}jinja 引用模型，以便 dbt 能够推断模型依赖关系并从上游表中正确构建。{{ source() }}jinja 应该只使用一次来从原始数据库中选择，并且永远不应该使用直接模型引用。 - 重用模型逻辑 —逻辑应尽可能向上游移动，以免重复(如列重命名)。如果您经常在多个数据模型中重用相同的逻辑，也许您可以将该逻辑本身转换成一个单独的数据模型，并将其移动到上游，这样就可以简单地用
{{ ref() }}引用它。 - 分析层 —一旦开发了 dbt 项目，您可能会因为“循环依赖”而遇到错误，其中两个模型相互依赖。我发现解决这个问题的最好方法是拥有多个模型层，其中每一层只引用其下一层中的模型。有一些关于你如何解决这个问题的文件。
现在谈谈您可能还没有遇到过的主要 dbt 技巧…
塞缪尔·里甘-阿桑特在 Unsplash 上拍摄的照片
1.快照
dbt 快照是实现类型 2 渐变维度的一种简单方法，使分析师能够更轻松地执行数据检查，例如数据值或分析指标何时以及为何发生变化。
这些更改是通过添加了dbt_valid_from和dbt_valid_to 列的行快照实现的，当前有效的行有dbt_valid_to=null。但是，这些列仅在每次运行快照时更新，因此，如果快照每小时运行一次，并且在此期间状态发生多次更改，则只有最新的值会被捕获为更改。因此，这并不能取代实际的数据监控解决方案，如审计数据库或向数据库中写入产品列，如status_value_at。
这里从product_sales表中创建了一个快照。与常用的updated_at策略不同，check策略(包含所有列)使快照能够自动包含新的表列。相反，如果从源表中删除了列，快照将保留这些列。
2.代理键
dbt-utils 包有一个有用的代理键宏,它实现了主键的生成。这对于为唯一主键创建 dbt 测试非常有用，对于在 Looker 等 BI 工具中使用该模型也非常有用，因为 Looker 需要专门定义主键才能正确执行聚合。
例如，如果我们为其创建快照的product_sales表没有id列，我们可以很容易地从两个分组列中创建这个主键。
select
{{ dbt_utils.surrogate_key(['product_id', 'month']) }} as product_sale_id
3.在枢轴上转动
再次回到 dbt-utils 包，这次是针对 pivot 宏。在 SQL 中，我们经常使用 CASE 语句来对总数进行分段，以便进行进一步的分析，例如在创建产品销售的群组视图来查看逐月业绩时。
select
product_id,
sum(case when month = 'jan' then amount else 0 end) as amount_jan,
sum(case when month = 'feb' then amount else 0 end) as amount_feb,
sum(case when month = 'mar' then amount else 0 end) as amount_mar
from product_sales
group by 1
order by product_id
但是随着我们希望透视的列数的增加，这种语法很快就会变得很麻烦。如果我们有 20 个月，我真的不想为每一列复制和粘贴相同的 SQL 逻辑，如果逻辑发生变化，那么我需要更新 20 行。
相反，我们可以使用 dbt pivot util 只用几行代码就可以做到这一点。缺点是这在 cte 上不起作用，只能在物化数据上起作用。因此，如果我们想要引用的模型不存在，我们需要创建它或使用另一个解决方案(如雪花的枢纽函数)。
这里选择了行(product_id ),然后dbt_utils.pivot函数接受要透视的列名的参数和要转换成列(month)的行值。这个宏是通过 CASE WHEN 语句 so 实现的，默认为then 1 else 0 end，但是这里我们设置了then_value，所以结果是then amount else 0 end。
4.试验
dbt 附带了四个通用测试，有助于涵盖您可能执行的一般数据完整性测试。这些是unique、not_null、accepted_values和relationship测试。通过项目 yaml 文件可以很容易地实现通用测试和文档，并且测试将在每次运行时与数据模型一起被检查。
这里有一个通用的主键检查，通常应该应用于每个数据模型。
version: 2models:
- name: product_sales
description: |
Area: Product
Table of product sales each month.
columns:
- name: product_sale_id
description: "Primary key"
tests:
- unique
- not_null
可能导致问题的是，如果 dbt 测试失败，将不会构建 dbt 模型。这可能意味着，如果不能设置测试的严格性，我们就不能在非主键列上添加健全性测试，比如accepted_values或not_null。
columns:
- name: month
description: "Month of sale."
tests:
- not_null
- accepted_values:
values: ['jan', 'feb', 'mar]
config:
severity: warn
5.宏指令
除了非常有用的 dbt-utils 包，我们还可以创建自己的宏。要使用它们，请确保将它们添加到 dbt 项目路径。这对于创建可以多次重用的代码片段非常有用，正如我们看到的 dbt-utils pivot 函数的实现一样。
这种用例的一个例子是获取表中所有未删除的行。可能是快照，原始数据是 Fivetran 同步的，有一个 deleted_at 列。最好用{{ active_table(table) }}来实现这一点，而不是在代码的多个地方添加 3 个不同的 WHERE 子句。
另一个例子是，尽管 min/max 返回忽略雪花中的空值的最小值/最大值，但是对于日期最大值 / 最小值，如果任何参数为空，则两者都返回空值。例如，如果我们想要获得许多日期中的第一个日期，以获得客户的第一个活动日期，这种行为可能会令人讨厌。为了减轻这种情况，我们必须用一个虚拟值合并每个参数…或者我们可以创建一个宏来完成这个任务。
类似的dbt_least值的虚拟值类似于'12/31/9999'，所以在我写这篇文章的时候，它至少还能工作 7977 年！
最后的想法
dbt 是用于构建数据模型的强大分析工程解决方案，使用户能够专注于创建健壮的业务逻辑，而不是担心加载和写入数据的细节。我们快速介绍了 dbt 和一些重要的初始项目注意事项，然后介绍了 dbt-utils 包中一些有用的特性和宏。这有助于改进一般语法，避免重复代码块，并减少最终数据模型中可能出现的错误。
如果你喜欢这篇文章，你可以找到更多的文章，并在我的个人资料上关注我！
保存机器学习模型的 5 种不同方法
原文：https://towardsdatascience.com/5-different-ways-to-save-your-machine-learning-model-b7996489d433
简化重用模型的过程
照片由弗雷迪·雅各布在 Unsplash 拍摄
保存经过训练的机器学习模型是机器学习工作流程中的一个重要步骤:它允许您在将来重用它们。例如，您很可能必须比较模型，以确定投入生产的冠军模型——在模型经过培训后保存模型会使这一过程更容易。
另一种方法是在每次需要使用模型时对其进行训练，这可能会极大地影响生产率，尤其是在模型需要长时间训练的情况下。
在本帖中，我们将介绍 5 种不同的方法来保存你训练过的模型。
头号泡菜
Pickle 是 Python 中最流行的序列化对象的方法之一；你可以用 Pickle 把你训练好的机器学习模型序列化，保存到一个文件里。稍后或在另一个脚本中，您可以反序列化该文件以访问定型模型并使用它进行预测。
下面是我创建的用于保存模型管道的实用函数，我还将在培训管道中演示它的功能:
让我们看看这在我们的培训管道脚本中是如何工作的:
您可以看到我们在第 50 行调用了save_pipeline实用函数。
为了加载管道，我创建了另一个名为load_pipeline的实用函数。
在我们的预测脚本中，我们将管道加载到一个名为_fraud_detection_pipe的变量中:我们现在可以使用这个变量作为我们训练的管道对象的实例来进行预测。让我们看看剧本的其余部分…
注 :第 14 行加载训练好的模型。
#2 工作库
Joblib 是 pickle 的替代工具，我们可以用它来保存[和加载]我们的模型。它是 SciPy 生态系统的一部分，在携带大型 NumPy 数组的对象上更有效——在这个 StackOverflow 讨论中了解更多关于 Joblib 的好处。
“Joblib 是一套工具，用于在 Python 中提供轻量级流水线操作。特别是:函数的透明磁盘缓存和惰性重求值(memoize 模式)简单易行的并行计算。”
— 来源 : Joblib 文档
为了用 Joblib 保存我们的模型，我们只需要对我们的save_pipeline()函数进行修改。
注意，我们有重要的joblib而不是pickle，在第 16 行，我们用joblib序列化了我们的模型管道。
注 :有兴趣的读者可以在我的GitHub上看到完整代码。
第三名 JSON
另一种保存模型的方法是使用 JSON。与 Joblib 和 Pickle 不同，JSON 方法不一定会直接保存拟合的模型，而是保存构建模型所需的所有参数——当需要完全控制保存和恢复过程时，这是一个好方法。
注 :有兴趣的读者不妨详细了解一下 继承 来了解我们是如何构建这个类的。
现在我们可以在我们的MyLogisticRegression实例上调用save_json()方法来保存参数。
我们可以在另一个脚本中调用它，如下所示:
您可以使用所有这些数据来重现之前构建的模型。
第四名 PMML
预测模型标记语言(PMML)是从业者用来保存他们的机器学习模型的另一种格式。它比 Pickle 健壮得多，因为 PMML 模型不依赖于创建它们的类——这与 Pickle 模型不同。
我们也可以如下加载模型:
第五名 Tensorflow Keras
Tensorflow Keras 可用于将 Tensorflow 模型保存到SavedModel或HDF5文件。
让我们建立一个简单的模型，并用 Tensorflow Keras 保存它—首先，我们将从生成一些训练数据开始。
现在让我们建立一个序列模型:
在上面代码的第 16 行，我们在顺序模型实例上使用了save()方法，并传递了一个路径到我们想要保存模型的目录。
为了加载模型，我们简单地在models对象上使用了load_model()方法。
包裹
在本文中，我们讨论了保存机器学习模型的 5 种不同方法。记录用于构建模型的 Python 版本以及所用库的版本也很重要-这些数据将简化重新创建模型构建环境的过程，以便日后可以重现它们。
感谢阅读。
联系我:
LinkedIn
Twitter
insta gram
如果你喜欢阅读这样的故事，并希望支持我的写作，可以考虑成为一名灵媒。每月支付 5 美元，你就可以无限制地阅读媒体上的故事。如果你使用我的注册链接，我会收到一小笔佣金。
已经是会员了？订阅在我发布时得到通知。
https://kurtispykes.medium.com/subscribe
清理脏数据的 5 个简单 SQL 技巧
原文：https://towardsdatascience.com/5-easy-sql-tricks-to-clean-dirty-data-dc423a0ab3e9
数据科学
立即掌握它— SQL 查询清理数据并为分析做好准备
照片由奥利弗·黑尔在 Unsplash 拍摄
"没有数据是干净的，但大多数是有用的."
—迪安·阿博特
真实世界的数据几乎总是杂乱无章的。作为数据科学家或分析师，你需要发现数据的真相。要做到这一点，数据必须整洁，没有错误。因此，第一步是清理数据。✅
因此，我总结了 5 个技巧，你可以用来清理 SQL 中杂乱的数据。
这是一个快速阅读，你可以用你的咖啡来完成它，并掌握一些清理脏数据的有趣技巧。🏆
使用这个索引，您可以轻松地导航到您最喜欢的部分。
**·** [**Find Missing Values in Your Data**](#8ad1) **·** [**Flag Certain Records**](#6314) **·** [**Clean Up Messy Values**](#22de) **·** [**Bucket Values into Segments or Bins**](#fc62) **·** [**Correct Data Types**](#74b8)
📍注意:我使用的是 SQLite 和一个自己创建的Dummy _ Sales _ Data使用Faker创建的，你可以在我的Githubrepo 下免费获得MIT license！！
好的，我们开始吧…🚀
查找数据中缺失的值
缺失值的问题在许多现实生活的数据集中相当普遍。缺失值可能会使数据分析或机器学习模型的结果产生偏差，或者降低模型的准确性，或者只是使数据分析变得困难。
使用这些现成的查询来找出数据中缺少的值，并检查是否有任何模式与数据相关联。
- 特定列中缺少数据
例如，找出Product_Category丢失的OrderIDs。
SELECT OrderID,
Sales_Manager,
Product_Category,
Shipping_Address
FROM Dummy_Sales_Data_v1
WHERE **Product_Category IS NULL**
按作者查找数据|图像中缺少的值
此外，当某些列有缺失值时，您可以发现数据集是否遵循任何趋势。
- 与缺失数据相关的模式
例如，在我们的例子中，当列Product_Category中的值丢失时，让我们尝试找出数据是否遵循任何特定的模式。
SELECT Shipping_Address,
OrderID,
Quantity,
Product_Category
FROM Dummy_Sales_Data_v1
WHERE **Product_Category IS NULL**
GROUP BY Shipping_Address, OrderID, Quantity
与 SQL | Image 中缺失数据相关的模式(按作者)
这样，您可以检查，当Product_Category丢失时，数据是否遵循特定的模式。您可以在WHERE子句中传递任意数量的列，并获得与那些缺失值相关联的模式。
此外，当列有特定值时，您总是可以发现数据中的模式，而不是丢失值，如下所示。
SELECT Shipping_Address,
OrderID,
Quantity
FROM Dummy_Sales_Data_v1
WHERE **Product_Category LIKE 'Healthcare'**
GROUP BY Shipping_Address, OrderID, Quantity
ORDER BY Quantity DESC
数据模式|作者图片
在本例中，您找到了与Healthcare产品相关的数量和送货地址模式，并清楚地看到了订单Quantity的前 5 个送货地址。
标记某些记录
另一个最佳实践是创建一个简单的二进制列来标记一些记录。这可以在执行数据分析的后期阶段使用。
例如，假设您希望将所有记录标记为Dirty_Data，如果数据集中缺少Delivery_Time。
SELECT OrderID,
Sales_Manager,
Shipping_Address,
Delivery_Time,
**CASE WHEN Delivery_Time IS NULL THEN 1
ELSE 0
END AS Dirty_data**
FROM Dummy_Sales_Data_v1
按作者标记 SQL | Image 中的缺失值
一个新列Dirty_Data被添加到输出中，其值为0和1。当这个输出作为 excel 或任何编辑器输出时，它肯定会使进一步的任务变得容易，例如找出Delivery_Time丢失的订单。
这样，您可以包含尽可能多的不同条件来定义脏数据并对其进行标记。
接下来，让我们看看如何清理比需求粒度更大的数据。
清理混乱的价值观
清理粒度值的最好方法之一是将其标准化。✅
通常，列值的粒度比所需的更细。在这种情况下，在更高的层次上对它们进行标准化更有意义。
例如，中的**shipping address**列包含国家名称，这些名称可以标准化为地区名称，如欧洲、北美等，如下面的查询所示。
SELECT OrderID,
Shipping_Address,
**CASE WHEN Shipping_Address IN ('Germany','UK') THEN 'Europe'
ELSE 'Other'
END AS region**
FROM Dummy_Sales_Data_v1
使用 CASE-WHEN | Image by Author 标准化值
因此，国家级别的发货地址信息是细粒度的，所以您在地区级别对其进行了标准化。
为了简单起见，我在CASE中只使用了一个WHEN语句，然而，我们可以通过使用多个WHEN语句随时在region列中创建更多的值。
更进一步，让查询稍微复杂一点，您可以跨多个记录分析数据。
将值存储到段或箱中
这是 SQL 中**CASE**语句的经典用例。CASE语句是 SQL 处理 if-then 逻辑的方式。
你可以从我的最新文章——2022 年你应该知道的 5 个高级 SQL 概念 中更深入地洞察CASE的说法。
</5-advanced-sql-concepts-you-should-know-in-2022-b50efe6c99>
让我们看看，如何使用它将值存储到存储箱中。
假设您想根据值将Shipping_Cost分为低、中和高。
*SELECT OrderID,
Shipping_Cost,
**CASE WHEN Shipping_Cost < 25 THEN 'Low'
WHEN Shipping_Cost BETWEEN 25 AND 32 THEN 'Medium'
WHEN Shipping_Cost > 32 THEN 'High'
END AS cost_range**
FROM Dummy_Sales_Data_v1*
将值存储到垃圾箱中 SQL |按作者分类的图像
结果，一个新的列cost_range被创建，根据列shipping_cost包含值低、中、高。
嗯，这些箱子是用来分类运输成本的。但是，如果您想按照cost_range按升序(从低到高)或降序(从高到低)对记录进行排序，这些箱子不起作用。见下文，
*SELECT OrderID,
Shipping_Cost,
CASE WHEN Shipping_Cost < 25 THEN 'Low'
WHEN Shipping_Cost BETWEEN 25 AND 32 THEN 'Medium'
WHEN Shipping_Cost > 32 THEN 'High'
END AS cost_range
FROM Dummy_Sales_Data_v1
**ORDER BY cost_range DESC***
SQL | Image 中按作者降序排序的框
记录按cost_range降序排列，介质在最上面，这是不正确的。❌
正确的输出应该是顶部有高电平的行，后面是中电平和低电平的行。为了得到正确的结果，你需要聪明地命名你的箱子。✅
最简单的方法之一是，使用如下所示的数字。
*SELECT OrderID,
Shipping_Cost,
CASE WHEN Shipping_Cost < 25 THEN **'1\. Low'**
WHEN Shipping_Cost BETWEEN 25 AND 32 THEN **'2\. Medium'**
WHEN Shipping_Cost > 32 THEN **'3\. High'**
END AS cost_range
FROM Dummy_Sales_Data_v1
ORDER BY cost_range DESC*
SQL | Image 中按作者降序排列的记录
现在，你答对了。这里，请注意使用 3，2，1 对值进行重新排序。🎯
接下来，不正确的列数据类型可能会成为数据提取和分析的一个重大障碍。让我们看看如何在 SQL 中处理它。
正确的数据类型
在现实世界中，有时，列的数据类型没有准确地分配，或者最初分配的数据类型不再适用于您的任务。
例如，日期-时间列通常存储为文本列，或者具有浮点值的列被赋予数据类型 integer。
如果数据类型不正确，只提取数据类型可能不会有任何问题，但是，如果您希望连接两个表，并且两个表中公共列的数据类型不同，查询将返回错误。
❓那有什么解决办法..
CAST 函数！！！
在 SQL 中，**CAST**函数用于显式地将给定的数据类型转换为 SQL 数据库中的不同数据类型。它有最简单的语法，
*CAST(column_name AS new_data_type)*
其中column_name是要更改其数据类型的列的名称。
关于CAST的一个有趣的事实是，它可以跨不同的数据库管理系统移植，比如微软 SQL Server、MySQL、Oracle，并且在每一个系统上都可以工作。💯
让我们快速浏览一个例子。
假设，您想要将Shipment_Cost转换为 float 值，该值最初存储为整数。
*SELECT Shipping_Cost,
**CAST(Shipping_Cost AS REAL)** AS Shipping_Cost_float
FROM Dummy_Sales_Data_v1*
要浮动的整数|按作者排序的图像
很简单！
但是，它也有一些局限性。您不能简单地将列从一种数据类型转换为另一种数据类型。🚩
例如，日期列不能转换为浮点型。两种数据类型——现有的和新的——本质上应该是相似的。
微软提供了一个有趣的图表，可以作为快速参考，了解哪些数据类型是相互兼容的，你可以从这里下载。
微软 SQL Server 数据类型转换图
*https://www.microsoft.com/en-us/download/details.aspx?id=35834
仅此而已！🏆*
希望你很快看完这篇文章，觉得耳目一新，很有用。
我使用 SQL 已经 3 年了，通过实践我发现了这些技巧。你可以随时让我知道，你还做了什么来清理数据。这些概念在实际项目中非常有用。
对阅读介质上的无限故事感兴趣？？
💡考虑 成为媒体会员访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡请务必 注册我的电子邮件列表 以免错过另一篇关于数据科学指南、技巧和提示、SQL 和 Python 的文章。
感谢您的阅读！
5 个易于实施的小技巧来缩小你的 Docker 图片尺寸
原文：https://towardsdatascience.com/5-easy-to-implement-tricks-to-trim-down-your-docker-image-size-263978a6ed29
最小化你的码头工人形象(外加一个加分)
这是一个非常小的建筑！(图片由 unsplash 上的 edgeeffectmedia 提供)
在这篇短文中，我们将介绍如何缩小 docker 图片尺寸的 5 个技巧(和一个好处)。通过这样做，我们更多地了解了 Docker 如何构建映像以及如何使用基本映像。我们来编码吧！
在我们开始之前:我们使用了很多终端命令。不熟悉的话可以看看 这篇文章 。
1.捆绑层
Docker 图像的大小是其图层的总和。因为每一层都有一点点开销，所以我们可以通过减少层数来做一点点但非常容易的改进。
只是改变:
FROM python:3.9-slim
RUN apt-get update -y
RUN apt-get install some_package
RUN apt-get install some_other_package
收件人:
FROM python:3.9-slim
RUN apt-get update -y && apt install -y \
package_one \
package_two
我已经用一些用于构建的包对此进行了测试，并在下面列出了它们。正如你所看到的，我们通过捆绑层节省了大约 10MB。虽然这不是一个巨大的尺寸减少，但它非常令人印象深刻，因为它是这样一个小的努力。
捆绑这些层在下面的包列表中节省了大约 10MB(图片由作者提供)
# packages:
git, cmake, build-essential, jq, liblua5.2-dev, libboost-all-dev, libprotobuf-dev, libtbb-dev, libstxxl-dev, libbz2-d
2.避免安装不必要的软件包
如果你用 apt-get 安装软件包，添加--no-install-recommends标签。这避免了在您正在安装的软件包旁边安装推荐但不需要的软件包。看起来是这样的:
FROM python:3.9-slim
RUN apt-get update -y && apt install -y --no-install-recommends \
package_one \
package_two
通过添加这个标志，我们节省了大约 40MB。同样，这在整个计划中并不算多，但却非常重要，因为我们仅仅添加了一个标志。
通过添加一个简单的标志又减少了 40MB。让我们继续修剪这张图片(图片作者)
清理也会减少我们的图像尺寸(图片由jeshoots.com在 unsplash 上提供)
3.安装后清理
安装包也有一些开销。我们可以通过将rm -rf /var/lib/apt/lists*/** 添加到来清理这个问题，就像这样:
FROM python:3.9-slim
RUN apt-get update -y && apt install -y --no-install-recommends \
package_one \
package_two \
&& rm -rf /var/lib/apt/lists*/**
用简单的一行代码又救了一个 40MB ！
4.小一点的图像怎么样？
这一点非常明显；用小一点的图像就好！正如您可能已经注意到的，在之前的代码片段中，我们已经使用了python:3.9-slim，这导致图像总大小几乎为 1GB ，增加了所有之前的优化。与python:3.9相比，这已经是一个很好的改进了(这将导致总大小为 1.3GB )。
一个改进是使用python:3.9-alpine。Alpine 集装箱是专门为在集装箱中运行而建造的，非常小，重量约为 49MB。这比我们使用python:3.9时要小 20 倍以上。那么为什么不一直用阿尔卑斯呢？有一些缺点:
- 兼容性问题:一些 Python 轮子是为 Debian 构建的，需要重新构建以兼容 Alpine。由于很难调试的兼容性问题，这可能会导致一些非常奇怪的错误。
- 依赖关系 : Alpine 用
apk add代替apt-get install安装依赖关系。此外，并非所有的封装都可用，或者与 alpine 兼容。
如果磁盘空间是一个主要问题，我只建议使用 alpine。还可以查看下一部分，了解如何通过将 alpine 与构建阶段相结合来减轻其缺点。
5.使用. dockerignore
如果您创建了一个新的 Docker 映像，那么 Docker 需要访问您想要从中创建映像的文件。这些文件被称为构建上下文。每次构建图像时都会发送它们，因此最好尽量保持较小的规模。
此外，添加一个 dockerignore 是一个非常好的想法，以防止机密的暴露。如果您使用ADD或COPY将文件复制到您的映像中，您可能会无意中复制到您不想烘焙到映像中的文件或文件夹(如.git)。
奖励:多阶段构建
有时候你需要像curl、git或make这样的工具来建立你的形象。完成后，你就不再需要这些包了。他们现在所做的只是让我们的形象更大。解决这个问题的一个好方法是使用多阶段构建。下面我们将看一个简单的例子，它使用curl作为我们构建映像所需的包之一，但是一旦我们的映像构建完成，它就变得多余了:
- 拍一个像
ubuntu的图像 - 安装卷曲
- 将数据文件卷曲成图像(例如分类器)
- 现在我们再拍一张像
python:3.9-slim一样的照片 - 将卷曲的文件从
ubuntu复制到python:3.9-slim阶段 - 其余的(例如，用 pip 安装包等。)
当这样做的时候，我们在我们的最终图像中有了我们的分类器文件，而没有我们的图像被卷曲弄得臃肿。另一个优势是，我们可以使用更丰富的映像来执行我们的安装(例如python:3.9，然后将所有生成的文件复制到一个非常小的映像中(例如python:3.9-alpine)。
这个解决方案的想法很简单，但是执行起来有点棘手。查看这篇文章 获得一个不错的演练。
结论
在这篇文章中，我们讨论了 5 个快速简单的方法来缩小你的 Docker 图片尺寸。一路上，我们对 Docker 构建图像的方式有了更多的了解。这篇文章主要集中在清理上，但是减少图像尺寸的最好方法是把构建层一起留下。这样我们甚至可以使用更小的图像，因为我们已经完成了所有复杂的任务。查看本文 了解更多关于这些所谓的多阶段构建的信息。
我希望这篇文章是清楚的，但如果你有建议/澄清，请评论，以便我可以做出改进。与此同时，请查看我的关于各种编程相关主题的其他文章:
- 适合绝对初学者的 Docker
- 面向绝对初学者的 Docker 作曲
- 将你的代码变成一个真正的程序:使用 Docker 打包、运行和分发脚本
- Python 为什么慢，如何加速
- Python 中的高级多任务处理:应用线程池和进程池并进行基准测试
- 编写自己的 C 扩展来加速 Python x100
- 【Cython 入门:如何用 Python 执行>每秒 17 亿次计算
- 用 FastAPI 用 5 行代码创建一个快速自动归档、可维护且易于使用的 Python API
编码快乐！
—迈克
页（page 的缩写）学生:比如我正在做的事情？跟我来！
https://mikehuls.medium.com/membership
提高机器学习模型准确性的 5 种有效方法
原文：https://towardsdatascience.com/5-effective-ways-to-improve-the-accuracy-of-your-machine-learning-models-f1ea1f2b5d65
如何将您的模型从 70%的准确率提高到 90%以上
照片来自 Pexels，作者黑脸田鸡·岛崎
创建机器学习模型是一个复杂的过程，即使是最有经验的数据科学家也经常出错。
如果你希望你的机器学习模型尽可能准确，你需要知道你可以改进它们的方法。
在这篇文章中，我们将讨论五种提高机器学习模型准确性的方法！
1.处理缺失值和异常值
提高机器学习模型准确性的最简单方法之一是处理缺失值和异常值。
如果您有缺失值或包含异常值的数据，您的模型可能会不太准确。这是因为缺失值和异常值会导致模型对你的数据做出不正确的假设。
例如，假设您有一个数据集，其中包含年龄大致相同的人(即成年人)的身高和体重测量值。如果其中一个人的体重测量值缺失，而另一个人的体重值异常高或低，那么您的模型将根据这两个人的身高做出错误的假设。
同样需要注意的是，缺失值和异常值会导致您的模型过拟合或欠拟合！
有许多方法可以处理缺失值和异常值。
您可以:
- 从训练数据集中移除包含缺失值或异常值的数据点。
- 使用 k-最近邻或线性回归等技术估算缺失值。
- 使用类似 bootstrapping 的技术来消除异常数据的影响
2.特征工程
特征工程是从现有特征中创造新特征的艺术。
例如，您可以创建一个要素，根据另外两个要素“家庭住址”和“工作场所位置”来表示某人住在离工作场所多远的地方。
特征工程通过允许机器学习模型做出更准确的预测来帮助提高机器学习模型的准确性。
创建新要素的最常见方法之一是将多个现有要素组合成一个或多个新要素。
例如，您可以将“年龄”与“体重”和“身高”结合起来，创建一个名为身体质量指数(身体质量指数)的特征。这使得您的模型能够做出更好的预测，因为模型中的要素和噪声更少。
设计要素有许多不同的方法，最佳方法通常取决于您正在使用的数据集。
但是，一些有用的提示包括:
- 尝试找出不同特征之间的相关性，并创建新的特征来捕捉这些关系。
- 使用对数变换或标准化等变换使您的要素更具可比性且更易于使用。
- 利用数据预处理技术(如要素提取和选择)来帮助您在数据集中找到最重要的要素。
3.特征选择
要素选择是一个帮助您识别数据集中最有用的要素的过程。
它的目标是通过删除机器学习模型中的冗余信息(即只包含一个特征的数据点)，来减少或消除噪声，提高机器学习模型的准确性。
有许多不同的方法来选择要素，但它们都涉及使用某种形式的统计分析或过滤掉重要性分数低的要素(即那些对模型的准确性没有太大贡献的要素)。
一些常见的特征选择技术包括:
- 根据要素与数据集中其他变量的相关性对要素进行分级，然后移除相关性较低的要素。例如，您可以使用皮尔逊相关系数来衡量两个变量之间的关系强度。
- 基于要素的重要性分数过滤要素，重要性分数通常使用梯度下降或随机森林等技术来计算。
- 选择与目标变量高度相关但彼此之间相关性低的特征子集(即，它们不相关或彼此独立)。
4.尝试多种算法
一个常见的错误是在训练模型时只尝试一种算法。虽然如果您有大量数据并且算法很容易从中学习，这可能行得通，但大多数真实世界的数据集要复杂得多。
数据集中可能会有一些对模型的准确性没有太大贡献的要素，移除它们只会使情况变得更糟。
这就是使用多种算法会有所帮助的地方。
通过尝试不同的算法，您可以确定哪些算法最适合您的数据，然后使用该信息来提高模型的准确性。
有许多不同类型的机器学习算法，因此很难知道哪些算法适合您的数据。一个很好的起点是对同一数据集使用多种算法的交叉验证，然后相互比较它们的准确度分数。
如果你正在使用 Python， scikit-learn 有一个很好的常用机器学习模型列表，你可以在你的数据上试用，包括:
- 线性回归
- 支持向量机
- 决策树
- 随机森林
- 神经网络
集合模型
另一种方法是使用集成方法，将两种或多种算法结合到一个模型中。集成算法通常比任何单个算法都更准确，因为它们利用了各自的优势，弥补了各自的不足。
换句话说，如果你将多个弱学习器(即，单独表现较差的模型)组合成一个集成，你可以得到一个更强的学习器(即，作为个体表现良好的模型)。
5.调整超参数
超参数是机器学习模型中决定它们如何工作的参数。
这些参数可以包括深度神经网络中的层数，或者集合模型中应该有多少棵树。
您通常需要自己调整这些超参数，因为它们不会在您训练模型时自动设置。
这就是交叉验证有用的地方。通过将数据分为训练集和测试集，您可以在训练集上尝试超参数的不同组合，然后查看它们在测试集上的表现。这有助于您找到模型的最佳超参数组合。
另一种方法是使用网格搜索，这是一种为您的数据寻找最佳超参数组合的方法。
网格搜索的工作方式是依次尝试每一种可能的参数组合，直到找到一种能为您的度量提供最佳性能(例如，准确性)的组合。然后，您可以使用超参数的组合来训练您的模型。
您可以通过 Python 中的 scikit-learn 库使用网格搜索。
结论
有很多方法可以提高你的机器学习模型的准确性。通过使用像特征工程、调整超参数和尝试多种算法这样的方法，你给自己一个很大的改变来创建一个真正精确的模型。
最重要的是不断尝试，从错误中学习。对数据和使用的算法了解得越多，模型的性能就越好。
与 5k 以上的人一起加入我的电子邮件列表，免费获得“完整的 Python 数据科学小抄手册”
异常检测系统的 5 个基本品质
原文：https://towardsdatascience.com/5-essential-qualities-of-anomaly-detection-systems-fcd1ec5ee9d5
确保您的业务具有前瞻性和抗风险性。
威尔·梅尔斯在 Unsplash 上拍照
介绍
本文涵盖了作为数据从业者应该了解的异常检测系统的五个基本特性。
异常检测是数据科学的一个关键应用，在保护企业和主动应对威胁方面具有卓越的价值。它还可以通过状态监控帮助检测复杂机器(如风力涡轮机)的故障开始。
异常检测解决方案的范围从基于领域知识设置简单的统计阈值到为实时案例构建复杂的机器学习系统。例如，当数据呈正态分布时，偏离平均值 2 到 3 个标准偏差的数据点可以作为异常提取出来，以供进一步研究。
当然，在构建异常检测系统的不同方法中存在权衡，并且不是所有的方法都提供相同的解决方案质量。
异常检测系统的 5 个基本品质
异常检测系统的基本素质(图片由作者提供)
现在，让我们讨论一个优秀的异常检测系统的五个主要属性。
- 响应能力
当构建异常检测解决方案用于关键领域(如电力和运输系统)的威胁检测时，它们必须能够快速采取行动以防止严重损害。
在许多现实世界的应用中，异常检测结果在损害发生之前是最有用的。
许多关于异常检测模型的实现和教程都是基于静态或历史数据，没有考虑响应的复杂性。然而，在现实世界的应用中，它可能会决定或影响项目的成功。
例如，异常检测系统的快速响应将使企业对平台故障的响应时间最短，从而全面提高客户满意度。
有用提示:并行化建模任务有助于在实时应用中加快系统的响应速度，尤其是在需要在线机器学习的情况下。此外，离线学习还可以帮助减少推理过程中的计算时间。
2。精度
短时间内过多的错误警报只会让利益相关者忽略您系统的警报，这使得该解决方案对任何实际应用都毫无用处。
愚弄我一次，你负责，但是如果你愚弄我两次，我负责。
因此，异常检测系统需要具有很高的精度，同时具有令人满意的灵敏度。
异常通常是罕见的，模型可能会在训练过程中对此进行过度补偿。例如，当模型对异常过于敏感时，可能会产生错误警报。因此，将正常的操作数据分类为过程中的异常。
有用提示:在分类任务中，这个问题可以在训练期间通过选择解决精确度问题的适当度量来解决，例如 F1 分数和受试者操作特征(ROC)曲线下的面积。对于回归任务，可以通过提高检测阈值来提高精确度，从而仅向利益相关者警告最严重的异常。
3。可扩展性
每个企业的目标都是成长。因此，像异常检测这样的集成系统必须是可伸缩的，以满足业务目标。此外，如果在设计阶段没有考虑到这一点，系统的响应能力可能会受到大规模影响。在大规模部署时，计算成本也可能显著上升，使得该解决方案不切实际。
例如，较简单且不太准确的解决方案可能优于较复杂且不太准确的解决方案，后者的可扩展性较差，无法处理更多数据。
有用提示:在可能的情况下，计算开销可以通过代码重新格式化和并行化来解决。此外，复杂的技术可以用计算效率更高但同样精确的方法来代替。
4。鲁棒性
一个健壮的异常检测系统必须能够处理数据质量问题，例如缺失值，特别是在实时应用中。该系统还应该能够处理可能在训练期间使模型产生偏差的坏例子。
例如，一些特性在推理时可能不可用。一个健壮的异常检测系统需要能够处理这样的情况。
有用的提示:健壮性问题可以在数据管道中解决，以正确捕获不同的数据质量问题。此外，可以使用一些对缺失值和异常值具有鲁棒性的算法(例如随机森林)。
5。可解释性
为了让利益相关者主动采取行动，异常检测结果需要是可解释的。这是构建更具弹性的业务流程的关键。此外，可解释的结果有助于工程师进行根本原因分析。
一个常见的机器学习困境可能会出现，其中更复杂和更准确的模型更难解释，而更简单和更不准确的模型给出了更好的解释结果。
例如，当使用诸如主成分分析(PCA)之类的技术来降低数据维度时，在特征工程期间可能会失去可解释性。
有用提示:可以开发复杂和简单的 ML 解决方案，其中前者用于准确检测异常，后者用于提供必要的解释。替换降低结果可解释性的方法也可能是有帮助的。
结论
在本文中，我们讨论了异常检测系统的基本特性:响应性、精确性、可伸缩性、健壮性和可解释性。在设计阶段必须考虑这些属性，以便从您的数据科学项目中获得最佳价值。
我希望你喜欢这篇文章，直到下次。干杯！
参考
- 在 Pinterest 建立时间序列实时异常检测系统
2.机器学习的敏感性和特异性
你可以通过下面我的推荐链接订阅 Medium 来获得更多我和其他作者的启发性文章，这也支持我的写作。谢谢大家！
https://aolaoye.medium.com/membership
成为成功数据科学家的 5 项必备软技能
原文：https://towardsdatascience.com/5-essential-soft-skills-to-succeed-as-a-data-scientist-1fffbcb74717
通过培养软技能来提高你的价值
杰森·古德曼在 Unsplash 上的照片
数据科学是一个快速增长的领域，根据美国劳工统计局的数据，未来十年对数据科学家的需求预计将增长 36%。然而，这个领域的竞争可能非常激烈，从初级数据科学家到晋升到大公司的高级职位需要经历许多步骤。
尽管在数据科学领域拥有良好的技术技能非常重要，但培养软技能同样重要，甚至更重要。发展这些技能将有助于你脱颖而出，如果你决定改变职业道路或晋升到更高级的职位，也会对你未来的角色有所帮助。
在本文中，我们将介绍成为一名成功的数据科学家应该具备的 5 项基本技能。
通讯技能
Teemu Paananen 在 Unsplash 上拍照
口头或书面交流对数据科学家来说至关重要。这不仅对你的工作质量很重要，对你如何与你的团队、客户和高管互动也很重要。
培养良好的沟通技巧将有助于你清晰地分享复杂的想法——即使这意味着简化事情，让每个人都能容易地理解。这将使你更容易解释你的发现，这一点尤其重要，如果你的客户可能与你有不同的需求，或者从未见过类似的工作！
此外，如果你的角色包括培训团队中的初级成员，你可能需要将复杂的想法和主题简化成他们容易理解的内容。
当进行口头演示时，我们有时可以使用演示幻灯片作为辅助。这可能会影响整体信息和传递。与其 100%依赖幻灯片，不如用幻灯片展示额外的信息，突出重点，增强观众的理解。
当我开始从事岩石物理学时，这涉及到处理大量数据和向客户提供储层研究，我的演示技巧非常糟糕。我经常会提供比要求更多的信息。几年后，我有了很大的进步，做了多次演讲，包括在会议上。
如果你想改进你的演示幻灯片，我推荐你看下面的视频:
领域知识
Andrea Piacquadio 的照片:https://www . pexels . com/photo/engineer-working-with-laptop-at-table-3769135/
许多不熟悉机器学习和数据科学的人认为，你把数据输入算法，点击一个按钮，就像变魔术一样，得出正确的答案。然而，现实往往大相径庭。
了解您工作的领域有助于您理解问题及其与业务目标的相关性。没有这一点，就很难确定解决问题的正确方法，也很难确定算法产生的结果是否有意义。
在岩石物理学或测井领域，我们使用许多科学工具对地下进行测量。这些包括记录地层的天然放射性和对电流的反应。有时，由于各种原因，我们可能会得到我们没有预料到的响应，或者是物理的结果。这些奇怪的响应可能会被无意中删除或忽略，并可能对最终的建模解决方案产生影响。
如果你打算长期呆在你的岗位上，那么学习你工作领域背后的基础知识可能是明智的。这样，您将对数据有更好的理解，并能够与其他利益相关者更有效地沟通。
或者，如果你在一个团队中工作，与主题专家讨论数据的背景和结果可能是谨慎的。
商业头脑
Adeolu Eletu 在 Unsplash 上的照片
作为一名数据科学家，对业务有充分的理解是取得进步的关键。它可以让你了解企业中不同的部门和流程是如何工作的，也可以让你了解公司可能面临的问题。一旦你理解了一家公司想要达到的目标，那么翻译业务问题、选择最合适的解决方案并将其与业务影响联系起来就会容易得多。
作为一名数据科学家，建立一个你认为可能解决公司问题的大型复杂模型可能很有诱惑力，但是，可能一个简单的数据分析就足够了。
有时简单的解决方案会产生最大的影响。
例如，对有多少人在结账时放弃了购物车进行漏斗分析，可以帮助营销团队专注于自动化电子邮件活动，以提高转化率。
协力
照片由汉娜·布斯在 Unsplash 上拍摄
与他人合作是数据科学家最重要的技能之一，原因显而易见:在从软件工程到医学甚至执法的许多领域，团队合作是成功的关键。一个好的团队会帮助你从工作中获得比个人努力更大的收获。
当在一个较大的项目中工作或在一个公司中工作时，在项目的不同阶段会需要具有不同水平的专业知识和能力的人。
例如，如果一个项目涉及创造一个商业产品。在早期阶段，可能只需要数据分析师、主题专家和产品经理。一旦项目开始获得动力，可能需要软件开发人员和机器学习工程师等其他学科。
哥伦比亚大学整理了一系列关于数据科学领域成功团队合作的技巧，非常值得一读:
https://datascience.columbia.edu/news/2021/top-ten-advice-for-successful-data-science-teamwork/
问题解决
照片由西格蒙德在 Unsplash 上拍摄
这种技能在任何使用数据或信息的领域都是必不可少的。一个好的问题解决者能够快速识别问题，快速提出解决方案(如果可能)，高效和有效地实施这些解决方案，并定期与利益相关者交流他们的进展。
当开始一个数据科学项目时，在进行任何工作之前的第一步是定义问题陈述。
起初，问题陈述可能是高层次和模糊的，例如:“我们需要提高我们的利润”。
但是，经过一些调整和调查，我们最终可能会得到一个更精炼、更集中的问题陈述，比如:“在接下来的 6 个月里，我们需要实施哪些最有效的流程来增加 10%的利润？”
这为我们提供了清晰、可衡量和精确的信息，使我们能够提出最有效和高效的解决方案。也省去了走错路的时间浪费。
下面这篇文章深入探讨了如何提炼问题陈述，非常值得一读。
https://analyticsindiamag.com/problem-solving-skills-the-guardian-angel-for-data-scientists/
摘要
学习数据科学时，大部分重点是发展技术技能，如数据可视化、python、R 或机器学习，但不应忘记或忽视软技能。
培养沟通、解决问题和商业头脑等软技能不仅会对你目前的工作有所帮助，它们也是可以转移的，会影响你未来可能从事的任何工作。
感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！*或者，您也可以* 注册我的简讯 免费将更多内容直接发送到您的收件箱。
其次，通过注册会员，你可以获得完整的媒介体验，并支持我和其他成千上万的作家。每月只需花费你 5 美元，你就可以接触到所有精彩的媒体文章，也有机会通过写作赚钱。如果你用 我的链接报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！
提高 Python 代码可读性的 5 个基本技巧
原文：https://towardsdatascience.com/5-essential-tips-to-improve-the-readability-of-your-python-code-a1d5e62a4bf0
通过文档、类型提示和正确的变量名改进您的 Python 代码
照片由 Unsplash 上的 Clément Hélardot 拍摄
你是否经常回头看你 6 个月前写的一些代码，挠头想知道这些乱七八糟的东西是什么？或者你有没有被别人接过一个项目，却苦于不知道从哪里开始？如果是这样，你并不孤单。
Python 中有很多方法可以帮助你理解代码的内部工作方式，所以当你回到代码中时，从你离开的地方继续下去会容易得多。
作为一个例子，我们最终得到的代码看起来很像下图中的代码。然而，这还不是最糟糕的，还有一些事情我们需要详细说明，例如:
- load_las_file 函数中 f 和 d 分别代表什么？
- 为什么我们要检查粘土函数的结果？
- 这些函数在寻找什么类型？彩车？数据框架？
在这篇文章中，我将介绍五个基本技巧，告诉你如何通过文档、提示输入和正确的变量名来提高应用程序/脚本的可读性。
本教程的视频版本
我最近上传了这篇文章的视频到我的 YouTube 频道。下面来看看吧。
如果你喜欢这些内容，请考虑点击这里订阅频道。
1.评论
为了让我们有一个好的开始，我们可以对代码做的第一件事是向一些行添加注释，但是，要注意避免做过头。注释应该告诉你为什么代码会工作，或者为什么某件事情会以某种方式完成，但是不能告诉你它是如何工作的。
Python 中的注释通常是通过使用 hashtag 符号(#)来完成的，可以跨越一行或多行。
# Comment using the hashtag
# Another comment using the hashtag
对于多行注释，我们也可以使用双引号。
"""
This is an example of
a multi-line comment
"""
在下面的示例中，代码中添加了一些注释，以解释一些代码行背后的工作流和推理
向 Python 代码添加注释。图片由作者提供。
2.显式打字
Python 语言是动态类型的，这意味着只在运行时检查变量类型。此外，变量可以在代码执行期间改变类型。
另一方面，静态类型涉及到显式声明变量是什么类型，并且在代码执行期间不能改变。
2014 年， PEP 484 引入了类型提示的思想，后来在Python 3.5 版本中引入。这些允许你明确地声明变量应该是什么类型。
通过添加类型提示，可以显著提高代码的可读性。在下面的例子中我们可以看出:
- 需要两个参数
filename参数的类型应该是字符串start_depth参数应该是类型浮点型，默认值为[None](https://www.w3schools.com/python/ref_keyword_none.asp)- 该函数将返回一个 pandas DataFrame 对象
向 Python 函数添加类型提示。图片由作者提供。
我们马上就可以根据类型提示准确地知道函数需要什么以及它将返回什么。
3.文档字符串(文档字符串)
文档字符串是紧跟在函数或类定义之后的字符串。 Docstrings 是一种很好的方式，可以详细解释你的函数做什么，它需要什么参数，它将引发的任何异常，它将返回什么，等等。
此外，如果您正在使用类似于 Sphinx 的东西来为您的代码创建在线文档，那么文档字符串将被自动提取并转换成适当的文档。
以下示例显示了名为 clay_volume 的函数的 docstring。
这里我们可以指定每个参数是什么。这比基本的类型提示更进了一步。你也可以包括更多关于函数背后的方法论的信息，比如学术参考或方程式。
Python 中的 docstring 示例。图片由作者提供。
当您从代码中的其他地方调用函数时，拥有文档字符串也很有帮助。例如，使用 Visual Studio 代码，您可以将鼠标悬停在函数调用上，并看到该函数的功能及其要求的弹出窗口。
使用 docstrings 时的浮动提示示例可以提供关于函数的额外信息。图片由作者提供。
如果您使用 Visual Studio Code (VSCode) 来编辑您的 Python 代码，那么您可以使用像 autoDocstring 这样的扩展来使创建 Docstring 的过程变得更加容易。这允许您键入三个双引号，并自动为您填充模板的其余部分。你只需要填写细节。
在 VSCode 中使用自动文档字符串的动画 gif。图片由作者提供。
提示:如果您已经在参数中声明了类型，那么它们将被自动选取。
4.可读的变量名
有时候当你写代码的时候，你不会太在意一个变量的名字，尤其是当你决定让代码运行起来而时间又不多的时候。然而，如果你回到代码中，发现一系列名为x1或var123的变量，乍一看你可能无法理解它们代表什么。
使用下面的例子，我们有两个变量f和d。我们可以通过查看代码的其他部分来猜测它们的意思，但是这需要时间，尤其是如果代码很长的话。
命名不当的 Python 变量示例。图片由作者提供。
如果我们给这些变量赋予适当的名称，我们将能够知道其中一个是由lasio.read()调用读取的data_file，并且很可能是原始数据。data变量告诉我们这是我们正在处理的实际数据。
Python 中正确变量名的例子。图片由作者提供。
5.避免幻数
幻数是代码中的值，其背后有无法解释的含义，可以代表常数。在代码中使用这些可能会导致歧义，特别是对于那些不熟悉使用该数字的任何计算的人。
此外，如果我们在多个地方有相同的幻数，我们需要更新它，我们将不得不更新它的每个实例。然而，如果这个数字被分配给一个正确命名的变量，这个过程就会容易得多。
它还打破了最古老的编程规则数据之一，可追溯到 20 世纪 60 年代。
在下面的例子中，我们有一个函数，它计算一个名为 result 的值，并将其乘以 0.6。这是什么意思？是换算系数吗？标量？
行 result = gr_index * 0.6 中的幻数示例。图片由作者提供。
如果我们声明一个变量并给它赋值，那么我们就有更好的机会知道它是什么。在这种情况下，粘土与页岩的比率用于将伽马射线指数转换为粘土体积。
在为幻数 clay_shale_ratio 声明一个变量后，我们可以更容易地阅读代码，并在将来更新它。图片由作者提供。
最终代码
应用上面的技巧后，我们的最终代码现在看起来更好，也更容易理解。
摘要
通过注释和 docstrings 向代码中添加文档可以帮助您和其他人理解您的代码在做什么。开始时，这可能感觉像是一件苦差事，但是随着工具的使用和经常的练习，它会变成你的第二天性。
感谢阅读。在你走之前，你一定要订阅我的内容，把我的文章放到你的收件箱里。 你可以在这里做！
其次，通过注册会员，你可以获得完整的媒介体验，并支持我自己和成千上万的其他作家。它每个月只花你 5 美元，你可以完全接触到所有令人惊叹的媒体文章，也有机会用你的写作赚钱。如果你用 我的链接 ， 报名，你直接用你的一部分费用支持我，不会多花你多少钱。如果你这样做了，非常感谢你的支持！
开始数据科学和数据分析职业生涯的 5 个基本工具
原文：https://towardsdatascience.com/5-essential-tools-to-start-a-career-in-data-science-and-data-analytics-dfcf25b5e51b
学习这 5 个工具，获得作为数据科学家或数据分析师的第一份工作
在 Unsplash 上由 Carlos Muza 拍摄的照片
动机
数据科学家的工作是利用大型结构化或非结构化数据集，以便提取有意义的信息，从而做出更好的决策。它结合了领域专业知识、数学和统计知识、数据建模和结果交流技能。然而，他们也需要工具来赋予这些概念以生命。
本文将在强调这些工具的好处之前，帮助您理解它们。
什么是数据科学和数据分析工具？
市场上有太多的工具，无论是开源还是付费许可，相关工具的升级可能会帮助您优化您的投资组合，并为您的下一个数据职业生涯做好准备。
本文范围内的工具是业内最常用的，分为三大类，如数据分析可视化、脚本/机器学习和数据库管理。
数据分析和可视化工具
数据可视化是数据的图形化表示。它与数据科学项目的任何其他方面一样重要。根据 ILS 测试统计数据显示，超过 65%的人是视觉学习者，因此清晰简洁的可视化有助于传达关于数据的关键信息，从而更好、更快地做出决策。
1 →表格
Tableau 是 2019 年 Salesforce 收购的无代码商业智能软件。它为分析和可视化提供了直观的拖放界面。非技术方面使其在行业中脱颖而出。
此外，它速度很快，并提供了互连来自多个来源(如电子表格、SQL 数据库等)的数据的能力。无论是从云还是内部创建单一可视化。Tableau 是地理空间和复杂数据可视化的通用工具。此外，它还兼容流行的编程语言，如 Python 和 r。
2 →微软 PowerBI
与 Tableau 类似， PowerBI 也是一个商业智能和数据可视化工具，允许将来自多个来源的数据转换成交互式商业智能报告，并且还支持 Python 和 r。
但是，它们真正的区别是什么呢？
它与 Tableau 的主要区别在于它不能处理和 Tableau 一样多的数据。除此之外，它可以连接到有限数量的数据源。例如，Power BI 不能与 MongoDB 这样的 NoSQL 数据库一起正常工作。但是，它价格实惠，不仅适用于大中型公司，也适用于小型公司。
机器学习和脚本工具
每个数据科学家无一例外都需要具备编程技能，要么为数据处理和分析创建脚本，要么构建机器学习模型。Python 和 R 是所有数据科学家最流行的编程语言之一。
3 → Python
Python 提供的简单性和灵活性迅速增加了数据科学家对它的采用。例如，以下代码为 Python 和 Java 生成相同的结果Data Science and Analytics Tools。
- 对于 Python，我们可以在命令行解释器中键入
python，后跟print语句，如下所示。
# Step 1: open interpreter
python# Step 2: write the following expression to show the message
>>> print("Data Science and Analytics Tools")
- 但是，对于 java，我们需要创建一个完整的程序，并对其进行编译，以获得相同的结果。这是因为它没有命令行解释器。
# Step 1: write this code in a file ShowMessage.javaclass ShowMessage {
public static void main(String[] args) {
System.out.println("Data Science and Analytics Tools");
}
}# Step 2: compile the file
javac ShowMessage.java# Step 3: execute the program to show the message
java ShowMessage
除了是开源的，并且有一个大型社区，Python 提供了以下框架和库(不是详尽的),它们是数据分析和机器学习的顶级框架和库。数据科学家可以:
- 使用
[Numpy](https://numpy.org/)执行高级数值计算，使用多维数组提供紧凑和快速的计算。 - 利用
[Pandas](https://pandas.pydata.org/)进行数据处理、清理和分析。它被广泛使用，是数据科学家使用的最流行的工具。 - 使用
[Matplotlib](https://matplotlib.org/)和[Seaborn](https://seaborn.pydata.org/)创建从简单到更高级的数据可视化，可以进一步集成到应用程序中以生成仪表板。 - 用
[Scikit-learn](https://scikit-learn.org/stable/)、[Pytorch](https://pytorch.org/)、[Keras](https://keras.io/)实现几乎所有的机器学习和深度学习算法。 - 使用
[Beautiful](https://beautiful-soup-4.readthedocs.io/en/latest/)从互联网上抓取数据，将其转换成合适的格式并存储，以创建数据存储。
4 → R(工作室)
这种编程语言是由统计学家创造的，这使得它在统计分析和数据可视化方面非常流行。它被数据科学家和业务分析师以及学术界广泛用于研究。
R 整合了[tidyverse](https://www.tidyverse.org/),一套用于数据科学任务的强大工具(并非详尽无遗)，例如:
- 使用
[ggplot2](https://ggplot2.tidyverse.org/).创建强大的数据可视化 - 使用
[modelr](https://modelr.tidyverse.org/).实现优雅的数据建模管道 - 使用
[dplyr](https://modelr.tidyverse.org/)执行数据操作，这是一个包含多个便捷函数的库，可以解决最常见的任务，如数据过滤、选择、聚合等。 - 使用
[readr](https://cran.r-project.org/web/packages/readr/readme/README.html)加载 CSV 和 TSV 数据文件，使用[readxl](https://readxl.tidyverse.org/)加载 Microsoft Excel 数据。
r 不仅提供了统计和可视化功能，还通过[caret](https://topepo.github.io/caret/)提供了机器学习能力，这是一个包含数百种算法的包。
数据库管理
作为数据科学家，您必须能够从本地或远程数据库中检索结构化或非结构化数据。
5 → SQL
结构化查询语言(SQL)是一种功能强大的语言，大、中、小型数据驱动型企业都使用这种语言来探索和操作他们的数据，以便提取相关的见解。这是因为大多数公司使用关系数据库系统，如 PostgreSQL、MySQL、SQLite 等，我们可以从 Stackoverflow 提供的 2022 年调查结果之后的中观察到这一点。
这一结果无疑使得 SQL 知识需求量很大。它甚至是数据科学家/机器学习专家、数据分析师、业务分析师和专业开发人员中最受欢迎的语言之一。
进一步挖掘一下调查，这张图显示了 SQL 的使用有多广泛，相比之下 Python 和 R 分别为 54.64%、43.51%和 3.56%。
考虑到专业开发人员使用关系数据库的百分比，这一发现显然并不令人惊讶。此外，从这些分析中得出的一个重要结论是，企业不会很快放弃 SQL。
好消息是，SQL 的人类可读方面使其成为最简单的学习语言之一，我在 DataCamp 上偶然看到了这门课程，我相信它可能会帮助你获得构建 SQL 组合的相关技能。
结论
作为数据科学家或数据分析师，你的第一份工作可能相当令人生畏。然而，学习符合就业市场要求的技能肯定可以帮助你建立一个强大的投资组合来面对这些挑战。现在是探索的时候了，获得你一直期待的第一份工作吧！
如果你喜欢阅读我的故事，并希望支持我的写作，考虑成为一个媒体成员解锁无限制访问媒体上的故事。
欢迎在媒体、推特和 YouTube 上关注我，或者在 LinkedIn 上打招呼。讨论人工智能、人工智能、数据科学、自然语言处理和人工智能是一种乐趣！
帮助你从今天开始学习朱莉娅的 5 门课程
原文：https://towardsdatascience.com/5-free-courses-to-learn-julia-start-learning-today-66c1e3173ebc
到 2023 年，你可以免费参加的最好的在线朱莉娅课程
在 Unsplash 上由阿尼鲁德拍摄的照片
编辑:我和我的合著者很高兴地告诉大家，我们的新书《茱莉亚速成班》已经开始预售了:
https://logankilpatrick.gumroad.com/l/juliacrashcourse
随着 Julia 编程语言越来越受欢迎，越来越多的人寻求学习这门语言的课程。在本帖中，我们将重点介绍 5 门可以免费在线学习的课程。鉴于我在 Julia 社区中的角色，我一直在寻找推荐新用户的最佳资源，这些是我在过去三年中找到的一些最佳资源。
在我们开始之前，我想快速记录一些重要的资源:
- 点击https://julialang.org/learning查看我们所有的学习资源。
- 前往 https://julialang.org/learning/classes/，看看世界各地的教室里是如何教授茱莉亚的！
- 最后，JuliaAcademy 是我们关于 Julia 的课程平台。在 https://juliaacademy.com 了解更多信息。
现在开始上课！🚀
计算思维导论(麻省理工学院)🧠
麻省理工学院艾伦·埃德尔曼教授讲授的《计算思维导论》可能是有史以来观看人数最多的朱莉娅课程(这在很大程度上要归功于与 YouTubers 用户格兰特·桑德森(3b1b)和詹姆斯·施洛斯(LeiosOS)的合作)。该课程还拥有一个由 Fons van der Plas 设计的令人惊叹的前沿主页，他是 Pluto.jl 的创始人，并使该课程网站成为许多令人垂涎的新 Pluto 功能的试验场。
边注，如果你不熟悉冥王星，我建议你查一下:
这门课最棒的一点是讲课质量很高。如果你想看一个例子，看看格兰特的这个:
那么课程包括什么呢？好吧，让我们来看看:
- 模块 1:图像、变换、抽象
- 模块 2:社会科学&数据科学
- 模块 3:气候科学
这些都是高层次的主题/激励性的例子，但教授的核心是如何使用 Julia 来处理微分方程、数学建模等问题。
这个班级周围也有一个活跃于不和的社区。你可以在课程网站上找到加入的链接:https://computationalthinking.mit.edu
朱丽亚的高级科学计算🧪(蒂姆·霍利)
蒂姆·霍利是朱莉娅生态系统的核心支柱。他的贡献是广泛的，同时仍然是圣路易斯 WashU 的活跃教授。当我看到 Tim 正在学习一门课程，讲述 Julia 的基础知识以及如何成为一名优秀的开源贡献者时，我知道这是我想要强调的东西。
Tim 带着一些动机开始了课程，解释为什么 Julia 如此适合今天的计算问题。如果你没有看过这个讲座，我强烈建议你去看看，因为这是我经常回顾的资源。
GitHub:【https://github.com/timholy/AdvancedScientificComputing
概括来说，本课程包括:
- 课程介绍:“为什么是朱莉娅？”和一个简短的参观
- Julia 包、Git 和 GitHub
- 测试和设计原则
- 持续集成、文档、包版本控制和发布
- 笔记本电脑上的高性能计算 I:了解和测量性能
- 笔记本电脑上的高性能计算 II:算法、编译器和推理
如果你是 Julia 和开源生态系统的新手，这个课程无疑是你可以投入时间的最好的事情之一。下次你见到 Tim(在线或亲自参加 Julia 活动)，一定要告诉他这门课程有多棒！
Julia 初学者机器学习🤖(由 Doggo dot JL——以前是天才业余爱好者的朱莉娅)
《天才业余爱好者的朱莉娅》(现为 Doggo.jl)是我在朱莉娅生态系统中最喜欢的频道和资源之一。他们的内容质量一贯很高，制作精良。如果你还没有看过他们制作的所有系列，我强烈建议你去看看。为了这篇文章，我将只强调我发现有帮助的课程之一:Julia Machine Learning for 初学者。
如果你已经准备好投入进去，不需要听更多的，去 YouTube 系列:
05 系列|初学茱莉亚机器学习
否则，让我们深入了解 Doggo.jl 在这个系列中涵盖了哪些内容，以及它如何对您有所帮助！
- 什么是机器学习？
- 朱莉娅的线性回归
- Julia 中的逻辑回归
- Julia 中的朴素贝叶斯分类器
- 使用 LIBSVM.jl 的支持向量机
- 决策树. jl，树和随机森林
- NearestNeighbor.jl
- Flux.jl 人工神经网络
- 还有更多！
Julia 中的机器学习是生态系统中利用最不足的领域之一，主要是因为学习该主题的资源仍然稀缺。来自 Doggo.jl 的这门课程超越了基础知识，带你经历各种不同的机器学习。
我最喜欢的视频是关于深度学习的(因为 DL 是 ML 中最酷的领域😄).自己去看看吧:
Julia 负责数据科学📊(作者胡达·纳萨尔)
在这篇文章中，我不能不提到胡达为社区建立的茱莉亚学院课程。她的课程将带你从对茱莉亚的数据科学能力一无所知，到训练模型和执行所有类型的常见分析:https://juliaacademy.com/p/julia-for-data-science
Huda 一直是生态系统的长期贡献者，也是我非常崇拜的人，所以值得看看这些视频和相关代码。
本课程涵盖:
- 与 Julia 一起处理数据
- 朱莉娅的线性代数基础
- 朱莉娅的统计学
- 聚类和分类
- 朱莉娅的图表(胡达的专长)
- 还有更多！
这是 Huda 查看 Julia 中图表的一个秘密峰值:
你可能还想看看 Huda 最近发表的一篇关于使用 Pagerank 生成 Julia 包依赖图的文章:https://forem . Julia lang . org/nassarhuda/page rank-on-the-Julia-Package-Dependency-Graph-2g bo
总的来说，Huda 是一个优秀的讲师，这门课程是我们在 JuliaAcademy 上提供的最受欢迎的课程之一，有超过 10，000 名学生注册。今天一定要在报名！
紧张的初学者的 Julia 编程😬
Julia Academy 上的 Julia for neural 初学者课程是我最喜欢的课程之一:https://Julia Academy . com/p/Julia-programming-for neural-初学者。
本课程由 Henri Laurie 教授，通过不假设你在学习 Julia 之前有深厚的编程背景，帮助扩展了 Julia 生态系统的范围。劳里博士带你从头开始，通过概念像循环，条件和功能。
本课程分为 4 周的内容，从逻辑+字符串开始，到使用 Julia 操作文件和数据结束。我看了这门课的所有讲座，劳里博士让课程内容平易近人的能力给我留下了深刻的印象。
如果您不确定本课程是否适合您，请观看这段介绍视频:
如果你知道有人想学习编程，但不知道如何去做，这是为他们准备的课程！在他们完成后，参加前面提到的其他课程将有助于强化这些想法。
总结+资源🔚
今天有很多不同的地方可以学习朱莉娅。如果你已经走了这么远，但没有被这些课程打动，我建议你去看看练习网上的茱莉亚赛道:https://exercism.io/tracks/julia
即使你是一个完全的初学者(或专家)，你也可以做一些专家导师和互动练习来磨练你的 Julia 技能。
如果你有我没有在这里提到的最喜欢的课程，请在评论中提出来，这样我可以确保与社区分享它。快乐学习！
学习数据科学数学的 5 个免费资源
原文：https://towardsdatascience.com/5-free-resources-to-learn-math-for-data-science-4cbf4fc43673
想学数据科学，又没有数学背景，从这里开始。
图片由 Freepik
我从数据科学有志者那里收到的最常见的问题之一是“对于机器学习，我需要知道多少数学知识？”
当我第一次开始自学数据科学时，我不知道我需要学习多少数学才能完全胜任入门级数据科学职位。
我花了很多时间学习本科水平的微积分、线性代数和统计学。
在我找到第一份数据科学工作后，我意识到在这个行业工作所需的数学量远远低于我的预期。
大多数公司倾向于建立机器学习模型来解决非常相似的业务问题。由于这一点，你一般不需要重新发明轮子，从零开始构建算法。您通常可以使用现有的解决方案来适应您当前的使用情形。
然而，至少对这些算法背后的工作有一个直观的理解总是更好的。
例如，梯度下降用于在线性回归模型中寻找最佳斜率值。这是微积分的一个应用，理解最佳拟合线是如何计算的总是有好处的。
类似地，线性代数在建模的数据准备中具有应用，并且在实施维度减少解决方案中被广泛使用。如果你想扩展你的深度学习知识，你将需要学习矩阵操作技术。
最后，统计学是成为数据科学家需要学习的最重要的数学分支。在野外工作时，您需要分析数据趋势，构建假设，并将观察结果转化为有意义的见解。这些都是统计学的应用，如果你想找一份数据科学的工作，这些都是必须要学的。
当我学习上述概念时，我最初花了很多时间进行手工计算。我学会了微分、积分和解线性方程。然而，这并不是学习数据科学的先决条件。
我们有计算机程序来为我们执行这些计算，我们真正需要的是对这些数学概念有一个高层次的、直观的理解。
同样，上述建议只适用于你试图学习数据科学以便在该行业找到工作的情况。如果你想成为一名机器学习研究人员或进入学术界，那么你需要学习的数学量将显著增加，因为你将从头开始构建新的解决方案。
在这篇文章中，我将为您提供 6 种学习机器学习数学的资源。我将包括免费的在线材料(YouTube 视频、在线课程、教科书)，你可以用它们来获得足够的数学能力，成为一名数据科学家。
1. 3Blue1Brown 的线性代数系列
3Blue1Brown 是一个受欢迎的 YouTube 频道，它采用可视化方法来分解高度复杂的数学概念。
他们的线性代数系列将带您了解核心的线性代数概念，如向量、线性组合、线性变换、矩阵乘法、特征值和特征向量。
他们不太深入数学计算。相反，本系列的重点是为您提供对线性代数的直观理解。你将会得到一个解释，而不是简单地记住公式，解释它们为什么有效，以及你如何自己推导出它们。
2. 3Blue1Brown 的微积分系列
这是由 3Blue1Brown 创建的该列表中的第二个资源。他们的微积分系列也很直观，容易理解。
他们将带你了解导数、链式法则和隐式微分等概念，所有这些概念在实现梯度下降算法中都有直接的应用。
3. 3Blue1Brown 的深度学习系列
虽然他们的微积分系列更加通用，并且迎合了任何想要增强数学知识的人，但 3Blue1Brown 的深度学习系列是专门为对人工智能感兴趣的学生创建的。
深度学习系列将带你了解神经网络的内部工作原理，以及它们是如何学习的。
您将获得反向传播算法及其工作原理的深入解释，以及其背后的微积分概念。
4.统计学习简介
这是作为机器学习爱好者可以阅读的最好的统计学入门教材之一。它在网上可以买到，也可以免费下载。
如果您过去已经实现了线性回归、逻辑回归和决策树等算法，但不了解这些模型背后的工作原理或何时使用它们，这本书是一个很好的起点。
您将对线性模型、基于树的算法和无监督技术的工作原理有一个直观的理解。提供了关于在创建不同的统计模型时如何应对过度拟合的解释。
这本书的每一章还包括一个 R 语言的实验练习，你可以跟着练习编码，这样你不仅可以从理论上理解这个主题，还可以将学到的概念应用到实践中。
5.哈佛大学统计 110
这个列表中的最后一个资源是 YouTube 上的一个系列，名为 statistics 110，由哈佛大学向公众开放。
这是我在网上找到的关于统计和概率的最好的系列讲座之一。它几乎涵盖了你在本科统计课上通常会看到的所有统计概念——概率公理、分布类型、蒙蒂霍尔问题、协方差、相关性、卡方检验、T 检验、马尔可夫链等等。
讲座从入门水平开始，即使你没有统计学和概率的背景，你也可以毫不费力地跟上。
上面的资源是让你接触机器学习的数学世界的好方法。它们为您提供了对数学概念的直观理解，这将增强您对每天构建的模型背后的工作的了解。
如果您没有时间浏览这个列表中的所有资源，那么我建议您至少阅读《统计学习入门》,因为这本教材中解释的概念可以直接应用到您作为数据科学家的日常工作流程中。
感谢阅读！本文最初发表于这里。
理解 Spark 大数据处理的 5 个基本概念
原文：https://towardsdatascience.com/5-fundamental-concepts-to-understand-big-data-processing-with-spark-f2a6aadb1093
#5.懒惰评估
SpaceX 在 Unsplash 上拍摄的
你们中的许多人可能都经历过计算机在某些任务上表现不佳。它要么不能完成任务，要么永远无法完成。
数据处理，尤其是处理大型数据集时，就是这些任务之一。您的计算机可能没有足够的能力或资源来进行大规模数据处理。
一种解决方案是通过形成集群(即一组计算机)来组合来自许多计算机的资源。即使您有许多计算机，您也需要一种有组织的方式将任务分成小部分，并在计算机之间分配。这就是 Spark 所做的。
Spark 是一个框架，它管理和协调跨计算机集群的任务执行。它让您可以分散数据和计算，从而实现显著的性能提升。
Spark 的默认语言是 Scala，但是我们可以通过数据科学生态系统中流行的编程语言来使用 Spark。
例如，PySpark 是一个 Python 库，允许使用 Python 语法运行 Spark 代码。Spark 还通过 SparkR 和 sparklyr 库支持 R。
在本文中，我们将回顾 5 个概念，它们是理解 Spark 大数据处理的基础。当您开始使用 Spark 进行大规模数据处理时，它们也会很有帮助。
如果你想在我发表新文章时收到电子邮件，别忘了订阅。
1.火花应用
Spark 应用程序由一个驱动程序进程和一组执行器进程组成。这些进程由集群管理器管理。
用户通过驱动程序进程与 Spark 应用程序进行交互。它接受用户输入，并在执行者之间分配工作。假设我们编写一个程序来计算超市产品的平均周销售额。我们不把任务分成块，分别分配给执行者。驱动程序处理在执行器之间分配和调度任务。
驱动程序进程还通过维护相关信息来跟踪 Spark 应用程序。
执行者完成司机交给他们的任务。它们还通知驱动程序计算的状态。
2.火花会议
火花应用通过一个叫做 SparkSession 的驱动程序来控制。因此，编写 Spark 代码的第一步是实例化一个 SparkSession 。
例如，下面的 PySpark 代码创建一个 SparkSession ，然后通过这个会话读取一个 parquet 文件。
from pyspark.sql import SparkSessionspark = SparkSession.builder.getOrCreate()df = spark.read.parquet("myfile.parquet")
3.数据帧和分区
DataFrame 基本上就是一个有行有列的表格。定义列及其数据类型的列表称为模式。
Spark 数据帧与熊猫或 R 数据帧非常相似，但有一个显著区别。在 Pandas 和 R 中，数据帧存储在一台机器或计算机上(有一些例外)，而 Spark 数据帧分布在许多计算机上。
Spark 将数据分成更小的块，称为分区。分区允许每个执行器并行工作，从而极大地提高了性能。
每个分区包含原始数据帧中的一组行。将数据划分为分区的原因是数据太大，无法在单台机器上运行，或者在单个分区上进行计算需要太多时间。
4.转换和操作
火花操作可分为两大类，即转换和动作。
修改数据帧的指令称为转换。例如，根据列中的值过滤数据帧就是一种转换。另一个例子是根据列中的不同值对行进行分组。
两种类型的变换是窄变换和宽变换。在窄转换中，每个输入分区只贡献给一个输出分区。过滤是窄变换的一个例子。一个分区中的值对其他分区没有任何影响。
宽转换包含宽依赖关系，这意味着一个输入分区可能对几个输出分区有贡献。对行进行分组(即 groupBy 操作)是广泛转换的一个例子。一个组可能包括来自许多不同输入分区的数据点(即行)。
(图片由作者提供)
当我们向 Spark 发出转换指令时，它不会立即转换数据。即使我们给出了一系列转换指令，它们也成为了转换计划的一部分。
当我们运行一个动作时，转换被执行或计算。动作告诉 Spark 通过执行转换来计算结果。Count、collect和aggregate是火花动作的一些例子。在控制台中显示数据也是一个操作。
让我们看一个例子来更清楚地解释这些术语。假设我们有一个数据框架，其中包含一家连锁超市的产品日销售量。我们需要找到蔬菜类产品的平均月销售额。
- 过滤属于蔬菜类别的产品(窄转换)
- 按月列对行进行分组(宽转换)
- 计算平均值(动作)
5.懒惰评估
我们刚刚提到，Spark 跟踪转换，直到一个动作被执行。Spark 不是立即修改或转换数据，而是根据给定的转换指令制定转换计划。这个过程叫做懒评。
当我第一次开始使用 Spark 时，我不知道懒惰评估。我被 Spark 执行数据转换的速度震惊了。然而，它实际上并没有进行转换，而是将它们保存起来以备后用。当我调用一个 action 操作时，所有的转换都被执行了，这需要相当长的时间。
惰性评估允许 Spark 优化整个操作集，这是一个很大的好处。考虑这样一种情况，我们进行了一系列转换，作为最后过滤操作的结果，只有一小部分数据受到影响。
由于惰性评估，Spark 可以通过只转换受影响的行来完成工作。否则，将完成所有转换，然后过滤受影响的行。
数据技术的进步使得收集、传输和存储数据比以往任何时候都更容易。面向数据的应用程序和产品是用非常大量的数据创建的。因此，Spark 等用于大规模数据处理的工具开始成为数据科学中的必要工具。
我们已经介绍了 5 个基本概念，可以帮助您开始学习 Spark。如果你是或者想成为一名数据科学家，我强烈建议你熟悉一下 Spark。
别忘了 订阅 如果你想在我发表新文章时收到电子邮件。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果您使用以下链接，我将收取您的一部分会员费，无需您支付额外费用。
https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。
5 个 Groovy 技巧帮助你在 Julia 中编写更好的代码
原文：https://towardsdatascience.com/5-groovy-tips-help-you-write-better-code-in-julia-4c7317e60862
一些提高 Julia 代码可读性的技巧使其更容易理解
(图片由 Pixabay 上的 Darkmoon_Art 提供)
介绍
在一些容量中，在某个时刻，每个程序员都写过一些糟糕的代码。事实是，在生活中，一个人经常需要犯错误，以便从这些错误中学习和成长，并使自己变得更好。这同样适用于软件工程和编程。通常代码可能是一个迷宫，这些困难使得从一个不是很结构化的东西创建一个结构变得非常困难。当软件是非结构化的时候，实现代码的更新是非常困难的。
幸运的是，编写良好且组织良好的代码可以缓解这些问题。唯一的问题是，在某些情况下，我们并不总是编写组织良好的代码。对于那些喜欢 Julia 编程语言的人来说，有一些非常简单的步骤可以让你的代码变得更好。考虑到方法定义还有一个新的方面，这些步骤对 Julia 来说是额外有价值的，那就是由于语言的多分派范例而被类型化。让我们来看看这些技术，我用它们来使我的代码在 Julia 中变得更好。另外，如果你想看 Python 的等价物，这里有我写的另一篇文章的链接:
№1:按类型和层次结构参数分开调度
我真正喜欢做的第一件事是将方法分组，并保持它们有组织。同名的方法可能应该一起定义。让这些方法具有层次结构是很有意义的，因为 Julian 子类型系统也是为了做同样的事情而设计的。考虑下面的例子，它很好地演示了不同的类型以及它们的超类型和子类型是如何被调度的。
showit(x::Number) = println("Number", x)
showit(x::Float64) = println("Float", x)
showit(x::Integer) = println("Integer", x)
在这段代码中，超类型是 Number。也就是说，如果我们要提供任何抽象数字类型的子类型，那么数字函数就会运行。然后我们有两个分派，一个是针对浮点 64 的，一个是针对 64 位整数的。如果我们在一个更大的文件中，将这些调度放在一起是很有意义的，因为从逻辑上讲，它们本质上是相同的函数定义。如果我们有另一个子类型调度，那么对这些调用进行分层排序是很有意义的，就像这样:
showit(x::Number) = println("Number", x)showit(x::Real) = println("Real Number", x)
showit(x::Float64) = println("Float", x)
showit(x::Integer) = println("Integer", x)
showit(x::Imaginary) = println("Imaginary Number", x)
showit(x::Complex) = println("Complex", x)
我认为这更有意义，因为我们可以主动查看哪个函数将在类型层次结构中捕捉每个类型。这最终使得方法定义更容易用它们的类型来估算，特别是当它与类型层次结构相关时。
№2:遵循命名惯例
朱莉娅有一个特殊的命名惯例，当然应该遵循。遵循这些惯例是一个好主意的原因是，你甚至可以在打电话之前就知道你正在使用什么样的定义。在 Julia 中，构造函数和模块在其名称中每个单词的开头都用大写字母表示。
module NotMain
mutable struct Hello
x::Int64
endend
变量名和方法名都是小写的。
x = 5
println(y::Hello) = println(y.x)
最后，如果一个函数改变了它的任何参数，那么你应该在它的名字后面加上一个解释点。这使得判断一个函数是否会改变你的数据变得容易得多，并且使得所有的数据改变变得非常明显，这绝对是你想要的，除非你喜欢数据丢失之类的。
change_thing!(x::5)end
所有这些共同创造了一种语法，在这种语法中，我们可以解开正在发生的事情的类型，甚至不知道我们正在使用的名称的任何信息。
using NotMain # Modulex = Hello(1) # Constructor
y = Hello(2) # Constructor
println("Hello") # Method ()
x # Defined variable name
incrementx!(h::Hello) = h.x += 1 # We can tell this is a mutating call
№3:使用类型层次结构
Julia 被低估的优势之一是类型层次结构。Julia 中的子类型的伟大之处在于，结合多种调度，它可以非常强大。使用子类型的另一个很大的好处是，它将使你的软件更具可扩展性，因为现在你可以导入抽象类型，用类似的字段对某些东西进行子类型化，然后这个新类型立即继承分派给那个类型的每个方法。这可以节省很多时间，因为您不需要为每种类型编写单独的函数，相反，您可以只调度一种类型，然后根据需要相应地调度下面的类型。我有一篇文章详细介绍了这一点，并概括了 Julia 中的类型，因此，如果您还不熟悉这一点，这可能是了解 Julia 中的类型层次结构的好地方:
№4:提取
在我的故事中，提取是一种技术，在这里我们重复这个选择，因为提取绝对是使代码更好的最有价值的事情之一。当我们提取代码时，我们将它移动到自己独特的方法中，这将在一个全新的元上清理代码。所有其他的例子通常主要适用于在全局或模块范围内工作，但是提取可以用来清理你的函数，以及缩短它们。
提取过程非常简单，您只需命名代码的一部分，然后将其封装到一个方法中。我也有一整篇关于提取的文章，如果你想更深入地了解这项技术的话。
[## 更多的方法意味着更好的代码
towardsdatascience.com](/more-methods-means-better-code-1d3b237f6cf2)
№5:内联迭代
创建 for 循环和迭代是每个程序员通常害怕的事情之一。这并不是说创建这种东西很困难，只是每次打开一个循环来做某件事时，它都会在循环被调用期间停止执行。即使使用并行处理，最终在一个线程上运行仍然需要时间，所以避免编写大量的 for 循环绝对是一个很好的约束。
For 循环还创建了一个全新的范围，接受参数，并创建了一个新的缩进级别。就处理和编写循环的实际语法而言，有很多东西要进入迭代循环。幸运的是，语法很容易改进，改进语法的一种技术是使用内联 for 循环。在 Julia 中，它们的速度也快得多，并且提供了返回，因此不需要初始化。考虑下面的短语:
x = []
for y in example
push!(x, y)
end
我们可以将这句话简化成这样一行代码:
x = [y for y in example]
我认为这样更简洁。内联迭代用[]语法表示，考虑到我们期望数组类型的可迭代返回，这很有意义。
结论
对于编程，有很多小事情可以做，以改善他们的代码，使其运行或看起来更好。在众多改进中，有这五个，我希望它们能提供一些易于使用的技术来改进你的 Julia 代码的外观，有时甚至是性能。特别是，我发现提取和单行 for 循环非常有价值。感谢您阅读我的文章，我希望所有这些很酷的提示都能派上用场。
2022 年将开展 5 个医疗保健数据分析项目
原文：https://towardsdatascience.com/5-healthcare-data-analytics-projects-to-take-up-in-2022-68e2dc820f3b
克里斯·利维拉尼在 Unsplash 上的照片
在当今不断发展的技术世界中，数据推动了业务的发展。
未来的职业生涯涉及各个行业的数据分析——医疗保健、金融、体育、零售&电子商务、流媒体、航空、约会、营销、天气、教育、政府、旅游，以及天底下的一切。
企业依靠数据来保持竞争力、灵活性并做出更明智的决策。医疗保健行业也不例外。在医疗保健行业工作了将近一年，我意识到医疗保健行业在技术采用方面是出了名的保守。我们使用的是 40 年前建立的遗留系统，这些年来根据需要进行了一些小的改造。现在是医疗保健数字化革命的时候了。
如果你正在寻找一份与数据相关的工作或学习数据科学以实现职业转换，或者对在朝九晚五之后从事数据项目感兴趣，我建议考虑医疗保健这一常青树领域。
在一个错误可能意味着生死之别的行业，项目只能如此有趣。
但是，您如何确定合适的项目呢？
我通常根据你的目标和工作带宽考虑三个因素:
- 项目长度
可以在一周而不是一个月内完成的项目(组合项目) - 问题陈述类型 聚类、回归、情感分析、预测建模
- 结果的表示
数据模型、Tableau 或 PowerBI 可视化、表格或图形
注 :以下项目是为了启发类似项目。用于项目的数据可能是开源的，也可能不是。
1.短期项目
预测医疗中心的手术量
数据 : 范德比尔特大学医学中心择期手术时间表
问题陈述:预测医疗中心的每日需求，以有效利用 55 个手术室
方法:根据 48 周手术日程的历史数据，预测手术例数需求。您可以识别独立变量，移除相关变量，并创建多个回归模型，以使手术量预测的误差最小
输出格式:表格
输出:基于多个预测模型的手术前 7 天和 3 天的手术量图片来源:作者
2.作品集项目
分析推特上关于新冠肺炎疫苗接种的趋势
论文发表于:https://infodemiology.jmir.org/2022/1/e33909
数据:从推特上提取的推文
目标(更多项目详情在我的GitHub):
- 从与 COVID 疫苗相关的时间范围内的推文中提取信息，其中观点高度非结构化、异质，或正面或负面或中性，并确定情绪变化的驱动因素
- 利用时间线中突破性事件支持的主题建模和文本分析，探索对话并提取收集的推文中出现的“主题”
- 可视化 Twitter 用户的情绪趋势以及与所发现的主题相关联的流行度
方法
- 数据收集:2021 年 1 月至 4 月间收集了 274 万条推文
- 数据预处理:数据清理和使用词袋将个人推文与组织和机器人推文分离
- 数据建模:
- 无监督的 LDA——理解隐藏在推文中的抽象主题
- 情绪分析——使用 VADER(用于情绪推理的效价感知词典)检查疫苗对疫情期间用户态度的影响
- 相关性解释(CorEx) —将主题建模转向由无监督 LDA 识别的主题。使用的标准化主题相关性(NTC)表示由特定主题解释的单个文档内的相关性
4.数据可视化:使用 Excel 的图形、图表和热图&表格
3.预测分析项目
在医院通过套餐定价评估治疗计划
套餐定价:根据临床定义的护理事件的预期费用，在入院时为患者提供治疗费用
此外还有传统定价:价格是通过综合处理或后处理设施中使用的服务来计算的
数据: 教会医院套餐定价
问题陈述:建立预测模型，根据入院时的临床因素估计治疗价格
方法:处理数据变量的相关性，处理空值，对重要变量进行特征工程，运行统计测试以了解因变量对目标变量的影响，并创建最佳多元回归模型以估计治疗价格
输出:治疗费用最高的数据变量
输出表明因变量和目标变量(治疗费用)之间的影响关系图片来源:作者
4.现成的项目
诊断为前列腺癌患者的生存分析
生存分析是回归的一个分支，允许量化一组预测因子对生存的影响。当我们需要分析某个事件发生之前的预期持续时间时，比如死亡或机器故障，就需要用到这个模型。
数据: PHI(受保护健康信息)——数据不公开
问题陈述:确定前列腺癌患者的 7 年生存率
方法:数据清理和特征工程识别诊断一年后未存活患者的症状。对诊断为前列腺癌的患者进行生存分析。
输出:识别重要的生存风险因素
输出是患者出现症状或接受最高风险因素治疗时的风险百分比图片来源:作者
5.可视化项目
用数据讲故事是现在和未来，并且会一直持续下去。
数据可视化是传达您的故事和从未见过的数据的潜在洞察力的最有效方式之一。任何包含医疗保健数据点的数据集都可以用几个问题语句来可视化。比如说—
- 在一个城市住院的时间长度
- 美国医疗支出
- 急诊室入院分析
小努力大有作为！
- 商业头脑就是一切
- 理解你的问题陈述，就像给企业增加价值一样
- 如果你花 80%的时间清理数据，那你就做对了
- 在每个步骤记录你的项目，并在 GitHub、Tableau Public 和 Public 平台上分享
这就是我的博客的结尾。感谢您的阅读！请在评论中告诉我你感兴趣的项目，你的数据之旅，以及 2022 年你想要什么！
如果你喜欢看这样的故事，可以考虑从这个 链接 注册成为一名中等会员！
数据帐篷快乐！
Rashi 是一名来自芝加哥的数据奇才，他喜欢将数据可视化，并创造富有洞察力的故事来传达商业见解。她是一名全职的医疗保健数据分析师，周末喝一杯好咖啡，写关于数据的博客……
熊猫的 5 个隐藏秘密改善你的工作流程
原文：https://towardsdatascience.com/5-hidden-secrets-of-pandas-to-improve-your-workflow-9f2bbebe584a
探索熊猫图书馆中隐藏的珍宝
Joshua Reddekopp 在 Unsplash 上拍摄的照片
Pandas 是 Python 中数据分析的精华库！该库使复杂的数据分析变得非常简单。然而，图书馆里有许多隐藏的宝石被藏了起来。在这篇文章中，你将学习五个顶级的功能和方法来改善你的熊猫工作流程。
本教程结束时，您将学会:
- 如何提高阅读 Excel 文件的能力
- 如何掌握缺失数据
- 如何使用分类数据节省空间和改进功能
- 如何将连续变量转换为分类变量
- 如何使用逗号分隔的调查数据
我们开始吧！
像冠军一样阅读 Excel 文件
在许多情况下，您将从读取 Excel 文件开始分析。与读取整个文件、删除列、转换数据类型和处理缺失值不同，您可以一次性完成所有这些工作！
在许多情况下，积极主动地了解如何读取数据可以提高代码的性能，并使其更易于阅读。让我们来看一个有一些怪癖的数据集:
要使用的 Excel 报表
在上面的报告中，我们可以注意到一些事情:
- 数据直到第 3 行才开始
- 有一个随机列不包含任何数据
- 我们有并不真正丢失的丢失数据，只是简单地标记为
MISSING - 我们有多种数据类型
让我们看看如何使用强大的pd.read_excel()函数一次性处理所有这些。接下来，可以在这里随意下载虚构的数据集(来源:作者创建)。
让我们来分解一下我们的代码做了什么:
skiprows=指示熊猫跳过规定的行数usecols=允许我们传入想要阅读的列。在这种情况下，我们使用 Excel 范围！na_values=指定哪些值代表缺失值。这也可以是一个值列表。dtype=接受一个column:datatype键值对的字典。这里有一点预览，用于将数据作为分类读取！
在下一节中，您将了解如何更优雅地处理丢失的数据。
改进缺失数据的处理
Pandas 为处理缺失数据提供了一个有用的缺失方法，即.fillna()方法。从表面上看，这个方法似乎很简单——事实也的确如此。也就是说，该方法还提供了相当多有用的功能，尤其是在与其他方法结合使用时。
看看下面的数据集:
含有大量缺失数据的数据集(来源:Nik Piepenbreier)
在上面的数据集中，我们有两列，每列都有缺失的数据:
Category栏缺少可以填写的类别Amount列缺少数据。在这种情况下，考虑到每个类别中值的差异，用单个值填充可能没有意义。
让我们先处理一下Category列:.fillna()方法有一个可选参数，它提供了向前填充数据的选项。我们可以通过在函数中传递method='ffill'来做到这一点。
Amount列稍微复杂一点:我们可能不想用任何给定值填充它。由于书籍和计算机的金额相差很大，简单地使用该列的平均值是不合适的。不过，我们可以用各组的平均值来填补缺失值。
让我们看看如何在熊猫身上处理这两种操作:
在上面的代码中，我们能够使用.groupby()方法和.fillna()方法来填充每组数据的平均值。
使用分类数据节省空间
在这一节中，我们将深入分类数据的奇妙世界！虽然这听起来可能不令人兴奋，但分类数据提供了很多很多好处。这些优势中有两个关键优势:
- 节省了大量空间，而且
- 向数据中添加自定义排序顺序
让我们先看看如何创建分类数据及其节省空间的属性。在第一部分中，我们在读取 Excel 文件时分配了数据类型。虽然这是最聪明的处理方式，但是让我们稍后转换一个列，看看这样可以节省多少空间。
从上面的代码中我们可以看到，即使在一个小的数据集中，将数据转换成分类数据也节省了将近 1/3 的空间！
在下一节中，您将学习如何使用分类数据通过逻辑类别对数据进行排序！
创建有序类别
基于您在上一节中学到的分类数据，我们甚至可以创建有序分类数据。当您有逻辑分类数据(如质量等级或衬衫尺寸)时，这很有帮助。
让我们看看如何在熊猫身上做到这一点:
让我们来分解一下上面的代码实现了什么:
- 我们创建了一个包含两列的数据框架
- 我们创建了一个分类数据类型，它按照逻辑顺序对我们的类别进行排序
- 然后，我们将列转换为这种新的数据类型
在那里，我们通过以下方式演示这种有序分类数据类型的功能:
- 按衬衫尺寸排序——数据不是按字母顺序排序，而是按我们之前提供的顺序排序
- 我们使用一个类别过滤我们的数据框架，并计算总销售额
展开您的调查数据
在最后一节中，我们将了解如何更好地处理调查数据，或者更确切地说，如何处理列中逗号分隔的值。
在许多情况下，从测量工具中提取的数据将在一个单元格中包含一个选项列表，用逗号分隔。这通常不是很好的工作，但谢天谢地熊猫来救援了！
我们可以看到，在我们的数据帧中，Sports列并不是特别有用。我们可以通过使用.explode()方法将这个列转换成更有用的东西，如下所示:
我们可以看到，通过分解我们的Sports列，我们创建了该列的非透视版本，在那里我们可以随心所欲地过滤！
结论
在本教程中，我们探索了熊猫图书馆的五个隐藏的瑰宝。该库充满了惊人的功能，让您以多种不同的方式探索和操作您的数据。
从多边形创建新要素的 5 个想法
原文：https://towardsdatascience.com/5-ideas-to-create-new-features-from-polygons-f8f902f5ad8f
如何从带有 Shapely 的 WKT 字符串中获取面积和其他特征
作者图片
多边形数据在数据科学的各种应用中非常有用。例如，在 2022 数据科学中的女性数据马拉松第二阶段挑战中，其中一个数据集包含建筑物平面图的多边形数据，以确定其能源使用情况。
这些多边形可以用公知文本(WKT)格式来表示。WKT 格式是一种表示几何 2D 和 3D 对象(如点、线、多边形等)的标记语言。在 WKT 格式中，多边形由多边形中每个点的坐标表示。以下是几个 WKT 格式的面描述示例:
"POLYGON ((10 10, 90 10, 90 90, 10 90, 10 10))""POLYGON ((10 10, 90 10, 90 90, 10 90, 10 10), (20 20, 50 20, 50 50, 20 50, 20 20))"
虽然您可以解析来自 WKT 字符串的多边形坐标，并自己编写函数来计算多边形的面积或周长等特性，但 Shapely 软件包 [1]会开箱即用地为您完成所有这些工作。您可以简单地将面的 WKT 字符串加载到形状良好的面中，如下所示:
import shapely.wkt
from shapely.geometry import Polygonwkt_string = "POLYGON ((10 10, 20 10, 20 80, 90 80, 90 90, 10 90, 10 10))"
polygon = shapely.wkt.loads(wkt_string)
在本文中，我们将首先看看如何用 Shapely 包或 Matplotlib 库可视化一个多边形。然后，我们将从 WKT 格式的多边形中学习五个特征工程思想。
如果您想尝试本文中描述的技术，您可以从我的相关 Kaggle 笔记本中下载或派生本文的代码。
如何可视化一个多边形
你可能想对多边形做的第一件事是将它可视化，以便对它有更好的直觉。您可以通过 Shapely 包直接绘制多边形，也可以使用 Matplotlib 库通过其坐标绘制多边形。
通过造型包装实现可视化
为了直观显示多边形的形状，可以在加载后显示形状良好的多边形。
wkt_string = "POLYGON ((10 10, 20 10, 20 80, 90 80, 90 90, 10 90, 10 10))"
polygon = shapely.wkt.loads(wkt_string)
polygon
用 Shapely 可视化 WKT 字符串的多边形(图片由作者从 Kaggle 获得)
wkt_string = "POLYGON ((10 10, 90 10, 90 90, 10 90, 10 10), (20 20, 50 20, 50 50, 20 50, 20 20))"
polygon = shapely.wkt.loads(wkt_string)
polygon
用 Shapely 可视化 WKT 字符串的多边形(图片由作者从 Kaggle 获得)
虽然这是一个快捷的选择，但它的缺点是你无法获得关于坐标的直觉。
通过 Matplotlib 库实现可视化
要通过坐标可视化多边形，除了 Shapely 包之外，还可以使用 Matplotlib 库。
import matplotlib.pyplot as plt
从形状良好的多边形中，您可以从外部(polygon.exterior.xy)和内部(polygon.interiors[i].xy)的xy属性中检索多边形的 x 和 y 坐标。“外部”是多边形的外部形状。此外，一个多边形可以没有，一个或多个“内部”，这是外部较小的多边形。您可以根据其xy属性绘制多边形的外部和内部，如下所示:
def plot_polygon(wkt_string, ax=None):
polygon = shapely.wkt.loads(wkt_string)
# Retrieve and plot x and y coordinates of exterior
x, y = polygon.exterior.xy
ax.plot(x, y, color = 'black')
# Retrieve and plot x and y coordinates of interior
for interior in polygon.interiors:
x, y = interior.xy
ax.plot(x, y, color = 'black')
ax.set_title(wkt_string.replace("),", "),\n"), fontsize=14)
ax.set_xlim([0,100])
ax.set_ylim([0,100])
来自 WKT 字符串的多边形用 Matplotlib 可视化(图片由作者来自 Kaggle )
1.求多边形的面积
将多边形可视化后，您可能想知道如何根据给定的坐标计算多边形的面积。不用编写自己的函数来计算它，您可以简单地从 Shapely 多边形的属性area中检索多边形的面积。
让我们绘制几个多边形并验证它们的面积。在左侧下方，您可以看到一个边长为 80 个单位的二次多边形。Shapely 多边形的area属性返回值 6400，相当于 80 乘以 80。因此是正确的。
area = polygon.area
多边形的面积(图片来自作者从 Kaggle
然而，并不是所有的多边形都是封闭的形状。有时，多边形可以有“洞”，这在 Shapely 包中被称为内部。如果我们绘制并验证它们的面积，我们可以看到有内部的多边形的面积小于没有任何内部的多边形的面积，因为内部的面积是从外部的面积中减去的。
多边形的面积(图片由作者从 Kaggle 获得)
2.求多边形的周长
接下来，您可能想知道如何根据给定的坐标计算多边形的周长。
让我们再次绘制几个多边形并验证它们的周长。下面，你可以再一次看到上一个例子中的边长为 80 个单位的二次多边形。Shapely 多边形的length属性返回值 320，相当于 80 的四倍。因此是正确的。
同样，一些多边形有内部。如果我们检索具有内部的多边形的周长，周长会增加，因为内部的周长增加了。您可以为外周和内周创建新要素，如下所示:
perimeter = polygon.length
outer_perimeter = polygon.exterior.length
inner_perimeter = perimeter - outer_perimeter
多边形的周长(图片作者来自 Kaggle
3.获取多边形内部的数量
正如你已经看到的，多边形可以有所谓的内部。这些是外部多边形中的洞。Shapely 包提供了一个内饰数组polygon.interiors，从中您可以获得内饰的数量:
num_interiors = len(list(polygon.interiors))
多边形内部的数量(图片由作者从 Kaggle 获得)
4.检查多边形是否无效
当多边形的内部与外部相交或者内部位于外部之外时，多边形可能无效。当您绘制一个形状良好的多边形时，该包通过多边形的颜色来指示该多边形是有效还是无效。有效的多边形以绿色填充，而无效的多边形以红色显示。可以根据面的有效性创建新要素。为此，您可以使用布尔属性is_valid。
validity = polygon.is_valid
多边形的有效性(作者图片来自 Kaggle
5.创建多边形的遮罩
除了根据面的属性创建新要素之外，如果想要对面应用一些计算机视觉模型，还可以根据面的坐标创建掩膜。
上面的函数以 NumPy 数组的形式返回多边形遮罩。
array([[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
...,
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0],
[0, 0, 0, ..., 0, 0, 0]], dtype=uint8)
如果我们绘制 NumPy 数组，掩码如下所示:
多边形的遮罩(图片由作者来自 Kaggle )
结论
WKT 格式是描述多边形的一种简单方式。借助 Shapely 包，您可以将 WKT 字符串转换为 Shapely 多边形对象，并利用其属性。在本文中，您已经学习了如何使用 Matplotlib 和/或 Shapely 可视化多边形。此外，我们还讨论了从面创建新要素的五种方法:
- 多边形的面积
- 多边形的周长
- 多边形内部的数目
- 多边形的有效性
- 多边形的遮罩
如果您想尝试本文中描述的技术，您可以从我的相关 Kaggle 笔记本中下载或派生本文的代码。
喜欢这个故事吗？
要阅读更多来自我和其他作家的故事，请在 Medium 上注册。报名时可以使用我的 推荐链接 支持我。我将收取佣金，不需要你额外付费。
https://medium.com/@iamleonie/membership
在LinkedIn和ka ggle！
参考
[1] S. Gillies，“匀称的用户手册。”https://shapely.readthedocs.io/en/stable/manual.html(2022 年 6 月 20 日访问)
2022 年朱利安节上你可能错过的 5 个重要演讲
原文：https://towardsdatascience.com/5-important-talks-you-might-have-missed-at-juliacon-2022-7d9601b5dfa5
作者图片
7 月 30 日星期六，JuliaCon 2022 以一年一度的虚拟黑客马拉松结束。作为会议组织者之一，在 JuliaCon 期间的现场会议日通常是灭火和确保一切顺利进行。以至于我往往会错过很多精彩的演讲，不得不在会议结束后回去努力赶上进度。2022 年也不例外，所以这里有 5 个我错过的演讲，你可能也错过了！
VS 代码中的 Julia 新功能🆕
VS Code 是 Julia 编程社区官方支持的 IDE。每年在 JuliaCon，从事 IDE 扩展的核心团队都会聚在一起，分享去年的成果。今年的演讲突出了
- 新的探查器用户界面
- 新表格查看器用户界面
- 改进的绘图库
- 云索引基础设施
- 与 JuliaFormatter 整合。
- 新的测试资源管理器 UI 集成。
还有更多！如果 VS 代码是你的 Julia 开发的日常驱动，你会想看看这个。
编辑:我和我的合著者很高兴地告诉大家，我们的新书《朱丽亚速成教程》已经开始预售了:
https://logankilpatrick.gumroad.com/l/juliacrashcourse
是什么让编程语言成功？(和杰瑞米·霍华德一起)🤔
2022 年 JuliaCon 的主题演讲人之一是 fast.ai 的联合创始人杰瑞米·霍华德。在这次演讲中，杰里米强调了编程语言生态系统需要做些什么才能取得长期成功。Jeremy 还提供了关于一些功能的具体反馈，这些功能将使他更有可能在日常生活中使用 Julia。其中一个让我印象深刻的想法是，Julia 需要能够支持可以在任何操作系统上运行的小的可执行文件。现在，有 PackageCompiler.jl，但它还没有达到通用阶段。
点击此处查看杰里米的完整演讲:
《朱丽亚的状态》( 2022 年)与杰夫·贝赞森🎤
一年一度的 JuliaCon 传统的一部分是让核心的 Julia 开发团队展示他们在过去一年中所做的工作，以及在不久的将来的期望。今年，杰夫·贝赞森(朱丽亚的联合创作者)发表了《朱丽亚的状态》。实际上，他在演讲接近一半时提到，Jeremy 的主题演讲非常及时，因为有许多正在进行的工作可以使使用 Julia 创建可执行文件的能力更简单，占用空间也更小。
Jeff 还讲述了其他重要话题，如:
- 编译器的主要更新
- Julia 中的线程路线图
- 发布时间表概述
以及许多其他有趣的(和编译器相关的)主题。查看下面的完整对话:
Makie.jl 的交互式数据可视化👀
Makie.jl 毫无疑问是生态系统中最受欢迎的 Julia 包之一，因为你可以使用它创建令人惊叹的交互式视觉效果。接下来的这个演讲实际上是一个两个半小时的研讨会，由西蒙·达尼什和朱利叶斯·克鲁格主持。他们以 Makie 生态系统的一些令人兴奋的更新开始，包括:
- Makie 正在过渡到它自己的 GitHub 组织
- Makie 正在向 NumFOCUS 申请成为官方项目
- 新的 Makie 网站！
Simon 还深入分析了 Makie 项目多年来的融资情况，这突出表明(至少对我来说)Makie 需要继续成熟，这样才能以更可持续的方式吸引资金。在那之后，Simon 和 Julius 给了 Makie 一个非常棒的介绍，以及如何做所有你想做的交互式可视化的事情。
你可以亲自去看看，也可以去参观一下即将成为 https://beautiful.makie.org 的https://lazarusa.github.io/BeautifulMakie/:
包预编译的改进📈
没有一个 JuliaCon 会是成功的，没有一个亮点，尽管在 2021 年做了令人难以置信的工作，Julia 开发者仍然以某种方式找到了如何在 2022 年更快地在 Julia 中制作不同的东西。在今年的补充中，核心开发人员 Tim Holy 和 Valentin Churvay (JuliaCon 联合主席)首先对他们所做的工作进行了激励，为什么 Julia 现在这么快，以及哪里可以改进。
Tim 随后快速演示了 Julia 1.8 中的包预编译改进，并展示了它们如何在整个生态系统中显著减少预编译时间。对于 Julia 生态系统中的人来说，包预编译一直是一件痛苦的事情，所以这些进步是朝着正确方向迈出的一大步。
图片来自下面的链接视频
有趣的是,《时代》杂志显示，对于包加载，Python 仍然比 Julia 快一个数量级，而对于情节渲染，它快 2 个数量级。这是一件大事，也是人们一直说的让他们不愿意转投朱莉娅的原因。要了解蒂姆和瓦伦丁对这些问题的解决方案，请查看完整的谈话:
简而言之，朱利安 2022🐿
今年的 JuliaCon 是社区包的又一个惊人进步，有这么多精彩的演讲(如你所见，很难将这篇文章限制在 5 篇)。你可能也会对组委会今年发布的 JuliaCon 2022 亮点帖子感兴趣，该帖子分享了该活动的许多重要指标:https://Julia lang . org/blog/2022/08/Julia con-highlights-2022/
你也可以在这里找到完整的 JuliaCon talk 播放列表(超过 290 个视频):https://www.youtube.com/playlist?list = PLP 8 IP y9 HNA 6 trg 6 qjablj-frmi 9 CP 7 gsx
最后一个小提示，如果你喜欢使用 Julia，并且想帮助宣传这种语言，可以看看我关于“如何成为一个有效的 Julia 宣传者”的演讲:
2023 年 JuliaCon 大会上见！
编写原始文档的 5 个非常有用的技巧
原文：https://towardsdatascience.com/5-incredibly-useful-tips-for-writing-pristine-documentation-803155ae4f45
我用来改进软件文档的一些技术
(图片由 Pixabay 上的曼弗雷德斯塔格
介绍
文档是软件工程中极其重要的一部分，但却很容易被忽视。创建软件有如此多的事情要做，以至于在打包和发布软件时，文档看起来是如此微不足道，如此简单。然而，这种对文档及其重要性的理解有些欺骗性，因为文档是软件最重要的组成部分之一。
如果你用 Python 编写了有史以来最伟大的模块，这并不重要，如果没有关于这个模块的文档，人们很可能不会使用它。人们不会使用没有任何文档的模块的原因是因为他们只是
不会知道怎么做。
也就是说，虽然实现编写文档的目标可能看起来很简单，但是编写真正优秀的文档的细微差别和秘密可能比人们最初想象的要深入得多。也就是说，虽然没有人能在一夜之间成为有史以来最伟大的软件文档编制者，特别是在软件工程涉及的所有其他更密集的事情上，但这里有一些有用的指导原则，每当我编程时，我都用它们来创建更好的文档。
№1:输入/输出
我认为在编写文档时首先应该考虑的是输入和输出。知道什么进入了一个方法，什么从它自己那里出来，可以完全指导一个方法的使用。定义函数或类型及其功能的三个最重要的因素是
- 名字
- 输入
- 输出
也就是说，虽然不能选择公开名称，但输入和输出肯定应该是有声的。输入将允许你的软件用户知道为你的函数提供什么样的参数。另一方面，输出将帮助他们知道这个方法实际上是干什么的。返回应该被看作是函数的使命，因此实际上应该由函数名和输出来描述。也就是说，将所有这些结合到你的文档中对于制作人们可以实际使用的软件是绝对重要的。
№2:提供例子
为了证明例子的有用性，请允许我提出一个大多数程序员都经历过的场景。每当你第一次开始编程，你在谷歌上搜索关于一个特定的包、函数或主题的信息时，什么对你帮助最大？以我的经验来看，无论什么时候开始，当谈到理解呼叫的基础时，例子是绝对必要的。
也就是说，虽然示例肯定可以帮助更有经验的开发人员，但我认为它们主要是为了向更广泛的受众开放该函数的用法，包括那些可能不太熟悉软件的人。文档需要为人们编写，而不一定是为开发人员编写——因为这让人们更容易学会如何使用软件。一个你可以复制和粘贴的东西的用法的例子，将会提供很多关于你的功能和它可能实际做什么的上下文。
№3:以粗体显示的参数
我最近决定做的一个改变是在整个函数描述中用粗体字按名称写参数。我已经开始这样做了，因为我认为这使输入变得非常明显。每当你解释什么被操纵以及如何被操纵时，让这些输入易于识别并通过文本突出出来是很有意义的。虽然所有这些都是可选的，这一个也不例外，但这是我真正喜欢的一个。也就是说，并不是所有的编程语言都支持文档字符串中的完全标记语法，所以在一些语言中，这个选项可能不适用。
№4:更短的描述
我想分享的下一个技巧是让你的文档名称的描述变得更小。没有人想读一整篇关于函数内部和外部的文章。我认为在很多方面，这又回到了提取。你的职能应该用最多五句话来描述。任何附加的句子都会使函数的目标变得复杂。
此外，如果你正在记录一个需要整个段落来描述的功能，它可能需要被最小化。也就是说，理想的情况是函数完成单一目标，而不是可能需要在整个代码中重复的复杂任务。我在编程中使用了一种技术，让我所有的软件都适合这个团队，这种技术叫做抽取。实际上，我写了一篇文章，详细介绍了提取以及如何使用它，如果您愿意，可以在这里阅读:
[## 更多的方法意味着更好的代码
towardsdatascience.com](/more-methods-means-better-code-1d3b237f6cf2)
№5:网络文档
作为一名计算机程序员，你可能知道开发人员多久去一次谷歌，查询他们想要的信息。也就是说，虽然代码内文档浏览更好，但网页更容易理解。Web 文档也非常容易制作。例如，如果你是一名 Python 程序员，这里有一篇来自 James Briggs 的关于数据科学的精彩文章，详细介绍了如何用 Python 自动化你的文档:
如果您碰巧写了 Julia，我有一篇详细介绍如何使用 Documenter.jl 的文章，您可能也会感兴趣:
对于大多数语言来说，通常都有能够做到这一点的包。这非常方便，从头开始创建文档站点是一件麻烦的事情——这已经是过去的事情了！也就是说，对于一个实际上想要使用的包来说，没有任何理由不拥有这样一个案例的 web 文档！
№6:(加分)遵循语言习惯
你可能使用的每一种高级编程语言都有比你更大的用户群。也就是说，看看周围，看看你的语言的标准库，看看其他模块是如何记录事情的，这可能是一个好主意。在整个生态系统中保持事物的一致性是非常重要的，在文档方面尤其如此。
也就是说，让你的文档遵循编写你的软件的编程语言的典型惯例是很有意义的。这将允许该语言的用户自动认同您的文档，因为他们对它很熟悉。此外，用户将确切地知道在哪里寻找文档中的什么信息，这是很方便的，因为通常当某人寻找关于某事的信息时，他们可能只寻找他们对给定功能的问题的特定答案。
结论
从表面上看，文档是一件非常简单的事情，但是编写优秀的文档需要大量的实践——甚至是潜在的工作。也就是说，更好地编写优秀的文档需要建议、考虑，最重要的是，
时间。
随着时间的推移，肯定会有所改善！甚至我自己也在不断提高自己的技能，在这方面还有很长的路要走。在很长一段时间内改进你的软件工程团队的各个方面并没有错。非常感谢您阅读我的文章，我希望它对您的软件之旅有所帮助！
面向初学者的 5 个 Julia 项目——用 Julia 开始编码的简单方法
原文：https://towardsdatascience.com/5-julia-projects-for-beginners-easy-ideas-to-get-started-coding-in-julia-938b823a0a08
作者图片
Julia 被用于许多真正有影响力和有趣的挑战，如机器学习和数据科学。但是在你接触复杂的东西之前，有必要探索一下基础知识，为你打下坚实的基础。在本教程中，我们将通过构建 5 个小型的 Julia 项目来复习 Julia 的一些基础知识:
- 疯狂的 Libs ✍️
- 猜数字游戏💯
- 电脑号码猜测器🤖
- 岩石🗿，纸张📃、剪刀✂️
- 密码生成器🎫
如果你还没有下载 Julia，请前往 https://julialang.org/downloads/或观看此视频:
编辑:我和我的合著者很高兴地告诉大家，我们的新书《朱莉娅速成班》已经开始预售了
https://logankilpatrick.gumroad.com/l/juliacrashcourse
疯狂的 Libs ✍️
在 Mad Libs 中，用户被提示输入不同类型的单词。然后，用户输入的随机单词被插入到一个句子中。这导致了一些非常古怪和有趣的结果。让我们尝试使用 Julia 编写一个简单版本的程序。
在这个问题的核心，我们想要连接(或加在一起)多个字符串，以便我们从带有一些占位符的句子到带有用户输入的句子。在 Julia 中实现这一点的最简单方法是字符串插值:
**julia>** name = "Logan""Logan"**julia>** new_string = "Hello, my name is $name""Hello, my name is Logan"
这里我们可以看到，我们定义的 name 变量可以通过使用$name语法插入到字符串中。
有很多其他方法可以做到这一点，比如使用string函数:
**julia>** new_string = string("Hello, my name is ", name)"Hello, my name is Logan"
但是在这种情况下，字符串插值似乎是最直接、最易读的。
既然我们知道如何设置字符串，我们现在需要提示用户输入。为此，我们可以如下使用readline功能:
**julia>** my_name = readline()Logan"Logan"
readline函数接受用户的单行输入，这正是我们想要使用的。让我们将所有这些放在一个简单的例子中:
在这个例子中，我们接触到了处理字符串、定义函数、打印语句等等！如前所述，有很多其他的方法来做我们上面做的事情，如果你想了解更多关于使用字符串的内容，请查阅茱莉亚文档:https://docs.julialang.org/en/v1/manual/strings/
猜数字游戏💯
在这个游戏中，我们将不得不产生一个随机数，然后猜猜它是什么。首先，我们需要生成一个随机数。像往常一样，有许多方法可以做到这一点，但最直接的方法是:
**julia>** rand(1:10)4
rand函数将您想要使用的数字范围作为您将生成的数字的界限。在这种情况下，我们将范围设置为包含这两个数字的1-10。
为了让这个例子正常工作，我们需要讨论的另一个新主题是 while 循环。while 循环的基本结构是:
while some_condition is true
do something
end
该循环将继续迭代，直到不再满足 while 循环的条件。您将很快看到我们如何使用它来不断提示用户输入一个数字，直到他们猜对为止。
最后，为了让我们简单一点，我们将添加一个 if 语句，告诉我们是否猜测到一个接近目标数字的数字。Julia 中 if 语句的结构是:
if some_condition is true
do something
end
最大的区别是 if 语句只检查一次，然后就完成了。除非 if 语句在循环中，否则不会重新检查初始条件。
现在我们已经有了基本的概念，让我们看看构建数字猜测器的实际代码。在检查下面的解决方案之前，我恳求你自己尝试一下。编码快乐！🎉
电脑号码猜测器🤖
既然我们已经看到了让我们尝试并猜测计算机随机生成的东西是什么样子，那么让我们看看计算机是否能比我们做得更好。在这个游戏中，我们将选择一个数字，然后看看计算机需要多长时间来猜测这个数字。为此，我们将引入一些新概念，如随机模块和 for 循环。
让我们从思考如何让计算机不重复地猜测随机数开始。一个简单的解决方案是使用rand函数，但问题是没有内置的方法来确保计算机不会多次猜测同一个数字，因为它毕竟是随机的！
我们可以通过结合collect功能和shuffle功能来解决这个问题。我们首先定义一个随机种子:
**julia>** rng = MersenneTwister(1234);
随机种子使得随机数生成器产生可重复的结果。接下来，我们需要定义所有可能的猜测:
**julia>** a = collect(1:50)
50-element Vector{Int64}:123⋮
我们现在需要使用shuffle函数使猜测变得随机:
**julia>** using Random
**julia>** shuffle(rng, a)50-element Vector{Int64}:41231349⋮
现在我们有了随机猜测设置，是时候一次一个地循环它们，看看这个数字是否等于用户输入的目标。同样，在查看以下解决方案之前，请尝试一下:
岩石🗿，纸张📃、剪刀✂️
如果你从未玩过石头、剪子、布，那你就错过了！基本要点是你试图用石头、布或剪刀击败你的对手。在这个游戏中，石头打败剪刀，剪刀打败布，布打败石头。如果两个人做同一个，你再来一次。
在这个例子中，我们将对着电脑玩石头、布、剪刀。我们还将使用sleep函数引入一个短暂的延迟，就好像有人在大声朗读单词一样(如果你亲自演奏，你就会这么做)。
sleep 函数接收一个数字，代表你想睡多久(以秒为单位)。我们可以用这个函数或循环来减慢速度，就像你在这个游戏中看到的那样。
sleep(1) # Sleep for 1 second
让我们也探索一下我在编写本教程时发现的一个函数，Base.prompt ，它帮助我们做我们之前使用readline所做的事情。然而，在这种情况下，prompt auto 在行尾附加了一个:，这样我们就可以避免打印和用户输入各占两行:
human_move = Base.prompt("Please enter 🗿, 📃, or ✂️")
我们还需要使用一个elseif来使这个示例游戏工作。为了完整起见，我们可以将if、elseif和else链接在一起。尝试将 if 条件、提示和休眠放在一起以获得期望的行为，然后查看下面的代码:
作者拍摄的视频
密码生成器🎫
警告:请勿使用此代码生成真实密码！
在这个数据泄露层出不穷、每个网站都使用同一个密码的时代，拥有一个安全的密码非常重要。在本例中，我们将生成任意数量的长度可变的密码。鉴于这可能需要很长时间，我们还将添加一个外部包 progress bars . JL:https://github.com/cloud-oak/ProgressBars.jl来直观地显示我们的 for 循环的进度。如果您以前从未添加过外部包，可以考虑看看这个强大的教程:
https://logankilpatrick.medium.com/the-most-underrated-feature-of-the-julia-programming-language-the-package-manager-652065f45a3a
要添加 Julia 包，请打开 REPL 并键入]，然后键入add ProgressBars。之后，正如我们对 Random 模块所做的那样(注意我们不需要添加它，因为它是基本 Julia 的一部分)，我们可以说using ProgressBars来加载它。
我们将在这里介绍的主要新概念是向量/数组。在 Julia 中，我们可以将任何类型放入数组。要创建空数组，我们需要:
password_holder = []
然后添加一些东西，我们使用push!函数，你将在下面的例子中看到。如前所述，我们将使用 ProgressBars 包在屏幕上显示进度。请注意，Julia 的速度非常快，它可能不会显示加载屏幕，除非您手动调用睡眠功能或输入大量密码来减慢速度。查看自述文件，了解在实践中使用它的示例。与另一个示例一样，在分析下面的示例之前，尝试将一些代码放在一起:
包扎🎁
我希望你和我一样，在工作和阅读这些项目时获得了很多乐趣。如果你想制作你自己版本的这篇文章，制作一些小的 Julia 项目并与世界分享，请这样做，并在这里打开一个 PR:https://github . com/logankilpatrick/10-Julia-Projects-for-初学者我可以很容易地改变回购名称，以适应小项目的涌入。
我还会注意到，像这样的练习也是潜在地为朱莉娅做贡献的一个很好的方式。在我写这篇文章的时候，我为茱莉亚开了两个公关，我认为这将有助于改善开发者的体验:https://github.com/JuliaLang/julia/pull/43635和https://github.com/JuliaLang/julia/pull/43640。
如果你喜欢这个教程，让我们在推特上联系:https://twitter.com/OfficialLoganK
防止 ML 项目失败的 24 小时黑客马拉松的 5 点经验
原文：https://towardsdatascience.com/5-learnings-from-a-24-hour-hackathon-to-prevent-ml-project-failures-f659ea998a42
从项目中产生价值需要的不仅仅是数据、编码技能和工具
照片由安德里亚·皮亚卡迪奥拍摄，由派克斯拍摄
根据 Gartner 的数据，超过 85%的数据科学项目失败了，只有 20%的分析洞察交付了业务成果。我可以从我为公司提供建议的经验中确认这些比率。
不，这不是数据。既不是缺失数据，也不是坏数据。
苏黎世联邦理工学院的数据日以 2022 年 5 月 15 日的 24 小时机器学习黑客马拉松结束，我是四场比赛之一的评委。
作为这样一个比赛的评审团成员，我有幸获得了许多真知灼见。除了解决方案本身，还有一些关于不同团队如何解决问题以及他们在黑客马拉松中的旅程的学习。
要解决的挑战是什么？
在我们的比赛中，团队必须建立一个旅游保险聊天机器人，帮助旅行者在新冠肺炎驱动的世界中应对不同的挑战，每个国家都有几个要求，旅行选项，以及在所有这些情况下的保险范围和援助。
- 如果我儿子感染了新冠肺炎病毒，酒店的隔离费用包括在内吗？
- 当航班因疫情而取消时，我可以获得什么支持？
- 我在哪些国家有旅行保险？
当你想到旅游保险聊天机器人时，这些精心设计的问题就会浮现在你的脑海中。
现实看起来不一样。问题不是写出来的，仅仅有一个‘高级搜索’工具是找不到答案的。保险合同的条款和条件是有解释空间的法律文本。有时需要个人帮助，事故是可以预防的。
答案、帮助和用户体验需要个性化。
各队得到了什么？
所有团队都可以使用 AWS 工具来构建聊天机器人、NLP 和机器学习。还有一个注解是，这只是“初学者工具包”，使用任何工具和方法都没有限制，不依赖于任何提供者。
已经给出了保险单数据和一组要回答的问题。
评估解决方案的标准是什么？
我们根据以下五个标准评估解决方案
(1)对已回答(给定)的问题集的定量评分
(2)对额外测试的棘手问题的定性评估
(3)解决方案的创造性
(4)解决方案的范围和深度
(5)包括讲故事在内的推介
(1)和(2)评估了解决方案的技术准确性，(3)将技术方法与业务方面联系起来。(4)介绍了通过该解决方案为不同利益相关方创造的价值，以及(5)展示了如何向管理层或业务部门展示和销售该解决方案的技巧
这是一种常见的价值链评估，它推动管理层决定是否实施解决方案。
我们最终通过几种不同的方法得到了广泛的解决方案。有些有效，有些无效。
所以，问题是:
是什么将表现最好的团队与其他团队区分开来？
1。首先澄清业务问题，然后定义如何将其转化为技术解决方案。
在你从技术上开始任何事情之前，首先要清楚要解决的问题的任何细节，可用的数据，以及如何将其转化为机器学习方法。
在这第一步，弄清楚
商业问题。用简明的业务问题陈述来总结它，着重回答一个特定的问题。它包含问题——需求——影响。这使团队与目标保持一致，并为与利益相关者的沟通奠定了基础(“推介”)。
确定受项目和解决方案影响的所有直接和间接利益相关者。您为其构建解决方案的不仅仅是保险公司的客户。
分析业务问题是否适用于分析解决方案、工具以及可用的数据。
根据先前的分析提炼业务问题陈述，如果必要，描述已知的或可能的约束。
确定商业利益。业务收益有定量的(如 ROI、NPV)和定性的(如内部技能发展)。它指导项目中的优先级设置，因为您总是有时间和资源限制。
就业务问题陈述、资源、时间框架、绩效指标和预算获得利益相关方的同意。在我们的案例中，利用可用的专家和参与者来就评估标准和对问题、工具和约束的解释达成一致。
表现最好的团队在这一步投入了相当多的时间。
2。从不同利益相关者的角度思考。
即使解决方案应该解决旅行者的问题，也要考虑其他利益相关者。
贵公司引入这种解决方案的成本和收益是什么？维护解决方案的人员(例如 IT 人员)的情况如何？有哪些技能和资源可用？还有哪些利益相关者受到影响？旅行社？酒店？保险公司客户的家庭成员？律师和监管者？(数据保护，或给出错误建议时的法律纠纷)。
确定所有利益相关者的兴趣、需求、限制和潜在的积极/消极影响
- 客户/顾客
- 潜在客户
- 自己的公司
- 公司的 IT
- 企业中的决策者
获胜的团队会这样做，并考虑他们对解决方案的见解。其中一些团队构建了不同的角色来反映和测试解决方案的设计。他们根据利益相关者的分析证明了黑客马拉松期间做出的所有决策的合理性。
3。UX 很重要。
以客户为中心是关键。在没有给出用户体验的情况下，再好的技术方案也不会有任何用途和需求。
根据用户和您自己的行为评估解决方案。只要有可能，就和客户一起测试。让他们测试你的解决方案，观察用户的行为。
他们如何操作工具？结果是如何使用的？
这种方法创造了各种功能。当请求不明确时，一个团队实施了解释。另一个人对公开信息进行了交叉检查，以警告潜在的变化情况和额外的信息链接。当解决方案无法解决某个特定问题时，其中一个实现了回退，即循环中可能的手动交互，而另一个则直接给出了手动帮助的选项。最后一个在某些触发表达式出现时自动将用户重新路由到个人服务。
所有这些团队都这样做了，因为他们评估了用户与解决方案的交互。一个小组在推介中表示，“我们本可以在技术准确性方面走得更远，但在休息了更长时间并对其有了新的看法后，我们决定专注于用户体验。”
4。与工具(和方法)无关。
一切从提供的“初学者工具包”开始。他们在设计解决方案和测试各种工具时发现了缺陷。一半的团队试图在给定的生态系统中修复它们，另一半则开始尝试集成其他可用的工具:AWS 与 Azure tools、GPT-3、TensorFlow 集成最新的相似性分析研究，等等。
这两种方法都可以修复缺陷。区别在于优先级。表现最好的团队没有重新发明轮子，而是专注于他们的战略和独特的 USP。仅仅因为你也能开发它，并不意味着你必须重建它。
因此，利用现有资源，不要重复发明轮子。你不应该把自己局限在一个供应商上，而把时间投入到开发已经可用的东西上。专注于您独特的 USP、战略优势和增值知识。不是技术使你与众不同，而是你与众不同之处的巧妙结合。这会让你在市场上获得成功。
5。总是根据真实案例测试结果。
在每门机器学习课程中，我们都学习如何在数据上训练和测试模型。然后我们有一些量化的措施，选择一两个，选择模型。但这还不够。
获胜的队伍做了大量的工作。他们采用了许多不同的单一案例，并在现实世界中进行测试。他们不是深入的保险专家，所以他们联系了这些专家，并与他们一起逐案评估许多数据点、结果以及什么应该是正确的结果。他们积累了大量关于现实世界的知识，以及他们的解决方案如何对现实世界做出反应，并相应地调整算法。结果的准确性令人印象深刻。
你需要深入细节，挑选单一的观察和结果。从简单的案例开始，逐步增加复杂性。将每个观察和结果与真实世界逐一比较。这将极大地增强您对如何改进超调、参数设置和校准的理解。
连接圆点
这五个步骤应该适用于任何数据科学项目。它们阐明了项目失败的主要原因。根据我在不同行业的经验，我可以说 90%未能成功部署的数据科学项目至少在这五个方面存在问题。
我对你下一个数据科学项目的建议是:
- 全面了解业务问题
- 考虑所有不同的直接和间接利益相关者以及他们的需求和困难
- 用户体验决定你解决方案的成败
- 不要重新发明轮子，而是专注于你的战略 USP
- 对照现实世界进行测试
这极大地提高了成功率。
你喜欢我的故事吗？
通过 加入我的电子邮件列表 ， 每次我发布新的故事，你都会收到通知，通过成为媒介会员，你将拥有 访问数千篇鼓舞人心的文章 。
阅读下一篇: 医疗保健中机器学习应用的 10 个激动人心的例子7 个不需要任何编码技能的牛逼数据科学工作作为数据科学初学者应该避免的 10 个错误
5 个鲜为人知的 Python 库可以帮助您的下一个数据科学项目
原文：https://towardsdatascience.com/5-less-known-python-libraries-that-can-help-in-your-next-data-science-project-5970a81b32de
使用这些库减少数据科学工作流程中的时间。
图片来自 Shutterstock，授权给 Frank Andrade
Python 有数百个库，让我们不用从头开始写代码。
有一些众所周知的数据科学库，如 pandas 和 numpy，我们离不开它们，但也有一些不太知名的库可以在您从事某个项目时助您一臂之力。
在本文中，我将向您展示一些您可能从未听说过的 Python 库，但它们可以帮助您加速数据分析、轻松创建报告、生成假数据等等。
1.米托:在几秒钟内完成数据分析
米托是一个 Python 库，允许我们在几秒钟内完成数据分析。有了米托，我们不需要记住 Pandas 的所有方法和函数，但是我们可以像处理 Excel 电子表格一样处理数据帧。
最好的部分是这个 Python 库为我们生成代码，所以我们甚至可以看到正在使用什么方法和函数。
假设我们有一个数据框架，我们想插入一个新列并更改它的名称。对于熊猫，我们会使用.insert和.rename方法，但是对于米托，这就像点击几下鼠标一样简单。
作者图片
记住，要使用米托，我们需要安装 Python 和 Jupyter Notebook 或 Jupyter Lab。要安装它，请在终端上运行以下命令。
python -m pip install mitoinstaller
python -m mitoinstaller install
如果你想知道更多关于米托的事情，请查阅官方文件。
2.SweetViz:一行代码的数据可视化
有时我们需要进行快速的探索性数据分析，但是我们没有时间或者不想写代码。在这些情况下，我们可以使用名为 sweetviz 的 Python 库生成多个可视化。
借助 sweetviz，我们可以快速构建一个具有漂亮可视化效果的报告，以分析数据集中的每一列。报告以 HTML 文件的形式导出，我们可以在工作目录中找到该文件。
要安装此库，请运行以下命令:
*# pip*
pip install sweetviz
一旦我们安装了库，我们就可以生成我们的报告。让我们用关于学生表现的数据集来测试一下，你可以在这里找到。
**import** sweetviz **as** sv **import** pandas **as** pd*# read dataset*
df = pd.read_csv('StudentsPerformance.csv')*# generate report*
my_report = sv.analyze(df)
my_report.show_html()
下面是生成的报告。
作者图片
3.Faker:为你的项目生成虚假数据
你有没有想过生成假数据来构建自己的数据集？在过去，我可以很容易地用 Numpy 生成随机数，但当我必须生成姓名，电子邮件和地址时，没有一个简单的解决方案…直到我发现了 Faker 库。
这个库帮助我们为项目生成假数据。使用 Faker 可以轻松生成工作、公司、社会安全号、住所、出生日期等数据。
**from** faker **import** Fakerfake = Faker()>>> fake.name()
Corey Edwards>>> fake.job()
Nurse, mental health>>> fake.company()
Patel-Porter>>> fake.ssn()
656-80-3536>>> fake.email()
stacey69@example.org>>> fake.address()
057 Bailey Club Suite 230 Jamieshire, WA 93828
默认情况下，区域设置是“en_US”，但是您可以在实例化该类时更改它。
**from** faker **import** Fakerfake = Faker('es_ES')>>> fake.name()
'Amada Grande Valero'>>> fake.residence()
'Camino de Sandalio Segarra 61 Puerta 6 \nTeruel, 13054'
要安装此库，请运行以下命令:
*# pip*
pip install faker*# conda*
conda install -c conda-forge faker
4.OpenDataset:用一行代码获取工作目录中的数据集
如果你曾经跟随教程和指南，你可能已经下载了几十个 Kaggle 数据集到你的电脑上。这意味着进入 Kaggle，下载文件，并将其拖到您的工作目录中。这没什么大不了的，但是当你不得不重复这些步骤很多次时，就变得乏味了。
在这里，OpenDataset 可以提供帮助。不需要遵循前面提到的所有步骤，只需安装这个 Python 库，导入它，只需一行代码，数据集就可以使用了。
首先，让我们安装库。
*# pip*
pip install opendatasets
现在让我们导入它并下载一个数据集。在下面的例子中，我将下载一个国际足联数据集。
**import** opendatasets **as** oddataset_url = "https://www.kaggle.com/datasets/stefanoleone992/fifa-20-complete-player-dataset"od.download(dataset_url)
但这还不是全部！您还可以在dataset_url中引入 Google Drive 链接或原始文件 URL。
如果你想了解更多关于这个库的信息，可以查看它的文档。
5.表情符号:将表情符号转换成文本
如果你曾经不得不从 Twitter 这样的社交网站中提取数据，你知道你不仅会找到纯文本，还会找到包含有用信息的表情符号。问题是，在提取推文时，我们可能会丢失表情符号。
举个例子，如果有人发微博说“生日快乐！❤️🎁“如果你提取那条推文，你会错过心脏和礼物表情符号内的信息。
幸运的是，我们可以使用一个名为表情符号的库来将表情符号转换为文本。首先，我们要安装表情库。
*# pip*
pip install emoji*# conda*
conda install -c conda-forge emoji
现在，我们可以将带有表情符号的推文转换成文本:
**import** emoji>>> emoji.demojize("Happy birthday! ️️❤️🎁")
Happy birthday! :red_heart::wrapped_gift:
我们也可以把表情符号的名字变成表情符号:
**import** emoji>>> emoji.emojize('Python is :thumbs_up:')
Python is 👍
你可以在这里看到一系列表情符号及其名称。
Bonus - PyForest:用 1 行代码导入 40 个 python 库(适合个人项目)
有多少次你试图使用 Python 库中的方法或函数，却发现还没有导入它？
这种情况过去经常发生在我身上，但现在我有时会使用一个名为 PyForest 的库，它只用一行代码就导入了用于数据分析的著名 Python 库。
要安装它，请运行下面的命令。
*# pip*
pip install pyforest
要导入它，请使用下面的代码。
**from** pyforest **import** *
如果您想查看所有导入的库，运行lazy_imports()。您将看到诸如 numpy、seaborn、matplotlib、pandas 等库被导入(实际上，如果您使用它们，它们也会被导入)。
顺便说一下，这个库仅供个人使用。如果您与团队合作并使用 PyForest，其他人不会知道您导入了哪些库。
用 Python 学习数据科学？ 通过加入我的 10k+人电子邮件列表，获取我的免费 Python for Data Science 备忘单。
如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你用我的链接注册，我会赚一小笔佣金，不需要你额外付费。
https://frank-andrade.medium.com/membership
作为一名数据科学家，我从一名机器学习工程师那里学到了 5 个教训
原文：https://towardsdatascience.com/5-lessons-i-learned-as-a-data-scientist-from-a-machine-learning-engineer-a8c3ebb223fd
如何解决数据科学问题并提供客户想要的解决方案
在 Unsplash 上拍摄的 ThisisEngineering RAEng
我 2017 年的第一份实习是一家投行的软件工程师。作为一名编程经验有限的数学系学生，我并没有马上适应这个角色。最初，我在一个机器学习工程团队工作，但我发现我对实际建造我打算生产的模型更感兴趣。所以我进入了数据科学家的角色。
快进 5 年，出于各种原因，我回到了机器学习工程，但我带着我在过去的数据科学家生涯中学到的经验教训。
你会注意到，我的外卖都不涉及必要的技术技能。我不是说理解每个模型是如何工作的，也不是建议每周读 10 篇论文。相反，我关注的是如何解决数据科学问题，以及如何最好地与您的客户互动。因此，这里是我作为数据科学家的五大收获。
1.你甚至需要机器学习吗？
机器学习和人工智能是流行语。我们每天都听到这些技术是如何“改变业务的！”，“优化流程！”、“自动化什么的！”。通常情况下，那些处于领导地位的人要么读到人工智能，认为它是解决他们所有问题的神奇解决方案，要么他们被迫采用它，只是因为他们可以说他们使用它。
根据我的经验，我发现终端用户并不在乎你是否使用了机器学习模型或基于规则的逻辑，只要它解决了他们的问题。
人工智能可以而且应该被应用的用例有很多。但是 ML 很可能会更贵，耗时更长，也更复杂。
2.问题的根本原因是什么？
作为一名以顾问身份工作的数据科学家，我一次又一次听到客户说:
“我们有这个问题，我们需要人工智能来解决它”
你需要真正理解潜在的问题，而不是只看表面的问题陈述，然后一头扎进解决方案。与客户坐下来，尽可能多地询问他们遇到的棘手问题。有时你一开始遇到的问题并不是根本原因。也许通过解决根本原因，你可以避免修补一个可能以另一种形式再次出现的问题。
在考虑实施解决方案之前，您必须花费大量时间进行探索性的数据分析。就这一点而言，你应该花时间彻底了解客户的数据；定期向客户展示调查结果，提出问题(尤其是在数据不熟悉的领域)并确认假设。
3.越简单越好
当然，神经网络及其各种风格都很酷，但有时你需要的只是一个简单的回归模型。更复杂的模型需要更多的时间来构建，需要更高水平的专业知识来构建和维护，并且通常更难解释结果。
4.尽快将您的代码从笔记本中取出并放入 Python 模块中
Jupyter 笔记本是探索数据和进行快速实验的完美之选。然而，没过多久，这些笔记本就变得大得离谱，让人摸不着头脑。如果你发现自己在不同的笔记本中重写功能，在团队成员之间发送代码，或者想“嗯，在复制的笔记本 3 或 4 中有这样的逻辑吗？”那么可能是时候做一个 Python 模块，把那些函数放在里面了。
反复使用的助手函数通常放在 utils.py 文件中。将代码放入 Python 模块更简洁，当您更新函数并将代码推送到存储库时，更容易看到发生了什么变化。
5.讲述一个客户真正关心的故事
我曾多次对底层模型及其工作方式感到兴奋，然后想与利益相关者分享这一点。但是你必须考虑你的目标受众。大多数客户可能不想了解 LSTM 是如何工作的，你不应该浪费你和他们的时间来解释它(除非他们真的想知道！).
作为一名数据科学家，在向利益相关者展示见解和结果时，我喜欢认为我在向他们讲述一个故事。谈论更广泛的商业背景，提醒他们你正在试图解决的问题和原因。强调解决这一问题的商业价值，并在您引导他们完成解决方案的步骤时，不断参考问题陈述。
总而言之，这些提示旨在帮助指导您完成整个数据科学之旅。确定问题是否需要人工智能，发现问题的根本原因，设计一个简单的解决方案，在编写解决方案时保持代码的组织性，并最终以有意义的方式将其交付给客户。
Python 熊猫过滤字符串的 5 种方法
原文：https://towardsdatascience.com/5-methods-for-filtering-strings-with-python-pandas-ebe4746dcc74
举例说明
(照片由 Neven Krcmarek 在 Unsplash 上拍摄)
我们经常处理文本数据，这比数字数据需要更多的清理。为了从文本数据中提取有用的信息，我们通常需要执行几个预处理和过滤步骤。
Pandas 库有许多函数和方法，使得处理文本数据变得容易和简单。在本文中，我们将学习 5 种不同的方法，可用于过滤文本数据(即字符串):
- 包含一系列字符
- 字符串的长度
- 以特定的字符序列开始或结束
- 数字或字母数字字符
- 特定字符序列出现的次数
让我们从从 csv 文件创建数据帧开始。
import pandas as pddf = pd.read_csv("example.csv")df
df(作者图片)
数据帧包含 6 行和 4 列。我们将使用不同的方法来过滤该数据帧中的行。这些方法可以通过 Pandas 的 str 访问器获得。
我们要做的第一个过滤操作是检查字符串是否包含特定的单词或字符序列。我们可以使用 contains 方法来完成这项任务。以下代码行查找描述字段包含“二手车”的行。
df[df["description"].str.contains("used car")]
(图片由作者提供)
二手车实际上有另一行，但描述中不包含“二手车”表达式。为了找到这个数据框架中的所有二手车，我们可以分别查找单词“used”和“car”。
df[df["description"].str.contains("used") &
df["description"].str.contains("car")]
(图片由作者提供)
最后一行包含“汽车”和“二手”，但不在一起。
我们也可以根据字符串的长度进行过滤。假设我们只对长度超过 15 个字符的描述感兴趣。我们可以通过使用内置的 len 函数来执行此操作，如下所示:
df[df["description"].apply(lambda x: len(x) > 15)]
我们编写一个 lambda 表达式，其中包括用 len 函数检查长度，并将其应用于 description 列中的每一行。更实际、更有效的方法是通过 str 访问器使用 len 方法。
df[df["description"].str.len() > 15]
输出将是相同的:
(图片由作者提供)
我们可以分别使用 startswith 和 endswith 方法基于字符串的第一个或最后一个字母进行过滤。
df[df["lot"].str.startswith("A")]
(图片由作者提供)
这些方法也能够检查前 n 个字符。例如，我们可以选择批次值以“A-0”开头的行:
df[df["lot"].str.startswith("A-0")]
(图片由作者提供)
Python 有一些内置的字符串函数，可以用来过滤熊猫数据帧中的字符串值。例如，在 price 列中，有一些非数字字符，比如$和 k。
df[df["price"].apply(lambda x: x.isnumeric()==True)]
(图片由作者提供)
如果我们正在寻找字母数字字符(即只有字母和数字)，我们可以使用 isalphanum 函数。
count 方法计算单个字符或一系列字符出现的次数。在某些情况下，这对于过滤可能会很方便。例如，您可能正在查找不多次包含一个字符序列的字符串。
我们可以将描述栏中的“已用”一词统计如下:
df["description"].str.count("used")**# output**
0 1
1 0
2 1
3 1
4 1
5 0
Name: description, dtype: int64
如果您想使用它进行过滤，只需将它与如下值进行比较:
df[df["description"].str.count("used") < 1]
我们已经介绍了基于字符串值的熊猫数据帧的 5 种不同方式。我们倾向于更加重视数字数据，但是文本数据也同样重要，它承载了大量有价值的信息。因此，能够清理和预处理文本数据对于数据分析和建模至关重要。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅https://sonery.medium.com/subscribe如果你想在我发表新文章时收到电子邮件。
感谢您的阅读。如果您有任何反馈，请告诉我。
交叉验证的 5 分钟指南
原文：https://towardsdatascience.com/5-minute-guide-to-cross-validation-be3c5b0ae693
有哪些策略？你应该如何以及何时使用它们？
保留交叉验证。作者图片
机器学习模型的目标是从具体的例子中学习的一般模式。在现实生活中，所有数据都包含一定程度的随机变化和噪声。为了学习数据集中的一般潜在模式并对新数据进行良好预测，重要的是机器学习模型能够区分信号和噪声。
机器学习模型的目标是从具体的例子中学习一般的模式。
当机器学习模型学习了太多的噪声，并且无法对以前看不见的例子进行归纳和做出良好的预测时，这被称为过度拟合。如果出现过度拟合，则很有可能存在一个模型，该模型在训练时表现出高度的准确性，但在部署到现实世界中时表现很差。
检查并防止过度拟合是开发机器学习模型的关键步骤。发现过度拟合的一般技术称为交叉验证。交叉验证包括保留训练数据的样本，稍后您可以在这些样本上测试您的模型，以检查它是否能够很好地概括。
有几种技术可以执行交叉验证，在这篇文章的剩余部分，我将给出一个最常用方法的初学者指南。这将包括代码示例、每种技术的优缺点以及何时使用每种方法的正确时间的总结。
坚持方法
最简单的交叉验证技术被称为保留法。这种技术包括将数据分成三部分。训练集和测试集用于迭代地执行模型选择和超参数调整。例如，在训练样本上训练特定算法，然后用测试集评估性能。
一旦选择了最佳算法和参数，验证集将用作优化模型性能的最终评估。这里的假设是，如果模型在测试集上过度拟合，这将在最终验证集的较低分数中显示出来。
维持交叉验证。作者图片
下面的代码使用了 Scikit-learn train_test_split函数两次。首先将整个数据集分为训练集和测试集，然后再次将训练集分为训练集和验证集。
优点
保持交叉验证的计算开销很小，因此即使在非常大的数据集上也可以快速返回结果。
缺点
与接下来讨论的技术相比，它的鲁棒性要差得多。
拒绝验证尤其不适合非常小的数据集，因为一般来说，将数据集分成三部分会留下太少的样本来训练。
k 倍
K-fold 交叉验证是一种更稳健的模型评估方法。利用这种技术，可用的训练数据被随机打乱并分成选定数量的样本(k)。k 的值可以是任何合理的数，通常选择 10。单个观测值只包含在一个折叠中，因此折叠之间没有重叠。
k-fold 算法迭代地使用每个折叠作为测试集，同时使用剩余的数据进行训练。然后评估每个 k 样本的模型性能。通常，在对所有折叠进行训练和评估后，计算模型得分的平均值。
k 倍交叉验证。作者图片
下面显示的代码使用 Scit-kit Learn KFold函数将训练数据分成 10 份。然后在每个折叠上迭代训练随机森林分类器，最后使用 Yellowbrick 库来显示模型分数的视觉摘要。
分数 K 倍交叉验证。作者图片
优点
比维持交叉验证健壮得多。
可用于小型数据集。
缺点
计算开销很大。
留一个出来
留一法是另一种交叉验证技术。该方法首先从单个观察值创建一个测试集，其余的观察值形成训练集。使用该训练集拟合模型，并在单次观察的基础上评估其性能。对整个数据集中的每个观测重复这个过程。类似于 k-fold，然后计算评估度量的平均值。
下面的代码使用 Scikit-Learn 的LeaveOneOut方法分割数据集，并 n 次拟合一个随机森林分类器。然后打印平均分数。
平均准确度分数。作者图片
优点
特别适合非常小的数据集。
缺点
计算开销很大。通常，这种技术不适合大型数据集。
在本文中，我讨论了最流行的交叉验证策略。这里描述的所有技术都用于评估模型的性能，特别强调检查过度拟合。
所涉及的方法各有利弊，这意味着它们更适合某些任务、数据集和问题陈述。前一段时间，我发现了一个关于栈交换的极好的总结，它给出了使用每种技术的正确情况的建议。我在下面总结了这一点，但这要归功于用户等密度振荡——本文底部的完整引用。
保留交叉验证:如果您的数据集大于 1，000，000 个示例，则应使用保留交叉验证，除非您拥有强大的计算能力，在这种情况下，可以使用 k = 5 的 k-fold。对于 20 到 100 个示例之间的较小数据集，可以使用较大的 k。
K-fold 交叉验证:如果您的数据集在 100 到 1，000，000 个示例之间，请使用 k = 5。如果计算能力有限，并且您的数据集为> 10，000 行，则应考虑保留交叉验证。
留一交叉验证:用于非常小的数据集，通常少于 20 个例子。
感谢阅读！
承认
等密度振荡(https://stats . stack exchange . com/users/25029/Isopycnal-Oscillation)，保留验证与交叉验证，URL(版本:2021–09–07):https://stats.stackexchange.com/q/307849
5 分钟书面解释:食品人工智能第一部分
原文：https://towardsdatascience.com/5-minute-paper-explanations-food-ai-part-i-9276b61873c1
im2recipe 论文“学习烹饪食谱和食物图像的跨模态嵌入”的直观深入分析
乍得·蒙塔诺在 Unsplash 上的照片
问题简介
欢迎来到我的新系列论文讲解！你可能会问那里有什么不同？好吧，我不会涵盖流行或著名的论文，而是选择机器学习研究中的子(子)领域，并通过这些文章绘制他们的研究进展。
让我们开始吧——今天，我们将了解一下的论文(发表于 2018 年)，该论文介绍了用于食品中机器学习研究的庞大数据集，并介绍了 im2recipe 检索问题。
问题陈述:给定一幅食物的图像(想象一下你最喜欢的食物！)，检索制作该食物的食谱。为了能够做到这一点，使模型学习相应的图像和配方嵌入，将这些嵌入转换到共享的联合嵌入空间，并在给定图像的情况下最小化测量配方检索性能的损失。很简单，对吧？
对于不知道什么是跨通道的人来说:通道是我们输入模型的一种信息源。它可以是视频、图像、文本、音频等。在 im2recipe 中，我们有图像和文本。所以，我们用两种模态工作，从一种到另一种，因此是跨模态的。
领域背景和改进
以前有过将食物与人工智能或机器学习交叉的研究。大型数据集的一个突出例子是 Food-101 和介绍它的论文。这是一个关于食物图像的分类问题。相比之下， im2recipe 论文介绍了一个检索问题和一个更丰富的数据集。
Food-101 数据集类的一些示例(图片由作者提供)
如果我们看到 Food-101 数据集中的类，它只包含关于食物名称的信息。在名为 Recipe1M，的 im2recipe 数据集中，我们不仅有更多的数据点，而且这些数据点包括食物图片、标题(名称)、制作说明和配料。
这种丰富数据的一个优势是，我们现在能够通过它的说明和成分对食谱的状态有一种逐步的信息。我们可以知道一种配料是生的、烤的、炸的等等。并且理论上能够用一个好的模型在这些阶段学习相应的不同图像。
资料组
庞大的 Recipe1M 数据集包含 100 万份食谱食材和说明，以及那些从烹饪网站上提取和下载的准备好的食谱的 80 万张相应图像，并组织成 JSON 格式文件。
在文本情态中，我们有一个标题、一份配料清单和一系列准备菜肴的说明。在第二种模式中，我们有 RGB/JPEG 格式的与配方相关联的任何图像。
配方的文本数据示例。id 映射到相应配方的图像(作者的图像)
作者对收集的数据集进行了一些分析:
- 数据集中的平均食谱由九种成分组成，它们在十个指令的过程中被转化。
- 配方图像对的精确副本已被删除
- 16，000 种成分中的 4，000 种占数据中成分出现次数的 95%
体系结构
如前所述，有两种形式和四种类型的数据:标题、成分、说明和图像。我们以不同的方式嵌入它们。
如下所示，首先使用双向 LSTM 从数据的成分列表中提取成分，然后编码成 word2vec 表示。
学习成分嵌入(作者图片)
使用 word2vec 中使用的跳过方法对每个指令元素进行编码，其中每个指令以其之前和之后的指令为目标，并且编码被优化以改善这些相邻指令的预测。这里所做的修改是也引入了开始和结束指令标记。接下来，这些单独的指令编码通过 LSTM 来产生指令嵌入。
学习指导嵌入(作者图片)
接下来，这些指令和成分嵌入通过仿射变换(具有学习的权重和偏差的线性变换)连接和变换到共享嵌入空间。对于作为从预训练的 ResNet-50 / VGG-16 提取的特征的图像嵌入也是如此。
学习共享嵌入(作者图片)
语义规则化
除了上述主要架构之外，作者还通过使联合嵌入模型(具有共享权重)学习将任何食谱图像或文本信息分类到 Food-101 类之一来执行正则化。直观上，这确保了模型已经粗略地知道了一些嵌入聚类(就这些类而言),并且它不会试图为每个图像-配方对创建一个聚类，因此不会过度拟合。因为权重在两个模态之间共享，所以这也确保了所学习的图像-食谱对嵌入彼此对齐(我们不会得到同一道菜的图像和文本信息的单独聚类)。
然而，该论文的作者发现，Food-101 类只覆盖了 Recipe1M 数据集的 13%，因此，他们用来自 Recipe1M 训练集(清理后)的食谱标题中的 946 个最常见的二元模型来扩充它。通过这样做，他们实现了 50%的覆盖率
损失函数
余弦相似度与利润损失(图片来自论文，作者)
所使用的损失函数是具有边际损失的余弦相似性。训练是以成对的方式进行的，类似于如何训练三重损失函数——用正和负图像配方对。这种训练方法和上述损失函数确保了正对( y=1 )的图像配方嵌入更靠近在一起(差值更接近于 0)，而负对被推得更远，其间有固定的余量 α 。
增加语义正则化
组合余弦和正则化损失(图片来自论文，作者)
通过添加正则化损失以获得组合，我们可以直观地看到学习过程将正对的图像配方嵌入集合在一起，将负对的图像配方嵌入推得更远，同时始终通过共享权重和分类保持图像配方对嵌入彼此对齐。具体地，如果 cᵣ和 cᵥ(分别用于图像和配方嵌入的分类预测)不同，则正则化损失将增加，否则将减少。
实验和结果
这是报告结果的方式:在从测试集中随机选择的 1000 个配方图像对的子集上。我们重复实验 10 次并记录平均结果。我们报告了所有检索实验的中值排序(MedR)和顶部 K 的召回率(R@K)。
如果我为每个图像检索 100 个食谱，那么中值等级就是每个实验中每对正确食谱出现的位置的中值。类似地，im2recipe 任务中的 R@5 表示在前 5 名中检索到相应配方的所有图像查询的百分比，因此越高越好。
基线结果是使用 CCA 的结果。顺便说一下，CCA 是一种很像 PCA 的技术，但是用于多组变量。典型相关分析确定了一组典型变量，即每组内变量的正交线性组合，它们最好地解释了组内和组间的可变性。详细的结果和消融研究可以在论文中看到，并且是不言自明的
我想在这里重点关注的是对嵌入的分析。作者使用向量算法提出，模型学习的嵌入具有语义意义。下面是一个例子。
word2vec 类型向量算法显示了学习嵌入的语义(图片来自论文，作者)
作者还使用给定神经元的顶部激活图像、成分列表和烹饪说明来提取和可视化局部单元激活，并专注于对这些单元的激活贡献最大的特定图像和文本区域。结果如下
学习特定的单元检测器。单元 352 学习检测图像和指令文本中的奶油，这也示出了模型跨模态对齐(图像来自论文，由作者)
这是我开始的一个新系列的一部分，关于直觉的论文解释。我将在行业中挑选一个子域，并浏览该域中的论文。如果你喜欢我写的东西，可以考虑订阅或者关注我这里或者在 Linkedin 或者 Twitter 上与我联系！关于我之前文章的代码，请访问我的 GitHub
5 分钟的书面解释:食品人工智能第二部分
原文：https://towardsdatascience.com/5-minute-paper-explanations-food-ai-part-ii-c085b2789bd1
im2recipe 相关论文“分而治之跨模态配方检索:从最近邻基线到 SoTA”的直观深入探讨
乍得·蒙塔诺在 Unsplash 上的照片
问题简介
欢迎来到人工智能食品系列论文的第二部分！上周，我写了一篇文章，解释了开创性的 im2recipe 论文，该论文将跨通道技术引入到处理与食品应用相关的机器学习中，例如使用照片搜索正确的食谱，自动确定一道菜的卡路里数，或者提高各种食谱推荐和排名系统的性能。我建议读者参考那篇文章，了解问题的介绍和动机，以及关于 Recipe1M 数据集和评估指标的详细信息。
正如上一篇文章中提到的，这些解释旨在绘制机器学习特定领域的研究进展。所以，今天，我们将关注 2019 年发表的题为“分而治之跨模态配方检索:从最近邻居基线到 SoTA”的论文。本文进一步研究了此处引入的和此处解释的的 im2recipe 问题，通过定义一个不同的和更好的基线来比较手头的检索任务。该基线旨在取代原始文件中的共同国家评估基线。
相关工作和改进
提高基线的原因是: 1) “在 1000 个食谱的测试集上，召回@1 的 CCA 基线是 14.0。这一结果在两年内被超越，翻了两番，达到 51.8。”作者认为，这更多地与“错误指定的基线”有关，而不是检索方法的真正改进。 2) 在最初的 im2recipe 论文中，模型是端到端训练的，因此很难理解模型的每个元素是如何单独执行的(这些元素是图像编码器、文本编码器等)。这可以通过建立一个概念简单且可解释的模型作为问题的基线来解决。
具体来说，模型中的检索功能是 kNN 算法的跨模式适应，称为 CkNN “应用于预先计算的图像-文本嵌入之上，其中图像和文本编码器不是使用 CkNN 进行端到端训练，而是独立使用自我监督这使得测试和分析它们在分离中的性能变得容易。
最后，作者扩展了这种方法，以获得关于该问题的一个新的最先进的性能。
论文引用的一些重要相关工作(除了 im2recipe 论文):
AdaMine Double Triplet Loss(图片由作者提供，来自论文)
- AdaMine -对准模块采用“双三重损失”作为损失函数进行改进。简单地说，这是应用于两组三元组的三元组损失:一组表示单个图像对实例，并帮助模型学习将来自单个配方的不同模态的嵌入映射在一起，另一组表示图像对实例的类别，其通过类别信息帮助模型学习哪些配方彼此相似。后者类似于 im2recipe 论文中的语义正则化。
- R2GAN——使用 GANs 帮助学习更好的图像和文本嵌入
- ACME -这是 CkNN 论文发表时的最先进水平，并使用了“GANs +跨模态三重损失一起+使用对抗学习策略的模态对齐+跨模态翻译一致性损失”。不去探究它是如何工作的细节(那可能是另一篇文章)，但重点是 CkNN 可以实现对 ACME 真正有竞争力的结果，我们很快就会看到。
体系结构
编码器
文本编码器(平均单词嵌入):平均单词嵌入是一种非常基本的文本编码方式。如下图所示。对于一个文档(可以是一个句子或一个段落或任何其他东西)，文档的嵌入是通过计算文档中单词嵌入的平均值来生成的。单词嵌入本身可以以多种方式生成。
在论文中，这样做的方式是:“说明和配料被视为文档，而类标签是配方标题中包含的最常见的单字和双字(类生成类似于 im2recipe)”。单词嵌入大小是 d=300 ，并且当它被随机初始化时，训练使用 softmax 激活，在文档中单词嵌入的平均值上具有二进制交叉熵损失来学习单词嵌入。
文本形态的平均单词嵌入架构(图片由作者提供)
图像编码器:使用 ResNet-50 的分类层之前的最后一层来获得图像嵌入，再次使用二进制交叉熵对使用来自配方标题的相同技术生成的一组类别标签进行正则化。
这里注意，为文本编码器和图像编码器生成的标签集是不同的(准确地说，文本是 3453，图像是 5036)。这样做的原因是，由于编码器是独立训练的，我们不局限于只使用图像-文本对作为数据，而是我们可以使用只包括文本或只包括图像的食谱数据。因此，对于文本和图像，我们有不同数量的数据点和不同的类。
交叉模态神经网络
CkNN 和 kNN 一样，是一个非参数模型。它充当图像-文本嵌入对准模块，并且如同该提议的系统中的其他组件一样，它被独立地应用。首先，编码器被训练以获得图像和文本嵌入，然后 CkNN 被应用于它们之上。这不同于 im2recipe 论文，在 im2 recipe 论文中，系统被端到端地训练，并且我们进行了转换以将嵌入带到共享空间。
CkNN(图片由作者提供，来自论文)
CkNN 有两个部分:一个在文本嵌入空间工作，另一个在图像嵌入空间工作。让我们看看它在文本嵌入空间是如何工作的(按照图像中的数字):[1]
- 使用文本编码器 e(T) 对一个候选文本文档(即食谱说明和配料) T 进行编码
- 使用文本嵌入空间中的余弦相似性，基于文本嵌入找到 k ₜ最近邻居，由 Rₜ 表示。
- 利用 Recipe1M 数据集提取与 Rₜ 相关联的组图像 Iₜ
- 使用图像编码器 e(I)对图像嵌入空间中的每个 I ∈ Iₜ 进行编码。
- 返回获得的图像嵌入的平均值作为结果
图像嵌入空间的相应算法是:
- 使用图像编码器 e(I) 对候选图像 I 进行编码
- 使用图像嵌入空间中的余弦相似性，基于图像嵌入找到 k ᵢ最近邻，用 R ᵢ表示。
- 利用 Recipe1M 数据集提取与 Rᵢ 关联的文本集 Tᵢ
- 使用文本编码器 e(T)对文本嵌入空间中的每个 T∈ Tᵢ 进行编码。
- 返回获得的文本嵌入的平均值作为结果
让我们把图像空间中的组件称为 Mᵢ ，把文本空间中的组件称为 Mₜ.
损失函数
CkNN 损失函数(图片由作者提供，来自论文)
损失函数基本上是在 1)图像嵌入空间和 2)文本嵌入空间中获得的图像和文本嵌入之间的距离的线性组合。轻松点。
实验和结果
我不把重点放在论文表格中可以看到的确切结果上，而是把重点放在他们的分析上。简而言之，对于新的基线 CkNN 和用于比较的其他方法，结果显示了以与原始 im2recipe 论文中相同的方式(加上也具有 10，000 的样本大小)测量的检索性能。
为了证明单独训练编码器然后将 CkNN 应用于它与在 ACME(当时的最先进技术)中端到端训练系统一样有效，使用来自相关作品的预训练图像和文本编码器的不同组合来生成嵌入，然后在其上使用 CkNN 来测量检索性能。结果表明，端到端召回率@1 为 20.6，而 CkNN 为 17.9，具有竞争力。该分析还表明，编码器的质量，而不是跨模态对齐，是改善先前研究结果背后的主要驱动力。
扩展到 SoTA
最后，受上述与 ACME 的竞争结果的鼓舞，作者在 CkNN 之上添加了他们自己的对齐模块，使用三元组损失来创建图像和文本的联合嵌入空间。
“具有一个隐藏层、丢失和批量标准化的两个前馈神经网络用带余量的三重丢失来训练:一个用于图像( gᵢ )特征，另一个用于文本( gₜ )特征。”
校准模块(作者图片，来自论文)
个人想法
看了这篇论文让我觉得深度学习并不是唯一可走的路。当然，这里使用的图像编码器很深奥，但是 ResNet 已经统治这个领域有一段时间了。实际发生的比对是一个简单的 kNN。添加一个 MLP，让你得到一个国家的最先进的性能！这是一篇聪明的论文，它采用了 im2recipe 论文中引入的跨通道概念，而不是改善结果(正如大多数论文一样)，而是从另一方面提出了问题:如果基线太低怎么办？这给了你一个理智的检查。
总之，本文重新定义了 im2recipe 任务的基线。新基线是使用非常简单的架构创建的，该架构不是端到端训练的，这简化了模型探索和模型比较。在下一篇文章中，我们将看看如何在另一篇论文中使用这个新的基线来再次提高 SoTA 性能。敬请期待！
这是我开始的一个新系列的第二部分，关于直觉的论文解释。我正在挑选行业中的一个子域，并浏览该域中的论文。如果你喜欢我写的东西，可以考虑订阅或者关注我这里或者在 Linkedin 或者 Twitter 上与我联系！关于我之前文章的代码，请访问我的 GitHub
论文引用
[1] Mikhail Fain、Andrey Ponikar、Ryan Fox 和 Danushka Bollegala，“划分和征服跨模态配方检索:从最近邻居基线到 SoTA”。2019 年更正
5 分钟的书面解释:食品人工智能第三部分
原文：https://towardsdatascience.com/5-minute-paper-explanations-food-ai-part-iii-bd7256473c4d
im2recipe 相关论文“跨通道检索和合成(X-MRS):缩小共享表征学习中的通道差距”的直观深度探讨
在 Unsplash 上由 Luisa Brimble 拍摄的照片
问题简介
欢迎来到人工智能食品系列论文的第三部分！
第一部分:“学习烹饪食谱和食物图像的跨模态嵌入”
第二部分:“分而治之的跨模态配方检索:从最近邻基线到 SoTA”
正如在以前的文章中提到的，这些解释旨在绘制机器学习的特定领域的研究进展。因此，今天，我们将关注 2020 年发表的题为“跨模态检索和合成(X-MRS):弥合共享表征学习中的模态差距”的论文。本文通过使用基于文本编码器的而不是原文中的 LSTM，以及本文中的平均单词嵌入(在第二部分中解释)，对本文中介绍的和本系列第一部分中解释的中的 im2recipe 问题进行了进一步研究。此外，X-MRS 的作者使用多语言翻译来规范模型，同时添加多语言功能，并通过生成食物图像的生成模型来显示学习嵌入的力量。
相关工作和改进
正如我们在本系列的前几部分中所看到的，以前在跨模态菜谱任务上的工作要么是端到端训练的模型，要么是预训练的编码器，这些编码器根据菜谱数据进行微调，在这些数据之上应用了跨模态对齐模块。在后一种情况下，也有对每个文本组件进行编码的方法(即标题、成分和说明)，然后连接各个嵌入物。
以前的工作还使用了一个正则化模块，主要使用一些外部数据来建立对学习到的表示的分类或聚类任务。其他一些我们没有看到的论文使用 GANs 来正则化模型。你可能会问，这是如何实现的？嗯，基于 GAN 的性能，即它生成真实食物图像的能力，正在学习的表示将被修改。在这里，gan 有效地充当解码器(从嵌入到实际图像)，并且“在高维空间中学习解码器是一项复杂的任务，这可能导致次优表示。”
作者与前述作者的方法不同之处在于:1)他们没有独立地处理和编码文本数据的不同部分；2)他们的模型是端到端训练的，不是预训练的；3)他们不使用 GANs 或设置分类任务来正则化所学习的表征。相反，他们使用多语言编码和反向翻译。
这为关注将 im2recipe 应用程序应用于世界各地不同语言的真实用例提供了机会。回译是一个概念，例如，将一个句子从英语翻译成法语，然后再翻译回英语。然后，实际上是彼此释义的原始英语句子和“回译”英语句子可以被比较并用于调整
旁白:目前世界上许多著名的超大型生成式图像模型都是文本诱导的条件图像合成模型。这意味着这些模型被训练成基于给它们的一些文本描述的编码来生成图像。这些当前的模型可以接受描述图像和合成图像的长描述，但是 X-MRS 论文的作者参考了论文，并且参考了这种类型的模型的文本描述必须很短才能使它们工作的时代。此外，没有一个文本描述像配方成分和说明那样，具有随时间而被修改的固有顺序。这是作者在从学习到的嵌入构建他们自己的图像合成模型时所做的改进。
体系结构
模型架构(作者图片，来自论文)
编码器
为了对图像进行编码，使用 ResNet-50。“ResNet-50 的最后一个全连接层由 2，1024 维全连接层代替，最后一个层与文本编码器共享”。
每个组件的文本数据不会单独处理。相反，标题、说明和成分被视为一个长文本描述，使用单词块标记器进行标记，嵌入到 768 的维度大小中，并通过 2 层 2 头变压器编码器(重点:只是变压器的编码器)。注意，这里记号赋予器的输出还包括一个【CLS】(分类)记号，它们都被修剪成只有 512 个记号来控制模型的内存占用。
那些使用过变形金刚的人会知道,[CLS]记号可以被认为是一个集合序列表示，这也是作者们所做的。[CLS]令牌的输出“在最终的 1024 维 FC 层将文本编码投影到共享表示空间之前，通过两个 1024 维 FC 层”。
GAN 合成模块
使用 GAN 背后的逻辑是双重的:1)如果学习的表示足够好，则 GAN 应该能够生成图像，除了图像是真实的之外，该图像实际上显示图像中的配方成分；2)只要在独立应用程序中使用经过训练的 GAN，如果提供了配料和说明，即使训练数据中没有，我们也能够生成给定配方的真实图像。
GAN 模块基于 StackGAN，其中“中间分辨率图像被丢弃”。GAN 的鉴别器也有一个 recipe 分类器，类似于第 1 部分中看到的利用从 Recipe1M 和其他数据集构造的类信息的分类器。接下来，如前所述，GAN 必须以文本为条件来生成图像。因此，在该模块中，配方编码通过“条件增强子网络”传递以创建条件代码，该条件代码被传递给解码器(与噪声一起)以生成图像。然后，鉴别器试图区分真假，并将图像归入正确的食谱类别。
损失函数
注意:为了更好地理解下面的内容，添加了一些符号。有关所有符号，请参考纸张。
编码器
编码损失函数(图片由作者提供，来自论文)
为了学习表示，编码器使用简单的具有余量损失的三元组，其中使用余弦相似性函数计算锚、阳性和阴性之间的相似性。该锚可以是图像或文本编码，正面将是来自相同配方的相应文本或图像编码，而反面将是来自不同配方的图像或文本编码。
锚、阳性和阴性遵循的采样策略是硬阴性挖掘。在这种情况下，被选择的否定是不同的类别，但是它与所有其他否定中的锚具有最高的相似性。
开始
鉴别器训练损失(图片由作者提供，来自论文)
如前所述，鉴别器试图区分真假，并将图像分类到正确的食谱类别中。将对应于这两个任务的损耗相加，得到最终的鉴频器损耗。损失是简单的交叉熵损失。
x ₁ 是实际的图像编码， G(v₂，z) 是生成的图像其中 z 是高斯噪声。【e(x₁~ x₁data】表示数据来自图像编码器。【e(v₂~ v₂data)表示数据来自文本编码器，然后传递给生成器。 Dᵣ 和 D𝒸 是鉴别器内部的子网络，分别代表对真假和配方类别进行分类的网络。
发电机培训损失(图片由作者提供，来自论文)
发电机损耗基本上等于 1 减去鉴别器损耗加上来自条件扩充(CA)子网络的正则项和监控项 ret。后半部分非常简单明了。
实验和结果
实验在 Recipe1M 数据集上进行。“R1M 英语(EN)食谱通过反向翻译从德语(EN- DE-EN)和俄语(EN-RU-EN)扩充而来。使用来自 fairseq 神经翻译工具箱的预训练模型获得德语、俄语和法语之间的翻译。
检索结果使用与第二部分相同的指标进行报告。对于 GAN 合成模型，除了报告对合成食品图像的检索性能外，还计算了 Fretchet 初始距离(FID)分数，该分数用于测量真实和合成图像分布之间的相似性 FID 值越低表示性能越好。
在训练和评估期间，作者进行的一些增强是:
图像增强: 1)具有一个以上样品配方的随机输入图像。2)随机选择，填充(在零、边缘复制或图像反射之间随机选择)为正方形，并调整大小为 256，或调整大小为 256。3)随机旋转 10♀4)随机裁剪到 224。5)随机水平翻转。
配方扩充: 1)在原始 en 表示和 EN-DE-EN 或 EN-RU-EN 中的反向翻译之间随机选择。2)在先前的 en 选项和 KO、DE、RU 或 FR 之间随机选择。
一如既往，准确的结果可以从论文中引用。在这里，我们重点分析结果。一个非常重要的结果是，带有基于 transformer 的文本编码器的 X-MRS 模型无法超越我们在本系列第二部分中走过的基线。
受关注的图像到配方定性前 3 名检索结果。最左边的图像是带有相应配方的查询图像。在这两种语言中，我们可以看到文本注意力图集中在最能描述图像的事物上。(图片由作者提供，来自论文)
作者还进行了消融研究，使用不同的文本数据成分测试检索性能。据观察，使用所有的信息导致最佳性能(咄！)，其次是说明+成分。这使得标题信息最少。还是那句话，不奇怪！很早的食物分类研究就已经开始仅仅使用标题，并没有取得很大进展。这里一个有趣的事情是使用数据集中的完整成分文本，而不仅仅是提取的成分名称会导致更好的检索性能。
还显示了不同语言的检索结果。这里应该注意的是，该论文的总体性能最好的检索模型也优于 CkNN 基线，它是在多语言数据上训练的，并使用英语进行检索。而且论文中也没有提到，到底是如何进行多语种培训的。
对于合成模块，测试生成图像的真实性和给定合成图像的配方的检索性能。据观察，有一些模型在生成更真实的食物图像方面做得更好，但是在多语言数据上训练的所提出的模型在检索方面最好。另外，使用合成图像的检索比使用真实图像的检索更好。
图像合成的例子。(图片由作者提供，来自论文)
因为生成器被训练为基于完整的食谱嵌入来生成食物图像，这意味着它也具有相应的文本信息，所以它比使用原始图像(不包含文本信息)时更容易具有更高的召回率。因此，为了测试图像-文本学习表示的纯度，作者进行了一项实验，他们训练生成器根据图像嵌入(而不是文本嵌入)来生成图像。他们发现生成图像的真实性没有下降，但检索性能却下降了。这是有意义的，因为现在生成的图像不包含文本信息，这表明文本和图像嵌入是独立的，但是在共享空间中足够接近，不会影响生成的图像的真实性。
使用不同语言的文本数据进行图像合成(图片由作者提供，来自论文)
个人想法
没有多语言培训的 X-MRS 模型无法超越第二部分中的 CkNN 基线，这一事实继续显示了强大的理论上合理的管道的力量，无论它使用传统方法还是现代“酷”的深层网络。也就是说，转换器的使用已经在管道中适当地完成了，在多语言数据和反向翻译的帮助下增加和规范化的想法是一个很酷的想法，也是可行的。
这是一篇更多依赖实验分析而不是理论直觉的论文。对生成的食谱图像的分析为如何分析学习到的嵌入提供了不同的视角，它甚至表明，如果学习得当，图像编码和文本编码可以互换，就像它应该的那样。
这是我开始的一个新系列的第三部分，关于直觉的论文解释。我正在挑选行业中的一个子域，并浏览该域中的论文。如果你喜欢我写的东西，可以考虑订阅或者关注我这里或者在 Linkedin 或者 Twitter 上与我联系！关于我以前文章的代码，请访问我的 GitHub
论文引用
[1] Ricardo Guerrero，Hai Xuan Pham 和 Vladimir Pavlovic，“跨模态检索和合成{(X-MRS ):在共享子空间中关闭模态
间隙”。2020 年更正
5 分钟的书面解释:食品人工智能第四部分
原文：https://towardsdatascience.com/5-minute-paper-explanations-food-ai-part-iv-902e5131fd8d
im2recipe 相关论文“用于跨模式食品检索的多模式正则化变压器解码器”的直观深入探讨
奥拉因卡·巴巴罗拉在 Unsplash 上的照片
问题简介
欢迎来到食品人工智能系列论文的第四部分，也是最后一部分！
第一部分:“学习烹饪食谱和食物图像的跨模态嵌入”
第二部分:“分而治之的跨模态配方检索:从最近邻基线到 SoTA”
第三部分:“跨通道检索和合成(X-MRS):缩小共享表征学习中的通道差距”
正如在以前的文章中提到的，这些解释旨在绘制机器学习的特定领域的研究进展。因此，今天，我们将关注 2022 年发表的名为“用于跨模态食品检索的多模态正则化变压器解码器”的论文。本文进一步研究了此处介绍的和本系列第一部分解释的中的 im2recipe 问题，主要是 1) 使用跨模态普通变压器和注意力，即注意力集中在图像和文本编码上，而不是像第三部分那样只关注文本；2)使用非常强大的视觉和语言预训练(VLP)模型剪辑；3) 使用模拟课程训练的动态三重损失；4) 使用多模态正则化技术，而不是通过第一部分中的分类任务和第三部分中的生成来正则化。
这里有一个题外话:VLP 的目标是从一个庞大的图像-文本对数据集学习多模态表示。在对 Recipe1M 数据集进行微调后，这个预训练的模型可以用于下游视觉语言任务，如本例。VLP 模型采用 CNN-Transformer 架构，用 CNN 嵌入图像，然后用 Transformer 对齐图像和文本。此处对 VLP 车型进行了很好的概述
相关工作和改进
一:在以前的论文中，我们看到文本编码可以为每个组件(成分、说明、标题)单独编码，也可以一起编码。本文所做的改进是对文本编码进行独立和共同的编码。作者首先使用分层转换器模块对组件进行单独编码，并使用这些输出来获得最终的文本编码。
第二:图像编码器不再仅仅是一个卷积神经网络，而是一个经过 VLP 任务预训练的视觉转换器。这确保了在学习图像编码的同时充分利用 transformer 的能力，而不仅仅是像以前那样学习文本编码。
三:以前，我们有一个单独的正则化模块，要么通过分类(合并 Food-101 或其他分类数据集信息)，要么通过图像生成(使生成的图像分布与实际图像分布相似)。这里，我们又有一个正则化子，但这个更复杂。它使用普通的变形器和图像和文本编码之间的交叉注意，使它们尽可能地相似，用于相同的食谱。更重要的是，这个模块只在训练时使用，在测试和推理时移除。
四:引入动态三重损失，其作用类似于课程训练
建筑:食物
整体架构(来自论文，作者)
整体架构可以在上面看到，与我们到目前为止看到的所有其他架构非常相似。我们有一个图像和一个图像编码器，相应的文本和文本编码器。然后，编码被投影到共享空间。应用一些损失，同时这些编码也被传递到“MMR”模块。该模块既作为对齐模块又作为正则化模块，从而分别通过分类来补充三元组丢失和替换 GANs /语义正则化。
图像编码器:如前所述，图像编码器是一个视觉转换器(特别是微调剪辑 ViT B/16)，确保我们也能获得图像编码转换器的好处。和以前一样，对于变形金刚，我们使用[CLS]令牌的输出作为图像的编码。
详细的文本编码器(来自论文，作者)
文本编码器:文本编码器是分层的。和第二部分一样，我们有单独的变形金刚 T 编码标题、指令和成分。在这里，说明书和配料一次编码一种配料或说明书。接下来，我们有单独的变压器 HT 对指令序列和成分编码进行编码。现在，显然单独编码每个组件会导致模型不知道它们是如何相互关联的。所以，作者使用变压器解码器 、HTD 来实现这一点。
这些解码器的工作方式是针对每个解码器，查询 Q 是相应 HT 的输出，而密钥 K 和值 V 是另外两个 HT 的输出的串联。 例如，对于成分解码器来说，查询是成分，而键和值是标题和指令的串联。这意味着我们交叉关注标题和说明上的成分。这基本上实现了不同数据格式如何编码的完全独立性，同时还能够学习它们之间的关系。
注意，对于文本，我们处理转换器的整个输出，而不仅仅是[CLS]令牌。通过对HTD 的所有输出令牌的值进行平均，将所有的平均输出连接起来，并投影到共享空间，从而获得最终的配方编码。**
多模态正则化+对齐模块(来自论文，作者)
****多模态正则化:请注意，该模块仅在训练期间使用，它取代了之前为对齐文本和图像编码而进行的在共享空间上的简单投影以及随后的对比(三元组)损失。相反，我们有一个使用交叉注意的变换器解码器，其中查询 Q 来自一个模态，而键和值 K、V(它们是相同的)来自另一个模态。
在本模块中，我们有两个子模块。图像标记增强模块(ITEM)是一个“将图像标记作为查询，将文本标记作为键和值的转换器解码器”。这“通过关注文本元素来丰富图像表征”。多模态转换器解码器(MTD)是实际上对配方令牌和增强图像令牌应用交叉关注的子模块。测量图像和文本标记之间对齐程度的匹配分数如下图所示获得。匹配分数不是以前论文中的余弦相似度，而是解码器直接输出的[0，1]范围内的分数。
MTD 匹配分数方程(图片由作者提供，来自论文)
因此，总的来说，我们有一个用于编码图像的 VLP 预训练视觉转换器，一个用于编码文本的分层转换器模块(首先用于单个组件，然后通过这些组件之间的交叉注意)。然后，图像和文本编码都被投影到一个共享空间，其中:1)图像编码通过处理文本元素的编码增强器项传递；2)增强的图像编码和文本编码通过用于计算匹配或对准分数的多模态变换器解码器。
损失函数
图像-文本匹配损失: ITM 是 BCE 损失，它跟踪图像-文本对是否匹配。计算这一损失所遵循的取样过程是硬负采矿法。我们在下面看到，这个等式与实际的 BCE 损失函数非常相似。 y 对于匹配的图文对是 1，否则是 0， s 是解码器输出的分数。然后计算这两者之间的交叉熵。
ITM 损失(图片由作者提供，来自论文)
****三重损失/增加余量损失:建议的三重损失是具有自适应余量的正常三重损失。裕度保持在可接受的范围内，当开始时裕度较小(因此更容易优化),并且逐渐变大。
现在，作者还通过对三元组使用自适应加权策略来适应动态三元组损失(称为 IncMargin ),如在 Adamine 论文中所述。通常，三重态损失的工作原理是，通过平均小批量中每个三重态的梯度来获得每个小批量的更新。问题是在许多代之后，一些三元组已经收敛，并且损失的梯度为零。使用一些数学魔法(这里不打算详述)，自适应加权策略设法给尚未收敛的三元组更多的权重。
****语义损失:作者还使用另一种三元组类型损失，其捕获给定查询图像和与查询相似的食谱图像的语义。例如，任何两个比萨饼应该比一个比萨饼和任何其他类别的另一个项目(如沙拉)更接近潜在空间。这种优化与其他优化一起直接在潜在空间中完成。这与第一部分中使用单独的分类正则化模块形成对比
语义三元组类型丢失(图片由作者提供，来自 Adamine 论文)
这里， xq 是查询， xₚ 属于与查询相同的语义类， xₙ 属于与查询不同的语义类。
全损(图片由作者提供，来自论文)
实验和结果
实验中使用的不同型号:作为图像编码器的 ViT-B/16 和 CLIP-ViT-B/16；对于配方编码器，变压器编码器有 2 层 4 头，用于分级变压器和 HT 。 HTD 使用 2 层 4 头变压器解码器(无屏蔽)。隐藏层维度被保存 512 在配方编码器中。利用输出维度 1024 的不同线性层来获得图像和配方嵌入。然后，在进入 MMR 模块之前，使用 1024 的相同输出尺寸的不同线性层来投影图像和配方标记。 项 模块由一个只有 1 层的 4 头隐藏尺寸为 1024 的变压器解码器组成。 MTD 由一个 4 层 4 头隐维 1024 的变压器解码器组成。
撇开实际数字不谈，我们可以从论文中的结果看出，使用从剪辑权重初始化的 CLIP-ViT 在这种架构中工作得最好。另一个值得注意的观察是，随着测试样本大小从 10k 开始增加，TFood 与其他产品之间的性能差异也在增加，这意味着 TFood 更具可伸缩性。
从消融研究中，验证了以下几点:1) HTD 导致更好的对准，因此证明配方成分是纠缠的，并且不应该单独编码；2) MTD 带来了额外的改进，表明多模态变压器是解决此类问题的好模块。此外，自适应三重态损耗和 ViT 也带来了显著的额外改进。
个人想法
这篇论文看起来很难理解，但实际上非常简单，因为它只使用了变压器。我认为，视觉变形金刚的发现让它受益匪浅。到处使用变压器的想法似乎也奏效了。这篇论文也更令人满意，因为作者已经能够使用 transformer 解码器来分离每个编码的学习，以及这些编码之间的关系。然而，本文方法的一个问题是计算和所需资源方面的复杂性。
这是我在直觉论文解释系列中开始的食品人工智能系列的最后一部分。我正在挑选行业中的一个子域，并浏览该域中的论文。我要写的下一个系列将是关于 VLP 模特的。如果你喜欢我写的东西，可以考虑订阅或者关注我这里或者在 Linkedin 或者 Twitter 上与我联系！有关我以前的媒体文章的代码，请访问我的 GitHub 。
论文引用
[1] Shukor，Mustafa 和 Couairon，Guillaume 和 Grechka，Asya 和 Cord，Matthieu，“用于跨模式食品检索的具有多模式调整的变压器解码器”。2022
您应该避免的 5 个最常见的 SQL 错误
原文：https://towardsdatascience.com/5-most-common-sql-mistakes-you-should-avoid-dd4eb4088f0c
了解如何加快 SQL 查询的执行速度
你应该避免的 5 个最常见的 SQL 错误
SQL 是查询关系型大数据最常用的编程语言之一。在 SQL 中，可能有多种创建数据表的方法，但了解并遵循正确的(最佳)方法非常重要，这样您就不必为执行代码而等待数小时。
在这篇博客中，我将带您了解 5 个最常见的 SQL 编程错误，为了优化您的 SQL 查询，您应该避免这些错误。
- **不要使用 Select *** : Select *输出一个数据表的所有列，这是一个开销很大的操作，会增加查询的执行时间。理想的方法是只选择子查询或输出表中的相关列。
例如，假设我们想从 Orders 表中获取订单 id，那么我们应该只选择 order id 列，而不是使用 select *选择所有列。
2.不要用‘Having’代替‘where’:Having 子句用于对聚合列(sum、min、max 等)应用过滤器。)使用 group by 操作创建。但是有时，程序员也使用‘having’子句(而不是‘where’子句)来过滤非聚集列。
例如，为了查找雇员 id 为 3 的雇员执行的订单总数，使用' having '子句进行筛选将会得到意外的结果。
3.不要使用‘where’进行连接:有些人使用‘where’子句执行内部连接，而不是使用‘inner join’子句。尽管两种语法的性能相似(查询优化的结果)，但由于以下原因，不建议使用“where”子句进行联接:
I .在过滤和连接中使用“where”子句会影响可读性和理解。
二。用于连接的“where”子句的用法非常有限，因为除了内部连接之外，它不能执行任何其他连接。
4.不使用 Distinct:Distinct 子句用于通过删除重复行来查找与所选列对应的 Distinct 行。“Distinct”子句在 SQL 中是一个耗时的操作，替代方法是使用“group by”。例如，以下查询从 order details 表中查找订单数:
5.避免过滤中的谓词:谓词是一个等同于布尔值(即真或假)的表达式。使用谓词执行过滤操作会降低执行时间，因为谓词不使用索引(SQL 索引是一个用于快速检索的查找表)。因此，应该使用其他替代方法进行过滤。例如，如果我们要查找电话号码以(171)代码开头的供应商。
谢谢！
如果你觉得我的博客有用，那么你可以 关注我 每当我发布一个故事，你就可以直接得到通知。
如果你自己喜欢体验媒介，可以考虑通过 报名成为会员 来支持我和其他成千上万的作家。它每个月只需要 5 美元，它极大地支持了我们，作家，而且你也有机会通过你的写作赚钱。
分享几个你可能感兴趣的故事:
https://anmol3015.medium.com/write-your-sql-queries-the-right-way-9c04dfbb6499 </10-sql-operations-for-80-of-your-data-manipulation-7461c56e25f4>
现代数据质量框架中最重要的 5 件事
原文：https://towardsdatascience.com/5-most-important-things-to-include-in-a-modern-data-quality-framework-34695711c992
通过纳入这些变化，使您的数据质量框架现代化
瓦伦丁·戈蒂埃在 Unsplash 上的照片
数据质量(DQ)仍然是许多组织面临的一大挑战，尤其是那些试图实现数据堆栈现代化的组织。多年来在数据项目上的投资不足，现在让公司在的监管罚款中损失了数百万英镑。
但那是大棒——胡萝卜是什么？在监管机构挥舞大棒之前，你如何说服你的高层领导团队投资 DQ？提出一个不需要花费数百万就能实现的框架。而且还能提高公司效率，帮助创造新的创收机会，并降低风险。
今天，我们将探讨实现上述目标应纳入现代 DQ 框架的五个核心要素。
让我们开始吧:
1.数据可观察性
数据可观察性不是正在接管 DQ 吗？不完全是。拥有强大的数据可观测性背后的理念是确保基本的技术 DQ 检查作为数据流的一部分执行。我认为数据可观察性是 DQ 的一个子集，它减少了常见的技术错误，使业务最终用户得以了解。
定义基本检查，如协调、唯一性检查和模式更改，有助于在数据最终出现在分析或 ML 模型中并对业务关键流程造成更多干扰之前，提前减少大部分问题。
例如:业务最终用户不知道部分数据是否已经加载到您的临时表中。他们会抱怨他们的“数字看起来不对”。针对数据完整性的数据可观察性检查可以在问题的源头附近发现问题。
2.自我修复管道
每当出现关于潜在 DQ 问题的警报，工程师必须修复管道时，修复时间将取决于工程师的工作任务。有时，作为 ETL(提取、转换、加载)过程的一部分，可以处理预期的 DQ 问题。尽管最好的方法是从源头上解决这个问题，但有时这是不可能的，您必须对解决方案持务实态度。
一种更具创新性的方法可以用于自我修复，在这种方法中，您可以设置处理坏数据的规则，或者训练一个 ML 模型来发现糟糕的 DQ 问题。如果从管道中过滤出一行坏数据，则必须将其记录在异常表中，以确保对数据进行端到端审计。
例如:可以在管道中创建一个规则，将每列中的重复行自动过滤到一个异常表中。这将确保管道作业不会失败，并且管理员/工程师知道过滤的数据，如果他们希望调查的话。
3.智能分类
发现问题是战斗中更容易接近的部分；只会有那么多地方会出错。找到理解问题的人，然后从源头或目标上解决问题，是一个更大的挑战。
具有一致的工程、分析和业务团队责任的健壮的治理框架可以帮助明智地对 DQ 问题进行分类。无论是通过数据可观察性警报发出技术问题警报，还是使用传统的 DQ 规则发出业务问题警报。可以添加额外的 ML 层，以确保警报模型随着时间的推移了解负责的团队，并从根本上消除任何级别的人为干预。
例如:可以创建一个工作流，根据生成的警报类型，自动分配给工程/分析/业务团队。如果自动分配错误地执行了这个分配，团队可以拒绝它，导致 ML 模型从这个误报场景中学习。该模型最初也将使用大量数据进行训练，以减少错误分配。
4.实现自动化沿袭
沿袭有很多好处，包括从源到目标的数据流概览。用 DQ 问题来掩盖血统是蛋糕上的樱桃。可视化 DQ 问题出现的位置，同时智能地进行分类并将其分配给正确的团队，将大大减少修复问题的时间。
沿袭还应该超越您的数据存储，从业务流程层开始，遵循数据捕获>数据传输>数据存储>数据转换>数据消费的整个周期。这一点很重要，这样您就可以确定业务流程需要更改，以避免在整个生命周期中发送坏数据。
例如:对于 B2C 业务，可以创建一个可视化的数据谱系图，它与数据流的不同部分集成，并通过 CRM/计费工具明确地查看数据的捕获阶段。一旦坏数据通过数据流，就可以使用 1。使用 2 处理。或者用 3 赋值。
5.评分数据健康
现代 DQ 框架需要透明，因为有太多的下游依赖关系来隐藏或歪曲低质量的数据。实施针对数据健康状况的评分机制将使分析和数据科学团队了解是否值得投入时间和精力来使用这些数据来回答关键的业务问题。
如果被业务视为优先事项，评分还提供了需要补救的数据和区域的进一步可视化表示。作为整体框架的一部分，权重应适用于每个 DQ 维度，如完整性、准确性、一致性等。，最终可以生成一个分数来表示数据的健康状况。
例如:0-10 分可以应用于一个表。如果一个表有多个惟一性问题，但是已经通过了准确性检查，那么可以给它打 5 分。另一方面，如果该表通过了大部分检查，则可以给它打 9 分。数据科学团队可以就下游业务案例可接受的数据分数达成一致。数据管理团队可以设计一个计划来改善得分较低的数据的健康状况。
结论
应该始终包含 DQ 框架的基础知识，例如分析源数据和目标数据的能力，创建复杂的业务 DQ 规则的能力等。然而，鉴于大数据的挑战，使流程更加现代化/自动化且不那么痛苦的是上面强调的五点。你能在这个清单上再加一些吗？欢迎在下面的评论中分享它们。
如果你喜欢这类内容，可以看看我的其他帖子:
如果你没有订阅 Medium，可以考虑使用我的推荐链接订阅。它比网飞便宜，而且客观上能更好地利用你的时间。如果你使用我的链接，我会获得一小笔佣金，而你可以在 Medium 上获得无限的故事，这是双赢的局面。
我也定期在推特上写东西；跟着我这里。
您应该遵循的 5 个最有用的 SQL 最佳实践
原文：https://towardsdatascience.com/5-most-useful-sql-best-practices-you-should-follow-ef753a50ad26
数据科学
避免经常犯的错误以改进您的代码
照片由亚历克斯·莱昂在 Unsplash 拍摄
SQL——所有数据专业人员最重要的技能之一！🏆
考虑到 SQL 中庞大的命令集，有多种方法可以获得所需的结果数据集。然而，重要的是要知道并实现有效的、计算成本低的方法来实现你的目标。
因此，我在这里列出了作为数据专业人员应该知道的编写 SQL 查询的 5 个最佳实践。
我把这篇文章写得很短，这样你就可以很快地完成它，并掌握节省时间、编写 SQL 查询的正确方法。🏆
您可以使用此索引快速导航到您最喜欢的部分。
**·** [**Prefer using specific column names in SELECT**](#7ac8) **·** [**Use WHERE and HAVING wisely**](#8bcf) **·** [**Prioritize using SQL JOINs over WHERE**](#1db3) **·** [**Select unique records without using DISTINCT**](#669f) **·** [**Use LIKE for filtering the dataset Rows**](#bc5d)
📍注意:我使用的是 SQLite DB 浏览器&自己创建的 Dummy_Sales_Data 使用 Faker 创建的，你可以在我的 Github repo 下免费获得 MIT 许可 ！
好了，我们开始吧…🚀
首选在 SELECT 中使用特定的列名
从数据库的特定表中检索所有数据的最常见和最简单的方法是SELECT *。但是，当您试图从一个拥有数十亿行、占用 100s GBs 数据的数据集中提取数据时，这将是最昂贵的方法。
在现实世界中，数据集中的所有列很少对特定任务有用。因此，在 SELECT 语句中传递所需的列名更有意义。
例如，当您需要虚拟销售数据集中的订单 ID、数量和状态列时，SELECT * FROM Dummy_Sales_Data_v1将生成包含数据集所有行和列的输出。
然而，你只需要三列，这意味着其他由SELECT *提取的信息对你的任务没有用。
相反，当你使用正确的方法时，
**SELECT OrderID,
Quantity,
Status**
FROM Dummy_Sales_Data_v1
您将仅获得任务所需的信息，如下所示
按作者选择 SQL | Image 中的列名
在我看来，以下是您不应该使用 SELECT *的 5 个原因
🔸SQL 联接的复杂性:
当 JOIN 语句中的两个表具有相同的列名时，在联接中使用 SELECT *可能会在列名之间引入歧义。
🔸失去透明性:
SELECT *无法让您的 SQL 查询读者知道您要从哪些列获取数据。
🔸增加的网络流量:
SELECT *返回的数据量肯定会超过您的任务需求，而且这不是免费的。您的数据库和网络正在遭受损失，因为它们正在处理所有的数据。
🔸内存消耗增加:
由于处理超过所需的数据会不必要地增加内存消耗。当您在单个计算集群上与一组专业人员一起工作时，这可能会特别成问题。
🔸数据复制不正确:
将数据从一个表复制到另一个表的常用方法之一是在 INSERT 语句中使用 SELECT。当使用 SELECT *而不是特定列时，如果两个表中的列顺序不同，可能会将不正确的数据复制到新表中。
最终， 选择是不好的做法，必须避免* 。相反，使用特定的列名来编写一个易于阅读、易于调试、节省时间和内存的查询。💯
接下来，我们讨论一下为什么理解 WHERE 和 HAVING 子句的区别很重要。
明智地使用和拥有
这两个子句在 SQL 中用于逻辑过滤数据。然而，他们在工作中有一点小小的不同。
**WHERE**子句用于根据其中提到的条件选择记录，而**HAVING**子句用于根据一列或多列的聚合从组中选择记录。这就是为什么HAVING出现在GROUP BY子句之后，它本质上是对行进行分组。
此外，与WHERE子句不同，您可以在HAVING子句中使用任何聚合函数，比如 sum、min、max。
但是，有时编码人员会像下面这样互换使用它们，
❌坏方法——使用HAVING过滤使用非聚集列的记录
SELECT OrderID,
Quantity,
Status
FROM Dummy_Sales_Data_v1
GROUP BY OrderID, Quantity, Status
**HAVING Quantity = 100**
AND Status LIKE 'Shipped'
AND Shipping_Cost > 30
✅最佳方式——使用WHERE过滤使用非聚集列的记录
SELECT OrderID,
Quantity,
Status
FROM Dummy_Sales_Data_v1
**WHERE Quantity = 100**
AND Status LIKE 'Shipped'
AND Shipping_Cost > 30
上述两个查询返回如下相同输出:
WHERE 和 HAVING | Image by Author 的输出相同
然而，人们应该始终考虑 SQL 操作的执行顺序。
如前面提到的 Sisense ，
在哪里被执行 在分组前被 查询。这意味着，WHERE在对行进行分组或聚合列计算之前选择行。
并且， HAVING 是在 GROUP BY 子句之后执行的，意思是在对分组后的行执行了聚集函数之后选择行。
这就是为什么是前置过滤器而是后置过滤器的原因。
所以，**WHERE** 会更快。
如果你的任务可以通过WHERE从句完成，那么我会建议不要用HAVING代替WHERE。
当您想要基于一些列聚合来选择行时,HAVING绝对是最佳解决方案。
另外，另一个常犯的错误是使用 WHERE 连接两个表，这在 SQL 中不是好的做法。下面我们来详细讨论一下。
优先使用 SQL 连接
在 SQL 中，JOIN子句用于根据多个表之间的相关列组合这些表中的行，而WHERE子句用于根据其中提到的条件选择行。
但是，有时 data professional 使用WHERE子句从两个表中选择行，此时某个列及其值同时出现在两个表中。
让我们看一个简单的例子。
首先，让我们创建两个cte 或公共表表达式 订单和价格。然后我们可以看到如何从两个表中选择行。(当您已经有两个表时，绝对不需要这一步)
WITH orders AS
(
SELECT OrderID,
Product_Category,
Quantity
FROM Dummy_Sales_Data_v1
WHERE Quantity = 100
AND Status LIKE 'Shipped'
AND Product_Category LIKE 'Healthcare'
),prices AS
(
SELECT OrderID,
UnitPrice,
Shipping_Cost,
Shipping_Address
FROM Dummy_Sales_Data_v1
WHERE Quantity = 100
AND Product_Category LIKE 'Healthcare'
)
现在，让我们从订单 ID 匹配的两个表中选择所有的行和列—订单 ID、产品类别、数量、单价。
❌不好的做法你应该避免
SELECT orders.OrderID,
orders.Product_Category,
orders.Quantity,
prices.UnitPrice
FROM orders, prices
**WHERE orders.OrderID = prices.OrderID**
在这种情况下，WHERE子句自动充当INNER JOIN，这意味着您正在执行 join 而没有显式地提及 JOIN 子句。所以，这里的**WHERE** 就变成了的隐式连接。
这导致可读性和理解性差。
然而，显式连接才是正确的方式，比如显式地提到连接的类型，比如— LEFT JOIN、RIGHT JOIN、INNER JOIN 。这样，您的查询可读性更好，也更容易理解。💯
它还为您提供了更多的灵活性来选择您想要执行的连接操作的类型——左连接或右连接——而WHERE子句不需要。
✅是你应该遵循的好习惯。
SELECT orders.OrderID,
orders.Product_Category,
orders.Quantity,
prices.UnitPrice
FROM orders
**INNER JOIN prices
ON orders.OrderID = prices.OrderID**
两个查询都检索相同结果集，如下所示:
SQL 联接-隐式和显式|作者图片
这样，您可以将两个表组合在一个公共列上，并将所有条件选择的行放在JOIN子句之后的WHERE子句上。
根据我的经验，使用JOIN而不是WHERE子句的主要优点是—
🔸SQL 联接使您能够控制扫描和联接表的顺序
🔸使用显式连接编写的查询易于阅读、理解和修改，因为JOIN标准与WHERE子句保持分离。
🔸在编写查询时，在 FROM 子句中提到表名后，您很容易忘记WHERE子句，而在 JOIN criteria 中却不是这样。当你想合并两个表格时，你肯定会在FROM后使用JOIN。
因此，显式总是比隐式好，因为它更容易理解和维护。💯
接下来，让我们讨论 DISTINCT 从表中选择唯一记录的最佳替代方法。
选择不使用 DISTINCT 的唯一记录
每当您需要从数据库中提取唯一的记录时，一个简单的答案就是使用**DISTINCT**！！
然而，DISTINCT可能很昂贵，因为它不会告诉您所使用的连接和过滤器是正确的还是不正确的，而这实际上是重复的原因。
只要您想从单个列中选择唯一的值，DISTINCT就能很好地工作。但是，当你想选择唯一的行(多列的组合)时，**GROUP BY**是最好的选择。💯
例如，从我们的数据集中选择销售经理、送货地址和运费的唯一行。
***--*** *Using* ***DISTINCT***SELECT **DISTINCT** Sales_Manager,
Shipping_Address,
Shipping_Cost
FROM Dummy_Sales_Data_v1
WHERE Status LIKE 'Shipped'
AND Product_Category LIKE 'Healthcare' ***--*** *Using* ***GROUP BY***SELECT Sales_Manager,
Shipping_Address,
Shipping_Cost
FROM Dummy_Sales_Data_v1
WHERE Status LIKE 'Shipped'
AND Product_Category LIKE 'Healthcare'
**GROUP BY** Sales_Manager,
Shipping_Address,
Shipping_Cost
两个查询返回完全相同的行
使用 DISTINCT 和 GROUP BY | Image by Author 选择唯一记录
由于在这个查询中没有提到任何复杂的 join 语句，并且数据集与商业数据集相比也很小，所以两个查询具有相同的性能。
然而，几乎 90%的时候，我发现GROUP BY更方便，因为我总是想使用集合函数做一些其他的计算，这可以使用GROUP BY来完成。
除了 GROUP BY 之外，还有 3 种最好的方法可以在不使用 DISTINCT 的情况下获得唯一的记录。
UNION()、INTERSECT() & ROW_NUMBER()
在我的上一篇文章中，了解更多关于在 SQL 中寻找唯一记录的 3 种终极方法。
💔-ultimate-ways-to-find-unique-records-in-sql-6ddf8ae567b0>
最后，让我们讨论如何使用 SQL 的内置特性(如索引)来提高查询性能。
使用 LIKE 筛选数据集行
过滤行最常见的方法是使用数学表达式，如**=**、**>**等等。然而，它们会生成布尔值——真或假——并且只选择那些表达式为TRUE的行。
这个过程很慢，因为它不使用 SQL 索引，而 SQL 索引是一种与表相关联的磁盘结构，可以加快从表中检索行的速度。
根据 微软 ，
索引包含从表或视图中的一列或多列构建的键。这些键存储在一个结构(B 树)中，该结构使 SQL Server 能够快速有效地找到与键值关联的一行或多行。
这些表达式的快速替代方法是使用像**LIKE**这样的操作符。
当然，当你需要对数值或聚合值使用过滤器时，这并不是一个好的选择。
但是，对于文本值，您总是可以使用 LIKE 运算符。💯
例如，让我们检索数据集的所有行，其中产品类别为“医疗保健”，状态为“已发货”
❌的不良做法是，
SELECT OrderID,
Product_Category,
Status
FROM Dummy_Sales_Data_v1
WHERE Product_Category **=** 'Healthcare'
AND Status **=** 'Shipped'
✅的良好做法是，
SELECT OrderID,
Product_Category,
Status
FROM Dummy_Sales_Data_v1
WHERE Product_Category **LIKE** 'Healthcare'
AND Status **LIKE** 'Shipped'
这样，即使您不知道要比较的确切文本值，也可以在 LIKE 运算符中使用通配符。
我推荐阅读 2022 年 你应该知道的 5 个实用 SQL 查询，深入了解如何使用 LIKE 运算符。
仅此而已！
我希望你很快完成这篇文章，并发现它对提高 SQL 技能很有用。
过去 3 年来，我一直在使用 SQL，并通过经验找到了这些最佳实践。此外，这些实践在数据科学工作面试中也会得到间接测试。采用它们肯定会为您的 SQL 技能增加更多价值。
对阅读媒体上的无限故事感兴趣？？
💡考虑 成为媒体会员 到访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡请务必 注册我的电子邮件列表 和 800+其他千万不要错过另一篇关于数据科学指南、技巧和提示、SQL 和 Python 的文章。
感谢您的阅读！
5 种流行的 CNN 架构得到清晰的解释和可视化
原文：https://towardsdatascience.com/5-most-well-known-cnn-architectures-visualized-af76f1f0065e
深度学习
为什么盗梦空间看起来像三叉戟？！
图片作者作者
**Table of Contents****·** [**Fully Connected Layer and Activation Function**](#c7c5)**·** [**Convolution and Pooling Layer**](#60dd)**·** [**Normalization Layer**](#b55c)
∘ [Local Response Normalization](#0f76)
∘ [Batch Normalization](#182a)**·** [**5 Most Well-Known CNN Architectures Visualized**](#8f20)
∘ [LeNet-5](#7ebd)
∘ [AlexNet](#c691)
∘ [VGG-16](#8ab0)
∘ [Inception-v1](#21f4)
∘ [ResNet-50](#6702)**·** [**Wrapping Up**](#87a2)
Yann LeCun 在 1990 年提出的 LeNet 激发了深度神经网络在实践中的可能性。然而，有限的计算能力和存储容量使得该算法直到 2010 年才得以实现。
虽然 LeNet 开启了卷积神经网络(CNN)的时代，但 Alex Krizhevsky 等人在 2012 年发明的 AlexNet 开启了 CNN 用于图像网络分类的时代。
AlexNet 是 CNN 能够在这个历史复杂的 ImageNet 数据集上表现良好的第一个证据，它表现得如此之好，以至于社会陷入了一场开发 CNN 的竞争:从 VGG 、盗梦空间、 ResNet ，到高效网络。
这些架构中的大多数遵循相同的配方:组合卷积层和汇集层后接全连接层，一些层具有激活功能和/或归一化步骤。你将首先学习所有这些晦涩难懂的东西，这样以后所有的架构都很容易理解。
注意:如果你想要这个故事中解释的架构的可编辑版本，请访问下面我的 gumroad 页面。
有了这个模板，你可能想要编辑现有的架构，用于自己的演示、教育或研究目的，或者你可能想要使用我们美丽的传说来构建其他令人惊叹的深度学习架构，但不想从头开始。免费(或者想付多少就付多少)！
https://dwiuzila.gumroad.com/l/cnn-architectures-visualized
全连接层和激活功能
让我们回到过去。1958 年，弗兰克·罗森布拉特推出了第一台 感知器 ，这是一种根据生物原理构造的电子设备，表现出一种学习的能力。感知器是一台机器，而不是一个程序，它的第一个实现是为图像识别而设计的。
这台机器非常像现代的感知机。在现代意义上，感知器是一种学习二元分类器的算法，如下所示。感知器利用依赖于数据的加权和的阶跃函数给出两个类之间的线性判定边界。
一个感知器|图片作者作者
感知器中的阶跃函数是 激活函数 的一个例子；它激活感知器的状态是开(1)还是关(0)。现在有很多种激活函数，其中大部分都可以用来给感知器引入非线性。除步进功能外，一些常见的激活功能有:
激活函数示例|图片作者作者
如果激活函数是 sigmoid，感知器被称为 逻辑回归模型 。
还有另一个值得一提的激活函数，在处理多类分类任务时使用: softmax 。考虑具有 K 个类的任务，则 softmax 表示为
Softmax 给出了模型选择类别 i 的预测概率。具有 softmax 激活函数的模型将挑选具有最高概率的类作为最终预测。
考虑具有任意激活函数 g 的感知器。您可以将任意数量的感知机堆叠成一层，并且可以将一层的输出连接到另一层。其结果就是我们所说的 多层感知器 (MLP)。
具有一个隐藏层的多层感知器 |图片由作者
在矢量化公式中，具有 L 层的 MLP 表示如下。
MLP 也被称为 密集神经网络 ，因为它类似于大脑的工作方式。上图最后一幅图中的每个单位圆称为一个 神经元 。在神经网络的世界中，MLP 层也被称为 全连接层 ，因为一层中的每个神经元都连接到下一层中的所有神经元。
卷积和汇集层
当很难找到一种有意义的方法从数据(例如表格数据)中提取要素时，完全连接的图层非常有用。说到图像数据，CNN 可以说是最著名的神经网络家族。对于图像数据，神经网络使用图像的 RGB 通道进行处理。
卷积如何与两个滤波器一起工作，每个滤波器的空间范围 F = 3，步长 S = 2，填充 P = 1 | 源
CNN 允许神经网络在图像的不同空间位置重复使用参数。各种选择的过滤器(也称为内核)可以实现不同的图像操作:身份，边缘检测，模糊，锐化等。CNN 的思想是通过引入随机矩阵作为卷积算子来发现图像的一些有趣特征。
在图像与内核卷积之后，你就剩下了一个被称为 的特征图 。您可以一次又一次地卷积您的特征地图来提取特征，然而，这被证明是非常昂贵的计算。相反，您可以使用 池图层 来缩小要素地图的大小。
池图层通过单个像素表示要素地图的小区域。可以考虑一些不同的策略:
- max-pooling(从特征图的 N×N 个小块中选择最高值)，
在 3 个大小为 4×4 的滤镜上应用 2×2 补丁的最大池|图片由作者
- 平均池化(对前一层的 N×N 个特征图进行求和，并选择平均值)，以及
在 3 个大小为 4×4 的滤镜上应用 2×2 补丁的平均池|图片由作者
- 全局平均池(类似于平均池，但不是使用 N×N 个特征图的补丁，而是一次使用所有特征图区域)。
全局平均池应用于 3 个大小为 4×4 的过滤器|图片由作者
池化使神经网络对输入图像中的小变换、扭曲和平移不变。输入中的微小失真不会改变汇集的结果，因为您在局部邻域中取最大值/平均值。
标准化层
局部响应标准化
Alex Krizhevsky 和其他人在他的 AlexNet 论文中介绍了 局部响应归一化 (LRN)，这是一种帮助 AlexNet 泛化能力的方案。
LRN 实现了 侧抑制 的想法，这是神经生物学中的一个概念，指的是一个兴奋的神经元抑制其邻居的现象:这导致了一个局部最大值形式的峰值，在该区域产生了对比，增加了感官知觉。
给定通过应用核 i 然后应用激活函数计算的神经元的活动 aᵢ ，响应标准化活动 bᵢ 由以下表达式给出
其中总和超过在相同空间位置的 n 个“相邻”内核映射，并且 N 是该层中内核的总数。常数 k 、 n 、 α 和 β 是超参数。
具体来说，让( k ， n ， α ， β ) = (0，2，1，1)。应用到 LRN 后，我们将计算左上角像素的值(下面是最浅的绿色)。
用(k，n，α，β) = (0，2，1，1)进行局部响应归一化 |图片由作者提供
计算如下。
批量标准化
深度神经网络优化的另一个突破是 批量归一化 (BN)。它解决的问题叫做 内部协变移位 :
前几层神经网络参数的变化改变了当前层的输入/协变量。这种变化可能是巨大的，因为它可能会改变投入的分布。如果一个层输入发生变化，那么这个层就几乎没有用了。
设 m 为训练时的批量。对于每一批产品，BN 都正式遵循以下步骤:
在哪里
这样，BN 有助于加速深度神经网络训练。网络收敛更快，在训练时表现出更好的正则化，对整体精度有影响。
5 个最著名的 CNN 架构被可视化
您已经了解了以下内容:
- 卷积层
- 汇集层
- 标准化层
- 全连接层
- 激活功能
现在，我们准备介绍和设想 5 种 CNN 架构:
- LeNet-5
- AlexNet
- VGG-16
- 盗梦空间-v1
- ResNet-50
它们将建立在您所学的层和功能之上。因此，为了简化事情，我们将删除一些信息，如过滤器的数量，步幅，填充和正则化的下降。你将使用下面的图例来帮助你。
本故事中使用的图例|图片由作者提供
注意:故事的这一部分很大程度上是受莱米·卡里姆的以下故事的启发。一定要去看看！
我们开始吧，好吗？
LeNet-5
这是一切的开始。不包括池化，LeNet-5 由 5 层组成:
- 内核大小为 5×5 的 2 个卷积层，然后是
- 3 个完全连接的层。
每个卷积层之后是一个 2×2 的平均池，除了最后一层(它有 softmax)之外，每一层都有 tanh 激活函数。
LeNet-5 建筑|图片由作者
LeNet-5 拥有60000 个参数。该网络在灰度 32×32 数字图像上被训练，并试图将它们识别为十个数字(0 到 9)中的一个。
AlexNet
AlexNet 引入了 ReLU 激活功能和 LRN。ReLU 变得如此流行，以至于几乎所有在 AlexNet 之后开发的 CNN 架构都在它们的隐藏层中使用 ReLU，放弃了 LeNet-5 中 tanh 激活函数的使用。
AlexNet 架构|图片作者作者
网络由 8 层组成:
- 内核大小不增加的 5 个卷积层，然后是
- 3 个完全连接的层。
最后一层用 softmax 激活函数，其他都用 ReLU。应用 ReLU 后，LRN 将应用于第一个和第二个卷积层。第一、第二和第五卷积层之后是一个最大 3×3 的池。
随着现代硬件的进步，AlexNet 可以用庞大的6000 万参数进行训练，并成为 2012 年 ImageNet 比赛的获胜者。ImageNet 已经成为开发 CNN 架构的基准数据集，并且它的子集(ILSVRC)由具有 1000 个类的各种图像组成。默认 AlexNet 接受尺寸为 224×224 的彩色图像。
VGG-16
研究人员调查了 CNN 深度对其在大规模图像识别设置中的准确性的影响。通过将深度推进到 11-19 层，VGG 家族诞生了:VGG 11 层，VGG 13 层，VGG 16 层，VGG 19 层。一个版本的 VGG-11 与 LRN 也进行了调查，但 LRN 没有提高性能。因此，所有其他 vgg 都是在没有 LRN 的情况下实现的。
VGG-16 建筑|图片作者作者
这个故事聚焦于 VGG-16，一个有 16 层的深度 CNN 架构:
- 内核大小为 3×3 的 13 个卷积层，接着是
- 3 个完全连接的层。
VGG-16 是拥有1.38 亿个参数的最大网络之一。就像 AlexNet 一样，最后一层配备了 softmax 激活功能，其他都配备了 ReLU。第 2、第 4、第 7、第 10 和第 13 卷积层之后是 2×2 最大池。默认的 VGG 16 接受尺寸为 224×224 的彩色图像，并输出 1000 个类别中的一个。
盗梦空间-v1
往深了说有个告诫: 爆炸/消失渐变 :
- 当大的误差梯度累积并导致训练期间不稳定的权重更新时，爆炸梯度是一个问题。
- 当损失函数的偏导数接近于零并且网络不能训练时，消失梯度是一个问题。
盗梦空间-v1 架构|图片作者作者
Inception-v1 通过添加两个连接到中间层的辅助分类器来解决这个问题，希望增加传播回来的梯度信号。在训练期间，他们的损失以 0.3 的折扣权重被添加到网络的总损失中。在推理时，这些辅助网络被丢弃。
Inception-v1 引入了 inception 模块 ，四个系列的一个或两个卷积和 max-pool 层并行堆叠，并在最后级联。初始模块旨在通过允许使用多种类型的核大小来近似 CNN 中的最佳局部稀疏结构，而不是局限于单个核大小。
《盗梦空间-v1》的参数比 AlexNet 和 VGG-16 少，只有 700 万美元，尽管它有 22 层:
- 内核大小为 7×7、1×1 和 3×3 的 3 个卷积层，然后是
- 18 层，由 9 个初始模块组成，每个模块有 2 层卷积/最大池，然后是
- 1 全连接层。
主分类器的最后一层和两个辅助分类器配备有 softmax 激活功能，并且所有其他分类器配备有 ReLU。第一和第三卷积层以及第二和第七初始模块之后是 3×3 最大池。最后一个初始模块之后是 7×7 平均池。LRN 是适用于第一次最大池和第三卷积层。
辅助分类器在第 3 和第 6 初始模块之后分支，每个从 5×5 平均池开始，然后是 3 层:
- 1 个具有 1×1 内核大小的卷积层，以及
- 2 个完全连接的层。
默认的 Inception-v1 接受尺寸为 224×224 的彩色图像，并输出 1000 个类中的一个。
ResNet-50
当更深的网络可以开始收敛时，一个 退化问题 已经暴露出来:随着网络深度的增加，精度达到饱和，然后迅速退化。
出乎意料的是，这种退化不是由过拟合引起的(通常由较低的训练误差和较高的测试误差表示)，因为向适当深度的网络添加更多层会导致较高的训练误差。
ResNet-50 架构|图片作者作者
通过引入 瓶颈剩余块 来解决退化问题。有两种残余块:
- Identity block:由 3 个卷积层组成，核大小分别为 1×1、3×3 和 1×1，所有卷积层都配有 BN。ReLU 激活函数应用于前两层，而身份块的输入在应用 ReLU 之前添加到最后一层。
- 卷积块:与恒等块相同，但卷积块的输入首先通过一个具有 1×1 核大小和 BN 的卷积层，然后添加到主序列的最后一个卷积层。
请注意，两个残差块都有 3 层。ResNet-50 总共有2600 万个参数和 50 层:
- 1 卷积层，然后应用 ReLU，接着
- 9 层，由 1 个卷积块和 2 个单位块组成，然后是
- 12 层，由 1 个卷积块和 3 个单位块组成，然后是
- 18 层，由 1 个卷积块和 5 个单位块组成，然后是
- 9 层，由 1 个卷积块和 2 个单位块组成，然后是
- 1 个带 softmax 的全连接层。
第一卷积层之后是 3×3 最大池，最后一个标识块之后是全局平均池。默认的 ResNet-50 接受尺寸为 224×224 的彩色图像，并输出 1000 个类别中的一个。
这里是所有架构的总结。
所有架构摘要|图片由作者提供
包扎
由 Markus Spiske 在 Unsplash 上拍摄的照片
在这个故事中，你已经了解到许多 CNN 架构是由卷积层和汇集层后跟全连接层的组合构建的，其中一些层具有激活功能和规范化步骤。重要的是，你知道这句话是什么意思。
你还从零开始构建了 5 个最著名的 CNN 架构。你会看到，更深的网络导致更好的性能，直到某个点它遭受 爆炸/消失梯度 或 退化问题 。为了解决这些问题，您使用了一些技巧，例如辅助分类器和瓶颈剩余块，分别在 Inception-v1 和 ResNet-50 中找到。
恭喜你！
🔥你好！如果你喜欢这个故事，想支持我这个作家，可以考虑 成为会员 。每月只需 5 美元，你就可以无限制地阅读媒体上的所有报道。如果你注册使用我的链接，我会赚一小笔佣金。
🔖想了解更多关于经典机器学习模型如何工作以及如何优化其参数的信息？或者 MLOps 大型项目的例子？有史以来最优秀的文章呢？继续阅读:
艾伯斯·乌兹拉
从零开始的机器学习
View list8 stories
艾伯斯·乌兹拉
高级优化方法
View list7 stories
艾伯斯·乌兹拉
MLOps 大型项目
View list6 stories
艾伯斯·乌兹拉
我最好的故事
View list24 stories
艾伯斯·乌兹拉
R 中的数据科学
View list7 stories
[1]王、、拉杰、比丘(2017): 关于深度学习的起源。https://arxiv.org/abs/1702.07800v4
2022 年必备的 5 本机器学习书籍
原文：https://towardsdatascience.com/5-must-have-machine-learning-books-in-2022-7ce91d06dfc8
使用这些专家推荐的书籍，启动并增强您的机器学习职业生涯
汤姆·赫曼斯在 Unsplash 上的照片
为什么书值得？
要成为机器学习的专家，你首先需要在三个方面打好基础:编码、机器学习理论和数学。有大量的资源和课程致力于教授这些技能。好书给个人提供了按照自己的进度学习的机会，而且不像在线课程那样更详细。它们也是很好的参考。机器学习是一个非常广阔的领域，拥有一本好书意味着你可以从一个简洁和详细的来源快速浏览几章来快速复习！
考虑到这一点，我想推荐几本帮助我获得第一份机器学习工作的书。我相信这些书绝对是必备的，对于初学者以及希望补充他们的发展和持续进步的更有经验的从业者来说都是极好的。当然，就像在线学习一样，为了充分利用这些书籍，值得自己实现代码示例和练习。
如果我要从头开始机器学习，这些建议是按照我浏览材料的顺序组织的。从 Python 的介绍开始，逐步走向动手机器学习，最后更深入地解决机器学习问题(自上而下的学习方法)。
这份列表中的每本书(除了最后一本基于理论的)都是围绕 Python 编程语言编写的。Python 是机器学习和数据科学的一个很好的工具，因为它是开源的，并且附带了大量强大的库— NumPy、Pandas、TensorFlow 和 Keras 等等。
这篇文章可能包含附属链接，当你点击链接时，我可能会赚取一小笔佣金，而无需额外付费。
所以…废话不多说…
用于数据分析的 Python:与 Pandas、NumPy 和 IPython 的数据争论，第 2 版
作者韦斯·麦金尼
用于数据分析的 Python | O ' Reilly 2017
这个列表中的第一本书并没有深入研究机器学习。然而，对于初学者来说，它是对 Python 的一个很好的介绍，对于有编码经验的人来说，它是一个很好的复习工具。这样做的一个关键原因是，这本书探索了数据科学和机器学习的核心 Python 库——NumPy、Pandas 和 Matplotlib。在整本书中，你将获得必要的技能来操作、清理和可视化数据。最后，您甚至可以获得关于时间序列数据的可靠介绍——这通常很难找到好的参考资料。
虽然这本书不会让你成为机器学习工程师，但如果你对这个主题很认真，那么你将从这本书中获得的基本 Python 技能将是无价的。很容易深入这个列表中的其他机器学习书籍。然而，我想你会发现他们的 Python 摘要章节是不够的，在你知道之前，你会迷失在所有的代码中。即使先决条件并不总是给出这一点。
使用 Scikit-Learn 进行机器实践学习，Keras & TensorFlow，第二版
作者奥雷连恩·盖伦
使用 Scikit-Learn、Keras 进行动手机器学习& TensorFlow | O'Reilly 2019
这是这份名单中我最喜欢的书！我真的不能推荐它。Géron 出色地完成了他的简明而详细的介绍，涉及广泛的机器学习主题，包括监督学习、非监督学习、深度学习甚至强化学习。
本书中的解释很清楚，并附有大量的动手示例，允许您练习和发展实用的机器学习技能。这本书从一个有趣的加州房价项目开始，从头到尾都完成了——让读者马上参与进来，而不会陷入大量的理论和数学中。然而，读者仍然带着丰富的理论知识和对主题的理解离开。
通过使用最流行的 Python 机器学习库(Sciki-Learn、Tensorflow 和 Keras ),读者一定会学到有价值且受欢迎的技能。作者还就如何处理和微调不同的现实世界问题给出了大量指导。最后，对于更高级的主题，作者给出了读者可能有兴趣进一步研究的前沿技术的建议。
我将这本书作为第二本书添加到我的列表中，因为我认为它确实需要预先的 Python 知识，即使没有严格的编码先决条件。
这本书的第三版也在路上——计划 2022 年 10 月出版！
机器学习向往
作者吴恩达
机器学习向往
这本书包含了如此多的知识、经验和指导，而且可以在一天之内读完，这一事实使它成为必读之书！
谈到机器学习的在线学习，吴恩达可能是领军人物。他是斯坦福大学的教授，是 Coursera、deeplearning.ai 和 Google Head 的联合创始人——所以你知道你从他那里获得的内容是值得你花时间的！在他的短篇书《机器学习的渴望》中，吴恩达传授了他关于如何构建机器学习项目的智慧。它为读者提供了最佳实践和潜在陷阱的警告。在你有了一些做自己项目的经验后，这本书可能更有价值，但是它的前半部分对初学者同样有价值！事实上，这本书是如此丰富的知识，经验和指导，但可以在一天内阅读，使其成为必读！
Python 深度学习，第二版
弗朗索瓦·乔莱
用 Python 进行深度学习| Manning 2021
这本书的作者弗朗索瓦·乔莱(Franç ois Chollet)是 Keras 的创始人——这是一个被谷歌采用的运行在 TensorFlow 之上的深度学习库。这本书最棒的一点是，Chollet 以一种非常直观的方式解释了复杂的概念——没有纠缠于所有的数学问题。如果你之前纠结于深度学习，这本书真的会帮到你。不仅如此，每一章都充满了大量的实践例子和详细的代码解释。如果你读了这本书，你一定会在理论理解和实践深度学习经验方面提升你的机器学习专业知识。
如果你对 Python 和机器学习有很好的理解，想要更深入地研究深度学习，并且更喜欢用 Python 代码而不是数学方程来解释概念——这本书就是为你准备的！
如果你想掌握实用的深度学习技能和 Keras 库——这本书就是为你准备的！
深度学习
作者伊恩·古德菲勒、约舒阿·本吉奥和亚伦·库维尔
深度学习|麻省理工出版社 2017
由该领域的三位专家撰写，深度学习是唯一一本关于该主题的综合性书籍。
——埃隆·马斯克
由三位专家撰写，这本全面的书将提升你对深度学习的理解。这本书深入介绍了数学概念和深度学习技术，适合所有人——学生、研究人员和软件工程师。
虽然这本书非常全面，但它排在了名单的最后，因为我相信所有这些信息对初学者来说可能是非常难以接受的。我个人发现自上而下的学习方式(先动手技能)更适合机器学习。从编码开始，这样你就可以很快看到自己是否觉得这是一件有趣的事情。然后，如果需要的话，深入研究不同算法背后的数学和理论，以改进解决方案并更好地理解主题。当然，其他人可能更喜欢自下而上的方法——对于你们中的一些人来说，这可能是一本好书。
结论
机器学习是一个快速发展的领域，大量的工具有时会让人不知所措。然而，本文中的书籍集应该作为您旅途中的一个很好的基础。总是记住如何解决不同的机器学习问题并不容易，从自然语言处理到计算机视觉和时间序列预测。希望这里推荐的书籍不仅能帮助你学习这门学科的高级技能，还能作为未来持续的参考。享受阅读吧！
关于数据科学的 5 个神话你最好忘记
原文：https://towardsdatascience.com/5-myths-about-data-science-youd-do-well-to-forget-9d0817aa4c64
神话 2:要在数据科学领域取得成功，你必须是一名数学天才
Ashkan Forouzani 在 Unsplash 上的照片
在大学早期，我被训练成为一名气候科学家。我被计算机科学和气候模型的交叉所吸引，也为有机会为急需的气候变化解决方案做出贡献而兴奋。
在那些日子里，每当我在的时候，我的朋友们都会说一个笑话:
"花了这么多钱和时间上大学，而穆尔塔扎却打算去当天气预报员."
请注意，即使我要去当天气预报员，我也会对这个笑话不屑一顾，因为这是一个非常体面的职业。然而，这里更重要的一点是，尽管气候科学家和气象学家有联系，但他们并不相同。不知道自己在说什么的人传播关于各种职业的错误信息是一种不幸的习惯。
起初，这可能看起来无害，但可能会对那些最终从事上述职业的人产生意想不到的负面影响。也就是说，有可能将自己与字段含义的不准确表示联系起来，然后在实际工作时承受后果。
随着数据科学处于现代就业市场的前沿，这种神话正在蔓延。
这里有 5 个你应该知道的。
误解 1:数据科学只是计算机科学的另一个名称
我所在的本科大学的数据科学项目存在一个严重的问题:它被广泛视为没有进入计算机科学专业的学生的退路。
学习数据科学的学生认为(至少在一开始)他们将有效地学习与计算机科学专业相同的技能。他们无法理解数据科学作为一个领域的自身价值和重要性。
虽然确实有重叠，但重要的是要认识到数据科学和计算机科学是不一样的。在其核心，计算机科学是关于建立计算机程序来完成各种任务。另一方面，数据科学是关于从大量数据中收集有意义的见解。从某种意义上说，这两个领域之间的关系可以这样理解:计算机科学是一个有用的工具，它简化了数据科学的过程。
大多数学习计算机科学的人可能会学习多种编程语言(Java、Python、C++、JavaScript 等等)以及软件开发的基础知识。他们的主要焦点是编写代码来构建更好的程序和系统。大多数人可能也有专长，比如网络、安全或前端开发。
同时，作为一名数据科学家，你对编程语言的掌握会更加集中(一般是 Python，有时是 R)。您将主要使用编程作为处理和分析数据的手段，还将学习统计学、用户测试和数据管理的基础知识。
知道区别。
误解 2:你必须是数学天才才能在数据科学领域取得成功
是的，数据科学涉及统计和概率。但这并不意味着你需要一个数学博士(甚至更多)才能为这个日益由数据主导的世界做出贡献。
加州大学伯克利分校是世界上的技术领导者之一，它在数据科学课程中采用了一种实用的方法，这是我们都可以借鉴的方法[1]。学生们不是从一大堆高等数学课程开始，而是先了解整体情况。
这在实践中是什么样子的？首先，学生将学习数据科学的基础知识，包括数据清理和收集、准确样本的识别、基本处理/分析/可视化等。在这个过程中，他们学习了必要的编程技巧来应用这些知识，以及让 T2 理解这些知识所需的统计能力。它保持实用和简洁；也就是说，在早期阶段，你不会花大量的时间去证明晦涩的数学概念。
现在，对于完整的数据科学专业，你确实需要学习更高级的数学和统计课程(有证明)，因为这些材料是整个数据科学的组成部分 [2]。但问题在于:很多人只上了最初的几门课(非数学课)，他们在数据科学方面表现出色。
如果你有能力收集、清理、处理、管理和分析数据，那么你在任何公司都可以大有作为。有许多计算工具可以帮助你完成这些任务——大数据世界除了理论天才之外，还非常需要实践工作者。
最棒的是，无论如何，你可能会在旅途中学到一些非常好的数学技能。
神话 3:有了先进的数据科学，我们将不再需要人类
这种想法是整个科技界的一个主要问题。许多人认为自动化是未来的趋势，我们越自动化，我们就越不需要人工决策。甚至有一部分硅谷的改宗者也对奇点的不祥想法产生了兴趣:机器智能将超过人类的时间点。这是反乌托邦好莱坞电影的素材。
但事实上，我们现在比以往任何时候都更需要人类决策。盲目依赖技术是不道德制度的温床。这就是为什么许多现代算法现在面临偏见和歧视的问题。
机器——即使是智能机器——也不是有知觉的生物。许多人将人工智能(AI)和机器学习视为神奇的黑匣子，可以为人类无法独自解决的问题提供答案。但是所有现代形式的人工智能都是在数据上被训练的。这个数据来自人类。人类有自己的观点和偏见——由此产生的机器也是如此。因此，让机器在没有人类帮助的情况下做决定是愚蠢的。
暂时忘记机器，考虑下面的场景:有一些邪恶的天才，他们打算通过针对农业部门来摧毁经济。他把自己伪装成一个善意的“人民的人”，并从权力的位置开始做出看似无害的决定，影响全国的农民，最终导致大规模饥荒和饥饿。他能做到这一点是因为每个人都毫无疑问地听从他的决定。
在这种情况下，机器很容易成为“中间人”——一些意图不良的人可以建立一个预测性的机器学习系统，用于农业援助，但经过训练可以实现上述目标。
对抗这种情况的一种方法是一种被称为人在回路中的互动【3】的技术:人类应该在各个阶段参与进来，审查和质疑机器，帮助它做出正确的选择，并确保最终的决定符合道德规范，而不是让机器盲目地做出决定。将机器作为它们应该成为的工具，而不是让它们成为人类社会的终极目标。那样的话，至少在这种情况下，我们还有一些食物可以吃。
诚然，这是一个戏剧性的例子，但你得到了要点。
我们需要人。
误解 4:这完全是机器学习
特别是考虑到我的上一个例子，我觉得这是一个值得解决的神话。许多人有这样的想法:数据科学基本上只是机器学习,涉及到全天候构建和部署超级酷的模型。
这种想法如此普遍，以至于当我还是本科生的时候，我对申请数据科学研究生院有过一些严重的犹豫。我对机器学习从来没有太大的兴趣，这似乎是所有人都在谈论的话题。
幸运的是，和我的导师的一次谈话让我改邪归正。他向我保证，在很多领域都有大量的工作要做——可视化、数据管理和数据科学的定性方面，等等。
为了进一步说明这一点，大多数数据科学家承认，他们的工作中只有一小部分实际上涉及到建模。
所以，如果机器学习不是你的强项，不要把你自己排除在外。
神话 5:只有硅谷需要数据科学
因为数据科学诞生于技术的繁荣，所以很自然地认为它只对标准的硅谷、倾向于计算的技术人群感兴趣。然而，这与事实相去甚远。
所有领域都可以，也确实会从数据科学的应用中受益。这里的逻辑很简单。根据定义，任何东西都可以被视为数据。在生物学中，它是细胞分裂的速度。在金融领域，是最近的股票价格。在计算机科学中，它是你的程序的效率。每个领域都有自己的版本，数据科学可以作为理解和分析的手段。
我最近参加了全国数据科学教育研讨会 [4]，其中一个主题是加州大学伯克利分校崭露头角的计算、数据科学和社会学院。这将是一个令人着迷的项目，所有学生都从核心数据科学课程中学习，并选择以下专业之一:1)公共卫生，2)气候和可持续发展，3)社会正义和福利。
数据科学的未来不是数据科学。
是其他的一切。
总结和最终想法
这里有一个数据科学神话的小抄，下次你接触到被主流职业建议洗脑的人时可以使用:
- 神话:数据科学和计算机科学是一样的。
事实:两者有联系，但不等同。 - 神话:你需要成为数学专家才能在数据科学领域取得成功。
事实:仅仅接受标准的数学教育，你就能走很长的路。 - 神话:我们可以用数据科学来自动化一切。
事实:作为一个伦理问题，我们比以往任何时候都更需要人类。 - 神话:数据科学就是机器学习。事实:事情远不止如此。
- 神话:数据科学是一个独立的领域。
事实:在数据科学的帮助下，许多其他领域都可以蓬勃发展。
现在你知道了。
祝您好运，继续您的数据科学之旅。
想擅长 Python？ 获取独家、免费获取我简单易懂的指南在这里 。想在介质上无限阅读故事？用我下面的推荐链接注册！
https://murtaza5152-ali.medium.com/?source=entity_driven_subscription-607fa603b7ce---------------------------------------
我叫 Murtaza Ali，是华盛顿大学研究人机交互的博士生。我喜欢写关于教育、编程、生活以及偶尔的随想。
参考
[1]https://data . Berkeley . edu/academics/data-science-understand-studies/data-science-major
【2】https://towardsdatascience . com/an-introduction-to-mathematical-thinking-for-data-science-f 1214 D2 cc 61d
【3】【https://levity.ai/blog/human-in-the-loop
【4】https://data.berkeley.edu/2022workshop
构建数据平台时要考虑的 5 件不明显的事情
原文：https://towardsdatascience.com/5-non-obvious-things-to-consider-when-building-your-data-platform-fd8e74e8cd66
迁移到梦想中的自助服务数据平台时，需要回答以下 5 个重要问题
图片由克里斯汀·威尔森在 Unsplash 上提供。
构建数据平台——即您公司所有数据的中央存储库，支持数据的获取、存储、交付和治理，同时维护数据生命周期的安全性——已成为当今数据团队的必经之路。数据平台在现代组织中至关重要，因为它们允许领导者更容易地从数据中收集可操作的见解，从而帮助优化运营。
然而，在这个勇敢的新的数据驱动的世界中，确保您在构建数据平台时有一个良好的开端是一项挑战。构建时的一些考虑是显而易见的:例如，您将需要的工具、您将服务的用户、您将利用的数据源以及平台的最终用途。但是有几个组织和文化方面的考虑，即使是最有意图的数据团队也可能会在急于构建时忽略。
我们采访了 Toast 公司的 Noah Abramson 和 Angie Delatorre，这是一家领先的餐厅销售点提供商，也是最近的独角兽，了解他们构建高性能现代数据平台的方法。
在我们的交谈中，我们了解到在构建您的数据平台时有五个重要的考虑因素。让我们开始吧。
考虑 1:你将如何获得利益相关者的认同？
只有当数据平台的用户(即企业中的利益相关者)对它开放并熟悉它时，它才有用。在创建数据平台之前，让所有可能利用该平台的团队参与进来是非常重要的。
在 Toast，这非常简单。
“Toast 是一家超级数据驱动的公司，”诺亚说。“老实说，我认为这对我们的[数据]团队非常有益。我们的数据工程团队总监做得非常好，他让我们尽可能地为公司的其他人提供有价值的服务，让拥有这些数据洞察力的人能够获得决策支持，然后衡量这些决策和结果。”
组织中每个部门的员工都应该了解数据平台最终将如何为他们提供价值。这是数据团队的初始工作:解释和展示这种价值，并建立一种衡量成功的方法，即使公司在扩大。Toast 数据团队首先了解影响他们同事的业务问题，然后将数据团队定位为潜在解决方案的提供者。
“我们的主管让我们的团队尽早介入这些问题，并帮助我们了解我们将如何解决这些问题，我们将如何衡量我们是否正确解决了这些问题，以及我们将如何开始跟踪这些数据——不仅是现在，还有未来，”Noah 说。
随着时间的推移，Toast 开发了一个系统，通过构建自助分析模型来消除瓶颈，从而为更广泛的公司服务并消除瓶颈。
“我们的流程最初是超级集中的，我们拥有整个堆栈，”Noah 解释道。“随着公司开始发展，它变得势不可挡。我们转向了自助服务模式，我们成为了您在构建这些仪表板和拥有数据时可以咨询的团队。”
考虑 2:谁拥有数据堆栈中的什么？
为了得到最有效的利用，数据应该被视为整个组织的共享资源。不同的团队在公司数据生命周期的不同阶段拥有公司数据的所有权:例如，数据工程团队可能拥有原始数据，然后将数据交给分析工程团队进行分析和洞察，然后由商业智能团队进行解析和应用。
端到端数据堆栈由支持每个团队的多种工具和技术组成。Toast 从包括 Salesforce、NetSuite、Workday 和 Toast 本身在内的来源获取数据。这些数据流入团队的数据湖 S3，然后被复制到云数据仓库雪花。该团队使用 Looker 作为其前端工具，所有工作都通过气流进行编排。
图片由 Toast 网站的 Noah Abramson 提供。
在 Toast，数据平台团队拥有公司面向外部的数据洞察和分析。
“我们的一个大价值广告(作为一个组织)是给我们的客户提供商业见解:餐馆，”诺亚说。“他们在一段时间内表现如何？他们昨天的销售额是多少？谁是他们的顶级客户？与我们的餐厅客户互动是数据平台团队的工作。”
相比之下，诺亚的团队主要是内部的。
“我们说我们的顾客都是烤面包的员工，”他说。“我们试图为所有人提供尽可能多的数据。我们的团队为所有内部数据请求提供服务，从产品到上市，从客户支持到硬件运营。”因此，Noah 团队的工作是将数据流构建到总体系统中，并帮助整个组织的利益相关者从包括 Snowflake 和 Looker 在内的工具中获得洞察力。
考虑 3:你将如何衡量成功？
如果您无法衡量，您就无法管理—这一真理适用于评估数据对业务的影响。在构建数据平台时，衡量利益相关者如何利用数据来支持业务需求以及确定数据团队绩效的质量和效率都很重要。
关于他的团队如何考虑衡量与数据相关的 KPI，Noah 说:“我们真的倾听企业的需求。“在最高层，他们提出了几个不同的目标:例如，增加客户、增加收入、在某些支出领域削减成本。”
然后，Noah 和他的团队采用这些高级业务目标，并使用它们来构建目标和关键结果(okr)。
“我们可以用几种方法做到这一点，”诺亚说。“例如，如果你考虑扩大客户群，我们会问，‘我们如何让拥有数据的人做出更多决策？’如果有人有一个新产品的想法，我们如何发挥它，让他们把它放在那里，然后衡量它？"
此外，团队关注于测量其过程的可伸缩性。Angie 说:“我们不仅倾听业务需求并明确支持它们，而且还关注内部并解决可扩展性问题。”。“如果一项工作过去需要一个小时，现在需要三个小时，我们总是需要回去看看那些实例，这样也可以塑造我们的 okr。”
考虑 4:你会集中还是分散你的组织结构？
每个数据团队都是不一样的，每个团队的需求都会随着时间而变化。您的公司是否应该为您的数据团队寻求一种集中的组织结构？集权会带来太多的瓶颈吗？分散的方法会导致重复和复杂吗？在构建数据平台时，了解每个选项的情况并选择在给定时间点最适合您业务的模型是一个重要的考虑因素。
多年来，Toast 自身的结构经历了各种变化:从集中到分散再到混合。
最初，所有请求都流经数据团队。“这很有效，”诺亚说。"但随着公司开始成长，它变得势不可挡."
Toast 转向了一个分散的模型，强调分析师的自助服务，并将数据团队定位于一个更具咨询性的角色。这种变化是由快速增长的几个痕迹引起的，包括大量的传入数据、越来越多的人依赖这些数据，以及不断增长的数据工程团队的资源有限。
随着 Toast 的增长，该公司知道需要以新的方式利用数据来支持增长。
Noah 说:“我们需要考虑如何让所有这些新的业务线拥有与我们的上市团队相同的洞察力。“我们对数据使用有着很高的期望，我们希望让[整个组织]的所有人都能获得与我们为走向市场和销售所构建的访问权限相同的访问权限。”
这给带宽有限、捉襟见肘的数据工程团队带来了优先级问题。“我们团队的最新发展确实解决了这些类型的(业务)需求，”Noah 说。“在我们目前的设置中，我们生活在一个超级新的范式中，它是数据工程、分析工程，然后是可视化。我们现在可以有效地将数据导入雪花，并利用我们所有的不同来源。”
反过来，分析工程团队专注于创建一个数据模型，该模型可以服务于不同 Toast 成员对数据和业务的各种思考方式。
“我认为新的 分析工程 团队——我们对此感到非常兴奋——将会缩小一点，了解所有的问题，看看我们如何建立一个数据模型来服务于此，”诺亚说。Toast 当前的混合组织结构最适合其当前的需求——如果需求和环境发生变化，团队总是愿意重新评估和调整。
考虑 5:你将如何处理数据的可靠性和信任？
随着数据量随着各个业务部门利用数据的意愿而持续增长，数据可靠性(即组织在整个数据生命周期中提供高数据可用性和健康状况的能力)变得越来越重要。无论您选择构建自己的数据可靠性工具还是购买一个，它都将成为功能性数据平台的必要组成部分。
随着 Toast 团队开始处理不断增长的数据量，确保数据可靠性变得至关重要。
“有很多移动的部分，”数据栈的诺亚说。“中转区有很多逻辑，会发生很多事情。这就引出了一个问题，我们如何观察所有这些数据？我们如何确保当数据进入生产阶段时，看起来是我们想要的，它是准确的，及时的，以及所有我们真正关心的有趣的事情？”
最初，诺亚和另外两名工程师花了一天时间构建了一个他们称之为 Breadbox 的数据刷新工具。该工具可以执行基本的数据可观察性任务，包括存储原始计数、存储百分比空值、确保数据在需要时到达数据湖，等等。
“这真的很酷，”诺亚说，“但是随着数据的增长，我们跟不上了。随着所有这些新来源的出现，并要求不同类型的观察，我们花时间将集成构建到工具中，而不是花同样多的时间为该工具构建新的测试。”
一旦团队达到关键的增长水平，就应该考虑投资于数据可观察性，而不是投入时间和资源来完善他们自己的解决方案。
安吉说，对于任何一家公司来说，正确的选择都是不同的。
“我认为我们的建筑就其本来面目而言非常好，”她说。“但当你谈到可扩展性时，我们发展得如此之快，而且正在招人，教他们如何使用这一工具将会很困难。如果有什么东西坏了，就很难(修复)。”
她说，从长远来看，“我希望我们的团队专注于丰富数据和支持 Toast。如果有一款同类最佳的工具可以做到这一点，我们非常愿意为此付费，让我们的专业知识能够发挥我们的最大优势，让企业用户能够利用数据开展工作。”
自从实现了数据可观测性，Toast 的数据工程团队就可以做到这一点。此外，这种新方法为公司提供了定制工具无法提供的额外价值。
Angie 说:“我认为[关于数据可观察性]有几件事非常有价值。“机器学习，能够进去说‘这是意料之中的’，或者‘这是固定的’。”另一件事是事件的记录以及它们是如何发生的。我认为能够回到过去并拥有那个记录是非常有价值的。"
她认为，数据的可观察性也有助于团队避免警觉疲劳。
“这只是减少了时间，”她说。"你被准确地导向问题所在，然后从那里开始，你可以展开."
为您的团队提供最佳数据平台
每家公司的每个数据平台看起来都会有点不同，这是应该的。当谈到为您的团队和组织创建最佳数据平台时，重要的是要问自己一些关于您公司的文化、业务目标、结构等微妙的问题。
有兴趣了解有关如何构建可靠数据平台的更多信息吗？联系巴尔和蒙特卡洛 的 团队！
本文由 周浩宇 共同撰写。
作为一名自学成才的数据科学家，我推荐 5 门在线课程
原文：https://towardsdatascience.com/5-online-courses-i-recommend-as-a-self-taught-data-scientist-92941ec66f64
如果我必须从头开始我的数据科学之旅，我会选择这些课程
来自 Pexels 的照片由棉花兄弟拍摄
几天前，我写了一篇博客，讲述了我如何成为一名自学成才的数据科学家的故事。你可以看看下面博客。
在这篇博客中，我解释了在线课程如何成为我旅程的重要部分，以及它们如何真正帮助我学习数据科学的基础和主要组成部分。
那个博客获得了很多关注，很多人问如果你想成为一名自学成才的数据科学家，你应该学习什么课程。
因此，在这篇博文中，我将列出我作为自学成才的数据科学家推荐的五门在线课程，我已经完成了其中的 30 多门。
1.机器学习 A-Z:数据科学中的 Python & R 实践
我推荐你参加的第一门课程是机器学习 A-Z:数据科学中的 Python & R 实践课程。
这是一门非常全面和结构良好的课程，教你如何使用 Python 在实践中应用机器学习。
您将了解监督、非监督和强化算法，包括经典的 ML 方法和最先进的深度学习算法。
本课程最棒的部分是，它是由一位数据科学专家教授的，这位专家在的真实世界项目中使用了他教授的算法，所以你可以确保学会正确的做事方法。
完成本课程后，您将学会:
- 如何在实践中应用机器学习
- 最重要的监督、非监督和强化算法
- 经典的 ML 方法和最先进的深度学习算法
- 如何使用最流行的 ML 框架:TensorFlow、Scikit-Learn、XGBoost 和 Keras
这门课是我这辈子迄今为止做得最好的课程之一。它帮助我获得了对机器学习的坚实理解&获得了我对编程的最初信心，特别是在 r。
在此获取课程
如果你想精通机器学习，你绝对应该学习这门课程。
您可以在此获取课程:
机器学习 A-Z:数据科学中的动手 Python&R
2.完整的 SQL Bootcamp 2022:从零到英雄
我建议您参加的下一门课程是完整的 SQL Bootcamp 2022:从零到 SQL 英雄。
这是一门很好的课程，将教你如何使用 SQL 进行数据分析和数据操作。您将学到从关系数据库基础到更高级主题的一切，如窗口函数、子查询、集合运算符等等。
本课程由一位在实际项目中使用过 SQL 的数据科学家讲授，因此您可以确保学会正确的做事方式。
这是我在 SQL 上做过的最全面的课程之一&它真的帮助我获得了使用这种语言来操作大小数据集的信心。
完成本课程后，您将学会:
- 关系数据库和 SQL 的基础
- 如何使用 SQL 查询数据库
- 如何使用 SQL 进行数据分析和数据操作
- 如何使用窗口函数、子查询、集合运算符等等
在此获取课程
如果你想精通 SQL，你一定要上这门课。
您可以在此获取课程:
完整 SQL boot camp 2022:SQL从零到英雄
3.2022 年完成 Python Bootcamp 从零到 Python 中的英雄
我推荐你参加的下一个 l 课程是 2022 年完整的 Python 训练营，从零到英雄的 Python 课程。
这是一门优秀的在线课程，将教会你用 Python 编程所需要知道的一切。
您将学习 Python 的基础知识，比如数据类型、控制流、函数、模块包等等。您还将学习面向对象编程、软件设计模式等等。
本课程结束时，你将能够轻松地用 Python 编写自己的程序。
这是我最喜欢的课程之一，因为它有非常实用的方法，并使学习如何编程变得有趣&互动(每个模块结束时都会给你“作业”让你完成)。
完成本课程后，您将学会:
- Python 的基础知识，如数据类型、控制流和函数
- python 中的面向对象编程(类和对象)
- 复杂的话题，比如装修工
- 如何用 Python 创建游戏，像井字游戏和 21 点！
在此获取课程
对于任何想学习如何使用 Python 语言编程的人来说，这是一门极好的课程。
您可以在此处获得该课程:
2022 年完成 Python Bootcamp 从零到英雄
4.Tableau 2020 A-Z:数据科学实践 Tableau 培训
我推荐你参加的第四门课程是 Tableau 2020 A-Z:数据科学 Tableau 实践培训课程。
这是另一个很好的在线培训资源，它将帮助你成为世界上最强大的数据可视化软件 Tableau 的熟练用户。
这不仅仅是一个介绍性的教程，而是深入的，教你如何将 Tableau 用于数据科学的目的。
您将了解 Tableau 的不同功能，如何连接到各种数据源，执行基本和高级分析，创建令人惊叹的可视化效果，等等。
完成本课程后，您将学会:
- Tableau 的所有特征
- 如何连接到各种数据源:Excel、SQL Server、Oracle、Google Analytics 等等
- 如何执行基本和高级分析
- 如何轻松创建令人惊叹的可视化效果
在此获取课程
如果您想学习 Tableau，或者您已经熟悉它，并且想学习如何将它用于数据科学目的，那么本课程非常棒。
您可以在此获取课程:
Tableau 2020 A-Z:数据科学实操 Tableau 培训
5.深度学习 A-Z:动手人工神经网络
我推荐你参加的最后一门课程是深度学习 A-Z:动手操作人工神经网络课程。
这是另一个优秀的在线培训资源，将教你如何使用 Python 来实现深度学习算法。
本课程深入探讨了各种神经网络架构、数据准备技术(缺失值插补、缩放等)。)、模型选择和优化等等。
完成本课程后，您将学会:
- 如何使用 Python 构建深度学习模型
- 不同类型的神经网络结构
- 数据准备技术(缺失值插补、标度等)。)
- 模型选择和优化
在此获取课程
对于任何想要了解各种深度学习模型以及如何使用 Python 实现它们的人来说，这都是一门优秀的课程。
您可以在此处获得该课程:
深度学习 A-Z:动手人工神经网络
今天就开始学习
有很多在线课程可以帮助你 python，机器学习，深度学习，SQL 等。
如果这是你感兴趣的事情，那么这些在线资源将是你作为自学成才的数据科学家开始旅程的完美地方！
5 只熊猫按你在 Python 中应该知道的技巧分组
原文：https://towardsdatascience.com/5-pandas-group-by-tricks-you-should-know-in-python-f53246c92c94
数据科学
所有你需要知道的关于熊猫的数据框架组，以便有效地使用它
斯蒂夫·约翰森在 Unsplash 上拍照
熊猫力量！🔋
Pandas 是广泛用于数据分析项目的 Python 库。然而，分析数据并不容易，因为要从中获得有价值的见解是很难的。为了更好地理解数据，您需要对其进行转换和聚合。这时**groupby**出现了。
在 Pandas 中，**groupby**本质上是将数据集中的所有记录分成不同的类别或组，并为您提供按这些组分析数据的灵活性。
这是非常有效的，必须知道在数据分析功能，这给你几秒钟内有趣的见解。这也是为什么在数据科学工作面试中经常会被问到这个问题。所以，掌握它很重要。💯
在本文中，我将举例说明 5 个简单的熊猫groupby技巧，你必须知道这些技巧才能高效地进行数据分析，也才能在数据科学面试中胜出。
虽然这篇文章很短，但你可以通过这个索引自由地导航到你最喜欢的部分，并下载整个笔记本，最后还有例子！
**∘** [**How exactly group by works on pandas DataFrame?**](#41fa) **·** [**Number of Groups**](#782f) **·** [**Group Sizes**](#06fd) **·** [**Get First and Last**](#c09b) **·** [**Get Groups**](#461c) **·** [**Aggregate Multiple Columns with Different Aggregate Functions**](#ae8f)
📍注意:我使用的是自己创建的虚拟销售数据，你可以在我的 Github repo 上免费获得 麻省理工学院许可 ！！
让我们将数据集导入熊猫数据框架— **df**
import pandas as pd
df = pd.read_csv("Dummy_Sales_Data_v1.csv")
df.head()
虚拟销售数据|作者图片
这是一个简单的 9999 x 12 的数据集，我用 Python 中的Faker创建的📚
在继续之前，让我们快速了解一下—
“分组”到底是如何在熊猫数据框架上工作的？
当您对 DataFrame 的任何分类列使用.groupby()函数时，它会返回一个**GroupBy**对象。然后，您可以对该对象使用不同的方法，甚至聚合其他列来获得数据集的汇总视图。
例如，您使用下面df中产品类别列的.groupby()函数来获取GroupBy对象。
df_group = df.groupby("Product_Category")
type(df_group)# Output
**pandas.core.groupby.generic.DataFrameGroupBy**
返回的**GroupBy**对象只是一个字典，其中键是唯一的组，其中记录被拆分，值是每个组的列，这些列在groupby中没有提到。
当然，GroupBy object 保存整个数据帧的内容，但以更结构化的形式保存。就像字典一样，有几种方法可以有效地获取所需的数据。✅
让我们先从简单的事情开始，看看你的数据现在被分成多少个不同的组。
组数
一旦您将数据分成不同的类别，了解您的数据现在被分成多少个不同的组是很有趣的。
简单而常见的答案是在任何列上使用nunique()函数，这实际上给出了该列中唯一值的数量。因此，由于列中有许多唯一值，数据将被分成许多组。
例如，您可以查看使用产品类别可以形成多少个独特的组。
df.Product_Category.nunique()-- Output
**5**
然而，当你已经有一个GroupBy对象时，你可以直接使用它的
方法**ngroups**，它会给出你想要的答案。这是你如何使用它。
df_group = df.groupby("Product_Category") **df_group.ngroups**-- Output
**5**
一旦你知道了组的数量，你仍然不知道每个组的大小。下一个方法让你知道每个组有多大或多小。
组大小
使用函数可以很容易地获得每组GroupBy对象中的行数。大小()。****
例如，您想要查看每组产品类别中有多少不同的行。这可以简单地如下获得—
**df.groupby("Product_Category").size()**
熊猫按大小分组|作者图片
它只是计算每个组中的行数。这里有人会说，使用聚合函数count()可以获得相同的结果。让我们试一试，
**df.groupby("Product_Category").count()**
熊猫按数量分组|图片按作者
你可以看到两个结果之间的相似之处——数字是相同的。然而，它们的计算方式有很大的不同。
根据熊猫 ，聚合函数.count()只计算每一列的非空值 s，而.size()只是返回每一组中可用的行 s 的号，而不管有无值。
因此，在使用这两个函数之前，您必须对它们之间的差异有深刻的理解。简而言之，如果想知道每组的每一列中有多少非空值，就使用.count()，否则就使用.size() ✅
一旦你得到每个组的大小，你可能想看看第一个，最后一个或记录在数据中的任何随机位置。在这种情况下，下一个方法可能很方便。
获得第一和最后一名
在数据被分成不同的组后，这些函数返回第一条和最后一条记录。它不是引用 index，而是给出所有组中出现的第一行或最后一行。
例如，您可以看到每个组中的第一条记录，如下所示:
**df.groupby("Product_Category").first()**
查看熊猫分组的第一行|作者图片
没错，用类似的方法，你可以看看每组的最后一行。
**df.groupby("Product_Category").last()**
查看熊猫分组的最后一行|作者图片
一旦所有行都被分组到每个产品类别下，它就返回第一行和最后一行。
此外，您还可以在任何其他位置提取行。例如，也可以使用函数**.nth()**提取每组中的第 4 行
**df.groupby("Product_Category").nth(3)**
记住，Python 中的索引是从零开始的，因此当你说.nth(3)时，你实际上是在访问第 4 行。
从逻辑上讲，您甚至可以使用.nth()函数获得第一行和最后一行。例如，您可以使用.nth(0)和.first()获得每组的第一行，或者使用.nth(-1)和.last()获得最后一行。
那为什么这些不同的功能会存在呢？？ 🚩
虽然可以使用.first()和.nth(0)来获取第一行，但是在处理**NaN**或缺失值时有所不同。.first()给出每一列的第一个非空值，而.nth(0)返回组的第一行，不管这些值是什么。.last()的情况也是如此
因此，我推荐使用.nth()而不是其他两个函数来从一个组中获取所需的行，除非您专门寻找非空记录。💯
但是假设，不是只从组中检索第一行或最后一行，您可能很想知道特定组的内容。下一个方法会很快给出这些信息。
获取组
pandas GroupBy方法**get_group()**用于从GroupBy对象中选择或提取一个组。
例如，假设您想查看“医疗保健”组的内容。这可以用下面最简单的方法来完成。
**df_group.get_group('Healthcare')**
熊猫按 get_group() |图片按作者分组
如您所见，数据集的结构没有变化，您仍然可以获得产品类别为' Healthcare' '的所有记录。
对于这种方法，我有一个有趣的用例— 分割数据帧
假设您想要选择产品类别为【家庭】的所有行。一种简单且广泛使用的方法是使用如下的括号符号**[ ]**，
df[df["Product_Category"]=='Home']
这没什么不对的。但是使用下面的方法.get_group()可以得到完全相同的结果，
df_group = df.groupby("Product_Category")
df_group.get_group('Home')
更进一步，当您比较这两种方法的性能并分别运行 1000 次时，当然.get_group()是省时的。✅
切片用。groupby()比逻辑比较快 4 倍！！
这是通过在.get_group()方法中指定组名来一次只获取一个组。但是，如果您想一次浏览所有组的内容，该怎么办呢？？
你还记得—
**GroupBy**对象是字典吗！！ 🚩
因此，您可以像使用 dictionary 一样直接遍历它——使用键和值参数。💯
以下是你可以先睹为快每个组的内容。
**for name_of_group, contents_of_group in df_group:**
print(name_of_group)
print(contents_of_group)
遍历每组熊猫分组依据|图片依据作者
它将列出每个组的名称和内容，如上所示。在图片中只能看到一个组的内容，但是在笔记本中，你可以看到一个接一个列出的所有组的相同模式。
它基本上显示了每组中的第一行和最后五行，就像 pandas DataFrame 的.head()和.tail()方法一样。
接下来，如果不汇总数据，熊猫groupby的使用是不完整的。在这最后一部分中，让我们探索如何在不同的列上使用不同的聚合函数。
用不同的聚合函数聚合多个列
对每个组中的列应用聚合函数是一种广泛使用的做法，以获得汇总结构，用于进一步的统计分析。
根据 IBMhttps://www.ibm.com/docs/da/tnpm/1.4.2?topic=data-aggregation，****
您可以分析汇总的数据，以获得关于特定资源或资源组的见解
这就是拥有聚合功能的熊猫groupby非常有用的地方。使用groupby，您可以根据单个列或多个列将数据集分成不同的组。然后对剩余的数字列应用聚合函数。
让我们继续同一个例子。将数据按产品类别分组后，假设您想查看每个产品类别的平均单价和数量是多少。****
您所需要做的就是使用方括号引用GroupBy对象中的这些列，并对它们应用聚合函数.mean()，如下所示
**#Create a groupby object
**df_group = df.groupby("Product_Category")**#Select only required columns
**df_columns = df_group[["UnitPrice(USD)","Quantity"]]**#Apply aggregate function
**df_columns.mean()****
熊猫分组依据聚合函数|图片依据作者
这样你可以得到每组的平均单价和数量。您可以根据需要添加更多列，并应用其他聚合函数，如.min()、.max()、.count()、.median()、.std()等。
🚩请注意，代码被分成 3 行只是为了便于理解，在任何情况下，只需如下一行代码就可以获得相同的输出。
****df.groupby("Product_Category")[["UnitPrice(USD)","Quantity"]].mean()****
尽管像上面这样写一行程序看起来很容易，也很有趣，但是你应该始终记住 PEP-8 关于一行中字符数的准则。你可以在下面的文章中读到更多。
****</5-most-powerful-one-liners-you-should-know-in-python-programming-c9d49a89b7f3>
接下来，您可以使用GroupBy方法**.aggregate()**在同一列上应用多个聚合函数。只需提供要在列上应用的函数名列表。
举个例子，假设你想得到每个产品类别中数量的最大值、最小值、相加值和平均值。所以集合函数是min、max、sum和mean &你可以这样应用它们。
df.groupby("Product_Category")**[["Quantity"]].aggregate([min,
max,
sum,
'mean'])**
熊猫分组按同一列多重聚合|图片按作者
您将获得关于每组中数量的所有所需统计数据。
但是等等，你注意到你在.aggregate()中提供的函数列表中的一些东西了吗？？
sum、min、max 等所有函数都是直接编写的，但函数 mean 是以字符串形式编写的，即在单引号中，就像这样**‘mean’**
但为什么写得像一串呢？？ 🚩
根据 pandas ，传递给.aggregate()的函数必须是传递给数据帧或传递给DataFrame.apply()时起作用的函数。
简而言之，当你提到**‘mean’** ( 加引号)，.aggregate()搜索一个属于pd.Series即**pd.Series.mean()**的函数mean。
然而，如果您提到**mean** ( 不带引号)，.aggregate()将在默认 Python 中搜索名为mean的函数，该函数不可用，并将抛出NameError异常。
此外，使用.groupby()您可以在不同的列上应用不同的聚合函数。在这种情况下，您需要向.aggregate()传递一个字典，其中键将是列名，而值将是您想要应用的聚合函数。
例如，假设您想获得每个产品类别的总订单和平均数量。因此，您将传递给.aggregate(的字典将是— **{‘OrderID’:’count’, ’Quantity’:’mean’}**
您可以通过简单地如下传递这个字典来获得想要的输出，
**function_dictionary =** **{'OrderID':'count','Quantity':'mean'}**
df.groupby("Product_Category")**.aggregate(function_dictionary)**
多重聚合|作者图片
这样，您可以根据需要在多个列上应用多个函数。
熊猫**.groupby()**和它的**GroupBy**对象更加灵活。有一种方法可以通过单个函数**describe()**获得按每个组拆分的基本统计摘要。您需要指定一个必需的列，并在其上应用.describe(),如下所示
df.groupby("Product_Category")[["Quantity"]]**.describe()**
每组的描述性统计|按作者分类的图片
这样，您可以获得每个产品类别中数量的完整描述性统计汇总。如你所见，它包含了单个函数的结果，如count、mean、std、min、max和median。
就是这样！🏆****
我希望你从这篇文章中获得关于熊猫.groupby() 及其灵活性的有价值的见解。
在现实世界中，您通常会处理大量数据，并需要对不同组的数据进行类似的操作。熊猫.groupby()在所有这些场景中都非常灵活和方便。
有兴趣在媒体上阅读更多故事？？
💡考虑 成为媒体会员，可以无限制的获取媒体上的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡请务必 注册我的电子邮件列表 以免错过另一篇关于数据科学指南、技巧和提示、SQL 和 Python 的文章。
💡这里有一个完整的 笔记本 里面有所有的例子。
感谢您的阅读！
作为一名数据分析师，你可以在业余时间开发 5 种被动创收产品
原文：https://towardsdatascience.com/5-passive-income-generating-products-you-can-develop-in-your-spare-time-as-a-data-analyst-c3639800dcbd
找到你在这些产品中的位置将会帮助你获得额外的收入。
在 Unsplash 上由伊莎贝拉和莎·菲舍尔拍摄的照片
自从数据科学热潮开始以来，每个人和他们的猫都在开发产品出售，以产生被动收入。
当这些人开始建议其他数据分析师如何做同样的事情时，情况总是一样的:开一门课，写一本书，开一个 Youtube 频道。
除了现在，Udemy 上有成千上万的数据科学课程，当你在亚马逊上搜索“数据科学”寻找电子书时，会有超过 4 万个结果，Youtube 上的数据科学视频比我想的还要多。
作为一名数据分析师，开设一门课程、写一本书或开设一个 Youtube 频道来获得被动收入的建议是 10 年前的事了。如今，你需要积极主动、富有创造性、独一无二地想出如何从人群中脱颖而出，开发人们真正想买的产品。
数据科学产品市场的问题是很难从沙砾中筛选出金子。事实是，不是每个人都能教，不是每个人都能写，不是每个人都能创作出有趣的视频。然而人们仍然这样做。这意味着，即使你在这些类别中的任何一个都非常有天赋，你的理想客户在找到你的产品之前，也必须涉水过其他产品的海洋——如果他们找到你的产品的话。
因此，你需要提前五步考虑你的目标市场。他们到底在找什么？人们需要什么？我能给这个市场提供什么别人不能提供的东西？
这里的诀窍是从一开始就定位下来。不要开发如何学习 Python 的课程，不要写如何成为数据分析师的电子书，也不要创建 Youtube 视频教人们如何使用 Excel 和 Tableau 分析数据。这些想法都被打死了，不会让你获得任何额外收入。
但是你怎么发现你擅长什么呢？例如，我发表的关于数据科学的文章是面向那些希望过渡到数据科学的人，或者那些刚刚进入这个领域的人。我专注于撰写关于如何进入数据科学的文章，你需要从其他竞争对手中脱颖而出的技巧，如何编写更好的代码，如何学习数据科学，等等。这些文章关注的是成为一名数据科学家的初级步骤，尽管它们可能对该行业中更有经验的个人有用。我知道，如果我在数据科学的更多技术方面写更复杂的文章，我不会赚一毛钱，但我知道我可以帮助刚刚起步的人。
因此，考虑到这一点，是时候看看作为数据分析师，你可以在业余时间开发的五个简单项目了。这些项目可以出售，以产生被动收入，而不必每次都为新客户开发独特的产品。这些项目致力于开发即插即用的工具，人们可以购买这些工具，然后随心所欲地进行修改。这不仅让你的工作变得容易，而且如果客户正在寻找可以修改产品以满足他们需求的人，这也是一扇大门——这个人可能就是你。
Tableau 模板(销售文件)
Tableau 模板通常分为两类:独立的视觉效果或仪表板。
正如大多数数据分析师会告诉你的那样，在展示分析时，视觉效果往往是锦上添花。如果视觉效果能让你清楚地看到问题的核心，那么大量的赘述或总结通常会被丢弃或忽略。
在 Fiverr 上快速搜索发现，tableau 仪表盘的售价从 6 美元到 800 美元不等，数据可视化也在类似的范围内出售。在如此广阔的市场中脱颖而出的方法是开发既能吸引特定客户群又能让客户在收到文件后轻松定制的模板。
例如，您的模板可以面向石油和天然气行业，您知道该行业对某种类型的仪表板有特殊的偏好。或者，您可以将您的可视化效果更好地用于需要简单图形来描述其数据的小型企业。
应该花时间仔细地构造和注释这些文件，以确保可以轻松地更改颜色，修改标签，并相应地增加或减少所表示的数据量。
仪表板即服务(订阅)
以前产品的扩展是提供数据驱动的仪表板作为服务，客户可以通过按月或按年订阅来访问。
这是一项稍微复杂一点的服务，需要您与客户密切合作来开发和维护一个仪表板(可能使用现有的模板)，该仪表板以易于理解的格式提供公司的最新信息。
本质上，您将作为承包商在订阅期限内提供仪表板服务，并且需要亲自动手。根据您想要提供的服务级别，可能会涉及到错误修复、数据更新、分析代码等内容(专业提示:这可以使用以不同价格提供不同服务级别的分层订阅来确定)。
Python 代码片段(销售文件)
当你深入数据科学世界，每个人都是统计学家、编程大师、数据工程师和图形设计师时，当你浮出水面并意识到不是每个人都知道如何编码时，你会感到惊讶。更令人惊讶的是，人们通常更愿意花钱购买代码，而不是自己编写代码。
在这里，您可以通过出售有用的 Python 代码片段来提供丰富的专业知识。诀窍是编写你在别处找不到的代码。
例如，命令行 Python 工具可以免费找到，可能不会产生大量的被动收入。
然而，高度专业化的代码片段，如针对特定行业的网络爬行代码，可能会带来巨大的经济效益。或者，你可以出售一个 API(一段中介代码，允许两个应用程序相互对话)。与数据相关的 API 可以帮助公司报告数据、同步仪表板更新等等。
Excel 电子表格(销售文件)
如果你曾经见过一个没有数据意识的人开发的 Excel 文件，你会知道这是一堆乱七八糟的东西(我知道在阅读这篇文章时，你脑海中有一个你过去见过的 Excel 表格)。
信不信由你，人们在 Fiverr 上以 6 美元到 240 美元的价格出售 Excel 电子表格。有时候，让别人开发一个 Excel 表格比自己开发更容易。
要在 2000 多个可用的 Excel 电子表格服务中脱颖而出，至关重要的是您的电子表格服务于特定的利基市场。如前所述，这可能是小企业，自由职业者，或行业内的独特部门。此外，这些电子表格应该有一个额外的功能，让他们更进一步。例如，他们可能有一定程度的自动化，或者可能有一个简单的仪表板，以一种花哨但易于阅读的方式显示数据。
简而言之，如果人们愿意购买 Excel 表，你希望每次他们使用它时都有特殊的体验。
机器学习模型(订阅或出售文件)
我们最复杂的产品选项是一个机器学习模型，您可以通过订阅服务或作为文件出售。
小溪。加拿大阿尔伯塔省的 ML 公司开发了一个平台，允许任何人建立和销售自己的机器学习模型。在最基本的层面上，用户上传并标记他们的数据，然后训练他们的模型——就这么简单！模型托管和测试由 Stream 处理，因此您可以专注于构建一个产生结果的模型，以及一些被动收入。
或者，机器学习模型可以手工构建，并在 Fiverr 等自由职业网站上出售。机器学习服务目前的售价从 13 美元到 400 美元不等。
如上所述，要想在 Fiverr 上的 7000 多个机器学习服务中脱颖而出，你的模型需要瞄准一个利基市场。也许您想要开发一个模型来帮助小型企业估计有多少网站访问者会真正购买产品，或者您想要构建一个模型来为科学家提供一个模板，可以对该模板进行修改，以开始根据提供的图像数据来识别特定的植物物种。
关键是找到你的利基市场存在的问题，并使用机器学习模型解决它。
订阅让我的故事直接发到你的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将免费向您收取少量佣金):媒体会员
通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠
为了让您的数据科学游戏更上一层楼，您必须了解的 5 项知识
原文：https://towardsdatascience.com/5-pieces-of-knowledge-you-must-learn-to-take-your-data-science-game-to-the-next-level-ce8c9387a870
要在这个跨学科的领域出类拔萃，需要健康的技能组合
照片由丁在 Unsplash
“我真的很想进入数据科学领域。”
这是一个如今被随意使用的短语。在每个角落，都有另一个人强调他们想学习成为数据科学家所必需的技能。我承认目前的就业市场对这种技能有很大的需求，但即便如此，有时还是感觉范围很广。
但是，嘿，我愿意。你想成为一名数据科学家？那就说够了。是时候用一些知识来支持它了。
什么知识？
我很高兴你问了。
你必须学习 Python，特别是熊猫
爱你的人，保佑他们的灵魂，会因此恨我。
听着，我不是说 R 有什么问题(尽管 R 有很多问题)，但在这一点上我不会让步。
如果你想擅长数据科学，而不是仅仅涉猎它，你需要学习 Python。一旦你这样做了，你需要学习熊猫。
Pandas 是当今数据清理、处理和分析的黄金标准，其原因有很多:
- 作为一个 Python 模块，它的语法是可读的、简洁的，并且学习起来很合理。
- 它与 Python 作为一种语言的多功能性所允许的各种各样的其他任务无缝集成——构建 web 应用程序、使用云以及通用软件工程(见下一节)等等。
- 由于熊猫目前的受欢迎程度，工具正在不断开发，以使它变得更好。想要证据？看看这个 [1]。
Python 免费为您提供统计测试、数据操作、机器学习和许多其他功能。而且，也许最重要的是，它有一个专注而活跃的社区，随时愿意提供帮助。从最高的角度来看，数据科学是一项合作事业，Python(特别是 Pandas)积极支持这种合作。
围绕 r 的实用性有很多争论。虽然不是每个人都喜欢熊猫，但争议的声音明显不那么明显。
这是有原因的。
你必须学习基本的软件工程
我正在上一门独特的课，这是我本季度博士课程的一部分。有一个非常刻意的标题:面向数据科学家的软件开发。
作为一名数据科学家，你不需要像 T1 一样熟悉软件开发。但它肯定会帮助你找到工作，并在工作中表现出色。这里有几个原因可以解释为什么会这样:
- 作为一名数据科学家，您将与一组技术专家一起工作。
- 作为一名数据科学家，您需要一种方式来包装您的数据分析、见解和模型，并与整个世界进行交流。这可能会采取应用程序或系统的形式。
- 作为一名数据科学家，你将编写代码，或者与编写代码的人一起工作。因此，您应该了解编程的最佳实践。
这些都是你不必须在标准的编程入门课上学习的技能(重点是计算机科学的基础)，但是你会在软件工程课上学习。
它不一定是一门课——你可以在网上自学，或者只是通过参与项目来学习(这些可以说比上课更有效)。
但关键是:通过学习软件工程，你可以让自己有能力有效地分享和发展你从工作中获得的洞察力，从而将你的数据科学技能扩展到下一个层次。
你为什么不想这么做？
你必须学习实用统计学
无可否认，这是我自己可以改进的地方。统计学构成了数据科学的理论基础，不学也只能到此为止。
然而，你如何学习统计学很重要。让我解释一下我的意思。我有一个教授，他有数学学士学位，计算机科学博士学位，辅修统计学(作为博士学位的一部分)，都来自世界上两所顶尖的技术大学。实际上，她是个数学天才。
然而，当她在职业生涯后期转向数据科学时，她需要自学她使用的所有统计数据。她学到的所有正式统计数据都太深奥抽象了——不实用。
如果你对钻研数学有点犹豫，这是个好消息。作为一名成功的数据科学家，你不需要正式的数学学位，也不需要成为抽象证明的专家。你所做的需要的是你能够实际应用的数据科学中重要统计思想的概念性知识(例如，设计用户调查研究、运行假设测试、有效使用机器学习模型等)。).
这不一定是一个简单的任务，但它是一个非常可行的任务。网上有大量的资源供你使用。
祝你好运。
你必须学会简化和交流技术话题
如果数据不能被理解并随后被其他人用来做好事，那么来自数据的洞察力就没有什么用处。
让我再说一遍。
如果数据不能被理解并随后被其他人用来做好事，那么来自数据的洞察力就没有什么用处。
我不在乎你是否写了世界上最先进的将改变地球命运的模型——如果你不能以人们理解的方式与他们分享，这将没有什么好处。
你可能想知道为什么。毕竟，如果我可以应用模型并获得结果，这还不够吗？
要是世界有那么简单就好了。单靠一个人无法实现大规模的变革——你需要与团队、利益相关者、有钱人、有权力的人合作。你需要让他们相信你的工作是优秀的和开创性的。您需要在数据科学工作中采纳复杂的想法，并让非技术专家也能理解。
这包括两个部分:
- 有效的沟通。
- 把复杂的、相互关联的现象分解成它们的组成部分。
两者都有练习的方法。为了学会良好的沟通，你可以考虑参加写作或口语课程。至于第二点，形式上更难实现；这是一项日积月累的技能，通过不断练习向他人解释你的想法和工作。那么做吧。
但是无论你做什么，都不要轻视这一点。如果你没有办法传达，一百万个伟大的想法并不比 0 好。
你必须学会欣赏非技术性的东西
如果你痴迷于数字、计算和模型，却对偏见、伦理和社会一无所知，你就不应该被允许接近数据科学。
有效的数据科学超越了统计学和计算机科学。还有一个经常被忽视的第三个重要组成部分:领域知识。数据科学的主要目的是解决特定领域(如生物学、经济学、社会学、政治学等)的问题。).虽然你可能是数字和程序的大师，但你最有可能是而不是常驻领域的特殊偏见和微妙之处的大师。
在开发各种问题的数据解决方案时，与领域专家交流是绝对必要的。忽视这一步就是你如何以不准确、有偏见的模型告终，这些模型有可能弊大于利。
总结和最终想法
这里回顾了数据科学的 5 个必备基础知识:
- 学 Python 。具体来说，学熊猫。这是处理数据的黄金标准。
- 学习基础软件工程。T2 编写 T3 程序是一回事，但是如果你能让 T4 设计 T5 程序，你就能把你的市场推广能力提升到一个全新的水平。
- 学实用统计学。这是数据科学的基础，你最终必须学会它。你只能假装这么多。
- 学会简化复杂的想法，并进行沟通。人们需要知道你从数据中发现了什么。你需要知道如何告诉他们。
- 学会欣赏数据科学的非技术层面。这不全是数字的问题。从来都不是。
如果你想成为一名数据科学家，我不能给你一个确切的蓝图。这将涉及狂热的探索，一些尝试和错误，可能还有一些失败的尝试(就像数据科学本身一样)。
然而，我可以给你一些技巧的概要，如果你选择这条路，这些技巧将会非常有用——这正是我在上面的文章中所做的。
剩下的就看你的了。
想擅长 Python？ 获取独家、免费获取我简单易懂的指南点击 。想在介质上无限阅读故事？用我下面的推荐链接注册！
https://murtaza5152-ali.medium.com/?source=entity_driven_subscription-607fa603b7ce---------------------------------------
参考
【https://ponder.io/】
https://dl.acm.org/doi/abs/10.1145/3457607?【1】casa _ token = 7 x2 AC 2 uxljaaaaa:AvxyPMfvvCo-F4 uexo-9 _ IPTHGXOm-09lV-1 osiod 33 shaffefzaqx 3 acsy 7 mykvj 1 tgz 40 iynmxw
掌握 SQL 的 5 个实用 SQL 示例
原文：https://towardsdatascience.com/5-practical-sql-examples-to-master-sql-group-by-7877ddf03ba8
数据科学
在不到 10 分钟的时间内，通过使用案例轻松完成复杂的 SQL 分组
照片由 Mariah Hewines 在 Unsplash 上拍摄
SQL 中的 GROUP BY，解释
SQL——结构化查询语言——是从关系数据库中提取数据并进行转换的广泛使用的工具。
没有数据聚合，数据转换是不完整的，数据聚合是 SQL 中的一个重要概念。如果没有 GROUP BY，数据聚合是不可能的！因此，掌握 GROUP BY 以轻松执行所有类型的数据转换和聚合非常重要。
在 SQL 中，GROUP BY 用于数据聚合，使用聚合函数。如SUM()、MIN()、MAX()、AVG()、COUNT()。
但是，为什么聚合函数与 GROUP BY 一起使用？
在 SQL 中，GROUP BY 子句用于将行组合在一起。因此，当您在列上使用聚合函数时，结果描述了特定行组的数据。
在这篇文章中，我解释了在 SQL 查询中使用 GROUP BY 子句的 5 个例子，这将帮助你毫不费力地使用**GROUP BY**。
我把这篇文章写得很短，这样您就可以快速地完成它，并掌握 SQL 中的一个重要概念。
您可以使用此索引快速导航到您最喜欢的部分。
**·** [**GROUP BY with Aggregate Functions**](#4778) **·** [**GROUP BY without Aggregate Functions**](#23c7) **·** [**GROUP BY with HAVING**](#0ecc) **·** [**GROUP BY with ORDER BY**](#eeb2) **·** [**GROUP BY with WHERE, HAVING and ORDER BY**](#139a)
📍注意:我正在使用 SQLite DB 浏览器和一个自己创建的销售数据使用 Faker 创建。可以在我的 Github repo 上 MIT License 下免费获得！
这是一个简单的 9999 x 11 数据集，如下所示。
虚拟销售数据集|作者图片
好了，我们开始吧…
在继续之前，请记住下面的一条分组规则..
当您在 SQL 查询中使用GROUP BY时，那么SELECT语句中的每一列必须要么出现在GROUP BY子句中，要么作为参数出现在聚合函数中。
现在，让我们从最简单的用例开始。
使用聚合函数进行分组
这是最常用的场景，您可以在一个或多个列上应用聚合函数。如上所述，GROUP BY只是将在指定的列中具有相似值的行组合在一起。
举个例子，假设你想得到每个产品类别的单价的统计摘要。这个例子具体解释了如何使用所有的集合函数。
您可以使用以下查询获得这样的统计摘要—
SELECT Product_Category,
MIN(UnitPrice) AS Lowest_UnitPrice,
MAX(UnitPrice) AS Highest_UnitPrice,
SUM(UnitPrice) AS Total_UnitPrice,
AVG(UnitPrice) AS Average_UnitPrice
FROM Dummy_Sales_Data_v1
**GROUP BY Product_Category**
SQL | Image 中的数据聚合(按作者)
正如您在上面的查询中看到的，您使用了两列— Product_Category 和unit price——后者总是在聚合函数中使用。因此，GROUP BY子句只包含剩下的一列。
你可以注意到， Product_Category 中的第一条记录是**NULL**，这意味着GROUP BY将 Product_Category 中的所有NULL值合并到一个组中。这符合微软 指定的 SQL 标准
如果分组列包含空值，则所有空值都被视为相等，并将它们收集到一个组中
此外，默认情况下，结果表按照GROUP BY中列的升序排序，其中NULL(如果存在)位于顶部。如果您不想让 NULL 成为结果表的一部分，您可以随时使用**COALESCE**函数并给NULL一个有意义的名称，如下所示。
SELECT **COALESCE(Product_Category,'Undefined_Category') AS Product_Category**,
MIN(UnitPrice) AS Lowest_UnitPrice,
MAX(UnitPrice) AS Highest_UnitPrice,
SUM(UnitPrice) AS Total_UnitPrice,
AVG(UnitPrice) AS Average_UnitPrice
FROM Dummy_Sales_Data_v1
**GROUP BY Product_Category**
SQL GROUP BY | Image by Author 中的空值
🚩这里需要注意的重要一点是—
尽管
COALESCE应用于 Product_Category 列，但您实际上并没有从该列中聚合值。所以，它一定是 GROUP BY 的一部分。
这样，您可以在SELECT语句中添加您需要的任意多的列，在一些或所有列上应用聚合函数，并在GROUP BY子句中提及剩余的列名，以获得想要的结果。
嗯，这是关于使用GROUP BY和聚合函数。但是，您也可以在没有聚合函数的情况下使用该子句，下面将进一步解释。
不带聚合函数的 GROUP BY
尽管大多数情况下GROUP BY与聚合函数一起使用，但它仍然可以在没有聚合函数的情况下使用——用来查找唯一记录。
例如，假设您想要检索 Sales_Manager 和 Product_Category 的所有唯一组合。使用 GROUP BY，这非常简单。您所需要做的就是，在SELECT中提及您在GROUP BY中提及的所有列名，如下所示。
**SELECT Product_Category,
Sales_Manager**
FROM Dummy_Sales_Data_v1
**GROUP BY Product_Category,
Sales_Manager**
不带聚合函数的 SQL GROUP BY 按作者排序的图像
在这一点上，有些人可能会说，在列名之前使用**DISTINCT**关键字可以获得相同的结果。
然而，这里有两个主要原因，为什么你应该选择GROUP BY而不是DISTINCT来获得唯一的记录。
- 默认情况下，GROUP BY 子句获得的结果按升序排序。因此，您不需要单独对记录进行排序。
- 当您处理具有数百万行的数据集并且您的 SQL 查询包含连接时，DISTINCT 的开销可能会很大
因此，使用 GROUP BY 可以有效地从数据库中获得唯一的记录，即使您在查询中使用多个连接。
你可以在我以前的一篇文章中读到另一个有趣的GROUP BY子句用例——
💔-ultimate-ways-to-find-unique-records-in-sql-6ddf8ae567b0>
接下来，让我们进一步了解如何以有效的方式限制 GROUP BY 子句获得的输出。
用 HAVING 分组
在 SQL 中，HAVING的工作逻辑与WHERE子句相同，唯一的区别是它过滤一组记录，而不是每隔一条记录过滤一次。
例如，假设您想要获得具有产品类别、销售经理 & 运输成本的唯一记录，其中运输成本大于 34 。
这可以通过使用下面给出的WHERE和HAVING条款来实现。
***-- WHERE clause***SELECT Product_Category,
Sales_Manager,
Shipping_Cost
FROM Dummy_Sales_Data_v1
**WHERE** **Shipping_Cost >= 34**
**GROUP BY** Product_Category,
Sales_Manager,
Shipping_Cost***-- HAVING clause***SELECT Product_Category,
Sales_Manager,
Shipping_Cost
FROM Dummy_Sales_Data_v1
**GROUP BY** Product_Category,
Sales_Manager,
Shipping_Cost
**HAVING Shipping_Cost >= 34**
按 WHERE 和 HAVING in GROUP BY | Image by Author 输出相同
尽管上述两个查询生成相同的输出，但逻辑完全不同。WHERE子句在GROUP BY之前执行，所以本质上它扫描给定条件的整个数据集。
但是，HAVING是在GROUP BY之后执行的，所以它扫描的记录数量相对较少，因为行已经被分组在一起。所以HAVING是一个节省时间的地方。
好吧，假设你不太关心效率。但是，现在您想要总运费超过 6000 的所有产品类别和销售经理。而这正是HAVING派上用场的时候。
这里，要过滤这里的记录，您需要使用条件SUM(Shipping_Cost) > 6000，并且您不能在WHERE子句中使用任何聚合函数。
在这种情况下，你可以像下面这样使用HAVING
SELECT Product_Category,
Sales_Manager,
SUM(Shipping_Cost) AS Total_Cost
FROM Dummy_Sales_Data_v1
**GROUP BY** Product_Category,
Sales_Manager
**HAVING SUM(Shipping_Cost) > 6000**
SQL GROUP BY have | Image BY Author
由于您在 Shipping_Cost 上使用了聚合，所以在GROUP BY中不需要提及。从逻辑上讲，所有的行根据产品类别和销售经理分组，然后HAVING在所有这些组中扫描给定的条件。
因此，HAVING与GROUP BY结合使用是一种优化的方式，用于根据条件过滤行。
🚩注意:由于 HAVING 在 SELECT 之前执行，因此不能在 HAVING 子句的条件中使用列别名。
此外，尽管GROUP BY按照升序或字母顺序排列记录，但有时您可能希望按照聚合列来排列记录。这时ORDER BY跳了进来。
分组依据和排序依据
在 SQL 中，ORDER BY用于对结果进行排序，默认情况下，它以升序对结果进行排序。然而，要以降序获得结果，只需在ORDER BY子句中的列名之后添加关键字DESC。
让我们继续上面的例子。你可以看到最后一个结果是按字母升序排列的，首先是列产品类别，然后是销售经理。但是，最后一列中的值 Total_Cost 没有排序。
如下所述，这可以通过使用ORDER BY子句来具体实现。
SELECT Product_Category,
Sales_Manager,
**SUM(Shipping_Cost) AS** **Total_Cost**
FROM Dummy_Sales_Data_v1
GROUP BY Product_Category,
Sales_Manager
**ORDER BY Total_Cost DESC**
SQL 中的降序排序|按作者排序图像
显然，最后一列现在是按降序排列的。此外，您可以看到，现在前两列中的值没有特定的顺序。这是因为，你只把它们包含在GROUP BY中，而没有包含在ORDER BY子句中。
这个问题可以通过在ORDER BY条款中提及它们来解决，如下—
SELECT Product_Category,
Sales_Manager,
SUM(Shipping_Cost) AS Total_Cost
FROM Dummy_Sales_Data_v1
GROUP BY Product_Category,
Sales_Manager
**ORDER BY Product_Category,
Sales_Manager,
Total_Cost DESC**
按 SQL 中的多列排序|按作者排序图像
现在，前两列按升序排列，只有最后一列— Total_Cost —按降序排列。这是因为关键字DESC只在这个列名之后使用。
🚩这给了你一个重要的学习收获—
您可以按不同顺序排列多列 SQL 结果数据集，即按升序排列一些列，其余按降序排列。但是，请注意列名在ORDER BY中的顺序，因为它会改变结果集。
在这种情况下，理解 GROUP BY 是如何工作的很重要。你有没有问自己一个问题—
为什么在降序 order❓中看不到
Total_Cost列中的所有值
因为在GROUP BY中只提到了前两列。仅根据这两列中的值对所有记录进行分组，并通过合计 Shipping_Cost 列中的值来计算总成本。
因此，最终结果中的总成本值是基于这些组而不是整个表进行排列的。
接下来，让我们探索一个示例，它将进一步帮助您理解过滤记录之间的区别以及何时将WHERE和HAVING与GROUP BY结合使用。
GROUP BY with WHERE，HAVING 和 ORDER BY
到目前为止，您已经阅读了本文中的所有概念，让我们直接从一个示例开始。
假设您想要获取所有未交付给客户的订单的销售经理和产品类别的列表。同时，您希望只显示那些在运输特定产品类别的产品上花费超过 1600 美元的销售经理。
现在，你可以通过以下三个步骤来解决这个问题
- 使用条件
Status = ‘Not Delivered’过滤所有记录。因为这是一个非聚合列，所以可以使用 WHERE。 - 使用条件
SUM(Shipping_Cost) > 1600根据总运费过滤记录。因为这是一个聚合列，所以应该使用 HAVING。 - 为了计算总运费，您需要使用
GROUP BY按照销售经理和产品类别对记录进行分组
如果您正在跟进，您的查询应该看起来像这样—
SELECT Sales_Manager,
Product_Category,
SUM(Shipping_Cost) AS Total_Cost
FROM Dummy_Sales_Data_v1
**WHERE Status = 'Not Delivered'**
GROUP BY Sales_Manager,
Product_Category
**HAVING SUM(Shipping_Cost) > 1600**
SQL GROUP BY with WHERE and HAVING | Image BY Author
它给出了满足示例中提到的条件的销售经理和产品类别的所有唯一组合。
您可以注意到，前两列是按升序排列的。此外，用红色圈出的两行显示了同一销售经理的产品类别的升序。这是证据，默认情况下，GROUP BY 按升序排列记录。
这就是分组依据！
希望你很快看完这篇文章，觉得耳目一新，很有用。
在过去的 3 年里，我一直在使用 SQL，我发现这些替代方法非常省时，而且功能强大，尤其是在处理大型数据集时。在实际项目中，对这些概念的深刻理解是非常重要的。
有兴趣阅读更多介质上的故事？？
💡考虑 成为媒体会员 到访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡不要忘记 注册我的电子邮件列表 来接收我的文章的第一份副本。
感谢您的阅读！
2022 年你应该知道的 5 个实用 SQL 查询
原文：https://towardsdatascience.com/5-practical-sql-queries-you-should-know-in-2022-11b428560a30
数据科学
快速掌握这些省时且强大的 SQL 查询
由路易斯·科尔特斯在 Unsplash 上拍摄
SQL 无处不在！💯
SQL 或结构化查询语言是任何数据专业人员的必备工具，如数据工程师、分析师或数据科学家或任何与数据打交道的人。
为了有效地获得干净和所需的数据，了解不同的 SQL 查询和操作符是绝对必要的。因此，我列出了 5 个 SQL 查询，并附有例子和解释，你应该在 2022 年知道。
我把这篇文章写得很短，这样您就可以快速地完成它，并掌握最有用、最省时的 SQL 技巧。🏆
您可以使用此索引快速导航到您最喜欢的部分。
**·** [**How to Find Duplicate Values in SQL**](#87df) **·** [**How to avoid duplicates and select unique rows**](#3b2c) **·** [**How to display Nth row in the data table**](#d55a) **·** [**How to compute the cumulative total**](#f65c) **·** [**How to select words where a specific letter is at specific position**](#4750)
📍注意:我使用的是 SQLite DB 浏览器和自己创建的 Dummy_Sales_Data ，你可以在我的 Github repo 上免费获得！
好了，我们开始吧…🚀
首先，让我向您展示数据是怎样的。
虚拟销售数据|作者图片
这是一个简单的 9999 x 11 数据集，是我在文章 Faker:一个令人惊叹且极其有用的 Python 库 中创建的。📚
📚您可以使用这个 SQLite 数据库 来跟踪本文中的查询。
如何在 SQL 中查找重复值
在数据集中发现重复主要是关于质量检查和数据验证。
在处理数据处理任务时，您可能会在数据集中遇到重复的行。如果没有提前处理好，这些重复的值会打乱整个计算。
SQL 提供了一个简单的解决方案，使用**GROUP BY**和**HAVING**来识别和消除重复值。✅
在进入查询之前，非常重要的一步是定义重复项。
📌您需要定义哪些值/列的组合可以被认为是重复的。这完全取决于您的数据集和您正在执行的任务。
例如，在我们的数据集中查找单个列 Sales_Manager 中的重复值。
SELECT Sales_Manager, COUNT(*)
FROM Dummy_Sales_Data_v1
**GROUP BY** Sales_Manager
**HAVING COUNT(*)>1**
单列重复|按作者排序的图像
在上面代码的最后一行，**HAVING COUNT(*)>1** 我们指定了识别重复项的条件。这意味着，每当列中的特定值在数据集中出现不止一次时，它就是重复的。
让我们看另一个场景..
考虑到列 Sales_Manager 、 Shipping_Address 、Status 中的值组合重复，作为重复行。
这里应用了相同的逻辑，只是您需要在 SELECT 语句和 GROUP BY 子句中提到所有的列名。
SELECT **Sales_Manager,
Shipping_Address,
Status,**
COUNT(*)
FROM Dummy_Sales_Data_v1
GROUP BY **Sales_Manager,
Shipping_Address,
Status**
HAVING COUNT(*)>1
使用 SQL | Image by Author 在数据集中查找重复的行
这里，生成最后一列— COUNT()* 只是为了提供信息。即使不包括该列，查询仍然有效。
使用该查询可以回答的另一个有趣的问题是—特定记录在数据集中出现了多少次。
同时，这个查询也可以用来了解数据集中有多少以及哪些是不重复的记录。你所需要做的就是简单地让 having 子句中的COUNT(*)等于 1，作为**HAVING COUNT(*)=1** 。
在识别出重复行之后，您可能希望只保留重复行的一个外观。下一个查询解释了如何做到这一点。
如何避免重复并选择唯一的行
一旦确定了重复的行，并且希望每行只出现一次，就在 select 语句中使用**DISTINCT**,如下所示。
SELECT **DISTINCT** Sales_Manager,
Shipping_Address,
Status
FROM Dummy_Sales_Data_v1
GROUP BY Sales_Manager,
Shipping_Address,
Status
使用 DISTINCT | Image by Author 在数据集中选择唯一的行
由于DISTINCT使得查询只返回唯一的记录，所以它有时会被错误地用来隐藏错误查询(比如不正确的 SQL 连接)产生的重复记录。
📌最好的办法是在你使用
DISTINCT的时候提一个评论，并在那里提到使用DISTINCT的原因。
实现这一点的另一种方法是定义一个或多个标准，这通常是计算的形式，例如包括某一列的最小值、最大值。
例如，只保留重复行的一个外观，其中 Shipping_Cost 最小。
SELECT Sales_Manager,
Shipping_Address,
Status,
**min(Shipping_Cost)**
FROM Dummy_Sales_Data_v1
GROUP BY Sales_Manager,
Shipping_Address,
Status
按作者选择 SQL | Image 中的唯一行
DISTINCT的主要目的是返回唯一的记录。然而，几乎 90%的时候，我发现GROUP BY更方便，因为我总是想做一些其他的计算。
转到下一个有趣的问题..
如何显示数据表中的第 n 行
有时，您需要从数据集中选择特定行号的一条记录或从特定行号开始的多条记录。
在这个场景中，SQL 提供了一个非常有用的函数——**OFFSET()**——它在返回输出之前跳过指定的行数。
OFFSET可与LIMIT(返回指定的行数)一起使用，以返回第 n 行或从第 n 行开始的行数。
例如，让我们使用 OFFSET 和 LIMIT 从数据集中返回第 2 行。
SELECT *
FROM Dummy_Sales_Data_v1
**LIMIT 1
OFFSET 1**
使用偏移和限制|作者图像在 SQL 中选择第 n 行
因为我们想只提取第 2 行，即我们想跳过 1 行。这就是为什么OFFSET 1用于跳过 1 行，而LIMIT 1只返回 1 行作为输出。
❓:这也是一个常见的面试问题，要求候选人显示数据集中最高的 2 到 6 个价格，即不显示最高价格，而是从第二高的价格开始的 5 个最高价格。
让我向你展示如何使用OFFSET & LIMIT来实现这一点。
SELECT *
FROM Dummy_Sales_Data_v1
**ORDER BY UnitPrice DESC**
**LIMIT 5**
**OFFSET 1**
按作者显示数据集|图像中的第 n 个最高价格
查询只会返回上图中红色圈出的部分。
逻辑很简单→我们使用ORDER BY按降序排列价格，使用OFFSET跳过输出中的 1 行，使用LIMIT只返回 5 行。
✅用这种方法你可以保持你的代码整洁，易于解释和展示你有效地实现不同命令的能力。
接下来，让我们看一个有趣的工具来跟踪您的业务 KPI..
如何计算累计总数
累计总计(也称为运行总计)是指特定列中下一个单元格之前的一列的所有单元格中的值的总和。
简而言之，列的第 5 行中的累积总计是同一列的第 1 行到第 5 行中所有值的总和。
累积总计显示随着时间或其他序列增长的数据总和。
跟踪 KPI 的进度是非常流行和有用的，因为它可以用作跟踪 KPI 是否达标的指标。💯
因此，了解可以在这种情况下使用的 SQL 查询是非常重要的。在 SQL 中，可以使用窗口函数**OVER()**轻松计算累计总数，如下所示。
在我们的数据集中，让我们获得订单交付到意大利的数量的累计总数，其中销售经理是玛利亚。
SELECT Sales_Manager,
OrderDate,
Quantity,
**SUM(Quantity)
OVER (ORDER BY OrderDate) as Cumulative_total_order**
FROM Dummy_Sales_Data_v1
WHERE Sales_Manager = 'Maria'
AND Product_Category = 'Healthcare'
AND Status = 'Delivered'
AND Shipping_Address = 'Italy'
ORDER BY OrderDate
SQL | Image 中按作者的累计总数
如上图所示，第 2 行第 4 列的值70实际上是第 3 列前两行的29和41的相加。同样的逻辑一直延续到最后。
📌窗口函数OVER()创建一个由 OrderDate 排列的整个数据集的临时窗口，SUM(Quantity)仅应用于该临时窗口。
如上图所示，第 7 行第 4 列的值459是326 + 74 + 59的结果。这是因为，我们在订单日期上创建了一个临时窗口，对于第 7-8 行，订单日期是相同的。
这是最后一个非常有用的命令，可以有效地选择数据。
如何选择特定字母在特定位置的单词
有时，在提取数据时，您所知道的只是某一列中文本值的特定位置上的字符、字母或数字。您需要提取所有符合这个标准的行。
SQL 操作符**LIKE**在这种情况下非常方便。它在**WHERE**子句中用于搜索列中的指定模式。
只有两个通配符你应该记住。
1️⃣ **%**(百分号):表示零到多个字符
2️⃣ **_**(下划线符号):恰好表示一个字符
现在，让我们看看这是如何处理实际查询的。
假设，您希望获得数据集中产品类别和销售经理的唯一组合，其中 Product_Category 中值的最后一个字符是**e**，而 Sales_Manager 中值的第二个字符是**a**。
SELECT DISTINCT Product_Category,
Sales_Manager
FROM Dummy_Sales_Data_v1
WHERE Product_Category **LIKE '%e'**
AND Sales_Manager **LIKE '_a%'**
SQL 中的通配符 LIKE 运算符|按作者排序的图像
以上结果正是你想要的。在上述 SQL 查询的倒数第二行中，**LIKE ‘%e’** 用于提取值中有多个字符但以 e 结尾的所有产品类别。
类似地，带有**LIKE ‘_a%’** 的 SQL 查询的最后一行用于获取销售经理列中的所有值，这些值从开始就只有一个字符(仅由一个下划线符号**_**表示)，然后是字符**a**，在**a**之后有零个或多个字符(由百分号**%**表示)。
实现这个查询无疑展示了您在 SQL 的LIKE操作符中使用通配符的熟练程度。
仅此而已！
希望你很快看完这篇文章，觉得耳目一新，很有用。
我在过去的 3 年里一直在使用 SQL，我发现这些技巧非常省时，而且在一段时间内非常有效。此外，我发现其中一些问题是很好的面试问题。
对阅读介质上的无限故事感兴趣？？
💡考虑 成为媒体会员访问媒体上无限的故事和每日有趣的媒体文摘。我会得到你的费用的一小部分，没有额外的费用给你。
💡不要忘记 注册我的电子邮件列表 来接收我文章的第一份拷贝。
感谢您的阅读！
机器学习中的 5 种概率训练数据采样方法
原文：https://towardsdatascience.com/5-probabilistic-training-data-sampling-methods-in-machine-learning-460f2d6ffd9
合适的数据采样方法对于训练一个好的模型很重要
照片由 Testalize.me 在 Unsplash 上拍摄
模型训练中的数据采样是机器学习中一个被忽视的领域。机器学习有两个方面:建模和数据。这两者同等重要，在现实生活的机器学习项目中应该仔细考虑。然而，许多教科书、论文、博客都谈到了建模方面，很少有人谈到数据方面。
我们在这里使用“数据”而不是“数据集”，因为它们的概念不同:“数据集”是有限的、固定的和静止的，而“数据”是无限的、不固定的和动态的。当我们训练一个模型的时候，我们没有办法接触到世界上所有相应的可能数据；要使用的数据是由一些抽样方法创建的子集。数据充满了潜在的偏差，这可能是由于收集、采样或标记数据过程中的一些人为因素造成的。由于偏差在基于此数据训练的模型中是永久存在的，因此对能够减少数据中偏差的适当子集进行采样是至关重要的。
因此，了解不同的抽样方法是很重要的，因为首先，它帮助我们避免数据中的潜在偏差，其次，它帮助我们提高训练中的数据效率。
在数据采样期间，为了训练可靠的模型，采样的子集应该代表真实世界的数据，以减少选择偏差【1】。幸运的是，概率数据采样方法可以帮助我们认识到这一点。在这里，我将介绍五种在模型训练中有代表性的概率数据采样方法。
简单随机抽样
Volodymyr Hryshchenko 在 Unsplash 上拍摄的照片
这是最简单的概率抽样形式。总体中所有样本被抽样的机会相同，因此它们的概率形成均匀分布。例如，如果您想从 10 个样本中抽取 5 个样本，那么每个元素被选中的概率是 0.5。
该方法简单明了，易于实现，但总体中的稀有类可能不会在选择中被采样。假设您想从数据中抽取 1%的样本，但是一个稀有类只出现在 0.01%的总体中:这个稀有类的样本可能不会被选择。在这种情况下，用采样子集训练的模型可能不知道稀有类的存在。
分层抽样
由 KAZTO TAKAHASHI 在 Unsplash 上拍摄的照片
为了避免简单随机抽样的缺点，您可以根据您的要求，例如标签，将人群分成几组，并从每组中单独抽样。每一组被称为一个阶层，这种方法被称为分层抽样。
例如，要从具有 A 类和 B 类的总体中抽取 1%的样本，可以将总体分成两组，分别从这两组中抽取 1%的样本。这样，无论 A 或 B 有多稀有，采样的子集都保证包含这两类。
然而，分层抽样的一个缺点是总体并不总是可分的。例如，在每个样本具有多个标签的多标签学习任务中，根据不同的标签来划分群体是具有挑战性的。
加权抽样
廷杰伤害律师事务所在 Unsplash 上的照片
在加权抽样中，每个样本都被赋予一个权重，即被抽样的概率。例如，对于包含 A 类和 B 类的总体，如果将权重 0.8 分配给 A 类，0.2 分配给 B 类，则 A 类和 B 类被抽样的概率分别为 80%和 20%。
权重抽样可以利用领域专业知识，这对减少抽样偏差很重要。例如，在训练一些在线学习模型时，最近的数据比旧数据重要得多。通过为最近的数据分配较大的权重，为旧数据分配较小的权重，可以更可靠地训练模型。
储层取样
乔纳森·比恩在 Unsplash 上拍摄的照片
油藏采样是一种有趣而优雅的算法，用于处理在线学习模型中的流数据，在产品中相当流行。
假设数据是以顺序流的方式产生的，比如一个时间序列，你不可能把所有的数据都装进内存，也不知道以后会产生多少数据。你需要用 k 个样本对一个子集进行采样来训练一个模型，但是你不知道选择哪个样本，因为很多样本还没有生成。
储层采样可以处理这个问题，即 1)所有样本以相等的概率被选择，以及 2)如果你在任何时候停止算法，样本总是以正确的概率被选择。该算法包含 3 个步骤:
- 将前 k 个样本放入一个容器中，这个容器可以是一个数组或一个列表
- 当产生第 n 个样本时，在 1 到 n 的范围内随机选择一个数字 m 。如果选择的数字 m 在 1 到 k 的范围内，则用生成的第 n 个样本替换库内的第 m 个样本，否则不做任何操作。
- 重复 2，直到算法停止。
我们很容易证明，对于每一个新生成的样本，被选入储层的概率是 k / n 。我们还可以证明，对于每一个已经在油藏中的样本，不被替换的概率也是 k / n 。因此，当算法停止时，以正确的概率选择储层中的所有样本。
重要性抽样
由absolute vision在 Unsplash 上拍摄的照片
重要抽样是最重要的抽样方法之一。当我们只能访问另一个发行版时，它允许我们从一个发行版中取样。
例如，我们想要从分布 P(x) 中取样，但是不能访问它。然而，我们可以访问另一个分布 Q(x) 。下面的等式表明，在期望中，从 P(x) 采样的 x 等于从 Q(x) 采样的 x 由 P(x)/Q(x) 加权。
因此，可以替代从 P(x) 采样，也可以从可访问的 Q(x) 采样，并用 P(x)/Q(x) 对采样结果进行加权。结果与我们直接从 P(x) 取样的结果相同。
结论
在这篇文章中，我介绍了 5 种用于模型训练的代表性概率数据采样方法。这些方法是任务不可知的，可以用于各种机器学习领域的所有任务:计算机视觉、NLP、强化学习和表格数据分析等。使用哪种采样方法取决于特定的任务、数据集、问题设置以及您希望从模型中得到什么。我建议先用一个简单的方法，比如简单的随机抽样，随着你理解的深入再换成其他方法。乍一看，您可能会发现这很难，但是随着模型训练和数据监控的进展，事情会变得清楚。
参考
样本选择偏差作为规格错误，1979 年
设计机器学习系统，2022
https://dushuchen.medium.com/membership
学习 5 个 Python 库，开始您的数据科学生涯
原文：https://towardsdatascience.com/5-python-libraries-to-learn-to-start-your-data-science-career-2cd24a223431
掌握这些图书馆，让你的职业道路更加顺畅
图像由 200 度上的像素显示
如果你想学习 Python 进行数据科学开始一个新的职业生涯，我敢肯定你正在纠结这些东西要不要去了解和掌握。我知道你被所有这些新概念弄得不知所措，包括你应该知道的所有数学知识，你可能会觉得你永远也不会达到新工作的目标。
我知道:职位描述对此没有帮助。数据科学家似乎真的是外星人；有时甚至是大三学生。
在我看来，需要掌握的一个重要技能是学会如何停止“我必须知道一切”的恐惧。相信我:尤其是在开始的时候，如果你在追求一个初级职位，你绝对没有必要什么都知道。嗯，说实话:即使是老年人也不是什么都知道。
因此，如果你想在数据科学领域开始职业生涯，在本文中，我向你展示了你绝对必须知道的五个 Python 库。
1.蟒蛇
正如我们在他们的网站上看到的，Anaconda 是:
世界上最受欢迎的开源 Python 分发平台
Anaconda 是专门为数据科学创建的 Python 发行版；所以它不是一个严格意义上的库，但是我们可以把它当作一个库，因为在软件开发中，库是相关模块的集合；因此，既然 Anaconda 为数据科学家提供了所有必备的东西——包括最常用的包——我们可以将它作为一个库，也是您的必备之物。
Anaconda 提供的第一个重要的东西是 Jupyter Notebook ，它是:
用于创建和共享计算文档的原始 web 应用程序。它提供了一种简单、精简、以文档为中心的体验。
朱庇特笔记本。图片作者。
Jupyter Notebook 是一个在本地机器上运行的 web 应用程序，它是专门为数据科学家创建的。使它对数据科学家有吸引力(并且非常有用)的主要重要特征是，每个细胞都独立运行，这使我们有可能:
- 在独立单元格内做数学和编码实验，不影响整个代码。
- 如果需要，在每个单元格中写入文本；这使得 Jupyter 笔记本成为用您的代码展示科学作品的完美环境(因此，如果您愿意，您可以忘记 Latex 环境)。
要开始使用 Jupiter 笔记本，我建议你在这里阅读本指南。
然后，当你获得经验时，你可能需要一些捷径来加快你的经验。你可以在这里使用本指南。
另外，如前所述，Anaconda 为我们提供了数据科学所需的所有包。这样我们就不用安装它们了。比如说你需要“熊猫”；如果没有 Anaconda，您需要在终端中键入$ pip install pandas来安装它。有了 Anaconda，你不必这样做，因为它为我们安装了熊猫。一个非常好的优势！
2.熊猫
Pandas 是一个库，可以让你导入、操作和分析数据。在他们的网站上，他们说
pandas 是一个快速、强大、灵活且易于使用的开源数据分析和操作工具，建立在 Python 编程语言之上。
如果你想处理数据，你绝对需要精通熊猫，因为现在，它被数据科学家和分析师广泛使用。
Pandas 的强大之处在于这个库使我们能够处理表格数据。在统计学中，表格数据是指组织在具有行和列的表格中的数据。我们通常将表格数据称为数据框。
这很重要，因为我们在很多情况下都使用表格数据；例如:
- 用 excel 文件。
- 带 CSV 文件。
- 有了数据库。
数据框是表格数据的表示形式。图片来自熊猫网站:https://pandas.pydata.org/docs/getting_started/index.html
许多公司的现实是，不管你的角色是什么，你总是要以某种方式处理 excel/CSV 和/或数据库中的数据；这就是为什么熊猫是你需要掌握的基本资源。
此外，考虑到你甚至可以访问数据库中的数据，并将它们直接输入到你的 Jupyter 笔记本中，以便对熊猫进行进一步的分析。我们可以使用一个名为PyOdbc的库来实现。看看这里的。
3.Matplotlib
在对 Pandas 进行数据操作和分析后，您通常会想要绘制一些图。这可以通过 matplotlib 完成，它是:
一个全面的库，用于在 Python 中创建静态、动画和交互式可视化
Matplotlib 是我建议您使用的第一个绘制图形的库，因为它被广泛使用，并且在我看来，它有助于您获得编码经验。
Matplotlib 帮助我们绘制我们可能需要的最重要的图:
- 直方图或条形图等统计图表。
- 散点图。
- 箱线图。
还有很多。你可以从 Matplotlib 这里开始，使用他们的教程。
4.海生的
在某一点上，当你获得了分析数据的经验，你可能对 Matplotlib 不完全满意；主要是(根据我的经验)这可能是由于这样一个事实:为了执行高级的绘图，我们必须用 matplotlib 编写大量的代码。这就是为什么 Seaborn 可能会帮助你。 Seaborn ，其实:
是一个基于 matplotlib 的 Python 数据可视化库。它提供了一个高层次的界面来绘制有吸引力的和信息丰富的统计图形。
但是 Seaborn 主要帮助我们高级剧情，让我们比 matplotlib 写的代码更少是什么意思呢？例如，假设你有一些关于人们给服务员小费的数据。我们希望绘制一个总账单和小费的图表，但我们甚至希望显示人们是否吸烟，以及人们是否在餐厅吃饭或吃饭。我们可以这样做:
# Import seaborn
import seaborn as sns
# Apply the default theme
sns.set_theme()
# Load the dataset
tips = sns.load_dataset("tips")
# Create the visualization
sns.relplot(
data=tips,
x="total_bill", y="tip", col="time",
hue="smoker", style="smoker", size="size",
)
我们得到了:
上面编码的数据的可视化。图片摘自 Seaborn 网站上的一个教程:https://seaborn.pydata.org/tutorial/introduction.html
因此，正如我们所看到的，由于 Seaborn 的存在，我们只用很少的几行代码就可以获得很好的结果。
因此，可能会出现一个问题:“我应该使用 Matplotlib 还是 Seaborn？”
我的建议是从 Matplotlib 开始，然后当你获得一些经验时再转向 Seaborn，因为现实是，大多数时候，我们同时使用 Matplotlib 和 Seaborn(因为记住:Seaborn 是基于 Matplotlib 的)。
5.sci kit-学习
区分数据分析师和数据科学家的主要因素是使用机器学习(ML)的能力。机器学习是人工智能的一个分支，专注于使用数据和算法进行分类或预测。
在 Python 中，可以使用名为 scikit-learn (有时称为 sk-learn)的库调用和训练 ML 模型，该库包含:
简单高效的预测数据分析工具。
作为一名数据科学家，所有与机器学习相关的工作都是在 sk-learn 中完成的，这就是为什么对于你来说至少掌握这个库的基础知识是非常重要的。
结论
我们介绍的库已经按照升序进行了编号，我给你的建议是按照这个顺序。因此，首先，使用 Jupiter 笔记本安装 Anaconda 来设置环境并获得 Python 经验。然后，开始用熊猫分析数据。然后先用 Matplotlib 可视化数据，再用 Seaborn。最后，使用 sk-learn 进行机器学习。
考虑成为会员:你可以支持我，不需要额外的费用。点击 这里 成为会员，每月不到 5 美元，你就可以解锁所有的故事，并支持我的写作。
你应该避免的 5 个 Python 错误
原文：https://towardsdatascience.com/5-python-mistakes-you-should-avoid-12104e350030
一些最常见的错误很难找到
Javier Allegue Barros 在 Unsplash 上拍摄的照片
Python 非常直观，是编程初学者的最爱。虽然语法简单明了，脚本也很简短，但还是需要注意一些细节。忽略它们可能会导致您的代码被破坏，让您头疼。
在本文中，我们将看看五个常见的 Python 编程新手错误以及如何防止它们。
1.一遍又一遍地修改列表
在迭代集合或列表时对其进行更改并不是一个好主意。在迭代过程中，许多程序员不小心从列表中删除了项目。这里有一个恰当的例子:
odd = lambda x : bool(x % 2)
numbers = [i for i in range(10)]
for i in range(len(numbers)):
if odd(numbers[i]):
del numbers[i]
具体来说，错误如下:
索引错误:列表索引超出范围
解决方案:使用列表理解可以帮助我们。
odd = lambda x : bool(x % 2)
nums = [i for i in range(10)]
nums[:] = [i for i in nums if not odd(I)]
print(nums)
2.模块名称冲突
可用 Python 包和库的数量和种类令人印象深刻。如果您为 Python 模块指定的名称与 Python 标准库中已有的名称相同，则可能会出现名称冲突。
你应该注意代码中的模块和标准库中的模块之间的名称冲突，比如 math.py 和 email.py 。
如果您导入一个库，并且该库试图从 Python 标准库中导入模块，您可能会遇到一些棘手的问题。因此，软件包可能会尝试从 Python 的标准库中导入您的复制模块，而不是正式模块。
出于这个原因，您不应该使用与 Python 标准库中相同的模块名称。
3.不关闭已经打开的文件
Python 建议在完成最后一个操作并且文件不再使用后关闭打开的文件。
请务必记住，您打开的文件可能会占用系统资源，如果您在使用完这些文件后不关闭它们，它们会被锁定。
在读取文件时，始终使用和将有助于防止这些问题。它会自动保存您的更改，并在您完成后关闭文件。
示例:
而不是:
file_1 = open(‘filename_demo.txt’, ‘w’)
file_1.write(‘new_data’)
file_1.close()
方法如下:
with open(‘filename_demo.txt’, ‘w’) as file_1:
file_1.write(‘new_data’)
4.不了解 Python 函数是如何工作的
Python 预装了几个有用的工具。他们中的一些人可能做类似的任务；然而，它们的做法可能不同。如果我们，作为程序员，没有完全掌握某个函数是如何操作的，那么如果我们使用它，我们就冒着得到意想不到的后果的风险。
在 Python 中，我们有两个不同的函数——sort()和 sorted——用于以某种 sorted() 排列集合中的项目。它们都服务于相同的目的——以一定的顺序排列一个集合。但是这两个功能是如何运作的是截然不同的。
示例:
list1 = [6, 5, 7, 2, 9, 3]
print(list1.sort())list2 = [6, 2, 8, 5, 3, 11]
print(sorted(list2))
输出:
None[2, 3, 5, 6, 8, 11]
到底发生了什么事？尽管 sort()和 sorted()都很有用，但排序后的列表是由后者打印的，而 sort()返回 None。
在这种情况下， sort() 在排序(就地排序)时修改原始序列，不返回任何内容。另外， sorted() 函数总是在不改变输入顺序的情况下生成一个排序列表。
5.误用 init 方法
init 函数是一个特殊的、保留的 Python 方法，用于创建对象。每当 Python 创建一个类的实例时都会调用它，让该实例为该类的属性和方法设置值。
当一个类的对象被创建时，这个方法的工作是填充类的数据成员的值。然而，程序员经常因为让函数返回值而偏离了这个 init 函数的预期用途。
结论
我们已经讨论了每个 python 开发人员最常犯的五个错误以及如何解决它们。
如果您采用这些改进技巧，您可以使您的 Python 代码更加优化和无 bug。这些技巧在某些时候对竞争性编程也很有帮助。
我希望你喜欢这篇文章。更多精彩文章敬请期待。
感谢阅读！
在你走之前……
如果你喜欢这篇文章，并且想继续关注更多关于 Python &数据科学的精彩文章——请考虑使用我的推荐链接https://pranjalai.medium.com/membership成为中级会员。
还有，可以随时订阅我的免费简讯: Pranjal 的简讯 。
面向工程专业学生的 5 个 Python 项目
原文：https://towardsdatascience.com/5-python-projects-for-engineering-students-8e951b7c131f
面向工程师的初级到中级 Python 项目理念
这篇文章为工程专业的学生提供了 5 个 Python 项目建议，这些学生希望在专注于工程的同时展示一些软件开发技能。
由Isis frana在 Unsplash 上拍摄
介绍
Python 是一种非常流行的编程语言，在科学和工程领域都有很多应用。
作为在爱尔兰的本科工程师，我们只在 MATLAB 上完成了一个编程模块。结果，没有太多的重点放在提高你的软件开发技能上，当我进入这个行业时，我发现这个技能是至关重要的。
作为一个做过开发人员和测试人员，现在正走上 AI 和数据科学职业生涯的航天工程师，我所学的关于软件开发的一切都是自学。在很大程度上，今天仍然如此。
我希望我在大学里做的一件事是花更多的时间根据我在课堂上学到的东西修补和编写小程序。但是相反，我所做的是学习满足于通过考试的唯一目的。
让我们讨论一些 Python 项目，如果你有空闲时间或者想巩固你所学的一些理论，你应该作为一名工程师去探索。
下面你会找到这些建议，其中有简短的理由为什么它有价值以及你可以遵循的最佳资源来开始工作。
照片由洛伦佐·埃雷拉在 Unsplash 上拍摄
1)用泰勒多项式进行函数逼近
利益
泰勒级数让你用数字估计一个函数，比如 sin(t) 或者 cos(t) 。对工程师来说，编写代码是一项很棒的小任务，因为它需要了解 符号微分 和 数值方法。
大多数学生在大学的第一年就获得了这些领域的足够知识。泰勒级数使用这些基础技能，它们构成了科学和工程中许多更高级主题的基础。
资源
- 有哪些工程、数学或计算机科学爱好者不知道格兰特·桑德森。要理解泰勒系列的本质，先看看3 blue 1 browns视频吧。
如果左下角的动画看起来很熟悉，我是用3Blue1Brown 的数学动画软件 Manim 制作的。 - 另一个有益的资源是任何大学微积分教科书。例如，我使用罗伯特·A·亚当斯的微积分——完整教程。我没有很多课本，因为现在你可以很容易地找到在线书籍的讲义或免费的 PDF 版本。
泰勒多项式函数逼近(图片由作者提供)
2)龙格-库塔数值积分
利益
龙格-库塔是一种数值积分技术。模拟物理现象，例如由牛顿冷却定律描述的物体温度变化，结合了 常微分方程 (ODEs)。求解常微分方程在工程和科学的许多分支中都是至关重要的。
完成这个脚本为剩下的三个提议奠定了基础，所以这可能是对一般工程熟练程度最重要的。
资源:
- 免费球的良好振动对于工程师来说是一个极好的 YouTube 频道。他在 Python 中实现了一个 RK4 积分器来解决 Python 中的质量-弹簧-阻尼器系统。
- 其次，听理查德·布伦顿的这个讲座是完成这个项目的理想选择。在课程结束时，他在 MATLAB 中为一个 RK4 从头开始提供了代码。因此，如果你正努力用 Python 来做这件事，那么根据你的目的修改 Matlab 代码。
龙格-库塔数值积分(图片由作者提供)
3)动态系统建模
利益
通过模拟平移机械系统的动态响应，强化振动的基本原理。如果你对飞行器动力学或宇宙飞船动力学感兴趣，这项事业就是的精髓。
比如你可以衍生出一辆 一级方程式 赛车的悬挂的基本模型，相当酷。通常，使用 MATLAB 和 Simulink 可以解决这些问题，但是没有什么可以阻止你在 Python 中做同样的事情。
资源
- 查尔斯·m·克洛斯的动态系统建模和分析。谁不喜欢在网上找一本免费的 PDF 版本的像样的教材呢？对于学习如何推导系统运动方程和寻找样本问题解决是非常有价值的。
- 模拟动态系统 —里克·希尔。里克·希尔博士从何说起。对于 MDS 和控制系统，Hill 博士在 YouTube 上的讲座非常出色。我相信这套课程在过去救了很多学生，包括我。先生，谢谢你的工作。
- 同样，对于对 MDS 感兴趣的工程师来说，自由球的良好振动是一个很好的渠道。如果你打算参与这个项目，请点击这个链接。有清晰、简洁的解释，问题根源于实际应用。
动态系统建模(图片由作者提供)
最后两个项目更侧重于航空航天工程。两者来自同一个资源，工科学生的轨道力学。
4)三维运动学可视化
利益
给定粒子位置作为时间的函数来模拟样本轨迹并计算各种其他运动特性为更多复杂动力学问题提供了良好的基础。
不需要数值积分；直接堵和轧轧作响。尽管轨迹可视化相对具有挑战性。然而，你不需要为这些作业制作动画。
动画是蛋糕上一颗漂亮的樱桃用来展示你为每个项目所做的工作，但是理解如何实现理论和生成数字结果是最有益的方面。
资源
- 这个项目源于工科学生在轨道力学中的一道例题。这本书包含了你只使用 Numpy 和 Matplotlib 用 Python 编写这个 chef-d'oeuvre(艺术杰作)所需的数学背景。
3D 运动学可视化(图片由作者提供)
5)两体问题
利益
清单上的最后一个项目不是最难的，但却是我最喜欢的。谁不爱轨道力学？**两体问题是一个经典力学问题，你的目标是想象两个物体仅仅由于它们的相互 引力吸引而产生的运动。
你可以学习推导运动方程，其中的过程很可能没有你想象的那么复杂。此外，解决它们确实需要数值积分。
有大量奇妙的资源可以让你开始这个项目。如果这不是矛盾修饰法的话，这是一件令人愉快的差事，而且如果你能制作出动画，连续几个小时无休止地盯着它们看是相当令人满意的(不，只有我？).
资源
- 在整篇文章中，我大量引用了工程学生的轨道力学。最终的两个项目源自第 1 章中单独介绍的理论。在后面的章节中，你可以用 Python 探索项目和模拟的无数可能性。
二体问题(图片由作者提供)
项目列表
如果这些项目想法让你感兴趣，看看这个列表，其中的项目按照从初级到更高级的顺序排列。我重点关注工科生。然而，这些项目是为任何对数学和科学感兴趣的人准备的。此外，我经常引用 Python ，因为那是我的编程语言偏好。如果你掌握了不同语言的技能，带着这些想法去实践吧。
安德鲁·约瑟夫·戴维斯
Python 中的工程项目
View list8 stories
https://medium.com/@andrewdaviesul/membership
如果您对 Python、工程和数据科学感兴趣，请随时关注和查看我的其他文章。
我希望你找到了有用的东西。感谢您的阅读。
5 个 Python 项目让你的生活自动化:从初级到高级
原文：https://towardsdatascience.com/5-python-projects-to-automate-your-life-from-beginner-to-advanced-90fe29a7d664
你应该在 2022 年解决的全新自动化项目
图片来自 Shutterstock，授权给 Frank Andrade
如果你正在学习 Python，你应该尝试自动化你的日常任务。
你不仅可以通过实现你已经知道的东西来学习更多的 Python，而且最终，你可以看到你所有的努力是如何得到回报的。
最近，由于缺少时间，我经常自动完成任务。由于这个原因，我有了 5 个新项目，我把它们分为初级、中级和高级。
您将找到解决每个项目的完整脚本和教程的链接。另外，我会给他们每个人留一个挑战来测试你的 Python 技能。
1.自动化 Microsoft Word(初学者项目)
有多少次你不得不使用 Word 来创建求职信、合同协议、简历或报告？
如果你数不过来，这个项目就是给你的。
在这个项目中，我们将使用 Python 和一个名为docxtpl的库自动生成 Word 文档。为此，我们需要一个想要自动化的文档的模板。在模板内部，我们必须在每个想要替换的单词上引入占位符。我们使用{{}}符号作为占位符。
为了让事情更简单，我已经创建了一个求职信的模板。下面是我们将使用的模板的外观。
作者图片
为了使这个项目对初学者友好，我们只需使用 Python 和docxtpl替换元素{ {我的名字}}、{ {我的电话}}、{ {我的电子邮件}}、{ {我的地址}}和{ {今天日期}}。
在下面的视频中，您可以下载这个模板，获取脚本，并按照步骤解决这个项目。
挑战:如果你想让这个项目更上一层楼，试着从 Excel 文件中提取数据，引入 Word 模板中。
以上教程的第二部分有一个类似下表的 Excel 文件。
+-------+-----+------------+----------------+
| Name | ... | address | job |
+-------+-----+------------+----------------+
| Frank | ... | 123 Avenue | Data Scientist |
| ... | ... | ... | ... |
| John | ... | XYZ Avenue | Web Developer |
+-------+-----+------------+----------------+
您应该为表格的每一行生成一个新文档。
2.自动发送电子邮件(初学者项目)
我过去在工作中做过的最无聊的事情之一就是发电子邮件。
重要的邮件应该仔细阅读和回复，但是作为日常事务一部分的邮件应该自动化！这就是这个初学者项目的全部内容。我们将使用 Python 自动发送电子邮件。
如何自动化这项任务？我们只需要使用内置模块smtplib和email。我们需要smtplib使用简单邮件传输协议(SMTP)发送电子邮件，需要email包来读取、写入和发送更复杂的 MIME 消息。
下面是使用 Gmail 自动发送电子邮件的分步指南。以下是它涵盖的内容:
- 如何启用两步验证，以便在 Python 中使用 Gmail
- 如何用 Python 发送普通邮件
- 如何处理您可能遇到的 SSL 错误
挑战:如果你想让这个项目更有挑战性，试着在你的邮件里附上图片。为此，您需要使用imghdr库。
3.自动填写 Web 表单(中间项目)
互联网上最乏味的任务之一是填写网页表格。
我是认真的！一遍又一遍地填写你的姓名、电话号码、地址和更多信息是令人厌烦的。当你不得不拿出虚假数据来填写调查时，事情会变得更糟。
在这个中间项目中，我们将使用 Python 向 web 表单填充假数据。如何自动化这项任务？我们将使用一个 web 自动化库，它允许我们执行 web 操作，如访问网站、键入文本和点击按钮。
下面是如何用 Python 自动完成这项乏味任务的一步一步的教程。以下是它涵盖的内容:
- 如何在单个表单中填写数据
- 如何用 faker 库生成假数据
- 如何填写多个 web 表单
挑战:我们在本教程中填写的表格有简单的元素。如果你想让这个项目更有挑战性，可以在表单中添加一些高级元素，比如下拉菜单和选择题。然后尝试自动化这个高级表单。
4.自动化 Tinder(高级项目)
在约会应用上向右滑动是如此耗时，以至于一旦你得到了匹配，你就会在网上约会最重要的部分——将匹配转换成实际日期——变得懒惰！
这个先进的项目包括创建一个机器人，为你刷卡的权利，所以你可以稍后在你的搭讪线工作，并增加你的转换率。
是什么让这个项目先进？很多事情。仅举几个例子:
- 登录:无论你使用什么登录选项(谷歌、脸书)，Tinder 都会向你的手机号码发送一个代码。你需要用这个代码登录 Tinder。为了轻松处理这个问题，我们需要保持一个 Google Chrome 会话活动，然后用 Selenium 控制它。
- 棘手的按钮:如果使用
.click方法点击 like 按钮，有时可能会出错。对于这个特殊的网站，我们需要使用一个替代方案。 - 弹出窗口:向右滑动时，你可能会遇到不同的弹出窗口。你必须摆脱他们。
下面有一个教程可以帮助你处理所有这些问题。
挑战:让你的机器人给你的对手发送随机的搭讪信息。
但仅仅是为了这个项目！如果你想得到更多的回复，不要自动发送信息。我试过了，它不如你自己发送高质量的消息有效。
5.在工作中自动完成自己的任务(超级高级项目)
毫无疑问，自动化你工作中的乏味任务是你能做的最具挑战性的事情。
为什么？很可能没有一步一步的教程来指导你，你必须考虑你需要使用什么库，以及自动化它的最佳方法。
要找出自动化的内容，问自己以下问题:
- 我不断重复做的任务是什么？
- 用 Python 可以自动化哪些具体部分？
- 我应该使用什么 Python 库来自动化这个项目？
如果您知道问题#3 的答案，即使您没有找到关于如何自动化该特定任务的教程，您也可以查看文档或阅读指南来开始使用该库。
请在评论中告诉我你现在正在自动化什么任务！
使用 Python 自动化您的生活！ 加入我的 20k+人电子邮件列表，获取我的免费自动化备忘单。
如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你用我的链接注册，我会赚一小笔佣金，不需要你额外付费。
https://frank-andrade.medium.com/membership
不容错过的 5 个 Python 技巧
原文：https://towardsdatascience.com/5-python-tips-that-you-dont-want-to-miss-7696a9ec9df1
充分利用 Python
照片由 Unsplash 上的尼克·费因斯拍摄
如果您正在使用 Python 进行数据科学，您可以通过使用第三方库(如 Pandas、Scikit-Learn 等)来完成大多数任务。基本的 Python 特性和功能对于各种任务也很方便。此外，第三方库在许多情况下利用了基本的 Python 特性。
在这篇文章中，我将分享我认为对任何使用 Python 的人来说都应该知道的 5 个技巧。
注:本帖原载于datasciencehowto.com。
1.列表中缺少逗号
第一个技巧是关于列表的。list 是一种内置的 Python 数据类型，可用于在单个变量中存储多个项目。列表可以通过在方括号中写由逗号分隔的元素来构造。
mylist = ["John", "Jane", "Matt", "Ashley"]print(mylist)# output
['John', 'Jane', 'Matt', 'Ashley']
当创建包含多个字符串的列表时，我们需要小心。如果我们忘记在连续的条目之间加一个逗号，Python 仍然会创建列表而不会产生错误。但是，中间没有逗号的字符串会被连接起来。
mylist = ["John", "Jane", "Matt" "Ashley"]print(mylist)
['John', 'Jane', 'MattAshley']
因为没有关于丢失逗号的错误和警告，所以您可能会在脚本或分析中得到意想不到的结果。
2.具有多个条件的 If 语句
第二个技巧是关于 if 语句。考虑这样一种情况，您需要创建一个包含多个条件的 if 语句，并且您希望将条件写在单独的行中，以避免创建太长的行。
这里有一个例子:
variable_with_a_long_name = 50
another_variable_with_a_long_name = 10
another_variable_with_a_even_longer_name = 5if variable_with_a_long_name > 30 and
another_variable_with_a_long_name > 8 and
another_variable_with_a_even_longer_name > 4:
print("Done!")# output
SyntaxError: invalid syntax
我们得到一个错误，因为 Python 认为表达式在行尾结束。我们可以通过将条件放在括号中来解决这个问题。
variable_with_a_long_name = 50
another_variable_with_a_long_name = 10
another_variable_with_a_even_longer_name = 5if (variable_with_a_long_name > 30 and
another_variable_with_a_long_name > 8 and
another_variable_with_a_even_longer_name > 4):
print("Done!")# output
Done!
我们只要把条件写在括号里就可以了！
3.将列表乘以整数
Python 允许列表乘以整数。将一个列表乘以 3 意味着将同一个列表连接 3 次。这里有一个简单的例子来说明它是如何工作的。
mylist = [1, 2, 3] * 3print(mylist)# output
[1, 2, 3, 1, 2, 3, 1, 2, 3]
但是在包含列表的列表上做这个操作的时候需要小心。
mylist = [["a","b","c"]] * 3print(mylist)# output
[['a', 'b', 'c'], ['a', 'b', 'c'], ['a', 'b', 'c']]
变量mylist包含另一个列表的一个项目。因此，当它乘以 3 时，输出是包含 3 个相同列表的列表。这三个项目并不是不同的对象。它们可以被认为是指向内存中同一对象的不同指针。所以当我们修改这三个嵌套列表中的一个时，其他的也将被更新。
mylist = [["a","b","c"]] * 3# update the first item in the first list
mylist[0][0] = "new" print(mylist)# output
[['new', 'b', 'c'], ['new', 'b', 'c'], ['new', 'b', 'c']]
下面两个图显示了这里发生的情况:
(图片由作者在 Python 导师上创作)
(图片由作者在 Python Tutor 上创建)
正如我们在第一幅图中看到的，列表中的所有 3 项都指向内存中的同一个对象。因此，修改此对象会更新结果列表中的所有 3 个项目。
4.反复查阅字典
Dictionary 是另一种内置的 Python 数据结构。它由键值对组成。字典中的键必须是唯一的和可散列的。例如，我们不能在字典中使用列表作为键。
字典是可迭代的，所以我们可以迭代它们。默认情况下，迭代是在键上完成的。
mydict = {"John": 25, "Jane": 28, "Ashley": 22}for key in mydict:
print(key)# output
John
Jane
Ashley
如果我们想要迭代这些值，我们需要使用values方法。
mydict = {"John": 25, "Jane": 28, "Ashley": 22}for value in mydict.values():
print(value)# output
25
28
22
我们可以使用items方法迭代对。因为每个键-值对都是一个元组，所以我们可以很容易地将键和值分配给不同的变量。
mydict = {"John": 25, "Jane": 28, "Ashley": 22}for key, value in mydict.items():
print(f"{key} is {value} years old.")# output
John is 25 years old.
Jane is 28 years old.
Ashley is 22 years old.
5.字母数字字符串
假设我们需要检查一串字符串或用户输入，以确保它们只包含字母数字字符(即字母或数字)。一个快速简单的选择是isalnum方法。
password = "Aaa123"password.isalnum()# output
True------------------password = "Aaa123?"password.isalnum()# output
False
如果字符串包含任何非字母数字字符，该方法将返回 false。
我们在本文中介绍的内容不是您经常会遇到的。然而，它们对于一些任务来说很方便，并且在需要的时候有所作为。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果您使用以下链接，我将收取您的一部分会员费，无需您支付额外费用。
https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。
巩固 Python 列表知识的 5 个问题
原文：https://towardsdatascience.com/5-questions-to-consolidate-your-knowledge-of-python-lists-4a63ba1ab05e
选自 Stackoverflow
Zan 在 Unsplash 上的照片
Python 有 4 种内置的数据结构:列表、元组、集合和字典。这些数据结构极其重要，即使您使用 Python 进行数据科学研究。
所有这些本质上都是数据的集合。然而，它们之间的差异使得每个数据结构都是独特的。例如，列表是可变的，而元组是不可变的。我们不能向元组追加新项。
在本文中，我们将讨论 5 个问题，展示 Python 列表的一个特殊特性。我已经挑选了在 Stackoverflow 上有大量投票的问题，所以我们可以假设它们是 Python 社区经常问的问题。
Python 列表是一个有序的元素序列，写在方括号中，用逗号分隔。以下是 4 个元素的列表。
mylist = [4, True, "a", 15]
正如我们在这个例子中看到的，列表可以存储不同数据类型的对象。
1.如何检查一个列表是否为空？
有多种方法可以检查列表是否为空。例如，我们可以用 len 函数找到一个列表的长度，如果它是 0，那么这个列表就是空的。
mylist = []if len(mylist) == 0:
print("The list is empty!")**# output**
The list is empty!
更 pythonic 化的方法是基于空序列是假的这一事实。
mylist = []if not mylist:
print("The list is empty!")**# output**
The list is empty!
2.append 和 extend 方法之间有什么区别？
append 方法用于向列表添加新项目(例如，追加),而 extend 方法向列表添加另一个集合中的项目。换句话说，extend 方法通过使用给定集合中的项目来扩展列表。
让我们看几个例子来演示它们是如何使用的。
a = [1, 2, 3]a.append(4)print(a)**# output**
[1, 2, 3, 4]
如果将集合传递给 append 方法，它将作为单个元素添加到列表中。
a = [1, 2, 3]a.append([4, 5])print(a)**# output**
[1, 2, 3, [4, 5]]
列表“a”有 4 项。如果我们使用 extend 方法做同样的例子，结果列表将有 5 个条目，因为 4 和 5 将作为单独的条目添加。
a = [1, 2, 3]a.extend([4, 5])print(a)**# output**
[1, 2, 3, 4, 5]
3.如何获取列表中的最后一项？
有一个非常简单的方法来获取列表中的最后一项。列表第一项的索引是 0。最后一项的索引当然取决于列表的长度。但是，我们可以选择从最后一项开始索引。在这种情况下，索引从-1 开始。
a = [1, 2, 3, 4]a[-1]**# output**
4
这个方法有一个例外，就是空列表的情况。如果列表为空，上述方法会产生一个索引错误。我们可以用如下简单的方法解决这个问题:
a = []a[-1:]**# output**
[]
输出仍然是一个空列表，但是代码没有抛出错误。
4.你如何展平一个列表？
假设我们有一个如下的列表列表:
a = [[1, 2], [3, 4], ["a", "b"]]
我们希望将它展平，这意味着将它转换为如下所示的项目列表:
a = [1, 2, 3, 4, "a", "b"]
同样，执行这项任务有多种方式。我们将使用列表理解。
a = [[1, 2], [3, 4], ["a", "b"]]b = [item for sublist in a for item in sublist]print(b)**# output**
[1, 2, 3, 4, 'a', 'b']
如果列表理解的语法看起来令人困惑，试着把它想象成嵌套的 for 循环。例如，上面的列表理解可以通过下面的嵌套 For 循环来实现:
b = []for sublist in a:
for item in sublist:
b.append(item)
print(b)**# output**
[1, 2, 3, 4, 'a', 'b']
5.如何删除列表中的重复项？
同样，完成这项任务的方法不止一种。最简单的方法可能是使用 set 构造函数。Set 是 Python 中的另一种内置数据结构。集合的一个识别特征是它们不包含重复项。
a = [1, 1, 2, 3, 3, 4, 5, 6, 7, 7, 7]b = list(set(a))print(b)**# output**
[1, 2, 3, 4, 5, 6, 7]
我们首先将列表转换为集合，然后再转换回列表。
Python 中经常使用列表。它们是通用的和高度实用的，这使它们在许多情况下成为首选的数据结构。
你可以成为 媒介会员 解锁我的全部写作权限，外加其余媒介。如果你已经是了，别忘了订阅如果你想在我发表新文章时收到电子邮件。
*https://sonery.medium.com/membership
感谢您的阅读。如果您有任何反馈，请告诉我。*
成为 Python 和 R 领域高效数据科学家的 5 个快速简单的技巧
原文：https://towardsdatascience.com/5-quick-and-easy-tips-to-become-an-efficient-data-scientist-in-both-python-and-r-5cf51f6396a3
在使用 Python 和 R 之间转换有困难？尝试以下建议，让过渡更顺利
伊万·舒亚科夫在 Unsplash 上的照片
我最近的一个发现是，很多数据科学家同时使用 Python 和 r。
典型的情况是，他们使用 R 进行研究生学习和研究，而使用 Python 进行工作。由于许多人一边上学一边工作，这些数据科学家不得不在 Python 和 R 之间来回切换，有时一天内要切换几次，这取决于他们在学校或工作中要做什么。
因为许多(阅读:大多数)数据科学课程或学习途径关注一种语言而不是另一种语言，所以学习中存在一个缺口，忽略了帮助数据科学家在两种语言之间切换。也许令人惊讶的是，在同一天在两种编程语言之间切换可能是具有挑战性的，尤其是当您试图完成类似的工作时。例如，web 开发人员很容易在同一天在 HTML、CSS 和 JavaScript 之间切换，因为每种语言都处理网站的一个非常具体的部分。然而，数据科学家可以在研究生课程中用 R 语言完成一种类型的数据分析，而在当天晚些时候，他们需要使用 Python 来完成不同的工作分析。
每天有大量数据科学家在两种语言之间切换，这意味着需要通过提供如何更好地定期使用两种语言的技巧来填补数据科学教育中的空白。在这里，我们将看看几个简单的技巧，它们可以在不到 10 分钟的时间内作为您日常工作的一部分来实现，这将帮助您成为在 Python 和 r 之间切换的更高效的数据科学家。
1.在不同的日子里完成 Python 和 R 任务
为了开始高效地使用 Python 和 R，你可以做的最好的事情之一就是在不同的日子里完成你的 Python 和 R 工作。通过在某一天批处理所有 Python 任务，在另一天批处理 R 任务，可以保证在同一天不需要切换语言。
这需要不到 10 分钟的时间来实现，因为你所需要做的就是围绕你在某一天将要使用的语言来计划你的一周。例如，周一、周三和周五可能是你完成 Python 中的工作的日子，而周二和周四是留给需要休息的任务的。
基于编程语言的日批处理允许你保持一种流畅的状态，在这种状态下你不必担心使用不同的约定、语法或文档。相反，考虑到语言的约定，您可以专注于编写干净的代码，而不会陷入带重音的编码陷阱(参见技巧 5)。
记得大学第一年学软件开发的时候，我的大部分编码课程都是用 C#。这使得从一个班级转到另一个班级变得容易，而不需要习惯使用一门新的语言。在我的第二年，当我们开始学习各种语言的课程时，事情变得更加困难，包括 C#、Java、PHP 等等。这使得进入最佳状态变得更加困难，因为每两个小时就要更换编程语言。
这个挑战相当于在一天内说几种不同的语言。在你变得流利之前，在不同的语言之间进行转换是很费力的。你的嘴和舌头需要做出的形状不一样，声音不一样，语法不一样，语言的约定俗成和风俗不一样。然而，如果有一天你会说英语，下一次会说法语，下一次会说意大利语，等等，你会发现你更有能力有效地说，因为你在一种语言中工作了很长一段时间。
然而，不可能总是把一整天都花在 Python 或 r 上。有时，工作、学校和生活同时发生，这意味着你需要兼顾几个不同的截止日期、项目和需求。另一种类似的批处理任务的方法是用半天时间处理 Python 任务，另一半时间处理 R 任务。然后，通过在中间有一个实质性的休息，你可以做任何与任何一批任务相关的事情，你可以进入一天的后半部分，准备用一种不同的语言工作。一天当中的休息时间对于重置你的大脑，让它有机会删除你对另一种语言的使用是非常必要的。通过将你的任务分成两个独立的半天，你可以确保你不会在 Python 中工作 20 分钟，然后在 R 中工作一个小时，这样的循环会让你的大脑疲惫不堪，不能以最大效率工作。
2.找出 Python 和 R 之间的相似之处
当我在大学的时候，我用 C#和 Java 工作是最轻松的，因为我能够找到这两种语言之间的相似之处，并利用它们在这两种语言中高效地工作。同样，我在学俄语的时候，发现它和法语、英语有几个相似之处，这两个我都已经知道了。这些相似之处让我即使一开始没有马上理解单词，也能理解很多单词的内涵。
能够在 Python 和 R 之间切换的诀窍是找到这两种语言之间的相似之处，不管它们有多有限。例如，Python 和 R 都可以用来编写面向对象的代码，都可以用来进行统计分析。当然，使用两种不同索引的语言可能会很痛苦，但至少它们的共同点多于不同点。然而，您至少可以为这两种语言使用相同的 IDE，因为 RStudio 和 Atom 能够同时支持 R 和 Python。
重要的是要记住，你发现的两种语言之间的相似之处可能与其他人发现的不同。类似于如何以不同的方式创建类比来描述两个事物之间的关系，您在 R 和 Python 之间找到的相似之处也可以用来简化两种语言之间的转换。
这篇技巧不到 10 分钟就可以完成，因为您可以开始在便笺上创建 Python 和 R 相似性的列表。这张便条可以放在你的桌子上，提醒你每种语言的要点，可以用来轻松地从一种语言过渡到另一种语言。
3.学习如何问/Google/StackOverflow 正确的问题
我在大学学习软件开发时学到的最有价值的技能是如何提出好的问题。我敢肯定，你会发现，问一些不明确的问题会让你找到大约 200 个不同的 StackOverflow，这些问题可能与你正在寻找的答案有关，也可能无关，但还不够精确，不足以让你快速找到问题的解决方案。
使用 Python 和 R 这两种语言需要你能针对你当前使用的语言提出正确的问题。例如，像问关于 Python 的问题一样，问一个关于 R 的问题可能会返回结果，如前所述，这并不是您想要的结果。
虽然将错误消息复制到搜索栏是找到类似问题的 StackOverflow 响应的一个很好的方法。然而，如果您所做的只是复制一条错误消息，您真的了解哪里出错了吗？熟悉 Python 和 R 的特性的一个更好的方法是努力理解代码中哪里出错了。然后，您可以提出更好的问题，这些问题比一般的错误消息更直接地适用于您所遇到的问题。
练习如何提问可以在每天不到 10 分钟的时间内完成，最好在工作的时候完成。你会很快注意到哪些问题会产生正确的答案，而哪些问题会引导你找到可以解决无数问题的通用答案。
4.将技术文档放在手边，并学习如何有效地使用它
虽然我前面提到 Python 和 R 有更多的共同点，但是它们显著不同的一个关键地方是它们的文档。
众所周知，Python 拥有一些最好的代码文档，而 R 却严重缺乏。当在两种语言之间转换时，将任何可以得到的文档放在身边可以帮助您高效地编写代码。例如，在大学期间，当我用 Typescript(确切地说是 Angular)进行一个项目时，我会在浏览器中打开它的文档，以备我在知识上遇到缺口时使用。虽然 Typescript 语言类似于 JavaScript，但我发现这两种语言之间有足够的学习曲线，随时准备好文档可以使过渡更加顺利。
然而，我总是发现创建自己的文档或备忘单比查找技术文档要有价值一百万倍，不管写得多好。你知道你如何在创建小抄或学习指南时下意识地学习，即使感觉不像？同样的事情也适用于为 Python 和 r 创建参考指南、文档、工作表或学习指南。我在 LinkedIn 上看到过一些漂亮的参考表，它们将大量知识浓缩到一张 8.5 x 11 的纸上，可以打印出来并随时放在身边。这些参考表可以作为灵感和起点，开始创建自己的备忘单和文档，帮助您在 Python 和 r 之间进行转换。我喜欢在不同编程语言的参考表中包含代码片段、公式、函数信息和包描述。
创建您自己的参考表或获取他人的参考表只需要不到 10 分钟的时间，并且可以省去您必须记住 Python 和 r 的复杂性的需要。
5.不要用重音编码
在学习一门新的自然语言的时候带着口音说话是很可爱的。带重音符号的编码不是。
在之前我已经说过了，现在我要再说一遍:用一种语言编码，就好像它是另一种语言一样，这对你没有任何好处。
当你用一种没有按预期方式使用的语言编写代码时，使用它的任何人都无法阅读它，它不能按预期方式运行，或者更糟的是，它甚至不知道你在要求它做什么。
深入了解 Python 和 R 的独特设计、它们的约定以及它们的优缺点，将有助于您最大限度地利用每种语言编写代码。这就是拥有快速参考表(见上面的提示 4)的方便之处，因为它们为您提供了正确的语法、变量约定和您正在使用的语言的标准格式。
Python 和 R 在语法、格式和约定方面有很大的不同，这就是为什么拥有一个参考指南可以很方便地防止您陷入带口音的编码。
我最喜欢的确保我没有带着口音编码的方法是每完成半小时或一小时的工作设置一个提醒，提醒我检查我的代码是否流畅。这个代码检查不到 10 分钟，它只是提醒您查看语法、约定和格式，以确保您在使用 Python 时编写 Python，或者在使用 R 时编写 R。
订阅将我的故事直接发送到您的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将收取少量佣金，无需额外费用):媒体会员
通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠
用于分析/调试代码的 5 个真正方便的 python 装饰器
原文：https://towardsdatascience.com/5-real-handy-python-decorators-for-analyzing-debugging-your-code-c22067318d47
将这些方便的、通用的装饰器直接应用到您的代码中
装饰精美(图片由萨巴·萨阿德在 Unsplash 上拍摄)
decorators 的美妙之处在于它们非常容易应用，但是为你的代码提供了很多额外的功能。在本文中，我们将介绍 5 个方便的装饰器，您可以轻松地将它们应用到调试代码时遇到的实际问题中。我们来看看能帮到你的装饰师:
- 为你的功能计时
- 性能检查
- 中继器
- 执行前询问您是否确定
- 用 try-catch 包装您的函数
本文的目标是为您提供一些现成的装饰器，并启发您开发一些方便的、通用的装饰器。
在我们开始之前: 你知道你还可以让装修工记录状态吗？示例:计算一个函数被调用的次数，这样你就可以对它进行速率限制。请务必阅读本文https://mikehuls.medium.com/six-levels-of-python-decorators-1f12c9067b23以了解装饰器是如何工作的，如何应用它们以及何时使用装饰器。在这篇文章中，我们用 6 个越来越复杂的步骤来探索装饰者。
1.计时器
让我们从简单开始；我们将从一个装饰器开始，它打印出我们的函数运行所花费的时间。这是代码:
注意，我们的装饰器本身是用@ wrapps(func)包装的。这是为了确保我们传递了包装的函数。如果我们不这样做的话,wrapper.__name__只会打印出‘包装’,而不是我们实际正在装饰的功能。
我们将在一个计算素数的函数上使用这个装饰器:
现在我们检查调用is_prime_number(number=155153)时的输出:
[isprime] took 5.601100000000005 ms
2.性能检查
计时我们的功能很好，但我们需要更多的信息。除了持续时间之外，下一个装饰器还提供了关于函数的信息，包括名称和文档字符串，以及性能信息，如内存使用情况:
它与前面的函数非常相似，只是我们打印出了更多的信息:
调用is_prime_number(number=9843861881)会打印出以下内容:
Function: is_prime_number ( Checks whether a number is a prime number )
Memory usage: 0.000432 MB
Peak memory usage: 0.000622 MB
Duration: 0.000015 sec
----------------------------------------
3.中继器
这个装饰器在被调用时重复某个函数。这对于测试性能(参见其他 decorators)或者压力测试来说是很方便的
它是这样使用的:
调用 sayhello()将产生以下输出:
hello
hello
例如，在测量其性能时，可以很好地使用这个装饰器执行几次。
4.提示“您确定吗？”执行前
这个装饰器可以添加到需要很长时间才能完成或者有重大影响的函数中(比如删除数据)。一旦你调用了这个函数，装饰者会确保你在调用它之前确认你想要执行这个函数。否则它将返回并且而不是调用函数。
让我们再次修饰一下简单的 say_hi 函数:
如您所见，我们能够在装饰器上设置提示消息。当我们调用say_hi()时，您将会看到:
Sure? Press y to continue, press n to stop
如果你输入‘y’那么我们将执行say_hi()，任何其他输入(包括没有输入)将阻止say_hi()执行。
5.试着找一个室内装潢师
这使用装饰器将您的函数包装在一个 try-except 块中。优势在于，只需一行 Python 代码，整个函数就不会出现异常。代码如下所示:
我们将在下面的函数中使用这个装饰器:
现在，当我们调用trycatchExample(9, 3)时，函数返回3.0``。如果我们调用trycatchExample(9, 0)``(除以 0 ),它会正确返回以下内容:
Exception in trycatchExample: division by zero
我建议只将这个装饰器用于调试目的，并更准确地捕捉函数中的错误。
结论
通过这篇文章，我希望能够提供更多关于装饰者带来的好处的信息。如果我启发了你，分享一些你自己的便利的装饰！此外，你知道你甚至可以保持你的装饰状态吗？查看 这篇文章 深入探究装修工是如何工作的。
如果你有建议/澄清，请评论，以便我可以改进这篇文章。与此同时，请查看我的关于各种编程相关主题的其他文章:
- Python 为什么慢，如何加速
- 用 Python OpenCV 破坏猎鸭
- 使用 Python OpenCV 创建运动检测器
- Python 中的高级多任务处理:应用线程池和进程池并进行基准测试
- 编写自己的 C 扩展来加速 Python x100
- cyt hon 入门:如何用 Python 执行>每秒 17 亿次计算
- 用 FastAPI 用 5 行代码创建一个快速自动归档、可维护且易于使用的 Python API
- 创建并发布你自己的 Python 包
- 创建您的定制私有 Python 包，您可以从您的 Git 库 PIP 安装该包
- 面向绝对初学者的虚拟环境——什么是虚拟环境以及如何创建虚拟环境(+示例)
- 通过简单的升级大大提高您的数据库插入速度
编码快乐！
—迈克
页（page 的缩写）学生:比如我正在做的事情？跟着我！
**https://mikehuls.medium.com/membership **
不在产品中使用深度学习的 5 个理由
原文：https://towardsdatascience.com/5-reasons-for-not-using-deep-learning-in-your-product-4cae90de7d45
深度学习是一种受人脑工作方式启发的机器学习方法，在我们没有深度领域专业知识但有大量数据的情况下特别受欢迎。但是，它是你正在构建的人工智能产品的最佳解决方案吗？
附身摄影在 Unsplash 上拍照
近年来，关于深度学习的研究论文数量激增。研究人员在几乎所有与机器学习相关的会议和期刊上展示他们如何改进深度学习模型，数据科学家展示他们的深度学习技能，以构建(或试图构建)基于深度学习的应用。但是在你的产品中使用深度学习模型总是明智的吗？
近年来，我一直在观察数据科学社区中的宣传，并看到了大量不正确的深度学习使用的例子，只是因为宣传。不要误解我，我认为自己是深度学习专家，我毫不怀疑，凭借大量的数据、高效的数据存储、GPU、TPU、各种云计算设施和令人兴奋的深度学习研究，数据科学家已经创造了许多奇迹。但这并不总是最好的解决方案。
在这篇文章中，我想提一下而不是在你的产品中使用深度学习的原因。所以，下次你想解决一个问题的时候，用这个作为备忘单来决定深度学习是否是你手头问题的正确解决方案。
1.您是否有所需基础设施成本的预算？
训练深度学习模型涉及处理大量数据。与小数据相比，大数据需要不同的工具和基础架构。你可能能够在你的 PC 机器上或带有 CPU 的单个服务器上构建你的模型，但当涉及到生产就绪的模型时，与传统的机器学习模型不同，你将需要 GPU、TPU 和数百万或数十亿条数据记录来并行处理。如果您没有合适的基础设施，您的模型训练和实验将会非常缓慢，并且/或者无法以最佳能力进行构建。
2.你有足够的数据吗？
训练深度学习需要海量的数据。如果你没有大量最好的标记数据，传统的机器学习算法将以更低的成本和更低的复杂性执行相同的任务(如果不是更好的话)。在下图中，您可以看到数据量如何影响整体模型性能。
金、、郭、清华、李、闵、杨、、徐、鞠可欣、、张、景宣、景苏、、徐、强、刘、于。(2020).深度学习在生态资源研究中的应用:理论、方法和挑战。科学中国地球科学。10.1007/s 11430–019–9584–9。
顺便说一下，迁移学习对减少对大量标记数据的需求有很大帮助。比如你看英勇！人们使用 BERT(或类似的)的故事，微调它，得到了很好的结果。然而，人们通常会分享他们的成功，而在失败的时候会保持沉默。我的经验表明，迁移学习伴随着一个巨大的责任，那就是确保你不会在你的模型中引入无意的偏见或盲点。我会写一篇关于如果你不知道自己在做什么，迁移学习是多么危险的文章！
3.你能接触到领域知识吗？
当你无法接触到领域知识或者标记数据的成本很高时，深度学习是最好的方法。深度学习受到传统 ML 算法的青睐，因为你可以更少地担心特征工程，并且在处理复杂问题时是最好的。
然而，有研究表明，使用传统 ML 算法的特征工程可以以更低的成本执行类似或更好的深度学习方法。所以，如果问题不是很复杂，可以用特征工程解决，不要觉得丢人，选择特征工程。有很多例子表明，传统机器学习模型的特征工程确实比最好的深度学习模型表现得更好。
我在这里想说的是，当问题可以通过设置一些 if-else 规则来解决的时候，你不应该使用机器学习。这同样适用于深度学习:降低特征工程+传统机器学习解决问题时的成本。
4.你需要透明吗
深度学习模型以黑盒著称。已经有了诸如石灰、 SHAP 、深度提升等研究，让它们更有解释力。但在我看来，目前还不足以在面向客户的产品中使用它们。
如果你想使用深度学习方法，请三思而行，特别是当产品需要透明度时，例如涉及标记人员(如欺诈检测)或匹配(如求职者匹配)的方法。在这种情况下，你需要设计一个机器学习算法，它可以显示为什么模型会做出这样的决定，深度学习在这里是臭名昭著的。
5.你需要模型的快速更新吗
训练深度学习模型需要时间。越深越复杂，训练阶段就会越慢。在大多数应用程序中，您可以离线训练模型，并在它变旧并需要新数据和新训练之前使用它很长时间。然而，如果您的模型需要更定期地训练，因为您的数据变化很快，例如推荐引擎很快就会过时(数据漂移)和不相关，深度学习不一定是您的最佳解决方案。
额外提示。你只想做酷的事情吗？
虽然深度学习解决了许多复杂的问题，但它也带来了大肆宣传。如果你想做很酷的事情，尽一切办法，尝试深度学习解决方案。但是不要因为它很酷，每个人都在谈论它，就把深度学习作为你产品的解决方案。
希望这篇文章能帮助你下次设计机器学习产品，如果你有其他理由不在产品中使用深度学习，请随时分享你的想法。
在你走之前
我写的是数据科学、人工智能和人工智能产品的大图景。如果你喜欢这篇文章，关注我当我发表新文章时，你会得到通知。
每个数据科学家都应该考虑自由职业的 5 个理由
原文：https://towardsdatascience.com/5-reasons-why-every-data-scientist-should-consider-freelancing-42ad24fad3e
可能会不舒服，但对你有好处
安德鲁·尼尔在 Unsplash 上拍照
不管你是在职还是失业，是经验丰富的专业人士还是新手，喜欢与否，自由职业对你都有好处。
在开始之前，先介绍一下我的背景。我在研究生院期间开始从事数据科学工作。对于那些不熟悉的人来说，研究生院的大部分内容包括研究、截止日期和写论文。
在我第三年的中途，我开始了我的自由职业之旅，接受短期项目，并将它们融入我的研究和写作计划中。如果没有这些额外的工作量，我会学到很多东西，自由职业将我作为数据科学家的发展带到了另一个层次。在这里，我将讨论我从自己的经历中发现的 5 个好处。
1)解决新问题
数据科学的最大优势之一是它是上下文不可知的。这意味着您可以使用相同的技术来解决广泛的问题(例如，逻辑回归——评估客户流失、评估信用风险、预测股票价格等)。这为数据科学家提供了一个独特的机会，将他们的专业知识应用于广泛的领域和行业。
尽管有这个机会，但数据科学家很容易在狭窄的环境中工作，如果你的目标是学习和提高，这可能会有问题。
这引出了我在自由职业中发现的第一个好处:接触新的领域和问题。感觉和旅游差不多。正如出国访问有助于你更好地了解生活和文化一样，探索新问题有助于你更深入地了解数据科学。
2)通过营销、面试、谈判等方式改善沟通。
数据科学家通常不以他们在销售、营销和谈判方面的至高权力而闻名。这正是自由职业对我有好处的原因。它为我提供了几次发展这些技能的机会。
当你是自由职业者时，大多数潜在客户都是陌生人。因此，你需要与那些对你所知道的或者你如何解决他们的问题一无所知的人联系和交流。换句话说，你需要推销你自己和你的想法，这是一个很好的技能，无论你在人生的哪个阶段结束。
3)通过迭代微调音高
学习有两个关键要素:重复和反馈。重复次数越多，反馈越快越好。因此，如果你想改善你的简历，起草有说服力的提案，或者有效地展示自己，你需要代表和反馈。
这是自由职业者主导全职角色的一个方面。与全职工作相比，合同机会要多得多。此外，合同角色在更短的时间范围内运作。
明确地说，
- 更多的合同机会意味着更多的销售代表。
- 更短的时间意味着更快的反馈。
不用说，承包商会比全职有更好的表现。
4)灵活性&自主性
自由职业者主导(大多数)全职工作的另一个方面是灵活性。合同通常不会限制何时何地需要完成工作，只是需要在截止日期前完成。如果这意味着你每天在洪都拉斯的阁楼上工作 4 个小时，或者周一到周三在你妈妈的地下室工作 12 个小时，你可以自由地这样做。
此外，你选择你的工作。如果一个项目看起来很无聊，没有必要去追求它。相反，如果一个项目看起来令人兴奋，你就对获得合同的机会有很大的影响。
这种巨大的自主性不仅仅听起来像是美好的生活，它对动力有很大的影响。当我们可以选择做什么、什么时候做、和谁一起做时，我们做的工作会更有吸引力。
5)建立关系&新关系
我发现自由职业的最后一个好处是发展新的关系。有句话叫“你的人脉就是你的身家”。我对此的解读是，你认识的人有价值。
当然，你可以用金钱来衡量，但价值通常是通过有意义的联系、引人入胜的谈话以及“有个男人(或女人)为此而感到舒适”来体现的。
通过我的合同工作，我有机会认识一些迷人的人，他们在我甚至不知道存在的世界里工作。我曾与急诊室医生、特种部队操作人员、临床医生、商人和研究人员共事，他们有着如此多不同的背景和经历。这些联系真正丰富了我对世界的看法。
https://medium.com/the-data-entrepreneurs/how-to-start-freelancing-in-data-science-150551f25fda
奖金:钱🤑
如果这 5 个理由还不够，还有钱。数据科学承包工作可能非常有利可图。根据 ZipRecruiter 的数据，典型的时薪是每小时 56 美元左右，而 T2 的采访查询显示时薪甚至更高，超过 200 美元。无论是主要收入来源还是兼职，自由职业都是赚钱的好方法。
额外奖励:
资源
更多关于数据科学的信息 : 什么是数据科学？ | 什么是数据创业者？
连接 : 我的网站 | 预定电话 | 消息我
社交:YouTube|LinkedIn|Twitter
支持 : 给我买杯咖啡 ☕️ | 成为会员 ⭐️
https://shawhin.medium.com/membership
你的 ML 模型没有投入生产的 5 个原因
原文：https://towardsdatascience.com/5-reasons-your-ml-model-isnt-making-it-to-production-f6965f4e01ec
不理解精确度指标？尝试创建一个电梯图
在 Unsplash 上由 Max Duzij 拍照
好吧，那么你已经花了几个月的时间来建立你的机器学习模型。您已经分离了训练/测试集，确保没有任何数据泄漏，并调整了超参数，最终实现了 99%准确率的模型！现在你所要做的就是在生产中运行它，它将改善客户体验。
你拿着最终产品给产品经理看，强调模型的表现如何，剩下要做的就是把它放到合适的位置。几个月过去了，一年过去了，你的模型仍然没有在路线图中被优先考虑。怎么回事？
对于数据科学家的工作来说，这种情况并不少见，而且可能会让人失去动力。下面我们将讨论为什么即使在真正想利用你的模型的公司中，许多模型也不能投入生产的 5 个原因，以及我们可以做些什么来确保我们的大多数模型能够投入生产。
1.你把它作为笔记本留下了
Jupyter 笔记本对于大多数数据科学工作来说都是惊人的。它们非常适合探索性分析、原型开发、快速开发和快速脚本编写。然而，它们通常不适合编写生产级代码。无序运行单元格和访问笔记本中所有变量的能力可能会导致违背最佳实践的代码。将代码 pythonise 化和模块化成具有多种功能的脚本通常更好，这也能更顺利地与传统的单元测试和版本控制一起工作。
请注意，这并不总是问题，因为网飞在生产中直接使用笔记本电脑https://netflixtechblog . com/notebook-innovation-591 ee 3221233？gi=a7ada81eb58c 借助 nbdev 等工具。
2.没有人知道如何实际生产它
一个常见的问题是，在您摄取的数据集上运行模型的笔记本是完整的，但您需要模型在产品中实时运行。然而，主要的代码库也不是用 Python 编写的，所以您不能导入 pandas 或执行用于清理和处理数据的操作。团队中的软件工程师并不精通 Python，DevOps 的工程师忙于生产问题。听起来熟悉吗？
在这种情况下，您可能需要扩展到 MLOps 中，以确保模型实际进入生产环境(我们可以使用 flask 和 docker 将模型部署为 API，我将在后面的文章中介绍)。在数据科学功能不太成熟的小公司，这通常是阻力最小的途径。另一种方法是提出购买 MLOps 工具的商业案例，或者确保产品和业务利益相关方的大力支持，如下所示。
3.没有其他人投入其中
确保你的模型投入生产的最好和最直接的方法是让产品经理参与进来并投资。机器学习模型的目的是解决问题，因此通过开发模型来解决产品经理的关键问题，我们可以快速轻松地获得利益相关者的投资，同时知道我们的解决方案具有切实的影响。这有助于确保模型部署被添加到路线图中，并且您获得了宝贵的跨团队工程团队时间。
Slidebean 在 Unsplash 上拍照
需要注意的是，在模型的开发过程中，您需要致力于利益相关者的管理。对数据科学项目进行时间估计也可能特别困难，这是作为路线图的一部分所必需的。以这种方式实施监控或 CI/CD 可能也很困难。
4.其他人都不知道这是干什么用的
在本文中，总的来说，关键思想是确保最终的涉众将使用正在构建的模型。你需要和他们一起工作，了解他们将如何使用你的工作成果，无论是在产品内部还是其他方面。如果您的信用风险团队没有适当的规则来利用该输出，那么创建预测客户申请信贷的风险的 API 是没有意义的。
过去，我看到过一些令人惊叹的工作，它们解决了一个关键问题，甚至部署了未被使用的端到端，因为部署不在运营终端用户实际使用的工具内。这个解决方案实际上只是落满了灰尘。这本来可以通过与实际用户本身的讨论来避免——不要让这种情况发生在你的工作中！
5.没有人知道它的输出意味着什么(创建一个提升图)
这是一个经典的讨论，我相信你以前已经听过很多次了，但是即使我们的模型有 99%的准确性，这对其他数据科学家来说实际上意义不大，对业务利益相关者来说就更小了。这里，让我们回到我们的信用风险案例，我们可以通过将类别分为“违约”和“无违约”来预测违约的概率，从而产生一个分类问题。然后我们可以利用模型的predict_proba方法得到违约概率。信用风险是一个常见的不平衡数据集问题，因为没有违约的类将远远超过有违约的类(除非信用风险分析师做得很糟糕！).在这种情况下，我们的模型有可能通过预测整个人口的非违约达到 99%的准确性，这在度量方面表现很好，但实际上是一个非常糟糕的模型！
用于分类的更好的度量可能是分类报告，它给出了肯定和否定分类的精度和召回的混淆矩阵。这将标记一个坏模型的性能，该模型仅预测没有缺省值，至于缺省值(1)由于没有真阳性，它将具有 0.0 精度和召回率。
示例sk learn . metrics . class ification _ report。作者图片
为了更好地向业务涉众传达这一点的含义，我们需要将它转化为业务环境。大多数机器学习模型都有正面(拒绝正确的违约者)和负面(不正确地拒绝一个好的申请人)，那么对底线的实际影响会是什么？这里最重要的指标通常是收入和利润，所以让我们看看这个信用风险的例子。
首先，我们通过对每个数据点的概率进行分桶并检查实际分类行为是否反映了分桶的行为，来创建提升图。下面我们展示了一个理想化的情况，其中桶默认比例非常接近概率。可以根据数据集的大小调整存储桶的大小。
一个非常好的分类模型表。作者图片
图为一个非常好的分类模型。作者图片
现在我们有了提升图，我们可以交流使用我们的模型设置违约概率阈值的影响。例如，从上表中可以看出，如果我们以 0.9 的概率拒绝高于阈值的信贷申请，那么 88%的拒绝将是正确的，我们将因 12%的不正确拒绝而损失收入。现在，这可以很容易地转化为货币价值，并转化为与业务部门讨论如何继续发展，这取决于收入和盈利能力哪个更重要。
最后的想法
许多数据科学家在解决困难问题方面做了惊人的工作，但在将他们的解决方案应用到生产中时可能会遇到困难。我们讨论过，这种情况的一个常见结果是需要掌握 MLOps 类型的技能，但最重要的是与产品经理和最终用户利益相关者就您正在构建什么以及如何实际使用它进行协作。为了更好地帮助您决定如何使用模型，将准确性或 AUC 等常见指标转化为实际的业务影响是一条可行之路。
如果你喜欢这篇文章，你可以找到更多的文章，并在我的个人资料上关注我！
使用 Dask 时要避免的 5 个新手错误
原文：https://towardsdatascience.com/5-rookie-mistakes-to-avoid-when-using-dask-592e4a909de6
Python 中成功的分布式计算策略
图片由 unsplash.com 的梅廷·奥泽尔拍摄
第一次使用 Dask 可能是一个陡峭的学习曲线。这篇文章介绍了人们在使用 Dask 时最常犯的 5 个错误，以及如何避免犯这些错误的策略。
让我们跳进来。
1.“Dask 基本就是熊猫吧？”
在开始用 Dask 构建东西之前，最重要的一件事是花时间了解 分布式计算的基本原理 首先。
Dask API 尽可能地遵循 pandas API，这意味着您可以很快开始使用 Dask。但是“尽可能”听起来似乎很简单。这没有告诉你的是，当你从熊猫转移到 Dask 时，你实际上进入了一个完全不同的宇宙——有不同的语言，不同的基本物理定律和不同的时间概念。
图片来自 gifbin.com
要想在 Dask 中取得成功，你需要知道一些事情，比如 Dask 为什么“懒惰”，哪些类型的问题是“令人尴尬的并行”，以及“将分区持久化到集群内存”意味着什么。如果这些对你来说听起来像是胡言乱语，请阅读这篇基本分布式计算概念介绍。如果这让你感到有些不知所措，也不要担心——深呼吸，记住几个月前我对这一切也几乎一无所知😉
好消息是，你不需要掌握任何这些新的语言或法律或概念——在大多数情况下，你可以通过对基本概念的基本理解来导航。这有点像去一个你不会说那种语言的地方度假。你不需要就当地错综复杂的政治体系进行完整的对话，就能玩得开心。但是如果你能要一部电话或者如果你需要的话问一下去你的酒店的方向，那会很有帮助。
2.“我就打电话。每当我想看到结果时，就使用 compute()。
pandas 和 Dask 之间最明显的区别之一是，当你调用 pandas 数据帧时，你得到的数据帧是:
import pandas as pd
df = pd.DataFrame({
"Name": ["Mercutio", "Tybalt", "Lady Montague"],
"Age": [3, 2, 4],
"Fur": ["Grey", "Grey", "White"] }
) df
..然而，当您调用 Dask 数据帧时，您得到的是塑料包装的等价物，而不是糖果:您将看到一些关于内部内容的描述性信息，而不是数据帧的实际内容:
import dask.dataframe as dd
dask_df = dd.from_pandas(df) dask_df
你会很快发现这是因为 Dask 的“懒惰评估”,如果你把.compute()加到你的 df 调用中，你会得到你在熊猫身上习惯看到的结果。
但是你在这里要小心。达斯克懒洋洋地评价是有原因的。惰性评估允许 Dask 将如何得到结果的计算推迟到最后一刻——也就是说，当它拥有尽可能多的关于数据的知识以及你想从数据中得到什么的时候。然后它可以计算出最有效的方法来得到你的结果。调用.compute()太频繁或太早会中断这个优化过程。这有点像在烹饪过程中吃了所有半生不熟的食材——味道不会那么好，如果你还想要最终的结果，你就必须从头再来。
这里的经验法则是:少用.compute()。仅使用它来具体化您确信的结果:1)将适合您的本地内存，2)是“完全煮熟的”——换句话说，不要中途中断 Dask 的优化，以及 3)理想情况下将在以后重用。关于compute的更多细节见本帖。
3.“既然如此，咱们就。坚持()一切！”
发现.compute()后不久，你将了解.persist()。
起初可能很难理解这两个命令之间的区别:这两个命令都是通过触发 Dask 计算来实现结果的。这个定义将帮助你区分它们:.persist() 与 **.compute()** 基本相同——除了它将结果加载到集群内存而不是本地内存。如果您需要复习一下本地内存和集群内存之间的区别，请查看本文的“集群”一节。
你可能会想——嗯，在这种情况下，我不应该什么都做吗？尤其是如果我在一个几乎无限内存的基于云的集群上工作，难道坚持不会让一切运行得更快吗？
是的…直到它不存在。就像.compute()一样，调用.persist()告诉 Dask 开始计算结果(烹饪食谱)。这意味着这些结果可以在您下次需要时直接使用。但是你只有两只手，有限的工具，而且是在赶时间。仅仅在你所有的盘子里装满你以后可能需要(或者可能不需要)的烹饪原料并不一定是在正确的时间把你所有准备好的菜送到所有用餐者面前的好策略。
当处理大量数据时，远程集群是一个很好的资源。但是即使是集群也有极限。尤其是当在生产环境中运行 Dask 时——集群不是免费的，而是受到严密的成本监控——您将开始更加关心如何尽可能有效地使用集群内存。
所以这里的建议和上面的相似:谨慎使用.persist()。仅使用它来具体化您确信的结果:1)将适合您的集群内存，2)是“完全成熟的”——换句话说，不要中途中断 Dask 的优化，以及 3)以后将被重用。将一个.persist()调用分配给一个新变量也是最佳实践，因为调用.persist()会返回新的 Dask 对象，由内存数据支持。
# assign persisted objects to a new variable
df = dd.read_parquet("s3://bucket/file.parquet") df_p = df.persist()
更多关于persist的细节见本帖。
4."让我们将所有数据转储到 CSV 文件中！"
我们都爱我们的 CSV 文件。在过去的几十年里，他们为我们提供了很好的服务，我们很感激他们的服务…但是现在是让他们走的时候了。
现在，您已经大胆地向分布式计算领域迈进，这意味着您可以获得全新的可能性，比如并行读取和写入文件。CSV 不适合这些高级处理功能，当使用 Dask 时，强烈建议使用 Apache Parquet 文件格式。它是一种具有高压缩选项的列格式，允许您执行诸如列修剪、谓词下推过滤等操作，并避免昂贵且容易出错的模式推断。
Dask 允许您使用以下工具轻松地将 CSV 文件转换为拼花文件:
# convert CSV file to Parquet using Dask
df = dd.read_csv("file.csv")
df.to_parquet("file.parquet")
阅读这篇关于针对 Dask 分析的 Parquet 的优势的博客。
5.“Dask 仪表板？那是什么？”
如果你来自熊猫，你可能习惯于在等待一个单元完成时，对正在运行的代码看得很少。耐心地观察你正在运行的 Jupyter 笔记本电池旁边的星号是你的一个日常习惯——也许辅以进度条或通知铃声。
Dask 在这里完全改变了游戏。Dask 为您提供了关于它为您运行的计算的强大而详细的可见性和诊断。您可以检查正在运行的任务的数量和类型、集群中工作器之间的数据传输、特定任务占用的内存量等等。
一旦您对 Dask 有了更多的了解，您将会经常使用仪表板来找出使您的代码运行得更快、更可靠的方法。例如，需要注意的一件事是出现的红色空间(数据传输)和白色空间(空闲时间)的数量——您需要最小化这两者。
您可以通过以下方式获得 Dask 仪表板的链接:
# launch a local Dask cluster using all available cores
from dask.distributed import Client
client = Client()
client.dashboard_link>> 'http://127.0.0.1:8787/status'
或者使用 Dask Dashboard extension for JupyterLab，，如本文所述。
观看 Dask 的原作者 Matt Rocklin 的视频，了解如何更好地使用 Dask Dashboard。
6.“我不需要寻求帮助”
我知道我说的是 5…但是这里有一个“额外的错误”,这可能是成功学习如何使用 Dask 的最重要的关键之一。
想要自己先尝试一些事情是令人钦佩的(也是很好的实践)。但是当你需要帮助的时候，不要害怕伸出手去寻求帮助。无论何时，只要你想更详细地讨论任何事情，并从多年来一直在构建和维护 Dask 的工程师那里获得信息，Dask 话语就是你要去的地方。
下一步是什么？
现在，您已经很好地避免了人们在加入 Dask 时最常犯的错误。对于任何认真探索分布式计算可能性的人来说，公开的 Dask 教程是一个很好的下一步。
一旦你掌握了基础知识，你可以在下面找到使用 Dask 完成更高级的 ETL、数据分析和机器学习任务的资源:
- 将 Dask 数据帧转换成 pandas 数据帧，或者反过来转换
- 合并 Dask 数据帧
- 与 Dask 并行训练 XG boost
祝你 Dask 之旅好运！
感谢您的阅读！在 LinkedIn 上关注我,了解定期的分布式计算更新和技巧。
请考虑成为支持写作社区的媒体成员:
https://richardpelgrim.medium.com/membership
原载于 2022 年 2 月 10 日https://coiled . io。
VS 代码生产率的 5 个秘密
原文：https://towardsdatascience.com/5-secrets-of-vs-code-productivity-8c5d446ae5a0
让使用 VS 代码变得更加高效
克里斯托夫·高尔在 Unsplash 拍摄的照片
Visual Studio 代码是 Python(当然还有许多其他语言)最流行的代码编辑器之一！即使只有默认设置，该应用程序也能让您真正高效。
根据这五个秘密更进一步，你就可以更好地使用 VS 代码了！我们开始吧！
构建您自己的代码片段
VSCode 附带了大量有用的代码片段！不幸的是，Python 片段在最近的 VSCode 更新中被删除了。幸运的是，根据自己的喜好，很容易添加一些有用的。
您会遇到的一个常见片段是下面的语句:
if __name__ == '__main__':
...
有了代码片段中的两个 dunders，自动化这一点不是很好吗？VSCode 让一切变得简单！
您可以使用以下步骤添加自己的代码片段:
- 访问命令调色板并进入“配置用户片段”菜单
- 然后，选择 Python
这将打开一个新的 JSON 文件。您可以按照以下格式向文件中添加任意数量的代码片段:
$1表示光标应该放在哪里。如果您有多个占位符，这允许您按 tab 键在占位符之间移动。
同样，您可以多次添加同一个占位符！例如，这允许您使用以下代码片段修改 Pandas 中的列:
在上面的代码片段中，有以下占位符:
- 数据帧名称
- 列名
- 该修改
这允许您输入一次数据帧名称，并且在两个$1位置输入。类似地，在两个$2位置输入列名。最后，最后一次按 tab 键可以让您轻松地修改列！
主键盘快捷键
有大量的键盘快捷键使得编写代码变得更加容易！了解这些可以让你轻松地编写创造性的程序。虽然这些快捷方式本身并不能节省大量的时间，但是它们的效率加起来会给你带来巨大的能量！
- CTRL/Command + Enter :直接在下面插入新的一行，不管你在当前行的什么位置
- ALT/Option+Shift+Up/Down:上下复制当前行
- ALT/Option + Up/Down :上下移动当前行
- ALT/Option + Shift + Right :点击两次选择当前括号内的所有内容(如果需要重新映射，该选项称为 smartSelect.grow
- CTRL/Command + / :注释掉当前行
- CTRL/Command+【or】:向内或向外缩进行
让编写文档字符串变得愉快
编写文档字符串是创建易于理解的代码的一个重要部分(无论是你自己还是他人！).不幸的是，编写它们可能有点痛苦，尤其是当您想要一致地格式化它们时。
谢天谢地， autoDocstring 扩展使得这个过程变得更加容易！通过写出一个函数(或类),扩展将自动地拉出片断并给出建议。
例如在下图中，通过创建一个带有两个参数的函数，我们可以简单地编写"""并点击 Tab 来创建一个 docstring。docstring 将提供占位符，您可以通过 tab 键查看摘要和不同的参数。
让创建文档字符串变得有趣！资料来源:Nik Piepenbreier
类似地，如果您的函数返回值，docstring 也会包含该值！
更容易地重构代码
当你写代码的时候，你会意识到在你写了一些东西之后，你会想把它重构为，比如说，一个函数。这是 VSCode 简化的另一件事！
当您选择一段代码时，会弹出一个灯泡，询问您是否要从选择中提取一个方法。当你这样做的时候，一个函数被定义，返回一个值。
如何在 VS 代码中轻松重构？资料来源:Nik Piepenbreier
同样，原来的选择被替换为函数调用！
将待办事项整合到侧边栏
这篇文章的最后一个技巧是在你的侧边栏中包含待办事项或提醒来解决问题。这是通过使用Todo 树扩展来完成的，它允许你添加一个注释到你的代码中，将一些事情标记为待办或修复。
通过在关键字后添加描述，您可以定义项目的名称。然后，通过导航到侧边栏并选择 Todo Tree 特性，您将获得项目中不同文件的所有待办事项列表！
在 VS 代码中跟踪任务！资料来源:Nik Piepenbreier
这种扩展可以使维护不同的代码变得更加容易，而不需要使用像吉拉这样复杂的东西。
结论
在本教程中，我们探索了五种提高 VSCode 使用效率的好方法！VSCode 提供了如此多的潜力来定制您想要的工作方式。这只是五种方法，希望能让你的代码工作更有趣一点！
使用 GitHub 操作、MLflow 和 SageMaker 管道进行 MLOps 的 5 个简单步骤
原文：https://towardsdatascience.com/5-simple-steps-to-mlops-with-github-actions-mlflow-and-sagemaker-pipelines-19abf951a70
使用项目模板启动生产之路
今年早些时候，我发布了一个分步指南，通过内置的 SageMaker MLOps 项目模板和 MLflow 实现端到端 ML 生命周期的自动化。它将工作流编排、模型注册和 CI/CD 整合在一起，减少了运行端到端 MLOps 项目的工作量。
由 NASA 在 Unsplash 上拍摄的照片
在这篇文章中，我们将更进一步，定义一个基于 GitHub、GitHub Actions、MLflow 和 SageMaker 管道的 MLOps 项目模板，您可以在多个项目中重用它来加速您的 ML 交付。
我们将采用随机森林在加州房价数据集上训练的示例模型，并自动化其端到端生命周期，直到部署到实时推理服务中。
演练概述
我们将分 4 步解决这个问题:
- 我们将首先使用 IDE、MLflow tracking server 设置一个开发环境，并将 GitHub 操作连接到您的 AWS 帐户。
- 其次，我将展示如何进行实验，以及如何与团队成员轻松协作。我们还将把代码打包到容器中，并在可伸缩的 SageMaker 作业中运行它们。
- 然后，我们将使用 SageMaker 管道自动化您的模型构建工作流，并安排它每周运行一次。
- 最后，我们将使用基于 GitHub Actions 的 CI/CD 管道在您的帐户中部署实时推理服务。
注意:除了部署推理服务(例如:数据标记、日期版本控制、模型监控)，MLOps 还可以有更多的功能，这个模板应该为您提供足够的结构来满足您的需求。
先决条件
要浏览此示例，请确保您具备以下条件:
- 如果您对 SageMaker Pipelines 听起来不熟悉，请访问介绍亚马逊 SageMaker Pipelines 。
- 熟悉使用 MLFlow 和 Amazon SageMaker 管道的 MLOps】。
- 熟悉 GitHub 动作。Github Actions——如果对你来说听起来很新鲜，那么开始使用 Github Actions所需要知道的一切都是一个好的开始。
- 这个 GitHub 库克隆到您的环境中。
步骤 1:设置项目环境
作者图片:项目架构概述。
我们将在项目中使用以下组件:
- SageMaker 负责基于容器的工作、模型托管和 ML 管道
- MLflow 用于实验跟踪和模型注册。
- API 网关用于暴露 API 背后的推理端点。
- GitHub 作为 repo、CI/CD 和 ML 管道调度程序，具有 GitHub 动作。
如果您在企业中工作，此设置可能由 IT 管理员为您完成。
在您最喜欢的 IDE 中工作
为了提高工作效率，请确保您在自己熟悉的 IDE 中工作。在这里，我在 SageMaker 笔记本实例上托管 VS 代码，还将使用 SageMaker Studio 来可视化 ML 管道。
作者图片
参见亚马逊 SageMaker 上的主机代码-服务器获取安装说明。
设置中央 MLflow 跟踪服务器
我们需要一个中央 MLflow 跟踪服务器来合作进行实验和注册模型。如果没有，可以按照说明和博文在 AWS Fargate 上部署 MLflow 的开源版本。
图片由作者提供:一旦部署，确保你把负载平衡器 URI 放在某个地方。我们将在我们的项目中使用它，以便代码、作业和管道可以与 MLflow 对话。
您还可以将 MLflow 替换为本地 SageMaker 选项、权重和偏差或您选择的任何其他工具。
将 GitHub 操作连接到您的 AWS 帐户
接下来，我们将使用 OpenID Connect (OIDC)来允许 GitHub Actions 工作流访问您帐户中的资源，而无需将 AWS 凭据存储为长期 GitHub 机密。参见在亚马逊网络服务中配置 OpenID Connect 获取说明。
作者图片:我们将 GitHub OIDC 身份提供者添加到 IAM 中，并配置一个信任它的 IAM 角色。
您可以设置一个具有以下信任关系的github-actions角色:
我们添加 SageMaker 作为主体，这样我们就可以直接从 GitHub 工作流中运行作业和管道。对于 Lambda 和 API Gateway 也是如此。
为了便于说明，我将AdministratorAccess托管策略附加到角色上。确保在您的环境中加强权限。
为项目设置 GitHub 回购机密
最后，我们将AWS account ID、region name和github-actions role ARN作为秘密存储在 GitHub repo 中。它们可能是敏感信息，将被您的 GitHub 工作流安全地使用。详见加密秘密。
图片作者:确保机密名称映射到您的工作流程中使用的名称。
我们现在准备好出发了！
步骤 2:在你的项目中进行实验和协作
你可以在带有示例笔记本和脚本的 repo 中找到实验文件夹。它通常是你开始项目并试图找出解决你的 ML 问题的方法的地方。
下面是主笔记本，显示如何在加州房价数据集上训练一个随机森林模型，并进行基本预测:
在我们的端到端项目中，这是一个简单的例子，您可以运行pip install -r requirements.txt与您的团队成员使用相同的依赖项。
ML 项目的这个实验阶段可能是相当松散的，你可以和你的团队一起决定如何组织子文件夹。此外，您是否应该使用笔记本或 python 脚本完全取决于您。
您可以将本地数据和文件保存在data和model文件夹中。我已经把它们添加到了.gitignore中，这样你就不会把大文件推给 GitHub 了。
构建您的回购以实现轻松协作
你可以随心所欲地构建你的回购协议。请记住，易用性和可重复性是项目生产率的关键。所以在这里，我将整个项目放在一个回购中，并试图在 python 项目惯例和 MLOps 需求之间找到平衡。
您可以在下面的文件夹结构中找到描述:
使用 MLflow 进行跟踪实验
无论是在 IDE 中还是在 SageMaker 作业中运行代码，都可以使用 MLflow 跟踪实验运行。在这里，我记录了在housing实验下运行的日志。
作者图片
您也可以在本回购中找到示例实验室以供参考。
步骤 3:在 SageMaker 中从本地计算转移到基于容器的作业
在本地运行代码可以在项目早期发挥作用。但是，在某些时候，您会希望将依赖项打包到可复制的 Docker 映像中，并使用 SageMaker 来运行可伸缩的、基于容器的作业。我推荐阅读亚马逊 SageMaker 入门的提升和转移方法，如果这对你来说听起来很新鲜的话。
将工作流分解为作业
您可以将项目工作流分解为多个步骤。我们将我们的工作分成两部分:我们在 SageMaker 处理作业中运行数据处理，在 SageMaker 培训作业中运行模型培训。
作者图片:处理作业将运行并输出一个 CSV 文件到 S3。然后在启动培训作业时使用文件 S3 位置。
构建集装箱并将其推送到 ECR
我们作业的 docker 文件在 docker 文件夹中，您可以运行下面的 shell 命令将图像推送到 ECR。
sh scripts/build_and_push.sh <ecr-repo-name> <dockerfile-folder>
在项目中使用配置文件
为了防止硬编码，我们需要一个存放作业参数的地方。这些参数可以包括容器映像 URIs、MLflow 跟踪服务器 URI、入口点脚本位置、实例类型、在 SageMaker 作业中运行的代码中使用的超参数。
为此，我们将使用 model_build.yaml 。它的 YAML 结构使其易于扩展和维护。确保在运行作业之前将 MLflow 服务器 URI 和新推送的容器映像 URIs 添加到配置中。
在 SageMaker 运行集装箱作业
您现在已经准备好执行 run_job.py 并在 SageMaker jobs 中运行您的代码。它将从 src/model_build 中读取配置并使用代码来启动处理和训练任务。
SageMaker 会在运行时将 prepare.py 和 train.py 注入到各自的容器中，并将它们作为入口点。
步骤 4:自动化您的模型构建
因此，您已经成功地在本地进行了试验，并在 SageMaker 中将工作流步骤作为基于容器的作业运行。现在您可以自动化这个过程。让我们称之为model_build过程，因为它与模型版本注册到 MLflow 之前发生的所有事情相关。
我们希望自动化容器映像构建，将 ML 工作流步骤绑定到管道中，并将管道创建自动化到 SageMaker 中。我们还将安排管道执行。
使用 GitHub 工作流自动构建容器图像
在上一步中，我们用脚本将容器映像推送到 ECR，并在 SageMaker 作业中运行它们。转向自动化，我们使用这个 GitHub 工作流来为我们处理流程。
作者图片
工作流查看 docker 文件夹中的 Dockerfiles，并在 repo main分支中发生更改时触发。它使用了一个复合 GitHub 动作，负责登录 ECR、构建和推送图像。
该工作流还基于 GitHub commit 标记容器图像，以确保 ML 工作流步骤的可追溯性和可再现性。
在 SageMaker 中将 ML 工作流步骤绑定到管道中
接下来，我们在 SageMaker 中定义一个管道来运行我们的工作流步骤。你可以在 src/model_build 文件夹中找到我们的管道。它基本上运行处理步骤，获取其输出数据位置，并触发训练步骤。与作业一样，管道执行使用我们的 model_build.yaml 中定义的参数。
我在 repo 中添加了scripts/submit _ pipeline . py来帮助您按需在 SageMaker 中创建/更新管道。它可以在需要时帮助调试和运行 SageMaker 中的管道。
作者图片:你可以在 SageMaker Studio 中看到你更新的管道，并且可以用**submit_pipeline.py --execute** command.运行执行
一旦对管道满意，我们就使用更新管道 GitHub 工作流来自动化其管理。它在main分支中寻找管道变更，并运行 submit_pipeline 来创建/更新。
用 GitHub 动作调度我们的 SageMaker 管道
我们可以对管道应用不同的触发器，这里我们将使用schedule-pipelineGitHub 工作流来调度它的执行。它使用 cron 表达式在星期五的 12:00 运行管道。
这个基本的调度示例可以为您的一些用例工作，并在您认为合适的时候随意调整管道触发器。您可能还希望将 model_build 配置指向新数据进入的位置。
作者图片
每次执行管道后，您将看到 MLflow 中出现一个新的模型版本。这些是我们想要部署到生产中的模型版本。
步骤 5:将推理服务部署到生产环境中
既然我们已经有了定期进入模型注册中心的模型版本，我们就可以将它们部署到产品中了。这就是model_deploy过程。
我们的实时推理服务
我们将为我们的项目构建一个实时推理服务。为此，我们希望从模型注册中心获得模型工件，构建一个 MLflow 推理容器，并将它们部署到 SageMaker 端点中。我们将通过 Lambda 函数和 API 公开我们的端点，客户端可以调用这些函数和 API 进行预测。
作者图片
如果您需要批量运行预测，您可以使用我们为model_build采用的相同方法构建一个 ML 推理管道。
将推理容器映像推送到 ECR
除了 ML 模型，我们还需要一个容器映像来处理 SageMaker 端点中的推理。让我们把 MLflow 提供的推送到 ECR。
我已经添加了build-ml flow-imageGithub 工作流来自动完成这个任务，它将运行[mlflow sagemaker build-and-push-container](https://github.com/sofianhamiti/amazon-sagemaker-github-actions-mlflow/blob/master/docker/mlflow_endpoint/mlflow_pyfunc.sh)命令来完成这个任务。
用 CDK 定义我们的 API 栈
我们使用 CDK 来部署我们的推理基础设施，并在 model_deploy 文件夹中定义我们的堆栈。app.py 是我们的主堆栈文件。您将看到它读取了 model_deploy 配置，并创建了 SageMaker 端点、作为请求代理的 Lambda 函数以及使用 API gateway 的 API。
在部署之前，确保使用容器映像和 MLflow tracking server URIs 更新您的 model_deploy 配置。
通过多级 CI/CD 管道部署到生产环境中
我们使用基于主干的方法将我们的推理 API 部署到生产中。本质上，我们使用一个与 repo main分支挂钩的多阶段 GitHub 工作流来构建、测试和部署我们的推理服务。
作者图片
CI/CD 工作流程在部署-推理中定义，有 4 个步骤:
- build 从 MLflow(在配置中定义)中读取选择的模型版本二进制文件，并将其 model.tar.gz 上传到 S3。这是由 mlflow_handler 完成的，它还将模型 S3 位置保存在 AWS SSM 中，供以后的 CI/CD 阶段使用。MLflow 处理程序还将模型转换为模型注册表中的 Staging。
- 部署-试运行将 CDK 堆栈部署到试运行中，这样我们就可以在投入生产之前对 API 进行测试。这项工作使用了我为将 CDK 模板部署到 AWS 中而构建的复合 GitHub 动作。
- test-api 在准备阶段对推理服务进行基本测试。它向 API 发送一个示例有效负载，并检查响应状态是否正常。如果确定，MLflow 处理程序将在模型注册表中将模型转换为生产。如果您认为合适，可以随意添加更多的测试。
- 部署-生产将 CDK 堆栈部署到生产环境中。
作者提供的图片:模型阶段将在 MLflow 中转换，因为它在管道中前进，并在新版本出现时存档。
使用您的推理服务
当您的服务成功部署到产品中时，您可以导航到 AWS CloudFormation 控制台，查看堆栈Outputs，并复制您的 API URL。
作者图片
现在，您已经准备好调用您的推理 API，并且可以在请求正文中使用以下示例数据点:
你可以使用像 Postman 这样的工具从你的电脑上测试推理 API:
图片作者:API 将在几毫秒内返回预测的房价值。
结论
在这篇文章中，我与你分享了一个 MLOps 项目模板，它将实验跟踪、工作流程编排、模型注册和 CI/CD 放在一个伞下。它的主要目标是减少运行端到端 MLOps 项目的工作量，并加快您的交付。
它使用 GitHub、GitHub Actions、MLflow 和 SageMaker 管道，您可以在多个项目中重用它。
为了进一步学习，您可以访问 Awesome SageMaker ，在一个地方找到与 SageMaker 合作所需的所有相关和最新资源。
用 Python 更高效地编写代码的 5 个简单技巧
原文：https://towardsdatascience.com/5-simple-techniques-to-write-your-code-more-efficiently-in-python-f095bb2b1e15
让你的代码更快，更容易阅读，更容易理解
照片来自 Pexels，作者为 Cottonbro
Python 是一种强大的编程语言，它能让你用很少的代码做很多事情。
然而，权力越大，责任越大。
为了编写高效和优化的代码，您需要避免不必要的代码使用，并使用适当的实践和技术使您的代码运行得更快。
在本帖中，我们将讨论 5 种技术，它们将帮助你用 Python 编写更快、更高效的代码！
1.创建函数
函数是可以从程序中的任何地方调用的代码块。
函数通常用于执行重复性任务，如计算圆的面积或在屏幕上打印文本。创建它最简单的方法是使用 def 关键字，后跟它的名称和括号():
def square(x):
return x*xprint(“The square of”, 25, “is”, square(25))
这段代码将打印出来:25 的平方是 625。
函数是组织代码并使其更具可读性的好方法。您还可以使用它们向代码的用户隐藏实现细节。
不要一次又一次地编写相同的代码块，而是使用函数编写一次，然后从多个地方调用它。这将使你的代码更有效，更容易阅读和维护。
2.消除不必要的操作
编写代码时，尽量消除任何不必要的操作。例如，如果你正在遍历一个项目列表，并且只需要第一个项目，就不要再遍历列表的其余部分了。
list = [0, 0, 0]for i in range(len(list)):
print(“The Squared value of”, i, “is”, list[i]*list[i])
这会打印出来:0 的平方值是 0。
在这个例子中，为了提高代码的效率，您可以使用 index()方法来获取序列中某个元素的位置，然后在找到该位置时通过中断循环来停止。
这段代码效率更高，因为它做的工作更少。
list = [0, 0, 0]for i in range(len(list)):
if list[i] == 0:
break
print(“The Squared value of”, i, “is”, list[i]*list[i])
这段代码将打印出和以前一样的东西(0 的平方值是 0)，但不同的是它在更短的时间内得到相同的结果，因为它没有经过完整的循环，当我们得到我们需要的东西时它就停止了。
消除不必要操作的其他方法包括:
- 使用 continue 而不是 break 跳过循环中剩余的迭代
- 尽可能重用变量(例如，不要每次都创建新的变量)
- 对将多次使用的大型序列或迭代器使用生成器；这样可以节省内存，因为它一次只加载一个元素
3.使用对你有利的包装
Python 附带了大量的包，您可以使用这些包来使您的代码更加动态和高效。
包是由其他 Python 开发者编写的函数、类和其他工具的集合。它们存储在名为 PyPI (Python 包索引)的存储库中，可以使用 pip 工具进行安装。
包可以用来做任何事情，从解析 XML 文档到创建图形用户界面。通过运行以下命令，可以找到系统上安装的所有软件包的列表:
python -m pip freeze
这将打印出当前安装在您的系统上的所有软件包的列表，以及它们的版本号。您也可以使用这个命令来安装新的软件包。
例如，如果您想要安装 pandas 软件包，您可以运行以下命令:
python -m pip install pandas
这将从 PyPI 安装最新版本的 pandas 包。如果您想要使用不同的版本，也可以指定特定的版本号。
当寻找解决特定问题的包时，搜索 PyPI 存储库通常是个好主意。您可以通过运行以下命令来实现这一点:
pypi -l
这将打印出 PyPI 上所有可用包的列表，以及它们的描述。你也可以在 pypi.org 在线浏览 PyPI。
4.避免声明不必要的变量
编写代码时，避免声明不必要的变量。例如，如果您只需要使用一次某个值，就不要声明一个新变量来保存该值。
这是不要做的事情:
x = 25y = x*xprint(y)
这将打印出 25 的平方，即 625。在这里，您可以通过使用内置函数 pow()或 square()来消除对变量的需求。在这个例子中，我们将使用 power():
x = 25print(pow(x,x))
这段代码将像以前一样打印出来，但是现在我们只声明了 1 个变量，而不是 2 个。
我们不想要额外变量的简单原因是因为它们会使我们的代码难以阅读和维护。
当你在查看一段代码时，能够快速理解每个变量的用途是很重要的。如果变量太多，这就变得很难做到。
5.必要时中断循环
必要时打破循环是很重要的。例如，考虑以下代码:
while True:
print(“Hello World!”)
这将打印出“Hello World！”永远，或者直到您使用 Ctrl-C 手动终止程序。您可以通过在 if 子句中使用 break 语句来停止程序:
while True:
if some condition is met:
break
print(“Hello World!”)
这将打印出“Hello World！”直到满足某些条件，如 hello world 打印了 5 次，然后停止代码。
同样的概念也适用于 for 循环。例如，考虑以下代码:
for i in range(0, 100):
if i % 15 == 0:
break
print(i)
这段代码将打印出从 0 到 99 的所有数字，除了那些能被 15 整除的数字。当它达到一个能被 15 整除的数时，代码将停止。
break 语句在许多情况下非常有用，例如，当您因为满足某些条件或者在运行代码时出现错误而希望提前退出循环时。
结论
这些只是可以用来在 Python 中编写更高效代码的一些技术。您还可以做许多其他事情，例如使用类、将代码组织成模块以及利用内置函数。通过遵循这些提示，您可以编写易于阅读和理解并且运行速度更快的代码。
编码快乐！
与 5k 以上的人一起加入我的电子邮件列表，免费获得“完整的 Python 数据科学备忘手册”
5 个简单的技巧，帮助你成为一名经得起未来考验的数据科学家
原文：https://towardsdatascience.com/5-simple-tips-to-help-you-future-proof-yourself-as-a-data-scientist-8b34479e5aad
技术和标准可能会改变，但这些建议将适用于你的整个职业生涯
peer apon chantharaintron 在 Unsplash 上的照片
从事数据科学工作的人最大的恐惧是变得无关紧要。
没有什么比光速和科技产业发展得更快，数据科学家在进入该领域几年后就变得无关紧要也并不罕见。
这意味着，为了保持相关性，学习新技能，并确保您定期在数据科学领域占有一席之地，您将一直战斗下去。
然而，它不必像我说的那样可怕。尽管随着对新技术、深化的商业敏锐度和更敏锐的利益相关者演示的不断需求，数据科学发展迅速，但有一些简单的事情将永远保持不变。技术一直在变化，在研究如何让你的行业表现得更好方面总是有新的进展。
从长远来看，专注于你可以控制的事情，如软技能、项目管理、商业头脑和提出好的问题，会比学习一门新的编程语言或重新发明轮子让你走得更远。这些事情不仅会让你成为更好的数据科学家(因为让我们面对现实吧，数据科学，正如我们所希望的那样，不仅仅是数学和编程)，而且它们还会让你的职业生涯在长期内经得起考验。
作为一名数据科学家，你需要掌握的 5 个简单技巧
1.培养良好的商业头脑/成为中小企业
如果你能证明你为公司提供了价值，你就永远不会失业。
但是你如何证明你的影响力呢？
通过培养和保持良好的商业头脑，跟上行业的最新趋势和进步，你将确保自己在公司的餐桌上永远占有一席之地。
好的商业头脑是什么样的？
坚实的商业敏锐性将帮助你适应未来，这是你在工作场所的经历中积累的特定行业的知识和技能的丰富组合。商业敏锐性有助于你的决策，预测行业的进步或变化，并让你有信心引导你的公司(甚至是较小规模的部门)朝着特定的方向发展。这意味着对你所在行业的细节保持深入了解。我最喜欢的培养商业头脑和跟上行业发展的方法是订阅行业领导者和爱好者的时事通讯、博客、播客和 YouTube 频道。
我参与的一个项目与我以前参与过的项目属于不同的领域。在我们最初的几次会面之前，我做了一些快速的调查，这样我就能知道会发生什么，并了解这个行业的发展方向。大约 10 分钟后，我有了一个想法清单，然后向客户推销。虽然他们没有采纳我提出的每一个建议，但他们肯定对我花时间做一些研究来了解他们以及他们的业务是如何运作的印象深刻。此外，我的一些建议进入了最终产品，并最终提供了比他们最初期望的更多的见解和细节。
为了更进一步，你可以考虑成为主题专家(SME)。中小型企业的需求量很大，因为他们有非常具体的知识库，适用于客户可能面临的非常具体的情况。例如，你可以是一名数据科学家，他是野生动物种群生态学领域的中小型企业，利用这一知识帮助客户确定其工业项目的扩张如何减少了栖息地空间，从而影响了以该地区为家的物种种群。或者，你也可以是一名数据科学家，他是网站访客保持方面的中小型企业，可以利用数据准确定位客户网站失去访客的确切时间，以及如何补救。成为 SME 是你接受非数据科学教育(例如，科学、医学、工程、商业等学位)的好方法。)并应用到你所做的工作中。你也可以通过免费旁听大学课程、尽可能多地阅读相关内容来成为中小企业，还可以通过在网上发表作品来巩固自己作为中小企业的权威。
2.能够根据听众调整你的信息
这似乎是一个标准的提示，但有技术背景的人很少知道如何与他们面前的观众有效沟通。要记住你并不总是在对着自己的镜子说话是一件很难的事情。
开始向你的观众传递正确信息的最好方法是检查谁是你的观众，什么对他们是重要的。从那里，你可以开始精心制作你的信息，以满足观众的需求。
消息创建过程很简单。
与非技术人员交谈时，不要使用技术术语。
在与数据科学家同事交谈时，将对话快速引向技术内容。
与你交谈的人级别越高，你的信息就越要切中要害。
与长期客户的闲聊对于维持稳固的关系总是至关重要的。
CEO 只想知道你的分析结果，以及对他们公司的意义。
知道如何与每个人交谈给了我职业生涯中最大的成功。我灵活的沟通技巧最终推动我在技术领域的职业生涯朝着一个更少基于技术、更多基于管理的特定方向发展，因为我能够与我的团队成员谈论工作，我能够以非技术方式向客户解释技术概念，我能够在与潜在客户交谈时筛选出正确的信息。
与团队成员、其他技术人员、高管和长期客户等所有人进行有效、高效和直观沟通的能力是一项技能，它将使你成为公司的无价之宝。
3.提出好问题的能力将超过跟上最新技术的需要
自从数据科学出现以来，可以说大多数分析都可以使用 Excel 和 SQL 来完成。
数据分析是关于谁能提出正确的问题，而不是谁能最好地使用最新的技术。新数据科学技术的出现只是为了解决所有数据科学家在日常工作中遇到的小问题或不便。也许一个新的工具通过自动化一个简单的任务节省了你几分钟的工作量，或者也许一个工具允许你创建视觉上令人惊叹的图形，这可能是艺术家羡慕的。
然而，一种新的超高效工具无法克服能够提出好问题的必要性。如果你不能提出正确的问题，这些超级高效的工具也不会让你成为更好的数据科学家。
培养在正确的时间问正确的问题的能力，比你跟上一年后会变得模糊的新技术的能力更能让你成为一名数据科学家。
如上所述，大多数数据分析可以使用简单的工具完成。你向你的客户、老板或其他利益相关者提出的问题会带来不同。
在你职业生涯的剩余时间里，你应该在每次分析中提出的问题包括(但当然不限于):
- "哪些变量与我试图解决的问题相关？"
- “这个数据集的关键组成部分是什么？”
- “这些数据可以分类吗？”
- "这个分析结果不寻常吗？"
- “有哪些关键关系？”
- “这是该公司执行这项任务的最佳方式吗？”
- “在新的条件下会发生什么？”
- "什么因素最适合用来决定或预测这种可能性？"
我最喜欢在白板上标出从我的问题中获得的信息。在分析之前、之中和之后，我会在白板上添加他们想到的一般问题和具体问题。即使是简单的问题，比如“为什么这个分析的结果对组织很重要？”或者“谁是这个分析的涉众？”是为了使我试图解决的问题更加清晰。然后，当我收集我的答案时，我把它们写在便利贴上，并把它们加到黑板上他们回答的问题下面。在回答中使用便笺可以让我在从问题中获得的不同信息之间建立联系，并且当我对问题的回答基于不同的分析结果而改变时，也给了我一点灵活性。作为一个额外的收获，这些便利贴变成了我用来帮助我交流结果的关键信息，就像上面讨论的那样。
4.对你正在解决的问题保持良好的态度和真诚的好奇心会让你坚持下去
科技界的人以脾气暴躁、睡眠不足而闻名，他们想为那些他们认为不如他们聪明的人做最起码的工作。
我认为这通常是技术人口中体面阶层的公平代表。我见过几个人，尽管他们才华横溢，希望在与外界联系很少的数据科学岗位上工作，但他们仍然没有得到这份工作，因为他们把糟糕的精力带到了办公室。不幸的是，选择这种方式的人往往会在职业生涯中失败，因为糟糕的态度和仅略高于标准的工作会让团队成员、老板和公司利益相关者反感。
当他们的团队由快乐的、真正好奇的人组成时，每个人都喜欢来工作。没有人喜欢和一个明显只是为了赚钱的人一起工作——并且不断提醒其他人这个事实。
另一方面，在与客户密切合作时，良好的态度和对你正在解决的问题的真正好奇心是非常重要的品质。记住:客户永远是国王。这意味着确保他们快乐和被照顾是你的首要任务。当你在一家小公司工作时，这一点尤其重要，在那里你可能没有一个客户服务团队，他们是与客户的主要接口。在小公司，你可能不仅仅是一名数据科学家，你也可能是客户的主要联系人。记住保持专业、耐心和好奇的态度会让客户知道你真的关心他们，他们的数据会得到妥善保管。
在我的经历中，拥有良好的态度让我受益匪浅。无论这一天有多糟糕，或者我的代码运行得有多糟糕，我都会为客户打开它，散发出一种充满活力和好奇心的气息，这意味着与我打交道总是令人愉快的。在这里，你可以将良好的态度与扎实的商业头脑结合起来，以确保你与团队其他成员、高管或客户的每一次对话都富有成效，并产生以前可能没有考虑过的新想法。
数据科学行业也不例外，无论是在团队中工作还是与客户打交道，良好的态度都会让你的职业生涯走得更远。
5.培养项目管理技能，使其能够从头到尾完成一个项目
初级数据科学家与其他人的区别在于从头到尾管理项目的能力。
数据科学的进步往往基于项目和人员管理技能。如果你想让自己的职业生涯经得起未来考验，并享受在公司稳步上升的过程，这一点至关重要。
作为一名初级数据科学家，可以理解你职业生涯中的第一个目标仅仅是在一个项目中生存下来，并按时提交你的可交付成果。然而，随着你职业生涯的发展，你会意识到那些拥有项目管理技能的人比那些满足于只做项目一小部分的人更有可能进步。
培养项目管理技能不仅能让你在公司内部获得提升，还能让你有能力自己创业，如果你突然想为自己工作，你可以成为一名顾问。
从开始到结束管理数据科学项目涉及数据科学项目的所有传统阶段(包括问题定义、数据收集和清理、分析、可视化和实施)，还包括与客户的初步信息收集会议，以及在项目结束时向利益相关方最终展示调查结果。所有在线数据科学课程都教你如何完成数据科学项目的传统阶段，但很少有人超越并描述你应该如何执行项目的初始和最终阶段。
在项目的最初和最后阶段，你与客户的互动包括使用上述的提示 1-4。管理一个完整的数据科学项目将需要您在首次成为数据科学家时积累的所有技术和数学知识，还需要利用商业敏锐度、沟通技能、事实调查和组织技能，以及适当的举止和专业技能。
扎实的项目管理技能最终指导了我的科技职业生涯。虽然我在技术方面还不错，会做数学，会写代码，但我擅长管理项目。我没有与之抗争，而是决定离开这份工作中更具技术性的部分，专注于成为一名能够按时出色完成项目的强有力的领导者。虽然离开你熟悉的东西可能会令人害怕，但这可能是一次很好的学习经历，它会教会你比安全行事更多的东西，还会为你未来的发展提供一条途径。
额外收获:SQL、领域知识和软技能是唯一永远不会改变的东西
数据科学中永远不会改变的三件事是对 SQL 的需求、领域知识(商业头脑)和软技能。其余的将至少每年改变一次，但是你可以依赖的三个常数是上面列出的那些。
与其沉迷于似乎每五分钟就变化一次的技术，更重要的是巩固那些永远不会改变的技能。正如我之前所说，大多数数据科学项目都可以使用 SQL、Excel、商业敏锐性、良好的沟通技巧和一点直觉思维来完成。在数据科学领域，人们普遍认为那些只使用简单技术的人是不太优秀的数据科学家。相反，我认为那些能够使用简单技术解决与使用最新最伟大工具的人相同的问题的人是更好的数据科学家，因为他们没有所有花哨的噱头来完成他们的项目。
每家公司确实都有自己标准的做事方式和特定的标准，他们将使用这些标准来决定他们的数据科学家的进步。虽然掌握新技术可能是其中之一，但将会有更多的标准要求数据科学家具有坚实的商业头脑，能够与各种受众有效沟通，能够提出正确的问题来解决问题，对他们完成的项目有良好的态度和真诚的关心和好奇心，以及从头到尾管理项目的能力，换句话说，数据科学中的所有事情永远不会改变。
订阅将我的故事直接发送到您的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将收取少量佣金，无需额外费用):媒体会员
通过捐赠来支持我的写作，以资助更多像这样的故事的创作:捐赠
从初级数据科学家晋升到高级数据科学家的 5 项技能
原文：https://towardsdatascience.com/5-skills-to-move-from-junior-to-senior-data-scientist-94268137c0f3
期待什么以及如何到达那里？
戴维·比林斯在 Unsplash 上的照片
初级和高级数据科学家之间存在显著差异。如果你现在是大三学生，你可能会想:
- 对每个角色的期望是什么？
- 想要升职需要什么技能？
成功不是偶然，成功是选择。— 斯蒂芬·库里
这篇博文将讨论初级和高级数据科学家所需的不同技能和期望。我们将经历:
- 主要差异和期望
- 所需的技术技能和预期目标
- 为什么软技能很重要，哪一项很重要
主要差异和期望
初级数据科学家通常在该领域有大约两年的经验。他们通常刚刚开始学习新技能，磨练现有技能。另一方面，大四学生有大约五年或更多的经验。因此，他们对数据科学概念有了更深刻的理解，并能够以创新的方式应用它们。
那么，初级和高级数据科学家需要哪些不同的技能呢？大三需要胜任数据清理、分析、建模等工作。他们还需要了解基本的机器学习算法，并知道如何有效地使用它们。高年级学生需要成为所有这些方面以及大数据技术和架构的专家。他们还应该能够开发复杂的数据产品和解决方案。
除了拥有不同的技能，大三学生和大四学生也有不同的期望:
- 初级数据科学家通常会执行例行的数据清理和分析任务。他们也可能被要求开发模型或原型，但他们的主要重点是学习新技能和扩大他们的知识基础。
- 另一方面，高级数据科学家应该领导项目，指导下级，并支持业务利益相关者产生想法。他们还负责开发解决复杂业务问题的创新解决方案。
成为一名高级数据科学家需要多长时间？
成为学长需要时间和付出。这不是一朝一夕可以完成的事情。通常需要大约五年或更长时间才能到达那里。在这段时间里，你需要学习新的技能，不断增长你的知识库。您还需要在真实场景中有效地应用所学的技能。
成为一名高级数据科学家需要具备哪些技术技能？
照片由奥斯汀·迪斯特尔在 Unsplash 上拍摄
能够全程领导一个项目
你需要能够全程领导一个数据科学项目。这包括数据清理和预处理、特征工程、寻找最相关的模型、算法调整、性能优化和结果解释。
初级数据科学家应该已经知道这些步骤。尽管如此，我们还是期望一个资深者能够掌握它们，并且在没有外部验证的情况下执行它们。
在项目开始时，高级数据科学家还应该清楚地知道哪些步骤是相关的，并估计执行这些步骤所需的时间。
这就引出了第二项技术技能。
具有良好的项目管理技能
与初级数据科学家相比，高级数据科学家应该执行大多数项目管理任务。这将包括:
- 确保清晰的项目定义:与利益相关者会面，撰写分析计划，并制定详细的议程。定义成功是什么样子并建立跟踪机制。
- 管理时间表:定义需要做什么，在适当的时候沟通，在相关的时候停止调查…
- 监控项目执行:这包括每日/每周的状态会议，维护计划，并标记偏离计划的情况。
- 与利益相关者沟通:以有效的方式进行沟通(不仅仅是报告数字)。例如，能够翻译数据科学概念，以便业务利益相关者能够理解它们。
业务到数据转换:确保影响
高级数据科学家还需要知道如何将业务问题转化为技术解决方案。他需要能够提出假设，并弄清楚需要哪些数据来验证它们。
他们还应该能够与业务涉众合作，以了解他们将如何使用项目的结果或成果。
这可能是一名高级数据科学家的基本技能:确保项目会产生影响。
风险在于，在开始一个项目时，对其中的利害关系只有轻微的了解。那么输出很可能无法被业务涉众使用，并且变得不相关。
如果你能以 95%的准确率预测 Y，但你只能每个月得到一个答案，如果你的利益相关者需要每天做出决定，这可能是没有用的。如果每日预测不那么准确，他们可能会做得更好。
成为一名高级数据科学家需要具备哪些软技能？
照片由布鲁克·卡吉尔在 Unsplash 上拍摄
出色的沟通技巧至关重要
除了技术技能，高级数据科学家还需要很强的软技能。例如，他们需要能够有效地与业务利益相关者沟通，并以他们能够理解的方式传达数据相关的概念。
在某些情况下，如果高级数据科学家更多地走技术路线，强大的沟通技能可能不那么重要。然而，即使是最技术化的数据科学家也需要交流其发现，并能够说服他人。
作为一名数据科学家，我在这篇文章中更详细地讨论了沟通:
需要教练和领导来支持团队
高年级学生也必须学会领导和指导低年级学生。这包括发展团队合作技能和在需要时提供指导和支持。最后，高级数据科学家必须独立工作，并在需要时采取主动。
指导和培训他人也是高级数据科学家工作的一个重要方面。作为导师，他必须能够:
- 提供关于数据科学工具和技术的建议
- 关于如何构建数据分析项目的指南
- 审查数据科学工作产品的准确性和完整性
- 教授正确的编码实践、建模方法等。
- 评估更多初级同事的潜力
结论
成为高级数据科学家所需的技能多种多样，包括技术和软技能:
- 他们必须有很强的分析能力，他们还负责开发解决复杂业务问题的创新解决方案。
- 他们应该知道如何从头到尾领导一个项目。
- 他们必须掌握与商业利益相关者的沟通。见我之前关于这个话题的文章。
- 他们应该领导和指导初级数据科学家。你可以阅读这些书来帮助你。
- 此外，批判性思维技能对于数据科学家来说至关重要。
你是初级还是高级数据科学家？你对这个帖子有什么想法？请在下面的评论中告诉我！
瓦伦丁·穆克
- 如果你喜欢的话，可以 关注我上媒 ！
- 想联系也可以在Linkedin上联系。
如果你喜欢 Medium，请考虑使用我的推荐链接来无限制地访问每篇文章，我将免费收取你的一部分会员费！
https://valentin-mucke-ds.medium.com/membership
5 张幻灯片，介绍 Jupyter 笔记本的演示模式
原文：https://towardsdatascience.com/5-slides-for-tips-on-presentation-mode-in-jupyter-notebook-f858b15fff4f
使用 Jupyter Notebook 创建 HTML 幻灯片的教程
Austin Distel 在 Unsplash 上嵌入的照片
让我们开始吧
你在这里，你正在阅读这篇文章，你已经安装了 jupyter 笔记本并准备就绪。
jupyter 笔记本的演示幻灯片选项不言自明。这是将屏幕截图复制粘贴到其他演示软件的一种替代方法。
第一步是在视图>单元格工具栏选项中启用幻灯片显示选项。只需点击幻灯片选项，继续阅读。
启用幻灯片
Jupyter 笔记本中的每个单元格在右上角都有一个幻灯片类型选项。
幻灯片放映现已启用
带幻灯片演示的笔记本示例
这是我们接下来要看的 Jupyter 笔记本的完整图像。如果你愿意跟随，这款笔记本也可以在 GitHub 上找到。
接下来的步骤将包含演示结果的幻灯片输出，尽管会参考本笔记本。
作者图片
幻灯片
一旦您有了想要发送到 HTML 幻灯片演示文稿的笔记本，请从终端运行以下一行命令。因为您可能已经在现有的终端窗口上运行了 Jupyter Notebook，所以您可以打开另一个终端窗口来运行该命令行命令。
jupyter nbconvert 'Presentation Slides with Jupyter Notebook.ipynb' --to slides --post serve
该命令在运行 Jupyter Notebook 的浏览器中生成并打开了一个名为“用 Jupyter Notebook.slides.html 演示幻灯片”的文件。
第一张幻灯片
第一张幻灯片的类型为“幻灯片”,右下角有一个箭头，可移动到下一张幻灯片。
第一张幻灯片
第二张幻灯片
第二张幻灯片也是“幻灯片”类型，但在右下角有三个选项。
- 您可以通过单击向左箭头返回到第一张幻灯片
- 您可以通过单击右箭头前进到下一组主幻灯片，但这会跳过一些内容，因为您有一个可用的向下箭头
- 让我们单击向下箭头，看看接下来会发生什么
第二张幻灯片
第三张幻灯片(或者第三张图片，如果你喜欢的话)
单击上面的向下箭头后，我们现在在第三个图像上，它的类型是“子幻灯片”此选项启用了不同的幻灯片分组。但剩下的还不止这些。还有另一个向下箭头选项，让我们再次单击它。
第三张幻灯片
第四张幻灯片(或者第四张图片，如果你喜欢)
当这次点击向下按钮时，子幻灯片保留在屏幕上，而下一个幻灯片类型“片段”出现。
此外，幻灯片类型“-”出现在底部，因为“-”将在该幻灯片或子幻灯片的最后一次执行后出现。
第四张幻灯片
第五张幻灯片
然后，当您按下右箭头时，会出现最后一张幻灯片。也就是说跳过了“笔记”的幻灯片类型，类似于笔记本开头跳过“跳过”的幻灯片类型。没错——我们已经在开头使用了“跳过”幻灯片类型，用于导入熊猫的陈述。
最后一张幻灯片
重述幻灯片类型
概括地说，Jupyter 笔记本幻灯片有几种幻灯片类型。
- 滑动:用右箭头导航
- 子滑块:用向下箭头导航
- 片段:将在下一个箭头上被添加到当前幻灯片或子幻灯片中
- 备注，跳过:不会成为幻灯片的一部分
- -、<空白> :将出现在幻灯片或子幻灯片的底部，作为幻灯片或子幻灯片最后一次执行的一部分
其他提示和思考
为了给幻灯片添加页眉或页脚，请使用 Jupyter 笔记本的降价选项。
如果幻灯片上的内容太多，一些内容将不会出现在底部，并会从幻灯片中剪下。
Jupyter 笔记本幻灯片对于某些演示非常有用，因为无需将 Jupyter 笔记本信息传输到演示软件就可以构建幻灯片。但是其他软件的存在是有充分理由的，在某些情况下可能是更好的选择。
如果你喜欢这篇文章，并想阅读(和写)更多这样的文章，请考虑点击我的个人资料图片旁边的关注按钮和/或使用我的推荐链接https://sabolch-horvat.medium.com/membership订阅中级会员
你没有使用但应该使用的 5 个雪花查询技巧
原文：https://towardsdatascience.com/5-snowflake-query-tricks-you-arent-using-but-should-be-7f264b2a72d8
更少的行、更低的成本和更快的执行时间
凯利·西克玛在 Unsplash 上的照片
雪花是一个云计算数据解决方案，允许用户在他们的云平台上直接存储数据和运行查询，可以通过网络浏览器直接访问。它通常用于廉价的数据存储和自动伸缩能力，集群可以自动启动和停止来管理查询工作负载。
经常被忽视的是，雪花不仅仅使在数据库上设置和运行查询变得更容易。它还具有独特的查询语法，这是 PostgreSQL 或 MySQL 等其他数据库系统所没有的。在下面的这篇文章中，我们将介绍我最喜欢的这些强大的子句，以及如何使用它们来改进语法和可读性，但最重要的是减少计算成本和执行时间。
1.具有资格；合格；取得资格(或学历)
qualify 子句允许我们直接过滤窗口函数的结果，而不是先在 CTE 中创建结果，然后再过滤。窗口函数的一个非常常见的方法是使用子查询首先获得 row_number()
row_number() over (partition by email order by created_at desc) as date_ranking
然后在另一个 CTE 中对此进行过滤，以获得组中的第一行。
where date_ranking = 1
这种方法的问题是它需要一个额外的子查询。在 Snowflake 中，这可以通过使用 qualify 将窗口函数应用为 where 并同时执行这两个步骤来实现。
Qualify 还有另一个非常强大的用例。一个常见的即席或 QA 查询是检查重复项，以找出唯一性测试失败的原因，并避免无意中复制行的连接。这通常看起来像这样。
select
product_id,
count(*)
from product_sales
group by 1
having count(*) > 1
order by 2 desc
然而，这仅仅给了我们主键，并没有告诉我们副本出现在哪一列。要修复重复，我们需要知道是什么导致了它，因此最简单的方法就是能够看到所有的列。这可以通过使用上述查询的 CTE，然后执行另一个在 id 上过滤的选择(或者通过复制和粘贴主键值)来完成。
with base as (
select
product_id,
count(*)
from product_sales
group by 1
having count(*) > 1
order by 2 desc
)select *
from product_sales
where product_id in (select product_id from base)
但是现在我们知道了 qualify 的存在，我们实际上可以在四分之一的行中完成这个查询，而不需要任何额外的步骤。
select *
from product_sales
qualify count(*) over (partition by product_id) > 1
2.敌我识别系统(Identification Friend or Foe)
iff 子句允许我们使用一个简单的例子，但是在语法上更漂亮。这样做的好处是可以替换单个比较的 CASE 子句(例如，创建一个 true/false 字段)。
case when col is null then true else false end
我们现在可以用更少的单词和更常用的语法(如 Excel 或 Python)来执行上述功能，这就是if a then b else c逻辑。
这比前一种方法更漂亮(我认为),也清楚地表明了哪些情况下只执行一次比较，而哪些情况下实际上需要 CASE 子句。当与其他子句链接时是否更容易理解，因为它是一个带有开始和结束括号的自包含函数。
3.在枢轴上转动
在对每个列执行相同的聚合时， pivot 子句用于将一列中的唯一值分散到多个列中。透视值是一种常见的技术，用于对总数进行分段以供进一步分析，例如在创建产品销售群组视图以查看逐月业绩时。像 sql 中的许多东西一样，这可以通过使用 CASE 语句来实现。
select
product_id,
sum(case when month = 'jan' then amount else 0 end) as amount_jan,
sum(case when month = 'feb' then amount else 0 end) as amount_feb,
sum(case when month = 'mar' then amount else 0 end) as amount_mar
from product_sales
group by 1
order by product_id
但是，这种方法要求我们为我们想要透视的每个月值重复 CASE 逻辑，随着月数的增加，这可能会变得很长(想象一下，如果我们想要透视 2 年的值)。值得庆幸的是，在 Snowflake 中这是不必要的，因为我们有 pivot 子句可用，但是要使用该子句，我们首先必须将表简化为只有行列(仍然是行)、pivot 列(不同的值分布在多个列中)和值列(填充单元格值)。
这里，透视列在 AS 子句中有别名，以便使列名更具信息性，并删除列名中出现的引号，以便将来更容易引用它们。
4.尝试 _ 到 _ 日期
try_to_date 子句使我们能够尝试多种类型的日期转换而不抛出错误。如果日期存储为字符串(不要这样做)或通过某种自由流动的文本框收集(也不要这样做)，这将特别有用。理论上，您处理的所有日期都应该作为日期或时间戳类型存储在数据库中，但在实践中，您可能会遇到需要将多种类型的日期字符串转换为日期的情况。这就是该子句的亮点，因为您可以应用各种日期格式而不会出现错误。
假设我们将日期存储为文本列中的14/12/2020和19 September 2020。如果我们试图将该列转换为日期，如果有任何日期不能正确转换，我们将会得到一个错误。
Date '19 September 2020' is not recognized
Date '14/12/2020' is not recognized
通过返回 null 而不是错误，try_to_date 解决了我们之前的困境，它使我们能够将列转换为多种日期格式而不会引发错误，如果没有找到有效的日期转换，则最终返回 null。我们可以用一个 coalesce 子句将多种日期格式链接起来以实现这一点。
这也处理了雪花的假设，即日期是以MM/DD/YYYY格式表示的，即使对于像 14/12/2020这样的情况，这样的日期是不可能的，因为这将意味着一个月大于 12。
5.变量引用
可能是我们今天要讨论的最强大的技术。当执行 select 语句时，雪花实际上允许我们在查询的其他地方重用逻辑。这消除了对复制/粘贴业务逻辑的需要，这是在编写业务逻辑可能变得庞大和复杂的查询时的一个常见问题。在 select 和 where 中，有时甚至在 group 或 order by 子句中重复这样的逻辑既麻烦又不方便。
下面是一个简单的例子，我们重用了month别名，而不是重复最初构建它的查询。
select
date_trunc('month', created_at) as month,
count(*) as total_transactions
from product_sales
where month = '2022-01-01'
但是，如果我们使用的引用变成隐式的，我们需要小心(有两列引用)。在下面的例子中，雪花将使用第一个/已经存在的列i.status，而不是新创建的列。
select
iff(p.status in ('open', 'active'), 'active', i.status) as status,
iff(status = 'active', true, false) as is_active
from product_sales p
为了解决这个问题，我们可以简单地给中间列取不同的别名。这有助于减少成本和执行时间，因为我们只需要构建一次业务逻辑！
这并不总是我最喜欢的结果，因为我遇到过在引用它之前应用一些转换来实现结果的情况。正如我们之前看到的，这遇到了我们在status中遇到的重复别名的问题，所以如果有人设法找到了一个很酷的解决方案，请告诉我！
最后的想法
雪花是一个强大的数据库解决方案，它还具有一些非常有用的查询选项。我们看了一些 help，它们可以帮助我们绕过一些常见的查询障碍，减少相同输出所需的行数，最重要的是，改进语法和可读性，并减少成本和执行时间。
如果您喜欢这篇文章，您可以在我的上找到更多文章，并在我的个人资料上关注我！
成为更好的数据科学家的 5 个软件工程实践
原文：https://towardsdatascience.com/5-software-engineering-practices-to-become-a-better-data-scientist-61e6484ad8f5
数据科学家应该向软件工程师学习的最佳实践。
穆罕默德·拉赫马尼在 Unsplash 上的照片
让我们面对现实吧，作为数据科学家，我们经常编写代码，但有时并不关注诸如编写高效代码、代码结构和可维护性之类的事情。
但是我们应该！
数据科学家通常是项目的一部分，包括与其他人合作和共享代码。这就是为什么我们需要编写健壮的代码，并遵循软件工程师的一些好的实践。
数据科学家和软件工程师有一些共同点，在本文中，我将向您展示 5 个软件工程最佳实践，您应该借鉴它们成为更好的数据科学家。
编写干净的代码
编写干净的代码意味着编写可读、简单、简洁的代码。干净的代码是易于维护的脚本的基础。
相信我，通过编写易于理解的代码，你会让你的队友生活得更轻松。简单比复杂好，所以不要写复杂的代码，即使你可能也很难理解。
下面是一个编写干净代码的例子:
以下是上一个示例中遵循的良好实践:
- 使用有意义的变量名:使你的变量名具有解释性和描述性。名为
end的变量不如end_time.有解释力，布尔变量single不如is_single有描述力。 - 不要在变量名中使用没人能理解的缩写(例如
t和c)。 - 不要写太长没人会记得的变量名。
- 正确使用缩进和空白:这里有很多约定，比如使用四个空格缩进，或者用一个空行分隔各个部分。他们可能很难记住；幸运的是，像 Pycharm 这样的 ide 会建议您遵循这样的约定，并展示如何去做。
- 命名对象时尽可能遵循惯例(例如，如何使用大小写惯例，何时使用下划线等)
编写模块化代码
模块化代码意味着编写可以分成功能和模块的代码。
一个可以分解成模块的程序在调试时很有帮助。随着程序规模的增长，将代码分成模块是一个很好的做法。这让您可以很容易地查明错误的来源。
此外，模块化代码将帮助您避免重复，并编写高效和可重用的代码。
以下是开始编写模块化代码的一些建议:
-
不要重复:如果你使用相同的函数/方法来完成一个任务，考虑创建一个函数或 for 循环。
-
尽量减少函数、类和模块的数量
-
单一责任原则:一个类/函数应该只有一个责任。如果它们做不止一件事，考虑将它们重构为两个或更多的类/函数。
-
使用模块
优化您的代码
写有用的代码是好的，但是你知道什么更好吗？
编写运行速度快、占用内存和存储空间少的高效代码。这就是为什么您应该优化您的代码(即使它已经完成了工作)。
编写高效的代码并不容易。随着时间的推移，你会学到这种技能。也就是说，这里有一些建议可以帮助你现在就开始编写更高效的代码。
- 向量化操作:尽可能在循环中使用向量操作(Numpy)。
- 检查每个操作的运行时间:这将帮助您找到脚本中的瓶颈。
- 了解你的数据结构和哪些方法更快
让我们来看一个向量化操作如何帮助优化脚本性能的示例:
如果您运行上面的代码片段，您会看到两种解决方案得到相同的结果；然而，解决方案 1 完成这项工作需要大约 2.57 秒，而解决方案 2 只需要 0.06 秒。
虽然这个小小的调整仅仅为我们节省了 2 秒钟，但在更大的范围内，它可以在性能上产生很大的差异。
正确使用日志记录
Python 提供了一个内置的日志模块，我们可以将其用于我们的应用程序。
日志允许我们不断地查看我们的应用程序正在经历的流程，即使我们不在计算机前。这有助于我们记录运行程序时发生的事件，因此我们可以观察一段时间内的行为和错误，并更好地了解我们正在开发的应用程序。
虽然您可以用一个简单的print函数来完成所有这些，但是一旦您的应用程序超出了基本项目的范围，日志将会派上用场。例如，如果发生错误，日志可以提供深入的信息，比如程序在到达发生错误的代码行之前的状态。
以下是一些在编写日志消息时可以遵循的良好实践:
- 简洁并使用正常的大写字母
- 提供有用的信息
Bad: Failed to read the file
Better: Failed to read the file located at "..."
- 选择适当的日志记录级别:日志记录级别允许我们指定想要记录的内容。有 5 个标准日志记录级别:
来源:科里·斯查费
默认的日志记录级别是WARNING，因此默认情况下，它将捕获在WARNING级别或更高级别(WARNING、ERROR和CRITICAL)的任何内容，而忽略下面的级别(DEBUG和INFO)。
也就是说，您可以通过编辑默认配置来更改日志记录级别。
假设我们想要将默认的日志记录级别更改为DEBUG:
**import** logginglogging.**basicConfig**(**level**=logging.DEBUG)
测试您的代码
如今，雇主正在寻找能够为行业环境编写代码的数据科学家；这就是为什么你需要测试你的代码。
在数据科学过程中可能会出现许多问题，这些问题不像导致程序崩溃的错误那样容易检测到。您的代码可能运行得很好，而您没有意识到一些值编码不正确。这就是为什么测试您的代码是一个好的实践，以避免意外的结果，并对最终的输出有信心。
在 Python 中有不同的方法来测试你的代码。您可以使用控制台来测试您的代码，但是您必须手动完成大部分工作，这在运行大量单元测试时并不理想。
为了在 Python 中快速开始测试，我们可以使用 Pytest。这是一个测试框架，使得构建简单且可伸缩的测试变得容易。使用 Pytest，我们可以从简单的单元测试到复杂的功能测试。此外，我们将能够运行所有的单元测试，并查看哪些测试失败了，哪些成功了(相反，控制台在每次失败时都会停止)
下面是我用 Pytest 做的一个简单测试:
Pytest
要安装它，请遵循其文档中的说明。
好处:重构你的代码
时不时地，你必须重构你的代码。代码重构是在不改变外部行为的情况下重构现有计算机代码的过程。这样做的目的是改进代码的设计、结构和实现，同时保留其功能。
您的代码可能已经工作了，但总有改进的空间，所以再次检查您的脚本以清理您的代码，使其模块化和高效。
你还可以从软件工程师那里学到其他好的实践，比如使用版本控制和记录你的代码。去吧，也试试看。
https://medium.com/geekculture/is-a-degree-in-data-science-worth-it-1ca8c3bdb00c
与 7k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)
如果你喜欢阅读这样的故事，并想支持我成为一名作家，可以考虑报名成为一名媒体成员。每月 5 美元，让您可以无限制地访问数以千计的 Python 指南和数据科学文章。如果你使用我的链接注册，我会赚一小笔佣金，不需要你额外付费。
https://frank-andrade.medium.com/membership
Python 中的 5 种排序算法可视化
原文：https://towardsdatascience.com/5-sorting-algorithms-in-python-c7ece9df5dd6
使用 Python 实现选择、冒泡、插入、合并和快速排序算法
介绍
排序数组在编程中很常见，以帮助理解数据并执行查找。因此，与分类大量信息相关的速度对于功能设计和优化运行时间至关重要。存在许多算法来完成排序对象的任务。
这篇文章展示了五种流行的排序算法的实现和可视化。代码用 Python，图形界面用 Tkinter 构建。
这个项目的灵感来自于提莫·宾曼在 T21 的视频。
乔恩·泰森在 Unsplash 上的照片
涵盖的算法包括:
- 选择排序
- 冒泡排序
- 插入排序
- 合并排序
- 快速排序
阵列可视化
图 1 是无序整数数据的示例数组。
图 1 —无序的整数数据(作者图片)
一旦一个类提供了一些重载的比较 运算符的实现，那么就是可排序的。在 Python 中，它们是:
__lt__:小于__gt__:大于__eq__:等于
例如，Gist 1 中的代码显示了一个重载的小于的方法。
要点 1 —重载小于运算符
可以使用条来表示数字数据。 iᵗʰ条的高度等于 iᵗʰ数组元素的值。每个杆都有一个等宽。因此，图 2 给出了将图 1 中的数值列表描绘为一组条。
图 2 —以列高表示的整数数据值(图片由作者提供)
按或 升序排序数值数据需要相应地重新排列数值。因此，要实现操纵数据的每个算法的动画，需要在交换单个元素后刷新条形图。**
Gist 2 展示了 Python 代码来交换列表中的两个元素。**
要点 2 —交换列表中的元素
渲染需要两个类，一个是Canvas，另一个是Bar。查看带有注释代码的 GitHub 库以获得完整的用户界面。**
Gist 3 为Canvas类中的渲染更新提供了必要的代码。当bar index改变时，如上所述，setter触发主画布上的update_bar功能。一旦更新被触发，数组项交换位置。**
要点 3 —当条索引改变时，触发主画布上的渲染更新
算法
选择排序
选择排序是一种就地排序算法，意味着排序后的 项使用与原始元素相同的存储。**
要点 4 展示了选择排序 Python 实现，详细的注释*一步步解释了技术。***
外部循环遍历未排序数组的长度，而内部循环在数据集的剩余部分中搜索最小值。然后发生一次交换，用min_index项替换 iᵗʰ 元素。
要点 Python 中的选择排序算法
选择排序方法一般有以下几种:
- 时间复杂度 = O(n ) 。从两个嵌套的 for 循环中可以明显看出 n 次迭代。
- 空间复杂度 = O(1) 。如上所述，排序就地进行；因此，内存使用不依赖于处理数据。
图 3 显示了运行中的算法。
图 3 —选择排序(按作者排序的图片)
冒泡排序
冒泡或下沉排序反复遍历列表，比较相邻元素。根据分拣条件，物品被交换。**
Gist 4 展示了选择排序 Python 实现，详细的注释*一步步解释了技术。***
gist 4—Python 中的冒泡排序算法
冒泡排序有一个最坏情况和平均值😗***
- 时间复杂度 = O(n ) 。**内循环至少运行 n 次。因此，整个操作至少需要 n 次。****
- 空间复杂度 = O(1) 。N 没有额外的内存被利用，因为项目的交换发生在原始数组上。
当程序执行时，较大的值冒泡到列表的顶部，如图 4 所示。**
图 4 —冒泡排序(作者图片)
插入排序
插入排序构建最终数组一次一项。使用 Gist 5 中提供的代码对未排序的对象数组执行该方法。**
在外循环上遇到的每个对象被放在当前最接近的最小和最大元素之间。********
要点 Python 中的插入排序
插入排序有一个最坏的情况:
- 时间复杂度 = O(n ) 。循环的外运行大约 n 次，而循环的内运行大约相同的次数。****
- 空间复杂度 = O(1) 。操作发生在原始数组上。因此，不需要额外的内存需求。
图 5 展示了插入排序的实际应用。
图 5 —插入排序(按作者排序的图片)
合并排序
合并排序是一种分治排序算法。因此，问题将分解成更小的类似子问题，直到一个基础案例被解决。****
拆分未排序的数组，直到获得单个元素的基本情况。然后，在临时 数组之间进行比较，沿着递归堆栈向上移动。****
要点 Python 中的合并排序
合并排序有一个:
- 时间复杂度= O(n*log(n)) 。分治排序算法具有这种时间复杂度。⁴这种复杂性是最坏的情况。
- 空间复杂度= O(n) ，表明内存分配的增长不会快于一个常数 乘以数据集的大小，即 kN*
图 6 —合并排序(按作者排序的图片)
快速排序
Quicksort 比它的主要竞争对手 merge sort 和 heapsort 快两到三倍。它通常是递归实现的，如 Gist 6 所示。
Pivot 值是快速排序算法的核心。本质上，枢轴是在排序数组中它们的正确索引处的值。定位枢轴意味着左边的对象总是较少，而右边的项目比枢轴多。**
要点 Python 中的快速排序
递归地 划分数组，选择中枢点并将它们分配到正确的位置给出最终排序的数组。
快速排序有一个平均值:
- 时间复杂度 = **O(nlog(n)) 。像归并排序一样，这种表示法是由分而治之或快速排序决定的。一个最坏的情况是 O( n )。但是，这仅在数组元素正确升序或降序时发生。*****
图 7 显示了快速排序动画。
图 7 —快速排序(作者图片)
结论
优化排序在软件开发中至关重要。具体算法的时间复杂度会根据项目的初始 顺序而不同。然而，假设最坏的情况*是最合适的。*******
还有许多其他技术没有涉及。一些这样的例子包括堆、基数和心爱的 bogo 排序。
本文介绍了五种标准排序算法的 Python 代码和可视化。理解这些机制对于计算机科学的学生来说是很有价值的，因为其中一些程序经常出现在的编码面试中。********
如果你对 Python、工程学和数据科学感兴趣，可以看看我的其他文章。
***https://medium.com/codex/python-project-idea-graph-traversal-and-pathfinding-algorithm-visualisations-99595c414293 https://medium.com/@andrewdaviesul/membership
参考
[1] 原地排序 —美国国家标准技术研究院
【2】快速排序时间复杂度—Java point
【3】空间复杂度是什么意思？—stack overflow
【4】了解你的复杂性！ —大 O-备忘单***
偏见会影响你的机器学习模型的 5 种偷偷摸摸的方式
原文：https://towardsdatascience.com/5-sources-of-bias-in-ai-ml-729acbec3215
发现你的模型中隐藏的偏见并修正它们
由 Unsplash 上的真空背景拍摄
我们现在应该使用更多的人工智能解决方案。但是有这个偏见问题要考虑！
我们已经看到人工智能模型对代表性不足的群体表现不同。近年来，这些问题引起了激烈的辩论。在寻找产生偏见的原因时，我们发现，除了人类训练员的意图之外，还有更多方式可以导致偏见。
然而，当涉及到其他人的生活和工作时，造物主的清白是不可原谅的。顾客的反对、公众舆论和诽谤可能会损害你的声誉，而且可能很难恢复。
因此，理解人工智能偏见至关重要。你不能管理你不懂的东西。
这里有五种情况，偏见可能会潜入你的模型。
改变旧型号的用途是有用的，但也是危险的。
可重用性是开发人员和组织的首要任务。机器学习模型的好处甚至更高。
培训时间和资源消耗是公司采用人工智能实践的主要关注点。因此，重新利用旧模型或重用为不同目的构建的模型更有意义。
当然，云计算和平台即服务 (PAAS)解决方案已经彻底改变了数据科学。然而，我们训练的模型近年来也变大了。
语言模型 GPT3 有 1750 亿个参数。训练这个模型大约需要 460 万美元。嗯，那不是每个人都能负担得起的。
但是你可以花 0.0004 美元使用开放的 AI API。那更实惠。更好的是，您可以针对您的特定用例对这些模型进行微调。
然而，你不知道这些模型被训练的原始数据集。盲目重用会在应用程序中引入偏见。
现有模型的直接重用可能会引入偏差
像 Open AI 的 GPT-3 一样，你可以在很多其他地方找到预训练的模型。 Keras 文档列出了一系列此类车型。您可以抓住一个并在类似的用例上使用它。
例如，您可以抓起 VGG16，开始对图像进行分类。但它可能会将一个人标记为动物，因为模型没有看到足够多具有某些特征(例如，肤色)的人的例子。
在不同的环境中使用它可能会产生偏见，即使这是你自己的模型。例如，你用美国输入训练的聊天机器人可能在澳大利亚用户身上表现更差。
因此，最好不要在不同的上下文中重用模型，除非你 100%确定它的所有后果。必要的时候，如果你能让人参与其中，就去做。在预测开始产生影响之前，你可以让所有的预测或者可信度较低的预测得到人类的验证。
当然，并不是所有的应用程序都有人参与。如果是这样，使用迁移学习技术或集成方法更新模型是明智的。
使用迁移学习来更新模型，并为其提供上下文信息。
迁移学习是 ML 工程师重用现有模型的一种普遍做法。你可以在深度神经网络(DNN)上使用这种技术。
本质上，如果你有一个识别图像中的狗的模型，转移学习就会训练它识别猫。毕竟，猫和狗有很多相似之处——四条腿、耳朵、尾巴等等。
您可以向 DNN 添加新图层，也可以解冻最后一个图层。然后用您的特定领域示例训练模型。
迁移学习是一种节省成本和时间的技术，可以产生更好的结果。在你将它们应用到新的环境之前，先在你的模型上使用它将会减少偏见的机会。
你可以在我之前的文章中读到更多。
使用集合来移除模型中不必要的偏差。
集合意味着一组模型。如果已经有了预测猫的模型，可以附加一个额外的模型，增加一个新的职责——找狗。
如果您使用的是为类似目的而训练的模型，则可以使用另一个模型并用新数据准备它，以最大限度地减少偏差。
当你的模型从相互作用中学习时，偏见就产生了
当你的模型向你的用户学习时，你应该更加小心。
微软的 Twitter 聊天机器人 Tay 就是一个很好的案例研究。Tay 一直在从 Twitter 与其他用户的对话中学习。但是这个机器人仅仅在几个小时后就被关闭了，因为 Tay 从其他用户那里选择了攻击性的语言，并开始像他们一样说话。
如果你的模型是从用户那里学习的，它就暴露在偏见的风险中。在主动学习中避免偏见仍处于研究阶段，我们还没有可靠的解决方法。因此，当你选择这个的时候，你应该更加小心。
如果学习是分批进行的，你就可以控制它。在将新数据输入模型之前，您可以检查它们是否存在任何已知的偏差。此外，您可以在发布新版本的模型之前进行更多的检查。
拥有一个模型注册中心是一个很好的实践。模型注册中心可以帮助您试验几种模型来解决同一个问题。当您在生产环境中发现一个模型有问题时，您可以很容易地切换到一个旧的模型，并将影响最小化。
但是，在主动学习模型中，比如进化的强化算法，你把控制权留给了机器。
合成数据的使用可能会导致偏差。
有时，合成或人工创建的数据被用于训练机器学习。虽然听起来可能违反直觉，但合成数据有很多用处。
当收集新数据很困难或成本很高时，工程师使用合成数据来训练 ML 模型。此外，当匿名很重要时，合成数据是有益的。
通常，合成数据生成会对变量的潜在概率分布进行建模，并从中提取新样本。
随着合成数据对分布进行概化，它失去了数据集的原始上下文。因此，在偏见产生后果之前发现任何偏见的机会很小。
这也是近年来大多数图像生成算法备受争议的原因之一。使用图像增强来训练神经网络是一种普遍的做法。避免过度合身是必要的。
除了隐藏细节，合成数据增强还可以放大差异。有了更多的人工数据，你现在有更多的数据来代表你的主导类。
偏见可能隐藏在抽象的维度中。
像合成数据一样，PCA 等降维技术也掩埋了上下文，产生了抽象变量。这并不意味着我们应该避免这样的做法。但是要注意风险。
它们使得在早期阶段很难理解输入变量和检测偏差。追溯抽象变量偏差的来源将是一个挑战。
想象一个场景，你建立一个模型来预测信用评分。您的输入数据集包含收入变量。PCA 之后，您有 PC1 和 PC2，…而不是标签。
也许你会抽样调查低收入人群最有可能违约的人群。但是你永远不会知道这是一个抽样问题，因为变量是抽象的。
无法解释的模型导致无法解释的偏见。
偏见并不总是有偏见的数据集的产物。它还取决于模型从数据集中选择要素的方式。
深度神经网络(DNN)最大的前景是自动特征选择。它非常有益，但也有缺点。你对你的 DNN 型号的特征选择没有多少控制力。
从 A 市开车到 B 市，只要安全准时到达 B 市，可能不太在乎路径。但在机器学习中，这很重要！
可解释的人工智能(XAI)近年来受到了很多关注，因为对人工智能模型对代表性不足群体的预测提出了的担忧。
话虽如此，我们不能忽视和回避 DNN 的好处。合理的基准是人的水平的表现。确保人类也能以同样的方式表演。当预测置信度较低时，过滤它们并尝试手动进行。
最后的想法
将人工智能偏见的影响降至最低是数据科学界面临的一项挑战。
至此，世界已经清楚地明白了 AI 的好处，想要前进。然而，我们已经看到了机器预测的几个问题，我们知道还有更多要学习的。
算法天生没有偏见。但是他们从中学习的例子可以改变他们的行为。在这篇文章中，我们讨论了偏见进入你的模型的一些间接方式。
感谢阅读，朋友！在LinkedInTwitterMedium上跟我打招呼。
还不是中等会员？请使用此链接 成为会员 因为，在没有额外费用的情况下，我赚取了一点佣金。
作为初学者，你需要知道的 5 个 SQL 命令
原文：https://towardsdatascience.com/5-sql-commands-you-need-to-know-as-a-beginner-starting-out-cdc11cc2d9c
如果你想精通 SQL，你需要知道的 5 个基本命令
来自 Unsplash 的照片由 Lala Azizli 拍摄
SQL 是一种强大的语言，可用于各种数据分析任务。
它也非常适合想从事编程的人，因为它与许多其他编程语言非常相似。
在本文中，我们将分解您需要知道的 5 个 SQL 命令，并提供示例，这样到最后，您将对 SQL 有足够的了解，可以开始在自己的项目中使用它了！
1.挑选
如果使用 SQL，您需要知道的第一个命令是 SELECT。这是 SQL 中最基本的命令，用于从表中获取数据。
SELECT 的一些用途包括:
- 从表中选择所有数据
- 从表中选择特定的列
- 基于特定标准选择数据(使用 WHERE)
示例:
从表名中选择*
这将为您提供 tablename 表中的所有数据。您也可以通过在 select:
从表名中选择 id，名称
这将为您提供 tablename 表中的 id 和 name 列。
选择不同
如果只想选择唯一值，可以使用 SELECT DISTINCT。此命令从结果中删除重复值:
从表名中选择不同的 id
这将为您提供 tablename 表中所有惟一 id 的列表。
选择计数
SELECT COUNT 命令返回表中的行数:
SELECT COUNT(*) FROM tablename
这将返回 tablename 表中的总行数。您还可以对特定的列进行计数
2.在哪里
这里是 SQL 中另一个非常常见的命令。它用于过滤出现在 SELECT 语句中的数据:
WHERE 的一些用法包括:
- 按特定列过滤数据
- 按特定值过滤数据
- 按日期范围过滤数据
示例:
SELECT * FROM tablename，其中 id = 100
这将只返回 tablename 表中 id 等于 100 的行。可以使用 AND 或 or 指定多个条件:
SELECT * FROM tablename WHERE(id = 100)OR(name = ' John ')
这将返回 tablename 表中 id=100 或 name='John '的所有行。
SELECT * FROM tablename，其中 id 介于 EN 100 和 200 之间
这将返回 tablename 表中 id 在 100 到 200 之间的所有行。
SELECT * FROM 不在(100，200)中的表名
这将返回 tablename 表中 id 不等于 100 或 200 的所有行。
3.ORDERBY
ORDERBY 也常用在 SQL 中。它用于对 SELECT 语句的结果进行排序。这些结果可以按降序或升序排序。
ORDERBY 的一些用法包括:
- 按升序对结果排序:SELECT * FROM tablename ORDERBY id
- 按降序对结果排序:SELECT * FROM tablename order by id desc
- 按字母顺序对结果排序:SELECT * FROM tablename order by name
- 按日期对结果排序:SELECT * FROM tablename order by created _ at
示例:
SELECT * FROM tablename ORDER BY name
这将返回 tablenname 表中的所有行，并按它们的名称排序。如果要使用多列进行排序，请在逗号分隔的列表中指定它们:
SELECT * FROM tablename 其中 id > 100 ORDER BY age DESC，name ASC
这将给出 ID 大于 100 的所有行，并首先按年龄降序排列这些值，然后按姓名升序排列。
4.分组依据
GROUPBY 是 SQL 中的一条语句，用于按某一列对 SELECT 语句中的数据进行分组。
GROUPBY 的一些用途包括:
- 汇总数据
- 查找列的最大值或最小值
- 获取列的平均值、中值或标准差
示例:
从按 id 分组的表名中选择 id，name，SUM(age)作为“年龄”
这将返回一个包含三列的表:ID、姓名和年龄。Age 列将包含 tablename 表中按 ID 分组的所有年龄值的总和。
从按 id 分组的表名中选择 max(age)作为“最老的人”
这将返回一个包含一列的表:最老的人。“年龄最大的人”列将具有 tablename 表中按 ID 分组的最大年龄值。
从按 id 分组的表名中选择 avg(age)作为“平均年龄”
这将返回一个只有一列的表:平均年龄。“平均年龄”列将包含 tablename 表中所有行的平均年龄值，按 ID 分组。
5.喜欢
LIKE 运算符用于匹配字符串中的模式。百分号(%)用作通配符，这意味着它可以代表任意数量的字符。
LIKE 的一些用法包括:
- 匹配列中的模式
- 在列中查找特定值
示例:
SELECT id，name FROM tablename WHERE name LIKE ' A % '
这将返回第一列(name)至少包含一次字母 A 的所有行。
SELECT id，name FROM tablename WHERE name LIKE ' % end '
这将返回包含名为“end”的列的所有行。
SELECT * FROM tablename，其中名称如“John%”
这将返回 tablename 表中的所有行，其中 name 列包含后跟任意数量字符(%)的字符串 John。可以在字符串的开头、结尾或任何地方使用%。
开始掌握 SQL
我们在这篇博文中讨论的 SQL 命令是强大的工具，可以帮助您充分利用数据。
使用这些命令来帮助您分析和优化数据，您将很快掌握 SQL。
与 2k+人一起加入我的电子邮件列表，免费获得“完整的 Python 数据科学备忘手册”
每个分析工程师都需要知道的 5 个 SQL 函数
原文：https://towardsdatascience.com/5-sql-functions-every-analytics-engineer-needs-to-know-e356b26495c2
从基础到窗口功能，你会一直用到它们
蒂姆·莫斯霍尔德在 Unsplash 上的照片
SQL 无疑是每个分析工程师都需要知道的最重要的技能。这是基础性的，也是数据从业者经常忽略的顶级技能。因为它没什么“新的”或“新奇的”，所以被搁置了。但是，为了编写高质量的数据模型，您需要能够编写干净、简洁的 SQL 代码。
SQL 是数据建模的核心。虽然这不是数据建模的唯一方面，但它占了数据建模的很大一部分。虽然您也可以在不了解 SQL 的情况下编写数据模型，例如通过使用拖放模型来编写 SQL 函数，但 SQL 仍然是大多数分析工程师用来构建数据模型的工具。
编写清晰、简洁的 SQL 代码可以为您的数据模型带来很多好处。首先，它可以帮助您的模型运行得更快，当您的查询以最佳方式编写时，使用更少的计算能力。其次，它可以帮助您拼凑复杂的数据集，计算关键业务指标。第三，写得好的话，代码可以随着你的业务扩展，减少你的技术债务。
为什么分析工程师需要练习 SQL
虽然您可能认为只了解 SQL 基础知识会让您走得更远，但是您可以了解基础知识，仍然可以编写糟糕的代码。分析工程师需要不断实践新功能，重写查询以更好地优化它们。数据模型应该总是针对可伸缩性、运行时和效率进行优化。为了专注这三件事，你需要学会写干代码。这意味着您必须提前考虑，并以可伸缩的方式编写 SQL 查询。在找到理想的解决方案之前，你可能会遇到一些死胡同。
您的 SQL 代码也需要考虑可读性。同样，这需要练习。你需要让你自己接受团队成员的代码审查，以便学会编写每个人都能理解的代码。对你来说容易读懂的，对别人来说未必有意义。每次你写一段代码时，添加注释并做出修改，这样别人就能确切地知道代码在做什么。可读性总是胜过复杂性。
最后，作为分析工程师，我们需要计算核心指标并拼凑复杂的数据集。企业依靠我们来解决这些问题，并提供他们可以依赖的数据集。当我第一次想成为一名分析工程师时，我在 Leetcode 上练习了大量现实世界的商业问题。这帮助我学习了 SQL 函数，比如窗口函数，帮助我以我需要的方式解决问题。如果您习惯于编写基本的连接和聚合，练习更复杂的业务相关问题可以扩展其他类型函数的使用。
你需要知道的 5 个 SQL 函数
作为一名分析工程师，我使用两种类型的 SQL 函数，一种是我可以一直依赖的，另一种是我发现在解决复杂问题时非常有用的。你很自然地会比其他人更频繁地使用一些功能，但是当一个特定的用例需要它时，你总是很高兴你知道的那个独特的。让我们来看看我的前 5 名。
伯爵()
验证是数据建模的一大部分。无论您是重写一个已经存在的数据模型，还是完全从头开始编写一个数据模型，您都需要在编写之后对其进行验证。这涉及到一些最佳实践，比如将模型与其基本数据表进行比较，以及计算具有某些特征的行数。执行此操作时，COUNT()函数很方便。它允许您对模型和基表中的列进行分组，并对它们的值进行计数，以便于比较。
我经常用 COUNT()来统计某月或某年生成的行数。这确保了模型在所有时刻都正确运行，而不仅仅是在一个孤立的时间段内。
假设我需要验证一个 order_details 模型。我想将模型中每年的订单数与基础模型中的订单数进行比较。如果计数几乎相同，那么我知道我模型写的是正确的。如果没有，我可能需要更改一些逻辑，以使结果匹配。
我的查询应该是这样的:
SELECT
YEAR(ordered_at) AS year,
COUNT(order_id)
FROM order_details
GROUP BY YEAR(ordered_at)
根据需要验证的列，也可以用另一个值替换 year(ordered_at)。
COUNT()函数也非常有助于您更好地理解数据集。它可以告诉你你的数据是如何分布的，在某一列中哪些值是最受欢迎的。这就是为什么像 COUNT()这样的集合函数是初学者课程中最先教给你的函数之一！
ROW_NUMBER()
现在，这个可能会让你吃惊。许多人说学习窗口函数不是必须的，但我不敢苟同。虽然它们不用于日常工作，但当你遇到复杂的问题时，它们会派上用场。很多时候这个问题不使用窗口函数是解决不了的。或者，查询执行起来极其缓慢，难以理解。
ROW_NUMBER()根据指定的分区和顺序排列值。您可以指定要分区的内容或值的分组依据，以及这些组中值的排序顺序。
例如，如果您按学生的数学成绩对他们进行排名，但按性别对他们进行分类，则查询如下所示:
SELECT
first_name,
ROW_NUMBER() OVER(PARTITION BY gender ORDER BY score DESC) AS rank_by_gender
FROM student_scores
我们按性别将他们分开，然后从大到小排序。您将看到两个相同的“rank_by_gender ”,因为为两种性别生成了相同的值。
我曾经在拼凑 web 会话序列、确定用户最近的订单以及发现订单从哪个仓库发出时使用过这个函数。当消除值略有不同的重复主键时，这很方便，这是连接数据集时的最佳实践。
您还可以使用 RANK()函数，它的作用类似于“排列”值。不过我发现 ROW_NUMBER()更直观，更容易理解。
DATEDIFF()
有许多业务指标要求您计算时间段，有时以天为单位，有时以周为单位，甚至可能以月为单位。DATEDIFF()以您指定的单位计算两个日期或时间戳之间的时间。这使得分析工程师不必将时间段转换成所需的单位。DATEDIFF()简单地返回您正在寻找的任何单位。
您可以使用的一些值如下:
- 年
- 四分之一
- 工作日
- 分钟
我个人发现季度在计算季度指标时非常有用。DATDIFF()将返回您传递的两个日期值之间的季度数，这使得区分业务将会增长的时间段变得非常容易。我还发现 DATEDIFF()有助于计算用户的 web 会话时间。这通常包括将网站上的不同事件拼凑在一起，并计算第一个和最后一个事件之间的时间。
下面是我如何使用它来计算用户会话持续时间的示例:
SELECT
user_id,
device,
session_started_at,
session_ended_at,
DATEDIFF(second, session_started_at, session_ended_at) AS session_duration
FROM user_sessions
现在，您可以计算用户会话开始和结束之间的秒数差，而不必从一个单位转换到另一个单位。
剧组()
虽然 CAST()是一个相当简单的 SQL 函数，但它是我几乎每天都要使用的函数。在编写基本模型时，这是一个关键的功能。在基本模型中，您希望在将日期和数据类型用于组合来自多个不同来源的数据的数据模型之前，对它们进行标准化。CAST()确保所有的日期和时间戳都是同一类型。
当我第一次开始编写数据模型时，我假设所有的时间戳函数都是相同的。当 web 会话记录每天都在减少时，我很快意识到情况并非如此。原来我写的一个模型是比较两种不同类型的时间戳，排除了关键会话。幸运的是，我能够发现这个问题，并将我的所有时间戳列转换为相同的数据类型——确切地说是 timestamp_ntz。
使用 CAST()的基本模型通常如下所示:
SELECT
ad_id,
ad_name,
platform,
CAST(date_created AS date) AS date_created,
CAST(created_at AS timestamp_ntz) AS created_at
FROM ads
而且，如果您喜欢 SQL 快捷方式，这也会将值转换为您指定的数据类型:
created_at::timestamp_ntz
CAST()函数也可用于其他数据类型，如下所示:
- 小数
- 二进制的
- （同 Internationalorganizations）国际组织
- 茶
虽然您不一定要在基本模型中的每一列上使用 CAST()函数，但是一定要将它应用于经常涉及比较或连接的列。这些是真正重要的栏目。您不希望在连接或筛选时得到不正确的结果，因为数据类型的比较方式很奇怪。
SUM()
SUM()是另一个经典的聚合函数。由于它的实用性，尤其是在商业中，它是最常用的方法之一。通常使用 SUM()来计算支出、收入和激活次数。然而，它也有助于分析工程师验证数据模型。
类似于 COUNT()，它可用于比较模型和基表之间的值。例如，如果您为公司收入创建了一个数据模型，您希望确保它等于可以在基本模型中计算的利润和损失。如果您计算出来自一个基本模型的钱比模型预测的多，您可能需要仔细检查逻辑。
SUM()在比较数值列的实际值而不仅仅是行数时非常方便。这是一种不同类型的验证，由一个同样有用的人来验证。
让我们回到 order_details 模型。我想计算所有订单中售出的产品数量。我将查找某个月内所下订单的产品数量总和。然后，我将这个数字与 orders 基表的相同查询进行比较。
SELECT
SUM(product_quantity)
FROM order_details
WHERE ‘2021–01–01 <= order_date <= ‘2021–01–31’
现在，即使每个表中的 COUNT()行匹配，我们也可以检查特定的数量是否匹配。
结论
强大的 SQL 是每个分析工程师为了成功都需要学习的基本技能。为了提高数据建模技能，这是您需要不断练习的事情之一。尽管它可能被视为一项“基本”技能，但在你的职业生涯中不断提高它仍然是必不可少的。没有人会在没有练习的情况下变得更好。我强烈建议每天在 Leetcode 上做一到两个 SQL 问题，帮助你优化查询，学习解决业务问题的新方法。
学习更好的 SQL 实践只会有助于优化您的数据模型，使它们更快、更可读。改进的数据模型将渗透到数据团队工作的其他方面，在公司内部培养更好的数据文化。
训练和提高 SQl 技能的一种方法是使用类似于 Y42 这样的工具，它允许你使用无代码、低代码或 SQL 查询来构建模型。通过这种方式，您可以逐渐地从不用编写一行代码，到使用基本的 SQL 查询，再到完全用 SQL 编写您的模型。您可以使用您最熟悉的任何函数来混合、匹配和构建您的模型，但是您也可以直接进入 SQL 模型，并将我刚才与您分享的所有函数付诸实践。
看看我的第一本电子书，分析工程基础知识，一本全方位的分析工程入门指南。
使用 Apache Airflow 构建高效数据管道的 5 个步骤
原文：https://towardsdatascience.com/5-steps-to-build-efficient-data-pipelines-with-apache-airflow-d0b42576b530
发现优化大数据管道的最佳实践
由陈乐德在 Unsplash 上拍摄的照片
阿帕奇气流
Airflow 是一个开源的工作流程编排工具。尽管广泛用于构建数据管道，但 airflow 可用于管理各种工作流。
简单地说，如果我们要构建一个可伸缩的系统，以有序的方式执行一组需要与不同组件交互的任务，我们就可以用气流来管理这样的工作流。我们使用 Dag(有向无环图)来执行这样的操作/任务。
在这篇博客中，我们将揭示一些有效构建工作流的实践。
开发经济高效的数据管道
作为一名数据工程师，在处理项目时主要关心的问题之一是处理万亿字节数据所需的数据管道的效率。尽管解决方案通常很简单，但可能会出现管道架构、基础设施或底层数据模型阻碍管道高效运行的情况，从而导致解决方案过时。
让我们来看看一些策略，我们可以使用这些策略来处理海量数据的问题，而不会影响管道的有效性。
1.数据建模
照片由 Unsplash 上的 Shubham Dhage 拍摄
构建数据湖或数据平台并不等同于将数据转储到现代堆栈中。相反，它通常要求工程师识别支持有效使用数据的模型。建模通常包括数据的标准化和规范化，以消除重复，执行数据标准，并通过根据业务领域对数据进行分组来建立新的实体。合适的数据模型有三个好处:
- 它通过减少基础设施上不必要的负载来增加数据平台的能力。
- 它简化了组织的数据资产管理，支持高效的数据分析和其他前端应用程序。
- 数据通常基于业务领域进行分组，因此它有助于数据治理和编目。
虽然数据建模不是 Apache Airflow 独有的，但它在构建有效的数据管道中起着至关重要的作用。
2.选择最佳操作员
类似于许多领域，有几种方法可以解决数据工程中的任何问题。气流通过提供一系列操作员提供了类似的灵活性。选择正确的运营商可以提高管道性能，并大大减少开发时间。
操作符的选择会因用例而异。
选择合适的运营商通常取决于以下因素:
- 数据源和目的地
- 操作员灵活性
- 操作员效率
- 成本费用
a.数据源和目标
在开发数据管道时，数据通常要经过几个阶段。在数据湖的情况下，数据可能必须经过着陆区和转换区，然后才能进入管理区。
因此，可能会出现这样的情况:气流操作员需要将数据从 SQL 数据库导出到我们数据湖中的 s3 存储桶，或者从 S3 存储桶中读取文件，并将它们加载到数据库或基于我们数据平台架构的另一个 S3 存储桶中。
每个运营商的来源和目的地可以缩小搜索空间。例如，如果操作符将数据从 SQL 服务器导出到 S3 存储桶，尽管可以使用 PythonOperator 或 BashOperator 来完成，但由于其简单性和性能， SqlToS3Operator 将是一个不错的选择。
此外，如果 Airflow 集群位于 AWS 云上，并且源是一个 RDS 实例，我们可以使用上述操作符获得更好的性能，因为数据不会离开 AWS 环境，而是以闪电般的速度在 AWS 基础架构上通过服务流动。
b.操作员灵活性
尽管 Airflow 的优点是有几个提供商支持的钩子和操作符，但是由于任务的复杂性，使用提供商的现成操作符是不可行的。在这种情况下，我们可以使用 PythonOperator 或 BashOperator ，这给了我们足够的灵活性来产生想要的结果。
PythonOperator 和 BashOperator 都有各自的优点和缺点。一方面，PythonOperator 易于理解和实现，使得开发过程变得简单，从而减少了开发时的开销。另一方面，尽管 BashOperator 因不够直观而臭名昭著，但它通过更好的性能弥补了这一点。
c .操作员效率
尽管有几个操作员可以完成期望的 ETL/ELT 工作，但并不是所有的都是最佳的。一些运营商比其他运营商表现更好。为了补充上一点 PythonOperator vs BashOperator，我们将在本节看到每个运算符的性能差异。
我们创建以下管道来评估完成一个简单导出任务所需的时间。
作者图片
我们可以从下面的代码块中看到，上面 DAG 中的操作符执行相同的任务，也就是说，它们都将 RDS (MS SQL Server)中超过 200 万条记录的表导出到 CSV 文件中。
BashOperator 使用的 bash 脚本如下:
运营商的评价如下:
- 我们可以观察到， BashOperator 用了将近 316 秒来导出 200 万条记录。
- 相反， PythonOperator 用了几乎 470 秒来执行同样的导出。
- PythonOperator 对于使用相同基础设施的相同导出，运行时几乎增加了 50%。
话虽如此，PythonOperators 也有它的好处。Python 易于学习和编码，并且在为机器学习用例开发管道时具有方便的大量库的优势。
因此，我的原则是，如果我们必须导出/导入小块数据，或者需要支持开发和灵活性的公共可用库，PythonOperator 是最佳选择。但是，如果我们需要通过综合转换进行批量装载，BashOperator 可以很好地满足我们的需求，因为它的性能很快。
d .成本费用
最后，我们需要考虑与使用操作符相关的额外成本(如果有的话)。例如，AWS 提供其数据库迁移服务运营商将数据从数据库或外部来源迁移到云平台。DMS 提供持续复制、最少的停机时间和其他功能，使数据迁移变得容易。然而，它的便利是有代价的。因此，如果价格不是问题，并且数据平台在 AWS 中，那么 DMS 就成为运营商选择的合适候选。
3.定量
在上一节中，我们研究了用于将数据加载到我们的数据平台中的几个操作符。尽管我们设法选择了有效执行任务的操作符，但是每个操作符所能达到的性能都是有限的。
在构建数据管道时，有时可以观察到，即使有最好的运营商，管道仍然相对较慢。通常情况下，管道性能不佳是因为它没有利用底层基础设施的全部潜力。此外，有时管道处理数据的时间至关重要，足以决定项目的命运。
在这种情况下，我们可以通过设计一个高效的管道来解决这个问题。
分而治之！
举例来说，如果手头的任务是导出/导入一个具有万亿字节数据的巨大数据库，而不是像前面几节中描述的那样导出整个表，那么我们可以基于批处理来导出/导入数据。
作者图片
设计批处理管道时，需要注意以下几点:
- 管道应该保持数据的完整性。应注意确保批处理逻辑不会造成重复或数据丢失。
- 尽管并行性是好的，但它只应在不中断共享同一基础设施的其他应用程序的情况下使用。可以根据 CPU 利用率、内存使用量等指标来调整并行度。
- 应该构建高效的查询来从源系统中检索批处理，因为它们会显著影响管道的性能。
4.高效的查询和脚本
数据管道的性能不仅取决于架构，即选择的操作符或任务中的并行度，还取决于适当的转换逻辑。低效的查询会增加管道的处理时间，并给底层基础设施增加不必要的负载。
当设计具有批处理的管道时，这个问题变得特别严重。本节探讨两种批量导出数据的方法，并比较它们的性能。
- 在第一种方法中，我们使用-F(第一行)和-L(最后一行)标志批量导出数据。
上述脚本的性能如下:
- 其次，我们看一种使用最优 SQL 查询执行相同任务的更有效的方式。
上述脚本的性能如下:
注意:虽然我们创建了一个单独的脚本来测试批处理性能，但是每次迭代都是独立于之前的迭代的，因此如果操作是并行的，就可以给出准确的性能估计。这两个任务都使用 BCP 和相同的基础设施，不同之处仅在于批处理逻辑。
尽管这两种方法看起来相似，但我们可以从运行时观察到，后者比前者快得多。对于包含数亿条记录的大型数据集，随着第一种方法的导出时间呈指数级增长，更好的性能变得更加明显。
首先描述的方法中时间的增加是因为如果我们有 100 个批次，每个批次有 100 万条记录，那么要通过第一种方法导出第 100 个批次，BCP 必须读取 9900 万条记录，然后才能开始导出数据。这意味着随着批次数量的增加，导出数据所需的时间也会增加。
但是，使用后一种方法，查询被优化以从 1 亿条记录中获得所需的 ID，然后读取导出所需的记录，使每次导出保持一致。
5。选择合适的基础设施
由 Unsplash 上的 drmakete 实验室拍摄的照片
数据管道的性能取决于支持它们的底层基础设施。一个设计良好的数据管道，如果基础设施不完善，结果会很糟糕，反之亦然。因此，了解并使基础设施能够构建高效的管道至关重要。
有许多方法可以实现足够的基础设施。例如，气流与 Kubernetes 等技术很好地集成在一起。由 AWS、GCP 或 Azure 等云平台支持的 Kubernetes 可以帮助充分发挥数据管道的潜力。云平台在与 Airflow 集成时变得非常强大，因为它们提供了一些功能，如根据 CPU 利用率、内存等指标自动扩展或缩减基础架构。
上述方法有助于创建强健的基础架构，原因如下:
- Kubernetes 可以帮助在硬件上扩大或缩小 pod(我们数据管道中的每个任务)。
- 此外，云平台可以通过向 Kubernetes 集群添加或删除硬件资源来扩大或缩小规模，这可能会随着数据管道中负载的增加而增加。
- 此外，这两种技术相互作用，使基础设施更加可靠。
结论
构建数据管道是多个组件的混合。这篇博客探讨了设计良好的基础设施、架构和数据建模对于构建高效管道的重要性。
参考
https://airflow.apache.org/
阅读其他数据博客
在 Linkedin 上连接:
https://www.linkedin.com/in/vachan-anand-26bb76b7/
创建数据科学黑客马拉松笔记本的 5 个步骤
原文：https://towardsdatascience.com/5-steps-to-creating-a-data-science-hackathon-notebook-1f86190a72ec
黑客马拉松
向同事/朋友介绍 Python 和数据科学的世界
作者创建的图片|使用了来自canva.com的免费内容许可元素
有很多黑客马拉松，也有很多关于如何“通过”黑客马拉松的文章。但是做一个呢？如果您想让您的员工、朋友或同事掌握数据科学/数据处理领域的技能，该怎么办？通过可操作的手段教 python？遵循以下 5 个步骤，你可以很容易地创建一个原创的黑客马拉松。
请注意，我们正在 Jupyter 笔记本上为初学者创建一个机器学习黑客马拉松。
本文将带您一步步了解如何将一个基本数据集转化为机器学习的学习体验。我们的主要目标是教授其他人清理数据的基础知识，并介绍数据科学。本文涵盖:
- 选择数据集
- 使数据集变得混乱
- 使用机器学习创建解决方案笔记本
- 为参与者创建一个框架笔记本
- 评估的可能方法
- 以上五个步骤的总结
我们在整篇文章中提到的与案例研究相关的文件都可以在这里找到:
https://github.com/Causb1A/cyf-edf-hackathon [## GitHub-caus B1 a/cyf-EDF-hackathon
github.com](https://github.com/Causb1A/cyf-edf-hackathon)
注意:在整篇文章中，我们遵循我和 Marcell Orban 为慈善黑客马拉松“Code Your Future”组织创建的上述端到端黑客马拉松案例研究。我们选择了能量这个主题。这些都是开源的，所以你可以在自己的黑客马拉松中随意使用这些文件。
选择数据集
我们需要做的第一件事是为我们的黑客马拉松选择一个数据集。这一点非常重要。
你能在哪里找到这些数据？
你可以在 Kaggle 上找到它。有大量的数据集供你在你的黑客马拉松中使用，不需要做所有的手动创建或者考虑你可以从你的工作中使用什么数据。
例如，你可以在这里找到一些好的数据集:https://www.kaggle.com/ahmettezcantekin/beginner-datasets
我要提醒的是，在使用任何数据集之前，您应该验证所使用的数据是按照与所讨论的项目一致的条款许可/发布的；对于大多数黑客马拉松来说，这不是问题！
在我们的案例研究的特定例子中，我们使用上面初学者数据集文件中名为 energy.csv [1]的文件。这是一个清晰的数据集，有着清晰的关系，并且符合我们的能源主题。您也可以在本文引用的存储库中找到这些数据:https://github.com/Causb1A/cyf-edf-hackathon
选择什么数据的原则
选择数据集时，需要遵循一些原则:
- 数据必须非常清晰，具有清晰的逻辑关系和明确的目标变量(这一点非常重要，将在下面详述)。
- 确保至少有两种数据类型:整数(或浮点)和分类数据。如果没有分类数据，这没问题；但是，您必须能够将列转换为分类数据。
- 确保至少有 5 列 500 行数据。
- 确保数据有一个相对众所周知的上下文(也在下面的部分展开)。
这个黑客马拉松是人为的，不建议使用真实数据，因为真实数据是杂乱的，有时可能没有关系。一点也不适合初学者。我们希望激励新的数据科学家，激励人们从这个领域开始，而不是向他们展示死胡同。
下面是遵循上述原则的一个例子。
案例研究 Energy.csv:
让我们来评估我从 Kaggle 文件夹中选择的数据集:energy.csv [1]，这是一个包含房屋/物业及其热负荷的不同测量值的数据集。这符合我们的能源主题。在这个 CSV 中，我选择了“热负荷”——下图中的最后一列——作为预测的目标变量。
来自 energy.csv |公共领域数据的几篇专栏文章—知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
对于那些不知道的人来说，热负荷是将温度保持在可接受的范围内所需的热能的量。
让我们看看这个数据是否符合我提到的原则中的标准:
- 有明确的逻辑关系吗？可以说，所有或至少大部分专栏都是如此。玻璃面积，表面积，屋顶面积，这肯定会影响热负荷吧？表面积越大可能意味着热负荷越低。
- 它有多少种数据类型？它有整数和浮点数。它没有类别或布尔值，但您可以创建一个。有屋顶面积或表面面积，为什么不把它分成“非常低的表面面积”、“高的表面面积”等。那么就会存在一个分类列。
- 它的数据是否超过 5 列和 500 多行？是的，确实如此。
- 是一个比较知名的概念吗？热负荷和表面积是一个广义的概念，大多数人都知道。
这是一个合适的数据集。
使数据变得混乱
初学者数据集开始时太干净了，如果我们用这些数据开始黑客马拉松，即使对初学者来说也太容易了。我们也在尝试教别人如何处理杂乱的数据。因此，我们必须做到以下几点:
- 添加完全没有意义的额外列
- 给数据添加随机噪声，这样就不那么干净了
- 如果分类列不存在，则创建分类列
- 创建混乱的文本数据(例如在段落中嵌入一个数字来提取)
- 创建缺失值
- 随机添加一些异常
- 分割数据，为自己保留一个看不见的数据集
下面，我们评估了上述案例研究，供您作为范例遵循。有许多方法可以做到这一点，然而，在这里我们遵循这个例子。
案例研究:energy.csv
同样，下面我们来探讨案例研究。完整的 Jupyter 笔记本，在这个回购里:https://github.com/Causb1A/cyf-edf-hackathon而我参考的笔记本叫:make _ data _ noise . ipynb
R 记住，我们要预测的目标变量是供热负荷
在执行任何步骤之前，我们首先执行导入，并将数据定义为 df:
import numpy as np
import pandas as pd
import matplotlib
import matplotlib.pyplot as plt
import random
import sklearndf = pd.read_csv(“energy.csv”)
添加完全没有意义的额外列
我们首先添加与数据不相关的额外列。
下面我创建了两个随机列，一个数字列和一个分类列。
展示新的两个专栏的表格——energy . CSV |公共领域数据——知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
正如您在上面看到的，右边的两个新列显示了两个无用的数据列。一个有很多空值的。让我们看看初学者如何认识到这些是无用的专栏！
给数据添加随机噪声，这样就不那么干净了
我只对一个列这样做，但你可以对任何列这样做，只要对你产生的随机噪声的规模有逻辑，否则它可能是你使这个列对 ML 模型无用。下面我添加了随机数，让“上光面积分布”这一栏看起来很乱。
展示玻璃区域额外噪音的表格——energy . CSV |公共领域数据——知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
如果分类列不存在，则创建分类列
我们希望参与者体验处理分类列及其效果。所以让我们创建一个。我快速检查了“表面积”一栏，注意到最大值约为 800，最小值约为 500。所以我在此基础上创建了一些类别。
包含新类别的输出示例(如最右边一栏所示)— energy.csv |公共领域数据—知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
正如你在上面看到的，有一个新的类别列叫做“表面 _ 面积 _ 类别”。也许参与者会将其视为分类列，但作为额外的一步，您可以教他们一些具有清晰层次结构的类别，您可以将其转换为整数。例如，低表面积与高表面积具有不同的重量。但不管怎样，这取决于你和你教的东西！
创建混乱的文本数据(例如在段落中嵌入一个数字来提取)
有时在现实世界中，我们会处理杂乱的文本数据，作为数据科学家需要用 NLP(自然语言处理)来解密东西。我们可以通过创建有意义的文本数据让参与者体验一下。
下面我做两件事:
- 从列表中随机选择一种颜色，放入一些文本数据中来完成一个句子。
- 从“墙区域”列中取出浮动，并将其嵌入到文本中。
带有新的杂乱文本数据的输出示例(最右栏)— energy.csv |公共领域数据—知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
正如你在上面看到的，一个新的有墙的区域嵌入了文字和颜色。希望参与者可以尝试从文本中提取这个数字，努力清理数据，探索颜色是否是一个有用的变量。
创建缺失值
创造缺失的价值很重要，这样参与者就知道如何处理缺失的价值。因此，我建议手动放置缺失值，或者编写一个函数来创建随机的空值。在本例中，我写了几行代码，在几列中随机生成空值。
随机添加一些异常
你想教参与者的另一件事是如何处理数据集中的异常。在能源案例研究中，我知道数据，所以我只是手动输入一些异常。如果您想更聪明一点，编写一个函数来创建值必须是平均值的 5 倍的异常，这也是一个可行的解决方案。
分割数据，为自己保留一个看不见的数据集
在继续之前，创建数据集之后，请确保拆分数据。我们这样做的原因是，我们想看看参与者创建模型的效果如何。所以你可以用完全看不见的数据运行他们的模型，看看它的表现如何。我这样做是因为:
从上面来看，“energy _ noisy _ train.csv”将用于给参与者，而“energy _ noisy _ test.csv”将用于我测试他们的能力。
使用机器学习创建解决方案笔记本
您现在必须有两个杂乱的数据集:
- 一份给参与者，让他们尝试创造清洁和预测
- 另一个供您自己使用，以测试他们的笔记本电脑和型号的性能
此时，你必须考虑你想教给你的同事/参与者什么。现在你有了一个很好的数据集，有了基本的问题作为初学者的起点，有了各种要处理的元素，比如异常、空值等等。
现在，我们必须创建一个解决方案笔记本，向参与者展示如何解决这个问题的示例。在教其他人做什么之前，自己先在数据集上试一试，看看你对数据集的清理和预测有多好，同时记住你想教他们什么。首先定义你的目标变量(即你希望参与者预测的列)和问题陈述。然后继续探索和撤销你所做的所有工作，首先创建混乱的数据集。
清理您的人工数据
从以下框架开始:
- 为参与者定义一个问题陈述(即参与者必须预测什么)
- 从典型的探索性数据分析元素开始:df.shape、df.columns、df.dtypes 等。
- 进行一些可视化 EDA 探索，确保在你的可视化中探索异常、空值、类别和相关性。
- 幸运的是，既然你从干净的数据集开始，并自己把它弄得乱七八糟，你就知道如何清理这个人为的乱七八糟的数据集，因此，通过撤销你所做的一切来清理它。丢弃/估算空值，消除异常，从文本数据中提取数字等。
你在创建解决方案笔记本时采取的每一步都要记住，其他人也会经历这一步，所以要写得非常清楚，并在减价文本中解释需要解释的内容。
选择您的 ML 算法
您现在必须有一个解决方案笔记本，它已经将数据清理回其原始数据集。拼图的最后一块是实现一个 ML 模型。你可以选择任何你认为合适的模型，但是我推荐使用线性回归和岭回归。为什么？因为线性回归是最基本类型的预测模型。
有时候 ML 的概念对初学者来说有点难。在让他们尝试笔记本电脑之前，我可以说的一个技巧是做以下事情。首先教导参与者，当你有两个变量，x 和 y，并且它们有某种线性关系时，你可以画一条最佳拟合线并预测如下值:
线性回归图片示例|图片由作者生成
但是当你引入第三个变量 z 时呢？然后你可以向参与者展示一个 3D 图表。
作者创建的图片|使用了来自canva.com的免费内容许可元素
然后告诉参与者想象 4 维、5 维等等。但是解释一下，我们可能不能把它画出来，但是机器可以理解。这是向任何人介绍 ML 最容易理解的方式。
但是为什么还要引入岭回归呢？因为岭回归本质上是增加了一个参数的线性回归。参数在 ML 模型中非常重要，因此引入一个可以防止过度拟合的参数的基本概念是至关重要的。
案例研究:energy.csv
回到 energy.csv [1]的案例研究，在解决方案笔记本中展示和解释每一步都太多了。因此，我挑选了一些框架的例子。要访问完整的解决方案笔记本并查看我进行预测的每一步，请访问:
https://github.com/Causb1A/cyf-edf-hackathon
这个笔记本叫做CYF-解决方案-笔记本. ipynb 。
EDA 示例:探索视觉效果的相关性
了解数据自身的关联程度非常重要，因此我创建了一个函数和关联视觉效果:
清理示例:撤销杂乱的文本数据
在前面的部分中，我们创建了一个名为 wall_description 的列，并在文本文件中嵌入了一个数字。下面我创建一个函数来提取数字和颜色。
产出:
文本摘录示例— energy.csv |公共领域数据—知识共享许可可在https://www.kaggle.com/ahmettezcantekin/beginner-datasets获得
正如你在上面最右边的两列中看到的，我已经撤销了对名为“wall_description”的文本列所做的操作。我已经提取了颜色和墙壁面积。
ML 示例:引入线性回归
在所有的清理之后，我在下面的步骤中引入线性回归:
- 创建虚拟变量
- 训练模型
- 输出 rScores
如果你对上述内容不熟悉，我基本上还列出了 depVars，即参与者可以选择纳入模型培训的变量，这是另一个教学点。
为参与者创建一个框架笔记本
我们现在有了端到端解决方案笔记本。我对完全初学者的建议是，不要让他们一无所有，而是创建一个框架笔记本。框架笔记本是给参与者的笔记本，指导他们如何进行端到端项目，无论是以降价文本还是书面代码的形式。这是参与者将要制作的笔记本。内容很大程度上取决于你想向参与者透露多少，或者你想教多少。
在框架笔记本中，您需要做的第一件事是定义问题陈述(您应该已经完成了),导入正确的包，并读入数据。
你需要做的第二件事是从你的解决方案笔记本中取出每一个单元格，并将其粘贴到你的框架笔记本中，然后:
- 从上到下，删除你认为参与者需要自己做的内容，但保留你认为对初学者来说太难的内容。
- 尽可能记录下来，以帮助引导参与者。
- 当你去掉足够的元素后，留下盒子让参与者自己探索和清理。
这里的想法是从解决方案笔记本开始，并将其精简到参与者可以继续工作的点。根据你的观众水平，你可以决定去掉多少，保留多少，但是，我建议你保留整个 ML 位。特别是作为初学者入门，理解 ML 特别吃力。此时，数据清理/争论是最重要的技能，因为数据的质量在很大程度上影响了模型的质量。不要让参与者编写他们自己的 ML 部分，告诉他们如果你改变变量或包含杂乱的数据，模型会变得更好或更差。在前一节的案例研究中，我在一个列表中列出了 depVars。这是让参与者自己添加或删除变量，看看它如何影响 r 分数。但是，这完全取决于你。
案例研究:energy.csv skeleton 笔记本
https://github.com/Causb1A/cyf-edf-hackathon
骷髅笔记本命名:CYF-骷髅-笔记本. ipynb
还是那句话，这个笔记本太长了，每一步都写不完。简而言之，我去掉了所有的基本元素，但是留下了一些定义好的函数和更难的元素。例如，从列中提取数字的函数。我还写了一份问题陈述，并给参与者留出了完成工作的空间。最后，我离开 ML 模型是为了教导您可以将许多输入变化到模型中。
评估的可能方法
有几种可能的方法来评估参与者的工作。这里我们将介绍一些这样做的例子:
- 如果只有几个参与者，你可以在 hackathon 后自己运行他们的笔记本，加载从“使数据混乱”部分分离的测试数据，并通过他们的管道传递该数据，评估 rscores。
- 您可以创建一个管道，参与者以. py 格式提交他们的笔记本，您的管道将系统地通过看不见的数据集来对他们的分数进行排名。
- 您不需要评估，但最后展示解决方案笔记本，并让他们提问。
所有 5 个步骤的总结
让我们总结一下我们讨论过的所有内容:
选择数据集
我们可以根据以下标准从 Kaggle 中选择一个干净的数据集。
- 数据必须非常干净，有清晰的逻辑关系和明确的目标变量。
- 确保至少有两种数据类型:整数(或浮点)和分类数据。如果没有分类数据，只有当您可以将列转换为分类数据时，这才是好的。
- 确保有 5 列数据和至少 500 行。
- 确保数据具有相对众所周知的上下文。
使数据集变得混乱
- 添加完全没有意义的额外列
- 给数据添加随机噪声，这样就不那么干净了
- 如果分类列不存在，则创建分类列
- 创建混乱的文本数据(例如在段落中嵌入一个数字来提取)
- 创建缺失值
- 随机添加一些异常
- 分割数据，为自己保留一个看不见的数据集
使用机器学习创建解决方案笔记本
创建一个端到端解决方案笔记本，用于清理数据和预测目标变量
- 为自己和参与者创建一个问题陈述。
- 从典型的探索性数据分析元素开始:df.shape、df.columns、df.dtypes 等。
- 进行一些可视化 EDA 探索，确保在你的 EDA 可视化中识别出哪里有异常、空值、类别、相关性。
- 通过撤销你所做的一切来清理数据。丢弃/估算空值，消除异常，从文本数据中提取数字等。
- 使用简单的 ML 模型进行预测(例如线性回归)
- 添加一个需要一个参数的简单 ML 模型(如岭回归)
为参与者创建一个框架笔记本
创建一个供参与者使用的笔记本框架。
- 创建问题陈述和目标变量。
- 使用解决方案笔记本作为模板。从上到下，删除你认为参与者需要自己做的内容，但保留你认为对初学者来说太难的内容。
- 尽可能记录下来，以帮助引导参与者。
- 当你去掉足够的元素后，留下盒子让参与者自己探索和清理。
评估的可能方法
- 使用你看不见的数据，通过他们的笔记本，看到 r 分数。
- 创建一个自动排列代码的在线管道。
- 您不需要评估，但最后展示解决方案笔记本，并让他们提问。
结论
我们刚刚为初学者创建了一个端到端的数据科学笔记本。现在，你应该准备好帮助从未接触过 python 或数据科学的同事或朋友提高技能。这将引入数据争论/清理、数据操作和 ML 预测的概念。我们跟踪的案例研究是与一个名为 Code Your Future 的团体合作举办的一个成功的慈善日。您可以随意使用 Github 上的代码来举办自己的黑客马拉松。
如果你喜欢这篇文章，请留下掌声和关注支持！
或者，如果您有兴趣加入 Medium 社区，这里有一个推荐链接:
https://medium.com/@adrian.causby15/membership [## 通过我的推荐链接加入 Medium-Adrian caus by
medium.com](https://medium.com/@adrian.causby15/membership)
这要归功于 Marcell Orban，他也和我一起写了黑客马拉松笔记本。
参考
[1] P ycaret Data，n.d. |知识共享许可|公共领域|[在线]可在:https://www.kaggle.com/ahmettezcantekin/beginner-datasets[2022 年 3 月 7 日访问]。
5 简化组件以构建更好的应用
原文：https://towardsdatascience.com/5-streamlit-components-to-build-better-applications-71e0195c82d4
2 号是我的最爱
罗宾·格劳泽在 Unsplash 上的照片
Streamlit 是一个惊人的 Python 库。
我每天使用它来构建和共享解决各种任务的交互式 web 应用程序:与用户输入交互并理解机器学习模型的预测，提供可视化和探索数据的界面，共享自动化报告，等等。
让 Streamlit 更加强大的是开源社区开发和维护的大量插件(也称为 Streamlit 组件)。
在这篇文章中，我将回顾 5 个我经常用来扩展 Streamlit 原生功能的 Streamlit 组件。我们将了解这些库的确切用途以及何时应该使用它们。
如果你是一个 Streamlit 用户，你一定要看看这篇文章。
事不宜迟，让我们来看看👀
https://medium.com/membership/@ahmedbesbes
简化组件—它们是什么？
Streamlit 组件是安装在 Streamlit 之上以提供附加功能的外部 Python 库——您可以简单地将它们视为插件。
你可以去这个链接查看社区开源的最流行的组件。
作者截图
➡️:这超出了本文的范围，但是如果你对构建自己的定制 Streamlit 组件感兴趣，你可以观看这两个视频教程，它们很好地解释了这个过程。
第一部
第二部分
现在让我们浏览一下列表。其中一些组件没有出现在官方文档中，但是您仍然可以尝试一下😉。
👉1-streamlit _ tags
Streamlit 的自定义标签/关键字组件
- GitHub:https://github.com/gagan3012/streamlit-tags/
**pip install streamlit-tags**
Streamlit 本身不允许您输入单词列表，并在后端以 python 列表的形式检索这些数据。然而，有一个常见的解决方法:通过st.text_input或st.text_area获取用户输入，然后根据给定的分隔符解析它并获得一个列表。
但这似乎是不必要的工作。
streamit_tags 允许您直接从界面获取关键字，如下例所示。
作者图片
什么时候需要使用 streamlit-tags？
每当您希望输入一列单词，并且不想执行不必要的容易出错的字符串解析时。
👉2 — streamlit_aggrid
Ag-Grid JS 库周围的 Streamlit 包装器
GitHub:https://github.com/PablocFonseca/streamlit-aggrid
**pip install streamlit-aggrid**
streamlit_aggrid 是一个构建在AG Grid(一个高度可定制的 JavaScript 数据网格)之上的组件，它旨在提高 streamlit 在显示数据帧和与它们交互方面的能力。****
使用 streamlit_aggrid 非常简单，只需导入 aggrid 函数并将 dataframe 传递给它即可:
**from st_aggrid import AgGrid****AgGrid(df)**
以下是 AgGrid 的一些特性:
- 可以对列进行排序、过滤和搜索:
作者 GIF
- 你可以拖动列并改变它们的顺序:这在分析数据时很有用
作者 GIF
- 大型数据帧可以分页
作者 GIF
- 您可以直接从浏览器锁定列、对列进行分组并计算聚合
作者 GIF
- 您可以让您的数据框架与其余的 Streamlit 小部件交互(例如通过选择一行)
作者 GIF
这些 gif 是从我以前的一篇文章中截取的。如果你有兴趣了解更多关于 streamit_aggrid 的内容，可以去看看。
**</7-reasons-why-you-should-use-the-streamlit-aggrid-component-2d9a2b6e32f0>
什么时候需要使用 streamlit-aggrid？
除了样式和布局，我认为 streamlit_aggrid 最有趣的特性是使 dataframes 与 streamlit 应用程序的其他组件交互的能力。
👉3 — streamlit-echarts
用于渲染 ECharts 图的 Streamlit 组件。
Github:https://github.com/andfanilo/streamlit-echarts
**pip install streamlit-echarts**
当您必须在 Streamlit 中进行数据可视化时，您可能使用过 Matplotlib、Bokeh 或 Plotly:这些是最受欢迎的选择。
我最近遇到的另一个选择是 Echarts :一个令人惊叹的交互式图表和数据可视化库。它是用 JavaScript 编写的，由 Apache 基金会维护。
Echarts 提供强大的可视化功能和无限的定制。您可以使用它来绘制线条、条形图、饼图、散点图、地理热图、雷达图、有向图、树状图、桑基图、仪表图、平行图和许多其他疯狂的事情。
语法也很容易理解和适应。
如果你好奇，你可以在这里查看你能用电子海图做些什么。
作者截图
streamlit-echarts 是将 echarts 图集成到 streamlit 应用程序中所需的组件。
我玩过这个组件，我必须说它很容易使用。让我给你看一个例子。
假设您想要嵌入一个标尺，如下所示(代码可用此处来自官方示例)
作者截图
您所要做的就是转换下面的 JSON 对象(从左窗格中):
JS 对象
到 Python 字典:
Python 字典
然后，你得把这本字典传给st_echarts
**from streamlit_echarts import st_echarts
st_echarts(options=options, width="100%", key=0)**
在 Streamlit 上的结果看起来相当不错。
作者截图
您何时需要使用 streamlit-echarts？
- 这是 Plotly 的一个非常好的替代方案——我个人更喜欢 Echarts 布局
- 如果你有一些 JS 知识，你可以建立非常复杂的情节和定制的布局
👉4 —简化熊猫档案
熊猫——在您的 Streamlit 应用程序中进行剖析——只需一行代码
- Github:https://github.com/okld/streamlit-pandas-profilings
**pip install streamlit-pandas-profiling**
熊猫档案已经存在好几年了。这是一个 Python 库，允许你从你的 Pandas Dataframes 对象构建 HTML 报告。它非常有用，因为它自动化了我们重复执行的许多任务，以分析数据、计算统计指标、创建图表、发现相关性、异常或缺失数据。
在 Streamlit 中集成 pandas-profiling 实际上并不是一个坏主意。我发现自己多次在 Streamlit 中从头开始创建探索性数据分析(EDA)仪表板，这个组件可以节省大量时间。
这两个库之间的集成非常顺利，如下面的动画 GIF 所示:
作者 GIF
什么时候需要使用streamlit-pandas-profiling？
如果你正在构建一个执行探索性数据分析的 Streamlit 应用程序，Streamlit-pandas-profiling是一个可以自动完成这项任务的组件，或者至少可以大大加快它的速度。
👉5-ST-注释文本
显示注释文本的 Streamlit 组件
- Github:https://github.com/tvst/st-annotated-text
**pip install st-annotated-text**
st-annotated-text 是一个有趣的组件，它允许您突出显示文本的特定部分，并为其添加标签和颜色。如果您从事自然语言处理任务，如命名实体识别(NER)或词性标注，这个包就派上用场了。
作者截图
什么时候需要使用 st 注释文本？
让我用一个例子来回答这个问题:下面是我过去制作的一个用于匿名个人数据的 Streamlit 应用程序的截图。当用户输入一些文本时，NER 模型会识别命名实体，如人员和位置。然后用特定的颜色和标签对这些实体进行注释，最后进行哈希处理以生成匿名文本。
st-annotated-text 通过注释每个实体提供了有用的视觉信息。
作者截图
如果你有兴趣了解这个应用程序的更多信息，你可以查看我的帖子:
资源
一如既往，这里有一个资源列表，您可以进一步了解有关 Streamlit 和 Streamlit 组件的更多信息。
- 官方文件:【https://streamlit.io/components
- https://medium . com/ssense-tech/streamlit-tips-tricks-and-hacks-for-data-scientists-d 928414 e0c 16
- https://towards data science . com/7-reasons-why-you-should-use-the-streamlit-aggrid-component-2d 9 a2 b 6 e 32 f 0
- https://towards data science . com/how-to-build-and-deploy-a-text-anonymizer-with-spacy-and-streamlit-70ed 9607823
- https://www.youtube.com/watch?v=BuD3gILJW-Q&ab _ channel = Streamli
- https://www.youtube.com/watch?v=QjccJl_7Jco&ab _ channel = Streamlit
感谢阅读🙏
同样，如果您已经做到了这一步，我要感谢您的时间，并希望您发现这些 Streamlit 组件中至少有一个有用。
这就是我今天的全部内容。下次见！👋
新到中？您可以每月订阅 5 美元，并解锁无限的文章— 单击此处。
由 Karsten Winegeart 在 Unsplash 上拍摄**
每个熊猫用户都应该知道的 5 种基于字符串的过滤方法
原文：https://towardsdatascience.com/5-string-based-filtering-methods-every-pandas-user-should-know-48021938412e
字符串列过滤指南。
安德烈亚斯·帕尔默在 Unsplash 上拍摄的照片
Pandas 中的过滤操作指的是选择某个特定列中的值符合特定条件的行的子集。
例如，考虑下图左侧的虚拟数据帧。如果您想选择col1中的值为A或B的所有行，过滤操作应该产生右侧的数据帧。
过滤 col1 上的数据帧(图片由作者提供)。
上述类型的过滤特指 Pandas 中的基于字符串的过滤。
在这篇文章中，我将分享一些作为 Pandas 用户应该知道的在字符串列上过滤数据帧的最流行的方法。文章的亮点如下:
如何识别一个字符串列？基于字符串的过滤方法: →# 1 基于单个类别值的过滤 →# 2 基于多个类别值的过滤 →# 3 基于字符串长度的过滤【长度】
我们开始吧🚀！
如何识别字符串列？
在我继续使用 Pandas 中流行的方法来过滤字符串值数据之前，让我们先了解一下如何识别具有字符串数据类型的列。
在 Pandas 中，字符串列的数据类型表示为object。要确定数据类型，可以使用序列的dtype属性，如下所示:
这里，您应该注意，即使一个序列中的单个值是一个字符串，整个列也会被解释为字符串类型的列。例如，让我们将col2中的第一个值从1改为“1"。
这一次，col2的数据类型是object，而不是int64——描述的是字符串数据类型。
基于字符串的过滤方法
接下来，让我们继续理解可以用来在具有object数据类型的列上过滤数据帧的方法。
基于单个分类值的#1 过滤器
首先，假设您想要过滤字符串列中的值属于该列中的一个单个分类值的所有行。下图展示了这一点:
上述过滤在下面实现:
上面的方法过滤了所有col1中的值为“A”的行。
这也可以使用如下所示的query()方法实现:
注意:在字符串列上使用query()方法进行过滤时，应该用单引号将过滤值括起来，如上所示。
基于多个分类值的#2 过滤器
与上面的过滤类似，如果您想一次过滤多个值，可以通过三种方式。
- 使用逻辑运算符:
上述条件说明col1中的值应该是“A” 或 “B”。
- 第二种方法是使用
[isin()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.isin.html)方法，如下所示:
上面使用的isin()方法接受要过滤的值列表。
- 最后，我们可以使用如下所示的
query()方法:
上面使用的[isin()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.isin.html)方法接受一个过滤器值列表。另一方面，[query()](https://pandas.pydata.org/docs/reference/api/pandas.DataFrame.query.html)方法计算一个字符串表达式来过滤数据帧中的行。
#3 基于字符串长度的过滤器
在这里，假设您想要从数据帧中过滤掉一列中字符串长度大于/小于阈值的所有行。
在一个序列上调用[len()](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.len.html)方法可以让您计算单个条目的长度，然后可以使用它根据一个阈值过滤行。
下面，我们从 col1 中过滤掉所有长度大于4的字符串。
在对object列执行一个方法之前，应该使用str属性将值作为字符串类型进行检索，这样就可以运行 python 中的一系列字符串方法，比如strip()、isupper()、upper()、len()等。
#4 根据子字符串的存在进行过滤
接下来，假设您想要提取字符串列中的值包含特定子字符串的行。
有三种广泛使用的方法。
- 匹配字符串的开头
顾名思义，只有当子字符串匹配字符串值列的开头时，该方法才会返回一行。
假设您想要查找以子字符串“ Jo ”开头的所有字符串。我们将使用下面演示的[startswith()](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.startswith.html)方法。同样，回想一下前面的过滤方法(#3)，我们应该首先使用str属性将 object 列转换成一个字符串。
如果您的列有 NaN 值，您应该在startswith()方法中指定nan=False，否则，它将引发一个错误
错误块如下所示:
指定nan=False会忽略 NaN 值:
- 匹配字符串的末尾
字符串末尾匹配的语法类似于startswith()。这里，我们使用如下所示的[endswith()](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.endswith.html)方法:
注意:
startswith()和endswith()都是区分大小写的方法。
- 匹配字符串中的任意位置
与分别只匹配字符串开头和结尾的子字符串的startswith()和endswith()方法相比，[contains()](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.contains.html)方法可以在字符串值列中的任何地方找到潜在的匹配。
默认情况下，contains()方法执行区分大小写的匹配。但是，它也可以通过传递如下所示的case=False参数来执行不区分大小写的匹配:
#5 基于字符串中字符类型的过滤器
这种类型的过滤基于字符串中存在的字符类型，例如:
- Filter if all characters are upper-case : [**isupper()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isupper.html#pandas.Series.str.isupper)
- Filter if all characters are lower-case : [**islower()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.islower.html#pandas.Series.str.islower)
- Filter if all characters are alphabetic : [**isalpha()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isalpha.html#pandas.Series.str.isalpha)
- Filter if all characters are numeric : [**isnumeric()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isnumeric.html#pandas.Series.str.isnumeric)
- Filter if all characters are digits : [**isdigit()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isdigit.html#pandas.Series.str.isdigit)
- Filter if all characters are decimal : [**isdecimal()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isdecimal.html#pandas.Series.str.isdecimal)
- Filter if all characters are whitespace : [**isspace()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isspace.html#pandas.Series.str.isspace)
- Filter if all characters are titlecase : [**istitle()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.istitle.html#pandas.Series.str.istitle) **-** Filter if all characters are alphanumeric :[**isalnum()**](https://pandas.pydata.org/docs/dev/reference/api/pandas.Series.str.isalnum.html)
我在下面演示了其中的一些方法。
-
从数据帧中过滤字母数字字符串:
-
从数据帧中过滤数字字符串:
这就把我们带到了这篇文章的结尾。
总之，在这篇文章中，我们讨论了一些在熊猫中使用最广泛和必须知道的基于字符串的过滤方法。
基于字符串的过滤也可以使用 python 中的正则表达式(RegEx)来执行。由于时间关系，我没有在这篇文章中讨论它们，我将很快发布另一篇博客！
有兴趣在媒体上阅读更多这样的故事吗？？
✉️ 注册我的电子邮件列表 不要错过另一篇关于数据科学指南、技巧和提示、机器学习、SQL、Python 等的文章。Medium 会将我的下一篇文章直接发送到你的收件箱。
感谢阅读！
机器学习改变世界的 5 种令人惊讶的方式
原文：https://towardsdatascience.com/5-surprising-ways-machine-learning-is-revolutionizing-the-world-d1a0b94b3736
探索人工智能的前沿技术和应用，以及它们在改革行业和改善我们日常生活方面的潜力
稳定扩散生成的图像。
2022 年下半年充满了关于人工智能、机器学习和深度学习的惊喜和激动人心的时刻。像稳定扩散和 ChatGPT 这样的应用已经风靡全球，这是有充分理由的。它们是令人敬畏的科技产品。然而，在这个故事中，我们将获得该领域及其用例的更广阔的视角。
机器学习(ML)是一种人工智能，允许软件应用程序在没有专门编程的情况下提供答案。基本思想是，这些程序可以从数据中学习，识别模式，并在最少的人工干预下做出决定。这与传统编程形成对比，在传统编程中，程序员必须明确指定程序要遵循的所有规则。
深度学习是一种 ML，它使用具有多层处理单元的神经网络从大量数据中学习。它被称为“深度”学习，因为神经网络有许多层的处理单元，这与浅线性或非线性模型相反。深度学习已被证明对广泛的任务非常有效，如图像和语音识别、自然语言处理和机器翻译。它还被用于开发虚拟助手和其他应用程序，这些应用程序与用户的交互更加自然和直观。
机器学习起源于上世纪 50 年代。然而，直到 20 世纪 80 年代末和 90 年代初，这个领域才开始产生有希望的结果。另一方面，深度学习是机器学习中相对较新的领域。它产生于对人工神经网络的研究，该研究受到人类大脑结构和功能的启发。第一个成功的深度学习模型是在 20 世纪 80 年代开发的。尽管如此，直到 2010 年代初，该领域才开始获得牵引力，这主要是由于计算能力的进步和海量数据的可用性。
现在，我们已经了解了术语和历史，让我们看看正在改变世界的一些用例。
Learning Rate 是为那些对 AI 和 MLOps 的世界感到好奇的人准备的时事通讯。你会在每个月的第一个星期六收到我关于最新人工智能新闻和文章的更新和想法。订阅这里！
卫生保健
机器学习正被用于开发新的疾病治疗方法，并提高诊断的准确性。例如，机器学习算法可以分析大量的医疗数据，以识别模式，并对不同治疗的有效性进行预测。
稳定扩散生成的图像
像 AlphaFold 这样的应用程序可以准确预测蛋白质结构的 3D 模型，并加快生物学和药物发现几乎每个领域的研究。
此外，由 MosaicML 和斯坦福基础模型研究中心(CRFM)构建的大型语言模型 PubMed GPT 在美国医学许可考试(USMLE) 的医学问答测试中取得了最先进的结果。这种特定领域的语言模型可以在不久的将来支持生物医学研究。
农业
机器学习正在通过提高作物产量和农业运营效率来改变我们生产食物的方式。例如，机器学习算法可以分析农场设备上传感器的数据，以优化灌溉和施肥。
根据 Markets&Markets 的数据，未来几年，农业人工智能等高端技术解决方案的支出将继续增长，并将在 2026 年达到 40 亿美元的历史新高。
一个具体的现实世界的用途是使用机器学习通过分析植物的图像来识别作物中的病虫害。这可以帮助农民及时采取措施防止作物损失。联合国与普华永道合作正是为了做到这一点，评估亚洲的椰枣果园潜在的虫害(更多细节见此处)。
另一方面，你现在可以结合机器学习技术来训练模型，以分析 3D 地图，社会状况数据和基于无人机的土壤颜色数据。在我们开始播种之前，这些模型可以给你某块田的潜在产出率。你可以在这里找到更多关于这个项目的细节。
零售
推荐系统在零售和娱乐领域无处不在。他们的目标是改善和个性化客户体验，增加销售额。这可以通过向用户呈现更可能与他们的兴趣相关的项目来帮助提高用户参与度和满意度。
推荐系统被用于各种领域，但是最常见的是作为视频和音乐服务的播放列表生成器、在线商店的产品推荐器或者社交媒体平台的内容推荐器。
零售业中最突出的例子是亚马逊在线商店中部署的推荐系统。亚马逊可以使用算法来分析你的购物行为，并推荐符合你需求的产品。
人工智能在零售业的另一种应用方式是提高库存管理的准确性。零售商现在可以应对客户需求和季节性，而不必订购超过他们需求的商品。
运输
机器学习正被用于提高运输系统的安全性和效率。例如，机器学习算法可以分析自动驾驶汽车的数据，使其更加安全可靠。无人驾驶汽车还没有出现，但它们一定会在未来几年彻底改变交通领域。
稳定扩散生成的图像
此外，像优步和 Lyft 这样的公司使用机器学习算法来预测特定时间特定区域的乘车需求，并更有效地将乘客与可用司机进行匹配。他们还通过考虑交通、天气和需求等因素，使用机器学习来提高定价算法的准确性。
金融
ML 在金融中最突出的应用是欺诈检测。例如，机器学习算法可以分析交易数据，以识别可疑活动，并实时防止欺诈。这可以帮助金融机构防止财务损失并保护其客户的账户。每个银行或金融机构都在生产这样的系统。您可能在上次出国旅行中遇到过他们，当时您的付款没有得到处理。
ML 在金融中的另一个应用是信用风险评估。ML 模型可用于根据信用评分、收入和债务收入比等因素预测借款人拖欠贷款的可能性。这可以帮助贷方做出更明智的贷款决策，更好地管理风险。像这样的模式已经在影响我们的生活，其中一些模式并没有以最不偏不倚的方式进行。
结论
机器学习是一种人工智能，允许软件应用程序从数据中学习并提高性能，而无需专门编程。它被广泛用于各种行业，包括金融、医疗保健和交通运输。
机器学习的使用正在彻底改变这些行业，使它们能够更有效地运营，并为客户提供更好的服务。
关于作者
我叫迪米特里斯·波罗普洛斯，我是一名为阿里克托工作的机器学习工程师。我曾为欧洲委员会、欧盟统计局、国际货币基金组织、欧洲央行、经合组织和宜家等主要客户设计和实施过人工智能和软件解决方案。
如果你有兴趣阅读更多关于机器学习、深度学习、数据科学和数据运算的帖子，请关注我的 Medium 、 LinkedIn 或 Twitter 上的 @james2pl 。
所表达的观点仅代表我个人，并不代表我的雇主的观点或意见。
Python 中星号的 5 个语法应用，最后一个令人惊讶
原文：https://towardsdatascience.com/5-syntactic-applications-of-asterisks-in-python-the-last-one-is-surprising-41cbd9957216
形象由 pasja1000 来自皮克斯拜
星号*为 Python 贡献了大量的语法糖
许多编程语言在许多场景中使用星号“*”，Python 也是如此。例如，在其他编程语言中，星号最常见的用途之一可能是内存指针。这个概念存在于许多流行的语言中，比如 C++和 Objective-C。
不过，Python 并不使用内存指针。相反，有更多的情况下，让我们做更多的技巧使用星号。这可以在可靠性方面改进我们的代码，甚至带来一些新的特性。这就是所谓的“语法糖”。在本文中，我将列出 5 个强调技巧。希望他们能帮上忙。
1.经营者
形象由 NOST 从皮克斯拜
嗯，我打赌每个人都知道这一点。然而，为了确保关于 Python 中星号的这一总结的完整性，请允许我在这里介绍它。
将星号用作乘运算符可能存在于所有编程语言中。
除此之外，Python 还引入了另一个操作符，即电力操作符。a ** b将计算数字 a 的 b 的幂。在其他一些编程语言中，它可能是a ^ b。
2.传递可变长度参数
图像由 995645 来自 Pixabay
这可能是星号最“皮托尼”的用法。在 Python 中，我们可以编写一个允许可变长度参数的函数。
例如，我们可以编写这样一个函数，将传入的所有数字相加。为了允许参数可变长度，我们需要在参数名称前添加一个星号。
def sum_all(*numbers):
print('numbers:', numbers)
return sum(numbers)sum_all(1, 2, 3, 4, 5)
请注意，如果参数是数字，我没有检查它们的类型。该函数仅用于演示目的。
Python 还允许传递可变长度的键值对作为参数。我们只需要在参数名前面加上两个星号，如下所示。
def give_me_dict(**my_dict):
return my_dictgive_me_dict(name='Chris', age=33, gender='Male')
这两个特性为开发人员在编程过程中提供了很大的灵活性。如果您想了解更多关于 Python 中变长参数的知识，我为这个主题写了另一篇文章供您查阅。
3.拆箱清单和字典
图片来自皮克斯拜
当我们想对一个列表或一个字典的所有条目做一些事情时，我们通常需要使用 for 循环来迭代它们。但是，在某些情况下，我们可能不必这样做。
3.1 开箱清单
假设我们有一个如下的名字列表。现在我们要打印所有的名字。
student_list = ['Alice', 'Bob', 'Chris']
我们可以使用订阅来逐个获取它们，或者更聪明一点，使用 for 循环。
print(student_list[0], student_list[1], student_list[2])# Orfor name in student_list:
print(name)
还有一种更聪明的方法，那就是使用星号来解包列表。
print(*student_list)
我们甚至可以一次打开多个列表。
print(*['Alice', 'Bob'], *['Chris'], 'David')
为了将多个列表与一些松散的项目组合在一起，我们还可以使用星号来解包列表。
[*['Alice', 'Bob'], *['Chris'], 'David']
当我们想要将多个列表放入一个元组或集合中时，也可以使用这个技巧。
(*['Alice', 'Bob'], *['Chris'], 'David')
{*['Alice', 'Bob', 'Chris'], *['Chris'], 'David', 'Chris'}
现在，让我们考虑一个更高级的用例。我们得到了一个如下的二维列表。每个子列表有两个项目，一个名字和一个年龄。它不容易使用，所以我们想转置二维列表，这样一个列表有所有的名字，另一个有所有的年龄。
my_list = [
['Alice', 31],
['Bob', 32],
['Chris', 33]
]
最简单的方法是在一个zip()函数中解包列表。
for i in zip(*my_list):
print(list(i))
这相当于这样做。
for i in zip(['Alice', 31], ['Bob', 32], ['Chris', 33]):
print(i)
如果我们仍然想要一个二维列表，我们可以使用列表理解将两个子列表放入一个父列表中。
[list(i) for i in zip(*my_list)]
如果您不太熟悉zip()函数，请查看我以前的一篇深入研究这个函数的文章。
3.2 打开字典包装
从 Python 3.5 开始，星号也可以解包字典，但是我们需要在字典变量前面加两个星号来解包它。
最常见的用法之一是将多个字典组合在一起。假设我们有如下两个字典要合并，我们可以把它们拆开，放入另一个空字典中。
my_dict1 = {
'name': 'Chris',
'age': 33
}my_dict2 = {
'skill': 'Python'
}my_dict = {**my_dict1, **my_dict2}
另一个示例使用模式是格式字符串。虽然我喜欢 Python 中的 f-string 语法，但是格式字符串还是有一些优势的。例如，它允许带参数名的参数化字符串。
"My name is {name}. I'm {age} years old and I can use {skill}".format(
name='Chris',
age=33,
skill='Python'
)
在这种情况下，我们可以解包前面的字典，并将其放入格式字符串中以传递参数。
"My name is {name}. I'm {age} years old and I can use {skill}".format(**my_dict)
这非常整洁干净。此外，我们甚至可以将多本字典解包到其中。
"My name is {name}. I'm {age} years old and I can use {skill}".format(**my_dict1, **my_dict2)
3.3 拆包范围
使用星号进行解包的一个不太常见的用法是用于 Python 范围。我们通常使用range()来告诉一个 for 循环需要循环多少次。我们还可以用它来生成一系列序列号，如下所示。
list(range(10))
从语法上来说，我们也可以使用星号来解包 range 对象，尽管我认为在这种情况下没有任何好处。
[*range(10)]
4.打包清单
图片由克斯丁·里默尔从皮克斯拜拍摄
是的，我们不仅可以用星号打开列表，还可以在某些情况下打包项目。例如，我们可以使用下面的语法来使用 3 个变量分别从一个列表中获取 3 个项目。
students = ['Alice', 'Bob', 'Chris']my_classmate1, my_classmate2, me = students
假设在上面的例子中，谁是我的同学并不重要，我们只希望我的名字在最后，所有其他的名字应该留在一个列表中。在这种情况下，我们可以使用星号将所有其他项目打包。
students = ['Alice', 'Bob', 'Chris']
*other_students, me = students
您可能知道该语法也适用于元组。但是，需要注意的是，使用星号来打包项目总是会返回一个列表。换句话说，尽管原始对象是一个元组，但它不能足够智能地返回一个元组
students = ('Alice', 'Bob', 'Chris')
*other_students, me = studentsprint(me)
print(other_students)
使用这个技巧，我们也可以把一个字符串当作一个字符列表，并把一些特殊的字符和其他字符打包在一起。
product_code = 'A320'
class_indicator, *model = product_codeprint('Class indicator: ', class_indicator)
print('Model:', ''.join(model))
这也是为了演示的目的，因为我确信使用切片更容易，可读性更好。
print('Class indicator: ', product_code[0])
print('Model:', product_code[1:])
5.强制关键字参数
图片来自 Pixabay 的 Wokandapix
我不会相信这是一个频繁的用法，因为这个需求并不常见。不过，知道 Python 有这样一个特性还是不错的。也就是说，我们可以在函数的参数列表中放一个星号，强制右边的所有参数都必须用显式关键字传入。
例如，我们可以如下定义一个函数。
def my_func(arg1, *, arg2):
print(arg1)
print(arg2)
现在，如果我们试图传递两个参数，将会抛出错误。
my_func('a', 'b')
要使用这个函数，我们必须显式地指定参数arg2的键，因为它在星号的右边。
my_func('a', arg2='b')
摘要
图片由 jplenio 来自 Pixabay
在本文中，我总结了 Python 中星号的所有 5 种不同的使用模式。它可以是用于传递可变长度参数的运算符或指示符。它还可以打开列表、字典或范围对象，以及将它们打包。
https://medium.com/@qiuyujx/membership
如果你觉得我的文章有帮助，请考虑加入 Medium 会员来支持我和其他成千上万的作者！(点击上面的链接)
作为一名数据分析师，我在 2022 年实际做的 5 件事
原文：https://towardsdatascience.com/5-things-i-actually-work-on-as-a-data-analyst-in-2022-9e31df929fcb
听听医疗保健数据分析师对角色和职责的看法
在 Unsplash 上由 Mahbod Akhzami 拍摄的照片
如果你在网上搜寻数据分析师的真实工作描述，这是已经登陆的完美文献。
大家好，我是 Rashi，来自芝加哥 的医疗保健 数据分析师 。
我开始做数据分析师已经快一年了，我喜欢从事工作的方方面面。作为一名刚开始工作的毕业生或转行的专业人士，我们有一些关于数据科学家和数据分析师之间的区别、他们从事的工作以及之后工作所需技能的问题。
当我开始工作时，我花时间去了解我是否更倾向于做数据科学家或数据分析师。
在快速发展的技术领域，数据支持业务决策，数据和分析师无处不在-从金融到医疗保健，从刑事司法到时尚，食品，体育和约会-在许多其他领域，有许多需要学习和探索的地方。数据分析师的工作角色和职责因业务和团队而异，但是“基础”结构保持不变。
确定要分析的数据>>收集数据>>清理>>分析>>解释结果
基于这个生命周期，我可以明确地指出我认为与数据最相关的五个基本过程。
1.数据查询—大量的 SQL
对于任何数据分析师来说，一切都始于数据，也止于数据。
使用结构化查询语言(SQL)查询收集数据的次数是 10 次中的 8 次。SQL 是各行各业最需要的数据采集和分析技能。这些工具可以从内部部署到云— Microsoft SQL Server、Teradata、MySQL、Squirrel SQL、Hadoop、Snowflake、PostgreSQL、Oracle
对于数据分析师来说，SQL 的面试问题可能会令人望而生畏，但请相信我，当你在工作时，你总是会有一些过去的问题要参考。我直面这样的问题—
这些表应该用左外连接还是左内连接来连接？
如何包含两个表中同名的两列而不出错？
对于两个表，我应该使用 JOIN 还是 UNION？
对 case 语句、聚合函数、实体关系图(ERD)和其他 SQL 基础知识的透彻理解无疑为您的第一天工作提供了一个良好的开端。
几乎每个企业都将其数据存储在关系数据库中。通过使用 SQL，目标是快速从数据库中获取信息，从而节省时间和金钱。作为数据分析师，扎实的 SQL 基础是一项重要举措，可以让您的工作变得更加轻松！
2.数据建模
(数据建模的第一步是收集和清理要分析的数据)
作为一名数据分析师，我负责设计、创建和管理数据分析保护伞下的任何东西，可以是在 Excel 或选择的编程工具中创建预测模型，或者创建仪表板来展示员工能力与业务需求，或者创建月度面板来报告系统性能。这也包括统计学和数学。我花了几天时间分析数据点以及它们与因素的关系。
作为数据分析师，我的职责包括:
- 从与索赔、流程和业务手册相关的来源收集、集成和分析数据
- 通过支持业务的报告、预测模型、仪表板和分析计划来支持战略需求
- 不断加深对数据的理解以满足业务需求
- 与跨职能团队合作，利用工具并帮助构建可行的分析
- 在与合作伙伴和利益相关方一起制定和遵循项目计划的同时，承担责任领导
3.数据报告
了解棘手问题并转换数据以获得业务洞察力
作为一名数据分析师，最关键、最重要的任务之一是构建和自动化报告。在我的工作中，我与整个企业的跨职能团队和合作伙伴密切合作，如产品、销售、营销和交付，以了解他们的报告需求。
报告可以是在 Excel 电子表格中呈现的一次性分析，也可以是通过 Tableau 仪表板呈现的重复性分析。对报告功能的良好掌握使我(和其他数据分析师)能够从数据中阐明行动和隐含的见解。
作为数据分析师，您还负责根据需要维护和更新报告。底线是确保报告显示准确的结果。
4.用数据讲故事
数据本身不会说话，也不会影响变化。必须有人来整理和解读。
比方说，你被要求跟踪日常产品库存的变化，重点是假期。从分析中，您确定了几个需求低、仓库库存大的产品，每个季度都重复。你喜欢用文字来讲述故事，还是用视觉效果来讲述一个深入的故事，从而引发一场引人入胜的对话？
传统上，视觉效果在演示过程中需要更多的关注，并注重更好的沟通。在当今世界，高管和高层领导要求通过一站式服务快速高效地做出决策。
我做过多个高管仪表盘，也称为战略仪表盘，其目的是向高管提供问题陈述的全面概述、问题陈述相对于既定 KPI 的表现以及解决任何问题的步骤。
通过数据讲述故事的理念，我们的目标是在任何需要的时候提供更新的近实时数据，以做出有效的数据驱动型决策。
5.每天磨练商业头脑！
作为数据分析师，我再怎么强调尽可能深入了解业务的重要性也不为过。
虽然商业敏锐度没有单一的定义，但我将该术语理解为将业务问题转化为数据并将其连接回业务影响的能力。
如果不询问涉众的业务背景，我永远无法进行分析。对于手头的任何分析，除非你了解业务，否则你永远不会知道模型中的错误对业务意味着什么，为什么在产品推出后，一个人口较少的县的数字会被夸大，等等。
这也是为什么金融分析师或医疗分析师的职位描述需要有商业经验或领域知识的原因。在缺乏相关业务理解的情况下，你的分析往往会失去它应该产生的本质和影响。
每天学习你的业务领域！
这就是我的博客的结尾。感谢您的阅读！请在关于您的数据之旅的评论中告诉我，您希望在 2022 年探索什么！
如果你喜欢阅读这样的故事，可以考虑从这个 链接 注册成为一名中等会员！
数据帐篷快乐！
Rashi 是一名来自芝加哥的数据奇才，他喜欢将数据可视化，并创造富有洞察力的故事来传达商业见解。她是一名全职的医疗保健数据分析师，周末喝一杯好咖啡，写一些关于数据的博客……
我在麻省理工学院人工智能研究实验室工作一年所学到的 5 件事
原文：https://towardsdatascience.com/5-things-i-have-learned-working-in-an-mit-ai-research-lab-for-a-year-a65b4fcaef31
它如何改变了我对生活、知识、真理的看法，以及它对人类意味着什么
2022 年 1 月，我在麻省理工学院的圆顶前被寒风彻底吹倒。
嗨大家好！我叫 Mike，是麻省理工学院大脑和认知科学系(MIT BCS)的一名研究软件工程师/ML 工程师。我专门研究 Brain-Score，这是一种测量人工智能有多像大脑的工具。我来这里一年了，2021 年春天从弗吉尼亚大学毕业。
我和你一样，被迫多次滚动到一篇文章的结尾，以获得实际的外卖点，(看看你们这些食谱作家！)，所以本着不做那件事的精神，我将直接进入它。以下是我在麻省理工学院人工智能实验室工作一年来学到的 5 件事——有些事我希望你会觉得有趣或对你自己的旅程有用，有些事深刻地影响了我看待生活、成功、知识和人类本身的方式。
1.当你不知道某事时，承认是可以的。
这是我必须学习的最难的东西，也是我至今仍在挣扎的东西。
不要去想你为什么质疑，干脆不要停止质疑。不要担心你不能回答的，也不要试图解释你不能知道的。好奇心是它自身的原因。当你思考永恒、生命、现实背后的奇妙结构的奥秘时，你不敬畏吗？这就是人类思维的奇迹——用它的结构、概念和公式作为工具来解释人类看到、感觉到和触摸到的东西。试着每天多理解一点。有神圣的好奇心。
——阿尔伯特·爱因斯坦
我老实对你说——在我开始在麻省理工学院工作之前，我认为我很了不起。我刚刚从弗吉尼亚大学毕业，主修计算机科学和认知科学，辅修哲学和数学。我以为我很了解我的东西。然而，当我参加我的第一次每周麻省理工学院实验室会议时，这一切都被抛到了九霄云外——我可能理解了大约 10%—20 %(一个慷慨的上限),自从我第一次在高中三年级遇到物理并想知道实际的角动量是多少(仍然不完全确定)以来，我没有感到那么愚蠢？？).立刻，在接下来的几个星期里，我开始有一些严肃的问题。我在这里做什么？我是否足够聪明来问一个连贯的问题？我的智商是不是低到不能去麻省理工？为什么看起来我只是知道的还不够多？
最终，在与我的导师和其他实验室伙伴的交谈中，我意识到，是的，我只是知道的还不够多，这没关系。这就是我来这里的目的。我是来学习更多的 - 这才是重点！我突然发现，与我同处一个领域的专家们以最大的强度和动力研究这个领域，比我多花了 3 年到 40 年。仅在第一周，我就遇到了至少 5 或 6 个人，他们研究人工智能和神经科学的交集的时间比我活着的时间还要长，对于那些认为自己知道很多的人来说，这是一个令人羞愧但显然令人生畏的事实。我喜欢说这类似于谚语中的“婊子打我的脸”…
然而，真正让我感到困惑的是，这些已经研究这个课题几十年的人，这些在一个领域已经达到绝对顶峰的人，似乎总是在问问题。他们挖得很深。他们挑出每一个主张，每一个数据点，每一条趋势线。如果他们不理解为什么一个结果是重要的，为什么一个样本被排除在外，或者甚至不理解逻辑链本身如何从一个想法的概念流向一个真正的被证伪的假设 他们会问 。我一直注意到，房间里最聪明的人会问这样的问题:“对不起，我只是不明白这个”，或者“你说得太快了，我不能理解你说的话”，或者甚至是一个简单的“你把我搞糊涂了”。
这是一件神奇的事情——它证明了如果听众没有理解某人所说的话，他们没有错，但是演讲者有错。如果你愿意的话，它将“举证责任”，或者理解的责任，转移到了提出的人身上。他们的工作是确保科学是可以理解的，确保同行能够跟上思路，确保他们的论点是连贯的和有纪律的。他们的工作是预测问题，并放慢语速让听众跟上。这也展示了一种伟大的领导特质——这里是我们实验室最资深的成员，我的领导者，谦逊地承认他们不理解某些事情—并一遍又一遍地做这件事。这是一种非官方的承认，即可以提问——对于实验室的新人来说，这是对好奇心本身的认可——这是一种明确的“这是我们这里所重视的，这是我们做事的方式。”因此，我想对任何想在提问中培养这种安全感的经理或领导者说，你首先必须这么做。
起初，这对我来说很奇怪，我不得不去适应它(我第一次做实验报告是我一生中最紧张的两个小时之一)。但是，这又培养了一种神奇的环境，在这种环境中，人们感到安全，承认他们不明白发生了什么，而不是试图伪造他们的知识。现在对我来说，这几乎是总是可以察觉到的——如果有人被问到一个问题，考虑一下，然后以“我不确定，我必须研究一下”或“很好的建议，我必须进行更多的试验才能确定”来结束，而不是试图用一些垃圾词沙拉答案来胡说八道。
那么，这有什么意义呢？关键是，对于专家来说，对于真正的大师来说，一个共同点是他们从来不会停止提问。当他们不知道一些事情时，他们从不停止承认，因为这代表着一个机会，可以弥合理解的差距，提高自己的知识，并在他们所做的事情上做得更好。在我成长的过程中，很多时候在学校问问题经常被视为滑稽的事情——例如，“看看这个愚蠢的家伙，他甚至不知道角动量是什么”——但现在我个人认为这是体面的标志；这个人对自己的知识如此自信，对自己如此自信，对自己的身份如此自信，以至于他们不怕在同事面前变得脆弱。通过思考相反的情况，这一点会更加突出:同事似乎总是胜过你，总是想让别人知道他们有多聪明，总是对自己的职位没有安全感。
重要的是，在任何一个值得该死的安全环境中，这种友好和开放的意识都会如此。最好、最具创新性和包容性的环境将培养这种好奇心和无止境的改进循环。当你不知道某事时，承认是可以的。
2.有时候直言不讳更有效。
诚实、客观的反馈是你能得到的最有价值的东西之一。
“不要粉饰太平——它只会阻碍科学进步。我们没时间听这些废话。”
我的匿名实验室成员，2021 年 7 月
当我第一次被告知我已经被麻省理工学院的实验室录取时，我联系了当时弗吉尼亚大学的一位教授，他在麻省理工学院 EECS 分校获得了学士和博士学位。我基本上是问他“麻省理工学院怎么了，他们和弗吉尼亚大学在文化上有区别吗？那个长相怪异的蒂姆·比弗是怎么回事？为什么波士顿这么贵？"
他告诉了我很多很棒的建议，但我特别记得的是他的“警告”:他告诉我，在麻省理工学院，直率无处不在。如果你有一个愚蠢的想法，人们会告诉你。如果你做得不好，人们会告诉你。如果你的假设是垃圾，人们会告诉你——不管是一对一的还是在一屋子其他博士中。所以我把它记为绝妙的建议，并在几个月后召开了我的第一次实验室会议…
…意识到他是对的。非常正确。我有一些不好的想法，有人当着所有人的面告诉我。我犯了技术错误，被判出局。幸运的是，知道这是我第一次这样做，我的实验室是理解的。但真正酷的是，它发生在这里的每个人身上——不管你是否已经发表了 13 篇科学论文，或者从未发表过。不仅仅是在我的实验室，似乎整个麻省理工学院都是如此——这就是文化。事实上，如果你的听众不断插话和提问，这甚至被视为一种尊重的表现——这意味着他们感兴趣！如果你在这里做报告，没有人打断，那么这可能是一件无聊的事情。
显然，这有可能让不习惯这种方式的人感到不快，包括我刚到这里时的自己。但很快我又意识到这是有原因的——这是获得坦诚、客观反馈的一种方式。这是事实，因为正如#1 所指出的，对知识的探索和对科学前沿的推进在这里是神圣的。这种类型的反馈是有效的——它帮助人们做得更好。如果科学家做得更好，根据定义，科学就会向前发展。这是有效的，节省时间。
所以，我要说的是，给予客观反馈是有时间和地点的，在麻省理工学院，时间和地点实际上是随时随地。这是非常有价值的，因为理论上你可以专注于作品，而不用担心评论是个人的还是针对个人的。对我来说，我意识到它们不是对我个人或迈克本人的攻击——它们是对我的工作的批评，这与我是分开的。在过去的几个月里，我开始寻求这种直言不讳和客观的反馈，因为它在随着时间的推移进行改进和获取该领域的知识方面提供了最“划算”的方式——我们的时间有限，无法尽可能多地学习，所以为什么要回避批评，而不在该反馈时给出反馈呢？
你还可以通过一个人如何处理对其工作的批评来判断他的很多方面——他们是否保持沉默并为自己辩护，或者似乎在内部庆祝，因为你刚刚强调了他们变得更好或学习更多的方法。这种直言不讳的概念是一把双刃剑——高风险但高回报——所以在你的生活中要小心使用。但是有时候，直率更有效。
3.采取学徒心态
通往精通的道路很漫长，但非常值得。
“这样想吧:失败有两种。第一个是因为你害怕，或者因为你在等待最佳时机，所以从来没有尝试过你的想法。这种失败你永远无法吸取教训，这样的胆怯会毁了你。第二种来自大胆和冒险的精神。如果你以这种方式失败了，你学到的东西远远超过了你对自己声誉的打击。一次次的失败会磨练你的精神，让你明白事情必须怎么做。”
― 罗伯特·格林， 精通
或者你们当中那些以前关注过我的文章的人，你们知道我是一个积极的读者，并且参加了三年多的每周一本书的挑战。我读过一些真正精彩的书，也读过一些我不得不停止阅读的书，因为我认为它们纯粹是垃圾。无论如何，我可以说真正改变了我对生活和工作的思考方式的书籍之一是罗伯特·格林的《掌握》(上面引用的)。
这本书有很多我喜欢的地方——格林以直接、实用的方式写作，并穿插了实证、真实的例子，说明他的假设为什么有效/它们如何得到案例研究的支持。这本书跟踪了他们领域的几位大师，从舞蹈到拳击到工程，跨越了许多社会经济背景和多样性，并提取了共同的特征。
我学到的是:要成为某方面的大师——也就是说，要真正理解一个领域并产生影响，你必须经历不同的发展阶段。在你的正式教育之后，你可以进入一个“学徒”阶段，在这个阶段，用格林的话来说，你就像一个研究新社区的人类学家。你必须学习做事的方式，规则，包括显性的和隐性的，以及如何取得进展。这可能会持续 3 到 10 年，但总的来说会给你这个领域的基础知识。接下来，你进入所谓的创造性活跃阶段，在这个阶段，你开始拓展并发挥你自己的创造性独立性。最后，你进入了精通阶段。《精通》这本书本身非常值得一读，我发现其中几乎每一行都可以引用。
主要的收获是，精通一门学科或领域本身就是一种投资；对一些对你有意义的事情的内在追求，一些你在空闲时间思考的事情，一些你记得在童年时喜欢或被吸引的事情。掌握了一门学科，你就与自己和谐相处，因为你正在以一种有意义的方式发挥你的全部潜力。简单地说，这是对未来幸福和满足的投资，也是避免陷入没有出路的职业生涯或随着年龄增长而不快乐的一种方式。日本人的 Ikigai 概念也非常相关，值得自己分析。
我目前正处于人工智能/神经科学的学徒阶段，我可以绝对明确地说，这种思维模式消除了我的冒名顶替综合症的感觉——事实上，当谈到我对同事们的领域知识时，我已经承认我的劣势，因为他们已经做了更长时间，知道的比我多得多——再次呼应#1，这没关系！对我来说，重要的是，如果你发现自己处于某种学徒阶段，或者刚刚开始某个地方，尽可能快地学习你所在领域的知识。你想把他们的知识提取到你自己的知识中，并把他们的掌握作为启动自己旅程的一个引导。合适的导师绝对是无价的。提出问题，在寻求知识的过程中保持热情，在学习的时候永远不要有优越感——任何和你领域相关的事情，甚至是看起来不相关的事情，都值得学习。
用格林的话说，“服从理想的学徒制度”。这将在以后的生活中带来幸福和工作保障，也是我所知道的对抗一直存在的骗子综合症的第一方法。所以，如果你刚刚起步，或者甚至正处于职业生涯的中期，采取一种学徒的心态。
4.科学可以深刻地影响一个人的世界观。
这似乎是显而易见的，但比表面上看起来更微妙。
"科学是一种思维方式，而不仅仅是一种知识体系。"
——卡尔·萨根
在美国，似乎有一种“反科学”的感觉正在上升，这种感觉非常令人不安，原因有很多。卡尔·萨根(Carl Sagan)在 1996 年就曾非常、甚至是非常可怕地这样预测过:
“我有一种预感，在我的子孙后代的时代，美国将是一个服务和信息经济的时代；当几乎所有的制造业都转移到其他国家时；当令人敬畏的技术力量掌握在极少数人手中，甚至没有人代表公众利益能够抓住问题；当人民失去了设定自己的议程或明智地质疑当权者的能力时；当我们紧握着水晶，紧张地查阅我们的星座运势，我们的批判能力下降，无法区分什么感觉良好，什么是真实的，我们几乎没有注意到，滑回到迷信和黑暗中…
美国人的低俗化最明显地体现在影响力巨大的媒体中实质性内容的缓慢衰减、30 秒钟的新闻片段(现在缩短到 10 秒钟或更短)、最小公分母的节目、关于伪科学和迷信的轻信的介绍，但尤其是一种对无知的赞美”
― 卡尔·萨根， 恶魔出没的世界:黑暗中的科学蜡烛
吓人吧？似乎对科学事业本身持怀疑态度正变得越来越时髦，在谷歌上快速搜索一下“反科学运动”就能支持我的观点。那么有什么方法可以解决这个问题呢？我希望根据我在麻省理工学院一年来的观察，提供一些帮助我在新闻两极化、利益冲突和有偏见的故事时代保持理智的见解:
首先，就像我上面第一点所说的，质疑一切。没有任何东西，我的意思是没有任何东西，可以免于审查和适度的怀疑。遇到文章，看看是谁写的。在谷歌上搜索一下，看看他们是否写过其他东西，或者是否有任何经济动机来推动他们的叙述。在你做出结论之前，交叉参考来源并从多个来源确认。问问为什么有人想为他们正在争论的事情争论，问问他们能从正确中得到什么。如果一个观点只出现在一个地方，而那个地方有偏见的历史，那么你很可能只听到故事的一面。
第二，分析论点。寻找逻辑中的常见错误，如人身攻击、非逻辑推理和各种偏见，如选择和确认偏见(第一种偏见因其难以发现和可能产生的深远影响而臭名昭著)。从开始到结束，跟随作者如何提出他们的论点。在哲学中，确保论点是有效的(前提是正确的)和合理的(结论来自前提)。当心错误的暗示、无根据的主张和操纵的图表。为任何大的主张寻找证据，正如克里斯托弗·希钦斯所说:
“没有证据就可以断言的东西，也可以在没有证据的情况下被驳回”
最后，承认每个人都是人。人会犯错，数据往往不完整或有偏差；思想会改变，如果有新的证据，那么也应该改变。这是成熟的做法——当新的事实出现时，让旧的观念消失，并承认任何错误。
我希望这些话题能有助于我们在这个看似后真实的世界中导航。我发现自己现在更深入地挖掘前提或论点，并仔细分析结论是如何得出的，我还有很长的路要走。萨根的开场白说得很好——科学是一种思维方式，开明和怀疑之间的细微差别。但关键是，通过一点实践，科学可以深刻地影响一个人的世界观。
5.成为一个有意识的、工作的人类本身就是一个非凡的壮举。
大脑出现故障的方式似乎比正常运转的方式多。
“我不能假装我没有恐惧。但我最主要的感觉是感激。我爱过也被爱过；我被给予了很多，我也给予了一些回报；我阅读、旅行、思考、写作。我和这个世界有过交流，作家和读者的特殊交流。
最重要的是，在这个美丽的星球上，我是一个有意识的生物，一个有思想的动物，这本身就是一种巨大的特权和冒险。"
― 奥利弗·萨克斯， 感恩
人们很容易迷失在当今世界的日常琐事中。需要提交东西，需要发送电子邮件，需要预约。孩子们必须被接走，晚餐必须以某种方式出现。但是，当你退后一步，真正开始审视这些事情是如何表现出来的，你的大脑是如何回复电子邮件和查看塔可钟外卖菜单的，你开始真正对这些微小的任务有多么复杂感到敬畏。从光子击中你的视网膜到你的大脑意识到你正在看的东西实际上是一个蘸了调味汁的美味的意大利煎饼，许多令人惊讶的复杂事情发生了。神经元放电，这些信号被结合并传播成复杂的神经表征，然后在某个地方，类似于标签“Chalupa！”是吐出来，让我向等待我点菜的可怜灵魂确认，是的，我要牛排，不要鸡肉。
我在这篇咆哮中的观点(不幸的是没有赞助)是，可笑的复杂过程发生了，让你每天生活，并且有时，如果不是大多数时候，这些过程的本质没有被聚焦，它们的含义也没有被聚焦。我的意思是，你的大脑能够做出的惊人的事情往往被隐藏起来，并被认为是理所当然的，我可以告诉你，事情出错的方式比正确的方式多得多。多巴胺水平可能会失控，出现病变，信号丢失或被不恰当地重定向…可能的故障列表几乎是无穷无尽的。然而，你却在这里，不顾一切地读着这篇文章。
我请你花一点时间，意识到是什么让你能够偶然发现我的文章，阅读它，并一起存在——这种事情发生的几率几乎是无限小的，然而，你又在这里。在某个时刻，你将不复存在；这是一个令人不安的事实，你死后会发生什么谁也说不准。我确实知道此刻什么是真实的:这些快乐、悲伤、希望、胜利和失败、痛苦和渴望、狂喜和难以忍受的痛苦的有形时刻非常真实。它们是使我们成为人类的非常的东西，也是将很难在人工智能中很快复制的非常的东西。
一个人工智能是否能经历这样的事情是一个非常有争议和有争议的话题，对此我已经写了很多，惹恼了我的实验室同事，但我还没有找到答案；我根本不知道会发生什么。我只知道我是人类，因此我被灌输了几千年的进化遗产，就像你一样。我们来自一长串杰出的人类，希望会被一长串更杰出的人类所取代。
想想那些在你存在之前就已经湮没在历史中的故事——有着数千年历史价值的亲密爱情故事，腐败的背叛和邪恶的故事，不可思议的勇气和牺牲的故事，逆境战胜一切的故事——生存的故事。在许多方面，这些故事和它们的主题与 10，000 年前完全相同，只是人物和背景不同——但有一个主题跨越了几个世纪，一个短暂的存在和永恒的时间流逝:
我今天坐在同一个地方
在过去的岁月里，其他人来坐下。
一千年后还会有人来。
谁是歌手，谁是听众？
——阮公楚，越南诗人
所以，不管你生活中发生了什么，好的或坏的，不管日常生活中无聊的任务，也不管你个人的成功和失败:只要记住成为一个有意识的、工作的人本身就是一个非凡的壮举。
鸣谢:格雷戈·拉科齐 via Unsplash
感谢你的阅读，你可以在 Medium/TDS 上关注我，获取技术文章和哲学文章。你也可以在LinkedIn上关注我。我希望很快有自己的网站，有邮件列表，如果你感兴趣，请继续关注。另外，如果你想在我写故事的时候得到通知，订阅我的邮件列表——我希望每周至少发布一次新故事。妈妈，如果你正在读这封信，我爱你。
关于作者
迈克·弗格森是麻省理工学院吉姆·迪卡洛实验室的计算研究开发人员。他致力于大脑评分，这是一个测量人工神经网络有多像大脑的工具。他于 2021 年春季毕业于弗吉尼亚大学，获得了计算机科学和应用数学学士学位，以及认知科学和哲学学士学位。他是每周一本书挑战的参与者，在近四年的时间里，他阅读了超过 170 本关于人工智能、哲学以及对人类意味着什么的书籍。他在弗吉尼亚大学给 150 多名学生讲授了 3 个学期的人工智能课程，并在 2021 年夏天在南加州大学实习人工智能研究。
我从与高级工程师合作中学到的五件事
原文：https://towardsdatascience.com/5-things-i-learnt-by-pairing-with-a-senior-engineer-for-2-weeks-96150e5c8500
由 Unsplash 上的微妙电影艺术拍摄的照片
TLDR；开始构建一个 API 来提供预测，一个高级数据工程师介入来协助一个新功能，我们结束了两个星期的合作来重构大部分代码库。以下是 5 个要点。
加入数据团队后，我的任务是启动一项新的服务，从我们基于内容的推荐模型返回预测。该团队的机器学习模型被捆绑在各种各样的 Juypter 笔记本上，这些笔记本是在项目的模型构建阶段创建的。为了支持在毫秒级响应时间内提供建议，并将其扩展到每秒 1000 个请求，很明显模型需要由一个专门构建的 API 来提供服务。
需求很明确，我对需要做的事情很有信心，所以我开始工作 单干 构建 API 服务。抛开栈的技术细节，我选择了一个框架、验证库和测试包，并开始将它们连接在一起，以使我们的版本 1 工作。经过一点基础设施的争论，我得到了 API 服务模型的建议！检查检查✅ ✅
嗯，我也是这么想的……
这是我开始与高级工程师配对，为服务添加功能并修复一些 bug 的时间。
作为一名大三学生，带着一套不同的经验来到团队，很明显代码库中有一些元素需要重构，有人可能会称之为清理，实际上，这更像是清理！
当我们克服项目的缺点时，我有幸学习了一个高级数据工程师的思维过程。我也很幸运，这位工程师有耐心和精神空间来为项目重构的需要详细地完成每个决定——这就是我如何能够真正从经验中学习并收集这 5 个要点。
从一开始，我就稍微关心另一个人，一个前辈，密切地梳理我的代码库。但是我知道，为了让项目更上一层楼，为了让团队采用它，这是必须的。
(1)了解您的需求并规划您的解决方案
为了构建在专业工作环境中有用的东西，代码是带着目的、清晰和意图编写的。这位高级工程师毫不犹豫地整合问题，以更好地了解需求。
磨砺细节和强调需求的重要性本身就是一种技能。我认识到，即使拥有大量的经验、资历、知识和技能，解决问题和挑战当权者的要求也不会感到羞耻。
一旦问题解决了，我们就把技术需求分解成票务系统中的逻辑工作块。这有助于我更详细地考虑解决方案以及任何依赖项。
这一过程有助于我们保持专注，并确保我们正在解决解决方案所需的紧迫需求。
(2)不要低估基础设施知识
在不接触基础设施的情况下，您所能做的价值是有限的，尤其是对于一个尚未投入生产的年轻项目。
在重构过程中，我们深入探讨了以下技术:
- Terraform 将我们的基础设施详细描述为符合安全需求和部署模式的代码
- Docker标准化部署容器，设置运行时环境
- 为您的 CI/CD 管道编写部署和测试脚本
(您的设置可能会有所不同，但会有相似的工具)
高度了解这些工具可以让一个人在强大的开发实践中变得非常有效，并减少环境变化，例如在您的机器上测试，而不是在部署的环境中运行。
(3)避免过度设计
在反思我的代码时，我不断陷入的常见陷阱是试图让我的设计更加理论化，包括；将数据结构规范化为高阶组件，并努力迎合未来的特性。这对我最初的设计是有害的，因为我过度工程化了服务的组件，这使得为版本 1 建立项目变得更加困难。当我提到过度工程时，我会想到:
- 建造你显然不需要的东西
- 创建抽象层，这些抽象层可能只在未来需要
- 以复杂性为代价引入更多概念
现在我很清楚良好工程和过度工程之间的区别，因为我们编写的新代码具有以下特征:
- 清晰的关注点分离
一个函数/类/模块应该有一个清晰的目标。这可能意味着有更多的文件、函数和类，但是这些元素中的每一个都将更清楚它们服务于什么目标，并且更容易更改(和测试) - 简单接口
例如，当调用一个函数时，不是传入整个对象，而是只传入函数需要的参数。这可能意味着你要传入更多的参数，但是它允许你的代码更有目的性和目的性。这使得测试和维护变得更加容易
(4)让您的测试更进一步
重构之后，很明显，项目受益于以下各方的共同努力:
- 增加测试覆盖率——即使测试代码库的元素是困难和乏味的
- 单元级测试——测试规模更小，更简洁
(这与“创建清晰的关注点分离”齐头并进，因为每个元素都有自己清晰的目标。) - Stub、mock、patch——为了恰当地对代码而不是其他元素进行单元测试，需要使用 stub 来隔离代码
- 将您的测试镜像到您的代码中——这将有助于维护和确保适当的覆盖率
我看到了一个人可以测试多少东西，以及它所带来的价值。很明显，较高层次的测试会丢失较低层次的覆盖率，在较低层次会出现愚蠢的错误和难以追踪的小错误。通过将代码的较小部分镜像到我们的测试中，知道要测试什么以及代码的不同元素的边界变得非常容易。
(5)命名你的元素几乎和你的架构一样重要
不管幸运与否，命名代码会带来很多假设。命名事物的方式不仅应该描述代码应该做什么，还应该描述如何使用它以及它将如何响应。
我发现我没有足够重视元素的命名。你不会总是一开始就得到正确的名字，所以有时故意创建一个像“rename _ this _ variable _ that _ returns _ x”这样的临时名字将允许你继续工作，然后迫使你返回一个更合适的名字，最好地描述它到底做什么。
你给你的元素起的名字是为了你未来的自己，也是为了你的队友。所以我的建议是，考虑一下你的队友会如何理解这些代码，即使你可能是唯一一个从事这项工作的人，这也会对你未来的自己有所帮助。为了对如何命名事物有一个感觉，看看团队创建的其他你欣赏的代码库，或者甚至用一些名字接近其他队友，看看你得到了什么样的初步反应。通常，如果您对名称不确定，可以进行改进😃。
如果你有兴趣了解更多关于这个堆栈的信息，或者以上的任何细节，请在评论中告诉我，我会尽我所能给你回复，无论是另一个帖子还是回复！
我希望熊猫图书馆能做的 5 件事
原文：https://towardsdatascience.com/5-things-i-wish-the-pandas-library-could-do-e9017c127779
讨论熊猫的五个微妙局限
Georg Bommeli 在 Unsplash 上的照片
多亏了 Pandas 库，用 Python 处理、分析和处理表格数据从来没有像今天这样轻松和直接。
目前，Pandas API 提供了广泛的功能集合来管理表格数据，旨在为几乎每个数据科学项目服务，例如:
- 输入输出操作
- 数据过滤
- 表连接
- 数据可视化
- 重复数据处理，等等，你可以在这里阅读。
虽然 Pandas 确实是几乎所有使用表格数据的数据科学家的首选工具，但在我的项目中使用它让我意识到了它的一些主要警告/限制，我希望在本文中讨论这些。
因此，这篇文章提出了我希望熊猫在现实世界的表格数据集领域能够做的五件事。
本文的亮点如下:
#1 我希望熊猫可以并行读取一个 CSV 文件# 2 我希望熊猫可以一次读取多个 CSV 文件# 3 我希望熊猫数据帧使用更少的内存# 4 我希望熊猫可以用于大型数据集
我们开始吧🚀！
#1 我希望熊猫可以并行读取 CSV 文件
不幸的是，Pandas 对 CSV 文件的输入/输出操作是序列化的，这意味着 Pandas 没有固有的多线程支持。
首先，读取 CSV 文件上下文中的序列化意味着 Pandas 一次只能读取 CSV 文件中的一行(或一行)数据。下面的动画演示了这一点:
在熊猫中阅读 CSV(GIF by author)注意:CSV 文件是一个文本文件，上图并不是 CSV 的样子。这是为了直观地阐述观点。
和输入操作类似，输出操作也好不到哪里去。Pandas 也以序列化的方式将数据帧存储到 CSV 文件中。
串行输入和输出操作的过程使它变得非常低效和耗时。
可能的替代方案
根据我的研究，有两种潜在的解决方案可以用来提高总的输入输出运行时间。
- 更喜欢使用其他文件格式，如泡菜、拼花和羽毛来读取和存储数据帧。
除了速度快之外，这些格式存储数据占用的磁盘内存也更少。请在下面我的博客中阅读有关这些文件格式的更多信息:
- 使用像 DataTable 这样的库，它们不像 Pandas，拥有并行化能力。
在下面我的博客中阅读更多关于数据表的内容:
#2 我希望熊猫可以一次读取多个 CSV 文件
假设您有一个包含多个 CSV 文件的文件夹，您需要读取这些文件并将其作为 Pandas 数据帧导入。
在 Pandas 中实现这一点的唯一方法是遍历文件列表，一个接一个地读取它们，如下所示:
使用熊猫读取多个 CSV 文件(GIF 由作者提供)
上面的图示可以通过编程方式演示如下:
由于 Pandas 中缺乏多线程支持，一组可能并行读取的文件应该一个接一个地读取，导致运行时间增加和资源利用不足。
可能的替代方案
DataTable 库再次成为 Pandas 的一个很好的替代方案来解决这个限制。
使用 DataTable，您可以高效地读取多个 CSV 文件。下面演示了这一点:
在下面我的博客中阅读更多关于运行时性能的内容:
#3 我希望熊猫数据帧使用更少的内存
Pandas 数据帧非常庞大，而且内存使用效率很低。例如，假设我们创建了一个包含两列的数据帧，如下所示:
接下来，让我们使用dtypes属性确定 Pandas 分配给上述数据帧df的两列的数据类型:
默认情况下，Pandas 总是将最高的内存数据类型分配给列。例如，一旦熊猫将上面的colA解释为整数值，就有四个可能的子类别(有符号)可供选择:
int8: 8 位整数数据类型，跨越来自 2⁷].-2⁷的整数int16: 16 位整数数据类型，跨越从[-2 ⁵，2 ⁵].]的整数int32: 32 位整数数据类型，跨度为[-2，2 ]的整数。int64: 64 位整数数据类型，跨越来自【2⁶-2⁶】的整数。
然而，Pandas 将int64指定为整数值列的数据类型，而不考虑列中当前值的范围。我们注意到colB有类似的数据类型行为。
可能的替代方案
为了优化内存利用率，您可以探索一个方向，我称之为 min-max-reduce 分析。
第一步是找到感兴趣的列中的最小值和最大值。
最后一步是删节( reduce )列的数据类型。
由于当前范围的值可以被压缩到int16数据类型中(因为-2 ⁵ < 10000(最小值)< 30000(最大值)< 2 ⁵)，我们将使用astype()方法将数据类型从int64转换为int16，如下所示:
通过这个简单的单行数据类型转换，colA列使用的总内存减少了大约 40% 。
通过类似的 min-max-reduce 分析，您还可以改变其他整型和浮点型列的数据类型。
在我的博客中阅读更多关于内存优化技术的内容:
#4 我希望熊猫可以用于大型数据集
如上所述，Pandas 没有固有的多线程支持。因此，无论数据的规模如何，Pandas 将始终坚持单核利用率，从而导致运行时间增加，这与数据的大小成正比。
作者的 Doge meme(使用imgflip.com创建)
例如，考虑一个实验来研究数据帧大小和在数据帧上执行函数的运行时间之间的相关性。
我们从包含一千行和两列的随机数据帧开始。
接下来，我们定义一个函数，它接受数据帧的一行并返回其总和。该功能实现如下:
在每次迭代中，我们确定计算数据帧中每行总和的时间。为了消除随机性，我们将重复每次迭代runs次。在每次迭代结束时，我们将把数据帧的大小增加两倍。
该实验在下面实现:
下图描绘了迭代与运行时的关系图。随着每次迭代，数据帧的大小加倍，Pandas 的运行时间也加倍，这表明 Pandas 的运行时间总是与数据帧的大小成比例，并且它从不采用并行化。
数据帧与运行时图(图片由作者提供)
可能的替代方案
Pandas 非常适合处理小型数据集。然而，随着数据规模和管道复杂性的增加，作为一名数据科学家，您应该避免利用它，因为上面讨论了其深刻的运行时警告。
如果您的目标是将项目投入生产，PySpark 是理想的方法。其他备选方案包括 Terality、Vaex、DataTable 和 Dask——主要推荐用于大型数据集上 Pandas 的本地计算。
#5 我希望熊猫支持像 SQL 这样的条件连接(不知何故)
使用 SQL 的人喜欢编写复杂的连接条件来合并表的自由，不是吗？
顾名思义，条件连接超越了简单的基于等式的合并条件。换句话说，您可以在多个表的字段之间建立基于条件而不是相等的连接。
例如，假设您有两个表，table1和table2:
目标是基于以下条件连接这些表
(table1.col1 = table2.col1 + 2) and (table2.col2 >= table2.col2 - 2) and (table2.col2 <= table2.col2 + 2)
SQL 连接
上面的条件连接在 SQL 中非常简单。SQL 查询在下面实现，生成查询后的输出:
熊猫加入
Pandas 只能在数据帧上执行基于等式的连接。换句话说，只有当连接列中的值相同时，Pandas merge()方法才会连接两个记录——消除了条件连接的范围。
因此，使用 Pandas 的merge()方法执行条件连接的几种方法是:
- 使用联接条件中定义的操作创建联接列，并对新列执行合并。
- 执行交叉连接并过滤数据帧。在大型数据集的情况下，这可能极具挑战性。
下面展示了方法 1 和方法 2 的组合。
首先，我们创建两个数据帧来合并并定义连接条件。
(table1.col1 = table2.col3 + 2) and (table2.col2 >= table2.col4 - 2) and (table2.col2 <= table2.col4 + 2)
由于连接条件由不等式组成，让我们暂时把它们放在一边，先对等式执行连接(table1.col1 = table2.col3 + 2)。之后，我们将过滤结果，以纳入接下来的两个条件。
首先，我们将在table2中创建一个新列。姑且称之为col3_1。
接下来，我们将对来自table1的col1和来自table2的col3_1执行连接，然后根据连接条件中剩余的条件过滤得到的记录。这在下面实现:
可能的替代方案
PandaSQL 是一个流行的 python 包，它混合了 Pandas 和 SQL，允许您在 python 环境中利用 SQL 语法的强大功能。
因此，PandaSQL 使您能够使用 SQL 语法查询 pandas 数据帧。要执行类似 SQL 的连接，可以探索 PandaSQL。
然而，在 Pandas 数据帧中使用 SQL 的便利性是以运行时间为代价的。我在之前的博文中讨论过这个问题:
结论
总之，在这篇文章中，我讨论了熊猫的五个主要局限性，以及如果你陷入其中任何一种情况时的解决方法。
Pandas 非常适合处理日常的表格数据分析、管理和处理。
但是，假设您正在开发一个生产级别的解决方案，或者有大量的数据要处理。在这种情况下，Pandas 将不会对您有太大的帮助，因为它没有并行化和资源利用不足的限制。
感谢阅读！
作者的迷因(使用imgflip.com创建)
🧑💻成为数据科学专家！获取包含 450 多个熊猫、NumPy 和 SQL 问题的免费数据科学掌握工具包。
✉️ 注册我的电子邮件列表 不要错过另一篇关于数据科学指南、技巧和提示、机器学习、SQL、Python 等的文章。Medium 会将我的下一篇文章直接发送到你的收件箱。
简历中阻碍你获得第一份数据科学工作的 5 件事
原文：https://towardsdatascience.com/5-things-in-your-resume-that-are-keeping-you-from-getting-your-first-job-in-data-science-1a4d474ff3e4
解决这些问题会让招聘人员看你简历的时间超过 7.4 秒
里卡多·特里梅洛尼在 Unsplash 上拍摄的照片
学习所需的技能有时被认为是成为数据科学家过程中容易的一部分。最困难的部分往往是在申请工作的时候。
如今，许多人可以自称为数据科学家，尽管他们提供影响的能力和才能各不相同，这意味着你需要从人群中脱颖而出。
然而，在现代求职过程中，如果你不能亲自与招聘人员交谈，你甚至很难迈出第一步。随着我们中的许多人把简历投到了空白的地方，我们很难知道我们是否给人留下了正确的印象。
幸运的是，有一些简单的方法可以美化你的简历，确保招聘人员比平均的 7.4 秒看得更久。
以下是简历中阻碍你获得数据科学领域工作的五个不同因素，以及解决它们的五种方法:
1.表示技能熟练程度的技能水平条
简历制作的最新趋势之一是技能的图形化表示，使用技能条、百分比或其他图形来展示你的技能掌握水平。
来源:麦迪逊·亨特
虽然这一选项在许多准备发送给时尚、创业型公司的简历模板上都有，但它对你不利，甚至可能在他们见到你之前就让你在求职过程中打折扣。
首先，技能等级对招聘人员来说毫无意义。除非你开发了一个评分系统，否则招聘人员怎么知道“Python 熟练程度 4/5 星”是什么意思？此外，为了帮助招聘人员更好地理解你的评级系统，你需要为每项技能制定标准和客观测试，这样你就可以解释为什么你会给自己打这个分数。
第二，技能条是主观的。简而言之，人们在任何事情上都不擅长给自己打分，越聪明的人越倾向于给自己擅长的技能打分，越不聪明的人越倾向于给自己不擅长的技能打分。
第三，你给自己技能打分的能力完全不靠谱。如果没有一个可靠的、广为人知的测试量表来确定你的技能熟练程度，比如全球公认的欧洲通用语言参考框架，你自己确定自己技能水平的能力是完全不可靠的。例如，如果你告诉某人你的西班牙语达到了 B2 水平，他们可能会明白你的语言熟练程度。然而，如果你告诉某人你懂 80%的 Python，他们将不知道你的能力是什么——因为，让我们面对现实吧，80%的 Python 知识看起来像什么？
最终，在简历中使用技能等级栏会让你在踏入职场之前失去很多工作机会。招聘人员可能认为你是一个理想的候选人，但他们可能更愿意面试一个对 Python 有 80%熟练程度的人，而你只有 70%。
取而代之做什么
不要用技能水平条，而是讨论你在描述以前的工作和项目时使用的技能，来证明你使用这项技能有多长时间了，你用这项技能做了什么，以及使用这项技能产生了什么影响。
2.缺乏展示现实世界解决问题的个人项目
科技招聘人员最常见的抱怨之一是，候选人缺乏解决现实问题的技能。
大学里的问题很容易解决，只要它清楚地摆在你面前，有开头、中间和结尾，而且教授愿意回答你关于如何获得预期结果的问题。
然而，现实世界会向你抛出没有具体开始、中间或结束的问题，可能只有一个模糊的业务问题，现在你的工作是使用数据来回答。你申请加入的工作环境并不像你在大学或编码训练营经历的那样干净，这意味着你需要发展你在现实世界中解决问题的技能。
取而代之做什么
这里的关键是要记住一句老话，“秀，不要说。”
虽然很容易告诉雇主你已经通过你的独立研究项目解决了许多现实世界中的问题，但是如果你向他们展示你解决的问题以及你是如何解决的，会更有影响力。
与你的简历相关联的个人作品集会在这方面帮到你。在那个投资组合中，你想开发几个项目，找出你的目标行业中的具体问题。例如，如果你想从事气候科学，在你的文件夹中放满分析空气污染水平的项目，并描述污染水平如何与对比大城市的住院率相关联。
3.不适合这份工作的编程技能
第一次找数据科学工作的求职者将在简历中列出他们精通的 20 种编程语言，而不是专注于雇主在招聘广告中专门寻找的语言。
列出 20 种编程语言或技能对于一个只想知道你是否会使用 Python、Excel 和 SQL 的雇主来说是没有用的。此外，这也表明求职者缺乏准备，因为这份简历是为求职过程设计的“一刀切”的解决方案。
记住，多并不总是好的。招聘人员更希望看到他们公司正在寻找的编程语言和技能的具体经验证据，而不是 20 种不同语言的随机经验。
招聘人员倾向于只看简历 7.4 秒，这意味着如果他们不得不从你的技能列表中筛选出适用于他们公司的技能，那么你已经成为一个容易被淘汰的候选人。
取而代之做什么
仔细浏览招聘广告，突出他们需要的语言和技能，为每份工作申请准备一份量身定制的简历。然后，通过给出你的语言或技能能力的具体例子，并链接到展示你能力的项目，让招聘人员容易理解(再次强调，“展示，不要说”)。
关注特定公司正在寻找的语言和技能很重要，因为他们的业务流程围绕着这些语言。除非一家公司雇佣你来建立他们的数据分析流程，否则他们寻找的是一个能够使用他们所需的语言和技能无缝融入他们现有团队和流程的候选人。
简而言之，重点应该是让招聘人员容易想象你成功地成为团队中有价值的一员。
4.关注算法和代码，而不是结果
正如肯·吉的文章数据科学简历错误避免所言，数据科学家的价值在于他们对公司的影响以及他们的工作产生的结果。
如果你的简历更多地关注你用来解决问题的奇特算法，而不是解决问题的结果，招聘人员可能不会相信你的分析所产生的影响。
取而代之做什么
不要把你的整个项目描述都集中在你使用的算法或者你写的代码上，而是在你描述你的分析所产生的影响或者你的项目的结果的地方添加句子。
这种描述应该包括可量化的信息，如百分比、增长指数和货币价值。例如，你可以说你为你所在城镇的一家小企业做的公益项目帮助他们提高了流程效率，使他们的收入立即增加了 30%。或者，你可以说，你对大气污染水平的分析表明，到 2100 年，全球气温可能上升 2 摄氏度。
向招聘人员详细介绍你的项目所产生的影响或结果，会让他们觉得你有能力对他们的公司产生积极的影响。
5.没有终身学习的迹象
如前所述，数据科学家的价值取决于他们对公司的影响。这意味着数据科学家必须在整个职业生涯中保持相关性，不断学习新技能，自学所在行业的新趋势，并接触对公司流程更有效的最新技术。
没有任何继续教育的迹象，无论是通过课程、训练营还是个人项目，或者当前时间与你上一次参加的课程之间的巨大差距，都可能向招聘人员表明你对数据科学家至关重要的终身学习不认真。
取而代之做什么
时常做一些个人研究项目，向招聘人员展示你一直在寻求提高技能和学习新东西。
每个新项目不必很大，但它应该集成一些新技术、算法或思维过程来解决现实世界的问题。每个项目都应该在你的简历中用一个简短的句子来描述，抓住你技能的进步和你要解决的问题。
将链接添加到您的项目存储库或文件夹是让招聘人员亲自了解您的工作的好方法。
关键要点
- 不要用技能水平条来表示技能熟练程度，因为它们对招聘人员来说毫无意义，也因为它们不能可靠地表明你在某项技能上的能力。
- 与你的简历相关联的个人作品集可以让招聘人员直接看到你的工作，并让他们感受到你解决现实问题的能力。
- 把你的简历集中在每个独特工作所需的技能和编程语言上。
- 使用可量化的变量来表示项目的影响和结果。
- 在整个求职过程和职业生涯的剩余时间里保持自我教育，以保持相关性——你为作品集完成的每个新项目都应该融入新的技能，向招聘人员表明你对终身学习的承诺。
订阅将我的故事直接发送到您的收件箱:故事订阅
请成为会员，使用我的推荐链接获得无限制的媒体访问权限(我将收取少量佣金，无需额外费用):媒体会员
2021 年，作为一名数据科学家，我实际做了 5 件事
原文：https://towardsdatascience.com/5-things-that-i-actually-did-at-work-as-a-data-scientist-in-2021-e46d3a0d6dab
对数据科学家实际工作的一瞥
约书亚·厄尔在 Unsplash 上的照片
介绍
我经常被问到的一个问题是“你在工作中到底做些什么？”这是一个很好的问题。你在网上看到的数据科学项目和 Kaggle 笔记本代表了与数据科学家在工作中所做的(或我在工作中所做的大部分)不同的现实。
所以，我想和你们分享 2021 年我在工作中做的 5 件事。让我们开始吧！
请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！
1)群组分析
作者创建的图像
什么是队列分析？
群组分析包括构建群组图表，如上图所示。队列图是行为分析中常用的数据可视化的数据。
群组图表的结构通常如下:
- 每一行代表不同的群组或不同的用户群。在上图中，您可以想象每一行都代表按首次注册日期划分的用户。
- 列表示周期，无论是日、月还是年。
- 这些值表示感兴趣的指标如何随着时间的推移而发展。
它在商业环境中有什么用？
当您想要了解一个指标如何随着时间的推移而发展时，群组分析非常有用，换句话说，如果一个指标需要时间来成熟，那么它应该在业务功能中进行考察。
让我举一个例子来说明这在什么时候有用。考虑指标每个客户的平均订单数(AOPC)。直觉上，老顾客的 AOPC 会比新顾客高，因为他们会有更多的时间来下更多的订单。这就很难比较新客户和老客户的 AOPC。
但是，通过进行群组分析，您可以了解 AOPC 在一段时间内的演变情况，从而可以比较新老客户在给定时间内的 AOPC。
要了解如何用 SQL 或 Python 构建群组图表，请查看我的指南:
请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！
2)数据管道开发
什么是数据管道开发？
数据管道开发包括设计和构建系统(管道),该系统将原始数据输入清理并转换为所需的输出。
有很多方法可以做到这一点，也有很多技术可以使用，但是在我的例子中，这涉及到编写和调度关于 Airflow 的高效查询，并将输出推送到几个 BigQuery 表。
它在商业环境中有什么用？
大多数时候，公司原始数据的格式对于分析或建模来说并不理想。例如，您可能有一个包含所有用户进行的每一笔交易的表，或者一个包含每个用户在您的应用程序中进行的每一次接触的表。这是一个巨大的数据量，需要整合到全面的聚合中。
总体而言，强劲的渠道发展带来了:
- 更快的临时分析周转
- 进行更复杂分析和构建更强大模型的能力
- 最后(也是最重要的)，为技术含量较低的用户实现数据民主化。
3)倾向建模
由作者创建
什么是倾向建模？
倾向建模回答了“某人基于 x、y 和 z 做某事的可能性有多大？”在我的案例中，我建立了一个倾向模型来回答这个问题，“每个用户根据他们的注册信息和营销接触点成为活跃用户的可能性有多大？”
它在商业环境中有什么用？
倾向建模是有用的，因为它允许你分配一个概率，用户将在未来做某事，无论是采用一个新产品，订阅一个新的订阅，等等。
通过准确地给用户分配分数，您可以做两件事:
- 你可以预测用户未来可能会做什么，并制定独特的定位策略。
- 您还可以了解促使用户更愿意(或更不愿意)做某事的特征和变量。
总的来说，在我看来，倾向建模是机器学习非常有效的最适用的商业案例之一。
4)解释性建模
什么是解释性建模？
解释性建模包括对特征变量和目标变量进行建模，目的是更好地理解变量之间的关系。这可以通过使用 f 检验和 t 检验的线性回归方法来完成，或者通过对 ML 模型使用 SHAP 技术来完成
它在商业环境中有什么用？
虽然解释性建模没有解释因果关系，但它是更好地理解不同变量之间关联的一种非常有效的方式。例如，通过解释性建模，我能够推断出应用程序活动是倾向建模的最强预测因素之一。
同样，在你想要比关联更强的理解的情况下，解释性建模的结果可以激发实验的想法，关联是特定变量之间的因果关系。
请务必点击 订阅此处 千万不要错过另一篇关于数据科学指南、技巧和提示、生活经验等的文章！
5)终身价值(LTV)建模
什么是 LTV 建模？
LTV，或终身价值，代表了从客户第一次成为客户到客户流失期间，你期望从客户那里获得的总净利润。这是客户的 ARPU、任期和流失的结合。
它在商业环境中有什么用？
作为一家更加关注盈利能力的公司，LTV 至关重要。有了 LTV 模型，你可以从价值(利润)的角度进行分析。这意味着您可以查看具有较高 LTV 的产品或细分市场。您甚至可以进行解释性建模，以识别指示高利润用户的变量/特征/属性。
感谢阅读！
一定要 订阅此处 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
不确定接下来要读什么？我为你选了另一篇文章:
还有一个:
-特伦斯·申
- 如果你喜欢这个， 订阅我的媒介 获取独家内容！
- 同样，你也可以 关注我上媒
- 报名我的个人简讯
- 跟我上LinkedIn其他内容
让你的 Python 代码更加 Python 化的 5 件事
原文：https://towardsdatascience.com/5-things-that-will-instantly-make-your-python-code-more-pythonic-198c6d371c80
理解语言的规则
照片由亚历克斯·丘马克在 Unsplash 上拍摄
任何会说多种语言的人都明白，一种语言的规则不一定适用于另一种语言；我的母语是英语，但我也会说 Twi 语，这是加纳阿坎部落的一种方言。每当我在加纳的时候，我都强迫自己说 Twi 语——我犯了很多错误，但是当地人很友好，他们帮我解决了问题。
我犯的错误不一定会破坏我所说的意思，这通常只是对 Twi 语言的糟糕练习，他们在说英语时经常犯同样的错误。例如，加纳人用 Twi 语交流时，通常会在开始说“请”,所以他们在说英语时也会这样做。
虽然“请是”不一定是英语语法的坏用法，但你可能不会说它。但这个错误源于试图将英语的规则应用于 Twi。许多用各种语言编写代码的程序员也陷入了这个陷阱。
您的代码可能不会抛出错误，但是当其他程序员试图理解您所写的内容时，您会让他们的日子更难过。花时间去理解一门语言的最佳实践不仅对你自己有益，对那些必须与你合作的人也有益。因此，我们将讨论编写 Pythonic 代码的五种标准方法。
#1 枚举()而不是范围()
您将看到的最常见的 Python 误用之一是程序员使用range()和len()函数循环遍历一个列表[或序列]并生成索引。
names = ["john", "doe", "jane", "plane"]
**for** idx **in** range(**len**(names)):
**print**(idx, names[idx])0 john
1 doe
2 jane
3 plane
您会发现上面的代码是有效的，并且运行良好，那么为什么这是一个问题呢？这违背了 Python 成为如此成功的编程语言的一个原因:可读性。
使用range(len(names))约定很容易做到，但是不太理想，因为它牺牲了可读性。执行相同功能的更好方法是将列表传递给内置的enumerate()函数，该函数将返回序列中索引和元素的整数。
names = ["john", "doe", "jane", "plane"]
**for** idx, name **in enumerate**(names):
**print**(idx, name)0 john
1 doe
2 jane
3 plane
如果您不需要索引，那么您仍然可以按如下方式遍历元素:
names = ["john", "doe", "jane", "plane"]
**for** name **in** names:
**print**(name)john
doe
jane
plane
#2 使用“with”语句
你可能正在编写一个要求你读写文件的程序。open()和close()内置函数允许开发者分别打开和关闭文件。
requirements = open("requirements.txt", "w")
requirements.write(
"scikit-learn >= 0.24.2, < 0.25.0",
"numpy >= 1.21.2, < 1.22.0",
"pandas >= 1.3.3, < 1.4.0"
)
requirements.close()
在上面的代码中，我们打开了一个名为requirements.txt的文本文件，写了一些内容，然后在完成后关闭它。这段代码是完全有效的，但是 Python 程序员会称之为 不协调 。
这也很危险，因为很容易忘记关闭一个文件，有时这是我们无法控制的——比如当一个try子句发生错误，程序跳过对except子句的close()调用。
**try**:
requirements = open("requirements.txt", "w")
requirements.write(
"scikit-learn >= 0.24.2, < 0.25.0",
"numpy >= 1.21.2, < 1.22.0",
"pandas >= 1.3.3, < 1.4.0"
)
random_error = 25 / 0 # raises a 0 divide exception
requirements.close() # this is skipped
**except**:
**print**("An error occurred.")
上面的场景是不太可能的:我无法想象你写依赖关系，然后除以一些数字的例子。但是灾难的威胁是真实存在的。
在上面的代码中，跳过了close()方法，因为在我们的代码中发现了一个错误，这使得它跳到了except块。这可能会导致非常难以跟踪的文件损坏错误。
比较好的方法是open()和close()文件如下:
**with** open("requirements.txt", "w") as requirements:
requirements.write(
"scikit-learn >= 0.24.2, < 0.25.0",
"numpy >= 1.21.2, < 1.22.0",
"pandas >= 1.3.3, < 1.4.0"
)
requirements.close()
上面的代码更 Pythonic 化，也更安全，因为一旦执行离开了with语句块，文件总是关闭的。
#3 将None值与is值进行比较
将None值与is恒等运算符进行比较优于等式运算符==。
"应该总是用
is或is not来比较像 None 这样的单元组，而不是相等运算符."
-人教版 8
原因在于他们如何进行比较:
- 相等运算符
==比较两个对象的值。 is标识运算符比较两个对象的标识。因此，它是对等式的引用，这意味着它决定了两个对象是否有相同的身份。
如果这听起来像是行话，简单的说就是在 Python 中有相同值的两个对象不一定是相同的。
**# Example of equal values and identities**
a = [1, 2, 3, 4, 5]
b = a **id**(a)
"""
140049469156864
"""**id**(b)
"""
140049469156864
"""a is b
"""
True
"""a == b
"""
True
"""**# Example of equal values but different identities**
a = [1, 2, 3, 4, 5]
b = a[:] **id**(a)
"""
139699152256576
"""**id**(b)
"""
139699151636672
"""a is b
"""
False
"""a == b
"""
True
"""
当你比较一个值和None时，你应该总是使用is，因为相等运算符==仍然可以计算为True，即使对象实际上是None。
**class** Example:
**def** __eq__(self, other=None):
**return** Trueexample = Example()
example == None
"""
True
"""example is None
"""
False
"""
这种可能性是由于==操作符过载造成的。执行example is None会检查example标识符中的值是否为None。基本上，如果一个变量被设置为None，那么比较它，看看它is None是否总是评估为True——因为行为是可预测的，所以它是首选的。
原始字符串有其用途
Python 中以r或R为前缀的字符串称为原始字符串。
**print**(r"This is a raw string")
"""
This is a raw string
"""**print**(R"This is also a raw string")
"""
This is also a raw string
"""
原始字符串最常见的用法是当我们处理使用几个转义字符\的字符串时(即 windows 路径、正则表达式，或者如果我们想要将文本插入到字符串文字中，否则像'这样是不可能的)。
***# without raw strings*** **print**("This is Kurtis\' phone")
"""
This is Kurtis' phone
"""**print**("C:\\Users\\kurtis\\documents")
"""
C:\Users\kurtis\documents
"""***# with raw strings*** **print**(r"This is Kurtis' phone")
"""
This is Kurtis' phone
"""**print**(r"C:\Users\kurtis\documents")"""
C:\Users\kurtis\documents
"""
原始字符串不应该被认为是不同类型的字符串数据类型——它不是。这只是键入包含几个反斜杠的字符串的一种便捷方式。
f 字符串更适合格式化代码
Python 3.6 中添加的新特性之一是 f 字符串(格式字符串的简写)。它们提供了一种更简洁、更方便的方法来格式化字符串——也符合 Python 的可读性对象。
为了理解它的有用性，我们必须了解它的发展历程。最初+操作符用于连接字符串:
name = "John"
age = "30"
city = "London"**print**("Hi, my name is " + name + " and I'm " + age + " years old. I live in " + city )
尽管这种方法可行，但它包含了几个引号和+操作符，这会影响可读性。
Python 随后引入了转换说明符%s使其更加具体:
name = "John"
age = "30"
city = "London"**print**("Hi, my name is %s and I'm %s years old. I live in %s" % (name, age, city))
这也是可行的，但是对于可读性来说仍然不是最好的。
下面是我们如何用 f 弦做同样的事情:
name = "John"
age = "30"
city = "London"**print**(f"Hi, my name is {name} and I'm {age} years old. I live in {city}")
干净多了，也更像蟒蛇了。
感谢您的阅读。
联系我:
LinkedIn
Twitter
insta gram
如果你喜欢阅读这样的故事，并希望支持我的写作，可以考虑成为一名灵媒。每月支付 5 美元，你就可以无限制地阅读媒体上的故事。如果你使用我的注册链接，我会收到一小笔佣金。
已经是会员了？订阅在我发布时得到通知。
https://kurtispykes.medium.com/subscribe
使用雪花的原生数据分类之前要知道的 5 件事
原文：https://towardsdatascience.com/5-things-to-know-before-using-snowflakes-native-data-classification-30f4e1d2ac06
了解雪花的 PII 检测功能
由 Unsplash 上的absolute vision拍摄
在当今世界，数据收集和处理受到监管，组织别无选择，只能遵守这些法规。因此，公司开始重新思考他们设计信息系统、数据存储和业务流程的方式，同时考虑到隐私问题。
实施数据保护原则的一个基本要素是数据分类。
什么是数据分类？
数据分类通常被定义为将 数据组织成组类别的过程，以帮助公司更有效地使用和保护数据。数据分类有助于我们了解我们在语义方面拥有什么，以便更好地保护它。
然而，这个组件通常是一个难以解决的问题…一些公司采用手工方式，另一些公司使用 ML 来自动分类他们的数据集。无论哪种方式，解决这个问题都是昂贵的并且可能是无效的取决于数据存储的方式和位置。
雪花拯救世界
如果您的数据堆栈中存在雪花，您可能希望利用其固有的数据分类特性。在扫描和分析了数据仓库对象(表、视图等)的内容和元数据之后..)，该特征将确定适当的语义和隐私类别。它将帮助您发现&标记 PII 数据，并显著降低管理和保护您的数据的复杂性和成本。
文本到图像使用中途:北极熊在云端保护数据库
但是，在您决定使用雪花的原生数据分类功能之前，有几件重要的事情您应该考虑:
1。数据类型
虽然您可以对半结构化数据(带有 JSON 对象的变量类型列)进行分类，但是该特性仅限于分析具有单一数据类型的变量，例如:varchar 或 number。如果您的表不包含任何 JSON 字段，这应该不是什么大问题。但是，如果您非常依赖雪花存储和查询半结构化数据的能力，您应该记住它不能与数据分类功能结合使用。您将需要考虑一个多步骤的过程，其中(1)您展平您的列，并确保它是受支持的数据类型之一，然后(2)您运行分类。
2.综合
说到流程，第二点是关于找到您需要/想要执行数据分类的正确步骤。很可能，您已经建立了数据管道，为不同环境中的许多数据库提供数据。那么，具体到哪一点，您会对数据进行分类呢？也许，在将数据转储到数据仓库之后，您可能会想。
如果是，这个阶段的数据质量是否足够好，可以高置信度地进行可靠分类？数据量呢？也许在数据被清理和建模之后，在更下游的地方进行分类会更好，对吗？在这种情况下，您将如何处理法规遵从性、治理和安全性？永远不会到达业务/指标层的数据怎么办？在开始对数据进行分类之前，您需要彻底回答这些问题。
3.自动化和可扩展性
在他们的博客中，Snowflake 描述了原生数据分类特性，好像它将移除所有手动过程。这可能是定制数据集的理想场景中的情况，然而，真实世界的用例却大不相同；数据仓库通常包含多个环境、数据库和数据共享。事实上，雪花提供了三个存储过程；第一个用于对模式中的所有表进行分类，第二个用于对数据库中的所有表进行分类，第三个用于使用标记对分类的对象列应用分类结果。手动触发的(甚至是预定的)存储过程在自动化、可伸缩性和监控方面根本达不到预期。尤其是因为没有简单的方法来分类新的或改变的对象。
与上面提到的博客文章相比，Snowflake 的文档建议了一个工作流，用户可以选择手动检查分类输出，并根据需要进行修改。这种方法的问题是它很难扩展；这不仅是因为它需要人工关注，还因为缺少一个方便审查和批准过程的用户界面。您需要构建自己的工具来弥合这一差距。
4.表演
绩效评估是多方面的，但我将只讨论一个方面；全表扫描。
要分析表/视图中的列，需要运行以下函数:
EXTRACT_SEMANTIC_CATEGORIES('*<object_name>*' [,*<max_rows_to_scan>*])
除了对象名(如表名)，它还带有一个可选参数<max _ rows _ to _ scan>，代表样本大小。如果您没有明确地将它设置为 0 到 10000 之间的一个数字，它将默认为 10000 行。起初，我认为样本大小对性能(查询运行时间)有重要影响，但在对该特性进行实验后不久，我意识到无论我设置的样本大小是大是小，每次调用函数时，雪花都会执行全表扫描。样本大小将主要影响分类结果的准确性，而不是性能。如果您计划频繁运行分类过程，您应该评估性能。如果您发现分类很慢，您可以投入更多的计算能力来加快速度，或者使用像基于分数的行采样这样的技术来绕过全表扫描。
5.展开性
一旦EXTRACT _ SEMANTIC _ CATEGORIES函数运行分类算法，下一步就是将生成的结果作为标签应用于目标对象列。
截至本文发布之日，可用的分类标签如下所示:
{
"name": [
"PRIVACY_CATEGORY",
"SEMANTIC_CATEGORY"
],
"allowed_values": [
[
"IDENTIFIER",
"QUASI_IDENTIFIER",
"SENSITIVE",
"INSENSITIVE"
],
[
"EMAIL",
"GENDER",
"PHONE_NUMBER",
"IP_ADDRESS",
"URL",
"US_STATE_OR_TERRITORY",
"PAYMENT_CARD",
"US_SSN",
"AGE",
"LAT_LONG",
"COUNTRY",
"NAME",
"US_POSTAL_CODE",
"US_CITY",
"US_COUNTY",
"DATE_OF_BIRTH",
"YEAR_OF_BIRTH",
"IBAN",
"US_PASSPORT",
"MARITAL_STATUS",
"LATITUDE",
"LONGITUDE",
"US_BANK_ACCOUNT",
"VIN",
"OCCUPATION",
"ETHNICITY",
"IMEI",
"SALARY",
"US_DRIVERS_LICENSE",
"US_STREET_ADDRESS"
]
]
}
这些标签已经为您定义好了，并且存储在雪花型只读共享数据库的核心模式中。这意味着，如果您想要通过使用ASSOCIATE _ SEMANTIC _ CATEGORY _ TAGS存储过程来自动应用标签，您将受限于这个可用标签列表。鉴于许多标识符和准标识符是关注美国的，你可能需要考虑定义你自己的标签列表。但是，真正的挑战是弄清楚这个新列表将如何与原列表一起工作。因此，您将经历额外的步骤，例如创建和设置标签:
CREATE [ OR REPLACE ] TAG [ IF NOT EXISTS ] ...
ALTER TABLE ... MODIFY COLUMN ... SET TAG
最后的想法
总而言之，设计和构建数据分类解决方案并不是一件容易的事情。Snowflake 提供了一个很好的起点，它已经通过调用一个函数抽象出了许多挑战。但是，不要指望它会自动扫描您的整个数据仓库，并使用标签显示任何 PII。数据工程师仍然需要设计端到端的流程；包括但不限于构建一些工具来促进手动审查过程以及对数据量、预算和使用模式的优化。上面列出的五点可能没有涵盖 Snowflake 中 PII 分类特性产品化的所有方面。所以，如果你有不同的东西要补充，或者如果你认为某些方面可以用更好的方法来解决，请写下评论并分享你的想法。
在参加数据科学训练营之前，你应该知道的 5 件事
原文：https://towardsdatascience.com/5-things-you-should-know-before-you-embark-on-a-data-science-bootcamp-74d08a614904
适用于任何试图学习数据科学的人或任何人的见解
格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片
去年，我有幸在新加坡校区完成了大会的数据科学沉浸式课程。作为我职业转型的一部分(从城市农业开始)，我从今年的第一周开始学习 Python，并以数据科学沉浸式毕业结束了这一年。我从来没有想到，一个朋友提出的简单建议“学习 Python”并看看接下来会发生什么会发展成为一项成熟的努力，但事实确实如此。在本文中，我将概述我认为对我的数据科学之旅至关重要的关键原则。
1。找出你的误差范围
阿莱士·麦卡锡在 Unsplash 上拍照
乍一看，这似乎有点奇怪。误差幅度？嗯，我具体指的是你说你能实现的和你实际能实现的之间的差距。有时候，我们高估了它，有时候，我们恰恰相反。以数据为中心，我们应该依靠实际的可验证的观察。你能帮助自己的一件事是:
压力测试。
为了检查我是否真的对主题材料感兴趣，而不仅仅是对它的想法感兴趣，我参加了几个关于数据科学的 Udemy 课程，同时试图按照类似于训练营期间经历的日常时间表。我记录了时间的使用情况以及我是如何遵循(或不遵循时间表)的。最终，我学到了足够多的东西，能够用 Python 制作我的第一个迷你数据科学项目，这告诉了我足够多的东西。随后，我也能够用完整的 Python 代码完成训练营的招生面试任务。
在整个课程中，我经常能够测试我对各种任务的时间估计，其中值得注意的是主要的双周项目。
每次项目演示前一天晚上你上床睡觉的时间可能是最能说明问题的指标之一。
请注意，如果你从未亲自尝试过做一件特定的任务，不要以为有充足的时间。拥有特定代码集的文档并不表示该代码实际上能够在您的机器上运行。甚至像数据争论这样表面上“简单”的任务也可能成为主要的障碍。
你与自己设定的契约可能是你所拥有的最强大的力量。找出你的误差范围会让你更加信任自己，而这种信任是最重要的。退休的美国将军兼国防部长詹姆斯·马蒂斯在他的回忆录中写道:
行动以信任的速度发生。
就他而言，他谈论的是部门间的合作。然而在我看来，这也适用于自信。如果没有执行任务的信心，一个人很可能会受到阻碍。具有讽刺意味的是，你需要知道你的误差幅度才能执行得好，但是你需要首先执行才能知道你的误差幅度。因此，关键是要有最初的执行勇气，避免任何分析麻痹或完美主义。引用另一位美国将军乔治·S·巴顿的话:
现在猛烈执行的好计划胜过下周执行的完美计划。
那么，现在哪里有信心执行这个计划呢？正如拉尔夫·沃尔多·爱默生所说:
做这件事，你就会拥有力量。
上面的整个演讲不是关于做出鲁莽的决定，而是看:我从象棋中学到的一个教训是 你看不到某些东西，除非你做出某些动作 。这里的关键是，你要做出明智的、有计划的举动，让你能够学习(而不是在这个过程中被彻底消灭)。
响应式执行还有其他好处。例如，我没有陷入普遍的心理陷阱，决定课后彻底研究主题材料(以弥补注意力的任何下降)，而是尽最大努力在课堂上集中注意力，直接吸收材料。的确，课后大部分时间都被项目和其他冲突占据了。我在大会上的教练曾经引用迈克·泰森的话:“每个人都有一个计划，直到他们被打脸。”
如果你喜欢军事题材，你也可以选择‘没有计划能在与敌人的第一次接触中存活下来。’这要归功于普鲁士陆军元帅赫尔穆特·冯·毛奇。一个人可以在训练营中经历一些事情，比如亲戚住院，或者分手(这些都是真实的故事)。面对所有这些事件，当你达到极限时，知道自己的误差会给你信心。经历这些事件会给你更多的信息来计算你未来的误差幅度。如果你积极地观察和学习，这将是一个净正循环。
2.一次做一件事
照片由 Devin Avery 在 Unsplash 上拍摄
你不可能一下子学会所有的东西。
那里。我说了。
你会陷入极度恐慌。你会双手抱头，怀疑自己。你将走向数据科学/KDNuggets，被大量文章轰炸，想要阅读一切。也许，你可能会在文章中找到学习数据科学的路线图，并意识到你有多少不知道的。否则，你会在 LinkedIn 上，被从#datascience 标签中涌出的大量资源淹没。你会看着 Coursera/Udemy 上的所有课程，告诉自己你必须完成吴恩达的机器学习课程，以及 Git 上的另一门课程，也许还有整个 Python 之类的东西…
这样的例子不胜枚举。
你不可能一下子学会所有的东西。然而，你可以一次学会一件事。
先找到一件你想学的东西。把它学得相当好。重复一遍。
如果你一周接一周地吸收训练营每周带给你的信息，，到训练营结束时，你会积累相当多的信息。
如果你一下子看到了所有这些信息，我告诉你，在课程结束时，你会积累所有这些信息，你会告诉我，我疯了。
深呼吸，喝杯咖啡，通过小赢来征服物质。对任何事情都要有逻辑的方法。确保首先掌握必要的技能和基础知识(我的意思是:你知道如何让你的日期时间数据正确地显示在你的图中吗？)
想想什么水平的期望可以被认为是不合理的。我强烈推荐这篇文章的精华:你需要停止阅读关于成为数据科学家的耸人听闻的文章，作者在其中写道:
在不到一年的时间里学会成为一名数据科学家应该被认为是一个奇迹。
为期 3 个月的训练营是一项艰巨的任务，但你可以做到。与他人相比，不要对自己的进步过于自责。我经常说每个人都有一个关于他们目前所处位置的背景故事。例如，我完成了训练营，但我也在课程开始前几个月开始准备。请记住，你的旅程在训练营开始之前就已经开始了，而且在训练营结束之后还会持续很长时间。
我正在读加里·凯勒和杰伊·帕帕桑的书《唯一的事情:非凡结果背后惊人简单的真相》，这本书很大程度上基于一次全力以赴做一件事的力量。我也喜欢思考帕累托法则，或者 80/20 法则，它本质上表明，通常情况下，一小部分努力或投入要对大部分结果负责。你的目标是找出这个高价值的小众。例如，如果掌握数据科学课程中某个 20%的主题会给你带来 80%的可能回报，那会怎么样？
最后，一次做一件事也意味着要为训练营留出充足的时间。没有其他沉重的承诺，如果你能帮助它。记住，能出错的就会出错。空闲时间可能只是想象出来的。
3.找到你的位置
由 Austin Distel 在 Unsplash 上拍摄的照片
我们说过一次做一件事。嗯，非常擅长(至少)一件事也很重要。
没有什么比意识到你已经学到了足够多的知识，可以就各种各样的数据科学话题进行对话，但你无法在其中任何一个话题上可靠地执行一个项目——一个你会感到自豪的项目——更令人失望的了。
你的定位是什么？如果你只能选择一个数据科学领域来研究未来，你会选择什么？否则，如果你是一名数据科学通才，你会选择哪个行业或事业来应用你的技能？如果不是，是否有什么特别的东西让你与众不同(拥有其他人也拥有的数据科学技能)？当考虑你的利基时，这些都是值得考虑的问题。理想情况下，你应该能够做好某件事，如果可能的话，比别人做得更好。在训练营之前、之中甚至之后，你都有时间去思考。有时候，你对它的想法可能会改变，这是正常的。
在训练营中，你需要完成一个最终的顶点项目，同时也要展示出自己的个人品牌，告诉别人你的独特之处。两者都是探索你的利基的好机会。
4.不要忽视人的因素
阿克尔在 Unsplash 上的照片
我设定了一个个人目标，要在课程结束时和所有同学交谈。我做了，但是我必须平衡这个和我的顶点项目的义务才能到达那里。然而，正是这些互动让我的顶点工程成为可能。我们也建立了友谊。
时间可能成为一种奢侈品，决定把自己藏起来完成项目是很简单的。然而，为人际交往腾出时间是有道理的。通过与他人交谈，你可能会获得一些洞见，这些洞见可能会解开你在真空中永远看不到的东西。你也可以从阅读中获得有价值的见解，但交谈是一种双向交流，因此有其独特之处。在我们顶石项目的过程中，我们经常与我们的导师交谈，并获得了继续前进的清晰思路。我还记得有几次同学告诉我，我发给他们的文章给了他们项目的灵感。
与他人交谈时，你可能会获得帮助或情感支持，但更重要的是，给予帮助或情感支持。两者也可能同时发生。例如，教一个同学一个概念会在你的头脑中巩固它。讨论一个同学的顶点项目进展也给了你自己的见解。****
即使是消极的互动也有可能产生积极的结果。
你会学到东西。
无论是亲身经历还是观察到的，与数据科学专业同学基于团队项目的冲突使我能够看到交流中可能出现的潜在热点。与课外朋友的交谈让我感受到外行人是如何看待数据科学的。在有阻力的地方，它让我看到未来的利益相关者可能会对通常被炒作的概念(如机器学习模型)做出什么反应。
如果你需要更有说服力的关于人的因素的力量:
我在的第一个个人数据科学项目是一位数据科学家朋友让我尝试清理他的试跑结果数据，因为他没有时间这么做。
我看到了机会，我接受了挑战。我不想只是清理它；我也想分析它，我也这样做了。这个项目是催化剂，让我有信心申请沉浸式数据科学。
5.正确选择您的设置
塞巴斯蒂安·贝德纳雷克在 Unsplash 上的照片
在我报名参加沉浸式数据科学课程之前，我从来不知道一个操作系统会有什么不同。
Macbook 长期以来一直是程序员和其他人的首选，但显然最新的 M1 芯片 Macbook 太超前了——许多更先进的机器学习库都与它不兼容。这在未来可能会改变，但那是当时发生的事情。
幸运的是，我用的是 Windows 机器。
总会有一场关于哪个是最好的操作系统的争论，但是我所能说的就是仔细选择你的操作系统。总会有利弊，对每个系统的某些怪癖有个人偏好。
如果你对它感兴趣，你还可以设置快捷方式和自动化一些过程。对于训练营，我们需要每天从 Git 存储库中获取课程材料。我配置了一个 shell 脚本来运行 Git pull 所需的命令，并设置 Windows 任务计划程序每小时在整点运行该脚本。我还配置了 Windows 终端来启动 Anaconda 提示符。这允许我使用右键菜单来启动一个提示，在那里我可以直接在我想要的文件夹中启动一个 Jupyter 笔记本。
正如 StatQuest 的乔希·斯塔默所说，砰。
说到文件夹，妥善整理你的文件夹并做好备份。你以后会感谢自己的。
在选择合适的设置时，我也指的是物理方面，比如得到一把合适的支撑椅，或许还有第二台显示器。编码不仅要付出精神上的代价，还要付出身体上的代价。如果笔记本电脑键盘不好用，全键盘是个不错的选择。因为这是远程学习的时代，所以也应该考虑缩放会议的麦克风和网络摄像头功能。
学习数据科学不是一项简单的努力，在一切之前，了解自己以及为什么对它感兴趣是基石(因为我一直提到 capstones)。顶点工程绝对不是最后一战。学习永无止境。一个人总可以在项目上追加，会有后续的项目在规模上超过它。
什么样的规模？这是留给后代的问题。正如我的训练营教练曾经说过的，“你的未来会是怎样的？”
完成 100 门 Coursera 课程后的 5 个技巧
原文：https://towardsdatascience.com/5-tips-after-completing-100-coursera-courses-1ee5a35e72a4
反思我的电子学习之旅
在 Unsplash 上由 Zaini Izzuddin 拍照
上周末，我正式完成了我的第 100 期 Coursera 课程。3.5 年前，我被介绍到了电子学习的世界，并从那以后进入了 Coursera、DataCamp 和 Udemy。本文不是对不同类型的电子学习平台进行直接比较，而是对我所学到的东西进行反思，分享我推荐给那些计划开始电子学习之旅或想了解我如何在电子学习之旅中确保生产力的人的技巧和课程！
№1.做(好)笔记
做笔记有很多好处！请继续阅读，找出为什么以及如何做好笔记。
虽然这归结于个人的学习风格，但我通常发现写下东西、组织和重新表述内容有助于我更好地理解内容，特别是如果你是视觉或动觉学习者。我发现把内容记在别的地方更有效，因为不用重温课程视频就能更容易地查阅。
照片由大卫·特拉维斯在 Unsplash 上拍摄
为了写好笔记，我建议按主题组织笔记，而不是按课程。
我把笔记分成几个主题，比如“机器学习”、“软件开发”、“项目管理”、“Python”等等。如果我按课程组织我的笔记，那么像“使用 Python 的数据科学”这样的课程应该在同一个文档中，而它应该被分成机器学习和 Python-其中理论属于机器学习，代码示例应该放在 Python 下。通过这样做，如果其他课程涉及类似的主题，就更容易扩展笔记，这种情况经常发生。
我希望我能早点意识到这一点，因为我已经多次重新整理我的笔记。诚然，我仍然发现内容重叠(甚至课程在某些定义上不一致！)而且做笔记还需要额外的努力。在这种情况下，我发现重新组织内容有助于我回顾这些主题。不要害怕重新措辞和重新排序现有的笔记。作为免责声明，我相信做笔记没有“一个好方法”，但你必须从某个地方开始。
№2.你无法逃避数据科学中的数学
答在参加了各种数据科学、机器学习和深度学习课程后，数学是所有课程的核心。
数学分支很多，有些数学比其他的更平等(哈哈)。以下是我按字母顺序推荐的一些数学分支，以及在哪些情况下我会用到这些知识，
- 代数和矩阵:在计算机视觉和深度学习领域非常有用，有助于理解算法如何工作以及如何修改或改进它们
- 算法:我几乎不用公式，因为它们大部分已经实现了。然而，来自这些课程的想法对于软件工程理解不同的算法如何在准确性和复杂性上取得平衡的同时达到相同的结果是有用的
- 微积分:在机器学习和深度学习领域非常有用，可以理解随机梯度下降和损失函数等概念
- 博弈论:在有代理、行动和奖励的强化学习领域很有用
- 统计:用于数据分析，即检验两个分布是否来自同一个总体分布的统计检验，从数据中得到统计汇总，因果推断，推断中常见的陷阱。在处理连续、分类或时间序列数据时，统计学对于数据科学也很重要
如果我错过了任何数学分支，请在评论中告诉我！我不认为你必须精通数学的所有分支，但专注于与你领域相关的领域有助于你计划接下来要学的课程。
№3.不要只关注编码模块
学习脚本语言比(某些)编程语言更有意义
我喜欢编码。当我开始我的电子学习之旅并查看课程目录时，我有一种想要学习所有东西的冲动——Python、SQL、R、Java、Golang 等等。我很快意识到，并不是所有事情都与你的职业相关。当然，数据科学家最常用的编程语言是 Python 和 SQL(有时是 R ),但也有其他高度相关但经常被忽略的“编码”语言。也就是学习 Bash/UNIX 和 Git 命令。
Bash 和 Git——作者图片
Bash/UNIX 命令是帮助操作文件和目录的命令行工具，使用诸如ls之类的命令来列出文件目录或mkdir来创建新文件夹。而 Git 命令有助于版本控制。您可能熟悉git add、git commit、git push来对代码库进行更改。
当然，在您的工作环境中只有几个 Bash 和 Git 命令可以使用，但是了解它在幕后是如何工作的仍然很有用。例如，在 Git 中有 4 种方法来执行合并——快进合并、合并提交、挤压合并和重定基础。理解它们的差异对于为您的项目选择合适的合并策略至关重要。知道如何实现它们是很重要的，当你弄乱了你的代码(或其他人的代码)时，知道该怎么做是很重要的——这种情况时有发生！
№4.不要忘记追求其他的兴趣
除了前面几节讨论的数学、编码和脚本课程之外，很容易耗尽精力或知识超载。记得花些时间追求你的其他兴趣。
探索电子学习平台提供的众多课程类别！以 Coursera 为例，根据你对什么感兴趣，有艺术和人文，商业，计算机科学，数据科学，信息技术，健康，数学和逻辑，个人发展，物理科学和工程，社会科学和语言学习等类别。
罗伯特·科林斯在 Unsplash 上拍摄的照片
所有的信息都在那里，世界是你的牡蛎。
对于我自己，我也对编码最佳实践、数据可视化、财务、组织和项目管理模块感兴趣。为了准备我的计算(计算机科学)硕士学位，我还涉猎了大数据、云应用、计算机视觉、数据库和安全模块。就我个人而言，我更喜欢在深入某个主题之前，先了解广博的知识，但要因人而异。
№5.将学习与项目联系起来
申请申请申请。
无论是在公司项目还是个人项目中，在现实生活中应用你的知识都是有益的。在浏览课程内容的时候，想想它如何能对你有用或有所调整。
了解网络搜集——你会为一个兼职项目搜集哪些数据，比如收集 Twitter 上的推文进行情感分析？了解 ML Ops——您目前正在开发哪些将在未来部署的模型？您部署了哪些模型，它们是否遵循了与课程内容类似的实践？你明白了。
它不一定是一个大的飞跃，例如学习编码和立即制作一个 web 或移动应用程序。小事情可以走很长的路，例如编写可读的、优雅的代码，遵循新获得的关于编码最佳实践的知识。
结论
当我开始职业生涯时，我有机会开始我的电子学习之旅，我已经看到电子学习课程帮助我的朋友进入他们的角色。让我们不要陷入没有更早开始的遗憾中，下一个最好的开始时间就是现在。我希望这篇文章在某种程度上帮助你有效地学习电子学习课程，明确哪些模块应该优先考虑，以及如何不失去动力。
概括来说，这是本文分享的 5 个技巧
- 做(好)笔记
- 你无法逃避数据科学中的数学
- 不要只关注编码模块
- 不要忘记追求其他的兴趣
- 将学习与项目联系起来
感谢您的阅读！如果你喜欢这篇文章，请随意分享。
按主题推荐的课程
按字母顺序，
- 算法 : 算法(斯坦福大学)
- 人工智能 : 面向所有人的 AI(deep learning。AI)
- 痛击:Unix 工作台(约翰·霍普金斯大学)
- 云(Google Cloud):Google Cloud 上的高级机器学习
- 云(IBM) : 云应用开发基础
- 深度学习 : 深度学习(Deep Learning。AI)
- Git : 带有 Git 的版本控制
- Golang : 用 Google Go 编程
- Java : Java 编程与软件工程基础
- 机器学习 : 用 Python 应用数据科学
- 机器学习工程 : 面向生产的机器学习工程(DeepLearning。AI)
- 自然语言处理 : 自然语言处理(DeepLearning。AI)
- 项目管理(Scrum) : Scrum Master 认证
- 项目管理(六适马) : 六适马黄带
- 项目管理(六适马) : 六适马绿化带
- Python : Python 为大家
- Python:Python 中脚本的介绍
- R(基础) : R 编程(约翰·霍普斯金大学)
- R(高级) : 高级 R 编程(约翰·霍普斯金大学)
- 软件工程 : 软件设计与架构
- 统计(基本) : 基本统计
- 统计学(高级) : 统计推断(约翰·霍普斯金大学)
- 统计(硬) : 推断统计
- SQL(基本) : 结构化查询语言介绍
- SQL(高级) : 数据科学 SQL
赢得第一次数据科学面试的 5 个技巧
原文：https://towardsdatascience.com/5-tips-for-acing-your-first-data-science-interview-dbad5b5959d7
如果你正在寻找一个数据科学领域的全职、兼职甚至暑期实习机会，那么看看关于清除行为和技术面试阶段的 5 个简单提示。
作者使用 Canva Pro 制作的图片
如果你是一名寻求开始职业生涯的应届毕业生，一名为了更好的机会而跳槽的专家，甚至是一名申请暑期实习的学生，那么你必须知道工作面试是招聘过程中一个棘手的部分。为了通过多轮面试，申请人必须展示自己在领域知识、技术经验、人际交往技能以及对工作和公司的理解方面的专长。你需要知道你给公司带来的价值，理解招聘经理的期望。
当我开始申请工作时，我不知道数据科学面试是如何进行的。我从管理领域转行，所以我想他们可能会问我一些关于数据科学和如何管理项目的简单问题。大多数事情我都错了。数据科学面试很不一样。你需要了解技术术语、现代框架、编码、业务用例以及统计学。
从失败中吸取教训后，我总结了五条对我有用的建议，我相信它们也会对你有用。除了这些建议，你只需要自信和练习就能在任何面试中胜出。
查看工作和公司简介
忘记职位描述和公司愿景的细节是求职者最常犯的错误。招聘经理会在最初的几分钟里发现这些错误，到那时他/她已经下定决心拒绝你了。为什么？因为他们认为你对这份工作不认真。
如果你已经通过 LinkedIn 或任何招聘平台申请了，一定要回去花时间研究公司和职位描述。阅读工作要求、日常任务以及公司对你的期望。确保你了解公司的座右铭和工作环境。登陆官网，找找最近的项目。这些信息会帮助你给面试官留下深刻印象，说实话，这是你最初的目标。
招聘人员最常问的问题是“为什么你是这份工作的合适人选？”或“你对我们公司了解多少？”。如果你没有为面试做好准备，你会被这些问题卡住，这在你的求职申请上看起来很糟糕。
作者使用 Canva Pro 制作的图片
回顾你的简历和项目
如今，招聘人员专注于投资组合项目，他们会在安排工作面试前寻找 GitHub 或 T2 的简介。这有助于他们评估你的技术能力，并为与你最近的项目相关的问题做准备。问题不仅限于项目。面试官可能会问你一些关于你以前的工作和你简历中提到的技能的问题。
在一次技术面试中，我被要求描述我最近的自然语言处理项目的一切。他们向我询问了工具、技术概念和 web 框架。在第二轮面试中，我被问到关于 Deepnote 简介上的传记和简历。所以，最好回去回顾一下简历和项目组合。确保你能回答所有的问题，即使这个项目以失败告终。
图片来自作者的网站
修订数据科学术语
在一个例子中，我完全忘记了“随机梯度下降”是如何工作的，在另一个例子中，我忘记了术语“单词袋”。这些情况非常尴尬，因为我已经从事数据科学项目好几年了，但仍然不能回答基本的问题。为了避免这种情况再次发生，我养成了用备忘单修改技术术语的习惯。提前准备也让我有信心回答编程相关的问题。查看完整的数据科学备忘单集合第 1 部分和第 2 部分。
作者图片|数据科学备忘单全集第 1 部分和第 2 部分
备忘单提供了有关技术术语的字节大小信息，如果您想了解更多，请查看 DataCamp 关于数据科学的资源，包括 Python 、 R 和 SQL 。这些资源包括课程、博客、教程、小抄、评估测试和认证指南。
阅读最常见的面试问题
面试有三个环节。第一次由人力资源经理进行，它是非技术性的，侧重于你的优势和劣势。第二部分更具技术性，团队经理和首席数据科学家会评估您的技术知识。最后一部分由公司高管进行，重点关注公司文化、工作生活平衡和增长潜力。
我强烈建议你去阅读数据科学面试中的常见问题。这些问题既是技术性，也是非技术性的。看完 87 个常见的数据科学面试问题，你会惊讶地发现自己是如何毫无准备的。
作者使用 Canva Pro 制作的图片
我会极力推荐你去读读尼克·辛格和凯文·霍的《王牌数据科学访谈。这本书解释了工作申请流程是如何运作的，以及如何在行为面试中胜出。此外，它深入到数据科学的技术层面。专注于概率、统计、SQL、机器学习、编码、产品开发和案例研究。
参加一些模拟面试
模拟面试更像是练习面试，可以改善你的肢体语言、谈话要点和焦虑感。我有表现焦虑症，即使我知道答案，也无法回答问题。我甚至被简单的概率问题困住了。
为了改善我的肢体语言和克服焦虑问题，我开始在技术娴熟的上进行模拟面试。该平台将您与顶级行业人力资源经理、软件工程师和数据科学家联系起来。在我的情况下，我与招聘经理和首席数据科学家匹配。这次面试也让我意识到这个领域的新机会，以及如何接触招聘人员。
作者使用 Canva Pro 制作的图片
如果你不想支付模拟面试的费用，你可以请你的朋友或家人进行面试。模拟面试的主要目的是获得真实的反馈，并利用它为你实际的面对面/在线面试做准备。
附加资源
- 数据科学术语和行话
- 数据科学统计
- 十大数据科学框架
- 十大数据科学 SQL 面试问答
- 数据科学备忘单
- 商务智能术语终极词汇表
2022 年学习 SQL 的 5 个小技巧
原文：https://towardsdatascience.com/5-tips-for-learning-sql-in-2022-573822fe3f92
数据科学/数据分析/数据库
2022 年学习 SQL 的 5 个小技巧
基于个人经验的 SQL 学习建议
格伦·卡斯滕斯-彼得斯在 Unsplash 上拍摄的照片
如果你想进入任何类型的数据行业，SQL 是一项必须学习的技能。
大家好，我叫 Brenden，是达拉斯的一名数据专业人员，两年前，我决定进入令人难以置信的数据世界。这是我做过的最好的决定之一，从那以后我再也没有回头。两年前，当我第一次开始这个旅程时，我觉得我需要掌握多种先进的技术和统计概念，以便有机会获得任何数据角色。作为一个几乎没有接受过技术和数学教育就开始这段旅程的人，我做了大多数开始数据之旅的人所做的事情，我试图从头开始学习编程、人工智能和高级统计模型，并试图在 30 天内完成所有这些。嗯，在没有一次记住所有这些概念之后，我很快意识到我需要改变我的方法。在我考虑处理其他事情之前，我花了几个月的时间专注于学习 SQL。我使用 SQL 已经快两年了，可以肯定地说，在日常生活中，我使用 SQL 的次数比任何其他工具或技能都多。
那么为什么这个故事很重要呢？回顾这段经历，我意识到我并没有完全理解什么是数据，数据是如何表现的。随着越来越多的低代码环境被创建并用于数据领域，从整体上理解数据变得越来越重要。
随着越来越多的低代码环境被创建并用于数据领域，从整体上理解数据变得越来越重要
所以我为什么要学 SQL？
SQL 有用的原因有很多，关于这个主题有大量的资源。一旦我觉得我的 SQL 技能很扎实，并转移到其他数据概念，我就能够更好地理解我所学的内容，因为我能够以某种方式将每个概念引用回 SQL。例如，使用SELECT语句可以让您找到想要使用的数据，而UPDATE语句将永久改变表中的值。掌握这些小技能，比如进一步了解查询如何影响数据库，这些技能在处理生产解决方案时非常有用。因此，不要再拖延了，这里有一些提示将帮助你在 2022 年完成你的 SQL/数据之旅！
免责声明:学习是一个终生的过程。这并不是要告诉你你需要知道什么，而是从我的个人经历中给你一些实用的建议。更多信息请查看 走向数据科学 。如果你正在寻找今年学习 SQL 的不同想法，请继续阅读！
1。学习查询的基本结构
在非常基本的层面上，许多查询遵循相似的结构:
作者代码
这是 SQL 中拉取数据的基本公式。是的，有一些更高级的概念你可以使用，但这是大多数查询的框架。当你开始学习更高级的概念时，相对于从头开始尝试高级概念，依靠这个框架并以它为基础会更容易。
2.理解代码的动作
SQL 是一种有趣的语言，因为每条语句都有一次做这么多事情的能力。让我们来看看一些示例代码:
这是在 SQL 中删除表的方法:
作者代号
这是在 Python 中删除数据帧(或表)的方法:
作者代码
注意，在 python 中删除数据需要四行代码，而在 SQL 中删除数据需要三个字。这是因为 SQL 直接与数据库接口，这意味着如果您试图修改表或底层数据，您将经常对数据库进行永久更改。了解不同的语句如何与数据库交互将有助于学习使用 SQL，并确保您使用正确的方法，不删除或修改任何您不想删除或修改的内容，这就引出了我们的下一个技巧！
3.了解不同类型的 SQL 命令
有五种主要类型的 SQL 命令。将这五种类型的命令想象成相似的 SQL 语句组。以下是对不同类型功能的简要概述:
- 数据查询语言(DQL) ，可以用来查找和查看数据，而不需要对数据库做任何永久性的修改。
- 数据操作语言(DML) ，用于对数据进行永久性修改，如更新值或删除值。
- 数据定义语言(DDL) ，用于对表进行永久性修改，如创建或删除表。
- 数据控制语言(DCL) ，用于管理命令，如添加或删除不同表和数据库的用户。
- Transact 控制语言(TCL) ，是处理事务级语句的高级 SQL。
对我个人来说，当我学习 SQL 时，理解这些不同的组有助于我理解我的代码真正在做什么。这也让我能够确保我的代码完全按照我的要求运行，并且没有修改或删除历史生产数据的风险。在学习 SQL 的同时，您可以随意进行自己的研究，为您的学习过程添加一些背景知识！
4.使用不同类型的数据集进行练习
很多时候，您会遇到不熟悉的数据，必须依靠您的工具和技能(如 SQL)来使这些数据适合您的数据库，并对其进行相应的分析。例如，我觉得我看到了一种新的方式来安排每个月的日期。了解 datetime 函数在 SQL 中是如何工作的，并且能够依靠它将会节省您的时间，并在将来减少挫折。当我第一次开始练习更多的 SQL 时，我可能会告诉自己在我的数据集中包含更多的多样性，并有机会学习如何处理我以前从未处理过的问题，所以当你练习时，不时挑战自己，处理你可能不想处理的数据，因为你可能会发现自己处于这种情况下。
5.从修剪盆景树的角度考虑 SQL
照片由 Devin H 在 Unsplash 上拍摄
随着 Cobra Kai 第四季在网飞上映(如果你还没有看过这部剧，我肯定会推荐)，我觉得这是一个合适的类比，绝对适用于学习 SQL。在第一部《空手道小子》电影中，他们谈到你需要如何设想你在生活中想要什么，并在生活中做出改变，将你的愿景变成现实，就像修剪盆景树一样。问题是，一旦你做了一个大的改变或决定，你通常必须坚持下去，就像砍掉盆景树的树枝一样。类似地，在数据库工作中，在编写一行代码之前理解您想要的最终产品是什么是非常有益的，尤其是在 SQL 中。您是否正在尝试修改数据库中的表？您正在尝试删除、创建哪些列等。？
这将有助于您更有目的地设计查询，并使您的代码更加高效。肯定有这样的时候，你可以在没有最终产品的情况下开始编码，特别是当你被要求从零开始创造一些东西的时候。这两种方法都有效，但是把这两种方法都放在你的口袋里会节省你的时间和挫折。
结论
虽然这绝不是一个详尽的列表，但我希望这些提示能鼓励你在今年开始你的数据之旅，并帮助你避免一些挫折。与其他语言相比，SQL 在语法方面并不一定很难，但是，从系统的角度来看，它可能很难，因为 SQL 代码本身并不能说明全部情况，通常您需要在按下 run 之前了解代码的作用。实践您的代码，理解基本的基本概念，然后您就可以充分利用您的数据了。
如果你喜欢这篇文章，请告诉我！敬请期待 2022 年可能出现的第二部以及其他内容！
看看我的其他文章吧！
全新承担分析型工作流管理
三种分析工具和技巧你现在就可以开始学习
如何演讲:面向有志分析师
数据可视化受众和场景
有志分析师的三大技术栈
</10-tips-for-a-successful-internship-e8f0c14cd3d3>成功实习的 10 个秘诀**
作为营销分析实习生我学到了什么
营销分析实习生的一天
联系我或接收更多内容，在 Twitter 上关注我@BMNAnalytics！**
帮助你成为数据科学经理的 5 个技巧
原文：https://towardsdatascience.com/5-tips-that-will-help-you-become-a-data-science-manager-bd4b6981c024
照片由 Jungwoo Hong 在 Unsplash 上拍摄
所以你想升职？其他人也一样。怎样才能在同龄人中脱颖而出？
除了对数据科学的热情，我还一直对人员管理感兴趣。我一直想帮助他人实现他们的职业目标(因此是中型客户)，我喜欢了解全局，了解/帮助决定一个团队如何融入公司更广阔的生态系统。
当我一年半前开始我的新工作时，我希望很快晋升为经理，因为我有几年的个人贡献者(IC)经验，我认为我可以在网上找到一些关于如何实现这一转变的一般指导。但有趣的是，尽管互联网上充斥着面试指南和一般职业建议，却没有多少关于如何实现从 IC 到经理的转变的文章。每个人的经理之路都会略有不同，因为这里有很多变数。但是多亏了我的经理的辅导和指导，我能够从我的经验中提取一些一般性的教训，并希望能够帮助一些有抱负的 DS 经理。
采取主动
在这个过程中我学到的最有价值的一个教训是——你没有获得晋升，然后开始下一级的表现；你的表现更上一层楼，以便获得晋升。
因此，当你注意到某个地方存在差距时，即使它不一定属于你目前的角色描述，也不要害怕向你的经理提出来，讨论你是否可以/应该主动帮助弥补差距。你的经理肯定会欣赏能注意到这些事情并能帮助集思广益解决问题的集成电路。
注意差距并采取主动的最佳方式是做一个好的倾听者，并不断地与您的合作伙伴和利益相关者就他们团队的工作和痛点进行交流。一般来说，你对其他团队的工作以及他们如何相互协作了解得越多，你就越容易找到改进的方法。
指导一名同事
经理的最大职责之一是在优先排序、指导和一般指导方面帮助其他团队成员。所以，当你考虑转型时，你应该开始练习这些。
如果你有新成员加入团队，很好，主动提出成为的入职伙伴来指导他们度过最初的几周。看看你是否能够提供关于利益相关者、技术堆栈和团队项目的一般背景，并帮助解决更详细的问题。这也将帮助你更好地了解你的知识差距，并帮助你提高作为一个集成电路。
如果短期内没有新成员加入团队，当团队中的现有同事需要有人集体讨论解决方案或者当他们不知道应该联系哪个团队来解决问题时，你仍然可以帮助他们。
走出你的直接范围
作为一名经理，你需要从一个 IC 的范围提升，转而在更高层次上负责几个 IC 的工作流。把这个潜在的过渡期作为你的无风险实践。
如果你有日常工作之外的带宽，与你的队友交谈，了解他们的项目。偶尔你会发现团队成员之间协作的机会，提高团队效率；这些都是可以带给你的经理的好建议。
同样的事情在团队间也是可能的。如果你能够更多地关注那些看起来与你的直接范围无关的对话，你将能够快速地在不同的项目和计划之间建立联系，并帮助提高跨团队协作的效率。
参与团队活动
经理们总是喜欢在团队层面的活动中伸出援手，例如冲刺规划、季度规划甚至只是及时的建议。这将是一个很好的机会来测试你对其他团队成员的工作以及其他团队对你的团队的要求的了解。这也会让你接触到经理的计划和团队愿景。同样，志愿参加文化活动是一种很好的方式，可以练习将团队作为一个整体来思考，并开始锻炼你作为经理需要的肌肉。
我见过很多 IC，他们在自己的工作中实现了很棒的想法；无论是为他们开发的数据产品准备产品设计文档，还是与他们的合作伙伴团队签订 SLA 协议。更好的做法是将您在自己的工作中使用的最佳实践整理成文，这样整个团队都可以从中受益。这和“走出自己的范围”是一个精神；采取经理的心态，帮助整个团队。
与你的经理进行公开、及时的反馈对话
作为一名数据科学家，您应该知道指标对跟踪您的进展的重要性。那么，如何为你向经理的转变建立一个衡量标准呢？与你的经理进行公开和及时的对话是关键。
每个公司对于不同的角色都有稍微不同的水平指南。所以了解你作为管理者需要达到的标准是非常重要的。当您与您的经理进行首次职业发展对话时，询问平级指南。确保你尽快提到你想成为一名经理的愿望(不要害羞)以及你渴望实现的时间表。同时，请你的经理就他们对你成为经理的准备程度的评估，以及他们认为你需要解决的任何差距，提供坦诚的反馈。类似于“在公共场合建立”的心态，不要害怕把你自己放在那里去做那些事情；即使你失败了，这也是一次很好的学习经历。
在后续的职业发展检查中，请你的经理根据水平指南为你提供反馈。这将为您和您的经理提供清晰的目标进度。
总结
不知道你是否注意到了，但是沟通是上面提到的很多事情的关键。经常与你的队友、利益相关者和你的经理进行开诚布公的沟通。在整个过程中，获得经理的支持也很重要。如果没有我出色的经理丹尼斯的帮助和指导，我不可能做到这些。请记住，在所有这些促销对话中，您的经理将是您最大的支持者，因此让他们参与进来并在过程中获得他们的诚实反馈非常重要。
除此之外，记得走出你的直接工作范围，这样你就可以参与更多的团队层面的工作，指导同事，或者只是采取更多的主动。
想了解更多关于数据科学职业的信息？这里有一些很棒的文章给你。
</5-mistakes-i-wish-i-had-avoided-in-my-data-science-career-6c22a44304a1>
开始数据职业生涯的 5 个技巧
原文：https://towardsdatascience.com/5-tips-to-start-a-career-in-data-211ad15a7ca8
引领我成为一家跨国公司高级数据科学家的步骤
由 Unsplash 上的 SpaceX 拍摄的图像
你真的想和数据打交道，对吗？但是当你想到这个的时候，你脑海中真正浮现的是什么呢？
该领域有各种各样与数据相关的工作，需要高技能人才。已经有人说过数据是新的石油，而数据科学家是 21 世纪最性感的工作。媒体用人工智能的每一个显著进步来淹没我们。
你想成为其中一员吗？本指南将向您展示一点现实，以及如何开始数据职业生涯。
1 —了解你最喜欢的工作是什么
任何数据团队的主要目标都是创建基于数据的解决方案来帮助业务。这是一个相当宽泛的目标，可能有些保守，因为有许多方式可以实现它:
- 通过创建仪表板，让上层管理人员做出明智的战略决策。
- 开发能够预测复杂变量的模型，如产品定价或客户倾向。
- 减少相关信息的处理时间，这可能有助于客户选择我们的产品。
- 寻找可能表明市场趋势或公众需求的模式。
- 以及许多其他用例，我们可以利用数据驱动的解决方案为业务带来价值。
通常，数据团队有许多角色:数据科学家、数据分析师、数据工程师和机器学习工程师是其中的一些角色。
图片由 Marvin Meyer 在 Unsplash 上拍摄
这是数据团队的生态系统，所有这些角色的一个共同点是:他们都需要很好地了解自己的活动，但也需要了解其他角色的活动。他们都需要了解他们正在从事的业务。
我需要强调的是，它并不像听起来那么迷人。大部分工作是以表格和图表的形式处理数据，而不是使用某种机器人制造的神奇工具。
现在你已经选择了你最喜欢的角色，你下一步应该做什么？
2 —学习编程
起点是学编程。
最近，我看到许多人说“不一定要懂编程才能处理数据”，尽管这个领域正在快速走向无代码建模，但我们仍然在许多其他事情上使用编程技能。
图片由 Unsplash 网站上的 Luca Bravo 提供
如果有人问我，我会毫不犹豫的说:学 Python。
它的区别在于，你可以创建一个网站的后端，一个游戏，一个智能手机应用程序，以及除了数据操作之外的许多其他东西。我用 Python 实现了几个流程的自动化，包括与 MS Office 产品和网页的接口。
这是不可避免的:随着解决方案复杂性的增长,“标准”解决方案不再有意义，我们需要定制它们。怎么会？编码。创建新的类、函数、管道，直到框架适应我们的需求。
然而，如果你对开始感兴趣，不要让编程成为障碍。把基础学的很好，主要结构，函数，类之类的东西。你将有足够的时间更好地学习剩下的内容。
3 —深入你喜欢的领域…
我通常会说，20h 的在线课程不会神奇地将你转变为数据科学家(或分析师，或工程师)。但是我相信，如果你以前没有接触过数据，这是一个很好的开始。
从课程开始，参加研讨会和聚会，阅读相关内容。突然，你将面对一张你所在区域范围内的完整地图。这是你最终知道你需要关注什么的时候。
图片由 Unsplash 上的亚伦·伯顿拍摄
我还是这么做的！我通常会阅读和谈论很多关于数据科学的内容，每次当我面对一些我需要更好了解的东西时，我都会将它包含在一个学习列表中，以便以后检查。
不要满足于知道使用哪种工具，而是总是试图找出每种工具是如何工作的。随着时间的推移，你会在不知不觉中变得越来越专业。
只是要小心这个陷阱:数据主题太宽泛，感觉我们需要从一开始就了解 50 万件事情。深呼吸。冷静点。一次解决一个小问题。
4 — …但也了解一些其他领域
正如我之前所说，在数据生态系统中，我们需要接近其他角色。
如果您是一名数据工程师，您将需要了解科学家的需求，哪些表是分析师最常用的，哪些功能是在每次需要时手动创建的，因为它们在数据湖中不可用…
图片由普里西拉·杜·普里兹在 Unsplash 上拍摄
如果你不知道你同事的工作，在你的小世界里做超级英雄是没有用的，试图成为万事通也是没有用的。要成为所有领域的专家是不可能的，但至少了解一些基本知识是非常必要的。
这里的提示仍然有效:在线课程和免费内容可以帮助你发展更广泛的基础，而不需要在一个主题上太深入。
5-创建一个突出的投资组合
我们在这个领域面临很多竞争，所以你需要一些东西来突出你！
图片由哈尔·盖特沃克在 Unsplash 上拍摄
首先，我的建议是:建立一个投资组合。
在互联网上搜索很酷的问题和项目，创建解决方案，然后发布到 GitHub 或 kaggle 上。展示你理解并很好地履行你的角色的实际用例。
创建学习小组，一起解决案例和竞赛。互相教导。这些案例可以放在你的文件夹里，你可能会在路上找到好朋友。
结论
处理数据具有挑战性，需要不断学习。除了了解我们正在合作的企业，我们还需要继续研究和跟踪新的事物。
即便如此，与数据打交道是有回报的，知道自己的工作对业务产生了积极影响也是件很酷的事情。
我希望这个简短的指南能帮助你开始学习数据，或者至少能让你更好地理解它。
如果你喜欢这个帖子…
支持我一杯咖啡！
给我买杯咖啡！
看看这个很棒的帖子
在代码中写更好注释的 5 个技巧
原文：https://towardsdatascience.com/5-tips-to-write-better-comment-in-your-code-1d4681071967
帮助他人更容易地遵循您的代码
Artur Shamsutdinov 在 Unsplash 上拍摄的照片
作为程序员或技术领域的一部分，我们经常需要定期阅读、分析和编写代码。有些代码比其他代码更容易编写和遵循。代码越清晰，理解、使用和构建的速度就越快。对于任何程序员或数据科学家来说，编写优秀代码的能力都是一项基本技能。
但是，另一个重要的技能是写好评论。现在，我知道如果你掌握了编写可读代码的艺术，你就可以写更少的注释，但是我们不能为了现实而完全停止写注释。所以，即使你擅长写代码，你也需要能够写出好的注释。
注释是每一个好代码的主要部分。如果你打开一个代码，它没有任何注释，阅读和理解代码将会很费时间。缺乏评论和使用过多的评论一样糟糕。如果你的代码文件有 50%或更多的注释，那么你的代码可能写得不是很好，因此你需要很多注释来解释它。
写好评论并不是一件难事；这只是一个需要大量练习的问题。幸运的是，如果你正在阅读这篇文章，你要么是一名程序员，一名数据科学家，要么在技术领域工作。这意味着你在职业生涯中需要写/读大量的代码。
那么，如何写好评论呢？在这篇文章中，我将介绍 5 个技巧来帮助你写更好的评论，让你的评论写作技巧更上一层楼。
提示 1:保持简短，简明，切中要点
说到写评论，我会说，少即是多。尽量不要过度解释代码的每一步。保持你的注释简短，对于类和函数不要超过三句话，对于行内注释不要超过一句话。如果你的代码写得很好，你不需要很多注释来解释它。你只需要给用户(程序员同事)一点提示，告诉他们你为什么做出某些决定，以及不同代码段的整体功能。
一般来说，为了保持事物的有序和数量的统一，编程社区在为一个类编写注释(docstring)时，要包括一个简短的描述和最后一次修改的日期。然而，当你为一个函数编写代码时，它必须包含对其目的、参数和结果的描述。
提示 2:保持每个关卡的风格一致
通常，代码分为卡盘、函数、类、模块、库等。每一个都可以被认为是代码的一个层次。因此，当您编写注释时，最好为每个级别开发一种特定的样式，并在代码中维护它。
因此，您将为所有代码函数使用相同的编写 docstring 的风格；你的函数和内嵌注释也是如此。这将帮助任何阅读代码的人快速浏览并理解其结构，甚至不需要深入阅读。
技巧 3:在编写代码之前或编写代码时编写注释，然后编辑它们
初学者第一次学习编码时犯的最大错误之一——我也是这样——是先写代码，然后检查代码并写注释。这种方法的问题是，通常我们要花一段时间来编写代码，几天甚至几个月。所以，当我们接近写评论这一步的时候，我们已经忘记了我们为什么要做一些决定。
在这种情况下，最好的办法是在编写代码的同时编写注释。一些程序员甚至会说，你应该在写代码之前写注释(它将作为你的指南)。但是，在我看来，并行移动代码和注释是最省时省力的方法。所以，边走边写评论，最后，如果需要的话，再进行编辑。
秘诀 4:明确表达
评论不只是给将来会看你代码的人看的；他们也是为了未来——你将在接下来的发展步骤中维护和扩展它。所以，把你的评论说清楚，对其他开发者和你自己都有帮助。
一旦一行代码出现在屏幕上，你就进入了这段代码的维护模式菲尔·哈克
提示 5:记得保持简单
最后，也许是最简单的建议，就是保持事情简单。保持你的代码简单，这样就不需要在评论中做太多的解释，同时保持你的评论简单明了，这样别人和将来你都会觉得很容易理解。
一个基本的编程原则是 让你的代码自己说话。虽然那场运动最初是由不喜欢写注释的程序员发起的——一般来说，他们中的大多数，你不能 100%消除注释。尽管如此，你仍然可以大大减少它们的数量，但是要写一个更简单的代码。
最后的想法
成为一名成功的数据科学家需要你掌握不同的技能；编程可能是这些技能中最重要的。成为一名优秀的程序员意味着你能写出清晰易读的代码和简洁明了的注释。这两者对于产生高质量的代码同样重要。然而，大多数人更关注开发他们的代码编写技能，而忽略了他们的注释编写技能。
像任何其他技能一样，更好地写评论的唯一方法是练习写更好的评论。首先，阅读你认为写得很好的评论，并反思你为什么喜欢它们。通常，简短、清晰、描述性强且不过度使用的注释是最佳的。
这篇文章讲述了 5 个技巧，它们会让你的评论写作技巧更上一层楼。我留给你这个；注释并不意味着向用户解释代码；相反，您的代码用于向计算机解释注释。
每个数据科学家都需要掌握的 5 种工具
原文：https://towardsdatascience.com/5-tools-every-data-scientist-needs-to-master-fc2b0d5685b6
从绘图到版本控制…
苏珊·霍尔特·辛普森在 Unsplash 上的照片
数据科学是一个可以涉及从生物和金融到地理和零售等各种主题领域的领域。这意味着数据科学项目可以有各种各样的格式，面临着各种各样的挑战。然而，这并不意味着它们之间没有一些共性。在我之前的帖子中，我描述了每个数据科学项目将经历的五个阶段。在这里，我将介绍每个数据科学家都应该掌握的五种工具，以便能够尽可能顺利地完成这些阶段。
这些工具是:
- 一个绘图库:产生简单、快速、专业的可视化。
- 数学库:用于那些超出你编码语言基本能力的计算。
- 保存数据的库:快速简单地将数据加载、交互并输入到模型中。
- SQL :用于处理超出计算机内存容量的数据。
- 版本控制:能够有效管理自己的文件，与他人合作。
掌握这些将有助于您以最高标准完成数据科学项目！
绘图库
在大多数数据科学家的工具箱中，最重要的工具之一应该包括掌握至少一个绘图库，不管选择哪种语言。能够掌握绘图库的好处是能够创建有效的可视化来展示您的数据、方法和结果。当他们说一张图片胜过 1000 个单词时，在数据科学领域尤其如此。清晰的可视化可以让你有效地与各种不同的利益相关者沟通，增加你的项目的价值和范围。
对所选出图库的掌握，应该包括如何简单快速地创建简单的出图。这将在你陷入困境时对你有益，比如理解数据，不知道如何进步或确认你正朝着正确的方向前进。十有八九，这些挑战可以简单地通过查看快速和肮脏的情节来解决。这并不意味着你必须包括标签，正确地给情节上色，甚至添加标题，这个情节只有你能看到，所以只要你理解它，你就没问题。
能够创建这些简单的情节也将帮助你打下基础，创建更复杂的可视化，可以添加到出版物，演示文稿，或显示给领导。创建这些情节通常需要更长的时间来制作，并且需要对所选择的库有更深入的了解，但最终会让你将你的过程或结果传达给更广泛的受众。要做到这一点，你需要知道如何添加图例、标签、注释、处理颜色以及在同一个图表上组合多个图，等等。这些情节将能够以一种任何语言都无法在如此短的篇幅内传达的方式支持你试图向观众讲述的故事，并将为你的最终结果增加价值。
我建议从学习一个单独的库开始，因为它们之间的语法和实现可能会有所不同，通常一个库就能够涵盖大多数用例。然后，一旦你基本上理解了第一个库及其局限性，你就可以寻找其他库来添加到你的库，并填补当前库还做不到的空白。在 Python 中，大多数人开始学习的一个常用库是 Matplotlib。这是因为它非常容易学习，而且一旦你理解了一些更复杂的功能，它就非常通用，留下的空白需要由其他库来填补。除此之外，还有 plotly、seaborn、ggplot 和其他可以用来替代 Matplotlib 的工具，它们提供了不同的优缺点。
数学图书馆
应该出现在大多数数据科学家工具箱中的一个常见工具是核心数学和/或统计库。这是因为虽然大多数语言都有内置的数学运算，但在大多数数据科学工作流中，在现有功能的基础上使用一个库可以使许多过程变得更容易。由此带来的好处包括能够轻松使用数学常数或符号，快速有效地执行高级计算或操作，同时还能存储大量数据。
学习数学或统计库可能非常有用，尤其是对于您希望集成到数据科学工作流中的更复杂的数学方法。这可能包括一些使用大量数据的复杂操作或一些类型的统计分析。但是学习数学库也是有用的，因为在大多数语言中，一些更高级的库会建立在现有库的基础上。这方面的一个例子是 Sci-kit Learn，它是 Python 中的 go-to 机器学习库，利用 Numpy 的许多内置功能来执行它的一些计算和机器学习算法。通过了解其中一个基本库的功能，您通常能够更好地利用更高级的库，并且能够知道您的模型下正在发生什么。
在 Python 中，这个函数的库是 Numpy。这是因为该库具有丰富的功能深度和易用性，例如 Numpy 数组的实现，它可以比 Python 列表更有效地存储信息，同时还允许更快、更高级的数据操作功能。这包括快速有效地在更大规模上执行计算的能力，这是其他方式无法做到的。如果您想开始使用这个库，请随意查看下面的介绍:
保存数据的图书馆
每个数据科学家的工具箱中必须有的第三个工具必须是一个可用于存储、保存和操作数据的库。虽然许多语言都有内置的数据结构，但当涉及到数据科学工作流时，它们的功能往往是有限的。一个有效的库应该能够读取各种格式的数据，允许您执行基本的计算，输入到常见的绘图库(或者能够自己生成它们)，并且能够与各种机器学习模型集成以输入数据。
为了有效地使用这个工具，您必须能够执行三个操作。首先是能够从各种来源和各种格式加载数据。数据科学项目通常涉及来自许多不同地方的数据，因此能够处理所有这些数据的库将非常有用。掌握这一点将使您能够加载数据并开始工作，这比使用各种库或工具要快得多，否则会增加任何数据科学工作流的复杂性。虽然一个库可能无法从所有数据源加载，但它至少应该能够处理最常见的数据源，如 CSV、excel 文件、文本文件、json 格式和数据库。
数据科学家还应该能够使用所选的库执行简单的数据操作。这将包括能够在列或行之间执行简单的计算，根据特定条件选择一个或多个项目，将数据分组以获得汇总统计数据，以及能够创建数据的子集。这将允许任何数据科学家在执行任何可视化或建模之前获得对数据的感觉和概述，有助于缩小接下来的步骤。在项目的早期阶段，您希望确保任何数据操作都可以快速有效地完成，在一个好的库的帮助下，这将变得容易得多。
您必须能够执行的最后一个操作是将数据结构传递到另一个库中进行可视化或建模。在大多数情况下，虽然这个库将有一些用于可视化或计算的内置功能，但您通常会依赖其他库进行更深入的可视化或使用机器学习算法。能够有效地创建您想要传递到这些其他库中的数据结构对于在您的项目中创建有效的数据科学工作流至关重要。这可能涉及到上面提到的许多简单的数据操作，但是您需要确保数据能够以正确的格式传递给所选择的工具。
您将为此选择哪个库通常高度依赖于您所使用的语言，因为每种语言都有自己不同数据结构的实现。这使得从一种语言移植到另一种语言非常困难，您必须习惯每个新库的细微差别。在 Python 中，用于高效存储数据的最常见的库是 Pandas。这是因为熊猫数据帧是一种能够存储、操作和提取数据的有效方式，同时与 Python 生态系统中的大多数机器学习库相集成，使其有效地像数据科学瑞士军刀一样。
结构化查询语言
除了上面提到的工具(这通常取决于您为数据科学工作流选择的语言)，大多数数据科学家至少应该对结构化查询语言有一个基本的了解。这将允许您与来自各种来源的数据进行交互，这样您就可以轻松地提取您感兴趣的数据。这对于与大型数据集交互的数据科学项目尤其有益，因为大型数据集太大，无法以通用数据格式或结构进行有效存储或操作，或者在不使用数据时存储数据。
数据科学家至少应该学习 SQL 的基础知识，以便与结构化数据库进行交互。这些技能包括能够选择数据和过滤数据，就像用图书馆来保存你的数据一样，这样你就可以只提取你感兴趣的信息。在某些情况下，这种过滤必须在数据库级别完成，而不是在工作流级别，因为否则您可能没有足够的计算能力来处理传递的数据量。在早期阶段这样做也允许您只加载您感兴趣的数据，从而减少工作流中所需的计算资源量。从长远来看，这可以节省你的时间和金钱。
除此之外，您还应该能够执行简单的数据分组和连接。分组使您能够提取简单的汇总统计数据，这将使您能够在创建任何工作流之前获得数据的总体视图，为您正在处理的数据提供基础。而联接允许您有效地连接来自数据集内不同表或视图的数据，这样您就不必创建相同数据的重复实例，而是可以操纵它来获得您想要的结果。
版本控制
所有数据科学家工具箱中应该有的最后一个工具是版本控制工具，通常等同于 git。这对于长时间的工作流或协作项目非常重要，因为如果没有版本控制，它们会变得非常混乱。尽管如此，即使您单独从事一个项目，并且您从事的大多数项目都很小，您仍然应该使用某种形式的版本控制。不为别的，这将减少 v1、v2、v3、final、final v2 命名约定的数量，我敢肯定，这在许多工作文件夹中都很常见。
了解、理解和使用版本控制至少应该包括能够有效地管理本地存储库。这包括能够存储当前的工作流，对存储库进行新的提交，以及浏览以前的提交以撤销或重新进行更改。这种理解将允许数据科学家以这样一种方式有效地管理任何数据科学项目，即如果需要，可以移除或逆转引入工作流的任何改变或错误，并且不需要同一文件的多个实例。我们都经历过文件的 v1、v2、v3、最终版本、最终版本、最终版本。更高级的知识将包括如何创建分支，以及如何将它们合并或重组回主线分支，以便隔离功能开发并保持工作产品的稳定性。
数据科学家还应该知道如何将他们的本地存储库与远程存储库集成在一起。这不仅能确保你做的所有工作都有备份(非常重要！)而且使您能够与其他人有效协作。这包括了解如何推送到远程存储库、从远程存储库拉取、创建和合并特征分支以及处理合并冲突。这种技能应该有望在从事同一项目的团队中实现简单的协作，同时减少合并冲突的数量或其他人更改您正在从事的相同代码的问题。在现代数据科学项目中，这种情况更有可能发生，因为在地理和时差方面，一个广泛分散的团队可以从事一个项目。
学习 git 可能是一个永远漫长的旅程，但是理解基础知识将使任何数据科学家受益。这并不意味着他们必须是专门使用命令行的 git power 用户(有许多有用的 GUI！)但是任何一个数据科学家至少要知道基本的功能。下面的介绍是一个很好的起点:
结论
数据科学可能是一个棘手的领域，但有五个常用工具，一旦掌握它们，任何数据科学家的生活都会变得更加轻松。其中包括可用于有效绘图的库、可用于执行基本数学计算的库、用于存储工作流、SQL 和版本控制数据的库。虽然这些不会使每个数据科学项目变得轻而易举，但它们肯定会改进最终产品和过程！祝你好运！
如果你喜欢你所读的，并且还不是 medium 会员，请使用下面我的推荐链接注册 Medium，来支持我和这个平台上其他了不起的作家！提前感谢。
https://philip-wilkinson.medium.com/membership
或者随意查看我在 Medium 上的其他文章:
推动 2022 年元数据新世界的 5 大趋势
原文：https://towardsdatascience.com/5-trends-driving-the-new-world-of-metadata-in-2022-721f974cdf87
这些趋势汇聚起来，围绕着一种新的、现代的元数据概念掀起了一场风暴。
由 Unsplash 上的 Pietro Jeng 拍摄
去年，我们在元数据领域达到了一些重要的里程碑。Gartner 放弃了元数据管理的魔力象限，公司开始要求第三代数据目录，现代元数据公司(像我的！)发起并筹集了一些重要的风投资金。
所有这一切实际上促使我将元数据作为我今年的六个关键数据想法之一。
但是为什么元数据现在在数据世界里是一个如此热门的话题呢？所有这些炒作的背后是什么？
在本文中，我将分析这个元数据新世界背后的五种趋势。有些是五年前开始的，而有些只有几个月的历史——今天，它们聚集在一起，围绕一种新的、现代的元数据概念掀起了一场风暴。
TL；大卫:五大趋势
- 现代数据堆栈成为主流，拥有一系列前所未有的快速、灵活的云原生工具。问题是——元数据被遗漏了。
- 数据团队比以往更加多样化，导致混乱和协作开销。上下文是关键，元数据是解决方案。
- 数据治理正在被重新构想从自上而下的集中式规则到自下而上的分散式计划，这需要对元数据平台进行类似的重新构想。
- 随着元数据成为大数据，元数据湖现在和将来有无限的用例。
- 被动元数据系统正在被抛弃，取而代之的是主动元数据平台。
1.现代数据堆栈的创建
大约从 2016 年开始，现代数据堆栈成为主流。这指的是帮助当今企业存储、管理和使用其数据的工具和功能的灵活集合。
这些工具由三个关键理念统一起来:
- 面向各种用户的自助服务
- “敏捷”数据管理
- 云优先和云原生
当今的现代数据堆栈易于设置、按需付费、即插即用，如今人们再也无法忍受其他任何东西了！像 Fivetran 和 Snowflake 这样的工具可以让用户在不到 30 分钟的时间内建立一个数据仓库。
图片由图集
在一个越来越简单、快速、互联的数据工具的生态系统中，旧的元数据概念——被动、孤立的数据清单，由一群数据管家提供动力——不再适用。许多早期的第二代数据目录仍然需要大量的工程时间进行设置，更不用说与销售代表进行至少五次通话以获得演示。那么，有人对数据世界急切地寻找处理元数据的更好方法感到惊讶吗？
阅读更多关于现代数据栈的信息。
现代数据栈的最新版本。(图片由 Atlan 提供)。)
2.多样化的数据人类
几年前，只有“IT 团队”会接触数据。
然而，今天的数据团队比以往任何时候都更加多样化。他们包括数据工程师、分析师、分析工程师、数据科学家、产品经理、业务分析师、公民数据科学家等等。这些人中的每一个都有自己喜欢的、同样多样化的数据工具——从 SQL、Looker 和 Jupyter 到 Python、Tableau、dbt 和 r。
这种多样性既是一种力量，也是一种奋斗。
新的多样化数据团队。(图片由 Atlan 提供)。)
所有这些人都有不同的工具、技能、技术组合、工作风格和处理问题的方式…本质上，他们每个人都有独特的“数据 DNA”。更多样化的视角意味着创造性解决方案和创新思维的更多机会。然而，这通常也意味着协作中的更多混乱。
这种多样性也意味着自助服务不再是可选的。现代数据工具需要对拥有各种技能的广大用户来说是直观的。如果有人想将数据带入他们的工作，他们应该能够轻松地找到他们需要的数据，而不必询问分析师或提出请求。
元数据正成为这些挑战的解决方案。正如 Benn Stancil 所写的，“今天的数据堆栈正在迅速分裂成更小、更专业的部分，我们需要某种东西将它们结合在一起。”他对此的回答是元数据。随着我们不断将越来越多样化的人员和工具引入我们的数据生态系统，元数据正在不断发展，以提供关键的上下文。
阅读更多关于人类的资料。
3.数据治理的新愿景
数据治理被认为是一个官僚的、限制性的过程——一套从上面降下来的规则来减缓你的工作。而现实是，这通常是它实际工作的方式。
公司用复杂的安全流程和限制来包围他们的数据，所有这些都由远处的数据治理团队决定。
然而，随着现代数据堆栈使接收和转换数据变得更加容易，这种数据治理的想法已经成为日常数据工作中的最大障碍之一。
从业者第一次自下而上地感受到了治理的需要，而不是由于监管而自上而下地强制实施。这就是为什么数据治理目前正处于范式转变的中期。
引自 Tristan Handy 的“现代数据堆栈:过去、现在和未来”。(图片由 Atlan 提供。)
如今，治理正成为数据人类欣然接受而非畏惧的东西。就其核心而言，它现在更少涉及控制，而是更多地涉及帮助数据团队更好地合作。
因此，数据治理正在被重新设想为一套由令人惊叹的数据团队制定并为其服务的协作最佳实践，这些实践是关于授权和创建更好的数据团队，而不是控制他们。
当今的数据治理演变。(图片由 Atlan 提供。)
现代的、社区主导的数据治理需要一种全新的元数据管理平台。例如，旧的自上而下、基于管家的数据管理流程不再适用。工具需要适应允许数据用户众包上下文，作为他们在 Slack 或微软团队中日常工作流程的一部分。另一个关键方面涉及使用元数据来自动化数据分类，例如自动分类和限制对具有 PII 数据的资产的访问。
了解更多关于现代数据治理的信息。
4.元数据湖的兴起
2005 年，收集的数据比以往任何时候都多，使用数据的方式也比单个项目或团队想象的多。数据有无限的潜力，但是如何为无限的用例建立数据系统呢？这导致了数据湖的诞生。
今天，元数据在同一个地方。元数据本身正在成为大数据，雪花和红移等计算引擎的技术进步(即弹性)使得从元数据中获取智能成为可能，这种方式甚至在几年前都是不可想象的。
随着元数据的增加，我们可以从中获得的智能也在增加，元数据可以支持的用例的数量也在增加。
今天，即使是最受数据驱动的组织也只是触及了元数据的皮毛。然而，元数据正处于从根本上改变我们数据系统运行方式的尖端。元数据湖使这成为可能。
元数据湖是一个统一的存储库，可以存储所有类型的元数据，包括原始的和进一步处理的形式，以一种可以与数据堆栈中的其他工具共享的方式来驱动我们今天和明天已知的用例。
就像数据变得更容易使用数据湖一样，元数据湖让我们最终理解我们将如何能够使用今天泛滥的元数据。
阅读更多关于元数据湖的信息。
元数据湖的架构。(图片由 Atlan 提供。)
5.主动元数据的诞生
2021 年 8 月，Gartner 放弃了元数据管理魔力象限，代之以主动元数据管理市场指南。这标志着传统元数据管理方法的终结，并开启了一种新的元数据思维方式。
引自 Gartner 的 活动元数据管理市场指南 。(图片由 Atlan 提供)。)
传统的数据目录是被动的。它们从根本上来说是静态系统，不驱动任何操作，依靠人工来管理和记录数据。
然而，一个活跃的元数据平台是一个永远在线的、智能驱动的、面向行动的系统。
- 永不停机:它不断从日志、查询历史、使用统计等中收集元数据，而不是等待人工输入元数据。
- 智能驱动:不断处理元数据，将点与点连接起来，创造智能，比如通过查询日志解析自动创建血统。
- 以行动为导向的:这些系统不是被动的观察者，而是驱动建议，产生警报，并实时运作情报。
主动元数据平台充当双向平台，它们不仅像元数据湖一样将元数据集中到单个存储中，还利用“反向元数据”使元数据在日常工作流中可用。
阅读有关活动元数据的更多信息。
我们对活动元数据的愿景。(图片由 Atlan 提供)。)
展望未来
抱怨元数据的状态很容易。但是当我回顾五年前的情况时，我们已经取得了惊人的进步。
由于这五大趋势的融合，我们正处于元数据管理的转折点——从老式的被动工具向现代的主动元数据转变，为我们的整个数据堆栈提供动力。
元数据不再是静态的文档，它是开启我们真正智能数据管理系统梦想的钥匙。我们还有很长的路要走，但我个人迫不及待地想知道明年元数据会怎么样。
觉得这个内容有帮助？在我的时事通讯《元数据周刊》上，我每周都写关于活动元数据、数据操作、数据文化和我们的学习建设的文章 Atlan 。 在此订阅。
掌握熊猫的 5 招追加()
原文：https://towardsdatascience.com/5-tricks-to-master-pandas-append-ede4318cc700
使用 Pandas append()在当前数据帧末尾有效添加行的实践教程
照片由UX在 Unsplash 上拍摄
数据合并是将两个或多个数据集合并成一个数据集的过程。通常，当您将原始数据存储在多个文件、工作表或数据表中，并且希望一次性分析所有数据时，这个过程是必要的。
来源于 DisplayR 博客:什么是数据合并[1]
Pandas 提供了各种内置方法来轻松组合数据帧。其中，append()是[concat()](/pandas-concat-tricks-you-should-know-to-speed-up-your-data-analysis-cd3d4fdfe6dd)在当前数据帧末尾增加行的一个特例(axis=0和join='outer')。这种方法似乎很容易使用，但是仍然有一些技巧你应该知道，以加快你的数据分析。
在这篇文章中，你将学习熊猫append()处理以下用例的技巧:
- 追加单行
- 追加多行
- 当列名没有对齐时
- 带参数
sort=True - 带参数
verify_itegrity=True
请查看笔记本获取源代码。更多教程可从 Github Repo 获得。
1.追加单行
Pandas append()可以接受一个类似 Series/dict 的对象或列表，并将其添加到当前数据帧的末尾。为了进行演示，让我们创建一个数据帧df1并遍历不同的输入:一个系列，一个字典，以及一个列表。
df1 = pd.DataFrame({
'name': ['A', 'B', 'C', 'D'],
'math': [60,89,82,70],
'physics': [66,95,83,66],
'chemistry': [61,91,77,70]
})
1.1 A 系列
在这种情况下，我们想追加一只熊猫Series。我们需要确保我们的输入索引标签与 DataFrame 列匹配。
### Appending a Series
my_series = **pd.Series(
['E', 60, 70, 80],
index=['name', 'math', 'physics', 'chemistry']
)**df1.append(**my_series**, ignore_index=True)
熊猫追加()追加系列(图片由作者提供)
1.2 判词
同样，我们可以附加一个字典。该键需要与 DataFrame 列名相匹配。
### Appending a dict
my_dict = **{'name': 'E', 'math': 60, 'physics': 80, 'chemistry': 90 }**df1.append(my_dict, ignore_index=True)
熊猫附加()附加字典(图片由作者提供)
1.3 列表
有时，我们的数据可以是没有任何键或标签的列表，例如，JSON 格式的 HTTP 响应。将列表直接传递给熊猫append()会得到一个意想不到的结果:
### Appending a list - **wrong**
my_list = ['E', 60, 70, 80]df1.append(my_list, ignore_index=True)
熊猫追加()追加列表—错误(图片作者)
问题是 1D 数组['E', 60, 70, 80]被视为一个 4 乘 1 的矩阵，列名是从 0 开始的索引。列名不匹配，因此它被作为一个新列**0**。
要修复它，我们需要使用pd.Series()和参数index=df1.columns将列表转换成熊猫系列:
### Appending a list - **correct**my_list = ['E', 60, 70, 80]# Convert a lint to Pandas Series
**a_series = pd.Series(my_list, index=df1.columns)**df1.append(**a_series**, ignore_index=True)
熊猫追加()追加列表(图片由作者提供)
2.追加多行
通常，我们需要同时添加多行。熊猫append()可以接受类似 DataFrame/dict 的对象来添加多行。
2.1 数据框架
这里我们将把一个数据帧附加到df1。
# Create a DataFrame
df2 = pd.DataFrame({
'name': ['E', 'F', 'G', 'H'],
'math': [66,95,83,66],
'physics': [60,89,82,70],
'chemistry': [90,81,78,90]
})
要将df2追加到df1，我们可以简单地调用df1.append(df2)，它会将df2放在df1的底部。
df1.append(df2)
熊猫 append()追加数据帧(图片由作者提供)
您可能会注意到保留了df2的原始索引。如果我们希望从 0 开始的索引继续，我们可以设置ignore_index=True:
# With ingore_index=True
df1.append(df2, **ignore_index=True**)
熊猫 append()追加数据帧(图片由作者提供)
2.2 字典列表
我们也可以通过一个字典列表来追加多行。该键需要与 DataFrame 列相匹配。
## A list of dict
my_dict_list = [
{'name' : 'E', 'math' : 66, 'physics' : 60, 'chemistry': 90 },
{'name' : 'F', 'math' : 95, 'physics' : 89, 'chemistry': 81 },
{'name' : 'G', 'math' : 83, 'physics' : 82, 'chemistry': 78 },
{'name' : 'H', 'math' : 66, 'physics' : 70, 'chemistry': 90 }
]
熊猫追加()追加字典列表(图片由作者提供)
2.3 清单列表
类似地，我们也可以向传递一个列表列表来追加多行。最重要的部分是，我们首先需要使用带有参数columns=df1.columns的pd.DataFrame将列表转换成数据帧:
# A list of lists
my_list_of_list = [
['E', 66, 60, 90],
['F', 95, 89, 81],
['G', 83, 82, 78],
['H', 66, 70, 90]
]# Convert a list of lists to a DataFrame
my_df = **pd.DataFrame**(my_list_of_list, **columns=df1.columns**)df1.append(my_df, ignore_index=True)
熊猫 append()追加列表列表(图片由作者提供)
3.当列名没有对齐时
我们已经添加了一个类似数据帧/序列的对象，其列与原始数据帧的列相同。Pandas append()允许我们添加带有缺失/新列的数据集。
3.1 缺少的列
如果 DataFrame、Series 或 dict 中缺少列，则它们的值将作为输出中的NA:
熊猫 append()追加一个缺少列的数据帧(图片由作者提供)
3.2 新增栏目
如果我们在 DataFrame、Series 或 dict 中传递新的列名，那么新的列将在原始 DataFrame 上创建。
熊猫 append()用新列追加数据帧(图片由作者提供)
4 排序列名，sort=True
默认情况下，Pandas append()方法将遵循原始 DataFrame 的列顺序。如果我们希望输出按字母顺序排序，我们可以将参数sort设置为True:
df1.append(my_dict_list, ignore_index=True, **sort=True**)
熊猫 append()，sort=True(图片由作者提供)
5 避免 verify_integrity=True 的重复索引
熊猫append()中有一个参数verify_integrity用来配置输出是否允许重复索引。verify_integrity默认为False，表示输出允许重复索引。我们可以将它设置为True,以便在两行或更多行具有相同的索引时引发一个错误。例如，它抱怨重复的索引值**[1]**:
# Create a DataFrame
df2 = pd.DataFrame({
'name': ['E', 'F', 'G', 'H'],
'math': [66,95,83,66],
'physics': [60,89,82,70],
'chemistry': [90,81,78,90]
}, index=[**1**, 4, 5, 6])# Error Message
df1.append(df2, **verify_integrity=True**)
熊猫 append()，verify_integrity=True(图片由作者提供)
结论
在本文中，我们已经讨论了 5 个使用熊猫append()在当前数据帧末尾添加行的用例。该方法本身使用起来非常简单，是数据预处理中组合数据的最受欢迎的方法之一。
感谢阅读。请查看笔记本获取源代码，如果您对机器学习的实用方面感兴趣，请继续关注。更多教程可从 Github Repo 获得。
参考
[1] 什么是数据合并？
成为数据科学家:面向初学者的 5 种数据科学项目
原文：https://towardsdatascience.com/5-types-of-data-science-projects-for-beginners-6f33a7a0869c
初学者项目要放在你的作品集里
照片由屋大维丹在 Unsplash
介绍
进入数据科学大门的很大一部分是做项目。
首先，让我在这里说清楚:仅仅做项目不会保证你得到一份数据科学的工作。然而，由于数据科学如此多样化，在开始时拥有一个好的投资组合可以向雇主展示你拥有完成基本数据科学任务所需的基本技能。它允许您演示一些:
- 技术技能；
- 软技能(尤其是基于团队的项目)；
- 提取可行见解的能力。
如果你是数据科学的新手，并且你发现自己有一些空闲时间，你可以考虑我推荐给初学者的这 5 种数据科学项目。
除了阅读这篇文章，你还可以看看我在 YouTube 上关于这个话题的视频。
1.探索性数据分析
Joshua Sortino 在 Unsplash 上拍摄的照片
探索性数据分析(EDA)就是从数据中发现真知灼见。它构成了大多数数据科学项目的基础。这是因为 EDA 要求:
- 将数据清理和处理成正确的格式；
- 处理异常情况；
- 数据可视化；
- 统计分析，了解数据；
- 如果你在做机器学习的话。
在我看来，一个 EDA 项目(或者一个显示一些 EDA 的更大的项目)需要优先考虑，如果它不在你的投资组合中的话。
这通常没那么令人兴奋，但需要严格地完成。它为回答可能推动业务决策的问题奠定了基础。您以后可能进行的任何建模也需要它。
我建议使用有点乱的数据集，或者你甚至可以尝试自己收集一些数据来获得额外的印象分。这将使项目在展示你的结果时更加现实和有趣，而不是使用已经为你准备好的数据。
2.数据可视化(仪表板)
我的一个公共仪表盘。(图片由作者提供)
除非有专门的报告团队，否则我见过的几乎所有数据科学家的工作都需要一些创建仪表板的知识。
创建仪表板和良好的数据可视化可以让其他人看到数据并与之交互。这就是像 Power BI 和 Tableau 这样的工具非常有用的地方。
现在，你可以使用代码来创建仪表板。然而，这可能需要很大的努力来建立一些可靠和自动化的东西。现实情况是，大多数人并不关心你使用什么工具——他们只是想要一个他们可以信任并每天使用的东西。
认真对待分析的公司可能已经有了报告工具。他们可能已经建立了数据管道来处理和使用特定报告结构的数据。
就个人而言，我建议从 Tableau Public 这样的东西开始。这是免费的，你可以在他们的网站上创建一个在线作品集。
Power BI 也有免费版本，但我发现 Tableau 和他们的在线产品组合使用起来更直观。你选择哪一个并不重要；我见过很多招聘信息都要求这两者之一，因为技能相对来说是可以转移的。
如果你想更进一步，你甚至可以做他们提供的认证。尽管如此，我还是建议在进入认证之前先有一个投资组合，但如果你真的想认真对待数据可视化，它们是可用的。
3.回归
olieman.eth 在 Unsplash 上拍摄的照片
在大多数初学统计学的课程中，回归是首先要学的东西之一。有一个很好的理由:回归被用来预测一个连续变量。
这在现实世界中有很多应用，尤其是在金融领域。例如，您可以使用回归来预测和分析特定股票的趋势。
有许多不同类型的回归可用。在我看来，线性回归(最基本的一个)是开始学习的一个很好的工具。它教你基本的统计学，如果你想做的话，它是一个简单的机器学习工具。
一旦你习惯了，你也许可以尝试更有趣的方法，比如用神经网络进行时间序列预测。尽管坚持基本原则没有坏处，但是对于大多数问题来说，基本原则可以很好地完成工作。
在构建这些模型时，一定要仔细考虑如何评估它们。模型评估是了解您的模型是否适用于您的特定问题的关键步骤。
4.分类
克里斯·巴尔巴利斯在 Unsplash 上的照片
分类是关于预测分类结果的。它被称为监督的机器学习技术，因为它需要标记的数据，这是用类别或标签标记的数据；这种数据的一个例子是带有“性别”和“国籍”列的客户数据集。
就像回归模型一样，模型评估在这里也很重要。例如，如果您预测客户流失，那么您不会希望依赖准确性作为评估指标。因为职业的不均衡，你会想用精确和回忆之类的东西。
一些分类模型也给你一个预测类别的概率，你可以用它来帮助解释它的预测。
首先，我推荐像 XGBoost 这样的梯度增强算法，因为它们性能很好，运行起来很高效。如果你不知道什么是渐变提升，可以去看看这个视频或者介绍这个话题的博文。
5.使聚集
照片由阿德里安娜·吉奥在 Unsplash 拍摄
聚类就是将相似的数据组合在一起。更具体地说，这是一种无监督的机器学习技术，因为与分类模型相比，它不需要带标签的数据。
聚类可以在 EDA 中使用，或者用于生成在机器学习模型中使用的特征。在 EDA 中，聚类通过将数据点分组来帮助理解数据。这些数据组向我们展示了数据集中可能的关系。
例如，我们可能希望根据客户的支出或他们购买的产品对客户进行分组。这些小组可以让我们对客户行为有所了解。
我们最终可能会有两类客户:低价值客户和高价值客户。然后，我们可以根据这些数据点的分组对它们应用标签，从而得到一个增强的数据集。这为我们提供了一种训练分类模型的方法，该模型可以预测客户是低价值客户还是高价值客户。
基本上，集群在使用方式上非常灵活。您可以做一个专门研究集群的项目，也可以做一个包含集群的不同类型的项目。
结论
做项目是进入数据科学至关重要的一部分。希望这个列表能给你的下一个项目带来一些灵感；说到这里，你也可以看看这个视频，我在里面详细讲述了我是如何构建我的数据科学项目的。
如果你喜欢这篇文章，你可以看看我在 YouTube 上的其他视频。如果你想通过电子邮件了解我在做什么，你可以考虑注册我的简讯🙂
原载于 2022 年 1 月 7 日 https://leonlok.co.uk**的 。
