[PYTHON] Considérez la vitesse de traitement pour déplacer le tampon d'image avec numpy.ndarray

Contexte

Lors du traitement d'une vidéo, vous souhaiterez peut-être mettre en mémoire tampon n images consécutives. Ainsi, lorsque vous voulez rouler le tampon et l'utiliser, vous devez décaler l'index du tampon.

Lors du traitement avec numpy, je pense qu'il existe les deux méthodes de traitement suivantes.

1. Utilisez la méthode numpy.roll
2. Décalez l'index du tableau et attribuez

Je souhaite utiliser la méthode de traitement la plus rapide possible, je vais donc considérer lequel de ces deux processus est le plus rapide.

environnement

• python 3.7.1
• numpy 1.16.1
• jupyter notebook

résultat de l'inspection

J'ai essayé le processus suivant sur un ordinateur portable jupyter.

Définit le premier index du tableau sur l'index indiquant le nombre d'images

arr1 = np.zeros((30, 720, 1280))
# numpy.Utilisez la méthode du rouleau
%timeit np.roll(arr1, 1, axis = 0)
# 147 ms ± 1.73 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

#Remplacer par décalage par index
%timeit arr1[1:,:,:] = arr1[0:-1,:,:]
# 189 ms ± 7.14 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Définit le dernier index du tableau sur l'index indiquant le nombre d'images

arr2 = np.zeros((720, 1280, 30))
# numpy.Utilisez la méthode du rouleau
%timeit np.roll(arr2, 1, axis = 2)
# 186 ms ± 2.71 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

#Remplacer par décalage par index
%timeit arr2[:,:, 1:] = arr2[:,:,0:-1]
# 203 ms ± 1.06 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)

Il semble que l'utilisation de numpy.roll soit plus rapide à condition que la taille de l'image soit grande. De plus, il semble plus rapide de changer d'image au premier index.

Si l'image est petite

Lorsque l'image est très petite (20x20pixel), le résultat est que le décalage d'index est plus rapide, comme indiqué ci-dessous.

arr3 = np.zeros((30, 20, 20))
# numpy.Utilisez la méthode du rouleau
%timeit np.roll(arr3, 1, axis = 0)
# 17.1 µs ± 551 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

#Remplacer par décalage par index
%timeit arr3[1:,:,:] = arr3[0:-1,:,:]
# 7.36 µs ± 90.1 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

Points auxquels j'étais accro en termes de mise en œuvre du traitement

#erreur
arr[0:-2,:,:] = arr[1:-1,:,:]
arr[-1,:,:] = new_image

#Bonne réponse
arr[0:-1,:,:] = arr[1:,:,:]
arr[-1,:,:] = new_image

La définition du premier index sur -1 spécifie le dernier index.

arr[1:-1,:,:]Puis

 À première vue, il semble que vous puissiez spécifier du deuxième au premier (jusqu'au dernier index).
 En fait, puisque la seconde à la seconde est spécifiée, le mouvement est que la dernière image ne se déplace pas vers l'avant.