Как получить массив различных размерных нескольких массивов в Python?

Question

Я строю данные графика. Поэтому я сгенерировал 3 разные матрицы, такие как adjacency_matrix, Node_labels, & Adj_joint_matrix.

adjacency_matrix.shape = (4,4)
Node_labels.shape = (4,1)
Adj_joint_matrix.shape = (4,3)

. В то время я хочу объединить эти три многомерных массива в один общий массив с именем graph_struct. Я пытался

graph_struct = np.asarray([adjacency_matrix],[Node_labels],[Adj_joint_matrix]) 
graph_struct = np.array([adjacency_matrix],[Node_labels],[Adj_joint_matrix]).

Но это не дает решения.

вывод должен выглядеть так:

graph_struct = array([adjacency_matrix],[Node_labels],[Adj_joint_matrix])

Answer 1

Вы можете использовать структурированные массивы. См. https://docs.scipy.org/doc/numpy/user/basics.rec.html#.

Я предполагаю, что тип adjacency_matrix - bool. Два других являются целыми. Вы можете создать структурированный массив с помощью команды:

graph_struct = np.array((adjacency_matrix,Node_labels,Adj_joint_matrix),
                        dtype='(4,4)?,(4,1)i,(4,3)i')

Не забудьте поместить () вокруг элементов структуры, чтобы не допустить попыток объединить элементы в один ndarray.

Для входных данных:

adjacency_matrix = np.array([[0,1,0,0],[1,0,1,1],[0,1,0,0],[0,1,0,0]], dtype=bool)
Node_labels = np.array([[1],[2],[3],[4]], dtype=int)
Adj_joint_matrix = np.arange(12).reshape(4,3)

Вывод представляет собой структурированный массив с полями f0, f1, f2:

array(([[False,  True, False, False], [ True, False,  True,  True], [False,  True, False, False], [False,  True, False, False]],
       [[1], [2], [3], [4]],
       [[ 0,  1,  2], [ 3,  4,  5], [ 6,  7,  8], [ 9, 10, 11]]),
       dtype=[('f0', '?', (4, 4)), ('f1', '<i4', (4, 1)), ('f2', '<i4', (4, 3))])

Если форма ваших массивов заранее не известна, то ее можно построить с помощью:

graph_struct_dtype = np.dtype([('f0',(bool, adjacency_matrix.shape)),
                               ('f1',(int, Node_labels.shape)),
                               ('f2',(int, Adj_joint_matrix.shape))])

graph_struct = np.array((adjacency_matrix,Node_labels,Adj_joint_matrix),
                        dtype=graph_struct_dtype)

Answer 2

In [268]: x = np.ones((4,3),int); y = np.zeros((4,1),int)                       

При таком сочетании форм (одно и то же 1-е измерение) np.array выдает ошибку:

In [269]: np.array((x,y))                                                       
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-269-8419f5dd7aa8> in <module>
----> 1 np.array((x,y))

ValueError: could not broadcast input array from shape (4,3) into shape (4)

При разных 1-х измерениях он делает массив типа dtype - в основном прославленным (или униженным)) список массивов:

In [270]: np.array((x.T,y.T))                                                   
Out[270]: 
array([array([[1, 1, 1, 1],
       [1, 1, 1, 1],
       [1, 1, 1, 1]]),
       array([[0, 0, 0, 0]])], dtype=object)

np.array пытается создать обычный многомерный массив. Если формы не позволяют этого, он должен прибегнуть к объекту dtype или потерпеть неудачу.

Мы можем предварительно выделить массив объектов и назначить элементы:

In [271]: res = np.empty((2,),object)                                           
In [272]: res                                                                   
Out[272]: array([None, None], dtype=object)
In [273]: res[0]=x; res[1] = y                                                  
In [274]: res                                                                   
Out[274]: 
array([array([[1, 1, 1],
       [1, 1, 1],
       [1, 1, 1],
       [1, 1, 1]]),
       array([[0],
       [0],
       [0],
       [0]])], dtype=object)

Потенциально полезный структурированный массив может быть создан с помощью:

In [278]: res1 = np.zeros((4,), dtype=[('x',int,(3,)),('y',int,(1,))])          
In [279]: res1                                                                  
Out[279]: 
array([([0, 0, 0], [0]), ([0, 0, 0], [0]), ([0, 0, 0], [0]),
       ([0, 0, 0], [0])], dtype=[('x', '<i8', (3,)), ('y', '<i8', (1,))])
In [280]: res1['x']=x                                                           
In [281]: res1['y']=y                                                           
In [282]: res1                                                                  
Out[282]: 
array([([1, 1, 1], [0]), ([1, 1, 1], [0]), ([1, 1, 1], [0]),
       ([1, 1, 1], [0])], dtype=[('x', '<i8', (3,)), ('y', '<i8', (1,))])
In [283]: res1[0]                                                               
Out[283]: ([1, 1, 1], [0])

Если размер * 4 указан в dtype, результатом будет массив 0d:

In [284]: np.array((x,y), dtype=[('x',int,(4,3)),('y',int,(4,1))])              
Out[284]: 
array(([[1, 1, 1], [1, 1, 1], [1, 1, 1], [1, 1, 1]], [[0], [0], [0], [0]]),
      dtype=[('x', '<i8', (4, 3)), ('y', '<i8', (4, 1))])
In [285]: res2 = np.array((x,y), dtype=[('x',int,(4,3)),('y',int,(4,1))])       
In [287]: res2.shape                                                            
Out[287]: ()

Практически этобольше похоже на словарь, {'x':x, 'y':y}, чем массив.