J'ai une liste 1-d comme suit:

data = [1,5,9,13,
        2,6,10,14,
        3,7,11,15,
        4,8,12,16]

Je veux faire la liste suivante de tuples et calculer la moyenne de chaque tuple séparément.

[(1,5,2,6), (3,7,4,8), (9,13,10,14), (11,15,12,16)]

Le résultat attendu devrait être:

[3.5, 5.5, 11.5, 13.5]

Quelle est la manière la plus simple de le faire?

3
Borys 18 juil. 2015 à 21:23

3 réponses

Meilleure réponse

Mettez les données dans un tableau numpy 4-d avec la forme (2, 2, 2, 2), puis prenez la moyenne de ce tableau sur les axes 1 et 3:

In [25]: data
Out[25]: [1, 5, 9, 13, 2, 6, 10, 14, 3, 7, 11, 15, 4, 8, 12, 16]

In [26]: a = np.array(data).reshape(2, 2, 2, 2)

In [27]: a
Out[27]: 
array([[[[ 1,  5],
         [ 9, 13]],

        [[ 2,  6],
         [10, 14]]],


       [[[ 3,  7],
         [11, 15]],

        [[ 4,  8],
         [12, 16]]]])

In [28]: a.mean(axis=(1, 3))
Out[28]: 
array([[  3.5,  11.5],
       [  5.5,  13.5]])

Vous pouvez utiliser la méthode ravel() si vous avez besoin du résultat final sous forme de tableau 1-d:

In [31]: a.mean(axis=(1, 3)).ravel()
Out[31]: array([  3.5,  11.5,   5.5,  13.5])

Voir Comment puis-je vectoriser la moyenne de 2x2 sous-tableaux de tableau numpy? pour une question similaire.

2
Community 23 mai 2017 à 12:06

Dans ce post, vous trouverez quelques suggestions de solutions -

def grouped_mean(data,M2,N1,N2):

    # Paramters:
    # M2 = Columns in input data
    # N1, N2 = Blocksize into which data is to be divided and averaged

    # Get grouped mean values; transpose and flatten for final output
    grouped_mean = np.array(data).reshape(-1,N2).sum(1).reshape(-1,N1,M2/N2).sum(1)/(N1*N2)

    # Return transposed and flattened version as output (as per OP) 
    return grouped_mean.T.ravel()

Maintenant, grouped_mean pourrait être calculé avec {{X1 }} au lieu de np.sum comme ça -

stage1_sum = np.einsum('ij->i',np.array(data).reshape(-1,N2))
grouped_mean = np.einsum('ijk->ik',stage1_sum.reshape(-1,N1,M2/N2))/(N1*N2)

Ou, on peut aller avec la division du tableau d'entrée 2D en un tableau 4D comme suggéré dans @Warren Weckesser's solution, puis utiliser np.einsum comme ça -

split_data = np.array(data).reshape(-1, N1, M2/N2, N2)
grouped_mean = np.einsum('ijkl->ik',split_data)/(N1*N2)

Exemple d'exécution -

In [182]: data = np.array([[1,5,9,13],
     ...:                  [2,6,10,14],
     ...:                  [3,7,11,15],
     ...:                  [4,8,12,16]])

In [183]: grouped_mean(data,4,2,2)
Out[183]: array([  3.5,   5.5,  11.5,  13.5])

Tests d'exécution

Le calcul de grouped_mean semble être la partie du code la plus intensive en termes de calcul. Voici donc quelques tests d'exécution pour le calculer avec ces trois approches -

In [174]: import numpy as np
     ...: # Setup parameters and input list
     ...: M2 = 4000
     ...: N1 = 2
     ...: N2 = 2
     ...: data = np.random.randint(0,9,(16000000)).tolist()
     ...: 

In [175]: %timeit np.array(data).reshape(-1,N2).sum(1).reshape(-1,N1,M2/N2).sum(1)/(N1*N2)
     ...: %timeit np.einsum('ijk->ik',np.einsum('ij->i',np.array(data).reshape(-1,N2)).reshape(-1,N1,M2/N2))/(N1*N2)
     ...: %timeit np.einsum('ijkl->ik',np.array(data).reshape(-1, N1, M2/N2, N2))/(N1*N2)
     ...: 
1 loops, best of 3: 2.2 s per loop
1 loops, best of 3: 2.12 s per loop
1 loops, best of 3: 2.1 s per loop
1
Community 23 mai 2017 à 12:14

Voici une approche

In [29]: a = np.array(data)

In [30]: a2 = a.reshape(4,4)

In [31]: a3 = np.vstack((a2[:, :2], a2[:, 2:]))

In [32]: a4 = a3.reshape(4,4)

In [33]: np.mean(a4, axis=1)
Out[33]: array([  3.5,   5.5,  11.5,  13.5])
2
Akavall 18 juil. 2015 à 18:42