如何更好的做岭回归
优化和机器学习
使用优化器来寻找性能最佳的正则化矩阵
Photo by Massimiliano Morosinotto on Unsplash
让 X 和 y 表示训练数据的样本，其中 X 是具有 n 行特征向量的矩阵，而 y 是 n 个对应目标值的向量。如果**𝐱′**是具有未知目标值 y’的样本外特征向量，那么我们可以拟合线性模型 b̂ ，目标是最小化预期样本外误差
一种拟合模型的方法，最小二乘法，选择 b̂ 来最小化训练数据的误差平方和
虽然在给定足够的训练数据的情况下，这可能是一个很好的选择，但如果训练数据较少、噪声较多或预测器较弱的特征较多，它可能会过度拟合数据，从而使 b̂ 更多地反映噪声，而不是潜在的统计关系。
岭回归修正了最小二乘法以最小化
利用合适的矩阵γ，岭回归可以收缩或者限制 b̂ 的系数，以减少过拟合并提高样本外预测的性能。挑战在于正确选择γ。
通常，γ仅限于形式
并且通过在训练数据的交叉验证上试验不同的值并挑选具有最佳分数的值来选择α。我会参考这个，或者其他类似这样的选择γ、的方法作为微调。调整的缺点是会导致额外的计算，并且除了最简单的γ的参数化之外，不能扩展到任何参数化。例如，如果我们希望每个变量都有一个单独的正则项
我们有很多变量，通过调整来设置γ是不可能的。
在这篇博文中，我将展示如何将某些交叉验证的性能最大化γ设置为适当的优化问题，其中我们计算一阶、二阶导数，并在优化器的帮助下有效地迭代到最佳性能参数。这将允许我们扩展到具有许多变量的参数化，并且经常会导致比调整方法更好的结果。
留一交叉验证
让
表示移除第 I 个条目的特征矩阵和目标向量
表示适合这些数据的回归量。我们将留一交叉验证 (LOOCV)定义为
并且使用有效的优化器来寻求相对于γ最小化该值。优化器通过对函数的导数进行局部逼近来工作。他们使用近似来采取连续的步骤来改进目标，直到达到局部最优。但是在我们计算 LOOCV 的导数以提供给优化器之前，我们需要为目标导出一个更易处理的形式。
观察
放
那么对于任何一个 z
使用
因此，我们可以将岭回归方程改写为
因为 z 和 y 不依赖于 b ，并且 A 是正定，因此当
因此，
像这样为每个条目求解岭回归仍然是昂贵的，但幸运的是，我们可以进一步操纵方程来实现更有效的东西。注意到
根据谢尔曼-莫里森公式，我们有
因此，
放
然后自从
我们可以将第 I 个留一岭回归解改写为
将此代入 LOOCV 的第 I 项，我们得到
LOOCV 变成了
计算 LOOCV 梯度
我们可以用上一节的公式来推导导数的方程。设 α 表示γ的参数向量，定义 L( α )为给定参数的 LOOCV，其中 L _i 表示 LOOCV 求和的第 I 项。我假设γ由对角矩阵参数化
尽管这些方程可以容易地适用于其他参数化和单变量参数化
可以简单地计算为多变量偏导数的和。
放
那么第 I 个 LOOCV 项的导数就是
和
对于 ŷ 的偏导数，我们有
注意:在这里，我们已经利用这个公式来微分一个逆矩阵
同样，我们可以计算出 h 的偏导数
结合各项并求和，则全微分为
有了导数和值的有效公式，我们可以从任何初始猜测开始，使用优化程序，快速下降到最小化 LOOCV 的参数。
注意:为优化者提供 LOOCV 二阶导数的 hessian 矩阵也是有益的。这些方程更复杂，这篇博文只导出了一阶导数，但是它们可以用类似于梯度的方式计算。
模拟结果
让我们比较一下使用单个正则项的岭回归和对每个回归变量使用单独正则项的岭回归的性能。
我将使用模拟
对于模拟的每次试验，模型将适合于生成的具有独立同分布随机变量的 n×3 特征矩阵的训练数据，其中
目标值将由以下各项生成
随着
试验的结果就是预测误差
在样本外数据点𝐱′上，从与训练数据相同的分布中生成y′。误差是多次试运行的平均值，训练大小 n 是 varied⁴.比较的三个模型是
- LS :最小二乘回归
- RR-1 :单正则化的岭回归，由二阶优化器拟合，以最小化训练数据上的 LOOCV 误差。
- RR-p :针对每个特征变量使用单独正则化器的岭回归，由二阶优化器拟合，以最小化训练数据上的 LOOCV 误差。
下图显示了每个 n 值的模型平均预测误差，以及代表平均值 95%置信区间的误差条(使用 t 统计)。
虽然结果对模拟参数敏感，但这表明，至少对于某些问题，单独的正则化子可以提供比单个正则化子更好的性能。
结论
我们展示了如何有效地计算岭回归的 LOOCV，并推导出其导数的方程。这允许我们使用优化器来找到最小化 LOOCV 误差的正则化参数。优化器消除了挑选和试验不同参数的工作；但最重要的是，它打开了使用正则化矩阵的更复杂的多变量参数化的大门。我们展示了一个这样的多变量参数化(对每个特征变量使用单独的正则化)如何在测试问题上产生更好的性能。
在下一期 文章 中，我将解释为什么留一法通常不是交叉验证的正确形式，并介绍我们应该使用的广义交叉验证。我还将在一个现实世界的问题上比较不同岭回归方法的性能。
如果您对自动调整正则化参数或使用多个正则化子感兴趣，请查看building block . ai。**
脚注
[1]: sklearn.linear_model。RidgeCV (同样 sklearn.model_selection。例如，GridSearchCV )通过强力计算预先选择的参数列表的交叉验证，以找到得分最高的参数。
[2]:另请参见https://github . com/rn burn/ridge-regression-doc/blob/master/notebooks/loo cv-verify . ipynb以验证 loocv 方程
[3]:像这样推导导数方程很容易出错，但幸运的是，使用有限差分进行测试也很容易。参见https://github . com/rn burn/ridge-regression-doc/blob/master/notebooks/loo cv-gradient-verify . ipynb
[4]:完整模拟可作为笔记本:https://github . com/rn burn/ridge-regression-doc/blob/master/notebooks/loo cv-simulation . ipynb
用十行代码实现 BERT 和 Tensorflow 文本分类
免费试用 Google Colab 上最先进的语言建模技术！
需求
我们都知道 BERT 是一个引人注目的语言模型，已经被应用于各种下游任务，如情感分析和问答 (QA)。在某些方面，它超越了人类！
有没有在文本二元分类上尝试过？
老实说，直到最近，我的答案仍然是不。
为什么不呢？
因为 BERT 官方 GitHub repo 上的示例代码不太用户友好。
首先，我想要一个 IPython 笔记本，而不是 Python 脚本文件，因为我想在运行代码块时获得即时反馈。当然，谷歌 Colab 笔记本会更好，因为我可以通过免费的 GPU/TPU 立即使用代码。
其次，除了我在乎的人，我不想知道细节。我想控制有用的参数，比如时期数和批量大小。但是，我需要知道所有的“处理器”、“标志”和日志功能吗？
在我尝试了所有其他友好的框架之后，我是一个被宠坏的机器学习用户。
例如，在 Scikit-learn 中，如果你试图构建一个树分类器，这里(几乎)是你所有的代码。
from sklearn.datasets import load_iris
from sklearn import tree
iris = load_iris()
clf = tree.DecisionTreeClassifier()
clf = clf.fit(iris.data, iris.target)
如果想在 fast.ai 中做图像分类，需要输入这几行。
!git clone https://github.com/wshuyi/demo-image-classification-fastai.git
from fastai.vision import *
path = Path("demo-image-classification-fastai/imgs/")
data = ImageDataBunch.from_folder(path, test='test', size=224)
learn = cnn_learner(data, models.resnet18, metrics=accuracy)
learn.fit_one_cycle(1)
interp = ClassificationInterpretation.from_learner(learn)
interp.plot_top_losses(9, figsize=(8, 8))
你不仅可以得到分类结果，还可以得到激活图。
为什么 Google 开发者不能给我们一个类似的界面来使用 BERT 进行文本分类呢？
周一发现这个 Colab 笔记本。这是预测影评情绪的一个例子。
我非常兴奋，因为我知道伯特现在已经加入了 Tensorflow 中心。
但是打开之后发现，对于一个只关心文本分类应用的用户来说，细节还是太多了。
所以我试着重构代码，我做到了。
然而，原来，笔记本里还有很多代码。
所以我让我的读者帮我打包。很快，华中科技大学计算机科学专业研究生孙岩就这么做了，并把它做成一个 PYPI 包，命名为[bert-text](https://github.com/SunYanCN/bert-text)。
笔记本
请点击这个链接，你会在 github 上看到 IPynb 笔记本文件。
点按“在 Colab 中打开”按钮。Google Colab 会自动打开。
您需要点击“复制到驱动器”按钮，将副本保存到您自己的 Google Drive。
之后你只需要做四件事。
- 安装必要的软件包。
- 准备熊猫数据框格式的数据。我估计对大多数深度学习用户来说很容易。
- 如有必要，调整四个参数。
- 运行笔记本并显示您的结果。
让我们安装bert-text包并加载 API。
!pip install bert-text
from bert_text import run_on_dfs
我的例子是 IMDB 评论的样本数据集。它在训练集中包含 1000 个正样本和 1000 个负样本，而测试集包含 500 个正样本和 500 个负样本。
import pickle!wget https://github.com/wshuyi/info-5731-public/raw/master/imdb-sample.picklewith open("imdb-sample.pickle", 'rb') as f:
train, test = pickle.load(f)
我在 UNT 大学的 INFO 5731 课堂上使用它，让学生比较 textblob 包、单词包模型、带有单词嵌入的简单 LSTM 和 ULMfit 的结果。
现在我终于可以把伯特加入名单了。
您需要运行下面一行来确保训练数据被正确地打乱。
train = train.sample(len(train))
您的数据集应存储在 Pandas 数据框中。应该有一个称为train的训练集和一个称为test的测试集。
它们都应该至少包含两列。一列用于文本，另一列用于二进制标签。强烈建议选择 0 和 1 作为标签值。
现在数据已经准备好了，可以设置参数了。
myparam = {
"DATA_COLUMN": "text",
"LABEL_COLUMN": "sentiment",
"LEARNING_RATE": 2e-5,
"NUM_TRAIN_EPOCHS":10
}
前两个参数只是数据框的列名。您可以相应地更改它们。
第三个参数是学习率。你需要阅读原始论文，以找出如何明智地选择它。或者，您可以使用此默认设置。
最后一个参数是设置希望 BERT 运行多少个时期。我在这里选择 10，因为训练数据集非常小，我不想让它过拟合。
默认情况下，预先训练的语言模型是“bert_uncased_L-12_H-768_A-12”。它已经在英文维基百科和图书语料库上接受了训练。除此之外，现在还有五个选项可供你选择。
bert_multi_cased_L-12_H-768_A-12bert_uncased_L-24_H-1024_A-16bert_cased_L-12_H-768_A-12bert_chinese_L-12_H-768_A-12bert_cased_L-24_H-1024_A-16
如果您想换成另一个预先训练好的模型，比如处理法语或德语的多语言模型，请按如下方式更改myparam设置:
myparam = {
"DATA_COLUMN": "comment",
"LABEL_COLUMN": "sentiment",
"LEARNING_RATE": 2e-5,
"NUM_TRAIN_EPOCHS":3,
"bert_model_hub":"https://tfhub.dev/google/bert_multi_cased_L-12_H-768_A-12/1"
}
汉语是一个特例。您可能需要这样设置myparam:
myparam = {
"DATA_COLUMN": "comment",
"LABEL_COLUMN": "sentiment",
"LEARNING_RATE": 2e-5,
"NUM_TRAIN_EPOCHS":3,
"bert_model_hub":"https://tfhub.dev/google/bert_chinese_L-12_H-768_A-12/1"
}
如果您想看到整个输出(可选)，您应该添加下面两行代码。
import tensorflow as tf
tf.logging.set_verbosity(tf.logging.INFO)
好吧。现在你可以跑伯特了！
result, estimator = run_on_dfs(train, test, **myparam)
警告！这一行花了你一些时间来运行。
完成后，您可以运行最后一行来获得您的分类模型的评估结果(在 BERT 上)。
result
对于这么小的训练集来说，我觉得结果还是挺不错的。
仅此而已。
现在你也可以使用最先进的语言建模技术来训练你的文本二进制分类器！
相关博客
如果你对这篇博客文章感兴趣，你可能也想看看下面几篇:
- 如何用 Google Colab 练习 Python？
- 如何用 Python 和递归神经网络预测严重的交通堵塞？
- 使用 Python 和 fast.ai 进行深度学习，第 1 部分:使用预训练模型进行图像分类
- 使用 Python 和 fast.ai 的深度学习，第 2 部分:使用迁移学习的 NLP 分类
如何制作动画“比赛”条形图
探索英国足球有史以来最好的球队，并学习如何制作其中一个已经变得流行的比赛条形图
在本文中，我们将分析英国足球队自 1888 年联赛开始以来的历史表现，并使用该数据创建一个动画条形图，每年循环显示历史上前十名球队的总积分。我们还将使用标题栏来讲述这项运动在英格兰 130 年间的变化。这是成品，所有代码都在 Github 上:
The abbreviated history of English football
开始之前，让我们明确我们的目标。这是我们想要做的:
- 生成一个动画，循环播放从 1888 年到 2017 年的每个足球赛季，并显示截至该年每支球队的累计总积分，显示排名前 10 的球队。我们将只考虑在英格兰足球顶级联赛(现在被称为英超)中获得的积分。
- 偶尔在图表标题中加入仿真陈述，有助于讲述足球随时间的变化。
在这篇文章中，我不打算把重点放在样式和美观上，只讨论创建动画图形的基本功能。
准备数据
理想情况下，我们需要的是一个数据集，它能告诉我们通过历史获得的联赛积分，但我找不到那个数据集。相反，我发现了更详细、更棒的东西，这是自 1888 年以来每一场比赛的记录，以及结果和分数。我在这里发现它是以 R dataframe 对象的形式存在的——所以我们将在 R 中这样做。这是数据的快速快照。
这个数据集相当大，自 1888 年以来，每一级都有近 200，000 场比赛。首先，我们需要将每场比赛转换为给定球队的积分分配。主队和客队之间的积分分配如下:
- 1981 赛季前冠军得 2 分。从 1981 年赛季开始，为了鼓励更多的进攻，比赛规则发生了变化，获胜者可以获得 3 分。
- 败队得 0 分。
- 如果比赛以平局结束，每人得 1 分。
因此，让我们加载我们的数据，并加载我们的tidyverse包进行标准的数据操作。我们将使用result列分配主场和客场积分，通过使用dplyr::mutate()创建两个新列，如下所示:
library(tidyverse)load("data/england.rda")# assign points to results (2 pts for a win up to 1980-81 season then 3 pts for a win afterwards)england <- england %>%
dplyr::mutate(
homepts = dplyr::case_when(
Season <= 1980 & result == "H" ~ 2,
Season > 1980 & result == "H" ~ 3,
result == "D" ~ 1,
result == "A" ~ 0
),
awaypts = dplyr::case_when(
Season <= 1980 & result == "A" ~ 2,
Season > 1980 & result == "A" ~ 3,
result == "D" ~ 1,
result == "H" ~ 0
)
)
现在我们已经为每场比赛分配了积分，我们需要得到每支球队和每个赛季的主场和客场总积分，记住我们只对顶级比赛感兴趣:
# restrict to Tier 1 and assemble into total points per seasonhome_pts <- england %>%
dplyr::filter(tier == 1) %>%
dplyr::group_by(Season, home) %>%
dplyr::summarize(pts = sum(homepts))away_pts <- england %>%
dplyr::filter(tier == 1) %>%
dplyr::group_by(Season, visitor) %>%
dplyr::summarize(pts = sum(awaypts))
现在，我们可以将这两个数据框架绑定在一起，将主客场积分相加，得出每个赛季每个球队的总积分:
total_pts <- home_pts %>%
dplyr::rename(Team = home) %>%
dplyr::bind_rows(
away_pts %>%
dplyr::rename(Team = visitor)
) %>%
dplyr::group_by(Season, Team) %>%
dplyr::summarise(pts = sum(pts))
现在我们有了一个数据框架，显示了每支球队在每个赛季获得的积分。我们想操纵这一点，以便每个赛季显示我们所有积分的总和，包括该赛季。我们可以通过一个快速的for循环来实现这一点:
# create rolling sumstable <- total_pts %>%
dplyr::filter(Season == 1888) %>%
dplyr::select(Season, Team, Points = pts)for (i in 1889:2017) {
table <- total_pts %>%
dplyr::filter(Season <= i) %>%
dplyr::group_by(Team) %>%
dplyr::summarise(Points = sum(pts, na.rm = TRUE)) %>%
dplyr::mutate(Season = i) %>%
dplyr::bind_rows(table)
}
我们已经做了足够的工作来获得目标 1 所需的数据。对于目标 2，我将编辑Season栏，加入一些关于英格兰足球联赛的重要史实。我会让每个事实显示大约三季，让它在动画中出现足够长的时间，让观众阅读。让我们称这个新编辑的专栏为SeasonLabel。
# add some historic facts to seasonstable <- table %>%
dplyr::mutate(
SeasonLabel = dplyr::case_when(
Season <= 1891 ~ paste(Season, "Football League is formed with 12 teams in 1888", sep = " - "),
dplyr::between(Season, 1892, 1895) ~ paste(Season, "Second Division introduced in 1892", sep = " - "),
dplyr::between(Season, 1914, 1918) ~ paste(Season, "League suspended during World War I", sep = " - "),
dplyr::between(Season, 1920, 1924) ~ paste(Season, "Third Division North/South introduced in 1920/21", sep = " - "),
dplyr::between(Season, 1925, 1928) ~ paste(Season, "New Offside Law introduced in 1925", sep = " - "),
dplyr::between(Season, 1939, 1945) ~ paste(Season, "League suspended during World War II", sep = " - "),
dplyr::between(Season, 1958, 1961) ~ paste(Season, "Regional Third Divisions amalgamated in 1958 to form Nationwide Third and Fourth Divisions", sep = " - "),
dplyr::between(Season, 1965, 1968) ~ paste(Season, "Substitutes first allowed in 1965", sep = " - "),
dplyr::between(Season, 1974, 1977) ~ paste(Season, "First match played on a Sunday in 1974", sep = " - "),
dplyr::between(Season, 1981, 1984) ~ paste(Season, "Three points for a win introduced in 1981", sep = " - "),
dplyr::between(Season, 1986, 1989) ~ paste(Season, "Play-offs introduced to decide some promotions", sep = " - "),
dplyr::between(Season, 1992, 1995) ~ paste(Season, "Premier League formed in 1992, reducing Football League to three divisions", sep = " - "),
dplyr::between(Season, 2004, 2007) ~ paste(Season, "Football League renames divisions in 2004 to Championship, League One and League Two", sep = " - "),
dplyr::between(Season, 2013, 2016) ~ paste(Season, "Goal Line Technology introduced in Premier League in 2013", sep = " - "),
1L == 1L ~ as.character(Season)
)
)
现在让我们来看看我们的数据:
现在我们有了编码动画所需的一切。让我们使用save(table, 'data/table.RData')保存我们的数据集，这样我们就可以在一个新文件中打开它，我们将使用它来创建动画。
创建动画
在这个 StackOverflow 讨论的帮助下，我们将使用ggplot2包为这些数据设计一个静态条形图，然后我们将使用 awesome 包gganimate生成一个滚动动画，该动画通过每个SeasonLabel进行过渡并更新条形图。
让我们加载数据和一些我们需要的包。然后，首先，我们需要对每个赛季的每个球队进行排名，因为排名将决定柱线在“比赛”图中出现的顺序。我们还为每个团队创建了一个相对于排名靠前的团队的相对值，因为这将有助于衡量标准。最后，我们创建一个标签来从Points列中提取值。然后我们限制排名前 10 的队伍。
library(tidyverse)
library(ggplot2)
library(gganimate)
library(gifski)
ggplot2::theme_set(theme_classic())load("data/table.Rdata")# generate top n ranking by year groupanim_table <- table %>%
dplyr::group_by(Season) %>%
dplyr::mutate(
rank = min_rank(-Points) * 1,
Value_rel = Points / Points[rank == 1],
Value_lbl = paste0(" ", Points)
) %>%
dplyr::filter(rank <= 10) %>%
dplyr::ungroup()
现在我们已经拥有了绘制静态条形图所需的一切——这只需要一串相当基本的ggplot2命令。我不会详细讨论这些，但是如果你需要重新熟悉这些，我推荐你从 tidyverse.org 开始。这里的要点是，我们使用rank作为 x 美学，Points作为 y 美学，然后我们分配Team和Points，然后我们翻转图表，使其水平而不是垂直。
# create static bar chartp <- ggplot2::ggplot(anim_table, aes(rank)) +
ggplot2::geom_tile(aes(
y = Points / 2,
height = Points,
width = 0.9,
fill = "blue"
), alpha = 0.8, color = NA) +
ggplot2::geom_text(aes(y = 0, label = paste(Team, " ")), size = 12, vjust = 0.2, hjust = 1) +
ggplot2::geom_text(aes(y = Points, label = Value_lbl, hjust = 0)) +
ggplot2::coord_flip(clip = "off", expand = FALSE) +
ggplot2::scale_y_continuous(labels = scales::comma) +
ggplot2::scale_x_reverse() +
ggplot2::guides(color = FALSE, fill = FALSE)
现在是动画的主要部分。我们给静态图的标题和轴加了标签，但其中一个标签是我们将用来给图加动画的标签——即SeasonLabel.这被称为过渡变量。所以我们告诉ggplot2我们希望标题打印当前的过渡状态——即SeasonLabel在动画中旋转时作为标题。最后，我们使用ease_aes()来定义值在转换过程中的变化方式——这里有许多您可以尝试的缓和函数，详情请参考帮助文件。
# set SeasonLabel as transition state and set to animatep <- ggplot2::labs(p,
title = "{closest_state}", x = "", y = "Total Points",
caption = "Source: Github(jalapic/engsoccerdata) | Top tier points only, does not include mandatory points deductions | Plot generated by [@dr_keithmcnulty](http://twitter.com/dr_keithmcnulty)"
) +
ggplot2::theme(
plot.title = element_text(color = "darkblue", face = "bold", hjust = 0, size = 30),
axis.ticks.y = element_blank(),
axis.text.y = element_blank(),
plot.margin = margin(2, 2, 1, 16, "cm")
) +
gganimate::transition_states(SeasonLabel, transition_length = 4, state_length = 1) +
gganimate::ease_aes("cubic-in-out")
所以我们的动画情节现在作为对象p保存在环境中。我们现在需要做的就是把它作为一个输出文件。有许多设备可用于以各种格式呈现输出，但最常用的有:
gif输出——产生一个动画图像文件。这需要安装gifski包。mp4视频输出——这需要在您的机器上安装ffmpeg。
在我的例子中，我将按照之前显示的图像创建一个gif。您可以通过使用duration参数来调整 gif 的速度，也可以定制图像的大小和分辨率。
# save as preferred rendered formatgganimate::animate(p, nframes = 200, fps = 5, duration = 100, width = 2000, height = 1200, renderer = gifski_renderer("anim.gif"))
根据您在animate()函数中设置参数的方式，文件可能需要更长时间来渲染，但是您可以在控制台中查看进度。
继续教育
这是一个简短的实际案例研究。它只涵盖了 r 中很小一部分动画的可能性。我鼓励你多读一些关于gganimate的内容，然后尝试用它来制作一些你自己的数据动画。时间序列数据尤其适合制作好的动画。R 中的plotly包也增加了动画功能，值得一看。
最初我是一名纯粹的数学家，后来我成为了一名心理计量学家和数据科学家。我热衷于将所有这些学科的严谨性应用到复杂的人的问题上。我也是一个编码极客和日本 RPG 的超级粉丝。在LinkedIn或Twitter上找我。
如何主宰 MLS 幻想
编写 python 脚本来自动选择最佳 MLS 幻想阵容
Can algorithms really help when selecting a MLS Fantasy lineup?
你好，老朋友
所有非美国读者请注意，请原谅我把这项运动称为“英式足球”而不是“橄榄球”。尽情享受吧！
我在堪萨斯城长大，对和家人一起参加堪萨斯奇才队(现在是堪萨斯城体育队)的比赛有很多美好的回忆。作为一名足球运动员(请注意，不是很好)，我喜欢看我最喜欢的运动员在球场上一决雌雄，无休止地寻找球网的背面。为了在比赛间隙消磨时间，我经常阅读花名册的宣传信息，尽可能地了解我偶像的一切。
随着年龄的增长，我的注意力转移到了海外联赛，但随着美国职业大联盟在过去几年的复苏，我现在渴望回到我小时候喜欢的联赛。
在我退出美国职业棒球大联盟十多年的时间里，体育产业发生了巨大的变化，最大的不同是梦幻体育的引入和主导地位。这些年来，梦幻体育产业的受欢迎程度绝对呈爆炸式增长，并帮助许多粉丝了解了一项新的运动或联盟，鼓励他们在没有理由或欲望的情况下关注比赛。由于梦幻体育的包容性，我决定求助于 MLS Fantasy 来帮助我重新了解球队和明星。作为一个数据呆子，我不会让纯粹的猜测支配我的幻想阵容，而是创建一个算法，为我确定一个最佳阵容。
At the mercy of the laws of the game. Photo by Noelle Otto from Pexels
制定家规
在我们深入研究我使用的算法和我取得的结果之前，我们需要定义 MLS Fantasy 的规则和约束。任何有经验的人都可以跳到下一部分，因为这只是一个回顾。
MLS Fantasy 的基本前提是在每个比赛周创建一个能返还最多积分的阵容。这些分数可以通过在球场上采取积极的行动来获得，例如进球，助攻，扑救，传球等等。对球队产生负面影响的行为也会被扣分，例如乌龙球、防守失误或收到裁判的黄牌或红牌。这些分数是根据他们对比赛的影响来衡量的，所以进球得分比成功传球得分高得多。
所有球队由 2 名守门员、5 名后卫、5 名中场和 3 名前锋组成。首发阵容必须包括 11 名球员，其中 1 名是守门员。MLS Fantasy 支持很多不同的阵型，比如 3–5–2(3 个后卫，5 个中场，2 个前锋)，3–4–3，4–5–1，4–4–2，4–3–3，5–4–1，5–3–2。所有不在首发阵容中的球员都将被指定为替补(稍后会有更多)。
有趣的是，每支 MLS 梦幻球队都有 1 亿美元的比赛周预算来选择球队。每个球员都有一个基于他在联盟中相对表现的价格。例如，在撰写本文时，LAFC 的卡洛斯·贝拉是联盟中最贵的球员，身价 1180 万美元。一般来说，大多数球员的身价在 400 万美元到 1200 万美元之间。要使一个球队有效，名单上所有球员的总成本必须小于或等于 1 亿美元。低于 1 亿美元没有任何惩罚或奖励，所以建议获得一个尽可能接近最大预算的阵容，以优化团队的实力。
除了成本和位置限制之外，球队的最后一个主要限制是每支球队可以选择的球员数量。MLS Fantasy 限制同队球员的数量为 3 名，所以你不能从华盛顿联队选择超过 3 名球员。
替补队员给局面带来了一点麻烦。默认情况下，替补队员不会为你的周总成绩加分，不管他们在比赛中的个人表现如何。然而，如果你的首发球员在一周内一分钟都没有上场，替补就派上用场了。在这种情况下，你的第一个符合条件的替补名单将自动取代没有上场的球员。
一旦阵容确定，当每个玩家的游戏开始时，MLS Fantasy 将锁定你的名单，防止你在比赛开始后改变你的阵容。幻想游戏将跟踪每个玩家的表现，并计算他的分数。一旦某周的所有比赛结束，该队首发球员的所有得分之和就是你的球队的最终得分。这些分数可以与所有其他幻想玩家进行比较，赛季结束时得分最多的球队可以赢得奖品。
When in doubt, code it out! Photo by Clément H on Unsplash
构建算法
既然我们已经知道了 MLS Fantasy 的规则，让我们来讨论一下我们将用来生成最佳阵容的实际算法。由于我们希望在给定预算的情况下找到返回的最大点数，线性规划最大化算法似乎是最佳选择。这种算法让我们能够识别出在我们的限制范围内能够产生最高理论点数回报的玩家。幸运的是，Python 包PuLP让这变得很容易。为了达到我们期望的结果，我们需要采取以下步骤。
从 MLS API 提取数据
首先，我们需要从 MLS API 中提取数据，其中包含所有活跃的 MLS 玩家的信息，如本赛季的总幻想点数，玩家的资格(即。如果一个球员受伤或被禁赛，他就没有资格)，获得该球员的当前价格，以及该球员状态的最近趋势。
根据资格过滤玩家
我们不希望包括任何受伤或停赛的球员，因为他们将在接下来的比赛周因未能参加比赛而给我们带来零分。一些球队偶尔也会有周末，不打比赛。虽然这些球队的球员在 API 中被技术上标记为合格，但我们不想将他们包括在内，因为他们在本周没有机会获得积分。
我们也应该删除那些在当前赛季中没有参加过任何比赛的球员，因为他们还没有被证实，并且可能在本周不会有太多的上场时间。任何属于上述类别之一的球员都应该从我们的名单中过滤掉，因为他们给我们的分数可能是最少的。
根据运动员最近的表现对他们进行分类
为了确定每个玩家产生大量幻想点数的潜力，我们需要根据玩家的总点数对他们进行分类。我选择看球员最近 5 场比赛的平均水平作为他们目前状态的基准。我认为总积分不能显示一个玩家在过去几场比赛中得分是多了还是少了。考虑到这一点，我们将 MLS 中每一个活跃的玩家按照他们在过去 5 场比赛中的平均得分进行排序，第一个玩家的平均得分最高。
按位置分隔玩家
拥有一个单一的球员排序列表并不能给我们带来太多好处，因为我们对每个位置可以包含的球员数量有限制。相反，我们将按照位置(守门员、后卫、中场和前锋)来划分我们的排序列表。由于我们分离了已经排序的列表，每个单独的位置列表仍将根据我们之前的算法进行排序。
设置我们的 LP 最大化模型
现在实际创建我们的模型。给定上面详述的 MLS Fantasy 的规则，我们的模型由以下定义:
- 目标函数:我们希望通过只选择给我们最高回报的玩家来最大化可能的点数。
Goalie1变量是一个二元变量，表示是否应该使用一个特定的守门员(按照我们之前排序的球员名单的顺序)。其他职位也是如此。Goalie1Pts是Goalie1在过去 5 场比赛中的平均得分:
Score = Goalie1Pts * Goalie1 + Goalie2Pts * Goalie2 + ... \
Def1Pts * Defender1 + Def2Pts * Defender2 + ... \
Mid1Pts * Midfielder1 + Mid2Pts * Midfielder + ... \
For1Pts * Forward1 + For2Pts * Forward2 + ...
- 预算约束:接下来，我们需要包括我们的约束。首先是预算限制。默认情况下，我们被允许在我们的阵容上花费 1 亿美元。这个约束可以用下面的等式来表示。
Goalie1Cost是Goalie1的当前成本:
Budget = Goalie1Cost * Goalie1 + Goalie2Cost * Goalie2 + ... \
Def1Cost * Defender1 + Def2Cost * Defender2 + ... \
Mid1Cost * Midfielder1 + Mid2Cost * Midfielder2 + ... \
For1Cost * Forward1 + For2Cost * Forward2 + ...
- 位置约束:最后，我们有位置约束。目前，MLS Fantasy 认为，如果一个名单包括 2 名守门员，5 名后卫，5 名中场球员和 3 名前锋，则该名单符合条件:
Goalie1 + Goalie2 + ... == 2
Defender1 + Defender2 + ... == 5
Midfielder1 + Midfielder2 + ... == 5
Forward1 + Forward2 + ... == 3
运行模型
随着我们的模型的建立和所有约束的添加，是时候求解模型以找到最优解了。通过运行该模型，假设可以达到最优结果，达到最优结果所需的玩家被设置为值 1。
建立花名册
最后，我们需要打印每个位置的建议球员名单。首先，通过检查我们数据集中的每个玩家，我们识别二进制变量的值为 1 的任何玩家，并打印他的名字，因为这个玩家被建议在本周的幻想阵容中使用。
Will this algorithm gain traction on the leaderboard? Photo by Element5 Digital on Unsplash
检查结果
说到底，算法做得怎么样？请记住，由于国际比赛日的原因，在撰写本文时，许多球队和球员都没有参加比赛。考虑到可用的球员，算法选择了一个相当平衡的阵容，卡洛斯·贝拉作为我的队长，其余的球员虽然非常有天赋，在过去几周取得了令人印象深刻的回报，但并不完全是你可能期望的家喻户晓的名字。我还决定换出更便宜的替补球员，希望额外的预算可以为更强大的阵容提供更多的资金。我的完整阵容可以在下图中找到。
MLS Fantasy Lineup Game Week 4
缺少几个高水平球员的一个可能的理由是，当谈到幻想体育时，算法没有大多数人倾向于拥有的任何偏见。作为人类，我们通常选择有设计师名字的球员，这些名字每周都在联盟中闪耀。虽然这是一个聪明的举动，但它在预算中留下了很少的空间来填补阵容，迫使幻想玩家选择较弱的运动员来填补剩余的空缺。另一方面，计算机不关心运动员的遗产，也不关心他每周能得到多少报酬。他们只看到他们被展示的东西，而在我们的情况下，我们只是展示球场上的表现和幻想的价格标签。
说到底，尽管美国职业棒球大联盟因休息而平静了一周，但我的算法最终选择了一支竞争力强的球队，他们以 65 分的总成绩超过了全国 96%的人。它甚至是全国平均水平 31.5 的两倍。虽然我希望该算法将被证明是有用的，但我并不期望第一次迭代执行得如此之好，特别是考虑到我想从这里进行一些改进。
Plotting a course for the algorithm. Photo by Daniil Silantev on Unsplash
我们将何去何从？
由于该算法在第一周表现相对强劲，我计划在本赛季余下的比赛中使用它。由于我错过了游戏的前 3 周，我不指望在春季联赛中爬到排行榜的首位，或任何相对接近它的地方，但我计划利用秋季联赛，看看它在这段时间内表现如何。
由于这只是我使用的算法的第一次迭代，我仍然有很多想法让它更好地向前发展，并计划随着赛季的展开融入这些想法。以下只是其中的一些计划:
- 分析不同的小队队形
- 使用不同的方法来发现一个球员的潜力，而不仅仅是过去的 5 个平均水平
- 比起那些只安排一场比赛的球员，更喜欢一周有两场比赛的球员
- 确定在家或在路上打球的影响
- 更喜欢与排名靠后的球队对抗的球员
- 潜在地使用机器学习来预测玩家的预测得分
在接下来的几个月里，我计划半定期地更新算法的进展，以及它与其他算法相比表现如何。
这个结果是侥幸吗？我运气好吗？还是说国际比赛日给这个等式带来了一个在通常的比赛周不会出现的异常？所有这些问题的答案很可能都是“是”然而，由于 MLS Fantasy 的预算式设置，线性规划最大化算法似乎是为这个游戏量身定制的。
只有时间能证明我的计划会有多成功。对于一个完全基于数字的游戏来说，为什么不应该有一个可以利用这些数字的工具呢？
如何让您的 R&D 团队的生产力翻倍
一点点数学知识可以帮助你走很长的路
1919 年，英国面临大规模饥荒。虽然赢得了战争，但却破产了。几十年来，英国一直是粮食进口国，现在既不能自己生产足够的粮食，也不能从其他国家购买。债台高筑，经济混乱，政治家们希望科学家们能收拾残局。
他们求助于成立于 1843 年的农业研究站 Rothamsted。它的使命过去是(现在也是)使用科学方法来提高农业生产率。到 1919 年，它已经积累了大量的数据。
农业研究既高度复杂又极其缓慢。许多因素都会影响结果，有些在实验者的控制范围之内，有些则不然:天气、土壤、害虫、基因、肥料等等。更糟糕的是，实验既缓慢又昂贵——实验者不能加快季节的转换，而且可以工作的土地有限。
Winter brassica seedlings at Rothamsted Philip White / CC BY-SA 2.0
Rothamsted 的主任约翰·拉塞尔希望新的统计学能有助于加速事情的进展。他雇佣了正在开发遗传统计学的罗纳德·费雪，让他重新分析农作物数据，看看是否能学到更多东西并立即投入使用。
有可能。费希尔开发了一套技术，将从给定实验中提取的信息量增加了一倍，这是一项重大突破。
为了做到这一点，他忽视了科学探究的一条基本规则，这条规则可以追溯到弗朗西斯·培根，被认为是科学方法的关键。所有科学教育级别都教授的规则是:在每个实验中，你努力创造两个只有一个因素不同的场景。做到这一点，你就可以把不同场景之间的结果差异归因于那个因素。
Fisher 展示了如何在一个实验方案中同时分析多个变量。他的方法把噪音变成了数据。不受控制的因素，如天气或土壤，不一定会掩盖来自(例如)作物品种差异的信号。取而代之的是，多元分析提取了这些信号，并额外产生了关于其他因素影响的信息，包括它们之间的相互影响。
从这种事后分析中得到的教训被扩展到实验设计中。经过适当的随机化和考虑，最佳多因素设计每次运行产生的信息是单因素设计的两倍。
但是走进任何一个生物科学实验室，无论是学术的还是工业的，询问实验的统计设计，你得到的可能只是一个无言的眼神。
生物学家是热爱科学但讨厌数学的人。我们发现图片比数字更有说服力。我们为自己对实验系统如何工作有了一种感觉而自豪。任何关于我们不知道如何恰当地设计实验，或者我们应该用统计算法来代替我们来之不易的判断的建议都可能会遭到怀疑和敌意。
但这是真的。大多数科学家不知道如何设计实验来最大化信息回报。在这个过程中，他们在浪费你的时间和金钱。
一个杜撰的例子
原因如下。一次一个因素(OFAT)的实验设计只有在没有单个因素相互作用的情况下才有效。当他们这样做时，优化就变成了打地鼠游戏:解决一个问题，制造另一个问题。
假设你的团队正在优化一个酶促反应。他们知道(因为他们既聪明又有经验)pH 值和盐浓度等因素可能会影响反应速率。
他们运行一个 pH 系列，得到这样一条曲线:
现在知道了最佳 pH 值，他们在 pH8 下运行 NaCl 系列，并得到以下结果:
你现在知道最佳条件是 pH = 8 和 NaCl = 0.4。这是科学。
但是一些麻烦制造者对此表示怀疑。她熬夜观察酸碱度和盐分的每一种可能的组合。她所发现的令她震惊:
In biology, things interact.
事实证明，降低 pH 值也会降低最佳盐浓度。真正的最佳值实际上是 pH = 6.5 和 NaCl = 0.3。
太好了。但得到这个答案还是费了一番功夫。在六种 pH 水平和六种盐水平下，需要进行 36 次实验。如果她决定添加第三个变量，运行次数将会跳到 216；第四个，到 1296 年。有了更多的变量，你很快就会面临组合爆炸。
你不需要。费希尔和他的后继者表明，从优化设计中获得几乎与全因子实验(36 次运行)一样多的信息是可能的，这比 OFAT 方法(12 次运行)不需要更多的工作。
这里的关键概念是把每一个变量看作实验“空间”中的一个维度。好的实验设计在整个空间中最优地分布运行，对每个区域进行采样，并拾取由因素之间的相互作用引起的失真。对于一个有三个因素的实验，你可以把这个空间想象成一个立方体:
A central composite design for covering the experimental space among three factors. Own work.
像这样的统计设计确保您覆盖实验空间，并且(通过几次迭代)保证您找到一个最优值，不管您的系统行为有多复杂。
当然，像 salt vs pH 这样的简单系统并不是你需要高级设计算法的原因。任何半途而废的团队都可以在一些容易改变的因素中进行优化，即使他们的优化过程是不稳定和低效的。
但是生物科学正在从分子等简单的还原实体向复杂的细胞、组织和器官链转移。影响这些实体的因素的数量以及它们之间的相互作用导致了潜在响应的组合爆炸(通常是非线性的),这是 OFAT 方法所不能涵盖的。
现实世界的例子
我在 MicroPhage 的经历很能说明问题。我们的技术使用细菌病毒(噬菌体)来检测病原体金黄色葡萄球菌并确定其抗生素敏感性。噬菌体是用于诊断测试中非常复杂的实体。它们由数百种单独的蛋白质加上一个 DNA 基因组组成，为了产生信号，它们需要宿主细菌中几十种不同蛋白质的作用。该宿主(金黄色葡萄球菌)有数百种变异菌株，它们与噬菌体表现出不同的相互作用。更糟糕的是，样本基质(病人血液和培养液的混合物)本身就非常复杂多变。
Bacteriophage — a complex nanomachine for diagnostics. Pbroks13 (redraw) [CC BY-SA 2.5 (https://creativecommons.org/licenses/by-sa/2.5)]
当我接管 R&D 团队时，他们已经用 OFAT 的方法转了几年的轮子，优化了一个方面的性能，却发现另一个方面降级了。按顺序测试变量意味着将一些团队成员的想法排在其他人之前，这恰恰对人际关系动态产生了你所期望的影响。
我们梳理了科学文献(所有 100 年的文献),写下了每一个可能影响性能的合理因素，确保包括每个人最喜欢的想法。我相信这个列表大概有 42 个不同的变量。我们使用统计设计一次筛选出所有人。再过一周。每个人都有贡献，没有人的想法被冷落。
六个因素被证明是重要的，我们继续优化它们，使用一类被称为响应面的设计。以下是对其中两个因素的分析示例:
Non-linearity in action
我们系统地优化了各种测试条件下的性能，以确保我们的产品能够从实验室过渡到临床。最终结果是一项一流的测试，在 5 个小时内(而不是通常的 3 天)识别出金黄色葡萄球菌血流感染并确定其抗生素敏感性，准确率达到 98%。
我们花了大约 2000 万美元在 3 年内获得了 FDA 的批准。像我们这样的新诊断技术的通常数字更像是 5 年和 5000 万美元。但是有了像噬菌体这样的复杂实体作为关键成分，我非常怀疑我们使用 OFAT 的方法是否能成功。尽管噬菌体科学已有一百年的历史，但微噬菌体测试是第一个(也是唯一一个)FDA 批准的基于噬菌体的诊断方法。
虽然这是一次技术上的成功，但却是一次商业上的失败；先进的实验设计无法帮助营销工作。但是，如果你的技术包括相互作用的复杂组件，那么你肯定会发现自己被 OFAT 设计的局限性所困扰。实验的统计设计是你走出陷阱的方法。
如何从 IEX 下载所有历史日内 OHCL 数据:用 Python，异步，通过 API &免费。
你正在寻找一种免费获取大量 1 分钟内股价数据的方法吗？回测你的交易算法并在本地训练你的模型？有一个非常好的方法来做到这一点，我将在下面向你展示。
在这篇文章中，我将告诉你如何从 IEX 交易所下载免费的日内数据。请注意，IEX 是美国的一家证券交易所，每天交易的股票代码超过 8000 个。没听说过？点击了解更多信息。
重要的是，这篇文章将向你展示如何从 IEX 交易所有效地、定期地下载所有> 8K 票单的 OHCL 日内数据**。**
为什么从 IEX 获取数据？
你应该从 IEX 获得日内数据有三个原因:
- 免费的。IEX 是唯一一个让你定期免费下载大量日内 OHCL(开盘价、最高价、收盘价、最低价)数据的平台。通常，如果您想要获得大型数据集，日内数据是昂贵的。
- IEX 的空气污染指数很高。IEX API有很好的文档记录，易于理解，最重要的是它完美地支持异步请求。
- 你可以在羊驼上进行纸张交易。 羊驼是我发现的算法交易最好的 API。他们为 IEX 股票代码提供免费、无限制的纸上交易。因此，你可以直接将你用 IEX 数据开发的策略付诸实践。
金融数据的替代 API 服务是什么？
让我提一下我测试过的其他三个服务，你可以考虑作为当天 OHCL 数据的替代来源。出于特殊的原因，所有这些都可能是有趣的。
- 世界交易数据 :如果你想从纳斯达克、纽约证券交易所以及非美国交易所收集当天的 OHCL 数据，这是一个非常便宜的选择。示例:通过 16 美元/月的计划，您可以获得 ca 的 2 分钟分辨率数据。50k 股票。然而，这将需要您频繁下载(每隔 2 周，每天 1 个会话，持续 2 周)，并且您的下载将非常慢，因为根据我的经验，World Trading Data 不太支持异步请求。
- Tiingo : 如果你想收集 IEX 自大约。2017，Tiingo 是最便宜的选择。它只会花费你大约。总共 10 美元，因为 Tiingo 的 API 调用限制非常宽松。注:IEX API 不允许您访问过去超过 30 个日历日的日内数据。因此，如果您希望快速获得更长时间的历史数据，Tiingo 可能会很有意思。相比之下，IEX API 非常适合定期和完全免费的下载。
- Alphavantage**😗*如果您希望定期收集纳斯达克、纽约证券交易所等其他交易所的当天 OHCL 数据，并且不需要大量的股票代码，那么 alpha vantage 可能足以免费获得这些数据。Alphavantage 涵盖了大量的报价机。然而，免费计划的 API 调用限制相当有限(每分钟 5 个 API 调用，每天 500 个调用)。
剧本的目的是什么？
下面介绍的脚本是我个人用来从 IEX 收集 1 分钟日内数据的。您可能希望根据自己的目的调整脚本。然而，也许这正是你想要的。我写这个剧本时有以下三个目的:
- 收集数据用于后续处理例如回测和训练机器学习模型。(不是:用数据喂饱你的生活算法)
- 将数据存储在本地例如，存储在您的电脑上，或者甚至存储在您电脑上的云存储文件夹中。(不是:将数据放入数据库)
- 使下载变得简单例如，我希望能够在任何时候用
python download_IEX.py运行脚本(不是:必须传递任何参数或必须在特定日期进行下载)
脚本是如何工作的？
每当您用python download_IEX.py执行脚本时，您就开始了一个新的下载会话(对于过去有数据可用但尚未下载的所有日期)。每个下载会话的工作方式如下:
- **初始化日志:**脚本为当前会话启动一个新的日志文件(见
init_logging())。例如，如果您在 10 月 26 日进行培训，您将在script/log/20191026.log中找到相应的日志文件。实际上，每个日志文件都包含执行脚本时可以在终端中看到的打印输出。 - **获取日期:**脚本获取所有必须完成下载的日期(参见
get_dates())。为此，它检查output目录中的现有文件夹，并记下数据已经下载的日期。然后，所需的日期被计算为过去 30 天或更短时间内且尚未在output文件夹中的所有日期。 - **进行下载:**然后，脚本为步骤 2 中提取的每个日期进行一个单独的异步下载会话。对于每个日期，准备一个异步下载会话(参见
asyncio_prep()，例如，从 IEX API 获取所有可用的报价机。然后，使用函数download_tickers_asynchronous()执行该会话，该函数异步读取和写入各个报价机的数据(参见get_csv()和write_csv())。
我如何设置脚本？
要设置脚本，您需要完成以下三个步骤。
- 将存储库下载到您的计算机上
你可以在这里找到 Github 库。转到Clone or download，然后点击Download zip，下载存储库。然后，将下载的文件IEX_historical-prices-master.zip放在计算机上您选择的文件夹中，并解压缩 zip 目录。
现在，您应该有一个包含以下文件的文件夹(使用您选择的名称):
2.从 IEX 获得免费的 API 密匙
去 IEX 云网站免费注册。然后在SECRET找到API Tokens下你的免费 API 令牌(见下面截图中的红色方块)。
3.建立你的 **script/config.json** 文件
在您选择的文本编辑器中打开一个新文件，例如Visual Studio Code。然后，将以下内容放入新文件的前三行，并用上一步中的SECRET令牌替换YOUR_TOKEN。
{"TOKEN": "YOUR_TOKEN"}
现在，点击Save as，在script目录下保存名为config.json的新文件。您的文件夹现在应该看起来像这样:
我如何开始下载？
如上所述设置好脚本后，您可以在script文件夹中打开一个新的终端，并使用python download_IEX.py执行脚本。如果安装了所有需要的软件包(参见download_IEX.py开头的导入)，脚本将开始下载 IEX 当天的数据。
在终端中，您将看到每个下载文件的以下内容:
时间戳、股票代码、股票代码的索引(在所有可用的 IEX 股票代码中)以及股票下载的日期:
我如何中断下载？
您可以通过中断正在执行的脚本来中断下载。(如果你在终端中执行这个脚本，control+c在 Mac 上也可以。)稍后，您可以通过使用python download_IEX.py重新启动来恢复脚本，但是您必须在中断脚本时重新开始下载当前正在下载的数据。
重要的是，默认情况下，脚本启动时不会删除任何文件或文件夹。因此，您可能想要手动删除未完成下载的日期的文件夹。这样，当您使用python download_IEX.py重新启动时，脚本将为提到的日期重新开始。
我应该多久下载一次？
如果您希望使用此脚本定期下载 IEX 数据，您将希望至少每四周运行一次。原因是根据文档，API 允许你下载“30 个连续日历日”的数据(参见 IEX 文档)。这意味着，如果您只进行一次下载会话，例如每八周一次，您将有几天缺少数据。
然而，我实际上能够获得超过 30 个连续日历日的数据。可能文件的意思是“30 个连续日历周天”。无论如何，每四周执行一次脚本是安全的。
请注意，无论何时运行该脚本，您都不需要设置任何参数，因为它会自动检测哪些日期您已经下载了数据，哪些日期您可以从 IEX 下载数据。因此，您也可以每两周执行一次脚本，或者在下载会话之间有不规则的中断(有时两周，有时更长)。
我如何利用下载的文件？
您可以看到该脚本自动创建了一个按年份、ISO 日历周和日期的文件夹结构。对于每个日期，脚本都会执行一个单独的异步下载会话。这意味着每个交易日都有包含单独 csv 文件的文件夹:每个股票代码一个 csv 文件。
实际上，该脚本为您提供了来自 IEX 的原始数据。以后如何处理这些数据取决于您。例如，您可能希望为同一个跑马灯追加所有文件，以便为每个跑马灯符号获得一个单独的文件。
重要提示:
- 当某一天的异步下载会话完成时，该天的文件夹会自动压缩以节省空间。因此，您可能希望在处理原始数据之前解压缩文件夹。
- 每个日期文件夹包含三个数据文件夹
DONE、ERROR和NONE。您将需要使用文件夹DONE中的文件，因为这些文件包含有效股票代码的实际日内数据。文件夹ERROR中的文件大部分是来自 IEX 的测试 ticker(见本 GitHub 问题)，文件夹NONE中的文件对应于当天没有任何交易的 ticker(见本 GitHub 问题)。
下载的数据会是什么样子？
在给定日期的DONE文件夹中，您会发现每个 ticker 都有一个 csv 文件:
并且这些文件中的每一个都包含相同的 OHCL 信息。以下是苹果公司(AAPL)的一个例子:
参考
感谢您的阅读，期待您的反馈！
如何通过机器学习从加密货币中获得洞察力
一个方便的教程，总结了你可以做些什么来加载，处理和制作加密货币数据集的有用模型。
Source: Pixabay
加密货币热潮催生了各种各样的用例以及大量有趣的数据。由于默认情况下，支持这些加密货币的许多区块链都是公开的，因此不同区块链之间会产生大量数据。由于每个数据点都创造了经济价值，因此有各种各样的项目和参与者在研究这项技术，从税务监管机构到那些希望预测未来加密货币价格的人。
我是第一批为 TechCrunch 和 VentureBeat 撰写新加密货币以及比特币在汇款支付中的使用的人之一。我对这个主题很熟悉，我也是一个数据科学爱好者，曾帮助跳板公司在的机器学习训练营工作，并有工作保障，所以我一直在寻找方法，将加密货币产生的大量数据与你可以在这些数据基础上建立的具有现实意义的机器学习项目结合起来。
幸运的是，谷歌大查询可以轻松地免费处理一些世界领先的基于比特币的加密货币的数据，从比特币到 Zcash。
谷歌能够建立一个简单的分类器，检测交易是否来自于矿池。你可以在 iPython 笔记本中导入一个库，并开始使用 SQL 查询这个庞大的数据集。让我们用一些样本数据查询来找点乐子，看看我们能用谷歌手头的比特币数据做些什么。
模式中有两个主要的表需要检查:一个“blocks”表和一个“transactions”表，它们是可连接的。
以下是块表的模式:
Source: Author screenshot
在这里，我们需要知道几个基本的定义。区块链由一系列包含交易数据的数据块组成，这些数据块在一段时间后按顺序确认。使用 block_id 查询，我们实际上可以缩小到区块链中的特定块。
让我们用这个探险家来玩转一下区块链的基本概念。查看第一块，我们看到第一块有 50 个比特币输出。区块高度(1)表示它是比特币 mainnet 区块链中挖掘和验证的第一个区块，这是比特币的生产版本，人们使用它在彼此之间进行金融价值交易(与测试网相反，测试网仅用于暂存目的)。
您可以使用 previous_block 变量查询区块链中的前一个 block_id。在这种情况下，块高度为 1，没有 previous_block 引用。但是，如果您查看块高度为 2 的块，那么 previous_block 将引用 genesis 块/块高度为 1 的块。
Merkle root 是一个块中所有散列事务的散列，它允许您以低得多的计算成本来验证整个块的完整性。
每个数据块还有一个时间戳，它有一个相对准确的度量标准，用于验证数据块的有效性，并作为一个额外的认证层来抵御区块链攻击者。每个区块中的难度目标是开采一个区块需要多少计算能力的度量:每 2016 个区块调整一次难度，以确保每 10 分钟开采一个区块的持续平衡速率。由于比特币是一个工作验证系统，挖掘区块是允许系统就其当前状态达成共识的东西，无论存在多少节点和交易。
每个块都有一个满足网络要求的随机数，这意味着该块可以被挖掘。有一个版本标记，讲的是比特币代码的核心配置的版本，可以作为一个区块是在什么条件和具体规则下被挖掘的标记。
Work_terahash 表示贡献和挖掘一个块需要多少计算能力。以现在的比特币为例，认真的矿工会运行 terahashes(万亿次尝试的比特币问题解决方案)——每秒高达 13 次。该度量可以作为挖掘一个块需要多少计算资源的代理(连同难度等级)。
您可以在 BigQuery explorer 上试验不同的查询来测试它们，尽管您会受到速度的限制，尤其是对于返回千兆字节数据的大型数据查询。这个限制很容易与丰富的区块链数据发生冲突。
Google BigQuery 有一个特殊的函数，在这个函数中，您需要使用反斜杠(`)将表名括起来，这样它也是一个有效的查询。
作为第一个查询，我们可以看看比特币中的第一块，也就是创世纪块。我们看到它的 Merkle 根是“0 E3 e 2357 e 806 b 6 CDB 1 f 70 b 54 c 3a 17 b 6714 ee 1 f 0 e 68 bebb 44 a 74 B1 EFD 512098”。为该 Merkle 根选择 block_id 将得到 genesis 块的 block_id，00000000839 A8 e 6886 ab 5951d 76 f 411475428 AFC 90947 ee 320161 bb f18 EB 6048。当我们检查区块链资源管理器中的 block_id 时，我们看到它保存的块高度为 1，这证实了这实际上是比特币中开采的第一个块。
Source: Author screenshot
在分析了所有的块变量之后，我们可以进入交易级别的变量——不同比特币用户之间的交易量。
通过交易表的主键 transaction_id，我们可以解锁一个块内单个交易的信息:从每个块内每笔交易的代码输出到 satoshis (1 亿 satoshis 等于一个比特币)的金额的一切。区块将有许多交易，这些交易是比特币的生命线，即不同账户之间的价值转移。
coinbase 还包含与传输的 satoshis 无关的代码和输出——这可以用于识别挖掘池之类的事情，这些挖掘池聚合计算能力，然后在个体贡献者之间分配加密货币挖掘的收益，这些贡献者明确地将他们的签名作为输出放在块 coinbase 上以识别他们自己。
在体验了不同的 SQL 查询和 Google BigQuery 接口提供的不同概念之后，我们可以使用 Kaggle 的 BigQuery 客户端工具及其内核接口直接导入到 iPython 笔记本中，然后还可以执行聚合函数、子函数以及 SQL 提供的所有功能，以获取数据块及其包含的事务的准确数据量。
让我们对比特币区块链数据 中包含的每个数据块进行计数，并使用 iPython 和 Kaggle 内核 中的接口进行一些不同的查询，我们可以通过它们与 BigQuery 的集成轻松获得数据。
Source: Author screenshot
利用这种在比特币区块链和不同加密货币上获取丰富数据的能力，我们可以在机器学习中做些什么？
对矿工是否属于矿池进行分类
谷歌发布了一个样本项目，该项目能够对给定的交易是否由矿池生成进行分类，这是一种将几个实体和个人的计算能力聚合在一起的努力，目的是鉴于比特币和其他加密货币的难度，试图成功挖掘它们。
下面的查询从给定特定地址和空闲时间的输出得到 26 个特征向量。使用一个简单的随机森林分类器和 coinbase 中的矿工分类，谷歌能够训练和标记一个模型，帮助确定交易是否可能作为采矿池的一部分产生。
将加密货币的兴趣和难度与价格水平相关联并进行预测
你可以考虑各种因素，如区块链的难度和哈希能力，以及链条上的交易活动量，并将其与历史价格数据相关联，看看你是否可以根据时间序列分析和链条因素预测未来价格——目前这可能是一项非常有利可图的投资。
根据属性对不同的区块链进行分类
你可以从不同的区块链中获取不同的属性，例如矿工奖励的基尼系数，就像在对 Kaggle上的以太坊经典的分析中所做的那样，然后使用它来分析基于不同特征的不同区块链之间的相似性，例如采矿奖励的集中程度，或者难度水平或版本历史变化——或者你可以找到的任何其他东西。
如何用 Python 驱动你的 Arduino 推进的机械臂
Arduino 微控制器是一个漂亮的电子产品。开箱即用，它可以驱动您的大多数设备和原型。GPIO 的数量、用户友好的 IDE 和低廉的价格给现代原型方法带来了重大变化。然而，这种怪物不能解决强大的计算过程。由于机器人涉及复杂的算法，你应该考虑 Python 和 Arduino 的合作来让它活起来。
这是“从零开始设计机器人手臂”系列的第二篇文章。
在第一篇文章中，我们获得了一个相当有用的 Keras 模型，并在模拟中对其进行了图形化测试。
**现在我非常兴奋能在真正的原型上使用这个模型！**我们希望评估它与模拟结果相比有多好，并得出关于我们的接近值的第一个结论。最后的工作将是设计一些方法来最小化误差。
Python 和 Arduino 之间的串行链接。
为了连接它们，我想使用 pySerial 库，它使我们能够通过 Arduino 的串行端口进行通信。
基本上，当 Arduino 通过串口监听时，python 脚本会同时向他发送一些信息。这种基本的通信过程使我们能够向机器人发送我们预测的角度三元组，以便将它驱动到希望的位置。
Serial Communication Process
在端口参数中，您需要输入 Arduino 卡使用的通信端口。波特率应该与 Arduino 脚本中的波特率相同。
Code on the python-side
在 Serial.begin(9600)行中，您正在设置波特率。
Code on the Arduino-side
使用模型生成推论(预测需求角度)
多亏了 Keras 图书馆，这项工作才得以完成。你只需要使用函数
model.predict
您还可以决定创建两个不同的脚本:一个将训练模型，另一个将利用它。为此，您需要在第一个脚本中保存模型，并在第二个脚本中加载它。
很明显 Keras 已经帮你做了。以下是主要功能:
model.save(“model.h5”)
并且加载它:
model = load_model(“model.h5”)
现在你真的离你预想的很近了。现在的任务是设置你的伺服系统，为你的(X，Y)坐标生成预测，并将预测的角度发送给机器人——享受结果。
非常感谢您的阅读，如果您有任何问题，或者您有合理的批评，或者只是想交流您的项目，请随时联系我们。
下一篇文章将会比较模拟和应用程序的健壮性。为此，我使用 CNN 通过视觉识别来检测机器人的位置。
敬请期待！！
这是完整的 Python 脚本。
这是完整的 Arduino 脚本。
为了更好地理解，你应该读一下上一篇文章:
“一种高效快速控制机器人的方法。真的。”https://link.medium.com/LIGf4r3k5Z
参考文献:
张量流:https://en.wikipedia.org/wiki/TensorFlow
https://en.wikipedia.org/wiki/NumPy号
https://en.wikipedia.org/wiki/Matplotlib
https://en.wikipedia.org/wiki/Keras
如何使用 Flask 轻松部署机器学习模型
把你的模型从 jupyter 笔记本带到生产中
被困在付费墙后面？点击这里阅读完整故事与我的朋友链接！
当数据科学家/机器学习工程师使用 Scikit-Learn、TensorFlow、Keras、PyTorch 等开发机器学习模型时，最终目标是使其在生产中可用。很多时候，当我们从事机器学习项目时，我们会把很多精力放在探索性数据分析(EDA)、特征工程、超参数调整等方面。但我们往往会忘记我们的主要目标，即从模型预测中提取真正的价值。
部署机器学习模型或将模型投入生产意味着将您的模型提供给最终用户或系统。然而，在机器学习模型的部署中存在复杂性。这篇文章旨在让你开始使用 Flask API 将训练好的机器学习模型投入生产。
我将使用线性回归来预测第三个月的销售额，使用前两个月的利率和销售额。
什么是线性回归
线性回归模型的目标是找到一个或多个特征(自变量)和一个连续目标变量(因变量)之间的关系。当只有一个特征时，称为单变量线性回归，如果有多个特征，称为多元线性回归。
线性回归假设
线性回归模型可以由下面的等式表示
- Y 是预测值
- θ ₀是偏差项。
- θ ₁,…， θ ₙ为模型参数
- x ₁、 x ₂,…、 x ₙ为特征值。
Linear regression illustrated
为什么是烧瓶？
- 好用。
- 内置开发服务器和调试器。
- 集成单元测试支持。
- RESTful 请求调度。
- 大量记录。
项目结构
该项目有四个部分:
- model.py 它包含机器学习模型的代码，用于根据前两个月的销售额预测第三个月的销售额。
- app . py——它包含 Flask APIs，通过 GUI 或 API 调用接收销售细节，根据我们的模型计算预测值并返回。
- request.py —它使用请求模块调用 app.py 中定义的 API，并显示返回值。
- HTML/CSS —它包含 HTML 模板和 CSS 样式，允许用户输入销售详细信息，并显示第三个月的预测销售额。
Pipeline for deployment of a Machine Learning model
环境和工具
- sci kit-学习
- 熊猫
- numpy
- 瓶
代码在哪里？
事不宜迟，让我们从代码开始吧。github 上的完整项目可以在这里找到。
让我们从使用 HTML 为用户输入值制作前端开始。有三个字段需要用户填写——利率、第一个月的销售额和第二个月的销售额。
接下来，我使用 CSS 对输入按钮、登录按钮和背景进行了一些样式设计。
我为这个项目创建了一个自定义销售数据集，它有四列——利率、第一个月的销售额、第二个月的销售额和第三个月的销售额。
我们现在做一个机器学习模型来预测第三个月的销量。首先让我们用熊猫来处理缺失值。当没有为一个或多个项目提供信息时，可能会出现数据缺失。如果没有提供值，我用零填充比率列，用该列的平均值填充第一个月的销售额。我用线性回归作为机器学习算法。
序列化/反序列化
简而言之，序列化是一种在磁盘上编写 python 对象的方法，该对象可以传输到任何地方，稍后可以由 python 脚本反序列化(读取)回来。
Serialization, De-Serialization
我使用 pickling 将 python 对象形式的模型转换为字符流。这个想法是，这个字符流包含在另一个 python 脚本中重建对象所需的所有信息。
下一部分是制作一个 API，它通过 GUI 接收销售细节，并根据我们的模型计算预测的销售值。为此，我以 python 对象的形式反序列化了 pickled 模型。我用index.html设置了主页面。在使用 POST 请求向/predict提交表单值时，我们得到预测的销售额。
可以通过向/results.发出另一个 POST 请求来显示结果，它接收 JSON 输入，使用训练好的模型进行预测，并以 JSON 格式返回预测，可以通过 API 端点访问该格式。
最后，我使用请求模块来调用在app.py中定义的 API。它显示第三个月返回的销售额。
结果
使用此命令运行 web 应用程序。
$ python app.py
在您的网络浏览器中打开 http://127.0.0.1:5000/ ，应出现如下所示的 GUI。
Graphical user interface
结论
本文展示了一种部署机器学习模型的非常简单的方法。我使用线性回归来预测第三个月的销售额，使用利率和前两个月的销售额。人们可以利用在这个博客中获得的知识制作一些很酷的模型，并把它们投入生产，这样其他人就可以欣赏他们的工作。
参考资料/进一步阅读
[## 用 80 行代码编写一个简单的 Flask Web 应用程序
快速入门示例教程
towardsdatascience.com](/writing-a-simple-flask-web-application-in-80-lines-cb5c386b089a) [## 部署机器学习模型| Coursera
从加州大学圣地亚哥分校学习部署机器学习模型。在本课程中，我们将了解…
www.coursera.org](https://www.coursera.org/learn/deploying-machine-learning-models) [## 将机器学习模型部署到云的简单方法
使用简单的技术堆栈将您的第一个 ML 模型部署到生产环境中
towardsdatascience.com](/simple-way-to-deploy-machine-learning-models-to-cloud-fd58b771fdcf) [## 在生产中部署机器学习模型的不同方法概述
将模型投入生产的方法有很多种，不同的方法会带来不同的好处
www.kdnuggets.com](https://www.kdnuggets.com/2019/06/approaches-deploying-machine-learning-production.html)
在你走之前
相应的源代码可以在这里找到。
[## abhinavsagar/机器学习部署教程
从数据收集到将模型投入生产的端到端项目示例…
github.com](https://github.com/abhinavsagar/Machine-Learning-Deployment-Tutorials)
联系人
如果你想了解我最新的文章和项目，请关注我的媒体。以下是我的一些联系人详细信息:
快乐阅读，快乐学习，快乐编码。
如何在 Python 中通过位置快速连接数据—空间连接
如何在 Python 中轻松地进行空间连接，以及为什么它是数据科学中经常被忽略的强大工具。
如果你使用了熊猫图书馆，你很有可能已经加入了两个表。令人难以置信的是，将两个共享列的不同数据集组合起来是如此容易。但是您知道有一种基于位置连接表(数据帧)的简单方法吗？
Spatial join example
我向您展示了一种使用空间连接来连接表的有效方法。空间连接类似于通过属性连接数据。关键区别仅在于表是基于它们在空间连接中的位置进行连接的。要执行按属性连接，两个表中必须有匹配的键；相反，您需要位置(纬度&经度)来执行空间连接。
空间连接的用例很多。假设您将学校作为点，将学区作为面(多边形)，您想要确定每个学区有多少所学校。通过执行空间连接，可以快速将点表转换为面积表，反之亦然。
实际应用:以 Airbnb 数据集为例
足够的概念和假设的例子。让我们举一个具体的例子。我想知道每个投票区有多少 Airbnb 房源。在本教程中，我使用了斯德哥尔摩的 Airbnb 数据集。高亮显示的数据集用于演示空间连接。
Airbnb Dataset Stockholm — Source
让我们像往常一样用.read_csv()先读熊猫里的表格。在第 2 步中，我们使用 Geopandas 将纬度和经度转换成几何图形。邻域数据在 Geojson 中，因此我们可以直接在 Geopandas 中读取。Geopandas 是一个高级的 pandas 库，可以轻松处理位置数据。
import pandas as pd
import geopandas as gpd# 1- Listing points
listings = pd.read_csv(“data/stockholm_listings.csv”)# 2 - convert to Geopandas Geodataframe
gdf_listings = gpd.GeoDataFrame(listings, geometry=gpd.points_from_xy(listings.longitude, listings.latitude))# 3 - Neighbourhoods
geojson_file = “data/stockholm_neighbourhoods.geojson”
neighborhoods = gpd.read_file(geojson_file)
gdf_listings 表中每个属性有不同的列，包括主机名、邻居、纬度和经度。Geopandas 转换增加了几何列，允许我们进行空间连接。
Airbnb Listings table
另一方面，Geojson 邻域文件保存了邻域的名称和几何图形。
Neighbourhood table
两个数据集都有邻域列，如果你将它们重叠绘制，它们会很好地对齐(如下图)，我们可以很容易地分组，并根据每个邻域的大小来计算每个邻域中的列表数。
Airbnb Listing as Points and Neighborhoods as Areas
但是，假设您有一组不同的邻域(多边形)。假设投票区(较小的区域)提供了更好的粒度，并具有其他有趣的属性，如人口总数。让我先用 Geopandas 读取数据。
stockholm_areas = gpd.read_file(“data/stockholm_areas.geojson”)
stockholm_areas.head()
每个投票区都有一个保存该区代码的Deso列和一个保存每个区总人口的Total列。这些新的粒度(更小)区域也完全覆盖了点数据集，**但问题是我们不知道该点属于哪个投票区。**该数据仅来自“邻居”列
Listings map — Points of listings and voting districts
空间连接
假设我们对计算每个投票区域(投票区)的列表数量感兴趣。尽管在我们的专栏中不容易获得，但我们可以很容易地做到这一点，这就是空间连接派上用场的地方。只需一行代码，您就可以确定哪个点在每个投票区内。
sjoined_listings = gpd.sjoin(gdf_listings, stockholm_areas, op=”within”)sjoined_listings.head()
上面的代码根据位置将gdf_listings和stockholm_areas连接起来。op参数决定了你想要什么样的连接。在这种情况下，我们提供了“在内”，这决定了点属于哪个区域。下面是来自连接表的 5 行示例。
Spatial join table
正如您所看到的，这个表根据它们的位置将两者连接起来。我们知道点的属性以及点属于哪个区域。现在用熊猫分组功能很容易统计每个区域有多少房源。我们可以像这样执行 pandas Groupby，以获得每个投票选区中有多少列表。
grouped = sjoined_listings.groupby(“Deso”).size()
df = grouped.to_frame().reset_index()
df.columns = [‘Deso’, ‘listings_count’]
我们以地区代码Deso的数据框架结束，并列出每个地区的计数。
Grouped-by Dataframe — number of listings per voting district
请注意，这个分组数据是一个数据帧。如果你想用投票区数据集，你可以简单地使用 pandas 合并功能，基于两个数据帧上的“Deso”列。
merged_areas = stockholm_areas.merge(df, on=’Deso’, how=’outer’)
合并的结果是地理数据框架，您可以在地理上对其进行绘制。以下是各投票区列表数量的 Choroplpleth 地图。
Choropleth map — Number of listings per voting district
如果您有一些想法，请尝试空间连接，否则请尝试连接您选择的城市和不同区域的 Airbnb 数据集。
结论
空间连接是数据科学中不常用的强大工具。在 Geopandas 的帮助下，用 Python 实现这一点非常直观和简单。在本教程中，我们使用 Airbnb 数据集通过一个实际示例执行了空间连接。我希望您发现这有助于将它添加到您的数据科学技能中。
本教程的代码可以在这个 GitHub 存储库中找到。
如果你使用了熊猫图书馆，你很有可能已经加入了两个表。令人难以置信的是，这是多么容易…
github.com](https://github.com/shakasom/spatialjoin)
如果您想直接运行本文的代码，github 存储库中还包含一个 google colab 笔记本。
如何轻松地教孩子数据科学
父母总是在寻找新的方法让他们的孩子“迷上”科学、技术、数学或工程(STEM)学科。与其说是早期灌输工程学的乐高玩具，不如说是编程的树莓 pi 或 arduino，或者是激发数学和技术兴趣的书籍和玩具，似乎有各种各样的材料可供父母一夜之间将他们的孩子变成 STEM 明星。
不久前在一次飞行中，我邻座的人问我是做什么工作的。我解释说，我本质上是一名数据科学家。他们问我那具体是什么，我没有深究其中的细节，只是说那是“一个质疑数据以寻求答案的人。”这可能不是最好的解释，但他们点点头，继续问我问题。“什么类型的数据？”他们好奇地问，因为他们盯着他们的蔓越莓苹果。我回答说:“天气和气候，但我偶尔也会涉足其他领域，比如能源。”他们接着问，“金融方面呢？”我摇摇头，但接着说“检查财务数据对我来说并不难。数据科学实际上是了解何时使用某些模型，以及哪些功能最适合该模型。”然后，不知从哪里冒出来的，这个人说了一句让我思考了一整天的话:“伙计，我希望我的孩子也能成为那样的人。听起来真的很有挑战性。”我继续解释说，数据科学并不难，寻找(现实的、可验证的)模式才是这个领域的核心。孩子们已经很有能力这样做了。
所以我想，“怎样才能让孩子们成为数据科学家？”结果如下:
请注意，这种方法已经在两个 8 岁和 11 岁的孩子身上进行了测试。
- )获得 11 个不同形状、颜色、气味或质地的物体。
就我个人而言，我回想起小时候老师给我们彩虹糖来练习算术的日子。在这里，Skittles 也能很好地工作，只要确保你使用了所有的颜色，但是保留一种颜色作为“随机”或“黑天鹅”数据点。任何可以得到的东西都可以。
2.)在活页夹或其他分隔物(任何不让你的孩子看到的东西)后面，只用你收集的 5 个物体做一个图案(所以如果你有一便士、五分、一角、二角五分和一美元，你可以按你喜欢的任何顺序排列它们)。让你的小科学家看看你做了什么图案，然后添加你的下 5 个对象。
3.)揭秘:问你的小科学家你认为接下来的 5 个物体会是什么图案。如果他们猜对了，显示图案，但将第 11 个(之前未介绍的对象)添加到对象行中。如果他们没有猜对，让他们继续猜，直到他们猜对为止。暗示他们可能已经看过这些物品。
4.)随机性:在处理数据时，随机性或“噪音”是很重要的。人们可能认为它“没什么”,但调查它是非常重要的，而不是它真的“没什么”,或者它是否是一个独特的事件。未引入的对象产生随机性。起初，这会让你的小科学家感到困惑，但是你做得越多，他们就越有可能期待你这样做。
5.)预测:让你的小科学家告诉你下一个 5 天体的顺序会是什么。(做一个假设)将你使用的前 5 个物品放在你在第 3 步中放置的 6 个物品之前。你的孩子应该猜对了，甚至可能猜到你已经将“随机”对象添加回模式中。
6.)下一轮:确保你指出接下来的 5(或 6)个物体将与他们已经看过的图案相似。一旦他们记下了那个模式，你可以通过尝试不同的模式来混合它，或者混合对象来使它变得更复杂。
7.)形象化它:当你进行的时候，让你的小科学家画出物体顺序和它们的预测顺序的图表。这可以通过拿起一支铅笔，写下何时何地出现了什么样的物体来完成——如下图所示。你也应该保持跟踪以验证结果。
How the game should be “playing” out. Image made by author.
8.游戏结束:自然，这是一个可以永远继续下去的游戏，老实说，那样会更有趣。但是，你至少可以在三个回合后结束游戏。匹配它，看看他们做得有多好！
使用你家周围的材料，你可以很容易地教你的孩子关于模式，随机性和数据可视化。我使用这种方法是因为我认为对于父母来说，寻找一种快速、简单的游戏来和他们的孩子一起玩而不需要购买任何东西会更容易。你可以出去让你的孩子看看树叶上的虫子，但是大自然比客厅要复杂一点，你可能不会在虫子身上找到很多图案。不用大词，你已经很容易地向你的孩子灌输了模式、概率和随机性的概念。这些是数据科学家的核心概念，早期理解将使您的小科学家更有可能在以后的其他领域和应用中理解这些东西。
免责声明:这个游戏不会让你的孩子成为数据科学天才，但它将有助于开发一些早期的基础知识。如果你有任何其他方法想要分享，请在下面的回复中发表。
如何在你的业务中有效地运用人工智能策略
今天的首席管理人员的 5 个关键人工智能要点
人工智能已经从一个时髦的词发展成为今天的现实。拥有机器学习系统专业知识的公司正在寻求转向基于人工智能的技术。尚不具备机器学习文化的企业正试图设计一种策略来实现这种文化。在这种炒作和被抛在后面的恐惧中，你将如何在你的公司中着手一项人工智能战略？今天，这似乎是一个反复出现的常见问题。本文试图更深入地探讨企业在实施人工智能战略时面临的一些挑战、机遇和可能性。
当今人工智能的关键挑战:3t
在一家公司中创建人工智能生态系统会面临很多挑战。所有这些挑战可以归结为三个主要方面:
- **人才:**组建一个人才团队是当今许多企业最关心的问题之一。
- **时间:**另一个关键要素是时间。重要的是要看看通过实施人工智能战略，你能以多快的速度获得业务成果。
- **信任:**信任是指对你的机器学习模型的信任，以及你向监管者和利益相关者解释你的模型结果的能力。
这里有一些解决这些问题的建议，这些建议是通过多年来与大量 H2O.ai 的客户和用户交谈而形成的。
1.构建数据文化
为了利用产生的大量数据并理解它们，公司需要首先建立一种数据文化。在一家公司建立数据驱动的文化时，应该记住以下三个要点:
- 数据采集
要建立数据文化，首先需要主动收集数据。今天的数据可以从各种来源获得，如市场营销部门、销售部门、产品监控、客户分析等。这实质上形成了基础。
- 使数据可访问
已经收集的数据需要向人们公开。这意味着数据应该是这样一种格式，这使得人们可以轻松地处理数据并从中获得有意义的见解。
- 找到合适的人才
数据本质上是一项团队运动。这意味着，尽管公司需要专家来创建模型和算法，但他们也需要具有不同技术能力的人，这些人可以在将数据传递给专家之前，从数据中发现有用的见解。为此，我们可以培训现有的员工，因为他们拥有这项工作所必需的领域经验。机器学习既是一种文化转型，也是一种商业转型。因此，公司可以雇佣一些数据科学家，并利用现有的经验丰富的员工来协助他们，而不是从头开始创建一个新团队。
2.问正确的问题
提出正确的问题是在公司中创造数据文化的必要条件。我如何获得下一个客户，谁是下一个客户，我如何优化我的供应链是当今大多数企业需要回答的一些问题。有时候，将业务问题公式化可以作为实现人工智能的垫脚石。为了能够提出相关的问题，公司需要有分析型 思维定势的人，以及有 数据 支持的解决方案，而不是直觉。
- 你正在解决什么问题？
如今，人工智能和机器学习几乎被用于所有行业。一些众所周知的例子如下。
在这些行业中使用人工智能的想法是为了节省时间和金钱，并获得相对于其他人的竞争优势。如果您的公司处理上述任何用例或一些类似的业务问题，而您只依靠传统方法，您一定会落后。
- 决定结果
问正确的问题决定了它能产生什么样的结果。关键思想是将贵公司的高层次目标转化为业务问题，然后确定其结果。
- 衡量成功
公司也需要拿出衡量他们成功的标准。不同的公司对成功的定义可能不同，但最终目标是相同的，即盈利和创造价值。
3.连接到社区
社区在推动任何公司的变革中扮演着至关重要的角色。有在线(网络研讨会)和离线(聚会)两种方式与社区联系。组织聚会、网络研讨会和培训会议可以让一个人交流知识并向他人学习。向他人学习，参与会议，分享相关知识是联系社区的好方法。你在哪里不重要。世界各地都有机器学习社区，可能就在你家旁边就有一个地方分会。
连接到社区的另一个重要原因是，今天的大多数数据科学家和研究人员都希望与其他人合作。人工智能领域的技术正在飞速发展，通过连接，人们希望提出所有正确的问题，与他人分享，参与其中，并向每个人学习。不用说，在最近十年中，大多数前沿研究都来自学术界和开源社区。
4.技术考虑
决定使用哪种技术是一个重要的考虑因素，会对您的业务产生深远的影响。
- 开源还是闭源？
如果公司正在开始人工智能之旅，他们可能需要决定是使用开源软件还是开源软件，或者两者兼而有之。机器学习和人工智能领域的许多现有先驱定期开源他们的技术，这可以成为其他人的良好起点。一旦这些新的人工智能玩家成熟了，他们可能需要一个供应商来支持他们。你也可以选择一个本身就是软件包维护者的供应商，例如，对于开源的 H2O-3，H2O.ai 既是维护者也是供应商。
- 云还是本地？
这个问题的答案取决于你想以多快的速度开始。如果您刚刚开始，并且没有现成的开发-运营系统，那么开始使用云会更容易。这将消除购买硬件、安装软件、安全、基础设施和维护问题的需要。但是，如果您已经有了一个不错的 DevOps 基础架构，内部部署选项有助于优化成本。许多公司也更喜欢混合模式，无论他们是根据自己的要求在云和本地之间切换，这都是一种很好的做法。
- 数据
同样，正如已经提到的，数据是一个关键点。了解如何生成、保存和访问数据至关重要。数据隐私、数据治理和数据传承等是公司需要适当解决的一些问题。
5.信任人工智能
机器学习模型不应被视为“黑盒”。这意味着我们应该能够清楚地解释或识别他们预测背后的逻辑。能够充分地描述模型的决策，拥有健全的文档，从结果中消除偏见是一些重要的考虑因素，这些都是公司在向人工智能灌输信任元素时需要回答的。
你从这里去哪里？
那么，你将何去何从？通过深思熟虑以上五个要点，并与你的团队讨论，公司可以从哪里开始他们的旅程获得一种感觉或方向。思考并确定你目前试图解决的问题，看看你如何使用机器学习和人工智能来给你带来优势。人工智能文化需要发展，就像每一项重要任务一样，需要时间、耐心和资源。
如何在大规模神经网络中有效地传播激活
事件驱动的方法
在使用 sigmoid 激活函数的传统神经网络中，所有神经元都或多或少地被激活。这里没有不活跃神经元的明确例子。如果你想计算非常大的网络，这可能会有问题，因为在每一轮中，你必须更新所有的神经元。直觉上，只更新那些与当前输入数据集有关系的神经元会更理想。例如，如果你试图处理一只猫的图像，为什么所有与识别宇航员相关的神经元也要活跃呢？实现这个目标的一个先决条件是选择一个合适的激活函数。这种激活函数应该为所有负输入值返回零。人们可以使用 ReLU 作为激活函数或双曲正切函数的正半部分。利用这样的激活函数，通过使用零阈值，有可能清楚地区分活跃和不活跃的神经元。既然我们不想更新所有的神经元，那么我们如何决定哪些神经元应该更新呢？一种简单的方法是使用队列。如果一个神经元被激活，只需将所有通过传出突触连接的神经元添加到队列中。然后，在每个处理步骤中，从队列中取出一个神经元，更新它，如果它被激活，就再次将传出神经元添加到队列中。
但是，即使使用这种优化的算法，我们也可能会计算太多的更新操作。大多数更新的神经元在更新后仍将保持不活动。如果在我们真正更新神经元之前，我们就能决定它是否有机会变得活跃，那会怎么样？
让我们仔细看看一个神经元可以拥有的不同权重模式。这里可能有像这样的分离神经元:
在这种情况下，每一个输入神经元的激活都需要一个当前神经元的更新。但是可能会有更多像这样的连接神经元:
这里，输入 A 必须在当前神经元有机会激活自己之前被激活。因此，当前神经元的更新仅需要在输入 A 被激活之后发生。但是在下面的情况下会发生什么呢？
在这种情况下，在当前神经元需要更新之前，两个输入 A 和 B 都必须有效。这可以通过需要联合触发的三个或四个输入来进行。那么，我们如何利用这些知识来防止神经元过早更新呢？
这可以通过引入逻辑节点来实现，逻辑节点仅用于确定接下来需要更新哪个神经元。有了这些逻辑节点，我们突然进入了专家系统的领域，尽管我们是从我们的突触权重间接获得我们的知识库。这种基于逻辑的系统的好处是它们允许一些很好的优化。一种这样的优化是将较大的连接节点分割开，并在模式网格中表示它们:
在这样的网格中，如果无法激活节点，激活不需要传播到最特定的节点。例如，如果在这个点阵中只有两个输入 A 和 C 被激活，那么激活只需要传播到相对一般的节点 AC ，而不需要传播到更具体的节点 ABC 。因此，在这种情况下，与节点 ABC 相关联的神经元不需要更新。当然，这些逻辑节点可以由几个神经元共享。
代理对象
使用大型网络结构时出现的另一个问题是如何将它们放入主存。如果模型变得太大，唯一的解决方案是在外部存储模型的一部分。当然，这会造成性能损失，但这真的有那么糟糕吗？如果只有很少使用的神经元和逻辑节点(大多数通常都是这样)被存储在外部，那么这种损失对于大多数应用程序来说应该是可以接受的。延迟参数可用于确定未使用的神经元在被移除之前应在内存中停留多长时间。使用该参数，可以在性能和内存消耗之间进行权衡。
为了能够从网络中移除单个神经元或逻辑节点，可以使用代理对象。代理对象能够从外部源加载神经元，并在需要时将其恢复到主内存中。当然，所有的突触都需要链接这些代理对象，因为一些链接的神经元可能还不在内存中。代理对象简单地提供了一个 get() 函数，然后该函数返回对主对象的引用。
当在外部存储器中存储神经元时，区分连接和分离神经元是重要的。根据它们所代表的类别，分离的神经元可能拥有非常大的一组输入突触。为了防止这些大型数据结构需要一次性加载，可以将分离的突触存储在输入神经元侧。
目前，我们正在一个拥有约 2000 万个神经元的网络上使用这种算法，对于一个给定的文档，平均有几千个神经元被激活。一份文件的处理时间约为 100 毫秒至 200 毫秒。
这种方法的一个实现可以在 GitHub 上的 AIKA 开源项目中找到。
技巧、窍门、诀窍和魔法:如何毫不费力地优化您的 Jupyter 笔记本电脑
让 Jupyter 笔记本变得更好、更快、更强、更光滑、更棒的完整初学者指南
Image by peter_pyw from Pixabay
科技真正酷的地方在于有多少人在努力工作，让你的生活变得更有趣。每一天的每一分钟，都有人把他们的血汗和眼泪投入到工具中，让你的程序、软件包、应用程序和生活运行得更顺畅。
举例来说，你可能会认为一旦你有了 Jupyter 笔记本电脑，就万事大吉了。如果成功了，你就完了！你可能没有意识到的是，有几乎无穷无尽的方法可以定制你的笔记本电脑。安装程序或软件包仅仅是开始！
为什么不花几分钟时间放松一下，做一些改进呢？有很多简单的方法可以让你的 Jupyter 笔记本变得更好、更快、更强、更性感、更有趣。
本指南假设您对 Jupyter 笔记本相当陌生。在进入更酷的技巧之前，我们将从初学者真正基础的东西开始。如果您真的是新手，并且在安装和运行 Anaconda 时遇到了困难，您可能想看看这篇文章:
[## 如何在 Mac 上成功安装 Anaconda(并让它实际工作)
正确安装 Anaconda 和修复可怕的“找不到 conda 命令”错误的快速而简单的指南
towardsdatascience.com](/how-to-successfully-install-anaconda-on-a-mac-and-actually-get-it-to-work-53ce18025f97)
重要的事情先来
在你安装好所有东西后，任何时候你想启动 Jupyter 笔记本，你只需要打开你的终端并运行
jupyter notebook
你就可以开始工作了！
GIF via GIPHY
更改您的笔记本主题
人们想在 Jupyter 笔记本上改变的第一件事就是主题。人们为黑暗模式疯狂！这非常简单，你可以随时切换。
首先，转到您的终端并安装 Jupyterthemes
pip install jupyterthemes
现在你可以安装超级流行的黑暗主题
jt -t chesterish
随时使用恢复主题
jt -r
点击此处查找 Jupyterthemes GitHub 回购。
基本命令
- 您可以使用命令选项板快速访问键盘快捷键。只需键入
Ctrl + Shift + P或Cmd + Shift + P即可进入一个对话框，这很像 Mac 上的 Spotlight Search。它可以帮助你运行任何命令的名字，这是伟大的，如果你不知道键盘快捷键。
Shift + Enter让您运行当前单元格Esc进入命令模式。现在你可以用箭头键在你的笔记本上导航了！
在命令模式下，使用
A在当前单元格上方插入新单元格B在当前单元格下方插入新单元格M将当前单元格改为降价Y改回代码单元格D + D删除当前单元格(按两次键)Enter将您从命令模式带回到编辑模式
也
Shift + Tab将向您显示您刚刚在代码单元格中键入的对象的文档。(您可以持续按下此按钮在几种模式之间循环。)Esc + F帮助你查找和替换代码中的信息(不是输出中的)Esc + 0切换单元格输出Shift + J或Shift + Down向下选择下一个单元格。Shift + K或Shift + Up向上选择单元格。选择单元格后，您可以批量删除/复制/剪切/粘贴/运行它们。当您需要移动笔记本电脑的部件时，这真是太棒了！Shift + M允许您合并多个单元格。(如果你只是试图点击你想要工作的单元格，你会有麻烦。按住 shift 键并单击要合并的单元格。然后，在您仍然按住 shift 键的同时，按 m 键。)
- 此外，如果在开头加上感叹号，您可以在笔记本中运行 bash 命令。例如:
!pip install numpy - 您可以通过在最后一行代码的末尾添加分号来随时取消该函数的输出。
注释和取消注释代码块
您可能希望在工作时添加新的代码行并注释掉旧的代码行。如果您正在提高代码的性能或试图调试它，这是非常好的。
首先，选择您想要注释掉的所有行。
下一步点击cmd + /注释掉高亮显示的代码！
乳液
您可以随时在 Markdown 单元格中编写 LaTex，它将呈现为一个公式。
这改变了这一点
$P(A \mid B) = \frac{P(B \mid A)P(A)}{P(B)}$
变成这样
漂亮地打印所有单元格输出
通常只打印单元格中的最后一个输出。其他的都要手动添加print()，也可以但不是超级方便。您可以通过在笔记本顶部添加以下内容来进行更改:
from IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = "all"
这意味着，虽然通常只打印一个输出
现在您将看到两个输出！
任何时候你想回到原来的设置，只要运行
from IPython.core.interactiveshell import InteractiveShellInteractiveShell.ast_node_interactivity = "last_expr"
请注意，您必须在单独的单元中运行设置更改，以使其在下一次单元运行时生效。
扩展ˌ扩张
因为它是一个开源的网络应用程序，已经为 Jupyter 笔记本开发了大量的扩展。你可以在这里找到官方的 iPython 扩展列表。这是另一个流行的扩展包。
您可以随时从命令行安装 Nbextensions，如下所示
带 pip
pip install jupyter_contrib_nbextensions
jupyter contrib nbextension install --user
或者用蟒蛇
conda install -c conda-forge jupyter_contrib_nbextensions
conda install -c conda-forge jupyter_nbextensions_configurator
jupyter contrib nbextension install --user
安装完成后，您会看到一个 Nbextensions 选项卡。继续探索！
点击这里阅读更多关于扩展的内容，以及如何启用、禁用它们，等等。
关于添加和启用扩展以及如何使用它们，我不会讲太多的细节，因为在你的 Jupyter 笔记本里已经有了很好的解释！只需点击屏幕顶部的“Nbextensions”，点击你感兴趣的扩展，然后向下滚动，找到你需要的信息和一个正在运行的扩展的 GIF！
流行的扩展
- Scratchpad — 这太棒了。它允许您创建一个临时单元格来进行快速计算，而无需在工作簿中创建新的单元格。这是一个巨大的时间节省！
- 腹地 —这将为代码单元格中的每次按键启用代码自动完成菜单，而不仅仅是使用 tab 键
- 片段 —添加一个下拉菜单，将片段单元格插入当前笔记本。
- Autopep8 —这是一个自动格式化 Python 代码以符合 pep8 风格指南的工具。太方便了！确保您已经在本地机器上运行了
pip install autopep8 --user。这将确保您遵循正确的 python 编码约定。 - 拆分单元格笔记本 —启用 Jupyter 笔记本中的拆分单元格。进入命令模式，使用
Shift + S将当前单元格切换为拆分单元格或全角单元格。 - 目录 —这个扩展使你能够收集所有正在运行的标题，并把它们显示在一个浮动窗口中，作为一个侧边栏，或者带有一个导航菜单。
- 一个代码美化器— 清理、格式化和缩进你的代码，所以你不需要这么做。
- Notify — 当您的内核空闲时，它会显示一个桌面通知。当您运行需要几秒钟以上才能完成的代码时，这是非常棒的。
- 代码折叠— 在编辑模式下，一个三角形出现在装订线中，用于折叠您的代码。当你有大的函数需要隐藏以提高可读性时，这是个好方法。
- 禅模式— 让事情变得不那么杂乱。确保关闭设置中的背景。
魔法
当你想执行特定的任务时，魔法是方便的命令，使生活变得更容易。它们通常看起来像 unix 命令，但都是用 Python 实现的。外面有一大堆魔法！
有两种魔法:线魔法(在一条线上使用)和单元格魔法(适用于整个单元格)。线条魔术以百分比字符%开始，单元格魔术以两个字符%%开始。要查看可用的魔法，请运行:
%lsmagic
设置环境
使用%env，你可以轻松管理笔记本的环境变量，而无需重启任何东西。如果您不带任何变量运行它，它将列出您的所有环境变量。
插入代码
您可以使用%load从外部脚本插入代码。(下面有更多这方面的内容，但它很棒，所以我把它加在这里)例如:
%load basic_imports.py
将抓取 basic_imports.py 文件并加载到您的笔记本中！
导出单元格的内容
这非常有帮助。几乎不费吹灰之力，你就可以用%%writefile随时导出单元格内容。例如
%%writefile thiscode.pyyou'd write some cool code or function in here
that you'd want to export
and maybe even use later!
您是否发现自己在每台笔记本上运行相同的导入或一直添加相同的功能？现在可以一次写，到处用！
您可以编写一个包含以下代码的文件basic_imports.py:
%writefile basic_imports.pyimport pandas as pd
import numpy as np
import matplotlib.pyplot as plt
这将创建一个包含基本导入的. py 文件。
您可以随时通过编写以下内容来加载它:
%load basic_imports.py
执行此操作会用加载的文件替换单元格内容。
# %load imports.pyimport pandas as pd
import numpy as np
import matplotlib.pyplot as plt
现在我们可以再次运行单元来导入我们所有的模块，我们准备好了。
存储和重用代码:%macro Magic
像大多数人一样，你可能会发现自己一遍又一遍地写着同样的任务。也许有几个方程你发现自己在重复计算，或者有几行代码你已经产生了无数次。Jupyter 允许你将代码片段保存为可执行的宏！宏只是代码，所以它们可以包含在执行前必须定义的变量。来定义一个吧！
比方说
name = 'Kitten'
现在，为了定义一个宏，我们需要一些代码来使用。我们可以保存几乎任何东西，从字符串到函数，或者你需要的任何东西。
print('Hello, %s!' % name)**Hello, Kitten!**
我们使用%macro和%load魔法来建立一个可重用的宏。以双下划线开始宏名以区别于其他变量是很常见的。
%macro -q __hello_you 32
这个%macro魔术需要一个名称和一个单元号(或者数字)，我们也传递了-q以使它不那么冗长。%store允许我们保存任何变量，以便在其他会话中使用。这里我们传递了我们创建的宏的名称，这样我们可以在内核关闭后或在其他笔记本中再次使用它。
要加载宏，我们只需运行:
%load __hello_you
为了执行它，我们可以运行一个包含宏名的单元格。
__hello_you**Hello, Kitten!**
Image by Ilona Ilyés from Pixabay
成功！
让我们修改我们在宏中使用的变量。
name = 'Muffins'
当我们现在运行宏时，我们修改后的值被选中。
__hello_you**Hello, Muffins!**
这是因为宏在单元格范围内执行保存的代码。如果name没有定义，我们会得到一个错误。
Image by Helga Kattinger from Pixabay
想要在所有笔记本上使用相同的宏吗？
商店魔术
%store允许您存储宏并在所有 Jupyter 笔记本上使用。
现在你可以打开一个新的笔记本，用%store -r __hello_you试试。把婴儿装上车，你就可以出发了！
%store -r __hello_you
name = 'Rambo'
%load __hello_you**Hello, Rambo!**
运行魔法
magic 将执行您的代码并显示任何输出，包括 Matplotlib 图。你甚至可以这样执行整个笔记本。
%run可以从执行 python 代码。py 文件。它还可以执行其他 Jupyter 笔记本。
Pycat 魔法
如果您不确定脚本中有什么，您可以随时使用%pycat来显示脚本的内容。
%pycat basic_imports.py
自动保存
这个魔术可以让你改变你的笔记本自动保存到检查点文件的频率。
%autosave 60
这将设置你每 60 秒自动保存一次。
显示打印图像
%matplotlib inline
你可能已经知道这个，但是%matplotlib inline会在你的单元格输出中显示你的 Matplotlib 绘图图像。这意味着您可以在笔记本中包含 Matplotlib 图表和图形。在笔记本的开头，也就是第一个单元格中运行这个是有意义的。
时机
有两个 IPython 神奇的命令对计时很有用— %%time和%timeit。当您有一些缓慢的代码，并且您试图确定问题在哪里时，这些非常有用。它们都有行模式和单元模式。
%timeit和%time的主要区别在于%timeit多次运行指定代码并计算平均值。
%%time会给你单元格内单次运行代码的信息。
%%timeit使用 Python timeit 模块，该模块运行一条语句无数次，然后提供结果的平均值。您可以使用-n选项指定运行次数，使用-r指定重复次数，等等。
从不同的内核运行代码
您也可以使用指定的语言执行单元格。有多种语言的扩展。你有如下选择
%%bash%%HTML%%python%%python2%%python3%%ruby%%perl%%capture%%javascript%%js%%latex%%markdown%%pypy
例如，要在笔记本中呈现 HTML，您可以运行:
%%HTML
This is <em>really</em> neat!
你也可以随时直接使用乳胶
%%latex
This is an equation: $E = mc^2$
谁会魔法
不带任何参数的%who命令将列出全局范围内存在的所有变量。传递一个类似于str的参数将只列出该类型的变量。所以如果你输入类似
%who str
在我们的笔记本里，你会看到
普伦魔法
%prun显示你的程序在每个函数上花了多少时间。使用%prun statement_name会给出一个有序的表格，显示每个内部函数在语句中被调用的次数、每次调用所用的时间以及函数所有运行的累计时间。
Python 调试器魔术
Jupyter 有自己的 Python 调试器接口。这使得有可能进入函数内部，看看那里发生了什么。您可以通过运行单元格顶部的%pdb来打开它。
高分辨率绘图
IPython magic 的一个简单行将为您提供 Retina 屏幕的双倍分辨率图形输出。请注意，这不会在非视网膜屏幕上呈现。
%config InlineBackend.figure_format ='retina'
跳过一个单元格不运行
只需在单元格顶部添加%%script false
%%script falseyou'd put some long
code here that you don't want to run
right now
提醒我
这实际上是 Python 的一个技巧，但是当你运行的代码需要花费很长时间时，你可能需要它。如果你不想整天盯着你的代码，但是你需要知道它什么时候完成，你可以让你的代码在完成的时候发出“警报”!
在 Linux(和 Mac)上
import os
duration = 1 *# second*
freq = 440 *# Hz*
os.system('play --no-show-progress --null --channels 1 synth %s sine %f' % (duration, freq))
在 Windows 上
import winsound
duration = 1000 *# millisecond*
freq = 440 *# Hz*
winsound.Beep(freq, duration)
为了使用这个，你需要安装sox，你应该能够做到
brew install sox
…假设你安装了自制软件。如果您还没有花时间定制和改进您的终端，您可能想看看这篇文章！
如何在短短几分钟内打造一个更好、更快、更强、更性感的终端
towardsdatascience.com](/trick-out-your-terminal-in-10-minutes-or-less-ba1e0177b7df)
现在玩得开心！
这应该足以让你开始！如果你知道任何你认为可以帮助其他初学者的技巧和诀窍，请在下面的评论中让每个人都知道。你在这里的选择是无限的！
如果你真的想让事情更上一层楼，你可能想看看这篇文章:
根据我在过去一年中得到的一些提示，找到瓶颈并大幅提高速度。
towardsdatascience.com](/speed-up-jupyter-notebooks-20716cbe2025)
如果您对构建交互式仪表盘感兴趣，请查看这个:
欢迎来到“高级 Jupyter 笔记本技巧”的第二部分在第一部分，我描述了魔术，以及如何计算笔记本…
blog.dominodatalab.com](https://blog.dominodatalab.com/interactive-dashboards-in-jupyter/)
感谢阅读！如果你想接触或者找到更多很酷的文章，请来内容简约和我一起吧！
如何在你的 Azure 数据科学项目中嵌入安全性
使用 Azure 数据块和 Azure 安全服务和技术
1.介绍
许多公司努力将他们的数据科学项目投入生产。在之前的博客中，讨论了如何为数据科学项目建立构建/发布管道。这使得公司能够 1)端到端地跟踪模型，2)建立对模型的信任，从而 3)避免模型预测令人费解的情况。
在每个构建/发布管道中，安全性都是一个重要的主题。常见的安全方面如下:
- 对数据和端点的身份验证和授权
- 数据和端点的网络隔离
- 保险库中密钥的安全存储和密钥滚动过程
2020 年 9 月 17 日更新:本博客专用的博客和 gitrepo 不维护，不能 1 对 1 使用。不过，这些想法仍然有效。一个工作实例，见我之前的 博客
2.目标
在本教程中，将创建一个机器学习模型的构建/发布管道，用于预测一个人的收入阶层。在这种情况下，一个模型被构造成 Azure Databricks，然后这个模型被部署在一个 Web 应用中，这个 Web 应用充当 HTTPS 端点。构建/发布管道中包含以下安全方面:
- 数据存储在 Azure Storage gen 2 中，服务端点指向 VNET
- 密钥存储在密钥库中，密钥翻转是构建步骤的一部分。
- Azure Active Directory 用于对 Web 应用程序进行身份验证
- (可选)Web 应用程序是在 VNET 应用程序服务环境(ASE)中创建的
这可以在下面的体系结构概述中描述:
2. Architecture overview
在本博客的剩余部分，将执行以下步骤:
- 3.先决条件
- 4.创建机器学习模型
- 5.在 Azure DevOps 中构建模型
- 6.发布模型 Azure DevOps
- 7.结论
这是一个独立的教程，但是，现在的重点将是安全性，而不是机器学习模型。如果你对 ML 更感兴趣，建议做以前的博客，这里或者使用 scikit-learn，这里看。
3.先决条件
需要在同一资源组和同一位置创建以下资源。
- Azure CLI
- 天蓝色钥匙金库
- Azure Data 湖存储账户第二代
- Azure Databricks 工作区。如果您想要在您的存储帐户上设置防火墙规则(请参见步骤 4d)，请在自己的 VNET 中部署数据块，请参见此处的
- Azure 机器学习服务
- 蔚蓝 DevOps
4.创建机器学习模型
这一部分将执行以下步骤。请注意，尽可能使用 Azure CLI。
- 4a。将存储密钥添加到密钥库
- 4b。在 Azure 数据块中创建秘密范围
- 4c。向存储帐户添加数据
- 4d。(可选)存储帐户的网络隔离
- 4e。在 Azure Databricks 上运行笔记本
4a。将存储密钥添加到密钥库
在此步骤中，使用 Azure CLI 将存储帐户的密钥添加到密钥库中。按如下方式复制密钥:
az login
az storage account keys list -g <<resource group>> -n <<stor name>>
现在，使用以下代码将存储帐户名称和存储帐户密钥添加到 Azure 密钥库中。建议在整个教程中使用相同的粗体名称，因为这些名称在 Azure DevOps 构建步骤中用作变量。确保用于登录 Azure CLI 的用户有足够的权限在密钥库中创建/列出/获取密钥。
az keyvault secret set -n **stor-key** --vault-name <<vault name>> --value <<stor key>>
4b。在 Azure 数据块中创建秘密范围
在数据块中创建 Azure Key Vault 支持的机密范围。这使得您可以将您的秘密存储在密钥库中，而不必再将密钥存储在笔记本中。将秘密范围命名为: devaisec
管理机密从创建机密范围开始。秘密作用域由其名称来标识，在一个…
docs.azuredatabricks.net](https://docs.azuredatabricks.net/user-guide/secrets/secret-scopes.html#create-an-azure-key-vault-backed-secret-scope)
4c。向存储帐户添加数据
在您的电脑上从https://amldocker datasets . azure edge . net/adultcensus income . CSV下载数据文件。然后将数据添加到存储容器，如下所示:
az storage container create -n **dbrdata** --account-name <<stor name>>
az storage blob upload -f <<...\AdultCensusIncome.csv>>
-c **dbrdata** -n **AdultCensusIncome****.csv** --account-name <<stor name>>
4d。(可选)存储帐户的网络隔离
只有当您在自己的 VNET 中部署了 Databricks 工作空间时，这一步才是可能的，参见此处。转到您的存储帐户，选择防火墙，然后添加您在其中部署了 Databricks 工作区的 VNET。
4d1. Add VNET to storage account
确保 Databricks VNET 的私有和公共子网都已添加到存储帐户的防火墙中。
4e。在 Azure Databricks 上运行笔记本
转到您的 Azure Databricks 工作区，右键单击，然后选择导入。在单选按钮中，选择使用 URL 导入以下笔记本:
[https://raw.githubusercontent.com/rebremer/devopsai_databricks/master/project/modelling/](https://raw.githubusercontent.com/rebremer/devopsai_databricks/master/project/modelling/1_IncomeNotebookExploration.py)1_incomeNotebookExploration_sec.py
用您自己的变量替换下列变量
storageAccountName = "<<stor name>>" #see step_3
azureKevVaultstor2Key = **"stor-key"** # see step_4a
secretScope = **"devaisec"** # see step_4b
storageContainer = **"dbrdata"** # see step_4c
fileName = **"AdultCensusIncome.csv"** # see step_4c
确保笔记本电脑可以连接的群集正在运行。可以使用默认设置创建集群。然后运行 notebook 来创建 ML 模型。
5.在 Azure DevOps 中构建模型
Azure DevOps 是一个工具，可以持续地构建、测试和部署你的代码到任何平台和云。需要完成以下工作:
- 5a。在数据块中创建令牌
- 5b。创建 Azure DevOps 项目并添加存储库
- 5c。创建服务连接
- 5d。向项目添加秘密变量
- 5e。向项目添加其他变量
- 5f。创建和构建管道
5a。在数据块中创建个人访问令牌
以编程方式访问 Azure 数据块需要令牌。进入 Azure Databricks，点击右上角的人物图标。选择用户设置，然后生成新令牌。
5a1. Generate Databricks Access Token
再次将密钥添加到 Azure 密钥库:
az keyvault secret set -n **dbr-token** --vault-name <<vault name>> --value <<token_id>>
az keyvault secret set -n **dbr-key** --vault-name <<vault name>> --value <<key value>>
另外，将 subscription_id 的值添加到密钥库中。
az keyvault secret set -n **subscription-id** --vault-name <<vault name>> --value <<subscription_id>>
个人访问令牌将作为构建管道的一部分进行滚动。
5b。创建 Azure DevOps 项目并添加存储库
按照这个链接创建一个新的 Azure DevOps 项目。创建新项目后，单击存储库文件夹并选择导入以下存储库:
[https://github.com/rebremer/devopsai_databricks.git](https://github.com/rebremer/devopsai_databricks.git)
5c。创建服务连接
从 VSTS 访问资源组中的资源需要一个服务连接。转到项目设置、服务连接，然后选择 Azure 资源管理器。
5c1. Go to Service Connection
选择服务主体身份验证，并将范围限制到您的资源组。将连接命名为devopsaisec _ service _ connection
5c2. Create Azure Resource Manager service connection
要从 Azure DevOps 管道配置密钥滚动，服务主体需要拥有对 Azure 密钥库的访问权限。因此，通过点击服务连接来查找服务连接的应用 id，然后选择“更新服务连接”，然后点击链接“使用服务连接对话框的完整版本”。
5c3. Application id of service connection
最后，授予服务主体对密钥库中机密的 set 权限(服务连接已经拥有 get 和 list 权限)。
az keyvault set-policy --name <<vault name>>
--resource-group <<resource group>>
--secret-permissions get list set
--spn <<application id>>
5d。向项目添加秘密变量
在步骤 4a 中，存储密钥被添加到 Azure 密钥库中。随后，在步骤 5a 中添加了 Databricks 访问令牌和 subscription_id。
我们的 Azure DevOps 项目需要这些秘密。因此，单击库并选择将 Azure Key Vault 中的机密链接到项目。选择在步骤 5b 中创建的服务连接和存储机密的密钥库，然后单击 authorize。
5c1. Authorize to key vault
最后，将秘密变量“dbr-key”、“dbr-token”和“subscription-id”添加到项目中，然后单击 save。
5e。向项目添加其他变量
除了秘密变量，Azure DevOps 项目运行还需要其他配置。同样，转到库，允许访问所有管道，并使用您自己的值作为组添加以下变量:
**amls-name** <<azure ml_service name>>
**dbr-secretscope** **devaisec** <<see step_4b>>
**dbr-url** <<dbr_url, <<your region>>.azuredatabricks.net>>
**rg-name ** <<resource group>>
**stor-container ** **dbrdata** <<see step_4c>>
**stor-name ** <<store name>>
**keyvault-name ** <<vault name>>
5e1. Create secret variable group to be used in project
5f。创建和构建管道
在这一步中，将创建构建管道。单击“管道”，选择“新建”，然后选择“新建管道”。保留默认值，然后单击“继续”。在下一个屏幕中，选择“配置为代码”并单击“应用”。
选择作为代理池以拥有“托管的 Ubuntu 1604”并选择作为文件路径:project/config code _ build _ sec . yml。然后单击保存，另请参见下面的屏幕
5f1. Configuration as code
最后，链接前面创建的秘密变量组。因此，单击变量组，链接 5d 中创建的秘密变量组和 5e 中的其他变量组，并单击保存和队列开始构建。
5f2. Link variables group to build pipeline and build
成功执行 run 后，您可以看到构建、首次运行和最终结果。
5f3. Succesfull build
在这个构建管道中，执行以下步骤:
- 通过运行 notebook 使用 Azure Databricks 创建模型。
- 从将在发布步骤中部署的模型创建 docker 映像
- 执行 Databricks 令牌的密钥翻转，以最大限度地降低风险
- 创建用作发布管道输入的构建工件
6.Azure DevOps 中的发布模型
下一部分是关于创建一个发布管道。在这种情况下，它将机器学习模型部署为 web 应用程序上的容器。
- 6a。(可选)创建应用服务环境
- 6b。创建 web 应用和应用服务计划
- 6c。创建发布管道
- 6d。将容器部署到 web 应用程序
- 6e。在 web 应用中启用 Azure Active Directory 身份验证
- 6f。在 Postman 中设置对 web 应用程序的身份验证
6a。(可选)创建应用服务环境
为了实现对您的 web 应用程序的完全网络隔离，应使用应用程序服务环境。在应用服务环境中部署的所有 web 应用和应用服务计划。
关于如何创建和使用互联网隔离的 Azure 应用服务环境的详细信息
docs.microsoft.com](https://docs.microsoft.com/en-us/azure/app-service/environment/create-ilb-ase)
请注意，应用服务环境的成本可能很高。本教程的其余部分也可以使用未部署在私有 ASE 中的 web 应用来完成，但是，web 应用将拥有一个公共 IP。
6b。使用 Azure CLI 创建 web 应用程序
执行以下命令行在 linux 中创建 Azure web。
az appservice plan create -g <<resource group>> -n devaisec-plan --is-linux --sku S1
az webapp create -n devaisec-app -g <<resource group>>
-p devaisec-plan -i elnably/dockerimagetest
6c。创建发布管道
在这一步中，容器被部署到 web 应用程序。转到“Pipelines”，选择“Releases”，然后选择“empty job”作为模板。更改名称，然后单击保存。
6c1. Create release pipeline
添加您想要在此管道中发布的工件。在这种情况下，选择从构建管道中创建的工件。确保您始终选择默认版本:最新
6c2. Add release artifact
最后，将两个变量组(在步骤 5c 和 5d 中创建的)也添加到发布管道中。转到发布管道中的变量，并链接两个组，就像在构建管道中所做的那样。
6d。将容器部署到 web 应用程序
转到发布管道并选择添加任务。然后，您将看到一个包含代理作业的屏幕。同样，您需要将代理池更改为 Hosted Ubuntu 1604。
6d1. Agent pool Ubuntu 1604
随后，通过搜索 Azure CLI 添加新任务。选择devopsaisec _ service _ connection作为服务连接，引用“41_deployImageToWebapp_sec.sh”作为脚本路径。然后通过引用变量$(rg-name)使用以下 3 个由空格分隔的参数:webapp 的名称、容器注册表的名称和资源组的名称。
6d2. Azure CLI to deploy container to web app
保存并关闭，然后选择创建发布管道。填写变量以创建发布。然后通过点击 deploy 按钮来部署发布。等待 5 分钟，然后检查状态是否从“未部署”变为“成功”。
6e。在 web 应用中启用 Azure Active Directory 身份验证
在此步骤中，使用 Azure 门户在 web 应用中启用 Azure Active Directory 身份验证。转到您的 web 应用，选择身份验证/授权，然后选择 Azure Active Directory。然后选择快速并使用与您的 web 应用程序相同的名称创建新的应用程序注册
6e1. Set up AAD authentication in web app
在此步骤之后，web 应用程序 URL 需要身份验证，并且不能被使用。
6f。在 Postman 中设置对 web 应用程序的身份验证
最后一步是设置工具邮差来验证网络应用。在下面的教程中，解释了如何做到这一点。
在 Postman to the 应用程序中设置 Postman 和客户端身份验证后，可以使用 HTTPS 端点来创建预测。可以在项目中的项目/services/50_testEndpoint.py 中找到一个示例负载。在本例中，预测了三个人的收入等级。
- 对第一个人的预测是收入高于 50k，
- 对于另外两个人，预测值低于 50k。
6f1. Postman with bearer authentication to consume API for predictions
7.结论
在本教程中，将为机器学习项目创建一个安全的端到端管道。在这个项目中，Azure Databricks 被用来创建一个机器学习模型，并将其作为一个端点部署在一个 web 应用程序上。端到端管道的保护如下:
- 使用 Azure Active Directory 对 Web 应用程序进行身份验证和授权
- 存储帐户和 Web 应用程序的网络访问控制列表
- 在 Azure 密钥库中安全存储密钥，并在构建管道中添加密钥滚动过程
这使公司能够 1)端到端地跟踪模型，2)建立对模型的信任，3)避免模型预测莫名其妙的情况，最重要的是 4)使用 AAD、VNETs 和密钥库保护数据、端点和秘密，另请参见架构概述:
7. Architecture overview
注来自《走向数据科学》的编辑: 虽然我们允许独立作者根据我们的 规则和指导方针 发表文章，但我们不认可每个作者的贡献。你不应该在没有寻求专业建议的情况下依赖一个作者的作品。详见我们的 读者术语 。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
