Différence entre np.la moyenne et de la tf.réduire la moyenne dans Numpy et Tensorflow?

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

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

Voici la 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] sorte de sens, puisque la moyenne de [1,2] et [1,2] sont [1.5,1.5] mais ce qui se passe avec tf.reduce_mean(x,1)?

61
demandé sur Engineero 2015-12-12 03:21:08

4 réponses

La fonctionnalité de numpy.mean et tensorflow.reduce_mean sont les mêmes. Ils font la même chose. À partir de la documentation, pour numpy et tensorflow, vous pouvez voir que. Regardons un exemple,

c = np.array([[3.,4], [5.,6], [6.,7]])
print(np.mean(c,1))

Mean = tf.reduce_mean(c,1)
with tf.Session() as sess:
    result = sess.run(Mean)
    print(result)

Sortie

[ 3.5  5.5  6.5]
[ 3.5  5.5  6.5]

Ici, vous pouvez voir que lorsque axis (numpy) ou reduction_indices (tensorflow) est 1, Il calcule la moyenne à travers (3,4) et (5,6) et (6,7), donc 1 définit à travers quel axe la moyenne est calculée. Quand il est 0, la moyenne est calculée à travers(3,5,6) et (4,6,7), et ainsi de suite. Je j'espère que vous obtenez l'idée.

Maintenant, quelles sont les différences entre eux?

Vous pouvez calculer l'opération numpy n'importe où sur python. Mais pour faire une opération tensorflow, elle doit être effectuée dans un tensorflow Session. Vous pouvez en savoir plus à ce sujet ici . Donc, lorsque vous devez effectuer un calcul pour votre graphique tensorflow(ou structure si vous voulez), il doit être fait dans un TensorFlow Session.

Regardons un autre exemple.

npMean = np.mean(c)
print(npMean+1)

tfMean = tf.reduce_mean(c)
Add = tfMean + 1
with tf.Session() as sess:
    result = sess.run(Add)
    print(result)

On pourrait augmenter la moyenne de 1 dans numpy comme vous le feriez naturellement, mais pour le faire dans tensorflow, vous devez l'effectuer dans Session, sans utiliser Session Vous ne pouvez pas le faire. En d'autres termes, lorsque vous calculez tfMean = tf.reduce_mean(c), tensorflow ne le calcule pas alors. Il calcule seulement cela dans un Session. Mais numpy calcule cela instantanément, lorsque vous écrivez np.mean().

J'espère que c'est logique.

77
répondu Shubhashis 2018-10-02 19:17:13

La clé ici est le mot reduce, un concept de programmation fonctionnelle, qui permet à reduce_mean dans TensorFlow de conserver une moyenne courante des résultats des calculs à partir 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 reduce fait. 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 - il suffit de passer tout le tableau à np.dire et vous obtenez la moyenne. Cependant, que faire si vous deviez calculer la moyenne d'un flux de nombres? Dans ce cas, vous devez d'abord assembler le tableau en lisant à partir du flux, puis appeler np.signifie Sur le tableau résultant-vous devrez écrire un peu plus de code.

Une alternative est d'utiliser le paradigme de réduction. À titre d'exemple, regardez comment nous pouvons utiliser reduce 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. Note-c'est la seule étape où 2 chiffres sont lus hors de la liste
  2. Étape 2: Lisez le chiffre suivant de la liste-5. Évaluer lambda 5, 3 (3 étant le résultat de l'étape 1, qui réduisent stocké). réduire stocke le résultat 8.
  3. Étape 3: Lisez le chiffre suivant de la liste-4. Évaluer lambda 8,4 (8 étant le résultat de l'étape 2, qui réduisent stocké). réduire stocke le résultat 12
  4. Étape 4: lisez le chiffre suivant de la liste - il n'y en a pas, donc, retournez le résultat stocké de 12.

Lire la suite 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 float et calcule la moyenne. L'entrée du graphique n'est cependant pas un seul flotteur mais un tableau de flotteurs. 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 très pratique lors du calcul des valeurs sur les lots de images. Regardez L'exemple MNIST profond 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))
8
répondu Nikhil George 2017-11-11 19:58:05

La nouvelle documentation tf.reduce_mean() produit les mêmes résultats que np.moyenne:

Équivalent à np.moyenne

Il a également absolument les mêmes paramètres que np.moyenne. Mais voici une différence importante: ils produisent les mêmes résultats uniquement sur les valeurs flottantes :

import tensorflow as tf
import numpy as np
from random import randint

num_dims = 10
rand_dim = randint(0, num_dims - 1)
c = np.random.randint(50, size=tuple([5] * num_dims)).astype(float)

with tf.Session() as sess:
    r1 = sess.run(tf.reduce_mean(c, rand_dim))
    r2 = np.mean(c, rand_dim)
    is_equal = np.array_equal(r1, r2)
    print is_equal
    if not is_equal:
        print r1
        print r2

Si vous supprimez la conversion de type, vous verrez des résultats différents


En plus de cela, de nombreuses autres fonctions tf.reduce_ telles que reduce_all, reduce_any, reduce_min, reduce_max, reduce_prod produire les mêmes valeurs qu'il numpy analogues. Clairement parce que ce sont des opérations, elles ne peuvent être exécutées que de l'intérieur de la session.

1
répondu Salvador Dali 2017-05-01 01:19:23

1 fait généralement référence aux lignes, et 2 fait généralement référence aux colonnes. Réduire l'index" over " 1 signifie réduire le nombre de lignes.

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

Cette convention de numérotation des index est typique dans les logiciels stats, en particulier R.

-1
répondu shadowtalker 2015-12-12 00:49:39