引入人工智能产品组合
以及如何建立一个一步一步的教程！
Natasa Grabovac 在 Unsplash 上拍摄的照片
我的投资组合似乎太静态了。我应该做些什么来使它更具互动性和趣味性，同时还能应用我的 NLP 知识呢？
最近，我刚刚开发了一个人工智能投资组合，旨在提升我的静态网络投资组合。我嵌入了一个个人人工智能助手，它可以回答你关于我的问题，当然，有正确的反应！
无论你是招聘人员、同事，还是网上的任何人，如果你问“他”正确的问题，你会更了解我！ (PS:“他”几乎知道我的一切)。
在这里随意与我的私人 AI 助手互动。在这篇文章中，我将给出一个如何开发自己的个人 AI 助手的分步教程。你所需要的只是 HTML、JavaScript 和 CSS！
引擎
在进入教程之前，让我向你介绍一下这个人工智能组合中使用的引擎:语义反应器和USE-lite tensor flow-JS for QnA。
卢卡斯·范·奥尔特在 Unsplash 上拍摄的照片
语义反应器
第一个引擎，语义反应器，是实验引擎。基本上，它是谷歌的一个插件，可以添加到你的谷歌表单中。它是用来做什么的？
为了展示使用 NLU 有多简单，我们创建了一个名为语义反应器的工具，它使用预先训练的语言模型，提供不同的排名方法，并具有一些高级功能。—谷歌人工智能
换句话说，这个附加组件为您提供了预先训练好的模型，可以随时用于您的实验！您可以将这些模型用于问答任务或测量语义相似度。
甚至有一些创新的游戏使用这个工具作为他们的实验引擎！
你可以在这里和阅读更多关于语义反应器的内容。
将-Lite Tensorflow-JS 用于 QnA
第二个是部署阶段使用的主引擎。在我解释更多关于这个主引擎的信息之前，我先告诉你一点关于使用和 USE-Lite 模型的信息。
通用句子编码器(使用)是将任意给定的句子转换成 512 维句子嵌入的模型。然后，这些转换后的嵌入可以用作许多 NLP 任务的输入，例如文本分类、文本相似性分析、问答等等。
顾名思义，USE-Lite 只是原始使用模型的一个轻量级版本。
当您的计算资源有限时，这个精简版本非常适合使用。例如，设备上的推断。它很小，但在各种自然语言理解任务中仍然有很好的表现。— Tensorflow Hub 文档
最后，USE-Lite tensor flow-JS for Question/Answering 是一个将问答文本编码成 100 维嵌入的轻量级模型。
如使用文件中所述，使用模式有两种变体。第一个使用深度平均网络，而第二个使用变压器架构。这里使用-Lite Tensorflow-JS 进行问答，使用 Transformer 作为其基础架构。
怎么会？
有 6 个步骤，你必须做，以建立自己的个人人工智能助理，我会指导你的每一个步骤！
1.从 G 套件市场安装“语义反应器”附加组件
你可以简单地从这里安装插件。确保您使用与 Google Sheets 帐户相同的 Google 帐户来安装附加组件。
语义反应器页面。[作者截屏]
2.在谷歌表单中列出所有可能的回答
安装完 Semantic Reactor 附加组件后，您可以打开 google sheets，然后列出所有可能的响应。
我可能的反应的例子。[图片由作者提供]
我可以建议你的一个小技巧是根据主题生成几个回复列表。
在我的例子中，我生成了六种不同的回复列表，其中一种是一般的回复列表，其余五种都是针对与我的专业工作经历相关的回复( Traveloka、Tokopedia、Do-It、Qlue Smart City、World Bank )。
3.启动“语义反应器”附加组件
一旦您列出了所有可能的响应，您就可以启动语义反应器插件了。
启动语义反应器插件。[图片由作者提供]
4.选择“本地”模型和“输入/响应”等级方法
如前所述，附件提供了几个预先训练好的模型。这里，我们将选择“本地”模型，因为它与我们将在部署阶段使用的模型相同。
我们必须选择“输入/响应”等级方法，因为我们将在 QnA 任务中使用此附加组件。
模型和排序方法选择。[图片由作者提供]
5.根据给“语义反应器”的查询来改进你的回答
最有可能的是，您的第一组可能的响应不能支持预先训练的模型为给定的查询返回合适的答案。实际上，我们可以尝试从数据集中预先训练的模型进行迁移学习。
但在这种情况下，我认为更明智的做法是提炼我们可能的反应，而不是花费我们的时间和硬件资源来进行迁移学习。正如阿尔伯特·爱因斯坦所说:
“让一切尽可能简单，但不要更简单。”
因此，你可以不断改进所有可能的答案，直到你看到结果足够好。
给定查询时可见。[图片由作者提供]
6.将 TensorFlow-JS 使用 Lite 模型嵌入到 HTML 文件中
一旦您确定了可能的响应列表，就可以在部署中使用该列表。语义反应器中的“本地”模型是一个通用的句子编码器精简模型，这是我们将在部署中使用的引擎。
首先要做的是从 CDN 加载 TensorFlow-JS 并使用模块。
然后，您可以定义函数，在给定查询的情况下，从响应列表中选择最佳响应。
最后，我们必须根据给定的查询选择要使用的函数或要使用的响应列表。我在这里使用了关键字匹配方法来选择我们应该使用的响应列表。
我用来构建这个个人人工智能助手的所有主要代码都基于以下三个来源:
- https://github . com/tensor flow/tfjs-models/blob/master/qna/demo/index . js
- https://github . com/tensor flow/tfjs-models/tree/master/universal-sentence-encoder
- https://github . com/Google/making _ with _ ml/blob/master/semantic _ ml/use _ sample . js
最后的话
Recal Media 在 Unsplash 上拍摄的照片
恭喜你坚持到了这一步！希望这篇文章发表后，我可以看到许多新的人工智能投资组合的开发。
如果你喜欢我的内容，请关注我的媒体账户，以获得我未来其他帖子的通知。在接下来的 3 个月里，我还会做一个关于强化学习的系列文章。你可以在这里查看第一篇。
关于作者
Louis Owen 是一名数据科学爱好者，他总是渴望获得新知识。他获得了最后一年的全额奖学金，在印度尼西亚最好的大学之一Institut Teknologi Bandung攻读数学专业。最近，2020 年 7 月，他刚刚以优异的成绩从他的研究中毕业。
Louis 曾在多个行业领域担任分析/机器学习实习生，包括 OTA(Traveloka)、电子商务( Tokopedia )、fin tech(Do-it)、智慧城市 App ( Qlue 智慧城市 )，目前在 世界银行 担任数据科学顾问
查看路易斯的网站以了解更多关于他的信息！最后，如果您有任何疑问或要讨论的话题，请通过 LinkedIn 联系 Louis。
介绍亚马逊 SageMaker
说到 SageMaker
面向云的解耦数据科学解决方案
https://www . pexels . com/photo/白天蓝天白云下的玉米田-158827/
电脑。它们是棘手的事情——有些日子你会觉得不够，有些日子你会觉得比你需要的更多。您可能认为您只是在安装一个新的开源项目，但是四个小时后您仍然在和安装经理争论。你有一个很好的模型，但是没有一个框架来把它构建到应用程序中。现在，让我们重新想象一下这种体验，但是要使用专门为您构建的工具。欢迎，亚马逊 SageMaker。
亚马逊 SageMaker 是来自 AWS 的全托管机器学习解决方案。它将您的环境从开发、培训和部署中分离出来，使您能够分别扩展这些环境，并优化您的支出和时间。世界各地成千上万的开发人员正在以各种方式采用 SageMaker，有时是为了端到端的流程，有时是为了扩大培训工作，有时是为了死一般简单的 RESTful API 集成。在这里，我将带你了解我称之为 SageMaker classic 的主要方面，或者 SageMaker 的基本要素。
SageMaker 提供了一个托管的开发环境
SageMaker 从一个 notebook 实例开始，这是一个 EC2 实例，专门用于运行 Jupyter、您的环境以及您进行特性工程所需的任何额外代码。笔记本实例会自动配置您的 AWS 凭证，如 boto3 和 aws cli，因此您只需几行代码就可以轻松连接到您在 S3、红移、RDS、DynamoDB、Aurora 或任何其他位置的数据。为了将访问从您的笔记本实例扩展到其他 AWS 资源，只需确保更新分配给您的笔记本实例的 ExecutionRole。
SageMaker 笔记本实例
亚马逊 SageMaker 上的笔记本实例
SageMaker 提供了运行 Jupyter 的完全托管的 EC2 实例，有 10 多个环境、1400 多个包和数百个示例。
最好在一个较小的 EC2 实例上启动您的笔记本，一般来说 ml.t2.medium 是一个不错的选择。这是一台笔记本电脑每小时可以获得的最低金额。
但是一旦你开始钻研你的特性工程，当你意识到你实际上需要一个更大的实例或者更多的磁盘空间时，你可以轻松地调整托管你的笔记本的 EC2 实例的大小。你需要关闭它，更新设置，然后再次打开它。往返 7 分钟，但非常值得。
不要忘记关闭您的笔记本电脑，因为费用是按小时计算的，而不是按次计算的。通常最好是 实现一个 Lambda 函数来自动关闭这些 ，要么基于一天中的某个时间，要么根据笔记本本身的使用情况。
SageMaker 专门为您的每一款车型提供集群
现在有趣的部分来了——你可以在训练的时候为你的每个模型获得专用的 EC2 实例。这些被称为训练作业，无论你是使用 17 种内置算法中的一种，在 Docker 容器中引入自己的模型，还是在脚本模式下使用 AWS 管理的容器，你都可以配置它们。
亚马逊 SageMaker 上的培训工作
亚马逊 SageMaker 上的培训工作
关于你的培训工作的所有细节都被发送到 CloudWatch，并且你的模型工件在完成后被存储在 S3。
每个训练作业在 SageMaker 上都配置了一个 估算器 ，需要使用 17 种内置算法中的一种，没有任何限制。它们可能提供一些时间优势，因为通过使用它们，您编写的代码更少，但是如果您更喜欢使用 TensorFlow、MxNet、PyTorch、Sci-kit Learn 或任何框架来创建自己的模型，SageMaker 提供了一些示例来看看这是如何工作的。
每个训练作业都记录在 AWS 控制台中，因此您可以很容易地看到您使用了哪个数据集、它在哪里、模型在哪里以及客观结果，甚至在您完成 6 个多月后也是如此。
SageMaker 会围绕您的模型自动创建一个 RESTful API
在别的地方训练你的模特？别担心！实际上，你可以把任何预先训练好的模型放在 SageMaker 上——只要你能把它放在 Docker 容器中，你就可以在 SageMaker 上运行它。
使用 SageMaker 围绕任何模型创建 RESTful API
如果您在脚本模式托管容器支持的框架中引入模型，AWS 会为您实现 API。
初始化您的端点的所有资源需要 7 分钟以上，所以如果您看到端点显示“Pending”状态，请不要担心如果您将它投入生产以响应常规流量，那么最好为高可用性 API 设置至少两个 EC2 实例。这些将位于 AWS 管理的负载平衡器之后，位于 API 端点本身之后，API 端点可以连接到接收应用程序流量的 Lambda 函数。
保持开启的端点也会变得昂贵，因此确保 实现一个 Lambda 函数 ，以便在它们不在生产环境中时定期关闭它们。您可以在这里随意试验，选择一个更小的 EC2 实例，但是仍然能够满足您的需求。端点自带自动扩展功能，您只需配置和负载测试这些。
SageMaker 记录你所有的资源
默认情况下，SageMaker 会在控制台中为您记录所有培训作业、端点和超参数调整作业。每个作业都会向 CloudWatch 发出指标，因此您可以近乎实时地查看这些指标，以监控您的模型的训练情况。此外，通过 SageMaker Studio 提供的改进，您可以建立实验并监控这些实验的进展。
SageMaker Studio 提供实验管理，方便查看和跟踪项目进展。
在 SageMaker 中创建了一个实验之后，只需点击一个按钮，所有与之相关的作业就会在 Studio 中显示出来。
SageMaker Studio 在 re:Invent 2019 上公布，目前仍在公开预览中。这意味着 AWS 仍在微调解决方案，随着他们的开发，可能会有一些变化。因为预览版是公开的，任何拥有 AWS 帐户的人都可以在美国东部 2 区或俄亥俄州开设工作室，并开始使用。
资源
AWS 在机器学习方面的资源正呈爆炸式增长。GitHub 上为 SageMaker 托管了 250 多个示例笔记本，就在这里。数百个培训视频可供不同角色和经验水平的人免费使用点击这里。如果你想深入了解这篇文章中的任何内容，我亲自经历了在一个 11 视频系列中概述所有这些功能的麻烦，在这里主持。看看吧！
默认情况下，SageMaker 存在于每个 AWS 帐户中。你也可以创建自己的 AWS 账户，并在免费等级中进行实验。
黑客快乐！在 LinkedIn 上随时联系——我喜欢听你在自己的机器学习冒险中如何实现 SageMaker 的成功故事，所以继续吧！
维恩图 Python 包:Vennfig
在 Jupyter 或 Terminal 上用一行代码画一个维恩图
作者图片
**Table of Contents**[**Introduction**](#19c2)1\. [Installation:](#79a1)
2\. [Default Functions](#6842)
3\. [Parameters](#bc07)
4\. [A, B Venn Diagram](#d255)
5\. [A AND B, A NAND B Venn Diagram](#266d)
6\. [TRUE, FALSE Venn Diagram](#6746)
7\. [OR, NOR Venn Diagram](#4e16)
8\. [XOR, XNOR Venn Diagram](#d4dd)
9\. [NOT A, NOT B Venn Diagram](#3fd9)
10\. [A NOT B, B NOT A Venn Diagram](#fdf0)
11\. [Implication Venn Diagram](#a981)
12\. [Mutually exclusive Venn Diagram](#e045)
13\. [Complement Venn Diagram](#7fbc)
14\. [Subsets Venn Diagram](#36b7)
15\. [Terminal](#ce5a)[**Conclusion**](#18bf)
介绍
在上一篇文章中，我展示了如何使用[matplotlib_venn](https://github.com/konstantint/matplotlib-venn)绘制基本的维恩图。
每个图需要 40 行代码，所以我创建了我的第一个 Python 包，名为 Vennfig 。你可以用一行代码画一个基本的维恩图，但是足够灵活以满足你的需要。
安装:
您可以使用pip安装它:
pip install vennfig
在 Jupyter 上:
!pip install vennfig
你需要进口vennfig。
import vennfig as v
默认功能
所有的 vennfig 函数。
下表显示了您可以使用的所有功能。
除了subsets和mut_exclusive函数，所有默认函数都显示两个维恩图，例如 A 和 B，A 和 B。
它们有默认的颜色、大小、字体大小、标题等。
因素
参数允许你修改你的文氏图。你可以在每个源代码中找到参数的描述。
示例:
import vennfig as v
v.a_b(subs=2, size=6, fill_color='#f5b705', bg_color='#f7edd0',
font_size=25, title_a='P', set_a='P', set_b='Q')
参数名称
subs 你想要显示的文氏图的标识符。
-1:默认(两者)
-2: A
-3: B
大小
Matplotlibfigsize。默认值为 15。
fill_color 默认颜色为‘天蓝色’。您可以使用其中一个字符{'b', 'g', 'r', 'c', 'm', 'y', 'k', 'w'}，它是蓝色、绿色、红色、青色、品红色、黄色、黑色和白色的缩写。您也可以使用十六进制 RGB 或 RGBA 字符串(例如，'#4287f5'或'#4287f580')。
BG _ color bg_color设置 matplotlib 的 facecolor，即背景色。
默认为'white'。
font _ size
标题字体大小。默认为20。
标题 _ a
左侧文氏图的标题。
标题 _b 标题为右侧文氏图。
set _ a
左侧设置标签。默认为'A'。
设置 _b 右侧设置标签。默认为'B'。
text_size 设置文本字体大小。默认值为 15。
让我们看看画维恩图有多容易。
[## 如何在 Docker 上运行 Jupyter 笔记本
不再有 Python 环境和包更新
towardsdatascience.com](/how-to-run-jupyter-notebook-on-docker-7c9748ed209f) [## 如何在 Jupyter 上画维恩图
使用 Matplotlib-Venn 的所有基本逻辑文氏图
towardsdatascience.com](/how-to-draw-venn-diagrams-on-jupyter-75c604b093ac)
文氏图
请在源代码中找到更多细节。
a、B 默认文氏图
a、B 维恩图设置参数。
A 和 B，A 和 B 维恩图
请在源代码中找到更多细节。
A 和 B，A 和 B 默认维恩图。
a 和 B 默认文氏图设置参数。
真假文氏图
请在源代码中找到更多详细信息。
真，假默认文氏图。
真实维恩图设置参数。
或，或非文氏图
请在源代码中找到更多细节。
也不是默认的维恩图。
NOR 维恩图设置参数。
异或，XNOR 文氏图
请在源代码中找到更多细节。
异或，XNOR 默认文氏图。
XOR 文氏图设置参数。
不是 A，不是 B 文氏图
请在源代码中找到更多细节。
不是 A，不是 B 默认文氏图。
不是 Q 维恩图设置参数。
A 不是 B，B 不是维恩图
请在源代码中找到更多细节。
A 不是 B，B 不是默认的维恩图。
P NOT Q 维恩图设置参数。
蕴涵维恩图
请在源代码中找到更多细节。
隐含默认文氏图。
Q ⇒ P Venn diagram setting parameters.
互斥文氏图
请在源代码中找到更多细节。
互斥默认文氏图。
互斥文氏图设置参数。
互补文氏图
请在源代码中找到更多细节。
补充默认文氏图。
补充文氏图设置参数。
子集文氏图
请在源代码中找到更多细节。
子集默认文氏图。
子集文氏图设置参数。
末端的
你可以用终端创建一个文氏图。
在终端上运行 vennfig。
您也可以使用pan来移动图表。
终端的输出
结论
让我知道你的想法。你可以在这里找到 Github repo。
请继续关注下一篇文章。
通过 成为 会员，获得媒体上所有故事的访问权限。
https://blog.codewithshin.com/subscribe
介绍 Company2Vec
数据科学/机器学习
用机器学习帮助公司分析
TLDR : 我在 Github 上为数据科学家创建了一个包，可以从公司名称生成一个公司的矢量嵌入图——详情请见 此处
开发包装的动机
几年前，我在一家做大量简历分析工作的公司担任机器学习的角色。我的任务是编写一个算法，根据一个人的简历预测他的下一个职位(详情见)。虽然我的算法不包括公司的推荐，但我很好奇它们是如何被包括在内的。我很快意识到这是一个非常困难的问题，公司里与我交谈过的其他人也证实了这一点。
从许多简历来看，原因显而易见。同一个公司可以有多种不同的写法。为巴克莱银行工作的人可以在他们的简历上输入“巴克莱”/“巴克莱银行”/“巴克莱资本”/“巴克莱资本”/“巴克莱银行”等等中的任何一个。但这仅仅是问题的开始。如何处理子公司？如何处理品牌名称与其有限公司名称不同的公司？缩写呢？
以类似的方式，过了一段时间，我在一家大型制造公司工作，该公司希望使用机器学习来帮助他们的销售线索生成。当我查看他们的现有客户名单时，我意识到同样的问题也存在。
什么是向量嵌入？
在任何下游机器学习任务中分析公司的最佳方式是创建公司向量嵌入。但是什么是向量嵌入呢？
嵌入是离散—分类—变量到连续数字向量的映射。例如，单词“book”可以用向量(1，2，3)来表示。这非常有用，因为它最多可以做 3 件主要的事情:
- 识别相似的单词/实体。例如，识别单词“cat”与单词“kitten”非常相似。
- 机器学习任务的输入，特别是自然语言处理
- 对于概念和类别之间关系的可视化——你能在下面的图片中看到相似的单词之间有相似的向量关系吗？
那么什么时候公司矢量嵌入会有用呢？下面是一些潜在的用例(当然还有很多)。
- 潜在客户——寻找与你过去的销售对象相似的公司
- 映射不同公司之间的关系(例如，客户-供应商关系)
- 分析同行业公司之间的差异
- 工作推荐
- …以及许多其他下游机器学习任务！
包装详情
为了帮助解决这个问题，我开发了一个 python 包来生成公司矢量嵌入——见这里的包和如何使用它的详细说明。
在大多数情况下，你可能会想用这个，我认为你会有一个公司名称。鉴于缩写/首字母缩略词等的所有问题，该软件包使用一个搜索 API(每月最多 1000 次免费请求)来查找给定公司名称的公司网站。然后，该软件包使用 scrapy 对网站进行一次广泛而浅显的搜索。然后，将抓取的文本与预训练的手套向量嵌入相结合，以创建公司嵌入。
该软件包有两种用途。首先，有一个“快速启动”功能，可用于快速试验该包。如果你想大规模使用它，有一个 Klein web 应用程序和一个 Dockerfile(顺便说一下，由于 scrapy 的多线程工作方式，必须使用 Klein 而不是 Flask)。这可以用来封装一个 web 应用程序，然后部署到云上。
在以下情况下，此软件包工作正常:
- 您不想付费访问公司信息数据库/没有时间根据该数据库的公司条目标准化名称
- 这些公司通常用缩写形式表示。
- 这些公司的网站大部分都是相当静态的内容，并且很好地概述了公司的业务
此包的限制
然而，这个包肯定不是完美的，是一个正在进行的工作。在以下情况下，它的效果不太好:
- 如果大部分网站内容没有描述该公司，例如新闻网站
- 如果没有网站(显然……)
- 如果一家大公司使用相同的缩写/名称，使用缩写的小公司可能会很难被选中。
同样值得记住的是，如果网站上的大部分文本频繁更新，那么每次运行包时嵌入都会改变，影响您的下游分析。
结论
如果你是一名数据科学家，并在过去努力有效地分析公司，希望你会发现这很有用。一定要让我知道你的想法，并为帮助开发这个包做出贡献！
介绍 GeneAl:一个遗传算法 Python 库
在这篇文章中，我将介绍 GeneAl ，这是一个用遗传算法(GA)解决优化问题的 python 库。在这个过程中，我们将了解它们背后的理论，并通过 python 示例了解它们是如何工作的。
遗传算法(GA)是一种基于遗传学和自然选择原理的优化和搜索技术，本质上是模仿我们在生活中观察到的自然进化过程。他们的一般原则是基于这样的概念，即拥有一个由几个个体组成的初始群体，每个个体代表问题的一个特定解决方案，并允许它进化到一个最大化其整体适应度的状态，使用三个主要算子:选择、交叉和变异。我们将在下面更详细地研究这些方面。
遗传算法简直不可思议，因为它们可以应用于多种优化问题，并找到我们没有数学表达式的复杂函数的解决方案。然而，这是以计算复杂性为代价的，因为对于庞大的群体，我们必须评估每一代所有个体的适应度。如果适应度函数是昂贵的，算法运行将是缓慢的。
遗传算法可以分为二元和连续，这取决于我们正在优化的问题的类型。潜在地，所有问题都可以被分解为用二进制串表示它们的变量(基因)，但是一般来说，如果输入空间是实值的，那么使用连续 GA 更有意义。
由于连续 GA 的例子很少，这里显示的例子是针对 GA 版本的。
初始化
搜索从随机的 N 个个体开始。这些个体中的每一个都对应于一条染色体，它编码了一个基因序列，代表着我们试图优化的问题的特定解决方案。根据手头的问题，代表解决方案的基因可以是位(0 和 1)或连续的(实值)。下面显示了一个实值染色体的例子，它代表了一个具有 9 个变量(基因)的给定问题的解决方案。
个体染色体的例子
健身
每个个体的适应度定义了我们要优化的内容，因此，给定一个编码特定问题解决方案的染色体，其适应度将对应于特定个体作为问题解决方案的表现。因此，其适应值越高，该解决方案就越最优。
毕竟，个体的适应度分数是经过计算的，它们是经过排序的，因此可以选择最适应的个体进行交叉。
选择
选择是选择一定比例的个体相互交配并创造新后代的过程。就像现实生活中的自然选择一样，更健康的个体有更高的机会存活下来，因此，将他们的基因传递给下一代。虽然存在有更多个体的版本，但是通常选择过程匹配两个个体，创建成对的个体。有四种主要策略:
配对:这可能是最直接的策略，因为它只包括将最适合的染色体两两配对(将奇数行与偶数行配对)。
随机:这种策略包括从交配池中随机选择个体。
轮盘:这种策略也遵循随机原则，但是更健康的个体被选中的概率更高。
锦标赛:采用这种策略，算法先选出几个个体作为候选(通常是 3 个)，然后选出最适合的个体。该选项的优点在于，它不需要首先按照适合度对个体进行分类。
下面的代码片段显示了轮盘策略的 python 实现。
交叉
这是产生新后代的步骤，新后代将取代种群中最不适合的个体。杂交个体背后的想法是，通过组合不同的基因，我们可能会产生更健康的个体，这将是我们问题的更好解决方案。或者没有，在这种情况下，这些解决方案不会延续到下一代。
为了执行实际的交叉，来自选择步骤的每一对被组合以产生两个新个体，这两个新个体都具有来自父母中每一个的遗传物质。执行交叉有几种不同的策略，所以为了简洁起见，我们只讨论其中一种。
假设我们有一个由 9 个变量定义的问题，如果我们有 2 个父母，我们随机选择交叉基因作为索引 3，那么每个后代将是每个父母的组合，如下图所示。
显示双亲如何杂交产生新后代的图表
每个后代的交叉基因根据以下规则计算:
计算新交叉基因的方程式
其中 β 将是 0 和 1 之间的随机数。下面给出了交叉的 python 代码。
突变
变异是我们在群体中引入新的遗传物质的过程，允许算法搜索更大的空间。如果没有突变，群体中现有的遗传物质多样性不会增加，而且由于一些个体在世代之间“死亡”,实际上会减少，个体倾向于非常快地变得非常相似。
就优化问题而言，这意味着在没有新的遗传物质的情况下，该算法可以在探索足够大的输入空间以确保我们可以达到全局最优之前收敛到局部最优。因此，变异在保持种群多样性方面发挥着重要作用，并使其进化为更适合问题解决方案的*。*
我们可以做到这一点的最简单的方法是，给定一定的突变率，随机选择一些个体和一些基因，并为这些位置分配一个新的随机数。下面的图表和代码片段对此进行了举例说明。
个体中两个基因的突变
解算器
现在是时候把这一切联系起来了。使用我们上面定义的操作符，该算法现在可以解决这个问题，只需几行代码就可以实现该算法的实际主循环。该算法的流程图以及 python 中的示例实现如下所示。
遗传算法的流程图
介绍通用
GeneAl 是一个实现遗传算法的 python 库，可以用来解决许多优化问题。您可以使用提供的现成解算器类—binarygenalsolver和continuousgenalsolver——或者创建一个从其中一个继承的自定义类，并实现覆盖内置方法的方法。它还支持解决著名的旅行推销员问题。
为了简洁起见，我们将只看到如何使用连续版本——与本文保持一致——但是要了解更多细节，请查看该项目的自述文件。
第一件事是安装软件包，这可以通过pip完成，如下所示:
pip install geneal
安装完成后，就可以开始使用了。所以让我们看看如何使用continuousgenalsolver类。
作为最低要求，该类要求用户提供问题中存在的基因数量，以及提供自定义的适应度函数。为了方便起见，该库提供了一些可用于测试的默认适应度函数。
完成上述初始化后，该类将使用所有参数的默认值来解决问题。如果我们希望对算法运行有更多的控制，我们将希望调整这些，这可以如下所示:
最后，这个类允许用户指定问题的类型(如果可能的值是整数或浮点数)以及变量的限制，以便限制搜索空间。
这就完成了对这个库的简短介绍。如果你想知道更多，查看一下 GitHub 库，那里有更多的信息:)
感谢阅读！
引入广义积分梯度(GIG)
一种解释不同集成机器学习模型的实用方法
布莱克·惠勒在 Unsplash 上拍摄的照片
- 集成机器学习模型 比单个 ML 模型单独提供更高的预测准确性 和稳定性，但集成模型很难用普通的可解释方法来解释和信任。
- Zest AI 开发了一种新方法来解释复杂的集成模型，称为广义集成梯度，使它们可以安全地用于高风险应用，如信用风险承保。与其他方法不同，GIG 直接遵循一小组合理的规则，不需要任何武断的假设。
为什么需要新的信用分配方法
在全球经济中部署机器学习的所有方式中，影响最大的应用之一是信贷承销。机器学习被证明可以更好地预测借款人违约，增加需要贷款的人获得信贷的机会，并减少贷款中的偏见。但并不是所有的机器学习技术，包括监管较少的应用中的大量技术，都是透明的。许多被部署的算法会产生难以解释的结果。最近，研究人员提出了新颖而强大的方法来解释机器学习模型，特别是 Shapley 加法解释 (SHAP 解释者)和积分梯度 (IG)。这些方法提供了为模型用来生成分数的数据变量分配信用的机制。他们通过将机器学习模型表示为一个游戏来工作:每个变量都是一个玩家，游戏的规则是模型的得分函数，游戏的价值是模型给出的分数。合作博弈中的信用分配是一个众所周知的问题。
SHAP 使用各种方法来计算沙普利值，这在原子游戏中很有效，通过重新计算模型的结果来识别最重要的变量，每个变量都被系统地删除。当算法是一个神经网络，它运行无限小的小游戏，这些小游戏中没有一个是单独重要的，但它们在总体上是重要的，你需要积分梯度来解释一个模型。IG 使用 Aumann-Shapley 值来了解两个申请人之间模型分数的差异。它量化了每个输入变量对模型得分差异的贡献。毕竟，根据模型，有些变化比其他变化更重要，因此我们的任务是衡量模型认为哪些变化更重要或更不重要。
这两者本身都是伟大的创新，但都没有为实现最佳结果的混合型模式提供令人满意的信用分配。SHAP 包中实现的解释器要么要求变量在统计上是独立的，要么要求缺失值可以用平均值代替。这两者都不是金融服务业的新手。IG 要求模型处处可微，这对于决策树来说是不正确的，所以它只对像神经网络这样的模型有效。
谷歌、脸书和微软等大型科技公司多年来一直在利用集成 ML 的优势。他们使用树和神经网络以及一整套建模数学来构建模型，但他们不像金融服务公司那样在相同的监管约束下运营。银行和贷款机构将从将这些同类高级模型用于信贷承销和欺诈检测等应用中获益匪浅。(查看我们的最近的帖子介绍了一种叫做深度堆叠的新方法，这种方法为一家小型贷款机构带来了 1300 万美元的利润和一个更准确、更稳定的模型。)
所有的箭头都指向需要一种新的方式来解释复杂的、集合的 ML 模型，用于高风险的应用，如信贷和借贷。这也是 Zest AI 开发 GIG 的原因。
引入广义综合梯度
广义积分梯度 (GIG)是一种新的信用分配算法，它通过应用测度理论的工具，克服了 Shapley 和 Aumann-Shapley 的局限性。GIG 是 IG 的正式扩展，它可以为更广泛的模型准确分配信用，包括目前在机器学习领域使用的几乎所有评分功能。GIG 是严格计算每个变量对不同模型集合的贡献的唯一方法。
GIG 更好地解释复杂的 ML 模型是因为它避免了对数据做出不切实际和潜在危险的假设。GIG 直接遵循它的公理。使用 SHAP 和其他基于 Shapley 值的方法，您必须将输入变量映射到一个更高维的空间，以便让这些值为机器学习功能工作。这样的映射有无数种，并且不清楚哪种是正确的映射(如果有的话)。相比之下，GIG 完全由数学决定。
GIG 通过直接分段分析模型函数来分配信用，以回答问题“哪些输入变量导致了模型分数的变化？”它根据一个独特的公式来计算每个变量导致预测函数改变其得分的数量，通过沿从第一个输入到另一个输入的路径累积模型得分的变化来测量每个变量的重要性。
现实世界信用风险模型的应用
为了展示 GIG 的能力，我们用它来解释一个从真实世界贷款数据构建的混合集合模型。该模型，如下图所示并在前面引用，是 4 个 XGBoost 模型和 2 个神经网络模型的堆叠集合。
图 1:深度堆叠集成:训练数据用于训练多个子模型，其中一些可能是基于树的模型，如 XGBoost，其他是神经网络，然后使用神经网络将它们与输入一起集成到更大的模型中。
任何模型可解释性任务中的表格利害关系是精确量化模型中每个特征的重要性。我们进行了一系列实验(在我们的论文中进行了描述),这些实验表明 GIG 准确地量化了简单模型中变量的影响。实验基于输入数据的已知变化建立了一系列玩具模型，我们表明 GIG 能够准确地描述模型从故意修改的数据中学到了什么。这里，我们来看一个真实世界的应用程序。表 1 显示了图 1 中显示的更复杂集合的特征重要性。表格显示，GIG 甚至可以解释这个更复杂的真实世界模型。
表 1:图 1 所示集合的特征重要性。
除了计算整体特征的重要性，GIG 还允许您量化每个申请人和各种人群的特征重要性，例如表现最好和表现最差的贷款，或者导致男女申请人之间批准率差异的变量。
GIG 如何工作
正如我们之前提到的，GIG 是基于 IG 和 Aumann-Shapley 的一个差分信用分配函数。差异信用分配回答了输入的每次变化会在多大程度上引起模型分数变化的问题。您比较两个申请人之间的输入集以及模型为每个申请人返回的违约可能性(例如，一个申请人可能被拒绝，而另一个申请人可能被批准)。GIG 显示了每个输入变量对导致批准/拒绝决策的分数变化的影响程度。
让我们想象一下这一切是如何工作的。图 2 用绿色显示了一组批准的申请人，用红色显示了一组拒绝的申请人。被拒的申请人有很高的拖欠和破产率。被批准的申请人则相反。
图二。这个模型考虑了两个变量:破产和拖欠。获批的申请人破产率和拖欠率都很低。被拒绝的申请人破产率和拖欠率都很高。
像 GIG 这样的差别信贷分配功能通过比较每个被批准的申请人和每个被拒绝的申请人来解释两类申请人之间的差异:你基本上是在计算每对被批准和被拒绝的申请人之间拖欠和破产的差异，并取平均值。下面的图 3 展示了这一比较中的一对的过程。
图 3。红色的被拒绝的申请人和绿色的被批准的申请人之间的分数差异可以用拖欠率的差异和破产数的差异来解释。
这仅用于说明，图表中缺少模型分数。下面的图 4 显示了一个更真实的画面，它显示了模型分数如何随着拖欠和破产变量沿着被拒绝的申请人和被批准的申请人之间的路径而变化。IG 方法使用 Aumann-Shapley 值来计算违约和破产对批准和拒绝申请人之间的模型分数变化的影响。
图 4。这里，模型分数由 y 轴表示。x 轴和 z 轴代表拖欠和破产数量。沿着被拒绝的申请人(红点)和被批准的申请人(绿点)之间的路径的偏导数的积分代表每个变量(拖欠 x 和破产 z)对模型得分 y 的 Aumann-Shapley 贡献
一个模型可以有任何数量的维度，欧曼-沙普利将容纳它们。但正如我们之前所说，Aumann-Shapley 值只适用于像神经网络这样的平滑函数。图 5 展示了一个 Aumann-Shapley(以及 IG)无法解释的函数组合的简单例子。
图 5。函数组合示例。这里，离散组件用红色表示，表示在 x=1.75 处具有跳跃不连续性的决策树。连续部分以蓝色显示。这两个函数的组合以绿色显示。组合函数在 x=1.75 处包含跳跃不连续性，就像作为其一部分的离散函数一样。Shapley 或 Aumann-Shapley 无法充分解释这些功能，它们需要像 GIG 这样不同的东西。
GIG 首先枚举离散函数中的所有不连续点(例如，通过模型决策树的深度优先搜索),然后从每个不连续点的左侧和右侧计算离散函数的值。它根据这两个值的平均值分配分数，如下图 6 的左图所示。分配给连续零件的信用是使用 IG 计算的(图 6 的右图)。然后将离散和连续成分放回一起，以得到高度精确的组合成分。
图 6。GIG 的工作原理是，通过对离散部分左边和右边的值求平均值，然后将其与 Aumann-Shapley 对连续部分分配的信用相结合，来计算跳跃点的信用。
结论
集合模型比任何单独的建模方法产生更好的结果，但是迄今为止它们不可能被准确地解释。我们引入了一种新方法，广义积分梯度，这是在一小组合理的公理下，解释我们在机器学习的真实世界应用(如金融服务)中经常遇到的不同集合和函数组合的唯一方法。GIG 使得在你的贷款业务中使用这些先进的、更有效的模型成为可能，以制造更多的好贷款和更少的坏贷款，并且仍然向消费者、监管者和企业所有者解释结果。
最初的 GIG 论文是由 Zest AI 的约翰·梅里尔、杰夫·沃德、肖恩·卡姆卡、杰伊·布齐克和道格拉斯·梅里尔撰写的。
GitPlus 简介:Jupyter 的版本控制扩展
[图片与 undraw.io 的开放许可证一起使用]
没有简单的方法可以从 Jupyter UI 控制笔记本的版本。当然，你可以使用命令行& 来学习一些 git 命令来控制你的笔记本版本。但是并不是每个使用 Jupyter 的人都精通 git。因此我构建了 GitPlus ，一个 JupyterLab 扩展，它提供了直接从 JupyterLab UI 提交笔记本&创建 GitHub pull 请求的能力。
如何控制 Jupyter 笔记本的版本
安装 GitPlus 扩展时，它在 JupyterLab UI 中提供了一个新的菜单项Git-Plus。从那里，您可以提交笔记本文件或创建 GitHub pull 请求，如下面的演示视频所示。
从 Jupyter 创建 GitHub Pull 请求
从 Jupyter 创建&推送 GitHub 提交
它是如何工作的？
- 扩展的服务器组件使用git python&GitHub API 来推送提交和创建拉取请求。
- 扩展的客户端组件提供 UI 并调用服务器扩展上的适当端点。
- 客户端组件查看 JupyterLab 中所有打开的文件，并确定哪些文件在 GitHub 存储库中。
- 它允许您选择要向其推送提交或创建拉取请求的存储库。
- 它捕获要提交的文件列表、提交消息，并将更改作为提交推送到远程存储库。
- 在 pull 请求的情况下，它会创建一个新的分支并将更改推送到那里。这个新创建的分支与您的存储库的默认分支(通常是
master)进行比较。 - 在分叉存储库的情况下，在父存储库上创建拉请求。
装置
以下是安装说明。
限制
截至目前，GitPlus 只与 JupyterLab 合作。如果您有兴趣将其与经典 Jupyter UI 配合使用，请投票支持此功能请求。只有当有足够的兴趣时，我才愿意研究经典的 Jupyter 支持。
路标
将来 GitPlus 将能够，
- 从 GitHub 提取更改
- 在本地切换/创建 git 分支
- 解决笔记本合并冲突(不影响底层 JSON)
结论
如果您是 Git 的新手，可能需要一些时间来适应所有的命令。即使您对 git 很熟悉，notebook JSON 也会产生意想不到的副作用。GitPlus 提供了易于使用的接口，可以从 JupyterLab UI 完成大多数常见的 git 任务。可以结合 ReviewNB 看视觉差异&写笔记修改意见。
黑客快乐！
原载于 2020 年 4 月 11 日【https://blog.reviewnb.com】。
GraMi 简介 Grakn 的数据迁移工具
艾莉娜·格鲁布尼亚克在 Unsplash 上的照片
如果你和我一样，没多久你就会对 Grakn 感到兴奋。如果你像我一样，最令人兴奋的部分是数据建模、规则推理及其查询和分析功能。
在经历了如何迁移数据的官方示例之后，我确信只有几天时间可以远离所有的乐趣。然后，我花了几周时间构建了一个可靠且健壮的数据迁移器，它具有以下特性:
- 可扩展性和性能
- 基本数据清理
- 数据有效性
- 记录
- 故障恢复
它叫做 GraMi (Grakn Migrator)。如果你想，你也可以用它。
格拉米是什么？
GraMi 从文件中流式传输表格数据，并生成有效的 Graql insert 查询，然后提交到您选择的 Grakn 服务器。更具体地说:
数据输入:
- 数据从文件中流出，以保持低内存占用
- 支持任何表格数据文件(即:csv，。tsv，。*sv…)，是否压缩
实体和关系迁移:
- 迁移 Grakn 中任何可用类型的必需/可选属性(字符串、布尔、长整型、双精度、日期时间)
- 迁移必需/可选的角色扮演者
- 将类似列表的属性列作为 n 个属性迁移(Grakn 推荐)
数据清理和验证:
- 基本数据清理(删除前导和尾随空格以及不一致的特殊字符)
- 在写入 Grakn 之前，验证基于每个数据行的插入查询
- 记录所有无效数据记录，以便于分析(例如，缺少属性/球员或数据记录格式不正确)
表现:
- 在单线程和并行异步写入 Grakn 之间进行选择，以充分利用您的硬件配置
故障恢复:
- 跟踪迁移进度，允许停止/重启和(硬件)故障恢复
为什么是格兰米？
数据输入:
- 大多数数据将来自现有系统或结构化文件，并且大多数系统可以导出为表格格式
- 如果您有大量数据，您会希望以压缩格式存储
实体和关系迁移:
- 模板逻辑是为大型数据集复制的多种形式，大型数据集具有许多实体和必需/可选属性/参与者的关系以及具有属性列表的列
数据清理和验证:
如果你对数据很认真，你会使用大量的数据，并且非常关心数据的质量。所以你可能想:
- 记录所有不符合模式和数据建模约束的行
- 防止对 Grakn 的无效/空写入，浪费时间和无意义的迁移
性能:
- 如果您有数百万条记录，就不能缓慢插入
- 批处理和并行化代码并不简单，而且在 Grakn Discord 上经常被请求
故障恢复:
在处理大量不同质量的数据时，硬件和软件最终会出现故障/变得不可用，因此您需要跟踪迁移进度，并能够从中断的地方重新开始。
它是如何工作的
GraMi 要求你指定一个处理器配置文件(处理器配置)和一个数据配置文件(数据配置)。处理器配置充当你的模式、它的实体、关系、属性、播放器、值类型以及数据配置之间的粘合剂。数据配置描述了数据是如何格式化的，以及哪些列包含哪些模式概念。
配置约定:
- 对于模式中指定的每个实体和关系，在处理器配置中必须至少有一个处理器(至少如果您希望 GraMi 插入它的话)
- 每个数据文件只包含一个模式概念(即一个实体或关系以及它们相应的属性和参与者)
- 每个数据文件必须包含具有唯一列名的标题行
在这篇文章中，我们将构建你可以在 github 上找到的 grami-example 项目。这是对 Grakn 的电话呼叫示例的详细描述，扩展到显示 GraMi 此时的所有功能。
从这个例子中可以看出，下面是如何使用处理器和数据配置将数据映射到模式的概述:
图 1 —使用 GraMi 的处理器和数据配置将数据映射到模式。
从左到右(模式到数据):
- 给定一个模式概念(用黄色标记)，在本例中是实体 person …
- 处理器配置定义了一个名为人的处理器，它创建了 schemaType 人的实体的实例。对于 person 的每个属性，我们指定属性的值类型以及是否*需要将记录插入到 Grakn 中(read 中的 first-name ，蓝色的 nick-name )。**注意:*关键属性应该始终是必需的；但是，对于所有其他记录，如果缺少某些属性，这将使您能够排除对您的域没有用处的记录。
- 数据配置包含每个数据文件的一个条目。每个文件映射到处理器配置中的处理器(黄色框)，然后将数据文件中的每一列映射到所选处理器中的属性生成器。如果该列实际上是一个值列表(对于昵称，您可以指定列表分隔字符。
辅导的
让我们来看一下扩展电话呼叫的例子(完整的项目，包括模式、数据和配置可以在这里找到)。
步骤 1-实体的处理器配置
对于我们模式中的以下人实体(在这里找到完整模式):
对应的处理器配置条目将是:
- 你的处理者的 ID——这里是*人——*行 2
- 创建一个实体— 行 3
- 类型人— 第 4 行
- 具有以下属性:
- 您的属性生成器的 ID—这里的是名字，w 是第 7 行
- 创建名字属性—第 8 行
- 值类型的字符串(其他可能是:long、double、boolean、datetime) —第 9 行
- 那是不需要的— 第 10 行
- 或者必填(在电话示例中，电话号码是必填的)—第 16 行
请注意，在为关系定义处理器配置时，将会考虑到实体的“播放”定义。对于实体，只需指定属性生成器。
对模式中的所有实体执行上述操作。点击查看电话示例的完整处理器配置。
步骤 2—关系的处理器配置
对于我们的模式中的以下调用关系:
对应的处理器配置条目将是:
- 你的处理器的 ID——这里*调用——*行 2
- 创建一个关系— 行 3
- 类型为的调用— 第 4 行
- 与以下玩家: —第 6 行
- 你的玩家生成器的 ID——此处为呼叫者，w 为第 7 行
- 匹配类型为 person 的实体—第 8 行
- 使用属性电话号码识别人 —第 9 行
- 属于值类型字符串—第 10 行
- 插入人作为扮演呼叫者的角色—第 11 行
- 对于每个调用记录-第 12 行，哪一个是必需的角色
所有关系及其参与者都是如此。如果一个关系有属性，如调用的情况，只需为每个属性添加属性生成器，如步骤 1 实体所述。
步骤 3-实体的数据配置
我们现在将数据映射到刚刚创建的处理器配置。让我们来看看我们的 person.csv 数据文件:
我们的数据配置条目如下所示:
- 对于迁移步骤“person”——第 1 行
- 我们指定文件路径——第 2 行
- 表格列的分隔字符—第 3 行
- 通过 ID 从处理器配置中选择处理器，这里是pperson—line 4
- 我们设置批次大小——见下文
- 以及用于迁移的线程的数量——见下文
- 然后，我们在数据文件中的列名和在处理器配置中指定的属性生成器之间提供一个映射
- 如果列包含值列表，您可以指定列表分隔字符 —第 21 行
使用 4 个线程的 2000 年批次大小意味着每批 2000 条记录中，每个线程将向 Grakn 写入和提交大约 500 个插入查询。
GraMi 根据插入查询的长度将其均匀地分配给线程，这样每个线程都有大致相同数量的实体/关系和属性/播放器要插入——这可以防止一个线程在处理下一批之前比其他线程花费更长的时间来关闭，从而防止 CPU 浪费。不均匀的 insert 语句通常是由包含属性列表的列造成的，其中每个列表的值的数量在记录之间有很大差异。
步骤 4-关系的数据配置
继续这些关系，我们现在通过我们的 calls.csv 数据文件来工作:
数据条目如下所示:
这里唯一的新东西是第 7-16 行，在这里我们定义了从包含唯一标识关系 call 的角色玩家的属性的列到步骤 2 中的处理器配置中的适当玩家生成器的映射。
使用 GraMi
完成我们的处理器和数据配置后，我们准备开始迁移。有两种使用 GraMi 的方法:作为 Maven/Gradle Java 项目中的依赖项或作为独立的可执行文件(适用于 Linux 和 Mac):
在您的 Maven/Gradle 项目中使用 GraMi
使用 Maven 导入 GraMi:
或者使用 Gradle 导入 GraMi:(参见完整的 build.gradle 这里)
然后，您可以在代码中使用 GraMi，如下所示:
布尔标志 cleanAndMigrate 设置为真，如所示
GraknMigrator mig = new GraknMigrator(migrationConfig, migrationStatus, true);
如果存在，将删除模式和给定键空间中的所有数据。
如果设置为假，GraMi 将根据迁移状态继续之前的迁移——这意味着它将从之前停止的地方继续(关于迁移状态的更多细节——见下文)。
至于吗
mig.migrate(true, true);
migrateEntities 和 migrateRelations 标志总共有四种可能性，分别为:
- 真，真 -迁移数据配置中的所有内容
- 真，假 -仅迁移实体(对调试有用)
- 假，假 -仅迁移模式(注意:如上所述的 cleanAndMigrate 标志也必须为真)
- 假，真 -不能迁移没有实体的关系-设置为与 3 相同。
在 Java 项目中配置 GraMi 日志记录
要获得对 GraMi 日志记录的控制，请将以下内容添加到 log4j2.xml 配置文件中:
为了跟踪迁移进度，GraMi 的建议日志级别是 INFO。对于更详细的输出，在你空闲的时候将级别设置为调试或跟踪——以及错误报告…
使用 GraMi 作为 CLI 应用程序
在确保你的机器上安装了 Java 8 之后，在这里下载GraMi。解包后，您可以直接在/bin 目录下运行它，如下所示:
./bin/grami \
-d /path/to/dataConfig.json \
-p /path/to/processorConfig.json \
-m /path/to/migrationStatus.json \
-s /path/to/schema.gql \
-k yourFavoriteKeyspace \
-cf
只需确保您调整了文件的路径，并选择了您最喜欢的键空间。还要确保将 dataConfig.json 中指定的文件路径调整为本地路径。你可以在这里找到所有的数据和配置文件。
通过使用-h 标志，您可以找到 GraMi 的所有选项和标志:
图 2— GraMi CLI
格拉米伐木公司
GraMi 生成两个日志:应用程序日志和数据日志。
应用程序日志可让您跟踪迁移进度，如果发生异常，它会写出异常或给出软件崩溃原因的信息。对于成功的迁移，您可能会看到如下内容:
数据日志记录了与您的数据相关的所有问题。例如，当列应该是某种值类型，但不是时:
同样，所有违反数据有效性检查的数据记录(缺少必需的属性或玩家、空行等)都会被记录下来:
这使您可以快速找到数据文件中的问题，并在重试之前调整您的预处理(或者不调整，因为不应插入违反您的约束的记录，即需要的属性/球员)。
计划在下一个版本中为每个包含所有未插入 Grakn 的原始数据记录的数据文件创建一个相应的错误文件，这将进一步简化错误分析和修复。
GraMi 迁移状态
GraMi 通过记录为每个文件处理的数据记录数量来跟踪迁移过程。如果失败，GraMi 可以重新启动，或者跳过 -cf 标志(如果用作应用程序)，或者在应用程序代码中将 cleanAndMigrate 设置为 false(见上文)。GraMi 将读取您的 migrationStatus.json 文件，可能如下所示:
如果一个文件已经被完整地处理，则 isCompleted 被设置为真。否则为假，文件中处理的行数记录在 migratedRows 下。如果继续中止的迁移，GraMi 将跳过所有已完成的文件和每个未完全迁移的文件中的迁移行(如上面的 call.csv 所示)，然后继续下一个数据记录。欢迎您对此进行测试，方法是手动中止迁移，然后按照说明重新启动。
摘要
如果您已经按照上述教程进行了操作，并且从您的 Maven/Gradle 项目中或者通过使用 GraMi 作为独立的应用程序来运行示例迁移，那么您的应用程序日志 ( grami-log.log )应该与代码/应用程序运行的目录 ) 类似:
然后，您可以使用以下查询使用 Grakn Workbase 来浏览数据集:
match $e (caller: $caller, callee: $callee) isa call; get; offset 0; limit 5;
您应该会看到类似这样的内容:
图 3 —使用 Grakn 工作库探索电话呼叫
至此，您已经成功地完成了教程，现在可以使用 GraMi 获取您自己的数据了(希望不到几周)！
如果没有，请通过 Github 联系我或在下面留下评论…
链接和资源
格拉克工作基地
贡献
GraMi 是在语义和知识图技术小组@ Bayer AG 的工程师@ Grakn Labs 的大力支持下建立的！
批准
GraMi 和GraMi-示例存储库包括在拜耳公司开发的软件。它是在 GNU-3 通用公共许可证下发布的。
信用
来自 Flaticon 的 Smashicons 横幅中的图标。
Hiveplotlib 简介
通过蜂巢图在 Python 中实现更好的网络可视化
Hiveplotlib 是一个新的开源 Python 包，用于生成蜂巢图。
介绍hiveplotlib——一个用于生成蜂巢图的新的开源 Python 包。Hive Plots 最初是由 Martin Krzywinski 开发的，它生成定义明确的图形，允许对网络数据进行可解释的可视化探索。
hiveplotlib库在 Gitlab 上对所有人可见，其中文档包括对蜂巢图的进一步解释、示例(玩具数据和真实数据)以及完整的代码文档。
Hiveplotlib 可以通过pip安装:
$ pip install hiveplotlib
目前，我们只支持基于[matplotlib](https://matplotlib.org/)的可视化，但我们计划扩展 hiveplotlib，以用于交互式 Python viz 包，如[bokeh](https://docs.bokeh.org/en/latest/index.html)、[plotly](https://plotly.com/)和[holoviews](https://holoviews.org/).
运行时间
hiveplotlib很好地扩展到大型网络数据集。作为对合成数据的演示，让我们构建一个类似于hiveplotlib标志中的“o”的蜂巢图:
from hiveplotlib import hive_plot_n_axes, Node
from hiveplotlib.viz import hive_plot_viz_mpl
import numpy as np
import matplotlib.pyplot as pltnum_nodes = 20
num_edges = 80np.random.seed(0)*# build node data*
nodes = []
for i in range(num_nodes):
temp_node = Node(unique_id=i,
data={'a': np.random.uniform(),
'b': np.random.uniform(),
'c': np.random.uniform()})
nodes.append(temp_node)*# give the nodes simple int IDs*
node_ids = np.arange(num_nodes)*# build random edges*
edges = np.random.choice(np.arange(num_nodes),
size=num_edges*2).reshape(-1, 2)*# construct HivePlot instance, evenly spacing out nodes over 3 axes*
hp = hive_plot_n_axes(node_list=nodes, edges=edges,
axes_assignments=[
node_ids[:num_nodes//3],
node_ids[num_nodes//3:2*num_nodes//3],
node_ids[2*num_nodes//3:]
], sorting_variables=["a", "b", "c"],
axes_names=["A", "B", "C"],
vmins=[0, 0, 0], vmaxes=[1, 1, 1],
orient_angle=-30)*# change the line kwargs for edges in plot*
hp.add_edge_kwargs(axis_id_1="A", axis_id_2="B",
c=f"C0", lw=3, alpha=1, zorder=1.5)
hp.add_edge_kwargs(axis_id_1="B", axis_id_2="C",
c=f"C2", lw=3, alpha=1, zorder=1.5)
hp.add_edge_kwargs(axis_id_1="A", axis_id_2="C",
c=f"C1", lw=3, alpha=1, zorder=1.5)fig, ax = hive_plot_viz_mpl(hive_plot=hp)
plt.show()
用 hiveplotlib 生成的蜂巢图的合成示例。
这段代码(减去导入语句)在笔记本电脑上运行大约需要 200 毫秒。如果我们只将上面的代码更改为num_nodes = 10000和num_edges = 10000，运行时间会增加大约 1 秒。100，000 个节点和边在大约 10 秒内运行。
数据输入
为了使用 hiveplotlib，我们需要争论两个数据源，节点和边。
节点
在我们的框架中设置一个节点只需要一个数据字典和一个 unique_id。这对于来自数据库查询的任何json输出(例如，通过pymongo来自 Mongo 数据库的查询)来说都是非常好的。pandas数据帧也可以通过df.to_dict(orient="records")轻松转换成这种格式。
优势
边存储为一个(n, 2) numpy.ndarray，其中边(如果有方向)从第一列移动到第二列。**
为了用真实数据演示代码，让我们看一个小而流行的例子:Zachary 的空手道俱乐部。
一个例子:扎卡里的空手道俱乐部
从 1970 年到 1972 年，韦恩·w·扎卡里观察到一个空手道俱乐部分裂成两个派别，一派支持俱乐部主席，被称为“约翰·A”，另一派支持一名教练，被称为“嗨先生”最终，这两个派别正式分裂成两个俱乐部。
这个经常使用的数据集包含 34 个俱乐部成员(节点)和一个记录，记录了在俱乐部正式分裂之前谁与谁在班级之外交往(边缘)。
让我们首先将以下工作的所有导入放在一个地方:
**from** **hiveplotlib** **import** Axis, Node, HivePlot
**from** **hiveplotlib.viz** **import** axes_viz_mpl, node_viz_mpl, edge_viz_mpl
**from** **matplotlib.lines** **import** Line2D
**import** **matplotlib.pyplot** **as** **plt**
**import** **networkx** **as** **nx**
**import** **numpy** **as** **np**# if you're in a jupyter notebook
%matplotlib inline
通过networkx抓取空手道俱乐部数据集很方便:
G = nx.karate_club_graph()
这个网络的可视化——在最初的论文[networkx](https://networkx.github.io/documentation/stable/auto_examples/graph/plot_karate_club.html)，甚至维基百科——总是用一个圆形图来完成，所以让我们以此为起点:
*# color the nodes by faction*
color = []
**for** node **in** G.nodes():
**if** G.nodes.data()[node]['club'] == "Mr. Hi":
color.append("C0")
**else**:
color.append("C1")
fig, ax = plt.subplots(figsize=(10, 10))
plt.axis("equal")
nx.draw_circular(G, with_labels=**True**, node_color=color, ax=ax, node_size=1000)
ax.set_title("Zachary's Karate Club**\n**Circular Network Plot", fontsize=20)
*# legend*
john_a_legend = Line2D([], [], markerfacecolor="C1", markeredgecolor='C1',
marker='o', linestyle='None', markersize=10)
mr_hi_legend = Line2D([], [], markerfacecolor="C0", markeredgecolor='C0',
marker='o', linestyle='None', markersize=10)
ax.legend([mr_hi_legend, john_a_legend],
["Mr. Hi", "John A."],
loc='upper left', bbox_to_anchor=(1, 1), title="Faction")
plt.show()
扎卡里空手道俱乐部的环形网络图
从循环图得出的结论
从这张图表中可以得出一个清晰而不令人惊讶的结论，那就是 Hi 先生(node 0)和 John A. (node 33)很受欢迎，但很难得出更多其他结论。
用大约 10 秒钟的时间看上面的图，然后问自己以下问题:
这两个派别在社会上的分离程度如何？确认蓝色和橙色之间存在联系需要多长时间？
这两个群体之间的联系是来自一般更社会化的人吗？
要回答第一个问题，我们当然可以更小心地在我们的图中排序这些节点，将橙色与蓝色分开，但第二个问题仍然很难。
设计蜂巢图
蜂巢图允许我们仔细选择放置节点的轴以及如何在这些轴上对齐节点。
因此，有许多必要的声明，但有一个更易解释的网络可视化的回报。
为了回答上述问题，我们将按照以下方式构建蜂巢图:
- 我们将总共构建 4 轴——2 轴用于约翰 a 派，2 轴用于嗨先生派。使用重复轴可以让我们在结果可视化中以明确定义的方式看到内部派系的行为。
- 我们将查看 3 组边缘 —约翰 a .派系内的边缘、嗨先生派系内的边缘以及两个派系之间的边缘。这就给了我们上面第一个问题一个明确的答案。
- 我们将按照节点度为每个阵营排序一个轴。这让我们可以很好地回答上面的第二个问题，稍后会有更多的内容。
让我们首先计算所有节点的度，同时为 hiveplotlib 构建必要的数据结构:
edges = np.array(G.edges)
*# pull out degree information from nodes for later use*
node_ids, degrees = np.unique(edges, return_counts=**True**)
nodes = []
**for** node_id, degree **in** zip(node_ids, degrees):
*# store the index number as a way to align the nodes on axes*
G.nodes.data()[node_id]['loc'] = node_id
*# also store the degree of each node as another way to
# align nodes on axes*
G.nodes.data()[node_id]['degree'] = degree
temp_node = Node(unique_id=node_id,
data=G.nodes.data()[node_id])
nodes.append(temp_node)
接下来是hiveplotlib组件。让我们构建一个HivePlot()实例:
karate_hp = HivePlot()
*### nodes ###*
karate_hp.add_nodes(nodes)
*### axes ###*
axis0 = Axis(axis_id="hi_id", start=1, end=5, angle=-30,
long_name="Mr. Hi Faction**\n**(Sorted by ID)")
axis1 = Axis(axis_id="hi_degree", start=1, end=5, angle=30,
long_name="Mr. Hi Faction**\n**(Sorted by Degree)")
axis2 = Axis(axis_id="john_degree", start=1, end=5, angle=180 - 30,
long_name="John A. Faction**\n**(Sorted by Degree)")
axis3 = Axis(axis_id="john_id", start=1, end=5, angle=180 + 30,
long_name="John A. Faction**\n**(Sorted by ID)")
axes = [axis0, axis1, axis2, axis3]
karate_hp.add_axes(axes)
*### node assignments ###*
*# partition the nodes into "Mr. Hi" nodes and "John A." nodes*
hi_nodes = [node.unique_id **for** node **in** nodes
**if** node.data['club'] == "Mr. Hi"]
john_a_nodes = [node.unique_id **for** node **in** nodes
**if** node.data['club'] == "Officer"]
*# assign nodes and sorting procedure to position nodes on axis*
karate_hp.place_nodes_on_axis(axis_id="hi_id", unique_ids=hi_nodes,
sorting_feature_to_use="loc",
vmin=0, vmax=33)
karate_hp.place_nodes_on_axis(axis_id="hi_degree",
unique_ids=hi_nodes,
sorting_feature_to_use="degree",
vmin=0, vmax=17)
karate_hp.place_nodes_on_axis(axis_id="john_degree",
unique_ids=john_a_nodes,
sorting_feature_to_use="degree",
vmin=0, vmax=17)
karate_hp.place_nodes_on_axis(axis_id="john_id",
unique_ids=john_a_nodes,
sorting_feature_to_use="loc",
vmin=0, vmax=33)
*### edges ###*
karate_hp.connect_axes(edges=edges, axis_id_1="hi_degree",
axis_id_2="hi_id", c="C0")
karate_hp.connect_axes(edges=edges, axis_id_1="john_degree",
axis_id_2="john_id", c="C1")
karate_hp.connect_axes(edges=edges, axis_id_1="hi_degree",
axis_id_2="john_degree", c="C2")
作为hiveplotlib可视化的扩展，我们还将拉出 John A .和 Mr. Hi 节点位置，在最终图形中用不同的颜色绘制它们。
*# pull out the location of the John A. and Mr. Hi nodes
# for visual emphasis later*
john_a_degree_locations = \
karate_hp.axes["john_degree"].node_placements
john_a_node = \
john_a_degree_locations\
.loc[john_a_degree_locations.loc[:, 'unique_id'] == 33,
['x', 'y']].values.flatten()
mr_hi_degree_locations = \
karate_hp.axes["hi_degree"].node_placements
mr_hi_node = \
mr_hi_degree_locations\
.loc[mr_hi_degree_locations.loc[:, 'unique_id'] == 0,
['x', 'y']].values.flatten()
测绘
我们现在准备绘图:
*# plot axes*
fig, ax = axes_viz_mpl(karate_hp,
axes_labels_buffer=1.4)*# plot nodes*
node_viz_mpl(karate_hp,
fig=fig, ax=ax, s=80, c="black")*# plot edges*
edge_viz_mpl(hive_plot=karate_hp, fig=fig, ax=ax, alpha=0.7,
zorder=-1)
ax.set_title("Zachary’s Karate Club\nHive Plot", fontsize=20, y=0.9)
我们还将为 Hi 先生和 John A .添加一个突出显示节点，以及一个自定义图例以供参考，所有这些都使用标准的matplotlib:
*# highlight Mr. Hi and John. A on the degree axes*
ax.scatter(john_a_node[0], john_a_node[1],
facecolor="red", edgecolor="black", s=150, lw=2)
ax.scatter(mr_hi_node[0], mr_hi_node[1],
facecolor="yellow", edgecolor="black", s=150, lw=2)### legend ###*# edges*
custom_lines = [Line2D([0], [0], color=f'C{i}', lw=3, linestyle='-')
**for** i **in** range(3)]
*# John A. and Mr. Hi nodes*
john_a_legend = Line2D([], [], markerfacecolor="red",
markeredgecolor='black',
marker='o', linestyle='None', markersize=10)
custom_lines.append(john_a_legend)
mr_hi_legend = Line2D([], [], markerfacecolor="yellow",
markeredgecolor='black',
marker='o', linestyle='None', markersize=10)
custom_lines.append(mr_hi_legend)
ax.legend(custom_lines, ["Within Mr. Hi Faction",
"Within John A. Faction",
"Between Factions",
"John A.",
"Mr. Hi"],
loc='upper left', bbox_to_anchor=(0.37, 0.35),
title="Social Connections")
plt.show()
Zachary 的空手道俱乐部用 hiveplotlib 包可视化为一个蜂巢图。
蜂巢图的结论
让我们重温一下之前的问题:
这两个派别在社会上的分离程度如何？确认蓝色和橙色之间存在联系需要多长时间？
从这个图来看，派系内部的联系似乎比派系之间的联系多得多，但是我们可以清楚地看到绿色的派系之间的联系。
这两个群体之间的联系是来自更普遍的社会性的人吗？
派系间的联系和一般的社交能力之间似乎没有特别强的相关性。否则，只会在每个度数轴上较高的节点之间有绿色连接。
与圆形布局相比，生成这种蜂巢图可视化的设置成本当然更高——我们必须做出轴和排序决策。
然而，作为回报，我们可以生成明确的可视化，作为回答真正的研究问题的第一步。
Hiveplotlib 后续步骤
我们很高兴能继续开发这个项目。我们计划的后续步骤包括但不限于:
- 扩展包以使用交互式 Python 可视化包。
- 扩展排序过程(通过单调函数进行缩放，对分类数据进行排序)。
- 在结果可视化中操纵单个边权重。
- “分箱蜂巢图”——绘制边上节点分箱之间的连接，而不是单个节点到节点的边。
承认
感谢几何数据分析对该项目的开发和开源的支持。
我们还要感谢罗德里格·加西亚-埃雷拉对[pyveplot](https://gitlab.com/rgarcia-herrera/pyveplot)所做的工作，我们将其作为结构设计的起点。我们还翻译了他的一些实用方法用于这个资源库。
更多资源
- 我们的文件可以在https://geomdata.gitlab.io/hiveplotlib/index.html找到
- Hiveplotlib Gitlab 库:https://gitlab.com/geomdata/hiveplotlib
- https://pypi.org/project/hiveplotlib/
- 蜂巢地块的另一个优秀资源:http://www.hiveplot.com/
- 如果你正在寻找网络数据，斯坦福大学的大型网络数据集集合是一个很好的资源:https://snap.stanford.edu/data/
参考
Krzywinski M，Birol I，Jones S，Marra M (2011 年)。蜂巢图——可视化网络的理性方法。生物信息学简报(2011 年 12 月 9 日，doi: 10.1093/bib/bbr069)。
扎卡里 W. (1977)。小团体中冲突和分裂的信息流模型。人类学研究杂志，33，452–473。
介绍 Hone:Julia 的模块化面向对象图形库
为 Julia 对我的图形库的第一个版本进行最后的润色。
绘制数据可能非常令人兴奋，尤其是当你已经使用了一段时间的绘图功能，并且它最终以你想要的方式工作的时候。尽管仍然缺少许多参数，仍然有许多令人头痛的工作要做，但是有许多非常有前途的特性已经解决了。伴随着这些伟大的东西，第一版的《征服》也随之而来。现在您可以从 Github URL 将 Hone 添加到您的 Julia 环境中，
模块化的形状，网格和线条容易预制快速绘图简单和轻型车床集成(即将推出)…
github.com](https://github.com/emmettgb/Hone.jl)
如果您一直关注这个小系列，您可能会记得，在上一篇文章中，我们在绘图软件中留下了两个大漏洞:
颜色和轴。
颜色
因为我们使用 meta 标签来保存我们所有的数据，所以将数据转换成字符串格式可能会非常繁琐，这使得设置形状的填充颜色比通常情况下更具挑战性。哪里有问题，哪里就有想法，我想尝试的下一个想法是把我之前的两个想法结合起来。看一下我们的 Circle 函数，我们可以看到这个特定的问题是如何在原本打算放在那里的 meta 中放了一个重要的洞。
function Circle(x,y,diameter,fillin)
# composition = compose(context(), circle(x,y,diameter), fill(string(fillin))
# "compose(context(),circle(.5,.5,.1))
tag = string("circle(",string(x),", ",string(y),", ",string(diameter),"fill(string(","))")
tree() = introspect(composition)
show() = composition
x = x
y = y
update(x,y) = string("circle(",string(x),",",string(y),',',diameter,",fill(string(",Symbol(fillin),")))")
(var)->(show;composition;tree;tag;x;y;update;diameter)
end
我决定的第一件事是明确使用符号而不是字符串。我决定这样做，因为我认为这样会让我在将来出于其他目的需要调用这些对象的创建时不那么头疼。我们要做的第一件事是将我在第二部分中提到的正则表达式连接到我们的符号上。我们的符号还需要字符串类型断言，如下所示:
color = string("\"",string(fillin),"\"")
简单得很，现在我们所要做的就是重建我们的更新函数，它要么工作，要么不工作。
update(x,y) = string("circle(",string(x),",",string(y),',',diameter,"), fill(", color , "),")
现在让我们画些东西来测试一下！
x = [5,6,5,5.25,5.5,5.8,5,20]
y = [7,7,4,3.8,3.7,3.8,4,20]
shape = Circle(.5,.5,.01,:blue)
b = Scatter(x,y,shape)
我可能把它画倒了…
现在让我们试着把颜色改成粉红色:
x = [5,6,5,5.25,5.5,5.8,5,20]
y = [7,7,4,3.8,3.7,3.8,4,20]
shape = Circle(.5,.5,.01,:pink)
b = Scatter(x,y,shape)
轴
我休息的另一个特性是绘制 x 轴和 y 轴的能力。当然，轴只是从向量 2 (0，0)到向量 2 (1，0)为 X 轴，从向量 2(0，0)到向量 2(0，1)为 Y 轴绘制的简单直线。
这是我们留在“Line”对象中的代码，它允许我们这样做:
function Line(pairs, color)
tree() = introspect(composition)
show() = composition
composition = compose(context(), line(pairs), stroke(string(color)))
pairstring = ""
for i in pairs
s = string(i) * ","
pairstring = pairstring * s
end
update(pairs) = string("line([",string(join(pairstring)),"]), stroke(",string(color) ,")", )
(var)->(show;composition;tree;update;color;pairs)
end
这个函数遵循与 shape 函数相同的自然流程，首先进行合成，然后输入元信息，然后创建一个可调用的函数，用于返回一个标签。这个函数中最突出的部分可能是迭代循环，其中创建了一个空字符串，然后与坐标位置的各个向量连接起来。之所以这样做，是因为 Julia 的 NTuple-to-string 类型断言并不像您预期的那样工作，因此一个很好的解决方法是在一个循环内将单个 dim 转换为字符串，而不是整个变量。
这段代码中缺少的另一点是改变 meta 标记内部颜色的能力。为了解决这个问题，我当然会重复使用之前改变形状颜色的方法。第一步是将这一行添加到函数的第二步，其中定义了元表达式的各个部分。
color = string("\"",string(color),"\"")
相当简单…
现在我们可以将该字符串添加到更新函数中:
string("line([",string(join(pairstring)),"]), stroke(", color, "),")
既然我们的 Line 对象的 update 函数实际上正在工作(我希望如此)，我们可以将逻辑添加到我们的 Scatter 类中来实际呈现线条。第一步是获取标签:
axisx = Line([(-1,-1), (-1,1), (1,1)],:blue)
axisx_tag = axisx.update([(-1,-1), (-1,1), (1,1)])
axisy = Line([(0,0), (0,1), (0,1)],:blue)
axisy_tag = axisy.update([(0,0), (0,1), (0,1)])
与 Shape 对象不同，我们不能用 update 函数一致地调用同一个 line 对象。这是因为需要保留 update 函数，以便返回不会混淆整个类的内容。用不太宽泛的术语来说，如果我们要在这里添加一个回报:
然后，当我们运行函数“Line”来创建行时，我们将从更新函数中获得返回。考虑到这一点，尝试避免每个函数都返回一个值是非常明智的，这样我们仍然可以在不妨碍函数的情况下获得标签。问题是，只有在调用上面的迭代循环时，这些对才会被更新，您可能记得这是将数据转换为字符串所必需的。
现在是简单的部分；回到我们的 Scatter 函数，我们只需要在坐标解析器完成它的工作之前向表达式添加两行标记。
你可能已经注意到我硬编码了轴的颜色，这不是一成不变的，将来也不会是这样。在编程中，我从来不喜欢为了一个测试做不必要的事情。你可能还注意到我添加了一个“debug”参数，这只是为了让我更容易看到将要被计算的表达式，而不必添加临时打印。我认为这也可以帮助最终用户，因为这个库是模块化的，他们可能会自己构建很多东西。
所以让我们来测试一下吧！
观察
首先，您可能已经注意到，笔画也应用到了圆上。这可能是一个简单的解决办法，我只需要给我们的表达式添加一个新的上下文。另一个值得注意的是右下角的点。这一点之所以存在，是因为否则颠倒的笑脸会正好在图的边缘。我认为这明确说明了在散点对象中作为参数的边距的必要性。
绘制真实数据！
既然我们的散点图起作用了，是时候用一些真实的数据来测试它了！对于这个例子，我将使用我的小“WeatherHistory.csv ”,我不知道我从哪里获得的，也不知道我有多长时间了…
数据狂人的症状。
像往常一样，我们需要做的第一件事是用 CSV.jl 读入数据。
现在(不幸的是),我们需要显示参数 allcols 设置为 true 的数据。
数据筛选开始了…
找到我想要绘制的列后，我将它们放入名为“x”和“y”的变量中供我们使用。
x = df[Symbol("Wind Speed (km/h)")]
y = df[Symbol("Temperature (C)")]
接下来，我们需要创建我们想要用来绘制点的形状:
shape = Circle(.5,.5,.10,:lightblue)
然后我们可以把它代入我们的散射函数:
plot = Scatter(x,y,shape)
所以…这杀死了内核，但我不能说我感到惊讶。
事实上，它不仅杀死了我的内核，我认为它也杀死了韦兰。我的终端清空了，这意味着它 CD 回到了家里，彻底关闭了我的 Jupyter 服务器。
很奇怪。
在用 for 循环将 X 和 Y 数组的 dim 数限制到 700 之后(我打赌有一个默认函数我可以使用)，我们终于有了输出！令人惊讶的是，这实际上并没有花费我预期的那么长时间。我还对函数进行了计时，这样我们就可以很好地了解计算速度和分配情况。
我决定做的下一件事是将它与 Plots.jl 进行比较，plots . JL 是用于在 Julia 中绘图的标准库。Plots 模块的问题在于它依赖于 GR、Plot.ly 和 Matplotlib。虽然这很有趣，因为它们都是非常不同的库，并且将它们放在一个模块中肯定很酷也很奇怪，但我不认为使用 Pythonic 代码在 Julia 中绘图对性能来说是个好主意。我做的第一件比较的事情是设置限幅器到 3000 暗，做一个相对基本的测试。结果如下:
对于 Plots.jl:
这些时间没有说明的另一件事是导入 Plots.jl 所花费的令人痛苦的时间。好消息是我的函数比 Plots.jl 快得多。虽然 clearly Plots 绘制了更多的线条，以及图例和轴标签，但我不认为从长远来看这有什么价值，尤其是在我修改函数并寻求更多优化之后。
结论
对于 Hone，我还有很多事情需要完成，因为它还处于生命的早期。我认为我现在所做的所有工作将会使添加新的特征和形状变得非常容易，因为所要做的只是添加一个元表达式。使用 meta 的另一个很大的优点是，每个单独的对象仍将存储在内存中，并完全可以由最终用户调整，因为它存储在 debug 设置为 true 时，您可能会想起打印的相同表达式中。我对 Hone 最大的担忧可能是性能。虽然现在我当然可以进行一些优化，但我担心大量的优化可能会导致整个模块的彻底返工，就像发生在车床上的情况一样。虽然这可能是不可避免的，因为我喜欢不断地改进我工作的软件，我非常希望不必重写模块。
刚刚绘制的阵列大约有 96，000 个观察值，这当然是一个很大的数字，
但应该不是不可能的。
我也打算尽我所能地挑战极限，所以从这里开始并不一定是一件好事，因为这意味着我面前可能有很多工作要做。重要的是要记住，这些也是可缩放的图形；这意味着我们可以预期，在没有拉动一些字符串的情况下，类似的光栅化输出库的性能会更差。
尽管它的问题和一些改进肯定是可以做的，我对它目前为止的表现非常满意，我期待着为这个包添加更多的功能和优化。
JDoc 简介:Jupyter 笔记本上的团队对话
团队在 GitHub 上查看 Jupyter 笔记本的简单方法
在 ReviewNB 中，我们已经支持 GitHub 提交/拉取请求的 Jupyter 笔记本视觉差异&评论。
**今天我们发布了 JDoc，这是一个让团队在 GitHub 上查看笔记本的简单方法。**您可以打开存储库中的笔记本&在任何笔记本单元格下开始讨论。观看此存储库或参与对话的团队成员将会收到通知(通过电子邮件),以便他们能够插话并推进对话。这个工作流程对于数据科学/ ML 团队来说非常有用，他们可以互相回顾彼此的工作，提出澄清性问题&并直接在笔记本电脑上提供反馈。
为什么是新功能？
我们在“拉”请求上提供笔记本审阅功能，这在许多情况下非常有效，但在某些情况下却不尽如人意。
- **有时候你并不在乎笔记本的差异。**例如，我提交了一个新笔记本，上面有一些特别的分析&想让我团队中的某个人审阅一下。为了评审而创建一个 pull 请求有点多余，因为这个文件(新添加的笔记本)没有区别&没有合并到主文档工作流事后评审(特别分析)。
- 不是每个笔记本用户都精通 Git/GitHub。要求他们创建功能分支并打开拉取请求可能有点过分。有了 JDoc，作者只需将笔记本提交给 GitHub，就可以查看了。
- 有时你想在特定笔记本上查看所有过去的讨论&导航到文件的不同版本。JDoc 通过其以笔记本为中心的同行评审方法&版本控制使这变得容易。
它是如何工作的？
- 当您在 ReviewNB 上打开存储库时，您现在可以看到新的笔记本选项卡
- 您可以打开笔记本并在任何笔记本手机上开始对话
- 观看此存储库或参与对话的队友将在电子邮件中收到新的评论通知。当然，如果他们愿意，他们可以取消电子邮件通知。
- 队友可以回复/解决/开始新的对话或浏览评论。还有一个变更标签，显示该笔记本的版本历史。
需要注意的重要事项
- 有了拉式请求评论，你在 ReviewNB 上写的所有评论都会直接发布到 GitHub 上相应的 PR 上。**有了 JDoc，你写的所有评论都用 ReviewNB 保存。**这是因为 GitHub 没有提供任何直接在文件上发布注释的方式(GitHub 注释只允许在 commits/PRs 上发布)。当然，您的评论在 ReviewNB &中是安全的，存储库管理员可以请求机器可读导出他们报告中的所有评论。
- 目前，如果您更改了存储库中的笔记本名称/路径，它将被视为一个新文件 &您将不会在其中看到旧的对话。这是因为用原始 git 数据检测文件重命名并不容易。将来，我们将提供一个 UI 来指定重命名，然后通过注释进行移植。
- 由于 JDoc 就像是 Jupyter 的 Google Docs，所以在笔记本的整个生命周期中会产生很多对话。明智的做法是积极解决/删除旧的对话，以保持文档的整洁。
结论
JDoc 降低 Jupyter 笔记本同行评审的准入门槛。在某些情况下，它们比拉式请求审核更有意义，例如，您想要审核新添加的笔记本，或者您只想发布最终的笔记本版本进行审核，而不关心如何实现增量更新。
拉式请求评论仍然很值得一看视觉差异 &它们充当了讨论的奇妙容器。公关过程也有工程上的严格要求，因为最终结果是合并到母版。
我希望你能结合公关审查的力量和 JDoc 的灵活性，达成一个适合你的团队的平衡。
黑客快乐！
原载于 2020 年 6 月 20 日 https://blog.reviewnb.com*。*
Julia 简介:数据科学中 Python 和 R 的替代方案
迎接面向科学计算、数据科学和机器学习的 21 世纪编程语言。
当有人对我说，有一个新的孩子在这个街区，在这种情况下，孩子=编程语言，我有点怀疑。有一段时间，我是一个重度 Python 用户，工作时看 8 小时，在家看 3-4 小时——我喜欢它，没有理由不喜欢它。
嗯，也许有几个…
可以想象，一天中有一半甚至更多的时间在用 Python 编程的人，在尝试新语言时可能会有点怀疑。不久前，有几个人试图说服我转到 R，我真的尝试过，但不喜欢它。
数据科学不仅仅是关于统计的，你还必须创建 API 和其他东西，这样最终用户才能以某种方式与你所做的东西进行交互，所以对我来说，选择编程语言而不是统计语言是很自然的。但你可能不同意，这没关系。
无论如何，让我们回到主题。 那么朱丽亚是什么呢？ 根据快速网络搜索，Julia 是一种由麻省理工学院创建的高级、高性能、动态和通用编程语言，主要用于数值分析。该语言的工作始于 2009 年左右，第一次发布是在 2012 年。所以这种语言到现在已经有 8 年了，不是一个短时期，但肯定没有 Python 那么长。
那是一个相当的句子。你可以把它想象成 R 和 Python 的混合体，但是更快，因为它是一种编译语言。Julia 相对于 R 和 Python 的一些主要优势是:
- 它是编译过的——Julia 是实时(JIT)编译的，最好能接近或匹配 C 语言的速度
- 它可以调用 Python、C 和 Fortran 库——是的，你没看错，我们以后会更详细地探讨这个问题
- 并行化—Julia 中的并行化比 Python 中的更加精细
然而，举几个例子来说，每一个优点都有一个缺点:
- 数组索引从 1 开始——这对我来说太疯狂了
- 没有 Python 成熟
- 没有 Python 的那么多包——但是你可以通过 Julia 调用 Python 库
好的，我只希望你还在，因为现在我们将探索 Julia 编程语言的一些关键概念。然而，首先我们应该安装语言，对吗？
如何安装 Julia
在这一小节中，我们将快速浏览一下安装 Julia 的过程，并为 Jupyter 设置一个内核。如果你不使用 Jupyter，请随意下载你选择的编辑器插件。
让我们开始吧。打开下面的网址，点击那个写着下载的绿色大按钮。你将被要求指定你的操作系统，对我来说是 Windows x64，然后你可以下载文件。安装本身很简单，只需按几次下一步，你就可以开始了。
总之，我们还有一些工作要做。你需要打开 Julia 提示符，窗口应该是这样的:
现在输入下面两行:
using Pkg
Pkg.add("IJulia")
大约一分钟后，Julia 内核将配置有 Jupyter，我们可以通过打开 JupyterLab 来验证这一点，现在我已经有了 Julia 解释器和 Python 解释器:
太好了，现在创建一个 Julia 笔记本，你就可以开始享受乐趣了！
让我们探索一下基础知识
在新创建的笔记本中，您可以像使用 Python 一样定义变量:
默认情况下，变量值会被打印出来，为了避免这种情况，你可以把分号(；)在最后。如果你已经注意到，字符串需要用双引号括起来，因为单引号是为字符类型保留的。
您可以轻松地连接两个或更多字符串:
一开始乘法符号可能会很奇怪，但是你会习惯的。您还可以轻松检查任何给定变量(或值)的数据类型:
Julia 在数组的创建方面与 Python 类似(在某种程度上)，您不必指定数据类型或元素数量:
但这并不意味着你不能:
您可以用类似的方式声明向量，只是不要用逗号(，)分隔项目:
以类似的方式，你可以声明多维数组:
现在我们已经讲述了一些基础知识。接下来，我想快速介绍一下如何与 Julia 一起处理数据。
数据科学部分
首先，让我们安装 3 个库—用于处理 CSV 文件、数据可视化和一般数据框:
安装需要一分钟左右的时间，但安装完成后，我们必须在使用前导入它们:
好了，现在我们准备好了。对于一些快速的数据分析，我将使用 GitHub 上免费提供的 虹膜数据集 。让我们把它装进去，变点魔法:
如果您想知道，normalizenames param 将确保列名没有任何不需要的字符，比如点(。)，这些将被替换为下划线(_)。
您可以像使用 Python 的 Pandas 库一样浏览数据。让我们看看如何获取前 5 行和后 5 行，以及快速统计摘要:
这还没有触及表面。你能想到的熊猫图书馆的任何东西，很可能在朱莉娅中有一个替代品。
是的，这种语言在策划方面也很神奇。看看这几行代码能够产生什么:
开箱即用，它看起来比我用 Matplotlib 制作的任何东西都要好。你也可以做一些新奇的事情，比如组合情节:
您还可以做更多的事情，但这超出了本文的范围。
在你走之前
毫无疑问，朱莉娅是一种令人惊叹的语言。这篇文章的目标是展示基础知识——无论是语言本身，还是它处理数据的能力。
在接下来的文章中，我将更深入地关注各个部分，同时考虑它与 Python 的不同之处，以及我认为这种不同是积极的还是消极的。现在，我要说的是，数据可视化功能远远超出了传统 Python 可视化库所能提供的。
我在其他问题上的立场如何，嗯，你将不得不继续关注来找出答案。感谢阅读。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
介绍 Label Studio，数据标签的瑞士军刀
专业的机器学习工具是构建成功的基于 ML 的产品的基础和脚手架。
当我在一家企业从事个人虚拟助理项目时，我自己也经历过工具的缺乏，这个项目被大约 2000 万人使用。我们的团队一直在寻找提高质量、处理边缘案例和测试假设的方法。这通常需要处理非结构化数据，对其进行标记，直观地检查和探索模型预测。我们将一套内部工具拼凑在一起，用成吨的样板代码工作一次。不用说，共享这些工具或试图扩展它或将其嵌入到主应用程序中几乎是不可能的。
一次又一次
而且，这个过程是关于产品的定量分析。在试图改进模型时，机器学习工程师严重依赖于在固定数据集上计算的精度/召回统计数据，而忽略了该数据集如何与实际的真实世界数据保持一致。最终，它会导致生产中的系统误差，这只能通过定性分析来识别，即用你的眼睛观察模型的预测。
在生产中我能信任我的模型吗？照片由黛比·兰福德拍摄
我和几个朋友在想，我们能做得更好吗？Label Studio 就是这样诞生的。它旨在为个人机器学习实践者节省原型/实验时间，以及为技术团队缩短 ML 产品发布生命周期。
我们在工作时遵循的一些原则是:
- **化繁为简。**没有复杂的配置，易于集成到机器学习管道中。Label Studio 可以在不同的地方使用，具体取决于使用情况:
- 可快速配置多种数据类型。10 分钟内准备好工具。应该有一种简单的方法在标记文本、音频或图像之间切换，甚至同时注释所有三种类型。
在左侧面板中添加组件，并立即预览界面和输入/输出。
- **机器学习集成。**它应该能够集成所有过多的机器学习框架和模型。ML 有许多不同约束的应用，Label Studio 必须足够灵活来处理它们并提供帮助，而不是复杂化。
如果这听起来很有趣，让我们安装它，让你开始运行！
我们开始吧
启动 Label Studio 非常容易:
pip install label-studio
label-studio start my_project --init
它会自动在您的浏览器中打开 web 应用程序。只需配置您想要标记的内容和方式。就是这样。
文本的命名实体识别
许多现有的标记框架只接受一种数据类型，每次学习一个新的应用程序变得很乏味。开箱即用 Label Studio 处理文本、图像、音频、 HTML 文档(称为对象组件)，以及任何可以想象的注释任务组合，如分类、回归、标记、跨越、成对比较、对象检测、“
让我们来探索如何为您的用例配置 Label Studio 服务器
配置贴标界面
Label Studio 的界面不是预先构建的。相反，你可以自己创建它，就像创建网页一样。但是你得到的不是 HTML 标签，而是基于 jsx 的组件。不要害怕！除非你想，否则你不需要写 JavaScript。组件知道如何根据它们的类型和名称进行连接。这是一个图像分类的例子，其中通过使用 toName 属性指定名称，将选择(注释组件)连接到图像(对象组件)。
用预期的输入和输出标记配置
注意美元符号变量 $url 。它指定该组件的值来自您的数据集，它期望带有关键字 url 的记录提供图像的 url。前进到设置页面，用我们在那里的例子玩一玩。或者如果你还没有在当地经营，你可以去看看游乐场。
目前，大约有 20 个组件涵盖不同类型的标签，例如，图像的 Bbox 或文本的 NER。完整的列表可以在网站上找到。
数据导入和导出
配置好标注界面的外观后，您可以导入数据。web 导入支持多种格式:JSON、CSV、TSV 以及由这些格式组成的档案。您想要标记的每个数据点被称为一个任务。如果您的任务包含图像，您必须将它们保存在某个地方，并在数据键中公开 URL，就像上面例子中的{"url": "https://labelstud.io/opossum.jpg"}。然后，任务被加载到标签界面，等待您对其进行标签。
直接从文件系统导入数据集或使用 URL 上传，S3 集成即将推出
使用标签-工作室-转换器完成输出。这是一个库，可以采用基于内部 Label Studio JSON 的格式，并输出一些通用格式(JSON、CSV、TSV)或特定于模型的格式，如用于文本标记的 CONLL 或用于计算机视觉模型的 Pascal VOC 或 COCO 。
底层存储是普通文件。这使得集成变得非常容易，您只需要将数据放入 Label Studio 可以解析的格式中。您可以在网站上找到更多关于格式的信息。
好吧！现在你有了数据，你知道如何标记和如何导出，让我们来看几个用例，如何将 Label Studio 集成到你的管道中。
功能和使用案例
Label Studio 首先是一个数据标注工具，这使得它非常适用于所有基本的数据标注活动，如标注整个数据集或创建用于验证的基础事实标签。除了这些基础知识，这里还有一些对其功能非常独特的用例。
嵌入你的应用
对于某些应用，你能得到的最好的标签之一可能来自你产品的用户。你可以要求他们从头开始标记任务，或者提供一个模型预测并请求调整它。然后利用它来不断更新模型和提高应用程序的效率。
Label Studio 的独特之处在于，它是一个前端 NPM 包，可以包含在你的应用程序中。这里有一个例子:
收集用户反馈，灵感来自一个流行的视频共享服务
这里可以现场查看。或者看看要诀的来源。可以保存在本地，在浏览器中打开！
机器学习集成，连接模型
你可以通过使用 SDK 轻松地将你喜欢的机器学习框架与 Label Studio 连接起来。
SDK 创建可通过 URL 访问的微服务。它的框架是不可知的，并提供了集成示例。
这让你有机会使用:
- 自动贴标。使用模型预测标注数据。通过任务预标记，以及使用伪标记进行进一步训练，有助于更快地进行注释
- **不断学习。**从数据流中持续注释和训练您的模型，潜在地改变注释目标
- **主动学习。**实现对要标记的任务的更智能选择的技术
- 预测服务。即时创建和部署 REST API 预测服务
要了解更多关于起床和跑步的信息，请查看自述文件中的示例。
比较预测
您可以将来自不同模型体系结构或版本的多个预测加载到界面中，直观地验证、查找差异，并编辑您的模型所预测的内容:
来自不同模型的预测，并排比较它们
甚至更多
我们只讨论了我们自己发现令人兴奋的少数几个用例，以及我们看到 Label Studio 可以提供优于现有解决方案的优势的地方，但在我们撰写下一篇文章时，这里还有一些想法供您探索:
监控模型预测误差
你能永远相信你的模型预测吗？您如何理解什么时候是重新培训和重新部署模型的好时机？您可以将 Label Studio 集成到模型监控管道中。与上面的示例一样，您可以显示模型预测的多个版本，并检查预测质量是否有所下降。
(循环)预测管道中的人类
对于预测质量至关重要的应用，当模型不确定或充当低精度检测器时，可以使用 Label Studio 来调整模型预测。在这些场景中，模型预测首先被发送给注释器，注释器可以手动调整它。
从多人那里收集结果
Label Studio 支持每个任务多个结果(称为完成)，如果您需要将同一个任务分发给许多注释者，然后验证或组合他们的结果，这是非常有价值的。它的工作方式类似于模型预测可视化，不同之处在于可以将完成设置为基础事实并进行编辑。
增量数据集标注
在将模型部署到生产环境中之后，或者在开发它的过程中，您可能会意识到多标注一个属性可以增强模型的结果。这可能是您想要测试的假设或预定义的策略——从少量属性开始，随着时间的推移添加更多属性。您可以使用 Label Studio 进行增量标注:修改标注配置并随时添加新类。
后续步骤
这仅仅是一个开始。我们计划覆盖越来越多的数据类型，并实现更多覆盖不同标签场景的组件。
- 访问 GitHub 上的主库
- 探索我们为一些流行的贴标案例创建的模板https://labelstud.io/templates/
- 检查标签https://labelstud.io/tags/
- 尝试运行一个演示,您可以在浏览器会话中创建持久的注释运动场
我们总是很乐意了解更多可能的人在回路中的用例，并期待在 Label Studio 中实现它们。如果您有建议和/或反馈，请通过在 GitHub 上发帖或加入我们日益壮大的 Slack 社区与我们分享！
快乐贴标签！
Leya 简介:元统计 Lisp 类语言
我正在创造我梦想中的语言。
在过去的几周里，我一直在享受 GNU Common Lisp 的强大功能。在 Common Lisp 中，所有代码都包含一个列表，它是 list 中的一个数据类型。本质上，Lisp 程序只是列表中的一系列参数。首先，这使得 Lisp 成为元编程极其可行的语言。Lisp 的宏进一步增强了这种效果。Lisp 的宏使得从语言内部调用子进程和使用代码作为数据类型变得非常容易。这当然是非常有效的，不仅可以使你的代码干净、简洁、易读，而且可以自动化。
我正在构建的语言 Leya 是一个将这种方法论发挥到极致的计划。Lisp 很棒，但我确实不喜欢 Common Lisp 的某些地方:
- 包裹绝对是一种痛苦。我想有一个简单的结构类似这样的导入功能:
(import :package)
在 Lisp 中，添加包绝对是一场噩梦。当然，这不一定是 Lisp 的错，因为这种语言是在 1958 年创造的，但这肯定是一个缺点。包作为一个简单的文件存储在任何外部环境的本地，并且必须直接从源代码加载。如果不考虑安装在系统范围内的 lib-dependency(例如-lib-SDL 2)不能在 Lisp 中使用，这可能并不奇怪。有替代方案，比如 beta 版 Quick Lisp 包，但是这些肯定不能替代一个有效的包管理器。
- Lisp 实际上可以快得多，只要在后端做一些性能上的调整。
Lisp 具有强大的统计能力和惊人的速度！对于数据科学来说，这两者可能是致命的组合。事实是 Lisp 实际上可以比现在快得多。要理解这是为什么，我们需要理解一个叫做控制流的概念。每种语言都有一个控制流，控制流既可以“跳转”，也可以根据具体情况忽略。跳转是这里的关键词，因为无论何时进行跳转，程序的控制流都会随之改变。
默认情况下，控制流是垂直的，每个部分从 1 开始向上计数。这里有一个例子，写在 NASM 编译的汇编里:
_start:; Allocate our memory; Get the current brk address
mov rax, 12 ; brk
mov rdi, 0
syscall; rax => alloc_ptr && heap_start
mov [alloc_ptr], rax
mov [heap_start], rax; (Allocate memory)
mov rdi, rax
; 64 == 9 million;
add rdi, 1000000; Syscall
mov rax, 12
syscall; Read the source code into memory
; VVVVVVVVVVVV Recreate this with call reading_loop attached
; for read evaluate print
reading_loop:; Read from stdin
mov rax, 0
mov rdi, 0 ; stdin
mov rsi, [alloc_ptr]
mov rdx, 100000
syscalladd [alloc_ptr], raxcmp rax, 0
jne reading_loop
; call reading_loop
; After the loop:; Save the end of the program
mov rax, [alloc_ptr]
mov [program_end], rax; Add a null terminator
mov byte [rax], 0
inc rax; Align pointer
align_loop:
mov rdi, rax
and rdi, 0
好吧，这看起来像很多代码。
但是为了理解控制流，我们只需要看几个例子。每当调用“_start:”时，控制流被设置为降序，一个包含数字 0 的字节被放入内存。在“_start:”完成后，由于没有跳转或调用，控制流将继续下降，当它完成与内核的 syscall 通信时，它将进入位置 1:“reading _ loop:。”
在读取循环的最后，我们会看到三个命令:add、cmp、jne。首先，add 是做什么的？Add 将把我们在。bss 部分或。数据段添加到注册表 rax，它是 64 位高位注册表中的第一个位置。下一个命令 cmp 是 compare 的缩写。这将比较两个值，并根据标志的结果更改标志。在这个特殊的例子中，我使用存储在字节 0 的注册表标志，CF 标志。
(img src:https://www . slide share . net/safayethossain 3/assembly-flag-resister)
最后但同样重要的是 jne，这是一个条件跳转。如果满足这个标志，那么 jne 命令将通过将控制流保持在位置 1:“reading _ loop:.”来将控制流变成一个圆形
控制流实际上驱动了我们在日常语言中使用的大多数东西，以及我们使用的每个高级工具，例如循环、条件等。实际上通常会使用非常特殊的控制流。
(img src:【https://dzone.com/articles/how-draw-control-flow-graph】T2
当然，控制流不仅对我们想要做的事情非常重要，对性能也非常重要。你可能听说过 for 循环，一般来说，非常能够坦克性能。这是因为 for 循环使用至少四个位置的组合，并将根据添加的数据字节进行条件跳转(将字符长度存储在内存中，并将 cmp 值保存在内存中，循环数。)这意味着每次不满足最终迭代条件时，控制流将减少 2。假设我们在位置 3，每次 for 循环没有完成，我们就跳到位置 1，重复这个过程。
很明显，有很多方法可以通过调整控制流来提高性能。这个方法其实是朱莉娅想出来的，所以我不能居功；每当汇编编译器调用自身时，控制流就会不断地循环。这意味着在语言内部运行比汇编语言更有性能。这是因为汇编的进程在执行前由处理器读取。这类似于大多数语言的编译方式。
然而，当语言中最常用的核心函数是用语言本身编写的时候，就可以在运行时进行调用，而不需要另一次汇编。所以我们的目标是在一个单独的线程上运行一个已经分配、加载并标记了内存的代码。
结论
作为一种类似 Lisp 的语言，Leya 编程语言拥有 Lisp 的所有优点。轻松编译，用汇编器只汇编 3000 行左右的代码，一切都是列表，还有用宏进行元编程的轻松和流畅。
创建一种与另一种语言做同样事情的语言是有点愚蠢的，尽管我会第一个说构建编译器使我在汇编和编程方面做得更好。实际上，有一本有趣的书叫做《用 C 语言构建你自己的 Lisp 》,如果你想学习 C 语言，我建议你去看看。构建 Lisp 不仅能让你更好地学习 C 语言，或者帮助你学习 C 语言，而且我认为它还能让你更接近许多理解起来非常重要的计算机科学基础。
“Leya”这个名字的本意是解释它自己，而这种语言的构建意图完全不同:
机器学习的快速元编程。
“Leya”这个名字来源于术语 Lemma，它是一个论证或证明中的数学分离，也是中间的。这是我的原话，但这是谷歌的定义:
“论证或证明中的附属或中间定理.”
这非常类似于编程中的宏指令。Y 来自于我们都知道并且喜爱的 Y，我们算法的目标。
因为 Lisp 是轻量级的，易于编译，所以 Lisp 是一种非常快速的编程语言。Lisp 通常被认为不能像 C 那样使用，但是它的语法非常高级，很容易习惯。Lisp 最难的一点是，为了使用它，你必须直接从传统的角度来思考所有的事情。从回报开始，一直到价值。通常我只在一个值被循环使用的特殊情况下设置一个变量，以避免多次计算。
感谢您阅读到最后，如果您想了解 Leya，请访问 Github:
Leya -火烈鸟的官方编程语言。通过在…上创建帐户，为 emmettgb/Leya 的发展做出贡献
github.com](https://github.com/emmettgb/Leya)
每天都有越来越多的问题涌现出来，慢慢地，但肯定地，问题正在得到解决。截至目前，我有大约六个项目，我一直在工作，所以开发一直很慢(请放心提交！)但是希望到最后，这种语言是我所有数据科学需求的理想选择。
简单介绍线性回归(最小二乘法)
编码前理解
杰克·布吕克在 Unsplash 上的照片
线性最小二乘监督拟合技术是最简单和最常用的线性回归形式，为通过一组点找到最佳拟合直线的问题提供了解决方案。
我们的一般线性回归模型看起来像这样-
输入是一个特征向量 (x1，x2，⋯，xk)
输出是一个标量 y
该模型将输出与输入特征向量以线性关系联系起来:y = w0+w1 * x1+w2 * x2+w3 * x3+…+wk * xk
w0 是偏差。
我们为什么需要偏置？
在线性回归中，如果没有偏差项，我们的解必须经过原点。也就是说，当我们所有的特征都为零时，我们的预测值也必须为零。然而，这可能不是训练数据给出的答案。添加不依赖于任何特征的偏置权重允许由学习的权重描述的超平面更容易拟合不经过原点的数据。
偏置与无偏置
简单线性模型
现在，考虑一个非常基本的两变量线性模型。温度是自变量，我们希望找出温度对销售(因变量)的影响。
这 12 个数据点是(x，Y)的形式。x 坐标代表以摄氏度为单位的温度，Y 坐标代表以美元为单位的销售额。第一步是将数据可视化——绘制成图表(如上图所示)。在这种情况下，绘图是可能的，因为我们只考虑两个变量。
我们的目标是找到一条线，它是最适合上述数据的*，如上图所示。*
这条最佳拟合线是如何计算的？
任何一行都具有以下形式:
y = mx +c
其中 m 为直线的斜率(逆时针计算直线与 x 轴所成角度的tan)c为 y 截距。
这里 y 表示特定温度下的销售额 x.
因此，我们的 最佳拟合 线也将是 y = mx + c. 的形式
考虑第一个数据点(x1，Y1):
x1 : 实际温度值，单位为摄氏度
Y1 : 实际销售金额对应 x1
y1 = m * x1+c:根据最佳拟合线预测 x1 对应的销售值
E1 = y1 — Y1
E1 是第一个错误术语。
计算单个误差
注意:在统计学中，当我们使用术语“线性模型”时，我们不一定描述一条直线。
图中的两个形状都是“线性的”:
哪个是线性的？
“线性”在统计学中是用来描述我们正在使用的模型中的参数。线性意味着响应(y 变量)预期是解释变量(离散或连续)的线性组合。线性是指解释变量是可加的。
当我们说模型是线性的时，这种说法实际上是不完整的。线性回归需要指定和检查的是，如果模型是线性 w . r . t .参数 (w0，w1，w2，…，wk)。
回到错误上来。我们的目标是减少这些误差，从而最小二乘误差。
为什么我们使用“平方”误差，而不是误差的高次幂或绝对值？
这里有两个原因:
- 随着功率的增加，异常值的误差会放大更多。结果，越多的“最佳拟合”线将被拉向异常值，这将不再是最佳拟合。
- 最小化一个二次函数很容易——你只需要对它求导并将导数设置为零，这就产生了一个线性方程——我们有几个世纪的技巧来帮助我们解决这个问题。
通过缩放区域来直观地传达基础数据，从而提高地图的可视化效果
使用 mapscaler 按人口或任何其他值缩放州或县，以实现 choropleth 数据可视化
如何根据人口或任何其他值缩放州或县，以实现 choropleth 数据可视化
许多使用颜色作为维度的地图可视化具有误导性。
社交数据经常被放在地图上(一个 choropleth)，并用颜色来表示一些活动或行为。问题是，数据往往是关于人，但在读者眼里，地图本来就是关于地区的。地图上最大的区域吸引了读者的注意力，而忽略了数据中有多少人与该区域相关。如果你显示的数据恰好是按区域标准化的，比如人口密度，这没什么，但是这通常不是我们可视化的目标。
问题是，数据往往是关于人，但在读者眼里，地图本来就是关于地区的。
有时图表是更好的选择，但是大多数图表要么扭曲难以辨认，要么高度手工创建。因此，我创建了一个 Python 包，通过任何变量自动缩放任何地图的各个部分，没有任何重叠的形状，失真最小。
介绍贴图缩放器！您所需要的只是一个 GeoPandas 数据框架，包括一个列，其中包含用于缩放每个多边形的值。Mapscaler 将从那里开始做繁重的工作——将每个多边形缩放到适当的大小，然后重新排列它们(最低限度),直到它们不重叠。
这可以让你的地图对读者来说更加直观，而且出奇的漂亮！这里有一些例子来说明:
例子
1)美国各县
政治分析家喜欢用政治偏好来渲染地理。下面是一个典型的地图样式，使用的是 2000 年乔治·w·布什和阿尔·戈尔之间的总统选举数据:
这是一个差的形象化！目标是传达关于人们如何投票的信息，但这隐藏了一个完整的维度:并非所有这些县都有相等的投票人口！眼睛很容易被颜色比例所迷惑。2000 年的选举是历史上最接近的选举之一，只有 5 个选举人获胜！从这张地图上你永远也猜不到。一个更好的方法是根据投票的多少来划分各县。通过这种方式，读者可以了解有多少人投票给了哪个政党，也可以了解选民的地理分布情况:
如果您喜欢“气泡”而不是保留原始形状，mapscaler 也可以做到这一点:
2)美国各州
如果你有脸书，你(希望)知道他们追踪你带着手机去的任何地方。最近，脸书的“数据为好计划”发布了匿名数据，以证明新冠肺炎导致的流动性下降。在撰写本文时，你可以在链接找到一张地图，显示每个州有多少人留在原地:
资料来源:美国人口普查局，脸书良好计划数据
当大多数人看到这一点时，他们的目光会被吸引到美国中部色彩鲜艳的州，或者最多是中西部。毕竟，那是美国大部分地区的所在地！一个更好的地图应该按照人口比例来划分各州，以显示人口的实际分布情况:
资料来源:美国人口普查局，脸书良好计划数据
在后一张图中，你的视线被吸引到了德克萨斯州和沿海地区。这是应该的，因为那是大多数人真正生活的地方！这张地图，用同样的数据，讲述了一个更好的故事。
3)较小的地理区域
为了展示 mapscaler 的灵活性，这里有一个更局部的例子。北卡罗来纳州公共教育部公布了他们的支出；以下是 2018 年按县分列的用于残疾儿童的所有美元:
当然，在不知道孩子们实际上学地点的情况下，这张地图用处不大:
Mapscaler 可以用pip install mapscaler从 PyPi 下载。它还包括一些内置的地图，让你开始；我已经在官方文档中发布了一些示例代码。给我反馈或问题！
其他链接:
MIDAS 简介:图中异常检测的新基线
图片来自 Github
在机器学习中，自动驾驶汽车、GANs 和人脸识别等热门话题经常占据媒体的大部分聚光灯。然而，数据科学家正在努力解决的另一个同样重要的问题是异常检测。从网络安全到金融欺诈，异常检测有助于保护企业、个人和在线社区。为了帮助改进异常检测，研究人员开发了一种叫做 MIDAS 的新方法。
迈达斯是什么？
在新加坡国立大学，博士生西达尔特·巴蒂亚和他的团队开发了 MIDAS，这是一种新的异常检测方法，在速度和准确性上都优于基线方法。
MIDAS 代表基于微簇的边缘流异常检测器。顾名思义，MIDAS 检测微团簇异常或图形中突然出现的可疑相似边缘组。MIDAS 的主要优势之一是它能够实时检测这些异常，速度比现有的最先进的模型快许多倍。
图中异常检测的真实用例
简而言之，异常检测是寻找偏离数据集中预期的模式或异常值的实践。它可以帮助我们找到并消除有害内容。“图中的异常检测是在无数系统中发现可疑行为的关键问题，”西达尔特说。“其中一些系统包括入侵检测、虚假评级和金融欺诈.”
这项技术可以帮助 Twitter 和脸书等社交网络检测用于垃圾邮件和网络钓鱼的虚假个人资料。它甚至可以用来帮助调查人员识别网上的性侵犯者。“使用 MIDAS，我们可以在动态(时间演化)图中找到异常的边缘和节点，”西达尔特说。“在 Twitter 和脸书，推文和消息网络可以被视为一个时间演化图，我们可以通过找到这些图中的异常边缘和节点来发现恶意消息和虚假信息。”
异常检测的一些其他常见用例包括:
- 垃圾邮件过滤器
- 信用卡欺诈检测
- 数据集预处理
- 网络安全性
- 社交媒体内容审核
MIDAS 优于最先进的方法
“异常检测是一个经过充分研究的问题，大多数提出的方法都集中在静态图上，”西达尔特说。但是，许多真实世界的图表本质上是动态的，基于静态连接的方法可能会遗漏图表和异常的时间特征
MIDAS 解决了实时检测异常情况的需要，以便尽快开始恢复，并减少恶意活动的影响，如欺诈性信用卡购买。
“此外，由于顶点的数量会随着我们处理边流而增加，我们需要一种在图形大小上使用恒定内存的算法，”西达尔特解释道。此外，许多应用中的欺诈或异常事件发生在微集群或突然到达的可疑相似边缘组中，例如网络流量数据中的拒绝服务攻击和锁步行为
“通过使用一个原则性的假设检验框架，”西达尔特说。" MIDAS 提供了假阳性概率的理论界限，这是早期的方法所不能提供的."
迈达斯是怎么测试的？
西达尔特和他的同事展示了 MIDAS 在社交网络安全和入侵检测任务中的潜力。他们使用以下数据集进行异常检测:
- Darpa 入侵检测(450 万次 IP-IP 通信)
- Twitter 安全数据集(2014 年有 260 万条与安全事件相关的推文)
- 推特世界杯数据集(2014 年足球世界杯期间 170 万条推文)
为了比较 MIDAS 的性能，团队查看了以下基线:
- RHSS
- 色丹斯波特
然而，由于 RHSS 在 Darpa 数据集上的 AUC 测量值很低，为 0.17，该团队通过与 SEDANSPOT 进行比较来测量准确性、运行时间和真实世界的有效性。
结果呢
MIDAS 检测微团簇异常的准确率高达 48%,速度是当前基线方法的 644 倍。
“我们的实验结果表明，MIDAS 比基线方法高 42%-48%的准确率(就 AUC 而言)，”西达尔特说。“此外，MIDAS 处理数据的速度比基线方法快 162644 倍.”
改进 MIDAS:未来的工作
“我们已经将 MIDAS 扩展到 M-Stream:快速流式多方面群体异常检测，”西达尔特说。“在 M-Stream 中，我们检测具有分类和数字属性的多方面数据上的异常。”
西达尔特和他的团队表示，M-Stream 在准确性和运行时间方面也优于几个基准，包括流行的 Sklearn 算法，如隔离森林和局部离群因子。然而，他们与 M-Stream 的合作目前正在审查中。
“考虑到 MIDAS 的性能，我们认为它将成为一种新的基线方法，对异常检测非常有用，”西达尔特说。“此外，探索 MIDAS 如何在其他应用中发挥作用也将是一件有趣的事情.”
如果你有兴趣了解更多关于迈达斯的知识，请查阅西达尔特的全文。你也可以在 Github 上下载代码和数据集。
要获得更多机器学习采访、指南和新闻，请查看下面的相关资源，不要忘记订阅我们的时事通讯。
介绍电影大亨:GCP 为好莱坞主持的产品创意
利用谷歌云平台上的自然语言处理和大数据帮助电影投资
按作者分类的图片—产品徽标
向好莱坞的潜在客户和投资者推销产品…**
产品背后的动机
电影和观众的关系已经有几十年的历史了。电影不仅反映了我们生活的社会，也塑造了流行文化和愿望。然而，在互联网时代，这种联系已经逐渐超越了票房、影院和电视领域，成为在线流媒体和电影股票交易。
哼！电影炒股？那是什么？让我解释一下…
好莱坞证券交易所是世界领先的娱乐证券市场。在 HSX.com 的，游客用一种叫做好莱坞美元的货币买卖名人和电影的虚拟股票。****
显然，人们正在以更新的方式参与电影。作为一个行业，好莱坞也越来越多地期待利用数据分析来为创意和商业决策提供信息，这一点在大西洋上一篇名为 大数据和好莱坞:爱情故事 的报道中得到了强调。
“我的梦想是，当好莱坞真正开始关注数据，大规模使用数据，并推动商业价值时。”IBM 高级分析全球负责人 Richard Maraschi
电影大亨
电影大亨为 HSX.com 的电影投资者提供投资方向和投资对象的建议。此外，目的是为创意人员提供一个工具来分析评论，并将其作为未来项目的反馈。通过这种方式，投资者可以确定投资影院业务的正确价格，影院所有者可以根据票房预测安排电影放映。
数据管道
图一。来自 HSX 和烂番茄的数据流进入中枢引擎
除了来自罗顿番茄的评论，以下数据点来自 HSX 的周末票房:
- 电影名称
- 标志
- 周毛收入
- 总额
- 类型
- 出厂日期
- 剧院
- 美国电影协会评级
数据架构
图二。数据架构和相关的数据收集工具
产品管道
在数据来源于允许在电影数据库上查询解决方案的 Hive，以及 python web 抓取工具被部署来构建用于执行自然语言处理的语料库之后，电影大亨利用 GCP 上的 Cloudera Hadoop 来创建 mapper-reducer 框架。
然后，所有数据被发送到 Jupyter Notebook 进行进一步分析，最终输出以 csv 文件形式发送到 Tableau，以便为最终用户创建仪表板。
图三。电影大亨的产品渠道
蜂巢工作流程
通过 HIVE SQL 计算作业，所有数据流都变得很容易获得。为了确保将所有新的票房电影数据纳入分析中，Movie Tycoon 中的整个工作流都是使用调度程序作业自动执行的，每个作业都在每周一上午 8:00 运行。
在试运行期间，自动计划程序大约需要 10 分钟。
图 4。配置单元工作流
可视化产品洞察
为了帮助电影投资者、编剧和制片公司，整个决策支持系统在 Tableau 上可视化，使用如下所示的实时仪表板。
图五。实时 Tableau 仪表板
最高票房收入出现在以下类型中:
- 行动
- 音乐的
- 家庭的
NLP 洞察
理解电影评论对产品的成功和稳健至关重要，它能对观众如何看待电影提出战略性和深刻的观察。内容作者将从这个尚未开发的数据源中获得巨大收益。在使用各种 NLP 技术进行详细分析后，发现以下主题会产生非常积极的情绪:
- 故事
- 表演
- 精彩的戏剧
电影院 GIF 由詹姆士·柯伦
结论
再回到《大西洋月刊》的文章…
好莱坞的许多人希望，通过结合对内容和观众的深刻理解，电影公司将能够从一开始就选择和定制他们的电影，甚至可能找到某种编剧的神奇公式。
电影大亨将让你做到这一点，甚至更多，通过可扩展性*、云安全和智能分析等功能来推动决策。它使好莱坞和观众之间的距离比以往任何时候都更近，同时利用现代数据科学和大数据工具来实现这些利益相关者之间的协同作用。***
更多的技术文档，你可以在这里查看相关的代码文件。
介绍我的书:Python 金融烹饪书
来源: Unsplash
我的短篇小说从中型文章到图书合同
在这篇文章中，我想分享我的故事，即写关于走向数据科学的文章是如何开始一场冒险的，并最终成为一本书。我还将描述我在这个过程中学到了什么，以及在这个过程中哪些工具帮助了我。开始吧！
它是如何开始的
2019 年 2 月的某个时候，一位收购编辑联系了我，问我是否有兴趣创作一本书。我已经写了几篇关于 Medium 的文章，我对这个项目的规模有点不知所措。然而，这听起来像是一个令人兴奋的想法，并且有可能扩大我小小的写作爱好。很快，我同意接受挑战。
这个提议
整个过程的第一步是求婚。出版商已经对这本书的总体主题(主题，而不是内容本身)有了想法，这将是一本什么类型的书，以及它应该面向谁。
这是一个提到书的格式的好地方。如标题所示，这是一本烹饪书，侧重于实践方法。每一章都包含一系列的方法，每一个都是分析师在金融领域工作时可能遇到的独立任务。
在写提案的时候，我可以自由选择我想在章节中包含的食谱。提案必须非常详细，对于每一个食谱，我必须包括标题，一个简短的总结，以及预期的页数。这被证明是相当棘手的，但我稍后将回到这一点。
经过几次反复，并结合了编辑的一些建设性反馈，提案准备好了，我签了合同，开始写作。
该过程
我收到了出版商的一些介绍性文件。它们包括一些关于这本书应该遵循的风格的一般信息，但也包括一些关于写作过程本身的提示。根据他们的说法，每天写 1-2 页，按时完成这本书应该不成问题。
至少对我来说，大多数时候事情看起来并不是那样。写书可以类似于拥有另一份工作，至少在时间上是这样。将两者结合起来并拥有足够的个人生活时间是一个挑战。
为了让我更轻松，我尽可能在上下班的路上做更多的工作。因为我每天要坐两次 40 分钟的火车，所以尽可能有效地利用这段时间是有意义的。之前我在那时候看书或者做文章，所以我已经习惯在这样的条件下工作了。
即使我在上下班途中一天写两次书，我也很少能写出足够的内容来填满 1-2 页的配额。大多数时候，我也在晚上工作。经常发生的情况是，在一天的工作和长途通勤之后，我实在太累了，以至于晚上做不了任何有建设性的事情。因此，相对于最初的时间表，我有一些延误。谢天谢地，编辑们在这个过程中给予了支持和鼓励。
从 2019 年 3 月到 2020 年 1 月初，我一直在写这本书。对于每一章，我都遵循类似的工作流程。首先，我为我正在写的那一章收集资料。然后，我开始陈述手头的问题，并编写解决它的代码。编码部分完成后，我会写食谱的介绍，并详细描述代码是如何工作的(一步一步)。在大多数食谱中，我还写了一个有更多的部分，其中包含了一些关于该食谱的更高级的主题，或者专注于该任务的另一种可能的方法。
大多数时候，我把食谱的内容和代码写在同一个 Jupyter 笔记本上。这似乎是最方便的，因为我会将所有内容(文本+代码)一次性转移到出版商的基于 Markdown 的文本编辑器中。然而，也有与之相关的问题。在下一节中会有更多的介绍。
另外值得一提的是，在写这本书的同时，大纲也发生了演变。我在提案中计划的一些食谱被合并在一起，一些被替换。我觉得真的很难写出一个在实际开始写的时候不会改变的提案。
我所学到的…
在这一小段中，我将描述我在写书时学到的一些要点，以及我本可以做得不同的地方。我将主要写过程本身，而不是特别写编码。
- 在写提案时给出一个现实的页数比预期的要困难得多。我严重低估了每章所需的页数。首先，我没有考虑图像的大小，因为我不清楚每一章会有多少图像。第二，我低估了代码所占的空间。考虑到代码被分解成编号的步骤，并且每个步骤都有简短的描述，这极大地影响了页面数量。
- 与出版商的编辑更频繁地核对事实。正如我之前提到的，我主要是在 Jupyter 笔记本上写章节的内容，在那里我也给出了给定任务的解决方案。当我以为我已经看完了的时候，我才把这一章移到了出版商的编辑那里。这种方法的问题是，我在 Jupyter 中没有真正的页面计数指标。因此，当我将所有内容转移到编辑器时，常常会远远超出目标。此外，当将代码移动到编辑器时，它通常不能很好地适应页面宽度，需要进一步的重构——在笔记本和编辑器之间来回切换。
- 数据科学 9 个月真的很多，因为行业在不断发展。我从几个方面体验了这一点。首先，当我完成这本书时，一些 Python 库被重命名，这需要在多个章节中修改代码。第二，一些功能(关于下载数据)被弃用，因此，我删除了 2 个完整的食谱。第三，在写后面的章节时，我偶然发现了一些我想在前面的章节中使用的新的很酷的东西，但是，通常没有时间(和页数)来将它们合并到已经写好的部分中。最后一件事产生了多篇文章的想法，我希望很快发表:)
- 代码需要多轮重构。原因包括修改格式(使其符合页面宽度)，考虑库的变化等等。此外，当我在写作过程中进行开发时，我经常回到前面的章节来重构代码，以便它符合后面的标准。需要记住的一点是，修改代码不仅发生在 Jupyter 笔记本中，也发生在存储该书的出版商的编辑器中，因此正确更新这两个源是至关重要的。
- 我必须学会的一件事是延迟满足。以中等文章为例，文章一写完，几秒钟之内就可以发表，我可以看到它的接受度。我知道，这是虚荣心作祟。但是这本书花了将近一年的时间才完成，并且需要一些决心。最后，交付了这本书的最终版本，并且正在进行印刷，这种满足感是巨大的，值得等待。此外，在写这本书的过程中，我设法找到一些空闲时间来准备一些文章。正如我之前提到的，我有很多想法。例如，我正在研究 Python 中用于回溯测试交易策略的库。虽然我在书中使用了一个库(并坚持使用它以保持一致性)，但我对另一个库做了一些研究，如果不作为一系列文章来分享，那将是一种耻辱(由 this one 开始)。
让我生活更轻松的工具
- 特雷罗——它允许我们创建看板风格的任务列表。这是一个组织项目的伟大工具，无论是个人使用还是整个团队使用。对于这本书，我创建了一个板，并把它分成几个部分，如积压，做，修订，完成，想法。这样，每当我想出一个新的想法或者想要跟踪我仍然需要重构的东西时，我可以很容易地使用 Trello 来组织任务。我也用它来组织我的博客写作:)
- GitHub——可以说是最流行的版本控制平台。你可以在这里找到这本书的 GitHub 资源库。
- 语法上的——一个确保你的写作相对“正确”的伟大工具。通过显示潜在的错误，可以节省大量时间。然而，彻底阅读也很重要，因为语法上可能会错过一些复杂的边缘情况。Grammarly 也可以作为 Chrome 扩展安装，可以很好地与多个网站(包括媒体！).
- 海明威应用 —这个网络应用非常适合分析文本并展示其复杂性。它提供了额外的帮助，指出哪些句子太长或太复杂，可以使用一些调整(例如，将它们分成两个独立的句子)。总的来说，海明威应用程序的建议使文本更容易阅读和理解。
- draw . io——一个非常方便的创建出版物质量图表的工具。它作为一个浏览器拖放工具，提供了大量的图标和图像。最重要的是，它允许保存您的项目，再次加载它们进行可能的修改，并导出为多种格式(包括 PDF)。
- Jupyter Notebook/Visual Studio Code—大部分时间，我都是用 Jupyter 笔记本(带 nb 扩展比如目录、拼写检查器等。)进行编码和编写。每当我需要准备一个单独的
.py脚本时，我就使用 VS Code，这是我的首选文本编辑器。
这本书本身
在了解了所有关于过程本身的信息之后，是时候最终呈现这本书了。如前所述，书名是 Python 金融食谱，书中包含了 50 多个实用食谱。
这本书的目标读者是对 Python 有一定了解，同时也对量化金融/机器学习/深度学习有一定了解的人。在《食谱》中，我提供了所用技术背后的理论的高级概述，并经常参考论文/书籍进行深入阅读。但是一般来说，我着重解释 Python 中的实现，而不是底层理论。
本书分为 10 章:
第 1 章，金融数据和预处理，探讨金融数据与机器学习任务中常用的其他类型数据有何不同。我展示了如何从不同来源下载数据并对其进行预处理以供进一步分析。
第 2 章，Python 中的技术分析，演示了技术分析的一些基本知识，以及如何用 Python 快速创建优雅的仪表板。读者将能够从一些最常用的度量标准(如 MACD 和 RSI)中获得一些模式的洞察力。
第三章，时间序列建模，介绍时间序列建模的基础知识(包括时间序列分解和统计平稳性)。然后，我研究了两种最广泛使用的时间序列建模方法——指数平滑法和 ARIMA 类模型。最后，我提出了一种新的方法，使用脸书先知库中的加法模型对时间序列进行建模。
第 4 章，多因素模型，展示了如何在 Python 中估计各种因素模型。我从最简单的单因素模型开始，然后解释如何估计更高级的三因素、四因素和五因素模型。
第 5 章，用 GARCH 类模型建模波动率，向读者介绍使用(G)ARCH 类模型进行波动率预测的概念，如何选择最佳拟合模型，以及如何解释结果。
第 6 章，金融中的蒙特卡罗模拟，向读者介绍了蒙特卡罗模拟的概念，以及如何使用它们来模拟股票价格、欧式/美式期权的估值和计算 VaR。
第 7 章，Python 中的资产分配，介绍了现代投资组合理论的概念，并展示了如何在 Python 中获得有效前沿。然后，我看如何确定具体的投资组合，如最小方差或最大夏普比率。我还展示了如何评估这种投资组合的表现。
第 8 章，用机器学习识别信用违约，介绍了一个用机器学习预测信用违约的案例。本章介绍了从加载数据，通过各种预处理阶段，以估计分类器的完整管道。
第 9 章，金融中的高级机器学习模型，介绍了高级分类器的选择(包括堆叠多个模型)。此外，我还研究了如何处理类不平衡，使用贝叶斯优化进行超参数调优，以及从模型中检索特性重要性。
第 10 章，金融领域的深度学习，演示了如何使用深度学习技术来处理时间序列和表格数据。使用 PyTorch 训练网络(可能有 GPU 加速)。
结论
总的来说，我很高兴承担了这本书的写作，并为完成这本书感到自豪。这需要大量的努力和决心。在这个过程中，我有过怀疑的时刻，但是来自我亲密的人的支持帮助我度过了难关。
我希望这本书能对那些想学习如何使用 Python 解决金融领域实际问题的人有所帮助。如果你有兴趣购买这本书，你可以在亚马逊或者 Packt 的网站上买到。
如果你对这本书的写作过程有任何问题，或者对这本书本身有任何反馈，我很乐意在评论中阅读。你也可以在推特上联系我。
下次见！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
