Verwenden der Vektorisierung zum Ersetzen von Schleifen in Python

Alle Programmiersprachen sind untrennbar mit Schleifen verbunden. Daher beginnen wir standardmäßig mit der Ausführung einer Schleife, wann immer es einen sich wiederholenden Vorgang gibt. Aber wenn wir es mit einer großen Anzahl von Iterationen (Millionen/Milliarden Zeilen) zu tun haben, ist die Verwendung von Schleifen ein Verbrechen. Möglicherweise stecken Sie ein paar Stunden lang fest, nur um später festzustellen, dass es nicht funktioniert. An dieser Stelle wird die Implementierung der Vektorisierung in Python sehr wichtig.

Was ist Vektorisierung?

Vektorisierung ist eine Technik zum Implementieren von (NumPy)-Array-Operationen an einem Datensatz. Im Hintergrund wird die Operation auf alle Elemente des Arrays oder der Reihe gleichzeitig angewendet (im Gegensatz zu einer „for“-Schleife, die jeweils eine Zeile bearbeitet).

Als nächstes zeigen wir anhand einiger Anwendungsfälle, was Vektorisierung ist.

Summe der Zahlen

##使用循环
import time 
start = time.time()

 
# iterative sum
total = 0
# iterating through 1.5 Million numbers
for item in range(0, 1500000):
total = total + item


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

print(end - start)

#1124999250000
#0.14 Seconds

## 使用矢量化
import numpy as np

start = time.time()

# vectorized sum - using numpy for vectorization
# np.arange create the sequence of numbers from 0 to 1499999
print(np.sum(np.arange(1500000)))

end = time.time()

print(end - start)


##1124999250000
##0.008 Seconds

Die Ausführungszeit der Vektorisierung wird im Vergleich zur Iteration mit Bereichsfunktionen um etwa das 18-fache reduziert. Dieser Unterschied wird noch deutlicher, wenn Pandas DataFrame verwendet wird.

Matheoperationen

In der Datenwissenschaft verwenden Entwickler bei der Arbeit mit Pandas DataFrame Schleifen, um durch mathematische Operationen neue abgeleitete Spalten zu erstellen.

Im folgenden Beispiel können wir sehen, wie einfach es ist, Schleifen durch Vektorisierung für solche Anwendungsfälle zu ersetzen.

DataFrame sind tabellarische Daten in Form von Zeilen und Spalten.

Wir erstellen einen Pandas-DataFrame mit 5 Millionen Zeilen und 4 Spalten, gefüllt mit Zufallswerten zwischen 0 und 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()

Erstellen Sie eine neue Spalte „Verhältnis“, um das Verhältnis der Spalten „d“ und „c“ zu ermitteln.

## 循环遍历
import time 
start = time.time() 

# 使用 iterrows 遍历 DataFrame 
for idx, row in df.iterrows(): 
# 创建一个新列
df.at[idx, 'ratio' ] = 100 * (row[ "d" ] / row[ "c" ]) 
end = time.time() 
print (end - start) 
### 109 秒

## 使用矢量化
start = time.time() 
df[ "ratio" ] = 100 * (df[ "d" ] / df[ "c" ]) 

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

Wir können mit dem DataFrame erhebliche Verbesserungen feststellen, da die vektorisierte Operation im Vergleich zur Schleife in Python fast 1000-mal schneller dauert.

If-else-Anweisungen

Wir haben viele Operationen implementiert, die die Verwendung einer Logik vom Typ „If-else“ erfordern. Wir können diese Logik leicht durch vektorisierte Operationen in Python ersetzen.

Sehen wir uns das folgende Beispiel an, um es besser zu verstehen (wir werden den DataFrame verwenden, den wir in Anwendungsfall 2 erstellt haben):

Stellen Sie sich vor, wir möchten eine neue Spalte basierend auf einigen Bedingungen für die vorhandene Spalte „a“ erstellen. e"

## 使用循环
import time 
start = time.time() 

# 使用 iterrows 遍历 DataFrame 
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) 
### 耗时：166 秒

## 矢量化
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()
打印（结束 - 开始）
## 0.29007707595825195 秒

Der vektorisierte Vorgang dauert 600-mal schneller im Vergleich zu einer Python-Schleife mit if-else-Anweisungen.

Lösen von Netzwerken für maschinelles Lernen/Deep Learning

Deep Learning erfordert, dass wir mehrere komplexe Gleichungen und Probleme mit Millionen und Abermilliarden von zu lösenden Linien lösen. Das Ausführen von Schleifen zur Lösung dieser Gleichungen in Python ist sehr langsam und die Vektorisierung ist die beste Lösung.

Um beispielsweise die y-Werte für Millionen von Zeilen in der folgenden multiplen linearen Regressionsgleichung zu berechnen:

Wir können Vektorisierung anstelle von Schleifen verwenden. Die Werte von

m1, m2, m3… werden durch Lösen der obigen Gleichung unter Verwendung von Millionen von Werten entsprechend x1, x2, x3…

import numpy as np 
# 设置 m 的初始值
m = np.random.rand( 1 , 5 ) 

# 500 万行的输入值
x = np.random.rand( 5000000 , 5 )

## 使用循环
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 ("Computation time = "+ str ((toc - tic)) + "seconds" ) 

####计算时间 = 27.02 秒

## 矢量化
tic = time.process_time() 

#dot product
np.dot(x,mT) 

toc = time.process_time() 
print ( "计算时间 = " + str ((toc - tic)) + "seconds" ) 

####计算时间 = 0.107 秒

np vektorisierte Matrixmultiplikation im Backend. Im Vergleich zu Schleifen in Python ist es 165-mal schneller.

Fazit

Die Vektorisierung in Python ist sehr schnell und sollte Schleifen vorgezogen werden, wenn wir mit sehr großen Datensätzen arbeiten.

Wenn Sie mit der Zeit mit der Implementierung beginnen, werden Sie sich daran gewöhnen, entlang vektorisierter Codezeilen zu denken.

Das obige ist der detaillierte Inhalt vonVerwenden der Vektorisierung zum Ersetzen von Schleifen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!