简 介： 在numpy中的一维和二维数组与线性代数中的矩阵和向量的概念有区别，也有联系。恰当掌握numpy中的矩阵运算特点可以大大提高程序的编写的效率。这其中需要不断的做斗争的就是区分一维向量与一维矩阵之间的差异性。

关键词： numpy，matrix，dimension

§01 矩阵与向量

  在 numpy中的矩阵与数学上的矩阵的关系 讨论了numpy中的矩阵与向量关系。

一、矩阵

  numpy中的矩阵具有二维的结构。

1、初始化一个随机矩阵

from headm import *a = random.rand(2, 3)
printf(a, type(a), a.shape)

[[0.4336234  0.77036849 0.60096793][0.0316234  0.99120883 0.53601667]]
<class 'numpy.ndarray'>
(2, 3)

2、矩阵操作

（1）正常矩阵相乘

from headm import *a = random.rand(2, 3)
b = random.rand(3, 2)
c = dot(a,b)
printf(c, type(c), c.shape)

[[0.7684459  0.29381061][0.76060152 0.46711189]]
<class 'numpy.ndarray'>
(2, 2)

（2）矩阵广播操作

c = a*b

---------- [PYTHON ERROR] 186 ----------
Traceback (most recent call last):File "d:\temp\TEMP0001\test1.PY", line 13, in <module>c = a*b
ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

  但如果a，b是相同尺寸，可以使用这种广播操作：

from headm import *a = random.rand(2, 3)
b = random.rand(2, 3)
c = a*b
printf(c, type(c), c.shape)

[[0.2393848  0.41071455 0.16750262][0.70508388 0.14090312 0.16709447]]
<class 'numpy.ndarray'>
(2, 3)

3、矩阵转置

from headm import *a = random.rand(2, 3)
b = a.T
c = dot(a,b)
printf(c, type(c), c.shape)

[[0.47551039 0.46143036][0.46143036 1.11436681]]
<class 'numpy.ndarray'>
(2, 2)

二、向量

1、列向量与行向量

  下面展示通过一个列向量与其转置（行向量）的矩阵相乘，形成一个对称方阵。

from headm import *a = random.rand(5, 1)
b = a.T
c = dot(a,b)
printf(a,b,c)

[[0.53296778][0.78546112][0.94781325][0.52827569][0.12897877]]
[[0.53296778 0.78546112 0.94781325 0.52827569 0.12897877]]
[[0.28405466 0.41862547 0.50515393 0.28155392 0.06874153][0.41862547 0.61694917 0.74447046 0.41494002 0.10130781][0.50515393 0.74447046 0.89834995 0.5007067  0.12224778][0.28155392 0.41494002 0.5007067  0.27907521 0.06813635][0.06874153 0.10130781 0.12224778 0.06813635 0.01663552]]

  下面展示通过一个行向量与一个其转置（列向量）的矩阵相乘，也就是内积，所获得的的 一个取值。

from headm import *a = random.rand(1, 5)
b = a.T
c = dot(a,b)
printf(a,b,c)

[[0.01240721 0.93461735 0.77328477 0.75715417 0.90210299]]
[[0.01240721][0.93461735][0.77328477][0.75715417][0.90210299]]
[[2.85870512]]

  上面看到，虽然向量只有一行，或者一列，但仍然是二维的。

2、一维向量

  一维矩阵和它的的转置，都是一样的：

• dot，对应的是内积；
• • ， 对应的是对位相乘；
• 可以 sqrt, exp, log 进行广播操作。

from headm import *a = random.rand(5)
printf(a, a.shape)
b = a.T
printf(b, b.shape)printf(dot(a,b), a*b, sqrt(a*b), exp(a), log(exp(a)))

[0.81684852 0.56601384 0.19416386 0.40459394 0.39197519]
(5,)
[0.81684852 0.56601384 0.19416386 0.40459394 0.39197519]
(5,)
1.342653579591815
[0.6672415  0.32037167 0.0376996  0.16369626 0.15364455]
[0.81684852 0.56601384 0.19416386 0.40459394 0.39197519]
[2.26335566 1.76123249 1.21429524 1.49869382 1.47990099]
[0.81684852 0.56601384 0.19416386 0.40459394 0.39197519]

三、1维与2维转换

1、1维转换成2维

（1）方法一

from headm import *a = array([1,2,3,4,5])
printf(a, type(a), a.shape)
a = a.reshape(-1,1)
printf(a, type(a), a.shape)
a = a.reshape(1, -1)
printf(a, type(a), a.shape)

[1 2 3 4 5]
<class 'numpy.ndarray'>
(5,)
[[1][2][3][4][5]]
<class 'numpy.ndarray'>
(5, 1)
[[1 2 3 4 5]]
<class 'numpy.ndarray'>
(1, 5)

（2）方法二

from headm import *a = array([1,2,3,4,5])
printff(a, type(a), a.shape)
a = a[:,newaxis]
printf(a, type(a), a.shape)
a = a.reshape(1, -1)
printff(a, type(a), a.shape)

[1 2 3 4 5] <class 'numpy.ndarray'> (5,)
[[1][2][3][4][5]]
<class 'numpy.ndarray'>
(5, 1)
[[1 2 3 4 5]] <class 'numpy.ndarray'> (1, 5)

from headm import *a = array([1,2,3,4,5])
printff(a, type(a), a.shape)
a = a[newaxis, :]
printff(a, type(a), a.shape)

[1 2 3 4 5] <class 'numpy.ndarray'> (5,)
[[1 2 3 4 5]] <class 'numpy.ndarray'> (1, 5)

1、2维转换成1维

from headm import *a = array([[1,2,3,4,5],[5,4,3,2,1]])
printff(a, type(a), a.shape)a = a.flatten()
printff(a, type(a), a.shape)a = a.flatten()
printff(a, type(a), a.shape)

[[1 2 3 4 5][5 4 3 2 1]] <class 'numpy.ndarray'> (2, 5)
[1 2 3 4 5 5 4 3 2 1] <class 'numpy.ndarray'> (10,)
[1 2 3 4 5 5 4 3 2 1] <class 'numpy.ndarray'> (10,)

§02 广播操作

一、1维 与2维操作

1、矩阵操作

  二维与一维之间无法直接使用“*”操作，但可以把dot进行广播，但需要他们之间具有尺寸相容。

from headm import *a = random.rand(5)
b = random.rand(5,4)
printf(a, a.shape)
printf(b, b.shape)
c = dot(a,b)printf(c, c.shape)

[0.19540504 0.75713258 0.47409028 0.95749455 0.0499414 ]
(5,)
[[0.59277507 0.80779307 0.11313376 0.27368229][0.33829947 0.41488069 0.50918796 0.51450836][0.61328107 0.79625242 0.14989651 0.51877984][0.92596051 0.58771942 0.06328636 0.66607471][0.06887225 0.05885387 0.66259257 0.91295582]]
(5, 4)
[1.55276111 1.41513945 0.57238132 1.37233563]
(4,)

from headm import *a = random.rand(4)
b = random.rand(5, 4)
c = b+a
printf(c)

[[1.47109788 0.36818024 1.50356281 0.97173366][0.77678226 0.76248209 1.41903158 0.59809072][1.42392312 0.1606284  0.9226129  1.12151203][1.04568649 0.25796424 1.10219016 1.51238155][0.82297934 0.32509965 0.9520944  1.10784752]]

2. 矩阵运算

from headm import *a = arange(12)
printf(a)b = a.reshape(3,4)
c = a.reshape([4, 3])
printf(b,c)d = b.dot(c)
printf('a:\n{}'.format(a))
printf('b:\n{}'.format(b))
printf('c:\n{}'.format(c))
printf('d:\n{}'.format(d))

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[[ 0  1  2  3][ 4  5  6  7][ 8  9 10 11]]
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
a:
[ 0  1  2  3  4  5  6  7  8  9 10 11]
b:
[[ 0  1  2  3][ 4  5  6  7][ 8  9 10 11]]
c:
[[ 0  1  2][ 3  4  5][ 6  7  8][ 9 10 11]]
d:
[[ 42  48  54][114 136 158][186 224 262]]

二、传递函数

1、sigmoid， ReLU

from headm import *import matplotlib.patches as patchesplt.figure(figsize=(8,3))x = arange(-10, 10, 0.1)
s = 1.0/(1+exp(-x))y = clip(x, a_min=0, a_max=None)f = plt.subplot(121)
plt.plot(x, s, color='r')
plt.text(-5, 0.9, r'y=\sigma(x)', fontsize=13)
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)f = plt.subplot(122)
plt.plot(x, y, color='g')
plt.text(-3.0, 9, r'y=ReLU(x)', fontsize=13)
currentAxis = plt.gca()
currentAxis.xaxis.set_label_text('x', fontsize=15)
currentAxis.yaxis.set_label_text('y', fontsize=15)plt.show()

▲ 图2.2.1 传递函数图形

2、tanh(x)

from headm import *x = arange(-10, 10, 0.1)
y = (exp(x) - exp(-x))/(exp(x) + exp(-x))plt.plot(x, y)
plt.xlabel("X")
plt.ylabel("Y")
plt.grid(True)
plt.title("tanh(x)")
plt.tight_layout()
plt.show()

▲ 图2.2.2 tanh(x)图像

三、统计矩阵数值

from headm import *p = random.randn(10, 10)
printff(p, p.shape, size(p))pp = p>0
printf(pp)ppp = p[p>0]
printf(ppp)printf(size(ppp))

[[ 0.01620486  0.67258933  0.01932111 -1.24584168  1.66905431  0.611480411.50762446  1.45523268 -0.9894722   1.38123339][-0.48932425  0.41593151 -0.17275561 -2.37370434  0.42233764  0.102750551.31174454 -0.19584097 -0.83989111  0.12063591][-2.06617565 -0.17690216 -1.13955957 -0.94092216  0.73430913  0.27121380.50147495 -0.41762933  0.83625418  0.5509839 ][ 0.6517084  -0.80193123  1.74355584 -1.63959782  0.33740677 -0.30113330.85299477  1.18642947  0.54348421 -0.33220807][-0.76815237  0.1905339  -1.49133609 -0.50147435 -0.87359605  1.219546952.11818657  1.37251053  1.79651431 -0.35538793][ 0.95903604 -0.62433781 -0.57684665  1.05654807 -0.94306931  0.43132812-0.91129206  0.59148798  0.26663058  1.55453423][ 1.99357069  0.05755349  0.38198899  1.11991802  0.10749524 -0.291106851.86200101  0.48337364 -0.17757012  0.49664438][ 0.62996674  1.11491175  0.87189351 -1.92055209  1.90870303  0.05350043-1.10431046  0.5036674   0.64338918 -1.49798092][ 1.79025399 -0.09283397 -0.28797869 -0.85400135 -0.04489148 -0.5245149-1.57868568  0.30971683 -0.13945143 -0.50442115][-1.20187734  0.98333785 -0.74859386  0.09177302 -0.48566486  1.57009514-0.42442954  0.93099892 -1.58766247 -1.41113389]] (10, 10) 100
[[ True  True  True False  True  True  True  True False  True][False  True False False  True  True  True False False  True][False False False False  True  True  True False  True  True][ True False  True False  True False  True  True  True False][False  True False False False  True  True  True  True False][ True False False  True False  True False  True  True  True][ True  True  True  True  True False  True  True False  True][ True  True  True False  True  True False  True  True False][ True False False False False False False  True False False][False  True False  True False  True False  True False False]]
[0.01620486 0.67258933 0.01932111 1.66905431 0.61148041 1.507624461.45523268 1.38123339 0.41593151 0.42233764 0.10275055 1.311744540.12063591 0.73430913 0.2712138  0.50147495 0.83625418 0.55098390.6517084  1.74355584 0.33740677 0.85299477 1.18642947 0.543484210.1905339  1.21954695 2.11818657 1.37251053 1.79651431 0.959036041.05654807 0.43132812 0.59148798 0.26663058 1.55453423 1.993570690.05755349 0.38198899 1.11991802 0.10749524 1.86200101 0.483373640.49664438 0.62996674 1.11491175 0.87189351 1.90870303 0.053500430.5036674  0.64338918 1.79025399 0.30971683 0.98333785 0.091773021.57009514 0.93099892]
56

§03 Paddle中广播

飞桨（PaddlePaddle，以下简称Paddle）和其他框架一样，提供的一些API支持广播(broadcasting)机制，允许在一些运算时使用不同形状的张量。 通常来讲，如果有一个形状较小和一个形状较大的张量，会希望多次使用较小的张量来对较大的张量执行一些操作，看起来像是较小形状的张量的形状首先被扩展到和较大形状的张量一致，然后做运算。值得注意的是，这期间并没有对较小形状张量的数据拷贝操作。

一、广播准则

飞桨的广播机制主要遵循如下规则（参考 Numpy 广播机制 ）：

1. 每个张量至少为一维张量
2. 从后往前比较张量的形状，当前维度的大小要么相等，要么其中一个等于一，要么其中一个不存在

例如：

import paddle#------------------------------------------------------------
x = paddle.ones((2, 3, 4))
y = paddle.ones((2, 3, 4))printf(x,y)
# 两个张量 形状一致，可以广播
z = x + y
print(z.shape)
# [2, 3, 4]x = paddle.ones((2, 3, 1, 5))
y = paddle.ones((3, 4, 1))
# 从后向前依次比较：
# 第一次：y的维度大小是1
# 第二次：x的维度大小是1
# 第三次：x和y的维度大小相等
# 第四次：y的维度不存在
# 所以 x和y是可以广播的
z = x + y
print(z.shape)
# [2, 3, 4, 5]# 相反
x = paddle.ones((2, 3, 4))
y = paddle.ones((2, 3, 6))
# 此时x和y是不可广播的，因为第一次比较 4不等于6
# z = x + y
# InvalidArgumentError: Broadcast dimension mismatch.

二、广播结果

现在你知道什么情况下两个张量是可以广播的，两个张量进行广播语义后的结果张量的形状计算规则如下：

• 如果两个张量的形状的长度不一致，那么需要在较小形状长度的矩阵向前添加1，直到两个张量的形状长度相等。
• 保证两个张量形状相等之后，每个维度上的结果维度就是当前维度上较大的那个。

例如:

import paddlex = paddle.ones((2, 1, 4))
y = paddle.ones((3, 1))
z = x + y
print(z.shape)
# z的形状: [2,3,4]x = paddle.ones((2, 1, 4))
y = paddle.ones((3, 2))
# z = x + y
# ValueError: (InvalidArgument) Broadcast dimension mismatch.

※ 总  结 ※

  在numpy中的一维和二维数组与线性代数中的矩阵和向量的概念有区别，也有联系。恰当掌握numpy中的矩阵运算特点可以大大提高程序的编写的效率。

  这其中需要不断的做斗争的就是区分一维向量与一维矩阵之间的差异性。

from headm import *a = random.randn(5)
b = a.reshape(-1, 1)
printf(a, '\n', b, '\n')c = a*b
d = b*a
printf(c, d, '\n')printf(a*a, '\n')
printf(a.T*a, '\n')
printf(a*a.T)

[ 0.88506299 -0.51674935 -1.51025031  1.79745919 -1.49793202][[ 0.88506299][-0.51674935][-1.51025031][ 1.79745919][-1.49793202]][[ 0.78333649 -0.45735572 -1.33666665  1.59086461 -1.32576419][-0.45735572  0.26702989  0.78042086 -0.92883587  0.77405539][-1.33666665  0.78042086  2.280856   -2.7146133   2.26225229][ 1.59086461 -0.92883587 -2.7146133   3.23085955 -2.69247168][-1.32576419  0.77405539  2.26225229 -2.69247168  2.24380033]]
[[ 0.78333649 -0.45735572 -1.33666665  1.59086461 -1.32576419][-0.45735572  0.26702989  0.78042086 -0.92883587  0.77405539][-1.33666665  0.78042086  2.280856   -2.7146133   2.26225229][ 1.59086461 -0.92883587 -2.7146133   3.23085955 -2.69247168][-1.32576419  0.77405539  2.26225229 -2.69247168  2.24380033]][0.78333649 0.26702989 2.280856   3.23085955 2.24380033][0.78333649 0.26702989 2.280856   3.23085955 2.24380033][0.78333649 0.26702989 2.280856   3.23085955 2.24380033]

numpy中矩阵运算的特点相关推荐

1. Numpy中矩阵运算

   Numpy中矩阵运算 1 矩阵和向量 1.1 矩阵 矩阵,英文matrix,和array的区别矩阵必须是2维的,但是array可以是多维的. 如图:这个是 3×2 矩阵,即 3 行 2 列,如 m 为 ...

2. python科学计算笔记（一）NumPy中ndarray对象、ufunc运算、矩阵运算

   标准安装的Python中用列表(list)保存一组值,可以用来当作数组使用,不过由于列表的元素可以是任何对象,因此列表中所保存的是对象的指针.这样为了保存一个简单的[1,2,3],需要有3个指针和三个 ...

3. python矩阵运算numpy_Python Numpy中的几个矩阵乘法

   数学上的内积.外积和叉积 内积 也即是:点积.标量积或者数量积 从代数角度看,先对两个数字序列中的每组对应元素求积,再对所有积求和,结果即为点积.从几何角度看,点积则是两个向量的长度与它们夹角余弦的积 ...

4. numpy中的矩阵与数学上的矩阵的关系

   ➤00 矢量.矩阵 在数学上,矢量和矩阵之间具有很强的联系.矢量可以看成行数.或者列数为1的矩阵.所以它可以被分成行矢量,或者列矢量. 下面分别表示了一个行矢量和一个列矢量. xˉ=[x1,x2,x3 ...

5. 【Python进阶】你真的明白NumPy中的ndarray吗？

   欢迎来到专栏<Python进阶>.在这个专栏中,我们会讲述Python的各种进阶操作,包括Python对文件.数据的处理,Python各种好用的库如NumPy.Scipy.Matplotl ...

6. python3 numpy中矩阵np.dot(a,b)乘法运算

   python np.dot(a,b)乘法运算 首先我们知道矩阵运算是不满足交换律的,np.dot(a, b)与np.dot(b, a)是不一样的 另外np.dot(a,b)和a.dot(b)果是一样的 ...

7. 爱因斯坦求和约定在Python扩展库Numpy中的实现

   推荐教材: <Python数据分析.挖掘与可视化>(慕课版)(ISBN:978-7-115-52361-7),董付国,人民邮电出版社,定价49.8元,2020年1月出版,2021年12月第 ...

8. Python扩展库numpy中where()函数的三种用法

   第一种用法:只给where()函数传递一个数组作为参数,返回其中非0元素的下标. 第二种用法:给where()函数传递一个包含True/False值的数组,返回该数组中True值的下标,结合numpy ...

9. python Numpy 中的矩阵向量乘法（np.multiply（）、np.dot（）、np.matmul() 和 星号（*）、@）

   python Numpy 中的矩阵向量乘法 总结 1. 对于 np.array 对象 1.1 元素乘法 用 a*b 或 np.multiply(a,b) 1.2 矩阵乘法 用 np.dot(a,b) ...

最新文章

1. SHA204A加密芯片配置
2. 在C#用HttpWebRequest中发送GET/HTTP/HTTPS请求
3. Linux常用命令之rm
4. 微信公共平台php用$GLOBALS[“HTTP_RAW_POST_DATA“]收不到信息解决方法
5. 串行异步通信_单片机串行口介绍
6. 牛客假日团队赛5 L Catch That Cow HDU 2717 （BFS）
7. java中的codereview
8. 直博和读完硕士再读博，在能力上的差距有多大？
9. 给定一个数组和一个数M,在数组中求一些数使它们的和最接近M------递归
10. silverlight DataPager控件
11. python asyncio tcp server_关于 asyncio 创建多个 tcp 连接，线程数不准确的问题
12. （转载）MyEclipse 9.1配置ADT(Link方式配置Android开发环境)
13. ORA-03113：通信通道的文件结尾-完美解决方案
14. 数学建模层次分析法例题及答案_数学建模之层次分析法
15. 升级Spring Boot 2.x后RelaxedPropertyResolver不可用的解决方案
16. java affinity_sched_setaffinity（）如何工作？
17. 关于fiddle开启https证书协议源码
18. 在word中，“⑩”后面的顺序符号，如圈11、圈12等如何输入？
19. 爱上python系列------python上下文管理器(二):对suppress进行装饰器重新实现
20. php 完全前后端分离使用jwt,前后端分离，在 angular 8 中利用 JWT 进行身份认证

热门文章

1. Spring Webflux: Kotlin DSL [片断]
2. js 关于运算顺序的问题
3. shop++商品搜索出现乱码的解决方法
4. 《中国人工智能学会通讯》——11.66 结构属性表示及其在脑影像分析中的应用...
5. storm自定义分组与Hbase预分区结合节省内存消耗
6. mysql延迟解决方案
7. Leetcode: Intersection of Two Arrays
8. AngularJs前端环境搭建
9. Java程序执行过程
10. php高版本不再使用mysql_connect()来连接数据库