Remplacement rapide des valeurs dans un tableau numpy
J'ai un très grand tableau numpy (contenant jusqu'à un million d'éléments) comme celui ci-dessous:
[ 0 1 6 5 1 2 7 6 2 3 8 7 3 4 9 8 5 6 11 10 6 7 12 11 7
8 13 12 8 9 14 13 10 11 16 15 11 12 17 16 12 13 18 17 13 14 19 18 15 16
21 20 16 17 22 21 17 18 23 22 18 19 24 23]
et une petite carte de dictionnaire pour remplacer certains des éléments du tableau ci-dessus
{4: 0, 9: 5, 14: 10, 19: 15, 20: 0, 21: 1, 22: 2, 23: 3, 24: 0}
Je voudrais remplacer certains des éléments selon la carte ci-dessus. Le tableau numpy est vraiment grand, et seul un petit sous-ensemble des éléments (apparaissant comme clés dans le dictionnaire) sera remplacé par les valeurs correspondantes. Quelle est la manière la plus rapide de procéder?
Je pense qu'il existe une méthode encore plus efficace, mais pour l'instant, essayez
from numpy import copy
newArray = copy(theArray)
for k, v in d.iteritems(): newArray[theArray==k] = v
Microbenchmark et test d'exactitude:
#!/usr/bin/env python2.7
from numpy import copy, random, arange
random.seed(0)
data = random.randint(30, size=10**5)
d = {4: 0, 9: 5, 14: 10, 19: 15, 20: 0, 21: 1, 22: 2, 23: 3, 24: 0}
dk = d.keys()
dv = d.values()
def f1(a, d):
b = copy(a)
for k, v in d.iteritems():
b[a==k] = v
return b
def f2(a, d):
for i in xrange(len(a)):
a[i] = d.get(a[i], a[i])
return a
def f3(a, dk, dv):
mp = arange(0, max(a)+1)
mp[dk] = dv
return mp[a]
a = copy(data)
res = f2(a, d)
assert (f1(data, d) == res).all()
assert (f3(data, dk, dv) == res).all()
Résultat:
$ python2.7 -m timeit -s 'from w import f1,f3,data,d,dk,dv' 'f1(data,d)'
100 loops, best of 3: 6.15 msec per loop
$ python2.7 -m timeit -s 'from w import f1,f3,data,d,dk,dv' 'f3(data,dk,dv)'
100 loops, best of 3: 19.6 msec per loop
En supposant que les valeurs sont comprises entre 0 et un entier maximum, on pourrait implémenter un remplacement rapide en utilisant le tableau numpy comme int->int dict, comme ci-dessous
mp = numpy.arange(0,max(data)+1)
mp[replace.keys()] = replace.values()
data = mp[data]
où en premier
data = [ 0 1 6 5 1 2 7 6 2 3 8 7 3 4 9 8 5 6 11 10 6 7 12 11 7
8 13 12 8 9 14 13 10 11 16 15 11 12 17 16 12 13 18 17 13 14 19 18 15 16
21 20 16 17 22 21 17 18 23 22 18 19 24 23]
et remplacer par
replace = {4: 0, 9: 5, 14: 10, 19: 15, 20: 0, 21: 1, 22: 2, 23: 3, 24: 0}
on obtient
data = [ 0 1 6 5 1 2 7 6 2 3 8 7 3 0 5 8 5 6 11 10 6 7 12 11 7
8 13 12 8 5 10 13 10 11 16 15 11 12 17 16 12 13 18 17 13 10 15 18 15 16
1 0 16 17 2 1 17 18 3 2 18 15 0 3]
Une autre façon plus générale d'y parvenir est la vectorisation de fonctions:
import numpy as np
data = np.array([0, 1, 6, 5, 1, 2, 7, 6, 2, 3, 8, 7, 3, 4, 9, 8, 5, 6, 11, 10, 6, 7, 12, 11, 7, 8, 13, 12, 8, 9, 14, 13, 10, 11, 16, 15, 11, 12, 17, 16, 12, 13, 18, 17, 13, 14, 19, 18, 15, 16, 21, 20, 16, 17, 22, 21, 17, 18, 23, 22, 18, 19, 24, 23])
mapper_dict = {4: 0, 9: 5, 14: 10, 19: 15, 20: 0, 21: 1, 22: 2, 23: 3, 24: 0}
def mp(entry):
return mapper_dict[entry] if entry in mapper_dict else entry
mp = np.vectorize(mp)
print mp(data)
Aucune solution n'a encore été publiée sans boucle python sur le tableau (sauf celle de Celil, qui suppose cependant que les nombres sont "petits"), alors voici une alternative:
def replace(arr, rep_dict):
"""Assumes all elements of "arr" are keys of rep_dict"""
# Removing the explicit "list" breaks python3
rep_keys, rep_vals = array(list(Zip(*sorted(rep_dict.items()))))
idces = digitize(arr, rep_keys, right=True)
# Notice rep_keys[digitize(arr, rep_keys, right=True)] == arr
return rep_vals[idces]
la façon dont les "idces" sont créés vient de ici .
J'ai testé certaines solutions, et le résultat est sans appel:
import timeit
import numpy as np
array = 2 * np.round(np.random.uniform(0,10000,300000)).astype(int)
from_values = np.unique(array) # pair values from 0 to 2000
to_values = np.arange(from_values.size) # all values from 0 to 1000
d = dict(Zip(from_values, to_values))
def method_for_loop():
out = array.copy()
for from_value, to_value in Zip(from_values, to_values) :
out[out == from_value] = to_value
print('Check method_for_loop :', np.all(out == array/2)) # Just checking
print('Time method_for_loop :', timeit.timeit(method_for_loop, number = 1))
def method_list_comprehension():
out = [d[i] for i in array]
print('Check method_list_comprehension :', np.all(out == array/2)) # Just checking
print('Time method_list_comprehension :', timeit.timeit(method_list_comprehension, number = 1))
def method_bruteforce():
idx = np.nonzero(from_values == array[:,None])[1]
out = to_values[idx]
print('Check method_bruteforce :', np.all(out == array/2)) # Just checking
print('Time method_bruteforce :', timeit.timeit(method_bruteforce, number = 1))
def method_searchsort():
sort_idx = np.argsort(from_values)
idx = np.searchsorted(from_values,array,sorter = sort_idx)
out = to_values[sort_idx][idx]
print('Check method_searchsort :', np.all(out == array/2)) # Just checking
print('Time method_searchsort :', timeit.timeit(method_searchsort, number = 1))
Et j'ai obtenu les résultats suivants:
Check method_for_loop : True
Time method_for_loop : 2.6411612760275602
Check method_list_comprehension : True
Time method_list_comprehension : 0.07994363596662879
Check method_bruteforce : True
Time method_bruteforce : 11.960559037979692
Check method_searchsort : True
Time method_searchsort : 0.03770717792212963
La méthode "searchsort" est presque cent fois plus rapide que la boucle "for", et environ 600 fois plus rapide que la méthode numpy bruteforce. La méthode de compréhension de liste est également un très bon compromis entre la simplicité du code et la vitesse.
Une solution entièrement vectorisée utilisant np.in1d et np.searchsorted:
replace = numpy.array([list(replace.keys()), list(replace.values())]) # Create 2D replacement matrix
mask = numpy.in1d(data, replace[0, :]) # Find elements that need replacement
data[mask] = replace[1, numpy.searchsorted(replace[0, :], data[mask])] # Replace elements
Le paquet numpy_indexed (avertissement: je suis son auteur) fournit une solution vectorisée élégante et efficace à ce type de problème:
import numpy_indexed as npi
remapped_array = npi.remap(theArray, list(dict.keys()), list(dict.values()))
La méthode mise en œuvre est similaire à l'approche basée sur la recherche avancée mentionnée par Jean Lescut, mais encore plus générale. Par exemple, les éléments du tableau n'ont pas besoin d'être des entiers, mais peuvent être de n'importe quel type, même les sous-réseaux nd eux-mêmes; pourtant, il devrait atteindre le même genre de performances.
La manière pythonique sans avoir besoin que les données soient entières, peut être des chaînes paires:
from scipy.stats import rankdata
import numpy as np
data = np.random.Rand(100000)
replace = {data[0]: 1, data[5]: 8, data[8]: 10}
arr = np.vstack((replace.keys(), replace.values())).transpose()
arr = arr[arr[:,1].argsort()]
unique = np.unique(data)
mp = np.vstack((unique, unique)).transpose()
mp[np.in1d(mp[:,0], arr),1] = arr[:,1]
data = mp[rankdata(data, 'dense')-1][:,1]
for i in xrange(len(the_array)):
the_array[i] = the_dict.get(the_array[i], the_array[i])
Eh bien, vous devez faire un passage par theArray, et pour chaque élément le remplacer s'il est dans le dictionnaire.
for i in xrange( len( theArray ) ):
if foo[ i ] in dict:
foo[ i ] = dict[ foo[ i ] ]