使用 NLP 探索 4.5 年的日志条目
诺德伍德在 Unsplash 上拍摄的照片
使用 Python 和 fast.ai 写作 4 年多的经验解读
介绍
自 2016 年 1 月 1 日起，我每天都在谷歌文档中记录当天的事件和我的想法。我开始写日记是因为我对自己的现状不满意，希望能够回顾过去看到进步。尽管有这个目的，这些日记还是变得很长很快，我从来没有机会以任何有意义的方式回顾它们。
随着我的日志接近五周年纪念日，我认为最终回顾一下会很有趣——不是通过阅读它，而是通过用我新学到的数据科学和自然语言处理(NLP)技能来分析它。
数据收集
幸运的是，我是一个习惯动物。在过去的 53 个月里，每篇日志看起来都完全一样——每月一篇谷歌文档，格式如下:
一月
1 月 1 日
此处录入1 月 2 日
此处录入
诸如此类。
创建我的语料库就像下载每一个谷歌文档作为文本文件一样简单，快速阅读它以寻找零散的段落中断，并使用几行代码(准确地说是 21 行)将其全部放入 pandas DataFrame。在数据帧中，我包括了年、月、日、日期(日期时间)和日志条目。
作者图片
然后，我使用正则表达式(re)模块清理数据，使用 scikit-learn 的 CountVectorizer 函数创建文档术语矩阵，并按年份对其进行分组，然后将其转置用于探索性数据分析。
作者图片
探索性数据分析
为了更好地理解我的日记，我从三个角度来看它们:常用词、感悟和长度。
- **常用词:**我使用词云来确定和可视化最常用的词，以收集重要的主题。
- **情绪:**我用 TextBlob 库进行了一次情绪分析，看看我的极性是如何随时间变化的。
- **长度:**我用熊猫分离出各种长度指标，并推断出为什么我在特定时间点写得多或少。
最常见的单词
首先，我想看看最常见的单词，我希望这些单词能让我了解每年对我来说最重要的事情。我删除了五年中至少三年前 30 个最常用的单词，因为它们可能对区分不是很有见地。
我喜欢尽可能直观地表示信息，所以我使用文档术语矩阵来创建每年的单词云。
作者图片
我的观察:
- 2016: 我谈了很多我的另一半*、麦迪森** ，还有我的床(大概指的是我如何挣扎着从中走出来，或者因为背痛在里面待了多长时间)。其他让我印象深刻的词还有课、英语、生物、作业，指的是学校，打，指的是各种游戏和运动。
- 2017: 麦迪逊依旧突出但不那么突出；类似的学校主题也存在，工作指的是我在 Sonic 开始工作，而我将重要性显著增加——我想我开始更多地谈论我将来要做什么。
- 2018: Madison 随着我们关系的结束而再次凸显，随着人变大，我开始更多地谈论其他人。我也和汉娜成了好朋友，后来还和她约会。
- 2019: 汉娜变得很重要，其他人 — 2019 包括我高三第二学期和大学第一学期，所以很有意义。今年的乐趣也增加了，这是另一个不足为奇的变化。
- 2020: 工作指的是春季班增加的工作量——比如MIS——以及我在学期中的实习；人依然突出，数据和阅读指的是我在 2020 年捡来的爱好/兴趣(我正在用其中的一个写这篇文章)。
*匿名化名
情感分析
接下来，我想看看我的写作有多积极/消极，是否符合我那些年的感受。TextBlob 使得对语料库进行情感分析变得非常容易，所以我分析了语料库，并按月/年查看了极性。
作者图片
年度结果令人惊讶:2020 年几乎是其他年份的两倍。我肯定会认为 2020 年是我最快乐的一年，但我没想到情绪分析会如此强烈地支持我的直觉。
这里我们看到极性随着时间的推移以每月和每年的频率显现出来:
作者图片
长度分析
我想探究的最后一件事是长度:我写了多少，随着时间的推移，我的冗长是如何变化的？
为此，我创建了一个数据框架，其中包含关于日志条目长度的各种指标:
作者图片
我在 2019 年写得最多，在 2020 年写得最少，每天写得更多的年份词汇量更大。2020 年是迄今为止每日单词量最低的一年，这是有道理的(WPD)；这是我最快乐也最忙碌的一年。
看到我在 2020 年写得少了多少，不禁让人产生疑问:“快乐”(极性)和我的条目长度之间有联系吗？我用不同的方法绘制了每天平均字数与情绪的关系图，看看是否有什么规律。
作者图片
随着时间的推移，每天绘制情绪和单词显示了一些关系；除了 2019 年的字数大幅上升和 2020 年的字数快速下降之外，每月的情节都很好。
年度图表给出了一个更全面的见解，如果不是相互冲突的话:除了 2018-2019 年，情绪和字数都有所上升，字数和情绪相互反映。当情绪上升时，字数下降，反之亦然。这符合我的直觉，如果我更快乐、更积极，我会写更少的日志，而是花更多的时间关注那些积极的事情。
作者图片
去除时间成分，散点图变得不那么有意义；我看到的唯一趋势是，当绘制每日图表时，情绪非常高或非常低的条目没有高字数，而那些极性更中值(介于-0.5 和 0.15 之间)的条目有更高的字数。
这很有意思；如图所示，我不会期望在非常积极的日子里写很多，但在非常消极的日子里，我会期望写很多关于为什么这一天不好，为什么我感到沮丧/不安，等等。有可能 TextBlob 情绪分析并没有很好地将我的糟糕日子捕捉为低极性，而将我的积极日子捕捉为高极性。
深度学习
由于这是一个无监督的学习项目(没有标签的数据)，我的大部分见解来自探索性的数据分析。我尝试过主题建模，但结果无法理解。这是有意义的，因为主题建模最擅长识别高度不同的主题(如体育和政治)，而我的日志主要集中在谈论我的一天。
我的分类器计划也没有成功，因为我需要手动对所有 1601 日志条目进行分类——这不是对我时间的一个特别好的利用。
然而，我能够使用深度学习来完成我最感兴趣的任务:文本生成！
训练语言模型
我从一个语言模型开始，这个语言模型是在 Wikitext103 数据集上预先训练的，这个数据集是从维基百科中经过验证的文章中提取的超过 1 亿个标记的集合。
这样做让我可以利用迁移学习，这意味着我的模型从对英语的良好理解开始，而不是从零开始。然后，我对所有 1601 条日志条目进行了训练，经过四次微调后，准确率接近 33%。
作者图片
我对它的表现感到惊讶。在语言模型的上下文中，准确性基本上指的是它能够根据之前的词汇正确预测下一个单词的频率。鉴于我的词汇表中有成千上万的单词，当时⅓的正确预测是相当不可思议的。我想我是一个可预测的作家。
文本生成
对于文本生成，我给了模型各种各样的起始单词/短语，类似于我经常用来开始我的日志的单词/短语，并在获得满意的结果之前测试了一些不同的长度:
200 字，起始文字:“好的”
作者图片
这些条目波动很大是可以理解的，这里有一个不太容易理解的条目，其中有相同的参数:
作者图片
这里是我让它谈论大学里的事情的最佳尝试——起始文本是“我的宿舍”。考虑到我只有一年的大学经历，而高中有四年，我对这个模型很少提到与大学相关的话题并不感到惊讶。
作者图片
肯定有很多重复和一些无意义的部分，但老实说，这听起来很像我写日记的方式。我对结果很满意。这种语言模式确实一针见血地描述了我大多数时候是如何开始写日记的:起床，谈论学校。
Fast.ai 的 learner.predict 方法当然不是最好的文本生成方法，但在这个项目的范围内，我无法使用另外两种文本预测方法 【光束搜索】 或 nucleus predict 获得更好的结果。
语法上
我注意到的最后一件事是，生成的文本中有一些基本的语法错误，如缺少标点符号、笨拙的空格和大写错误。我本来可以安装大量的语法检查 API，但是我在学校使用 Grammarly，希望快速得到结果，所以我手动将生成的条目放入其中，不加区别地接受所有的修改建议。结果如下:
200 字，起始文字:“好的”
作者图片
200 字，起始文字:“我的宿舍”
作者图片
结论
从事这个项目不仅令人怀念，而且是一次很好的学习经历和许多乐趣。我不知道接下来会发生什么，但我发现了大量有趣的结果，并从一个新的数据驱动的角度审视了我的个人经历。
用我在过去三个月里学到的技能来解决这个新奇的问题真的很令人兴奋，我想继续使用指导我完成这个项目的过程来获得有意义的见解。
这是我写的第一篇文章，也是我完成的最大的数据科学项目，所以肯定还有改进的空间。如果你有任何建议，请让我知道。
作为投资者探索零售数据集
基于美国人口普查年度零售贸易调查数据集，应用数据分析寻找相关见解
介绍
年度零售贸易调查涵盖了 50 个州和哥伦比亚特区的零售贸易企业。这项贸易调查显示了国家的销售额、销售税、费用、库存等等。
这里的挑战是只探索这些数据，并发现我们可以找到什么样的相关见解，以及一些答案，以向投资者展示哪个细分市场可能是最佳选择。
当然，这可能会产生新的疑问和疑虑，但以下问题将在一开始引导我们:
- 作为投资人进入哪个细分市场更感兴趣？成本和费用如何影响细分市场？
- 哪一个有更多的钱花在存货上？
- 库存如何影响商业利润？
- 预测下一年(2015 年)的销售额
数据
为了找出这些答案，将使用由数据提供的美国人口普查年度零售贸易调查数据集。世界。通过这个数据集，我们可以获得从 2004 年到 2014 年在美国收集的销售、销售税、库存、毛利、费用、采购和应收账款总额等信息。
假设
美国人口普查年度零售贸易调查数据集得出了按主要细分市场组织的数据，其中一些细分市场。经过数据清理过程后，2004 年至 2014 年间，选择简化并仅处理主要类别。这些段和各自的代码是:
我们应该检查许多指标，以便尽可能准确地了解感兴趣的细分市场。然而，该数据集提供了一般信息，允许进行唯一的定量分析。这里的想法是从这个数据集中提取最相关的信息。
另一个重要的问题是，这个分析是一个研究案例，针对一个“假设的投资者”，他没有会计领域的知识，只是通过在该领域的一些研究。此处的目的是，即使数据有限，也要展示数据分析如何帮助识别相关信息，从而帮助做出决策。
说完了，我们开始吧！
克里斯蒂安·柯普克在 Unsplash 上拍摄的照片
销售
当有人考虑在某个领域投资时，销售额可能是第一个想到的指标。我们可以说这是合乎逻辑的，毕竟销售越多，钱就越多。因此，我们需要扫一眼，挑选出销售额较高的细分市场。
实际上，事情没那么简单。很明显，如果你不卖，你就退出了市场，但我们需要记住，销售不同于盈利能力。销售是必不可少的，可以为我们带来有价值的数据，但除了销售，我们还需要检查许多其他重要的指标。无论如何，这是一个很好的起点。
总销售额增长| 2004 年至 2014 年
上图向我们展示了逐年的销售增长，从 2004 年到 2007 年，我们可以实现接近平均 5%的持续增长。由于大衰退，我们可以看到从 2008 年开始下降，到 2009 年下降到-7.68%。从 2010 年开始，美国零售业开始恢复性增长，平均增长 4.2%。根据这一初步分析，我们可以预计 2015 年的增长率约为 3.5%。
在下面的图表中，我们可以看到一个有趣的按细分市场划分的年度总销售额视图。汽车和零部件经销商的总销售额最高，历年达到 94.4 亿美元。如果我们与销售额第二高的地方百货店比较，会发现销售额几乎少了 31%,而与销售额最低的地方体育用品、业余爱好、书籍和音乐商店相比，差距达到 90%以上。
细分市场总销售额| 2004 年至 2014 年
下面的下一张图显示了各细分市场的同比增长，除了各细分市场的情况与之前一样之外，还可以了解哪些领域对大衰退带来的经济问题更加敏感。汽车及零部件经销商板块是第二大受影响的板块，2009 年 -14.53% ，仅次于加油站，同年**-22.28%**。
另一方面，受影响最小的部门是百货商店，其次是食品和饮料商店，分别为 -1.03% 和 -0.14% 。
无店铺零售商多年来的增长最为稳定和强劲，在 2014 年达到了 8.48% 。
细分市场同比增长| 2004–2014 年
当我们按细分市场分析平均增长率时(如下所示)，无店铺零售商在分析期内的比率最高，为 6.85% 。
相比之下，汽车及零部件经销商，这一历年来总销售额最高的行业，平均增长仅为1.87%。
各细分市场的平均增长率| 2004–2014
从以前的数据分析到现在，我们可以得到一些结论。尽管是对经济危机最敏感的行业之一，汽车和零部件经销商的复苏最为强劲，从 2010 年开始计算，平均增长率为 8.75% 。
非商店零售商有类似的平均增长( 8.59%) ，但如果我们考虑总销售额，机动车和零部件经销商销售额为 94.4 亿美元。相比之下，非商店零售商的销售额略高于 37.4 亿美元，两者相差 57 亿美元。
费用和成本
之前的分析向我们展示了汽车和零部件经销商似乎是最有前景的细分市场，但正如之前所说，销售利润各不相同。
从现在起，我们的任务将是寻找能够证实或否定这一先前结论的相关信息。基于我们的数据集信息，我们可以开始寻找支出、成本以及它们如何影响收入。
让我们从一些用来探索公司财务稳定性和整体健康状况的最重要的利润率开始:毛利率和净利润率。****
首先，我们将分析毛利率。这个指标表明公司在成本之外获得了多少利润。这个结果越高，公司就越能有效地从每一美元的成本中获取利润。我们可以通过公式计算
毛利率=(收入—销货成本)/收入 x 100
我们可以使用总销售额作为收入，但首先我们需要找出商品销售成本(COGS ),它指的是生产公司销售的商品的直接成本。成本越高，利润就越低。为此，将使用下面的公式
销货成本=期初库存+购货—期末库存
商品成本 x 总收入
按部门划分的货物费率成本
上面的图表让我们大致了解了商品成本对零售利润的影响。总销售额较高(超过 50 亿美元)的细分市场也有较高的商品成本，在机动车和零部件经销商中超过 74 % ，在加油站中几乎达到 82% 。
另一方面，销售额较低的第二个区域，家具和 家居用品商店的价值较低，含 Cogs 的费用不到 49% 。
现在，我们可以访问毛利率并发现每一美元的成本可以产生多少利润。
按部门划分的平均毛利
同样，我们可以看到一个与之前相似的标准。销售额较高的细分市场每一美元的成本回报都较低。加油站和机动车和零部件经销商处于基线，每一美元产生 13 和 18 美分的毛利。排在第一位的是家具和** **家居用品店，每一美元涉及 46 美分的费用。
毛利率提供了一个公司盈利能力的大致线索，但不是一个精确的衡量标准。为了有一个更准确的数字，我们需要找到净利润率。为此，我们还需要将运营成本、税收、利息等其他费用纳入计算，以得出净收入，然后。****
净利润率=净收入/收入
该数据集仅带来费用文件，因此，将假设额外成本被收集到该文件中，以供进一步计算。
按部门划分的净利润率
上面的图表揭示了关于利润的更精确的数字。按照用于分析毛利率的相同标准，这些数字表达的是公司从销售退货中获得的每一美元中有多少是利润。
****加油站、电子电器商店和机动车和零部件经销商的数字较低，将利润转化为低于 3.5% 。换句话说，每卖出一美元，就有不到 0.035 美分的利润。无店铺零售商和杂货铺零售商的回报率最高，分别接近 15% 和 12% 。
下面我们对每个细分市场的净利润率和销售额进行了比较，结果显示，销售额最高的地区通常利润较低。
净利润率 x 销售额
更高的利润率是目标，因为这意味着公司从销售中获得更多。然而，来自领先位置细分市场的强劲销售并不一定转化为高利润率。我们需要找出这个百分比对应的金额。
汽车和零部件经销商仅转化为利润 3.30% — 对应于平均销售额2830 万美元——而位于销售图表中间的无店铺零售商获得 14.55%，对应4950 万美元。非商店零售商胜出。
如果我们将机动车辆和零件经销商与净利润率第二高的杂货铺零售商、进行比较，我们的、2830 万美元(3.30%)** 、1260 万美元、 (11.54%) 来自平均销售额。在这种情况下，机动车和零部件经销商转向最佳选择。**
到目前为止，无店铺零售商似乎是最好的选择，尽管它不是销售额最高的部门，但却有着最好的净利润率。
库存
库存是零售业中必须调查的另一个具有重大影响的关键领域。这意味着这是公司创收和盈利的来源之一。简单来说，就是指可供销售的商品和用于制造供销售的产品的原材料。
基本上，长期保持较高库存量对公司来说是不利的，除了过时之外，还会带来储存和损耗成本。然而，小的库存也会带来一些问题，比如由于库存不足而导致的潜在销售损失。
也就是说，我们需要使用以下公式，通过存货周转率来衡量一家公司在特定时期内销售和置换存货的次数
库存周转率=销售额/平均库存
按部门划分的库存周转率
一些消息来源称，零售的理想库存周转率在 4 到 6 之间，但是正如我们在上面看到的，这些数字会根据业务领域的不同而有所不同。事实上，这些数字只是指导搜索最佳结果的参考。
从上图可以看出，加油站的库存周转率较高，销售库存天数较少，每年替换库存 50.35 次，抛售库存 7.32 天。在这种情况下，我们可以说高销售需求和有限的库存空间可能是原因。然而，很少会在加油站停下来，面对由于燃料短缺而关闭的加油站。
考虑到参考值(4 和 6)，我们可以说体育用品、业余爱好、书籍和音乐商店**、服装和配件商店和机动车辆和零件经销商显示出最佳库存比率，正好在期望比率 4 和 6 之间。**
最后，我们将分析毛利润投资回报(GMROI)** ，这是一个零售指标，用于确定一家公司(在本例中，是一个细分市场)是否从购买的产品中获得了足够的毛利润。**
由此，我们可以使用下面的公式计算出需要多少库存投资才能产生理想的毛利润。
GMROI =毛利/平均库存成本
投资毛利率回报
上面的图表带来了有趣的数字。我们可以说，GMROI 越高，投资于库存的每一美元就能赚更多的钱。从机动车辆和零件经销商部门开始，显示最低的 GMROI 为 1.04，这意味着该部门的收入为 104%，仅略高于成本。
分析加油站**，GMROI 结果为 6.59 的细分市场返回了 656%的收入，因此销售商品的价格高于其购买成本。无店铺零售商紧随其后，销售额为 5.07 英镑，收益为 507%。基于这些结果，加油站和非商店零售商对投资者来说似乎是不错的选择。**
Adeolu Eletu 在 Unsplash 上拍摄的照片
结论
我们现在将总结一下到目前为止发现的关键见解。
- 由于大衰退(2008 年至 2009 年)，美国零售贸易地区在 2004 年至 2014 年期间的年平均增长率约为 2.5%。在此之前，该部门的增长率接近 5%。自 2010 年开始复苏后，预计 2015 年该细分市场的增长率约为 3.5%。
- 汽车及零部件经销商部门的总销售额较高，同期为 94.4 亿美元。比第二高的卖家多 31%左右的销量。
- 汽车及零部件经销商深受危机影响，在危机最严重的时候下降了 14.53%，但也是复苏最强劲的，2010 年至 2014 年平均下降了 8.75%。非商店零售商也有类似的复苏(8.59%)，但与汽车和零部件经销商相比，销售额减少了近 40%。****
-家具和 家居饰品店的销售成本(COGS)最低，不到费用的 49%。加油站和机动车和零部件经销商的 COGS 最高，分别为 82%和 74%。
- 加油站、电子和家电商店以及汽车和零部件经销商的净利润率较低，为 3.5%，每销售一美元利润仅获得 0.035 美分的回报。非商店零售商和杂货铺零售商显示了最好的数字，分别转换了近 15%和 12%。
- 无店铺零售商的净利润率更高，即使销售额排名第五。该部分的回报率为 14.55%，相当于 4950 万美元。最高卖家机动车及零部件经销商**，回报仅为 3.30%，回应为 2830 万美元。**
-尽管拥有可观的库存周转率，加油站和无店铺零售商都拥有最好的毛利率投资回报率(GMROI)达到 6.59 和 5.07，这意味着其收入分别为成本的 659%和 507%。
基于本文收集的所有信息，我们可以得出结论，无商店零售商细分市场是投资者的最佳选择。尽管不是销量最高的细分市场，但它在受大衰退影响较小的细分市场中排名第四，仅下降了-2.43%，在复苏中排名第二，平均增长 8.59%。
无店铺零售商也有最好的净利润率，回报率为 14.55%，或者说每卖出一美元赚 0.15 美分。此外，它的 GMROI 排名第二，收入是成本的 507%。
希望你喜欢这篇文章！谢谢大家！
这里 可以访问 用于分析的代码
探索悉尼的区域和场所
使用 Foursquare API 和 K-means 对悉尼地区进行聚类。
乔希·威瑟斯在 Unsplash 上的照片
这篇文章对我的项目进行了概述。要查看用于完成分析的代码，请查看我的笔记本。
1.介绍
新南威尔士州(NSW)是澳大利亚的主要州之一，拥有超过 810 万居民，是人口最多的州。新南威尔士州内有许多城镇，其首府悉尼是新南威尔士州近三分之二人口的家园。
该项目的目的是探索悉尼的不同地区，并根据每个区的顶级公共场所为新居民找到最佳位置。这篇文章将针对有意成为澳大利亚悉尼新南威尔士州居民的人，以及购房者、长期居留者和其他类似情况的人。其他有兴趣了解悉尼不同行政区的人也可以从中受益。
随着澳大利亚成为一个多元文化的国家，它的景观不断演变，看到不同的种族社区和场所的增加。将讨论悉尼区，以便利益相关者可以根据他们的兴趣选择最佳居住地点。
2.数据
将使用以下数据:
- 包含澳大利亚的二级行政和政治区划。这包括土著理事会、自治市、城市、政府和区理事会、市政当局、农村城市、郡和地区。导出的 JSON 文件中的相关信息包括州/地区、区/议会和每个分区的多个坐标。
- 用于获取悉尼每个区的公共场所，如餐馆、商店和公园。
数据集(1)由 11 个州或地区和 1395 个行政区组成，随后被提取以仅获得与新南威尔士州相关的数据；这包括 199 个行政区。在探索新南威尔士州的数据时，没有快速的方法来查找悉尼地区新南威尔士州的行政区。相反，不在悉尼附近的行被手动删除，悉尼被指定为在悉尼的 80 公里半径内。
在发现每个位置的几何都是多点类型后，我使用了我的数据框的第一个坐标，后来发现它是不准确的。相反，我手动清理了数据框，删除了重复的行政区名称(如利物浦东、利物浦西)，因为它们与其他行政区重叠，并使用谷歌地图/搜索获得了每个分区的正确坐标。最终的数据框现在由指定的悉尼地区的 38 个行政区组成。
3.方法学
在检索了我们指定的悉尼地区的行政区以及每个行政区的经度和纬度之后，我们现在将使用 Foursquare API 进行探索性分析，以找到我们附近的场馆。然后，我们将使用 K-means 聚类来创建具有相似特征的邻域聚类。
首先，使用地理库和树叶库我们可以创建一个叠加了 38 个区的悉尼地图。
现在，我们使用 Foursquare API 从给定的坐标中发现附近的场地。我将半径定义为 1 公里，并提取了场馆的信息，如名称、类别和坐标。然后，我们可以将其合并到一个新的数据框中，其中包含社区和场馆信息。例如，在阿什菲尔德我们发现:
不幸的是，一些位置没有返回任何地点(Botany Bay，Warringah ),这可能是由于坐标的放置，因此它们被从分析中删除。总的来说，我们的行政区共有 143 个独特的类别和 890 个场馆。下图显示了返回的前 10 个场馆类别；然而，有些是不准确的，因为他们没有捕捉到至少 10 个不同的场馆。
在使用一个热点编码并对每个场馆类别的频率取平均值后，我们可以使用 K-means 聚类，这是一种无监督学习算法，用于根据特征相似性创建数据点的 K 聚类。观察肘方法和剪影评分，我们发现要使用的最佳聚类数是 K = 4 。
在运行 K-means 聚类之后，生成的聚类标签被添加到一个新的数据框中，该数据框是从我们的原始数据框及其对应的前 10 个场馆合并而来的。
想象一下每个集群中每个社区的第一个最常见的场地也是很棒的。这样，我们可以为我们的集群形成不同的标签。我创建了第一个最常见场馆的堆积条形图:
挺有意思的。通过分析条形图(以及排名前 10 的场馆)，我们可以归纳出每个集群，并将其标记如下:
受塞尔詹·耶尔德兹项目的启发，我为每个区添加了前 2 个场馆，这样我们可以在创建新地图后查看该地区的更多信息。
我们可以合并新列，形成包含所有信息的最终数据框。
4.结果和讨论
最后，我们最终创建了显示集群信息的地图。
总共 36 个邻域的 K-均值聚类的结果描绘了 2 个主要聚类和 2 个单邻域聚类。通过检查集群，我们发现:
- 集群 0(红色)-在这些位置可以找到大量的咖啡馆，其中有两个独特的位置(曼利和萨瑟兰郡，在这种情况下，克罗努拉)拥有海滩
- 第 1 组(紫色)——各种社交区域、购物商店和餐馆/咖啡馆
- 集群 2(青色)——被自然保护区包围(库-环-盖)
- 聚类 3(浅黄色)-由公园和旧货店组成(Holroyd)
通过包含更多的社区/议会区域，这些集群可以更加独特，具有更多的特征。每个邻域坐标周围 1 公里的半径可能不足以获取该区域的信息。例如，在第 2 组和第 3 组的地点周围只发现了两个场馆。这可以通过选择更好的坐标来改善，这样更多的场馆将被包围。增加圆圈的半径也将捕获更多关于该区域内其他场馆的信息。
建议想去悉尼新南威尔士州旅游或居住的人多研究一下附近地区，看看这些地区是否适合他们的生活方式或文化。红点(聚类 0)大多更接近悉尼的中央商务区，该地区的特点是咖啡馆场地。紫色圆点(聚类 1)远离悉尼中央商务区，该区域以其各种美食场所为特色。通过更仔细的观察，一些地区可以通过特定菜系的餐馆数量来识别。例如，我们的分析涵盖了 Leichhardt 的意大利餐厅(7 家)、Marrickville 的越南餐厅(8 家)和 Strathfield 的韩国餐厅(15 家)。
运行笔来访问地图的交互式版本
通过分析不同社区的顶级场所，这导致探索许多以美食和咖啡馆为特色的区域。仅基于这一因素选择居住区域不是最佳选择，但可以帮助特定人群寻找社交聚会和美食的不同区域。
5.结论
希望成为居民和其他利益相关者的人可以根据他们的兴趣选择悉尼新南威尔士州的最佳位置，如餐厅的菜肴、咖啡馆的数量或靠近海滩和公园。然而，不建议这样做，因为在寻找一个可以参观或居住的地方时，会有很多因素在起作用。顶级场所的聚类对于那些希望在菜肴与该地区其他餐馆有所不同的地区开设餐馆的人来说可能是有用的。在这个项目中进行的分析展示了每个集群的一些独特的场地。
总的来说，为新居民寻找最佳地点的最终决定将由个人自己做出。除了发现社区是如何通过场馆数量来表征的，他们还应该考虑其他因素，如交通、房价和不同必需品的获取。
感谢阅读！
这是我的 IBM 数据科学专业证书的顶点项目的一部分。您可以在这里找到该分析中使用的代码。下一次，我想探索悉尼不同的美食，所以请保持警惕！
欢迎在 LinkedIn 上联系我，或者在 Medium 上关注我。我刚刚开始在这个网站上发帖，我将期待发布更多关于数据科学、统计和我的经历的内容。
使用 PipelineProfiler 探索 Auto-Sklearn 模型
如何打开 AutoML 的黑匣子
图片来源:负空格
构建机器学习管道通常是一项困难、耗时且反复试验的任务。AutoML 通过自动选择计算步骤、调整超参数和训练解决机器学习问题的端到端模型，使这一过程变得更容易。Auto-Sklearn 是最流行的开源 AutoML 系统之一。给定一个数据集、一个问题类型(分类或回归)和一个度量分数，Auto-Sklearn 能够产生集成管道来优化所选的度量并产生良好的结果。
以数字数据集为例，我们希望在这里对数字图像进行分类。我们可以自动创建一个管道，用几行代码解决这个问题:
import sklearn.datasets
import autosklearn.classification
X, y = sklearn.datasets.load_digits(return_X_y=True)
automl = autosklearn.classification.AutoSklearnClassifier()
automl.fit(X, y, dataset_name='digits')
虽然这极大地方便了模型构建过程，但也使结果更加模糊:数据科学家不知道采取了什么步骤来产生管道，探索了搜索空间的什么部分，以及调整了什么超参数。
在这篇博文中，我们展示了如何使用 PipelineProfiler 来调试和探索 Auto-Sklearn 生成的模型。 PipelineProfiler 是一个新的库，旨在生成端到端机器学习管道的详细可视化。它与 Python 笔记本(Jupyter 和 Google Colab)集成在一起，可以在数据科学工作流中使用。
管道剖面仪工具
给定由 Auto-Sklearn 生成的训练模型，我们可以使用具有三行代码的 PipelineProfiler:
import PipelineProfiler
profiler_data = PipelineProfiler.import_autosklearn(automl)
PipelineProfiler.plot_pipeline_matrix(profiler_data)
图 1 PipelineProfiler 应用于 Digits 数据集。
图 1 显示了应用于 Digits 数据集的 PipelineProfiler 。该系统分为三个部分。1)原始贡献，显示原始使用与管道分数的相关性。2)流水线矩阵，呈现流水线、所使用的原语和超参数的概要。3)管道比较视图，突出显示所选管道之间的差异。
管道分析
图一。显示顶部两条管线使用 Nystroem 采样器、 LDA 和变压器，但是在级平衡和采样器超参数的使用上有所不同。原始贡献向我们展示了 Nystroem 采样器和 LDA 与高准确度分数相关。反之，特征集聚与低分相关。
管道比较视图显示了所选管道的节点链接表示(按住键并点击可以选择多条管道)。图一。显示了三大管道之间的差异。为每个选定的管线指定一种颜色，并用颜色对图形节点进行编码，以表示原始管线。
PipelineProfiler 还显示被评估管道的性能指标。在图 1 中。，我们会看到所有管道的准确度分数。但是，我们可以将此视图切换到其他管道指标。例如，Auto-Sklearn 生成的集合由所有评估的管道的加权平均值组成。我们可以切换度量分数来显示总体权重。我们还可以可视化每个管道的训练时间。图二。显示了可以显示的多个指标。我们从这个图像中移除了原始贡献视图，因为对于每个选择的度量，贡献都是不同的。
图 2 PipelineProfiler 可用于检查 Auto-Sklearn 提供的指标，例如准确度、总体重量和时间。
我们注意到管线#9 和#19 不属于系综，因为它们的权重被设置为零。此外，我们看到管道#7 训练时间最长，管道#9 和#5 训练时间最快。我们还注意到，流水线#1 具有最好的精度，但是不具有最高的总体权重。这表明 Auto-Sklearn 使用其他标准将权重分配给集合中的管道。
如果我们对哪些原语导致了长训练时间感兴趣，我们可以研究原语贡献视图:
图三。基于时间度量计算的原始贡献。梯度提升是与流水线训练时间最相关的原语。
这里，我们看到梯度增强和多项式是与高训练时间相关的两个原语，因此它们可能是罪魁祸首。直观地说，原始的多项式会导致更长的训练时间，因为它会从原始数据中生成大量的多项式特征。
最后的想法
这篇文章简要介绍了 PipelineProfiler ，这是一个 Python 库，可以用来研究 AutoML 模型。我们已经在 Jupyter Notebook 中看到了如何从 Auto-Sklearn 导入和可视化管道。
PipelineProfiler 是一款新工具，我们正在积极寻求关于我们应该支持哪些功能的反馈。如果您有任何问题或想要合作，请告诉我们！
安装和演示
该系统的现场演示可在 Google Colab 上获得。
该代码是在 BSD 3 许可下开源的。github 库是:https://github.com/VIDA-NYU/PipelineVis
PipelineProfiler 可从 PyPI 库中获得。它可以通过以下命令安装:
pip install pipelineprofiler
欲了解更多信息，请参见我们的论文并观看我们的视频演示:
[1]福雷尔，马蒂亚斯等.高效健壮的自动化机器学习。 神经信息处理系统进展 2015。https://automl.github.io/auto-sklearn
[2] Ono，Jorge 等人，“PipelineProfiler:用于探测 AutoML 管道的可视化分析工具”。2020.https://arxiv.org/abs/2005.00160
探索 Azure Cosmos DB 中的内置 Jupyter 笔记本
快速介绍如何使用内置的 Jupyter 笔记本探索 Azure Cosmos DB 数据
Azure Cosmos DB Logo 来源。 Jupter 标志来源
【2019 年 5 月，Cosmos DB 团队公布了在 Cosmos DB 账户内运行 Jupyter 笔记本的预览。该功能于 2019 年 9 月公开发布，适用于所有的 Cosmos DB API。有了这个功能，我们可以使用 Jupyter 笔记本来运行交互式查询，探索我们的数据和可视化我们的数据。我们甚至可以在 Cosmos DB 中的数据上建立机器学习模型！
我能从中得到什么？
在我们的 Cosmos DB 帐户中拥有 Jupyter 笔记本电脑会给我们带来很多好处。其中包括:
- 我们可以在我们的 Cosmos DB 数据上生成很酷的数据可视化。
- 在我们的笔记本中更轻松地共享代码。有没有尝试过在 GitHub 中分享 Jupyter 笔记本代码中的代码？这是可行的，但是通过在 Cosmos DB 中使用笔记本，它更具交互性，我们可以在 Azure 门户中显示结果。
- 我们的代码更具交互性，我们可以在笔记本中嵌入用户控件
- 我们可以在一个文档中组合不同类型的文档、文本、图像、动画等。
- 我们可以在笔记本上执行神奇的宇宙命令！稍后会详细介绍。
听起来很酷，怎么才能得到这个功能？
创建一个新的支持笔记本的 Azure Cosmos DB 帐户非常简单:
在 Azure 门户中，点击创建资源并选择 Azure Cosmos DB。在创建 Azure Cosmos DB 帐户中，确保您选择了笔记本。点击审核+创建，然后点击创建。
创建帐户后，您将在数据浏览器窗格中找到您的笔记本工作区。
但是我已经有一个 Cosmos DB 帐户了！要使用笔记本电脑，我必须销毁现有的笔记本吗？
一点也不！您可以通过执行以下操作来启用笔记本功能:
进入你的 Cosmos DB 账户的数据浏览器面板，选择启用笔记本。点击完成设置，您的账户将可以使用笔记本！
好了，我都准备好了！给我演示一下！
现在我们的 Cosmos DB 帐户中已经有了笔记本，让我们开始使用它吧！我已经在我的 Cosmos DB 帐户中创建了一个容器，并按照这个演示使用数据填充它。(这个演示是由 Cosmos DB 工程团队提供的一系列演示，如果您想深入了解 Cosmos DB 的所有内容，我强烈推荐它！).
我们可以在我们的 Jupyter 笔记本上安装新的软件包，就像其他笔记本一样。让我们通过输入以下命令来安装 Pandas:
import pandas as pd
点击运行，很快，我们就可以在笔记本上使用熊猫了。现在让我们使用这些宇宙命令中的一个来创建一个我们可以使用的熊猫数据框架。我有一个名为 CustomCollection 的集合，它是由 /type 划分的。我想创建一个 DataFrame 来处理我的所有类型为 PurchaseFoodOrBeverage 的项目。我们可以通过执行以下命令来做到这一点:
%%sql --database EntertainmentDatabase --container CustomCollection --output df_foodOrBeverage
SELECT c.id, c.unitPrice, c.totalPrice, c.quantity, c.type FROM c WHERE c.type = "PurchaseFoodOrBeverage"
在这个查询中，我只选择了我们的 POCO 属性。SELECT *还将包括 Cosmos DB 系统生成的属性，所以我现在将它们排除在外。我们现在可以通过执行以下命令来查看我们的数据帧:
df_foodOrBeverage.head(10)
我们现在应该看到以下结果:
让我们通过可视化来结束这个快速演示。键入以下命令:
pd.options.display.html.table_schema = True
pd.options.display.max_rows = Nonedf_foodOrBeverage.groupby("quantity").size()
这将产生一个 nteract 数据浏览器。这使我们能够过滤和可视化我们的数据框架。我们只需将 table_schema 设置为 True，将 max_rows 设置为我们想要的值，或者设置为 None 以显示所有结果。
我们可以用笔记本做很多事情，比如使用内置的 Python SDK for Cosmos DB，并将 JSON 文件上传到特定的 Cosmos DB 容器。查看文档以了解我们可以在 Jupyter 笔记本上为 Cosmos DB 做的所有事情！
结论
希望你现在对在 Cosmos DB Jupyter 笔记本上可以做什么有了一个基本的概念。如果你有什么问题，欢迎在评论中提问！
使用 Python Scikit-learn-Iris 数据集探索分类器
如何在 Python 中构建第一个分类器的分步指南。
凯文·卡斯特尔在 Unsplash 上的照片
一瞬间，想象你不是花卉专家(如果你是专家，那对你有好处！).你能区分三种不同的鸢尾吗——刚毛鸢尾、杂色鸢尾和海滨鸢尾？
鸣谢:基尚·马拉德卡(链接
我知道我不能…
但是，如果我们有一个包含这些物种实例的数据集，并对它们的萼片和花瓣进行测量，会怎么样呢？
换句话说，我们能从这个数据集中学到什么来帮助我们区分这三个物种吗？
古玩目录
资料组
在这篇博文中，我将探索来自 UCI 机器学习知识库的虹膜数据集。摘自其网站，据说是“也许是 模式识别文献【1】中最知名的数据库 。此外，创建了机器学习大师社区的杰森·布朗利(Jason Brownlee)称之为机器学习的“Hello World”[2]。
我会把这个数据集推荐给任何一个初学数据科学并渴望构建他们的第一个 ML 模型的人。以下是该数据集的一些良好特征:
- 150 个样本，4 个属性(相同单位，全是数字)
- 均衡的类别分布(每个类别 50 个样本)
- 没有丢失数据
正如您所看到的，这些特征有助于最大限度地减少您在数据准备过程中需要花费的时间，以便您可以专注于构建 ML 模型。并不是说准备阶段不重要。相反，这个过程非常重要，对于一些初学者来说，它可能太费时间了，以至于他们可能在进入模型开发阶段之前就不知所措了。
例如，来自 Kaggle 的流行数据集House Prices:Advanced Regression Techniques有大约 80 个特征，其中超过 20%包含某种程度的缺失数据。在这种情况下，您可能需要花一些时间来理解属性并输入缺失的值。
现在希望你的信心水平(没有统计双关语)相对较高。这里有一些关于数据争论的资源，你可以在处理更复杂的数据集和任务时通读一下:降维、不平衡分类、特征工程和插补。
目标
探索该数据集后，我们希望能够回答两个问题，这两个问题在大多数分类问题中非常典型:
- 预测 —给定新的数据点，模型预测其类别(物种)的准确度如何？
- 推断 —哪个(些)预测器能有效地帮助预测？
简单说说分类
分类是一种类型的 监督机器学习 问题，其中目标(响应)变量是分类的。给定包含已知标签的训练数据，分类器逼近从输入变量(X)到输出变量(Y)的映射函数(f)。有关分类的更多资料，请参见统计学习介绍、吴恩达的机器学习课程(第 3 周)和 Simplilearn 的分类教程中的第 3 章。
Florian Olivo 在 Unsplash 上拍摄的照片
现在是时候写一些代码了！见我的 Github 页面获取我的完整 Python 代码(写在 Jupyter 笔记本上)。
导入库并加载数据集
首先需要导入一些库: pandas (加载数据集) numpy (矩阵操作) matplotlib 和 seaborn (可视化) sklearn (构建分类器)。确保在导入它们之前已经安装了它们(安装包指南此处为)。
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from pandas.plotting import parallel_coordinates
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn import metrics
from sklearn.naive_bayes import GaussianNB
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis, QuadraticDiscriminantAnalysis
from sklearn.neighbors import KNeighborsClassifier
from sklearn.svm import SVC
from sklearn.linear_model import LogisticRegression
要加载数据集，我们可以使用 pandas 的 read_csv 函数(我的代码还包括通过 url 加载的选项)。
data = pd.read_csv('data.csv')
加载完数据后，我们可以通过 head 函数查看前几行:
data.head(5)
注意:所有四个测量单位都是厘米。
数字汇总
首先，让我们通过*描述:*来看看每个属性的数字摘要
data.describe()
我们还可以使用 groupby 和 size 检查等级分布:
data.groupby('species').size()
我们可以看到每个类都有相同数量的实例。
列车测试分离
现在，我们可以将数据集分为训练集和测试集。一般来说，我们还应该有一个验证集，用于评估每个分类器的性能，并微调模型参数，以便确定最佳模型。测试集主要用于报告目的。然而，由于这个数据集很小，我们可以通过使用测试集来服务于验证集的目的，从而简化这个过程。
此外，我使用分层的拒绝方法来估计模型的准确性。另一种方法是做交叉验证来减少偏差和方差。
train, test = train_test_split(data, test_size = 0.4, stratify = data[‘species’], random_state = 42)
注意:一般的经验法则是将数据集的 20–30%作为测试集。由于这个数据集很小，我选择了 40%来确保有足够的数据点来测试模型性能。
探索性数据分析
分割数据集后，我们可以继续研究训练数据。无论是 matplotlib 还是 seaborn 都有很棒的绘图工具，我们可以用来进行可视化。
让我们首先通过每个特征的直方图创建一些单变量图:
n_bins = 10
fig, axs = plt.subplots(2, 2)
axs[0,0].hist(train['sepal_length'], bins = n_bins);
axs[0,0].set_title('Sepal Length');
axs[0,1].hist(train['sepal_width'], bins = n_bins);
axs[0,1].set_title('Sepal Width');
axs[1,0].hist(train['petal_length'], bins = n_bins);
axs[1,0].set_title('Petal Length');
axs[1,1].hist(train['petal_width'], bins = n_bins);
axs[1,1].set_title('Petal Width');# add some spacing between subplots
fig.tight_layout(pad=1.0);
四个特征的直方图
请注意，对于花瓣长度和花瓣宽度，似乎有一组数据点的值比其他数据点的值小，这表明该数据中可能有不同的组。
接下来，让我们尝试一些并排的方框图:
fig, axs = plt.subplots(2, 2)
fn = ["sepal_length", "sepal_width", "petal_length", "petal_width"]
cn = ['setosa', 'versicolor', 'virginica']
sns.boxplot(x = 'species', y = 'sepal_length', data = train, order = cn, ax = axs[0,0]);
sns.boxplot(x = 'species', y = 'sepal_width', data = train, order = cn, ax = axs[0,1]);
sns.boxplot(x = 'species', y = 'petal_length', data = train, order = cn, ax = axs[1,0]);
sns.boxplot(x = 'species', y = 'petal_width', data = train, order = cn, ax = axs[1,1]);
# add some spacing between subplots
fig.tight_layout(pad=1.0);
并排箱形图
底部的两个图表明我们之前看到的那组数据点是setas。它们的花瓣尺寸比其他两种更小，也更不展开。比较其他两个物种，云芝的平均价值低于海滨锦鸡儿。
Violin plot 是另一种类型的可视化，它结合了直方图和箱线图的优点:
sns.violinplot(x="species", y="petal_length", data=train, size=5, order = cn, palette = 'colorblind');
花瓣长度的小提琴图
现在，我们可以通过使用 seaborn 的 pairplot 函数来制作所有成对属性的散点图:
sns.pairplot(train, hue="species", height = 2, palette = 'colorblind');
全配对属性散点图
注意，一些变量似乎是高度相关的，例如，花瓣长度和花瓣宽度。此外，花瓣的测量方法比萼片的测量方法更能区分不同的物种。
接下来，我们制作一个相关矩阵来定量考察变量之间的关系:
corrmat = train.corr()
sns.heatmap(corrmat, annot = True, square = True);
相关矩阵
主要的收获是花瓣测量值具有高度正相关，而萼片测量值不相关。注意花瓣特征与萼片长度也有相对较高的相关性，但与萼片宽度没有相关性。
另一个很酷的可视化工具是平行坐标图，它将每个样本表示为一条线。
parallel_coordinates(train, "species", color = ['blue', 'red', 'green']);
平行坐标图
正如我们之前看到的，花瓣测量比萼片测量更能区分物种。
构建分类器
现在我们准备建立一些分类器(呜-呼！)
为了使我们的生活更容易，让我们先把类标签和特性分离出来:
X_train = train[['sepal_length','sepal_width','petal_length','petal_width']]
y_train = train.species
X_test = test[['sepal_length','sepal_width','petal_length','petal_width']]
y_test = test.species
分类树
我想到的第一个分类器是一个被称为分类树的区别性分类模型(在这里阅读更多)。原因是我们可以看到分类规则，并且很容易解释。
让我们使用 sklearn ( 文档)构建一个，最大深度为 3，我们可以在测试数据上检查它的准确性:
mod_dt = DecisionTreeClassifier(max_depth = 3, random_state = 1)
mod_dt.fit(X_train,y_train)
prediction=mod_dt.predict(X_test)
print(‘The accuracy of the Decision Tree is’,”{:.3f}”.format(metrics.accuracy_score(prediction,y_test)))--------------------------------------------------------------------
The accuracy of the Decision Tree is 0.983.
该决策树正确预测了 98.3%的测试数据。该模型的一个优点是，您可以通过其 feature_importances_ 属性看到每个预测值的重要性:
mod_dt.feature_importances_--------------------------------------------------------------------
array([0\. , 0\. , 0.42430866, 0.57569134])
从输出和基于四个特征的索引，我们知道前两个特征(萼片测量)不重要，只有花瓣特征用于构建该树。
决策树的另一个好处是我们可以通过 plot_tree 可视化分类规则:
plt.figure(figsize = (10,8))
plot_tree(mod_dt, feature_names = fn, class_names = cn, filled = True);
此树中的分类规则(对于每个拆分，左->是，右->否)
除了每个规则之外(例如，第一个标准是花瓣宽度≤ 0.7)，我们还可以看到在每个分割、指定类别等处的基尼指数(杂质测量)。注意，除了底部的两个“浅紫色”方框外，所有的终端节点都是纯的。对于这两类情况，我们可以不那么自信。
为了演示对新数据点进行分类是多么容易，假设一个新实例的花瓣长度为 4.5 厘米，花瓣宽度为 1.5 厘米，那么我们可以根据规则预测它是杂色的。
由于只使用了花瓣特征，我们可以可视化决策边界并绘制 2D 的测试数据:
在 60 个数据点中，59 个数据点被正确分类。显示预测结果的另一种方式是通过混淆矩阵:
disp = metrics.plot_confusion_matrix(mod_dt, X_test, y_test,
display_labels=cn,
cmap=plt.cm.Blues,
normalize=None)
disp.ax_.set_title('Decision Tree Confusion matrix, without normalization');
通过这个矩阵，我们看到有一个我们预测是弗吉尼亚的云芝。
一个缺点是建造一个单独的树是它的 不稳定 ，这可以通过集合技术来改善，如随机森林，助推等。现在，让我们继续下一个模型。
高斯朴素贝叶斯分类器
最流行的分类模型之一是朴素贝叶斯。它包含单词“Naive ”,因为它有一个关键的假设类-条件独立性,这意味着给定类，每个特性的值被假设为独立于任何其他特性的值(在这里阅读更多)。
我们知道，显然不是这种情况，花瓣特征之间的高度相关性证明了这一点。让我们用这个模型来检验测试的准确性，看看这个假设是否可靠:
The accuracy of the Guassian Naive Bayes Classifier on test data is 0.933
如果我们只使用花瓣特征，结果会怎样:
The accuracy of the Guassian Naive Bayes Classifier with 2 predictors on test data is 0.950
有趣的是，仅使用两个特征会导致更正确的分类点，这表明在使用所有特征时可能会过度拟合。看来我们的朴素贝叶斯分类器做得不错。
线性判别分析
如果我们使用多变量高斯分布来计算类别条件密度，而不是采用单变量高斯分布的乘积(在朴素贝叶斯中使用)，那么我们将得到 LDA 模型(在此阅读更多和)。LDA 的关键假设是类之间的协方差相等。我们可以使用所有特征并且仅使用花瓣特征来检查测试准确性:
The accuracy of the LDA Classifier on test data is 0.983
The accuracy of the LDA Classifier with two predictors on test data is 0.933
使用所有特征提高了我们的 LDA 模型的测试精度。
为了可视化 2D 的决策边界，我们可以使用只有花瓣的 LDA 模型，并绘制测试数据:
四个测试点被错误分类——三个 virginica 和一个 versicolor。
现在假设我们想用这个模型对新的数据点进行分类，我们可以在这个图上画出这个点，并根据它所属的彩色区域进行预测。
二次判别分析(QDA)
LDA 和 QDA 的区别在于，QDA 并不假设协方差在所有类中都是相等的，它被称为“二次的”,因为决策边界是二次函数。
The accuracy of the QDA Classifier is 0.983
The accuracy of the QDA Classifier with two predictors is 0.967
在所有特征的情况下，它与 LDA 具有相同的准确性，在仅使用花瓣时，它的性能略好。
同样，让我们为 QDA(只有花瓣的模型)绘制决策边界:
K 个最近邻居(K-NN)
现在，让我们稍微转换一下话题，看看一个名为 KNN 的非参数生成模型(点击阅读更多)。这是一个流行的模型，因为它相对简单且易于实现。然而，当特征数量变大时，我们需要注意维度的诅咒。
让我们画出不同 K 选择的测试精度图:
我们可以看到，当 K 为 3，或者介于 7 和 10 之间时，精度最高(约为 0.965)。与之前的模型相比，对新数据点进行分类不太直接，因为我们需要查看四维空间中它的 K 个最近邻居。
其他型号
我还探索了其他模型，如逻辑回归，支持向量机分类器等。详见我在 Github 上的代码。
请注意， **SVC(带线性内核)**实现了 100%的测试准确率！
我们现在应该很有信心，因为我们的大多数模型的准确率都超过了 95%。
接下来的步骤
以下是对未来研究的一些想法:
- 创建一个验证集并运行交叉验证，以获得准确的估计值，并比较它们之间的差值和平均准确度。
- 找到包括其他鸢尾属物种及其萼片/花瓣测量值的其他数据源(如果可能，也包括其他属性)，并检查新的分类准确性。
- 制作一个交互式网络应用程序，根据用户输入的测量值预测物种(查看我的简单网络演示，Heroku 部署此处
摘要
让我们回顾一下。
我们研究了虹膜数据集，然后使用 sklearn 构建了一些流行的分类器。我们看到花瓣的测量比萼片的测量更有助于实例的分类。此外，大多数模型的测试准确率都达到了 95%以上。
我希望你喜欢这篇博文，并请分享你的任何想法:)
查看我关于探索 Yelp 数据集的另一篇文章:
[## 发现你下一个最喜欢的餐馆 Yelp 数据集上的探索和可视化
你用 Yelp 找好餐馆吗？这篇文章揭示了流行的 Yelp 数据集中的见解和模式。
towardsdatascience.com](/discover-your-next-favorite-restaurant-exploration-and-visualization-on-yelps-dataset-157d9799123c)
参考
[1]https://archive.ics.uci.edu/ml/datasets/iris
【2】https://machinelingmastery . com/machine-learning-in-python-step-by-step/
探索张量板上混淆矩阵的演化
训练卷积神经网络对来自数据集的图像进行分类，并使用 TensorBoard 来探索其混淆矩阵如何演变。
张量板上的混淆矩阵演化
Tensorboard 是在训练和验证神经网络时可视化许多指标的最佳工具。在大多数情况下，我们需要寻找更多的细节，比如模型如何处理验证数据。有时训练和验证损失和准确性是不够的，我们需要弄清楚验证数据的性能。一种方法是使用混淆矩阵来可视化。
混淆矩阵
在机器学习领域，特别是统计分类问题中，混淆矩阵，也被称为误差矩阵，是一种特定的表格布局，允许算法性能的可视化，通常是监督学习算法(在非监督学习中，它通常被称为匹配矩阵)。矩阵的每一行代表预测类中的实例，而每一列代表实际类中的实例(反之亦然)。该名称源于这样一个事实，即它可以很容易地看出系统是否混淆了两个类(即通常将一个类误标为另一个类)。
让我们建立一个混淆矩阵
我不会深入研究编码，我将只强调重要的代码部分，展示如何用 python 在 tensorboard 中设置和实现自定义回调。如果你想查看完整的代码，你可以查看我的知识库，我在这个故事的底部添加了一个链接。
我假设您已经构建并编译了一个 Keras 序列模型。
定义绘制 cm 的函数
def plot_confusion_matrix(cm, class_names):
"""
Returns a matplotlib figure containing the plotted confusion matrix.
Args:
cm (array, shape = [n, n]): a confusion matrix of integer classes
class_names (array, shape = [n]): String names of the integer classes
"""
figure = plt.figure(figsize=(8, 8))
plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
plt.title("Confusion matrix")
plt.colorbar()
tick_marks = np.arange(len(class_names))
plt.xticks(tick_marks, class_names, rotation=45)
plt.yticks(tick_marks, class_names)
# Normalize the confusion matrix.
cm = np.around(cm.astype('float') / cm.sum(axis=1)[:, np.newaxis], decimals=2)
# Use white text if squares are dark; otherwise black.
threshold = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
color = "white" if cm[i, j] > threshold else "black"
plt.text(j, i, cm[i, j], horizontalalignment="center", color=color)
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
return figure
设置 tensorboard 回调
我们现在准备训练 CNN，并在此过程中定期记录混淆矩阵。使用下面的代码，您将创建一个 Keras TensorBoard 回调来记录基本指标。
logdir = "logs/image/" + datetime.now().strftime("%Y%m%d-%H%M%S")tensorboard_callback = keras.callbacks.TensorBoard(log_dir = logdir, histogram_freq = 1)file_writer_cm = tf.summary.create_file_writer(logdir + '/cm')
将 Matplotlib 图形转换为 PNG
遗憾的是，Matplotlib 文件格式不能作为图像记录，但 PNG 文件格式可以记录。因此，我们将创建一个 helper 函数，它接受一个 Matplotlib 图形，并将其转换为 PNG 格式，以便可以编写。
def plot_to_image(figure):
"""
Converts the matplotlib plot specified by 'figure' to a PNG image and
returns it. The supplied figure is closed and inaccessible after this call.
"""
buf = io.BytesIO()
# Use plt.savefig to save the plot to a PNG in memory.
plt.savefig(buf, format='png')
# Closing the figure prevents it from being displayed directly inside
# the notebook.
plt.close(figure)
buf.seek(0)
# Use tf.image.decode_png to convert the PNG buffer
# to a TF image. Make sure you use 4 channels.
image = tf.image.decode_png(buf.getvalue(), channels=4)
# Use tf.expand_dims to add the batch dimension
image = tf.expand_dims(image, 0)
return image
计算混淆矩阵
我们将定义一个计算混淆矩阵的函数。
def log_confusion_matrix(epoch, logs):
# Use the model to predict the values from the test_images.
test_pred_raw = model.predict(test_images)
test_pred = np.argmax(test_pred_raw, axis=1)
# Calculate the confusion matrix using sklearn.metrics
cm = sklearn.metrics.confusion_matrix(test_labels, test_pred)
figure = plot_confusion_matrix(cm, class_names=class_names)
cm_image = plot_to_image(figure)
# Log the confusion matrix as an image summary.
with file_writer_cm.as_default():
tf.summary.image("Confusion Matrix", cm_image, step=epoch)
设置张量板以记录混淆矩阵
我们将在纪元结束时设置 tensorboard 回调来记录混淆矩阵
cm_callback = keras.callbacks.LambdaCallback(on_epoch_end=log_confusion_matrix)
开始冲浪板和训练
我们需要将值指定为 model.fit 中回调参数的列表，以指定 Keras 在训练时使用我们的自定义回调函数。
# Start TensorBoard.
%tensorboard --logdir logs/image# Train the classifier.
model.fit(train_images,
train_labels,
epochs=5,
verbose=0, # Suppress chatty output
callbacks=[tensorboard_callback, cm_callback],
validation_data=(test_images, test_labels))
默认情况下，tensorboard 服务器运行在端口 6006 上，如果您想要指定任何其他端口，您需要将该端口指定为 tensorboard 命令的参数。
Jupyter 用户只需在第一个单元格中键入%load_ext tensorboard并在导入库之前运行，这将在 Jupyter 笔记本中加载 tensorboard。
让我们看看我们的困惑矩阵
想试试自己吗
[## novas ush/tensor board-时尚 MNIST
训练一个卷积神经网络来分类时尚 MNIST 数据集的图像，并使用 TensorBoard 来探索…
github.com](https://github.com/novasush/Tensorboard-with-Fashion-MNIST)
参考我的 Github 回购链接。我在时尚 Mnist 数据集上训练了一个 CNN 分类器，并设置了一个混淆矩阵。以上输出来自我的 tensorboard 服务器。
额外资源
探索冠状病毒研究出版物
执行探索性数据分析
在冠状病毒爆发后，许多数据来源已向公众开放，以鼓励该领域的研究。最近，白宫和一群领先的研究人员公布了新冠肺炎开放研究数据集(CORD-19)，，该数据集可在 Kaggle *上获得。*我们的目标是让全球研究界应用机器学习和自然语言处理的最新进展，以获得对传染病的深入了解。
与大多数文本挖掘工作一样，生成汇总统计数据并直观地表示文本信息的内容是探索性数据分析的一个非常重要的部分。
在本帖中，我们将对*新冠肺炎开放研究数据集(CORD-19)进行探索性数据分析。*我们将使用 python 库，如‘seaborn’，‘matplotlib’和 Pandas 来探索和可视化数据集中提供的分类和文本信息。我们将使用的特定文件名为“all _ sources _ metadata _ 2020–03–13 . CSV”。
我们开始吧！
读取数据
首先，让我们将数据读入 Pandas 数据框:
import pandas pd
df = pd.read_csv(“all_sources_metadata_2020–03–13.csv”)
接下来，让我们打印前五行数据。让我们放松对显示的列数的限制(这里输出被抑制):
pd.set_option('display.max_columns', None)
print(df.head())
我们可以从很多地方开始分析。最简单的第一步是查看列的列表及其长度:
print("List of columns:")
print(list(df.columns))
print("Length of columns:", len(df.columns))
我们还可以查看数据集中的行数:
print("Number of rows: len(df))
接下来，我们可以查看所有出版物在期刊中的出现频率。我们可以使用 collections 模块中的 Counter 方法来实现这一点(这里输出也被抑制):
from collections import Counter
print(Counter(df['journal']))
我们可以看到，这是相当期刊名称和频率的列表。我们可以通过删除缺失值(’ nan ')并将输出限制为最常见的 10 个日志来缩小范围:
df['journal'].dropna(inplace = True)
print(Counter(df['journal']).most_common(10))
然后，我们可以使用“matplotlib”和“seaborn”来可视化最常见的期刊出版物。让我们对五种最常见的出版物也这样做:
import matplotlib.pyplot as plt
import seaborn as snssns.set()
bar_plot = dict(Counter(df['journal'].values).most_common(5))
plt.bar(*zip(*bar_plot.items()))
plt.show()
同样值得注意的是，如果我们看一下期刊的总数:
print(len(set(df['journal'])))
该数据集中有 1732 个日志。
出于好奇，我查找了这些期刊的影响因子。对于那些不知道的人来说，期刊影响因子是一个衡量期刊被引用频率的指标。越有声望或越难在期刊上发表的文章通常有更高的影响因子。最常见的五种期刊在 2019 年有以下影响因素:
- PLoS one: 2.8
- 急诊传染病:7.4
- 科学报告:4.1
- 公共科学图书馆 Pathog: 6.2
- 病毒:3.8
由于新兴传染病 (Emerg Infect Dis)的影响因子最高，发表数量第二高，因此分析该期刊发表的论文的文本内容可能会很有意思。
另一个有趣的项目是找出每种期刊的影响因子，并用影响因子信息扩充现有数据。用这些信息扩充我们的数据将允许我们过滤和搜索高影响力的新冠肺炎研究出版物。为了找到具有最高影响因子和相对出版物数量的期刊，我们需要将 1732 种期刊映射到影响因子值。
现在，让我们假设新兴传染病是一个有大量与新冠肺炎相关的出版物的好杂志。加强了这个假设，，一个期刊排名网站，把新兴传染病排在他们传染病期刊名单的第八位，这是相当不错的。
过滤数据
接下来，让我们过滤我们的数据，仅包括来自新发传染病的数据，并打印数据帧长度以供验证:
df = df[df.journal == 'Emerg Infect Dis']
print(len(df))
我们看到数据帧长度为 941。
现在我们来看一些摘要。让我们先来看看前 5 篇摘要，以便对文中的内容有所了解:
print(list(df['abstract'].values)[0])
print('-'*170)
print(list(df['abstract'].values)[1])
print('-'*170)
print(list(df['abstract'].values)[2])
print('-'*170)
print(list(df['abstract'].values)[3])
print('-'*170)
print(list(df['abstract'].values)[4])
print('-'*170)
情感分析
接下来我们要看的是摘要的情感分数。也许我们可以给每个摘要分配情感分数，看看分数是否与积极的结果相关联。
为了获得情感分数，我们需要导入一个名为 textblob 的 python 包。textblob 的文档可以在这里找到。要安装 textblob，请打开命令行并键入:
pip install textblob
下次导入 textblob:
from textblob import TextBlob
我们将使用极性得分作为积极或消极情绪的衡量标准。极性得分是一个从-1 到+1 的浮点数。
例如，让我们考虑一下 1991 年关于癌症药物紫杉醇的出版物， 紫杉醇:一种新的有效的抗癌药物 。摘要中有一句肯定的情感句子:
临床试验表明，紫杉醇对治疗难治性卵巢癌、乳腺癌、恶性黑色素瘤和其他可能的实体瘤有效。
如果我们定义一个 textblob 对象并传入上面的句子，我们有:
abstract_sentence = "Clinical trials indicate that taxol is effective in the treatment of patients with refractory ovarian cancer, breast cancer, malignant melanoma and probably other solid tumors."sentiment_score = TextBlob(abstract_sentence).sentiment.polarity
print("Sentiment Polarity Score:", sentiment_score)
如果我们把句子中的有效改为无效:
“临床试验表明，紫杉醇在治疗难治性卵巢癌、乳腺癌、恶性黑色素瘤以及其他可能的实体瘤患者时无效。”
并将其传递给我们的 textblob 对象:
abstract_sentence = "Clinical trials indicate that taxol is ineffective in the treatment of patients with refractory ovarian cancer, breast cancer, malignant melanoma and probably other solid tumors."sentiment_score = TextBlob(abstract_sentence).sentiment.polarity
print("Sentiment Polarity Score:", sentiment_score)
我们看到 textblob 能够捕捉科学陈述中的消极和积极情绪。让我们将此应用于新冠肺炎数据的摘要:
df['abstract'] = df['abstract'].astype(str)
df['sentiment'] = df['abstract'].apply(lambda abstract: TextBlob(abstract).sentiment.polarity)
让我们限制数据框中的列，使其包括“抽象”和“情感”,并打印前五行:
df = df[['abstract', 'sentiment']]
print(df.head())
我们也可以计算积极和消极情绪的数量:
df_pos = df[df['sentiment'] > 0.0]
df_neg = df[df['sentiment'] < 0.0]
print("Number of Positive Results", len(df_pos))
print("Number of Negative Result", len(df_neg))
为了安全起见，让我们将积极情绪的极性阈值提高到> 0.5，并打印一些积极情绪摘要:
df_pos = df[df['sentiment'] > 0.5]
print(list(df_pos['abstract'].values)[0])
print('-'*170)
print(list(df_pos['abstract'].values)[1])
print('-'*170)
print(list(df_pos['abstract'].values)[2])
print('-'*170)
print(list(df_pos['abstract'].values)[3])
print('-'*170)
print(list(df_pos['abstract'].values)[4])
print('-'*170)
我们看到 textblob 在给摘要分配积极的分数方面做得很好。让我们对负面情绪摘要做同样的事情，我们将把负面情绪阈值降低到-0.1:
df_neg = df[df['sentiment'] < -0.1]
print(list(df_neg['abstract'].values)[0])
print('-'*170)
print(list(df_neg['abstract'].values)[1])
print('-'*170)
print(list(df_neg['abstract'].values)[2])
print('-'*170)
print(list(df_neg['abstract'].values)[3])
print('-'*170)
print(list(df_neg['abstract'].values)[4])
print('-'*170)
这些结果不太确定。理想情况下，我们希望带有负面情绪的摘要包含如下陈述:
“没有证据表明会横向传染给其他猫，因为只有两只猫产生了抗 H5N1 病毒的抗体。”
将这种情感评分方法应用于所有期刊并比较期刊之间的消极和积极情感将是有趣的。
我就说到这里，但请放心地继续研究这些数据。可能值得研究其他文本分类方法，如 BERT，它可用于对报告负面和正面结果的期刊进行分类。
结论
总之，在本文中，我们对新冠肺炎开放研究数据集(CORD-19) 进行了简单的探索性分析。我们生成期刊数量的频率计数，可视化最常见的期刊，过滤我们的数据以将我们的分析限制在具有大量出版物的高影响力期刊，并对期刊摘要执行情感分析。我希望你觉得这篇文章有用/有趣。这篇文章中的代码可以在 GitHub 上找到。感谢您的阅读！
探索 DenseNets:从纸到 Keras
拆开 DenseNets 看看里面有什么“密”！
DenseNets 广泛用于图像分类任务、分割、图像重建等。如果你是一个经验丰富的 TF 开发者，你可能会在tf.keras.applications模块中看到它们。什么是 DenseNets？它们里面真的有密的东西吗？来吧，让我们一起探索！
您可以在本笔记本中查看 TF 的实现，
编辑描述
colab.research.google.com](https://colab.research.google.com/drive/1v2p228o-_PRtecU0vYUXuGlG_VierqcP#scrollTo=wbkXMkrTgXiF&forceEdit=true&sandboxMode=true)
致密网应该是致密的。对吗？
绝对的，DenseNets 是密集连接的卷积神经网络。我们将通过比较普通的 CNN(你会在大多数在线博客中看到)和密集块(DenseNet 的构建块)来理解这一点。).
矩形代表卷积层，红线表示连接或信息流。
常规 CNN(左)和密集区块(右)。
注意上面两个网络中的卷积层 3。在第一网络中，第三层接收来自前一层即第二层的信息。这似乎很正常。
看一看第二网络。这就是密集块的作用。第二网络中的第三卷积层接收来自所有先前层的信息。它接收 3 个输入，
- 红色箭头来自图像。这是第一层的输入。
- 另一个红色箭头来自前一层(第二层)。
- 来自第一层的黑色箭头。这是第一层的输出。
看，我们得到了所有先前层(第 1 层和第 2 层)的输出以及输入。这就是我们普通 CNN 和密块的区别。密集块中的每一层都与该块中的每一个后续层相连。一个块只是一组具有密集连接的层的别称。
除了密集块，我们还有所谓的过渡层。它们基本上对特征地图进行下采样。这些层执行 1 × 1 卷积和 2 × 2 平均合并。
每一层都从所有前面的层获得输入。听起来是不是很疯狂？
这个主意被证明是一个绝妙的诡计。在我们传统的 CNN 中，每一层只知道从前一层接收的特征地图。较差的卷积层对网络的输入一无所知。它只学习以前的输入。
另一方面，密集块中的每一层都从所有层接收输入或信息。简而言之，在全球范围内，整个网络都可以获得这些信息。这一点甚至在 DenseNets 的惊人论文中也有提及，
“除了更好的参数效率，DenseNets 的一大优势是改善了整个网络的信息流和梯度，这使得它们易于训练。”
而且，
“为了进一步改善各层之间的信息流，我们提出了一种不同的连接模式:我们引入了从任何一层到所有后续层的直接连接。”
我们也可能包括瓶颈层来提高计算效率。由于许多输入的串联，我们有大量的特征图，这可能会减慢训练。因此，我们对输入执行 1 × 1 卷积来解决这个问题。
解决上述问题的另一种方法是使用压缩率。它从区间 ( 0，1】中选择，并决定过渡层将产生的特征图的数量。如果θ是压缩因子并且 m 是输入特征图的数量，则过渡层产生由下式给出的 p 特征图，
数学
我们确实可以用一些数学来理解稠密连通性的概念！别担心，这很容易理解。考虑一个输入图像 x₀ 给我们的密集块。
H 是一个复合函数，由三个运算组成:批量归一化→ ReLU →卷积
我们将 H()定义为三个连续操作的复合函数:批量归一化(BN)，然后是校正线性单元(ReLU)和 3×3 卷积(Conv)。
第一层(x₁)的输出将由，
1.第一层的输出。
**一般对于常规 CNN(非 DenseNets)，**第l层的输出将由第l-1层的输入产生。
(1)的一般表达式。
对于一个 DenseNet ，正如我们之前讨论的，一个层从前面的层接收输入。它看起来会像，
方括号表示 x₀,x₁,…,xₗ₋₁的连接
这是 DenseBlock 的数学表达式。
在 TensorFlow 里看起来怎么样？(请用 Keras！)
我们都在急切地等待这个，对吗？我会坚持让你跟着 Colab 笔记本去看看 DenseNets 的实现。首先，我们实现前面讨论过的 H 函数。
然后是过渡层
现在，实现了密集块。我们将调用H()方法，将之前输出的conv_outputs和inputs连接起来。这将会循环发生，
我们现在将所有的密集块组装在一起，并用过渡层将它们连接起来，
最后，我们做了一个漂亮的tf.keras.models.Model()，
培训和评估包含在 Colab 笔记本中。恭喜你，你已经从零开始实现了一个 DenseNet！
更多关于 ML 的资源和博客
就这样
DenseNets 的想法令人印象深刻。请确保您也阅读了 ResNets。浏览报纸，你会了解更多关于训练的细节。感谢阅读。
探索 Python 中的设计模式
乔治·帕甘三世在 Unsplash 上的照片
如何在您的编程体验中实现可重用模型
设计模式用于帮助程序员理解概念、教学、学习，以及构建其他伟大的工作理念和概念。所以，当你思考设计模式的时候，要想到解决问题。设计模式是帮助构建和解决简单到复杂问题的模型。许多程序员实际上已经在他们自己的代码中实现了它们，而没有意识到这一点。这是因为它是一个如此抽象的概念，以至于你甚至不用真正思考它是什么就可以使用它。通过了解什么是设计模式以及如何使用它们，你可以克服那些看起来势不可挡的障碍。你还可以带来另一个层次的意识，而不是意外地实现一个笨拙的设计模式，你可以有意识地实现一个伟大的设计模式。设计模式在软件社区中被越来越多地使用，了解它们是一大优势。重要的是你至少知道面向对象编程的基础。更具体地说，你知道继承和多态性。
设计模式通常被称为设计模板，因为它们提供了如何处理常见的重复出现的问题的模板。您可以使用现有的设计模式，甚至创建自己的模式。设计模式有许多种类，下面是一些流行的设计模式:
- 创意
- 结构性
- 行为
设计模式有一些独特的优点:
- 它们适用于任何面向对象编程语言。
- 它们是灵活的。不断变化、发展和更新。
- 经常因为创造力而没有完成。
模式结构
模式名称
模式的简要描述。
问题还是意图
你试图解决的潜在问题是什么？
解决办法
指定模式适用的位置。定义模式的结构和行为。
参与者
模式中涉及的类和对象。
结果
使用该模式可能产生的影响。
Python 设计模式的常见类型:
创造型的
工厂
抽象工厂
一个
建设者
原型
对象池
结构的
装饰者
代理人
转接器，适配器；改编者
复合材料
桥
外表
轻量级
行为的
观察者
访问者
迭代程序
战略
命令
调解人
纪念品
状态
责任链
用 Python 实现基本设计模式
图案名称:工厂
图案类型:创意
在 Python 中实现设计模式时，能够为正确的用途选择正确的模式是很重要的。了解您的设计模式类别将有助于这个决策过程。
**问题:**你不确定你需要什么类型的对象或者你将使用什么类。
因此，在这个假设的场景中，假设您拥有一家计算机商店，并且只销售一种类型的显示器。你已经在卖的显示器是小显示器。您现在想在库存中添加大型显示器进行销售。
**解决方案:**这种模式适合创建新对象。它在许多涉及接口或类实例化的编程问题领域也有广泛的适用性。这对于大规模扩展您的类实例化并保持代码快速、简单和有组织非常有用。
# First Class for Small Monitor
class SmallMonitor():
def __init__(self, brand):
self._brand = brand def details(self):
details = "24in x 24in 1080p | $87.00"
return details# Second Class for Large Monitor
class LargeMonitor():
def __init__(self, brand):
self._brand = brand def details(self):
details = "32in x 32in 1080p | $115.00"
return details# Basic Creative Design Pattern Implementation
def get_monitor(monitor = 'small_monitor'):
"""factory method"""
monitors = dict(small_monitor = SmallMonitor("ASUS"),
large_monitor = LargeMonitor("HP"))
ruturn monitors[monitor]small_monitor = get_monitor("small_monitor").details()
large_monitor = get_monitor("large_monitor").details()print(small_monitor)
print(large_monitor)[out]
24in x 24in 1080p | $87.00
32in x 32in 1080p | $115.00
**参与者:**参与者是SmallMonitor()和LargeMonitor()类。另外，small_monitor和large_monitor对象也将包含在内。
**结果:**当应用于大规模的类实例化时，该模式具有积极的结果，但有时可能会令人困惑，或者对于更简单的实例化来说没有必要。在某些情况下，它会限制可用的代码。这也是 Python 中不推荐的许多应用程序。
结论
设计模式支持社区之间以及个人之间一致的编码。它们有助于维护一个健康的编程生态系统，该系统对常见问题有众所周知的解决方案。使用设计模式有时会使事情变得更糟，应该使用逻辑、推理和适当的实现将其集成到您的编码方案中。有时你手头的问题有错误的设计模式，有时没有或创建自己的设计模式是最好的主意。不管怎样，设计模式的知识只会让你成为更好的程序员。在许多情况下，它们将显著提高您的代码和效率。我希望这能帮助任何想了解更多 Python 设计模式基础知识的人。谢谢大家，编码快乐！
探索贝叶斯领域的实验
通过贝叶斯方法将 A/B 实验提升一个档次
资料来源:datascientistinsights.com
这篇文章的目的是鼓励人们探索实验设计的贝叶斯框架。
这篇文章包括:
- 什么是 A/B 测试，大多数人一般是怎么做的？
- 贝叶斯框架相对于频率主义方法的优势
- 这两种方法的根本区别在于
- 接下来去哪里找？
你也可以在这个 Jupyter 笔记本里找到这个题目的详细版本和解释(带代码)。
1.什么是 A/B 测试，人们一般是怎么做的？
极限实验是开启公司成功之门的钥匙之一。我们试验得越多，学到的东西就越多，就越有可能发现顾客的真正需求。
A/B 测试(有时也称为分割测试)是指同时向不同部分的访问者显示同一网页的两种变体，并比较哪种变体能带来更多的转换。
资料来源:Optimizely.com
历史上，公司一直使用频率主义/经典方法来测试不同的假设(例如，从两个不同的网站中找出一个胜出的版本)。基于这种方法，正在做出建立成功的客户-公司关系的决策。
那么大多数人/公司是怎么做的呢？
设计实验的整个过程由多个步骤组成，如决定测试组和对照组(即哪个用户将看到页面的哪个变体)，希望实验运行的天数，以及最后测量结果。规划和测量阶段通常需要统计计算，如先验功效分析、效应大小和样本大小计算。最后，为了评估或测量结果，我们通常对比例进行 t 检验、卡方检验和 z 检验，以获得 p 值。这被称为频率主义/古典框架。
资料来源:reddit.com
上面我提到了相当多的统计关键词。如果您不知道这些术语，请不要担心。这些我已经在这里详细解释过了。
现在让我们来看看为什么我们应该谈论这个奇特的贝叶斯理论！
资料来源:xkcd.com
2.贝叶斯框架相对于频率主义方法的优势
实验/假设的成功也取决于决策者如何解释这些结果。实验者面临的常见挑战是统计结果的商业翻译，如*“由于 p 值小于 0.05，我们可以拒绝零假设。我们相信，如果零假设是真的，我们看到的证据不太可能在 95%的情况下出现。”*
他们实际上想听到的是“变量 B 优于 A 的概率是 x%。”
幸运的是，有一种方法可以降低实验成本，使我们做出决策的速度比平时快大约 50%,并且分析师可以大胆地大声说出下面的话:
“根据数据，从‘B’转换高于 A 的概率为 80%(举例)”。
不仅如此，我们可以在贝叶斯框架中不断地测量我们的结果，提供更多的透明度，而不是固定的样本大小设计。
贝叶斯框架为我们提供了这种非凡的方式。我们可以使用贝叶斯估计和序贯贝叶斯因子方法来设计我们的实验和测量我们想要的结果。
以下是贝叶斯方法相对于频率主义方法的明显优势:
一、达成决策所需的样本量约为频率主义方法的 50%(图 1) ( 白皮书 )
二。可解释性:简单直观地解释结果
观察结果的例子会是这样的——
频率主义者:“当我们观察到显著的 p 值为 0.02 时，我们可以拒绝零假设。”
Bayesian:“有 95%的可能性‘A’版本比‘B’版本更好，转化率的预期提升是 1.2 个百分点。”
三。我们可以对两个变量的转换率的实际概率进行评论
四。贝叶斯框架实现了一个连续的测量，相比之下，frequentist 的方法，窥视往往导致 p 值黑客攻击，这是一个有问题的做法
3.这两种方法的根本区别在于
借助于一个例子，也许可以更好地理解基本的区别(本节假设一些关于假设检验的先验知识)。
假设我们有两组，一组是治疗组，另一组是对照组。在频率主义者的方法中，我们从陈述我们的零假设开始。
**零假设:**经过某种处理后两组表现相似(假设这里考虑的度量是均值)；即治疗组的平均值等于对照组的平均值。
这个假设固定了μ1 — μ2 =0 的信念(参数)。修正这个无效假设，我们继续看数据如何以 p 值的形式证明这个信念。
在贝叶斯方法中，我们说我们的信念有一定的不确定性，我们试图找到我们信念/参数的概率分布。所以，在贝叶斯的世界里，我们试图估计这个信念的概率分布(参数；即μ1 — μ2 ),在合并了来自我们先前的信念的信息(我们认为参数可能是什么，如果我们对先前的信念没有意见也没关系！)和观测数据。简单来说，我们不看单点估计，我们看假设的概率分布，给定数据。这叫做后验概率。
p 值和后验概率之间的根本区别在于，p 值是关于被观察数据的概率的陈述(假设我们的零假设为真)，而后验概率是关于特定参数的置信程度(概率分布)的陈述。
4.接下来去哪里找？
我阅读了大量的博客和白皮书来理解贝叶斯方法。当我开始的时候，我对贝叶斯推理的看法是一种“神奇的修正”。我需要一个代码，在那里我可以输入数据，并可以得到类似“A 比 B 好的概率是 x%”的输出。一旦我完成了阅读和研究，我就把我所有的理解浓缩在一个笔记本里
但是在我能够使用、理解和应用这个神奇的修复方法之前，我遇到了一些令人痛苦的术语，如知情和不知情的先验、后验、可能性、边际可能性、贝叶斯因子、共轭先验、马尔可夫链蒙特卡罗模拟、假阳性率(当零假设实际上为真时拒绝它)和假阴性率(当零假设实际上为假时未能拒绝它)。
来源:布拉尼·韦达科维奇的博客
有了这本 Jupyter 笔记本，我希望能让任何想要理解贝叶斯框架及其与频率主义方法的比较的人变得更容易。
非常感谢建设性的反馈！
探索 Pytorch 库中几个有用的张量函数
通过探索 Pytorch 的库开始使用 py torch
马库斯·斯皮斯克在 Unsplash 上的照片
D 由脸书人工智能研究实验室开发的 PyTorch 如今被广泛用作深度学习框架，原因很多，从小规模的机器学习原型到生产层面的应用。
“Pytorch 是一个开源的机器学习框架，它加速了从研究原型到生产部署的道路”，官方网站上的描述说。
这篇博客故事是由 Jovian.ml 与 freecodecamp 合作提供的关于 Pytorch 深度学习的 6 周课程的一部分。#零托甘人
在本教程中，我们将深入探讨 Pytorch 库中关于张量的 5 个有用函数。让我们开始吧。
首先:进口 Pytorch
import torch
torch.rand():
该函数返回一个张量，其中填充了区间[0，1]上均匀分布的随机数。它的一些参数如下所示:
size(int)-定义输出张量形状的整数序列。可以是可变数量的参数或集合，如列表或元组。
dtype (torch.dtype，可选)-返回张量的所需数据类型。默认值:如果没有，则使用全局默认值(请参见 torch.set_default_tensor_type())。
requires_grad (bool，可选)-如果自动签名应该记录对返回张量的操作。默认值:False。
让我们看看这个相当简单的函数的几个例子。
工作示例-1
我们可以观察到，我们得到了区间[0，1]中 9 个元素的张量向量。
工作示例-2
这里，我们得到一个形状为 3x4 的张量，其元素在区间[0，1]中
何时使用该功能？
当我们希望以随机值的张量作为[0，1]范围内的元素时，可以使用这个函数。
torch.mean():
torch.mean 函数返回张量的平均值。下面列出了它的一些参数。
输入(张量)——输入张量。
dim (int 或 python 的 tuple:ints)-要减少的一个或多个维度。
keep dim(bool)——输出张量是否保留 dim。
out (张量，可选)—输出张量。
现在，让我们看几个使用这个非常方便的函数的例子。
在单元格中，通过对张量向量应用 torch.mean()，我们可以观察到张量向量中的所有数字相加并除以元素的个数。
让我们用这个函数来解决一些复杂的问题。
有时我们可能不想在整个张量上计算平均值，而是在行或列上计算。
使用 torch.mean()的“dim”参数
在上述单元格中，torch.mean()应用于(3，5)张量，并带有一个名为“dim”的附加参数。此参数指定应该对行(如果 dim=0，则为每一列)或列(如果 dim=1，则为每一行)取平均值
有人曾经说过，“当你知道如何打破一个东西，那么你就真正知道如何用好它。”现在，让我们试着打破这个函数，我的意思是让我们理解这个函数什么时候不能像预期的那样工作。
打破火炬
在单元格中，我们得到的运行时误差”只能计算浮点类型的平均值。却得到了布尔。”这意味着 torch.mean()只能应用于 floating 类型，其他所有情况下都会失败。
不知道这是 bug 还是特性。我会把它留给你去想象。
何时使用该功能？
当有人想要计算张量的平均值时，例如当我们想要使用均方根误差(RMSE)作为损失函数时，可以使用该函数。
torch.view(形状):
PyTorch 有趣的一点是，它允许一个张量成为一个现有张量的视图。视图张量与其基础张量共享相同的底层数据。视图避免了显式的数据复制，因此允许我们进行快速且节省内存的整形、切片和基于元素的操作。
该函数返回一个新的张量，其数据与自张量相同，但形状不同。
正如我们可以观察到的，我们得到了给定张量的一个不同大小的副本，我们可以对它进行运算。
这是使用 view 函数的另一个例子。这里的-1 是从其他维度推断出来的。
看看这个功能什么时候不行。
这里，我们得到一个错误，因为形状应该匹配输入张量的大小。
torch.view 的灵感来源于 numpy . ndarray . shape()或 numpy.reshape()。它创建了张量的新视图，只要新形状与原始张量的形状兼容。
torch.reshape()函数将返回一个视图，与使用 torch 完全相同。Tensor.view()只要新的形状与原始张量的形状兼容。否则，它将返回一个副本。
然而，torch.reshape()的注释警告说:
连续输入和具有兼容步幅的输入可以在不复制的情况下被重新整形，但是不应该依赖于复制和查看行为。
torch.linspace():
个人感觉这个功能以后会很好用。
该函数返回“开始”和“结束”参数之间等距点的一维张量向量。点数是“步数”参数。它的一些重要参数是:
start(float)-点集的起始值
结束(浮点)-点集的结束值
steps(int)-开始和结束之间的采样点数。默认值:100。
out(张量，可选)-输出张量。
dtype (torch.dtype，可选)-返回张量的所需数据类型。默认值:如果没有，则使用全局默认值(请参见 torch.set_default_tensor_type())。
requires_grad (bool，可选)—如果亲笔签名的应该记录对返回张量的操作。默认值:False。
在单元格中，开始=10，结束=4，步数=25。因此，我们得到 25 个等间距的点，在 10 和 4 之间(包括 10 和 4)。默认情况下， PyTorch 给我们的元素是浮点。
这类似于上面的例子，但是这里我们得到的是类型为 int32 的元素。
现在我们来试着破函数。
torch.linspace()的“out”参数，它指定要由 torch.linspace 函数返回的值替换的所需张量。运行时错误“dtype Int 不匹配 dtype of out 参数(Float)”告诉我们，要使用“out”参数，两种类型的张量应该相同。
何时使用该功能？
当我们知道真实数据位于特定区间时，可以使用 torch.linspace 创建张量形式的数据。
torch.trace():
该函数返回输入二维矩阵的主对角线(从左上到右下)的元素之和。它唯一需要的参数是一个输入 2D 张量。
正如我们所见，该函数接受输入的 2D 张量，并计算对角线上元素的总和。
正如我们所见，该函数接受输入的 2D 张量，并计算对角线上元素的总和。
这个函数只需要一个 2D 矩阵，给它任何东西都会破坏它。这里，我们给出了一个 1D 数组。
虽然现在还不可用，但是这个函数的一个简单的新特性是允许我们得到任意对角线元素的和。但那不会被称为矩阵的“迹”。
何时使用该功能？
单独来看，跟踪操作并不有趣，但是它提供了一种更简单的符号，并且它被用作其他关键矩阵操作中的一个元素。
结论:
这里，我们展示了一些与 PyTorch 张量的一些核心概念相关的基本函数，如:
- 如何生成元素在[0，1]范围内的随机张量？
- 如何计算张量及其不同变量的平均值？
- 如何为给定的张量创建不同的视图。
- 如何创建一个张量，其元素在点与点之间等距。
- 如何计算 2D 张量的轨迹？
我希望你喜欢这个博客。感谢您的阅读，我希望这对您有所帮助。
参考资料:
- 链接到我的笔记本:https://jovian.ml/shivasankeerth/01-tensor-operations
- 链接开始 py torch ZerotoGANs by freeCodeCamp:https://www . freeCodeCamp . org/news/free-deep-learning-with-py torch-live-course/
- Pytorch 文档
用 Spark 探索金融消费者投诉
PySpark 数据框架入门
在仔细阅读“美国政府公开数据的所在地”Data.gov 时，我偶然发现了美国联邦金融服务消费者投诉数据库。我想到了一些初步的问题，包括:这要追溯到多久以前？这是最新的吗？人们会提出多少投诉？哪些公司产生的投诉最多？
为了回答这些问题，我决定求助于 Spark。
当你有资格向消费者金融保护局投诉时，你可能需要的宁静形象。米尔科维在 Unsplash 上的照片
如何在你的电脑上设置 Spark
互联网上有很多博客/帖子/地方可以找到在你的电脑上安装 Spark 的方法(见莫塔达·梅希亚尔的帖子)。Spark 曾经以在你的电脑上启动和运行是一个挑战而闻名，但我在 1.6 GHz 英特尔酷睿 i5 和 8 GB 内存上使用运行 macOS Mojave 的 MacBook Air 时并没有太多的挣扎。对于不同的设置或以前版本的 Spark，这可能更具挑战性。
在这个阶段，你可能也需要一点额外的平静。照片由 A. Shuau (Obofili) 在 Unsplash 上拍摄
开始使用 Spark 之前需要了解的一些事情
- 关于为什么你可能想使用它的一点点(无耻地塞给我的文章，或者 HackerNoon 的， Toptal 的)
- 使用 Spark 时,“你可以编写代码来描述你希望如何处理数据，而不是你希望如何执行，然后 Spark 代表你‘做正确的事情’来尽可能高效地运行它”(3)
- Spark 使用“懒惰评估”，在你询问答案之前什么都不做。然后，它仍然只进行获得答案所需的计算，从而最小化工作量。你应该避免强迫它在不必要的中间步骤进行评估。
现在，我们已经准备好使用 SQL/pandas 风格的工作来研究一些真实的数据。今天，我们将调查金融服务消费者投诉数据库。我从 Data.gov这里下载的。坦白地说，我很难使用 Spark 的 CSV 加载器正确加载 CSV，所以我使用 pandas 将 CSV 转换为 parquet 文件。我很喜欢你有任何提示来解决我的问题，其中一些文本列被切成两半(可能在逗号？)，导致表的行数和列数大约是原来的两倍。
注意:您需要安装 pyarrow 或 fastparquet 才能运行。下面镶木地板。
import pandas as pdpd_df = pd.read_csv('../data/Consumer_Complaints.csv')
pd_df.columns = [col.lower().replace(' ', '_') for col in
pd_df.columns]
pd_df.to_parquet('../data/consumer_complaints.parquet')
在决定进行切换后，Spark 中 parquet 文件的加载速度比 CSV 文件快得多，这给我留下了深刻的印象。唯一的不便是，似乎 Spark 和/或 Parquet 文件不能很好地处理带空格的列名。在转换到拼花文件之前，我选择在 pandas 中删除它们。总的来说，还有另一个理由来为你的数据库/仓库/湖泊起一个合理的、没有空格的名字。
现在你知道该怎么做了:根据你所处的环境，你可能有很多机会利用照片来恢复宁静。梁朝伟在 Unsplash 上拍照
让火花在您的环境中运行
如果您使用的是基本的 Spark 特性和方法，那么您应该从初始化 SparkContext 开始，通过连接到特定的执行环境来设置 Spark 应用程序。如果我想在本地机器的所有内核上运行，我会使用:
import pysparksc = pyspark.SparkContext('local[*]')
您可以随时使用sc.stop()停止 SparkContext。
对于我们的 DataFrame 工作，我们将让 SparkSession 为我们初始化 SparkContext:
import pysparkspark = pyspark.sql.SparkSession \
.builder \
.master('local[*]') \
.appName('Python Spark Consumer Complaints example') \
.getOrCreate()
在这里，我们使用 SparkSession 构建器来“获取或创建”(如果尚不存在，则创建)一个 SparkSession，它具有指定的执行环境(我的本地计算机上的所有内核),并命名该应用程序以便在在线用户界面上进行识别。
作为检查，我运行了spark.sparkContext.defaultParallelism来确保 Spark 使用了预期数量的内核。
将数据导入数据框架
df = spark.read.load('../data/consumer_complaints.parquet',
inferSchema='true', header='true')
仅此而已。我做了一个快速的df.count()来确认这次 Spark 读取了正确的行数。
使用 PySpark 数据框架
现在我们有了数据框，让我们继续使用它来回答一些问题:
我们在看什么时间框架？
这里我们需要转换成日期时间类型。我“选择”(像 SQL 一样)接收的日期转换成日期格式的日期类型，并给它一个别名。然后我按日期排序，取 1。Take 产生的结果与 limit 相同，但我不确定 Spark 各版本的性能差异。Take(n)是一个基本的 spark 经典，返回前 n 个结果，而 limit()对于面向 SQL 的人来说更直观。
from pyspark.sql.functions import to_datefirst_date = df.select(to_date(df.date_received,
'MM/dd/yyyy').alias('date')) \
.orderBy('date').take(1)
first_date Out: [Row(date=datetime.date(2011, 12, 1))]last_date = df.select(to_date(df.date_received,
'MM/dd/yyyy').alias('date')) \
.orderBy('date', ascending=False).take(1)
last_date Out: [Row(date=datetime.date(2020, 1, 12))]
通过几行代码，我们看到数据集的时间跨度从 2011 年 12 月 1 日到 2020 年 1 月 12 日。
我们总共有多少投诉？每天？
对于投诉总数，快速df.count()返回约 150 万。
为了获得每天的投诉，我们将使用上面的 datetime 对象:
days = last_date[0]['date']-first_date[0]['date']
days Out: datetime.timedelta(days=2964)
每天平均投诉数量:
df.count()/days.days Out: 497.49257759784075
我通过将 PySpark 数据帧转换成熊猫数据帧并使用matplotlib来可视化每天的抱怨:
dates = df.select(to_date(df.date_received,
'MM/dd/yyyy').alias('date'))
complaints_per_day_pd =dates.groupBy('date').count() \
.sort('date').toPandas()
我注意到了这些峰值，并决定进行调查。你可以像在pandas中使用.loc一样使用 filter(有时与 where 和 when 结合使用)。
daily_complaint_counts = dates.groupBy('date').count()
daily_complaint_counts.filter(
daily_complaint_counts['count'] > 1500) \
.orderBy('date').show()
返回的格式为 SQL 样式:
+— — — — — + — — -+
| date|count|
+ — — — — — + — — -+
|2017–01–19| 2070|
|2017–01–20| 1633|
|2017–09–08| 3553|
|2017–09–09| 2709|
|2017–09–13| 1600|
+ — — — — — + — — -+
2017 年 9 月是 Equifax 安全漏洞。我不确定 2017 年 1 月发生了什么，除了特朗普总统 20 日的就职典礼。
哪些公司被投诉最多？
这里我想再次使用matplotlib可视化结果，所以我将结果转换成熊猫。
company_counts = df.groupBy('company').count()
company_counts_for_graph = company_counts.filter(
company_counts['count'] >1000) \
.sort('count', ascending=False).toPandas()
然后我使用matplotlib来可视化结果:
对于信用报告机构来说并不可爱…但是我们看到 Spark 的这个模块用相当 SQL-y 的代码很快就得到答案。如果您知道如何在 SQL 或 pandas 中实现，PySpark 的方式可能是相似的，或者至少在 PySpark 中可能有相似的方式。像往常一样，有许多方法可以得到相同的结果。
一些最后的问题
投诉是怎么接到的？主要是通过网络。
df.groupBy('submitted_via').count().sort('count',
ascending=False).show()Out:
+ — — — — — — -+ — — — -+
| submitted_via| count|
+ — — — — — — -+ — — — -+
| Web|1106079|
| Referral| 187007|
| Phone| 88292|
| Postal mail| 72485|
| Fax| 20297|
| Email| 408|
+ — — — — — — -+ — — — -+
回应是否及时？通常情况下。
df.groupBy('timely_response?').count().sort('count',
ascending=False).show()Out:
+ — — — — — — — — + — — — -+
| timely_response?| count|
+ — — — — — — — — + — — — -+
| Yes|1439485|
| No| 35083|
+ — — — — — — — — + — — — -+
他们有争议吗？有时候。这取决于 null 在这一列中的含义。
df.groupBy('timely_response?').count().sort('count',
ascending=False).show()Out:
+ — — — — — — — — — + — — — +
|consumer_disputed?| count|
+ — — — — — — — — — + — — — +
| null|706088|
| No|620102|
| Yes|148378|
+ — — — — — — — — — + — — — +
这篇文章的最后一个提示:你可以用*SparkSession*.stop()关闭你的 SparkSession。
我希望这有助于您开始使用 Spark 查看数据！你可以在这里找到回购。
了解 Spark 工作原理的其他资源
- https://mapr . com/blog/datasets-data frames-and-spark-SQL-for-processing-of-tabular-data/
- https://mapr.com/blog/how-spark-runs-your-applications/
- https://mapr.com/blog/5 分钟-指南-理解-意义-apache-spark/
- https://realpython.com/pyspark-intro/
使用 Covid19、Foursquare 和 Zomato APIs 探索印度德里的食品商店
IBM 数据科学顶点项目
作为 Coursera 上应用数据科学顶点项目的一部分，我必须使用 FourSquare API 来获取位置数据，并使用任何其他必要的数据来创建一个有洞察力的数据科学项目。在这篇文章中，我将讨论我用来探索和识别印度德里的食品商店的方法。
介绍
世界正面临来自新冠肺炎疫情的前所未有的威胁。毫无疑问，这个疫情影响了我们的生活方式，但也彻底改变了消费者的行为。
我们看到网上订购食品、衣服、日常家居用品、杂货等的数量激增。最近这段时间。
消费者行为的这种变化也意味着，现在消费者不仅会关注那些以合理价格提供优质食品的食品商店，还会关注食品商店的卫生等级和所在区域，以确保安全和卫生不会受到影响。
此外，保持消费者对食品安全性和可用性的信任和信心也变得至关重要。
在这篇文章中，我将帮助消费者找到那些不仅价格合理，而且安全的食物店。
目标
这个项目的目的是根据以下几点对印度德里的食品商店进行分类:
- 平均值。价格
- 评级
- 位置
- 该区的冠状病毒病例
- 在线交付服务
数据
我将合并来自 3 个 API 的数据:
- Covid19 API —获取德里不同地区所有确诊的冠状病毒病例
- FourSquare API—使用我们从 Covid19 API 收到的地区的位置坐标，并将其作为输入传递给 four square API，以检索德里每个地区 4 公里半径内的 100 个地点。
- Zomato API —我将把从 FourSquare API 检索到的地点和位置坐标作为输入传递给 Zomato API，以获得关于餐馆的信息，如评级、平均价格。价格，评论数，是否有线上发货等。
我还将使用网络抓取来提取餐厅的卫生评级。
在合并了上述数据源之后，我绘制了从 FourSquare API 接收的数据和从 Zomato API 接收的数据，以帮助我们更好地将其可视化。
在德里地图上绘制正方形数据:
四方数据
在德里地图上绘制 Zomato 数据:
佐马托数据
从视觉上看，大多数位置似乎是匹配的，但是我们必须小心组合来自不同数据集的数据。
为了合并这两个数据集，我将检查来自 Zomato API 和 FourSquare API 的每个相应地点的纬度和经度值是否匹配，因为我们使用了该地点的坐标作为 Zomato API 的输入，以获得有关该地点的更多信息。因此，我将纬度和经度值四舍五入到小数点后 4 位。然后，我将计算相应的纬度和经度值之间的差异，并查看差异是否小于 0.0005，这在理想情况下意味着两个位置是相同的。这是我对这个项目的一个假设。
此外，一些场馆的名称根本不匹配。例如，从 Foursquare API 检索到的地点名称是 KFC，但是当我们将它传递给 Zomato API 时，它返回了“Al Kuresh ”,这显然是错误的。我们需要把这些从桌子上拿走。
清理完数据后，我们只剩下 67 行，现在可以开始处理数据了。
方法学
我们将执行 EDA 和聚类的食品出口的基础上评级，平均。价格、位置、卫生等级和冠状病毒病例数。
第 1 部分:探索性数据分析
等级
餐厅评分分布
从上面的剧情可以看出，大部分餐厅的评分都是 3.8 和 4。
价格
价格分布
接下来，让我们探索一下德里餐馆的平均价格，这对初来德里并想了解餐馆平均价格的人来说很有用。原来德里的大部分餐厅均价 300 卢比。
卫生等级
卫生等级分布
让我们了解一下餐馆的卫生等级。考虑到冠状病毒的爆发意味着餐馆必须遵守严格的卫生政策，这是一个重要因素。有趣的是，德里所有的餐馆卫生等级都是 0，这意味着这些餐馆的卫生习惯没有得到评定。Zomato 应努力确保所有餐厅都有卫生评级，尤其是有了疫情之后。
网上发货
在线交付的分布
从上面的图中，我们可以看到在线交付功能几乎是平均分布的。其中一半没有网上送货，另一半有。在这个疫情期间，如果餐馆在加强必要的卫生政策的同时，强调网上送货，利润会高得多。
价格区间
价格范围的分布
Zomato 还提供了每家餐厅“价格区间”的详细信息。此功能的范围从 1 到 4，其中 1 表示方便，4 表示昂贵的餐馆。大多数餐厅更倾向于方便消费者，这对消费者来说是一个加分点。
地区与价格
地区与价格
高端餐厅位于新德里和南德里区。我们在德里东南部和德里中部也有一些价格较高的餐厅，尽管这些地区的平均价格较低，这使得这些餐厅成为异类。
地区 vs 评级
地区与评级
德里东南部和新德里是餐馆平均得分较高的地区。而南德里的餐馆平均得分最低。评级。
评级 vs 价格
评级与价格
评分 2.6 的餐厅，均价 2500 真的很高！这些餐馆需要重新考虑他们的价格范围，因为他们的评级不是很好。经过进一步分析，发现位于新德里和德里东南部的“电气室”是 2.6 级和 2500 卢比的插座，他们可能应该重新考虑他们的价格点。
另一个有趣的观察是，评分为 4.8 的餐馆比评分为 4.5 的餐馆有更低的价格点。
地区 vs 美食
地区 vs 美食
让我们试着去了解德里每个地区的大多数餐馆都提供什么样的菜肴。
从上面的地图，我们可以看到:
- 在德里东北部，大多数餐馆提供“北印度、快餐、穆格莱”菜肴。
- 在德里市中心，大多数餐馆都提供“咖啡馆和甜点”美食。
- 在东德里，大多数餐馆提供“南印度、北印度和中国”菜肴。
- 在新德里，大多数餐馆供应“欧洲和大陆”菜肴。
- 在德里东南部，大多数餐馆都供应“北印度，穆格莱”菜肴。
- 在南德里，大多数餐馆都供应“意大利沙拉”菜肴。
- 在西南德里，大多数餐馆都供应“街头食品，米泰”美食。
- 在西德里，大多数餐馆提供“咖啡馆、快餐、甜点、饮料、三明治”美食。
第 2 部分:集群
我们将首先使用“肘方法”来确定集群的最佳数量。
肘法
对于每个 k 值，我们将初始化 k 均值，并使用惯性属性来确定样本到最近的聚类中心的平方距离之和。
使用最优‘k’进行聚类
最佳的“K”值是 3，我们将使用它进行 K 均值聚类。
kmeans=KMeans(n_clusters=3).fit(df_clustering)
kmeans.predict(df_clustering)
final_venues.insert(0,'cluster_label',kmeans.labels_)
final_venues.head()
在德里地图上绘制聚类
集群 0 中的场馆有:
- 均价 631.82 卢比
- 平均值。评分 4.34
- 平均值。冠状病毒病例 98.91
- 平均值。复习计数 1736.36
- 网上交货的差价为 0.36
第一组的场馆有:
- 平均价格 400.53 卢比
- 平均值。评分 3.50
- 平均值。冠状病毒个案 119.23
- 平均值。审查总数为 292.68
- 网上交货的差价为 0.60
第 2 组的场馆有:
- 均价 2238.89 卢比
- 平均值。评分 3.91
- 平均值。冠状病毒病例 82.00
- 平均值。审核计数为 560.44
- 网上交货差价为 0.00
结果和讨论
从我们的分析中，我们注意到大多数餐厅的平均评分为 3.8 。我们还注意到平均。大多数餐馆的价格是 250-300 卢比，并不贵。
Zomato 的“价格区间”功能也能给我们提供有价值的见解。这个特征的范围从 1 到 4(1 是口袋友好到 4 是昂贵)，结果大多数餐馆更倾向于口袋友好。
关于餐馆的“卫生等级”有一个有趣而又令人担忧的观察。所有餐馆的卫生等级都是 0，这意味着这些餐馆没有被评为卫生等级。 Zomato 应努力确保所有餐厅都有卫生评级，尤其是有了这个疫情，因为它将帮助消费者确保他们的安全和卫生不受损害。
另一个有趣的观察结果是，在线交付功能在餐厅中几乎平均分布，即一半的餐厅没有在线交付，而另一半有。在这次疫情期间，更多地强调网上送货对餐馆来说是有益的。
在根据餐馆的评级分析价格时，我们注意到评级为 3.5 的餐馆的平均得分为 3.5。价格为 1500 卢比的餐馆和评分为 4.9 的餐馆的平均得分为 1。价格 2500 卢比。
不过评分 2.6 的餐厅也有均价 2500 挺高的！经过进一步分析，发现这是由于“Lodhi 酒店电气室”的 2 个插座造成的这些分店分别位于新德里和德里东南部。鉴于他们的评级如此之低，他们可能应该重新考虑他们的价格点。
我们还分析了德里每个区的大多数餐馆提供的美食，这将有助于消费者确定当他们渴望某种特定的美食时应该去哪个区。
现在来看餐馆的聚类，我们能够从我们的数据集中导出 3 个聚类。
位于第一个集群(即集群 0 的餐厅价格合理，评级最高，评论数最高，冠状病毒病例较少，因此理想情况下，人们可以在采取适当安全预防措施的情况下访问这些食品商店。有趣的是，第 0 组的大多数商店都位于德里市中心或新德里区。
集群 1 中的商店价格最低，评级体面，评论数最低，大多数餐馆提供在线送货，但与其他集群相比，该集群的冠状病毒病例数也最高。在准备和运送食物时，这个集群中的食物出口必须格外小心。如果你确实从这里订餐，我建议你采取额外的预防措施，非常小心。
最后，位于最后一个集群，即集群 2 的门店具有最高的价格点、良好的评级和评论数，没有在线交付，但冠状病毒病例最少。如果你是一个不介意花钱购买质量不错的食物，同时又注重安全的人，你可以试试这些餐馆。
结论
这个项目的目的是探索德里不同的食品商店，牢记卫生和冠状病毒病例。这个项目的局限性之一是我只能从 Zomato API 中检索大约 170 家餐馆的数据。另一个主要限制是，我已经将该区冠状病毒病例的数量分配给该区目前的每个食品商店。然而，德里的每个区都很大，需要细分到社区才能获得更准确的表示，但德里没有社区级别的冠状病毒病例。
在合并了来自不同 API 的数据之后，我执行了 EDA 来揭示一些有趣的观察结果，并且还基于 rating，avg 对数据集执行了 K 均值聚类。价格、位置、店铺所在地区的冠状病毒病例、是否提供在线配送以及该食品店铺的总评论。
聚类分析显示，新德里的大多数餐馆和德里中部的一些餐馆可以安全点餐，而且提供最优质的食物，而德里东南部的餐馆也可以安全点餐，但价格更高。根据游客对等级、价格和其他要求的选择，他/她可以在这三个集群中的不同食品商店中进行选择。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
