Почему эти почти идентичные функции работают по -разному? ⇐ Python

[Anonymous]

Я написал четыре функции, которые изменяют квадратный 2D -массив на месте, он отражает половину от квадратной массивы, разграниченной двумя сторонами, которые встречаются, и соответствующие диагонали 45 градусов, на другую половину, разделенную одной и той же диагональю. Product (('lower', 'Upper'), ('right', 'left')) .
Они используют Numba для компиляции справедливого времени, и они параллелизируются с использованием numba.prange и, следовательно, намного быстрее, чем методы, предоставляемые Numpy:

In [2]: sqr = np.random.randint(0, 256, (1000, 1000), dtype=np.uint8)

In [3]: %timeit x, y = np.tril_indices(1000); sqr[x, y] = sqr[y, x]
9.16 ms ± 30.9 μs per loop (mean ± std. dev. of 7 runs, 100 loops each)
< /code>
Как видите, приведенный выше код занимает очень много времени для выполнения. < /p>

Код: Выделить всё

import numpy as np
import numba as nb

@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_LL2UR(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")

for i in nb.prange(height):
arr[i, i:] = arr[i:, i]

@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_UR2LL(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")

for i in nb.prange(height):
arr[i:, i] = arr[i, i:]

@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_LR2UL(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")

last = height - 1
for i in nb.prange(height):
arr[i, last - i :: -1] = arr[i:, last - i]

@nb.njit(cache=True, parallel=True, nogil=True)
def triangle_flip_UL2LR(arr: np.ndarray) -> None:
height, width = arr.shape[:2]
if height != width:
raise ValueError("argument arr must be a square")

last = height - 1
for i in nb.prange(height):
arr[i:, last - i] = arr[i, last - i :: -1]
< /code>
In [4]: triangle_flip_LL2UR(sqr)

In [5]: triangle_flip_UR2LL(sqr)

In [6]: triangle_flip_LR2UL(sqr)

In [7]: triangle_flip_UL2LR(sqr)

In [8]: %timeit triangle_flip_LL2UR(sqr)
194 μs ± 634 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [9]: %timeit triangle_flip_UR2LL(sqr)
488 μs ± 3.26 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [10]: %timeit triangle_flip_LR2UL(sqr)
196 μs ± 501 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

In [11]: %timeit triangle_flip_UL2LR(sqr)
486 μs ± 855 ns per loop (mean ± std. dev. of 7 runs, 1,000 loops each)
< /code>
Почему у них есть время выполнения со значительной разницей? Двое из них требуют около 200 микросекундов для выполнения, два других около 500 микросекунд, несмотря на то, что они почти идентичны. < /P>

Я что -то обнаружил. triangle_flip_ur2ll (arr) 

то же самое, что и triangle_flip_ll2ur (sqr.t) и наоборот.

Код: Выделить всё

In [109]: %timeit triangle_flip_UR2LL(sqr.T)
196 μs ± 1.15 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

In [110]: %timeit triangle_flip_LL2UR(sqr.T)
490 μs ± 1.24 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

Почему это происходит?


Подробнее здесь: https://stackoverflow.com/questions/795 ... ifferently