Nhân bản vô tính vectơ hàng hoặc cột vectơ

Đôi khi nó rất hữu ích để "sao chép" một vectơ hàng hoặc cột vào một ma trận. Bằng cách nhân bản, tôi có nghĩa là chuyển đổi một vectơ hàng như

[1,2,3]

Vào một ma trận

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

hoặc một vectơ cột như

[1
 2
 3
]

vào

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

Trong matlab hoặc octave, điều này được thực hiện khá dễ dàng:

 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

Tôi muốn lặp lại điều này trong numpy, nhưng không thành công

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

Tại sao phương thức đầu tiên ( In [16]) hoạt động? Có cách nào để đạt được nhiệm vụ này ở trăn một cách tao nhã hơn không?

Đây là một cách trang nhã, Pythonic để làm điều đó:

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

vấn đề với [16]dường như là chuyển vị không có tác dụng đối với một mảng. có lẽ bạn muốn một ma trận thay thế:

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

Sử dụng numpy.tile:

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

hoặc để lặp lại các cột:

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

Đầu tiên lưu ý rằng với các hoạt động phát sóng của numpy thường không cần thiết phải sao chép các hàng và cột. Xem cái này và cái này để mô tả.

Nhưng để làm điều này, lặp lại và newaxis có lẽ là cách tốt nhất

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

Ví dụ này là cho một vectơ hàng, nhưng áp dụng điều này cho một vectơ cột là hy vọng rõ ràng. Lặp lại dường như đánh vần điều này tốt, nhưng bạn cũng có thể làm điều đó thông qua phép nhân như trong ví dụ của bạn

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

Để cho:

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

Phân bổ không chi phí

Một khung nhìn không mất thêm bộ nhớ. Do đó, những tuyên bố này là tức thời:

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

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

Phân bổ cưỡng bức

Nếu bạn muốn buộc các nội dung nằm trong bộ nhớ:

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

Tất cả ba phương pháp đều có cùng tốc độ.

Tính toán

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

Tất cả ba phương pháp đều có cùng tốc độ.

Phần kết luận

Nếu bạn muốn sao chép trước khi tính toán, hãy xem xét sử dụng một trong các phương pháp "phân bổ chi phí bằng không". Bạn sẽ không phải chịu hình phạt hiệu suất của "phân bổ bắt buộc".

Tôi nghĩ rằng sử dụng phát sóng trong numpy là tốt nhất và nhanh hơn

Tôi đã làm một so sánh như sau

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

sử dụng phát sóng nhanh hơn khoảng 15 lần

Một giải pháp rõ ràng là sử dụng chức năng sản phẩm bên ngoài của NumPy với một vectơ:

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

cho ncác hàng lặp lại. Chuyển thứ tự đối số để có được các cột lặp lại. Để có được số lượng hàng và cột bằng nhau, bạn có thể làm

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

Bạn có thể dùng

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

gạch sẽ tạo ra các đại diện của vector

và định hình lại sẽ cho nó hình dạng bạn muốn

Nếu bạn có một khung dữ liệu gấu trúc và muốn bảo tồn các kiểu chữ, thậm chí là phân loại, đây là một cách nhanh chóng để làm điều đó:

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)

sản lượng:

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