如何把完全交互式的、可运行的代码放到一篇中等的文章中
(Source)
代码应该是交互式的。
- 前往回复
- 用你最喜欢的语言写一些代码。
- 复制并粘贴你的回复到一个中等职位的网址。
- 发布帖子，使代码具有交互性。
Interactive code. In a Medium article! (from repl.it).
请随意使用上面的代码。这是一个简单的例子，但是您可以为读者创建复杂的脚本以在多种语言中运行。
笔记
- 代码只有在发布后才是完全交互的
- 您可以添加包、数据文件，或者在您的 repl 中包含多个脚本
- 这在手机上确实有效，尽管并不完美
- 每次重新加载页面时，都会安装软件包
除了在文章中嵌入代码，repl.it 还有一个很棒的论坛和互动练习来学习编码。
我欢迎评论、反馈或建设性的批评，可以通过 Twitter @koehrsen_will 联系。
如何(快速)建立 Tensorflow 培训渠道
如何在 Tensorflow 中建立一个高效的培训和管道，而不会在树林中迷路
Tensorflow 很棒。真的，你可以做任何你能想到的事情。你可以用它来打造真正的酷产品。然而，Tensorflow 的代码示例通常倾向于掩盖如何将数据输入到您的模型中:它们有时会天真地认为其他人已经为您做了艰苦的工作并将数据序列化为 Tensorflow 的原生格式，或者展示不合理的缓慢方法，这些方法会使 GPU 以低得惊人的性能闲置。此外，代码通常非常粗糙，难以遵循。因此，我认为展示一个小的、自包含的例子可能是有用的，这个例子在一个重要的例子上处理训练和有效的数据管道。
向张量流模型提供数据的 3 种方法:如何正确获取数据？
There are three paths to enlightenment. Or at least to feeding Tensorflow models with data.
在典型的 Tensorflow 中，有许多方法可以设置数据管道。本指南将快速列出前 3 项，并向您展示如何使用折衷方案，获得易于编码且对于 80%的用例来说速度惊人的解决方案。
一般来说，有三种方法可以将数据输入到模型中:
- 使用
feed_dict命令，使用输入数组覆盖输入张量。这种方法在在线教程中有广泛介绍，但是由于一系列原因，它的缺点是非常慢。最值得注意的是，要使用feed_dict，你必须在 python 中将数据加载到内存中，这已经否定了多线程的可能性，因为 python 有一个丑陋的怪兽，叫做全局 interperer 锁(又名 GIL )。使用feed_dict在其他教程中有广泛介绍，在某些情况下是一个很好的解决方案。然而，一旦你试图利用高容量的 GPU，你会发现你正在尽力利用它的 30%的计算能力！ - 使用 Tensorflow
TfRecords。我觉得在这里我可以大胆地说，卷入这场混乱十有八九是个坏主意。从 python 中序列化记录既缓慢又痛苦，反序列化它们(即读入 tensorflow)同样容易出错，需要大量编码。你可以在这里阅读如何使用它们。 - 使用 tensorflow 的
tf.data.Dataset对象。现在，这是一个很好的方法，但有太多不同的方法来使用它，Tensorflow 的文档在构建重要的数据管道方面并没有真正的帮助。这就是本指南的用武之地。
让我们看看现实生活中的用例，并建立一个复杂的数据管道，在一台具有潜在高容量 GPU 的机器上以惊人的速度进行训练。
我们的模型:基本的人脸识别
所以我们来处理一个具体的例子。假设我们的目标是建立一个人脸识别模型。模型的输入是 2 张图片，如果是同一个人，输出是 1，否则是 0。让我们看看一个超级天真的张量流模型如何完成这项任务
好吧，所以这个模型不会赢得任何历史上最佳人脸识别的奖项。我们只是取两幅图像之间的差异，通过标准的 conv-雷鲁-马克斯普尔神经网络输入这个差异图。如果这对你来说是胡言乱语，不要担心:这不是一个比较图像的好方法。请相信我的话，它至少在某种程度上能够识别同一个人的照片。模型现在需要的只是数据——这就是我们有趣的小帖子的重点。
那么我们的数据是什么样的呢？
数据
一个经典的(微小的)人脸识别数据集叫做标签为 野外人脸，你可以在这里 *下载。*数据很简单:你有一堆文件夹，每个文件夹都包含同一个人的照片，就像这样:
/lfw
/lfw/Dalai_Lama/Dalai_Lama_0001.jpg
/lfw/Dalai_Lama/Dalai_Lama_0002.jpg
...
/lfw/George_HW_Bush/George_HW_Bush_0001.jpg
/lfw/George_HW_Bush/George_HW_Bush_0002.jpg
...
我们可以做的一件事是生成所有可以想象的配对，缓存它们，并将其提供给模型。那会很高，会占用我们所有的内存，因为这里有 18，984 张照片，18，894 的平方是……很多。
因此，让我们构建一个非常轻量级的 pythonic 函数，它生成一对照片，并指示它们是否是同一个人——并在每次迭代中随机抽取另一对照片。
哇哦。但是我不是说过 python 对于一个数据管道来说太慢了吗？答案是肯定的，python 很慢，但是在随机抽字符串和喂它的时候，就足够爽快了。重要的是，所有的重担:阅读。jpg 图像，调整它们的大小，对它们进行批处理，对它们进行排队等等——这些都是在 pure Tensorflow 中完成的。
张量流数据集管道
所以现在我们只剩下在 Tensorflow 中构建数据管道了！事不宜迟:
所以基本上我们从 pythonic 生成器输出(3 个字符串)的字典开始。让我们来分析一下这里发生了什么:
- 让我们知道它将由我们的 pythonic 发电机提供能量。这一行根本没有评估我们的 pythonic 生成器！它只是建立了一个计划，每当我们的数据集渴望更多的输入，它将从生成器中获取它。
这就是为什么我们需要煞费苦心地指定生成器将要生成的输出的类型。在我们的例子中，image1 和 image2 都是图像文件的字符串，label 是一个布尔值，表示是否是同一个人。 map操作:这是我们设置所有必要任务的地方，从生成器输入(文件名)到我们实际上想要馈送给模型的内容(加载和调整大小的图像)。_read_image_and_resize()会处理好的。batchoperation 是一个方便的功能，它可以将图像批处理成具有一致数量元素的包。这在训练中非常有用，因为我们通常希望一次处理多个输入。请注意，如果我们从[128，128，3]维的图像开始，在该批之后，我们将得到[10，128，128，3]，在本例中，10 是批大小。prefetchoperation 让 Tensorflow 做簿记工作，包括设置队列，以便数据管道继续读取数据并对数据进行排队，直到 N 批数据全部加载并准备就绪。在这种情况下，我选择了 5，并且通常发现数字 1-5 通常足以充分利用 GPU 的能力，而不会不必要地增加机器的内存消耗。
就是这样！
现在一切都设置好了，简单地实例化一个会话并调用session.run(element)将自动获得img1_resized、img2_resized和label的实际值。如果我们点击session.run(opt_step)，那么一个新的数据将通过管道执行一个优化步骤。这里有一个很小的脚本，用于获取一个数据元素，并执行 100 个训练步骤来查看它是否全部工作
当你只把乔治·布什和达赖喇嘛作为类别时，这个模型收敛得相当快。下面是这次模拟运行的结果:
/Users/urimerhav/venv3_6/bin/python /Users/urimerhav/Code/tflow-dataset/recognizer/train.py
{'person1': 'resources/lfw/Dalai_Lama/Dalai_Lama_0002.jpg', 'person2': 'resources/lfw/George_HW_Bush/George_HW_Bush_0006.jpg', 'same_person': False}
{'person1': 'resources/lfw/Dalai_Lama/Dalai_Lama_0002.jpg', 'person2': 'resources/lfw/George_HW_Bush/George_HW_Bush_0011.jpg', 'same_person': False}
step 0 log-loss 6.541984558105469
step 1 log-loss 11.30261516571045
...
step 98 log-loss 0.11421843618154526
step 99 log-loss 0.09954185783863068
Process finished with exit code 0
我希望这本指南对你有用。github 上有完整的(微小的)代码回购。你觉得合适就随便用吧！
示例 2 —从产品图片中移除背景
稍后我可能会写一篇更详细的博文，但我应该注意到我最近的数据培训管道，我很喜欢我作为副业项目建立的一个名为 Pro Product Pix 的小型概念验证网站。这个概念很简单:电子卖家需要拍摄产品的照片，然后必须做一项费力的任务，即去除背景像素(这相当繁琐！).为什么不自动这么做呢？
但是获得有背景和没有背景的产品的标签图像是非常棘手的。所以:数据生成器来拯救！以下是我最后做的事情:
- 在只有一个物体存在的公共领域搜索图像(实际上有很多这样的东西——透明的 png 文件到处都是)
- 在 Bing 图片中搜索一些普通的背景模板，如“地毯”或“墙”
- 建立一个生成器，生成成对的背景文件路径+对象文件路径，将它们融合在一起。
- 让模型猜测哪些像素属于背景，哪些属于物体(以及一堆其他东西，但那是另一篇文章)。
总之，我们有很多这样的背景:
Bunch of backgrounds
我们把它们和没有背景的产品照片融合在一起
Random product photos
这里有一堆小问题要解决。对于 exmaple，背景通常比产品照片大得多，所以我们需要将背景照片裁剪到产品尺寸，然后将两张照片合并。整个管道有点复杂，因为它不是在编写教程的时候考虑的，但是我会把重点片段放在这里。我们有一个生成背景路径+产品路径的生成器
我们将背景加载为 rgb 图像，对象 png 实际上既有 rgb 图像，也有我们所说的透明贴图(我们称之为 object_pixels:它告诉我们哪些像素属于背景，哪些属于对象)。然后在我们的 dataset.map 操作中，我们随机裁剪一块背景，并将其与前景混合。
有时候，结果非常好。这里有一张我比较喜欢的之前/之后的照片，尽管它仍然不是 100%完美的:
我希望有一天我会找到时间写更多关于实际使用的模型。你可以在网站[这里](http://proproductpix.org)玩这个模型，但是要预先警告——这基本上只适用于类似真实产品照片的图片。其他的，都是垃圾进——垃圾出！
最初发布在霍斯科技博客(那是我的 ML 咨询公司)
如何用 Python 快速测试几十个深度学习模型
让我们开发一个神经网络装配线，使我们能够轻松地试验众多的模型配置。
Assembly Line of Neural Networks (Source: all_is_magic on Shutterstock & Author)
优化机器学习(ML)模型不是一门精确的科学。最佳模型架构、优化算法和超参数设置取决于您正在处理的数据。因此，能够快速测试几种模型配置对于最大化生产率和推动 ML 项目的进展是必不可少的。在本文中，我们将创建一个易于使用的界面，允许您这样做，类似于 ML 模型的装配线。
深度学习模型由一组超参数管理，我们可以创建对这些超参数进行归纳的函数，并建立临时模型。以下是控制神经网络的主要超参数:
- 隐藏层数
- 每层神经元的数量
- 激活功能
- 最优化算法
- 学习率
- 正则化技术
- 正则化超参数
我们可以将这些打包成一个哈希表:
model_info = {}
model_info['Hidden layers'] = [100] * 6
model_info['Input size'] = og_one_hot.shape[1] - 1
model_info['Activations'] = ['relu'] * 6
model_info['Optimization'] = 'adadelta'
model_info["Learning rate"] = .005
model_info["Batch size"] = 32
model_info["Preprocessing"] = 'Standard'
model_info["Lambda"] = 0
model_2['Regularization'] = 'l2'
model_2['Reg param'] = 0.0005
在我们开始试验各种模型架构之前，让我们将数据可视化，看看我们在做什么。虽然标准缩放是事实上的预处理方法，但我使用了各种预处理策略来可视化数据。我使用主成分分析和 t-SNE 来降低每种预处理方法的数据维数。以下是看起来最容易分离的数据可视化:
Source: Author
然后，我们可以定义一个函数，在给定超参数哈希表的情况下，该函数将构建和编译一个神经网络:
既然我们有了一种快速、灵活的构建和编译神经网络的方法，我们就可以快速测试一些基线模型。这使我们能够快速推断出哪些超参数似乎工作得最好:
使用上面的函数，在用五重交叉验证评估了十几个模型架构之后，我发现需要更深更宽的架构来获得数据的高性能。这很可能是由于我们数据的非线性结构。下图说明了收益递减。将每层中隐藏单元的数量从 15 个增加到 120 个，可以显著提高训练数据的性能，但实际上对测试数据没有任何影响。这是模型过度拟合的迹象，即训练集的性能不能概括测试数据。
旁白:如果你不熟悉 k-fold 交叉验证，这是一种模型评估技术，涉及到将数据分成 K 个不相交的分区。这些分区中的一个用作测试集，其余的用作训练集。然后我们遍历每个折叠，这样每个分区都有一个回合作为测试集。执行 k-fold 交叉验证使我们能够获得模型性能的可靠评估。
Source: Author
K-fold 交叉验证是一种评估模型性能的稳健方法，但需要注意的是，获得这些结果的计算成本很高。我们可以将数据分成训练和测试集，以在优化超参数的同时得出更快的启发，并在每个时期后保存模型，以便它们在训练后可检索。 Tensorboard 回调也可用于检查模型是如何被训练的:
一旦我们了解了哪些超参数设置工作良好，我们就可以获得更可靠的性能评估。
网格搜索不是行业中超参数优化的首选方法。相反，一种被称为由粗到细的方法被更频繁地采用。在由粗到细的方法中，我们从大范围的超参数开始，然后专注于最有效的参数设置。然后，我们从想要试验的狭窄范围的值中随机抽样超参数设置。既然我们有了动态实例化深度神经网络的方法，我们可以快速迭代众多模型配置:
旁白:当从你的终端调用 Tensorboard 日志目录时，你不能在文件路径中有空格。在 Windows 上，日志目录中的空格会阻止 Tensorboard 正确加载数据。
上面的代码还将每个模型的重要指标(例如 ROC 曲线下的面积)保存到一个 CSV 文件中，以便我们可以轻松地比较和对比哪些超参数会导致性能变化。
一旦我们对哪些超参数值工作良好有了更好的了解，我们就可以开始在这个值范围内优化模型。下面的函数生成一个随机化的神经网络。然后，我们可以使用该函数在我们缩小的值范围内试验各种随机超参数设置:
在本文中，我们学习了如何快速试验众多的模型架构和超参数设置。如果你喜欢这篇文章或学到了新的东西，请随时关注我或留下掌声。再次感谢！
源代码:此处
警告:
我在代码中发现了一个 bug，可能是 Tensorboard Keras 回调或者 build_nn()函数导致的。这不是一个主要问题，但我想和你讨论这个问题。问题是，在测试一系列神经网络时，会将多个图形写入 Tensorboard 日志文件。例如，当我们运行上面的“模型实验”代码时，我们得到了 model_1 的图形可视化:
Erroneous Graph (Source: Author)
正如您所看到的，这里有两个不同的图形:一个对应于 model_0(左)，一个对应于 model_1(右)。model_0 的图形不会发生这种情况，因为它是在 model_1 之前训练的:
Visualizing model_0 Architecture via Tensorboard (Source: Author)
然而，如果我们在训练之后加载 model_1，我们可以看到，对于我们传递给 build_nn()的哈希表，该架构是正确的:
print("Model 1")
saved_model = load_model(FILE_PATH)
print(saved_model.summary())Model 1
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
dense_8 (Dense) (None, 110) 10120
_________________________________________________________________
activation_8 (Activation) (None, 110) 0
_________________________________________________________________
dense_9 (Dense) (None, 110) 12210
_________________________________________________________________
activation_9 (Activation) (None, 110) 0
_________________________________________________________________
dense_10 (Dense) (None, 110) 12210
_________________________________________________________________
activation_10 (Activation) (None, 110) 0
_________________________________________________________________
dense_11 (Dense) (None, 1) 111
_________________________________________________________________
activation_11 (Activation) (None, 1) 0
=================================================================
Total params: 34,651
Trainable params: 34,651
Non-trainable params: 0
_________________________________________________________________
这表明使用该代码获得准确的评估没有潜在的问题，但是它不允许我们可视化管道中的模型。如果您有任何见解、建议或知道为什么会出现这种情况，请随时修改代码或告诉我。我想继续研究这个问题，但作为一名有三份兼职工作的全日制学生，我无法做到这一点。再次感谢阅读！
如何降低电子商务结账阶段的废弃率——A/B 测试电子支付方式
If SpaceX A/B Tests their Rockets, shouldn’t you at least A/B Test your Checkout Page?
随着电子商务公司不断寻找新的方法来提高他们的转化率，他们中的大多数人仍然不得不应对高比例的购物者放弃结账阶段的最后一步。即使顾客输入了个人信息，选择了送货方式，20-30%的顾客仍然会放弃付款页面。这就给我们带来了挑战:如何降低结账阶段的弃用率？
我花了几年时间，帮助世界上一些最大的电子商务商家，我相信一个更明显的答案在于 A/B 测试电子支付选项，以确定最高的转换组合。
电子支付系统如何工作
电子支付系统可以分为三种类型，基于信用，替代和数字钱包。
基于信用的电子支付系统使用信用卡/借记卡/预付卡接受和处理来自发卡机构的支付，如万事达、维萨、美国运通、 Discover/Diners 和银联。使用四方模型或三方模型，其中涉及发行者(向购物者提供信用卡/借记卡/预付卡)、收单方(以商家的方式处理交易)、商家(与网关集成以接受交易)和购物者(向商家发起支付)。
可供选择的电子支付系统有多种实施方式，但几乎都使用由第三方处理机构促成的直接银行转账，例如荷兰的 iDeal 和比利时的 Bancontact 。第三方处理器提供一方面与网关集成，另一方面与银行环境集成的技术，以启动从购物者到商家的资金转移。
数字钱包电子支付系统是像 PayPal 、谷歌钱包和 Apple Pay 这样的服务，它们作为中介接受和处理支付，并从转入账户或关联信用卡或银行账户的资金中进行内部贷记。与替代电子支付系统类似，数字钱包为网关提供 API 以集成其钱包或直接为商家提供集成选项。
哪种电子支付系统最常用？
根据国家的不同，零售中采用基于信用卡或借记卡的支付方式对所使用的电子支付系统有很大的影响。美国和英国的信用卡使用率很高，这导致大多数商家提供基于信用的电子支付方式。虽然荷兰和比利时等国家更喜欢使用借记卡，但这导致银行合作开发 iDeal 和 Bancontact 等替代支付选项，以防止万事达卡和 Visa 抢占更多市场份额。
导致采用电子支付系统的其他几个因素是安全性和易用性。这导致电子商务公司不得不提供多种支付方式。像 AirBnB、Amazon 和 Zalando 这样的公司都是以基于信用的电子支付系统起家的，但是随着他们的成长，电子支付方式已经适应了消费者的偏好。例如，AirBnB 接受信用卡、借记卡和预付卡，但在特定国家也接受 PayPal，在中国只接受支付宝，在意大利接受 Postepay ，在德国接受 Sofort ，在荷兰接受 iDeal，在印度接受 PayU ，在巴西接受 Boleto Bancário、 Hipercard 、 Elo 和 Aura。
A/B 测试电子支付选项
通过实施 A/B 测试，商家能够测试电子支付选项的不同组合。在任何 A/B 测试中，都有可以测试的变量。通过与世界各地的商家合作，我分析了我认为在 A/B 测试电子支付选项中最重要的变量。
如前所述，国家是电子支付方式可用性和接受度的重要组成部分。另一个变量是购买商品或服务时使用的 D 设备类型，无论是台式机、平板电脑还是手机。对于具有结账功能的应用程序，平台是另一个可以用于测试的变量，可以是 iOS (15%的市场份额)，Android (85%的市场份额)。
测试电子支付方式背后的数学原理
要确定添加额外的电子支付方式是否会对转换率产生影响，可以实施 A/B 测试。为了确定哪个版本是赢家，Z 测试可以计算 B 版本是否明显优于控制版本。
根据您的交易量，我建议您尝试达到 95%的置信度。
95%区间估计的公式如下:
在哪里
- p(hat) =我们的点估计
- 1.96 =对应于 95%显著性的正常曲线 Z 值估计值
- n =我们的样本量
这可以解释为有 95%的把握皮肤上的转化率介于:
95%的置信水平告诉我们，如果测试重复多次，并且计算了每次测试的置信区间，则 95%的置信区间将包含真实的转化率。前面处理的是单个样本。在 A/B 测试中，重点在于比较多个样本。为了凭经验确定在 A/B 测试中观察到的两个转化率之间的差异是否足够大，从而可以合理地归因于 A 和 B 之间的经验差异，而不是因为采样误差，必须计算两个比例的 Z 统计量。
如果给定的指标是一个百分比或一个比例，则测试统计由下式给出:
在其最基本的形式中，它可以被认为是被称为标准误差的总体变化的量度，可以通过下式计算:
对于两个比例，通过合并所有值，计算合并比例，然后根据两个样本大小进行归一化，可以获得标准误差。如果 X A 是第一个样本中转换的人数，第二个样本中转换的人数，则综合转换率由下式给出:
在计算检验统计量(Z)时，采取以下步骤:
基于这个测试统计，我们观察到的差异是由于随机机会的概率可以计算出来。该值称为 p 值，是某一点之前或之后标准正态(Z)分布下方的区域。如果 Z 值为负，则计算到该点为止的值，并乘以 2。如果 Z 值为正，则在该点之后计算该值，然后乘以 2。乘以 2 是所谓的双尾检验的应用。
对商家有什么好处
A/B 测试电子支付选项有很多好处
- 通过 A/B 测试电子支付选项，商家可以消除猜测工作，为客户提供正确的电子支付方式组合，并在此过程中降低支付页面的放弃率。
- 降低获客成本 :通过在结账流程的关键阶段降低弃购率，这直接提高了转化率。虽然获得客户的成本相同，但购买量降低了平均获得客户的成本。
- 更高的利润 :更低的废弃率等于更高的交谈率，这导致销售商品的收入和成本增加，但在相同的管理费用和广告成本下，这导致更高的利润。
随着购物者越来越习惯于在网上购买商品和服务，他们首选的支付方式可能会因国家而异。通过使用 A/B 测试，商家可以测试并找到每个国家和设备的电子支付选项的正确组合。通过降低结账过程中最关键部分的废弃率，商家将能够降低他们的客户获取成本并增加利润。
感谢阅读；)，如果你喜欢它，请点击下面的掌声按钮，这对我意义重大，也有助于其他人了解这个故事。通过在 Twitter、Linkedin 和 Twitter 上联系，让我知道你的想法。或者留下回应。
如何用基本的数据科学技术减少营销膨胀
在不损失客户的情况下减少营销支出
势头是营销策略中一个非常强大的因素。公司利用多年的经验来完善演示、流程和内容，以吸引新客户并让现有客户满意。
但是势头也会导致膨胀。随着组织推动自身前进，动力随着以新方式吸引客户的额外策略而增长。就像滚落山坡的雪球越滚越大，通信接触点越来越多。最终，营销势头有了自己的生命，从客户的角度来看，他们看到了大量的信息，这使他们更有可能忽略这一切。
人们退订邮件列表的首要原因是:“我收到太多邮件了。”第二个原因:“电子邮件与我无关。”—2016 年 12 月 MarketingSherpa“客户满意度调查研究”
势头不仅导致量上的膨胀，也导致目的上的膨胀。相比有针对性的信息传递，动量策略更倾向于对多个客户群有效的策略。即使每个营销人员都知道理论上专注是至关重要的，但在实践中却很难实现。
“能够个性化网络体验的营销人员看到销售额增加了 20%……但大多数人不知道如何去做。”— 经济咨询/货币化
求解雪崩的动量并不容易。你如何在不危及你辛辛苦苦创造的成功的情况下撤回战术？当通用的遗留方法看起来足够有效时，您如何将策略与受众群体相匹配？
有答案，使用已建立的机器学习方法，世界上最大的品牌每天都在做。对于较小的组织来说，这项任务似乎更加艰巨。值得努力吗？答案很简单:如果你能节省 50%的营销成本，但能取得更好的效果，你会这么做吗？
减少营销膨胀的两步法
第一步:通过随机对照实验消除浪费
有时，为了做出高效的决策，有必要抛开一些你对客户的了解。随机对照实验通常与临床试验相关，在市场营销中同样有效。类似于 A/B 测试，随机控制实验使得测试现有营销策略对无所作为的影响成为可能。关键是控制两组都暴露的因素，并随机选择测试组(而不是基于分段)。随机化可以让你考虑选择偏差，如果进行得正确，实验可以告诉你你在哪里花了不必要的钱。
如何进行随机对照营销实验
- **选择一个变量进行测试:**哪种策略可能是多余的？还是很贵？
- **选择相关受众:**要考一段还是多段？
- **最终确定假设:**你想测试什么理论？例如，“取消我们的客户简讯不会影响客户保留率。”或者“这个新的和改进的策略将增加 10%的转化率。”
- **说明破坏性因素:**哪些因素会破坏实验？例如，重叠策略可能会触发误报。
- **完成实验流程:**确保因果关系尽可能清晰，并有清晰的协议和结果跟踪。
- **初步研究:**用随机划分的试验组和对照组进行一个小实验，使风险最小化。
- R **evise 流程:**将您在试点研究中学到的东西应用到修订后的流程中。
- **扩大实验:**对更大的受众重复实验。
- **分析结果:**寻找哪些符合你的假设，哪些不符合。
关于随机对照实验的一个很好的概述，见 Amy Gallow 在哈佛商业评论上的精彩文章。
第二步:使用预测分析最大化收益
预测分析的最佳用途之一是决定不向谁营销。换句话说，你可以使用预测分析来创建一个规模更小、成本更低、转化率更高的营销活动。使用二元逻辑回归等基本预测方法或随机森林决策树等更高级的技术，您可以创建一个预测模型，该模型使用历史数据来确定您的客户群中谁最有可能在未来对给定的营销策略做出反应。
通过对积极响应的可能性进行评分，您可以将营销活动集中在最高收益目标上。例如，你可以决定只针对列表中得分最高的 20%的部分，如果你针对所有人，仍然可以获得 80%的最佳结果。这种方法在像直邮这样的高成本策略中特别有效，但在电子邮件过载的危险不断增加的电子邮件营销中也同样适用。
在不损失客户的情况下减少营销膨胀并不难——只需要一个考虑到迭代改进的深思熟虑的实验过程。当然，还有挑战现状的欲望。
如何在云中运行定制的 Tensorflow 培训
您的 Tensorflow 代码在本地运行。现在，您希望在生产环境中设置它，以获得所有额外的 GPU 功能。有两种选择。比较流行的两个托管 ML 云平台是 Google Cloud ML Engine 和 AWS Sage Maker。它们让您快速部署您的模型并训练它们。但是，您可能想要构建一个更加定制化的解决方案。为此，您可以使用 AWS 批次。
为什么 AWS 批量？
这里的主要思想是尽可能降低成本，同时仍然利用 GPU 的能力。持续运行 GPU 实例会产生巨大的成本。AWS batch 使用一个作业队列，并根据作业需求扩展实例。因此，如果没有作业，就没有正在运行的实例。通过使用点实例，您可以进一步降低运行培训工作的成本。
先决条件:
- AWS 账户:https://aws.amazon.com/console。
- 用于部署的 AWS 命令行:https://aws.amazon.com/cli/。
- https://docs.docker.com/install/。
构建 Docker 映像
AWS 批处理需要一个 docker 映像，您的 Tensorflow 训练代码将在其中运行。Dockerfile 文件如下。
- 安装所需的相关 cuda 基础映像和库，从这里获取https://github . com/tensor flow/tensor flow/blob/master/tensor flow/tools/docker/docker file . GPU(版本可能会有所不同)。
- 复制您的代码使用的 Pipfile 并将其安装在映像上。Pipfile 也应该包含 Tensorflow 版本。
- 设置相关的环境变量。
- 复制获取并运行脚本，该脚本将在 s3 上获取一个 shell 脚本(稍后将详细介绍)来处理 Tensorflow 代码的运行(也驻留在 S3 上)。
$RUN_SCRIPT 参数将作为环境变量传递给 AWS 批处理作业。
接下来，构建映像并将其推送到 docker 存储库，以便批处理作业可以访问它。
> docker build -t $DOCKER_IMAGE_TAG aws_batch_image
> docker push $DOCKER_IMAGE_TAG
aws_batch_image 是一个包含 docker 文件以及获取和运行脚本的文件夹。
建立 AMI
Tensorflow 依赖于特定的 NVIDIA 驱动程序和软件包来运行。你可以使用 AWS Deeplearning AMI ，它附带了一组预装的驱动程序，或者你也可以自己构建一个。我将通过各种步骤来构建您的自定义 Tensorflow AMI。
创建一个 GPU 基础 AMI
从 Amazon EC2 仪表板创建 Amazon Linux AMI。我们将使用带有 16GB 通用 SSD 卷存储的 p2.xlarge 实例。确保生成一个定制的密钥对，您可以用它来 SSH 到实例中。
安装 NVIDIA 驱动
首先使用以下命令将 ssh 连接到您的实例。
> ssh -i custom-key-pair.pem ec2-user@<Public DNS>
运行以下命令。
# Update package cache and get package updates
> sudo yum update -y# Installs gcc compiler and kernel header package
> sudo yum install -y gcc kernel-devel-$(uname -r)
接下来，我们需要安装基于 Tensorflow 版本的 NVIDIA 驱动程序。P2 实例包含特斯拉 K-80 GPU 的。我们将使用与 CUDA Toolkit 8.0 兼容的 Tensorflow 1.3。你可以使用这个链接帮助找到兼容的驱动程序http://www.nvidia.com/Download/Find.aspx。我们将使用版本 367.106。
下载驱动程序安装文件。
> wget http://us.download.nvidia.com/XFree86/Linux-x86_64/367.106/NVIDIA-Linux-x86_64-367.106.run
运行安装文件，然后重新启动。
> sudo /bin/bash ./NVIDIA-Linux-x86_64-367.106.runVerifying archive integrity... OKUncompressing NVIDIA Accelerated Graphics Driver for Linux-x86_64 367.106............................................................................................................................................................................................................................................................................................................................................................................................................................................................................................................> sudo reboot
SSH 到您的实例中，并运行以下命令来测试驱动程序是否安装正确。
> nvidia-smi -q | head==============NVSMI LOG==============Timestamp : Tue Apr 10 11:01:04 2018Driver Version : 367.106Attached GPUs : 1GPU 0000:00:1E.0Product Name : Tesla K80Product Brand : Tesla
如果您选择的驱动程序不起作用，请尝试使用不同的版本。
配置 nvidia-docker
NVIDIA Docker RPM 安装将 NVIDIA 驱动程序复制到 AWS 批处理作业中 Docker 容器的正确位置所需的组件。
用以下内容创建一个 bash 脚本文件。
运行该脚本，验证您可以运行 docker 容器，并使用以下命令访问已安装的驱动程序。
> ./configure_nvidia_gpu.sh> sudo docker run --privileged -v /var/lib/nvidia-docker/volumes/nvidia_driver/latest:/usr/local/nvidia nvidia/cuda:8.0-cudnn6-devel nvidia-smi
您应该得到类似于下面的输出。
删除实例上的 docker 容器和映像，以减小 AMI 的大小。
> sudo docker rm $(sudo docker ps -aq)
> sudo docker rmi $(sudo docker images -q)
从实例中创建 AMI
- 首先，创建图像的快照。可以参考这里https://docs . AWS . Amazon . com/AWS C2/latest/user guide/EBS-creating-snapshot . html。
- 从 EC2 仪表板中选择您的实例，并选择操作、图像、创建图像。
- 如下填写字段(我已经将快照 ID 和实例 Id 变白)。
4.单击创建图像。
您的 ami 现在应该显示在 AMIs 部分。状态变为可用可能需要一段时间。
设置 AWS 批
先决条件
- 创建 AWS 批处理服务角色。参考这里的获取信息。
- 创建一个 ecsInstanceRole。参考此处的获取信息。
- 创建一个 EC2SpotFleetRole。参考此处获取信息。
- 创建一个 EC2 密钥对。参考此处获取信息。
- 创建一个 EC2ContainerServiceTask 角色，并为其附加一个 AmazonS3FullAccess 策略。
AWS 批处理可以通过 GUI 或命令行设置。我们将通过命令行完成设置过程。如果你想通过图形用户界面来设置它，请遵循这里的教程并填写下面给出的信息。
创建计算环境
创建一个 JSON 文件来指定计算环境的各种属性。
类型:我们选择 managed，因为我们希望 AWS Batch 负责调度和管理资源。
状态:表示您现在是否想要激活。我们将其设置为 enabled。
计算资源:
- 类型:现场实例或按需实例。选择 spot 实例以降低成本。
- 这是你在上面创建的舰队角色的 arn。
提示:您可以使用 cli 获取您的角色的 arn，如下所示。
> aws iam get-role --role-name aws-batch-spot-fleet-role --query 'Role.Arn' --output text
- minvCpus :不管作业需求如何，要维护的虚拟 CPU 的最小数量。为了节省成本，我们将其设置为零。
- maxvCpus :我们希望作业运行的虚拟 CPU 的最大数量。
- desiredvCpus :计算环境在启动时应该拥有的虚拟 CPU 的数量。随着需求的增加或减少，AWS 批次的数量将在最大值和最小值之间进行调整。
- 实例类型:要启动的 EC2 实例的类型。我们将把它设置为 p2.xlarge(我们用来创建 AMI 的同一个实例)。
- bidPercentage :实例启动前，现货实例价格与该实例类型的按需价格相比必须达到的最大百分比。
- **子网:**要在其中运行批处理实例的虚拟私有云(VPC)子网。
提示:您可以从 cli 查询您的子网 id，如下所示:
> aws ec2 describe-subnets
- **security groupid:**您希望应用到您的实例的安全组的标识符，例如 SSH 访问。
提示:您可以从 cli 查询您的安全组 id，如下所示。
> aws ec2 describe-security-groups
- ec2KeyPair: 用于 SSH 进入实例。将其设置为您在上面创建的值。
- instanceRole :将其设置为您在上面创建的角色的名称。
serviceRole: 将其设置为您在上面创建的角色的名称。
运行以下命令创建计算环境。
> aws batch create-compute-environment --cli-input-json file://<path_to_json_file>/compute_environment_spec.json
您应该会得到类似下面的输出。
创建作业队列
创建一个 JSON 文件来指定作业队列参数。
jobQueueName: 作业队列的名称。
**状态:**表示您希望它现在激活。我们将其设置为 enabled。
**优先级:**当与相同的计算环境相关联时，优先级参数具有较高整数值的作业队列首先被评估。我们使用单独的计算环境进行培训，因此我们只将其设置为 1。
计算环境清单:
- **顺序:**作业调度器使用该参数来确定哪个计算环境应该执行给定的作业。
- **计算环境:**计算环境的名称。
运行以下命令创建作业队列。
> aws batch create-job-queue --cli-input-json file://<path_to_json_file>/job_queue_spec.json
输出应该如下所示。
登记工作定义
创建一个 JSON 文件来指定作业定义参数。
**作业定义名称:**作业定义的名称。
**类型:**作业的类型。目前只支持容器类型。
容器属性:
- **图片:**你上面创建的 docker 图片的标签。
- **vcpu:**工作所需的 vcpu 数量。
- **内存:**作业所需的内存。
- jobRoleArn: 您在上面创建的 EC2ContainerServiceTask 角色的 Arn。
- **卷:**传递给 docker 守护进程的卷。
- **主机:**数据卷在容器上的位置。我们将把它指向我们在 AMI 上安装的 NVIDIA 驱动程序。
- **名称:**卷的名称。
- **挂载点:**容器中卷的挂载点。
- containerPath: 容器上装载主机卷的路径。
- sourceVolume: 上面提到的源卷的名称。
- privileged: 这赋予容器在主机容器实例上的根特权。
- **重试策略:**重试失败作业的策略。
- **尝试次数:**运行作业的尝试次数。我们将它设置为 1，这表示如果失败就不会重试。
使用以下命令创建作业定义。
> aws batch register-job-definition --cli-input-json file://<path_to_json_file>/job_definition_spec.json
输出应该如下所示。
设置代码
- 在 Tensorflow 代码文件夹中创建运行脚本，如下所示
$ SCRIPT _ DIR:S3 目录路径，包含运行培训的所有脚本。
$MODEL_DIR:存储检查点的 s3 目录路径。
$EXPORT_PATH:保存训练好的模型的 s3 目录路径。
$TRAINING_DATA:包含训练数据的 CSV 的 s3 路径。
$TEST_DATA:包含测试数据的 CSV 的 s3 路径。
批处理作业将通过环境变量传递这些变量的值。
2.将您的 Tensorflow 代码、训练数据和测试数据上传到 s3 中的文件夹。(样本训练代码和数据可参考 https://github.com/vigbk/tensorflow-ami-example的
运行批处理作业
创建以下 JSON 来指定批处理作业参数
按如下方式运行批处理作业。
aws batch submit-job --cli-input-json file://<path_to_json_file>/batch_job_spec.json
作业输出应该如下所示。
您可以通过 Amazon CloudWatch 控制台查看您的作业日志，或者使用以下命令从 cli 获取它
> aws logs get-log-events --log-group-name /aws/batch/job --log-stream-name TrainModel/default/876da822-4198-45f2-a252-6cea32512ea8--query events[*].message --limit 100
这就是所有的人…
有许多即插即用的解决方案可以在云中使用 Tensorflow 管理培训，但我希望这篇文章能够让您了解如何定制 Tensorflow 培训，从而在不牺牲性能的情况下降低成本。
如果你喜欢这篇文章，请随意点击“鼓掌”按钮👏帮助其他人找到它。
参考文献:-
- https://docs . AWS . Amazon . com/batch/latest/user guide/batch-GPU-ami . html
- https://docs . AWS . Amazon . com/AWS C2/latest/user guide/install-NVIDIA-driver . html
我是啰嗦的项目维护者之一，这是一个数据转换库。帮助我们在 GitHub 上宣传这个项目:https://github.com/productml/blurr
如何在亚马逊云上或没有监视器的情况下运行 Unity
经过几天的咒骂和诅咒，我设法让我的 Unity 应用程序在一台“无头”Linux 机器上运行和渲染，这台机器没有物理显示器。最终甚至在亚马逊云上！
最后，所有的问题都是由于 Unity 的而不是，而是配置操作系统和驱动程序的问题。一旦我设法让 OpenGL 样本 glxgears 在没有监视器的情况下运行，Unity 也能运行。
TL；DR: 给我准备好使用使用 GPU 的亚马逊磁盘镜像。
为什么有人想在没有显示器的情况下运行 Unity 应用程序？
如果你正在与机器学习合作— 教学代理通过查看像素来玩 Unity 游戏或在 Udacity 自动驾驶汽车模拟器中驾驶。如果你用合成图像来扩充训练集，或者简单地为你的电影渲染大量的帧，你可能想要在远程服务器上运行，在云中运行，或者至少在你自己的桌面上隐藏烦人的窗口。
你仍然需要渲染循环运行和 GPU 工作，所以通常的方法来运行 Unity 作为一个服务器是行不通的。
Linux 来拯救我们了！
在没有显示器的服务器上运行带有图形的 Unity 应用程序
假设你有 Linux box(我在 Ubuntu14.04) 上测试过)并且已经安装了 NVIDIA 驱动程序并且可以工作。
剩下的工作非常简单——配置虚拟显示器，运行 X 服务器，并确保在与 X 相同的显示器上启动应用程序:
在本地机器上运行 Unity 应用程序
当您的 DeepQ 代理正在学习时，隐藏烦人的窗口很有用。
安装虚拟和虚拟。xduminum 将在屏幕外创建新的虚拟显示，VirtualGL 将捕获传入的 OpenGL 调用，并在真实的 GPU 上执行它们。参见说明:
在亚马逊云上运行带有图形的 Unity 应用程序！
现在最有趣和最有价值的部分——在亚马逊弹性计算云(亚马逊 EC2) 上运行 Unity。
亚马逊提供了几个 GPU 选项:旧的 g2 实例和更快的 p2 实例。到目前为止，我在使用 Ubuntu 14.04 的 g2.2xlarge 单 GPU 实例上测试了以下内容。
最复杂的部分是找到正确的 NVIDIA 驱动程序，可以支持云上的 GPU。到目前为止，我发现 367.57 和 340.46 正在使用位于 g2 实例内部的 GRID K520 GPU。然而，安装程序有一个问题——它忘记将总线 ID 添加到配置中——需要手动修补文件。
你需要禁用 Ubuntu 自带的新驱动程序。他们对可怜的 K520 没有任何好处。
除此之外——构建并安装 X 服务器，设置虚拟显示并启动 X。
您的应用程序应该准备好在与 x 相同的显示器上启动。
如果你想知道更多关于 NVIDIA 驱动安装的细节，请关注:https://askubuntu . com/questions/429596/how-to-choose-the-VGA-when-setting-the-x-server/534622 # 534622
准备使用亚马逊启动映像
如果你不能被上面的步骤所困扰，那也没关系。我为你创建了可以在 Amazon 上运行 Unity 或任何其他 OpenGL 应用程序的引导磁盘映像(AMI)。
图片包含 Ubuntu 14.04，NVIDIA 驱动 367.57。在启动时，它用虚拟显示器启动 X 服务器。当然，所有的 OpenGL 调用都将在 GPU 上执行。
图像名为: Ubuntu 14.04，带有针对 GPU 加速 OpenGL 的虚拟显示设置，可在以下位置获得: us-west-1 、 us-west-2 和 us-east 。
要在亚马逊云上找到它，只需在 AMI 搜索栏中键入“ Ubuntu GPU ”或使用链接:https://console.aws.amazon.com/ec2/v2/home?region = us-west-1 # LaunchInstanceWizard:ami = ami-921 C40 f 2
PS: 出于测试目的，你可以下载我的小 Unity app，它会渲染一些盒子，抓取截图并写入磁盘:【https://www.dropbox.com/s/abycjktjzmkrmb4/auto.zip?dl=0】
如何破坏你的第一个生产模型？
我听过很多关于生产中数据科学的恐怖故事。细节很重要，有两个潜在的危险直到为时已晚才显现出来。
Source: unsplash.com
Jason Bell 提供了数据科学模型如何在“数据科学最忽略的东西”中失败的很好的例子。
在这些例子中有两个主要的失败。一是问错了问题。另一个是使用了错误的评估程序。可惜这些技巧很难掌握，有很多微妙的层次。
问错误的问题
Jason Bell 指出，我们需要思考我们认为什么是胜利。"谷歌的广告活动会带来销售线索吗？"vs .“谷歌广告活动是否带来了销售线索，从而增加了销售额？”
谷歌“亚马逊”，第一个广告通常是亚马逊。算法做的好吗？我不这么认为。在这种情况下，人们不会受到广告的影响，但他们仍然会点击它。这是最糟糕的！
有许多创造性的方法来问错误的问题，但是我将直接跳到一个解决方案。
当我们建立一个模型时，我们应该考虑如何使用我们的结果。一个成功的模型将提供信息或做出决定。这一决定可以说是一种干预或政策选择。从这个角度来说，借用节目评测的一些思路是有意义的。
项目评估着眼于项目和政策的效率和效果。该规程要求我们提出以下问题:
- 我们的模型所提供的干预是否有必要？
- 我们是否对干预将如何影响下游结果以及上游情景如何影响干预有了可行的理解？
- 干预的实施是否会反映我们心中的设计？
- 我们如何衡量干预是否成功？我们看到的是正确的结果吗？
- 干预的好处是否证明实施所需的成本是合理的？
一般来说，一个完整的项目评估是一个漫长的考验。然而，简单地询问这些问题并与最终用户交流将会避免许多概念性错误。
使用错误的评估程序
模型评估背后的直觉非常简单。我们希望根据其在生产条件下的表现来选择最佳型号。如果我们不能在生产中测试，我们最多只能模拟生产条件。我们将我们的数据分成训练数据和测试数据，以基于过去的数据来模拟未来的条件(参见交叉验证)。
做好这一点非常困难。选择合适的评估指标和无偏见的数据样本需要仔细关注。
错误的评估指标
选择错误的评估指标是一个常见的问题，与问错误的问题有关。这不是一个困难的选择，我们只需要仔细考虑结果变量和用例。当我们解决了错误的问题时，花哨的模型和 rockstar 编程并不重要。
我不禁想起了史蒂夫·斯基纳的《算法设计》手册中的“如何设计算法”一章。
我真的理解这个问题吗？
(a)投入具体包括什么？
(b)确切的预期结果或产出是什么？
©我能否构建一个足够小的输入示例，以便手动解决？当我试图解决它时会发生什么？
(d)我总能找到最佳答案对我的应用程序有多重要？我能满足于接近最优的答案吗？
(e)我的典型问题有多大？
(f)速度对我的应用程序有多重要？
(g)我可以在实施上投入多少时间和精力？
取样偏差
机器学习模型只有在它们被训练的环境与它们被使用的环境相同时才起作用。上下文只是意味着我们的训练数据代表了我们的生产数据。如果我们的训练数据不符合我们的用例，我们就有一个采样偏差问题。换句话说，我们收集了错误的训练数据。
采样偏差是无声的。它在数据收集、数据清理、特征工程和决策制定过程中悄悄潜入。
数据采集
在数据收集过程中，我们必须处理有限的数据，可能会选择与生产条件不匹配的样品。例如，我们可能会无意中使用现有的客户数据来预测新客户的行为。
不幸的是，存在一种选择偏差效应，某些类型的人成为现有客户，并意味着新客户的行为会有所不同。我们从现有客户那里学到的经验，对新客户来说只有很小的机会。
数据清理
在数据清理期间删除有问题的行来提高模型的性能是很诱人的。想象一下，将客户评论分为正面和负面情绪，有些评论太短，无法做任何有用的事情。
如果我们从测试数据和训练数据中删除所有非常短的评论，那么由于模糊性的减少，我们的模型很有可能会做得更好。然而，在生产系统中，我们将不得不处理简短的评论，我们的模型针对错误的上下文进行了优化。
让简短评论成为特例本身并没有什么错，但是我们的评估程序应该反映这种变化。开箱即用的评估程序会夸大我们模型的准确性。
特色工程
在特征工程和 ETL 过程中，我们经常想要生成数据的集合，比如均值、中位数等。需要为训练和测试数据分别生成这些聚合。
如果我们或其他人对整个数据集进行平均，那么我们会在测试过程中暴露训练数据中有关“未来”的信息。其结果是，我们会夸大我们的模型的有效性。即使训练和测试数据中的平均值几乎相同，这也是一个问题。
决策
决策给模型构建增加了一个奇怪的转折。当基于我们的模型做出决策时，它可能会影响我们建模的结果或我们使用的功能。在生产中评估我们的模型变得困难，并且在我们使用的数据中引入了抽样偏差。
当我们重用一个模型时，这就成了一个问题。我们在特征变量和结果变量之间引入反馈效应。
想象一下，一所大学决定为可能不及格的学生实施预警系统。根据学生过去的课程，我们会在注册时发出警告，以阻止学生注册，如果他们可能会失败。让我们假设识别学生的模型做得非常好。
第一学期，这种模式发挥了作用，提高了课程的通过率。更令人鼓舞的是，那些对自己有把握的学生忽略了警告，并经常成功地上了课。那些对自己没有信心的学生没有选修这门课，从而避免了不及格。
当我们再次尝试应用我们的模型时会发生什么？
如果我们使用旧模式，我们的信息可能会过时。它也从未见过无视警告系统的学生。他们是否与之前的学生群体有足够的差异，从而导致不准确？
如果我们训练一个新的模型呢？因为新的通过率更高，所以肯定会有不同的结果。背景也发生了变化，因为关注预警系统的学生不再反映在数据中。
不要放松警惕
如果您有幸拥有一个将用于生产的模型，请花一点时间考虑这些问题。它们不是复杂的想法，但却经常被忽视。大多数问题会在您处理数据时出现，但只有在有人尝试使用您的模型后才会出现。
如果您觉得这很有帮助，请推荐并分享，点击💚这样其他人就能看到了。
如何用机器学习节省 HR 的时间
上周末，我参加了 WNS 分析向导 2018 ，机器学习在线黑客马拉松。在 72 小时内，1000 多名参与者解决了 WNS 分析公司的一个任务。在这篇文章中，我将描述一种技术方法，它帮助我在这次活动中获得了第四名，并给你一些关于我的解决方案的商业价值的想法。
挑战简介
在这场竞争中，我们的客户是大型跨国公司 WNS 分析公司。他们想让我们找到合适的人选来升职。目前，这一过程包括几个步骤:
- 他们首先根据推荐和过去的表现确定一组员工；
- 被选中的员工将接受每个垂直行业单独的培训和评估计划。这些计划基于每个垂直行业所需的技能；
- 在计划结束时，根据各种因素，如培训绩效、KPI 完成情况(仅考虑 KPI 完成率高于 60%的员工)等。，一名员工获得晋升。
The pipeline of a promotion process
正如你可能猜到的，整个过程需要很多时间。加快速度的一个方法是在检查点确定合适的候选人，这样公司可以节省时间和金钱。我们将使用数据驱动的方法来预测候选人是否会被提升。我们的预测将基于员工从提名晋升到关卡的表现以及人口统计特征的数量。
竞赛问题被公式化为一个二元分类任务，评价指标是 F1 得分。训练集包括 54808 个样本，测试集包括 23490 个样本。只有 8.5%的员工被推荐晋升。
Dataset features explanation
验证策略
验证策略在所有数据驱动的任务中至关重要，尤其是在竞赛中。在比赛开始时，我假设测试数据来自不同的分布，然后是训练数据。如果训练/测试分割是由某个时间变量完成的，而组织者并没有提供该时间变量，则可能会出现这种情况。在这种情况下，StratifiedKFold进行的简单验证得出的分数可能会高估我们的真实分数和在排行榜上的预期位置。
我决定根据属于测试集的可能性，将训练数据集分成若干部分。这是一种简单而强大的技术，用于处理训练/测试零件中的不同分布。这种方法的思想很简单:在解决任何机器学习任务之前，我们计算每个训练样本出现在测试集中的可能性。它允许我们:
- 确定明显区分训练数据集和测试数据集的特征。这些特征经常导致过度拟合(即它们是无用的)，我们可能会丢弃它们以增加模型的分数。此外，我们可能会从这些特性的本质中获得一些见解；
- 确定与测试示例非常相似的训练样本(即“异常值”)。我们可以照亮这些样本，在训练期间给它们较低的权重，或者在训练和验证期间给它们较低的权重。根据我的经验，它总是在验证和排行榜上增加一个分数；
- 进行更好的验证。我们希望我们的验证折叠具有与测试集完全相同的分布(这正是验证的理念)。通过在折叠中随机分割训练，我们可能会在这样一种情况下结束，其中几个折叠由与测试集相似的例子组成。我们不能依赖这种分裂的分数，因此我们的验证是无用的。通过作为测试集的一部分的相似性进行划分可以帮助我们克服这个问题。
为了执行这项技术，我添加了一个新的特性:is_test，它等于训练部分的0和测试部分的1。我将两个数据集结合在一起，预测了新的目标— is_test。
import pandas as pd
import numpy as np
from scipy.stats import rankdata
from [sklearn.model_selection](http://scikit-learn.org/stable/modules/classes.html#module-sklearn.model_selection) import cross_val_predicttrain['is_test'] = 0
test['is_test'] = 1
train_examples = train.shape[0]
train = train.drop('is_promoted', axis=1)
data = pd.concat([train, test], axis=0).reset_index(drop=True)data_x = data.drop('is_test', axis=1)
data_y = data['is_test']is_test_probs = cros_val_predict(some_ml_model, data_x, data_y, method='predict_proba')[:train_examples]train['is_test'] = rankdata(is_test_probs)
bins = np.histogram(train['is_test'])[1][:-1]
train['is_test_bins'] = np.digitize(train['is_test'], bins)# use 'is_test_bins' as stratification
然而，这种方法在这次比赛中并没有帮助我。该任务的 AUC 分数约为 0.51，这清楚地表明分类器不能区分训练和测试部分(测试数据类似于训练数据)。我决定用 11 折的StratifiedKFold来代替。
预处理和特征工程
我用一个新的类别missing填充了education和previous_year_rating中缺失的值。所有其他要素都没有缺失值和异常值，该数据集使用起来非常舒适。
我添加了一些特征，作为分类特征和与员工年龄相关的特征的组合，它们略微增加了分数:
train['work_fraction'] = train['length_of_service'] / train['age']
test['work_fraction'] = test['length_of_service'] / test['age']train['start_year'] = train['age'] - train['length_of_service']
test['start_year'] = test['age'] - test['length_of_service']
此外，我注意到avg_training_score是分类器的一个重要特性，所以我创建了一堆带有分类特性和avg_training_score的组合。例如，新特性avg_training_score_scaled_mean_department_region是avg_mean_score除以特定地区和部门的平均分数的结果。从下图中可以清楚地看到，这种类型的归一化对于分类器来说是一个很好的特性。一个人的分数高于所在部门的平均水平，就有更大的机会得到提升。
The distributions of avg_training_score for a positive and negative target are presented on left figure. The distributions of avg_training_score divided on the mean scores of each department_region are presented on the right figure
为了使我的模型多样化，我使用了几种方法来处理分类特征:标签编码、一键编码和均值编码。均值编码通常会增加具有多层次分类特征的任务的得分。但另一方面，平均值编码的不正确使用可能会损害分数(见下图)。均值编码的正确方法是将数据集分成几个折叠，并在每个折叠内分别执行均值编码。
Results of playground experiments with Click-Through Rate Prediction dataset and mean encoding (LogLoss metrics). The wrong approach to mean encoding will gradually increase CV score, but dramatically decrease leaderboard score
训练有素的模特
我在 11 个折叠(总共 55 个模型)上用不同的预处理策略训练了 3 个 CatBoost 和 2 个 LightGBM:
- CatBoost — 1
旧功能+标签编码 - CatBoost — 2
旧功能+新功能+标签编码 - CatBoost — 3
旧功能+新功能+平均编码 - LightGBM — 1
旧功能+新功能+ MeanEncoding - LightGBM — 2
旧功能+新功能+ OHE
对于每个模型，我在StratifiedKFold中对不同的模型使用了不同的种子(只要我不打算堆叠，那就可以了)。对于每个折叠，我根据折叠的 F1 分数来确定最佳阈值。最后的预测是 55 个模型的主要投票。最佳单个模型的交叉验证 F1 得分为 0.5310，最终模型为 0.5332，私人得分为 0.5318(公共排行榜第 20 位，私人排行榜第 4 位)。永远相信你的简历！
Row-wise normalized confusion matrix of the best submit, F1 score is equal to 0.5432
总结
我们如何解释这场比赛的结果？我认为有很大的改进余地。首先，我认为问题的焦点应该从“谁应该被提升？”到“员工必须做些什么才能获得晋升？”。在我看来，机器学习工具应该为一个人指明道路，这样他就会有清晰的理解和动力在工作中取得成功。一个小小的焦点改变会让一切变得不同。
第二，在我看来，即使是最好的模型，分数结果也是相当差的。如果它的性能比人更好，这可能是有用的，但 WNS 分析公司可能会考虑在决策过程中添加更多数据。我说的是增加更多与促销过程无关的功能，而是在促销过程开始之前，增加与员工工作相关的 KPI。
最后，我为这次比赛的结果感到高兴。对我来说，这是一场很好的比赛。在这次竞赛中，我已经在真实世界的数据集上测试了几个想法；设置半自动管道进行混合和堆叠；处理数据，并完成了一些明显的特征工程以外的工作。
更别说很好玩了:)
如何扩展您的机器学习管道
使用 Luigi、Docker 和 Kubernetes 并行化和分发您的 Python 机器学习管道
kurzgesagt.org
本文介绍了将您的机器学习应用程序从简单的 Python 程序转变为运行在集群上的可伸缩管道的最简单方法。
查看 Github 库中现成的示例代码。
您将学到的内容:
- 如何使用
[luigi](http://luigi.readthedocs.io/)管理任务 - 如何用
[click](http://click.pocoo.org/6/)轻松创建 python 脚本的命令行界面 - 如何在多个 Docker 容器中运行管道
- 如何在您的机器上部署小型集群
- 如何在集群上运行应用程序
不要计算两次——Luigify 你的管道
您的应用程序中的一些函数可能非常耗时，并且会返回大量输出，因此，如果您的管道在运行过程中出现故障，无论出于什么原因，修复一个小错误并重新运行所有内容都将花费您大量的时间和精力。
让我们做点什么吧。
假设您的管道需要做以下事情:
- 获取最近 10 天的数据；
- 转换数据；
- 用两种不同的模型做预测。
您可以像这样编写工作流:
但是这段代码很容易出错，比如在下载数据时可能发生的错误——一个网络错误，您所做的所有工作都会丢失。此外，如果您今天下载了最近十天的数据，并计划明天再次运行相同的管道，再次下载 90%的必要数据没有多大意义。
那么如何才能避免同样的事情做两次呢？
当然，您可以想出如何保存和重用中间结果的想法，但是没有必要自己编写代码。
我推荐使用[luigi](http://luigi.readthedocs.io/)套装。它让您可以轻松地将代码划分为单独的数据处理单元——称为任务——每个单元都有具体的需求和输出。
您的任务之一可能如下所示:
从这个片段中，我们可以看到:
- 任务名称为
TransformData； - 任务有一个参数，即
date； - 这取决于
FetchData类的十个任务，前十天各一个； - 它将其输出保存在一个以
date参数命名的 CSV 文件中。
下面我给出了一个完整的虚拟管道的例子。花点时间分析任务的依赖关系是如何创建逻辑管道的:
现在，当您尝试运行MakePredictions任务时，Luigi 将确保所有上游任务都提前运行。尝试用pip install luigi安装 Luigi，将上面的例子保存在task-dummy.py中，然后运行这个命令:
PYTHONPATH=. luigi --module task-dummy MakePredictions --date 2018-01-01 --local-scheduler
此外，当输出已经存在时，Luigi 不会运行任何任务。尝试再次运行相同的命令——Luigi 将报告给定日期的MakePredictions已经完成。
在这里你可以找到另一个帮助你开始学习 Luigi 的好例子。
免费并行— Luigi workers
我可以同时运行多个任务吗？
是的，你可以！Luigi 提供了开箱即用的功能。例如，只需在命令中添加
--workers 4，就可以让 Luigi 同时运行四个任务。
让我们利用这个机会来介绍一下 Luigi 的图形界面。
打开第二个终端并运行以下命令:
luigid
这将启动一个所谓的中央 Luigi 调度器，它监听默认端口 8082。你可以在你的浏览器上查看它漂亮的仪表盘: http://localhost:8082 。
现在回到第一个终端——您可以再次运行 Luigi 命令，这一次不带--local-scheduler参数(不要忘记删除您已经创建的文件，或者选择另一个日期来查看任务的执行情况)。如果需要并行，在命令中添加--workers 4。刷新仪表板页面后，您应该会看到一个计划任务列表。点击MakePredictions任务旁边的树图标，查看它所有的依赖项(是不是很漂亮？):
大规模并行—迁移到集群
现在我们开始认真起来——如果一台机器不足以让您并行运行任务，您可以将您的管道提升到下一个级别，并将其部署在集群上。我会引导你完成所有必要的步骤。
在前面的示例中，所有文件都保存在执行任务的同一台计算机上。
那么，如何在集群中的多台机器之间共享文件呢？
这个问题有很多答案，但我们将专注于其中一种可能的方式——使用亚马逊的 S3。
AWS S3 是一个简单的存储服务。它可以让你把你的文件存储在云端。你将文件保存在s3://bucket/data/file.csv下，而不是/home/user/data/file.csv。Python 提供了一些工具，可以轻松地从本地存储切换到 S3。
为了简化本教程，如果你想遵循下面的说明，我需要你 建立一个免费的 AWS 试用帐户 你将使用它来存储你的文件。你可以在这里做而且一年内完全免费。如果你不再需要它，你可以选择退出。
创建账户后，到 这里 创建一个桶。把一个桶想象成硬盘上的一个分区。
为了从 S3 读取和写入数据，我们将使用luigi.contrib.s3.S3Target类。您可以通过简单地添加一个适当的导入并替换任务定义中的LocalTarget来修改这个虚拟示例，正如我在这里所做的:
你还需要删除所有的self.output().makedirs()来电，因为你不需要在 S3 上创建文件夹。
要使用 Luigi 的 S3 功能，您必须pip install boto3。
您还需要为 S3 认证提供您的应用程序凭证。让我们使用最简单的方法:您可以在站点上创建一个新的访问密钥。您将获得一个访问密钥 ID 和一个秘密访问密钥——分别保存在环境变量AWS_ACCESS_KEY_ID和AWS_SECRET_ACCESS_KEY中。
现在，您的应用程序应该能够读写 AWS S3 的数据。通过再次运行管道来尝试一下。
将您的管道容器化，放在一个集群上
可悲的是，你不能把你的 Python 代码放在一个集群上，然后直接执行它。但是，您可以在某个容器中运行某个命令。
我将向您展示如何重构您的管道，以便在单独的 Docker 容器中运行每个任务。
将您的任务转化为迷你程序—通过点击添加一个简单的 CLI
在容器中运行任务的第一步是让它们可以从命令行运行。
用 Python 写 CLI 最快的方法是什么？
回答:点击。Click 是一个非常棒的软件包，它使得创建命令行界面变得非常容易。
让我们回到TransformData任务的例子(不是虚拟的)。它的run()方法调用两个函数，即transform_data和save_result。假设这些函数是在名为transform.py的文件中定义的:
现在让我们从命令行运行这些功能:
这里，我们定义了一个函数(cli)，当我们从命令行运行这个脚本时会调用这个函数。我们指定第一个参数将是一个输出路径，所有进一步的参数将组成一个输入路径元组。运行pip install click之后，我们可以从命令行调用数据转换:
*python transform.py s3://your-bucket/output.csv input1.csv input2.csv*
为了方便起见，我们把我们的项目叫做tac(为什么不重要)。如果您将setup.py添加到项目中，并将pip install添加到项目中(查看示例项目以了解项目应该如何构建，并且不要忘记将__init__.py添加到包目录中)，您应该能够运行您的脚本:
*python -m tac.transform s3://your-bucket/output.csv input1.csv input2.csv*
让东西变得可移植——在容器中运行任务
现在的问题是:
如何轻松创建一个 Docker 容器来运行我的命令？
嗯，那很简单。
首先，在项目根目录下创建一个requirements.txt文件。您将需要以下软件包:
*click
luigi
boto3
pykube # we'll talk about this one later*
现在，在项目根目录下创建一个Dockerfile,并将它放入:
*FROM python
COPY requirements.txt /requirements.txt
RUN pip install -r /requirements.txt
COPY . /tac
RUN pip install /tac
ARG AWS_ACCESS_KEY_ID
ENV AWS_ACCESS_KEY_ID=${AWS_ACCESS_KEY_ID}
ARG AWS_SECRET_ACCESS_KEY
ENV AWS_SECRET_ACCESS_KEY=${AWS_SECRET_ACCESS_KEY}*
让我们来分解一下:
FROM python给我们一个安装了 python 的基础映像。COPY requirements.txt /requirements.txt和RUN pip install -r /requirements.txt安装所有需要的软件包。COPY . /tac和RUN pip install /tac安装我们的项目。- 最后四行将让我们在构建时在映像中设置 AWS 凭证(这不是一个好的做法，但让我们保持本教程简单)。
现在，您可以通过从项目根目录执行来构建包含项目的 Docker 映像(假设您在 env 变量中仍有 AWS 凭证):
*docker build -t tac-example:v1 . --build-arg AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID --build-arg AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY*
因此，您刚刚构建了一个标记为tac-example:v1的 Docker 映像。让我们看看它是否有效:
*docker run tac-example:v1 python -m tac.transform s3://your-bucket/docker-output.csv input1.csv input2.csv*
这应该会在您的 S3 存储桶中保存一个docker-output.csv文件。
与集群对话—准备要在 Kubernetes 中运行的任务
如果您想在一个集群中运行所有或者部分管道任务，Luigi 提供了一个解决方案。
看一看uigi.contrib.kubernetes.KubernetesJobTask。
长话短说，Kubernetes 是一个可以管理集群的系统。如果你想和一个集群互动，可以和 Kubernetes 交流。
要在集群中运行一段代码，您需要向 Kubernetes 提供以下信息:
- 应该用于创建容器的图像；
- 应为容器指定的名称；
- 应该在容器中执行的命令。
让我们修改来自虚拟管道的旧任务TransformData,以符合这些需求。
- 首先，将基类更改为“KubernetesJobTask”:
*from luigi.contrib.kubernetes import KubernetesJobTask
class TransformData(KubernetesJobTask):
date = luigi.DateParameter()*
- 给它起个名字:
*@property
def name(self):
return 'transform-data'*
- 定义应该运行的命令:
*@property
def cmd(self):
command = ['python', '-m', 'tac.transform',
self.output().path]
command += [item.path for item in self.input()]
return command*
- 提供要传递给 Kubernetes 的信息:
*@property
def spec_schema(self):
return {
"containers": [{
"name": self.name,
"image": 'tac-example:v1',
"command": self.cmd
}],
}*
- 删除
run()方法，因为它是由KubernetesJobTask实现的。 - 此外，运行
pip install pykube，因为这是KubernetesJobTask的要求。
您应该会得到类似于您在示例项目中看到的东西。
但是在连接到集群之前，我们无法运行它。继续读。
家居集群— Kubernetes 和 Minikube
如何在不访问集群的情况下在集群中运行管道？
最酷的是，你实际上可以在你的笔记本电脑上运行一个真实集群的迷你版本！
你可以用 Minikube 来做这件事。Minikube 在您计算机上的虚拟机内运行单节点(单机)集群。
现在花点时间安装 Minikube。你可以在这里找到说明。你需要这些说明中提到的所有部件。
安装后，您应该能够运行
*minikube start*
启动您的本地集群。耐心点，因为这可能需要一段时间，尤其是当你第一次做的时候。验证您的群集正在运行
*kubectl cluster-info*
您应该会看到类似如下的内容:
*Kubernetes master is running at https://192.168.99.100:8443
KubeDNS is running at https://192.168.99.100:8443/api/v1/...*
如果一切正常，您应该能够访问 Kubernetes 的仪表板，其中显示了您的集群的当前状态:
*minikube dashboard*
将会打开一个新的浏览器选项卡，并向您显示以下内容:
由于集群运行在一个单独的(虚拟)机器上，它不能访问您的 Docker 映像(因为您没有将它推送到任何在线注册表)。我们将使用一个小技巧来克服这一点。
以下命令会将您当前的控制台会话设置为不使用本地 docker 引擎，而是使用集群虚拟机的 Docker 引擎来执行 Docker 命令:
*eval $(minikube docker-env)*
现在你需要做的就是再次调用docker build命令。这一次，您的映像将构建在虚拟机内部:
*docker build -t tac-example:v1 . --build-arg AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID --build-arg AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY*
关键时刻到了。
我们将在刚刚配置的集群中执行管道。
如果一切顺利，只需调用 Luigi 命令就足够了。Minikube 已经设置了适当的配置，所以KubernetesJobTask知道目标 Kubernetes 在哪里运行。
所以试着从task-dummy.py所在的目录执行这个命令:
*PYTHONPATH=. luigi --module task-dummy MakePredictions --date 2018-01-01*
并观察您的TransformTask作业如何在集群中运行:
尾注
- 如果
KubernetesJobTask报告如下消息:No pod scheduled by transform-data-20180716075521-bc4f349a74f44ddf并且无法运行，这可能是 Luigi 错误，而不是您的错。检查仪表板，查看transform-data-…Pod 是否处于状态Terminated:Completed。如果是这样，那么任务实际上已经完成，再次运行管道应该可以解决问题。 - 考虑一下 Google Kubernetes 引擎如何构建一个真正的集群。
- 当使用谷歌的集群时，考虑从 AWS S3 切换到谷歌云存储，以显著加快数据访问速度。这个模块应该会有帮助。
- 阅读更多关于使用 Dask 和 Kubernetes 加速管道的信息。
原载于www.datarevenue.com*。*
如何使用 Python 和 ScraPy 蜘蛛抓取网页
Each of those hairs scrapes. Source: Pixabay
有时候 Kaggle 还不够，还需要自己生成数据集。
也许你需要你正在训练的这个疯狂的卷积神经网络的蜘蛛图片，或者也许你为了，嗯，科学的目的想要刮 NSFW 子网格。不管你的理由是什么，浏览网页可以给你带来非常有趣的数据，并帮助你汇编令人惊叹的数据集。
在本文中，我们将使用 ScraPy 来抓取 Reddit 子编辑并获取图片。
有些人会告诉我使用 Reddit 的 API 是一种更实用的获取数据的方法，这绝对是真的。确实如此，我可能很快会写一篇关于它的文章。
但是只要我们做得很少，并且不要让 Reddit 繁忙的服务器超负荷工作，应该没问题。所以请记住，本教程仅用于教育目的，如果你需要 Reddit 的数据，你应该使用官方渠道，比如他们的牛逼 API 。
那么，我们如何着手清理网站呢？让我们从头开始。
检查机器人. txt
首先我们将进入 reddit.com/robots.txt。对于一个站点来说，习惯上是让他们的 robots.txt 文件可以从他们的主域访问。它遵循以下格式:
User-agent: <pattern>
Disallow: <patterns>
其中 U ser-agent 描述一种设备类型(我们属于*，通配符模式)，而 Disallow 指向一个我们无法抓取的 url 模式列表。
我在那里没有看到/r/，所以我觉得*刮一个 subreddit 的主页也可以。出于礼节，我仍然建议你在任何严肃的项目中使用 API。
不尊重一个网站的 robots.txt 文件可能会有法律后果，但这主要只是让你看起来像一个卑鄙的人，我们不希望这样。
建立我们的项目。
为了用 Python 抓取网站，我们将使用 ScraPy，它是主要的抓取框架。有些人喜欢美丽的声音，但我觉得 ScraPy 更有活力。
ScraPy 的基本抓取单元叫做蜘蛛，，我们将通过创建一个空蜘蛛来开始这个程序。
因此，首先，我们将安装 ScraPy:
pip install --user scrapy
然后我们将开始一个零碎的项目:
scrapy startproject project_name
您可以在此输入任何内容，而不是项目名称。该命令将创建一个目录，其中包含许多文件和 python 脚本。
现在，对于我们的最后一个初始化命令，我们将创建我们的第一个蜘蛛。为此，我们将运行 scrapy 的 genspider 命令，该命令将一个蜘蛛的名称和一个域 url 作为其参数。我会给我的取名为小猫捕手(小心:剧透)和爬行reddit.com/r/cats。
scrapy genspider kitten_getter reddit.com/r/cats
现在我们只进入/spider目录，不关注其余部分。和往常一样，我在GitHub 项目中发布了我的代码。
搭建我们的第一只蜘蛛
在蜘蛛目录中，我们将打开名为 kitten_getter.py 的文件并粘贴以下代码:
这里发生了什么事？嗯，每个蜘蛛需要三样东西:一个解析方法，一个开始请求方法，和一个名称。
- 每当我们从控制台启动蜘蛛时，都会使用蜘蛛的名称和。
- 从控制台运行 spider 将使其从 start_requests 例程启动。
- 我们让例程在 URL 列表上执行 http 请求，并在它们的 http 响应上调用我们的解析方法。
为了运行它，我们所要做的就是在项目的目录中打开我们的终端并运行:
scrapy crawl kitten_getter
释放你的蜘蛛！让他们漫游网络，攫取宝贵的数据。
如果您运行该命令，它将运行我们刚刚编写的蜘蛛，因此它将发出请求，获取我们提供的 url_list 中第一个 url 的 HTML，并按照我们要求的方式解析它。在这种情况下，我们所做的就是将整个响应直接写入一个名为“kitten_response0”的文件中(大小约为 140Kb)。
如果你打开它，你会看到它只是我们刮的网站的 HTML 代码。这对我们的下一个目标很有用。
识别模式
如果你去链接reddit.com/r/cats寻找小猫图片，你会注意到有两种帖子。
- 点击链接到评论区的文章。
- 直接指向 pic 的帖子
我们还注意到，我们无法在不违反 robots.txt、的情况下找到任何与reddit.com/r//comments/*匹配的内容，因此从帖子中提取图片是错误的。然而，如果图片直接链接到 subreddit 的主页，我们可以获得图片的 URL。我们看到那些链接总是在一个<>*标签中的 href 属性，所以我们要做的是调用响应对象的 xpath 方法来获得它们。
xPath 是一种在网站的 HTML 树中移动并获取其中一些元素的方法。Scrapy 还为我们提供了 css 方法，它允许一种不同的索引和标记元素的方式。我个人发现在浏览器中右键单击一个元素，点击 inspect，然后 copy xpath 是一种快速的开始方式，然后我只是稍微摆弄一下输出。
在这个特殊的例子中，因为我们需要的只是每个*<>*元素的 href 值，我们将调用
response.xpath(‘//a/@href’)
这将为每个 href 值(ScraPy 库中的一个对象)返回一个迭代器。然后，我们通过调用 extract 方法提取该值的字符串形式，并通过查看它是否以’结尾来检查它是否实际上是一个到图像的链接。png ‘或’。jpg。
下面是整个改进的解析方法，它现在还创建了一个 html 文件来显示所有图像，而无需下载它们:
因此，我们让我们的蜘蛛再次爬行，输出应该是这样的:
Crawled (200) <GET [https://www.reddit.com/r/cats/](https://www.reddit.com/r/cats/)> (referer: None)
[https://i.imgur.com/Au0aqkj.jpg](https://i.imgur.com/Au0aqkj.jpg)
[https://i.imgur.com/Xw90WFo.jpg](https://i.imgur.com/Xw90WFo.jpg)
[https://i.imgur.com/fOINLvP.jpg](https://i.imgur.com/fOINLvP.jpg)
其中每个链接都是一只可爱小猫的图片。作为奖励，文件kittens.html应该洋溢着可爱。
就是这样！您已经成功抓取了您的第一个网站！
保存图像
假设我们想下载图片，而不是制作一个 HTML 文件。然后我们要做的是导入 Python 的请求库，以及 unicodedata 库。请求将完成这项繁重的工作，但是我们需要 unicodedata ，因为提取的字符串默认为 unicode ，而请求需要 ASCII 码。
现在，我们将传递我们的 scrapy，而不是解析方法。请求函数将下面的函数作为回调参数:
它所做的只是下载一张图片，并将其保存为 JPG。它还自动增加存储在蜘蛛中的索引属性，为每张图片命名。
到处玩:交互式 shell
ScraPy 为我们提供了一个交互式的 shell，在这里我们可以尝试不同的命令、表达式和 xpaths。这是一种比用 crawl 命令一遍又一遍地运行整个程序更有效的迭代和调试蜘蛛的方式。要启动 shell，我们只需运行以下命令:
scrapy shell ‘http://reddit.com/r/cats’
当然，这个网址可以用其他任何网址代替。
伸出我们的蜘蛛
如果我们想得到更多的图像，我们可以让 download_pictures 方法调用 scrapy。请求下一页的 URL 上的，可以从“下一页”按钮的 href 属性中获得。我们还可以让蜘蛛将 subreddit 作为参数，或者更改下载的文件扩展名。
总而言之，最好的解决方案通常是最简单的，所以使用 Reddit 的 API 会让我们省去很多麻烦。
我希望你现在能够制作自己的蜘蛛，并获得自己的数据。请告诉我您是否觉得这很有用，以及您认为使用此工具可以生成什么样的好数据集—越有创意越好。
最后，还有一本我喜欢的奥莱利的书。当我开始我的数据科学之旅时，我发现它非常有用，它让我接触到了一个不同的、更容易使用(尽管不太灵活)的 Web 抓取框架。用 Python 叫做从零开始的数据科学，大概也是我得到这份工作的一半原因。如果你读到这里，你可能会喜欢它！
关注我，获取更多 Python 教程、技巧和诀窍！
你可以在我的 个人网站 中看到我正在做的事情以及我最近的文章和笔记。
如何为 SparkSQL 设置经济高效的 AWS EMR 集群和 Jupyter 笔记本电脑(2020 年 11 月更新)
高级数据科学技能
Photo by Myriam Jessier on Unsplash
这是一篇基于我个人工作笔记的生活类文章。随着时间的推移，AWS 界面和选项发生了很大的变化，所以我会在空闲时间不断更新本文。
我在一家国际信息服务公司工作，处理来自各个领域的数百个数据源，因此本文的主题对我和许多其他人来说都很重要。不要浪费时间处理我已经有的问题！
入门指南
创建 EMR 集群有三种主要方式:
- 从头开始创建一个，这在本文中有详细介绍。
- 克隆现有的 EMR 集群。如果您正在克隆其他人的集群，您只需更改集群名称、指定您的 RSA 密钥、启用集群自动缩放并更改集群标签*(即*
*creator*、*product**等)。一些公司使用标签来自动应用规则到你的集群，像闲置 X 分钟自动终止，S3 数据访问权限和会计/预算。)*您要克隆的集群不必当前处于活动或运行状态，即它可以处于terminated或running状态。我喜欢使用如下的命名分类法，因为它具有足够的描述性和唯一性，我可以在以后的克隆中找到:
project-name_myuseridANYOUNG_DDMM_spark.一旦你创建了一个特定于你的项目类型的集群，这个过程在将来会更加简单，因为你不需要改变你的集群标签，只需要偶尔改变你的集群名称。 - 使用 AWS CLI。这是最快最有效的方法。但是，这也是最先进的方法，并且配置最适合您项目的参数的前期成本很高。对于本文的读者来说，我只在尝试了前两种方法后才推荐这种方法。
步骤 0:创建 EMR 集群
选择右上方的区域。区域影响成本和延迟，这与实时应用相关。点击Create cluster按钮。
Image source: author, taken Nov. 2020.
步骤 1:软件配置
点击"Go to advanced Options."
Image source: author, taken Nov. 2020.
选择如下所示的配置，然后单击下一步。
I recommend installing more software than you need if: 1. you work on a variety projects 2. you want a one-size-fits-most cluster to clone in the future. Image source: author, taken Nov. 2020.
Image source: author. Taken Nov. 2020.
如果您打算在笔记本中安装 Python/Scala 包和 SQL 函数，请确保选择的Release是emr-5.30.0 。有些包，尤其是实现新算法的包，不能通过带有!pip install或pypi的笔记本安装在集群的所有节点上。在撰写本文时，无论是我还是多个企业 AWS 技术支持成员(国外和美国都有，如果这对你很重要的话)都无法在任何更高版本的emr上安装包，尽管进行了数周的试验。坦率地说，我在使用 emr-5.30.0 版本时没有遇到任何问题，尽管目前有这么多更新的版本。
Software configuration that I recommend for a one-size-fits-most cluster. Image source: author, taken Nov. 2020.
默认情况下，选择并安装 Hadoop、Hive 和 Ganglia 应用程序。你将不得不添加火花和其他你可能需要的。安装比您需要的更多的软件的后果是，集群将需要更长的启动时间，但在大多数情况下，额外的等待时间可以忽略不计。
一个可选步骤优化您的集群以读取存储在 S3 的 Parquet 格式的文件，在 PySpark 数据框中处理它们，并防止在尝试从 Jupyter 笔记本中长时间运行 Spark 作业时出现常见错误。完成上述任务的代码，
Image source: author, taken Nov. 2020.
编辑软件设置，进入配置，添加以下 JSON 代码:
[{"classification":"spark","properties":{"maximizeResourceAllocation":"true"}},{"classification":"spark-defaults","properties":{"spark.network.timeout":"1500"}},{"classification":"hdfs-site","properties":{"dfs.replication":"2"}},{"classification":"livy-conf","properties":{"livy.server.session.timeout":"10h"}},{"classification":"emrfs-site","properties":{"fs.s3.maxConnections":"100"}}]
解释:
"maximizeResourceAllocation":"true" -- Configures your executors to utilize the maximum resources possible on each node in a cluster. This EMR-specific option calculates the maximum compute and memory resources available for an executor on an instance in the core instance group. It then sets the corresponding spark-defaults settings based on this information. [[reference](https://docs.aws.amazon.com/emr/latest/ReleaseGuide/emr-spark-configure.html#emr-spark-maximizeresourceallocation)]"livy.server.session.timeout":"10h" -- addresses errors from long-running Spark tasks in a Jupyter/EMR notebook that die after an hour of execution:
An error was encountered:
Invalid status code '400' from https://xxx.xx.x.xxx:18888/sessions/0/statements/20 with error payload: "requirement failed: Session isn't active." [[reference](https://stackoverflow.com/questions/54220381/how-to-set-livy-server-session-timeout-on-emr-cluster-boostrap)]"fs.s3.maxConnections":"100" -- addresses the “Timeout waiting for connection from pool” error [[reference](https://aws.amazon.com/premiumsupport/knowledge-center/emr-timeout-connection-wait/)]
步骤 2:硬件配置
选择内部 AWS 工程团队指定的网络和子网，或者保留默认设置。
对于 Spark 作业，建议申请以下实例数量和类型:
1 个主节点实例、
1 个核心节点实例、
1 个任务节点实例各 1-3 种不同类型，即r4.2xlarge、r5.2xlarge、r5.4xlarge等。
Image source: author, taken Nov. 2020.
对于任务节点，选择现货定价，选择按需作为最高价格。我们愿意为主节点和核心节点支付“按需”价格，因为主节点总是需要对我们连续可用，而任务节点可以基于市场定价(“现货”定价)来来去去。
Image source: author, taken Nov. 2020.
在我上面的截图中，我显示按需价格是每实例小时 0.192 美元；相同实例类型、地区和日期的现货价格显示在左侧:0.040 美元/实例小时。按需定价几乎贵了 5 倍！
我推荐固定数量的实例的原因是因为我们正在构建一个**自动伸缩的集群:**实例的数量将根据您的工作的计算压力和您指定的自动伸缩规则而增加或减少。
在实施自动扩展规则之前，为每个 EBS 卷实例将核心和任务节点的 EBS 存储类型调整到至少 500 GB 的吞吐量优化 HDD (ST1) 。您还可以为每个“ EBS 卷实例”增加“实例的数量一般来说，我有两个卷实例，每个实例有 500 GB，核心总共有 1000 GB。如果您正在处理大数据，请添加更多实例/内存。主节点不需要 EBS 存储。
当在 S3 使用 Spark 时，中间数据被写入磁盘临时本地存储，而不是在 HDFS，因此当处理大型数据集时，为实例提供更多存储是有用的。我们选择 500 GB 的硬盘驱动器(HDD)而不是固态驱动器(SSD)上的 32 GB 存储，因为写入速度的瓶颈将是互联网速度而不是 HDD 写入速度，并且 HDD 更便宜。
步骤 2*:集群扩展(2020 年 7 月发布)
这对我来说是最重要的一步，也是 AWS 在 2020 年 7 月 7 日发布了 EMR 管理的自动缩放功能后最简单的一步。这曾经是一个非常痛苦、耗时的过程，但现在变得非常容易。自动缩放是这样完成的:
选中Enable Cluster Scaling并使用默认Use EMR-managed scaling.主节点不可伸缩，因此这只影响核心和任务节点。
根据我正在做的事情，我喜欢将核心和任务节点的最小数量保持在 1 到 3 之间。1 如果我正在试验一个新项目，3 如果我想安全行事，保证在关键任务的最后期限内不会出现任何问题。
- 简单来说:核心节点是数据存储，任务节点是计算。处理更大的数据？允许更多的核心节点以避免内存问题(进一步阅读: AWS 文档)
- **将最大节点数设置为一个较大但合理的数值。我根据自己的项目选择 250 到 1000 之间的一个数字。**在理论和实践中，最大数量的节点只会在需要的时候被征用。但是，从理论上讲，用户错误和/或未知的未知因素也有可能导致您的集群占用大量接近无穷大的节点。一个合理的数字是一个防止预算超支的数字，并允许对你的最大燃烧速度进行一些控制。在三年多的时间里，我经常在 AWS 上处理数十 Pb 的数据，最大节点数不超过 1000 个，没有出现任何问题。
- 将按需限制设置为 0。我们不想为节点支付按需价格，因为它们比现货价格高 5 倍！我将随时以现货价格(每实例小时 0.040 美元)购买一个 m5.xlarge 节点，而不是以按需价格(每实例小时 0.100 美元)购买一个 m4.large 节点！(注意，这是指定多个实例类型允许您“套利”AWS 节点投标系统的地方，因为您可以以更低的采购成本获得更大的能力)。
- 将最大核心节点设置为接近但不等于最大值的高值。在下面的例子中，我将其设置为 200，最多 250 个节点。我这样做是为了让我的集群可以自由地分配我的节点；如果我需要的核心节点比任务节点多，那就给我弄来。
Image source: author, taken Nov. 2020.
步骤 3:常规集群设置
下面的要点后面提供了截图示例。
- 描述性地命名集群。这使您能够记住它的用途以及您仅通过查看名称就能设置的一些参数。我喜欢使用如下所示的集群命名分类法，因为它具有足够的描述性和唯一性，便于我日后进行克隆:
project-name_myuseridANYOUNG_DDMM_spark. - 始终启用记录和调试。您需要同时启用这两个功能，以便对错误进行故障排除，或者在 AWS 技术支持下进行调试。
- 填写标签中的标签，以帮助跟踪贵公司工程团队指定的使用情况、预算和自动化集群策略。下面是标签示例:
创建者:输入你的名字或其他一些唯一的标识符。
项目:一个详细描述你正在进行的项目的有用名称。
部门:【数据科学 R & D、数据科学分析、其他】
环境:【开发、测试、生产】
克隆此群集时会复制这些设置，因此如果您要克隆其他人的群集，请根据需要进行更改。如果您正在克隆您自己的旧集群，您可能不需要做太多改变！
Image source: author, taken Nov. 2020.
步骤 3*:引导安装脚本
您需要一个引导脚本来在 EMR 集群的所有节点上安装软件包。以下是实现这一点的步骤:
- 用以下内容创建一个
.sh文件并保存在 S3:
Author’s code
#!/bin/bash -xesudo pip install \
pandas \
numpy \
xgboost \
scikit-learn \
nbextensions
2.指定引导操作脚本 S3 位置:
Image source: author, taken Nov. 2020.
步骤 4:安全设置
如果您在大型企业环境中工作，您可能需要指定这些设置。选择您的 EC2 密钥对和 EC2 实例角色。我将撰写另一篇文章，介绍如何创建 EC2 密钥对，允许登录主节点进行故障排除/测试。下面的截图是一个虚拟的 AWS 帐户，所以我没有创建 EC2 密钥对，因此警告说不能 SSH 到它。
Image source: author, taken Nov. 2020.
步骤 5:创建后监视集群
点击创建集群后，仪表盘页面显示状态为开始，设置完成后变为**【等待】**。
请注意，您可以对正在运行的 EMR 集群进行动态调整。例如，您可以通过克隆一个“step”脚本并在 S3 将输入文件更改为新上传或修改的.sh脚本来安装软件。
第六步:使用电子病历笔记本(2018 年 11 月发布)
命名并配置您的笔记本。将其附加到您创建的 EMR 集群。即使在 EMR 集群终止后，笔记本仍然存在。EMR 笔记本很好，因为您可以通过浏览器连接，每个包含 PySpark 代码的单元格在执行后都有其作业进度跟踪。
关于作者
安德鲁·杨是 Neustar 的 R&D 数据科学家经理。例如，Neustar 是一家信息服务公司，从航空、银行、政府、营销、社交媒体和电信等领域的数百家公司获取结构化和非结构化的文本和图片数据。Neustar 将这些数据成分结合起来，然后向企业客户出售具有附加值的成品，用于咨询、网络安全、欺诈检测和营销等目的。在这种情况下，Young 先生是 R&D 一个小型数据科学团队的实践型首席架构师，负责构建、优化和维护一个为所有产品和服务提供信息的系统，该系统为 Neustar 带来了超过 10 亿美元的年收入。(在 LinkedIn上关注他，了解数据科学的最新趋势！)
更多热门文章:
过时的说明(备案)
由于 AWS Engineering 于 2020 年 7 月 7 日发布，以下说明已过时:引入 Amazon EMR 托管扩展—自动调整集群大小以降低成本
接下来，定义自动扩展策略。对于核心节点，将最大实例数设置为 100(或其他合理的值)，将最小实例数设置为 1。选中规则中默认的横向扩展和比例的复选框，因为它们性能良好。对于任务节点类型，将最大实例数设置为 50，最小实例数设置为 0。检查规则中默认横向扩展和比例的复选框，因为它们执行良好。如果由于某种原因默认规则不可见，请手动添加它们。有两个横向扩展规则:
- “rule1”:如果YARNMemoryAvailablePercentage比 15 小 1 五分钟，冷却时间 300 秒，则增加 1 实例。
- “规则 2”:如果 ContainerPendingRatio 大于 0.750.75持续 1 五分钟，冷却时间为 300 秒，则添加 1 实例。
在标尺中增加一个标尺:
- “rule1t”:如果YARNMemoryAvailablePercentage大于 75 持续 1 五分钟，冷却时间为 300 秒，则终止 1 实例。
任何横向扩展规则都不能与任何纵向扩展规则同名。注意，最大实例数在技术上是任意的，但是为了安全起见，不要给出一个荒谬的数字。大致来说，运行 10 小时的 10 节点集群的成本与运行 1 小时的 100 节点集群的成本相同，因此最好在需要时征用所需的节点。
如何用 Keras/Theano 在 AWS 上搭建深度学习环境
**更新:**2017 年 5 月 19 日——在这篇文章中，我将一步一步地解释如何建立一个运行在亚马逊的 EC2 GPU 实例上的深度学习环境，使用:
- 图片:ami-b 03 ffedf(Ubuntu Server 16.04 LTS(HVM)，SSD 卷类型)
- 区域:欧盟中部-1(欧盟法兰克福)
- 实例类型:g2.2xlarge
- 存储:30 GB(建议至少 20gb 以上)
软件:
1。创建一个新的 EC2 GPU 实例
Select the Ubuntu Server 16.04 LTS AMI.
Take the g2.2xlarge GPU Instance. Alternatively, you could also take the g2.8xlarge if you need more computing power.
Change the standard storage size to 30 GB.
Launch the cluster and assign an EC2 key pair.
2。在 GPU 实例上安装 CUDA/cud nn
NVIDIA 驱动程序
更新图形驱动程序:
$ sudo add-apt-repository ppa:graphics-drivers/ppa -y
$ sudo apt-get update
$ sudo apt-get install -y nvidia-375 nvidia-settings
CUDA
SSH 到 EC2 GPU 实例:
$ ssh -i ~/folder_key_pair/key_pair.pem ubuntu@public_dns_ec2
首先下载 CUDA 8.0 到你的$HOME 文件夹( /home/ubuntu ):
$ wget [https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64-deb](https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64-deb)
安装 CUDA:
$ sudo dpkg -i cuda-repo-ubuntu1604-8-0-local_8.0.44-1_amd64-deb
$ sudo apt-get update
$ sudo apt-get install -y cuda nvidia-cuda-toolkit
检查所有安装是否正确:
$ nvidia-smi
$ nvcc --version
cuDNN
接下来，在 NVIDIA 的加速计算开发者计划上注册一个帐户，并将 cuDNN 5.0 下载到您的本地机器上:
Select cuDNN v5 Library for Linux
将 TAR 归档文件 SCP 到 EC2 GPU 实例:
$ scp -i ~/folder_key_pair/key_pair.pem ~/folder_tar_file/cudnn-8.0-linux-x64-v5.0-ga.tgz ubuntu@public_dns_ec2:/home/ubuntu/
SSH 到 EC2 GPU 实例并解压缩文件:
$ tar -zxvf cudnn-8.0-linux-x64-v5.0-ga.tgz
最后，打开*。巴沙尔*然后加上这个:
export LD_LIBRARY_PATH=/home/ubuntu/cuda/lib64:$LD_LIBRARY_PATHexport CPATH=/home/ubuntu/cuda/include:$CPATHexport LIBRARY_PATH=/home/ubuntu/cuda/lib64:$LD_LIBRARY_PATH
重新装上*。巴沙尔:*
$ source ~/.bashrc
3。安装 Keras 和 Theano
在 EC2 实例上下载 Anaconda 并安装它:
$ wget [https://repo.continuum.io/archive/Anaconda3-4.2.0-Linux-x86_64.sh](https://repo.continuum.io/archive/Anaconda3-4.2.0-Linux-x86_64.sh)$ bash Anaconda3-4.2.0-Linux-x86_64.sh
注意:重新加载您的 bash 概要文件(源代码。bashrc)以便激活 Anaconda。
最后，安装 Keras 和 Theano:
$ pip install --upgrade --no-deps git+git://github.com/Theano/Theano.git$ pip install keras
注意:确保在 Keras 中将 Theano 用作后端。如果没有，您需要在 Keras 配置中更改它。keras/keras.json)，通常在 python 中第一次导入后创建。
1 {
2 "backend": "theano",
3 "epsilon": 1e-07,
4 "floatx": "float32",
5 "image_dim_ordering": "th"
6 }
4。测试您的环境:
现在你可以走了！通常，我倾向于用一个简单的脚本来测试我的环境，看看是否一切都像预期的那样工作。
以下是一个用于训练 MNIST 数据集的简单 MLP 网络:
通过调用以下命令运行脚本:
$ THEANO_FLAGS=floatX=float32,device=gpu0,lib.cnmem=0.8,nvcc.flags=-D_FORCE_INLINES,dnn.enabled=True python mnist_gpu_test_script.py
或者，您可以在的 no 配置文件(中指定设置。theanorc ):
[global]floatX = float32device = gpu[lib]cnmem = 0.8[dnn]enabled = true[nvcc]flags = -D_FORCE_INLINES
注意:标志“nvcc.flags=-D_FORCE_INLINES”对于 Ubuntu 16.04 非常重要，因为 CUDA 8.0 似乎不支持默认的 gcc 版本(5.4.0)(参见 Ubuntu 16.04 和 CUDAglibc 2.23)的修复)。目前这是一个棘手的问题。或者，您也可以通过使用 update-alternatives 将 CUDA 链接到一个较旧的 gcc 版本(参见* 此处 )。*
最终，这里是输出:
We can see that cuDNN is enabled (cuDNN 5005).
注意:监视 NVIDIA 的系统管理界面以查看是否有一些活动也很有趣，例如内存使用、运行进程和 GPU 利用率。
*$ watch -n1 nvidia-smi*
结论/展望
在这篇博文中，我一步一步地描述了如何在 AWS 上建立深度学习环境。如果有不清楚的地方，请通过 twitter @datitran 联系我，或者关注我。在下一篇文章中，我将关注如何通过使用 docker 来自动化上面解释的那些步骤，从而极大地加快设置过程。
如何为深度学习设置一个强大且经济高效的 GPU 服务器
Looking for GPU computational power for deep learning experimentations?
使用 Paperspace 和 fast.ai
语境
如果你打算开始你的深度学习之旅，并成为令人兴奋的深度学习实践者社区的一部分，你肯定需要设置一个 GPU 服务器。
在这篇文章中，我将介绍 Paperspace ，一个非常适合深度学习活动(以及其他)的虚拟机云提供商。尽管存在其他几种替代方案(亚马逊网络服务、谷歌云平台、微软 Azure 、 Crestle 、…)、，但我发现paper space使用起来非常方便，而且功能强大，性价比高。
I quickly adopted Paperspace as my perfect deep learning platform.
Paperspace 提供了一个现成的 fast.ai 模板。 fast.ai 是一个构建在 PyTorch 之上的超级便捷的深度学习框架，由杰瑞米·霍华德和瑞秋托马斯开发并教授；你肯定会想在某个时候尝试一下。
让我们来配置你的深度学习环境吧！
关于定价
Paperspace 提供有吸引力的定价选项。你确实可以以不到 40 美元的价格获得一台功能强大的机器，预计每月使用 40 小时。定价可详述如下:
- 一个公共 IP 地址每月 3$
- 250 GB 硬盘(存储)每月 7 美元
- 0.65 美元/小时对于一台 NVidia Quadro P5000 机器(RAM 30GB8 个 CPU，8GB GPU)
我上面提到的替代方案在我看来既不便宜也不简单。
注意:学习深度学习的另一个好方法(这也是我真心推荐的！)是跟随deep learning . ai的专精由吴恩达。这种在线课程(mooc)由 5 门课程组成(每门课程约 1 个月)，每月 49 美元。稍微贵一点，但是仍然值得投资，因为 Andrew 也是一个很好的老师。
步骤 1:创建图纸空间帐户
如果你打算使用这项服务，这是非常明显的一步！您需要提供有效的电子邮件地址作为标识符，以及密码。
Enter valid email address + password to create your account.
一旦完成，你就可以在几分钟内创建你的深度学习 gpu 服务器。
步骤 2:创建一台机器
- 从https://www.paperspace.com/console/machines，点击‘新机器’按钮
You GPU server is only a few clicks away from this screen.
- 选择一个地区(选择离你最近的一个)
For some regions, you might have to provide some justification on your planned usage, in order to reduce fraud and enable Paperspace to prioritize requests. In such a case expect ~2 days for the investigation to take place.
- 为您的机器选择一个模板
Paperspace 提供多种模板供您使用。我推荐使用 fast.ai 模板。Paperspace 的 fast.ai 模板是云中的一个全功能 Linux (Ubuntu 16.04) 实例，专为启动和运行非常受欢迎的 Fast.ai 在线 MOOC 而构建，名为“程序员实用深度学习”。该模板旨在为交互式开发提供一个全功能的机器学习环境。
该模板包括英伟达用于使用 GPU 运行机器学习程序的库，以及各种用于 ML 开发的库(Anaconda Python 发行版、Jupyter notebook、fast.ai 框架……)。
fast.ai is a popular template that will definitively make your life easier!
- 选择机器的计算能力
Available options might evolve over time. P4000 and P5000 will give you sufficient resources to build world-class classifiers and become a serious Kaggle competitor.
- 根据您的需求选择存储空间，从 50GB 到 2000GB 不等
Note that you can upgrade to a higher storage any time.
- 选择选项 -您需要一个公共 IP 地址来访问 jupyter 笔记本电脑
Turn ON Public IP (cost is $3/month) | Turn OFF Auto Snapshot (to save money on doing back-ups)
- 添加您的信用卡信息并继续付款
- 创建您的纸张空间框
由于高需求，您的请求可能需要几个小时才能完成。完成后，您将收到一封主题为“您的新 Paperspace Linux 机器准备就绪”的电子邮件，其中包含一个临时密码，可通过 ssh 登录到您的新机器。
步骤 3:连接到您的机器
- 点击‘开始’按钮来启动你的机器
Screenshot from Paperspace home > Machines > Machine id.
- 打开机器。您将被重定向到一个基于 web 的命令行界面，但是您可以随意使用任何其他界面( Cygwin ，…)
Click the ‘open’ button once machine is ready.
- 将确认邮件中的密码复制粘贴到终端中:Windows: Ctrl + Shft + v. Mac: Cmd + v
And here you are!
第四步:不要忘记关闭你的机器！
每当您停止工作时，点击“关机”按钮,以防止您每月的账单无谓地增加！
Tip: Paperspace let you choose to automatically shut down your machine at: 1h, 8h, 1d, 1w.
结论
请随意评论和分享您自己对 Paperspace 或任何其他提供商的体验。感谢阅读，快乐深度学习！
来源
如何在 AWS GPU 实例上设置深度学习环境
设定我们的目标
目标是学习如何在 Amazon 的 AWS GPU 实例上建立一个机器学习环境，通过使用 docker 容器，该环境可以很容易地复制并用于其他问题。
设置环境
第一步是在亚马逊的网络服务上建立一个虚拟机。为此，我们需要选择正确的硬件和软件包来构建深度学习模型。深度学习模型消耗大量计算能力，对非常大的矩阵进行矩阵运算。AWS 上有两个硬件选项。仅限 CPU 或 GPU。GPU 代表图形处理单元。CPU 和 GPU 架构的主要区别在于，GPU 是并行处理器，但更加专业化。相反，CPU 是通用计算架构，在并行计算上做不好。Amazon 允许您为繁重的计算建立一个带有专用 GPU 核心的虚拟机。当然，这增加了一点你的成本，但是如果你考虑到你节省的时间，这是一个很好的交易。
或者，如果你真的想认真对待这个问题，那么我建议你在家里用 nvidia GPUs 构建自己的系统。
下面是我们在 AWS 上设置 GPU 实例所需的步骤:
- 启动实例
- 选择 ubuntu 16.04
- 选择 g2.xlarge — 8 个 vCPU、15Gb RAM、60GB 启动 SSD、1 个 GPU K520
- 选择可用性区域
- 防止意外终止
- 添加存储— 120 GB
- 添加标签，如名称和环境…
- 选择安全组
- 启动并选择键
连接到实例
导航到存储 SSH 密钥的目录，使用下面的命令在终端中连接到您的实例
ssh -i “your_ssh_key.pem” ubuntu@*[your instance public IP address]*
安装 NVIDIA 驱动程序
sudo apt-get updatesudo apt-get upgrade
要领
sudo apt-get install openjdk-8-jdk git python-dev python3-dev python-numpy python3-numpy build-essential python-pip python3-pip python3-venv swig python3-wheel libcurl3-devsudo apt-get install -y gcc g++ gfortran git linux-image-generic linux-headers-generic linux-source linux-image-extra-virtual libopenblas-dev
NVIDIA 驱动程序
sudo add-apt-repository ppa:graphics-drivers/ppa -ysudo apt-get updatesudo apt-get install -y nvidia-375 nvidia-settings
安装 CUDA 8 库
wget [https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64-deb](https://developer.nvidia.com/compute/cuda/8.0/Prod2/local_installers/cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64-deb)sudo dpkg -i cuda-repo-ubuntu1604-8-0-local-ga2_8.0.61-1_amd64-debsudo apt-get updatesudo apt-get install cudanvidia-smi
为 nvidia GPU 机器设置 docker 引擎(nvidia-docker)
参考:https://docs.docker.com/engine/installation/linux/ubuntu
添加 docker 引擎库
sudo apt-get updatesudo apt-get install \ apt-transport-https \ ca-certificates \ curl \ software-properties-commoncurl -fsSL [https://download.docker.com/linux/ubuntu/gpg](https://download.docker.com/linux/ubuntu/gpg) | sudo apt-key add -sudo apt-key fingerprint 0EBFCD88sudo add-apt-repository \ “deb [arch=amd64] [https://download.docker.com/linux/ubuntu](https://download.docker.com/linux/ubuntu) \ $(lsb_release -cs) \ stable”
安装 docker 引擎 ce
sudo apt-get updatesudo apt-get install docker-cesudo docker run hello-worldsudo usermod -aG docker $USER
安装 nvidia-docker
# Install nvidia-docker and nvidia-docker-pluginwget -P /tmp [https://github.com/NVIDIA/nvidia-docker/releases/download/v1.0.1/nvidia-docker_1.0.1-1_amd64.deb](https://github.com/NVIDIA/nvidia-docker/releases/download/v1.0.1/nvidia-docker_1.0.1-1_amd64.deb)sudo dpkg -i /tmp/nvidia-docker*.deb && rm /tmp/nvidia-docker*.deb# Test if docker is using nvidia GPUsnvidia-docker run — rm nvidia/cuda nvidia-smi
用 jupyter 笔记本、tensorflow 和机器学习库建立 docker 容器
为 gpu 拉张量流 docker 图像
docker pull tensorflow/tensorflow:latest-gpu-py3
用 tensorflow 为 gpu 创建 docker 容器
nvidia-docker run -it -name planet -p 8888:8888 tensorflow/tensorflow:latest-gpu-py3 bash
码头集装箱内
奠定基础
apt-get updateapt-get install sudosudo apt-get updatesudo apt-get install gitsudo apt-get install nano #or your choice of editor
设置 Python 环境
首先让我们看看我们需要什么，我们有什么。我们需要:
Python 3.5，PIP3 9.0.1，带 Python 3.5 内核的 jupyter 笔记本，tensorflow 1.1，带 tensorflow 后端的 keras，还有这些 librarise: cv2 (OpenCV)，sys，os，gc，numpy，pandas，seaborn，matplotlib，scikit-learn (sklearn)，scipy，itertools，subprocess，six，skimage，IPython.display，tqdm，多重处理，concurrent.futures
运行 ipython 并导入下面的库，以确保一切正常。这些库的大部分已经安装在 tensorflow docker 映像中。但是，其中一些可能不包括在内。
import sysimport osimport gcimport numpyimport pandasimport seabornimport matplotlibimport sklearnimport scipyimport itertoolsimport subprocessimport siximport skimageimport IPython.displayimport tensorflowimport kerasimport tqdmimport multiprocessingimport concurrent.futuresimport cv2
安装缺失的库
pip3 install seabornpip3 install scikit-imagepip3 install keraspip3 install tqdmpip3 install opencv-python
从这个容器创建一个新的图像，并将其命名为 keras-tf
docker commit amazon keras-tf:latest
如何为您的组织设置数据科学职能
本文将提供在 3 种类型的组织中建立数据科学职能的有效方法的高级理解:***(1)***初创公司，(2)中型组织，以及(3)大型组织。
M ost 公司已经意识到，为了在各自的市场中保持竞争力，他们需要数据科学能力。在某些情况下，来自组织内数据科学(DS)团队的产品和见解正日益成为他们的主要竞争优势。
然而，很少有公司做对了这一点。
组织需要的东西和数据科学家想要研究的东西之间的脱节与双方的优先事项有关。
大多数公司都有很多“易得之果”(数据清理、简单查询等)。)不需要复杂的数据科学模型来解决。然而，大多数数据科学家希望解决业务中最复杂的问题。
组织需要清楚地传达为什么这些唾手可得的成果能迅速为组织增加价值，数据科学家需要明白，解决这些问题将让他们了解业务。一旦他们了解了业务，数据科学家就可以在组织数据科学能力的成熟过程中发挥重要作用。
为了做好这件事，需要做两件事:
Source: Monica Rogati’s article on “The AI Hierarchy of Needs”
(I)了解“数据科学需求层次”
https://hacker noon . com/the-ai-hierarchy-of-needs-18f 111 FCC 007
(ii)如何根据组织的规模组建团队。
1。创业公司:
在大多数初创公司中，资源(时间、资源和员工数量)是有限的，同时，你的 DS 团队必须(1)负责建立整个数据基础设施，以及(2)生成引导组织朝着正确方向前进所需的关键见解。
由于这两个原因，创业公司中最有效的 DS 团队有成对的数据科学家和数据工程师一起工作。这使得两种技能都能发挥各自的优势，推动数据产品和见解向前发展。
2.中型组织
在中型公司中，可以用来创建数据产品和见解的资源不那么稀缺。这意味着他们可以将数据科学家和数据工程师分开。在某些情况下，一个中等规模的公司也可能有软件工程师来负责数据收集和数据获取。
这允许基于技能组合的更多的分离。
这里的关键要点是，数据工程师和数据科学家可以专注于分析和指标，这些分析和指标可以有效地告诉企业他们的产品或服务表现如何，同时还可以拓展开发新的复杂模型的范围。
3.大型组织
当公司变得足够大时，他们开始在员工身上花钱。这样做有两个好处:(1)员工不必担心他们领域之外的事情，以及(2)员工可以专注于他们最擅长的事情，很少分心。
与中型组织类似，在大型组织中，软件工程师负责仪表、日志等。数据工程师专注于数据管道的架构。
现在，不同类型的数据科学家之间出现了分化。
- 数据科学，分析工程师
这些数据科学家专注于:
(i)获取大型数据集，并将它们转化为具体的结论和可操作的见解。
(ii)向不同的受众传达复杂的主题。
(iii)创造性地思考，发现新的机会，将组织引向正确的方向。 - 数据科学，机器学习工程师
这些数据科学家专注于:
(i)开发高度可扩展的工具，利用基于规则的模型。
(ii)建议、收集和综合需求，以创建有效的路线图。
(iii)与工程团队合作编写可交付成果。
(iii)采用标准的机器学习方法，最好地利用现代并行环境。
在数据科学家的动机和组织表示希望数据科学家加入他们的意思之间，仍然很难弥合差距。
双方都要思考数据科学的需求层次，以及如何最好地实施配对，让个人发挥他们的优势，这将为数据科学团队带来最佳结果。
在我的下一篇文章中，我将讨论产品设计师和数据科学家如何合作开发高效的产品。
如何为机器学习设置 Python 环境
想获得灵感？快来加入我的 超级行情快讯 。😎
为机器学习设置 Python 环境可能是一项棘手的任务。如果你以前从未设置过这样的东西，你可能会花几个小时摆弄不同的命令，试图让它工作。但我们只想直接去 ML！
在本教程中，您将学习如何建立一个稳定的 Python 机器学习开发环境。您将能够直接进入 ML，再也不用担心安装包了。
(1)设置 Python 3 和 Pip
第一步是安装 pip，这是一个 Python 包管理器:
sudo apt-get install python3-pip
使用 pip，我们将能够用一个简单的pip install *your_package* *安装在 Python 包索引 中索引的任何 Python 包。*你很快就会看到我们如何用它来建立我们的虚拟环境。
接下来，当从命令行运行pip或python命令时，我们将 Python 3 设置为默认。这使得使用 Python 3 更加容易和方便。如果我们不这样做，那么如果我们想使用 Python 3，我们每次都必须记住键入pip3和python3！
为了强制 Python 3 成为默认版本，我们将修改~/.bashrc文件。从命令行执行以下命令来查看该文件:
nano ~/.bashrc
向下滚动到 #更多 ls 别名部分，并添加以下行:
alias python='python3'
保存文件并重新加载您的更改:
source ~/.bashrc
嘣！Python 3 现在是您的默认 Python 了！你可以在命令行上用简单的python *your_program* 来运行它。
(2)创建虚拟环境
现在我们将建立一个虚拟环境。在那里，我们将安装机器学习所需的所有 python 包。
我们使用虚拟环境来分离我们的编码设置。想象一下，如果你想在你的电脑上做两个不同的项目，需要不同版本的不同库。将它们都放在同一个工作环境中可能会很麻烦，并且您可能会遇到库版本冲突的问题。你的项目 1 的 ML 代码需要 1.0 版本的numpy，但是项目 2 需要 1.15 版本。呀！
虚拟环境允许我们隔离工作区域，以避免这些冲突。
首先，安装相关的软件包:
sudo pip install virtualenv virtualenvwrapper
一旦我们安装了 virtualenv 和 virtualenvwrapper，我们将再次需要编辑我们的~/.bashrc文件。将这三行放在底部，保存它。
export WORKON_HOME=$HOME/.virtualenvs
export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3
source /usr/local/bin/virtualenvwrapper.sh
保存文件并重新加载您的更改:
source ~/.bashrc
太好了！现在我们终于可以像这样创建我们的虚拟环境了:
mkvirtualenv ml
我们刚刚创建了一个名为ml的虚拟环境。要输入，请执行以下操作:
workon ml
不错！你在ml虚拟环境中进行的任何库安装都将被隔离在那里，不会与任何其他环境冲突！因此，无论何时你希望运行依赖于安装在ml环境中的库的代码，首先用workon命令进入，然后正常运行你的代码。
如果您需要退出 virtualenv，请运行以下命令:
deactivate
(3)安装机器学习库
现在我们可以安装我们的 ML 库了！我们将使用最常用的方法:
- numpy: 用于任何矩阵工作，尤其是数学运算
- 科学技术计算
- pandas: 数据处理、操作和分析
- matplotlib: 数据可视化
- scikit learn: 机器学习
这里有一个简单的技巧，可以快速安装所有这些库！创建一个requirements.txt文件，列出您希望安装的所有软件包，如下所示:
numpy
scipy
pandas
matplotlib
scikit-learn
完成后，只需执行以下命令:
pip install -r requirements.txt
瞧啊。Pip 将继续安装文件中列出的所有软件包。
恭喜你，你的环境已经设置好了，你可以开始机器学习了！
喜欢学习？
在推特上关注我，我会在这里发布所有最新最棒的人工智能、技术和科学！也在 LinkedIn 上与我联系！
如何设置 JupyterLab 项目环境
在一分钟内创建和定制您的容器化和脚本控制的 JupyterLab 项目环境。
本文是本书的一部分: 用 Python 实践量子机器学习。
在这里免费获得前三章。
TL；博士:
JupyterLab-Configuration 让您轻松创建您的 JupyterLab 配置，它在容器中运行 JupyterLab，并使用脚本自动完成整个设置。容器是一个独立的环境，它封装了您在其中安装的库，而不会影响您的主机。脚本自动执行您通常需要手动运行的所有命令。因为您可以查看和编辑脚本，所以您可以随时完全控制您的配置。
在本帖中，您将看到这个 JupyterLab 配置是如何工作的，以及如何定制它来满足您的需求。
我是一名数据科学家，不是 DevOps 工程师
该死的吉姆。我是数据科学家，不是 DevOps 工程师
数据科学家的要求清单非常长。它包含数学和统计，编程和数据库，通信和可视化，领域知识，等等。
*“求求你，不要把 DevOps 加到名单里，”*你觉得呢？好吧！你觉得这些过程怎么样？
创建您的 JupyterLab 配置:
- JupyterLab-Configuration 让你轻松创建你的定制配置
- 下载并解压缩您的配置
- 根据您的需求进行定制(可选)
下图显示了运行中的 JupyterLab 配置。通过两个简单的步骤使用它:
- 执行
sh {path_to_your_project}/run.sh - 在浏览器中打开
localhost:8888
Using the JupyterLab configuration
如果我对这种配置的工作原理感兴趣呢？解释它需要多少时间？
当然，几个小时，先生。但是你没有几个小时，所以我会在几分钟内为你做。
这篇文章的剩余部分从概念上给你一个 JupyterLab 配置如何工作的概述。它解释了构造块，并使您能够根据自己的需求定制配置，例如
- 添加软件包
- 添加您自己的 Python 模块
- 定制 Jupyter 笔记本服务器
我为什么需要一个 JupyterLab 配置？
2018 年，Project Jupyter 推出了 JupyterLab——一个用于处理笔记本、代码和数据的交互式开发环境。JupyterLab 完全支持 Jupyter 笔记本，使您能够在选项卡式工作区中与笔记本一起使用文本编辑器、终端、数据文件查看器和其他自定义组件。
如果您运行的是基于 Unix 的操作系统(macOS 或 Linux)，那么您可以使用两个简单的命令来安装和启动 JupyterLab:
python -m pip install jupyterlab
jupyter lab
**但是等等！**JupyterLab 的手动设置如此简单，乍看之下可能无法满足您在数据科学项目中需要做的所有事情。您可能还需要:
- Jupyter 内核(例如 bash、Javascript、R 等等)
- 文件转换器(如 Pandoc、Markdown 等)
- 库(例如 NumPy、SciPy、TensorFlow、PyTorch 等)
- 支持软件(Git、NbSphinx 等)
将这些依赖项直接安装在您的计算机上并不是一个好主意，因为您将很难确保保持您的计算机干净。
- 如果您有不同的项目需要不同版本的库会怎样？你会在每次切换项目时卸载旧版本并安装正确的版本吗？
- 如果你不再需要一个库，该怎么办？如果你发现你还需要它，你会马上把它移除并重新安装吗？或者您会等到忘记删除这个库吗？
手动安装这些依赖项也不是一个好主意。你将无法控制你安装的所有东西。
- 如果你想在另一台电脑上完成这个项目，该怎么办？重新建立项目需要多少时间和工作量？
- 如果有人问你要你正在使用的所有第三方库怎么办？在您安装在主机上的所有库当中，您如何识别您在本项目中使用的库？
集装箱式结构
容器是独立于主机的虚拟环境。它创建了自己的运行时环境，可以适应您特定的项目需求。它只以特定的方式与宿主互动。对容器的任何更改都不会影响您的主机，反之亦然。 Docker 是用于项目环境虚拟化的最著名和最广泛使用的平台之一。
下图描述了包含两个步骤的 Docker 过程:(1)从 Docker 文件构建一个映像，以及(2)在容器中运行该映像。
The Docker process
我们的配置在run.sh-脚本中自动化了这个过程。这是一个运行在主机上的 shell 脚本(sh或bash)。同样，这个脚本是您开始 JupyterLab 项目的切入点。只需打开一个终端并运行:
sh {path_to_your_project}/run.sh
Docker 文件是告诉 Docker 如何在容器内配置系统的脚本。在docker build步骤中，Docker 创建了该系统的映像。映像是一个可执行包，其中包含运行应用程序所需的一切—代码、运行时环境、库、环境变量和配置文件。
虽然 Docker 支持从头开始构建系统，但最佳实践是从现有映像开始，例如包含操作系统甚至完整配置的映像。
配置从一个现有图像开始。你可以在这个 GitHub-Repository 中找到相应的 Dockerfile。此映像包含以下软件和库:
- Ubuntu 18.04
- Python 3.7.0
- 点
- 朱庇特和朱庇特实验室
- Bash 和 Jupyter Bash-Kernel
- 文档(pdf)工具(
pandoc、texlive-xetex) - 构建工具(例如，
build-essential、python3-setuptools、checkinstall) - 通讯工具(
openssl、wget、requests、curl) - 各种 Python 开发库
如果你需要更多的软件库，那么 Dockerfile 就是你要去的地方。只需在FROM语句后添加一个新行。这一新行需要以RUN开始，并包含您可能想要执行的任何 shell 命令，通常类似于apt-get install或pip install。例如，您可以使用以下语句使用pip安装一些主要的数据科学包:
RUN pip install numpy
RUN pip install scipy
RUN pip install pandas
Dockerfile 中的更改在build步骤中生效。如果您已经启动了容器，您需要停止它(例如在您的终端中使用 ctrl+c)并重新启动它(sh {path_to_your_project}/run.sh)。编辑 docker 文件时，build步骤可能需要一些时间。Docker 试图重用现有的图像，当你没有改变任何东西时，它在随后的启动中非常快。
如果您从 Docker 文件中删除命令并重新运行run.sh-脚本，Docker 会创建一个新的系统映像。您不需要从系统中卸载任何东西。因为被删除的命令从来就不是这个结果系统的一部分。这使您的配置始终保持干净。您可以实验性地安装库，而不必担心。如果你不需要它们，就去掉它们。您将得到一个从未安装它们的系统映像。
下图描述了 Dockerfile 如何配置系统:它按照其RUN-命令中指定的方式安装软件。
The Dockerfile specifies the configuration of the system
命令在一个容器中执行这个图像。此外，它定义了在容器内运行的系统如何连接到外部世界，即主机。
有两种主要的连接类型:卷和端口。卷是主机上的目录和容器中的目录之间的链接。这些目录是同步的，即主机目录中的任何变化都会影响容器中的目录，反之亦然。端口映射让 Docker 将对主机端口的任何请求(例如 HTTP 请求)转发到容器的映射端口。
下图描述了我们到目前为止的配置。run.sh-脚本负责 Docker build和run步骤。一旦您执行该脚本，它将创建一个运行容器，通过文件系统卷和端口映射与您的主机连接。
The run.sh script automates the Docker process
文件系统
当您从 Git-Hub-Repository 下载文件时，您将在.zip文件中获得以下文件结构:
{path_to_your_project}/
├─ config/
│ ├─ {projectname}.Dockerfile
│ ├─ jupyter_notebook_configuration.py
│ └─ run_jupyter.sh
├─ libs/
│ └─ nbimport.py
├─ notebooks/
│ └─ …
└─ run.sh
- 文件夹包含 JupyterLab 项目的配置文件。这些文件配置 Docker 容器，安装软件包，并配置 JupyterLab 环境。
libs-文件夹包含软件库，这些软件库不是作为软件包安装的，而是作为文件添加的，例如您在其他项目中自己编写的 Python 模块。- 文件夹是我们放笔记本的目录。
在 Dockerfile 文件中，我们设置指向这些目录的环境变量。因为配置中的脚本使用了这些环境变量，所以如果愿意，您可以编辑它们。只要确保变量中的路径与实际路径匹配即可。
ENV MAIN_PATH=/usr/local/bin/{projectname}
ENV LIBS_PATH=${MAIN_PATH}/libs
ENV CONFIG_PATH=${MAIN_PATH}/config
ENV NOTEBOOK_PATH=${MAIN_PATH}/notebooks
在配置中，我们将当前工作目录({path_to_your_project})映射到容器中的${MAIN_PATH}-文件夹。因此，您放入该目录的任何文件在您的 JupyterLab 项目中都是可用的。反之亦然，您在 JupyterLab 中添加或更改的任何文件(例如 Jupyter 笔记本)都会出现在您的主机上。
此外，在 Dockerfile 的EXPOSE命令中，我们指定配置提供 JupyterLab 端口8888。容器内的这个端口被映射到您的主机计算机的端口。
下图描述了容器如何将其文件系统和端口连接到主机。
Connect the file system and the port
特定于 JupyterLab 的配置
我们 docker 文件中的最后一个命令是CMD-命令。它告诉 Docker 无论何时启动容器都要执行这条指令。在配置中，我们执行run_jupyter.sh-脚本。这个脚本允许我们做一些最后的准备，比如:
- 将
jupyter_notebook_configuration.py文件放在 JupyterLab 期望的位置 - 配置一个定制的 Jupyter-Kernel 来自动加载
nbimport.pyPython 模块
jupyter_notebook_configuration.py可让您配置 Jupyter 笔记本电脑服务器，例如设置用于网络认证的密码。可用选项列表可在这里找到。
定制 Python 内核将${LIBS_PATH}添加到您的 Python sys.path中。这允许您从${LIBS_PATH}-文件夹中导入任何 Python 模块，例如import libs.nbimport。此nbimport.py-模块进一步使您能够导入位于${NOTEBOOK_PATH}-文件夹中的笔记本。每当你用 Python 内核启动 Jupyter 笔记本时，系统会自动为你做这些事情。
最后，run_jupyter.sh-脚本启动 JupyterLab。您现在可以在浏览器中打开localhost:8888，其中8888是您指定的端口。
下图描述了完整的 JupyterLab 配置。
The complete JupyterLab configuration
摘要
JupyterLab-Configurator 可让您轻松创建自定义配置。这个 JupyterLab-Configuration 在容器中运行 JupyterLab。它将 JupyterLab 运行的环境与主机环境分开。因此，您可以更改 JupyterLab 环境(例如，卸载/安装软件包),而不会影响您的主机或任何其他项目。
这个JupyterLab-Configuration使用脚本自动完成整个设置。这些脚本:
- 使您能够使用单个命令(例如
sh run.sh)运行 JupyterLab - 使您的项目可移植:只需将目录移动或复制到另一台主机上
- 揭示您的配置的一部分，并允许您查看和编辑您的配置
- 让您的配置成为您的源代码的一部分。您可以像对代码进行版本控制一样对它们进行版本控制
GitHub-repository提供了完整的源代码。
使用 JupyterLab 配置非常简单:
- 执行
sh {path_to_your_project}/run.sh - 在浏览器中打开
localhost:8888
Using the JupyterLab configuration
注 :运行 Docker 容器的能力是这个 JupyterLab-Configuration 对主机的唯一要求。Docker 在 Windows 上可用，并且最近获得了运行基于 Linux 的容器的能力。因此，Jupyterlab 没有理由不在 Windows 上运行。如果你想尝试一下，你需要运行 Docker，并将run.sh的docker build和docker run命令移动到一个可以在 Windows 上执行的.cmd文件中。
扫一扫
721
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
