Partitionner un tableau en N morceaux avec Numpy

Question

Il y a ceci Comment diviser une liste en morceaux de taille égale ? pour diviser un tableau en morceaux. Existe-t-il un moyen de faire cela plus efficacement pour les tableaux géants en utilisant Numpy ?

Answer 1

Essayez numpy.array_split .

Dans la documentation :

>>> x = np.arange(8.0)
>>> np.array_split(x, 3)
    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

Identique à numpy.split mais ne lèvera pas d'exception si les groupes ne sont pas de même longueur.

Si le nombre de morceaux > len(array), vous obtenez des tableaux vides imbriqués à l'intérieur, pour résoudre ce problème - si votre tableau divisé est sauvegardé dans le fichier a alors vous pouvez supprimer les tableaux vides par :

[x for x in a if x.size > 0]

Il suffit de le sauvegarder dans a si vous le souhaitez.

Answer 2

Quelques exemples d'utilisation de array_split , split , hsplit y vsplit :

n [9]: a = np.random.randint(0,10,[4,4])

In [10]: a
Out[10]: 
array([[2, 2, 7, 1],
       [5, 0, 3, 1],
       [2, 9, 8, 8],
       [5, 7, 7, 6]])

Quelques exemples d'utilisation array_split :
Si vous donnez un tableau ou une liste comme deuxième argument, vous donnez essentiellement les indices (avant) qui doivent être 'coupés'.

# split rows into 0|1 2|3
In [4]: np.array_split(a, [1,3])
Out[4]:                                                                                                                       
[array([[2, 2, 7, 1]]),                                                                                                       
 array([[5, 0, 3, 1],                                                                                                         
       [2, 9, 8, 8]]),                                                                                                        
 array([[5, 7, 7, 6]])]

# split columns into 0| 1 2 3
In [5]: np.array_split(a, [1], axis=1)                                                                                           
Out[5]:                                                                                                                       
[array([[2],                                                                                                                  
       [5],                                                                                                                   
       [2],                                                                                                                   
       [5]]),                                                                                                                 
 array([[2, 7, 1],                                                                                                            
       [0, 3, 1],
       [9, 8, 8],
       [7, 7, 6]])]

Un nombre entier comme seconde arg. spécifie le nombre de égal des morceaux :

In [6]: np.array_split(a, 2, axis=1)
Out[6]: 
[array([[2, 2],
       [5, 0],
       [2, 9],
       [5, 7]]),
 array([[7, 1],
       [3, 1],
       [8, 8],
       [7, 6]])]

split fonctionne de la même manière mais soulève une exception si un partage égal n'est pas possible.

En plus de array_split vous pouvez utiliser des raccourcis vsplit y hsplit .
vsplit y hsplit sont plutôt explicites :

In [11]: np.vsplit(a, 2)
Out[11]: 
[array([[2, 2, 7, 1],
       [5, 0, 3, 1]]),
 array([[2, 9, 8, 8],
       [5, 7, 7, 6]])]

In [12]: np.hsplit(a, 2)
Out[12]: 
[array([[2, 2],
       [5, 0],
       [2, 9],
       [5, 7]]),
 array([[7, 1],
       [3, 1],
       [8, 8],
       [7, 6]])]

Answer 3

Je crois que vous cherchez numpy.split ou éventuellement numpy.array_split si le nombre de sections ne doit pas diviser correctement la taille du tableau.

Answer 4

Pas tout à fait une réponse, mais un long commentaire avec un bon formatage du code vers les autres réponses (correctes). Si vous essayez ce qui suit, vous verrez que ce que vous obtenez sont des vues du tableau original, pas des copies, et ce n'était pas le cas pour la réponse acceptée dans la question que vous mettez en lien. Soyez conscient des effets secondaires possibles !

>>> x = np.arange(9.0)
>>> a,b,c = np.split(x, 3)
>>> a
array([ 0.,  1.,  2.])
>>> a[1] = 8
>>> a
array([ 0.,  8.,  2.])
>>> x
array([ 0.,  8.,  2.,  3.,  4.,  5.,  6.,  7.,  8.])
>>> def chunks(l, n):
...     """ Yield successive n-sized chunks from l.
...     """
...     for i in xrange(0, len(l), n):
...         yield l[i:i+n]
... 
>>> l = range(9)
>>> a,b,c = chunks(l, 3)
>>> a
[0, 1, 2]
>>> a[1] = 8
>>> a
[0, 8, 2]
>>> l
[0, 1, 2, 3, 4, 5, 6, 7, 8]

Answer 5

Que pensez-vous de ça ? Ici, vous divisez le tableau en utilisant la longueur que vous voulez avoir.

a = np.random.randint(0,10,[4,4])

a
Out[27]: 
array([[1, 5, 8, 7],
       [3, 2, 4, 0],
       [7, 7, 6, 2],
       [7, 4, 3, 0]])

a[0:2,:]
Out[28]: 
array([[1, 5, 8, 7],
       [3, 2, 4, 0]])

a[2:4,:]
Out[29]: 
array([[7, 7, 6, 2],
       [7, 4, 3, 0]])