Conversion de type place d'un tableau NumPy

Question

Étant donné un tableau NumPy de int32, comment le convertir en float32en place? Donc, fondamentalement, je voudrais faire

a = a.astype(numpy.float32) 

sans copier le tableau. C'est gros.

La raison pour cela est que j'ai deux algorithmes pour le calcul de a. L'un d'entre eux renvoie un tableau de int32, l'autre renvoie un tableau de float32 (et ceci est inhérent aux deux algorithmes différents). Tous les autres calculs supposent que a est un tableau de float32.

Actuellement, je fais la conversion dans une fonction C appelée via ctypes. Y a-t-il un moyen de faire ça en Python?

Answer 1

Vous pouvez faire une vue avec un autre DTYPE, puis copiez en place dans la vue:

import numpy as np 
x = np.arange(10, dtype='int32') 
y = x.view('float32') 
y[:] = x 

print(y) 

donne

array([ 0., 1., 2., 3., 4., 5., 6., 7., 8., 9.], dtype=float32) 

Pour montrer la conversion était en place, notez que la copie dex à y modifié x:

print(x) 

impressions

array([   0, 1065353216, 1073741824, 1077936128, 1082130432, 
     1084227584, 1086324736, 1088421888, 1090519040, 1091567616]) 

Answer 2

Vous pouvez modifier le type de tableau sans conversion comme ceci:

a.dtype = numpy.float32 

mais vous devez changer tous les entiers à quelque chose qui sera interprété comme le flotteur correspondant. Une façon très lent à faire serait d'utiliser le module struct de python comme ceci:

def toi(i): 
    return struct.unpack('i',struct.pack('f',float(i)))[0] 

... appliqué à chaque membre de votre tableau.

Mais peut-être un moyen plus rapide serait d'utiliser les outils de ctypeslib de numpy (que je ne connais pas bien)

- modifier -

Depuis ctypeslib ne marche pas semble fonctionner, alors je procéder à la conversion avec la méthode numpy.astype typique, mais procéder à des tailles de blocs qui se trouvent dans les limites de votre mémoire:

a[0:10000] = a[0:10000].astype('float32').view('int32') 

... puis changer le DTYPE lorsque vous avez terminé.

Voici une fonction qui accomplit la tâche pour tout dtypes compatible (ne fonctionne que pour dtypes avec des objets de même taille) et gère des réseaux arbitrairement en forme avec l'utilisateur contrôle sur la taille des blocs:

import numpy 

def astype_inplace(a, dtype, blocksize=10000): 
    oldtype = a.dtype 
    newtype = numpy.dtype(dtype) 
    assert oldtype.itemsize is newtype.itemsize 
    for idx in xrange(0, a.size, blocksize): 
     a.flat[idx:idx + blocksize] = \ 
      a.flat[idx:idx + blocksize].astype(newtype).view(oldtype) 
    a.dtype = newtype 

a = numpy.random.randint(100,size=100).reshape((10,10)) 
print a 
astype_inplace(a, 'float32') 
print a 

Answer 3

Mise à jour: Cette fonction permet d'éviter que la copie si elle peut, par conséquent, Ce n'est pas la bonne réponse à cette question. La réponse de @ unutbu est la bonne.

---

a = a.astype(numpy.float32, copy=False) 

numpy astype a un drapeau de copie. Pourquoi ne devrions-nous pas l'utiliser?

Answer 4

Utilisez ceci:

In [105]: a 
Out[105]: 
array([[15, 30, 88, 31, 33], 
     [53, 38, 54, 47, 56], 
     [67, 2, 74, 10, 16], 
     [86, 33, 15, 51, 32], 
     [32, 47, 76, 15, 81]], dtype=int32) 

In [106]: float32(a) 
Out[106]: 
array([[ 15., 30., 88., 31., 33.], 
     [ 53., 38., 54., 47., 56.], 
     [ 67., 2., 74., 10., 16.], 
     [ 86., 33., 15., 51., 32.], 
     [ 32., 47., 76., 15., 81.]], dtype=float32) 

Answer 5

a = np.subtract(a, 0., dtype=np.float32)