Julia 及其在数据科学中的用途
作者:扎卡里亚斯·沃尔加里斯
Julia 是一种相对较新的编程语言，由麻省理工学院的一组研究人员为数据科学开发。不像其他擅长利基用例的编程语言，Julia 是一种面向各种应用程序和更多受众的多用途语言。最近，随着越来越多的包进入 Julia 生态系统，它在数据科学中的有用性变得更加明显。
Julia 是一种很好的通用编程语言，因为它有六个要点。首先，它轻便高效。为了运行相对复杂的 Julia 脚本，您不需要拥有最先进的机器。事实上，在一些用例中，Julia 使用了非常轻量级的计算机，比如微型计算机，来实时执行计算密集型操作。这在新数据科学和数据工程中特别有用，因为它允许更好地利用现有资源。
Julia 的另一个优势是可伸缩性。很难高估这种优势的价值，尤其是。在当今的大规模数据世界中。Julia 不需要大数据框架来扩大规模。向运行 Julia 的系统添加更多的资源，并在 Julia 内核上运行必要的命令，可以让您的脚本以相当直接的方式进行扩展。不用说，这对数据科学至关重要。
Julia 也是一种多调度语言。这允许它有更直观的函数名，可以处理多个任务，这取决于您给它们的输入。因此，您可以拥有一个可以处理所有变量的函数，而不是拥有一堆相同函数的不同变体，每个变体都专用于一组特定的参数，Julia 可以选择最适合您提供给该函数的参数的方法。这使得函数池更容易理解和记忆，可以在数据科学项目中使用。
与其他一些语言不同，Julia 与开发人员和数据科学家中流行的现有编程语言集成得很好。比如你可以通过 Julia 调用一个 C，Python，R 脚本。这使得将 Julia 集成到您的工作流中变得更加容易，促进了整个数据科学管道。
此外，Julia 是一种高级语言，使得理解和管理 Julia 脚本更加容易(即使您不是这种语言的专家)。这与这种语言的另一个优势联系得很好，那就是它的易学性。如果您的团队中有数据科学家需要为某个特定项目学习它，这一点尤其重要，一般来说，完成这一任务不需要花费太多时间或资源。
正如我们之前提到的，Julia 是一种高性能语言。在相应的图形中可以看到，其性能与计算机科学中使用多年的低级语言 C 和 Fortran 不相上下。这一点怎么强调都不为过。Julia 与难以编写代码的语言不相上下(这通常是那些学习编程多年的软件开发人员所做的事情)。然而，用这种语言创建原型是相当容易的。因此，Julia 解决了两种语言的问题，当涉及到数据科学应用程序时，您可以使用一种语言(通常是 Python 或 R)创建 PoC，而使用另一种语言(通常是 C++或 Java)在生产中实现它。
朱莉娅吸引了科学界和工业界的许多人。这导致了包和库的开发，它们与用低级语言编写的包和库一样高效。因此，毫不奇怪，Julia 社区正在迅速发展，它已经成为跨不同行业的灵活工具。它会成为下一个数据科学语言吗？很有可能。你会从中受益吗？嗯，那主要取决于你。
如果你正在寻找一种直接的方法来学习如何在数据科学中使用 Julia，我教了一门 8 周 50 小时的课程。点击此处查看更多详情。
七月版:深入 ML 应用
探索当今 ML 应用的 5 篇文章
读者们——新的一个月又开始了。上个月，我们一直在关注如何做，以及关于可视化和指南的有用文章。这个月，我们决定研究机器学习的一些令人惊叹的应用。
从天气，到医学和房地产，再到游戏建议，这里有一些关于人工智能应用的新文章！
通过智能游戏推荐提高用户参与度
Andre Tan 讲述了在 Playphone 等手机游戏发行公司构建推荐引擎的过程。他解决了非主动用户的问题，以及建议用户尝试相关游戏的方法如何对游戏商店的成功至关重要。
AI 如何做你的营养师，预防糖尿病
糖尿病是一种主要的健康负担，影响着全球 8.5%的成年人口，其并发症包括中风、心脏病发作、肾衰竭和视力丧失等。餐后血糖反应- PPGR -是 2 型糖尿病的主要危险因素，并且在个体之间差异很大。仍然没有现有的方法可以准确预测 PPGR，目前的模型仍然依赖于碳水化合物计数，这不能提供良好的预测。在本文中，关朝聪利用机器学习解决了这个问题。
房地产摇钱树
利用轻松获取关于位置、我们如何移动、我们停留多久、我们支付多少以及我们的感受的数据， Easy Atlas 通过三个案例场景:1) 在巴黎开一家咖啡馆，2) 在上海投资住宅房地产，以及 3) 在纽约市开设一家夜总会，来展示数据如何帮助我们做出这些决定。
挖掘社交媒体通知雾霾应对
为了应对森林和泥炭地火灾或烟雾事件，灾害管理机构需要火灾热点信息以及基线信息，例如受影响人口的估计和可用设施的数据。Jakarta Pulse Lab与卡塞尔大学的研究人员合作，测试社交媒体帮助应对雾霾的潜力。
Stock2Vec —从 ML 到 P/E
在本文中，Jon Perl 使用机器学习算法 Word2Vec 尝试对股票市场中的类似公司进行分组。
我们也感谢最近加入我们的所有伟大的新作家埃文·贝克、那华·康、马尼什·沙布拉尼、米歇尔·格林、普拉那瓦西亚尼 G 、奥菲尔·萨姆森、安德鲁·皮尔诺、杰罗姆·萨姆森、李·施伦克、马库斯·奥贾拉 杰森·科瓦尔、罗布·托马斯、阿瑟·格雷顿、肯尼·琼斯、李·罗布、埃里克森、越武、约翰内斯·里克、拉维·谢哈尔、阿尼什·辛格·瓦利娅等众多。
Inês Teixeira。
七月版:文本理解
8 篇必读文章
自然语言处理从业者指南
由迪潘然(DJ)萨卡尔 — 31 分钟阅读。
非结构化数据，尤其是文本、图像和视频包含了丰富的信息。然而，由于处理和分析这些数据的固有复杂性，人们通常不会花费额外的时间和精力从结构化数据集冒险出来分析这些非结构化数据源，这可能是一座潜在的金矿。
如何用深度学习为任意对象创建自然语言语义搜索
通过哈默尔侯赛因 — 13 分钟读取。
现代搜索引擎的力量是不可否认的:你可以随时从互联网上获取知识。不幸的是，这种超级力量并非无处不在。在许多情况下，搜索被归为严格的关键字搜索，或者当对象不是文本时，搜索可能不可用。
使用 Scikit-Learn 进行多类文本分类
由苏珊李 — 11 分钟读完。
文本分类在商业领域有很多应用。例如，新闻故事通常是按主题组织的；内容或产品通常按类别进行标记；用户可以根据他们在网上谈论产品或品牌的方式进行分类…
将机器学习模型嵌入 Web 应用
由查敏·娜琳达 — 12 分钟读完。
学习数据科学的最佳方式是实践，没有其他选择。在这篇文章中，我将反映我如何开发一个可以将电影评论分为正面或负面的机器学习模型，以及如何将该模型嵌入到 Python Flask web 应用程序中。
谁在椭圆形办公室发推特？
由格雷格·拉弗蒂——18 分钟读完。
我开发了一个推特机器人@ who sintheval，它转发唐纳德·特朗普的每一条推文，并预测这条推文是由特朗普本人还是他的一名助手写的。请务必在 Twitter 上关注这个机器人，并继续阅读以了解我是如何构建这个模型的！
川普，用他自己的话说
由亚历克斯·p·米勒 — 5 分钟阅读。
唐纳德·特朗普(Donald Trump)在 2016 年总统竞选过程中的优先事项发生了怎样的变化？随着竞选的临近，他在移民问题上变得更强硬了吗？还是他把重心转移到了经济上？他什么时候开始谈论希拉里的邮件的？
变型自动编码器作为双人游戏
通过最大 Frenzel — 17 分钟读取。
本系列文章的目的是使可变自动编码器和自然语言编码背后的基本思想尽可能容易理解，并鼓励已经熟悉它们的人从新的角度来看待它们。
LDA2vec:主题模型中的单词嵌入
由 Lars Hulstaert — 11 分钟读取。
主题模型的一般目标是产生可解释的文档表示，这些表示可用于发现未标记文档集合中的主题或结构。这种可解释文档表示的一个例子是:文档 X 20%是主题 a，40%是主题 b，40%是主题 c。
利用研究助教奖学金进入微软
来到机会之地:美国，已经一个月了。到目前为止，这是一次美妙的旅程，我很喜欢。所以，回到印度后，我有两个选择，是去达索系统公司做一名 R&D 的助理开发工程师，还是去锡拉丘兹大学信息研究学院攻读应用数据科学硕士。正如你从标题中理解的那样，你知道我做了哪个选择。如果你不知道，让我告诉你,《美国新闻》将锡拉丘兹大学信息学院的信息项目列为全美第二。为抵达美国做准备是一段艰难的时光，但我享受其中的每一刻。我于 2018 年 8 月 6 日抵达美国纽约锡拉丘兹的汉考克国际机场。这里的天气不可预测，但相对凉爽。到目前为止，美国没有让我失望，因为它是一种不同的文化，人们更加友好和外向，但我想念我的家人，朋友和最后但并非最不重要的“假期”。大学有一个巨大的校园，占地 700 多英亩，位于城市环境中，拥有最先进的基础设施和设备。
闲话少说，让我开门见山:我是如何从第一学期就获得研究助教奖学金的？我说“助教奖学金”了吗？对不起，我指的是“助教奖学金”:让我带你看一下整个过程。
我什么时候接触过老师了？
我在 2018 年 5 月中旬完成了我的本科学业，在家里无所事事。许多人告诉我，你通常不会在第一学期获得助教奖学金，但这总是值得一试。我最初在大学网站上浏览了教员的研究概况。每所大学都有教师网页，在那里你可以找到教授们目前参与的所有有趣的东西。我列出了与我的研究兴趣有交集的五位教授的候选名单，并在 5 月底之前发送了关于我对他们工作的兴趣的电子邮件。
我在那些邮件里写了什么？
教授们确实会收到很多关于他们实验室工作的电子邮件，同时他们也非常忙。你的电子邮件中应该有一个能引起教授注意的钩子。钩子？伙计，你说的钩子是什么意思？等等，我在解释。实际上，你的电子邮件有两个主要的吸引读者的地方。主题:人们习惯写各种各样的主题，比如“未来的研究助理——2018 年秋季”，“你实验室的 RA/GA/TA”等等，但是它包含教授感兴趣的东西吗？没有。他/她为什么会打开你的邮箱？在这个繁忙的时刻，教授们已经收到了很多类似的电子邮件。这就是为什么第一个钩子是主题行。对我有用的是:对你教授的研究做适当的功课，找到你研究兴趣的交叉点。然后，你可以把主题简单地写成“[研究兴趣] —在你的实验室工作”。这是不是太简单了，但它确实有效；
)**2。开篇:**这是大多数学生犯的一个错误，他们介绍了自己，并对自己说了很多废话。如果教授打开你的电子邮件，他很少有机会阅读你的第二段，因为你在第一段吹嘘自己，浪费了这个机会。第一段应该基于你对教授做的家庭作业:谈论他的项目、论文、兴趣。这是人类的一种倾向，他们喜欢听到关于他们自己的事情。它不应该超过 3-4 行，然后巧妙地将它与你觉得这些东西有趣的原因联系起来。我确实用一句话把它和我过去做过的一个项目联系起来。现在，教授知道你值得他/她的时间，因为你自己已经研究过他/她的兴趣和工作。现在你们两个都有共同的兴趣，他/她可能会看第二段，在那里你简要介绍自己，并描述与教授相关的所有工作。如果你想要一个很长的第二段，或者分成 4-4 行的段落，总共最多 3 段关于你自己和你的工作，这完全取决于你。确保一切都与你想做的工作类型相关。
你认为你现在都准备好了吗？啊哈。一定要写下结束语，直截了当地问你想要什么。你可以礼貌地问“我想知道你的实验室是否有一个为你的研究做贡献的空缺职位”，并以注明你已经放在邮件中供教授参考的所有附件结束这一段。你在说什么依恋，伙计？你至少应该附上你的简历，但你可以添加更多像实习信，论文(即使是未发表的，因为它是你的学术写作样本的例子)和项目报告。
嗯……就这些？不，还有更多。15 天后，如果你没有收到任何回复，你可以发一封提醒邮件，因为他们有时会因为忙碌而错过邮件。让我们回到我的故事，我说到哪里了？是的，我告诉你我在五月底给五位教授发了电子邮件。第一天，第二天，第三天，第四天，我得到了一位教授的第一次回复，他说我的背景非常适合他/她的研究，并要求我在来锡拉丘兹之前阅读一些技术。哦，那是积极的。在发出提醒邮件后，我又收到了两封回复，其中一封说他/她想在我到达锡拉丘兹大学后和我面谈，猜猜那个教授是我最优先考虑的。
我在八月初到达锡拉丘兹，然后给他们发电子邮件告知我的到达。他们很忙，面试被安排在八月的第三周。与此同时，我知道系里有一个门户网站，上面贴出了所有学院研究助理的职位空缺，找到一个好职位后，我就去申请了。就在一天之内，我得到了一个面试的机会，面试是在接到通知的第二天，因为教授在那之后几周都不在城里。关于面试，确保你知道你写在简历上的所有内容，并准备好回答深层次的概念性问题。我在第一次面试中被盘问，除了我的简历之外，还问了一些关于优化模式匹配算法、微积分和数学的问题。不要犹豫地说“你不知道”,不要试图愚弄教授，因为他们是你所用技术的大师。最终，我完成了对不同教授的三次面试，幸运的是，他们都给了我一份工作，让我在他们各自的实验室做研究助理。我的假新闻检测项目(听起来很棒？但这是美国著名的研究课题)和在印度人类住区研究所的实习经历在面试中发挥了至关重要的作用。
In-front of School of Visual and Performing Arts, Syracuse University
这是一种幸福的结局，对不对？我最终决定与 Jennifer Stromer-Galley 教授合作进行启发性项目，开发机器学习算法和自然语言处理技术，以跟踪脸书和推特上大约 1100 名 2018 年联邦选举的候选人。该项目得到了奈特基金会、哥伦比亚大学数字新闻 Tow 中心、锡拉丘兹大学信息研究学院计算和数据科学中心以及 BITS 实验室的支持。那都是乡亲们！在 gmail dot com 的[我的名字][我的名字]或我的LinkedIn上提问。关于这项工作的更新即将推出。
六月版:概率、统计和机器学习
10 篇必读文章
解释概率概念(介绍、最大似然估计、参数估计的贝叶斯推断)。
琼尼·布鲁克斯-巴特利特——30 分钟阅读
这些年来，我阅读了许多关于概率论不同方面的文本和文章，每一篇似乎都需要不同程度的先决知识来理解正在发生的事情。我绝不是这一领域的专家，但我觉得我可以通过写一系列通俗易懂的文章来解释概率中的各种概念。
数据科学家需要掌握的 10 项统计技术
由詹姆斯·勒 — 15 分钟读完
不管你站在数据科学性感的立场上，都不可能忽视数据的持续重要性，以及我们分析、组织和联系数据的能力。
对匆忙人群的统计
凯西·科济尔科夫(Cassie Kozyrkov)—8 分钟阅读
曾经希望有人能告诉你统计学的要点是什么，术语用简单的英语表达是什么意思吗？让我试着帮你实现这个愿望吧！我将在 8 分钟内快速浏览统计学中所有最重要的观点！或者只有 1 分钟，如果你坚持使用大字体的话。
你需要知道的数据科学概念！
迈克尔·巴伯 — 27 分钟阅读
这一系列帖子旨在介绍并快速发展数据科学和数据分析中的一些核心概念，并特别关注我觉得在其他材料中被忽略或简单处理的领域。
超越准确度:精确度和召回率
由威廉·科尔森 — 11 分钟阅读
你会相信一个声称完全在大脑中创造了一个模型的人以超过 99%的准确率识别试图登机的恐怖分子吗？
陌生事物:分析和交流数据的五堂课
到乔丹·德沃金 — 8 分钟阅读
作为一名统计领域的研究生，我很快意识到，不与数据打交道的人对统计这个词通常会有两种反应:“哦，我讨厌那门课！”和“你一定很喜欢数学！”
如何在数据科学面试中胜出:统计学
由卡森·福特 — 9 分钟阅读
对于从事或试图从事数据科学工作的人来说，统计学可能是你需要发展的最大和最令人生畏的知识领域。这篇文章的目标是把你需要知道的东西减少到有限数量的具体想法、技术和方程式。
平均而言，您使用了错误的平均值
丹尼尔·麦克尼克 — 19 分钟阅读
你有一堆数字。你想用更少的数字来概括它们，最好是单个数字。所以你把所有的数字加起来，然后除以数字的总数。嘣:看“平均值”，对吧？
主成分分析的一站式商店
通过哑光 Brems — 15 分钟读取
主成分分析(PCA)是统计学和数据科学领域中需要理解的一项重要技术……但是在为我的学生组织课程时，我发现网上的资源技术性太强，没有完全满足我们的需求，并且/或者提供了相互矛盾的信息。
解释机器学习模型
作者拉尔斯·赫尔斯特 — 8 分钟阅读
不管您的数据科学解决方案的最终目标是什么，最终用户总是更喜欢可解释和可理解的解决方案。
6 月版:自动驾驶汽车
你必须阅读的 6 篇关于自动驾驶汽车的文章。
卡尔曼滤波器:直觉和离散情况推导
由 Vivek Yadav — 6 分钟阅读。
在这篇文章中，我们将回顾离散卡尔曼滤波器的推导过程。我们将首先建立由离散动态控制的系统的方程，然后表达近似系统，计算误差协方差并计算最小化误差协方差的更新规则。由于经由卡尔曼滤波的估计涉及连续的测量和状态传播，所以在离散实现的情况下它们更容易理解。
车辆检测与跟踪
由伊万·卡萨科夫 — 7 分钟读完。
这是 Udacity 的自动驾驶汽车工程师纳米学位项目第一学期的最后一个项目。源代码和更详细的技术文章可以在 GitHub 上找到
自动驾驶汽车如何转向
由 Priya Dwivedi — 5 分钟阅读。
典型的自动驾驶汽车从感知系统开始，该系统估计周围环境的状态，包括地标、车辆和行人。
帮助无人驾驶汽车自我定位
由 Priya Dwivedi — 4 分钟阅读。
定位，或者说知道“我在哪里”对于自动驾驶汽车来说至关重要。每时每刻它都需要知道自己在世界的哪个角落。当我们开车时，我们使用 GPS 和地图应用程序来知道我们的车在哪里。但是 GPS 的精度是 1-3 米，有时更高。这不适用于自动驾驶汽车，因为这是车道的宽度。
用深度学习进行车道检测(第一部分 & 第二部分
由迈克尔处女座 — 10 & 9 分钟阅读。
即使在各种各样的条件下，人们也可以相当容易地找到道路上的车道线。除非有雪覆盖地面，降雨量非常大，道路非常脏或年久失修，我们可以告诉我们应该去哪里，假设这些线实际上是有标记的。
需要视觉
由 Harish Vadlamani — 13 分钟阅读。
嗯，我做到了！我终于完成了 Udacity 自动驾驶汽车 Nanodegree 的第一学期。至少可以说，过去的三个月是一段坎坷的旅程，我已经成功地克服了这段时间所面临的障碍，无论是实际上还是象征性的！
我们也感谢最近加入我们的所有伟大的新作家彼得·斯威尼、马丁·施密茨、博士、关朝聪、约翰尼·邓恩、狄奥尼索斯·鲍威尔、阿比吉特·勃拉姆斯、萨纳坦·米什拉、迈克尔·何、埃里克·兰根伯格、伊万·卡萨科夫、 胡安.马特奥斯-加西亚、科伦廷·杜古埃、泰勒·基利安、布伦丹·贝利、克里斯·文泰歇尔、巴拉兹·凯格尔、犹他工程、亨里克·林德伯格等众多。
tmux 和 ssh 中的 Jupyter 和 tensorboard
在最近的帖子中，我描述了如何设置你的个人深度学习工作站以及如何打开并远程访问它。
在这篇短文中，我解释了我通常如何用 tmux 设置我的远程工作环境，并在我的手机上检查我的计算进度。
tmux 是一个终端复用器，允许用户在单个终端窗口或远程终端会话中访问多个独立的终端会话。
首先，将以下几行添加到您笔记本电脑上的.ssh/config中。看这里,如果你想要更详细的关于如何远程访问你的电脑的指导。
Host workstation
HostName <hostname>
User <username>
Port <port>
LocalForward 8888 localhost:8888
LocalForward 6006 localhost:6006
现在输入ssh workstation就可以登录了。键入tmux new -s <sessionname>来启动 tmux。我通常通过键入Ctrl-b %垂直分割屏幕，然后通过键入Ctrl-b "水平分割屏幕。使用Ctrl-b o 可以导航到下一个窗格。我通常会打开右上方的窗格，用source active <name>启动我的虚拟环境，然后通过键入jupyter-notebook启动一个 jupyter 笔记本。将链接复制到笔记本电脑的浏览器中。接下来，我们开始 tensorboard。键入Ctrl-b o将光标移动到 tmux 中的下一个窗格。通过键入tensorboard --logdir=<log directory>激活虚拟环境并启动 tensorboard。在笔记本电脑的浏览器中打开一个新标签，然后进入 http://localhost:6006 。现在 tensorboard 应该也在运行(如果它不工作，确保 tensorboard 真的像我的情况一样使用端口 6006)。
现在最精彩的部分来了:当你停止工作时，只需输入Ctrl-b d就可以从 tmux 会话中脱离，当你想继续工作时，输入tmux attach -t <sessionname>就可以回到你离开的地方！
不幸的是，我不认为有一种方法可以关闭 jupyter 笔记本，同时它继续在后台运行，以后再回来。我经常做的是，当我想留下一些计算的东西过夜时，通过键入jupyter-nbconvert --to script <name>.ipynb将它转换成 python。现在，只需运行.py，脱离 tmux 会话，第二天再回来查看输出。如果有人知道更好的方法，请留下评论，我会很高兴知道。
以下是 tmux 的一些非常有用的快捷方式:
# session management
tmux ls (or tmux list-sessions)
tmux new -s session-name
Ctrl-b d Detach from session
tmux attach -t [session name]
tmux kill-session -t session-nameCtrl-b c Create new window
Ctrl-b d Detach current client
Ctrl-b l Move to previously selected window
Ctrl-b n Move to the next window
Ctrl-b p Move to the previous window
Ctrl-b & Kill the current window
Ctrl-b , Rename the current window
Ctrl-b q Show pane numbers (used to switch between panes)
Ctrl-b o Switch to the next pane
Ctrl-b ? List all keybindings# moving between windows
Ctrl-b n (Move to the next window)
Ctrl-b p (Move to the previous window)
Ctrl-b l (Move to the previously selected window)
Ctrl-b w (List all windows / window numbers)
Ctrl-b window number (Move to the specified window number, the
default bindings are from 0 -- 9)# Tiling commands
Ctrl-b % (Split the window vertically)
CTRL-b " (Split window horizontally)
Ctrl-b o (Goto next pane)
Ctrl-b q (Show pane numbers, when the numbers show up type the key to go to that pane)
Ctrl-b { (Move the current pane left)
Ctrl-b } (Move the current pane right)
Ctrl-b x kill current pane# Make a pane its own window
Ctrl-b : "break-pane"
另一个有用的提示:如果你使用 hyperdash ，你可以在手机上追踪你的模特的表现，而不必登录你的电脑:
hyperdash run -n "DQN Breakout" python DQN.py
希望这能为你节省不少时间:)玩得开心！
Jupyter 数据科学堆栈+ Docker 在 15 分钟内完成
动机 :假设你想使用 Python 或 R 中一些很酷的数据科学库，但你不想花费 小时 来安装 Python 或 R，找出你需要的库，安装每一个库，然后在你的 Linux/Windows/OSX/OS9 版本上无聊地工作——这就是 Docker 的用处！有了 Docker，我们可以立即建立并运行 Jupyter“数据科学”笔记本堆栈。我们开始吧！
Docker 允许我们在所谓的 容器 中运行“准备就绪”的 Jupyter 数据科学堆栈:
容器映像是一个轻量级的、独立的、可执行的软件包，包含了运行它所需的一切:代码、运行时、系统工具、系统库、设置。基于 Linux 和 Windows 的应用程序都可以使用容器化软件，无论环境如何，容器化软件都可以运行。容器将软件从其周围环境中隔离出来，例如开发和阶段环境之间的差异，并有助于减少在同一基础设施上运行不同软件的团队之间的冲突。
那么容器和虚拟机有什么区别呢？
容器和虚拟机具有类似的资源隔离和分配优势，但功能不同，因为容器虚拟化的是操作系统而不是硬件，容器更具可移植性和效率。
要开始使用 Docker，您需要安装 Docker 社区版。在此下载适合您环境的安装程序。一旦你安装了 Docker，重启你的机器，我们就可以开始安装 Jupyter 容器了。当运行一个容器时，你需要告诉 Docker 这个容器的基本映像是什么。
那么什么是 图像 以及它如何与 容器 相关联呢？
Docker 图像是由一系列层构建而成的。每一层代表图像 docker 文件中的一条指令。除了最后一层，每一层都是只读的。
一个 容器 就是一个 图像 的运行实例。使用 Docker 真正节省时间的是，其他人已经构建了一个映像，其中包含了我们开始使用全套 Jupyter 数据科学堆栈所需的一切！我们所需要做的就是告诉 Docker 根据预定义的图像启动一个容器。为此，我们将以 Docker compose 文件的形式编写一个简单的配方。将下面的文件作为 docker-compose.yml 保存到您的工作目录中:
保存文件后，用您最喜欢的编辑器打开它，并更改以下部分:
/Absolute/Path/To/Where/Your/Notebook/Files/Will/Be/Saved
本地机器上保存您的工作的路径。确保路径确实存在，也就是说，已经创建了所有目录。如果不这样做，当你试图启动你的容器时会导致错误，更糟糕的是，你将不能保存你在容器中做的任何工作！
很好，我们已经准备好了 Docker compose 文件，现在我们可以使用 docker-compose 命令来启动我们的容器。打开终端或命令提示符，进入您的工作目录并运行以下命令:
docker-compose up
您应该在终端/命令提示符下看到类似下面的输出(为了简洁起见，我省略了一些输出):
$ **docker-compose up**Creating network “jupyternotebook_default” with the default driverCreating datascience-notebook-container …Creating datascience-notebook-container … doneAttaching to datascience-notebook-containerdatascience-notebook-container | Execute the command: jupyter notebook.
.
.datascience-notebook-container | [I 11:37:37.993 NotebookApp] The Jupyter Notebook is running at: [http://[all ip addresses on your system]:8888/?token=123456789123456789123456789123456789](http://localhost:8888/?token=123456789123456789123456789123456789)datascience-notebook-container | [I 11:37:37.993 NotebookApp] Use Control-C to stop this server and shut down all kernels (twice to skip confirmation).datascience-notebook-container | [C 11:37:37.994 NotebookApp]datascience-notebook-container |datascience-notebook-container | Copy/paste this URL into your browser when you connect for the first time,datascience-notebook-container | to login with a token:datascience-notebook-container | [http://localhost:8888/?token=123456789123456789123456789123456789](http://localhost:8888/?token=123456789123456789123456789123456789)
最后一行是一个 URL，我们需要将其复制并粘贴到我们的浏览器中，以访问我们的新 Jupyter 堆栈:
[http://localhost:8888/?token=123456789123456789123456789123456789](http://localhost:8888/?token=123456789123456789123456789123456789)
一旦你做到了这一点，你应该迎接你自己的集装箱 Jupyter 服务！您可以访问此链接了解 Jupyter 数据科学堆栈为您提供的更多信息。
要创建您的第一个笔记本，请进入工作目录，然后单击右侧的“新建”按钮，并选择“Python 3”来创建一个基于 Python 3 的新笔记本。一旦你这样做了，检查你的路径，你选择保存你的工作到本地，你应该看到你的新笔记本的。ipynb 文件已保存！
要在完成工作后关闭容器，只需在终端/命令提示符下按 Ctrl-C。您的工作将全部保存在您的实际机器上，路径是我们在 Docker compose 文件中设置的。这就是你开始使用 Jupyter 笔记本和 Docker 魔力的简单快捷的方法。
我希望这篇文章对你有所帮助，请在下面留下你的反馈或评论。黑客快乐！
使用 SQL 的 Jupyter Magics
Jupyter/IPython 笔记本可用于在关系数据库上使用 SQL 进行交互式数据分析。这融合了使用 Jupyter(一个成熟的数据分析平台)的优势、SQL 的易用性和 SQL 引擎的性能。
Jupyter 的神奇功能允许你用更简洁的代码片段替换样板代码片段。让我们探索 Jupyter SQL 的魔力，它允许我们与 Presto 或任何其他关系数据库进行交互。
什么是神奇功能？
魔术函数是 Jupyter 内核中执行所提供命令的预定义函数(“魔术”)。有两种面向行和面向单元的魔法，分别以%和%%开头。
为了看出区别，我们开始比较使用和不使用 magics 函数的代码示例。最终，两条语句达到了相同的结果。
让我们开始创建与 SQLAchemy 的连接，以获取最后执行的查询并将其放入数据框。
如果我们启用了 SQL 魔法函数，我们将这样做。
入门指南
这些示例使用 Prestodb 作为 SQL 引擎。然而，该方法可以扩展到任何与 Python SQLAlchemy 兼容并且具有实现 Python DB 2.0 规范的驱动程序的引擎。为了实现这种魔力，我们需要一个 ipython-sql 库。此外，这些例子大多来自 ipython-sql 官方知识库。
pip install pandas
pip install sqlalchemy # ORM for databases
pip install ipython-sql # SQL magic function
要使用 Prestodb，我们需要 PyHive 库。幕后的 SQLAlchemy 将使用该库建立连接并提交 SQL 查询。对于其他引擎，您需要安装合适的驱动程序，即PostgreSQL、 MySQL 。
pip install pyhive[presto] # DB driver library
使用
ipython-sql 库使用%load_ext iPython 扩展语法加载，并指向连接对象，如下所示:
%load_ext sql
%config SqlMagic.autocommit=False # for engines that do not support autommit
请注意，对于普雷斯托，黑斑羚和其他一些引擎，你需要禁用autocommit功能。这是通过 SqlMagic config 属性完成的。列出您可以在单元中运行的所有配置选项:%config SqlMagic
关系
要连接到数据库，您需要将 SQLAlchemy 格式的连接字符串传递给%sql函数。
%sql presto://user@localhost:8080/system
如果没有提供连接字符串并且还没有建立连接，ipython-sql试图从DATABASE_URL环境变量中获取连接信息。如果您的连接信息是静态的，您可以在~/.bashrc中导出环境变量DATABASE_URL。%env 是另一个设置环境变量的神奇函数。
%env DATABASE_URL=presto://user@localhost:8080/system
%sql SELECT 1 as "Test"
在多个 SQL 引擎的情况下，如果您想要组合来自它们的数据，您可以在单元模式下将连接字符串与神奇函数的每个查询一起传递。
%%sql user@jmx
SHOW SCHEMAS
绑定变量
参数替换是一个方便的特性，它允许在查询运行时定义 SQL 查询参数。它使代码不那么脆弱，也不那么富于表现力。该参数需要在本地范围内定义，并以冒号为前缀，即:parameter
变量赋值
普通的 IPython 赋值适用于单行%sql查询:
result = %sql select query_id, state from runtime.queries limit 1
对于多行查询，您需要使用<<语法。
%%sql result_set <<
SELECT query_id, state, query
FROM runtime.queries
LIMIT 2
熊猫
SQL magic 与 pandas 库有很好的集成。SQL 查询的结果可以通过DataFrame调用转换成常规的 pandas 数据帧。
结论
你也应该考虑阅读一下内置的神奇功能，它可以让你完成更多的工作，减少输入！你也可以看看满笔记本贴上的例子。
IPython-笔记本-IPython 笔记本的集合
github.com](https://github.com/satybald/ipython-notebooks/blob/master/MagicsSQL.ipynb)
Jupyter 笔记本备忘单
您可能已经非常了解 Jupyter 笔记本，它可能是 Jupyter 生态系统中最知名的部分之一！如果你还没有探索过这个生态系统，或者你只是想了解更多，请不要犹豫，点击这里去探索它吧！。
对于那些不熟悉 Project Jupyter 的人来说，Jupyter Notebook 应用程序可以生成包含可执行代码、文本元素甚至 HTML 的混合文档，这使得它成为汇集分析描述及其结果以及实时执行数据分析的理想场所。这一点，加上其许多有用的功能，解释了为什么 Jupyter 笔记本电脑是数据科学家的首选开发环境之一，它允许交互式、可重复的数据科学分析、计算和通信。
Jupyter 笔记本的另一个优点是什么？
它们非常容易上手！当你阅读 DataCamp 的Jupyter 笔记本权威指南时，你可能已经注意到了这一点。然而，当您第一次进入应用程序时，您可能需要在呈现给您的各种功能中找到自己的方式:从保存您当前的笔记本到在笔记本中添加或移动单元格，或者在笔记本中嵌入当前的小部件——毫无疑问，当您第一次开始使用时，有很多东西需要发现！
这就是为什么 DataCamp 为那些刚刚起步并希望获得一些帮助来找到出路的人制作了一个 Jupyter 笔记本备忘单。
请注意Jupyter 笔记本应用程序有一个方便的“帮助”菜单，包括一个完整的用户界面浏览！—别担心，我们也在备忘单中包含了这一点:)
请点击这里查看:
点击 这里 看小抄。
简而言之，这份备忘单将帮助你启动你的数据科学项目，无论它们是大是小:通过一些截图和解释，你很快就会成为 Jupyter 笔记本专家！
你还在等什么？是时候开始了！
Jupyter 笔记本扩展
如何在笔记本电脑环境中提高工作效率
Jupyter 笔记本是一个很好的教学、探索和读写编程环境，但是开箱即用的笔记本众所周知缺乏特性。幸运的是，有许多方法，包括 Jupyter 笔记本扩展，来改进这个无价的工具。
极其简洁的版本
在命令提示符下运行以下命令:
pip install jupyter_contrib_nbextensions && jupyter contrib nbextension install
启动 Jupyter 笔记本并导航到新的 Nbextensions 选项卡:
Jupyter Notebook Extensions Tab
启用您想要的扩展并享受工作效率优势。
(如果您没有看到选项卡，请打开笔记本并点击编辑> nbextensions 配置)
可以在笔记本的工具栏中看到启用的扩展:
稍长的版本
如果这还不够让你满意，下面是一些关于 Jupyter 笔记本扩展的细节。我还列出了我的前 5 条建议来帮助你开始。
什么是笔记本扩展？
Jupyter 笔记本扩展是扩展笔记本环境基本功能的简单附件。用 JavaScript 编写，他们做的事情有自动格式化你的代码或者当一个单元格完成时发送一个浏览器通知。扩展目前只适用于 Jupyter 笔记本(不适用于 Jupyter 实验室)。
为什么要使用这些扩展？Jupyter 笔记本是教学、学习、原型制作、探索和尝试新方法的绝佳工具(甚至在网飞的生产中也是如此)。然而，普通笔记本的功能有限，这使得在笔记本上工作令人沮丧。虽然 Jupyter 笔记本扩展没有完全解决问题，但它们确实增加了一些好处，使您的工作更加轻松。
使用哪个
以下是我最常用的 5 款 Jupyter 笔记本扩展:
1.目录:更简单的导航
一旦你开始在一个 Jupyter 笔记本上放几十个电池，就很难把它们都记录下来。目录通过添加可放置在页面任何位置的链接目录解决了这个问题:
Table of Contents
您还可以使用该扩展在笔记本顶部添加一个链接的目录。这甚至显示哪个单元被选中，哪个单元正在运行:
Table of Contents in Notebook
2.Autopep8:一键完成简洁的代码
我们都应该编写符合 pep8 的代码，但有时你会陷入分析中，很难坚持最佳实践。当你写完这个惊人的情节时，这个扩展允许你简单地点击木槌，自动格式化你混乱的代码。
Autopep8 your code.
像最好的附加组件一样，这一个只需简单的点击就能完成耗时而乏味的任务，让你专注于思考问题。
3.变量检查器:跟踪你的工作空间
变量检查器显示您在笔记本中创建的所有变量的名称，以及它们的类型、大小、形状和值。
Variable inspector
对于从 RStudio 迁移过来的数据科学家来说，或者如果你不想继续打印df.shape或者想不起x的type的话，这个工具是非常宝贵的。
4.ExecuteTime:显示单元运行的时间和时长
我经常发现自己试图弄清楚一个单元运行需要多长时间，或者我最后一次运行打开了几天的笔记本是什么时候。ExecuteTime 通过显示一个单元完成的时间和花费的时间来处理这两个问题。
ExecuteTime extension output
有更好的方法来计时(例如[%%timeit](https://ipython.readthedocs.io/en/stable/interactive/magics.html#magic-timeit)单元格魔术)但是这很容易实现并且覆盖了笔记本中的所有单元格。
5.隐藏代码输入:隐藏工作显示结果
虽然我们中的一些人喜欢看到进入分析的艰苦工作，一些人只是喜欢看到结果。Hide input all 扩展允许您在保留输出的同时立即隐藏笔记本中的所有代码。
Hide all code
下一次有人说他们只想看到结果，你有一个单击解决方案。(尽管您应该经常检查代码)。
这些只是我发现自己最常使用的扩展，你并不局限于五个。安装扩展并打开一个笔记本(这里显示的笔记本在 GitHub 上)来检查整个列表！(如果您愿意，您甚至可以编写自己的扩展。文档很少，但是这里是基本结构。)
结论
安装 Jupyter 笔记本扩展，花点时间搞清楚哪些对你有用，提高你的生产力。虽然没有一个能改变生活，但它们都增加了足够的价值，累积起来节省了您几个小时的宝贵开发时间。
尽管如果你正在编写生产代码(我喜欢而不是代码)，你可能想花一些时间在学习 IDE ，Jupyter 笔记本仍然是数据科学工作流程中不可或缺的一部分。如果您打算使用这种环境，那么您最好充分利用您的工具。
一如既往，我欢迎反馈和建设性的批评。可以通过 Twitter @koehrsen_will 或者通过我的个人网站 willk.online 找到我。
初学者 Jupyter 笔记本:教程
Photo by Harish Sharma on Pixabay
Jupyter Notebook 是一个非常强大的交互式开发和展示数据科学项目的工具。笔记本将代码及其输出集成到一个文档中，该文档结合了可视化、叙述性文本、数学方程和其他富媒体。直观的工作流促进了迭代和快速开发，使笔记本电脑成为当代数据科学、分析以及越来越普遍的科学的核心中越来越受欢迎的选择。最棒的是，作为开源项目 Jupyter 的一部分，它们是完全免费的。
Jupyter 项目是早期 IPython 笔记本的继任者，该笔记本于 2010 年作为原型首次发布。尽管在 Jupyter 笔记本中可以使用许多不同的编程语言，但本文将重点讨论 Python，因为它是最常见的用例。
为了从本教程中获得最大收益，你应该熟悉编程，特别是 Python 和熊猫。也就是说，如果你有使用另一种语言的经验，本文中的 Python 不应该太神秘，pandas 应该是可解释的。Jupyter 笔记本也可以作为一个灵活的平台来掌握 pandas 甚至 Python，这一点在本文中会变得很明显。
我们将:
- 涵盖安装 Jupyter 和创建您的第一台笔记本的基础知识
- 深入钻研，学习所有重要的术语
- 探索在线共享和发布笔记本有多容易。的确，这篇文章是一本 Jupyter 笔记本！这里的所有内容都是在 Jupyter 笔记本环境中编写的，您正在以只读形式查看它。
Jupyter 笔记本中的示例数据分析
我们将通过一个示例分析来回答一个现实生活中的问题，这样您就可以看到笔记本的流程如何让任务直观地通过我们自己来完成，以及当我们与他人分享时让他人理解。
假设你是一名数据分析师，你的任务是找出美国最大公司的利润历史变化。你会发现一组财富 500 强公司的数据，从 1955 年第一次发布到现在已经超过 50 年了，这些数据来自财富的公共档案库。我们已经创建了一个 CSV 格式的数据，您可以在这里使用。
正如我们将要展示的，Jupyter 笔记本非常适合这项调查。首先，让我们继续安装 Jupyter。
装置
初学者开始使用 Jupyter 笔记本最简单的方法是安装 Anaconda 。Anaconda 是数据科学中使用最广泛的 Python 发行版，预装了所有最流行的库和工具。除了 Jupyter，Anaconda 中一些最大的 Python 库包括 NumPy 、 pandas 和 Matplotlib ，尽管完整的 1000+列表已经很详尽了。这使您可以在自己的全面储备的数据科学研讨会中立即投入运行，而不会有管理无数安装的麻烦，也不会担心依赖关系和特定于操作系统(即特定于 Windows)的安装问题。
要得到 Anaconda，很简单:
- 下载Python 3 的 Anaconda 最新版本(忽略 Python 2.7)。
- 按照下载页面和/或可执行文件中的说明安装 Anaconda。
如果您是已经安装了 Python 的高级用户，并且喜欢手动管理您的包，那么您可以只使用 pip:
创建您的第一个笔记本
在本节中，我们将了解如何运行和保存笔记本，熟悉它们的结构，并理解界面。我们将熟悉一些核心术语，引导您实际理解如何自己使用 Jupyter 笔记本电脑，并为下一部分做好准备，这一部分将逐步介绍一个示例数据分析，并将我们在此学到的一切融入生活。
跑步 Jupyter
在 Windows 上，您可以通过 Anaconda 添加到开始菜单的快捷方式来运行 Jupyter，这将在您的默认 web 浏览器中打开一个新的选项卡，看起来应该类似于下面的截图。
这还不是一个笔记本，但不要惊慌！没什么大不了的。这是笔记本仪表盘，专门用于管理您的 Jupyter 笔记本。将它视为探索、编辑和创建笔记本的发射台。
请注意，仪表板将只允许您访问 Jupyter 启动目录中包含的文件和子文件夹；但是，启动目录可以更改。也可以在任何系统上通过命令提示符(或 Unix 系统上的终端)输入命令jupyter notebook来启动仪表板；在这种情况下，当前工作目录将是启动目录。
敏锐的读者可能已经注意到仪表板的 URL 类似于http://localhost:8888/tree。Localhost 不是一个网站，但它表明内容是从您的本地机器(您自己的计算机)提供的。Jupyter 的笔记本和仪表板是 web 应用程序，Jupyter 启动了一个本地 Python 服务器来为您的 web 浏览器提供这些应用程序，使其基本上独立于平台，并打开了更容易在 web 上共享的大门。
仪表板的界面基本上是不言自明的——尽管我们稍后会简单地回到它。那么我们还在等什么呢？浏览到您想要创建第一个笔记本的文件夹，单击右上角的“新建”下拉按钮，然后选择“Python 3”(或您选择的版本)。
嘿，很快，我们到了！您的第一个 Jupyter 笔记本将在新选项卡中打开，每个笔记本都使用自己的选项卡，因为您可以同时打开多个笔记本。如果你切换回仪表板，你会看到新的文件Untitled.ipynb，你应该会看到一些绿色的文字，告诉你你的笔记本正在运行。
什么是 ipynb 文件？
理解这个文件到底是什么会很有用。每个.ipynb文件都是一个文本文件，以一种叫做 JSON 的格式描述你笔记本的内容。每个单元格及其内容，包括已经转换为文本字符串的图像附件，与一些元数据一起列在其中。如果你知道你在做什么，你可以自己编辑它！—从笔记本的菜单栏中选择“编辑>编辑笔记本元数据”。
也可以从仪表盘上的控件中选择“编辑”来查看笔记本文件的内容，但这里的关键词是“可以”；除非你真的知道自己在做什么，否则除了好奇没有别的原因。
笔记本界面
现在你面前有一个打开的笔记本，它的界面看起来不会完全陌生；毕竟，Jupyter 本质上只是一个高级的文字处理器。为什么不四处看看呢？检查一下菜单，感受一下，特别是花一些时间向下滚动命令面板中的命令列表，命令面板是带有键盘图标的小按钮(或Ctrl + Shift + P)。
你应该注意到两个相当突出的术语，它们可能对你来说是新的:细胞和内核是理解 Jupyter 的关键，也是它不仅仅是一个文字处理器的关键。好在这些概念并不难理解。
- 内核是一个“计算引擎”，它执行笔记本文档中包含的代码。
- 单元是显示在笔记本中的文本或由笔记本内核执行的代码的容器。
细胞
稍后我们将回到内核，但首先让我们来了解一下细胞。细胞构成了笔记本的主体。在上一节中新笔记本的屏幕截图中，带有绿色轮廓的框是一个空单元格。我们将介绍两种主要的细胞类型:
- 一个代码单元包含要在内核中执行的代码，并在下面显示其输出。
- Markdown 单元格包含使用 Markdown 格式化的文本，并在运行时就地显示其输出。
新笔记本中的第一个单元格总是代码单元格。让我们用一个经典的 hello world 例子来测试一下。在单元格中输入print('Hello World!')，点击上方工具栏中的运行按钮或按下Ctrl + Enter。
结果应该是这样的:
Hello World!
当您运行该单元时，其输出将显示在下方，其左侧的标签将从In [ ]变为In [1]。代码单元的输出也构成了文档的一部分，这就是为什么您可以在本文中看到它。您总是可以区分代码单元格和降价单元格，因为代码单元格的标签在左边，而降价单元格没有。标签的“In”部分是“Input”的简称，而标签号表示单元在内核上执行的时间——在这种情况下，单元首先被执行。再次运行该单元，标签将变为In [2]，因为现在该单元是第二个在内核上运行的单元。当我们更仔细地研究内核时，会更清楚为什么这是如此有用。
从菜单栏中，点击插入并选择在下方插入单元格，在第一个单元格下方创建一个新的代码单元格，并尝试以下代码，看看会发生什么。你注意到什么不同了吗？
这个单元格不产生任何输出，但是它确实需要三秒钟来执行。请注意 Jupyter 是如何通过将标签更改为In [*]来表示该单元当前正在运行的。
一般来说，单元格的输出来自于在单元格执行期间专门打印的任何文本数据，以及单元格中最后一行的值，无论是单独的变量、函数调用还是其他。例如:
'Hello, Tim!'
您会发现自己在自己的项目中几乎经常使用这种方法，以后我们会看到更多。
快捷键
运行单元格时，您可能观察到的最后一件事是，它们的边框变成了蓝色，而在编辑时它是绿色的。总是有一个“活动”单元格用边框高亮显示，边框的颜色表示其当前模式，其中绿色表示“编辑模式”，蓝色表示“命令模式”
到目前为止，我们已经看到了如何使用Ctrl + Enter运行单元，但是还有更多。键盘快捷键是 Jupyter 环境中非常流行的一个方面，因为它们促进了基于单元格的快速工作流。其中许多操作是您可以在活动单元格处于命令模式时执行的。
下面，你会发现一些 Jupyter 的键盘快捷键列表。你不需要马上去做，但是这个列表会让你知道什么是可能的。
- 分别用
Esc和Enter在编辑和命令模式之间切换。
一旦进入命令模式:
- 用
Up和Down键上下滚动单元格。 - 按下
A或B在当前单元格的上方或下方插入一个新单元格。 M将当前单元格转换为降价单元格。Y将当前单元格设置为代码单元格。D + D(D两次)将删除当前单元格。Z将撤消单元格删除。- 按住
Shift并按下Up或Down一次选择多个单元格。
选择多个单元格:
Shift + M将合并您的选择。Ctrl + Shift + -，在编辑模式下，将光标处的活动单元格拆分。- 您也可以点击单元格左边的空白处的和
Shift + Click来选择它们。
继续在你自己的笔记本上尝试这些。一旦你有了一个剧本，创建一个新的降价单元，我们将学习如何在我们的笔记本上设置文本格式。
降价
Markdown 是一种轻量级的、易于学习的标记语言，用于格式化纯文本。它的语法与 HTML 标签一一对应，所以这里的一些先验知识会有所帮助，但绝对不是先决条件。请记住，这篇文章是在 Jupyter 笔记本上写的，所以到目前为止，您看到的所有叙述性文本和图像都是在 Markdown 中实现的。让我们用一个简单的例子来介绍一下基础知识。
# This is a level 1 heading
## This is a level 2 heading
This is some plain text that forms a paragraph.
Add emphasis via **bold** and __bold__, or *italic* and _italic_.Paragraphs must be separated by an empty line.* Sometimes we want to include lists.
* Which can be indented.1\. Lists can also be numbered.
2\. For ordered lists.[It is possible to include hyperlinks]([https://www.example.com](https://www.example.com))Inline code uses single backticks: `foo()`, and code blocks use triple backticks:```
bar()
Or can be intented by 4 spaces:
foo()
And finally, adding images is easy: 
附加图像时，您有三种选择:
* 使用网络上图像的 URL。
* 使用一个本地 URL 链接到您将与笔记本一起保存的图像，比如在同一个 git repo 中。
* 通过“编辑>插入图像”添加附件；这将把图像转换成一个字符串并存储在你的笔记本`.ipynb`文件中。
* 请注意，这将使您的`.ipynb`文件更大！
Markdown 还有很多细节，特别是关于超链接，也可以简单地包含普通的 HTML。一旦你发现自己正在挑战上述基础知识的极限，你可以参考创作者约翰·格鲁伯在其网站上提供的官方指南。
# 核
每台笔记本背后都运行着一个内核。当您运行一个代码单元时，该代码在内核中执行，任何输出都返回到该单元进行显示。内核的状态会随着时间的推移在单元格之间持续存在——它属于整个文档，而不是单个单元格。
例如，如果您在一个单元格中导入库或声明变量，它们将在另一个单元格中可用。通过这种方式，您可以认为笔记本文档有点类似于脚本文件，只是它是多媒体的。让我们试试这个来感受一下。首先，我们将导入一个 Python 包并定义一个函数。
一旦我们执行了上面的单元格，我们可以在任何其他单元格中引用`np`和`square`。
1 squared is 1
不管笔记本中单元格的顺序如何，这都将有效。你可以自己试试，我们再把变量打印出来。
Is 1 squared is 1?
这里没有惊喜！但是现在让我们改变`y`。
如果我们再次运行包含我们的`print`语句的单元格，您认为会发生什么？我们会得到输出`Is 4 squared is 10?`！
大多数情况下，笔记本中的流程是自上而下的，但经常会回头进行修改。在这种情况下，每个单元格左边的执行顺序，比如`In [6]`，将让您知道是否有任何单元格有过时的输出。如果你想重新设置，内核菜单中有几个非常有用的选项:
* 重启:重启内核，从而清除所有已定义的变量等。
* 重新启动并清除输出:同上，但也会清除代码单元格下方显示的输出。
* 重启并运行全部:同上，但也将从第一个到最后一个顺序运行所有单元格。
如果您的内核卡在一个计算上，并且您希望停止它，您可以选择 Interupt 选项。
## 选择内核
你可能注意到了，Jupyter 给了你改变内核的选项，事实上有很多不同的选项可供选择。当您通过选择 Python 版本从仪表板创建新笔记本时，您实际上是在选择使用哪个内核。
不仅有不同版本 Python 的内核，还有超过 100 种语言的[内核，包括 Java，C，甚至 Fortran。数据科学家可能对](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels) [R](https://irkernel.github.io/) 和 [Julia](https://github.com/JuliaLang/IJulia.jl) 的内核，以及 [imatlab](https://github.com/imatlab/imatlab) 和 [Calysto MATLAB 的内核](https://github.com/calysto/matlab_kernel)特别感兴趣。 [SoS 内核](https://github.com/vatlab/SOS)在一台笔记本电脑中提供多语言支持。每个内核都有自己的安装说明，但可能需要您在计算机上运行一些命令。
# 实例分析
现在我们已经看了什么是 Jupyter 笔记本，是时候看看它们在实践中是如何使用的，这会让你更清楚地了解为什么它们如此受欢迎。终于到了开始使用前面提到的财富 500 强数据集的时候了。请记住，我们的目标是找出美国最大的公司的利润是如何历史变化的。
值得注意的是，每个人都将发展自己的喜好和风格，但一般原则仍然适用，如果你愿意，你可以在自己的笔记本上跟随这一部分，这给了你发挥的空间。
# 命名您的笔记本
在开始编写项目之前，您可能希望给它起一个有意义的名称。可能有些令人困惑的是，你不能从笔记本应用程序本身命名或重命名你的笔记本，而是必须使用仪表板或你的文件浏览器来重命名`.ipynb`文件。我们将返回到仪表板来重命名您之前创建的文件，它将具有默认的笔记本文件名`Untitled.ipynb`。
您不能在笔记本运行时对其进行重命名，因此您必须先将其关闭。最简单的方法是从笔记本菜单中选择“文件>关闭并暂停”。但是，您也可以关闭内核，方法是在笔记本应用程序中进入“内核>关闭”，或者在仪表板中选择笔记本，然后单击“关闭”(见下图)。
然后，您可以选择您的笔记本电脑，并单击仪表板控件中的“重命名”。
请注意，关闭浏览器中的“笔记本”选项卡将**而不是**“关闭”您的笔记本，就像在传统应用程序中关闭文档一样。笔记本的内核将继续在后台运行，并且需要在它真正“关闭”之前关闭——尽管如果你不小心关闭了标签或浏览器，这是非常方便的！如果内核关闭，您可以关闭标签页，而不用担心它是否还在运行。
一旦你命名了你的笔记本，打开它，我们就可以开始了。
# 设置
通常从专门用于导入和设置的代码单元开始，这样，如果您选择添加或更改任何内容，您可以简单地编辑并重新运行该单元，而不会导致任何副作用。
我们导入[熊猫](https://pandas.pydata.org/)来处理我们的数据， [Matplotlib](https://matplotlib.org/) 来绘制图表，以及 [Seaborn](https://seaborn.pydata.org/) 来使我们的图表更漂亮。导入 [NumPy](http://www.numpy.org/) 也很常见，但是在这种情况下，虽然我们通过 pandas 使用它，但是我们不需要显式地导入。第一行不是 Python 命令，而是使用一种叫做 line magic 的东西来指示 Jupyter 捕获 Matplotlib 图并在单元格输出中呈现它们；这是超出本文范围的一系列高级特性之一。
让我们继续加载我们的数据。
明智的做法是在单个单元格中也这样做，以防我们需要在任何时候重新加载它。
# 保存和检查点
现在我们已经开始了，定期储蓄是最好的做法。按下`Ctrl + S`会通过调用“保存和检查点”命令来保存你的笔记本，但是这个检查点是什么东西呢？
每次创建新笔记本时，都会创建一个检查点文件以及您的笔记本文件；它将位于保存位置的一个隐藏子目录中，名为`.ipynb_checkpoints`，也是一个`.ipynb`文件。默认情况下，Jupyter 会每隔 120 秒自动将您的笔记本保存到该检查点文件，而不会改变您的主笔记本文件。当您“保存并检查”时，笔记本和检查点文件都会更新。因此，检查点使您能够在出现意外问题时恢复未保存的工作。您可以通过“文件>恢复到检查点”从菜单恢复到检查点
# 调查我们的数据集
现在我们真的开始了！我们的笔记本被安全保存，我们已经将数据集`df`加载到最常用的 pandas 数据结构中，该结构被称为`DataFrame`，基本上看起来像一个表。我们的看起来像什么？
看起来不错。我们有我们需要的列，每一行对应于一年中的一家公司。
让我们重新命名这些列，以便以后引用它们。
接下来，我们需要探索我们的数据集。完成了吗？熊猫如预期的读了吗？是否缺少任何值？
25500
好的，看起来不错——从 1955 年到 2005 年，每年都有 500 行。
让我们检查一下我们的数据集是否像我们期望的那样被导入了。一个简单的检查是查看数据类型(或 dtypes)是否被正确解释。
year int64
rank int64
company object
revenue float64
profit object
dtype: object
啊哦。看起来利润栏有问题——我们希望它像收入栏一样是一个`float64`。这表明它很可能包含一些非整数值，所以我们来看看。
正如我们所怀疑的！有些值是字符串，用于指示丢失的数据。有没有其他的价值观已经悄然进入？
{‘N.A.’}
这很容易解释，但是我们应该怎么做呢？嗯，那要看少了多少个值。
369
这只是我们数据集的一小部分，尽管并非完全无关紧要，因为它仍然在 1.5%左右。如果包含`N.A.`的行在这些年中大致均匀分布，最简单的解决方法就是删除它们。所以让我们快速看一下分布情况。
一眼看去，我们可以看到一年中最无效的值少于 25，并且由于每年有 500 个数据点，删除这些值将占最差年份数据的不到 4%。事实上，除了 90 年代左右的飙升，大多数年份都不到峰值的一半。出于我们的目的，假设这是可以接受的，并继续删除这些行。
我们应该检查一下是否有效。
25131
year int64
rank int64
company object
revenue float64
profit float64
dtype: object
太好了！我们已经完成了数据集设置。
如果您要将笔记本显示为报告，您可以去掉我们创建的调查单元格(此处包含这些单元格是为了演示使用笔记本的流程),并合并相关单元格(请参阅下面的高级功能部分了解更多信息)以创建单个数据集设置单元格。这意味着，如果我们在其他地方弄乱了数据集，我们可以重新运行 setup 单元来恢复它。
# 使用 matplotlib 绘图
接下来，我们可以通过绘制每年的平均利润来解决手头的问题。我们也可以绘制收入图，所以首先我们可以定义一些变量和一个减少代码的方法。
现在我们来策划！
哇，这看起来像一个指数，但它有一些巨大的下降。它们必须与 20 世纪 90 年代初的衰退和 T2 的网络泡沫相对应。在数据中看到这一点很有趣。但是，每次衰退之后，利润是如何恢复到更高水平的呢？
也许收入能告诉我们更多。
这增加了故事的另一面。收入没有受到如此严重的打击，这是财务部门的一些伟大的会计工作。
通过栈溢出的一点点帮助[，我们可以用+/-它们的标准偏差叠加这些图。](https://stackoverflow.com/a/47582329/604687)
这是惊人的，标准差是巨大的。一些财富 500 强公司赚了数十亿美元，而另一些公司却损失了数十亿美元，而且随着这些年利润的增加，风险也在增加。也许有些公司比其他公司表现更好；前 10%的利润比后 10%的利润波动更大还是更小？
接下来我们可以研究很多问题，很容易看出在笔记本上工作的流程是如何与一个人自己的思维过程相匹配的，所以现在是时候结束这个例子了。这个流程帮助我们轻松地在一个地方调查我们的数据集，而无需在应用程序之间切换上下文，并且我们的工作可以立即共享和重现。如果我们希望为特定的受众创建更简洁的报告，我们可以通过合并单元格和删除中间代码来快速重构我们的工作。
# 共享您的笔记本
当人们谈论共享他们的笔记本时，他们通常会考虑两种模式。大多数情况下，个人分享他们工作的最终结果，很像这篇文章本身，这意味着分享他们笔记本的非交互、预渲染版本；然而，也有可能在笔记本上与 aid 版本控制系统协作，例如 [Git](https://git-scm.com/) 。
也就是说，有一些[T4 的](https://mybinder.org/)[新兴公司](https://kyso.io/)出现在网络上，提供在云中运行交互式 Jupyter 笔记本的能力。
# 在分享之前
共享笔记本将完全按照导出或保存时的状态显示，包括任何代码单元格的输出。因此，为了确保您的笔记本可以共享，您应该在共享前采取以下几个步骤:
1. 单击“单元格>所有输出>清除”
2. 点击“内核>重启并全部运行”
3. 等待您的代码单元完成执行，并检查它们是否按预期执行
这将确保您的笔记本不包含中间输出，没有过时状态，并在共享时按顺序执行。
# 导出您的笔记本
Jupyter 内置了对导出为 HTML 和 PDF 以及其他几种格式的支持，你可以在“文件>下载为”下的菜单中找到如果您希望与一个小型私人团体共享您的笔记本电脑，此功能可能正是您所需要的。事实上，由于学术机构的许多研究人员都获得了一些公共或内部网络空间，并且因为您可以将笔记本导出为 HTML 文件，Jupyter 笔记本可以成为他们与同行分享成果的一种特别方便的方式。
但是如果共享导出的文件对你来说还不够，还有一些非常流行的方法可以更直接地在网上共享`.ipynb`文件。
# 开源代码库
随着 GitHub 上的[公共笔记本数量在 2018 年初超过 180 万，它无疑是最受欢迎的与世界分享 Jupyter 项目的独立平台。GitHub 已经集成了对直接在存储库和网站上的 gists 中呈现`.ipynb`文件的支持。如果你还不知道的话，](https://github.com/parente/nbestimate) [GitHub](https://github.com/) 是一个代码托管平台，用于版本控制和使用 [Git](https://git-scm.com/) 创建的存储库的协作。你需要一个帐户来使用他们的服务，但标准帐户是免费的。
一旦你有了 GitHub 账户，在 GitHub 上分享笔记本最简单的方法实际上根本不需要 Git。自 2008 年以来，GitHub 提供了 Gist 服务来托管和共享代码片段，每个代码片段都有自己的存储库。要使用 Gists 共享笔记本:
1. 登录并浏览至[gist.github.com](https://gist.github.com/)。
2. 在一个文本编辑器中打开你的`.ipynb`文件，选择全部并复制里面的 JSON。
3. 将笔记本 JSON 粘贴到要点中。
4. 给你的要点一个文件名，记住要加上`.ipynb`，否则就没用了。
5. 点按“创建秘密要点”或“创建公开要点”
这应该类似于以下内容:
如果你创建了一个公共 Gist，你现在可以和任何人分享它的 URL，其他人也可以[复制你的作品。](https://help.github.com/articles/forking-and-cloning-gists/)
创建自己的 Git 库并在 GitHub 上共享超出了本教程的范围，但是 [GitHub 提供了大量的指南](https://guides.github.com/)让你自己开始。
对于那些使用 git 的人来说，一个额外的提示是[为 Jupyter 创建的那些隐藏的`.ipynb_checkpoints`目录添加一个例外](https://stackoverflow.com/q/35916658/604687)到你的`.gitignore`中，这样就不会不必要地提交检查点文件到你的 repo 中。
# Nbviewer
到 2015 年，NBViewer 已经发展到每周渲染[数十万台](https://blog.jupyter.org/rendering-notebooks-on-github-f7ac8736d686)笔记本，是网络上最受欢迎的笔记本渲染器。如果你已经有一个地方可以在线存放你的 Jupyter 笔记本，无论是 GitHub 还是其他地方，NBViewer 都会呈现你的笔记本并提供一个可共享的 URL。作为 Jupyter 项目的一部分，它是免费提供的，可在[nbviewer.jupyter.org](https://nbviewer.jupyter.org/)获得。
NBViewer 最初是在 GitHub 的 Jupyter 笔记本集成之前开发的，它允许任何人输入 URL、Gist ID 或 GitHub 用户名/repo/file，它会将笔记本呈现为网页。Gist 的 ID 是其 URL 末尾的唯一数字；比如`https://gist.github.com/username/50896401c23e0bf417e89cd57e89e1de`中最后一个反斜杠后的字符串。如果您输入 GitHub 用户名或用户名/回购，您将看到一个最小的文件浏览器，让您浏览用户的回购及其内容。
显示笔记本时，NBViewer 显示的 URL 是一个常数，基于它所渲染的笔记本的 URL，因此您可以与任何人共享它，只要原始文件保持在线，它就可以工作-nb viewer 不会缓存文件很长时间。
# 最后的想法
从基础开始，我们已经掌握了 Jupyter 笔记本的自然工作流程，深入研究了 IPython 更高级的功能，并最终学会了如何与朋友、同事和世界分享我们的工作。我们从一台笔记本电脑上完成了这一切！
应该清楚笔记本如何通过减少上下文切换和模仿项目过程中思维的自然发展来促进高效的工作体验。Jupyter 笔记本的强大之处应该也是显而易见的，我们介绍了大量线索，让您开始探索自己项目中更高级的功能。
如果你想为你自己的笔记本获得更多灵感，Jupyter 已经收集了[一系列有趣的 Jupyter 笔记本](https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks)，你可能会觉得有帮助，并且[NBC viewer 主页](https://nbviewer.jupyter.org/)链接到一些真正高档的优质笔记本。也来看看我们的 [Jupyter 笔记本提示](https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/)列表。
> 想了解更多关于 Jupyter 笔记本的信息？我们有[一个引导项目](https://www.dataquest.io/m/207/guided-project%3A-using-jupyter-notebook)你可能会感兴趣。
# 提高 Jupyter 笔记本电脑的工作效率
> 原文：<https://towardsdatascience.com/jupyter-notebook-hints-1f26b08429ad?source=collection_archive---------1----------------------->
# Jupyter (IPython)笔记本特性
首先，我想指出，它是创建可读分析非常灵活的工具，因为人们可以将代码、图像、注释、公式和图表放在一起:
Jupyter 具有很强的可扩展性，支持其他编程语言，几乎可以在任何服务器上轻松托管——您只需要通过 ssh 或 http 访问服务器。而且是完全免费的。
# 基础
热键列表显示在**帮助>键盘快捷键**中(列表会不时扩展，所以不要犹豫再看一遍)。
这给了你一个如何与笔记本互动的想法。如果你经常使用笔记本，你当然会学到大部分的内容。特别是:
* `Esc + F`查找和替换仅搜索代码，不搜索输出
* `Esc + O`切换单元格输出
* 您可以选择一行中的多个单元格，然后删除/复制/剪切/粘贴它们。当您需要移动笔记本的部件时，这很有帮助
# 共享笔记本
最简单的方法是共享笔记本文件。ipynb)，但并不是所有人都在用笔记本，所以选项有
* 将笔记本转换为 html 文件
* 分享给正在渲染笔记本的 gists。
* 将您的笔记本存放在 dropbox 中，并将链接放入 [nbviewer](http://nbviewer.jupyter.org/) 中。nbviewer 将渲染笔记本
* github 渲染笔记本(有一些限制，但在大多数情况下是可以的)，这使得保持你的研究历史非常有用(如果研究是公开的)
# 在笔记本中绘图
有许多绘图选项:
* matplotlib(事实上的标准)，用`%matplotlib inline`激活
* `%matplotlib notebook`是交互式模式，但是非常慢，因为渲染是在服务器端完成的。
* mpld3 为 matplotlib 代码提供了可选的渲染器(使用 d3)。很好，虽然不完整
* 散景是构建交互式地块的更好选择
* plot.ly 可以生成很好的图，但是会让你花钱
# 魔法
魔术师正在把简单的 python 变成*神奇的 python* 。魔法是 ipython 力量的关键。
在[1]中:
# list available python magics
%lsmagic
Out[1]:
Available line magics:
%alias %alias_magic %autocall %automagic %autosave %bookmark %cat %cd %clear %colors %config %connect_info %cp %debug %dhist %dirs %doctest_mode %ed %edit %env %gui %hist %history %killbgscripts %ldir %less %lf %lk %ll %load %load_ext %loadpy %logoff %logon %logstart %logstate %logstop %ls %lsmagic %lx %macro %magic %man %matplotlib %mkdir %more %mv %notebook %page %pastebin %pdb %pdef %pdoc %pfile %pinfo %pinfo2 %popd %pprint %precision %profile %prun %psearch %psource %pushd %pwd %pycat %pylab %qtconsole %quickref %recall %rehashx %reload_ext %rep %rerun %reset %reset_selective %rm %rmdir %run %save %sc %set_env %store %sx %system %tb %time %timeit %unalias %unload_ext %who %who_ls %whos %xdel %xmodeAvailable cell magics:
%%! %%HTML %%SVG %%bash %%capture %%debug %%file %%html %%javascript %%js %%latex %%perl %%prun %%pypy %%python %%python2 %%python3 %%ruby %%script %%sh %%svg %%sx %%system %%time %%timeit %%writefileAutomagic is ON, % prefix IS NOT needed for line magics.
# %环境
您可以管理笔记本的环境变量，而无需重新启动 jupyter 服务器进程。一些库(比如 theano)使用环境变量来控制行为，%env 是最方便的方法。
在[2]中:
# %env - without arguments lists environmental variables
%env OMP_NUM_THREADS=4env: OMP_NUM_THREADS=4
# 执行 shell 命令
您可以调用任何 shell 命令。这对于管理您的虚拟环境特别有用。
在[3]中:
**!**pip install numpy
**!**pip list | grep TheanoRequirement already satisfied (use --upgrade to upgrade): numpy in /Users/axelr/.venvs/rep/lib/python2.7/site-packages
Theano (0.8.2)
# 抑制最后一行的输出
有时不需要输出，所以我们可以在新行上使用`pass`指令，或者在末尾使用分号
在[4]中:
%matplotlib inline
from matplotlib import pyplot as plt
import numpy
在[5]中:
# if you don’t put semicolon at the end, you’ll have output of function printed
plt**.hist(numpy.**linspace(0, 1, 1000)******1.5);
# 看 python 函数/类/什么的源码带问号(？, ?？)
在[6]中:
from sklearn.cross_validation import train_test_split
# show the sources of train_test_split function in the pop-up window
train_test_split**??**
在[7]中:
# you can use ? to get details about magics, for instance:
%pycat**?**
将在弹出窗口中输出:
Show a syntax-highlighted file through a pager.This magic is similar to the cat utility, but it will assume the file
to be Python source and will show it with syntax highlighting.This magic command can either take a local filename, an url,
an history range (see %history) or a macro as argument ::%pycat myscript.py
%pycat 7-27
%pycat myMacro
%pycat http://www.example.com/myscript.py
# %run 执行 python 代码
%run 可以从执行 python 代码。py 文件—这是一种有据可查的行为。
但它也可以执行其他 jupyter 笔记本！有时候还是挺有用的。
NB。%run 与导入 python 模块不同。
在[8]中:
# this will execute all the code cells from different notebooks
%run ./2015-09-29-NumpyTipsAndTricks1.ipynb[49 34 49 41 59 45 30 33 34 57]
[172 177 209 197 171 176 209 208 166 151]
[30 33 34 34 41 45 49 49 57 59]
[209 208 177 166 197 176 172 209 151 171]
[1 0 4 8 6 5 2 9 7 3]
[‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’ ‘j’]
[‘b’ ‘a’ ‘e’ ‘i’ ‘g’ ‘f’ ‘c’ ‘j’ ‘h’ ‘d’]
[‘a’ ‘b’ ‘c’ ‘d’ ‘e’ ‘f’ ‘g’ ‘h’ ‘i’ ‘j’]
[1 0 6 9 2 5 4 8 3 7]
[1 0 6 9 2 5 4 8 3 7]
[ 0.93551212 0.75079687 0.87495146 0.3344709 0.99628591 0.34355057
0.90019059 0.88272132 0.67272068 0.24679158]
[8 4 5 1 9 2 7 6 3 0][-5 -4 -3 -2 -1 0 1 2 3 4]
[0 0 0 0 0 0 1 2 3 4]
[‘eh’ ‘cl’ ‘ah’ …, ‘ab’ ‘bm’ ‘ab’]
[‘ab’ ‘ac’ ‘ad’ ‘ae’ ‘af’ ‘ag’ ‘ah’ ‘ai’ ‘aj’ ‘ak’ ‘al’ ‘am’ ‘an’ ‘bc’ ‘bd’
‘be’ ‘bf’ ‘bg’ ‘bh’ ‘bi’ ‘bj’ ‘bk’ ‘bl’ ‘bm’ ‘bn’ ‘cd’ ‘ce’ ‘cf’ ‘cg’ ‘ch’
‘ci’ ‘cj’ ‘ck’ ‘cl’ ‘cm’ ‘cn’ ‘de’ ‘df’ ‘dg’ ‘dh’ ‘di’ ‘dj’ ‘dk’ ‘dl’ ‘dm’
‘dn’ ‘ef’ ‘eg’ ‘eh’ ‘ei’ ‘ej’ ‘ek’ ‘el’ ‘em’ ‘en’ ‘fg’ ‘fh’ ‘fi’ ‘fj’ ‘fk’
‘fl’ ‘fm’ ‘fn’ ‘gh’ ‘gi’ ‘gj’ ‘gk’ ‘gl’ ‘gm’ ‘gn’ ‘hi’ ‘hj’ ‘hk’ ‘hl’ ‘hm’
‘hn’ ‘ij’ ‘ik’ ‘il’ ‘im’ ‘in’ ‘jk’ ‘jl’ ‘jm’ ‘jn’ ‘kl’ ‘km’ ‘kn’ ‘lm’ ‘ln’
‘mn’]
[48 33 6 …, 0 23 0]
[‘eh’ ‘cl’ ‘ah’ …, ‘ab’ ‘bm’ ‘ab’]
[‘eh’ ‘cl’ ‘ah’ …, ‘ab’ ‘bm’ ‘ab’]
[‘bf’ ‘cl’ ‘dn’ …, ‘dm’ ‘cn’ ‘dj’]
[‘bf’ ‘cl’ ‘dn’ …, ‘dm’ ‘cn’ ‘dj’][ 2.29711325 1.82679746 2.65173344 …, 2.15286813 2.308737 2.15286813]
1000 loops, best of 3: 1.09 ms per loop
The slowest run took 8.44 times longer than the fastest. This could mean that an intermediate result is being cached.
10000 loops, best of 3: 21.5 µs per loop0.416
0.416
# %负载
将代码直接加载到单元格中。您可以选择本地文件或网上文件。
在取消下面代码的注释并执行后，它将用文件的内容替换单元格的内容。
在[9]中:
# %load http://matplotlib.org/mpl_examples/pylab_examples/contour_demo.py
# %store:在笔记本电脑之间传递数据时偷懒
在[10]中:
data = ‘this is the string I want to pass to different notebook’
%store data
del data # deleted variableStored ‘data’ (str)
在[11]中:
# in second notebook I will use:
%store -r data
print datathis is the string I want to pass to different notebook
# %who:分析全局范围的变量
在[12]中:
# pring names of string variables
%who strdata
# 时机
当您需要测量花费的时间或找到代码中的瓶颈时，ipython 可以帮上忙。
在[13]中:
%%time
import time
time.sleep(2) # sleep for two secondsCPU times: user 1.23 ms, sys: 4.82 ms, total: 6.05 ms
Wall time: 2 s
在[14]中:
# measure small code snippets with timeit !
import numpy
%timeit numpy.random.normal(size=100)The slowest run took 13.85 times longer than the fastest. This could mean that an intermediate result is being cached.
100000 loops, best of 3: 6.35 µs per loop
在[15]中:
%%writefile pythoncode.pyimport numpy
def append_if_not_exists(arr, x):
if x not in arr:
arr.append(x)
def some_useless_slow_function():
arr = list()
for i in range(10000):
x = numpy.random.randint(0, 10000)
append_if_not_exists(arr, x)Overwriting pythoncode.py
在[16]中:
# shows highlighted source of the newly-created file
%pycat pythoncode.py
在[17]中:
from pythoncode import some_useless_slow_function, append_if_not_exists
# 分析:%prun，%lprun，%mprun
在[18]中:
# shows how much time program spent in each function
%prun some_useless_slow_function()
输出示例:
26338 function calls in 0.713 seconds Ordered by: internal time ncalls tottime percall cumtime percall filename:lineno(function)
10000 0.684 0.000 0.685 0.000 pythoncode.py:3(append_if_not_exists)
10000 0.014 0.000 0.014 0.000 {method ‘randint’ of ‘mtrand.RandomState’ objects}
1 0.011 0.011 0.713 0.713 pythoncode.py:7(some_useless_slow_function)
1 0.003 0.003 0.003 0.003 {range}
6334 0.001 0.000 0.001 0.000 {method ‘append’ of ‘list’ objects}
1 0.000 0.000 0.713 0.713 :1()
1 0.000 0.000 0.000 0.000 {method ‘disable’ of ‘_lsprof.Profiler’ objects}
在[19]中:
%load_ext memory_profiler
在[20]中:
# tracking memory consumption (show in the pop-up)
%mprun -f append_if_not_exists some_useless_slow_function()(‘’,)
输出示例:
Line # Mem usage Increment Line Contents
3 20.6 MiB 0.0 MiB def append_if_not_exists(arr, x):
4 20.6 MiB 0.0 MiB if x not in arr:
5 20.6 MiB 0.0 MiB arr.append(x)
**%lprun** 是行剖析，但它似乎在最新的 IPython 版本中被打破了，所以这次我们将不用魔法来管理:
在[21]中:
import line_profiler
lp = line_profiler**.LineProfiler()
lp.add_function(some_useless_slow_function)
lp.runctx(‘some_useless_slow_function()’, locals=locals(), globals=globals())
lp.**print_stats()Timer unit: 1e-06 sTotal time: 1.27826 s
File: pythoncode.py
Function: some_useless_slow_function at line 7Line # Hits Time Per Hit % Time Line Contents
7 def some_useless_slow_function():
8 1 5 5.0 0.0 arr = list()
9 10001 17838 1.8 1.4 for i in range(10000):
10 10000 38254 3.8 3.0 x = numpy.random.randint(0, 10000)
11 10000 1222162 122.2 95.6 append_if_not_exists(arr, x)
# 使用%debug 调试
Jupyter 有自己的接口用于 [ipdb](https://docs.python.org/2/library/pdb.html) 。使得进入函数内部并研究那里发生的事情成为可能。
这不是 pycharm，需要很多时间来适应，但是在服务器上调试时，这可能是唯一的选择(或者从终端使用 pdb)。
在[22]中:
#%%debug filename:line_number_for_breakpoint
# Here some code that fails. This will activate interactive context for debugging
一个简单一点的选项是`%pdb`，它在异常出现时激活调试器:
在[23]中:
# %pdb*# def pick_and_take()😗
# picked = numpy.random.randint(0, 1000)
# raise NotImplementedError()
# pick_and_take()
# 用乳胶写配方
markdown 单元格使用 MathJax 渲染 latex。
p(a∣b)=p(b∣a)p(a)p(b)p(a∣b)=p(b∣a)p(a)p(b)
Markdown 是笔记本的重要组成部分，别忘了利用它的表现力！
# 在一个笔记本中使用不同的语言
如果你错过了很多，使用其他计算内核:
* %%python2
* %%python3
* % %红宝石
* %%perl
* %%bash
* %%R
是可能的，但是显然您需要首先设置相应的内核。
在[24]中:
**%%**ruby
puts 'Hi, this is ruby.'Hi, this is ruby.
在[25]中:
%%bash
echo 'Hi, this is bash.'Hi, this is bash.
# 大数据分析
许多解决方案可用于查询/处理大型数据样本:
* [ipyparallel(以前的 ipython cluster)](https://github.com/ipython/ipyparallel) 对于 python 中的简单 map-reduce 操作来说是一个很好的选择。我们在 rep 中使用它来并行训练许多机器学习模型
* [pyspark](http://www.cloudera.com/documentation/enterprise/5-5-x/topics/spark_ipython.html)
* spark-sql magic [%%sql](https://github.com/jupyter-incubator/sparkmagic)
# 让其他人不用安装任何东西就能玩你的代码
像 mybinder 这样的服务可以让用户访问装有 jupyter 笔记本的机器，上面安装了所有的库，这样用户就可以在只有浏览器的情况下玩半个小时。
你可以用 [jupyterhub](https://github.com/jupyterhub/jupyterhub) 设置自己的系统，这在你组织小型课程或研讨会而没有时间关心学生机器时非常方便。
# 其他语言的书写功能
有时候 numpy 的速度不够，我需要写一些快速代码。原则上，你可以在动态库中编译函数并编写 python 包装器…
但是当这个无聊的部分为你做的时候会好很多，对吗？
您可以用 cython 或 fortran 编写函数，并直接从 python 代码中使用它们。
首先，您需要安装:
!pip install cython fortran-magic
在[26]中:
%load_ext Cython
在[27]中:
**%%**cython
def myltiply_by_2(float x):
return 2.0 ***** x
在[28]中:
myltiply_by_2(23.)
Out[28]:
46.0
就我个人而言，我更喜欢使用 fortran，我发现它对于编写数字运算函数非常方便。
在[29]中:
%load_ext fortranmagic/Users/axelr/.venvs/rep/lib/python2.7/site-packages/IPython/utils/path.py:265: UserWarning: get_ipython_cache_dir has moved to the IPython.paths module
warn(“get_ipython_cache_dir has moved to the IPython.paths module”)
在[30]中:
%%fortran
subroutine compute_fortran(x, y, z)
real, intent(in) :: x(😃, y(😃
real, intent(out) :: z(size(x, 1)) z = sin(x + y)end subroutine compute_fortran
在[31]中:
compute_fortran([1, 2, 3], [4, 5, 6])
Out[31]:
array([-0.95892429, 0.65698659, 0.41211849], dtype=float32)
我还应该提到，有不同的抖动系统可以加速你的 python 代码。
# 多个光标
因为最近 jupyter 支持多个光标(在一个单元格中)，就像 sublime ot intelliJ！
Gif 取自 http://swanintelligence.com/multi-cursor-in-jupyter.html
# [Jupyter-contrib 扩展](https://github.com/ipython-contrib/jupyter_contrib_nbextensions)
安装有
!pip install https://github.com/ipython-contrib/jupyter_contrib_nbextensions/tarball/master
!pip install jupyter_nbextensions_configurator
!jupyter contrib nbextension install --user
!jupyter nbextensions_configurator enable --user
这是一系列不同的扩展，包括例如 **jupyter 拼写检查器和代码格式化器**，它们在 jupyter 中是缺省的。
# [崛起](https://github.com/damianavila/RISE):用笔记本做演示
Damian Avila 的扩展使笔记本电脑作为演示展示成为可能。此类演示的示例:[http://bollwyvl.github.io/live_reveal/#/7](http://bollwyvl.github.io/live_reveal/#/7)
当你教别人使用图书馆时，这是非常有用的。
# Jupyter 输出系统
笔记本显示为 HTML，单元格输出可以是 HTML，因此您可以返回几乎任何内容:视频/音频/图像。
在本例中，我扫描了存储库中包含图像的文件夹，并显示了前五个图像:
在[32]中:
import os
from IPython.display import display, Image
names = [f for f in os**.listdir(‘…/images/ml_demonstrations/’) if f.endswith(‘.png’)]
for name in names[:5]:
display(Image(‘…/images/ml_demonstrations/’ + name, width=**300))
# 我可以用 bash 命令获取相同的列表
因为 magics 和 bash 调用返回 python 变量:
在[33]中:
names = **!**ls …/images/ml_demonstrations/*.png
names[:5]
Out[33]:
[‘…/images/ml_demonstrations/colah_embeddings.png’,
‘…/images/ml_demonstrations/convnetjs.png’,
‘…/images/ml_demonstrations/decision_tree.png’,
‘…/images/ml_demonstrations/decision_tree_in_course.png’,
‘…/images/ml_demonstrations/dream_mnist.png’]
# 重新连接到内核
很久以前，当您开始某个耗时的过程，并且在某个时刻您与 ipython 服务器的连接断开时，您完全失去了跟踪计算过程的能力(除非您将这些信息写入文件)。因此，要么中断内核并潜在地丢失一些进程，要么等到它完成而不知道发生了什么。
选项现在可以在不中断计算的情况下再次连接到正在运行的内核，并显示新的输出(但是部分输出已经丢失)。
# 在笔记本上写下你的帖子
比如这个。使用 nbconvert 将它们导出到 html。
# 有用的链接
* IPython [内置魔法](https://ipython.org/ipython-doc/3/interactive/magics.html)
* Ben Zaitlen 关于 jupyter 的精彩互动演示
* 高级笔记本[第一部分:魔法](https://blog.dominodatalab.com/lesser-known-ways-of-using-notebooks/)和[第二部分:小工具](https://blog.dominodatalab.com/interactive-dashboards-in-jupyter/)
* [使用 jupyter 在 python 中进行剖析](http://pynash.org/2013/03/06/timing-and-profiling/)
* [扩展笔记本的 4 种方式](http://mindtrove.info/4-ways-to-extend-jupyter-notebook/)
* [IPython 笔记本小技巧](https://www.quora.com/What-are-your-favorite-tricks-for-IPython-Notebook)
* [Jupyter vs Zeppelin 争夺大数据](https://www.linkedin.com/pulse/comprehensive-comparison-jupyter-vs-zeppelin-hoc-q-phan-mba-)
# Jupyter 笔记本毫无特色——使用 Jupyter 实验室
> 原文：<https://towardsdatascience.com/jupyter-notebooks-are-breathtakingly-featureless-use-jupyter-lab-be858a67b59d?source=collection_archive---------4----------------------->
我们喜欢 Jupyter 笔记本，笔记本格式是构建数据叙事的有效方式。但是浏览器内置集成开发环境只是简单的免费功能，很难提供 Atom、VS Code、Sublime 甚至 RStudio 那种不可思议的编辑能力。因此，从工作流的角度来看，数据科学和数据工程之间的差距仍然很大。让我们缩短这个差距。
Jupyter Notebook
让我们来看看典型的数据科学家工作流程。他们打开笔记本，导入一些数据，做一些探索性分析，然后建立一个模型。如果他们发现了新的东西，他们可能希望在生产中实现它。
*解决方案的当前笔记本表现与生产实施有多接近？*远得不可思议。
笔记本的某些部分是可重用的，可视化的部分我们可能会省去，希望一些功能已经定义。但这正是 Jupyter 笔记本的局限性真正开始显现的地方。
*我的文件树*在哪里？如果我的文件树不容易看到，就很难保持一个干净的、可管理的存储库。不用说，我们也希望一些基本的跳转功能，一次打开多个文档。*如何将我的代码快速转移到 python 脚本中？* *我的终端在哪里？*我知道我可以通过导入和显示熊猫来查看原始数据，但让我们面对现实吧，这与 RStudio 的文件查看器相比相形见绌——我的*合法 csv 查看器在哪里？*和* w *我的 Jupyter 笔记本左右两边浪费的空间是什么？**
正是由于 Python 作为一种语言的优势，以及笔记本文档作为一种呈现叙事的手段，Jupyter 笔记本一直保持着与 RStudio 的竞争力——**而不是 Jupyter 的实际特性**。
当然，所有这些事情都可以通过额外的窗口来解决。但是我们不会对我们的编辑器和 IDE 做出这样的妥协。Atom 为您提供了跳转功能、广泛的热键灵活性、文件树(可以关闭),以及几乎任何您可以在编辑器中想象到的东西。
[Jupyter Lab](https://github.com/jupyterlab/jupyterlab) 在其 *Alpha* 产品中提供了这些对功能的基本期望；尽管产品仍在开发中，但它的功能已经让最初的 Jupyter 笔记本黯然失色。
Jupyter Lab
在 Jupyter Lab 上的 PyData Seattle 演讲中，作者演示了打开 1 万亿行乘 1 万亿列的 csv(并毫不费力地在各列之间左右滚动)，以及使用 Jupyter Lab Google Drive 扩展、OOTB 维加和 GeoJSON 兼容性以及许多其他令人难以置信的功能进行实时协作。
Jupyter 实验室和 Jupyter 笔记本有两个不变量。
1. 笔记本文档是相同的(您的旧文档仍然有效)。
2. 笔记本电脑服务器是相同的(您的集成仍然有效)。
我写这篇文章是因为我最近向我的几个同事演示了 Jupyter 实验室。他们的反应？*“我怎么没听说过这个？”*这些功能早就应该出现了，我认为是时候做出改变了，让我们的日常数据科学离生产代码更近一步。
# Jupyter 笔记本，如 Light、Percent 或 Sphinx 脚本
> 原文：<https://towardsdatascience.com/jupyter-notebooks-as-light-percent-or-sphinx-scripts-efca8bc3aa44?source=collection_archive---------18----------------------->
几周前，我们[发布了](/introducing-jupytext-9234fdff6c57) Jupytext，这是 Jupyter 的一个插件，可以像脚本一样读写 Jupyter 笔记本。将 Jupyter 笔记本表示为文本文件大大简化了笔记本的使用。笔记本作为脚本很容易编辑、重构，甚至可以在专门的 ide 中执行。Jupyter 笔记本作为脚本的版本控制产生了有意义的差异。最后，在笔记本的文本表示上合并多个贡献并不比在标准脚本上合并贡献更难，这为在 Jupyter 笔记本上更容易的协作开辟了道路。
Jupytext 的最初版本为笔记本引入了`light`格式作为脚本。从那以后，我们继续探索如何最好地将 Jupyter 笔记本表现为文本文件。我们与 Spyder、Hydrogen 和 Matplotlib 团队进行了有趣的交流，除了`light`格式之外，他们还发现了两种将 Jupyter 笔记本表示为 Python 脚本的现有的流行格式:`percent`和`sphinx`格式。
下面，我们简要回顾一下这三种格式，并回忆一下如何在 Jupyter 笔记本和这三种格式之间来回转换。
# `light`格式
当我们准备 Jupytext 的初始版本时，我们在设计`light`格式时考虑了以下目标:
* 将任意脚本作为笔记本打开，带有有意义的单元格，
* 将笔记本表示为带有少量单元格标记的脚本，如果可能的话，不要标记，
* 在往返转换时保留笔记本的脚本和输入。
普通脚本没有单元格标记。所以我们决定代码段应该是自然细胞。后跟缩进行的空行以及属于多行注释的空行不被视为单元格分隔符。完全注释的段落被理解为标记单元格。
在 Jupytext 中，我们关心的是往返转换——我们不想弄乱你的笔记本！因此，我们必须找到一种方法来明确地识别在 Jupyter 笔记本中包含不止一个代码段的代码单元。为此，我们使用`# +`作为单元开始标记，使用`# -`作为单元结束标记。
对于所有类型的单元格，`light`格式完全支持单元格元数据。包含元数据的单元格有一个显式的头`# + {JSON}`，其中元数据以 JSON 格式表示。
此处提供了`light`格式的笔记本样本[。](https://github.com/mwouts/jupytext/blob/master/demo/World%20population.lgt.py)
`light`格式已经在 Python 脚本上进行了广泛的测试。Jupytext 也为 R、Julia、Scheme、C++实现了那种格式，如果这里没有列出你最喜欢的语言，欢迎询问！
# `percent`格式
受 Matlab 启发的`percent`格式是 Spyder 在五年前推出的。现在支持该格式的有:
* [Spyder IDE，](https://docs.spyder-ide.org/editor.html#defining-code-cells)
* [氢，](https://atom.io/packages/hydrogen)基于原子的笔记本编辑器，
* [VS 代码](https://code.visualstudio.com/)使用 [vscodeJupyter](https://marketplace.visualstudio.com/items?itemName=donjayamanne.jupyter) 扩展时，
* [Visual Studio 的 Python 工具](https://github.com/Microsoft/PTVS)，
* [PyCharm 专业](https://www.jetbrains.com/pycharm/)。
Jupytext 也实现了`percent`格式。为了实现 Jupyter 笔记本到`percent`脚本的无损往返转换，我们扩展了格式以支持 markdown 和 raw 单元格，以及单元格元数据。我们实现的单元头是:
%% Optional cell title [cell type] {optional JSON metadata}
其中单元格类型要么省略(代码单元格)，要么`[markdown]`或`[raw]`。显然，markdown 和 raw 单元格的内容在`percent`脚本中被注释掉了！
这里有`percent`格式的笔记本样品[。](https://github.com/mwouts/jupytext/blob/master/demo/World%20population.pct.py)
格式不限于 Python。 [Hydrogen](https://atom.io/packages/hydrogen) 已经将`percent`格式推广到所有的 Jupyter 语言:Julia、Python、R、Javascript 等等！Jupytext 目前实现了 Julia、Python、R、Scheme 和 C++的`percent`格式。再说一次，你可以要求更多。
上面列出的所有编辑器都可以识别单元格，并允许执行它们的内容。Hydrogen 甚至在输入电池的正下方显示输出，就像 Jupyter 笔记本一样。并且 [Matplotlib](https://gist.githubusercontent.com/mwouts/91f3e1262871cdaa6d35394cd14f9bdc/raw/3e2dde646d66207e132fba30d7c407a5917c0371/percent_format_matplotlib.png) 和 [Plotly](https://gist.githubusercontent.com/mwouts/91f3e1262871cdaa6d35394cd14f9bdc/raw/3e2dde646d66207e132fba30d7c407a5917c0371/percent_format_plotly.png) 两个图都很好的集成在编辑器中。
# 狮身人面像画廊格式
这是 Matplotlib 用来生成其[图库](https://matplotlib.org/gallery.html)的格式。文本单元格表示为三重引号字符串或注释文本块，以带有许多散列符号的行开始。连续的代码单元用空字符串分隔。
Jupytext 实现了 Jupyter 笔记本的`sphinx`格式，这里给出了一个笔记本示例[。如果你想为你的斯芬克斯画廊设计新的例子，使用这种格式，或者反过来，如果你想使用](https://github.com/mwouts/jupytext/blob/master/demo/World%20population.spx.py) [mybinder](http://mybinder.org/) 和 [Jupytext](https://github.com/mwouts/jupytext/blob/master/README.md#sphinx-gallery-scripts) 作为 Jupyter 笔记本访问你的斯芬克斯画廊。
# 使用 Jupytext
使用升级 Jupytext
pip install jupytext --upgrade
Jupytext 为 Jupyter 提供了一个插件，允许你在 Jupyter 中将脚本作为笔记本打开，并与配对的笔记本一起工作(下面将详细介绍)。将 Jupytext 的内容管理器添加到您的 Jupyter 配置文件`.jupyter/jupyter_notebook_config.py`:
c.NotebookApp.contents_manager_class=“jupytext.TextFileContentsManager”
通过将`"jupytext": {"formats": "ipynb,py:percent"},`添加到笔记本元数据，将脚本或笔记本转换为配对笔记本。然后，Jupyter 将你的笔记本保存为传统的`.ipynb`文件和补充的`percent`格式的`.py`文件。正如[公告](/introducing-jupytext-9234fdff6c57)中所述，您可以编辑`.py`文件，并刷新 Jupyter 以获得更新的输入单元格(通过在单元格中运行`%autosave 0`关闭 Jupyter 的自动保存)。
或者，使用[命令行转换器](https://github.com/mwouts/jupytext/blob/master/README.md#command-line-conversion)将 Jupyter 笔记本转换为`percent`脚本，然后再转换回来:
create notebook.py with ‘# %%’-cells
jupytext --to py:percent notebook.ipynb# update input cells in notebook.ipynb
jupytext --to ipynb --update notebook.py
使用以下命令将`light`脚本转换为`percent`脚本:
Convert light.py to percent.py
jupytext --from py:light --to py:percent --output percent.py light.py# In place conversion! Handle with care.
jupytext --from py:light --to py:percent notebook.py
# 所有格式一览
# 结论
将笔记本表示为文本文件可以方便地重构、共享和版本控制 Jupyter 笔记本。作为文本文件的笔记本不包括输出单元格，因此当[将](https://github.com/mwouts/jupytext/blob/master/README.md#paired-notebooks)与传统的`.ipynb`笔记本配对时，它们工作得最好。
Jupyter 笔记本可以用各种文本格式表示。除了 [Markdown](https://github.com/mwouts/jupytext/blob/master/demo/World%20population.md) 和 [R Markdown](https://github.com/mwouts/jupytext/blob/master/demo/World%20population.Rmd) 之外，Jupytext 还将 Jupyter 笔记本实现为`light`和`percent`脚本。使用`light`格式(由 Jupytext 提供)打开任意脚本作为笔记本，并以离散单元格格式保存笔记本。或者用 Spyder 五年前贡献的`percent`格式，现在很多编辑都支持。这四种格式是语言不可知的，已经在 Python、Julia、R、Scheme 和 C++笔记本上进行了测试。
你愿意投稿吗？我们想使格式规范坚如磐石，请让我们知道你是否能帮忙。我们也对向`light`和`percent`格式添加[更多语言](https://github.com/mwouts/jupytext/blob/master/README.md#extending-the-light-and-percent-formats-to-more-languages)的贡献感兴趣。一个能够编辑元数据的[笔记本扩展](https://github.com/mwouts/jupytext/issues/86)将会改善用户体验。
# Jupyter 笔记本让我变成了一个懒惰的程序员…
> 原文：<https://towardsdatascience.com/jupyter-notebooks-made-me-a-lazy-programmer-bef237c310bf?source=collection_archive---------11----------------------->
Don’t try this at home.
## …而且方式不对
像大多数数据科学家和机器学习实践者一样，我使用 Jupyter 笔记本进行原型设计、执行数据分析，并将我的结果传达给其他团队成员、上层管理人员、客户和利益相关者。Jupyter 在这方面很棒，然而不知何故，在几乎专门在笔记本上编码一段时间后，我发现我的编码能力开始下降。过了一段时间，我发现自己染上了坏习惯。
很多时候，我会发现自己在复制和粘贴可以轻松重用的大代码块，或者在需要的地方随意导入代码。如果你只是拼凑一些东西，这没什么问题，但当需要展示你的代码或组装成完整的演示或解决方案时，你不得不争先恐后地将你的片段组装成类似于所谓的机器学习“专家”开发的复杂预测模型的东西。
> 如果把 X 改成 Y 运行，结果会怎么样？
我们都听说过。在自豪地宣称您可以在他们眼前动态运行您的模型并生成结果后，您正在进行现场演示！不要介意你刚刚花了 6 个小时润色你的图表、表格和其他可视化的东西来有效地传达你的结果。因为你已经在笔记本上设计了你的模型，代码很可能是支离破碎的，不能很好地概括来处理这个问题。有时这是不可避免的，但我发现我已经不止一次遇到这种情况，结果是可信度降低。我们都去过那里(…对吗？)
我不是对笔记本有意见，绝对不是。笔记本摇滚。我回想起当初为什么开始用笔记本。听我说，这一切都是有意义的。
我在一台机器上工作，这台机器充当了我团队的 YARN 集群和我在其上开发的其他虚拟机的网关。在我早期的职业生涯中，我使用了许多不同的 ide 和文本编辑器来开发我的代码和模型。现在我在一个充满挑战的环境中工作。我很快就和维姆成为了好朋友。Vim 无处不在，它比大多数人意识到的要强大得多。
vim — it actually doesn’t suck.
这是一个完全不同的问题。我很快开始成为 vim 超级用户，并发现自己比以前更有效率了！我的编码能力提高了，很快我发现自己一直在制造新的算法，能够从一个系统跳到另一个系统，而不必每次都重新配置我的开发环境。我势不可挡…
…至少我是这么认为的。尽管我可以编写大量的脚本和代码来生成可视化效果、表格或写入我们的数据库，而不会有在演示过程中被要求编码的尴尬。即便如此，我还是被迫在编码前思考——在写之前设计我的模型。这留下了大量可重用的设计模式，我可以用它们来构建有效的模型。这极大地增强了我的能力，我将这些代码汇编成库，可以随时调用。现在，我的剧本仅仅是一口袋的台词，然而却能让我领悟到在过去曾让我领悟了数百次的东西。掌握 vim 让我变得懒惰——以一种好的方式！我已经到达了数据科学的天堂，但是我仍然缺少一些东西。
不知何故，一切都太死板了。此外，我只在远程机器上工作。将 matplotlib 可视化中导出的图像复制回我的根计算机以查看结果，挑剔的 X-forwarding，或者依赖于更大的基础设施和 It 限制，这真的很烦人。不，我想要再次自由。我想让我的代码感觉我又一次在一台机器上工作，当我完成或想继续程序执行时，我可以弹出一个绘图窗口并关闭它。此外，我希望向我们的最终用户公开一些我已经编入我的宝贵库中的数据争论和算法功能，其中一些用户本身就是数据科学家。
进入 Jupyter。哇，当我建立了我的第一个 Jupyter 环境并通过代理运行时，我就被迷住了。我可以从任何网关机器上访问它。现在，我甚至可以从任何机器上直接登录到我的环境中，并运行交互式代码。我甚至可以在利益相关者的机器上这样做，并向他们展示我在用他们的数据做什么。感觉棒极了。很快，我的团队让 Jupyter hub 在我们的环境中运行。我仍然可以通过使用我的老朋友 vim 在我们的虚拟机上开发我的结构化代码和库，但是可以使用 Jupyter 快速原型化新算法。什么会出错？
嗯，就像我们大多数人在某个时候发生的一样，我换了工作。我现在正在研究新机器。我的旧代码？不可接近，在我以前的同事手里，对我来说完全看不见。哦，好吧，去做更大更好的事情吧！
我从以前的工作中学到了很多，我想用我学到的知识前进。我立即着手开发一个新的模型，这次我从 Jupyter 笔记本开始。很快，我发现自己的代码杂乱无章，笔记本支离破碎。别让我开始讨论范围问题！然后人们开始要求我和他们分享我的作品。啊哦，人们都会看到我的代码！很快，我发现自己抄近路，走捷径，让事情运行简单，但至少我又有效率了。我的笔记本自给自足，能够从头到尾完整地解释我的过程和模型。
> 你为什么一直滚动这么多代码？我只想看到结果。
有可能，如果你在听到这个之前已经在笔记本上演示过，或者至少是类似的东西。他们是对的——大多数人不关心你的代码，所以虽然展示代码对数据科学家来说很好，但对客户来说就不那么好了，你知道，那些帮你赚钱的人？
进入 reveal.js 这改变了我写笔记本的方式！我可以点击一个小标签，在演示中隐藏我的代码。想展示我的代码吗？打开和关闭非常简单。
我仍然发现自己退回到糟糕的编码习惯。我无法在良好的编码实践和编写可重用性以及 Jupyter 提供的敏捷性之间找到平衡。本质上，因为我没有被强迫去想清楚，所以我没有。我已经变成了一个懒惰的程序员。当然，我是有效的，但是我仍然为我的代码感到尴尬。有时候难看的代码很重要——我们数据科学家有时候需要粗制滥造一个模型，让代码的美丽见鬼去吧。如果有一种方法可以让笔记本快速原型化，并且在共享我的笔记本时隐藏我的代码就好了。我想拥有可演示的笔记本，而不需要旋转一堆旋钮和隐藏代码来让它看起来像样。我需要别的东西。我需要…
…JupyterLab！JupyterLab 就像是上帝给我的礼物。我不仅可以快速组装笔记本，还可以在同一个基于 web 的环境中直接将我的类和函数复制粘贴到文本文件中。这让我重新开始计划。不知何故，让文本文件和笔记本一起编辑让一切都不同了。不仅仅是编辑。实验室能让你接触到终端。但是等等，还有呢！
我找回了我的活力。嗯，部分原因。它至少拥有多年来成为肌肉记忆的相同键绑定。当然，我一直带着它，但是现在我把它放在我心爱的笔记本旁边。但是仍然缺少一些东西。我讨厌轻松的主题。笔记本默认是浅色的，只有通过安装第三方扩展，你才能切换到深色的。这没什么不对的，除非你无法访问你正在使用的 Jupyter 笔记本服务器。JupyterLab 的文本编辑器有多个深色主题，Lab 整体有一个深色主题。
太美了。我已经决定(现在！)是我快速迭代的工作流。如果我发现自己写的东西在演示中没有用武之地，我会把它藏到别处，并从我的笔记本中引用文件或库。这比我以前做的感觉好多了，我只是在这里抓了一点皮毛。如果你喜欢笔记本电脑，但发现自己陷入了和我类似的陷阱，给 JupyterLab 一针——我打赌你会喜欢它。
总而言之:
* 保持你的*真实*代码与你的笔记本分开，除非你在写编码教程。这会让你的笔记本更整洁，养成把东西分开的习惯会让你更有效率。将来你会感谢你的。
* 动笔之前先思考。这将避免不得不当场拼凑一些东西来回答一个问题。能当场跑位是 Jupyter 的一部分实力，用起来！
* 使用 JupyterLab。说真的，太神奇了。
* 玩得开心！
*本文表达的观点为本人观点，不一定与本人雇主相同。
# 提高生产力的 Jupyter 工具
> 原文：<https://towardsdatascience.com/jupyter-tools-to-increase-productivity-7b3c6b90be09?source=collection_archive---------1----------------------->
Photo by [Philip Swinburn](https://unsplash.com/photos/vS7LVkPyXJU?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText) on [Unsplash](https://unsplash.com/search/photos/tools?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText)
> *“如果你唯一的工具是一把锤子，你会把所有的问题都看成钉子。”*
>
> *亚伯拉罕·马斯洛*
像许多其他数据科学家一样，Jupyter notebook 是我的数据科学工具包中不可或缺的一部分。它易于使用，功能强大得令人难以置信。在这篇文章中，我将记录一些可用的扩展和特性，我认为每个使用 Jupyter 的人都应该熟悉它们。
但是等等，这难道不是旧东西吗？既然 JupyterLab 刚刚出现，我们现在应该对它感到满意吗？
JupyterLab 是 Jupyter 笔记本电脑的发展，引入了一些期待已久的功能，然而它目前处于测试阶段，当我试用它时，发现许多为 JupyterLab 开发的很酷的扩展由于版本兼容性问题不能很好地工作。所以我想，即使 JupyterLab 是未来，至少在不久的将来，我还是会坚持使用经典笔记本几个月。
# Jupyter contrib nbextensions
你知道 Jupyter 笔记本有扩展吗！确实有，而且非常有用！
*安装*
[官方 github repo](https://github.com/ipython-contrib/jupyter_contrib_nbextensions) 有安装的所有细节，所以我不会重复这些。但是，如果你懒得去过，这里是 TLDR 版本的基本步骤:
pip install jupyter_contrib_nbextensionspip install https://github.com/ipython-contrib/jupyter_contrib_nbextensions/tarball/masterjupyter contrib nbextension install --user
还要安装扩展配置器，以便轻松切换扩展:
pip install jupyter_nbextensions_configuratorjupyter nbextensions_configurator enable --user
你完了！
刷新 Jupyter 主页，您应该能够看到类似这样的内容:
nbextensions tab
以下是一些我认为有用的 nbextensions，并简要描述了它们的功能:
1. *目录(2)* :根据笔记本的表头单元格自动创建一个目录。`Display Table of Contents as a sidebar`选项创建了一个 TOC 作为侧边栏，有助于保持上下文和浏览笔记本。
Table of contents
*2。可折叠的标题*:这个和 toc2 一起可以很好的卷起笔记本中你不想在特定时间关注的部分。
Collapsible heading
*3。代码折叠*:您可以通过折叠函数定义和长代码块来减小单元格的大小。
codefolding
*4。execute time*:`%%time`单元格魔术函数对于检查运行时非常有用。但是有了 ExecuteTime，所有代码单元格的运行时都显示在左下角，所以你不需要记得使用单元格魔术。
execute time
*5。Gist-it* :非常适合在 Github 上创建 Gist。为什么是 gist？实验时可以在不同状态下保存同一个笔记本的不同版本。此外，gists 更容易共享和引用。
*6。隐藏所有输入*:当你需要编码来生成和输出，但是不需要显示代码的时候(为了简洁)，这对于整理一个笔记本来演示是很棒的。
# Jupyter 魔法函数
Jupyter 中有很多神奇的功能。对于 Ipython 内核，这里是到文档的[链接。](http://ipython.readthedocs.io/en/stable/interactive/magics.html)
以下是一些我认为特别有用的线条魔术功能:
1. `%cd <path>`:在笔记本中切换工作目录的快捷方式。
2. `%autoreload`:在每个使用脚本/项目的笔记本上使用。您对它们所做的更改将自动重新加载到 jupyter 上下文中。
%reload_ext autoreload
%autoreload 2
1. `%timeit`:多次运行代码行，并打印代码运行时的度量。
2. `%lprun and %mprun`:python 的行分析器和内存分析器。非常适合优化代码:
line profiler in action
要使用 line_profiler，请使用 pip 安装它:
pip install line-profiler
pip install memory_profiler
然后加载扩展:
%load_ext line_profiler
%load_ext memory_profiler
1. `!`或`%%bash` : Bash 命令在终端上很容易使用，但是如果你有一系列需要重复运行的命令，那么把它们放在笔记本上就更好了！一行之前的`!`将在 bash 中执行该行。例如:
!ls -lht
如果您使用 AWS 之类的云服务，并且您有多个 cli 命令，将它们放在一个笔记本中会使事情变得容易得多，因为您有可搜索的命令历史和结果。
注意:由于某种原因，我发现使用单元格魔术`%%bash`会在执行完成后打印输出*。这对于大多数用例来说是好的，但是假设您正在检查 docker 日志，您可能很想检查进度。*
# 临时演员
Jupyter 还可以做很多其他很酷的事情，但我无法一一列举，只能列出一个简短的列表:
1. *Jupyter 小部件:* Jupyter 支持小部件，也支持有用的[交互](https://ipywidgets.readthedocs.io/en/latest/examples/Widget%20List.html)甚至很酷的[可视化](http://jupyter.org/widgets)。交互小部件对于创建交互式笔记本来说是很棒的，我想如果你安装了 JupyterHub，它们会更棒，这样你就可以在笔记本上协作了。
2. *跨语言支持:*事实证明，Jupyter 实际上是一个缩写——Julia Python R，并且有许多不同语言的内核。。
3. *调试:【Jupyter 笔记本有很多调试选项，哪一个最有效很大程度上取决于你如何编写代码。对我来说，由于我将大部分代码放在了`.py`文件中，所以我使用 ipython 调试器来调试代码:*
from IPython.core.debugger import set_tracedef func(x):
x = x+2
set_trace()
x = x-2
return xfunc(2)
这将弹出一个交互框来检查笔记本中的变量。
还有更容易使用的选项:
出现异常时打开调试器界面的`%%pdb`单元魔术。
或者你可以在出现异常后立即运行`%debug`行来检查堆栈。
4.Jupyter 笔记本预览与 Vistual 工作室代码
所以笔记本很棒，当你更有条理的时候，你可以用它做更多的事情。但是，笔记本的版本化仍然是个问题。这意味着你可能会为一个项目制作几十个笔记本，如果你想找到一些你在项目早期写的代码，你必须一个接一个地打开它们，或者试着记住 grep 的相关关键词。除了使用命名约定和利用文件夹结构之外，我没有解决版本控制问题的干净的解决方案，但是，对我来说，如果我可以预览笔记本而不必启动内核并等待它加载(特别是如果笔记本很大的话)，这是有帮助的。拯救的 Visual Studio 代码！这个方便的文本编辑器与 Sublime Text 非常相似，并且有一个方便的插件`vscode-nbpreviewer`，它允许你在不启动内核的情况下打开笔记本，加载速度非常快。
使用 Visual Studio 代码的另一个好处是:spyder 喜欢脚本中的代码单元，因此您可以将代码从脚本发送到编辑器
此外，它是 Anaconda 的可选安装！
这是我目前所有的。随着我发现更多有用的东西，我会继续更新。感谢阅读！
# JupyterLab 是我们一直在寻找的数据科学用户界面
> 原文：<https://towardsdatascience.com/jupyterlab-you-should-try-this-data-science-ui-for-jupyter-right-now-a799f8914bb3?source=collection_archive---------1----------------------->
Jupyter 项目(正式名称为 IPython)是一个多语言、基于网络的开源数据科学工具。通过[笔记本](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html#notebook-document)的想法，它支持跨[多种编程语言](https://github.com/jupyter/jupyter/wiki/Jupyter-kernels)(所谓的[内核](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html#kernel))的交互式数据科学和[科学计算](https://github.com/jupyter/jupyter/wiki/A-gallery-of-interesting-Jupyter-Notebooks)。
Jupyter 与语言无关的行为使它成为一个可能的游戏规则改变者，因为它将多个开源社区团结在同一个工具周围。它现在有一个很大的社区，并且发展得非常快，导致 Github 上出现了许多扩展——包括一个由 SAS 自己维护的用于 SAS 的[内核，一个用于](https://github.com/sassoftware/sas_kernel) [SPARQL 查询](https://github.com/paulovn/sparql-kernel)的内核，多个[小部件](http://jupyter.org/widgets.html)等等。
Jupyter 目前默认的笔记本界面(上图)已经相当不错了，但它可能已经找到了继任者:JupyterLab。JupyterLab 正在成为 Project Jupyter 的下一代 UI，因为它为用户提供了类似 IDE 的体验(如下图)。JupyterLab 不需要用户处理分散的工具，而是将数据科学家需要的大部分工具放在一起，允许窗口停靠/组合和按需创建动态仪表板。这种可定制的灵活环境无疑会提高工作效率，并可能改变用户对笔记本电脑的看法。
JupyterLab Demo (own)
除了提供像文件浏览器、终端、图像浏览器、控制台、代码/文本编辑器等工具之外。在同一个屏幕上，JupyterLab 允许使用第三方扩展。这种扩展可能不仅与笔记本本身有关，还与整个公共数据科学生态系统有关。作为一个很好的例子，在下面的视频中，我们可以看到一个扩展，允许用户在编辑笔记本时(通过 Google Drive)实时**协作**，以及第二个 UI 优化的扩展，允许用户打开包含(字面上)数万亿行的海量 CSV 文件并与之交互。
你可以在项目的[库](https://github.com/jupyter/jupyterlab)找到更多关于如何安装 JupyterLab 的细节。现在，这里是安装基础:
**如果用康达:**
conda install -c conda-forge jupyterlab
**如果使用画中画:**
pip install jupyterlab
jupyter serverextension enable --py jupyterlab --sys-prefix
**如果你有一个**[**JupyterHub**](https://github.com/jupyterhub/jupyterhub)**环境:**
//Install JupyterLab and then install this extension
jupyter labextension install @jupyterlab/hub-extension**//Edit** “jupyterhub_config.py” and add/edit the following line c.Spawner.default_url = ‘/lab’//This issue may be useful for troubleshooting
# **号外:**
下面的演讲(由@[**SylvainCorlay**](https://twitter.com/SylvainCorlay)**在 PlotCon)是一个了解 ipywidgets 和其他基于 Jupyter 构建的流行小部件库提供的大多数特性和功能的好机会。在视频中，您可以看到 JupyterLab 如何通过在嵌套布局中组装简单的控件和可视化小部件来支持仪表板的创作。**
# 只是另一个试图预测股市的人工智能:第 1 部分
> 原文：<https://towardsdatascience.com/just-another-ai-trying-to-predict-the-stock-market-part-1-d0663673a30e?source=collection_archive---------2----------------------->
学习如何建立机器学习模型既不是一件简单的事情，也不是一件容易的事情。我花了一个月左右的时间学习神经网络如何详细工作，以及是什么让某些模型比其他模型表现得更好。
现在我决定将我的知识付诸实践，实现一个相当简单的例子——使用 GRU 网络预测 S&P500 指数的股票价格。
**你可以将这些系列作为你机器学习之旅的起点，所以不要犹豫，毫无准备地投入进去吧。**如果有任何问题，请在评论区与我分享。
## #1.准备数据
我们应该做的第一件事就是获取数据来训练我们的模型。雅虎财经是一个寻找任何公司新数据的好地方。因此，我们将使用从 1950 年 1 月 1 日到今天这段时间的 [S & P500 数据集](https://finance.yahoo.com/quote/%5EGSPC/history?p=%5EGSPC)。只需点击*下载数据*即可。
出于这个例子的目的，我们将只使用一个 python 文件，没有面向对象的模式或任何花哨的结构。让我们将文件命名为 *sp_rnn_prediction.py* 并加载数据。
这些库的目的如下:
* [numpy](http://www.numpy.org/) —用于轻松进行矩阵计算和数学运算，这对于任何 ML 模型都是必不可少的
* [熊猫](https://pandas.pydata.org/) —用于为你的训练数据定义一个好的数据结构
* [sklearn](http://scikit-learn.org/stable/) —用于数据分析的工具(例如标准化或聚类数据)
* [matplotlib](https://matplotlib.org/) —用于显示我们的数据
* [tensorflow](https://www.tensorflow.org/) — Google 的开源库，用于以简单优雅的方式构建 ML 图
数据集应分为训练/验证/测试部分，每个部分都相互独立。我选择将数据分成 80%的训练、10%的验证和 10%的测试。
最后，我用*熊猫*来装载*。csv* 文件，并将其存储到一个数据框架中。我们将在后面看到如何使用它。
## #2.操纵数据
我们的下一步是以某种方式改革数据，使其可用于训练。
首先，我们需要规范化它，这基本上意味着将每个特征缩放到一个给定的范围，在我们的例子中，这个范围在 0 和 1 之间。正常化通过以下方式实现:
我们使用`sklearn.preprocessing.MinMaxScaler()`和`fit_transform`将*开盘价、最高价、最低价和收盘价*中的每个值拟合到 0-1 的范围内，并将这些矩阵转换为(-1，1)的形状。用(-1，1)整形意味着我们希望，例如，`df['open'].values`成为形状(k，1)的矩阵，其中 k 未知，由 numpy 决定。在这种情况下，k 将等于不同价格的数量。
然后，我们需要将数据分为训练、验证和测试。如上所述，80%是培训，10%是验证，10%是测试。
在上面的代码片段中有 3 个主要步骤:
1. 将数据分割成长度相同的不同数组`seq_len`。
2. 根据项目数量确定训练/验证和测试数据的长度。
3. 按照正确的比例划分数据。
## #3.显示数据
最后，我们需要显示规范化的数据。这对于模型性能来说并不重要，但是在调试代码时非常有用。因此，应该养成经常可视化数据集的习惯。
在绘制数据之前，我们需要使用上面定义的方法。
首先，我们复制数据帧并删除未使用的参数(本例中为“Volume”)，然后对其他值进行规范化。之后，我们只需要使用 matplotlib 库来绘制它:
* 第 14 行:初始化图像帧。
* 第 15–18 行:绘制不同的值。
* 第 19–23 行:添加符号并显示图形。
S&P500 price visualization (normalized)
## 在下一部分
我们以上面的可视化来结束第一部分。在[第 2 部分](/just-another-ai-trying-to-predict-the-stock-market-part-2-88605f9d8e45)中，我们将重点关注使用价格训练模型。我们将大量使用 TensorFlow，因此您可以看到这个优秀的库在实践中是如何工作的。
## 谢谢你的阅读。如果你喜欢这篇文章，给它一些掌声👏。希望你有一个伟大的一天！
# 只是另一个试图预测股市的人工智能:第二部分
> 原文：<https://towardsdatascience.com/just-another-ai-trying-to-predict-the-stock-market-part-2-88605f9d8e45?source=collection_archive---------3----------------------->
在本节中，我将向您展示如何使用来自[第 1 部分](/just-another-ai-trying-to-predict-the-stock-market-part-1-d0663673a30e)的数据训练模型。我们挑选了一份过去 50 年中每天的标准普尔 500 指数价格清单，并对其做了一些修改。**现在我们要训练我们的模型**，让它尽可能准确地预测未来价格。
在上一部分中，我们使用`load_data`函数和定义为`df_stock`矩阵的价格值将数据分为训练/验证/测试。它是按如下方式完成的:
`x_train, y_train, x_valid, y_valid, x_test, y_test = load_data(df_stock, seq_len)`在哪里`seq_len = 20`。如果你从[我的上一篇文章](/just-another-ai-trying-to-predict-the-stock-market-part-1-d0663673a30e)中考察`load_data`的实现，你会对`seq_len`有更好的理解。基本上，它将数据分成更大的 20 个元素的块。
## #1.定义超参数
当建立机器学习模型时，需要定义一组直接反映模型性能的参数。当你自己做的时候，你可能会发现自己花了太多的时间在调整正确的组合和评估基于你的选择的模型上。在本例中，我们将浏览预定义的，但可以随意更改它们并进行实验。
* `n_steps = seq_len-1`:输入(训练)数据的第一维度。
* `n_inputs = 4`:输入(训练)数据的第二维——不同种类的价格(“开盘价”、“收盘价”、“最高价”、“最低价”)。
* `n_neurons = 200`:用于表示我们 GRU 单元格中隐藏状态的维度。使用隐藏层的数量和输入数据的大小来确定维度。想了解更多信息，我推荐参考这个 Quora 回答。
* `n_outputs = 4`:神经网络输出层的维度。
* `n_layers = 2`:我们希望我们的网络由多少个 GRU 细胞组成。
* `learning_rate = 0.001`:当我们使用梯度下降(或另一个优化器)来最小化损失函数以校正权重和偏差时，使用该比率。
* 通常，在训练时，一次使用全部数据是低效的。这就是为什么我们迭代一组长度为 50 的批处理。
* `n_epochs = 100`:帮助确定训练迭代的次数，每个迭代使用不同的批次。
* `train_set_size = x_train.shape[0]`:也有助于确定训练迭代的次数。
## #2.设置图表
我们的下一步是使用上面的一些参数来建立训练图。但这意味着什么呢？术语“图形”来自张量流的构造方式。基本上，用 Tensorflow 建立模型时，首先需要建立架构(图)，然后使用适当的训练数据运行它。
首先是 GRU 层:
* 第 1 行:重置图形堆栈，为新的初始化做准备。
* 第 3–4 行:初始化输入和输出的张量流占位符。
* 第 6 行:使用张量流 GRU 单元格，我们将几个单元格(基于 n_layers 参数)组合成一个列表。GRU 单元用`num_units`和激活函数初始化，在这种情况下激活函数是`leaky_relu`。如上所述,`num_units`是隐藏状态的维度。[激活功能](/activation-functions-neural-networks-1cbd9f8d91d6)应用于结果值。
* 第 8–9 行:将 GRU 细胞堆叠成一个`multi_layer_cell`并运行 [tf.nn.dynamic_rnn](https://www.tensorflow.org/api_docs/python/tf/nn/dynamic_rnn) 来使用输入数据 x 创建递归神经网络
* 第 11 行:重塑网络输出。
现在我们需要添加输出层并设置损失函数:
使用`tf.layers.dense`添加最后一层，该层在对(输入*权重+偏差)应用激活函数后返回输出。
您可以从第 7–9 行看到优化器是如何使用学习率初始化的(我们使用 AdamOptimizer 而不是梯度下降)。然后，我们只需最小化损失函数，在这种情况下，就是均方误差。
如果你觉得有点困惑，把上面的方程看成一个黑盒，我会推荐你略读我之前关于[递归神经网络](/learn-how-recurrent-neural-networks-work-84e975feaaf7)的文章。如果你还有任何问题，就在评论区留下，我会跳出来讨论。
## #3.开始训练
现在最有趣的部分来了——训练模型。一般来说，如果你想得到一组可以做出准确预测的权重和偏差，你至少需要等几个小时。训练的速度取决于上面定义的超参数。
首先，我们将定义一个简单的函数`get_next_batch`，它将使用训练数据生成一批给定大小的数据:
* 第 1–3 行:从每批数据集中定义初始索引，并用 0 到`x_train.shape[0]-1`的值填充一个排列数组。
* 第 6 行:在已经声明的变量前使用 python 关键字`global`将允许我们从函数内部修改以反映全局范围。
* 最后，我们从`x_train`和`y_train`返回大小为`batch_size`的集合。
现在让我们运行图表来训练模型:
* 第 1 行:我们使用 Tensorflow 会话，它用于运行 Tensorflow 操作。
* 第 2 行:用`tf.global_variables_initializer()`我们初始化任何被声明的 Tensorflow 变量。在我们的例子中，我们没有任何。
* 第 3–11 行:我们通过多次迭代来训练模型——通过运行`training_op`,我们最小化了损失函数。第 8-11 行用于通知我们关于 out 培训的进度。
* 第 13、14、15 行:我们根据优化器模型计算输出。在第 3 部分，我们将比较`y_valid_pred`和`y_valid`以及`y_test_pred`和`y_test`，看看我们的模型表现如何。
## 在下一部分
通过以上培训，我们完成了系列的第 2 部分。在[的最后一部分](https://medium.com/p/ee2d419e00c3/edit)，我们将使用我们的模型进行预测，看看我们是否能够破解股票市场😄。
## 谢谢你的阅读。如果你喜欢这篇文章，给它一些掌声👏。希望你有一个伟大的一天！
# 只是另一个试图预测股市的人工智能:第 3 部分
> 原文：<https://towardsdatascience.com/just-another-ai-trying-to-predict-the-stock-market-part-3-ee2d419e00c3?source=collection_archive---------7----------------------->
这是我的如何使用递归神经网络预测股票市场系列的最后一部分，我们将进行实际预测。在[第一部分](/just-another-ai-trying-to-predict-the-stock-market-part-1-d0663673a30e)中，我们准备了我们的数据(S & P500 价格)，在[第二部分](/just-another-ai-trying-to-predict-the-stock-market-part-2-88605f9d8e45)中，我们训练了我们的模型。现在我将向你展示如何做最后的预测。
## #1.获取预测值
让我们复习一下上一部分的内容。优化我们的模型后，我们获得了预测值(第 13–15 行):
## #2.可视化结果
为了将实际结果与我们的预测进行比较，我们将绘制两者的曲线图，并清楚地看到差异。
首先让我们定义一个新的变量`price = 0`,它将决定价格类型的指数(在这种情况下，我们看开盘价；收盘价为 1，最高价为 2，最低价为 3)
* 绘制训练数据的结果:
在我们图表的 X 轴上，我们将有从 0 到训练数据大小的数字。在 Y 轴上，我们将绘制实际结果和预测结果。
* 绘制验证数据的结果:
在图表的 X 轴上，我们将把从训练数据末尾到验证数据末尾的数字相加。在 Y 轴上，我们将绘制实际结果和预测结果。
* 测试数据的绘图结果:
在我们图表的 X 轴上，我们将把从验证数据末尾到测试数据末尾的数字相加。在 Y 轴上，我们将绘制实际结果和预测结果。
最后，我们需要显示图表的图例:
使用第 2 部分中的 S&P500 数据和超参数，最终的图像应该与此类似:
当然，你的可能会不同，所以我建议用一组参数进行实验，看看什么时候模型会产生最好的结果。
## 最后的想法
我希望这个实现对您有用。如果你有任何问题，请在评论区留言，我们可以一起讨论。
## 谢谢你的阅读。如果你喜欢这篇文章，给它一些掌声👏。希望你有一个伟大的一天！
# 只是“一堆东西”和人工智能的魔力
> 原文：<https://towardsdatascience.com/just-pile-of-stuff-and-magic-of-ai-8bd651428b9d?source=collection_archive---------11----------------------->
*Pile of Stuff*
有多少次你逛商店，告诉他们，你需要一条裙子。但不是所有的裙子，你需要一条长及膝盖的裙子，看起来非常宽松，但没有很多褶皱，而且超级宽松。
等等，这不是真正的裙子，这是一种裤子，看起来像裙子，但不像裙子…
…或者类似的事情。
*你真的不知道。*
但是等等，如果你知道呢？知道它叫“裙裤”。
只需上网，寻找[裙裤](https://www.google.co.in/search?q=buy+culottes&rlz=1C5CHFA_enIN749IN749&oq=buy+culottes&aqs=chrome..69i57j0l5.3185j0j9&sourceid=chrome&ie=UTF-8)，瞧，你就可以挑选了。
或者你仍然继续寻找，但你至少知道你在寻找什么。:)
这就是[小队](https://www.squadplatform.com/)正在做的事情。不仅仅是映射正确的东西，或者定义它，或者给它标签，而是让用户能够从一堆东西中找到正确的东西。
想象你开了一个购物平台，你需要一些下装。第一页向你展示了什么是下装，并询问你是在找裤子、运动裤还是裙子。
如果你决定买一条裙子，它会向你展示裙子的几种选择。你知道铅笔裙和紧身衣有多么不同，你挑选它，选择合适的长度，选择合适的颜色，然后把它放到你的购物车里，瞧！世界感觉稍微好了一点，一切尽在你的指尖。
现在，想象一下上面的场景，仅仅好 10 倍，不仅是裙子，还有裤子，上衣，内衣，民族服装，以及所有其他种类的服装。
所有你曾经想到的，但现在更容易找到。
我知道你现在可能在想，这可能吗？你如何去每一家商店，告诉他们对你的“一堆东西”使用相同的定义？
甚至不同的网上购物平台都有自己喜欢的类别，在不同的建筑中寻找特定的商品就像在煤窖中寻找黑猫一样。
但是等等，你听说过一个叫艾的镇上的魔术师吗？只要一眨眼的功夫，它就能帮你找到你正在寻找的那条裙子，因为我们为魔鬼提供了类别和属性的详尽映射。
这就是我们在过去几个月里所做的。在我们的领域专家 Deepika Sai Chitkara 的帮助下，我们创建了一个详尽的类别和属性列表。
我们首先定义了女装，并创建了一个八级深度分类树。
**为什么有女装分类树？**
在 Squad，我们对来自不同客户的产品清单进行[内容审核和质量检查](https://www.squadplatform.com/blog/content-moderation-humans-ai/)。每个客户都有自己的分类来安排产品目录。根据我们的经验，我们观察到没有全球标准可循，至少在时尚领域是如此(在不同客户的分类法中)。相同产品的信息在不同客户之间不一致，例如*客户 A* 认为是裤子*客户 B* 认为是七分裤。
这让我们开始探索一个可以代表时尚行业标准的分类树。但令我们惊讶的是，我们没有发现任何这样的服装行业现有的标准化流程。这就是为什么我们开始研究一个分类树，它可以作为映射不同客户分类的标准。
**分类树中的前 5 个目标**
当我们开始构建女装的品类树和属性列表时，我们有以下目标。
1. 以聚合和标准化客户端上多个数据点。
2. 解决时尚的内容审核用例，并建议适当的类别。
3. 使用丰富和标准的概念，共同解决分类和归属的自动化问题。
4. 在联合模型的帮助下获得自动生成的描述。
5. 为基于搜索相关性和排名的用例创建更好的机器学习模型。
**我们的分类体系树快照&属性模板**
经过我们小型求解团队近一个月的努力，我们为女装建立了一个标准的分类树。以表格形式找到我们的标准分类树的快照。下表仅描述了我们的分类分类树中 218 个节点(女装概念)的 178 个唯一路径中的几个路径。
我们还创建了一个属性模板，其中包含不同客户的所有独特属性的值和指导原则。
在下面找到归因模板的快照，以及视觉相似性的“难度等级”。下表仅描述了我们属性模板中 5 种不同属性类型和 175 个唯一值中的少数属性和值。
**使用分类树和属性模板进行数据标准化和聚合**
我们的分类分类树和属性模板不仅有助于映射视觉上相似的概念并实现标准化，还能帮助我们消除数据集中的不一致。
一个详尽的 8 级深度树帮助我们聚集和标准化了不同客户的近 50–60%的数据点，并使女装分类和属性数据点的数量分别达到 130 万卢比和 40 万卢比，顶级概念下有 15000 多点。使用标准树，我们增加了每个类别的样本数量。因此，这有助于我们学习属性和分类的通用模型，以实现审核和质量检查的自动化。
为您提供一些关于它如何帮助我们消除数据稀疏性的统计数据:下面是一些产品在不同客户中不一致命名的分布表快照，以及使用我们的分类法的最终类别和数量。
我们使用干净和丰富的数据来执行各种实验，以正确分类和检索服装图像，而不使用边界框或丰富的注释来进行归因。我们一直在不断努力进一步改善我们的[基础设施](https://medium.com/@om.vedvasu/evolution-of-kernel-the-backbone-of-squadai-7c605ec64b28)，以便我们可以展示 Squad 的人工智能算法的炼金术，用于解决最复杂的消费者对消费者(C2C)内容调节问题，如时尚等用例。
Results using our categorisation pipeline without using bounding boxes or rich annotation on few leaf nodes of our Women’s Apparel Taxonomy Tree. Rows 1–4 are Blouses, Cardigans, Dresses, and Jackets.
**游戏规则改变者**
我们相信，我们现在是印度极少数成功打破女装分类的公司之一。结合我们已经到位的归因指导方针，我们可以成为新一代时尚商业的答案。
由于服装行业没有现成的标准化流程，这样的分类树可以作为 [ISO 61.020](https://www.iso.org/ics/61.020/x/) 未来项目书籍的垫脚石，包括内衣、睡衣、针织品、军装、针织品等。以及它们的标签和尺寸编码方案。我们的分类法也符合 Euratex 的标准，因此对欧洲组织很有用。
再次感谢我们的领域专家 Deepika Sai Chitkara、我们崭露头角的 MLE 实习生 Priyank Jain 和我们的运营团队为这个博客做出的重要贡献。
**对于不知道什么是“一堆东西”的人来说**
米兰达·普里斯特利:【*米兰达和几个助手正在为一套服装挑选两条相似的腰带。安迪窃笑，因为她认为他们看起来一模一样*有什么好笑的吗？
[安迪·萨克斯](http://www.imdb.com/name/nm0004266/?ref_=tt_trv_qu):不，不，不。没什么……你知道，只是这两条皮带在我看来完全一样。你知道，我还在学习这些东西，嗯…
米兰达·普里斯特利:‘这……东西’？哦。好吧。我明白了。你以为这跟你没关系。你走进你的衣橱，选择了……我不知道……那件凹凸不平的蓝色毛衣，比如说，因为你试图告诉世界，你太把自己当回事了，以至于不在乎你背上穿的是什么。但你不知道的是，那件毛衣不只是蓝色，也不是青绿色。不是青金石。其实是天蓝色的。你可能还不知道，2002 年，奥斯卡·德拉伦塔设计了一系列天蓝色礼服。然后我想是伊夫圣罗兰…不是他展示了天蓝色的军用夹克吗？我想我们需要一件夹克。然后天蓝色很快出现在八个不同设计师的作品中。然后它，呃，通过百货商店渗透下来，然后慢慢流到某个悲惨的休闲角落，毫无疑问，你是在那里从某个清仓垃圾箱里找到它的。然而，这种蓝色代表着数百万美元和无数的工作机会，你觉得自己做了一个让你远离时尚行业的选择，这有点滑稽，事实上，你穿着的毛衣是这个房间里的人从一堆东西中为你挑选的。
# Jupyter 笔记本快捷方式
> 原文：<https://towardsdatascience.com/jypyter-notebook-shortcuts-bf0101a98330?source=collection_archive---------1----------------------->
# 什么是 *Jupyter 笔记本*？
*Jupyter 笔记本*广泛用于数据分析。我在 2-3 个月前开始学习 ***数据科学*** 并且我用这个工具探索了一些数据集(数据的集合)。太牛逼了！
让我们看看文档中的定义。
> **笔记本文档**是由 *Jupyter 笔记本 App* 生成的文档，**既可以包含代码**(如 **Python** )也可以包含富文本元素(**段落、等式、链接等)..**)。
>
> ***Jupyter 笔记本应用*** 是一个客户端-服务器**应用**，允许**通过**浏览器**编辑和运行笔记本文档**。
在这里你可以找到更详细的信息，如果你想的话。
# 快捷指令
作为一名开发人员，我喜欢尽可能多地使用快捷方式和代码片段。它们只是让编写代码变得更加容易和快速。我喜欢遵循一条规则:
> 如果你开始用鼠标做一些动作，停下来想一想是否有捷径。如果有一个-使用它。
当我开始使用 *Jupyter Notebook* 时，我不知道这个工具有快捷方式。好几次，我把我的**单元格类型**从 ***代码*** 更改为 ***markdown*** 并且我不知道如何更改。正如你能猜到的，这让我很头疼。有一天我刚好看到菜单栏里有一个`Help > Keyboard Shortcuts`链接。令我惊讶的是，原来 *Jupyter 笔记本*有**一吨的快捷方式**。
在这篇文章中，我将向你展示我最喜欢的几个。请注意，这些快捷方式是针对`Windows`和`Linux`用户的。无论如何，对于`Mac`用户来说，它们是`Ctrl`、`Shift`和`Alt`的不同按钮:
* `Ctrl`:命令键`⌘`
* `Shift`:换挡`⇧`
* `Alt`:选项`⌥`
首先我们要知道它们是 *Jupyter 笔记本 App* 中的 **2 模式**:**命令模式**和**编辑模式**。我将从两种模式之间共享的快捷方式开始。
两种模式下的快捷键:
* `Shift + Enter`运行当前单元格，选择下图
* `Ctrl + Enter`运行选定的单元格
* `Alt + Enter`运行当前单元格，在下面插入
* `Ctrl + S`保存和检查点
在命令模式下(按下`Esc`激活):
* `Enter`进入编辑模式
* `H`显示所有快捷方式
* `Up`选择上面的单元格
* `Down`选择下面的单元格
* `Shift + Up`扩展上面选中的单元格
* `Shift + Down`扩展下面选中的单元格
* `A`在上面插入单元格
* `B`在下方插入单元格
* `X`剪切选中的细胞
* `C`复制选中的单元格
* `V`粘贴单元格下方
* `Shift + V`粘贴单元格上方
* `D, D (press the key twice)`删除选中的单元格
* `Z`撤消单元格删除
* `S`保存和检查点
* `Y`将单元类型更改为*代码*
* `M`将单元格类型更改为*降价*
* `P`打开命令调色板。
该对话框帮助你**运行任何名为**的命令。如果你不知道一些快捷方式，或者当你没有想要的命令的快捷方式时，这真的很有用。
Command Palette
* `Shift + Space`向上滚动笔记本
* `Space`向下滚动笔记本
在编辑模式下(按`Enter`激活)
* `Esc`带你进入命令模式
* `Tab`代码完成或缩进
* `Shift + Tab`工具提示
* 缩进
* `Ctrl + [`德登
* `Ctrl + A`全选
* `Ctrl + Z`撤销
* `Ctrl + Shift + Z`或`Ctrl + Y`重做
* `Ctrl + Home`转到单元格开始
* `Ctrl + End`转到单元格末尾
* 向左走一个单词
* `Ctrl + Right`向右移动一个单词
* `Ctrl + Shift + P`打开命令调板
* `Down`向下移动光标
* `Up`向上移动光标
这些是我在日常工作中使用的捷径。如果你还需要这里没有提到的东西，你可以在快捷键对话框中找到(`H`)。您也可以从菜单栏中的`Help > Edit Keyboard Shortcuts`链接**编辑现有的**或**添加更多的**快捷方式**。单击该链接将打开一个对话框。在它的底部有添加或编辑快捷方式的规则。你需要用连字符`-`来代表应该同时按下的键。**
**例如，我为*重启内核并运行所有单元*命令添加了一个快捷方式`Ctrl-R`。**
# **我的其他博客文章**
* **[数据科学的 Python 基础知识](/python-basics-for-data-science-6a6c987f2755)**
* **[Python 数据科学:Matplotlib 数据可视化简介](/data-science-with-python-intro-to-data-visualization-and-matplotlib-5f799b7c6d82)**
* **[使用 Python 的数据科学:使用 pandas 加载和子集化/过滤数据简介](/data-science-with-python-intro-to-loading-and-subsetting-data-with-pandas-9f26895ddd7f)**
* **[文本自然语言处理介绍](/introduction-to-natural-language-processing-for-text-df845750fb63)**
# **商务化人际关系网**
**如果你想和我联系，这是我的 LinkedIn 个人资料。**
# **时事通讯**
**如果你想在我发表新的博客文章时得到通知，你可以订阅我的时事通讯。**
# **最后的话**
**谢谢你的阅读，如果你喜欢这篇文章，请按住按钮。另外，我很乐意分享您的反馈。**
# 一个深度学习分类器！
> 原文：<https://towardsdatascience.com/k-as-in-keras-simple-classification-model-a9d2d23d5b5a?source=collection_archive---------8----------------------->
希望你知道这篇文章是关于什么的，是的，你是对的！它是关于使用 Keras API 构建一个简单的分类模型。众所周知，Keras 是目前最简单、用户友好和最受欢迎的深度学习库之一，它运行在 TensorFlow/Theano 之上。Keras 上完整的文档是 [**这里**](https://keras.io/) 。Kears 受欢迎是因为以下指导原则。
**模块化**:一个模型可以单独理解为一个序列或者一个图。
极简主义:它提供了足够的可读性。
**Python:** 一切都是原生 Python。
酷，让我们开始使用这个简单的框架构建一个简单的分类器。完整的代码在 [**GitHub**](https://github.com/Msanjayds/Keras/blob/master/Classification_Model_using_Keras.ipynb) 中。
**步骤 1:安装所需的库**
我已经用 [**GoogleColab**](https://colab.research.google.com/notebooks/welcome.ipynb) (感谢谷歌)建立了这个模型。因为所有需要的库都是预安装的，所以我们不需要担心安装它们。只是导入了如下所需的库和函数。
**第二步:加载并拆分数据**(训练并测试/验证)。
对于这个例子，我使用了 Pima Indianas 发病糖尿病数据集。它描述患者病历数据，并告知患者是否患有糖尿病(1:是，0:否)。所有的输入变量都是数值型的，所以我们可以很容易地直接在模型中使用它，而不需要太多的预处理。正如我们在下面看到的，我们有 8 个输入特征和一个输出/目标变量(糖尿病-1 或 0)。
我已经将输入特征和输出分成 x & y 变量。我使用 scikitlearn 的 train_test_split 函数将数据分成训练集和测试集(90:10)。拥有一个验证集对于通过检查我们的模型是否欠拟合、过拟合或泛化来调整模型更有用。
**第三步:** **定义模型**
我们使用的是一个**序列**模型，这是一个简单的线性层叠。我们可以通过向构造器一次传递一个层实例列表来创建这个模型，直到我们对网络拓扑满意为止。
在这个例子中，我使用了一个全连接的 3 层结构(2 个隐藏层，每个层有 100 个节点，1 个输出层有一个节点，不包括输入层)。使用**密集**类定义完全连接的层。层数和节点数是随机选择的。理想情况下，我们需要一个足够大的网络来学习/捕捉数据的趋势/结构。
在第一个隐藏层中，我们需要使用 **input_dim** 参数来指定输入维度的数量(在我们的例子中是 8 个特征)。对于每一层，我们需要指定激活函数(非线性)。我对隐藏层使用了“ **relu** ，因为它提供了比“tanh”更好的性能，对输出层使用了“ **sigmoid** ，因为这是一个二进制分类。
由于我们的训练集只有 691 个观察值，我们的模型很可能会过拟合，因此我对隐藏层应用了 **L2 调节**。权重正则化是一种减少深度学习神经网络模型对训练数据的过拟合并提高测试数据性能的方法。Keras 提供了 3 个**kernel _ regulator**实例(L1，L2，L1L2)，它们为损失函数增加了一个权重大小的惩罚，从而在一定程度上降低了它的预测能力，这反过来有助于防止过拟合。
我还使用了**辍学**正规化技术。在这种技术中，在训练过程中，一些随机选择的神经元被忽略，即“退出”。这里我使用了 0.3，即在每次迭代中，我们在给定的层中随机丢弃 30%的神经元。如果需要，我们可以为每个层设置不同的辍学率。由于丢失，它们对下游神经元激活的贡献被暂时取消，并且在向后传递期间没有权重更新被应用于那些神经元。
*如果神经元在训练过程中被随机丢弃，那么其他神经元必须介入并处理对丢失的神经元进行预测所需的表示。这导致所有神经元更好地学习，因此网络对神经元的特定权重变得不太敏感，因此泛化能力更好，不太可能过度拟合。*
**第四步:** **编译模型**
这里，我们需要让模型知道使用什么损失函数来计算损失，使用哪个优化器来减少损失/找到最佳权重/偏差值，以及使用什么指标来评估模型性能。
我们使用**‘二元交叉熵**(负对数损失)’作为我们的损失函数，因为我们只有两个目标类。如果我们的类多于两个，我们可以选择范畴交叉熵。
接下来是模型训练最重要的超参数，**优化器，**在我们的例子中，我们使用了“**亚当**”(自适应矩估计)。其他优化器在整个训练过程中保持单一的学习速率，其中 Adam 随着训练的进行采用学习速率(自适应学习速率)。Adam 结合了 SGD(随机梯度下降)的其他两个扩展的优点，即均方根传播(RMSProp)和自适应梯度算法(AdaGrad)。它利用了 RMSProp 的最大优点，并将它们与动量优化的思想相结合。结果是一个允许快速有效优化的策略。下图显示了不同优化器在迭代过程中训练成本的下降。Adam 提供了最佳性能，收敛速度很快。
下一个参数是“**指标**，用于判断我们模型的性能。其类似于损失函数，除了在训练模型时不使用评估度量的结果。我们使用准确性(**ACC**’)作为我们的度量，它返回一个单一的张量值，代表所有数据点的平均值。
从下面的模型总结中，我们可以看到我们模型的可训练参数细节。(请忽略单词 dense 旁边的数字，如 dense_89、dense_90 等。)
第一层总共有 900 个参数((100 * 8)权重+ (100 * 1)偏差)
第二层有 10100 个参数((100 * 100)权重+ (100 * 1)偏差= 10100)。总的来说，这个模型有 11，101 个可训练参数。
**第五步:训练模型**
编译后，我们可以使用' **fit** '方法训练模型。我们使用训练集(x_train，y_train)来训练模型。我已经用 20 的 batch_size 运行了 500 个**时期**的模型。 **Batch_size** 也是一个随机数(理想值为 10 到 124 ),取决于我们拥有的数据量，它决定了一次迭代中使用的训练样本的数量。因此，在一个给定的时期，我们将有许多迭代。Verbose 可以设置为 0 或 1，它打开/关闭每个时期的日志输出。我们可以使用 **validation_data** 参数提供用于评估损失的 validation_data 和每个时期结束时的任何模型指标，模型将**不会根据该验证数据进行**训练。
with verbose = 1
正如我们在上面看到的，来自最后一个历元的训练精度大约是 75.55，验证精度是 76.62。所有时期的平均训练精度约为 73.03%，平均验证精度为 76.45%。我想这还算可以😉。下图显示了各时期训练和测试数据的准确性和损失。
使用' **predict** '方法对测试数据进行预测，并得出混淆度量。这表明在 77 个测试样本中，我们错分了 12 个样本。我们的准确率达到了 85.7%。
这就是这篇文章的全部内容，非常感谢你阅读到这里。非常欢迎你的评论/建议/纠正。如果你喜欢这个帖子，请👏。下次博客再见。
# k-means——营销组合建模的一个步骤
> 原文：<https://towardsdatascience.com/k-means-a-step-towards-market-mix-modeling-d3feca510d21?source=collection_archive---------7----------------------->
Source: [www.mstecker.com/](http://www.mstecker.com/pages/chfmcflosIMG_2046a1.htm)
聚类是一种无监督的技术，它将某些对象分类成称为簇的组，使得一个簇中的对象与其他簇中的对象相比具有相似的模式和不同的模式。
使用聚类分析的市场细分有助于根据客户行为和其他方面的相似性或独特性将各种市场划分为小的类别。一些特征包括不同品牌的价格点、品牌的市场份额、人口统计(年龄、性别、收入)、行为(使用、频率、忠诚度)、地理、倾向、媒体习惯等。
在本文中，我将介绍一个小型案例研究，说明如何应用 k-means 对各种市场进行聚类，以及从结果中可以获得什么样的见解。
假设一个国家有 20 个市场。我们有每个市场的以下变量的数据:
> 主要品牌的市场份额
>
> 市场份额——您自己的品牌
>
> 市场份额增长—您自己的品牌
>
> 平均价格(主要品牌)
我们需要根据上述特征对市场进行细分，找到 5-6 个集群。因此，每个集群都有相似的特征市场。这将有助于为每个集群制定营销战略，而不是将重点放在所有 20 个市场上。
使用 k-means 算法，市场被划分为 6 类。
采取以下步骤来执行 k 均值:
> I .数据清理和缺失值检查
>
> 二。数据标准化(所有变量有不同的单位)
>
> 三。运行 k = 5 或 6 的 k 均值算法(此处 k 为聚类数)
>
> 四。使用肘方法找到正确的集群数量(您可以使用其他方法，如平均轮廓和间隙统计)
你一定想知道为什么我选择了 5-6 个集群。这就是领域知识发挥作用的地方。通过取 6 个集群，我们假设我们可以将一个国家的市场分成 6 个集群。每个集群中的市场将具有相似的特征。假设或直觉来自领域知识。
基于上述方法，市场被分为 6 类，分析揭示了以下内容:
你可能想知道这些集群是如何形成的，什么是组件 1 和组件 2。在引擎盖下，五氯苯甲醚正在发挥作用。我们也可以用 t-SNE 来表示更高维度的星团。
因此，通过主成分分析，我们知道以下两个变量解释了模型中 80.9%的方差:
> 一、主要品牌市场份额:49.2%
>
> 二。自有品牌市场份额:31.7%
在降维技术中，我们忽略了不能解释太多差异的特征向量/分量，从而减少了变量的数量。在这里，我们不会忽略或删除任何变量，相反，我们的目标是看看哪些变量是集群形成的关键。
**那么，有哪些见解呢？**
> 重申一下，我们有 6 个集群。
>
> 每个集群代表相似的市场
>
> 市场份额是一个变量，基于这个变量可以推断市场的独特性或相似性(记住通过 PCA 得出的方差 80.91！！)
**营销组合建模的链接**
公司通常对了解多个市场的营销组合感兴趣。但是他们可能不会执行这种分析，因为:
> 有限的预算
>
> 时间限制
>
> 由于帕累托原则:80 %的收入来自 20%的市场，他们很少有市场在他们的雷达上。
因此，市场细分拯救了他们。他们可以从每个集群中挑选高潜力市场，并专注于在那里获得正确的营销组合，而不是建立 50 个模型。
*有句谚语说:“不要只看到树木而忽略了森林！！!"*
营销语境中的 k 意味着帮助营销人员“不要只见树木不见森林”
Source: [Max and Dee Bernt/flickr](https://www.flickr.com/photos/lhanaphotography/17313962841)
如果你喜欢我的文章，给它一些掌声，或者更好地与你的朋友或同事分享。
**附注**:最近，很多人问我是否做市场组合建模/营销分析方面的咨询。
您可以将您的咨询问题发布到:[https://www.arymalabs.com/](https://www.arymalabs.com/)
领英:[https://www.linkedin.com/in/ridhima-kumar7/](https://www.linkedin.com/in/ridhima-kumar7/)
推特: [@kumar_ridhima](https://twitter.com/kumar_ridhima)
**版权所有 2018**[**www.ridhimakumar.com**](http://www.ridhimakumar.com)**版权所有。**
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
