多重比较问题概述
本文通过介绍相关问题、描述可能的修正以及使用 python 代码展示一个可视化示例，对多重比较问题进行了概述。
2012 年， IgNobel 奖被授予了一项对一条死鲑鱼的功能磁共振成像研究[1],因为在对体素进行多次测试后，他们在一条死鲑鱼的大脑中发现了显著的活动。
这项研究是所谓多重校正问题的一个例子，在维基百科中定义为“当一个人同时考虑一组统计推断或推断基于观察值选择的参数子集时出现的问题。换句话说，这是在同一实验中进行大量统计测试时出现的问题，因为我们做的测试越多，获得至少一个具有统计显著性的测试的概率就越高。
在对死亡鲑鱼的研究中，作者研究了典型 fMRI 体积中 130，000 个体素的大脑活动。由于大量的测试，获得至少一个假阳性的概率几乎是确定的(正如它发生的那样)。
因此，当运行多个测试时，意识到这个问题是很重要的。因此，为了警告数据科学家，本文旨在:
- 讲授如何根据α和检验次数计算两组间获得统计显著性的概率。
- 呈现多个比较校正。
- 使用 python 代码运行实验并显示结果。
1。根据α和测试次数计算两组间获得统计显著性的概率的公式
这个概率被称为家族错误率 (FWER)，其公式为:
其中“α”是单独测试的α水平(例如 0.05)，而“m”是测试次数
该错误率表示在执行多个假设测试时做出一个或多个错误发现的概率。
如果我们运行一个测试(α = 0.05)来评估两组之间是否有统计学显著性差异，则 FWER 为:
然而，如果我们运行相同的测试六次，FWER 将不再是 5%,而是增加到大约 26%。
图 1 显示了根据α和测试次数的 FWER 图。
图一。对于不同的α值，FWER 或 I 型错误率如何随着测试次数的增加而增加的图表。来源:作者照片
2。多重比较校正
有不同的方法可以防止这个问题发生。本文介绍了三种多重比较校正:Bonferroni、Bonferroni-Hold 和 idák。
Bonferroni 校正是最简单和最保守的方法，它将整组比较的α值设置为单个测试的α值除以执行的测试次数。
其中“α”是单个试验的α水平,“m”是进行试验的次数
“α”是一个新的阈值，需要达到该阈值才能将单个测试归类为显著性。
Bonferroni 方法的代价是，通过防止假阳性错误，无法拒绝一个或多个假零假设的风险增加了。因此，该另一种方法通过将获得的 p 值从最低到最高排序并将它们与α/m 到α的标称α水平进行比较来改进上述方法
最低 p _ value
该方法还定义了一个新的α’来达到。该阈值使用 FWER 和测试次数来定义。
其中“FWER”是家族误差率,“m”是测试次数
3。多重比较问题及例题纠正
本例旨在通过比较两个具有不同平均值( rvs1 为 5，rvs2 为 6.5)和标准偏差( rvs1 为 10， rvs2 为 8)的正态分布( rvs1 和 rvs2 )与 100 个具有类似于 rvs1 的平均值和标准偏差的正态分布来说明上述所有术语
常识告诉我们 rvs1 应该没有统计学意义，但是 rvs2 应该有统计学意义。
导入 Python 库
用随机数创建两个正态分布。rvs1 的平均值为 5，rvs2 的平均值为 6.5。rvs1 的标准偏差为 10，rvs2 的标准偏差为 8
图二。左边是正态分布 rvs1 的图。右边是正态分布 rvs2 的图。
t 检验分析功能:
Bonferroni 校正功能:
Bonferroni-Hold 校正功能:
idák 校正功能:
通过 rvs1 和 rvs2 运行上述四个函数的代码。对于本实验，α为 0.05。
结果是:
表 1
表 1 中的数字表示具有统计显著性的测试次数。
正如所观察到的，t 检验结果表明 rvs1 和 rvs2 在统计上是显著的，无论所有的校正方法如何显示 rvs2 是唯一显著的分布。
如果你喜欢这篇文章，请考虑 订阅 。你将获得我所有的内容+所有其他来自牛逼创作者的文章！
参考文献
[1] Craig M. Bennett 等人，大西洋鲑鱼死后物种间视角的神经相关性:适当多重比较校正的论证 (2009)，《偶然发现和意外结果杂志》。
PEP 8 风格指南概述
让您的 Python 代码具有风格。
ython Enhancement Proposal 8 或 PEP 8 是一个全面的 Python 代码样式指南。PEP 8 的目标是将所有 Python 集合在一个样式指南下。这增加了 Python 代码的可读性和整体理解。PEP 8 并不意味着在任何情况下都要遵循。你会遇到不适用的代码，如果是这样，你可能需要暂时脱离风格指南。关键是尽可能使用风格指南。它将帮助你和其他所有看到你的代码的人阅读和处理它。我会涵盖我认为最重要的领域。我不会讨论一些领域和其他领域，我可能只是略读一下。我真的推荐完整阅读 PEP 8，因为这个指南更像是一个快速概览。为了真正理解并获得更深入的解释，以及我选择不包含在本文中的部分。PEP 8 中我将复习的部分如下:
- 代码布局
- 用线串
- 空白
- 尾随逗号
- 评论
- 命名规格
- 推荐
PEP 8 可在此处找到:
Python 编程语言的官方主页
www.python.org](https://www.python.org/dev/peps/pep-0008/)
代码布局
缩进:
- 4 个空格，虽然这取决于你的延续行，只要有某种形式的缩进。
- 您可以垂直排列括号中的换行元素，或者使用悬挂缩进。
# 4 space indent
def hello(var):
print(var)# vertical alignmentexample2 = function(first_var, second_var,
third_Var, fourth_var)# hanging indentexample3 = function(
first_var, second_var,
third_var, fourth_var)
- 您可以对太长或希望成为延续行的条件使用类似的工作流。您可以在两个字符的关键字后使用括号，这将允许在转到新行时自动缩进。这对于长条件语句很有用，比如一个
if语句。对于嵌套语句，您可以选择没有额外的缩进，注释您的缩进细节，或者添加额外的缩进。 - 您可以将结束标点(大括号、中括号或圆括号)与最后一行的第一个字符或非空白的多行表达式的第一个字符对齐。
# last line, first character
new_list = [
'one', 'two', 'three',
'four', 'five', 'six'
]# first line, first character
new_list = [
'one', 'two', 'three',
'four', 'five', 'six'
]
制表符和空格
- 建议缩进时使用空格，而使用制表符是为了与使用制表符缩进的代码保持一致。
- Python 不允许在同一个代码中同时使用这两者。如果您正在转换混合了两者的 Python 2，请使用空格重做。
最大线路长度
- 最大的行长度应该是 79 个字符，虽然我发现这有时是限制性的，在那些情况下必须更长。在这种情况下，最多可以输入 99 个字符。
- 对于注释和文档字符串，应该使用 72 个字符，不能增加。
- 这有助于阅读 Python 代码并将其保存在编辑器、检查和调试工具中。
- 为了帮助你坚持下去，Python 有一个助手。您可以用括号将行括起来，从第一个关键字之后的所有内容开始，到下一个关键字之前结束。这是 PEP 8 建议的，它会根据正确的 Python 行样式格式自动换行。
- 也可以使用反斜杠，仅当圆括号换行不适用时，例如
assert语句。
使用二元运算符换行
- 为了更好的可读性，你应该在二进制操作符之前换行，尽管在过去这是相反的，如果它们是一致的，这两者都是可以接受的。
空白行
- 在类定义之前和之后应该有两个空行。
- 方法定义前后都应该有一个空行。
- 您应该在代码中保守地使用空行来分隔函数组。
- 如果不同行之间只有一行代码相互独立，则不必包含空行。
- Python 使用 control-L (^L)换行符来表示空白。
源文件编码
- 代码应该使用核心 Python 3 发行版的 UTF-8(Python 2 的 ASCII ),并且不应该有声明。
- 除此之外的编码只应用于测试目的。
- 跳转到 PEP 3131 了解更多关于这项政策的信息。
- 标识符应该只使用 ASCII，如果可能的话，应该使用英文单词。
进口
- 导入通常没有空行分隔。
- 导入通常应该在不同的行上分开，除非使用
from关键字。 - 导入属于代码的顶部，在注释和文档字符串之后，在全局变量和常量之前。
- 进口应该是这个顺序。
- 标准程序库
- 第三方
- 特定于本地/库。
5.推荐绝对导入，但是显式相对导入也很好。以不太冗长的为准。
6.从单独的类模块导入类。
7.除非必要，否则不应使用通配符(*)。
8.模块级“dunders”是带有两个尾随下划线的名称。这些名称应该放在注释和文档字符串之后，但在导入之前。
9.from __future__导入必须在除注释和文档字符串之外的任何代码之前。
用线串
- 字符串两边的单引号或双引号意思相同。你可以选择你更喜欢哪一个，但是要坚持，这样你就可以用你没有选择的替代来代替反斜杠。
- 三重引号应该使用双引号字符。检查一下 PEP 257 。
空白
避免尾随空白。
- 不要在你的表达式和语句中使用过多的空格。如果逗号、冒号和分号不在中括号、大括号或圆括号后面，则应该在逗号、冒号和分号后面有空格。
- 对于任何运算符，您都应该在运算符的两边使用空格。用于切片的冒号被视为二元运算符，它们之间不应该有任何空格。
- 当调用函数
function()时，函数旁边应该有不带空格的括号。 - 索引或切片时，括号应直接紧挨着集合，没有空格
collection[‘index’]。 - 不建议使用空格来排列变量值。
- 当可选选项可用时，请确保与您选择的格式一致。
尾随逗号
- 唯一需要尾随逗号的时候是在创建单个元素元组的时候。
- 如果您使用尾随逗号，请用括号将它们括起来。
- 尾部逗号经常在版本控制中使用，用来详细说明以后将要扩展的区域。
评论
- 确保您的注释有意义，并且对阅读代码有用。适得其反的注释可能会损害代码的可读性。
- 更新代码时，请确保更新您的注释。
- 确保你的评论对其他 Python 程序员来说容易理解。
- 块注释是一段或多段单行注释，以每行的结束标点结束。他们应该以
#开头，然后是空格。同样，块注释的缩进量应该与它们将要进入的代码的缩进量相同。用一行没有任何内容的注释来分隔段落。 - 在多行注释中，在句尾使用两个空格，除了在最后一句后只使用一个空格。
- 行内注释是跟在同一行代码后面的注释。保守地使用行内注释。在您的代码后面，它们应该至少由两个空格分隔。只有在必要时才使用它们。
- 文档字符串或文档字符串确实如其所述。它们为模块、函数、类和方法提供文档。对于以下所有内容，您都应该有 Docstrings。通过在文档串的开头和结尾使用三个
“””引号来创建文档串。要了解更多关于文档字符串的信息，请看 PEP 257 。
命名规格
尽管 Python 库中的命名约定与 Python 有些不一致，但仍然建议使用当前的命名约定，除非您正在使用的已经有了不同的约定，然后使用该格式。
最重要的原则是你应该为你的 API 的公共方面反映用法而不是实现。
有多种命名方式可供选择。记得要有描述性。您也可以使用前缀将名称组合在一起。
b
B
lowercase
lower_case_underscore
UPPERCASE
UPPER_CASE_UNDERSCORE
CamelCase
mixedCase
Cap_words_Underscore # not recommended
4.规范的命名约定
- 单前导下划线:弱，除非内部使用，否则不推荐使用。
- 单结尾下划线:用于避免 Python 关键字的问题。
- 双前导下划线:用于命名类属性。
- 双前导和尾随下划线是用户名称空间中的“神奇”对象或属性。
要避免的名字:
# try not to use.
l # lowercase L
O # uppercase o
I # uppercase i
ASCII 兼容性:
- 标准库要求标识符与 ASCII 兼容。
包和模块名称:
- 如果可能的话，包和模块应该有小写和简短的名字。
- 模块可以有下划线。
- 包不应有下划线。
- 如果一个模块在 C 或 C++中，并且与一个 Python 模块相关联，那么它会创建一个更高的接口，并且可以用一个前导下划线来命名。
类名:
- 使用大写单词的惯例
WordExample。 - 如果函数有很好的文档记录，并且主要用于可调用，那么您可以使用函数命名约定。
- 内置名称通常是一个单词或两个单词长。他们也只对异常和内置常量使用大写单词约定。
类型变量名称:
- 类型变量应该使用大写字母约定和简称。
- 后缀
_co用于具有协变行为的变量。 - 后缀
_contra用于具有逆变行为的变量。
异常名称:
- 使用类命名约定。
- 后缀
Error用于出错的异常名。
全局变量名称:
- 遵循函数命名约定。
__all__机制应该用来防止由from M import *引起的全局变量或者像前缀globals一样使用。
功能&变量名:
- 函数和变量应该是带下划线的小写字母。
- 如果已经在使用混合案例风格，您可以使用它。
函数&方法参数:
- 包含
self作为即时方法的第一个参数。 - 包含
cls或类方法的第一个参数。 - 如果需要，最好使用尾随下划线，而不是缩写。
方法名&实例变量:
- 使用函数命名约定。
- 对非公共方法和实例变量使用前导下划线。
- 如有必要，您可以使用两个前导下划线，以使用 Python 的名称 mangling。
常量:
- 带下划线的大写命名约定。
继承:
- 确保您的类的属性是公共的或非公共的。
- 非公共属性不是为第三方设计的。
- “私有”是 Python 中使用的一个术语。
- “子类 API”(又名。“受保护”)。旨在继承。基类。
- 公共属性=没有前导下划线，除非关键字冲突。
- 只公开公共数据属性的属性名。
- 子类化的类可以用双前导下划线来命名，使用 Python 的名称转换器。
5.公共和内部接口
- 用户应该能够区分公共接口和内部接口。
- 如果一个接口被文档化，它就被认为是公共的，除非文档中另有说明。
- 未记录的接口是内部接口。
- 模块应该使用
__all__来声明公共 API。如果__all__设置为空列表，表示没有公共 API。 - 内部接口的单前导下划线。
- 如果任何名称空间是内部的，那么接口也是内部的。
- 导入是一个实现细节。
推荐
- 编写代码，以免对 Python 的其他实现产生负面影响。
is或is not来比较单件。is not而不是not is。- 将 lambda 表达式绑定到标识符时，使用
def而不是赋值。 - 对于例外情况，使用
Exception代替BaseException。 - 确保您的异常链接被正确使用。
- 尽可能具体说明例外情况。
- 使用显式名称绑定语法。
- 对操作系统错误使用显式异常层次结构。
- 当使用
try和except时，在需要包装在try块中的区域周围保持代码紧凑。 - 在本地资源上使用
with语句。 - 确保正确使用
return语句。要么有return表情，要么没有。 - 与字符串模块相对的字符串方法。
- 使用方法
.startswith()和.endswith()进行字符串前缀和后缀切片。 - 使用
isinstance(<item>, <item>)而不是if type(<item>) is type(<item>)。 - 空序列被视为
False。 - 不要用
==来做TrueFalse的比较。 - 流控制语句应该在
finally代码块中。
函数注释
- 功能注释见 PEP 484 。
可变注释
- 变量注释见 PEP 526 。
结论
对于任何 Python 程序员来说，PEP 8 都是一个不可思议的资源。如果使用正确，它将保持你的代码可读性和 PEP 8 的风格参数。同样，这只是对 PEP 8 的一个简要概述，如果你想真正了解这个令人惊叹的样式指南，我鼓励你在 Python 网站或 GitHub 上阅读整个内容。我希望你喜欢阅读和快乐编码！
Python 编程语言的官方主页
www.python.org](https://www.python.org/dev/peps/pep-0008/) [## python/peps
标题:Python 代码版本风格指南: R e v i s i o n Revision Revision Last-Modified: D a t e Date Date作者:吉多·范·罗苏姆，巴里华沙…
github.com](https://github.com/python/peps/blob/master/pep-0008.txt)
TensorFlow 2.0 使用概述
一个想法的显现。
透明 tensor flow Logo Png@pngkit.com
Tensorflow 已经成为最受欢迎的深度学习库之一。程序员、数据科学家和研究人员可以使用它，通过使用 API 或从头开始编写东西来创建开箱即用的模型。它和你的需求一样抽象。
解决机器学习问题所需的基本步骤序列包括拥有数据集、创建模型、训练和评估模型以及最终部署它。我们将详细讨论这些步骤。不过，在此之前，让我们讨论一些与 TensorFlow 2 相关的有用更新。
急切的执行
TensorFlow 2 默认启用了急切执行。在 TensorFlow 的早期版本中，即使是打印张量这样最简单的任务也要创建一个会话。急切执行使代码更加直观。
打印张量 z 值的旧方法。它不是直观的。
更新更直观的方式打印张量(TF2)。
比如 Numpy
Numpy 是一个流行的 Python 库，专注于涉及矩阵的数学运算。由于急切的执行，TensorFlow 2 感觉更像 numpy。张量上的“numpy”方法也允许张量转换成 numpy 数组。
TensorFlow 更像 Numpy。
tf .函数装饰
这个装饰器加速了函数在后续调用中的执行。它允许使用 TensorFlow 使用的底层图模型的性能优势。装饰器告诉 TensorFlow 跟踪函数的计算并提高性能。
@ tf.function decorator 用来提升性能。
清洁剂 API
TensorFlow API 已经过清理，其中添加了 tf.keras.layers 和 TF . keras . loss 等命名空间。为了更好地组织，许多命名空间都被重命名，例如 tf.mod 被重命名为 tf.math.mod。少数端点(如 tf.rint)已被弃用。有关所有变更的详细列表，请参考 TensorFlow 名称空间。
数据设计
随着时间的推移，机器学习社区已经整合了许多有用的数据集，其中一些可以与深度学习库一起使用。很明显，您可以使用自己的数据并创建一个输入管道来进行训练。例如，“flow_from_directory”可用于高效地读取图像并动态地对其进行扩充。也可以使用 CSV 等文件中存储的数据。然而，在 TensorFlow 2 中，在数据集方面有两个选项—
使用 Keras 数据集
Keras datasets 提供回归数据集(如 boston housing)、图像分类数据集(如 mnist)和情感分类数据集(如 imdb)。这些数据集以 numpy 格式提供，并适合内存。
从 keras 数据集导入 MNIST 数据集。文档 tf.keras.datasets 。
使用张量流数据集
Tensorflow 数据集是使用数据的更快、更有效的方式。这是一种高性能的数据集格式。使用 TensorFlow 数据集读取的数据不是 numpy 格式，而是 tf.data 格式。它由大量面向研究的数据集组成，这些数据集被分类为音频、图像、图像分类、对象检测、结构化、摘要、文本、翻译和视频。这些数据集更加真实。
使用张量流数据集导入 MNIST 数据集。阅读数据集 TensorFlow 数据集的完整目录。 文档 张量流 _ 数据集。
模型设计
TensorFlow 2 已经推荐使用 Keras 作为其官方 API。在 Tensorflow 中设计模型就像插入内置层一样简单，从零开始为研究应用程序编写一切。
顺序 API
顺序 API 用于制作线性模型，一层一层的堆叠在另一层的顶部。使用 add()方法将不同的层(如 Dense、Flatten 和 Conv2D)添加到模型中。一旦你创建了你的模型，你就可以看到模型的概要。顺序 API 是创建模型最常用的 API。基本思想是堆叠一堆层来创建一个模型，该模型随后被编译和进一步训练以得出推论。
顺序卷积神经网络。
模型摘要。文档TF . keras . sequential .
功能 API
顺序 API 建立线性模型，而函数 API 用于建立非线性模型。这些模型的架构类似于有向图(DAG)。这些模型具有接受多个输入、产生多个输出和共享层的能力。
使用函数式 API 创建的模型。
用图形表示模型。文档 : Keras 功能 API
子类
子类化允许从头开始写所有的东西。它对创建模型的各个方面提供了更好的控制。框架给出了一个类，其中构造函数定义了要使用的层，调用方法将这些层按顺序放在一起。如果您想了解事情在幕后是如何工作的，推荐使用这种方法。
init 方法定义层。call 方法定义了如何使用已定义的层。您可以打印第 12 行生成的“x”值。你可以得到 x 的值，并对它应用各种数学函数。文档 : 编写自定义图层和模型
培训设计
使用拟合方法
拟合是用于训练模型的最常用方法。它适用于使用上述任何策略创建的模型。当数据集很小并且适合内存时使用它。
在使用 fit 方法训练模型之前，模型被编译，在此期间为模型指定损失函数、优化器和度量。
使用拟合方法训练模型。文档 model.fit() 。
使用回调
各种图表用于在训练期间监控模型的进度。或者，可以使用回调来监控各种评估指标的状态，并做出决定，例如停止训练、定期保存模型、安排学习速率、可视化训练进度等。它们在训练期间的不同点被调用，例如一个时期的开始、一批的结束等等。回调作为列表传递给 fit 方法。
EarlyStopping 的回调示例，它根据某个条件停止训练。文档 回调。
使用 Fit 生成器
这是训练模型的另一种方式。当数据集太大而无法放入内存时，使用拟合生成器方法。fit generator 的一个常见用例是从目录中读取图像，同时对它们应用数据扩充。
fit_generator()的示例。这些图像是从/tmp/data(第 3 行)中读取的，batch_size 为 20(第 16 行)。您还可以在从目录流动时应用放大，如缩放和剪切。文档 : fit_generator
批量使用列车
分批训练在分批水平上工作。它将单个批次作为输入，并在执行反向传播后更新模型参数。它允许我们在每批之间做额外的事情。一个用例是根据您可能稍后收集的一批新样本来更新预训练模型。它也用于 LSTM，其中 LSTM 的状态通常需要在每个数据系列之后复位。
批量训练的一个例子。文件 : 批量培训
编写自定义训练循环
在训练模型时，fit 和 fit_generator 函数抽象了许多细节。但是，如果需要，TensorFlow 2 允许您使用“GradientTape”查看网络的梯度。您还可以看到权重如何使用这些渐变进行更新。基本上，它可以让你更好地控制如何更新权重。讨论自定义训练循环的完整示例可能会让人不知所措。这里已经讨论过的一个详细例子。
分布式培训
在训练深度学习模型时，可扩展性至关重要。TensorFlow 2 允许在不对代码进行重大更改的情况下扩大学习任务的规模，以加快学习速度。训练过程可以扩展到多个 GPU、TPU 和机器。定义了多种策略来满足不同的用例。例如，MirroredStartegy 支持在一台机器上对多个 GPU 进行训练，而 MultiWorkerMirroredStrategy 支持在多台机器上进行同步分布式训练，每台机器都可以有多个 GPU。
使用 MirroredStrategy 的示例。代码中只添加了第 4 行和第 6 行，以支持分布式培训。其中的函数是分布式感知的。文档 : tf.distribute
序列化
一旦模型被训练，它需要被保存以便在生产中使用。在 TensorFlow 2 中，保存模型已使用 SavedModel 格式标准化，该格式保存完整的模型及其权重。SavedModel formal 使使用 TensorFlowJS、TensorFlowLite 或 TensorFlow Serving 部署模型变得更加容易。
使用 saved_model 保存张量流模型。文档: 已保存的模型
加载模型以备将来使用。
部署
使用 TensorFlow 服务
TensorFlow 服务允许机器学习模型作为 REST 或 gRPC(远程过程调用)客户端 API。通过提供 docker 文件，TensorFlow 中的服务变得更加容易。这里已经讨论了一个实现。
使用 TensorFlow Lite
移动和物联网设备也可用于部署 TensorFlow 模型。然而，这些设备具有诸如功耗和电池寿命的限制。TensorFlow 提供了一种方法，用于将最初训练的模型转换为它们的轻量级版本，这些版本可以部署在具有功率和处理约束的设备上。它是一个适用于 Android、iOS 和嵌入式系统的轻量级解决方案。
将 SavedModel 转换为较简单的格式。文档 : TFLite
使用 TensorFlowJS
TensorFlowJS 已经能够使用 NodeJS 在浏览器或服务器端直接使用机器学习。一旦保存了模型，就可以使用 TensorFlowJS 轻松地部署它。该模型首先被转换成 TensorFlowJS web 格式，然后被加载用于部署。
用于将 SavedModel 格式转换为 TensorFlow 的脚本。JS web 格式。文档 : 导入一个模型 TensorFlowJS
导入转换后的模型并将其用于预测。
结论
在 tf.keras 命名空间下整合不同的优化器、度量、损失函数和层之后，我能够在 TensorFlow 2 中编写更一致的代码。急切执行简化了调试。我现在可以使用 python 的标准 print 函数打印出来，而不是创建一个会话来获取张量的值。tf.function decorator 的加入使得使用标准 python 编写的函数能够通过 TensorFlow 进行性能优化。我可以使用 tf.distribute 提供的策略轻松调整我的模型的训练，而无需对代码进行重大更改。
此外， TensorFlow hub 允许我通过使用迁移学习来重用机器学习模型，从而加快训练过程。总的来说，TensorFlow 已经成长为一个开发者友好而强大的人工智能库。
探索新型冠状病毒的 R 包
冠状病毒(CoV)是一个大的病毒家族，可导致从普通感冒到更严重疾病的疾病，如中东呼吸综合征(MERS-CoV)和严重急性呼吸综合征(SARS-CoV)。一种新型冠状病毒(nCoV)是一种新的毒株，此前尚未在人类中发现。
最近发现南方医科大学生物信息学教授于广创的一篇博文，讲的是一个 R 包，里面包含了中国乃至全世界最新的 nCov 数据之一。在过去的几天里，我一直在把这个包从中文翻译成英文，以便让每个人都更容易理解。
*注:这篇博文是对于博士的原帖的尝试性英文翻译。我会在页面底部用中文链接他的博文。
第一部分—快速入门
首先，您可以通过在 R 中运行以下命令来轻松安装:
remotes::install_github("GuangchuangYu/nCov2019")
要获取最新数据，可以用get_nCov2019()载入。
**library**(nCov2019)
x <- get_nCov2019(lang='en')
确保您包含了参数lang='en'，否则，数据默认为中文(如果您能阅读中文，这没问题)。
如果打印数据，会显示中国确诊病例总数，以及最新更新时间:
> x
China (total confirmed cases): 40235
last update: 2020-02-10 15:12:35
此数据收集自腾讯，athttps://news.qq.com/zt2020/page/feiyan.htm，包含冠状病毒的最新公开信息之一。
全局数据
要查看全局数据，您可以运行代码x['global', ]:
> x['global', ]
name confirm suspect dead heal showRate deadRate healRate
1 China 40235 23589 909 3371 FALSE 2.26 8.38
2 Japan 96 0 0 1 FALSE 0.00 1.04
3 Singapore 43 0 0 2 FALSE 0.00 4.65
4 Thailand 32 0 0 8 FALSE 0.00 25.00
5 Republic of Korea 27 0 0 3 FALSE 0.00 11.11
6 Malaysia 18 0 0 3 FALSE 0.00 16.67
7 Australia 15 0 0 5 FALSE 0.00 33.33
8 Germany 14 0 0 0 FALSE 0.00 0.00
9 Vietnam 14 0 0 3 FALSE 0.00 21.43
10 United States USA 12 0 0 1 FALSE 0.00 8.33
11 France 11 0 0 0 FALSE 0.00 0.00
12 Canada 7 0 0 0 FALSE 0.00 0.00
13 United Arab Emirates 7 0 0 0 FALSE 0.00 0.00
14 United Kingdom 4 0 0 0 FALSE 0.00 0.00
15 Italy 3 0 0 0 FALSE 0.00 0.00
中国省市数据
因为数据来源主要集中在中国，你有能力真正深入挖掘中国的案例。比如你有能力看到四川某个城市确诊病例数。
通过x[]，您可以轻松查看中国各省的数据。
> x[]
name confirm suspect dead heal showRate deadRate healRate
1 Hubei 29631 0 871 1795 TRUE 2.94 6.06
2 Guangdong 1151 0 1 148 FALSE 0.09 12.86
3 Zhejiang 1092 0 0 215 FALSE 0.00 19.69
4 Henan 1073 0 6 181 FALSE 0.56 16.87
5 Hunan 879 0 1 201 FALSE 0.11 22.87
6 Anhui 830 0 3 89 FALSE 0.36 10.72
7 Jiangxi 771 0 1 102 FALSE 0.13 13.23
8 Jiangsu 492 0 0 80 FALSE 0.00 16.26
9 Chongqing 468 0 2 61 FALSE 0.43 13.03
10 Shandong 466 0 1 64 FALSE 0.21 13.73
11 Sichuan 405 0 1 79 FALSE 0.25 19.51
12 Beijing 337 0 2 44 FALSE 0.59 13.06
13 Heilongjiang 331 0 7 20 FALSE 2.11 6.04
14 Shanghai 299 0 1 48 FALSE 0.33 16.05
15 Fujian 261 0 0 36 FALSE 0.00 13.79
如果您想获得更精细的数据，您可以进入每个省，将数据分解到各个城市。例如，如果您想查看湖北省内的案例，您可以使用x[1,]或x['Hubei',]。
> x['Hubei', ] # replace Hubei with any province
name confirm suspect dead heal showRate deadRate healRate
1 Wuhan 16902 0 681 1044 TRUE 4.03 6.18
2 Xiaogan 2541 0 33 81 TRUE 1.30 3.19
3 Huanggang 2252 0 45 189 TRUE 2.00 8.39
4 Suizhou 1049 0 10 23 TRUE 0.95 2.19
5 Jingzhou 1045 0 15 46 TRUE 1.44 4.40
6 Xiangyang 1019 0 9 42 TRUE 0.88 4.12
7 Huangshi 805 0 3 67 TRUE 0.37 8.32
8 Yichang 749 0 8 43 TRUE 1.07 5.74
9 Ezhou 725 0 24 48 TRUE 3.31 6.62
10 Jingmen 641 0 20 63 TRUE 3.12 9.83
11 Xianning 507 0 4 44 TRUE 0.79 8.68
12 Shiyan 481 0 0 46 TRUE 0.00 9.56
13 Xiantao 416 0 7 16 TRUE 1.68 3.85
14 Tianmen 217 0 10 10 TRUE 4.61 4.61
15 Enshi 187 0 0 24 TRUE 0.00 12.83
当然，也可以将这些数据用于可视化。这里有一个安徽的例子。
library(forcats)
library(ggplot2)
d = x['Anhui',] # replace Anhui with any province
d$confirm=as.numeric(d$confirm)
d$name = fct_reorder(d$name, d$confirm)ggplot(d, aes(name, confirm)) +
geom_col(fill='steelblue') + coord_flip() +
geom_text(aes(y = confirm+2, label=confirm), hjust=0) +
theme_minimal(base_size=14) +
scale_y_continuous(expand=c(0,10)) +
xlab(NULL) + ylab(NULL)
每日数据
您已经在上面看到了如何获得总的累积数据，但是如果您有兴趣查看新添加的案例的数量呢？一种方法是使用参数by='today'。要查看中国所有省份新增的数量，您可以运行以下命令:
> head(x[by='today'], 10)
name confirm suspect dead heal isUpdated
1 Hubei 2618 0 0 0 TRUE
2 Guangdong 31 0 0 0 TRUE
3 Zhejiang 29 0 0 0 TRUE
4 Henan 40 0 0 0 TRUE
5 Hunan 41 0 0 0 TRUE
6 Anhui 51 0 0 0 TRUE
7 Jiangxi 32 0 0 0 TRUE
8 Jiangsu 24 0 0 0 TRUE
9 Chongqing 22 0 0 0 TRUE
10 Shandong 31 0 0 0 TRUE
类似地，要获得更细粒度的视图，您可以通过运行以下命令来获得数据:
> x['Hubei', by='today'] # replace Hubei with any province
name confirm suspect dead heal isUpdated
1 Wuhan 1921 0 0 0 TRUE
2 Xiaogan 105 0 0 0 TRUE
3 Huanggang 115 0 0 0 TRUE
4 Suizhou 65 0 0 0 TRUE
5 Jingzhou 48 0 0 0 TRUE
6 Xiangyang 57 0 0 0 TRUE
7 Huangshi 52 0 0 0 TRUE
8 Yichang 45 0 0 0 TRUE
9 Ezhou 89 0 0 0 TRUE
10 Jingmen 12 0 0 0 TRUE
11 Xianning 14 0 0 0 TRUE
12 Shiyan 14 0 0 0 TRUE
13 Xiantao 37 0 0 0 TRUE
14 Tianmen 20 0 0 0 TRUE
15 Enshi 21 0 0 0 TRUE
16 Qianjiang 3 0 0 0 TRUE
17 Shennongjia 0 0 0 0 TRUE
18 Location TBD 0 0 0 0 TRUE
*注:第二部分中关于每日/历史数据的更多细节。
每日数据摘要
要获得每日数据的累积摘要，可以使用x上的summary函数。
> summary(x)
confirm suspect dead heal deadRate healRate date
1 41 0 1 0 2.4 0.0 01.13
2 41 0 1 0 2.4 0.0 01.14
3 41 0 2 5 4.9 12.2 01.15
4 45 0 2 8 4.4 17.8 01.16
5 62 0 2 12 3.2 19.4 01.17
6 198 0 3 17 1.5 8.6 01.18
7 275 0 4 18 1.5 6.5 01.19
8 291 54 6 25 2.1 8.6 01.20
9 440 37 9 25 2.0 5.7 01.21
10 571 393 17 25 3.0 4.4 01.22
11 830 1072 25 34 3.0 4.1 01.23
12 1287 1965 41 38 3.2 3.0 01.24
13 1975 2684 56 49 2.8 2.5 01.25
14 2744 5794 80 51 2.9 1.9 01.26
15 4515 6973 106 60 2.3 1.3 01.27
类似地，如果您想查看新的每日案例，您可以使用today参数:
> summary(x, by="today")
confirm suspect dead heal deadRate healRate date
1 77 27 0 0 0.0 0.0 01.20
2 149 53 3 0 2.0 0.0 01.21
3 131 257 8 0 6.1 0.0 01.22
4 259 680 8 6 3.1 2.3 01.23
5 444 1118 16 3 3.6 0.7 01.24
6 688 1309 15 11 2.2 1.6 01.25
7 769 3806 24 2 3.1 0.3 01.26
8 1771 2077 26 9 1.5 0.5 01.27
9 1459 3248 26 43 1.8 2.9 01.28
10 1737 4148 38 21 2.2 1.2 01.29
11 1982 4812 43 47 2.2 2.4 01.30
12 2102 5019 46 72 2.2 3.4 01.31
13 2590 4562 45 85 1.7 3.3 02.01
14 2829 5173 57 147 2.0 5.2 02.02
15 3235 5072 64 157 2.0 4.9 02.03
如果您想要可视化累积汇总数据，示例图如下:
library(ggplot2)
ggplot(summary(x), aes(as.Date(date, "%m.%d"), as.numeric(confirm))) +
geom_col(fill='firebrick') + theme_minimal(base_size = 14) +
xlab(NULL) + ylab(NULL) +
labs(caption = paste("accessed date:", time(x)))
第二部分—历史数据
第一部分只能显示最新的数据，但大多数人真正关心的是每天的历史数据。
如果要分析一些详细的历史数据怎么办？不要害怕， *load_nCov2019()* 是来救援的。
> x <- load_nCov2019(lang='en')
> x
nCov2019 historical data
last update: 2020-02-07
同样，如果你想使用中文版本，你可以删除lang='en'的说法。
注:该数据仅包含中国的病例。不幸的是，您将无法获得全球历史数据。
中国的历史数据
使用与get_nCov2019()相同的方法，我们可以使用[查询所有省级明细数据。
> head(x[][c(1:6, 9:11)])
province city time cum_confirm cum_heal cum_dead confirm dead heal
1 Shanghai Shanghai 2020-02-08 292 41 1 NA
2 Yunnan Yunnan 2020-02-08 140 17 0 NA
3 Yunnan Kunming 2020-02-08 41 6 0 NA
4 Yunnan Xishuangbanna 2020-02-08 15 2 0 NA
5 Yunnan Yuxi 2020-02-08 14 2 0 NA
6 Yunnan Zhaotong 2020-02-08 12 1 0 NA
我们可以只选择累积的和新添加的数据。相关列是province, city, time, cum_confirm, cum_heal, cum_dead, confirm, dead, heal，所以x['Hubei', c(1:6,9:11)]就足够了。
中国各省市的详细信息
与上面类似，如果您想更深入地获取特定于省份的数据，那么您只需要包括省份名称:
> head(x['Hubei', c(1:6, 9:11)]) # replace Hubei with any province
province city time cum_confirm cum_heal cum_dead confirm dead heal
250 Hubei Wuhan 2020-02-08 14982 877 608 NA
251 Hubei Xiaogan 2020-02-08 2436 45 29 NA
252 Hubei Huanggang 2020-02-08 2141 137 43 NA
253 Hubei Jingzhou 2020-02-08 997 34 13 NA
254 Hubei Xiangyang 2020-02-08 988 40 7 NA
255 Hubei Suizhou 2020-02-08 984 23 9 NA
如果您想更深入地挖掘特定于城市的数据，那么您可以在省内指定一个city。例如，如果您想查看武汉的数据，您可以执行以下操作:
> head(subset(x['Hubei',], city == "Wuhan"))[c(1:6, 9:11)]
province city time cum_confirm cum_heal cum_dead confirm dead heal
250 Hubei Wuhan 2020-02-08 14982 877 608 NA
612 Hubei Wuhan 2020-02-07 13603 698 545 NA
972 Hubei Wuhan 2020-02-06 11618 535 478 NA
1084 Hubei Wuhan 2020-02-05 10117 432 414 NA
1464 Hubei Wuhan 2020-02-04 8351 369 362 1967 49 65
1976 Hubei Wuhan 2020-02-03 6384 303 313 1242 48 79
然后，您可以将这些数据用于可视化。例如:
library(ggplot2)
require(ggrepel)d <- x['Anhui',] # replace Anhui with any provinceggplot(d, aes(time, as.numeric(cum_confirm), group=city, color=city)) +
geom_point() + geom_line() +
geom_text_repel(aes(label=city), data=d[d$time == time(x), ], hjust=1) +
theme_minimal(base_size = 14) + theme(legend.position='none') +
xlab(NULL) + ylab(NULL)
中国的汇总结果
与get_nCov2019()类似，您也可以对数据调用summary()函数。
> head(summary(x)[,1:5])
province time cum_confirm cum_heal cum_dead
1 Shanghai 2020-02-07 281 30 1
2 Yunnan 2020-02-07 138 12 0
17 Inner Mongolia 2020-02-07 52 5 0
29 Beijing 2020-02-07 315 34 2
30 Taiwan 2020-02-07 16 1 0
31 Jilin 2020-02-07 69 4 1
如果您想查看特定省份的汇总，您只需将省份名称添加到summary中，如下所示:
> summary(x, 'Hubei')[,1:5]
province time cum_confirm cum_heal cum_dead
251 Hubei 2020-02-07 24953 1119 699
611 Hubei 2020-02-06 22112 818 618
723 Hubei 2020-02-05 19665 651 549
1103 Hubei 2020-02-04 16678 520 479
1615 Hubei 2020-02-03 13522 396 414
1792 Hubei 2020-02-02 11177 295 350
2325 Hubei 2020-02-01 9074 215 294
2482 Hubei 2020-01-31 7153 166 249
2820 Hubei 2020-01-30 5806 116 204
3452 Hubei 2020-01-29 4586 90 162
3673 Hubei 2020-01-28 3554 80 125
3803 Hubei 2020-01-27 2714 47 100
4225 Hubei 2020-01-26 1423 44 76
4488 Hubei 2020-01-25 1052 42 52
4710 Hubei 2020-01-24 729 32 39
这是另一个快速可视化的例子:
ggplot(summary(x, 'Hubei'), aes(time, as.numeric(cum_confirm))) +
geom_col()# or city-specific
# ggplot(subset(x['Hubei',], city == "Huanggang"), aes(time, as.numeric(cum_confirm))) + geom_col()
第三部分—地图绘制
世界地图
得到世界地图的一个情节真的很简单。只需要三行代码:
require(nCov2019)
x = get_nCov2019(lang='en')
plot(x)
如你所见，与其他地方相比，中国确诊病例的数量高得吓人。你现在可能会想，有没有一种方法可以分解中国的案例？当然可以，但是你必须先安装chinamap，才能得到中国地图。
remotes::install_github("GuangchuangYu/chinamap")
安装后，您可以运行以下代码来查看中国各地的确诊病例。
require(chinamap)cn = get_map_china()
## translate province
cn$province <- trans_province(cn$province)plot(x, chinamap=cn)
*注意:为了给中国着色，省份必须如上翻译。
如果红色不适合你，你可以使用palette参数随意改变它:
plot(x, chinamap=cn, palette="Purples")
中国地图
为了更好地了解中国的情况，你可以在情节中添加一个region = ‘china'参数。我建议使用font.size=2,这样省的文本就不会太大。
plot(x, region='china', chinamap=cn, font.size=2)
如果到目前为止你已经看完了所有的内容，非常感谢！这是我的第一篇博客，但绝对不是最后一篇。如果你正在寻找余博士的中文帖子，我会在本页底部链接它们。
任何评论、问题或总体反馈总是。请随时通过我的LinkedIn联系我。
Thank you Dr. Yu for the package, as well as allowing me to contribute. And special thanks to Tencent and 新一线城市研究所×8 点健闻 for making the data available in the first place.
于博士文章的链接:
VADER 简介
对我在 Spotify 上播放最多的歌曲进行半监督情感分析。
答几周前，我写了一篇文章，讲述如何通过几行代码获得任何 Spotify 播放列表的歌词。在过去的两年里，Spotify 进行了一场聪明的营销活动，它编辑了一份年度最佳 100 首歌曲的播放列表。这通常会在社交媒体上传播，因为人们会分享他们在过去 365 天里在淋浴时摇头晃脑和唱歌的内容。我认为这将是我尝试一些半监督情绪分析的完美播放列表，同时希望发现一些关于我自己的收听习惯的有趣事实。
nltk .情操.维德
价觉词典和情感推理机(VADER)
它是什么。
VADER 是nltk.sentiment Python 库中的一个模块，它是专门为处理社交媒体环境中产生的文本而创建的，然而，它当然也可以处理源自其他上下文的语言。当被分析的数据未被标注时，VADER 能够检测出给定文本的情感极性(积极或消极)。在传统的情感分析中，算法有机会从标记的训练数据中学习。一个经典的例子是根据给定评论家的书面评论来预测电影评论的星级。星级将是目标变量，文本将是预测变量。
在歌词的情感分析中，我们没有任何标签。歌词没有按 0 到 10 分(0 为负面，10 为正面)评分。那么，VADER 如何判断市场情绪呢？
VADER 使用情感相关词汇词典来确定给定文本的整体情感。下面是词典结构的一个例子，每个单词都有一个配价等级:
VADER 利用亚马逊的机械土耳其人(Mechanical Turk)建立了这个标签化的词典，这是一个众包平台，向“众包工作者”支付报酬，让他们一起完成任务，从而产生了一种令人印象深刻的高效方法。
预处理。没有。
VADER 令人难以置信的是，它不需要大量的预处理工作。与 NLP 的一些有监督的方法不同，不需要预处理，例如记号化和词干化/词尾化。你几乎可以插入任何文本，它将决定情绪。
VADER 甚至聪明到能够理解非常规文本的化合价，包括表情符号(即:-()、大写(即 sad vs SAD)和扩展标点符号(即？vs？？？).这就是该模块如此擅长分析社交媒体文本的原因。此外，VADER 删除停止字自动，所以没有必要这样做你自己。
与 VADER 合作
我们可以在命令行中使用pip install nltk在我们的设备上安装这个库。然后，我们需要使用下面截取的第一行代码将 VADER 导入到我们的编程环境中。
然后，我们可以初始化情感分析对象，并使用polarity_scores()方法来确定字符串的情感。其输出是四个标准化的分数:
- { ’ neu ':0–1 }—陈述的中立程度。
- { ’ neg ':0–1 }—陈述的负面程度。
- { ’ pos ':0–1 }—陈述的积极程度。
- { ’ compound ':-1–1 }—陈述的总体情绪。
我的 2019 音乐品味
我们开始吧。在我去年播放最多的 100 首歌曲中，有 66 首歌词是我用我在之前的一篇文章中概述的方法获得的(我的音乐库中有很大一部分是电子版的，没有歌词元素)。
下面的图表显示了每首歌歌词中积极和消极的“数量”。积极情绪多于消极情绪的歌曲会有一个正的复合分数，因此会有积极的情绪，反之亦然。
令我惊讶的是，45 首(68%)歌曲被认为是积极向上的。在进行这种分析时，我预计我的大多数歌曲都会有负面情绪。
这很可能是因为一首歌的歌词显然没有描绘出全貌。例如，对“爱”有强烈感情的句子可能看起来是积极的，然而，在它们后面有悲伤的旋律，它们可能会坚定地属于悲伤的情歌类别。
展望未来，看看这些年来我的听力习惯是如何改变的会很有趣。不幸的是，Spotify 只向用户提供了过去两年中播放次数最多的 100 首歌曲的播放列表，但当有更多数据可用时，我认为可以进行一些有趣的分析。尤其是如果 Spotify 将自己对歌曲的评级包括在内，比如通过其 API 提供的“可跳舞性”和“活力”。
谢谢你读到这里！我希望您喜欢这个关于 VADER 的简短介绍，并可以继续在您自己的数据集上尝试它。我很想听听你在评论里想说些什么。如果你想直接联系我，请在 LinkedIn上给我留言。
Numpy 的终极备忘单
由 Unsplash 上的 Pietro Jeng 拍摄
日常工作所需的所有 Numpy 功能
Numpy 是一个开源的 Python 库。这个库对于使用 python 的数据科学家来说是必不可少的。其他一些重要的库，如 Pandas、Scipy，都是在 Numpy 库的基础上构建的。所以我决定做一个小抄。在这里，我包含了迄今为止我使用过的所有 Numpy 函数。我相信这些功能足以满足您作为数据科学家或数据分析师的日常工作需求。
我将从最基本的 Numpy 函数开始，慢慢向更高级的函数发展。但是使用 Numpy 很容易。你在这里找不到任何复杂的编码技巧。
Numpy 是什么？
在 Numpy 文档中，Numpy 是这样定义的:
NumPy 是 Python 中科学计算的基础包。这是一个 Python 库，它提供了一个多维数组对象、各种派生对象(如掩码数组和矩阵)以及一系列对数组进行快速操作的例程，包括数学、逻辑、形状操作、排序、选择、I/O、离散傅立叶变换、基本线性代数、基本统计操作、随机模拟等等。
我每天都使用这个图书馆。如果是 python 用户，大多数数据科学家都会这么做。它快速、易用、易懂、简单。我不想写太多关于它如何以及为什么这么好。因为当你阅读这篇文章的时候，你会亲眼看到。
我的目标是记录 Numpy 每天使用的方法。
如题，是 Numpy 指南。它也可以用作备忘单。如果您正在使用 Numpy 库，或者计划在将来使用，或者试图学习，这个页面可以成为您日常生活的一个很好的资源。
这些是这里将要涉及的主题:
- Numpy 数组基础
- 重复
- 数学
- 统计数字
- 初始化不同类型的数组
- 重新排列或重组数组
- 数组的索引和切片
- 添加行或列
- 追加、插入、删除和排序
- 随意
- 文件导入、保存和加载
开始吧！！
Numpy 数组基础
这部分是
我在整个练习中使用了一个 Jupyter 笔记本。第一个导入数字。
import numpy as np
制作一个 Numpy 数组。为此，我们需要传递一个 Python 列表。
输入:
a = np.array([1,2,3])
a
输出:
array([1, 2, 3])
在数组 a 中，我使用了所有的整数。现在，制作一个浮点数组:
输入:
b = np.array([[9.0, 10.0, 6.0], [6.0,1.0,7.0]])
b
输出:
array([[ 9., 10., 6.],
[ 6., 1., 7.]])
让我们试着做一个既有整型又有浮点型的数组:
输入:
np.array([1, 3.0, 0.004, -2])
输出:
array([ 1\. , 3\. , 0.004, -2\. ])
注意，Numpy 自动将整数转换成浮点数！
找出数组 a 和 b 的维数:
输入:
a.ndim
输出:
1
输入:
b.ndim
输出:
2
数组“a”是一维数组，数组 b 是二维数组。
现在，找出数组‘a’和‘b’的形状:
输入:
a.shape
输出:
(3,)
输入:
b.shape
输出:
(2, 3)
数组“a”是一维数组。所以，它在形状上只有一个值。但是数组“b”是一个二维数组。所以，它的形状是 2 x 3。这意味着它有 2 行 3 列。
求数组的长度:
输入:
len(a)
输出:
3
输入:
len(b)
输出:
2
数组“a”的长度为 3，因为它包含 3 个元素。数组“b”是一个二维数组。所以，数组的长度并不意味着数组中元素的数量。长度是指其中一维数组的个数或其中的行数。它有两排。所以，长度是 2。
重复
有几种不同的方法来重复数组的元素。如果你想重复整个数组，
输入:
np.array([2,4,6]*4)
输出:
array([2, 4, 6, 2, 4, 6, 2, 4, 6, 2, 4, 6])
看，数组[2，4，6]重复了 4 次。
这里是如何做元素方面的重复，
输入:
np.repeat([1,2,3], 3)
输出:
array([1, 1, 1, 2, 2, 2, 3, 3, 3])
这次每个元素重复 3 次。
让我们用这个来表示一个二维数组，
输入:
arr = np.array([[2, 4, 6]])
arr
输出:
array([[2, 4, 6]])
现在，对它重复使用:
输入:
np.repeat(arr,3,axis=0)
输出:
array([[2, 4, 6],
[2, 4, 6],
[2, 4, 6]])
这里，我们提到了轴= 0。因此，重复发生在轴 0 方向或行方向。
输入:
np.repeat(arr,3,axis=1)
输出:
array([[2, 2, 2, 4, 4, 4, 6, 6, 6]])
轴 1 表示列的方向。因此，重复发生在列的方向。
数学
在这一部分，我将展示数学运算。大多数操作都是不言自明的。我将从一个数组的数学运算开始。
输入:
a = np.array([1,2,3,4])
a
输出:
array([1, 2, 3, 4])
输入:
a+2
输出:
array([3, 4, 5, 6])
它给数组的每个元素加 2。
输入:
a-2
输出:
array([-1, 0, 1, 2])
您可以简单地以这种方式使用类似的操作，例如:
输入:
a/2
输出:
array([0.5, 1\. , 1.5, 2\. ])
输入:
a**2
输出:
array([ 1, 4, 9, 16], dtype=int32)
两个星号表示指数。a 中的每个元素都是平方的。
输入:
np.sqrt(a) #square root
输出:
array([1\. , 1.41421356, 1.73205081, 2\. ])
我们还可以执行一些三角运算:
输入:
np.cos(a)
输出:
array([ 0.54030231, -0.41614684, -0.9899925 , -0.65364362])
输入:
np.sin(a)
输出:
array([ 0.84147098, 0.90929743, 0.14112001, -0.7568025 ])
输入:
np.tan(a)
输出:
array([ 1.55740772, -2.18503986, -0.14254654, 1.15782128])
现在看看我们如何在两个数组或矩阵中做一些数学运算。首先，再做一个数组，
输入:
b = np.array([3,4,5,6])
输出:
array([3, 4, 5, 6])
提醒一下，我们的数组“a”是这样的:
array([1, 2, 3, 4])
现在，我们有两个数组，a 和 b。让我们做同样的数学运算。同样，它简单明了，
输入:
a + b
输出:
array([ 4, 6, 8, 10])
同样，您可以执行以下操作:
a - b
a*b
a/b
a**b
另一个广泛使用的操作是，
输入:
a.dot(b)
输出:
50
什么是 a.dot(b)？它是逐元素的乘法，然后像这样加法，
1*3 + 2*4 + 3*5 + 4*6
其中数组“a”是[1，2，3，4]，数组 b 是[3，4，5，6]。
您也可以编写稍微不同的语法，
np.dot(a, b)
这是一样的。输出将是 50。
我们可以在多维数组中使用这种点过程。让我们做两个多维数组，
输入:
c = np.array([[3, 5, 1], [6, 4, 9]])
c
输出:
array([[3, 5, 1],
[6, 4, 9]])
输入:
d = np.array([[5,2], [7,9], [4, 3]])
d
输出:
array([[5, 2],
[7, 9],
[4, 3]])
我们准备对多维数组进行“点”操作，
输入:
c.dot(d)
输出:
array([[54, 54],
[94, 75]])
当输入为 2D 阵列时，“点”函数的行为类似于矩阵乘法。
这意味着只有当第一个数组的列数与第二个数组的行数匹配时，才能执行“点”操作。
如果第一个数组是 m x n，第二个数组应该是 n x p。
矩阵乘法有另一种表达方式，
输入:
np.matmul(c, d)
输出:
array([[54, 54],
[94, 75]])
‘NP . mat mul’在一维数组中不起作用
记住，这个乘法法则不适用于其他运算，如加、减或除。我们需要相同形状和大小的数组来对一个矩阵进行加法、减法或除法运算。
统计数字
Numpy 也有基本的统计操作。这里有一些例子。
先做一个新的数组。
输入:
x = np.array([1,3,4,6,-3,-2])
x.sum()
输出:
9
输入:
x.max()
输出:
6
输入:
x.min()
输出:
-3
输入:
x.mean()
输出:
1.5
输入:
x.std() #standard deviation
输出:
3.2015621187164243
还有另外两个非常有用的函数，它们不完全是统计函数，
输入:
x.argmin()
输出:
4
输入:
x.argmax()
输出:
3
什么’ argmin()‘或者’ argmax()'？
“argmin()”给出数组最小元素的索引，“argmax()”返回数组最大值的索引。
数组“x”的最小元素是-3，最大元素是 6。现在检查他们的索引是否与结果匹配。
初始化不同类型的数组
Numpy 中有很多不同的方法来初始化一个数组。在这里我将讨论一些常用的方法:
输入:
np.arange(10)
输出:
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
这是初始化数字序列的方法。注意它从 0 开始，到 9 结束。上限始终被排除在外。这里的上限是 10。所以，它停在 9 点。
我们还可以给它添加一个数学运算:
输入:
np.arange(10)**2
输出:
array([ 0, 1, 4, 9, 16, 25, 36, 49, 64, 81], dtype=int32)
在这种情况下，我们要求 10 平方的范围，我们在输出数组中得到 0 到 9 的平方。
我们可以按一定的间隔排列数列。
np.arange(0, 15, 3)
输出:
array([ 0, 3, 6, 9, 12])
这里，0 是下限，15 是上限，3 是区间。
另一种方法给出的序列稍有不同:
输入:
np.linspace(0, 3, 15)
输出:
array([0\. , 0.21428571, 0.42857143, 0.64285714, 0.85714286,
1.07142857, 1.28571429, 1.5 , 1.71428571, 1.92857143,
2.14285714, 2.35714286, 2.57142857, 2.78571429, 3\. ])
这里，0 是下限，3 是上限，15 是元素数。在这种情况下，Numpy 自动生成 15 个从 0 到 3 等间距的元素。
还有一些其他类型的数组:
输入:
np.ones((3, 4))
输出:
array([[1., 1., 1., 1.],
[1., 1., 1., 1.],
[1., 1., 1., 1.]])
输入:
np.zeros((2, 3))
输出:
array([[0., 0., 0.],
[0., 0., 0.]])
你可以启动一个三维数组:
输入:
np.ones((4,3,2), dtype='int32')
输出:
array([[[1, 1],
[1, 1],
[1, 1]],[[1, 1],
[1, 1],
[1, 1]],[[1, 1],
[1, 1],
[1, 1]],[[1, 1],
[1, 1],
[1, 1]]])
这里，(4，3，2)表示 4 个二维数组，每个数组有 3 行 2 列。
输入:
np.full((2,2), 30)
输出:
array([[30, 30],
[30, 30]])
还有另一个名为 full_like 的方法可以替换数组中的元素:
输入:
ar = np.array([[2,3], [4,5]])
ar
输出:
array([[2, 3],
[4, 5]])
输入:
np.full_like(ar, 4)
输出:
array([[4, 4],
[4, 4]])
还有另一种称为单位矩阵的矩阵:
输入:
np.identity(5)
输出:
array([[1., 0., 0., 0., 0.],
[0., 1., 0., 0., 0.],
[0., 0., 1., 0., 0.],
[0., 0., 0., 1., 0.],
[0., 0., 0., 0., 1.]])
这是一个 5 乘 5 的矩阵，其中所有的元素都是 0，只有对角元素是 1。
还有一种叫做“眼睛”。它呈矩阵状:
输入:
np.eye(3,3)
输出:
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])
输入:
np.eye(3,4)
输出:
array([[1., 0., 0., 0.],
[0., 1., 0., 0.],
[0., 0., 1., 0.]])
这些对角线数可以不同于 1。
输入:
a = np.array([2,4,5])
np.diag(a)
输出:
array([[2, 0, 0],
[0, 4, 0],
[0, 0, 5]])
重新排列或重组数组
有不同的方法来重新排列或调整一个数组。
我们来举例学习一下。首先，做一个数组，
输入:
x = np.arange(0, 45, 3)
x
输出:
array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])
我在上一节解释了“arange”函数。让我们看看如何重塑它。
输入:
x.reshape(3, 5)
输出:
array([[ 0, 3, 6, 9, 12],
[15, 18, 21, 24, 27],
[30, 33, 36, 39, 42]])
我们通过了(3，5)。所以，它变成了一个有 3 行 5 列的二维数组。我们可以通过以下方式实现同样的目标:
x.resize(3,5)
如果我们想回到原来的一维数组呢？
方法是这样的，
输入:
x.ravel()
输出:
array([ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 30, 33, 36, 39, 42])
看，我们找回了原来的数组！
注意另一件事。也就是说我们改变了数组的维度。数组“x”是一维数组。我们通过重塑使它成为一个二维数组。
现在，制作另一个数组来更好地理解它。这是另一个例子。
输入:
c = np.array([4,5,6])
c
输出:
array([4, 5, 6])
这次我将使用 resize。重塑也是如此。为了练习调整大小，让我们在这里使用 resize。
输入:
c.resize(3,1)
输出:
array([[4],
[5],
[6]])
看，我们提供(3，1)作为调整大小的参数。所以它有 3 行 1 列。这是一个 3x1 的矩阵。我们也可以有一个 1×3 的矩阵。
输入:
c.resize(1,3)
c
输出:
array([[4, 5, 6]])
原来 c 是一个一维数组。现在它是一个二维数组或矩阵。
不要认为你只能改变一维数组的形状。你也可以在一个更高维的数组中这样做。
这里我有一些例子:
输入:
x = np.array([[1,2,3,4], [5,6,7,8]])
x
输出:
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
现在重塑这个二维数组，
输入:
x.reshape(4,2)
x
输出:
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
你可以用我之前提到的“调整大小”来实现。还有另一种方法，
输入:
y = x.reshape(4, -1)
y
输出:
array([[1, 2],
[3, 4],
[5, 6],
[7, 8]])
看起来很困惑？想象一下，你有一个巨大的数组或数据集。在重塑之前，你只知道一个维度。因此，在 reshape 方法中，传递一个维度，对另一个维度使用-1。这样 Numpy 自己就能找到另一个维度。
在上面的例子中，我传递了第一个维度 4。这意味着我告诉 Numpy 做 4 行。我不知道列数。所以我就在那里过了-1。因此，它自动知道要制作 2 列。
当我们处理大型数据集或数据帧，并且必须构建机器学习算法时，这是一个非常有用的技巧。
在上面所有的例子中，我们看到了如何重塑和改变尺寸。
这是改变维度的方法。上面的数组“y”是一个 4x2 的矩阵。我们再做一个 2×4 的矩阵。
输入:
y.T
输出:
array([[1, 3, 5, 7],
[2, 4, 6, 8]])
这种方法被称为转置。当你在一个数组或矩阵上使用转置时，它只是改变了维度。2×3 矩阵变成 3×2，3×6 矩阵变成 6×3 或者 1×3 矩阵变成 3×1。
索引或切片
索引和切片是一项非常常见的日常任务。让我们来看几个例子:
输入:
a = np.array([2,5,1,7,6,3,9,0,4])
输入:
a[0]
输出:
2
a[0]给出数组的第一个元素。同样，我们可以从 a[1]，a[2]，一直到整个数组。
输入:
a[3]
输出:
7
我们也可以切一片，
输入:
a[1:5]
输出:
array([5, 1, 7, 6])
这就是解释。我们通过了[1:5]。因此，切片将从索引 1 开始，在索引 5 之前结束。记住，下界包含，上界排除。
在本文中，我不会深入探讨切片和索引。因为我已经写了另一篇文章详细解释了它。请检查。学好它很重要。
[## Numpy 中 1D、2D 和 3D 数组的索引和切片
本文从基础到高级展示了 Numpy 数组的索引和切片。
towardsdatascience.com](/indexing-and-slicing-of-1d-2d-and-3d-arrays-in-numpy-e731afff0bbe)
添加行或列
Numpy 有几种不同的方法来添加行或列。首先，我将开始一些堆叠技术。这里有一些例子。
这次我将使用一些列表或数组。Numpy 会在堆叠的时候自动把它们变成数组。
这里有两个列表:
x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [1, 0, 9, 5]
现在把它们垂直堆叠起来。
输入:
np.vstack([x1, x2])
输出:
array([[2, 4, 3, 7],
[2, 5, 3, 1],
[1, 0, 9, 5]])
你想叠多少次都可以。
输入:
np.vstack([x1, x2, x2])
输出:
array([[2, 4, 3, 7],
[2, 5, 3, 1],
[1, 0, 9, 5],
[1, 0, 9, 5]])
让我们做一些水平堆叠。我们需要行数相同的数组。
“x1”有 2 行。用它做一个数组。
输入:
np.array(x1)
输出:
array([[2, 4, 3, 7],
[2, 5, 3, 1]])
制作另一个数组“x3”。
输入:
x3 = np.ones((2,3))
x3
输出:
array([[1., 1., 1.],
[1., 1., 1.]])
水平堆叠的时间到了。
输入:
np.hstack([x1, x3])
输出:
array([[2., 4., 3., 7., 1., 1., 1.],
[2., 5., 3., 1., 1., 1., 1.]])
串联
添加列或行的另一种方式。但是与堆叠相反，这次我们需要两个相同维度的数组。记住，当我们做垂直堆叠时，我们有一个二维和一维列表。
这是我在这个例子中的两个列表。
x1 = [[2, 4, 3, 7], [2, 5, 3, 1]]
x2 = [[1, 0, 9, 5]]
串联操作，
输入:
np.concatenate((x1, x2), axis=0)
输出:
array([[2, 4, 3, 7],
[2, 5, 3, 1],
[1, 0, 9, 5]])
现在，水平连接。但是我们需要两个行数相同的数组。
x3 = [[2,4], [7,5]]
连接 x1 和 x3。
输入:
np.concatenate((x1, x3), axis=1)
输出:
array([[2, 4, 3, 7, 2, 4],
[2, 5, 3, 1, 7, 5]])
追加、插入、删除和排序
你可能知道这些操作的名字。
追加
输入:
np.append([2,3], [[4,5], [1, 3]])
输出:
array([2, 3, 4, 5, 1, 3])
输入:
np.append([2, 3, 1], [[4, 5], [1,3]])
输出:
array([2, 3, 1, 4, 5, 1, 3])
在这些例子中，我们没有提到任何轴。所以，默认情况下，他们取轴 1 或列方向或水平方向。现在，做一个垂直方向的附加操作。
输入:
np.append([[1,3,5], [4,3,6]], [[1,2,3]], axis=0)
输出:
array([[1, 3, 5],
[4, 3, 6],
[1, 2, 3]])
插入
这次我们将在某个位置插入一个元素。从新数组开始。
输入:
a = np.array([[2, 2], [3, 4], [5, 6]])
a
输出:
array([[2, 2],
[3, 4],
[5, 6]])
在数组的开头插入元素 5。
输入:
np.insert(a, 0, 5)
输出:
array([5, 2, 2, 3, 4, 5, 6])
首先，了解输入。在(a，0，5)中，a 是数组，0 是我们想要插入元素的位置，5 是要插入的元素。
注意，插入是如何发生的。首先，二维数组“a”被展平为一维数组。然后在索引 0 处添加 5。
我们也可以沿轴插入。
输入:
np.insert(a, 0, 5, axis=1)
输出:
array([[5, 2, 2],
[5, 3, 4],
[5, 5, 6]])
看，一列 5 被添加到数组“a”中。我们也可以添加一排 5。
输入:
np.insert(a, 0, 5, axis=0)
输出:
array([[5, 5],
[2, 2],
[3, 4],
[5, 6]])
删除
我会像以前一样做一个新的数组。
输入:
a= np.array([[1,3,2,6], [4,1,6,7], [9, 10, 6, 3]])
a
输出:
array([[ 1, 3, 2, 6],
[ 4, 1, 6, 7],
[ 9, 10, 6, 3]])
输入:
np.delete(a, [1, 2, 5])
输出:
array([ 1, 6, 4, 6, 7, 9, 10, 6, 3])
像插入操作一样，删除操作也会展平数组。在输入[1，2，5]中是我们想要删除的索引列表。为了看清楚，让我们把原来的数组‘a’展平。
输入:
a.flatten()
输出:
array([ 1, 3, 2, 6, 4, 1, 6, 7, 9, 10, 6, 3])
现在检查一下，索引 1、2 和 5 的元素被删除了。
像插入一样，我们可以删除特定的行或列。
删除列索引 1。
输入:
np.delete(a, 1, 1)
输出:
array([[1, 2, 6],
[4, 6, 7],
[9, 6, 3]])
在输入(a，1，1)中，a 是数组，1 是我们要删除的列的索引，最后一个 1 是轴。
输入:
np.delete(a, 1, 0)
输出:
array([[ 1, 3, 2, 6],
[ 9, 10, 6, 3]])
排序
这里是数组“a”:
array([[ 1, 3, 2, 6],
[ 4, 1, 6, 7],
[ 9, 10, 6, 3]])
输入:
np.sort(a)
输出:
array([[ 1, 2, 3, 6],
[ 1, 4, 6, 7],
[ 3, 6, 9, 10]])
看，它是双向分类的。我们可以指定轴并在特定的轴上排序。
输入:
np.sort(a, axis=None)
输出:
array([ 1, 1, 2, 3, 3, 4, 6, 6, 6, 7, 9, 10])
当坐标轴为 None 时，它将数组展平并排序。现在，在 0 轴和 1 轴排序。
输入:
np.sort(a, axis=0)
输出:
array([[ 1, 1, 2, 3],
[ 4, 3, 6, 6],
[ 9, 10, 6, 7]])
输入:
np.sort(a, axis=1)
输出:
array([[ 1, 2, 3, 6],
[ 1, 4, 6, 7],
[ 3, 6, 9, 10]])
翻转
听起来确实如此。翻转数组和行。
这是一个数组。
arr
输出:
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
现在，在轴 0 和 1 的方向翻转这个数组。
输入:
np.flip(arr, 0)
输出:
array([[ 9, 10, 11, 12],
[ 5, 6, 7, 8],
[ 1, 2, 3, 4]])
输入:
np.flip(arr, 1)
输出:
array([[ 4, 3, 2, 1],
[ 8, 7, 6, 5],
[12, 11, 10, 9]])
随意
Numpy 拥有优秀的随机数生成功能。它们在机器学习、研究或统计中非常有用。这里有一些例子。
输入:
np.random.rand()
输出:
0.541670003513435
它生成一个 0 到 1 之间的数字。我们可以像这样从随机数中得到一个数组或矩阵。
输入:
np.random.rand(3)
输出:
array([0.6432591 , 0.78715203, 0.81071309])
输入:
np.random.rand(2, 3)
输出:
array([[0.91757316, 0.74438045, 0.85259742],
[0.19826903, 0.84990728, 0.48328816]])
它不一定是从 0 到 1 的数字。我们可以生成随机整数。
输入:
np.random.randint(25)
输出:
20
它产生一个 0 到 25 之间的随机数。我们可以指定想要生成多少个数字。
输入:
np.random.randint(1, 100, 10)
输出:
array([96, 44, 90, 13, 47, 16, 9, 46, 49, 20])
这里，我们要求 Numpy 生成 1 到 100 范围内的 10 个数字。
现在，生成一个范围为 1 到 100 的 3x3 矩阵。
输入:
np.random.randint(1, 100, (3,3))
输出:
array([[25, 80, 42],
[95, 82, 66],
[64, 95, 55]])
您可以提供一个数组，并要求 Numpy 使用您提供的数组中的数字制作一个 3x3 的矩阵，而不是一个范围。
输入:
np.random.choice([1,2,3,4,5,6,7,8,9,10], size=(3,3))
输出:
array([[ 7, 9, 2],
[ 6, 4, 6],
[ 3, 10, 6]])
另一个有用的功能是“随机播放”。让我们做一个新的数组，然后洗牌。
输入:
a = np.array([3,6,3,1,0, 11])
np.random.shuffle(a)
a
输出:
array([ 3, 0, 6, 3, 11, 1])
看，我们有相同的元素，只是洗牌后重新排列。
保存、加载和导入文件
我们可以将数组“arr”保存在一个文件中。
输入:
np.save('arrfile', arr)
这里，我们创建一个名为“arrfile”的文件来保存数组“arr”。该文件将以扩展名’保存。npy。
我们可以加载该文件，并带回来进一步使用这样的数组，
输入:
np.load('arrfile.npy')
输出:
array([[ 1, 2, 3, 4],
[ 5, 6, 7, 8],
[ 9, 10, 11, 12]])
我们可以使用 Numpy 作为数组导入 CSV 文件或文本文件。我有一个名为“Cartwheeldata.csv”的文件，与我处理这些示例的 Jupyter 笔记本放在同一个文件夹中。现在，将文件导入到这里。
输入:
filedata = np.genfromtxt('Cartwheeldata.csv', delimiter=',')
filedata=filedata.astype('int32')
filedata
输出:
我在这里展示了数组的一部分。因为文件很大。这是那个文件的信息。
这些类型的数组在机器学习中非常有用。
结论
这就是我想在本文中分享的所有 Numpy 功能。Numpy 是一个大图书馆。它有很多可用的方法。但是这些功能对于日常使用来说已经足够好了。如果你认为我错过了这里的任何主题或者需要添加更多的功能，请告诉我。我会添加它们。
更多阅读:
熊猫的所有基本视觉类型和一些非常高级的视觉…
towardsdatascience.com](/an-ultimate-cheat-sheet-for-data-visualization-in-pandas-4010e1b16b5c) [## 使用 Pandas 的 Groupby 功能进行有效的数据汇总和分析
学习使用聚合函数，数据转换，过滤，映射，在数据框架中应用
towardsdatascience.com](/efficient-data-summarizing-and-analysis-using-pandas-groupby-function-7b2cc9eff186) [## 编程、软件工程和数据科学的最佳免费资源
麻省理工、哈佛和斯坦福等顶尖大学的免费课程
towardsdatascience.com](/best-free-courses-for-computer-science-software-engineering-and-data-science-50cd88cafd74) [## 如何在 Python 中呈现多个变量之间的关系
了解如何使用 Python 中的多元图表和绘图来呈现要素之间的关系
towardsdatascience.com](/how-to-present-the-relationships-amongst-multiple-variables-in-python-70f1b5693f5) [## 无经验的数据科学家如何抓住机遇
当技能遇到机会时，成长就会发生
towardsdatascience.com](/inexperienced-data-scientists-guide-to-meet-the-opportunity-9e8078e5ad74) [## 学习机器学习和深度学习的优质免费课程
顶级大学高质量免费课程的链接
towardsdatascience.com](/great-quality-free-courses-to-learn-machine-learning-and-deep-learning-1029048fd0fc)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
