Disons que j'ai deux tableaux en 3 dimensions (a et b) de forme (1.000.000, ???, 50), (??? = voir ci-dessous).

Comment les fusionner, pour que le résultat soit (1.000.000, {forme de la deuxième dimension de a + b}, 50)?

Voici les exemples, comme vous pouvez le voir ci-dessous: (np.arrays sont également possibles)

EDIT: ajout du code utilisable, veuillez faire défiler ^^

[ #a
     [           
                 ],
     [ 
       [1  2  3]
                 ],
     [ 
       [0  2    7]
       [1  Nan  3]
                 ],
     [ 
       [10   0  3]
       [NaN  9  9]
       [10 NaN  3]
                 ],
     [ 
       [8  2  0]
       [2  2  3]
       [8  1  3]
       [1  2  3]
                 ],
     [ 
       [0  2  3]
       [1  2  9]
       [1  2  3]
       [1  0  3]
       [1  2  3]
                 ]
                     ] 



[#b
     [ 
       [7  2  3]
       [1  2  9]
       [1  2  3]
       [8  0  3]
       [1  7  3]
                 ]
     [ 
       [3  9  0]
       [2  2  3]
       [8  1  3]
       [0  2  3]
                 ],
     [ 
       [10   0  3]
       [0  NaN  9]
       [10 NaN  3]
                 ],
     [ 
       [0  2  NaN]
       [1  Nan  3]
                 ],
     [ 
       [1  2  NaN]
                 ],
     [           
                 ]
                     ] 

a = [    [                ],
     [ [1, 2, 3]          ],
     [ [0, 2, 7],  [1,np.nan,3]   ],
     [ 
       [10,0,3],  [np.nan,9,9],  [10,np.nan,3]
                 ],
     [ 
       [8,2,0],  [2,2,3],  [8,1,3],  [1,2,3]
                 ],
     [   
      [0,2,3],  [1,2,9],  [1,2,3],  [1,0,3],     [1,2,3]    
                 ]
                     ] 
 
b = [
     [ 
       [7,2,3],     [1,2,9],   [1,2,3],  [8,0,3],   [1,7,3]
                   ],
     [ 
       [3,9,0],   [2,2,3],   [8,1,3],   [0,2,3]
                   ],
     [ 
       [10,0,3],  [0,np.nan,9],   [10,np.nan,3]
                   ],
     [ 
       [0,2,np.nan],  [1,np.nan,3]
                   ],
     [ 
       [1,2,np.nan]
                   ],
     [           
                   ]
                     ]

Résultat attendu:

[ 
     [ [7  2  3]# from b
       [1  2  9]# from b
       [1  2  3]# from b
       [8  0  3]# from b
       [1  7  3]# from b
                  ],
     [ 
       [1  2  3]
       [3  9  0]# from b
       [2  2  3]# from b
       [8  1  3]# from b
       [0  2  3]# from b
                 ],
     [ 
       [0  2    7]
       [1  Nan  3]
       [10   0  3]# from b
       [0  NaN  9]# from b
       [10 NaN  3]# from b
                 ],
     [ 
       [10   0  3]
       [NaN  9  9]
       [10 NaN  3]
       [0  2  NaN]# from b
       [1  Nan  3]# from b
                    ],
     [ 
       [8  2  0]
       [2  2  3]
       [8  1  3]
       [1  2  3]
       [1  2  NaN]# from b
                 ],
     [ 
       [0  2  3]
       [1  2  9]
       [1  2  3]
       [1  0  3]
       [1  2  3]
                 ] 
                     ] 

Connaissez-vous un moyen de le faire efficacement?

EDIT: essayé concaténer (n'a pas fonctionné):

DF_LEN, COL_LEN, cols = 20,5,['A', 'B']
a = np.asarray(pd.DataFrame(1, index=range(DF_LEN), columns=cols))
a = list((map(lambda i: a[:i], range(1,a.shape[0]+1))))
  
b = np.asarray(pd.DataFrame(np.nan, index=range(DF_LEN), columns=cols))
b = list((map(lambda i: b[:i], range(1,b.shape[0]+1))))
b = b[::-1]

a_first = a[0];  del a[0]
b_last  = b[-1]; del b[-1]
result  = np.concatenate([a, b], axis=1)

>>>AxisError: axis 1 is out of bounds for array of dimension 1
1
La-Li-Lu-Le-Lo 27 août 2020 à 21:43

2 réponses

Meilleure réponse

Vous ne pouvez pas avoir un tableau de longueur variable dans une dimension. a et b sont très probablement des listes de listes et non des tableaux. Vous pouvez utiliser la compréhension de liste avec zip:

np.array([x+y for x,y in zip(a,b)]) 

MODIFIER : ou en fonction du commentaire fourni si a et b sont des listes de tableaux:

np.array([np.vstack((x,y)) for x,y in zip(a,b)])

La sortie de votre exemple ressemble à ceci:

[[[ 7.  2.  3.]
  [ 1.  2.  9.]
  [ 1.  2.  3.]
  [ 8.  0.  3.]
  [ 1.  7.  3.]]

 [[ 1.  2.  3.]
  [ 3.  9.  0.]
  [ 2.  2.  3.]
  [ 8.  1.  3.]
  [ 0.  2.  3.]]

 [[ 0.  2.  7.]
  [ 1. nan  3.]
  [10.  0.  3.]
  [ 0. nan  9.]
  [10. nan  3.]]

 [[10.  0.  3.]
  [nan  9.  9.]
  [10. nan  3.]
  [ 0.  2. nan]
  [ 1. nan  3.]]

 [[ 8.  2.  0.]
  [ 2.  2.  3.]
  [ 8.  1.  3.]
  [ 1.  2.  3.]
  [ 1.  2. nan]]

 [[ 0.  2.  3.]
  [ 1.  2.  9.]
  [ 1.  2.  3.]
  [ 1.  0.  3.]
  [ 1.  2.  3.]]]
2
hpaulj 28 août 2020 à 03:20

Pour effectuer votre concaténation, exécutez:

result = np.concatenate([a, b], axis=1)

Pour tester ce code, j'ai créé a et b comme:

a = np.stack([ np.full((2, 3), i) for i in range(1, 6)], axis=1)
b = np.stack([ np.full((2, 3), i + 10) for i in range(1, 4)], axis=1)

Ils contiennent donc:

array([[[1, 1, 1],        array([[[11, 11, 11],
        [2, 2, 2],                [12, 12, 12],
        [3, 3, 3],                [13, 13, 13]],
        [4, 4, 4],        
        [5, 5, 5]],              [[11, 11, 11],
                                  [12, 12, 12],
       [[1, 1, 1],                [13, 13, 13]]])
        [2, 2, 2],
        [3, 3, 3],
        [4, 4, 4],
        [5, 5, 5]]])

Et leurs formes sont: (2, 5, 3) et (2, 3, 3)

Le résultat de ma concaténation est:

array([[[ 1,  1,  1],
        [ 2,  2,  2],
        [ 3,  3,  3],
        [ 4,  4,  4],
        [ 5,  5,  5],
        [11, 11, 11],
        [12, 12, 12],
        [13, 13, 13]],

       [[ 1,  1,  1],
        [ 2,  2,  2],
        [ 3,  3,  3],
        [ 4,  4,  4],
        [ 5,  5,  5],
        [11, 11, 11],
        [12, 12, 12],
        [13, 13, 13]]])

Et la forme est (2, 8, 3) , telle qu'elle devrait être.

Modifier à la suite du commentaire à partir de 19: 56Z

J'ai essayé le code de votre commentaire. Après avoir exécuté a = list((map(lambda i: a[:i], range(1,a.shape[0]+1)))), le résultat est:

[array([[1, 1]], dtype=int64),
 array([[1, 1],
        [1, 1]], dtype=int64),
 array([[1, 1],
        [1, 1],
        [1, 1]], dtype=int64),
 array([[1, 1],
        [1, 1],
        [1, 1],
        [1, 1]], dtype=int64),
 array([[1, 1],
        [1, 1],
        [1, 1],
        [1, 1],
        [1, 1]], dtype=int64),
...

a est donc une liste de tableaux de différentes tailles.

Il y a quelque chose qui ne va pas dans la façon dont vous construisez vos données. Vérifiez d'abord que vos deux tableaux sont 3D et que leurs formes diffèrent uniquement dans l'axe 1. Ce n'est qu'alors que vous pouvez exécuter mon code sur eux. Pour l'instant, a et b sont de simples listes pythoniques , pas des tableaux Numpy !

1
Valdi_Bo 27 août 2020 à 20:35