风险管理方法可能误导的 3 种方式以及如何纠正！
常见的错误会使你的风险管理努力完全无用，甚至适得其反。
埃斯彭·比埃尔德的照片
🔥【公告】
在你继续阅读这篇文章之前，我只想让你知道，几天前，我发布了一个完整的课程，帮助你提高你的决策技能，并在竞争中领先。
它是多年研究的成果，在有限的时间内免费提供。
👉如果你想用科学的方法做出更好的决定，这里有一个链接:https://smart-decision-makers.streamlit.app/
[/Announcement]🔥
为了最大化任何努力的成功机会，关键是要正确地识别和优先考虑风险，将你的精力和注意力集中在最重要的事情上。
在本文中，我将与您分享三个常见的错误，这些错误可能会使您的风险管理努力完全无用，甚至适得其反。
首先，我们来回忆一下一些定义；PMBoK(项目管理知识体系)指南将风险描述为:不确定的事件或条件，如果发生，会对项目目标产生积极或消极的影响。
因此，为了正确管理您在项目中识别的风险，您需要评估它们的概率和影响。
大多数风险管理方法依靠简单的尺度来评估风险的概率或影响。
例如，PMBoK 指南建议使用下面的定义表，按照从“非常高”到“非常低”的明确范围对概率和影响进行分类
PMBOK 指南 2017 年第 6 版—项目管理协会，表 11–1，第 407 页
错误#1:重复使用现有的比例定义
在许多情况下，比例定义是标准化的，由您的组织提供。您也可能会尝试重用以前项目中的比例定义。
为了说明这种做法有多危险，让我们举个例子。
如果你被告知优先考虑两个风险，一个可能会给你的项目增加 17%的延迟，另一个可能会使你的总预算增加 2 倍。你认为哪一个更重要？
这个问题的答案取决于你的项目的性质，然而，大多数人会同意损失 100%比损失 17%更重要。
现在，让我们使用 PMBOK 中提供的以前的规模定义表，并将其应用于一个预计持续两年的 50 万美元的项目。
假设您必须以相同的概率优先考虑两个风险，一个可能会使您的项目延迟 17% (4 个月)，第二个风险可能会使您损失 100%的预算(50 万美元)。
根据定义表，第一个风险(17%延迟)将被评定为“高优先级”，而第二个风险(100%超出预算)将被评定为“中等”。这和我们之前做出的直观结论正好相反！
作为一个收获，在使用任何尺度的定义之前，即使它是由您的组织提供的，您也应该始终确保不同的尺度是一致的、连贯的，并且非常适合您的项目环境。
错误#2:秤的压缩偏差
一旦您使用明确定义的等级评估了概率和影响级别，传统的风险管理方法会建议为每个等级关联一个分数。然后将概率和影响得分相乘，计算风险的重要程度。
这种危险程度越高，风险就越被认为是重要的，值得您采取行动，将其可能性或影响降低到可接受的水平。
在 PMBoK 指南中提供的示例中，建议的分数范围从 0.9 表示“非常高”的概率到 0.1 表示“非常低”的概率，影响分数范围从 0.8 到 0.05。
用这样的尺度，两个显著不同的随机事件可以被认为是等同的。例如，概率分别等于 0.71 和 0.99 的两个事件将具有相同的分数 0.9。
这种规模压缩现象甚至可以颠倒风险的优先顺序。例如，考虑两种风险:
- 风险 1:高概率(51% — 70%)和中等影响(50.1 万美元—100 万美元)
- 风险 2:低概率(11% — 30%)和高影响(100 万美元—500 万美元)
根据上面的概率-影响矩阵，第一个风险的重要程度(0.14)高于第二个风险(0.12)。我们希望它有更高的优先级。
但是，如果我们计算在两种情况下都有风险的最大预期影响，我们会发现优先级顺序相反！
事实上，第一种风险的最坏情况是 70 万美元(70% * 100 万美元:损失 100 万美元的可能性为 70%)，而第二种风险的最坏情况是 150 万美元(损失 500 万美元的可能性为 30%)。
如果我们将预算影响的所有可能值与关键程度的演变进行绘图，我们可以看到该函数正在减少的其他几个点。这意味着它颠倒了已识别风险的自然优先级顺序。
风险预算是风险重要程度的函数
我们刚刚证明，由于规模的压缩效应，风险管理方法可能导致风险优先级的逆转。
错误#3:秤的解释
我们在处理风险时犯的最后一种错误与人们(错误地)解释概率尺度的方式有关。
福特汉姆大学(Fordham University)心理计量学和定量心理学教授大卫·布德斯库(David Budescu)进行了几项研究，他询问了成千上万不同国籍的人对政府间气候变化专门委员会(IPCC)报告中句子的理解。
IPCC 是联合国评估气候变化相关科学的机构。IPCC 依靠概率尺度(如“不太可能”和“非常可能”)来传达其预测的潜在不确定性。
David Budescu 证明了人们系统地曲解概率陈述，即使他们被提供了这些尺度的明确定义(例如，不太可能< 33%; very likely > 90%)。
大卫·布德斯库的团队通过改变量表的定义，以匹配参与者将“可能”、“非常可能”和其他日常生活中使用的词联系起来的概率，成功地提高了与定义一致的解释的百分比。
因此，一致解释的百分比从 26%跃升至 40%。然而，40%的理解尺度的一致性仍然很低。
想象一下，你正在和你的同事开会，刚刚同意将一个特定的风险归类为“非常可能”，而你指的是“非常可能”与高于 90%的概率相关联的等级定义。
根据这项研究，您的团队中仍有 40%的人同意您使用“非常可能”这一级别，而如果让他们为同一事件分配一个概率，他们会说> 50%。
在这次会议中，你唯一成功做到的事情就是在你的团队中创造一种沟通和一致的假象，让他们知道什么是最重要的要解决的风险。
结论:
在本文中，我们刚刚分享了传统风险管理方法可能产生误导和模糊的 3 种方式。
我不是说你应该停止使用这些方法。然而，重要的是要意识到这些偏差，以便最大限度地利用这些方法，同时限制它们可能的缺点。
以下是增加你成功机会的几条指导方针:
- 如果你使用的是天平，确保它们是一致的，并且相互对齐。
- 当把你的量表转换成分数时，总是使用对称的分数，否则你会偏爱一种类型的影响。
- 总是倾向于直接使用定量概率，而不依赖于中间尺度。这是对不确定性进行明确描述的最佳方式。
参考
布德斯库，D.V .，波尔 h .，，布鲁姆尔，S. (2012 年)。IPCC 报告中不确定性的有效沟通。气候变化，113，181–200。
布德斯库，D.V .，波尔，h .，布鲁姆尔，s .，，史密森，M. (2014)。世界范围内 IPCC 概率声明的解释。自然气候变化，4508–512。DOI:10.1038。/NCLIMATE2194。
使用 Keras API 在 TensorFlow 中构建神经网络的 3 种方法
在 TensorFlow 2.x 中使用 Keras 构建深度学习模型，可以使用顺序 API 、功能 API 和模型子类
图一。顺序 API、函数 API、并行的子类化方法模型
如果你四处逛逛，查看不同的教程，进行谷歌搜索，花大量时间研究 TensorFlow 的堆栈溢出，你可能已经意识到有大量不同的方法来建立神经网络模型。长期以来，这一直是 TensorFlow 的一个问题。这几乎就像 TensorFlow 试图找到通往光明的深度学习环境的道路。如果你仔细想想，这正是正在发生的事情，对于 2.x 版本的库来说，这很正常。由于 TensorFlow 是迄今为止市场上最成熟的深度学习库，这基本上是你能得到的最好的库。
克拉斯-张量流关系
一点背景
TensorFlow 向深度学习平台的进化不是一蹴而就的。最初，TensorFlow 将自己推销为一个符号数学库，用于跨一系列任务的数据流编程。所以 TensorFlow 最初提供的价值主张并不是一个纯粹的机器学习库。目标是创建一个高效的数学库，以便在这个高效结构之上构建的定制机器学习算法可以在短时间内以高精度进行训练。
然而，用低级 API 重复地从零开始构建模型并不是很理想。所以，谷歌工程师 Franç ois Chollet 开发了 Keras，作为一个独立的高级深度学习库。虽然 Keras 已经能够在不同的库上运行，如 TensorFlow、Microsoft Cognitive Toolkit、Theano 或 PlaidML，但 TensorFlow 过去是，现在仍然是人们使用 Keras 的最常见的库。
现状
在看到模型构建过程的混乱之后，TensorFlow 团队宣布【Keras 将成为用于在 TensorFlow 2.0 中构建和训练模型的核心高级 API。另一个高级 APIEstimator API，在这个声明之后，已经开始失去它已经逐渐减少的受欢迎程度。
Estimator API 和 Keras API
图二。Keras API 和估算器 API 在张量流图中的位置
现在，让我们回到问题上:人们使用 TensorFlow 建立模型的方法有很多种。造成这个问题的主要原因是 TensorFlow 没有采用单一模型 API。
在 1.x 版本中，对于生产级项目，最常用的模型构建 API 是 Estimator API。但是，随着最近的变化，Keras API 几乎赶上了 Estimator API。最初，Estimator API 更具可伸缩性，允许多种分布，并且具有方便的跨平台功能。然而，Estimator API的大部分优势现在都消失了，因此，很快 Keras API 可能会成为构建 TensorFlow 模型的单一标准 API。
因此，在本文中，我们将只关注在 TensorFlow 中构建模型的 Keras API 方法，其中有三种方法:
- 使用顺序 API
- 使用函数式 API
- 模型子类化
我将直接将它们与相应的模型构建代码进行比较，这样您就可以亲自测试它们了。让我们深入编码。
进行比较的初始代码
为了测试这三种 Keras 方法，我们需要选择一个深度学习问题。用 MNIST 进行图像分类是一项非常简单的任务。我们试图实现的是训练一个模型来识别手写数字，使用著名的 MNIST 数据集。
图 3。基准分析的虚拟任务:MNIST 图像分类
MNIST 数据集，代表修改的国家标准和技术研究所数据库，是一个手写数字的大型数据库，通常用于训练各种图像处理系统。MNIST 数据库包含来自美国人口普查局员工和美国高中生的 60，000 幅训练图像和 10，000 幅测试图像。如果你想看完整的教程，你可以找到我关于图像分类的单独教程。
[## 使用 MNIST 数据集在 10 分钟内完成图像分类
利用 TensorFlow 和 Keras |监督深度学习使用卷积神经网络来分类手写数字
towardsdatascience.com](/image-classification-in-10-minutes-with-mnist-dataset-54c35b77a38d)
使用下面的代码，我们将导入所有的层和模型，这样在接下来的部分就不会打扰我们了。我们还下载了 MNIST 数据集并对其进行预处理，以便它可以用于我们将使用这三种不同方法构建的所有模型中。只需运行下面的代码:
要点 1。必要的进口，MNIST 装载，预处理
现在，这部分就不碍事了，让我们把重点放在建立张量流模型的三种方法上。
构建 Keras 模型的 3 种方法
在 TensorFlow 中构建 Keras 模型有三种方法:
- 顺序 API: 当你试图构建一个只有一个输入、输出和层分支的简单模型时，顺序 API 是最好的方法。对于想快速学习的新人来说，这是一个很好的选择。
- 函数式 API: 函数式 API 是构建 Keras 模型最流行的方法。它能做顺序 API 能做的一切。此外，它允许多输入、多输出、分支和层共享。这是一种简洁易用的方法，并且仍然允许很好的定制灵活性。
- **模型子类化:**模型子类化适用于需要完全控制他们的模型、层和训练过程的高级开发人员。您需要创建一个定义模型的定制类，并且您可能在日常任务中不需要它。但是，如果你是一个有实验需求的研究者，那么模型子类化可能是你最好的选择，因为它会给你所有你需要的灵活性。
图 4。使用展平图层将二维图像阵列转换为一维阵列
让我们看看这些方法是如何实现的。我们将建立一个基本前馈神经网络，它具有一个平坦层，将二维图像阵列转换为一维阵列和两个密集层。
顺序 API
在顺序 API 中，我们需要从 tf.keras.Models 模块创建一个顺序对象。我们可以简单地将所有层作为列表格式的单个参数传递，如下所示。如你所见，这很简单。
要点 2。用 Keras 顺序 API 构建的前馈神经网络
功能 API
对于函数式 API，我们需要单独定义我们的输入。然后，我们需要创建一个输出对象，方法是创建所有相互关联并与输出关联的层。最后，我们创建一个模型对象，它接受输入和输出作为参数。代码仍然非常干净，但是我们在函数式 API 中有了更多的灵活性。
要点三。用 Keras Functional API 构建的前馈神经网络
模型子类化
让我们继续讨论模型子类化。在模型子类化中，我们从创建一个扩展 tf.keras.Model 类的类开始。模型子类化有两个关键功能:
- init 函数充当构造函数。多亏了 init ，我们可以初始化模型的属性(例如层)。用于调用父构造函数(构造函数在 tf.keras.Model )和 self 用于引用实例属性(如图层)。
- 调用 函数是在 init 函数中定义图层后定义操作的地方。
为了用模型子类化构建相同的模型，我们需要编写更多的代码，如下所示:
要点 4。基于 Keras 模型子类化的前馈神经网络
结束代码
既然您可以用三种不同的方法创建同一个模型，那么您可以选择其中的任何一种，构建模型，并运行下面的代码。
要点 5。模型配置、培训和评估
上面几行负责模型配置、训练和评估。当我们比较这三种方法的性能时，我们看到它们非常接近，但略有不同。
表 1。不同 Keras 方法的性能:顺序 API、函数 API 和模型子类化
Jonathan Chng 在 Unsplash 上的照片
我们更复杂的模型子类化方法优于顺序 API 和函数 API。这表明这些方法在低端的设计上也有细微的差别。然而，这些差异可以忽略不计。
最终评估
到目前为止，您已经了解了这三种 Keras 方法之间的异同。但是，让我们用一个表格来总结一下:
表二。TensorFlow 中构建 Keras 模型的不同方法比较:顺序 API、函数 API 和模型子类化
总之，如果您刚刚开始，请坚持使用顺序 API。当您深入到更复杂的模型时，尝试一下函数式 API。如果你正在读博士或者只是喜欢进行独立的研究，试试模型子类化。如果你是专业人士，坚持使用功能 API。它可能会满足你的需要。
在评论中让我知道你最喜欢的建立 Keras 模型的方法。
订阅邮件列表获取完整代码
如果你想在 Google Colab 上获得完整的代码，并获得我的最新内容，请订阅邮件列表:✉️
喜欢这篇文章吗？
如果你喜欢这篇文章，可以考虑看看我的其他类似文章:
* [## 4 个预训练的 CNN 模型，用于具有迁移学习的计算机视觉
使用最先进的预训练神经网络模型，通过迁移学习解决计算机视觉问题
towardsdatascience.com](/4-pre-trained-cnn-models-to-use-for-computer-vision-with-transfer-learning-885cb1b2dfc) [## TensorFlow Hub & Magenta 在 5 分钟内实现快速神经风格转换
利用 Magenta 的任意图像风格化网络和深度学习，将梵高的独特风格转移到照片中
towardsdatascience.com](/fast-neural-style-transfer-in-5-minutes-with-tensorflow-hub-magenta-110b60431dcc) [## 使用 MNIST 数据集在 10 分钟内完成图像分类
利用 TensorFlow 和 Keras |监督深度学习使用卷积神经网络来分类手写数字
towardsdatascience.com](/image-classification-in-10-minutes-with-mnist-dataset-54c35b77a38d)*
Python 中计算加权平均值的 3 种方法
编程 | 面试 | 办公时间
在这篇简短的教程中，我将展示如何在 Python 中定义自己的函数或使用 NumPy 来计算加权平均值
照片来自像素
更新:你们中的许多人联系我，要求提供宝贵的资源，以便使用 Python 自动化 Excel 任务，或者使用 Python应用流行的统计概念 。下面我分享我推荐的四门课程:
希望你也会发现它们有用！现在欣赏:D 的文章
何时使用加权平均值？
假设您必须分析下表，该表显示了一家小公司员工的年薪，这些员工分为五组(从低到高工资):
作者在 Tableau 中创建的图像。使用了模拟数据。
如果您计算Salary Per Year列的简单平均值，您将获得:
但是 62000 英镑能准确代表所有群体的平均工资吗？因为数据已经汇总，每个组有不同的Employees Number，每个组的平均Salary Per Year在总平均值中的权重不同。在计算简单平均值时，每组的权重相同，导致结果有偏差。
在这种情况下，解决方案是通过计算加权平均值来考虑每组的权重，加权平均值可以用以下公式用代数表示:
其中x代表分配(Salary Per Year),w代表待分配的权重(Employees Number)。假设该表包括五个组，则上述公式变为:
用实际数字代替x和w，你应该得到下面的结果:
请注意，考虑到权重因素，各组的平均值Salary Per Year几乎比简单平均法计算出的值低 18，000，这是描述数据集的一种准确方式，因为每组都有一定数量的员工。
既然已经介绍了理论，让我们看看如何使用 3 种不同的方法在 Python 中获得加权平均值。为此，第一步是导入包和employees_salary表本身:
import pandas as pd
from numpy import averagedf = pd.read_csv(‘C:/Users/anbento/Desktop/employee_salary.csv’)df.head()
distribution = df[‘salary_p_year’]
weights = df[‘employees_number’]
[## 3 纳米学位你应该考虑在 2021 年推进你的数据工程职业
towardsdatascience.com](/3-nanodegrees-you-should-consider-to-advance-your-data-engineering-career-in-2021-baf597debc72)
方法 1:使用列表理解的功能
如果您希望编写自己的算法，计算加权平均值的第一个非常简单的方法是使用列表理解来获得每个Salary Per Year与相应的Employee Number ( numerator)的乘积，然后除以权重之和(denominator)。
Output:
44225.35
上面的函数可以很容易地重写为一行代码:
Output:
44225.35
方法 2:使用 Zip()函数
除了使用列表理解，您可以简单地从空列表(weighted_sum)开始，并通过其weight附加每个组的平均值salary的乘积。zip()函数非常方便，因为它生成一个元组迭代器，帮助将每个salary与对应的weight配对。
Output:
44225.35
方法 3:使用 Numpy Average()函数
numpy包包括一个average()函数(已经在上导入)，您可以在其中指定一个权重列表来计算加权平均值。这是迄今为止在生产中执行此类计算最简单、最灵活的方法:
Output:
44225.35
在这篇文章中，我介绍并分享了 FAANG 中经常出现的一些基本算法的解决方案
towardsdatascience.com](/10-algorithms-to-solve-before-your-python-coding-interview-feb74fb9bc27)
结论
在这个简短的教程中，我们了解了每次以汇总或分组的方式呈现数据时，加权平均值应该是首选选项，其中可以确定一些数量或频率。我们还发现了至少 3 种使用 Python 计算加权平均值的方法，要么使用自定义函数，要么使用内置函数。我很想知道你是否使用其他算法或软件包来计算加权平均值，所以请留下你的评论！
给我的读者一个提示
这篇文章包括附属链接，如果你购买的话，我可以免费给你一点佣金。
你可能也喜欢
通过从真实面试中解决问题来练习，最终得到你应得的工作。
towardsdatascience.com](/7-fundamental-sql-concepts-you-will-be-challenged-with-in-faang-interviews-d26097a8d867) [## 使用环境变量隐藏您的密码
关于如何在使用 Python 连接到数据库时使用环境变量隐藏密钥的教程
towardsdatascience.com](/connect-to-databases-using-python-and-hide-secret-keys-with-env-variables-a-brief-tutorial-4f68e33a6dc6) [## 在你开始第一个项目之前，要掌握 15 个 Git 命令
您需要掌握的最后一个 Git 教程是命令行版本控制。
towardsdatascience.com](/15-git-commands-you-should-learn-before-your-very-first-project-f8eebb8dc6e9)
使用 Keras 和 TensorFlow 2.0 创建机器学习模型的 3 种方法(顺序、函数和模型子类化)
为初学者构建机器学习模型的分步教程
使用 Keras 和 TensorFlow 2.0 创建机器学习模型的 3 种方法
在我之前的文章 Google 机器学习实践的 7 个步骤:结构化数据的 TensorFlow 示例中，我提到了用 Keras 和 TensorFlow 2.0 实现机器学习模型的 3 种不同方法
- 顺序模型是在 TensorFlow 2.0 中启动和运行 Keras 的最简单方法
- 功能 API 用于更复杂的模型，尤其是具有多个输入或输出的模型。
- 模型子类化是完全可定制的，使我们能够实现我们自己定制的模型前向传递
在本文中，我们将学习如何用三种不同的方法建立一个机器学习模型，以及如何为我们的项目选择正确的方法。
环境设置、源代码和数据集准备
为了运行本教程，您需要安装
TensorFlow 2，numpy，pandas，sklean，matplotlib
它们都可以直接安装在 vis PyPI 上，我强烈建议创建一个新的虚拟环境。最佳实践是避免使用 base(root) ，因为这可能会破坏您的系统。
有关创建 Python 虚拟环境的教程，您可以在这里查看:
[## 使用“virtualenv”创建虚拟环境，并将其添加到 Jupyter 笔记本中
你是机器学习工程师，正在使用 Python 和 Jupyter Notebook 吗？在这篇文章中，你会看到为什么…
towardsdatascience.com](/create-virtual-environment-using-virtualenv-and-add-it-to-jupyter-notebook-6e1bf4e03415) [## 使用“conda”创建虚拟环境，并将其添加到 Jupyter 笔记本中
你正在使用 anaconda 和使用 Jupyter Notebook 和 Python 吗？在这篇文章中，你将看到如何创建虚拟的…
medium.com](https://medium.com/analytics-vidhya/create-virtual-environment-using-conda-and-add-it-to-jupyter-notebook-d319a81dfd1)
源代码
这是一个循序渐进的教程，所有的说明都在这篇文章中。我已经把笔记本开源了，请查看最后的 Github 链接。
数据集准备
本教程使用安德森鸢尾花(iris) 数据集进行演示。该数据集包含五个属性下的一组 150 条记录:萼片长度、萼片宽度、花瓣长度、花瓣宽度、和类(从 sklearn 数据集称为目标)。
首先，让我们导入库并从 scikit-learn 库中获取虹膜数据集。你也可以从 UCI 虹膜数据集下载。
import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split**iris = load_iris()**
为了研究数据，让我们将数据加载到一个数据帧中
# Load data into a DataFrame
**df = pd.DataFrame(iris.data, columns=iris.feature_names)** # Convert datatype to float
**df = df.astype(float)** # append "target" and name it "label"
**df['label'] = iris.target** # Use string label instead
**df['label'] = df.label.replace(dict(enumerate(iris.target_names)))**
并且df应该如下所示:
运行df.head()预览虹膜数据
我们注意到 标签 列是一个分类特征，需要将其转换成一个热编码。否则，我们的机器学习算法将无法直接将其作为输入。
# label -> one-hot encoding
**label = pd.get_dummies(df['label'])
label.columns = ['label_' + str(x) for x in label.columns]**
**df = pd.concat([df, label], axis=1)**# drop old label
df.drop(['label'], axis=1, inplace=True)
现在，df应该是这样的:
接下来，让我们创建X和y。Keras 和 TensorFlow 2.0 只接受 Numpy 数组作为输入，所以我们必须将 DataFrame 转换回 Numpy 数组。
# Creating X and y**X = df[['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']]**
# Convert DataFrame into np array
**X = np.asarray(X)****y = df[['label_setosa', 'label_versicolor', 'label_virginica']]** # Convert DataFrame into np array
**y = np.asarray(y)**
最后，让我们使用来自 sklearn 库的**train_test_split()** 将数据集拆分成训练集(75%)和测试集(25%)。
X_train, X_test, y_train, y_test **= train_test_split(
X,
Y,
test_size=0.25
)**
太好了！我们的数据已经准备好建立一个机器学习模型。
1.顺序模型
顺序模型是层的线性堆叠。创建顺序模型有两种方法
- 将层列表传递给构造函数
- 只需通过
.add()方法添加图层:
让我们继续建立一个具有 3 个密集层的神经网络。
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense# Passing a list of layers to the constructor
model = Sequential(**[
Dense(5, activation='relu', input_shape=(4,)),
Dense(10, activation='relu'),
Dense(3, activation='softmax'),
]**)model.summary()
通过.add()方法，以上与以下相同
# Adding layer via add() method
model = Sequential()
model.**add(Dense(5, activation='relu', input_shape=(4,)))**
model.**add(Dense(10, activation='relu'))**
model.**add(Dense(3, activation='softmax'))**model.summary()
顺序模型需要知道它应该期望什么样的输入形状。因此，顺序模型中的第一层需要接收关于其输入形状的信息，这通常通过指定input_shape参数来完成。
1.1 训练一个序列模型
为了训练一个序列模型，我们首先必须使用model.compile()配置我们的模型，参数如下:
- 使用优化器 RMSProps (
rmsprop) - 对于我们的 多类分类 问题，使用分类交叉熵损失函数(
categorical_crossentropy - 为简单起见，使用
accuracy作为我们在训练和测试期间评估模型的评估指标。
model.compile(
**optimizer='rmsprop',**
**loss='categorical_crossentropy',**
**metrics=['accuracy']**
)
之后，我们可以调用model.fit()来训练我们的模型
history = **model.fit**(X_train, y_train,
batch_size= 64,
epochs= 30,
validation_split=0.2
)
如果一切顺利，我们应该得到如下输出
Train on 89 samples, validate on 23 samples
Epoch 1/30
89/89 [==============================] - 1s 13ms/sample - loss: 1.4717 - accuracy: 0.3258 - val_loss: 1.1884 - val_accuracy: 0.3478
Epoch 2/30
89/89 [==============================] - 0s 465us/sample - loss: 1.4152 - accuracy: 0.3258 - val_loss: 1.1683 - val_accuracy: 0.3478
Epoch 3/30
89/89 [==============================] - 0s 463us/sample - loss: 1.3836 - accuracy: 0.3258 - val_loss: 1.1503 - val_accuracy: 0.3478
......
......
Epoch 30/30
89/89 [==============================] - 0s 488us/sample - loss: 1.0734 - accuracy: 0.3258 - val_loss: 1.0290 - val_accuracy: 0.3478
1.2 模型评估
一旦训练完成，就该看看模型是否适合模型评估了。模型评估通常包括
- 绘制损失和准确度指标的进度
- 用从未用于训练的数据来测试我们的模型。这就是我们之前搁置的测试数据集
X_test发挥作用的地方。
让我们创建一个函数plot_metric()来绘制指标。
%matplotlib inline
%config InlineBackend.figure_format = 'svg'
def plot_metric(history, metric):
train_metrics = history.history[metric]
val_metrics = history.history['val_'+metric]
epochs = range(1, len(train_metrics) + 1)
plt.plot(epochs, train_metrics, 'bo--')
plt.plot(epochs, val_metrics, 'ro-')
plt.title('Training and validation '+ metric)
plt.xlabel("Epochs")
plt.ylabel(metric)
plt.legend(["train_"+metric, 'val_'+metric])
plt.show()
通过运行plot_metric(history, 'loss')来绘制损失进度。
通过运行plot_metric(history, 'accuracy')绘制精度进度。
根据测试数据集测试我们的模型
model.**evaluate**(x = **X_test**,y = **y_test**)
我们应该得到一个具有损耗和精度的输出，如下所示:
38/1 [===] - 0s 139us/sample - **loss: 0.9356** - **accuracy: 0.7105**[0.9538187102267617, 0.7105263]
1.3 何时使用顺序模型
顺序模型适用于简单的层堆叠，其中每层都有一个输入和一个输出。
一个顺序模型是不合适当[1]:
- 您的模型有多个输入或多个输出
- 您的任何图层都有多个输入或多个输出
- 您需要进行图层共享
- 您需要非线性拓扑(例如，剩余连接、多分支模型)
2.功能 API
Keras functional API 提供了一种更加灵活的定义模型的方式。特别是，它允许我们定义多个输入或输出模型以及共享层的模型。
让我们使用函数式 API 创建相同的神经网络
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense# This returns a tensor
**inputs = Input(shape=(4,))**# A layer instance is callable on a tensor, and returns a tensor
**x = Dense(5, activation='relu')(inputs)
x = Dense(10, activation='relu')(x)
outputs = Dense(3, activation='softmax')(x)**# This creates a model that includes
# the Input layer and three Dense layers
**model = Model(inputs=inputs, outputs=outputs)**model.summary()
在函数式 API 中:
- 每一层实例都是 上一个可调用的张量 ，而 则返回一个张量
Input()用于定义以输入形状为自变量的输入层**shape=(4,)**- 在
Model()中我们只需要引用inputs和outputs张量
2.1 训练一个功能 API 模型
功能 API 模型可以像顺序模型一样被训练。
# First configure model using model.compile()
model.compile(
optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy']
)# Then, train the model with fit()
history = model.fit(X_train, y_train,
batch_size= 64,
epochs= 30,
validation_split=0.2
)
如果一切顺利，我们应该得到如下输出
Train on 89 samples, validate on 23 samples
Epoch 1/30
89/89 [==============================] - 1s 10ms/sample - loss: 1.5887 - accuracy: 0.3596 - val_loss: 2.0215 - val_accuracy: 0.1739
Epoch 2/30
89/89 [==============================] - 0s 475us/sample - loss: 1.4872 - accuracy: 0.3596 - val_loss: 1.9218 - val_accuracy: 0.1739
Epoch 3/30
89/89 [==============================] - 0s 470us/sample - loss: 1.4204 - accuracy: 0.3596 - val_loss: 1.8256 - val_accuracy: 0.1739
Epoch 4/30
89/89 [==============================] - 0s 486us/sample - loss: 1.3627 - accuracy: 0.3596 - val_loss: 1.7535 - val_accuracy: 0.1739
......
......
Epoch 30/30
89/89 [==============================] - 0s 477us/sample - loss: 0.8373 - accuracy: 0.4719 - val_loss: 0.9029 - val_accuracy: 0.3043
2.2 模型评估
这个模型可以像我们在序列模型中所做的那样进行评估
通过运行plot_metric(history, 'loss')绘制损失进度。
通过运行plot_metric(history, 'accuracy')绘制精度进度。
根据测试数据集测试我们的模型
model.**evaluate**(x = **X_test**,y = **y_test**)
我们应该得到一个具有损耗和精度的输出，如下所示:
38/1 [===] - 0s 139us/sample - **loss: 0.7776** - **accuracy: 0.6053**[0.8011450893000552, 0.6052632]
2.3 多输入多输出模型
具有多输入或多输出的模型是函数式 API 的良好用例。这里，我展示了 3 种不同的场景:
- 具有 2 个输入和 1 个输出的模型
- 具有 1 个输入和 2 个输出的模型
- 具有两个输入和两个输出的模型
**对于有 2 个输入和 1 个输出的模型。**假设我们有用于鸢尾花分类的图像数据和结构化数据。我们想建立一个机器学习模型，如下所示:
2 输入 1 输出神经网络
函数式 API 使得构建它变得很容易
from tensorflow.keras.layers import concatenate# 2 inputs, one structure data, the other image data
**input_structure = Input(shape=(4,), name='input_structure')
input_image = Input(shape=(256,), name='input_image')**# middle layers
x_1 = Dense(10, activation='relu')(input_structure)
x_2 = Dense(100, activation='relu')(input_image)**c = concatenate([x_1, x_2])**outputs = Dense(3, activation='sigmoid', name='outputs')(c)model = Model(**inputs=[input_structure, input_image], outputs=outputs**)model.summary()
为了获得 2 个不同的输入，我们需要使用**concatenate([x_1, x_2])**将它们连接起来。要定义一个有多个输入的模型，我们只需要指定一个输入列表**inputs=[input_structure, input_image]**。
如果全部运行成功，我们应该得到如下摘要:
**对于有 1 个输入和 2 个输出的模型。**假设我们只有图像数据，任务是识别给定图像是否是花，如果是，是什么类型的鸢尾花？
并用功能 API 来构建它
from tensorflow.keras.layers import concatenate# only one input
**input_image = Input(shape=(256,), name='input_image')**# middle layer
x = Dense(300, activation='relu')(input_image)# output layser
output_1 = Dense(1, activation='sigmoid', name='output_1')(x)
output_2 = Dense(3, activation='softmax', name='output_2')(x)model = Model(inputs=input_image, **outputs=[output_1, output_2]**)model.summary()
为了定义一个有多个输出的模型，我们只需要指定一个输出列表**outputs=[output_1, output_2]** 。
如果一切顺利，我们应该会得到如下摘要。
**对于有 2 个输入和 2 个输出的模型。**假设我们有结构化数据和图像数据。任务是识别图像中是否有鸢尾花，以及它是什么类型的鸢尾花。
2 个输入和 2 个输出
有了函数式 API，构建它相当容易
from tensorflow.keras.layers import concatenate# 2 inputs, one structured data, the other image data
**input_structured = Input(shape=(4,), name='input_structured')
input_image = Input(shape=(256,), name='input_image')**# middle layers
x_1 = Dense(10, activation='relu')(input_structure)
x_2 = Dense(300, activation='relu')(input_image)**c = concatenate([x_1, x_2])**# output layser
**output_1 = Dense(1, activation='sigmoid', name='output_1')(c)
output_2 = Dense(3, activation='softmax', name='output_2')(c)**model = Model(**inputs=[input_structured, input_image], outputs=[output_1, output_2]**)model.summary()
要定义一个有多个输入和多个输出的模型，我们只需要使用**concatenate([x_1, x_2])**连接输入，并指定输入和输出列表来建模Model(**inputs=[input_structured, input_image], outputs=[output_1, output_2]**)。
如果一切顺利，我们应该会得到如下摘要。
2.4 功能 API 中的共享层
函数式 API 的另一个好用途是使用共享层的模型。让我们来看看共享图层。
inputs = Input(shape=(4,))# a layer instance is callable on a tensor, and returns a tensor
**shared_layer = Dense(4, activation='relu')**# Now we apply the layer three times
x = **shared_layer**(inputs)
x = **shared_layer**(x)
x = **shared_layer**(x)
x = **shared_layer**(x)predictions = Dense(3, activation='softmax')(x)model = Model(inputs=inputs, outputs=predictions)model.summary()
一个层实例在张量上是可调用的，并返回一个张量，这就是我们如何创建一个共享层。
3.模型子类化
最后一种用 Keras 和 TensorFlow 2.0 实现机器学习模型的方法叫做模型子类化。这种构建模型的方式为您提供了对模型的构造和操作的低级控制。
让我们看看如何使用它来建立我们的虹膜流量分类器。
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Denseclass **CustomModel(Model)**:
def __init__(self, **kwargs):
super(CustomModel, self).__init__(**kwargs)
**self.dense1 = Dense(5, activation='relu', )
self.dense2 = Dense(10, activation='relu')
self.dense3 = Dense(3, activation='softmax')**
def call(self, **inputs**):
**x = self.dense1(inputs)
x = self.dense2(x)
return self.dense3(x)**my_custom_model = CustomModel(name='my_custom_model')
这个模型类CustomModel与我们使用顺序模型和函数式 API 制作的模型相同。事实上，顺序模型和函数 API 都继承自Model类。
如您所见，CustomModel继承自模型类。当模型子类化时要记住的基本结构是，我们在初始化器__init__()中创建层，并在call()方法中定义向前传递。
3.1 训练模型子类化模型
可以像顺序模型和函数 API 一样训练模型子类模型。
my_custom_model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])history = my_custom_model.fit(X_train, y_train,
batch_size= 64,
epochs= 30,
validation_split=0.2)
如果一切运行顺利，您应该得到如下输出:
Train on 89 samples, validate on 23 samples
Epoch 1/30
89/89 [==============================] - 1s 13ms/sample - loss: 1.5281 - accuracy: 0.3596 - val_loss: 1.6140 - val_accuracy: 0.1739
Epoch 2/30
89/89 [==============================] - 0s 571us/sample - loss: 1.3818 - accuracy: 0.3596 - val_loss: 1.4869 - val_accuracy: 0.1739
Epoch 3/30
89/89 [==============================] - 0s 711us/sample - loss: 1.3231 - accuracy: 0.3596 - val_loss: 1.4209 - val_accuracy: 0.1739
Epoch 4/30
89/89 [==============================] - 0s 598us/sample - loss: 1.2934 - accuracy: 0.3596 - val_loss: 1.3799 - val_accuracy: 0.1739
......
......
Epoch 30/30
89/89 [==============================] - 0s 555us/sample - loss: 1.1350 - accuracy: 0.4831 - val_loss: 1.1362 - val_accuracy: 0.6087
我们也可以调用my_custom_model.summary()来显示它的内容:
模型子类化摘要的输出
3.2 模型评估
这个模型可以像我们在顺序模型和函数式 API 中那样进行评估。
通过运行plot_metric(history, 'loss')来绘制损失进度。
通过运行plot_metric(history, 'accuracy')绘制精度进度。
根据测试数据集测试我们的模型
my_custom_model.**evaluate**(x = **X_test**,y = **y_test**)
我们应该得到一个具有损耗和精度的输出，如下所示:
38/1 [===] - 0s 139us/sample - **loss: 1.1417** - **accuracy: 0.4737**[1.1410379598015232, 0.47368422]
3.3 什么时候使用模型子类化？
模型子类化为我们提供了对模型的构造和操作的低级控制。然而，它的灵活性给 bug 带来了更多的机会，而且比顺序模型和函数式 API 更难利用。模型子类化主要由研究人员用来实现奇异的架构或定制的层/模型，这是使用顺序模型和功能 API 不可能实现的。
因此，尽管模型子类化使我们能够做任何事情，我还是建议只在你真正需要的时候才使用这种方法。
就这样，接下来呢？
本文是快速介绍，主要是给大家展示用 Keras 和 TensorFlow 2 实现一个机器学习模型的三种不同方式。我已经尽量避免了很多机器学习的概念和配置，让这个教程对于初学者来说尽可能的简单。
请在我的 Github 上查看笔记本的源代码。
在实际项目中，使用 Keras 和 TensorFlow 2 构建模型时，需要考虑更多的配置。例如，优化器、损失函数、评估指标、批量、验证分割等。另外，本教程只使用了Dense()层，还没有提到任何关于深度学习的内容。
下一步是什么？既然有几个人问我超参数调优的问题，那我们下次就用网格搜索，随机搜索，超带算法做个教程吧。
如果你对机器学习的实用方面感兴趣，请继续关注。
参考
使用 Python 从日期中提取要素的 3 种方法
在一行代码中从时间序列数据集中获取更多要素
动机
处理时间序列时，数据集的值可能会受到节假日、一周中的哪一天以及一个月中有多少天的影响。有没有一种方法可以用一行代码从日期特性中提取这些特性？
是啊！在本文中，我将向您展示如何使用两个不同的 Python 库从 date 列中提取上述三个特性。
导入和处理数据
我们将使用每日女性出生数据集。这个数据集描述了 1959 年加州每天女性出生的数量。
使用以下方式下载数据:
!wget [https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-total-female-births.csv](https://raw.githubusercontent.com/jbrownlee/Datasets/master/daily-total-female-births.csv)
Datapane 随机分配时间，因此您可以忽略表中的时间。现在我们将数据可视化
df.set_index('Date').plot()
提取工作日
一周中不同的日子可能会影响出生的数量。因此，我们将添加工作日作为我们数据的一个特征
提取假期
节假日也会影响生育数量。父母可能会避免在新年或圣诞节等节日带孩子。在这篇博客中，圣诞节被认为是出生婴儿最少的一天。
基于日期提取假日的最简单方法是使用名为 holidays 的 Python 库。安装假日使用
pip install holidays
假日图书馆提供许多国家的假日。我们还可以指定要从国家的哪个州或省提取假期。
由于我们的数据描述了加州每天女性分娩的数量，因此我们将找到加州的假期。在得到一个假期字典后，我们简单地使用holiday_dict.get(date)来得到那个日期的假期。
Timestamp('1959-01-01 00:00:00')"New Year's Day"
我们也可以在所有可用的假期达到顶峰
datetime.date(1959, 1, 1): "New Year's Day",
datetime.date(1959, 2, 22): "Washington's Birthday",
datetime.date(1959, 5, 30): 'Memorial Day',
datetime.date(1959, 7, 4): 'Independence Day',
datetime.date(1959, 7, 3): 'Independence Day (Observed)',
datetime.date(1959, 9, 7): 'Labor Day',
datetime.date(1959, 10, 12): 'Columbus Day',
datetime.date(1959, 11, 11): 'Veterans Day',
datetime.date(1959, 11, 26): 'Thanksgiving',
datetime.date(1959, 12, 25): 'Christmas Day'}
尝试调用字典中没有的日期
None
如果您发现字典中缺少一些日期，您还可以创建自定义假日对象。
让我们使用这个库为数据集创建一个假日要素。
厉害！现在我们有了一个具有假日特征的数据集。为了比较节假日和正常工作日的出生人数，我们将数据按节假日分组，并取同一天所有出生人数的中位数。
可视化我们的数据
元旦出生人数最少。与正常日期的出生人数相比，其他节日的出生人数似乎相当高。
然而，这个数据仅仅是一年内的，所以不足以让我们确定假期对出生人数的实际影响。如果我们有一个 3 年或 4 年的数据集，我们可能会发现在其他节假日出生的人数比正常日期少。
提取一个月中的天数
父母也可能避免在 2 月 29 日生孩子，因为这是每四年一次的日子。
如果我们想比较不同月份之间的出生人数，一个月中的日期数也可能会影响出生人数。因此，在分析我们的时间序列数据集时，将一个月中的日期数量考虑在内可能很重要。
提取特定月份和年份的天数的一个非常快速的方法是使用calendar.monthrange.这是一个内置的 Python 库，所以我们不需要安装这个库来使用它。
monthrange()方法用于获取指定年份和月份中每月第一天的工作日和一个月中的天数。
Weekday of first day of the month: 5
Number of days in month: 29
自从我们知道 2020 年 2 月有 29 天以来，这个库似乎工作得很好。我们将使用它为我们的数据集创建一个days_in_a_month列
厉害！现在我们可以比较每月平均出生人数和每月天数
9 月份平均出生人数有一个高峰。可能是因为 9 月份的天数比其他月份多？你可能已经知道答案了，但是让我们用一个月中的天数柱状图来确认一下
不完全是。九月只有 30 天。一月、三月、五月等月份的天数更多。
即使我们在这里看不到直接的相关性，但一个月中的天数和其他特征的组合可以给我们一些与出生人数的相关性。
结论
恭喜你！您已经学习了如何使用日期为时间序列数据集创建更多要素。我希望这些想法能帮助你想出创造性的方法来处理时间序列数据集。
本文的源代码可以在这里找到。
Permalink GitHub 是 5000 多万开发人员的家园，他们一起工作来托管和审查代码、管理项目以及…
github.com](https://github.com/khuyentran1401/Data-science/blob/master/time_series/extract_features/extract_features_from_dates.ipynb)
我喜欢写一些基本的数据科学概念，并尝试不同的算法和数据科学工具。你可以在 LinkedIn 和推特上和我联系。
如果你想查看我写的所有文章的代码，请点击这里。在 Medium 上关注我，了解我的最新数据科学文章，例如:
[## 自动读取、创建和运行多个文件的 3 个 Python 技巧
用 Python 和 Bash For Loop 自动化枯燥的东西
towardsdatascience.com](/3-python-tricks-to-read-create-and-run-multiple-files-automatically-5221ebaad2ba) [## 可视化的 6 大 Python 库:使用哪一个？
对使用哪种可视化工具感到困惑？我为你分析了每个图书馆的利弊
towardsdatascience.com](/top-6-python-libraries-for-visualization-which-one-to-use-fe43381cd658) [## 我收集了超过 1k 的顶级机器学习 Github 配置文件，这就是我的发现
从 Github 上的顶级机器学习档案中获得见解
towardsdatascience.com](/i-scraped-more-than-1k-top-machine-learning-github-profiles-and-this-is-what-i-found-1ab4fb0c0474) [## 使用 TextBlob 增强您的 Python 字符串
在一行代码中获得更多关于文本的见解！
towardsdatascience.com](/supercharge-your-python-string-with-textblob-2d9c08a8da05)
在你第一份工作之前获得现实生活数据科学经验的 3 种方法
如何通过实际项目发展您的数据科学技能
由故事创建的信息图向量—www.freepik.com
介绍
获得我的第一份数据科学工作很难。
当公司通常要求硕士学位和至少 2-3 年的经验时，进入数据科学领域尤其困难。也就是说，我发现了一些很棒的资源，想和大家分享一下。
在本文中，我将向您介绍三种可以让您自己获得实际数据科学经验的方法。通过完成这些项目，你将对 SQL 、熊猫和机器学习建模有一个深刻的理解。
- 首先，我将为您提供真实的 SQL 案例研究，在这些案例中，您遇到了一个业务问题，需要查询数据库来诊断问题并制定解决方案。
- 其次，我将为你提供几十个熊猫练习题，熊猫是 Python 中的一个库，用于数据操作和分析。这将有助于您发展数据争论和数据清理所需的技能。
- 最后，我将为您提供各种机器学习问题，您可以开发一个机器学习模型来进行预测。通过这样做，您将学习如何处理机器学习问题，以及从头到尾开发机器学习模型所需的基本步骤。
说了这么多，让我们开始吧！
1.SQL 案例研究
如果你想成为一名数据科学家，你必须有很强的 SQL 技能。Mode 提供了三个模拟真实业务问题的实用 SQL 案例研究，以及一个在线 SQL 编辑器，您可以在其中编写和运行查询。
要打开 Mode 的 SQL 编辑器，请转到 此链接 并单击显示“打开另一个 Mode 窗口”的超链接。
学习 SQL
如果您是 SQL 新手，我会首先从 Mode 的 SQL 教程开始，在那里您可以学习基本、中级和高级 SQL 技术。如果您已经对 SQL 有了很好的理解，可以跳过这一步。
案例研究 1:调查用户参与度的下降
链接到案例 。
本案例的目的是确定 Yammer 项目用户参与度下降的原因。在深入研究这些数据之前，您应该先阅读一下 Yammer 的概述这里是。您应该使用 4 张表。
到案例的链接将为您提供关于问题、数据和应该回答的问题的更多细节。
如果你需要指导，请点击这里的查看我是如何完成这个案例研究的。
案例研究 2:了解搜索功能
链接到案例 。
这个案例更侧重于产品分析。在这里，您需要深入研究数据，确定用户体验是好是坏。这个案例的有趣之处在于，由你来决定什么是“好”和“坏”以及如何评估用户体验。
案例研究 3:验证 A/B 测试结果
链接到案例 。
最实际的数据科学应用之一是执行 A/B 测试。在本案例研究中，您将深入研究 A/B 测试的结果，其中对照组和治疗组之间存在 50%的差异。在这种情况下，您的任务是在彻底分析后验证或否定结果。
2.熊猫练习题
当我第一次开始开发机器学习模型时，我发现我缺乏熊猫技能是我所能做的一个很大的限制。不幸的是，互联网上没有多少资源可以让你练习熊猫技能，不像 Python 和 SQL…
然而，几周前，我偶然发现了这个资源——这是一个专门为熊猫准备的练习题资源库。通过完成这些练习题，您将知道如何:
- 过滤和排序您的数据
- 分组和聚合数据
- 使用。apply()操作数据
- 合并数据集
- 还有更多。
如果你能完成这些练习题，你应该可以自信地说，你知道如何使用熊猫进行数据科学项目。这也将对你下一节有很大的帮助。
3.机器学习建模
获得数据科学经验的最佳方式之一是创建自己的机器学习模型。这意味着找到一个公共数据集，定义一个问题，用机器学习解决问题。
Kaggle 是世界上最大的数据科学社区之一，有数百个数据集可供选择。以下是一些你可以用来开始的想法。
预测葡萄酒质量
数据集此处 。
特里·维利迪斯在 Unsplash 上拍摄的照片
该数据集包含各种葡萄酒、其成分和葡萄酒质量的数据。这可能是一个回归或分类问题，取决于你如何设计它。看看你能否预测给定 11 个输入(固定酸度、挥发性酸度、柠檬酸、残糖、氯化物、游离二氧化硫、总二氧化硫、密度、pH、硫酸盐和酒精)的红酒质量。
如果你想要一些为这个数据集创建机器学习模型的指导，请查看我的方法 这里 。
二手车价格评估员
数据集 此处 。
Craigslist 是世界上最大的二手车销售网站。这个数据集由 Craigslist 搜集的数据组成，每隔几个月更新一次。使用这个数据集，看看是否可以创建一个数据集来预测一个汽车列表是过高还是过低。
感谢阅读！
我希望这些资源和想法对您的数据科学之旅有所帮助。😃
特伦斯·申
如果你喜欢这样，你应该每周查看一下 我的免费数据科学资源 有新素材！
创始人ShinTwin|我们连线上LinkedIn|项目组合这里是。****
第一份工作前获得 SQL 实战经验的 3 种方法
如何在实际项目中发展您的 SQL 技能
由 fullvector 创建的技术向量—www.freepik.com
介绍
“如果我没有任何 SQL 经验，如何获得数据分析师/数据科学工作？”
当我开始我的数据科学之旅时，我注意到能够获得实际的 SQL 经验是多么重要，如果你仍在努力获得第一份工作，或者如果你正在进行重大的职业转换，这可能会非常困难。
本文旨在解决这一问题。
下面是三种获得真实 SQL 体验的有效方法。您不仅可以解决实际问题，还可以在 GitHub 上展示这些问题，并将其添加到简历的项目部分！
本文将重点讨论三种类型的问题:
- 从原始数据创建数据管道
- SQL 编码(面试)问题
- SQL 案例研究
1.从原始数据创建数据管道
询问任何数据科学家、数据分析师或数据工程师，他们都会告诉你将原始数据转化为干净、可用和可靠的数据是多么重要。创建可靠的数据管道的能力将使你在数据职业生涯中走得更远，所以为什么不现在就开始呢？
作者创建的图像
如果你不确定我的意思，看看上面的图片。在许多情况下，您将直接从其来源获得原始数据，并负责将其转换为与您的同事和利益相关者相关的表格。
下面是几个例子，如果你想出点子需要帮助，你可以自己尝试一下。这些例子使用来自 Kaggle 的数据集，所以我将创建一个新的笔记本，并使用 SQLite 直接在其中编写查询。
案例 1:苹果公司的乔布斯
假设这个数据集在这里是一个存储苹果所有工作列表的活动表，但是你的经理只需要一个显示所有提到的不同技能的表，以及每个提到的技能按州细分的计数。
看看是否可以使用 SQL 操作数据来创建所需的表。
案例 2: Kickstarter 项目
这个数据集在这里包含了许多 Kickstarter 项目及其细节。
看看您是否可以使用 SQL 操作该表，以便显示每个类别的项目数量、每个类别的平均目标金额、每个类别的平均承诺金额、每个类别达到目标的项目百分比，以及每个类别从启动到截止日期的平均时间。
2.SQL 编码问题
Leetcode 和 Hackerrank 是很棒的资源，它们帮助我学会了我从来不认为可能的技能和技巧。这是我在找工作时充分利用的东西，也是我会经常回去查阅的资源。
这类网站最大的好处是它们通常有推荐的解决方案和讨论板，所以你可以了解更有效的解决方案和技术。
不确定从哪里开始？以下是一些你可以尝试的好问题:
3.SQL 案例研究
作为数据分析师/数据科学家，案例研究是模拟现实生活问题的最佳方式。Mode 提供了三个模拟真实业务问题的实用 SQL 案例研究，以及一个在线 SQL 编辑器，您可以在其中编写和运行查询。Mode 提供了 3 个案例研究，我将在下面介绍:
要打开 Mode 的 SQL 编辑器，请转到 此链接 并点击显示“打开另一个模式窗口”的超链接。
案例研究 1:调查用户参与度的下降
链接到案例 。
本案例的目的是确定 Yammer 项目用户参与度下降的原因。在深入研究这些数据之前，您应该先阅读一下 Yammer 的概述这里的。您应该使用 4 张表。
到案例的链接将为您提供关于问题、数据和应该回答的问题的更多细节。
如果您需要指导，请点击此处查看我是如何完成这个案例研究的。
案例研究 2:了解搜索功能
链接到案例 。
这个案例更侧重于产品分析。在这里，您需要深入研究数据，确定用户体验是好是坏。这个案例的有趣之处在于，由你来决定什么是“好”和“坏”以及如何评估用户体验。
案例研究 3:验证 A/B 测试结果
链接到 。
最实际的数据科学应用之一是执行 A/B 测试。在本案例研究中，您将深入研究 A/B 测试的结果，其中对照组和治疗组之间存在 50%的差异。在这种情况下，您的任务是在彻底分析后验证或否定结果。
感谢阅读！
我相信完成这些项目会给你知识和信心，让你在实践中获得成功。一如既往，我祝你在努力中好运！😃
不确定接下来要读什么？我为你挑选了另一篇文章:
学习聪明，不努力。
towardsdatascience.com](/ten-sql-concepts-you-should-know-for-data-science-interviews-7acf3e428185)
特伦斯·申
- 如果你喜欢这个， 在 Medium 上关注我 了解更多
- 关注我关于Kaggle了解更多内容！
- 我们连线上LinkedIn
- 有兴趣合作吗？查看我的 [网站](http://Want to collaborate?) 。
- 查看 我的免费数据科学资源 每周都有新素材！
在 Python 中处理参数的 3 种方法
直奔主题的指南
照片由 Maja Petric 在 Unsplash 上拍摄
#1 系统模块
Python 中的sys模块具有argv功能。当通过终端触发执行时，该功能返回提供给main.py的所有命令行参数的列表。除了其他参数，返回列表中的第一个元素是main.py的路径。
考虑下面这个main.py的例子
import syslist_of_arguments = sys.argvprint(list_of_args[0])
print(list_of_args[1])
print(list_of_args[2])
print(list_of_args[3])
触发main.py为:
python main.py first_arg "[second_arg]" "{\"arg\": 3}"
会返回:
test.py
first_arg
[second_arg]
{"arg": 3}
#2 带有一个大参数的 sys 模块
这是为 Python 代码提供参数的一种简单而强大的方法。您提供了一个单一的“大”参数，而不是提供许多按空格分开的参数。这个大参数是一个字符串字典，其中 dict-keys 表示参数名，dict-values 表示它们对应的值。
因为这个字典参数在 Python 中被表示为一个字符串，所以您应该将其转换为字典。这可以通过使用ast.literal_eval或json.loads功能来完成。需要相应地导入ast或json模块。
考虑下面这个main.py的例子:
import sys
import ast
raw_arguments = sys.argv[1]
print(raw_arguments)
arguments = ast.literal_eval(raw_arguments)
print(arguments['name']) # John
print(arguments['surname']) # Doe
print(arguments['age']) # 22
触发main.py为:
python main.py "{\"name\": \"John\", \"surname\": \"Doe\", \"age\": 22}"
会返回:
{"name": "John", "surname": "Doe", "age": 22}
John
Doe
22
# 3 arg parse 模块
如果您想为您的应用程序提供一个合适的命令行界面，那么argparse就是您需要的模块。这是一个完整的模块，它提供了开箱即用的参数解析、帮助消息以及在参数被误用时自动抛出错误。这个模块预装在 Python 中。
为了充分利用 **argparse 提供的功能，**需要一些时间来掌握。作为开始，考虑以下main.py的例子:
import argparse
parser = argparse.ArgumentParser(description='Personal information')parser.add_argument('--name', dest='name', type=str, help='Name of the candidate')parser.add_argument('--surname', dest='surname', type=str, help='Surname of the candidate')parser.add_argument('--age', dest='age', type=int, help='Age of the candidate')
args = parser.parse_args()print(args.name)
print(args.surname)
print(args.age)
在初始化一个ArgumentParses的对象后，我们使用add_argument函数添加所有期望的参数。该函数接收多个参数，其中包括参数名称(例如--name)目标变量、预期数据类型、、要显示的帮助消息等。
触发main.py为:
python main.py --name John --surname Doe --age 22
会回来
John
Doe
22
要找到关于这个模块的更多信息，请看一下 argparse 文档。
结论
很多时候，您需要向 Python 脚本传递参数。Python 通过sys模块提供对这些参数的访问。您可以直接访问argv功能并处理您自己的参数解析，或者您可以使用其他模块作为argparse来为您完成这项工作。
在我的日常编码生活中，我使用小脚本中的 sys 和arg parse 时，我是它们的唯一用户/维护者。
编码快乐！
面向数据工程师的综合词汇表
towardsdatascience.com](/150-concepts-heard-in-data-engineering-a2e3a99212ed) [## 如何用 Python 生成 MS Word 表格
30 秒内自动生成报告
towardsdatascience.com](/how-to-generate-ms-word-tables-with-python-6ca584df350e) [## 新手通常误用 Python 的 5 种场景
更好地利用 Python
towardsdatascience.com](/5-scenarios-where-beginners-usually-misuse-python-98bac34e6978)
作为数据科学家赚取额外收入的 3 种方法
建立收入来源来补充或取代你朝九晚五的工作。
毫无疑问，数据科学是一个利润丰厚的职业。来自 Glassdoor 的最新报告称，美国数据科学家——所有行业、所有公司类型，与工作经验无关——的平均年薪为 11.33 万美元。相比之下，2020 年第一季度美国的薪酬中值为4.97 万美元。
这只是美国的情况，实际数字因国家而异，但让我们假设比率大致相同——平均而言，数据科学家的平均收入大约是世界任何地方普通居民的两倍。
但是，做同样的工作，怎么可能从 11.3 万美元涨到 20 万美元呢？
这就是副业收入的威力发挥的地方。作为一名数据科学家，你有潜力赚很多钱。
原因有很多。让我们通过谷歌趋势来探索数据科学和机器学习的趋势:
蓝色:数据科学；红色:机器学习
这是 5 年的数据，这两个术语之间似乎有很强的关系(如预期的那样)。此外，我们可以清楚地看到趋势是积极的。我怀疑我们可以期待任何时间很快会有任何剧烈的变化。
另一个显而易见的原因是你技能的价值。我在各种脸书小组中看到许多初学者问一些任何有 6 个月经验的人都能毫不费力回答的问题。向完全的初学者教授基础知识可能是一个可行的方法，但稍后会有更多的介绍。
在今天的文章中，我将与你分享我每天使用的赚取额外收入的三大方法。这三个因素使我在不到一年的时间里收入增加了 2.5 倍。大部分额外收入来自第一条建议，所以让我们直接跳到它。
#1:写博客
拥有一个博客会影响你职业生活的方方面面。我将整篇文章都献给了这个主题，所以可以随意阅读:
提示:这也适用于其他职业
towardsdatascience.com](/how-having-a-blog-can-advance-your-career-as-a-data-scientist-245270cc281e)
概括一下，以下是写博客的最大好处:
- 你可以更深入地学习事物
- 出色的声誉建立者——带来更多的工作机会
- 惊人的收入潜力
我建议你通读这篇文章以获得深入的解释，因为它只有 5 分钟的阅读时间。撰写数据科学文章或任何技术主题的文章需要首先对主题有很好的理解。成为一个成功的博客需要你用最简单的词语解释复杂的话题，这将进一步帮助你理解。
我知道你现在的想法——在我开始写作之前，我需要多年的经验——这与事实相去甚远。事实是，你只需要比你的目标读者领先一步。就是这样。我来详细说明一下。
假设你想写关于的主成分分析。要做到这一点，你需要对主题有一个像样的理解，你的目标读者要么是对 PCA 一无所知的人，要么是理解得不够好的人。因此，你只比你的读者领先一步，因为你对 PCA 的了解足以解释它。
另外，写一篇教育性的文章首先是学习某个主题的一个很大的动力。放轻松，不要想太多。没有人会因为你犯了一些错误而怨恨你，即使有人怨恨，那也是他们的问题。
即使你做的每件事都是对的，仍然有很大的可能会有没事可做的人来纠正你的语法，所以要学会忽略它。
#2:教育视频
我发现教育视频是补充你博客的好方法。以文本和视频的形式报道相同的主题会让你的内容更加清晰可见。
不是每个人都想通读一篇难懂的科技文章。此外，有些主题过于直观，无法用文本进行深入解释。我一直记得来自 3Blue1Brown 的线性代数视频。
*你能想象从课本上学习线性代数这样复杂的题目吗？*这很可能是你最初学习的方式，但你的理解有多好呢？
我敢打赌，你已经记住了如何为了考试而计算东西，但完全错过了事物在视觉层面上如何工作的更大图景。这没什么丢人的，因为我们都经历过。我再说一遍，有些事情通过视频可以更好地解释。
好吧，那么你有哪些制作数据科学视频的选择？
嗯，第一个也是最明显的一个是 YouTube 。只要不违反他们的内容政策，你基本上可以上传任何东西，但新手很难赚钱。我来解释一下原因。
要想在 YouTube 上赚钱，你需要至少 1000 名订户，并且在去年至少有 4000 小时的公众观看时间。对于初学者来说，这不是一件容易的事情。我的频道还没有上线，但我希望它会很快上线。你需要投入大量的时间才能看到结果，一般来说，制作视频比你想象的要花更多的时间。
我知道在制作了我的第一个视频后，我感到很累，尽管我已经准备好了代码。
但是我的母语不是英语
我也不是，而且我对说英语给世界听的想法不是最舒服的。谷歌一下斯拉夫口音——你马上就会明白为什么。您可以:
- 不管怎样，忍着点去做吧
- 使用文本到语音转换软件
后一种选择让我受益匪浅，因为随着时间的推移，这些工具变得越来越好。 IBM 的 Watson TTS 是一个廉价入门的好方法。
如果你觉得 YouTube 太饱和了，还有其他平台可以考虑。我想到的一个是 Udemy ，但是我对它们没有任何经验，所以我会把它留给你去研究。
#3:联盟营销
时不时地，你会读一本很棒的书或看一堂很棒的课程。如果你认为这是他们可以从中受益的东西，没有理由不与你的观众分享。
你可以用两种方式推荐这本书或一门课程:
- 通过正常的链接
- 通过附属链接
唯一的区别是联盟链接会为你的每次购买/订阅赚取一些钱，而正常的不会。如果有人决定购买一本书或一门课程，链接的类型对他们来说并不重要。此外，如果他们喜欢你的内容，他们很有可能会支持你。
我最近的一篇文章是这种想法的一个很好的例子:
了解数据科学最重要的支柱
towardsdatascience.com](/the-single-best-introductory-statistics-book-for-data-science-a2601ea7c0be)
所以，简单地说，我读了一本很棒的书。我 100%确定至少我的观众中有人能从中受益，所以我写了一篇简短的评论并放了一个联盟链接。这是双赢的局面。
然而，你应该小心联盟营销。我永远不会推荐我没有亲自读过或看过，也不是 100%满意的东西。这是联盟营销的一大禁忌，因为当你不知道自己在说什么时，读者很容易感觉到。
那么，从哪里开始呢？
亚马逊有一个惊人的联盟计划，我用它来推荐高质量的书籍。
Udemy 有一个很棒的程序，我用它来推荐在线课程。
在你走之前
作为一名数据科学家，你有很大的收入潜力，这不应该仅限于你工作的公司愿意付给你多少钱。随着时间的推移，你的收入会翻倍——这是有保证的。这取决于你努力工作，直到它发生，但它将不可避免地发生。
然后你可以自由选择是否朝九晚五真的值得，因为你的大部分额外收入将是被动的，这意味着你不需要真的为之工作。
只要投入时间并相信这个过程。你会成功的。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
思考贝叶斯法则的三种方式
对“引擎盖下”真正发生的事情发展直觉
贝叶斯法则是数据科学的核心。它也是所有科学的基础和批判性思维的关键工具。不幸的是，它经常被教成只是一个要记忆的公式，花在真正探究正在发生的事情上的时间太少。当第一次有人教我这个的时候，我真的很难接受，这是我希望当时有人告诉我的。
预赛
贝叶斯法则相对简单:
英语中，**“给定 B 的条件概率等于给定 A 的 B 的条件概率乘以 A 的概率再除以 B 的概率”**如果这看起来很拗口，不用担心；视觉上会更有感觉。
证明也很简单:
根据定义， P(X|Y) = P(X ⋂ Y) / P(Y) ，所以 P(X ⋂ Y) = P(X|Y) P(Y)。
p(a⋂b)= p(b⋂a)
p(a | b)p(b)= p(b | a)p(a)
p(a | b)= p(b | a)p(a)/p(b)
到目前为止，这只是一个有证明的公式，一些需要记忆和应用的东西。幸运的是，有一些思考方式让它感觉更自然，并提供一些关于真实发生的事情的见解。
1.重新构建宇宙
第一种是可视化方法，将公式的右侧分解为 3 个步骤，每个步骤都有清晰的图形解释。把宇宙想象成一个实验所有可能结果的集合。例如，掷骰子的宇宙 U 是{1，2，3，4，5，6}。但是如果我告诉你我掷出了一个偶数，而你不知道是哪一个，那就把 U 缩小到{2，4，6}。我们在这里做同样的事情，但是用图形来说明。
首先，我们的基本设置:
我们有两个事件，A 和 B，它们有时会一起发生:A ∩ B .我们的宇宙 U 是一切可能发生的事情，面积代表概率。因为它是我们现在所有其他事情的参考框架，我们用蓝色突出显示它。
第一步:P(B|A)
这是我们的起点——一个条件概率，但不是我们真正想要的。在某种意义上，这给了我们一个新的、更小的宇宙:A(用蓝色突出显示)。我们感兴趣的事件是灰色区域 a⋂b。area(a⋂b)/area(a)回答问题，“如果我们已经知道 a 已经发生了，b 的可能性有多大？”
第二步:p(b | a)****p(a)=p(a⋂b)
这是我们将画面拉回到原始宇宙的方式。感兴趣的事件 A ⋂ B 保持不变，但是宇宙(我们概率分数的分母，如果你愿意的话)变大了。
第三步:****P(B | A)****P(A)/P(B)= P(A | B)
最后，我们通过除以 P(B)把宇宙缩小到 B。感兴趣的事件仍然没有改变。现在我们有了 P(A|B)，我们感兴趣的贝叶斯法则的左边。
对于以视觉为导向的学习者(大多数人)，这是一种令人满意且直观的思考概率的方式。只要你能描绘出“框架”移动来收缩或拉伸我们的宇宙，你就能描绘出贝叶斯法则到底发生了什么，希望这能帮助你理解为什么它总是正确的。它甚至可以帮助你记住公式。
2.更新我们的先验 P(A):
这是真正的统计学家谈论贝叶斯法则时最常用的词汇。“贝叶斯更新”是每个科学分支中的一个重要概念。它的基本主旨是，虽然我们最终想知道 P(A|B ),但我们从我们的先验概率 P(A ),即 A 的无条件概率开始。在此基础上，我们使用 P(B|A)和 P(B)将 P(A)调整到它应该在的位置——这是我们在考虑所有相关信息后现在知道的。
我喜欢把 P(B|A)/P(B)想象成一个比例因子，我们用它来更新 P(A)。本质上，我们用 P(B|A)/P(B)来加权 P(A ),以确定我们应该根据新信息改变我们的先验多少。
我们可以认为我们的比例因子是“A 产生 B 的可能性有多大”。如果 A 和 B 是独立的，这将是 1。如果不相交，则为 0。如果是同一事件，则为 1/ P(B) =1/ P(A) 。如果 A 的发生使 B 发生的概率增加了λ倍，那么给定 B 的条件概率应该比 P(A)大λ倍。
如果你仍然不知道为什么这是真的，就用等式
P(A | B)/P(A)=P(B | A)/**P(B)把它想成: “多了多少可能性 B 使得A“=”多了多少可能性A 右边是我们的比例因子，而左边包含我们的起点和终点。
万一你不明白为什么必须是真的，A 增加 B 的概率正好等于 B 增加 A 的概率，看看下面明显是真的等式，尤其是第二个。(提示:取消什么？每个分数代表哪个概率？分数的每个乘积代表什么？)这是很好的锻炼。如果你愿意，让 Area(U)=1。
贝叶斯法则的高明之处在于，它将我们在日常生活中如何做决定的关键观点形式化了。我们从关于现实的基线信息开始，通常是假设。每一点点新信息都会导致我们更新我们的信念，当然，除非它完美地证实了我们的信念(不幸的是，我们经常发现新信息比我们应该的更加确定——工作中的确认偏差)。或者至少新的证据应该促使我们更新信念，因为这是理性的一个重要组成部分。
如果我们已经很自然地做到了这一点，为什么我们还需要贝叶斯法则？好问题。问题是，在一些情况下，包括一些非常高风险和重要的情况，我们的猴脑直觉会崩溃，将这种信念更新的过程形式化可以帮助我们避免错误。我们稍后将考虑一个这样的例子。
3.调整“其他”条件概率 P(B|A)
如果已知给定 A 的 B 的条件概率，但想得到另一个条件概率 P(A|B)，我们只需要知道两个事件的无条件概率。从一个条件概率到另一个条件概率，我们需要做的就是乘以无条件概率的比率。以这种方式陈述，这种关系可能看起来令人惊讶或随机，但形象地思考它可以帮助你明白为什么它一定是真的。
事实上，这可能看起来只是视觉解释的一种不太有用的重述，但事实证明，作为一名数据科学家，这是一种特别好的思考方式。这是因为它允许我们从回忆到精确，反之亦然。一旦我们看到了一个例子，我们将详细讨论这个问题，这样会更有意义。
需要注意的是，这些都是思考贝叶斯法则的等价方式。你不需要在脑子里把它们都变戏法。如果有一个真的合你意，那就用那个。我发现通常在不同的情况下，一个比另一个更有意义。
经典贝叶斯例子
让我们来看看这三种解释中的每一种在现实世界中的应用。考虑以下场景:
- 有一种罕见的疾病困扰着 0.01%的人口
- 有一种检测这种疾病的方法可以检测出 98%的病例
- 只有 1%的人检测出该疾病呈阳性
(注:具体数字没太大关系。我们可以选择不同的数字。一个有趣的练习是一次改变一个数字，看看每次改变对结果有什么影响。)
为了简单起见，我们可以重命名我们的事件，并确定哪个概率在公式中的位置:
- A = {你有这种病}
- ā= {你没有病}
- B = {你测试呈阳性}
- b̅= {你测试阴性}
- P(A) = 0.0001
- p(ā)= 0.9999
- P(B) = 0.01
- P(B̅) = 0.99
- P(B|A) = 0.98
- P(A|B) =？
注意，这里我们没有明确给出 P(A ⋂ B) 。不过，这是隐含的，如果必要的话，计算起来并不困难。
现在，我们准备将这三种解释应用到我们的数字中。
解释#1(视觉)
由于患有这种疾病的人群非常少，我们只能放大到我们宇宙的一个小角落。这不是完全按比例绘制的，但对我们的目的来说已经足够接近了。
第一步:P(B | A) 从我们知道的条件概率开始:如果你确实患有疾病，正确诊断的概率。
第二步:P(B | A) P(A) = P(A ⋂ B) 乘以 P(A)得到交集的概率。我们也可以认为这是对条件概率的“去条件化”。
**第三步:P(B | A)P(A)****/**P(B)= P(A | B) 现在我们再放大，但是到一个不同的宇宙(B)，给我们真正关心的条件概率。
这个故事的寓意是什么？测试非常罕见的疾病是非常困难的。这并不是说考试本身很糟糕；只是当这么少的人患有这种疾病时，不可能有很多假阳性，而不会使测试对那些测试阳性的人非常不可靠。这是医生使用多种测试的一个原因，像这种假设的测试被用来筛选谁应该接受进一步的(通常更昂贵的)测试。毕竟，它的召回率真的相当高——在患有疾病的人中，它检测到了绝大多数人(代价是警告了更多健康的人→低精度)。
解释#2(更新信念)
在这个框架下，你去看医生，假设你得这种病的概率是 0.01%，或者 0.0001。然后，你将利用测试结果来更新你对自己是否患有这种疾病的信念。
结果是，你的测试呈阳性。所以你需要用
P(B|A) / P(B) = 0.98/0.01 = 98 来衡量你的信念。这听起来很多——你有 98 倍以上的把握确定自己患有这种疾病。这里的好消息当然是你更新后的概率 P(A|B) = 98 P(A) = 98 0.0001 = 0.0098，即 0.98%。换句话说，你仍然有不到 1%的机会真正患上这种疾病。
在这个上下文中，比例因子到底是什么意思？它本质上告诉我们，相对于在人群中随机选择的任何人[=P(B)]，当你患有疾病时，你得到阳性的可能性有多大。这个比例很大的事实告诉我们，我们应该通过增加我们对自己患有疾病的相信程度来相应地更新。在这种情况下，如果我们患有这种疾病，我们检测阳性的可能性是 98 倍，所以我们采用 0.01%的事前比率，并将其放大 98 倍。换句话说，1/10，000 的人患有这种疾病，但 1/10，000 的测试阳性者中有 98 人确实患有这种疾病，所以阳性诊断会让你相应地更新你的信念。
练习:为了看到这个测试的好处，考虑一下如果测试结果是阴性的话，比例因子会是多少。
解释#3(回忆的精确性)
在这种解释中，你从“其他”条件概率开始，用无条件概率的比率来衡量它，以获得我们对你患有该疾病的最终相信程度。
“如果我真的患有这种疾病，我检测呈阳性的概率有多大？”这个问题我们已经有了答案如果你已经检测为阳性，现在你想从那里得到你患这种疾病的概率。就像在第二个范例中一样，我们对它进行缩放，以获得我们最终的信任度。
在这种方法中，比例因子为 P(A) / P(B) = 0.0001/0.01 = 0.01。
所以 P(A | B)= 0.01 P(B | A)= 0.01 0.98 = 0.0098。
当然，我们得到了与上面相同的答案，但有趣的部分是我们如何到达那里的不同。
有趣的是，我们可以从精确度和召回率的角度来看这个问题。高精度意味着很少的假阳性，高召回意味着很少的假阴性。我们知道，测试中的高召回率(99%)意味着更高的精确度，保持所有其他因素不变(因为两个公式的 TP 都在增加)。但是我们需要把其他因素考虑进去，才能知道高召回率是否真的转化为高精确度，在这种情况下，它不是。
这是为什么呢？我们的比例因子 P(A)/P(B)告诉我们，对于我们人口中随机选择的个体，实际患有该疾病的概率远低于检测为阳性的概率。事实上，它告诉我们，你测试呈阳性的可能性是你患病的 100 倍。因此，尽管绝大多数患病者都能被准确检测出来，但他们仍将是所有检测呈阳性者中的少数。
换句话说，我们的比例因子将假阴性的数量与假阳性的数量进行比较。这并不完全是它们的比率，而是每一个与真阳性数量相加的比率。
简而言之:从回忆开始，然后通过“与得到阳性诊断相比，患这种疾病的可能性有多大”来衡量，以获得精确度。在下一节，也是最后一节，我们将详细介绍这一点。
额外收获:根据精确度和召回率重新陈述贝叶斯法则
作为一个临时演员，让我们深入研究这个问题，并展示贝叶斯法则与精确度和召回率之间的关系。
设置:
- TP，TN，FP，FN 是真/假阳性/阴性
- A = TP + FN(所有实际患病的人)
- B = TP + FP(所有疾病检测呈阳性的人)
- A ⋂ B = TP
- P(A ⋂ B) = TP / (TP + TN + FP + FN)
- P(A) = (TP + FN) / (TP + TN + FP + FN)
- P(B) = (TP + FP) / (TP + TN + FP + FN)
- prec = TP/(TP+FP)= p(a⋂b)/p(b)= p(a | b)
- rec = TP/(TP+fn)= p(a⋂b)/p(a)= p(b | a)
派生:
- P(A|B) = P(B|A) P(A) / P(B)
- Prec = Rec P(A) / P(B)
- prec = Rec((TP+FN)/(TP+TN+FP+FN))/((TP+FP)/(TP+TN+FP+FN))
- Prec = Rec (TP + FN) / (TP + FP)
当我们这样陈述时，它似乎是微不足道的。“精确就是回忆，只不过你取消了让它回忆起来的那部分，加上了让它精确的那部分。”我们可以更进一步
- Prec = Rec Prec / Rec
这是显而易见的，一点帮助都没有。不过，这种方法的真正价值在于，我们现在有办法将两个不同的概念联系在一起，这两个概念有时被视为完全不同，但实际上密切相关。
使用 SAS-SQL 转变您的 SAS 数据工作流的 3 种方式
用 SAS？利用 SQL 来简化您的工作。
照片由 Roma Ryabchenko 在 Unsplash 上拍摄
- 介绍
- 在 SAS 中使用 SQL 的好处
- 示例数据集
- 示例 1:连接数据集
- 示例#2:向新列添加值
- 示例#3:选择列中的唯一值
- 结论
1。简介
作为一个必须在新的工作场所快速掌握 SAS 的人，我很高兴看到我可以使用我现有的 SQL 知识来补充我公司主要使用 SAS 的分析团队。一般来说，我发现在 MySQL 和 PostgreSQL 等其他 SQL 平台上可以做的大多数事情都是适用的，尽管语法可能会有所不同。
在对我们现有的 SAS 代码进行了一些故障排除之后，我能够向我的同事展示 SQL 可以改进我们工作流的一些方便的方法。下面我用三个例子来演示其中的一些方法。
2。在 SAS 中使用 SQL 的一些好处
- 可读性 — SQL 可读性强，学习直观。
- SQL 可以一步完成操作、汇总、排序等多种功能。
- 如果您已经了解 SQL，并且是 SAS 新手，您可以立即开始为您的团队做出贡献。
- 结合 SQL 和 SAS 数据步骤可以简化工作流程。
- SQL 是大多数数据库使用的 ANSI 标准语言。
3。我们的示例数据集
我们在示例中使用的两个表来自 Beth Morrison 创建的巴塔哥尼亚服装数据集。注意，对于这些例子，我使用的是 SAS Studio ，尽管同样的语法也可以用在其他 SAS 平台上，比如 SAS Viya 或 SAS Enterprise。
“服装 _ 类别”表。图片作者。
“服装 _ 列表”表。图片由作者提供。
4。示例 1:连接数据集
假设您想找出“服装列表”表中哪些服装适合陆地或水域。在这种情况下，您需要使用公共列“item_category”将“clothing_category”表连接到“clothing_list”表。
SAS: 在 SAS 中将表连接或合并在一起的等效操作可能是一个多步骤的过程。请在此参考 SAS 文档。
SQL: 用 SQL-SAS 连接表很简单，可以节省时间。注意，SQL-SAS 中的“JOIN”和“LEFT JOIN”是相同的。
PROC SQL;
SELECT *
FROM clothing_category
JOIN clothing_list
ON
clothing_category.item_category = clothing_list.item_category;
QUIT;
上述连接产生的输出表。现在，您可以看到“服装列表”表中的“物品类别”与“服装类别”表中的“土地”或“水”值相匹配。图片由作者提供。
5。示例 2:向新列添加值
假设您希望根据另一列的值为新列赋值。这里，我们将添加一个列，该列的值将指定“clothing_list”中的每件商品的价格是低于 100 美元还是高于 100 美元。
SAS: 在 SAS 中，您可以运行一个数据步骤，使用 LENGTH 函数创建一个新列“price_category”，然后使用“IF-THEN-ELSE”语句为该列中的行赋值。
DATA work.output_table;
SET work.clothing_list;
LENGTH price_category $50.;
IF item_price < 100 THEN price_category = 'Less than $100';
ELSE IF item_price > 100 THEN price_category = 'More than $100';
ELSE price_category = 'Not available';
RUN;
SQL: 您可以在 SQL-SAS 中使用 CASE WHEN 语句，而不是使用带有多个 IF 语句的 SAS 来运行数据步骤。这也为您提供了在单步中进行聚合(分组依据)、排序(排序依据)等操作的灵活性。
PROC SQL;
SELECT item_category, item_name, item_price,
(CASE
WHEN item_price < 100 THEN 'Less than $100'
WHEN item_price > 100 THEN 'More than $100'
ELSE 'Not available'
END) AS price_category
FROM work.clothing_list
;
QUIT;
运行上述任一代码块都将输出下表:
请注意“价格类别”列。图片由作者提供。
6。示例#3:选择列中的唯一值
假设您想在一个列中查找唯一值，例如商店中服装的唯一商品价格的数量。这就是 SAS-SQL 中的 SELECT DISTINCT 大放异彩的地方。
SAS: 在 SAS 中，您可以使用 PROC SORT 找到唯一值:
PROC SORT DATA = work.clothing_list
OUT = work.unique_values
(KEEP = item_price)
DUPOUT = work.duplicate_table
(KEEP = item_price)
NODUPKEY
;
BY item_price; /*this is the column of interest*/
RUN;
在这种情况下，SAS 的优点在于,“DUPOUT”选项除了输出包含唯一商品价格列表的“work.unique_values”表之外，还输出“work.duplicate_table”表中额外重复值的表。您还可以选择输出整个匹配行。
“NODUPKEY”告诉 SAS 只保留输出表中 BY 语句中列出的列的每个唯一值的第一个匹配项。
工作中的重复项目价格。重复 _ 表格。图片作者。
作品中独特的物品价格。唯一值表。这里可以看到“75”和 429”也在这个表中。图片由作者提供。
SQL: 在 SQL 中，只需编写如下几行代码，就可以获得与上面的表相同的输出，其中包含唯一的值。注意:这不会输出带有额外重复行的表。
PROC SQL;
SELECT DISTINCT item_price
FROM clothing_list;
QUIT;
7。结论
我希望这能帮助您更多地了解在 SAS 中使用 SQL 的潜力！在实践中，我发现使用 SAS 数据步骤和 SQL 代码块最适合我的数据准备工作。
您如何在 SAS 中使用 SQL 来改进您的工作流程？想了解 SQL-SAS 如何节省您的时间并简化您的代码吗？请在下面的评论中告诉我！
—吉米
FAANG 科技巨头的 30 多个数据科学面试问题
来自脸书、亚马逊、苹果、网飞和谷歌的深度访谈问答
图片由皮克斯拜的 Gerd Altmann 提供
本文汇集了来自顶级科技巨头(也称为 FAANG 公司，如脸书、亚马逊、苹果、网飞、谷歌)的三十多个数据科学面试问题和答案。随意用这个来准备面试，看看哪里需要多学习，甚至你只是想看看顶级公司都问些什么！
脸谱网
问:你从 100 枚硬币中随机抽取一枚——1 枚不公平硬币(正面朝上)，99 枚公平硬币(正面朝下)，然后掷 10 次。如果结果是 10 头，硬币不公平的概率是多少？
这可以用贝叶斯定理来回答。贝叶斯定理的扩展方程如下:
假设选到不公平硬币的概率表示为 P(A)，连续翻转 10 个头像的概率表示为 P(B)。那么 P(B|A)等于 1，P(B∣ A)等于 0。⁵ ⁰，P( A)等于 0.99。
如果填入等式，那么 P(A|B) = 0.9118 或者 91.18%。
问:有一栋楼有 100 层。你有两个相同的鸡蛋。如何用 2 个鸡蛋找到门槛楼层，在这里鸡蛋肯定会从 N 层以上的任何一层破开，包括 N 层本身。
更具体地说，问题是在给定两个鸡蛋的情况下，寻找阈值下限的最优方法。
为了更好地理解这个问题，我们假设你只有一个鸡蛋。要找到门槛楼层，你可以简单地从第一层开始，放下鸡蛋，然后一层一层往上爬，直到鸡蛋裂开。
现在想象我们有无限的鸡蛋。寻找最低门槛的最佳方法是通过二分搜索法。首先，你会从 50 楼开始。如果鸡蛋裂开了，你就在 25 楼扔一个鸡蛋，如果鸡蛋没有裂开，你就在 75 楼扔一个鸡蛋，重复这个过程，直到你找到门槛楼层。
对于两个鸡蛋，寻找阈值下限的最佳方法是上述两种解决方案的混合…
例如，你可以每隔 5 层扔第一个鸡蛋，直到它破了，然后用第二个鸡蛋找出在 5 个增量之间的哪一层是门槛层。在最坏的情况下，这将需要 24 滴。
如果你每隔 10 层楼丢下第一个鸡蛋，直到它破掉，在最坏的情况下需要 19 次，这比每隔 5 层楼丢下第一个鸡蛋要好得多。但是如果你想做得更好呢？
这就是最大遗憾最小化这个概念发挥作用的地方。基本上，这意味着当你以给定的增量完成更多的下降(你跳过多少层)时，你希望每次都缓慢地减少增量，因为阈值楼层的可能楼层会更少。这意味着如果你的第一次下落是在 n 层，那么你的第二次下落应该是在 n + (n-1)层，假设它没有破裂。这可以写成下面的等式:
更进一步，这可以简化为:
求解 n，你得到大约 14。因此，你的策略将是从第 14 层开始，然后 14+13，然后 14+13+12，等等，直到它打破，然后使用第二个蛋一次一层地找到门槛层！
问:我们有两种在 Newsfeed 中投放广告的选择。方案一:每 25 个故事中，就有一个是 ad。方案二:每个故事都有 4%的几率成为广告。对于每个选项，100 个新闻故事中显示的广告的预期数量是多少？
两种选择的预期赔率都是 4/100。
对于选项 1，1/25 相当于 4/100。
对于选项 2，100 的 4%是 4/100。
如果我遗漏了什么，请随时告诉我，因为这个问题似乎太直截了当了！
问:只知道性别身高，你如何证明男性平均比女性高？
你可以用假设检验来证明男性平均比女性高。
零假设是男性和女性平均身高相同，而另一个假设是男性的平均身高高于女性的平均身高。
然后，您将收集男性和女性身高的随机样本，并使用 t 检验来确定您是否拒绝空值。
问:如果 iOS 上 70%的脸书用户使用 Instagram，但 Android 上只有 35%的脸书用户使用 Instagram，你会如何调查这种差异？
有许多可能的变量会导致这种差异，我将检查一下:
- iOS 和 Android 用户的人口统计数据可能会有很大差异。例如，根据 Hootsuite 的调查，43%的女性使用 Instagram，而男性只有 31%。如果 iOS 的女性用户比例明显高于 Android，那么这可以解释这种差异(或者至少是部分差异)。这也适用于年龄、种族、民族、地点等
- 行为因素也会对差异产生影响。如果 iOS 用户比 Android 用户更频繁地使用手机，他们更有可能沉迷于 Instagram 和其他应用程序，而不是那些在手机上花费时间少得多的人。
- 另一个需要考虑的因素是 Google Play 和 App Store 有什么不同。例如，如果 Android 用户有明显更多的应用程序(和社交媒体应用程序)可供选择，这可能会导致用户的更大稀释。
- 最后，与 iOS 用户相比，用户体验的任何差异都会阻止 Android 用户使用 Instagram。如果这款应用对安卓用户来说比 iOS 用户更容易出错，他们就不太可能在这款应用上活跃。
问:每个用户的点赞数和在一个平台上花费的时间在增加，但用户总数在减少。它的根本原因是什么？
一般来说，你会想从面试官那里获得更多的信息，但是让我们假设这是他/她唯一愿意提供的信息。
关注每个用户的点赞数，有两个原因可以解释为什么这个数字会上升。第一个原因是，随着时间的推移，用户的平均参与度普遍提高了——这是有道理的，因为随着使用该平台成为一种习惯性做法，久而久之的活跃用户更有可能成为忠实用户。每个用户点赞数会增加的另一个原因是分母，即用户总数，在减少。假设停止使用该平台的用户是不活跃的用户，也就是参与度和点赞数低于平均水平的用户，这将增加每个用户的平均点赞数。
上面的解释也适用于在平台上花费的时间。随着时间的推移，活跃用户变得越来越活跃，而很少使用的用户变得不活跃。总体而言，参与度的增加超过了参与度很低的用户。
更进一步说，有可能“参与度低的用户”是脸书能够检测到的机器人。但随着时间的推移，脸书已经能够开发出识别和删除机器人的算法。如果以前有大量的机器人，这可能是这种现象的根本原因。
问:脸书发现赞数每年增长 10%，为什么会这样？
给定年份的总赞数是用户总数和每个用户的平均赞数的函数(我称之为参与度)。
用户总数增加的一些潜在原因如下:由于国际扩张而获得的用户以及随着年龄增长而注册脸书的年轻群体。
参与度增加的一些潜在原因是用户对应用程序的使用增加，用户变得越来越忠诚，新的特性和功能以及用户体验的改善。
问:如果一个项目经理说他们想把新闻订阅的广告数量增加一倍，你如何判断这是不是一个好主意？
您可以通过将用户分成两组来执行 A/B 测试:一组是广告数量正常的对照组，一组是广告数量翻倍的测试组。然后，您将选择指标来定义什么是“好主意”。例如，我们可以说零假设是广告数量翻倍会减少花在脸书上的时间，另一个假设是广告数量翻倍不会对花在脸书上的时间有任何影响。但是，您可以选择不同的指标，如活跃用户数或流失率。然后，您将进行测试，并确定拒绝或不拒绝 null 的测试的统计显著性。
问:有一个游戏，给你两个公平的六面骰子，让你掷骰子。如果骰子上的数值之和等于 7，那么您将赢得 21 美元。但是，每次掷出两个骰子，你都必须支付 5 美元。你玩这个游戏吗？
掷出 7 的几率是 1/6。
这意味着期望支付 30 美元(5*6)赢得 21 美元。
取这两个数字，预期支付额为-$ 9(21–30)。
由于预期付款为负，你不会想要支付此游戏。
亚马孙
问:如果有 8 个重量相等的弹珠和 1 个稍重的弹珠(总共 9 个弹珠)，需要称重多少次才能确定哪个弹珠最重？
作者创建的图像
需要称重两次(见上文 A 和 B 部分):
- 你将九个弹珠分成三组，每组三个，称其中两组的重量。如果天平平衡(选择 1)，你知道重的弹球在第三组弹球中。否则，您将选择权重更大的组(选项 2)。
- 然后你将练习同样的步骤，但是你将有三组一个弹球，而不是三组三个。
问:凸与非凸代价函数的区别；当一个代价函数是非凸的时候意味着什么？
凸函数是指在图上任意两点之间画的一条线位于图上或图上。它有一个最小值。
非凸函数是在图上任意两点之间画的线可能与图上其他点相交的函数。它的特征是“波浪形”。
当成本函数是非凸的时，这意味着该函数有可能找到局部最小值而不是全局最小值，从优化的角度来看，这在机器学习模型中通常是不期望的。
问:什么是过度拟合？
过度拟合是一种错误，即模型“拟合”数据太好，导致模型具有高方差和低偏差。因此，过度拟合模型将会不准确地预测新的数据点，即使它对训练数据具有高的准确性。
问:改变基本会员费会对市场产生什么影响？
我对这个问题的答案没有 100%的把握，但我会尽力而为！
让我们举一个主要会员费上涨的例子——有两方参与，买方和卖方。
对于买家来说，提高会员费的影响最终取决于买家需求的价格弹性。如果价格弹性很高，那么给定的价格上涨将导致需求大幅下降，反之亦然。继续购买会员费的买家可能是亚马逊最忠诚和最活跃的客户——他们也可能更加重视 prime 产品。
卖家将受到打击，因为现在购买亚马逊一篮子产品的成本更高了。也就是说，一些产品将受到更严重的打击，而其他产品可能不会受到影响。亚马逊最忠实的顾客购买的高端产品可能不会受到太大影响，比如电子产品。
问:描述决策树、支持向量机和随机森林。谈论他们的优点和缺点。
决策树:一种树状模型，用于根据一个或多个条件对决策进行建模。
- 优点:易于实现，直观，处理缺失值
- 缺点:高方差，不准确
支持向量机(Support Vector Machines):一种分类技术，可以找到一个超平面或两类数据之间的边界，从而最大化两类数据之间的差距。有许多平面可以分隔这两个类别，但只有一个平面可以最大化类别之间的边距或距离。
- 优点:高维精确
- 缺点:容易过度拟合，不能直接提供概率估计
随机森林:一种基于决策树的集成学习技术。随机森林包括使用原始数据的自举数据集创建多个决策树，并在决策树的每一步随机选择一个变量子集。然后，该模型选择每个决策树的所有预测的模式。
- 优点:可以实现更高的准确性，处理缺失值，不需要特征缩放，可以确定特征重要性。
- 缺点:黑盒，计算量大
问:为什么降维很重要？
降维是减少数据集中要素数量的过程。这主要在您想要减少模型中的方差(过度拟合)的情况下很重要。
维基百科陈述了降维的四大优势(见此处):
- 它减少了所需的时间和存储空间
- 多重共线性的消除改善了机器学习模型参数的解释
- 当数据降低到非常低的维度时，如 2D 或 3D，就变得更容易可视化
- 它避免了维数灾难
问:商品在位置 A 的概率是 0.6，在位置 b 的概率是 0.8。在亚马逊网站上找到该商品的概率是多少？
我们需要对这个问题做一些假设才能回答。让我们假设在亚马逊上有两个可能的地方购买一件特定的商品，在位置 A 找到它的概率是 0.6，在位置 B 找到它的概率是 0.8。在亚马逊上找到该商品的概率可以这么解释:
我们可以把上面的话重新措辞为 P(A) = 0.6，P(B) = 0.8。此外，让我们假设这些是独立的事件，这意味着一个事件的概率不受另一个事件的影响。然后我们可以使用公式…
P(A 或 B) = P(A) + P(B) — P(A 和 B)
P(A 或 B) = 0.6 + 0.8 — (0.6*0.8)
P(A 或 B) = 0.92
问:什么是助推？
Boosting 是一种集成方法，通过减少模型的偏差和方差来改进模型，最终将弱学习者转换为强学习者。总体思路是训练一个弱学习器，通过对前一个学习器的学习，依次迭代改进模型。这里 可以了解更多 。
苹果
问:描述 L1 和 L2 正则化之间的区别，特别是关于它们对模型训练过程的影响的区别。
L1 和 L2 正则化都是用于减少训练数据过拟合的方法。最小二乘法使残差平方和最小，这可能导致低偏差但高方差。
L2 正则化，也称为岭回归，最小化残差平方和加上λ乘以斜率平方。这个附加项被称为岭回归损失。这增加了模型的偏差，使得对训练数据的拟合更差，但是也减少了方差。
如果您采用岭回归罚分并用斜率的绝对值替换它，那么您将得到套索回归或 L1 正则化。
L2 不太稳健，但有一个稳定的解决方案，而且总是一个解决方案。L1 更稳健，但是具有不稳定的解，并且可能具有多个解。
问:ACF 和 PACF 的含义是什么？
要了解 ACF 和 PACF，首先需要知道什么是自相关或序列相关。自相关着眼于给定时间序列与其自身滞后版本之间的相似程度。
因此，自相关函数(ACF) 是一种工具，用于发现数据中的模式，具体而言，是指由各种时间滞后分隔的点之间的相关性。例如，ACF(0)=1 意味着所有数据点都与自身完美相关，ACF(1)=0.9 意味着一个点与下一个点之间的相关性为 0.9。
PACF 是偏自相关函数的简称。引用 StackExchange 中的一段文字，“它可以被认为是由若干个周期 n 分隔的两个点之间的相关性，但中间相关性的影响已被消除。”比如说。如果 T1 与 T2 直接相关，而 T2 与 T3 直接相关，则似乎 T1 与 T3 相关。PACF 将消除与 T2 之间的关联。
这里很棒的解释了 ACF 和 PACF 这里 。
问:什么是偏差-方差权衡？
估计值的偏差是期望值和真实值之间的差值。具有高偏差的模型往往过于简单，导致拟合不足。方差表示模型对数据和噪声的敏感度。具有高方差的模型导致过度拟合。
因此，偏差-方差权衡是机器学习模型的一个属性，其中较低的方差导致较高的偏差，反之亦然。一般来说，可以找到两者的最佳平衡，使误差最小化。
作者创建的图像
问:XGBoost 如何处理偏差-方差权衡？
作者创建的图像
XGBoost 是一种利用梯度推进算法的集成机器学习算法。本质上，XGBoost 就像是类固醇上的装袋和助推技术。因此，可以说 XGBoost 处理偏差和方差的方式类似于任何 boosting 技术。Boosting 是一种集成元算法，通过对许多弱模型进行加权平均来减少偏差和方差。通过关注弱预测和迭代模型，误差(从而偏差)减少了。类似地，因为它对许多弱模型进行加权平均，所以最终的模型比每个弱模型本身具有更低的方差。
问:什么是随机森林？为什么朴素贝叶斯更好？
随机森林是一种建立在决策树基础上的集成学习技术。随机森林包括使用原始数据的自举数据集创建多个决策树，并在决策树的每一步随机选择一个变量子集。然后，该模型选择每个决策树的所有预测的模式。依靠“多数获胜”模型，它降低了单个树出错的风险。
作者创建的图像
例如，如果我们创建一个决策树，第三个，它会预测 0。但是如果我们依赖所有 4 个决策树的模式，预测值将是 1。这就是随机森林的力量。
随机森林提供了其他几个好处，包括强大的性能，可以模拟非线性边界，不需要交叉验证，并赋予功能重要性。
从过程和结果易于训练和理解的意义上来说，朴素贝叶斯更好。一个随机的森林看起来就像一个黑盒。因此，在实现和理解方面，朴素贝叶斯算法可能更好。但是，就性能而言，随机森林通常更强，因为它是一种集合技术。
网飞
问:为什么整流线性单位是一个很好的激活函数？
由作者创建
整流线性单元，也称为 ReLU 函数，已知是比 sigmoid 函数和 tanh 函数更好的激活函数，因为它执行梯度下降更快。请注意，在左侧的图像中，当 x(或 z)非常大时，斜率非常小，这会显著降低梯度下降的速度。然而，这不是 ReLU 函数的情况。
问:正规化有什么用？L1 正则化和 L2 正则化有什么区别？
L1 和 L2 正则化都是用于减少训练数据过拟合的方法。最小二乘法使残差平方和最小，这可能导致低偏差但高方差。
L1 vs L2 正规化
L2 正则化，也称为岭回归，最小化残差平方和加上λ乘以斜率平方。这个附加项被称为岭回归损失。这增加了模型的偏差，使得对训练数据的拟合更差，但是也减少了方差。
如果取岭回归罚分，用斜率的绝对值代替，那么就得到套索回归或 L1 正则化。
L2 不太稳健，但有一个稳定的解决方案，并且总是有一个解决方案。L1 更稳健，但是具有不稳定的解，并且可能具有多个解。
问:在线学习和批量学习有什么区别？
批量学习，也称为离线学习，就是你对一组组的模式进行学习。这是大多数人都熟悉的学习类型，在这种情况下，您可以获取一个数据集，然后一次性在整个数据集上构建一个模型。
另一方面，在线学习是一种一次吸收一个观察数据的方法。在线学习是数据高效的，因为数据一旦被消费就不再需要，这在技术上意味着你不必存储你的数据。
问:在查询数据集时，如何处理空值？还有其他方法吗？
有多种方法可以处理空值，包括:
- 您可以完全忽略空值行
- 您可以用集中趋势的度量值(平均值、中值、众数)替换空值，或者用新的类别替换空值(如“无”)
- 您可以根据其他变量预测空值。例如，如果某一行的 weight 值为空，但它的 height 值为空，则可以用该给定高度的平均重量替换该空值。
- 最后，如果您正在使用自动处理空值的机器学习模型，则可以保留空值。
问:如何防止模型的过度拟合和复杂性？
对于那些不知道的人来说，过度拟合是一种建模错误，当一个函数与数据过于接近时，会导致新数据引入模型时出现高水平的错误。
有多种方法可以防止模型过度拟合:
- 交叉验证:交叉验证是一种用于评估模型在新的独立数据集上表现如何的技术。交叉验证最简单的例子是将数据分成两组:定型数据和测试数据，其中定型数据用于构建模型，测试数据用于测试模型。
- 正则化:当模型具有更高次的多项式时，会发生过度拟合。因此，正则化通过惩罚高次多项式来减少过拟合。
- 减少特征数量:你也可以通过减少输入特征的数量来减少过度拟合。您可以通过手动移除特征来实现这一点，或者您可以使用一种称为主成分分析的技术，该技术将高维数据(例如 3 维)投影到较小的空间(例如 2 维)。
- 集成学习技术:集成技术通过 bagging 和 boosting 将许多弱学习者转化为强学习者。通过装袋和增压，这些技术比它们的替代技术更容易过度适应。
问:对于我们正在考虑的新功能，你会如何设计实验？什么样的指标是重要的？
作者创建的图像
我会进行 A/B 测试，以确定新特性的引入是否会在我们关心的给定指标上带来统计上的显著改进。度量标准的选择取决于功能的目标。例如，可以引入一个功能来提高转换率、web 流量或保留率。
首先，我会制定我的零假设(特征 X 不会改善度量 A)和我的替代假设(特征 X 会改善度量 A)。
接下来，我会通过随机抽样来创建我的控制组和测试组。因为 t 检验天生就考虑样本量，所以我不打算指定一个必要的样本量，虽然越大越好。
一旦我收集了我的数据，根据我的数据的特点，我会进行 t 检验，韦尔奇的 t 检验，卡方检验，或贝叶斯 A/B 检验，以确定我的控制组和测试组之间的差异是否有统计学意义。
谷歌
问:一个盒子里有 12 张红卡和 12 张黑卡。另一个盒子里有 24 张红牌和 24 张黑牌。你想从两个盒子中的一个里随机抽取两张卡片，一次抽取一张。哪个盒子得到同色卡片的概率更大，为什么？
有 24 张红卡和 24 张黑卡的盒子获得两张同色卡片的概率更大。让我们走过每一步。
假设你从每副牌中抽出的第一张牌是红色的 a。
这意味着在有 12 个红和 12 个黑的牌组中，现在有 11 个红和 12 个黑。因此，你再抽一张红色的几率等于 11/(11+12)或 11/23。
一副牌中有 24 个红和 24 个黑，那么就有 23 个红和 24 个黑。因此，你再抽一张红色的几率等于 23/(23+24)或 23/47。
由于 23/47 > 11/23，所以卡数较多的第二副牌有较大概率得到相同的两张牌。
问:你在赌场，有两个骰子可以玩。你每掷一次 5 就赢 10 美元。如果你一直玩到你赢了然后停止，预期的回报是多少？
- 我们假设每次你想玩的时候要花 5 美元。
- 两个骰子有 36 种可能的组合。
- 在 36 种组合中，有 4 种组合会掷出 5(见蓝色)。这意味着有 4/36 或 1/9 的机会掷出 5。
- 1/9 的胜算意味着你会输八次，赢一次(理论上)。
- 因此，您的预期支出等于$ 10.00 * 1-$ 5.00 * 9 =-35.00。
编辑:谢谢各位的评论和指出，应该是——35 美元！
问:如何判断给定的硬币是否有偏差？
这不是一个难题。答案很简单，就是进行假设检验:
- 零假设是硬币没有偏向，翻转头的概率应该等于 50% (p=0.5)。另一个假设是硬币有偏差，p！= 0.5.
- 抛硬币 500 次。
- 计算 Z 得分(如果样本小于 30，则需要计算 t 统计量)。
- 对比 alpha(双尾检验所以 0.05/2 = 0.025)。
- 如果 p 值>α，则不拒绝 null，硬币不偏。
如果 p 值< alpha，则拒绝 null，硬币有偏。
了解更多假设检验 这里 。
让不公平的硬币变得公平
由于抛硬币是二进制的结果，你可以通过抛两次硬币来使不公平的硬币变得公平。如果你掷两次，有两种结果可以赌:正面跟着反面或者反面跟着正面。
P(正面)* P(反面)= P(反面)* P(正面)
这是有意义的，因为每一次抛硬币都是一个独立的事件。这意味着如果你得到正面→正面或反面→反面，你需要重新抛硬币。
问:你即将登上去伦敦的飞机，你想知道你是否需要带雨伞。你随便打电话给三个朋友，问他们是否在下雨。你的朋友说实话的概率是 2/3，他们通过撒谎对你恶作剧的概率是 1/3。如果他们三个都说在下雨，那么伦敦下雨的概率是多少。
你可以看出这个问题与贝叶斯理论有关，因为最后一个陈述本质上遵循这样的结构，“假设 B 为真，A 为真的概率是多少？”因此，我们需要知道某一天伦敦下雨的概率。假设是 25%。
P(A) =下雨的概率= 25%
P(B) =三个朋友都说在下雨的概率
P(A|B)假定他们说在下雨的概率
P(B|A)假定在下雨的情况下三个朋友都说在下雨的概率= (2/3) = 8/27
第一步:求解 P(B)
P(A | B)= P(B | A) * P(A)/P(B)，可以改写为
P(B)= P(B | A)* P(A)+P(B |非 A)* P(非 A)
P(B)=(2/3)* 0.25+(1/3)* 0.75 = 0.25 * 8/27+0.75 * 1
第二步:求解 P(A | B)
P(A | B)= 0.25 *(8/27)/(0.25 * 8/27+0.75 * 1/27)
P(A | B)= 8/(8+3)= 8/11
因此，如果三个朋友都说在下雨，那么有 8/11 的几率是真的在下雨。
问:给你 40 张四种不同颜色的卡片——10 张绿卡、10 张红牌、10 张蓝卡和 10 张黄牌。每种颜色的卡片都从一到十编号。随机抽取两张牌。找出所选卡片不是相同号码和相同颜色的概率。
由于这些事件不是独立的，我们可以使用规则:
P(A 和 B) = P(A) * P(B|A)，也等于
P(非 A 非 B) = P(非 A) * P(非 B |非 A)
例如:
P(非 4 非黄)= P(非 4) * P(非黄|非 4)
P(非 4 非黄)= (36/39) * (27/36)
P(非 4 非黄)= 0.692
所以，挑出来的牌不是同号同色的概率是 69.2%。
感谢阅读！
如果你喜欢我的工作并想支持我，我会非常感谢你在我的社交媒体频道上关注我:
有兴趣合作？查看我的写作机构，ShinTwin，我们来连线吧！
一篇文章中的熊猫 30 天
总结了 30 种有用的熊猫功能和方法
Pandas 是一个专门用于数据操作的 Python 包。这个包是数据科学家生活中不可分割的一部分，了解它不会给你带来任何伤害。
之前，在我的 LinkedIn 帖子中，我在三十天中每天发布我认为有用的熊猫包中的新函数和方法。有些人要求我做一个总结，正因为如此，我会在这里写一篇关于它的文章。
继续读！
第一天:style.bar
我想展示一个名为style.bar的 Pandas 数据框对象的方法，它允许你在数据框中创建一个数值列的柱状图。您只需在数据框对象后使用. style.bar 来调用此方法。
如果你想让你的数据展示更有冲击力，更清楚地说明你的观点，这种方法很有用
#Day 1 style.barimport pandas as pd
import seaborn as snsplanets = sns.load_dataset('planets')planets.head(10)[['method','year', 'distance']].sort_values(by = 'distance').style.bar(color = 'lightblue', subset = 'distance').hide_index()
第二天:qcut
今天我要给大家展示一个从熊猫到划分你的数据的有用函数叫做qcut。
熊猫的功能qcut是什么？qcut函数将对连续变量进行分箱，其中基于等级或基于样本分位数，分箱大小相等。
那么什么是分位数呢？分位数基本上是一种以相等方式划分连续值的除法技术。例如，如果我们将连续值分为 4 部分；它被称为四分位，如图所示。
#Day 2 qcutimport seaborn as sns
import pandas as pd
mpg = sns.load_dataset('mpg')pd.qcut(x = mpg['mpg'], q = 4, labels = [1,2,3,4])
第三天:数据透视表
在这篇文章中，我想向你介绍一种最强大的方法，叫做 pivot_table。
通过调用方法，可以在数据框对象中访问此方法。数据框对象后的 pivot_table。
那么这个方法是干什么的呢？它根据我们传递给 columns 参数的 categorical 对象创建一个数据透视表，values 参数接受数值。
pivot_table 的特殊之处在于，结果不仅仅是值，还有传递给参数的聚合函数。
您可以查看示例图片了解更多信息。希望有帮助！
#Day 3 pivot_tableimport pandas as pd
import seaborn as sns
tips = sns.load_dataset('tips')tips.pivot_table(columns = 'sex', values = 'total_bill', aggfunc = 'mean', index = 'size', margins = True)
第四天:agg
今天先说一个比较简单的方法。在这里，我要介绍一个来自数据框对象的方法，叫做 agg。
就像名字一样，这个方法创建一个聚合表。也就是说，我们将预期的聚合放在。agg 方法和所有数字列都由创建表的聚合函数处理。
这个函数的伟大之处在于，我们可以通过创建自己的函数来放置我们想要的聚合，并且结果表会像示例图片中一样显示出来。
#Day 4 aggimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')def mean_divided_by_2(col):
return (col.mean())/2mpg.agg(['mean', 'std',mean_divided_by_2])
第五天:融化
我想给你介绍一种来自熊猫数据帧的奇特方法，叫做融化。
当我们将每个值和变量分解到另一个表中时，这种方法与 pivot 方法相反。
请看下面的例子，这次我将 id_vars 指定为 tip 列，值为 sex 列。我们得到的是 tip 列中的每个值和 sex 列中的每个值都是成对的。
#Day 5 meltimport pandas as pd
import seaborn as sns
tips = sns.load_dataset('tips')tips.melt(id_vars = 'tip', value_vars = 'sex')
第六天:style.applymap
今天我要给大家介绍一个来自熊猫 Dataframe 的令人兴奋的方法，叫做style.applymap。
那么这个方法是干什么的呢？看一下这个例子，你可以看到一些数字是红色的，而另一些是黑色的。这是因为我们使用了 style.applymap 方法。
这个方法所做的是接受一个函数来修改我们 Jupyter 笔记本中的 CSS，并应用于我们数据框中的每一个值。
例如，在我的示例中，该函数将对小于等于 20 的数值进行着色。该函数需要为每个改变颜色的值返回的是一个带有颜色规范的字符串；例如’【T1 ')。
#Day 6 style.applymapimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')def mean_divided_by_2(col):
return (col.mean())/2mpg.agg(['mean', 'std',mean_divided_by_2])
第 7 天:选择类型
我想分享一个来自熊猫数据框架的简单而强大的方法，叫做.select_dtypes。
在数据清理和工程过程中，我经常使用这种方法，如果没有.select_dtypes方法，我会很难受。
那么，这是什么方法呢？很简单，这个方法用于根据特定的数据类型选择数据框中的列。例如“数字”或“对象”。
在示例中，我向您展示了我将“数字”数据类型传递给该方法；这意味着我只选择数字列(浮点数或整数)。我使用的另一个例子是“object ”,这意味着我只选择对象列。
#Day 7 select_dtypesimport seaborn as sns
import pandas as pd
mpg = sns.load_dataset('mpg')#Selecting the number data type
mpg.select_dtypes('number')#Selecting the object data type
mpg.select_dtypes('object')
第八天:style.hide_
今天我想向你介绍一个简单而有用的方法，尤其是在演讲中。这些方法是 style.hide_index 和 style.hide_columns。
所以，仅仅通过方法名，我想你可以猜到这个函数是用来隐藏索引和/或列的。
从示例中，您可以看到我隐藏了数据框索引和数据框列(通过传递列名)。
希望有帮助！
#Day 8 style.hide_import seaborn as sns
import pandas as pd
mpg = sns.load_dataset('mpg')mpg.head(10).style.hide_index().hide_columns(['mpg', 'name', 'model_year'])
第九天:更正
好吧，我很肯定很多人都知道。来自数据框对象的 corr 方法。
好吧，如果你不知道它是什么；。corr 是一种自动计算两个数值变量之间的相关性并将结果显示为矩阵图的方法。
默认情况下。corr 法有三种相关法计算；皮尔森，斯皮尔曼和肯德尔。但是，您知道您可以使用自己的相关函数计算吗？
在这个例子中，我从 scipy.stats weightedtau 创建了自己的函数来创建一个 weighted_tau 相关计算。我们需要的是。工作的 corr 方法是一个接受双参数并返回一个浮点对象的函数。
希望有帮助！
#Day 9 corrimport pandas as pd
import seaborn as sns
from scipy.stats import weightedtaudef weight_tau(x, y):
return weightedtau(x, y)[0]tips= sns.load_dataset('tips')
tips.corr(weight_tau)
第 10 天:更换
今天我要给大家介绍的数据框对象方法叫做. replace。
所以，这个方法顾名思义；它曾经取代了一些东西，但是什么呢？
这个方法做的主要事情是替换值；是的，列中的值。
从这个例子中，您可以看到我通过在方法中传递一个 dictionary 对象来替换这个值。所以我例子中的逻辑是: {columns name: {values you want to replace: values to replace}}。
#Day 10 replaceimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg.replace({'cylinders' : {3: 'Three', 4: 'Four', 5: 'Five', 6: 'Six', 8 : 'Eight'}}, inplace = True)
mpg.head()
第 11 天:历史
嗯，我想给你介绍一个来自熊猫系列对象的很酷的方法，叫做. hist。
所以，这种方法工作简单；它从您的数字系列对象创建一个直方图。简单吧？
你只需要调用它，它会自动创建你的直方图，就像例子一样。
#Day 11 histimport seaborn as sns
import pandas as pd
mpg = sns.load_dataset('mpg')mpg['mpg'].hist()
第 12 天:拿假人
我想给你介绍一个熊猫的特殊功能，叫做 get_dummies。
从这个例子中，你可能得到它所做的，但对你来说没有；这种方法被称为一个热编码或 OHE。
get_dummies 函数用于基于一个变量中的分类类创建新要素，新要素的值为 0 或 1；0 表示不存在，1 表示存在。
当您需要将分类数据转换为数字数据时，最常用的一种编码方式。
#Day 12 get_dummiesimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
pd.get_dummies(mpg['origin'])
第 13 天:查询
我想给大家介绍一种很酷的数据帧方法，叫做.query。
那么，这个方法是干什么的呢？这个方法允许使用字符串表达式进行选择。这是什么意思？
看例子图片，它就像一些有条件的选择，对不对？这是一种基于布尔的选择方法。毕竟。
在示例表中，我们经常需要像mpg[(mpg['mpg'] <=11) & (mpg['origin] == 'usa')]那样为选择指定条件，但是使用 query 这一切都被简化了。只要向方法传递一个字符串条件，我们就会得到相同的选择结果。
#Day 13 queryimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg.query("mpg <= 11 & origin == 'usa'")
第 14 天:面膜
我想给大家介绍一个 if-then 方法，叫做. mask。
那么这个方法是干什么的呢？它用于将特定值替换为满足给定条件的另一个值。
在我的例子中，我传递了一个 mpg 值小于 20 的条件，然后用“大于 20”替换它。多酷啊！
#Day 14 maskimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg['mpg'].mask(mpg['mpg'] < 20, 'More than Twenty' )
第 15 天:交叉表
已经完成一半了，所以今天我想向大家介绍一个叫做 crosstab 的表格格式化函数。
那么，这个函数是做什么的呢？这个函数将帮助我们创建一个分类类的数据透视表，使用一个数值列的聚合函数作为值，尽管您也可以创建分类类之间的计数。
看看这个例子，你可以看到我指定了 origin 和 model_year(两者都是分类的)分别作为索引和列。此外，我将 mpg 列作为数值，并使用平均值作为聚合函数。
#Day 15 crosstabimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
pd.crosstab(index = mpg['origin'], columns = mpg['model_year'], values = mpg['mpg'], aggfunc = 'mean' )
第 16 天:申请
熊猫法是我在分析时经常使用的一种方法，我已经习惯了它的简洁。熊猫数据框方法是适用的。
这种方法接受一个函数，并将其应用于整个数据(以行的方式或列的方式)。函数返回的是结果。
看看这个例子，我应用了一个 lambda 函数，它返回每个数据值的长度。
#Day 16 applyimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg['name'].apply(lambda x: len(str(x)))
第 17 天:设置选项
今天我想给你介绍熊猫的一个特殊功能。这个函数被称为。设置选项。
这个功能是什么？所以，这个函数不是直接应用到你的数据上，而是影响到对象本身。
让我们看看下面的例子，我传递字符串来设置笔记本中显示的最大列数和最大行数。你可以在这里阅读所有选项。
希望有帮助！
#Day 17 set_optionimport pandas as pd
import seaborn as sns
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 50)mpg = sns.load_dataset('mpg')
mpg
第 18 天:描述
我只想向你展示一个来自 Pandas 数据帧对象的最广为人知的方法，叫做.describe。
我敢打赌，大多数用 Python 开始数据科学之旅的人都知道这种方法。对于不了解的人来说，这种方法可以生成包含所有基本统计数据的数据框。
虽然，这个 API 里有个小技巧。默认情况下，describe 只计算所有数字列，这些数字列依次为您提供平均值、标准差、百分位数等信息。
但是，如果像示例中那样排除数字列，最终会得到不同的数据框。这一次，将计算非数字列。在这里，我们得到的是频率和顶级类。
#Day 18 describeimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')#Describe numerical columns
mpg.describe()#Describe non-numerical columns
mpg.describe(exclude = 'number')
数字描述
分类描述
第 19 天:因子分解
我想给你介绍一个有用的熊猫函数和称为因式分解的级数方法。
首先看一下这个例子，这里我取了分类变量 origin，并对它使用了因式分解方法。结果如何呢？有两件事，数字数组和独特的类。
那么这种方法有什么特别之处呢？您刚才看到的数字数组是编码为数值的分类变量中的类。如何知道哪个数字代表哪个阶级？这就是为什么我们也有独特的类。
在下面的示例中，0 代表美国，1 代表日本，2 代表欧洲。就像独一无二的位置。
当您需要将分类编码成数值时，这个函数是最有用的，但是其中有一个序数假设。
#Day 19 factorizeimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg['origin'].factorize()
第 20 天:绘图
第 20 天，我要介绍一个来自熊猫的绘图功能，叫做 pd.plotting.radviz。
那么，这个函数是做什么的呢？据 Pandas 称，radviz 允许我们将一个 N 维数据集投影到一个 2D 空间，其中每个维度的影响都可以被解释为所有维度影响之间的平衡。
简单来说，这意味着我们可以用原始的方式将多维数据投影到 2D 空间。
数据帧中的每个系列都表示为一个圆形上均匀分布的切片。只看例子，有一个带系列名称的圆圈。
每个数据点都根据每个系列的值呈现在圆圈中。数据框中高度相关的系列更靠近单位圆。
要使用pd.plotting.radviz，您需要一个多维数据集，其中除了 class 列(应该是 categorical)之外，其他都是数字列。
#Day 20 plotting.radvizimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
pd.plotting.radviz(mpg.drop(['name'], axis =1), 'origin')
第 21 天:散点矩阵
今天我要介绍的是熊猫的另一个绘图功能。这一次，该函数被称为 plotting.scatter_matrix。
这是一个简单的函数，但在我们的数据分析生活中非常有用。主要的事情很简单，它在数据框中的所有数值变量之间创建了一个散点图。
对于对角线位置的图(变量本身)将是一个分布图(直方图或 KDE)。
如何使用该函数很简单，你只需要将数据框变量传递给该函数，它就会自动检测数值列。
#Day 21 scatter_matrix
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as pltmpg = sns.load_dataset('mpg')
pd.plotting.scatter_matrix(mpg, figsize = (8,8))
plt.show()
第 22 天:绘图
我想介绍一个简单的方法，从名为 plotting.boxplot 的 series 对象创建一个 boxplot。
如果你不知道箱线图是什么，引用熊猫指南箱线图是“一种通过四分位数图形化描述数字数据组的方法”。该方框从数据的 Q1 值延伸到第三季度的四分位值，中间有一条线(Q2)。触须从框的边缘延伸出来，以显示数据的范围。默认情况下，它们从盒子的边缘延伸不超过 1.5 * IQR(IQR = Q3-Q1)，在该间隔内最远的数据点结束。离群值标为单独的点”。
您只需要传递系列或数据框，数字列就会自动绘制出来。
#Day 22 plotting.boxplotimport pandas as pd
import seaborn as sns
import matplotlib.pyplot as pltmpg = sns.load_dataset('mpg')
pd.plotting.boxplot(mpg['mpg'])
第 23 天:任何
我将向您介绍一个简单而有用的 Series 和 DataFrame 方法。
这是什么方法呢？所以，。any 将返回布尔值，如果任何元素为 True，则返回 True；如果系列或列中没有 True 布尔值，则返回 False。
当我们想检查数据集中是否有缺失值时，这是最有用的。看看这个例子，我们被锁住了。isna with .any。只有马力返回 True，因为此列中缺少数据。
#Day 23 anyimport pandas as pd
import seaborn as sns
import matplotlib.pyplot as pltmpg = sns.load_dataset('mpg')
mpg.isna().any()
第 24 天:哪里
我想向您介绍一个 DataFrame 方法，类似于我之前发布的方法。
因此，与。我之前贴的蒙版方法。基本上，这是一种接受条件的方法，不满足条件的值将被替换。
看看这个例子，我给出了寻找低于 20 的值的标准，任何低于 20 的值都将保持它们的值，否则，它将被替换为“大于 20”。
#Day 24 whereimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg['mpg'].where(mpg['mpg'] < 20, 'More than Twenty' )
第 25 天:换位
今天我将向你展示一个简单而有用的方法。转置或. t。
这个方法很简单，通过执行。转置方法我们将切换数据帧列成为索引，而索引将成为数据帧列。
看看这个例子，我们有一个数据框，所有的位置都被调换了。当我们希望我们的行变成列时，这个函数很有用，反之亦然。
希望有帮助！
#Day 25 transposeimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg.transpose()
#or mpg.T
第 26 天:阴谋.散布
今天我想介绍一个熊猫数据帧对象的快速绘图方法，名为 plot.scatter。
我相信很多人都知道散点图是什么，虽然对你来说谁也不知道；它基本上是一个图，我们在 2 个不同的数字列中绘制每个数据，其中的值在图中是可视化的。
我们可以通过在数据框对象中使用. plot.scatter 创建一个快速散点图，并传递您想要的 2 列名称。
#Day 26 plot.scatterimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg.plot.scatter('mpg', 'weight')
第 27 天:转变
今天要介绍一个来自 Series 和 Data Frame 对象的方法，叫做.transform。
这是一个简单的功能，但功能强大。此函数的主要前提是我们传递一个函数或聚合字符串名称，并且该函数应用于所有的值。
如果在 DataFrame 对象中使用它，该函数将应用于每列中的每个值。
#Day 27 transformimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
mpg['mpg'].transform(lambda x: x/2)
第 28 天:自举 _ 情节
今天我要介绍一个熊猫独有的绘图功能，叫做.bootstrap_plot。
根据 Pandas 的说法，bootstrap 图用于通过依赖带有替换的随机抽样来估计统计的不确定性。
简而言之，它用于通过替换重新采样数据(您可以多次采样相同的数据)来尝试确定基本统计数据(如平均值和中值)中的不确定性。
boostrap_plot函数将为给定数量和给定大小的样本生成均值、中值和中间值统计的自举图。就像下面的例子一样。
#Day 28 bootstrap_plot
import pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')
pd.plotting.bootstrap_plot(mpg['mpg'], size = 50, samples = 500)
plt.show()
第 29 天:烟斗
在今天的熊猫贴子里，我想介绍一个我鼓励大家多使用的方法。方法是. pipe。
所以，熊猫鼓励我们使用方法链来操作我们的数据。通常我们会通过在函数或方法后面传递函数来链接方法。
与。管道函数，Pandas DataFrame 中的链接方法可以减少我们编写的行数并更快地执行函数。
的示例。管道方法如下图。我创建了两个不同的函数，并通过执行。管两次。这是为了创建一个链方法和更快的执行。
#Day 29 pipeimport pandas as pd
import seaborn as snsmpg = sns.load_dataset('mpg')#Function to extract the car first name and create a new column called car_first_name
def extract_car_first_name(df):
df['car_first_name'] = df['name'].str.split(' ').str.get(0)
return df#Function to add my_name after the car_first_name and create a new column called car_and_name
def add_car_my_name(df, my_name = None):
df['car_and_name'] = df['car_first_name'] + my_name
mpg.pipe(extract_car_first_name).pipe(add_car_my_name, my_name = 'Cornellius')mpg.head()
第 30 天:显示版本
在最后一天，我想向你们展示熊猫的一个特殊功能，叫做。显示版本。这个函数是做什么的？
这个函数给我们提供关于主机操作系统，熊猫版本，以及其他相关软件包版本的信息。它提供了有用的信息，尤其是当您处理相关的包时，并且对于 bug 报告也很重要。
#Day 30 show_versionsimport pandas as pdpd.show_versions(True)
结论
所以。这就是我的熊猫 30 天帖子。对我来说，这是一个非常有趣和有见地的活动。我喜欢为人们创造这样的内容，我希望它对我接触到的任何人都有用。
如果您喜欢我的内容，并希望获得更多关于数据或数据科学家日常生活的深入知识，请考虑在此订阅我的简讯。
如果您没有订阅为中等会员，请考虑通过我的介绍订阅。
扫一扫
723
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
