Differenza tra np.mean e tf.reduce_mean in Numpy e Tensorflow?

Question

Nel MNIST beginner tutorial, c'è accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

tf.cast cambia sostanzialmente il tipo di tensore l'oggetto è, ma ciò che è la differenza tra tf.reduce_mean e np.mean?

Ecco il doc su 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.] 

Per un vettore 1D, sembra np.mean == tf.reduce_mean ma non capisco cosa sta succedendo nel tf.reduce_mean(x, 1) ==> [1., 2.]. tf.reduce_mean(x, 0) ==> [1.5, 1.5] tipo di ha senso, dal momento che media di [1,2] e [1,2] sono [1.5,1.5] ma cosa succede con tf.reduce_mean(x,1)?

Answer 1

La funzionalità di numpy.mean e tensorflow.reduce_mean sono gli stessi. Fanno la stessa cosa Dalla documentazione, per numpy e tensorflow, puoi vederlo. Vediamo un esempio,

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) 

uscita

[ 3.5 5.5 6.5] 
[ 3.5 5.5 6.5] 

Qui potete vedere che quando axis (NumPy) o reduction_indices (tensorflow) è 1, calcola medio di tutti (3,4) e (5,6) e (6,7), quindi 1 definisce attraverso quale asse viene calcolata la media. Quando è 0, la media è calcolata su (3,5,6) e (4,6,7), e così via. Spero che tu abbia capito l'idea.

Ora quali sono le differenze tra loro?

È possibile calcolare l'operazione numpy in qualsiasi parte di python. Ma per fare un'operazione di tensorflow, deve essere fatto all'interno di un tensorflow Session. Puoi leggere di più su di esso here. Pertanto, quando è necessario eseguire calcoli per il proprio grafico di tensorflow (o struttura, se lo si desidera), deve essere eseguito all'interno di un tensorflow Session.

Consente di guardare un altro esempio.

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) 

Potremmo aumento medio da 1 in numpy come si farebbe naturalmente, ma per farlo in tensorflow, è necessario eseguire che nel Session, senza l'utilizzo di Session non è possibile farlo. In altre parole, quando state calcolando tfMean = tf.reduce_mean(c), tensorflow non lo calcola allora. Calcola solo quello in un Session. Ma numpy calcola immediatamente quando scrivi np.mean().

Spero che abbia senso.

Answer 2

1 di solito si riferisce alle righe e 2 di solito si riferisce alle colonne. Ridurre l'indice "sopra" 1 significa ridurre la riga.

[1., 2.] è solo [ <row 1 mean> , <row 2 mean> ].

Questo indice convenzione di numerazione è tipico nel software previsti, soprattutto R.

Answer 3

La nuova documentazione indica che tf.reduce_mean() produce gli stessi risultati di np.significa:

Equivalente a np.mean

ache assolutamente gli stessi parametri np.mean. Ma qui è una differenza importante: producono gli stessi risultati solo su float valori:

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 

Se si rimuove la conversione del tipo, si vedrà risultati diversi

---

In aggiunta a questo, molte altre funzioni tf.reduce_ come reduce_all, reduce_any, reduce_min, reduce_max, reduce_prod producono gli stessi valori degli analoghi numerici. Chiaramente perché sono operazioni, possono essere eseguite solo dall'interno della sessione.

Answer 4

La chiave qui è la parola reduce, un concetto di programmazione funzionale, che consente a reduce_mean in TensorFlow di mantenere una media costante dei risultati dei calcoli da un batch di input.

Se non si ha familiarità con la programmazione funzionale, questo può sembrare misterioso. Quindi per prima cosa vediamo cosa riduce. Se ti è stata data una lista come [1,2,5,4] e ti è stato detto di calcolare la media, è facile: basta passare l'intero array a np.mean e ottieni la media. E se invece dovessi calcolare la media di un flusso di numeri? In quel caso, dovresti prima assemblare l'array leggendo dallo stream e poi chiamare np.mean sull'array risultante: dovresti scrivere un altro codice.

Un'alternativa è utilizzare il paradigma di riduzione. Ad esempio, guarda come possiamo ridurre in python per calcolare la somma dei numeri: reduce(lambda x,y: x+y, [1,2,5,4]).

funziona così:

1. Fase 1: leggi le 2 cifre dalla lista - 1,2. Valutare lambda 1,2. Riduci i negozi al risultato 3. Nota: questo è l'unico passaggio in cui vengono lette 2 cifre dall'elenco
2. Passaggio 2: leggere la cifra successiva dall'elenco - 5. Valutare lambda 5, 3 (3 è il risultato del passaggio 1 , che riducono memorizzati). ridurre i negozi il risultato 8.
3. Passaggio 3: leggere la cifra successiva dall'elenco - 4. Valutare lambda 8,4 (8 è il risultato del passaggio 2, che riduce memorizzato). ridurre memorizza il risultato 12
4. Fase 4: Leggere la cifra successiva dalla lista - non ce ne sono, in modo da restituire il risultato memorizzato di 12.

Leggi tutto qui Functional Programming in Python

Per vedere come questo si applica su TensorFlow, guarda il seguente blocco di codice, che definisce un semplice grafico, che prende in virgola mobile e calcola la media. L'input al grafico tuttavia non è un singolo float ma una serie di float. Il reduce_mean calcola il valore medio su tutti quei galleggianti.

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})) 

Questo modello è utile quando si calcolano valori su lotti di immagini.Guardate The Deep MNIST Example dove si vede il codice come:

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