Programmiererforum

Ich habe den folgenden Code in Python3 und vergleiche die Numba Jit Compiler -Leistung mit einem regulären Code.import warnings
warnings.filterwarnings("ignore") #https://github.com/numba/numba/issues/4553
import timeit
import numpy as np
from numba import jit

A = list(range(1, 5000000, 1))

# Algorithms to be tested

def makeSquareLoopFor(A):
result = []
for i, v in enumerate(A):
result.append(A[i]**2)
return result

makeSquareLoopForBenchmark = timeit.timeit("makeSquareLoopFor(A)", globals=globals(), number=1)
print("makeSquareLoopForBenchmark =", makeSquareLoopForBenchmark)

@jit(nopython=True)
def makeSquareLoopForJit(A):
result = []
for i, v in enumerate(A):
result.append(A[i]**2)
return result

makeSquareLoopForBenchmarkJit = timeit.timeit("makeSquareLoopForJit(A)", globals=globals(), number=1)
print("makeSquareLoopForBenchmarkJit =", makeSquareLoopForBenchmarkJit)
print()

def makeSquareLoopWhile(A):
result = []
i = 0
while i < len(A):
result.append(A[i]**2)
i += 1
return result

makeSquareLoopWhileBenchmark = timeit.timeit("makeSquareLoopWhile(A)", globals=globals(), number=1)
print("makeSquareLoopWhileBenchmark =", makeSquareLoopWhileBenchmark)

@jit(nopython=True)
def makeSquareLoopWhileJit(A):
result = []
i = 0
while i < len(A):
result.append(A[i]**2)
i += 1
return result

makeSquareLoopWhileJitBenchmark = timeit.timeit("makeSquareLoopWhileJit(A)", globals=globals(), number=1)
print("makeSquareLoopWhileJitBenchmark =", makeSquareLoopWhileJitBenchmark)
print()

def makeSquareListComprehension(A):
return [v**2 for v in A]

makeSquareListComprehensionBenchmark = timeit.timeit("makeSquareListComprehension(A)", globals=globals(), number=1)
print("makeSquareListComprehensionBenchmark =", makeSquareListComprehensionBenchmark)

@jit(nopython=True)
def makeSquareListComprehensionJit(A):
return [v**2 for v in A]

makeSquareListComprehensionJitBenchmark = timeit.timeit("makeSquareListComprehensionJit(A)", globals=globals(), number=1)
print("makeSquareListComprehensionJitBenchmark =",makeSquareListComprehensionJitBenchmark)
print()

def makeSquareMap(A):
return list(map(lambda v: v**2, A ))

makeSquareMapBenchmark = timeit.timeit("makeSquareMap(A)", globals=globals(), number=1)
print("makeSquareMapBenchmark =", makeSquareMapBenchmark)

@jit(nopython=True)
def makeSquareMapJit(A):
return list(map(lambda v: v**2, A ))

makeSquareMapJitBenchmark = timeit.timeit("makeSquareMapJit(A)", globals=globals(), number=1)
print("makeSquareMapJitBenchmark =", makeSquareMapJitBenchmark)
print()

def makeSquareNumpy(A):
return np.square(A)

makeSquareNumpyBenchmark = timeit.timeit("makeSquareNumpy(A)", globals=globals(), number=1)
print("makeSquareNumpyBenchmark =", makeSquareNumpyBenchmark)

# @jit(nopython=True)
def makeSquareNumpyJit(A):
return np.square(A)

makeSquareNumpyJitBenchmark = timeit.timeit("makeSquareNumpyJit(A)", globals=globals(), number=1)
print("makeSquareNumpyJitBenchmark =", makeSquareNumpyJitBenchmark)
< /code>
Wie wir in der folgenden Ausgabe sehen können, spielt der Numba JIT-Compiler im Vergleich zu keinem Numba-Code nicht wie erwartet.makeSquareLoopForBenchmark = 1.6181618960108608
makeSquareLoopForBenchmarkJit = 7.653679737006314

makeSquareLoopWhileBenchmark = 2.3787347140023485
makeSquareLoopWhileJitBenchmark = 7.815255765017355

makeSquareListComprehensionBenchmark = 2.4829419960151426
makeSquareListComprehensionJitBenchmark = 8.279022732982412

makeSquareMapBenchmark = 1.5203839530004188
makeSquareMapJitBenchmark = 7.935965497017605

makeSquareNumpyBenchmark = 0.43739607697352767
makeSquareNumpyJitBenchmark = 0.4406902039772831
< /code>
Was fehlt mir hier? Warum ist die Numba weniger leistungsfähig als normales Python?