DeepLearing学习笔记-数据矢量化

最新推荐文章于 2022-10-02 11:20:16 发布

JasonLiu1919

最新推荐文章于 2022-10-02 11:20:16 发布

阅读量3.3k

点赞数 2

分类专栏： Python 文章标签： python

本文链接：https://blog.csdn.net/ljp1919/article/details/78077363

版权

Python 专栏收录该内容

51 篇文章 1 订阅

订阅专栏

背景：

通过矢量化提高矩阵运算速度

准备知识：

dot/outer/elementwise product 的区别：

dot product 点乘：

向量点积：
向量的点乘,也叫向量的内积、数量积，对两个向量执行点乘运算，就是对这两个向量对应位一一相乘之后求和的操作，点乘的结果是一个标量。
定义： $a \cdot b= ||a|| ||b||\cos(\theta)$ ，即是两个向量的模和两向量夹角余弦的乘积。
点乘的几何意义是可以用来表征或计算两个向量之间的夹角，以及在b向量在a向量方向上的投影。
矩阵内积：
内积是一种降维运算，变成一个数。矩阵的内积是每行每列的点积所组成的矩阵。所以，点积是一维向量之间的操作，内积是多维向量，即矩阵的操作。两者本质是一样的。其实，内积就是我们一般常用的矩阵乘积，行列进行相互乘积，作为结果矩阵指定位置的元素结果值。所以，要求a矩阵的列数量等于b矩阵的行数量。
示例代码：

x = numpy.array([1, 2])
y = numpy.array([10, 20])
print("Array inner:")
print(numpy.inner(x, y))
''' Output：
Array inner:
50
'''

x = numpy.mat([[1, 2], [3, 4]])
y = numpy.mat([10, 20])
print("Matrix inner:")
print(numpy.inner(x, y))

Output：
Matrix inner:
[[ 50]
 [110]]

outer product 外积：

两个向量的叉乘，又叫向量积、外积、叉积，叉乘的运算结果是一个向量而不是一个标量，是向量的升维运算。并且两个向量的外积与这两个向量组成的坐标平面垂直。m维向量和n维向量的外积是m*n维矩阵。
定义：
$a\times b$
矩阵外积：
假设a的维度是（m，n），b的维度是（p，q）
$a\times b= \left[\begin{matrix} a_{11} & ... & a_{1m} \\ ... & ... & ... \\ a_{1m} & ... & a_{mn} \end{matrix} \right] \left[\begin{matrix} b_{11} & ... & b_{1q} \\ ... & ... & ... \\ b_{1p} & ... & b_{pq} \end{matrix} \right] =\left[\begin{matrix} a_{11}*b_{11} & ... & a_{11}*b_{1q} & a_{11}*b_{21} & ... & a_{11}*b_{pq} \\ ... & ... & ... & ... & ... & ... \\ a_{1n}*b_{11} & ... & a_{1n}*b_{1q} & a_{1n}*b_{21} & ... & a_{1n}*b_{pq} \\ a_{21}*b_{11} & ... & a_{21}*b_{1q} & a_{21}*b_{21} & ... & a_{21}*b_{pq} \\ ... & ... & ... & ... & ... & ... \\ a_{mn}*b_{11} & ... & a_{mn}*b_{1q} & a_{mn}*b_{21} & ... & a_{mn}*b_{pq} \end{matrix} \right]\tag{1}$
向量外积：
$a=(x_1,y_1,z_1)$
$b=(x_2,y_2,z_2)$
$a \times b= \left[\begin{matrix} i & j & k \\ x_1 & y_1 & z_1 \\ x_2 & y_2 & z_2 \end{matrix} \right]=(y_1z_2-y_2z_1)i - (x_1z_2-x_2z_1)j+(x_1y_2-x_2y_1)k\tag{2}$
其中：
$i=(1,0,0) \qquad j=(0,1,0) \qquad k=(0,0,1)$
叉乘几何意义:
在三维几何中，向量a和向量b的叉乘结果是一个向量，更为熟知的叫法是法向量，该向量垂直于a和b向量构成的平面。
在二维空间中，叉乘还有另外一个几何意义就是：aXb等于由向量a和向量b构成的平行四边形的面积。

示例代码：

x = numpy.array([1, 3])
y = numpy.array([10, 20])
print("Array outer:")
print(numpy.outer(x, y))
''' Output：
Array outer:
[[10 20]
 [30 60]]
'''

x = numpy.mat([[1, 2], [3, 4]])
y = numpy.mat([10, 20])
print("Matrix outer:")
print(numpy.outer(x, y))

Output：
Matrix outer:
[[10 20]
 [20 40]
 [30 60]
 [40 80]]

elementwise product 元素积：

定义：
$a * b$
有三种情况：
$a * b=\left[\begin{matrix} a_1 & … & a_{m} \end{matrix} \right]\left[\begin{matrix} b_1 & ... & b_{m} \end{matrix} \right]\tag{3}$

$a*b=\left[\begin{matrix} a_1 & … & a_{n} \end{matrix} \right]\left[\begin{matrix} b_1\\b_2\\...\\b_m \end{matrix} \right]\ =\left[\begin{matrix} a_1b_1 &...& a_nb_1&\\ ...&...&...\\ a_1b_m&...&a_nb_m \end{matrix} \right]\tag{4}$
第三种情况，就是两个矩阵尺寸相同，则是对应位置的元素乘积。

示例代码：

x = numpy.array([1, 3])
y = numpy.array([10, 20])
print("Array element-wise product:")
print(x * y)

输出：
Array element-wise product:
[10 60]

矢量化操作：

循环实现矩阵运算：

import time

x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]
x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]
#用循环来实现dot product
### CLASSIC DOT PRODUCT OF VECTORS IMPLEMENTATION ###
tic = time.process_time()
dot = 0
for i in range(len(x1)):
    dot+= x1[i]*x2[i]
toc = time.process_time()
print ("dot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

#用循环来实现outer product
### CLASSIC OUTER PRODUCT IMPLEMENTATION ###
tic = time.process_time()
outer = np.zeros((len(x1),len(x2))) # we create a len(x1)*len(x2) matrix with only zeros
for i in range(len(x1)):
    for j in range(len(x2)):
        outer[i,j] = x1[i]*x2[j]
toc = time.process_time()
print ("outer = " + str(outer) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

#用循环来实现 元素之间乘积
### CLASSIC ELEMENTWISE IMPLEMENTATION ###
tic = time.process_time()
mul = np.zeros(len(x1))
for i in range(len(x1)):
    mul[i] = x1[i]*x2[i]
toc = time.process_time()
print ("elementwise multiplication = " + str(mul) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

#用循环来实现泛化的点积，即内积。
### CLASSIC GENERAL DOT PRODUCT IMPLEMENTATION ###
W = np.random.rand(3,len(x1)) # Random 3*len(x1) numpy array
tic = time.process_time()
gdot = np.zeros(W.shape[0])
for i in range(W.shape[0]):
    for j in range(len(x1)):
        gdot[i] += W[i,j]*x1[j]
toc = time.process_time()
print ("gdot = " + str(gdot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

执行结果：

dot = 278
 ----- Computation time = 0.0ms
outer = [[ 81.  18.  18.  81.   0.  81.  18.  45.   0.   0.  81.  18.  45.   0.
    0.]
 [ 18.   4.   4.  18.   0.  18.   4.  10.   0.   0.  18.   4.  10.   0.
    0.]
 [ 45.  10.  10.  45.   0.  45.  10.  25.   0.   0.  45.  10.  25.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [ 63.  14.  14.  63.   0.  63.  14.  35.   0.   0.  63.  14.  35.   0.
    0.]
 [ 45.  10.  10.  45.   0.  45.  10.  25.   0.   0.  45.  10.  25.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [ 81.  18.  18.  81.   0.  81.  18.  45.   0.   0.  81.  18.  45.   0.
    0.]
 [ 18.   4.   4.  18.   0.  18.   4.  10.   0.   0.  18.   4.  10.   0.
    0.]
 [ 45.  10.  10.  45.   0.  45.  10.  25.   0.   0.  45.  10.  25.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]
 [  0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.   0.
    0.]]
 ----- Computation time = 0.0ms
elementwise multiplication = [ 81.   4.  10.   0.   0.  63.  10.   0.   0.   0.  81.   4.  25.   0.   0.]
 ----- Computation time = 0.0ms
gdot = [ 17.02350757  18.34972831  15.85377834]
 ----- Computation time = 0.0ms

上述的运行结果，并没有很直观表现循环操作的耗时，这是因为测试时候选用的数据量少的缘故。

基于numpy的矢量化矩阵运算

x1 = [9, 2, 5, 0, 0, 7, 5, 0, 0, 0, 9, 2, 5, 0, 0]
x2 = [9, 2, 2, 9, 0, 9, 2, 5, 0, 0, 9, 2, 5, 0, 0]

### VECTORIZED DOT PRODUCT OF VECTORS ###
tic = time.process_time()
dot = np.dot(x1,x2)
toc = time.process_time()
print ("dot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED OUTER PRODUCT ###
tic = time.process_time()
outer = np.outer(x1,x2)
toc = time.process_time()
print ("outer = " + str(outer) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED ELEMENTWISE MULTIPLICATION ###
tic = time.process_time()
mul = np.multiply(x1,x2)
toc = time.process_time()
print ("elementwise multiplication = " + str(mul) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

### VECTORIZED GENERAL DOT PRODUCT ###
tic = time.process_time()
dot = np.dot(W,x1)
toc = time.process_time()
print ("gdot = " + str(dot) + "\n ----- Computation time = " + str(1000*(toc - tic)) + "ms")

运行结果：

dot = 278
 ----- Computation time = 0.0ms
outer = [[81 18 18 81  0 81 18 45  0  0 81 18 45  0  0]
 [18  4  4 18  0 18  4 10  0  0 18  4 10  0  0]
 [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [63 14 14 63  0 63 14 35  0  0 63 14 35  0  0]
 [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [81 18 18 81  0 81 18 45  0  0 81 18 45  0  0]
 [18  4  4 18  0 18  4 10  0  0 18  4 10  0  0]
 [45 10 10 45  0 45 10 25  0  0 45 10 25  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]
 [ 0  0  0  0  0  0  0  0  0  0  0  0  0  0  0]]
 ----- Computation time = 0.0ms
elementwise multiplication = [81  4 10  0  0 63 10  0  0  0 81  4 25  0  0]
 ----- Computation time = 0.0ms
gdot = [ 17.02350757  18.34972831  15.85377834]
 ----- Computation time = 0.0ms

采用矢量化的方式执行，结果更加简洁高效（数据量大时候，更加明显）。且对于np.dot是可以适用于矩阵或者矩阵向量的。对应元素的乘积，可以用np.multiply()或者*操作符。

循环方式和矢量化速度对比：

import time
import numpy as np
a = np.random.rand(1000000)
b = np.random.rand(1000000)
tic = time.time()
c = np.dot(a,b)
print(c)
toc = time.time()
print("vectorized version:" + str(1000*(toc-tic)) + "ms")
c = 0
tic = time.time()
for i in range(1000000):
    c+=a[i]*b[i]
toc = time.time()
print(c)
print("loop version:" + str(1000*(toc-tic)) + "ms")

运行结果如下：

250375.165705
vectorized version:24.0023136138916ms
250375.165705
loop version:543.0543422698975ms

JasonLiu1919

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
DeepLearing学习笔记-数据矢量化

背景：通过矢量化提高矩阵运算速度准备知识：dot/outer/elementwise product 的区别：dot product 点乘：向量点积：向量的点乘,也叫向量的内积、数量积，对两个向量执行点乘运算，就是对这两个向量对应位一一相乘之后求和的操作，点乘的结果是一个标量。定义：a⋅b=||a||||b||cos(θ)a \cdot b= ||a|| ||b||\cos(\theta)，
复制链接

扫一扫

专栏目录