Comment écrire plus rapidement en utilisant numpy comme deque

Chose que tu veux faire

Si vous voulez faire quelque chose comme deque avec numpy.ndarray, est-il plus rapide d'utiliser simplement np.append (x, y) et np.delete (x, 0), ou vous devriez utiliser deque puis ndarray. Je vais vérifier cela.

Code suspect qui semble être en retard

x = np.append(x, 1)
x = np.delete(x, 0)

Je l'ai ajouté à la fin et supprimé le début.

numpy semble sécuriser une zone de longueur fixe lors de la création d'un tableau, donc changer la longueur semble être un peu lent.

Cette vérification semble concerner le FIFO [First-In First-Out / First-In First-Out], mais on suppose que l'ensemble est lu sans lire le début. En d'autres termes, il s'agit d'une vérification lorsqu'elle est utilisée comme un tampon.

Cette fois, je veux utiliser numpy.mean () et numpy.std () chaque fois que je l'ajoute, j'ai donc limité les conditions pour que ce soit numpy.ndarray à la fin. Si vous souhaitez simplement créer un tableau, il est plus rapide d'utiliser deque tel quel, mais vous ne pouvez pas utiliser la moyenne de numpy () et std () tel quel.

Cette fois, en supposant que la fonction numpy est utilisée pour chaque boucle, je voudrais comparer le coût de conversion, y compris le coût de conversion.

Candidat alternatif

Utilisez numpy.roll ()

x = np.roll(x, -1)
x[-1] = 1

Le moyen le plus simple est de le déplacer par un comme deque et de le remplacer à l'arrière.

ajouter et supprimer

x = np.append(x, 1)
x = np.delete(x, 0)

Exactement ce que tu veux faire. Cela semble être tard, donc je vérifie cette fois.

Copiez-en un avant et remplacez-le à la fin

x[0:-1] = x[1:]
x[-1] = 1

Le tranchage semble être rapide, il semble donc que cela fasse quelque chose de similaire à rouler, mais c'est subtilement différent.

Manipulez avec deque puis convertissez en numpy.ndarray

d.append(1)
x = np.array(d)

Où d est le deque généré par d = deque (maxlen). Si maxlen est spécifié, le début disparaîtra sans autorisation. Deque est extrêmement rapide si vous ajoutez simplement, mais cette fois, vous devez le convertir en numpy.array à chaque fois.

code de vérification

Ensuite, c'est la vérification qui est la plus rapide. Cliquez ici pour le code utilisé pour la vérification

import time
import numpy as np
from collections import deque

xlen = 1000

n = 100000

x = np.zeros(xlen)

s = time.time()
for i in range(n):
    x = np.roll(x, -1)
    x[-1] = 1

print(time.time() - s)

s = time.time()
for i in range(n):
    x = np.append(x, 1)
    x = np.delete(x, 0)

print(time.time() - s)

s = time.time()
for i in range(n):
    x[0:-1] = x[1:]
    x[-1] = 1

print(time.time() - s)

#Déclaration et initialisation de deque
d = deque(maxlen=xlen)
for i in range(xlen):
	d.append(1)

s = time.time()
for i in range(n):
    d.append(1)
    x = np.array(d)

print(time.time() - s)

résultat de l'inspection

Je l'ai exécuté avec python3.8.

Le résultat le plus rapide était ** la copie par tranches et l'attribution à la fin **. Il est également peu probable que le code présumé soit le mauvais choix. Deque peut également être bon car np.array () n'est pas si lent lorsque le tableau est court. S'il s'allonge, cela prendra énormément de temps pour np.array (), ce qui est dangereux.

J'espère que cela vous sera utile.