TowardsDataScience 博客中文翻译 2016~2018（六）
数据可视化可能存在的 5 种方式
在一个越来越受数据驱动的世界里，从新闻提要到活动跟踪，图表开始随处可见。有些很漂亮(纽约时报可视化实验室做了惊人的工作)，但更多的时候质量会有所欠缺，结果会令人困惑甚至误导。
我们使用可视化来压缩数据，以创建对趋势的直观理解。我们将讨论在展示数据时可能犯的一些基本错误，但首先快速浏览一下图表的结构:
可视化的元素可以通过强调或减少数据影响的方式进行修改。网格线或刻度数量的变化可以强调粒度，标签可以精心制作以产生偏见，或者颜色选择可以唤起潜意识的情绪反应。我将探索修改可视化的方法，包括:
- 轴向裁剪
- 轴缩放
- 扔掉
- 饼图
- 2 轴图
对于其中的每一个都有特定的情况，这些技术也可以用来帮助可视化制作一个更清晰的故事，所以像数据科学中的大多数东西一样，它们是可以使用或滥用的工具。
轴向裁剪
X 和 Y 轴是理解图的比例和关系的关键。可以为 X 或 Y 维度(或两者)裁剪一个轴，以显示数据的子集。取决于什么样的节目和情节类型，这可能是偶然发生的，也可能是故意的。我想我们所有人都可以在这些数据中找到一些图表，让他们的观点看起来更有道理。
这是相同数据的三个直方图。通过限制轴，它不仅减少了多少是可见的比例也发生了变化。在中间的例子中，y 轴的裁剪使得增加看起来比未编辑时更陡。
有时，有一个很好的理由进行裁剪。如果可视化的想法是讲述一个故事，这可能是一个无价的工具来强调一个变化。这是一篇很棒的文章，当它真正有帮助的时候:
在 Quartz，我们一年制作数千张图表，当我们收到关于它们的投诉时，通常是 y 轴…
qz.com](qz.com/418083/its-…)
然而，我已经看到了许多这样的例子，它被用来通过过度夸大关系规模来混淆人们，使差异看起来比实际情况更大(当轴上的数字被完全省略时，情况会变得更糟)。这是一篇关于图表如何被大量编辑以使某些东西看起来与实际结果不同的惊人帖子:
这张美国广播公司的新闻图表似乎占据了我的 Twitter feed 的顶部，所以我最好对它进行评论。ABC 新闻的某人…
junkcharts.typepad.com](junkcharts.typepad.com/junk_charts…)
裁剪图表的轴可以隐藏各种问题。当我在 Kaggle 泰坦尼克号比赛上尝试我的第一个机器学习问题时，在提供的数据集中有多个年龄缺失。下面的直方图显示了年龄的分布(对于那些有过的人)。
我通读了其他内核，并从他们解决问题的方法中获得了灵感。一份提交的材料特别使用了老鼠(R 中的一个包)来填写年龄。我复制了他们所做的，并运行它来理解它是如何工作的。在我 16 岁左右的时候，每次都有一个巨大的峰值，但是他们笔记本上的图像没有显示任何峰值。左边是我做的时候发现的，右边是我在他们笔记本上看到的:
过了几个小时，我才意识到他们的直方图被设置为隐藏任何 16 岁以下的年龄，从而掩盖了数据中的峰值。我用了另一种方法来填写年龄，但这对我来说是一个教育时刻。
轴缩放
比较图表时，了解它们是否设置为相同的比例非常重要。根据所使用的可视化程序，轴通常会自动调整到最佳状态。如果有多个图表的数据不完全相同，那么一个图表中的一英寸可能等于 10，而另一个图表中的一英寸可能等于 30。
当我为一个客户处理数据集时，我曾经艰难地了解到这一点。得出几个结论后，我正准备完成演示，这时我意识到我比较的两个图表是完全不同的尺度。我及时发现了这一点，但是我在报告中的结论被修改得更加谨慎了。
我也一直在研究佛蒙特州伯灵顿的警察违规公开数据(见我的帖子这里)并遇到了同样的问题。伯灵顿有两条不同的街道，每条街道都有违章记录。
上面看起来教堂街比主街的非法侵入量大四倍，但是下面当我们把它们按同样的比例缩放时，很明显非法侵入的数量更接近相同。更清楚的是，由于那里的交通事故，Main Street 总共有更多的违规行为，这是最初的图表一眼不会告诉你的。
与第一个问题不同，这通常是一个错误。可视化的默认行为通常会自动引入问题。只需记住在比较图表时进行比较的重要性，并注意观察坐标轴。
扔掉
直方图是理解数据分布的非常有用的方法。在某些方面，它通过计算一定范围内的数据点数量来换取绝对的准确性。这被称为宁滨，bin 值 10 将从零到最大值拆分成 10 个桶。
有几个公式可用于确定容器大小；斯特奇斯公式、赖斯法则和弗里德曼-迪阿科尼斯选择都是很好的起点。但是，让我们首先考虑不同的宁滨可以是什么样的直方图序列:
在上面的例子中，不难看出通过改变容器，洞察力会如何改变。通过仔细的宁滨，一些不规则性可以被掩盖，或者在特定值的异常值可以被平滑。
此外，还必须考虑 y 轴比例随频段的变化。如果将 500 个总值分成 5 个箱，而不是 100 个箱，那么会产生很大程度的缩放。如果相互比较直方图，请记住确保柱是相同的，轴也是相同的。
饼图
饼图通常是展示复杂信息的糟糕方式。当切片数量超过三个左右时，我们的大脑不太擅长比较切片。更糟糕的是，许多标签看起来很酷，但实际上很难辨认。
看一看左边没有标签的模拟饼图，试着猜测各种比例关系，然后在右边添加标签的位置。
绿色切片实际上等于黄色切片的四分之一，粉红色是紫色切片值的三分之一。当它以饼状图的形式出现时，我们的品牌很难进行换位和比较。
对饼状图的厌恶被广泛分享，许多关于这个主题的文章被写成了。甚至切片的顺序也能玩出心理把戏。下面的缅因州和佛蒙特州实际上是相同的价值，但很难猜测。
这是另一个例子，五个相当接近的切片，其中一个比其他的多 3%。猜猜是哪一个。
如果你选择新罕布什尔州，那你就错了，它实际上是马里兰州。3D 效果在视觉上增加了切片的体积，欺骗了你的眼睛。如果没有标签标明百分比，准确猜测的可能性微乎其微。
2 轴图
图表实际上可以有左右两个独立的垂直轴。有时这种图表可以用来显示两个图之间的相关性，但这种关系可能是微妙的，如果不是不存在的话。
通过使用上面提到的轴裁剪和轴缩放，小斜面可以变成悬崖，不一致的数据可以被截断，以得出错误的相关性和比较。下面是一个虚构的例子:
不难想象，当差异超过 250 时，有人可能不会注意到两个独立的尺度，并相信新罕布什尔州的计数 1 和计数 2 是相同的。当一个是百分比，另一个是类似货币的东西时，这种不明确性会进一步加剧。这里有一个特别好的例子,说明糟糕的图表是如何被用来证明一个不准确的观点的。
在绘制两组数据之间的精确相关性时，使用两个轴可能会很有用，但当有人这样做时，请确保查看轴的比例，并了解可能已进行的任何其他修改。
结论
我们使用可视化来探索数据，理解错误是如何产生的，不管是有意还是无意，这将使我们更好地得出准确的结论。最好彻底地怀疑，在把可视化视为理所当然之前，看看所有的部分。
虽然这侧重于视觉技巧，但也有统计操纵的一面。这包括破解数据集、忽略相关的异常值，以及许多其他技术，这些技术甚至可以在它成为图表之前很久就被应用。
在一个“假新闻”被如此频繁地抛出的时代，很难写这篇文章而不关注政治和媒体。双方都操纵和歪曲了可视化，以支持数据无法支持的结论。
就像我们必须学会如何应对 90 年代的第一次互联网诈骗(那个可怜的尼日利亚王子……)，我们现在也必须发展理解数据背后的同样的复杂性。随着数据越来越深入到几乎所有事物的核心，不理解它将会给你带来危险。知道如何持怀疑态度会让一切变得不同。
大自然母亲激发人工智能的 5 种方式
人工智能的世界有很多事情要感谢它在我们今天的技术景观中的存在。人类不仅花费了数十年的研究来完善数学计算，使这些非常复杂的学习算法发挥作用，而且在这段时间里，我们比我们自己的物种看得更远，作为在我们的星球上创造下一代智能存在的灵感。大自然母亲，以及它所包含的一切，已经深深扎根于人工智能的工作中——并且会一直存在下去。
大卫·爱登堡爵士的野生动物纪录片难道不令人难以置信吗？它们对地球上众多居民的行为和属性进行了令人难以置信的高清晰度描述，并让我们了解他们如何融入自然生态系统，并共同努力，以使我们的星球繁荣昌盛——让它成为地球。虽然我不是大卫·爱登堡爵士，但我还是要带你们去看一部我自己的野生动物纪录片。问题中的明星生物不是别人，正是那些直接受大自然启发的人工智能算法。但首先，我需要向你们介绍两个算法概念。搜索/寻路和预测建模。
搜索(寻路)算法
搜索算法本质上是一种程序，旨在找到到达目标的最佳/最短路线。例如，旅行推销员问题是一个典型的搜索优化问题，给你一个城市列表和这些城市之间的距离。你必须为旅行推销员寻找最短的路线，同时访问每个城市一次，以最大限度地减少旅行时间和费用(确保你回到出发城市)。这个问题的实际应用是送货卡车。想象一下，伦敦有 100 个人在网上订购，所有的箱子都被装进一辆货车。快递员(比如说……DPD)现在必须计算从仓库交付这些包裹(最终返回仓库)的最有效路线(平衡距离/所用时间),以确保公司在交付过程中尽可能少地浪费时间和金钱。
预测建模算法
今天，预测模型是所有炒作的地方。各地的数据科学家都在高呼“神经网络！”在他们舒适的办公大楼的屋顶上，像谷歌这样的公司正试图用这些复杂的小“人工大脑”的不同变体来解决世界问题。本质上，预测模型使用统计学来预测结果。你经常听到数据科学家试图解决两种预测建模问题，回归和分类。回归是寻找两组变量之间相关性的黑暗艺术，而分类是确定数据集属于不同集合的概率的过程。
5 种受生物启发的学习算法
1.人工神经网络
Feed Forward Neural Network — the most basic type of Neural Network.
算法类型:预测建模
生物灵感:认知脑功能(神经元)
用例:情感分析、图像识别/检测、语言校正、机器人
让我们从其中最常见的人工智能(AI)算法开始。神经网络是被称为机器学习的人工智能子类的一部分。它们被设计和建造为在神经元水平上模仿大脑功能，与轴突和树突相互作用，以便通过系统传递信息，从而通过一系列“层”产生预测输出。每一层都提供了额外的数据表示层，并允许您对最复杂的问题进行建模。
神经网络可能是使用最广泛的机器学习算法，也是迄今为止数据科学和机器学习的最热门趋势。这个概念最初在 1958 年取得成果，被称为感知机，后来由 Geoffrey Hinton 完善，并由谷歌和脸书等公司推广。神经网络可用于解决广泛的问题类型，包括自然语言处理和视觉识别。这种监督学习算法可以支持回归和分类问题，其使用示例可以在常规消费产品中找到，包括智能手机和联网的家庭设备。
2.遗传算法
Reproduction of individuals in a Genetic Algorithm
算法类型:搜索/寻路
生物灵感:适者生存/进化(细胞繁殖)
用例:数据挖掘/分析、机器人、制造/设计、流程优化
为了解决搜索问题，遗传算法在连续几代的一系列个体中采取“适者生存”的类似进化的方法。每一代都包含一群模仿我们在 DNA 中看到的染色体的字符串。群体中的每个个体代表搜索空间中的一个点，因此每个个体都是可能的候选解。为了改进解的群体，我们让个体经历一个进化过程。
- 种群中的每个个体都会为资源和配偶而竞争。
- 在每次竞争中最成功的个体(通常)会比那些表现不佳的个体产生更多的个体。
- 来自更“理想”候选人的基因在群体中传播，所以那些好父母通常会产生具有更大潜力的后代。
3.群体/集体智慧
Example of Ant Colony Optimisation — a type of collective intelligence algorithm.
算法类型:搜索/寻路
生物灵感:蚁群/鱼群/鸟群
使用案例:机器人，视频游戏人工智能，制造业，路线规划
蚁群优化和粒子群优化是两种最常见的算法，符合“集体智能”概念的界限。在一个基本层面上，正在讨论的算法都利用了多个工作代理。每一个工作主体都表现出非常基本的行为，这些行为集体(作为一个群体)一起工作，产生更复杂的、紧急的行为，以解决问题。
蚁群优化(ACO)与粒子群优化(PSO)非常不同。两者都旨在实现突现行为，但以两种不同的方式进行。像真正的蚁群一样，蚁群算法利用信息素的气味来引导个体智能体走上最短路径。最初，在问题空间中初始化随机信息素。个体代理将开始遍历搜索空间，并在途中散发信息素气味。在每个时间步中，信息素将以一个确定的速率衰减。单个智能体根据他们前面的信息素气味的强度做出决策，以便遍历搜索空间。特定方向上的气味越强烈，就越有可能向那个方向传播。最著名的解决方案将会是具有最强信息素气味的解决方案。
粒子群优化算法更关注群体的整体方向。许多单个代理被初始化，并且它们以随机的方向开始。在每个时间步，每个代理都需要决定是否改变方向。该决定将基于最佳已知解决方案的方向(称为 pbest/全局最佳)、最佳最近邻的方向(局部最佳)以及当前行进方向。新的旅行方向通常是所有这些价值观的良好“妥协”。
4.强化学习
Agent Behaviour within a Reinforcement Learning Environment.
算法类型:预测建模
生物灵感:经典条件反射
用例:视频游戏、控制自动驾驶汽车、生产线软件、金融系统
强化学习(RL)以心理学为基础，其过程让人想起经典的条件作用，支持对主体采取的有利行动提供积极的数字响应的想法。与流行的经典条件作用例子相比，学习强化学习的概念通常更容易；巴甫洛夫的狗。这是 19 世纪 90 年代进行的一项研究，当时俄罗斯心理学家伊凡·巴甫洛夫正在观察狗对喂食的反应。一篇解释这个问题的优秀文章可以在这里找到。本质上，如果一个 RL 代理采取了一个好的行动，朝着完成要求的任务迈出了一步，它会被给予一个数字奖励。代理将使用策略进行学习，例如:最大化每一步的回报。将原始输入应用到算法中允许代理开发它自己对问题的感觉，以及如何以最有效的方式解决它。
RL 算法与其他机器学习技术(如神经网络)配对是很常见的。这通常被称为深度强化学习。当一个 RL 代理做出一个特定的决定时，神经网络经常被用来估计给予它的奖励。现在是谷歌公司的 Deep Mind 已经在这个领域取得了很大的进展，它使用深度 Q 学习方法来处理更常见的问题(例如一个算法能够在没有帮助的情况下玩完整个雅达利游戏库，并在“围棋”游戏中击败世界冠军本身)。他们现在正在采用这种方法，以便能够处理更复杂的游戏，如星际争霸 2。
作为参考，Q 学习是强化学习算法的无模型版本。它可以用来寻找任何有限马尔可夫决策过程的最优行动选择策略。在程序初始化时，每个动作-值对的 Q 值由开发者定义，并由 RL 算法在每个时间步更新。下图是更新 Q 操作-值对的公式示例。
Q Learning Value Update Equation
5.人工免疫系统
Components of an Artificial Immune System
算法类型:预测建模
生物灵感:免疫系统
用例:安全软件、自主导航系统、调度系统、故障检测软件
免疫系统是一种通过产生免疫反应来保护身体免受物质和病原微生物侵害的系统。人工免疫系统(AIS)是自适应系统，受理论免疫学和应用于解决问题的观察免疫功能的启发。人工智能是生物启发计算和自然计算的一个子领域，与机器学习和人工智能有联系。人工智能通常有多种算法:
- 克隆选择
- 树突细胞
- 否定选择
- 人工免疫识别
像生物免疫系统一样，人工免疫系统能够将系统内的所有“细胞”分类为“自体”或“非自体”细胞。分布式智能任务组用于对所有细胞采取行动。参与免疫的两种最重要的细胞是 B 细胞和 T 细胞(对你我来说是白细胞)。t 细胞有三种类型:一种类型激活 B 细胞，一种类型结合并摧毁外来入侵者，最后一种类型抑制自身免疫问题。b 细胞负责产生抗体，抗体是一种与抗原(一种有毒/外来物质)结合的特定蛋白质。人工免疫系统通常用于通过监控入侵检测来防御网络攻击，并且通常被集成到企业级软件中。与本文中提到的其他算法不同，关于这个主题的免费在线学习材料非常有限，并且可能是最不发达的。
让我们总结一下…
所以我举了 5 个例子来说明大自然是如何激励我们的研究和提高我们的技术的。还有许多受生物启发的算法影响着我们的人工智能系统，所以请在评论区分享你的经验和我错过的知识。
我是一名健身运动员&软件工程师，对健美和机器学习充满热情。我经营着自己的博客和网站，在那里我讨论这些话题，甚至更多。我提供了我的 Github 资源库的链接，这样你就可以看到我正在进行的项目和社交媒体账户(脸书、Instagram、Twitter 等)。)所以你可以跟着我健身改造。
lukealexanderjames.com/
如果你喜欢你所读的，请考虑按住鼓掌按钮一会儿！
50 tensor flow . js API 5 分钟讲解| TensorFlow.js Cheetsheet
TensorFlow API Cheetsheet
在这篇文章中，我真的想看看张量流**。js**API，从整体上理解这个库，并理解它为机器学习社区提供了哪些令人惊叹的东西。
我知道这篇文章应该有 5 分钟长，但不要担心，理解这些显而易见的 API 不会超过 5 分钟，即使它们中的许多从名字上看非常明显，对我来说保持初学者友好是很重要的。
我在文章的其余部分尽可能用例子来说明问题。但是如果你们有任何疑问，让我们在评论中讨论吧。
它将帮助你为任何新的未来项目编写更好的通用机器学习代码。
创造🚀
API 有助于创建张量、克隆体等东西。
1 - tf.tensor ( 数值， 形状？ ， dtype？ )
创建具有指定数据类型形状的张量。
*// Pass an array of values to create a vector.*
tf.tensor([1, 2, 3, 4]).print();**------RESULT------**
**Tensor [1, 2, 3, 4]***// Pass a flat array and specify a shape yourself.*
tf.tensor([1, 2, 3, 4], [2, 2]).print();**------RESULT------**
**Tensor [[1, 2],
[3, 4]]**
Returns → tf。张量
注:他们也有形状指定的 API，比如 *tf.tensor1d，tf.tensor2d，*TF . tensor 3d 和 tf.tensor4d 。
2--TF . buffer(shape，dtype？，价值观？)
创建一个缓冲张量。
*// Create a buffer and set values at particular indices.*
**const** buffer = tf.buffer([2, 2]);
buffer.set(3, 0, 0);
buffer.set(5, 1, 0); *// Convert the buffer back to a tensor.* buffer.toTensor().print();**-------RESULT------**
**Tensor [[3, 0],
[5, 0]]**
返回→ tf。张量缓冲器
3-TF . from pixels**(**num channels？ )
从图像中创建一个张量。
***const** image = new ImageData(1, 1);
image.data[0] = 100;
image.data[1] = 150;
image.data[2] = 200;
image.data[3] = 255;
tf.fromPixels(image).print();**------RESULT------**
**Tensor [ [[100, 150, 200],]]***
返回→ tf。Tensor3D
4--TF . linspace(start，stop，num )
创建一个具有均匀间隔数字的张量。
*tf.linspace(0, 9, 10).print();**------RESULT------**
**Tensor [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]***
返回→ tf。张量 1D
5-TF . onehot(indexes，depth， onValue？ ， offValue？ )
将一组稀疏的标签转换成密集的独热表示。
*tf.oneHot**(**tf.tensor1d([0, 1], 'int32'), 3**)**.print();**------RESULT------
Tensor [[1, 0, 0],
[0, 1, 0]]***
返回→ tf。张量 2D
*6-TF . print**(*啰嗦？ )
打印信息。关于任何张量。
****const** verbose = true;
tf.tensor2d([1, 2, 3, 4], [2, 2]).print(verbose);**------RESULT------
Tensor dtype: float32
rank: 2
shape: [2,2]
values: [[1, 2],
[3, 4]]****
退货→ 作废
7-TF . variable(initial value，** 可训练？，名字？，dtype？ )**
用提供的初始值创建一个张量变量。
****const** x = tf.variable(tf.tensor([1, 2, 3]));
x.assign(tf.tensor([4, 5, 6]));
x.print();**------RESULT------** **Tensor [4, 5, 6]****
Returns → tf。变量
tf 的方法。张量
8 - 展平 ()
将张量展平为 1D 数组
返回→ tf。张量 1D
转换一个 size-1 的 tf。张量到一个 tf.Scalar.
返回→ tf。标量
10.1-as1D()
转换一个 tf。张量到一个 tf.Tensor1D.
返回→ tf。张量 1D
10.2-as2D(行、列)
转换一个 tf。张量到一个 tf.Tensor2D.
返回→ tf。张量 2D
10.3-as3D(行、列、深度)
转换一个 tf。张量到一个 tf.Tensor3D.
Returns→ tf。张量 3D
10.4 - as4D ( 行，列，深度，depth2 )
转换一个 tf。张量到一个 tf.Tensor4D.
Returns→ tf。张量 4D
11-as type【dtype】
施放一个 tf。指定数据类型的张量。
返回→ 本
12 - 缓冲 ( )
返回一个 tf。保存底层数据的 TensorBuffer。
返回→ tf。张量缓冲器
13 - 数据 ()
tf.data API 有助于构建灵活高效的输入管道。
退货→ 承诺
14 - 处分 ( )
处置 tf。来自记忆的张量。
退货→ 作废
15.1 - 浮动 ( )
将数组转换为 float32 类型。
返回→ 这个
15.2-toInt()
将数组转换为 int32 类型。
返回→ 这个
15.3 - 托布尔 ( )
将数组转换为 bool 类型。
返回→ 这个
将张量整形为所提供的张量的形状。
返回→ tf。张量
17 - toString (啰嗦？)
返回张量的可读描述。对日志记录有用。
返回→ 字符串
tf 的方法。变量扩展到 tf。张量
18 - 赋值 (新值)
分配一个新的任务组。这个变量的张量。
退货→ 作废
TF 的方法。张量缓冲
tf。TensorBuffer 允许在声明一个 tf 之前设置一个值。不可改变的张量。
19-设置 ( value，locs )
在缓冲区的给定位置设置一个值。
退货→ 作废
20 - 获取 ( locs )
返回缓冲区中指定位置的值。
退货单→ 编号
创建一个不可变的 tf。缓冲区中的张量对象。
返回→ tf。张量
变形
22-TF . expanddims(x，轴？)****
返回一个 tf。通过在张量的形状中插入一个维度来扩展秩的张量。
********const** x = tf.tensor1d([1, 2, 3, 4]);
**const** axis = 1;
x.expandDims(axis).print();**------RESULT------
Tensor [[1], [2], [3], [4]]********
返回→ tf。张量
23-TF . cast(x，dtype )****
施放一个 tf。张量到一种新的数据类型。
********const** x = tf.tensor1d([1.5, 2.5, 3]);
tf.cast(x, 'int32').print();**------RESULT------
Tensor [1, 2, 3]********
返回→ tf。张量
24-TF . pad(x，paddings，constantValue？)****
垫一个 tf。具有给定值和填充的张量。
******const x = tf.tensor1d([1, 2, 3, 4]);
x.pad([[1, 2]]).print();**------RESULT------
Tensor [0, 1, 2, 3, 4, 0, 0]********
返回→ tf。张量
25-TF . shape(x，shape)****
重塑一个 tf。给定形状的张量。
********const** x = tf.tensor1d([1, 2, 3, 4]);
x.reshape([2, 2]).print();**------RESULT------
Tensor [[1, 2],
[3, 4]]********
Returns→ tf。张量
26 - tf.squeeze ( x，轴？)
从 tf 的形状中删除尺寸为 1 的尺寸。张量
******const x = tf.tensor([1, 2, 3, 4], [1, 1, 4]);
x.squeeze().print();**------RESULT------
Tensor [1, 2, 3, 4]********
Returns→ tf。张量
模型
模型是层的集合，有关层如何连接的详细信息，请参见模型创建。
模型是由层组成的数据结构，其节点被定义为输入和输出。
用 tf.model 制作的模型比 tf.sequential 模型更普通。
下面的代码片段定义了一个由两个密集层(全连接)组成的模型， 10 和 4 个单元。
*******//Define input, which has a size of 5(not including batch dimension)*
**const input = tf.input({shape: [5]});**
*// First dense layer uses relu activation.*
**const denseLayer1 = tf.layers.dense({units: 10, activation: 'relu'});**
*// Second dense layer uses softmax activation.*
**const denseLayer2 = tf.layers.dense({units: 2, activation: 'softmax'})**;
*// Obtain the output symbolic tensor by applying the layers on the input.*
**const output = denseLayer2.apply(denseLayer1.apply(input));** *// Create the model based on the inputs.*
**const model = tf.model({inputs: input, outputs: output});** *// The model can be used for training, evaluation and prediction.*
*// For example, the following line runs prediction with the model on* *// some fake data.*
**model.predict(tf.ones([2, 5])).print();****------RESULT------
Tensor [[0.3465916, 0.6534085], [0.3465916, 0.6534085]]********
27.1 - 编译 ( config )
为训练和评估配置和准备模型。编译用配置(优化器、损失和/或度量)装备模型。在未编译的 模型上调用 fit 或 evaluate 会抛出错误。
退货→ 作废
27.2 - 评估 ( x，y，config？)
返回测试模式下模型的损失值和度量值，这些值是在 compile()期间指定的，需要在调用 evaluate()之前发生。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})] }); model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
**const** result = **model.evaluate(tf.ones([8, 10]), tf.ones([8, 1]), { batchSize: 4})**;
result.print();
**------RESULT------
Tensor 0.00010169133020099252********
返回→ tf。标量或 tf。标量[]
27.3 - 预测 ( x，config？)
为输入样本生成输出预测，计算分批完成。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.predict(tf.ones([8, 10]), {batchSize: 4}).print();
**------RESULT------
Tensor
[[1.8470926],
[1.8470926],
[1.8470926],
[1.8470926],
[1.8470926],
[1.8470926],
[1.8470926],
[1.8470926]]********
返回→ tf。张量或 tf。张量[]
27.4 - 预测批次 ( x )
返回一批样本的预测值，其中 x 是张量。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.predictOnBatch(tf.ones([8, 10])).print();
**------RESULT------** **Tensor
[[-1.1825931],
[-1.1825931],
[-1.1825931],
[-1.1825931],
[-1.1825931],
[-1.1825931],
[-1.1825931],
[-1.1825931]]********
返回→ tf。张量或 tf。张量[ ]
27.5 - 拟合 ( x，y，config？)
为固定数量的历元(数据集上的迭代)训练模型。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})] }); model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
for (let i = 1; i < 5 ; ++i) {
**const** h = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]),
{ batchSize: 4, epochs: 3 });
console.log("Loss after Epoch " + i + " : " + h.history.loss[0]);
}
**------RESULT------** **Loss after Epoch 1 : 0.32676371932029724
Loss after Epoch 2 : 0.016571789979934692
Loss after Epoch 3 : 0.0008404387044720352
Loss after Epoch 4 : 0.00004262066795490682********
退货→ 承诺
28 - tf。()延伸到 tf。型号****
一个有一堆层的模型，从一层到下一层线性进给。
*******// Define a model for linear regression.*
**const** model = tf.sequential();
model.add(tf.layers.dense({units: 1, inputShape: [1]}));
*//Prepare model for training: Specify the loss and the optimizer.*
model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});
*// Generate some synthetic data for training.*
**const** xs = tf.tensor2d([1, 2, 3, 4], [4, 1]);
**const** ys = tf.tensor2d([1, 3, 5, 7], [4, 1]);
*// Train the model using the data then do inference on a data point //the* *model hasn't seen:*
await model.fit(xs, ys); model.predict(tf.tensor2d([5], [1, 1])).print();**------RESULT------** **Tensor [[3.1389987],]********
28.1 - 添加 (图层)
在层堆栈上添加一个层实例。
******const model = tf.sequential();
model.add(tf.layers.dense({units: 8, inputShape: [1]})); model.add(tf.layers.dense({units: 4, activation: 'relu6'})); model.add(tf.layers.dense({units: 1, activation: 'relu6'}));
*// Note that the untrained model is random at this point.*
model.predict(tf.randomNormal([10, 1])).print();**------RESULT------** **Tensor [[0.0679427],
[0.3440365],
[0.4146437],
[0 ],
[0.0855753],
[0.0688378],
[0.1540508],
[0 ],
[0 ],
[0 ]]********
退货→ 作废
28.2 - 评估 ( x，y，config？)
返回测试模式下模型的损失值&度量值，计算是成批完成的。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
**const** result = model.evaluate(tf.ones([8, 10]), tf.ones([8, 1]), {
batchSize: 4,
});
result.print();**------RESULT------** **Tensor 5.569275379180908********
返回→ tf。标量或 tf。标量[]
28.3 - 预测 ( x，config？)
为输入样本生成输出预测，计算分批完成。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.predict(tf.ones([2, 10])).print();**------RESULT------** **Tensor [[-0.6576568], [-0.6576568]]********
返回→ tf。张量或 tf。张量[]
28.4 - 拟合 ( x，y，config？)
为固定数量的历元(数据集上的迭代)训练模型。
********const** model = tf.sequential({
layers: [tf.layers.dense({units: 1, inputShape: [10]})]
});
model.compile({optimizer: 'sgd', loss: 'meanSquaredError'});
**const** history = await model.fit(tf.ones([8, 10]), tf.ones([8, 1]), {
batchSize: 4,
epochs: 3
});
console.log(history.history.loss[0]);**------RESULT------** **0.486328125********
退货→ 承诺
29-TF . load model(path 或 IOHandler )****
加载一个模型，包括它的拓扑和可选的权重。
例 1 :将 tf.model()的拓扑和权重保存到浏览器本地存储；然后装回去。
********const** model = tf.sequential(
{layers: [tf.layers.dense({units: 1, inputShape: [3]})]});
console.log('Prediction from original model:');
model.predict(tf.ones([1, 3])).print();
**const** saveResults = await model.save('localstorage://my-model-1');
**const** loadedModel = await tf.loadModel('localstorage://my-model-1');
console.log('Prediction from loaded model:');
loadedModel.predict(tf.ones([1, 3])).print();**------RESULT------
Prediction from original model: Tensor [[0.7820088],] Prediction from loaded model: Tensor [[0.7820088],]********
示例 2: 从 HTML 文件输入元素中从用户选择的文件中加载模型。
*******// Note: this code snippet will not work without the HTML elements in the page*
**const** jsonUpload = document.getElementById('json-upload');
**const** weightsUpload = document.getElementById('weights-upload');**const** model = await tf.loadModel**(**
tf.io.browserFiles([jsonUpload.files[0], weightsUpload.files[0]])**)**;******
示例 3: 从 HTTP 服务器加载一个模型。
********const** model = await
tf.loadModel('https://storage.googleapis.com/tfjs-models/tfjs/iris_v1/model.json')******
模型管理
30.1-TF . copy model(sourceURL，destURL )****
将模型从一个 URL 复制到另一个 URL。
*******// First create and save a model.*
**const** model = tf.sequential();
model.add(tf.layers.dense**(** {units: 1, inputShape: [10], activation: 'sigmoid'})**)**;
await model.save('localstorage://demo/management/model1');
*// Then list existing models.*
console.log(await tf.io.listModels()); *// Copy the model, from Local Storage to IndexedDB.*
await tf.io.copyModel('localstorage://demo/management/model1', 'indexeddb://demo/management/model1'); *// List models again.*
console.log(await tf.io.listModels());
*// Remove both models.*
await tf.io.removeModel('localstorage://demo/management/model1'); await tf.io.removeModel('indexeddb://demo/management/model1');**------RESULT------
[object Object] [object Object]********
退货→ 承诺
30.2-TF . list models()****
列出存储在注册存储介质中的所有型号。
*******// First create and save a model.*
const model = tf.sequential();
model.add**(**tf.layers.dense( {units: 1, inputShape: [10], activation: 'sigmoid'})**)**;
await model.save('localstorage://demo/management/model1');
*// Then list existing models.*
console.log(await tf.io.listModels()); *// Delete the model.*
await tf.io.removeModel('localstorage://demo/management/model1');
*// List models again.*
console.log(await tf.io.listModels());**------RESULT------
[object Object] [object Object]********
退货:→ 承诺
30.3-TF . move model(sourceURL，destURL )****
将模型从一个 URL 移动到另一个 URL。
*******// First create and save a model.*
**const** model = tf.sequential();
model.add(tf.layers.dense({units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1'); *// Then list existing models.*
console.log(await tf.io.listModels()); *// Move the model, from Local Storage to IndexedDB.*
await tf.io.moveModel('localstorage://demo/management/model1', 'indexeddb://demo/management/model1'); *// List models again.*
console.log(await tf.io.listModels()); *// Remove the moved model.*
await tf.io.removeModel('indexeddb://demo/management/model1');**------RESULT------
[object Object] [object Object]********
退货→ 承诺
30.4-TF . remove model(网址)****
从注册的存储介质中删除由 URL 指定的型号。
*******// First create and save a model.*
**const** model = tf.sequential();
model.add(tf.layers.dense( {units: 1, inputShape: [10], activation: 'sigmoid'}));
await model.save('localstorage://demo/management/model1'); *// Then list existing models.
* console.log(await tf.io.listModels()); *// Delete the model.*
await tf.io.removeModel('localstorage://demo/management/model1'); *// List models again.*
console.log(await tf.io.listModels());
**------RESULT------
[object Object] [object Object]********
退货→ 承诺
层(高级激活)
31.1-TF . layers . leaky relu(config？)****
输入形状:任意。将该层用作模型中的第一层时，使用配置
**inputShape**。
(x) = alpha * x for x < 0.f(x) = x for x >= 0.输出形状→与输入形状相同。
returns→TF . layers . layer****
31.2-TF . layers . soft max(config？)****
输入形状 →任意。将该层用作模型中的第一层时，使用配置
inputShape。输出形状 →与输入形状相同。
returns→TF . layers . layer****
层(基本功能)
创建一个密集的(完全连接的)层。
输出=激活(点(输入，内核(又名权重))+偏差)
单位(数字)正整数，输出空间的维数。
returns→TF . layers . layer****
32.2-TF . layers . dropout(rate，config？)****
将漏失应用于输入。
速率(数字)在 0 和 1 之间浮动。要丢弃的输入单位的分数。
returns→TF . layers . layer****
32.3-TF . layers . flatten(config？)****
拉平输入，不影响批量大小。
它将输入到 1D 的每一批变平(使输出为 2D)。
********const** input = tf.input({shape: [4, 3]});
**const** flattenLayer = tf.layers.flatten();*// Inspect the inferred output shape of flatten layer, which*
*// equals `[null, 12]`. The 2nd dimension is 4 * 3, i.e., the result // of the flattening.(The 1st dimension is undermined batch size.)*console.log(JSON.stringify(flattenLayer.apply(input).shape));**------RESULT------
[null,12]********
returns→TF . layers . layer****
层(卷积)
33-TF . layers . conv2d(滤镜)****
该层创建一个卷积核，该卷积核与层输入进行卷积，以产生输出张量。
滤波器(数字)输出空间的维数(即卷积中滤波器的数量)。
returns→TF . layers . layer****
34-TF . layers . cropping 2d(裁剪，配置？)****
该层可以在图像张量的顶部、底部、左侧和右侧裁剪输入。
裁剪 (number|[number，number]|[[number，number]，[number，number]])裁剪沿宽度和高度的尺寸。
********const** model = tf.sequential(); model.add(tf.layers.cropping2D({cropping:[[2, 2], [2, 2]], inputShape: [128, 128, 3]})); *//now output shape is [batch, 124, 124, 3]*******
returns→TF . layers . layer****
图层(标准化)
35-TF . layers . batch 规格化 ( axis，config？)
标准化每批前一层的激活，即应用一个保持平均激活接近 0 和激活标准偏差接近 1 的变换。
轴(数字)应该归一化的整数轴(通常是特征轴)。默认值为-1。
返回→ tf.layers.Layer
层(池化)
36-TF . layers . averagepool2d(poolSize，config )****
空间数据的平均池化操作。
poolSize (number 或[number，number])在每个维度[垂直，水平]中缩减的因子。需要一个整数或 2 个整数的数组。
returns→TF . layers . layer****
注:他们还有平均池 1d 和全局平均池等。****
37-TF . layers . maxpool2d(poolSize， config )
空间数据的最大池化操作。
pool size(number |[number，number])在每个维度[垂直，水平]中缩减的因子。需要一个整数或 2 个整数的数组。
returns→TF . layers . layer****
注:它们还有 maxPooling1d 和 globalMaxPooling 等。
层(包装)
38-TF . layers . bidirectional(layer，config )****
它包括复制网络中的第一个循环层，从而现在有两个并排的层，然后将输入序列原样作为输入提供给第一层，并将输入序列的反向副本提供给第二层。这项技术有助于 LSTMs。
图层 (RNN)一个要被包裹的 RNN 图层的实例。
退货→ 包装
39-TF . layers . time distributed(图层)****
输入应该至少是 3D 的，索引 1 的维度将被认为是时间维度。
returns→TF . layers . layer****
图层(当前)
40-TF . layers . rnn(cell(TF。RNNCell 或 tf。RNNCell[ ] ) )****
输入形状:带形状的 3D 张量。
returns→TF . layers . layer****
41 - tf。multi rnncell(lstmCells，data，c，h)****
计算 LSTMCells 堆栈的下一个状态和输出。
每个单元格的输出用作下一个单元格的输入
lstmCellsLSTMCell 函数的数组。
数据 输入到单元格中。
c前一个单元格状态的数组。
h 前一个单元输出的数组。
返回→【TF。Tensor2D[]，tf。Tensor2D[]]****
注意:它们还有TF . layers . simplernncell，****
TF . layers . stackednncells(配置)，****
layers . simplernn(配置)****
42-TF . layers . lstm【配置】****
长短期记忆层
********const** lstm = tf.layers.lstm({units: 8, returnSequences: true}); *// Create an input with 10 time steps.*
**const** input = tf.input({shape: [10, 20]});
**const** output = lstm.apply(input); console.log(JSON.stringify(output.shape)); *// [null, 10, 8]: 1st dimension is unknown batch size;
// 2nd dimension is the same as the sequence length of [tf.input()]//(#input), due to `returnSequences`: `true`;*
*// 3rd dimension is the `LSTMCell`'s number of units.***------RESULT------
[null,10,8]********
returns→TF . layers . layer****
43-TF . layers . lstmcell(配置)****
LSTM 单元与 RNN 子类 LSTM 的不同之处在于，其应用方法仅获取单个时间步长的输入数据，并在该时间步长返回单元的输出，而 LSTM 获取多个时间步长的输入数据。
例如:
******const cell = tf.layers.lstmCell({units: 2});
const input = tf.input({shape: [10]});
const output = cell.apply(input); console.log(JSON.stringify(output.shape));
*// [null, 10]: This is cell's output at a single time step. The 1st* *// dimension is the unknown batch size.***------RESULT------
[null,10]********
LSTMCell 工作流最典型的用途是将多个像元组合成一个堆叠的 RNN 像元。例如
********const** cells = [tf.layers.lstmCell({units: 4}), tf.layers.lstmCell({units: 8}), ];
const rnn = tf.layers.rnn({cell: cells, returnSequences: true}); *//Create input with 10 time steps and length-20 vector at each step.*
const input = tf.input({shape: [10, 20]});
const output = rnn.apply(input);console.log(JSON.stringify(output.shape)); *// [null, 10, 8]: 1st dimension is unknown batch size; 2nd dimension //is the* *same as the sequence length of [tf.input()](#input), due to //`returnSequences`: `true`;* *3rd dimension is the last `lstmCell`'s //number of units.***------RESULT------
[null,10,8]********
返回→ tf。RNNCell
44-TF . basiclstmcell(健忘偏差，lstmKernel，lstmBias，数据，c，h )****
计算 BasicLSTMCell 的下一个状态和输出。
c 前一个单元格状态。
h 前一个单元输出。
returns→【TF。Tensor2D，tf。Tensor2D]****
训练(梯度)
45-TF . grad(f)****
f 代表数学函数。
*******// f(x) = x ^ 2*
**const** f = x => x.square(); *// f'(x) = 2x*
**const** g = tf.grad(f);
**const** x = tf.tensor1d([2, 3]);
g(x).print();**------RESULT------
Tensor [4, 6]********
另一个例子
*******// f(x) = x ^ 3*
**const** f = x => x.pow(tf.scalar(3, 'int32')); *// f'(x) = 3x ^ 2*
**const** g = tf.grad(f); *// f''(x) = 6x*
**const** gg = tf.grad(g);
**const** x = tf.tensor1d([2, 3]);
gg(x).print();**------RESULT------
Tensor [12, 18.0000038]********
returns→(x:TF。张量 ，dy？:T30TF。张量)=>TF。张量
46-TF . custom grad【f】****
*******// Override gradient of our custom x ^ 2 op to be dy * abs(x);*
**const** customOp = tf.customGrad**(**x => {
return {value: x.square(), gradFunc: dy => [dy.mul(x.abs())]};
}**)**;**const** x = tf.tensor1d([-1, -2, 3]);
**const** dx = tf.grad(x => customOp(x));
console.log(`f(x):`);
customOp(x).print();
console.log(`f'(x):`);
dx(x).print();**------RESULT------
f(x): Tensor [1, 4, 9] f'(x): Tensor [1, 2, 3]********
returns→(…args:TF。张量[])=>TF。张量
培训(优化人员)
47-TF . train . Adam(learning rate？，beta1？，beta2？，ε？)****
构建一个使用 Adam 算法的 AdamOptimizer。见https://arxiv.org/abs/1412.6980
参数:
learningRate (数字)用于 Adam 梯度下降算法。可选择的
(数字)一阶矩估计值的指数衰减率。可选择的
(数字)二阶矩估计值的指数衰减率。可选择的
ε(数字)用于数值稳定的小常数。可选择的
Returns→ AdamOptimizer
48-TF . train . rms prop(learning rate，decay？，气势？，ε？，居中？)****
构造一个 tf。使用 RMSProp 梯度下降的 RMSPropOptimizer。
参数:
学习率(数字)用于 RMSProp 梯度下降算法的学习率。
衰减(数字)历史/未来梯度的贴现因子。可选择的
动量(数字)用于 RMSProp 梯度下降算法的动量。可选择的
ε(数字)小值避免分母为零。可选择的
居中(布尔型)如果为真，则通过梯度的估计方差对梯度进行归一化。可选择的
Returns→ tf。RMSPropOptimizer
培训(损失)
49-TF . losses . meansquadererror(标签，预测，权重？，还原？)****
计算两个张量之间的均方误差。
返回→ tf。张量
50-TF . losses . softmaxcrossentropy(labels，logits，dim？)****
计算逻辑和标签之间的 softmax 交叉熵。它测量类别互斥的离散分类任务中的概率误差。
例如，每个 CIFAR-10 图像都有且只有一个标签:图像可以是狗或卡车，但不能同时是狗和卡车。
返回→ tf。张量
自我提醒:不要列很长的清单
— — — — — —奖金— — — — —
表演
TF . tidy(nameOrFn，Fn？，gradMode？)****
执行 f 提供的函数，执行后清除 f 分配的所有中间张量，f 返回的除外
使用这种方法有助于避免内存泄漏。一般来说，将对操作的调用包装在 tf.tidy() 中进行自动内存清理。
*******// y = 2 ^ 2 + 1*
**const** y = tf.tidy(() => { */
/ a, b, and one will be cleaned up when the tidy ends.*
**const** one = tf.scalar(1);
**const** a = tf.scalar(2);
**const** b = a.square();
console.log('numTensors (in tidy): ' + tf.memory().numTensors); *// The value returned inside the tidy function will return*
*// through the tidy, in this case to the variable y.*
return b.add(one); });
console.log('numTensors (outside tidy): ' + tf.memory().numTensors); **y.print();****------RESULT------
numTensors (in tidy): 16
numTensors (outside tidy): 14
Tensor 5********
returns→void | number | string | TF。张量|tf。张量[]|{[key: string]:tf。张量|数字|字符串}****
保持一个 tf。tf.tidy()内部生成的张量不会被自动释放。
********let** b;
**const** y = tf.tidy**(**() => **{**
const one = tf.scalar(1);
const a = tf.scalar(2); *// b will not be cleaned up by the tidy. a and one will be cleaned //up when the tidy ends.*
b = tf.keep(a.square());
console.log('numTensors (in tidy): ' + tf.memory().numTensors); *// The value returned inside the tidy function will return*
*// through the tidy, in this case to the variable y.*
return b.add(one);
**})**; console.log('numTensors (outside tidy): ' + tf.memory().numTensors); console.log('y:'); y.print();
console.log('b:');
b.print();**------RESULT------
numTensors (in tidy): 16
numTensors (outside tidy): 15
y: Tensor 5
b: Tensor 4********
Returns→ tf。张量
返回程序当前时间的内存信息。
Returns→ MemoryInfo
TF . time(f)****
执行 f( ) 并返回一个带有计时信息的承诺。
********const** x = tf.randomNormal([20, 20]);
**const** time = await tf.time(() => x.matMul(x)); console.log**(**`kernelMs: ${time.kernelMs}, wallTimeMs: ${time.wallMs}`**)**;**------RESULT------
kernelMs: 0.10000000149011612, wallTimeMs: 33.40000000037253********
退货→ 承诺
TF . set back end(backen dtype，safeMode？)****
设置后端(cpu、webgl 等)负责创建张量并在这些张量上执行操作。
退货→ 作废
TF . topixels(img，canvas？)****
画出一个 tf。像素值的张量 到一个字节数组或可选的画布。
此外，当输入的 dtype 为“float32”时，我们假定值在范围[0–1]内。否则，当输入为“int32”时，我们假定值在范围[0–255]内。
要绘制到的画布。可选择的
img (tf。Tensor2D 或 tf。Tensor3D)秩 2 或秩 3 张量。如果等级为-2，则绘制灰度。如果秩为 3，则深度必须为 1、3 或 4。当深度为 1 时，绘制灰度。
退货→ 承诺
现在…我很确定我已经错过了你最喜欢的 API，所以不要忘记在评论或任何问题中提到它。
感谢您阅读帖子。
我希望这篇文章对你有所帮助。
关注我 中 获取更多惊艳教程。
鼓掌吧！分享一下！跟我来。
乐意帮忙。荣誉……..
你会喜欢的以前的故事:
****** [## 手机上的 tensor flow:tensor flow Lite
我们得到了什么？
towardsdatascience.com](/tensorflow-on-mobile-tensorflow-lite-a5303eef77eb) [## 纪元与批量大小与迭代次数
了解您的代码…
towardsdatascience.com](/epoch-vs-iterations-vs-batch-size-4dfb9c7ce9c9) [## 手机上的 TensorFlow:教程
在 Android 和 iOS 上
towardsdatascience.com](/tensorflow-on-mobile-tutorial-1-744703297267) [## 激活函数:神经网络
Sigmoid，tanh，Softmax，ReLU，Leaky ReLU 解释！！！
towardsdatascience.com](/activation-functions-neural-networks-1cbd9f8d91d6)******
500 多个关于数据科学和机器学习的精彩书签
这是我去年建立的免费在线数据科学和机器学习资源列表。网络上有丰富的信息，作为一名数据科学专业人员，我经常会在数据科学资源的海洋中丢失真正有用的东西。从那时起，我开始在一个地方组织一切——书签工具栏——易于访问、共享和维护。
这个列表包括文章、教程、博客和其他与数据科学相关的有趣的东西——这些东西我觉得很有用，你也可能觉得有用。
如何使用这个列表
当你试图理解/使用 PCA，但它没有意义时，这就是你去“PCA”部分并阅读一些关于 PCA 背后的直觉的文章的时候。
如果你只是想读一些关于人工智能世界正在发生的事情的酷的东西，去“文章”区，你会发现一些有趣的东西。
你明白了吗..
注意:您可以直接右键打开该页面的任意链接，也可以从这里下载 HTML 文件，将该列表作为书签导入您喜欢的浏览器中！
名单
文章
越来越擅长机器学习— Robert Chang — Medium
在人工智能时代，语言比以往任何时候都重要
优步天气预报简介
MLflow:管理机器学习生命周期的平台——O ' Reilly Media
想要更少偏见的决定？使用算法。
构建人工智能软件:数据驱动与模型驱动的人工智能，以及我们为什么需要人工智能专用软件…
Neuralink 想把你的大脑连接到互联网上——会有什么问题呢？
人工智能正在发明人类无法理解的语言。我们应该阻止它吗？
接近机器学习问题—Bhushan shevale—Medium
气流:工作流管理平台——Airbnb 工程&数据科学——媒介
博客和教程
超过 200 个最好的机器学习、NLP 和 Python 教程— 2018 版
【2017 年最全面的数据科学学习计划
一系列 Jupyter 笔记本，使用 Scikit-Learn 和 TensorFlow 带您了解 python 中机器学习和深度学习的基础知识。
Python 中的“好的数据科学”机器学习项目演练:第一部分
Bokeh vs Dash——哪个是 Python 最好的仪表盘框架？
有趣的 Jupyter 笔记本图库 jupyter/jupyter Wiki GitHub
rasbt/Python-Machine-Learning-book:《Python 机器学习(第一版)》图书代码库和信息资源
ageron/handson-ml:一系列 Jupyter 笔记本，使用 Scikit-Learn 和 TensorFlow 带您了解 python 中机器学习和深度学习的基础知识。
ujjwalkarn/Machine-Learning-Tutorials:机器学习和深度学习教程、文章和其他资源
josephmisiti/awesome-Machine-Learning:一个由 awesome 机器学习框架、库和软件组成的精选列表。
ujjwalkarn/Machine-Learning-Tutorials:机器学习和深度学习教程、文章和其他资源
ujjwalkarn/DataSciencePython:使用 Python 的常见数据分析和机器学习任务
数据科学初学者教程| KagglePython 中完整的机器学习演练:第三部分
GitHub—ShuaiW/ml-cheat sheet:一个不断更新的 python 机器学习 cheatsheet
教程【Auton Lab】Python 中脊和套索回归的完整教程
技术对话-数据表/数据表技术对话。主 silvabrian/tech-talk-datatable 的 rmd
出版物/有趣的网站等
Nate Silver 的 FiveThirtyEight 使用统计分析——硬数字——讲述关于政治、体育、科学、经济和文化的引人入胜的故事。
Data Viz Project |收集可视化数据，从中获得灵感并找到合适的类型。
数据科学中心 数据科学搭便车指南，机器学习，R，Python —数据科学中心
2018 年你应该阅读的 5 大数据科学出版物| Udacity
数据好奇 2017 年回顾:我最喜欢的数据故事、数据集和可视化结果…
如何利用您的数据科学项目创造价值 整合 Google Sheets 和 Jupyter Notebooks
EliteDataScience —第 3 页，共 4 页—促进您的数据科学职业生涯。
Scikit _ Learn _ Cheat _ Sheet _ python . pdf
数据科学概念
主成分分析
pca —主成分分析的意义，特征向量&特征值—交叉验证 主成分分析输出的结论—交叉验证
有没有 PCA 比 t-SNE 更适合的例子？—交叉验证
大脑咀嚼博客档案主成分分析(PCA) vs 普通最小二乘法(OLS):一个直观的解释
在 Python 中使用 PCA 和 t-SNE 可视化高维数据集
缺失数据
走向数据科学 如何用 Python 处理缺失数据 处理缺失数据— pandas 0.22.0 文档
Claudia Perlich 对我如何处理预测模型中缺失值的回答？——Quora
特征工程
GitHub—Feature tools/Automated-Manual-Comparison:自动与手动特征工程对比。使用功能工具实现。
树模型的特征重要性测量—第一部分 深度特征综合:自动化特征工程如何工作|特征实验室 了解特征
回归
线性回归—详解—走向数据科学 所有机器学习者都应该知道的 5 个回归损失函数
为什么你需要检查你的残差图来进行回归分析:或者，犯错是人之常情，随机犯错是统计学上的奇迹
比较连续数据、二元数据和计数数据的假设检验 Jim 的统计数据
自然语言处理
自然语言处理很有趣！—亚当·盖特基—中号
理解终极指南&实现自然语言处理 自然语言处理初学者:使用 TextBlob
GitHub—JasonKessler/scattertext:各种文档类型之间语言差异的美丽可视化。
使用 Python 进行可视文本分析| The Mien Blog
处理文本数据的终极指南(使用 Python)——面向数据科学家&工程师
concrete _ NLP _ tutorial/NLP _ notebook . ipynb at master 百块/concrete_NLP_tutorial
使用 Python NLTK 的 NLP 教程(简单例子)— DZone AI
皱胃向左移
主题建模非常简单。|石头和贝壳
使聚集
数据科学家需要知道的 5 种聚类算法 层次聚类:简单解释| Orange 博客
模型评估
准确度、精确度、召回率& F1 分数:性能指标解释— Exsilio 博客
嵌套与非嵌套交叉验证— scikit-learn 0.19.0 文档
Python 中的训练/测试分割和交叉验证—面向数据科学— Medium
AB 测试
Julia Silge —从功率计算到 P 值:堆栈溢出时的 A/B 测试
集成学习
Python | ka ggle中的组装/堆栈介绍
一位 Kaggle 大师讲解渐变提升|没有自由的预感 (33)合集(3):渐变提升— YouTube
一个 Kaggle 高手讲解渐变提升|没有自由的预感 (33)合集(3):渐变提升— YouTube 提升树介绍— xgboost 0.71 文档
集成学习:当每个人都猜的时候…我就猜！
使用 AdaBoost 和梯度增强进行增强——数据科学家的成就——Medium
XGBoost 中参数调整的完整指南(带 Python 代码)
关联规则
购物篮分析简介—关联规则 可视化关联规则和项目集—plot arulesViz
IEEE Xplore 全文 PDF: 可视化层次分组中的关联规则
购物篮分析与 R : Salem Marafi 关联规则—RDA Ming . com:R 和数据挖掘
在 R | DataScience+ 中实现 Apriori 算法
缩放数据
什么时候标准化回归模型中的变量至关重要？
异常检测
逻辑回归
SVM
请解释支持向量机(SVM)，就像我是一个 5 岁的孩子。:机器学习
决策树
降维
(2/1)在机器学习中拥有大量的功能是一件坏事吗？——Quora
使用 Python | Kaggle 进行数据分析和特征提取
时间数列预测法
R 中的 ARIMA 估计—YouTubeR 中的 ARIMA 预测简介
(31)时间序列预测理论| AR、MA、ARMA、ARIMA |数据科学— YouTube
其他人
GitHub—dssg/MLforPublicPolicy:用于 CAPP 30254(用于公共政策的机器学习)的类资源
用 Scikit-learn 管道管理机器学习工作流第 1 部分:简介
auto-sk learn—AutoSklearn 0 . 3 . 0 文档
Learn | Kaggle 深度学习和计算机视觉简介| Kaggle
Squarespace/datasheets:从 Google 工作表中读取数据，向其写入数据，并修改其格式
marcotcr/lime: Lime:解释任何机器学习分类器的预测
数据可视化
David McCandless:数据可视化之美| TED 演讲| TED.com
自动生成——一行 R 代码构建流行统计结果的交互式可视化——袁博客
学习高级 Tableau 的分步指南——面向数据科学和商业智能专业人士——Analytics vid hya
D3 提示和技巧…马尔科姆·麦克莱恩[Leanpub PDF/iPad/Kindle]
dimple——一个用于 d3 数据可视化的简单图表 API
Bloomberg/bq plot:IPython/Jupyter 笔记本的绘图库
使用 Python 中的散景进行数据可视化，第三部分:制作完整的仪表板
mathisonian/awesome-visualization-research:关于数据可视化的推荐研究论文和其他读物的列表
fasouto/awesome-dataviz:awesome 数据可视化库和资源的精选列表。
使用 Seaborn | Python 数据科学手册进行可视化
探索性数据分析
5 种简单的技术来讲述强大的数据故事— Brit Cava — Medium
DataExplorer:用最少的代码快速探索数据| R-bloggers
如何抛弃 PowerPoint，用 Jupyter 和 Reveal.js 制作更好的幻灯片
reveal . js—HTML 展示框架 RPubs —太阳国 HW
R 代表数据科学 中级 Tableau 代表数据科学、商业智能专业人士
交易概率的广泛 EDA | ka ggleJupyter 笔记本查看器
结构化查询语言
mysql —我如何决定何时使用右连接/左连接或内连接，或者如何确定哪个表在哪一边？—堆栈溢出
数据工程
设计数据产品—走向数据科学 SQL vs NoSQL:如何选择— SitePoint
数据工程入门指南—第一部分— Robert Chang —中级
Python 中的工作流:准备数据以构建模型| Civis Analytics
软件设计
对干净代码的思考— Severin Perez — Medium
部署和维护 Web 应用程序的工作流程——Mark Nagelberg
挖掘数据科学工具:Docker-Mark Nagelberg
为数据科学家揭秘 Docker——深度学习项目的 Docker 教程|机器学习博客
使用 Kinesis、DynamoDB 和 Twitter 的 AWS 无服务器架构教程
如何用 Amazon 索引新的和现有的 Amazon DynamoDB 内容
弹性搜索服务。 用 Amazon 索引 Amazon DynamoDB 内容
使用 AWS Lambda | AWS Compute 博客的 Elasticsearch 服务
研究
GitHub—MW outs/jupy text:jupy ter 笔记本作为 Markdown 文档，Julia、Python 或 R 脚本
人工智能系统的剖析
火花
3 分钟内开始使用 PySpark 和 Jupyter 笔记本
Python 中的 Apache Spark:初学者指南(文章)— DataCamp
如何将 Python 函数转化为 PySpark 函数(UDF)——Chang Hsin Lee——将我的想法付诸文字。
用 scikit-learn 和 PySpark 熊猫 UDF 进行大规模预测
Pyspark —基于泰坦尼克号数据集的教程— Saagie 用户群 Wiki — Saagie
GitHub—jadianes/Spark-py-notebooks:Apache Spark&Python(py Spark)大数据分析和机器学习教程作为 IPython / Jupyter 笔记本
mahmoudparsian/pyspark-Tutorial:py spark-Tutorial 提供了使用 py spark 的基本算法
Python 资源
熊猫
GitHub—TomAugspurger/effective—pandas:我收集的关于使用熊猫的文章的源代码。
合并、加入和连接——pandas 0 . 20 . 3 文档
分组依据:拆分-应用-合并-pandas 0 . 20 . 3 文档
在 Python Pandas 中汇总、聚合和分组数据| Shane Lynn 使用数据帧
对 Pandas 中的组应用操作— Python 日期时间属性
关于熊猫指数，我需要知道些什么？(第一部分)——YouTube
熊猫的 19 个基本片段
基本统计功能 快速入门教程— NumPy v1.13 手册 搜索页面
字典—艰难地学习 PythonPEP 265—按值排序字典| Python.org
数据即
Python Seaborn 初学者教程(文章)— DataCamp
Matplotlib 教程:Python 绘图(文章)—data campPython—Matplotlib 中的命名颜色—堆栈溢出
GitHub — ioam/holoviews:停止绘制你的数据—注释你的数据，让它自己可视化。
如何用 Python 生成 FiveThirtyEight 图
如何可视化决策树 可视化的机器学习——伊恩·约翰逊——Medium
Matplotlib
为什么很多例子在 Matplotlib/pyplot/python 中使用“fig，ax = PLT . subplots()”—堆栈溢出
Matplotlib API—Matplotlib 2 . 0 . 2 文档
Pyplot 教程— Matplotlib 2.0.2 文档
Matplotlib . axes . axes . plot—Matplotlib 2 . 0 . 2 文档
美味的汤
用 Python 解析 HTML 表格用 BeautifulSoup 和 pandas——Scott Rome——从事机器学习的数学博士
使用 BeautifulSoup 的 Python 网页抓取教程
学习 Python:第 1 部分—刮擦和清理 NBA 选秀— Savvas Tjortjoglou
Python Web Scraping 简介— Chi Hack 之夜—芝加哥每周一次的活动，旨在构建、分享和了解市政技术。
其他有趣的东西
一系列有用的 Python 技巧——freeCodeCamp.org
如何使用 Dask 数据帧在 Python 中运行并行数据分析
在 AWS 上部署 Flask 应用程序—Scott Rodkey—MediumFlaskBook.comExplore Flask—Explore Flask 1.0 文档
GitHub—acro trend/awesome-Dash:awesome Dash(plotly)资源的精选列表
为 Python 安装 Oracle(CX _ Oracle)|希顿研究 掌握 Oracle+Python，第 1 部分:查询最佳实践
GitHub—krzjoa/awesome-Python-data science:Python 中数据科学软件的精选列表
pycon-2017-EDA-tutorial/2-red card-players . ipynb at master CMA wer/pycon-2017-EDA-tutorial GitHub
GitHub—EpistasisLab/tpot:Python 自动化机器学习工具，使用遗传编程优化机器学习管道。
r 资源
使用 R Markdown 进行课堂报告 (6)使用 RStudio 的 R Markdown—YouTube
数据挖掘中 apriori 算法的初学者教程，带 R 实现| HackerEarth 博客
前 50 个 ggplot2 可视化—主列表(含完整 R 代码)
dplyr
DP lyr-tutorial/DP lyr-tutorial。主 justmarkham/dplyr 的 Rmd 教程 GitHub
使用 ggplot2 和 dplyr 进行数据探索(代码和教程)
由 tclavelle 提供的 DP lyr-tidyr-教程
R 用于数据科学 RPubs —用 dplyr & amp 进行数据处理；tidyr
GitHub—Susan Li 2016/Data-Analysis-with-R:使用 gglot2、tidyr、dplyr、ggmap、choroplethr、shiny、逻辑回归、聚类模型等
备忘单—r studioGitHub—jrnold/gg themes:gg plot 主题和比例gg plot 2—备忘单
R 图目录seananderson.ca/ggplot2-FISH554/
有没有更好的组织方式？
当然啦！我每天都这么做。当我发现新内容时，书签工具栏中的文件夹和子文件夹会发生变化和发展。因为数据科学和机器学习中的许多概念和想法重叠，所以确实没有“正确”的方式来组织这些东西。这只对我有用。确保你创造了一个适合你的系统。
6 个情感回报的数据科学项目
通过专注于一个像这里提到的项目，在你的工作中找到更多的满足感。
数据科学领域最适合那些热爱数学和与数字打交道的人。
虽然有些项目是单调乏味的，尤其是在初级阶段，但这个领域有大量令人兴奋和有益的工作适合有资格、有经验的专业人士。
大数据和下一代数据分析的出现让个人获得比以往更多的数据，从而使该领域更加创新和令人兴奋。
由于我们目前生活在信息时代，只有以有趣、创造性和有益的方式使用这些数据才有意义。
1.诊断和解决个人健康问题
个人健康和幸福与 10 年、20 年或 50 年前一样重要。显著的区别在于诊断机器、设备和服务的可用性——其中许多可以及时检测出大多数健康问题进行治疗。
再加上技术的快速进步，很容易看到这些设备每天都在变得越来越智能。
它们的体积也越来越小，因为下一代芯片和处理器比以往任何时候都更紧凑。一些设备甚至可以作为用户身体上的配件佩戴，或者作为智能手机应用程序使用。
但这些设备都依赖于下一代数据和先进的数据收集算法——所有这些都必须得到组织、处理和分析，以实现最大的有效性。现代软件和硬件使许多这些过程自动化，但敏锐的人眼仍然是确保数据完整性、验证来源和做出关键决策所必需的。
2.打击犯罪
刑事司法部门越来越多地以新的和创新的方式使用数据。从执行日常巡逻的地方官员到最复杂的联邦调查和审判，技术处于大多数行动的最前沿。
虽然执法机构使用的一些数据收集和存储做法存在争议，但在许多领域，这些数据对犯罪产生了真正的影响。官员们用它来预测和防止大规模屠杀，打击人口和毒品贩运等等。
数据也可以揭露白领犯罪，包括挪用公款、欺诈和其他通常发生在高级或行政级别的计划。
通过密切关注企业统计数据并发现某些趋势或模式，勤奋且训练有素的数据科学家可以快速识别可疑活动，并将其报告给适当的机构。
3.倡导改善客户服务
今天的大多数零售商，包括电子商务店面和传统的实体企业，都依靠数据来改善客户服务。他们使用预测、统计和分析(如地区人口统计、购物历史、最近的消费趋势等)来为最有价值的客户提供个性化服务。
在当今的许多商业模式中，增强客户体验是一个至关重要的策略。它也非常有效。
由于大多数消费者更喜欢具体、有针对性的广告和有用的交易，而不是迎合最低公分母的通用广告和优惠券，许多公司都在积极寻找合格的数据科学家来处理这些数据。
4.公共教育经费分析
公共教育部门一直在寻找降低风险、控制成本和满足不断变化的学生需求的方法。许多学校从国家赞助的彩票系统获得资助。例如，仅在 2017 年，弗吉尼亚彩票就向全州公立学校捐赠了超过 6 . 06 亿美元。
通过分析特定学校的支出，数据科学家可以根据他们收到的钱、学生表现、课外活动的存在等轻松得出结论。
更重要的是，数据科学家可以利用这些数字在开发未来课程和建立新的娱乐机会时提供指导和方向。
5.改善本地交通挤塞
数据在公共部门的其他领域也很有用。它最近在交通管理、规划和控制方面获得了发展势头。
中国浙江的一个城市最近在该市一些最繁忙的交通检查站安装了超过1000 个数字监控设备。这些系统每月处理 1tb 的数据，这对本地数据科学家来说是一项繁重的工作。
物联网，或物联网，是这个系统和许多其他系统背后的驱动力。它不仅从下一代汽车、公共汽车和火车上的单个传感器收集数据，还将这些信息实时传输给该地区的数据科学家、it 专家和交通官员，以进行即时处理。
6.种植更好、更健康的作物
大数据甚至在现代农场和宅地中也很有用。随着越来越多的美国人采用传统的生活方式，以及世界各地的其他人仍然以更简单的方式生活，这个领域将从先进的数据收集和应用中受益匪浅。
今天，数据有助于更准确地预测作物，生产更具弹性和生产力的种子，并使田间的某些任务自动化。结果是一个更智能、数据驱动的农场，用更少的体力劳动提供更高的产量。
在数据科学中寻找情感回报
数据科学可能是一个有益和充实的职业。
从帮助他人克服个人健康问题到参与打击犯罪，甚至生产更健康的食品，这些信息的价值是不可否认的。
图像由 Rawpixel 组成
数据可视化项目失败的 6 个原因
Photo: Thomas Tucker on Unsplash
一幅画最大的价值是当它迫使我们注意到我们从未期望看到的东西。约翰·w·图基
尽管数据可视化有着巨大的前景，并且这一学科成为主流已经有十年了，但它一点也不成熟。尽管有大量的可视化工具可供使用，也有出色的数据科学家在玩这些工具，但在企业中，数据可视化的有效使用仍然很少见。
由于从业者的持续进步和顶级玩家的营销闪电战，可视化已经深入到组织的深处。尽管有投资和意识，但从可视化计划或工具的长期采用中获得商业投资回报是很难的。
有时，人们想知道是什么使得信息的视觉显示如此困难。
- 也许这与信息设计的减少有关，信息设计是蹩脚的，但是光滑的仪表板显示各种 KPI。
- 也许是花哨的图表和令人眼花缭乱的功能在某个地方失去了用户的脉搏。
- 或者，由于优先级冲突和混乱的执行，善意的计划中途脱轨了。
我们能看看可视化项目中的主要失败点吗？或者，作为观想练习者，你想要一些分享挫折的有趣反映吗？请继续阅读我们在 Gramener 近十年来在企业中实施视觉智能的经验样本。让我们也讨论如何解决这些陷阱。
Photo: Isaac Davis on Unsplash
**1。“我代表所有最终用户..**不要再看了
终端用户通常不直接参与定义可视化项目的需求。人们经常听到项目发起人或经理说他们*‘完全知道用户想要什么’*。要么用户的时间不容易获得(CXOs..)或者说他们人太多了(运营人员)。他们很容易被忽视，天真地认为其他人可以为他们开脱。
这是可视化仪表板在首次展示后经常被闲置的主要原因。如果仅仅列出常见问题或定义 KPI 就足够了，这个挑战就不会出现了。真正需要的是绘制用户故事图，并倾听用户如何解决业务问题。这是用户无法转移的实践智慧，与可操作性紧密相连。
让终端用户参与进来并收集他们细微的业务观点非常重要，这样才能将其构建到仪表盘中。通过访谈建立用户角色，通过温和的探索绘制用户旅程，并共同勾画出现有的业务场景。这也有助于列出观想将会回答的问题，并澄清那些不会回答的问题。
Keeping User at the foundation of Visual Experience (Source: Julian Missig, 2006, Jesse James Garrett 2000)
2。“我能拥有以上所有特征吗？”
当提出各种不同的观想选项时，你多久会听到一次答案，“以上都有”？当被要求进行优先级排序时，用户会产生一种强烈的不安全感，担心未来的场景可能无法处理。如果这是一个企业的第一个可视化项目，融入所有可能的花哨功能的冲动就会增强。
赞助商忽略了一点，你投入到应用程序中的越多，它就越少被使用。当一个人通过检查所有的框得到一种错误的满足感时，认知负荷会变得如此之高，以至于用户干脆完全停止使用它。当谈到优先级时，最有见识的用户可能没有正确的观点来接受艰难的呼叫，或者没有勇气咬紧牙关。
扮演一个顾问的角色并帮助将特性列表削减到最关键的是很重要的。虽然屏幕空间在技术上是无限的，但对数据密度加以限制是有用的，比如*‘只不过是一个不可滚动的屏幕’*。船上的利益相关者知道事情的轻重缓急，他们能够做出艰难的决定，也能在说服其他用户的许多战斗中获胜。
UI Matrix — A framework for prioritisation of Visual Requirements
3。"你真的需要数据来观想吗？"
当在数据可视化项目中对数据的需求受到质疑时，事情会变得非常奇怪。如果没有人告诉他们*“首先构建仪表板，然后在上线时直接插入数据”*，他们可以认为自己是幸运的。是的，在清理数据和准备提要方面存在挑战，但是设计没有任何数据的仪表板就像是本末倒置。
改装数据是最终导致不可操作的仪表板或看起来怪异的图表的根本原因。如果没有探索性分析，图表可能会被异常值扭曲，或者更糟，最终没有模式。图表的选择也是由数据决定的。例如，最多 4 个产品的收入分布可以是一个堆积条形图，但对于更多产品，类似 treemap 的图表是相关的。
作为项目规划的一部分，预先考虑数据非常重要。虽然获得标题行是一个有用的开始，但在做出关键的设计决策之前，完整的数据是必不可少的。必须教育客户，数据确实是可视化的关键路径，数据洞察推动设计决策。
Mapping the data types to their Visual Encodings by Noah Illinsky
4。“请给我我的旭日”
有时，人们会深深地爱上一张图表，以至于他们注定要将这种关系延伸到冷静的观想例子之外。这导致了无效的将图表强行拟合到解决方案中。为这种调整所做的妥协可能会对整个项目造成严重破坏。
那些即使在用例不支持的情况下也要求奇异或 3D 图表的人，这样做是为了他们自己的满足，最终疏远了用户。这不是自助餐，人们可以挑选各种各样的花式图表放在盘子里。人们可能会迷恋桑基图或 T2 和弦图，但如果把这些图表交给不懂数据的观众，那将是一场灾难。
图表的选择是一门科学，有像图形语法这样强大的学科来管理它。选择图表的因素包括:表示类型*(分布，趋势..)，数据点(少，多..)，用户角色(运营，战略..)，用户的数据熟悉度(分析师，业务用户..)*等。必须积极地教育用户基本原理，并用例子解释。
A catalogue of Data visualisations: Source datavizcatalogue
5.“我想要丰富的用户界面..你能让一切都可以点击吗？”
在设计导航和交互性时，一个常见的要求是*“能够深度钻取到最后一级，让一切都可以点击”*。如果把整个世界都放在一个屏幕上是一个普遍的幻想，那么让它都可以点击是密切相关的。当被要求在一个屏幕内优先显示功能时，一个常见的借口是用户试图将整个仪表盘隐藏在不相关的点击后面。
在一个屏幕上隐藏 100 次点击，将可视化变成了寻找复活节彩蛋。用户可能永远不知道有用的信息可能隐藏在仪表板的什么地方。在大多数应用程序中，超过 90%的点击从来没有被使用过，只有 10%的点击真正进入了用户的工作流程。
丰富的用户界面并不意味着大量的点击，它意味着正确和直观的放置。强加一些指导方针可能是有用的，比如说，每个屏幕不超过 8 次点击。静态格式的数据故事同样强大，所以要仔细考虑所需的交互性。用户会感谢这个电话。
A powerful visualisation - static, with a shelf life of 200 years: Napoleon’s failed Russia campaign
6。“我想要绿色和蓝色..并且，扔进去一些紫色的"
虽然到目前为止所涉及的所有问题都可以被合理化，但颜色就不一样了。诸如*“仪表板中似乎缺少了什么东西”或“这种视觉效果缺少惊喜效果”*这样的陈述会让实践者起鸡皮疙瘩。如果有必要，鞭策我们，但不要让反馈悬而未决。
每个用户都有自己选择的颜色，他们可能会非常固执己见。不幸的是，这可能对应用程序的接受度有很大影响。颜色不仅仅是外观和感觉。我们在一个有红绿色盲用户的项目中学到了这个痛苦的教训。我们丰富的 RGB 调色板显示为一个单一的颜色斑点，使其无法使用。
色彩理论与其说是科学，不如说是一门艺术，尽管有处理美学、功能和社会方面的标准指南。最好遵循用户角色和应用程序需求，而不是试图取悦每个人。人们还必须努力阐明选择，并帮助解决脱节问题，因为大多数用户无法解释他们的颜色偏好。
Color advisor tool — Colorbrewer
总结
虽然我们已经看到了数据可视化项目失败的 6 个关键点，但它们也恰好落在可视化项目的 6 个关键阶段。因此，通过避免陷阱来使它们正确，可以使天平向计划的整体成功倾斜。
可视化应该被视为使用数据讲述故事的媒介。一个视觉故事是艺术和科学的完美结合。从业者必须磨练自己的技能，将正确的美学成分与科学元素融合在一起。这创建了与用户相关的输出，解决了特定的业务挑战，并为企业提供了 ROI。
数字有一个重要的故事要讲。他们依靠你给他们一个清晰而有说服力的声音。—斯蒂芬·诺
对数据科学充满热情？随意在 LinkedIn 或者Twitter上加我。
在其他网站上包含此 LinkedIn 个人资料
www.linkedin.com](www.linkedin.com/in/ganes-ke…)
我如何通过 6 个简单的步骤将人体动作分类器的验证准确率提高到 80%
你们中有多少人是拖延大师？🙌如果你是，你来对地方了。
在这篇文章中，我想和大家分享一些我在担任数据科学家期间学到的技巧和诀窍，以及我如何用它们来快速增强我的模型。我将通过采用在德克萨斯大学达拉斯分校的多模态人体动作数据集( UTD-MHAD )上执行人体动作分类的集成方法来演示这一点。该集合实现了 0.821 的验证准确度，这与基线论文的 0.672 的准确度相比是显著的改进。
背景(问题)
我的任务是在 UTD-MHAD 应用数据融合来建立一个模型，对 27 种不同的人类行为进行分类，像所有拖延症大师一样，我把它留到了最后一周才开始做。最大压力=最高生产率！
UTD-MHAD 是从 Kinect 摄像头和一个可穿戴惯性传感器收集的开放数据集。该数据集包含由 8 名受试者(4 名女性和 4 名男性)执行的 27 个动作，每个受试者重复每个动作 4 次。在去除 3 个损坏的序列之后，数据集剩下 861 个数据序列。数据集包含 4 种数据形态，即:
- RGB 视频(时空)
- 深度视频(时空)
- 骨骼关节位置(时空)
- 惯性传感器信号(时间)
所有 4 种设备都进行了时间同步，并存储在中。阿维和。分别为 mat 格式。
任务:击败 0.672 的基线精度
该数据集来自一篇论文( C.Chen，2015 )，该论文使用了协同表示分类器(CRC)，其验证精度为 0.672。这是根据训练-验证分割计算的，其中受试者 1、3、5、7 用于训练，受试者 2、4、6、8 用于验证，这也是我必须打破的基线准确度！
一切都被点燃了，我立即去网上开始寻找过去的代码和教程。在网上呆了大约 30 分钟后，我很快意识到没有可重用的代码！压力水平增加。我突然意识到，我必须从头开始做这件事。我迅速拿出笔和笔记本，开始制定我的策略。
密码
6 个步骤概述
第一步:理解数据
在你开始做任何事情之前，知道你在处理什么是很重要的。在这种情况下，最好的办法就是出图！我使用了 NumPy、SciPy 和 Matplotlib 库来有效地实现这些。下面是进行网球挥杆的受试者的深度、骨骼和惯性数据的曲线图。
Video screenshot of a Tennis Swing
Depth videos of a Tennis Swing
Skeleton joint positions of a Tennis Swing
Inertial sensor signals of a Tennis Swing
所以现在我们已经绘制了它们，我们必须将它们转换成合适的格式来支持我们的模型。我的选择是 NumPy 数组。在这篇文章中，我将主要关注使用骨骼和惯性数据。对于 RGB 和深度视频，在创建 VideoDataGenerator 时需要特别小心，以便从磁盘中读取它们，因为它们太大，无法加载到内存中。
骨架和惯性数据具有变化的周期，并且对于惯性传感器来说，具有变化的幅度。直方图是显示这些分布的有效方法。
周期分布
Period Distribution of Inertial sensor data
这并不奇怪，因为这些是由不同的受试者执行的不同动作。这个实验也没有具体说明一个特定的动作应该如何进行，所以我猜想受试者只是根据他们自己的经验来执行这个动作。
拥有这些变化的周期是行不通的，因为我们的模型需要一个固定的输入形状。我们有两个策略来处理这个问题:
- 将所有信号填充至最大长度 326
- 将信号重新采样至 180°的平均周期
振幅分布
Amplitude Distribution of 3-axial Gyroscope data (min on the left, max on the right)
Amplitude Distribution of 3-axial Accelerometer data (min on the left, max on the right)
振幅的分布非常类似于长尾。由于幅度不影响输入数据的形状，我们可以选择不对其应用任何预处理技术。否则，诸如均值-方差归一化之类的归一化技术可以应用于预处理。
第二步:快速原型
正如精益创业方法所宣扬的，“失败得快，失败得便宜”。下一步是构建一个允许快速迭代的轻量级模型。用 Python 编写的高级神经网络包装器 Keras 将是这项任务的首选框架。Keras 允许一种干净、极简的方法，让你只用几行代码就能构建巨大的深度学习模型。您可以看到回购中的代码实现是多么容易。另外，我们也将使用它与 Tensorflow 后端。
首先，我们只从惯性数据开始。由于数据是 6 个通道的序列(加速度计的 3 轴+陀螺仪的 3 轴)，我们要建立的第一个模型是一个简单的 LSTM ( S. Hochreiter 等人，1997 )，它有 512 个隐藏单元的 LSTM 单元。
Minimalist Keras Code to implement the Simple LSTM model
Network Diagram of Simple LSTM model
第三步。性能指标
随着模型的创建，我们现在需要一个可靠的反馈系统来通知我们模型的执行情况。因为这是一个具有良好平衡的类别分布的分类任务，所以准确度将足以作为唯一的性能度量，而不需要计算精确度、召回或 F1 分数。
为了查看我们的模型是否过度拟合，我们还可以得到训练验证准确性损失图。还可以绘制一个 27 类混淆矩阵，以查看哪些行为经常被误归类为另一种行为。
Loss (Left) Accuracy (Right) plots of the Training (Blue) and Validation (Green) set of the Simple LSTM
从精度损失图中，我们可以看到，我们的模型在非常早的时期过拟合，在第 4 个时期后，我们的验证精度达到稳定。在 epoch 15，我们得到了一个验证精度约为 0.238 的模型，这与我们必须打破的基线 0.672 相差甚远。
这表明我们要么改变策略，要么应用更多的正则化技术，如丢弃层。
Confusion matrix of the Simple LSTM model on Inertial data
哦天哪！这个混淆矩阵看起来像一个扫雷游戏的截图！唯一可取的是“站着坐着”和“坐着站着”这两个动作，模型分别正确预测了 16 次(满分)和 13 次。其他 25 个动作表现很差。
在我们给自己施加压力之前，让我们后退一步，看看我们迄今为止都做了些什么。
Data Science Pipeline (adapted from Practical Data Science Cook Book)
我们刚刚完成了上述流程图中从步骤 1 到步骤 4 的一次完整迭代，我们得到了 0.238 的第一次验证精度。这并不理想，但却是一个很好的开端。我们已经为自己建立了一个高度迭代的数据科学管道，在这里我们可以有效地探索、构建和评估我们的项目。询问任何从业者，他们都会同意数据科学是一个高度迭代的旅程。
有了这个基础，我们现在可以发挥创造力，尝试不同的东西来改进我们的模型。我不想让你们看到我尝试的所有不同的试验，所以在接下来的部分，我将向你们展示我使用这个迭代管道发现的所有关键结果。
预处理
通过这个管道，我还发现，与零填充相比，将序列重新采样到 180 的平均值会导致更好的收敛。振幅的标准化不会导致模型性能的明显改善，因此我们将跳过它以防止不必要的计算。
第四步。将你能做到的部分自动化，并把你的训练传送到 Google Colab
因为我们很可能经常重复某些步骤，所以花些时间自动化它们是值得的。我们可以将某些经常使用的代码转换成脚本，并对它们进行功能抽象。你不那么未来的自己会非常感激你这样做。
Keras 回调
对于试图涉足深度学习的人来说，Keras 回调是最好的事情之一。它们是自动化模型训练的工具，我将分享 3 个我最喜欢的回调，它们在我的各种项目中极大地帮助了我。
首先是张量板。这允许 Keras 保存事件日志文件，该文件在训练期间不断更新，并且可以由 TensorBoard 读取和查看。这允许对你的模型训练进行实时、图形化的可视化，我强烈推荐它作为一种替代方案，而不是仅仅从 Keras 的model.fit()输出中查看它。
二、模型检查点。这允许您的 Keras 模型将权重保存到给定的文件目录中。有一些有用的论点，如monitor和save_best_only，让你可以控制你希望 Keras 如何减轻你的体重。
最后但同样重要的是，提前停止回调。拥有这个可以让 Keras 根据你指定的条件停止你的训练。对于我的例子，如下所示，我设置了min_delta=0和patience=5。这意味着，如果 Keras 发现模型的验证精度在 5 个时期后没有增加，它将停止训练。
有了这三个回调，我们可以安全地离开我们的模型训练，去吃午饭了。
Useful Keras Callbacks
谷歌联合实验室
众所周知，训练深度学习模型是一个非常 GPU 密集型的过程。幸运的是，谷歌合作实验室免费提供了强大的 TPU 内核！对于那些负担不起强大的 GPU 的人，可以考虑将你的培训转移到 Google Colab。Google Colab 还提供了一个熟悉的类似 Jupyter 笔记本的界面，使用起来非常直观。它也安装在你的 Google Drive 上，所以你可以很容易地将你的数据读入 Colab。重量和日志也可以很容易地保存。
第五步。在网上搜索，并与同事讨论以获得灵感
在第 2-4 节中完成了快速原型制作和评估的半自动流程后，是时候获得灵感并找到创造性的方法来提高我们模型的验证准确性了。谷歌不同的搜索词，或去门户网站如谷歌学术，科学直接和 Pubmed 可以给我们提供见解。与同事谈论你的问题会给我们带来意外的“发现”时刻。
我和一个正在进行自然语言处理(NLP)项目的同事聊天，这个项目给了我尝试双向 LSTM (BLSTM)的灵感。BLSTM 反转原始隐藏层并将它们连接起来，允许一种形式的生成性深度学习，从而使输出层同时获得来自过去和未来状态的信息。仅仅是加了一层 BLSTM，就让我的验证准确率翻倍到了 0.465。
Network Diagram of Bi-Directional LSTM model
Network Diagram of Conv LSTM model
conv·LSTM 模型
当我为特征提取添加卷积层时，主要的突破出现了。由于输入数据是 1D 信号，该模型使用一系列 1D 卷积和 1D 最大池层来提取更高维度的潜在特征，然后将它们馈送到捕获时间信息的 2 个 LSTM 单元。然后，LSTM 单元的输出变平，在添加带有 softmax 激活的密集层以对所有 27 个动作进行分类之前，我们附加了一个丢失率为 0.5 的丢失层。
这使我的惯性数据验证精度达到 0.700，这是我们第一次超过 CRC 模型基线 0。对于我们的所有模型，我们使用 AdamOptimizer(d . p . Kingma et al . m 2014)，其 学习率为 1e-4，β1 为 0.9，β2 为 0.999。我们使用 Xavier Glorot 初始化器( X. Glorot et at)初始化我们的可训练参数。，2010 )并将我们的批量大小设置为 3，以允许我们的模型更好地泛化( E. Hoffer 等人，2017 )。
UNet LSTM 模型
UNet ( O. Ronneberger et al .，2015 )是一个完全卷积的神经网络(FCNN)，在收缩和扩张路径上几乎是对称的。在收缩路径中，输入 was 通过一系列卷积和最大池来馈送，增加了特征图并降低了图像的分辨率。这增加了“什么”而减少了“哪里”。在扩展路径中，低分辨率的高维特征通过卷积核被上采样。在此操作过程中，要素地图被缩减。UNet 的一个新颖特征是，它将收缩路径中的高维特征连接到扩展层的低维特征映射。类似地，我将从卷积网络中提取的特征添加到 2 个 LSTM 单元中，平坦化输出，并附加一个丢失率为 0.5 的丢失层，最后是一个带有 softmax 激活的密集层，以对所有 27 个动作进行分类。我在下面的附录中附上了网络图。
UNet LSTM 模型在惯性数据上实现了 0.712 的验证精度。
第六步。集合你的模型
conv·LSTM 和 UNet·LSTM 在验证数据上表现都很好，我们可以通过取平均值来合并他们的 softmax 输出。这立即将验证准确度提高到 0.765！
对于大多数监督学习问题，集成方法往往优于单模型方法。目前认为这是因为它具有穿越假设空间的能力。一个集成能够导出一个更好的假设，该假设不在其构建的单个模型的假设空间中。
根据经验，当模型中存在多样性时，集成往往会产生更好的结果( L. Kuncheva 等人，2003 )。从下面显示的混淆矩阵中，我们可以看到 Conv LSTM 能够更好地拾取向右滑动和下蹲等动作，而 UNet LSTM 能够更好地拾取篮球投篮和画 x 等动作。这表明在这两个模型之间存在模型差异，并且确实如此，通过将它们组合在一起，我们得到了从 0.700 和 0.712 到 0.765 的验证精度！
Confusion Matrices of Conv LSTM (left) and UNet LSTM (right) on Inertial data
下面是我用来创建合奏的方程式。有关代码实施，请参考回购协议。
Average of the softmax output for the Conv LSTM and UNet LSTM
Softmax output for an action j
结合骨架数据
为了达到标题中承诺的 80%的验证准确性，我添加了骨架数据，并将其重采样为 180 个单位的周期。将其与 6 通道惯性数据融合后，我们得到(N，180，66)的输入形状，其中 N 是样本数。所有验证准确度的表格汇编如下。
Summary of Validation Accuracy of the Different Models
瞧，我们的最佳性能模型的混淆矩阵显示如下，验证精度为 0.821。
Confusion Matrix of Ensemble on Inertial + Skeleton data
摘要
恭喜你一路走到了这里！如果您完全遵循了这些步骤，您将会成功地构建您自己的集合人体动作分类器！
模型动物园
一些关键要点
- 绘图是理解数据的一种快速简单的方法
- 数据科学是一个高度迭代的过程
- 尽你所能实现自动化
- 合奏是让我们训练有素的模特发挥最大作用的快捷方式
- 使用谷歌 Colab 来提高你的训练速度
- Keras 是深度学习模型快速原型化的首选框架
如果你准备接受挑战，并且觉得 0.821 还不够，你可以阅读下面的小节来改进你的模型。
还能做些什么
A.过度装配问题
在我们的训练中，早期的过度适应似乎是我们面临的主要挑战。我们尝试添加漏失层和集合，使我们的模型更加通用，但我们还可以走得更远。当我们的模型试图学习可能没有用的高频特征时，往往会发生过度拟合。添加零均值高斯噪声和所有频率中的数据点可能会增强我们的 模型的学习能力。同样，即使是相同的活动，不同科目的时间顺序也有很大差异。使用时间缩放和转换来执行数据扩充将增加训练数据的量，从而允许我们的模型更好地概括。
另一方面，我们的模型还可以进一步调整，以降低其复杂性，以及过度拟合的风险。随着最近的神经架构搜索论文如 NAS ( B. Zoph 等人，2016 )、NASnet ( B.Zpoh 等人，2017 )和 Efficient-NAS ( H. Pham 等人，2018 )获得牵引力，我们也可以尝试应用它们，因为这也是一项分类任务。
B.RGB 与深度数据的数据融合
我们玩了惯性，我们在最后添加了骨架，以获得更多信息来找到我们需要数据的模型。为了更好地推动我们的模型，我们必须找到将它与深度和 RGB 数据融合的方法。这将允许更多的输入训练变量从中学习和提取特征，从而提高验证的准确性。
C.尝试其他集成学习技术
我们可以尝试更高级的集成学习方法，如 Boosting 和 Bagging，而不是简单的平均。
如果你对我参与过的其他项目感兴趣，可以随时访问我的Github！
附录
Network Diagram of UNet LSTM model
