如何将 Jupyter 笔记本连接到远程 spark 集群，每天运行 spark 作业？
作为一名数据科学家，您正在开发笔记本电脑，用于处理不适合使用 Spark 的笔记本电脑的大量数据。你会怎么做？这不是一个微不足道的问题。
让我们从最简单的解决方案开始，不用在你的笔记本电脑上安装任何东西。
- “无笔记本”:SSH 进入远程集群，并在远程集群上使用 Spark shell。
- “本地笔记本”:对数据进行下采样，并将数据提取到您的笔记本电脑中。
“没有笔记本”的问题是开发者体验在 Spark shell 上是不可接受的:
- 你不能像在 Jupyter 笔记本或 Zeppelin 笔记本上那样轻易地修改代码并打印出结果。
- 很难显示 Shell 中的图像/图表。
- 在远程机器上用 git 进行版本控制是很痛苦的，因为你必须从头开始设置，并像 git diff 一样进行 git 操作。
火花壳截图
第二个选项“本地笔记本”:您必须对数据进行下采样，并将数据拖到您的笔记本电脑上(下采样:如果您的集群上有 100GB 的数据，您可以将数据下采样到 1GB，而不会丢失太多重要信息)。然后你可以在本地的 Jupyter 笔记本上处理数据。
它产生了一些新的令人痛苦的问题:
- 您必须编写额外的代码来缩减数据采样。
- 缩减采样可能会丢失有关数据的重要信息，尤其是在处理可视化模型或机器学习模型时。
- 你必须花费额外的时间来确保你的代码为原始数据。如果没有，就要花额外的时间来找出问题所在。
- 您必须保证本地开发环境与远程集群相同。否则，它很容易出错，并可能导致难以检测的数据问题。
好吧，“无笔记本”和“本地笔记本”显然不是最好的做法。如果您的数据团队可以访问云，例如 AWS，会怎么样？是的，AWS 在其 EMR 集群和 SageMaker 上提供 Jupyter 笔记本。笔记本服务器通过 AWS Web 控制台进行访问，当集群准备就绪时，它就可以使用了。
这种方法被称为“云上远程笔记本”。
AWS EMR 和由 AWS 提供的 Jupyter 笔记本电脑
“云上的远程笔记本电脑”的问题有
- 每次集群开始运转时，您都必须设置您的开发环境。
- 如果你想让你的笔记本运行在不同的集群或区域，你必须手动&重复地完成。
- 如果集群意外终止，您将丢失在这些集群上所做的工作。
具有讽刺意味的是，这种方法是可以访问 AWS 的数据科学家中最受欢迎的方法。这可以用最省力的原理**来解释:**它提供了对远程集群的一键式访问，以便数据科学家可以专注于他们的机器学习模型、可视化和业务影响，而无需在集群上花费太多时间。
除了“无笔记本”、“本地笔记本”和“云上的远程笔记本”，还有将笔记本电脑上的 spark 指向远程 spark 集群的选项。代码通过本地笔记本提交，并发送到远程 spark 集群。这种方法被称为“桥接本地和远程火花”。
创建 sparkSession 时，可以使用 set remote master
val spark = SparkSession.builder()
.appName(“SparkSample”)
.master(“spark://123.456.789:7077”)
.getOrCreate()
这些问题是
- 你必须找出如何认证你的笔记本电脑远程火花集群。
- 仅当 Spark 作为独立部署而不是 YARN 部署时，它才有效。如果您的 spark 集群部署在 YARN 上，那么您必须将远程集群上的配置文件
/etc/hadoop/conf复制到您的笔记本电脑上，并重启您的本地 spark，假设您已经知道如何在您的笔记本电脑上安装 Spark。
如果您有多个 spark 集群，那么您必须通过复制配置文件来来回切换。如果集群在云上是短暂的，那么它很容易变成一场噩梦。
“桥接本地和远程火花”对大多数数据科学家来说并不奏效。幸运的是，我们可以把注意力转回到 Jupyter 笔记本上。有一个名为“Sparkmagic”的 Jupyter 笔记本内核，它可以将您的代码发送到远程集群，假设 Livy 安装在远程 spark 集群上。这一假设适用于所有云提供商，在 Apache Ambari 的帮助下，在内部 spark 集群上安装并不困难。
火花魔法建筑
看起来“火花魔法”是目前最好的解决方案，但为什么它不是最受欢迎的。有两个原因:
- 很多数据科学家都没有听说过“Sparkmagic”。
- 数据科学家很难解决安装、连接和认证问题。
为了解决问题 2，sparkmagic 推出了随时可用的 Docker 容器。Docker 容器确实解决了安装中的一些问题，但它也给数据科学家带来了新的问题:
- docker 容器是为航运应用程序设计的，它的学习曲线对数据科学家来说并不友好。
- 它不是为来自不同技术背景的数据科学家直观使用而设计的。
关于 docker 容器的讨论就到此为止，另一篇解释如何让 Docker 容器真正为数据科学家工作的文章将在几天后发表。
总而言之，我们有两类解决方案:
- 笔记本&笔记本内核:“无笔记本”、“本地笔记本”、“云上远程笔记本”、“Sparkmagic”
- Spark 本身:“连接本地和远程 spark”。
尽管存在安装和连接问题，“Sparkmagic”仍是推荐的解决方案。然而，通常还有其他未解决的问题会降低生产率并损害开发人员的体验:
- 如果需要其他语言 python 和 R 在集群上运行呢？
- 如果笔记本要每天运行会怎样？如果只有在另一台笔记本运行成功时才运行该笔记本，该怎么办？
让我们回顾一下当前的解决方案:
- 设置远程 Jupyter 服务器和 SSH 隧道(Rreference)。这肯定是可行的，但设置起来需要时间，而且笔记本电脑都在远程服务器上。
- 设置 cron 调度程序。大多数数据科学家都接受 cron scheduler，但是如果笔记本无法运行呢？是的，shell 脚本会有所帮助，但是大多数数据科学家都愿意编写 shell 脚本吗？即使答案是肯定的，数据科学家也不得不 1。访问已完成的笔记本 2。获取状态更新。即使有数据科学家乐于编写 shell 脚本，为什么每个数据科学家都要编写自己的脚本来自动化完全相同的东西呢？
- 设置气流。这是一个在数据工程师中非常受欢迎的解决方案，它可以完成工作。如果有数据工程师或数据平台工程师支持的 Airflow 服务器，数据科学家可以设法学习 Airflow 的操作人员，并让它为 Jupyter Notebook 工作。
- 设置 Kubeflow 和其他基于 Kubernetes 的解决方案。诚然，kubeflow 可以完成工作，但实际上有多少数据科学家可以访问 Kubernetes 集群，包括运行在云上的托管解决方案？
让我们重新定义这些问题:
- 如何在能够访问远程集群的本地笔记本电脑上进行开发？
- 如何在远程集群上操作？
Bayesnote 实施的解决方案可以在 5 分钟内完成所有工作。Bayesnote 是用于 Jupyter 笔记本的笔记本编排平台:
- 在 5 分钟内协调不同集群上的笔记本电脑
- 一键访问远程 Jupyter 笔记本电脑
- 运行具有依赖性的 Jupyter 笔记本，然后重试
- 一键查看输出笔记本
那儿有
- 没有学习曲线。不需要学习抽象概念，也不需要 docker/Kubernetes 知识。
- 无运营成本。没有额外的数据库安装，没有端口打开。它可以毫无困难地将自己安装到集群中。
Bayesnote
教程可以在 https://github.com/Bayesnote/Bayesnote找到
如何将 Python 连接到 Google Cloud 的文本到语音转换
布雷特·乔丹在 Unsplash 上的照片
所以你可能想知道谷歌云的文本到语音和其他文本到语音有什么不同。首先，由于人工智能的力量(这些被称为 wavenet voices)，它可以将文本转换为听起来更自然的语音。
所以我实际上遇到了这项技术，因为我想在 YouTube 上制作教学视频。自从在家工作发生后，我一直无法创造一个可以创作画外音的空间。最棒的是它附带的免费层，所以任何人都可以尝试这段代码！
如果你想继续下去，谷歌 Colab 笔记本的副本可以在这里找到。
设置
没有任何进一步的犹豫，让我们继续前进，并开始设置它。我们要做的第一件事是登录我们的谷歌账户，然后进入谷歌云的文本到语音转换 API 。我们现在要通过单击“enable”来激活它。它会要求你付费，但不要担心，除非你超过免费层，否则它不会向你收费。
因为我是在 Google Colab 笔记本上运行的，所以您需要创建一个服务帐户并下载一个 JSON 密钥文件。这样做的指令将位于这里。我现在把 JSON 文件放在我的 Google Drive 中。请记住，我希望这完全在线。所以我想运行的第一部分代码是连接到 Google Drive。
from google.colab import drivedrive.mount('/content/drive')
一旦我连接到驱动器，我现在想找到那个 JSON 文件。我创建了一个名为 text2speech 的文件夹，放在那里。这是我们进行身份验证所需要的。
import osos.environ['GOOGLE_APPLICATION_CREDENTIALS'] = '/content/drive/My Drive/text2speech project/My Project-e0a97add923c.json'!echo $GOOGLE_APPLICATION_CREDENTIALS
我们现在想安装谷歌云文本到语音库。我们可以通过在代码块中运行 pip 安装来实现这一点。
pip install --upgrade google-cloud-texttospeech
所以谷歌云的文本到语音转换很酷的一点是我们可以定制它。从音高到音调，甚至翻译语言。点击查看语音演示。我勉强接受了Wavenet J的男声。既然我们已经选好了声音，剩下的就容易了。我们只需设置它并发送文本。我们将为此创建一个函数，它将文本输出到 mp3 文件。
def synthesize_text(text):"""Synthesizes speech from the input string of text."""from google.cloud import texttospeechclient = texttospeech.TextToSpeechClient()input_text = texttospeech.SynthesisInput(text=text)# Note: the voice can also be specified by name.# Names of voices can be retrieved with client.list_voices().voice = texttospeech.VoiceSelectionParams(language_code="en-US",name="en-US-Wavenet-J",ssml_gender=texttospeech.SsmlVoiceGender.MALE,)audio_config = texttospeech.AudioConfig(audio_encoding=texttospeech.AudioEncoding.MP3)response = client.synthesize_speech(request={"input": input_text, "voice": voice, "audio_config": audio_config})# The response's audio_content is binary.with open("output.mp3", "wb") as out:out.write(response.audio_content)print('Audio content written to file "output.mp3"')
非常容易。我们现在将向该函数发送一个文本字符串。这是文本字符串。
text = "Hello! My name is Wavenet J and I am running on Google Cloud's Text To Speech! Nice to meet you and thank you for reading my friend's article!"
现在我们把所有东西都装满了，准备好了。
mp3file = synthesize_text(text)
现在在最左边，我们想选择文件夹图标，现在可以下载我们的 mp3 文件，并听取一个舒缓的人工智能的声音！
结论
我向目前正在使用语音的人推荐这种方法。即使是从事自然语言处理的人。此外，如果你是一名教师，这将是一个完美的方式把讲座视频格式。这也很神奇，因为你可以翻译讲座和任何其他文本！
我是如何让学习数据变得有趣的！
那是叉子还是条形图？为什么不两者都要？！
当你想到你在教授数据可视化的研讨会、视频和网站上看到的数据例子时，你会想到什么主题？销售，利润，计算部件……唉。无意义、枯燥、枯燥的数据。我们肯定能做得更好？
为什么这么严肃？
为普通观众设计学习练习意味着你需要找到每个人都能理解的数据。这可能很棘手，我明白了——金融方面的例子很有意义——每个人都知道钱和买东西，金融听起来对培训课程来说足够公司化了。但是我真的在乎西北区销量比南方多吗？不。这门课的其他人也不知道。我们什么时候再吃午饭？
相比之下，任何看过汉斯·罗斯林展示数据的人都会同意，即使是最严肃的数据也能以鼓舞人心、引人入胜的方式展示。现在我并不是建议数据可视化培训应该像汉斯展示他的材料一样以同样的兴趣和热情来展示，没有人能持续 8 个小时！
但是我们如何找到教授数据技能的中间地带呢？我们是否有足够的勇气以一种不把自己看得太重的方式教授严肃的技能？我们可以！
数据技能是严肃的，但是学习它并不否定乐趣！
以学习仪表板设计为例。我可能想教授的常见技能和技术包括:
- 比较数字(条形图)和整体部分(饼图或圆环图)的良好图表选择
- 通过直接标注数据而不是使用图例来减少混乱
- 有目的地使用颜色，例如用于不同图表中的共同元素
我可以使用以下简单的仪表板来演示这些内容:
运筹学
我可以用这个来做:
在每种情况下都需要同样的技能。两个仪表板展示了相同的关键数据可视化概念。但是制作一个更有趣！当你的同事问你在昨天的课程中学到了什么时，你更容易想起这些。
是的，我们可以坚持公司的颜色、严肃的展示风格，以及让首席财务官满意的东西。但是这有什么意思呢？把这些留到明天，当你在日常工作中运用新技能的时候。今天让我们享受自由吧！
所以，我们来学习一下如何做一个叉形条形图吧！
我在培训课程中使用这个练习作为我的基本条形图的补充练习。它旨在为已经在定期创建条形图或只想从数据中获得乐趣的学员增加一些新的技能。我通常不会像下面这样提供解决方案或步骤，因为我也喜欢把它作为创建可重用设计的一课。这使得这个练习更具挑战性！
如果你想挑战自己——不要继续读下去，现在就停下来，试着创建图表。不要使用任何文本框或形状(除了刀或叉子的手柄)。您应该能够自动更新类别名称或值和图形更新！然后回来看看你的解决方案是否和我的相似。 ]
让我们从构建一个基本条形图开始:
现在我想把条形的顶部做成圆形，但是如果只是使用圆形，当数据改变时它们不会移动。相反，我可以在图表上创建第二个系列，使用相同的数据，并用圆形标记绘制成折线图。
首先，通过单击条形复制图表系列，按 Ctrl-C，然后按 Ctrl-V。
然后，我可以通过右键单击第二个系列来更改其图表类型，选择“更改系列图表类型”:
对于第二个系列的图表类型，您需要选择“带标记线”并取消选中“次坐标轴”复选框。
现在让我们改进造型。单击条形，使用“格式化数据系列”面板将条形间距缩小到 50%。
在我们对折线图进行样式化之前，我们需要将整个图表区域重新调整到它的最终纵横比。当我们在这，让我们删除网格线，两个轴和边界。
我们快到了。现在调整折线图样式。使用“格式化数据系列”面板将标记类型更改为“内置”，选择一个圆形并调整标记大小，直到它与条形宽度匹配。当你在那里的时候，不要忘记移除连接线。
功能元素的最后一步是添加数据标签。我们可以利用我们有两个数据系列的事实来添加两组标签。我们将向圆圈添加标准数据标签，将标签放置在圆点上方:
对于类别标签，我们将使用类别名称作为条形图的数据标签，并将它们放置在“内部基准”处。
要将它们转向侧面，我们将单击此面板的对齐部分，并将文本方向更改为“将所有文本旋转 270 度”:
最后一些颜色和字体的调整:
请记住，您可以通过单击两次来改变单个数据点的颜色，第一次单击会选择整个系列，第二次单击只会隔离该数据点。您会注意到，只有该数据点被突出显示:
最后一步，添加形状来创建叉子的手柄。这里我展示了我在最终设计中使用的蓝色边框和间隔，然后重叠的形状:
就是这样。一个完全可重复使用的 12 步叉形条形图！谁知道 Excel 能做到这一点！
如何利用贝叶斯定理更智能地消费新闻
基础利率、边际概率、敏感性和特异性
马库斯·斯皮斯克在 Unsplash 上的照片
当谈到在不确定的情况下更新信念和做出决策时，贝叶斯定理几乎是可用的最佳工具。然而，当它应该为我们的日常生活带来价值时，它却经常被归入学术教科书和机器学习应用程序。
这篇文章是写给那些熟悉贝叶斯定理，但在阅读诸如“红酒降低痴呆症风险”这样的标题时，可能难以记住哪些术语出现在哪里，并且不会立即想到它的人的。
首先，我将回顾贝叶斯定理，谈谈为什么我认为在确实不应该记住的时候很难记住，并根据敏感性和特异性(我将定义它)来阐述它。接下来，我将讨论几种使用该公式对新闻中经常出现的挑衅性言论做出适当反应的方法。最后，我将留给你一些关于在日常生活中使用贝叶斯定理的注意事项，以及其他最后的想法。
关键要点如下。我将定义所有出现的术语:
- 贝叶斯定理告诉我们，在给定一些新的条件下，如何修正一些结果的概率估计。在日常生活中，当有更多证据时，它可以简单地更新我们的信念，或者确定某个结果(如癌症)是否更有可能在某种情况下(如吸烟)出现。
- 你需要三条信息来正确更新你对结果的信念:结果的基本比率，证据的敏感性和特异性。新闻往往只会给你敏感。
- 在缺乏所有三条信息的情况下，尝试自己填补空白，并警惕极端(高/低)基本利率或证据的高边际概率的情况。
敏感性和特异性方面的贝叶斯定理
贝叶斯定理告诉我们，在给定新证据的情况下，如何计算结果的后验概率。这被表示为 P(A|B)形式的条件概率。
当公式被表示为一堆混乱的字母时，很容易把它们弄混，忘记分子和分母分别是什么。由于这个原因，我喜欢用结果和条件来写。
从数学上来说，没有理由把一个事件称为“结果”，而把另一个事件称为“条件”。但在现实生活中，有些事情我们想知道却无法直接测量——比如，你得癌症的概率。这将是一个结果。像医学诊断结果这样的证据是用来估计这种结果概率的条件。
p(结果)是我们感兴趣的事情的已知的先验概率或基本概率。这是有道理的，它将与我们更新的概率成比例，因为否则，我们将在每次遇到新证据时翻转我们的信念。
p(条件)称为条件的边际概率，把它看作一个实体可能有点奇怪。它是在结果为真和不为真的两个世界中，观察到我们所观察到的条件或证据的总概率。
现在，我想再介绍两个术语:敏感性和特异性。假设你读到 70%的医学生弹钢琴。也就是说，弹钢琴作为学医的证据，其敏感度为 70%。
但是，是否是钢琴演奏者肯定不是一个人是否是医科学生的有力指标。其中一个原因是它的低特异性。也就是说，很多不是医学生的人也会弹钢琴。
为了使一个条件强烈地影响结果的概率，它必须同时具有高敏感性和高特异性。此外，为了得出一个后验概率估计，除了证据的敏感性和特异性，我们还必须对结果的基本比率有一个概念。下面是贝叶斯公式的改写，与这些直觉一致:
我发现新闻文章通常不会提供所有必要的细节来得出一个完全基于数据的观点。贝叶斯定理告诉我们调整信念的数量往往是反直觉的，尤其是在处理罕见事件时。在下一节中，我将描述如何避免对类似“90%的新冠肺炎病例发生在穿有鞋带的鞋子的人身上”的陈述反应过度
需要注意的场景
同样，计算结果的后验概率需要三条信息:结果的基础率、条件的敏感性和条件的特异性。特别是，如果敏感性或特异性没有什么特别的(~0.5)，那么这就是后验概率不会与基础概率有太大差异的标志。在这种情况下，假设你当前的行为是基于你的信念，你可能不需要调整你正在做的事情来解释新的数据。
但是当新闻只提供一两条的时候，你该怎么办？好吧，你的选择是:
- 承认你不能有意义地吸收新数据，忽略它。
- 估计缺失的部分。
虽然有些情况下你真的无法估计缺失的部分，但是过分依赖这个选项是很危险的。我发现，敏感性通常是新闻中提供的信息，而基本利率和边际概率(以及特异性)可以毫不费力地找到。
在这种情况下，每当我的估计出现低基本利率、高边际概率或高基本利率时，我都学会了保持警惕。让我们使用虚构的例子依次检查每种情况。
低基本利率
" 90%有天才级智商孩子的母亲报告说在怀孕期间吃贝类."
在像上面例子这样的情况下，我们感兴趣的结果(有一个天才水平智商的孩子)是非常罕见的。这意味着，除非我们测试的条件在灵敏度和特异性方面非常精确(如果没有在科学杂志上直接报道，可能就不是这样)，否则我们的后验概率也可能非常低。
高边际概率
“几乎每个寻求抑郁症咨询的美国大学生都拥有一部智能手机.”
就像拥有带鞋带的鞋子一样，除了抑郁症咨询，拥有一部智能手机现在已经很普遍了。换句话说，拥有智能手机的边际概率很高。这可能是疾病特异性低的警告信号。
换句话说，我们可以假设几乎每一个没有寻求抑郁症咨询的大学生也拥有一部智能手机，这意味着拥有一部智能手机本身并不是一个学生将寻求咨询的强有力指标。
高基本利率
“95%坐过飞机的人在 100 岁之前就去世了。”
在你读到这样的文章并决定你的飞行时代结束之前，考虑一下在 100 岁之前死亡已经很普遍了。在第 100 次旋转之前死亡的后验概率有可能比基本概率低**。无论如何，后路可能不会有足够的不同来保证生活方式的改变。**
警告和结论
我希望我已经设法提供了另一个角度来看待贝叶斯定理，这将使它在日常生活中更直观和更容易使用。但是权力越大，责任越大，所以要注意以下几点。
- 即使你确定一些新的信息不足以调整你的信念来改变你的行为，那也不等于它根本没有调整你的信念。如果越来越多的证据指向同一件事，最终会改变你的整体观点。忘记每一个证据并回复到你之前的状态对你没有好处，因为你认为它是不充分的。
- 再次提醒，不要断然拒绝新闻，因为它没有明确提供运行贝叶斯法则所需的所有要素。如果你只对你不喜欢的新闻应用这样的过滤器，这就有导致动机怀疑的风险。
- 虽然在我上面的例子中，我直接做出了敏感性声明，但标题通常会直接对结果做出声明(例如，“智能手机增加了抑郁症的可能性”)，但随后只报告了证据在体内的敏感性。看过去这样的标题，找到数字。
记住这几点，你应该准备好以一种更有分寸和数据意识的方式对你遇到的信息做出反应。干杯！
附注轶事证据在这个框架内仍然毫无价值。
如何将 Spark 中训练的模型容器化:MLLib、ONNX 等等
将 ML 运送到生产部门
以经济高效的方式包装 Spark 模型的替代方案
如果我们要说出现代应用中的两个趋势，其中一个应该提到容器和机器学习。越来越多的应用程序正在利用容器化的微服务架构来提高弹性、容错能力和可扩展性，无论是在内部还是在云中。同时，机器学习越来越成为任何应用的基本要求。
然而，这两件事并不总是能和谐相处，Spark 就是这种情况。通过使用 Cloudera、Azure Databricks、AWS EMR 或任何其他工具，Spark 现在已经成为大数据分析的行业事实标准。但是如果您想在集群之外的某个地方使用您在 Spark 中训练的模型呢？
您的选择，按菜单点菜
对此有几个选项:
- 如果您**使用 TensorFlow、PyTorch、Scikit-Learn 等工具训练您的模型，**那么您可以将您的模型打包成不同的可移植格式。因为这些框架并不直接依赖于 Spark，所以您可以开始了。我不会在这篇文章中谈论这个选项。
- 如果使用 MLLib (比如在 pyspark.ml.*)训练模型，那么可以将模型导出为可移植的格式，比如 ONNX ，然后使用 ONNX 运行时来运行模型。这有一些限制，因为不是所有的模型都支持 ONNX。
- 如果您使用 MLLib 训练您的模型，那么您可以通过创建一个无集群 Spark 上下文对象来持久化您的模型并从容器内部加载它。
- **(2022 年 2 月更新)**使用 MLFlow 持久化您的模型，并使用 MLModel 规范打包它。MLFlow 目前支持 Spark，它能够使用 MLModel 规范打包您的模型。您可以使用 MLFlow 将您的模型部署到任何您想要的地方。关于这个策略的更多细节请看我的帖子:使用 MLFlow 轻松部署。
ONNX 是机器学习模型的序列化和规范的开放标准。由于该格式描述了计算图(输入、输出和操作)，所以它是独立的。它专注于深度学习，主要由微软和脸书倡导。在 TensorFlow 和 PyTorch 等许多框架中得到支持。
Spark 中的模型是如何工作的？
在 Spark 中，一个 ML 模型由一个 [Transformer](https://spark.apache.org/docs/latest/ml-pipeline.html)表示，它将一个具有特征的输入DataFrame转换成另一个具有预测的DataFrame。一个Transformer还可以输出另一组特征。因为在机器学习中，你通常必须执行几个步骤来产生想要的预测，Spark 有一个PipelineModel对象，它是一系列步骤或Transformers(注意，管道对象有点复杂，但为了本文的简单起见，我们将假设它是这样)。它将多个Transformers链接在一起，以指定一个 ML 工作流。
考虑下面这个来自spark.apache.org的例子，其中我们有一个包含三个阶段的PipelineModel:一个标记器(获取文本并返回单词)、一个散列函数(获取单词并返回向量)和一个逻辑回归模型(获取特征并返回预测)。
文本分析的 PipelineModel 示例。来源:spark.apache.org
您可以通过使用方法fit()训练管道来获得 PipelineModel。这里有一个例子:
tokenizer = Tokenizer(inputCol="text", outputCol="words")
hashingTF = HashingTF(inputCol=tokenizer.getOutputCol(), outputCol="features")
lr = LogisticRegression(maxIter=10, regParam=0.01)
pipeline = Pipeline(stages=[tokenizer, hashingTF, lr])model = pipeline.fit(training)
现在的问题是，如何在 Spark 之外运行这个 PipelineModel 对象？
选项 1:导出到 ONNX 并使用 ONNX 运行时运行模型
ONNX 是为深度学习模型设计的，然而，它在某些方面支持更“传统”的机器学习技术。Spark 通常用于那些更传统的方法。在 Spark 中这包括:
- 矢量器和编码(字符串索引、OneHotEncoding、Word2Vec)
- 定标器(定标器、输入器、二进制化器、存储桶)
- 模型:线性模型，随机森林，梯度推进，朴素贝叶斯，SVM，主成分分析
要将您的模型导出为 ONNX 格式，您需要首先安装 onnxmltools ，该工具目前仅适用于 PySpark 。安装库的方式取决于您使用的平台。在我的例子中，我使用的是 Azure Databricks，所以我将使用集群中的 Install library 选项来安装这个库。
一旦安装了库，就可以通过以下方式将管线模型导出到 ONNX 中:
from onnxmltools import convert_sparkml
from onnxmltools.convert.sparkml.utils import buildInitialTypesSimpleinitial_types = buildInitialTypesSimple(test_df.drop("label"))
onnx_model = convert_sparkml(model, 'Pyspark model', initial_types, spark_session = spark)
在哪里，
buildInitialTypesSimple函数创建一个来自模型(特征)的所有预期输入的列表。它接受一个样本数据帧作为参数。在我的例子中，我使用了 test_df 数据帧，删除了 label 列，只保留了所有的特性。- 型号是安装管道的名称(
PipelineModel) - “Pyspark 模型”是模型的描述
- initial_types 是预期的输入要素名称和类型。正如我所说的，这可以通过使用
buildInitialTypesSimple函数来提供，或者通过手工构建来提供，比如[ ('education '，string sensortype([1，1])] spark_session=spark将 SparkSession 上下文传递给该方法。
注意:这最后一个参数没有记录在 GitHub 库中，但是在调试之后，我需要指定它以避免使用空的 spark 上下文。在我的例子中，我使用的是 Azure Databricks，所以我不知道这是否特定于 Databricks。
一旦模型被转换，您可以通过以下方式将其保存到文件中:
with open(os.path.join("/tmp/", "model.onnx"), "wb") as f:
f.write(onnx_model.SerializeToString())
您可以使用 Python 中的 ONNX 运行时轻松加载该模型，如下所示:
import onnxruntime
session = onnxruntime.InferenceSession(model_file_path, None)
output = session.get_outputs()[0]
inputs = session.get_inputs()input_data= {i.name: v for i, v in zip(inputs, input_sample.values.reshape(len(inputs),1,1).astype(np.float32))}}results = session.run([output.name], input_data)
注 :
input_data是以键为特征名，以张量(1，1)为值的字典。reshape函数将输入转换为一个形状为(feature_count，1，1)的张量数组，这是所期望的。将值转换为float32也很重要。
然后，您可以将这个模型放在 docker 容器中，并安装 Python 和以下库:
您的评分文件将使用onnxruntime.InferenceSession()方法加载模型。你通常只做一次。另一方面，您的计分例程将调用session.run()。
在下面的 GitHub 链接中，我有一个样本评分文件。
ONNX 在 Spark 中的局限性:
在撰写本文时，Spark-ONNX 转换器缺少以下特性:
- 缺少功能哈希、TFIDF、RFormula、NGram、SQLTransformer 和某些模型(聚类、FP、ALS 等)的导出程序
- 仅支持 PySpark
- 一些问题:ONNX 规范不支持 Tokenizer
选项 2:打包 PipelineModel 并使用 Spark 上下文运行它
在容器内部运行 PipelineModel 的另一种方法是导出模型，并在容器内部创建一个 Spark 上下文，即使没有可用的集群。
如果你想持久化这个 PipelineModel，这个对象实现了接口MLWritable，它扩展了方法save(path)和write().overwrite().save(path)。此方法将模型保存在如下所示的文件夹结构中:
piepline 模型的文件夹结构，由 VectorAssembler 和 GradientBoostedRegressor 组成。
在这种结构中，PipelineModel 保存在一个文件夹结构中，其中详细描述了管道中的所有步骤。在这种情况下，我创建的这个模型有两个阶段:一个 VectorAssembler 和一个 GradientBoostedRegressor。与您可能习惯的相反，所有的结构都需要加载和恢复训练好的模型。如果你使用的是一个模型注册中心，比如 MLFlow 或者 Azure 机器学习服务，我建议你把目录压缩到一个归档文件中。下面一行有助于做到这一点:
import shutilmodel.write().overwrite().save(model_path)
path_drv = shutil.make_archive(model_name, format='zip', base_dir=model_path)
请注意shutil.make_archive将在本地文件系统的驱动节点中创建文件。
如何在您的容器内使用它？
因为您将直接加载 Spark 模型，所以您需要在容器映像中安装pyspark Python 库。然后，在您的评分脚本中，您将创建一个 spark 会话，将归档文件解压缩到一个文件夹中，并加载 PipelineModel 对象。
import pyspark
from pyspark.ml import PipelineModelspark = pyspark.sql.SparkSession
.builder.appName("pyspark_runtime").getOrCreate()model_unpacked = "./" + model_name
shutil.unpack_archive(model_path, model_unpacked)trainedModel = PipelineModel.load(model_unpacked)
变量spark和trainedModel必须在所有程序中可用。我个人认为这两个变量是全局变量。
然后，通过以下方式运行您的模型:
input_df = spark.createDataFrame(pandas_df)predictions = trainedModel.transform(input_df).collect()
preds = [x['prediction'] for x in predictioprint('[INFO] Results was ' + json.dumps(preds))
我在下面的 GitHub 链接中有一个样本评分文件。
结论
在本文中，我们回顾了两种不同的方法来移植在 Spark 集群中训练的模型，以便在容器中运行它们。使用开放标准 ONNX 或在 Spark 上下文中加载持久模型。如果你想看到例子的完整代码，你可以查看 GitHub 库。还有一个 Databricks 记事本可以生成 ONNX 文件和 MLLib zip 文件。希望有帮助。
作为初级开发人员，如何为开源软件做出贡献
意见
它帮助我获得了我的第一份软件工程工作
我谷歌了一下“作为初级开发者如何为开源做贡献”。
给的建议没那么好。
随着时间的推移，它并没有发生太大的变化。而且没有在我还是初级开发者的时候帮我背，跟着它。
我将根据我为开源做贡献的经验分享一些替代建议。
常见的建议(对我没有帮助)
- 查找标有“初学者”的问题
- 选择流行的代码库
- 你不需要写代码
这不管用。尽管注册了邮件列表，发现了“初学者问题”，并试图找到有助于…
在发现一个小型机器学习库不允许导入自定义的停用词列表后，我偶然发现了我的第一个贡献。我正在从事的开发者组合项目需要这个特定的特性。
所以我给它写了代码，做了个 PR。经过 repo 维护者几个周期的反馈和修复，我的代码发布了。
事实证明，这比寻找回购协议要容易得多。原因如下。
为你实际使用的图书馆做贡献
如果你不使用你所贡献的库，你就是在黑暗中写代码。
使用一个库会给你一种幕后架构的感觉。如果你熟悉一个库的特性，你会更快地理解它的代码是如何组合在一起的。
外卖:
查看您使用的库中未解决的问题。如果出现一个简单的问题，尝试解决它并提交一份 PR！
向你喜欢的(或者认为很酷的)图书馆投稿
仅仅因为你使用一个库(见上)，并不意味着你喜欢它到喜欢贡献。
如果你认为图书馆的工作很有趣，你会有更多的动力去贡献。你的第一次投稿终究不会轻松！
外卖:
每个人都使用像 pip，bundler，yum，yarn 这样的包…但是如果你觉得他们做的事情没意思，那就辛苦了。找一些你感兴趣的东西。
用一个贡献者来贡献小的包是可以的
这甚至可能是你第一次投稿的好主意。
如果代码库很小，你会更容易找到方向。
是的，将来有可能一个小图书馆不会被维护。但是大多数图书馆也是如此。
在这一点上，你的目标是参与其中。
外卖:
不要羞于为一个小小的利基图书馆做贡献。
不要寻找带有“初学者问题”的回购
一些回购特别为初学者标记容易的问题。
如果你要解决这些问题，我建议你至少使用图书馆，并认为它很有趣。
否则，贡献仍将是艰难的。你必须弄清楚如何使用这个库，同时代码如何工作。
许多软件包不时会出现简单的问题，它们可能只是没有被标记出来。
外卖:
不要把自己局限在为初学者标记容易问题的库中。
为自己做贡献
你可以通过写你想要的特写来最大化你成功投稿的机会。
您将确切地知道它应该如何工作，因为这是您自己的用例。在软件开发中，这通常是编写代码的一半。
这是我的第一个开源贡献如此平易近人的原因。否则我想我不会这么容易成功。
外卖:
如果一个图书馆没有做你想让它做的事情，那就制造一个问题，问问你是否可以自己去做！
不要将文档更新为您的贡献
我明白了。首次捐款令人望而生畏。任何贡献都有助于建立信心。
也就是说，你是一名软件工程师，而不是一名作家(对吗？).你的一部分可能想为你的事业做点贡献。
编辑文档是一种简单的方法。与实际贡献代码相比，困难就相形见绌了。因此，如果您必须这样做，那么请尽快开始贡献代码。
好的文档在软件工程中非常重要。但是我们的目标是让你尽快贡献代码。稍后再回到文档。
外卖:
贡献文档可能会建立信心，但这只是贡献代码的第一步。
它会变得更容易
随着你编写软件的经验越来越多，你会对库是如何编写的有所了解，包括公共架构。
当你这样做的时候，导航代码库和弄清楚如何做出贡献变得更加容易。
为此，我要求你破解你常用的库的代码，并研究你使用的函数是如何编写的。
结论
这不是为开源做贡献的指南。这只是我对你完成第一次贡献的建议。
为开源做贡献帮助我找到了第一份工作。那时候我不是一个很好的开发人员，所以我可以做，你也可以！
大多数开发者都不会为开源做贡献。但是我们无限依赖开发者的慷慨。
那么为什么不试一试呢？
如何控制 2048 的游戏板
用极大极小算法玩 2048
…并完成最小最大算法的实现
作者图片
在本文中，我们将完成玩 2048 游戏的 minimax 算法的实现，然后我们将使用这个实现来自动玩这个游戏的 web 版本，这个版本可以在 Github 页面上找到。
这里是之前关于这个主题的文章，我在其中展示了如何表现 2048 年的游戏状态。如果您错过了，请查看:
…以及如何以面向对象的方式做到这一点
towardsdatascience.com](/how-to-represent-the-game-state-of-2048-a1518c9775eb)
为此，我们将首先创建GameDriver类，它将作为我们的 minimax 实现和网页上的游戏之间的中间人。GameDriver类负责与游戏交互。我们需要处理两个操作:获取游戏当前状态的数据，并做出一个动作:上、下、左、右。这两种操作通过以下方法实现:
.getGrid()—这将获取游戏状态数据，并将其作为Grid对象返回。.move()—这将把移动方向代码作为参数，并模拟适当箭头键的按键。
我们在实施中选择的移动方向代码是:
- 0 =向上
- 1 =向下
- 2 =左
- 3 =右
对于这个GameDriver类的实现，我们将使用 Selenium，它是做这种事情的一个好库:与 web 浏览器交互。如果你不知道，看看这篇文章。
现在，我们开始导入一些东西。从 Selenium 库中，我们需要 webdriver 和 Keys，它们将用于为您想要的 web 浏览器创建一个驱动程序实例，分别用于使用箭头键。我们还将 int 类型的最大大小作为MAX_INT和time包导入；过一段时间我们就会知道我们需要什么了。
from selenium import webdriverfrom selenium.webdriver.common.keys import Keysfrom sys import maxsize as MAX_INTimport time
接下来，我们为GameDriver类创建实例化方法。我们存储游戏页面的 URL，创建 Chrome 驱动程序的实例，并打开游戏 URL。然后，我们需要存储对页面主体元素的引用，以便稍后能够发送箭头键命令。我们还存储了一个字典，将移动方向代码映射到相应的箭头键。
.getGrid()方法提取关于游戏状态的数据并返回一个Grid对象。我们将数据存储为一个矩阵，并在返回时将其传递给Grid的构造函数。首先，用 0 初始化矩阵，然后当我们在页面上找到瓦片时更新它。
稍微考察了一下，Chrome 开发者工具里的游戏页面(CTRL+SHIFT+I)，我的结论是:
- 图块可以通过“图块”类名来识别。
- 网格上每个图块的位置(行号和列号)可以从每个图块的类属性中的“图块-位置- 列 - 行”形式的类名中提取。
- 图块编号是可以从“tile- num ”形式的类名中提取的最大值，它位于每个图块的类属性中。
下面是实现上述想法的代码:
下面的.move()方法向 body 元素发送适当的箭头键信号，以便按照它所采用的参数指示的方向移动。然后，我们使用time.sleep(0.1)在移动信号发出后暂停 0.1 秒，以便页面有时间更新自己。
def move(self, moveCode): self.body.send_keys(self.moves[moveCode]) time.sleep(0.1)
下面是GameDriver类的完整代码:
现在是实现 minimax 算法的时候了，它由 3 个函数组成:maximize()、minimize()和getBestMove()。如果你不熟悉极大极小算法，你可以查看这篇文章，以确保你理解这里发生了什么。
maximize()函数取参数:state为网格对象，a和b为来自α-β剪枝的α和β，d为最大允许深度。该函数返回一个形式为(maxChild, maxUtility)的元组，其中maxChild是使效用最大化的当前状态对象(在 minimax 算法树中)的子对象，maxUtility是maxChild游戏状态的效用值。
maxUtility变量将保存到目前为止遇到的节点的最大效用。在函数开始时，我们不知道任何效用值，所以我们认为最大值比任何效用值都小。我选择了-1。
然后，我们检查当前状态是否是一个终端节点，或者我们是否达到了最大深度。如果是，我们返回 None 作为maxChild并评估当前状态的效用，否则，我们继续迭代当前状态的所有子节点。在每一次迭代中，我们复制当前的游戏状态，并在一个可用的移动中移动；for 循环中的child变量是一个移动方向代码，用于进行该移动。
然后我们让 Min 通过minimize()函数完成他的移动，并从这个函数中获得当前迭代的子状态的效用。如果我们选择移动到循环中的当前子节点，这就是我们将得到的工具。如果这个效用大于我们之前的maxUtility，那么我们相应地更新maxChild和maxUtility。在这之后，我们根据α-β剪枝算法再做 2 次检查，这样我们就跳过了博弈树中那些我们事先知道它们不会给出最佳走法的路径。
minimize()函数类似于maximize()，但现在我们处于最小玩家的位置，我们试图选择效用最小化的移动。
getBestMove()函数调用maximize()并返回我们必须采取的行动的代码，以最大化我们的分数/效用。
下面是我们的 minimax 实现的代码:
现在，是时候创建一个游戏循环了，在这个循环中，我们重复以下三件事，直到游戏结束:获取游戏数据，使用极大极小法来确定什么是最好的走法，并实际执行这个走法。
当我们运行这个游戏循环时，我们的屏幕上应该会出现一个 2048 年的游戏，它会像页面顶部的 GIF 那样自动播放。
你可以在 Github 上找到这个项目的完整代码。
我希望您对这些信息感兴趣，感谢您的阅读！
这篇文章也贴在我自己的网站这里。随便看看吧！
如何将二进制文件转换成张量流记录
使用 Apache Beam 大规模转换自定义二进制文件
如果你有 JPEG 或者 PNG 的图片，可以使用 tf.io.decode_image 直接读入 TensorFlow。如果您的数据是某种特定于行业的二进制格式，该怎么办？
为什么 HRRR 要做张量流记录？
高分辨率快速更新(HRRR)模式是一个数值天气模式。因为当世界各国汇集它们的观测数据时，天气模型工作得最好，所以天气数据的格式由世界气象组织决定，并且极难改变。所以，HRRR 的数据是以#@的方式传播的！$@&=称为 GRIB 的二进制格式。
不管你在哪个行业——制造、发电、制药研究、基因组学、天文学——你可能都有这样的格式。一种现代软件框架都不支持的格式。尽管这篇文章是关于 HRRR 的，但是这里的技术将适用于您拥有的任何二进制文件。
张量流训练最有效的格式是张量流记录。这是一种 protobuf 格式，使训练程序能够缓冲、预取和并行读取记录。因此，机器学习的第一步是将特定行业的二进制格式文件转换为 TensorFlow 记录。
阅读 HRRR 文件
阅读 HRRR·GRIB 文件最简单的方法是使用一个名为 cfgrib 的软件包。这个包将底层数据作为自描述的 numpy 数组返回，这些数组被打包成一种称为 xarray 的格式。要使用 cfgrib，您需要一个名为 libecccodes0 的 Linux 库，它通常不安装在任何 Linux 发行版上。非常棘手的事情，但底线是我们需要在 bog 标准的 Google 计算引擎虚拟机上进行以下设置:
sudo apt-get -y --quiet install libeccodes0
python3 -m pip install -q cfgrib xarray
一旦我们安装了这两个，我们可以读取一个 GRIB 文件，并提取其中一个感兴趣的图像(在一个文件中有许多预测字段)，如下所示:
import xarray as xr
ds = xr.open_dataset(FILENAME, engine='cfgrib', backend_kwargs={'filter_by_keys': {'typeOfLevel': 'atmosphere', 'stepType': 'instant'}})
refc = ds.data_vars['refc']
refc.plot()
从云存储中读取
不幸的是，我们使用的 Python 包只适用于本地文件。它不读取云存储。谷歌云存储上有一个 HRRR 档案，网址如下:
gs://high-resolution-rapid-refresh/hrrr.20200811/conus/hrrr.*
预测文件非常庞大。我们希望从云存储中即时读取数据，这样我们就不必再为永久磁盘付费了。
要创建一个只处理从云存储中读取的本地文件的库，我们可以使用一个简单的技巧——创建一个临时目录，将文件从云存储中复制到本地磁盘，读取文件，并在完成后删除临时目录。这听起来有点拗口，但实际上很容易做到，因为 Python 的 tempfile 和 TensorFlow 的 tf.io.gfile 模块完成了所有繁重的工作:
import xarray as xr
import tensorflow as tf
import tempfile
import cfgrib**with tempfile.TemporaryDirectory()** as tmpdirname:
TMPFILE="{}/read_grib".format(tmpdirname)
**tf.io.gfile.copy**(FILENAME, TMPFILE, overwrite=True)
ds = xr.open_dataset(TMPFILE, engine='cfgrib', backend_kwargs={'filter_by_keys': {'typeOfLevel': 'atmosphere', 'stepType': 'instant'}})
refc = ds.data_vars['refc']
refc.plot()
转换为张量流记录
我们不希望只是读取数据，我们希望将其转换为 TensorFlow 记录。为此，我们必须创建一个 tf.train.Example:
refc = ds.data_vars['refc']
size = np.array([ds.data_vars['refc'].sizes['y'],
ds.data_vars['refc'].sizes['x']])
tfexample = tf.train.Example(features=tf.train.Features(
feature={
'size': tf.train.Feature(int64_list=tf.train.Int64List(value=size)),
'ref': _array_feature(refc.data),
'time': _string_feature(str(refc.time.data)[:19]),
'valid_time': _string_feature(str(refc.valid_time.data)[:19])
}))
TensorFlow 记录只能保存 bytes、int64、floats 类型的要素。所以，我们必须把其他所有东西都转换成这些类型。它也不了解 IEEE 类型，如-inf 或 nan。因此，要将一个 2D 数组转换成一组浮点数，我们必须做:
def _array_feature(value):
if isinstance(value, type(tf.constant(0))): # if value is tensor
value = value.numpy() # get value of tensor
value = np.nan_to_num(value.flatten())
return tf.train.Feature(float_list=tf.train.FloatList(value=value))
使用 Apache Beam 缩放它
这很好，但它只是一个文件。对于 ML 训练，我们需要转换大量的文件。我们需要进行大规模的转换。一个好的方法是使用 Apache Beam。管道将如下所示:
它应该花费 27 个小时，但我只花了 1 个小时，因为管道扩展到了许多机器上(在云上，在一台机器上花费 27 个小时的管道和在 27 台机器上花费 1 个小时的管道成本是相同的)。
完整的代码是这里是，但它的核心是:
p | 'hrrr_files' >> beam.Create(
**generate_filenames**(options['startdate'], options['enddate']))
| 'create_tfr' >>
beam.FlatMap(**create_tfrecord**)
| 'write_tfr' >> **beam.io.tfrecordio.WriteToTFRecord**(
os.path.join(options['outdir'], 'tfrecord')))
基本上，第一步是生成我想要转换的所有文件的名称(我可以列出 GCS 目录，但我想每小时对天气预报进行一次采样，因为天气在 15 分钟内不会发生太大变化):
def generate_filenames(startdate: str, enddate: str):
start_dt = datetime.strptime(startdate, '%Y%m%d')
end_dt = datetime.strptime(enddate, '%Y%m%d')
logging.info('Hourly records from {} to {}'.format(start_dt, end_dt))
dt = start_dt
while dt < end_dt:
# gs://high-resolution-rapid-refresh/hrrr.20200811/conus/hrrr.t04z.wrfsfcf00.grib2
f = '{}/hrrr.{:4}{:02}{:02}/conus/hrrr.t{:02}z.wrfsfcf00.grib2'.format(
'gs://high-resolution-rapid-refresh',
dt.year, dt.month, dt.day, dt.hour)
dt = dt + timedelta(hours=1)
yield f
第二步是创建 TF 示例，最后一步是将示例写到云存储中。
现在，还记得我们为了让 cfgrid 在我们的机器上工作所做的所有恶作剧吗？我们必须告诉 Beam runner 如何在每个 worker 节点上安装它需要的包。我们通过指定一个 setup.py 来实现，并在那里声明:
CUSTOM_COMMANDS = [
'apt-get update'.split(),
'apt-get --assume-yes install libeccodes0'.split()
]
和
REQUIRED_PACKAGES = [
'cfgrib',
'xarray'
]
在数据流上运行它
要在 Dataflow 上运行上述代码，我们只需运行代码。它将负责提交代码，自动缩放工人，并在完成后关闭一切。
python3 -m wxsearch.hrrr_to_tfrecord -- \
--startdate 20190101 --enddate 20200101 \
--outdir gs://{BUCKET}/wxsearch/data/2019 \
--project {PROJECT}
大约 60 分钟后，您将获得 2019 年 HRRR 反射率文件的相应 TF 记录。
链接
- 进行转换的代码: hrrr_to_tfrecord.py 。
- 在数据流工作器上安装必要软件的 setup.py 。
- 阅读本系列接下来的两篇文章:如何在 HRRR 数据上训练自动编码器，以及如何使用结果嵌入。
尽情享受吧！
如何将 DB2 查询转换成 python 脚本
提供一个简单的 3 步模板来提升技能并过渡到 python
克里斯蒂娜@ wocintechchat.com 在 Unsplash 上的照片
许多公司正在使用 python 脚本运行常见的数据分析任务。他们要求员工将目前可能存在于 SAS 或其他工具集中的脚本转换为 python。这个过程的一个步骤是能够用新技术获取相同的数据。本文是关于将 DB2 查询转换成 python 脚本的。
如何将查询转换成 python？这听起来很难，但比你想象的要简单。一旦有了数据源的模板，您需要做的就是更改查询和输出文件名。
有几种方法可以做到这一点，但是我将概述一个直观的模板，它允许您在本地笔记本电脑/台式机上运行 DB2 查询。
在 DiscoDonuts 使用您的 DB2 专业知识
让我们假设你在一家大型甜甜圈公司工作，DiscoDonuts。您需要对 DB2 运行以下查询。通常，您可能会使用 DataStudio 之类的工具。很简单。
SELECT store_id, donut_style, date, volume, net_sales
FROM donutsdb.sales_data
WHERE date = '2020-08-16'
WITH UR;
现在，您的经理要求您开始使用 python。深呼吸；没那么难。在设置好代码之后，您只需要更新两个字段，输出文件的名称和查询本身。然后你点击运行。这有多简单？
初始一次性设置
如果您还没有，您需要联系您的 IT 部门安装一个工具(“IDE”)(如 PyCharm、VSCode、Jupyter Notebooks)。
要连接到 DB2，您需要输入您自己公司的数据库、主机名和端口 id。最有可能的是，您在当前使用的任何工具中都已经有了这些信息。
模板
首先，填写数据库连接信息。现在你可以保存这个模板，以备不时之需。
对于您想要运行的每个查询，您需要更新输出文件名和实际的查询本身。该查询被传递给 DB2，因此它与您已经在使用的 DB2 格式相同。
import ibm_db
import ibm_db_dbi
import pandas as pd# name your output file (and path if needed)
output_filename = "donut_sales.csv"# enter your query between the triple quotes
query = """ SELECT store_id, donut_style, date, volume, net_sales
FROM donutsdb.sales_data
WHERE date = '2020-08-16'
WITH UR;
"""# one way to do credentialing
import getpass as gp
uid=input('Enter uid: ')
pwd=gp.getpass('Enter password (hidden): ')# connect to your database
db = (
"DRIVER = {IBM DB2 ODBC DRIVER - DB2COPY1};"
"DATABASE=<your donut database>;"
"HOSTNAME=<your db2 hostname>;"
"PORT=<your db2 port ####>;"
"PROTOCAL=TCPIP;"
'UID='+uid+';'
'PWD='+pwd+';')
ibm_db_conn = ibm_db.connect(db, "", "")
pconn = ibm_db_dbi.Connection(ibm_db_conn)#optional if you are using the accelerator #ibm_db.exec_immediate(ibm_db_conn, "SET CURRENT QUERY ACCELERATION = ALL") df = pd.read_sql(query, pconn)
df.to_csv(output_filename,index=False)
点击运行。您将被要求输入您的凭证，您的查询将在 DB2 上运行，数据将被传输回您的脚本，您的文件将被创建！
如果您愿意，所创建的数据框可作为您的数据在 python 脚本中进行进一步分析。
下一个查询的三个步骤
- 更新您的输出文件名
- 更新您的查询
- 点击运行！
结论
将 DB2 SQL 知识转移到 python 并不困难。这是一项很好的技能，可以与他人分享。
我总是欢迎反馈。如果你有另一种技巧，请在回复中分享。解决问题的方法有很多，我只介绍了其中一种。代码是不断发展的，所以今天有效的可能明天就无效了。
如何将 Jupyter 笔记本转换成 pdf
用几行代码将 Jupyter 笔记本转换为 pdf(调试“500:内部服务器错误”)
照片由Cookie Pom在 Unsplash 拍摄
如果你是许多正在找工作的数据科学家中的一员，你可能会发现自己正在从事数据科学的家庭作业。如果您能够转换笔记本并提交 pdf 版本，而不是共享您的 Jupyter 笔记本，将会更加整洁。在这篇博客中，我想分享你如何用几行代码将 Jupyter 笔记本变成 pdf 格式！
之前的一次课后作业让我学会了如何做这件事
安装 nbconvert 和 LaTeX
nbconvert 允许用户将笔记本转换成其他格式。安装 nbconvert 后你会想，你可以开始了…对吗？如果这么简单，我为什么要写这篇文章？
在我安装了 nbconvert 之后，我收到了一个错误，上面写着“500:内部服务器错误。”之所以会看到这个错误，是因为你还没有安装 LaTeX 或者 Pandoc 。我决定下载 LaTeX。下载 LaTeX 的好处是，它让你的分析看起来像一篇研究论文，这非常合法。
从命令行运行 nbconvert
安装这两个软件包后，您可以尝试使用以下命令行将笔记本转换为您想要的格式:
$ jupyter nbconvert --to FORMAT notebook.ipynb
这个命令行将把 Jupyter 笔记本文件转换成由FORMAT字符串给出的输出格式。出于本文的目的，我们将把它转换成 pdf，但是您也可以把它转换成 HTML、Markdown 等。如果你想把笔记本文件转换成 HTML，只需把pdf替换成html，反之亦然。
$ jupyter nbconvert --to pdf notebook.ipynb
根据您之前安装的软件包，您可能需要降级或升级其中的一些软件包。
例如，如果您看到以下错误消息…
spyder 3.3.6 has requirement pyqt5<5.13; python_version >= "3", but you'll have pyqt5 5.13.0 which is incompatible
您可以通过卸载 pyqt5 并安装 pyqt5==5.12.0 来解决此错误。
安装 nbconvert 模板
在我成功地将笔记本转换成 pdf 文件后，我意识到文件的边距是关闭的！幸运的是，我在提交之前仔细检查了文件！
下面是对比。默认情况下，我们可以看到保证金是非常关闭。默认的 pdf 格式会切掉页面的一边。
泰勒·马卡罗在他的 Github 上的照片
为了解决这个问题，我找到了一个由泰勒·马卡罗创建的模板。我首先通过运行命令行安装了他的nb_pdf_template:pip install nb_pdf_template.，然后我将cd放入 LaTeX 文件夹，并添加了 Tyler 创建的两个模板:classic.tplx 和 classicm.tplx。最后但同样重要的是，不要忘记从 LaTeX 文件夹中删除默认的 article.tplx。
完成后，您将能够通过运行以下命令行获得格式良好的 pdf:
$ jupyter nbconvert --to pdf notebook.ipynb --template classic
结论
以下是您需要的所有软件包:
你有它！如果你觉得这很有帮助，请分享并关注我的博客，这样你就不会错过了！
下次见，快乐学习！👩🏻💻
如果你喜欢我的内容，请关注我❤️，看看我最近的博客:
举例说明最常见的离散概率分布
towardsdatascience.com](/understanding-and-choosing-the-right-probability-distributions-with-examples-5051b59b5211) [## 作为分析师如何准备商业案例面试？
作为数据分析师或数据科学家，我们不仅需要知道概率和统计，机器学习算法…
towardsdatascience.com](/how-to-prepare-for-business-case-interview-as-an-analyst-6e9d68ce2fd8) [## 构建电子商务产品推荐系统:第二部分——模型构建
这个博客是我之前工作的延续，在我之前的工作中，我谈到了我是如何收集产品评论和…
medium.com](https://medium.com/@kessiezhang/building-a-product-recommendation-system-for-e-commerce-part-ii-model-building-8b23a9b3ac27) [## 为电子商务建立一个产品推荐系统:第一部分——网络搜集
今天，如果我们想到机器学习在商业中最成功和最广泛的应用，推荐者…
medium.com](https://medium.com/@kessiezhang/building-a-product-recommendation-system-for-e-commerce-part-i-web-scraping-798b6251ab51)
对于多元回归问题，如何将 Pandas 数据框架转换为 Keras RNN，然后再转换回 Pandas
这篇文章提供了一个简单的 Python 代码，它采用熊猫数据帧中的数据，并使用 Keras RNN LSTM 模型以相同的格式输出预测。
我遇到的问题相当普遍(我认为):以pandas dataframe格式获取数据，并使用带有keras RNN 的时间序列回归模型进行预测，其中我有不止一个独立的X(也称为特征或预测器)和一个依赖的y。更准确地说，问题不是构建模型，而是将数据从pandas dataframe格式转换成 RNN 模型(在keras中)需要的格式，并从keras模型中获得预测作为pandas dataframe。
感觉无论我在哪里寻找解决方案，我都能得到关于 RNN 如何工作的解释或者单变量回归问题的解决方案。因此，我会尽量保持这篇文章的简洁和集中。这里的编码假设您已经做了所有必要的预处理(例如，数据清理、特征工程等。)并以pandas dataframe格式准备好用于分析的时间序列。
你不会在这里找到的:
理论解释
RNN 模型的精美插图
预处理技术
复杂或精密的模型
网上有很多资源可以很好地解释这些问题，我强烈推荐查看一下 StackOverflow 的问题和杰森·布朗利的博客帖子。
你会在这里找到什么:
一个简单的 Python 代码，采用一个pandas dataframe并使用一个keras RNN LSTM 模型以相同的格式输出预测，用于多元回归问题。
这篇文章将描述代码片段和解释，并在最后提供完整的无缝代码。
让我们开始吧:
第一步，让我们导入所有需要的包并检查keras版本
如你所见，我的keras版本是2.3.1，所以如果你对我在这里发布的代码有一些问题，请检查你是否有相同或更高的版本。
第二步，读取数据
如你所见，我有 32，128 行 4 列，有一个y 和三个X。这里的代码可以在任意数量的X 上运行，包括一个X *。*注意，你需要定义你的y列，以使事情变得更简单和通用。
可选步骤-绘制数据
我知道，这里的分辨率不是很高，但是你可以想象我的数据是什么样子的。
第三步，拆分数据进行训练和测试
请注意第三行的注释。让我们再次策划，看看我们的分裂是否有意义。
还是那句话，不要介意分辨率，这不重要。图看起来不错，过去(蓝色)是我们的训练数据，最近的日期是我们的测试数据(橙色)。
第四步，只对训练数据分开X和y。我们将稍后处理测试数据。
现在，X_train看起来像这样:
而y_train看起来是这样的:
步骤 5，为keras缩放并准备X和y数据
这部分需要一些解释。这里我们将数据从pandas数据帧转换成keras所需的numpy数组。在第 1–8 行中，我们首先使用sklearn MinMaxScaler模型缩放X和y，使它们的范围从 0 到 1。接下来的几行是对y的一些形状处理，以使其适用于keras。我们需要y的形状是(n, )，其中n是行数。第 12 行通过在第一个位置添加零将y数据向前“推”一步，第 13 行通过删除最后一个时间步(最后一行)保持y的形状。下面是第 12–13 行中发生的情况的一个简化示例:
#let's say y = [1,2,3,4]
# y = np.insert(y,0,0) --> [0,1,2,3,4]
# y = np.delete(y,-1) --> [0,1,2,3]
如果这个解释不够清楚，我建议你参考 Jason Brownlee 的博客文章。查找标题为:多元输入和相关系列示例的部分。
总结一下y的形状操控，让我们快速看一下发生了什么。我们从作为数据帧的y数据开始:
现在它应该是这样的:
array([0\. , 0.12779697, 0.12401905, ..., 0.59237795, 0.6018512 , 0.61132446])
第六步，使用keras和TimeseriesGenerator组合X和y
TimeseriesGenerator将分离的X和y转换成样本结构，准备训练深度学习模型。我建议打印生成器对象的形状，以确保它能够工作。形状应该与第 8 行第 6 步中显示的完全一样。
将我们的数据从pandas dataframe转换成可用于深度学习模型的东西的困难部分已经过去了。现在我们可以进入第 7 步，实例化模型:
请注意，我在这里使用了一个非常简单的模型，只有一个隐藏层，没有脱落层。这是因为我想保持这篇文章的简洁，实际的模型架构不是这里的重点。但是可以随意尝试更多的层。
第八步，拟合模型并绘制损失图
同样在这里，我使用了简单的设置，只有 5 个时期，只是为了说明整个过程。
现在模型可以使用了，我们可以在测试集上进行预测。
第一行通过从测试集中删除y 来生成X_test数据，我们不希望y 数据包含在X中。然后我们根据之前安装在X_train上的MinMaxScaler模型来缩放X_test。第 3 行很重要，因为我们需要为测试数据创建一个TimeseriesGenerator。我很纠结这部分，因为在我看到的例子中，这里包含了y_test，但是我不希望模型有任何关于y_test数据的知识。我不希望有任何可能导致预测偏差的数据泄露。多亏了 Marco Cerliani 在 StackOverflow 上给了我很大的帮助，我明白了TimeseriesGenerator中的第二个参数，也就是y_test只是一种预测方法，并且y_test的实际值并不重要(在这个特定的地方)，所以你可以插入一个虚拟的y_test →一个与实际y_test数据形状相同的零数组。TimeseriesGenerator的其余部分类似于训练数据，这里我也打印了形状以确保它没问题。
第 10 行调用预测方法，第 11 行重新调整预测。记住，我们之前在 0 和 1 之间缩放了y数据，所以我们需要将它缩放回来。在第 12 行，我们从y_true和y_pred构造了一个dataframe。注意，我们只调用了y_true ( test[y_col].values[n_input:])的子集，这是因为模型需要n_input时间步长(行或观察值)来开始预测，所以它从X_test中取出这些n_input (在本例中为 25 个时间步长)，然后才开始预测。例如，如果我们的测试集中有 50 个时间步长(或 50 行或 50 个观察值)，那么我们将只有 25 个预测，因为前 25 个是模型根据我们设置的体系结构使用的。
现在我们有了一个很好的熊猫数据帧结构:
我们可以使用results.plot();来绘制它们:
就这样，我们以pandas dataframe格式的数据开始，以同样格式的预测结束。
这是一个块中的全部代码
我希望这是有用的，将有助于您的机器学习任务。如果你有任何意见，请写在下面给我。
如何将 SQL 查询结果转换为熊猫数据框架
使用 Python 读取 Jupyter 笔记本中的 SQL 查询来创建熊猫数据框架
Tobias Fischer 在Unsplash【1】上拍摄的照片。
目录
- 介绍
- 工具
- 例子
- 摘要
- 参考
介绍
作为一名数据科学家，您可能经常需要从数据库表中提取数据。建模过程中收集数据集的第一步通常是从 SQL 代码的结果中获取。SQL 通常不是成为数据科学家所需的主要语言；但是，在某些情况下，练习和利用来获取数据集是很重要的。不过，也有一些问题——来回使用 Python 代码、SQL，有时还有 Jupyter Notebook，可能会加重问题。有一个非常简单的过程可以帮助解决这个问题。解决方案是在 Jupyter 笔记本中编写 SQL 查询，然后通过将其转换为 pandas 数据帧来保存输出。下面，我将提供代码和一个例子来展示这个简单而有益的过程。
工具
这个过程由几个关键工具组成。首先，您将使用您原来已经有的 SQL 查询，然后，使用 Python，将引用 pandas 库来将输出转换成数据帧，所有这些都在您的 Jupyter 笔记本中。
SQL —结构化查询语言，大多数数据分析师和数据仓库/数据库工程师使用这种语言来拉取数据，用于报表和数据集开发。
--return all columns from table
SELECT * FROM TABLE
Python —数据科学家使用的主要编程语言之一。
# display text
print('Hello, world!')
Pandas —数据科学家用来从各种来源读取数据的流行图书馆。静态数据可以作为 CSV 文件读入。还可以使用 pandas 连接一个活动的 SQL 连接，然后将其从输出转换为数据帧。在下面的例子中对此进行了解释。
# creating and renaming a new a pandas dataframe column
df['new_column_name'] = df['original_column_name']
Jupyter Notebook —为您的数据科学模型运行 Python 代码(以及 SQL)的平台/环境。
例子
在这个例子中，我将使用一个模拟数据库作为 SQL 查询将引用的存储环境。
首先，导入 pandas 库，如果需要，创建一个别名’ pd’ ,用于速记符号。接下来，创建一个凭据变量来存储:
- 数据库/SQL 环境— PostgreSQL
- 用户名:密码
- 数据仓库:数据库 URL (IP 地址)
- 通道数
- 数据库名称
这个变量将是一个用引号括起来的长字符串。Jupyter 笔记本中的下一个单元格将是 SQL 查询本身。Pandas 将用于执行查询，同时将输出转换为数据帧。该查询的格式是包含带有三重引号的语句。在最后一个引号之后，逗号后面会跟一个连接参数，该参数将等于您的凭据变量。
以下是该示例的代码(您必须使用自己的凭据):
# import python library
import pandas as pd# assign a variable that contains a string of your credentials
credentials = "postgresql://username:password@your_sql_connection_url:port_number/database_name"# read in your SQL query results using pandas
dataframe = pd.read_sql("""
SELECT column_1, column_2
FROM Table
WHERE column_1 > number
ORDER BY column_1
""", con = credentials)# return your first five rows
dataframe.head()
仔细看看 Jupyter 笔记本中的代码:
Jupyter 笔记本的例子(改为 read_dql 改为 read_sql)。作者截图[3]。
更多关于熊猫功能的文档，点击这里【4】。您还可以在那里找到更多关于参数的有益信息。
摘要
当创建将用作数据集的数据框时，有大量选项可用于收集该数据。有时读入 CSV，而数据帧可以通过定义列和值来生成。但是，在本例中，我们看到您可以使用 SQL 从数据库中查询，并将这些结果作为数据返回，最终作为新的数据帧读入。现在你有了数据框架，你就可以遵循数据科学的正常流程了。希望这篇文章对您有所帮助，感谢您的阅读！
参考
[1]照片由托比亚斯·菲舍尔在Unsplash(2017)拍摄
[2]Chris Ried 在 Unsplash 上拍摄的照片，(2018)
[3] M.Przybyla，Jupyter 笔记本截图，(2020)
[4]熊猫，(2008 年至 2014 年)
如何用 PyTorch 烹饪神经网络
使用 PyTorch 的深度学习项目的诀窍
py torch 训练配方
好了，你已经决定了这道菜(你的神经网络)，现在你需要用 PyTorch 来烹饪(训练)它。但是等等，这不是一个简单的“快餐”任务，不像其他流行的 python 机器学习库(例如 Scikit Learn ， Keras )那样运行fit()和eval()方法的一些变体。你需要遵循一个食谱(过程)并自己定义这些方法。你可能会问，为什么？嗯，这里当然有一个权衡。虽然 PyTorch 以其可解释性、pythonic 式和可调试代码以及创建动态计算图的能力而闻名，但它不像 Keras 那样实用，因为它缺乏更高级别的 API，尤其是在训练和评估模型方面。同样，这是一个权衡:灵活性与实用性。PyTorch 侧重于前者，但也有让训练和评估更容易的库，比如 ignite 、 fastai 和 lightning (举几个例子)。
所以回到我们的食谱…我们先看一下大图，然后放大到每一步。让我们后退一步，看看一个典型的 ML 过程可能是什么样子。原来有一个简单的食谱你可以遵循。事情是这样的:
- 加载和预处理数据
- 定义模型、优化器和损失
- 训练和验证模型
- 评估模型
现在让我们看看如何在 PyTorch 中实现这一点。我将向您展示一个包含一些样板代码(没有双关的意思)的菜谱，您可以按照它来开发和训练您自己的模型。然后，它将取决于你改变配料和香料的食谱在这里和那里！
1。数据加载和预处理
定义变换(仅用于图像分类 )
如果您正在进行影像分类，您可能需要转换数据。PyTorch 的torchvision模块有一个很好的子模块叫做transforms，可以让你构建一个转换管道。不像在 Keras 中，这里你可以定义变换的顺序。这些变换可以包括图像增强技术，如调整大小、裁剪、颜色抖动、图像翻转等。转换的详细列表可以在 PyTorch 网站的这里找到。
如果你的数据集很好并且标准化了(所有的图像都有相同的大小，几乎都在中心，没有颜色变化，图像没有旋转或翻转)，就像 MNIST 一样，那么你可能只需要将你的图像转换成张量并标准化它们。下面是一个简单的转换管道的例子，您可以使用transforms模块将它用于标准化数据集。
在上面的例子中，ToTensor()转换将图像作为输入，然后通过将每个通道的值除以 255，在 0 和 1 之间缩放每个像素值(我们正在处理上面的灰度图像，它只有一个通道)。接下来，张量被归一化，使得值在-1 和 1 之间(从 0.5 的平均值中减去先前缩放的像素，然后除以 0.5 的标准偏差)。这就像一个管道，对于预处理图像非常方便。
但是，如果您试图对猫和狗的图像或任何真实世界的数据集进行分类，您可能会从数据扩充中受益。主要思想是，当你的模型在更多种类的数据上被训练时，它将更好地概括。数据扩充是一种通过对原始内容进行变化(或转换)来利用现有数据的技术。这里有一个如何完成这项任务的例子:
变形金刚的名字非常直观，你可以通过浏览 PyTorch 文档查看这些和其他变形金刚的定义。请注意如何为训练集和测试集定义不同的转换。此外，请注意，在标准化步骤中，我们现在有三个通道，而不是一个。
下载数据集
PyTorch 为您提供了一些包含或下载数据集的选项。torchvision包包含预加载的数据集，如 CIFAR10 和 MNIST ，如果你想对你的模型进行基准测试或只是想学习图像分类，这将非常方便。如果你想对你自己的图片进行分类或者从网上下载，你需要另一种方式来加载数据集。为此，PyTorch 提供了ImageFolder类，该类假设您已经将所有图像存储到以每个类标签命名的目录中(即文件夹‘dog’将包含狗的图像，文件夹‘cat’将包含猫的图像)。您应该有一个结构相同的 train 和一个 test 文件夹。这样，您可以像这样加载数据:
现在，假设您需要对您的图像进行一些清理和预处理，或者如果您不进行图像分类，而是需要编写一个基于文本的分类器，要求对文本进行预处理，或者您需要在表格数据集上预测销售额，要求在将数据输入模型之前进行清理或某种数据争论。对于这些情况，您可以通过从torch.utils.data扩展Dataset类来创建自己的数据集。您需要定义三个方法，遵循如下的模板:
这是一种更优雅、更灵活的定义数据集的方法，也是通用的，适用于任何类型的数据集。一旦定义了数据集，就可以实例化该类并为多个集合传递参数，比如 train 和 test。所以你会有类似于…
你可以在这里获得更多关于创建自定义类以及其他自定义数据相关类的信息。
创建验证集
好了，是时候拆分并创建一个验证集来帮助你实现目标了。注意这是一个可选步骤，但绝对是一个最佳实践，强烈推荐用于评估和优化您的模型。创建验证集的一种方法是使用torch.utils.data中的random_split函数。这非常简单，只需要您想要分割的数据集和每次分割的大小。
定义数据加载器
一旦定义了数据集，就需要将它们包装在一个名为DataLoader的类中。这个类基本上是一个简单的方法，可以让你加载批量数据，并且包括免费的并行处理，不需要做任何额外的编码。很酷的东西。让我们来看看:
2。定义模型、优化器和损失
很好，现在您已经准备好开始定义您的模型了。定义模型有几种不同的方法，我将在另一篇文章中介绍。但是现在，我们只选择类方法，因为它是 PyTorch 中最流行的方法之一，而且非常直观。这是你发挥创造力的地方。根据您的问题，您可以尝试不同类型的神经网络和架构。为了便于说明，我选择实现一个简单的 CNN。
你可以在这里找到更多关于创建你的定制模型的信息。好了，现在你已经定义了你的模型，你可以实例化它，并定义优化器和损失函数。这些都是一行程序，很容易实现。让我们先实例化模型。
输出:
MyCNN(
(fc1): Linear(in_features=32, out_features=16, bias=True)
(fc2): Linear(in_features=16, out_features=8, bias=True)
(fc3): Linear(in_features=8, out_features=2, bias=True)
)
接下来，要定义优化器，您需要从 PyTorch 导入optim模块。PyTorch 有很多优化器，你可以在这里查找完整的列表来看看使用哪一个。每个优化器都有不同的参数，但是大多数都需要至少一个学习率，称为lr。为了让 PyTorch 优化您的网络，您首先需要传递模型参数。它应该是这样的:
然后，您需要定义 PyTorch 将使用的损失函数，以了解您的模型预测离实际目标有多远。损失函数的选择取决于你试图解决的问题的类型，你可以在这里找到更详细的损失列表。现在，我们将使用二元交叉熵损失，适用于二元分类问题。我们将该损失标准称为标准，如下所示:
3。训练并验证模型
Becca Tapert 在 Unsplash 上拍摄的照片
好了，现在你开始真正的烹饪了。如果与我之前提到的 sklearn 或 keras 相比，火车循环并不直接，但它非常直观，可以帮助您了解引擎盖下发生了什么，另外您可以通过插入跟踪来非常容易地调试它。你基本上只需几步就能完成一个火车环…
你在上面看到的是一个带验证的简单 PyTorch 训练循环。然而，在实践中，您可能希望累积精度或您选择的度量和/或在每个时期结束时应用早期停止。好的方面是这是完全可定制的。真的，天空才是极限。尽管出于本文的目的，我们将保持简单。
4。评估模型
斯蒂芬·约翰逊在 Unsplash 上拍摄的照片
训练完模型后，最后一步是预测和评估结果。测试循环与验证循环非常相似，但是相反，您将查询test_loader来读取测试数据，并且只运行一次测试数据来评估模型。换句话说，您不需要担心 epochs，因为您只想查看模型在每个实例上的执行情况。
结束语
既然您已经看到了它有多简单，那么您可以自己尝试用 PyTorch 构建一个神经网络！食谱基本上是一样的，但你可以在这里或那里改变一些成分，根据你的味蕾进行定制。还有其他方法可以实现这些步骤，但是我决定向您展示我认为最简单的一种方法。让我知道你的想法，我很想知道你是怎么做这道菜的！
如何在加密的 S3 桶交叉帐户之间复制
包括一步一步的教程
在加密存储桶、交叉帐户之间复制时涉及的所有资源的概述。用 Draw.io 创建
加密很棘手，即使你使用的是 AWS 这样的托管服务。
在我的上一篇文章中，我讲述了你需要了解的关于 IAM 的内容，IAM 是 AWS 提供的身份和访问管理服务。在这篇文章中，我想更具体一点，介绍一个常见的场景，其中有大量不同的权限在起作用。在这里，您将看到我之前谈到的所有不同类型的资源都在运行，希望一切都会顺利。
如果你需要 AWS 中权限如何工作的基础知识，请阅读我的对 IAM 的介绍帖子。
概观
假设我们使用几个 AWS 账户，我们想将某个 S3 桶中的数据从一个源账户复制到某个目的地账户，如上图所示。此外，让我们想象我们的数据必须在静态下加密，出于监管目的；这意味着我们在和账户中的桶也必须被加密。
在 AWS 上实现上述目标有很多方法，但我将讨论以下组合:
- KMS 用于主密钥的加密/解密。一种替代方法是实现客户端加密并自己管理主密钥。
- 使用客户管理密钥的 S3 服务器端加密适合您的使用案例。与 S3 托管密钥相比，客户托管密钥有几个优点，比如审计跟踪。
- S3 默认加密适合你的桶对象；这意味着添加到 bucket 中的对象将被自动加密，而不需要您指定一个标志来加密它们。
- 作为执行复制的身份的角色，与用户相对。
政策
这里有 5 个主要的资源:我们的两个处理桶加密的主密钥，我们的两个 S3 桶，以及我们的角色。这意味着您需要 4 个资源策略(不包括角色的信任策略)和 1 个身份策略才能正常工作。
注意:你不能复制/粘贴下面的所有内容。对于每个策略，您必须将资源 ARNs 和帐户 id 更改为属于您的源/目标的资源 ARNs 和帐户 id。
角色身份策略
这是我们将附加到我们的S3Porter角色的身份策略，以便让它联系 S3 和 KMS。这里有 4 个必要的语句:顶部图表中的每个资源一个。
- 从跨帐户来源时段复制。跨帐户访问要求发送方的身份策略和接收方的资源策略都允许访问。在本例中，我们允许发送者发出请求。
- 复制到同一个 AWS 帐户中的 bucket。请注意下面的策略是如何将资源限制在单个 S3 存储桶中的:作为一种最佳实践，重要的是将您的策略限制在它们绝对需要的资源上。
- 使用跨帐户 KMS 密钥来解密我们的源桶中的对象。
- 加密到我们的目的地账户。这可能看起来很有趣，我们仍然需要对我们的目的地 bucket 的
kms:Decrypt权限，因为我们只是将数据复制到其中。我们需要kms:Decrypt是因为，在幕后，S3 可能会把你的文件分成块，然后重新组合以便把它们复制到一个桶里。重组过程可能需要您的角色具有解密权限，因为文件的大部分在最初上传时将被加密，并且在重组前需要再次解密。您可能会注意到该策略需要kms:GenerateDataKey权限；之所以需要这些，是因为 S3 会用从你的主密钥导出的唯一密钥来加密你的每个对象，这个过程被称为信封加密。
目标存储桶资源策略
我们的目的地 bucket 不需要资源策略，因为对它的请求来自同一个 AWS 帐户中的 S3Porter 角色，并且我们已经在我们的身份策略中添加了对目的地 bucket 的s3:PutObject权限。
值得注意的是，我们还可以在目的地桶上添加一个资源策略，而不是在上面的S3Porter身份策略上添加它。
目标加密密钥资源策略
下面实际上是默认的密钥策略。有点无聊。
然而，值得注意的是，KMS 的关键政策不同于大多数资源政策。如果没有显式访问权限，则不允许仅身份策略上的 IAM 权限访问 CMK，即使在同一个 AWS 帐户中也是如此。在 KMS 密钥策略中，赋予帐户内策略访问密钥的能力的默认方式是允许根帐户用户访问密钥；这也将使其他 IAM 策略能够关键地采取行动，如下所示。
源时段资源策略
为了允许跨帐户访问 S3 存储桶，我们需要添加一个资源策略，称为*存储桶策略，*到我们的 S3 存储桶。这个策略相对简单:
- 在主体部分中，我们指定要授予权限的交叉帐户角色的 ARN。
- 在 actions 部分，我们提供了
s3:GetObject和s3:ListObject权限。这两个都是获取我们桶中所有内容所必需的。 - 作为资源，我们指定了 bucket 本身
arn:aws:s3:::source以及 bucket 中的所有对象 tarn:aws:s3:::source/*。
缺少任何这些东西都可能导致一个相当模糊的 403(拒绝访问)。
更复杂的 bucket 策略可能使用条件来限制 IP 地址范围或缩小我们的S3Porter角色可以访问的对象。
授予以下权限的另一种方式是使用访问控制列表(ACL)。ACL 是 IAM 之前 S3 管理权限的“老方法”。ACL 没有被弃用，但是它们是遗留的，并且 AWS 推荐使用桶策略来代替。
源加密密钥资源策略
最后，我们还有一个策略，允许我们的S3Porter从我们的跨帐户源桶中解密数据。
漫游教程
下面我设置并执行两个桶之间的复制，交叉帐户。
我建议在自动化或使用基础设施即代码签入东西之前，自己完成下面的内容，以获得跨帐户存储桶访问的舒适性。
- 为了隐私，我已经把所有的 id，ARNs，账户等等的名字都改了。
- 当然，首先您必须拥有创建所有必要对象的权限。对于本教程，我假设您有两个概要文件:
source-admin和destination-admin。你可以看到我是如何用下面的~/.aws/credential文件建立这些档案的。
**注意:**这里值得一提的是，我们使用的是 AWS CLI 的第 2 版。AWS CLI 很棒，因为默认情况下，它使用 TLS 1.2 对我们传输中的数据进行加密，所以不用担心我们在这里通过网络发送明文。
为我们的教程创建和设置所有的资源。
接下来，我们需要编辑我们的~/.aws/credentials文件；这将让我们使用我们的搬运工角色作为个人资料。
这是 AWS 概要文件在设置了上述所有用户和 S3Porter 角色后的样子。请注意来自承担角色的凭证是如何手动添加的。
最后的步骤
如果你遵循了上面的例子，记得在这么做的时候拆掉你创造的任何资源！
感谢阅读！如果你想聊天或对帖子有反馈，你可以随时通过 Twitter、LinkedIn 或 evankozliner@gmail.com 联系我
笔记
[1]对信封加密的全面概述超出了本文的范围，但是信封加密是一个重要的(也是有趣的)话题。信封加密很方便的原因有很多:从简化主密钥的轮换并确保它们留在 HSMs 中，到通过允许使用不同的算法来存储对象和密钥来加速加密。
如何使用 Ceres Solver 创建一个 C++项目？
开始使用 Ceres 解算器的逐步步骤
使用 Ceres 优化的 3D 姿势图示例。来源:谷神星教程
我猜你们大多数人已经知道一点谷神星解算器是什么。对于那些没有听说过它的人来说， Ceres Solver 是最受欢迎的开源库之一，用于解决大型复杂的优化问题。Ceres Solver 的一个突出特点是能够解决带有边界约束的非线性最小二乘问题。它在机器人学中广泛用于解决束调整和 SLAM 等问题。用户和应用程序的集合可以在官方网站上找到。
尽管 Ceres Solver(在本文的其余部分称为 Ceres)有很好的文档和实践教程来帮助新用户入门。我发现关于如何使用 Ceres 创建一个新项目的信息隐藏在官方指南中。这正是这个故事的内容。
安装 Ceres
首先，我们需要安装 Ceres 才能使用。在这一节中，我们将讨论如何在 Ubuntu 机器上构建和安装 Ceres 作为静态库。如果您正在使用不同的操作系统，或者您更喜欢将 Ceres 构建为共享库，请遵循安装页面上的说明。
我们从推荐给 Ubuntu 的依赖项开始:
在 Ubuntu 上安装 Ceres 的依赖项
然后我们从 Ceres 的网站上获取源代码。在撰写本文时，最新的稳定版本是 1.14.0。请在以下命令中相应地调整版本:
将 Ceres 构建为静态库
现在我们已经成功编译了谷神星。我们应该能够运行谷神星的 HelloWorld 示例。
运行 Ceres 附带的 Hello World 示例
最后一步是将 Ceres 安装到之前指定的安装目录中:
根据安装目录，您可能需要也可能不需要sudo权限。
使用 Ceres-Solver 创建一个项目
在上一节中，我们已经讨论了将 Ceres-Solver 作为静态库来构建和安装。我们还运行了 Ceres 附带的 HelloWorld 示例。下一步是能够编译我们自己的 HelloWorld 程序，并开始探索谷神星的魔法世界。
为此，我们将创建一个简单的项目，如下所示:
my_project
├── CMakeLists.txt
└── helloworld.cc
helloworld.cc只是我们之前运行的 HellowWorld 示例的源代码。你可以从 Ceres 的 git 库获得。还有许多其他可用的示例，包括但不限于圆拟合示例、束调整示例、姿势图优化的 2D & 3D 示例等。
CMakeLists.txt包含关于如何使用CMake 构建系统构建我们的helloworld.cc的信息:
helloworld.cc 的 CMakeLists.txt
注意 Ceres 官方支持 CMake 2.8 向后兼容。但 2020 年采用 CMake 3.x 风格对我们来说并无大碍。
如果你不熟悉 CMake 构建系统，我强烈推荐 Aakash Mallik 的 C++应用开发系列。
如果您想发布使用 Ceres 的项目，请参考安装/导出使用 Ceres 的项目了解更多信息。
希望这个简写版的 Ceres 安装指南对那些不熟悉 CMake 的人有所帮助。
参考
[## Ceres 求解器——一个大规模非线性优化库
Ceres Solver [1]是一个开源的 C++库，用于建模和解决大型复杂的优化问题。它…
ceres-solver.org](http://ceres-solver.org/index.html) [## 安装- Ceres 解算器
您可以从最新的稳定版本开始。或者如果你想要最新的版本，你可以克隆 git 库 git…
ceres-solver.org](http://ceres-solver.org/installation.html) [## C++应用程序开发(第二部分— CMakeLists.txt)
如果你曾经做过一个比较大的 C++项目，那么你一定听说过这个工具。它可能看起来会做一些…
medium.com](https://medium.com/heuristics/c-application-development-part-2-cmakelists-txt-e415b5b387dc) [## CMake 教程- CMake 3.17.3 文档
CMake 教程提供了一个分步指南，涵盖了 CMake 帮助解决的常见构建系统问题…
cmake.org](https://cmake.org/cmake/help/latest/guide/tutorial/index.html)
如何在不到一小时的时间内用 Python 和深度学习创建聊天机器人
显然不要指望会是 Siri 或者 Alexa…
希望有一天 BB-8 会成为现实…
有些人真的不喜欢人际交往。每当他们被迫参加社交活动或有很多人参加的活动时，他们会感到孤立和尴尬。就我个人而言，我相信我是最外向的，因为我从与其他人的互动中获得能量。在这个地球上有很多人恰恰相反，他们在社会交往中变得非常疲惫。
我想起了一部非常独特的电影，叫做她(2013) 。这部电影的基本前提是，一个遭受孤独、抑郁、无聊的工作和即将离婚的男人最终爱上了他计算机操作系统上的一个 AI(人工智能)。也许在当时这是一个非常科幻的概念，因为那时人工智能还没有先进到足以成为代理人，但现在呢？2020?事情发生了很大的变化。我担心人们会放弃在人类中寻找爱情(甚至是社会交往),转而在数字领域寻找爱情。不相信我？我不会告诉你这是什么意思，但只要搜索一下术语和畏缩* 的定义就可以了。*
对于一个简单的机器学习项目，这难道不是一个过于冗长的介绍吗？可能吧。既然我已经详细描述了这个世界上许多男人(和女人)有理由实际关注的问题，让我们换个话题，做些简单有趣的事情吧！
这是成品的样子。
漂亮简单的界面
显然，这个聊天机器人的反应极其有限
议程
- 图书馆和数据
- 初始化聊天机器人训练
- 构建深度学习模型
- 构建聊天机器人 GUI
- 运行聊天机器人
- 结论
- 需要改进的地方
如果你想更深入地了解这个项目，或者如果你想添加代码，查看一下 GitHub 库 。
图书馆和数据
运行这个项目所需的所有组件都在 GitHub 存储库中。您可以随意派生存储库并将其克隆到您的本地机器上。下面是组件的快速分类:
- train_chatbot.py —将自然语言数据读入训练集并使用 Keras 顺序神经网络创建模型的代码
- chatgui.py —基于模型的预测清理响应并创建与聊天机器人交互的图形界面的代码
- classes.pkl —不同类型的响应类别列表
- words.pkl —可用于模式识别的不同单词的列表
- intents . JSON—JavaScript 对象的集合，列出了对应于不同类型单词模式的不同标签
- chatbot_model.h5 —由 train_chatbot.py 创建并由 chatgui.py 使用的实际模型
完整的代码在 GitHub 库中，但是为了透明和更好的理解，我将遍历代码的细节。
现在让我们从导入必要的库开始。(当您在终端上运行 python 文件时，请确保它们安装正确。我使用 pip3 来安装包。)
我们有一大堆库，如 nltk (自然语言工具包)，其中包含一大堆用于清理文本并为深度学习算法做准备的工具， json ，它将 json 文件直接加载到 Python 中， pickle ，它加载 pickle 文件， numpy ，它可以非常高效地执行线性代数运算，以及 keras ，这是我们将使用的深度学习框架。
初始化聊天机器人训练
现在是时候初始化所有存储自然语言数据的列表了。我们有我前面提到的 json 文件，其中包含“意图”。下面是 json 文件的一个片段。
典型的 json 格式
我们使用 json 模块加载文件并将其保存为变量 intents。
如果仔细观察 json 文件，可以看到对象中有子对象。例如，“模式”是“意图”中的一个属性。因此，我们将使用一个嵌套的 for 循环来提取“模式”中的所有单词，并将它们添加到我们的单词列表中。然后，我们将每对模式添加到我们的文档中，列出它们对应的标签。我们还将标签添加到我们的类列表中，并使用一个简单的条件语句来防止重复。
接下来，我们将获取单词列表，并对其中的所有单词进行词汇化和小写。如果你还不知道的话， lemmatize 的意思是把一个单词变成它的基本意思，或者它的引理。比如“走”、“走了”、“走了”这些词都有同一个引理，就是“走了”。将我们的词语词汇化的目的是将所有的东西缩小到尽可能简单的程度。当我们实际处理这些词进行机器学习时，它将节省我们大量的时间和不必要的错误。这与词干非常相似，都是将一个屈折的单词缩减到它的基础或词根形式。
接下来，我们对列表进行排序，并打印出结果。好了，看起来我们要建立我们的深度学习模型了！
构建深度学习模型
让我们用变量 training 初始化我们的训练数据。我们正在创建一个巨大的嵌套列表，其中包含每个文档的单词包。我们有一个名为 output_row 的特性，它只是作为列表的一个键。然后，我们洗牌我们的训练集，做一个训练-测试-分裂，模式是 X 变量，意图是 Y 变量。
现在我们已经准备好了我们的训练和测试数据，我们现在将使用来自 keras 的深度学习模型，称为 Sequential。我不想用深度学习模型如何工作的所有细节来淹没你，但如果你好奇，请查看文章底部的参考资料。
keras 中的序列模型实际上是最简单的神经网络之一，一个多层感知器。如果你不知道那是什么，我不怪你。这里是喀拉斯的文档。
这个特定的网络具有 3 层，第一层具有 128 个神经元，第二层具有 64 个神经元，第三层具有作为神经元数量的意图数量。请记住，这个网络的要点是能够预测给定一些数据的选择意图。
模型会用随机梯度下降进行训练，这也是一个非常复杂的课题。随机梯度下降比正常梯度下降更有效，你只需要知道这些。
在模型被训练之后，整个东西被转换成一个 numpy 数组并保存为 chatbot_model.h5.
我们将使用这个模型来形成我们的聊天机器人界面！
构建聊天机器人 GUI
同样，我们需要从文件中提取信息。
下面是一些函数，包含了运行 GUI 的所有必要过程，并将它们封装成单元。我们有 clean_up_sentence() 函数，它清理输入的任何句子。这个函数用在 bow() 函数中，该函数提取被清理的句子，并创建一个单词包，用于预测类别(基于我们之前训练模型得到的结果)。
在我们的 predict_class() 函数中，我们使用 0.25 的误差阈值来避免过多的过拟合。这个函数将输出一个意图和概率的列表，以及它们与正确意图匹配的可能性。函数 getResponse() 获取输出的列表并检查 json 文件，以最高的概率输出最多的响应。
最后，我们的 chatbot_response() 接收一条消息(将通过我们的 chatbot GUI 输入)，用我们的 predict_class() 函数预测类，将输出列表放入 getResponse() ，然后输出响应。我们得到的是我们聊天机器人的基础。我们现在可以告诉机器人一些事情，然后它会作出回应。
有趣的部分来了(如果其他部分还不有趣的话)。我们可以用 tkinter 创建我们的 GUI，tkinter 是一个 Python 库，它允许我们创建自定义接口。
我们创建了一个名为 send() 的函数，它设置了聊天机器人的基本功能。如果我们输入到聊天机器人的消息不是空字符串，机器人将根据我们的 chatbot_response() 函数输出一个响应。
之后，我们构建聊天窗口、滚动条、发送消息的按钮和创建消息的文本框。我们用简单的坐标和高度将所有组件放置在屏幕上。
运行聊天机器人
终于是时候运行我们的聊天机器人了！
因为我在 Windows 10 机器上运行我的程序，所以我必须下载一个名为 Xming 的服务器。如果你运行你的程序，它给你一些关于程序失败的奇怪错误，你可以下载 Xming 。
在运行你的程序之前，你需要确保你安装了 python 或者 python3 和 pip(或者 pip3)。如果您不熟悉命令行命令，请查看下面的参考资料。
一旦你运行你的程序，你应该得到这个。
结论
祝贺您完成这个项目！构建一个简单的聊天机器人会让您接触到各种数据科学和一般编程的有用技能。我觉得学习任何东西的最好方法(至少对我来说)就是建造和修补。如果你想变得擅长某件事，你需要大量的练习，而最好的练习方法就是亲自动手去做。
需要改进的地方
感谢您花时间通读这篇文章！请随意查看我的作品集网站或我的 GitHub 。
1.尝试不同的神经网络
我们用的是最简单的 keras 神经网络，所以有很大的改进空间。你可以在你的项目中随意尝试卷积网络或递归网络。
2.使用更多数据
就各种可能的意图和响应而言，我们的 json 文件非常小。人类语言比这要复杂几十亿倍，所以从头开始创建 JARVIS 需要更多的东西。
3.使用不同的框架
深度学习框架不只是 keras，还有很多。有 tensorflow，Apache Spark，PyTorch，Sonnet 等等。不要把自己局限在一个工具上！
资源
如何在 CodaLab 上创建你的第一个比赛
很洒脱！
来源:istockphoto.com(作者购买)
组织一次挑战可以让你众包最困难的机器学习问题。这也是学习数据科学的绝佳方式。这份简短的实践教程将为你提供创建你的第一个竞赛所需的一切——就在今天！
为什么是 Codalab？
Codalab 是一个开源网络平台，举办数据科学竞赛。这意味着你可以建立自己的实例，或者使用 codalab.lisn.fr 上的主实例。Codalab 强调科学，每年都有数百项挑战发生在科学上，挑战许多领域的极限:物理、医学、计算机视觉、自然语言处理甚至机器学习本身。它的灵活性允许解决各种各样的任务！
一旦你有了账号，你就可以发布你的第一场比赛了！唯一的限制是你的想象力。
开始
要创建你的第一个机器学习挑战，你需要做的就是上传一个竞赛捆绑包。竞赛包是一个ZIP 文件，包含竞赛的所有部分:数据、文档、评分程序和配置设置。
先从一个例子说起；这是最简单的方法。这里是 Iris Challenge 的比赛捆绑，基于著名的 Fisher 的数据集；只需点击链接: Iris 竞赛捆绑。
现在只需将名为“iris _ competition _ bundle . zip”的文件上传到 Codalab 中，如下所示:
转到“我的比赛”，然后是“我正在参加的比赛”，最后是“创建比赛”
就是这样！您的竞争对手已经准备好接受提交。
定制您的比赛
这很酷，但我刚刚重新创建了虹膜挑战。我想设计我自己的任务，包括我的数据集！—你
要定制您的比赛，您需要更改捆绑包中包含的文件并重新上传。让我们仔细看看包里有什么。
HTML 文件
HTML 文件定义了参与者在参加比赛时可以看到的各种页面。使用它们来提供文档和规则，以及您认为重要的任何信息。
Iris 挑战赛主页。网页是由包中的 HTML 文件定义的。
标志；徽标
把“logo.png”换成你酷炫的 logo！
Iris 竞赛包中的“logo.png”
数据
如果你在设计一个机器学习问题，很可能你已经有数据了。公共数据(或输入数据)文件夹用于参与者将访问的数据，参考数据文件夹用于地面真相，通常是来自测试集的您想要保密的标签。您可以使用与提供的示例相同的数据格式，或者您喜欢的任何其他格式。为了确保兼容性，您需要更新评分程序——我们将在下一节讨论它。
如果你的问题不涉及数据，不用担心！Codalab 非常灵活，可以根据您的需要定义您的问题(例如强化学习任务)。
摄取和评分计划
摄取和评分程序是你的竞赛代码的主要部分:它们定义了提交的内容将被评估的方式。如果你想只允许成绩提交，那么你只需要评分程序；摄取程序对于代码提交很有用。
- 摄取程序:定义如何训练模型并保存它们的预测。
- 评分程序:定义如何将预测与实际情况进行比较。
启动套件
如果你已经作为竞争对手参加了挑战，你就知道拥有一套好的出发装备有多重要。在这里，您只需包括参与者轻松投入挑战所需的一切:一些提交的示例、Jupyter 笔记本等。他们可以从网页“参与>文件”下载。
用户可以从网页“参与>文件”下载启动工具包
competition.yaml 文件
最后但同样重要的是，competition . YAML文件定义了你挑战的设置。标题、描述、Docker 图片(只需输入 DockerHub 名称，提交的内容将在其中运行)、日期、奖品等等。
编辑现有竞赛
你的比赛开始了！但是，您希望编辑它。还是有可能的。作为您自己挑战的管理员，您可以访问“编辑”菜单；点击如下按钮:
管理功能包括编辑现有的竞争
然后，您将访问一个面板，在这里您可以编辑每个设置。如果您希望更改数据集或评分程序，首先需要从“我的数据集”页面上传新版本。
走得更远
恭喜你！你知道如何在 Codalab 上创造竞争！然而，我们仅仅触及了软件提供的所有可能性的表面。想了解更多，可以参考 Codalab 的 Wiki 。例如，您将了解如何将您的个人计算机工作人员(CPU、GPU)联系起来，或者如何使用多个标准定义复杂的排行榜。你甚至可以加入努力，发展自己的特色！
来源:codalab.org
如何使用机器学习创建简洁的图像表示
Keras 中 HRRR 图像自动编码器的设计与训练
互联网上的 Autoencoder 示例似乎要么是关于玩具示例(MNIST，28x28 图像)，要么是利用了 ImageNet 瓶颈层的迁移学习。我将向您展示如何从头开始训练自动编码器，如果您有足够的数据和完全不同于 ImageNet 组成的照片的数据，您将会这样做。
在之前的一篇文章中，我展示了如何获取天气预报图像并从中创建张量流记录，以使它们为机器学习做好准备。
在本文中，我将展示如何对这些图像执行一项机器学习任务:使用自动编码器从高分辨率快速刷新(HRRR)模型创建雷达反射率“分析”场的简明表示。HRRR 的图像是 1059x1799，看起来像这样:
在 Keras 中设计自动编码器
自动编码器由通常如下所示的体系结构组成:
自动编码器架构。来源:维基百科上的 Chervinskii(https://commons . wikimedia . org/wiki/File:auto encoder _ structure . png)
编码器试图将输入图像表示为一个更小的数字数组。解码器从代码中重建图像。整个模型被训练以最小化输入和输出的差异。
有几个陷阱需要注意:
- 代码(或嵌入)需要比输入小得多。否则，ML 模型可以简单地将输入像素复制到代码中。不会有一概而论。
- 具有一百万像素输入的参数数量可能会失控。传统上，减少参数数量的方法是使用卷积层。
- 然而，卷积层保留位置信息。所以，从本质上来说，这些层所做的就是让图像越来越模糊。为了超越单纯的模糊，你应该在每个阶段增加卷积滤波器中“通道”的数量。这样，您就可以在各层之间保存信息。
- 此外，你至少需要一个密集的连接，在图像的不同部分之间带来“远程连接”。我选择在创建嵌入时这样做。
- 仔细考虑你是否需要短路层，注意力等。这取决于您正在处理的图像类型和层数。在我的例子中，这些是带有很强的位置约束的地理图像。所以，我决定不使用这些伎俩。
- 减小卷积滤波器大小的方法是使用池层。在解码器中，相反的操作是进行上采样。
这是我最后的建筑:
让我们用代码浏览一下(完整代码在 GitHub 上)。第一层是输入层:
input_img = tf.keras.Input(shape=(1059, 1799, 1), name='refc_input')
我更喜欢大小是 2 的幂，这样更容易得到更小的层。我可以将 1059 一直填充到 2048，但裁剪到 1024 似乎更合理——无论如何，HRRR 图像的边缘分辨率都很差。因此，第二层是一个裁剪层:
x = tf.keras.layers.Cropping2D(cropping=((17, 18),(4, 3)), name='cropped')(input_img)
我们不知道需要多少个卷积层，所以让层数(nlayers)成为一个超参数。此外，我们将使过滤器的数量(或通道的数量)成为超参数，因为这控制了从一层到下一层传递多少信息。最后，poolsize 也将是一个超参数，因为它控制着图像大小从一层到下一层的缩减量:
last_pool_layer = None
for layerno in range(**nlayers**):
x = tf.keras.layers.Conv2D(2**(layerno + **numfilters**), poolsize, activation='relu', padding='same', name='encoder_conv_{}'.format(layerno))(x)
last_pool_layer = tf.keras.layers.MaxPooling2D(**poolsize**, padding='same', name='encoder_pool_{}'.format(layerno))
x = last_pool_layer(x)
output_shape = last_pool_layer.output_shape[1:]
我还确保捕捉最后一层，以便在嵌入层之前获得输出形状(原因将变得明显)。
一旦卷积层完成，我们可以让它通过一个密集层。我还将密集节点的数量(本质上是嵌入的长度)作为一个超参数:
# flatten, send through dense layer to create the embedding
x = tf.keras.layers.Flatten(name='encoder_flatten')(x)
x = tf.keras.layers.Dense(**num_dense**, name='refc_embedding')(x)
x = tf.keras.layers.Dense(output_shape[0] * output_shape[1] * output_shape[2], name='decoder_dense')(x)
embed_size = num_dense
请注意，我是如何使用输出形状预嵌入来恢复解码器第一层中的原始展平长度的。
然后，我们一个接一个地颠倒操作。首先是对解码器进行整形，以获得最后一个 conv 池块的输出形状:
x = tf.keras.layers.Reshape(output_shape, name='decoder_reshape')(x)
然后，创建一个解码器模块，由长度相反的卷积和上采样组成:
for layerno in range(nlayers):
x = tf.keras.layers.Conv2D(2**(nlayers-layerno-1 + numfilters), poolsize, activation='relu', padding='same', name='decoder_conv_{}'.format(layerno))(x)
x = tf.keras.layers.UpSampling2D(poolsize, name='decoder_upsamp_{}'.format(layerno))(x)
before_padding_layer = tf.keras.layers.Conv2D(1, 3, activation='relu', padding='same', name='before_padding')
x = before_padding_layer(x)
htdiff = 1059 - before_padding_layer.output_shape[1]
wddiff = 1799 - before_padding_layer.output_shape[2]
我们在编码器中进行裁剪的地方，现在需要进行零填充:
before_padding_layer = tf.keras.layers.Conv2D(1, 3, activation='relu', padding='same', name='before_padding')
x = before_padding_layer(x)
htdiff = 1059 - before_padding_layer.output_shape[1]
wddiff = 1799 - before_padding_layer.output_shape[2]
decoded = tf.keras.layers.ZeroPadding2D(padding=((htdiff//2,htdiff - htdiff//2),
(wddiff//2,wddiff - wddiff//2)), name='refc_reconstructed')(x)
现在，创建自动编码器:
autoencoder = tf.keras.Model(input_img, decoded, name='autoencoder')
autoencoder.compile(optimizer='adam',loss=tf.keras.losses.LogCosh())
为什么是 LogCosh？因为我们做的是回归，而 LogCosh 对异常值的容忍度比均方差高。
编写培训师
一旦模型写好了，培训师(完整代码:检查一下)就成了样板。我们所有的图像都是 TFRecord，所以我们创建一个 TF record 数据集，创建模型并调用 model.fit。
创建 TFRecord 数据集:
def parse_tfrecord(example_data):
parsed = tf.io.parse_single_example(example_data, {
'size': tf.io.VarLenFeature(tf.int64),
'ref': tf.io.VarLenFeature(tf.float32),
'time': tf.io.FixedLenFeature([], tf.string),
'valid_time': tf.io.FixedLenFeature([], tf.string)
})
parsed['size'] = tf.sparse.to_dense(parsed['size'])
parsed['ref'] = tf.reshape(tf.sparse.to_dense(parsed['ref']), (1059, 1799))/60\. # 0 to 1
return parseddef read_dataset(pattern):
filenames = tf.io.gfile.glob(pattern)
ds = tf.data.TFRecordDataset(filenames, compression_type=None, buffer_size=None, num_parallel_reads=None)
return ds.prefetch(tf.data.experimental.AUTOTUNE).map(parse_tfrecord)
要创建模型并对其进行训练:
def run_job(opts):
def input_and_label(rec):
return rec['ref'], rec['ref']
ds = read_dataset(opts['input']).map(input_and_label).batch(opts['batch_size']).repeat()
checkpoint = tf.keras.callbacks.ModelCheckpoint(os.path.join(opts['job_dir'], 'checkpoints'))
strategy = tf.distribute.MirroredStrategy()
with strategy.scope():
autoencoder, error = create_model(opts['num_layers'], opts['pool_size'], opts['num_filters'], opts['num_dense'])
history = autoencoder.fit(ds, steps_per_epoch=opts['num_steps']//opts['num_checkpoints'],
epochs=opts['num_checkpoints'], shuffle=True, callbacks=[checkpoint, HptCallback()])
autoencoder.save(os.path.join(opts['job_dir'], 'savedmodel'))
这里有几点:
- 我获取 TFRecord 并返回与输入和标签相同的反射率图像数据。这是因为我们正在进行自动编码。
- MirroredStrategy 将允许我创建一个具有多个 GPU 的机器，并获得快速的分布式训练。
- 我创建模型检查点(检查点是机器学习设计模式书中的设计模式之一；这有助于使分布式培训更有弹性)
- 在 fit()方法中，我处理了 steps_per_epoch 和 epoch 的数量。这是检查点模式的虚拟纪元变体。再次，阅读这本书，了解为什么这很重要。
- 因为我们正在进行自动编码，所以我不会为验证数据集而烦恼。我们越能接近地表现输入，就越好。
批量过装
像我一样设计一个模型架构的最佳实践是确保最终的架构足够强大，能够学习我们需要它学习的东西。做到这一点的方法是有用的过度拟合(我们书中的另一个模式)。基本上，取一个非常小的数据集(我用了 4 张图片)并在这个数据集上过度拟合模型。如果你能让误差变得非常小，那么这个模型就足够强大了。
所以，我是这么做的。我写了我的 ML 模型，然后我在超参数空间上做了网格搜索，并选择了最小的嵌入大小，这允许我尽可能完美地学习 4 幅图像(这不会是完美的，因为图像表示将是模糊的)。
因此，还有一个超参数回调:
class HptCallback(tf.keras.callbacks.Callback):
def __init__(self):
self.hpt = hypertune.HyperTune()
def on_epoch_end(self, epoch, logs):
self.hpt.report_hyperparameter_tuning_metric(
hyperparameter_metric_tag='final_loss',
metric_value=logs['loss'], #history.history['loss'][-1],
global_step=epoch
)
我现在可以在谷歌云人工智能平台上进行培训:
gcloud ai-platform jobs submit training $JOB_NAME \
--package-path $PACKAGE_PATH \
--module-name $MODULE_NAME \
--job-dir gs://${BUCKET}/wxsearch/trained \
--region $REGION \
--config hyperparam.yaml \
--input gs://${BUCKET}/wxsearch/data/2019/tfrecord-00000-* \
--project ${PROJECT} \
--batch_size 4 --num_steps 1000 --num_checkpoints 4
结果，我发现这个架构已经足够了:
--num_layers 4 --pool_size 4 --num_filters 4 --num_dense 50
仅仅 50 个数字代表 100 万像素！
训练自动编码器
一旦我们决定了小批量超拟合的超参数，我们就可以采用该模型并在整个 HRRR 2019 数据集上训练它:
gcloud ai-platform jobs submit training $JOB_NAME \
--package-path $PACKAGE_PATH \
--module-name $MODULE_NAME \
--job-dir gs://${BUCKET}/wxsearch/trained \
--region $REGION \
--config train.yaml -- \
** --input gs://${BUCKET}/wxsearch/data/2019/tfrecord-* \**
--project ${PROJECT} \
--batch_size 4 --num_steps **50000** --num_checkpoints 10
train.yaml 在哪里:
trainingInput:
scaleTier: CUSTOM
masterType: n1-highmem-2
masterConfig:
acceleratorConfig:
count: 2
type: NVIDIA_TESLA_K80
runtimeVersion: '2.2'
pythonVersion: '3.7'
scheduling:
maxWaitTime: 3600s
这以 0.0023 的最终损失结束，实际上甚至比微小数据集上的过度拟合损失更好。
后续步骤:
试用一下(GitHub 的所有链接)
- 从 HRRR 图像创建张量流记录: hrrr_to_tfrecord.sh
- [可选] Overfit batch 查找最佳超参数集:overfit_batch.sh
- 在 2019 年 HRRR 数据集上训练自动编码器: train_autoencoder 。嘘
- 在我的系列的下一篇文章中，我将展示如何采用训练好的模型，并为整个 2019 数据集创建嵌入。然后做一个嵌入，告诉你如何从中重建 HRRR 图像。
如何在 Power BI 中创建控制图
在本文中，我将向您展示如何在 Power BI 中构建动态控制图，帮助您的团队查明任何异常值或失控的流程。
随着公司实施精益六适马实践，跟踪流程如何随着时间的推移而变化是必不可少的。控制图可以帮助企业可视化一段时间内的过程测量。
控制图(图片来自 r-bar.net)
对于不知道什么是控制图的人来说，首先要做的是。
🚩控制图由 4 个主要特征组成:
- X 轴和 Y 轴数值:数据值为 Y 轴。这可以是客户数量、票据数量、收入、成本或企业想要测量的任何数据值。时间将是 X 轴。
- 中心线 ( 又名平均值):这是数据点的平均值。它在图表的中间部分用实线表示。
- 控制下限 (LCL):低于平均值，称为-3 sigma 线，作为下限。
- 控制上限 (UCL):高于平均值，称为+3 sigma 线，作为上限。
这是我在 Power BI 中创建的控制图(图片由作者提供)
🚩让我们从在 Power BI 中构建控制图开始
为了实现控制图的主要特性，我们首先创建一些 DAX 度量:
对于平均值计算，您只需使用 Average 函数。我们包含了 ALLSELECTED 函数，以便根据用户在日期切片器中的选择进行动态计算。
AVERAGE CASES = CALCULATE(AVERAGEX(CONTROL_CHART_DATE,[TotalCases]), ALLSELECTED(CONTROL_CHART_DATE))
为了得出 UCL 和 LCL，我们首先需要计算标准差。标准差的语法如下:
STDEV = CALCULATE(STDEVX.P(CONTROL_CHART_DATE,[TotalCases]),ALLSELECTED(CONTROL_CHART_DATE[DATE]))
现在我们有了标准差，我们可以在 UCL 和 LCL 语法中输入这段。
对于 UCL，我们将“平均案例”度量与“标准偏差”度量相加，然后乘以 3(因此，3 sigmas)。
Upper Control Limit (UCL) = AVERAGE CASES + [STDEV]*3
对于 LCL，我们的做法与 UCL 相反。我们用 STDDEV 度量值减去 AVERAGE CASES 度量值，然后乘以 3。
Lower Control Limit (LCL) = AVERAGE CASES - [STDEV]*3
用度量创建折线图:
一旦创建了这些度量，就创建一个折线图。将 LCL、UCL 和平均案例拖到数值中。选择轴的日期。
下面的操作应该可以让您了解控制图的主要组成部分。别忘了带上你的日期切片器。日期切片器将允许用户根据历史日期查看下限和上限。
现在是剩下的部分:在仪表板上添加当前数据。您需要创建另一个独立的日期表，用于第二个日期切片器。这两个数据表应该连接到从中获取主值的表。
创建第二个日期表后，使用该表添加一个日期切片器。
现在是有趣的部分。你们中的一些人可能想知道如何将当年的数据反映在一个使用历史数据的带有日期轴的图表上？
该解决方案是一个创造性的变通办法。创建另一个折线图，将日期 2 作为 x 轴，并将正在分析的值作为 Y 轴。如果折线图中没有显示任何值，那么拍拍自己的背，因为 Power BI 正在工作。您将需要编辑日期切片器和图表之间的交互，方法是选择一个日期切片器，然后单击格式选项卡下的编辑交互。
现在，您想选择第一个日期，在我的例子中是“控制图日期”，并在第二个日期通过选择右边的圆形图标点击“无”。
选择第二个日期切片器，并通过选择右边的圆形图标确保第一个日期没有被过滤。
在第二个日期切片器上选中时，您会希望在您创建的最后一个折线图上单击过滤器，方法是选择左侧图标，该图标看起来像旁边带有过滤器的图形。
确保在带有控制件的第一个图表上选择“无”。通过这些交互，您应该会看到第二个折线图最终出现。
现在，我们实际上有一个影响控制图(UCL、LCL、平均值)的日期限幅器和一个影响图表的日期限幅器，在本例中，它包含总计值。
相应调整折线图格式:
那么，如何让图表上下重叠呢？单击第二个图表，将背景设置为透明，这样它就能清楚地显示在第一个图表上。将图表放在另一个的上面。
确保调整两个图表，使 Y 轴具有相同的刻度，否则总值可能无法调整到控制图的刻度。
通过按住 CTRL 键选择两个图表并单击视图下的锁定对象，将两个图表锁定在一起以保持格式，这样缩放就不会受到影响。
瞧啊。这就是最终的结果。我能够选择 2019 年和 2018 年的日期范围，这些日期范围会影响控制图，同时将其与我当前的 2020 年数据进行比较。
最终结果是一个控制图，您可以将当前数据与历史平均值、控制上限和控制下限进行比较。因为日期切片器和图表相互独立，所以您可以比较不同的日期范围，而不像 SAMEPERIODLASTYEAR 之类的函数将用户限制为只能比较去年的数据。
报告愉快，希望这个创造性的解决方案可以帮助其他 Power BI 开发人员更轻松地制作控制图！
—
娜塔莉·加尔塞斯是一名来自大西雅图地区的数据分析师。她获得了华盛顿大学的商业和 MSBA 学士学位。她写作并热衷于数据可视化、投资和所有科技方面的东西。
如何创建 R 中变量过多的相关矩阵
有效地过滤掉不相关的变量，以查看更相关的结果。
我使用了 Kaggle 房价数据集，它有 79 个解释变量。在我的分析中，我试图查看所有变量之间的相关性，并意识到有太多的变量使任何典型的视觉辅助工具变得有意义。
我尝试了几种不同的软件包和工具，并决定我可以操纵 corrplot 做我最想要的事情。没有任何处理，这就是相关矩阵的样子。这显然是一种非常无益的视觉化。肯定有方法可以改变包中内置的视图，但是没有一种方法可以真正处理这么多的变量。
library(corrplot)df_cor <- cor(df)
corrplot(df_cor)
corrplot 中的初始图表
经过大量的反复试验和对堆栈溢出的清理，我能够创建一个函数来简化这个过程。首先，它会将所有变量转换成数值(如果还没有)。然后，它会丢弃重复项并完善相关性(与自身的相关性)。这些显然是没用的。
corr_simple <- function(data=df,sig=0.5){
#convert data to numeric in order to run correlations
#convert to factor first to keep the integrity of the data - each value will become a number rather than turn into NA
df_cor <- data %>% mutate_if(is.character, as.factor)
df_cor <- df_cor %>% mutate_if(is.factor, as.numeric) #run a correlation and drop the insignificant ones
corr <- cor(df_cor)
#prepare to drop duplicates and correlations of 1
corr[lower.tri(corr,diag=TRUE)] <- NA
#drop perfect correlations
corr[corr == 1] <- NA #turn into a 3-column table
corr <- as.data.frame(as.table(corr))
#remove the NA values from above
corr <- na.omit(corr) #select significant values
corr <- subset(corr, abs(Freq) > sig)
#sort by highest correlation
corr <- corr[order(-abs(corr$Freq)),] #print table
print(corr) #turn corr back into matrix in order to plot with corrplot
mtx_corr <- reshape2::acast(corr, Var1~Var2, value.var="Freq")
#plot correlations visually
corrplot(mtx_corr, is.corr=FALSE, tl.col="black", na.label=" ")
}corr_simple()
接下来，它将设置数据框以查看表中的原始相关性，因为原始数据可能会有所帮助。数据帧首先按照最高相关性排序。
相关表
为了减少变量的绝对数量(无需手动挑选)，只选择高于特定显著性水平阈值的变量。初始默认值设置为 0.5。
生成表格后，它将返回以下经过筛选的相关矩阵图。只有显著性水平足够高的相关性才会有彩色圆圈。如果仍然有许多剩余变量，这进一步有助于去除噪声。
使用 corr_simple 函数过滤掉有用的相关矩阵
结论
这个“corr_simple”函数可以在一些特征工程之后反复运行，或者具有不同的显著性水平。这确实有助于更快的分析和只查看相关数据。对于更多的变量，可能需要使用不同的显著性水平和/或使用更多的特征工程来减少相关变量的数量，然后重新运行函数，直到结果可读且有用。
如何创建自定义损失函数| Keras
对于神经网络
损失功能是神经网络的重要组成部分之一。损失无非是神经网络的一个预测误差。计算损失的方法称为损失函数。
损耗用于计算神经网络的梯度。并且梯度被用于更新权重。这就是神经网络的训练方式。
Keras 有许多内置的损失函数，我在之前的一篇 博客 中提到过。这些损失函数对于分类和回归等许多典型的机器学习任务来说已经足够了。
但是可能有一些任务我们需要实现一个自定义的损失函数，我将在这篇博客中介绍。
开始之前，让我们快速回顾一下如何在 Keras 中使用内置损失函数。
使用内置损失函数
下面是一个使用内置损失函数的简单例子。
克拉斯损失函数
这里我们使用内置的分类 _ 交叉熵损失函数，它主要用于分类任务。我们在model.compile()方法中传递损失函数的名称。
创建自定义损失函数
我们可以简单地如下创建一个定制的损失函数。
定制损失函数
构建自定义损失函数时，您必须遵循以下规则。
- 损失函数应该只有两个参数，即目标值
(y_true)和预测值(y_pred)。因为为了测量预测中的误差(损失),我们需要这两个值。这些参数是在拟合数据时从模型本身传递过来的。 - 损失函数在计算损失时必须使用
y_pred值，如果您不这样做，那么梯度表达式将不会被定义，您将得到一个错误。 - 然后你可以简单地将这个函数插入到
model.compile()方法中来使用它。
小心数据维度
- 参数
y_true和y_pred的第一维总是与批处理大小相同。例如- 如果您正在拟合批量为 32 的数据，并且您的神经网络有 5 个输出节点，那么y_pred的形状将是(32, 5)。因为会有 32 个输出，每个输出有 5 个值。 - 损失函数应该总是返回一个长度为
batch_size的向量。因为你必须返回每个数据点的损失。例如- 如果您要拟合批量为 32 的数据，那么您需要从损失函数中返回一个长度为 32 的向量。
为了更好地理解，我们来看一个例子。
示例|自定义损失函数
比方说，你为某个回归任务设计了一个神经网络，它输出一个长度为 2 的向量[x1, x2]。
假设值x2比x1更重要，你希望它真正接近目标值。对于这种情况，您可以创建一个定制的 MSE (均方差)损失函数，该函数对x2的预测误差比对x1的预测误差更不利。
MSE 损失函数
这里我用权重 0.3 和 0.7 乘以损失值，给第二个值，也就是x2，更多的惩罚。您可以根据自己的需要决定重量。
我还写下了代码片段中变量的形状。您可以看到最终损失的形状是(batch_size,)，这意味着每个数据点有一个损失值。
现在你可以简单地将这个损失函数插入到你的模型中。
model.compile(loss=custom_mse, optimizer='adam')
注意
- 我建议您使用 Keras 后端函数，而不是 Numpy 函数，以避免任何意外。Keras 后端函数的工作方式几乎类似于 Numpy 函数。
奖金
现在，您已经知道如何构建自定义损失函数。您也可以以完全相似的方式创建定制的评估指标。这里，我创建了一个平均绝对误差(MAE)指标，并将其插入到model.compile()方法中。
MAE 度量
如果你想理解尺寸的概念和形状的概念。你可以阅读下面这篇文章，我会在其中详细解释这些概念。
知道如何沿数据的不同轴应用函数。
towardsdatascience.com](/understanding-axes-and-dimensions-numpy-pandas-606407a5f950)
如何创建数据科学产品组合—由数据科学家讲述
展示数据科学项目的网站
尼古拉斯的作品集网站
读者您好，
我希望每个人都保持安全和洗手。真的是在这样的时候，精神和身体健康对我们的前进极其重要。
正如我在之前的文章中提到的，
数据科学不会与经济发生碰撞。
数据行业仍然有需求，有些人甚至会说，由于环境的原因，现在需求很大。当事情开始变得棘手时，企业主开始向我们求助。
来源: reddit
也就是说，对数据科学职业的兴趣仍然很高。人们想进入这个领域，我明白。谁不想被称为 21 世纪最性感的工作？
21 世纪最性感的新工作，数据科学家——LinkedIn
然而并不全是彩虹和鲜花。你必须面对一些艰难的筛选和面试，那些你不知道会发生什么的面试。我已经在这里写下了所有的内容。看一看。
在数据科学面试中，你应该期待什么样的问题？
towardsdatascience.com](/data-science-interview-questions-beginners-guide-7b3034373ccb)
作为一个已经在这个领域工作了两年的人，我给我的初级数据科学家同事的第一个建议是拥有一个数据科学组合。没有什么比拥有一个展示你所有作品的网站更好的了。雇主会立刻对你的工作和专业素养有所了解，让你在获得这份工作时有额外的优势。
有趣的是，我是一个真正的伪君子。我自己没有投资组合，直到现在。
等等，我有很好的理由来解释为什么我不得不推迟制作我的个人投资组合网站。先别生气。
有一个稳定的朝九晚五
我知道。我知道。谁没有呢？我不希望这成为“我没有足够的时间”的借口。然而，我必须平衡我的日常工作，同时也在媒体上写作。在过去的一年里，我已经写了 20 多篇文章。技术报道的制作并不简单。产生干净的代码并用通俗易懂的语言向读者解释需要时间。我会说这几乎就像一个侧面的骗局。
gif bybig brotherafterdark
网络开发新秀
我是一名精算毕业生。实习期间掌握了 SQL 。
我在做数据科学家期间，掌握了 Python 。在这么短的时间内，我能学的语言就这么多。
我全心全意地想用我自己写的代码来制作我的作品集网站。有好几个选择，比如 Wix 和 Squarespace，你可以简单地在运行中建立自己的网站，但是我更喜欢自己做。
说到这里，我的网站运行在 HTML 、 **CSS、**和 Javascript 上。我不得不自学所有的语言，这需要一些时间。
没有值得骄傲的工作
这个很有意思。作品集网站的唯一目的就是展示你的作品，但是如果你没有作品可以展示呢？
当你刚刚开始你的职业生涯时，这更令人沮丧。是的，你可以展示自己发起的项目，但是雇主喜欢看你在真实环境中的实际成就。此外，我对自己的工作感到自豪。我不会展示我不引以为豪的东西。
我花了很多时间来积累出色的工作。我越专注于我的工作，我做的工作就越多，因此就有了延迟
我的投资组合网站
你好，我叫梁家杰。我是一名数据科学家，目前在一家在线分类广告技术公司工作。在我的…
nickefy.github.io](https://nickefy.github.io/porfoliosite/)
这是我的网站的样子。
简单明了，开门见山。
有 5 个主页。
主页
登录页面。你的名字总是被期待在这里。这个页面为整个网站定下基调。我已经默认使用一个设计，在中间有一些巨大的文本来吸引注意力。
我的名字和激情在这里展示。没什么。
投资组合
在这个页面上，我展示了我所有的作品，以及适当的文档和代码。我只包括我认为有价值的项目。我还努力包含了各种各样的项目。我有项目在
- 机器学习
- ETL/ELT 管道
- 数据可视化
- 数据分析
这些都与数据科学有关。我很感激能够接触到许多类型的项目，这让我能够展示我工作中的多样性。各种各样的项目展示了我在数据方面的技能，从工程到可视化。它有助于设定对雇主的期望。
确保到文档和代码的链接做得很好并且正常工作。你的代码应该是可读的。我们不期望雇主理解守则，但我们希望在面试时用通俗易懂的语言向雇主解释我们的守则。
确保在代码中包含注释、空格和适当的缩进，以表明你知道自己在做什么。你永远不知道谁会阅读你的代码，可能是从产品经理到高级软件工程师。因此，请保持你的代码整洁和专业。
关于
关于部分。在这里，你可以讲一点关于你的故事。介绍你自己，谈谈你的激情、目标和成就。相反，雇主想知道他们在雇佣谁。
站在他们的角度想想。你会雇佣一个你一无所知的人吗？还是对自己的工作充满热情的人？公司是由人组成的，人们想知道他们在和谁一起工作。个性是你想在这里展示的，尽量简短。
出版物
这是我的额外部分。作为一名媒体作家，我有出版物可以炫耀。我写我感兴趣的东西，我想表现出来。再一次，这是为了显示我对工作的热情。
这也很容易成为话题的引子。雇主可能会问，你参与过自己的项目吗？你可以回答说，是的，我已经写了关于它的一切，你可以在这里找到它。这当然比只是说说要好，因为雇主可以实际看到你做了什么。
接触
浏览完网站后，你已经给访问者留下了好奇心。他/她想更多地了解你，甚至想和你一起工作。这一部分提供了联系你的方法，以便他们能进一步发展这种关系。
gif by 原稿
密码
我用 HTML 、 **CSS、**和 Javascript 对网站进行编码。
我用了 Bootstrap ，一个免费和开源的 HTML CSS 框架来提供响应式布局。完成这个项目后，我发现 bootstrap 非常容易使用，因为它为你的网站提供了响应能力，你需要做的就是给元素分配正确的 CSS 类。这里有一个例子。
<div class="col-sm-4 col-xs-12>
<p>Apache Airflow</p>
</div>
我在这里定义了一个 div，在这里我为每个项目插入了标题文本。
Bootstrap 的工作方式类似于网格系统，它将浏览器页面划分为页面上的行和列。设置类col-xs-12col-sm-4告诉浏览器，当屏幕很小时，这个 div 应该占据 4 列的宽度。当屏幕特别小时，它应该占据 12 列，这几乎是整个页面。
这意味着对于一个普通的桌面窗口，这个 div 将占据浏览器页面的 1/3。当你用手机浏览页面时，div 会展开并占据整个页面。这非常有用，因为你会希望一些元素在手机上显示得更大，因为这样看起来更好。
这是我的项目卡片在桌面上的样子。
项目卡(桌面)
这是我的项目卡在手机上的样子。
项目卡(手机)
巨大的差异。确保网页的手机版看起来不错是非常重要的，因为谷歌声称 70%的流量来自手机。在我看来， Bootstrap 是一个很好的起点，如果你想尝试 web 开发，因为它简单易学，容易实现，资源丰富。
java 描述语言
我还使用 javascript 在网站上添加一些动画、平滑滚动和页面导航。当你滚动到投资组合部分时，你看到的最明显的是淡入。
项目卡动画
这些动画很好，但不是必需的。这当然让网站看起来更漂亮，但是如果你在短时间内负担不起学习 Javascript 的费用，那就以后再来。你可以把整个网站布局好，以后再添加动画。
主办；主持
我使用 Github 页面 托管站点。
Github Pages 提供免费的解决方案来展示你的网站，而无需设置任何服务器和数据库。它在 git repo 的特定分支中查找项目内容。它还会为你生成一个唯一的网址，这样你就不必购买域名了。下面是怎么做的。
进入你的 Github 库->设置-> Github 页面->选择分支。在我的例子中，我只有一个主分支，所以这就是我运行的内容。
如果 SEO 是你的顾虑之一，我建议不要使用 Github 页面。
如果你想在谷歌上被发现，你会想要建立自己的域名，并手动建立搜索引擎优化。Github 页面有专门的搜索引擎优化插件，但是我不能保证它的有效性。我以前试过 WIX SEO ，它要复杂和有效得多。
恭喜
现在我们有了。
建立自己的数据科学组合的简单、免费且有效的方法。
你基本上已经完成了向世界展示你有多有才华的第一步。剩下的其实就是做工作了。
此外，这是非常酷的。
在你走之前
我们的数据之旅还没有结束。在这个行业缺乏人才的情况下，用适当的数据和机器学习知识来教育自己将使你在获得数据角色方面具有优势。敬请关注，我正在撰写关于更多数据科学项目，以及更多数据行业的故事、指南和经验。与此同时，请随意查看我的其他文章来暂时填补您对数据的渴望。
像往常一样，我引用一句话作为结束。
世界是一个大数据问题。安德鲁·迈克菲，麻省理工学院项目的联合主任
订阅我的时事通讯，保持联系。
也可以通过 我的链接 注册一个中等会员来支持我。你将能够从我和其他不可思议的作家那里读到无限量的故事！
我正在撰写更多关于数据行业的故事、文章和指南。你绝对可以期待更多这样的帖子。与此同时，你可以随时查看我的其他 文章 来暂时填补你对数据的渴望。
感谢 的阅读！如果你想和我联系，请随时通过 nickmydata@gmail.com 联系我或者我的 LinkedIn 个人资料 。你也可以在我的Github中查看之前写的代码。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
