Satır veya sütun vektörlerini “klonlama”

Bazen bir satır veya sütun vektörünü bir matrise "klonlamak" yararlı olabilir. Klonlama ile kastedilen bir satır vektörünü

[1,2,3]

Bir matrise

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

veya bir sütun vektörü

[1
 2
 3
]

içine

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

Matlab veya oktavda bu oldukça kolay bir şekilde yapılır:

 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

Bunu numpy olarak tekrarlamak istiyorum, ama başarısız

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.]])

İlk yöntem ( In [16]) neden çalışmadı? Bu görevi python'da daha zarif bir şekilde başarmanın bir yolu var mı?

İşte bunu yapmanın zarif, Pythonic bir yolu:

>>> 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]])

ile ilgili sorun [16], devrik bir dizi için hiçbir etkisi yoktur gibi görünüyor. muhtemelen bunun yerine bir matris istiyorsunuz:

>>> 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]])

Kullanım numpy.tile:

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

veya sütunları tekrarlamak için:

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

İlk olarak, numpy'nin yayın işlemleri ile satır ve sütunları çoğaltmanın gerekli olmadığını unutmayın . Açıklamalar için bu ve buna bakın .

Ancak bunu yapmak için, tekrar ve newaxis muhtemelen en iyi yoldur

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]])

Bu örnek bir satır vektörü içindir, ancak bunu bir sütun vektörüne uygulamak umarım açıktır. tekrarlama bu kadar iyi heceliyor gibi görünüyor, ancak bunu örnekte olduğu gibi çarpma yoluyla da yapabilirsiniz

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.]])

İzin Vermek:

>>> n = 1000
>>> x = np.arange(n)
>>> reps = 10000

Sıfır maliyet tahsisleri

Bir görünüm ek bellek gerektirmez. Bu nedenle, bu bildirimler anlıkdır:

# New axis
x[np.newaxis, ...]

# Broadcast to specific shape
np.broadcast_to(x, (reps, n))

Zorunlu dağıtım

İçeriğin bellekte kalmasını istiyorsanız:

>>> %timeit np.array(np.broadcast_to(x, (reps, n)))
10.2 ms ± 62.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit np.repeat(x[np.newaxis, :], reps, axis=0)
9.88 ms ± 52.4 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit np.tile(x, (reps, 1))
9.97 ms ± 77.3 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Her üç yöntem de kabaca aynı hızdadır.

Hesaplama

>>> a = np.arange(reps * n).reshape(reps, n)
>>> x_tiled = np.tile(x, (reps, 1))

>>> %timeit np.broadcast_to(x, (reps, n)) * a
17.1 ms ± 284 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit x[np.newaxis, :] * a
17.5 ms ± 300 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

>>> %timeit x_tiled * a
17.6 ms ± 240 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

Her üç yöntem de kabaca aynı hızdadır.

Sonuç

Bir hesaplamadan önce çoğaltma yapmak istiyorsanız, "sıfır maliyet ayırma" yöntemlerinden birini kullanmayı düşünün. "Zorunlu tahsis" performans cezası çekmeyeceksiniz.

Bence yayını numpy ile kullanmak en iyisi ve daha hızlı

Aşağıdaki gibi bir karşılaştırma yaptım

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

yayını kullanarak yaklaşık 15 kat daha hızlı

Temiz bir çözüm NumPy'nin dış ürün işlevini bir vektörle kullanmaktır:

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

nyinelenen satırlar verir . Yinelenen sütunları almak için bağımsız değişken sırasını değiştirin. Eşit sayıda satır ve sütun almak için

np.outer(np.ones_like(x), x)

Kullanabilirsiniz

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

karo vektörün tekrarlarını üretecektir

ve yeniden şekillendirme istediğiniz şekli verecektir

Bir panda veri çerçeveniz varsa ve kategorileri, hatta kategorileri korumak istiyorsanız, bunu yapmanın hızlı bir yoludur:

import numpy as np
import pandas as pd
df = pd.DataFrame({1: [1, 2, 3], 2: [4, 5, 6]})
number_repeats = 50
new_df = df.reindex(np.tile(df.index, number_repeats))

import numpy as np
x=np.array([1,2,3])
y=np.multiply(np.ones((len(x),len(x))),x).T
print(y)

verim:

[[ 1.  1.  1.]
 [ 2.  2.  2.]
 [ 3.  3.  3.]]