Le “clonage” de ligne ou de colonne vecteurs

Il est parfois utile de "cloner" une ligne ou une colonne de vecteur à une matrice. Par clonage, je veux dire la conversion d'un vecteur ligne tels que

[1,2,3]

Dans une matrice

[[1,2,3]
 [1,2,3]
 [1,2,3]
]

ou un vecteur colonne comme

[1
 2
 3
]

en

[[1,1,1]
 [2,2,2]
 [3,3,3]
]

Dans matlab ou octave cela se fait assez facilement:

 x = [1,2,3]
 a = ones(3,1) * x
 a =

    1   2   3
    1   2   3
    1   2   3

 b = (x') * ones(1,3)
 b =

    1   1   1
    2   2   2
    3   3   3

Je tiens à répéter ce dans numpy, mais en vain

In [14]: x = array([1,2,3])
In [14]: ones((3,1)) * x
Out[14]:
array([[ 1.,  2.,  3.],
       [ 1.,  2.,  3.],
       [ 1.,  2.,  3.]])
# so far so good
In [16]: x.transpose() * ones((1,3))
Out[16]: array([[ 1.,  2.,  3.]])
# DAMN
# I end up with 
In [17]: (ones((3,1)) * x).transpose()
Out[17]:
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.],
       [ 3.,  3.,  3.]])

Pourquoi n'était-ce pas la première méthode ([16]) de travail? Est-il un moyen pour accomplir cette tâche en python de manière plus élégante?

  • Dans Matlab, remarque qu'il est beaucoup plus rapide à utiliser repmat: repmat([1 2 3],3,1) ou repmat([1 2 3].',1,3)
  • Octave a également repmat.
  • Pour ceux qui cherchent à faire la même avec une pandas dataframe la caisse de la tile_df lien ici
InformationsquelleAutor Boris Gorelik | 2009-10-11
  1. 64

    Voici un élégant, Pythonic façon de le faire:

    >>> array([[1,2,3],]*3)
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

>>> array([[1,2,3],]*3).transpose()
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

    le problème avec [16] semble être que la transposition n'a pas d'effet pour un tableau. vous êtes probablement vouloir une matrice plutôt:

    >>> x = array([1,2,3])
>>> x
array([1, 2, 3])
>>> x.transpose()
array([1, 2, 3])
>>> matrix([1,2,3])
matrix([[1, 2, 3]])
>>> matrix([1,2,3]).transpose()
matrix([[1],
        [2],
        [3]])
    • (transposition de travaux pour la 2D des tableaux, par exemple, pour le carré de l'un dans l'exemple, ou lors de la mise en (N,1)forme de tableau à l'aide de .reshape(-1, 1))
    • C'est très inefficace. Utilisation numpy.tile comme indiqué dans le pv.'s réponse.
    InformationsquelleAutor Peter
  2. 242

    Utilisation numpy.tuile:

    >>> tile(array([1,2,3]), (3, 1))
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

    ou de répéter les colonnes:

    >>> tile(array([[1,2,3]]).transpose(), (1, 3))
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])
    • Upvote! Sur mon système, pour un vecteur de 10000 éléments répété 1000 fois, le tile méthode est de 19,5 fois plus rapide que la méthode actuellement accepté de répondre (à l'aide de la multiplication-opérateur-méthode).
    • Dans la deuxième section ("répétition colonnes"), pouvez-vous expliquer ce que le deuxième ensemble de crochet fait, c'est à dire [[1,2,3]]
    • il fait un tableau 2D avec une longueur de 1 dans le premier axe (vertical sur votre écran) et de longueur 3 dans le deuxième axe (horizontal sur votre écran). La transposition permet alors ont une longueur de 3 dans le premier axe de longueur et de 1 dans le deuxième axe. Une forme de vignette de (1, 3) des copies de cette colonne de plus de trois fois, c'est pourquoi le nombre de lignes du résultat contenir un seul élément distinct de chacun.
    • Ce doit être la accepté de répondre puisque vous pouvez passer n'importe quel vecteur déjà initialisé alors que l'on a accepté l'un ne peut fonctionner que si vous ajoutez la virgule alors que vous initialiser le vecteur. Merci !
    InformationsquelleAutor pv.
  3. 32

    Abord de noter qu'avec numpy est de radiodiffusion des opérations, il n'est généralement pas nécessaire de dupliquer les lignes et les colonnes. Voir cette et cette pour les descriptions.

    Mais pour ce faire, repeat et newaxis sont probablement la meilleure façon

    In [12]: x = array([1,2,3])

In [13]: repeat(x[:,newaxis], 3, 1)
Out[13]: 
array([[1, 1, 1],
       [2, 2, 2],
       [3, 3, 3]])

In [14]: repeat(x[newaxis,:], 3, 0)
Out[14]: 
array([[1, 2, 3],
       [1, 2, 3],
       [1, 2, 3]])

    Cet exemple est pour un vecteur ligne, mais de l'application d'un vecteur colonne, je l'espère, évident. répétez semble sort bien, mais vous pouvez aussi le faire via la multiplication comme dans votre exemple

    In [15]: x = array([[1, 2, 3]])  # note the double brackets

In [16]: (ones((3,1))*x).transpose()
Out[16]: 
array([[ 1.,  1.,  1.],
       [ 2.,  2.,  2.],
       [ 3.,  3.,  3.]])
    • newaxis a l'avantage supplémentaire qu'il ne fait pas de copier les données jusqu'à ce qu'il en a besoin. Donc, si vous faites cela de multiplier ou de l'ajouter à une autre matrice 3x3, la répétition est inutile. Lire sur numpy de radiodiffusion afin d'obtenir l'idée.
    • Bon point. J'ai mis à jour ma réponse à signaler.
    • Quels sont les avantages de l'utilisation de np.repeat vs np.tile?
    • Aucun, surtout, pour ce cas. Pour un petit 1D tableau, elles sont similaires et il n'y a pas de différence significative/avantages/avantage de/etc. Personnellement, je trouve la symétrie entre la ligne et la colonne de clonage pour être plus intuitive, et je n'aime pas la transposition nécessaires pour la tuile, mais c'est juste une question de goût. Mateen Ulhaq réponse aussi dit de répétition est plus rapide, mais cela dépendra de l'utilisation exacte de cas qui ont considéré que, bien que la répétition est beaucoup plus proche du C-fonctionnalité, donc risque de rester un peu plus rapide. En 2D, ils ont des comportements différents de sorte qu'il questions.
    InformationsquelleAutor tom10
  4. 8

    Je pense que l'aide à la diffusion dans numpy est le meilleur, et le plus vite

    J'ai fait une comparaison comme la suite

    import numpy as np
b = np.random.randn(1000)
In [105]: %timeit c = np.tile(b[:, newaxis], (1,100))
1000 loops, best of 3: 354 µs per loop

In [106]: %timeit c = np.repeat(b[:, newaxis], 100, axis=1)
1000 loops, best of 3: 347 µs per loop

In [107]: %timeit c = np.array([b,]*100).transpose()
100 loops, best of 3: 5.56 ms per loop

    environ 15 fois plus rapide grâce à la diffusion

    • Vous pouvez indexer avec None de faire la même chose.
    • qu'est-ce que newaxis?!
    InformationsquelleAutor smartkevin
  5. 5

    np.broadcast_to est encore plus rapide que np.tile:

    x = np.arange(9)

%timeit np.broadcast_to(x, (6,9))
100000 loops, best of 3: 3.6 µs per loop

%timeit np.tile(x, (6,1))
100000 loops, best of 3: 8.4 µs per loop

    Mais le plus rapide est @tom10 de la méthode:

    %timeit np.repeat(x[np.newaxis, :], 6, axis=0) 
100000 loops, best of 3: 3.15 µs per loop
    InformationsquelleAutor Mateen Ulhaq
  6. 2

    Vous pouvez utiliser 

    np.tile(x,3).reshape((4,3))

    tuile va générer les représentants de l'vecteur

    et de remodeler la volonté de lui donner la forme que vous voulez

    InformationsquelleAutor thebeancounter
  7. 1

    Une solution propre est d'utiliser NumPy externe-fonction du produit d'un vecteur de:

    np.outer(np.ones(n), x)

    donne n répéter les lignes. Commutateur de l'argument afin d'obtenir de répéter les colonnes. Pour obtenir un nombre égal de lignes et de colonnes que vous pourriez faire

    np.outer(np.ones_like(x), x)
    InformationsquelleAutor Jon Deaton
  8. 0
    import numpy as np
x=np.array([1,2,3])
y=np.multiply(np.ones((len(x),len(x))),x).T
print(y)

    rendements:

    [[ 1.  1.  1.]
 [ 2.  2.  2.]
 [ 3.  3.  3.]]
    InformationsquelleAutor kibitzforu