HalvingGridSearch 将超参数调谐速度提高了 11 倍
连续减半彻底粉碎了 GridSearch 和 RandomSearch
介绍
一段时间以来，Scikit-learn 的GridSearchCV和RandomizedSearchCV类一直是超参数调优的首选。给定一个可能参数的网格，两者都使用蛮力方法来计算任何给定模型的最佳超参数集。虽然它们提供了非常健壮的结果，但是在大型数据集上调整较重的模型会花费太多时间(这里我们说的是几个小时)。这意味着除非你有一台 16 核以上的机器，否则你就有麻烦了。
但是在 2020 年 12 月，Scikit-learn 的 0.24 版本推出了两个新的超参数调优类— HalvingGridSearch和HalvingRandomSearchCV。在官方用户指南中，Scikit-learned 声称“他们可以更快地找到一个好的参数组合”，天哪，他们是对的吗！
在我比较GridSearchCV和HalvingGridSearchCV的第一个实验中，后者找到最佳超参数集的速度比 GridSearch 快 11 倍。在第二个实验中，我将参数网格的大小增加了 30 倍(大约 3000 个最终候选)，我使用了HalvingRandomSearchCV,结果性能提高了 6%,整个过程只花了 10 分钟。
请继续阅读，了解这两个非凡的类是如何工作的，并学习如何在自己的工作流程中使用它们。
https://ibexorigin.medium.com/membership
获得由强大的 AI-Alpha 信号选择和总结的最佳和最新的 ML 和 AI 论文:
https://alphasignal.ai/?referrer=Bex
术语注释
在我们继续之前，让我们确保我们对我今天将使用的一些术语有相同的理解。
1。超参数:应该由用户设置的模型内部设置。模型无法从训练数据中学习这些。一个例子是xgboost估计器中的学习率。
2。参数网格:一个字典，以参数名作为键，以可能的超参数列表作为值。以下是XGBClassifier的参数网格示例:
参数网格的大小或所有可能的组合通过乘以每个参数的可能值的数量来计算。所以，上面的网格有 4 * 3 * 3 = 36 种可能的组合。一般来说，参数网格会比这个大得多。
3。候选者:参数网格中所有可能的超参数集合的单一组合。
4。资源或样本:手头数据的别称。一个示例引用训练数据中的一行。
5。迭代:对训练数据使用一组超参数的任何一轮。
GridSearchCV和RanomizedSearchCV概述
因为新类的主要思想与 GridSearch 和 RandomSearch 相关，所以让我简单介绍一下它们是如何工作的。
GridSearch 是一个详尽的强力估算工具。这意味着将使用交叉验证来训练超参数的所有组合。如果有 100 个可能的候选项，并且您正在进行 5 重交叉验证，则给定的模型将被训练 500 次(500 次迭代)。当然，对于笨重的模型来说，这需要非常长的时间。
RandomizedSearch 试图通过对每次迭代中选择哪组参数做出“更聪明”的选择来控制迭代次数。它有一个额外的n_iter参数直接控制这个过程。如果有 1000 个候选项并且n_iter被设置为 100，搜索将在第 100 次迭代后停止，并从这 100 个中返回最佳结果。这种随机选择过程导致训练时间大大缩短，但其性能不如 GridSearch。
如果你想进一步了解它们，并看到它们的实际应用，请查看我关于这个主题的另一篇文章:
什么是连续减半？
虽然 GridSearch 和 RandomizedSearch 都使用所有的训练数据来训练候选人，但是 HalvingGridSearch 和 HalvingRandomSearch 采用了一种不同的方法，称为连续减半。让我们看看它在 HalvingGridSearch (HGS)方面意味着什么。
HGS 就像所有候选人之间的竞争(超参数组合)。在第一次迭代中，HGS 用一小部分训练数据训练所有候选人。在下一次迭代中，只有表现最好的候选人才会被选中，他们将获得更多的竞争资源。因此，随着每一次迭代,“幸存”的候选者将被给予越来越多的资源(训练样本),直到最佳超参数集保持不变。
现在，让我们更细化。上述过程的速度可以由两个参数控制— factor和min_samples。min_samples取一个整数来指定在第一次迭代中使用的训练数据的样本数。所有候选人都在这个数据上被训练，并且在下一次迭代中min_samples增加factor，并且候选人的数量减少factor。所有下一轮都以这种方式继续，直到找到最佳候选人。
通过一个例子让这个想法深入人心，假设我们在参数网格中有 1000 个样本和 20 个候选者。如果我们将min_samples设置为 20，并选择factor为 2，那么迭代将会这样展开:
将min_resources设置为 20，有 20 个候选，我们只能运行 4 次迭代，因为我们将在用尽所有样本之前用完所有候选。这意味着剩余的训练数据(1000 - 160 = 840)将被浪费，并且最佳候选仅通过仅在 160 行数据上进行训练来找到。
同样，我们也可能在所有候选人都被试用之前就用完了样本。例如，假设我们有 1000 个样本和 300 个候选人。我们将min_samples设置为 50，并选择因子 2:
如您所见，在第五次迭代中，我们没有足够的资源来进一步翻倍，我们只剩下 18 个最终候选项。这些最终候选人别无选择，只能在完整的数据集上接受训练，这与普通的老式网格搜索没有什么不同。这个问题在真实世界的数据集上更加明显。
例如，我们今天将使用的数据集有 145，000 个样本。因此，我们需要确保我们选择了这样一个factor和min_samples的组合，在最后一次迭代中，我们将得到尽可能多的未浪费的资源。
这听起来确实有很多猜测，但幸运的是，您可以将exhaust传递给min_samples，这样最小数量的资源将被自动确定，以创建与factor和大量候选人的最佳可能组合。例如，对于 1000 个样本和因子 2，将min_samples设置为exhaust会将其设置为 250，在我们进行每次迭代时，这将变成 250、500、1000 个样本。
官方指南称，耗尽样本数量肯定会导致参数选择更加稳健，但可能会多花一点时间。在接下来的部分中，我们将探索新的类比它们的同类好多少。
HalvingGridSearchCV 与旧 GridSearchCV 的比较
为了比较这两个类，我将使用澳大利亚的Rain数据集来预测今天是否下雨。为了只关注手头的主题，我创建了包含所有必要预处理步骤的prep.py文件:处理缺失值、缩放数字特征和编码分类变量(您可以在GitHub gist中获得该文件)。
运行preprocess函数会返回一个干净的、经过处理的特征和目标数组，我们将以传统的名称保存它们:
目标变量是RainToday，作为基本估计量，我们将使用 XGBoostClassifier。让我们首先通过用默认参数拟合来建立基础分数:
要计算 ROC_AUC 得分，应该对目标和预测进行编码，但它们不是:
让我们用LabelEncoder对它们进行编码:
我们的基本分数是 0.73。现在，我们将尝试通过仅调整 4 个超参数来对此进行改进:
如果你不熟悉 XGBoost 以及它的参数是什么，可以看看我在上面写的初学者友好的文章。
候选人数为 108 人。首先，我们将使用五重交叉验证进行详尽的 GridSearch，这是两个类中的默认设置。度量仍然是roc_auc:
一个多小时后，我们找到了最佳参数和分数:
令人惊讶的是，roc_auc的分数下降了一点。也许，我们没有提供足够好的参数网格。然而，为了便于比较，让我们使用HalvingGridSearchCV进行同样的调优。它也是从sklearn.model_selection进口的，你也应该进口enable_halving_search_cv，因为它仍然是一个实验性的功能。
如我所说，我们将把min_resources设置为exhaust，并选择 Scikit-learn 推荐的因子 3:
哇！运行时间显著减少——几乎比 GridSearch 快 11 倍。现在让我们来看看表演:
如你所见，结果几乎相同。但是 HGS 比GridSearchCV快了 11 倍！
评估 HalvingRandomSearchCV
这一次，让我们用更好的超参数创建一个更大的网格。
首先， XGBoost 文档说要考虑到类不平衡，我们应该调整scale_pos_weight。结果表明，要找到最优值，我们应该用正类的和除以负类的和。让我们开始吧:
我们找到了scale_pos_weight。现在，我们还修正了subsample和colsample_bytree的值，以避免过度拟合。这次让我们提供更多可能的值，因为模型可能受到了太多的约束。
上次，gamma的最佳值被发现是 1，这是它的范围的结尾，所以我们也应该扩展它:
现在，我们有了一个相当大的网格，有将近 3000 个候选人。让我们看看HalvingRandomSearchCV是怎么回事(通过将n_candidates设置为exhaust来耗尽该类中的所有可用资源):
在看到 HGS 碾压 GridSearch 之后，我甚至懒得去比较
HalvingRandomSearchCV和普通的RandomizedSearchCV。显然，连续减半比两种老方法都好。
对于一个相当大的网格，只需要 10 分钟就可以找到最好的分数。此外，这次我们看到了 6%的分数增长，这是 HGS 和 GridSearch 都做不到的。
你印象深刻了吗？
结论
在完成上述实验后，我已经下定决心要转到新的班级。
你应该注意到，我们只有通过调整新类的最基本设置才能达到如此高的性能。根据文档，这两个类都提供了更多的设置来控制速度和性能，所以也值得一试:
如果您感兴趣，XGBoost 参数调整的官方指南:
不要忘记进行你自己的实验并分享结果！
如果你不知道接下来要读什么，这里，我为你挑选了一些:
https://towardsdev.com/how-to-use-plotly-as-pandas-plotting-backend-123ff5378003
掌握熊猫价值排序的 11 个技巧
有效使用 Pandas sort_value()的实践教程
数据排序是将数据按某种有意义的顺序排列，使其更容易理解、分析或可视化的过程。[1]
数据排序是数据分析中最常见和最基本的过程之一。Pandas 有一个内置的方法sort_values()来根据给定的标签对数据进行排序。该方法本身使用起来相当简单，但在实践中，您可能会遇到各种排序问题，例如，缺少值、特殊字符、自定义标签(例如，t 恤尺寸 XS 、 S 、 M 、 L 、 XL 等)。
在本文中，我们将通过一些实践教程来探索熊猫sort_values()的不同用例。本文组织如下:
- 对系列进行排序
- 按单列对数据帧进行排序
- 按多列对数据帧进行排序
- 排序前应用转换
- 对多列应用转换
- 处理自定义排序
- 处理缺失值
- 就地排序值
- 忽略带有
ignore_index=True的索引 - 按行对数据帧进行排序
- 选择不同的排序算法
请查看 笔记本 获取源代码。更多教程可从Github Repo获取。
为了演示，让我们创建一个数据帧:
df = pd.DataFrame({
'product': ['keyboard', 'mouse', 'desk', 'monitor', 'chair'],
'category': ['C', 'C', 'O', 'C', 'O'],
'year': [2002, 2002, 2005, 2001, 2003],
'cost': ['$52', '$24', '$250', '$500', '$150'],
'promotion_time': ['20hr', '30hr', '20hr', '20hr', '2hr'],
})
作者图片
1.对系列进行排序
sort_values()最简单的用法就是对一个数列进行排序。例如，让我们对“**年”**列的值进行排序:
df['**year**'].sort_values()3 2001
0 2002
1 2002
4 2003
2 2005
Name: year, dtype: int64
df['year']将“年”列作为一个序列返回，sort_values()用于对值进行排序。默认情况下，sort_values()返回的输出是升序的。我们可以将ascending参数设置为False来获得降序结果。
df['year'].sort_values(**ascending=False**)2 2005
4 2003
0 2002
1 2002
3 2001
Name: year, dtype: int64
2.按单列对数据帧进行排序
要根据单个列中的值对 DataFrame 进行排序，需要传递该列的名称。例如，让我们按“年”列对数据集进行排序
df.sort_values(**'year'**)
# same as df.sort_values(**by='year'**)
熊猫按单个列对 _values()排序(图片按作者)
默认情况下，该方法将返回一个按升序排序的新数据帧，并且不会修改原始数据帧。
我们还可以使用ascending参数来指定我们的偏好，例如将它设置为False来获得降序结果。
df.sort_values('year', **ascending=False**)
熊猫按单个列对 _values()排序(图片按作者)
3.按多列对数据帧进行排序
有时，我们需要按多列对数据帧进行排序。熊猫sort_values()非常简单，因为第一个参数by接受一个列表作为输入:
df.sort_values(**['category', 'year']**)
熊猫按多列对 _values()排序(图片按作者)
默认情况下，它按升序对多列进行排序。ascending参数接受一个布尔值列表，每个值对应一列。因此，我们也可以指定我们的偏好如下:
df.sort_values(**['category', 'year'], ascending=[True, False]**)
熊猫按多列对 _values()排序(图片按作者)
4.排序前应用转换
有时，您的数据不能像预期的那样正确排序，例如“成本列中的符号$。
熊猫 sort_values()带变换(图片由作者提供)
问题是，如果我们调用这个方法，我们将得到按字符串而不是数字排序的结果。
Pandas sort_values()提供了一个key参数，它允许我们在排序之前传递一个自定义函数来转换值。让我们创建一个 lambda 函数来删除$并将剩余的字符串转换成一个数字:
df.sort_values(
'cost',
**key=lambda val: val.str.replace('$', '').astype('float64')**
)
熊猫 sort_values()带变换(图片由作者提供)
5.对多列应用转换
在 Pandas sort_values()中，key功能适用于每个排序列。我们来看看如何按“年”、“促销 _ 时间”、“成本【T31”)对数据帧进行排序。
df = pd.DataFrame({
'product': ['keyboard', 'mouse', 'desk', 'monitor', 'chair'],
'category': ['C', 'C', 'O', 'C', 'O'],
**'year': [2002, 2002, 2005, 2001, 2003],**
**'cost': ['$52', '$24', '$250', '$500', '$150'],**
**'promotion_time': ['20hr', '30hr', '20hr', '20hr', '2hr'],**
})
注意“成本”和“促销 _ 时间”都是字符串值，需要转换，年的值也可以。让我们继续创建一个常规函数sort_by_cost_time():
def **sort_by_cost_time**(x):
if x.name == 'cost':
return x.str.replace('$', '').astype('float64')
elif x.name == 'promotion_time':
return x.str.replace('hr', '').astype('int')
else:
return x # Pass the function to the key argument
df.sort_values(
**['year', 'promotion_time', 'cost'],**
**key=sort_by_cost_time** )
熊猫 sort_values()带变换(图片由作者提供)
sort_by_cost_time()函数检查列名并应用相应的转换。else块适用于任何其他列，并返回原始数据。
6.处理自定义排序
Pandas sort_values()使用起来相当简单，但是它不能用于自定义排序，例如，
- t 恤尺码:
XS、S、M、L和XL - 月份:
Jan、Feb、Mar、Apr、…。等等 - 星期几:
Mon、Tue、Wed、Thu、Fri、Sat和Sun。
我们已经学习了使用key参数的转换。我们当然可以用它来解决自定义排序问题，但是在处理大型数据集时，性能会非常糟糕。我们可以通过声明一个CategoricalDtype来更有效地解决这个问题。让我们来看看这个例子:
df = pd.DataFrame({
'cloth_id': [1001, 1002, 1003, 1004, 1005, 1006],
**'size': ['S', 'XL', 'M', 'XS', 'L', 'S'],**
})
首先，让我们导入CategoricalDtype。
from pandas.api.types import **CategoricalDtype**
然后，创建一个自定义类别类型cat_size_order,用
- 第一个参数设置为
['XS', 'S', 'M', 'L', 'XL']为布料尺寸的唯一值。 - 第二个变量
ordered=True将被视为有序分类变量。
cat_size_order = CategoricalDtype(
['XS', 'S', 'M', 'L', 'XL'],
ordered=True
)
之后，调用astype(cat_size_order)将尺寸数据转换为自定义类别类型。通过运行df['size']，我们可以看到 大小 列已经转换为带有顺序[XS < S < M < L < XL]的类别类型。
df['size'] = df['size']**.astype(cat_size_order)**
df['size']0 S
1 XL
2 M
3 XS
4 L
5 S
Name: size, **dtype: category**
**Categories (5, object): [XS < S < M < L < XL]**
最后，我们可以调用sort_values('size')对值进行排序。
df.**sort_values('size')**
自定义排序的 Pandas sort_values()
这里有一篇文章可以了解更多关于熊猫的自定义排序:
7.处理缺失值
在 Pandas 中，缺失值被赋予值NaN，这是“不是一个数字”的缩写。当我们对值进行排序时，默认情况下，这些NaN被放在所有其他有效值的后面。
df = pd.DataFrame({
'id': [4, 2, 3, **np.nan**, 6, 5],
'name': ['A', 'B', 'C', 'D', 'E', 'F'],
})df.sort_values('id')
Pandas sort_values()处理缺失值(图片由作者提供)
如果我们想将它们放在开头，我们可以将na_position参数设置为First。
df.sort_values('id', **na_position='first'**)
或者，我们可以考虑删除或替换丢失的值。
8.就地排序值
重要的是要记住，默认情况下，sort_values()将返回一个新的数据帧，而原始数据帧保持不变。为了避免创建新的数据帧，可以将参数inplace设置为True。
df.sort_values('id', **inplace=True**)
注意，使用inplace=True，调用将返回None。
9.用ignore_index=True忽略索引
您可能已经注意到，在结果中，每个排序的行的索引保持不变。如果您想忽略原始索引并用0到n-1标记结果(有序索引)，您可以将参数ignore_index设置为True:
10.按行对数据帧进行排序
熊猫sort_values()支持axis的说法。默认为0，即按列对值进行排序。在某些情况下，您可能希望按行而不是按列对数据帧进行排序。为此，我们可以将axis参数设置为1:
df = pd.DataFrame({
'Tom': [70, 67, 90, 50],
'Jacky': [90, 85, 76, 70],
'Lucy': [56, 60, 75, 77]
}, index=['Math', 'Chemistry', 'Physics', 'Art'])df.sort_values(**'Chemistry'**, **axis=1**)
熊猫按行排序 _ 值()
11.选择不同的排序算法
我们应该知道 Pandas sort_values()允许我们选择不同的排序算法。根据官方 API【2】，默认算法为 快速排序 。而其他可用的算法有***【merge sort】heap sortstable***。要改变这一点，可以将算法名传递给参数kind:
df.sort_values('Chemistry', **kind='heapsort'**, axis=1)
注意:对于数据帧，此选项仅在对单列或单行排序时适用。[2]
结论
在本文中，我们已经讨论了 11 个使用熊猫sort_values()方法对值进行排序的用例。它非常方便，是探索性数据分析和数据预处理中最受欢迎的方法之一。数据排序是数据科学中一项重要的基本技能。我希望你喜欢这篇文章，并学到一些新的有用的东西。
感谢阅读。请查看笔记本获取源代码，如果你对机器学习的实用方面感兴趣，请继续关注。更多教程可从 Github Repo 获得。
参考资料:
- [1] 什么是数据排序？
- [2] 熊猫 API 文档 sort_values()
14 个活跃的人工智能游戏比赛将于 2022 年结束(正在进行和即将进行)
这些不是普通的数据科学竞赛。
马尔科·布拉泽维奇在 Unsplash 上的照片
人工智能游戏比赛也被称为人工智能编程比赛或*机器人编程比赛。*它们不同于一般的数据科学竞赛。在人工智能游戏比赛中，你不会得到一个数据集。取而代之的是，你得到一个游戏或者模拟游戏，你的工作是编写一个可以在其中竞争的代理程序(有时是和其他玩家的代理进行正面交锋)。
它们可以是练习编程、算法和 AI/ML 的好地方。这些竞赛在难度、奖金、可用语言和可行策略方面有很大差异。为了帮助你找到合适的游戏，我整理了一份正在进行和即将进行的人工智能游戏比赛的列表，下面就来看看。
注: 如果你对面向强化学习的竞赛感兴趣，可以查看 活动强化学习竞赛列表 。
**2021 年 12 月更新:**2022 年改版！更新了战斗代码，俄罗斯 AI 杯，代码杯和 IEEE CoGs 的比赛细节。在名单上增加了武士。将 Yare.io 和 AICrowd 移至特别提及
AI 游戏比赛列表
1.https://www.kaggle.com/simulations(2010—)
由两个适马制作的石盐，现在在 Kaggle 上(截图由作者拍摄)
你可能听说过 Kaggle。他们是最受欢迎的举办数据科学竞赛的平台。但它们也是一系列模拟游乐场的所在地，如 ConnectX 、饿鹅和资源管理游戏两个适马的 Halite。玩家提交在实时排行榜上竞争的代理，奖品包括 Kaggle 商品和您的 Kaggle 个人资料的排名积分。
如果你是人工智能游戏竞赛的新手，Kaggle 是一个很好的起点，因为他们提供教程和免费的 GPU 来进行培训。目前，他们的模拟只支持 Python 中的提交。
2.AWS DeepRacer(2018—)****
AWS DeepRacer 是一款 3D 赛车模拟器，旨在帮助开发者开始强化学习。使用他们的预建模型，您将能够专注于设计奖励函数和调整超参数。
在 AWS 上开始 10 小时的培训是免费的。顶级赛车手每年都会获得一次付费旅行，在 re:Invent 参加 AWS DeepRacer 冠军杯比赛。如果你打算认真竞争，你需要为培训、评估和在 AWS 上存储你的模型付费。
除了他们的虚拟赛道，还有一个选择是花 399 美元购买他们的 deep racer Evo(1/18 比例的自动赛车),在物理赛道上尝试你的 RL 模型。
3. 编码器一个 (2020 —)
地下城和数据结构游戏(图片由作者提供)
Bomberland 是一个基于经典主机游戏 Bomberman 的多智能体 AI 竞赛。比赛目前正在进行，全年都有持续的排行榜。当前赛季的奖品包括 1000 美元的现金和定制商品。顶级球队将在 2022 年 3 月举行的决赛直播中亮相。
比赛的特点是具有挑战性的 1v1 基于网格的环境。每个特工控制一个由 3 个单位组成的小组，收集皮卡和放置炸药，目标是打倒对手。
参与者可以自由选择使用任何语言。初学者工具包有 Python、TypeScript、C++和 Go 版本。
4.终端通过关联一 (2018 —)
浏览器中的终端游戏(作者截图)
终端是由 Correlation One 组织的双人塔防游戏。在终端，你轮流建造建筑和移动单位来打倒你的对手。
Terminal 提供常规赛季(目前在第 8 季)，拥有可笑的奖金池(200，000 美元以上)，并以决赛锦标赛结束。
玩家可以使用 Python、Java 或 Rust 来构建他们的代理。
5.https://codingame.com(2012—)****
CodinGame 的内置 IDE(作者截图)
CodinGame 是一个面向程序员的培训平台，具有一系列基于游戏的练习、内置的 IDE 和对多种语言的支持。
他们举办季节性比赛，每次持续约两周。每个比赛都有一个新的游戏，和一个排名系统来衡量你的进步。以前的奖品包括 CodinGame T 恤、显示器和键盘以及亚马逊礼品卡。
如果你打算参加，你会有一个很好的公司，因为每个比赛都吸引了成千上万的开发者，其中一些人积极地参与其中。
6. Screeps (2014 —)
Screeps:世界(作者截图)
Screeps 是一个在线 RTS PvP 游戏，在这个游戏中，你控制一个殖民地来收获资源，建造单位，征服领土，并与其他殖民地进行贸易。
最初的 Screeps 游戏让玩家在一个持续开放的世界中竞争。最近在 2021 年末发布了“Screeps: Arena”的预发布版本，该版本将在基于比赛的竞技场环境中进行。
最初的 Screeps(改名为 Screeps: World)和 Screeps: Arena 都可以在 Steam 上购买(15-19.95 美元)。可以用 JavaScript 以及 WebAssembly 支持的其他语言(C/C++、Rust、TypeScript、Go 等等)编程。
7. Lux AI 挑战赛 (2021 —)
Lux AI 挑战赛首页(作者截图)
Lux AI 是一个新的 AI 编程比赛，于 2021 年底在 Kaggle 上首次推出。
它的特点是一个 1v1 的 RTS 游戏，白天/夜晚循环，在这个游戏中你可以控制一队可以收集资源、研究和建造城市的单位。目标是有效地管理你的资源，以维持最大的城市。
之前的比赛有 10，000 美元的奖金池，支持 Python、C++、JavaScript/TypeScript 和 Java。
9.战斗密码 (2003 —)
Battlecode 是麻省理工学院历史最长的编程竞赛。主题每年都在变化，但一般都围绕着一个回合制策略游戏。参与者用 Java 写一个人工智能玩家控制一个机器人军队去打倒他们的对手。
任何人都可以参加比赛。尽管如此，只有全日制学生团队(国际学生和麻省理工学院学生)才有资格获得锦标赛奖金(2021 年的锦标赛设有 15，000 美元的奖金池)。比赛以多阶段锦标赛的形式进行，为期一个月。
下一场比赛将于 2022 年 1 月 3 日开始。
10.俄罗斯艾杯 (2012 —)
俄罗斯人工智能杯是由邮报组织的年度比赛。茹组和My.com。比赛之间的游戏差异很大，但前几年的特色是 RTS，动作/平台游戏等。
每场比赛大约有 2，000 名参与者，奖品包括商品、MacBook 和现金(最高 250，000 卢布)。
官方支持的语言有:C++，C#，F#，D，Go，Java，Kotlin，Scala，Python，Ruby，JavaScript，Rust。
更新:他们的沙盒模式现在开放练习，但是比赛已经推迟到 2022 年 2 月。
11.战蛇 (2015 —)
战蛇主页(作者截图)
《战蛇》是一款多人贪吃蛇游戏(类似于 Kaggle 的饿鹅)。你的目标是活得最久——要么消灭别人，要么努力不挨饿。
《战蛇》每年都会举办为期几个月的季节性联赛。奖品包括礼品卡、定制商品和商品。
要参与，你需要在你自己的服务器上运行你的代理，实现 Battlesnake API。您将能够使用任何语言，官方初学者工具包可用于 Python、Go、Java、JavaScript 和 Ruby。
11. 武士 (2021 — )
武士是一年一度的国际人工智能编程比赛，总部设在日本。基于网格的游戏包括控制一个武士和狗队挖掘比你的对手更多的宝藏。压轴活动通常是 IPSJ 国民大会的一部分。
2022 年比赛的时间表尚未公布，但通常在 12 月至 3 月之间举行。参与者可以从支持的编程语言中进行选择，包括 Python、Java 等。
12.艾体育馆 (2018—)
往届 AI 体育馆比赛(作者截图)
艾体育馆是爪哇的年度比赛，将于 2021 年 7 月回归。每年都有一个新的主题，通常围绕资源管理和实时策略。
比赛分为两个部分:短跑和决赛，并伴有溪流。整个比赛将持续约 3 周，总奖金约 1000 欧元。
13. CodeCup (2000 —)
CodeCup 每年举行一次，由荷兰国家信息学奥林匹克竞赛组织。2021 年的比赛已经结束，但 CodeCup 可能会在 2022 年初回归。
每年都会推出一款新游戏。前几年包括益智和棋盘游戏，如五排和井字游戏。支持的语言有 Pascal、C、C++、Java、Python 或 Haskell。
14. IEEE 游戏大会 (2019 —)
IEEE 游戏会议(CoG)是为游戏中人工智能一般领域的研究人员举办的年度活动。它旨在帮助研究人员在游戏人工智能方面产生新的论文和研究，但也以向公众开放的人工智能游戏的竞赛轨道为特色。
在这里，你会发现一系列人工智能游戏正在研究中使用，如 Dota 2，星际争霸，愤怒的小鸟，太空入侵者等等。一些比赛还将提供 500 美元的现金奖励。
CoG 将于 2022 年 8 月回归。比赛曲目尚未公布。
特别提及
以下是一些额外的网站和平台:
- AICrowd (2018 —):举办受监督的 ML 比赛和 RL 比赛。
- yare . io(2021—):2021 年 4 月推出的类似 Screeps 的新 RTS 游戏。以一个美学的空间主题为特色，在这个主题中，你可以控制攻击、防御和从恒星获取能量的单位来创造更多的单位。
- 机器人大战(Robot Rumble)(2021—):一个简单的双人游戏，你控制多个机器人，目的是用比对手更多的机器人结束游戏。在 Alpha 中，支持 Python 和 JavaScript。
- 星际争霸 2 人工智能竞技场 (2016 —):一个为星际争霸 2 开发脚本化和深度学习代理的活跃社区。
- 【AIGaming.com】(2017—):以战舰、象棋、围棋等众多游戏为特色的网站。
结束语
我试图把所有正在进行的和即将进行的人工智能游戏竞赛综合列出来。随着新的比赛的出现，我将努力保持这个列表的更新。
无论你最终选择哪个比赛，祝你好运！
你可以用 Python 和 Plotly 免费制作 12 种常见的 JMP 图表
📊对 JMP 的图形生成器感兴趣，但是更好+免费？
用 Plotly 制作图标 JMP 图的代码模板
介绍
JMP 是由 SAS 公司开发的统计分析软件。几十年来，它一直被科学和工程界用来执行统计分析和创建可视化。
现在，你可以使用 Plotly 为免费制作那些相同的可视化效果。不需要座位或者执照。
Plotly 是一个免费的开源图形库，它允许你用很少的编码知识制作漂亮的数据可视化和图表。
在这篇文章中，我们将探索如何重新制作一些 JMP 最有用和最具代表性的数据可视化，甚至给你所有的模板开始。
我们将涵盖:
- 控制图
- 直方图
- 散点图矩阵
- 箱线图
- 剥离地块
- 三元图
- 热图
- 树形图
- +更多！
每个图表部分将有三个子部分:
- 对比图显示了 JMP 和普洛特利的情节
- 重新创建 Plotly 可视化的代码
- 嵌入式 Chart Studio 图像。Chart Studio 是 Plotly 基于网络的拖放平台，用于创建、发布和嵌入交互式图表。想想类似于 JMP 的图形生成器，多了一些附加功能。提示:如果您点击嵌入的图形，您可以在 Chart Studio 中处理数据
所以让我们开始吧！
1)控制图:
控制图比较(作者制作)
控制图用于监控过程变化。它们有助于确定过程变化是随机的、自然的，还是来自于潜在变量的变化。这些通常用于制造环境，以确保高标准的质量和效率。
代码:
chart studio 的模板:
2)彩色控制图:
彩色控制图对比(作者制作)
代码:
chart studio 的模板:
3)可变性测量图:
可变性测量图比较(由作者制作)
可变性测量图显示了过程的变化如何在多个类别之间变化。在对复杂问题进行故障排除以试图找到问题根源时，它们非常有用。在工程和制造领域，测量多种模式下的机器一致性非常有用。
代码:
chart studio 的模板:
4)散点图矩阵:
散点图矩阵比较(作者制作)
散点图矩阵是评估多个变量之间相互关系的强大工具。他们绘制了散点图的所有双变量组合，这允许快速分析在一个图像中哪些关系是强有力的。当您拥有高维多变量数据时，尤其是具有高度相关性的数据时，它们会非常有用。它们在可视化和识别异常值时也很有用。
代码:
chart studio 的模板:
5)直方图:
直方图比较(作者制作)
直方图是数字数据的近似表示。它们是查看数据集“形状”的简单方法。它们可用于查看过程是遵循高斯分布还是均匀分布。JMP 还在柱状图顶部放置了一个水平箱线图，以强调四分位数和潜在的异常值。
代码:
chart studio 的模板:
6)箱线图:
箱线图比较(作者制作)
箱线图是观察变量分布的好方法。在这种情况下，我们使用一个具有两个级别的分割分类 x 轴。数据按年龄和性别进行了划分，显示了两个分类变量的值如何变化，并允许快速了解数据中的模式。
代码:
chart studio 的模板:
7)三元图:
三元情节对比(作者制作)
三元图一次显示三个变量及其关系。三条边中的每一条都代表一个变量，通常从端到端具有 0 到 1 的值。它们在生物学、化学、地质学等经常使用组件的领域中应用广泛。
代码:
chart studio 的模板:
8)平均值的置信区间:
均值比较的置信区间(作者制作)
置信区间图可能看起来很基本，但它们是比较一个类别中变量平均值的非常简单的方法。如果所列各组之间存在显著差异，它们会迅速让眼睛消化。
代码:
chart studio 的模板:
9)热图:
热图对比(作者制作)
热图对于可视化多个变量之间的差异以及理解它们之间的关系非常有用。它们对于查看具有趋势和模式的时间序列数据以及高维数据(如制造或传感器数据)非常有用。通常他们遵循一个连续的颜色方案，允许容易消化一个可变的组合对目标结果的影响。它们也很容易允许分组和模式理解。
代码:
chart studio 的模板:
10)剥离地块:
剥离图比较(由作者制作)
条状图或点状图类似于散点图，其中一个维度是绝对的。他们使用一个叫做“抖动”的术语来稍微向左或向右移动点，这样点就不会重叠。它们用于查看异常值和跨多个类别的分布，如果点是彩色的，甚至允许使用另一个分类变量。
代码:
chart studio 的模板:
11)树形图:
树形图比较(作者制作)
树形图是显示类别和两个定量变量之间关系的有趣方式。当显示数据集有多个层的分层数据时，它们也很有用。它们的工作原理是尺寸的格式塔原理和人类区分不同尺寸矩形的能力。最常见的情况是，矩形的大小与某种形式的数量相关。
代码:
chart studio 的模板:
12)多折线图:
多折线图比较(图片由作者提供)
折线图经常被用来说明变量是如何随时间变化的。它们对于理解制造系统非常有用，可以说明之前发生的事情。
代码:
chart studio 的模板:
结论:
当使用 Plotly 时，重新制作 JMP 可视化是快速和方便的。只用了几行代码，我们就能够重新创建这些图，并几乎完全匹配格式！如果使用 Chart Studio，我们甚至不需要代码！
最棒的是。我们为你做了繁重的工作！你所需要做的就是复制 Plotly 代码，修改几行来导入你的数据，然后你就可以重新制作图表了！或者对于那些对编码不太感兴趣的人，只需点击嵌入式 Chart Studio 小部件中的“编辑图表”,就可以在 Chart Studio 中处理数据了。
你甚至可以使用 Plotly 的 Dash 来为优秀的分析应用程序创建一系列图表和用户界面小部件(Dash 这个术语是杜撰的，现在被业内许多人使用)。这些应用程序是在线托管的，可以通过简单的链接共享。
迫不及待想看看你做了什么。
你应该知道的 12 个基本 Docker 命令
简化您的软件开发
照片由 Aron Yigin 在 Unsplash 上拍摄
ocker 已经成为软件工程不可或缺的一部分。我们使用 Docker 进行开发、测试和部署，因为它易于管理环境。由于它的可移植性，它在软件行业变得流行起来。这意味着如果你的代码在开发中有效，它将在生产中有效。此外，开发人员可以更快地协作，而不必担心他们需要安装哪个软件依赖项。
在这篇文章中，我将介绍 12 个基本的 docker 命令，它们将帮助你在 Docker 的神奇世界中导航。你可以从 Docker 的文档页面找到这些命令的官方文档。
1.docker 搜索
我们可以使用命令docker search在 Docker hub 上搜索公共图像。它将返回有关图像名称，描述，明星，官方和自动化的信息。
docker search MySQL
如果你喜欢基于图形用户界面的搜索选项，使用 Docker Hub 网站。
2.码头工人拉动
现在我们知道了图像的名称，我们可以使用命令docker pull从 Docker hub 中提取它。这里，我们还设置了平台选项。
docker pull --platform linux/x86_64 mysql
标签用于识别存储库中的图像。如果我们不指定标签，Docker 引擎默认使用:latest标签。所以，在前面的例子中，Docker 提取了mysql:latest图像。
如果我们的应用程序依赖于图像的特定版本，我们可以使用标记名来指定。
docker pull --platform linux/arm64/v8 mysql:5.6
因为我们可以在一个存储库中有多个图像，所以我们可以使用--all-tags选项提取所有的图像。以下命令将从 mysql 存储库中提取所有图像。
docker pull --all-tags mysql
3.docker 图像
太棒了，现在我们的本地机器上应该有一些图像了，为了确认，让我们运行下面的命令来列出所有的本地图像。
docker images
docker 图像
在我的例子中，我有两个在上一步中下载的图像。
4.码头运行
好了，现在我们有了一些图像，我们可以试着创建一个容器。这里我们使用了--env选项来设置一个强制的环境变量，使用--detach选项来在后台运行容器。
docker run --env MYSQL_ROOT_PASSWORD=my-secret-pw --detach mysql
此外，我们可以使用--name选项为容器指定一个名称。如果我们不提供名称，Docker 会随机分配一个名称。
5.docker ps
我们可以使用以下命令列出所有正在运行的容器。
docker ps
把所有的集装箱都列出来，包括停止的，怎么样？我们可以通过添加--all选项来实现。
docker ps --all
6.码头停车
要停止一个容器，使用带有容器 id 或容器名称的docker stop命令。如果我们想改变 docker 运行命令，我们可以停止一个容器。
docker stop f8c52bedeecc
7.docker 重启
让我们使用下面的命令重新启动停止的容器。我们可能需要在重启机器后使用它。
docker restart f8c52bedeecc
8.docker 重命名
现在，让我们将集装箱名称从compassionate_fermi改为test_db。我们可能希望更改名称，以便更容易地跟踪我们的容器。
docker rename compassionate_fermi test_db
9.码头经理
通过运行以下命令来访问正在运行的容器test_db。如果我们想访问 MySQL 命令行并执行 MySQL 查询，这很有帮助。
docker exec -it test_db bash
mysql -uroot -pmy-secret-pw
SHOW DATABASES;
-i and -t选项用于在交互模式下访问容器。然后我们提供想要访问的容器的名称，在本例中是test_db。最后，bash命令用于获取容器内部的 bash shell。
10.码头日志
这个命令有助于调试我们的 Docker 容器。它将从指定的容器中获取日志。
docker logs test_db
如果我们想继续流式传输新的输出，我们可以使用选项-follow。
docker logs -follow test_db
11.码头工人室
如果我们想删除一个容器，我们可以使用下面的命令。
docker rm test_db
您可能会遇到类似这样的错误
来自守护程序的错误响应:您无法删除正在运行的容器……在尝试删除或强制删除之前停止该容器
正如它所建议的，我们可以先停止容器，然后移除它，或者使用选项-f来强制移除正在运行的容器。
docker stop test_db
docker rm test_db
# or
docker rm -f test_db
12.码头工人 rmi
最后，如果我们想释放一些磁盘空间，我们可以使用带有映像 id 的docker rmi命令来删除一个映像。
docker rmi eb0e825dc3cf
这些命令带有大量有用的选项。如果您想了解其他可用选项，运行docker command_name --help命令。例如:
docker logs --help
我几乎每天都用 Docker 进行开源开发。它允许其他人轻松地为项目做贡献，而不用担心如何运行项目。希望这 12 个 Docker 命令能帮助你入门 Docker。如果你想了解更多关于 Docker 的知识，那么看看下面的文章。编码快乐！
相关职位
12 款 Jupyter 笔记本扩展，让您的生活更加轻松
Jupyter 笔记本电脑的重要扩展功能，可提高您的工作效率。
Jupyter Notebook 是数据科学家的首选计算笔记本，您可以在其中创建不仅包含实时代码，还包含公式、可视化和文本的文档。然而，默认情况下，Jupyter Notebook 缺少一些有用的功能，如自动完成、目录、代码折叠等。
这就是为什么我决定列出一个有用的 Jupyter 笔记本扩展列表，它将使您的生活更加轻松，并提高您编写代码的效率。下面您可以找到本文中列出的所有扩展。
**Table of Contents** 1\. [How to Install Extensions](#c42a)
2\. [Move selected cell](#bdf1)
3\. [Enable autocompletion (Hinterland)](#48e1)
4\. [Shortcuts to run multiple cells (Runtools)](#ef13)
5\. [Search files inside Jupyter Notebook (Tree filter)](#26b0)
6\. [Hide input (Hide input + Hide input all)](#7f6c)
7\. [Snippet Menu](#6f02)
8\. [Add a Table of Content (Table of Content 2)](#ed76)
9\. [Scrathpad](#435e)
10\. [Codefolding](#edca)
11\. [Variable inspector](#bcb8)
12\. [Translate text inside Jupyter Notebook (nbTranslate)](#1802)
13\. [Bonus: Change Themes](#7224)
如何安装扩展
要安装扩展，请在命令提示符或终端中运行以下代码
pip install jupyter_contrib_nbextensions
然后运行下面的代码，将 nbextensions 文件添加到 Jupyter 服务器的搜索目录中。
jupyter contrib nbextension install
现在打开 Jupyter 笔记本。应该有一个名为“Nbextensions”的新选项卡。点击它，你会看到一堆扩展，你可以用它来提高你的工作效率。
作者图片
以下是我觉得最有用的扩展。
移动选定的单元格
这是一个非常有用的扩展，允许你使用快捷键Alt-up和Alt-down来移动选中的单元格。只需选中 Nbextensions 中的“移动所选单元格”框。然后，刷新笔记本，您将能够通过简单的击键来移动单元格。
作者图片
Eenable自动完成(腹地)
对于那些努力在 Jupyter 笔记本上写代码的人来说，这是一个非常有用的扩展，因为没有自动完成功能。通过选中“腹地”框，您将在 Jupyter 笔记本上启用自动完成功能，并且能够像在您最喜欢的编辑器中一样编写代码。
作者图片
运行多个单元的快捷方式(运行工具)
Runtools 提供了许多额外的功能来处理 IPython 笔记本中的代码单元。其中一些是运行上面的单元格(⌥A)、运行下面的单元格(⌥B)和运行所有单元格(⌥X).要启用它，请选中 Nbextensions 中的“Runtools”框(在那里您也可以找到完整的快捷方式列表)。一旦它被激活，你会在工具栏中看到下面的图标。
作者图片
单击它打开带有这些代码执行按钮的浮动工具栏。
作者图片
在 Jupyter 笔记本中搜索文件(树形过滤器)
此扩展允许您在 Jupyter 笔记本文件树页面中按文件名进行过滤。
作者图片
隐藏输入(隐藏输入+隐藏所有输入)
您可以通过分别选中“隐藏所有输入”和“隐藏输入”来隐藏所有单元格的输入或特定单元格的输入。之后，工具栏中会出现以下图标。左边的一个将帮助你隐藏所有代码单元格的代码，而第二个只隐藏特定的单元格。
作者图片
代码片段菜单
对于那些喜欢备忘单的人来说，“摘录菜单”是 Jupyter 笔记本中必须包含的扩展。启用它后，您会看到一个名为“Snippet”的新菜单项，它将允许您插入代码和 markdown 代码片段。例如，Pandas 库有许多可用的代码片段，可以帮助您记住有用的 Pandas 方法。
作者图片
添加目录(目录 2)
写了许多行代码后，浏览你的笔记本会变得很困难。这就是为什么您应该添加一个目录，通过收集笔记本中包含的所有标题并在侧栏中显示它们，使导航更容易。
要在 Jupyter 笔记本中启用目录，请选中 Nbextensions 中的“目录(2)”框。之后，刷新笔记本，你会在工具栏中看到下面的图标。
作者图片
点击它以显示类似图片的目录(您需要至少有一个降价 h1、h2 或 h3 才能在内容部分看到它们)
作者图片
便条簿
您是否曾经想要在不修改笔记本文档的情况下测试新的代码行？您可以使用“便签簿”扩展来完成此操作。只要启用它，您就能够在当前内核上执行代码，而无需修改笔记本文档。启用后，右下角会出现以下图标。
点击它或使用快捷键Ctrl-B 打开草稿栏。在那里，您可以通过使用Shift-Enter或任何其他应用于笔记本文档的快捷方式来执行代码。
代码折叠
这个扩展允许代码单元中的代码折叠。只需启用 nbextension 选项卡中列出的“Codefolding”扩展，然后您会在代码单元格的左边看到一个三角形。
点击它或者使用快捷键Alt+F 来折叠代码。有三种不同的折叠模式支持:缩进折叠，括号折叠，和魔术折叠。
变量检查器
如果你想跟踪你在笔记本中使用的所有变量，你应该启用“变量检查器”扩展。这将帮助您查看所有已定义的变量名称、类型、大小和形状
启用后，工具栏中应该会出现以下图标。
点击它显示一个浮动窗口，收集所有已定义的变量。窗口可拖动、可调整大小和可折叠。
注意:打开“变量检查器”后，我发现了一些小故障。如果你也找到它们，只需关闭“变量检查器”。
翻译 Jupyter 笔记本中的文本(nbTranslate)
每当你必须阅读用外语写的笔记本时，这最后一个扩展将非常有用。只需启用“nbTranslate”扩展，然后你会在工具栏中看到两个新图标。
作者图片
右边的图标帮助您配置主要和辅助语言。设置完成后，当您想要将 markdown 单元格翻译成您的母语时，请单击左侧的图标。
作者图片
奖励:改变主题
Jupyter 笔记本上有很多可用的主题。首先，你需要安装jupyterthemes.打开一个终端并写
pip install jupyterthemes
在此之后，要查看可用主题列表，请编写jt -l
对于这个例子，我将选择“onedork”主题。若要更改主题，请编写以下代码。
jt -t onedork -T -N
其中-T是工具栏可见的，-N是名称&标识可见的(您甚至可以通过在上面的代码中添加-kl来显示内核标识)
注意:你也可以在一个笔记本中完成所有这些，只需在一个命令前添加 *!* 符号(如 *!*jt -l)
作者图片
就是这样！希望本文中列出的扩展对您有用。
下面你可以找到几个你可以开始在 Jupyter 笔记本上工作的项目。
与 3k 以上的人一起加入我的电子邮件列表，获取我在所有教程中使用的 Python for Data Science 备忘单(免费 PDF)**
12 个数学窍门帮助你不用计算器就能解决问题
在你的脑子里解决它
克里斯·贾维斯在 Unsplash 上的照片
加法+减法
1.添加
第一个技巧是通过把问题分成小块来简化它。例如，我们可以重写
567 + 432
= 567 + (400 + 30 + 2)
= 967 + 30 + 2
= 997 + 2
= **999**
转换
添加一个较小的数字通常更容易，所以不要用 131 + 858，而是交换数字
858 + 131
= 858 + 100 + 30 + 1
= **989**
2.减法
使用一个数的补数有助于使减法更容易。补数是原始数和一个整数的差，比如 100，1000。
以下是一些数字及其补数与 100 比较的例子:
67:33, 45:55, 89:11, 3:97
请注意，第二个数字加起来是 10，第一个数字加起来是 9。
这很有帮助
721–387
# the complement of 87 is 13, so we can swap 387 with 400 – 13
-> 721 — (400 - 13)
= 321 - -13
= 321 + 13
= **334**
另一种方法是写出较大的数字，使其以 99 结尾。同一个例子:
721 -> (699 + 22)
= 699 – 387 + 22
= 312 + 22
= **334**
克里斯·利维拉尼在 Unsplash 上的照片
乘法运算
3.上午 11 点左右的点心
对于两位数，将数字相加，并将答案放在要相乘的数字的中间:
35 x 11
-> 3**_**5
-> 3+5 = 8
-> 3**8**5
如果总和大于 10，将十位数加到左边下一栏，并将一位数写在答案中。比如 4+8 = 12，写下 2，把 1 进位到下一列。
48 x 11
-> 4_8
-> 4+8 = 12
-> 4,12,8
-> **528**
对于三位数和更大的数字，这个过程稍微复杂一点，但是它以类似的方式工作。这次保留第一个和最后一个数字，并成对求和
725 X 11
-> 7__5
-> 7_,(7+2=9), (2+5=7), _5
-> **7975**51973 x 11
-> 5__3
-> 5_,(5+1=6),(1+9=10), (9+7=16), (7+3=10), _3
# where the sum is greater than ten we move the tens digit into the next column
-> 5,(6+1),(0+1),(6+1),(0),3
-> **571703**
4.九
乘以 9 可以简化为乘以 10 再减去原来的数
799 x 9
= 799 x (10 -1)
= 7990 – 799
= **7191**
对任何以 9 结尾的内容使用相同的方法
72 x 89
= 72 x (90–1)
= (70 x 90) + (2 x 90) — 72
= 6300 + 180–72
= **6408**
5.如何解正方形
你可以用这个公式把一个平方方程改写成更容易处理的数字
n^2 = (n+d)(n-d) + d^2
其中 n 是要平方的数字，d 是差值
这里有一个例子
57^2
= (57+3)(57–3) + 3^2
# we add 3 to 57, as 60 is easier to multiply than 57, and subtract 3 from the second 57
-> 60 x 54 + 9
= 3000 + 240 + 9
= **3249**
最终的例子是，当你平方一个以 5 结尾的数，然后将一个数向上舍入到最接近的 10，将另一个数向下舍入到最接近的 10，再加上 25。
65^2
= (60 x 70) + 5^2
= 4200 + 25
= **4225**
6.紧密结合法
相似的方法也适用于相近的数字相乘。该公式适用于所有数字，但除非数字相似，否则它不能很好地简化。
这是公式。n 是“基数”
(n+a)(n+b) = n(n + a + b) + ab
一个例子:
47 x 43
= (40 + 7)(40 + 3)
= 40 x (40 + 3 + 7) + (7 x 3)
= (40 x 50) + (7 x 3)
= 2000 + 21
= **2021**
在这个例子中，一位数加起来是十，所以我们的“基数”和乘数是整数(40 和 50)。
这是另一个例子。减少较小的数字以达到最接近的整数——我们的基数，在本例中是 40。将差额加到较大的数字上。基数的倍数和更大的数。最后，加上原始数和基数之差的乘积。
47 x 42
= (40 + 7) x (40 + 2)
= (40 + 7 + 2) x 40 + (7 x 2)
= (49 x 40) + (7 x 2)
= (40 x 40) + (40 x 9) + (7 x 2)
= 1600 + 360 + 14
= **1974**
也可以四舍五入到基数。由于原始数字小于基数，我们将两个负数的乘积相加。
47 x 42
= (50 x 39) + (-3 x -8)
= (50 x 30) + (50 x 9) + (-3 x -8)
= 1500 + 450 + 24
= **1974**
这也适用于三位数。在这种情况下，基数在我们的数之间，所以乘积是负数。
497 x 504
= (500 – 3) x (500 + 4)
= (500) x (500 + 4 - 3) + (-3 x 4)
= 500 x 501 - 12
= 250,000 + 500 – 12
= **250,488**
桑德罗·舒赫在 Unsplash 上的照片
师
7.简化计算
你甚至可以在开始之前简化一些方程。例如，将除数和被除数都除以 2。
898 / 4
= 449 / 2
= 224 and ½
注意，用这种方法，你必须把余数写成一个分数:
898/4 has a remainder of 2 — divided by 4
449/2 has a remainder of 1 — divided by 2
分数相同，但绝对数不同。
除以 5 时，将等式乘以 2。除以 10 要容易得多。例如:
1753/5
= 3506 / 10
= **350.6**
8.可分性检验
有很多方法可以快速判断一个数是否是因子。
2 :数量为偶数。
Example 28790 is even, so it is divisible by 2.
3 :位数之和能被 3 整除。
Example: 1281 -> 1+2+8+1 = 12
-> 12 is a multiple of 3, so 1281 is divisible by 3
4 :最后两位数能被 4 整除。为什么会这样？100 是 4 的倍数，所以我们只需检查后两位。
Example: 1472, 72 is divisible by 4, so 1472 is divisible by 4.
5 :数字以 5 或 0 结尾。
Example: 575 ends in 5, so it is divisible by zero
6 :数是偶数，位数之和能被 3 整除。6 是 3 x 2，所以 2 和 3 的规则适用。
Example: 774 is even and 7+7+4 = 18
-> 18 is divisible by 3, so 774 is divisible by 6.
7 :给你的数字加上或减去 7 的倍数，使其以零结尾。将最后一个数字和零一起删除，然后重复这个过程。继续，直到你能确定结果是否能被 7 整除。
Example: 2702 add 98 (7 x 14) -> 2800, drop the zeroes
-> 28 is a multiple of 7, so 2702 is divisible by 7.
8 :后三位数能被 8 整除。
Example: 79256, 256 is divisible by 8, so 79256 is divisible by 8.(Alternate rule: if the hundreds digit is **even**, last **2** digits divisble by 8, if hundreds digit is **odd**, last **2** digits **+ 4** divisible by 8)
9 :和 3 一样的规则，但是用了 9。如果数字之和能被 9 整除，那么这个数就能被 9 整除。
Example: 13671 -> 1+3+6+7+1 = 18
-> 18 is divisible by 9, so 13671 is divisible by 9
10 :数字以 0 结尾。
Example: 280 ends in 0, 280 is divisible by 10
11 :与 3、9 规则相似，从右边数字开始，其余数字交替加减。如果答案是零，或者是 11 的倍数，那么这个数可以被 11 整除。
Example: 12727 -> 1 - 2 + 7 - 2 + 7 = 11, so 12727 is divisible by 11.
你可以在这里查看一些附加的方法。
9.用 9 除大数
Example:
-> 10520/9
在等式上方写下第一个数字，在最后一个数字上方写下“R”(表示余数)。把你刚写的数字和它右下方的数字加起来。把这个新数字写在第二点上。将该数字添加到右下方的数字中。继续这个过程，直到你到达 r。
将相同颜色的数字相加，得出下一个数字
最后，将 R 下面的数字加上最后一位数，得到余数。
10520/9
= **1168 R8**
or 1168.889
这是另一个例子:
-> 57423/9
这一次，在我们完成第一步之后，我们的第一个数字和斜下方和右边的数字之和大于 10(5+7 = 12)。我们在第一个数字上加 1，然后从中减去 9。(我们以 9 为基数除数，所以我们减去 9 而不是 10)。将得到的数字放在第二个位置(12–9 = 3)。继续同样的过程。
在这个例子中，我们的余数大于 9 (9+3 = 12)。再一次，我们在前一位数上加 1，从余数中减去 9，剩下 3。现在将结果和进位数字相加。
57423 / 9
= **6380 R3** or 6380.333
百分比和分数
10.反过来问
百分比是关联的，所以有时颠倒问题的顺序会更容易计算。
Example:
What’s 36% of 25
-> is the same as 25% of 36
-> 25% is ¼
-> 36/4 = 9
36% of 25 is **9**
11.分数
正如您在上一个示例中看到的，它有助于了解分数以及它们与百分比的关系。
1/2 = 50%1/3 = 33.33%, 2/3 = 66.67%,1/4 = 25%, 3/4= 75%1/5 = 20%, 2/5 = 40% …1/6 = 16.67%, 5/6 = 83.33% (2/6 = 1/3, 3/6 = 1/2, 4/6 = 2/3)1/7 = 14.2857%, 2/7 = 28.5714%, 3/7 = 42.8571%, 4/7 = 57.1428% (note the recurring .142857 pattern)1/8 = 12.5%, 3/8 = 37.5%, 5/8 = 62.5%, 7/8 = 87.5%1/9 = 11.11%, 2/9 = 22.22%, 3/9 = 33.33% …1/10 = 10%, 2/10 = 20% …1/11 = 9.09%, 2/11 = 18.18%, 3/11 = 27.27% …1/12 = 8.33%, 5/12 = 41.67%, 7/12 = 58.33%, 11/12 = 91.67%
12.第七十二条规则
72 法则提供了在给定的百分比回报率下，一项投资翻一番需要多少年的估计。它的工作原理是将 72 除以百分比，得到的答案是翻倍所需的年数。
2% -> 72/2 = 36, approximately 36 years to double
8% -> 72/8 = 9, approximately 9 years to double
请注意，72 的规则是基于自然对数 2 的指导原则，自然对数 2 给出 0.693。所以 69.3 的规则会更准确，但是 72 更容易计算。
投资翻三倍也有 114 法则，投资翻四倍也有 144 法则。
额外资源
我发现亚瑟·本杰明的两本书在这个话题上很有帮助。这篇博客中的许多例子都是受这些书的启发。你可以在这里查阅。
https://www.amazon.com/Magic-Math-Solving-Figuring-Out/dp/0465096212/
https://www . Amazon . com/Secrets-Mental-Math-Math magicians-Calculation/DP/0307338401/
如果您觉得这有帮助，请留下评论，或者分享您遇到的任何其他有用的技巧。
我最喜欢的 12 个 Python 实践，以获得更好的功能
编写糟糕的函数很容易，但编写示例性的函数就难多了——下面是我改进自己的一些方法
(src =https://unsplash.com/photos/vc3iVL_znJ8
介绍
W 写代码可能是一件非常困难和具有挑战性的工作。当一些问题很难解决，并且有多个解决方案时，尤其如此。保持你的代码处于最佳、完美的状态并不总是容易的。尤其是当一个问题有多种解决方案时，有些是错的，有些是对的。当你听到你的教授说“永远不要这样做”，这是一个记忆深刻的教训。你编程时一直在做的事情。
也就是说，虽然编程可能很难，但最终用高级语言编程的概念非常简单。虽然事情经常会妨碍这种简单性，但是有一些基本的方法可以用来改进代码。本文将更多地针对编写函数的过程，以及一些让函数更好、让你的代码更好的有趣方法。然而，如果你想学习一些重构方法来改进已经写好的代码，我有一篇很棒的文章推荐给你:
</5-fabulous-refactoring-methods-for-prettier-code-e3bc3447c0b2> [## 更漂亮的代码的 5 个惊人的重构方法
towardsdatascience.com](/5-fabulous-refactoring-methods-for-prettier-code-e3bc3447c0b2)
还有一件事，这篇文章实际上有一个笔记本，如果他们想看这篇文章中的例子，可以浏览一下。您可以在 Github 上找到该笔记本:
https://github.com/emmettgb/Emmetts-DS-NoteBooks/blob/master/Python3/Better Function practices.ipynb
№1:输入/输出
编写函数的第一个技巧是后退一步。考虑你的函数实际上做什么。最终，一个功能的命运是回归，或者改变某些东西。在这种情况下，我们应该问的问题是
“去那里需要什么？”
没有一个明确的方向，一个函数写起来就没有意义。首先问我们需要从函数中得到什么？这是我们的产出。接下来，为了得到这个结果，我们需要在函数中输入什么？最后，我们在中间填入算术。在某些情况下，用 return 开始函数可能更有价值。虽然下面的例子相对简单，但它肯定可以用一种非常基本的方式来演示这个概念。让我们写一个函数来计算平均值。
首先，让我们确定我们的输出。在这种情况下，我们当然希望计算平均值作为回报。像这样的数据通常存储在一个向量中，或者 Python 中的一个列表中，所以我们可以假设这是我们的输入:
def mean(x : list): return(mu)
现在我们如何从列表中得到平均值？只需填写空白并返回正确的值:
def mean(x : list): mu = sum(x) / len(x) return(mu)
№2:提取
另一种我可以肯定的编写函数的方法是抽取。提取是清理代码的重要组成部分。提取只是简单地创建更多的方法，以便在一个函数中处理多种事情，而不是让所述函数成为我们需要的不同值的寻宝游戏。相反，我们编写一个函数来获取这些值。函数应该简单并且有简短的指令。这使得代码更好，就像我过去说过的，更多的方法意味着更好的代码！如果你想读一整篇关于提取的文章，我有一篇我很喜欢写的文章，你可以在这里读:
[## 更多的方法意味着更好的代码
towardsdatascience.com](/more-methods-means-better-code-1d3b237f6cf2)
在展示一个简化的 Python 示例之前，让我们看一个真实世界中我的一个函数的 Julian 示例，以便了解我是如何使用这种技术的:
function OddFrame(file_path::String)# Labels/Columnsextensions = Dict("csv" => read_csv)extension = split(file_path, '.')[2]labels, columns = extensions[extension](file_path)length_check(columns)name_check(labels)types, columns = read_types(columns)# Coldatacoldata = generate_coldata(columns, types)# Head"""dox"""head(x::Int64) = _head(labels, columns, coldata, x)head() = _head(labels, columns, coldata, 5)# Dropdrop(x) = _drop(x, columns)drop(x::Symbol) = _drop(x, labels, columns, coldata)drop(x::String) = _drop(Symbol(x), labels, columns, coldata)dropna() = _dropna(columns)dtype(x::Symbol) = typeof(coldata[findall(x->x == x,labels)[1]][1])dtype(x::Symbol, y::Type) = _dtype(columns[findall(x->x == x,labels)[1]], y)# typeself = new(labels, columns, coldata, head, drop, dropna, dtype);select!(self)return(self);end
关于这个函数，您可能会注意到，任何不能在少于三行内完成的事情都会被提取出来。如果所有这些函数都写在同一个函数中，那么它会非常长。此外，几乎不可能一步一步地跟踪所有正在发生的事情。人们可能遇到的另一个重要问题是堆栈跟踪。如果一个 bug 包含在一个一英里长的函数中，那么堆栈跟踪这个 bug 将会更加困难。每当我们收到一个堆栈跟踪，我们得到每个函数，从一个错误发生的地方出来。记住这一点，我们可以看到每个函数中发生错误的确切调用。
我明白；Julian 的例子有点过了，尤其是对于那些编写 Python 的人来说。让我们创建一个规范化函数(不，不是一个类)，它将以一种简单得多的方式利用提取方法，以便使这个概念更容易理解。旁注，当然这些函数在我们可以导入的库中都是可用的，但是这当然不是重点——这仅仅是一个实现你自己函数的例子。
from numpy import sqrtdef norm(x : list): mu = sum(x) / len(x) x2 = [(i-mu) ** 2 for i in x] m = sum(x2) / len(x2) std = sqrt(m) return([(i - mu) / std for i in x])
让我们从第一行开始。假设这个包正在计算这个数据的标准，我们可以假设这个包是面向统计的。也就是说，我们可能不仅仅在这个函数中使用均值。尽管这是一行操作，但我们可能会更多地使用它——同样，最好是尽可能少地在这样的主函数中进行操作，并且主要调用其他函数。当然，这并不是一个可怕的例子，但让我们看看接下来会发生什么。
接下来，我们开始计算 x，这是 x 中 xbar 的 xbar，我们看到这只是一个我们需要的值，以便在函数的后面得到我们的标准差。在我们得到这个值之后，我们写出算法——并重复相同的精确代码——以便计算平均值。最后，我们得到标准差，然后返回正态分布的数据。这种方法最有可能使用一些提取。我们将调用一个方法来调用它，而不是将整个标准差的算法放在这个函数中。我们也将为 mean 做同样的事情，它将共同努力把这个函数减少到只有区区三行。
def mean(x : list): return(sum(x) / len(x))def std(x : list): mu = sum(x) / len(x) x2 = [(i-mu) ** 2 for i in x] m = sum(x2) / len(x2) return(sqrt(m))def betternorm(x : list): mu = mean(x) st = std(x) return([(i - mu) / st for i in x])
这个版本唯一的缺点是平均值被计算了两次，一次在 scope 或 betternorm()内，一次在 std()的范围内。肯定有一种方法可以解决这个问题——但是尽管有一个折衷——这是一个很小的性能代价，这将是一个对任何人来说都更容易接受的代码。
№3:命名
一个经常被忽视的函数的重要性是函数的名字。名字很重要，因为在大多数情况下，它们应该告诉你函数的输出。例如，我的函数 mean 的输出。从那以后，文档字符串仅仅用于确定输入应该如何格式化，以及我们可以期望在所述输入中传递哪种类型。例如，让我们说下面的函数让“Jerry”吃了一个泡菜:
def pickle(n_pickles : int):
pass
函数名“pickle”不是很具体。这一点很重要，因为在工作环境中，你可能会和其他人一起工作。谁知道谁用这种方法得到了这个泡菜？相反，该方法应该命名为类似
def jerry_eat_pickle(n_pickles : int):
pass
当然，这仅仅是一个例子，一个愚蠢的例子——但是我认为这一点非常明显。函数需要用方便的名字命名。我甚至会说，让人们能够猜出你的函数叫什么是很好的。例如，你想合并到熊猫词典，在你的脑海中你使用这个词。这样做的函数不叫 mer()或 m()。这很有意义，只需要一秒钟。这场名称之争的另一个方面是遵循惯例，Python 使用所有小写的方法名——你不希望在你的工作中使用大写字母。大写的别名是为类型保留的。
命名的另一个方面也是命名一个人的功能的特定部分。在我的 Julia 使用提取方法的例子中，你可以看到没有过度注释——这是我最讨厌的地方之一。当然，如果你试图一步一步地解释某事是一回事，但是像
# multiply 5 by x
5 * x
真磨我齿轮！总之，我给函数的这些部分贴上了标签，因为它们都是为返回服务的，在这个例子中是一个类型。这并不是说你需要为你的函数的每一部分留一个注释，尽管这是有帮助的——例如，有人在我的 OddFrame 类型中的 head 函数上做了一些工作，并且想要改变它被构造成该类型的方式，这对于他们来说是相对容易找到的。也就是说，我认为命名还有一个好处，那就是让程序员把事情组织在一起。这对阅读代码的人来说更好，因为他们一次只需要阅读一件事。
№4:没有重写
正如我之前提到的，重复自己是不好的。当然，在许多情况下，这可以通过提取得到帮助，但是不管怎样，您可能会发现必须一遍又一遍地重写相同代码的情况。这可能会有问题。也就是说，找到某种方式来避免重复编写代码可能是个好主意。
我们不要忘记，模块是加载到内存和/或缓存中的。这意味着每次加载一个模块时，该模块的每个字符都被加载到某种内存中。记住这一点，尽量减少重复是很重要的。这是编写更好的代码的一个很好的方法，这些代码会运行得更好，工作得更好。
№5:少即是优
较少的代码总是优于较多的代码。通常，更少的代码对性能成本也有很大的好处。也就是说，代码越少越容易阅读，这在很多情况下实际上比性能更重要。让我们只考虑我们在这里写的语言是 Python。Python 并不一定因为它的速度而受人尊敬。然而，这种语言以相对简单和初学者友好而闻名。
也就是说，由于数据科学领域目前围绕着 Python，本文也是如此，所以性能可能会受到可读性的影响。即便如此，我认为大多数时候更简洁的解决方案最终会更快。
№6:限制类型
许多初学者在开始开发他们的第一个 Python 模块和函数时犯的一个巨大错误是没有限制参数的类型。有许多令人信服的理由可以解释为什么要限制类型，但是让我们从最基本的开始。考虑以下函数:
def add5(x): return(x + 5)
如果我们要通过它传递一个字符串，我们会得到一个错误，就像这样:
add5("hello")
虽然有些用户可能能够很快分辨出这个错误，并将该字符串更改为整数，但对其他人来说，这可能会令人困惑。鉴于 x 列在最前面，这一点尤其重要。这意味着 throw 认为我们为字符串的加法运算提供了错误的类型，而不是整数。因此，有些人可能读到这里会说“但是我提供的是一个字符串！”当然，我的假设是错误的，但是最终你可以通过两句话的回答来避免整个 Github 问题，只要确保最终用户知道传递一个整数，并且可以更容易地识别它。虽然在 Python 中情况可能不太一样，但在其他语言中(尤其是我唯一的语言 Julia)，设置参数的类型非常重要！
您可能希望设置参数类型的另一个原因是，在类型被传递之前，解释器知道您可能在函数中使用的类型。这对解释器很有帮助，有可能加速你的软件！
№7:文档字符串！
显然，我最喜欢读的东西之一是文档。这是因为我花了将近四分之一的时间做这件事。随着所述文档而来的是文档字符串。文档字符串是绝对重要的——没有它们你根本无法有效地操作。作为一个人，你肯定会忘记事情。你不可能记住分布在 10 个文件中的 10，000 行代码的模块在每个单独的容量中做了什么。
记住，不仅文档字符串对最终用户很重要，对开发者也很重要。当在协作中工作时，这些对于编写一个整个团队可以在你的所有代码中使用的函数是必不可少的。下一次你写函数的时候，不要让函数的头部孤独:
def add5(x: int): return(x + 5)
而是文档！
"""Adds five to an integer"""
def add5(x: int): return(x + 5)
№8:最小嵌套
编程界另一个常见的新手错误是嵌套太多。嵌套是一个术语，每当给定软件内部声明了新的范围级别时，都会用到它。例如，在 Julia 中，我们编写“module”来启动一个模块，这就创建了第一层嵌套。我们的范围不再是全球性的，现在我们在一个更小的范围内运作。我们在这个模块中声明了一个函数，这样就有了另一层。
然而，通常每当程序员在否定的上下文中谈论嵌套时，他们指的是嵌套循环和嵌套条件。每个 for 循环和 conditional 循环分别有自己的作用域，下面是一个嵌套 for 循环的示例:
for i in range(1, 5):
for i in range(1, 3):
print(i)
这个 for 循环现在会在每次调用嵌套它的循环时被调用。不用说，这对我们软件的性能来说是一个难以置信的问题。也就是说，有些时候这是不可避免的——但这是唯一应该使用的时候！这是我的建议，只写一个嵌套的 for 循环
- 样机研究
- 所有其他选择都用尽的解决方案
№9: (Python)装饰者
在我看来，Python 编程语言的一个被低估的部分是使用 Python decorators 完全改变类工作方式的能力。这些都被可笑地低估了！谁会想到仅仅通过在函数的顶部添加一个简单的装饰器就可以完全改变代码的本质或者提高代码的效率和速度呢？！
为了最大限度地利用你的函数和类，在用 Python 编程时，你绝对应该研究一下 decorators！装饰器非常容易使用，并且在各种事情上都非常有效，从提高代码速度到完全改变 Python 语言的范式。我提到过这可以通过一个简单的调用在一行中完成吗？哦，对了，如果你不熟悉 Python 中令人惊叹的装饰者世界，我也碰巧为你提供了一个我最喜欢的装饰者的庞大列表，我喜欢使用:
</10-fabulous-python-decorators-ab674a732871> [## 10 个神话般的 Python 装饰者
towardsdatascience.com](/10-fabulous-python-decorators-ab674a732871)
№10:编写你的评论
我经常看到的一个错误，也是我之前提到过的，就是一些程序员的评论是多么的荒谬。如果你有一个 500 行代码和 500 行注释的代码文件，你可能用错了注释。避免发表明显的言论，例如:
# get parameters
parameters = get_params(data)
首先，我们在这里赋值的变量是命名参数，所以我认为大多数人可能会认为我们得到了参数。其次，即使变量有一个随机的名字，这个函数也叫做 get_params。如果人们不能阅读一个简单的断言，他们可能不会阅读你的代码！在每行代码之间使用注释看起来很难看，这是一种可怕的做法——也不符合 PEP。也就是说，如果你碰巧不知道什么时候注释你的代码或者不注释它——我为 Python 程序员写了一个简短的注释指南，你可以在这里阅读:
№11:使用 lambda！
编写函数的另一个重要技巧是根本不要编写函数。相反，你可以用 lambda 关键字写一个表达式。这将有效地把您的 Python 函数变成一行可以映射到数组的语句。这远远优于——并且比您这样做的典型迭代方法更 Pythonic 化。它非常容易使用，就像这个例子一样，使用我们之前写的均值函数:
mean = lambda x: sum(x) / len(x)
现在我们可以像写出函数一样调用它:
mean([5, 10, 15])10
当然，这个简单的例子仅仅展示了 lambda 是如何被用于单行函数的。当这些表达式与其他函数一起使用时，真正的力量就来了。实际上，我有一整篇关于 lambda 及其用法的文章，以及我喜欢它的原因，如果你感兴趣，可以在这里阅读:
差不多一年前！哇哦。
№12:尽可能避免暴食
在编写 Python 函数时，我的最后一个编程技巧是避免关键字参数。当然，我并不认为关键词论证是不好的，显然我们有这样的理由。它们非常有用，尤其是对于我们用于绘图或机器学习软件的参数。不用说，他们有他们的位置。
然而，我相信我之前的声明。他们有他们的位置！他们的位置不是到处都是！当可以使用位置参数时，它们应该使用！首先，键入关键字参数很烦人…其次，它们确实对性能有很大的影响，当然不应该烦人！也就是说，我并不是在讨伐他们——只是在错误的上下文中使用关键字的论点不是一个好主意！
结论
这些是我的一些方法、过程和建议，帮助我编写更好、更高效、更简洁的 Python 函数。当然，没有一个函数在第一次完成时是完美的，但是使用这些技巧中的一些，你至少可以使你的函数的第一次重现相对地具有示范性！非常感谢你的阅读，我真的希望这些建议中的一些能派上用场，或者给一些你可能做错的事情的想法！如果你也有保持功能简洁的建议，我很乐意在回复中看到它们！谢谢大家！祝您白天或晚上休息愉快，数据管理愉快！
下一次数据科学面试中你必须知道的 12 个统计学概念
自信地赢得下一次数据科学面试
统计学提供了工具和方法来发现数据的结构和有意义的见解，还帮助我们量化隐含的不确定性，因此，拥有良好的统计学基础对任何数据科学家都至关重要。因此，对于任何数据科学面试，我们都会根据我们的统计知识进行测试。
米利安·耶西耶在 Unsplash 上拍摄的照片
在这篇文章中，我整理了 12 个统计学概念，我发现它们对破解面试非常有用。因此，我将在这里回顾这 12 个概念，并解释它们的全部内容。
- 条件概率与贝叶斯定理
对于任意两个事件 A 和 B，P(A|B)表示在事件 B 已经发生的情况下，事件 A 发生的条件概率。条件概率的公式由以下等式给出
继续条件概率的讨论，当新的信息可用时，修正我们对事件的先验概率是一个关键阶段，这就是贝叶斯定理变得有用的地方。下面的数学等式总结了贝叶斯定理。
在这个等式中，A 是一个事件，B 是从数据中获得的经验证据或信息。因此，P(A)是事件 A 的先验概率，P(B)是基于数据证据的事件 B 的概率，P(B|A)被称为可能性。因此，贝叶斯定理根据我们对事件的先验知识给出了事件的概率，并在我们获得新的信息时更新条件概率。
贝叶斯定理的一个非常简单的例子是，假设早晨多云，预测某一天下雨的概率。假设，在六月的某一天下雨的概率是 10%,如果下雨，早上多云的概率是 50%。此外，六月任何一天早晨多云的概率，即 P(云)是 40%，那么应用贝叶斯定理，我们可以得出结论，假定今天早晨多云，今天下雨的概率是:
2。取样技术
如果我们把一组中的所有元素称为总体，那么这个总体的一个子集称为样本。样本中观察值或个体的总数称为样本容量。人口的任何统计常数，例如，人口的任何特征的平均值、方差等描述性度量被称为参数。当基于样本观察值计算时，相同的统计度量将被称为统计量。从总体中选择样本的方法有两种——概率性的和非概率性的。
概率抽样方法
答:简单随机抽样
在简单随机抽样中，每个样本从总体中选取的可能性是相等的。这项技术减少了选择偏差。然而，这种技术的缺点是，我们可能无法根据任何特定的特征来选择样本，这是不常见的。
举例— 简单随机抽样的一个例子是通过抽签从一个 100 人的班级中选出 10 名学生。
b .系统采样
在系统抽样中，样本是在固定的特定时间间隔内收集的。系统抽样的优点是它有助于保持足够的抽样规模。
系统抽样的一个例子是在一家杂货店中选择每 10 个顾客进行顾客满意度调查。
c .分层抽样
在分层抽样中，整个人口被分成不同的小组，也称为具有相似特征的阶层。这种取样的主要目的是从所有在感兴趣的特征中表现出可变性的亚组中获得代表性。。
例如，如果我们有兴趣了解人们对印度任何特定话题的看法，我们可以根据城市、性别和年龄组来划分人口。基于所选特征的这些子群体被称为层，并且层中的每个样本是基于概率抽样方法(例如简单随机抽样)来选择的。
非概率抽样方法
a .方便取样
在方便抽样中，参与者是根据他们的可用性和参与研究的意愿来选择的。然而，这种技术可能会受到志愿者偏见的影响，这可能是所有非概率抽样方法的风险，因为样本是自己选择的，而不是随机挑选的。
b .配额抽样
配额抽样在市场调查中相当流行。在这种情况下，采访者只需根据任何调查/研究所需的配额选择样本。例如，一家智能手机公司可能希望调查某个城市中哪个年龄段的人使用哪个品牌的手机。然后他们申请配额，例如每个年龄组 100 人，例如 21-30 岁、31-40 岁、41-50 岁，或者他们可以进一步根据性别实行配额，例如每个年龄组 50 名男性和 50 名女性。他们将根据获取的难易程度和他们的研究预算来选择样本。然而，如前所述，配额抽样作为一种非概率方法，仍可能存在自愿偏差。
c .有目的的取样
在有目的抽样中，研究人员运用他们对目标人群的专业知识，以非随机方式选择“代表性”样本。有目的的取样无疑是省时、省钱的，但是除了志愿者的偏见之外，这种类型的取样会导致研究者在选择参与者时的判断偏差/错误。
3。概率分布
概率分布对于理解任何数据结构都是至关重要的。主要有两种分布类型——离散分布和连续分布。
答:离散概率分布
这些分布模拟了以离散值作为输出的随机变量的概率。例如，如果 X 是一个离散的随机变量，描述了一次投掷中的人头数，我们可以重复多次投掷，并记录每个可能结果的概率。如果我们用函数的形式来表示它，那么它将被称为“概率质量函数(PMF)”，它定义了离散随机变量 X 取特定值 X 的概率。这种分布的例子有伯努利分布、二项式分布、泊松分布。
**b .连续概率分布:**另一方面，连续概率分布模拟随机变量的概率，这些随机变量可能具有本质上连续的任何可能结果。例如，代表城镇居民体重的随机变量 X 的可能值可以是任何值，如 54.5、47.2、60.3 等。示例可以是正态分布、学生 T 分布、卡方分布、指数分布等。
4。假设检验
我们使用一个假设来对总体参数进行断言或假设。现在，为了在我们收集的样本数据的基础上验证我们的主张，我们创建了两个假设——无效假设和替代假设。
零假设反映了研究者对假设检验结果的中立观点。它基本上陈述了默认情况，例如，在药物功效实验中，无效假设可以是获得药物的患者和获得安慰剂的患者组之间的治愈率没有差异。与零假设完全相反的陈述就是替代假设。替代假设总是挑战零假设。接受或拒绝零假设的决定是基于样本数据做出的。
5。置信水平
继续假设检验的概念，理解什么是置信水平是非常重要的。假设检验中的置信水平是当原假设实际上为真时，不拒绝原假设的概率。它传达了如果我们再次重复这个实验，我们对得到同样的结果有多大的把握。因此，我们构造了一个置信区间，它是由统计推断产生的参数的区间估计。该时间间隔通过以下公式计算:
[基于选定置信水平下样本分布的点估计临界值*样本的标准偏差]
例如，如果我们有一个均值为 60、标准差为 5 的抽样分布，那么 95%的置信区间将在(60–1.96 * 5)即 50.2 和(60 +1.96*5)即 69.8 之间。这里，1.96 是临界值，其来源于这样的事实，即对于正态分布，95%的区域位于 1.96 的标准偏差内
我们永远不可能对统计数据有 100 %的信心，因为我们总会有一些不确定性。因此，在统计研究中，我们通常会遇到 99%、95%或 90%的置信度。
6。p 值和显著性水平
对于任何统计推断研究，我们都需要做出拒绝/接受零假设的决定，该决定是基于随机样本的观察值做出的。然而，我们从总体样本中得出的结论总是有可能是错误的。当零假设实际上为真时，与拒绝零假设相关的误差被称为 I 型误差，当零假设为假时，与接受零假设相关的误差被称为 II 型误差。现在，让我们假设，犯第一类错误的概率是某个数字，α，这是任何研究人员为他的研究设定的重要性水平。5%的α表示当我们拒绝零假设时，我们愿意接受 5%的错误概率。另一方面，p 值是观察到的显著性水平，它给出了当零假设为真时，我们获得与从我们的样本数据计算的结果一样极端的结果的概率。
7。A/B 测试
A/B 测试是对 A 和 B 两组进行的随机实验，用非常简单的语言来说，它是一种比较单个变量的两个变量的方法，以找出在受控环境中哪个变量的表现优于另一个变量。这种技术通常用于提高客户满意度的营销策略。
例如，可以向一家公司总客户群的 30%发送两封具有不同行动号召的营销电子邮件，以测试哪一封的点击率更高。营销团队然后等待几个小时，他们选择向其余 70%的客户发送点击量更多的电子邮件
8。z 检验和 t 检验
在假设检验中，z 检验和 t 检验都非常有用。当样本量较大(即 n ≥ 30)且总体标准差已知时，当我们想要了解两个样本均值是否存在显著差异时，通常会使用 z 检验。另一方面，对于 n >0 的小样本量，t 检验可用于比较两个样本的均值，即使我们不知道总体标准差。t 检验遵循学生的 t 分布，而 z 检验假设样本分布是正态的。在大样本的情况下，Z 检验和 t 检验往往会给出相同的结果，因为对于足够大的样本量，t 分布接近正态分布，Z 得分和 t 得分之间的差异变得可以忽略不计。现在，当我们想要了解样本均值是否与总体均值有显著差异时，可以使用 t 检验来执行单样本 t 检验。因为我们不知道 t 检验中的总体标准差，所以我们使用样本标准差。
9。协方差和相关性之间的差异
协方差度量为我们提供了两个变量之间线性关系的方向。另一方面，相关性给了我们这两个变量之间关系的强度和方向。如果我们思考一下数学公式，我们可以用这两个变量的协方差除以同一个变量的标准差的乘积来计算这两个变量的相关系数。因此，相关值是标准化的。因此，相关系数位于-1 到+1 之间，但是协方差可以位于-∞到+∞之间。
10。线性回归 vs 逻辑回归
当因变量连续时，通常使用线性回归。线性回归的关键假设之一是因变量和自变量之间存在线性关系。另一方面，当因变量是二元时，使用逻辑回归。它通过将数据拟合到 logit 函数中来预测事件发生的概率。对于逻辑回归，我们不需要因变量和自变量之间的线性关系。
线性回归拟合数据中的直线，而逻辑回归拟合数据中的曲线。线性回归假设预测误差为高斯(或正态)分布。然而，基于线性回归的模型的因变量或自变量不需要遵循正态分布。有时，当训练数据有一些异常值或因变量过于倾斜时，模型中产生的误差也可能不符合正态分布。逻辑回归假设因变量呈二项式分布。
11。中心极限定理和大数定律
中心极限定理指出，无论特定变量在总体中的分布如何，当我们从总体中收集样本时，随着样本量的增加，变量均值的采样分布将接近正态分布。中心极限定理在统计学中非常重要，原因有两个:正态性假设对于参数假设检验和估计的精度至关重要。在现实生活中，我们经常会遇到非正态分布。因此，我们可能会担心我们正在进行的假设检验或我们正在得到的参数估计没有给我们准确的结果。然而，如果我们有一个大样本量(> 30)，那么 CLT 允许我们使用测试和估计，即使数据不是正态分布。
另一方面，根据大数定律，随着实验中试验次数的增加，试验的平均结果将最终接近真实的总体平均值。例如，当我们投掷一枚公平的硬币 1000 次时，我们更有可能看到一半的时间正面朝上，而相比之下，同样的硬币只投掷 10 次。
12。最大似然估计(MLE)
最大似然估计涉及通过最大化似然函数来估计参数，以找到最好地解释观察数据的参数。MLE 就是这样一种预测性建模框架，其中模型参数是通过优化问题找到的。这里，似然函数 p(y| θ)描述了给定参数θ时观察数据 y 的似然性。我们通过最大化给我们最大似然值的参数集(θ)来解决优化问题。最大似然估计在处理大数据量时效果很好，并给出了无偏最小方差估计量。
尾注:
感谢阅读！
对统计学有非常深刻的理解是成为成功的数据科学家的先决条件。我希望这篇文章能帮助你准备下一次数据科学面试。我在这里讨论的 12 个概念将为你建立进一步学习的重点领域。
比较了 12 种 Twitter 情感分析算法
12 种情感分析算法在推文分类的准确性上进行了比较。fasText 深度学习系统胜出。
图片:Farknot Architect / iStockPhoto
情感分析用于确定一段文本中的情感是积极的、消极的还是中性的。情感分析是自然语言处理的一种形式，也是自然语言处理技术的一部分，被称为信息提取的 T2。
数据科学家的一项工作是为给定的任务选择最佳算法。通常，最好的方法是尝试许多不同的算法，看看什么效果最好。
在本文中，我将比较十几种使用 Python 编程语言的情感分析技术，包括 Google 和 Amazon 的现成情感分析服务。这些技术的 Python 代码可以在Github 库中找到。
Twitter 情感分析数据源
本文中用于分析的数据集是一组关于消费者对航空公司表现印象的推文。每条推文都被分为正面、负面或中性情绪。12 种情绪分析算法中的每一种都为每条推文计算一种情绪。然后，基于数据集中的情感得分，将计算出的情感评分为正确或不正确。使用的总体衡量标准是准确性或算法正确计算的推文百分比。
情感分析算法
12 种情感分析算法可以分为四类:
- 情感词汇的使用
- 现成的情感分析系统，包括亚马逊理解、谷歌云服务和斯坦福 CoreNLP 系统
- 经典机器学习算法
- 深度学习算法
情感词汇
第一种算法将推文中的每个单词与被标记为积极或消极情绪的单词数据库进行比较。有许多这样的数据库。为了这个分析，我从 Kaggle 下载了一个正面和负面情绪词汇的列表。
在将推文中的单词与正面和负面单词列表进行比较之前，首先需要将推文或评论拆分成一个令牌列表(主要是单词)。这是使用 NLTK 分词器完成的。NLTK 是 Python 语言中比较流行的自然语言处理工具包之一。
然后，每个令牌通过修改或移除令牌的管道(即，一系列代码转换)来运行。流水线中使用的步骤是:
- 转换为小写
- 删除推文中的@提及
- 删除超链接
- 删除缩写(例如，将“不会”转换为“会”和“不”
- 删除标点符号
- 将每个标记转换成它的基本形式，这个过程称为变元化。比如“动”转换为“动”，“脚”转换为“足”。NLTK 中可用的 WordNet Lemmatizer 就是为了这个目的而使用的。这个 lemmatizer 接受一个标记作为输入，不管它是动词、名词还是形容词，这个符号也是由上面提到的单词标记化器产生的。
- 最后，所有像“a”和“the”这样对情感没有贡献的常用词都被删除。这个“停用词”列表是从 NLTK 语料库停用词函数中获得的。
正面和负面列表中的每个单词也通过这条管道，以实现“苹果对苹果”的比较。正面词多于负面词的推文被评为正面。负面词较多的一个被评为负面，如果没有正面/负面词或相同的数字，则被评为中性。
对于推文情感分析，这种方法对推文产生了 46%的准确率。几率准确率 33%。
使用了 15000 多条推文。
使用现成系统的 Twitter 情感分析
第二类算法是现成的系统，不需要对数据进行任何预处理。你提供文本，系统计算情感。我测试了来自谷歌云和亚马逊理解的情感分析服务。
相对于下面讨论的机器学习算法，这些服务有点劣势，因为它们必须适用于所有类型的文本。相比之下，机器学习算法有机会了解是什么使推文不同于评论和其他文本。
在这一部分，我还测试了斯坦福大学的 CoreNLP 情感分析器。这个工具甚至更不利，因为它试图首先分析句子的句法结构。然而，tweets 经常不合语法，所以这个工具表现不好也就不足为奇了。
这些工具都经过了 15000 多条推文的测试。谷歌情绪分析工具表现最好，为 59%，亚马逊情绪分析工具紧随其后，为 58%，斯坦福工具为 47%。谷歌和亚马逊工具的性能比情感词典算法好得多。
使用机器学习算法的推特情感分析
用于情感分析的机器学习算法应该是表现最好的，因为它们有机会根据特定类型的数据(如推文或评论)来定制决策。
然而，机器学习算法需要比情感词典算法或现成算法大得多的数据集。除了 tweets 的测试集，还必须有一组训练数据。
为了创建训练和测试集，我从 3 万条推文开始。然后，使用上面在情感词典算法部分中讨论的流水线，对其中的每一个进行预处理。
一种标准的方法是将这些数据集分成一个训练数据集和一个测试数据集。我将这些数据集分成 70%用于训练，30%用于测试。
然而，积极、消极和中性推文在训练集中的分布远非均匀。积极的推文远远多于消极或中性的推文。这种不平衡的数据可能会导致机器学习系统发现大多数推文都是正面的，并学会依赖对每条推文的正面猜测。
为了解决这个问题，我使用 SMOTE 过采样向训练集添加负面和中性的例子，这样训练集就有大约 12，000 条正面、12，000 条负面和 12，000 条中性的推文。需要注意的是，在进行训练测试分割后进行过采样是非常重要的。如果它是在训练-测试分割之前完成的，那么在训练和测试集中都会有一些例子，这会导致误导性的高精度数字。
机器学习需要的另一个修改是将每条推文中的标记转换为一组可以由机器学习算法分析的特征。有很多方法可以做到这一点，但我选择了使用单词袋(BOW)方法。BOW 方法的特点是 tweets 中最常见的 2000 个单词。所以每条微博有 2000 个特征。每个特征值仅仅是这个词在 tweet 中出现的次数。当然，每条推文的特征向量非常稀疏，即大多数特征的值为零。
然后，我使用 scikit-learn 将这些 BOW 特征输入到几个机器学习算法中，包括:
- 朴素贝叶斯:众所周知，这种算法适用于许多文本分类问题，并且需要相对较少的训练样本。
- 支持向量机:像朴素贝叶斯分类器一样，支持向量分类器也适用于文本分类，并且需要相对较少的训练样本。
- 决策树:决策树通常在学习分类方面做得很好，并且以决策树的形式产生易于解释的结果。
- XGBoost:该算法使用一组不同的决策树，称为随机森林。众所周知，这种方法既快速又能达到很高的精度。然而，它不像简单的决策树那样具有可解释性。
- k-最近邻:该算法通过寻找最接近测试示例的训练示例来工作。
这些 ML 分类器的最高准确度是 XGBoost 和 Naive Bayes，它们都达到了 73%的准确度。线性 SVC 算法以 71%紧随其后。决策树以 63%的比例出现，k 近邻以 38%的比例远远落后。
使用深度学习的推特情感分析
深度学习算法通常优于上一节讨论的更经典的机器学习算法。然而，它们通常需要更多的数据。尽管如此，为了进行比较，我对深度学习算法使用了与上一节中对机器学习算法相同的训练和测试数据。
测试了三个深度学习算法:
- Keras: Keras 是一个简单易用的层，位于 TensorFlow 和其他深度学习框架之上。我使用了一个 3 层顺序网络。我尝试了 10 个、20 个和 50 个历元，尽管在准确性上差别不大。
- fasText: fasText 是一个由脸书 AI 开发的 NLP 库。这是一个开源、免费、轻量级的库，允许用户学习文本表示和文本分类器。它在标准的通用硬件上工作。模型可以缩小尺寸，甚至适合移动设备。在这里，我也使用了 10、20 和 50 个历元，发现在准确性上没有什么不同。
- distill BERT:distill BERT 是著名的 BERT 语言模型的一个更小、更快的版本。预训练的 DistilBERT 系统的最后一层用作逻辑回归分类器的一组特征输入，并遵循本 Google Colab 演示笔记本中使用的基本方案。这也是唯一一个我没有在电脑上运行的算法，因为它太耗费资源了。相反，我在我的 Google Colab Pro 帐户上运行了它。即便如此，我也不得不将数据集中的 tweets 数量限制在 10，000 条以内，以避免耗尽内存。
最快的算法表现最好，准确率为 71%。Keras 和 DistilBERT 网络都获得了 68%的分数。
获胜者
XGBoost 和 Naive Bayes 算法在测试的 12 种 Twitter 情绪分析方法中准确率最高。深度学习系统可能没有足够的数据来实现最佳性能。也就是说，我已经看到 XGBoost 在至少另一场烘焙比赛中胜过深度学习系统。
可能有许多方法可以提高整体性能。如果我有足够的内存来运行完整的数据集，那么 DistilBERT 方法的性能可能会更好。此外，除了使用预训练的特征，人们还可以做进一步的训练，以在 tweet 数据集上微调系统。最后，代替使用 BOW 方法，使用单词嵌入作为特征可能会产生更好的整体准确性。也许这将是未来文章的主题。
圣诞节 12 天的 12 个有用算法
所有数据科学家都应该知道的非常酷的算法
由 freepik 创建的背景向量—www.freepik.com
务必 订阅此处 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
介绍
又到了一年的这个时候了！这一次，不是圣诞节 12 天的 12 个数据科学项目，我想和你们分享 12 个非常酷、非常强大的算法，我们不只是在谈论监督算法。
我们在同一页上，一个算法是一系列用于解决问题的指令。从技术上来说，菜谱是一种算法，但我们将专注于与数据科学相关的算法。
我将更多地关注每个算法背后的逻辑，而不是数学，但我会提供额外的资源以防万一。😃
说到这里，让我们开始吧！
1.基于密度的噪声应用空间聚类
作者创建的图像
这是什么？
DBSCAN，也称为基于密度的带噪声应用程序空间聚类，是一种聚类算法，它通过查找密集聚集在一起的区域(换句话说，具有许多近邻的点)来识别聚类。
DBSCAN 是最好的聚类算法(优于 k-means 聚类或层次聚类),原因如下:
- 它可以自己确定最佳的集群数量
- 它可以发现异常形状的集群，而不仅仅是圆形的
- 它足够健壮，不会受到离群值的影响
更多资源
https://en.wikipedia.org/wiki/DBSCAN https://www.kdnuggets.com/2020/04/dbscan-clustering-algorithm-machine-learning.html
一定要 订阅这里 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
2.TF-IDF
TF-IDF 方程
这是什么？
TF-IDF 代表术语频率-逆文档频率，它用于确定一个词在语料库(文档集合)中作为文档的重要性。
具体而言，给定单词的 TD-IDF 值相对于该单词在文档中出现的次数而增加，并随着语料库中也包含该特定单词的文档数量而减少。这是为了说明一般情况下更常用的单词。
TF-IDF 是自然语言处理和信息检索领域的一种流行技术。
更多资源
https://monkeylearn.com/blog/what-is-tf-idf/ https://www.analyticsvidhya.com/blog/2021/11/how-sklearns-tfidfvectorizer-calculates-tf-idf-values/
3.Apriori 算法
这是什么？
Apriori 算法是一种关联规则算法，最常用于确定项目集中相互关联最紧密的项目组。
举个例子，假设我们有一个顾客在杂货店购物的数据库。Apriori 算法可用于确定哪些商品对或商品组最常一起购买。
主要有两个参数:支持度和信心。支持度指的是物品出现的频率，而置信度表示在一个或多个其他物品被购买的情况下，一个物品被购买的条件概率。
更多资源
https://www.educative.io/edpresso/what-is-the-apriori-algorithm
4.霍尔特-温特斯指数平滑
这是什么？
霍尔特-温特斯指数平滑法，也称为三重指数平滑法，是一种流行的预测技术，用于显示趋势和季节性的时间序列数据。
它被称为三重指数平滑，因为它考虑了数据的水平、数据的趋势和数据的季节性。
这种预测方法相对于其他方法(如 ARIMA)的优势在于:
- 理解和实现起来很简单
- 它相当准确
- 而且它的计算成本很低，也不占用太多资源
更多资源
https://machinelearningmastery.com/exponential-smoothing-for-time-series-forecasting-in-python/
务必 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
5.矩阵分解
这是什么？
矩阵分解算法是一种常用于构建推荐系统的协同过滤算法。
协同过滤背后的思想是基于其他相似用户的兴趣来预测给定用户的兴趣。这被称为基于记忆的方法，但另一种方法是基于模型的方法，其中使用机器学习算法来预测用户对未评级项目的评级。
更多资源
https://developers.google.com/machine-learning/recommendation/collaborative/matrix
6.莱文斯坦距离
作者创建的图像
这是什么？
Levenshtein 距离是一种简单的算法，用于确定两个字符串之间的相似性。
具体来说，它等于将一个单词更改为另一个单词的最小单字符编辑(替换、添加、删除)次数。
例如，“taco”和“eggs”之间的 Levenshtein 距离是 4。“十字”和“纵横字谜”之间的 Levenshtein 距离也是 4。直觉上，这些对排序相同是很奇怪的，这显示了这种算法的局限性。
所以，我推荐的两个更好的字符串相似性算法是 Trigram 和 Jaro-Winkler 算法。
更多资源
https://blog.paperspace.com/implementing-levenshtein-distance-word-autocomplete-autocorrect/
7.页面等级
这是什么？
PageRank 是 Google 创建的一种算法，用于对他们的网页进行搜索结果排名。根据谷歌的说法，“ PageRank 的工作原理是统计一个页面的链接数量和质量，以确定对该网站重要性的粗略估计。潜在的假设是，更重要的网站可能会从其他网站收到更多的链接。
简化公式如下:
对于链接到页面 u 的所有页面，页面 u 的页面排名等于页面 v 的页面排名之和除以来自页面 v 的链接数量
更多资源
https://en.wikipedia.org/wiki/PageRank https://www.link-assistant.com/news/google-pagerank-algorithm.html
8.Dijkstra 算法
作者创建的图像
这是什么？
Dijkstra 算法是一种用于在节点图中寻找从起始顶点(节点)到目标顶点(节点)的最短路径的算法。
Dijkstra 的算法采用贪婪的迭代方法，生成一组信息，其中包括从一个起始顶点到图形中每隔一个顶点的最短路径(见下面的视频)。
Dijkstra 的算法通常用于寻找最短的运输路线，确定最短的石油线路长度，并在一些社交媒体应用程序中使用。
更多资源
https://en.wikipedia.org/wiki/Dijkstra's_algorithm https://stackabuse.com/dijkstras-algorithm-in-python/
务必 订阅此处 千万不要错过另一篇关于数据科学的指南、诀窍和技巧、生活经验等文章！
9.ε-贪婪算法
这是什么？
ε-贪婪算法是解决多臂强盗问题的一种简单方法，该问题代表了探索与开发的两难选择。
这个问题背后的想法是，有 k 个不同的选择，每个选择都有不同的回报，但是你不知道任何一个选择的回报。所以，你从探索不同的选择开始，随着时间的推移，在探索更多的选择和开发报酬最高的选择之间有一个权衡。
使用ε-贪婪算法，在时间的一部分ε中选择一个随机的备选项。其余时间(1-ε)，选择已知最高支出(奖励)的备选项。ε是一个必须设置的参数。
更好的解决方案包括置信上限解决方案和贝叶斯汤普森抽样。
更多资源
https://www.geeksforgeeks.org/epsilon-greedy-algorithm-in-reinforcement-learning/ https://en.wikipedia.org/wiki/Multi-armed_bandit#Optimal_solutions
10.高斯朴素贝叶斯
这是什么？
朴素贝叶斯是一种基于贝叶斯定理的分类最大似然算法。
更具体地说，高斯朴素贝叶斯是一种朴素贝叶斯，它假设连续变量遵循正态分布，并由以下等式表示:
虽然朴素贝叶斯持有非常不切实际的假设，但它速度快，易于实现，并且适用于多类预测。这使得它在实时预测、多类预测、文本分类，甚至补充推荐系统方面很受欢迎。
更多资源
https://scikit-learn.org/stable/modules/naive_bayes.html
11.随机森林分类器
这是什么？
随机森林算法是一种集成学习算法，它涉及创建多个决策树，然后选择每个决策树的所有预测的模式。通过使用投票系统，或“多数获胜”模型，它减少了个别树的可能性误差。结果是一个更准确、更稳健、偏差更小的模型。
作者创建的图像
用这个图像，如果我们创建一个决策树，第三个，它会预测 0。但是通过使用所有四个决策树，预测值将是 1。
更多资源
12.哈里斯角探测器
这是什么？
Harris 角点检测器是一种在计算机视觉算法中用来识别图像中的角点的算子。这对于图像处理和计算机视觉是很重要的，因为已知角点是图像中的重要特征。
基本直觉如下:
作者创建的图像
- 在平坦的区域，任何方向都没有渐变(颜色变化)。
- 在边缘区域，边缘方向没有梯度变化。
- 只有在角区域中，在所有方向上都有梯度变化
因此，在整个图像中使用这种方法来确定图像中的角点在哪里。
更多资源
https://medium.com/data-breach/introduction-to-harris-corner-detector-32a88850b3f6
感谢阅读！
被 确定要 订阅此处 千万不要错过另一篇关于数据科学指南、诀窍和技巧、生活经验等的文章！
不确定接下来要读什么？我为你选了另一篇文章:
还有一个:
特伦斯·申
奥运会 120 年
使用 R flexdashboard、ggplot2 和 plotly 实现数据可视化
布莱恩·特纳在 Unsplash 上的照片
介绍
东京奥运会刚刚结束，我想回顾一下现代奥运会 120 年的历史。现代奥运会是主要的国际体育赛事，包括夏季和冬季体育比赛。创作灵感来自公元前 8 世纪至公元 4 世纪在希腊奥林匹亚举行的古代奥运会。第一届现代奥运会于 1896 年在雅典举行。
数据准备
数据源
数据从这个 kaggle 链接下载:https://www . ka ggle . com/hee soo 37/120-years-of-Olympic-history-sports-and-results。这个数据集是 rgriffin 在 2018 年 5 月创建的。
数据探索
该数据集下有两个 csv 文件。AthleteEvents 包含参加每项赛事的运动员的详细信息。它有运动员的身高、体重、年龄和名字，运动和事件以及结果(赢得的奖牌)。nocRegion 包含三个字母的 NOC 名称和各自的区域。基于以上信息，我得到了如下的实体关系图。
作者图片
数据分析
我决定使用 R flexdashboard 来可视化这个数据集。需要安装和加载几个 R 包。
在 flexdashboard 中，我们可以设计多个页面，每个页面用“=”表示。在每一页下面，我们可以用“-”来标记图表的区域。我决定用三页来显示结果。这三页将是:体育和事件，运动员和国家与奖牌。最终产品可以在这个环节中找到。
1.运动和事件
我想看看夏季和冬季奥运会的运动项目数量的增长。我先准备好数据，命名为 fig_dat1。1906 年被排除在外，因为它通常不被认为是正式的奥运会。我计算每届夏季和冬季奥运会的不同运动和项目。
作者图片
我们可以看到运动项目的数量有了显著的增长。我们还可以确定在 1920 年、1940 年和 1944 年，由于第一次和第二次世界大战，有三届夏季奥运会和两届冬季奥运会缺席。
我还用树状图显示了 2016 年夏季奥运会和 2014 年冬季奥运会每个项目下的赛事数量。我用 tabset 两个在这个区域显示两个图表。
作者图片
2.运动员
我想知道每届奥运会的运动员人数和性别比例。我们可以看到越来越多的运动员，尤其是女运动员参加了奥运会。
作者图片
接下来我想看看每届奥运会上每个国家的运动员人数和金牌数之间的关系。我使用散点图，每个点代表一个 NOC。
作者图片
3.奖章
在这一部分，我想看看哪个国家在每届奥运会上获得最多的金牌。
作者图片
很明显，美国正在主宰夏季奥运会。在 28 届夏季奥运会中，它 17 次蝉联冠军！冬季运动会，俄罗斯相当强。
我希望看到 2016 年夏季奥运会和 2014 年冬季奥运会的奖牌排行榜。
作者图片
作者图片
结论
数据可视化是识别模式和从数据中获取洞察力的非常有效的方式。r 有很多用于数据准备和分析的软件包。GGplot2 是一个非常强大的图表绘制包，在 flexdashboard 模板的帮助下，可以非常方便地构建仪表板并部署到 web。
奥运会 120 年——如何用 R 分析和形象化历史
实践教程
找出哪些国家赢得了最多的奖牌，以及这些国家的参与程度是如何随着时间的推移而变化的
仪表板看到生成的关于奥运会的情节。文末的链接
我最喜欢的季节之一是奥运会到来的季节。许多运动员成为整整一代人的英雄，高举他们国家的名义，更重要的是，为儿童和青年提供了一个伟大的榜样和灵感。
从公元前 776 年到公元 393 年，古代奥运会在希腊的奥林匹亚举行。1503 年后，再次出现。1896 年，第一届现代奥运会在希腊雅典举行。从 1896 年雅典奥运会到 2016 年里约奥运会，所有的奥运会都被称为“现代奥运会”。1894 年，皮埃尔·德·顾拜旦男爵提出了这个想法。
在 1912 年到 1920 年之间，以及 1936 年到 1948 年之间，有两个很长的时期没有任何游戏，分别对应于一战和二战。
也许视觉分析最重要的好处是，它使复杂的数据更容易解释，同时以清晰、简洁和合适的方式呈现出来。这篇文章对 1896 年至 2016 年的奥运会进行了有益的可视化分析。本文旨在通过具体的分析实例，为您提供一个高效、实用、方便的模型。
主要目的是演示如何从构建的系统的可视化表示中获益。在向人们介绍奥运会的同时，用户界面非常重要，而且简单，很容易用 RStudio 制作。
这篇文章的主要问题是:哪些国家最占优势？参与是如何演变的？哪些国家的各个学科奖牌最多？参加奥运会的男女比例是多少？
数据准备
数据特征:事件(夏季和冬季)，体育层面的数据，艺术比赛不包括在运动员数据中(侧重于田径)
在对各种数据集进行广泛研究后，120 年的奥运会正在接受代表性检查。它的数据集有几个优势，包括作为一个跨越 1896 年至 2016 年的大规模数据集。最后但并非最不重要的一点是，奥运会数据集被认为值得从视觉表现的角度进行研究，并提供最佳的用户体验。
此外，这篇文章旨在吸引对奥运会感兴趣的人，并直接回答他们的问题。为了回答这个主要问题，从 Kaggle 中选择了一个数据集，它由两个不同的表组成，运动员事件和事件区域。
要创建可视化效果，您将使用两种不同的数据框。在审查数据集后，决定不删除任何数据，而是使用 dplyr 软件包来操作和修改数据，使其更加适用和真实。
一些特征，比如运动员的年龄、体重和身高，在这些例子中没有实现，但是你可以用这些数据进行你自己的更广泛的分析。
也就是说，您可以开始了，首先，您需要加载将要使用的库，加载数据并进行第一次查看。
# REQUIRED LIBRARIESlibrary("gganimate")
library("data.table")
library("knitr")
library("gridExtra")
library("tidyverse")
library("plotly")# LOAD ATHLETES EVENTS DATAdataOlympics <- read_csv("datasets/athleteEvents.csv", col_types = cols(
ID = col_character(),
Name = col_character(),
Sex = col_factor(levels = c("M","F")),
Age = col_integer(),
Height = col_double(),
Weight = col_double(),
Team = col_character(),
NOC = col_character(),
Games = col_character(),
Year = col_integer(),
Season = col_factor(levels = c("Summer","Winter")),
City = col_character(),
Sport = col_character(),
Event = col_character(),
Medal = col_factor(levels = c("Gold","Silver","Bronze"))
)
)glimpse(dataOlympics)
head(dataOlympics)
您将找到 271116 个观察值，在第一个数据集中有 15 个变量。现在，您将加载第二个数据集，其中包含 NOC(国家奥委会)信息。
# LOAD DATA MATCHING NOCs (NATIONAL OLYMPIC COMMITTEE) WITH COUNTRIESNOCs <- read_csv("datasets/nocRegions.csv", col_types = cols(
NOC = col_character(),
region = col_character()
))
glimpse(NOCs)
head(NOCs)
随着时间的推移，运动员、国家和项目的数量是增加了还是减少了？
这是你可以用第一个数据集中的数据回答的第一个问题。您可以创建一个可视化图形来识别国家和运动员以及事件的参与情况是如何变化的。
# NUMBER OF NATIONS, ATHLETES AND AND EVENTS, WITHOUT ART COMPETITIONSnumbers <- dataOlympics %>%
group_by(Year, Season) %>%
summarize(Nations = length(unique(NOC)), Athletes = length(unique(ID)), Events = length(unique(Event))
)numbers <- numbers %>%
mutate(gap= if(Year<1920) 1 else if(Year>=1920 & Year<=1936) 2 else 3)plotNations <- ggplot(numbers, aes(x=Year, y=Nations, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4")) +
labs(x = " ", y = "Nations",
title="Nations, Athletes and Events",
subtitle = "Olympic Games from 1896 to 2016")
plotAthletes <- ggplot(numbers, aes(x=Year, y=Athletes, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4")) +
xlab("")plotEvents <- ggplot(numbers, aes(x=Year, y=Events, group=interaction(Season,gap), color=Season)) +
geom_point(size=2) +
geom_line() +
scale_color_manual(values=c("chocolate","deepskyblue4"))
grid.arrange( plotNations, plotAthletes, plotEvents, ncol=1)
您将得到如下结果，您可以看到它是如何随着时间的推移而增加的。
120 年的奥运会——如何用 R 分析和可视化历史:绘制国家、运动员和事件随时间的变化
哪个国家获得的奖牌最多？
这是你可以回答的第二个问题，如果能够直观地显示每个国家获得的金牌、银牌和铜牌的比例，那将会很有趣。假设你想进入前 30 名。
# THE TOTAL NUMBER OF MEDALS GIVEN TO EACH TEAMmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" )medalCounts <- medalCounts %>%
mutate (Team = region)medalCounts <- medalCounts %>% select( Medal, Team, Count)# ORDERING TEAM BY TOTAL MEDAL COUNTlevelsTeam <- medalCounts %>%
group_by(Team) %>%
summarize(Total=sum(Count)) %>%
arrange(desc(Total)) %>%
select(Team) %>%
slice(30:1)medalCounts$Team <- factor(medalCounts$Team, levels=levelsTeam$Team)medalCounts <- medalCounts %>% filter(Team != "NA")# PLOT MEDAL COUNTSggplot(medalCounts, aes(x=Team, y=Count, fill=Medal)) +
geom_col() +
coord_flip() +
scale_fill_manual(values=c("gold3","gray64","sienna")) +
labs(x = "Nations", y = "Count",
title="Top 30 - Nations with the most medals won in history",
subtitle = "Olympic Games from 1896 to 2016")
你会得到如下图。你可以看到美国、俄罗斯和德国是领先的国家。你的国家在顶端吗？可悲的是，我来自的国家不是。
奥运会 120 年——如何用 R 分析和可视化历史:描绘历史上获得奖牌最多的国家
哪个国家获得的奖牌最多？—动画剧情
另一个有趣和有吸引力的方法是用动画情节来显示以前获得的奖牌，它可以详细显示每个国家多年来获得的奖牌，假设为此你只需要前 10 名。
# NUMBER OF MEDALS GIVEN TO EACH TEAMmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games, Year) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal, Year) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" )medalCounts <- medalCounts %>%
mutate (Team = region)medalCounts <- medalCounts %>% select( Medal, Team, Count, Year)# ORDERING TEAM BY TOTAL MEDAL COUNTlevelsTeam <- medalCounts %>%
group_by(Team) %>%
summarize(Total=sum(Count)) %>%
arrange(desc(Total)) %>%
select(Team) %>%
slice(10:1)medalCounts$Team <- factor(medalCounts$Team, levels=levelsTeam$Team)medalCounts <- medalCounts %>% filter(Team != "NA")# ANIMATED PLOT MEDAL COUNT
plotMedalsAnim<- ggplot(medalCounts, aes(x=Team, y=Count, fill=Medal)) +
labs(x = "Nations", y = "Count",
title='Top 10 - Comparison over time, nations with the most medals',
subtitle = 'Olympic Games from 1896 to 2016 - Year: {frame_time}') +
transition_time(Year)+
geom_col() +
coord_flip() +
scale_fill_manual(values=c("gold3","gray64","sienna"))
animate(plotMedalsAnim,fps=2)
你将得到一个吸引人的动画情节，如下图所示，如果你想知道你加载 gganimate 库的目的，这里是原因。
奥运会 120 年——如何用 R 分析和可视化历史:历史上获得奖牌最多的国家
查看地图，看看哪些国家赢得了最多的奖牌
另一种直观显示每个国家累积奖牌数量的方法是通过地图。这也将从总体上提供整个地球的视觉概观。
# MAP NATIONS WITH MOST MEDALS WONmedalCounts <- dataOlympics %>% filter(!is.na(Medal))%>%
group_by(NOC, Medal, Event, Games) %>%
summarize(isMedal=1)medalCounts <- medalCounts %>%
group_by(NOC, Medal) %>%
summarize(Count= sum(isMedal))medalCounts <- left_join(medalCounts, NOCs, by= "NOC" ) %>%
select(region, NOC, Medal, Count)medalCounts <- medalCounts %>%
group_by(region) %>%
summarize(Total=sum(Count))data_regions <- medalCounts %>%
left_join(NOCs,by="region") %>%
filter(!is.na(region))earth <- map_data("world")earth <- left_join(earth, data_regions, by="region")# PLOT MAPplotMapMedals <- ggplot(earth, aes(x = long, y = lat, group = group)) +
geom_polygon(aes(fill = Total, label= region)) +
labs(x = "", y = "",
title="Map of nations with the most medals won",
subtitle = "Olympic Games from 1896 to 2016") +
guides(fill=guide_colourbar(title="medals")) +
scale_fill_gradient(low="white",high="gold3")
plotMapMedalsggplotly(plotMapMedals)
然后你会看到一张类似下图的地图，在那里你可以看到那些直到 2016 年里约奥运会还没有获得一枚奖牌的国家，比如洪都拉斯、玻利维亚和阿尔巴尼亚。希望 2020 年东京奥运会对这些国家来说是一个很好的机会。
奥运会 120 年——如何用 R 分析和可视化历史:历史上获得奖牌最多的国家地图
一段时间内男女运动员的参与情况
我们知道，很长一段时间以来，不幸的是纵观历史，人类在许多方面大多是性别歧视的，奥运会运动员中包括女性也不例外。你可以看看在这次全球活动中包容性是如何增加或减少的。为了更吸引人，你可以创造另一个动画情节。
# PARTICIPATION OF MALE AND FEMALE ATHLETES OVER TIME, WITHOUT ART COPETITIONSdataOlympics <- dataOlympics %>%
filter(Sport != "Art Competitions")# AFTER 1992, CHANGE THE YEAR OF THE WINTER GAMES TO COINCIDE WITH THE NEXT SUMMER GAMES. THE TERM "YEAR" CURRENTLY REFERS TO THE OLYMPICS TOOK PLACEoriginal <- c(1994,1998,2002,2006,2010,2014)new <- c(1996,2000,2004,2008,2012,2016)for (i in 1:length(original)) {
dataOlympics$Year <- gsub(original[i], new[i], dataOlympics$Year)
}dataOlympics$Year <- as.integer(dataOlympics$Year)# COUNT NUMBER OF ATHLETES BY SEX AND YEARcountsSex <- dataOlympics %>%
group_by(Year, Sex) %>%
summarize(Athletes = length(unique(ID)))countsSex$Year <- as.integer(countsSex$Year)# PLOT MALE AND FEMALE ATHLETES OVER TIMEggplot(countsSex, aes(x=Year, y=Athletes, group=Sex, color=Sex)) +
geom_point(size=2) +
geom_line() +
transition_reveal(Year)+
scale_color_manual(values=c("deepskyblue4","red4")) +
labs(x = "Year", y = "Athletes",
title="Male and Female athletes over time",
subtitle = "Olympic Games from 1896 to 2016")
正如你所看到的，女性参加比赛的人数明显增加，然而，男性仍然占主导地位，尽管今天这种差异没有以前那么大。
奥运会 120 年——如何用 R 分析和可视化历史:男女运动员随时间的情节参与
现在你知道了如何处理数据，我邀请你继续用获得的信息进行你自己的分析，并回答许多其他有趣的问题。
非常感谢您的善意阅读。和我的大部分文章一样，我在一个 flexdashboard 中分享了用plotely生成的情节，我把它放在一起更美观一点:【https://rpubs.com/cosmoduende/olympic-games】T4
在这里你可以找到完整的代码:https://github.com/cosmoduende/r-olympic-games
感谢你坚持到最后，祝你分析非常愉快，可以把一切都付诸实践，对结果感到惊讶，和我一样开心！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
