Np.mean और tf.reduce_mean में क्या अंतर है?

Question 1

में MNIST शुरुआत ट्यूटोरियल , वहाँ बयान है

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

tf.castमूल रूप से वस्तु के दसियों प्रकार में परिवर्तन होता है, लेकिन क्या tf.reduce_meanऔर क्या अंतर है np.mean?

यहाँ डॉक्टर पर है tf.reduce_mean:

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

input_tensor: कम करने के लिए टेंसर। संख्यात्मक प्रकार होना चाहिए।

reduction_indices: कम करने के आयाम। यदि None(अवक्षेप), सभी आयामों को कम करता है।
# '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.]

1 डी वेक्टर के लिए, यह दिखता है np.mean == tf.reduce_mean, लेकिन मुझे समझ में नहीं आता कि क्या हो रहा है tf.reduce_mean(x, 1) ==> [1., 2.]। tf.reduce_mean(x, 0) ==> [1.5, 1.5]मतलब की तरह, के बाद से [1, 2]और [1, 2]है [1.5, 1.5], लेकिन क्या हो रहा है tf.reduce_mean(x, 1)?

Question 2

की कार्यक्षमता numpy.meanऔर tensorflow.reduce_meanसमान हैं। वही काम करते हैं। दस्तावेज़ से, सुन्न और टेंसोफ़्लो के लिए , आप देख सकते हैं। एक उदाहरण को देखते हैं,

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)

उत्पादन

[ 3.5  5.5  6.5]
[ 3.5  5.5  6.5]

यहाँ आप देख सकते हैं कि जब axis(सुन्न) या reduction_indices(टेंसोफ़्लो) 1 होता है, तो इसका मतलब पार (3,4) और (5,6) और (6,7) होता है, इसलिए यह 1परिभाषित किया जाता है कि कौन सा अक्ष गणना है। जब यह 0 होता है, तो माध्य (3,5,6) और (4,6,7) में गणना की जाती है, और इसी तरह। मुझे उम्मीद है कि आपको यह विचार मिलेगा।

अब उनके बीच क्या अंतर हैं?

आप अजगर पर कहीं भी सुन्न ऑपरेशन की गणना कर सकते हैं। लेकिन एक टेंसरफ़्लो ऑपरेशन करने के लिए, इसे टेंसोफ़्लो के अंदर किया जाना चाहिए Session। आप इसके बारे में और अधिक यहाँ पढ़ सकते हैं । इसलिए जब आपको अपने टेंसरफ़्लो ग्राफ (या यदि आप चाहें तो संरचना) के लिए कोई गणना करने की आवश्यकता है, तो इसे टेंसोफ़्लो के अंदर किया जाना चाहिए Session।

एक और उदाहरण देखते हैं।

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)

हम से मतलब बढ़ सकते 1में numpyआप स्वाभाविक रूप से होगा के रूप में है, लेकिन आदेश tensorflow में ऐसा करने के लिए, आपको लगता है कि प्रदर्शन करने के लिए की जरूरत है Session, का उपयोग किए बिना Sessionआप ऐसा नहीं कर सकते। दूसरे शब्दों में, जब आप गणना कर रहे होते हैं tfMean = tf.reduce_mean(c), तो टेंसोफ़्लो इसकी गणना नहीं करता है। यह केवल गणना करता है कि ए Session। लेकिन जब आप लिखते हैं तो सुन्न गणना करता है np.mean()।

मुझे उम्मीद है कि यह समझ में आता है।

Question 3

यहां कुंजी शब्द को कम करना है, कार्यात्मक प्रोग्रामिंग से एक अवधारणा है, जो कि इनपुट के बैच से गणनाओं के परिणामों का एक औसत चलने के लिए TensorFlow में कम करने के लिए संभव बनाता है।

यदि आप कार्यात्मक प्रोग्रामिंग से परिचित नहीं हैं, तो यह रहस्यमय लग सकता है। तो पहले देखते हैं कि क्या कम करता है। यदि आपको [1,2,5,4] जैसी सूची दी गई थी और कहा गया था कि इसका अर्थ गणना करना है, तो यह आसान है - बस np.mean को पूरे सरणी को पास करें और आपको इसका मतलब मिलता है। हालाँकि, यदि आपको संख्याओं की धारा के बीच की गणना करनी हो तो क्या होगा? उस स्थिति में, आपको पहले स्ट्रीम से पढ़कर सरणी को इकट्ठा करना होगा और फिर परिणामी सरणी पर np.mean को कॉल करना होगा - आपको कुछ और कोड लिखना होगा।

एक विकल्प कम प्रतिमान का उपयोग करना है। एक उदाहरण के रूप में, हम संख्याओं की संख्या की गणना करने के लिए अजगर में कमी का उपयोग कैसे कर सकते हैं, इसे देखें reduce(lambda x,y: x+y, [1,2,5,4]):।

यह इस तरह काम करता है:

चरण 1: सूची से 2 अंक पढ़ें - 1,2। लैम्ब्डा 1,2 का मूल्यांकन करें। भंडार कम करें परिणाम 3. नोट - यह एकमात्र चरण है जहां 2 अंक सूची से पढ़े जाते हैं
चरण 2: सूची से अगला अंक पढ़ें - 5. लंबोदर 5, 3 का मूल्यांकन करें (3 चरण 1 से परिणाम है, कि संग्रहीत)। दुकानों को कम करने के परिणाम 8।
चरण 3: सूची से अगला अंक पढ़ें - 4. लंबोदर 8,4 का मूल्यांकन करें (8 चरण 2 का परिणाम है, जो संग्रहीत कम हो जाता है)। दुकानों 12 परिणाम कम करें
चरण 4: सूची से अगला अंक पढ़ें - कोई नहीं हैं, इसलिए 12 का संग्रहीत परिणाम लौटाएं।

यहाँ और अधिक पढ़ें पायथन में कार्यात्मक प्रोग्रामिंग

यह देखने के लिए कि यह TensorFlow पर कैसे लागू होता है, कोड के निम्नलिखित ब्लॉक को देखें, जो एक सरल ग्राफ को परिभाषित करता है, जो फ्लोट में लेता है और माध्य की गणना करता है। ग्राफ में इनपुट हालांकि एक फ्लोट नहीं है, बल्कि फ्लोट्स की एक सरणी है। उन सभी फ़्लोट्स पर माध्य मान को कम करता है।

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

यह पैटर्न काम में आता है जब छवियों के बैचों पर मानों की गणना होती है। को देखो दीप MNIST उदाहरण है जहाँ आप की तरह कोड देखें:

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

Question 4

नए दस्तावेज़ में कहा गया है कि tf.reduce_mean()np.mean के समान परिणाम उत्पन्न करता है:

Np.mean के बराबर

यह भी बिल्कुल np.mean के समान पैरामीटर है । लेकिन यहाँ एक महत्वपूर्ण अंतर है: वे केवल फ्लोट मूल्यों पर एक ही परिणाम उत्पन्न करते हैं :

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

यदि आप टाइप रूपांतरण को हटा देंगे, तो आपको अलग परिणाम दिखाई देंगे

इस के लिए अतिरिक्त में, कई अन्य tf.reduce_कार्यों जैसे reduce_all, reduce_any, reduce_min, reduce_max, reduce_prodएक ही मान वहाँ numpy एनालॉग के रूप में उत्पादन। स्पष्ट रूप से क्योंकि वे ऑपरेशन हैं, उन्हें सत्र के अंदर से ही निष्पादित किया जा सकता है।

Question 5

1आमतौर पर पंक्तियों को संदर्भित करता है, और 2आमतौर पर स्तंभों को संदर्भित करता है। "ओवर" इंडेक्स 1को कम करने का मतलब है रोव्यू को कम करना।

[1., 2.]बस है [ <row 1 mean> , <row 2 mean> ]।

यह इंडेक्स नंबरिंग कन्वेंशन सांख्यिकी सॉफ्टवेयर में विशिष्ट है, विशेष रूप से आर।