Paritition tableau en N morceaux avec Numpy

Il y a cette Comment vous répartissez vous une liste en morceaux de taille égale?
pour fractionner un tableau en morceaux. Est-il de toute façon à le faire plus efficacement pour le géant de tableaux à l'aide de Numpy?

  • désolé, je suis toujours à la recherche d'une réponse efficace ;). droit maintenant, je pense ctypes est le seul moyen efficace.
  • Définir efficace. Donner des exemples de données, votre méthode actuelle, comment il est rapide, et à quelle vitesse vous avez besoin qu'il soit.
InformationsquelleAutor Eiyrioü von Kauyf | 2013-01-18
  1. 69

    Essayer numpy.array_split.

    À partir de 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 pas lever une exception si les groupes ne sont pas égaux en longueur.

    Si le nombre de morceaux > len(array), vous obtenez vide matrices imbriquées à l'intérieur, à l'adresse que - si votre split tableau est enregistré dans a, alors vous pouvez supprimer des tableaux vides par:

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

    Il suffit d'enregistrer dans la a si vous le souhaitez.

    • comment pouvez-vous supprimer le vide listes si?
    • Pouvez-vous donner un petit exemple?
    • si # de morceaux > len(array), vous obtenez vide tableaux imbriqués à l'intérieur.
    • Simplement, je ne voudrais pas utiliser # morceaux > len(tableau), mais j'ai inclus une deuxième étape qui devrait supprimer des tableaux vides. Laissez-moi savoir si cela fonctionne.
    • oui, c'était ce que j'étais en aide ... mais de toute façon faire que w/ numpy? Interprétations de la liste en python sont lents.
    • Ne np.array_split copie du tableau d'entrée?

    InformationsquelleAutor Prashant Kumar
  2. 19

    Juste quelques exemples sur l'utilisation de array_split, split, hsplit et 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 sur l'utilisation de array_split:

    Si vous donner un tableau ou d'une liste comme deuxième argument en gros, vous donner des indices (avant) pour "couper" les

    # 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 entier comme deuxième argument. spécifie le nombre de l'égalité 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 façon, mais lève une exception si une répartition égale n'est pas possible

    En plus de array_split vous pouvez utiliser des raccourcis vsplit et hsplit.

    vsplit et hsplit sont assez bien l'auto-explanatry:

    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]])]
    • mon problème c'est que si des morceaux > len(tableau), puis vous obtenez vide tableaux imbriqués ... comment voulez-vous vous débarrasser de celui-ci?
    • De bons exemples, je vous remercie. Dans votre np.array_split(a, [1], axis=1) exemple, savez-vous comment empêcher le premier tableau, d'avoir chaque élément imbriqué?
    InformationsquelleAutor Theodros Zelleke
  3. 7

    Je crois que vous êtes à la recherche pour numpy.split ou éventuellement numpy.array_split si le nombre de sections n'a pas besoin de diviser la taille de la matrice correctement.

    • même question que j'ai demandé à Prashant. Comment pouvez-vous vous débarrasser de la vide des tableaux numpy?
    InformationsquelleAutor mgilson
  4. 7

    Pas tout à fait une réponse, mais un long commentaire avec une belle mise en forme de code à l'autre (correcte) des réponses. Si vous essayez ce qui suit, vous verrez que ce que vous obtenez de la vue sur le tableau d'origine, pas de copies, et qui n'était pas le cas pour la accepté de répondre à la question que vous vous lien. Être conscient de la possibilité d'effets secondaires!

    >>> 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]
    • +1) qui est un bon point à prendre en compte, vous pouvez étendre votre solution supplémentaires pour gérer certaines multidim. cas
    • oui en ce moment j'utilise que. Je me demandais de plus agréable à faire que l'utilisation de numpy. esp. avec multi-dim 🙁
    • Cela est pertinent pour le plus grand nombre de données. Je suis à l'aide de numpy.array_split qui semble faire des copies des données. De passage à votre multitraitement piscine fera encore une autre copie des données...
    InformationsquelleAutor Jaime