Come faccio a creare un array intorpidito da un generatore?

Come posso costruire una matrice numpy da un oggetto generatore?

Vorrei illustrare il problema:

>>> import numpy
>>> def gimme():
...   for x in xrange(10):
...     yield x
...
>>> gimme()
<generator object at 0x28a1758>
>>> list(gimme())
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> numpy.array(xrange(10))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> numpy.array(gimme())
array(<generator object at 0x28a1758>, dtype=object)
>>> numpy.array(list(gimme()))
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

In questo caso, gimme()è il generatore il cui output mi piacerebbe trasformare in un array. Tuttavia, il costruttore dell'array non esegue l'iterazione sul generatore, ma memorizza semplicemente il generatore stesso. Il comportamento che desidero è quello di numpy.array(list(gimme())), ma non voglio pagare l'overhead di memoria di avere contemporaneamente l'elenco intermedio e l'array finale. Esiste un modo più efficiente in termini di spazio?

Le matrici Numpy richiedono che la loro lunghezza sia impostata esplicitamente al momento della creazione, a differenza delle liste di Python. Ciò è necessario affinché lo spazio per ciascun elemento possa essere allocato consecutivamente in memoria. L'allocazione consecutiva è la caratteristica chiave degli array intorpiditi: questo combinato con l'implementazione del codice nativo consente alle operazioni su di essi di eseguire molto più rapidamente degli elenchi regolari.

Tenendo presente questo, è tecnicamente impossibile prendere un oggetto generatore e trasformarlo in un array a meno che:

1. può prevedere quanti elementi produrrà durante l'esecuzione:

   my_array = numpy.empty(predict_length())
   for i, el in enumerate(gimme()): my_array[i] = el
   

2. sono disposti a memorizzare i suoi elementi in un elenco intermedio:

   my_array = numpy.array(list(gimme()))

3. può creare due generatori identici, eseguire il primo per trovare la lunghezza totale, inizializzare l'array e quindi eseguire nuovamente il generatore per trovare ogni elemento:

   length = sum(1 for el in gimme())
   my_array = numpy.empty(length)
   for i, el in enumerate(gimme()): my_array[i] = el
   

1 è probabilmente quello che stai cercando. 2 è spazio inefficiente e 3 è tempo inefficiente (è necessario attraversare il generatore due volte).

Un google dietro questo risultato stackoverflow, ho scoperto che esiste un numpy.fromiter(data, dtype, count). L'impostazione predefinita count=-1prende tutti gli elementi dall'iterabile. Richiede dtypedi essere impostato esplicitamente. Nel mio caso, ha funzionato:

numpy.fromiter(something.generate(from_this_input), float)

Mentre puoi creare un array 1D da un generatore con numpy.fromiter(), puoi creare un array ND da un generatore con numpy.stack:

>>> mygen = (np.ones((5, 3)) for _ in range(10))
>>> x = numpy.stack(mygen)
>>> x.shape
(10, 5, 3)

Funziona anche con array 1D:

>>> numpy.stack(2*i for i in range(10))
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])

Si noti che numpy.stacksta consumando internamente il generatore e creando un elenco intermedio con arrays = [asanyarray(arr) for arr in arrays]. L'implementazione può essere trovata qui .

Un po 'tangenziale, ma se il tuo generatore è una comprensione dell'elenco, puoi usarlo numpy.whereper ottenere in modo più efficace il tuo risultato (l'ho scoperto nel mio codice dopo aver visto questo post)

Le funzioni vstack , hstack e dstack possono assumere come generatori di input che producono array multidimensionali.