python - यह टेंसरफ्लो कार्यान्वयन Matlab के एनएन की तुलना में काफी कम सफल क्यों है?




1 Answers

मैंने 50000 पुनरावृत्तियों के लिए प्रशिक्षण की कोशिश की जो इसे 0.00012 त्रुटि मिली। टेस्ला के 40 में लगभग 180 सेकंड लगते हैं।

ऐसा लगता है कि इस तरह की समस्या के लिए, पहला ऑर्डर ग्रेडियेंट वंश एक अच्छा फिट नहीं है (पन इरादा), और आपको लेवेनबर्ग-मार्क्वर्ट या एल-बीएफजीएस की आवश्यकता है। मुझे नहीं लगता कि किसी ने उन्हें अभी तक टेंसरफ्लो में लागू किया है।

इस समस्या के लिए tf.train.AdamOptimizer(0.1) उपयोग करें संपादित करें। 4000 पुनरावृत्तियों के बाद यह 3.13729e-05 हो जाता है। साथ ही, डिफ़ॉल्ट रणनीति के साथ जीपीयू भी इस समस्या के लिए एक बुरा विचार लगता है। कई छोटे ऑपरेशन हैं और ओवरहेड जीपीयू संस्करण को मेरी मशीन पर सीपीयू की तुलना में 3x धीमी गति से चलाने का कारण बनता है।

एक खिलौना उदाहरण के रूप में मैं 100 नो-शोर डेटा पॉइंट्स से फ़ंक्शन f(x) = 1/x फिट करने की कोशिश कर रहा हूं। Matlab डिफ़ॉल्ट कार्यान्वयन औसत वर्ग अंतर ~ 10 ^ -10 के साथ असाधारण रूप से सफल है, और पूरी तरह से interpolates।

मैं 10 सिग्मोइड न्यूरॉन्स की एक छिपी परत के साथ एक तंत्रिका नेटवर्क को लागू करता हूं। मैं तंत्रिका नेटवर्क पर एक नौसिखिया हूं इसलिए गूंगा कोड के खिलाफ अपने गार्ड पर रहो।

import tensorflow as tf
import numpy as np

def weight_variable(shape):
  initial = tf.truncated_normal(shape, stddev=0.1)
  return tf.Variable(initial)

def bias_variable(shape):
  initial = tf.constant(0.1, shape=shape)
  return tf.Variable(initial)

#Can't make tensorflow consume ordinary lists unless they're parsed to ndarray
def toNd(lst):
    lgt = len(lst)
    x = np.zeros((1, lgt), dtype='float32')
    for i in range(0, lgt):
        x[0,i] = lst[i]
    return x

xBasic = np.linspace(0.2, 0.8, 101)
xTrain = toNd(xBasic)
yTrain = toNd(map(lambda x: 1/x, xBasic))

x = tf.placeholder("float", [1,None])
hiddenDim = 10

b = bias_variable([hiddenDim,1])
W = weight_variable([hiddenDim, 1])

b2 = bias_variable([1])
W2 = weight_variable([1, hiddenDim])

hidden = tf.nn.sigmoid(tf.matmul(W, x) + b)
y = tf.matmul(W2, hidden) + b2

# Minimize the squared errors.
loss = tf.reduce_mean(tf.square(y - yTrain))
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)

for step in xrange(0, 4001):
    train.run({x: xTrain}, sess)
    if step % 500 == 0:
        print loss.eval({x: xTrain}, sess)

मीन स्क्वायर अंतर ~ 2 * 10 ^ -3 पर समाप्त होता है, इसलिए मैटलैब की तुलना में परिमाण के लगभग 7 ऑर्डर खराब होते हैं। के साथ visualizing

xTest = np.linspace(0.2, 0.8, 1001)
yTest = y.eval({x:toNd(xTest)}, sess)  
import matplotlib.pyplot as plt
plt.plot(xTest,yTest.transpose().tolist())
plt.plot(xTest,map(lambda x: 1/x, xTest))
plt.show()

हम देख सकते हैं कि फिट व्यवस्थित रूप से अपूर्ण है: जबकि matlab एक समान रूप से मतभेदों के साथ नग्न आंखों के लिए सही दिखता है <10 ^ -5: मैंने मैटलैब नेटवर्क के आरेख को टेंसरफ्लो के साथ दोहराने की कोशिश की है:

संयोग से, चित्र सिग्मोइड सक्रियण समारोह के बजाय एक tanh का मतलब है। मुझे यह सुनिश्चित करने के लिए दस्तावेज़ में कहीं भी नहीं मिल रहा है। हालांकि, जब मैं टेंसरफ्लो में एक तनह न्यूरॉन का उपयोग करने की कोशिश करता हूं तो फिटिंग जल्दी से चर के लिए nan के साथ विफल रहता है। मुझे नहीं पता क्यों।

Matlab Levenberg-Marquardt प्रशिक्षण एल्गोरिदम का उपयोग करता है। Bayesian नियमितकरण 10 ^ -12 पर औसत वर्गों के साथ और भी सफल है (हम शायद फ्लोट अंकगणित के वाष्प के क्षेत्र में हैं)।

टेंसरफ्लो कार्यान्वयन इतना खराब क्यों है, और इसे बेहतर बनाने के लिए मैं क्या कर सकता हूं?




Related