La façon la plus rapide pour calculer l'entropie de chaque tableau numpy ligne?

J'ai un tableau de taille MxN et je voudrais calculer la valeur d'entropie de chaque ligne. Quel serait le moyen le plus rapide de le faire ?

l'entropie: -np.somme(probs * np.log2(probs))
Par le plus rapide, vous voulez dire que vous voulez une version optimisée, ou voulez-vous dire que vous voulez quelque chose qui s'inscrit dans une ligne et il est facile à lire?
pas la plus facile, la plus rapide en termes de calcul puisque j'ai une assez grande matrice, ligne itération prend trop de temps.
Votre premier commentaire devrait être une partie de la question. J'interprète la question comme "j'ai un tableau de probabilités probs, et je veux l'entropie de l'lignes." Si vous n'avez pas de probabilités, veuillez préciser la question.

OriginalL'auteur erogol | 2015-11-09

  1. 6

    scipy.spécial.entr calcule -x*log(x) pour chaque élément dans un tableau. Après l'appel, vous pouvez additionner les lignes.

    Voici un exemple. Tout d'abord, créez un tableau p de valeurs positives dont les lignes somme de 1:

    In [23]: np.random.seed(123)

In [24]: x = np.random.rand(3, 10)

In [25]: p = x/x.sum(axis=1, keepdims=True)

In [26]: p
Out[26]: 
array([[ 0.12798052,  0.05257987,  0.04168536,  0.1013075 ,  0.13220688,
         0.07774843,  0.18022149,  0.1258417 ,  0.08837421,  0.07205402],
       [ 0.08313743,  0.17661773,  0.1062474 ,  0.01445742,  0.09642919,
         0.17878489,  0.04420998,  0.0425045 ,  0.12877228,  0.1288392 ],
       [ 0.11793032,  0.15790292,  0.13467074,  0.11358463,  0.13429674,
         0.06003561,  0.06725376,  0.0424324 ,  0.05459921,  0.11729367]])

In [27]: p.shape
Out[27]: (3, 10)

In [28]: p.sum(axis=1)
Out[28]: array([ 1.,  1.,  1.])

    Maintenant calculer l'entropie de chaque ligne. entr utilise le logarithme naturel, de sorte à obtenir le base-2 log, divisez le résultat par log(2).

    In [29]: from scipy.special import entr

In [30]: entr(p).sum(axis=1)
Out[30]: array([ 2.22208731,  2.14586635,  2.22486581])

In [31]: entr(p).sum(axis=1)/np.log(2)
Out[31]: array([ 3.20579434,  3.09583074,  3.20980287])

    Si vous ne voulez pas que la dépendance sur scipy, vous pouvez utiliser la formule explicite:

    In [32]: (-p*np.log2(p)).sum(axis=1)
Out[32]: array([ 3.20579434,  3.09583074,  3.20980287])
    Mon probabilités étaient tous 0. Pour résoudre cela, j'ai eu à jeter le dénominateur est la somme de flotter, par exemple, p = x/float(x.somme(axis=1, keepdims=True)). Dans le cas où quelqu'un a le même problème.
    scipy.stats.entropy calcule également la même valeur que entr(p).sum(axis=1)

    OriginalL'auteur Warren Weckesser

  2. 1

    @Warren l'a souligné, il est difficile de savoir à partir de votre question de savoir si vous êtes au départ d'un tableau de probabilités, ou de la crue des échantillons eux-mêmes. Dans ma réponse j'ai assumé ce dernier, auquel cas le principal goulot d'étranglement sera le calcul de la bin compte sur chaque ligne.

    En supposant que chaque vecteur d'échantillons est relativement long, le moyen le plus rapide pour ce faire sera probablement utiliser np.bincount:

    import numpy as np

def entropy(x):
    """
    x is assumed to be an (nsignals, nsamples) array containing integers between
    0 and n_unique_vals
    """
    x = np.atleast_2d(x)
    nrows, ncols = x.shape
    nbins = x.max() + 1

    # count the number of occurrences for each unique integer between 0 and x.max()
    # in each row of x
    counts = np.vstack((np.bincount(row, minlength=nbins) for row in x))

    # divide by number of columns to get the probability of each unique value
    p = counts / float(ncols)

    # compute Shannon entropy in bits
    return -np.sum(p * np.log2(p), axis=1)

    Bien que Warren méthode de calcul des entropies de la probabilité des valeurs à l'aide entr est légèrement plus rapide qu'à l'aide de la formule explicite, dans la pratique, il est probable que cela ne représentent qu'une infime fraction de la quantité totale d'exécution par rapport au temps nécessaire pour calculer le bin compte.

    Test de justesse à une seule rangée:

    vals = np.arange(3)
prob = np.array([0.1, 0.7, 0.2])
row = np.random.choice(vals, p=prob, size=1000000)

print("theoretical H(x): %.6f, empirical H(x): %.6f" %
      (-np.sum(prob * np.log2(prob)), entropy(row)[0]))
# theoretical H(x): 1.156780, empirical H(x): 1.157532

    Vitesse d'essai:

    In [1]: %%timeit x = np.random.choice(vals, p=prob, size=(1000, 10000))
   ....: entropy(x)
   ....: 
10 loops, best of 3: 34.6 ms per loop

    Si vos données ne consiste pas en entier indices entre 0 et le nombre de valeurs uniques, vous pouvez les convertir dans ce format à l'aide np.unique:

    y = np.random.choice([2.5, 3.14, 42], p=prob, size=(1000, 10000))
unq, x = np.unique(y, return_inverse=True)
x.shape = y.shape
    vous pourriez être en mesure de gagner du temps en utilisant -np.dot(a, b) en place de -np.sum(a * b)
    Avec np.dot je ne peut pas facilement vectoriser l'entropie de calcul sur plusieurs lignes. Un autre moyen serait quelque chose comme -np.einsum('ij,ij->i', p, np.log2(p)), bien que vous pourriez tout aussi bien utiliser entr pour cette partie car il a une axis argument. De toute façon, le coûteux partie est généralement le calcul de la corbeille du compte.

    OriginalL'auteur ali_m