约斯特黄金法则
或者，用任何语言写出更好代码的 12 条简单规则。
你不需要了解很多关于编码的知识就能看出可读代码和不可读代码的区别。拿起你匆忙拼凑起来的任何东西，几个月后可能就无法阅读了。你投入时间和精力的代码可能几个月，甚至几年后才可读。这里有一些让你的代码更好的规则。
Ashkan Forouzani 在 Unsplash 上的照片
简史
在我大学的第一份工作中，我非常高兴为 Joost " 工作，鼠标是给用户用的“den Haan——他们在操作电脑时永远不会碰他的鼠标。他精通键盘和他选择的语言 MATLAB。
约斯特是一个有原则的人，他会三思而后行。他总是有一个计划来克服摆在他面前的挑战。他是那种工作精明但不努力的人；早在它变凉之前。早在这个概念被大肆宣传之前，他就已经在编写清晰、整洁的代码了。约斯特是一个超越时代的人。
他有一些简单的规则，任何人都可以应用于任何项目，不管是什么编程语言。一些简单的规则可以帮助你思考你在编码什么以及如何编码。当你敲击键盘上的键时，要记住一些黄金法则。
更好编码的几个简单规则
Joost 黄金法则的第一条规则是，每个程序员都可以局部忽略任何黄金法则，只要这能使工作更快、更容易或更便宜……规则是手段而不是目的。规则是用来指导你的，但永远不会让你停止思考你实际上想做什么。
每个程序员都可以局部忽略任何黄金法则。
1.为别人写代码。
正是如此，你可能会换到一个不同的工作或职位，在将来的某个时候，别人应该会更新你的代码。你不仅是在为未来的自己写代码，也是在为未来的某个人写代码。如果你在编码的时候把他们记在心里，你就帮了他们两个人一个大忙。
2.考虑代码对处理能力的影响。
代码会随着时间的推移而增长，忽略代码对处理能力的影响会在某个时候回来困扰你。趁你还在的时候考虑一下
3.从创建基础设施开始。
当开始一个新项目时，首先要为你的项目建立基础设施。从高层次上考虑代码的结构。建立数据库连接、集成，并为您的功能编写框架。这应该包括测试程序，然后才开始编程的内容。
4。总是复制代码。
如果你写代码总是复制你创建的名字。这可以防止你打错字，创造 100%的一致性。
5。千万不要复制代码。
永远不要复制代码片段(没有检查)，这很容易出错，并且会产生不必要的难以维护的重复代码。所以当你复制的时候，可能有一个更聪明的方法。参见第六条规则。
6.零一无限。
0 — 1 — ∞表示脚本的重复。(顺便说一下，无穷符号叫做双纽线。)你要么使用一个操作零次，要么使用一次。如果你不得不多次重复做同样的事情，你必须想办法把它扩展到无穷大(例如通过创建一个函数)。
潜在的想法是，如果你必须改变代码，你不必同时在两个地方做同样的操作，因为你很有可能会错过一个。
7.创建可重用的功能。
创建可重用的功能。可以从不同来源调用的代码。这并不是因为这利用了您自己的工作，而是更重要的是，它确保了这些功能是简单的、不可变的，并且事后易于管理。让它们尽可能小。
8.不写评论。
当然，你可以写评论，但是作为一条规则，你应该写尽可能少的评论。代码和脚本需要不言自明。只允许简单的监督意见。
9.避免不必要的缩写。
编写有意义的变量名没有额外的成本。在给变量命名时使用描述性的名字，这样更容易理解代码。(所以可以用时间的时候就不要用 t 。)
10.不必要时不要硬编码
命名变量时，将所有硬编码的变量全部大写，这样你就有一种直观的方式来记住这是一个硬编码的变量。对于所有其他变量，选择是使用 camelCase 还是下划线 _case。
11。在可能的地方显式，在需要的地方隐式
显式关联输入参数。即使下面是相等的:
- 在< 2
- number_of_arguments_in ≤ 1
The former holds a direct relationship to the number of inputs (i.e., 2), whereas the latter does not. This gives a direct link to between the elements in your program.
Photo by 克里斯多佛·伯恩斯在 Unsplash 上
12.内部名称与外部标签
将函数的内部名称和外部标签分开。这使得为客户更改 UI / API 接口变得容易，而不必更改函数的内部工作方式。这也使得调试更加容易。
就是这样…
如果你把这些简单的规则记在心里(或放在身边)，从长远来看，你会让你自己的生活和你周围的人的生活变得更容易，还可能节省一些钱和时间。
不言而喻，Joost 确实应该为这些规则受到称赞。可能是他应该写这个或者类似“干净代码”的东西
云计算之旅:如何成为 AWS 认证解决方案架构师
【来源:Pexelbay】
作为一名 IT 解决方案架构师，我一直有兴趣将自己的知识从应用扩展到基础设施，因此我决定准备参加亚马逊 Web 服务认证解决方案架构师助理考试，这是 IT 行业最重要、最受广泛认可的 T2 证书之一。我想分享我成功准备考试的方法，从而在这个过程中帮助其他人。
为什么选择 AWS 解决方案架构？
审视过去 10 年的企业 IT 行业趋势，有一些高增长的领域继续扩张并奖励工程人才:云基础设施、数据分析和安全。尽管一个人可以通过认证进入数据分析和安全领域，但除非他拥有多年的经验，特别是在数据科学方面，至少拥有两年的 STEM 硕士学位，最好是应用数学、计算机科学或统计学专业，否则财务和专业回报并不显著。由于顶级平台供应商的优秀公开文档和我将在下面分享的全套教育资源，云基础架构有一个更平坦的倾斜和更低成本的学习曲线。
AWS 客户的广度[来源:AWS]
此外，考虑一下云计算不可避免的进步，因为基于传统硬件和软件的传统数据中心由于其资本支出基础、灵活性和技术停滞而衰落。正如 Gartner 的 2019 年报告所建议的，各种规模的组织都在将工作负载迁移到云。数据中心支出从 2017 年的 6%增长放缓至 2019 年的不到 2%；服务器采购在 2019 年下降了 1%，预计在未来五年内每年将进一步下降 3%。与此同时，包括云计算在内的 IT 服务支出的增长速度是 2017 年的两倍，从 2017 年的 4%上升到 2019 年的近 5%。
云平台支出趋势[来源:Statista]
此外，人们必须评估云计算供应商，以了解在哪里进行专业下注。截至 2020 年 2 月，亚马逊网络服务(AWS)、微软 Azure 和谷歌云平台是这一领域无可争议的领导者。AWS 于 2006 年推出，已经领先其竞争对手，例如 AWS 在 2019 年拥有 33%的市场份额，并且每年增长超过 35%。相比之下，2010 年诞生的 Azure 现在已经达到 18%的市场份额，而 2013 年开始的 GCP 已经达到 8%的市场份额。此外，今年有报道称，泄露的谷歌备忘录暗示，如果 Alphabet 不能在市场上排名第一或第二，它可能会在 2024 年之前退出云平台领域。
最后，解决方案架构代表了 IT 劳动力市场中最适合适应 IT 行业不断变化的领域。魔鬼总是在细节中，但是架构是与业务一致的概念和逻辑活动，云计算使人们能够更好地推理和组装计算、存储、数据和网络乐高积木，以设计更好的分布式系统来解决业务问题。将所有这些放在一起，专注于顶级云平台(如 AWS)的解决方案架构不仅会产生良好的业务和常识，而且会令人愉快，因为您正在对组织产生战略影响，并与各种利益相关者进行互动。因此，云解决方案架构师的工资与上述其他领域不相上下，并且工作岗位比上述其他领域更加丰富也就不足为奇了。
在工作中使用 AWS，在家里做实验。
没有什么能代替你在工作中接触现实世界的项目，你会在某些领域获得深度；然而，许多 AWS 服务用户指南都有 10 分钟的教程和半真实的样本，可以拓宽你的知识面，扩大你的舒适区。这一步骤将持续进行，可能需要一年时间，这大约是您可以参加 AWS 考试之前的最低经验量，也是 AWS 服务免费层可以为个人或公司帐户持续的时间长度。
遵循 AWS 证书培训课程。
阅读 RDS 、 EC2 、 Route 53 、 SQS 、 VPC 的常见问题。阅读关于 AWS 架构良好的框架及其支柱的白皮书；然后，确保您能够设计出平衡并满足其成本、性能、可靠性、操作和安全性限制的技术解决方案。记下手写笔记并绘制图表，以加强您对材料的理解，并构建一个关于 AWS 组件如何组合在一起的强大心理模型。采取免费的 AWS 数字培训视频系列。这个步骤需要一(1)个月。
- https://aws.amazon.com/certification/certification-prep/
- https://aws.amazon.com/architecture/well-architected/
- https://www.aws.training/Details/Curriculum?id=20685
参加 Ryan Kroonenburg 的 Udemy 课程。
50 万人在 Udemy 上了 Ryan Kroonenburg 的解决方案架构师助理课程。我强烈推荐这门课程，因为 Ryan 是一个优秀的沟通者，云专家的材料是最新的和全面的，模拟 AWS 考试的两个模拟测试非常值得课程本身的价格，根据正在进行的 Udemy 折扣和促销活动，价格从 11.99 美元到 149.99 美元不等。这个步骤需要一(1)个月。
阅读教程道场和数云培训发布的婴儿床笔记
Tutorials Dojo 和 Digital Cloud Training 发布的婴儿床笔记和备忘单非常出色，结合了非凡的广度和深度。它们涵盖了考试中出现的所有主要 AWS 服务，并简化了考试准备期间的复习过程。从这些笔记中获取额外的手写笔记，以补充早期的 AWS 材料，并进一步巩固您的记忆。这一步需要两(2)周时间。
- https://tutorialsdojo . com/AWS-certified-solutions-architect-associate/
- https://digital cloud . training/certification-training/AWS-solutions-architect-associate/
参加 AWS 和 Udemy 模拟考试
我建议在参加真正的考试之前，至少参加 3 次全程模拟考试。Ryan 的 Udemy 课程有两次这样的考试。你也可以花大约 20 美元从 AWS 购买一个官方的实践考试。不过最好的一套练习考试是乔恩·邦森在 Udemy 上主持的 6 套练习考试，价格为 12.99-39.99 美元。Ryan 和 Jon 的考试都包含对正确和错误答案的详细解释，他们的考试报告有助于确定你的优势和劣势。这一步需要两(2)周时间。一旦你经常获得 75%以上的分数，你也应该报名参加考试。
- https://www . udemy . com/course/AWS-certified-solutions-architect-associate-Amazon-practice-exams
- https://www.aws.training/certification?src=exam-prep
期末考试复习
在正式考试前的最后一周，我建议再参加一次练习考试，多复习一遍笔记，得到锻炼和休息，和家人朋友一起放松，这样你在参加考试的时候就充满了信心。
[来源:Supushpitha Atapattu @ Pexelbay]
人生没有成功的捷径。如果你能投资至少三(3)个月和大约 80 美元参加两门 Udemy 课程和 AWS 实践考试，请放心，你会像我一样通过 AWS 解决方案架构师助理考试。我希望这篇文章能帮助 IT 社区的其他人达到他们的职业目标。祝你好运，让我知道你的想法！
理解厚尾分布
迈向稳定的分销之旅#1
多胖才算胖？
嗨，我是卢先生
T 何系列《钢化稳定分布之旅》旨在帮助人们了解厚尾分布中的一种:钢化稳定分布。因此，本文档的目的是介绍和解释一些概念和工具，这些概念和工具是理解利用调和稳定分布来达到他们自己的目的所必需的。我不会深入每一种厚尾分布的本质，而是试图用一种直观的方式解释相关的统计和数学概念/问题，并在金融中有所应用。我希望有一个有用的外卖给所有不同背景的读者。欢迎通过本文档末尾的电子邮件提出任何问题。
在第 1 部分中，我们讨论随机变量具有**“厚尾”**分布意味着什么。
远吗？胖？
为了理解厚尾现象，我们需要回答以下两个问题。
1.多远才算远？
2。多胖才算胖？
要谈尾巴，我们需要确定多远才算远，才能决定离中间多远才算远，才能说它是‘尾巴’。换句话说，尾巴从哪里开始？看情况！不幸的是，没有单一的答案。
考虑正态分布。注意有两条尾巴:右边和左边。例如，如果我们想用一个标准差来描述分布的“右”尾，那么阴影部分指的是正态分布的右尾。
图。一
形式上，我们可以这样描述尾巴:
- 右尾:P(X>x)
- 左尾:P(X≤-x)
对于一个大的值‘x’。现在，我们知道了“尾巴”的概念。
**[R codes for Tail]**
#For normal distribution with value 'x=a'
a=1
1-pnorm(a) #right tail
pnorm(-a) #left tail
每个分布都有尾巴吗？
想想[0，1]上的均匀分布。它有尾巴吗？在这个博客中，它说不是每个发行版都有尾巴。
如果你想要“尾部的行为”来描述当“x”变大时 pdf 的特征，那么有界分布没有尾部。然而，尾部的一些特征是可以量化的。特别是，通过使用极限和渐近行为，你可以定义重尾的概念。 SAS 博客
我将在下面解释(指数)有界/无界分布。到了那里请提醒自己制服发放！
我们为什么要关心分配的“尾部”部分？
分布的尾部一直是风险管理的主要关注点。例如，收益或损失分布的两个最常用的风险度量是 【风险值】 和 【预期亏空】
为什么损失不还？
- 损失实际上是负(-)回报
- 将极限取负无穷大是不直观的。所以我们取返回值的负值，也就是说，将分布翻转到 y 轴上。
看看 VaR 和 ES 这两个量和‘尾巴’有什么关系就知道了。不需要理解它们背后的数学或含义。
图。2 //资料来源:Ch2，量化风险管理(以下简称 QRM ),作者麦克尼尔等人
考虑损失的分布， L ，相当于**(负)回报**，在给定的持有期内。为了便于理解，我们假设明天损失的随机变量遵循正态分布:
然后，我们可以通过以下方式计算 VaR:
来源:埃里克·齐沃特的课堂笔记
**通过第二条线，我们可以很容易的检查出 VaR 只是一个与胖尾相关的量。**关于风险值的更多细节，请查看《量化风险管理:概念、技术和工具》一书的第二章，以及 Eric Zivot 在他网站上的讲座笔记。
**[R codes for VaR]**alpha = 0.95 #significant level
VaR.alpha = qnorm(alpha, mu, sigma)
VaR.alpha = mu + sigma*qnorm(alpha, 0, 1)
同样，我们可以看到预期短缺是一个与分布尾部相关的量:
来源:埃里克·齐沃特的课堂笔记
在第四行中，它表示“ES 是损失分布的上“尾“中的预期损失”。类似于 VaR，在正态分布的情况下，现在计算 ES 很方便，因为它只是一个截尾正态分布的均值。
来源:埃里克·齐沃特的课堂笔记
**[R codes for ES]**
alpha = 0.95
q.alpha.z = qnorm(alpha)
ES.alpha = mu + sigma*(dnorm(q.alpha.z)/(1-alpha))
如果有人好奇我们为什么除以 1 — *α，*这只是一个**归一化常数(或比例因子)**以确保截断损失分布的积分为 1，这是概率分布的一个要求。
回到“尾部”的故事，我只想强调尾部分布被广泛用作风险管理工具。
多胖才算胖？多重才算重？
既然我们弄清楚了分布中的‘尾巴’是什么，用在什么地方，现在就该说说‘肥’的部分了。我们都知道正态分布没有厚尾。相反，我们被教导在对金融回报序列建模时使用 student-t 分布和对数正态分布来考虑“厚尾”特性。但是我们需要知道肥尾的定义。不幸的是，脂肪这个词没有统一的定义。
我将试着解释英语、图形和数学的语言中的胖尾巴。希望你至少喜欢这三个中的一个。
在英语中，
- 重尾分布具有比指数分布更重的尾部(Bryson，1974)
- 当尾部比指数分布衰减得更慢时，称分布具有重尾。
为什么是指数？
使用指数分布作为参考是很方便的。指数分布的 pdf 以“指数”方式快速接近零。也就是说，pdf 的尾部**看起来像(但表现不同于)**指数分布。
用图表的语言来说，
我将向您展示 4 个不同的图表，显示在一组不同分布的最右侧尾部发生的情况，如下所示:
- 指数分布
- 幂律分布
- 正态分布
- 对数正态分布
- 学生 t 分布
- 柯西分布
- 征税分布
- 威布尔分布
我不会解释每一个发行版。相反，让我们欣赏一下这些分布图，感受一下尾部的情况。第一个图形显示了整个图形中“x”位于[0，5]中的部分
图。5，文档末尾提供了该图的 R 代码
根据上面的图 5，我们无法判断尾巴的行为。但是，这里有一些事情值得一提
- 正态分布、student-t 分布和柯西分布都是双尾分布。所有其他的都是单尾分布
- 对于 PL(2.5)和 PL(3.5)，在 x=1.7 附近有一个交叉点，说明 PL(2.5)的尾部较粗。
让我们看看当 x 位于[5，8]时是什么样子。请注意，y 轴上的值会变得更小。
图。6
问:你在这个图表中看到了什么？
答:最上面的线会有最粗的尾巴！(但也不尽然！！！)你就知道为什么了！
在此之前，让我们检查一下上面图 6 中的重要事实。
- 当 x=5 时，正态和 exp(2)分布在 0 附近爬行。尤其对于正态分布，其 5 标准差的 pdf 值为 0.000001486 (=pnorm(5))。这大约是柯西分布的 8000 倍。换句话说，在柯西分布下，5 sigma 事件发生的可能性是正态分布的 8000 倍。
- 在图 6 中，请记住 exp(0.2)分布位于对数正态分布和幂律分布之上。请检查在扩展“x”值的范围后，它是如何在下图中反转的。
让我们看看当 x 位于[8，100]时是什么样子。同样，请注意 y 轴上的值会变得小得多。
图。七
- 请注意，蓝线 exp(0.2)在穿过另外两条线 PL(2.5)和 Cauchy 时衰减很快。这就是“衰减慢于指数分布”的含义
- 看到“x”等于 100 附近发生的情况令人惊讶。其 PL(1.5)的 pdf 值为 0.0005。难怪对于 PL(1.5)，一阶矩和二阶矩(均值和方差)都是无穷大。这方面的详细信息将在下一篇文档中介绍。敬请期待！
让我们放大 y 轴来详细看看它是如何表现的！
图。8
- 令人惊讶的是，蓝线 exp(0.2)通过穿过 PL(3.5)和 LN(0，1)而减小。此外，我们可以看到 LN(0，1)比 PL(3.5)衰减得更快，因为它穿过 PL(3.5)并在它下面。
- PL(1.5)、PL(2.5)和 Levy 分布甚至没有显示在该图中。
在数学语言中，
‘重’vs‘胖’
厚尾分布是重尾分布的一个子类。这意味着尽管每一个厚尾分布都是重尾分布，但反过来就不成立(例如，威布尔分布)。根据杰伊·泰勒的讲义，他用以下方式区分了胖子和胖子。
重尾的定义
- 如果尾部是“非”指数有界的，则称分布有一个右重尾
等式 1
我们可以解读为，当‘x’变大时，指数增长的速度快于重右尾上概率下降的速度。花点时间想想吧！
看看它是如何与英语定义联系起来的。
- 比指数衰减慢的概率分布函数被称为右重尾。
当指数有界时。
如果重的右尾不够重，即，当“x”趋向无穷大时，它衰减得非常快，那么等式 1 收敛到零。一个明显的例子是我们上面讨论的[0，1]上的均匀分布。一旦‘X’超过 1，X 大于 1 的概率变为零，因此它是指数有界的。另一个流行的例子是正态分布。设 X 为标准常态。画出一系列不同λ值的图表
图。3
我们可以看到它收敛到零，所以正态分布的尾部是指数有界的。
**[R codes for Figure. 3]** f_exp = function(x, lambda){return (exp(lambda*x))
cdf_normal = function(x) pnorm(x)
ccdf_normal = function(x) {1-cdf_normal(x)}xs = seq(1,10,length=10000)
plot(xs, f_exp(xs,0.1)*ccdf_normal(xs), type='l', xlab='',ylab='', col='blue', lwd=2)
abline(v=1, lty = 'dashed')
lines(xs,f_exp(xs,0.5)*ccdf_normal(xs), col='purple', lwd=2)
lines(xs,f_exp(xs,1)*ccdf_normal(xs), col='red', lwd=2)
lines(xs,f_exp(xs,1.5)*ccdf_normal(xs), col='orange', lwd=2)
lines(xs,f_exp(xs,2)*ccdf_normal(xs), col='darkred', lwd=2)
lines(xs,f_exp(xs,3)*ccdf_normal(xs), col='darkblue', lwd=2)
grid()
legend(8, 0.15,
legend=c("0.1", "0.5","1","1.5","2","3"), title = "lambda",
col=c("blue",'purple', "red",'orange','darkred','darkblue'), lwd=2, cex=1)
胖尾的定义
- 如果有一个称为尾部指数的正指数(α),则称分布有一个右厚尾(T1)
“~”的意思是不变的。或者说尾部与幂律成正比。准确地说，它的意思如下。
如果数学对你来说很难，你可以跳过。
因此，厚尾分布的尾部遵循幂律(x 的负α次方)。对于那些不熟悉幂律的人来说，现在不用担心。想想当α等于 2 时的图形。
图。四
提醒自己，尾部看起来类似于我们在上面的图 5-8 中看到的幂律。我将在本系列的[第 2 部分]中更详细地解释幂定律。
摘要
我们在本文中直观地、图形化地和数学地讨论了“厚尾”这个概念。要理解“缓和的稳定分布”，就必须对厚尾有一个基本的了解。希望这份文件有助于提高你的理解。如果你有任何问题，请在下面评论。我希望你对接下来会发生什么感到好奇。下一次，我会带着[回到炼成稳定分布的旅程【部分。2:无限可分分布]](https://medium.com/@corr.roh/infinitely-divisible-distribution-586b18c63670) "
**[R Codes of Figure. 5]**
f_exp = function(x, lambda, xmin) {lambda*exp(-lambda*(x-xmin))}
f_power = function (x, k, x_min) {
C = (k-1)*x_min^(k-1)
return (C*x^(-k))
}
f_cauchy = function(x) dcauchy(x)
f_levy = function(x) dlevy(x) # required package: 'rmulti'
f_weibul = function(x) dweibull(x,shape=1)
f_norm = function(x) dnorm(x)
f_lnorm = function(x) dlnorm(x)
f_t = function(x) dt(x,5)
xs = seq(0.1,100,length=1000)plot(xs, f_exp(xs,0.5,0.1),type='l',xlab='',ylab='', col='blue', lwd=2,
main='Distributions on [0,5]', cex.main=1,
xlim=c(0,5),
ylim=c(0,2.5))
lines(xs,f_exp(xs,1,0.1), col='purple', lwd=2)
lines(xs,f_exp(xs,2,0.1), col='bisque3', lwd=2)
lines(xs,f_power(xs,1.5, 1), col='red', lwd=2)
lines(xs,f_power(xs,2.5, 1), col='orange', lwd=2)
lines(xs,f_power(xs,3.5, 1), col='darkred', lwd=2)
lines(xs,f_norm(xs),col='black', lwd=2)
lines(xs,f_lnorm(xs), col='darkgreen', lwd=2)
lines(xs,f_t(xs), col='deeppink', lwd=2)
lines(xs, f_cauchy(xs), col='darkblue', lwd=2)
lines(xs, f_levy(xs), col='azure4', lwd=2)
lines(xs, f_weibul(xs), col='springgreen', lwd=2)
abline(v=2, lty = 'dashed')
abline(v=3, lty = 'dashed')
grid()
legend(3.5, 2.5,
legend=c("exp(0.2)", "exp(1)", 'exp(2)', "PL(1.5)", 'PL(2.5)', 'PL(3.5)', 'N(0,1)','LN(0,1)','student-t(5)','Cauchy','Levy','Weibull'),
col=c("blue",'purple', 'bisque3',"red",'orange','darkred', 'black','darkgreen','deeppink','darkblue', 'azure4','springgreen'), lwd=2, cex=0.8)
参考资料:
[1]杰伊·泰勒，重尾分布(2013)，讲义，
[2] Eric Zivot，风险度量(2013)，课堂讲稿
[3] Aaron Clauset，复杂系统的推理、模型和模拟(2011)，讲义
[4]https://blogs . SAS . com/content/IML/2014/10/13/fat-tailed-and-long-tailed-distributions . html
我还为上面所有的参考文献添加了超链接。请查阅参考资料了解详细信息。如果有我错过的任何事情，我将稍后更新参考。
感谢您阅读本文档。如果你觉得这份文件有用，别忘了与你的朋友分享。
使用 Python 的 JSON 和 API
使用 Python 的 JSON 和 API 介绍
肖恩·林在 Unsplash 上的照片
介绍
在另一个教程中，我们讨论了如何用 python 进行网页抓取。网络抓取的目标是从网站或网页获取数据。嗯，有时候一个网站可以让用户通过 API(应用编程接口)更容易地直接访问他们的数据。这基本上意味着该公司制作了一组专用的 URL，以纯形式提供这些数据(意味着没有任何表示格式)。这种纯数据通常是 JSON (JavaScript 对象表示法)格式，我们可以使用 python 解析并提取我们需要的内容。
对于本教程，我们将使用在 covid19api.com 发现的免费 API，提供冠状病毒的数据。我们将找到每个国家确诊病例的总数，然后我们将创建一个包含这些信息的熊猫数据框架。所以让我们开始吧！
如何在 python 中使用漂亮的 soup 和请求库进行网页抓取
pub.towardsai.net](https://pub.towardsai.net/web-scraping-with-python-6d01f5e9378f)
检查 API
如果你进入 API 的文档页面，你会看到:
这向我们展示了 API 中的不同 URL、它们提供的信息以及右边这些 URL 的请求/响应示例。
我们可以看到，我们正在寻找的信息在摘要页面。我们可以单击右侧的“查看更多”,这样我们就可以看到来自该 URL 的响应:
这是一个 JSON 对象！如您所见，它非常类似于 python 字典，由键值对组成。事实上，为了让我们解析它并从中提取我们想要的东西，我们最终会将它转换成 python dictionary 对象。经过检查，我们可以看到它看起来像一个嵌套的字典。外部字典具有关键字“Global”(具有字典的值)和“Countries”(具有由字典组成的列表的值，每个字典对应一个特定的国家)。
Python 中制表和熊猫数据帧函数的性能比较
towardsdatascience.com](/two-ways-to-create-tables-in-python-2e184c9f9876)
从 API 发出 HTTP 请求
因此，让我们打开一个 jupyter 笔记本，从那个 URL 请求信息。我们将使用请求库从那个 U RL 发出一个 HTTP 请求，并将响应对象的文本保存在变量 response 下:
response = requests.get(‘https://api.covid19api.com/summary’).text
这显示了 API 对我们的 HTTP 请求的响应。如您所见，这是一个 JSON 格式的长 python 字符串。
如何将字符串方法应用于 pandas 数据框架中的列
towardsdatascience.com](/using-string-methods-in-pandas-5e4509ff1f5f)
创建 Python 字典
由于响应是 JSON 格式的，我们可以将这个字符串加载到 python 中，并将其转换成 python 字典。我们首先需要导入 json 库，然后我们可以使用 json 库中的 loads 方法，并向它传递我们的字符串:
response_info = json.loads(response)
注意我们的 response_info 变量的类型现在是一个 python 字典！
既然我们的响应是 python 字典的形式，我们可以使用我们所知道的 python 字典来解析它并提取我们需要的信息！
**还要注意:**requests 库有一个内置的 json 解码器，我们可以用它来代替 JSON 模块，后者会将我们的 JSON 对象转换成 python 字典。但是，我在本教程中使用了上述方法来介绍 json 模块。如果我们在请求模块中使用 JSON 解码器，代码看起来会是这样的:
requests.get(‘https://api.covid19api.com/summary’).json()
解析字典
如前所述，我们希望创建一个包含两列的熊猫数据框架:国家和该国确诊病例总数。我们可以通过循环外部字典的“Countries”键的值来实现这一点:
如您所见，我们的“Countries”键的值只是一个字典列表，每个字典都包含对应于特定国家的键-值对。因此，我们需要遍历这个字典列表，从每个字典中提取“Country”和“TotalConfirmed”关键字的值，然后将它们追加到一个新列表中，如下所示:
country_list = []for country_info in response_info[‘Countries’]:
country_list.append([country_info[‘Country’], country_info[‘TotalConfirmed’]])
这将遍历字典列表，从每个字典中提取“Country”和“TotalConfirmed”键的值到一个列表中，然后将这个结果列表添加到我们的 country_list 中。我们将以一个列表列表结束，外部列表中的每个列表或元素都包含国家名称和该特定国家的确诊病例总数。
了解如何使用 pandas Python 库中的 loc 方法
towardsdatascience.com](/how-to-use-loc-in-pandas-49ed348a4117)
创建熊猫数据框架
我们现在将使用这个 country_list 和 pandas 数据帧构造函数创建一个 pandas 数据帧:
country_df = pd.DataFrame(data=country_list, columns=[‘Country’, ‘Total_Confirmed’])
成功！我们现在有一个包含两列的数据框架:Country 和 Total_Confirmed！
如果你喜欢阅读这样的故事，并想支持我成为一名作家，考虑注册成为一名媒体会员。每月 5 美元，你可以无限制地阅读媒体上的故事。如果你用我的 链接 注册，我会赚一小笔佣金。
阅读卢艾·马塔尔卡的每一个故事(以及媒体上成千上万的其他作家)。您的会员费直接支持…
lmatalka90.medium.com](https://lmatalka90.medium.com/membership)
结论
在本教程中，我们简要介绍了什么是 API 和 JSON。然后，我们向一个冠状病毒 COVID19 API 发出 HTTP 请求，以获取每个国家确诊的冠状病毒病例总数的信息。然后，我们将这个对我们请求的 JSON 响应转换成一个 python 字典。然后我们解析这个字典，提取我们要寻找的信息，然后创建一个包含这些信息的熊猫数据帧。
JSON 为 Python 用户解释:数据科学版
使用 JSON 数据是不可避免的——让我们正确地学习它。
JSON 数据无处不在。它仍然不是数据科学家最广泛使用的数据格式，因为数据集存储在 CSV 或数据库中。今天，您将学习如何处理 JSON，以及如何在您的数据科学项目中使用它。
安德斯·吉尔登在 Unsplash 上的照片
但是 JSON 是什么？
好问题。JSON 代表“JavaScript 对象表示法”，是一种简单且众所周知的数据格式。一旦你习惯了括号，人类很容易读写。此外，每一种主要的编程语言本身都支持它。
JSON 类型建立在两种数据结构之上:
- 对象—键/值对的集合
- 数组-值列表
并且使用起来非常简单。
这是一篇没有废话的文章，目标是尽快让你的手脏起来。我们一会儿将连接到一个实际的 API，然后讨论基础知识。稍后您将看到我最喜欢的 JSON 功能，从数据科学的角度来看。
我们开始吧。
API 连接
如果您还没有启动笔记本电脑环境，请启动它。我们现在将只使用请求库:
import requests
让我们先来探索一下 API。它可以在此链接上找到，包含一些用户的虚拟数据。完美满足我们的需求。
让我们把它装进去，好吗？这个过程很简单，就像 Python 中的大多数东西一样:
req = requests.get(‘[https://jsonplaceholder.typicode.com/users'](https://jsonplaceholder.typicode.com/users'))
req**>>> <Response [200]>**
这个 200 状态代码意味着请求已经成功，我们已经准备好处理数据了。让我们将 JSON 数据存储到一个单独的变量中:
users = req.json()
users[0]
你看到这有多简单了吗？
现在让我们来看看用户变量。我已经指出 JSON 是建立在两种结构上的——对象和数组——让我们看看这种说法是否成立:
type(users)**>>> list**type(users[0])**>>> dict**
它成立——因为列表和数组是同义词(ish ),而字典可以被解释为对象。接下来将讨论保存和加载 JSON 数据。
保存和加载数据
我们可以使用纯 Python 功能来保存和读取 JSON 数据。以下是如何实现节约的方法:
import jsonwith open(‘json_write_test.json’, ‘w’) as f:
json.dump(users, f, indent=4)
indent 参数是可选的，它表示单个选项卡应该有多大。非常类似于 Python 的 4 空格缩进语法。我们可以验证文件是否确实被保存了:
读取过程非常相似——我们只需要从写模式切换到读模式，并使用 load() 函数，而不是 dump() :
with open(‘json_write_test.json’) as f:
data = json.load(f)
我们可以再次验证该过程是成功的:
这几乎涵盖了阅读和写作。
使用 JSON
这将是一个简短的部分。*为什么？*因为使用 JSON 就像使用 Python 字典一样。我来详细说明一下。
默认情况下，JSON 数据不是 Python 字典的数组。但是当加载到 Python 中时，就变成了一次。因此，我们可以将 JSON 数据视为字典列表。
**这里有一个例子:**我们想打印每个用户的姓名和完整地址，不包括邮政编码。这很简单:
for row in users:
print(f”Address of {row[‘name’]} is {row[‘address’][‘street’]} {row[‘address’][‘suite’]}, {row[‘address’][‘city’]}”)
这篇文章看起来有点乱，但是只要把代码复制到你的笔记本上就可以了。你马上就会明白它的要点。这是你应该知道的。下一节将介绍我最喜欢的处理 JSON 的方式——数据科学方式。
JSON 扁平化
用像熊猫这样的库读取 JSON 数据有时会有问题。如果没有嵌套(对象中的对象)，那么一切都会好的。大多数真实世界的数据是嵌套的，我们需要以某种方式解决这个问题。
下面是将我们的 JSON 数据加载到一个 Pandas 数据帧时会发生的情况:
pd_data = pd.DataFrame(data)
pd_data.head()
在地址列之前看起来还不错，在那里地址本身被分成街道、套房、城市和邮政编码。同样适用于公司栏。
但是我们如何解决这个问题呢？
前段时间我使用定制库进行 JSON 扁平化，但是有几次它们并没有像宣传的那样工作。这就是我想出这个函数的原因，得到了堆栈溢出的一点帮助:
def flatten_json(json):
output = {}
def flatten(inpt, name=’’):
if type(inpt) is dict:
for elem in inpt:
flatten(inpt[elem], name + elem + ‘_’)
elif type(inpt) is list:
i = 0
for elem in inpt:
flatten(elem, name + str(i) + ‘_’)
i += 1
else:
output[name[:-1]] = inpt
flatten(json)
return output
该函数几乎是不言自明的，必须应用于数据的每一行。如果您有一个 100 个 JSON 对象的数组，您不能只将函数应用于数组本身，而是要应用于数组的每个元素。方法如下:
flattened = [flatten_json(row) for row in data]
以下是现在数据的不同之处:
原始和展平数据的第一条记录
注意展平的数据中没有缩进，以及所有以前嵌套的元素现在都有前缀。
转换到 Pandas 数据帧的过程现在按预期工作:
今天到此为止。让我们在下一部分总结一下。
在你离开之前
我使用过的大多数 API 都以 JSON 或 XML 的形式返回数据——这由您来选择。JSON 要简单得多，至少在 Python 中是这样。
您还可以将 JSON 存储在数据库中:
- SQL 数据库的 LOB 格式
- NoSQL 数据库的“原始”格式
但那是以后的事了。感谢您的阅读，希望对您有用。
喜欢这篇文章吗？成为 中等会员 继续无限制学习。如果你使用下面的链接，我会收到你的一部分会员费，不需要你额外付费。
[## 通过我的推荐链接加入 Medium-Dario rade ci
作为一个媒体会员，你的会员费的一部分会给你阅读的作家，你可以完全接触到每一个故事…
medium.com](https://medium.com/@radecicdario/membership)
Python 中的 JSON 对象
Python 中 JSON 对象的介绍
Java Script Object Notation (JSON)是一种轻量级数据格式，与 python 字典有许多相似之处。JSON 对象非常有用，因为浏览器可以快速解析它们，这对于在客户机和服务器之间传输数据非常理想。在本帖中，我们将讨论如何使用 python 的 JSON 库来发送和接收 JSON 数据。
我们开始吧！
首先，让我们来看看下面这个 JSON 包，里面有关于甲壳虫乐队的专辑黄色潜水艇的信息:
{
"album_title" : "Yellow Submarine",
"release_year" : 1966,
"won_grammy" : false,
"band" : "The Beatles",
"album_sale": null
"musicians" : ["John Lennon", "Paul McCartney", "George Harrison", "Ringo Starr"],
"studio" : {"studio_name": "Abbey Road Studios", "location": "London, England"}
}
在 JSON 对象中，键是字符串，值可以是字符串、数字(浮点数或整数)、布尔值、列表、null 或其他 JSON 对象。从这个例子中可以看出 python 字典和 JSON 对象之间有一些差异。例如，布尔值为小写，而“无”值为“空”。python 字典的等价形式是:
{
"album_title" : "Yellow Submarine",
"release_year" : 1966,
"won_grammy" : False,
"band" : "The Beatles",
"album_sale": None
"musicians" : ["John Lennon", "Paul McCartney", "George Harrison", "Ringo Starr"],
"studio" : {"studio_name": "Abbey Road Studios", "location": "London, England"}
}
现在，让我们将示例 JSON 数据保存到一个名为“album.txt”的文本文件中。我是使用终端命令行和“vim”文本编辑器来完成的，但是您也可以使用任何您喜欢的工具。接下来，在 python 脚本中，让我们导入 JSON 模块:
import json
让我们使用“dir()”方法来看看本模块中可用的方法:
print(dir(json))
我们将重点关注加载和转储方法。要继续，让我们使用 open 方法打开文件。在 open 方法中，让我们指定文件名“album.txt”和模式(读或写)。我们将读取文件，因此模式为“r”:
album_json_file = open("album.txt", "r")
接下来，我们可以使用 load 方法从我们的文件中加载 JSON 数据:
album = json.load(album_json_file)
加载 JSON 数据后，我们关闭文件:
album_json_file.close()
我们现在可以打印加载的 JSON 数据了:
print(album)
如果我们打印这个对象的类型，我们会看到它是一个 python 字典:
print(type(album))
让我们看看 JSON 对象和 python 字典之间的区别。JSON 对象中的’ won_grammy ‘值是’ false ‘，而在字典中是大写的’ False '。此外,“album_sale”值 Null 在 python 字典中被解析为“None”。
既然我们已经将数据加载为一个字典，我们可以通过键访问解析后的字典中的值。例如，如果我们想要访问“相册标题”,我们执行以下操作:
print("Album Title: ", album['album_title'])
或者如果我们想查看专辑发行的年份:
print("Release Year: ", album['release_year'])
在客户机/服务器应用程序中，JSON 对象通常以字符串的形式出现。例如，我们用于相册信息的 JSON 对象可以是这样的:
album_string = """{"album_title" : "Yellow Submarine",
"release_year" : 1966,
"won_grammy" : false,
"band" : "The Beatles",
"album_sale": null,
"musicians" : ["John Lennon", "Paul McCartney", "George Harrison", "Ringo Starr"],
"studio" : {"studio_name": "Abbey Road Studios", "location": "London, England"}
}"""
为了使用 JSON 模块加载这些数据，我们使用’ loads()'方法:
album_s = json.loads(album_string)
album_string.close()
print(album_s)
现在，假设我们从字典格式的数据开始，并希望将这些数据以 JSON 格式发送到数据库。我们可以使用 dumps 方法将字典转换成字符串 JSON 对象。让我们定义我们的原始字典:
album2 = {'album_title': 'Yellow Submarine', 'release_year': 1966, 'won_grammy': False,
'band': 'The Beatles', 'album_sale': None, 'musicians': ['John Lennon', 'Paul McCartney', 'George Harrison', 'Ringo Starr'],
'studio': {'studio_name': 'Abbey Road Studios', 'location': 'London, England'}}
接下来，让我们使用 dumps 方法打印字符串 JSON 对象:
print(json.dumps(album2))
print(type(json.dumps(album2)))
我们的字典被正确解析为一个字符串 JSON 对象。我们看到“album_sale”值“None”现在为“null”，而“won_grammy”值“false”现在为“False”。
最后，我们可以把这个 JSON 对象写到一个。txt '文件使用转储方法:
file2 = open("album2.txt", "w")
json.dump(album2, file2)
我就讲到这里，但是您可以自己随意摆弄代码。
结论
总之，在这篇文章中，我们讨论了如何使用 python JSON 库发送和接收 JSON 数据。我们讨论了帮助我们接收数据的加载方法和帮助我们发送数据的转储方法。如果你有兴趣学习更多关于在 python 中使用 JSON 对象的知识，我推荐苏格拉底的 YouTube 教程。我希望你觉得这篇文章有用/有趣。这篇文章的代码可以在 GitHub 上找到。感谢您的阅读！
OpenAI 的点唱机。
人工智能生成音乐的魅力(附样本和 Colab 笔记本)
作者图片
点唱机——人工智能作曲家。
如果你仔细听，你会听到它们:来自另一个世界的声音。我听到了。嗯，不是直接，而是用点唱机。
JukeBox 是一个生成音乐的神经网络，一个由 OpenAI 团队实现的项目。他们开发了神经框架，并对不同音乐家、作曲家和乐队的 120 万首歌曲和音乐片段进行了训练。
这是一张音乐家地图:
来源:【https://openai.com/blog/jukebox/(截图:作者)
已经有各种各样的方法和人工智能驱动的模型来产生音乐，但直到现在，他们仍然能够创造出一些 MIDI 质量的旋律。
例如，这首曲子是我用 TensorFlow powered Magenta 框架的 Piano Transformer 创作的(试用: Colab Notebook )
钢琴变形金刚像 GPT-3 中的变形金刚一样，使用了自我关注，这给旋律带来了一些内在的连贯性，相当具有算法张力(嗯，JS 巴赫也用算法创作了他的赋格曲)。
JukeBox 使用变压器，但有另一种方法:对音频数据进行采样和上采样。这确实意味着，这个音乐模型“知道”各种风格和声音听起来如何，并写出它的解释。作为音频文件。
我在关于使用人工智能制作播客的教程中写过关于点唱机和其他音乐模型的内容:
在这篇文章中，我想与你分享我的一些惊人发现。
它是如何工作的？
在“ DEVS ”系列中有一个激动人心的时刻，科学家们对不可能的事情有了越来越清晰的认识——随着每一次迭代，他们都能越来越好地看到不可思议的事情。
使用点唱机你可以体验类似的感觉。有一款官方 Colab 笔记本可以用。
但也有 Colab 笔记本，SMarioMan增强，( GitHub )。它允许你在谷歌硬盘上存储数据——以防你的笔记本电脑崩溃。因为你需要时间来创作音乐——长达 8-10 个小时。
这里有一个由 Broccaloo 制作的关于使用点唱机的非常有用的视频教程:
首先，你需要定义一个艺术家和流派。你可以在 OpenAI 生成的巨大的人工智能音乐播放列表中找到 JukeBox 训练的所有艺术家和流派:
[## OpenAI Jukebox 示例资源管理器
浏览所有样品
jukebox.openai.com](https://jukebox.openai.com/) 
点唱机播放列表，作者截图
第二次，在 10-30 分钟内 (第 2 级) 生成几个样本(默认为 3 个项目)。如果你不喜欢，你可以重新播放。
第三个，生成您满意的样本— 升级(1 级和 0 级)** 。这需要时间，有时是半天。有时笔记本崩溃(连接中断，谷歌服务器问题等。等等。).但是如果你使用 SMarioMan 的笔记本，你所有的进展都存储在你安装的 GoogleDrive 中——你可以继续使用那里保存的检查点。
Colab 笔记本还能做什么？你可以…
- 重采样现有的音乐片段(AI 可以从指定的时间点继续)
- 尝试选择不同的艺术家和流派
- 高档已经完成的音乐作品质量更好
- 输入你的短信，运气好的话，人工智能生成的歌手会表演出来。
同时，我们可以观察到非常有趣的结果。跟随莱昂纳多·古铁雷斯，他对点唱机做了很多实验。利用我们对 AC/DC 歌词的共同改写，他创作了一个新版本的“在黑暗中拍摄”:
布罗卡罗(他在上面做了一个非常有用的视频教程)也做了有趣的实验:
Discord 上甚至有一个点唱机用户的粉丝社区:
查看 Discord 上的点唱机 AI 社区-与 469 名其他成员一起玩，享受免费的语音和文本聊天。
discord.com](http://discord.com/invite/6At7WwM)
来自异次元的声音。
点唱机上最让我着迷的是什么？不完全是模仿现有的表演者或演绎著名的作品，而是发现隐藏的宝石。机器的音乐幻觉。独特的声音景观。
恐怖谷已经过时了。这不再是一种怪异或令人毛骨悚然的感觉——这是遇到人工美学的幸福。
事实上，这些作品都是独一无二的:每一次都有一首新的前所未有的音乐作品产生——而且你可以肯定(就像 GPT 3 号的)这个序列永远不会重复。只是给你的。只有现在和这里。
我的第一次实验让我起鸡皮疙瘩。第二层已经很特别了，不是真正的音乐作品。越是向上采样，它就变得越迷人和清晰:
二级:
一级:
0 级:
听起来…很奇怪。就像记录一个未知国家和未知文化的配乐。
的确，点唱机完美地模仿语言。它可以解释你预先设定的文本，但它也可以产生一种语言的音乐解释。
你可以把它和 StyleGAN2 相比，style gan 2 解释文字的视觉效果而不是语义:
由 StyleGAN2 驱动的art breader生成的图像(我将它们用作虚构的 AI 相册的封面)，由作者生成的图像
称之为 Brut Art ，称之为 Glitch Art ，但是 JukeBox 生成的一些音频样本却异常强烈。这里是我最喜欢的一些，我非常想知道你对它的看法？
你从未听过的声音。
除了上面的电影配乐，我还有几首音乐特别吸引我的兴趣。暂时忘记机器学习和理论。只要闭上眼睛，听音乐，保持对各种音频现象的关注。为了获得最佳体验，我建议使用耳机。
赛博布鲁斯/自由风格爵士乐
点唱机非常适合爵士乐。尤其是充满了同步和变调的自由式或实验性作品。上面的第一个片段也是用声音传递的——你可以识别单词，你也可以听到它模仿英语，但那是唯一的模仿。第二张唱片也有鼓舞人心的大乐队氛围——乐器的音质令人惊叹。
现象:你在这里观察到的另一个令人兴奋的现象——大部分生成的音乐片段已经完成作曲。它们不会在你设置好音乐长度的那一秒突然结束(至少不是全部)。同样的音乐变压器使旋律连贯的工作往往能使优雅的音乐结束。
声音
听听这把木吉他——你甚至可以听到吉他琴弦的刮擦声，仿佛这里不仅产生了音乐，还产生了音乐家。
现象:在上面的例子中，你会观察到(0:27 分钟)一些尖锐的音调，好像有人在鼓掌。只有两次——从现在开始，旋律节奏与这次鼓掌一致。变压器转换音乐，而不破坏其声学美学。
中世纪音乐剧
这很特别:闭上眼睛，你会想象一个有演员的舞台，他们的表演，甚至观众的反应。
**现象:**听这首曲子你有什么想象？我几乎看到一个欢闹的国王伴着喇叭声入场(伴随着观众的笑声)，然后在一些柴可夫斯基的样本之后是一首情歌(结尾是主角唱“给你！…"(他可能会在他的女士面前跪下)，公众无法用热烈的掌声、笑声和口哨来掩饰自己的情绪。一个不存在的戏剧表演的非常有机和现实的视觉。
在峡湾中歌唱
这首曲子是在玛丽莎·纳德勒上训练的，但在开始时，一个女孩的声音用一种不存在的语言演唱。独奏结束后，铿锵有力的音乐开始，脆弱的声音变得浑厚。
现象:强度、回声和气氛令人无法抗拒。我使用的是由 RoseBud 提供的 TokkingHeads 服务。AI (实现 i.a. 一阶运动模型)来可视化该性能:
**观察:**点唱机产生独特的风格和语言，可以帮助音乐家和作曲家获得新的令人惊讶的想法和灵感。
我没有任何问题(如特雷西·查普曼所唱)
在这两个版本中，我选择了特雷西·查普曼作为表演者。正文是 GPT 为我写的——3:
非人类诗歌
thecreative .咖啡馆](https://thecreative.cafe/a-rock-and-a-poem-8e14a791a092)
这很有效 Tracy 演唱人工智能生成的歌词的独特声音(我爱上了这首 GPT 3 的诗)。
现象:就像在其他人工智能生成的歌曲中一样，即使你为歌唱指定了歌词，人工智能也不一定会服从并使用你的文本。有时——甚至经常——它用额外的语言错误来扩充文本。这种意想不到的和个人的随机性再次证明，人工智能作为一个创造性的实例，肯定不仅仅是一些算法音乐预测方法。
人生不过是一场梦
为了这首歌，我训练点唱机上的童谣“划划划你的船”和吉米·卡伦作为表演者。还是那句话，你不仅能听到著名韵文的正文，还能听到一些语言故障。
**现象:**在这个案例中，给我留下深刻印象的不仅仅是声音的爵士配乐和强大的瘴气。但也是无意的，但完美实现的省略号:“仅仅，仅仅，仅仅，仅仅”……而小船正漂向光的海洋。
**观察:**点唱机可以给我们有趣的音乐隐喻的想法。
顺便说一句。这是另一个版本的“划你的船”，听起来更像是一首爵士冷战情歌*“来自俄国的爱”*:
管弦乐队的陷阱
这首乐曲听起来令人震惊——它以实验性的管弦乐声音开始，残酷而尖锐的尺八或萨克斯管音调，其他乐器加入了不和谐的声音，但随后出现了和声合唱。
如果我没有从 JukeBox Notebook 获得这首音乐，我会认为它是 UbuWeb 音频部分的某首音乐杰作。
**现象:**在吉米·卡伦接受训练，但在“经典音乐”流派中带来了有趣而独特的结果——训练基地再也认不出来了。混合方面会导致令人惊讶的效果。
如果你想听更多:收听我的每日 #LatentVoices 频道，或者查看我在 Soundcloud 上的#自动点唱机播放列表。
或者创作你的音乐并在这里与我们分享。
Julia 负责数据科学
在 Julia 中从零开始建立具有梯度下降的多元线性回归
图片来源:朱丽亚话语
目前，Python 和 R 无疑是机器学习领域使用最广泛的编程语言。不幸的是，这些编程的高级和优雅的抽象通常是有代价的，尤其是在处理大型系统时。在我们开始之前，这篇文章不会对 Python 或 R 进行无休止的抨击，所以任何有这种期望的读者都应该去别处看看。相反，这篇文章旨在启发和告知读者 Julia 可能会加入他们的工具箱。归根结底，所有这些编程语言都只是具有不同用例的工具。
朱莉娅到底是什么？
Julia 被描述为一种动态编程语言，它专注于高性能，即使是高级抽象。因此，这种语言非常适合数字和科学计算。2009 年，4 名计算机科学家(其中 3 人的照片如下)共同创造了 Julia。
Juila 图像信用的共同创造者:麻省理工学院新闻
“说话像 Python，走路像 C .”
这一行是最常用的引用之一，总而言之，这是这种编程语言的主要优点。有些读者可能读过关于臭名昭著的“两种语言问题”的报道。对于门外汉来说，这两个语言问题简单地描述了这种情况；
开发人员必须用 C/C++等低级语言重新编写代码库的关键和性能部分，因为 Python/R 等高级语言由于其高级抽象而在某些任务上可能会很慢
在 Python 和 r 等高级语言中，快速构建新想法的原型相对更容易。这些语言在数据科学生态系统中占据如此主导地位的一个主要原因是，数据科学生态系统严重依赖于尽快尝试新想法。这里的折衷(就速度而言)对于中小规模的应用程序来说是可以接受的，但是对于大规模的系统和应用程序来说非常明显。
Julia 被称为可以解决这种双语言问题的语言，它提供了 Python/R 这样的高级语言的友好性，同时匹配 C/C++这样的低级语言的速度。
gif 信用:https://giphy.com
“足够的速度基准，告诉我如何使用它！”
我听说过朱莉娅，但我总是想知道它的用法。有 Python/R 那么简单吗？
这篇文章简单地通过使用 Julia 的梯度下降从零开始构建多元线性回归来测试这个断言。我使用 Python 和 R 已经有几年了，所以我决定看看用 Julia 来快速解决这样的任务有多快。这篇文章不是 Julia 和其他语言之间的基准测试，因为这样的测试已经被很好地覆盖了，而是关注于这种语言对那些习惯于 Python/R 的人的用户友好性。
数据
将用于该测试的数据集是来自 UCI 数据仓库的联合循环发电厂数据集 ( Sheet5 )。这里的目的是生成一个模型，该模型可以根据 4 个数值(连续)特征预测***【EP】***:
- 温度(AT) 在 1.81 摄氏度和 37.11 摄氏度范围内。
- 排气真空(V) 在25.36–81.56厘米汞柱范围内。
- 环境压力(AP) 在992.89–1033.30毫巴范围内。
- 相对湿度在 25.56%到 100.16%的范围内。
建模工作流
这个实验的攻击计划就像一个典型的建模工作流，其中数据将是:
-
加载到内存:数据以 DataFrame 对象的形式加载到内存中，大多数读者对这段代码已经很熟悉了:
-
**为算法进行预处理:**随着数据成功加载到内存中，现在让我们将它分成一个训练和验证集，使用比例 80% 用于模型的训练，保留 20% 用于生成模型的评估。下面的代码片段实现了这个功能(但是更健壮的方法是打乱索引)。我们的目标是快速启动并运行，所以这就足够了。
正如您可能已经注意到的，这些特征处于不同的标度(从百分比到毫巴)，这对于大多数算法来说可能是有问题的，因此常见的做法是标准化特征，以便它们可以处于相同的“标度”。下面代码片段中的两个函数用于标准化训练和测试特性。
我们的数据现在已经过预处理，可以进行建模了。
- 模型拟合&评估:这里的目标是找到一个线性模型，最好地最小化良好的旧均方差函数。我们的均方成本函数本质上是一个半均方函数，其定义如下:
定义好成本函数后，让我们使用梯度下降法为每个特征(包括常数)找到最佳权重，使成本函数最小化。下一个函数负责处理这个问题:
NB :这个实现实现了没有正则化的梯度下降(我鼓励你添加到你自己的实现中)。
现在，让我们通过绘制成本历史向量𝐉:来检查梯度下降是否有效并最小化我们的成本函数
每个时期的成本
从图中可以看出，随着迭代次数的增加，成本下降，直到在某个点持平。看来梯度下降在寻找最小化我们的成本函数的权重方面做得很好。
gif 信用:https://giphy.com
现在是时候做一些预测并评估我们新的闪亮回归模型的性能了。两个新函数用于生成预测并对训练和测试数据集进行评分。
从评分函数来看，训练集和测试集的均方根误差 ( RMSE )为:
**RMSE** for Training Set: **4.578258826855693**
**RMSE** for Testing Set: **4.473104537374325**
现在让我们看看模型在两个数据集中的预测能力(根据 R 平方值),以及该函数:
**Training R²** score for test sets: **0.9274046053983883**
**Testing R²** score for test sets: **0.9335248094191678**
这些分数似乎表明，一些像样的预测能力( 0.927 & 0.934 )！
gif 信用:https://giphy.com/
然而，测试分数优于训练分数，这似乎表明该模型对数据拟合不足。修改阿尔法项( α )和/或迭代次数( n_iter )应该可以从这个模型中挤出更多的性能，但是我将让读者自己去修改。
基于这个朱莉娅实验的好恶
从这个实验中，我基于之前与 Python 和 r 的互动，自然对 Julia 有了一些好恶。
喜欢
- 本地 Unicode/符号支持:我最喜欢的 Julia 无疑是它对 Unicode 和科学符号的本地支持。在脚本中使用’ θ 而不是’θ’，使用’α’而不是’ alpha '，这很酷也很简洁。这是一种为科学/数字计算而从头开始构建的语言！我发现每次我不得不使用科学记数法时，我都在微笑。
- 一种语言的语法在它快速将思想原型化的能力中起着关键的作用。Julia 的语法和 Python 没什么区别。就语法而言，Julia 感觉自己是 Python 和 Matlab 之间的私生子。在大多数情况下，我需要快速查找文档，以避开一些糟糕的语法调用。此外，用真正的科学符号分享和阅读科学代码是非常容易的！
- **对现有 Python/R 生态系统的支持:**作为一门年轻的语言，预计生态系统中会缺少一些急需的包。然而，令人耳目一新的是，现有的 Python/R 包可以在 Julia 中使用。这种功能让朱莉娅享受成熟的生态系统的好处，并避免不必要的重新发明某些车轮。
不喜欢
- **缓慢的预编译时间:**与 Python/R 相比，人们注意到的第一件事是在 Julia 中加载包所花费的时间。每次加载包都需要预编译，这确实需要一些明显的时间(超过 10 秒)。对于习惯于即时导入包的 Python/R 用户来说，这可能会令人沮丧。
- 年轻的语言/生态系统:无论是 Python 还是 r，几乎都有一些常见的数据角力任务的包，Julia 作为一个新人，自然没有老牌语言享有的那么原生丰富的生态系统。然而，这个问题现在可以通过使用 PyCall & JuliaCall 包支持从 Python 和 R 导入来解决。
- **缺乏传统的 OOP 支持:**Python 对于数据科学应用程序的魅力和广泛采用的部分原因是它用面向对象编程构造函数的简洁而方便的方式。例如，如果所有预处理功能以及所有学习到的参数都可以在一个类中获得，那将是非常简洁的。Julia 采用了" 多重分派 "范例，这有助于它比其他高级语言更快。
结论
Julia 是一种很有前途的语言，它是为数字和科学计算而从头开始构建的。在这篇文章中，我已经展示了在 Julia 中建立原型相对容易，并成功实现了使用梯度下降的多元线性回归。这是每一个数据至少应该保持的一种语言，并且是一个数字眼睛。对于 Julia 来说，有一些令人惊讶的数据科学软件包。拿些数据集，和 Julia 玩玩，让我知道你的想法？在我看来，启动并运行的最佳方式是安装使用 Atom 的 IDE 附带的 JuliaPro。
一如既往，我期待着反馈(好的或坏的！).这个博客的 GitHub 库上可以找到这个post 的所有功能的脚本。最后，你可以在我的个人博客上查看其他帖子。直到下一个帖子，祝你在茱莉亚编码愉快！
Julia For Data Science:正则化逻辑回归
如何在 Julia 中从头构建正则化(L2)逻辑回归
图片来源:https://dzone.com/
用于机器学习任务的惊人的库(如 scikit-learn)使得这些天来生成机器学习模型变得非常容易。必须从头开始编写每个模型的日子已经一去不复返了。这是一件好事，我们已经走过了那些时间，因为大多数问题最终都是优化问题。另一方面，这种“符合和预测”文化会对整个领域的学习文化产生严重的长期影响。一些拾荒者正在利用那些半生不熟的"在 30 天内学会数据科学"计划来喂养"人工智能炒作，这些计划经常导致毫无准备的学生在他们的"拟合和预测"模板背后没有真正的直觉。这是我最近关注的这些“从头创建”帖子的主要动机。
逻辑回归和正则化背后的直觉
对于不熟悉正则化和逻辑回归内部工作原理的读者，我强烈鼓励这些读者通过观看加州大学伯克利分校的讲座，对正则化逻辑回归如何工作有一个很好的认识。这个讲座解释了内部工作逻辑回归以及正规化的需要。
对于已经熟悉这个主题的读者，让我们直接进入实现代码。
数据
这个实验的数据集是来自 UCI 机器学习库中的 HTRU2 数据集 。本实验的目的是生成一个二元分类器，它可以根据 8 个连续特征预测一颗恒星是否是脉冲星:
- 综合轮廓的平均值。
- 综合轮廓的标准偏差。
- 积分轮廓的过度峰度。
- 综合剖面的偏斜度。
- DM-SNR 曲线的平均值。
- DM-SNR 曲线的标准偏差。
- DM-SNR 曲线的过度峰度。
- DM-SNR 曲线的偏斜度。
二进制类显示了负类和正类之间的巨大不平衡，具有16259个负样本和1639个正样本，这在大多数分类项目中非常常见。考虑到与该数据集的不平衡，任何模型都必须超过基本精度分数91%(16259/17898)才能被认为是一个像样的模型。这是一个经典的例子，说明了为什么准确性作为一种衡量标准对于存在巨大阶级不平衡的问题毫无意义。
建模工作流
我真的回到了董事会，为一个正则化的逻辑回归构建各种组件。这个练习非常有助于确定以矢量化为重点的优化实施方案。
梯度下降正则化逻辑回归的矢量化实现
在理论实现的涂鸦之后，是通过 Julia 翻译成代码的时候了。
这个实验的攻击计划就像一个典型的建模工作流，其中数据将是:
- **为算法进行预处理:**为了简洁以及关注实现的需要，训练和测试示例(以及标签)被分开保存，以便我们可以专注于建模。对于感兴趣的读者，代码将在 Jupyter 笔记本的结论链接中提供。通过下面的代码片段，将数据加载到内存非常简单:
加载了各种分区之后，让我们将注意力转向实现阶段。
- 模型拟合&评估:鉴于所有特征都是连续变量，预处理阶段也将相当简单。因此，训练和验证分区都将通过标准化进行规范化，如下所示:
随着特征现在被归一化，让我们为我们的正则化逻辑回归定义"*假设"*和"成本函数":
这里的目标是找到权重(θ),该权重使上面使用方向梯度定义的正则化成本函数最小化。这个目标是通过这个函数实现的:
如果梯度下降在这个最小化目标上是成功的，那么成本应该在随后的迭代中开始下降。让我们看看这个实验是不是这样:
每次迭代的成本
该图显示了随着迭代次数的增加，成本值的减少，这是实现正在工作的积极迹象！
图片来源:https://giphy.com/
让我们做一些预测，并测试生成的正则化模型的准确性。
**注意:**对于分类项目，在面临类别不平衡的情况下，准确性可能不是模型评估的稳健指标。准确性作为一个度量标准就足够了，因为重点更多的是在实现上。
**Training score**: 0.9769
**Testing score**: 0.9788
训练和验证准确度分数几乎相同，这有助于减轻对过度拟合/欠拟合的任何担忧。为了更好地理解这个实现的成功或失败，我们将把这些结果与 Python 中令人惊叹的 scikit-learn 的结果进行比较。
- 与 scikit-learn 实施方案的比较:使用 scikit-learn 的带梯度下降的正则化逻辑回归构建等效管道相当简单，如下所示:
**Train score for SGDClassifier**: 0.9791
**Test score for SGDClassifier**: 0.9807
有趣的是，结果非常接近，但毫不奇怪，sklearn 的实现在准确性分数方面超过了它。这是一个更加优化的实现，非常聪明的调整！在这篇文章中，我们在 Julia 中使用梯度下降从零开始成功地实现了正则化逻辑回归。
最后的想法
唷！对于少数几个被选中的人来说，我希望你们喜欢这次旅程。我和 Julia 的旅程仍处于起步阶段，这个实验比之前的线性回归实验耗时更长，难度更大。我开始明白茱莉亚是多么喜欢处理矩阵、标量和向量运算( 那些)符号 )。我计划在以后的文章中用这种有趣的编程语言做更多的实验来解包经典和当代的算法。它可能是最终解决了埃隆·马斯克今天所阐述的“双语”问题的语言！
一如既往的期待反馈(好的坏的！).这篇文章的 Jupyter 笔记本可以在这个博客的 GitHub 知识库中找到。最后，你可以在我的个人博客上查看其他帖子。直到下一个帖子，祝你在茱莉亚编码愉快！
游戏开发的朱莉娅——错失的机会
如果不是因为这个，朱莉娅的一个意想不到的用途可能是非常可行的…
所以最近我一直在尝试并习惯于将游戏开发作为一种爱好。虽然在某种程度上，它肯定类似于编写任何其他软件，但关于所有部分以一种不可思议的方式发挥作用的一些东西让我对编程一个游戏着迷。下面是我录制的一个简短演示，展示我创建的模块化矢量图像数据加载算法，我把它放在 Youtube 上，供感兴趣的人观看:
但是包括 C#、GDscript (Godot)和 C++ (Steamworks API)在内的一系列不同语言的所有这些开发努力让我对我最喜欢的编程语言想了很多:
美丽的，
宏伟的
毕竟，朱莉娅和游戏编程似乎是天作之合。游戏需要基于数据的快速语言。Julia 现在比游戏编程中的脚本之王要快得多。最重要的是，Julia 代码可以快速有效地编写，尤其是与 C++这样的语言相比。
当前的不足之处
有两种主要的语言用于现代游戏开发(在很大程度上)，C#和 C++。几十年来，C++一直是推动计算机行业的主导力量，当然也是一门伟大的语言。C++有相当多的领域优势，因为它是面向对象的，而且是鸭子类型的。这与更常用的另一种语言 C#相比，是一个巨大的进步。C#是一种静态类型的高级脚本语言，可以与 Python 这样的语言相比，
虽然这可能会有点困难。
如果你是一个真正的朱利安，你可能已经意识到，我们可以说朱莉娅同样的事情。
Julia 是一种静态类型的高级脚本语言，可以与 Python 这样的语言相提并论
使用 C#最大的缺点可能是它的专有许可。C#是一个奇怪的例子，其中只有某些组件是开源的，而其他组件是隐藏的。另外，不言而喻，C#确实比 Julia 慢。
另一方面，C++对于游戏开发来说可能远远不够。问题？从 C#或 Python 这样的语言跳到 C++可能会让人不舒服。不管什么原因，我在很小的时候就开始学习 C++作为我的第一门编程语言
这确实令人困惑。
现在使用 C++在某种程度上让我感到沮丧，因为我不能像在高级语言中那样快速完成函数，通常需要 30 分钟编程的操作很快就变成了一个小时到一个半小时。当然，这不是 C++的错，但对我来说，当 Julia 能够做我需要做的事情时，使用 C++做任何事情都没有多大意义。
朱莉娅
我认为 Julia 在游戏开发领域最大的优势之一是它惊人的速度。Julia 的语法比 C#简单得多，但运行速度是 c#的 1.5 倍。从 C#到 Julia 实际上也不会有太大的飞跃。Julia 和 C#都是静态类型编程语言，专注于数据和类型调度的不变性。
朱莉娅在游戏方面也有“恰到好处的慢”。Julia 在速度方面的最大障碍可能是预编译和启动时间。虽然这些问题在某些情况下可能很严重，但 Julia 仍然比 C#快，游戏中的启动时间转化为加载时间。简单地观察一下，大部分加载时间都花在移动数据上，而不是加载模块上，我认为可以肯定地说这种担心是没有的。
已经有 Julia 开发者在开发一些非常酷的 Julia 游戏项目，可能会让你大吃一惊。这是一个地图加载器。BSP 映射文件:
用 Julia 和现代 OpenGL 写的实验性的 Quake 2 地图渲染器。在黑客学校创建的。这是一个玩具，而不是…
github.com](https://github.com/jayschwa/Quake2.jl)
这是一个用 Julia 写的非常简单的桨球克隆体:
使用该库构建的一个简单的 pong 克隆。这个回购是一个例子，建立一个完整的游戏，编译和…
github.com](https://github.com/NHDaly/PaddleBattle.jl)
除了这些展示之外，我们还拥有在 Julia 内部进行游戏开发所需的足够的工具。例如，SDL2(低级)和 SFML(高级)都有 Julia 端口，绝对值得一试。
箭头指向膝盖
在目前这个时间点上，Julia 的游戏开发有一个显著的缺点。这不仅是游戏开发者的问题，也是软件工程师、编剧甚至数据科学家的问题。
Julia 确实有一个编译可执行文件的工具链，但是它还没有*。看起来很多都还在开发中，不一定被 Julia computing 优先考虑。那我怎么想？*
我认为，由于其简单的语法和快速的速度，Julia 绝对有潜力超越 C# mono 或 C++这样的语言，但我认为在这成为现实之前，Julia 仍有一定的距离要走。虽然我当然会一直主要关注 Julia 的统计和分析方面，但如果 1.0 中更好的编译可执行文件能够实现，我会非常高兴。据我所知，Julia 编译的可执行文件(我尝试过，但最终的. x64_x86 文件从未运行过)正在为依赖环境保存某种奇怪的系统状态。我想我会把它留在那里，朱莉娅带走了一切；一个包管理器，一门语言，统计编程，只是让它变得更好。我理解为什么在没有本机支持的头文件的情况下实现像编译的可执行文件这样的东西可能是一个真正的挑战。有鉴于此，我会耐心等待，
但是你不能指望我不兴奋！
Julia Oop Vs. Julia Dispatch:谁是速度王？
这种拙劣的方法能打败朱莉娅稳健的调度吗？
我如何以及为什么将面向对象的范例应用于 Julia 机器学习。
towardsdatascience.com](/how-im-using-functional-oop-for-machine-learning-533c1d764628)
在我之前写的一篇文章中，我在 Julia 的机器学习包中取得了相当大的进步，车床，它允许在主要功能的多范例语言 Julia 中进行面向对象的编程。这个概念本身对 Julia 来说是非常独特的，因为构造的类型是在没有返回的情况下创建的，也没有通常用于构造该类型的结构。
不管这个概念有多有用，为了对已经存在了一段时间的软件做出重大改变，我认为测试是很重要的。车床的利基主要是机器学习大师，他们在寻找以下参数:
- 快的
- 使用方便
- 可扩张的
- 可攀登的
- 轻量级选手
这些是车床作为一个软件的支柱，任何修改都需要符合这些参数，并超过在一个或另一个参数中失去阵地的成本。在我们研究“新手”之前，让我们先看看车床目前使用的方法，
朱莉娅的派遣
我们拥有的
Julia 的 dispatch 是一种奇妙的方式，它使用一种泛型编程概念将方法作为结构的属性来应用，这种通用编程概念是从函数范式中建立起来的，并包含在 ML 编程语言参数多态性中。Julia 的 dispatch 没有使用典型的函数式方法(方法与存储在类型中的静态数据进行交互),而是本质上应用了一个通用规则，通过方法将流量导向语言本身。
快的
就速度而言，朱莉娅的调度肯定是最慢的。与使用条件或单个函数相比，使用轻量级调度可以使速度翻倍。首先，Julia 是一种考虑到速度而构建的语言，因此非常快，但是，将语言的自然速度与编写良好、调度良好的代码结合起来，可以使 Julia 在竞争中脱颖而出。
使用方便
使用 Lathe 中的当前解决方案，可以通过一个通用方法(predict()方法)轻松地分派类型，如下所示:
using Lathe.models: predict, FourSquare
yhat = predict(FourSquare(trainX,trainy), testX)
再加上内置的？()文档在车床，我相信这是比较直截了当的，易于使用。最重要的是，已经不太需要异常处理了，因为车床是与数据帧绑定在一起的。JL，并使用 Julia 的基类型。这是我在许多语言中见过的问题，包括 Julia，但最常见的是在 Python 中，因为 Python 作为一种统计语言具有可扩展和极简的特性(没有 Numpy 就没有多少线性代数，所以用其他东西构建的包会自动受到限制。)每当我试图通过列表函数传递 Numpy 数组，以及通过各种函数传递 Pandas 系列时，我肯定会遇到问题。
可扩张的
使用 Julia 的调度允许在显式导入时修改车床。我认为这是召唤一个一致的生态系统的巨大好处。与车床无关的包仍然有扩展车床功能的潜力。所有的扩展都可以很容易地使用 Julia 的调度来完成和重新路由，使得扩展车床变得简单明了。
可攀登的
作为一名数据科学家，对我来说最重要的事情之一是构建一些可以扩展到大型应用程序的东西，同时在较小规模的应用程序中也能做得很好。幸运的是，通过大量艰苦的工作，车床模型是可部署的，并且能够用 Genie 完全自动化。自动化的范围可以从再培训和序列化到测试。
轻量级选手
Julia 的调度相对简单，因为它需要三个关键部分:
- 派单本身(一行)
- 要分派到的函数
- 要分派给函数的类型
这是一个相对轻量级的解决方案，因为它不需要带有几个函数的大型类，而是让语言在使用数据进行实际计算方面对结构的属性负责。
已经很不错了
有了车床的所有这些支柱，让 Julia 进行面向对象编程的晦涩技巧有可能胜过 dispatch 吗？使用 dispatch 的最大问题是缺少初始化。缺少初始化意味着没有训练函数，任何计算出的值都需要在再次使用模型之前重新计算，这是很糟糕的。
然而，在很多情况下，这并不重要，因为 Julia 语言可以弥补我们的罪过。每当大型神经网络在车床的新神经网络框架内被训练时，这个问题就会出现。显然，不能在每次需要访问模型时都计算成本，保存值的状态对于缓解这个问题是绝对必要的。
除了能够在初始化时训练模型之外，测试这将对整体进行预测和调度数据以及扩展数据调度和允许数据变异的性能影响也很重要。
所以我们来测试一下吧！
设置
为了测试这种新的函数方法，我决定加载一个数据集，我坐在我的计算机上进行回归性能测试，正式名称为
天气历史. csv
我们可以在 using CSV.jl 中读取这个 CSV 文件:
**using** DataFrames, CSV
df = CSV.read("weatherHistory.csv")
由于 Julia 省略了列的打印，下一步是显示数据框中的每一列，这样我们就可以知道我们可以使用什么特征来预测特定的目标。我们可以使用 show()方法的参数 allcols (bool 类型)来实现这一点，该方法用于显示数据帧，如下所示:
show(df,allcols=true)
因为我们是在进行性能测试，所以我将我选择的两个特性，温度和湿度，分成两列数据帧。这将使查看数据变得更加容易，同时也使数据整体更加清晰。
df = DataFrame(:Temp => df[Symbol("Temperature (C)")], :Humidity => df[:Humidity])
接下来，我决定我的特性和目标，并使用符号通过变量名访问它们(例如，万一我们以后想改变特性):
target = :Temp
Feature = :Humidity
和训练测试分割:
**using** Lathe.preprocess: TrainTestSplit
train, test = TrainTestSplit(df)
现在它就像插入我们刚刚分配的变量一样简单:
trainx = train[Feature]
trainy = train[target]
testx = test[Feature]
testy = test[target]
现在让我们从车床模型中导入我们需要的东西，并预测:
**using** Lathe.models: predict, LinearRegression
现在使用相同的代码，但是采用超结构形式(我以前的文章给出了源代码):
一直以来，在一系列可能让我的 CPU 想提前退休的压力测试中，Julia oop 的表现超过了 Julia 的 dispatch。更令人吃惊的是分配减少了大约 67%(平均 70%(当重复测试时))，计算时间减少了大约 16%(平均 18%(当重复测试时))。
所以没错，确实是高效了很多。
结论
我认为这种新方法显示了很大的可伸缩性，然而，可能只是可扩展性概念中的一个弹孔。没有明确确定的类型，我们会冒方法普遍无法识别结构的风险，并且需要嵌入与类型相关的所有函数，这很不幸。另一个不幸的副作用是遗留代码的死亡。车床已经正式离开了长期的支持，0.0.1 已经从一开始，这是一种悲哀。幸运的是，我确实相信这种进步利大于弊，并且肯定会允许在预测建模的多个领域进行扩展。
一个紧凑的比较:Julia，R 和 Python——2022 年的数据科学
如果您对数据科学感兴趣，您可能会注意到这三种语言。问题是，你应该选择哪一个，哪一个最有可能是最先进的？让我们比较一下每种语言的 KNN 算法的实现。
我再一次发现自己正处于考虑学习一门新语言或者仅仅是培养我已经知道的知识的过程中。
每年似乎都是“新”语言的一年，似乎关于“数据科学语言”的讨论比以往任何时候都更加强烈。因此，我将快速浏览所有三种语言，Julia、R 和 Python，同时引导您完成一个基本的 KNN 算法。
我们将按以下顺序讨论语言(1) Julia，(2) R 和(3) Python。代码 可以在下面找到。
首先，背景调查。从 Julia开始，这种通用的动态语言于 2012 年推出，迎合了每个愿意学习一种完全适合性能密集型任务的新语言的人。像其他两种语言一样，Julia 遵循多种编程范例，所以不管你有什么编程知识，你都有可能很快赶上。
我个人很欣赏可选输入的合理实现，根据你软件的用途，这可能会非常方便。语法有时看起来有点像介于 R 和 Python 之间的混合体，但是一般来说，如果遇到困难，你不会很难找到帮助自己的方法。
虽然 Julia 的目标是通用和高性能，但似乎主要是数据科学社区真正推动了 Julia 的成功。著名用户的名单已经很长了:Nasa、IBM、BlackRock、Pfizer 或纽约联邦储备银行——仅举几个例子。
前方曲折的道路[0]
R 于 1993 年首次发布，它比以往任何时候都更成为统计计算的主要竞争者之一。除了 Julia，R 被发明出来作为科学目的的编程语言。这种语言成功地(imho)击败了各种大型竞争对手，如 IBM 的 SPSS(它有一个类似电子表格的用户界面，因此对许多人来说更容易使用)和 SAS(一个商业分析软件提供商和语言)(使用相同的名称)。r 通常以一种简单明了的方式来完成任务，同时也是一种出色而简单的方式来展示数据。
大约在 R 出现的同时，吉多·范·罗苏姆发明了 Python ，一种通用的、解释的和面向对象的编程语言。随着时间的推移，Python 已经停滞不前，受到了 Ruby 等公司的激烈竞争(尤其是在 web 开发方面——Ruby on Rails ),但最终成为了许多人的首选。在基本库出现之后，Pythons 在数据科学领域的成功在 2000 年代突飞猛进。根据您比较数据的位置，Python 现在是使用最多的两三种语言之一(取决于来源)。Python 很方便，因为它可以用于自动化之类的简单任务，也可以用于大型程序。
出于数据科学的目的，Python 需要通过 Pandas (2008)和 Numpy/Scipy (2005，2001)做好准备，因为独立的语言不会给你提供必要的工具。
浏览网页时，你可能经常读到的一个问题是，一些语言只是附带了[令人困惑的大量的软件包，这可能是一件好事，但也可能增加复杂性，并让语言偏离所用软件包的“通用标准”。如果这对你来说听起来很奇怪，试着在 Python 中找到一个好的 Grubbs 测试，它对离群点的去除很有用。
由于 Julia 是我们的候选人中最年轻的(即使我们考虑 Python 从 2000 年代后期开始的崛起)，包的数量不太多(无论如何稳步增长)，R 已经很好地建立起来，并带有许多被用作通用标准的包。Python 做了所有的事情，有一些“主要”的库，但是可供选择的选项似乎是无穷无尽的。
现在够了，让我们进入我们的数据——鸢尾花数据集:
Bye，bye head( ) — Julia 的 first(df，n) 函数
为了使以后的事情具有可比性，这里有一个测试数据点及其引用类。这两个将为我们提供一个机会，将一个“类似于现有的”数据点与我们预测的数据点进行比较。
## Our test data point derived from the reference class
## We can assume that the result must be class = 1[7,3,5,1] ~> 1.0
引用类是 IRIS 数据集中的一个数据点:
## Reference class
sepal_length 7.0 -> **7** (0)
sepal_width 3.2 -> **3** (-.2)
petal_length 4.7 -> **5** (+.3)
petal_width 1.4 -> **1** (-.4)
class 1.0 ≈> 1.0
Name: 50, dtype: float64
朱莉娅开始了。我们将使用 CSV、数据帧和统计数据来计算我们的 knn 结果。
显然，重命名列似乎与我们从 R 和 Python 中了解的有很大不同，相比之下，字典非常好用。一个小提示，使用双引号而不是单引号，因为朱莉娅不会处理单引号(伤心！).
此外，请注意重命名！函数后面跟一个感叹号——理由很充分:这个函数修改它的参数！所以在编写自己的函数时要记住这一点。
就个人而言，我更喜欢在这里使用字典，但是因为我们已经使用字典进行映射，所以我通过数据类型 DataFrame 演示了最近邻的收集和计算。虽然导入非常简单，但循环结构让我想起了古代的 Pascal (RIP ),进一步考虑不要在循环中使用大量的换行符。当使用 IJulia 内核时，我遇到了错误，因为有时找不到结束部分。无论如何，我推荐使用 Atom 进行开发。
结果——只是和其他的比较一下:
**Julia:**
[53, 77, 51, 59, 87]Prediction: 1.0
接下来是 R 大放异彩的时候了。在这一点上值得注意的是，就我的专业背景来看，R 仍然是一条路要走——而且这很可能会保持不变。为什么？r 已经被很好地建立，在数量上是广泛的(机器学习，线性代数， ggplot 等)。)，可以用于简单的脚本，并且已经在许多公司中使用，比如脸书、谷歌、Twitter、微软、优步等等，这只是其中最著名的几个——令人印象深刻，对吧？[2]
有趣的事实，IBM 加入了 R 财团集团(记得我之前提到 IBM 是和 SPSS 的竞争对手吗？)！
根据我的经验，许多大学也教授 R(我有幸两次)。怎么说呢，R 很棒！
r 语法易于阅读，学习起来也很有趣。我欣赏它与其他语言的相似之处，以及在调试时准确的错误消息。由于 R 从早期就受到支持，所以对于开发，您可能会喜欢使用 Atom 或(钟爱的)RStudio。值得一提是，我经常体验到，当涉及到不准确的代码时，R 就不那么宽容了，忘记一个逗号可能会导致一个小时的头痛。学习曲线相当陡峭。
结果——只是为了和其他的比较。注意，像 Julia 但不像 Python，索引从 1 开始。
**R:**
X.index.....i X.dist.....distance
53 53 0.5291503
77 77 0.5291503
51 51 0.5385165
59 59 0.6480741
87 87 0.6633250Prediction: 1
最后，让我们来看看 Python🐍。
我喜欢 Python 的原因是它的列表理解力、强大的迭代方法和简洁的数据结构。虽然使用各种工具非常有趣，但这可能会使开始和理解变得相当困难。Python 的 ide 有很多，我会选择 Pycharm (这对于标准目的是免费的！=笔记本和 Web 开发)或者 Atom(第三次)。
我们的 knn 算法非常简洁(可能是因为我学习 Python 的时间最长)…)，尽管如此，使用 lambda 和 list comprehension 进行排序可能并不是每个人最好的朋友。在这种情况下，我没有使用数据帧，因为我不想导入🐼给你。
结果——只是和其他的比较一下:
**Python:**
[[52, 0.5291502622129179], [76, 0.5291502622129183], [50, 0.5385164807134504], [58, 0.6480740698407865], [86, 0.6633249580710798], [77, 0.7615773105863908]]
Prediction: 1
tldr
Julia——老实说，我真的很喜欢使用 Julia，但是有时候感觉…复杂，不必要的。在下面的例子中，我任意使用了一个字典(在 R 中没有，在 Python 中更方便)和一个 DataFrame 来操作数据。相比之下，使用大多数数据结构非常有趣，而且看起来确实非常快。朱莉娅可能是一种现代的“一种语言适合所有人”的语言。这可能真的是一个爱情故事的开始！
r 就是坚如磐石。它提供了大量的包，非常成熟，并且用它来编码很有趣。由于它的成熟，有很多文档和例子。如果你对数据感兴趣，选择 R 绝对不会错。
Python 很棒，但它还不是性能最好的，它速度快，易于阅读和学习，并且有各种各样的库。在我看来，主要的优势是 Python 可以用于许多不同的目的。 Python 常常如此直观，你会想事情能有多简单。
比较 Python 和(另一种通用语言)Julia，很可能有一天会转向 Julia，尤其是不仅仅是为了科学目的——但是时间会证明一切。
一如既往，下次见！注意安全，待在家里。
[0]图片由费迪南德·斯托尔拍摄(谢谢！)—https://unsplash.com/@fellowferdi?utm_source=medium&UTM _ medium = referral
[1]朱莉娅案例研究—https://juliacomputing.com/case-studies/
[2] R 用户—https://www . datasciencecentral . com/profiles/blogs/list-of-companies-using-R
Julia # R # Rlang # Python # Numpy # Pandas # data science # web development # IDE # Google # IBM # Twitter
Julia 可视化库:哪个最好？
意见
Julia 语言中常用的可视化库概述
(图片由作者提供)
介绍
Julia 编程语言是一种相对年轻的、新兴的科学和数值计算语言。虽然根据我的经验，Julia 客观上更快，主观上更有乐趣，但它的生态系统是短视的。Julia 的生态系统相对不成熟，主要当然是因为 Julia 是如此年轻的语言。也就是说，朱莉娅的生态系统正在快速进化。
在任何数据科学体系中，最重要的软件包之一是数据可视化软件。虽然 Julia 可能没有像 Bokeh 和 Plot.ly 这样最现代和最完善的 Python 库，但它在数据可视化方面确实有一些相对强大的选项。然而，对于新用户来说，这个新的生态系统可能有点令人生畏，并且很难选择正确的软件包。
我的偏好(前言)
关于图形库和一般的模块，我想解释的一件事是，有时有主观和客观的原因，人们可能更喜欢使用一个而不是另一个。也就是说，虽然这篇文章将主要关注客观点，但我的偏好肯定会在某个时候出现。
在 Julia 的三大数据可视化包中，有许多完全不同的方法在起作用。有时候，某些方法可能会被一些人喜欢，而被另一些人讨厌。说完这些，下面是我的结论和对当今三个最大的 Julia 语言绘图库的比较。
Plots.jl
(图片由作者提供)
Plots.jl 是一个包，可以作为一个高级 API，用于处理几个不同的绘图后端。这包括 GR，Matplotlib。Pyplot，最后是 Plot.ly。该软件包主要用于 Julia 生态系统还不成熟，无法支持纯 Julian 图形架构的时候。话虽如此，但现在情况已经不同了——所以就可用性而言，我当然不会推荐 Plots.jl。
Plots.jl 的第一个也是最明显的缺陷是它本质上是其他软件的接口。有些软件还依赖 PyCall.jl，这意味着 Pyplot 和 Plot.ly 可视化的运行速度要比 Julian 软件包慢得多。此外，PyCall.jl 实际上比使用 Python 本身要慢，因此将 Plots.jl 与 Julia 一起使用，而不是将 Plot.ly 或 Pyplot 与 Python 一起使用，这为 Python 实现提供了客观优势。
这个包的另一个大问题是绝对荒谬的 JIT 预编译时间。这是一个问题的原因，因为需要编译三个不同的包，其中没有一个是本地的 Julia，模块才能工作。
另一方面，Plots.jl 的一个优点是它的可靠性和简单性。事实上，它依赖于古老的后端，这意味着这个包很少被破坏。Plots.jl 包也相对简单易用，尤其是使用默认的 GR 后端。如果你想学习更多关于使用 Plots.jl 的 GR 后端的知识，我在这里有一个完整的教程:
没错，又是 Julia，我保证 R，Scala，Python 还在这个爱情圈里
towardsdatascience.com](/spruce-up-your-gr-visualizations-in-julia-88a964450a7)
牛虻. jl
(图片由作者提供)
在某种程度上，牛虻. jl 是朱莉娅对 Plot.ly 的回答。从主观上来说，牛虻是该语言中我最喜欢的可视化库，但从客观上来说，与其他竞争模块相比，它也非常棒。牛虻通过 Javascript 集成产生了漂亮的交互式可视化效果，这是这个列表中的任何其他可视化软件包都无法真正感受到的概念。
牛虻也是用纯朱丽亚写的。与 Plots.jl 相比，牛虻预编译只需要几毫秒，并且可以在很短的时间内完成可视化。
虽然《牛虻》在这个列表中是我最喜欢的，但它也有一些明显的缺陷。首先，它不一定是最多样化的包。在可视化中很难得到你想要的确切的东西，因为用牛虻很难从头开始构建东西。也就是说，这个问题主要是 Javascript 实现的结果，并且主要是在与更静态的解决方案进行比较时才会感觉到。如果你想了解更多关于牛虻的信息，我这里有一整篇文章:
看看朱莉娅对 2020 年统计绘图的最佳选择
towardsdatascience.com](/gadfly-jl-the-pure-julia-plotting-library-from-your-dreams-3ee6ca107a5c)
VegaLite.jl
(图片由作者提供)
另一个为 Julia 准备的很棒的可视化软件包是 VegaLite.jl，VegaLite 可以被认为是对 Python 的 Seaborn 之类的东西的 Julian 回应。与牛虻类似，Julian VegaLite 实现是用纯 Julia 编写的。VegaLite 的伟大之处在于它的包容性和令人难以置信的活力。
虽然 VegaLite 可能没有牛虻的交互性，但它肯定是一个非常棒的可视化库，可以令人难以置信地定制。VegaLite 和牛虻之间的一个显著区别是 VegaLite 由组合在一起形成组合物的模块化部分组成。因此，VegaLite 是一个更加多样化的套餐，有很多选择。
结论
尽管 Julia 在过去没有最好的图形库实现，但很明显这正在迅速改变。不仅有新的纯朱利安选项可供使用，但他们也是相当神奇的选择。这三个中我最喜欢的通常是牛虻。这是因为我喜欢交互式可视化。牛虻的方法也非常简单，这使得用最少的努力就可以很容易地建立和运行一些可视化。也就是说，对于数据分析的深度可视化，VegaLite 可能是 Julia 程序员的最佳选择之一。
JuliaHub:将包和文档放在一起的最好方法
JuliaHub 如何自动化所有程序员讨厌做的事情。
(图片由作者提供)
Julia 编程语言是一种年轻的、崭露头角的语言，它采用出色的方法来解决现代编程中的问题。首先，这种语言非常灵活，而且这种语言自带的所有标准软件背后都添加了非常强大的方法论，这使得这种语言变得更加流畅。这种想法可以在很多方面感受到，例如 Julia 对虚拟环境和依赖关系的抢先方法，这使得管理项目语言中的依赖关系变得轻而易举，而不管团队的规模如何。
Julia computing 的一个相当新的前沿功能是新的 Julia Hub 网站，它仍处于测试阶段。如果你想看看这个网站的现状，你可以点击这里查看:
[## JuliaHub
编辑描述
juliahub.com](https://juliahub.com/ui/Home)
每当注册一个 Julia 包时，将包添加到 Julia General registry 的 pull 请求是完全自动化的，由 Registrator.jl bot 完成，这已经非常方便了。每当软件包被添加到 Julia General registry 时，它们也被添加到可从 JuliaHub 网站访问的数据块中。
包搜索
有时候很难找到很棒的软件包来做特定的工作。JuliaHub 用自己的包浏览器解决了这个老问题，它允许用户按名称、学科或功能浏览包。这使得发现新的和令人兴奋的技术变得容易，并使终身学习者保持警觉，等待他们可能遇到的下一个令人敬畏的图书馆。
此外，从软件包的页面上，您可以找到更多关于它的信息！例如，您可以阅读描述，访问 Github 页面，甚至查看文档。更进一步，您可以对特定项目、贡献者、README.md，甚至依赖于它的其他包的所有依赖关系进行概述。只要看看 JuliaHub 上的车床. jl 页面就知道了:
(图片由作者提供)
不用说，这太棒了！能够在一个地方访问所有这些信息非常方便。作为一名程序员，您可能需要的唯一其他东西是您正在查看的包的文档。
等等。
(图片由作者提供)
证明文件
在过去，我曾经谈到过 Documenter.jl，它是一个 Julia 包，可以从代码中提取文档字符串，并将其放入漂亮的 HTML5 模板中，这些模板是可部署的、可搜索的，并且是完全自动创建的。如果您想了解更多关于 Documenter.jl 的内容以及如何使用它，您可以在这里查看那篇文章:
[## 如何用 Documenter.jl 自动化 Julia 文档
没有文档，软件是没有用的，所以用 Documenter.jl 把文档的痛苦去掉吧
towardsdatascience.com](/how-to-automate-julia-documentation-with-documenter-jl-21a44d4a188f)
这种自动化文档在 JuliaHub 网站上采用了一种全新而出色的方法。没错，Documenter 基于 web 的文档是自动生成的，甚至更好——由 JuliaHub 免费托管。这是一个革命性的想法，用一种语言为每个库创建一致的、自动化的和简单的文档，所有这些都可以在一个地方容易地获得。不再需要搜索来找到你需要的文档，现在你可以在一个地方以完全相同的格式找到它们！
结论
JuliaHub 是一种有趣且吸引人的方法，可以解决当今文档和包信息的许多问题。尽管 JuliaHub 可能还处于测试阶段，相对来说还不成熟，但很明显，它正在成为开发人员和有抱负的软件工程师的一个很好的工具。不仅如此，通过舒适地将每个软件包上的信息方便地放在一个地方，这无疑使开发新软件变得更加容易。
自从我开始使用 JuliaHub，我也发现自己拿起包裹的速度很快。像 JuliaHub 这样一个简单而包容的环境，提供了一个近乎完美的环境来促进探索和学习——这是我非常欣赏的，因为我是一个知识迷——尤其是在计算机和其他领域；朱莉娅。
Julia 关于名称空间的大问题
作为一名 Julia 开发者，这是一个可能会影响你的重大问题。
(图片由作者提供)
背景
J ulia 是一种现代而年轻的编程语言，自 2018 年 8 月发布 1.0 版本以来，它一直在科学计算界掀起风暴。尽管 Julia 作为一种语言有大量对开发人员有用的奇妙属性，如多态性、极其动态的语法和类型，但由于 Julia 是一种如此年轻且相对复杂的语言，所以很容易理解为什么编程语言会出现一些问题。
为了理解为什么 Julia 不擅长处理命名冲突，我们需要看看 Julian 模块是如何工作的。首先，模块的标准标识符是“module”，所以我们可以创建一个类似这样的模块:
module fizz
function buzz(foo)
return(foo)
endend
这将使一个叫做 fizz 的模块具有一个小时候叫做 buzz 的功能。我们可以通过以下任何一种方式访问 buzz:
using fizzfizz.buzz(foo)using fizz: buzzbuzz(foo)import fizzfizz.buzz(foo)import fizz: buzzbuzz.foo
每当我们进口 buzz 而不含 fizz 时，我们使用的是所谓的直接进口。这意味着我们将只使用这个特定的函数，模块的其余部分不会加载到我们的环境中。这是防止命名冲突的一个很好的方法，因为如果我们只需要来自不同模块的特定方法或结构，那么我们可以相应地获取它们。还应注意“进口”和“使用”之间的区别。每当我们使用“导入”时，我们都是显式地导入模块、函数或类型。这意味着我们计划对它进行扩展。例如，我可以有这样一个调度方法:
module fizz
buzz(foo::Int64) = add_5(foo)
buzz(foo::Bool) = negate(foo)
end
然后显式导入它并为更多类型提供操作:
function add_10(foo)
return(foo + 10)
endimport fizz: buzzbuzz(foo::Float64) = add_10(foo)
当然，这将使得如果一个 float 被用于这个方法，我们将调用我的新 add_10 函数，它被用 dispatch 路由到这个函数。
通常，这些命名约定不容易发生冲突。在直接导入时，我们不太可能会遇到问题，如果我们在冲突出现时没有意识到冲突，这种情况肯定不会发生。然而，您可能会遇到的问题是，大多数 Julia 模块完全遵循函数范式。这意味着它们可能会在导出之上使用导出——这将危及您的个人命名约定。考虑以下模块:
module fizz
buzz(foo::Int64) = add_5(foo)
buzz(foo::Bool) = negate(foo) export buzz
end
导出参数的不同之处在于，现在只要导入模块 fizz，我们就可以直接访问 buzz。请注意，这是大多数 Julia 包的典型约定。
using fizzbuzz(foo)
记住这一点，考虑两个流行的 Julia 模块:
牛虻. jl 和剧情. jl
这两个都是使用 plot()方法的图形库。虽然它们仍然采用完全不同的参数，但这些都是常规函数，而不是调度操作。另一个需要注意的重要事情是，它们都采用了许多关键字参数，这在 dispatch 中几乎是不可能的。这两个方法都是导出的，这意味着每当我们导入它们时，我们毫无疑问会遇到命名冲突。如果我们使用直接的约定，比如使用Plots: plot ，这可能是不正确的，但是如果我们想一前一后地使用两个包，这仍然是一个问题。
另外，如果你想了解更多关于这两个图形库的知识，我写了一些很好的文章，你可以在这两个库上查阅！：
看看朱莉娅对 2020 年统计绘图的最佳选择
towardsdatascience.com](/gadfly-jl-the-pure-julia-plotting-library-from-your-dreams-3ee6ca107a5c) [## 在 Julia 中美化您的 GR 可视化
没错，又是 Julia，我保证 R，Scala，Python 还在这个爱情圈里
towardsdatascience.com](/spruce-up-your-gr-visualizations-in-julia-88a964450a7)
截至 1.5.1 的补救措施
W 虽然作为一门语言，这个问题很难解决，但现在 Julia 中有一些东西可以帮助解决这个问题。首先，在处理命名冲突时，dispatch 将会是一个很好的朋友，它有可能帮助您解决在 Julia 语言中可能遇到的大多数命名问题。然而，正如我在上面提到的，分派带有大量关键字参数的方法是相当困难的，有时甚至是不可能的。因此，尽管派遣可能是避免冲突的较好方法之一，但它肯定不是避免上述冲突的万无一失的方法。
考虑如何避免编程语言中的命名冲突的一个很好的方法是环顾四周，看看其他编程语言是如何避免冲突的。在很多方面与 Julia 非常相似的语言的一个很好的例子当然是 Python。Python 使用可由用户定义的别名来非常有效地避免命名冲突。然而，当我们在 Julia 中查看这个相同的概念时，我们看到虽然别名是可能的，但它仍然不能使我们绕过名称冲突:
**import** Queryverse
**const** qv = Queryverse
虽然这似乎是一个解决方案，但问题仍然存在，因为您已经定义了 Queryverse 及其所有导出的标识符，它们将与以相同名称进入您的环境的新标识符冲突。在这方面，我们可能得到的最接近的方法是显式导入一个特定的方法或类型，然后设置一个与该类型相等的常数。
除了这两个相当简单且不太有用的解决方案之外，真的没有太多的可能来避免命名冲突，就像 Julia 语言中的瘟疫一样。至少据我所知，这两个是预防的最佳选择，但如果你已经在试图解决这个问题，它们不会让你脱离困境。
来自 C++的解决方案
伴随着一些开发人员可能会遇到的这个严重问题，出现了一个非常好的解决方案，Julia 语言有可能从 C++继承过来。C++使用了一个叫做名字间隔的概念，它允许我们总是指示我们想要使用哪个模块，甚至在任何特定的场景中我们想要使用模块的哪个部分。考虑一下 C++中 STD 的例子:
#include <iostream>int main()
{
std::cout <<< 0
}
STD 是名称空间，cout 是包含在名称空间中的函数。这些都包含在我们放在顶部的包中。对于代码中需要调用 cout 的每一点，我们都会调用 std::cout，而不仅仅是 cout。这意味着，如果我们有一个来自不同名称空间的新标识符，比如 foo::cout，我们仍然可以以完全相同的方式使用那个函数。此外，我们还可以在命名空间上调用 using，使对象或函数在全局和局部范围内都可用:
#include <iostream>using std::cout // <- Global Scope
int main()
{using std::cout //<- Local Scope
cout <<< 0 //<- Notice we don't need to use the namespace
}
我认为这将为 Julia 中的 include()方法增加一些扩展的可用性。而不仅仅是能够包含。JL 文件，我们也可以用模块名来调度它。这使得在 Julia 代码中根据它们所在的模块创建名字空间成为可能。Include 可被视为名称空间语法，而 using 仍以其一贯的方式使用。以下是一些理论代码的示例:
include(Gadfly)
using PlotsGadfly::plot(x, y) #< -- This would use Gadfly
plot(x, y) #< -- This would use plots
当前的解决方案
虽然这些关于语言迁移的理论上的建议可能对 Julia 的未来迭代有意义，但重要的是要考虑开发人员现在可能拥有的选项——在 Julia 库之外。这种可取之处当然是以模块的形式出现，这可能有助于避免 Julia 语言中的命名冲突。为此，考虑使用别名避免冲突的 Pythonic 示例。请允许我介绍
ImportMacros.jl
[## fredrikekre/ImportMacros.jl
提供两个宏:@import 和@using，用于加载模块或对象并将其绑定到别名。@导入可以用…
github.com](https://github.com/fredrikekre/ImportMacros.jl)
jl 允许在加载导出之前使用宏创建 Pythonic 别名语法。如果我们在这种情况下使用 Import 宏，我们可以避免在当前范围内定义模块。虽然这不一定适用于导出(因此也不是最好的解决方案)，但是您仍然可以直接调用导出，并相应地为它们起别名。尽管这种解决方案可能不是最好的长期解决方案，但在开发或构想出更好的解决方案时，它可能会让您摆脱困境。
结论
Julia 编程语言做了很多非常棒的事情。虽然这种语言很棒，提供了很多有些人可能从来没有想过的东西，但它也带来了一些问题。重要的是要记住，Julia 作为一种语言是非常年轻的，开源社区每天都在开发它。因此，这种语言肯定会在未来得到改进和发展，但肯定会不时出现问题。
我真的很想看看 C++对名字间距的处理方式，看看如何在 Julia 中解决这个问题会很有趣。就解决方案而言，它可能是最连贯的解决方案之一，也不会改变 1.5.1 中语言核心的功能。
不管怎样，Julia 语言是一个不断扩展和引人入胜的东西，我认为它绝对值得一试。感谢您的阅读，我希望至少这些概念是有趣的！
朱莉娅最令人敬畏的特征
Julia 编程语言中我最喜欢的五个特性。
(茱莉亚 logo src =http://julialang.org，茱莉亚格普 logo src =https://github.com/JuliaGPU)
编程语言的范围包括编程概念和范例。许多语言利用它们的范例以及有趣的泛型编程概念来创建特性，以区别于其他语言。然而，这些特性通常范围有限，有时使用频率不够高，甚至没有存在的理由。
Julia 编程语言是一个有趣的例子，因为与大多数语言不同，Julia 有一些致命的定义特性，这些特性使它能够做各种你可能想不到的事情。虽然 Julia 语言使用了一大堆奇妙的特性，但这是我认为最有用和最吸引人的五个特性。
№1:宏
尽管宏对于编程来说肯定不是一个新概念，但它们在 Julia 中的实现是相当独特的，而且在我看来做得相当好。宏是可以用来快速有效地访问函数的“快捷方式”，在处理 Julia 语言的函数应用程序时非常有用。在 Julia 中，只需使用“macro”就可以定义一个宏。
macro add(num1,num2)
num1 + num2
end
我们可以通过在宏名前添加@符号来使用宏。参数可以添加空格，不需要括号或逗号！
№2:调度
如果您熟悉 Julia 语言，并且相对地使用过它，那么您很可能熟悉 Julia 的高性能调度。使用 Julia 中的语法表达式，我们可以创建不同的函数，这些函数使用参数多态以相同的方法处理不同的类型。为此，我们只需使用等号运算符。
exampledispatch(x::Int64) = _int(x)
exampledispatch(x::Float64) = _float(x)
关于 Julia 的调度，你可能没有注意到一个惊人的副作用，那就是所有的 Julia 函数都可以在任何类型上通用。考虑这个例子:
我想创建一个类型，它使用 push 函数将数据添加到包含在结构中的数组中。
用力！()函数是 Julia 基础的一部分，而在大多数其他语言中，为了避免冲突，我们需要为我们的模块编写一个全新的标识符。使用该语言附带的标准库时尤其如此。但是，在 Julia 中，我们可以只发送 push！()处理我们的类型:
push!(data,x::Type{ihavedatainme}) = _pushdata(data,x)
№3:语法表达
甚至一些 Julia 程序员可能没有意识到这一点，但是语法表达式负责我们如何编写 Julia 代码背后的整个方法。本质上，使用语法表达式，我们可以设置任何表达式或变量等于任何表达式或变量。这也是 dispatch 的工作方式，因为我们所做的只是将一个方法的特定参数类型设置为对应的方法。
然而，除了分派之外，我们还可以通过多种方式使用语法表达式。例如，我们可以将一个方法设置为一个表达式:
如果你想学习更多关于语法表达式的知识，并学习一些很酷的方法，我这里有一篇关于它们的文章:
利用朱莉娅语法的力量来断言任何事情。
towardsdatascience.com](/syntactical-expressions-are-awesome-dc9ba5f25911)
№4:元编程
Julia 以一种非常有趣的方式处理像元编程这样的概念。元编程和类似概念的包通常是分段的，但仍然包含在 Julia 的库中。这使得 Julia 的 base 在预编译时花费的时间少得多，同时仍然加载了令人敬畏的特性。为了在 Julia 中进行元编程，您应该从 Meta.parse()和 eval()这两个函数开始。Eval 包含在 Julia 核心中，不需要导入，而 Meta 是包含在 Base 中的一个模块。
using Base.Meta
评估元表达式的第一步是解析它。这将把一个常规字符串转换成 eval()能够处理的表达式类型。
meta_code = "1 + 1"
expression = Meta.parse(meta_code)
№5:并行计算
(src =https://github.com/JuliaGPU
好的，我明白了…并行计算本身并不一定是一个“特性”，但是 Julia 的并行计算令人印象深刻的是 Julia Computing 在这方面做了多么了不起的工作。与许多其他语言不同，Julia 自带了大量的 GPU 支持。核心的 Julia 语言支持图形数组和处理，这是你在其他地方无法得到的。将并行计算紧密集成到 Julia 中，并使用专门设计的类型和函数来处理它，比在大多数语言中(这是事后才想到的)要强大得多。此外，Julia 拥有各种用于并行计算的优秀包，以及 CUDA 和 OpenCL 等行业标准。
结论
Julia 编程语言有一大堆令人难以置信的特性，这些特性绝对让使用这种语言物有所值。有了所有独特的解决问题的方法，很少有时候你不能用这种语言创造性地完成一些事情。除此之外，Julia 还拥有它通常所拥有的所有优势。这些是我最喜欢的，但是我也想知道其他程序员喜欢这种语言的什么。(想分享就留言评论吧！)
朱莉娅的包装经理棒极了
为什么 Julia 的 Pkg 是我用过的最好的软件包管理器。
(http://julia-lang.org/和达塔沃基)
在过去的中，我对令人惊叹的多范例统计语言 Julia 赞不绝口。这是有充分理由的，因为 Julia 是一种令人难以置信的高级语言，它扩展了我们认为可能来自这种高级语法的限制。此外，就机器学习的理想性而言，从我使用四大的次数来看，Julia 完全能够超越 Python、R 甚至 Scala。我甚至开玩笑说要在我的头上纹一个朱莉娅的纹身，甚至要对那个东西进行半真实的渲染:
看起来很棒，不是吗？
但是对于我一直以来最喜欢的编程语言之一的炫耀，我忽略了一个让 Julia 变得更好的特性:
包装
Pkg 是 Julia 的包管理器，它不是 Python 或 r 中常见的那种典型的包管理器。事实上，在大多数情况下，我坚信 Julia 的包管理器胜过我用过的所有 Linux 包管理器，包括 Dnf、Apt、Man，可能还有最健壮的:Pacman。有几个关键的好处使得用 Pkg 包管理器管理 Julia 中的包变得轻而易举，你可能会说
“它能做到吗？”在某个时候。
REPL 和包裹
Pkg 的一个巨大好处是它有自己的读取评估打印循环，或 REPL。这是有益的，原因有几个，首先我想提到的是，它可以比库等价物更快地添加包。这是因为它可以简单地通过按键完全跳过重新编译陈旧的缓存文件，
]
此外，这允许非语法的包添加，使得只需一个命令和一个空格就可以超级快速和容易地添加包:
add "Lathe"
然而，除了有一个 REPL，Julia 的 Pkg 也以 Julia 包本身的形式出现。这很有用，因为这意味着您不仅可以从 REPL 中添加包，还可以添加代码本身。每当我创建 TopLoader 时，这就特别有用，这是一个 Python 包，允许你创建一个虚拟的 Pkg 环境，然后使用添加到该环境中的包。
Github 集成
(src = http://github.com/)
Julia 的包管理器完全基于 Github，包被推送到 Registrator.jl 库，你可以在这里看一下。
(src =https://github.com/JuliaRegistries/Registrator.jl
这不仅使得通过 Github 推送您的 Julia 包变得非常容易，还允许您添加带有 Git URLs 的未注册包。这使得通常存储在 Git 兼容的存储库中的未发布的软件总是可用的。Julia 的包使用 Github 作为开发的基础，这当然不是一个坏主意，因为即使是非开发人员也很清楚开源开发本质上是围绕 Github 进行的。
虚拟环境
生活中有许多问题尚未得到解答，但一个古老的问题是
“谁的环保做得最好？”
肯定已经有答案了。与 Pip、Package get、Quick Lisp 和数以千计的其他软件包管理器(也称为“Pkg”)相比，Julia 的 Pkg 再次在竞争中脱颖而出。从一开始，您就可以通过 REPL 的两个简单命令或软件包中的一个方法来激活虚拟环境。
using Pkg
Pkg.activate("venv")julia> ]
pkg> activate "venv"
这使得管理和利用这些虚拟环境变得异常简单。如果不与 Julia 的竞争对手之一 Python 的类似选项进行比较，很难证明这种激活虚拟环境的方法是正确的。Python 的包管理器是 Pip，虽然肯定不如 Pkg 健壮，但我认为 Pip 肯定经得起时间的考验，并在 Python 中完成了工作。但是要为 Pip 激活一个虚拟环境，你需要安装一个全新的包，就是 venv，或者类似的东西(有几个不同的选项。)
sudo pip3 install virtualenv
python3
python3 -m venv venvname
这当然并不可怕，但是从另一方面来说:肯定没有 Julia 等价类那么健壮和简单。重申一下我的 Python 包，它用于在虚拟环境中加载 Julia 模块，开发这个包非常容易，因为我能够使用 activate()方法。
结论
我喜欢 Julia 的 Pkg，我向那些努力开发它的开发人员致敬，他们只是为了让 Julia 的编程体验变得更好。我认为许多其他的包管理器有很多东西要向 Pkg 学习，因为对我个人来说，它一直感觉像是完美的包管理器。我鼓励您尝试一下，因为它感觉像是充斥着 CLI 软件包管理器的世界中的一股新鲜空气。总的来说，我认为 Pkg.jl 为 Julia 做出了很大的贡献，并且使这种语言变得更加有趣。
七月版:嘿 Siri，我是什么意思？
月刊
自然语言处理与人工智能的未来
到目前为止，我们中的许多人已经与设备的内置助手进行了交互。可能是故意的，甚至是说“你是认真的吗？”离 iPhone 太近了。无论是 Alexa，Siri，还是你喜欢的智能设备中的任何人；它使用自然语言处理(NLP)结合语音识别来理解你，为你的问题提供适当的答案，有时甚至进行学习。但是 NLP 到底是什么？很简单，它是一台试图解析、构建和总结文本的机器，就像人类“自然”会做的那样说话或写作。NLP 为许多人经常使用的人工智能提供了实际用途。
那么，它是如何工作的呢？NLP 成功的关键在于深度和递归神经网络。深度神经网络(DNN)和递归神经网络(RNNs)使用数万个单词和句子进行训练，以便在对它尚未看到的短语进行测试时最准确地预测反应。你可以在这里阅读更多关于深度神经网络。与许多机器学习算法一样，DNNs 和 RNNs 在用于预测时也有其缺陷。例如，当你想输入“我要一个奶油奶酪百吉饼”时，你的手机可能会建议你喜欢奶油苍蝇百吉饼或类似于奶酪的按键。随着 NLP 的改进，这些预测也会随之改进。
不管你是在使用智能助理、自动电话菜单，还是只是尝试输入信息，NLP 都被用在我们每天做的许多事情中。
想了解更多关于自然语言处理的知识吗？以下是我们关于这个主题的一些最受欢迎的文章！
索菲·曼，编辑助理
自然语言处理实践指南(上)——处理&理解文本
由迪潘詹(DJ)萨卡尔 — 31 分钟阅读
经过验证和测试的解决 NLP 任务的实践策略
如何用深度学习为任意对象创建自然语言语义搜索
这是一个端到端的例子，展示了如何构建一个可以在语义上搜索对象的系统。
用 Python 进行模糊字符串匹配的自然语言处理
由苏珊李 — 5 分钟读完
当我们比较不同网站的酒店房价时，我们必须确保我们是在进行比较
文本自然语言处理简介
由文茨斯拉夫·约尔达诺夫 — 16 分钟阅读
读完这篇博客后，你会知道一些从一些文本中提取特征的基本技术，所以你可以使用这些特征作为机器学习模型的输入。
您的自然语言处理(NLP)指南
由迭戈·洛佩兹伊塞 — 13 分钟阅读
机器如何处理和理解人类语言
自然语言处理:从基础到使用 RNN 和 LSTM
由 vibhor nigam — 11 分钟阅读
对自然语言处理领域中流行的所有概念的详细介绍
德雷克——用自然语言处理理解他的歌词
由布兰登·彭图罗 — 8 分钟读完
我们知道德雷克的作品很受欢迎，但为什么他的大多数歌曲如此受欢迎呢？是制作的原因吗？是市场营销吗？
新视频
- 前瞻优化器:向前 k 步，向后 1 步| Michael Zhang
- 引入带有 Rayshader 的 3D gg plots|Carrie Lo
- 3 个策略(成功地)转换到蓬勃发展的数据科学职业 | Haebichan Jung
- 创建有效的行业-学术人工智能合作伙伴关系| Darin Graham
- 用基尼系数衡量统计离差 | 金佰利·费塞尔
- Zynga 的生产深度强化学习| Patrick Halina&Medhi Ben Ayed
- 灵活的实体解析框架| Hoyoung Jang &程林
- Python 中线性混合模型(LMM)的贝叶斯方法 | 爱德华多·科罗纳多·斯罗卡
新播客
- Max Welling — 机器学习的未来
- 肖恩·纳普— 数据工程勇敢的新世界
- Matthew Stewart，博士研究员——环境科学中的数据隐私和机器学习
- Nick Pogrebnyakov — 路透社的数据科学，以及冠状病毒之后的远程工作
我们也感谢最近加入我们的所有伟大的新作家 K .德尔菲诺、迪夫扬舒·马尔瓦、卢克·瓦瑟、因内克·马亚契塔、陈琦程、斯科特·罗戈夫斯基、多·李、吉伊斯·范·登·多尔、米尔科·萨瓦斯塔、克莱尔·萨尔 保罗·斯图布莱、维多利亚·张、马切伊·德·科尔泽克、卡兰·普拉哈拉杰、阿普茹瓦·乔希、埃洛德·帕尔·奇尔马兹、伊恩·何、乌古尔·厄塔斯、约翰·麦卡利斯特等众多。 我们邀请你看看他们的简介，看看他们的工作。
六月版:机器中的偏见
人工智能和机器学习模型中的公平性、偏见和可解释性
随着机器学习应用变得越来越广泛，人们对实现算法来转变通常的业务流程以实现效率产生了极大的兴趣。从贷款审批到司法判决，消费者和公民面对黑箱模式的现实，成为我们生活中一些最重要决策和事件背后的最终仲裁者。理解我们创建的模型中的偏见和公平问题，并确保它们不会产生意想不到的和/或歧视性的结果，变得比以往任何时候都更加重要。
在数据科学中，机器学习偏见没有得到很好的解决，甚至没有得到很好的理解。但研究人员和其他从业者已经采取措施，强调减少偏见来源并找到解决方案以防止由此造成的伤害的重要性。下面的文章是我们关于偏见、公平和可解释性的最佳故事精选。我们希望它们能丰富您的理解，并在您遇到自己的模型中的偏差时作为最佳实践的资源。
《走向数据科学》的编辑埃利奥特·冈恩。
什么是 AI 偏见？
凯西·科济尔科夫(Cassie Kozyrkov)—4 分钟阅读
人工智能偏见问题始于定义，但并未结束。“偏见”是一个被过度使用的术语，在不同的上下文中，它的意思是非常不同的。
用合成数据减少 AI 偏差
亚历山大·沃森 — 5 分钟阅读
生成人工记录以平衡有偏差的数据集并提高整体模型准确性
解释公平的措施
由斯科特伦德伯格 — 11 分钟阅读
通过将现代可解释的人工智能方法应用于公平测量，避免机器学习中公平度量的黑盒使用。
可解释的机器学习
通过 Parul Pandey — 10 分钟阅读
从任何机器学习模型中提取人类可理解的见解
可解释机器学习指南
马修·斯图尔特博士研究员——28 分钟阅读
破除深度学习黑箱神话的技术。
可解读人工智能或者说我是如何学会了不再担心和信任人工智能
由 Ajay Thampi — 13 分钟阅读
构建健壮、公正的人工智能应用的技术
算法偏差的算法解决方案:技术指南
由 Joyce Xu — 16 min 阅读
我想谈谈减轻算法偏差的技术方法。
新论文:塑造行为的激励机制
瑞安·凯里和埃里克·朗罗伊
因果模型如何描述代理人的动机。
新视频
- 爱德华多·科罗纳多——不要害怕非参数主题模型
- 洛根·杨 — 为什么是 s 形:一个概率视角
- 谢尔登·费尔南德斯和迈克尔·圣·朱尔斯— 富有影响力的解释
- Nick Frosst — 可证明对敌对攻击的鲁棒性；有什么意义？
新播客
- Bahador Khalegi — 可解释的人工智能和人工智能可解释性
- Roland Memisevic — 能看能听的机器
- Denise Gosnell 和 Matthias Broecheler — 你真的应该学习一下图形数据库。原因如下。
- Rubén Harris — 学习和寻找检疫工作
我们也感谢最近加入我们的所有伟大的新作家让-马蒂厄·舍尔策、拉维·查兰、阿图尔·尤尔加斯、阿尤什·塔库尔、布兰登·洛克哈特、迈克尔·达茨、马特·马切耶斯基、舒尼特·哈威夫·哈基米、君特·罗赫里 塞巴斯蒂安·沙尔、詹卢卡·金德罗、阿克塞尔·泰韦诺、马特·布里顿、弗洛里安·韦特肖雷克、托马斯·汐宫光·克拉克、克里斯多夫·吕克、蒲进以及许多其他人。 我们邀请你看看他们的简介，看看他们的工作。
朱诺让朱莉娅写作变得很棒
用于 Julia 的基于原子的 IDE
(http://junolab.org)
除非你一直生活在岩石下，或者根本不为计算机编程，否则你很可能听说过 Atom。Atom 是一个简单、可扩展、漂亮的开源文本编辑器，可以在 Linux、Windows 和 MacOS 上使用。应该注意的是，Atom 本身并不是一个集成开发环境，而仅仅是一个文本编辑器。
Atom 对我来说是一个很棒的文本编辑器，因为它很现代，看起来很好，而且高度可扩展和可调整。Atom 提供了为替代语言应用主题、扩展和语法突出显示所需的所有工具，这些工具都内置在它们的 UI 中，并由免费和开源开发人员开发的扩展库提供服务。在方法论上，这与 Linux 的发布方式非常相似，所以这确实是我的拿手好戏。Atom 在没有任何扩展的情况下，对于所有语言都有很高的终端窗口能力，但是通常安装扩展会突出语法。然而，在 Juno 中，我们得到的不仅仅是简单的语法突出显示。
(http://julialang.org/)
J ulia 是一种高级的、多范例的统计语言。Julia 也是开源的，与 r 等其他统计语言相比有很多优势。虽然 Julia 大部分是函数式的，但与 Lisp 一样，它也可以用于通用目的。Julia 是一种拥有如此高级语法的相对快速的语言。速度通常稍慢，但在某些情况下实际上可以超过 C。当然，这是非常罕见的情况，这种观察有许多变量，因为它是在使用 IPython magic timers 的 Jupyter 内核中测试的，但即使接近 C 的速度也使 Julia 比 R 和 Python 更有优势。此外，Julia 拥有出色的浮点精度，这也让 Julia 领先于 Scala。
Julia 可以成为你的“大数据”语言
(http://junolab.org/
原子+朱丽亚拼图的最后一块是朱诺。Juno 把 Atom 这个简单的文本编辑器改造成了 Julia 的全功能 IDE，真的太牛逼了！Juno 具有许多特性，这些特性使 Julia 成为我在 Atom 内部编写的最令人愉快的语言。
取代
Juno 拥有许多其他扩展所没有的东西:
REPL
您可以通过 Atom 访问 Julia 的 Read Evaluate Print 循环(REPL ),从而方便地包含和编译您的程序。随着朱莉娅 With 的加入，朱莉娅变得非常强大，甚至对于常规软件开发也是如此。
远程过程
您不仅可以通过常规的 REPL 处理 Julia，还可以启动与 Julia 交互的远程进程。这是一个非常棒的特性，因为它将 Atom for Julia 变成了一个现代的 IDE，而不仅仅是一个带有输出窗口的简单 IDE。
格式化
Juno 还附带了一个完全自动化的格式化工具，该工具完全可以通过 Atom 内部的菜单栏来访问。这很有用，因为它创建了一个一致的代码风格，所有 Julia 用户都可以与之交互和阅读，但仍然允许您最初以自己的风格编写 Julia。
运行块
我非常喜欢 Juno 的另一个特性是运行 Julia 块的能力。这可以使体验与 REPL 高度互动，使 Julia 编程体验更像在笔记本内工作。
设置
Juno 设置的包容性令人惊讶。从“设置”菜单中，您可以调整路径、线程数和 Julia 引导模式。Julia 引导模式是一个概念，在这个概念中，您可以让您的 ide 根据您使用的是远程 Julia、集成终端还是外部终端来设置单独的运行时，甚至可以设置一个循环模式来保持所有三个 Julia 进程始终运行，以便加快 IDE 内部的运行速度。另一个很酷的特色是优化级别，虽然优化是拼写
最佳化
在设置中。
优化允许您选择，无论是永久地还是暂时地，您希望编译有多快，以及您希望您的代码有多快。当然，这也非常有用，尽管我不怎么用它，因为我在 Julia 中工作时一般不会遇到性能问题。Julia 中性能最差的部分是过时的缓存文件重新编译，它:
在部署中不是问题。
虽然使用 Genie 确实会使服务器启动时间有点慢，但通常“有点慢”只是大约一分钟。
打开包裹
Juno 还允许您在新窗口中立即打开任何安装了 Pkg 的软件包，让您轻松地根据自己的喜好调整软件包。对于该特定功能，我唯一想做的更改是在没有 REPL 的情况下使虚拟环境更易于管理，这可能与该功能有关。但这并不是说首先很难从 REPL 激活虚拟环境。用 Pkg 激活一个环境只需要 3 个命令，包括]和初始化 Julia。
或者，你也可以
using Pkg;Pkg.activate("dev")
原子底部的 REPL 内部。
文档浏览器
Juno 的另一个很酷的特性是能够从 Atom UI 中快速查找文档。这当然不是什么新鲜事，因为 Julia 在处理文档方面做得非常好。对于大多数包，使用？()函数将打印出所述包的文档——使得访问文档网站成为一种不同语言要处理的事情。
结论
我真的很喜欢并感谢大家为 Atom 在 Juno 上付出的努力。我每天都使用 Atom 作为我的文本编辑器，还有 Gedit 和 Nano，在我实际使用的文本编辑器中，我最喜欢的语言得到如此多的关注真是太棒了。我也很高兴他们决定在 Atom 上支持 Julia，而不是构建他们自己的 IDE。这不仅需要更多的资源，还需要在热键和设置方面的新的学习体验，需要处理的新的用户界面，以及回收的文本编辑应用程序的额外磁盘空间。总的来说，我对 Juno 的结果非常满意，尤其是它让 Julia 的开发变得如此容易！
Juno vs . Jupyter——Julia 的开发环境哪个更好？
意见
比较我在数据科学中最常用的两个 ide。
(I Julia logo src =https://github.com/JuliaLang/IJulia.jl，Juno logo src =https://junolab.org/)
影响编程效率的最重要因素之一是您的开发环境。对于数据科学来说尤其如此，因为数据科学家更经常需要在执行作为应用程序一部分的任何代码之前分析和处理数据。拥有一个适合你的好的设置意味着在一小时或一整天内完成一件事的区别。
通常，在讨论 Julia IDE 的数据科学时，有两个主要选择:
伊茱莉亚和朱诺。
伊朱丽亚
IJulia 是 Julia 的 Jupyter 内核，可以用 Pkg 添加:
Pkg.add("IJulia")
优势
Jupyter 笔记本电脑具有许多优于 Juno 的优势。首先，细胞水平的执行棒极了。使用单元格，您可以选择何时运行哪个代码，甚至可以避免运行某些单元格来获得某个结果。此外，Jupyter 输出相当方便，易于处理。
使用笔记本的另一个好处是可以使用 IJulia 的“神奇”命令。虽然这些在技术上并不是“神奇的”命令，而是从 IJulia 导出的 Julia 函数，但它们确实是紧急情况下手头上的一个好东西。最重要的是，使用宏来运行 bash 命令要比困在 REPL 中，像在 Juno 中一样打开第二个终端窗口好得多。
然而，在我看来，使用笔记本电脑的最大优势之一可能是
再现性。
笔记本是教学和传播信息的好工具。如果能够为带有解释的大块文本添加标记单元格，就更是如此。这就是为什么我通常使用笔记本来演示我在 Medium 上的文章中的想法和代码，尽管主观上我更喜欢使用 Juno。
不足之处
在 Jupyter 内核中调试软件包可能非常困难，因为每当需要从 Jupyter 内核中重新加载软件包时，内核都需要重新启动，所有代码都需要重新执行。
与运行一个简单的 Julia 可执行文件相比，内核也是相当费力的。这不仅会导致性能下降，而且在使用 Jupyter 笔记本电脑时，多任务处理也会变得相当困难。最重要的是，杀死一个内核比超时一个 REPL 要容易得多，所以总是有可能遇到不先去 REPL 就无法执行的代码。
使用 Jupyter 的最后一个缺点是你的代码会被保存在笔记本里。虽然这既是一种祝福，也是一种诅咒，但任何不使用笔记本的人都可以感受到这种诅咒。对于任何不从事数据科学的人来说，笔记本可能是一个完全陌生的概念，这意味着您的代码无法到达更多的受众，同时也相当有限，直到它被复制到一个独立的 JL 文件中，或者保存为一个文件。
朱诺
Juno 是 Julia 的集成开发环境，可以作为 Atom 文本编辑器的扩展添加。您可以添加 Julia，方法是进入 Atom 菜单栏中的编辑>首选项，然后选择扩展并搜索“Juno”
优势
拥有一个朱莉娅·REPL 是一个非常强大的工具。使用朱莉娅·REPL，你还可以访问 Pkg REPL，这比导入 Pkg，预编译 Pkg，然后使用 Pkg 方法要方便得多。此外，由于更加关注本地文件系统，管理虚拟环境和。jl 文件变得容易多了。
Juno 的另一大优势是“Plots”窗格。“Plots”窗格从 Julia 获取任何图像输出，并将其放入 iframe 中。这非常方便，因为您可以实时缩放图形。此外，当前会话中使用的所有图都保存在此窗格中，使浏览数据可视化变得毫不费力。
Juno 的另一个优点是启动新会话非常容易。正如我在使用 IJulia 的缺点中提到的，不断地重启内核是非常乏味和烦人的。使用 Juno，您可以通过按 ctrl+D 快速重启 Julia 会话，并出现中断异常。
在 Juno 中，您还可以使用“Documentation Browser”窗格，它提供了一个灵活的 UI 来搜索所有添加的包的 Julia 文档。
另一个很酷的功能是自动格式化。在 Juno 中，您可以随时通过单击 Juno >格式化代码来突出显示和格式化您的代码。最重要的是，您可以执行单个代码块，这使得利用包含 Julia 代码的文本缓冲区变得非常方便。
锦上添花的是，您还可以从 Juno 内部启动远程 Julia 进程。
不足之处
虽然这对我来说肯定不是一个缺点——因为我喜欢 Atom，而且它是我的首选文本编辑器，但那些喜欢 VSCode 或其他替代产品的人可能会觉得使用 Juno 需要 Atom 有点烦人。我可以肯定地看到，对于那些以前没有使用过 Atom 的人来说，Atom 可能需要一些时间来适应。
让我们面对现实吧——在 REPL 中输入函数远不如在文本缓冲区中输入函数方便。虽然把你所有的功能都输入朱莉娅 cell 肯定是可能的，但这肯定比把它们输入一个 Jupyter 单元格要慢。此外，您将失去复制和粘贴的能力。您可以通过将函数放入 Atom 文本缓冲区内的. jl 文件来缓解这个问题，但是每次添加或修改函数时，您都必须包含()或重新运行文件。
结论
Jupyter 和 Juno 都是不可思议的工具，在很多方面，他们都有不足和进步。我希望朱诺拥有朱庇特拥有的许多东西，朱庇特拥有的许多东西我也希望朱诺拥有。总的来说，我不认为这是一个“什么”的问题，而是一个“什么时候”的问题。我认为有些情况下 Juno 是更好的选择，有些情况下 Jupyter 是更好的选择。就我个人而言，我更喜欢使用 Juno，因为它具有惊人的多功能性。在 Jupyter 中开发软件包相当困难，但是在 Juno 中进行数据分析却非常有效。然而，这并不是说我不愿意使用 Jupyter 进行数据分析，而相应地使用 Juno 进行软件包分析，事实上，我通常就是这么做的。
显然，Jupyter 在我的信息性文章中对我也非常有用。首先演示，其次分享我的作品会困难得多。jl 文件和 REPL 会议。Jupyter 最大的缺点可能是死内核，Juno 最大的缺点可能是可重复性。总的来说，在很多方面，我认为你使用的工具可能与你想要做的事情密切相关。
朱庇特和马克登
无论您是与朋友和同事分享您的 Jupyter 笔记本，还是更广泛地发布它们，如果它们布局合理、格式正确，将会更受欢迎。
作者图片
您可以在 Jupyter 笔记本代码中添加注释，以帮助读者了解您在做什么。但是较长的注释最好放在与代码分开的文本单元格中。
Jupyter 中的文本单元格支持 Markdown 语言，我们将看看它提供的功能。Markdown 是一组简单的标记代码，可以很容易地转换成 HTML 以便在浏览器中呈现。Markdown 远没有 HTML 那么复杂，但是对于记录一个笔记本来说已经足够了(尽管如果你需要对外观或布局有更多的控制，也可以嵌入 HTML)。
这篇文章最初是用 Markdown 写的(本文末尾有原文的链接)，第一段和两个标题是这样的:
# Jupyter and Markdown
## Making your Notebooks look good
Whether you are sharing your Jupyter Notebooks with friends and colleagues or publishing them more widely, they will be better appreciated if they are well laid out and formatted.
很简单。#位于相当于 HTML 中的
的标题之前，其中两个表示二级标题
。#符号越多，标题越小。
因此，下面的 Markdown 代码将显示一个标题列表，其大小逐渐减小。
# heading 1
## heading 2
### heading 3
#### heading 4
##### heading 5
###### heading 6
作者图片
Markdown 支持最常见的样式，如粗体和斜体，您可以构造带编号和不带编号的列表。您可以在段落中嵌入代码或显示完整的代码块。包括超链接，你也可以插入图像。表格可以用非常简单的语法用左对齐和右对齐的列来构造。
Markdown 忽略单行分隔符，因此要分隔段落，需要插入两个换行符。
下面我们来看一些降价代码的例子。对于每个示例，我将向您展示 Markdown 代码，然后按照它呈现后的样子进行操作。
内嵌标记—代码，粗体和斜体
首先，我们来看看一些简单的内联标记。
下面是代码，下面是渲染版本:
This is a paragraph that illustrates some of the Markdown features.
This is a new paragraph that includes some code: `print(123)` you can see that it is enclosed in single back ticks. Other simple markup is *italic which is enclosed in asterisks* and **bold which is enclosed in double asterisks**.
作者图片
您可以使用单下划线或双下划线将文本变为斜体或粗体。所以，通过混合下划线和星号，你可以得到既斜体又
You can also use an _underscore to make things italic_, or two of them for __bold__. This means you can have both _**italic and bold**_ text.
作者图片
大宗报价
块引号前面有一个 v 形符号。
> To include a block quote you precede it with a `>`
作者图片
代码块
如果要包含代码块，请使用三个反斜杠或~字符将代码括起来，如下所示:
~~~python
for i in (1,2,3):
print(i)
~~~
或者这个
```python
for i in (1,2,3):
print(i)
你会得到一段代码，可能是彩色编码的:
作者图片
请注意，使用编程语言这个名称是可选的，尽管它不是 Markdown 规范的一部分，但大多数渲染器中都包含了颜色编码。
# 列表
有序列表和无序列表都有。无序列表中的项目前面有一个星号、减号或加号:
- item
- item
- item
这看起来像
* 项目
* 项目
* 项目
子列表只是缩进一个空格:
- item
- item
- item
- item
作者图片
编号列表以一个数字开始，后面跟着一个点，你猜对了。你可以混合搭配有序列表、无序列表和子列表。
1. item
2. item
3. item
- item
- item
4. item
作者图片
# 形象
图像通过其路径或 URI 来引用。要包含一个图像，该行以一个感叹号开始，后跟一对方括号，用于放置 alt-text，然后是一对大括号，包含图像路径和一个字符串，当您将鼠标悬停在图像上时会显示该字符串。
e/raw/master/src/common/images/icon48.png “Markdown Logo”)
图片由亚当·普里查德提供
# 链接
链接看起来与图像相似，只是方括号中的文本是实际的链接文本。
Here is a link to [Google’s](https://www.google.com “Google’s Homepage”) home page.
其呈现为:
这里有一个到谷歌主页的链接。
# 桌子
在表格中，各列用管道字符(|)分隔，标题后是一行破折号，然后其余的数据逐行排列，如下所示:
| Col1 | Col2 | Col3 |
|---|---|---|
| Data1 | Data2 | Data3 |
| Data1 | Data2 | Data3 |
| Data1 | Data2 | Data3 |
| Data1 | Data2 | Data3 |
作者图片
您也可以通过在标题下划线中放置冒号来对齐列。右边的冒号表示右对齐，左边的冒号表示左对齐，两边各有一个冒号居中。这里有一个例子:
| Left aligned column | Centered column | Right aligned column |
|---|---|---|
| Bold data | Italic data | Normal data |
作者图片
正如您所看到的，表格中的条目可以加粗或斜体。
代码的布局不一定要整洁，Markdown 会整理出来。上表的这个乱七八糟的版本被渲染的一模一样。
| Left aligned column | Centered column | Right aligned column |
|---|---|---|
| Bold data | Italic data | Normal data |
作者图片
# 嵌入式 HTML
如果 Markdown 不完全符合您的要求，您可以添加任何您想要的 HTML。
Here’s a bit of Markdown text. Can you see the difference between
Markdown bold and HTML bold?No, you can’t because it’s the same!
这是一小段降价文字。你能看出 **Markdown bold** 和 **HTML bold** 的区别吗？
不，你不能，因为这是一样的！
# 水平线
最后是一条水平线。只需在一行上单独键入三个破折号
(媒体编辑器里没有横线但是我相信你可以想象出一条！)
# 你还想要什么
我认为这足以让你的笔记本成为吸引人的可读文档。
由于 Medium 不支持 Markdown 可以做的所有事情，我在很大程度上依赖于图像。但是，如果你想看这款笔记本的原始版本，你可以查看或下载，点击[这里](https://github.com/alanjones2/Article-code/blob/master/markdownref.ipynb)。
如果您想了解未来的文章，请订阅我的免费 Technofile 简讯[。](https://technofile.substack.com)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
