python - 使用numpy数组时如何处理itertools.product？

Question

我想获得两个 numpy 数组的张量积。例如，给定

a = np.random.uniform(-1,1,size=[10,2])
b = np.random.uniform(2,3,size=[20,3])

我想带走

products = np.array(list(prod for prod in itertools.product(a,b)))

但是，当我这样做时，结果数组将是

[[array([-0.0954691 ,  0.36734629])
  array([2.20196909, 2.02029329, 2.29627849])]
  ...
 [array([-0.07571476,  0.95934329])
  array([2.46847944, 2.3456241 , 2.28091522])]]

我想去掉列表中的'array'得到

 [[[-0.0954691 ,  0.36734629],[2.20196909, 2.02029329, 2.29627849]]
  ...
  [[-0.07571476,  0.95934329],[2.46847944, 2.3456241 , 2.28091522]]]

也许我可以用

for i in range(products.shape[0]):
    np.concatenate((products[i][0], products[i][1]))

但我认为有更聪明的方法来做到这一点。谁能帮帮我？谢谢。

Answer 1

In [129]: products = np.array(list(prod for prod in itertools.product(a,b)))    

结果是一个二维数组 - 但对象数据类型:

In [130]: products.shape                                                        
Out[130]: (200, 2)

这个数组的第一行，也是对象数据类型，有 2 个元素，每个元素都是一个数组:

In [131]: products[0]                                                           
Out[131]: 
array([array([-0.38279696,  0.51916671]),
       array([2.26576386, 2.50428761, 2.1463347 ])], dtype=object)

它包含第一行a和b:

In [132]: a[0]                                                                  
Out[132]: array([-0.38279696,  0.51916671])
In [133]: b[0]                                                                  
Out[133]: array([2.26576386, 2.50428761, 2.1463347 ])

由于这些数组具有不同的长度，因此生成的组合必须是对象数据类型。如果 a 和 b 有相同的列数，你会得到数字数组

例如 a 和 a:

In [134]: arr = np.array(list(prod for prod in itertools.product(a,a)))         
In [135]: arr.shape                                                             
Out[135]: (100, 2, 2)
In [136]: arr.dtype                                                             
Out[136]: dtype('float64')

如果我们将 a 和 b 转换为列表(嵌套)，我们将再次获得一个二维对象数组 - 包含列表:

In [137]: products = np.array(list(prod for prod in itertools.product(a.tolist()
     ...: ,b.tolist())))                                                        
In [138]: products.shape                                                        
Out[138]: (200, 2)
In [139]: products[0,:]                                                         
Out[139]: 
array([list([-0.38279696426849363, 0.5191667144605163]),
       list([2.2657638604936015, 2.50428761464766, 2.1463346999537767])],
      dtype=object)

如果我们省略 array 包装器，我们会得到一个元组列表(列表):

In [140]: products = list(prod for prod in itertools.product(a.tolist(),b.tolist
     ...: ()))                                                                  
In [141]: len(products)                                                         
Out[141]: 200
In [142]: products[0]                                                           
Out[142]: 
([-0.38279696426849363, 0.5191667144605163],
 [2.2657638604936015, 2.50428761464766, 2.1463346999537767])
In [143]: type(products)                                                        
Out[143]: list

product 生成元组(参见其文档)，如这个更简单的示例所示:

In [145]: list(itertools.product('abc','def'))                                  
Out[145]: 
[('a', 'd'),
 ('a', 'e'),
 ('a', 'f'),
 ('b', 'd'),
 ('b', 'e'),
 ('b', 'f'),
 ('c', 'd'),
 ('c', 'e'),
 ('c', 'f')]

编辑

在评论时拆分 prod 元组:

In [147]: arr0 = np.array(list(prod[0] for prod in itertools.product(a,b)))     
In [148]: arr1 = np.array(list(prod[1] for prod in itertools.product(a,b)))     
In [149]: arr0.shape                                                            
Out[149]: (200, 2)
In [150]: arr1.shape                                                            
Out[150]: (200, 3)
In [151]: arr0[:3,:]                                                            
Out[151]: 
array([[-0.38279696,  0.51916671],
       [-0.38279696,  0.51916671],
       [-0.38279696,  0.51916671]])
In [152]: arr1[:3,:]                                                            
Out[152]: 
array([[2.26576386, 2.50428761, 2.1463347 ],
       [2.63018066, 2.64559639, 2.51747175],
       [2.14425882, 2.39274225, 2.6460254 ]])

这是两个数值数组。

它们可以在 axis=1 上连接起来形成一个包含 5 列的数组:

In [153]: arr3 = np.hstack((arr0,arr1))                                         
In [154]: arr3[:3,:]                                                            
Out[154]: 
array([[-0.38279696,  0.51916671,  2.26576386,  2.50428761,  2.1463347 ],
       [-0.38279696,  0.51916671,  2.63018066,  2.64559639,  2.51747175],
       [-0.38279696,  0.51916671,  2.14425882,  2.39274225,  2.6460254 ]])

奖金

从这两个数组创建一个结构化数组:

In [159]: dt=np.dtype([('a',float,2),('b',float,3)])                            
In [160]: arr3 = np.zeros(200,dt)                                               
In [161]: arr3['a']=arr0                                                        
In [162]: arr3['b']=arr1                                                        
In [163]: arr3[:3]                                                              
Out[163]: 
array([([-0.38279696,  0.51916671], [2.26576386, 2.50428761, 2.1463347 ]),
       ([-0.38279696,  0.51916671], [2.63018066, 2.64559639, 2.51747175]),
       ([-0.38279696,  0.51916671], [2.14425882, 2.39274225, 2.6460254 ])],
      dtype=[('a', '<f8', (2,)), ('b', '<f8', (3,))])