[python] Différence entre np.mean et tf.reduce_mean dans Numpy et Tensorflow?


Answers

La clé ici est le mot reduce, un concept issu de la programmation fonctionnelle, qui permet à reduce_mean dans TensorFlow de conserver une moyenne courante des résultats de calculs d'un lot d'entrées.

Si vous n'êtes pas familier avec la programmation fonctionnelle, cela peut sembler mystérieux. Alors voyons d'abord ce que réduit. Si on vous a donné une liste comme [1,2,5,4] et qu'on vous a dit de calculer la moyenne, c'est facile - passez simplement le tableau entier à np.mean et vous obtiendrez la moyenne. Cependant, que faire si vous deviez calculer la moyenne d'un flux de nombres? Dans ce cas, vous devrez d'abord assembler le tableau en lisant le flux, puis appeler np.mean sur le tableau résultant - vous devrez écrire du code supplémentaire.

Une alternative est d'utiliser le paradigme réduire. A titre d'exemple, regardez comment nous pouvons utiliser réduire en python pour calculer la somme des nombres: reduce(lambda x,y: x+y, [1,2,5,4]) .

Cela fonctionne comme ceci:

  1. Étape 1: Lire 2 chiffres de la liste - 1,2. Évaluer lambda 1,2. Réduire stocke le résultat 3. Remarque - C'est la seule étape où 2 chiffres sont lus sur la liste
  2. Étape 2: Lire le chiffre suivant de la liste - 5. Évaluer lambda 5, 3 (3 étant le résultat de l'étape 1, qui réduit stocké). réduire les magasins le résultat 8.
  3. Etape 3: Lire le chiffre suivant dans la liste - 4. Evaluer lambda 8,4 (8 étant le résultat de l'étape 2, qui réduit stocké). réduire les magasins le résultat 12
  4. Étape 4: Lisez le chiffre suivant de la liste - il n'y en a pas, alors retournez le résultat enregistré de 12.

En savoir plus ici Programmation fonctionnelle en Python

Pour voir comment cela s'applique à TensorFlow, regardez le bloc de code suivant, qui définit un graphique simple, qui prend un flottant et calcule la moyenne. L'entrée sur le graphique n'est cependant pas un seul flottant mais un tableau de flottants. Le reduce_mean calcule la valeur moyenne sur tous ces flottants.

import tensorflow as tf


inp = tf.placeholder(tf.float32)
mean = tf.reduce_mean(inp)

x = [1,2,3,4,5]

with tf.Session() as sess:
    print(mean.eval(feed_dict={inp : x}))

Ce modèle est pratique lorsque vous calculez des valeurs sur des lots d'images. Regardez l' exemple Deep MNIST où vous voyez du code comme:

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
Question

Dans le tutoriel débutant MNIST , il y a la accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

tf.cast change fondamentalement le type de tenseur de l'objet, mais quelle est la différence entre tf.reduce_mean et np.mean ?

Voici le doc sur tf.reduce_mean :

reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)
input_tensor: The tensor to reduce. Should have numeric type.
reduction_indices: The dimensions to reduce. If `None` (the defaut),
    reduces all dimensions.

# 'x' is [[1., 1. ]]
#         [2., 2.]]
tf.reduce_mean(x) ==> 1.5
tf.reduce_mean(x, 0) ==> [1.5, 1.5]
tf.reduce_mean(x, 1) ==> [1.,  2.]

Pour un vecteur 1D, il ressemble à np.mean == tf.reduce_mean mais je ne comprends pas ce qui se passe dans tf.reduce_mean(x, 1) ==> [1., 2.] . tf.reduce_mean(x, 0) ==> [1.5, 1.5] un sens, puisque les moyennes de [1,2] et [1,2] sont [1.5,1.5] mais que se passe-t-il avec tf.reduce_mean(x,1) ?




1 se réfère généralement aux lignes, et 2 se réfère généralement aux colonnes. Réduire l'indice "over" 1 signifie réduire les rangées.

[1., 2.] est juste [ <row 1 mean> , <row 2 mean> ] .

Cette convention de numérotation d'index est typique dans les logiciels de statistiques, en particulier R.






Related