как лучше всего объединить две numpy матрицы по строкам?

Question

У меня есть две numpy 2D-матрицы i и u

import numpy as np
u = np.array([[1,2,3],[3,4,5]])
i = np.random.rand(3,4)
u
array([[1, 2, 3],
       [3, 4, 5]])
i
array([[0.01564089, 0.01274327, 0.39282509, 0.25177788],
       [0.08531619, 0.04668083, 0.91260452, 0.63481191],
       [0.34607795, 0.87053449, 0.27467456, 0.02215169]])

И я хочу объединить две матрицы по строкам, как показано ниже

array([[1,2,3, 0.01564089, 0.01274327, 0.39282509, 0.25177788],
[1,2,3, 0.08531619, 0.04668083, 0.91260452, 0.63481191],
[1,2,3, 0.34607795, 0.87053449, 0.27467456, 0.02215169],
[3,4,5, 0.01564089, 0.01274327, 0.39282509, 0.25177788],
[3,4,5, 0.08531619, 0.04668083, 0.91260452, 0.63481191],
[3,4,5, 0.34607795, 0.87053449, 0.27467456, 0.02215169]]
)

Answer 1

В одну сторону с использованием numpy.repeat и numpy.tile:

def join(arr1, arr2):
    a1 = np.repeat(arr1, arr2.shape[0], 0)
    a2 = np.tile(arr2, (arr1.shape[0], 1))
    return np.hstack([a1, a2])
join(u, i)

Вывод:

array([[1.   , 2.   , 3.   , 0.832, 0.885, 0.86 , 0.233],
       [1.   , 2.   , 3.   , 0.76 , 0.46 , 0.421, 0.654],
       [1.   , 2.   , 3.   , 0.083, 0.   , 0.981, 0.047],
       [3.   , 4.   , 5.   , 0.832, 0.885, 0.86 , 0.233],
       [3.   , 4.   , 5.   , 0.76 , 0.46 , 0.421, 0.654],
       [3.   , 4.   , 5.   , 0.083, 0.   , 0.981, 0.047]])

Answer 2

Вы можете попробовать это с помощью itertools.product

import itertools  
ls=[np.concatenate([x,y]).tolist() for x,y in itertools.product(u, i)]
combinedarray=np.array(ls)
combinedarray

Вывод:

u
[[1 2 3]
 [3 4 5]]

i
[[0.99154112 0.72960938 0.5764647  0.34136825]
 [0.6014229  0.81085954 0.00631983 0.15401643]
 [0.98828194 0.46407222 0.60403416 0.20934805]]

combinedarray
array([[1.     , 2.     , 3.     , 0.99154112, 0.72960938, 0.5764647, 0.34136825],
       [1.     , 2.     , 3.     , 0.6014229 , 0.81085954, 0.00631983, 0.15401643],
       [1.     , 2.     , 3.     , 0.98828194, 0.46407222, 0.60403416, 0.20934805],
       [3.     , 4.     , 5.     , 0.99154112, 0.72960938, 0.5764647, 0.34136825],
       [3.     , 4.     , 5.     , 0.6014229 , 0.81085954, 0.00631983, 0.15401643],
       [3.     , 4.     , 5.     , 0.98828194, 0.46407222, 0.60403416, 0.20934805]])

Answer 3

Ваши массивы (заменяя i на целые числа, чтобы сделать дисплей более компактным):

In [230]: u = np.array([[1,2,3],[3,4,5]]) 
     ...: i = np.random.randint(0,10,(3,4))*10                                                       
In [231]: u                                                                                          
Out[231]: 
array([[1, 2, 3],
       [3, 4, 5]])
In [232]: i                                                                                          
Out[232]: 
array([[40, 20, 40, 10],
       [20, 10, 90, 50],
       [50, 10, 10, 30]])

Сделайте целевой массив - 3d:

In [233]: res1 = np.zeros((2,3,7))                                                                   

Измените (2 , 3) u в (2,1,3), и пусть широковещательная рассылка расширяет его до (2,3,3):

In [234]: res1[:,:,:3]=u[:,None,:]                                                                   

Затем транслирует (3,4) i на (2,3,4) slot

In [235]: res1[:,:,3:]=i[None,:,:]       # None is optional here                                                            
In [236]: res1                                                                                       
Out[236]: 
array([[[ 1.,  2.,  3., 40., 20., 40., 10.],
        [ 1.,  2.,  3., 20., 10., 90., 50.],
        [ 1.,  2.,  3., 50., 10., 10., 30.]],

       [[ 3.,  4.,  5., 40., 20., 40., 10.],
        [ 3.,  4.,  5., 20., 10., 90., 50.],
        [ 3.,  4.,  5., 50., 10., 10., 30.]]])

, затем измените форму на (6,7):

In [237]: res1.reshape(-1,7)                                                                         
Out[237]: 
array([[ 1.,  2.,  3., 40., 20., 40., 10.],
       [ 1.,  2.,  3., 20., 10., 90., 50.],
       [ 1.,  2.,  3., 50., 10., 10., 30.],
       [ 3.,  4.,  5., 40., 20., 40., 10.],
       [ 3.,  4.,  5., 20., 10., 90., 50.],
       [ 3.,  4.,  5., 50., 10., 10., 30.]])

Все значения должны быть int или float. (Объект dtype допускает смешивание, но математика для такого массива медленнее.)

Я не могу сказать, какой подход самый быстрый. Один может быть лучшим для таких небольших примеров (я делаю ставку на itertools), а другой (мой?) - для больших случаев.