python 使用矢量化替换循环

介绍

循环自然而然地出现在我们身边，我们了解几乎所有编程语言中的循环。因此，默认情况下，只要有重复操作，我们就会开始执行循环。但是当我们处理大量迭代（数百万/十亿行）时，使用循环是一种犯罪。您可能会被困几个小时，后来才意识到它行不通。这就是在 python 中实现矢量化变得非常关键的地方。

什么是矢量化？

矢量化是在数据集上实现 (NumPy) 数组操作的技术。在后台，它将一次性运算数组中所有元素（不同于一次操作一行的“for”循环）。
下面我将用一些示例，分别使用python 循环和矢量化实现，看下能够帮助您节省出多少时间。
就是把能数学运算的数据（int、float）放到numpy的数组中处理

示例

示例1：求数字之和

循环

import time 
start = time.time()

total = 0
for item in range(0, 1500000):
    total = total + item


print('sum is:' + str(total))
end = time.time()

print(end - start)

#sum is 1124999250000
#0.14 Seconds

矢量化

import numpy as np

start = time.time()
print(np.sum(np.arange(1500000)))

end = time.time()

print(end - start)

#1124999250000
#0.008 Seconds

与使用循环函数的迭代相比，矢量化的执行时间减少了约 18 倍。在使用 Pandas DataFrame 时，这种差异将变得更加显着。

示例2：在DataFrame上数学运算

DataFrame 是行和列形式的表格数据。
创建一个具有 500 万行和 4 列的 pandas DataFrame，其中填充了 0 到 50 之间的随机值。

import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randint(0, 50, size=(5000000, 4)), columns=('a','b','c','d'))
df.shape
# (5000000, 5)
df.head()

目的创建一个新列“ratio”来保存列“d”和“c”的比率。
循环

import time 
start = time.time()

for idx, row in df.iterrows():
    df.at[idx,'ratio'] = 100 * (row["d"] / row["c"])  
end = time.time()
print(end - start)
# 109 Seconds

矢量化

start = time.time()
df["ratio"] = 100 * (df["d"] / df["c"])

end = time.time()
print(end - start)
# 0.12 seconds

我们可以看到 DataFrame 的显着改进，与 Python 中的循环相比，矢量化操作所花费的时间几乎快 1000 倍。

示例3：在 DataFrame 上If-else语句

基于示例2，我们根据现有列“a”上的某些条件创建一个新列“e”。
循环

import time 
start = time.time()

for idx, row in df.iterrows():
    if row.a == 0:
        df.at[idx,'e'] = row.d    
    elif (row.a <= 25) & (row.a > 0):
        df.at[idx,'e'] = (row.b)-(row.c)    
    else:
        df.at[idx,'e'] = row.b + row.c

end = time.time()

print(end - start)
#177 seconds

矢量化

start = time.time()
df['e'] = df['b'] + df['c']
df.loc[df['a'] <= 25, 'e'] = df['b'] -df['c']
df.loc[df['a']==0, 'e'] = df['d']end = time.time()
print(end - start)
# 0.28007707595825195 sec

与使用 if-else 语句的 python 循环相比，矢量化操作所花费的时间快 600 倍。

示例4：机器学习/深度学习

深度学习要求我们解决多个复杂的方程式，而且需要解决数百万和数十亿行的问题。在 Python 中运行循环来求解这些方程式非常慢，矢量化是最佳解决方案。
例如，计算以下多元线性回归方程中数百万行的 y 值：

循环

import numpy as np
m = np.random.rand(1,5)
x = np.random.rand(5000000,5)

total = 0
tic = time.process_time()

for i in range(0,5000000):
    total = 0
    for j in range(0,5):
        total = total + x[i][j]*m[0][j] 
        
    zer[i] = total 

toc = time.process_time()
print(str((toc - tic)) + "seconds")

# 28.228 seconds

矢量化

tic = time.process_time()

np.dot(x,m.T) 

toc = time.process_time()
print(str((toc - tic)) + "seconds")
# 0.107 seconds

np.dot 在后端实现矢量化矩阵乘法。与 Python 中的循环相比，它快 165 倍。