web-dev-qa-db-fra.com

Quelle est la différence entre np.mean et tf.reduce_mean?

Dans le tutoriel de débutant en MNIST , il y a la déclaration

_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 la doc sur tf.reduce_mean :

reduce_mean(input_tensor, reduction_indices=None, keep_dims=False, name=None)

_input_tensor_: Le tenseur à réduire. Devrait avoir un type numérique.

_reduction_indices_: Les dimensions à réduire. Si None (le défaut), réduit toutes les 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, cela 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] a un sens, puisque la moyenne de [1,2] et [1,2] correspond à [1.5,1.5] mais que se passe-t-il avec tf.reduce_mean(x,1)?

pythonnumpymachine-learningmeantensorflow
75
O.rka

Les fonctionnalités de numpy.mean et tensorflow.reduce_mean sont identiques. Ils font la même chose. Dans la documentation, pour numpy et tensorflow , vous pouvez le voir. 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]

Vous pouvez voir ici que lorsque axis (numpy) ou reduction_indices (flux tensoriel) vaut 1, il calcule la moyenne entre (3,4) et (5,6) et (6,7), donc 1 définit sur quel axe la moyenne est calculée. Quand il est 0, la moyenne est calculée sur (3,5,6) et (4,6,7), et ainsi de suite. J'espère que vous avez 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 effectuer une opération tensorflow, il faut que ce soit à l'intérieur d'un tensorflow Session. Vous pouvez en lire plus à ce sujet ici . Ainsi, lorsque vous devez effectuer un calcul pour votre graphe de tensorflow (ou sa structure si vous préférez), vous devez le faire à l'intérieur d'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)

Nous pourrions augmenter la moyenne de 1 dans numpy comme vous le feriez naturellement, mais pour le faire dans tensorflow, vous devez exécuter cela dans Session, sans utiliser Session vous ne peut pas faire ça. En d'autres termes, lorsque vous calculez tfMean = tf.reduce_mean(c), tensorflow ne le calcule pas alors. Il ne calcule que dans un Session. Mais numpy calcule cela instantanément lorsque vous écrivez np.mean().

J'espère que ça a du sens.

94
Shubhashis

La clé ici est Word Word, un concept issu de la programmation fonctionnelle, qui permet à reduction de conserver dans TensorFlow une moyenne mobile des résultats de 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 réduit fait. Si on vous donne une liste comme [1,2,5,4] et qu'on vous dit de calculer la moyenne, c'est facile - il suffit de passer le tableau entier à np.mean et vous obtiendrez la moyenne. Mais que se passe-t-il si vous devez calculer la moyenne d'un flux de nombres? Dans ce cas, vous devez d'abord assembler le tableau en le lisant dans le flux, puis appeler np.mean sur le tableau obtenu. Vous devrez alors écrire du code supplémentaire.

Une alternative consiste à utiliser le paradigme de réduction. A titre d'exemple, voyons comment nous pouvons utiliser réduire dans 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. Évaluez lambda 1,2. réduire stocke le résultat 3. Remarque - il s'agit de la seule étape où 2 chiffres sont lus dans la liste.
  2. Étape 2: Lisez le prochain chiffre de la liste - 5. Évaluez lambda 5, 3 (3 étant le résultat de l’étape 1, qui réduit la valeur enregistrée). réduire stocke le résultat 8.
  3. Étape 3: Lire le prochain chiffre de la liste - 4. Évaluer lambda 8,4 (8 étant le résultat de l’étape 2, qui réduit la valeur enregistrée). réduire les magasins le résultat 12
  4. Étape 4: Lisez le prochain chiffre de la liste - il n’en existe aucun, renvoyez donc le résultat mémorisé de 12.

Lire la suite ici Programmation fonctionnelle en Python

Pour voir comment cela s’applique à TensorFlow, examinez le bloc de code suivant, qui définit un graphique simple, qui prend un float et calcule la moyenne. Cependant, l’entrée dans le graphique n’est pas un simple float, mais un tableau de float. Reduction_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 de 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))
15
Nikhil George

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

Équivalent à np.mean

Il a aussi absolument les mêmes paramètres que np.mean . Mais voici une différence importante: ils produisent les mêmes résultats uniquement sur les valeurs de type float :

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 produisent les mêmes valeurs que là. analogues numpy. Clairement, parce qu’il s’agit d’opérations, elles ne peuvent être exécutées qu’à l’intérieur de la session.

2
Salvador Dali