Coursera | Andrew Ng (01-week-2-2.16)—关于 python _ numpy 向量的说明

该系列仅在原课程基础上部分知识点添加个人学习笔记，或相关推导补充等。如有错误，还请批评指教。在学习了 Andrew Ng 课程的基础上，为了更方便的查阅复习，将其整理成文字。因本人一直在学习英语，所以该系列以英文为主，同时也建议读者以英文为主，中文辅助，以便后期进阶时，为学习相关领域的学术论文做铺垫。- ZJ

Coursera 课程 |deeplearning.ai |网易云课堂

---

转载请注明作者和出处：ZJ 微信公众号-「SelfImprovementLab」

知乎：https://zhuanlan.zhihu.com/c_147249273

CSDN：http://blog.csdn.net/JUNJUN_ZHAO/article/details/78951837

---

2.16 A note on Python_numpy vectors(关于 python _ numpy 向量的说明)

(字幕来源：网易云课堂)

The ability of python to allow you to use broadcasting operations and more generally,the great flexibility of the python numpy program language is,I think, both a strength as well as a weakness of the programming language.I think it’s a strength because they create expressivity of the language.A great flexibility of the language lets you get a lot done even with just a single line of code.But there’s also weakness because with broadcasting and this great amount of flexibility,sometimes it’s possible you can introduce very subtle bugs very strange looking bugs,if you’re not familiar with all of the intricacies of how broadcasting and how features like broadcasting work.For example, if you take a column vector and add it to a row vector,you would expect it to throw up a dimension mismatch or type error or something.

Python 让你能够使用广播运算，一般来说，python numpy 程序语言给你提供了很高的灵活性，我想这算是一门编程语言的优势，同时也是弱势，我认为是一种优势，因为它让语言的表现力更强，语言的灵活性很大，就是说,你可以用一行代码完成很多运算，但也有弱点，因为广播和这么大的灵活性，有时可能会引入非常细微的错误，非常奇怪的 bug，如果你不熟悉所有复杂的，广播运作的方式，比如你想用列向量，把它加到一个行向量，你可能会预计它会报错说维度不匹配，或者类型错误之类的。

But you might actually get back a matrix as a sum of a row vector and a column vector.So there is an internal logic to these strange effects of Python.But if you’re not familiar with Python,I’ve seen some students have very strange,very hard to find bugs.So what I want to do in this video is share with you some couple tips and tricks that have been very useful for me to eliminate or simplify and eliminate all the strange looking bugs in my own code.And I hope that with these tips and tricks,you’ll also be able to much more easily write bug-free,python and numpy code.To illustrate one of the less intuitive effects of Python-Numpy,especially how you construct vectors in Python-Numpy,let me do a quick demo.

但你实际上会得到，一个行向量和列向量求和之后的矩阵，Python 的这些奇怪的效果有其内在逻辑，但是如果你不熟悉 Python，我看过有些学生写出很奇怪，非常难调试的 bug，所以我想在这个视频里，跟你分享一些技巧，对我来说非常有用，可以排除 简化，或者说消灭我自己代码里各种奇奇怪怪的 bug，我希望通过这些提示和技巧，你可以更容易写出无 bug 的，python 和 numpy 代码，为了说明Python-Numpy 不太直观的效果，尤其是在 Python-Numpy 中构建向量时的怪事，我很快展示一下。

Let’s set a = np.random.randn(5) ,so this creates five random Gaussian variables stored in array a.And so let’s print and now it turns out that the shape of a when you do this is this five column structure.And so this is called a rank 1 array in Python and it’s neither a row vector nor a column vector.And this leads it to have some slightly non-intuitive effects.So for example, if I print a transpose,it ends up looking the same as a.So a and a transpose end up looking the same.And if I print the inner product between a and a transpose,you might think a times a transpose is maybe the outer product should give you matrix maybe.But if I do that, you instead get back a number.So what I would recommend is that when you’re coding neural networks,that you just not use data structures where the shape is 5, or n, rank 1 array.

我们令 a = np.random.randn(5)，这就生成了 5 个随机高斯变量 储存数组 a 中，我们 print 一下 看看 a 的形状是怎样的，a.shape print 出来是这种 (5,) 结构，所以这是所谓的 Python 秩为 1 的数组，它既不是行向量也不是列向量，这导致它有一些略微不直观的效果，所以比如我把 a 转置 print 出来，看起来和 a 还是一样的，所以 a 和 a 转置看起来还是一样的，如果我 print 一下 a 和 a 转置的内积，你可能觉得 a 乘以 a 转置，或者说外积可能会得到一个矩阵，但如果我这么做的话会得到一个数字，我建议，当你编写神经网络程序时，你就不要用这种数据结构，其中形状是(5,)或(n,)这种秩为 1 的数组。

# 2.16 A note on python/numpy vectors

# 产生随机 5 个高斯变量存储在 a 中
# 官方文档中给出的用法是：numpy.random.rand(d0,d1,…dn) 
# 以给定的形状创建一个数组，数组元素来符合标准正态分布N(0,1) 
# 若要获得一般正态分布N(μ,σ^2) 描述则可用sigma * np.random.randn(…) + mu进行表示 

a = np.random.randn(5)
print('a=', a)
# [-0.23427061 -0.79637413 -0.06117785  0.15440186 -1.43061057]

# a 的大小 
print(a.shape)
# (5,)

# a 的转置 ，这只是秩 为 1 的数组
print(a.T)
# [-0.5694968  -0.23773807 -0.08906264  0.87211753 -0.08380342]

# a 和 a 转置的内积
print(np.dot(a, a.T))
# 1.15639015502

# 因为 a.shape (5,) 不规范

# tips tricks 技巧，若要生成随机数组 给出指定的 行列向量

b = np.random.randn(5, 1)
print(b)
# 这是标准的 5 * 1 的列向量
# [[ 0.10087547]
#  [-1.2177768 ]
#  [ 1.55482844]
#  [ 1.39440708]
#  [-1.72344715]]
print(b.T)
# 这是标准的 1 * 5 的行向量
# [[ 0.10087547 -1.2177768   1.55482844  1.39440708 -1.72344715]]
# 5 *1  乘以 1 *5 得到的是一个矩阵 5*5
print(np.dot(b, b.T))
# [[ 0.08517485  0.38272589 -0.11342526  0.23506654  0.16852131]
#  [ 0.38272589  1.71974596 -0.5096667   1.05625134  0.75723604]
#  [-0.11342526 -0.5096667   0.15104565 -0.31303236 -0.2244157 ]
#  [ 0.23506654  1.05625134 -0.31303236  0.64873937  0.46508706]
#  [ 0.16852131  0.75723604 -0.2244157   0.46508706  0.33342507]]


# >>> a = np.mat([[1],[2],[3],[4],[5]])
# >>> b = np.mat([[2,2,2,2,2]])
# >>> c = np.dot(a,b)
# >>> c
# matrix([[ 2,  2,  2,  2,  2],
#         [ 4,  4,  4,  4,  4],
#         [ 6,  6,  6,  6,  6],
#         [ 8,  8,  8,  8,  8],
#         [10, 10, 10, 10, 10]])

Instead, if you set a to be this, 5 by 1,then this commits a to be a 5 by 1 column vector.And whereas previously, a and a transpose looked the same,it becomes now a transpose, now a transpose is a row vector.Notice one subtle difference.In this data structure, there are two square brackets when we print a transpose.Whereas previously, there was one square bracket.So that’s the difference between this is really a 1 by 5 matrix versus one of these rank 1 arrays.And if you print, say, the product between a and a transpose,then this gives you the outer product of a vector, right?And so, the outer product of a vector gives you a matrix.So, let’s look in greater detail at what we just saw here.The first command that we ran, just now, was this.And this created a data structure with a.Shape was this funny thing was this funny thing 5 comma so this is called a rank 1 array.

相反如果你令 a 为这种 5×1 矩阵的话，那么就可以令 a 变成 5×1 列向量，而之前 a 和 a 转置看起来是一样的，现在看看 a 转置, 现在 a转置就是一个行向量了，注意一个微妙的区别，在这个数据结构中 有两个方括号，当我们 print a 转置时，以前这里只有一个方括号，所以这是区别 这是一个 1×5 矩阵，而不是这些秩为1的数组，如果你 print 出来 比如说 a 和 a 转置的乘积，这样应该会得到一个向量的外积 对吧?，所以 向量的外积可以得到一个矩阵，现在我们仔细看看这里见到的东西，我们刚才跑的第一个命令 是这个，这创建了一个数据结构，a.shape就是这个奇怪的 5,有时这叫秩为 1 的数组。

And this is a very funny data structure.It doesn’t behave consistently as either a row vector nor a column vector,which makes some of its effects nonintuitive.So what I’m going to recommend is that when you’re doing your programing exercises,or in fact when you’re implementing logistic regression on your neural networks that you just do not use these rank 1 arrays.Instead, if every time you create an array,you commit to making it either a column vector,so this creates a 5,1 vector, or commit to making it a row vector,then the behavior of your vectors may be easier to understand.So in this case, a.Shape is going to be equal to 5,1.And so this behaves a lot like a,but in fact, this is a column vector.

这是一个非常有趣的数据结构，它的行为和，行向量或列向量并不一样，所以有些效果没那么直观，那么我推荐的是，当你进行编程练习时，或者实现，神经网络的 logistic 回归时，你就不用这些秩为 1 的数组，相反 每次创建数组时，你要把它定义成列向量，所以这创建一个5×1向量 或者把它变成一个行向量，那么你的向量的行为也许更容易理解一些，所以在这种情况下 a.shape就等于(5,1)，所以这个行为很像，但实际上这就是一个列向量。

And that’s why you can think of this as 5 by 1 matrix,where it’s a column vector.And here a.Shape is going to be 1,5,and this behaves consistently as a row vector.So when you need a vector,I would say either use this or this,but not a rank 1 array.One more thing that I do a lot in my code is if I’m not entirely sure what’s the dimension of one of my vectors,I’ll often throw in an assertion statement like this,to make sure, in this case, that this is a vector.So this is a column vector.These assertions are really inexpensive to execute,and they also help to serve as documentation for your code.So don’t hesitate to throw in assertion statements like this whenever you feel like it.

所以你可以将它看成是 5×1 矩阵，它是一个列向量，而这里a.shape是 1,5，然后这里的行为和行向量一致，所以当你需要一个向量时，我说就用这个和这个，但不要用秩为1的数组，还有一件事 如果我在代码中做了很多事情，所以如果我不太确定，一个向量具体的维度是多少，我会经常assert()这样一个声明，确保这是一个向量，所以这是一个列向量，这些assert()执行起来很快，它们也可以看成是代码的文档，所以不要犹豫，你觉得需要的时候 就使用assert()声明。

And then finally, if for some reason you do end up with a rank 1 array,You can reshape this,a equals a.Reshape into say a 5 by 1 array or a 1 by 5 array so that it behaves more consistently as either column vector or row vector.So I’ve sometimes seen students end up with very hard to track because those are the nonintuitive effects of rank 1 arrays.By eliminating rank 1 arrays in my old code,I think my code became simpler.And I did not actually find it restrictive in terms of things I could express in code.I just never used a rank 1 array.And so takeaways are to simplify your code,don’t use rank 1 arrays.

最后 如果由于某种原因，你得到了一个秩为 1 的数组，你可以用reshape，a=a.reshape 转换成比如说一个5×1数组或1×5数组，那么它的行为更好预测，就是列向量或行向量的行为，所以我有时候会看到学生很难调试一些错误，都来自秩为 1 数组的反直觉行为，通过消除代码中的秩为 1 的数组，我可以让代码变得更简单，而我其实并没有，觉得这样写代码限制太多，我只是从来不会用秩为 1 的数组，所以重点在于要简化你的代码，不要使用秩为 1 的数组。

Always use either n by one matrices,basically column vectors,or one by n matrices, or basically row vectors.Feel free to toss a lot of insertion statements,so double-check the dimensions of your matrices and arrays.x to make sure that your matrices or your vectors are the dimension that you need it to be.So that, I hope that this set of suggestions helps you to eliminate a cause of bugs from Python code,and makes the problem exercise easier for you to complete.

始终使用 $n×1$ 矩阵，基本上是列向量，或 $1×n$ 矩阵 基本上是行向量，随意插入assert()声明，要仔细检查你的矩阵和数组的维度，不要害怕调用reshape，来确保你的矩阵或向量，是你需要的维度，所以我希望这一套建议，能帮助你消除 Python 代码中的错误，并使习题更容易完成。

---

重点总结：

• 虽然在 Python 有广播的机制，但是在 Python 程序中，为了保证矩阵运算的正确性，可以使用reshape()函数来对矩阵设定所需要进行计算的维度，这是个好的习惯；

• 如果用下列语句来定义一个向量，则这条语句生成的 a 的维度为（5，），既不是行向量也不是列向量，称为秩（rank）为 1 的 array，如果对 a 进行转置，则会得到 a 本身，这在计算中会给我们带来一些问题。

a = np.random.randn(5)

• 如果需要定义（5，1）或者（1，5）向量，要使用下面标准的语句：

a = np.random.randn(5,1)
b = np.random.randn(1,5)

• 可以使用assert语句对向量或数组的维度进行判断。assert会对内嵌语句进行判断，即判断 a 的维度是不是（5，1），如果不是，则程序在此处停止。使用assert语句也是一种很好的习惯，能够帮助我们及时检查、发现语句是否正确。

assert(a.shape == (5,1))

• 可以使用reshape函数对数组设定所需的维度

a.reshape((5,1))

参考文献：

[1]. 大树先生.吴恩达Coursera深度学习课程 DeepLearning.ai 提炼笔记（1-2）– 神经网络基础

---

PS: 欢迎扫码关注公众号：「SelfImprovementLab」！专注「深度学习」，「机器学习」，「人工智能」。以及 「早起」，「阅读」，「运动」，「英语 」「其他」不定期建群 打卡互助活动。