web-dev-qa-db-fra.com

Numpy modify array en place?

J'ai le code suivant qui tente de normaliser les valeurs d'un tableau m x n (il sera utilisé comme entrée dans un réseau de neurones, où m est le nombre d'exemples d'apprentissage et n est le nombre de fonctionnalités).

Cependant, lorsque j'inspecte le tableau dans l'interpréteur après l'exécution du script, je constate que les valeurs ne sont pas normalisées. c'est-à-dire qu'ils ont toujours les valeurs d'origine. J'imagine que c'est parce que l'affectation à la variable array à l'intérieur de la fonction est uniquement visible à l'intérieur de la fonction.

Comment puis-je faire cette normalisation en place? Ou dois-je retourner un nouveau tableau à partir de la fonction de normalisation?

import numpy

def normalize(array, imin = -1, imax = 1):
    """I = Imin + (Imax-Imin)*(D-Dmin)/(Dmax-Dmin)"""

    dmin = array.min()
    dmax = array.max()

    array = imin + (imax - imin)*(array - dmin)/(dmax - dmin)
    print array[0]


def main():

    array = numpy.loadtxt('test.csv', delimiter=',', skiprows=1)
    for column in array.T:
        normalize(column)

    return array

if __== "__main__":
    a = main()
pythonarraysnumpyin-place
24
User

Si vous souhaitez appliquer des opérations mathématiques à un tableau numpy sur place, vous pouvez simplement utiliser les opérateurs sur place standard +=, -=, /=, etc. Ainsi, par exemple:

>>> def foo(a):
...     a += 10
... 
>>> a = numpy.arange(10)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> foo(a)
>>> a
array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19])

La version en place de ces opérations est un peu plus rapide à démarrer, en particulier pour les baies plus volumineuses:

>>> def normalize_inplace(array, imin=-1, imax=1):
...         dmin = array.min()
...         dmax = array.max()
...         array -= dmin
...         array *= imax - imin
...         array /= dmax - dmin
...         array += imin
...     
>>> def normalize_copy(array, imin=-1, imax=1):
...         dmin = array.min()
...         dmax = array.max()
...         return imin + (imax - imin) * (array - dmin) / (dmax - dmin)
... 
>>> a = numpy.arange(10000, dtype='f')
>>> %timeit normalize_inplace(a)
10000 loops, best of 3: 144 us per loop
>>> %timeit normalize_copy(a)
10000 loops, best of 3: 146 us per loop
>>> a = numpy.arange(1000000, dtype='f')
>>> %timeit normalize_inplace(a)
100 loops, best of 3: 12.8 ms per loop
>>> %timeit normalize_copy(a)
100 loops, best of 3: 16.4 ms per loop
22
senderle

C'est un truc qui est légèrement plus général que les autres réponses utiles ici:

def normalize(array, imin = -1, imax = 1):
    """I = Imin + (Imax-Imin)*(D-Dmin)/(Dmax-Dmin)"""

    dmin = array.min()
    dmax = array.max()

    array[...] = imin + (imax - imin)*(array - dmin)/(dmax - dmin)

Ici, nous assignons des valeurs à la vue array[...] plutôt que d’attribuer ces valeurs à une nouvelle variable locale dans l’étendue de la fonction.

x = np.arange(5, dtype='float')
print x
normalize(x)
print x

>>> [0. 1. 2. 3. 4.]
>>> [-1.  -0.5  0.   0.5  1. ]
4
Ian Hincks
def normalize(array, imin = -1, imax = 1):
    """I = Imin + (Imax-Imin)*(D-Dmin)/(Dmax-Dmin)"""

    dmin = array.min()
    dmax = array.max()


    array -= dmin;
    array *= (imax - imin)
    array /= (dmax-dmin)
    array += imin

    print array[0]
4
ely

Il existe un bon moyen de procéder à la normalisation sur place lors de l’utilisation de numpy. np.vectorize est très utile lorsqu'il est combiné à une fonction lambda lorsqu’il est appliqué à un tableau. Voir l'exemple ci-dessous:

import numpy as np

def normalizeMe(value,vmin,vmax):

    vnorm = float(value-vmin)/float(vmax-vmin)

    return vnorm

imin = 0
imax = 10
feature = np.random.randint(10, size=10)

# Vectorize your function (only need to do it once)
temp = np.vectorize(lambda val: normalizeMe(val,imin,imax)) 
normfeature = temp(np.asarray(feature))

print feature
print normfeature

On peut comparer les performances avec une expression génératrice, mais il existe probablement de nombreuses autres manières de procéder.

%%timeit
temp = np.vectorize(lambda val: normalizeMe(val,imin,imax)) 
normfeature1 = temp(np.asarray(feature))
10000 loops, best of 3: 25.1 µs per loop


%%timeit
normfeature2 = [i for i in (normalizeMe(val,imin,imax) for val in feature)]
100000 loops, best of 3: 9.69 µs per loop

%%timeit
normalize(np.asarray(feature))
100000 loops, best of 3: 12.7 µs per loop

La vectorisation n’est donc certainement pas la plus rapide, mais elle peut être évocatrice dans les cas où les performances ne sont pas aussi importantes.

1
salomonvh