tensorflow हानि न्यूनीकरण प्रकार त्रुटि

Question

मेरे पास टेंसरफ्लो में लागू एक हानि फ़ंक्शन है जो औसत वर्ग त्रुटि की गणना करता है। उद्देश्य का गणना करने के लिए उपयोग किए जाने वाले सभी टेंसर फ्लोट 64 के प्रकार हैं और इसलिए हानि फ़ंक्शन स्वयं dtype float64 का है। विशेष रूप से,

print cost 
==> Tensor("add_5:0", shape=TensorShape([]), dtype=float64) 

हालांकि, जब मैं कम करने का प्रयास मैं एक मूल्य त्रुटि सम्मान के साथ टेन्सर के प्रकार के प्राप्त:

GradientDescentOptimizer(learning_rate=0.1).minimize(cost) 
==> ValueError: Invalid type <dtype: 'float64'> for add_5:0, expected: [tf.float32]. 

मुझे समझ नहीं आता क्यों टेन्सर की उम्मीद dtype है एक सटीक फ्लोट जब गणना के लिए अग्रणी सभी चर प्रकार float64 प्रकार हैं। मैंने पुष्टि की है कि जब मैं फ्लोट 32 होने के लिए सभी चरों को मजबूर करता हूं तो गणना सही ढंग से निष्पादित होती है।

क्या किसी के पास कोई अंतर्दृष्टि है कि यह क्यों हो रहा है? मेरा कंप्यूटर एक 64 बिट मशीन है।

यहाँ एक उदाहरण है कि व्यवहार

import tensorflow as tf 
import numpy as np 

# Make 100 phony data points in NumPy. 
x_data = np.random.rand(2, 100) # Random input 
y_data = np.dot([0.100, 0.200], x_data) + 0.300 

# Construct a linear model. 
b = tf.Variable(tf.zeros([1], dtype=np.float64)) 
W = tf.Variable(tf.random_uniform([1, 2], minval=-1.0, maxval=1.0, dtype=np.float64)) 
y = tf.matmul(W, x_data) + b 

# Minimize the squared errors. 
loss = tf.reduce_mean(tf.square(y - y_data)) 
optimizer = tf.train.GradientDescentOptimizer(0.5) 
train = optimizer.minimize(loss) 

# For initializing the variables. 
init = tf.initialize_all_variables() 

# Launch the graph 
sess = tf.Session() 
sess.run(init) 

# Fit the plane. 
for step in xrange(0, 201): 
    sess.run(train) 
    if step % 20 == 0: 
     print step, sess.run(W), sess.run(b) 

Answer 1

पुनरुत्पादित करता है वर्तमान में tf.train.GradientDescentOptimizer वर्ग केवल supports 32-बिट फ्लोटिंग प्वाइंट चर और नुकसान मूल्यों पर प्रशिक्षण।

हालांकि, ऐसा लगता है कि कर्नेल को डबल-परिशुद्धता मानों के लिए लागू किया गया है, इसलिए आपके परिदृश्य में ट्रेन करना संभव होना चाहिए।

class DoubleGDOptimizer(tf.train.GradientDescentOptimizer): 
    def _valid_dtypes(self): 
    return set([tf.float32, tf.float64]) 

... और फिर tf.train.GradientDescentOptimizer के स्थान पर DoubleGDOptimizer का उपयोग करें:

एक त्वरित समाधान का एक उपवर्ग कि tf.float64 मूल्यों के रूप में अच्छी तरह से समर्थन करता है परिभाषित करने के लिए किया जाएगा।

संपादित करें: आपको यह काम करने के लिए tf.constant(learning_rate, tf.float64) के रूप में सीखने की दर में प्रवेश करने की आवश्यकता होगी।

(नायब यह एक समर्थित इंटरफ़ेस नहीं है और यह भविष्य में बदलने के लिए विषय हो सकता है, लेकिन टीम डबल परिशुद्धता तैरता के अनुकूलन के लिए इच्छा के बारे में पता है, और एक में निर्मित समाधान प्रदान करना चाहता है।)