Beschleunigen Sie Ihren Python-Code mit NumPy

Bild von storyset auf Freepik

NumPy ist ein Python-Paket, das häufig für mathematische und statistische Anwendungen verwendet wird. Einige wussten jedoch noch nicht, dass NumPy die Ausführung unseres Python-Codes beschleunigen kann.

Es gibt mehrere Gründe, warum NumPy die Ausführung von Python-Code beschleunigen könnte, darunter:

• NumPy verwendet während der Schleife C-Code anstelle von Python
• Der bessere CPU-Caching-Prozess
• Effiziente Algorithmen bei mathematischen Operationen
• Möglichkeit zur Verwendung paralleler Operationen
• Speichereffizient bei großen Datensätzen und komplexen Berechnungen

Aus vielen Gründen ist NumPy effektiv bei der Verbesserung der Python-Codeausführung. Dieses Tutorial zeigt Beispiele, wie NumPy den Codeprozess beschleunigt. Lassen Sie uns direkt loslegen.

NumPy zur Beschleunigung der Python-Codeausführung

Das erste Beispiel vergleicht numerische Operationen von Python-Pay attention und NumPy-Arrays, die das Objekt mit dem gewünschten Wertergebnis abrufen.

Wir möchten beispielsweise eine Liste von Zahlen aus zwei Pay attention, die wir addieren, additionally führen wir die vektorisierte Operation aus. Wir können das Experiment mit dem folgenden Code versuchen:

import numpy as np
import time

pattern = 1000000

list_1 = vary(pattern)
list_2 = vary(pattern)
start_time = time.time()
consequence = ((x + y) for x, y in zip(list_1, list_2))
print("Time taken utilizing Python lists:", time.time() - start_time)

array_1 = np.arange(pattern)
array_2 = np.arange(pattern)
start_time = time.time()
consequence = array_1 + array_2
print("Time taken utilizing NumPy arrays:", time.time() - start_time)

Output>>
Time taken utilizing Python lists: 0.18960118293762207
Time taken utilizing NumPy arrays: 0.02495265007019043

Wie Sie in der obigen Ausgabe sehen können, ist die Ausführung von NumPy-Arrays beim Erzielen desselben Ergebnisses schneller als die der Python-Liste.

Im gesamten Beispiel werden Sie feststellen, dass die NumPy-Ausführung schneller ist. Sehen wir uns an, ob wir eine statistische Aggregationsanalyse durchführen möchten.

array = np.arange(1000000)

start_time = time.time()
sum_rst = np.sum(array)
mean_rst = np.imply(array)
print("Time taken for aggregation capabilities:", time.time() - start_time)

Output>> 
Time taken for aggregation capabilities: 0.0029935836791992188

NumPy kann die Aggregationsfunktion ziemlich schnell verarbeiten. Wenn wir es mit der Python-Ausführung vergleichen, können wir die Unterschiede in der Ausführungszeit erkennen.

list_1 = checklist(vary(1000000))

start_time = time.time()
sum_rst = sum(list_1)
mean_rst = sum(list_1) / len(list_1)
print("Time taken for aggregation capabilities (Python):", time.time() - start_time)

Output>>
Time taken for aggregation capabilities (Python): 0.09979510307312012

Mit dem gleichen Ergebnis würde die integrierte Funktion von Python viel mehr Zeit in Anspruch nehmen als NumPy. Wenn wir einen viel größeren Datensatz hätten, würde Python viel länger brauchen, um NumPy fertigzustellen.

Ein weiteres Beispiel: Wenn wir versuchen, Operationen direkt durchzuführen, können wir sehen, dass NumPy viel schneller wäre als das Python-Beispiel.

array = np.arange(1000000)
start_time = time.time()
array += 1
print("Time taken for in-place operation:", time.time() - start_time)

list_1 = checklist(vary(1000000))
start_time = time.time()
for i in vary(len(list_1)):
    list_1(i) += 1
print("Time taken for in-place checklist operation:", time.time() - start_time)

Output>>
Time taken for in-place operation: 0.0010089874267578125
Time taken for in-place checklist operation: 0.1937870979309082

Der Punkt des Beispiels besteht darin, dass es viel besser ist, wenn Sie die Möglichkeit haben, mit NumPy zu arbeiten, da der Vorgang dann viel schneller abläuft.

Wir können eine komplexere Implementierung mithilfe der Matrizenmultiplikation ausprobieren, um zu sehen, wie schnell NumPy im Vergleich zu Python ist.

def python_matrix_multiply(A, B):
    consequence = ((0 for _ in vary(len(B(0)))) for _ in vary(len(A)))
    for i in vary(len(A)):
        for j in vary(len(B(0))):
            for ok in vary(len(B)):
                consequence(i)(j) += A(i)(ok) * B(ok)(j)
    return consequence

def numpy_matrix_multiply(A, B):
    return np.dot(A, B)

n = 200
A = ((np.random.rand() for _ in vary(n)) for _ in vary(n))
B = ((np.random.rand() for _ in vary(n)) for _ in vary(n))

A_np = np.array(A)
B_np = np.array(B)

start_time = time.time()
python_result = python_matrix_multiply(A, B)
print("Time taken for Python matrix multiplication:", time.time() - start_time)

start_time = time.time()
numpy_result = numpy_matrix_multiply(A_np, B_np)
print("Time taken for NumPy matrix multiplication:", time.time() - start_time)

Output>>
Time taken for Python matrix multiplication: 1.8010151386260986
Time taken for NumPy matrix multiplication: 0.008051872253417969

Wie Sie sehen, ist NumPy bei komplexeren Aktivitäten, wie beispielsweise der Matrixmultiplikation, bei der Customary-Python-Code verwendet wird, sogar noch schneller.

Wir können noch viele weitere Beispiele ausprobieren, aber NumPy sollte schneller sein als die Ausführungszeiten der integrierten Funktionen von Python.

Abschluss

NumPy ist ein leistungsstarkes Paket für mathematische und numerische Prozesse. Im Vergleich zu den integrierten Standardfunktionen von Python ist die Ausführungszeit von NumPy schneller als die des Python-Gegenstücks. Versuchen Sie daher, NumPy zu verwenden, wenn es anwendbar ist, um unseren Python-Code zu beschleunigen.

Cornellius Yudha Wijaya ist Information Science Assistant Supervisor und Datenautor. Während seiner Vollzeitbeschäftigung bei Allianz Indonesien teilt er gerne Python- und Datentipps über soziale Medien und in den Medien. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.