Qual'è la differenza tra np.mean e tf.reduce_mean?

90

Nel tutorial per principianti di MNIST , c'è la dichiarazione

accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))

tf.castsostanzialmente cambia il tipo di tensore dell'oggetto, ma qual è la differenza tra tf.reduce_meane np.mean?

Ecco il documento su tf.reduce_mean:

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

input_tensor: Il tensore da ridurre. Dovrebbe avere un tipo numerico.

reduction_indices: Le dimensioni da ridurre. Se None(il valore predefinito), riduce tutte le dimensioni.

# '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 stia succedendo in tf.reduce_mean(x, 1) ==> [1., 2.]. tf.reduce_mean(x, 0) ==> [1.5, 1.5]ha senso, dal momento che significa [1, 2]e [1, 2]è [1.5, 1.5], ma cosa sta succedendo tf.reduce_mean(x, 1)?

python  numpy  machine-learning  mean  tensorflow 
— O.rka
fonte
producono risultati diversi su valori interi a causa della divisione in python
— Salvador Dali
Una differenza importante per chi è nuovo a tensorflow: tf.reduce_meanè il multi-thread, tipicamente calcolato sulla tua GPU, mentre np.meanè calcolato su una singola CPU. Inoltre, tfè progettato per elaborare un batch di dati mentre npagisce su una singola istanza di dati.
— drevicko

Risposte:

110

Le funzionalità di numpy.meane tensorflow.reduce_meansono le stesse. 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)

Produzione

[ 3.5  5.5  6.5]
[ 3.5  5.5  6.5]

Qui puoi vedere che quando axis(numpy) o reduction_indices(tensorflow) è 1, calcola la media tra (3,4) e (5,6) e (6,7), quindi 1definisce su quale asse viene calcolata la media. Quando è 0, la media viene calcolata tra (3,5,6) e (4,6,7) e così via. Spero che tu abbia avuto l'idea.

Ora quali sono le differenze tra loro?

Puoi calcolare l'operazione numpy ovunque su Python. Ma per eseguire un'operazione di tensorflow, deve essere eseguita all'interno di un tensorflow Session. Puoi leggere di più al riguardo qui . Quindi, quando è necessario eseguire qualsiasi calcolo per il proprio grafo tensorflow (o struttura se si desidera), deve essere eseguito all'interno di un tensorflow Session.

Vediamo 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 aumentare la media di 1in numpycome faresti naturalmente, ma per farlo in tensorflow, devi eseguirlo Session, senza usare Sessionnon puoi farlo. In altre parole, quando stai tfMean = tf.reduce_mean(c)elaborando, tensorflow non lo calcola allora. Calcola solo che in un file Session. Ma numpy lo calcola istantaneamente, quando scrivi np.mean().

Spero abbia senso.

— Shubhashis
fonte
21
Ma cosa significa ridurre parte significa qui?
— rsht
20
@Roman è un termine della programmazione funzionale. potete leggerlo qui: python-course.eu/lambda.php
— Daniyar
1
@rsht REDUCE = ridurre i numeri sommandoli fino a 1 valore. MEDIA = media di quella somma.
— Meghna Natraj
1
@rsht Immagina di avere N elementi e di voler calcolare il valore medio (M) di questi N numeri. Un modo per vedere questo problema è che abbiamo un vettore di dimensione (1, N) e sopra l'asse = 0, riduciamo gli elementi (qui abbiamo N elementi). La riduzione (o aggregazione) viene fornita con una funzionalità e, nel nostro esempio, la funzione è la funzione media.
— alift
22

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

Se non hai familiarità con la programmazione funzionale, questo può sembrare misterioso. Quindi, prima vediamo cosa fa ridurre. Se ti viene fornita una lista come [1,2,5,4] e ti viene detto di calcolare la media, è facile: passa l'intero array a np.mean e ottieni la media. Tuttavia, cosa succederebbe se dovessi calcolare la media di un flusso di numeri? In tal caso, dovresti prima assemblare l'array leggendo dal flusso e quindi chiamare np.mean sull'array risultante - dovresti scrivere altro codice.

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

Funziona così:

  1. Passaggio 1: leggere 2 cifre dall'elenco - 1,2. Valuta lambda 1,2. reduce memorizza il 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 riduce memorizzato). ridurre memorizza 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. Passaggio 4: leggi la cifra successiva dall'elenco: non ce ne sono, quindi restituisci il risultato memorizzato di 12.

Maggiori informazioni qui Programmazione funzionale in Python

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

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 i valori su batch di immagini. Guarda The Deep MNIST Example dove vedi codice come:

correct_prediction = tf.equal(tf.argmax(y,1), tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
— Nikhil George
fonte
3

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

Equivalente a np.mean

Inoltre ha assolutamente gli stessi parametri di np.mean . Ma ecco una differenza importante: producono gli stessi risultati solo su valori 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

Se rimuovi la conversione del tipo, vedrai risultati diversi

In aggiunta a questo, molte altre tf.reduce_funzioni quali reduce_all, reduce_any, reduce_min, reduce_max, reduce_prodproducono gli stessi valori analoghi là numpy. Chiaramente poiché sono operazioni, possono essere eseguite solo dall'interno della sessione.

— Salvador Dalì
fonte
potrebbe essere utile se, oltre all'esempio, spiegassi qual è la differenza. Dall'esecuzione del tuo esempio, ho l'impressione che tf.reduce_meanassicuri che l'output dtypecorrisponda all'input dtype. L'output di np.mean()è sempre un float. È corretto?
— craq
-1

1di solito si riferisce a righe e di 2solito si riferisce a colonne. Ridurre l'indice "oltre" 1significa ridurre per riga.

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

Questa convenzione di numerazione dell'indice è tipica dei software statistici, in particolare R.

— shadowtalker
fonte
1
Credo che 0 si riferisca alla colonna, non 2
— hfz
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.