मिनिस्ट/सीफर ट्यूटोरियल को पूरा करने के बाद मैंने सोचा कि मैं डेटा का अपना 'बड़ा' सेट बनाकर और सादगी के लिए टेन्सफोर्लो के साथ प्रयोग करूंगा, मैं एक काले-सफेद पर बस गया अंडाकार आकार जो 28x28 पिक्सेल छवि के रूप में 0.0-1.0 स्केल पर अपनी ऊंचाई और चौड़ाई को स्वतंत्र रूप से बदलता है (जिसमें से मेरे पास 5000 प्रशिक्षण छवियां, 1000 परीक्षण छवियां हैं)।एकाधिक स्वतंत्र लेबलों के लिए लागत और सक्रियण फ़ंक्शन
मेरे कोड एक आधार (गति के लिए वापस बढ़ाया) के रूप में 'MNIST expert' ट्यूटोरियल का उपयोग करता है, लेकिन मैं here से सलाह के आधार पर एक चुकता त्रुटि आधारित लागत समारोह में बंद और, अंतिम सक्रियण परत के लिए एक अवग्रह समारोह में बदली, यह देखते हुए कि यह एक वर्गीकरण नहीं है बल्कि दो टेंसर, y_ और y_conv के बीच 'सर्वश्रेष्ठ फिट' है।
हालांकि 100k पुनरावृत्तियों के दौरान, हानि उत्पादन 400 से 900 (या इसके परिणामस्वरूप, 50 के बैच में 2 लेबलों से अधिक किसी दिए गए लेबल के 0.2-0.3) के बीच एक ओसिसेशन में जल्दी से निपटता है, इसलिए मुझे कल्पना है मुझे सिर्फ शोर मिल रहा है। शायद मैं गलत हूं लेकिन मैं उम्मीद कर रहा था कि छवियों को दृढ़ करने के लिए टेन्सफोर्लो का उपयोग करें ताकि 10 या अधिक स्वतंत्र लेबल किए गए चर को कम किया जा सके। क्या मैं यहाँ कुछ मौलिक याद कर रहा हूँ?
def train(images, labels):
# Import data
oval = blender_input_data.read_data_sets(images, labels)
sess = tf.InteractiveSession()
# Establish placeholders
x = tf.placeholder("float", shape=[None, 28, 28, 1])
tf.image_summary('images', x)
y_ = tf.placeholder("float", shape=[None, 2])
# Functions for Weight Initialization.
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)
# Functions for convolution and pooling
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
strides=[1, 2, 2, 1], padding='SAME')
# First Variables
W_conv1 = weight_variable([5, 5, 1, 16])
b_conv1 = bias_variable([16])
# First Convolutional Layer.
h_conv1 = tf.nn.relu(conv2d(x, W_conv1) + b_conv1)
h_pool1 = max_pool_2x2(h_conv1)
_ = tf.histogram_summary('weights 1', W_conv1)
_ = tf.histogram_summary('biases 1', b_conv1)
# Second Variables
W_conv2 = weight_variable([5, 5, 16, 32])
b_conv2 = bias_variable([32])
# Second Convolutional Layer
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
h_pool2 = max_pool_2x2(h_conv2)
_ = tf.histogram_summary('weights 2', W_conv2)
_ = tf.histogram_summary('biases 2', b_conv2)
# Fully connected Variables
W_fc1 = weight_variable([7 * 7 * 32, 512])
b_fc1 = bias_variable([512])
# Fully connected Layer
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*32])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1)+b_fc1)
_ = tf.histogram_summary('weights 3', W_fc1)
_ = tf.histogram_summary('biases 3', b_fc1)
# Drop out to reduce overfitting
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
# Readout layer with sigmoid activation function.
W_fc2 = weight_variable([512, 2])
b_fc2 = bias_variable([2])
with tf.name_scope('Wx_b'):
y_conv=tf.sigmoid(tf.matmul(h_fc1_drop, W_fc2)+b_fc2)
_ = tf.histogram_summary('weights 4', W_fc2)
_ = tf.histogram_summary('biases 4', b_fc2)
_ = tf.histogram_summary('y', y_conv)
# Loss with squared errors
with tf.name_scope('diff'):
error = tf.reduce_sum(tf.abs(tf.sub(y_,y_conv)))
diff = (error*error)
_ = tf.scalar_summary('diff', diff)
# Train
with tf.name_scope('train'):
train_step = tf.train.AdamOptimizer(1e-4).minimize(diff)
# Merge summaries and write them out.
merged = tf.merge_all_summaries()
writer = tf.train.SummaryWriter('/home/user/TBlogs/oval_logs', sess.graph_def)
# Add ops to save and restore all the variables.
saver = tf.train.Saver()
# Launch the session.
sess.run(tf.initialize_all_variables())
# Restore variables from disk.
saver.restore(sess, "/home/user/TBlogs/model.ckpt")
for i in range(100000):
batch = oval.train.next_batch(50)
t_batch = oval.test.next_batch(50)
if i%10 == 0:
feed = {x:t_batch[0], y_: t_batch[1], keep_prob: 1.0}
result = sess.run([merged, diff], feed_dict=feed)
summary_str = result[0]
df = result[1]
writer.add_summary(summary_str, i)
print('Difference:%s' % (df)
else:
feed = {x:batch[0], y_: batch[1], keep_prob: 0.5}
sess.run(train_step, feed_dict=feed)
if i%1000 == 0:
save_path = saver.save(sess, "/home/user/TBlogs/model.ckpt")
# Completion
print("Session Done")
मैं कैसे टेन्सर बोर्ड पता चलता है कि वजन मुश्किल से जो भी बदल रहे हैं लगता है पर सबसे अधिक चिंतित हूँ, घंटे और प्रशिक्षण के घंटे और एक खस्ताहाल सीखने दर (हालांकि नहीं कोड में दिखाया गया है) के बाद भी। मशीन सीखने की मेरी समझ यह है कि, छवियों को घुलनते समय, परतें प्रभावी रूप से किनारे का पता लगाने की परतों के बराबर होती हैं ..... इसलिए मैं उलझन में हूं कि उन्हें मुश्किल से क्यों बदलना चाहिए।
वर्तमान में मेरे सिद्धांत हैं:
1. मैंने हानि समारोह के बारे में कुछ अनदेखा/गलत समझा है।
2. मुझे गलत समझा गया है कि वजन कैसे शुरू किया गया है/अपडेट किया गया है
3. मैंने पूरी तरह से अनुमान लगाया है कि प्रक्रिया कितनी देर लेनी चाहिए ... हालांकि, फिर से, नुकसान बस लग रहा है।
किसी भी मदद की सराहना की जाएगी, धन्यवाद!