Conversione del tipo sul posto di un array NumPy

Dato un array NumPy di int32, come posso convertirlo sul float32 posto ? Quindi, sostanzialmente, vorrei fare

a = a.astype(numpy.float32)

senza copiare l'array. È grande.

Il motivo per questo è che ho due algoritmi per il calcolo di a. Uno di essi restituisce un array di int32, l'altro restituisce un array di float32(e questo è inerente ai due diversi algoritmi). Tutti gli ulteriori calcoli presuppongono che asia un array di float32.

Attualmente eseguo la conversione in una funzione C chiamata via ctypes. C'è un modo per farlo in Python?

È possibile creare una vista con un tipo diverso, quindi copiarla sul posto nella vista:

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

print(y)

i rendimenti

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

Per mostrare la conversione era sul posto, si noti che la copia da x a yalterato x:

print(x)

stampe

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

Aggiornamento: questa funzione evita la copia solo se possibile, quindi questa non è la risposta corretta a questa domanda. la risposta di unutbu è quella giusta.

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

il tipo numpy ha un flag di copia. Perché non dovremmo usarlo?

È possibile modificare il tipo di array senza convertire in questo modo:

a.dtype = numpy.float32

ma prima devi cambiare tutti i numeri interi in qualcosa che verrà interpretato come il float corrispondente. Un modo molto lento per farlo sarebbe usare il structmodulo di Python in questo modo:

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

... applicato a ciascun membro dell'array.

Ma forse un modo più veloce sarebbe quello di utilizzare gli strumenti ctypeslib di numpy (di cui non ho familiarità)

- modificare -

Dal momento che ctypeslib sembra non funzionare, quindi procederei con la conversione con il numpy.astypemetodo tipico , ma procederò in blocchi di dimensioni che rientrano nei limiti di memoria:

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

... quindi, quando hai finito, cambia il tipo.

Ecco una funzione che compie l'attività per tutti i tipi compatibili (funziona solo per i tipi con elementi della stessa dimensione) e gestisce array di forma arbitraria con controllo dell'utente sulla dimensione del blocco:

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

import numpy as np
arr_float = np.arange(10, dtype=np.float32)
arr_int = arr_float.view(np.float32)

usa view () e il parametro 'dtype' per cambiare l'array in posizione.

Usa questo:

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)

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